{ "cells": [ { "cell_type": "markdown", "id": "5dbe7b9e", "metadata": {}, "source": [ "# Optimization and gradient descent\n", "\n", "Toy example demonstrating optimization via gradient descent with a simple, easy-to-visualize function.\n", "\n", "## Notebook set-up" ] }, { "cell_type": "code", "execution_count": 1, "id": "eb815ffe", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "id": "b7e2e87a", "metadata": {}, "source": [ "## 1. Problem statement\n", "\n", "Dr. P is tired of grading hundreds of labs, problems sets & exams. But, while looking at grades for past semesters, he noticed an interesting phenomenon - there seems to be a strong correlation between attendance and final grade. Maybe we can use a student's attendance to predict their score.\n", "\n", "## 2. Goal\n", "\n", "Write a custom optimization function to fit a linear model to the provided data.\n", "\n", "The goal of this mini-project is to get you thinking about optimization - how do we fit a model to data? How do we quantify 'how good' a model is? The best way to think deeply about a topic is start with a tractable example and think it though.\n", "\n", "## 3. Data" ] }, { "cell_type": "code", "execution_count": 2, "id": "e1a46e0b", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "n = 100\n", "noise_width = 5\n", "attendance = np.array(list(range(n))) + np.random.normal(-noise_width, noise_width, n)\n", "score = np.array(list(range(n))) + np.random.normal(-noise_width, noise_width, n)\n", "\n", "plt.title('Attendance and score: freshman general chemistry')\n", "plt.scatter(attendance, score, color='black')\n", "plt.xlabel('Attendance (%)')\n", "plt.ylabel('Score (%)')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "ea7e7aeb", "metadata": {}, "source": [ "## 4. Model functions\n", "\n", "Write two functions:\n", "\n", "1. **Linear model**: function that accepts three arguments: a list of attendance values, a slope ('m' parameter) and a y-intercept ('b' parameter). The function should then use these three arguments to calculate and return a list of scores.\n", "2. **Error function**: takes list of true scores and list of predicted scores from the linear model as arguments. Calculates the average of the difference between the true and predicted value for each student.\n", "\n", "**Hint**: square or take the absolute value of each difference before averaging them - this prevents the tendency of negative and positive error values to cancel out.\n", "\n", "### 4.1. Linear model" ] }, { "cell_type": "code", "execution_count": 3, "id": "34ebe89f", "metadata": {}, "outputs": [], "source": [ "def linear_model(attendance: list, m: float, b: float) -> np.ndarray:\n", " \"\"\"\n", " Linear model that predicts scores based on attendance.\n", "\n", " Args:\n", " attendance: list/array of attendance percentages\n", " m: slope parameter\n", " b: y-intercept parameter\n", "\n", " Returns:\n", " predicted_scores: list/array of predicted scores\n", " \"\"\"\n", "\n", " predicted_scores = m * np.array(attendance) + b\n", "\n", " return predicted_scores" ] }, { "cell_type": "markdown", "id": "b75b623a", "metadata": {}, "source": [ "### 4.2. Error function" ] }, { "cell_type": "code", "execution_count": 4, "id": "5dacffab", "metadata": {}, "outputs": [], "source": [ "def error_function(true_scores: list, predicted_scores: np.ndarray) -> float:\n", " \"\"\"\n", " Calculate the mean squared error between true and predicted scores.\n", "\n", " Args:\n", " true_scores: list/array of true score values\n", " predicted_scores: list/array of predicted score values\n", "\n", " Returns:\n", " error: mean squared error\n", " \"\"\"\n", "\n", " # Calculate squared differences to prevent positive and negative errors from canceling out\n", " squared_errors = (np.array(true_scores) - np.array(predicted_scores)) ** 2\n", "\n", " # Return the average error\n", " return np.mean(squared_errors)" ] }, { "cell_type": "markdown", "id": "ed8391a9", "metadata": {}, "source": [ "## 5. Optimizer\n", "\n", "Write an optimization function which iteratively tries different values of m and b. The function should calculate the error for a given parameter set (choice of m and b), then update those values based on the size of the error. Along the way, the function should keep the 'winning' values and then return the best parameters at the end. Here are the rough steps the loop should follow:\n", "\n", "1. Pick values for m and b\n", "2. Call the linear model to get predictions for all of the student's scores\n", "3. Call the error function to calculate the error of the predictions relative to the true values\n", "4. Decide how much and in which direction to change the values of m and b\n", "5. Repeat\n", "\n", "**Hints**: \n", "1. Look at the toy data - is it visually obvious what the value of b should be? If you can, set b to a constant. This way you only have to optimize m.\n", "2. Keep a 'memory' of the values you have tried so far and their error values.\n", "\n", "### 5.1. Approach 1: grid search optimizer\n", "\n", "Grid search is a simple optimization technique that involves trying many combinations of parameters in a specified range. This is a brute-force approach and can be computationally expensive, but does a good job finding the optimal solution within the defined grid, as long a enough iterations are run." ] }, { "cell_type": "code", "execution_count": 5, "id": "bba8c59e", "metadata": {}, "outputs": [], "source": [ "def grid_search_optimizer(attendance: list, score: list, linear_model: callable, error_function: callable) -> tuple:\n", " \"\"\"\n", " Optimize the linear model parameters using grid search.\n", "\n", " Args:\n", " attendance: list/array of attendance values\n", " score: list/array of true score values\n", " linear_model: function to make predictions\n", " error_function: function to calculate error\n", "\n", " Returns:\n", " best_m: optimal slope parameter\n", " best_b: optimal y-intercept parameter\n", " m_values: list of all m values tested\n", " errors: list of corresponding errors\n", " \"\"\"\n", "\n", " # Set b to a constant (looking at the data, it starts near 0)\n", " b = 0\n", "\n", " # Define the range of m values to test\n", " m_min, m_max = -0.5, 2.0\n", " num_points = 100\n", " m_values = np.linspace(m_min, m_max, num_points)\n", "\n", " # Convert to numpy arrays for easier computation\n", " attendance_array = np.array(attendance)\n", " score_array = np.array(score)\n", "\n", " # Lists to store results\n", " errors = []\n", " best_error = float('inf')\n", " best_m = None\n", " best_b = b\n", "\n", " print(f\"Starting grid search with {num_points} points from m = {m_min} to m = {m_max}\")\n", " print(f\"Fixed b = {b}\")\n", "\n", " # Test each m value\n", " for i, m in enumerate(m_values):\n", " \n", " # Get predictions with current m value\n", " predictions = linear_model(attendance_array, m, b)\n", " \n", " # Calculate error\n", " current_error = error_function(score_array, predictions)\n", " errors.append(current_error)\n", " \n", " # Keep track of best parameters\n", " if current_error < best_error:\n", " best_error = current_error\n", " best_m = m\n", " \n", " # Print progress every 20 evaluations\n", " if (i + 1) % 20 == 0:\n", " print(f\"Evaluated {i + 1}/{num_points} points: current m = {m:.4f}, error = {current_error:.4f}\")\n", " \n", " print(f\"Grid search complete!\")\n", " print(f\"Best parameters: m = {best_m:.4f}, b = {best_b}\")\n", " print(f\"Best error: {best_error:.4f}\")\n", " print(f\"Total function evaluations: {len(m_values)}\")\n", " \n", " return best_m, best_b, m_values, errors" ] }, { "cell_type": "markdown", "id": "c10c5a2b", "metadata": {}, "source": [ "### 5.2. Approach 2: gradient descent optimizer\n", "Gradient descent is a more sophisticated optimization technique that iteratively adjusts parameters based on the gradient of the error function. It is generally more efficient than grid search, especially for high-dimensional parameter spaces." ] }, { "cell_type": "code", "execution_count": 6, "id": "fffee897", "metadata": {}, "outputs": [], "source": [ "def gradient_descent_optimizer(attendance: list, score: list, linear_model: callable, error_function: callable) -> tuple:\n", " \"\"\"\n", " Optimize the linear model parameters using gradient descent.\n", "\n", " Args:\n", " attendance: list/array of attendance values\n", " score: list/array of true score values\n", " linear_model: function to make predictions\n", " error_function: function to calculate error\n", "\n", " Returns:\n", " best_m: optimal slope parameter\n", " best_b: optimal y-intercept parameter\n", " m_values: list of m values during optimization\n", " errors: list of corresponding errors\n", " \"\"\"\n", "\n", " # Set b to a constant (looking at the data, it starts near 0)\n", " b = 0\n", "\n", " # Randomly initialize slope in the interval [-0.5, 2.0]\n", " np.random.seed(42) # For reproducible results\n", " m = np.random.uniform(-0.5, 2.0)\n", "\n", " # Gradient descent parameters\n", " learning_rate = 0.0001 # Step size for gradient descent\n", " max_iterations = 1000 # Maximum number of iterations\n", " tolerance = 1e-6 # Stop if improvement is less than this\n", "\n", " # Convert to numpy arrays for easier computation\n", " attendance_array = np.array(attendance)\n", " score_array = np.array(score)\n", " n_samples = len(attendance_array)\n", "\n", " # Lists to store the optimization history\n", " m_values = [m]\n", " errors = []\n", "\n", " print(f\"Starting gradient descent with initial m = {m:.4f}, b = {b}\")\n", "\n", " for iteration in range(max_iterations):\n", "\n", " # Forward pass: get predictions\n", " predictions = linear_model(attendance_array, m, b)\n", "\n", " # Calculate current error\n", " current_error = error_function(score_array, predictions)\n", " errors.append(current_error)\n", "\n", " # Calculate gradient of MSE with respect to m\n", " # MSE = (1/n) * sum((y_true - y_pred)^2)\n", " # y_pred = m * x + b\n", " # d(MSE)/dm = (2/n) * sum((y_true - y_pred) * (-x))\n", " # d(MSE)/dm = (-2/n) * sum((y_true - (m*x + b)) * x)\n", " gradient_m = (-2.0 / n_samples) * np.sum((score_array - predictions) * attendance_array)\n", "\n", " # Update parameters using gradient descent\n", " new_m = m - learning_rate * gradient_m\n", "\n", " # Check for convergence\n", " if abs(new_m - m) < tolerance:\n", " print(f\"Converged after {iteration + 1} iterations\")\n", " break\n", "\n", " m = new_m\n", " m_values.append(m)\n", "\n", " # Print progress\n", " print(f\"Iteration {iteration + 1}: m = {m:.4f}, error = {current_error:.4f}\")\n", "\n", " print(f\"Final parameters: m = {m:.4f}, b = {b}\")\n", " print(f\"Final error: {errors[-1]:.4f}\")\n", "\n", " return m, b, m_values, errors" ] }, { "cell_type": "markdown", "id": "441e1253", "metadata": {}, "source": [ "## 6. Results\n", "\n", "Run the model optimization and plot the following:\n", "\n", "1. The final linear model and the grade data on the same plot. How good is the model? Is it a good idea to use this when grading students?\n", "2. The value of m vs the error for all of the values sampled during optimization. Is this the 'best' model? How could the algorithm be improved. Could we make it faster/more efficient?" ] }, { "cell_type": "code", "execution_count": 7, "id": "441e1253", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "============================================================\n", "RUNNING GRID SEARCH OPTIMIZER\n", "============================================================\n", "Starting grid search with 100 points from m = -0.5 to m = 2.0\n", "Fixed b = 0\n", "Evaluated 20/100 points: current m = -0.0202, error = 2996.1074\n", "Evaluated 40/100 points: current m = 0.4848, error = 820.4406\n", "Evaluated 60/100 points: current m = 0.9899, error = 52.6697\n", "Evaluated 80/100 points: current m = 1.4949, error = 692.7946\n", "Evaluated 100/100 points: current m = 2.0000, error = 2740.8153\n", "Grid search complete!\n", "Best parameters: m = 1.0152, b = 0\n", "Best error: 51.2384\n", "Total function evaluations: 100\n", "\n", "============================================================\n", "RUNNING GRADIENT DESCENT OPTIMIZER\n", "============================================================\n", "Starting gradient descent with initial m = 0.4364, b = 0\n", "Iteration 1: m = 0.7545, error = 968.2557\n", "Iteration 2: m = 0.8971, error = 235.3150\n", "Iteration 3: m = 0.9609, error = 88.1791\n", "Iteration 4: m = 0.9896, error = 58.6419\n", "Iteration 5: m = 1.0024, error = 52.7124\n", "Iteration 6: m = 1.0081, error = 51.5220\n", "Iteration 7: m = 1.0107, error = 51.2831\n", "Iteration 8: m = 1.0119, error = 51.2351\n", "Iteration 9: m = 1.0124, error = 51.2255\n", "Iteration 10: m = 1.0126, error = 51.2236\n", "Iteration 11: m = 1.0127, error = 51.2232\n", "Iteration 12: m = 1.0128, error = 51.2231\n", "Iteration 13: m = 1.0128, error = 51.2231\n", "Iteration 14: m = 1.0128, error = 51.2231\n", "Iteration 15: m = 1.0128, error = 51.2231\n", "Iteration 16: m = 1.0128, error = 51.2231\n", "Converged after 17 iterations\n", "Final parameters: m = 1.0128, b = 0\n", "Final error: 51.2231\n", "\n", "============================================================\n", "COMPARISON SUMMARY\n", "============================================================\n", "Grid Search - Best m: 1.0152, Final error: 51.2384, Evaluations: 100\n", "Gradient Descent - Best m: 1.0128, Final error: 51.2231, Evaluations: 17\n", "Error difference: 0.0153\n", "Parameter difference: 0.0024\n" ] } ], "source": [ "# Run both optimizers to compare their performance\n", "\n", "print(\"=\" * 60)\n", "print(\"RUNNING GRID SEARCH OPTIMIZER\")\n", "print(\"=\" * 60)\n", "\n", "# Run the grid search optimizer\n", "grid_m, grid_b, grid_m_values, grid_errors = grid_search_optimizer(attendance, score, linear_model, error_function)\n", "\n", "print(\"\\n\" + \"=\" * 60)\n", "print(\"RUNNING GRADIENT DESCENT OPTIMIZER\")\n", "print(\"=\" * 60)\n", "\n", "# Run the gradient descent optimizer\n", "gd_m, gd_b, gd_m_values, gd_errors = gradient_descent_optimizer(attendance, score, linear_model, error_function)\n", "\n", "# Get predictions from both models\n", "grid_predictions = linear_model(attendance, grid_m, grid_b)\n", "gd_predictions = linear_model(attendance, gd_m, gd_b)\n", "\n", "print(\"\\n\" + \"=\" * 60)\n", "print(\"COMPARISON SUMMARY\")\n", "print(\"=\" * 60)\n", "print(f\"Grid Search - Best m: {grid_m:.4f}, Final error: {min(grid_errors):.4f}, Evaluations: {len(grid_errors)}\")\n", "print(f\"Gradient Descent - Best m: {gd_m:.4f}, Final error: {min(gd_errors):.4f}, Evaluations: {len(gd_errors)}\")\n", "print(f\"Error difference: {abs(min(grid_errors) - min(gd_errors)):.4f}\")\n", "print(f\"Parameter difference: {abs(grid_m - gd_m):.4f}\")" ] }, { "cell_type": "code", "execution_count": 8, "id": "7c8c3958", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAMWCAYAAADs4eXxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FNX6wPHvbsqmNwgpQEgILQkdFEIX0FAFO4hSLEgTARHFH9IFRUSkW+6lKSp2rwiKVCkCUkMSWkhAkCRAekg2Zef3R+7OzZJNsmkkgffzPPvATtszJ5vMvHPOeY9GURQFIYQQQgghhBBCVDhtVRdACCGEEEIIIYS4W0nQLYQQQgghhBBCVBIJuoUQQgghhBBCiEoiQbcQQgghhBBCCFFJJOgWQgghhBBCCCEqiQTdQgghhBBCCCFEJZGgWwghhBBCCCGEqCQSdAshhBBCCCGEEJVEgm4hhBBCCCGEEKKSSNAtKsXIkSPx9/cvcbvY2Fg0Gg3r1q2r9DJVFX9/fwYMGFDVxbin+Pv7M3LkyHIfp0ePHvTo0aPcxykvjUbD7Nmzq7oYRSpPPVXUz0oIcXeR+4j/qer7iOpyLRSiJpOgW5iIiYlhwoQJNGnSBAcHBxwcHAgODmb8+PGcOnWqSssWGxvLqFGjCAwMxM7ODm9vb7p168asWbOqtFxVYffu3Wg0GvWl0+nw8vKiR48eLFiwgOvXr5f52JGRkcyePZvY2NiKK3A1VbAOC768vb3Nbv/PP/8we/ZsTpw4UWjdpk2bWLp0aeUWuBjGG0+NRsP8+fPNbjNs2DA0Gg1OTk53uHRCiHuF3EfUHFIflil4fTX3euedd6q6iKIGsK7qAojq4+eff+app57C2tqaYcOG0apVK7RaLWfOnOG7775j9erVxMTE0KBBgxKP9cknn2AwGCqsbBcuXOC+++7D3t6e5557Dn9/f65du8axY8d49913mTNnToV9Vk0yceJE7rvvPvLy8rh+/ToHDhxg1qxZLFmyhM2bN9OzZ89SHzMyMpI5c+bQo0cPi1oZaroHH3yQ4cOHmyyzt7cH4LfffjNZ/s8//zBnzhz8/f1p3bq1ybpNmzZx+vRpJk2aVJnFLZGdnR1ffPEFM2bMMFmekZHBjz/+iJ2dXRWVTAhxt5P7iJpD6qP0hg4dSr9+/Qotb9OmTRWURtQ0EnQLAKKjoxkyZAgNGjRgx44d+Pj4mKx/9913WbVqFVpt8Z0jMjIycHR0xMbGpkLL98EHH5Cens6JEycKXawTEhIq9LMsYTzPqta1a1cef/xxk2UnT57koYce4rHHHiMyMrLQz1KYatKkCc8884zZdba2tne4NOXXr18/vvvuO06ePEmrVq3U5T/++CPZ2dn06dOHnTt3VmEJhRB3I7mPKJ2qvo+obvVRE7Rt27bI+4WiKIpCVlaW+jC/oKysLGxtbUv8nShOVX+PhOWke7kAYNGiRWRkZLB27VqzQZq1tTUTJ06kfv366rKRI0fi5OREdHQ0/fr1w9nZmWHDhqnrbm8lTU5OZuTIkbi6uuLm5saIESNITk62qHzR0dHUq1fP7NPxOnXqFFq2detWunbtiqOjI87OzvTv35+IiAiTbU6dOsXIkSNp2LCh2q3queee4+bNmybbzZ49G41GQ2RkJE8//TTu7u506dJFXf/ZZ59x//334+DggLu7O926dSvUQgqwb98+7r//fuzs7GjYsCEbNmwwe57R0dEW1UlRWrVqxdKlS0lOTmbFihXq8kuXLjFu3DiaNm2Kvb09tWrV4oknnjDpRr5u3TqeeOIJAB544AG169Tu3buB/MCtf//++Pr6otPpCAwMZN68eeTl5ZVYLks+31gGjUbD/v37mTJlCp6enjg6OvLII48U6javKArz58+nXr16ODg48MADDxT6OZdHwXFsu3fv5r777gNg1KhRat2sW7eOHj16sGXLFi5duqQuL/j91+v1zJo1i0aNGqHT6ahfvz7Tpk1Dr9ebfJ5er2fy5Ml4enri7OzMww8/zJUrV0pV5tDQUAICAti0aZPJ8s8//5w+ffrg4eFhdr9Vq1YREhKCTqfD19eX8ePHm/39/PjjjwkMDMTe3p7777+fP/74w+zxLD1nIcTdQe4jatZ9RGnr43YJCQk8//zzeHl5YWdnR6tWrVi/fr3JNsZu2YsXL+aDDz6gQYMG2Nvb0717d06fPl3omGfOnOHxxx/Hw8MDOzs72rdvz08//VRsOXJycvDw8GDUqFGF1qWmpmJnZ8fUqVPVZcuXLyckJESt6/bt2xe6XpaHcfz9r7/+Svv27bG3t+ejjz5ShwV++eWXzJgxg7p16+Lg4EBqaioAX3/9Ne3atcPe3p7atWvzzDPPcPXqVZNjF/f7Iqo/aekWQH6XsEaNGtGhQ4dS7Zebm0tYWBhdunRh8eLFODg4mN1OURQGDRrEvn37GDNmDEFBQXz//feMGDHCos9p0KABv//+Ozt37iyxy/TGjRsZMWIEYWFhvPvuu9y6dYvVq1fTpUsXjh8/rl7Et2/fzsWLFxk1ahTe3t5ERETw8ccfExERwZ9//olGozE57hNPPEHjxo1ZsGABiqIAMGfOHGbPnk2nTp2YO3cutra2HDp0iJ07d/LQQw+p+164cIHHH3+c559/nhEjRvDvf/+bkSNH0q5dO0JCQtTtevXqBVDu8dTGz/rtt994++23AThy5AgHDhxgyJAh1KtXj9jYWFavXk2PHj2IjIzEwcGBbt26MXHiRJYtW8abb75JUFAQgPrvunXrcHJyYsqUKTg5ObFz505mzpxJamoq7733XrFlsuTzC3r55Zdxd3dn1qxZxMbGsnTpUiZMmMBXX32lbjNz5kzmz59Pv3796NevH8eOHeOhhx4iOzvb4rrKysrixo0bJsucnZ3R6XQmy4KCgpg7dy4zZ85k9OjRdO3aFYBOnTpRt25dUlJSuHLlCh988AGAOm7aYDDw8MMPs2/fPkaPHk1QUBDh4eF88MEHnDt3jh9++EH9jBdeeIHPPvuMp59+mk6dOrFz50769+9v8bkYDR06lM8++4x33nkHjUbDjRs3+O2339i4cSPbtm0rtP3s2bOZM2cOvXv3ZuzYsZw9e5bVq1dz5MgR9u/fr7Y4/etf/+Kll16iU6dOTJo0iYsXL/Lwww/j4eFhciNdmnMWQtwd5D6iZt1HlKY+bpeZmUmPHj24cOECEyZMICAggK+//pqRI0eSnJzMK6+8YrL9hg0bSEtLY/z48WRlZfHhhx/Ss2dPwsPD8fLyAiAiIoLOnTtTt25d3njjDRwdHdm8eTODBw/m22+/5ZFHHjFbFhsbGx555BG+++47PvroI5Meaj/88AN6vZ4hQ4YA+UMWJk6cyOOPP84rr7xCVlYWp06d4tChQzz99NMlnvetW7cK3S8AuLm5YW39v5Dq7NmzDB06lJdeeokXX3yRpk2bquvmzZuHra0tU6dORa/XY2try7p16xg1ahT33XcfCxcuJD4+ng8//JD9+/dz/Phx3Nzc1P0t/X0R1ZAi7nkpKSkKoAwePLjQuqSkJOX69evq69atW+q6ESNGKIDyxhtvFNpvxIgRSoMGDdT3P/zwgwIoixYtUpfl5uYqXbt2VQBl7dq1xZbx9OnTir29vQIorVu3Vl555RXlhx9+UDIyMky2S0tLU9zc3JQXX3zRZHlcXJzi6upqsrzguRh98cUXCqDs3btXXTZr1iwFUIYOHWqy7fnz5xWtVqs88sgjSl5ensk6g8Gg/r9BgwaFjpmQkKDodDrl1VdfNdmvQYMGJvVWlF27dimA8vXXXxe5TatWrRR3d3f1vbnzPXjwoAIoGzZsUJd9/fXXCqDs2rWr0PbmjvHSSy8pDg4OSlZWVrFltvTz165dqwBK7969Tepx8uTJipWVlZKcnKwoSn4d2traKv379zfZ7s0331QAZcSIEcWWR1EUBTD7Mn4fu3fvrnTv3l3d/siRI0V+X/v372/2Z7dx40ZFq9Uqf/zxh8nyNWvWKICyf/9+RVEU5cSJEwqgjBs3zmS7p59+WgGUWbNmFXsuMTExCqC89957yunTpxVA/cyVK1cqTk5OSkZGhjJixAjF0dFR3c9Yjw899JDJ93jFihUKoPz73/9WFEVRsrOzlTp16iitW7dW9Hq9ut3HH3+sACb1ZOk5K0r+d96Sn5UQovqS+4j/qSn3EZbWh6IUvhYuXbpUAZTPPvtMXZadna2EhoYqTk5OSmpqqqIo/7su2dvbK1euXFG3PXTokAIokydPVpf16tVLadGihcm9hMFgUDp16qQ0bty42HP59ddfFUD5z3/+Y7K8X79+SsOGDdX3gwYNUkJCQkqomcKM51HU6+DBg+q2xp/Vtm3bTI5hvG9r2LChyffGeG1t3ry5kpmZqS7/+eefFUCZOXOmuqy43xdR/Un3cqF2bTGX0bhHjx54enqqr5UrVxbaZuzYsSV+xi+//IK1tbXJtlZWVrz88ssWlTEkJIQTJ07wzDPPEBsby4cffsjgwYPx8vLik08+Ubfbvn07ycnJDB06lBs3bqgvKysrOnTowK5du9RtC46vMbZ2duzYEYBjx44VKsOYMWNM3v/www8YDAZmzpxZaDzO7U+3g4OD1ZZRAE9PT5o2bcrFixdNtouNja2wrOFOTk6kpaWp7wueb05ODjdv3qRRo0a4ubmZPV9zCh4jLS2NGzdu0LVrV27dusWZM2cs3teSzx89erRJPXbt2pW8vDwuXboEwO+//052djYvv/yyyXalTWQ2aNAgtm/fbvIKCwsr1TGK8/XXXxMUFESzZs1MvpPGlgXjd/KXX34B8pPjFVSWxGwhISG0bNmSL774AshP8jZo0CCzT8SN9Thp0iST7/GLL76Ii4sLW7ZsAeCvv/4iISGBMWPGmLQkGLt6luWchRB3B7mPqHn3EZbWhzm//PIL3t7eDB06VF1mY2PDxIkTSU9PZ8+ePSbbDx48mLp166rv77//fjp06KBe9xITE9m5cydPPvmkem9x48YNbt68SVhYGOfPny/U1bqgnj17Urt2bZOecElJSWzfvp2nnnpKXebm5saVK1c4cuRIifVjzujRowvdL2zfvp3g4GCT7QICAoq8jxgxYoTJ98Z4bR03bpxJotP+/fvTrFkz9RpckCW/L6L6ke7lAmdnZwDS09MLrfvoo49IS0sjPj7ebPIIa2tr6tWrV+JnXLp0CR8fn0IX5IJdbkrSpEkTNm7cSF5eHpGRkfz8888sWrSI0aNHExAQQO/evTl//jxAkV2lXFxc1P8nJiYyZ84cvvzyy0JJQ1JSUgrtGxAQYPI+OjoarVZb6I+tOX5+foWWubu7k5SUVOK+ZZWenq7+bCG/O9jChQtZu3YtV69eVbu2gfnzNSciIoIZM2awc+dO9SbL0mOU9vNvrzN3d3cAtc6MwXfjxo1NtvP09FS3tUS9evXo3bu3xduX1vnz54mKisLT09PseuN379KlS2i1WgIDA03Wl+Z3pKCnn36a999/n8mTJ3PgwAHefPNNs9sZ6/H2z7G1taVhw4bq+qLq28bGhoYNG5oss/SchRB3B7mPqJn3EZbUhzmXLl2icePGhR4UGIeiGa8XRrdfN4yfvXnzZiC/67yiKLz11lu89dZbZj8zISHBJHAvyNramscee4xNmzah1+vR6XR899135OTkmATdr7/+Or///jv3338/jRo14qGHHuLpp5+mc+fORdSQqcaNG1t0v3D7z7m4dUVdgwGaNWvGvn37TJZZ+vsiqh8JugWurq74+PiYTWphHJtV1FNTnU5XrqyLZWFlZUWLFi1o0aIFoaGhPPDAA3z++ef07t1bnV5k48aNZudaLjjm5sknn+TAgQO89tprtG7dGicnJwwGA3369DE7TYm5zJOlKbM5BQPPipSTk8O5c+do3ry5uuzll19m7dq1TJo0idDQUFxdXdFoNAwZMsSiaVmSk5Pp3r07Li4uzJ07V53X89ixY7z++uslHqO0n3+n66yyGAwGWrRowZIlS8yuLzgWuiINHTqU6dOn8+KLL1KrVi2TsYGVrarOWQhRNeQ+ombfRxRXH3eCsa6mTp1aZAtxo0aNij3GkCFD+Oijj9i6dSuDBw9m8+bNNGvWzGQWj6CgIM6ePcvPP//Mtm3b+Pbbb1m1ahUzZ86s0CnSivs5l+c7AFXz+yIqhgTdAsjvxvLpp59y+PBh7r///go/vnEKkfT0dJOn1GfPni3Xcdu3bw/AtWvXANRWwjp16hR7sUhKSmLHjh3MmTOHmTNnqsuNT7gtERgYiMFgIDIystCczVXtm2++ITMz0+Ti9c033zBixAjef/99dVlWVlahzK+3d2kz2r17Nzdv3uS7776jW7du6vKYmBiLy2TJ51vKmHH1/PnzJi2t169fr7QeBEXVTXHrAgMDOXnyJL169Sp2/wYNGmAwGIiOjjZ54l3W3xE/Pz86d+7M7t27GTt2rMmN4u2fa/ycgvWYnZ1NTEyM+ntUsL4LtgDl5OQQExNjcmNj6TkLIe4ech+Rr6bfR9xeH+Y0aNCAU6dOYTAYTAJA4zCz2zOim6uTc+fOqQnpjNceGxubMgf63bp1w8fHh6+++oouXbqwc+dO/u///q/Qdo6Ojjz11FM89dRTZGdn8+ijj/L2228zffp0k+7dd0rBa/DtvSvOnj1r0Zz2omaQRyUCgGnTpuHg4MBzzz1HfHx8ofXlfZLar18/cnNzWb16tbosLy+P5cuXW7T/H3/8QU5OTqHlxvFAxiAlLCwMFxcXFixYYHZ745RTxifGt5/X0qVLLSoP5I9R0mq1zJ07t9AT7bLWV0VMGXby5EkmTZqEu7s748ePV5dbWVkVKtfy5csLTfdlnO/x9mDYXJ1lZ2ezatUqi8pl6edbqnfv3tjY2LB8+XKT45bmZ1haRdWNcZ257oRPPvkkV69eNTtGLjMzk4yMDAD69u0LwLJly0y2Kc/5zJ8/n1mzZhU75rF3797Y2tqybNkyk3r817/+RUpKipo9vX379nh6erJmzRqT7PDr1q0rVB+WnrMQ4u4h9xH5asp9hKX1YU6/fv2Ii4szGUOdm5vL8uXLcXJyonv37ibb//DDDyZjsg8fPsyhQ4fU616dOnXo0aMHH330kdlg//bpQs3RarU8/vjj/Oc//2Hjxo3k5uaadC0HCk3lZmtrS3BwMIqimK2LO6F9+/bUqVOHNWvWmEypuXXrVqKioso0g4monqSlWwD541Q2bdrE0KFDadq0KcOGDaNVq1YoikJMTAybNm1Cq9WWeRzJwIED6dy5M2+88QaxsbEEBwfz3XffWTyW+N133+Xo0aM8+uijtGzZEshPUrJhwwY8PDzUZFMuLi6sXr2aZ599lrZt2zJkyBA8PT25fPkyW7ZsoXPnzqxYsQIXFxe6devGokWLyMnJoW7duvz2228Wt9pCflen//u//2PevHl07dqVRx99FJ1Ox5EjR/D19WXhwoWlrqfSThn2xx9/kJWVRV5eHjdv3mT//v389NNPuLq68v3335t0jRswYAAbN27E1dWV4OBgDh48yO+//06tWrVMjtm6dWusrKx49913SUlJQafT0bNnTzp16oS7uzsjRoxg4sSJaDQaNm7caPGNgaWfbylPT0+mTp3KwoULGTBgAP369eP48eNs3bqV2rVrl+mYJQkMDMTNzY01a9bg7OyMo6MjHTp0ICAggHbt2vHVV18xZcoU7rvvPpycnBg4cCDPPvssmzdvZsyYMezatYvOnTuTl5fHmTNn2Lx5szqXZ+vWrRk6dCirVq0iJSWFTp06sWPHDi5cuFDm8nbv3r3Qzc/tPD09mT59OnPmzKFPnz48/PDDnD17llWrVnHfffepYzBtbGyYP38+L730Ej179uSpp54iJiaGtWvXFhrTbek5CyHuHnIfUbPuIyytD3NGjx7NRx99xMiRIzl69Cj+/v5888037N+/n6VLl5rkkzGeZ5cuXRg7dix6vZ6lS5dSq1Ytpk2bpm6zcuVKunTpQosWLXjxxRdp2LAh8fHxHDx4kCtXrnDy5MkSz/2pp55i+fLlzJo1ixYtWqhjzI0eeughvL296dy5M15eXkRFRbFixQr69+9fqMzmHDt2jM8++6zQ8sDAQEJDQ0vc3xwbGxveffddRo0aRffu3Rk6dKg6ZZi/vz+TJ08u03FFNXRHc6WLau/ChQvK2LFjlUaNGil2dnaKvb290qxZM2XMmDHKiRMnTLa9feqh29fdPmXFzZs3lWeffVZxcXFRXF1dlWeffVY5fvy4RVN97N+/Xxk/frzSvHlzxdXVVbGxsVH8/PyUkSNHKtHR0YW237VrlxIWFqa4uroqdnZ2SmBgoDJy5Ejlr7/+Ure5cuWK8sgjjyhubm6Kq6ur8sQTTyj//PNPoemZjFN9XL9+3WzZ/v3vfytt2rRRdDqd4u7urnTv3l3Zvn27ur5BgwZK//79C+13+xQcxm1LM2WY8WVjY6N4enoq3bp1U95++20lISGh0D5JSUnKqFGjlNq1aytOTk5KWFiYcubMGbNTNn3yySdKw4YNFSsrK5Ppw/bv36907NhRsbe3V3x9fZVp06apU3WYm2KsLJ9vnDLsyJEjZs+54Ofk5eUpc+bMUXx8fBR7e3ulR48eyunTpy2ehgpQxo8fX+R6cz+jH3/8UQkODlasra1Nvrvp6enK008/rbi5uSmAyc8xOztbeffdd5WQkBD1e9KuXTtlzpw5SkpKirpdZmamMnHiRKVWrVqKo6OjMnDgQOXvv/8u9ZRhxSnq93bFihVKs2bNFBsbG8XLy0sZO3askpSUVGi7VatWKQEBAYpOp1Pat2+v7N2712w9WXrOMmWYEHcXuY+oGfcRpakPc58THx+vXtNtbW2VFi1aFPoZFLwuvf/++0r9+vUVnU6ndO3aVTl58mShMkVHRyvDhw9XvL29FRsbG6Vu3brKgAEDlG+++abE81GU/CnG6tevrwDK/PnzC63/6KOPlG7duim1atVSdDqdEhgYqLz22msm1yRzSpoyrOA1rKifVUlTvX711Vfqd8DDw0MZNmyYyTRrilL874uo/jSKUsOyEgkhhBBCCCGqtdjYWAICAnjvvfeYOnVqVRdHiColY7qFEEIIIYQQQohKIkG3EEIIIYQQQghRSSToFkIIIYQQQgghKomM6RZCCCGEEEIIISqJtHQLIYQQQgghhBCVRIJuIYQQQgghhBCiklhXdQGqA4PBwD///IOzszMajaaqiyOEEOIeoigKaWlp+Pr6otXKs/DSkmu4EEKIqmLxNbwqJwnfs2ePMmDAAMXHx0cBlO+//95kvcFgUN566y3F29tbsbOzU3r16qWcO3fOZJubN28qTz/9tOLs7Ky4uroqzz33nJKWllaqcvz999/FTnovL3nJS17ykldlv/7+++/yXlbvSXINl5e85CUveVX1q6RreJW2dGdkZNCqVSuee+45Hn300ULrFy1axLJly1i/fj0BAQG89dZbhIWFERkZiZ2dHQDDhg3j2rVrbN++nZycHEaNGsXo0aPZtGmTxeVwdnYG4O+//8bFxaViTq6KGAwGrl+/jqenp7SYlEDqqnSkviwndWU5qStITU2lfv366rVIlE5FXsPl+2g5qavSkfoqnYL1FRwczLVr1/Dx8eHMmTNVXbRqSb5fpVOR9WXpNbxKg+6+ffvSt29fs+sURWHp0qXMmDGDQYMGAbBhwwa8vLz44YcfGDJkCFFRUWzbto0jR47Qvn17AJYvX06/fv1YvHgxvr6+FpXD2B3NxcXlrgi6s7KycHFxkV+6EkhdlY7Ul+WkriwndfU/0jW6bCryGi7fR8tJXZWO1FfpmKsvrVZb4+/TK4t8v0qnMuqrpGt4tR3THRMTQ1xcHL1791aXubq60qFDBw4ePMiQIUM4ePAgbm5uasAN0Lt3b7RaLYcOHeKRRx6piqILIYQQQgghKsCaNWvIzMzE3t6+qosiRJlV26A7Li4OAC8vL5PlXl5e6rq4uDjq1Kljst7a2hoPDw91G3P0ej16vV59n5qaCuQ/9TAYDBVS/qpiMBhQFKXGn8edIHVVOlJflpO6spzUFff0uQshREkGDBhQ1UUQotyqbdBdmRYuXMicOXMKLb9+/TpZWVlVUKKKYzAYSElJQVEU6V5SAqmr0pH6spzUleWkriAtLa2qiyCEEEKISlRtg25vb28A4uPj8fHxUZfHx8fTunVrdZuEhAST/XJzc0lMTFT3N2f69OlMmTJFfW8cAO/p6VnkWBGDwUB2dnZZT+eOMRgM5ObmypgOC0hdlU556svGxgYrK6tKKln1YzAY0Gg0ktDEAlJXqIlBReXJy8sjJyenxO0MBgM5OTlkZWXds99HS0ldlU5Z6+teu34KcbeqtkF3QEAA3t7e7NixQw2yU1NTOXToEGPHjgUgNDSU5ORkjh49Srt27QDYuXMnBoOBDh06FHlsnU6HTqcrtFyr1Zr9Q5idnU1MTEyN6AJo7KaZnp4uSXlKIHVVOuWtLzc3N7y9ve+ZutZoNEX+TRGm7vW6ulfP+05QFIW4uDiSk5Mt3t5gMJCWlnbP/K0qK6mr0ilPfd1r18/bHT16lOzsbGxtbdX7fSFqmioNutPT07lw4YL6PiYmhhMnTuDh4YGfnx+TJk1i/vz5NG7cWJ0yzNfXl8GDBwMQFBREnz59ePHFF1mzZg05OTlMmDCBIUOGWJy5vCSKonDt2jWsrKyoX79+tb85UhSF3NxcrK2t79k/zpaSuiqdstaXoijcunVL7ZVSsOeKEEJUJmPAXadOHRwcHEr82yXXBctJXZVOWepLrp/5Bg0axNWrV6lbty5Xrlyp6uIIUSZVGnT/9ddfPPDAA+p7Y5fvESNGsG7dOqZNm0ZGRgajR48mOTmZLl26sG3bNpOueJ9//jkTJkygV69eaLVaHnvsMZYtW1ZhZczNzeXWrVv4+vri4OBQYcetLHIRtJzUVemUp76MGUcTEhKoU6eOdJUTQlS6vLw8NeCuVauWRfvIdcFyUlelU9b6kuunEHeHKg26e/TogaIoRa7XaDTMnTuXuXPnFrmNh4cHmzZtqoziAfkXbQBbW9tK+wwh7gXGh1Y5OTly0yBqLIPBQEREBElJSbi7uxMSElLte0Ddq4xjuGvCA3MhiiPXTyFqvmo7pru6kae4QpSP/A6Jmu7AgQOsWLGCqKgo9Ho9Op2OoKAgJkyYQKdOnaq6eKIIpfnbk50Nej3odPkvIaoDuX4KUfPJ43khhBCiBAcOHGDq1KkcO3YMNzc3/P39cXNz4/jx40ydOpUDBw5UdRFFOeTlwaVLcP68Qny8gXPn8t//t7ObEEIIUS4SdIsaZ/bs2WpGeyGEqGwGg4EVK1aQmJhIo0aNcHJywsrKCicnJwIDA0lKSmLlypU1YoYLYd7VqwaysjJwckrG1laPRgPJySA5m6onRVEYPXo0Hh4eaDQaTpw4UWVliY2NrfIyCCGqPwm671KjRo1Co9Gg0WiwsbHBy8uLBx98kH//+9+lvjFct24dbm5ulVPQMpg6dSo7duwo1T7+/v4sXbq0cgokhLirRUREEBUVhY+PDxqNBkVRSE1N5ebNm6SlpeHl5UVkZCQRERFVXVRRBno9pKaCTqdHo1HQanOwslLQavOX6/V3tjzGa3dRr9mzZ9/ZAlVD27ZtY926dfz8889cu3aN5s2b35HPHTlypDqDjlH9+vXvaBmEEDWTjOm+Q6oi+U6fPn1Yu3YteXl5xMfHs23bNl555RW++eYbfvrpJ6yta+aP38nJCScnp6ouhhDiHpGUlIRer8fe3p7ExETOnz9PRkYGiqJgbW2Nk5MTtra2JCUlVXVRRRnk5EBenpbcXB02NlmAgrV1NgaDHbm5+evv5Pjua9euqf//6quvmDlzJmfPnlWXFbz+KYpCXl5etbme5+XlodFoCt3fGOdYLq2i9ouOjsbHx6da5FKwsrLC29u7qoshhKjmpKX7Djhw4ADPPPMMw4cPZ8yYMQwfPpxnnnmm0scA6nQ6vL29qVu3Lm3btuXNN9/kxx9/ZOvWraxbt07dbsmSJbRo0QJHR0fq16/PuHHjSE9PB2D37t2MGjWKlJSUQk/ZN27cSPv27XF2dsbb25unn35anUuyKP7+/sybN4+hQ4fi6OhI3bp1Wblypck2ly9fZtCgQTg5OeHi4sKTTz5JfHy8uv727uXGJ8+LFy/Gx8eHWrVqMX78eDVzbY8ePbh06RKTJ09WzwHg0qVLDB48GA8PDxwdHQkJCeGXX34pa3ULIe5S7u7u6HQ6Lly4wJEjR7hx4wZZWVlkZ2ej1+u5efMm169f59KlS1VdVFEGNjag1YJe/7/I2to6C4Mhv7XbxubOlsfb21t9ubq6otFo1PdnzpzB2dmZrVu30q5dO3Q6Hfv27TPbAjtp0iR69OihvjcYDCxcuJCAgADs7e1p1aoV33zzTbFl0ev1TJ06lbp16+Lo6EiHDh3YvXu3un7Dhg24u7vz008/ERwcjE6n4/Lly+q1fvjw4bi4uDB69GgAvv32W0JCQtDpdPj7+/P++++bfF5R+xU0cuRIXn75ZS5fvoxGo8Hf31/d9/Yeba1btzbpGaDRaPj000955JFHcHBwoHHjxvz0008m+0RERDBgwABcXFxwdnama9euREdHM3v2bNavX8+PP/6o3kvs3r3bbPfyPXv2cP/996PT6fDx8eGNN94gNzdXXd+jRw8mTpzItGnT8PDwwNvbW3owCHGXk6C7klW35Ds9e/akVatWfPfdd+oyrVbLsmXLiIiIYP369ezcuZNp06YB0KlTJ5YuXYqLiwvXrl3j2rVrTJ06FcifumLevHmcPHmSH374gdjYWEaOHFliGd577z1atWrF8ePHeeONN3jllVfYvn07kH9TMGjQIBITE9mzZw/bt2/n4sWLPPXUU8Uec9euXURHR7Nr1y7Wr1/PunXr1AcL3333HfXq1WPu3LnqOQBMmDCB7Oxs9uzZQ3h4OO+++660oAtRQxkMBsLDw9m7dy/h4eEVOr46JCSE2rVrEx0drc6za2VlhVarJS8vT72Z3rp1q4zrroF0OnBxgdxca3Jz81uMNZo8NJpcXFyqZxbzN954g3feeYeoqChatmxp0T4LFy5kw4YNrFmzhoiICCZPnswzzzzDnj17itxnwoQJHDx4kC+//JJTp07xxBNP0KdPH86fP69uc+vWLd59910+/fRTIiIiqFOnDgCLFy9Wr/VvvfUWR48e5cknn2TIkCGEh4cze/Zs3nrrLZNGAHP73e7DDz9k7ty51KtXj2vXrnHkyBGLzt9ozpw5PPnkk5w6dYp+/foxbNgwEhMTAbh69SrdunVDp9Oxc+dOjh49ynPPPUdubi5Tp07lySefpE+fPuq9hLmW9qtXr9KvXz/uu+8+Tp48yerVq/nXv/7F/PnzTbZbv349jo6OHDp0iEWLFjF37lz1XkgIcfepHv2R7lK3J98xtrAak+9ER0ezcuVKOnbseEfneW3WrBmnTp1S30+aNEn9v7+/P/Pnz2fMmDGsWrUKW1tbkyftBT333HPq/xs2bMiyZcu47777SE9PLzZ47dy5M2+88QYATZo0Yf/+/XzwwQc8+OCD7Nixg/DwcGJiYqhfvz6Q/yQ9JCSEI0eOcN9995k9pru7OytWrMDKyopmzZrRv39/duzYwYsvvoiHhwdWVlZqi7zR5cuXGTx4MC1atECj0dCwYUPLK1EIUW3ciam80tPTURRFfW8c221cptPp1HHdLVq0qJDPFJVj27ZtZGVlmSxTFMjI4L9dtXNRFNBorHBwsOb48Yr5XDs7O/r06VMhx5o7dy4PPvigxdvr9XoWLFjA77//TmhoKJB/3d63bx8fffQR3bt3L7TP5cuXWbt2LZcvX8bX1xfIz6mybds21q5dy9tvvw3kP4BftWoVrVq1Mtm/Z8+evPrqq+r7YcOG0atXLzWQbtKkCZGRkbz33nsmD+xv3+92rq6uODs7l7lb98iRIxk6dCgACxYsYNmyZRw+fJg+ffqwcuVKXF1d+fLLL7H5bxeHJk2aqPva29uj1+uL/dxVq1ZRv359VqxYgUajoVmzZvzzzz+8/vrrvPnmm+p2LVu2ZNasWQA0btyYFStWsGPHjlL9XO8VUVFRKIoiU6eJGk2C7kp0e/KdgoxBbFXcpN3+h+v3339n4cKFnDlzhtTUVHJzc8nKyuLWrVs4ODgUeZyjR48ye/ZsTp48SVJSktrCc/nyZYKDg4vcz3jBL/je2CUsKiqK+vXrqwE3QHBwMG5ubkRFRRUZdIeEhGBlZaW+9/HxITw8vOhKAF5++WXGjRvHjh076N27N4899pjFLQZCiOrB2JsoMTERHx8f7O3tyczMVHsTLV68uNyBd0REBDdu3FDHlubl5WEwGNRElTqdjtzcXFJTU2Vcdw2QlZVFZmZmoeX5lxBFHZqk0UBmpk21vNFv3759qba/cOECt27dKhTQZWdn06ZNG7P7hIeHk5eXZxJ0Qn4AX6tWLfW9ra2t2Wvn7WWMiopi0KBBJss6d+7M0qVLycvLU6/hpT230ipYVkdHR1xcXNShcSdOnKBr165qwF0WUVFRhIaGmnxvOnfuTHp6OleuXFEf8N9eZz4+PiUO0btXOTs7V3URhCg3CborUcHkO+bY29sTHx9/x2/SoqKiCAgIAPKnuhgwYABjx47l7bffxsPDg3379vH888+TnZ1dZNCdkZFBWFgYYWFhfP7553h6enL58mXCwsLIzs6+k6cDUOgCqdFoSuzm+cILL9CrVy9+/fVXtm/fzsKFC3n//fd5+eWXK7OoQogKcqd6EyUlJZGXl4etrS02NjYoCmRnPwLocHD4HsglIyMDKysr3N3dK+bkRKWxs7Mrdn1OTo56/dBo8ocSFHimW2mfWxqOjo4m77VarUlPDEB9eACoeVq2bNlC3bp1TbbTFdF/Pj09HSsrK44ePWryUBtMk7nZ29ubfTBxexktVdb9SqoDo+LuF4q6X6sMZblvEULUXBJ0VyJj8p3MzEyz3a0zMzPR6XR39CZt586dhIeHM3nyZCC/tdpgMPD++++rN6WbN2822cfW1pa8vDyTZWfOnOHmzZu88847aqv0X3/9ZVEZ/vzzz0Lvg4KCAAgKCuLvv//m77//Vo8bGRlJcnJysa3nJTF3DpA/1ceYMWMYO3Ys06dP55NPPpGgW4ga4k71JnJ3d8fFxYWMjAzS0vzJzDykrtNqbbCx2ai2CIaEhJT5c8SdUVwXb0VRyMrK5ubNdHJzwWCwIiPDFRcXDfXqUSHBd2Xw9PTk9OnTJstOnDihBnYFk5yZ60puTps2bcjLyyMhIYGuXbsWWn97gFuSoKAg9u/fb7Js//79NGnSpFBQXxaenp4mmd9TU1OJiYkp1TFatmzJ+vXrycnJMdvaXdS9REFBQUF8++23Jr0K9+/fj7OzM/Xq1StVeYQQdw9JpFaJQkJCCAoKIi4urtDFSVEU4uLiCA4OrrSbNL1eT1xcHFevXuXYsWMsWLCAQYMGMWDAAIYPHw5Ao0aNyMnJYfny5Vy8eJGNGzeyZs0ak+P4+/uTnp7Ojh07uHHjBrdu3cLPzw9bW1t1v59++ol58+ZZVK79+/ezaNEizp07x8qVK/n666955ZVXAOjduzctWrRg2LBhHDt2jMOHDzN8+HC6d+9eri5n/v7+7N27l6tXr3Ljxg0gfyz7b7/9RkxMDMeOHWPXrl1q8C+EqP4s6U2k1+vL3ZsoJCSE4OBg0tM/NQm4811S81hMnz79jubnEJUjKUlLZmZ+wGVllYe1dQ7JyXDlStWWqzg9e/bkr7/+YsOGDZw/f55Zs2aZBOHOzs5MnTqVyZMns379eqKjozl27BjLly9n/fr1Zo/ZpEkThg0bxvDhw/nuu++IiYnh8OHDLFy4kC1btpS6jK+++io7duxg3rx5nDt3jvXr17NixQo1OWt59ezZk40bN/LHH38QHh7OiBEjSh3MT5gwgdTUVIYMGcJff/3F+fPn2bhxozplm7+/P6dOneLs2bPcuHHDbEv6uHHj+Pvvv3n55Zc5c+YMP/74I7NmzWLy5Mny96GMlixZwuzZs1myZElVF0WIMpPf/kqk1WqZMGEC7u7uREdHk56eTl5eHunp6URHR+Pu7s748eMr7Y/wtm3b8PHxwd/fnz59+rBr1y6WLVvGjz/+qF6IWrVqxZIlS3j33Xdp3rw5n3/+OQsXLjQ5TqdOnRgzZgxPPfUUnp6eLFq0CE9PT9atW8fXX39NcHAw77zzDosXL7aoXK+++ip//fUXbdq0Yf78+SxZsoSwsDAgv3Xqxx9/xN3dnW7dutG7d28aNmzIV199Va66mDt3LrGxsQQGBuLp6Qnkj8t85ZVXCA4Opk+fPjRp0oRVq1aV63OEEHdOwd5E5lRUb6KcHC1ffLGJW7cGmizXaC6Rnb0VFxcX3n77bbp06VKuzxFVLzs7P6Fabq4dxs4TOp0erRZSU0Gvr9ryFSUsLIy33nqLadOmcd9995GWlqY+XDeaN28eb731FgsXLiQoKIg+ffqwZcsWdbiZOWvXrmX48OG8+uqrNG3alMGDB3PkyBH8/PxKXca2bduyefNmvvzyS5o3b87MmTOZO3euRbOeWGL69Ol0796dAQMG0L9/fwYPHkxgYGCpjlGrVi127txJeno63bt3p127dnzyySdqq/eLL75I06ZNad++PZ6enoVa7gHq1q3LL7/8wuHDh2nVqhVjxozh+eefZ8aMGRVynveiJUuWMGfOHAm6RY2mUUrbP+gulJqaiqurKykpKbi4uJisy8rKIiYmhoCAgDKPxzKXWTc4OJjx48dXWGZdI0VR1CltqmPyF39/fyZNmmSSMb2qVPe6qm7KW18V8btUUxgMBhISEqhTp460bJSgPHVlMBh45plnOH78OIGBgSbfS0VRiI6Opm3btmzcuLHMP4f//Acefrjwck/Pybi6/kyTJk2YPn16uQLu4q5BomRF1V9Z/uakpyv8808uubnWODikoNHkdyW+dcuN7GwrAgNBZpbMJ9fQ0ilPfd1L10+jgtcGPz8/rl69St26dblSnbucVCG57yidiqwvS6/hMqb7DujUqRMdO3YkIiKCpKQk3N3dCQkJkV8KIYQoB2NvoldffZWIiAjc3NxwcnLCysqK+Pj4cvcmatAALl8uvPzPPyPQ6x/B3f05+Vt+l7Gxyc9abjBATo4OW9tbAFhZ6dFqHShHUmshhBD3MLlTuEO0Wi0tWrSgW7dutGjRQm7ShBCigjg7O5OcnExUVBRHjhzh5MmT1K9fv8zThV2/nh943R5wP/BA/nzOHTqE3BN/y69evcozzzxDrVq1sLe3p0WLFiYJMxVFYebMmepUbb179+b8+fMmx0hMTGTYsGG4uLjg5ubG888/r2bSNjp16hRdu3bFzs6O+vXrs2jRojtyfubY2oKjI+TlgV6vAzQoClhb63FxUSgi0bcQQghRLGnpFndUbGxsVRdBCHGXKDhHd6tWrdScGSkpKaSlpZXpmO+9B9OmFV5+8CB07FjOAtcgSUlJdO7cmQceeICtW7fi6enJ+fPnTcbHL1q0iGXLlrF+/XoCAgJ46623CAsLIzIyUu0CO2zYMK5du8b27dvJyclh1KhRjB49mk2bNgH53fIeeughevfuzZo1awgPD+e5557Dzc2N0aNHV8m516oFubmQkqIlO9sWGxs9trYGatXKBiTqFkIIUXoSdAshhKh0BoOhQofYFDVHt5ubG3Xr1i31HN2KAkVtlpdX9Lq71bvvvkv9+vVZu3atuqxgwi1FUVi6dCkzZsxg0KBBAGzYsAEvLy9++OEHhgwZQlRUFNu2bePIkSPq7BPLly+nX79+LF68GF9fXz7//HOys7P597//ja2tLSEhIZw4cYIlS5ZUWdCt1UL9+uDlBVlZOnJy9Gg0kJOjx95egm4hhBCld4/dRgghhLjTDhw4wDPPPMPw4cMZM2YMw4cP55lnnuHAgQNlPmZp5uguydat5oPqadOKD8bvZj/99BPt27fniSeeoE6dOrRp04ZPPvlEXR8TE0NcXBy9e/dWl7m6utKhQwcOHjwIwMGDB3FzczOZ7rF3795otVoOHTqkbtOtWzdsbW3VbcLCwjh79my5p3orL50OXFyssbbOn+0jOzuH1NTcapvBXAghRPUlLd1CCCEqTcEu4Maxv5mZmRw/fpypU6fy3nvvlXpaH7Bsju74+PgSA7eikgjHxuYnUrtXXbx4kdWrVzNlyhTefPNNjhw5wsSJE7G1tWXEiBHExcUB4OXlZbKfl5eXui4uLo46deqYrLe2tsbDw8Nkm9unrDIeMy4uzux0b3q9Hn2ByDc1NRXI7/1gMBjU5QaDAUVR1JeljNsa/7W1tSMxMYPcXMjO1qPXW+HqCr6+UMppoO86t9eVKF5Z68v4Hb79O343M/7+3n6+98r5l1ZR9SXMq8j6svQYEnQLIYSoFEV1AXdyciIwMJDo6GhWr15dpsRZBefodjIzh1NJc3TfupWfMMsciR/yf3bt27dnwYIFALRp04bTp0+zZs0aRowYUaVlW7hwIXPmzCm0/Pr162RlZanvc3JyMBgM5Obmkpuba9GxFUUhLy9/mjDj9zU5WYvBAFZWCvb2WWi1NmRlaUhIAE/PCjihGspcXYmilae+cnNzMRgM3Lx5U50z/G5nMBhISUkxCYyM0zyJwgrW192c4LOiVGR9WZpDRoJuIYQQlcKSLuBRUVFcvnwZb2/vUh07JCSEoKCgIufojouLo23btoSEhBTad948mDmz8DGfew7+9a9SFeOu5ePjQ3BwsMmyoKAgvv32WwD15xUfH4+Pj4+6TXx8PK1bt1a3uf0GOTc3l8TERHV/b29v4uPjTbYxvi/qOzF9+nSmTJmivk9NTaV+/fp4enoWmqc7LS0Na2trrK1Ld7tjDGyys+HmTbCz02Frm9+6rigGsrN13LyZn3StQM/4e9K9EgRWlLLUl7W1NVqtllq1at1T83RrNBo8PT1p164dN27coHbt2oV6z4h8BetLgu6SVWR9Wfo7KUG3EEKISmFJF/Dr168XmkLKEsY5uqdOnUp0dDTe3t7Y2dlx48YNEhIScHd3Z+zYsYUupkU1MF2/DrVrl7oYd63OnTtz9uxZk2Xnzp2jwX/73AcEBODt7c2OHTvUIDs1NZVDhw4xduxYAEJDQ0lOTubo0aO0a9cOgJ07d2IwGOjQoYO6zf/93/+Rk5OjBiPbt2+nadOmRfZS0Ol06MzM3aXVak1+3lqtFo1Go74soSiKuq1GoyEnJ3/O7txcOzXotrbOIjtbR15e/vp7dRqx2+tKFK889WX8Dt/+Hb/bGc/5P//5T1UXpUa4F78j5VFR9WXp/vJTEWbt3r0bjUZDcnJykdusW7cONze3O1amihQbG4tWq+XEiROl3nfHjh0EBQWp3cQEDBkyhPfff7+qiyGqmYJdwM0xdgE31z3cEp06dWLx4sW0adOGq1evcuDAAU6fPs3Nmze5ceMGCxYsYN++fQDExBQdcCtKyQG3wWAgPDycvXv3Eh4eftePm5s8eTJ//vknCxYs4MKFC2zatImPP/6Y8ePHA/k3K5MmTWL+/Pn89NNPhIeHM3z4cHx9fRk8eDCQ3zLep08fXnzxRQ4fPsz+/fuZMGECQ4YMwdfXF4Cnn34aW1tbnn/+eSIiIvjqq6/48MMPTVqyq5KNTX4ivdxca/Ly8h8KaLV5aLW5aLX566uju/ka3qNHDyZNmnTHP9eSOhVCiKJI0H0Xi4uL45VXXqFRo0bY2dnh5eVF586dWb16Nbdu3Sp2306dOnHt2jVcXV3LVYY9e/bQs2dPPDw8cHBwoHHjxowYMYLs7OxyHbcqTZs2jRkzZmB1BzPoZGVlMXLkSFq0aIG1tbV6U1uSxMREhg0bhouLC25ubjz//PMmrYqWHNd4o6HVarG1tVVbj4yJkABmzJjB22+/TUpKSnlPVdxFjF3A4+LiCiUOMnYBDwoKws/Pr8yf0alTJ8aNG4e9vT12dnY4ODig0WhISkpi586dDB48mKZNr9KwYeF9//Uvy8ZvV0b29eruvvvu4/vvv+eLL76gefPmzJs3j6VLlzJs2DB1m2nTpvHyyy8zevRo7rvvPtLT09m2bZtJV7vPP/+cZs2a0atXL/r160eXLl34+OOP1fWurq789ttvxMTE0K5dO1599VVmzpxZZdOF3S4/g3l+a7den9+krSj5rd0uLpXbyl0druHif8pSpyNHjrT4ei2EuLtJ9/K71MWLF+nSpQtubm4sWLCAFi1aoNPpCA8P5+OPP6Zu3bo8/PDDZvfNycnB1ta21GMsbxcZGUmfPn14+eWXWbZsGfb29pw/f55vv/22UluJjclKSjuGzxL79u0jOjqaxx57rMKPXZy8vDzs7e2ZOHGiOqbSEsOGDePatWts376dnJwcRo0axejRo9m0aVOpj3vmzBkcHBywtrZGo9GYjKtq3rw5gYGBfPbZZ2pLmBDmuoAbs5cbM1Ob6wJeGgaDgVWrVpGcnEx2djY5OTnY2dmh1WrJzc3j5s0b3LxZeL+cHLDkT0RJ2dcXL15Mp06dylz+6mzAgAEMGDCgyPUajYa5c+cyd+7cIrfx8PBQ/94UpWXLlvzxxx9lLmdlq1cv/9/UVFvy8qzQavOwt8+mTp08oHIevl68eJHOnTtX6TW8KmRnZ5tMH1ed1NQ6FUJUD9LSfZcaP3481tbW/PXXXzz55JMEBQXRsGFDBg0axJYtWxg4cKC6rUajYfXq1Tz88MM4Ojry9ttvm+1GtW7dOvz8/HBwcOCRRx7hprk72QJ+++03vL29WbRokRqU9enTh08++cRkjOe+ffvo2rUr9vb21K9fn4kTJ5KRkaGu37hxI+3bt8fZ2Rlvb2+efvppk+Q8xrJu3bqVdu3aodPp2LdvHwaDgUWLFtGoUSN0Oh1+fn68/fbbJmWMiYmhZ8+eODg40KpVK3V+2aJ8+eWXPPjggyYtObNnz6Z169b8+9//xs/PDycnJ8aNG0deXh6LFi3C29ubOnXqFPrs0nB0dGT16tW8+OKLFl/0o6Ki2LZtG59++ikdOnSgS5cuLF++nC+//JJ//vmn1MetU6cO3t7e6uv2QGngwIF8+eWXZTtBcdcq2AU8OTmZ2NhYkpOTadu2LYsXLyY0NLRcx4+IiCAyMpKsrCxycnJwdHTEysqK7OweJCUV/htVp46xpbLkY9+efd3JyQkrKys1+3pSUhIrV66867ua3+usrPKnj7Oz03DunD3JyVrs7SE3t/Im7B43blyVX8Ozs7OZMGECPj4+2NnZ0aBBAxYuXKiuT05O5qWXXqJOnTq4uLjQs2dPTp48qa6Pjo5m0KBBeHl54eTkxH333cfvv/9u8hn+/v7MmzeP4cOH4+LiovZw2L9/Pz169MDBwQF3d3fCwsJMpv8zGAxMmzYNDw8PvL29mT17drHnYmxxnjNnjppwb8yYMSa97vR6PRMnTqROnTrY2dnRpUsXjhw5oq6/vU6N3fN//fVXgoKCcHJyok+fPly7dg3IvzdYv349P/74o9pbbM+ePSXWqyjs4YcfJjQ0tMgHTULUBBJ034Vu3rzJb7/9xvjx43EsYk6c25N4zJ49m0ceeYTw8HCee+65QtsfOnSI559/ngkTJnDixAkeeOAB5s+fX2w5vL29uXbtGnv37i1ym+joaPr06cNjjz3GqVOn+Oqrr9i3bx8TJkxQt8nJyWHevHmcPHmSH374gdjYWEaOHFnoWG+88QbvvPMOUVFRtGzZkunTp/POO+/w1ltvERkZyaZNmwrNKTtz5kxeffVVTpw4QZMmTRg6dGixU8v88ccftG/f3ux5bN26lW3btvHFF1/wr3/9i/79+3PlyhX27NnDu+++y4wZMzh06JC6T9++fXFyciryZS7rcmkcPHgQNzc3k/L27t0brVZrUg5LtWnTBj8/Px566CH2799faP3999/P4cOHTebPFQLyA+/PPvuMDRs2sGbNGjZs2MDGjRsrpIU4KSmJ1NRUMjMz1YdhCQnxpKRsLrTtF19c4LZE2cWyJPt6ZGQkERER5ToHUb2lpsL48dC3Lzz/vC2PPOLCtGkOxMdnkZamUNF/8qrLNXzZsmX89NNPbN68mbNnz/L555/j7++vrn/yySdJSEjgl19+4ejRo7Rt25ZevXqRmJgIQHp6Ov369WPHjh0cP36cPn36MHDgQC5fvmzyOYsXL6ZVq1YcP36ct956ixMnTtCrVy+Cg4M5ePAg+/btY+DAgSY95NavX4+joyOHDh1i0aJFzJ07l+3btxd7Pjt27CAqKordu3fzxRdf8N1335lMPTdt2jS+/fZb1q9fz7Fjx2jUqBFhYWHq+Zhz69YtFi9ezMaNG9m7dy+XL19m6tSpAEydOpUnn3xSDcT/+ecfQkNDS6xXUdixY8f4888/OXbsWFUXRYiyU4SSkpKiAEpKSkqhdZmZmUpkZKSSmZmpLmvXTlHq1r3zr3btSj4Xg8Gg7Nu3TwGU7777zmRdrVq1FEdHR8XR0VGZNm2auhxQJk2aZLLtrl27FEBJSkpSFEVRhg4dqvTr189km6eeekpxdXUtsiy5ubnKyJEjFUDx9vZWBg8erCxfvtyknp9//nll9OjRJvv98ccfilarNanzgo4cOaIASlpamklZf/jhB3Wb1NRURafTKZ988onZY8TExCiA8tFHHykGg0FRFEWJiIhQACUqKqrIc3J1dVU2bNhgsmzWrFmKg4ODkpqaqi4LCwtT/P39lby8PHVZ06ZNlYULF6rvr1y5opw/f77IV2xsrNkyjBgxQhk0aFCRZTR6++23lSZNmhRa7unpqaxatcri4545c0ZZs2aNcuTIEWXPnj3KyJEjFWtra+Xo0aMm2508eVIBiiy3ud+lu1VeXp5y7do1k5+/MK+8dXXq1CmlUaNGioODg1K7tr+S345d+BUQEKDs2bOnVMfes2ePEhQUpPTt21cZMGBAoVffvn2VoKCgUh/3dsVdg0TJiqq/svzNMRgMSnZ2tnpdUBRFGTdOUby8FKVRI0Vp2VJRGjbMVWrXzlOeffaWEhmZqZw6pSixsYqSm1sx5/Pnn39Wi2v4yy+/rPTs2dOkLoz++OMPxcXFRUlLSzNZHxgYqHz00UdFHjMkJERZvny5+r5BgwbK4MGDTbYZOnSo0rlz5yKP0b17d6VLly4my+677z7l9ddfL3KfESNGKB4eHkpGRoa6bPXq1YqTk5OSl5enpKenKzY2Nsrnn3+urs/OzlZ8fX2VRYsWKYpSuE7Xrl2rAMqFCxfUfVauXKl4eXmZfK7xumr8bk2YMKHIei3KvXT9NCp4bahbt64CKHXr1q3qYlVbct9ROhVZX5Zew2VMdxnExcHVq1VditI7fPgwBoOBYcOGFWqNNNd6W1BUVBSPPPKIybLQ0FC2bdtW5D5WVlasXbuW+fPns3PnTg4dOsSCBQt49913OXz4MD4+Ppw8eZJTp07x+eefq/spioLBYCAmJoagoCCOHj3K7NmzOXnyJElJSWpXzsuXL5vMI1vwHKKiotDr9fTq1avY82rRooX6f+NcswkJCTRr1szs9gVb0wry9/fH2dlZfe/l5YWVlZVJF2wvLy+TbvF169YttmzVRdOmTWnatCmKopCbm0vXrl25ePEiH3zwARs3blS3Mw4ZKCnBjxAVKSQkhMaNG3Phwq/culU4W5q19Wd4eLyKi4tPkVNQGQwGIiIiSEpKwt3dnZCQELRarUn2dXMZ1o3Z14s6rqj5Ll+GX38FZ2cw5s9ydNSSl2dgzx5bRo/OwNVVR3Jyfsvzf2dUqxR3+ho+cuRIHnzwQZo2bUqfPn0YMGAADz30EAAnT54kPT290LCkzMxMoqOjgfyW7tmzZ7NlyxauXbtGbm4umZmZhVq6by/7iRMneOKJJ4o9n5YtW5q89/HxKTQn/O1atWqFg4OD+j40NJT09HT+/vtvUlJSyMnJoXPnzup6Gxsb7r//fqKiooo8poODA4GBgaUqx8iRI3nooYfM1qsQ4u4lQXcZVFUeDUs/NzAwEI1GU2iO1Yb/Td9rbs7corqwVYS6devy7LPP8uyzzzJv3jyaNGnCmjVrmDNnDunp6bz00ktMnDix0H5+fn5kZGQQFhZGWFgYn3/+OZ6enly+fJmwsLBCGdALnkNR8wLfrmCyNWN3veLGZ9auXdtkXJmRzW3zxmg0GrPLCh67b9++xSYPatCgQbm6rXp7exe6+Ofm5pKYmFjuZDD333+/OhWTkbELnqenZ7mOLURpaLVatm79xew6Bwd/bG1TsLNzISQkxOyQjQMHDrBixQr1QZ1OpyMoKIgJEybQsWNHgoKCOH78uPp31Uj5b/b1tm3blnsoiKi+rlyBrCyoVSv/vaJAXp4Ge3uFpCQNCQkKnp65ZGfbkJoKen35M5o3atSoWlzD27ZtS0xMDFu3buX333/nySefpHfv3nzzzTekp6fj4+PD9u3b1eSaRsZpyKZOncr27dtZvHgxjRo1wt7enscff7zYa3dR53e7kq6vd4q5ciglTIlQXL0KIe5eEnSXwV9/VXUJilerVi0efPBBVqxYwcsvv1whF+OgoKBC44D//PPPUh/H3d0dHx8fNVFa27ZtiYyMpFGjRma3Dw8P5+bNm7zzzjvUr18fgL8s+AE0btwYe3t7duzYwQsvvFDqchalTZs2REZGVsixPv300yLnL4bCF/PSCg0NJTk5maNHj9KuXTsAdu7cicFgoEOHDuU69okTJ9SeAUanT5+mXr161C5pwmMhKsiJE9Cmjfl1zs4u/51GzIW6desyfvz4Qsn/LMlMXlL2dXPHFXePevXAzg5u3cpv6TbGU7duadHpFLy9DVhbZ5Gba0Nubn5W/PIG3dXpGu7i4sJTTz3FU089xeOPP06fPn1ITEykbdu2xMXFYW1trT4kuN3+/fsZOXKk2sKenp5ObGxsiZ/ZsmVLduzYYTLeuiKcPHmSzMxMNaj/888/cXJyon79+tSuXRtbW1v2799Pg/92V8jJyeHIkSPlmhPc1tbW7GwtRdWrh4dHmT9LCFG9SdB9l1q5ciVdunShffv2zJ49m5YtW6LVajly5AhnzpxRgzBLTZw4kc6dO7N48WIGDRrEr7/+Wmy3NICPPvqIEydO8MgjjxAYGEhWVhYbNmwgIiKC5cuXA/D666/TsWNHJkyYwAsvvICjoyORkZFs376dFStW4Ofnh62tLcuXL2fMmDGcPn2aefPmlVheOzs7Xn/9daZNm4atrS2dO3fm+vXrRERE8Pzzz5fq3AsKCwtj/fr1Zd6/oNJ2L4+MjCQ7O5vExETS0tI4ceIEAK1btwbyux4OHz6cHTt2ULduXYKCgujTpw8vvvgia9asIScnhwkTJjBkyBB8fX0tPu7SpUsJCAggODiY9PR01q1bx86dO/ntt99MyvfHH39IFzlxx5i5xwegTp0/cXF5lry82ri45Ldwjx8/vlDSttszkxuDBmNm8ujoaFauXMnGjRtZvHix2hoeHx+PTqejbdu2Zo8r7i5+fhAWBsYZFe3tIS0Nbt3S0K9fNnXrGoBsIA+t1opyPitVrVq1is6dO1fpNXzJkiX4+PjQpk0btFotX3/9Nd7e3ri5udG7d29CQ0N5/PHHWbRoEU2bNuWff/5hy5YtPPLII7Rv357GjRvz3XffMXDgQDQaDW+99ZZFrdHTp0+nRYsWjBs3jjFjxmBra8uuXbt44oknyvVQNzs7m+eff54ZM2YQGxvLrFmzmDBhAlqtFkdHR8aOHctrr72Gh4cHfn5+LFq0iFu3bpXrnsHf359ff/2Vs2fP4uHhgaOjI8uWLcPX19dsvQoh7l4SdN+lAgMDOX78OAsWLGD69OlcuXIFnU5HcHAwU6dOZdy4caU6XseOHfnkk0+YNWsWM2fOpHfv3syYMaPYANjYBXnMmDH8888/akbuH374ge7duwP5T7T37NnD//3f/9G1a1cURSEwMJCnnnoKyO+qvG7dOt58802WLVumTjNkybQRb731FtbW1sycOZN//vkHHx8fxowZU6rzvt2wYcOYNm0aZ8+epWnTpuU6Vmn169ePS5cuqe/b/LeJz9iV7datW5w9e5acnBx1m88//5wJEybQq1cvtFotjz32GMuWLSvVcbOzs3n11Ve5evUqDg4OtGzZkt9//50HHnhA3ScrK4sffvihxJs4ISxR1BhryG9pLKphOSsLbGzuJyLiO7P7FlSazOSdOnWiY8eORZZJ3N2Mszn9+iskJuZPIdarl4ZXXsn/G6koYGWlx8nJodyt3EbV4Rru7OzMokWLOH/+PFZWVtx333388ssv6vd+y5YtvPnmmzz33HNcv34db29vunXrps4SsmTJEp577jk6depE7dq1ef3110lNTS2xrE2aNOG3337jzTff5P7778fe3p4OHTowdOjQUp3z7Xr16kXjxo3p1q0ber2eoUOHmkw19s4772AwGHj22WdJS0ujffv2/Prrr+XK2fDiiy+ye/du2rdvT3p6Otu3by+xXoUQdyeNUtLgk3tAamoqrq6upKSk4OLiYrIuKyuLmJgYAgICzCbQqm6Mya5uH2MlCitrXb322mukpqby0UcfVWLpqp/i6mv16tV8//33hVq/C6ppv0vlYTAYSEhIoE6dOlV+I1VcAFsd3F5XxY2xPneuE6NGmT9Oaa9ke/fuZcyYMfj7+2NlZVVofV5eHrGxsaxZs4Zu3bqV4cwsV9w1SJSsqPory9+c4v7OXb6cP8bbxyf/wU9amgFHx2Q0GgVray3e3m5YW987192adL8xcuRIkpOT+eGHH6qsDOWpr3vp+mlU8Nrg5+fH1atXqVu3LleuXKnqolVL1em+oyaoyPqy9BouLd1ClNL//d//sWrVKgwGg/xh+y8bGxt1yICoPooLYI3doqtTUF7cGOvOnc134/75Z+jfv/SfJZnJRWn5+eW/jPR6LenptiiKHo3GQG6uHmvreyMgEkIIUToSdAtRSm5ubrz55ptVXYxqpSKT1YmKYUmSMKDEoPxOKWqMtZ1dbc6c2WV2n/L00woJCZHM5KJcdDrQanWkpuZP33Xrlp7cXB02NpoK62YuhIApU6aQmpoqPYFEjSZBtxBC3GUsSRI2e/Zs0tLSSEpKKjIov5OBd2RkZKEx1seOTeWff7oX2rZ+/fyuvuWh1WolM7koNxsbG6ysrElPzyU3N5eMjFwMBhtcXPIzn5sZuSCqwLp166q6CKIcpkyZUtVFEKLc5G5CCCHuMiUlCfPy8uLIkSPExcXRqFEjnJycsLKyUoPypKQkVq5ceUfnvU1KSkKv16vT+fz883/MBtxffXWo3AG3UadOnVi8eDFt2rQhOTmZ2NhYkpOT1YSNkplcWCI11Q5j/ko7uywAkpPzx38LIYQQIC3dQghx17k9gL1dbm4umZmZ+Pv7l5i5u0WLFneiyOoY6xs3vDhyZK3ZbVq3bkNQ0IYij1GW8emSmVyUh14PKSm2ODlp0WgMWFvnYG2dR26uFamp+eulq7kQQggJui0kSd6FKJ872Wp6ryspSVhGRgaA2XUA9vb2xMfHk5SUZPFnFhXwWhoIBwcHc+LEcbPHDgj4AZ1uOsHBRY+xtiRpXFG0Wu0de7gg7i45OWAwaMjN1WFrmwko2NjoMRgcyM3NXy9BtxDlk5aWhqIoaDQanJ2dq7o4QpSJBN0lsLGxQaPRcP36dTw9Pav9tBg1aQqPqiZ1VTplrS9FUcjOzub69etotVpsbW0rsZQCSk4SlpKSgr29vdmpsqD0mbuLCni7d+/Onj17SgyEFQVsbMxfjrp1e5CEhCvFjrG2JGmcdBUXlcHGJn/6ML3eDlvbLEDB2lpPVpY9Wq0GG5uqLqEQNV9QUJBMGSZqPAm6S2BlZUW9evW4cuUKsbGxVV2cEimKok5lJYFk8aSuSqe89eXg4ICfn590270DSkoS5uXlRWBgIFeuXMHJyalcmbuLCnj379/Pf/7zHzw8PAgICCAvL4/09HQOHjxITEwM77//Pp06dWLjRhg50tvssYOCgklN1dG2bVvGjx9vNnC2JGncypUr6dixo3z3RIXT6cDFBZKTtWRn22JrqwcMWFnpcXCwk1ZuIYQQQDUPuvPy8pg9ezafffYZcXFx+Pr6MnLkSGbMmKHeWCmKwqxZs/jkk09ITk6mc+fOrF69msaNG1dYOZycnGjcuDE5xkwp1ZjBYODmzZvUqlVLbjBLIHVVOuWpLysrK+lRcIcZk4QZW6Dj4+PR6f4XwALlztxdVMDr6OhIbm4u2dnZZGRkcP78edLT09WHNjdv3mT27Nls3/4b5vJ5fv+9gcDACJKS1hTbJd1gMPD9999z5MgR3NzcCq2vqvHp4t5Sr17+v+npdtjY5E8f5uychbe3DpC/eUIIIap50P3uu++yevVq1q9fT0hICH/99RejRo3C1dWViRMnArBo0SKWLVvG+vXrCQgI4K233iIsLIzIyEjs7OwqrCxWVlZFdsWsTgwGAzY2NtjZ2UkgWQKpq9KR+qp5SkoSVlxQXlR37IJjtK9fv05kZGShLOlpaWmkp6dja2tLcnIytra2anf2vLw8bt2y/m/AXVh++gwtUHyAbOzSfuTIES5fvkx8fDz//PMP/v7+eHh4qNuVZXy6EKVhZQUNGoBeb01amg2Qg0aTh8GQA8hwGiGEENV8yrADBw4waNAg+vfvj7+/P48//jgPPfQQhw8fBvJbuZcuXcqMGTMYNGgQLVu2ZMOGDfzzzz/88MMPVVt4IYSoBoxJwrp160aLFi1MHph06tSJzz77jA0bNrBmzRo2bNjAxo0biwy4Dxw4wDPPPMPw4cMZM2YMb7zxBjExMWRlZZlsl5OTQ15eHtnZ2RgMBnQ6ndrTISXlD7Ky4gsd29FRwdJ8lcYu7ceOHcPNzQ2dToeVlRUpKSlERUWRmJioblva8elClFV+V3M7jM+fMjKySE/Pz2BeWiNHjkSj0aivWrVq0adPH06dOlVh5Z09ezatW7eusONVtr179zJw4EB8fX3RaDQW3+ft3r2btm3botPpaNSoUaE5uy057u0/D41GQ58+fcp/UkKIe0a1Dro7derEjh07OHfuHAAnT55k37599O3bF4CYmBji4uLo3bu3uo+rqysdOnTg4MGDVVJmIYSoSYoLygu6PdD19/fHzc0NvV5PZGSkSaBr89/sUbm5uWi1WvWYCQnx5OUFFzr27t3XSU21LOK+vUu7l5cXzs7O5OTk4ODgQHZ2NrGxsSiKoo5PDw4Otmh8uhDlZWNjg1ZrRWYmpKTkEBuby7lzcOkS5OWV7lh9+vTh2rVrXLt2jR07dmBtbc2AAQMqp+A1QEZGBq1atWLlypUW7xMTE0P//v154IEHOHHiBJMmTeKFF17g119/LfVxC/48rl27xhdffFHmcxFC3HuqdffyN954g9TUVJo1a6Z2S3z77bcZNmwYAHFxcQB4eXmZ7Ofl5aWuM0ev16Mv8Og5NTUVyL+Zq+nTGhkMBjXhlSie1FXpSH1Z7m6rK4PBwMqVK0lOTqZx48ZqV3Jvb2+uXbvGzZs3uXz5Mh4eHmg0GlxcXHBwcCAzM/O/QUhDEhKOmD32rl27adKkqcV1dfr0ac6ePYuvr68azDds2JCoqCiysrLQ6XRkZGSQkJBARkYGHh4ejBs3Tj2P6qi6lkuUnkajIT3djtzcDDQasLPLIjPTieTk/PUNGlh+LJ1Oh7d3fpJBb29v3njjDbp27arOpgLw999/8+qrr/Lbb7+h1Wrp2rUrH374If7+/kB+K++0adOIiIjAxsaGkJAQNm3axK5du5gzZ45aZoC1a9cycuTIQuUYOXIkycnJ3H///Xz44Yfo9XqmTJnC9OnTeeONN1i7di0ODg7MmzePUaNGlaneLNG3b1+10cVSa9asISAggPfffx/Iz4K9b98+PvjgA8LCwkp13II/DyGEKK1qHXRv3ryZzz//nE2bNhESEqI+pfT19WXEiBFlPu7ChQvVi01B169fL9RNsqYxGAykpKSgKIqMuy2B1FXpSH1Z7m6rq9jYWHJzc+nYsSP29vYm6zw8PIiNjSUnJwdnZ2dcXV3R6/W0bt2alJQUzp37gBs3CndXr1PnND16zMPObjLJyckW11VCQgINGjTAy8tL3b5+/fo0bNiQ+Ph4MjMzycnJwdPTk8aNG9O/f38CAwNJSEiomMqoBGlpaVVdBFFB9HpITtbh5HQLjUbBxiabnBwDublaUlPz15clo3l6ejqfffYZjRo1olatWkD+MI6wsDBCQ0P5448/sLa2Zv78+Wo3dK1Wy+DBg3nxxRf54osvyM7O5vDhw2g0Gp566ilOnz7Ntm3b+P3334H8noJF2blzJ/Xq1WPv3r3s37+f559/ngMHDtC5c2f+/PNPNm/ezEsvvcSDDz5IPWNmudssWLCABQsWFHuekZGR+Pn5lb6CinDw4EGT3pAAYWFhTJo0qdTH2r17N3Xq1MHd3Z2ePXsyf/589WchhBAlqdZB92uvvcYbb7zBkCFDAGjRogWXLl1i4cKFjBgxQn3iGB8fj4+Pj7pffHx8seOUpk+fzpQpU9T3qamp1K9fH09PT1xcXCrnZO4Qg8GARqPB09PzrrjZr0xSV6Uj9WW5u62uzp49S0REBA0aNDCbUDInJ4eoqChu3ryJjY0NOp2OZs2aFZksrWPHnqSmxmNj04a2bdty8+ZNi+uqTp06XLp0ieTkZJycnEzW2djYkJiYSEpKCq+++iqDBg2qEfVfkUk/hWWWLFnCkiVLStyubdu2/PTTTybLHn74YY4dO2Z2e0WB3FzQaBRefHEML7wwDhubLAwGB3JzISfH8qD7559/Vr/jGRkZ+Pj48PPPP6vf6a+++gqDwcCnn35q0lrt5ubG7t27ad++PSkpKQwYMIDAwEAgv6XXyMnJCWtra4tabz08PFi2bBlarZamTZuyaNEibt26xRtvvIG1tTXTp0/nnXfeYd++feo92+3GjBnDk08+Wezn+Pr6llwxpWCcIrEgLy8vUlNTyczMLPQQsSh9+vTh0UcfJSAggOjoaN5880369u3LwYMHa0SSXSFE1avWQfetW7cK3TBZWVmpXfECAgLw9vZmx44dapCdmprKoUOHGDt2bJHH1el06Mxc9QqOPazJNBrNXXMulU3qqnSkvixXlXVVMMN4cVNuWcrDwwMbGxtu3bpVKNCF/L+pDRo04K233sLT05MDB/yZPt18a1X37j2Ij4/H3d2dcePGqQnWLK2r5s2b07RpU44fP05gYGChOcbT0tJo3749jzzySI35ntaUct5NUlNTuXr1aonb1a9fv9Cy69evW7RvWlo6ANbWerKy7NFqNfw33YFFHnjgAVavXg1AUlISq1atom/fvhw+fJgGDRpw8uRJLly4gLOzs8l+WVlZREdH89BDDzFy5EjCwsJ48MEH6d27N08++aRJI4Wlbv8b4uXlZZInwcrKilq1ahXbo8TDw8NkZoGapOCDhBYtWtCyZUsCAwPZvXs3vXr1qsKSCSFqimoddA8cOJC3334bPz8/QkJCOH78OEuWLOG5554D8m9qJ02axPz582ncuLE6ZZivry+DBw+u2sILIUQVME6lFRUVhV6vR6fTERQUxIQJE4rMSl6SkJAQgoKCigx04+LiaNu2LY888ghWVuYDyMaNR2JtfZiUFNNpyUo7nlmr1TJhwoRyzzEu7m0uLi7UrVu3xO2MY6dvX1bcvnl5YDCAg4Pbf5cY0Gr1ODralapruaOjI40aNVLff/rpp7i6uvLJJ58wf/580tPTadeuHZ9//nmR5V67di0TJ05k27ZtfPXVV8yYMYPt27fTsWNHywvC/5IjGmk0GrPLivt9roru5d7e3sTHm86WEB8fj4uLi8Wt3OY0bNiQ2rVrc+HCBQm674Aff/yR7OxsbG1lCj5Rc1XroHv58uW89dZbjBs3joSEBHx9fXnppZeYOXOmus20adPIyMhg9OjRJCcn06VLF7Zt2ybd9YQQ9xxjhvHExER8fHzUYPT48eNMnTqVxYsXlynwtiTQff75l4sMuPPyDEREvFphLe+dOnUq0xzjQhhNmTLFZJiZkaIo5Obmqj0wzLm9u/nt8vLgyhXIyMhFUVIAcHHJwttbB5g/piWMPUIyMzOB/K7vX331FXXq1Cl2aFybNm1o06YN06dPJzQ0lE2bNtGxY0dsbW3JK21K9XKoiu7loaGh/PLLLybLtm/fTmhoaLmOe+XKFW7evFmmXgOi9Nq1a1fVRRCi3Kp10O3s7MzSpUtZunRpkdtoNBrmzp3L3Llz71zBhBCimrl9Ki1jwODk5ERgYCDR0dGsXLmSjh07lingLS7QTUlZQq9eXoX2cXeH/JnE8qclq0idOnWiY8eOFdqNXoiKYGWVn6Vcr7cmLc0GyEGjySM7O4esLFtsbCwb163X69WZWJKSklixYgXp6ekMHDgQgGHDhvHee+8xaNAg5s6dS7169bh06RLfffcd06ZNIycnh48//piHH34YX19fzp49y/nz5xk+fDgA/v7+xMTEcOLECerVq4ezs7PZoXcVpbzdy9PT07lw4YL63lh2Dw8PtXV8+vTpXL16lQ0bNgD5gf6KFSuYNm0azz33HDt37mTz5s1s2bLF4uOmp6czZ84cHnvsMby9vYmOjmbatGk0atRIzYAuhBAlqdZBtxBCCMtEREQQFRWFj49PoRY6jUaDt7c3kZGRRERElDkANhfotmxp/lgXLsB/czdVGuMc40JUR/nxq460tBwyMyEpSU9Ghi1aLbi4QL16+QF6UbZt26a2pDo7O9OsWTO+/vprevToAYCDgwN79+7l9ddf59FHHyUtLY26devSq1cvXFxcyMzM5MyZM6xfv15tlR0/fjwvvfQSAI899hjfffcdDzzwAMnJyUVOGVZd/PXXXzzwwAPqe2NPhREjRrBu3ToArl27xuXLl9VtAgIC2LJlC5MnT+bDDz+kXr16fPrppybBcknHtbKy4tSpU6xfv57k5GR8fX156KGHmDdvXqU+pBBC3F00iqIoVV2IqpaamoqrqyspKSl3RfbyhIQE6tSpIy0+JZC6Kh2pL8tVRV3t3buXMWPG4O/vbzabbl5eHrGxsaxZs4Zu3bqV+/POnYOmTc2vK81VRb5Xd9c1qCoUVX9ZWVnExMQQEBBg8ZAzS7qXl4aiKFy9mkJOTh4aDWRmupKba43BAG5upZu3u7qp6Lq625WnvsryXa7pCl4bfvnlFzXb/IABA6q6aNWSXEtLpyLry9JruLR0CyHEXcDd3R2dTkdmZqbZDOOZmZnodDrc3d3L/VlF3S+OGQP/TbYshACyszVkZOjQ6W6h0YCtrR5Fyb/1Ks+83ULcS8aMGcPVq1epW7cuV65cqeriCFEm8ihECCHuAsYM43FxcdzegcmYYTw4ONhkmp+yKCrgzsyUgFuI2+XkgF7/vwRq1tZ6NBoDWm1+hvOcnKotnxBCiDtDgm4hhLgLGDOMu7u7Ex0dTXp6Onl5eaSnpxMdHV3uqbS++qrogPvUqXAOH95LeHh4qacAE+JuZmMDGo2W7Gxjc7aCjU0WBgNotZRq3m4hhBA1l3QvF0KIu0RlTaVVVLA9efJF4uJmMHx44TnBLcksbjAYOH36tDquqnnz5jIWTdxVdLr8pGkpKXbY2urRaBSsrPQYDPa4uWmka7kQQtwjJOgWQoi7SEVOpZWZCQ4O5tft31/0nOAvvfQS3t7e3Lhxo1Awbgz8Dxw4wIoVKzh79iwNGjTg0qVLNG3a1GQbUXVmz57NnDlzTJY1bdqUM2fOAPmJnV599VW+/PJL9Ho9YWFhrFq1Ci+v/00dd/nyZcaOHcuuXbtwcnJixIgRLFy4EGvr/9167N69mylTphAREUH9+vWZMWNGhWfQrup8sfXqAViRnW2LjU1+93IPDz2+vvdGQixRflX9HRZClJ80KQghxF3GOJVWt27daNGiRZkC7hdfNB9wOzlBXp7pnOBOTk5YWVnh5OSEh4cHFy5c4NChQ7i6uuLv74+bmxvHjx9n6tSpHDhwgAMH8gP2Y8eO4erqipeXF66uribbiKoXEhLCtWvX1Ne+ffvUdZMnT+Y///kPX3/9NXv27OGff/7h0UcfVdfn5eXRv39/srOzOXDgAOvXr2fdunXMnDlT3SYmJob+/fvzwAMPcOLECSZNmsQLL7zAr7/+WiHlt/lv3+1bt25VyPHKyjhvd716djg45P8OOTtnodVKICUsY/wO28h4BCFqLGnpFkIIYaKo7uTnzkHjxhAebn5OcEVRiI2NRaPRoNFoUBRFDcYDAwOJjo5mxYoVKIqiBuxarRatVmuyzcqVK+nYsaN0Na9i1tbWeHt7F1qekpLCv/71LzZt2kTPnj0BWLt2LUFBQfz555907NiR3377jcjISH7//Xe8vLxo3bo18+bN4/XXX2f27NnY2tqyZs0aAgICeP/99wEICgpi3759fPDBBybzKJeVlZUVbm5uJCQkAPnzWpc0VVNlToOl0eQH4NnZ2eTkQHa2Fjs7W2xtK/Rj7hiZMqx0ylJfiqJw69YtEhIScHNzMzsdpBCiZpCgWwghBAAXLuQH1eYU7N2YlJSEXq/H3t7eZJu0tDTS09Oxt7f/b2Dxv9TMGo0Gb29vjh07BlAoYC+4TWRkJBEREbRo0aJiTkyUyfnz5/H19cXOzo7Q0FAWLlyIn58fR48eJScnh969e6vbNmvWDD8/Pw4ePEjHjh05ePAgLVq0MOluHhYWxtixY4mIiKBNmzYcPHjQ5BjGbSZNmlRh52B8aGAMvEuiKAoGgwGtVlspgWROTh7p6fmJ1AwGLdnZ9tjb58/ZXdOeMVV2Xd1tylNfbm5uZh+ACSFqDgm6hRBC4OwM6emFl7/wAnzyiemyouYEz8nJwWAwoCgKWq22UFdIe3t7srKy1P+bY29vT3x8PElJSeU7IVEuHTp0YN26dTRt2pRr164xZ84cunbtyunTp4mLi8PW1hY3NzeTfby8vIiLiwMgLi7OJOA2rjeuK26b1NRUMjMzi/yO6PV69Hq9+j41NRXIT8xnLnu+l5cXtWvXNnkIVBSDwUBiYiIeHh6V0tPi7bcVrl/fj5tbKlotREbeT1xcbR58EP7v/yr84ypVZdfV3aas9WVjY4OVlRWKotxTY7uN15Lbf6dlhgzziqovYV5F1pelx5CgWwgh7nFFNbrcugXm4h7jnODHjx8nMDBQbbWxsbFBo9GQlZWFu7s7zs7OJvtlZmZiZ2en/r9gwF5wG51Oh7u7e/lOSpRL37591f+3bNmSDh060KBBAzZv3lxkMHynLFy4sFCSN4Dr16+rD3XKymAwkJGRgbW1dYUHktevQ3g4ODl54up6lbw8aNDgJBrNfYSHQ3Q0eHpW6EdWqsqsq7uR1FfpGAwGUlJSUBQFOzs7nJycsLOzs7jXyr2mYH3J96tkFVlfaWlpFm0nQbcQQtyjvvkGnnjC/LriGlSMc4JPnTqV6OhovL29sbe3V4NvRVFo0KBBofHecXFxtG3bFkVROHHihEnAfvs2ISEhFXKOomK4ubnRpEkTLly4wIMPPkh2djbJyckmrd3x8fFqF1hvb28OHz5scoz4+Hh1nfFf47KC27i4uBQb2E+fPp0pU6ao71NTU6lfvz6enp64uLiU6zwNBgMajQZPT88Kv3GNjoYTJ6BWrdrY219Gp8sA0rhxw4a//3YnNRVq0te+MuvqbiT1VToF6+vcuXNVXZxqT75fpVOR9WVsTCiJBN1CCHEPKqp1+4svYMiQkvcvak7wjh07cu3aNZKSktDpdOpUYnFxcbi7uzNhwgQANWD38fHBYDCQnp7OtWvXcHd3Z/z48XLTUM2kp6cTHR3Ns88+S7t27bCxsWHHjh089thjAJw9e5bLly8TGhoKQGhoKG+//bY6BzvA9u3bcXFxITg4WN3ml19+Mfmc7du3q8coik6nQ2dmgmtjUr7y0mg0FXasgurXB1tbSE/XEhfXDD+//PwGtWqdIz4+lPr1a9647sqqq7uV1FfpSH2VjtRX6VRUfVm6vwTdQghxD8nKMt9lHIpv3TanqDnB//zzz0LBeNu2bRk/frw6B7cxYD979izx8fGkpKQU2kZUnalTpzJw4EAaNGjAP//8w6xZs7CysmLo0KG4urry/PPPM2XKFDw8PHBxceHll18mNDSUjh07AvDQQw8RHBzMs88+y6JFi4iLi2PGjBmMHz9eDZjHjBnDihUrmDZtGs899xw7d+5k8+bNbNmypSpPvdL4+UFYGHz7LVy4EIiPz2k0mmw8PC7Rp08r/PzMzNEnhBDiriBBtxBC3CPGjoU1awov1+nyg/GyMM4JXlBRwXjBp8HGbU6fPq22hjZv3lye0FcTV65cYejQody8eRNPT0+6dOnCn3/+ied/Bx1/8MEHaLVaHnvsMfR6PWFhYaxatUrd38rKip9//pmxY8cSGhqKo6MjI0aMYO7cueo2AQEBbNmyhcmTJ/Phhx9Sr149Pv300wqZLqy6Wrgw/99ff7Xm/PnGNGkSga+vwoABZ4C2VVo2IYQQlUeCbiGEuAsZDAaToLdlS/PTb505A02bVvznmwvGzW3TvHlzNeiWgLv6+PLLL4tdb2dnx8qVK1m5cmWR2zRo0KBQ9/Hb9ejRg+PHj5epjDWRiwusXAmXL0NMTBNiYs6g0+Vx/nw0eXnNadDAFj+/qi6lENXLa6+9pl7L3nvvvaoujhBlIkG3EELcZQ4cOKB2705Pd+bChb1mt7uHZp8Rolrx8wM/Pzu02gC2br3A9eu5fPrpBa5dCyYsLL9FvJw54YS4a3zxxRdcvXqVunXrStAtaixpVhBCCAsZDAbCw8PZu3cv4eHh1XI+zAMHDjB16lSOHTvG1atLzAbcI0ZIwC1EdbB5czOuXcv/f+PGZ9Fq8/j2W5g+vWrLJYQQomJJS7cQQligYOuxXq9Hp9MRFBTEhAkTqk3iL4PBwIoVK0hMTOTs2TNmt3nyyVH8+9//Qp65ClG1Ll+GrVudad68Hj4+V7C2ziIwMJYLFwL59df89dLVXAgh7g5y1yWEECUo2Hrs5uaGv78/bm5uHD9+nKlTp3LgwIFK++yCresnT57k5MmTRba0R0REcPp0LImJZrKlAT16PMC5cyeIiIiotPIKISxz5Up+AsPr14PUZT4+kTg4KGRl5a8XQghxd5CWbiGEKEbB1uNGjRqh+e8E105OTgQGBhIdHc3KlSvp2LFjhScCK9i6npSUREpKCgCurq64u7sXamk/dCibs2c/Jzs7wOQ4HTu+Se3a4eTl2RMfH09SUlKFllMIUXr16oGdHSQk1CYtrQ7OzgnodOk4Ol4mI6MB9epVdQmFEEJUFGnpFkKIYkRERBAVFYWPj48acBtpNBq8vb2JjIys8Nbjgq3rGo2GlJQU9Ho9er2elJQUNBqN2tL+xx8H0GjgxRfbqQG3RpNDUNC/GTBgILVrhwOQmZmJTqfD3d29QssqhCg947zdaWlw9mwIigK5ueDrG0FYmCJdy4UQ4i4iQbcQQhQjKSkJvV6Pvb292fX29vbo9foKbT0u2LoeGBhIfHw8OTk5ODk54ezsTE5ODvHx8TRs2JCrVxvRrZvpmHI7u9N07z6ewMDv1WWKohAXF0dwcDAhISEVVlZRPeTm5jJ37lyuSJ/kGmXhQnjsMUhK8uL6dQ8AmjRJ4ZVX/qnikgkhhKhI0r1cCCGK4e7ujk6nIzMzEycnp0LrK6P1uGDrenp6Ounp6eh0OrWl3c7OjvT0dP744z3S0oIL7d+q1Tji4q7j7e2Nvb09mZmZxMXF4e7uzvjx42U+7LuQtbU17733HsOHD6/qoohS+N+83RoiIkK4du0P7O0hPDyC69d9qV9fIy3eQghxF5A7LyGEKEZISAhBQUHExcWh3DbPVmW1HhdsXc/JycFgMGBlZVVgCxdSU1MKBdxNm+ZPBbZkyTu0adOG5ORkYmNjSU5Opm3btixevLjaZFoXFa9nz57s2bOnqoshysDPD/r0qYuHhwvh4bBt203GjLlOz54wfjykplZ1CYUQQpSHtHQLIUQxtFotEyZMYOrUqURHR9+R1uOCres2NjZotVry8vKwtrYmM3MoaWlLC+2zenUMY8bkj+fu1KkTHTt2JCIigqSkJNzd3QkJCZEW7rtc3759eeONNwgPD6ddu3Y4OjqarH/44YerqGTCEhqNht27Q0hJOYi1NYSERHD0aB2+/TZ//cqVVVs+IapK//79SUxMxMPDo6qLIkSZSdAthBAl6NSpE4sXL1YzicfHx6PT6Wjbti3jx4+v8NZjY+v68ePHadiwIU5OTqSkpJCYeNPs9kOGDGf06HUmy7RaLS1atKjQconqbdy4cQAsWbKk0DqNRkNeXt6dLpIohcuXYcsWPzp2PIWdXQbu7nH4+CQCHjJvt7inffTRR1VdBCHKTYJuIYSwwJ1sPS7Yun7x4kWcnHrxzz8bCm3n4vI9ISHv8fLLi6UVWxSat13ULFeuQGamlvj4IJyc/gLyM5mnpHTl5s389RJ0CyFEzSRBtxBCWOhOth4bW9d79GhFTo5jofXNmj1K27b2jB8v47SFuBsY5+2+dKkhfn6nsbHJwt39CpCCnZ2rzNsthBA1mDSNCCFENZSbC507dzIbcO/evZfNm+ewceNGCbiFiT179jBw4EAaNWpEo0aNePjhh/njjz+quljCAsZ5u1NSrLh4sZk6b7eXVxRhYdLKLYQQNZkE3UIIUc188gnY2BRe/uCD+dnJu3fvRosWLUy6lBsMBsLDw9m7dy/h4eHS1fge9Nlnn9G7d28cHByYOHEiEydOxN7enl69erFp06aqLp6wgHHe7qtXG5GRYQtA+/axvPVWRhWXTIiq0759e+rVq0f79u2ruihClJl0LxdCiGrkv1NxFxITA/7+5tcdOHBATfKm1+vR6XQEBQUxYcIEaQm/h7z99tssWrSIyZMnq8smTpzIkiVLmDdvHk8//XQVlk5Y4n/zdttw5EgTUlJOY2+vcOpUFBcvtqdePWnxFveeuLg4rl69WtXFEKJcpKVbCCGqgYSEogNuRSk+4J46dSrHjh3Dzc0Nf39/3NzcOH78OFOnTuXAgQOVVmZRvVy8eJGBAwcWWv7www8TExNTBSUSZeXnBwMGNMHOzprwcPjyy4s880yWzNsthBA1lATdQghRxf79b/DyKrx8wYL8gLsoBoOBFStWkJiYSKNGjXBycsLKygonJycCAwNJSkpi5cqV0tX8HlG/fn127NhRaPnvv/9O/fr1q6BEojx0Oh1Hjzbi2jWwssojJOQMGg18+y1Mn17VpRNCCFEa0r1cCFFpDAbDHZliqyYrqnX71i2wty9+34iICKKiovDx8UFz24E0Gg3e3t5ERkYSERFRqqzr8nOrmV599VUmTpzIiRMn1GEF+/fvZ926dXz44YdVXDpRWpcvw9atzQgNPYe1tQFf3/MkJAQBOpm3WwghahgJuoUQlaI6jjOuzGCy4LHd3NyoXbt2sdtfulR0l/HiWrcLSkpKQq/XY19EdG5vb098fDxJSUmWHRDLfm4SlFdPY8eOxdvbm/fff5/NmzcDEBQUxFdffcWgQYOquHSitK5cgdRUexITA/D2jkarzcXb+yxZWS1l3m4hhKhhJOgWQlQ44zjjxMREfHx8sLe3JzMzUx1nvHjxnZlbumBweOnSJX755RfOnDlT4Q8Bbg9U7e3teeCBB3jkkUfo3Llzoe2nToX33y98nHXr/qJtWx0Gg2VBrLu7OzqdjszMTJycnAqtz8zMRKfT4e7ubvF5lPRzA6rdwxQBubm5LFiwgOeee459+/ZVdXFEBTDO233+fAje3hcBBS+vc5w92ww7O1uZt1sIIWoQaZoQQlSo6jLO+MCBAzzzzDMMHz6c4cOHM2bMGLZs2YJGoyk22Vhpp94yl8jM1dWVixcvMm3atNuOnd+d3FzA3apVG959N7+szzzzjEUJ0EJCQggKCiIuLg7ltuZxRVGIi4sjODiYkJCQEo9lyc9t9uzZvPrqq5K0rRqytrZm0aJF5ObmVnVRRAUxztt944Yjf/8dgKKAouRQu/ZZmbdbCCFqGAm6hRAVqjTjjCtLwUDY1dWV7OxsFEUhLy+PCxcu8Pfff2MwGGjYsKHJQ4CCgfqYMWNKDICLC1S9vb1JTk5Wj71/P1hZFT5GgwbLaNq0Ge7upQ9itVotEyZMwN3dnejoaNLT08nLyyM9PZ3o6Gjc3d0ZP368Ra3mJf3cvLy8OHLkCHFxcZK0rZrq1asXe/bsqepiiApknLc7NjYEvT7/97Jr17PMnZtdxSUTQghRGtK9XAhRoSpjnHFp3B4Ip6WlkZGRgY2NDXq9nqysLM6cOYODgwNOTk54eXkRGRnJ559/zurVq0vVJd6SQDUyMhIrK/NB76OPvkRExB4aNWqk7m8MYqOjo1m5ciUdO3YsNmju1KkTixcvVrt8x8fHo9PpaNu2LePHj7e4y3dJP7fc3FwyMzPx9/ev0KRtouL07duXN954g/DwcNq1a4ejo6PJ+ocffriKSibK6n/zdjtx4EAAt25dxN4+h/Dwc9jaNpd5u4UQooaQoFsIUaEqepxxad0eCOfk5KgvRVHQarUoioJGoyElJYVbt27h6urK+vXr1UDd0gC4pEAV6nHixM5CSwMC4Mcfwxk+/HCFZB7v1KkTHTt2LFdys5J+bhkZGQBm10HlP0wRJRs3bhwAS5YsKbROo9GQl5d3p4skKoifH3h4hPD99zGEhyv8+utZdu1qio2NDWFh+S3iLi5VXUohKseiRYu4desWDg4OVV0UIcpMgm4hRIUyjjM+fvw4gYGBJgGlcZxx27ZtLRpnXBa3B8LW1tbk5ORgMBiwts7/k5eXl4dWq8XR0ZG0tDSSkpL4+++/8fX1LVUAXFyg+tlns0lN9SxUvp9+MjBwoJa9eyu2R4BWqy1XC3NJP7eUlBTs7e2xMtdHnsp/mCJKJl37725OTk6cPOnPzZsx2NhkExJyjvPnQ/j22/z1K1dWbfmEqCxPP/10VRdBiHKr9mO6r169yjPPPEOtWrWwt7enRYsW/PXXX+p6RVGYOXOm2h20d+/enD9/vgpLLMS9rSLHGZdFwUD4doqiqK3cGo1GTT5mMBjIzs4uNgDW6/WFAuCiEpn95z8/mQ24W7YM5Ysv8seIF1dOuPNBbEk/Ny8vL9q3b098fHy5k7aJipeTk4O1tTWnT5+u6qKISnL5Mvz6awjW1mBtDXXrnsHdPQdnZ9R5u4UQQlRP1TroTkpKonPnztjY2LB161YiIyN5//33TW5CFy1axLJly1izZg2HDh3C0dGRsLAwsrKyqrDkQtzbjOOM27RpQ3JyMrGxsSQnJ9O2bdtKny7s9kA4NzcXGxsbtFotBoNBbeUGuHXrFjqdDmdnZ6ytrUsdAN8eqF66FMTPP//H7DH69u2Hh4edOkY8JSWlwjKPV5Tifm7vv/8+c+bMqbKHKaJ4NjY2+Pn5SRfyu9iVK5CU5Exioj8A1tbZeHmdw8EBsrLy1wshhKieqnX38nfffZf69euzdu1adVlAQID6f0VRWLp0KTNmzGDQoEEAbNiwAS8vL3744QeGDBlyx8sshMhvOXZ2dmb06NHcvHmTWrVqUatWrVKPMy4LYyA8depUoqOjcXJywtraGisrKzWotrKyIjc3F1dXV7y8vDAYDPj6+hITE1PqLvHGQLVzZ/MPElq0WEaDBtsBK5Mx4qtXr2bcuHFMmzaN6OhovL291eRtcXFxVRbEljQ+vCKStonK8X//93+8+eabbNy4EQ8Pj6oujqhgBeftrlMnFgBv7zOcO9cUOztrmbdb3LXOnj1Lbm4u1tbWNG3atKqLI0SZVOug+6effiIsLIwnnniCPXv2ULduXcaNG8eLL74IQExMDHFxcfTu3Vvdx9XVlQ4dOnDw4EEJuoWoAgcOHFCDMr1ej06nIygoiAkTJtyxALJgRu/IyEg0Gg3Z2dl4enqqwa2NjQ1OTk5cvHiRtm3bMnbs2DIFwDk5FBlw9+jREycn0wzSBceIu7q6Vssgtrjx4RWRtE1UjhUrVnDhwgV8fX1p0KBBoezlx44dq6KSiYpgnLf7229duHq1Ab6+l4BsatU6R5s2wZLFXNy1evXqxdWrV6lbty5XpEuHqKGqddB98eJFVq9ezZQpU3jzzTc5cuQIEydOxNbWlhEjRhAXFweAl5eXyX5eXl7qOnP0ej16vV59n5qaCuS3ztX0RDQGgwFFUWr8edwJUlelY0l9HTx4kGnTppGUlGQSuJ48eZLXXnuNRYsWERoaekfK27FjR+6//34iIyPZt28fn3zyCXq9Hnd3d7VcsbGxeHh4MG7cOEJDQ3nvvfdYtWoVZ86c4fr16+h0Otq1a8fYsWPp2LFjoXN/8kkN336rMfv5jz76GHq9Q6HEbAAODg5cv36dxMREunbtqpbTGMQGBwer3eGrq9tb/ctaVvk9rLgEaIMHD66Q44jqa+HC/H//+KM5tWtfwsoKunc/w2uvNaGa39IJIcQ9rVr/hTYYDLRv354FCxYA0KZNG06fPs2aNWsYMWJEmY+7cOFC5syZU2j59evXa/xYcIPBQEpKijo1kiia1FXplFRfBoOB77//njp16tCqVSuTYLNZs2bExcXx/fffExAQcEfru06dOjz66KMEBQWxZcsW/v77b3JycnBycqJt27b079+fwMBAEhISCAwM5L333uPy5cukp6fj5OSEn58fWq2WhIQEk+P6+Hib/bzvv7+Jt/d5Nm9uQEpKCnZ2doW2MWY71+l06nHr1KlDnTp1ALhx40YF10L1Jb+HkJaWViHHmTVrVoUcR1Rf/5u324V9+/zIyrqMvb2eiIjzWFkFybzdQghRTVXroNvHx4fg4GCTZUFBQXz73/kxvL3zb3rj4+Px8fFRt4mPj6d169ZFHnf69OlMmTJFfZ+amkr9+vXx9PTEpYZPdGkwGNBoNHh6et6zN7CWkroqnZLq6/Tp0+zatQtXV1ezyZzS09PZtWsXw4cPp3nz5neiyCbq1KlD165dzbYo3874t8WcixehcWPz35e8PAPgTm5uW7755hsOHz6Mv79/oTHiFy9epE2bNrRv3/6e/+7J7yFmH8yUxuHDh2nXrl2R07np9Xp+/PFHnnzyyXJ9jqg+/Pygf//m/PTTZcLDYdu2KHbtaoytrbXM2y2EENVQtQ66O3fuzNmzZ02WnTt3jgYNGgD5SdW8vb3ZsWOHGmSnpqZy6NAhxo4dW+RxdTodOp2u0HKtVntX3PRpNJq75lwqm9RV6RRXX8nJyWRmZuLl5VUoGzfkBxZxcXEkJyeXur4NBkOFjCHWarW0bNmy1PsZP79lS/PjnOvWNWYOzi+TtbU1/fv35+DBg1y4cMHsGPFx48ap84bf6+7138PynndoaCjXrl1Te0q4uLhw4sQJGjZsCOT/bg4dOlSC7ruMq6srp07V58aNv7G11RMScp4LF4Jk3m4hhKiGqvUdzuTJk/nzzz9ZsGABFy5cYNOmTXz88ceMHz8eyL9RmzRpEvPnz+enn34iPDyc4cOH4+vrK2PbhLjDKmLeaYPBQHh4OHv37iU8PByDwcCBAwd45plnGD58OGPGjGH48OE880z+XNd3gvHziwq4b940P1VPUFAQixYtqpJp08S9xdyUcyVtUxrvvPOOer01ysrKYvz48dSqVQsnJycee+wx4uPjTfa7fPky/fv3x8HBgTp16vDaa6+Rm5trss3u3btp27YtOp2ORo0asW7dujKX815z+TL89ltzdd7uevWicHfPlXm7hRCiGqrWzSz33Xcf33//PdOnT2fu3LkEBASwdOlShg0bpm4zbdo0MjIyGD16NMnJyXTp0oVt27aVu7ueEKJ0jPNjHz9+vNTTboH5rOe1a9cmLi6OnJwcfHx81NZi41zXlR28HjhwgBde+JKoqE1m1+/ffwAPj6I/PzQ0lNDQUMn0LaqcuYR+ljhy5AgfffRRoR4ikydPZsuWLXz99de4uroyYcIEHn30Ufbv3w9AXl4e/fv3x9vbmwMHDnDt2jWGDx+OjY2NmqclJiaG/v37M2bMGD7//HN27NjBCy+8gI+PD2FhYeU74XvAlStw86YbSUl+eHpextpaj5fXWfT6EPVhoIzvFkKI6qHa3/kNGDCA8PBwsrKyiIqKUqcLM9JoNMydO5e4uDiysrL4/fffadKkSRWVVoh7l3F+bHd3d6Kjo0lPTycvL4/09HSio6OLnXbrwIEDTJ06lWPHjuHm5oa/vz+urq4cOnSICxcuqK1pVlb/m+s6KSmJlStXVlrWa4PBQOfOnYiKWlZoXWDgVzRrFmTR5xun3+rWrRstWrSQgFvUGOnp6QwbNoxPPvnEpIdKSkoK//rXv1iyZAk9e/akXbt2rF27lgMHDvDnn38C8NtvvxEZGclnn31G69at6du3L/PmzWPlypVkZ2cDsGbNGgICAnj//ffVaQUff/xxPvjggyo535rGOG/3uXP/64Xj4xOFXp+NnR0yb7cQQlQjcvcnhKgwxvmxS9Ol2mAwsGLFChITE2nUqJEaXCuKgkajQaPREBsba9I9tuBc1xERERV+Hrm5YGVl/s9j//4DCQr6rFI/X4jSioyM5NSpU5w6dQpFUThz5oz6vqzf0fHjx9O/f3969+5tsvzo0aPk5OSYLG/WrBl+fn4cPHgQyJ8+sEWLFiZTeoaFhZGamqqW5+DBg4WOHRYWph5DFM84b3dCggtXrgSgKKAoOXh6niEsTFq5hRCiOqnW3cuFEDVPp06d6Nixo8VdqiMiIoiKisLHx8ekC2xOTg4GgwF7e3vS09NJS0szmV3A3t6e+Ph4kpKSKrT8CxfCm2+aXzdgwMBK/3whyqJXr14mD6YGDBgA5D+gMj7AKo0vv/ySY8eOceTIkULr4uLisLW1xc3NzWS5l5cXcXFx6jYFA27jeuO64rZJTU0lMzMTe3t7s2XT6/Xo9Xr1fWpqKpD/AK+8PV9q2rzxb78NGg3s3RuMp2cMVlYKHTue4YEHGnPpko769Svvs2taXVU1qa/SKaq+pP7Mk+9X6VRkfVl6DAm6hRAVoqwZxpOSktDr9YVusG1sbNBqteofxZycHJP1liRmK62i4pKuXSfh6hpdps+vqMzrQhQlJiamQo/3999/88orr7B9+/ZqmR9l4cKFzJkzp9Dy69evk5WVVa5j18R542fMgOvX4ejROly8eJm0ND1ffHGIlJRmtG0Lw4eDg0PFf25NrKuqJPVVOgXra8uWLeTl5WFlZUVCQkJVF61aku9X6VRkfaWlpVm0nQTdQohyM5cEzThGs6REZwWznjs5OanLnZ2dcXJyIikpCWtra2xsbNR1liRmK43ERKhVy/y6Zs2CcHEJBEqXGA7yu8+uXLmyTPUihKWM02hWlKNHj5KQkEDbtm3VZXl5eezdu5cVK1bw66+/kp2dTXJysklrd3x8vDrHvbe3N4cPHzY5rjG7ecFtbs94Hh8fj4uLS5Gt3ADTp09nypQp6vvU1FTq16+Pp6enSW+Ysqip88bXqQMff+xEWtp1bG0NODjEc+LEffz1lz03bsCywqkpyq2m1lVVkfoqnYL1ZfybIYom36/Sqcj6svThtATdQohyMSZBS0xMLFOG8aKynms0Gho0aEBiYqI6tjsvL89kruuiErOVxtixsGZN4eXjxsGwYQeYOjU/MZy5ubaL+/yoqChmzJjBzZs3qyTzuhBl1atXL8LDw02WjRo1imbNmvH6669Tv359bGxs2LFjB4899hgAZ8+e5fLly4SGhgL5mfvffvttEhIS1PnDt2/fjouLC8HBweo2v/zyi8nnbN++XT1GUXQ6HTqdrtDyiprrvSbOG3/5Mmzd6kTjxk3w9z8LGGjSJIpTp9qzbVvlZTKviXVVlaS+Skfqq3SkvkqnourL0v3L/VMpOK5KCHFvKSoJWmkyjBeX9TwpKYlGjRrRoUMHUlJSKnyua43GfMCdlgYrV5YtMZyxXrZs2aKW/05nXheiPJydnWnevLnJy9HRkVq1atG8eXNcXV15/vnnmTJlCrt27eLo0aOMGjWK0NBQOnbsCMBDDz1EcHAwzz77LCdPnuTXX39lxowZjB8/Xg2Yx4wZw8WLF5k2bRpnzpxh1apVbN68mcmTJ1fl6ddIV65AVhYkJARjMFgB4OkZjbt7BllZ+euFEEJUnVK3dG/dupUvv/ySP/74g7///huDwYCjoyNt2rThoYceYtSoUfj6+lZGWYUQ1UxRSdCgcIbxFi1aFHEU6NixI2PHjmX9+vVcuXIFrVaLTqejbdu2jB8/vlSJ2Sxx8iS0bm1+XYFcVEDxieGKGq8dGRnJ33//jbe3d7nqRYjq6oMPPkCr1fLYY4+h1+sJCwtj1apV6norKyt+/vlnxo4dS2hoKI6OjowYMYK5c+eq2wQEBLBlyxYmT57Mhx9+SL169fj0009lju4yME4flppqR3x8U3x8ItFoDNSpc5rExA4yfZio0T7++GPS09NxcnJi9OjRVV0cIcrE4qD7+++/5/XXXyctLY1+/frx+uuv4+vri729PYmJiZw+fZrff/+defPmMXLkSObNm4enp2dlll0IUcWKSoJmZEmG74LjwY1JkHx9fRkxYgTDhg1Tg+uKCk4bNgRzead++gkGDiy8HP4313ZR5b59vHZOTg45OTnlqhchqpPdu3ebvLezs2PlypWsXLmyyH0aNGhQqPv47Xr06MHx48crooj3NOP0Yd9+C2fPNsPT8zyQQ+3aMfTtG4yfn3NVF1GIMps7dy5Xr16lbt26EnSLGsvioHvRokV88MEH9O3b12wL05NPPgnA1atXWb58OZ999pl0ERPiLldUEjSjkjJ8FzUe/OrVq6xevZrAwMAKG/dsMICVVdHrSjOjUknj2MeOHYuNjQ3Jyck4OjoW2r8yMq8LIe5tCxfm//vrrzrOnm1G06bh+PoqPPjgaaD4cfJCCCEql8VB98GDBy3arm7durzzzjtlLpAQouYoKgkalJzh+/bx4MZ9jeOeo6OjWblyJR07dix3kovDh6FDh8LL778fDh0q3bEsKfe2bduoV68ep0+fJiAgoFT1IkRptGnTxuI5uI8dO1bJpRFVycUlPxfF5ctw6VJTYmPPYm2dTUxMLAZDMI0bu1ZKMjUhhBAlq5D0dhkZGaSmplbEoYQQNUhxSdCio6OLzfBdmvHg5eHvbz7gPnu29AE3WFbuM2fO0L59e9zc3EpdL0KUxuDBgxk0aBCDBg0iLCyM6OhodDodPXr0oEePHtjZ2REdHS3jpO8hfn7QtasNwcHBhIfDwYOwZMkpevaE8eNBbteEEOLOK9eUYZGRkQwfPpxjx46h0WgIDg5m7dq1tG/fvqLKJ4So5owZvo3jm+Pj402SoBXVPbwixoMXJykJPDwKL/f2hmvXynTI/x635HJfv34dT09PFi1apM7TbWm9CFEas2bNUv//wgsvMPH/2bvv8KjKtPHj35mUSWBSIQ1SCAFJIZSAkAQFRAQVO++76oqg67qWYENkYddVUXdZEXFXifJuUXTVtfxQV0EEBIGFhBaCQBJaKCkw6b1Mkpnz+2OcIWUCkzop9+e6uHTOOXPmmSeTzLnP8zz3/eSTvPLKKy2Oyc7O7u6mCTt7772RlJQcZ+DAWoKCcrhwoZj1601/FC+zFF8IIUQX6FDQ/cgjj7Bw4UJ+8YtfUFdXx5tvvsmCBQs6PDIlhOhdLpfhuzUdXQ9+OU8+CW+/3XL7q6+mcdttRozG9mc/t7XdWq2WSZMmERcX16mZ14VozRdffMHBgwdbbJ83bx4TJ07kvffes0OrhD1kZcHmzY4EBkYREZECQGTkYSorZ7B5s2m/TDUXQoju06Yrv9tvv53c3FzL44KCAm677TYGDBiAp6cnN998M3l5eZ3eSCFEz2fO8D116lSio6OvGFia14PrdDqUZnW6zOueIyMj27zuWaWyHnCPGRPLxx//L/Pnz2fevHkkJSW16bxtaXdERATBP1/RtrVfhGgvV1dX9uzZ02L7nj17cHFxsUOLhL2Y63aXlo5Arzclc3R3zyMgQCd1u4UQwg7adPU3b948ZsyYwVtvvYWiKCxcuJCoqCjuuece5s6dy4033sjTTz/dRU0VQvQlHVkPbs3Ro61nIB81Khxvb1eGDRuGp6enJct4ewJvW9r92GOPSXAtut3TTz/NY489xpNPPslHH33ERx99xBNPPEFCQoJUE+lnzHW7q6rU5OSMtWwfOjQVFxdF6nYLIUQ3a9NV4f/+7/+yf/9+0tPTiY2NZcqUKWzZsoUpU6Zw7bXXsmXLFp5//vmuaqsQoo8xrwcfP348paWlnDt3jtLSUmJiYli1apXN655HjoQxY1puv/ba1YwaFc6IESPQarU4ODhYsoyXlJSQmJiI0Wjs9HbHxUl5HtH9li5dygcffEBKSgpPPvkkTz75JIcOHeL9999n6dKl9m6e6Ebmut0VFXD2bDCVlZ40NICLSym33JIlU8uFEKKbtXlNt4eHB2vXrmX37t0sWLCAG264gVdeeYUBAwZ0RfuEEH1ce9aDmxkM4NjKX7GffjrKggX/sik7enR0dKe2uz2BvBCd4Re/+AW/+MUv7N0M0QNcqtut4qefxjN58o8EBMCoUT+xe3cQwcFqCb5Fr3DVVVfh4eGBn5+fvZsiRLu1ef5jcXExKSkpREdHk5KSgru7O+PHj+e7777rivYJIfqB9qx7/tOfrAfcMTGgKFBaeuUs43q9vt3Z0dvbbiG6UmlpKf/4xz/43e9+R3FxMWCqz904H4voH8x1u7dvh7Vr/Zk50xSw7N5dxZIlp6SEmOg1tm/fTlpaGtu3b7d3U4RotzZdIX7yyScEBgYyZ84cQkJC2LRpEy+++CL/+c9/WLlyJb/4xS8kkZoQosupVPD737fcfvw4pJgS9TbJMm5NR7KjC9ETHTlyhKuuuorXXnuN119/ndLSUgC+/PJLli1bZt/GCbsJDob4eNizZ5ylXGJERBqOjvWsXw/y0RBCiK7XpqB72bJlvPfee+h0OrZt28Yf/vAHAMLDw9mxYwc33HCDrGUUQnSZ/PzWk6UpCowadelxV2VHF6KnWrRoEQ888ACnTp1qkq385ptvZteuXXZsmbC3rCz47jtviouDcXQEZ2c9o0Zl4OaGpYSYEEKIrtOmoLuyspJRP1/VhoWFUV1d3WT/ww8/zN69ezuvdUII8bNJk8Dacq5p00wBd3OdnR1diJ7uwIEDPPLIIy22Dx06FJ1OZ4cWiZ7CXEJMpxsDmO5c+vufwMOjRkqICSFEN2hTIrUFCxYwZ84cpk+fzsGDB7n//vtbHOPr69tpjRNC9G1Go9GmBGqtjW4XFsKgQa2f35xlfM2aNWRkZJCXl4dGoyEmJoaEhASbs6ML0RtoNBrKrSzQPXnyJD4+PnZokegpzCXEiovdyM8fga/vKdTqBnx9j1FaerWUEBM92n333UdhYSGDBw/m448/tndzhGiXNgXdq1ev5rrrruP48eM88MADzJo1q6vaJYTo45KSkizBsF6vR6PREBERwcKFCy3BcFoajB5t/fnWRret6Uh2dCF6k9tuu42XX36Zzz//HDBl6c/KyuK3v/0tc+fOtXPrhD2ZS4itXw8ZGaPx9j4LNODrm0lY2CiCg93t3UQhWrVz505yc3MZOnSovZsiRLu1+arz1ltv5bnnnpOAWwjRbklJSSxevJhDhw7h6enJsGHD8PT0JDU1lcWLF5OUlISHh/WAe9Uq2wNuM8kyLvqDN954g8rKSnx9fampqWHatGmMGDECNzc3/vjHP9q7ecLOVqyAuXOhrs6FEyciABgyRGH69CMkJcm6biGE6Eo2j3R/+umn3HPPPTYdm52dTVZWFlOmTGl3w4QQfZPRaGTNmjUUFxczYsQISw1trVZLWFgYp0+fYcoU69O+jcbWp5oL0d95eHiwdetW9uzZw08//URlZSUxMTHMnDnT3k0TPYC5hFhWFpw/H87p0yc5dUrP999nk5RUhF4/iNmzTcG5uwx8CyFEp7J5uOfdd98lIiKClStXkpGR0WJ/WVkZ3333Hb/85S+JiYmhqKioUxsqhOgb0tLSyMjIICAgwBJwm128eA0nTqS3eE50tGl0WwJuIayrr6/H0dGRY8eOMWXKFB5//HGWLFkiAbdoITgYrr3WkSNHoi0lxMaOPYxKpUgJMSGE6CI2j3Tv3LmTb775hrfffptly5YxcOBA/Pz8cHFxoaSkBJ1Ox+DBg3nggQc4duwYftbSDAsh+r2SkhL0ej2urq5Ntm/Y8K3V4w8dgvHjO/aatiZsE6K3cnJyIjg4GIPBYO+miF4gKws2bAhj8uTjuLhU4uGRT0hILufPB1pKiAUH27uVQgjRd7Qpkdptt93GbbfdRmFhIbt37+b8+fPU1NQwePBgxo8fz/jx4+VCVoh+or2BrJeXFxqNhpqaGrRaLfX1rmze/LnVY9u6dtsaWxK2CdEX/P73v+d3v/sd//rXv/D29rZ3c0QPlpMDNTVqcnPHER6+G4CgoMMUFg6hsFBNTo4E3UII0ZnaFHSbDR48mDvuuKOTmyKE6C06EshGRUURERFBamoqZ84kUVfn1eKYUaM28tlngezaVdahkWlzwrbi4mICAgJwdXWlpqbGkrBt1apVEniLPmPNmjWcPn2aIUOGEBISwsCBA5vsP3TokJ1aJnoacwmxnJxAAgMHo9UW4uJSgafnKSorR0kJMSGE6GTtCrqFEP1XcnIyzz33XLsDWbVazcKFC1tNlhYREUdgoBsPPFDQoZHpKyVsy8zMJDExkdjYWJmhI/oEuRkubHWphJiKtLQYJk3agsEAgYHHGD06lOBgZ3s3UQgh+hQJuoUQNjMajbzzzjsdCmSTkmg14L7hhllcvFhJVlZJh0emL5ewTaVS4e/vT3p6OmlpaURHR7ehF4TomV588UV7N0H0IitWmP67efMgzp8PITDwPMHBdcTHp5GUNJ7AQJliLoQQnUWCbiGEzbKysjh+/Hi7A9nWso/feutFXnklnz//eRBZWVmdMjLdWsI2M1dXV/Ly8igpKbniuYQQoq9pXELszJmxnD6dw5kzBr766iS7do1AUdykhJjoER5++GHKysrw8PCwd1OEaDcJuoUQNqusrGxXIGs0goOD9XM2NICDQwBHjxZ2KKBvrnnCtuZqamrQaDR4ebVcUy5Eb2QwGHjzzTf5/PPPycrKoq6ursn+4uJiO7VM9GTBwRAcPJBvvx1FcXE6jo5Gxo37icOHr2H9etMxiYn2baPo32QWj+gLOrSQsa6ujhMnTtDQ0NBZ7RFC9GBardYSyFpjLZB9443WA25FubTPlpFpvV5v88i0OWGbTqdDaZYGXVEUdDodkZGRREVF2XQ+IXq65cuXs3r1au6++27KyspYtGgRd911F2q1mpdeesnezRM9mKmEWCRGowuOjjB4cDZDhxbg5oalhJgQQoj2a1fQXV1dzUMPPcSAAQOIiooi6+e/xk888QR//vOfO7WBQoieIzg4mPDwcJsDWZUKFi9ueZ6dO40cOXKUXbt2cfToUYxGY5ORaWvaOjJtTtjm5eVFZmYmlZWVGAwGKisryczMxMvLi4SEBEmiJvqMjz/+mL///e88++yzODo6cu+99/KPf/yDF154gb1799q7eaIHy8mBqionLly4NIsoOPgQAwYo1Naa9gshhGi/dl1tLlu2jJ9++okdO3bg4uJi2T5z5kw+++yzTmucEKJnUavVPP7441cMZCsr1a2u396zJ4m1a+cxf/58Hn30UebPn8+8efMoKyvr9JHp+Ph4Vq1axfjx4yktLeXcuXOUlpYSExMj5cJEn6PT6SxLL7RaLWVlZQDccsstbNy40Z5NEz2cuYTYuXNh1NSY1s0OHFiMm9t5XFyQEmJCCNFB7VrT/fXXX/PZZ58RGxvbZO1lVFQUmZmZndY4IUTPExcXx6pVqyx1uvPy8tBoNMTExJCQkMDXX8czZUrL502eDKtXt143e8mSJSxYsIBz586RmZmJv7+/Zb9Op2v3yHR8fDyxsbGkpaVRUlLSobrfQvRkgYGBXLx4keDgYMLCwtiyZQsxMTEcOHAAjUZj7+aJHqxxCbH09PHExOzAYICgoMOEhQWSk+NoOU6I7hYYGEhubi5Dhw4lR6ZdiF6qXUF3QUEBvr6+LbZXVVW1SIAkhOh7WgtkHRysB7J5eTB4sJF58y5fN3vXrl2sXLmSd955x2pA33xk2mg02hRMq9VqKQsm+rw777yTbdu2MXnyZJ544gnmzZvHP//5T7KysnjmmWfs3TzRw10qIRZAbu4Q/Pwu4O5eQ2ZmOr/4xRhcXJBs5kII0U7tCronTpzIxo0beeKJJwAsF8//+Mc/iIuL67zWCSF6rMaB7L59l0+WBnD0qG11sz08PPjoo4+uGEwnJSVZRtv1ej0ajYaIiAgWLlwo08ZFv9Q4p8rdd99NcHAwycnJjBw5kltvvdWOLRO9QeMSYqdPj2fTJh2FhUZCQjIoLx9OSYlWspkLIUQ7tSvo/tOf/sRNN91Eeno6DQ0N/PWvfyU9PZ2kpCR27tzZ2W0UQvRgrU1u+fRTuPvuS4/bUjf7SiPTSUmtT1NfvHixrNcWAtNSELkRLtrKNIXcnSNHriI4+DiOjkaGD0/l9OlrgUvZzGWdtxBC2K5dQfc111zDTz/9xIoVK4iOjrasG0tOTpYpnEL0E4oCrS2LNhha7vPy8sLZ2ZmCggKcnJxwcnLCzc3NMupta3Zyo9HImjWXn6aemJhIbGysrNsW/cqHH3542f3z58/vppaI3i4nB44fH01g4DmgFi+vHNzc8qiv96OoyLRfgm4hhLBdm4Pu+vp6HnnkEf7whz/w97//vSvaJITo4b7+Gu680/q+ZonHLcrKyigpKSEvLw9HR0ccHBzQarUMGzYMLy8vdDodMTExV8xOnpZm2zT1tLQ0uQko+pWnnnqqyeP6+nqqq6txdnZmwIABEnQLmwUGgpOTEydPjmX06H0AhISkkJt7Iy4uagm4hRCijdo8DOTk5MR686IeIUS/4+Cgthpw79jResCdlJTEkiVLANBoNCiKglqtpqysjGPHjnH06FGbs5PbMk1dr9dTUlLSlrclRK9XUlLS5F9lZSUnTpzgmmuu4d///nebzvXuu+8yZswY3N3dcXd3Jy4ujk2bNln219bWkpCQwKBBg9BqtcydO5e8vLwm58jKymLOnDkMGDAAX19fnnvuORoaGpocs2PHDmJiYtBoNIwYMYJ169a1+/2LzmPOZn7qVCglJd4oCjg5leHpeZrZsyWLuRBCtFW75l7ecccdfP31153clCv785//jEql4umnn7Zss+WLXwjRcZWVEBDgb3WfosC0adaf13g6eHR0NNHR0Xh6emI0GgHQ6/WoVCpWrlxp0zpsLy8vNBoNNTU1VvfbOk1diP5g5MiR/PnPf24xCn4lgYGB/PnPfyYlJYWDBw8yY8YMbr/9dtLS0gB45pln+Pbbb/niiy/YuXMnFy5c4K677rI832AwMGfOHOrq6khKSuKDDz5g3bp1vPDCC5Zjzp49y5w5c7juuus4fPgwTz/9NL/+9a/ZvHlz57x50SErVsDcuSpOnpxAXZ1p29SpR7n1Vj1ZWfZtmxBC9DbtWtM9cuRIXn75Zfbs2cOECRMYOHBgk/1PPvlkpzSusQMHDvB///d/jBkzpsn2Z555ho0bN/LFF1/g4eHBwoULueuuu9izZ0+nt0GI/up3v4MVK1reo1u4EN5++/LPbT4d3MvLC09PTyoqKqivr6e8vBy9Xk9eXh5Go/GKI91RUVFERESQmppKWFhYkynmiqLYPE1diP7C0dGRCxcutOk5zbOd//GPf+Tdd99l7969BAYG8s9//pNPPvmEGTNmAPD+++8TERHB3r17iY2NZcuWLaSnp/PDDz/g5+fHuHHjeOWVV/jtb3/LSy+9hLOzM2vXriU0NJQ33ngDgIiICHbv3s2bb77J7NmzO+fNi3a7lM18MD/+OIy0tHOUlNTxxhtHOHv2am68ERYtsncrhRCid2hX0P3Pf/4TT09PUlJSSElJabJPpVJ1etBdWVnJfffdx9///ndeffVVy/aysrIrfvELIdqucf3radOmWj2muBhsGUy2Nh1cpVJhMBg4f/48FRUV6PV6li5dyvr1669Y8kutVrNw4UIWL15MZmYm/v7+luzlOp3O5mnqQvQ133zzTZPHiqJw8eJF1qxZw5QpU9p9XoPBwBdffEFVVRVxcXGkpKRQX1/PzJkzLceEh4dbSpTFxsZaEqv6+flZjpk9ezaPPfYYaWlpjB8/nuTk5CbnMB/TeDabsL/gYDhwYBzl5TloNA2EhZ2moGAkX37pzuDB0GjyghBCiFa0K+g+e/ZsZ7fjshISEpgzZw4zZ85sEnTb8sUvhGgbc/3r1NRqjh//2uoxra3dtqbxdHCtVguYAvH09HTq6upwcnJCo9Hg6elpc8mv+Ph4Vq1aZanTnZeXh0ajISYmhoSEBCkXJvqlO+64o8ljlUqFj48PM2bMsIwmt8XRo0eJi4ujtrYWrVbLV199RWRkJIcPH8bZ2RlPT88mx/v5+aHT6QDQ6XRNAm7zfvO+yx1TXl5OTU1Nq3kb9Ho9er3e8ri8vBww3Sw0L1tpL6PRiKIoHT5PX5KdDVu2aAgOjuCqq44AEB29n4MHryM1VSEryyhrvG0gn622adxfH374IXq9Ho1GI/3XCvl8tU1n9pet52hX0N2Y8vPVd/Mswp3l008/5dChQxw4cKDFPp1Od8Uvfmu68gvb3uSXznbSVy0lJyezZMkSDh78mLq6YS32L1uWxssvj8JotH0UOSIiwnKhbg66z58/T0NDA1qtlurqajw8PPD3N60XP3PmDO+88w6TJk267Gh1bGwskyZNIj09nZKSEry8vIiMjEStVtv9ZyqfLdtJX9n+hd1d5zEbNWoUhw8fpqysjP/3//4fCxYsYOfOnZ36Gu2xYsUKli9f3mJ7QUEBtbW1HTq30WikrKzMkuxRwJkzMHw4uLt74ezsiJNTFQMH5hIbexhnZy1nzii4uEhfXYl8ttqmcX9FRkZatufn59uxVT2XfL7apjP7q6Kiwqbj2h10f/jhh7z++uucOnUKgKuuuornnnuO+++/v72nbCE7O5unnnqKrVu34uLi0mnn7covbHuTXzrbSV81ZTQa+fLLr0hKsp4P4c47/wetNoa8vAU4ODi06dy//vWvee+996iqqsLFxYXhw4ejVqtpaGjA0dGRoKAg3NzcAPDx8aGqqoqDBw8ybNiwK57b19cXX19fAAoLC9vUrq4iny3bSV/Z/oXd3ZydnRkxYgQAEyZM4MCBA/z1r3/l7rvvpq6ujtLS0iY3vfPy8iw3z/z9/dm/f3+T85mTnDY+pnni07y8PNzd3Vsd5QZYtmwZixotJi4vLycoKAgfHx/c3d3b/4YxfR7NMwT66+exOb3eFHirVFBUNIVRo8w3XrLIz7+a4cN98fWVvroS+Wy1jfRX20h/tU1n9petMWq7gu7Vq1fzhz/8gYULF1rWie3evZtHH32UwsJCnnnmmfactoWUlBTy8/OJiYmxbDMYDOzatYs1a9awefPmK37xW9OVX9j2Jr90tpO+amrNmvOsXr3K6r5bb72NsrIqjhw5QmFhYZvrX/v6+uLs7Mw777zDwYMHycrKQqPR4ObmRkhICKWlpZSWlgJY1nrr9XpLMN3byGfLdtJXtn9hX8miNmS1Wr16dZvPbzQa0ev1TJgwAScnJ7Zt28bcuXMBOHHiBFlZWcTFxQEQFxfHH//4R/Lz8y2/x1u3bsXd3d0yahUXF8d3333X5DW2bt1qOUdrNBoNGo2mxXa1Wt0pnyGVStVp5+oLQkLghhtg/XowGofi7R2Ep2cOKpWeiIjT5OYGolarZYq5DeSz1TbSX20j/dU2ndVftj6/XUH322+/zbvvvsv8+fMt22677TaioqJ46aWXOi3ovv766zl69GiTbQ8++CDh4eH89re/JSgo6Ipf/NZ09Re2vckvne2kr0xMq0NCW2yfOvUJ3N3PoSimwMB8k6s9/TVlyhTi4uL46quvWLp0KZ6envj5+aFSqSzLVACqq6txcnLC29u7V/9c5LNlu/7eV531vlNTU0lNTaW+vp5Ro0YBcPLkSRwcHJrcvLZlOdiyZcu46aabCA4OpqKigk8++YQdO3awefNmPDw8eOihh1i0aBHe3t64u7vzxBNPEBcXZ8mlMmvWLCIjI7n//vtZuXIlOp2O559/noSEBMv376OPPsqaNWtYsmQJv/rVr9i+fTuff/45Gzdu7JT+EJ1nxQrTfzdvhtTUGK699iIaTQM1NVn85jcl6PWDmD3bdFwvH7sQPdCOHTssa7qnT59u7+YI0S7tCrovXrxoNVFRfHw8Fy9e7HCjzNzc3Bg9enSTbQMHDmTQoEGW7Vf64hdCtK6yEn6e1d3CLbc0LRlkToTWkfrXarWaO++8k/Xr15OamtoiiZKU/BKi/W699Vbc3Nz44IMPLL+nJSUlPPjgg1x77bU8++yzNp8rPz+f+fPnc/HiRTw8PBgzZgybN2/mhhtuAODNN99ErVYzd+5c9Ho9s2fP5p133rE838HBgQ0bNvDYY48RFxfHwIEDWbBgAS+//LLlmNDQUDZu3MgzzzzDX//6VwIDA/nHP/4h5cJ6oEvlwyAnZyD/+tdo9PrDDBigMH58Cvv23cD69aabOYmJdm6s6HPmzZtHbm4uQ4cOJScnx97NEaJd2hV0jxgxgs8//5zf/e53TbZ/9tlnjBw5slMaZqsrffELIaz7wx+gUTEAC0/PT5ky5SOgaf3rvLw8YmJimiQ0aQ8p+SVE13jjjTfYsmVLkxtjXl5evPrqq8yaNatNQfc///nPy+53cXEhMTGRxMtEWCEhIS2mjzc3ffp0UlNTbW6XsC/zFPIffghn8uRMHBz0uLsXEhZ2lszM4WzebArMZaq5EEI01a6ge/ny5dx9993s2rXLsqZ7z549bNu2jc8//7xTG9jcjh07mjy25YtfCNFUa7NLN23az8svv0VmZkmLYNjb25s5c+Z0SjAsJb+E6Hzl5eUUFBS02F5QUNBjk7WJ3icnB2pq1OTkTCAgYDMAQUGHyc8PJD/fmZwcCbqFEKK5dgXdc+fOZd++fbz55pt8/fXXgKks0P79+xk/fnxntk8I0Q5Go5G0tDRKSkrw8PAAoKysjIoKP265ZZTV55iWVU/C3d16MPz4448TFhZm9TW8vLyIiopqU0AeHx9PbGxsh84hhLjkzjvv5MEHH+SNN95g0qRJAOzbt4/nnnuOu+66y86tE31FYCC4uMDFi/5UVwcAxTg66vH3/4ny8qsJDLR3C4UQ4vKys01VGfR6U7LI7tDukmETJkzgo48+6sy2CCE6QVJSkiVoLikpoaysDICamh/Q61sG3P/6F8ybd+lxa8EwXKqP2fg1zMlNIiIiWLhwYZtGqdVqdZszoQshrFu7di2LFy/ml7/8JfX19QA4Ojry0EMP8frrr9u5daKvCA6G2bPhq6/g4sVRDB58AEUx4Od3moCA4eTkDLIcJ4QQPUl5OSxbBlu3wvDhpsD7hhu6Jwlku4Lu7777DgcHhxbJTjZv3ozRaOSmm27qlMYJIdomKSmJxYsXU1xczIABAygrK6O2Vk9tbbXV4xsawFrJbWvBsNFoBCA5OZnnnnuO4uJiAgICLFPQU1NTWbx4MatWrWrz9PCOjpoLIWDAgAG88847vP7662RmZgIQFhbGwIED7dwy0desWGFappSV5UpGxmhGjfoJZ2coLd3P3XfPRqNRSzZzIUSPs2yZqfxhWFg2Xl4KKpXpMXR9Esh2XdUuXboUg8HQYruiKCxdurTDjRJCtJ3RaGTNmjUUFxcTFhZGXl4eev1VVgNuR8eL/PKX96FSGdv8Gu+88w7FxcWMGDECrVaLg4MDWq2WsLAwSkpKSExMtATotkhKSmLevHnMnz+fRx99lPnz5zNv3jySkpLa1DYhhMnAgQMZM2YMHh4enD9/vk2/j0LYwt0d3noL/vhH+NOfrsLd3YO6OnB3L2X06BOWC9lly+zdUiGEMMnKMpU99PUtJzo6mSFD/ktY2Gnc3LAkgexK7Qq6T506ZTWDcXh4OKdPn+5wo4QQbZeWlkZGRgYBAQFUVlZy4UIuNTX7WhwXE/Nrrrnml6Snp5OWltam18jKyuL48eMEBAS0qPWrUqnw9/dv03nNI/OHDh3C09OTYcOG4enpaRk1l8BbiCt77733WL16dZNtv/nNbxg+fDjR0dGMHj2a7OxsO7VO9GU+PhAcrGbHjkk4OoKjIwQHH8XHp6rbLmSFEMIWOTlQW6sQFXUAtdqIWt2ARlPFgAFQW2va35XaFXR7eHhw5syZFttPnz4t09iEsMJoNHL06FF27drF0aNHu2TkqaSk5Of11W7s2rXT6jFarRsaTTqurq7o9XpKSkra9BqVlZXo9XpcXV2t7m/LeRuPzHfWqLkQ/dHf/va3JmXCvv/+e95//30+/PBDDhw4gKenJ8uXL7djC0VflpMD+fmDKSgwlYxVqw2EhBxkwAClWy5khRDCFoGBEBJyDq3WlJ+oocGVCxeiqK42JYfs6iSQ7Qq6b7/9dp5++mnLmjEwBdzPPvsst912W6c1Toi+oLumT3t5eVFbez2bN3/TYp+b25MMGjQYtVqNk5MTNTU1aDSaJhfqttBqtWg0Gmpqaqzub8t5G4/Md8aouRD91alTp5g4caLl8X/+8x9uv/127rvvPmJiYvjTn/7Etm3b7NhC0ZeZs5kfPz6G+nrTDVlPzwsMGJDTLReyQghxJVlZcO6cnri4VBoaTDmNioqiKC11pKLClByyq5M/tivoXrlyJQMHDiQ8PJzQ0FBCQ0OJiIhg0KBBrFq1qrPbKESv1Z3Tp2+7bTRnz77dYvugQaNwdf2M2tpatFotWq0WnU5HZGSkJSu5rYKDgwkPD0en06GYaoxZKIrSpvOaR+Y7Y9RciP6spqYG90bZqpKSkpg6darl8fDhw9HpdPZomugHgoJMF6ylpc6kp8egKKYL2tDQFGbPrpMs5qLDcnJyUBSFHJk2IdqovBwSEmDGDPjTnw5RWqrH2Rny8oLIz/dBUWDuXFPSx67WruzlHh4eJCUlsXXrVn766SdcXV0ZM2ZMky95Ifq75tOnzaO55unTmZmZJCYmEhsb26FM3YWFpnV10HS0WKM5h6vreKqr9T8/1uDn58eZM2fw8vIiISGhza+rVqt5/PHHee6558jMzMTf39+SvVyn07XpvF5eXpZRc61W22J/e0fjhehvQkJCSElJISQkhMLCQtLS0pgyZYplv06nw8PDw44tFH2d+YJ18+YgcnOH4O9/gWHDaoiNPUJS0kQCA6WEmBCi+5mzlQcHX2TYsHMYDFBV5YS3dwzz51cwfHgvqNOtUqmYNWsWs2bN6sz2CNFntGX6dHtrVa9aBc8913L7DTe8SEHBN5SUeFBWVoZKpcLd3R1FUYiJiSEhIaHNZb3M4uLiWLVqlaVOd15eHhqNps3njYqKIiIigtTUVMLCwpr0kXnUPCYmps2j8UL0NwsWLCAhIYG0tDS2b99OeHg4EyZMsOxPSkpi9OjRdmyh6Ovc3U3ldrKyVJw5M5HTpzdy5oyBb745RXLyMPT6wVJCTAjRrczZyj08GoiO3o9KZUr2mJU1Hp3OlUWLKggK6r72tCnoTk5OpqioiFtuucWy7cMPP+TFF1+kqqqKO+64g7fffhuNRtPpDRWit7Fl+nReXl67pk8rCrQ2mGyq5vciaWn/Q0lJiWWEq6ysrNNqYMfHxxMbG9uh2tpqtZqFCxeyePHiDo+aC9GfLVmyhOrqar788kv8/f354osvmuzfs2cP9957r51aJ/qT4GAIDh7If/4TTWnpYRwdYcKE/ezdeyPr15v+lnd1LVwhhABztnKIiTmCs7OpfG5FhS9lZcOprVUoLOze9rQp6H755ZeZPn26Jeg+evQoDz30EA888AARERG8/vrrDBkyhJdeeqkr2ipEr9JV06fT0sDaoNVzz8HKleZH6naPnttKrb70GkajsV0BeHx8fKeMmgvRn6nVal5++WVefvllq/ubB+FCdKWsLNiwYRQTJ57D07MUR8cywsPTycgYbSkhJlPNRVssX76csrIyPDw8ePHFF+3dHNFLBAaCj08Rfn4nAFAUNWfPTqK6WoWLi8Lgwd3bnjYF3YcPH+aVV16xPP7000+ZPHkyf//73wEICgrixRdflKBbCLpm+vT998NHH7Xcfu5c961JaS4pKckSNJtKlmmIiIhg4cKFNgXNnTFqLoQQomfIyYGaGjXnzsUybtxmQGHIkDTy8wPJyfEkJ0eCbtE2f//738nNzWXo0KESdAubZGVBVpaR667bh3lCaU5ONPn5blRUwP/8jzkfUvdpU9BdUlKCn5+f5fHOnTu56aabLI+vvvpqsrOzO691QvQi1kZ7O2v6dF0dtLZqo1kS8U5h7b1YY87OXlxcTEBAgOX9mbOzr1q1yqbAu/GouRBCiN7LXEKssNCLixcjCAhIR6UyEhKyj4sXZ6HTqWS0WwjRJcrLTcnTNm+GgIAMRo0qw9kZyso8OXYsHI3GlK381VdNU8+7U5uCbj8/P86ePUtQUBB1dXUcOnSI5cuXW/ZXVFTg5OTU6Y0Uoqe73GhvR6dPf/cdzJnTcvsHH8D8+d33XhISEggLC7Mc113Z2YUQQvQewcGmEmLr10NGxmg8PLJxcqrA2bmYQYNO8OST4bi4IInVhBCdzpyt3Ne3nIiIYyiKaeBq4MBJfPaZ2lJJwWjs4UH3zTffzNKlS3nttdf4+uuvGTBgANdee61l/5EjR5pclAvRH9gy2vvRRx+1a/p0WBicOdNye0UFWFkmDrR/ffWV3suSJUt49dVX8fX1BbonO7sQQoje51IJMQdSUiYTE/MDAOPGHSEtbSjFxW6sX286RhKrCSE6gzlbuZubwpgx+3FwMAKQnR3O6dODePFF+86waVPQ/corr3DXXXcxbdo0tFotH3zwAc7Ozpb97733npQQE/1KW0Z72xJ4Xqq93dS118KuXa0/ryPrq6/0Xs6ePcvGjRu59tprUavVXZqdXQghRO91qYQYHDzow9q1VxESchJHRwMjR+7n+PEZgEoSqwkhOo05W3lU1Cnc3AoA0OsHkpcXTW0tds8n0aage/DgwezatYuysjK0Wi0ODg5N9n/xxRdWszQL0Vd1xWjvm2/CokUtt+/eDVOmtP68jq6vvtJ78fPzIzs7m/T0dMaMGdNl2dmFEO1jMBhYt24d27ZtIz8/H6PR2GT/9u3b7dQy0V8FB5sudE+cGMvQoTk4Olbj5paPj08m9fUjKCqy/4WwEKJvCAwEL68Khg49bNl29uxkKisdcXEx7benNgXdZua6v815e3t3qDFC9DadOdp7pdrbl5sh3hnrq215L/X19Zb30hXZ2YUQ7ffUU0+xbt065syZw+jRo1vcPBPCHgIDwcnJkbS0SUyYsAOA4OBUsrOH4OIywO4XwkKIvkFRFKZO3UdVlYGGBigoGEFOjh8VFabkafa+udeuoFsIYdJZo73p6WAtNn3mGVi9+srt6IwRd1vei1artbwXtVrdadnZhRAd9+mnn/L5559z880327spQlhcSqwWgJ9fKEOHnsVobCA0dB9eXtPJyVFZjhNCiLYyZyw/duwUYWEFGI1QWjqAlJTxlmzl5jwT9iRXw0J0gHm0V6fToTSr3WUe7Y2MjLzsaO+CBdYD7rNnbQu4wbZRar1ef9kR9yu9l7y8PIKCgoiMjLRsj4+PZ9WqVYwfP57S0lLOnTtHaWkpMTExNpcLE0J0DmdnZ0aMGGHvZgjRwooVpgvfU6diqKhwRVFgyBAdZ85k8otfwIwZkJBgungWQoi2WLYMNm2qICzsMM7OphK7R4/GcvXVjmzfbsov0ROqJMhItxAd0JHR3vp6aJSHsIm21t7ujBH3K70Xb29v5syZ0+K9xMfHExsb2+6M6UKIzvHss8/y17/+lTVr1sjUctGjXEqs5kxa2iR+/HEnBQVw1VWp1NUFUFIyULKZi1ZNmzaNwsJCBg8ebO+miB7GlLFcYcKEfWg0BgCKi0dgMPhx5IidG9eMBN1CNNPWklvm0d621OL+/nu46aaW53rvPXjwwba3ubPWV1/uvTz++OOtlgRUq9VSFkwIO9u9ezc//vgjmzZtIioqCicnpyb7v/zySzu1TAgT0xTyISQmDicg4AyOjg1cddVeyWYuLuvjjz+2dxNED5WTA76+Jxk06FK28uzs8QwYQI9L1ChBtxCNtLfkVltGe6+6Ck6danmO8nJwc2tfuztzfXVr7wUgPz+/fQ0UQnQ5T09P7rzzTns3Q4jLysmBo0dj8PHRWbKZ+/mdpL5+VI+7SBZC9Gze3hWEh/+EwQCOjqZs5UajI9XV9IiM5Y1J0C3EzzpacutKo71FRWBtZlRcHCQldbz97Rlxb42199K8/JAQomd5//337d0EIa7IlM3ciWPHYpk40VTGLijoJ7KzA3Bxce9RF8lCiJ7r/HmFffv2MniwgYICyM0dSXGxH9XV9JiM5Y1J0C0EnVNy63Jmz4YtW1pu37ULrr22o62/RNZXCyGE6MkuZTP3w8dnJMHBpzAYDAwfvhe1+gZA8hEIIVpnzlaekZHBsGGFqNWgKAM5eXIctbWmEe6ekrG8MQm6haBzSm5Zc7na2w0N4ODQkVZbJ+urhei//t//+398/vnnZGVlUVdX12TfoUOH7NQqIZoyXwxv3ToOd/eLODtX4u5eRGZmBjNmRDJ7tumYnpBxWNjfjBkzyMvLw8/Pj+3bt9u7OcLOli2DLVtKmDr1KE5OYDDA3r1xxMc78uijptk0PWmE20yGv4Sgc0puNbdtm/WA+ze/MQXj7Qm4jUYjR48eZdeuXRw9elSmfAshLN566y0efPBB/Pz8SE1NZdKkSQwaNIgzZ85wk7XMjULYiTmb+Q8/OKJWx6JWm8r8jB59FK22lPXrTRfWQgCcPHmS9PR0Tp48ae+mCDvLyoKtWw1cfXUSzs5GVCooKIjEYPAhKannBtwgI91CAC1LbimKQkVFBfX19Tg5OaFSqa5Ycqux1qr1JCdDbGz72tjeJG9CiP7hnXfe4W9/+xv33nsv69atY8mSJQwfPpwXXniB4uJiezdPCKv27/chLCyc4cOPA0bGjdtDcvKNbN7sIJnMhRBN5OSYckC4u5cDUF3tSW5udI/MVt6cjHQLwaWSWzqdjqKiIlJTUzl8+DBHjx7l8OHDHDp0CB8fnyuW3KqtbT3gVpSOBdyLFy/m0KFDeHp6MmzYMDw9PS1J3pI6IxObEKJXy8rKstyAc3V1paKiAoD777+ff//73/ZsmhBW5eSYvjfz8sZQU+MBgKtrOeHhh6mtNe0XQggwjXKfPatj2LATGAygKGrOnIlHUdQ9Mlt5cxJ0C8GlkluOjo6kpqZSUlKCg4MDzs7O1NfXU19fz8WLF9m7d2+r55g3D6zNTr/3XlPA3V7Nk7xptVocHBwsSd5KSkpITEyUqeZC9HP+/v6WEe3g4GDL36uzZ8+idOSPkBBdJDDQdKFcVeVAZuYUFMV0WerrexJf34vodKYLbSFE/1VeDgkJMGtWHRs37qO+3nSz7vjxsZSXe1BWZspWPnt2zx3lBgm6hbCIjY0lICAAJycnHB0dqa+vp6GhAS8vL2JiYmhoaGg1uFWp4OOPW57z4kX45JOOtastSd6EEP3XjBkz+OabbwB48MEHeeaZZ7jhhhu4++67pX636JHMmcwrKkCn8+Ds2XGWC+qRI/fy7LO1zJhhuuAuL7d3a4UQ9rBsGaxfD1dddRB392qcnSE/35fU1FEUFZkGtnpitvLmZE23ED9LS0ujoKCAmJgYFEWxrOd2c3NDpVLh7OzcIoN5RgZERlo/X2cNLNmS5C0vL69NSd6EEH3P3/72N8tNwYSEBAYNGkRSUhK33XYbjzzyiJ1bJ4R15gvlzZshLe0qVKqL+PhcxM2tlquv3k9q6rWsX2+64ZyYaMeGCiG6XVaW6W9DWNh5hg49D4Ba7URubhyenirefBMmTuzZI9xmMtItxM/Mwe2AAQNwd3dn0KBBuLu7W0aXm2cwV6msB9wLF3ZewA1Nk7xZU1NT06Ykb0KIvkmtVuPoeOle+j333MNbb73FE088gbOzc5vOtWLFCq6++mrc3Nzw9fXljjvu4MSJE02Oqa2ttQT3Wq2WuXPnkpeX1+SYrKws5syZw4ABA/D19eW5556joaGhyTE7duwgJiYGjUbDiBEjWLduXdveuOjVzJnMt2+Ht95SkZk5GQcHDU5OMGhQLiNGZOLmZrrwlqnmQvQvOTmgUlUSGbnfsu38+Yk4OAzAYAB//94RcIME3UJYtCW4bS1ZWm0tvP1257arcZK35usyFUVBp9MRGRl5xSRvQoi+77///S/z5s0jLi6O3NxcAP71r3+xe/fuNp1n586dJCQksHfvXrZu3Up9fT2zZs2iqqrKcswzzzzDt99+yxdffMHOnTu5cOECd911l2W/wWBgzpw51NXVkZSUxAcffMC6det44YUXLMecPXuWOXPmcN1113H48GGefvppfv3rX7N58+YO9oTobYKDTRfQNTWunDs3qdH2Q3h7l0tiNSH6oSFDjMTE7AFMN2uLioZRVDSsVyROa06CbiF+Zktw6+r6a8aMibb6fEUx1RntbOYkb15eXmRmZlJZWYnBYKCyspLMzEy8vLxISEhAba0ouBCi31i/fj2zZ8/G1dWV1NRU9Ho9AGVlZfzpT39q07m+//57HnjgAaKiohg7dizr1q0jKyuLlJQUyzn/+c9/snr1ambMmMGECRN4//33SUpKsiRw27JlC+np6Xz00UeMGzeOm266iVdeeYXExETq6uoAWLt2LaGhobzxxhuWEoj/8z//w5tvvtmJPSN6C3NitdzcQAoKwgBQqw2Ehibj6GiUxGpC9CNZWXDw4BFCQoppaICKCi2nTk3sNYnTmpOrdCF+dqXg9vjxDJKTE1o876uvOnc6uTXx8fGsWrWK8ePHU1payrlz5ygtLSUmJoZVq1ZJnW4hBK+++ipr167l73//O05OTpbtU6ZM4dChQx06d1lZGQDe3t4ApKSkUF9fz8yZMy3HhIeHExwcTHJyMgDJyclER0fj5+dnOWb27NmUl5dbEj8mJyc3OYf5GPM5RP/SOLHa0aMxVFe7UV8PTk7FDB16mCefRBKr9UMvvPACb7zxRpNZMqLvMmcrnztXx3ffZVBcDE5OKo4ejaegwKnXJE5rThKpCdGIObhds2YNGRkZ5OXl4eSk5fjxDKvHd2cVnvj4eGJjY0lLS6OkpAQvLy+ioqJaHeE2Go02HyuE6P1OnDjB1KlTW2z38PCgtLS03ec1Go08/fTTTJkyhdGjRwOg0+lwdnbG09OzybF+fn7odDrLMY0DbvN+877LHVNeXk5NTY3VBJJ6vd4yig9Q/nP0ZTQaO1w60Wg0oiiKlGC0QVf11R//aMqZsmWLmoMHY4mJ+QEwEhl5HGdnXy5cGMJXX5mOeeutTn3pLiWfrbZp3F+//vWvm2wXLfWlz9fvfgcbN9YyfXoSGo2CwQDHjo1l3DgvfvMbI4GBEBRkOra9b7cz+8vWc0jQLfoFawFoaxoHt2vXDuCdd8JaHOPtDUVFXdli69RqtSVz+uUkJSVZbhzo9Xo0Go1l6qaMigvRN/n7+3P69GmGDRvWZPvu3bsZPnx4u8+bkJDAsWPH2rwuvKusWLGC5cuXt9heUFBAbW1th85tNBopKytDURS5SXkFXdlXzz8PjzwCp07B+vXD8PPLwMEBxo/fydCh8VRUuJKVBWlp4OPTqS/dZeSz1TbSX23TV/qroACyshRmz07B3d00w6q2djA+Pl6UlOTj7m5aypmf37HX6cz+qqiosOk4CbpFn9daAJqQkEBYWMuAGkzBbWtrtzMzoQPXr10uKSmJxYsXU1xcTEBAAK6urtTU1JCamsrixYtlOroQfdTDDz/MU089xXvvvYdKpeLChQskJyezePFi/vCHP7TrnAsXLmTDhg3s2rWLwEYZa/z9/amrq6O0tLTJaHdeXh7+/v6WY/bv39/kfObs5o2PaZ7xPC8vD3d391bLJC5btoxFixZZHpeXlxMUFISPjw/u7u7tep9mRqMRlUqFj49Pr75w7Q5d3Ve+vqZppv/9rw9xcXoGDTIlBlSpTpGVNYOiIjXl5dBbcojKZ6ttpL/apq/0V2YmFBefYOjQcqqqNNTXa0hLm0FNjStFRXTa73xn9peLi4tNx0nQLfq0pKQknn32WXQ6HZ6engwaNAgHBwdSU1NZsmQJr776Kr6+vk2eU1JiGsm2pjunk7eH0WhkzZo1FBcXM2LECEu5M61WS1hYGJmZmSQmJhIbG9ur/ygLIVpaunQpRqOR66+/nurqaqZOnYpGo2Hx4sU88cQTbTqXoig88cQTfPXVV+zYsYPQ0NAm+ydMmICTkxPbtm1j7ty5gGl6e1ZWFnFxcQDExcXxxz/+kfz8fMvf2a1bt+Lu7k7kz/UW4+Li+O6775qce+vWrZZzWKPRaNBYyVqpVqs75e+aSqXqtHP1dV3dV0FB4OwMR47EER+/CWfnarTaInx80qmoGENQEPSmH5N8ttrG3F95eXkYDAYcHBwICAiwd7N6rN7++crKgqysIq666ggNDSocHeHMmXjq6gZSWWn6W9CZv/Od1V+2Pr93/lSEsIHRaOSll14iLS2NoqIiTp8+zZEjRzh16hTe3t6UlpaycePGJmsxEhOtB9xvv93zA26AtLQ0MjIyCAgIsATcZiqVCn9/f9LT0y1JjIQQfYdKpeL3v/89xcXFHDt2jL1791JQUMArr7zS5nMlJCTw0Ucf8cknn+Dm5oZOp0On01lKKnp4ePDQQw+xaNEifvzxR1JSUnjwwQeJi4sjNjYWgFmzZhEZGcn999/PTz/9xObNm3n++edJSEiwBM2PPvooZ86cYcmSJRw/fpx33nmHzz//nGeeeabzOkb0WubEaiUlzhw+HI/RqKKhAYYOTWP6dB05OZLNvD+4+uqrCQoK4uqrr7Z3U0QXMCdOmzWrjm+/3U1Dg5HaWjhzJpzCwoBem628ORnpFn3Wxx9/zJ49ezAajU1GRUpLS8nIyCA0NJTs7GzS09MZM2ZMq7W39XrT3bXeoKSkBL1e3+q0TFdXV/Ly8igpKenmlgkhuouzs7NlJLm93n33XQCmT5/eZPv777/PAw88AMCbb76JWq1m7ty56PV6Zs+ezTvvvGM51sHBgQ0bNvDYY48RFxfHwIEDWbBgAS+//LLlmNDQUDZu3MgzzzzDX//6VwIDA/nHP/7B7NmzO9R+0XeYMxRv3uxDevoYRo36CWdnqKlJZt68m1CrXZg923RcB1cXCCHsYNkyWL9eIT4+GXf3ahoa4MKFQezbNxat1lRGsDdmK2+uRwfdK1as4Msvv+T48eO4uroSHx/Pa6+9xqhRoyzH1NbW8uyzz/Lpp582+dJvng1V9C9Go5EPPviAuro6HBwcqKystOxzdHSkpqaGvLw8QkJCOHKklrFjW57jsceg0fVjr+Dl5YVGo6GmpgatVttif01NDRqNBi8vLzu0TgjRFX71q1/ZdNx7771n8zkVG6b2uLi4kJiYSGJiYqvHhISEtJg+3tz06dNJTU21uW2if3F3N81Cy8qC7OwIPv88j/JyHRpNLZMn7+HgwRmsX2+6a36Zj6IQogfKyoLNmyEyMgM/vwsAqFTOZGVdg4eHmjffhIkTe/cIt1mPnl6+c+dOEhIS2Lt3L1u3bqW+vp5Zs2ZRVVVlOeaZZ57h22+/5YsvvmDnzp1cuHCBu+66y46tFj1BWloap06dwmg0Ul9fb1mzoVaraWhooKGhgZKSElJTH+H++ye1eP6pU70v4AaIiooiIiICnU7X4qJZURR0Oh2RkZGXzd4uhOhd1q1bx48//khpaSklJSWt/hOiNwsOhqAgFVu2xGEwuOLoCJ6e+URFHcHNzXThLlPNhehdcnLA1TWfkSOPWLadOROHg8MADAbw9+8bATf08JHu77//vsnjdevW4evrS0pKClOnTqWsrIx//vOffPLJJ8yYMQMwTX2LiIhg7969lnVlov8pKiqipKQElUrVIvhUq9UYDI5UV1dx7lzL5/aGtdutUavVLFy4kMWLF5OZmYm/v78le7lOp8PLy4uEhIRem2RDCNHSY489xr///W/Onj3Lgw8+yLx58/BuLRukEL1YTg5UVLhw5kw80dHbAYWAgHRKSwdx+nQgOTl95wJdiL4uKwtyc2sZOzYJo1FBrYYLF6IoKxtCdbVpWnmjohm9Xo8OupsrKzPVazNfTKSkpFBfX8/MmTMtx4SHhxMcHExycnKrQbder0ev11sel5eXA6Ypyb29qHxnFnvvzYqKijAYDLi4uFBbW4vBYLDsU5QnUZQ3WzwnMdHIo49Cb++62NhYXn/9dd555x2OHz9OQUEBGo2GCRMm8NhjjxEbG9uuz4d8tmwnfWU76Ss6/N4TExNZvXo1X375Je+99x7Lli1jzpw5PPTQQ8yaNatFUkUheqvAQNOFeF6eL56e4wgKMi1LCA3di043G53OjawsCbyF6MnKy03ruDdvVhg9Ogl39xpqa6G62pdz56KprjYlTps7t2/9LveaoNtoNPL0008zZcoURo8eDYBOp8PZ2blJjVAAPz8/dDpdq+dasWIFy5cvb7G9oKCA2traTm13d+vMYu+9mbu7OzExMej1+iaj3QcO7Ld6/PHjeXh4KOTnWz+f0WgkKyuLyspKtFotwcHBPbp/w8LCeP311622Ob+1N3kF8tmynfSV7aSvoKKiosPn0Gg03Hvvvdx7772cP3+edevW8fjjj9PQ0EBaWprVHA9C9DbmbObr18OJE6NwdS3EwyObhoZ6wsN38/TTN+Ds7CiJ1YTowUyJ0yA6+ij+/nk0NEBZmQv//e8UnJ1VfSZxWnO9JuhOSEjg2LFj7N69u8PnWrZsGYsWLbI8Li8vJygoCB8fH9x7+V/oziz23pv5+Phw5MgRqqqqfq7DF0hd3Vmrx9bXN6BW+7R6ruTkZMuosV6vR6PREB4ezuOPP37ZWrI9gb+/f6edSz5btpO+sp30lSkhWWdSq9WWm42NZ/kI0RdcymauYv/+yUyYUMrAgRUMHlzKxIkHOXp0siRWE6KHMidOGzYshxEjTOVrnZzg7NkpuLq69KnEac31iqB74cKFbNiwgV27dhHYaHK/v78/dXV1lJaWNhntzsvLu2ywodFompSQMuvNBeUb66xi772ZuQ8cHR2pq9tNQ8PEFscMGLCMH364DbV6cqt9lZSUxHPPPUdxcTEBAQGW9dGHDh3iueeeY9WqVcTHx3f12+kx5LNlO+kr2/X3vuqM963X6y3Ty3fv3s0tt9zCmjVruPHGG/ttv4q+qXE284MHnXj++WuJjd2Ck1MDfn5nqakZzOnTIyyJ1frixbsQvdXBg9DQUE5UVLJlW07OWOrrfftc4rTmevQ3saIoLFy4kK+++ort27cTGhraZP+ECRNwcnJi27Ztlm0nTpwgKyurx49Aiq5VVlaGh4cHen0titIy4Pbw8MXP77MmmfCbMxqNrFmzhuLiYkaMGIFWq8XBwQGtVktYWBglJSUkJib267WoQgj7e/zxxwkICODPf/4zt9xyC9nZ2XzxxRfcfPPNEnCLPis42HSBXl7uwblzl6qQhISk4OtbRGUlbNokGc2F6AnKyyEhARYvric6ehe1tQ3U1EBRURAXL0b0ycRpzfXoke6EhAQ++eQT/vOf/+Dm5mZZp+3h4YGrqyseHh489NBDLFq0CG9vb9zd3XniiSeIi4uTzOX93NmzQzl//pzVfUOGDMXPLxCVSnXZdY5paWlkZGQQEBDQIhGRSqXC39+f9PR00tLSiI6O7szmCyGEzdauXUtwcDDDhw9n586d7Ny50+pxX375ZTe3TIiuZU6slp0dgqdnIX5+J1GpjAwd+l+OHJnNiy+68vrryBrvXm7btm00NDTg6NijwxZxGaZ13Apxccl4eFRQXw8FBR4cPBiLu7uqTyZOa65Hf3rfffddAKZPn95k+/vvv88DDzwAwJtvvolarWbu3Lno9Xpmz57NO72xwLLoEKPRSFpaGiUlJVx//TU0NIS1OCYyMoHBg4+h1Y7jzJkzTJgwgeDL/HaXlJSg1+txdXW1ut/V1ZW8vDypfyuEsKv58+dLhnLRLzVOrHbs2HhcXEpwdCzAyamG6dP/S3b29VRVObB+vel4WePdO40aNcreTRAdYF7HPXp0Gv7+uQDU1zuTlHQtFRWOfTZxWnM9OuhuXl/ZGhcXFxITE0mUv6T9VlJSEmvWrCEt7RRHjhywesz06df9vB5bzZkzZ/D09GT27Nmkp6dTWFjI6NGjW0zD9PLyQqPRUFNTY3VEvKamBo1Gg5eXV5e8LyGEsMW6devs3QQh7OZSYjU1u3dfw8SJm9FqqwkMLMLF5QBnz04GVLLGWwg7yckBrTaXESOOWrbpdPH4+7vh6Ahvvgl33WXHBnaTHh10C3ElSUlJLF68mJyckWRntwy4x449S2Tk78nIKCUvLw+NRkNQUBAAf/nLXwgJCeH8+fOMGjWKhQsXNkmKFhUVRUREBKmpqYSFhTUZSVIUBZ1OR0xMDFFRUV3/RoUQQgjRQuPEaps2ufDGG9cyffoPgIHBg89SXe1Fff0oiopMF/8SdAvRfbKyIDu7nLFjkzEYwNHRlDitrCyAhgbw8DBlK+8PJMOK6LXMic4OHfob2dkftNgfFjadqKjn+fDDD/nwww9Zu3YtixYtoqKigqysLDw8PPDz88PDw4PU1FQWL15MUlKS5flqtZqFCxfi5eVFZmYmlZWVGAwGKisryczMxMvLi4SEBElUJIQQQthZcDDcdBMYjd4cOza50fZU1GpTTiBZhdE7ffLJJ/zjH//gk08+sXdThI3MidNmzarjq692oSj11NbChQtBZGVFUFYGFRWm5SH95UaYRAuiVzEajRw9epRdu3bx3nub+Pe/P0GvH93iuFtuuZWgIBXp6elkZGQQHR3NNddcw6ZNmygpKbFkI1er1ZfNRh4fH8+qVasYP348paWlnDt3jtLSUmJiYvpduTAhhBCiJzOv8T5zJoTMzEiMRqiqUhgxYg/19ZXcf78pECgvt3dLRVssWbKEhx9+mCVLlti7KcJGy5bBl18aGT36v3h6VuDsDGVlHvz3v7EUFalQlP6xjrsxmV7eTzRONObl5UVUVFSvG6E1r93OyMggM3MFFRVzWhwzefLz+Pj8BLRMdNbebOTx8fHExsZ2Wf/1hZ+NEEII0RNcWuM9BkUpxdf3Aq6udcyatZMDB2axfr0TIEnVhOgqpsRpCjExB/HxyQdApdJw5sw03NwcefNN05Ty/jLCbSZBdz/QOFjV6/VoNBoiIiJarGHuycxrt4uLizlx4rjVY26++XbU6kuj1M0TnXUkG7lare6SsmB94WcjhBBC9BTmNd7JySruuScOH58tDBxYAZQTE7ObgwensXmzWpKqCdFFcnLAz+8EQUGZACiKmlOnpuLgMBCDAfz9++fvngyn9XHmYPXQoUN4enoybNgwPD09ra5htqbxdO6jR482mXrdXcxrt3NzQ1oNuAMChqBSGSyPzYnOIiMjLYnOGmcjt6a7s5F39GcjhBBCCOsUBQwGZzIzp9HQ4AyAh4eOqKgUamsVcnLs3EAh+qCsLDhz5gLh4akYfr4sP3t2MpWVg6muBhcXCAy0bxvtRYLuPqBxYHzs2DFLYGwOVouLiy1rmB0cHC67hrmxpKQk5s2bx/z583n00UeZP38+8+bN6/ZgMC0tjU8//SdZWf9usS8q6gnc3T0oLi4mLy/vsonOzNnIdTpdi3J01oL0rtTRn40QQgghWhcYaLrALy524/Tpa1EU07XA4MGnCQ09gU5nChCEEB1nTpx2662lbN26h/p6qK2FU6ei0OmG9cvEac3J9PJervn0ZFdXV6677jruvPNO3N3d27WG2Xxe83TugICAn2tc11hGYbsriVh9PYwZY31a9y233AqAm1sk6enplJaWUlRUhIODA1dddRXLli1r0kZzNvLFixeTmZlJQEAARqORyspKLly4gIuLC1OmTCEtLa3T11U3X7dtNBrb/bMRQgghxOWZk6qtXw85Ob6o1ZMIDd2LXg+hoam8+qqW8vJAZs82rQN3d7d3i4XovZYtg2+/rWXatJ24ujbQ0ACZmUEcOhSNm5vpBlh/S5zWnATdvZi1wLi2tpYzZ86wZMkS7rvvvnatYW4+CmsOCs2jsJmZmSQmJhIbG9ulCb/efRcef7zldl/fA0ya9LLlsYuLC76+vvj7+6PT6TAYDOTm5vLOO++gVqubBN7mbORr1qzhxIkT5OXlceHCBWpray3v++9//3unrqu2tm570KBBlJSUEBAQYPU5l1tfLoQQQogru5RUDU6cCKWyspKrrjqGszNMnJjEwYPXs379IEASqwnRXllZsHVrA/HxO9BqqwGoq/PmwoVYPD1V/TZxWnMyvbyXutz0ZH9/f0pLS9m4cSPOzs5tXsPclizfXUWlsh5wz5jxQJOAW1EUzpw5Q2lpKQUFBQQGBhIeHo6Xl1era6Pj4+P56KOPeP/997nllltwdXVFo9EwdOjQTl9X3dq67czMTAoKCtDpdFaf193ry4UQQoi+xpxUbft2eOst0OlGU1YWgpMTODgYiInZxeDBVWzeLFPNhWiPrCz47jsjV121G09P00BRXd0ATp2aiouLY79OnNacBN291JUCYz8/P3JzcxkyZEib1zDbkuVbr9d3ySisTmcKuK2Ji4vnwoV9VFZWWtZunz59mqqqKgYMGNCmtdFqtZrISNO0dL1ez8iRIzt9XfXlboxERkbi4OBAZmZmi/N39/pyIYQQoi8LDjZd+BsMKrKyTEmdAJycapkwYQd6vZ5NmyTwFsJW5jXcM2YorF9/AA+Pi1RXQ0ODEydPTqe+3rXfJ05rToLuXsqWwLiuro5bbrkFLy8vMjMzmwSr1hKNmdkry/e994K12dYrV5qykK5atYrx48dTWlrKuXPnKC0tJSwsDG9vb4YPH97mUfn09HSys7Px9/fvkhH9y90YUavVjBgxgoaGBjIyMmz+2QghhBCi7cyJ1aqqHDh5cip6vRYARSknMnIXy5cbmDHDFEiUl9u5saIJf39/hg4dir+/v72bIn62bJkpX8KwYWmEhZ3BwQHq69Vs2zaV8nIPSZxmhazp7qUaB8ZarbbFfnNgfO211zJu3DjLmuK8vDw0Gg0xMTEkJCRYXbNszvKdmppKWFhYk4DRPAobExPTqaOwrY1u19SYviTBNC08NjbWkpDMw8ODlJQUXn75ZRoaGlAUpUVwe7m10SUlJdTX17erbrctrnRjxN/fn+LiYoYPH05RUZFNPxshhBBCtF3jxGqgIS1tOqGhW3Fw0OPnV4iHxx4OH76G9etNN7tljXfPcfDgQXs3QTSSlWXKkzByZCYjRx4FYOBA2LEjjuxsXwYPNj3u74nTmpOgu5e6UmCcl5fHuHHjLFm4GwerXl5el83O3TzLt7+/vyV7uU6n69RR2L17IS7O+r5mM+ItbYuOjiYpKYnXXnuNQ4cOodPpKCwsxMPDg9DQ0CYj8Jcblffy8sLJyYnS0lIGDhzYYn9HR/RtuTHi5eXFG2+8gVqttulnI4QQQoj2aZxY7fx5N86enc4NN2xj4MAGBg7MZezYAxw+PInNm1VkZckInRDNZWXBpk3g4nKByMgDlu3Z2eNxdg5m0CB46SW46Sb5/WlOrux7KXNgbG3quE6nw9PTs0lgbA5Wp06dSnR09BWDOnOW7+bTuWNiYjqtXJiHh/WA+4cfrAfcZo2Tk/n7++Pt7Y3RaKS0tJT09HTLyPSV1kZHRkYSFBREXl5el9TttrUueHR0dJt+NkIIIYRou8aJ1ZYvB7Xam+zsxjW8zzBq1FEqK5E13kI0cmkNN7z5ZiGjR++mpsZ0bZuXNwqdLpzqatBqJeBujVzd92LWAuOysjKGDx/OypUrOxwYm7N8f/jhh6xdu5YPP/yQf/3rXx0+b329aTq5tTVTigLXX9/6c5snJ3NzcyM0NBQXFxdUKpWlZFpFRcUV10ar1WrmzJljySbe2euqL3djRNZtCyGEEPYRHGwKDLRauHjRnzNnYi37vL3T8PI6yYsvImu8hfiZeQ23VlvKNdfswNnZgMEAp04FkZk5XtZw20Cml/dyzdc5e3p6Mnjw4E5LNmEeIbeF0Wi84hT2v/0NHnmk5XNnz4bvv7/ya1hLTubt7U1ERITlpkNxcTE6nY4JEyZccW10REQEK1euJDEx0eY1723RuC54V5xfCCGEEG3XeI332bMhqFS1+PkdwmCAq69OISdHQ3Z2yM9rwGWNtz098sgjFBcX4+3tzf/93//Zuzn9jnkNt69vBVdf/SOOjvU4OcG5c378979xeHurZA23DSTo7gMaB8ZGo5H8/Pw2Pd+WYPlKkpKSLIGlXq9Ho9EQERHBwoULLYFla8nSzp2DkBDbXqe15GTe3t54eXlRVlZGdnY2v/3tb1mwYIFN7yMuLo64uLgO90Frmt8YkXXbQgghhP01XuP900+jGDKkltGj0xk4EEaNSkatduD8+UBLHW8ZwbOPjRs3kpuby9ChQ+3dlH7HvIa7oaGaCRO24+hYC0BV1SB0uql4eTnIGm4bSdDdS3VGoAy2Bcu2nGPx4sUUFxcTEBBgSbqWmprK4sWL+f3v/8ott1xt9bmXW7ttzeWSk6lUKhwdHfHy8mLixIlt6o+2jOi3R1efXwghhBBtY17jbQ4sXnxxDCEhegYOzAQURozYQ13dVE6eDGDTJgksRP9RXm6aUr55M9TV1TJu3HYMhmoAamo8OHFiOpWVjrKGuw1kqK0XSkpKYt68ecyfP59HH32U+fPnM2/ePJKSktp8HnNCMk9PT4YNG4anp6clWLblfM3XWGu1WhwcHNBqtYSFhXHgwHqrAfeKFW0PuMH25GSdWc5MCCGEEH3XpTXeKo4du5qiItP0O5XKSHDwf1Gr82WNt+hXzGu4HR3rmDbtRzw9KzAYID9fy7Fj11Fc7CxruNtIgu5e5kqBcnJysk3nuVKwXFJSQmJiIkaj8bLnsbbG2mzjxg00NAS0eE5NDSxdavt7bkySkwkhhBCis5nXeFdUqDh8OJbCwkCqqkBRDFx33U7CwgpRqUyByLJl9m6tEF3HvIbb07Oeq6/eiVZbysCBUF/vyg8/zCA31xVFkTXcbSWRSS9iS6D87rvvXjFQhssHyyqVCn9/f9LT00lLS7vseaytsc7Ovp4NG761eryigIuLDW/2MrqjnJkQQggh+pcVK0yBhNGoZvfuKeTmBuDgAO7uDURF7SAgoAQ3NyxrvIXoiw4ehMrKesaN24FWWwhAQ4MzWVnX4eo6kJdeMpXdS0w0LdEQtpE13b2ILYFyRkYGWVlZV8xe3lpCMjNXV1fy8vIsNa9b03yNdWvB9ssv5/CHPwRe9lxtIcnJhBBCCNGZmq7xVrN8+bX4+u4A8nFwqGfUqB+pr5/B2bOessZb9DnmddybNtUzduwOHBwKqakBR0dnTp6cQVGRh6zh7gCJUHoRWwJlvV5PZWXlFc/VOFi2pqamBo1Gg5eXl9X9RqORo0ePUlRUREBAABcuFLQacN977338/vdDrtimtjInJ5s6dSrR0dEScAshhBCiw8xrvAcMcODQoWlUVg4CwNFRz7Bh2zAYSmSNt+hzli2Dr79uYMKEnQQEmEa4q6qc2b59Bhcveska7g6SKKUXsTVQbp7V25qOJCRrnMjt8ccfZ+/eOzl58pjV14mNjWPhQlljLYQQvcmuXbu49dZbGTJkCCqViq+//rrJfkVReOGFFywVK2bOnMmpU6eaHFNcXMx9992Hu7s7np6ePPTQQy1uCh85coRrr70WFxcXgoKCWLlyZVe/NSFsYl7jXVbmyIED06mo8KaqCtTqOmbO3M7w4cWyxlv0GVlZsHVrA/HxOxg8uADT+J4zO3deR1aWF3V1soa7oyQS6kVsCZQjIiIIvsItKHO5sWuuuQZnZ2dOnz5tc0Ky5oncMjLSKSl5uMVrODlNw9PTy6YbAEIIIXqWqqoqxo4dS2JiotX9K1eu5K233mLt2rXs27ePgQMHMnv2bGpray3H3HfffaSlpbF161Y2bNjArl27+M1vfmPZX15ezqxZswgJCSElJYXXX3+dl156ib/97W9d/v6EsIV5jXdDgzM7dlxHfv4gHBzA07OO0aO3M2RIkazxFr1eVhZ8910DERE7GDSoAACDwYns7OsYNMgbLy94801Zw91Rsqbbjtpaa9ucuXvx4sVkZmbi7+9vqYmt0+nw8vLiscceu+w5mtflbmhoQK/Xk5ubi6OjIxqNhpiYGBISElokJGucyG3o0Fi2b19n9TXGjh2Hm5sbDg5jycnJYfHixZLgTAghepGbbrqJm266yeo+RVH4y1/+wvPPP8/tt98OwIcffoifnx9ff/0199xzDxkZGXz//fccOHCAiRMnAvD2229z8803s2rVKoYMGcLHH39MXV0d7733Hs7OzkRFRXH48GFWr17dJDgXwl6arvF25uWXr2PatB1AoWWNd03NdM6eHczBgzLttqvce++9lmtl0XnMa7i3basjPHwnWm0h1dWg0Thx8uR1VFd709AAHh7w859x0QESdNtJ8+BXo9EQERHBwoULLxucmjN3m5+bl5fXJFCOjY0lPz+/1ddcvHgxxcXFlimBNTU1XLx4EY1GwyOPPMK1117bavBvTuR2/vx2TpxouUZbrf4KrfYBPDzG4f7zrTCtVktmZiaJiYnExsbKNHMhhOjlzp49i06nY+bMmZZtHh4eTJ48meTkZO655x6Sk5Px9PS0BNwAM2fORK1Ws2/fPu68806Sk5OZOnUqzs7OlmNmz57Na6+9dtkLbL1ej16vtzwu/3lBrdFotKl6x+UYjUYURenwefqD/tRXgYFw443wxhsOpKZOY8KEXbi55VNfX8fw4dvJzp7Gs8/6sH07vPqq9dHA/tRfnaFxf7322mtNtouW2vP5+t3vYOPGWuLjd+LhUUJ1NdTUOPHf/5pmq1ZXG6mqgrvuMv0O9KWu78zfR1vPIUG3HbQW/JprbV9pVPhymbtb+8E3Lzdmzn6u1WoZMWIEmZmZ7Nmzh0cffbTVwLikpITDh1Ot7nNzG4qTUy11dUbq6+st25uXH4uOjra1m4QQQvRAOp0OAD8/vybb/fz8LPt0Oh2+vr5N9js6OuLt7d3kmNDQ0BbnMO9rLehesWIFy5cvb7G9oKCgyfT29jAajZSVlaEoitwkvoL+1lcaDfzyl5CUBJWVEWg01QwYUISrq565czdTWDiekyd9+Mtf4NFHWz6/v/VXR0l/tU1b+qugAE6dguzsGm655SCurqZcGy4uzqSnj8XPz4C7ez4uLhATA/PnQyvjeb1WZ36+KioqbDpOgu5udrngNywszOZRYXPmblu1pS63tfN+/z3cdNNUq+eOi4vn6NFyFMUJtVqNk5NTk/22lh8TQgghrmTZsmUsWrTI8ri8vJygoCB8fHwss6zay2g0olKp8PHxkQv9K+iPffX001BYCBs3wsWLN3Httf8lMFCHiwt4eaWRkxPLBx8EM2YMTJgAQUGXntsf+6sjpL/axpb+Ki+H55+HLVugvr6CceP2UVlZj8Ggob5+ACdOTKey0p28PHjxRdPsjsaf4b6kMz9fLi4uNh0nQXc362jw214dqcvdrJkWY8a8RXDwVsrLnVCpVNTW1uLl5YWbm1uT465UfkwIIUTv4e/vD0BeXh4BAQGW7Xl5eYwbN85yTPOlTg0NDRQXF1ue7+/vT15eXpNjzI/Nx1ij0WjQaDQttqvV6k65OFepVJ12rr6uv/WVpyesWWMqFfbII2pyc6cxaFASLi45gEJYWDKFhfU88shIPDxM2c9XrLg03by/9VdHSX+1zZX66/e/N2Xb9/MrIz7+R+rra6ivV1FdrSUnZwZ1dQOprIQBA/pHLe7O+nzZ+nz5FHczW2ttd/aocHvqctfXtx5wa7XuODisw2AwWG4eKIpCSEhIk5sJVyo/JoQQoncJDQ3F39+fbdu2WbaVl5ezb98+4uLiAIiLi6O0tJSUlBTLMdu3b8doNDJ58mTLMbt27WqyJGnr1q2MGjVKbtKKHm3iRFNyqfp6B06fvoaCgjBqaqChASZMOEhMzDFUKkXKiXWS8PBw3N3dCQ8Pt3dTeq2sLFOW/aFDC5g06QdcXWtwcoKyMnc2bZpJSclAysqQWtxdSILubtae4LcztLUu97Jl0Ci3TRPjx8egUsGJEydIT0+nrKyM2NhYRowYQUlJic3lx4QQQvRMlZWVHD58mMOHDwOm5GmHDx8mKysLlUrF008/zauvvso333zD0aNHmT9/PkOGDOGOO+4AICIightvvJGHH36Y/fv3s2fPHhYuXMg999zDkCGmRJy//OUvcXZ25qGHHiItLY3PPvuMv/71r02mjgvRE5lreFdUQFmZirS0qzlyJBIAJycYPvwo0dGHcHNTpJxYJ6isrKSiooLKykp7N6VXMmXfh4EDs5kw4UccHesAMBi8SUmZSU2NK0VFoChSi7sryfTybmYOflNTUwkLC7M6KhwTE9Ppo8K2lBszB8atjW5Pn/4oWm0uMJSAgADS09MZMWIEq1atIjo6mr1797aaVV3KhQkhRO9x8OBBrrvuOstjcyC8YMEC1q1bx5IlS6iqquI3v/kNpaWlXHPNNXz//fdN1rZ9/PHHLFy4kOuvvx61Ws3cuXN56623LPs9PDzYsmULCQkJTJgwgcGDB/PCCy9IuTDRK5gDk82bobBQRUnJWBwdnZkw4TAAfn4nUatrSUqKZdMmB2680ZSMTYjuYi4JtnkzDBp0ktGjU6ithYEDobzcj9Onr0WrdcLZ2VSHe+JEGeHuSiql+bBnP1ReXo6HhwdlZWUdTsJiC3P28pKSEqvBb0dqWhuNRvLz8/H19bU6smytVFlkZCQJCQmEhMQTGGj9vLfccmuLbZWVlZSWlvLhhx9a1p+3tfa4PV2pr0RT0l+2k76ynfRV938H9TWd2X/yebSd9JVJVhYcPAjPPGOaIRgWdobQ0P2AQlUV5OUNJiPjWlxcnPnlL/N5+mlfPD37b3/ZqvHnKzg4mNzcXIYOHUpOTo69m9YjWft9TEiA9esVxo49TGjocaqrwWCACxeGUVIymaoqNRUVptHtxEQ7v4Fu1pl/v2z9DpKRbju4Uq3trhwVbq3cWESEmpMnWx6v1f7AtdeuBhxa7LOWfK2tWdWFEEIIIXqr4GDTv23bTEmqMjOHU1urYejQJKABP79CAgK2cPjwVJKSTNnP16yxd6tFX2a+EbRxo4HJk/cyZIhpfcPAgZCaGklKyhgGD1YxcKBMJ+9OEnTbyeVqbXe15oFxa9PJk5LSePzx56ip8USr1bbYL1nJhRBCCCGaTjc/fnwoaWkzue66nbi71wBVTJr0A2VlEWzc6MuMGTKVV3S+6mp48klTmd+amlqionbj5VVg2X/+/ERqakYyaBC89FL/yFDek8j8FjsyB79Tp04lOjq626dnffJJ6wG3osDkyRFtSr4mhBBCCNEfububpuhu3w7Ll4ODgxdnz86iutoTAAeHOnx9D+LoeJZHHjGVHUtIMK27FaIzfPghfPklaLWlzJy5GR+fAurroarKgVOnppKfP5LqatBqJeC2Bwm6+ymVCu67r+X2tWtNATdcSr7m5eVFZmamZCUXQgghhLiM4GBTQKPVQmnpADIyZlJWFkBtLT+XzNvH1VenolYbpaSY6BRZWfD113DgAISG5jB58lYGDKjGyQlqalzZvPl6cnOHSkkwO5NoqZ9paGh9dNtohEceabrNvP58/PjxlJaWcu7cOUpLS4mJibEp4ZvRaOTo0aPs2rWLo0ePYjQaO+mdCCGEEEL0PI1LipWUOHH48FSOHx+BophKioWEHOfqq3fg5aVnwwbT6KSUFRNtVV5umi0xYwY89piCs/NpRo7cjVrdAJhKgu3fP4uiokFSEqwHkDXd/cgf/gCvvmp93+Vy2Ld3/bm1TOkREREsXLhQSogJIYQQos9qvMa7oEDN6dMTCAxUGDToDADu7nlER3/P9u1TeeQRLzw8TIH6ihWmqepCXMmyZabkfR4eDVxzTTL+/qcpLTXVpauuDuHs2cm4ujowdKiUBOsJJOjuJ1ob3d6xA6ZNu/Lz25qV3FwWrbi4mICAAEtZtNTUVBYvXtyhsmhCCCGEED2ZeY23OZP0s8+qqKsL4eTJEMLCkqiv1+PkVM3MmVu5cGEyFy+GsH696bn9rXzTlaxdu5aamhpcXV3t3ZQeIznZNKV80KByrr76vwwYUIbDz4WGUlLG0tAQQUODylIS7K677NpcgQTdfd7FizBkiPV9XVWh3Wg0smbNGoqLixkxYgSqnyN+rVZLWFgYmZmZJCYmEhsbK+vBhRBCCNFnmUuKbd8OJ09Cbq4vRUU3MmTIf/H2LsbFxUBUVBKDBhWRljaODRvUXH+9jEo2dsstt9i7CT1GeblphPs//wFn5/NER+8HGn5euuDITz9dy/HjQXh7m278yHTynqPPRDyJiYkMGzYMFxcXJk+ezP79++3dJLsbPdp6wH3zzV0XcAOkpaWRkZFBQECAJeA2U6lU+Pv7k56eTlpaWtc1QgghhBCih3j1VYiPN11/XbgwgG3bZqLThWIevPX3P0FExA+UllZKdnPRqmXL4KuvDERFHWDKlCQcHBqor4fCQg/y8+Oorx/K0KGmxMjbt5tmTchyhZ6hTwTdn332GYsWLeLFF1/k0KFDjB07ltmzZ5Ofn9+t7ehJScMcHNRYi2lLS2Hjxq597ZKSEvR6favTgFxdXdHr9ZSUlHRtQ4QQQgghegB3d3j0Udi6Ff7v/yAgwIGsrMmcPz8RRVFTUwNabRGzZ39PeHgWKhV8/jk88IAkWROmz8CXX8K2bZVMnbqV4cNP4/jzfOVz54axadMNFBdrqaiAW24xTSeXmRI9S5+YXr569WoefvhhHnzwQcC09mPjxo289957LF26tFva0FOShm3fDjfc4G91X1eObjfm5eWFRqOhpqYGrVbbYn9NTQ0ajQYvL6/uaZAQQgghRA8QFAQhIbBtG6xfr+LUqZEUFHgzZEgSWm0lAwbUM3r0Hpyc8sjKiuGbbxxISTEFUv01yVpKSgp1dXU4OzszYcIEezenW5mnk2/eDAMHnmfMmAO4uNQDoNE4cOTIBNLShmM0KhgMpmD7T3+yc6OFVb0+6K6rqyMlJYVljQodqtVqZs6cSXJystXn6PV69Hq95XH5z3N3jEZju0ank5OTWbJkCSUlJfj7+1uShv30008899xzrFy5kri4uDaft60cHNRYm7ywZo2Rxx4zlQTrDhEREURGRnL48GG0Wm2TKeaKopCfn8/48eOJiIiw62wAo9GIoihSxsxG0l+2k76ynfQV/fq9C9FfNc5ufu7cII4evZFrr93PiBFZ1NRAQMBpZs0qIClpCgaDR79Osnb77beTm5vL0KFDycnJsXdzupVp/XYdEyYcwM8vi6oqqK+H6motFy9eg1rtRUAAGI0KS5fC1Kkg6ZJ6pl4fdBcWFmIwGPDz82uy3c/Pj+PHj1t9zooVK1i+fHmL7QUFBdTW1rbp9Y1GI1999RW+vr6MHTu2SYAZHh6OTqfjq6++IjQ0tMuShhkMEBhofXT7wgUdKhV080x7fv3rX/Pee+9RVVWFp6cnGo0GvV5vqfH9q1/9isLCwu5tVDNGo5GysjIURZGEbjaQ/rKd9JXtpK+goqLC3k0QQnSz5tnNn3nGiXPn4lEUf3x8UnBwMODhUcbs2d9TXDyGzMxwNmxQSZK1fsL8udizJ48ZM/YycGA1YKrznpkZzMGDkxg2zImGBqithf/5HwgPt3OjxWX1+qC7PZYtW8aiRYssj8vLywkKCsLHxwf3Ns7bOXbsGD/++CMeHh4YDIYW+ysrK/nxxx+ZP38+o0ePtumcRqOR9PR0S03syMjIVi9GP/4Y5s+3vs9gMAK+Nr+XzuTr64uzszPvvPMOP/30U5Mp948++mi3jPxfidFoRKVS4ePj028v9ttC+st20le2k74CFxcXezdBCGEn5uzm5unmx4+HkZo6mPj4Pbi7l+HsbCQ09DDOzjns2hXLI4+4SU3vPsw8nXzrVgMBAT8RFXXCMnJtMDiRk3M1GRkh1NdDUdGlDOWvvmoKvkXP1euD7sGDB+Pg4EBeXl6T7Xl5efj7Wx/91Wg0aDSaFtvVanWbL/pKS0upqanBz88PxcqiaRcXF3Q6HaWlpTad+3Jrw2NjY0lLS7ME42PGWK+b/f33hdxwg7fdL2CnTJlCXFxckzZHRUXZvV2NqVSqdv3c+yvpL9tJX9muv/dVf33fQohLzNPNN2yAsjIPtmyZTWzsESIijlNTA25uhdx44yYKCsaSlXUV69ebajA/+igEBsrId2+XlQU5Oaas4/v3FzBx4n602nLLdPKiIl+KiuKoqxuAlxcMHAhvvnlp1oPRKEF3T9frg25zUoVt27Zxxx13AKaRk23btrFw4cIuf/3OTBqWlJTE4sWLKS4uJiAgwLI2PDU1lUceeQR/f38KCwuprtZw8uReq+cwGIzk5zd0+H11BqPR2KMDbiGEEEKInsA83fy3v4VnnoFduxy4cGE8tbWB+PvvRautxMXFwFVXHcLfP5sff5zMv//txpYtoNXKyHdv1ThRWm1tPUOHHmbSpNMMHGja7+Cg5uDBsZw6NYoRI1Q0NEBFhWl0+6677Nt20Ta9PugGWLRoEQsWLGDixIlMmjSJv/zlL1RVVVmymXelqKgoIiIiSE1NJSwsrEXSMJ1OR0xMDFFRUZc9j9FoZM2aNRQXFzNixAjLebRaLd7e3hw6dIjz58/j7LyJoqIpLZ7//PPwyivdlyztSnpKNnchhBBCiN4iOBjef/9SIHbmjA+HD99EbOxhIiNPAeDkVMC0ad+RkRFJdXUkiuLQrxOt9UaNR7a3bIFhw3K46qqDGAw1GAxQUwNGozeZmZPJz/dEUZpOJzfPjBC9R58Iuu+++24KCgp44YUX0Ol0jBs3ju+//75FcrWuoFarWbhwIYsXLyYzM7NJ9nKdToeXlxcJCQlXHOFNS0sjIyODgICAFoH7uXPnUKlUVFSUW33u//7vr1i+/B/0lLLrlxuxX7x4MatWrZLAWwghhBDCipZJ1hy5cGEianUQISF7aWioRq02Mnr0MRwdz5GVNZHs7AA2bEASrfVwjUe2KyuhqqqGyZNTGDkyG0UxbWtocODIkTGoVFfh7Ky2Op1c9D49I0rrBAsXLuT8+fPo9Xr27dvH5MmTu+214+PjWbVqFePHj6e0tJRz585ZsnTbGmCWlJSg1+txdXVtsr2iooLS0lHU1FRbfd706ddx6lQqaWlpnfJeOqr5iL1Wq8XBwQGtVktYWBglJSUkJiZKiRwhhBBCiMsIDjZNIb7lFtOU4pwcP5KS5pCeHoGiqHB0BFfXSkaN2kFo6G6Kimp45BGYMQMSEkwBnuhZli2D9evBwcFAVFQaN9+8AT+/bGpqQKWCkpIANm2aQ0ZGONXVasrKTD/7W24xfRYk4O69+sRId08QHx/fItFZW9Ywt7Y2fNeunVaPHzduNYGBP2IwuJKXl0dJSUmnvI+Oam3EHkzJkvz9/UlPTyctLY3oaOuJ4IQQQgghhEnjmt4VFY6cPTuO/PxhTJt2EFfXAmpqwMcnmzlzLlJSEsH58+GsX+8oidZ6EPOshQ0bFEJDc4iMPISTUzWVlaAoUF2tISsrhpKSEECFSgVVVaYRbplO3jdI0N2J1Gp1uwPJ5mvDQc3Gjd9YPXbOnFsxx7NtSdTWVu1JhNbaiL2Zq2vPukkghBBCCNGTNZ5ufmkdsCf791/P0KFn8fE5jLOzHlfXBry9jxIUdJr9+8fw73+HsmWLShKt2UlWFpw4Af/6FyQlgdFYwqhRKQwZUoCzs+kYR0fIyBjB0aNjGDJEg0oFrq5w++1yw6SvkaC7E3UkW3fjteEHD15NXt6LVo6p4uab77E8bkuitrZqbyK0zszmLoQQQgghTMw1vUePNq8LVpGWNpyqqqFMmnSE8PBMQMFgqGHMmH0EBx+noGA8JSUBrF9Prx35zsjIQFGUFjMoe6rG67Z1OnB0rGD8+GOMGHGO6mpTCTCA+no/zp6N4fhxT+rrW45syw2SvkWC7k7SGdm64+PjSU5OsrpvxIi5ODqmU1nZvkRtbX0v7U2E1lnZ3IUQQgghREstE61pyM29moaGqxgy5DDOzhcA8PIqIyhoB+XlvuzdG82//+3bK0uMubm52bsJNmmekdzTs4qxY48REnIWlUqhvh6cnKCkRMvhw+MZMGAoDQ0qGdnuJ/pMIjV7Mgephw4dwtPTk2HDhuHp6WkJUpOSrAfSjRUVQWs38AwGIx988GyHErXZqqOJ0Mwj9l5eXmRmZlJZWYnBYKCyspLMzMwuuUkghBBCCNHfNE+0lpfnwaFD09i27XqKi71xdDRdWzo75xMXt43rrvuBoCAdKpXC55/DAw+YAkXRMeXlpsR1M2aYfh5ff13NyJEHuOaaDYSGnsHBQUGlgupqZy5cGEdy8s3k5gZSVKRCUUwj22vWQHy8BNx9mYx0d9Dl6muHhYWRmZlJYmIisbGxrQaac+fCl1+23H7//fDhhwDqDidqs1VnJEIzZ3M3j/zn5eWh0WiIiYkhISFByoUJIYQQQnSSxonWKiuhqMiXpKRZXH11FoGBR2hoqATA17eA0NAfycsbRErKaL75JoCUFBW33AKPPw5lZTLS2hbNR7b9/MoID8/Aze08arWRhgbTcXV1Tpw6Fc7x46MIDnbCw8O0bltKgPUvEnR3UEeD1NZGt0tLwcOj6baOJGqzVWclQuuumwRCCCGEEP2Z9URrKs6fD+H8+SCMxvNERaXh7V2BXg8DBxYxbdpOSks9yM+/ig8/HMZHHzni5gYuLj1v6vnq1aspLy/H3d2dRYsW2bs5zWptKzg45DNuXAahoRcttbYVBWprHcnKGsXhw+HU1zujVkNtrenf3LmmUXHRf0jQ3UHtDVIzM2HECOvnVJTObqXtOjMRWnfcJBBCCCGEENYSrUFlpZqiolAKC4cxblwWHh7HcHc3FfD29Cxj8OADhIT8xJkzYRgMI6mqGtjjkq6tXr2a3Nxchg4dategu/FNjW3bGhg+PIuhQ0/i4GC6xq+pMY1ggxPHj4/g+PFw/PxccHKCujrTem5HRykB1l9J0N1B7QlSW5tO/t578OCDXdnaK5NEaEIIIYQQvVdrI9+ZmSHk5QUTFJTDyJHHCQgopKEBNJo6IiIycHXNoLx8KIcPh/HppwFs2aK2JF3rj9PPzf3n4QHvvAObNys4OBTj5ZXJtGlZeHjUNxnZLi8fwMWL4RQWDuf0aSfq6vi5hropUdr998OoUf2n/0RTEnR3UFuCVKMRHBysn8dobH2qeXdqXLosMzMTf/+uz5YuhBBCCCE6V/OR7w0bQFFUZGcHUVkZRGFhEa6uJwkOzkKtNuLgAK6uuUycmEt0tIaqqhAuXgzl/fe9+OgjVZPp530xCG8ZZJumguv1tfj7ZzFxYiZubqVUV5uON49sV1V589NPEWRnBxISopZa28IqCbo7yNYgdds2NbNmtXz+vffCJ590f7svRxKhCSGEEEL0DeaR79/+Fp55BnbtMgWW1dWDOHIkjkOHxjNu3GnCw0/T0FADgIuLnsGDT+Lnd5KgIHfOnx+Gk1MgpaUevP8+fPQRfSIIz8qCEyfgX/+CpCRTkF1RAVBHdHQ2Q4acx9ExH5VKwcnJNHimUkF9vSPnzwdjNIZRUzOIoiLTyJnU2hatkaC7E1wpSL3ppnjKy1s+7+xZGDas25trE0mEJoQQQgjRdwQHw/vvX1rvXVEBAwZAfb0LeXmjKSiIpLZWx7BhZwkNzQFMGbg9PMoZM+YIAwYcoaTEjczMQC5cGIq7+yD0enWLIDw+vudOpbY2mq3TmYJtX98KwsNzcXDIZfDgAjQaBWdnLCPbDQ1QUTGI48fDSE8Ppr7eiWHDkJFtYRMJujuJtSA1JCQKDw/rQao9k6XZShKhCSGEEEL0Hc3XezcOPisq1BQVDaG8fAg1NXVotdloNGfx8SmwPF+jqSAyMoPIyAycnZ24eNEPR0d/Cgr8GDDAjbw8FZ98Yspd5O9vfRTc/NpdEZw2P3drU8YrKkClquWqq/Lx9dXh45OHVluJoyMYDKZzNTSAszNUVQ0gOzuE8+eHMWiQJ66upu0NDTKyLWwnQXcnahykrl4Nzz7b8pi//AWeeqp72yWEEEIIIYSZeb03WEu6BmVlzlRVhXH6dBguLlVERmYzbFgOjo4FlhxEjo71DBqUw6BBOQAYDM7odD4UFPhQWuqNonjx/vvOllFwZ2dTgFpVZcrm3drU9KwsyM42BbC+vpeCYIPB9qC6+WtVVhpxdS1jxIhCvL2LUJRC3NwqLEG2SmUaEDO/VmWlltzcoUAI5897U1ysQqWCwYNNidNkZFu0lQTdXaC1hGiVlaY/AEIIIYQQQvQU1sqNXZp+PpDCwnDKy8PJzq7F3/8CYWEXGTJEB9RZzuHgUMfQobkEBuaiKKb1z2VlAygr88LV1Z3sbDfy891RFC0BAS5UVqqaTE1vHCg3NMDYsaaguuDngfa8PIiONh3j4tI0qK6ogPp6CAqqIzi4kpKSShSlgtDQUvz9y1CUcsu67MZTxi8F9GqKiweRmzuU0tKhXLzohkqlYsQIU9sqK00lvyoqTK8tI9uirSTo7kQFBaY7cs0NGgSFhd3fHiGEEKI3SExM5PXXX0en0zF27FjefvttJk2aZO9mCdHvXH76OTg4uHDhwnAUZThZWQpFRSX4+OgIDCzA3b0QF5c6yxJKgwG02mq02mpcXHLx9jaNJqtUMGCAmrIyF0pLB1Bb64KHhzMFBRoqKpzx8HDA11eFg0M5VVXVqFSmyFitbsDf/xSenvWoVPUYDA34+tYyaFAtNTW1uLjUMHBgPS4ul8p4qVSmILm21tQm85Rxo1FNaakneXl+VFT4kZXlg8HgiFoNfn6mYxoH2Q8+2HuTxYmeQYLuTuTn13Lbtm0wY0b3t0UIIYToDT777DMWLVrE2rVrmTx5Mn/5y1+YPXs2J06cwNfanWwhRJdrbfp50yBchV7vzdmz3lRWgk6noNWWM2hQEX5+JQwcWIynZymOjg2W86rVpmDYaDTi5FSNj49pyNnFxRTwXwrKFZyc9Gi1Gmprh6DXa9Fo3Ln66jYtCugAAQAASURBVIOWczUOqp2dTdsaGkz/Gr+WoqgoK3OnrMyD4uJBuLoOJjvbi8JCB1QqCA0FjcY0am4eCZcgW3Q2Cbo7kYPDpV906Dm1t4UQQoieavXq1Tz88MM8+OCDAKxdu5aNGzfy3nvvsXTpUju3TggBtgXhTk4qyso8aGjwAExVeoxGhcDAakJCyikqKkerLUerNQXbBkM1Gk1dk9e5FJSbHqtUMG3aYss+uLTPfCyAweBATY0L1dUDcXLSkpOjpaLCjaoqd/z93bl4UU1xsel8I0aYpqaXl5uC7Opq8PExrdHuqVnXRe8nQXcnqqqC3/8ebrkFpk2zd2uEEEKInq2uro6UlBSWLVtm2aZWq5k5cybJyclWn6PX69Hr9ZbH5T/X5DQajRjNV+PtZDQaURSlw+fpD6Sv2qav9VdgoOkfwNtvmxKfnTgBH38Mycmm6dxarWmdtbOzKxUVrly44EdlpWn7kCFw+jSAgYAAPUOG1JGTo8fRsR5HRwOBgQ24uRVz5owbiuKAoqgAFUajmro6JxoaHKmrc8JgcCYw0JULFxybBNUXLmB5LbUaPDyMVFebguyqKtPo+K9+ZUqEZh7NDgq69P5624+pr32+ulpn9pet55CguxM5O8Prr9u7FUIIIUTvUFhYiMFgwK/Z+iw/Pz+OHz9u9TkrVqxg+fLlLbYXFBRQa1642U5Go5GysjIURUGttl7yU5hIX7VNX+8vjQbGjDH9Kygw5TIaOBC++w4OHTIlOwsMNB2n15uC8cGDTeu+vbxM2cCdnFTU1jrj4gI+PkYGDGggL88DjUaNo6MpWFYUUyDd0AC1tQZcXGrw86th6FAoKTHNOnV1heHDm75WUBDcdx/cfLPpPIMHm0a3wfT/APn59uu/jurrn6/O1pn9VVFRYdNxEnQLIYQQotdYtmwZixYtsjwuLy8nKCgIHx8f3DuYSthoNKJSqfDx8ZEL1yuQvmqb/tRfjVMxTJxoGgU3l/kKCrr02MPjUomyxmW+iorg/HkjY8ao0Ot9KCxUU1trCpahafbyoiLTNHYXF5g1q+XIdfPX7qv60+erM3Rmf7m4uNh0nATdQgghhLCLwYMH4+DgQF5eXpPteXl5+Pv7W32ORqNBo9G02K5WqzvlYlOlUnXaufo66au26a/9FRJi+mft8Zo11mtvm+p0q4iKUjN79h1cvFhARIQP//znN1brdLeW7Kz5a/dl/fXz1V6d1V+2Pl+CbiGEEELYhbOzMxMmTGDbtm3ccccdgGkEYtu2bSxcuNC+jRNCdIvGSdrMjwMDL033zsg4RG5uLqWlQ60eK0nPRG8gQbcQQggh7GbRokUsWLCAiRMnMmnSJP7yl79QVVVlyWYuhBBC9HYSdAshhBDCbu6++24KCgp44YUX0Ol0jBs3ju+//75FcjUhhBCit5KgWwghhBB2tXDhQplOLoQQos+SlfZCCCGEEEIIIUQXkaBbCCGEEEIIIYToIhJ0CyGEEEIIIYQQXUSCbiGEEEIIIYQQootIIjVAURQAysvL7dySjjMajVRUVODi4tLhYu99nfRV20h/2U76ynbSV5e+e8zfRaJtOvM7XD6PtpO+ahvpr7Zp3F9Go9GyrS9cq3cF+Xy1TWf2l63f4RJ0AxUVFQAEBQXZuSVCCCH6q4qKCjw8POzdjF5HvsOF6B8uXrwofyNFj3Wl73CVIrfWMRqNXLhwATc3N1Qqlb2b0yHl5eUEBQWRnZ2Nu7u7vZvTo0lftY30l+2kr2wnfWW6O15RUcGQIUNkhKIdOvM7XD6PtpO+ahvpr7aR/mob6a+26cz+svU7XEa6AbVaTWBgoL2b0anc3d3ll85G0ldtI/1lO+kr2/X3vpLRm/briu/w/v55bAvpq7aR/mob6a+2kf5qm87qL1u+w+WWuhBCCCGEEEII0UUk6BZCCCGEEEIIIbqIBN19jEaj4cUXX0Sj0di7KT2e9FXbSH/ZTvrKdtJXoieRz6PtpK/aRvqrbaS/2kb6q23s0V+SSE0IIYQQQgghhOgiMtIthBBCCCGEEEJ0EQm6hRBCCCGEEEKILiJBtxBCCCGEEEII0UUk6BZCCCGEEEIIIbqIBN19TGJiIsOGDcPFxYXJkyezf/9+ezfJ7lasWMHVV1+Nm5sbvr6+3HHHHZw4caLJMbW1tSQkJDBo0CC0Wi1z584lLy/PTi3uOf785z+jUql4+umnLdukry7Jzc1l3rx5DBo0CFdXV6Kjozl48KBlv6IovPDCCwQEBODq6srMmTM5deqUHVtsHwaDgT/84Q+Ehobi6upKWFgYr7zyCo3zeEpfCXsoLi7mvvvuw93dHU9PTx566CEqKysv+5zp06ejUqma/Hv00Ue7qcXdq63XFF988QXh4eG4uLgQHR3Nd999100t7Rna0l/r1q1r8TlycXHpxtba165du7j11lsZMmQIKpWKr7/++orP2bFjBzExMWg0GkaMGMG6deu6vJ09RVv7a8eOHS0+XyqVCp1O1z0NtiNbrvut6eq/XxJ09yGfffYZixYt4sUXX+TQoUOMHTuW2bNnk5+fb++m2dXOnTtJSEhg7969bN26lfr6embNmkVVVZXlmGeeeYZvv/2WL774gp07d3LhwgXuuusuO7ba/g4cOMD//d//MWbMmCbbpa9MSkpKmDJlCk5OTmzatIn09HTeeOMNvLy8LMesXLmSt956i7Vr17Jv3z4GDhzI7Nmzqa2ttWPLu99rr73Gu+++y5o1a8jIyOC1115j5cqVvP3225ZjpK+EPdx3332kpaWxdetWNmzYwK5du/jNb35zxec9/PDDXLx40fJv5cqV3dDa7tXWa4qkpCTuvfdeHnroIVJTU7njjju44447OHbsWDe33D7acw3m7u7e5HN0/vz5bmyxfVVVVTF27FgSExNtOv7s2bPMmTOH6667jsOHD/P000/z61//ms2bN3dxS3uGtvaX2YkTJ5p8xnx9fbuohT2HLdf9zXXL3y9F9BmTJk1SEhISLI8NBoMyZMgQZcWKFXZsVc+Tn5+vAMrOnTsVRVGU0tJSxcnJSfniiy8sx2RkZCiAkpycbK9m2lVFRYUycuRIZevWrcq0adOUp556SlEU6avGfvvb3yrXXHNNq/uNRqPi7++vvP7665ZtpaWlikajUf797393RxN7jDlz5ii/+tWvmmy76667lPvuu09RFOkrYR/p6ekKoBw4cMCybdOmTYpKpVJyc3NbfV7jv4l9WVuvKX7xi18oc+bMabJt8uTJyiOPPNKl7ewp2tpf77//vuLh4dFNrevZAOWrr7667DFLlixRoqKimmy7++67ldmzZ3dhy3omW/rrxx9/VAClpKSkW9rUkzW/7remO/5+yUh3H1FXV0dKSgozZ860bFOr1cycOZPk5GQ7tqznKSsrA8Db2xuAlJQU6uvrm/RdeHg4wcHB/bbvEhISmDNnTpM+Aemrxr755hsmTpzI//7v/+Lr68v48eP5+9//btl/9uxZdDpdk77y8PBg8uTJ/a6v4uPj2bZtGydPngTgp59+Yvfu3dx0002A9JWwj+TkZDw9PZk4caJl28yZM1Gr1ezbt++yz/34448ZPHgwo0ePZtmyZVRXV3d1c7tVe64pkpOTW3xnzJ49u1/8Drf3GqyyspKQkBCCgoK4/fbbSUtL647m9kr9+fPVEePGjSMgIIAbbriBPXv22Ls5dtH8ut+a7vh8OXbamYRdFRYWYjAY8PPza7Ldz8+P48eP26lVPY/RaOTpp59mypQpjB49GgCdToezszOenp5NjvXz8+sXa1+a+/TTTzl06BAHDhxosU/66pIzZ87w7rvvsmjRIn73u99x4MABnnzySZydnVmwYIGlP6z9Tva3vlq6dCnl5eWEh4fj4OCAwWDgj3/8I/fddx+A9JWwC51O12KqpaOjI97e3pf93P3yl78kJCSEIUOGcOTIEX77299y4sQJvvzyy65ucrdpzzWFTqfrt7/D7emvUaNG8d577zFmzBjKyspYtWoV8fHxpKWlERgY2B3N7lVa+3yVl5dTU1ODq6urnVrWMwUEBLB27VomTpyIXq/nH//4B9OnT2ffvn3ExMTYu3ndxtp1vzXd8fdLgm7RryQkJHDs2DF2795t76b0SNnZ2Tz11FNs3bq1XyV0aQ+j0cjEiRP505/+BMD48eM5duwYa9euZcGCBXZuXc/y+eef8/HHH/PJJ58QFRVlWY83ZMgQ6SvR6ZYuXcprr7122WMyMjLaff7Ga76jo6MJCAjg+uuvJzMzk7CwsHafV/QvcXFxxMXFWR7Hx8cTERHB//3f//HKK6/YsWWiLxg1ahSjRo2yPI6PjyczM5M333yTf/3rX3ZsWffqSdf9EnT3EYMHD8bBwaFFFum8vDz8/f3t1KqeZeHChZZEOY3vIvv7+1NXV0dpaWmTEdz+2HcpKSnk5+c3uQtqMBjYtWsXa9asYfPmzdJXPwsICCAyMrLJtoiICNavXw9g6Y+8vDwCAgIsx+Tl5TFu3Lhua2dP8Nxzz7F06VLuuecewBSonD9/nhUrVrBgwQLpK9Gpnn32WR544IHLHjN8+HD8/f1bJLlqaGiguLi4TX/PJk+eDMDp06f7TNDdnmsKf3//fnsN0hnXYE5OTowfP57Tp093RRN7vdY+X+7u7jLKbaNJkyb1iOCzu7R23W9Nd/z9kjXdfYSzszMTJkxg27Ztlm1Go5Ft27Y1uZPaHymKwsKFC/nqq6/Yvn07oaGhTfZPmDABJyenJn134sQJsrKy+l3fXX/99Rw9epTDhw9b/k2cOJH77rvP8v/SVyZTpkxpUYLi5MmThISEABAaGoq/v3+TviovL2ffvn39rq+qq6tRq5t+3Tg4OGA0GgHpK9G5fHx8CA8Pv+w/Z2dn4uLiKC0tJSUlxfLc7du3YzQaLYG0LQ4fPgzQ5IZRb9eea4q4uLgmxwNs3bq1X/wOd8Y1mMFg4OjRo33qc9SZ+vPnq7McPny4X3y+rnTdb023fL46LSWbsLtPP/1U0Wg0yrp165T09HTlN7/5jeLp6anodDp7N82uHnvsMcXDw0PZsWOHcvHiRcu/6upqyzGPPvqoEhwcrGzfvl05ePCgEhcXp8TFxdmx1T1H80y90lcm+/fvVxwdHZU//vGPyqlTp5SPP/5YGTBggPLRRx9Zjvnzn/+seHp6Kv/5z3+UI0eOKLfffrsSGhqq1NTU2LHl3W/BggXK0KFDlQ0bNihnz55VvvzyS2Xw4MHKkiVLLMdIXwl7uPHGG5Xx48cr+/btU3bv3q2MHDlSuffeey37c3JylFGjRin79u1TFEVRTp8+rbz88svKwYMHlbNnzyr/+c9/lOHDhytTp06111voMle6prj//vuVpUuXWo7fs2eP4ujoqKxatUrJyMhQXnzxRcXJyUk5evSovd5Ct2prfy1fvlzZvHmzkpmZqaSkpCj33HOP4uLioqSlpdnrLXSriooKJTU1VUlNTVUAZfXq1Upqaqpy/vx5RVEUZenSpcr9999vOf7MmTPKgAEDlOeee07JyMhQEhMTFQcHB+X777+311voVm3trzfffFP5+uuvlVOnTilHjx5VnnrqKUWtVis//PCDvd5Ct7Hlut8ef78k6O5j3n77bSU4OFhxdnZWJk2apOzdu9feTbI7wOq/999/33JMTU2N8vjjjyteXl7KgAEDlDvvvFO5ePGi/RrdgzQPuqWvLvn222+V0aNHKxqNRgkPD1f+9re/NdlvNBqVP/zhD4qfn5+i0WiU66+/Xjlx4oSdWms/5eXlylNPPaUEBwcrLi4uyvDhw5Xf//73il6vtxwjfSXsoaioSLn33nsVrVaruLu7Kw8++KBSUVFh2X/27FkFUH788UdFURQlKytLmTp1quLt7a1oNBplxIgRynPPPaeUlZXZ6R10rctdU0ybNk1ZsGBBk+M///xz5aqrrlKcnZ2VqKgoZePGjd3cYvtqS389/fTTlmP9/PyUm2++WTl06JAdWm0f5pJWzf+Z+2jBggXKtGnTWjxn3LhxirOzszJ8+PAm13F9XVv767XXXlPCwsIUFxcXxdvbW5k+fbqyfft2+zS+m9ly3W+Pv1+qnxsnhBBCCCGEEEKITiZruoUQQgghhBBCiC4iQbcQQgghhBBCCNFFJOgWQgghhBBCCCG6iATdQgghhBBCCCFEF5GgWwghhBBCCCGE6CISdAshhBBCCCGEEF1Egm4hhBBCCCGEEKKLSNAthBBCCCGEEEJ0EQm6hRBW7dixA5VKRWlpqb2bYpOpU6fyySefdOgcsbGxrF+/vpNaJIQQQnQOlUrF119/be9mAHDixAn8/f2pqKjo0HnkO1f0JxJ0C2EnycnJODg4MGfOnBb7XnrpJcaNG9die0/60u1JvvnmG/Ly8rjnnnss2xYtWoS3tzdBQUF8/PHHTY7/4osvuPXWW1uc5/nnn2fp0qUYjcYub7MQQggBUFBQwGOPPUZwcDAajQZ/f39mz57Nnj177N00q5YtW8YTTzyBm5tbh84j37miP5GgWwg7+ec//8kTTzzBrl27uHDhgr2b06u99dZbPPjgg6jVpj9p3377LZ988glbtmxh5cqV/PrXv6awsBCAsrIyfv/735OYmNjiPDfddBMVFRVs2rSpW9svhBCi/5o7dy6pqal88MEHnDx5km+++Ybp06dTVFRk76a1kJWVxYYNG3jggQc6fC75zhX9iQTdQthBZWUln332GY899hhz5sxh3bp1ln3r1q1j+fLl/PTTT6hUKlQqFevWrWPYsGEA3HnnnahUKstjgP/85z/ExMTg4uLC8OHDWb58OQ0NDZb9KpWKf/zj/7N333FNXf0fwD8JI4QNyhYBQWWICC7Eqli14NbauuusE7QOtPo8Dtytuypq7VDUWrfVuvfELSoCLopQlaGyVyDJ+f3BL/chJEDCkOH3/Xrx0tx57sk493vP+hX9+/eHrq4uGjdujGPHjsml6eTJk2jSpAmEQiE6d+6MV69eya3/8OEDhgwZAhsbG+jq6sLd3R1//vmn3Da+vr6YOnUqZs+eDVNTU1haWiI4OFhum7S0NEyYMAEWFhbQ0dFBs2bNcPz4cW799evX0aFDBwiFQtja2mLq1KnIzs4uMS/fvXuHixcvytVcR0dHw9fXF61atcKQIUNgaGiI2NhYAMDs2bO5GoXiNDQ00KNHD+zdu7fE8xFCCCGVJS0tDdeuXcOPP/6Izp07w87ODm3atMHcuXPRp0+fEveLiIjA559/DqFQiHr16mH8+PHIysri1o8aNQr9+vXDokWLYGZmBkNDQ0ycOBH5+fncNlKpFCtWrICDgwOEQiE8PDxw8ODBUtO7f/9+eHh4wMbGhlu2Y8cOGBsb4/jx42jatCl0dXXx1VdfIScnB6GhobC3t4eJiQmmTp0KiUTC7UdlLvmkMELIR/fbb7+xVq1aMcYY+/vvv5mjoyOTSqWMMcZycnLYzJkzmZubG0tISGAJCQksJyeHJScnMwBs+/btLCEhgSUnJzPGGLt69SozNDRkO3bsYDExMezs2bPM3t6eBQcHc+cDwBo0aMD27NnDXrx4waZOncr09fXZhw8fGGOMxcfHM4FAwGbMmMGePn3Kdu/ezSwsLBgAlpqayhhj7PXr12zVqlUsPDycxcTEsA0bNjANDQ12+/Zt7jydOnVihoaGLDg4mD1//pyFhoYyHo/Hzp49yxhjTCKRMG9vb+bm5sbOnj3LYmJi2N9//81OnjzJGGPs5cuXTE9Pj61bt449f/6c3bhxg3l6erJRo0aVmJeHDx9menp6TCKRcMtOnz7NHB0dWUpKCrt37x4zMDBgKSkp7Nq1a6xVq1ZMLBaXeLwtW7YwOzs7Vd9KQgghpNwKCgqYvr4+mzZtGsvLyytxOwDsyJEjjDHGsrKymJWVFfvyyy9ZREQEu3DhAnNwcGAjR47kth85ciTT19dngwYNYk+ePGHHjx9nZmZm7D//+Q+3zdKlS5mzszM7ffo0i4mJYdu3b2cCgYBdvny5xHT06dOHTZw4UW7Z9u3bmZaWFuvWrRt78OABu3LlCqtXrx774osv2MCBA1lkZCT7+++/mba2Ntu7d6/cvlTmkk8FBd2EVAMfHx+2fv16xlhhgVu/fn126dIlbv3ChQuZh4eHwn5FC12ZLl26sOXLl8st27VrF7OyspLbb968edzrrKwsBoCdOnWKMcbY3Llzmaurq9wxvv/+e7mgW5mePXuymTNncq87derEPvvsM7ltWrduzb7//nvGGGNnzpxhfD6fPXv2TOnxxo4dy8aPHy+37Nq1a4zP57Pc3Fyl+6xbt441atRIYfnChQuZo6Mja9asGTt8+DATiUSsWbNm7N69e2zjxo2sSZMmzMfHhz158kRuv6NHjzI+ny8XxBNCCCFV5eDBg8zExITp6OgwHx8fNnfuXPbo0SO5bYqW/9u2bWMmJiYsKyuLW3/ixAnG5/NZYmIiY6ww6DY1NWXZ2dncNlu2bGH6+vpMIpGwvLw8pqury8LCwuTOM3bsWDZkyJAS0+rh4cEWL14st2z79u0MAHv58iW3bMKECUxXV5dlZmZyy/z8/NiECRPk9qUyl3wqNKurhp2QT9WzZ89w584dHDlyBACgqamJQYMG4bfffoOvr6/ax3v06BFu3LiBZcuWccskEgny8vKQk5MDXV1dAEDz5s259Xp6ejA0NERycjKAwubYbdu2lTtuu3bt5F5LJBIsX74c+/fvx5s3b5Cfnw+RSMQdX6boeQDAysqKO8/Dhw/RoEEDNGnSpMRrefz4sdzAZ4wxSKVSxMbGwsXFRWGf3Nxc6OjoKCwPDg6Wa9q+aNEidO3aFVpaWli6dCkiIiJw/PhxjBgxAvfv3+e2EwqFkEqlEIlEEAqFStNJCCGEVJYBAwagZ8+euHbtGm7duoVTp05h5cqV+PXXX5X2nY6OjoaHhwf09PS4Ze3bt4dUKsWzZ89gYWEBAPDw8JAro9u1a4esrCz8+++/yMrKQk5ODrp16yZ37Pz8fHh6epaY1pLKXF1dXTg6OnKvLSwsYG9vD319fbllsvsBGSpzyaeCgm5CPrLffvsNYrEY1tbW3DLGGAQCATZt2gQjIyO1jpeVlYVFixbhyy+/VFhXtGDU0tKSW8fj8dQaMXTVqlX46aefsH79eri7u0NPTw/Tpk2T6x9W1nnKKlCzsrIwYcIETJ06VWGdsj7YAFC/fn2kpqaWetynT59i9+7dCA8Px++//46OHTvCzMwMAwcOxJgxY5CZmcmNwpqSkgI9PT0q/AkhhHw0Ojo66NatG7p164b58+fj22+/xcKFCytlwDJlZP2/T5w4Idc/GwAEAkGJ+5VU5ior+1W576Ayl3wqKOgm5CMSi8XYuXMn1qxZgy+++EJuXb9+/fDnn39i4sSJ0NbWlhtsREZLS0thuZeXF549ewYnJ6dyp8vFxUVhYLVbt27Jvb5x4wb69u2L4cOHAygcgOX58+dwdXVV+TzNmzfH69ev8fz5c6W13V5eXoiKilLrWjw9PZGYmIjU1FSYmJgorGeMYcKECVi7di309fUhkUhQUFAAANy/RfP0yZMnpT7lJ4QQQqqaq6triVOEuri4YMeOHcjOzuZqu2/cuAE+n4+mTZty2z169Ai5ublcQHvr1i3o6+vD1tYWpqamEAgEiI+PR6dOnVROl6enJ6Kiosp/YcVQmUs+FTR6OSEf0fHjx5GamoqxY8eiWbNmcn8DBgzAb7/9BgCwt7dHbGwsHj58iPfv30MkEnHLL1y4wAWZALBgwQLs3LkTixYtQmRkJKKjo7F3717MmzdP5XRNnDgRL168wKxZs/Ds2TPs2bNHbkR1AGjcuDHOnTuHsLAwREdHY8KECUhKSlLr+jt16oSOHTtiwIABOHfuHGJjY3Hq1CmcPn0aAPD9998jLCwMgYGBePjwIV68eIGjR48iMDCwxGN6enqifv36Jc5n+uuvv8LMzIwb3bx9+/a4ePEibt26hXXr1sHV1RXGxsbc9teuXVN4IEIIIYRUhQ8fPuDzzz/H7t278fjxY8TGxuLAgQNYuXIl+vbtq3SfYcOGQUdHByNHjsSTJ09w6dIlTJkyBd988w3XtBwobCo+duxYREVF4eTJk1i4cCECAwPB5/NhYGCAoKAgTJ8+HaGhoYiJicGDBw+wceNGhIaGlphePz8/3Lx5U2nFQHlQmUs+FRR0E/IR/fbbb+jatavSJuQDBgzAvXv38PjxYwwYMAD+/v7o3LkzzMzMuKm51qxZg3PnzsHW1pZ7Muzn54fjx4/j7NmzaN26Nby9vbFu3TrY2dmpnK6GDRvi0KFD+Ouvv+Dh4YGtW7di+fLlctvMmzcPXl5e8PPzg6+vLywtLdGvXz+18+DQoUNo3bo1hgwZAldXV8yePZsrvJs3b44rV67g+fPn6NChAzw9PbFgwQK5pvjFaWhoYPTo0XL9wGWSkpKwbNkybNiwgVvWpk0bzJw5Ez179sT+/fuxfft2bt2bN28QFhaG0aNHq31dhBBCiLr09fXRtm1brFu3Dh07dkSzZs0wf/58jBs3Dps2bVK6j66uLs6cOYOUlBS0bt0aX331Fbp06aKwfZcuXdC4cWN07NgRgwYNQp8+feTGOlmyZAnmz5+PFStWwMXFBf7+/jhx4gQcHBxKTG/37t2hqamJ8+fPV/jaqcwlnxIeY4xVdyIIIaQiEhMT4ebmhgcPHqj1sKG477//Hqmpqdi2bVslpo4QQgj5uEaNGoW0tLQSm6hXREhICI4dO4YzZ85U6DhU5pJPCfXpJoTUepaWlvjtt98QHx9foaDb3NwcM2bMqMSUEUIIIXXLhAkTkJaWJjcIaXlQmUs+JVTTTQghhBBCSB1SlTXdhBD1UdBNCCGEEEIIIYRUERpIjRBCCCGEEEIIqSIUdBNCCCGEEEIIIVWEgm5CCCGEEEIIIaSKUNBNCCGEEEIIIYRUEQq6CSGEEEIIIYSQKkJBNyGEEEIIIYQQUkUo6CaEEEIIIYQQQqoIBd2EEEIIIYQQQkgVoaCbEEIIIYQQQgipIhR0E0IIIYQQQgghVYSCbkIIIYQQQgghpIpQ0E0IIYQQQgghhFQRCroJIYQQQgghhJAqQkE3KZdRo0bB3t5ebhmPx0NwcHC1pIeQj+ny5cvg8Xi4fPlyhY7z6tUr8Hg87Nixo1LSVV47duwAj8fDq1evqjUdJalIPlXWe0UIqVx0H0FkakpZSEhVoqC7lomNjUVgYCCaNGkCXV1d6OrqwtXVFQEBAXj8+HF1J6/K7dmzB+vXr1d5e3t7e/B4PPB4PPD5fBgbG8Pd3R3jx4/H7du3qy6h1ejt27cIDg7Gw4cPK3ScUaNGcXnH4/Ggr6+PRo0a4auvvsKhQ4cglUrLfWx138faShbMKvubM2eO0n1Onjyp9KYzJycHwcHB1Ro8BgcHc9+lf//9V2F9RkYGhEIheDweAgMDqyGFhJCy0H0E3UeUpbLuIwDg77//RqdOnWBubg5dXV00atQIAwcOxOnTpyue0DpEVr6W9JeYmFjdSSQVpFndCSCqO378OAYNGgRNTU0MGzYMHh4e4PP5ePr0KQ4fPowtW7YgNjYWdnZ21ZK+3NxcaGpW7Udqz549ePLkCaZNm6byPi1atMDMmTMBAJmZmYiOjsaBAwfwyy+/YPr06Vi7dm0VpbZ6vH37FosWLYK9vT1atGhRoWMJBAL8+uuvAArf37i4OPz999/46quv4Ovri6NHj8LQ0FDt45bnfazNFi9eDAcHB7llzZo1g52dHXJzc6GlpcUtP3nyJEJCQhQC75ycHCxatAgA4OvrW9VJLpVAIMCff/6J2bNnyy0/fPhwNaWIEKIKuo+g+whVVNZ9xOrVqzFr1ix06tQJc+fOha6uLl6+fInz589j79698Pf3r7xE1xFbtmyBvr6+wnJjY+OPnxhSqSjoriViYmIwePBg2NnZ4cKFC7CyspJb/+OPP2Lz5s3g80tvvJCdnQ09Pb0qSaOOjk6VHLeibGxsMHz4cLllP/74I4YOHYp169ahcePGmDRpUjWlrmbT1NRUyLulS5fihx9+wNy5czFu3Djs27evmlJXe3Tv3h2tWrVSuq6mfm9K06NHD6VB9549e9CzZ08cOnSomlJGCCkJ3UeUH91HqE8sFmPJkiXo1q0bzp49q7A+OTm5GlJV83311VeoX7++Wvvk5eVBW1tb6Xe3ot9XqVSK/Pz8GvvdrE2oeXktsXLlSmRnZ2P79u0KBSVQGBxNnToVtra23LJRo0ZBX18fMTEx6NGjBwwMDDBs2DAAwLVr1/D111+jYcOGEAgEsLW1xfTp05Gbm6tw7L/++gvNmjWDjo4OmjVrhiNHjihNo7K+WG/evMGYMWNgYWEBgUAANzc3/P7773LbyPpc7t+/H8uWLUODBg2go6ODLl264OXLl9x2vr6+OHHiBOLi4rjmNsX7g6lKKBRi165dMDU1xbJly8AY49ZJpVKsX78ebm5u0NHRgYWFBSZMmIDU1FS5Y9y7dw9+fn6oX78+hEIhHBwcMGbMGLltpFIpfvrpJ7i7u0NHRwdmZmbw9/fHvXv35LbbvXs3WrZsCaFQCFNTUwwePFih+a6vry+aNWuGqKgodO7cGbq6urCxscHKlSvl8rJ169YAgNGjR3P5JOsnlZOTg6dPn+L9+/flyjeZOXPm4IsvvsCBAwfw/PlzbvnRo0fRs2dPWFtbQyAQwNHREUuWLIFEIpG7jpLex/z8fCxYsAAtW7aEkZER9PT00KFDB1y6dEmldKlyflkayspLmdevX6Nfv37Q09ODubk5pk+fDpFIVI5cU1S8H9uoUaMQEhICAHLNyl69egUzMzMAwKJFi7jlRb9vT58+xVdffQVTU1Po6OigVatWOHbsmMI5IyMj8fnnn0MoFKJBgwZYunSp2l0Fhg4diocPH+Lp06fcssTERFy8eBFDhw5Vuk9ycjLGjh0LCwsL6OjowMPDA6GhoQrbpaWlYdSoUTAyMoKxsTFGjhyJtLQ0pcdU9ZoJIXQfAdB9xMe8j3j//j0yMjLQvn17pevNzc1L3R8ALl68iA4dOkBPTw/Gxsbo27cvoqOj5baRNct++vQpBg4cCENDQ9SrVw/fffcd8vLyFI6pSj4Vd/DgQfB4PFy5ckVh3c8//wwej4cnT54AKCwLR48ejQYNGkAgEMDKygp9+/attDFTZJ/1vXv3Yt68ebCxsYGuri4yMjJK/b5mZ2dj5syZsLW1hUAgQNOmTbF69Wq5zy0ArnvYH3/8ATc3NwgEAuoKUEmopruWOH78OJycnNC2bVu19hOLxfDz88Nnn32G1atXQ1dXFwBw4MAB5OTkYNKkSahXrx7u3LmDjRs34vXr1zhw4AC3/9mzZzFgwAC4urpixYoV+PDhA/djUpakpCR4e3tzX2AzMzOcOnUKY8eORUZGhkLTrh9++AF8Ph9BQUFIT0/HypUrMWzYMK7P1H//+1+kp6fj9evXWLduHQAobYKjKn19ffTv3x+//fYboqKi4ObmBgCYMGECduzYgdGjR2Pq1KmIjY3Fpk2bEB4ejhs3bkBLSwvJycn44osvYGZmhjlz5sDY2BivXr1SaF47duxY7NixA927d8e3334LsViMa9eu4datW1zN57JlyzB//nwMHDgQ3377Ld69e4eNGzeiY8eOCA8Pl2tSlJqaCn9/f3z55ZcYOHAgDh48iO+//x7u7u7o3r07XFxcsHjxYixYsADjx49Hhw4dAAA+Pj4AgDt37qBz585YuHBhhQer+eabb3D27FmcO3cOTZo0AVDYh1lfXx8zZsyAvr4+Ll68iAULFiAjIwOrVq0CUPr7mJGRgV9//RVDhgzBuHHjkJmZid9++w1+fn64c+dOmc3cVDm/qnkJFDZ17NKlC+Lj4zF16lRYW1tj165duHjxolp5lZ6ernCDouxJ9oQJE/D27VucO3cOu3bt4pabmZlhy5YtmDRpEvr3748vv/wSANC8eXMAhYF0+/btYWNjgzlz5kBPTw/79+9Hv379cOjQIfTv3x9A4c1A586dIRaLue22bdsGoVCo1vV07NgRDRo0wJ49e7B48WIAwL59+6Cvr4+ePXsqbJ+bmwtfX1+8fPkSgYGBcHBwwIEDBzBq1CikpaXhu+++AwAwxtC3b19cv34dEydOhIuLC44cOYKRI0cqHFPVayaEFKL7CLqPAD7efYS5uTmEQiH+/vtvTJkyBaampmrl7fnz59G9e3c0atQIwcHByM3NxcaNG9G+fXs8ePBA4WHJwIEDYW9vjxUrVuDWrVvYsGEDUlNTsXPnTm4bdfKpqJ49e0JfXx/79+9Hp06d5Nbt27cPbm5uaNasGQBgwIABiIyMxJQpU2Bvb4/k5GScO3cO8fHxKj3gSUlJUVimqampkLYlS5ZAW1sbQUFBEIlE0NbWBqD8+8oYQ58+fXDp0iWMHTsWLVq0wJkzZzBr1iy8efOG+y7IXLx4Efv370dgYCDq169f7gdTpBhGarz09HQGgPXr109hXWpqKnv37h33l5OTw60bOXIkA8DmzJmjsF/R7WRWrFjBeDwei4uL45a1aNGCWVlZsbS0NG7Z2bNnGQBmZ2cntz8AtnDhQu712LFjmZWVFXv//r3cdoMHD2ZGRkZcGi5dusQAMBcXFyYSibjtfvrpJwaARUREcMt69uypcN7S2NnZsZ49e5a4ft26dQwAO3r0KGOMsWvXrjEA7I8//pDb7vTp03LLjxw5wgCwu3fvlnjsixcvMgBs6tSpCuukUiljjLFXr14xDQ0NtmzZMrn1ERERTFNTU255p06dGAC2c+dObplIJGKWlpZswIAB3LK7d+8yAGz79u0K55XlddH3qSQjR45kenp6Ja4PDw9nANj06dO5Zco+VxMmTGC6urosLy+PW1bS+ygWi+U+A4wVfsYtLCzYmDFjykyzqudXNS/Xr1/PALD9+/dzy7Kzs5mTkxMDwC5dulRqerZv384AKP1jjLHY2FiF9yogIIAp+2l+9+5die9dly5dmLu7u9w1SqVS5uPjwxo3bswtmzZtGgPAbt++zS1LTk5mRkZGDACLjY0t9XoWLlzIALB3796xoKAg5uTkxK1r3bo1Gz16NGOs8LcgICCAWyfLx927d3PL8vPzWbt27Zi+vj7LyMhgjDH2119/MQBs5cqV3HZisZh16NBBIZ9UvWbZZ76s94qQuozuI+g+grGPfx+xYMECBoDp6emx7t27s2XLlrH79+8rbKesLGzRogUzNzdnHz584JY9evSI8fl8NmLECG6ZrFzq06eP3DEnT57MALBHjx4xxtTLJ2WGDBnCzM3NmVgs5pYlJCQwPp/PFi9ezBgr/C4BYKtWrSojZxTJrkPZX9OmTbntZPnfqFEjhe9gSd9XWdm6dOlSueVfffUV4/F47OXLl9wyAIzP57PIyEi1r4GUjpqX1wIZGRkAlD+N9fX1hZmZGfcna5palLJ+RkVrtrKzs/H+/Xv4+PiAMYbw8HAAQEJCAh4+fIiRI0fCyMiI275bt25wdXUtNc2MMRw6dAi9e/cGYwzv37/n/vz8/JCeno4HDx7I7TN69GjuSR0A7unqP//8U+q5KkKWp5mZmQAKn9wbGRmhW7ducmlu2bIl9PX1uWbOsieOx48fR0FBgdJjHzp0CDweDwsXLlRYx+PxABQOPCWVSjFw4EC581laWqJx48YKzar19fXl+pVpa2ujTZs2KueRr68vGGOVMiVL8bwD5D9XmZmZeP/+PTp06MA1RyuLhoYG9xmQSqVISUmBWCxGq1atFD4vyqhzflXy8uTJk7CyssJXX33FLdPV1cX48ePLTEtRISEhOHfunNxfZUlJScHFixcxcOBA7prfv3+PDx8+wM/PDy9evMCbN2+46/H29kabNm24/c3MzLjmZ+oYOnQoXr58ibt373L/ltS0/OTJk7C0tMSQIUO4ZVpaWpg6dSqysrK4JnsnT56Epqam3G+WhoYGpkyZUu5rJoTQfQTdR8in92PdRyxatAh79uyBp6cnzpw5g//+979o2bIlvLy8FJqJFyX73IwaNUquhrx58+bo1q0bTp48qbBPQECA3GtZuSHbVt18Km7QoEFITk6Wm0Hk4MGDkEqlGDRoEIDC74S2tjYuX76s0JVAVYcOHVK4X9i+fbvCdiNHjiyxlVrx7+vJkyehoaGBqVOnyi2fOXMmGGM4deqU3PJOnTqV+f0k6qPm5bWAgYEBACArK0th3c8//4zMzEwkJSUpDPIBFDZJUdaEKz4+HgsWLMCxY8cUfhjS09MBAHFxcQCAxo0bK+zftGnTUoOgd+/eIS0tDdu2bcO2bduUblN8EI2GDRvKvTYxMQGAcv9wqUKWp7I8fvHiBdLT00vsayRLc6dOnTBgwAAsWrQI69atg6+vL/r164ehQ4dCIBAAKBy0xtrautQmVS9evABjTGkeA5Ab1RoAGjRowBW0MiYmJtUyzUvxvAMKm/zOmzcPFy9e5G7yZGSfq7KEhoZizZo1ePr0qdyNSPHRv5VR5/yq5GVcXBycnJwUtmvatKlK1yLTpk2bEgdSq6iXL1+CMYb58+dj/vz5SrdJTk6GjY0N4uLilDYtVfd6AMDT0xPOzs7Ys2cPjI2NYWlpic8//1zptnFxcWjcuLHCIC8uLi7cetm/VlZWCoFB8fSpc82EELqPoPuI//nY9xFDhgzBkCFDkJGRgdu3b2PHjh3Ys2cPevfujSdPnigdoEv2uVFWNrm4uODMmTMKA4QVv35HR0fw+XyuL7W6+VScv78/jIyMsG/fPnTp0gVAYdPyFi1acF3sBAIBfvzxR8ycORMWFhbw9vZGr169MGLECFhaWpZ6fJmOHTuqNJBaSfdEyr6vcXFxsLa2lrtfAxTL4LKOTSqGgu5awMjICFZWVtwgDUXJbqBLGqBBIBAo3OhKJBJ069YNKSkp+P777+Hs7Aw9PT28efMGo0aNqtD8yzKyYwwfPlxpf0zgf/1RZTQ0NJRux4oN8lCZZHnq5OQEoDDd5ubm+OOPP5RuLxvMisfj4eDBg7h16xb+/vtvnDlzBmPGjMGaNWtw69YtlfuISaVS8Hg8nDp1Sun1Fz9OdeRRSYrnXVpaGjp16gRDQ0MsXrwYjo6O0NHRwYMHD/D999+r9LnavXs3Ro0ahX79+mHWrFkwNzeHhoYGVqxYgZiYmFL3Vff8NSkvK0J2XUFBQfDz81O6jew9qmxDhw7Fli1bYGBggEGDBpU56nFlqc5rJqQ2ovsIuo+Qqa6yz9DQEN26dUO3bt2gpaWF0NBQ3L59W6GPdGUp/mBB3XwqTiAQoF+/fjhy5Ag2b96MpKQk3LhxA8uXL5fbbtq0aejduzf++usvnDlzBvPnz8eKFStw8eJFeHp6VvzC/l9JtdzKvq+VdWxSMRR01xI9e/bEr7/+ijt37sg1DS2PiIgIPH/+HKGhoRgxYgS3vHiTV9k8nS9evFA4xrNnz0o9h5mZGQwMDCCRSNC1a9cKpbeo4j+iFZGVlYUjR47A1taWe9rn6OiI8+fPo3379ir96Hh7e8Pb2xvLli3Dnj17MGzYMOzduxfffvstHB0dcebMGaSkpJT4lNrR0RGMMTg4OHBPSiuqMvOoNLt27QKPx0O3bt0AFI6o+eHDBxw+fBgdO3bktouNjVU5jQcPHkSjRo1w+PBhuW2UNa0rTp3zq8rOzg5PnjwBY0wuPWV9/iuipLwpaXmjRo0AFD6lL+u7ZmdnV67vc0mGDh2KBQsWICEhQW7gN2Xnffz4MaRSqdzNgKzJv+y3RjaVUVZWltwNUPH0qXPNhJBCdB9RiO4jylbV9xGtWrVCaGgoEhISlK6XfW6UfUaePn2K+vXrK0yD9eLFC7ka2pcvX0IqlXKDgFVGPg0aNAihoaG4cOECoqOjwRjjmpYX5ejoiJkzZ2LmzJl48eIFWrRogTVr1mD37t3lOm9F2dnZ4fz588jMzJSr7S5eBpOqRX26a4nZs2dDV1cXY8aMQVJSksJ6dZ5Qyp7wFd2HMYaffvpJbjsrKyu0aNECoaGhck1zz507h6ioqDLPMWDAABw6dEjpk/V3796pnN6i9PT0VG6mXJrc3Fx88803SElJwX//+1+ugBk4cCAkEgmWLFmisI9YLOamLkpNTVXIc9nI2rLppAYMGADGGBYtWqRwLNm+X375JTQ0NLBo0SKF4zHG8OHDB7WvTVYQKZtmqbKmDPvhhx9w9uxZDBo0iGuqpexzlZ+fj82bNytNo7L3Udkxbt++jZs3b5aZJnXOr6oePXrg7du3OHjwILcsJyenxKaOlaGk9082YnDx5ebm5vD19cXPP/+s9Aam6HetR48euHXrFu7cuSO3vqQambI4Ojpi/fr1WLFiRak38T169EBiYqLcnO5isRgbN26Evr4+V9PRo0cPiMVibNmyhdtOIpFg48aNcsdT55oJIYXoPqIQ3UeUrTLuI3Jyckosu2V9iEvq2lT0c1M0DU+ePMHZs2fRo0cPhX2Kj0UgKzdks5FURj517doVpqam2LdvH/bt24c2bdrIBfo5OTkK05Q5OjrCwMCg0qYaLY8ePXpAIpFg06ZNcsvXrVsHHo/H5RGpWlTTXUs0btwYe/bswZAhQ9C0aVMMGzYMHh4eYIwhNjYWe/bsAZ/PV2kKDmdnZzg6OiIoKAhv3ryBoaEhDh06pLTP04oVK9CzZ0989tlnGDNmDFJSUrBx40a4ubkp7RtW1A8//IBLly6hbdu2GDduHFxdXZGSkoIHDx7g/PnzSqdFKEvLli2xb98+zJgxA61bt4a+vj569+5d6j5v3rzhni5mZWUhKioKBw4cQGJiImbOnIkJEyZw23bq1AkTJkzAihUr8PDhQ3zxxRfQ0tLCixcvcODAAfz000/46quvEBoais2bN6N///5wdHREZmYmfvnlFxgaGnKFQefOnfHNN99gw4YNePHiBfz9/SGVSnHt2jV07twZgYGBcHR0xNKlSzF37ly8evUK/fr1g4GBAWJjY3HkyBGMHz8eQUFBauWRo6MjjI2NsXXrVhgYGEBPTw9t27aFg4OD2lOGicViLu/y8vIQFxeHY8eO4fHjx+jcubNc8Onj4wMTExOMHDkSU6dOBY/Hw65du5TeyJX0Pvbq1QuHDx9G//790bNnT8TGxmLr1q1wdXUt8/OmzvlVNW7cOGzatAkjRozA/fv3YWVlhV27dnEBcFVo2bIlAGDq1Knw8/ODhoYGBg8eDKFQCFdXV+zbtw9NmjSBqakpmjVrhmbNmiEkJASfffYZ3N3dMW7cODRq1AhJSUm4efMmXr9+jUePHgEovOnetWsX/P398d1333FThslqostDNt1XacaPH4+ff/4Zo0aNwv3792Fvb4+DBw/ixo0bWL9+PffkvXfv3mjfvj3mzJmDV69ewdXVFYcPH1Z6g6zqNRNCCtF9RCG6jyhbZdxH5OTkwMfHB97e3vD394etrS3S0tLw119/4dq1a+jXr1+pza1XrVqF7t27o127dhg7diw3ZZiRkZHS88bGxqJPnz7w9/fHzZs3sXv3bgwdOhQeHh7cNVU0n7S0tPDll19i7969yM7OxurVq+XWP3/+HF26dMHAgQPh6uoKTU1NHDlyBElJSRg8eHCpx5Y5ePCg0qbu3bp1g4WFhUrHKK53797o3Lkz/vvf/+LVq1fw8PDA2bNncfToUUybNg2Ojo7lOi5RU6WPh06q1MuXL9mkSZOYk5MT09HRYUKhkDk7O7OJEyeyhw8fym1b2pRPUVFRrGvXrkxfX5/Vr1+fjRs3jj169EjpFBGHDh1iLi4uTCAQMFdXV3b48GE2cuTIMqf6YIyxpKQkFhAQwGxtbZmWlhaztLRkXbp0Ydu2beO2kU1/cODAAbl9lU0hkZWVxYYOHcqMjY2VTjdSnJ2dHTflAo/HY4aGhszNzY2NGzdObtqk4rZt28ZatmzJhEIhMzAwYO7u7mz27Nns7du3jDHGHjx4wIYMGcIaNmzIBAIBMzc3Z7169WL37t2TO45YLGarVq1izs7OTFtbm5mZmbHu3bsrTJlx6NAh9tlnnzE9PT2mp6fHnJ2dWUBAAHv27Bm3TadOnZibm5tCWpW9F0ePHmWurq5MU1NTLg/VnTJMlncAmK6uLrO3t2cDBgxgBw8eZBKJRGGfGzduMG9vbyYUCpm1tTWbPXs2O3PmjMKUTSW9j1KplC1fvpzZ2dkxgUDAPD092fHjx5VeozKqnl+dvIyLi2N9+vRhurq6rH79+uy7777jpn5RdcqwkqaEUfYZF4vFbMqUKczMzIzxeDy56cPCwsJYy5Ytmba2tsL7GBMTw0aMGMEsLS2ZlpYWs7GxYb169WIHDx6UO+fjx49Zp06dmI6ODrOxsWFLlixhv/32m9pThpUGxaYMY6zwt2D06NGsfv36TFtbm7m7uyudjubDhw/sm2++YYaGhszIyIh988033PR0xbdX5ZppyjBC5NF9BN1HFFcV9xEFBQXsl19+Yf369ePKdF1dXebp6clWrVolN7WbsveJMcbOnz/P2rdvz4RCITM0NGS9e/dmUVFRctvIyqWoqCj21VdfMQMDA2ZiYsICAwNZbm6uQrpUyafSnDt3jvss/Pvvv3Lr3r9/zwICApizszPT09NjRkZGrG3btnLTjpaktCnDipZhJX3WGSv9+5qZmcmmT5/OrK2tmZaWFmvcuDFbtWoVN/WcjLLym1QOHmO1bNQgQgghhBBCyCcvODgYixYtwrt371Qa9ZuQ6kJ9ugkhhBBCCCGEkCpCQTchhBBCCCGEEFJFKOgmhBBCCCGEEEKqCPXpJoQQQgghhBBCqgjVdBNCCCGEEEIIIVWEgm5CCCGEEEIIIaSKUNBNCCGEEEIIIYRUEc3qTkBNIJVK8fbtWxgYGIDH41V3cgghhHxCGGPIzMyEtbU1+Hx6Fq4uKsMJIYRUF5XLcFaNrly5wnr16sWsrKwYAHbkyBG59VKplM2fP59ZWloyHR0d1qVLF/b8+XO5bT58+MCGDh3KDAwMmJGRERszZgzLzMxUKx3//vsvA0B/9Ed/9Ed/9Fdtf//++29Fi9VPEpXh9Ed/9Ed/9Ffdf2WV4dVa052dnQ0PDw+MGTMGX375pcL6lStXYsOGDQgNDYWDgwPmz58PPz8/REVFQUdHBwAwbNgwJCQk4Ny5cygoKMDo0aMxfvx47NmzR+V0GBgYAAD+/fdfGBoaVs7FVROpVIp3797BzMyMakzKQHmlHsov1VFeqY7yCsjIyICtrS1XFhH1VGYZTp9H1VFeqYfySz2y/OrUqRMSEhJgZWWFp0+fVneyaiz6fKmnMvNL1TK8WoPu7t27o3v37krXMcawfv16zJs3D3379gUA7Ny5ExYWFvjrr78wePBgREdH4/Tp07h79y5atWoFANi4cSN69OiB1atXw9raWqV0yJqjGRoa1omgOy8vD4aGhvSlKwPllXoov1RHeaU6yqv/oabR5VOZZTh9HlVHeaUeyi/1yPJLlld8Pr/W36NXJfp8qacq8qusMrzG9umOjY1FYmIiunbtyi0zMjJC27ZtcfPmTQwePBg3b96EsbExF3ADQNeuXcHn83H79m30799f6bFFIhFEIhH3OiMjA0DhGyCVSqvoij4OqVQKxlitv46PgfJKPZRfqqO8Uh3lFT7payeEkNJs3rwZIpEIQqGwupNCSIXU2KA7MTERAGBhYSG33MLCgluXmJgIc3NzufWampowNTXltlFmxYoVWLRokcLyd+/eIS8vr6JJr1ZSqRTp6elgjNGTrjJQXqmH8kt1lFeqo7wCMjMzqzsJhBBSI/Xq1euTLRtI3VJjg+6qNHfuXMyYMYN7LWuLb2ZmVuubrkilUvB4POrToQLKK/VQfqmO8kp1lFfgxighhBBCSN1UY4NuS0tLAEBSUhKsrKy45UlJSWjRogW3TXJystx+YrEYKSkp3P7KCAQCCAQCheV8Pr/Emz6pVIr8/Hx1L+Ojk0qlEIvFyM/P/2RvYFVFeaWeup5f2tralXpdPB6v1N8U8j+fel59qtf9MUkkEhQUFJS5nVQqRUFBgVxfUqIc5ZV66mJ+VXa5SUhdVmODbgcHB1haWuLChQtckJ2RkYHbt29j0qRJAIB27dohLS0N9+/fR8uWLQEAFy9ehFQqRdu2bSstLfn5+YiNja0V/e5kfSMzMzNpUJ4yUF6pp67nF5/Ph4ODA7S1tas7KYSQSsIYQ2JiItLS0lTevi7/zlUmyiv11MX8+hjl5v379yEWi6Gtrc3d6xNSG1Vr0J2VlYWXL19yr2NjY/Hw4UOYmpqiYcOGmDZtGpYuXYrGjRtzU4ZZW1ujX79+AAAXFxf4+/tj3Lhx2Lp1KwoKChAYGIjBgwerPHJ5WRhjSEhIgIaGBmxtbWv8Ez3GGMRiMTQ1NevMj3pVobxST13OL6lUirdv3yIhIQENGzasc9dHyKdKFnCbm5tDV1e3zO92Xf6dq2yUV+qpa/n1scrN/v37482bN7CxscHr16+r5ByEfAzVGnTfu3cPnTt35l7L+lmPHDkSO3bswOzZs5GdnY3x48cjLS0Nn332GU6fPi3X/+2PP/5AYGAgunTpAj6fjwEDBmDDhg2VlkaxWIycnBxYW1tDV1e30o5bVeraj3pVorxST13PLzMzM7x9+xZisRhaWlrVnRxSQ0mlUkRGRiI1NRUmJiZwc3Or8Q9jP1USiYQLuOvVq6fSPnX9d64yUV6ppy7mF5WbhKiuWoNuX19fMMZKXM/j8bB48WIsXry4xG1MTU2xZ8+eqkgegMJCGwA1OSWkjpN9xyUSCd08EKXCwsKwadMmREdHQyQSQSAQwMXFBYGBgfDx8anu5JFiZH24a8MDc0JqIyo3CVEdPZ5XUV15KkkIUY6+46Q0YWFhCAoKwoMHD2BsbAx7e3sYGxsjPDwcQUFBCAsLq+4kkhLQd5uQqkHfLUJUR0E3qXWCg4O5wfUIIaSqSaVSbNq0CSkpKXBycoK+vj40NDSgr68PR0dHpKamIiQkpFYMtklKJpVKkZubq9Io56R6McYwfvx4mJqagsfj4eHDh9WWllevXlV7GgghNR8F3XXU6NGjwePxwOPxoKWlBQsLC3Tr1g2///672jeGO3bsgLGxcdUktByCgoJw4cIFtfaxt7fH+vXrqyZBhJA6LTIyEtHR0bCyslKo2eHxeLC0tERUVBQiIyOrKYWkomT9v3NzcyESiao1LbKyu6S/4ODgak1fTXD69Gns2LEDx48fR0JCApo1a/ZRzjtq1ChuMF8ZW1vbj5oGQkjtVGOnDCMV5+/vj+3bt0MikSApKQmnT5/Gd999h4MHD+LYsWPQ1Kydb7++vj709fWrOxmEkE9EamoqRCIRhEIhGGPIyMhAeno6AMDIyAh6enoQiURITU2t5pSS8uLz+dDQ0IBYLIZEIqnWgaESEhK4/+/btw8LFizAs2fPuGVFyz/GGCQSSY0pzyUSCXg8nsLggvn5+eUaG6ek/WJiYmBlZVUjxlLQ0NCApaVldSeDEFLDUU33RyKVShEREYGrV68iIiLiozRDFAgEsLS0hI2NDby8vPCf//wHR48exalTp7Bjxw5uu7Vr18Ld3R16enqwtbXF5MmTkZWVBQC4fPkyRo8ejfT0dIWn7Lt27UKrVq1gYGAAS0tLDB06FMnJyaWmyd7eHkuWLMGQIUOgp6cHGxsbhISEyG0THx+Pvn37Ql9fH4aGhhg4cCCSkpK49cWbl8uePK9evRpWVlaoV68eAgICuCaCvr6+iIuLw/Tp07lrAIC4uDj069cPpqam0NPTg5ubG06ePFne7CaE1FEmJiYQCARITEzE7du3cfPmTTx58gRPnjzBzZs3cevWLYjFYpiYmFR3Ukk58Xg8CAQC7nV11nZbWlpyf0ZGRlxrCktLSzx9+hQGBgY4deoUWrZsCYFAgOvXryutgZ02bRp8fX2511KpFCtWrICDgwOEQiE8PDxw8ODBUtMiEokQFBQEGxsb6OnpoW3btrh8+TK3fufOnTAxMcGxY8fg6uoKgUCA+Ph4rqwfMWIEDA0NMX78eADAoUOH4ObmBoFAAHt7e6xZs0bufCXtV9SoUaMwZcoUxMfHg8fjwd7entu3eIu2Fi1ayLUM4PF4+PXXX9G/f3/o6uqicePGOHbsmNw+kZGR6NWrFwwNDWFgYIAOHTogJiYGwcHBCA0NxdGjR7l7icuXLyttXn7lyhW0adMGAoEAVlZWmDNnDsRiMbfe19cXU6dOxezZs2FqagpLS0tqwUBIHUdB90cQFhaG4cOHY8SIEZg4cSJGjBiB4cOHV8vAO59//jk8PDxw+PBhbhmfz8eGDRsQGRmJ0NBQXLx4EbNnzwYA+Pj4YP369TA0NERCQgISEhIQFBQEoHBk2CVLluDRo0f466+/8OrVK4waNarMNKxatQoeHh4IDw/HnDlz8N133+HcuXMACm8K+vbti5SUFFy5cgXnzp3DP//8g0GDBpV6zEuXLiEmJgaXLl1CaGgoduzYwT1YOHz4MBo0aIDFixdz1wAAgYGByM/Px5UrVxAREYEff/yRatAJqaWq8sGmm5sb6tevj8jISKSkpEAqlXI1o1KpFOnp6UhKSuJqv0ntJBAIuIey+fn5NbqP/pw5c/DDDz8gOjoazZs3V2mfFStWYOfOndi6dSsiIyMxffp0DB8+HFeuXClxn8DAQNy8eRN79+7F48eP8fXXX8Pf3x8vXrzgtsnJycGPP/6IX3/9FZGRkTA3NwcArF69mivr58+fj/v372PgwIEYPHgwIiIiEBwcjPnz58tVAijbr7iffvoJixcvRoMGDZCQkIC7d++qdP0yixYtwsCBA/H48WP06NEDw4YNQ0pKCgDgzZs36NixIwQCAS5evIj79+9jzJgxEIvFCAoKwsCBA+Hv78/dSyiraX/z5g169OiB1q1b49GjR9iyZQt+++03LF26VG670NBQ6Onp4fbt21i5ciUWL17M3QsRQuqemtEeqQ6TjXibkpICKysrCIVC5ObmciPerl69+qM3j3J2dsbjx4+519OmTeP+b29vj6VLl2LixInYvHkztLW15Z60FzVmzBju/40aNcKGDRvQunVrZGVllRq8tm/fHnPmzAEANGnSBDdu3MC6devQrVs3XLhwAREREYiNjYWtrS2Awifpbm5uuHv3Llq3bq30mCYmJti0aRM0NDTg7OyMnj174sKFCxg3bhxMTU2hoaHB1cjLxMfHo1+/fnB3dwePx0OjRo1Uz0RCSI3xsabyEovFkEql0NLSAo/H46a85PF4EIvF2Lx5M3x8fGje7hru9OnTyMvLU7pO1rwcADQ1NaGhoVFp59XR0YG/v3+lHGvx4sXo1q2bytuLRCIsX74c58+fR7t27QAUltvXr1/Hzz//jE6dOinsEx8fj+3btyM+Ph7W1tYACsdUOX36NLZv345ly5YBKHwAv3nzZnh4eMjt//nnn2PmzJnc62HDhqFLly5cIN2kSRNERUVh1apVcg/si+9XnJGREQwMDMrdrHvUqFEYMmQIAGD58uXYsGED7ty5A39/f4SEhMDIyAh79+7luhc0adKE21coFEIkEpV63s2bN8PW1habNm0Cj8eDs7Mz3r59i++//x7/+c9/uO2aN2+OhQsXAgAaN26MTZs24cKFC2q9r4SQ2oOC7ipUfMRb2RN02Yi3MTExCAkJgbe390e9SWOMyQ0GdP78eaxYsQJPnz5FRkYGxGIx8vLykJOTU+r8pvfv30dwcDAePXqE1NRUrlYgPj4erq6uJe4nK/CLvpY1CYuOjoatrS0XcAOAq6srjI2NER0dXWLQ7ebmJndzZGVlhYiIiJIzAcCUKVMwefJkXLhwAV27dsWAAQNUrjEghNQMH+PBZmRkJP79918IBAJIJBJIpVJIpVJuoErZ8gcPHiAyMhLu7u6VdHWkKuTl5SE3N1fpOqlUyjUD5vF40NTUrJHTIrVq1Uqt7V++fImcnByFgC4/Px+enp5K94mIiIBEIpELOoHCAL5evXrca21tbaVlZ/E0RkdHo2/fvnLL2rdvj/Xr10MikXBluLrXpq6iadXT04OhoSHXNe7hw4fo0KFDhfrzR0dHo127dnKfm/bt2yMrKwuvX7/mHvAXzzMrK6syu+h9iiIjI+W6BhJSW1HQXYXUGfH2Y96kRUdHw8HBAUDhVBe9evXCpEmTsGzZMpiamuL69esYO3Ys8vPzSwy6s7Oz4efnBz8/P/zxxx8wMzNDfHw8/Pz8kJ+f/9GuRaZ4Acnj8cpsGvjtt9+iS5cuOHPmDM6dO4cVK1ZgzZo1mDJlSlUmlRBSST7Wg83U1FTk5eWBz+dDX18fEomEe3ipqakJxhhycnKQl5dHg6nVAjo6OqWuz8/P51oxaGlpVdpD8bLOqw49PT2513w+n0uzTNGpz2TjtJw4cQI2NjZy2xXty15UVlYWNDQ0cP/+fYUa/6Kt2YRCodKAqHgaVVXe/crKA5nS7heEQmG5zl0e5blv+RQZGBhQ6yFSJ1DQXYWKjnirjFAoRFJS0ke9Sbt48SIiIiIwffp0AIW11VKpFGvWrOF+1Pbv3y+3j7a2NtfcTubp06f48OEDfvjhB65W+t69eyql4datWwqvXVxcAAAuLi74999/8e+//3LHjYqKQlpaWqm152VRdg1A4VQfEydOxKRJkzB37lz88ssvFHQTUkt8rAebJiYmXMAklUqhqamJVgUFMJRIcFFDg/tt0dHRocHUaoHSmngzxpCbm8vVhGtra8PAwOBjJa3czMzM8OTJE7llDx8+5AK7ooOcKWtKroynpyckEgmSk5PRoUMHhfXFA9yyuLi44MaNG3LLbty4gSZNmlRKM34zMzO5kd8zMjIQGxur1jGaN2+O0NBQFBQUKK3tLuleoigXFxccOnRIrlXhjRs3YGBggAYNGqiVHkJI3UGPjqqQbMTbkpqx5ebmQiAQVNlNmkgkQmJiIt68eYMHDx5g+fLl6Nu3L3r16oURI0YAAJycnFBQUICNGzfin3/+wa5du7B161a549jb2yMrKwsXLlzA+/fvkZOTg4YNG0JbW5vb79ixY1iyZIlK6bpx4wZWrlyJ58+fIyQkBAcOHMB3330HAOjatSvc3d0xbNgwPHjwAHfu3MGIESPQqVOnCjU5s7e3x9WrV/HmzRu8f/8eQGFf9rNnzyI2NhYPHjzApUuXuOCfEFLzqfJgszKm8nJzc4Onpyf4fD4McnKQlJyME6mp+DM9Hf3y8iASiaChoQEvLy+4ublV6Fyk+mlqanIPoQsKCsoMsmqCzz//HPfu3cPOnTvx4sULLFy4UC4INzAwQFBQEKZPn47Q0FDExMTgwYMH2LhxI0JDQ5Ues0mTJhg2bBhGjBiBw4cPIzY2Fnfu3MGKFStw4sQJtdM4c+ZMXLhwAUuWLMHz588RGhqKTZs2cYOzVtTnn3+OXbt24dq1a4iIiMDIkSPVDuYDAwORkZGBwYMH4969e3jx4gV27drFTdlmb2+Px48f49mzZ3j//r3SmvTJkyfj33//xZQpU/D06VMcPXoUCxcuxPTp06nGlpBPGH37q5CbmxtcXFyQmJio8ESYMYbExES4urpW2U3a6dOnYWVlBXt7e/j7++PSpUvYsGEDjh49yhVEHh4eWLt2LX788Uc0a9YMf/zxB1asWCF3HB8fH0ycOBGDBg2CmZkZVq5cCTMzM+zYsQMHDhyAq6srfvjhB6xevVqldM2cORP37t2Dp6cnli5dirVr18LPzw9AYe3U0aNHYWJigo4dO6Jr165o1KgR9u3bV6G8WLx4MV69egVHR0eYmZkBKJxP9LvvvoOrqyv8/f3RpEkTbN68uULnIYR8PB/rwSafz8eUKVOwRChEbLFzpYhEkEgkaNiwIQIDA+mmug4oOn0YY6xapw9TlZ+fH+bPn4/Zs2ejdevWyMzM5B6uyyxZsgTz58/HihUr4OLiAn9/f5w4cYLrbqbM9u3bMWLECMycORNNmzZFv379cPfuXTRs2FDtNHp5eWH//v3Yu3cvmjVrhgULFmDx4sUqzXqiirlz56JTp07o1asXevbsiX79+sHR0VGtY9SrVw8XL15EVlYWOnXqhJYtW+KXX37har3HjRuHpk2bolWrVjAzM1OouQcAGxsbnDx5Enfu3IGHhwcmTpyIsWPHYt68eZVynZ+adevWITg4GGvXrq3upBBSITymbvugOigjIwNGRkZIT0+HoaGh3Lq8vDzExsbCwcGhXP2xZIP8pKamwtLSkhvkJzExESYmJpU+ejljDGKxuMYO/mJvb49p06bJjZheXWp6XtU0dT2/KvpdL0oqlSI5ORnm5uYUhJWhInkllUoxfPhwhIeHw9HRUe5zyRhDTEwMvLy8sGvXroq9D4wBJexvYmSE1m3aIDg4uNy/5aWVQaRsJeVfeb7Tst85Pp+P9PR0MMbA5/NhbGxcJ3/3KqKulwmVrS7mV2WWm8XJyoZWrVrhzZs3sLGxwevXryv1HHUJ3XeopzLzS9UynN6VKubj44PVq1fD09MTaWlpePXqFdLS0uDl5VUt04URQkhdwefzERgYCBMTE8TExCArKwsSiQRZWVmIiYmBiYkJAgICKlaghocrDbgf9eyJ7b//jstXruD06dP0W17H8Pl8rnZTKpUqbUZMCCGEqIoGUvsIfHx84O3tjcjISKSmpsLExARubm70JIoQQirIx8cHK1euxPLly/HixQtIJBIYGhrCy8sLAQEBFQuG+/UDjh5VXP7vv/Bo0AAeimtIHaKjo8PNxpGXlwdtbe1qThEhhJDaiqK+j4TP58Pd3R0dO3aEu7v7Jxtwv3r1qkY0LSeE1A1hYWHYvHkz3r59y831a21tjUmTJpU/4M7LA3g8xYBbX7+wqfknMgLxmzdvMHz4cNSrVw9CoRDu7u5ys1QwxrBgwQJufvSuXbvixYsXcsdISUnBsGHDYGhoCGNjY4wdO5abvkrm8ePH6NChA3R0dGBra4uVK1d+lOsri6amJjf+SW0ZUI0QQkjN9GlGfoQQQmo92ZgZDx48gImJCZydndGgQQPExsZi9uzZCAsLU/+gBw8CykZD37sXyMyseKJridTUVLRv3x5aWlo4deoUoqKisGbNGrlB6VauXIkNGzZg69atuH37NvT09ODn54e8vDxum2HDhiEyMhLnzp3D8ePHcfXqVYwfP55bn5GRgS+++AJ2dna4f/8+Vq1aheDgYGzbtu2jXq8yRQdUAyB3XYQQQog6qHk5IYSQKieVSiu1i41UKsWmTZuQkpICJycnbmAifX19ODo6IiYmBiEhIfD29lb9PKamgLLpxXJylAfiddiPP/4IW1tbbN++nVtWdJRrxhjWr1+PefPmoW/fvgCAnTt3wsLCAn/99RcGDx6M6OhonD59Gnfv3uWmfNy4cSN69OiB1atXw9raGn/88Qfy8/Px+++/Q1tbG25ubnj48CHWrl0rF5xXF9no+LJRzHV1devMIFiEEEI+Hgq6CSGEVKmwsDBs2rQJ0dHREIlEEAgEcHFxQWBgILy9vct1zMjISERHR8PKykohCOLxeLC0tERUVBQiIyPh7u5e+sGiogBlUzf27AkcP16u9NV2x44dg5+fH77++mtcuXIFNjY2mDx5MsaNGwcAiI2NRWJiIrp27crtY2RkhLZt2+LmzZsYPHgwbt68CWNjYy7gBoCuXbuCz+fj9u3b6N+/P27evImOHTvK9Zf28/PDjz/+yD2gKU4kEslN45WRkQGg8EGMVCrllkulUjDGuD9VybZljIHH40FbWxsikYgLvIvWfn/qiuYVKVtdyy/Zd6v4d68yyL6/xZcR5WT5RXmkmsrML1WPQUE3IYSQKiNrAp6SksL1/c3NzUV4eDiCgoKwatUqtefSBQqbP4tEIghLqIEWCoVISkpCqrKa66Lc3AqD7uLu3QNatlQ7XXXFP//8gy1btmDGjBn4z3/+g7t372Lq1KnQ1tbGyJEjkZiYCACwsLCQ28/CwoJbl5iYCHNzc7n1mpqaMDU1ldum+DzRsmPKptYsbsWKFVi0aJHC8nfv3sk1AS8oKIBUKoVYLIZYLFbpuhljXN9t2cMcDQ0N7uY/NzeX6+f9qVOWV6RkdTG/xGIxpFIpPnz4wI32X1mkUinS09O5PJNN8USUk+WXbJpDUrrKzK9MFbueUdBNCCGkSqjSBHzLli3lGjjLxMSEa/qrr6+vsD43NxcCgUBp0Pb/iQNKCp6k0sKB1D5hUqkUrVq1wvLlywEAnp6eePLkCbZu3YqRI0dWa9rmzp2LGTNmcK8zMjJga2sLMzMzhXm6MzMzoampCU1N9W53igYQmpqayM/P5wIM2TJSqLKDrbquLuWXpqYm+Hw+6tWrVyXzdPN4PO4hF5/PV3iIR/5Hll9mZmYUdKugMvNL1c8+lRqEEEKqhCpNwKOjoxEfHw9LS0u1ju3m5gYXFxeEh4fD0dFR7viMMSQmJsLLywtuypqN798PDBqkuLxZMyAiQq101FVWVlZwdXWVW+bi4oJDhw4BAPd+JSUlwcrKitsmKSkJLVq04LYpXjMlFouRkpLC7W9paYmkpCS5bWSvS/pMCAQCpU28+Xy+3M0Tn88Hj8fj/lQha1IOyNdGCgQCrrZcJBLVqcCpvErKK6JcXcwv2Xer+HevMo/v6enJPVSjYLJ0Vfle1EWVlV+q7k/vCiGEkCqhShNwkUikMIWUKvh8PgIDA2FiYoKYmBhkZWVBLBYjMTEREREREAgEmDRpkmJhyOMpD7ijokoNuKVSKSIiInD16lVERETU+X5z7du3x7Nnz+SWPX/+HHZ2dgAKB1WztLTEhQsXuPUZGRm4ffs22rVrBwBo164d0tLScP/+fW6bixcvQiqVom3bttw2V69eRUFBAbfNuXPn0LRp05JbKVQDgUDAfZby8/Pr7Ps/atQo9OvXj3vt6+tbo6b5rGnpqUlevXoFHo+Hhw8fVndSKtXRo0dx8+ZNHDt2rLqTQkiFUNBNKlVNL7A/Bfn5+XBycirfdEl11OnTp9GiRYs6e6NcUxVtAq6MrAm4subhqvDx8cHq1avh6emJN2/eICwsDE+ePMGHDx/w/v17LF++HNevXy/cODW15CbjjAEuLiWeJywsDMOHD8eIESMwceJEjBgxAsOHD6/T37Hp06fj1q1bWL58OV6+fIk9e/Zg27ZtCAgIAFBYQzBt2jQsXboUx44dQ0REBEaMGAFra2uuDHBxcYG/vz/GjRuHO3fu4MaNGwgMDMTgwYNhbW0NABg6dCi0tbUxduxYREZGYt++ffjpp5/kmo/XBEWnD5MNqFbVEhMT8d1338HJyQk6OjqwsLBA+/btsWXLFuTk5FT5+QHg8OHDWLJkSaUes/h9Ql22Y8cOGBsbf5Rz2draIiEhAc2aNVN5n+DgYK5lCiGkalHQXYd96gX2qFGjuKZPWlpasLCwQLdu3fD777/XuuBLnYJx69atcHBwgI+PT9Umqpht27bB19cXhoaG4PF4SEtLU2m/kJAQ2NvbQ0dHB23btsWdO3fUPm6fPn3QsGFD6OjowMrKCt988w3evn3Lrff394eWlhb++OOPilwiUZOsCXhiYqLCKLSyJuAuLi5o2LBhuc/h4+ODyZMnQygUQkdHh5vSKTU1FRcvXkS/fv3wxNe3cDqw4r7/vjDgLkXRucCNjY1hb28PY2NjbiC4uhp4t27dGkeOHMGff/6JZs2aYcmSJVi/fj2GDRvGbTN79mxMmTIF48ePR+vWrZGVlYXTp0/L9W/7448/4OzsjC5duqBHjx747LPP5ObgNjIywtmzZxEbG4uWLVti5syZWLBgQY2YLqy44nN2V+UI1P/88w88PT1x9uxZLF++HOHh4bh58yZmz56N48eP4/z58yXuW7TVQEWZmprCwMCg0o5Hqo6GhgYsLS1pvAFCaigKuusoKrAL+fv7IyEhAa9evcKpU6fQuXNnfPfdd+jVq5fKo9nWJowxbNq0CWPHjv3o587JyYG/vz/+85//qLzPvn37MGPGDCxcuBAPHjyAh4cH/Pz85PqBqnLczp07Y//+/Xj27BkOHTqEmJgYfPXVV3LbjBo1Chs2bFD/wki5KWsCLpFIkJWVhZiYGJiYmChvAq4GqVSKzZs3Iy0tDfn5+dyUTnp6etDT08P7Dx/Q7MoVxR0zMoAffijz2EUHgtPX14eGhgY3EFxqaipCQkJq3UM8VfXq1QsRERHIy8tDdHQ0N12YDI/Hw+LFi5GYmIi8vDycP38eTZo0kdvG1NQUe/bsQWZmJtLT0/H7778rtGxo3rw5rl27hry8PLx+/Rrff/99lV9beWhoaHBTm0mlUuTn51fZuSZPngxNTU3cu3cPAwcOhIuLCxo1aoS+ffvixIkT6N27N7ctj8fDli1b0KdPH+jp6WHZsmWQSCQYO3YsHBwcIBQK0bRpU/z0009y55BIJJgxYwaMjY1Rr149zJ49W+FBQvHWaiKRCEFBQbCxsYG+vj7at2+Py5cvc+tlNbtnzpyBi4sL9PX1uXIYKHyAHBoaiqNHj3IPxYvuX1R2djZGjBgBfX19WFlZYc2aNQrbFE2Pnp4e2rZtK3e8uLg49O7dGyYmJtDT04ObmxtOnjzJrY+MjESvXr1gaGgIAwMDdOjQATExMdz6X3/9FS4uLtDR0YGzszM2b97MrZM15z58+DA6d+4MXV1deHh44ObNmwCAy5cvY/To0UhPT+f6ji5evFjptcoerP/888+wtbWFrq4uBg4ciPT0dG4bqVSKxYsXo0GDBhAIBGjRogVOnz6tkB5Z8/LLly+Dx+PhwoULaNWqFXR1deHj48N1G9mxYwcWLVqER48ece/Fjh07wBhDcHAwGjZsCIFAAGtra0ydOlVpugkhamCEpaenMwAsPT1dYV1ubi6Liopiubm51ZAy9UmlUpafn8/8/PxYgwYNWFZWVonbyQBgmzdvZr1792a6urps4cKFTCwWszFjxjB7e3umo6PDmjRpwtavXy93DLFYzKZPn86MjIyYqakpmzVrFhsxYgTr27cvt02nTp3Yd999x73Oy8tjM2fOZNbW1kxXV5e1adOGXbp0iVu/fft2ZmRkxE6fPs2cnZ2Znp4e8/PzY2/fvmWMMbZw4UIGQO6v6P5FjRw5Ui4tMhcuXGAA2LZt21h+fj6TSqUsNTWVjR07ltWvX58ZGBiwzp07s4cPH3L7PHz4kPn6+jJ9fX1mYGDAvLy82N27d7n1169fZ506dWJCoZAZGxuzL774gqWkpDDGGJNIJGz58uVcXjZv3pwdOHCA2/fSpUsMADt//jxr2bIlEwqFrF27duzp06dcnhS/5u3btyu95rt37zI+n88yMjK4ZbGxsQwA27dvH/vss8+Yjo4Oa9WqFXv27Bm7c+cOa9myJdPT02P+/v4sOTlZ6XEZ+99nq+hnRxnZ9aSmppa6HWOMtWnThgUEBHCvJRIJs7a2ZitWrKjQcY8ePcp4PB7Lz8/nlsXFxTEA7OXLl0r3qczvukQiYQkJCUwikVT4WHXBjRs32JAhQ1iLFi2Yi4sLa9GiBRs6dCi7ceNGhfPq8ePHzMPDg5mbmzM9PT1mbm7OzM3Nma+JCWOF9diKf2ocu0WLFszX15f16tVL4c/X15e1aNGCPX78uFxplymtDCJlKyn/yvOdVvo7l53N2C+/MNa1K5M6OzNRp04sc906lp6QUFmXIOf9+/eMx+Mp/R1UBgAzNzdnv//+O4uJiWFxcXEsPz+fLViwgN29e5f9888/bPfu3UxXV5ft27eP2+/HH39kJiYm7NChQywqKoqNHTuWGRgYlFqGf/vtt8zHx4ddvXqVvXjxgv3www9MIBCw58+fM8YKyystLS3WtWtXdvfuXXb//n3m4uLChg4dyhhjLDMzkw0cOJD5+/uzhIQElpCQwEQikdLrmjRpEmvYsCE7f/48e/z4MevVqxczMDAoMT0vX75kq1atkktPz549Wbdu3djjx49ZTEwM+/vvv9mVK1cYY4y9fv2amZqasi+//JLdvXuXPXv2jP3+++9c2bt7925mZWXFDh06xP755x926NAhZmpqynbs2MEY+1/Z6uzszI4fP86ePXvGvvrqK2ZnZ8cKCgqYSCRi69evZ4aGhiwhIYG9ffuWpaSkKC1DFy5cyPT09Njnn3/OwsPD2ZUrV5iTkxOXb4wxtnbtWmZoaMj+/PNP9vTpUzZ79mympaXFXassPeHh4Yyx/5WZbdu2ZZcvX2aRkZGsQ4cOzMfHhzHGWE5ODps5cyZzc3Pj3oucnBx24MABZmhoyE6ePMni4uLY7du32bZt25S+R1V5jywrG3r16sW8vb1Z7969K/0cdQndd6inMvNL1TKcgm5WjqC7ZUvGbGw+/l/LlmVei1QqZQkJCbWiwFZWQFZmgV1S0M0YYx4eHqx79+7czVXXrl1Z79692d27d9nz58/ZzJkzWb169diHDx8YY4y5ubmx4cOHs+joaPb8+XO2f/9+LigPDw9nAoGATZo0iT18+JA9efKEbdy4kb17944xxtjSpUuZs7MzO336NIuJiWHbt29nAoGAXb58mTFW/oJRmbVr1zJnZ2e5ZUVvDE6fPs2ioqKYt7c3a9myJfP19WXXr19nDx48YE5OTmzixIncfrt372Z6enql/l29elUhDaoGxyKRiGloaLAjR47ILR8xYgTr06dPuY/74cMHNnDgQNa+fXuFdRYWFiU+sKCgu2pJJBL2+PFjduXKFfb48WMubyqaV1euXGEODg7MwMCA1atXj5mbm7M4Pl9psB37009qH9vFxYV1795dadDdvXt35uLiwt3ElxcF3RVTpUF3djZjQ4YwZmXFmLU1kzZqxMSWlkxsYcHyvvySFVTBe3br1i0GgB0+fFhueb169bjf3tmzZ3PLAbBp06aVedyAgAA2YMAA7rWVlRVbuXIl97qgoIA1aNCgxDI8Li6OaWhosDdv3jDG/pdXXbp0YXPnzmWM/e8hcdGHmyEhIczCwoJ7XVrZLJOZmcm0tbXZ/v37uWUfPnxgQqGwxPTIFE2Pu7s7Cw4OVnqOuXPnMgcHB7mHs0U5OjqyPXv2yC1bsmQJa9euHWPsf2Xrr7/+yq2PjIxkAFh0dDRj7H8VCYyV/uB64cKFTENDg71+/ZpbdurUKcbn81nC/z/csba2ZsuWLZPbr3Xr1mzy5Mly6SkedJ8/f57b/sSJEwwA951YuHAh8/DwkDvmmjVrWJMmTUrMl6I+RtBtY2PDADAbG5tKP0ddQvcd6qmOoJs6fpRHYiLw5k11p6JEMTExYIyhadOmcsvr16+PvLw8AEBAQAB+/PFHbt3QoUMxevRoue0XLVrE/d/BwQE3b97E/v37MXDgQADA+vXrMXfuXHz55ZcACvsSnzlzpsR0xcfHY/v27YiPj+cG0QkKCsLp06exfft2bj7YgoICbN26FY6OjgCAwMBArkmWvr4+N+KxulMMFeXs7IzHjx8DAK5fv447d+4gOTmZ67O3evVq/PXXXzh48CDGjx+P+Ph4zJo1C87OzgCAxo0bc8dauXIlWrVqJdfsTDZNkUgkwvLly3H+/HluRN9GjRrh+vXr+Pnnn9GpUydun2XLlnGv58yZg549eyIvLw9CoRD6+vrQ1NQs85rj4uK4vC0uKCgIfn5+AIDvvvsOQ4YMwYULF9C+fXsAwNixY7Fjxw5u+z59+nAjDAOFTdfFYjE0NTW56U5sbGxKTU9p3r9/D4lEAgsLC7nlFhYWePr0qdrH+/7777Fp0ybk5OTA29sbx48fV9jG2toacXFx5U4zKT8+nw93d/dKP66JiQk0NDQgkUigyeMhsdgUVTKN7O2xo0UL2Kt57ArNBU5qvz17gMuXC8cE0NEBDwDP2BjS7Gxo3riBgp07oRkY+FGScufOHUilUgwbNkxhILdWrVopbB8SEoLff/8d8fHxyM3NRX5+Pjc2SHp6OhISEuR+4zU1NdGqVasS+6pHRERAIpEodCEQiUSoV68e91pXV5crv4HC6eeKTx1XlpiYGOTn58ulz9TUVO6+RpX0TJ06FZMmTcLZs2fRtWtXDBgwAM2bNwcAPHz4EB06dFA6/Vt2djZiYmIwduxYuW4VYrEYRkZGctvKjie7VgBITk7m7hdU1bBhQ7kytV27dpBKpXj27Bl0dXXx9u1brryWad++PR49elTqcUtKX0ljaXz99ddYv349GjVqBH9/f/To0QO9e/emvuKEVBB9g8qjAsFedZ73Uyqwy8KKzJf56NEjZGVlyaUBKLyhlvXtmjFjBr799lvs2rULXbt2xddff82l8eHDh/j666+Vnufly5fIyclBt27d5Jbn5+fD09NTbpm6BaMyubm5coMYlXR8WaBbNAiysLCQy2cDAwO5/vjKgu6aZNasWRg7dizi4uKwaNEijBgxAsePH5dLq1Ao/GiDCJKPw83NDY0bN8byf/7B10re29t8PvrUrw8rI6MSg2OpVIrIyEikpqbCxMQEbm5u4PP5FZsLnNQN+/YVjnpf5HeVJ3vN40Hj4EFIJ0+u1HlxnZycwOPxFKZsa9SoEQAonYJPT09P7vXevXsRFBSENWvWoF27djAwMMCqVatw+/btcqcrKysLGhoauH//PjQ0NOTKhKJlRfEglsfjVcmgc8XTU5TsIdm3334LPz8/nDhxAmfPnsWKFSuwZs0aTJkypcSpDGXHBoBffvlF7j4HgMK5il6v7DeiJo3zoG76bG1t8ezZM5w/fx7nzp3D5MmTsWrVKly5coXmpyekAijoLo9796o7BaWS3RzW9AK7qKK1SB+jwI6OjoaDgwOXLisrK6WDucim+ggODsbQoUNx4sQJnDp1CgsXLsTevXvRv39/lQruEydOKNQKFx0JF6icgrt+/fqIKGGuYWXHL76s6Pn++OMPTJgwodTznTp1Ch06dFArjUXTqqGhgaSkJLnlSUlJ5WrFUL9+fdSvXx9NmjSBi4sLbG1tcevWLa6FAQCkpKTAzMysXOklNROfz8fJU6eUrmsuFOJfgQCGOjpwc3NTGhyHhYVh06ZNiI6O5gZhc3FxQWBgIHx8fBAYGIigoCDExMTA0tISQqEQubm5SExMhImJCQICAio14CI1zJs3cgE3gMLabj4fEAjAS0godS768qhXrx66deuGTZs2YcqUKQrlsypu3LjBjewvU3SAMCMjI1hZWeH27dvo2LEjgMJa3Pv378PLy0vpMT09PSGRSJCcnIwOHTqU+0GstrY2JBJJqds4OjpCS0sLt2/f5h48p6am4vnz51yLsOLpKYmtrS0mTpyIiRMnYu7cufjll18wZcoUNG/eHKGhoSgoKFC477CwsIC1tTX++ecfuRH71aXKtcrEx8fj7du3XGu1W7dugc/no2nTpjA0NIS1tTVu3Lgh10Luxo0baNOmTaWnTygUonfv3ujduzcCAgLg7OyMiIiIEj8bhJCyUdBdB9WWAru81CnElLl48SIiIiK4EVm9vLyQmJgITU1N2Nvbl7hfkyZN0KRJE0yfPh1DhgzB9u3b0b9/fzRv3hwXLlyQa44v4+rqCoFAgPj4eLmCUl2qXrOnpye2bNkiV5NfXlXdvFxbWxstW7bEhQsXuCngpFIpLly4gMAKNteUPTwo2qIjLy8PMTExCi0MSC0WHw/Y2SldZWhgAKFQCEMdHdjY2CgNjmXTgaWkpMDKyooLqGXTga1evZqbC1wWmCclJUEgEMDLywsBAQEffWo+8pHZ2ABRUQqL+Xw+pCIRpPb2EIlE0NHRqdQWQJs3b0b79u3RqlUrBAcHo3nz5uDz+bh79y6ePn2Kli1blrp/48aNsXPnTpw5cwYODg7YtWsX7t69yz1sBgq7Gf3www9o3LgxnJ2dsXbt2lKnemzSpAmGDRuGESNGYM2aNWjRogUSExNx+fJleHh4oGfPnipdm729Pc6cOYNnz56hXr16MDIyUgh69fX1MXbsWMyaNQv16tWDubk5/vvf/8p9h4unx9PTE+/evcOFCxfQvHlz9OzZE9OmTUP37t3RpEkTpKam4tKlS3BxcQFQ2HVt48aNGDx4MObOnQsjIyPcunULbdq0QdOmTbFo0SJMnToVRkZG8Pf3h0gkwr1795CamqryPPL29vbIysri0qStrQ1DQ0Ol2+ro6GDkyJFYvXo1MjIyMHXqVAwcOJB7CD1r1iwsXLgQjo6OaNGiBbZv346HDx9WaCpMe3t7xMbG4uHDh2jQoAEMDAzw559/QiKRoG3bttDV1cXu3bshFAphV8JvLSFENRR011EhISH47LPPanSBrayAVIUqBbaMSCRCYmIiJBIJkpKScPr0aaxYsQK9evXCiBEjwBhD165d0a5dO/Tr1w8rV65EkyZN8PbtW5w4cQL9+/eHm5sbZs2aha+++goODg54/fo17t69iwEDBgAA5s6dC3d3d0yePBkTJ06EtrY2Ll26hK+//hr169dHUFAQpk+fDqlUis8++wzp6em4ceMGDA0NMXLkSJWvuXjBWLymHCicOisrKwuRkZFo1qyZSscuibrNyxMTE5GYmIiXL18CKOxOYGBggIYNG8L0/+dI7tKlC/r3788F1TNmzMDIkSPRqlUrtGnTBuvXr0d2drbc+AJlHff27du4e/cuPvvsM25qqvnz58PR0VGulvvWrVsQCARyy0jNVFJzbzlOTkCRB4EyHwQCeNvaor5EAkNDQ7i5uSkNjotPByb7TMumA4uJiUFISAi8vb3h4+MDb2/vstNE6p5Bg4AFC4DcXKBIbTYvNxc8xpDfrx8kEgkKCgq46cQqg6OjI8LDw7F8+XLMnTsXr1+/hkAggKurK4KCguQeiCszYcIEhIeHY9CgQeDxeBgyZAgmT56MU0VahcycORMJCQkYOXIk+Hw+xowZg/79+8tNU1Xc9u3bsXTpUsycORNv3rxB/fr14e3tLTeFWVnGjRuHy5cvo1WrVsjKysKlS5fg6+ursN2qVauQlZWF3r17w8DAADNnzlRIW0np6dWrF4DCadECAgLw+vVrGBoawt/fH+vWrQNQWEFx8eJFzJo1C506dYKGhgZatGjB9Zv+9ttvoauri1WrVmHWrFnQ09ODu7u73BRqZfHx8cHEiRMxaNAgfPjwAfPmzStx2jAnJyd8+eWX6NGjB1JSUtCrVy+5sWKmTp2K9PR0zJw5E8nJyXB1dcWxY8fkxphR14ABA7gpz9LS0rB9+3YYGxvjhx9+wIwZMyCRSODu7o6///5boQseIURNFR6yrQ6oi1OGSaVS9vbtWxYYGMgcHByYlpYW09fXZ23atGGrVq1i2dnZ3D4AFEaQzsvLY6NGjWJGRkbM2NiYTZo0ic2ZM0dulMuCggL23XffMUNDQ2ZsbMxmzJhR5pRhslHR7e3tmZaWFrOysmL9+/fnptwpOtKnzJEjR1jRj2pycjLr1q0b09fXL3PKMPz/FFuamprMzMyMde3alf3+++9MIpHI5VVGRgabMmUKs7a2ZlpaWszW1pYNGzaMxcfHM5FIxAYPHsxsbW2ZtrY2s7a2ZoGBgXKficuXLzMfHx8mEAiYsbEx8/Pz40bZlkqlbP369axp06ZMS0uLmZmZMT8/P27EY2WjcoeHhzMALDY2lns/BgwYwIyNjUudMowxxgYOHMjmzJnDvS4+omlJ51SW90WVNWWYsunciqfVzs6OLVy4UG6/jRs3soYNGzJtbW3Wpk0bduvWLbWO+/jxY9a5c2dmamrKBAIBs7e3ZxMnTpQbBZYxxsaPH88mTJhQ4vXR6OXVo3heKZtebMiQIezGjRv/26mkqcA+fChxlPTiPtZ0YKqg0csr5mOOXs4aNSr818qKiQcOZO/j49n79+8/yfdO1WkkSaGyRi8vPop4bUCjl9ccdN+hnuoYvZzHWBWMblHLZGRkwMjICOnp6QrNfvLy8hAbGwsHB4cSB6iqSVgNH+yqJqmrefX48WN069YNMTExSkdcLq/anF/v379H06ZNce/ePbnWGkVV5nddKpUiOTkZ5ubm1V4bqlKtcTUqmle3bt1S2txb1n/61wED4BoUpPxAahZlV69excSJE2Fvb68wxgRQWEP26tUrbN26letCU1VKK4NI2UrKv/J8p5X+zuXkFI5ivm9fYR9vGxtg0CCwIUOQXlDAdf0xMjL6pEZ4rs1lQnUoLb+Cg4Px119/4eHDh9WTuHKqyntkWdnQqlUrvHnzBjY2Nnj9+nWlnqMuqUn3HbVBZeaXqmX4p1M6EPKJaN68OX788UfExsZWyRRNtdGrV6+wefPmEgPuuqqsQcKAmhOUl9Xc+/iJE8DNm4o7/vIL8O23ap+PpgMjKtPVLfyMFfuc8QDo5OUhOzsbQGF3pk8p6CaEEKI6Kh0IqYNGjRpV3UmoUVq1aqV0Wry6TJVBwgCUGZR/LFFRUYiOjoaVlZVcLZCGVIq/Tp5UvpNUWjidUznQdGCkMmhrayMnJweMMW4Uc6plIuoKDg5GcHBwdSejRpo+fToyMzOpFRCp9SjoJoSQOkaVQcKCg4ORmZmJ1NTUUkfu/lhSU1MVpl4aExWF/v/8o3yHCvaM4vP5NB0YqTA+nw+BQIC8vDy5wJsQUjmmT59Ov8OkTqBPMSGE1DGRkZFKa42BwvnYLSwscPfuXSQmJsLJyQn6+vrQ0NDggvLU1FSEhISoPU98RRRt7g0Afx8/rjTgfn7oUIkBt1QqRUREBK5evYqIiIgy0y+bDszT0xNpaWl49eoV0tLS4OXl9dEfOpDaq2hfVpFIBBoqhxBCSHFU060iKkQJqdvq0ndcWa1xUWKxGLm5ubC3t1calFtaWiIqKgqRkZEqjwtQ0b7hrq6ucHFxQdLt2/i7hNrtYUOHYtf/z+lenCr915Wh6cBIRWloaEBLSwsF/z+oWmVPH0YIIaT2o6C7DLJRbfPz86nJGCF1WH5+PgAoHcm6tilrkDDZwE8ljW4vFAqRlJSE1NRUlc5XWsCrakDL5/Ox48wZaKekKKw7aWCApc2aYXUJzb1V6b9eWuDN5/Np0EFSITo6OigoKABQOKIzBd2EVI7MzEzweDzweDwYGBhUd3IIKTcKusugqakJXV1dvHv3DlpaWjW+9oOm8FAd5ZV66nJ+SaVSvHv3Drq6unVi9OGyBglLT0+HUCgs8QGDOiN3lxbwTpgwAVZWVnj37l2Ztc98DQ0oC1Paubujkbs7VgcEKA2cVem/HhISAm9v7xr/+01qLy0tLWhoaHA13bLfSkJIxbi5udGUYaROoBKhDDweD1ZWVoiNjUVcXFx1J6dMjDFIpVLw+fw6FxhVNsor9dT1/OLz+WjYsGGduLayBgmzsLCAo6MjXr9+DX19/XKP3F1awGtiYoLw8HDExcXB09MTUqkUWVlZuHnzJmJjY7FmzZrCIPqvv2A5YIDS41+9cgXbymjuXVb/9fI0lSdEXTweDzo6Olwrkry8vBJbkhBCCPn01OigWyKRIDg4GLt370ZiYiKsra0xatQozJs3j7u5Yoxh4cKF+OWXX5CWlob27dtjy5YtaNy4caWlQ1tbG40bN+aan9ZkUqkUHz58QL169ahWpwyUV+qp6/mlra1dp65LNkiYrNl3UlISBAIBvLy8EBAQAADlGrm7aN/td+/eISoqSiHgZYwhLi4OPB4PEomEa3Yue2jz4cMHBAcH4+y5c8pH89y9Gxg2DB3LuEapVIp79+4hNTUV+vr6YIwpBN7qNpUnpLxkXTqkUiny8/O5zzshhBBSo4PuH3/8EVu2bEFoaCjc3Nxw7949jB49GkZGRpg6dSoAYOXKldiwYQNCQ0Ph4OCA+fPnw8/PD1FRUXIjilYUn8+v1ONVFalUCi0tLejo6FBhXwbKK/VQftU+ZQ0SVlpQrqwpd/G+2wUFBUhOToZQKJSr1cvMzERWVhY0NTWRnZ0NqVQKXV1drvktcnJw9tw55YlWcUA7WVoePHiAxMREvH//HkZGRrC3t4epqSm3nTpN5QmpCB6PxwXejDHk5eVBV1e3XMcaNWoUQkNDudempqZo3bo1Vq5ciebNm1dKeoODg/HXX3/h4cOHlXK8qnb16lWsWrUK9+/fR0JCAo4cOYJ+JQysWNTly5cxY8YMREZGwtbWFvPmzcOoUaPUOm5wcDD27t2Lf//9F9ra2mjZsiWWLVuGtm3bVu5FEkLqrBp95xwWFoa+ffuiZ8+esLe3x1dffYUvvvgCd+7cAVBYm7J+/XrMmzcPffv2RfPmzbFz5068ffsWf/31V/UmnhBCagDZIGEdO3aEu7u73AMTHx8f7N69Gzt37sTWrVuxc+dO7Nq1q8SAOygoCA8ePICxsTHs7e1hbGwMkUiEqKgopBQZAE02irNIJAJQWNssGwvgRGYmPuTlKU+sGgG3LC2WlpYwNTWFVCpFeno6oqOjubTImsq7urqW2VSekMogEAi41hYVnT7M398fCQkJSEhIwIULF6CpqYlevXpVVlJrnezsbHh4eCAkJETlfWJjY9GzZ0907twZDx8+xLRp0/Dtt9/izJkzah23SZMm2LRpEyIiInD9+nXY29vjiy++wLt37yp0TYSQT0eNrun28fHBtm3b8Pz5czRp0gSPHj3C9evXsXbtWgCFP6aJiYno2rUrt4+RkRHatm2LmzdvYvDgwUqPKxKJuJtBAMjIyABQWJP3MeelrQpSqZTre0tKR3mlHsov1dW2vCoekBZPt1QqRUhICNLS0tC4cWMuqLC0tERCQgI+fPiA+Ph4mJqagsfjcU31JRIJtLS0IBAIAAAJiYlKz//u9GmYdOkCvgr5pSwtjo6OXO17fn4+4uLioK2tjeTkZJiammLy5MlKr6umqKnpIurT0NCAtrY2151CJBKVu5WcQCCApaUlgMLv2pw5c9ChQwe8e/cOZmZmAIB///0XM2fOxNmzZ8Hn89GhQwf89NNPsLe3B1BYyzt79mxERkZCS0sLbm5u2LNnDy5duoRFixYBAPd93r59u1wNsMyoUaOQlpaGNm3a4KeffoJIJMKMGTMwd+5czJkzB9u3b4euri6WLFmC0aNHl+taVdG9e3d0795drX22bt0KBwcHrFmzBgDg4uKC69evY926dfDz81P5uEOHDpV7vXbtWvz22294/PgxunTpolaaCCGfphoddM+ZMwcZGRlwdnbmmiUuW7YMw4YNAwAk/v8NnIWFhdx+FhYW3DplVqxYwRU2Rb179w55JdXA1BKy2h7GGDUBLgPllXoov1RX1/Lq1atXEIvF8Pb2Vpg60dTUFK9evUJBQQEMDAxgZGSE+vXrQywWIz8/H3p6erASi7Hn+nWlxz5/7hxsbGxQkJysUl4pS4utrS0aNWqEpKQkZGdnQyKRwNjYGC1btkTPnj3h6OiI5OTkimdEFcnMzKzuJJBKpKOjwz3Yz8vLk6v9Lq+srCzs3r0bTk5OqFevHoDCFiV+fn5o164drl27Bk1NTSxduhT+/v54/Pgx+Hw++vXrh3HjxuHPP/9Efn4+7ty5Ax6Ph0GDBuHJkyc4ffo0zp8/D6Cw0qIkFy9eRIMGDXD16lXcuHEDY8eORVhYGNq3b49bt25h//79mDBhArp164YGDRooPcby5cuxfPnyUq8zKioKDRs2LGcuKbp586ZcxQwA+Pn5Ydq0aeU+Zn5+PrZt2wYjIyN4eHhUMIWEkE9FjQ669+/fjz/++AN79uyBm5sb1zTI2toaI0eOLPdx586dixkzZnCvMzIyYGtrCzMzMxgaGlZG0quNVCoFj8eDmZlZnbjZr0qUV+qh/FJdXcurZ8+eITIyEnZ2dkqnGSsoKEB0dDQ+fPjA1WwLBAJERkZir0iE3hKJwj5PdHUx0tkZv5uZwdjYWOW8Ki0tWlpaAAofyI4bNw7ffPNNrcj/2jBeSF2zdu1artVcaby8vHDs2DG5ZX369MGDBw9K3Y8xhokTJ2Ly5MkoKCgo17zdx48f58ZKyM7OhpWVFY4fP859pvft2wepVIpff/1Vrrba2NgYly9fRqtWrZCeno5evXrB0dERQGFNr4y+vj40NTW52vTSmJqaYsOGDeDz+WjatClWrlyJnJwczJkzB5qampg7dy5++OEHXL9+vcRWhhMnTsTAgQNLPY+1tXXZGaMG2WwNRVlYWCAjIwO5ubkKDxFLc/z4cQwePBg5OTmwsrLCuXPnUL9+/UpNLyGk7qrRQfesWbMwZ84c7gfc3d0dcXFxWLFiBUaOHMkVFElJSbCysuL2S0pKQosWLUo8ruyGsDg+n18rbtDKwuPx6sy1VDXKK/VQfqmuOvOq6AjjxQdPKw9TU1NoaWkhJydH6TRIAoEAdnZ2mD9/PszMzGBiYgIXFxdo/n8QXFyXtm3xNj0dXs7OcHNzw/v371XOq7LSoqmpCSMjI7Rq1arWzJNM36ePLyMjA2/evClzO1tbW4Vl7969U2lfWQuGvLy8cgXdnTt3xpYtWwAAqamp2Lx5M7p37447d+7Azs4Ojx49wsuXL2FgYCC3X15eHmJiYvDFF19g1KhR8PPzQ7du3dC1a1cMHDhQ7n5JVcV/QywsLOS6pWhoaKBevXqltigxNTWVG+SwtpH1C3///j1++eUXDBw4ELdv34a5uXl1J40QUgvU6DuSnJwchZsRDQ0Nrv+bg4MDLC0tceHCBS7IzsjIwO3btzFp0qSPnVxCCKl2xUcYFwgEcHFxQWBgoNIB0lTh5uYGFxcXhIeHw9HRscR5vfv371/4m/3nn0AJIyz7duqEpKSkUqclq4y00MBppDSGhoawsbEpcztZ3+niy1TZV9Zcu6CgAGKxWO2HQHp6enBycuJe//rrrzAyMsIvv/yCpUuXIisrCy1btsQff/xRYrq3b9+OqVOn4vTp09i3bx/mzZuHc+fOwdvbW620aBV7gMbj8ZQuK218gupoXm5paYmkpCS5ZUlJSTA0NFSrlhv43/vh5OQEb29vNG7cGL/99hvmzp1baeklhNRdNTro7t27N5YtW4aGDRvCzc0N4eHhWLt2LcaMGQOg8Ad+2rRpWLp0KRo3bsxNGWZtba3SNBKEEFKXyEb1TklJgZWVFTf3dnh4OIKCgrB69epyBd58Ph+BgYGqzetdQt/V0U5OuK2lBUF6uty0ZOoOIqZWWggpwYwZM+S6mckwxrgAuaR+2MWbm5ckLy8P2dnZ3P+VtcxQh6z1TG5uLoDCpu/79u2Dubl5qV3jPD094enpiblz56Jdu3bYs2cPvL29oa2tXTiF30dSHc3L27Vrh5MnT8otO3fuHNq1a1fhY8sGyiNV68iRIxCLxeVqLUJITVKjg+6NGzdi/vz5mDx5MpKTk2FtbY0JEyZgwYIF3DazZ89GdnY2xo8fj7S0NHz22Wc4ffo09ZEjhHxSpFIpNm3ahJSUFDg5OXEBg76+PhwdHRETE4OQkBB4e3uXKyD18fEpfV7vFi1KDLilEglmVGJz9zLTUs4afUIqk7a2NnJycsAYQ35+PqRSqVqfe5FIxA0Km5qaik2bNiErKwu9e/cGAAwbNgyrVq1C3759sXjxYjRo0ABxcXE4fPgwZs+ejYKCAmzbtg19+vSBtbU1nj17hhcvXmDEiBEAAHt7e8TGxuLhw4do0KABDAwMlHa9qywVbV6elZWFly9fcq9laTc1NeVqx+fOnYs3b95g586dAAoD/U2bNmH27NkYM2YMLl68iP379+PEiRMqHzc7OxvLli1Dnz59YGVlhffv3yMkJARv3rzB119/Xe7rIapp2bIlPUQldUKNDroNDAywfv16rF+/vsRteDweFi9ejMWLF3+8hBFCSA0TGRmJ6OhoWFlZKdTQ8Xg8WFpaIioqCpGRkXB3dy/XOXx8fODt7a3YX3zkSGD3bsUdTEyAlBTwgXKfU+200M0ZqSH4fD50dHSQm5sLxhhEIpFaTZpPnz7N9b82MDCAs7MzDhw4AF9fXwCArq4url69iu+//x5ffvklMjMzYWNjgy5dusDQ0BC5ubl4+vQpQkND8eHDB1hZWSEgIAATJkwAAAwYMACHDx9G586dkZaWVuKUYTXFvXv30LlzZ+61rKXCyJEjsWPHDgBAQkIC4uPjuW0cHBxw4sQJTJ8+HT/99BMaNGiAX3/9lZsuTJXjamhocPn4/v171KtXD61bt8a1a9eoGwshRGU8xhir7kRUt4yMDBgZGSE9Pb1OjF6enJwMc3NzuvksA+WVeii/VFcdeXX16lVMnDgR9vb2SkcYl0gkePXqFbZu3YqOHTtW3olLmgopJgZo1KjM3elzVbfKoOpQUv7l5eUhNjYWDg4OKrd+U6V5uTokEgnS0tIAFAbhxsbGlXLcmqCy86quq4v5VZ7vmKqobFAP5Zd6KjO/VC3Da3RNNyGEENWYmJhAIBAgNzdXad/R3NxcCAQCmJiYVM4Jo6KAkmp56FkuIQAKB3/V1tbmmpfn5+dXaRNuQuqa48ePc61EevXqVd3JIaTc6FEIIYTUAbJRvRMTE1G8AZNsVG9XV9fKaQ7J4ykPuKdMoYCbkGKK1gDm5eUpfD8JISWbPHkyBg4ciIkTJ1Z3UgipEAq6CSGkDpCN6m1iYoKYmBhkZWVBIpEgKysLMTExlTOqN2MlNie/du4cIsaNU3s0ckLqOi0tLW66MLFYjIKCgmpOESGEkI+Ngm5CCKkjZKN6e3p6Ii0tDa9evUJaWhq8vLzKPV0YZ/t2oISA3bNFC0yYOhUjRozA8OHDERYWBqlUioiICFy9ehUREREUjJNPWtEB1PLy8qoxJYQQQqoD9ekmhJA6pEpG9S6hdnuZoyN2aWrCythYbk7wCRMmwNLSEu/fv4dIJIJAIICLiwsCAwPlAn+pVIonT55wg5k0a9aMBoAhdZKWlhY0NDQgkUhQUFDADahFCCHk00B3N4QQUsfw+Xy4u7ujY8eOcHd3L38gm5lZYsA9dMgQ7NLUhJOTE/T19aGhoQF9fX2Ympri5cuXuH37NoyMjGBvbw9jY2OEh4cjKCgIYWFhAICwsDAMHz4co0ePxubNmzF69GiulpxUv+DgYPB4PLk/Z2dnbn1eXh4CAgJQr1496OvrY8CAAUhKSpI7Rnx8PHr27AldXV2Ym5tj1qxZEIvFcttcvnwZXl5eEAgEcHJy4qZ+qkw1oQ81j8dT6NtNSG1XE75bhNQWFHQTQghRNGAAoGzqi4YNEfH4sdI5wRljePXqFRekMca4YNzR0RGpqakICQnB9evXERQUhAcPHsDIyAgWFhYwMjJSCMxJ9XJzc0NCQgL3d/36dW7d9OnT8ffff+PAgQO4cuUK3r59iy+//JJbL5FI0LNnT+Tn5yMsLAyhoaHYsWMHFixYwG0TGxuLnj17onPnznj48CGmTZuGb7/9FmfOnKmU9GtpaQEAcnJyKuV4FSUQCLgHYCKRCBKJpJpTREjF5OfnA4DSaSoJIfKobRMhhBB5Jc0hGx8P2Noi9epVbgqXojIzM5GVlQWhUIj8/Hy5AaN4PB4sLS0RGRmJ5cuXIyUlBU5OTuDz+eDz+VxgHhMTg5CQEHh7e1NT82qmqakJS0tLheXp6en47bffsGfPHnz++ecAgO3bt8PFxQW3bt2Ct7c3zp49i6ioKJw/fx4WFhZo0aIFlixZgu+//x7BwcHQ1tbG1q1b4eDggDVr1gAAXFxccP36daxbtw5+fn4VTr+GhgaMjY2RnJwMANDV1S1zfuSqnkuZx+NxgUp6ejp0dXUr/RwfS12cd7oq1bX8kkqlePfuHXR1damrBCEqoG8JIYSQQg8fAp6eytcVaUZY0pzgBQUFkEqlYIyBz+dzNY0yQqEQcXFxyM7ORoMGDRRuPGWBeVRUFCIjI+Hu7l5pl0bU9+LFC1hbW0NHRwft2rXDihUr0LBhQ9y/fx8FBQXo2rUrt62zszMaNmyImzdvwtvbGzdv3oS7uzssLCy4bfz8/DBp0iRERkbC09MTN2/elDuGbJtp06aVmi6RSASRSMS9zsjIAFAYBBQfsM/c3ByMMYWm76WRSqVV+sCnaM17bQ66garPq7qmruUXn89HgwYNwBir9KbmsrKk+DKinCy/KI9UU5n5peoxKOgmhBBScu32998DP/wgt0g2J3h4eDgcHR254FlLSws8Hg95eXkwMTGBgYGB3H65ubncYFLFa8llhEIhkpKSkJqaWvFrIuXWtm1b7NixA02bNkVCQgIWLVqEDh064MmTJ0hMTIS2tjaMjY3l9rGwsEBiYiIAIDExUS7glq2XrSttm4yMDOTm5pb4GVmxYgUWLVqksPzdu3dK+0rz+XwYGxur1JybMYbMzEzo6+tXWW1kcnIy3r59CwCws7NDw4YNq+Q8Ve1j5FVdUtfyi8fjQUNDA2lpaVVyfKlUivT0dO57K5VKuVYrRJEsv2QPvUnpKjO/MjMzVdqOgm5CCPmUMVbiVGDIzweK1VYD/5sTPCgoCDExMbC0tIRQKORuJBljsLOzU+jvnZiYiCZNmuDNmzcKteQyubm5EAgEMDExqZzrI+XSvXt37v/NmzdH27ZtYWdnh/3795cYDH8sc+fOxYwZM7jXGRkZsLW1hZmZGQyVjUOgBlmTWTMzsyq7cTUyMuKC7sTERLRp06ZW9on9GHlVl1B+qUcqlYLH48HIyAjZ2dkwNDSEubl5dSerxpLlF32+VFOZ+VV0kMzSUNBNCCGfqi1bgMmTla8ro6mgbE7wTZs2ITo6GklJSRAIBPD29kZCQgJSU1MhEAi4qcQSExNhYmKCuXPnYvPmzQq15IWnLAzMvby84ObmVplXSirI2NgYTZo0wcuXL9GtWzfk5+cjLS1NrrY7KSmJ6wNuaWmJO3fuyB1D1sS76DbFm30nJSXB0NCw1MBeIBBAIBAoLJeND1BRPB6v0o6ljKGhIezs7BAfH4/8/Hy8evUKjRs3rpJzVbWqzqu6hvJLPTweD1FRUZRfKqLPl3oqK79U3Z/eFUII+RTxeMoD7rNnywy4ZXx8fLB7927s3LkTW7duxc6dO3H69Gn8/PPP8PT0RFpaGl69eoW0tDR4eXlh9erV+OyzzxAYGAgTExPExMQgKysLUqkUWVlZiImJgYmJCQICAuimoYaRvT9WVlZo2bIltLS0cOHCBW79s2fPEB8fj3bt2gEA2rVrh4iICLnmoOfOnYOhoSFcXV25bYoeQ7aN7Bh1mYuLC/f/p0+f0tRLhBBSx1FNNyGEfErS0oCSmm6X48ZfNid4UT4+PvD29kZkZCRSU1NhYmICNzc3LpAuWkv+7NkzJCUlIT09HV5eXggICICPj4/a6SCVKygoCL1794adnR3evn2LhQsXQkNDA0OGDIGRkRHGjh2LGTNmwNTUFIaGhpgyZQratWsHb29vAMAXX3wBV1dXfPPNN1i5ciUSExMxb948BAQEcLXUEydOxKZNmzB79myMGTMGFy9exP79+3HixInqvPSPwtTUFObm5khOTkZWVhZev34NW1vb6k4WIYSQKkJBNyGEfCr8/QFlcyC7uQFPnlTqqZQF40XJAvMnT54gOTkZ5ubmaNasGdVw1xCvX7/GkCFD8OHDB5iZmeGzzz7DrVu3YGZmBgBYt24d+Hw+BgwYAJFIBD8/P2zevJnbX0NDA8ePH8ekSZPQrl076OnpYeTIkVi8eDG3jYODA06cOIHp06fjp59+QoMGDfDrr79WynRhtYGrqyvXEiA6OlrpiP6EEELqBgq6CSGkDpJKpXI1ze7Nmyvf8O1bwMrq4ybu//H5fDRr1owLuingrjn27t1b6nodHR2EhIQgJCSkxG3s7Oxw8uTJUo/j6+uL8PDwcqWxtrO0tISRkRHS09Px4cMHvHv3jgaKIqSY2bNnIy0tDSYmJli1alV1J4eQcqOgmxBCVFQ8kC3aZLomCQsL4wY4s8zIwKl//lG+IfUjJaTa8Hg8uLi44NatWwAKa7sp6CZE3t69e/HmzRvY2NhQ0E1qNQq6CSFEBUUDWZFIBIFAABcXFwQGBtaoPshhYWEICgpCSkoKjr55g6ZZWYobLVoELFjw8RNHCJFjZ2eHx48fIycnB2/fvkV6ejqMjIyqO1mEEEIqWc2roiGEkBpGFsg+ePAAxsbGsLe3h7GxMcLDwxEUFISwsLAqO7dUKkVERASuXr2KiIgISKXSUrfdtGkTUj58wNNnz5QG3MMHD4Z03rwqSy8hRHV8Ph9NmzblXkdFRVVjagghhFQVqukmhJBScIFsSgqcnJy4gY709fXh6OiImJgYhISEwNvbu9KbmhevXdfW1oa1tTV69eqFDh06KDRvj4yMxOuICIS+f69wrLe6uhjWpg3Snj5FZGRkqYOcEUI+HkdHR0RGRiI/Px9xcXFo3rw59PT0qjtZhBBCKhEF3YQQUorIyEhER0fDyspKYWRhHo8HS0tLREVFVXogW7SZuJWVFfLy8vDPP//g6dOnuHTpEmxtbdGqVSu55u2Sq1ex9+lTWIvFcscK6NgR8YaGEEokSEpKQmpqaqWlkxBSMVpaWmjSpAmePHkCxhiio6PRqlWr6k4WIYSQSkTNywkhpBSpqakQiUQQCoVK1wuFQohEokoNZIvXrufn5+PZs2fIzs6Gnp4e+Hw+0tPT8eDBAwQFBeHWpUsAj4cWgYFcwJ2jqYm1LVqgd69eiDc0BADk5uZCIBDApKR5ukmtJRaLsXjxYrx+/bq6k0LKoUmTJtDULKwHiYmJQW5ubjWniBBCSGWioJsQQkphYmICgUBQ4k1wVQSyRWvXAeDVq1fIz8+Hrq4uNDU1IRQKkZeXB3Nzc7SJi4P355/L7X9XKMTkjh1xqUEDbhljDImJiXB1dYWbm1ulpZXUDJqamli1ahXExVo5kNpBIBDAyckJQOFDt2fPnlVzigghhFQmCroJIaQUbm5ucHFxQWJiIlixKbaqKpAtWruemZmJrKwsCAQCrnk7n8+HVCrFibAwrH/7Vm5fqaYmpnt44Pbbt8jKyoJEIkFWVhZiYmJgYmKCgICAGjnNGam4zz//HFeuXKnuZJBycnZ25r6bL168QH5+fjWniBBCSGWhPt2EEFIKPp+PwMBABAUFISYmBpaWlhAKhcjNzUViYmKVBLJFa9cLCgoglUqhoaHBrTcXi/FE2VRgvXuDf+wYVhYZgC0pKQkCgQBeXl4ICAioUdObkcrVvXt3zJkzBxEREWjZsqXCYFx9+vSpppQRVQiFQjg4OCAmJgZisRjPnz9Hs2bNqjtZhBBCKgEF3YQQUgYfHx+sXr36owWystr18PBwmJmZgc/nQyKRQFNTE7OzsjAzJ0dhnxd796LxoEFcer29vREZGYnU1FSYmJgojHRO6p7JkycDANauXauwjsfjQSKRfOwkETW5uroiJiYGAPD8+XM4Oztzfb0J+RT16NEDqampMDU1re6kEFIh9EtOCCEq+JiBbNHa9eTkZOjo6CAnKwsflATbADBsyBDs+vprhWPQtGCfltLmcCe1g76+Puzs7BAXFweRSISYmBi5ebwJ+dRs3bqVHhiTOoE+xYQQoiJZINuxY0e4u7tX6Y2ArHbdy8sLQ/l8ZCoJuDfUrw+fdu0QEBhINyWE1BGurq7c/6Ojo+lhCiGE1AF0l0YIITWUj48P9vz5J9YlJiqs6+rmhttffIHVq1dTP23CuXLlCnr37g0nJyc4OTmhT58+uHbtWnUni6jB2NgYNjY2AApnR4iNja3mFBFCCKkoCroJIaQmSk0F/n+08uKuXrmCdX/+iV27dnEBt1QqRUREBK5evYqIiAiqHfsE7d69G127doWuri6mTp2KqVOnQigUokuXLtizZ091J4+ooWhtd1RUlMLMCYQQQmoX6tNNCCE1zeTJwJYtisvnzgWWL0fHYovDioxWLhKJIBAI4OLigsDAQKoF/4QsW7YMK1euxPTp07llU6dOxdq1a7FkyRIMHTq0GlNH1FG/fn2Ym5sjOTkZWVlZiI+Ph52dXXUni5CPrk2bNkhMTISlpSXu3btX3ckhpNyoppsQQmoSHk95wJ2ZCSxfrrA4LCwMQUFBePDgAYyNjWFvbw9jY2OEh4cjKCgIYWFhHyHRpCb4559/0Lt3b4Xlffr0oSbKtZCbmxv3f6rtJp+qxMREvHnzBolKulkRUptQ0E0IITVBeHiJzcnBGKCvr7BYKpVi06ZNSElJgZOTE/T19aGhoQF9fX04OjoiNTUVISEh1NT8E2Fra4sLFy4oLD9//jxsbW2rIUWkIiwsLLhpktLS0pCQkFDNKSKEEFJe1LycEEKqW1AQsGaN4vK//wZ69Spxt8jISERHR8PKygq8YgE7j8eDpaUloqKiEBkZSdOHfQJmzpyJqVOn4uHDh1y3ghs3bmDHjh346aefqjl1RF08Hg9ubm7cQHiRkZFKv+uEEEJqPgq6CSFVRiqVfpR5rWuCotdqbGyM+vXrq7IToKFR8roybq5TU1MhEokgFAqVrhcKhUhKSkJqamrZaZE7denv26f0vtYmkyZNgqWlJdasWYP9+/cDAFxcXLBv3z707du3mlNHysPGxgaGhobIyMjA+/fvkZycDAsLi+pOFiGEEDVR0E0IqRI1YXCv4sGhi4sLoqOjKz1YLH6tQqEQnTt3Rv/+/dG+fXvlO928CSjJh+wWLSC8fx98FWqzTExMIBAIkJubC30lzc9zc3MhEAhgYmJS7msp/r7VhPeVKBKLxVi+fDnGjBmD69evV3dySCXh8Xho1qwZNzZDREQEBd2EEFILUdBNCKl0ssG9UlJSYGVlBaFQiNzcXG5wr48xt3Tx4FAsFnNBoqamZonBorq1uMquNS8vD//88w9mz56NVatWKV6rry9w5YrCsdo3bowcAC7Dh6sUxLq5ucHFxQXh4eFwdHSUa3bKGENiYiK8vLzkBmQqK89Ke99GjhyJ0NDQan1fiXKamppYuXIlRowYUd1JIZWsYcOGiIiIQGZmJt69e4ekpCQKvAkhpJah9oCEkEpVEwb3Kj6it5GREZKSkpCYmIi3b9+Cx+NBU1MTDx48kBvhOywsDMOHD8eIESMwceJEjBgxAsOHDy9xBPDSrtXS0hJpaWny15qVVdhkvFjA/UZTE519fWHk5KTWyON8Ph+BgYEwMTFBTEwMsrKyIJFIkJWVhZiYGJiYmCAgIECl2vyy3reUlBSsWLECHz58oEHbaqguXbrgipKHOaR2k9V2yzx58qQaU0MIIaQ8qKabEFKpqntwr+LBIwA8f/4c+fn5AAqbXD9//hy6urrQ09NDXl4eFyzOnj1brVrcsq7VwsLif9d6/z4werRCeifa2OB1ixbQ///9ZUFsTEwMQkJC4O3tXWrQ7OPjg9WrV3O1+klJSRAIBPDy8kJAQIDKNc9lXYuBgQHi4uLQrFkzGrSthurevTvmzJmDiIgItGzZEnp6enLr+/TpU00pIxUlq+3OyspCcnIykpOTYW5uXt3JIoQQoiIKugkhlaqqBvdSVfHgMSMjA2lpaRCLxWCMgc/ngzHGrdPQ0MCdO3eQmprKBeo8FQNgVa41MTER7s2bK13funlz6JuacgG3jLpBrI+PD7y9vSs0uFlZ18Ln8yGVSqFRwsBvVf2+krJNnjwZALB27VqFdTweDxKJ5GMniVQSPp+PZs2a4datWwAK+3Z36dKlmlNFCCFEVRR0E0IqVVUM7qWO4sFjfn4+8vPzIZVKoalZ+JMnkUjA5/Ohp6eHrKwsJCQkgDEGW1tbtWpxy7rW5q9f40R0tGIihw3D1fHjkT1xIswq6eEEn8+vUA1zWdcilUrB5/NLDNyq+n0lZaOm/XWbnZ0dnjx5wtV2v3v3DmZmZtWdLEKq1A8//IC8vDzo6upWd1IIqRDq000IqVSywb0SExPBGJNbJxvcy9XVVeXBvdRVNHgEgIKCAi5glKWBx+NxwbW2tjYKCgqQl5dXao21SCRSCIBLu9aQzZux4vFjhWPN6tEDYZMnK6SzuI8dxJb1vmVmZsLCwgKZmZnV8r6S0hUUFEBTU5P6+9ZhfD5f7vsVERFRjakh5OMYOnQovv32WwwdOrS6k0JIhdT4oPvNmzcYPnw46tWrB6FQCHd3d9y7d49bzxjDggULuD6YXbt2xYsXL6oxxYR82ipzcK/yKB48amlpgcfjgTEGxhjXRFpTUxOMMRQUFEBLSws6OjpqB8DKrpVXUIBjf/+t9DidO3XC8X/+QVBQENLT06v14URxZb1vpqammDt3LkxNTavlfSWl09LSQsOGDakJeR1nb2/P9dVPSkrC+/fvqzlFhBBCVFGj745SU1PRvn17aGlp4dSpU4iKisKaNWvkbnxXrlyJDRs2YOvWrbh9+zb09PTg5+eHvLy8akw5IZ822eBenp6eSEtLw6tXr5CWlgYvL68qn1aqePAoFoshEAgAFM5lzOPxIBQKIRaLkZOTAw0NDVhZWaFJkyblCoCLXuvYyEgcO3NGabp69+oFfQMDbqTvLVu2/B97dx4XVbn/AfwzM8Cw78uwyqayKuAGmEtlUWFldW+LmrangmWGprduZXWzzLJuYt5W85Yt/tq1XHJDBVwAlU2URUFwhn0ZlgHmnN8fNOcyzAAzMHAG+L5fL18155w5852HgTnf8zzP98GKv3q8jSWJ7e/n9vTTT/P2cyX9e/HFF/GPf/wDtbW1fIdChgj1dhNCyMgkYHteYRqRdevW4eTJkzh+/LjW/SzLwsPDA88//zySkpIAAA0NDXBzc8OOHTvw4IMP6vQ6jY2NsLOzQ0NDA2xtbQ0WPx8YhuGqmlKPU9+orfSjT3up1rquqalBTU0NnJyc4OTkpHdxr8FQrdOdl5eHkpIStLa2QiQSQSQSQSAQQCgUwtraGiYmJrjhhhuwfPlyrF27FnV1dZBIJFz1cqlUCgcHh/6Tyh5zwVUSZs9GaY+/K3K5HPX19di5cyeamprU1hMXi8UICQnRq/K4ofW3Vrm+a5n391pj/ffQUN9BkZGRKCwsREdHB8aNG6dRvTwzM3OwoRolQ36Hj4TPI8Mw+O2339DS0gIAuOWWW+Ds7MxLHMbeVsaE2ks/qvaqq6vjarJMnDiR77CMFn2+9GPI9tL1O8ioC6n9+uuviIuLw9///nccO3YMnp6eWLFiBZ588kkAQElJCaRSKebNm8c9x87ODjNmzEBaWlqvSbdCoYBCoeAeNzY2Auj6AYz0QjQMw3BDaEnfqK30o2t7paWlYdu2bbh48SKXRAYFBXGVlYervaOjozF9+nTk5eXhxIkT+OSTT9DW1gYbGxuIRCKuV9nBwQErVqxATEwM3nnnHS72qqoqiMViTJkyBcuXL0d0dLT22PPyIOylgNn8+HgIhUL0TMctLS1RVVWF2tpazJo1i4tTlcSGhIRw1cL50rNXv2cs/e3XFf0eGu53YsGCBQY5DzFuqt7uM2fOAOhat3vu3Ln8BkXIELnllltQXl4OT09PXLt2je9wCBkwo066i4uL8dFHH2H16tX4xz/+gTNnzuCZZ56BmZkZli5dCqlUCgBwc3NTe56bmxu3T5uNGzdiw4YNGturqqpG/LB0hmHQ0NDALY1EekdtpR9d2is/Px+ff/45WlpaMHnyZIjFYigUCtTX12P79u1ob29HcHDwsMbt6uqKe++9F8HBwdi7dy/Kysq4edze3t6Ij49HQEAAKisrERAQgHfeeQelpaWQy+WwtraGj48PhEIhKisrNc4tcXfX+prVt96KN0ND4dbQAHNzc439qgrhYrGYO6+rqyu37u5YmqdJv4dAU1OTQc7zyiuvGOQ8xPj5+/sjNzcXLS0tuH79OjeiiBBCiHEy6qSbYRhMnToVb775JoCuoXM5OTnYvn07li5dOuDzrl+/HqtXr+YeNzY2wtvbGy4uLqNieLlAIICLi8uYvYDVFbWVfvprL4Zh8OmnnyIrKwsBAQFqiSPLssjMzATLstixYwcv7e3q6opZs2Zp7VHuSSKR9Hs+YS/rVTN1dbC1tITwH//A6dOn4evrq7YMGcuyKC4uRmRkJKZOnTrmP3v0ewitN2b0cfr0aUyZMqXXNdQVCgV++eUX3H///YN6HWI8tPV2z5kzh+eoCCGE9Maok253d3eEhISobQsODsYPP/wA4H8XxjKZDO7depxkMhkiIiJ6Pa9YLOYKK3UnFApHxUWfar7qaHgvQ43aSj99tVdubi7y8vK4kSc9y0W4uroiNzcX+fn5eq8nbag5xEKhEJMmTdL7ed1fP2D/fnj+dSNQA8tCCMCEYRAfH4+0tDQUFhZqnSO+YsUKbt3wsW6s/x4O9n3HxMTg+vXr3EgJW1tbnDt3Dv7+/gCA+vp6PPTQQ5R0jzLde7srKiqot5sQQoyYUV/hzJw5EwUFBWrbLl26hHHjxgEA/Pz8IJFIcOjQIW5/Y2MjTp06hZiYmGGNlZCxrq6uDgqFQu+1rrtjGAbZ2dlISUlBdnY2GIZBamoqFi9ejCVLlmDZsmVYsmQJFi9ejNTU1KF6K2q6v/7sOXO0J9ybNgE9bjIEBwdj06ZNVOmbDDltFff7O4aMfEKhUK1jgtZoJ4QQ42XUSfdzzz2H9PR0vPnmmygsLMSuXbvw8ccfIyEhAUBX78iqVavwxhtv4Ndff0V2djaWLFkCDw8PKihDyDBzcHCAWCzWe61rFW3JdVxcHJ5++mlkZmbC3t4evr6+sLe3R1ZWFpKSkoY88U5NTUVSUhLyzp5F1rlz2g9iWWDNGq27YmJi8NVXX2Hnzp3Yvn07du7cif/+97+UcJNhJ+ilur4u3nrrLe77VqWtrQ0JCQlwcnKCtbU17rvvPshkMrXnlZaWIj4+HpaWlnB1dcWaNWvQ2dmpdszRo0cRFRUFsViMwMBA7NixY8BxjkX+/v6wtLQEAFRUVIypehCEEDKSGHXSPW3aNPz000/45ptvEBYWhtdffx3vv/8+Fi1axB2zdu1arFy5Ek899RSmTZsGuVyOffv2DXqOHCFEP6GhoQgODh7QWteq5LZ7cm1nZ4dTp06hsLCQu7AXiUSwtrbm1rpOTk4esqrXDMNg69atWJWXh3OXL2s9ZtHChf2+vlAoRHh4OGbPno3w8PAxO4SajExnzpzBf/7zH41pGc899xx+++037N69G8eOHUNFRQXuvfdebr9SqUR8fDza29uRmpqKL7/8Ejt27MDLL7/MHVNSUoL4+HjceOONOHfuHFatWoUnnngC+3tZ655oEolEan9TL1y4wGM0hBBCemP0Ewrnz5+P+fPn97pfIBDgtddew2uvvTaMURFCehIKhUhMTERSUhKKioq0zmNOSEjQSDpVyW1tbS0CAwO5HjmWZSEQCCAQCHDlyhU4ODhw+wQCASQSCfLy8pCbm6v3HHFd5ObmYtc332jd9+ysWbggEqF+CF+fEH3k5eVxq3awLIuLFy9CLpcDGHg1fLlcjkWLFuGTTz7BG2+8wW1vaGjAZ599hl27duGmm24CAHzxxRcIDg5Geno6oqOjceDAAeTl5eHPP/+Em5sbIiIi8Prrr+OFF17Aq6++CjMzM2zfvh1+fn549913AXRNyThx4gS2bNmCuLi4wTTHmOLv74+8vDw0NzdDJpNBJpNprOpCCCGEX0afdBNCRo7Y2Fhs3rwZW7duRX5+PmQyGcRiMaKiopCQkKB1WLWquJq7u7vaENiOjg4wDAMLCwvI5XI0NTWprS5gYWEBmUzW5xzxAbt0CeG9FFy786+bgBZK5dC9PiF6uvnmm9VGmKhuVgsEAu4Glr4SEhIQHx+PefPmqSXdGRkZ6OjowLx587htQUFB8PHxQVpaGqKjo5GWlobw8HC15C8uLg7Lly9Hbm4uIiMjkZaWpnYO1THdh7Fro1AooFAouMeNjY0Aum7gDXbky0hdNz4sLAzp6ekAgPPnz+Pmm28e1JQCXYzUtuILtZd+VO3VcxvRjj5f+jFke+l6Dkq6CSEGFRsbi+joaJ2rjfdWgM3U1BRCoZD7o9jR0aG2v7854gMWEAAUF2ts3u/tja2TJw/96xOip5KSEoOf89tvv0VmZia3JFV3UqkUZmZmsLe3V9vu5ubG9bZLpVKN3lbV4/6OaWxsRGtra69FGTdu3IgNGzZobK+qqkJbW5tub7AXI3XdeAsLC5iamkIul6O8vBx5eXlwcXEZ0tccqW3FF2ov/ajaS6lUco8rKyt5jsp40edLP4Zsr6amJp2Oo6SbEGIQA13Wq3sBNmtra267jY0NrK2tUVdXBxMTE5iamnL7VHPEo6KitM4RH7Beeobuue02dHZb3kuf1zfUcmeE9Ea1ooehlJWV4dlnn8XBgweNsj7K+vXrsXr1au5xY2MjvL294eLiojYaZiBG8rrx06dPx8mTJwEA5eXlCAkJGdLe7pHcVnyg9tKPqr1Onz4NlmUhEom4ZRGJJvp86ceQ7aXr9yQl3YSQQUtNTeWGlCsUCojFYgQHByMxMbHfSt2qAmxZWVkICAhQm7c9btw41NbWcnO7lUplv3PEB+TIEeCvuak9xcbEoO7KFZ3nqHeXlpaG5OTkAbULIXzJyMhAZWUloqKiuG1KpRIpKSnYunUr9u/fj/b2dtTX16v1dstkMkgkEgCARCLB6dOn1c6rqm7e/ZieFc9lMhlsbW177eUGALFYDLFYrLHdUGu9j9R14318fJCXl4f6+nrU1dWhoqIC3t7eQ/qaI7Wt+ELtpR+BQABPT09qLx3R50s/hmovXZ8/6J9K93lVhJCxR1vlcX2W9VIVYHNwcEBRURHkcjmUSiXkcjnq6uoQGBiIGTNmoKGhYWjWuhYItCfcx44BLIvNmzcPaK3t/Px8rF27lrflzggZqJtvvhnZ2dk4d+4c92/q1KlYtGgR9/+mpqY4dOgQ95yCggKUlpYiJiYGQNdyednZ2WrDQQ8ePAhbW1tubemYmBi1c6iOUZ2D6EcgEKhVmb9w4QKtz04IIUZC757uP/74A99++y2OHz+OsrIyMAwDKysrREZG4tZbb8Wjjz4KDw+PoYiVEGJkeqs8rlrWq6ioCMnJyYiOju7zTmB/Bdj0mSOus7Y2oLfetG4XqvrOUQe62mXv3r3cTYOBtgshfLCxsUFYWJjaNisrKzg5OXHbH3/8caxevRqOjo6wtbXFypUrERMTg+joaADArbfeipCQEDz88MPYtGkTpFIpXnrpJSQkJHC91MuWLcPWrVuxdu1aPPbYYzh8+DC+//577N27d3jf8Cji4eEBJycn1NTUoLGxEaWlpQaffkAIIUR/OifdP/30E1544QU0NTXhjjvuwAsvvAAPDw9YWFigtrYWOTk5+PPPP/H666/jkUceweuvvz7kRTwIIfzqrfI4oN+yXgzDwMbGBk899RRqamrg5OQEJycnteTWoMtybdoEvPCC5vb77we++05js2qtbW1xa0vG8/LyUFZWBolEMqh2IcRYbdmyBUKhEPfddx8UCgXi4uKwbds2br9IJMKePXuwfPlyxMTEwMrKCkuXLlVb3tPPzw979+7Fc889hw8++ABeXl749NNPabmwQVD1dh85cgRAV2+3t7c33dwjI9bHH3+MlpYWWFtb46mnnuI7HEIGTOeke9OmTdiyZQtuv/12rX+877//fgBdxTs+/PBDfPXVV3juuecMFykhxOj0VnlcRZdlvfqaDz4kF4q9FRa6fh34a66pLvqKu6OjAx0dHYNqF0KMydGjR9Uem5ubIzk5GcnJyb0+Z9y4cfj999/7PO/cuXORlZVliBDJX9zc3ODq6orKykrI5XKUlJQgICCA77AIGZA33ngD5eXl8PT0pKSbjGg6J91paWk6Hefp6Ym33nprwAERQkaO3iqPq/S3rJZqPnhtbS3c3d25QmWqec8Gm7cNADU1gLOz9n16znvsL+7ly5fD1NQU9fX1sLKy0ng+LTdGDCUyMlLnCtWZmZlDHA0xBqre7j///BMAkJOTA19fX4hEIp4jI4SQscsg3UjNzc1obGw0xKkIISOIqvK4VCrVKNijWlYrJCRE67JaPeeDW1tbQyQScfOe6+rqkJycDIZhBh/oli3aE+6PPtI74dYl7n379sHLywsymUzvdiFEHwsWLMDdd9+Nu+++G3FxcSgqKoJYLMbcuXMxd+5cmJubo6ioiIZsjzEuLi5wd3cHALS0tKC4uJjniAghZGwb1JJheXl5WLJkCTIzMyEQCBASEoIvvvgCU6dONVR8hBAjpqo8npSUhKKiIr2W1TLUfPA+sSzQ2xD19nag29rfutIl7osXL2L+/PlIT0/Xu10I0ccrr7zC/f8TTzyBZ555Bq+//rrGMWVlZcMdGuHZpEmTcP36dQBdf7f8/PxgYkIrxRJCCB8GdcX39NNPIzExEXK5HDU1Nbj33nuxdOlSQ8VGCBkBVJXH9V1WS5f54AqFYuDzng8c0J5wP/NMVzI+gIQb0D1uFxcXbNq0aUDLjREyELt378aSJUs0ti9evBg//PADDxERPjk6OsLLywtA15SWS5cu8RwRIYSMXXrd8rz77ruxbds2eHp6AgCqqqpw1113wdLSEpaWlrjjjjv6LKpCCBmdBrKs1mDng/eplzmup7/9FhYhIQhlmAH3Musat7W1NaZPn46YmBjDL3dGiBYWFhY4efIkxo8fr7b95MmTMDc35ykqwqdJkybh2rVrALpGJwYEBHBLthFCCBk+eiXdixcvxk033YSEhASsXLkSiYmJCA0NxZw5c9DR0YHDhw/j+eefH6pYCSFGrLdltXqjmg+elZWFgIAAtaHaqnnPUVFR+s17bmkBtBQuA4DIiAgoNmxQqzI+kN5mXeKeMmUKfHx8AOjfLoQM1KpVq7B8+XJkZmZi+vTpAIBTp07h888/xz//+U+eoyN8sLOzg5+fH0pKStDR0YG8vDxERkbyHRYhhIw5enW3/P3vf8fp06eRl5eH6OhozJw5EwcOHMDMmTMxa9YsHDhwAC+99NJQxUoIGUVU88EdHBxQVFQEuVwOpVIJuVyOoqIi/ec9v/aa1oR7r4sLgiZOhL29PXx9fWFvb89VGU9NTR2SuJcvX0692WTYrVu3Dl9++SUyMjLwzDPP4JlnnkFmZia++OILrFu3ju/wCE8mTZrE/T26dOkSWlpaeI6IEELGHr0ratjZ2WH79u04ceIEli5diltuuQWvv/46LC0thyI+QsgoppoPrlrvWiaTQSwWIyoqCgkJCbr3RPcynPzpe+7Bsbw8BAYGcj3SqirjRUVFSE5ORnR0tN4Jcn9xR0dHo7KyUq9zEmII999/P+6//36+wyBGxNLSEhMmTMDFixfBMAwuXLiA6OhovsMihJAxRe+ku7a2FiUlJQgPD0dGRgbefPNNREZGYsuWLbjjjjuGIkZCyCg2kPngnKwsICpK667sCxdwesmSIauO3lfcBlnmjJABqK+vx//93/+huLgYSUlJcHR0RGZmJtzc3Lh6LGTsCQkJQVFRETo6OlBSUoKgoCDY29vzHRYh/ZowYQLs7Ozg5ubGdyiEDIpeSfeuXbvwxBNPwNbWFm1tbdi5cydeeeUVPPDAA1i2bBl27NiBDz/8kH4xCCF6GdC85156t/HFF8Ajj6AuJaXfKuMymWzg1dFB87WJcblw4QLmzZsHOzs7XLlyBU888QQcHR3x448/orS0FDt37uQ7RMITsViMkJAQnD9/HgBw/vx5zJkzh+eoCOnfn3/+SdO1yKig16d4/fr1+PzzzyGVSnHo0CGuMEtQUBCOHj2KW265BTExMUMSKCGEAOha7qu3hLuzE3jkEQDqVca1GVR1dEKM0OrVq/HII4/g8uXLatXK77jjDqSkpPAYGTEGEydO5KYCVlRU0BQYQggZRnol3XK5HBMnTgQABAQEaBTjePLJJ5Genm646AghpLutW7WvvQ10JeMiEfdQVWVcKpWCZdkeh3ZVGQ8JCdGvOjohRuzMmTN4+umnNbZ7enpCKpXyEBExJiKRSG1kzrlz5zT+NhJCCBkaeiXdS5cuRXx8PBYuXIjp06fj4Ycf1jjG1dXVYMERQkY3hmGQnZ2NlJQUZGdn9z0XWiAAVq7U3H7gQFfC3YPBq6MTYuTEYjEaGxs1tl+6dAkuLi48RESMjZ+fH2xtbQEANTU13BrehBBChpZec7rfe+893Hjjjbh48SIeeeQR3HrrrUMVFyFklEtNTeWqfysUit7Xz5bLARsb7Sfpp5fGYNXRCRkB7rrrLrz22mv4/vvvAXQVDCwtLcULL7yA++67j+foiDEQCASIiIjgphucP38enp6edPORGK3FixejpqYGzs7O+Prrr/kOh5AB07t6+Z133ok777xzKGIhhIwRqampSEpKQm1tLdzd3WFhYYHW1lZu/ezNmzd3JcTr1wNvvaV5grAwIDtbp9caVHV0QkaQd999F3/729/g6uqK1tZWzJkzB1KpFDExMfjXv/7Fd3jESHh4eMDZ2RnV1dVoampCcXExAgMD+Q6LEK1SUlJQXl5Oqy+QEU/npPvbb7/Fgw8+qNOxZWVlKC0txcyZMwccGCFkdGIYBlu3bkVtbW2f62fH9vb34/p1QCLR6zWpyjgZC+zs7HDw4EGcPHkS58+fh1wuR1RUFObNm8d3aMSIqHq7//zzTwBATk4OfH19YWKidz8MIYQQHenc1fPRRx8hODgYmzZtQn5+vsb+hoYG/P7771i4cCGioqJQU1Nj0EAJIaNDbm4u8vPze10/+0ZLS3y9a5f2J7Os3gk3IWNBR0cHTExMkJOTg5kzZ2LFihVYu3YtJdxEKxcXF67nsLW1FQUFBTxHRAgho5vOSfexY8fw9ttv4+DBgwgLC4OtrS3Gjx+P8PBweHl5wcnJCY899hh8fHyQk5ODu+66ayjjJoSMUHV1db2un/1+Sgq2ZWZqPmnXrn7nbxMylpmamsLHxwdKpZLvUMgIMXnyZO7/8/Pz0dbWxmM0hBAyuuk1luiuu+7CXXfdherqapw4cQJXr15Fa2srnJ2dERkZicjISJonScgYwTDMgOZJd18/29raumsjy+K3vXu1P6GzU20psOGMlZCR5MUXX8Q//vEP/Pe//4WjoyPf4RAjZ2dnx03p6ejoQHZ2NqZNm8Z3WIQQMioNaAKPs7MzFixYYOBQCCEjhc6Vx7VQrZ+dlZWFgIAAzJRKsT4jQ+uxKceOwSEvb1BJ8mBiJWQk2bp1KwoLC+Hh4YFx48bByspKbX+mtlEkZEwLDw/H1atX0dnZiaKiIkyYMAF2dnZ8h0UIIaMOVc0ghOglLS0Na9as6b/yeC9U62cnJSVhTy+920/FxOBMaysUy5YNKknWuUo6IaMA3Qwn+rKwsEBISAguXLgAlmWRlZWFuXPn8h0WIYSMOpR0E0J0xjAMtm3b1m/l8ejo6D57pmMDA5GalqZ1X3hYGDoMkCTrWiW9v1gJGSleeeUVvkMgI9DEiRNRWFiIlpYWXL9+HVKpFBIqWEkIIQZFV5qEEJ2Vlpbi4sWLvVYel0gkyMvLQ25ubu8niY4G3Nw0NlctXoyHHnwQHR0dCAwMhLW1NUQiEZck19XVITk5GQzD6BRrf1XSdYqVEEJGORMTE0yaNIl7nJmZCZYKVxJCiEFRTzchRGdyubzXyuNA11BFmUyGuro67SfokfxyysshranBxSVLdEqSdVlzu68q6TrFSsgIo1QqsWXLFnz//fcoLS1Fe3u72v7a2lqeIiPGztfXF5cuXUJtbS0aGhpQXFyMgIAAvsMiBE888QQaGxup1gAZ8QbV093e3o6CggJ0dnYaKh5CiBGztrbmKo9r09raCrFYDAcHB/UdKSm9J9wsC3h46JQkKxQKnZPk7lXS9YqVkBFqw4YNeO+99/DAAw+goaEBq1evxr333guhUIhXX32V7/CIERMIBIiMjOQeX7hwAR0dHTxGREiXl19+Ge+99x5NnyEj3oCS7paWFjz++OOwtLREaGgoSktLAQArV67EW2+9ZdAACSHGw8fHB0FBQZBKpRrDD1mWhVQqRUhICEJDQ/+3QyAA5szRPNk776itvW3oJFlVJV2vWAkZwb7++mt88skneP7552FiYoKHHnoIn376KV5++WWkp6fzHR4xcq6urvDy8gIAtLW1IT8/n+eICCFk9BhQ0r1+/XqcP38eR48ehbm5Obd93rx5+O677wwWHCHEuAiFQqxYsQIODg4oKiqCXC6HUqmEXC5HUVERHBwckJCQ0FWYTKnstXeb6ehAdlwcUlJSkJ2dDYZhDJ4kq6qk6xQrIaOAVCrlpl5YW1ujoaEBADB//nzs7WWlAEK6i4iI4P4mXrx4ES0tLTxHRAgho8OArjZ//vlnbN26FTfccIPa3MvQ0FAUFRUZLDhCiPGJiYnB5s2bERkZifr6ely5cgX19fWIior6X3XxXbsAE+0lI1JPnsTiJUuwZMkSLFu2DEuWLMHixYuRnp5u8CQ5Nja2/1gJGSW8vLxw/fp1AEBAQAAOHDgAADhz5gzEYjGfoZERwsbGBuPHjwfQVSPg3Llz/AZECCGjxIAKqVVVVcHV1VVje3Nzs0YBJELI6BMbG4vo6Gjk5uairq4ODg4OCA0N7UqIe/sbkJ6OVKWy33WzN2/ejK1btyI/Px8ymQxisRhRUVFISEgYUJLcZ6yEjCL33HMPDh06hBkzZmDlypVYvHgxPvvsM5SWluK5557jOzwyQoSFhaGkpATt7e24evUqxo8fDxcXF77DImOUj48PysvL4enpiWvXrvEdDiEDNqCke+rUqdi7dy9WrlwJAFyi/emnnyImJsZw0RFCjJZQKFSvIl5bCzg5aT+YZbvWzV68uN91s//73//qnCQzDKPTcRqxEjIKda+p8sADD8DHxwdpaWkYP3487rzzTh4jIyOJmZkZJk2ahLNnzwIAMjIyEBcXR50qhBAyCANKut98803cfvvtyMvLQ2dnJz744APk5eUhNTUVx44dM3SMhBBjFx4O5ORobv/HP4B//QuAfutmh4eH95skp6amcj3iCoUCYrEYwcHBSExMpGHjhKBrKgjdCCcDERAQgMuXL6OhoQF1dXW0hBghhAzSgJLuG264AefPn8fGjRsRHh6OAwcOICoqCmlpadSbRMhY01vvR1MTYG3NPTTkutmpqan9DlOnxJuMNTt37uxz/5IlS4YpEjLSCYVCTJkyBYcPHwYAnD9/Ht7e3jAzM+M5MkIIGZn0Tro7Ojrw9NNP45///Cc++eSToYiJEDISZGUBUVHa9/WoPg50LQlmZmaGqqoqmJqawtTUFDY2Nlyvt65LgjEMg61bt/Y7TD06OprmbZMx5dlnn1V73NHRgZaWFpiZmcHS0pKSbqIXNzc3eHt7o6ysDAqFArm5uWpreRNCCNGd3lekpqam+OGHH4YiFkLISOHlpT3hTk7WmnAD4IYpZmdn48KFCzh37hyysrJQW1ur15Jg+gxTJ2QsqaurU/snl8tRUFCAG264Ad988w3f4ZERKDIyEiKRCABQUFCAxsZGniMihJCRaUDdQAsWLMDPP/9s4FAIIUZPqYRQJALKyzX3MQywYoXWp6WmpmLt2rUAALFYDJZlIRQK0dDQgJycHGRnZ+u8JJguw9QVCoVOw9QJGe3Gjx+Pt956S6MXvD8fffQRJk2aBFtbW9ja2iImJgZ//PEHt7+trQ0JCQlwcnKCtbU17rvvPshkMrVzlJaWIj4+HpaWlnB1dcWaNWvQ2dmpdszRo0cRFRUFsViMwMBA7NixY8DvlRielZUVgoKCAAAsyyIzM5PniAghZGQaUNI9fvx4vPbaa/jb3/6GjRs34t///rfav6Hy1ltvQSAQYNWqVdw2Xb74CSEG8MUXkHh5aW6Pje3q3e5lbnf34eCqAmn29vZgGAZA1++wQqHA008/jejo6H7DcHBwgFgsRmtrq9b9ug5TJ2SsMDExQUVFhV7P8fLywltvvYWMjAycPXsWN910E+6++25uBMlzzz2H3377Dbt378axY8dQUVGBe++9l3u+UqlEfHw82tvbkZqaii+//BI7duzAyy+/zB1TUlKC+Ph43HjjjTh37hxWrVqFJ554Avv37zfMGycGERISAktLSwDA9evX9f4sEUIIGWAhtc8++wz29vbIyMhARkaG2j6BQIBnnnnGIMF1d+bMGfznP//BpEmT1LY/99xz2Lt3L3bv3g07OzskJibi3nvvxcmTJw0eAyFjRc+luMInTdJ+h66wEOinom3P4eAODg6wt7dHeXk5rl27BoZhUF9fj40bN2L//v39Vh8PDQ1FcHAwsrKyEBAQoDbEXDVMPSoqqt9h6oSMNr/++qvaY5Zlcf36dWzduhUzZ87U61w9lxj717/+hY8++gjp6enw8vLCZ599hl27duGmm24CAHzxxRcIDg5Geno6oqOjceDAAeTl5eHPP/+Em5sbIiIi8Prrr+OFF17Aq6++CjMzM2zfvh1+fn549913AQDBwcE4ceIEtmzZgri4uEG0BDEkExMTREREIDU1FQCQmZkJiUTCc1SEEDKyDCjpLikpMXQcfZLL5Vi0aBE++eQTvPHGG9z2hoaGfr/4CSH66b4Ul2VzM05evqz9wF7mbvekbTh4fX09rl69ivb2dm44uIWFhU7Vx4VCIRITE5GUlISioiJIJBKuerlUKtV5mDoho82CBQvUHgsEAri4uOCmm27iEtuBUCqV2L17N5qbmxETE4OMjAx0dHRg3rx53DFBQUHcuuDR0dHcaiZubm7cMXFxcVi+fDlXkCstLU3tHKpjuo9m00ahUEChUHCPVfOMGYbhRtAMFMMwYFl20OcZbby8vODs7Iyqqio0NjYiLy8PQUFB1FZ6oM+WflTt1XMb0Y4+X/oxZHvpeo4BJd3dqX4hehY0MqSEhATEx8dj3rx5akm3Ll/82gzlFzbf6JdOd9RWmtLS0rB27VrU1dXh24oKTGpo0DhG+eqrEPzzn11zuHVgb28PCwsLtLW1wdraGizL4urVq+js7ISNjQ06OzthamoKOzs7eHl5obi4GNu2bcP06dN7TZyjo6PxzjvvYNu2bbh48SKqqqogFosxZcoULF++HNHR0bz+XOmzpTtqK8NdSBq6DbOzsxETE8P97v70008ICQnBuXPnYGZmBnt7e7Xj3dzcIJVKAQBSqVQt4VbtV+3r65jGxka0trb2Wrdh48aN2LBhg8b2qqoqtLW1Dei9qjAMg4aGBq7uBPmfcePGoby8nJvbbWlpCYVCQW2lI/ps6UfVXu+//z46OjogFotRWVnJd1hGiz5f+jFkezU1Nel03ICT7p07d+Kdd97B5b96wSZMmIA1a9bg4YcfHugptfr222+RmZmJM2fOaOyTSqX9fvFrM5Rf2HyjXzrdUVupYxgGP/30E1xdXXHyr2GEPW165RUseuIJiPT44nN2dsaNN96I4uJiSCQStLa2wt/fHyYmJhAIBFAoFLCysoK/vz/XM9fc3IyzZ8/C19e31/MGBATgnXfeQWlpKeRyOaytreHj4wOhUMj7FzN9tnRHbaX7F/ZwmzhxIs6dO4eGhgb83//9H5YuXYpjx47xHRbWr1+P1atXc48bGxvh7e0NFxcX2NraDurcDMNwf4fG6uexN66urmhoaOCu+65du4bx48dTW+mIPlv6UbXXggULqL10QJ8v/RiyvczNzXU6bkBJ93vvvYd//vOfSExM5OaJnThxAsuWLUN1dTWee+65gZxWQ1lZGZ599lkcPHhQ5zeki6H8wuYb/dLpjtpKXU5ODqr27MFPBQVa9998001wuXgRcdXVCA8P1+vc99xzD9auXYuCggKYm5vj8uXLMDMzQ3t7O8zMzBAUFIRr164B6BrKevXqVSgUCri6uvZ7bmOcW0ifLd1RW+n+hd2f7t9r/Xnvvff6PcbMzAyBgYEAgClTpuDMmTP44IMP8MADD6C9vR319fVqN71lMhn3+yiRSHD69Gm186mKnHY/pmfhU5lMBltb2157uYGuFRDEYrHGdqFQaJDPkEAgMNi5RpvJkydz63Zfu3YNjo6OcHNzo7bSEX229EPtpR9qL/0Yqr10ff6Aku4PP/wQH330EZYsWcJtu+uuuxAaGopXX33VYEl3RkYGKisrEdVtPWClUomUlBRs3boV+/fv7/eLX5uh/sLmG/3S6Y7a6n9CYmPxZXOzxvb3J0/GIW9vmDMM9/umb3vNnDkT77zzDrZu3YrMzEy0t7eDYRjY2dnB19cXDg4O3FSVlpYWmJqawtHRcUT/XOizpbux3laGet9ZWVnIyspCR0cHJk6cCAC4dOkSRCKR2vfoQKeDMQwDhUKBKVOmwNTUFIcOHcJ9990HoGsN59LSUsTExAAAYmJi8K9//QuVlZXczbODBw/C1tYWISEh3DG///672mscPHiQOwcxPmZmZoiIiMCpU6cAAHl5eZg4ceKY/d0lhBBdDSjpvn79utYiR7Gxsbh+/fqgg1K5+eabkZ2drbbt0UcfRVBQEF544QV4e3v3+8VPCOlHRwdgZqb1j8Gd8fHcUmCtra2wtrYe8FJcsbGxiI6ORnZ2Np5//nkUFRUhJCRE7WKNqo8TMnB33nknbGxs8OWXX3K/p3V1dXj00Ucxa9YsPP/88zqfa/369bj99tvh4+ODpqYm7Nq1C0ePHsX+/fthZ2eHxx9/HKtXr4ajoyNsbW2xcuVKxMTEcLVUbr31VoSEhODhhx/Gpk2bIJVK8dJLLyEhIYG76b1s2TJs3boVa9euxWOPPYbDhw/j+++/x969ew3fOMRg/Pz8UFRUhKqqKjQ3N6OgoABhYWF8h0VGqaNHj3JzuufOnct3OIQM2IBuTQYGBuL777/X2P7dd99h/Pjxgw5KxcbGBmFhYWr/rKys4OTkhLCwMLUv/iNHjiAjIwOPPvqo2hc/IaQP27cDZmYam7OcnXHn/Plcws2yLGQyGby9vbleqoEQCoWYPHkyXnvtNbi7u6O4uBhyuRxKpRJyuRxFRUVUfZyQAXr33XexceNGtRtjDg4OeOONN/SuXl5ZWYklS5Zg4sSJuPnmm3HmzBns378ft9xyCwBgy5YtmD9/Pu677z7Mnj0bEokEP/74I/d8kUiEPXv2QCQSISYmBosXL8aSJUvw2muvccf4+flh7969OHjwICZPnox3330Xn376KS0XZuQEAgGmTp3KPc7NzUWzllFShBjCkiVLcNttt2Hx4sV8h0LIoAyop3vDhg144IEHkJKSws3pPnnyJA4dOqQ1GR9KW7ZsgVAoxH333QeFQoG4uDhs27ZtWGMgZETqZYjpvVFRyG9pgUQuV1uKy9HREfHx8QZJhmNjY7F582ZuaTKZTAaxWIyoqCgkJCT0uU43IUS7xsZGVFVVaWyvqqrSu1jbZ5991ud+c3NzJCcnIzk5uddjxo0bpzF8vKe5c+ciKytLr9gI/xwcHDBhwgRkZ2dDqVQiMzMTs2bN4jssQggxWgNKuu+77z6cOnUKW7Zswc8//wwACA4OxunTpxEZGWnI+DQcPXpU7bEuX/yEjDUMwyA3Nxd1dXVwcHBAaGjo/5Ll69cBDw/tT2RZJHVbp7t7MrxixQoEBATo9ho6UA03H8w5CCH/c8899+DRRx/Fu+++i+nTpwMATp06hTVr1uDee+/lOToy2oSFheHSpUsAuiqZV1RUwKO37xZCCBnjBrxk2JQpU/DVV18ZMhZCiAGkdkuaFQoFzMzM4OHhgfnz52Phr7/Cfv9+zSdt2gSsWQOg92QYALcUV8/XEIvFCA4ORmJiol691EKhUO9K6IQQ7bZv346kpCQsXLgQHR0dAAATExM8/vjjeOedd3iOjow2ZmZmmDhxIgr+WvEiIyMDbm5uEIlEPEdGCCHGZ0BJ9++//w6RSKQx72r//v1gGAa33367QYIjhOgnNTUVSUlJqK2thbu7O9ra2lBcXIyLFy/i9z/+0P6k1lagx5JF2pJhhmEAAGlpaVizZg33Gqoh6FlZWUhKSsLmzZtpeDghPLC0tMS2bdvwzjvvoKioCEDXevZWVlY8R0ZGKw8PD9TW1qK6uhpyuRy5ubmYNGkS32ERQkifVNe0w2lA4zjXrVsHpVKpsZ1lWaxbt27QQRFC9McwDLZu3Yra2loEBgaivb0dBQUFcGtqQptCof1JLKuRcPf3Gtu2beNew9raGiKRCNbW1ggICEBdXR2Sk5P1/mPGMAyys7ORkpKC7OxsXv4YEjJaWFlZYdKkSbCzs8PVq1fp94kMGVVRNdW0oPz8fDQ0NPAcFSGE9I5lWRw6dAgXL15EZ2fnsL3ugJLuy5cva61gHBQUhMLCwkEHRQjRX25uLvLz8+Hu7g4AuHLlCt5vasKF1laNY5d4e2PRwoV6X4yXlpbi4sWLcHd311jrVyAQQCKRIC8vD7m5uTqfMzU1latsvGzZMixZsgSLFy9GamqqXrERMlZ9/vnneO+999S2PfXUU/D390d4eDjCwsJQVlbGU3RktLOzs0NQUBCArhuop0+fBsuyPEdFCCHaXbp0CTU1NSgpKcHJkyeH7XUHlHTb2dmhuLhYY3thYSENYyOEJ3V1dVAoFF3DvRsaUF5RgSVa7uDFxsSgLCBA7+QYAORyOfca2lhYWEChUKCurk6n86mGw2dmZsLe3h6+vr6wt7fnhqpT4k1I/z7++GO1ZcL27duHL774Ajt37sSZM2dgb2+PDRs28BghGe3CwsJgbW0NAKiurtZ6jUgIIXxraWnBhQsXuMeDWQZXXwNKuu+++26sWrWKmzMGdCXczz//PO666y6DBUfIaDEcw6cdHBwgFosRdu0aDp04obF/jZUV7GxtYWpqqndyrGJtbQ2xWIxWLb3nANDa2gqxWKyWAPSm53B4Qw1VJ2SsuXz5stq6yb/88gvuvvtuLFq0CFFRUXjzzTdx6NAhHiMko51IJMK0adO4x1lZWWhra+MxIkII0ZSRkcENKff29oaLi8uwvfaAku5NmzbBysoKQUFB8PPzg5+fH4KDg+Hk5ITNmzcbOkZCRrThGj4dGhqKX0pKsCk7W2PfeGdnfISupNnGxkav5Lg7Hx8fBAUFQSqVagwfZFkWUqkUISEhXLXzvnQfDm+ooeqEjEWtra2wtbXlHqempmL27NncY39/f0ilUj5CI2OIRCLBuHHjAAAdHR3IzMzkOSJCCPmfa9eu4dq1awAAsViMiRMnDuvrD3h4eWpqKvbu3YsVK1bg+eefx6FDh3D48GHY29sbOERCRq5hGz5dVwehSAQfLQVsnBwdcb21FWZmZvDz8wMAvZLj7oRCIVasWAEHBwcUFRVBLpdDqVRCLpejqKgIDg4OSEhI0Gmt7e7D4bUZaG88IWPNuHHjkJGRAaBraG9ubi5mzpzJ7ZdKpbCzs+MrPDKGREVFwczMDABw9epVutlDBq20tBQsy3LJEiED0d7ejrNnz3KPo6KiYGpqOqwxDCjpBrp6om699VasWbMGiYmJanfVCSHDOHz6ww8BR0eNzUs8PWFpYYHm5mZYWlpi4sSJMDU11Ts57ikmJgabN29GZGQk6uvrceXKFdTX1yMqKkqv5cJUw+ENMVSdkLFs6dKlSEhIwOuvv46///3vCAoKwpQpU7j9qampCAsL4zFCMlaYm5sjIiKCe3z69Gmtq90QQshwOn/+PHe96e7uDh8fn2GPQa91utPS0lBTU4P58+dz23bu3IlXXnkFzc3NWLBgAT788EOIxWKDB0rISKPP8Omea2LrrMd5VRiFAmsKChB9/Dj27NmDiooKNDQ0oK2tDVFRUUhISBjUWtqxsbGIjo5Gbm4u6urq4ODggNDQUL2S+NDQUAQHByMrKwsBAQFqbaQaqh4VFaV3bzwhY83atWvR0tKCH3/8ERKJBLt371bbf/LkSTz00EM8RUfGGn9/f5SUlKCqqgrNzc3IycnB5MmT+Q6LEDJGVVZWcqtrmZiYYNq0aRrX5cNBr6T7tddew9y5c7mkOzs7G48//jgeeeQRBAcH45133oGHhwdeffXVoYiVkBFFl+HTMplsYMOnL14EgoM1t69YASQnQwggPDwc4eHhWLZs2aCS494IhcKB3yz46/mJiYlISkpCUVERJBJJV+X11lZIpdJB9cYTMpYIhUK89tpreO2117Tu75mEEzKUBAIBpk2bhn379oFhGOTn58PHx4dGLRFChp1SqcTp06e5x5MmTYKVlRUvRXr1SrrPnTuH119/nXv87bffYsaMGfjkk08AdFWBe+WVVyjpJgTqw6dVS6l0N+Dh0489Bnzxheb2wkIgIEBj82CTY10wDDOgxD42NhabN2/G1q1bkZ+fD5lMBrFYbJDeeEIIIfyws7NDSEgIcnJywLIs0tPTERcXRzdRid5ee+01NDY2ws7ODq+88grf4ZARJjc3F01NTQAAJycnTJgwgbdY9Eq66+rq4Obmxj0+duwYbr/9du7xtGnTUFZWZrjoCBlBeiaewcHBhh0+3dEB/FWgRkOPSuKDpS2J7k1qaiqXNCsUCojFYgQHByMxMVGnpNkQQ9UJIYQYl9DQUJSVlaGhoQH19fW4ePHisK6JS0aHTz/9FOXl5fD09KSkm+ilvr4eeXl5ALpG4EyfPp2XYeUqeiXdbm5uKCkpgbe3N9rb25GZmYkNGzZw+5uamoa9EhwhxqC3xHPOnDm4cuXK4IdP79sHdLvBxfn4Y+DJJ4flvSQkJCCgR0+6qjp7bW0t3N3dufenqs6ua2G14eiNJ4QQMnyEQiFmzJiBAwcOAOiakujl5aW2vB0hhAwFlmVx6tQpbnnbkJAQ3lfY0qsr6Y477sC6detw/PhxrF+/HpaWlpg1axa3/8KFCxoX5YSMdn0tC/bll19i6dKlg6v0PX689oS7oWFIEu7e3svatWuRn5/PHTts1dkJIYSMSE5OTggKCgLQ9Z3R/SKYEEKGyqVLl1BbWwsAsLGxMYqivHr1dL/++uu49957MWfOHFhbW+PLL7/k1mMEgM8//xy33nqrwYMkxFj1TDxVw1ZUiWdRURFSUlKwc+dO5Ofn6zd8uroacHHR3B4dDaSl9RnTQIZq9/deSkpKsHfvXsyaNQtCoXB4qrMTQggZ0cLDw3Ht2jXI5XJUV1fj8uXLvM6rJISMbk1NTTh//jz3eMaMGRCJRDxG1EWvpNvZ2RkpKSloaGjgerW62717t9aCUYSMVromnvn5+folnu+9Bzz/vOb2lBSg2+iSngYzv7q/9+Lm5oaysjLk5eVh0qRJQ1udnRCiN6VSiR07duDQoUOorKzUGGVy+PBhniIjY5mJiQmmT5/Off7Onz8PT09PWFlZ8RwZIWS0UQ0rVyqVAIDAwEC4aOvA4oFeSbeKnZ2d1u2Ojo6DCoaQkcbgiSfLAr31Snd2An3cqRvs/Gpd3ktHRwf3XoasOjshZECeffZZ7NixA/Hx8QgLC+O1YAwh3bm5uXGjvzo7O3H69GnMnTuXPqOEEIO6dOkSqqqqAACWlpaIjIzkOaL/GVDSTQjpYtDEMzcXCAvT3P7cc109333QZZh7cnIyoqOjex1qrst7sba25t5LaGioYauzE0IG5dtvv8X333+PO+64g+9QCNEQERGBiooKrphocXEx1QEihBhMz2Hl0dHRMDExnlSX1uQhZBBUiadUKtUoDqNKPENCQvpPPBct0p5wl5T0m3ADug9zz83NHfB7kclk8Pb25pZ8EQqFSExMhIODA4qKiiCXy6FUKiGXy1FUVKRfdXZCyKCZmZkhMDCQ7zAI0crMzAzTpk3jHmdlZaG5uZnHiAgho4W2YeXdl7k2BnQ1TMggDDrxbG8HBAJg1y7NfSwL+PrqFIcuQ8MVCkWfw9z7ey/29vaIj49Xey+xsbHYvHnz4KqzE0IM4vnnn8cHH3xA1aGJ0fL09ITvX99rHR0dVM2cEGIQxjysXMV4+twJGaFUiaeqgJlMJoNYLEZUVBQSEhJ6Tzx/+w246y7N7Tt2AEuX6hWDoYa59/VeVqxYoXUoYGxsLKKjowdUMZ0QYjgnTpzAkSNH8McffyA0NBSmpqZq+3/88UeeIiPkf6ZMmQKZTIbW1lbIZDIUFhZi/PjxfIdFjNTs2bNRU1MDZ2dnvkMhRsrYh5WrGF9EhPBsIEtu6Z14+vgAZWWa25uagAGsAGDI+dW9vRcAqKys1PocoVBIy4IRwjN7e3vcc889fIdBSJ/MzMwwY8YMHD16FEDXMHOJRAIbGxt+AyNG6auvvqKb+KRXI2FYuQol3YR0M5glt3RKPCsrAW1/DObOBY4cGXDcqqHhSUlJKCoqgkQi4aqXS6VSvedXa3svPZcfIoQYly+++ILvEAjRibu7OwIDA1FYWAilUon09HTMmzePqpkTQvTSfVi5lZWVUQ4rV6FbR4T8RbXkVmZmJuzt7eHr6wt7e3tuya3U1NTBvcBbb2lPuFNTB5Vwq9D8akIIISNFZGQkt1Z3dXU1Ll68yHNEhJCRpKGhQW1Y+YwZM4xyWLmK8UZGyDAyxJJbvepr7W2lsvd9A0DzqwkZ2/7v//4P33//PUpLS9He3q62LzMzk6eoCNFkYmKC6OhoHDp0CABw4cIFeHh4wM7OjufICCHGjmEYpKWlccPKJ0yYYLTDylXoSpwQGGbJLa1++UV7Ur1uXd/JeC8YhkF2djZSUlKQnZ2tdci3amj47NmzER4eTgk3IWPEv//9bzz66KNwc3NDVlYWpk+fDicnJxQXF+P222/nOzxCNLi6umLixIkAur7f0tPTaSoTUTNv3jyEhobipptu4jsUYkRycnK4FXlsbGwQERHBb0A6oJ5uQqC55BbLsmhqakJHRwdMTU1haWnZ75JbGnqbm1ZaCnh76x3jYOabE0JGv23btuHjjz/GQw89hB07dmDt2rXw9/fHyy+/jNraWr7DI0SryZMno6KiAk1NTaitrUVOTg4mTZrEd1jESFy6dAnl5eVoaGjgOxRiJKqrq7lOMIFAgNjYWIhEIp6j6h91gREC9SW3amtrkZWVhXPnziE7Oxvnzp1DZmYmOjs7+11yC0BXBfLeEm6WHXDCPaTzzQkhI15paSl3A87CwgJNTU0AgIcffhjffPMNn6ER0iuRSISYmBhulFlubi5XGIkQQrrr7OxEWloa9zg8PByOjo48RqQ7SroJwf+W3CouLkZeXh4aGhpgYmICCwsLmJiYoL6+HnV1df3faV23DrC11dyekNCVcA9Az/nm1tbWEIlE3Hzzuro6JCcn05A8QsY4iUTC9Wj7+PggPT0dAFBSUgJ2gH9/CBkOTk5OCAsL4x6npaWho6ODx4gIIcYoMzMTcrkcQNffjeDgYJ4j0h0l3YSgax70ihUr0NzcjJaWFojFYohEIjAMA4VCAUtLS1hZWeGjjz7qPbkVCIC339bcXlcHbN064NiGbL45IWRUuemmm/Drr78CAB599FE899xzuOWWW/DAAw/Q+t3E6IWEhMDZ2RkA0NzcjIyMDJ4jIoQYk/LychQVFQHoKsQYExMzouoW0ZxuQv5iZ2cHR0dHiEQitLW1ob29HUKhEHZ2dvDz84OpqSmX3KqtYZ2WBvQ2p9oAvUs955v3ZGFhAZlMpt98c0LIqPPxxx9zNwUTEhLg5OSE1NRU3HXXXXj66ad5jo6QvgmFQsTExOCPP/5AZ2cnSkpK4OHhAR8fH75DI4TwrK2tDadOneIeR0ZGwsbGhseI9EdJNyF/qaurg4mJCaKiotDS0sIVUbOxsYFAIIBSqdRMbnubu/3118DChQaJq/t8c2tra439ra2tEIvFus03J4SMWkKhUO2u/4MPPogHH3yQx4gI0Y+1tTWmTp3KTY04ffo0nJ2dYWlpyXNkhBC+sCyL9PR0KBQKAICHhwcCAgJ4jkp/I6dPnpAhpkpu29raYGtrCycnJ9ja2nJDutWSW4bpPeHu7DRYwg38b765VCrVmJfJsiykUilCQkIQGhpqsNckhIxMx48fx+LFixETE4Py8nIAwH//+1+cOHFCr/Ns3LgR06ZNg42NDVxdXbFgwQIUFBSoHdPW1sb1qFtbW+O+++6DTCZTO6a0tBTx8fGwtLSEq6sr1qxZg87OTrVjjh49iqioKIjFYgQGBmLHjh36v3Eyavj6+sL7r4KjHR0dSEtLo5oEhIxhBQUFuH79OgBALBZjxowZGtMtRwJKugn5i87J7e+/A70tTcCyve8bIKFQiMTERDg4OKCoqAhyuRxKpRJyuRxFRUVwcHBAQkLCiJrXQggxvB9++AFxcXGwsLBAVlYW1yvQ0NCAN998U69zHTt2DAkJCUhPT8fBgwfR0dGBW2+9Fc3Nzdwxzz33HH777Tfs3r0bx44dQ0VFBe69915uv1KpRHx8PNrb25Gamoovv/wSO3bswMsvv8wdU1JSgvj4eNx44404d+4cVq1ahSeeeAL79+8fZGuQkUogEGD69Olc73ZlZSUuXrzIc1SEED7U1tbi/Pnz3OOYmBiYm5vzGNHA0VU6IX/RJbn9etcuCNet03zy8eMGmb/dm9jYWGzevBmRkZGor6/HlStXUF9fj6ioKGzevJnW6SaE4I033sD27dvxySefwNTUlNs+c+ZMZGZm6nWuffv24ZFHHkFoaCgmT56MHTt2oLS0lCtu1dDQgM8++wzvvfcebrrpJkyZMgVffPEFUlNTuaHBBw4cQF5eHr766itERETg9ttvx+uvv47k5GS0t7cDALZv3w4/Pz+8++67CA4ORmJiIv72t79hy5YtBmoVMhKZmZkhOjqae3zhwgXU1NTwGBEhZLh1dnYiNTWVq1USFBQEd3d3nqMaOJrTTUg3quR269atyM/Ph0wmg1gsxsywMHz6f/+n/UnDNOwtNjYW0dHRyM3NRV1dHRwcHBAaGtprDzfDMDofSwgZ+QoKCjB79myN7XZ2dqivrx/UuVXLJarWQ83IyEBHRwfmzZvHHRMUFAQfHx+kpaUhOjoaaWlpCA8Ph5ubG3dMXFwcli9fjtzcXERGRiItLU3tHKpjVq1a1WssCoWC68UHgMbGRgBdf/MGu3QiwzBgWZaWYNTBULeVi4sLgoKCkJ+fD6VSiRMnTiAuLg5mZmZD8npDjT5b+lG114svvoiWlhZYWVlR2/VhNH6+zpw5w/19d3R0RHh4uMHenyHbS9dzUNJNSA89k9uQjz+G89dfax44cyag5zzJwRIKheqV03uRmprK3ThQKBQQi8VcLxL1ihMyOkkkEhQWFsLX11dt+4kTJ+Dv7z/g8zIMg1WrVmHmzJncWspSqRRmZmawt7dXO9bNzQ1SqZQ7pnvCrdqv2tfXMY2NjWhtbdW6asPGjRuxYcMGje1VVVVoa2sb2Jv8C8MwaGhoAMuydJOyH8PRVm5ubtzILoVCgaNHj2Ly5Mkjcj4nfbb0o2qvu+++m2uvyspKnqMyXqPt81VRUcFNKzExMcH48eNRXV1tsPMbsr2ampp0Oo6SbjImaOv17QuX3Pb2xV5VBfy1nqixSU1NRVJSEmpra+Hu7g4LCwu0trYiKysLSUlJNBydkFHqySefxLPPPovPP/8cAoEAFRUVSEtLQ1JSEv75z38O+LwJCQnIycnRuxjbUFm/fj1Wr17NPW5sbIS3tzdcXFxga2s7qHMzDAOBQAAXF5dRceE6lIarrebNm4d9+/aho6MDtbW1aGpqQmBg4JC93lChz5Z+qL30M5raSy6Xo7CwEGKxGAAQHR2tcTN5sAzZXrrOMaekm4x6J06cwJtvvonLly9DqVTC1tYWISEhSEhI6H3JgStXAD8/7fuMuIoqwzDYunUramtrERgYyPUGWFtbIyAgAEVFRUhOTkZ0dPSI/6NMCFG3bt06MAyDm2++GS0tLZg9ezbEYjGSkpKwcuXKAZ0zMTERe/bsQUpKCry8vLjtEokE7e3tqK+vV+vtlslkkEgk3DGnT59WO5+qunn3Y3pWPJfJZLC1tdXayw10Va9VXYx113PJtIESCAQGO9doNxxtZWNjg+joaO6mz7lz5+Dq6qoxymIkoM+Wfqi99DMa2othGKSlpUGpVEIgEMDX13dQI7X6Yqj20vX5I/enQogO/vOf/2DBggU4fPgwKioqUF1djevXryM1NRVr165Ffn6+5pNeekl7wv3jj0adcANAbm4u8vPz4e7urjH8TiAQQCKRIC8vD7m5uTxFSAgZKgKBAC+++CJqa2uRk5OD9PR0VFVV4fXXX9f7XCzLIjExET/99BMOHz4Mvx5/E6dMmQJTU1McOnSI21ZQUIDS0lLExMQA6Koym52drTYk9ODBg9yNT9Ux3c+hOkZ1DkIAwNvbG+PHjwcAbn53z6XnyOh0/fp1XLt2jVsyioxu586dQ21tLYCuDqOpU6fyHJHhUE83GbVOnDiBF198EY2NjbCwsOCSULlcjvb2dgiFQuzduxezZs3qukvFML0v99XXutxGpK6uDgqFotceIgsLC8hkMtTV1Q1zZISQ4WJmZsYltQOVkJCAXbt24ZdffoGNjQ03B9vOzg4WFhaws7PD448/jtWrV8PR0RG2trZYuXIlYmJiuKrTt956K0JCQvDwww9j06ZNkEqleOmll5CQkMD1VC9btgxbt27F2rVr8dhjj+Hw4cP4/vvvsXfv3sE1Ahl1IiMjUVVVhfr6ejQ1NeHs2bNqFc7J6DRjxgyUl5fD09MT165d4zscMoTKyspQUFAAoKv3ODY2Vm0ljpHOqJPujRs34scff8TFixdhYWGB2NhYvP3225g4cSJ3TFtbG55//nl8++23UCgUiIuLw7Zt2zQKs5CxhWEYvPnmm2hsbIRAIFBbW9bExARtbW1oaWlBaWkp8vLyMKm1FdD25b16NfDuu8MY+eA4ODhALBajtbUV1tbWGvtbW1shFovh4ODAQ3SEkKHw2GOP6XTc559/rvM5P/roIwDA3Llz1bZ/8cUXeOSRRwAAW7ZsgVAoxH333af2/asiEomwZ88eLF++HDExMbCyssLSpUvx2muvccf4+flh7969eO655/DBBx/Ay8sLn376KeLi4nSOlYwNIpEIM2fOxP79+9HZ2YmSkhK4ublpjMIghIw8TU1NOHXqFPc4KioKTk5OPEZkeEaddB87dgwJCQmYNm0aOjs78Y9//AO33nor8vLyYGVlBQB47rnnsHfvXuzevRt2dnZITEzEvffei5MnT/IcPeFTbm4uLly4wM0J6T7forOzk0vEW1tb4f3YY8Bfa8+qkUqBEXbzJjQ0FMHBwcjKykJAQIDaEHOWZSGVShEVFdVvITlCyMixY8cOjBs3DpGRkWANNAVGl/OYm5sjOTkZycnJvR4zbtw4/P77732eZ+7cucjKytI7RjL22NraYtq0aUhLSwPQtaSQg4PDiJzfTQjpopoy0tHRAQDw8fEZkcUS+2PUSfe+ffvUHu/YsQOurq7IyMjA7Nmz0dDQgM8++wy7du3CTTfdBKDrLnxwcDDS09Np2NEYVlNTw61LKxAI1JJPoVAIhmEgamvDb3v2aD7Z3R2oqBimSA1LKBQiMTERSUlJKCoqgkQi4aqXS6VSODg4ICEhYUQX2SCEqFu+fDm++eYblJSU4NFHH8XixYu59bQJGW18fX0hk8lQXFwMpVKJ48ePj+j1uwkZ6zIyMrhrdhsbG0yfPn1ELgvYnxF15d3Q0AAA3MVERkYGOjo6MG/ePO6YoKAg+Pj4cHdBydhUU1MDpVIJkUgElmXV/gkEAnzEMKjXVoTl559HbMKtEhsbi82bNyMyMhL19fXcGqdRUVG0XBgho1BycjKuX7+OtWvX4rfffoO3tzfuv/9+7N+/32A934QYk6lTp3LTpORyOdLT0+mzTsgIVFJSgqKiIgBdU0huuOGGUTWPuzuj7unujmEYrFq1CjNnzkRYWBgAQCqVwszMTGNYkZubG1f0RRuFQgGFQsE9bmxs5F6DYRjDBz+MGIYBy7Ij/n0MlqOjI8zNzdHa2gqGYaBUKrl9yl7ahmlpAcTirqJpPfcxDPLy8rh1vkNCQoy6tzg6OhrTp0/XGvNAPxv02dIdtZXuqK1gkPcuFovx0EMP4aGHHsLVq1exY8cOrFixAp2dncjNzdVa44GQkUp1cb5//360t7ejvLwc+fn5gy4gSAgZPg0NDThz5gz3eOrUqaN6qsiISboTEhKQk5PDrdM4GBs3bsSGDRs0tldVVaGtrW3Q5+cTwzBoaGgAy7JGnRQONQsLC0RHR6O2tpa7+z2xuRn/zcvTOLbTwwPVGRnAXyMpesrPz8fevXtRVlaGjo4OmJqawtvbG/Hx8QgODh7S9zFYrq6ucHV1BQBUV1cP6lz02dIdtZXuqK26CsgYklAohEAgAMuyajccCRlNrK2tERMTg2PHjgEAzp8/DycnJyqkS8gI0N7ejuPHj3PfUf7+/kO2HrexGBFJd2JiIvbs2YOUlBR4eXlx2yUSCdrb21FfX692Z0Qmk0EikfR6vvXr12P16tXc48bGRnh7e8PFxQW2trZD8h6GC8MwEAgEcHFxGbMXsEBXT/fFixdRUVEBoVCIorY2eGg5rvrLL2G/cCFce2mrtLQ0vPTSS6irq+PmR9fX1yMnJwdpaWnYtGnTmFlPlj5buqO20h21VVdBssFSKBT48ccf8fnnn+PEiROYP38+tm7dittuu23MtisZ/Tw8PBAaGorc3FwAwMmTJ3HbbbfB0tKS58gIIb1hWRbp6encDWc7O7tRtR53b4w66WZZFitXrsRPP/2Eo0ePaiwLMWXKFJiamuLQoUO47777AAAFBQUoLS3tMxESi8XcGqHdCYXCUXFxoqrWPRrey0AVFBTA1NQUVmIxanvpRQqaMAE7JkzA9F7aimEYJCcno6amBoGBgVxRBysrK/j5+aGoqAjbtm1DTEzMmGlr+mzpjtpKd2O9rQb7vlesWIFvv/0W3t7eeOyxx/DNN9/A2dnZQNERYtzCw8NRU1MDqVQKhUKBkydP4uabbx6zf08IMXY5OTkoLy8HAJiZmWH27NkQiUQ8RzX0jDrpTkhIwK5du/DLL7/AxsaGm6dtZ2cHCwsL2NnZ4fHHH8fq1avh6OgIW1tbrFy5EjExMVS5fIyrq6vD/XI53tCScJ8yM8OqqCiYNDVBLpf3eo7c3Fzk5+fD3d1do4qiQCCARCJBXl4ecnNzER4ebvD3QAghuti+fTt8fHzg7++PY8eOccNte/rxxx+HOTJChp5AIEBsbCz27duHlpYWVFdXIyMjA9OmTeM7NEJID9euXUNOTg73ODY2dszUHDHqpPujjz4C0LWGZ3dffPEFHnnkEQDAli1bIBQKcd9990GhUCAuLg7btm0b5kiJsZk9Zw5ma9n+4LRpkLu6wry5Ge3t7X3+otfV1UGhUMDCwkLrfgsLC8hkMtTV1RkoakII0d+SJUtG5fIqhOhKLBbjhhtuwJ9//gmGYVBYWAgHB4dRudbvWHPw4EEwDAMTE6NOWYgOGhsbkZ6ezj2ePHky3N3deYxoeBn1J1iX5R/Mzc2RnJyM5OTkYYiIGCuGYZCbmwt5cTFiFizQesyd8+d3/Q/L4vr16wgMDERTUxNycnIQFhamMRTNwcEBYrEYra2tWpPz1tZWiMVibtkSQgjhw44dO/gOgRDeOTk5Ydq0aTh16hSArmVl7ezs4OLiwnNkZDAmTpxIUwVGgY6ODqSkpKCjowMA4O3tbfTFiA2NPsVkxEtNTcXixYtxdc4crQn3+87OuHHuXCiVSsjlcmRnZ6O6uhqFhYX46KOP8Oijj2Lx4sVITU1Ve15oaCiCg4MhlUo1bgCxLAupVIqQkBCEhoYO5dsjhBBCiA78/f0xceJEAF03448fP47m5maeoyJkbGNZFmlpaWqF06Kjo8fcCC1KusmIlpqaiqSkJOz65hvM1zLM+9N//xunb7kF9fX1uHLlCsrLy9HS0gIrKyt4eHjAzc0NdnZ2yMrKQlJSklriLRQKkZiYCAcHBxQVFUEul3OJe1FRERwcHJCQkEB3YAkhhBAjERERwS0bplAocPz4cXR2dvIcFSFjV/fCaaamppg1a9aYnC5A2QIZURiGQXZ2NlJSUnD+/Hl8u3EjUtPStB4bHBSEI+np2LlzJ3bu3Ilt27YhMDAQTk5OCA8Ph7W1NYRCIaytrREQEIC6ujokJyeDYRjuHLGxsdi8eTMiIyO5xL2+vh5RUVHYvHkzYmNjh+utE0IIIaQfQqEQM2fOhJWVFYCu+iynTp3SacoiMT67du3Cp59+il27dvEdChmAq1evahROs7Gx4TEi/oy92wxkxEpNTcXWrVuRn58PhUKB0wUF+He3BFnlpRkzcN7FBRK5HHl5ecjPz0d4eDiys7Nx/fp1vauRx8bGIjo6Grm5uairq4ODgwNCQ0Oph5sQQggxQmKxGHPmzMGBAwfQ2dmJ0tJSODg4ICQkhO/QiJ7WrVuH8vJyeHp6YuHChXyHQ/RQXV2tVjgtIiICHh4ePEbEL0q6xwhVobGRmjSqhpHX1tbCy80Nf6akaD3uzvh44K+Eumd18cFUIxcKhUO2LNhI/9kQQgghxsbOzg4xMTE4fvw4AOD8+fOwtbWFl5cXz5ERMvq1tLTg+PHj3OhRf39/BAUF8RwVvyjpHgN69hCLxWIEBwcjMTFxRAyPZhgGW7duRW1tLVaamiJBS8L9kZUV9s6dq9aD3bO6uDFWIx/pPxtCCCHEWHl5eXEj3YCu79ybb74ZTk5OPEdGyOjV2dmJY8eOoa2tDQDg4uKCadOmjbnCaT1Rd9oop+ohzszMhL29PXx9fWFvb6+1cJg23edQZ2dnq813Hi65ubnIz8/HxYICJHSbF6IyQSzGC0IhVxUR0F5d3NiqkQ/2Z0MIIYSQvoWGhmLcuHEAAKVSiZSUFKpoTsgQYVkWqampqK+vBwBYW1tj1qxZNIITlHSPCt0T45ycHC4x7t5DHBgYCGtra4hEoj4Lh3WnWopryZIlWLZsGZYsWaJ1aa2h1lxYiKxz57TumxkbiyoLCygUCjQ2NvZZXVxbNXKGYSCXy1FYWAixWIyZM2ciNzfX4DcXet686OzsHNTPhhBCCCH9EwgEmDFjBpydnQEAbW1tOHbsGLdeMCHEcM6fP69WqXzOnDkQi8U8R2UcaHj5CNdzeLKFhQVuvPFG3HPPPbC1tUV+fr7ehcNU51XNoXZ3d4eFhQVaW1u5Xthhq9z9t78h+ocfNDZ/FhyMnwMC4AjAz88PJSUlaG1txcWLFyESiTBhwgSsX79eI0ZVNfKtW7eioKAAMpkMFRUVaGtr425SfPLJJwYd4q1tCLm7uzsKCwvh6emp98+GEEIIIboTiUSYPXs2Dhw4ALlcjoaGBpw4cQJz5syhHjhCDKSwsBD5+fkAuq5lb7jhBtja2vIclfGgvzQjmLbhyXZ2diguLsbatWtx/PjxfguHKRQKjcJhg+0hNxiBANCScN9z++34OSAAQNcwltbWVkydOhV+fn4QiURQKpUoLy/Htm3btPbKx8bG4quvvsIXX3yB+fPnw8LCAmKxGJ6engYf4t3bEPLc3FyUlZVBoVBofV5vPxtCCCGE6E8sFmPu3LkwMzMDAEilUmRkZNBSYoQYQHl5Oc6cOcM9njJlCiQSCY8RGR9KukeovhJjiUSC+vp67N27F2ZmZmhtbdV6jt4Kh6nmUOvSQz4kjh/nKpD3FBwUhPrWVrVh5CYmJpBKpSgpKYGXlxeCgoLg4ODQZ+IsFAoREhKCvLw8KBQKjB8/3uA3F/r6GY0bNw4sy6KoqEjrFz4fRd0IIYSQ0czGxkZtfmlhYSEuXrzIc1SEjGw1NTU4efIk9zgoKAjjx4/nMSLjREn3CNVfYuzm5oby8nJ4eHjoXThMl6W1hqwXViQCZs/W3H7sGFJPnkRkZCTq6+tx5coV1NfXIzIyEu7u7ujo6NC7Vz4vLw9lZWWQSCRDcnOhr5+Rra0t7Ozs0NDQgMbGRrV9fBR1I4QQQsYCV1dXTJ8+nXt87tw5XLlyhb+ACBnBmpqacOzYMSiVSgCAj48PIiIi+A3KSNGc7hFKl8S4vb0d8+fPx1dffYWioiJIJBJubrZUKtUoNKbCy9JaCgVgbq593183DGIBREdHq61pzTAMHnnkkQHNW6+rq0NHR8eA1u3WRV8/I4FAAH9/f5w/fx5Xr16Fv7+/Tj8bQgghhAyOn58fmpubuaXE0tPTuXorxLiohijTUGXj09bWhqNHj3JTJV1dXREdHT3mlwbrDV3Rj1DdE2NtVInxrFmzsHnzZo0e4qioqF6LoQ370lpbtmhPuO+9l0u4VYRCIcLDwzF79myEhoYiMzMTdXV16Ozs1DpMu69eeQcHB5iamuo9/F5X/f2MzM3N4eXlhdDQUJ1/NoQQQggZvNDQUAR0qw9z4sQJ1NTU8BwV6en06dO4du0azp49y3copBvVWtxyuRxA1wjOWbNmQSQS8RyZ8aKe7hFKlRhnZWUhICBA7a4Sy7KQyWSIiIhAaGgohEKhRg+xars2qqW1kpKS9OohH5De7oaVlwMeHr0+TVURPDMzE1KpFNXV1bCzs4Ofn59aktxX4hwSEgJvb2/k5OTAz89Pow2lUimioqIGfHOhv5+RVCrFtGnT8OWXXyI/P1+nnw0hhBBCBk8gEGDatGlQKBS4du0al0TMmzePKi4T0geGYXDy5EnU1tYCALdykqpIIdGOruxHKG1rTquKi0mlUtjb22usUa3qIQ4PD+83qVMtraVPD7leysp6T7hZtt+EW1URXCKRwNHREQzDoL6+Hnl5eVyvdn+98kKhEPHx8bC3t9doQ23rfOurr59R9/ObmJjo9bMhhBBCyOAJBALExsbCxcUFAKBQKHDkyJFeR6gRMtaxLIv09HRUVFQA6FqLe+7cubC0tOQ5MuNHV/cjmLbEuKGhAf7+/ti0adOgE2PV0lo7d+7E9u3bsXPnTvz3v/8dfMIdHw/4+Ghu37pVYzh5Tz0rgtvY2MDPzw/m5uYQCARoa2tDcXExmpqadEqcg4ODsWnTpiG7uTDkNy8IIYQQMmCqNbzt7OwAAC0tLThy5Aja29t5jowQ48KyLM6ePYurV68C6OpcmjVrFuzt7fkNbISg4eUjXGxsrNrQcXt7ezg7Oxus4ISqh1wXDMP0P4S9t97t9nbA1LTf19BWEdzR0RHBwcHcTYfa2lpIpVJMmTIFCQkJ/Sa2MTExiImJ0Xn4vb56/oxoCDkhhBBiPMzMzHDjjTfiwIEDaGlpQUNDA44dO4Ybb7wRJiZ0qcynZcuWoa6uDo6OjvjPf/7Ddzhj2oULF1BYWAiga5TIzJkz4ebmxnNUIwf9JRkFuifGDMOgsrJSr+frlCz3QzXHOj8/HwqFAmKxGMHBwUhMTOxKeg8fBm6+WfOJlpZAc7POr9NbRXBHR0c4ODigoaEBZWVleOGFF7B06VKd34c+NxcGYqjPTwghhJCBU81L/fPPP6FQKFBdXY2UlBTMmTOHikPx6Pfff0d5eTk8PT35DmVMy8/PR15eHvd4xowZ8PLy4jGikYeS7hHKEIkyoEOyrOM5kpKSUFtbC3d3d67oWlZWFpKSkpCaltbbE4GYGL3i7Ws5M4FAABMTEzg4OGDq1KnUk0wIIYQQndna2uLGG2/EoUOH0NHRAZlMhhMnTmDWrFl0TUHGrMLCQpw7d457PGXKFPj5+fEX0AhFf0FGoNTUVCxevBhLlizBsmXLsGTJEixevBipqal6n0dVkMze3h6+vr6wt7f/X7Ksw/l6zrG2traGSCSCtbU1wn18ek+4WVbvhBvgYTkzQgghhIwZDg4OmDt3LjesvKKiAqmpqWAYhufICBl+V69exZkzZ7jHkyZNwoQJE3iMaOSipHuE6S9RTustye2hr2Q5ICAAdXV1SE5O7vdLRtscawD46MgRfH/ggOYTFi3qt1haX3StCE53pAkhhBAyEM7Ozpg9ezY3rLysrAynTp3SuNlPyGhWWlqqllcEBQUhJCSEx4hGNspMRhBdEuWPPvpIp7uxvSXLQNcwbYlEgry8POTm5vZ5Hm1zrH/bswde2uZpy2TAV1/p9mb7QBXBCSGEEDKU3NzccMMNN3A38a9cuYIzZ85Q4k3GhNLSUqSmpnKf94CAAERERGjkDER3NKd7BNElUc7Pz0dpaWm/1ct7K0imYmFhAZlMxq153Zvuc6zDGAYfpqRoPS77wgWEu7r2eS59UEVwQgghhAwlDw8PzJw5EydOnADLsigqKoJAIMDUqVMp+SCjVllZmVrC7e/vj2nTptFnfpAoQxlBdEmUFQoF5HJ5v+fqnixr09raCrFYDAcHB637GYZBdnY2ampq4O7ujiNHj2pNuI9ZWWHRwoVDMsdaVRF89uzZCA8Pp4SbEEIMJCUlBXfeeSc8PDwgEAjw888/q+1nWRYvv/wyVzxz3rx5uHz5stoxtbW1WLRoEWxtbWFvb4/HH39c4/vpwoULmDVrFszNzeHt7Y1NmzYN9VsjRC9eXl6I6VaDprCwEKdPn6YebzIqlZWV4eTJk2oJ9/Tp0ynhNgDKUkYQXRPlnlW9e2IYBgzDwMnJCVeuXNEYjt5fQbLuhdxWLF+O3//4Q+vrBPn6Yl14OM2xJoSQEaa5uRmTJ09GcnKy1v2bNm3Cv//9b2zfvh2nTp2ClZUV4uLi0NbWxh2zaNEi5Obm4uDBg9izZw9SUlLw1FNPcfsbGxtx6623Yty4ccjIyMA777yDV199FR9//PGQvz9C9DFu3Di1xLu4uJjmeJNRp2fC7efnRwm3AdHwch7pu+yXqnJ3VlYWAgIC1H4JVInylClT4OPj0+s5ui8RVldXh6qqKtTU1CAwMBASiQStra2QSqW9FiTrvjzYkyyL5y9d0vo65mIxLOrr4R0YqGerEEII4dvtt9+O22+/Xes+lmXx/vvv46WXXsLdd98NANi5cyfc3Nzw888/48EHH0R+fj727duHM2fOYOrUqQCADz/8EHfccQc2b94MDw8PfP3112hvb8fnn38OMzMzhIaG4ty5c3jvvffUknNCjIGvry+EQiE37LakpASsQoEZly5B+P33QHk54OkJPPAAsHAhYGnJd8iE6Exbwj1jxgxKuA2Ikm6eDGR9bFXl7qSkJBQVFUEikXBrYqsS5eXLl/eauPdcT9vd3R1SqRSFhYUoKChAbW0tHBwcEBUVhYSEBI04uhdyu1hQoPU17hGLURIUhGk2NhCJRLh27RqSkpKowBkhhIwSJSUlkEqlmDdvHrfNzs4OM2bMQFpaGh588EGkpaXB3t6eS7gBYN68eRAKhTh16hTuuecepKWlYfbs2TAzM+OOiYuLw9tvv83djCbEmPj4+EAgEHQlJ52duLJnD5icHMTk50MoFgN5ecDLLwOHDwOffkqJtwE8+OCDqK+vp78HQ0g1ckPF19eXEu4hQEk3D3omv6rEWbXsV18Jqqpytyphl8lkEIvFXKIcHR2NyspKjef1rHyu+kXy9PSEu7s78vPzERAQgM2bN/c6Pzo3NxdlOTm9JtyWFhYwNTVFhJ0dbG1tAQDW1tYoKipCcnIyoqOjaZg5IYSMcFKpFEBXdefu3NzcuH1SqRSuPYpnmpiYwNHRUe0YPz8/jXOo9vV2ka1QKKBQKLjHjY2NAP43dWpDSrSpAAA4UklEQVQwGIYBy7K0JrMOxmpbeXp6YubMmTi5axeYmhpcHTcOSjs7xBQXQ8SyQFsbkJIC7NoFPPYY97yx2l4DpWqvt956i7t2pLbr3UA/X5cuXUJmZib3WDWknGXZUT19wpC/j7qeg5LuYdZb8qta9kuXBLWvyt29/eD7qnwuFAoxbtw4VFdXQygU9vq6Hk89hePZ2Rrbr5mbI9TMDBYmJmhvb0dHRwe3r+fyY+Hh4Tq1EyGEEKLNxo0bsWHDBo3tVVVVanPKB4JhGDQ0NIBlWbpJ3I+x3FampqYIuXoVWTY2YMzMUGRjgwYXF0TW1MCEZYG6OuDUKWD+fO45Y7m9BoLaSz/6thfLsiguLsalbtNEx40bB19fX1RVVQ1lqEbBkJ+vpqYmnY6jpHuY6bM+dl8Jqqpyt64GvUSYQAAnLZuX3nwzLre0gMnO5j64pqam+p2bEELIiKFaklImk8Hd3Z3bLpPJEBERwR3Tc9RVZ2cnamtruedLJBLIZDK1Y1SP+1r2cv369Vi9ejX3uLGxEd7e3nBxceFGWQ0UwzAQCARwcXGhC/1+jPW2ck1JgZOVFU5ERkIpFKIJQK6JCWZfvgxxdTVw7RrQbbTHWG8vfVF76Uef9mJZFhcuXMDVq1chFosBdNWNCgsLGzNDyg35+TI3N9fpOEq6h5mh1sfWV/fK59qqm/e6RNjly8CECVrPeedfd3BNOzogEAjQ1tYGBwcH2NjY6HZuQgghI46fnx8kEgkOHTrEJdmNjY04deoUli9fDgCIiYlBfX09MjIyMGXKFADA4cOHwTAMZsyYwR3z4osvoqOjg7tZe/DgQUycOLHP7wuxWMxdKHbX10gtfQgEAoOda7Qb023l7g7PvDzcZGGBYxMmoEMkQq2VFQ4FBeGmY8dg6e4O9GiXMd1eA0DtpR9d2otlWWRkZKCwsJBLsCMiIhAcHDxcYRoNQ32+dH0+fYqH2WDXxx4oVeVzqVSqMUej1yXCBAKtCfdGExPY2tigvLwcSqWS+6VlWRbjxo3TWlW9t+XHCCGEGB+5XI5z587h3LlzALqKp507dw6lpaUQCARYtWoV3njjDfz666/Izs7GkiVL4OHhgQULFgAAgoODcdttt+HJJ5/E6dOncfLkSSQmJuLBBx+Eh4cHAGDhwoUwMzPD448/jtzcXHz33Xf44IMP1HqxCTFaDzwAsCxcqqowLz8fFn9NrWsyM8PB6Gg0/u1vPAc4OoSEhMDW1hZBQUF8hzLiKZVKnDhxAoWFhdy2adOmjcmEmw+UdA+zASW/BqCqfO7g4ICioiLI5XIolUrI5XIUFRWpLxHGsl0Jtxbz4+Kw+69h7QUFBcjLy0NDQwOio6MRGBiIurq6vs9NCCHE6J09exaRkZGIjIwEAKxevRqRkZF4+eWXAQBr167FypUr8dRTT2HatGmQy+XYt2+f2jC7r7/+GkFBQbj55ptxxx134IYbblBbg9vOzg4HDhxASUkJpkyZgueffx4vv/wyLRdGRoaFC4G5c4G6OtgXF2NeWhqs6+qAjg60eHriTwcH1NTU8B3liCeXy9HU1AS5XM53KCOaQqHAoUOHcO3aNQBdvbwxMTEIpKV9h42AHc2l6XTU2NgIOzs7NDQ0DHo+mC5U1cvr6uq0Lvs1mOW1GIZBZWUlXF1dtSa52pYqCwkJ+d8SYR98AKxapfG8SnNzPN5teRiGYZCXl4fAwECu4nl6enrf5zYy/bUVUUftpTtqK91RWw3/d9BoY8j2o8+j7qitALS0dFUp/+47oLwcbT4+ODJvHuolEkAkgkgkQmxsLLy8vKi99KRqr6lTp6K8vByenp5cwkg09fX5ksvlOHr0KFfwy8TEBDfccINaTY6xxpC/j7p+B9Gcbh70t+zXUCaofVU+7613+7nJk1Ho7a22TSgUwtfXV63ieZ/nJoQQQggZTSwtgSee6PoHwBzAze3tSElJQVVVFZRKJY4fP47IyEiMHz+e31jJmFRTU4Njx45xyyxaWFhgzpw5VGeJB5R084TPBFWj8nllJdBjvVWVkOBg+Hp4QKRln7aib/pWVSeEEEIIGS3MzMxw44034tSpU7h69SoAICsrC42NjfDy8uI5OjKWlJeXIzU1FZ2dnQAAW1tbzJ07F1ZWVjxHNjZRFySPVAnq7NmzER4ezk+PsKWl9oQ7MhLZFy7wUvSNEEIIIWSkEolEiImJQVhYGLetsLAQmZmZ6Pir4BohQ4VlWeTn5yMlJYVLuF1cXHDLLbdQws0jSrrHMoEA0JZQS6VAZiZvRd8IIYQQQkYygUCA8PBwREdHc50qVVVVOHToEJqbm3mOjoxWSqUS6enp3MoTAODt7Y0bb7wRZmZm/AVGKOkek37/vdf522BZrudbr4rnvWAYBtnZ2UhJSUF2djYYhhmKd0QIIYQQYnT8/Pwwd+5cbi36+vp67Nu3DzKZjOfIyGjT1taGw4cP48qVK9y2sLAwzJw5EyKRtomiZDjRnO6xprdk+/HHgU8/1dg8mKJv2iqlBwcHIzEx0SirmRNCCCGEGJqbmxtuueUW7N+/H0qlEu3t7Thy5AgiIiIwceJECHq7NiNERzU1NUhLSwPLshAIBBCJRIiOjoaPjw/foZG/UNI9VjAM0Ntdrs7O3vdhYEXfVMui1dbWwt3dnVsWLSsrC0lJSYNaFo0QQgghZCSxtbVFbGwsCgsLuWl7WVlZqK2txfTp02FiQpfkZGBKSkpw+vRptLW1QSwWw9LSErNnz6aaS0aGfsPHgrfeAtav175Px2Xa9alKzjAMtm7ditraWgQGBnJ3cK2trREQEICioiIkJyerzXMihBBCCBnNTE1NMXv2bOTk5CAvLw8AcPXqVTQ0NGD27NlU5EqLbdu2QaFQwMLCgu9QjI5SqcTZs2dRXFzM1V5ydnbG7NmzYW5uznN0pKdRk/EkJyfD19cX5ubmmDFjBk6fPs13SMZBINCecJ84oXPCra/c3Fzk5+fD3d1dY8iUQCCARCJBXl4ecnNzh+T1CSGEEEKMkUAgwOTJk3HDDTdwvduqed7Xrl3jOTrjM3/+fPz973/H/Pnz+Q7FqDQ1NeHAgQMoLi7mtqkKplHCbZxGRdL93XffYfXq1XjllVeQmZmJyZMnIy4uDpWVlXyHxp/Kyr6Lpc2cOWQvXVdX1+ddSQsLCygUCrX1vQkhhBBCxgpvb2/ceuutsLa2BgC0t7fj+PHjyMjIgFKp5Dk6YsxKS0uxb98+1NfXAwA3fzssLIwKphmxUZF0v/fee3jyySfx6KOPIiQkBNu3b4elpSU+//zzYY3DWCp1O8XFQejurrlj1qwh693uzsHBgdb3JoQQQgjpg52dHeLi4uDl5cVtu3TpEg4cOICmpiYeIyPGSKlUIiMjAydPnuTW37axsUFcXBx8fX35DY70a8TP6W5vb0dGRgbWdxtCLRQKMW/ePKSlpQ1bHMZSqVsoEmm/k1JdDTg5DUsMqvW9s7KyEBAQoDbEXLW+d1RUFK3vTQghhJAxzczMDDfccAMKCwuRmZkJhmG44ebTpk0b88lURkYGOjs7YWZmhilTpvAdDm/q6+uRmpqKhoYGbpuPjw9mzJgBExMTWpJ3BBjxSXd1dTWUSiXc/lpbWsXNzQ0XL17U+hyFQgGFQsE9bmxsBNDVUz2QD21aWhrWrl2Luro6SCQSrlL3+fPnsWbNGmzatAkxMTF6n1cvR45AOG+e1l2MapjSMP5CJiQkYO3atSgpKYGbmxvXJjKZDI6OjlixYsVfIfH3R4JhGLAsS3+odETtpTtqK91RW/H7d5AQwj+BQIDx48fD2dkZJ0+eRFNTEzo7O5GWlobr169jypQpMDMz4ztMXtxzzz0oLy+Hp6fnmJzzzrIsLl68iAsXLnDfFUKhEFFRUWrFionxG/FJ90Bs3LgRGzZs0NheVVWFtrY2vc7FMAx++uknuLq6YvLkyWof/qCgIEilUvz000/w8/MbskrdzjNmwKS0VGN744YNaHnqqa753cMsICAAb7zxBvbu3YuysjJ0dHTA2toaUVFRiI+PR0BAAO9z7hmGQUNDA1iWpSrqOqD20h21le6orUDDSAkhALqm59122204e/YsSkpKAABXrlyBTCbD9OnT4eHhwXOEZDg1NzcjPT1d7XrZzs4OsbGxsLe35y8wMiAjPul2dnaGSCSCTCZT2y6TySCRSLQ+Z/369Vi9ejX3uLGxEd7e3nBxcYGtra1er5+Tk4MjR47Azs5Oa+ELuVyOI0eOYMmSJQgLC9PpnAzDIC8vj1sTOyQkRPvFqFIJYS93Pjvb22EtEsFar3djWK6urpg1a5Zu74UHDMNAIBDAxcXFaGIyZtReuqO20h21FajSLCGEY2JigujoaEgkEpw9exYdHR1obW3FsWPH4O/vj6ioKJiamvIdJhlCLMviypUryMjIQEdHB7c9KCgIkyZNomJpI9SIT7pVczwOHTqEBQsWAOi6iDt06BASExO1PkcsFkMsFmtsFwqFel/01dfXo7W1FW5ubtwaed2Zm5tDKpWivr5ep3P3NTc8Ojoaubm5qKurg9+JE/B+8UWt55Bevw5XkcgoLmCFQiEmTZrEdxi9EggEA/q5j1XUXrqjttLdWG+rsfq+CSG98/X1haurK06dOgWpVAoAKC4uhlQqxYwZM3rtWCIjW3NzM06fPs39zAHA0tIS0dHRGlNpycgy4pNuAFi9ejWWLl2KqVOnYvr06Xj//ffR3NyMRx99dMhfu3ulbtWyD93pU6k7NTUVSUlJqK2thbu7OzcPOisrC08//TQkEgmqq6uRde6c9hNcugQmIICX4eTaMAzD3SRwcHBAaGgoXVwSQgghhOjA0tISc+fORVFREbKystDZ2YmWlhYcOXIEfn5+iIyM1NqJREYehmFw6dIlXLhwQW3k7Lhx4zB16tQxO6d/NBkVSfcDDzyAqqoqvPzyy5BKpYiIiMC+ffuG5Y6QoSp1MwyDrVu3ora2Vq0wgrW1NRwdHZGZmYnmkhIUNzdrP4Gql91ICvIYSzV3QgghhJCRSiAQIDAwEO7u7mrze0tKSlBeXo6IiAj4+/tTQa0RrK6uDqdOnUJdXR23zcLCAlOnTlVbTo6MbKOm2zExMRFXr16FQqHAqVOnMGPGjGF5XaFQiMTERDg4OKCoqAhyuRxKpRJyuRxFRUVwcHBAQkJCvz28ubm5yM/Ph7u7u0bifuXKFfza3q414d7m5IRFCxcaVfVbVY99ZmYm7O3t4evrC3t7e2RlZSEpKQmpqal8h0gIIYQQMmJYWVnhpptuwtSpU7k53e3t7Th9+jT+/PNP1NfX8xsg0Vt7ezsyMzOxf/9+tYR7/PjxiI+Pp4R7lBk1STefYmNjsXnzZkRGRqK+vh5XrlxBfX09oqKisHnzZp16duvq6qBQKGBhYaG2vampCeUVFbhFS1L9t9tuw+7wcOTl5SE3N9dg72cwevbYW1tbQyQSwdraGgEBAairq0NycrJR3SQghBBCCDF2qqXF4uPjMW7cOG57dXU19u3bh8zMTLS3t/MYIdEFy7IoLCzEnj17UFBQwNWEsrW1xS233KJ2Y4WMHqNieLkxiI2NVSt0pu8cZm1zw0NqavB2WprW4++cPx9A1/ATmUymdoeMT7312ANdXxYSiYS7SRAeHs5TlIQQQgghI5OFhQViY2Ph7++Ps2fPoqmpCSzLoqCgACUlJQgLC8P48eOpjo4RkslkyMjIQENDA7dNJBIhJCTEqFb4IYZHSbeR6Dk3fM/evVqP2xQZieOentxjfQq16WsghdB667FXMbabBIQQQgghI5FEIsHtt9+O/Px85OXlQalUckOWL126hMmTJ8Pb25vmexuBxsZGnD9/HteuXVPb7uPjg4iICFhZWfEUGRkulHQbyGALh6nmhr/w/PO9Jtyx0dFwcnbmHutTqE1fA30/hqzmTgghhBBCeicSiRAWFgY/Pz9cuHABV65cAQDI5XKcPHkSTk5OiIiIgKurK7+BDlBubi4EAsGIvXEgl8uRk5ODkpISte0ODg6YMmUKXFxceIqMDDcaw2AAhiocFpuSguPp6Rrba8zMEB4Whrr6+gEXahuu96PqsZdKpRrrlqtuEoSEhBj8JgEhhBBCyFhlZWWFmJgYxMXFqSXYNTU1OHToEA4dOgSZTKZxbWbsbGxsYGtrCxsbG75D0UtLSwtOnz6NPXv2qCXc5ubmmDFjBuLi4ijhHmMo6R4kgxUOEwiA9es1Nl/65Rc4tLbiP//5z6AKtQ3X+zFUNXdCCCGEEKIfR0dH3HTTTZg9ezZsbW257ZWVlTh8+DD+/PNPXL9+vSv5bmkBPv0UuOUWICSk67+fftq1nQyIXC7H2bNn8dtvv6GoqIi7yWFmZobJkyfjzjvvpCXexigaXj5Igy4cVl4O9LYkAMtiwl//O9hCbcP2fvC/au6q4ekymQxisRhRUVFISEigdboJIYQQQoaIQCCAp6cn3N3dceXKFeTm5kIulwPoqnR+9OhRONnaIviHH+C5f39XD5y5OZCXB7z8MnD4cFfybWnJ6/sYSaqrq3Hx4kWUlZWpbTc1NcXEiRMxceJEmJmZ8RQdMQaUdA/SoAqHvfQS8K9/aW5PTAQ+/FBjs1AoHPKK34YqhDZcNwkIIYQQQogmoVAIf39/+Pn54erVq8jNzUVjYyMAoCYnBycAWN5yC8bX1CCgshJipRJobQWOHgV27QKeeILX+AFgy5YtaGpqgq2tLVavXs13OGpYlkV5eTkuXryIqqoqtX0ikQgTJkxAcHAwxGIxTxESY0JJ9yANuHBYb8NKmpt5vbNoyEJow3GTgBBCCCGE9E4gEMDX1xfjxo1DWVkZcnJy0FBRAQBosbDAeS8v5Hh6Ylx1NSbIZHCorwe++85oku7y8nJ4enoaTdLd0tKC4uJiFBUVoaXHUHxzc3NMmDABgYGBlGwTNZR0D1LPpb66D8nWWl08OxuYNEn7yYyguIXe74cQQgghhBg9gUAAHx8feHt7Q/bGGyhwc0OFRAIAUAoEKHZxQbGLCxw8POBXU4NxbW0wNzfnOWrjwDAMKioqUFRUhIq/blh0Z2tri6CgIPj6+kIkEvEQITF2lHQPkqpwWFJSEoqKiiCRSGBhYYHW1lZIpVL1wmE33ACcPKl5klOngOnThz94LfR6P4QQQgghZEQRCASQWFlBcvo0mnx9cdnNDcXOzuj4K1mss7JCnUSCrJ9/hru7O/z8/ODp6TnmkkmWZVFdXY3S0lKUlpaira1N4xiJRIIJEybAw8ODiqORPlHSbQD9Fg6bPr334eRG0LvdExVCI4QQQggZxR54AHj5ZdjU1yNKoUD4tWu44uyMYnt71JqbAx4eYFkWFRUVqKiogImJCdzd3eHt7Q0PDw+Ympry/Q6GBMMwqK6uRnl5OUpLSzWGjwOApaUl/P394e/vDysrKx6iJCMRJd0G0mvhsB9+ALT9YXrmGeCDD4Y/UB1RITRCCCGEkFFq4cKuKuVHjwL19TA1N8f48nKMZ1k0zJuHKzfeiCvXr3NJZ2dnJ8rKylBWVgahUAgXFxe4u7vD3d0ddnZ26r28LS1dhdi++65rlR5Pz64kf+FCo6yI3traCplMhoqKCly/fh3t7e0axwiFQnh4eCAgIEDrCj+E9IeSbgPSKBzW2y+kVAq4uQ1PUINAhdAIIYQQQkYhS8uuZcG6J8f+/sADD8Bu4UJMtrTEJJZFZWUlSkpKUF5eziWjDMNAJpNBJpPh3LlzMDc3h6urK1xcXOBibQ37pCQIjh7tug7ubSkybYn5ggVdz/npJ+D6dSAmpqvAsAGxLIuWlhZUV1ejqqoKMpmMq+jek2qpXB8fH3h5edGSX2RQKOkeClVVgKur9n1GOJycEEIIIYSMMZaWXRXKe6lSLhAI4ObmBjc3NzAMg6qqKly7dg3Xrl1TG3bd1tbGzXtGaSlMTExgP2cOHBUKOLS0wKGlBTZ1dTBRLUW2cGHXa3ZPzHNygBMnuk5oZwfU1HTFV1/fta28vOvYb74BHnxQp7fHsiyamprQ0NCA+vp61NXVoaamRuvcbBVTU1O4u7vDw8MDHh4eVIGcGAwl3Ya2Zg2webPm9q++AhYtGv54CCGEECOXnJyMd955B1KpFJMnT8aHH36I6UZSYJQQ0jX6UZWAR0VFoampCdevX4dUKkVlZSU6Ozu7DqyoQKeJCaqtrFDd4xyWDQ2wSUuDtVwOy7IyWAYFwRKAeUcHzCorIa6thaizE5DJgN6mMz70EACAuf9+dHR0QKFQoK2tDa2trWhtbUVzczPkcjnkcjmam5uhVCr7fF8CgQCOjo5wc3ODRCKBi4sLTaUkQ4KSbkPavFl7wt3ern1eNyGEEDLGfffdd1i9ejW2b9+OGTNm4P3330dcXBwKCgrg2tuoMUIIbwQCAWxtbWFra4uJEyeCYRjU19ejqqoKVbt3o8bKCi1aeohbLC3RIhRCVlICjB8PdD+muRmYNg3Czk6IlEoIGQbtDg5oy84G2trQZm6OX+LioBSJ0PnTT1AOcOSoqakpnJyc4OTkBGdnZ7i4uIzaonDEuFDSbUhr1qg/njoVOHOGn1gIIYSQEeC9997Dk08+iUcffRQAsH37duzduxeff/451q1bx3N0hJD+CIVCODo6wtHRERObmoBTp6Dw8upaeszSEg0WFmi0sEATy6Ld0RFobdXsyf4riWaEQjBCIViBAAozM4xzcoJDWxtszc3RokcRNqFQCGtra9ja2sLe3h729vaws7ODjY0NFUEjvKCk25A++AB49tmu/8/MBCIj+Y2HEEIIMWLt7e3IyMjA+vXruW1CoRDz5s1DWloaj5ERQgbkr6XIxHI5JEolJKoiZa2tYOvqoHj1VbT89htarl1Di7s7WszMoDA1RXtdHRRCIdpNTMCIROgUiQBLS6yPjoaQZSFgWQhaWyFgGJh2dMDU2RmmpqYwMzODhYUFzM3NYW5uDisrK1hbW8PCwoKSa2JUKOk2pGee6fpHCCGEkH5VV1dDqVTCrceKHm5ubrh48aLW5ygUCigUCu6xqvIwwzBgGGZQ8TAMA5ZlB32esYDaSj9jpr0efBA4cgQ4dgxobOwqktbW1tWTfeONMFu4EGZCIexffRXo7OzaD3QVTisv79qGrh7vqqgouGRmQqitzfbs6TMMlmXBjqHixWPm82UghmwvXc9BSTchhBBCRoyNGzdiw4YNGturqqr6rEqsC4Zh0NDQAJZlqZhSP6it9DOm2uvNN7uS7uPHu5JpJydg1ixgzhxALgduuQW4eBHIzu6qSG5qCjg4AO7uXUk3y4IRCNAQGAgWgFBb8lxZOexvy5iNqc+XARiyvZqamnQ6jpJuQgghhPDC2dkZIpEIMplMbbtMJoNEItH6nPXr12P16tXc48bGRnh7e8PFxQW2traDiodhGAgEAqpgrANqK/2MufZavLjrX29efRX49lvg+++BkhLAw6NrKbHmZmD9ejBCIQSA9p7ur7/ufWneMWrMfb4GyZDtZa4ardEPSroJIYQQwgszMzNMmTIFhw4dwoIFCwB0XQwdOnQIiYmJWp8jFou1rp0rFAoNcrEpEAgMdq7RjtpKP9Re3Vhb975G+GOPAffcA4FCgXs6O1ENwAXAr4Be63SPNfT50o+h2kvX51PSTQghhBDerF69GkuXLsXUqVMxffp0vP/++2hubuaqmRNCxhhn567h6ZWVyJo6FeXl5fD09ASuXeM7MkIGjJJuQgghhPDmgQceQFVVFV5++WVIpVJERERg3759GsXVCCGEkJGKkm5CCCGE8CoxMbHX4eSEEELISEeD/gkhhBBCCCGEkCFCSTchhBBCCCGEEDJEKOkmhBBCCCGEEEKGCCXdhBBCCCGEEELIEKGkmxBCCCGEEEIIGSJUvRwAy7IAgMbGRp4jGTyGYdDU1ARzc/NBL/Y+2lFb6YfaS3fUVrqjtvrfd4/qu4jox5Df4fR51B21lX6ovfSjai+GYbjHo+E6fajQ50s/hmwvXb/DKekG0NTUBADw9vbmORJCCCFjVVNTE+zs7PgOY8Sh73BCRr/r16/T30di1Pr7DhewdGsdDMOgoqICNjY2EAgEfIczKI2NjfD29kZZWRlsbW35DseoUVvph9pLd9RWuqO26ro73tTUBA8PD+qhGABDfofT51F31Fb6ofbSD7WXfqi99GPI9tL1O5x6ugEIhUJ4eXnxHYZB2dra0i+djqit9EPtpTtqK92N9baiHpyBG4rv8LH+edQHtZV+qL30Q+2lH2ov/RiqvXT5Dqdb6oQQQgghhBBCyBChpJsQQgghhBBCCBkilHSPMmKxGK+88grEYjHfoRg9aiv9UHvpjtpKd9RWxJjQ51F31Fb6ofbSD7WXfqi99MNHe1EhNUIIIYQQQgghZIhQTzchhBBCCCGEEDJEKOkmhBBCCCGEEEKGCCXdhBBCCCGEEELIEKGke5RJTk6Gr68vzM3NMWPGDJw+fZrvkHi3ceNGTJs2DTY2NnB1dcWCBQtQUFCgdkxbWxsSEhLg5OQEa2tr3HfffZDJZDxFbDzeeustCAQCrFq1ittGbfU/5eXlWLx4MZycnGBhYYHw8HCcPXuW28+yLF5++WW4u7vDwsIC8+bNw+XLl3mMmB9KpRL//Oc/4efnBwsLCwQEBOD1119H95Ii1FaED7W1tVi0aBFsbW1hb2+Pxx9/HHK5vM/nzJ07FwKBQO3fsmXLhini4aXvNcXu3bsRFBQEc3NzhIeH4/fffx+mSI2DPu21Y8cOjc+Rubn5MEbLr5SUFNx5553w8PCAQCDAzz//3O9zjh49iqioKIjFYgQGBmLHjh1DHqex0Le9jh49qvH5EggEkEqlwxMwj3S57tdmqP9+UdI9inz33XdYvXo1XnnlFWRmZmLy5MmIi4tDZWUl36Hx6tixY0hISEB6ejoOHjyIjo4O3HrrrWhubuaOee655/Dbb79h9+7dOHbsGCoqKnDvvffyGDX/zpw5g//85z+YNGmS2nZqqy51dXWYOXMmTE1N8ccffyAvLw/vvvsuHBwcuGM2bdqEf//739i+fTtOnToFKysrxMXFoa2tjcfIh9/bb7+Njz76CFu3bkV+fj7efvttbNq0CR9++CF3DLUV4cOiRYuQm5uLgwcPYs+ePUhJScFTTz3V7/OefPJJXL9+nfu3adOmYYh2eOl7TZGamoqHHnoIjz/+OLKysrBgwQIsWLAAOTk5wxw5PwZyDWZra6v2Obp69eowRsyv5uZmTJ48GcnJyTodX1JSgvj4eNx44404d+4cVq1ahSeeeAL79+8f4kiNg77tpVJQUKD2GXN1dR2iCI2HLtf9PQ3L3y+WjBrTp09nExISuMdKpZL18PBgN27cyGNUxqeyspIFwB47doxlWZatr69nTU1N2d27d3PH5OfnswDYtLQ0vsLkVVNTEzt+/Hj24MGD7Jw5c9hnn32WZVlqq+5eeOEF9oYbbuh1P8MwrEQiYd955x1uW319PSsWi9lvvvlmOEI0GvHx8exjjz2mtu3ee+9lFy1axLIstRXhR15eHguAPXPmDLftjz/+YAUCAVteXt7r87r/TRzN9L2muP/++9n4+Hi1bTNmzGCffvrpIY3TWOjbXl988QVrZ2c3TNEZNwDsTz/91Ocxa9euZUNDQ9W2PfDAA2xcXNwQRmacdGmvI0eOsADYurq6YYnJmPW87tdmOP5+UU/3KNHe3o6MjAzMmzeP2yYUCjFv3jykpaXxGJnxaWhoAAA4OjoCADIyMtDR0aHWdkFBQfDx8RmzbZeQkID4+Hi1NgGorbr79ddfMXXqVPz973+Hq6srIiMj8cknn3D7S0pKIJVK1drKzs4OM2bMGHNtFRsbi0OHDuHSpUsAgPPnz+PEiRO4/fbbAVBbEX6kpaXB3t4eU6dO5bbNmzcPQqEQp06d6vO5X3/9NZydnREWFob169ejpaVlqMMdVgO5pkhLS9P4zoiLixsTv8MDvQaTy+UYN24cvL29cffddyM3N3c4wh2RxvLnazAiIiLg7u6OW265BSdPnuQ7HF70vO7XZjg+XyYGOxPhVXV1NZRKJdzc3NS2u7m54eLFizxFZXwYhsGqVaswc+ZMhIWFAQCkUinMzMxgb2+vdqybm9uYmPvS07fffovMzEycOXNGYx+11f8UFxfjo48+wurVq/GPf/wDZ86cwTPPPAMzMzMsXbqUaw9tv5Njra3WrVuHxsZGBAUFQSQSQalU4l//+hcWLVoEANRWhBdSqVRjqKWJiQkcHR37/NwtXLgQ48aNg4eHBy5cuIAXXngBBQUF+PHHH4c65GEzkGsKqVQ6Zn+HB9JeEydOxOeff45JkyahoaEBmzdvRmxsLHJzc+Hl5TUcYY8ovX2+Ghsb0draCgsLC54iM07u7u7Yvn07pk6dCoVCgU8//RRz587FqVOnEBUVxXd4w0bbdb82w/H3i5JuMqYkJCQgJycHJ06c4DsUo1RWVoZnn30WBw8eHFMFXQaCYRhMnToVb775JgAgMjISOTk52L59O5YuXcpzdMbl+++/x9dff41du3YhNDSUm4/n4eFBbUUMbt26dXj77bf7PCY/P3/A5+8+5zs8PBzu7u64+eabUVRUhICAgAGfl4wtMTExiImJ4R7HxsYiODgY//nPf/D666/zGBkZDSZOnIiJEydyj2NjY1FUVIQtW7bgv//9L4+RDS9juu6npHuUcHZ2hkgk0qgiLZPJIJFIeIrKuCQmJnKFcrrfRZZIJGhvb0d9fb1aD+5YbLuMjAxUVlaq3QVVKpVISUnB1q1bsX//fmqrv7i7uyMkJERtW3BwMH744QcA4NpDJpPB3d2dO0YmkyEiImLY4jQGa9aswbp16/Dggw8C6EpUrl69io0bN2Lp0qXUVsSgnn/+eTzyyCN9HuPv7w+JRKJR5KqzsxO1tbV6/T2bMWMGAKCwsHDUJN0DuaaQSCRj9hrEENdgpqamiIyMRGFh4VCEOOL19vmytbWlXm4dTZ8+3SiSz+HS23W/NsPx94vmdI8SZmZmmDJlCg4dOsRtYxgGhw4dUruTOhaxLIvExET89NNPOHz4MPz8/NT2T5kyBaampmptV1BQgNLS0jHXdjfffDOys7Nx7tw57t/UqVOxaNEi7v+prbrMnDlTYwmKS5cuYdy4cQAAPz8/SCQStbZqbGzEqVOnxlxbtbS0QChU/7oRiURgGAYAtRUxLBcXFwQFBfX5z8zMDDExMaivr0dGRgb33MOHD4NhGC6R1sW5c+cAQO2G0Ug3kGuKmJgYteMB4ODBg2Pid9gQ12BKpRLZ2dmj6nNkSGP582Uo586dGxOfr/6u+7UZls+XwUqyEd59++23rFgsZnfs2MHm5eWxTz31FGtvb89KpVK+Q+PV8uXLWTs7O/bo0aPs9evXuX8tLS3cMcuWLWN9fHzYw4cPs2fPnmVjYmLYmJgYHqM2Hj0r9VJbdTl9+jRrYmLC/utf/2IvX77Mfv3116ylpSX71Vdfcce89dZbrL29PfvLL7+wFy5cYO+++27Wz8+PbW1t5THy4bd06VLW09OT3bNnD1tSUsL++OOPrLOzM7t27VruGGorwofbbruNjYyMZE+dOsWeOHGCHT9+PPvQQw9x+69du8ZOnDiRPXXqFMuyLFtYWMi+9tpr7NmzZ9mSkhL2l19+Yf39/dnZs2fz9RaGTH/XFA8//DC7bt067viTJ0+yJiYm7ObNm9n8/Hz2lVdeYU1NTdns7Gy+3sKw0re9NmzYwO7fv58tKipiMzIy2AcffJA1Nzdnc3Nz+XoLw6qpqYnNyspis7KyWADse++9x2ZlZbFXr15lWZZl161bxz788MPc8cXFxaylpSW7Zs0aNj8/n01OTmZFIhG7b98+vt7CsNK3vbZs2cL+/PPP7OXLl9ns7Gz22WefZYVCIfvnn3/y9RaGjS7X/Xz8/aKke5T58MMPWR8fH9bMzIydPn06m56ezndIvAOg9d8XX3zBHdPa2squWLGCdXBwYC0tLdl77rmHvX79On9BG5GeSTe11f/89ttvbFhYGCsWi9mgoCD2448/VtvPMAz7z3/+k3Vzc2PFYjF78803swUFBTxFy5/Gxkb22WefZX18fFhzc3PW39+fffHFF1mFQsEdQ21F+FBTU8M+9NBDrLW1NWtra8s++uijbFNTE7e/pKSEBcAeOXKEZVmWLS0tZWfPns06OjqyYrGYDQwMZNesWcM2NDTw9A6GVl/XFHPmzGGXLl2qdvz333/PTpgwgTUzM2NDQ0PZvXv3DnPE/NKnvVatWsUd6+bmxt5xxx1sZmYmD1HzQ7WkVc9/qjZaunQpO2fOHI3nREREsGZmZqy/v7/addxop297vf3222xAQABrbm7OOjo6snPnzmUPHz7MT/DDTJfrfj7+fgn+Co4QQgghhBBCCCEGRnO6CSGEEEIIIYSQIUJJNyGEEEIIIYQQMkQo6SaEEEIIIYQQQoYIJd2EEEIIIYQQQsgQoaSbEEIIIYQQQggZIpR0E0IIIYQQQgghQ4SSbkIIIYQQQgghZIhQ0k0IIYQQQgghhAwRSroJIVodPXoUAoEA9fX1fIeik9mzZ2PXrl2DOkd0dDR++OEHA0VECCGEGIZAIMDPP//MdxgAgIKCAkgkEjQ1NQ3qPPSdS8YSSroJ4UlaWhpEIhHi4+M19r366quIiIjQ2G5MX7rG5Ndff4VMJsODDz7IbVu9ejUcHR3h7e2Nr7/+Wu343bt3484779Q4z0svvYR169aBYZghj5kQQggBgKqqKixfvhw+Pj4Qi8WQSCSIi4vDyZMn+Q5Nq/Xr12PlypWwsbEZ1HnoO5eMJZR0E8KTzz77DCtXrkRKSgoqKir4DmdE+/e//41HH30UQmHXn7TffvsNu3btwoEDB7Bp0yY88cQTqK6uBgA0NDTgxRdfRHJyssZ5br/9djQ1NeGPP/4Y1vgJIYSMXffddx+ysrLw5Zdf4tKlS/j1118xd+5c1NTU8B2ahtLSUuzZswePPPLIoM9F37lkLKGkmxAeyOVyfPfdd1i+fDni4+OxY8cObt+OHTuwYcMGnD9/HgKB4P/bu/eYKus/DuBvQIRzOJIgBKQESGBc5AwGXjC5iIjFhihOxrqAUR7+IGZSMBoIlOLSGaY2m+MEGFNGXkLukJoRRI2QmyAgo5EOpLhsHq5y+Pz+cD7zCU6Jiu0Xn9fG2PO9Pd/n8MeHz/N9nu+BlpYWsrKyYG1tDQDYunUrtLS0hGMAyM/Ph5ubG/T19bF8+XKkpqZicnJSqNfS0kJGRga2bt0KqVQKOzs7XLx4UTSn4uJi2NvbQyKRwNfXF7/99puovr+/H2FhYVi6dCmkUilWrlyJM2fOiNr4+PggJiYGcXFxMDY2hrm5OVJSUkRthoaGoFAoYGZmBn19fTg7O6OwsFCo//HHH7F+/XpIJBJYWloiJiYGw8PDGj/LP/74A5cvXxatXLe2tsLHxwfu7u4ICwuDoaEhurq6AABxcXHCisJf6ejo4LXXXkNubq7G8zHGGGNPy9DQECorK/Hpp5/C19cXVlZWWLVqFRISEhAUFKSxX1NTEzZs2ACJRIIlS5Zg165dUKlUQn1ERASCg4ORmpoKU1NTGBoaIioqChMTE0KbqakpHDhwADY2NpBIJJDL5Th79uzfzjcvLw9yuRxLly4VyrKysrB48WIUFhZixYoVkEql2L59O0ZGRpCdnQ1ra2sYGRkhJiYGarVa6Mcxl80rxBh75pRKJbm7uxMRUUFBAdna2tLU1BQREY2MjFBsbCw5OTlRT08P9fT00MjICPX19REAyszMpJ6eHurr6yMioh9++IEMDQ0pKyuLOjs7qby8nKytrSklJUU4HwBatmwZnT59mjo6OigmJoZkMhn19/cTEVF3dzfp6enRnj176MaNG5STk0NmZmYEgAYHB4mI6NatW3To0CG6du0adXZ20tGjR0lHR4d+/vln4Tze3t5kaGhIKSkp1N7eTtnZ2aSlpUXl5eVERKRWq2nNmjXk5ORE5eXl1NnZSQUFBVRcXExERDdv3iQDAwNKT0+n9vZ2qqqqIldXV4qIiND4WZ4/f54MDAxIrVYLZaWlpWRra0sDAwNUW1tLixYtooGBAaqsrCR3d3eanJzUON6JEyfIysrqUf+UjDHG2GO7d+8eyWQy2r17N42NjWlsB4AuXLhAREQqlYosLCxo27Zt1NTURJcuXSIbGxsKDw8X2oeHh5NMJqPQ0FBqbm6mwsJCMjU1pY8++khos2/fPnr55ZeptLSUOjs7KTMzk/T09Oj777/XOI+goCCKiooSlWVmZpKuri75+/tTXV0dXb16lZYsWUKbNm2iHTt20PXr16mgoIAWLlxIubm5or4cc9l8wUk3Y/8CT09POnLkCBHdD7gmJiZ05coVoT45OZnkcvm0fg8H3Qf8/PwoLS1NVPb111+ThYWFqF9iYqJwrFKpCACVlJQQEVFCQgI5OjqKxoiPjxcl3TMJDAyk2NhY4djb25teeeUVURsPDw+Kj48nIqKysjLS1tamtra2GceLjIykXbt2icoqKytJW1ubRkdHZ+yTnp5Oy5cvn1aenJxMtra25OzsTOfPn6fx8XFydnam2tpaOnbsGNnb25Onpyc1NzeL+uXn55O2trYoiWeMMcbmytmzZ8nIyIj09fXJ09OTEhISqKGhQdTm4fh/8uRJMjIyIpVKJdQXFRWRtrY29fb2EtH9pNvY2JiGh4eFNidOnCCZTEZqtZrGxsZIKpVSdXW16DyRkZEUFhamca5yuZw+/vhjUVlmZiYBoJs3bwplCoWCpFIp3b17VygLCAgghUIh6ssxl80XC/6tFXbG5qu2tjb88ssvuHDhAgBgwYIFCA0NhVKphI+Pz6zHa2hoQFVVFfbv3y+UqdVqjI2NYWRkBFKpFADg4uIi1BsYGMDQ0BB9fX0A7j+OvXr1atG4a9euFR2r1WqkpaUhLy8Pt2/fxsTEBMbHx4XxH3j4PABgYWEhnKe+vh7Lli2Dvb29xmtpbGwUbXxGRJiamkJXVxccHBym9RkdHYW+vv608pSUFNGj7ampqdi4cSN0dXWxb98+NDU1obCwEG+99RZ+/fVXoZ1EIsHU1BTGx8chkUhmnCdjjDH2tISEhCAwMBCVlZWoqalBSUkJDh48iIyMjBnfnW5tbYVcLoeBgYFQtm7dOkxNTaGtrQ1mZmYAALlcLorRa9euhUqlwu+//w6VSoWRkRH4+/uLxp6YmICrq6vGuWqKuVKpFLa2tsKxmZkZrK2tIZPJRGUP/h94gGMumy846WbsGVMqlZicnMQLL7wglBER9PT0cPz4cTz33HOzGk+lUiE1NRXbtm2bVvdwYNTV1RXVaWlpzWrH0EOHDuHzzz/HkSNHsHLlShgYGGD37t2i98P+6Tz/FFBVKhUUCgViYmKm1c30DjYAmJiYYHBw8G/HvXHjBnJycnDt2jV89dVX8PLygqmpKXbs2IG3334bd+/eFXZhHRgYgIGBAQd/xhhjz4y+vj78/f3h7++PpKQkvPPOO0hOTn4qG5bN5MH730VFRaL3swFAT09PYz9NMXem2P8o/3dwzGXzBSfdjD1Dk5OTOHXqFA4fPoxNmzaJ6oKDg3HmzBlERUVh4cKFos1GHtDV1Z1W7ubmhra2Nrz00kuPPS8HB4dpG6vV1NSIjquqqrBlyxa88cYbAO5vwNLe3g5HR8dHPo+Liwtu3bqF9vb2GVe73dzc0NLSMqtrcXV1RW9vLwYHB2FkZDStnoigUCjw2WefQSaTQa1W4969ewAg/H74M21ubv7bu/yMMcbYXHN0dNT4FaEODg7IysrC8PCwsNpdVVUFbW1trFixQmjX0NCA0dFRIaGtqamBTCaDpaUljI2Noaenh+7ubnh7ez/yvFxdXdHS0vL4F/YXHHPZfMG7lzP2DBUWFmJwcBCRkZFwdnYW/YSEhECpVAIArK2t0dXVhfr6evz5558YHx8Xyi9duiQkmQCwd+9enDp1Cqmpqbh+/TpaW1uRm5uLxMTER55XVFQUOjo68OGHH6KtrQ2nT58W7agOAHZ2dqioqEB1dTVaW1uhUChw586dWV2/t7c3vLy8EBISgoqKCnR1daGkpASlpaUAgPj4eFRXVyM6Ohr19fXo6OhAfn4+oqOjNY7p6uoKExMTjd9nmpGRAVNTU2F383Xr1uHy5cuoqalBeno6HB0dsXjxYqF9ZWXltBsijDHG2Fzo7+/Hhg0bkJOTg8bGRnR1deGbb77BwYMHsWXLlhn7vP7669DX10d4eDiam5tx5coVvPfee3jzzTeFR8uB+4+KR0ZGoqWlBcXFxUhOTkZ0dDS0tbWxaNEifPDBB3j//feRnZ2Nzs5O1NXV4dixY8jOztY434CAAPz0008zLgw8Do65bL7gpJuxZ0ipVGLjxo0zPkIeEhKC2tpaNDY2IiQkBJs3b4avry9MTU2Fr+Y6fPgwKioqYGlpKdwZDggIQGFhIcrLy+Hh4YE1a9YgPT0dVlZWjzyvF198EefOncO3334LuVyOL7/8EmlpaaI2iYmJcHNzQ0BAAHx8fGBubo7g4OBZfwbnzp2Dh4cHwsLC4OjoiLi4OCF4u7i44OrVq2hvb8f69evh6uqKvXv3ih7F/ysdHR3s3LlT9B74A3fu3MH+/ftx9OhRoWzVqlWIjY1FYGAg8vLykJmZKdTdvn0b1dXV2Llz56yvizHGGJstmUyG1atXIz09HV5eXnB2dkZSUhLeffddHD9+fMY+UqkUZWVlGBgYgIeHB7Zv3w4/P79p7f38/GBnZwcvLy+EhoYiKChItNfJJ598gqSkJBw4cAAODg7YvHkzioqKYGNjo3G+r776KhYsWIDvvvvuia+dYy6bT7SIiP7tSTDG2JPo7e2Fk5MT6urqZnWz4a/i4+MxODiIkydPPsXZMcYYY89WREQEhoaGND6i/iS++OILXLx4EWVlZU80DsdcNp/wO92Msf975ubmUCqV6O7ufqKk+/nnn8eePXue4swYY4yx/xaFQoGhoSHRJqSPg2Mum094pZsxxhhjjLH/kLlc6WaMzR4n3YwxxhhjjDHG2BzhjdQYY4wxxhhjjLE5wkk3Y4wxxhhjjDE2RzjpZowxxhhjjDHG5ggn3YwxxhhjjDHG2BzhpJsxxhhjjDHGGJsjnHQzxhhjjDHGGGNzhJNuxhhjjDHGGGNsjnDSzRhjjDHGGGOMzRFOuhljjDHGGGOMsTnyP6JNZtONdIjTAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "DETAILED PERFORMANCE COMPARISON:\n", "Method Final Error RMSE Correlation Evaluations \n", "-----------------------------------------------------------------\n", "Grid Search 51.2384 7.16 0.9702 100 \n", "Gradient Desc. 51.2231 7.16 0.9702 17 \n" ] } ], "source": [ "# Create comparison plots showing the same analysis for both methods\n", "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(10, 8))\n", "\n", "# Calculate the empirical error function across the parameter space\n", "m_empirical = np.linspace(-0.5, 2.0, 200) # Higher resolution for smooth curve\n", "empirical_errors = []\n", "\n", "for m in m_empirical:\n", " predictions = linear_model(attendance, m, 0) # b = 0\n", " error = error_function(score, predictions)\n", " empirical_errors.append(error)\n", "\n", "# Plot 1: Grid Search - Data and fitted model\n", "ax1.scatter(attendance, score, color='black', alpha=0.7, label='Data points')\n", "ax1.plot(attendance, grid_predictions, color='blue', linewidth=2, label=f'Grid Search (m={grid_m:.3f})')\n", "ax1.set_title('Grid Search: Data and Fitted Model')\n", "ax1.set_xlabel('Attendance (%)')\n", "ax1.set_ylabel('Score (%)')\n", "ax1.legend()\n", "ax1.grid(True, alpha=0.3)\n", "\n", "# Plot 2: Grid Search - Slope vs Error with empirical function\n", "ax2.plot(m_empirical, empirical_errors, color='gray', linewidth=2, alpha=0.7, label='True error function')\n", "ax2.scatter(grid_m_values, grid_errors, color='blue', s=20, alpha=0.8, label='Grid search points')\n", "ax2.axvline(x=grid_m, color='black', linestyle='--', linewidth=2, label=f'Best m = {grid_m:.3f}')\n", "ax2.set_title('Grid Search: Slope vs Error')\n", "ax2.set_xlabel('Slope (m)')\n", "ax2.set_ylabel('Mean Squared Error')\n", "ax2.legend(loc='upper left')\n", "ax2.grid(True, alpha=0.3)\n", "\n", "# Plot 3: Gradient Descent - Data and fitted model\n", "ax3.scatter(attendance, score, color='black', alpha=0.7, label='Data points')\n", "ax3.plot(attendance, gd_predictions, color='red', linewidth=2, label=f'Gradient Descent (m={gd_m:.3f})')\n", "ax3.set_title('Gradient Descent: Data and Fitted Model')\n", "ax3.set_xlabel('Attendance (%)')\n", "ax3.set_ylabel('Score (%)')\n", "ax3.legend()\n", "ax3.grid(True, alpha=0.3)\n", "\n", "# Plot 4: Gradient Descent - Slope vs Error with empirical function\n", "ax4.plot(m_empirical, empirical_errors, color='gray', linewidth=2, alpha=0.7, label='True error function')\n", "ax4.scatter(gd_m_values, gd_errors, color='red', s=30, alpha=0.8, label='Gradient descent points')\n", "ax4.axvline(x=gd_m, color='black', linestyle='--', linewidth=2, label=f'Best m = {gd_m:.3f}')\n", "ax4.set_title('Gradient Descent: Slope vs Error')\n", "ax4.set_xlabel('Slope (m)')\n", "ax4.set_ylabel('Mean Squared Error')\n", "ax4.legend(loc='upper left')\n", "ax4.grid(True, alpha=0.3)\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# Calculate performance statistics for both methods\n", "grid_correlation = np.corrcoef(score, grid_predictions)[0, 1]\n", "gd_correlation = np.corrcoef(score, gd_predictions)[0, 1]\n", "\n", "print(f\"\\nDETAILED PERFORMANCE COMPARISON:\")\n", "print(f\"{'Method':<15} {'Final Error':<12} {'RMSE':<8} {'Correlation':<12} {'Evaluations':<12}\")\n", "print(\"-\" * 65)\n", "print(f\"{'Grid Search':<15} {min(grid_errors):<12.4f} {np.sqrt(min(grid_errors)):<8.2f} {grid_correlation:<12.4f} {len(grid_errors):<12}\")\n", "print(f\"{'Gradient Desc.':<15} {min(gd_errors):<12.4f} {np.sqrt(min(gd_errors)):<8.2f} {gd_correlation:<12.4f} {len(gd_errors):<12}\")" ] }, { "cell_type": "markdown", "id": "d58d103b", "metadata": {}, "source": [ "## 7. Discussion\n", "\n", "### Is this a good idea for grading students?\n", "\n", "**Short answer: No!** \n", "\n", "While there's clearly a strong correlation between attendance and performance, using attendance to predict grades raises several important concerns:\n", "\n", "1. **Causation vs Correlation**: The correlation doesn't necessarily mean attendance causes better grades. Students who attend more might also study more, be more engaged, or have fewer external pressures.\n", "2. **Fairness**: Some students might miss class due to legitimate reasons (illness, family emergencies, work obligations) but still master the material through self-study.\n", "3. **Different Learning Styles**: Some students learn effectively through reading and independent study and might not need to attend every class.\n", "4. **Circular Logic**: If attendance becomes part of the grade, it creates a feedback loop that doesn't reflect actual learning.\n", "\n", "### Further Improvements:\n", "\n", "1. **Adaptive Learning Rate**: Implement learning rate scheduling or Adam optimizer\n", "2. **Multiple Parameters**: Optimize both m and b simultaneously \n", "3. **Cross-validation**: Split data into training/validation sets to test generalization\n", "4. **Regularization**: Add L1/L2 penalties to prevent overfitting\n", "5. **Non-linear Models**: Try polynomial or neural network approaches\n", "6. **Batch Processing**: For larger datasets, implement mini-batch gradient descent\n", "\n", "The gradient descent approach is much more practical and forms the foundation of modern machine learning optimization algorithms." ] } ], "metadata": { "kernelspec": { "display_name": ".venv (3.12.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.3" } }, "nbformat": 4, "nbformat_minor": 5 }