From 8b4d1fd34c6b6eae31089156e6dbcbff6c8fd5cf Mon Sep 17 00:00:00 2001
From: NaveedMohiuddin <naveed.mohiuddin.1234@gmail.com>
Date: Thu, 21 Nov 2024 23:17:41 -0600
Subject: [PATCH 1/5] ML-Project2

---
 BoostingTrees/GradientBoostingTree.py | 117 ++++
 BoostingTrees/evaluate_model.ipynb    | 880 ++++++++++++++++++++++++++
 README.md                             | 132 +++-
 small_test.csv                        |  51 ++
 4 files changed, 1163 insertions(+), 17 deletions(-)
 create mode 100644 BoostingTrees/GradientBoostingTree.py
 create mode 100644 BoostingTrees/evaluate_model.ipynb
 create mode 100644 small_test.csv

diff --git a/BoostingTrees/GradientBoostingTree.py b/BoostingTrees/GradientBoostingTree.py
new file mode 100644
index 0000000..f9c0321
--- /dev/null
+++ b/BoostingTrees/GradientBoostingTree.py
@@ -0,0 +1,117 @@
+import numpy as np
+from sklearn.metrics import mean_squared_error
+
+
+class CustomGradientBoostingRegressor:
+    def __init__(self, n_estimators=100, learning_rate=0.1, max_depth=3, min_samples_split=2):
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.trees = []  # Stores individual decision trees
+        self.loss_history = []  # Tracks loss over iterations
+
+    def fit(self, X, y):
+        """
+        Fits the gradient boosting model.
+        """
+        # Initialize model with a constant value (mean of y)
+        self.initial_prediction = np.mean(y)
+        current_prediction = np.full_like(y, self.initial_prediction, dtype=float)
+
+        for estimator in range(self.n_estimators):
+            # Calculate residual errors
+            residuals = y - current_prediction
+
+            # Fit a regression tree to the residuals
+            tree = DecisionTreeRegressor(max_depth=self.max_depth, min_samples_split=self.min_samples_split)
+            tree.fit(X, residuals)
+            self.trees.append(tree)
+
+            # Update predictions
+            update = tree.predict(X)
+            current_prediction += self.learning_rate * update
+
+            # Track loss
+            loss = mean_squared_error(y, current_prediction)
+            self.loss_history.append(loss)
+
+            print(f"Iteration {estimator + 1}/{self.n_estimators}, Loss: {loss:.4f}")
+
+    def predict(self, X):
+        """
+        Predicts using the gradient boosting model.
+        """
+        current_prediction = np.full(X.shape[0], self.initial_prediction, dtype=float)
+        for tree in self.trees:
+            update = tree.predict(X)
+            current_prediction += self.learning_rate * update
+        return current_prediction
+
+class DecisionTreeRegressor:
+    def __init__(self, max_depth=3, min_samples_split=2):
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.tree = None
+
+    def fit(self, X, y):
+        self.tree = self._build_tree(X, y, depth=0)
+
+    def predict(self, X):
+        return np.array([self._predict_row(row, self.tree) for row in X])
+
+    def _build_tree(self, X, y, depth):
+        num_samples, num_features = X.shape
+        if depth >= self.max_depth or num_samples < self.min_samples_split or np.std(y) == 0:
+            return np.mean(y)
+
+        best_split = self._find_best_split(X, y, num_features)
+        if not best_split:
+            return np.mean(y)
+
+        left_indices = X[:, best_split["feature"]] < best_split["threshold"]
+        right_indices = ~left_indices
+
+        left_tree = self._build_tree(X[left_indices], y[left_indices], depth + 1)
+        right_tree = self._build_tree(X[right_indices], y[right_indices], depth + 1)
+
+        return {
+            "feature": best_split["feature"],
+            "threshold": best_split["threshold"],
+            "left": left_tree,
+            "right": right_tree
+        }
+
+    def _find_best_split(self, X, y, num_features):
+        best_split = {}
+        min_error = float("inf")
+
+        for feature in range(num_features):
+            thresholds = np.unique(X[:, feature])
+            for threshold in thresholds:
+                left_indices = X[:, feature] < threshold
+                right_indices = ~left_indices
+
+                if len(y[left_indices]) == 0 or len(y[right_indices]) == 0:
+                    continue
+
+                left_error = np.mean((y[left_indices] - np.mean(y[left_indices])) ** 2)
+                right_error = np.mean((y[right_indices] - np.mean(y[right_indices])) ** 2)
+                error = (len(y[left_indices]) * left_error + len(y[right_indices]) * right_error) / len(y)
+
+                if error < min_error:
+                    min_error = error
+                    best_split = {"feature": feature, "threshold": threshold}
+
+        return best_split if min_error < float("inf") else None
+
+    def _predict_row(self, row, tree):
+        if isinstance(tree, dict):
+            feature = tree["feature"]
+            threshold = tree["threshold"]
+            if row[feature] < threshold:
+                return self._predict_row(row, tree["left"])
+            else:
+                return self._predict_row(row, tree["right"])
+        else:
+            return tree
\ No newline at end of file
diff --git a/BoostingTrees/evaluate_model.ipynb b/BoostingTrees/evaluate_model.ipynb
new file mode 100644
index 0000000..ba72899
--- /dev/null
+++ b/BoostingTrees/evaluate_model.ipynb
@@ -0,0 +1,880 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.ensemble import GradientBoostingRegressor\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "from GradientBoostingTree import CustomGradientBoostingRegressor  # Import the custom model\n",
+    "\n",
+    "# Multiple types of data generating functions\n",
+    "def generate_linear_data(n_samples=100, noise=0.1):\n",
+    "    X = np.random.rand(n_samples, 1) * 10\n",
+    "    y = 5 * X.squeeze() + np.random.randn(n_samples) * noise\n",
+    "    return X, y\n",
+    "\n",
+    "def handle_missing_data(X):\n",
+    "    X = pd.DataFrame(X)\n",
+    "    X = X.fillna(X.mean())\n",
+    "    return X.values\n",
+    "\n",
+    "def generate_polynomial_data(n_samples=100, noise=0.1):\n",
+    "    X = np.random.rand(n_samples, 1) * 10\n",
+    "    y = 0.5 * X.squeeze()**2 + 3 * X.squeeze() + np.random.randn(n_samples) * noise\n",
+    "    return X, y\n",
+    "\n",
+    "def generate_noisy_data(n_samples=100, noise=5):\n",
+    "    X = np.random.rand(n_samples, 1) * 10\n",
+    "    y = 2 * X.squeeze() + 3 + np.random.randn(n_samples) * noise\n",
+    "    return X, y\n",
+    "\n",
+    "def generate_missing_data(n_samples=100):\n",
+    "    X = np.random.rand(n_samples, 1) * 10\n",
+    "    y = 3 * X.squeeze() + 7\n",
+    "    X[np.random.choice(n_samples, size=10), 0] = np.nan  # Introduce NaNs\n",
+    "    return X, y\n",
+    "\n",
+    "# Custom train-test split function\n",
+    "def custom_train_test_split(X, y, test_size=0.2, random_state=None):\n",
+    "    if random_state is not None:\n",
+    "        np.random.seed(random_state)\n",
+    "    n_samples = X.shape[0]\n",
+    "    indices = np.arange(n_samples)\n",
+    "    np.random.shuffle(indices)\n",
+    "\n",
+    "    split_index = int(n_samples * (1 - test_size))\n",
+    "    train_indices = indices[:split_index]\n",
+    "    test_indices = indices[split_index:]\n",
+    "\n",
+    "    X_train, X_test = X[train_indices], X[test_indices]\n",
+    "    y_train, y_test = y[train_indices], y[test_indices]\n",
+    "\n",
+    "    return X_train, X_test, y_train, y_test\n",
+    "\n",
+    "\n",
+    "#Method for evaluating both custom and SK learn models\n",
+    "def evaluate_model(custom_model, sklearn_model, X_test, y_test):\n",
+    "    # Custom model predictions\n",
+    "    y_pred_custom = custom_model.predict(X_test)\n",
+    "    mse_custom = mean_squared_error(y_test, y_pred_custom)\n",
+    "    r2_custom = r2_score(y_test, y_pred_custom)\n",
+    "\n",
+    "    # Sklearn model predictions\n",
+    "    y_pred_sklearn = sklearn_model.predict(X_test)\n",
+    "    mse_sklearn = mean_squared_error(y_test, y_pred_sklearn)\n",
+    "    r2_sklearn = r2_score(y_test, y_pred_sklearn)\n",
+    "\n",
+    "    # Scatter plots for comparison\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "\n",
+    "    # Custom model plot\n",
+    "    plt.subplot(1, 2, 1)\n",
+    "    plt.scatter(y_test, y_pred_custom, color='blue', alpha=0.7, label='Custom Predictions')\n",
+    "    plt.plot(y_test, y_test, color='black', linestyle='--', label='Ideal Line (y=x)')\n",
+    "    plt.title(\"Custom Model: True vs Predicted\")\n",
+    "    plt.xlabel(\"True Values\")\n",
+    "    plt.ylabel(\"Predicted Values\")\n",
+    "    plt.legend()\n",
+    "    plt.grid()\n",
+    "\n",
+    "    # Sklearn model plot\n",
+    "    plt.subplot(1, 2, 2)\n",
+    "    plt.scatter(y_test, y_pred_sklearn, color='green', alpha=0.7, label='Sklearn Predictions')\n",
+    "    plt.plot(y_test, y_test, color='black', linestyle='--', label='Ideal Line (y=x)')\n",
+    "    plt.title(\"Sklearn Model: True vs Predicted\")\n",
+    "    plt.xlabel(\"True Values\")\n",
+    "    plt.ylabel(\"Predicted Values\")\n",
+    "    plt.legend()\n",
+    "    plt.grid()\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "    # Results\n",
+    "    print(\"\\nCustom Model Performance:\")\n",
+    "    print(f\"Mean Squared Error: {mse_custom:.4f}\")\n",
+    "    print(f\"R-Squared: {r2_custom:.4f}\")\n",
+    "\n",
+    "    print(\"\\nSklearn Model Performance:\")\n",
+    "    print(f\"Mean Squared Error: {mse_sklearn:.4f}\")\n",
+    "    print(f\"R-Squared: {r2_sklearn:.4f}\")\n",
+    "\n",
+    "    # Residuals Plot for Custom Model\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.scatter(X_test, y_test - custom_model.predict(X_test), color=\"red\", alpha=0.6, label=\"Custom Model Residuals\")\n",
+    "    plt.axhline(0, color=\"black\", linestyle=\"--\")\n",
+    "    plt.title(\"Residuals Plot - Custom Model\")\n",
+    "    plt.xlabel(\"Feature X (Test Data)\")\n",
+    "    plt.ylabel(\"Residuals (True - Predicted)\")\n",
+    "    plt.legend()\n",
+    "    plt.grid()\n",
+    "    plt.show()\n",
+    "\n",
+    "    # Residuals Plot for Sklearn Model\n",
+    "    plt.figure(figsize=(12, 6))\n",
+    "    plt.scatter(X_test, y_test - sklearn_model.predict(X_test), color=\"purple\", alpha=0.6, label=\"Sklearn Model Residuals\")\n",
+    "    plt.axhline(0, color=\"black\", linestyle=\"--\")\n",
+    "    plt.title(\"Residuals Plot - Sklearn Model\")\n",
+    "    plt.xlabel(\"Feature X (Test Data)\")\n",
+    "    plt.ylabel(\"Residuals (True - Predicted)\")\n",
+    "    plt.legend()\n",
+    "    plt.grid()\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "    # Combined summary comparison\n",
+    "    print(\"Analysis:\")\n",
+    "    if mse_custom < mse_sklearn and r2_custom > r2_sklearn:\n",
+    "        print(\"The custom model performed better!\")\n",
+    "    elif mse_sklearn < mse_custom and r2_sklearn > r2_custom:\n",
+    "        print(\"The Scikit-learn model performed better!\")\n",
+    "    else:\n",
+    "        print(\"Both models performed similarly with slight differences.\")\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test-1 \n",
+    "- Testing both the custom and SKlearn model on Generated data and comparing the it's evaluations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 1/100, Loss: 153.8706\n",
+      "Iteration 2/100, Loss: 125.5954\n",
+      "Iteration 3/100, Loss: 102.5517\n",
+      "Iteration 4/100, Loss: 83.8278\n",
+      "Iteration 5/100, Loss: 68.5453\n",
+      "Iteration 6/100, Loss: 56.1805\n",
+      "Iteration 7/100, Loss: 46.0846\n",
+      "Iteration 8/100, Loss: 37.9147\n",
+      "Iteration 9/100, Loss: 31.2559\n",
+      "Iteration 10/100, Loss: 25.8514\n",
+      "Iteration 11/100, Loss: 21.4720\n",
+      "Iteration 12/100, Loss: 17.8970\n",
+      "Iteration 13/100, Loss: 14.9824\n",
+      "Iteration 14/100, Loss: 12.6188\n",
+      "Iteration 15/100, Loss: 10.6983\n",
+      "Iteration 16/100, Loss: 9.1259\n",
+      "Iteration 17/100, Loss: 7.8571\n",
+      "Iteration 18/100, Loss: 6.8158\n",
+      "Iteration 19/100, Loss: 5.9717\n",
+      "Iteration 20/100, Loss: 5.2845\n",
+      "Iteration 21/100, Loss: 4.7216\n",
+      "Iteration 22/100, Loss: 4.2636\n",
+      "Iteration 23/100, Loss: 3.8894\n",
+      "Iteration 24/100, Loss: 3.5838\n",
+      "Iteration 25/100, Loss: 3.3302\n",
+      "Iteration 26/100, Loss: 3.1255\n",
+      "Iteration 27/100, Loss: 2.9496\n",
+      "Iteration 28/100, Loss: 2.8052\n",
+      "Iteration 29/100, Loss: 2.6796\n",
+      "Iteration 30/100, Loss: 2.5598\n",
+      "Iteration 31/100, Loss: 2.4748\n",
+      "Iteration 32/100, Loss: 2.3750\n",
+      "Iteration 33/100, Loss: 2.3048\n",
+      "Iteration 34/100, Loss: 2.2361\n",
+      "Iteration 35/100, Loss: 2.1861\n",
+      "Iteration 36/100, Loss: 2.1348\n",
+      "Iteration 37/100, Loss: 2.0884\n",
+      "Iteration 38/100, Loss: 2.0460\n",
+      "Iteration 39/100, Loss: 1.9860\n",
+      "Iteration 40/100, Loss: 1.9370\n",
+      "Iteration 41/100, Loss: 1.9041\n",
+      "Iteration 42/100, Loss: 1.8706\n",
+      "Iteration 43/100, Loss: 1.8410\n",
+      "Iteration 44/100, Loss: 1.8194\n",
+      "Iteration 45/100, Loss: 1.7805\n",
+      "Iteration 46/100, Loss: 1.7565\n",
+      "Iteration 47/100, Loss: 1.7287\n",
+      "Iteration 48/100, Loss: 1.6938\n",
+      "Iteration 49/100, Loss: 1.6761\n",
+      "Iteration 50/100, Loss: 1.6541\n",
+      "Iteration 51/100, Loss: 1.6302\n",
+      "Iteration 52/100, Loss: 1.6113\n",
+      "Iteration 53/100, Loss: 1.5954\n",
+      "Iteration 54/100, Loss: 1.5759\n",
+      "Iteration 55/100, Loss: 1.5624\n",
+      "Iteration 56/100, Loss: 1.5362\n",
+      "Iteration 57/100, Loss: 1.5195\n",
+      "Iteration 58/100, Loss: 1.5038\n",
+      "Iteration 59/100, Loss: 1.4894\n",
+      "Iteration 60/100, Loss: 1.4822\n",
+      "Iteration 61/100, Loss: 1.4693\n",
+      "Iteration 62/100, Loss: 1.4499\n",
+      "Iteration 63/100, Loss: 1.4325\n",
+      "Iteration 64/100, Loss: 1.4206\n",
+      "Iteration 65/100, Loss: 1.4022\n",
+      "Iteration 66/100, Loss: 1.3889\n",
+      "Iteration 67/100, Loss: 1.3803\n",
+      "Iteration 68/100, Loss: 1.3673\n",
+      "Iteration 69/100, Loss: 1.3522\n",
+      "Iteration 70/100, Loss: 1.3419\n",
+      "Iteration 71/100, Loss: 1.3355\n",
+      "Iteration 72/100, Loss: 1.3182\n",
+      "Iteration 73/100, Loss: 1.2947\n",
+      "Iteration 74/100, Loss: 1.2896\n",
+      "Iteration 75/100, Loss: 1.2767\n",
+      "Iteration 76/100, Loss: 1.2684\n",
+      "Iteration 77/100, Loss: 1.2644\n",
+      "Iteration 78/100, Loss: 1.2539\n",
+      "Iteration 79/100, Loss: 1.2471\n",
+      "Iteration 80/100, Loss: 1.2439\n",
+      "Iteration 81/100, Loss: 1.2190\n",
+      "Iteration 82/100, Loss: 1.2037\n",
+      "Iteration 83/100, Loss: 1.2010\n",
+      "Iteration 84/100, Loss: 1.1927\n",
+      "Iteration 85/100, Loss: 1.1860\n",
+      "Iteration 86/100, Loss: 1.1791\n",
+      "Iteration 87/100, Loss: 1.1770\n",
+      "Iteration 88/100, Loss: 1.1632\n",
+      "Iteration 89/100, Loss: 1.1532\n",
+      "Iteration 90/100, Loss: 1.1420\n",
+      "Iteration 91/100, Loss: 1.1279\n",
+      "Iteration 92/100, Loss: 1.1225\n",
+      "Iteration 93/100, Loss: 1.1192\n",
+      "Iteration 94/100, Loss: 1.1101\n",
+      "Iteration 95/100, Loss: 1.1021\n",
+      "Iteration 96/100, Loss: 1.0968\n",
+      "Iteration 97/100, Loss: 1.0894\n",
+      "Iteration 98/100, Loss: 1.0827\n",
+      "Iteration 99/100, Loss: 1.0735\n",
+      "Iteration 100/100, Loss: 1.0672\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Custom Model Performance:\n",
+      "Mean Squared Error: 7.4155\n",
+      "R-Squared: 0.9662\n",
+      "\n",
+      "Sklearn Model Performance:\n",
+      "Mean Squared Error: 6.5688\n",
+      "R-Squared: 0.9700\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+cAAAIjCAYAAABh8GqqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8p0lEQVR4nO3deVxU9f7H8feA7AKmaC6YG5qQhgjZTcsst2y1bsvNyuW2Z6tZab9yKzVbbTXbTCtv3bLttnj1ZrZaGaJW4oIpirgRNigIAnN+f5xmdGRxBgbOMLyejwePYb7nO2c+M5w5zOd8N5thGIYAAAAAAIBlgqwOAAAAAACAxo7kHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHADQoEyZMkU2m82jujabTVOmTKnTeAYMGKABAwbU6XMcrT5eFxqurVu3ymaz6fXXX/f6scuXL5fNZtPy5ct9HhcAoHok5wCAGnn99ddls9lcP02aNFG7du00evRo7dixw+rwGhxnQuX8CQ4O1gknnKCLL75Yq1ev9slzrFu3TlOmTNHWrVt9sr/KbN68WTfeeKM6d+6s8PBwxcTEqF+/fnr66ad18ODBOnnOhQsXavbs2XWy79pwXkgKCgrS9u3bK2wvKChQRESEbDabbr31VgsiBAD4E5JzAECtTJs2TW+88YZefPFFDRs2TG+++abOPPNMFRcX18nzPfDAA3WW5PmDK6+8Um+88YZee+01jRgxQsuWLdPf/vY3nyTo69at09SpU+ssOf/000/Vs2dP/fvf/9YFF1ygZ599VjNnztQJJ5yge+65R3fccUedPK+/JudOYWFh+te//lWh/P3337cgGgCAv2pidQAAgIZt2LBhSktLkyRdd911iouL06xZs/Txxx/r8ssv9/nzNWnSRE2aBO6/r969e+vqq6923e/Xr58uvPBCzZkzR3PnzrUwsupt2bJF//jHP9ShQwctW7ZMbdq0cW0bO3assrKy9Omnn1oYoXXOPfdc/etf/9K9997rVr5w4UKdd955WrRokUWRAQD8CS3nAACfOuOMMySZ3ZuPtH79el166aVq3ry5wsPDlZaWpo8//titTmlpqaZOnaquXbsqPDxcLVq00Omnn66lS5e66lQ25rykpER33XWXWrZsqejoaF144YXKycmpENvo0aPVsWPHCuWV7XPevHk6++yz1apVK4WFhSkpKUlz5szx6D149tlnddJJJykyMlLHHXec0tLStHDhQo8ee7Szzz5bkpn8VicjI0PDhg1TTEyMmjZtqoEDB+qHH35wbX/99dd12WWXSZLOOussV/d5X40tfvTRR3XgwAG9+uqrbom5U0JCgqvlvLox0UePp9+/f7/uvPNOdezYUWFhYWrVqpUGDx6sVatWSTLH/H/66afKzs52vaYj/8Z79uzRtddeq+OPP17h4eFKTk7W/Pnz3Z7TGc/jjz+u559/Xp07d1ZkZKSGDBmi7du3yzAMPfTQQ4qPj1dERIQuuugi5efne/zejBgxQqtXr9b69etdZbt27dKyZcs0YsSISh/jSdyS9Oeff2r06NGKjY1Vs2bNNGrUKP3555+V7tOTzyAAwDqB2/QAALCEs8v0cccd5yr77bff1K9fP7Vr104TJkxQVFSU/v3vf2v48OFatGiRLr74Yklmkjxz5kxdd9116tOnjwoKCvTzzz9r1apVGjx4cJXPed111+nNN9/UiBEj1LdvXy1btkznnXderV7HnDlzdNJJJ+nCCy9UkyZN9J///Ee33HKLHA6Hxo4dW+XjXn75Zd1+++269NJLdccdd6i4uFhr167Vjz/+WGUiVh3nRY4WLVpUWee3337TGWecoZiYGN17770KCQnR3LlzNWDAAH311Vc69dRT1b9/f91+++165plndP/99ysxMVGSXLe19Z///EedO3dW3759fbI/p5tuuknvvfeebr31ViUlJemPP/7Qt99+q8zMTPXu3Vv/93//J7vdrpycHD311FOSpKZNm0qSDh48qAEDBigrK0u33nqrOnXqpHfffVejR4/Wn3/+WaGb/VtvvaVDhw7ptttuU35+vh599FFdfvnlOvvss7V8+XLdd999ysrK0rPPPqvx48frtdde8+g19O/fX/Hx8Vq4cKGmTZsmSXrnnXfUtGnTSo9TT+M2DEMXXXSRvv32W910001KTEzUBx98oFGjRlXYp6efQQCAhQwAAGpg3rx5hiTjf//7n7F3715j+/btxnvvvWe0bNnSCAsLM7Zv3+6qO3DgQKNnz55GcXGxq8zhcBh9+/Y1unbt6ipLTk42zjvvvGqfd/LkycaR/75Wr15tSDJuueUWt3ojRowwJBmTJ092lY0aNcro0KHDMfdpGIZRVFRUod7QoUONzp07u5WdeeaZxplnnum6f9FFFxknnXRSta+hMlu2bDEkGVOnTjX27t1r7Nq1y1i+fLmRkpJiSDIWLVrkqnv06xo+fLgRGhpqbN682VWWm5trREdHG/3793eVvfvuu4Yk48svv/Q6vurY7XZDknHRRRd5VN/5WufNm1dh29GvLTY21hg7dmy1+zvvvPMq/bvOnj3bkGS8+eabrrJDhw4Zp512mtG0aVOjoKDALZ6WLVsaf/75p6vuxIkTDUlGcnKyUVpa6iq/8sorjdDQULfjuTLO42rv3r3G+PHjjYSEBNe2U045xRgzZozrNR/5Gj2N+8MPPzQkGY8++qirXllZmXHGGWdUeH89/Qx++eWXdXKMAACOjW7tAIBaGTRokFq2bKn27dvr0ksvVVRUlD7++GPFx8dLkvLz87Vs2TJdfvnl2r9/v/Ly8pSXl6c//vhDQ4cO1aZNm1yzuzdr1ky//fabNm3a5PHzf/bZZ5Kk22+/3a38zjvvrNXrioiIcP1ut9uVl5enM888U7///rvsdnuVj2vWrJlycnK0cuXKGj3v5MmT1bJlS7Vu3VoDBgzQ5s2bNWvWLF1yySWV1i8vL9eSJUs0fPhwde7c2VXepk0bjRgxQt9++60KCgpqFIunnPuPjo72+b6bNWumH3/8Ubm5uV4/9rPPPlPr1q115ZVXuspCQkJ0++2368CBA/rqq6/c6l922WWKjY113T/11FMlSVdffbXbPAennnqqDh065NWqBCNGjFBWVpZWrlzpuq2qJ4WncX/22Wdq0qSJbr75Zle94OBg3XbbbW778+YzCACwDt3aAQC18vzzz6tbt26y2+167bXX9PXXXyssLMy1PSsrS4Zh6MEHH9SDDz5Y6T727Nmjdu3aadq0abrooovUrVs39ejRQ+ecc46uueYanXzyyVU+f3Z2toKCgtSlSxe38hNPPLFWr+u7777T5MmTtWLFChUVFblts9vtbkncke677z7973//U58+fZSQkKAhQ4ZoxIgR6tevn0fPe8MNN+iyyy5TUFCQmjVrppNOOsnt/Tza3r17VVRUVOnrTUxMlMPh0Pbt23XSSSd59PxOBw8erHARonXr1pXWjYmJkWSOD/e1Rx99VKNGjVL79u2Vmpqqc889VyNHjnS7EFGV7Oxsde3aVUFB7m0Rzq782dnZbuUnnHCC233n37h9+/aVlu/bt8/j15GSkqLu3btr4cKFatasmVq3bu2aT6CmcWdnZ6tNmzaubvxORx8L3nwGAQDWITkHANRKnz59XLO1Dx8+XKeffrpGjBihDRs2qGnTpnI4HJKk8ePHa+jQoZXuIyEhQZI5Nnfz5s366KOPtGTJEr3yyit66qmn9OKLL+q6666rdaxHT/rmVF5e7nZ/8+bNGjhwoLp3764nn3xS7du3V2hoqD777DM99dRTrtdUmcTERG3YsEGffPKJFi9erEWLFumFF17QpEmTNHXq1GPG2LVrVw0aNMi7F1YH3nnnHY0ZM8atzDCMSuvGxMSobdu2+vXXXz3at6d/B0m6/PLLdcYZZ+iDDz7QkiVL9Nhjj2nWrFl6//33NWzYMI+ez1PBwcFelVf1flRlxIgRmjNnjqKjo3XFFVdUSL7rijefQQCAdUjOAQA+ExwcrJkzZ+qss87Sc889pwkTJrhaOENCQjxKOps3b64xY8ZozJgxOnDggPr3768pU6ZUmZx36NBBDodDmzdvdmsx3LBhQ4W6xx13XKUzWR/dgvqf//xHJSUl+vjjj91aU7/88stjxi9JUVFRuuKKK3TFFVfo0KFDuuSSSzR9+nRNnDhR4eHhHu3DUy1btlRkZGSlr3f9+vUKCgpytfxWlRRXZujQoW6z5B/L+eefr5deekkrVqzQaaedVm1d52SBR/8tjv47OLVp00a33HKLbrnlFu3Zs0e9e/fW9OnTXcl5Va+rQ4cOWrt2rRwOh1si7Jw1vUOHDh69Nl8ZMWKEJk2apJ07d+qNN96osp6ncXfo0EFffPGFDhw44NZ6fvSx4O1nEABgDcacAwB8asCAAerTp49mz56t4uJitWrVSgMGDNDcuXO1c+fOCvX37t3r+v2PP/5w29a0aVMlJCSopKSkyudzJmjPPPOMW/ns2bMr1O3SpYvsdrvWrl3rKtu5c6c++OADt3rOltIjW0btdrvmzZtXZRxVvYbQ0FAlJSXJMAyVlpYe8/HeCg4O1pAhQ/TRRx+5ZsqXpN27d2vhwoU6/fTTXd3Oo6KiJFVMiivTpk0bDRo0yO2nOvfee6+ioqJ03XXXaffu3RW2b968WU8//bQks6U9Li5OX3/9tVudF154we1+eXl5ha71rVq1Utu2bd2OiaioqErnATj33HO1a9cuvfPOO66ysrIyPfvss2ratKnOPPPMal+Tr3Xp0kWzZ8/WzJkz1adPnyrreRr3ueeeq7KyMrcl/srLy/Xss8+67c+bzyAAwDq0nAMAfO6ee+7RZZddptdff1033XSTnn/+eZ1++unq2bOnrr/+enXu3Fm7d+/WihUrlJOTozVr1kiSkpKSNGDAAKWmpqp58+b6+eefXctoVaVXr1668sor9cILL8hut6tv37764osvlJWVVaHuP/7xD9133326+OKLdfvtt6uoqEhz5sxRt27dXOtmS9KQIUMUGhqqCy64QDfeeKMOHDigl19+Wa1atao0uTnSkCFD1Lp1a/Xr10/HH3+8MjMz9dxzz+m8886rkwnTJOnhhx/W0qVLdfrpp+uWW25RkyZNNHfuXJWUlOjRRx911evVq5eCg4M1a9Ys2e12hYWFudZyr60uXbpo4cKFuuKKK5SYmKiRI0eqR48eOnTokL7//nvXUmBO1113nR555BFdd911SktL09dff62NGze67XP//v2Kj4/XpZdequTkZDVt2lT/+9//tHLlSj3xxBOueqmpqXrnnXc0btw4nXLKKWratKkuuOAC3XDDDZo7d65Gjx6t9PR0dezYUe+9956+++47zZ49u87+HtU5evm2ynga9wUXXKB+/fppwoQJ2rp1q5KSkvT+++9XeqHC088gAMBCVk4VDwBouJxLqa1cubLCtvLycqNLly5Gly5djLKyMsMwDGPz5s3GyJEjjdatWxshISFGu3btjPPPP9947733XI97+OGHjT59+hjNmjUzIiIijO7duxvTp083Dh065KpT2bJnBw8eNG6//XajRYsWRlRUlHHBBRcY27dvr7Asl2EYxpIlS4wePXoYoaGhxoknnmi8+eable7z448/Nk4++WQjPDzc6NixozFr1izjtddeMyQZW7ZscdU7eim1uXPnGv379zdatGhhhIWFGV26dDHuuecew263V/t+Opfzeuyxx6qtZxgVlxszDMNYtWqVMXToUKNp06ZGZGSkcdZZZxnff/99hce+/PLLRufOnY3g4OA6WTJr48aNxvXXX2907NjRCA0NNaKjo41+/foZzz77rNsyXkVFRca1115rxMbGGtHR0cbll19u7Nmzx+21lZSUGPfcc4+RnJxsREdHG1FRUUZycrLxwgsvuD3ngQMHjBEjRhjNmjUzJLktq7Z7925jzJgxRlxcnBEaGmr07NmzwhJuVb33zmXF3n33Xbfy6o79Ix25lFp1dNRSap7GbRiG8ccffxjXXHONERMTY8TGxhrXXHONkZGRUelSdZ58BllKDQCsYzMML2czAQAAAAAAPsWYcwAAAAAALEZyDgAAAACAxUjOAQAAAACwGMk5AAAAAAAWIzkHAAAAAMBiJOcAAAAAAFisidUB1CeHw6Hc3FxFR0fLZrNZHQ4AAAAAIMAZhqH9+/erbdu2Cgqqun28USXnubm5at++vdVhAAAAAAAame3btys+Pr7K7Y0qOY+OjpZkvikxMTEWR2MqLS3VkiVLNGTIEIWEhFgdDlBrHNMINBzTCDQc0wg0HNPwdwUFBWrfvr0rH61Ko0rOnV3ZY2Ji/Co5j4yMVExMDCcTBASOaQQajmkEGo5pBBqOaTQUxxpazYRwAAAAAABYjOQcAAAAAACLkZwDAAAAAGAxknMAAAAAACxGcg4AAAAAgMVIzgEAAAAAsBjJOQAAAAAAFiM5BwAAAADAYiTnAAAAAABYjOQcAAAAAACLkZwDAAAAAGAxknMAAAAAACxGcg4AAAAAgMWaWB0AAAAAAABecTikrCzJbpdiY6WEBCmoYbc9k5wDAAAAABqOjAxp/nwpM1MqLpbCw6XERGnUKCklxeroaozkHAAAAADQMGRkSNOmSXl5Uny8FBUlFRZK6elSdrY0aVKDTdAbbLv/I488IpvNpjvvvNPqUAAAAAAAdc3hMFvM8/LMlvKYGCk42LxNTDTLFyww6zVADTI5X7lypebOnauTTz7Z6lAAAAAAAPUhK8vsyh4fL9ls7ttsNrN83TqzXgPU4JLzAwcO6KqrrtLLL7+s4447zupwAAAAAAD1wW43x5hHRVW+PTLS3G63129cPtLgxpyPHTtW5513ngYNGqSHH3642rolJSUqKSlx3S8oKJAklZaWqrS0tE7j9JQzDn+JB6gtjmkEGo5pBBqOaQQajulGpGlTKTpaKikxu7IfrajI3N60qeRHx4Onx6bNMAyjjmPxmbffflvTp0/XypUrFR4ergEDBqhXr16aPXt2pfWnTJmiqVOnVihfuHChIiMj6zhaAAAAAEBjV1RUpBEjRshutyumsosKf2kwyfn27duVlpampUuXusaaHys5r6zlvH379srLy6v2TalPpaWlWrp0qQYPHqyQkBCrw0FDs3attHChtGGDeQUxLEw68URpxAjJojkZOKYRaDimEWg4phFoOKZryeGQfv9dKigwW6M7d/bv9cLXrpVmzZL++ENq29bsyl5UJOXmSi1aSPfdZ9n34KoUFBQoLi7umMl5g+nWnp6erj179qh3796usvLycn399dd67rnnVFJSouDgYLfHhIWFKSwsrMK+QkJC/O6D648xwc9lZEgPP3x4GYnWrc1lJH76yTzBWryMBMc0Ag3HNAINxzQCDcd0DTTE9cJTU6WJEyvGffLJ0siRfhm3p8dlg0nOBw4cqF9++cWtbMyYMerevbvuu+++Cok5ENCOXkbCOVulcxmJzExzGYnkZP++8gkAAABrNOT1wlNSzO+5WVnm5G+xsVJCQoP/3ttgkvPo6Gj16NHDrSwqKkotWrSoUA4EPG+WkejWzZoYAQAA4J8CoaEnKCjgvuf66TsNoFoBvowEAAAA6lCArxfeUDWYlvPKLF++3OoQAGvExppjawoLq15GIjzcrAcAAAAcyZOGntxcGnrqGS3nQEOUkGB2OcrJkY5ecMEwzPKkJLMeAAAAcKQjG3oqQ0OPJUjOAX/gcEgbN0orV5q3Dkf19YOCzFk04+LMLkkFBVJZmXmbmWmWjxzpv2OEAAAAYB0aevxSg+7WDgSEmi5hkZJizqLpfGxurvnYtDS/XUYCAAAAfsDZ0JOdfXjsuXO98JwcGnosQnIOWKm2S1gE6DISAAAggDkcfHfxBzT0+B2Sc8AqvlrCIgCXkQAAAAGqpj0GUTdo6PErJOeAVVirHAAANCa17TGIukFDj9/gkghgFdYqBwAAjcXRPQZjYqTg4MM9BvPyzB6Dx5oUFwhgJOeAVVjCAgAANBbe9BgEGimSc8AqLGEBAAAaC3oMAsdEcg5YhbXKAQBAY0GPQeCY+NYPWMm5hEVqqpSfb3blys83l7BgUhQAABAo6DEIHBOztQNW83YJC9YGBQAADY2zx2B29uGx55GRZot5Tg49BgGRnAP+wdMlLFgbFAAANFTOHoPO7zK5ueZ3mbQ0MzHnuwwaOZJzoKFgbVAAANDQedtjEGhESM6BhuDotUGdS5A41wbNzDTXBk1O5p8bAADwb572GAQaGb7FAw0Ba4MCAAAAAY3kHGgIWBsUAAAACGgk50BDwNqgAAAAQEAjOQcaAtYGBQAAjZ3DIW3cKK1cad46HFZHBPgUE8IBDQFrgwIAgMasuuVke/SwOjrAJ0jOgYaCtUEBAEBjdKzlZB94wOoIAZ8gOQcaEtYGBQAAjYkny8n+61/SGWdYGyfgAyTnQEPD2qAAAKCx8GQ52fXrSc4REGhuAwAAAOCfPFlOtqSkfmMC6gjJOQAAAAD/5MlysmFh9RsTUEdIzgEAAAD4J0+Wk+3e3ZrYAB8jOQcAAADgn5zLycbFmWPPCwqksjLzNjPTLL/ySqujBHyC5BwAAACA/3IuJ5uaKuXnm5PE5eeby8lOmiSdfLLVEQI+wWztAAAAAPxbdcvJlpZaHR3gEyTnAAAAAPwfy8kiwNGtHQAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYs7UDAAB4w+GofDknAABqgeQcAADAUxkZ0vz5UmamVFwshYdLiYnSqFHmOswAANQQyTkAAIAnMjKkadOkvDwpPl6KipIKC6X0dCk7W5o0iQQdAFBj9MECAAA4FofDbDHPyzNbymNipOBg8zYx0SxfsMCsBwBADZCcAwAAHEtWltmVPT5estnct9lsZvm6dWY9AABqgOQcAADgWOx2c4x5VFTl2yMjze12e/3GBQAIGCTnAAAAxxIba07+VlhY+faiInN7bGz9xgUACBgk5wAAAMeSkGCOLc/JkQzDfZthmOVJSWY9AABqgOQcAADgWIKCzOXS4uLMsecFBVJZmXmbmWmWjxzJeucAgBrjPwgAAIAnUlLM5dJSU6X8fHPyt/x8KS2NZdQAALXGOucAAACeSkmRkpPNxNxuN8eYJyTQYg4AqDWScwAAAG8EBUndulkdBQAgwHCZFwAAAAAAi5GcAwAAAABgMZJzAAAAAAAsxphzAADQcDgcTMYGAAhIJOcAAKBhyMiQ5s831xUvLpbCw6XERHP9cZYxAwA0cCTnAADA/2VkSNOmSXl5Uny8FBUlFRZK6elSdjbrjKPhojcIgL+QnAMAAP/mcJgt5nl5Zku5zWaWx8SY9zMzpQULzPXHSWrQkNAbBMAR+A8GAAD8W1aWmbzExx9OzJ1sNrN83TqzHtBQOHuDpKdLzZtLXbuat+npZnlGhtURAqhnJOcAAMC/2e1mq2JUVOXbIyPN7XZ7/cYF1NTRvUFiYqTg4MO9QfLyzN4gDofVkQKoRyTnAADAv8XGmt19Cwsr315UZG6Pja3fuICaojcIgEqQnAMAAP+WkGC2JubkSIbhvs0wzPKkJLPesTgc0saN0sqV5i0tk7ACvUEAVIIJ4QAAgH8LCjInyMrOPtzaGBlptpjn5EhxcdLIkceeDI7Jt+AvjuwNEhNTcTu9QYBGiZZzAADg/1JSzOXSUlOl/Hyzu29+vpSW5tkyaky+BX/iy94gAAIGLecAAKBhSEkxl0vzdk1olmKDv/FVbxAAAYXkHAAANBxBQVK3bt49xpvJt7zdN1BTzt4gzqEWublmV/a0NDMxZ6gF0OiQnAMAgMDmyeRbublMvoX6V9PeIAACEsk5AAAIbEy+BX9Wk94gAAISl+UAAEBgY/ItAEADQHIOAAACm3Pyrbg4c2xvQYFUVmbeZmYy+RYAwC/wXwgAAAS+2i7FBgBAHWPMOQAAaByYfAsA4McazH+jmTNn6pRTTlF0dLRatWql4cOHa8OGDVaHBfg/h0PauFFaudK8dTisjggArOOcfOuUU8xbEnMAgJ9oMC3nX331lcaOHatTTjlFZWVluv/++zVkyBCtW7dOUVUtjQI0dhkZh9dPLS42ZyNOTDTHXtKFEwAAAPAbDSY5X7x4sdv9119/Xa1atVJ6err69+9f6WNKSkpUUlLiul9QUCBJKi0tVWlpad0F6wVnHP4SDwLI2rXSrFnSH39Ibdua6/sWFkq//CLNnCndd5908sk+f1qOaQQajmkEGo5pBBqOafg7T49Nm2EcvaZIw5CVlaWuXbvql19+UY8ePSqtM2XKFE2dOrVC+cKFCxUZGVnXIQIAAAAAGrmioiKNGDFCdrtdMTExVdZrkMm5w+HQhRdeqD///FPffvttlfUqazlv37698vLyqn1T6lNpaamWLl2qwYMHKyQkxOpw/J/DIf3+u7n8TUyM1Lkz4wUrk5Ul3XOPdNxx5vt0tIICad8+6bHHfL6uL8c0Ag3HNAINxzQCDcc0/F1BQYHi4uKOmZw3mG7tRxo7dqx+/fXXahNzSQoLC1NYWFiF8pCQEL/74PpjTH6H8dOeO3BA2r9fat3aXMv3aKGh5vYDB6Q6Ou44phFoOKYRaDimEWg4puGvPD0uG1xyfuutt+qTTz7R119/rfj4eKvDQX3JyJCmTZPy8qT4+MPjp9PTpexs1qg9WmysefGisLDylvOiInN7bGz9xwYAAACgggbTH9gwDN1666364IMPtGzZMnXq1MnqkFBfHA6zxTwvz2wpj4mRgoPN28REs3zBApYIO1JCgvne5ORIR49cMQyzPCnJ513aAQAAANRMg0nOx44dqzfffFMLFy5UdHS0du3apV27dungwYNWh4a6lpVldmWPj5dsNvdtNptZvm6dWQ+moCCzu39cnPneFRSY3dsLCsz7cXHSyJGM1wcAAAD8RIP5Zj5nzhzZ7XYNGDBAbdq0cf288847VoeGuma3m2PMq1rPPjLS3G63129c/i4lxezun5oq5eebFy/y86W0NIYBAAAAAH6mwYw5b4CTysNXGD9dcykpUnKymZjb7eZ7lJDQeFvMHQ7eCwAAAPilBpOcoxFzjp9OTzdvj+za7hw/nZbG+OmqBAVJ3bpZHYX1mO0fAAAAfozkHP7POX46O/vw2PPISLPFPCeH8dM4Nmb7BwAAgJ8jm0HDwPhp1BSz/QMAAKABoOUcDQfjp1ET3sz2T/d/AAAAWITkHA0L46fhLU9m+8/NZbZ/AAAAWIomRwCB7cjZ/ivDbP8AAADwAyTnAAKbc7b/nBxzdv8jOWf7T0pitn8AAABYim7tAAIbs/1XxHrvAAAAfofkHEDgc87271znPDfX7MqelmYm5o1ptn/WewcAoOHiAntAIzkH0Dgw2z/rvQMA0JBxgT3gkZwDaDwa82z/R6/37lxWzrnee2amud57cnLjumABAEBDwAX2RoFvYADQGHiz3jsAwHsOh7Rxo7RypXnrcFgdEQLF0RfYY2Kk4ODDF9jz8swL7BxzDR4t5wDQGLDeOwDUHboboy55c4G9sfYQDBC0nANAY8B67wBQN5zdjdPTpebNpa5dzdv0dLM8I8PqCNHQeXKBvbiYC+wBgOQcABoD1nsHAN+juzHqAxfYGw2ScwBoDJzrvcfFmV3jCgqksjLzNjOzca73DgC1xXweqA9cYG80+BYGAI2Fc7331FQpP9/8spifb673ziyvAOA9uhujPnCBvdFgQjgAaExY7x0AfOfI7sYxMRW3090YvuK8wO6ceDA31zy20tLMxJwL7AGB5BwAGpvGvN47APiSs7txerp5e2TXdmd347Q0uhvDN7jAHvBIzgEAAICacHY3zs4+PPY8MtJsMc/JobsxfI8L7AGNMwUAAABQU8znAcBHaDkHAAAAaoPuxgB8gOQcAAAAqC26GwOoJS7nAQAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGI1Wkpt27Ztys7OVlFRkVq2bKmTTjpJYWFhvo4NAAAAAIBGwePkfOvWrZozZ47efvtt5eTkyDAM17bQ0FCdccYZuuGGG/T3v/9dQUE0yAMAAAAA4CmPsujbb79dycnJ2rJlix5++GGtW7dOdrtdhw4d0q5du/TZZ5/p9NNP16RJk3TyySdr5cqVdR03AAAAAAABw6OW86ioKP3+++9q0aJFhW2tWrXS2WefrbPPPluTJ0/W4sWLtX37dp1yyik+DxYAAAAAgEDkUXI+c+ZMj3d4zjnn1DgYAAAAAAAaoxpNCIdGxuGQsrIku12KjZUSEiTmFQAAAAAAn/EoOU9JSZHNZvNoh6tWrapVQPAzGRnS/PlSZqZUXCyFh0uJidKoUVJKitXRAQAAAEBA8Cg5Hz58uOv34uJivfDCC0pKStJpp50mSfrhhx/022+/6ZZbbqmTIGGRjAxp2jQpL0+Kj5eioqTCQik9XcrOliZNIkEHAAAAAB/wKDmfPHmy6/frrrtOt99+ux566KEKdbZv3+7b6GAdh8NsMc/LM1vKnT0nYmLM+5mZ0oIFUnIyXdwBAAAAoJa8zqreffddjRw5skL51VdfrUWLFvkkKPiBrCwzAY+PP5yYO9lsZvm6dWY9AAAAAECteJ2cR0RE6LvvvqtQ/t133yk8PNwnQcEP2O3mGPOoqMq3R0aa2+32+o0LAAAAAAKQ17O133nnnbr55pu1atUq9enTR5L0448/6rXXXtODDz7o8wBhkdhYc/K3wkKzK/vRiorM7bGx9R8bAAAAAAQYr5PzCRMmqHPnznr66af15ptvSpISExM1b948XX755T4PEBZJSDDHlqenu485lyTDkHJypLQ0sx4AAAAAoFZqtM755ZdfTiIe6IKCzOXSsrMPjz2PjDRbzHNypLg4aeRIJoMDAAAAAB+oUWb1559/6pVXXtH999+v/Px8Seb65jt27PBpcLBYSoq5XFpqqpSfb07+lp9vtpizjBoAAAAA+IzXLedr167VoEGDFBsbq61bt+q6665T8+bN9f7772vbtm1asGBBXcQJq6SkmMulZWWZk7/Fxppd2WkxBwAAAACf8TrDGjdunEaPHq1Nmza5zc5+7rnn6uuvv/ZpcPATQUFSt27SKaeYtyTmAAAAAOBTXrecr1y5UnPnzq1Q3q5dO+3atcsnQQEAgEbK4aC3FgCgUfI6OQ8LC1NBQUGF8o0bN6ply5Y+CQoAADRCGRnS/PnmRKTFxeaSnYmJ5gSlzHMCAAhwXl+KvvDCCzVt2jSVlpZKkmw2m7Zt26b77rtPf//7330eIAAAaAQyMqRp08wlPJs3l7p2NW/T083yjAyrIwQAoE55nZw/8cQTOnDggFq1aqWDBw/qzDPPVEJCgqKjozV9+vS6iBEAAAQyh8NsMc/LM1vKY2Kk4GDzNjHRLF+wwKwHAP7C4ZA2bpRWrjRvOUehlrzu1h4bG6ulS5fqu+++05o1a3TgwAH17t1bgwYNqov4AABAoMvKMruyx8dLNpv7NpvNLF+3zqzXrZs1MQLAkRiGgzrgdXK+YMECXXHFFerXr5/69evnKj906JDefvttjRw50qcBAgCAAGe3m19uo6Iq3x4ZKeXmmvUAwGrOYTh5eebFw6goqbDQHIaTnS1NmkSCjhrxulv7mDFjZK/kn+P+/fs1ZswYnwQFAAAakdhYs9WpsLDy7UVF5vbY2PqNCwCOxjAc1CGvk3PDMGQ7usuZpJycHMXyTxNoWBgrBcAfJCSYX2pzciTDcN9mGGZ5UpJZDwCs5M0wHMBLHndrT0lJkc1mk81m08CBA9WkyeGHlpeXa8uWLTrnnHPqJEgAdYCxUgD8RVCQee7Jzj78pTcy0mwxz8mR4uKkkSNZ7xyA9RiGgzrkcXI+fPhwSdLq1as1dOhQNW3a1LUtNDRUHTt2ZCk1oKFgrBQAf5OSYp57nBcNc3PNi4ZpaWZizjkJgD84chhOTEzF7QzDQS14nJxPnjxZktSxY0f94x//UFhYWJ0FBaAOHT1WytklyzlWKjPTHCuVnEwrFYD6lZJinnuyssxWp9hYsys75yIA/sI5DCc93f17lHR4GE5aGsNwUCNe/7dLSkrS6tWrK5T/+OOP+vnnn30RE4C6xFgpAP4sKMhcLu2UU8xbEnMA/sQ5DCcuzvw+VVAglZWZt5mZDMNBrXh91IwdO1bbt2+vUL5jxw6NHTvWJ0EBqEOejJUqLmasFAAAQGWcw3BSU6X8fLNBIz/fbDFnaCBqwet1ztetW6fevXtXKE9JSdG6det8EhSAOsRYKQAAgNphGA7qgNdHT1hYmHbv3l2hfOfOnW4zuAPwUyxZBAAAUHsMw4GPeX0EDRkyRBMnTpT9iC6vf/75p+6//34NHjzYp8GhHrDOdePDWCkAAADA73jd1P3444+rf//+6tChg1L+Gk+xevVqHX/88XrjjTd8HiDqEOtcN14sWQQAAAD4Fa+T83bt2mnt2rV66623tGbNGkVERGjMmDG68sorFRISUhcxoi6wzjUYKwUAAAD4jRoNEo+KitINN9zg61hQX1jnGk7OsVIAAAAALOVRcv7xxx9r2LBhCgkJ0ccff1xt3QsvvNAngaEOebPONYkbAACoTw4HvboANEoeJefDhw/Xrl271KpVKw0fPrzKejabTeXl5b6KDXXFk3Wuc3OtXeeaf8wAADQ+zIcDoBHzKDl3HDGDt8Pi2byff/55PfbYY9q1a5eSk5P17LPPqk+fPpbG1OD4+zrX/GMGAKDxYT4cAI1cg2qKfOeddzRu3DhNnjxZq1atUnJysoYOHao9e/ZYHVrD4s/rXDv/MaenS82bS127mrfp6WZ5Rkb9xwQAAOrW0fPhxMRIwcGH58PJyzPnw2HJVwABzKOW82eeecbjHd5+++01DuZYnnzySV1//fUaM2aMJOnFF1/Up59+qtdee00TJkzweD+FhYUKDg6uUB4cHKzw8HC3elUJCgpSREREjeoWFRXJ+CspLi0tVXFxsQoLCxUSEiKbzabIyMhK6x7t6LoHDx6stmdDlLMbe1CQDl5xhRybN0u//iq1aydFREgHD0o7dkgtWijqiHWui4uLqx2uEHVE9/hj1Y2MjJTtr3HuJSUlKisrO7zR4ZBeeUXavVs68URF/vV+KCZGJd26qSwzU3r1VWnmzApd3CMiIhT0V9mhQ4dUWlpaZQze1A0PD3cdK97ULS0t1aFDh6qsGxYWpiZNmnhdt6ysTCUlJVXWDQ0Nda2a4E3d8vJyFRcXV1k3JCREoaGhHtU9ksPh0MGDBz3a77HqNmnSRGFhYZIkwzBUVFTkk7refO6tOEccrV7OEV7WrbdzRC3q1uYcUVRU5HaePhLnCJM35whvPvecIyqvW9tzhPO7R1FRkWKP6CVn6Tnir/lwitu0UXlln+XWraW1axW5aZNsJ54oyX/OEXyP8J9zRGXnaSfOESa+R9Ssbm3PEdX9/dwYHujYsaPbT1RUlGGz2YzjjjvOOO644wybzWZERUUZnTp18mR3NVJSUmIEBwcbH3zwgVv5yJEjjQsvvLDSxxQXFxt2u931s337dkNSlT/Dhg0zDh065PqJjIyssm7//v3d6sbFxVVZNzU11a1uhw4dqqybmJjoVjcxMbHKuh06dHCrm5qaWmXduLg4t7r9+/evsm5keLhb3WHDhlX7vh1Z95JLLqm27r59+1x1r7nmmmrr7hgzxjh0yy3GoVtuMW7q0aPauhs3bnTtd9y4cdXWzcjIcNV94IEHqq37/fffu+rOnDmz2rpLly511X366aerrfvhhx+66r7yyivV1l24cKGr7sKFC6ut+8orr7jqfvjhh9XWffrpp111ly5dWm3dmTNnuup+//331da9//77jQ8//NAoLCw0MjIyqq07btw41343btxYbd2bbrrJVXfHjh3V1r3mmmtcdfft21dt3UsuucTtGK6uLucI8ycyMtI/zhE7drjq3nTTTdXW5Rxh/vjDOeKBBx5w1eUcYe054oQTTvCfc8QPPxiHBg0yLuncudq6+778knOEOEc4f5zniMLCQmPu3LnV1uUcYf7wPeLwjxXnCLvdXm3O61HL+ZYtW1y/L1y4UC+88IJeffVVnfjXlcsNGzbo+uuv14033ujJ7mokLy9P5eXlOv74493Kjz/+eK1fv77Sx8ycOVNTp071+Dn27Nmjzz77zHW/uqsyf/zxh1vdQ9VcsbTb7W51q7v6duDAAbe6Bw4cqLJuUVGRW117NRO4HTp0yK3uH3/8UWXdcsNwq3usYQNH1t21a1e1df/73/+6rhjm5ORUW/d/Awa4ruhnb9litvJX4csvv3QdG7///nu1+/3mm2+UnZ0tSdq0aVO1db/77jvX66/qOHP64YcfXFfFfvvtt2rr/vzzz67f16xZU23djIwM11XLjGN061+zZo3r73Hkc1Tmt99+c9X95Zdfqq27fv16V91jvWebN29Wnz59tHTpUm3btq3aur///rtrv7t37662bnZ2tqtudce6ZB5bzrrHauXftWuX2zFcHc4RpvLycv84R/zvf4fPEX99pqvCOeLwvqw+R2zatMlVl3OEteeIgwcP+tc54tZbtevRR6VqPqP/3b1b4X/V5xxh4hzh2eeTc4SJ7xGH+cM54mg2w6iiH0MVunTpovfee08pR03IkZ6erksvvdQtkfel3NxctWvXTt9//71OO+00V/m9996rr776Sj/++GOFx5SUlLh1xykoKFD79u2VnZ2tmEomQrOqW/uyZct09tln11+3di/r1ltXk82bpf/7P+m446ToaEU2aXK4bnm5yux2ad8+afp0qUsXt/3SHc3kD93RJOmrr77S4MGDFRwcTJfVGtSlO5p/dUcrKipyO08fiXOEiW7t3te1ulv7smXLNHDgQP/p1u5wSPffr+L0dJV37eq+1KthSJs2ScnJipw1S7a/Pkf+co7ge4T154jS0lL997//1emnn063dvE9wt++R5SWlqqgoEAdOnSQ3W6vNA918qjl/Eg7d+6sNPDy8vJjXtWujbi4OAUHB1d4jt27d6t169aVPiYsLMz1wTpSs2bNqn1TjqznKW/qHvmPsLS0VOHh4WrWrFmlJ5PYqmZMr2SpsRAPXpNTVScuS+umpEjdu5uTvyUmSkd88EKcE9WlpZn1qllWzV9e25EnM1/WPfLk68u6R/6zqE1d58kqJCREISEhlX4Gq+JNXec/bl/XravPfU3PEb6s6y+fjYZWNzQ0tNrzdE3321jPEUfjHOF93dqeI5zfPWJjY92OW8s/c1dfrZDff5fWrzdna4+MNFeQycmR4uKk0aPNFVz8Jd46rss5wuTp5z4oKOiY5+kjcY7wvq6/fDYaYt2ganKXI3k9W/vAgQN14403atWqVa6y9PR03XzzzRo0aJC3u/NYaGioUlNT9cUXX7jKHA6HvvjiC7eW9EYhI0MaN0667TZp/Hjzdty4hj+TeVCQuVxaXJy5jFpBgVRWZt5mZprlR0xUBwAAAkhKirlcWmqqlJ9vNkLk55sX5llGDUAj4HXL+WuvvaZRo0YpLS3NrdvL0KFD9corr/g8wCONGzfO9dx9+vTR7NmzVVhY6Jq9vVEI9DVAnf+Yneuc5+aaV8nT0szEvCG/NgAAUL2UFCk5uULvQC7MA2gMvE7OW7Zsqc8++0wbN250TWzRvXt3devWzefBHe2KK67Q3r17NWnSJO3atUu9evXS4sWLK0wSF7COXgPUOR7LuQZoZqa5BmhycsP+J8Y/ZgAAGq+gIKkevlcCgL/xOjl36tixowzDUJcuXVyTTNSHW2+9Vbfeemu9PZ9f+WsNUMXHu0+UIpn34+OldevMeg39nxr/mAEAAAA0Il43RRYVFenaa69VZGSkTjrpJNcSB7fddpseeeQRnweII9jtUnGx2ZW9MpGR5vZjLA8BAAD8iMMhbdworVxp3lYzwzEAIHB5nZxPnDhRa9as0fLly91mWhw0aJDeeecdnwaHo8TGmuOvq1pKoajI3O7FrIsAAMBCgTrJKwDAa14n5x9++KGee+45nX766a514STppJNO0ubNm30aHI6SkGCOLc/JMdf8PJJzqbGkJLMeAADwb85JXtPTpebNpa5dzdv0dLOcBB0AGhWvk/O9e/eqVatWFcoLCwvdknXUAZYaAwAgMBw9yWtMjBQcfHiS17w8c5JXurgDQKPhdRaXlpamTz/91HXfmZC/8sorjW+9cSuwBigAAA2fN5O8AgAaBa+nWZ8xY4aGDRumdevWqaysTE8//bTWrVun77//Xl999VVdxIijsdQYAH/hcHAuAmrCk0lec3OZ5BUAGhGvk/PTTz9da9as0cyZM9WzZ08tWbJEvXv31ooVK9SzZ8+6iBGVYakxAFbLyDC75WZmmklGeLjZHXfUKHrxAMdy5CSvMTEVtzPJKwA0Ol4l56Wlpbrxxhv14IMP6uWXX66rmAAA/s45kVVentn9NirKTDLS06XsbIbZAMfinOQ1Pd28PbJru3OS17Q0JnkFgEbEq76HISEhWrRoUV3FAgBoCJjICqg9JnkFABzF6zP+8OHD9eGHH9ZBKACABoGJrADfYJJXAMARvB5z3rVrV02bNk3fffedUlNTFXXURCa33367z4IDAPghJrICfIdJXgEAf/E6OX/11VfVrFkzpaenKz093W2bzWYjOQeAQMdEVoBvMckrAEA1SM63bNlSF3EAABoKJrICAKDxYNnUeuNVcv7DDz/oP//5jw4dOqSBAwfqnHPOqau4AAD+yjmRVXb24bHnkZFmi3lODhNZAQAQKFg2tV55nJy/9957uuKKKxQREaGQkBA9+eSTmjVrlsaPH1+X8QEA/JFzIivnP+zcXPMfdlqamZjzDxsAgIaNZVPrncfJ+cyZM3X99dfr+eefV3BwsGbOnKkZM2aQnANAY8VEVgAABKajl011DmFzLpuamWkum5qczP99H/L4ndywYYPGjx+v4OBgSdLdd9+t/fv3a8+ePXUWHADAzzknsjrlFPOWf9AAADR8LJtqCY+/RRUVFSnmiFl5Q0NDFR4ergMHDtRJYAAAAAAAC3iybGpxMcum+phXE8K98soratq0qet+WVmZXn/9dcXFxbnKWEoNAAA0SsxoDCBQsGyqJTxOzk844QS9/PLLbmWtW7fWG2+84brPOucAAKBRYkZjAIGEZVMt4XFyvnXr1joMAwAAoIFiRmMAgYZlUy3BuwkAAFBTR89oHBMjBQcfntE4L8+c0djhsDpSAPCOc9nU1FQpP98ctpOfb7aYc9GxTng15hwAAABH8GZG427drIkRAGqKZVPrFck5AABATXkyo3FuLjMaA2i4nMumos5xyQMAAKCmjpzRuDLMaAwA8BDJOQAA/sjhkDZulFauNG8Zs+yfnDMa5+SYMxgfyTmjcVISMxoDAI6pVt3azzvvPL3yyitq06aNr+IBAAAsy9VwMKMxAMBHapWcf/311zp48KCvYgEAACzL1fA4ZzR2XlDJzTUvqKSlmYk5fy8AgAeYEA4AAH9x9LJcztm/nctyZWaay3IlJ9MS62+Y0RgAUEu1Ss47dOigkJAQX8UCyfxixj92AGicWJarYWNGY+vw/QlAAKhVcv7rr7/6Kg5IjDEEgMaOZbkA7/H9CUCAoFu7v1i7Vnr4YcYYAkBjduSyXDExFbezLBfgjjkaAAQQ+vv4i4ULD48xjImRgoMPjzHMyzPHGLKMDgAENpblAjx39BwNfH8C0MCRnPuLDRs8G2MIAAhczmW54uLMLroFBVJZmXmbmcmyXMCRvJmjAQAaAP67+4uSkurHGBYXM8YQABoD57JcqalSfr6ZWOTnm8ty0UUXOMyTORr4/gSgAanRmPOysjItX75cmzdv1ogRIxQdHa3c3FzFxMSoadOmvo6xcQgLY4whAMDEslzAsTFHA4AA43Vynp2drXPOOUfbtm1TSUmJBg8erOjoaM2aNUslJSV68cUX6yLOwHfiidJPP7mvaysdHmOYlsYYQwBoTFiWC6iec46G9HS+PwEICF5fgr/jjjuUlpamffv2KSIiwlV+8cUX64svvvBpcI3KiBGMMQQAAPAUczQACDBet5x/8803+v777xUaGupW3rFjR+3YscNngTU6J59sjiV0rtOZm2t2xUpLM/+xMMYQAADAnXOOBr4/AQgAXifnDodD5eXlFcpzcnIUHR3tk6AaLcYY1p7DwfsHAEBjwvcnAAHC6+R8yJAhmj17tl566SVJks1m04EDBzR58mSde+65Pg+w0WGMYc1lZBy+cl5cbF45T0w0u7xx5RwAgMDF9ycAAcDr5PyJJ57Q0KFDlZSUpOLiYo0YMUKbNm1SXFyc/vWvf9VFjMCxZWRI06ZJeXnmuqZRUebsrenpUnY2yw8BAAAA8GteJ+fx8fFas2aN3n77ba1du1YHDhzQtddeq6uuusptgjig3jgcZot5Xp77bK0xMeb9zExpwQKzyxtd3AAAAAD4oRqtc96kSRNdffXVvo4FqJmsLDMBj493X0ZFMu/Hx0vr1pn16PIGAAAAwA95nZwvWLCg2u0jR46scTBAjdjt5hjzqKjKt0dGmrO32u31GxcAAAAAeMjr5PyOO+5wu19aWqqioiKFhoYqMjKS5Bz1LzbWnPytsNDsyn60oiJze2xs/ccGAAAAAB7wegDuvn373H4OHDigDRs26PTTT2dCOFgjIcEcW56TIxmG+zbDMMuTksx6AAAAAOCHfDI7VteuXfXII49UaFUH6kVQkLlcWlycOfa8oEAqKzNvMzPN8pEjmQwOAAAAgN+q0YRwle6oSRPl5ub6aneA5xwOc7z53/8uLV0q7dxpjjEPD5fS0szEnGXUAAAAAPgxr5Pzjz/+2O2+YRjauXOnnnvuOfXr189ngQEeycgwl1HLzDQnhQsLk9q0kQYPlvr0Mbuy02IOAAAAwM95nZwPHz7c7b7NZlPLli119tln64knnvBVXPAXDoe5BJndbk6o5k/JbkaGNG2aub55fLzZel5YKP3+u7RokXTSSf4TKwAAAABUw+vk3OFw1EUc8EdHt0qHh5sTr40aJSUnW5u0OxxmbHl5ZkzO9c1jYsz7mZnSggVmnCToAAAAAPycV8l5aWmpunfvrk8++USJiYl1FRP8QVWt0unp0po1ZtfxP/6omLTX19jurCwzAY+PP5yYO9lsZvm6ddLGjWZy7o8t/wAAAADwF6+S85CQEBUXF9dVLPAX1bVKt2wpffWVmfSecYbUtOnhpD07W5o0qX4SdLvdvDAQFVX59shIM8apU6X8fOsuIgAAAACAB7xuQhw7dqxmzZqlsrKyuogH/qCqVmnDkDZtMlueneXBwYe7kuflmV3J62PoQ2ysmWwXFla+fccOaft2M97mzaWuXc3b9HSzR0BGRt3HCAAAAAAe8rjlfNu2bYqPj9fKlSv1xRdfaMmSJerZs6eijmq5fP/9930eJOpZVa3Sdrv0559SdLR08KB06NDhbUd2Jc/Kkrp1q9sYExLMCwLp6e6t+5J5ceCXX6SQELOF3NmNnfHoAAAAAPyUx8l5p06dtHPnTjVr1kx///vf6zImWO3IVumYmMPlhw5JZWVSaKjUpIl5e6TISHN9cbu97mMMCjK7p2dnH27lj4yUiorM1vLSUql374rJd31fRAAAAAAAD3icnBuGIUmaN29enQUDP1FVq3RoqNmNvaBAat3aPXGXzMQ4PNxM7utDSoo5xt05o3xurvn8XbuaXfDj4yt/XH1eRAAAAAAAD3g1IZzt6FmxEZiqapW22cyk1+EwE+Cjx6Pn5EhpaWZyX19SUiou6+ZwSHfcUbHl36m+LyIAAAAAwDF4lZw/+OCDioyMrLbOk08+WauA4CeqapUeMMD8fe9eKSzscFfynBwpLk4aObL+x3EHBbl3T3c4qh6PbtVFBAAAAACohlfJ+S+//KLQo8cZH4GW9QBTWat0QoK5zvnRSXtampmY+8MSZdWNR7fyIgIAAAAAVMGr5PyDDz5Qq1at6ioW+KOjW6WlqpN2f0p2q2r596eLCAAAAADwF4+Tc1rF4aaypN3fNISLCAAAAACgGszWDjQoDeEiAgAAAIBGz+MmxHnz5imW2a0BAAAAAPA5j5LzH374QaNGjVJYWNgx6xYVFem3336rdWAAAAAAADQWHiXn11xzjYYOHap3331XhYWFldZZt26d7r//fnXp0kXp6ek+DRIAAAAAgEDm0ZjzdevWac6cOXrggQc0YsQIdevWTW3btlV4eLj27dun9evX68CBA7r44ou1ZMkS9ezZs67jBgAAAAAgYHjUch4SEqLbb79dGzZs0IoVK3T99derR48eateunQYMGKC5c+cqNzdX//rXv+okMd+6dauuvfZaderUSREREerSpYsmT56sQ4cO+fy5AAAAAACob16tcy5JaWlpSktLq4tYqrR+/Xo5HA7NnTtXCQkJ+vXXX3X99dersLBQjz/+eL3GAgAAAACAr3mdnFvhnHPO0TnnnOO637lzZ23YsEFz5swhOQeAxsbhkLKyJLtdio2VEhLMZRMBAAAasAaRnFfGbrerefPm1dYpKSlRSUmJ635BQYEkqbS0VKWlpXUan6eccXgcj8Mh/f67VFAgxcRInTvzpRR+xetjGvDG2rXSwoXShg1SSYkUFiadeKI0YoR08sl18pQc0wg0HNMINBzT8HeeHps2wzCMOo7F57KyspSamqrHH39c119/fZX1pkyZoqlTp1YoX7hwoSIjI+syRAAAAAAAVFRUpBEjRshutysmJqbKepYm5xMmTNCsWbOqrZOZmanu3bu77u/YsUNnnnmmBgwYoFdeeaXax1bWct6+fXvl5eVV+6bUp9LSUi1dulSDBw9WSEhI1RXXrpVmzZL++ENq21aKipIKC6XcXKlFC+m+++qs1QjwhsfHNOANh0O6/35p9WqzpdxmO7zNMMyW9JQUafp0n/cm4phGoOGYRqDhmIa/KygoUFxc3DGTc590a//zzz/VrFkzrx939913a/To0dXW6dy5s+v33NxcnXXWWerbt69eeumlY+4/LCxMYWFhFcpDQkL87oNbbUwOh/TGG9LOnVJiovml1DCkyEipSxcpM1N6803piSfo4g6/4Y+fMzRgGzdKv/4qtWollZdX3N6qlfTLL1J2ttStW52EwDGNQMMxjUDDMQ1/5elx6XVyPmvWLHXs2FFXXHGFJOnyyy/XokWL1Lp1a3322WdKTk72eF8tW7ZUy5YtPaq7Y8cOnXXWWUpNTdW8efMU1JiS0KwsMwGPj3dvLZLM+/Hx0rp1Zr06+lIKAJay26XiYrPXUGUiIqT8fGnFCvM+k8QBAIAGxutvLi+++KLat28vSVq6dKmWLl2qzz//XMOGDdM999zj8wAlMzEfMGCATjjhBD3++OPau3evdu3apV27dtXJ8/mdY30pjYw0t9vt9RsXANSX2FgpPNwcznO0vDzpu++kLVuk556TbrtNGjdOysio/zgBAABqyOuW8127drmS808++USXX365hgwZoo4dO+rUU0/1eYCSeREgKytLWVlZio+Pd9vWAOez896RX0orG6NQVGRuj42t/9gAoD4kJJjDetLTDw/vkczEPD3dbDVv08ace6OoyCzLzpYmTTLHogMAAPg5r1vOjzvuOG3fvl2StHjxYg0aNEiSmSSXVzYO0AdGjx4twzAq/WkUnF9Kc3LMseZHMgyzPCnJrAcAgSgoSBo1SoqLM4f5FBRIpaXmOPT8fKl5c6lHD6lJE/MiZmKimbgvWGDO2wEAAODnvE7OL7nkEo0YMUKDBw/WH3/8oWHDhkmSMjIylEByWDcq+1JaVmbeZmaa5SNHMr4SQGBLSTFbwlNTzYT8l1/MFSzatDHL4uIO1z16Pg4AAAA/53W39qeeekodO3bU9u3b9eijj6pp06aSpJ07d+qWW27xeYD4i/NL6fz5ZkKem2t2ZU9LMxNzum0CaAxSUqTkZDPhXrHCHGN+8slmi/nRIiPNcyXzcQAAgAbA6+Q8JCRE48ePr1B+1113+SQgVOPIL6V2uznGnBmJATQ2QUGHV6ZYuNAcY858HAAAoIHzKDn/+OOPPd7hhRdeWONg4IEjv5QCQGNW1SRx0uH5ONLSmI8DAAA0CB4l58OHD/doZzabrc4mhQMAwI1zPo7sbHO4T3y82ZW9qMhMzJmPAwAANCAeJecOZroFAPgj5uMAAAABwusx5wAA+BXm4wAAAAGgRsl5YWGhvvrqK23btk2HDh1y23b77bf7JDAAADzGfBwAAKCB8zo5z8jI0LnnnquioiIVFhaqefPmysvLU2RkpFq1akVyDgAAAACAl7zu83fXXXfpggsu0L59+xQREaEffvhB2dnZSk1N1eOPP14XMQIAAAA4msMhbdworVxp3jJPFNCged1yvnr1as2dO1dBQUEKDg5WSUmJOnfurEcffVSjRo3SJZdcUhdxAgAAAHDKyDg8GWZxsTkZZmKiuYoFk2ECDZLXLechISEK+muSnVatWmnbtm2SpNjYWG3fvt230QEAAABwl5EhTZsmpadLzZtLXbuat+npZnlGhtURAqgBr1vOU1JStHLlSnXt2lVnnnmmJk2apLy8PL3xxhvq0aNHXcQIAAAAQDK7rs+fL+XlmS3lNptZHhNj3s/MlBYsMFexYNUKoEHx+hM7Y8YMtWnTRpI0ffp0HXfccbr55pu1d+9evfTSSz4PEAAAAMBfsrLMBDw+/nBi7mSzmeXr1pn1ADQoXrecp6WluX5v1aqVFi9e7NOAAAAAAFTBbjfHmEdFVb49MlLKzTXrAWhQ6OsCAAAANBSxsebkb4WFlW8vKjK3x8bWb1wAas3rlvNOnTrJdnQXmiP8/vvvtQoIAAAAQBUSEsyx5enp7mPOJckwpJwcKS3NrAegQfE6Ob/zzjvd7peWliojI0OLFy/WPffc46u4AAAAABwtKMhcLi07+/DY88hIs8U8J0eKi5NGjmQyOKAB8jo5v+OOOyotf/755/Xzzz/XOiAAAAAA1UhJkSZNOrzOeW6u2ZU9Lc1MzFnnHGiQvE7OqzJs2DBNnDhR8+bN89UuYQWHw5zd0243xyolJHDlFQAAwN+kpJjLpfG9DQgYPkvO33vvPTVv3txXu4MVMjIOX4EtLjavwCYmml2nuAILAADgX4KCpG7drI4CgI94nZynpKS4TQhnGIZ27dqlvXv36oUXXvBpcKhHGRnStGlSXp45dikqypwFND3dHNM0aRIJOgAAAADUEa+T8+HDh7vdDwoKUsuWLTVgwAB1797dV3GhPjkcZot5Xp77rJ8xMeb9zExpwQKz6xRdpQAAAADA57xOzidPnlwXccBKWVmHZ/s8epk8m80sX7fOrEfXKQAAAADwOY+S84KCAo93GBMTU+NgYBG73RxjHhVV+fbISHMWULu9fuMCAADWYIJYAKh3HiXnzZo1cxtnXp3y8vJaBQQLxMaak78VFppd2Y9WVGRuj42t/9gAAED9YoJYALCER8n5l19+6fp969atmjBhgkaPHq3TTjtNkrRixQrNnz9fM2fOrJsoUbcSEsx/uunp7mPOJckwpJwcc93MhATrYgQAAHWPCWIBwDIeJednnnmm6/dp06bpySef1JVXXukqu/DCC9WzZ0+99NJLGjVqlO+jRN0KCjKvhmdnHx57Hhlptpjn5EhxcdLIkXRnAwAgkDFBLABYyusz64oVK5SWllahPC0tTT/99JNPgoIFUlLMq+GpqVJ+vjnOLD/fbDHnKjkAAIHPmwliAQA+5/Vs7e3bt9fLL7+sRx991K38lVdeUfv27X0WGCyQkmJeDWcCGAAAGh8miAUAS3mdnD/11FP6+9//rs8//1ynnnqqJOmnn37Spk2btGjRIp8HiHoWFMRyaQAANEZMEAsAlvK6SfTcc8/Vxo0bdcEFFyg/P1/5+fm64IILtHHjRp177rl1ESMAAADqmnOC2Jwcc0LYIzkniE1KYoJYAKgjXrecS2bX9hkzZvg6FgAAAFiFCWIBwFIeJedr165Vjx49FBQUpLVr11Zb9+STT/ZJYAAAAKhnzglineuc5+aaXdnT0szEnAliAaDOeJSc9+rVS7t27VKrVq3Uq1cv2Ww2GUd3d5Jks9lUXl7u8yABAABQT5ggFgAs4VFyvmXLFrVs2dL1OwAAAAIYE8QCQL3zKDnv0KFDpb8DAAAAAIDa87p/0vz58/Xpp5+67t97771q1qyZ+vbtq+zsbJ8GBwAAAABAY+B1cj5jxgxFRERIklasWKHnnntOjz76qOLi4nTXXXf5PEAAAAAAAAKd10upbd++XQl/rW/54Ycf6tJLL9UNN9ygfv36acCAAb6ODwAAAACAgOd1y3nTpk31xx9/SJKWLFmiwYMHS5LCw8N18OBB30YHAAAAAEAj4HXL+eDBg3XdddcpJSVFGzdu1LnnnitJ+u2339SxY0dfxwcAgMnhYGknAAAQsLxOzp9//nk98MAD2r59uxYtWqQWLVpIktLT03XllVf6PEAAAJSRIc2fL2VmSsXFUni4lJgojRplrskMAADQwHmdnDdr1kzPPfdchfKpU6f6JCAAANxkZEjTpkl5eVJ8vBQVJRUWSunpUna2NGkSCToAAGjwatQf8JtvvtHVV1+tvn37aseOHZKkN954Q99++61PgwMANHIOh9linpdntpTHxEjBweZtYqJZvmCBWQ8AAKAB8zo5X7RokYYOHaqIiAitWrVKJSUlkiS73a4ZM2b4PEAAQCOWlWV2ZY+Pl2w29202m1m+bp1ZDwAAoAHzOjl/+OGH9eKLL+rll19WSEiIq7xfv35atWqVT4MDADRydrs5xjwqqvLtkZHmdru9fuMCAADwMa+T8w0bNqh///4VymNjY/Xnn3/6IiYAAEyxsebkb4WFlW8vKjK3x8bWb1wAAAA+5nVy3rp1a2VV0n3w22+/VefOnX0SFAAAkszl0hITpZwcyTDctxmGWZ6UZNYDAABowLxOzq+//nrdcccd+vHHH2Wz2ZSbm6u33npL48eP180331wXMQIAGqugIHO5tLg4c+x5QYFUVmbeZmaa5SNHst45AABo8LxeSm3ChAlyOBwaOHCgioqK1L9/f4WFhWn8+PG67bbb6iJGAEBjlpJiLpfmXOc8N9fsyp6WZibmLKMGAAACgNfJuc1m0//93//pnnvuUVZWlg4cOKCkpCQ1bdpUBw8eVERERF3ECQBozFJSpORkc1Z2u90cY56QQIs5AAAIGF4n506hoaFKSkqSJJWUlOjJJ5/Uo48+ql27dvksOAAAXIKCpG7drI4CAACgTnjc5FBSUqKJEycqLS1Nffv21YcffihJmjdvnjp16qSnnnpKd911V13FCQAAAABAwPK45XzSpEmaO3euBg0apO+//16XXXaZxowZox9++EFPPvmkLrvsMgUHB9dlrAAAAAAABCSPk/N3331XCxYs0IUXXqhff/1VJ598ssrKyrRmzRrZbLa6jBEAAAAAgIDmcbf2nJwcpaamSpJ69OihsLAw3XXXXSTmAAAAAADUksfJeXl5uUJDQ133mzRpoqZNm9ZJUAAAAAAANCYed2s3DEOjR49WWFiYJKm4uFg33XSToqKi3Oq9//77vo0QAAAAAIAA53FyPmrUKLf7V199tc+DAQAAAACgMfI4OZ83b15dxgEAAAAAQKPl8ZhzAAAAAABQN0jOAQAAAACwGMk5AAAAAAAWIzkHAAAAAMBiJOcAAAAAAFiM5BwAAAAAAIuRnAMAAAAAYLEGl5yXlJSoV69estlsWr16tdXhAAAAAABQaw0uOb/33nvVtm1bq8MAAAAAAMBnmlgdgDc+//xzLVmyRIsWLdLnn39+zPolJSUqKSlx3S8oKJAklZaWqrS0tM7i9IYzDn+JB6gtjmkEGo5pBBqOaQQajmn4O0+PTZthGEYdx+ITu3fvVmpqqj788EPFxcWpU6dOysjIUK9evap8zJQpUzR16tQK5QsXLlRkZGQdRgsAAAAAgFRUVKQRI0bIbrcrJiamynoNIjk3DEPnnnuu+vXrpwceeEBbt271KDmvrOW8ffv2ysvLq/ZNqU+lpaVaunSpBg8erJCQEKvDAWqNYxqBhmMagYZjGoGGYxr+rqCgQHFxccdMzi3t1j5hwgTNmjWr2jqZmZlasmSJ9u/fr4kTJ3q1/7CwMIWFhVUoDwkJ8bsPrj/GBNQGxzQCDcc0Ag3HNAINxzT8lafHpaXJ+d13363Ro0dXW6dz585atmyZVqxYUSHRTktL01VXXaX58+fXYZQAAAAAANQtS5Pzli1bqmXLlses98wzz+jhhx923c/NzdXQoUP1zjvv6NRTT63LEAEAAAAAqHMNYrb2E044we1+06ZNJUldunRRfHy8FSEBAAAAAOAzDW6dcwAAAAAAAk2DaDk/WseOHdUAJpkHAAAAAMAjtJwDAAAAAGAxknMAAAAAACzWILu1A0Cj4nBIWVmS3S7FxkoJCVIQ11YBAAACCck5APizjAxp/nwpM1MqLpbCw6XERGnUKCklxeroAAAA4CMk5wDgrzIypGnTpLw8KT5eioqSCgul9HQpO1uaNIkEHQAAIEDQLxIA/JHDYbaY5+WZLeUxMVJwsHmbmGiWL1hg1gMAAECDR3IOAP4oK8vsyh4fL9ls7ttsNrN83TqzHgAAABo8knMA8Ed2uznGPCqq8u2RkeZ2u71+4wIAAECdIDkHAH8UG2tO/lZYWPn2oiJze2xs/cYFAACAOkFyDgD+KCHBHFuekyMZhvs2wzDLk5LMegAAAGjwSM4BwB8FBZnLpcXFmWPPCwqksjLzNjPTLB85kvXOAQAAAgTf6gDAX6WkmMulpaZK+fnm5G/5+VJaGsuoAQAABBjWOQcAf5aSIiUnm4m53W6OMU9IoMUcAAAgwJCcA4C/CwqSunWzOgoAAADUIZJzAACAozkc9FgBANQrknMAAIAjZWRI8+ebky8WF5vLFiYmmpM0MtcDAKCOkJwDAAA4ZWRI06ZJeXlSfLwUFSUVFkrp6VJ2NpMxAgDqDP2zAAAAJLMr+/z5ZmKemCjFxEjBweZtYqJZvmCBWQ8AAB8jOQcAAJDMMeaZmWaLuc3mvs1mM8vXrTPrAQDgYyTnAAAAkjn5W3Gx2ZW9MpGR5na7vX7jAgA0CiTnAAAAkjkre3i4Oca8MkVF5vbY2PqNCwDQKJCcAwAASOZyaYmJUk6OZBju2wzDLE9KMusBAOBjzNYOAAAgmeuYjxplzsruHHseGWm2mOfkSHFx0siRrHcOzzkc5hwFdrvZ4yIhgeMHQJVIzgEAqIzzS/W+fYfvI/ClpJjLpTnXOc/NNbuyp6WZiTnLqMFTGRmHj6PiYvM4Skw0LwBxHAGoBMk5AABHO/JLtcMh3XqrdP/90tVX86W6MUhJkZKTafFEzWVkSNOmmcvvxcebkwwWFkrp6WbPjEmTOJcAqIDkHACAIx39pdo5+dfq1dLvv/OlurEICpK6dbM6CjREDod5cS8vz2wpdy7LFxNj3s/MlBYsMC8AccEHwBE4IwAA4HT0l+qYGCk42Nx24olm+YIFdHEHULWsrMNzFjgTcyebzSxft86sBwBHIDkHAMCJL9UAastuN8eYR0VVvj0y0txut9dvXAD8Hsk5AABOfKkGUFuxsebkb4WFlW8vKjK3O4fMAMBfSM4BAHDiSzWA2kpIMIfF5ORIhuG+zTDM8qQksx4AHIHkHAAAJ75UA6itoCBzubS4OHOYTEGBVFZm3mZmmuUjRzIZHIAKOCsAAOBU1ZdqSdqwgS/VADyTkmKu7JCaKuXnm/NU5OdLaWms+ACgSiylBgDAkZxfqp3rnOflHS6/6iq+VAPwTEqKuVxaVpY5T0VsrNnrhot7AKpAcg4AwNGO/FK9b5+0a5c0fboUFmZ1ZAAakqAgqVs3q6MA0EBw6Q4AgMo4v1T37n34PgAAQB3hmwYAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALBYg0rOP/30U5166qmKiIjQcccdp+HDh1sdEgAAAAAAtdbE6gA8tWjRIl1//fWaMWOGzj77bJWVlenXX3+1OiwAAAAAAGqtQSTnZWVluuOOO/TYY4/p2muvdZUnJSVZGBUAAAAAAL7RIJLzVatWaceOHQoKClJKSop27dqlXr166bHHHlOPHj2qfFxJSYlKSkpc9wsKCiRJpaWlKi0trfO4PeGMw1/iAWqLYxqBhmMagYZjGoGGYxr+ztNj02YYhlHHsdTa22+/rSuvvFInnHCCnnzySXXs2FFPPPGElixZoo0bN6p58+aVPm7KlCmaOnVqhfKFCxcqMjKyrsMGAAAAADRyRUVFGjFihOx2u2JiYqqsZ2lyPmHCBM2aNavaOpmZmVq1apWuuuoqzZ07VzfccIMks1U8Pj5eDz/8sG688cZKH1tZy3n79u2Vl5dX7ZtSn0pLS7V06VINHjxYISEhVocD1BrHNLzicEi//y4VFEgxMVLnzlKQf81VyjGNQMMxjUDDMQ1/V1BQoLi4uGMm55Z2a7/77rs1evToaut07txZO3fulOQ+xjwsLEydO3fWtm3bqnxsWFiYwsLCKpSHhIT43QfXH2MCaoNjGseUkSHNny9lZkrFxVJ4uJSYKI0aJaWkWB1dBRzTCDQc0wg0HNPwV54el5Ym5y1btlTLli2PWS81NVVhYWHasGGDTj/9dEnmFbKtW7eqQ4cOdR0mAMDXMjKkadOkvDwpPl6KipIKC6X0dCk7W5o0yS8TdAAAgLrSICaEi4mJ0U033aTJkyerffv26tChgx577DFJ0mWXXWZxdAAArzgcZot5Xp7ZUm6zmeUxMeb9zExpwQIpOdnvurgDAADUlQaRnEvSY489piZNmuiaa67RwYMHdeqpp2rZsmU67rjjrA4NAOCNrCwzAY+PP5yYO9lsZvm6dWa9bt2siREAAKCeNZjkPCQkRI8//rgef/xxq0MBANSG3W6OMY+Kqnx7ZKSUm2vWAwAAaCToLwgAqF+xsebkb4WFlW8vKjK3x8bWb1wAAAAWIjkHANSvhARzbHlOjnT0ap6GYZYnJZn1AAAAGgmScwBA/QoKMpdLi4szx54XFEhlZeZtZqZZPnIkk8EBAIBGhW8+AID6l5JiLpeWmirl55uTv+XnS2lpLKMGAAAapQYzIRwAIMCkpJjLpWVlmZO/xcaaXdlpMQcAAI0QyTkAwDpBQSyXBgAAIJJzAAAAIKAZhqGysjKVl5dbHUqdKC0tVZMmTVRcXBywrxH+LTg4WE2aNJHNZqvVfkjOAQAAgAB16NAh7dy5U0VFRVaHUmcMw1Dr1q21ffv2WidHQE1FRkaqTZs2Cg0NrfE+SM4BAACAAORwOLRlyxYFBwerbdu2Cg0NDcjk1eFw6MCBA2ratKmCmLcE9cwwDB06dEh79+7Vli1b1LVr1xofhyTnAAAAQAA6dOiQHA6H2rdvr8jISKvDqTMOh0OHDh1SeHg4yTksERERoZCQEGVnZ7uOxZrg6AUAAAACGAkrUPd88TnjkwoAAAAAgMVIzgEAAAAAsBjJub9zOKSNG6WVK81bh8PqiAAAAAA0EAMGDNCdd97pcf3XX39dzZo1q7N4PDFlyhT16tWr2jqjR4/W8OHDffq8Vr92knN/lpEhjRsn3XabNH68eTtunFkOAAAABLBdu3bptttuU+fOnRUWFqb27dvrggsu0BdffOGT/W/dulU2m02rV6/2yf5q+vzBwcHasWOH27adO3e61s3eunWrJfFVx2azuX5iYmJ0yimn6KOPPvLZ/sePH++zv3NDQnLurzIypGnTpPR0qXlzqWtX8zY93SwnQQcAAEB9qefenFu3blVqaqqWLVumxx57TL/88osWL16ss846S2PHjq3T565v7dq104IFC9zK5s+fr3bt2lkUkWfmzZunnTt36ueff1a/fv106aWX6pdffvHJvps2baoWLVr4ZF8NCcm5P3I4pPnzpbw8KTFRiomRgoPN28REs3zBArq4AwAAoO5Z0Jvzlltukc1m008//aS///3v6tatm0466SSNGzdOP/zwg6TKW77//PNP2Ww2LV++XJK0b98+XXXVVWrZsqUiIiLUtWtXzZs3T5LUqVMnSVJKSopsNpsGDBggyVyabdq0aYqPj1dYWJh69eqlxYsXu57D+bz//ve/dcYZZygiIkKnnHKKNm7cqJUrVyotLU1NmzbVsGHDtHfv3mO+1lGjRrlicpo3b55GjRpVoe5XX32lPn36KCwsTG3atNGECRNUVlbm2l5YWKiRI0eqadOmatOmjZ544okK+ygpKdH48ePVrl07RUVF6dRTT3W9X95o1qyZWrdurW7duumhhx5SWVmZvvzyS9f27du36/LLL1ezZs3UvHlzXXTRRW69AJYvX64+ffooKipKzZo1U79+/ZSdnS2pYrf28vJyjRs3Ts2aNVOLFi107733yjAMt3g6duyo2bNnu5X16tVLU6ZMcd1/8skn1bNnT0VFRal9+/a65ZZbdODAgSpf45o1a3TWWWcpOjpaMTExSk1N1c8//+z1e+UpknN/lJUlZWZK8fGSzea+zWYzy9etM+sBAAAAdcWC3pz5+flavHixxo4dq6ioqArbvRkT/OCDD2rdunX6/PPPlZmZqTlz5iguLk6S9NNPP0mS/ve//2nnzp16//33JUlPP/20nnjiCT3++ONau3athg4dqgsvvFCbNm1y2/fkyZP1wAMPaNWqVWrSpIlGjBihe++9V08//bS++eYbZWVladKkSceM8cILL9S+ffv07bffSpK+/fZb7du3TxdccIFbvR07dujcc8/VKaecojVr1mjOnDl69dVX9fDDD7vq3HPPPfrqq6/00UcfacmSJVq+fLlWrVrltp9bb71VK1as0Ntvv621a9fqsssu0znnnFPh9XmqrKxMr776qiQpNDRUklRaWqqhQ4cqOjpa33zzjb777js1bdpU55xzjg4dOqSysjINHz5cZ555ptauXasVK1bohhtukO3o3OcvTzzxhF5//XW99tpr+vbbb5Wfn68PPvjA61iDgoL0zDPP6LffftP8+fO1bNky3XvvvVXWv+qqqxQfH6+VK1cqPT1dEyZMUEhIiNfP66kmdbZn1JzdLhUXS5WcjCRJkZFSbq5ZDwAAAKgLR/fmdCZOzt6cmZlmb87kZMmHa6lnZWXJMAx179691vvatm2bUlJSlJaWJslsXXVq2bKlJKlFixZq3bq1q/zxxx/Xfffdp3/84x+SpFmzZunLL7/U7Nmz9fzzz7vqjR8/XkOHDpUk3XHHHbryyiv1xRdfqF+/fpKka6+9Vq+//voxYwwJCdHVV1+t1157Taeffrpee+01XX311RWSwBdeeEHt27fXc889J5vNpu7duys3N1f33XefJk2apKKiIr366qt68803NXDgQElm9/j4+Hi392PevHnatm2b2rZt63odixcv1rx58zRjxgyP3ldJuvLKKxUcHKyDBw/K4XCoY8eOuvzyyyVJ77zzjhwOh1555RVXwj1v3jw1a9ZMy5cvV1pamux2u84//3x16dJFkpSYmFjlc82ePVsTJ07UJZdcIkl68cUX9d///tfjWJ2OnBivY8eOevjhh3XTTTfphRdeqLT+tm3bdM8997iOxa5du3r9nN6g5dwfxcZK4eFSYWHl24uKzO2xsfUbFwAAABoPi3pzHt1duTZuvvlmvf322+rVq5fuvfdeff/999XWLygoUG5urivBdurXr58yMzPdyk4++WTX78cff7wkqWfPnm5le/bs8SjOf/7zn3r33Xe1a9cuvfvuu/rnP/9ZoU5mZqZOO+00t9blfv366cCBA8rJydHmzZt16NAhnXrqqa7tzZs314knnui6/8svv6i8vFzdunVT06ZNXT9fffWVNm/e7FGsTk899ZRWr16tzz//XElJSXrllVfUvHlzSWZ38KysLEVHR7ueo3nz5iouLtbmzZvVvHlzjR49WkOHDtUFF1ygp59+Wjt37qz0eex2u3bu3On2upo0aeK64OKN//3vfxo4cKDatWun6OhoXXPNNfrjjz9UVFRUaf1x48bpuuuu06BBg/TII494/R55i+TcHyUkmFcjc3Kko09OhmGWJyWZ9QAAAIC64ElvzuJin/fm7Nq1q2w2m9avX19tvaC/WuuPTOZLS0vd6gwbNkzZ2dm66667lJubq4EDB2r8+PE+ifPIlm1nwnx0mcPDOaJ69uyp7t2768orr1RiYqJ69OjhkxiPduDAAQUHBys9PV2rV692/WRmZurpp5/2al+tW7dWQkKChgwZonnz5umKK65wXYw4cOCAUlNT3Z5j9erV2rhxo0aMGCHJbElfsWKF+vbtq3feeUfdunVzzSdQE0FBQRUu7Bx5PGzdulXnn3++Tj75ZC1atEjp6emunhCHDh2qdJ9TpkzRb7/9pvPOO0/Lli1TUlJSjbrTe/wa6mzPqLmgIGnUKCkuzrxaWVAglZWZt5mZZvnIkT7tPgQAAAC4sag3Z/PmzTV06FA9//zzKqzkuf/8809Jh7ulH9niWtmyaC1bttSoUaP05ptvavbs2XrppZckHR4fXV5e7qobExOjtm3b6rvvvnPbx3fffaekpKRava5j+ec//6nly5dX2moumd2+V6xY4ZaAfvfdd4qOjlZ8fLy6dOmikJAQ/fjjj67t+/bt08aNG133U1JSVF5erj179ighIcHt58iu/d7q06ePUlNTNX36dElS7969tWnTJrVq1arC88QecbykpKRo4sSJ+v7779WjRw8tXLiwwr5jY2PVpk0bt9dVVlam9PR0t3otW7Z0OxYKCgq0ZcsW1/309HQ5HA498cQT+tvf/qZu3bopNzf3mK+tW7duuuuuu7RkyRJdcsklFSbv8yWyO3+VkiJNmiSlpkr5+WZ3ofx8KS3NLE9JsTpCAAAABDILe3M+//zzKi8vV58+fbRo0SJt2rRJmZmZeuaZZ3TaaadJkiIiIvS3v/1Njz76qDZs2KCvvvpKDzzwgNt+Jk2apI8++khZWVn67bff9Mknn7jGNrdq1UoRERFavHixdu/eLftfPQDuuecezZo1S++88442bNigCRMmaPXq1brjjjt8/jqPdP3112vv3r267rrrKt1+yy23aPv27brtttu0fv16ffTRR5o8ebLGjRunoKAgNW3aVNdee63uueceLVu2TL/++qtGjx7t6mEgmYnmVVddpZEjR+r999/Xli1b9NNPP2nmzJn69NNPaxX/nXfeqblz52rHjh266qqrFBcXp4suukjffPONtmzZouXLl+v2229XTk6OtmzZookTJ2rFihXKzs7WkiVLtGnTpirHnd9xxx165JFH9OGHH2r9+vW65ZZbXBdpnM4++2y98cYb+uabb/TLL79o1KhRCg4Odm1PSEhQaWmpnn32Wf3+++9644039OKLL1b5eg4ePKhbb71Vy5cvV3Z2tr777jutXLmy2rHxtcWEcP4sJcWcYCMry+wuFBtrnvxoMQcAAEBdc/bmzM4+PPY8MtJsMc/JqdPenJ07d9aqVas0ffp03X333dq5c6datmyp1NRUzZkzx1Xvtdde07XXXquzzjpLJ554oh599FENGTLEtT00NFQTJ07U1q1bFRERoTPOOENvv/22JHPc8jPPPKNp06Zp0qRJOuOMM1wJpN1u19133609e/YoKSlJH3/8cZ1PBtakSRPXTPKVadeunT777DPdc889Sk5OVvPmzXXttde6XZB47LHHdODAAV1wwQWKjo7W3Xff7bro4DRv3jw9/PDDuvvuu7Vjxw7FxcXpb3/7m84///xaxX/OOeeoU6dOmj59ul544QV9/fXXuu+++3TJJZdo//79ateunQYOHKiYmBgdPHhQ69ev1/z58/XHH3+oTZs2Gjt2rG688cZK9+08BkaNGqWgoCD985//1MUXX+z22iZOnKgtW7bo/PPPV2xsrB566CG3lvPk5GQ9+eSTmjVrliZOnKj+/ftr5syZGjlyZKXPGRwcrD/++EMjR47U7t27FRcXp0suuURTp06t1ftUHZvhyxkX/FxBQYFiY2Nlt9sVExNjdTiSzHEQn332mc4999w6nZYfqC8c0wg0HNMINBzTjUdxcbG2bNmiTp06KTw8vOY7ysgwZ23PzDTHmIeHmy3mI0f6RW9Oh8OhgoICxcTEuLUSA/Wpus+bp3koLecAAAAAqkZvTqBekJwDAAAAqF5QkNStm9VRAAGNy10AAAAAAFiM5BwAAAAAAIuRnAMAAAABrBHN/wxYxhefM5JzAAAAIAA5Z+MvKiqyOBIg8Dk/Z7VZBYMJ4QAAAIAAFBwcrGbNmmnPnj2SpMjISNlsNouj8j2Hw6FDhw6puLiYpdRQ7wzDUFFRkfbs2aNmzZopODi4xvsiOQcAAAACVOvWrSXJlaAHIsMwdPDgQUVERATkxQc0DM2aNXN93mqK5BwAAAAIUDabTW3atFGrVq1UWlpqdTh1orS0VF9//bX69+9fqy7FQE2FhITUqsXcieQcAAAACHDBwcE+SR78UXBwsMrKyhQeHk5yjgaNQRkAAAAAAFiM5BwAAAAAAIuRnAMAAAAAYLFGNebcuTB8QUGBxZEcVlpaqqKiIhUUFDBGBgGBYxqBhmMagYZjGoGGYxr+zpl/OvPRqjSq5Hz//v2SpPbt21scCQAAAACgMdm/f79iY2Or3G4zjpW+BxCHw6Hc3FxFR0f7zRqIBQUFat++vbZv366YmBirwwFqjWMagYZjGoGGYxqBhmMa/s4wDO3fv19t27ZVUFDVI8sbVct5UFCQ4uPjrQ6jUjExMZxMEFA4phFoOKYRaDimEWg4puHPqmsxd2JCOAAAAAAALEZyDgAAAACAxUjOLRYWFqbJkycrLCzM6lAAn+CYRqDhmEag4ZhGoOGYRqBoVBPCAQAAAADgj2g5BwAAAADAYiTnAAAAAABYjOQcAAAAAACLkZwDAAAAAGAxknOLPf/88+rYsaPCw8N16qmn6qeffrI6JKBGZs6cqVNOOUXR0dFq1aqVhg8frg0bNlgdFuATjzzyiGw2m+68806rQwFqbMeOHbr66qvVokULRUREqGfPnvr555+tDguokfLycj344IPq1KmTIiIi1KVLFz300ENirms0ZCTnFnrnnXc0btw4TZ48WatWrVJycrKGDh2qPXv2WB0a4LWvvvpKY8eO1Q8//KClS5eqtLRUQ4YMUWFhodWhAbWycuVKzZ07VyeffLLVoQA1tm/fPvXr108hISH6/PPPtW7dOj3xxBM67rjjrA4NqJFZs2Zpzpw5eu6555SZmalZs2bp0Ucf1bPPPmt1aECNsZSahU499VSdcsopeu655yRJDodD7du312233aYJEyZYHB1QO3v37lWrVq301VdfqX///laHA9TIgQMH1Lt3b73wwgt6+OGH1atXL82ePdvqsACvTZgwQd99952++eYbq0MBfOL888/X8ccfr1dffdVV9ve//10RERF68803LYwMqDlazi1y6NAhpaena9CgQa6yoKAgDRo0SCtWrLAwMsA37Ha7JKl58+YWRwLU3NixY3Xeeee5nauBhujjjz9WWlqaLrvsMrVq1UopKSl6+eWXrQ4LqLG+ffvqiy++0MaNGyVJa9as0bfffqthw4ZZHBlQc02sDqCxysvLU3l5uY4//ni38uOPP17r16+3KCrANxwOh+68807169dPPXr0sDocoEbefvttrVq1SitXrrQ6FKDWfv/9d82ZM0fjxo3T/fffr5UrV+r2229XaGioRo0aZXV4gNcmTJiggoICde/eXcHBwSovL9f06dN11VVXWR0aUGMk5wB8buzYsfr111/17bffWh0KUCPbt2/XHXfcoaVLlyo8PNzqcIBaczgcSktL04wZMyRJKSkp+vXXX/Xiiy+SnKNB+ve//6233npLCxcu1EknnaTVq1frzjvvVNu2bTmm0WCRnFskLi5OwcHB2r17t1v57t271bp1a4uiAmrv1ltv1SeffKKvv/5a8fHxVocD1Eh6err27Nmj3r17u8rKy8v19ddf67nnnlNJSYmCg4MtjBDwTps2bZSUlORWlpiYqEWLFlkUEVA799xzjyZMmKB//OMfkqSePXsqOztbM2fOJDlHg8WYc4uEhoYqNTVVX3zxhavM4XDoiy++0GmnnWZhZEDNGIahW2+9VR988IGWLVumTp06WR0SUGMDBw7UL7/8otWrV7t+0tLSdNVVV2n16tUk5mhw+vXrV2F5y40bN6pDhw4WRQTUTlFRkYKC3FOZ4OBgORwOiyICao+WcwuNGzdOo0aNUlpamvr06aPZs2ersLBQY8aMsTo0wGtjx47VwoUL9dFHHyk6Olq7du2SJMXGxioiIsLi6ADvREdHV5gvISoqSi1atGAeBTRId911l/r27asZM2bo8ssv108//aSXXnpJL730ktWhATVywQUXaPr06TrhhBN00kknKSMjQ08++aT++c9/Wh0aUGMspWax5557To899ph27dqlXr166ZlnntGpp55qdViA12w2W6Xl8+bN0+jRo+s3GKAODBgwgKXU0KB98sknmjhxojZt2qROnTpp3Lhxuv76660OC6iR/fv368EHH9QHH3ygPXv2qG3btrryyis1adIkhYaGWh0eUCMk5wAAAAAAWIwx5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAA4Jg2bNig1q1ba//+/VaH4jfWrVun+Ph4FRYWWh0KACAAkJwDACBp9OjRstlsFX6ysrJ8sv/XX39dzZo188m+aqK8vFx9+/bVJZdc4lZut9vVvn17/d///V+1j584caJuu+02RUdHV/leOX86duxY4zhHjx6t4cOHe1TP+XwhISE6/vjjNXjwYL322mtyOBxePWdN/zZJSUn629/+pieffNLrxwIAcDSScwAA/nLOOedo586dbj+dOnWyOqwKSktLvX5McHCwXn/9dS1evFhvvfWWq/y2225T8+bNNXny5Cofu23bNn3yyScaPXq0JOnpp592e48kad68ea77K1eu9Dq+mnD+vbZu3arPP/9cZ511lu644w6df/75Kisrq5cYxowZozlz5tTb8wEAAhfJOQAAfwkLC1Pr1q3dfoKDgyVJH330kXr37q3w8HB17txZU6dOdUvInnzySfXs2VNRUVFq3769brnlFh04cECStHz5co0ZM0Z2u93V2jtlyhRJks1m04cffugWR7NmzfT6669LkrZu3SqbzaZ33nlHZ555psLDw13J9SuvvKLExESFh4ere/fueuGFF6p9fd26ddMjjzyi2267TTt37tRHH32kt99+WwsWLFBoaGiVj/v3v/+t5ORktWvXTpIUGxvr9h45Y3be3717t4YNG6amTZvq+OOP1zXXXKO8vDzX/t577z317NlTERERatGihQYNGqTCwkJNmTJF8+fP10cffeR6n5YvX37Mv1e7du3Uu3dv3X///froo4/0+eefu96/2vxt3njjDaWlpSk6OlqtW7fWiBEjtGfPHrcYBg8erPz8fH311VfVvvcAABwLyTkAAMfwzTffaOTIkbrjjju0bt06zZ07V6+//rqmT5/uqhMUFKRnnnlGv/32m+bPn69ly5bp3nvvlST17dtXs2fPVkxMjKt1efz48V7FMGHCBN1xxx3KzMzU0KFD9dZbb2nSpEmaPn26MjMzNWPGDD344IOaP39+tfu57bbblJycrGuuuUY33HCDJk2apOTk5GO+/rS0NI/i/PPPP3X22WcrJSVFP//8sxYvXqzdu3fr8ssvlyTt3LlTV155pf75z38qMzNTy5cv1yWXXCLDMDR+/Hhdfvnlbj0Y+vbt69kb9Jezzz5bycnJev/9911lNf3blJaW6qGHHtKaNWv04YcfauvWra7eA06hoaHq1auXvvnmG6/iBACgAgMAABijRo0ygoODjaioKNfPpZdeahiGYQwcONCYMWOGW/033njDaNOmTZX7e/fdd40WLVq47s+bN8+IjY2tUE+S8cEHH7iVxcbGGvPmzTMMwzC2bNliSDJmz57tVqdLly7GwoUL3coeeugh47TTTjvWSzUyMzMNSUbPnj2N0tLSY9ZPTk42pk2bVuX2I1/DQw89ZAwZMsRt+/bt2w1JxoYNG4z09HRDkrF169ZK9zVq1CjjoosuOmZM1dW74oorjMTExCof6+nf5mgrV640JBn79+93K7/44ouN0aNHH/PxAABUp4mF1wUAAPArZ511lubMmeO6HxUVJUlas2aNvvvuO7eW8vLychUXF6uoqEiRkZH63//+p5kzZ2r9+vUqKChQWVmZ2/baOrLlurCwUJs3b9a1116r66+/3lVeVlam2NjYY+7rtddeU2RkpLZs2aKcnJxjTuB28OBBhYeHexTnmjVr9OWXX6pp06YVtm3evFlDhgzRwIED1bNnTw0dOlRDhgzRpZdequOOO86j/XvCMAzZbDbX/Zr+bdLT0zVlyhStWbNG+/btc000t23bNiUlJbnqRUREqKioyGfxAwAaJ7q1AwDwl6ioKCUkJLh+2rRpI0k6cOCApk6dqtWrV7t+fvnlF23atEnh4eHaunWrzj//fJ188slatGiR0tPT9fzzz0uSDh06VO1z2mw2GYbhVlbZhG/OCwXOeCTp5Zdfdovp119/1Q8//FDt833//fd66qmn9Mknn6hPnz669tprKzz/0eLi4rRv375q6xwZ2wUXXOAW1+rVq7Vp0yb1799fwcHBWrp0qT7//HMlJSXp2Wef1YknnqgtW7Z4tH9PZGZmuibyq+nfprCwUEOHDlVMTIzeeustrVy5Uh988EGlj8vPz1fLli19Fj8AoHGi5RwAgGPo3bu3NmzYoISEhEq3p6eny+Fw6IknnlBQkHnd+9///rdbndDQUJWXl1d4bMuWLV0znkvSpk2bjtkKe/zxx6tt27b6/fffddVVV3n8OoqKijR69GjdfPPNOuuss9SpUyf17NlTL774om6++eYqH5eSkqJ169Z59By9e/fWokWL1LFjRzVpUvnXDJvNpn79+qlfv36aNGmSOnTooA8++EDjxo2r8n3y1LJly/TLL7/orrvuklTzv8369ev1xx9/6JFHHlH79u0lST///HOlz/nrr7/q0ksvrXHMAABItJwDAHBMkyZN0oIFCzR16lT99ttvyszM1Ntvv60HHnhAkpSQkKDS0lI9++yz+v333/XGG2/oxRdfdNtHx44ddeDAAX3xxRfKy8tzJeBnn322nnvuOWVkZOjnn3/WTTfdpJCQkGPGNHXqVM2cOVPPPPOMNm7cqF9++UXz5s2rds3tiRMnyjAMPfLII66YHn/8cd17773aunVrlY8bOnSoVqxY4VHSPHbsWOXn5+vKK6/UypUrtXnzZv33v//VmDFjVF5erh9//FEzZszQzz//rG3btun999/X3r17lZiY6Ipp7dq12rBhg/Ly8qpdNq6kpES7du3Sjh07tGrVKs2YMUMXXXSRzj//fI0cOVJSzf82J5xwgkJDQ12P+/jjj/XQQw9ViGHr1q3asWOHBg0adMz3BgCAalk75B0AAP9wrInIFi9ebPTt29eIiIgwYmJijD59+hgvvfSSa/uTTz5ptGnTxoiIiDCGDh1qLFiwwJBk7Nu3z1XnpptuMlq0aGFIMiZPnmwYhmHs2LHDGDJkiBEVFWV07drV+OyzzyqdEC4jI6NCTG+99ZbRq1cvIzQ01DjuuOOM/v37G++//36l8S9fvtwIDg42vvnmmwrbhgwZYpx99tmGw+Go9LGlpaVG27ZtjcWLF1e6XUdNardx40bj4osvNpo1a2ZEREQY3bt3N+68807D4XAY69atM4YOHWq0bNnSCAsLM7p162Y8++yzrsfu2bPHGDx4sNG0aVNDkvHll19W+pyjRo0yJBmSjCZNmhgtW7Y0Bg0aZLz22mtGeXm5W92a/m0WLlxodOzY0QgLCzNOO+004+OPP67wt5gxY4YxdOjQSmMEAMAbNsM4xkAzAADQ6D3//PP6+OOP9d///tfqUPzGoUOH1LVrVy1cuFD9+vWzOhwAQAPHmHMAAHBMN954o/7880/t379f0dHRVofjF7Zt26b777+fxBwA4BO0nAMAAAAAYDEmhAMAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGL/DyhqJQV1YzTaAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Analysis:\n",
+      "The Scikit-learn model performed better!\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Before running this cell ensure that you have Executed the first cell\n",
+    "\n",
+    "# Generate Linear data\n",
+    "X, y = generate_linear_data(n_samples=200, noise=2.0)\n",
+    "\n",
+    "# Handle missing data (if present)\n",
+    "X = handle_missing_data(X)\n",
+    "\n",
+    "# Custom train-test split\n",
+    "X_train, X_test, y_train, y_test = custom_train_test_split(X, y, test_size=0.25, random_state=42)\n",
+    "\n",
+    "# Train custom model\n",
+    "custom_model = CustomGradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3)\n",
+    "custom_model.fit(X_train, y_train)\n",
+    "\n",
+    "# Train sklearn model\n",
+    "sklearn_model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)\n",
+    "sklearn_model.fit(X_train, y_train)\n",
+    "\n",
+    "# Evaluate models\n",
+    "evaluate_model(custom_model, sklearn_model, X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test-2\n",
+    "- Testing both custom and SKlearn model on noisy generated data "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 1/100, Loss: 26.8436\n",
+      "Iteration 2/100, Loss: 22.3473\n",
+      "Iteration 3/100, Loss: 18.7052\n",
+      "Iteration 4/100, Loss: 15.7212\n",
+      "Iteration 5/100, Loss: 13.2911\n",
+      "Iteration 6/100, Loss: 11.3284\n",
+      "Iteration 7/100, Loss: 9.7300\n",
+      "Iteration 8/100, Loss: 8.4363\n",
+      "Iteration 9/100, Loss: 7.3840\n",
+      "Iteration 10/100, Loss: 6.5320\n",
+      "Iteration 11/100, Loss: 5.8351\n",
+      "Iteration 12/100, Loss: 5.2722\n",
+      "Iteration 13/100, Loss: 4.8104\n",
+      "Iteration 14/100, Loss: 4.4330\n",
+      "Iteration 15/100, Loss: 4.0982\n",
+      "Iteration 16/100, Loss: 3.8436\n",
+      "Iteration 17/100, Loss: 3.6156\n",
+      "Iteration 18/100, Loss: 3.4342\n",
+      "Iteration 19/100, Loss: 3.2597\n",
+      "Iteration 20/100, Loss: 3.1168\n",
+      "Iteration 21/100, Loss: 3.0042\n",
+      "Iteration 22/100, Loss: 2.9054\n",
+      "Iteration 23/100, Loss: 2.8269\n",
+      "Iteration 24/100, Loss: 2.7443\n",
+      "Iteration 25/100, Loss: 2.6758\n",
+      "Iteration 26/100, Loss: 2.6058\n",
+      "Iteration 27/100, Loss: 2.5547\n",
+      "Iteration 28/100, Loss: 2.4959\n",
+      "Iteration 29/100, Loss: 2.4509\n",
+      "Iteration 30/100, Loss: 2.4144\n",
+      "Iteration 31/100, Loss: 2.3743\n",
+      "Iteration 32/100, Loss: 2.3457\n",
+      "Iteration 33/100, Loss: 2.3097\n",
+      "Iteration 34/100, Loss: 2.2856\n",
+      "Iteration 35/100, Loss: 2.2359\n",
+      "Iteration 36/100, Loss: 2.2086\n",
+      "Iteration 37/100, Loss: 2.1845\n",
+      "Iteration 38/100, Loss: 2.1454\n",
+      "Iteration 39/100, Loss: 2.1319\n",
+      "Iteration 40/100, Loss: 2.1154\n",
+      "Iteration 41/100, Loss: 2.0739\n",
+      "Iteration 42/100, Loss: 2.0529\n",
+      "Iteration 43/100, Loss: 2.0202\n",
+      "Iteration 44/100, Loss: 2.0021\n",
+      "Iteration 45/100, Loss: 1.9813\n",
+      "Iteration 46/100, Loss: 1.9579\n",
+      "Iteration 47/100, Loss: 1.9487\n",
+      "Iteration 48/100, Loss: 1.9270\n",
+      "Iteration 49/100, Loss: 1.8923\n",
+      "Iteration 50/100, Loss: 1.8781\n",
+      "Iteration 51/100, Loss: 1.8605\n",
+      "Iteration 52/100, Loss: 1.8311\n",
+      "Iteration 53/100, Loss: 1.8060\n",
+      "Iteration 54/100, Loss: 1.7878\n",
+      "Iteration 55/100, Loss: 1.7763\n",
+      "Iteration 56/100, Loss: 1.7380\n",
+      "Iteration 57/100, Loss: 1.7243\n",
+      "Iteration 58/100, Loss: 1.7151\n",
+      "Iteration 59/100, Loss: 1.7073\n",
+      "Iteration 60/100, Loss: 1.6870\n",
+      "Iteration 61/100, Loss: 1.6806\n",
+      "Iteration 62/100, Loss: 1.6576\n",
+      "Iteration 63/100, Loss: 1.6501\n",
+      "Iteration 64/100, Loss: 1.6357\n",
+      "Iteration 65/100, Loss: 1.6304\n",
+      "Iteration 66/100, Loss: 1.6008\n",
+      "Iteration 67/100, Loss: 1.5690\n",
+      "Iteration 68/100, Loss: 1.5648\n",
+      "Iteration 69/100, Loss: 1.5531\n",
+      "Iteration 70/100, Loss: 1.5278\n",
+      "Iteration 71/100, Loss: 1.5034\n",
+      "Iteration 72/100, Loss: 1.4999\n",
+      "Iteration 73/100, Loss: 1.4794\n",
+      "Iteration 74/100, Loss: 1.4734\n",
+      "Iteration 75/100, Loss: 1.4639\n",
+      "Iteration 76/100, Loss: 1.4444\n",
+      "Iteration 77/100, Loss: 1.4275\n",
+      "Iteration 78/100, Loss: 1.4247\n",
+      "Iteration 79/100, Loss: 1.4110\n",
+      "Iteration 80/100, Loss: 1.4032\n",
+      "Iteration 81/100, Loss: 1.4005\n",
+      "Iteration 82/100, Loss: 1.3813\n",
+      "Iteration 83/100, Loss: 1.3764\n",
+      "Iteration 84/100, Loss: 1.3540\n",
+      "Iteration 85/100, Loss: 1.3384\n",
+      "Iteration 86/100, Loss: 1.3343\n",
+      "Iteration 87/100, Loss: 1.3155\n",
+      "Iteration 88/100, Loss: 1.3031\n",
+      "Iteration 89/100, Loss: 1.2787\n",
+      "Iteration 90/100, Loss: 1.2724\n",
+      "Iteration 91/100, Loss: 1.2600\n",
+      "Iteration 92/100, Loss: 1.2450\n",
+      "Iteration 93/100, Loss: 1.2252\n",
+      "Iteration 94/100, Loss: 1.2230\n",
+      "Iteration 95/100, Loss: 1.2022\n",
+      "Iteration 96/100, Loss: 1.1927\n",
+      "Iteration 97/100, Loss: 1.1793\n",
+      "Iteration 98/100, Loss: 1.1508\n",
+      "Iteration 99/100, Loss: 1.1408\n",
+      "Iteration 100/100, Loss: 1.1252\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Custom Model Performance:\n",
+      "Mean Squared Error: 6.8906\n",
+      "R-Squared: 0.8259\n",
+      "\n",
+      "Sklearn Model Performance:\n",
+      "Mean Squared Error: 6.0692\n",
+      "R-Squared: 0.8466\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Analysis:\n",
+      "The Scikit-learn model performed better!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Generate Noisy data\n",
+    "X, y = generate_noisy_data(n_samples=200, noise=2.0)\n",
+    "\n",
+    "# Handle missing data (if present)\n",
+    "X = handle_missing_data(X)\n",
+    "\n",
+    "# Custom train-test split\n",
+    "X_train, X_test, y_train, y_test = custom_train_test_split(X, y, test_size=0.25, random_state=42)\n",
+    "\n",
+    "# Train custom model\n",
+    "custom_model = CustomGradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3)\n",
+    "custom_model.fit(X_train, y_train)\n",
+    "\n",
+    "# Train sklearn model\n",
+    "sklearn_model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)\n",
+    "sklearn_model.fit(X_train, y_train)\n",
+    "\n",
+    "# Evaluate models\n",
+    "evaluate_model(custom_model, sklearn_model, X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test-3\n",
+    "- Testing both custom and SKlean model on polynomial generated data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 1/100, Loss: 415.9947\n",
+      "Iteration 2/100, Loss: 338.4194\n",
+      "Iteration 3/100, Loss: 275.3606\n",
+      "Iteration 4/100, Loss: 224.2216\n",
+      "Iteration 5/100, Loss: 182.6294\n",
+      "Iteration 6/100, Loss: 148.9348\n",
+      "Iteration 7/100, Loss: 121.5232\n",
+      "Iteration 8/100, Loss: 99.1525\n",
+      "Iteration 9/100, Loss: 80.9827\n",
+      "Iteration 10/100, Loss: 66.2510\n",
+      "Iteration 11/100, Loss: 54.2763\n",
+      "Iteration 12/100, Loss: 44.5413\n",
+      "Iteration 13/100, Loss: 36.6163\n",
+      "Iteration 14/100, Loss: 30.1824\n",
+      "Iteration 15/100, Loss: 24.9158\n",
+      "Iteration 16/100, Loss: 20.6520\n",
+      "Iteration 17/100, Loss: 17.1730\n",
+      "Iteration 18/100, Loss: 14.3475\n",
+      "Iteration 19/100, Loss: 12.0421\n",
+      "Iteration 20/100, Loss: 10.1708\n",
+      "Iteration 21/100, Loss: 8.6430\n",
+      "Iteration 22/100, Loss: 7.3989\n",
+      "Iteration 23/100, Loss: 6.3921\n",
+      "Iteration 24/100, Loss: 5.5662\n",
+      "Iteration 25/100, Loss: 4.8953\n",
+      "Iteration 26/100, Loss: 4.3495\n",
+      "Iteration 27/100, Loss: 3.9069\n",
+      "Iteration 28/100, Loss: 3.5459\n",
+      "Iteration 29/100, Loss: 3.2525\n",
+      "Iteration 30/100, Loss: 3.0079\n",
+      "Iteration 31/100, Loss: 2.8090\n",
+      "Iteration 32/100, Loss: 2.6475\n",
+      "Iteration 33/100, Loss: 2.5146\n",
+      "Iteration 34/100, Loss: 2.3877\n",
+      "Iteration 35/100, Loss: 2.2914\n",
+      "Iteration 36/100, Loss: 2.2025\n",
+      "Iteration 37/100, Loss: 2.1255\n",
+      "Iteration 38/100, Loss: 2.0614\n",
+      "Iteration 39/100, Loss: 2.0046\n",
+      "Iteration 40/100, Loss: 1.9578\n",
+      "Iteration 41/100, Loss: 1.9182\n",
+      "Iteration 42/100, Loss: 1.8691\n",
+      "Iteration 43/100, Loss: 1.8320\n",
+      "Iteration 44/100, Loss: 1.7933\n",
+      "Iteration 45/100, Loss: 1.7722\n",
+      "Iteration 46/100, Loss: 1.7355\n",
+      "Iteration 47/100, Loss: 1.7100\n",
+      "Iteration 48/100, Loss: 1.6924\n",
+      "Iteration 49/100, Loss: 1.6584\n",
+      "Iteration 50/100, Loss: 1.6381\n",
+      "Iteration 51/100, Loss: 1.6113\n",
+      "Iteration 52/100, Loss: 1.5846\n",
+      "Iteration 53/100, Loss: 1.5678\n",
+      "Iteration 54/100, Loss: 1.5529\n",
+      "Iteration 55/100, Loss: 1.5320\n",
+      "Iteration 56/100, Loss: 1.5164\n",
+      "Iteration 57/100, Loss: 1.5049\n",
+      "Iteration 58/100, Loss: 1.4807\n",
+      "Iteration 59/100, Loss: 1.4702\n",
+      "Iteration 60/100, Loss: 1.4595\n",
+      "Iteration 61/100, Loss: 1.4477\n",
+      "Iteration 62/100, Loss: 1.4192\n",
+      "Iteration 63/100, Loss: 1.4057\n",
+      "Iteration 64/100, Loss: 1.3944\n",
+      "Iteration 65/100, Loss: 1.3747\n",
+      "Iteration 66/100, Loss: 1.3599\n",
+      "Iteration 67/100, Loss: 1.3437\n",
+      "Iteration 68/100, Loss: 1.3291\n",
+      "Iteration 69/100, Loss: 1.3218\n",
+      "Iteration 70/100, Loss: 1.3088\n",
+      "Iteration 71/100, Loss: 1.2969\n",
+      "Iteration 72/100, Loss: 1.2926\n",
+      "Iteration 73/100, Loss: 1.2892\n",
+      "Iteration 74/100, Loss: 1.2698\n",
+      "Iteration 75/100, Loss: 1.2528\n",
+      "Iteration 76/100, Loss: 1.2423\n",
+      "Iteration 77/100, Loss: 1.2389\n",
+      "Iteration 78/100, Loss: 1.2310\n",
+      "Iteration 79/100, Loss: 1.2199\n",
+      "Iteration 80/100, Loss: 1.2160\n",
+      "Iteration 81/100, Loss: 1.2026\n",
+      "Iteration 82/100, Loss: 1.1916\n",
+      "Iteration 83/100, Loss: 1.1885\n",
+      "Iteration 84/100, Loss: 1.1778\n",
+      "Iteration 85/100, Loss: 1.1538\n",
+      "Iteration 86/100, Loss: 1.1514\n",
+      "Iteration 87/100, Loss: 1.1426\n",
+      "Iteration 88/100, Loss: 1.1363\n",
+      "Iteration 89/100, Loss: 1.1292\n",
+      "Iteration 90/100, Loss: 1.1272\n",
+      "Iteration 91/100, Loss: 1.1146\n",
+      "Iteration 92/100, Loss: 1.1074\n",
+      "Iteration 93/100, Loss: 1.0991\n",
+      "Iteration 94/100, Loss: 1.0976\n",
+      "Iteration 95/100, Loss: 1.0752\n",
+      "Iteration 96/100, Loss: 1.0699\n",
+      "Iteration 97/100, Loss: 1.0617\n",
+      "Iteration 98/100, Loss: 1.0440\n",
+      "Iteration 99/100, Loss: 1.0394\n",
+      "Iteration 100/100, Loss: 1.0238\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Custom Model Performance:\n",
+      "Mean Squared Error: 7.5595\n",
+      "R-Squared: 0.9841\n",
+      "\n",
+      "Sklearn Model Performance:\n",
+      "Mean Squared Error: 6.8193\n",
+      "R-Squared: 0.9856\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Analysis:\n",
+      "The Scikit-learn model performed better!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Generate Polynomial data\n",
+    "X, y = generate_polynomial_data(n_samples=200, noise=2.0)\n",
+    "\n",
+    "# Handle missing data (if present)\n",
+    "X = handle_missing_data(X)\n",
+    "\n",
+    "# Custom train-test split\n",
+    "X_train, X_test, y_train, y_test = custom_train_test_split(X, y, test_size=0.25, random_state=42)\n",
+    "\n",
+    "# Train custom model\n",
+    "custom_model = CustomGradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3)\n",
+    "custom_model.fit(X_train, y_train)\n",
+    "\n",
+    "# Train sklearn model\n",
+    "sklearn_model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)\n",
+    "sklearn_model.fit(X_train, y_train)\n",
+    "\n",
+    "# Evaluate models\n",
+    "evaluate_model(custom_model, sklearn_model, X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test-4\n",
+    "- An example usage on how we can use this model for a CSV file (Considering the file to be present in the directory)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\NAVEED\\AppData\\Local\\Temp\\ipykernel_8256\\3486327811.py:12: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
+      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
+      "\n",
+      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
+      "\n",
+      "\n",
+      "  data[column].fillna(data[column].mean(), inplace=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 1/25, Loss: 426.4952\n",
+      "Iteration 2/25, Loss: 355.2171\n",
+      "Iteration 3/25, Loss: 297.5956\n",
+      "Iteration 4/25, Loss: 246.9453\n",
+      "Iteration 5/25, Loss: 204.8729\n",
+      "Iteration 6/25, Loss: 168.2329\n",
+      "Iteration 7/25, Loss: 138.4560\n",
+      "Iteration 8/25, Loss: 114.2709\n",
+      "Iteration 9/25, Loss: 94.6602\n",
+      "Iteration 10/25, Loss: 78.5620\n",
+      "Iteration 11/25, Loss: 65.2980\n",
+      "Iteration 12/25, Loss: 54.3881\n",
+      "Iteration 13/25, Loss: 45.4158\n",
+      "Iteration 14/25, Loss: 38.9591\n",
+      "Iteration 15/25, Loss: 32.7409\n",
+      "Iteration 16/25, Loss: 27.2538\n",
+      "Iteration 17/25, Loss: 22.7718\n",
+      "Iteration 18/25, Loss: 19.0138\n",
+      "Iteration 19/25, Loss: 16.2402\n",
+      "Iteration 20/25, Loss: 13.8283\n",
+      "Iteration 21/25, Loss: 12.0028\n",
+      "Iteration 22/25, Loss: 10.0964\n",
+      "Iteration 23/25, Loss: 8.5502\n",
+      "Iteration 24/25, Loss: 7.2539\n",
+      "Iteration 25/25, Loss: 6.2709\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean Squared Error: 80.2701\n"
+     ]
+    }
+   ],
+   "source": [
+    "def load_and_preprocess_data(filepath):\n",
+    "    \"\"\"\n",
+    "    Loads a CSV file and handles missing values.\n",
+    "    - Missing numeric values are filled with the mean of the column.\n",
+    "    - Missing categorical values are filled with the mode of the column.\n",
+    "    Returns: X (features), y (target)\n",
+    "    \"\"\"\n",
+    "    data = pd.read_csv(filepath)\n",
+    "    # Handle missing values\n",
+    "    for column in data.columns:\n",
+    "        if np.issubdtype(data[column].dtype, np.number):\n",
+    "            data[column].fillna(data[column].mean(), inplace=True)\n",
+    "        else:\n",
+    "            data[column].fillna(data[column].mode()[0], inplace=True)\n",
+    "\n",
+    "    # Assume the last column is the target\n",
+    "    X = data.iloc[:, :-1].values\n",
+    "    y = data.iloc[:, -1].values\n",
+    "    return X, y\n",
+    "\n",
+    "\n",
+    "# File path for the CSV file\n",
+    "filepath = \"../small_test.csv\"  # Assuming the file exists in the directory\n",
+    "\n",
+    "# Load and preprocess the data\n",
+    "X, y = load_and_preprocess_data(filepath)\n",
+    "\n",
+    "# Split data into training and testing sets\n",
+    "split = int(0.8 * len(X))\n",
+    "X_train, X_test = X[:split], X[split:]\n",
+    "y_train, y_test = y[:split], y[split:]\n",
+    "\n",
+    "# Train Gradient Boosting Regressor\n",
+    "gbr = CustomGradientBoostingRegressor(n_estimators=25, learning_rate=0.1, max_depth=3)\n",
+    "gbr.fit(X_train, y_train)\n",
+    "\n",
+    "# Make predictions\n",
+    "y_pred = gbr.predict(X_test)\n",
+    "\n",
+    "# Plot results\n",
+    "plt.figure(figsize=(10, 5))\n",
+    "plt.scatter(range(len(y_test)), y_test, label=\"True Values\", color=\"blue\")\n",
+    "plt.scatter(range(len(y_pred)), y_pred, label=\"Predicted Values\", color=\"red\")\n",
+    "plt.xlabel(\"Sample Index\")\n",
+    "plt.ylabel(\"Target\")\n",
+    "plt.title(\"Gradient Boosting Regression\")\n",
+    "plt.legend()\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "# Evaluate model\n",
+    "mse = mean_squared_error(y_test, y_pred)\n",
+    "print(f\"Mean Squared Error: {mse:.4f}\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/README.md b/README.md
index f746e56..64bb0c2 100644
--- a/README.md
+++ b/README.md
@@ -1,29 +1,127 @@
 # Project 2
 
-Select one of the following two options:
+# Submitted by:
+- **Sana Samad**: A20543001
+- **Naveed Mohiuddin**: A20540067
+- **Owaiz Majoriya**: A20546104
 
-## Boosting Trees
+---
 
-Implement the gradient-boosting tree algorithm (with the usual fit-predict interface) as described in Sections 10.9-10.10 of Elements of Statistical Learning (2nd Edition). Answer the questions below as you did for Project 1.
+# Gradient Boosting Regressor Implementation
 
-Put your README below. Answer the following questions.
+## Project Overview
+This project implements a Gradient Boosting Regressor, which is an ensemble learning method for regression tasks. The model iteratively trains weak learners (decision trees) to minimize the residual errors of previous iterations. This implementation was built using Python and relies on `sklearn` for constructing the decision trees but handles the boosting logic manually.
 
-* What does the model you have implemented do and when should it be used?
-* How did you test your model to determine if it is working reasonably correctly?
-* What parameters have you exposed to users of your implementation in order to tune performance? (Also perhaps provide some basic usage examples.)
-* Are there specific inputs that your implementation has trouble with? Given more time, could you work around these or is it fundamental?
+## Features
+- **Gradient Boosting Framework**: Utilizes iterative training of decision trees to optimize predictions.
+- **Customizable Parameters**: Provides users with control over `n_estimators`, `learning_rate`, and `max_depth` to fine-tune model performance.
+- **Performance Evaluation**: Includes evaluation using Mean Squared Error (MSE) and scatter plots for true vs. predicted values.
 
-## Model Selection
+---
 
-Implement generic k-fold cross-validation and bootstrapping model selection methods.
+## Setup
 
-In your README, answer the following questions:
+### Prerequisites
+Ensure you have the following Python libraries installed:
+- Python 3.x
+- NumPy
+- Matplotlib
+- Pandas
+- Scikit-learn
 
-* Do your cross-validation and bootstrapping model selectors agree with a simpler model selector like AIC in simple cases (like linear regression)?
-* In what cases might the methods you've written fail or give incorrect or undesirable results?
-* What could you implement given more time to mitigate these cases or help users of your methods?
-* What parameters have you exposed to your users in order to use your model selectors.
+Install them via pip:
+```bash
+pip install numpy pandas matplotlib scikit-learn
+```
 
-See sections 7.10-7.11 of Elements of Statistical Learning and the lecture notes. Pay particular attention to Section 7.10.2.
+### How to Run
+1. Clone the repository or download the files.
+   ```bash
+   git clone <your_repo_url>
+   cd <your_project_directory>
+   ```
 
-As usual, above-and-beyond efforts will be considered for bonus points.
+2. Ensure your dataset is a CSV file in the expected format:
+   - All columns except the last one are features.
+   - The last column is the target variable.
+
+3. Modify `evaluate_model.ipynb` to include the correct path to your dataset.
+
+4. Run the Jupyter Notebook:
+   ```bash
+   jupyter notebook evaluate_model.ipynb
+   ```
+
+5. The notebook will preprocess the data, train the Gradient Boosting Regressor, evaluate it, and visualize the results.
+
+---
+
+## Parameters
+You can adjust the following parameters for tuning performance:
+- `n_estimators`: Number of trees in the ensemble.
+- `learning_rate`: Controls the contribution of each tree.
+- `max_depth`: Maximum depth of each decision tree.
+
+---
+
+## Outputs
+- **Training Metrics**: MSE is displayed as a quantitative evaluation of the model's predictions.
+- **Visualization**: A scatter plot compares true and predicted values to illustrate performance.
+
+---
+
+## How to Run the Example
+Here is an example of training and evaluating the Gradient Boosting Regressor:
+
+```python
+from GradientBoostingTree import CustomGradientBoostingRegressor
+from sklearn.metrics import mean_squared_error
+
+# Initialize the model
+gbr = CustomGradientBoostingRegressor(n_estimators=50, learning_rate=0.1, max_depth=3)
+
+# Train the model
+gbr.fit(X_train, y_train)
+
+# Make predictions
+y_pred = gbr.predict(X_test)
+
+# Evaluate the model
+mse = mean_squared_error(y_test, y_pred)
+print(f"Mean Squared Error: {mse:.4f}")
+```
+
+---
+
+# QUESTIONS:
+
+1. **What does the model do, and when should it be used?**
+   The model implements Gradient Boosting Regression, a machine learning algorithm for predicting numerical targets. It iteratively trains decision trees to minimize residual errors. This model is ideal for:
+   - Regression problems where high accuracy is needed.
+   - Scenarios with non-linear relationships between features and targets.
+   - Cases where overfitting can be controlled via boosting parameters.
+
+2. **How was the model tested?**
+   The model was tested using:
+   - An 80-20 train-test split on the dataset.
+   - Evaluation of predictions against the ground truth using Mean Squared Error (MSE).
+   - Visualization of true vs. predicted values via scatter plots.
+
+3. **Exposed Parameters for Tuning Performance:**
+   The following parameters are exposed for tuning:
+   - `n_estimators`: Number of boosting iterations (trees).
+   - `learning_rate`: Contribution of each tree to the final prediction.
+   - `max_depth`: Limits the depth of each decision tree, controlling overfitting.
+
+4. **Troublesome Inputs and Possible Solutions:**
+   The model may struggle with:
+   - **High-dimensional data**: Training time increases significantly with many features.
+     - *Solution*: Use dimensionality reduction techniques like PCA.
+   - **Outliers**: Sensitive to outliers in the target variable.
+     - *Solution*: Preprocess the data to remove or handle outliers.
+   - **Imbalanced datasets**: May not handle heavily skewed data distributions well.
+     - *Solution*: Use sampling techniques or modify the loss function.
+   - **Large datasets**: Computationally intensive for large datasets.
+     - *Solution*: Parallelize the implementation or use distributed frameworks.
+
+---
diff --git a/small_test.csv b/small_test.csv
new file mode 100644
index 0000000..12a8455
--- /dev/null
+++ b/small_test.csv
@@ -0,0 +1,51 @@
+x_0,x_1,x_2,y
+-2.421348566501347,6.290215260063935,2.516304163087373,10.240119830146476
+8.13465811997068,-6.975968662410185,-3.2810945459842866,-6.8962940548446845
+-0.4531238994261493,0.05889462611191654,-3.592293253611172,14.10428803155231
+3.979832584128687,-8.129001764124755,9.202914789330517,-43.788867687445624
+-4.354231825431758,2.4724749171156333,8.45972163584499,-12.067617018047834
+8.726620980175113,-9.607722575405269,-5.092837184080405,-8.265643240683891
+-0.29136484802189955,8.224663789274086,-3.8193339707565555,32.98185595386334
+1.4118708853910462,6.003042800612462,3.9968255952773095,0.7267789346532836
+0.21525181834957507,-3.321041549359367,-5.352746248495515,11.93444109619503
+4.80226153299567,9.818246112545182,4.936296097738831,3.5995719453822046
+9.71733974143089,0.1440918710436101,8.74993701189404,-34.917122745540794
+4.098687611436789,-9.75205878861841,7.980744101999381,-43.32805584620358
+-2.398060521804659,2.8278192128541733,-1.626174948927721,16.91539285950553
+5.398272903061114,7.583046908728093,2.758295974535457,4.437457748228852
+3.371527871466675,-5.430064318728407,2.1915998058530857,-16.03565826569788
+2.0863644528269365,0.10824916542728857,8.144465640869694,-25.094326089867696
+2.8255940202840684,-2.286321234798363,4.771241059098381,-18.000440202657604
+-8.150227640024978,-4.259315052105519,1.8923353680502952,-1.3930242667026356
+-6.067265316809651,3.6776254617776942,8.4817269440159,-10.278522746897893
+8.64017362219969,9.717801217085075,4.980672567111553,-0.9266647796977245
+-4.636910653452324,0.9373715699813872,4.978170771263397,-3.8217233698137143
+-7.940395120999431,2.953441321061362,-0.9370552302607145,21.291726783530805
+7.692709298116139,-5.485844206553388,-6.019643260327971,2.1873435652525455
+-6.485086441297707,7.06589989184231,-8.842925435171665,50.35981404591074
+5.036321300769028,2.0420739888497152,-4.368234397412891,15.435100617505809
+-2.203566631709222,-6.141030616852454,-1.822186931753599,-0.5890454529472771
+3.2620868350599768,7.851306022896178,-4.479265977335616,27.896949611024628
+6.402611257683294,-4.018677430646336,0.48600102750762986,-12.289355696825485
+5.378501224056757,4.355667003325474,-7.565417868242747,31.017195148404717
+2.0486633392332614,8.253411759540757,-3.966950647644751,29.555547834722987
+2.626017326894857,3.314924154867276,9.810418858378235,-22.85112181951592
+-0.04750452520510429,5.935777040113393,-0.3470621837504506,16.516617979443822
+-6.775500897482147,-0.8747563332852692,-2.758815934335188,16.55155644731519
+-5.130765599150095,8.959898235120185,1.1701541118251235,22.753375944830324
+9.607901921761815,-9.108821424255002,5.524296399378377,-41.93781490943017
+-2.9201254899877434,5.134928295361929,-9.896226148902585,43.58829658171542
+6.956501039100711,0.8359369151964895,-6.1636372998431295,16.225403196517274
+7.725179239543149,-4.913104095867496,-1.110476120153832,-9.936035489824537
+-6.142683379729563,1.4244393989902058,1.8529074318076262,5.554396424524908
+-2.0474061706133977,-1.2170618863263076,8.899325908803291,-23.596187786238964
+9.359523403637155,3.4124788823300065,-1.4222946765509725,2.4507844709064064
+-8.642800876507275,-9.508822574677566,2.9901775243378577,-16.775543378589024
+-2.470992582133973,5.1672327675732195,-8.753045094764744,40.855147394263106
+-7.756097982925145,5.227601844332813,-3.179199348468109,30.739018818654756
+5.393783291304004,-1.5186710515725927,-7.469139234639499,17.503383657767756
+-7.644671911438172,1.8115363641056241,-6.167155079348694,33.57677356652164
+6.557442460132911,-4.44188855380612,-6.368621306151785,7.435670420087931
+0.21009363927752744,-2.719754693698011,1.0885820356480096,-6.289562485886653
+-8.571672299069252,8.890348599509473,5.468260371802332,15.412904086362603
+7.872454219630789,-3.9905860234116357,0.9068940749874717,-16.017543419998542

From 385c094d721cacc6c97ee200a21d4b94bc92cc9d Mon Sep 17 00:00:00 2001
From: NaveedMohiuddin <naveed.mohiuddin.1234@gmail.com>
Date: Thu, 21 Nov 2024 23:22:01 -0600
Subject: [PATCH 2/5] ML-Project2

---
 BoostingTrees/evaluate_model.ipynb | 260 ++++++++++++++++-------------
 1 file changed, 141 insertions(+), 119 deletions(-)

diff --git a/BoostingTrees/evaluate_model.ipynb b/BoostingTrees/evaluate_model.ipynb
index ba72899..9c2d668 100644
--- a/BoostingTrees/evaluate_model.ipynb
+++ b/BoostingTrees/evaluate_model.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -11,7 +11,15 @@
     "import matplotlib.pyplot as plt\n",
     "from sklearn.ensemble import GradientBoostingRegressor\n",
     "from sklearn.metrics import mean_squared_error, r2_score\n",
-    "from GradientBoostingTree import CustomGradientBoostingRegressor  # Import the custom model\n",
+    "from GradientBoostingTree import CustomGradientBoostingRegressor  # Import the custom model\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
     "# Multiple types of data generating functions\n",
     "def generate_linear_data(n_samples=100, noise=0.1):\n",
@@ -38,8 +46,15 @@
     "    X = np.random.rand(n_samples, 1) * 10\n",
     "    y = 3 * X.squeeze() + 7\n",
     "    X[np.random.choice(n_samples, size=10), 0] = np.nan  # Introduce NaNs\n",
-    "    return X, y\n",
-    "\n",
+    "    return X, y\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "# Custom train-test split function\n",
     "def custom_train_test_split(X, y, test_size=0.2, random_state=None):\n",
     "    if random_state is not None:\n",
@@ -55,8 +70,15 @@
     "    X_train, X_test = X[train_indices], X[test_indices]\n",
     "    y_train, y_test = y[train_indices], y[test_indices]\n",
     "\n",
-    "    return X_train, X_test, y_train, y_test\n",
-    "\n",
+    "    return X_train, X_test, y_train, y_test\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
     "#Method for evaluating both custom and SK learn models\n",
     "def evaluate_model(custom_model, sklearn_model, X_test, y_test):\n",
@@ -150,118 +172,118 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration 1/100, Loss: 153.8706\n",
-      "Iteration 2/100, Loss: 125.5954\n",
-      "Iteration 3/100, Loss: 102.5517\n",
-      "Iteration 4/100, Loss: 83.8278\n",
-      "Iteration 5/100, Loss: 68.5453\n",
-      "Iteration 6/100, Loss: 56.1805\n",
-      "Iteration 7/100, Loss: 46.0846\n",
-      "Iteration 8/100, Loss: 37.9147\n",
-      "Iteration 9/100, Loss: 31.2559\n",
-      "Iteration 10/100, Loss: 25.8514\n",
-      "Iteration 11/100, Loss: 21.4720\n",
-      "Iteration 12/100, Loss: 17.8970\n",
-      "Iteration 13/100, Loss: 14.9824\n",
-      "Iteration 14/100, Loss: 12.6188\n",
-      "Iteration 15/100, Loss: 10.6983\n",
-      "Iteration 16/100, Loss: 9.1259\n",
-      "Iteration 17/100, Loss: 7.8571\n",
-      "Iteration 18/100, Loss: 6.8158\n",
-      "Iteration 19/100, Loss: 5.9717\n",
-      "Iteration 20/100, Loss: 5.2845\n",
-      "Iteration 21/100, Loss: 4.7216\n",
-      "Iteration 22/100, Loss: 4.2636\n",
-      "Iteration 23/100, Loss: 3.8894\n",
-      "Iteration 24/100, Loss: 3.5838\n",
-      "Iteration 25/100, Loss: 3.3302\n",
-      "Iteration 26/100, Loss: 3.1255\n",
-      "Iteration 27/100, Loss: 2.9496\n",
-      "Iteration 28/100, Loss: 2.8052\n",
-      "Iteration 29/100, Loss: 2.6796\n",
-      "Iteration 30/100, Loss: 2.5598\n",
-      "Iteration 31/100, Loss: 2.4748\n",
-      "Iteration 32/100, Loss: 2.3750\n",
-      "Iteration 33/100, Loss: 2.3048\n",
-      "Iteration 34/100, Loss: 2.2361\n",
-      "Iteration 35/100, Loss: 2.1861\n",
-      "Iteration 36/100, Loss: 2.1348\n",
-      "Iteration 37/100, Loss: 2.0884\n",
-      "Iteration 38/100, Loss: 2.0460\n",
-      "Iteration 39/100, Loss: 1.9860\n",
-      "Iteration 40/100, Loss: 1.9370\n",
-      "Iteration 41/100, Loss: 1.9041\n",
-      "Iteration 42/100, Loss: 1.8706\n",
-      "Iteration 43/100, Loss: 1.8410\n",
-      "Iteration 44/100, Loss: 1.8194\n",
-      "Iteration 45/100, Loss: 1.7805\n",
-      "Iteration 46/100, Loss: 1.7565\n",
-      "Iteration 47/100, Loss: 1.7287\n",
-      "Iteration 48/100, Loss: 1.6938\n",
-      "Iteration 49/100, Loss: 1.6761\n",
-      "Iteration 50/100, Loss: 1.6541\n",
-      "Iteration 51/100, Loss: 1.6302\n",
-      "Iteration 52/100, Loss: 1.6113\n",
-      "Iteration 53/100, Loss: 1.5954\n",
-      "Iteration 54/100, Loss: 1.5759\n",
-      "Iteration 55/100, Loss: 1.5624\n",
-      "Iteration 56/100, Loss: 1.5362\n",
-      "Iteration 57/100, Loss: 1.5195\n",
-      "Iteration 58/100, Loss: 1.5038\n",
-      "Iteration 59/100, Loss: 1.4894\n",
-      "Iteration 60/100, Loss: 1.4822\n",
-      "Iteration 61/100, Loss: 1.4693\n",
-      "Iteration 62/100, Loss: 1.4499\n",
-      "Iteration 63/100, Loss: 1.4325\n",
-      "Iteration 64/100, Loss: 1.4206\n",
-      "Iteration 65/100, Loss: 1.4022\n",
-      "Iteration 66/100, Loss: 1.3889\n",
-      "Iteration 67/100, Loss: 1.3803\n",
-      "Iteration 68/100, Loss: 1.3673\n",
-      "Iteration 69/100, Loss: 1.3522\n",
-      "Iteration 70/100, Loss: 1.3419\n",
-      "Iteration 71/100, Loss: 1.3355\n",
-      "Iteration 72/100, Loss: 1.3182\n",
-      "Iteration 73/100, Loss: 1.2947\n",
-      "Iteration 74/100, Loss: 1.2896\n",
-      "Iteration 75/100, Loss: 1.2767\n",
-      "Iteration 76/100, Loss: 1.2684\n",
-      "Iteration 77/100, Loss: 1.2644\n",
-      "Iteration 78/100, Loss: 1.2539\n",
-      "Iteration 79/100, Loss: 1.2471\n",
-      "Iteration 80/100, Loss: 1.2439\n",
-      "Iteration 81/100, Loss: 1.2190\n",
-      "Iteration 82/100, Loss: 1.2037\n",
-      "Iteration 83/100, Loss: 1.2010\n",
-      "Iteration 84/100, Loss: 1.1927\n",
-      "Iteration 85/100, Loss: 1.1860\n",
-      "Iteration 86/100, Loss: 1.1791\n",
-      "Iteration 87/100, Loss: 1.1770\n",
-      "Iteration 88/100, Loss: 1.1632\n",
-      "Iteration 89/100, Loss: 1.1532\n",
-      "Iteration 90/100, Loss: 1.1420\n",
-      "Iteration 91/100, Loss: 1.1279\n",
-      "Iteration 92/100, Loss: 1.1225\n",
-      "Iteration 93/100, Loss: 1.1192\n",
-      "Iteration 94/100, Loss: 1.1101\n",
-      "Iteration 95/100, Loss: 1.1021\n",
-      "Iteration 96/100, Loss: 1.0968\n",
-      "Iteration 97/100, Loss: 1.0894\n",
-      "Iteration 98/100, Loss: 1.0827\n",
-      "Iteration 99/100, Loss: 1.0735\n",
-      "Iteration 100/100, Loss: 1.0672\n"
+      "Iteration 1/100, Loss: 157.8390\n",
+      "Iteration 2/100, Loss: 128.7378\n",
+      "Iteration 3/100, Loss: 105.1316\n",
+      "Iteration 4/100, Loss: 85.9653\n",
+      "Iteration 5/100, Loss: 70.4030\n",
+      "Iteration 6/100, Loss: 57.6884\n",
+      "Iteration 7/100, Loss: 47.4053\n",
+      "Iteration 8/100, Loss: 39.0152\n",
+      "Iteration 9/100, Loss: 32.1936\n",
+      "Iteration 10/100, Loss: 26.6566\n",
+      "Iteration 11/100, Loss: 22.1283\n",
+      "Iteration 12/100, Loss: 18.4608\n",
+      "Iteration 13/100, Loss: 15.4643\n",
+      "Iteration 14/100, Loss: 13.0125\n",
+      "Iteration 15/100, Loss: 11.0303\n",
+      "Iteration 16/100, Loss: 9.4086\n",
+      "Iteration 17/100, Loss: 8.0930\n",
+      "Iteration 18/100, Loss: 7.0232\n",
+      "Iteration 19/100, Loss: 6.1486\n",
+      "Iteration 20/100, Loss: 5.4342\n",
+      "Iteration 21/100, Loss: 4.8531\n",
+      "Iteration 22/100, Loss: 4.3772\n",
+      "Iteration 23/100, Loss: 3.9933\n",
+      "Iteration 24/100, Loss: 3.6770\n",
+      "Iteration 25/100, Loss: 3.4047\n",
+      "Iteration 26/100, Loss: 3.1873\n",
+      "Iteration 27/100, Loss: 3.0011\n",
+      "Iteration 28/100, Loss: 2.8520\n",
+      "Iteration 29/100, Loss: 2.7129\n",
+      "Iteration 30/100, Loss: 2.6055\n",
+      "Iteration 31/100, Loss: 2.5052\n",
+      "Iteration 32/100, Loss: 2.4173\n",
+      "Iteration 33/100, Loss: 2.3478\n",
+      "Iteration 34/100, Loss: 2.2826\n",
+      "Iteration 35/100, Loss: 2.2179\n",
+      "Iteration 36/100, Loss: 2.1668\n",
+      "Iteration 37/100, Loss: 2.1287\n",
+      "Iteration 38/100, Loss: 2.0766\n",
+      "Iteration 39/100, Loss: 2.0420\n",
+      "Iteration 40/100, Loss: 2.0138\n",
+      "Iteration 41/100, Loss: 1.9893\n",
+      "Iteration 42/100, Loss: 1.9496\n",
+      "Iteration 43/100, Loss: 1.9240\n",
+      "Iteration 44/100, Loss: 1.9034\n",
+      "Iteration 45/100, Loss: 1.8706\n",
+      "Iteration 46/100, Loss: 1.8312\n",
+      "Iteration 47/100, Loss: 1.7992\n",
+      "Iteration 48/100, Loss: 1.7742\n",
+      "Iteration 49/100, Loss: 1.7585\n",
+      "Iteration 50/100, Loss: 1.7272\n",
+      "Iteration 51/100, Loss: 1.7087\n",
+      "Iteration 52/100, Loss: 1.6914\n",
+      "Iteration 53/100, Loss: 1.6706\n",
+      "Iteration 54/100, Loss: 1.6313\n",
+      "Iteration 55/100, Loss: 1.6158\n",
+      "Iteration 56/100, Loss: 1.5967\n",
+      "Iteration 57/100, Loss: 1.5807\n",
+      "Iteration 58/100, Loss: 1.5626\n",
+      "Iteration 59/100, Loss: 1.5492\n",
+      "Iteration 60/100, Loss: 1.5177\n",
+      "Iteration 61/100, Loss: 1.5056\n",
+      "Iteration 62/100, Loss: 1.4801\n",
+      "Iteration 63/100, Loss: 1.4516\n",
+      "Iteration 64/100, Loss: 1.4419\n",
+      "Iteration 65/100, Loss: 1.4248\n",
+      "Iteration 66/100, Loss: 1.4123\n",
+      "Iteration 67/100, Loss: 1.4044\n",
+      "Iteration 68/100, Loss: 1.3838\n",
+      "Iteration 69/100, Loss: 1.3609\n",
+      "Iteration 70/100, Loss: 1.3443\n",
+      "Iteration 71/100, Loss: 1.3379\n",
+      "Iteration 72/100, Loss: 1.3299\n",
+      "Iteration 73/100, Loss: 1.2995\n",
+      "Iteration 74/100, Loss: 1.2943\n",
+      "Iteration 75/100, Loss: 1.2840\n",
+      "Iteration 76/100, Loss: 1.2700\n",
+      "Iteration 77/100, Loss: 1.2597\n",
+      "Iteration 78/100, Loss: 1.2514\n",
+      "Iteration 79/100, Loss: 1.2449\n",
+      "Iteration 80/100, Loss: 1.2311\n",
+      "Iteration 81/100, Loss: 1.2244\n",
+      "Iteration 82/100, Loss: 1.2160\n",
+      "Iteration 83/100, Loss: 1.2105\n",
+      "Iteration 84/100, Loss: 1.1969\n",
+      "Iteration 85/100, Loss: 1.1857\n",
+      "Iteration 86/100, Loss: 1.1790\n",
+      "Iteration 87/100, Loss: 1.1745\n",
+      "Iteration 88/100, Loss: 1.1654\n",
+      "Iteration 89/100, Loss: 1.1538\n",
+      "Iteration 90/100, Loss: 1.1465\n",
+      "Iteration 91/100, Loss: 1.1412\n",
+      "Iteration 92/100, Loss: 1.1357\n",
+      "Iteration 93/100, Loss: 1.1298\n",
+      "Iteration 94/100, Loss: 1.1238\n",
+      "Iteration 95/100, Loss: 1.1204\n",
+      "Iteration 96/100, Loss: 1.1062\n",
+      "Iteration 97/100, Loss: 1.0983\n",
+      "Iteration 98/100, Loss: 1.0939\n",
+      "Iteration 99/100, Loss: 1.0890\n",
+      "Iteration 100/100, Loss: 1.0847\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 2 Axes>"
       ]
@@ -275,17 +297,17 @@
      "text": [
       "\n",
       "Custom Model Performance:\n",
-      "Mean Squared Error: 7.4155\n",
-      "R-Squared: 0.9662\n",
+      "Mean Squared Error: 6.9875\n",
+      "R-Squared: 0.9721\n",
       "\n",
       "Sklearn Model Performance:\n",
-      "Mean Squared Error: 6.5688\n",
-      "R-Squared: 0.9700\n"
+      "Mean Squared Error: 6.3102\n",
+      "R-Squared: 0.9748\n"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+cAAAIjCAYAAABh8GqqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8p0lEQVR4nO3deVxU9f7H8feA7AKmaC6YG5qQhgjZTcsst2y1bsvNyuW2Z6tZab9yKzVbbTXbTCtv3bLttnj1ZrZaGaJW4oIpirgRNigIAnN+f5xmdGRxBgbOMLyejwePYb7nO2c+M5w5zOd8N5thGIYAAAAAAIBlgqwOAAAAAACAxo7kHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHADQoEyZMkU2m82jujabTVOmTKnTeAYMGKABAwbU6XMcrT5eFxqurVu3ymaz6fXXX/f6scuXL5fNZtPy5ct9HhcAoHok5wCAGnn99ddls9lcP02aNFG7du00evRo7dixw+rwGhxnQuX8CQ4O1gknnKCLL75Yq1ev9slzrFu3TlOmTNHWrVt9sr/KbN68WTfeeKM6d+6s8PBwxcTEqF+/fnr66ad18ODBOnnOhQsXavbs2XWy79pwXkgKCgrS9u3bK2wvKChQRESEbDabbr31VgsiBAD4E5JzAECtTJs2TW+88YZefPFFDRs2TG+++abOPPNMFRcX18nzPfDAA3WW5PmDK6+8Um+88YZee+01jRgxQsuWLdPf/vY3nyTo69at09SpU+ssOf/000/Vs2dP/fvf/9YFF1ygZ599VjNnztQJJ5yge+65R3fccUedPK+/JudOYWFh+te//lWh/P3337cgGgCAv2pidQAAgIZt2LBhSktLkyRdd911iouL06xZs/Txxx/r8ssv9/nzNWnSRE2aBO6/r969e+vqq6923e/Xr58uvPBCzZkzR3PnzrUwsupt2bJF//jHP9ShQwctW7ZMbdq0cW0bO3assrKy9Omnn1oYoXXOPfdc/etf/9K9997rVr5w4UKdd955WrRokUWRAQD8CS3nAACfOuOMMySZ3ZuPtH79el166aVq3ry5wsPDlZaWpo8//titTmlpqaZOnaquXbsqPDxcLVq00Omnn66lS5e66lQ25rykpER33XWXWrZsqejoaF144YXKycmpENvo0aPVsWPHCuWV7XPevHk6++yz1apVK4WFhSkpKUlz5szx6D149tlnddJJJykyMlLHHXec0tLStHDhQo8ee7Szzz5bkpn8VicjI0PDhg1TTEyMmjZtqoEDB+qHH35wbX/99dd12WWXSZLOOussV/d5X40tfvTRR3XgwAG9+uqrbom5U0JCgqvlvLox0UePp9+/f7/uvPNOdezYUWFhYWrVqpUGDx6sVatWSTLH/H/66afKzs52vaYj/8Z79uzRtddeq+OPP17h4eFKTk7W/Pnz3Z7TGc/jjz+u559/Xp07d1ZkZKSGDBmi7du3yzAMPfTQQ4qPj1dERIQuuugi5efne/zejBgxQqtXr9b69etdZbt27dKyZcs0YsSISh/jSdyS9Oeff2r06NGKjY1Vs2bNNGrUKP3555+V7tOTzyAAwDqB2/QAALCEs8v0cccd5yr77bff1K9fP7Vr104TJkxQVFSU/v3vf2v48OFatGiRLr74Yklmkjxz5kxdd9116tOnjwoKCvTzzz9r1apVGjx4cJXPed111+nNN9/UiBEj1LdvXy1btkznnXderV7HnDlzdNJJJ+nCCy9UkyZN9J///Ee33HKLHA6Hxo4dW+XjXn75Zd1+++269NJLdccdd6i4uFhr167Vjz/+WGUiVh3nRY4WLVpUWee3337TGWecoZiYGN17770KCQnR3LlzNWDAAH311Vc69dRT1b9/f91+++165plndP/99ysxMVGSXLe19Z///EedO3dW3759fbI/p5tuuknvvfeebr31ViUlJemPP/7Qt99+q8zMTPXu3Vv/93//J7vdrpycHD311FOSpKZNm0qSDh48qAEDBigrK0u33nqrOnXqpHfffVejR4/Wn3/+WaGb/VtvvaVDhw7ptttuU35+vh599FFdfvnlOvvss7V8+XLdd999ysrK0rPPPqvx48frtdde8+g19O/fX/Hx8Vq4cKGmTZsmSXrnnXfUtGnTSo9TT+M2DEMXXXSRvv32W910001KTEzUBx98oFGjRlXYp6efQQCAhQwAAGpg3rx5hiTjf//7n7F3715j+/btxnvvvWe0bNnSCAsLM7Zv3+6qO3DgQKNnz55GcXGxq8zhcBh9+/Y1unbt6ipLTk42zjvvvGqfd/LkycaR/75Wr15tSDJuueUWt3ojRowwJBmTJ092lY0aNcro0KHDMfdpGIZRVFRUod7QoUONzp07u5WdeeaZxplnnum6f9FFFxknnXRSta+hMlu2bDEkGVOnTjX27t1r7Nq1y1i+fLmRkpJiSDIWLVrkqnv06xo+fLgRGhpqbN682VWWm5trREdHG/3793eVvfvuu4Yk48svv/Q6vurY7XZDknHRRRd5VN/5WufNm1dh29GvLTY21hg7dmy1+zvvvPMq/bvOnj3bkGS8+eabrrJDhw4Zp512mtG0aVOjoKDALZ6WLVsaf/75p6vuxIkTDUlGcnKyUVpa6iq/8sorjdDQULfjuTLO42rv3r3G+PHjjYSEBNe2U045xRgzZozrNR/5Gj2N+8MPPzQkGY8++qirXllZmXHGGWdUeH89/Qx++eWXdXKMAACOjW7tAIBaGTRokFq2bKn27dvr0ksvVVRUlD7++GPFx8dLkvLz87Vs2TJdfvnl2r9/v/Ly8pSXl6c//vhDQ4cO1aZNm1yzuzdr1ky//fabNm3a5PHzf/bZZ5Kk22+/3a38zjvvrNXrioiIcP1ut9uVl5enM888U7///rvsdnuVj2vWrJlycnK0cuXKGj3v5MmT1bJlS7Vu3VoDBgzQ5s2bNWvWLF1yySWV1i8vL9eSJUs0fPhwde7c2VXepk0bjRgxQt9++60KCgpqFIunnPuPjo72+b6bNWumH3/8Ubm5uV4/9rPPPlPr1q115ZVXuspCQkJ0++2368CBA/rqq6/c6l922WWKjY113T/11FMlSVdffbXbPAennnqqDh065NWqBCNGjFBWVpZWrlzpuq2qJ4WncX/22Wdq0qSJbr75Zle94OBg3XbbbW778+YzCACwDt3aAQC18vzzz6tbt26y2+167bXX9PXXXyssLMy1PSsrS4Zh6MEHH9SDDz5Y6T727Nmjdu3aadq0abrooovUrVs39ejRQ+ecc46uueYanXzyyVU+f3Z2toKCgtSlSxe38hNPPLFWr+u7777T5MmTtWLFChUVFblts9vtbkncke677z7973//U58+fZSQkKAhQ4ZoxIgR6tevn0fPe8MNN+iyyy5TUFCQmjVrppNOOsnt/Tza3r17VVRUVOnrTUxMlMPh0Pbt23XSSSd59PxOBw8erHARonXr1pXWjYmJkWSOD/e1Rx99VKNGjVL79u2Vmpqqc889VyNHjnS7EFGV7Oxsde3aVUFB7m0Rzq782dnZbuUnnHCC233n37h9+/aVlu/bt8/j15GSkqLu3btr4cKFatasmVq3bu2aT6CmcWdnZ6tNmzaubvxORx8L3nwGAQDWITkHANRKnz59XLO1Dx8+XKeffrpGjBihDRs2qGnTpnI4HJKk8ePHa+jQoZXuIyEhQZI5Nnfz5s366KOPtGTJEr3yyit66qmn9OKLL+q6666rdaxHT/rmVF5e7nZ/8+bNGjhwoLp3764nn3xS7du3V2hoqD777DM99dRTrtdUmcTERG3YsEGffPKJFi9erEWLFumFF17QpEmTNHXq1GPG2LVrVw0aNMi7F1YH3nnnHY0ZM8atzDCMSuvGxMSobdu2+vXXXz3at6d/B0m6/PLLdcYZZ+iDDz7QkiVL9Nhjj2nWrFl6//33NWzYMI+ez1PBwcFelVf1flRlxIgRmjNnjqKjo3XFFVdUSL7rijefQQCAdUjOAQA+ExwcrJkzZ+qss87Sc889pwkTJrhaOENCQjxKOps3b64xY8ZozJgxOnDggPr3768pU6ZUmZx36NBBDodDmzdvdmsx3LBhQ4W6xx13XKUzWR/dgvqf//xHJSUl+vjjj91aU7/88stjxi9JUVFRuuKKK3TFFVfo0KFDuuSSSzR9+nRNnDhR4eHhHu3DUy1btlRkZGSlr3f9+vUKCgpytfxWlRRXZujQoW6z5B/L+eefr5deekkrVqzQaaedVm1d52SBR/8tjv47OLVp00a33HKLbrnlFu3Zs0e9e/fW9OnTXcl5Va+rQ4cOWrt2rRwOh1si7Jw1vUOHDh69Nl8ZMWKEJk2apJ07d+qNN96osp6ncXfo0EFffPGFDhw44NZ6fvSx4O1nEABgDcacAwB8asCAAerTp49mz56t4uJitWrVSgMGDNDcuXO1c+fOCvX37t3r+v2PP/5w29a0aVMlJCSopKSkyudzJmjPPPOMW/ns2bMr1O3SpYvsdrvWrl3rKtu5c6c++OADt3rOltIjW0btdrvmzZtXZRxVvYbQ0FAlJSXJMAyVlpYe8/HeCg4O1pAhQ/TRRx+5ZsqXpN27d2vhwoU6/fTTXd3Oo6KiJFVMiivTpk0bDRo0yO2nOvfee6+ioqJ03XXXaffu3RW2b968WU8//bQks6U9Li5OX3/9tVudF154we1+eXl5ha71rVq1Utu2bd2OiaioqErnATj33HO1a9cuvfPOO66ysrIyPfvss2ratKnOPPPMal+Tr3Xp0kWzZ8/WzJkz1adPnyrreRr3ueeeq7KyMrcl/srLy/Xss8+67c+bzyAAwDq0nAMAfO6ee+7RZZddptdff1033XSTnn/+eZ1++unq2bOnrr/+enXu3Fm7d+/WihUrlJOTozVr1kiSkpKSNGDAAKWmpqp58+b6+eefXctoVaVXr1668sor9cILL8hut6tv37764osvlJWVVaHuP/7xD9133326+OKLdfvtt6uoqEhz5sxRt27dXOtmS9KQIUMUGhqqCy64QDfeeKMOHDigl19+Wa1atao0uTnSkCFD1Lp1a/Xr10/HH3+8MjMz9dxzz+m8886rkwnTJOnhhx/W0qVLdfrpp+uWW25RkyZNNHfuXJWUlOjRRx911evVq5eCg4M1a9Ys2e12hYWFudZyr60uXbpo4cKFuuKKK5SYmKiRI0eqR48eOnTokL7//nvXUmBO1113nR555BFdd911SktL09dff62NGze67XP//v2Kj4/XpZdequTkZDVt2lT/+9//tHLlSj3xxBOueqmpqXrnnXc0btw4nXLKKWratKkuuOAC3XDDDZo7d65Gjx6t9PR0dezYUe+9956+++47zZ49u87+HtU5evm2ynga9wUXXKB+/fppwoQJ2rp1q5KSkvT+++9XeqHC088gAMBCVk4VDwBouJxLqa1cubLCtvLycqNLly5Gly5djLKyMsMwDGPz5s3GyJEjjdatWxshISFGu3btjPPPP9947733XI97+OGHjT59+hjNmjUzIiIijO7duxvTp083Dh065KpT2bJnBw8eNG6//XajRYsWRlRUlHHBBRcY27dvr7Asl2EYxpIlS4wePXoYoaGhxoknnmi8+eable7z448/Nk4++WQjPDzc6NixozFr1izjtddeMyQZW7ZscdU7eim1uXPnGv379zdatGhhhIWFGV26dDHuuecew263V/t+Opfzeuyxx6qtZxgVlxszDMNYtWqVMXToUKNp06ZGZGSkcdZZZxnff/99hce+/PLLRufOnY3g4OA6WTJr48aNxvXXX2907NjRCA0NNaKjo41+/foZzz77rNsyXkVFRca1115rxMbGGtHR0cbll19u7Nmzx+21lZSUGPfcc4+RnJxsREdHG1FRUUZycrLxwgsvuD3ngQMHjBEjRhjNmjUzJLktq7Z7925jzJgxRlxcnBEaGmr07NmzwhJuVb33zmXF3n33Xbfy6o79Ix25lFp1dNRSap7GbRiG8ccffxjXXHONERMTY8TGxhrXXHONkZGRUelSdZ58BllKDQCsYzMML2czAQAAAAAAPsWYcwAAAAAALEZyDgAAAACAxUjOAQAAAACwGMk5AAAAAAAWIzkHAAAAAMBiJOcAAAAAAFisidUB1CeHw6Hc3FxFR0fLZrNZHQ4AAAAAIMAZhqH9+/erbdu2Cgqqun28USXnubm5at++vdVhAAAAAAAame3btys+Pr7K7Y0qOY+OjpZkvikxMTEWR2MqLS3VkiVLNGTIEIWEhFgdDlBrHNMINBzTCDQc0wg0HNPwdwUFBWrfvr0rH61Ko0rOnV3ZY2Ji/Co5j4yMVExMDCcTBASOaQQajmkEGo5pBBqOaTQUxxpazYRwAAAAAABYjOQcAAAAAACLkZwDAAAAAGAxknMAAAAAACxGcg4AAAAAgMVIzgEAAAAAsBjJOQAAAAAAFiM5BwAAAADAYiTnAAAAAABYjOQcAAAAAACLkZwDAAAAAGAxknMAAAAAACxGcg4AAAAAgMWaWB0AAAAAAABecTikrCzJbpdiY6WEBCmoYbc9k5wDAAAAABqOjAxp/nwpM1MqLpbCw6XERGnUKCklxeroaozkHAAAAADQMGRkSNOmSXl5Uny8FBUlFRZK6elSdrY0aVKDTdAbbLv/I488IpvNpjvvvNPqUAAAAAAAdc3hMFvM8/LMlvKYGCk42LxNTDTLFyww6zVADTI5X7lypebOnauTTz7Z6lAAAAAAAPUhK8vsyh4fL9ls7ttsNrN83TqzXgPU4JLzAwcO6KqrrtLLL7+s4447zupwAAAAAAD1wW43x5hHRVW+PTLS3G63129cPtLgxpyPHTtW5513ngYNGqSHH3642rolJSUqKSlx3S8oKJAklZaWqrS0tE7j9JQzDn+JB6gtjmkEGo5pBBqOaQQajulGpGlTKTpaKikxu7IfrajI3N60qeRHx4Onx6bNMAyjjmPxmbffflvTp0/XypUrFR4ergEDBqhXr16aPXt2pfWnTJmiqVOnVihfuHChIiMj6zhaAAAAAEBjV1RUpBEjRshutyumsosKf2kwyfn27duVlpampUuXusaaHys5r6zlvH379srLy6v2TalPpaWlWrp0qQYPHqyQkBCrw0FDs3attHChtGGDeQUxLEw68URpxAjJojkZOKYRaDimEWg4phFoOKZryeGQfv9dKigwW6M7d/bv9cLXrpVmzZL++ENq29bsyl5UJOXmSi1aSPfdZ9n34KoUFBQoLi7umMl5g+nWnp6erj179qh3796usvLycn399dd67rnnVFJSouDgYLfHhIWFKSwsrMK+QkJC/O6D648xwc9lZEgPP3x4GYnWrc1lJH76yTzBWryMBMc0Ag3HNAINxzQCDcd0DTTE9cJTU6WJEyvGffLJ0siRfhm3p8dlg0nOBw4cqF9++cWtbMyYMerevbvuu+++Cok5ENCOXkbCOVulcxmJzExzGYnkZP++8gkAAABrNOT1wlNSzO+5WVnm5G+xsVJCQoP/3ttgkvPo6Gj16NHDrSwqKkotWrSoUA4EPG+WkejWzZoYAQAA4J8CoaEnKCjgvuf66TsNoFoBvowEAAAA6lCArxfeUDWYlvPKLF++3OoQAGvExppjawoLq15GIjzcrAcAAAAcyZOGntxcGnrqGS3nQEOUkGB2OcrJkY5ecMEwzPKkJLMeAAAAcKQjG3oqQ0OPJUjOAX/gcEgbN0orV5q3Dkf19YOCzFk04+LMLkkFBVJZmXmbmWmWjxzpv2OEAAAAYB0aevxSg+7WDgSEmi5hkZJizqLpfGxurvnYtDS/XUYCAAAAfsDZ0JOdfXjsuXO98JwcGnosQnIOWKm2S1gE6DISAAAggDkcfHfxBzT0+B2Sc8AqvlrCIgCXkQAAAAGqpj0GUTdo6PErJOeAVVirHAAANCa17TGIukFDj9/gkghgFdYqBwAAjcXRPQZjYqTg4MM9BvPyzB6Dx5oUFwhgJOeAVVjCAgAANBbe9BgEGimSc8AqLGEBAAAaC3oMAsdEcg5YhbXKAQBAY0GPQeCY+NYPWMm5hEVqqpSfb3blys83l7BgUhQAABAo6DEIHBOztQNW83YJC9YGBQAADY2zx2B29uGx55GRZot5Tg49BgGRnAP+wdMlLFgbFAAANFTOHoPO7zK5ueZ3mbQ0MzHnuwwaOZJzoKFgbVAAANDQedtjEGhESM6BhuDotUGdS5A41wbNzDTXBk1O5p8bAADwb572GAQaGb7FAw0Ba4MCAAAAAY3kHGgIWBsUAAAACGgk50BDwNqgAAAAQEAjOQcaAtYGBQAAjZ3DIW3cKK1cad46HFZHBPgUE8IBDQFrgwIAgMasuuVke/SwOjrAJ0jOgYaCtUEBAEBjdKzlZB94wOoIAZ8gOQcaEtYGBQAAjYkny8n+61/SGWdYGyfgAyTnQEPD2qAAAKCx8GQ52fXrSc4REGhuAwAAAOCfPFlOtqSkfmMC6gjJOQAAAAD/5MlysmFh9RsTUEdIzgEAAAD4J0+Wk+3e3ZrYAB8jOQcAAADgn5zLycbFmWPPCwqksjLzNjPTLL/ySqujBHyC5BwAAACA/3IuJ5uaKuXnm5PE5eeby8lOmiSdfLLVEQI+wWztAAAAAPxbdcvJlpZaHR3gEyTnAAAAAPwfy8kiwNGtHQAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYs7UDAAB4w+GofDknAABqgeQcAADAUxkZ0vz5UmamVFwshYdLiYnSqFHmOswAANQQyTkAAIAnMjKkadOkvDwpPl6KipIKC6X0dCk7W5o0iQQdAFBj9MECAAA4FofDbDHPyzNbymNipOBg8zYx0SxfsMCsBwBADZCcAwAAHEtWltmVPT5estnct9lsZvm6dWY9AABqgOQcAADgWOx2c4x5VFTl2yMjze12e/3GBQAIGCTnAAAAxxIba07+VlhY+faiInN7bGz9xgUACBgk5wAAAMeSkGCOLc/JkQzDfZthmOVJSWY9AABqgOQcAADgWIKCzOXS4uLMsecFBVJZmXmbmWmWjxzJeucAgBrjPwgAAIAnUlLM5dJSU6X8fHPyt/x8KS2NZdQAALXGOucAAACeSkmRkpPNxNxuN8eYJyTQYg4AqDWScwAAAG8EBUndulkdBQAgwHCZFwAAAAAAi5GcAwAAAABgMZJzAAAAAAAsxphzAADQcDgcTMYGAAhIJOcAAKBhyMiQ5s831xUvLpbCw6XERHP9cZYxAwA0cCTnAADA/2VkSNOmSXl5Uny8FBUlFRZK6elSdjbrjKPhojcIgL+QnAMAAP/mcJgt5nl5Zku5zWaWx8SY9zMzpQULzPXHSWrQkNAbBMAR+A8GAAD8W1aWmbzExx9OzJ1sNrN83TqzHtBQOHuDpKdLzZtLXbuat+npZnlGhtURAqhnJOcAAMC/2e1mq2JUVOXbIyPN7XZ7/cYF1NTRvUFiYqTg4MO9QfLyzN4gDofVkQKoRyTnAADAv8XGmt19Cwsr315UZG6Pja3fuICaojcIgEqQnAMAAP+WkGC2JubkSIbhvs0wzPKkJLPesTgc0saN0sqV5i0tk7ACvUEAVIIJ4QAAgH8LCjInyMrOPtzaGBlptpjn5EhxcdLIkceeDI7Jt+AvjuwNEhNTcTu9QYBGiZZzAADg/1JSzOXSUlOl/Hyzu29+vpSW5tkyaky+BX/iy94gAAIGLecAAKBhSEkxl0vzdk1olmKDv/FVbxAAAYXkHAAANBxBQVK3bt49xpvJt7zdN1BTzt4gzqEWublmV/a0NDMxZ6gF0OiQnAMAgMDmyeRbublMvoX6V9PeIAACEsk5AAAIbEy+BX9Wk94gAAISl+UAAEBgY/ItAEADQHIOAAACm3Pyrbg4c2xvQYFUVmbeZmYy+RYAwC/wXwgAAAS+2i7FBgBAHWPMOQAAaByYfAsA4McazH+jmTNn6pRTTlF0dLRatWql4cOHa8OGDVaHBfg/h0PauFFaudK8dTisjggArOOcfOuUU8xbEnMAgJ9oMC3nX331lcaOHatTTjlFZWVluv/++zVkyBCtW7dOUVUtjQI0dhkZh9dPLS42ZyNOTDTHXtKFEwAAAPAbDSY5X7x4sdv9119/Xa1atVJ6err69+9f6WNKSkpUUlLiul9QUCBJKi0tVWlpad0F6wVnHP4SDwLI2rXSrFnSH39Ibdua6/sWFkq//CLNnCndd5908sk+f1qOaQQajmkEGo5pBBqOafg7T49Nm2EcvaZIw5CVlaWuXbvql19+UY8ePSqtM2XKFE2dOrVC+cKFCxUZGVnXIQIAAAAAGrmioiKNGDFCdrtdMTExVdZrkMm5w+HQhRdeqD///FPffvttlfUqazlv37698vLyqn1T6lNpaamWLl2qwYMHKyQkxOpw/J/DIf3+u7n8TUyM1Lkz4wUrk5Ul3XOPdNxx5vt0tIICad8+6bHHfL6uL8c0Ag3HNAINxzQCDcc0/F1BQYHi4uKOmZw3mG7tRxo7dqx+/fXXahNzSQoLC1NYWFiF8pCQEL/74PpjTH6H8dOeO3BA2r9fat3aXMv3aKGh5vYDB6Q6Ou44phFoOKYRaDimEWg4puGvPD0uG1xyfuutt+qTTz7R119/rfj4eKvDQX3JyJCmTZPy8qT4+MPjp9PTpexs1qg9WmysefGisLDylvOiInN7bGz9xwYAAACgggbTH9gwDN1666364IMPtGzZMnXq1MnqkFBfHA6zxTwvz2wpj4mRgoPN28REs3zBApYIO1JCgvne5ORIR49cMQyzPCnJ513aAQAAANRMg0nOx44dqzfffFMLFy5UdHS0du3apV27dungwYNWh4a6lpVldmWPj5dsNvdtNptZvm6dWQ+moCCzu39cnPneFRSY3dsLCsz7cXHSyJGM1wcAAAD8RIP5Zj5nzhzZ7XYNGDBAbdq0cf288847VoeGuma3m2PMq1rPPjLS3G63129c/i4lxezun5oq5eebFy/y86W0NIYBAAAAAH6mwYw5b4CTysNXGD9dcykpUnKymZjb7eZ7lJDQeFvMHQ7eCwAAAPilBpOcoxFzjp9OTzdvj+za7hw/nZbG+OmqBAVJ3bpZHYX1mO0fAAAAfozkHP7POX46O/vw2PPISLPFPCeH8dM4Nmb7BwAAgJ8jm0HDwPhp1BSz/QMAAKABoOUcDQfjp1ET3sz2T/d/AAAAWITkHA0L46fhLU9m+8/NZbZ/AAAAWIomRwCB7cjZ/ivDbP8AAADwAyTnAAKbc7b/nBxzdv8jOWf7T0pitn8AAABYim7tAAIbs/1XxHrvAAAAfofkHEDgc87271znPDfX7MqelmYm5o1ptn/WewcAoOHiAntAIzkH0Dgw2z/rvQMA0JBxgT3gkZwDaDwa82z/R6/37lxWzrnee2amud57cnLjumABAEBDwAX2RoFvYADQGHiz3jsAwHsOh7Rxo7RypXnrcFgdEQLF0RfYY2Kk4ODDF9jz8swL7BxzDR4t5wDQGLDeOwDUHboboy55c4G9sfYQDBC0nANAY8B67wBQN5zdjdPTpebNpa5dzdv0dLM8I8PqCNHQeXKBvbiYC+wBgOQcABoD1nsHAN+juzHqAxfYGw2ScwBoDJzrvcfFmV3jCgqksjLzNjOzca73DgC1xXweqA9cYG80+BYGAI2Fc7331FQpP9/8spifb673ziyvAOA9uhujPnCBvdFgQjgAaExY7x0AfOfI7sYxMRW3090YvuK8wO6ceDA31zy20tLMxJwL7AGB5BwAGpvGvN47APiSs7txerp5e2TXdmd347Q0uhvDN7jAHvBIzgEAAICacHY3zs4+PPY8MtJsMc/JobsxfI8L7AGNMwUAAABQU8znAcBHaDkHAAAAaoPuxgB8gOQcAAAAqC26GwOoJS7nAQAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGI1Wkpt27Ztys7OVlFRkVq2bKmTTjpJYWFhvo4NAAAAAIBGwePkfOvWrZozZ47efvtt5eTkyDAM17bQ0FCdccYZuuGGG/T3v/9dQUE0yAMAAAAA4CmPsujbb79dycnJ2rJlix5++GGtW7dOdrtdhw4d0q5du/TZZ5/p9NNP16RJk3TyySdr5cqVdR03AAAAAAABw6OW86ioKP3+++9q0aJFhW2tWrXS2WefrbPPPluTJ0/W4sWLtX37dp1yyik+DxYAAAAAgEDkUXI+c+ZMj3d4zjnn1DgYAAAAAAAaoxpNCIdGxuGQsrIku12KjZUSEiTmFQAAAAAAn/EoOU9JSZHNZvNoh6tWrapVQPAzGRnS/PlSZqZUXCyFh0uJidKoUVJKitXRAQAAAEBA8Cg5Hz58uOv34uJivfDCC0pKStJpp50mSfrhhx/022+/6ZZbbqmTIGGRjAxp2jQpL0+Kj5eioqTCQik9XcrOliZNIkEHAAAAAB/wKDmfPHmy6/frrrtOt99+ux566KEKdbZv3+7b6GAdh8NsMc/LM1vKnT0nYmLM+5mZ0oIFUnIyXdwBAAAAoJa8zqreffddjRw5skL51VdfrUWLFvkkKPiBrCwzAY+PP5yYO9lsZvm6dWY9AAAAAECteJ2cR0RE6LvvvqtQ/t133yk8PNwnQcEP2O3mGPOoqMq3R0aa2+32+o0LAAAAAAKQ17O133nnnbr55pu1atUq9enTR5L0448/6rXXXtODDz7o8wBhkdhYc/K3wkKzK/vRiorM7bGx9R8bAAAAAAQYr5PzCRMmqHPnznr66af15ptvSpISExM1b948XX755T4PEBZJSDDHlqenu485lyTDkHJypLQ0sx4AAAAAoFZqtM755ZdfTiIe6IKCzOXSsrMPjz2PjDRbzHNypLg4aeRIJoMDAAAAAB+oUWb1559/6pVXXtH999+v/Px8Seb65jt27PBpcLBYSoq5XFpqqpSfb07+lp9vtpizjBoAAAAA+IzXLedr167VoEGDFBsbq61bt+q6665T8+bN9f7772vbtm1asGBBXcQJq6SkmMulZWWZk7/Fxppd2WkxBwAAAACf8TrDGjdunEaPHq1Nmza5zc5+7rnn6uuvv/ZpcPATQUFSt27SKaeYtyTmAAAAAOBTXrecr1y5UnPnzq1Q3q5dO+3atcsnQQEAgEbK4aC3FgCgUfI6OQ8LC1NBQUGF8o0bN6ply5Y+CQoAADRCGRnS/PnmRKTFxeaSnYmJ5gSlzHMCAAhwXl+KvvDCCzVt2jSVlpZKkmw2m7Zt26b77rtPf//7330eIAAAaAQyMqRp08wlPJs3l7p2NW/T083yjAyrIwQAoE55nZw/8cQTOnDggFq1aqWDBw/qzDPPVEJCgqKjozV9+vS6iBEAAAQyh8NsMc/LM1vKY2Kk4GDzNjHRLF+wwKwHAP7C4ZA2bpRWrjRvOUehlrzu1h4bG6ulS5fqu+++05o1a3TgwAH17t1bgwYNqov4AABAoMvKMruyx8dLNpv7NpvNLF+3zqzXrZs1MQLAkRiGgzrgdXK+YMECXXHFFerXr5/69evnKj906JDefvttjRw50qcBAgCAAGe3m19uo6Iq3x4ZKeXmmvUAwGrOYTh5eebFw6goqbDQHIaTnS1NmkSCjhrxulv7mDFjZK/kn+P+/fs1ZswYnwQFAAAakdhYs9WpsLDy7UVF5vbY2PqNCwCOxjAc1CGvk3PDMGQ7usuZpJycHMXyTxNoWBgrBcAfJCSYX2pzciTDcN9mGGZ5UpJZDwCs5M0wHMBLHndrT0lJkc1mk81m08CBA9WkyeGHlpeXa8uWLTrnnHPqJEgAdYCxUgD8RVCQee7Jzj78pTcy0mwxz8mR4uKkkSNZ7xyA9RiGgzrkcXI+fPhwSdLq1as1dOhQNW3a1LUtNDRUHTt2ZCk1oKFgrBQAf5OSYp57nBcNc3PNi4ZpaWZizjkJgD84chhOTEzF7QzDQS14nJxPnjxZktSxY0f94x//UFhYWJ0FBaAOHT1WytklyzlWKjPTHCuVnEwrFYD6lZJinnuyssxWp9hYsys75yIA/sI5DCc93f17lHR4GE5aGsNwUCNe/7dLSkrS6tWrK5T/+OOP+vnnn30RE4C6xFgpAP4sKMhcLu2UU8xbEnMA/sQ5DCcuzvw+VVAglZWZt5mZDMNBrXh91IwdO1bbt2+vUL5jxw6NHTvWJ0EBqEOejJUqLmasFAAAQGWcw3BSU6X8fLNBIz/fbDFnaCBqwet1ztetW6fevXtXKE9JSdG6det8EhSAOsRYKQAAgNphGA7qgNdHT1hYmHbv3l2hfOfOnW4zuAPwUyxZBAAAUHsMw4GPeX0EDRkyRBMnTpT9iC6vf/75p+6//34NHjzYp8GhHrDOdePDWCkAAADA73jd1P3444+rf//+6tChg1L+Gk+xevVqHX/88XrjjTd8HiDqEOtcN14sWQQAAAD4Fa+T83bt2mnt2rV66623tGbNGkVERGjMmDG68sorFRISUhcxoi6wzjUYKwUAAAD4jRoNEo+KitINN9zg61hQX1jnGk7OsVIAAAAALOVRcv7xxx9r2LBhCgkJ0ccff1xt3QsvvNAngaEOebPONYkbAACoTw4HvboANEoeJefDhw/Xrl271KpVKw0fPrzKejabTeXl5b6KDXXFk3Wuc3OtXeeaf8wAADQ+zIcDoBHzKDl3HDGDt8Pi2byff/55PfbYY9q1a5eSk5P17LPPqk+fPpbG1OD4+zrX/GMGAKDxYT4cAI1cg2qKfOeddzRu3DhNnjxZq1atUnJysoYOHao9e/ZYHVrD4s/rXDv/MaenS82bS127mrfp6WZ5Rkb9xwQAAOrW0fPhxMRIwcGH58PJyzPnw2HJVwABzKOW82eeecbjHd5+++01DuZYnnzySV1//fUaM2aMJOnFF1/Up59+qtdee00TJkzweD+FhYUKDg6uUB4cHKzw8HC3elUJCgpSREREjeoWFRXJ+CspLi0tVXFxsQoLCxUSEiKbzabIyMhK6x7t6LoHDx6stmdDlLMbe1CQDl5xhRybN0u//iq1aydFREgHD0o7dkgtWijqiHWui4uLqx2uEHVE9/hj1Y2MjJTtr3HuJSUlKisrO7zR4ZBeeUXavVs68URF/vV+KCZGJd26qSwzU3r1VWnmzApd3CMiIhT0V9mhQ4dUWlpaZQze1A0PD3cdK97ULS0t1aFDh6qsGxYWpiZNmnhdt6ysTCUlJVXWDQ0Nda2a4E3d8vJyFRcXV1k3JCREoaGhHtU9ksPh0MGDBz3a77HqNmnSRGFhYZIkwzBUVFTkk7refO6tOEccrV7OEV7WrbdzRC3q1uYcUVRU5HaePhLnCJM35whvPvecIyqvW9tzhPO7R1FRkWKP6CVn6Tnir/lwitu0UXlln+XWraW1axW5aZNsJ54oyX/OEXyP8J9zRGXnaSfOESa+R9Ssbm3PEdX9/dwYHujYsaPbT1RUlGGz2YzjjjvOOO644wybzWZERUUZnTp18mR3NVJSUmIEBwcbH3zwgVv5yJEjjQsvvLDSxxQXFxt2u931s337dkNSlT/Dhg0zDh065PqJjIyssm7//v3d6sbFxVVZNzU11a1uhw4dqqybmJjoVjcxMbHKuh06dHCrm5qaWmXduLg4t7r9+/evsm5keLhb3WHDhlX7vh1Z95JLLqm27r59+1x1r7nmmmrr7hgzxjh0yy3GoVtuMW7q0aPauhs3bnTtd9y4cdXWzcjIcNV94IEHqq37/fffu+rOnDmz2rpLly511X366aerrfvhhx+66r7yyivV1l24cKGr7sKFC6ut+8orr7jqfvjhh9XWffrpp111ly5dWm3dmTNnuup+//331da9//77jQ8//NAoLCw0MjIyqq07btw41343btxYbd2bbrrJVXfHjh3V1r3mmmtcdfft21dt3UsuucTtGK6uLucI8ycyMtI/zhE7drjq3nTTTdXW5Rxh/vjDOeKBBx5w1eUcYe054oQTTvCfc8QPPxiHBg0yLuncudq6+778knOEOEc4f5zniMLCQmPu3LnV1uUcYf7wPeLwjxXnCLvdXm3O61HL+ZYtW1y/L1y4UC+88IJeffVVnfjXlcsNGzbo+uuv14033ujJ7mokLy9P5eXlOv74493Kjz/+eK1fv77Sx8ycOVNTp071+Dn27Nmjzz77zHW/uqsyf/zxh1vdQ9VcsbTb7W51q7v6duDAAbe6Bw4cqLJuUVGRW117NRO4HTp0yK3uH3/8UWXdcsNwq3usYQNH1t21a1e1df/73/+6rhjm5ORUW/d/Awa4ruhnb9litvJX4csvv3QdG7///nu1+/3mm2+UnZ0tSdq0aVO1db/77jvX66/qOHP64YcfXFfFfvvtt2rr/vzzz67f16xZU23djIwM11XLjGN061+zZo3r73Hkc1Tmt99+c9X95Zdfqq27fv16V91jvWebN29Wnz59tHTpUm3btq3aur///rtrv7t37662bnZ2tqtudce6ZB5bzrrHauXftWuX2zFcHc4RpvLycv84R/zvf4fPEX99pqvCOeLwvqw+R2zatMlVl3OEteeIgwcP+tc54tZbtevRR6VqPqP/3b1b4X/V5xxh4hzh2eeTc4SJ7xGH+cM54mg2w6iiH0MVunTpovfee08pR03IkZ6erksvvdQtkfel3NxctWvXTt9//71OO+00V/m9996rr776Sj/++GOFx5SUlLh1xykoKFD79u2VnZ2tmEomQrOqW/uyZct09tln11+3di/r1ltXk82bpf/7P+m446ToaEU2aXK4bnm5yux2ad8+afp0qUsXt/3SHc3kD93RJOmrr77S4MGDFRwcTJfVGtSlO5p/dUcrKipyO08fiXOEiW7t3te1ulv7smXLNHDgQP/p1u5wSPffr+L0dJV37eq+1KthSJs2ScnJipw1S7a/Pkf+co7ge4T154jS0lL997//1emnn063dvE9wt++R5SWlqqgoEAdOnSQ3W6vNA918qjl/Eg7d+6sNPDy8vJjXtWujbi4OAUHB1d4jt27d6t169aVPiYsLMz1wTpSs2bNqn1TjqznKW/qHvmPsLS0VOHh4WrWrFmlJ5PYqmZMr2SpsRAPXpNTVScuS+umpEjdu5uTvyUmSkd88EKcE9WlpZn1qllWzV9e25EnM1/WPfLk68u6R/6zqE1d58kqJCREISEhlX4Gq+JNXec/bl/XravPfU3PEb6s6y+fjYZWNzQ0tNrzdE3321jPEUfjHOF93dqeI5zfPWJjY92OW8s/c1dfrZDff5fWrzdna4+MNFeQycmR4uKk0aPNFVz8Jd46rss5wuTp5z4oKOiY5+kjcY7wvq6/fDYaYt2ganKXI3k9W/vAgQN14403atWqVa6y9PR03XzzzRo0aJC3u/NYaGioUlNT9cUXX7jKHA6HvvjiC7eW9EYhI0MaN0667TZp/Hjzdty4hj+TeVCQuVxaXJy5jFpBgVRWZt5mZprlR0xUBwAAAkhKirlcWmqqlJ9vNkLk55sX5llGDUAj4HXL+WuvvaZRo0YpLS3NrdvL0KFD9corr/g8wCONGzfO9dx9+vTR7NmzVVhY6Jq9vVEI9DVAnf+Yneuc5+aaV8nT0szEvCG/NgAAUL2UFCk5uULvQC7MA2gMvE7OW7Zsqc8++0wbN250TWzRvXt3devWzefBHe2KK67Q3r17NWnSJO3atUu9evXS4sWLK0wSF7COXgPUOR7LuQZoZqa5BmhycsP+J8Y/ZgAAGq+gIKkevlcCgL/xOjl36tixowzDUJcuXVyTTNSHW2+9Vbfeemu9PZ9f+WsNUMXHu0+UIpn34+OldevMeg39nxr/mAEAAAA0Il43RRYVFenaa69VZGSkTjrpJNcSB7fddpseeeQRnweII9jtUnGx2ZW9MpGR5vZjLA8BAAD8iMMhbdworVxp3lYzwzEAIHB5nZxPnDhRa9as0fLly91mWhw0aJDeeecdnwaHo8TGmuOvq1pKoajI3O7FrIsAAMBCgTrJKwDAa14n5x9++KGee+45nX766a514STppJNO0ubNm30aHI6SkGCOLc/JMdf8PJJzqbGkJLMeAADwb85JXtPTpebNpa5dzdv0dLOcBB0AGhWvk/O9e/eqVatWFcoLCwvdknXUAZYaAwAgMBw9yWtMjBQcfHiS17w8c5JXurgDQKPhdRaXlpamTz/91HXfmZC/8sorjW+9cSuwBigAAA2fN5O8AgAaBa+nWZ8xY4aGDRumdevWqaysTE8//bTWrVun77//Xl999VVdxIijsdQYAH/hcHAuAmrCk0lec3OZ5BUAGhGvk/PTTz9da9as0cyZM9WzZ08tWbJEvXv31ooVK9SzZ8+6iBGVYakxAFbLyDC75WZmmklGeLjZHXfUKHrxAMdy5CSvMTEVtzPJKwA0Ol4l56Wlpbrxxhv14IMP6uWXX66rmAAA/s45kVVentn9NirKTDLS06XsbIbZAMfinOQ1Pd28PbJru3OS17Q0JnkFgEbEq76HISEhWrRoUV3FAgBoCJjICqg9JnkFABzF6zP+8OHD9eGHH9ZBKACABoGJrADfYJJXAMARvB5z3rVrV02bNk3fffedUlNTFXXURCa33367z4IDAPghJrICfIdJXgEAf/E6OX/11VfVrFkzpaenKz093W2bzWYjOQeAQMdEVoBvMckrAEA1SM63bNlSF3EAABoKJrICAKDxYNnUeuNVcv7DDz/oP//5jw4dOqSBAwfqnHPOqau4AAD+yjmRVXb24bHnkZFmi3lODhNZAQAQKFg2tV55nJy/9957uuKKKxQREaGQkBA9+eSTmjVrlsaPH1+X8QEA/JFzIivnP+zcXPMfdlqamZjzDxsAgIaNZVPrncfJ+cyZM3X99dfr+eefV3BwsGbOnKkZM2aQnANAY8VEVgAABKajl011DmFzLpuamWkum5qczP99H/L4ndywYYPGjx+v4OBgSdLdd9+t/fv3a8+ePXUWHADAzzknsjrlFPOWf9AAADR8LJtqCY+/RRUVFSnmiFl5Q0NDFR4ergMHDtRJYAAAAAAAC3iybGpxMcum+phXE8K98soratq0qet+WVmZXn/9dcXFxbnKWEoNAAA0SsxoDCBQsGyqJTxOzk844QS9/PLLbmWtW7fWG2+84brPOucAAKBRYkZjAIGEZVMt4XFyvnXr1joMAwAAoIFiRmMAgYZlUy3BuwkAAFBTR89oHBMjBQcfntE4L8+c0djhsDpSAPCOc9nU1FQpP98ctpOfb7aYc9GxTng15hwAAABH8GZG427drIkRAGqKZVPrFck5AABATXkyo3FuLjMaA2i4nMumos5xyQMAAKCmjpzRuDLMaAwA8BDJOQAA/sjhkDZulFauNG8Zs+yfnDMa5+SYMxgfyTmjcVISMxoDAI6pVt3azzvvPL3yyitq06aNr+IBAAAsy9VwMKMxAMBHapWcf/311zp48KCvYgEAACzL1fA4ZzR2XlDJzTUvqKSlmYk5fy8AgAeYEA4AAH9x9LJcztm/nctyZWaay3IlJ9MS62+Y0RgAUEu1Ss47dOigkJAQX8UCyfxixj92AGicWJarYWNGY+vw/QlAAKhVcv7rr7/6Kg5IjDEEgMaOZbkA7/H9CUCAoFu7v1i7Vnr4YcYYAkBjduSyXDExFbezLBfgjjkaAAQQ+vv4i4ULD48xjImRgoMPjzHMyzPHGLKMDgAENpblAjx39BwNfH8C0MCRnPuLDRs8G2MIAAhczmW54uLMLroFBVJZmXmbmcmyXMCRvJmjAQAaAP67+4uSkurHGBYXM8YQABoD57JcqalSfr6ZWOTnm8ty0UUXOMyTORr4/gSgAanRmPOysjItX75cmzdv1ogRIxQdHa3c3FzFxMSoadOmvo6xcQgLY4whAMDEslzAsTFHA4AA43Vynp2drXPOOUfbtm1TSUmJBg8erOjoaM2aNUslJSV68cUX6yLOwHfiidJPP7mvaysdHmOYlsYYQwBoTFiWC6iec46G9HS+PwEICF5fgr/jjjuUlpamffv2KSIiwlV+8cUX64svvvBpcI3KiBGMMQQAAPAUczQACDBet5x/8803+v777xUaGupW3rFjR+3YscNngTU6J59sjiV0rtOZm2t2xUpLM/+xMMYQAADAnXOOBr4/AQgAXifnDodD5eXlFcpzcnIUHR3tk6AaLcYY1p7DwfsHAEBjwvcnAAHC6+R8yJAhmj17tl566SVJks1m04EDBzR58mSde+65Pg+w0WGMYc1lZBy+cl5cbF45T0w0u7xx5RwAgMDF9ycAAcDr5PyJJ57Q0KFDlZSUpOLiYo0YMUKbNm1SXFyc/vWvf9VFjMCxZWRI06ZJeXnmuqZRUebsrenpUnY2yw8BAAAA8GteJ+fx8fFas2aN3n77ba1du1YHDhzQtddeq6uuusptgjig3jgcZot5Xp77bK0xMeb9zExpwQKzyxtd3AAAAAD4oRqtc96kSRNdffXVvo4FqJmsLDMBj493X0ZFMu/Hx0vr1pn16PIGAAAAwA95nZwvWLCg2u0jR46scTBAjdjt5hjzqKjKt0dGmrO32u31GxcAAAAAeMjr5PyOO+5wu19aWqqioiKFhoYqMjKS5Bz1LzbWnPytsNDsyn60oiJze2xs/ccGAAAAAB7wegDuvn373H4OHDigDRs26PTTT2dCOFgjIcEcW56TIxmG+zbDMMuTksx6AAAAAOCHfDI7VteuXfXII49UaFUH6kVQkLlcWlycOfa8oEAqKzNvMzPN8pEjmQwOAAAAgN+q0YRwle6oSRPl5ub6aneA5xwOc7z53/8uLV0q7dxpjjEPD5fS0szEnGXUAAAAAPgxr5Pzjz/+2O2+YRjauXOnnnvuOfXr189ngQEeycgwl1HLzDQnhQsLk9q0kQYPlvr0Mbuy02IOAAAAwM95nZwPHz7c7b7NZlPLli119tln64knnvBVXPAXDoe5BJndbk6o5k/JbkaGNG2aub55fLzZel5YKP3+u7RokXTSSf4TKwAAAABUw+vk3OFw1EUc8EdHt0qHh5sTr40aJSUnW5u0OxxmbHl5ZkzO9c1jYsz7mZnSggVmnCToAAAAAPycV8l5aWmpunfvrk8++USJiYl1FRP8QVWt0unp0po1ZtfxP/6omLTX19jurCwzAY+PP5yYO9lsZvm6ddLGjWZy7o8t/wAAAADwF6+S85CQEBUXF9dVLPAX1bVKt2wpffWVmfSecYbUtOnhpD07W5o0qX4SdLvdvDAQFVX59shIM8apU6X8fOsuIgAAAACAB7xuQhw7dqxmzZqlsrKyuogH/qCqVmnDkDZtMlueneXBwYe7kuflmV3J62PoQ2ysmWwXFla+fccOaft2M97mzaWuXc3b9HSzR0BGRt3HCAAAAAAe8rjlfNu2bYqPj9fKlSv1xRdfaMmSJerZs6eijmq5fP/9930eJOpZVa3Sdrv0559SdLR08KB06NDhbUd2Jc/Kkrp1q9sYExLMCwLp6e6t+5J5ceCXX6SQELOF3NmNnfHoAAAAAPyUx8l5p06dtHPnTjVr1kx///vf6zImWO3IVumYmMPlhw5JZWVSaKjUpIl5e6TISHN9cbu97mMMCjK7p2dnH27lj4yUiorM1vLSUql374rJd31fRAAAAAAAD3icnBuGIUmaN29enQUDP1FVq3RoqNmNvaBAat3aPXGXzMQ4PNxM7utDSoo5xt05o3xurvn8XbuaXfDj4yt/XH1eRAAAAAAAD3g1IZzt6FmxEZiqapW22cyk1+EwE+Cjx6Pn5EhpaWZyX19SUiou6+ZwSHfcUbHl36m+LyIAAAAAwDF4lZw/+OCDioyMrLbOk08+WauA4CeqapUeMMD8fe9eKSzscFfynBwpLk4aObL+x3EHBbl3T3c4qh6PbtVFBAAAAACohlfJ+S+//KLQo8cZH4GW9QBTWat0QoK5zvnRSXtampmY+8MSZdWNR7fyIgIAAAAAVMGr5PyDDz5Qq1at6ioW+KOjW6WlqpN2f0p2q2r596eLCAAAAADwF4+Tc1rF4aaypN3fNISLCAAAAACgGszWDjQoDeEiAgAAAIBGz+MmxHnz5imW2a0BAAAAAPA5j5LzH374QaNGjVJYWNgx6xYVFem3336rdWAAAAAAADQWHiXn11xzjYYOHap3331XhYWFldZZt26d7r//fnXp0kXp6ek+DRIAAAAAgEDm0ZjzdevWac6cOXrggQc0YsQIdevWTW3btlV4eLj27dun9evX68CBA7r44ou1ZMkS9ezZs67jBgAAAAAgYHjUch4SEqLbb79dGzZs0IoVK3T99derR48eateunQYMGKC5c+cqNzdX//rXv+okMd+6dauuvfZaderUSREREerSpYsmT56sQ4cO+fy5AAAAAACob16tcy5JaWlpSktLq4tYqrR+/Xo5HA7NnTtXCQkJ+vXXX3X99dersLBQjz/+eL3GAgAAAACAr3mdnFvhnHPO0TnnnOO637lzZ23YsEFz5swhOQeAxsbhkLKyJLtdio2VEhLMZRMBAAAasAaRnFfGbrerefPm1dYpKSlRSUmJ635BQYEkqbS0VKWlpXUan6eccXgcj8Mh/f67VFAgxcRInTvzpRR+xetjGvDG2rXSwoXShg1SSYkUFiadeKI0YoR08sl18pQc0wg0HNMINBzT8HeeHps2wzCMOo7F57KyspSamqrHH39c119/fZX1pkyZoqlTp1YoX7hwoSIjI+syRAAAAAAAVFRUpBEjRshutysmJqbKepYm5xMmTNCsWbOqrZOZmanu3bu77u/YsUNnnnmmBgwYoFdeeaXax1bWct6+fXvl5eVV+6bUp9LSUi1dulSDBw9WSEhI1RXXrpVmzZL++ENq21aKipIKC6XcXKlFC+m+++qs1QjwhsfHNOANh0O6/35p9WqzpdxmO7zNMMyW9JQUafp0n/cm4phGoOGYRqDhmIa/KygoUFxc3DGTc590a//zzz/VrFkzrx939913a/To0dXW6dy5s+v33NxcnXXWWerbt69eeumlY+4/LCxMYWFhFcpDQkL87oNbbUwOh/TGG9LOnVJiovml1DCkyEipSxcpM1N6803piSfo4g6/4Y+fMzRgGzdKv/4qtWollZdX3N6qlfTLL1J2ttStW52EwDGNQMMxjUDDMQ1/5elx6XVyPmvWLHXs2FFXXHGFJOnyyy/XokWL1Lp1a3322WdKTk72eF8tW7ZUy5YtPaq7Y8cOnXXWWUpNTdW8efMU1JiS0KwsMwGPj3dvLZLM+/Hx0rp1Zr06+lIKAJay26XiYrPXUGUiIqT8fGnFCvM+k8QBAIAGxutvLi+++KLat28vSVq6dKmWLl2qzz//XMOGDdM999zj8wAlMzEfMGCATjjhBD3++OPau3evdu3apV27dtXJ8/mdY30pjYw0t9vt9RsXANSX2FgpPNwcznO0vDzpu++kLVuk556TbrtNGjdOysio/zgBAABqyOuW8127drmS808++USXX365hgwZoo4dO+rUU0/1eYCSeREgKytLWVlZio+Pd9vWAOez896RX0orG6NQVGRuj42t/9gAoD4kJJjDetLTDw/vkczEPD3dbDVv08ace6OoyCzLzpYmTTLHogMAAPg5r1vOjzvuOG3fvl2StHjxYg0aNEiSmSSXVzYO0AdGjx4twzAq/WkUnF9Kc3LMseZHMgyzPCnJrAcAgSgoSBo1SoqLM4f5FBRIpaXmOPT8fKl5c6lHD6lJE/MiZmKimbgvWGDO2wEAAODnvE7OL7nkEo0YMUKDBw/WH3/8oWHDhkmSMjIylEByWDcq+1JaVmbeZmaa5SNHMr4SQGBLSTFbwlNTzYT8l1/MFSzatDHL4uIO1z16Pg4AAAA/53W39qeeekodO3bU9u3b9eijj6pp06aSpJ07d+qWW27xeYD4i/NL6fz5ZkKem2t2ZU9LMxNzum0CaAxSUqTkZDPhXrHCHGN+8slmi/nRIiPNcyXzcQAAgAbA6+Q8JCRE48ePr1B+1113+SQgVOPIL6V2uznGnBmJATQ2QUGHV6ZYuNAcY858HAAAoIHzKDn/+OOPPd7hhRdeWONg4IEjv5QCQGNW1SRx0uH5ONLSmI8DAAA0CB4l58OHD/doZzabrc4mhQMAwI1zPo7sbHO4T3y82ZW9qMhMzJmPAwAANCAeJecOZroFAPgj5uMAAAABwusx5wAA+BXm4wAAAAGgRsl5YWGhvvrqK23btk2HDh1y23b77bf7JDAAADzGfBwAAKCB8zo5z8jI0LnnnquioiIVFhaqefPmysvLU2RkpFq1akVyDgAAAACAl7zu83fXXXfpggsu0L59+xQREaEffvhB2dnZSk1N1eOPP14XMQIAAAA4msMhbdworVxp3jJPFNCged1yvnr1as2dO1dBQUEKDg5WSUmJOnfurEcffVSjRo3SJZdcUhdxAgAAAHDKyDg8GWZxsTkZZmKiuYoFk2ECDZLXLechISEK+muSnVatWmnbtm2SpNjYWG3fvt230QEAAABwl5EhTZsmpadLzZtLXbuat+npZnlGhtURAqgBr1vOU1JStHLlSnXt2lVnnnmmJk2apLy8PL3xxhvq0aNHXcQIAAAAQDK7rs+fL+XlmS3lNptZHhNj3s/MlBYsMFexYNUKoEHx+hM7Y8YMtWnTRpI0ffp0HXfccbr55pu1d+9evfTSSz4PEAAAAMBfsrLMBDw+/nBi7mSzmeXr1pn1ADQoXrecp6WluX5v1aqVFi9e7NOAAAAAAFTBbjfHmEdFVb49MlLKzTXrAWhQ6OsCAAAANBSxsebkb4WFlW8vKjK3x8bWb1wAas3rlvNOnTrJdnQXmiP8/vvvtQoIAAAAQBUSEsyx5enp7mPOJckwpJwcKS3NrAegQfE6Ob/zzjvd7peWliojI0OLFy/WPffc46u4AAAAABwtKMhcLi07+/DY88hIs8U8J0eKi5NGjmQyOKAB8jo5v+OOOyotf/755/Xzzz/XOiAAAAAA1UhJkSZNOrzOeW6u2ZU9Lc1MzFnnHGiQvE7OqzJs2DBNnDhR8+bN89UuYQWHw5zd0243xyolJHDlFQAAwN+kpJjLpfG9DQgYPkvO33vvPTVv3txXu4MVMjIOX4EtLjavwCYmml2nuAILAADgX4KCpG7drI4CgI94nZynpKS4TQhnGIZ27dqlvXv36oUXXvBpcKhHGRnStGlSXp45dikqypwFND3dHNM0aRIJOgAAAADUEa+T8+HDh7vdDwoKUsuWLTVgwAB1797dV3GhPjkcZot5Xp77rJ8xMeb9zExpwQKz6xRdpQAAAADA57xOzidPnlwXccBKWVmHZ/s8epk8m80sX7fOrEfXKQAAAADwOY+S84KCAo93GBMTU+NgYBG73RxjHhVV+fbISHMWULu9fuMCAADWYIJYAKh3HiXnzZo1cxtnXp3y8vJaBQQLxMaak78VFppd2Y9WVGRuj42t/9gAAED9YoJYALCER8n5l19+6fp969atmjBhgkaPHq3TTjtNkrRixQrNnz9fM2fOrJsoUbcSEsx/uunp7mPOJckwpJwcc93MhATrYgQAAHWPCWIBwDIeJednnnmm6/dp06bpySef1JVXXukqu/DCC9WzZ0+99NJLGjVqlO+jRN0KCjKvhmdnHx57Hhlptpjn5EhxcdLIkXRnAwAgkDFBLABYyusz64oVK5SWllahPC0tTT/99JNPgoIFUlLMq+GpqVJ+vjnOLD/fbDHnKjkAAIHPmwliAQA+5/Vs7e3bt9fLL7+sRx991K38lVdeUfv27X0WGCyQkmJeDWcCGAAAGh8miAUAS3mdnD/11FP6+9//rs8//1ynnnqqJOmnn37Spk2btGjRIp8HiHoWFMRyaQAANEZMEAsAlvK6SfTcc8/Vxo0bdcEFFyg/P1/5+fm64IILtHHjRp177rl1ESMAAADqmnOC2Jwcc0LYIzkniE1KYoJYAKgjXrecS2bX9hkzZvg6FgAAAFiFCWIBwFIeJedr165Vjx49FBQUpLVr11Zb9+STT/ZJYAAAAKhnzglineuc5+aaXdnT0szEnAliAaDOeJSc9+rVS7t27VKrVq3Uq1cv2Ww2GUd3d5Jks9lUXl7u8yABAABQT5ggFgAs4VFyvmXLFrVs2dL1OwAAAAIYE8QCQL3zKDnv0KFDpb8DAAAAAIDa87p/0vz58/Xpp5+67t97771q1qyZ+vbtq+zsbJ8GBwAAAABAY+B1cj5jxgxFRERIklasWKHnnntOjz76qOLi4nTXXXf5PEAAAAAAAAKd10upbd++XQl/rW/54Ycf6tJLL9UNN9ygfv36acCAAb6ODwAAAACAgOd1y3nTpk31xx9/SJKWLFmiwYMHS5LCw8N18OBB30YHAAAAAEAj4HXL+eDBg3XdddcpJSVFGzdu1LnnnitJ+u2339SxY0dfxwcAgMnhYGknAAAQsLxOzp9//nk98MAD2r59uxYtWqQWLVpIktLT03XllVf6PEAAAJSRIc2fL2VmSsXFUni4lJgojRplrskMAADQwHmdnDdr1kzPPfdchfKpU6f6JCAAANxkZEjTpkl5eVJ8vBQVJRUWSunpUna2NGkSCToAAGjwatQf8JtvvtHVV1+tvn37aseOHZKkN954Q99++61PgwMANHIOh9linpdntpTHxEjBweZtYqJZvmCBWQ8AAKAB8zo5X7RokYYOHaqIiAitWrVKJSUlkiS73a4ZM2b4PEAAQCOWlWV2ZY+Pl2w29202m1m+bp1ZDwAAoAHzOjl/+OGH9eKLL+rll19WSEiIq7xfv35atWqVT4MDADRydrs5xjwqqvLtkZHmdru9fuMCAADwMa+T8w0bNqh///4VymNjY/Xnn3/6IiYAAEyxsebkb4WFlW8vKjK3x8bWb1wAAAA+5nVy3rp1a2VV0n3w22+/VefOnX0SFAAAkszl0hITpZwcyTDctxmGWZ6UZNYDAABowLxOzq+//nrdcccd+vHHH2Wz2ZSbm6u33npL48eP180331wXMQIAGqugIHO5tLg4c+x5QYFUVmbeZmaa5SNHst45AABo8LxeSm3ChAlyOBwaOHCgioqK1L9/f4WFhWn8+PG67bbb6iJGAEBjlpJiLpfmXOc8N9fsyp6WZibmLKMGAAACgNfJuc1m0//93//pnnvuUVZWlg4cOKCkpCQ1bdpUBw8eVERERF3ECQBozFJSpORkc1Z2u90cY56QQIs5AAAIGF4n506hoaFKSkqSJJWUlOjJJ5/Uo48+ql27dvksOAAAXIKCpG7drI4CAACgTnjc5FBSUqKJEycqLS1Nffv21YcffihJmjdvnjp16qSnnnpKd911V13FCQAAAABAwPK45XzSpEmaO3euBg0apO+//16XXXaZxowZox9++EFPPvmkLrvsMgUHB9dlrAAAAAAABCSPk/N3331XCxYs0IUXXqhff/1VJ598ssrKyrRmzRrZbLa6jBEAAAAAgIDmcbf2nJwcpaamSpJ69OihsLAw3XXXXSTmAAAAAADUksfJeXl5uUJDQ133mzRpoqZNm9ZJUAAAAAAANCYed2s3DEOjR49WWFiYJKm4uFg33XSToqKi3Oq9//77vo0QAAAAAIAA53FyPmrUKLf7V199tc+DAQAAAACgMfI4OZ83b15dxgEAAAAAQKPl8ZhzAAAAAABQN0jOAQAAAACwGMk5AAAAAAAWIzkHAAAAAMBiJOcAAAAAAFiM5BwAAAAAAIuRnAMAAAAAYLEGl5yXlJSoV69estlsWr16tdXhAAAAAABQaw0uOb/33nvVtm1bq8MAAAAAAMBnmlgdgDc+//xzLVmyRIsWLdLnn39+zPolJSUqKSlx3S8oKJAklZaWqrS0tM7i9IYzDn+JB6gtjmkEGo5pBBqOaQQajmn4O0+PTZthGEYdx+ITu3fvVmpqqj788EPFxcWpU6dOysjIUK9evap8zJQpUzR16tQK5QsXLlRkZGQdRgsAAAAAgFRUVKQRI0bIbrcrJiamynoNIjk3DEPnnnuu+vXrpwceeEBbt271KDmvrOW8ffv2ysvLq/ZNqU+lpaVaunSpBg8erJCQEKvDAWqNYxqBhmMagYZjGoGGYxr+rqCgQHFxccdMzi3t1j5hwgTNmjWr2jqZmZlasmSJ9u/fr4kTJ3q1/7CwMIWFhVUoDwkJ8bsPrj/GBNQGxzQCDcc0Ag3HNAINxzT8lafHpaXJ+d13363Ro0dXW6dz585atmyZVqxYUSHRTktL01VXXaX58+fXYZQAAAAAANQtS5Pzli1bqmXLlses98wzz+jhhx923c/NzdXQoUP1zjvv6NRTT63LEAEAAAAAqHMNYrb2E044we1+06ZNJUldunRRfHy8FSEBAAAAAOAzDW6dcwAAAAAAAk2DaDk/WseOHdUAJpkHAAAAAMAjtJwDAAAAAGAxknMAAAAAACzWILu1A0Cj4nBIWVmS3S7FxkoJCVIQ11YBAAACCck5APizjAxp/nwpM1MqLpbCw6XERGnUKCklxeroAAAA4CMk5wDgrzIypGnTpLw8KT5eioqSCgul9HQpO1uaNIkEHQAAIEDQLxIA/JHDYbaY5+WZLeUxMVJwsHmbmGiWL1hg1gMAAECDR3IOAP4oK8vsyh4fL9ls7ttsNrN83TqzHgAAABo8knMA8Ed2uznGPCqq8u2RkeZ2u71+4wIAAECdIDkHAH8UG2tO/lZYWPn2oiJze2xs/cYFAACAOkFyDgD+KCHBHFuekyMZhvs2wzDLk5LMegAAAGjwSM4BwB8FBZnLpcXFmWPPCwqksjLzNjPTLB85kvXOAQAAAgTf6gDAX6WkmMulpaZK+fnm5G/5+VJaGsuoAQAABBjWOQcAf5aSIiUnm4m53W6OMU9IoMUcAAAgwJCcA4C/CwqSunWzOgoAAADUIZJzAACAozkc9FgBANQrknMAAIAjZWRI8+ebky8WF5vLFiYmmpM0MtcDAKCOkJwDAAA4ZWRI06ZJeXlSfLwUFSUVFkrp6VJ2NpMxAgDqDP2zAAAAJLMr+/z5ZmKemCjFxEjBweZtYqJZvmCBWQ8AAB8jOQcAAJDMMeaZmWaLuc3mvs1mM8vXrTPrAQDgYyTnAAAAkjn5W3Gx2ZW9MpGR5na7vX7jAgA0CiTnAAAAkjkre3i4Oca8MkVF5vbY2PqNCwDQKJCcAwAASOZyaYmJUk6OZBju2wzDLE9KMusBAOBjzNYOAAAgmeuYjxplzsruHHseGWm2mOfkSHFx0siRrHcOzzkc5hwFdrvZ4yIhgeMHQJVIzgEAqIzzS/W+fYfvI/ClpJjLpTnXOc/NNbuyp6WZiTnLqMFTGRmHj6PiYvM4Skw0LwBxHAGoBMk5AABHO/JLtcMh3XqrdP/90tVX86W6MUhJkZKTafFEzWVkSNOmmcvvxcebkwwWFkrp6WbPjEmTOJcAqIDkHACAIx39pdo5+dfq1dLvv/OlurEICpK6dbM6CjREDod5cS8vz2wpdy7LFxNj3s/MlBYsMC8AccEHwBE4IwAA4HT0l+qYGCk42Nx24olm+YIFdHEHULWsrMNzFjgTcyebzSxft86sBwBHIDkHAMCJL9UAastuN8eYR0VVvj0y0txut9dvXAD8Hsk5AABOfKkGUFuxsebkb4WFlW8vKjK3O4fMAMBfSM4BAHDiSzWA2kpIMIfF5ORIhuG+zTDM8qQksx4AHIHkHAAAJ75UA6itoCBzubS4OHOYTEGBVFZm3mZmmuUjRzIZHIAKOCsAAOBU1ZdqSdqwgS/VADyTkmKu7JCaKuXnm/NU5OdLaWms+ACgSiylBgDAkZxfqp3rnOflHS6/6iq+VAPwTEqKuVxaVpY5T0VsrNnrhot7AKpAcg4AwNGO/FK9b5+0a5c0fboUFmZ1ZAAakqAgqVs3q6MA0EBw6Q4AgMo4v1T37n34PgAAQB3hmwYAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALBYg0rOP/30U5166qmKiIjQcccdp+HDh1sdEgAAAAAAtdbE6gA8tWjRIl1//fWaMWOGzj77bJWVlenXX3+1OiwAAAAAAGqtQSTnZWVluuOOO/TYY4/p2muvdZUnJSVZGBUAAAAAAL7RIJLzVatWaceOHQoKClJKSop27dqlXr166bHHHlOPHj2qfFxJSYlKSkpc9wsKCiRJpaWlKi0trfO4PeGMw1/iAWqLYxqBhmMagYZjGoGGYxr+ztNj02YYhlHHsdTa22+/rSuvvFInnHCCnnzySXXs2FFPPPGElixZoo0bN6p58+aVPm7KlCmaOnVqhfKFCxcqMjKyrsMGAAAAADRyRUVFGjFihOx2u2JiYqqsZ2lyPmHCBM2aNavaOpmZmVq1apWuuuoqzZ07VzfccIMks1U8Pj5eDz/8sG688cZKH1tZy3n79u2Vl5dX7ZtSn0pLS7V06VINHjxYISEhVocD1BrHNLzicEi//y4VFEgxMVLnzlKQf81VyjGNQMMxjUDDMQ1/V1BQoLi4uGMm55Z2a7/77rs1evToaut07txZO3fulOQ+xjwsLEydO3fWtm3bqnxsWFiYwsLCKpSHhIT43QfXH2MCaoNjGseUkSHNny9lZkrFxVJ4uJSYKI0aJaWkWB1dBRzTCDQc0wg0HNPwV54el5Ym5y1btlTLli2PWS81NVVhYWHasGGDTj/9dEnmFbKtW7eqQ4cOdR0mAMDXMjKkadOkvDwpPl6KipIKC6X0dCk7W5o0yS8TdAAAgLrSICaEi4mJ0U033aTJkyerffv26tChgx577DFJ0mWXXWZxdAAArzgcZot5Xp7ZUm6zmeUxMeb9zExpwQIpOdnvurgDAADUlQaRnEvSY489piZNmuiaa67RwYMHdeqpp2rZsmU67rjjrA4NAOCNrCwzAY+PP5yYO9lsZvm6dWa9bt2siREAAKCeNZjkPCQkRI8//rgef/xxq0MBANSG3W6OMY+Kqnx7ZKSUm2vWAwAAaCToLwgAqF+xsebkb4WFlW8vKjK3x8bWb1wAAAAWIjkHANSvhARzbHlOjnT0ap6GYZYnJZn1AAAAGgmScwBA/QoKMpdLi4szx54XFEhlZeZtZqZZPnIkk8EBAIBGhW8+AID6l5JiLpeWmirl55uTv+XnS2lpLKMGAAAapQYzIRwAIMCkpJjLpWVlmZO/xcaaXdlpMQcAAI0QyTkAwDpBQSyXBgAAIJJzAAAAIKAZhqGysjKVl5dbHUqdKC0tVZMmTVRcXBywrxH+LTg4WE2aNJHNZqvVfkjOAQAAgAB16NAh7dy5U0VFRVaHUmcMw1Dr1q21ffv2WidHQE1FRkaqTZs2Cg0NrfE+SM4BAACAAORwOLRlyxYFBwerbdu2Cg0NDcjk1eFw6MCBA2ratKmCmLcE9cwwDB06dEh79+7Vli1b1LVr1xofhyTnAAAAQAA6dOiQHA6H2rdvr8jISKvDqTMOh0OHDh1SeHg4yTksERERoZCQEGVnZ7uOxZrg6AUAAAACGAkrUPd88TnjkwoAAAAAgMVIzgEAAAAAsBjJub9zOKSNG6WVK81bh8PqiAAAAAA0EAMGDNCdd97pcf3XX39dzZo1q7N4PDFlyhT16tWr2jqjR4/W8OHDffq8Vr92knN/lpEhjRsn3XabNH68eTtunFkOAAAABLBdu3bptttuU+fOnRUWFqb27dvrggsu0BdffOGT/W/dulU2m02rV6/2yf5q+vzBwcHasWOH27adO3e61s3eunWrJfFVx2azuX5iYmJ0yimn6KOPPvLZ/sePH++zv3NDQnLurzIypGnTpPR0qXlzqWtX8zY93SwnQQcAAEB9qefenFu3blVqaqqWLVumxx57TL/88osWL16ss846S2PHjq3T565v7dq104IFC9zK5s+fr3bt2lkUkWfmzZunnTt36ueff1a/fv106aWX6pdffvHJvps2baoWLVr4ZF8NCcm5P3I4pPnzpbw8KTFRiomRgoPN28REs3zBArq4AwAAoO5Z0Jvzlltukc1m008//aS///3v6tatm0466SSNGzdOP/zwg6TKW77//PNP2Ww2LV++XJK0b98+XXXVVWrZsqUiIiLUtWtXzZs3T5LUqVMnSVJKSopsNpsGDBggyVyabdq0aYqPj1dYWJh69eqlxYsXu57D+bz//ve/dcYZZygiIkKnnHKKNm7cqJUrVyotLU1NmzbVsGHDtHfv3mO+1lGjRrlicpo3b55GjRpVoe5XX32lPn36KCwsTG3atNGECRNUVlbm2l5YWKiRI0eqadOmatOmjZ544okK+ygpKdH48ePVrl07RUVF6dRTT3W9X95o1qyZWrdurW7duumhhx5SWVmZvvzyS9f27du36/LLL1ezZs3UvHlzXXTRRW69AJYvX64+ffooKipKzZo1U79+/ZSdnS2pYrf28vJyjRs3Ts2aNVOLFi107733yjAMt3g6duyo2bNnu5X16tVLU6ZMcd1/8skn1bNnT0VFRal9+/a65ZZbdODAgSpf45o1a3TWWWcpOjpaMTExSk1N1c8//+z1e+UpknN/lJUlZWZK8fGSzea+zWYzy9etM+sBAAAAdcWC3pz5+flavHixxo4dq6ioqArbvRkT/OCDD2rdunX6/PPPlZmZqTlz5iguLk6S9NNPP0mS/ve//2nnzp16//33JUlPP/20nnjiCT3++ONau3athg4dqgsvvFCbNm1y2/fkyZP1wAMPaNWqVWrSpIlGjBihe++9V08//bS++eYbZWVladKkSceM8cILL9S+ffv07bffSpK+/fZb7du3TxdccIFbvR07dujcc8/VKaecojVr1mjOnDl69dVX9fDDD7vq3HPPPfrqq6/00UcfacmSJVq+fLlWrVrltp9bb71VK1as0Ntvv621a9fqsssu0znnnFPh9XmqrKxMr776qiQpNDRUklRaWqqhQ4cqOjpa33zzjb777js1bdpU55xzjg4dOqSysjINHz5cZ555ptauXasVK1bohhtukO3o3OcvTzzxhF5//XW99tpr+vbbb5Wfn68PPvjA61iDgoL0zDPP6LffftP8+fO1bNky3XvvvVXWv+qqqxQfH6+VK1cqPT1dEyZMUEhIiNfP66kmdbZn1JzdLhUXS5WcjCRJkZFSbq5ZDwAAAKgLR/fmdCZOzt6cmZlmb87kZMmHa6lnZWXJMAx179691vvatm2bUlJSlJaWJslsXXVq2bKlJKlFixZq3bq1q/zxxx/Xfffdp3/84x+SpFmzZunLL7/U7Nmz9fzzz7vqjR8/XkOHDpUk3XHHHbryyiv1xRdfqF+/fpKka6+9Vq+//voxYwwJCdHVV1+t1157Taeffrpee+01XX311RWSwBdeeEHt27fXc889J5vNpu7duys3N1f33XefJk2apKKiIr366qt68803NXDgQElm9/j4+Hi392PevHnatm2b2rZt63odixcv1rx58zRjxgyP3ldJuvLKKxUcHKyDBw/K4XCoY8eOuvzyyyVJ77zzjhwOh1555RVXwj1v3jw1a9ZMy5cvV1pamux2u84//3x16dJFkpSYmFjlc82ePVsTJ07UJZdcIkl68cUX9d///tfjWJ2OnBivY8eOevjhh3XTTTfphRdeqLT+tm3bdM8997iOxa5du3r9nN6g5dwfxcZK4eFSYWHl24uKzO2xsfUbFwAAABoPi3pzHt1duTZuvvlmvf322+rVq5fuvfdeff/999XWLygoUG5urivBdurXr58yMzPdyk4++WTX78cff7wkqWfPnm5le/bs8SjOf/7zn3r33Xe1a9cuvfvuu/rnP/9ZoU5mZqZOO+00t9blfv366cCBA8rJydHmzZt16NAhnXrqqa7tzZs314knnui6/8svv6i8vFzdunVT06ZNXT9fffWVNm/e7FGsTk899ZRWr16tzz//XElJSXrllVfUvHlzSWZ38KysLEVHR7ueo3nz5iouLtbmzZvVvHlzjR49WkOHDtUFF1ygp59+Wjt37qz0eex2u3bu3On2upo0aeK64OKN//3vfxo4cKDatWun6OhoXXPNNfrjjz9UVFRUaf1x48bpuuuu06BBg/TII494/R55i+TcHyUkmFcjc3Kko09OhmGWJyWZ9QAAAIC64ElvzuJin/fm7Nq1q2w2m9avX19tvaC/WuuPTOZLS0vd6gwbNkzZ2dm66667lJubq4EDB2r8+PE+ifPIlm1nwnx0mcPDOaJ69uyp7t2768orr1RiYqJ69OjhkxiPduDAAQUHBys9PV2rV692/WRmZurpp5/2al+tW7dWQkKChgwZonnz5umKK65wXYw4cOCAUlNT3Z5j9erV2rhxo0aMGCHJbElfsWKF+vbtq3feeUfdunVzzSdQE0FBQRUu7Bx5PGzdulXnn3++Tj75ZC1atEjp6emunhCHDh2qdJ9TpkzRb7/9pvPOO0/Lli1TUlJSjbrTe/wa6mzPqLmgIGnUKCkuzrxaWVAglZWZt5mZZvnIkT7tPgQAAAC4sag3Z/PmzTV06FA9//zzKqzkuf/8809Jh7ulH9niWtmyaC1bttSoUaP05ptvavbs2XrppZckHR4fXV5e7qobExOjtm3b6rvvvnPbx3fffaekpKRava5j+ec//6nly5dX2moumd2+V6xY4ZaAfvfdd4qOjlZ8fLy6dOmikJAQ/fjjj67t+/bt08aNG133U1JSVF5erj179ighIcHt58iu/d7q06ePUlNTNX36dElS7969tWnTJrVq1arC88QecbykpKRo4sSJ+v7779WjRw8tXLiwwr5jY2PVpk0bt9dVVlam9PR0t3otW7Z0OxYKCgq0ZcsW1/309HQ5HA498cQT+tvf/qZu3bopNzf3mK+tW7duuuuuu7RkyRJdcsklFSbv8yWyO3+VkiJNmiSlpkr5+WZ3ofx8KS3NLE9JsTpCAAAABDILe3M+//zzKi8vV58+fbRo0SJt2rRJmZmZeuaZZ3TaaadJkiIiIvS3v/1Njz76qDZs2KCvvvpKDzzwgNt+Jk2apI8++khZWVn67bff9Mknn7jGNrdq1UoRERFavHixdu/eLftfPQDuuecezZo1S++88442bNigCRMmaPXq1brjjjt8/jqPdP3112vv3r267rrrKt1+yy23aPv27brtttu0fv16ffTRR5o8ebLGjRunoKAgNW3aVNdee63uueceLVu2TL/++qtGjx7t6mEgmYnmVVddpZEjR+r999/Xli1b9NNPP2nmzJn69NNPaxX/nXfeqblz52rHjh266qqrFBcXp4suukjffPONtmzZouXLl+v2229XTk6OtmzZookTJ2rFihXKzs7WkiVLtGnTpirHnd9xxx165JFH9OGHH2r9+vW65ZZbXBdpnM4++2y98cYb+uabb/TLL79o1KhRCg4Odm1PSEhQaWmpnn32Wf3+++9644039OKLL1b5eg4ePKhbb71Vy5cvV3Z2tr777jutXLmy2rHxtcWEcP4sJcWcYCMry+wuFBtrnvxoMQcAAEBdc/bmzM4+PPY8MtJsMc/JqdPenJ07d9aqVas0ffp03X333dq5c6datmyp1NRUzZkzx1Xvtdde07XXXquzzjpLJ554oh599FENGTLEtT00NFQTJ07U1q1bFRERoTPOOENvv/22JHPc8jPPPKNp06Zp0qRJOuOMM1wJpN1u19133609e/YoKSlJH3/8cZ1PBtakSRPXTPKVadeunT777DPdc889Sk5OVvPmzXXttde6XZB47LHHdODAAV1wwQWKjo7W3Xff7bro4DRv3jw9/PDDuvvuu7Vjxw7FxcXpb3/7m84///xaxX/OOeeoU6dOmj59ul544QV9/fXXuu+++3TJJZdo//79ateunQYOHKiYmBgdPHhQ69ev1/z58/XHH3+oTZs2Gjt2rG688cZK9+08BkaNGqWgoCD985//1MUXX+z22iZOnKgtW7bo/PPPV2xsrB566CG3lvPk5GQ9+eSTmjVrliZOnKj+/ftr5syZGjlyZKXPGRwcrD/++EMjR47U7t27FRcXp0suuURTp06t1ftUHZvhyxkX/FxBQYFiY2Nlt9sVExNjdTiSzHEQn332mc4999w6nZYfqC8c0wg0HNMINBzTjUdxcbG2bNmiTp06KTw8vOY7ysgwZ23PzDTHmIeHmy3mI0f6RW9Oh8OhgoICxcTEuLUSA/Wpus+bp3koLecAAAAAqkZvTqBekJwDAAAAqF5QkNStm9VRAAGNy10AAAAAAFiM5BwAAAAAAIuRnAMAAAABrBHN/wxYxhefM5JzAAAAIAA5Z+MvKiqyOBIg8Dk/Z7VZBYMJ4QAAAIAAFBwcrGbNmmnPnj2SpMjISNlsNouj8j2Hw6FDhw6puLiYpdRQ7wzDUFFRkfbs2aNmzZopODi4xvsiOQcAAAACVOvWrSXJlaAHIsMwdPDgQUVERATkxQc0DM2aNXN93mqK5BwAAAAIUDabTW3atFGrVq1UWlpqdTh1orS0VF9//bX69+9fqy7FQE2FhITUqsXcieQcAAAACHDBwcE+SR78UXBwsMrKyhQeHk5yjgaNQRkAAAAAAFiM5BwAAAAAAIuRnAMAAAAAYLFGNebcuTB8QUGBxZEcVlpaqqKiIhUUFDBGBgGBYxqBhmMagYZjGoGGYxr+zpl/OvPRqjSq5Hz//v2SpPbt21scCQAAAACgMdm/f79iY2Or3G4zjpW+BxCHw6Hc3FxFR0f7zRqIBQUFat++vbZv366YmBirwwFqjWMagYZjGoGGYxqBhmMa/s4wDO3fv19t27ZVUFDVI8sbVct5UFCQ4uPjrQ6jUjExMZxMEFA4phFoOKYRaDimEWg4puHPqmsxd2JCOAAAAAAALEZyDgAAAACAxUjOLRYWFqbJkycrLCzM6lAAn+CYRqDhmEag4ZhGoOGYRqBoVBPCAQAAAADgj2g5BwAAAADAYiTnAAAAAABYjOQcAAAAAACLkZwDAAAAAGAxknOLPf/88+rYsaPCw8N16qmn6qeffrI6JKBGZs6cqVNOOUXR0dFq1aqVhg8frg0bNlgdFuATjzzyiGw2m+68806rQwFqbMeOHbr66qvVokULRUREqGfPnvr555+tDguokfLycj344IPq1KmTIiIi1KVLFz300ENirms0ZCTnFnrnnXc0btw4TZ48WatWrVJycrKGDh2qPXv2WB0a4LWvvvpKY8eO1Q8//KClS5eqtLRUQ4YMUWFhodWhAbWycuVKzZ07VyeffLLVoQA1tm/fPvXr108hISH6/PPPtW7dOj3xxBM67rjjrA4NqJFZs2Zpzpw5eu6555SZmalZs2bp0Ucf1bPPPmt1aECNsZSahU499VSdcsopeu655yRJDodD7du312233aYJEyZYHB1QO3v37lWrVq301VdfqX///laHA9TIgQMH1Lt3b73wwgt6+OGH1atXL82ePdvqsACvTZgwQd99952++eYbq0MBfOL888/X8ccfr1dffdVV9ve//10RERF68803LYwMqDlazi1y6NAhpaena9CgQa6yoKAgDRo0SCtWrLAwMsA37Ha7JKl58+YWRwLU3NixY3Xeeee5nauBhujjjz9WWlqaLrvsMrVq1UopKSl6+eWXrQ4LqLG+ffvqiy++0MaNGyVJa9as0bfffqthw4ZZHBlQc02sDqCxysvLU3l5uY4//ni38uOPP17r16+3KCrANxwOh+68807169dPPXr0sDocoEbefvttrVq1SitXrrQ6FKDWfv/9d82ZM0fjxo3T/fffr5UrV+r2229XaGioRo0aZXV4gNcmTJiggoICde/eXcHBwSovL9f06dN11VVXWR0aUGMk5wB8buzYsfr111/17bffWh0KUCPbt2/XHXfcoaVLlyo8PNzqcIBaczgcSktL04wZMyRJKSkp+vXXX/Xiiy+SnKNB+ve//6233npLCxcu1EknnaTVq1frzjvvVNu2bTmm0WCRnFskLi5OwcHB2r17t1v57t271bp1a4uiAmrv1ltv1SeffKKvv/5a8fHxVocD1Eh6err27Nmj3r17u8rKy8v19ddf67nnnlNJSYmCg4MtjBDwTps2bZSUlORWlpiYqEWLFlkUEVA799xzjyZMmKB//OMfkqSePXsqOztbM2fOJDlHg8WYc4uEhoYqNTVVX3zxhavM4XDoiy++0GmnnWZhZEDNGIahW2+9VR988IGWLVumTp06WR0SUGMDBw7UL7/8otWrV7t+0tLSdNVVV2n16tUk5mhw+vXrV2F5y40bN6pDhw4WRQTUTlFRkYKC3FOZ4OBgORwOiyICao+WcwuNGzdOo0aNUlpamvr06aPZs2ersLBQY8aMsTo0wGtjx47VwoUL9dFHHyk6Olq7du2SJMXGxioiIsLi6ADvREdHV5gvISoqSi1atGAeBTRId911l/r27asZM2bo8ssv108//aSXXnpJL730ktWhATVywQUXaPr06TrhhBN00kknKSMjQ08++aT++c9/Wh0aUGMspWax5557To899ph27dqlXr166ZlnntGpp55qdViA12w2W6Xl8+bN0+jRo+s3GKAODBgwgKXU0KB98sknmjhxojZt2qROnTpp3Lhxuv76660OC6iR/fv368EHH9QHH3ygPXv2qG3btrryyis1adIkhYaGWh0eUCMk5wAAAAAAWIwx5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGIk5wAA4Jg2bNig1q1ba//+/VaH4jfWrVun+Ph4FRYWWh0KACAAkJwDACBp9OjRstlsFX6ysrJ8sv/XX39dzZo188m+aqK8vFx9+/bVJZdc4lZut9vVvn17/d///V+1j584caJuu+02RUdHV/leOX86duxY4zhHjx6t4cOHe1TP+XwhISE6/vjjNXjwYL322mtyOBxePWdN/zZJSUn629/+pieffNLrxwIAcDSScwAA/nLOOedo586dbj+dOnWyOqwKSktLvX5McHCwXn/9dS1evFhvvfWWq/y2225T8+bNNXny5Cofu23bNn3yyScaPXq0JOnpp592e48kad68ea77K1eu9Dq+mnD+vbZu3arPP/9cZ511lu644w6df/75Kisrq5cYxowZozlz5tTb8wEAAhfJOQAAfwkLC1Pr1q3dfoKDgyVJH330kXr37q3w8HB17txZU6dOdUvInnzySfXs2VNRUVFq3769brnlFh04cECStHz5co0ZM0Z2u93V2jtlyhRJks1m04cffugWR7NmzfT6669LkrZu3SqbzaZ33nlHZ555psLDw13J9SuvvKLExESFh4ere/fueuGFF6p9fd26ddMjjzyi2267TTt37tRHH32kt99+WwsWLFBoaGiVj/v3v/+t5ORktWvXTpIUGxvr9h45Y3be3717t4YNG6amTZvq+OOP1zXXXKO8vDzX/t577z317NlTERERatGihQYNGqTCwkJNmTJF8+fP10cffeR6n5YvX37Mv1e7du3Uu3dv3X///froo4/0+eefu96/2vxt3njjDaWlpSk6OlqtW7fWiBEjtGfPHrcYBg8erPz8fH311VfVvvcAABwLyTkAAMfwzTffaOTIkbrjjju0bt06zZ07V6+//rqmT5/uqhMUFKRnnnlGv/32m+bPn69ly5bp3nvvlST17dtXs2fPVkxMjKt1efz48V7FMGHCBN1xxx3KzMzU0KFD9dZbb2nSpEmaPn26MjMzNWPGDD344IOaP39+tfu57bbblJycrGuuuUY33HCDJk2apOTk5GO+/rS0NI/i/PPPP3X22WcrJSVFP//8sxYvXqzdu3fr8ssvlyTt3LlTV155pf75z38qMzNTy5cv1yWXXCLDMDR+/Hhdfvnlbj0Y+vbt69kb9Jezzz5bycnJev/9911lNf3blJaW6qGHHtKaNWv04YcfauvWra7eA06hoaHq1auXvvnmG6/iBACgAgMAABijRo0ygoODjaioKNfPpZdeahiGYQwcONCYMWOGW/033njDaNOmTZX7e/fdd40WLVq47s+bN8+IjY2tUE+S8cEHH7iVxcbGGvPmzTMMwzC2bNliSDJmz57tVqdLly7GwoUL3coeeugh47TTTjvWSzUyMzMNSUbPnj2N0tLSY9ZPTk42pk2bVuX2I1/DQw89ZAwZMsRt+/bt2w1JxoYNG4z09HRDkrF169ZK9zVq1CjjoosuOmZM1dW74oorjMTExCof6+nf5mgrV640JBn79+93K7/44ouN0aNHH/PxAABUp4mF1wUAAPArZ511lubMmeO6HxUVJUlas2aNvvvuO7eW8vLychUXF6uoqEiRkZH63//+p5kzZ2r9+vUqKChQWVmZ2/baOrLlurCwUJs3b9a1116r66+/3lVeVlam2NjYY+7rtddeU2RkpLZs2aKcnJxjTuB28OBBhYeHexTnmjVr9OWXX6pp06YVtm3evFlDhgzRwIED1bNnTw0dOlRDhgzRpZdequOOO86j/XvCMAzZbDbX/Zr+bdLT0zVlyhStWbNG+/btc000t23bNiUlJbnqRUREqKioyGfxAwAaJ7q1AwDwl6ioKCUkJLh+2rRpI0k6cOCApk6dqtWrV7t+fvnlF23atEnh4eHaunWrzj//fJ188slatGiR0tPT9fzzz0uSDh06VO1z2mw2GYbhVlbZhG/OCwXOeCTp5Zdfdovp119/1Q8//FDt833//fd66qmn9Mknn6hPnz669tprKzz/0eLi4rRv375q6xwZ2wUXXOAW1+rVq7Vp0yb1799fwcHBWrp0qT7//HMlJSXp2Wef1YknnqgtW7Z4tH9PZGZmuibyq+nfprCwUEOHDlVMTIzeeustrVy5Uh988EGlj8vPz1fLli19Fj8AoHGi5RwAgGPo3bu3NmzYoISEhEq3p6eny+Fw6IknnlBQkHnd+9///rdbndDQUJWXl1d4bMuWLV0znkvSpk2bjtkKe/zxx6tt27b6/fffddVVV3n8OoqKijR69GjdfPPNOuuss9SpUyf17NlTL774om6++eYqH5eSkqJ169Z59By9e/fWokWL1LFjRzVpUvnXDJvNpn79+qlfv36aNGmSOnTooA8++EDjxo2r8n3y1LJly/TLL7/orrvuklTzv8369ev1xx9/6JFHHlH79u0lST///HOlz/nrr7/q0ksvrXHMAABItJwDAHBMkyZN0oIFCzR16lT99ttvyszM1Ntvv60HHnhAkpSQkKDS0lI9++yz+v333/XGG2/oxRdfdNtHx44ddeDAAX3xxRfKy8tzJeBnn322nnvuOWVkZOjnn3/WTTfdpJCQkGPGNHXqVM2cOVPPPPOMNm7cqF9++UXz5s2rds3tiRMnyjAMPfLII66YHn/8cd17773aunVrlY8bOnSoVqxY4VHSPHbsWOXn5+vKK6/UypUrtXnzZv33v//VmDFjVF5erh9//FEzZszQzz//rG3btun999/X3r17lZiY6Ipp7dq12rBhg/Ly8qpdNq6kpES7du3Sjh07tGrVKs2YMUMXXXSRzj//fI0cOVJSzf82J5xwgkJDQ12P+/jjj/XQQw9ViGHr1q3asWOHBg0adMz3BgCAalk75B0AAP9wrInIFi9ebPTt29eIiIgwYmJijD59+hgvvfSSa/uTTz5ptGnTxoiIiDCGDh1qLFiwwJBk7Nu3z1XnpptuMlq0aGFIMiZPnmwYhmHs2LHDGDJkiBEVFWV07drV+OyzzyqdEC4jI6NCTG+99ZbRq1cvIzQ01DjuuOOM/v37G++//36l8S9fvtwIDg42vvnmmwrbhgwZYpx99tmGw+Go9LGlpaVG27ZtjcWLF1e6XUdNardx40bj4osvNpo1a2ZEREQY3bt3N+68807D4XAY69atM4YOHWq0bNnSCAsLM7p162Y8++yzrsfu2bPHGDx4sNG0aVNDkvHll19W+pyjRo0yJBmSjCZNmhgtW7Y0Bg0aZLz22mtGeXm5W92a/m0WLlxodOzY0QgLCzNOO+004+OPP67wt5gxY4YxdOjQSmMEAMAbNsM4xkAzAADQ6D3//PP6+OOP9d///tfqUPzGoUOH1LVrVy1cuFD9+vWzOhwAQAPHmHMAAHBMN954o/7880/t379f0dHRVofjF7Zt26b777+fxBwA4BO0nAMAAAAAYDEmhAMAAAAAwGIk5wAAAAAAWIzkHAAAAAAAi5GcAwAAAABgMZJzAAAAAAAsRnIOAAAAAIDFSM4BAAAAALAYyTkAAAAAABYjOQcAAAAAwGL/DyhqJQV1YzTaAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -295,7 +317,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -313,7 +335,7 @@
     }
    ],
    "source": [
-    "#Before running this cell ensure that you have Executed the first cell\n",
+    "#Before running this cell ensure that you have Executed all the previous cells\n",
     "\n",
     "# Generate Linear data\n",
     "X, y = generate_linear_data(n_samples=200, noise=2.0)\n",
@@ -346,7 +368,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -540,7 +562,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -734,14 +756,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "C:\\Users\\NAVEED\\AppData\\Local\\Temp\\ipykernel_8256\\3486327811.py:12: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
+      "C:\\Users\\NAVEED\\AppData\\Local\\Temp\\ipykernel_3152\\3486327811.py:12: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
       "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
       "\n",
       "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",

From 340c379076ac163aa2d8c1279b5b0a35ce9fcfc4 Mon Sep 17 00:00:00 2001
From: NaveedMohiuddin <naveed.mohiuddin.1234@gmail.com>
Date: Thu, 21 Nov 2024 23:26:43 -0600
Subject: [PATCH 3/5] ML-Project2

---
 BoostingTrees/evaluate_model.ipynb | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/BoostingTrees/evaluate_model.ipynb b/BoostingTrees/evaluate_model.ipynb
index 9c2d668..17e0ba2 100644
--- a/BoostingTrees/evaluate_model.ipynb
+++ b/BoostingTrees/evaluate_model.ipynb
@@ -756,22 +756,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\NAVEED\\AppData\\Local\\Temp\\ipykernel_3152\\3486327811.py:12: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
-      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
-      "\n",
-      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
-      "\n",
-      "\n",
-      "  data[column].fillna(data[column].mean(), inplace=True)\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -833,9 +820,9 @@
     "    # Handle missing values\n",
     "    for column in data.columns:\n",
     "        if np.issubdtype(data[column].dtype, np.number):\n",
-    "            data[column].fillna(data[column].mean(), inplace=True)\n",
+    "            data[column].fillna(data[column].mean())\n",
     "        else:\n",
-    "            data[column].fillna(data[column].mode()[0], inplace=True)\n",
+    "            data[column].fillna(data[column].mode()[0])\n",
     "\n",
     "    # Assume the last column is the target\n",
     "    X = data.iloc[:, :-1].values\n",

From 0453ffec9489088bf58142d1cd8e5716144909b1 Mon Sep 17 00:00:00 2001
From: NaveedMohiuddin <naveed.mohiuddin.1234@gmail.com>
Date: Thu, 21 Nov 2024 23:44:49 -0600
Subject: [PATCH 4/5] ML-Project2

---
 BoostingTrees/GradientBoostingTree.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/BoostingTrees/GradientBoostingTree.py b/BoostingTrees/GradientBoostingTree.py
index f9c0321..d2d2b72 100644
--- a/BoostingTrees/GradientBoostingTree.py
+++ b/BoostingTrees/GradientBoostingTree.py
@@ -15,24 +15,24 @@ def fit(self, X, y):
         """
         Fits the gradient boosting model.
         """
-        # Initialize model with a constant value (mean of y)
+        #starting with a constant value (mean of y)
         self.initial_prediction = np.mean(y)
         current_prediction = np.full_like(y, self.initial_prediction, dtype=float)
 
         for estimator in range(self.n_estimators):
-            # Calculate residual errors
+            # Calculate residual errors to know how far we are from the actual target
             residuals = y - current_prediction
 
-            # Fit a regression tree to the residuals
+            # Training a tree to fix these residuals
             tree = DecisionTreeRegressor(max_depth=self.max_depth, min_samples_split=self.min_samples_split)
             tree.fit(X, residuals)
             self.trees.append(tree)
 
-            # Update predictions
+            # updating predictions
             update = tree.predict(X)
             current_prediction += self.learning_rate * update
 
-            # Track loss
+            # Tracking loss
             loss = mean_squared_error(y, current_prediction)
             self.loss_history.append(loss)
 
@@ -55,12 +55,15 @@ def __init__(self, max_depth=3, min_samples_split=2):
         self.tree = None
 
     def fit(self, X, y):
+        #For Building the decision tree.
         self.tree = self._build_tree(X, y, depth=0)
 
     def predict(self, X):
+        #Predictng the target values for input data
         return np.array([self._predict_row(row, self.tree) for row in X])
 
     def _build_tree(self, X, y, depth):
+        #Recursive method to for constructing the decision tree
         num_samples, num_features = X.shape
         if depth >= self.max_depth or num_samples < self.min_samples_split or np.std(y) == 0:
             return np.mean(y)
@@ -106,6 +109,7 @@ def _find_best_split(self, X, y, num_features):
         return best_split if min_error < float("inf") else None
 
     def _predict_row(self, row, tree):
+        #Predicting the target value for a single data row
         if isinstance(tree, dict):
             feature = tree["feature"]
             threshold = tree["threshold"]

From 80d85668d1f41feb289aac9075ec77991102e3c9 Mon Sep 17 00:00:00 2001
From: Naveed Mohiuddin <78361672+NaveedMohiuddin@users.noreply.github.com>
Date: Mon, 7 Jul 2025 22:16:19 -0500
Subject: [PATCH 5/5] Update README.md

---
 README.md | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/README.md b/README.md
index 64bb0c2..b389a18 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,3 @@
-# Project 2
-
-# Submitted by:
-- **Sana Samad**: A20543001
-- **Naveed Mohiuddin**: A20540067
-- **Owaiz Majoriya**: A20546104
 
 ---