{ "cells": [ { "cell_type": "markdown", "id": "eace5ee0-82ec-459a-80e8-faa2c7030f73", "metadata": { "tags": [] }, "source": [ "# Upgrading CMA-ME to CMA-MAE on the Sphere Benchmark\n", "\n", "_This tutorial is part of the series of pyribs tutorials! See [here](https://docs.pyribs.org/en/stable/tutorials.html) for the list of all tutorials and the order in which they should be read._\n", "\n", "In the [previous tutorial](https://docs.pyribs.org/en/stable/tutorials/lunar_lander.html), we showed how to implement the CMA-ME algorithm in pyribs to tackle the lunar lander problem. CMA-ME enabled us to search for a diverse collection of high-performing lunar lander agents, including ones which landed like a space shuttle:" ] }, { "cell_type": "code", "execution_count": 1, "id": "918913af-8097-4fe1-89c3-d78f43f07679", "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from IPython.display import display, HTML\n", "display(HTML(\"\"\"\"\"\"))" ] }, { "cell_type": "markdown", "id": "b31307ca-c662-44f6-9bea-e1a3c42f0029", "metadata": {}, "source": [ "Recent work introduced [Covariance Matrix Adaptation MAP-Annealing (CMA-MAE)](https://arxiv.org/abs/2205.10752), an algorithm which builds on and improves CMA-ME. CMA-MAE not only has strong theoretical guarantees, it also empirically outperforms CMA-ME in a variety of domains.\n", "\n", "One such domain is the sphere linear projection benchmark introduced in [Fontaine 2020](https://arxiv.org/abs/1912.02400). The below heatmaps compare CMA-MAE and CMA-ME on the 100-dimensional version of this benchmark. We can clearly see that CMA-MAE does a better job of populating the archive with high-performing solutions than CMA-ME." ] }, { "cell_type": "code", "execution_count": 2, "id": "f87b10c6-a220-4908-ae51-1383196eb706", "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(HTML(\"\"\"\"\"\"))" ] }, { "cell_type": "markdown", "id": "6eaf9edd-a6f6-4b78-80a3-fe3b9992cd4a", "metadata": {}, "source": [ "In this tutorial, we'll show you how to implement this more advanced algorithm in pyribs. To understand how CMA-MAE operates, we'll compare it to CMA-ME on the benchmark mentioned above, and we'll run multiple versions of it to see how different hyperparameters affect its performance." ] }, { "cell_type": "markdown", "id": "4e35386c", "metadata": { "id": "4e35386c", "tags": [] }, "source": [ "## Setup\n", "\n", "First, let's install pyribs." ] }, { "cell_type": "code", "execution_count": null, "id": "9562ca7d-0e1a-4916-86b0-67b8254a79c7", "metadata": {}, "outputs": [], "source": [ "%pip install ribs[visualize] tqdm" ] }, { "cell_type": "code", "execution_count": 3, "id": "fa90af0b-d7bb-477e-84a6-f384327e9d34", "metadata": {}, "outputs": [], "source": [ "import sys\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm, trange" ] }, { "cell_type": "markdown", "id": "e1900b33", "metadata": { "id": "e1900b33" }, "source": [ "## The Sphere Linear Projection Benchmark\n", "\n", "Next, let's define the sphere function that we'll be using as we introduce CMA-MAE. This benchmark, introduced in [Fontaine 2020](https://arxiv.org/abs/1912.02400), challenges a QD algorithm's ability to handle distortions in the measure space.\n", "\n", "The objective function is the negative [sphere function](https://en.wikipedia.org/wiki/Test_functions_for_optimization):\n", "\n", "$$f(\\mathbb{\\theta}) = -\\sum_{i=1}^n \\theta_i^2$$\n", "\n", "where $n$ is the dimensionality chosen for the sphere function (in this tutorial, we use 100 dimensions). In this benchmark, the function is further modified such that the center is shifted to $[0.4 * 5.12, 0.4 * 5.12, ...]$, so that the optimal solution is not the zero vector. Furthermore, the outputs of the function are normalized to the range $[0, 100]$.\n", "\n", "Meanwhile, the measure function is a linear projection, i.e., a weighted sum of the components of the input vector. Given a clip function defined as follows:\n", "\n", "$$clip(\\theta_i) = \\begin{cases} \\theta_i & \\text{if} -5.12 \\le \\theta_i \\le 5.12 \\\\ 5.12/\\theta_i & \\text{otherwise} \\end{cases}$$\n", "\n", "The measure function outputs two values:\n", "\n", "$$m(\\theta) = \\left( \\sum_{i=1}^{\\lfloor\\frac{n}{2}\\rfloor}clip(\\theta_i), \\sum_{i=\\lfloor\\frac{n}{2}\\rfloor+1}^n clip(\\theta_i) \\right)$$\n", "\n", "In short, this measure function creates distortion in the measure space that prevents a QD algorithm from easily reaching the bounds of the archive. To better understand this benchmark and its properties, refer to Appendix B of [Fontaine 2022](https://arxiv.org/abs/2205.10752)." ] }, { "cell_type": "code", "execution_count": 4, "id": "8cb2801c", "metadata": { "id": "8cb2801c" }, "outputs": [], "source": [ "def sphere(solution_batch):\n", " \"\"\"Sphere function evaluation and measures for a batch of solutions.\n", "\n", " Args:\n", " solution_batch (np.ndarray): (batch_size, dim) batch of solutions.\n", " Returns:\n", " objective_batch (np.ndarray): (batch_size,) batch of objectives.\n", " measures_batch (np.ndarray): (batch_size, 2) batch of measures.\n", " \"\"\"\n", " dim = solution_batch.shape[1]\n", "\n", " # Shift the Sphere function so that the optimal value is at x_i = 2.048.\n", " sphere_shift = 5.12 * 0.4\n", "\n", " # Normalize the objective to the range [0, 100] where 100 is optimal.\n", " best_obj = 0.0\n", " worst_obj = (-5.12 - sphere_shift)**2 * dim\n", " raw_obj = np.sum(np.square(solution_batch - sphere_shift), axis=1)\n", " objective_batch = (raw_obj - worst_obj) / (best_obj - worst_obj) * 100\n", "\n", " # Calculate measures.\n", " clipped = solution_batch.copy()\n", " clip_mask = (clipped < -5.12) | (clipped > 5.12)\n", " clipped[clip_mask] = 5.12 / clipped[clip_mask]\n", " measures_batch = np.concatenate(\n", " (\n", " np.sum(clipped[:, :dim // 2], axis=1, keepdims=True),\n", " np.sum(clipped[:, dim // 2:], axis=1, keepdims=True),\n", " ),\n", " axis=1,\n", " )\n", "\n", " return objective_batch, measures_batch" ] }, { "cell_type": "markdown", "id": "-8bqAHnuJxRa", "metadata": { "id": "-8bqAHnuJxRa" }, "source": [ "## Introducing CMA-MAE\n", "\n", "When inserting solutions into an archive, CMA-ME quickly moves away from high-objective solutions. This happens because after discovering a solution with a high objective value, subsequent solutions found in the same cell (and more generally, in the same region) have a low improvement value.\n", "\n", "The intuition of CMA-MAE is that there could be value in discovering more solutions in a high-objective region. For instance, there could be even better solutions in the same region, but CMA-ME will move away from the region regardless if it does not discover a better solution in the next few iterations.\n", "\n", "CMA-MAE overcomes this problem by using a threshold value (not the objective value) to determine whether a new solution is accepted by the archive. Formally, a new solution $\\theta'$ in cell $e$ is accepted to the archive if and only if $f(\\theta') > t_e$, where $t_e$ is the threshold of cell $e$, and $f(\\theta')$ is the objective value of $\\theta'$. The \"improvement value\" of a solution is calculated as $\\Delta = f(\\theta') - t_e$. When a cell does not have a solution, its threshold $t_e$ is initialized to a predefined minimum threshold $min_f$.\n", "\n", "Furthermore, after $\\theta'$ is accepted into cell $e$, $t_e$ is updated according to the equation $t_e \\gets (1 - \\alpha) t_e + \\alpha f(\\theta')$ where the constant $\\alpha$ denotes the _archive learning rate_ and controls how quickly the threshold is adapted.\n", "\n", "When $\\alpha = 1$, **CMA-MAE behaves like CMA-ME**, with the improvement values $\\Delta$ quickly dropping to zero. Meanwhile, if $\\alpha = 0$, **CMA-MAE behaves like CMA-ES**, as the improvement values always correspond to the objective values since the threshold never changes, resulting in CMA-MAE only optimizing the objective.\n", "\n", "To understand how using a threshold can be useful, consider this example from [Fontaine 2022](https://arxiv.org/abs/2205.10752):\n", "\n", "> Consider discovering solutions in the same cell with objective value 100 in 5 consecutive iterations. The improvement values computed by CMA-ME would be 100, 0, 0, 0, 0, thus CMA-ME would move rapidly away from this cell. The improvement values computed by CMA-MAE with α = 0.5 would diminish smoothly as follows: 100, 50, 25, 12.5, 6.25, enabling further exploitation of the high-performing region." ] }, { "cell_type": "markdown", "id": "ade59e92", "metadata": { "id": "ade59e92" }, "source": [ "## CMA-MAE with pyribs\n", "\n", "Setting up CMA-MAE in pyribs is similar to CMA-ME. However, there are a few key differences, which we will review below." ] }, { "cell_type": "markdown", "id": "bb793875-cd60-4862-bc80-ccfd8531089a", "metadata": {}, "source": [ "### GridArchive\n", "\n", "First, we will create the [`GridArchive`](https://docs.pyribs.org/en/stable/api/ribs.archives.GridArchive.html). The archive is 100x100 and stores 100-dimensional solutions. The ranges of the archive are determined by the maximum outputs of the measure function. Since the $clip(\\theta_i)$ function has a maximum output of 5.12, and each component of the output is the sum of $\\frac{n}{2}$ clipped components, the bounds of the measure space are $\\pm 5.12 * \\frac{n}{2}$.\n", "\n", "Next, the key difference from CMA-ME is that this archive takes in the `learning_rate` parameter ($\\alpha$) which controls how quickly the threshold in each cell is updated. We set this to 0.01 from the CMA-MAE paper. The second difference is that this archive takes in a `threshold_min` parameter ($min_f$) which is the starting threshold for each cell. This threshold is typically the minimum objective in the problem, hence we choose 0.0.\n", "\n", "**Note: threshold_min**\n", "> If your solutions $\\theta$ consistently have objective values $f(\\theta) = min_f$, you may need to set $min_f$ to be slightly smaller so that these solutions are accepted into the archive. This is because solutions are accepted if and only if $f(\\theta) > t_e$. Thus, if $f(\\theta) = t_e$, then $\\theta$ will not be accepted." ] }, { "cell_type": "code", "execution_count": 5, "id": "aa4e5b4d", "metadata": { "id": "aa4e5b4d" }, "outputs": [], "source": [ "from ribs.archives import GridArchive\n", "\n", "max_bound = 100 / 2 * 5.12\n", "\n", "archive = GridArchive(solution_dim=100,\n", " dims=(100, 100),\n", " ranges=[(-max_bound, max_bound), (-max_bound, max_bound)],\n", " learning_rate=0.01,\n", " threshold_min=0.0)" ] }, { "cell_type": "markdown", "id": "79a7ac58", "metadata": { "id": "79a7ac58" }, "source": [ "In CMA-MAE, since solutions are added to the archive based on the **threshold** of each cell rather than on the **objective** of the elite in each cell, it is possible for CMA-MAE to make \"backwards\" progress. _Specifically, a solution's objective can exceed the cell's threshold value but not exceed the objective of the cell's current elite,_ which results in overwriting the **better** solution.\n", "\n", "For this reason, CMA-MAE sometimes benefits from a separate **result archive** that keeps track of the best solutions encountered in each cell. The `GridArchive` does this by default since it has a default `learning_rate=1.0` and `threshold_min=-inf`. Hence, we create an archive below which is identical to the one above except for the `learning_rate` and `threshold_min`." ] }, { "cell_type": "code", "execution_count": 6, "id": "b1e4948b", "metadata": { "id": "b1e4948b" }, "outputs": [], "source": [ "result_archive = GridArchive(solution_dim=100,\n", " dims=(100, 100),\n", " ranges=[(-max_bound, max_bound), (-max_bound, max_bound)])" ] }, { "cell_type": "markdown", "id": "1e4d7086-15c2-4c1c-a313-a2b36929ee8e", "metadata": {}, "source": [ "### EvolutionStrategyEmitter\n", "\n", "Next, we set up 15 instances of the [`EvolutionStrategyEmitter`](https://docs.pyribs.org/en/stable/api/ribs.emitters.EvolutionStrategyEmitter.html). The key difference from CMA-ME's `EvolutionStrategyEmitter` is that these emitters use _improvement ranking_ rather than _two-stage improvement ranking_. Two-stage improvement ranking (see the [Lunar Lander tutorial](https://docs.pyribs.org/en/stable/tutorials/lunar_lander.html)) considers the \"status\" and \"value\" of each solution, such that solutions which introduced new cells in the archive come first, followed by solutions which improved existing cells and solutions which were not added. In contrast, improvement ranking considers only the improvement values $\\Delta = f(\\theta') - t_e$, i.e., the difference between the objective values of incumbent solutions and the threshold of their corresponding cells in the archive.\n", "\n", "There are further differences which set these emitters apart from the ones which are used in CMA-ME. First, the CMA-MAE emitters below use the \"mu\" `selection_rule`, which affects which solutions the emitter uses as parents for updating CMA-ES. The default \"filter\" selection (used in CMA-ME) uses all solutions which added a new cell or improved the archive, while \"mu\" selects the top half of all the generated solutions as parents. Second, the CMA-MAE emitters use a \"basic\" restart rule, which restarts the emitter according to the convergence rules of CMA-ES. The default \"no_improvement\" restart rule restarts the emitter when none of its generated solutions are inserted into the archive." ] }, { "cell_type": "code", "execution_count": 7, "id": "beb8f299", "metadata": { "id": "beb8f299" }, "outputs": [], "source": [ "from ribs.emitters import EvolutionStrategyEmitter\n", "\n", "emitters = [\n", " EvolutionStrategyEmitter(\n", " archive,\n", " x0=np.zeros(100),\n", " sigma0=0.5,\n", " ranker=\"imp\",\n", " selection_rule=\"mu\",\n", " restart_rule=\"basic\",\n", " batch_size=36,\n", " ) for _ in range(15)\n", "]" ] }, { "cell_type": "markdown", "id": "1a1b940d", "metadata": { "id": "1a1b940d" }, "source": [ "### Scheduler\n", "\n", "Finally, the [`Scheduler`](https://docs.pyribs.org/en/stable/api/ribs.schedulers.Scheduler.html) controls how the emitters interact with the archive and result archive. On every iteration, the scheduler calls the emitters to generate solutions. After the user evaluates these generated solutions, the scheduler inserts the solutions into both the archive and result archive. It then passes feedback from the archive (but not the result archive) to the emitters. In this manner, the emitters only interact with the archive, but the result archive stores all the best solutions found by CMA-MAE." ] }, { "cell_type": "code", "execution_count": 8, "id": "e5c4f108", "metadata": { "id": "e5c4f108" }, "outputs": [], "source": [ "from ribs.schedulers import Scheduler\n", "\n", "scheduler = Scheduler(archive, emitters, result_archive=result_archive)" ] }, { "cell_type": "markdown", "id": "279ad11f-103b-4517-800a-121be37cf446", "metadata": {}, "source": [ "### Summary: Differences Between CMA-ME and CMA-MAE\n", "\n", "To summarize, the differences between CMA-ME and CMA-MAE in pyribs are as follows:\n", "\n", "* The archive (we used `GridArchive` but you can also use another archive) takes in a `learning_rate` and `threshold_min` parameter. The `learning_rate` is between 0 and 1 (inclusive), and the `threshold_min` typically corresponds to the minimum objective of the problem.\n", "* A second result archive is created to store best solutions, as introducing thresholds means that the first archive is not guaranteed to store the best solutions. This archive is identical to the first, but it does not have `learning_rate` or `threshold_min` parameters.\n", "* `EvolutionStrategyEmitter` uses improvement ranking (`ranker=\"imp\"`) rather than two-stage improvement ranking (`ranker=\"2imp\"`).\n", "* `EvolutionStrategyEmitter` uses `selection_rule=\"mu\"` and `restart_rule=\"basic\"` instead of the default `selection_rule=\"filter\"` and `restart_rule=\"no_improvement\"`.\n", "* `Scheduler` also takes in the `result_archive`.\n", "\n", "Note that some of these differences are flexible; in particular, you can try playing around with the `selection_rule` and `restart_rule` to see how these parameters affect the behavior of CMA-MAE." ] }, { "cell_type": "markdown", "id": "1d6a2c2c-5e40-4e67-980f-8b96c0dc2f96", "metadata": {}, "source": [ "## Aside: Activating CMA-ME Behavior\n", "\n", "When creating the latest version of pyribs, we wondered whether we should explicitly support CMA-ME since CMA-MAE is theoretically equivalent to CMA-ME at $\\alpha=1.0$. Ultimately, we decided to continue supporting CMA-ME behavior for two reasons.\n", "\n", "First, let us consider how the improvement is computed in each algorithm. In CMA-ME, improvement is computed in two stages: (1) the solution's status (i.e., whether it was new, improved an existing cell in the archive, or was not inserted at all), and (2) a value which depends on the status. In contrast, CMA-MAE computes a single improvement value $\\Delta$ which is calculated in the same manner regardless of the solution's status. While CMA-MAE is theoretically equivalent to CMA-ME when $\\alpha=1$, this difference in improvement value computation may lead to slight differences between CMA-MAE and CMA-ME.\n", "\n", "Second, CMA-MAE always requires defining `threshold_min`, and in some problems, this value is not known beforehand. While it is possible to set `threshold_min` to an arbitrarily low value, we foresee that users may wish to only use CMA-ME without having to worry about `threshold_min`.\n", "\n", "Thus, we have made it possible to activate the original CMA-ME behavior by passing in $\\alpha=1$ and $min_f=-\\infty$ (note that these are in fact the default values for all archives). The table below shows all the possible values of `learning_rate` and `threshold_min` for the archives.\n", "\n", "| `learning_rate` ($\\alpha$) | `threshold_min` ($min_f$) | Improvement values |\n", "| -------------------------- | ------------------------- | --------------------------- |\n", "| $1$ | $-\\infty$ | Two-stage (CMA-ME) |\n", "| $0\\le\\alpha\\le1$ | (any value) | $f(\\theta) - t_e$ (CMA-MAE) |\n", "\n", "Supporting this behavior introduces two additional considerations:\n", "\n", "1. When we perform batch addition via the `add()` method on an archive with CMA-MAE, we apply the CMA-MAE batch addition rule in Appendix H of [Fontaine 2022](https://arxiv.org/abs/2205.10752). However, when using CMA-ME settings, we update the threshold by taking the maximum objective value to maintain consistency with the original algorithm.\n", "2. When using the CMA-ME settings, using a regular `ImprovementRanker` (i.e. `ranker=\"imp\"`) is not advisable, as CMA-ME is only designed to work with two-stage improvement ranking (it is okay to use non-two stage versions of [other rankers](https://docs.pyribs.org/en/stable/api/ribs.emitters.rankers.html), however)." ] }, { "cell_type": "markdown", "id": "f8a30983", "metadata": { "id": "f8a30983" }, "source": [ "## Running CMA-MAE\n", "\n", "Having set up the necessary components above, we now run CMA-MAE for 10,000 iterations in accordance with the experiments in [Fontaine 2022](https://arxiv.org/abs/2205.10752). Note that we report the **normalized QD score** here, which is the QD score divided by the number of cells in the archive. This experiment should take **~5 minutes** to run." ] }, { "cell_type": "code", "execution_count": 9, "id": "9bf03e8d", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9bf03e8d", "outputId": "c89a1865-76df-4b27-8225-2afefffa151d" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration 500 | Archive Coverage: 57.910% Normalized QD Score: 46.191 \n", "Iteration 1000 | Archive Coverage: 66.210% Normalized QD Score: 51.180 \n", "Iteration 1500 | Archive Coverage: 72.000% Normalized QD Score: 54.795 \n", "Iteration 2000 | Archive Coverage: 75.200% Normalized QD Score: 56.734 \n", "Iteration 2500 | Archive Coverage: 76.500% Normalized QD Score: 58.192 \n", "Iteration 3000 | Archive Coverage: 78.030% Normalized QD Score: 59.573 \n", "Iteration 3500 | Archive Coverage: 78.240% Normalized QD Score: 60.064 \n", "Iteration 4000 | Archive Coverage: 78.700% Normalized QD Score: 60.706 \n", "Iteration 4500 | Archive Coverage: 79.670% Normalized QD Score: 61.416 \n", "Iteration 5000 | Archive Coverage: 80.410% Normalized QD Score: 61.985 \n", "Iteration 5500 | Archive Coverage: 80.570% Normalized QD Score: 62.287 \n", "Iteration 6000 | Archive Coverage: 80.680% Normalized QD Score: 62.527 \n", "Iteration 6500 | Archive Coverage: 80.810% Normalized QD Score: 62.722 \n", "Iteration 7000 | Archive Coverage: 80.810% Normalized QD Score: 62.810 \n", "Iteration 7500 | Archive Coverage: 80.970% Normalized QD Score: 62.958 \n", "Iteration 8000 | Archive Coverage: 81.010% Normalized QD Score: 63.038 \n", "Iteration 8500 | Archive Coverage: 81.010% Normalized QD Score: 63.099 \n", "Iteration 9000 | Archive Coverage: 81.060% Normalized QD Score: 63.192 \n", "Iteration 9500 | Archive Coverage: 81.060% Normalized QD Score: 63.234 \n", "Iteration 10000 | Archive Coverage: 81.060% Normalized QD Score: 63.271 \n", "Iterations: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 10000/10000 [02:36<00:00, 63.91it/s]\n" ] } ], "source": [ "total_itrs = 10_000\n", "\n", "for itr in trange(1, total_itrs + 1, file=sys.stdout, desc='Iterations'):\n", " solution_batch = scheduler.ask()\n", " objective_batch, measure_batch = sphere(solution_batch)\n", " scheduler.tell(objective_batch, measure_batch)\n", "\n", " # Output progress every 500 iterations or on the final iteration.\n", " if itr % 500 == 0 or itr == total_itrs:\n", " tqdm.write(f\"Iteration {itr:5d} | \"\n", " f\"Archive Coverage: {result_archive.stats.coverage * 100:6.3f}% \"\n", " f\"Normalized QD Score: {result_archive.stats.norm_qd_score:6.3f}\")" ] }, { "cell_type": "markdown", "id": "17207b65", "metadata": { "id": "17207b65" }, "source": [ "## Visualization\n", "\n", "Now we visualize the result archive with [`grid_archive_heatmap`](https://docs.pyribs.org/en/stable/api/ribs.visualize.grid_archive_heatmap.html) from the [`ribs.visualize`](https://docs.pyribs.org/en/stable/api/ribs.visualize.html) module (as mentioned previously, the archive used in the main algorithm does not always hold the best solutions, while the result archive does)." ] }, { "cell_type": "code", "execution_count": 10, "id": "3d03f124-0073-4f6c-9401-454b0b00afdf", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from ribs.visualize import grid_archive_heatmap\n", "\n", "plt.figure(figsize=(8, 6))\n", "grid_archive_heatmap(result_archive, vmin=0, vmax=100)" ] }, { "cell_type": "markdown", "id": "8jizIZfWjYT0", "metadata": { "id": "8jizIZfWjYT0" }, "source": [ "## Exploring the Effect of Learning Rate $\\alpha$\n", "\n", "In the previous section, we explored CMA-MAE using $\\alpha = 0.01$, but what about other settings of $\\alpha$? In theory, lower values of $\\alpha$ should result in a greater emphasis on optimization, to the point that CMA-MAE becomes CMA-ES at $\\alpha = 0.0$. Meanwhile, higher values should result in less emphasis on optimization, to the point that CMA-MAE becomes CMA-ME at $\\alpha = 1.0$. We'll see if we can reproduce this behavior in our experiments by exploring how different learning rates affect CMA-MAE on the sphere function. We first define a method for creating a scheduler with a given `learning_rate`." ] }, { "cell_type": "code", "execution_count": 11, "id": "FN3RMtPLnSr5", "metadata": { "id": "FN3RMtPLnSr5" }, "outputs": [], "source": [ "def create_scheduler(learning_rate):\n", " max_bound = 100 / 2 * 5.12\n", "\n", " archive = GridArchive(solution_dim=100,\n", " dims=(100, 100),\n", " ranges=[(-max_bound, max_bound), (-max_bound, max_bound)],\n", " learning_rate=learning_rate,\n", " threshold_min=0)\n", "\n", " result_archive = GridArchive(solution_dim=100,\n", " dims=(100, 100),\n", " ranges=[(-max_bound, max_bound), (-max_bound, max_bound)])\n", "\n", " emitters = [\n", " EvolutionStrategyEmitter(\n", " archive,\n", " x0=np.zeros(100),\n", " sigma0=0.5,\n", " ranker=\"imp\",\n", " selection_rule=\"mu\",\n", " restart_rule=\"basic\",\n", " batch_size=36,\n", " ) for _ in range(15)\n", " ]\n", "\n", " return Scheduler(archive, emitters, result_archive=result_archive)" ] }, { "cell_type": "markdown", "id": "t0LABtIuqS7a", "metadata": { "id": "t0LABtIuqS7a" }, "source": [ "Then, we run the experiments with a range of learning rates while keeping track of the performance (normalized QD score and archive coverage) for each learning rate. This experiment should take **~15 minutes** to complete. To save time, we reduce the iterations for this experiment from 10,000 to 5,000." ] }, { "cell_type": "code", "execution_count": 12, "id": "gU2ngZ8PjgEs", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "gU2ngZ8PjgEs", "outputId": "57dad911-4513-46ac-8841-79f3a297ac72" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=== (1/5) Running CMA-MAE with learning_rate = 0 ===\n", "Iteration 500 | Archive Coverage: 3.220% Normalized QD Score: 3.111 \n", "Iteration 1000 | Archive Coverage: 3.520% Normalized QD Score: 3.406 \n", "Iteration 1500 | Archive Coverage: 3.890% Normalized QD Score: 3.760 \n", "Iteration 2000 | Archive Coverage: 4.230% Normalized QD Score: 4.086 \n", "Iteration 2500 | Archive Coverage: 4.270% Normalized QD Score: 4.125 \n", "Iteration 3000 | Archive Coverage: 4.380% Normalized QD Score: 4.230 \n", "Iteration 3500 | Archive Coverage: 4.490% Normalized QD Score: 4.334 \n", "Iteration 4000 | Archive Coverage: 4.560% Normalized QD Score: 4.403 \n", "Iteration 4500 | Archive Coverage: 4.750% Normalized QD Score: 4.583 \n", "Iteration 5000 | Archive Coverage: 4.950% Normalized QD Score: 4.770 \n", "Iterations: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [01:14<00:00, 67.42it/s]\n", "=== (2/5) Running CMA-MAE with learning_rate = 0.001 ===\n", "Iteration 500 | Archive Coverage: 30.720% Normalized QD Score: 28.557 \n", "Iteration 1000 | Archive Coverage: 38.930% Normalized QD Score: 35.443 \n", "Iteration 1500 | Archive Coverage: 44.310% Normalized QD Score: 39.752 \n", "Iteration 2000 | Archive Coverage: 51.160% Normalized QD Score: 44.905 \n", "Iteration 2500 | Archive Coverage: 57.350% Normalized QD Score: 49.248 \n", "Iteration 3000 | Archive Coverage: 60.330% Normalized QD Score: 51.225 \n", "Iteration 3500 | Archive Coverage: 63.220% Normalized QD Score: 53.086 \n", "Iteration 4000 | Archive Coverage: 65.490% Normalized QD Score: 54.505 \n", "Iteration 4500 | Archive Coverage: 68.680% Normalized QD Score: 56.440 \n", "Iteration 5000 | Archive Coverage: 69.870% Normalized QD Score: 57.131 \n", "Iterations: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [01:15<00:00, 66.17it/s]\n", "=== (3/5) Running CMA-MAE with learning_rate = 0.01 ===\n", "Iteration 500 | Archive Coverage: 53.790% Normalized QD Score: 44.054 \n", "Iteration 1000 | Archive Coverage: 65.040% Normalized QD Score: 50.904 \n", "Iteration 1500 | Archive Coverage: 71.730% Normalized QD Score: 54.715 \n", "Iteration 2000 | Archive Coverage: 74.890% Normalized QD Score: 56.757 \n", "Iteration 2500 | Archive Coverage: 76.000% Normalized QD Score: 57.990 \n", "Iteration 3000 | Archive Coverage: 77.340% Normalized QD Score: 59.132 \n", "Iteration 3500 | Archive Coverage: 78.470% Normalized QD Score: 60.224 \n", "Iteration 4000 | Archive Coverage: 79.140% Normalized QD Score: 60.905 \n", "Iteration 4500 | Archive Coverage: 79.230% Normalized QD Score: 61.216 \n", "Iteration 5000 | Archive Coverage: 79.770% Normalized QD Score: 61.791 \n", "Iterations: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [01:16<00:00, 65.28it/s]\n", "=== (4/5) Running CMA-MAE with learning_rate = 0.1 ===\n", "Iteration 500 | Archive Coverage: 59.240% Normalized QD Score: 44.706 \n", "Iteration 1000 | Archive Coverage: 67.000% Normalized QD Score: 52.202 \n", "Iteration 1500 | Archive Coverage: 69.410% Normalized QD Score: 54.884 \n", "Iteration 2000 | Archive Coverage: 71.640% Normalized QD Score: 56.774 \n", "Iteration 2500 | Archive Coverage: 73.880% Normalized QD Score: 58.491 \n", "Iteration 3000 | Archive Coverage: 74.640% Normalized QD Score: 59.178 \n", "Iteration 3500 | Archive Coverage: 74.780% Normalized QD Score: 59.353 \n", "Iteration 4000 | Archive Coverage: 74.780% Normalized QD Score: 59.364 \n", "Iteration 4500 | Archive Coverage: 74.780% Normalized QD Score: 59.367 \n", "Iteration 5000 | Archive Coverage: 74.780% Normalized QD Score: 59.367 \n", "Iterations: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [01:14<00:00, 66.88it/s]\n", "=== (5/5) Running CMA-MAE with learning_rate = 1 ===\n", "Iteration 500 | Archive Coverage: 44.090% Normalized QD Score: 36.848 \n", "Iteration 1000 | Archive Coverage: 47.630% Normalized QD Score: 40.044 \n", "Iteration 1500 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iteration 2000 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iteration 2500 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iteration 3000 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iteration 3500 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iteration 4000 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iteration 4500 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iteration 5000 | Archive Coverage: 47.900% Normalized QD Score: 40.321 \n", "Iterations: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [01:13<00:00, 68.46it/s]\n" ] } ], "source": [ "# The learning rates that we run CMA-MAE with.\n", "learning_rates = [0, 0.001, 0.01, 0.1, 1]\n", "\n", "# Run for 5000 iterations.\n", "total_itrs = 5000\n", "\n", "# All schedulers for the experiments.\n", "all_schedulers = [\n", " create_scheduler(lr) for lr in learning_rates\n", "]\n", "\n", "# Tracks the metrics of all the experiments.\n", "all_metrics = {}\n", "\n", "for li, (scheduler, learning_rate) in enumerate(zip(all_schedulers, learning_rates)): \n", " result_archive = scheduler.result_archive\n", "\n", " # Metrics that we track.\n", " metrics = {\n", " \"Archive Coverage\": {\n", " \"x\": [0],\n", " \"y\": [0.0],\n", " },\n", " \"Normalized QD Score\": {\n", " \"x\": [0],\n", " \"y\": [0.0],\n", " },\n", " }\n", "\n", " print(f\"=== ({li+1}/{len(learning_rates)}) Running CMA-MAE with learning_rate = {learning_rate} ===\")\n", " for itr in trange(1, total_itrs + 1, file=sys.stdout, desc='Iterations'):\n", " solution_batch = scheduler.ask()\n", " objective_batch, measure_batch = sphere(solution_batch)\n", " scheduler.tell(objective_batch, measure_batch)\n", "\n", " if itr % 500 == 0 or itr == total_itrs:\n", " tqdm.write(f\"Iteration {itr:5d} | \"\n", " f\"Archive Coverage: {result_archive.stats.coverage * 100:6.3f}% \"\n", " f\"Normalized QD Score: {result_archive.stats.norm_qd_score:6.3f}\")\n", "\n", " metrics[\"Archive Coverage\"][\"x\"].append(itr)\n", " metrics[\"Archive Coverage\"][\"y\"].append(result_archive.stats.coverage * 100)\n", " metrics[\"Normalized QD Score\"][\"x\"].append(itr)\n", " metrics[\"Normalized QD Score\"][\"y\"].append(result_archive.stats.norm_qd_score)\n", "\n", " all_metrics[learning_rate] = metrics" ] }, { "cell_type": "markdown", "id": "C-FL-5syqpCy", "metadata": { "id": "C-FL-5syqpCy" }, "source": [ "Now, we can plot the metrics for each learning rate." ] }, { "cell_type": "code", "execution_count": 13, "id": "V4WxUyt5t0rJ", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 295 }, "id": "V4WxUyt5t0rJ", "outputId": "13d9b9b4-972b-4c72-8311-a88724ddb230" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Markers for accessiblity.\n", "markers=['o', 'P', 'x', 'v', '^']\n", "\n", "for learning_rate, marker in zip(learning_rates, markers):\n", " metrics = all_metrics[learning_rate]\n", " plt.plot(metrics[\"Normalized QD Score\"][\"x\"],\n", " metrics[\"Normalized QD Score\"][\"y\"],\n", " marker=marker)\n", "\n", "plt.title(\"Normalized QD Score of CMA-MAE at Various Learning Rates\")\n", "plt.xlabel(\"Iteration\")\n", "plt.ylabel(\"Normalized QD Score\")\n", "plt.legend(learning_rates, title=\"learning rate\");" ] }, { "cell_type": "code", "execution_count": 14, "id": "yuyAm-5rxMsJ", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 295 }, "id": "yuyAm-5rxMsJ", "outputId": "1741da9a-0b6a-440a-e30d-f3b992ff4797" }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAHFCAYAAAAHcXhbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC1f0lEQVR4nOzdd3jTVdvA8W/SpnvvQYECbVllCIiALBUQcG95nKCAuAAVQRwICoKK+CqCAxmP4lYeRWVrWSKI7D3LaEspdNDdJOf949ekTXegE+7PdfVq8lu5m6bJ3XPuc45OKaUQQgghhGig9HUdgBBCCCHEpZBkRgghhBANmiQzQgghhGjQJJkRQgghRIMmyYwQQgghGjRJZoQQQgjRoEkyI4QQQogGTZIZIYQQQjRokswIIYQQokGTZKYK/u///g+dTkfbtm1r5PqTJk1Cp9ORkpJS6bFNmzblkUceqZE4KmM2m/nvf//LDTfcQEBAAAaDgaCgIG666SZ++eUXzGZzncR1JXj55Zdp3Lgxjo6O+Pj4VHr8unXruOeeewgPD8fJyQlvb2+6d+/OnDlzyMrKsh7XtGlTdDodffr0KfM6ixYtQqfTodPp+PPPP8s8ZuzYseh0Om666Sa7fqYFCxZUeG2lFC1atKgwvpSUFJydndHpdPzzzz9lHvPII49YH6esr+qyePFiZs2aVelxZ8+excnJifvuu6/cYzIyMnBzc+OWW26pltgs7zH10fHjx9HpdLzzzjt1HYrd6vJ5tTy25ctgMNC4cWMef/xxkpKSLuqa2dnZTJo0qdy/9frMsa4DaAg+//xzAPbs2cPff/9N165d6yyWn376CS8vr1p/3NzcXG677TZWrFjBfffdx5w5cwgJCeHs2bMsW7aMu+++m2+++YZbb7211mO73P3vf//jzTffZOLEiQwcOBBnZ+cKj3/ttdeYPHky3bt3Z8qUKTRv3pzs7Gw2btzIpEmTOHjwIO+99571eE9PT9auXcuRI0do3ry5zbU+//xzvLy8yMjIKPOxCgoK+OKLLwBYtmwZp0+fJjw83K6fz9PTk3nz5pVKWOLi4jhy5Aienp7lnvvf//6X/Px8AObNm0fnzp3LPM7V1ZU1a9bYFZe9Fi9ezO7duxk9enSFxwUGBnLLLbewZMkSUlNT8fX1LXXM119/TU5ODsOGDauW2B577DFuvPHGarmWKFIfntdly5bh7e1NZmYmK1as4N1332Xjxo1s374dg8Fg17Wys7N5/fXXAcr9B6LeUqJCW7ZsUYAaPHiwAtTjjz9epfOMRqPKzc2t0rGvvfaaAtTZs2cvJdQa9cQTTyhALVy4sMz9Bw8eVDt27KjlqCpnNptVdnZ2XYdxSd544w0FqDNnzlR67LfffqsANWzYMGU2m0vtz8jIUMuXL7feb9KkiRo4cKBq1KiReumll2yOPXz4sNLpdOrxxx9XgPrjjz9KXe+7776z+ft48803q/xzzZ8/XwHqscceU66urio9Pd1m/wMPPKC6deum2rRpo3r37l3mNdq2bauCgoJUly5dlLe3d5m/64cffli5u7tXOa6LNXjwYNWkSZMqHfvbb78pQH3wwQdl7u/atasKDg5WBQUFlxRTVlbWJZ1fG44dO6YA9fbbb9d1KA3i+bIo73Pj0UcfVYBas2aN3dc8e/asAtRrr71WTVHWHklmKjFy5EgFqF27dqnu3bsrT0/PUi94yx/j9OnT1ZQpU1TTpk2Vg4OD+v3335VSSm3atEnddNNNys/PTzk7O6tmzZqpZ5991nq+5UW5e/dudd999ykvLy8VFBSkHn30UZWWlmbzWE2aNFEPP/ywUkqp5ORkZTAY1Msvv1wq7n379ilAvf/++9ZtiYmJavjw4So8PFwZDAbVtGlTNWnSpErfMBMTE5XBYFADBgyo8vMWHx+v/vOf/6jAwEDl5OSkWrZsqd555x1lMpmUUkrl5+erwMBA9cADD5Q6NzU1Vbm4uKgxY8ZYt6Wnp6vnnntONW3aVBkMBhUWFqaeffZZlZmZaXMuoJ588kk1Z84c1bJlS2UwGNScOXOUUkpNmjRJXX311crX11d5enqqjh07qs8++6zUh35ubq4aO3asCg4OVq6urqpnz57qn3/+sXnuL/U5VUopk8mkpk+frmJiYpSTk5MKDAxUDz74oDp58qT1mCZNmijA5quiN5q2bdsqX1/fKr8pN2nSRA0ePFi99NJLKjw83Pr7UUqpl156STVu3Fh988035SYzN954o3JyclLJyckqIiJCtWjRoswkqiyWZGb16tXK1dVVzZ0717ovLS1Nubq6qk8//bTcZGbTpk0KUM8995z65JNPFKD++9//ljruUpOZDz/8UPXs2VMFBgYqNzc31bZtWzV9+nSVn59vPaZ3796lfk8V/a9oMplUo0aN1FVXXVVq3969exWgXnjhBaWUUitWrFC33HKLCg8PV87Ozqp58+Zq+PDhpT7ELO8jW7duVXfeeafy8fFRISEhNvtKxlDZ608pVebr3vIzF/+9mEwmNWXKFBUdHa1cXFyUt7e3io2NVbNmzSr3eVCq6slMVd8DqvL7ssTfpk0bFRcXp7p166ZcXV3VvffeaxPPu+++q5o2barc3d3VNddco/766y+ba5T1vFr+pn7//XfVsWNH5eLiomJiYtS8efNK/Uzr1q1T11xzjXJ2dlZhYWHq5ZdfVp9++qkC1LFjxyp8PspLZmbPnq0A9dVXX1m3JScnqyeeeEK1atVKubu7q8DAQNW3b1+1du1a6zGWn7vkV/Hf/cGDB9X9999v877+4Ycf2jz+xb4OLpUkMxXIzs5W3t7eqkuXLkoppT777DMFqAULFtgcZ3kRhIeHq759+6rvv/9erVixQh07dkwtW7ZMGQwG1a5dO7VgwQK1Zs0a9fnnn6v77rvPer7lRRkTE6NeffVVtXLlSjVz5kzl7OysHn30UZvHKvnGcvvtt6uIiAibDyGllBo3bpxycnJSKSkpSintQzciIkI1adJEffzxx2rVqlVqypQpytnZWT3yyCMVPg+LFy9WgDUpqExycrIKDw9XgYGBau7cuWrZsmXqqaeeUoB64oknrMeNGTOmzP/IP/roIwWonTt3KqW0/5Y6dOigAgIC1MyZM9WqVavU+++/r7y9vdV1111n8+Fp+T20a9dOLV68WK1Zs0bt3r1bKaXUI488oubNm6dWrlypVq5cqaZMmaJcXV3V66+/bvP4999/v9Lr9Wr8+PFqxYoVatasWSoiIkJ5e3vbPPeX8pwqpdTw4cMVoJ566im1bNkyNXfuXBUYGKgiIiKsb1D//vuvGjZsmALUsmXL1F9//VXqw8YiISFBAeree++t9LEtLG+8llaY3377TSmltSyGh4erV1991dr6UjKZOXnypNLr9eruu+9WSin18ssvK0D9+eefVXpsSzKzZcsW9eCDD6qrr77aum/OnDnK3d1dZWRklJvMWFqM9uzZozIyMpSbm5vq06dPqeMsyUxBQUGpr5J/N2UZM2aMmjNnjlq2bJlas2aNeu+991RAQIDN3+aePXtUjx49VEhIiPrrr7+sXxWxPF/bt2+32f7CCy8oQO3bt8/6XEybNk39/PPPKi4uTi1cuFC1b99excTE2HxAW95HmjRpol588UW1cuVKtWTJEpt9xVXl9adU1ZOZadOmKQcHB/Xaa6+p1atXq2XLlqlZs2apSZMmVfg8VCWZsec9oCq/L0v8fn5+KiIiQn3wwQfqjz/+UHFxcdZ4mjZtqm688Ua1ZMkStWTJEhUbG6t8fX1t/sEsL5lp1KiRat26tVq0aJFavny5uvvuuxWg4uLirMft2LFDubi4qHbt2qmvv/5a/fzzz2rQoEGqadOml5TMPP/889ak1mL//v3qiSeeUF9//bX6888/1dKlS9WwYcOUXq+3/l3n5uaqZcuWWVt2La/hw4cPK6W017glMVm0aJFasWKFeu6555Rer7f5HV/s6+BSSTJTgUWLFinA+h/jhQsXlIeHh+rZs6fNcZYXf/PmzUtl/82bN1fNmzdXOTk55T6O5UU5Y8YMm+2jRo1SLi4uNn+oJd9Yfv75ZwWoFStWWLcZjUYVFham7rzzTuu2ESNGKA8PDxUfH2/zGO+88471A6E8b731lvXDtCrGjx+vAPX333/bbH/iiSeUTqdTBw4cUEoptXPnTgWoTz75xOa4q6++WnXq1Ml6f9q0aUqv16stW7bYHPf9998rwPoBrJSWzHh7e6vz589XGKPJZFIFBQVq8uTJyt/f3/oc79mzRwHqxRdftDn+q6++KvVfyqU8p5aWs1GjRtls//vvvxVg0+VT1W5IS0vF+PHjKzyuOEsyo5T25n7XXXcppZT69ddflU6nU8eOHSs3mZk8ebLN6+Lo0aNKp9OpBx98sEqPXTyZ+eOPP6ytk0op1aVLF2tCWFYyk5WVpby8vNQ111xj3fbwww8rnU5nffMtvr2s/zgBdf3111ftiSpked0sWrRIOTg42LzO7OlmUqro+XrmmWes2woKClRISIjq0aNHmeeYzWZVUFCg4uPjFaD+97//WfdZXievvvpqqfNKfuja8/qrajJz0003qQ4dOlT6c5dUlWTGnveA4ir6fVla01avXl1mPLGxscpoNFq3b968uVSLR3nJjIuLi837Qk5OjvLz81MjRoywbrv77ruVu7u7zd+1yWRSrVu3tiuZSUpKUgUFBSo1NVV9++23yt3dXd1///0Vnms0GlVBQYG6/vrr1e23327dXlE304ABA1SjRo1K/fP51FNPKRcXF+tze7Gvg0slo5kqMG/ePFxdXa2jDjw8PLj77rtZt24dhw4dKnX8LbfcYlNwdfDgQY4cOcKwYcNwcXGp9PFKjlxo164dubm5JCcnl3vOwIEDCQkJYf78+dZty5cvJyEhgaFDh1q3LV26lL59+xIWFobRaLR+DRw4ENCKLavLmjVraN26NVdffbXN9kceeQSllLUQMzY2lk6dOtnEvm/fPjZv3lwq9rZt29KhQweb2AcMGFDmSJjrrruuzKLKNWvWcMMNN+Dt7Y2DgwMGg4FXX32Vc+fOWZ9jy/Nwzz332Jx711134ehoWy9/Kc/pH3/8YX1Oirv66qtp1aoVq1evLvfcmjJ06FB+/vlnzp07x7x58+jbty9NmzYt81ilFPPnzyciIoJ+/foBEBkZSZ8+ffjhhx+sBcNKKZvnxmg0lnm93r1707x5cz7//HN27drFli1bbF4DJX377bdkZGTYHDN06FBrXCW5urqyZcuWUl8fffRRpc/Ltm3buOWWW/D397e+bh566CFMJhMHDx6s9PzyREZG0rdvX7788ktrEfPvv/9OUlKSzc+VnJzMyJEjiYiIwNHREYPBQJMmTQDt76WkO++8s9LHronX39VXX82OHTsYNWoUy5cvL7do/GLY8x5gz+/L19eX6667rszHHDx4MA4ODtb77dq1AyA+Pr7SeDt06EDjxo2t911cXIiOjrY5Ny4ujuuuu46AgADrNr1eX+q9pzIhISEYDAZ8fX2555576NSpEwsXLix13Ny5c7nqqqtwcXGxvo5Wr15d5muopNzcXFavXs3tt9+Om5ubze9g0KBB5ObmsmnTJqBmXwcVkWSmHIcPH2bt2rUMHjwYpRRpaWmkpaVx1113AUUjnIoLDQ21uX/27FkAGjVqVKXH9Pf3t7lvGbWSk5NT7jmOjo48+OCD/PTTT6SlpQHakNfQ0FAGDBhgPe7MmTP88ssvGAwGm682bdoAVDgs3PJHeezYsSr9HOfOnSv1XACEhYVZ91sMHTqUv/76i/379wMwf/58nJ2duf/++21i37lzZ6nYPT09UUqVir2sx968eTP9+/cH4NNPP2XDhg1s2bKFiRMnAkXPsSW24OBgm/MdHR1L/X4u5Tm1PE55z1Px56iq7P09lXTXXXfh4uLCe++9xy+//FLhSJo1a9Zw7Ngx7r77bjIyMqx/H/fccw/Z2dl89dVXgPaGXfL5OX78eKnr6XQ6Hn30Ub744gvmzp1LdHQ0PXv2LPfx582bh4uLCzfeeKP1sdu1a0fTpk1ZsGABJpPJ5ni9Xk/nzp1LfUVHR1f4nJw4cYKePXty+vRp3n//fdatW8eWLVuYPXs2UPHfZlUMGzaMc+fO8fPPPwPa69/Dw8P6gWY2m+nfvz8//vgj48aNY/Xq1WzevNn6wVHW45f1miqpJl5/EyZM4J133mHTpk0MHDgQf39/rr/++nKHzNujqu8B9v6+KnquLub9uLxzLecXP/fcuXOl3meg9HtPZVatWsWWLVtYvnw5d955J2vXruXpp5+2OWbmzJk88cQTdO3alR9++IFNmzaxZcsWbrzxxir9POfOncNoNPLBBx+U+h0MGjQIKHq/q8nXQUVkaHY5Pv/8c5RSfP/993z//fel9i9cuJA33njDJnMvOd9AYGAgAKdOnarRWB999FHefvttvv76a+69915+/vlnRo8ebRNbQEAA7dq148033yzzGpZEoyx9+/bFYDCwZMkSRo4cWWk8/v7+JCYmltqekJBgjcXi/vvvZ+zYsSxYsIA333yT//73v9x22202LSsBAQG4urqWmUCWvB6U/j2ANtTVYDCwdOlSm1ayJUuWlIodtDfP4kOMjUZjqTf4S3lOLY+TmJhYKtlNSEgo9TNVRWhoKLGxsaxYsYLs7Gzc3NzsOt/NzY377ruPadOm4eXlxR133FHusfPmzQO0N8mZM2eWuX/EiBF06tSJLVu22Owr73l55JFHePXVV5k7d265zyloLZ7r168HsPnvt7jly5db32QvxZIlS8jKyuLHH3+0toYAbN++/ZKvDXDHHXfg6+vL559/Tu/evVm6dCkPPfQQHh4eAOzevZsdO3awYMECHn74Yet5hw8fLveaVZn3xJ7Xn4uLC3l5eaWukZKSYnOco6MjY8eOZezYsaSlpbFq1SpeeuklBgwYwMmTJ+1+PRZX1fcAe39fdTn3jr+/P2fOnCm13d45Ytq3b2/9+fv168eAAQP45JNPGDZsGF26dAHgiy++oE+fPsyZM8fm3AsXLlTpMXx9fXFwcODBBx/kySefLPOYyMhIoGZfBxWRZKYMJpOJhQsX0rx5cz777LNS+5cuXcq7777L77//XuFEYdHR0dam87Fjx1Y6P8jFatWqFV27dmX+/PmYTCby8vJ49NFHbY656aab+O2332jevHmZXTAVCQkJ4bHHHmPOnDksWrSIhx56qNQxR44cISsri3bt2nH99dczbdo0/v33X6666irrMZYJ2Pr27Wvd5uvry2233caiRYvo1q1bqSZ2S+xTp07F39/f+gdjL51Oh6Ojo02Cl5OTw3//+1+b43r16gXAN998YxP7999/X6qL5FKeU0vT9hdffGF9wwHYsmUL+/bts7YY2euVV17hnnvu4ZlnnuHTTz8t9WadmZnJxo0bra1UJT3xxBOcOXOG3r17l9s1mpqayk8//USPHj144403Su3/7LPP+PLLL9m9ezdt27Ytd+6XksLDw3nhhRfYv3+/zQd3SZZE6tNPP6VFixY2+3Jycrj11lv5/PPPqyWZsTx/xf92lVJ8+umnpY4t+Z93Vbi4uDBkyBDmzp3L9OnTKSgosHn9l/X4AB9//LFdj1OSPa+/pk2bsnPnTpvzDx48yIEDB8pNun18fLjrrrs4ffo0o0eP5vjx47Ru3fqi463qe4A9v6+61rt3b3777TebpNBsNvPdd99d9DV1Oh2zZ8+mdevWvPzyyyxfvty6veRraOfOnfz1119ERERYt5XX+uTm5kbfvn3Ztm0b7dq1w8nJqUrxVPfroCKSzJTh999/JyEhgenTp5c5cVDbtm358MMPmTdvXqWzns6ePZubb76Za665hjFjxtC4cWNOnDjB8uXL+fLLL6st5qFDhzJixAgSEhLo3r07MTExNvsnT57MypUr6d69O8888wwxMTHk5uZy/PhxfvvtN+bOnVthd9jMmTM5evQojzzyCMuXL+f2228nODiYlJQUVq5cyfz58/n6669p164dY8aMYdGiRQwePJjJkyfTpEkTfv31Vz766COeeOKJUk37Q4cO5ZtvvuGpp56iUaNG3HDDDTb7R48ezQ8//ECvXr0YM2YM7dq1w2w2c+LECVasWMFzzz1X6USGgwcPZubMmQwZMoThw4dz7tw53nnnnVJ/4G3atOH+++/n3XffxcHBgeuuu449e/bw7rvv4u3tjV5f1DN7Kc9pTEwMw4cP54MPPkCv1zNw4ECOHz/OK6+8QkREBGPGjKnw5ynP3XffzSuvvMKUKVPYv38/w4YNs06a9/fff/Pxxx9z7733lpvMdOjQoVRrVUlffvklubm5PPPMM2X+ffj7+/Pll18yb948m8n5quKtt96qcL/RaGTRokW0atWKxx57rMxjbr75Zn7++WfOnj1rbR01m83WrpmSOnbsWO4/Gv369cPJyYn777+fcePGkZuby5w5c0hNTS11bGxsLD/++CNz5syhU6dO1q6tygwbNozZs2czc+ZMWrZsSffu3a37WrZsSfPmzRk/fjxKKfz8/Pjll19YuXJlpdetiD2vvwcffJAHHniAUaNGceeddxIfH8+MGTOsz63FzTffbE1eAwMDiY+PZ9asWTRp0oSoqKhKY9q1a1eZreBdunSp8nuAPb+vujZx4kR++eUXrr/+eiZOnIirqytz5861ztBd/L3GHlFRUQwfPpyPPvqI9evXc+2113LTTTcxZcoUXnvtNXr37s2BAweYPHkykZGRNv+keXp60qRJE/73v/9x/fXX4+fnR0BAAE2bNuX999/n2muvpWfPnjzxxBM0bdqUCxcucPjwYX755RdrLeSlvg4uWq2XHDcAt912m3XujPLcd999ytHRUSUlJVVajf/XX3+pgQMHKm9vb+s8EcXnUClvtIpltEfxqvbyRhakp6crV1dXBahPP/20zDjOnj2rnnnmGRUZGakMBoPy8/NTnTp1UhMnTiw1V0NZjEajWrhwobruuuuUn5+fcnR0VIGBgWrgwIFq8eLFNsNc4+Pj1ZAhQ5S/v78yGAwqJiZGvf3222UOhTWZTCoiIkIBauLEiWU+dmZmpnr55Zetc2JYhgiOGTNGJSUlWY+jcJ6Zsnz++ecqJibGOtfPtGnT1Lx580o9x5Z5ZoKCgpSLi4t1fglvb2+b39ulPqeWeT6io6OVwWBQAQEB6oEHHig19PpiJlWMi4tTd911lwoNDVUGg0F5eXmpbt26qbfffltlZGRYjys+mqk8JUczdejQQQUFBam8vLxyz7nmmmtUQEBAhccUH81UkeKjmZYsWaKACuessAwvfffdd5VSFY9mAtShQ4cqfPxffvlFtW/fXrm4uKjw8HD1wgsvqN9//73UCK/z58+ru+66S/n4+CidTlfhPDMldezYscwRjUpp887069dPeXp6Kl9fX3X33XerEydOlBp1UtHrpKJ5Zip7/ZnNZjVjxgzVrFkz5eLiojp37qzWrFlTajTTu+++q7p3764CAgKUk5OTaty4sRo2bJg6fvx4hT97efObWL7mz5+vlKr6e0BVf1+WeWbKi6es9/PynvPiyvubKvl8KaXNM9O1a1fl7OysQkJC1AsvvKCmT5+ugFJzjJVU0e/7zJkzysPDQ/Xt21cppVReXp56/vnnVXh4uHJxcVFXXXWVWrJkiXr44YdLjcBbtWqV6tixo3J2di41gvPYsWNq6NCh1nm1AgMDVffu3dUbb7xhPeZiXweXSqeUUjWXKglxedi4cSM9evTgyy+/ZMiQIXUdjhDiMtW/f3+OHz9+SSPlrkTSzSRECStXruSvv/6iU6dOuLq6smPHDt566y2ioqIqLIoVQgh7jB07lo4dOxIREcH58+f58ssvWblypbUuTFSdJDNClODl5cWKFSuYNWsWFy5cICAggIEDBzJt2rQqzRckhBBVYTKZePXVV0lKSkKn09G6dWv++9//8sADD9R1aA2OdDMJIYQQokGTSfOEEEII0aBJMiOEEEKIBk2SGSGEEEI0aJd9AbDZbCYhIQFPT886nbpaCCGEEFWnlOLChQuEhYVVOongZZ/MJCQk2EzXLIQQQoiG4+TJk5Uu2HzZJzOenp6A9mR4eXnVcTRCCCGEqIqMjAwiIiKsn+MVueyTGUvXkpeXlyQzQgghRANTlRIRKQAWQgghRIMmyYwQQgghGjRJZoQQQgjRoEkyI4QQQogGTZIZIYQQQjRokswIIYQQokGTZEYIIYQQDZokM0IIIYRo0CSZEUIIIUSDVqfJjNFo5OWXXyYyMhJXV1eaNWvG5MmTMZvN1mOUUkyaNImwsDBcXV3p06cPe/bsqcOohRBCCFGf1GkyM336dObOncuHH37Ivn37mDFjBm+//TYffPCB9ZgZM2Ywc+ZMPvzwQ7Zs2UJISAj9+vXjwoULdRi5EEIIcWX6aPtHzN0xt8x9c3fM5aPtH9VyRHWczPz111/ceuutDB48mKZNm3LXXXfRv39//vnnH0BrlZk1axYTJ07kjjvuoG3btixcuJDs7GwWL15cl6ELIYQQVyS9Ts/s7bNLJTRzd8xl9vbZ6HW1n1rUaTJz7bXXsnr1ag4ePAjAjh07WL9+PYMGDQLg2LFjJCUl0b9/f+s5zs7O9O7dm40bN5Z5zby8PDIyMmy+hBBCiPqoPrZyVGZk+5E82eFJZm+fzaytszideZpZW2cxe/tsnuzwJCPbj6z1mOp01ewXX3yR9PR0WrZsiYODAyaTiTfffJP7778fgKSkJACCg4NtzgsODiY+Pr7Ma06bNo3XX3+9ZgMXQghR73y0/SP0On2ZH6Zzd8zFrMyM6jCqDiIrn6WVA7CJ29LK8WSHJ6vtsYxmI1kFWWQXZJNVkEWWMcv2fkEW2cbsUvctt63HFp4HMG/3PObtngdQZ4kM1HEy88033/DFF1+wePFi2rRpw/bt2xk9ejRhYWE8/PDD1uNKLv+tlCp3SfAJEyYwduxY6/2MjAwiIiJq5gcQQghRb9RmYlBdLHEWj9sS76j2o3ig1QOcyTpDltE26SiZWNjsM2aRU5BTKiHJM+XV2M9RXhJZW3RKKVVXDx4REcH48eN58smiF9gbb7zBF198wf79+zl69CjNmzfn33//pWPHjtZjbr31Vnx8fFi4cGGlj5GRkYG3tzfp6el4eXnVyM8hhBCXm4bQyqGUIseYw4X8C9pXwQW+PfAtS48upVejXnQM6sjfiX+zKXETV4dczVXBV2FWZpRSmJUZM9ptkzIVbVNmFEW3y9pmPafENjMlzim2rdTjYBtHSnYKqXmp1p/NUe+I0WyskefNoDfgbnDH3eCOm8ENd8fC7wZ33BzdbPcV3i5+jOW4bw98y2e7P8OgN1BgLqj2lhl7Pr/rtGUmOzsbvd62bMfBwcE6NDsyMpKQkBBWrlxpTWby8/OJi4tj+vTptR6vEEJcKWqjlaOsZORC/gUy8jOKtuWXv+1C/gWMquwP/LWn1rL21Frr/c1Jm9mctPmSY64txRMZR50jbgY3a+JRMtEoLwGxbLduKzzX4GC45Pjm7pjLZ7s/syYwltcFcOXVzNx88828+eabNG7cmDZt2rBt2zZmzpzJ0KFDAa17afTo0UydOpWoqCiioqKYOnUqbm5uDBkypC5DF0KIy1pF3R+WD7CaTEbs4ahzxNPJ0+br78S/USj0Oj13RN2BHj06nQ4HnQN6nXZbj77otk5f9EXl23SU2F9im+WxSj0Oehz0DtZjLdf89civLDmyBEedI0Zl5IFWD/B4u8dxN7jjpHcqt7SiLpR8HUDZr5faVKfJzAcffMArr7zCqFGjSE5OJiwsjBEjRvDqq69ajxk3bhw5OTmMGjWK1NRUunbtyooVK/D09KzDyIUQ4vKUVZDFmewzJGcnE+YRxjWh1zB7+2w+2v4RCkWgayC/HPmFxfsWV1sy4qBzwMvJq1RCUuE2Q9E2V0dXmw/7uTvmsilxk7X7I9gtuE7rOSozd8dclhxZUqqVw9vZu17GbVbmMruULPfNylzWaTWqTmtmaoPUzAghBJjMJs7lniM5O9marFi+it+3jFKxh4POoUpJR1kJipeTV6lk5FKUbDUoqxWhPikvvvoed21oMDUzQghxJajpYtrsgmybhKSsZOVczjlMylSl67kb3AlyCyLILYi03DQOpB7AQeeASZkYHDmYe2LuqbFk5FLUx+6PytTHVo6GSJIZIYSoYRdbTGsymzife75UglIyWcksyKxyHAEuAdZEJcgtiGD3YNv7bsG4G9xLxVe8laOpd9N6lxRAw0wMKkpi6+NzXF9JMiOEEDWsrNaBD/79gE92fcJtzW8j3COcebvmlWpNSclJqXJripujmzUZKZmcWG77u/rjqK/a235DbOWQxODKJTUzQghRzZRSZORnkJCZQEJmAqczT5OQlcCG0xs4nnHcrmvpdXr8XfzLTVAstz2cPKr1Z2gI88yIy5s9n9+SzAghhJ3KS1ZOZ562bqtK14+ro2uplpSSyUqAa0CVW1OEuJxIAbAQQlyi9Lz0S05W/F38CfcIJ8wjjDCPMI6kHSHuVJx1dtehbYdK94cQ1UCSGSFEg1Jd3R+WlpXiCUrx2xcKLlR6DT8XP5tkJdxdux3uGU6oeyiujq42scWdiqs3M6YKcTmRZEYI0aBUdWRQjSYrHuGEetgmKxVpiMW0QjQkkswIIRqUke1HolDM3j6bs9ln6RHeg+8Ofsf60+uJ9IpkVfwqFu1ZVKvJSmUa4pBhIRoSKQAWQtQrmfmZJOck2wxTTs5O5mz2We12TjIp2SlVmkbfz8WPMPcwa4JiSVoaeTQixD0EN4NbLfxEQoiLIQXAQogqqc3htwWmAs7mnLVNUnJKJCrZyWQbs6t0PR06FMp6+5E2jxS1sHhoNSuSrFy8gsREjOfPl7vf0d8fQ0hILUZUOYm5dtTHmCWZEeIKdrEz0xZnVmbS8tJKtaRYW1QKE5jzueW/+ZXkafAk0C3QZrhyoGsgwW7B1u0/HvqROTvmWBcTdDO4cV/L++x/EmpBfXzzr4g5P59jd92N6dy5co9xCAigxZrV6J2cajGy8knMtaO+xizJjBBXsLKKUIsnMg+1fojj6cetM9KWbFk5m32W5JxkjOaqrZxs0BusiYlNouIWaJ1bJdA1sNIWlbk75jJnx5wGMTKovr75V0RnMGAIDcV0/jyUVYmg02EICUFnMNR+cOWQmGtHfY1ZkhkhrnAj2o3gbPZZZm+fzZztczBjxsfZh4V7FloThKrwc/GzaTkJci2dqPg4+1zygoQNbWRQfX3zL0kpBSYTymQCkwn/EcM5/fQz5R2M78MPY0w+W7tBVsL34YdJfOGFsndKzNWmspgDn3221hcelQJgIa5A2QXZ/J34N2tPr2XtqbUkZyeXe6y7wb1UF0/Jrp8A1wAMDrXzYTxv1XScL+RxZ/Sdpfb9cPAH8rxcGHb9uFqJpTxKKVR2Nqb0dEzp6WSuW8/ZmTPLPd6jb18cQ4LBZEaZjNp3swmMJpTZbJNkaPeNKFPR9gqPNRrL3F7ymDITLSHsodfj0ro1Tb/7tlqSGSkAFkKUcjrzNGtPrSXuVBxbEreQb8637rPMSOugc8CkTNza/FaGxg61WUG5PjDn59PztV8wnTvHcb4qtb8TWpeNuefoaumyUUphzsrClJaOKT0Nc2FyYkpLK/yebk1YbLanp0NBQZUfJ/OPPy451lql12tf9ZHZrH2VJDFXr7JiNpvrpFUGJJkR4rJlNBvZcXYHcafiWHdqHYfTDtvsD/cIp2d4T7IKsvjl6C+l6k8aeTaqV901cPFdNkopzJmZWqKRakk4tO9mSxJSMjGxJCXGqtUDlRevg48PDj7eKCD/0OFSx3jeeCNOkU3R6R3AQY/OwRGdgx70DugcHYp916NzcAAHB+27XjtWO8eyzUE7t5JrWK+j14Ojo/a9jO3odMTfP4TcvXu1D65q/s+7JiilOH73PRJzDSsvZvdre9RJPJLMCHEZSc9LZ/3p9cSdimPD6Q1k5GdY9+l1ejoEdqB3RG96hfeiuU9zPt75MV8f+Lrh1J/odAQ++ywnH3+87AOUQu/pwamRT9i0kpgyMsBkuvjHdXLSkhJvb+3L1we95bZ34XbLfh9v63E6V1frh1F5b/7h782stx9YgO3zXYf/eVdVqdeIxFwj6lvMkswI0YAppTicdpi1p7Tal+1nt9vMJuvt7E2PsB70btSbHuE98Hb2tjm/ocxMq4xG8o4cIWfnTnJ27kLn4oLKzS3z2Oy/NpV7HZ2Li21SUjz58CmRoPgUJSh6F5dL/hnq25t/Vblf2wOXtm3J3b0bl7Zt6+w/b3tIzLWjPsUsBcBCNDB5pjw2J262dh8lZCXY7G/h04LejXrTq1Ev2gW2w1HfsP5nUUpRcOoUOTt3krtrNzm7dpG7dy8qJ6fScz1vvBHX2LZaAuLtjaM1QfHBwdurWpKSS2FtnSl886/P3QjFZW3cSNKbUwmZ+BLu3bvXdThVIjHXjpqM2Z7Pb0lmhGgAzmSd0UYenVzL30l/k2Ms+mB30jtxdejV1gQmzCOsDiO1nzElRUtYLInLrl2Y0tJKHad3d8elbVtc28Xi3KYt5+bMIe/QoQZTY2DRED+whKgLMppJiAbOZDax+9xu4k7Gse70Ovaf32+zP8gtyJq8XB1ydYOZtt+UmUXunj3k7tpJzq7d5OzaiTEhsdRxOoMB55YtcY2NxSU2Ftd2sThFRmqFqYUc3N0bXJcNgHv37jT/dWldhyHEZUWSGSHqiQv5F9iYsJG1p9ay/vR6m+n/dehoF9iOXo160btRb6J9o+v9B7fKzyf3wEFydlm6i3aSf+Ro6VFIOh1OzZppiUu7WFxjY3GOial0aHV96q8XQtQtSWaEqCNKKY5nHLcW7/575l+blaA9DB70CO9Br0a9uDb8Wvxc/Ko9hupaM0iZzeQfP25T55K3bx+qjLlWHMNCcW2rtba4tI3FpW0bHDw87I5dp9MRNHYMSW9OJWjsmHqf3Akhao4kM0JUk6qsQP147OP8c+YfawJz4sIJm+OaejWld6Pe9I7oTYegDhj0NTer7sWuGaSUwnjmTGHisoucXbvJ3b0bc2Zm6fO9va3dRC5tY3GNbYtjYGC1/QzSZSOEAElmhKg25a1APfOfmczfM59m3s1YtHcRWQVZ1n2Oeke6BHehV6Ne9GrUi8ZejWst3qpOQGfOyiJ78xabOhfT2ZTSh7u44NK6tU13kSEiQlpMhBA1TpIZIapJ8cnmzuWcw8/Vj+8PfE9yjrbu0dH0owAEuAbQM7wnvRv15pqwa+psuYCqTEBXkHyGQ93KGHHj4IBzVJRtnUuLFugc5S1FCFH75J1HiGp0f8v7+ePEH3x94Gub7W3821iLd1v5t0Kvq/v1VpTRiEOAP47hYdqIojJaZ0yFq/UamjQuqnOJjcWlVSv0rq61HbIQQpRJkhkhqoFSil+P/crbW962GYXkoHNg5V0rCXSrvjqRi6GUouDECXJ27iJ3d2Gdy9695c6iC+B926143XQzrm3b4ODjU3vBCiGEnSSZEeISncg4wZRNU9iUqE2j7+vsS2peKga9gQJzAT8c+qHW1zcqOJNcmLTsInfnLnL27MGcnl7qOL2HB85t2pB/5IhWCKyUdQK60GnTpN5FCNEgSDIjxEUqMBUwf898Pt7xMfnmfJz0TnQM7sjfiX+XWoEaam7BRlN6Ojm7d2tDondryYsxObnUcTonJ5xbtcQ1th2usW1xiY3FqWlTdHo9mevWN8gJ6IQQAuo4mWnatCnx8fGlto8aNYrZs2ejlOL111/nk08+ITU1la5duzJ79mzatGlTB9EKUWTrma1M/muytaj3mtBraOHTgi/2fVGjK1Cbc3PJ3btPa3XZqU39n1/G3xB6Pc4tWuAS29Y6i65LVBS6ciaikwnohBAXJe0kZJ8DN3/wiaizMOo0mdmyZQsmk8l6f/fu3fTr14+7774bgBkzZjBz5kwWLFhAdHQ0b7zxBv369ePAgQN4enrWVdjiCpael857W9/jh0M/AODn4scLXV5gcORg5uyYU60rUCujkbzDh4smotu9m7yDB6HY34yFISKisLWlsNWldWv0blVf4kAmoBNC2C3tJHzYCYx54OgMT22ts4SmXi00OXr0aJYuXcqhQ4cACAsLY/To0bz44osA5OXlERwczPTp0xkxYkSVrikLTYrqUFaB751RdzKm0xi8nb2BS5tNt1SB7s5d5O7bV2aBrkNAQGFrS1tcY9vh0rYNjr6+1fBTCiGEHRK2wye9i+4Pj4OwDtV2+Qa50GR+fj5ffPEFY8eORafTcfToUZKSkujfv7/1GGdnZ3r37s3GjRvLTWby8vLIy8uz3s/IyKjx2MXlrWSBb3Pv5rza7VWuCr7Keoy9s+naU6Dr0rZtseQlFseQEGk5EULUndR4OHcYTv9juz3loPa9Drqc6k0ys2TJEtLS0njkkUcASEpKAiA4ONjmuODg4DLrbCymTZvG66+/XmNxiitHWQW+I9qP4NE2j2JwsF1moCqz6eocHDg1Zgx5u3aXW6Dr0qqVNv1/YZeRU9MmNitFCyFEjTKbISsZMk5D+mnISNBuZxTeTo2HCwllnKiDHwsHEdRBl1O9SWbmzZvHwIEDCQsLs9le8j9QpVSF/5VOmDCBsWPHWu9nZGQQEVF3RUmiYSpZ4NsttBsvX/NyucsNVGU2XeOZMxjPnNHu2xTotsMltm2FBbpCiCtATRfTVpaopJ/WEhWzsfJrlVLsnzhjnvZzXGnJTHx8PKtWreLHH3+0bgsprC1ISkoiNDTUuj05OblUa01xzs7OODs711yw4rJWVoHvuC7jGBQ5qMwk2nj+PDnbt5OzbRtZ//4LOl3ZLTMGA5433IBru4sr0BVCXOYutZi2OhMVnR48QsA7HLzCwCu88CsMHJzg+0fBlF90rDIXfQctfjd/+5+DS1Avkpn58+cTFBTE4MGDrdsiIyMJCQlh5cqVdOzYEdDqauLi4pg+fXpdhSouU1Up8FUmkza6aNs2crZtI3v7dgriT1R0WauIjz7Co+e1NRa/EKKByz6nJTJQumWjJhIVr7DCZKVYouLdSPvuEQIOFaQHT/+rxZdysKhrSZnhjk8hIPrKrJkxm83Mnz+fhx9+GMdii9TpdDpGjx7N1KlTiYqKIioqiqlTp+Lm5saQIUPqMGJxuSmvwLe9awtyNu/g7Lbt5GzfRs6OnZizskqd7xzVAtcOHXDt0BGXDu1JfHE8uXv3am9AhbPpyrwtQogyWbqWzh6w3f7b82DMhaxzWiJTW4lKVfhElJ2sBERX62gme9R5MrNq1SpOnDjB0KFDS+0bN24cOTk5jBo1yjpp3ooVK2SOGVEtbAp8TXk0STXwuL4XnQ96kPvZqxw8fKTUOXp3d1zbt8O1Q0dcO3bAtV07HLy9bY6xqZ2R2XSFEOVJOQQfdQNzQel9p7bY3q8oUfEK17ZVR6JiDzd/rUvJ0jVWy11LxdWreWZqgswzI8qy9dgGvvhxEp4HEog+rWid6IBrdun/fAxNGuNmSVw6dsS5RQt0Dg4VXlspxfG777HOptv0u28lmRFCaNJPw6HlcHA5HPkDTHmVnzPkO2jeF0qMoqwXarBouUHOMyNETVFKUXD6NDnbtpH2z2ZO/7UKr5NpDLdJ443onJ1xiW2LW8eOuHbsiGv79jj62/+fhsymK4SwMpshYRscXKZ9Je0s/9jyimmDWtXPRAbK73KqZZLMiHrpUmbTNeflkbtnr1aou10r1DWdTbHut8yVm+Xnhn+X7nh3uhrXjh1wiYmptqHR7t270/zXpdVyLSFEA5OXCUf/KExgVmg1L1Y6aNQFogdAzEBw9oTs8/WqmLYhkmRG1DsXM5uuZYRRzvbt5O7diyqw7YM2Oeg4Eqw4GK4jPSqUO24fT+fYfjX9owghrhSp8VrX0cFlcHxd0dBlACdPaHEdRA+EqH7gHmB7rk8Z81fVYTFtQyTJjKh3qjSbrsFAwovjydmxHWNCYqlDHAICcGnfjl2hBfxXv5mDQVo30sj2Ixnd5pFSM/gKIYRdzCatSPfgMi2JSd5ru9+3qZa8xNwIjbuDYyWtvvWomLYhkgJgUS9lrltf/my6Jen1OMfE4NaxgzZEumNHdhnOMHnTlCrP4CuEEJXKTYfDq7Xk5dAKyCnWFa5zgMbXQPSN2ldAlDaJpj1qegbgBkYKgEWD535tD5xbtSJv377SOx0ccOvRHffCQl2XtrE4eLgD2gy+U+2YwVcIISp07khR8W78Rtv5Xly8oUU/rfal+XXg5ndpj1VPimkbIklmRL2U8++/FFjWMSqh0ZyP8OzVy2ZbVWbwFUKISpkK4MSmou6jc4ds9wdEa8W70QMhomvtzusiyiW/BVGvKKORlLkfk/LRR9qQRicnMBptZtP16NnT5pzyZvC9KviquvgRhBD1gT1dNtnn4fAqLYE5vErrTrLQO0KTHlrrS1R/8G9es3GLiyLJjKg3ChISOD1uHDn/bAXA+9Zb8bjhBk4//bR2QInZdG1m8DXn46R3YmT7kTwiBb5CXNkqW7RRKW35AEvry8lNRfO6gJYARfXXal+a99W6k0S9JsmMqBcylq8g8ZVXMGdkoHd3J2TSa3jffDNKKVzatrXOpmtZ42jrma1M/muyFPgKIUora9FGjyCI31A0fDr1uO05QW20kUfRN0J4J9BXPNO3qF8kmRF1ypyTw5m3ppP2zTcAuLRrR/g7b/PZ+aXod8xlZPuRNrPpZuRnMHzFcPae14ZBSoGvEMLK0rWUctB2+9IxkLwPjDlF2xycILJX4eijAWXP9SIaDElmRJ3JPXCA0889R/7hI6DT4f/YYwQ+8zQ6gwF9qp7Z22cDMLL7SJot/YVfj/3K5O/7kVP4hiQFvkIIq/PHYXYX28nqLBL+Lbrd5g6IvQsie4OzR62FJ2qWJDOi1imlSF28mOTpM1D5+TgEBhA+fTru3btbjxnZfiQAs7fPJj0vncNph60Fvr7OvszqO0sKfIW4UikFafFweiuc2qp9T9hWdiJTUo9nZWbdy5AkM6JWGVNTSZz4Mplr1gDg0bs3odOm4uhXen6Gke1HcvLCSb7Y94V12zWh1/DR9R9Jga8QV5Ls83D6Xy1pOf2P9j27/OVONDpAlV60UWbWvSxJMiNqTdamTSSMexFjcjI6g4GgcePwfeA/5da6bD2zlRXHV1jvO+od+bT/p7UVrhCiLhTkQtKuoqTl9FY4f7T0cXoDhMRqxbqNOmvfHZwgJ1UWbbwCSTIjapwqKODsh7M598knoBROzZoRPvNdXFq2LPecPSl7eHL1k+SacgEw6A0UmAuYW1gULIS4DJjN2qR0p7fCqcLk5cxu21l2LfxbaAlLeCcI7wwhbbWWlpJ8m5TeJos2XvYkmRE1Kv/UKU4/9xy5O3YC4HP33QRPGI/eza3ccw6lHmLEqhFkFWQBMKLdCJ7q+BRzd8wtKgqWhEaIhicjsai1xVLnkpdR+jj3QC1hCe8E4VdBWEf7lgqQRRuvOJLMiBqTvvRXkiZNwpyZid7Li9DJk/G6cUCF58RnxPP4isdJz9Nm4BweO5ynOj4F2BYFF78vhKhhF7MAYt4FSNherLvoX8g4Xfo4gxuEdoBGnYpaXrwj7F+ksTifCG2iPFm08YohyYyoduasLJLeeJP0n34CwPWqqwh/ewaG8PAKz0vITOCxFY9xLvcc/i7+3N7idp6+6mmbYywJjLn4bJ1CiJpT2Wy6oK1nlLzXdnTR2f2Asj1Op4eg1lpri6W7KLBlzaxvJIs2XlEkmRHVKmfPHhLGPkd+fDzo9QSMHEnAqCfQOVb8UjubfZbHVzxOUlYSTb2asuDGBfi7lt00LC0yQtSiUrPppmg1LZbWltNbIXGH7YR0Ft6NiyUunbS6FSf3Wg1fXBkkmRHVQpnNnF+4iOSZM6GgAMeQEMLfnoFbly6Vnpuam8rwlcM5ceEE4R7hfNr/03ITGSFELbF0LZ3ZY7t9wU2Qn1n6eBfvYgW6nSDsKvAMrp1YxRVPkhlxyYwpKSSMn0DW+vUAePbrR+iUyTj4+FR67oX8C4xcNZLDaYcJcg3i0/6fEuIeUsMRCyHKpRQcWQOL7yl7VJE1kdFB+/uhWR8tefFrBnp9bUYqhJUkM+KSZK5bT8L48ZjOnUPn7EzwhAn43HtPldZJyi7I5snVT7L33F78XPz4dMCnRHhKH7cQtS4jEY7+CUf/0L5nnqnCSQq6jpAhz6JekGRGXBSVn0/ye7M4P38+AM7R0YS/+w7OUVFVOj/PlMezfzzLtuRteDp58nG/j2nm3awmQxZCWORnwfENWvJy5A84u892v6OLtjSApdDeMouuzKYr6ilJZoTd8o8f5/Rzz5O7R+tL9x0yhKBxL6B3canS+QXmAp6Pe55NiZtwdXRlzg1zaOlX/gR6QohLZDZB4nYtcTnyB5z8G8wFxQ7QaXO5NO8LzfpCxNWQmVy0ArXMpivqOUlmRJUppUhf8j+SpkxBZWfj4O1N6NQ38bz++ipfw2Q2MXHdRP48+SfODs7Mvn427QPb11zQQlypUo9ricvRP+BoHOSm2e73aawlLs37aitIl5yUrryhzTKbrqiHJJkRVWLKzCRp0utkLF0KgNvVVxP29gwMwVUfrWBWZiZvmszvx3/HUe/IzD4z6RJS+WgnIUQV5KTBsbVFXUepx2z3O3tDZM+i1he/ZlWbmE5m0xUNgCQzolI5O3Zw+rnnKTh1ChwcCHz6afwffwydg0OVr6GU4u0tb/PjoR/R6/RM7zmdXo161WDUQlzmTAVwakth19EaSPi3qJ4FQO8IjboUtr5cp3UjXczkdDKbrmgAJJkR5VImE+c+m8fZDz4AoxFDeDhh77yNW8eOdl/rw+0f8sW+LwCY3H0y/Zv2r+5whbi8KaXVr1i6jo6vLz3fS0B0UddR02vB2bN6Hltm0xX1nCQzokwFZ5JJePFFsjdtAsBr0CBCXp+Eg6f9b46f7fqMT3Z+AsDErhO5tcWt1RqrEA2KPescZZ61HTJdcm0jtwBtnpfmfbXv3o1qJmYh6jlJZkQpF9b8QeJLL2FKS0Pn5kbIyy/jffttVZo7pqTF+xbz/r/vAzC201jua3lfdYcrRMNR2TpHBTlw4q+i1pekXbbnOzhDk25FrS/BsTJRnRDUg2Tm9OnTvPjii/z+++/k5OQQHR3NvHnz6NSpE6DVWrz++ut88sknpKam0rVrV2bPnk2bNm3qOPLLjzkvj+S33yH1C607yLl1K8LffRfnyMiLut6Sw0uYtnkaACPajeDRto9WW6xCNEgl1znKSoGc80XJS/xfYMqzPScktih5adwNDK61H7cQ9VydJjOpqan06NGDvn378vvvvxMUFMSRI0fwKTYN/owZM5g5cyYLFiwgOjqaN954g379+nHgwAE8L6LLQ5Qt7/BhTj/3PHkHDgDg98gjBI4dg97J6aKut/z4cl7b+BoAD7Z+kCc7PFltsQrR4Fi6llIO2m5fWMY6R55hRSOOmvUBj8BaC1OIhkqnlFKVH1Yzxo8fz4YNG1i3bl2Z+5VShIWFMXr0aF588UUA8vLyCA4OZvr06YwYMaLSx8jIyMDb25v09HS8vLyqNf6GoiAxEeP582XvVJD110ZSZn+Eys3Fwd+fsLem4dGz50U/3tpTa3l2zbMYlZE7o+7ktW6vXVQXlRCXhZTD8NE1JSapK0Gnh17joO0dWhGv/L0IYdfnd522zPz8888MGDCAu+++m7i4OMLDwxk1ahSPP67NNnns2DGSkpLo379o5IuzszO9e/dm48aNZSYzeXl55OUVNdNmZGTU/A9Sj5nz8zl2192Yzp2r9Fj3Hj0Ie2sajoEX/5/g34l/M+aPMRiVkUGRg3jlmlckkRFXFsuoo8Or4chqOLau4kQGtCHVMQMhMKZ2YhTiMlOnyczRo0eZM2cOY8eO5aWXXmLz5s0888wzODs789BDD5GUlARAcImJ2YKDg4mPjy/zmtOmTeP111+v8dgbCp3BgCE0FNP589qbbDkCn38e/6GPoruEYsLtydt5es3T5JvzuS7iOt649g0c9FWfi0aIBisnDY7FFSYwayD9ZPnHyjpHQlS7Ok1mzGYznTt3ZurUqQB07NiRPXv2MGfOHB566CHrcSX/s1dKlfvf/oQJExg7dqz1fkZGBhERV+78CDqdjsBnn+VkYWtXWYInTsTvwQcu6XH2ndvHqFWjyDHm0D2sO2/3fhuD3nBJ1xSi3jKbIGG71vJyeLU2eZ0yFe13cIYm3aHF9dD8enD2gOzzss6REDWkTpOZ0NBQWrdubbOtVatW/PDDDwCEhIQAkJSURGhoqPWY5OTkUq01Fs7Ozjg7O9dQxA2T+7U9cGnblty9e8Fsttnn3Lo1vg/855KufyTtCCNWjuBCwQWuCrqKWX1n4eRwcYXDQtRbF5KKuo6O/KGNQiouIFpLXFpcD016gJOb7X6fxqWvKescCVEt6jSZ6dGjBwcKR89YHDx4kCZNmgAQGRlJSEgIK1eupGPhrLP5+fnExcUxffr0Wo+3oaqodSZozJhLqmk5mXGSx1c8TmpeKm382zD7+tm4OsrQUXEZMOZpc75Yuo7O7Lbd7+wFzXoXJTBlJSslyTpHQtSIOk1mxowZQ/fu3Zk6dSr33HMPmzdv5pNPPuGTT7TZYnU6HaNHj2bq1KlERUURFRXF1KlTcXNzY8iQIXUZeoPjfm0PHHx9MaWmahv0elxat8b92h4Xfc2krCQeW/EYZ3PO0sKnBXNvmIuHk0c1RSxELVMKzh0p6jo6vg4KsosdoNPWN2pxPbS4AcI727/WkaxzJESNqNNkpkuXLvz0009MmDCByZMnExkZyaxZs/jPf4q6PcaNG0dOTg6jRo2yTpq3YsUKmWPGTjqdDgcfn6Jkxmwm8NlnL7pVJiUnhcdXPE5CVgJNvJrwaf9P8XHxqb6AhagNuRnaStOWBCatxMACj+CilpdmfcG9GlpSZJ0jIapdnc4zUxtknhmNMpvZ36kz5OQA4NK2LU2/+/aikpn0vHSGLh/KwdSDhLqHsvDGhYR6hFZ+ohDVzZ51jkCrGUvaUdR1dPJvMBuL9js4QeNrChOYGyC4jcz5IkQdaTDzzIjaU3DqlJbIODri1LgxQWMvrlYmqyCLJ1Y9wcHUgwS4BvBZ/88kkRF1o7J1jiwyk7XExZLAZKfY7vdrXtR11PRacHKvnfiFENVGkpkrRG5hobVLTAyRP3x/UdfIMebw5Oon2ZWyCx9nHz7t9ymNvapQ9ChETSi5zlH2OS2ZMeZrLS6WrqOknbbnOXlCZK/CBOZ68G1a66ELIaqXJDNXiLz9WjLjHHNxM4zmm/IZ8+cYtp7ZiofBg4/7fUwL3xbVGaIQVVPeOkd/f6zVvCRsK1G4C4S211peml8PEVeDg8yBJMTlRJKZK0TeQUvLTLTd5xrNRsatHceG0xtwdXTloxs+orV/68pPFKK6Fe9aAkAHFJb97VhcdJyrH0T1LyrclcUahbisXVQyc/LkSY4fP052djaBgYG0adNGJqqr53IPaP/F2tsyY1ZmXtnwCqtPrMagN/B+3/fpGNSxJkIUonLFu5YAayJT0gM/Qri8ToW4UlQ5mYmPj2fu3Ll89dVXnDx5kuKDoJycnOjZsyfDhw/nzjvvRH8J6/uI6mfOyqLgxAnAvmRGKcWbm95k6dGlOOocmdlnJt3CutVUmEJULjUem9YYi5LrHLkH1HZkQog6VKWs49lnnyU2NpZDhw4xefJk9uzZQ3p6Ovn5+SQlJfHbb79x7bXX8sorr9CuXTu2bNlS03ELO+Qe1FplHIOCcPT1rdI5Sine/eddvj34LTp0TOs5jT4RfWowSiEqkH4Kvh8K3z0EKDB4QOw9Rfst6xwNjyt/VJMQ4rJVpZYZJycnjhw5QmBg6X7noKAgrrvuOq677jpee+01fvvtN+Lj4+nSpUu1BysuTt5FdDHN3TGXhXsXAvB699e5MfLGGolNiArlZ8PG/4P1s8CYA+ig08PQ92XIOA27vi06VtY5EuKKVaVk5u23367yBQcNGnTRwYiaYS3+bVm1ZGbhnoV8tOMjAMZfPZ7bo26vsdiEKJNSsOdHWPEqZJzStjXpATe+BaHttPvGXFnnSAgBXOJoppSUFP7++29MJhNdunSxWdla1B/W4t/oypOZbw98yzv/vAPAs1c9y39aXdqK2kLYLWE7LBuvLfII4B0B/adA69tsZ+OVdY6EEIUuOpn54YcfGDZsGNHR0RQUFHDgwAFmz57No48+Wp3xiUuklCLvgGWOmYqHZf9y5Bfe2PQGAI/FPsZjsY/VeHxCWGWehTWT4d//AgocXaHnWOj+NBjKWYld1jkSQmBHMpOZmYmHR9GKyK+//jqbN28mOlr7gPz11195/PHHJZmpZwpOJ2DOzERnMOAcGVnucaviV/HKhldQKIa0HMIzHZ+pxSjFFc2YD5s/gbjpkJehbYu9G26YBN6N6jQ0IUTDUOUx1J06deJ///uf9b6joyPJycnW+2fOnMHJyal6oxOXzFIv49SiBTpD2bOerj+9nhfWvoBJmbitxW28ePWLF72athB2ObgC5nSDFRO1RCa0AwxdDnd+JomMEKLKqtwys3z5ckaNGsWCBQuYPXs277//Pvfeey8mkwmj0Yher2fBggU1GKq4GJYuJpfosruYtiRtYfQfozGajdzY9EYmdZuEXifzBIkadvYgLJ8Ah1dp992D4IbXoP0QkHmqhBB2qnIy07RpU3777TcWL15M7969efbZZzl8+DCHDx/GZDLRsmVLXFxcajJWcRFyK1iTadfZXTy1+inyTHn0adSHqT2n4qB3qO0QxZUkJ03rTtr8CZiNoDdAt1HQ83lw8arr6IQQDZTd/wINGTKEzZs3s23bNvr06YPZbKZDhw6SyNRTlpaZVQbbRfkOnD/AyFUjyTZmE+4Rzjt93sGgl8X3RA0xm+Cfz+GDq2DTR1oiEzMInvwb+k2WREYIcUnsGs30+++/s3fvXtq3b8+8efP4888/GTJkCIMGDWLy5Mm4upYz4kDUCXNODvnx8QD834VfSN3RhJHtR3Is/RjDVw4nI18rthwcORhnB1lbS9SQ4+vh9/FwZpd2PyAGbpymLQIphBDVoMotM+PGjeORRx5hy5YtjBgxgilTptCnTx+2bduGs7MzHTp04Pfff6/JWIWd8g4dAqVwCAjgwR5PMXv7bGZsmcHjKx7nfO55QBuC/fRVT9dxpOKylBoP3z4MCwZriYyLNwycAU9skERGCFGtdKr4ipEVCAgIYPny5XTq1Inz589zzTXXcPBgUdfFnj17GDFiBOvXr6+xYC9GRkYG3t7epKen4+V1ZTVlp373HUmvvIp79+40/nwes7bOYt7uedb9w9oOY3Sn0XUXoLg85WfB+vdg4wfaLL06PXQeCn1eAneZpVcIUTX2fH5XuZvJzc2NY8eO0alTJ06ePFmqRqZNmzb1LpG50pVckynQrWhtLYPeIImMqF5Kwa7vYOVrcCFB29a0JwycDsFt6jY2IcRlrcrdTNOmTeOhhx4iLCyM3r17M2XKlJqMS1QD67DswjWZfjr0EwB6nZ4CcwFzd8yts9jEZeb0vzCvP/z4uJbI+DSGe/4LD/8iiYwQosZVuWXmP//5DzfeeCNHjx4lKioKHx+fGgxLXCqlFLkHioZlz90xlwOp2v3/6/t/7Du/j9nbZwMwsv3IOotTNHAXzsDqybD9C+2+wR16PQfXPAkGGeEohKgddo1m8vf3x99f+rwbAmNSEuaMDHB0ZGHmKmbv+RgdOhSK1v6t6R3RG0ASGnFxjHmwaQ6sfRvyM7Vt7e7TJr7zCqvb2IQQV5wqdTONHDmSkydPVumC33zzDV9++eUlBSUunbVVJjISk6OeO6LuQKEIdA201s6MbD+SJzs8iVmZ6zJU0ZAoBft/hdldYdVrWiIT3gmGrYI7PpZERghRJ6rUMhMYGEjbtm3p3r07t9xyC507dyYsLAwXFxdSU1PZu3cv69ev5+uvvyY8PJxPPvmkpuMWlbAW/7ZsyagOo/hyn5ZgtvZvbXOctMiIKkveB8vGw9E/tfseIdpikO3ulSUIhBB1qkrJzJQpU3j66aeZN28ec+fOZffu3Tb7PT09ueGGG/jss8/o379/jQQq7JN3YD8ALjHamkx7z+0FSiczQlilnYTsc+DmDz4RRduzz8Of02DLPFAmcHCCbk9Bz7Hg7Fl38QohRKEq18wEBQUxYcIEJkyYQFpaGvHx8eTk5BAQEEDz5s1lleV6JrfEsGxJZkSF0k7Ch520WhhHZ3hqK3iGwtb58MebkJOqHdfyJuj/BvhF1m28QghRjF0FwBY+Pj4ymqkeM+flkX/sGADO0THkGHM4mn4UkGRGlCP7nJbIgPb90ArY8hkka0kwQa21JQia9amzEIUQojwXlcyI+i3v8GEwm3Hw9cUxKJA9Z3dgVmYCXAMIcguq6/BEfWLpWkqxXYiUX8dq35294fpXoNOj4CBvF0KI+knenS5DefuL5pfR6XTSxSTKVrxrCQAdUGJ1E2MuRN8oiYwQol6TIQiXobyDhTP/SvGvqEjxriWgVCIDYMrTjhNCiHqsTpOZSZMmodPpbL5CQkKs+5VSTJo0ibCwMFxdXenTpw979uypw4gbBmvxb3Rh8e95LZlp5deqzmIS9ZCDo7YIZEnFtzk6a6ObhBCiHruoZMZoNLJq1So+/vhjLly4AEBCQgKZmZl2X6tNmzYkJiZav3bt2mXdN2PGDGbOnMmHH37Ili1bCAkJoV+/ftbHFKUppcjbrw3Ldm4ZQ64xl6NpUvwrilEK9vwEi24Hy4SJkb2L7TfDHZ/C8DhtVFPxYdpCCFEP2d0RHh8fz4033siJEyfIy8ujX79+eHp6MmPGDHJzc5k7177FCx0dHW1aYyyUUsyaNYuJEydyxx13ALBw4UKCg4NZvHgxI0aMsDf0K4Ix+SymtDTQ63Fu0YJdqfsxKRN+Ln4EuwXXdXiirqWfht+ehwO/afcDouHm/wODK3xSLKEJiIawDnUSohBC2Mvulplnn32Wzp07k5qaiqurq3X77bffzurVq+0O4NChQ4SFhREZGcl9993H0aNaK8KxY8dISkqymYTP2dmZ3r17s3HjxnKvl5eXR0ZGhs3XlcRSL+MUGYne2dmmXkbmArqCmc2w+VNtGYIDv4HeAL1fhJHroUk3rSvJ0Vk7VrqWhBANjN0tM+vXr2fDhg04OTnZbG/SpAmnT5+261pdu3Zl0aJFREdHc+bMGd544w26d+/Onj17SEpKAiA42LY1ITg4mPj4+HKvOW3aNF5//XW74ric5B2wFP/KZHmi0NkD8PMzcHKTdr9RF601JrjYa8InQutSKmsGYCGEqOfsTmbMZjMmk6nU9lOnTuHpad/U5gMHDrTejo2NpVu3bjRv3pyFCxdyzTXXAJRqTVBKVdjCMGHCBMaOHWu9n5GRQUTElfPGLDP/CitjPqx/D9a9A6Z8cPKA61+DLsNA71D6eJ8ISWKEEA2S3d1M/fr1Y9asWdb7Op2OzMxMXnvtNQYNGnRJwbi7uxMbG8uhQ4esdTSWFhqL5OTkUq01xTk7O+Pl5WXzdSWxFv/GRJNrzOVI2hEA2vi3qcuwRG07uRk+7gV/TtUSmaj+MGoTdB1ediIjhBANmN3JzHvvvUdcXBytW7cmNzeXIUOG0LRpU06fPs306dMvKZi8vDz27dtHaGgokZGRhISEsHLlSuv+/Px84uLi6N69+yU9zuXKnJ9PXuEyBi4xMRxMPSjFv1eavAvw2ziY1x/O7gO3ALhzHgz5VlpdhBCXLbu7mcLCwti+fTtfffUV//77L2azmWHDhvGf//zHpiC4Kp5//nluvvlmGjduTHJyMm+88QYZGRk8/PDD6HQ6Ro8ezdSpU4mKiiIqKoqpU6fi5ubGkCFD7A37ipB/9CgYjei9vXEMCWHvgTgAWvm3kuLfK8HB5bB0LGSc0u63HwID3gQ3v7qNSwghathFzVHu6urK0KFDGTp06CU9+KlTp7j//vtJSUkhMDCQa665hk2bNtGkSRMAxo0bR05ODqNGjSI1NZWuXbuyYsUKu2tzrhS5hV1MLtHRtssY+Em9TG07ue886745SM97o4loVcPJROZZWPYi7P5Bu+/TBG6eBc2vs+sytRpzNZGYa4fEXDsk5otndzLz888/l7ldp9Ph4uJCixYtiIyMrNK1vv766wr363Q6Jk2axKRJk+wN84qUV07xb0Ovl6kvfyxVpZRi05IjpCZls2nJERq19K2ZljGlYMdXsPwlyEnVZu7t9iT0mQBO7vUz5mokMdcOibl2SMyXxu5k5rbbbkOn06GU7Toulm06nY5rr72WJUuW4OvrW22BispZhmU7x0STZ8qzFv825JFM9emPpapO7j1Pcrw2S3Vy/AVO7j1P4zbVPG/L+WOwdDQc/VO7HxILt3wAYR0v6nK1EnM1k5hrh8RcOyTmS6NTJbOSSqxevZqJEyfy5ptvcvXVVwOwefNmXn75ZV555RW8vb0ZMWIEXbt2Zd68eTUStD0yMjLw9vYmPT39sh/ZdPDanphSUmj63bccDoEhvw3B19mXuHvj6n0CUJ4Te87xywc7rPdvfrp9uX8sSimUWWEyKkxGMyajGbOp2O3C7WaTGVOBwmSy3V7yeJNRYbbcLtxuLr7dZpu23VhgIuNsDiZj0Z+V3kGHq5ehen4HCsi/ALnpWsuMTgcu3uDkqS16fTGXVIqcjALMphqKuQZIzLVDYq4dl0XMOghq7Mld4ztXW8z2fH7b3TLz7LPP8sknn9iMKLr++utxcXFh+PDh7Nmzh1mzZl1yPY2wjzElBVNKCuh0OLdowd54rTuwIc/8m3Mhnz8XH7DZ9tvcXXj6ORcmHaowMSlKLMpa+LmumU2KrNT8aryiExBYdDcLyMor7+CLUv0x1zyJuXZIzLWjwcWs6rZ1xu5k5siRI2VmSF5eXtalCKKiokhJSbn06ESV5RZ2MTk1aYLe1ZV95/cBDa+LKedCPke3n+XIv8mc3J9aKjkxFZhJO5NT5es5OOpxcNShd9Rbbzs46tE7FLtts6349sLbDkXHWL70DjocDHocHIqurXfQseH7Q6Qn51C8vVOnA58QN65/+CJHlRnzYOsC2PEtYNImv7tmFMQM1C5+CZRSrF64j7Sk7OqNuQZJzLVDYq4dl1vMf/98lIjWfrUes93JTKdOnXjhhRdYtGgRgYHaf4dnz55l3LhxdOnSBdDWW2rUqFH1RioqVF7xb0NIZrIzihKY0wfTUOYKmld04BPkynUPtcLR4KAlGQ56HAyFCYYlsXDUodfravUP6sSec2UmWkpBamI2eVlG+/9jORoHS5+F1GNgANrcDjdOB8/qmTfoxJ5zpCZmV2/MNUxirh0Sc+243GKuq9YZu5OZefPmceutt9KoUSMiIiLQ6XScOHGCZs2a8b///Q+AzMxMXnnllWoPVpTPuiZTyxjyTfkcSjsE1N9kJis9j2Pbz3L432QSDqbZZPeBjT3xD3dn/19JpU9UkHYmh4JcE6HNfWot3soopfj756Na3UpZuZi9/7Fkn4eVr8C2L7T7nmEw+F1oeWmzbNdozLVAYq4dEnPtkJirj93JTExMDPv27WP58uUcPHgQpRQtW7akX79+6PXahMK33XZbdccpKpFrHckUw6HUQxjNRnycfQh1D63jyIpkpedxdNtZDm9NJuFwms0fQlATT5pfFUTzqwLxCnDl+7f+qXd/LBUxGxUXzueWX7OjIDM1D7NR4WCoIGalYM9P8Ps4yDqrbevymLamkkv1FrBXW8y1SGKuHRJz7ZCYq4/do5kamithNJMqKGD/VZ2goIDmq1axJGsDUzZNoXtYdz7u93GdxpaZmsfR7ckc3ppM4pF02wSmqRfNrwqkxVVBeAUUzR5tKjCz8KUN5FwoKPe6bl5OPPRmdxwMdq/IUWMunM8lN7P8mF09DXj4upR/gfTT8OtzcPB37X5ADNzyf9D4mmqOtMglx1wHJObaITHXDom5fDU6mgkgKyuLuLg4Tpw4QX6+bbX1M888czGXFJcg79gxKChA7+GBITyMvX9p9TKt/FrVSTyZqbkc+VergUk8km6zLzjSq6gFxr/s5S8cDHruntCl0j+W+pTIAHj6ueDpdxF/wGYz/DMPVr2uDbvWG6Dnc9BzLDg6V3+gxVx0zHVIYq4dEnPtkJirh93JzLZt2xg0aBDZ2dlkZWXh5+dHSkoKbm5uBAUFSTJTB4oX/9osY1CL9TIXzudy5N9kjvybTNLRDJt9Ic28aX5VIM2vCqryH0B9/GOpEcn74Zdn4OTf2v1GV2utMUF1k4gKIURDZHcyM2bMGG6++WbmzJmDj48PmzZtwmAw8MADD/Dss8/WRIyiEnkHCtdkiomu1eLfjJQcjmzTWmDOHCuWwOggtLk3zTtqLTD1rYm0XjDmwfr3YN27YMrXhlvfMAk6DwN9/WpxEkKI+s7uZGb79u18/PHHODg44ODgQF5eHs2aNWPGjBk8/PDD3HHHHTURp6hArqVlJjqGQ2la8a+XkxfhHuHV/lgZKTkc/jeZI1uTrdNYA6CDsBY+WgtMxyDcfWq2e6RBO7kZfn4azmpJKNE3aiOVvGU6AyGEuBh2JzMGQ9H0ysHBwZw4cYJWrVrh7e3NiRMnqj1AUbniazIV72KqrpE+6WezOfKvNgrp7ImiBEang7AoH5pfFUSzjoG4e0sCY5V2ErLPgZs/+ERo2/IuwOrJsPlTQIF7IAycDm3uuOTJ74QQ4kpmdzLTsWNH/vnnH6Kjo+nbty+vvvoqKSkp/Pe//yU2NrYmYhQVMKamYkxOBsAlOpq9O4uWMbgUaWeyObJNG4WUcjLTul2ng7BoX1pcFUizjkG4eTld0uNcltJOwoedtK4kR2d4aiuc2QO/joWM09oxHR6A/lPArf6vAi6EEPWd3cnM1KlTuXBB++98ypQpPPzwwzzxxBO0aNGC+fPnV3uAomKWVhlD48bo3d0rLf49ue886745SM97o4loZftBmpqUpbXA/JvMuVPFEhi9jvDowhaYDoGSwFQm+5yWyID2/een4egf2n3fpnDTLGjet66iE0KIy45dyYxSisDAQNq0aQNAYGAgv/32W40EJqrGOvNvTDQFpgIOpZZf/KuUYtOSI6QmZbNpyREatfQlNSnbOgrp3Oks67E6vY5GLX1p3jGQZh0CcfWUBKZSlq6llIO224/+Aeig0yMwYCo4udVFdEIIcdmyO5mJiopiz549REVF1VRMwg4li38LzAV4OXnRyKN0MenJveetRbvJ8RdYNHEjmeeLVlvW63U0auWrtcC0D8TFw1A7P8TloHjXUpkU7FiszR8jyYwQQlQru5IZvV5PVFQU586dk2Smnsjbr42IcW4ZY+1iauVfepVVpRQbfzxssy3zfB46PTRu7U/zqwKJbB+Ii7skMBeleNdSeYx52nGWgmAhhBDVwu4JLWbMmMELL7zA7t27ayIeYQdlNJJ3WEtQXGJiKqyXObn3vE03kkX/YW256an2tOoeJonMxTr9L6x8tex9umJ/Yo7O2ugmIYQQ1cruAuAHHniA7Oxs2rdvj5OTE66utlPSnz9/vtqCExXLj49H5eejc3PD0KgRe3eWncxYVzktQaeDbSviaX5VYL1ZsLFBSdgGf04vWksJHUQNgMhrYcXL2iZlhjs+hYBo22HaQgghqo3dycysWbNqIAxxMazFv1FRGJWJg6la/UwbvzY2xxWvlSlOKa125uTe8zRuIy0GVZa4A/58Cw4UFr/r9BB7D/QeB/7NIWG77fEB0RDWobajFEKIK4bdyczDDz9cE3GIi5C7v3CyvJYtOZx2mAJzAZ5OnjTyLCr+La9VxkoHf/98lIjWftI6U5nEnRA3HfYv1e7r9BB7N/R6AQKK1ZC5+WtdSpZ5ZqRrSQghatRFrZp95MgR5s+fz5EjR3j//fcJCgpi2bJlREREWIdti5pXfObffef3AdDaz3bmX7NRceF8bvkXUZCZmofZqHAwSDJTpqRdWkuMJYlBV5TEBEaXPt4nQpsor+QMwEIIIWqE3clMXFwcAwcOpEePHqxdu5Y333yToKAgdu7cyWeffcb3339fE3GKMuQe1LqVtOJfrW6jZL2Mg0HP3RO6sPLzvSQeTqPddY1oeU2ozTGungYcDLK4YSlJuyHuLdj3S+EGHbS9E3q/WHYSU5xPhCQxQghRS+xOZsaPH88bb7zB2LFj8fT0tG7v27cv77//frUGJ8pnSk/HmJgIgHN0NHvXvguUPZLJw8eZ8wnajL7RV4cQ2Niz1DGimDN7tO6kvf8r3KCDtndAr3EQ1LJOQxNCCFGa3cnMrl27WLx4cantgYGBnDt3rlqCEpXLtSxjEB6O2d2FA+e1+2UlM+cSssjLNuLo7EBghEetxtmgnNlbmMQsKdyggza3a4W9Qa3qMjIhhBAVsDuZ8fHxITExkcjISJvt27ZtIzw8vNoCExXLs8z8GxPD0bSj5Jvz8TB42BT/WiQcSgMgtLk3egfpTioleb/WnbRnCaC0ba1v07qTgi9twU4hhBA1z+5kZsiQIbz44ot899136HQ6zGYzGzZs4Pnnn+ehhx6qiRhFGfIOFhX//lNs5l+9rnSyYklmwqJ8aiu8hiF5P6ydAbt/pCiJubUwiZFCdiGEaCjsTmbefPNNHnnkEcLDw1FK0bp1a0wmE0OGDOHll1+uiRhFGSxrMrnEtGTPuS2ANpKpJKUUCYfTAElmrM4egLgZsPsHrElMq1u0JCakbZ2GJoQQwn52JzMGg4Evv/ySyZMns23bNsxmMx07dpS1mmqRMpnIO2jpZopm395FQNn1MmlnssnJyMfBUU9wE69ajbPeSTmk1cTs+h5rEtPyJugzHkJi6zQ0IYQQF++ihmb37t2b5s2b07x585qISVQi/8QJVG4uOhcX9I3COLCh/OJfSxdTcKTXlTv8OuWw1p206ztteQHQkpjeL0Jou7qNTQghxCWz+9OtX79+NG7cmPHjx1frYpPTpk1Dp9MxevRo6zalFJMmTSIsLAxXV1f69OnDnj17qu0xGypr8W9UFEcvHCfPlIe7wZ3GXo1LHXtFdzGdOwI/joDZXWDnN1oiEzMYRqyF+76UREYIIS4TdiczCQkJjBs3jnXr1tGuXTvatWvHjBkzOHXq1EUHsWXLFj755BPatbP9cJkxYwYzZ87kww8/ZMuWLYSEhNCvXz8uXCi9ztCVxFL869KyaKXsVn5S/Gt17gj8NBI+7Aw7v9aSmOiBMDwO7l8Moe3rOkIhhBDVyO5kJiAggKeeeooNGzZw5MgR7r33XhYtWkTTpk257rrr7A4gMzOT//znP3z66af4+vpatyulmDVrFhMnTuSOO+6gbdu2LFy4kOzs7DLnubmSWNdkii5KZsrqYso4l0Pm+Tz0eh0hzbxrNcY6cf4oLBkFH3aBHV8VJjE3wvA/YcjXstijEEJcpi6piCIyMpLx48fz1ltvERsbS1xcnN3XePLJJxk8eDA33HCDzfZjx46RlJRE//79rducnZ3p3bs3GzduLPd6eXl5ZGRk2HxdboqvybT3fPnJTGJhq0xgE08Mzg61Fl+tO38MljwJH3SG7V+CMkHUAHh8DQz5BsI61nWEQgghatBFLTQJsGHDBr788ku+//57cnNzueWWW5g6dapd1/j666/5999/2bJlS6l9SUlJAAQHB9tsDw4OJj4+vtxrTps2jddff92uOBoS04ULFJw+DYBjVHMOFo5qqqj4t8F3MaWdLHvRxtTjsPZt2P6VlsAAtOgHfSZAo051EqoQQojaZ3cy89JLL/HVV1+RkJDADTfcwKxZs7jttttwc3Oz6zonT57k2WefZcWKFbi4uJR7XPEVoEHrfiq5rbgJEyYwduxY6/2MjAwiIi6fBf/yDh0CwDE0lHjOkWvKxd3gThOvJqWOPX05JDNpJ+HDTmDMA0dnbTVqZYZ178D2xWA2ase1uKEwielct/EKIYSodXYnM3/++SfPP/889957LwEBARf9wFu3biU5OZlOnYr+gzaZTKxdu5YPP/yQA4VdKUlJSYSGFq3ynJycXKq1pjhnZ2ecnZ0vOq76Lnf/fgBcoqPZWlgv09KvZani36z0PNKTc0CnLWPQYGWf0xIZ0L4vGw8HlxUlMc2v1+aJibi67mIUQghRp+xOZiqqV7HH9ddfz65du2y2Pfroo7Rs2ZIXX3yRZs2aERISwsqVK+nYUat5yM/PJy4ujunTp1dLDA1R8TWZKir+tXQxBTTywNnNUGvxVRtL11LKQdvt+5dq3xt3gxteh8Zdaz82IYQQ9cpF1cwcOXKEWbNmsW/fPnQ6Ha1ateLZZ5+1axI9T09P2ra1nTre3d0df39/6/bRo0czdepUoqKiiIqKYurUqbi5uTFkyJCLCfuyYFP8e+4roOLi37AWPrUVWvUp3rVUnoR/wSus9mISQghRb9mdzCxfvpxbbrmFDh060KNHD5RSbNy4kTZt2vDLL7/Qr1+/agtu3Lhx5OTkMGrUKFJTU+natSsrVqzA09Oz2h6jIVFmM7mFBb+G6CgO/F3BzL+WyfKifWorvOpTvGupPMY87Tify6ceSgghxMWxO5kZP348Y8aM4a233iq1/cUXX7ykZObPP/+0ua/T6Zg0aRKTJk266GteTgpOnUJlZ6NzcuK0jyLXlIuboxtNvZraHJebVcC501lAA22ZyU0HdFjXT7Lc1umLliNwdNZGNwkhhLji2T3PzL59+xg2bFip7UOHDmXv3r3VEpQoW66li6lFC/ZlaLfLKv611Mv4hrjh6ulUqzFesl3fw1f3Awpc/aHXC1iTGmWGOz7VZvJ9aqu0ygghhAAuIpkJDAxk+/btpbZv376doKCg6ohJlKPKxb8NcT0mYx78+jz8MAwKsqBpTxj1l7YgZHEB0dpMvpLICCGEKGR3N9Pjjz/O8OHDOXr0KN27d0en07F+/XqmT5/Oc889VxMxikJ5BwqHZbeMYe+51UAlxb8NJZlJOwHfPQKnt2r3ez4HfV4CB0cw5WtdSpZ5ZqRrSQghRAl2JzOvvPIKnp6evPvuu0yYMAGAsLAwJk2axDPPPFPtAYoiuYUtM4aoKPYfmw2UTmbyc42cPaEtxNkgkplDq+DHxyAnFVx84I5PIHpA0X6fCK1LqawZgIUQQgguIpnR6XSMGTOGMWPGWFevvlJHF9Umc1YWBSdOAHAm1IWcQzm4OrqWKv5NOpKOUuAV4IKHb/kzK9c5swn+fEtbjgAFoR3gnkXgW3omY3wiJIkRQghRrirXzOTk5PDzzz9bExjQkhhPT08yMjL4+eefycurZDituGjWZQwCA9ln1tZmaunXEge97QKSDWI9pqwU+OIOWDsDUNB5KAxdXnYiI4QQQlSiysnMJ598wvvvv19mK4yXlxf/93//x2effVatwYkiufsLRzK1bFmlmX/rbTJz4m+Y2xOO/gkGN7j9E7jpPTDU41YkIYQQ9VqVk5kvv/yS0aNHl7t/9OjRLFy4sDpiEmXIO6glMy4x0eUmM8Z8E2eOZwD1MJlRCv6aDQsGwYUE8I+Cx9dA+3vrOjIhhBANXJVrZg4dOkT79u3L3d+uXTsOFXaFiOpXvPh33/lvAWjtZ5vMnDmWgdmkcPd2wivAtdZjLFduBvzvSdj3s3a/zR1wy/+Bs9RaCSGEuHRVbpkxGo2cPXu23P1nz57FaDRWS1DCllLKuibTuUae5Bi14t9I70ib44rPL6PT6Wo7zLIl7YZP+miJjN4AA9+Guz6XREYIIUS1qXIy06ZNG1atWlXu/pUrV9KmTZtqCUrYKjidgDkzEwwG9nlo3UgxvjH1v/h3+2L47AY4fwS8GsGjv0PX4VBfEi0hhBCXhSonM0OHDmXKlCksXbq01L5ffvmFN954g6FDh1ZrcEJjqZdxbt6cvellLy5pMppJOpIOQFiUb+0GWFJBLvz8NCx5Aow50Px6GLEWIrrUbVxCCCEuS1WumRk+fDhr167llltuoWXLlsTExKDT6di3bx8HDx7knnvuYfjw4TUZ6xXL0sVUUfHv2RMXMBaYcfEw4BvqVusxWp0/Ct8+DEk7AR30fQl6Pg96u1fOEEIIIarErk+YL774gq+//pro6GgOHjzI/v37iYmJ4auvvuKrr76qqRiveJbiX6eYGPaf15Y0KJnMWLuYWtRhvcz+X+HjPloi4+YPD/4IvcdJIiOEEKJG2T0D8D333MM999xTE7GIcuTt1xKYtEbeZCdm4+LgUrr4ty7rZUxGWP06bPw/7X6jq+HuBeAdXvuxCCGEuOLYncyI2mXOySE/Ph6AQ/75kAgxfjE46ot+dWazIrGuVsq+kATfPQonNmr3rxkFN7wOjk61G4cQQogrliQz9Vze4cOgFA7+/uwynwRKdzGdO5VJfq4JJxcH/Bt51F5wx9bB90MhKxmcPOHWD6HNbbX3+EIIIQSSzNR7uYVdTC4xMew7tw8ov14mtIUPen0t1MuYzbBhFqyZAsoMQW20RSIDWtT8YwshhBAlSDJTz+VZi3+j2Xf+J6CMZKY2u5hyUuGnkXBwmXa//f0weCY41eEIKiGEEFe0i05mDh8+zJEjR+jVqxeurq4operPrLOXEcuw7MzG/mTlZ+Hi4EIz72bW/Uqp2iv+TdgG3z4EaSfAwRkGzYCrHpZJ8IQQQtQpu8fMnjt3jhtuuIHo6GgGDRpEYmIiAI899hjPPfdctQd4JVNKkXtQa5k5HqAAiPaLtin+TU3MJjezAEeDnsDGNbREgFLwz+cwr7+WyPg0gWEroNMjksgIIYSoc3YnM2PGjMHR0ZETJ07g5lbUtXDvvfeybNmyag3uSmdMSsKcng6Ojux0Pw+UXlzS0sUU3MwbB8camM8lP0vrVlo6Bkz5EDMIRsRBWIfqfywhhBDiItjdzbRixQqWL19Oo0aNbLZHRUURXziEWFSP3MIuJufISHZfKHsZgxrtYko5BN88CGf3gc4Brn8VejwrrTFCCCHqFbuTmaysLJsWGYuUlBScnZ2rJSihsSn+PbcBsE1marReZveP2vpK+ZngEaytdN302up9DCGEEKIa2N0v0atXLxYtWmS9r9PpMJvNvP322/Tt27dag7vSWYp/c5sEk1mQiZPeiWY+RcW/GSm5ZKXloXfQERLpVT0PasyH31+E7x/VEpkm18KIdZLICCGEqLfsbpl5++236dOnD//88w/5+fmMGzeOPXv2cP78eTZs2FATMV6xLN1Mp0IcIFub+degN1j3JxxKBSC4qReOTg6X/oDpp+C7R+DUFu3+tWOg78vgICP4hRBC1F92f0q1bt2anTt3MmfOHBwcHMjKyuKOO+7gySefJDQ0tCZivCKZ8/LIP3YMgN0+mZBdwWR51dHFdHgV/PA45JwHF2+4/WOIGXjp1xVCCCFq2EX9yx0SEsLrr79e3bGIYvIOHwazGQcfH7aZjgM1VPxrNkHcDIibDigIbQ93LwS/yEpPFUIIIeoDu2tmIiMjeeWVVzhQ2AUiaoal+Nc5JoZ957UlDYonM5mpuWSk5KLTQWgz76pfOO0kJGzXvmelwJd3QdxbgIJOj8LQFZLICCGEaFDsbpl5+umn+eqrr3jzzTfp2LEjDz74IPfee690MVWzvANaApMfGcaFgq046Z1o7tPcut8yv0xAhCdOrlX8NaadhA87gTEPHAzg6geZZ8DRFW6eBe3vq+afQgghhKh5drfMjB07li1btrB//35uuukm5syZQ+PGjenfv7/NKCdxaXILW2aSQrXh7tG+0SWKf9MBCIv2qfpFs89piQyAqUBLZPxbwOOrJZERQgjRYF30lLHR0dG8/vrrHDhwgHXr1nH27FkeffRRu64xZ84c2rVrh5eXF15eXnTr1o3ff//dul8pxaRJkwgLC8PV1ZU+ffqwZ8+eiw25wVBKkVe4WvYBv1yggnqZFj6VX9DStXSmxHMX3glu/j9wrqZh3UIIIUQduKQxt5s3b2bx4sV88803pKenc9ddd9l1fqNGjXjrrbdo0aIFAAsXLuTWW29l27ZttGnThhkzZjBz5kwWLFhAdHQ0b7zxBv369ePAgQN4etbQOkT1gPHsWUxpaaDX849LUqmRTDkX8klNzAKqkMwU71qyoYPTW2HBIHB0hqe2gk9Etf4cQgghRG2wu2Xm4MGDvPbaa0RFRdGjRw/27t3LW2+9xZkzZ/jmm2/sutbNN9/MoEGDiI6OJjo6mjfffBMPDw82bdqEUopZs2YxceJE7rjjDtq2bcvChQvJzs5m8eLF9obdoFgmy3OKbMrOzNLLGFjqZfzC3HHxMJQ630bxriUbquimMU87TgghhGiA7G6ZadmyJZ07d+bJJ5/kvvvuIyQkpFoCMZlMfPfdd2RlZdGtWzeOHTtGUlIS/fv3tx7j7OxM79692bhxIyNGjKiWx62PLMmMuVkEF/JPYNAbaOHTwrrfriHZbv5ay0vJhEanB2XWbjs6a8cJIYQQDZDdycz+/fuJjo6utgB27dpFt27dyM3NxcPDg59++onWrVuzceNGAIKDg22ODw4OrnBBy7y8PPLyij64MzIyqi3W2mIp/k0J9wAKi38dihf/pgFVTGZ8IrQupA3vwZZ5RduVGe74FAKitURGupiEEEI0UHYnM9WZyADExMSwfft20tLS+OGHH3j44YeJi4uz7teVWKFZKVVqW3HTpk1r8BP6WYp/jwSYANsuprwcIymnMgE7JsvziYDjG0tvD4iGsA6XEqoQQghR56pUM+Pn50dKSgoAvr6++Pn5lftlLycnJ1q0aEHnzp2ZNm0a7du35/3337d2XyUlJdkcn5ycXKq1prgJEyaQnp5u/Tp58qTdMdUlc34+eYXLGGz11OpYiicziYfTQIF3kCvu3lVcpfzMHji7D/QGcCg8R7qWhBBCXCaq1DLz3nvvWUcPzZo1qybj0YYl5+URGRlJSEgIK1eupGPHjgDk5+cTFxfH9OnTyz3f2dkZZ+cqfsjXQ/lHj4LRiN7Li82mw0CJ4t+LWcJg1/fa96j+MHC6VuwrXUtCCCEuE1VKZh5++OEyb1+ql156iYEDBxIREcGFCxf4+uuv+fPPP1m2bBk6nY7Ro0czdepUoqKiiIqKYurUqbi5uTFkyJBqi6G+sRT/6po3IaNgHwa9gSifKOt+u5MZpWB3YTITe6eWwEgSI4QQ4jJyUfPMmM1mDh8+THJyMmaz2WZfr169qnydM2fO8OCDD5KYmIi3tzft2rVj2bJl9OvXD4Bx48aRk5PDqFGjSE1NpWvXrqxYseKynmMmd7+WzKRF+AIQ5RtlLf4tyDNxNv4CUMXJ8gBObYG0E2Bwh2hZBVsIIcTlx+5kZtOmTQwZMoT4+HiUUjb7dDodJpOpyteaN29ehft1Oh2TJk1i0qRJ9obZYFlaZuKDtPut/FpZ9yUdS8dsVnj4OuPp71K1C1q6mFoOBie36gxVCCEaLJPJREFBQV2HcUUzGAw4ODhUy7XsTmZGjhxJ586d+fXXXwkNDa1wZJGwX+5BbVj2Tm9tSHl59TJVet5NRtjzk3Y71r7ZmYUQ4nKklCIpKYm0tLS6DkUAPj4+hISEXHIuYXcyc+jQIb7//nvrEgSi+hhTUjClpIBOxwbnE6CgjX8b6/5Ee+tljq+DrGRw9YVmfas/YCGEaGAsiUxQUBBubm7yD3kdUUqRnZ1NcnIyAKGhoZd0PbuTma5du3L48GFJZmpAbmEXkz4inLMqCUe9I1G+WvGvqcBM0jGttabKyYyli6n1reDoVN3hCiFEg2IymayJjL+/TE1R11xdXQFtypWgoKBL6nKqUjKzc+dO6+2nn36a5557jqSkJGJjYzEYbNcGateu3UUHc6XLK5z5N7NJAJBElE8UTg5aEnImPgNTgRlXTwM+wVWofTHmwb5ftNuxd9dQxEII0XBYamTc3KR+sL6w/C4KCgpqPpnp0KEDOp3OpuB36NCh1tuWffYWAAtbluLfhGAtQbykeplDKyEvHTzDoHH3ao9VCCEaKulaqj+q63dRpWTmWOGMtKJmWYp/9/pmASVm/rW3XsYyt0zbO0Bv9+LoQgghRINRpWSmSZMmNR3HFU8VFJB/WJvx9y+3RKAomTGbzCQeSQeqmMzkXYADy7Tbbe+s9liFEOJy1KdPHzp06FDjM91XxaRJk1iyZAnbt2+v61AaBLv/ZZ82bRqff/55qe2ff/55hcsMiIrlHTuGKigAdzeOuGbgqCsq/k05lUlBnglnN0f8wzwqv9j+38CYA37NIKxjDUcuhBCiuj3//POsXr26rsMo159//olOp6s3Q9ztTmY+/vhjWrZsWWp7mzZtmDt3brUEdSWyFP/mNQ0BnY4Wvi1wLlwU0lIvE9rCB52+Cv2L1uUL7gbpGxZCiHojPz+/Ssd5eHjUyYirqsZX39idzCQlJZU5HjwwMJDExMRqCepKlHdQK/5NDtWGqhWvlzl9MA2o4hIG2efhyBrtdluZKE8IIS5Wfn4+48aNIzw8HHd3d7p27cqff/5p3X/u3Dnuv/9+GjVqhJubG7GxsXz11Vc21+jTpw9PPfUUY8eOJSAggH79+llbNVavXk3nzp1xc3Oje/fuHCgcBAJaN1OHDh2s9x955BFuu+023nnnHUJDQ/H39+fJJ5+0mcU4MTGRwYMH4+rqSmRkJIsXL6Zp06YVdptZrjtt2jTCwsKIjo4G4IsvvqBz5854enoSEhLCkCFDrHPCHD9+nL59tbnLfH190el0PPLII4A2f8yMGTNo1qwZrq6utG/fnu+///5inn672J3MREREsGHDhlLbN2zYQFhYWLUEdSWyrMl00F/Lilv7acmMMisSD6cBVayX2bsEzEYIiYXA6BqIVAghrgyPPvooGzZs4Ouvv2bnzp3cfffd3HjjjRw6dAiA3NxcOnXqxNKlS9m9ezfDhw/nwQcf5O+//7a5zsKFC3F0dGTDhg18/PHH1u0TJ07k3Xff5Z9//sHR0dFmlHBZ/vjjD44cOcIff/zBwoULWbBgAQsWLLDuf+ihh0hISODPP//khx9+4JNPPrEmIBVZvXo1+/btY+XKlSxduhTQErkpU6awY8cOlixZwrFjx6wJS0REBD/88AMABw4cIDExkffffx+Al19+mfnz5zNnzhz27NnDmDFjeOCBB4iLi6s0jkth96R5jz32GKNHj6agoIDrrrsO0J6IcePG8dxzz1V7gFcKy7DsfzzOAkUtM+cTs8jLNuLo7EBA4yrUy1gmypNWGSGEuGhHjhzhq6++4tSpU9Z/1J9//nmWLVvG/PnzmTp1KuHh4Tz//PPWc55++mmWLVvGd999R9euXa3bW7RowYwZM6z3k5KSAHjzzTfp3bs3AOPHj2fw4MHk5ubi4lL22nu+vr58+OGHODg40LJlSwYPHszq1at5/PHH2b9/P6tWrWLLli107twZgM8++4yoqKhKf1Z3d3c+++wznJyKJlctnlg1a9aM//u//+Pqq68mMzMTDw8P/Pz8AAgKCsLHxweArKwsZs6cyZo1a+jWrZv13PXr1/Pxxx9bf9aaYHcyM27cOM6fP8+oUaOsfWsuLi68+OKLTJgwodoDvBIYU1MxFmbPe7wv4KgzEO2ntapY62WaeeHgUElDWvppiN+o3ZZRTEIIcdH+/fdflFLWbheLvLw8ay2LyWTirbfe4ptvvuH06dPk5eWRl5eHu7u7zTmW5KKk4pPMWso3kpOTady4cZnHt2nTxmZiudDQUHbt2gVoLSSOjo5cddVV1v0tWrTA19e30p81NjbWJpEB2LZtG5MmTWL79u2cP38es9kMwIkTJ2jdunVZl2Hv3r3k5ubSr18/m+35+fl07Fizg1HsSmZMJhPr16/nxRdf5JVXXmHfvn24uroSFRWFs7NzTcV42bMU/xpDA8h1TiPGp3mp4t8qdTHt+RFQ0Lgb+ETUTLBCCHEFMJvNODg4sHXr1lIz03p4aK3k7777Lu+99x6zZs0iNjYWd3d3Ro8eXaqItmRyY1F8Bn3L5HGWpKGy4y3nWI4vPqltceVtryi+rKws+vfvT//+/fniiy8IDAzkxIkTDBgwoMICYUssv/76K+Hh4Tb7ajpHsCuZcXBwYMCAAezbt4/IyEi6dOlSU3FdUfIO7AfgfCNPIM3axaSUKpbMVJ5dF3UxSauMEEJcio4dO2IymUhOTqZnz55lHrNu3TpuvfVWHnjgAUD7MD906BCtWrWqzVABaNmyJUajkW3bttGpUycADh8+fFFDp/fv309KSgpvvfUWERHaP8b//POPzTGWlpzis/63bt0aZ2dnTpw4UaNdSmWxuwA4NjaWo0eP1kQsV6zcwpaZYwFaVmtJZtKTc8jOyMfBUU9QU8+KL5JyGBK3g84B2txek+EKIcRlLzo6mv/85z889NBD/Pjjjxw7dowtW7Ywffp0fvvtN0Drxlm5ciUbN25k3759jBgxwloPU9tatmzJDTfcwPDhw9m8eTPbtm1j+PDhuLq62r1kQOPGjXFycuKDDz7g6NGj/Pzzz0yZMsXmmCZNmqDT6Vi6dClnz54lMzMTT09Pnn/+ecaMGcPChQs5cuQI27ZtY/bs2SxcuLA6f9xS7E5m3nzzTZ5//nmWLl1KYmIiGRkZNl/Cfpbi321eqUBRMmNplQmO9MLRUMkCXJa5ZZr1AfeAmghTCCGuKPPnz+ehhx7iueeeIyYmhltuuYW///7b2lrxyiuvcNVVVzFgwAD69OlDSEgIt912W53Fu2jRIoKDg+nVqxe33347jz/+OJ6enuUWFJcnMDCQBQsW8N1339G6dWveeust3nnnHZtjwsPDef311xk/fjzBwcE89dRTAEyZMoVXX32VadOm0apVKwYMGMAvv/xCZGRktf2cZdGpqnSoFaMvts5P8Wyvvi40mZGRgbe3N+np6Xh5edV1OKUoo5EDV3VC5efz9AgHUvwd2TRkEy6OLqyav5cDfyfReVBTut7SrIKLKPiwC5w7BLfNhQ73194PIIQQDURubi7Hjh0jMjLS7g/4hujUqVNERESwatUqrr/++roOp0wV/U7s+fy2ezTTH3/8Ye8pogL58fGo/HzMLk4k+5po4dMMF0ftF2qtl6lssryknVoi4+gCLQfXbMBCCCHqpTVr1pCZmUlsbCyJiYmMGzeOpk2b0qtXr7oOrcbZncxUVNQjC2LZz9LFdCHCF6U7Z50sL+NcDhfO56LT6whuVkmLkqXwN6o/uNS/1ichhBA1r6CggJdeeomjR4/i6elJ9+7d+fLLL0uNgroc2Z3MlJSens6XX37JZ599xo4dO+pdN1N9Zyn+PRmk1cRY6mUSD2urZAc18cTJpYJfk9kMu3/UbsfKRHlCCHGlGjBgAAMGDKjrMOqE3QXAFmvWrOGBBx4gNDSUDz74gEGDBpUauiUql7dfG5a92/sCULr4t9IuppObIOMUOHlqLTNCCCHEFcaulplTp06xYMECPv/8c7KysrjnnnsoKCjghx9+KHdGQFGx3INay8wev2z0Ogdi/GIAOybLs3QxtboZDK41FKUQQghRf1W5ZWbQoEG0bt2avXv38sEHH5CQkMAHH3xQk7Fd9kzp6RgLVxo/EQjNvJvh6uhKVnoeaWeyQQchzb0ruECBtrAkQKxMlCeEEOLKVOWWmRUrVvDMM8/wxBNPVGnhKlG5vMJWmZwAT3JcckrVy/iHe+DiXkHh1tE4yD4HbgEQ2aeGoxVCCCHqpyq3zKxbt44LFy7QuXNnunbtyocffsjZs2drMrbLXu5+bSRTYqi2ZkWpepnKupgsE+W1uQ0cLrmWWwghhGiQqpzMdOvWjU8//ZTExERGjBjB119/TXh4OGazmZUrV3LhwoWajPOylHdQS2b2++UA0Ma/DVDF4t+CHNj3i3a7rYxiEkIIceWyezSTm5sbQ4cOZf369ezatYvnnnuOt956i6CgIG655ZaaiPGyZRmWvd83B71OT4xfDLlZBZxLyAQqaZk5uBzyM8E7AiK61kK0QgghRP100UOzAWJiYpgxYwanTp3iq6++qq6YrgjKZCLv0CEA4oN01uLfxMNpoMA3xA03L6fyL2DpYmp7B+gv6dcohBCiGpjMir+OnON/20/z15FzmMx2rRZ00T766CPrcgCdOnVi3bp1tfK49Um1FFo4ODhw22231ekCWw1N/okTqJwcTE6OJPkqbi5RLxNaUatMbjocXKHdli4mIYSoc8t2J/L6L3tJTM+1bgv1duG1m1tzY9vQGnvcb775htGjR/PRRx/Ro0cPPv74YwYOHMjevXtp3LhxjT1ufSP/0teRvMIuppRQN5ReZ99keft/BVMeBERDSGwNRyqEEKIiy3Yn8sQX/9okMgBJ6bk88cW/LNudWGOPPXPmTIYNG8Zjjz1Gq1atmDVrFhEREcyZM6fGHrM+qtNkZtq0aXTp0gVPT0+CgoK47bbbOFC4VpGFUopJkyYRFhaGq6srffr0Yc+ePXUUcfWxFP8e8TcC2kim/FwjZ09WoV5m13fa97Z3QbGVy4UQQlw6pRTZ+cYqfV3ILeC1n/dQVoeSZdukn/dyIbegStdTqupdU/n5+WzdupX+/W1nf+/fvz8bN268+CegAarT8bxxcXE8+eSTdOnSBaPRyMSJE+nfvz979+7F3d0dgBkzZjBz5kwWLFhAdHQ0b7zxBv369ePAgQN4enrWZfiXxFL8e8AvF73OkRjfGJIOpaPMCk9/Fzz9ylmePvOsNr8MyFpMQghRA3IKTLR+dXm1XEsBSRm5xE5aUaXj904egJtT1T6aU1JSMJlMBAcH22wPDg4mKSnJ3lAbtDpNZpYtW2Zzf/78+QQFBbF161Z69eqFUopZs2YxceJE7rjjDgAWLlxIcHAwixcvZsSIEXURdrWwrMl0PFhHpFckbgY3Eg5pTZHhFbXK7F0CygRhHcG/ec0HKoQQol7TlWihV0qV2na5q1czraWnazPf+vn5AXDs2DGSkpJsmtCcnZ3p3bs3GzdubLDJjOnCBQpOnwa0ZQyus6f417IWkxT+CiFEjXA1OLB3ctVWn9587DyPzN9S6XELHu3C1ZF+VXrsqgoICMDBwaFUK0xycnKp1prLXb1JZpRSjB07lmuvvZa2bdsCWH9BZTWhxcfHl3mdvLw88vLyrPczMjJqKOKLZxmSnenjTJaridb+rTHmmzhzXIu13HqZtBPaKtnotCHZQgghqp1Op6tyV0/PqEBCvV1ISs8ts25GB4R4u9AzKhAHffW2ljg5OdGpUydWrlzJ7bffbt2+cuVKbr311mp9rPqu3oxmeuqpp9i5c2eZ89XY04Q2bdo0vL29rV8RERE1Eu+lyLV0MQVp91v5t+LM8QzMRoWbtxPegeWsfr37B+1702vBK6wWIhVCCFERB72O127WWtdLfipZ7r92c+tqT2Qsxo4dy2effcbnn3/Ovn37GDNmDCdOnGDkyJE18nj1Vb1IZp5++ml+/vln/vjjDxo1amTdHhISAmBXE9qECRNIT0+3fp08ebLmAr9IlmHZh/zz0aGjlV8rm/WYyu3r3FWYzLSVFbKFEKK+uLFtKHMeuIoQb9uBGyHeLsx54KoanWfm3nvvZdasWUyePJkOHTqwdu1afvvtN5o0aVJjj1kf1Wk3k1KKp59+mp9++ok///yTyMhIm/2RkZGEhISwcuVKOnbsCGhD0eLi4pg+fXqZ13R2dsbZ2bnGY78UeYXDz+ODdDT1blpY/JsGVDC/zNkDcGYX6B2h9ZXVfCiEEPXdjW1D6dc6hM3HzpN8IZcgTxeujvSrsRaZ4kaNGsWoUaNq/HHqszpNZp588kkWL17M//73Pzw9Pa0tMN7e3ri6uqLT6Rg9ejRTp04lKiqKqKgopk6dipubG0OGDKnL0C+aMpvJO6i1zMQH6ejg3xqTyUzSUa34OSzap+wTLYW/za8Ht8qLyIQQQtQuB72Obs396zqMK1KdJjOWGQr79Oljs33+/Pk88sgjAIwbN46cnBxGjRpFamoqXbt2ZcWKFQ12jpmCU6cwZ2djdNST6AdD/Fpz9sQFjPlmXNwN+IW4lz5JqaKJ8mRuGSGEEMJGnXczVUan0zFp0iQmTZpU8wHVgtzCLqaEIAfMekVr/9Yk7EgDILSFN7qymiQT/oXUY+DoCjGDajFaIYQQov6rFwXAVxJL8e8Rf6NW/OvfioTDaUAFQ7Ithb8xA8HZo+aDFEIIIRoQSWZqmaX490SQjiZeTXB1cCPxcGG9TFnJjNkEe37UbksXkxBCCFGKJDO1LNc6kklbXPLc6Uzyc4wYXBwIaFRGq0v8RriQCC7e0OKGWo5WCCGEqP8kmalF5qwsCk6cALSRTK39WxctYdDcG71DGb8OS+Fvq5vBsX4PORdCCCHqgiQztciyjEG6p54Lbloyk1hssrxSjPmw93/a7di7aydIIYQQooGRZKYW5RYW/x4L0EZxtfRtWaz417f0CUfWQG4aeARD0561FKUQQgjRsEgyU4vyDmhrMsUHQVOvphSc15NzoQAHg56gJmXMm7O7cKK8NreDvuorqQohhBBXEklmapGlZSY+qHBIdmEXU0gzLxwcS/wq8rNg/2/a7bYyikkIIRqEtJOQsF37Xks++ugjIiMjcXFxoVOnTqxbt67C4+Pi4ujUqRMuLi40a9aMuXPnljrmhx9+oHXr1jg7O9O6dWt++uknm/1r167l5ptvJiwsDJ1Ox5IlS6rzR7KbJDO1RCllsyZTG/82Fa/HdOB3KMgCnybQqHPtBSqEEOLipJ2EDzvBJ72177WQ0HzzzTeMHj2aiRMnsm3bNnr27MnAgQM5UTjYpKRjx44xaNAgevbsybZt23jppZd45pln+OGHH6zH/PXXX9x77708+OCD7NixgwcffJB77rmHv//+23pMVlYW7du358MPP6zxn7Eq6nQG4CuJMSEBc2YmRgdI8IdWfq3YW1Hx7+7CF1bsXVDeKtpCCCHqj+xzYMzTbhvztPs+ETX6kDNnzmTYsGE89thjAMyaNYvly5czZ84cpk2bVur4uXPn0rhxY2bNmgVAq1at+Oeff3jnnXe48847rdfo168fEyZMAGDChAnExcUxa9YsvvrqKwAGDhzIwIEDa/Rns4e0zNQSy/wyp/zB5KCjEc3ISstD76AjuJm37cE5qXBopXZbupiEEKJ2KaV19Vf16+wBOPEXJO2yvU7SLm372QNVv1YVlvmxyM/PZ+vWrfTv399me//+/dm4cWOZ5/z111+ljh8wYAD//PMPBQUFFR5T3jXrA2mZqSXFu5iaeDUh47j2oglq4oXBqURx775fwFwAQa0huHVthyqEEFe2gmyYGnbp1/n5KfvPeSkBnMpYcLgMKSkpmEwmgoODbbYHBweTlJRU5jlJSUllHm80GklJSSE0NLTcY8q7Zn0gLTO1xFL8eyJIR2u/1pyuqIvJMlFe2ztrJzghhBANlq5EKYJSqtS2yo4vud3ea9Y1aZmpJdaWmUC4wb8VCavSgDKSmQtJcKywEl3WYhJCiNpncNNaSKoi/RTM7QmmwloZnR6Uueg7gIMzjFwH3o2q9thVFBAQgIODQ6kWk+Tk5FItKxYhISFlHu/o6Ii/v3+Fx5R3zfpAWmZqgTknh/z4eADig3W0MLQk42wOOh2ENC9RL7PnJ0BBoy7g27TWYxVCiCueTqd19VTlKzAGnt4Kw+Pgjk+LEhhl1u4Pj9P2B8ZU7Xp2tH44OTnRqVMnVq5cabN95cqVdO/evcxzunXrVur4FStW0LlzZwwGw/+3d+fxUVV348c/dyYzScgyIYQsI4GEfUnYAmJwAQticXmk1paqBRfURqQF0/76c3laqLWCraVAZZGWFrXtA31eKLWWWoKyqCDIEg0koEAgLAkhQDZCZjIz5/ljMpNMFpKQmWQmfN+v17wy995z7/3OmZD75Zxzz71qmeaO6Q+kZaYDWI4eBYeD0m5QFqYReTEBOE5MYgTBoQ2+gpzaifJk4K8QQgSGqMSm71qKGQjmkT49dWZmJjNmzGDMmDGkp6ezevVqCgoKyMjIAJx3Ip05c4a33noLgIyMDF5//XUyMzN58skn2bVrF2vWrHHfpQQwd+5cbrvtNl599VXuu+8+/vGPf7BlyxY++eQTd5nKykqOHj3qXs7Pzyc7O5vo6Gh69+7t08/cFElmOoCri6kgViMxIpHSfGdzZKP5ZS7mw5m9zubJYd/q4CiFEEK0S7cezgcC2yzOn916+PyU06dP58KFC7z00ksUFhaSkpLCpk2b6NOnDwCFhYUec84kJyezadMmnn32WZYvX47ZbGbZsmXu27IBxo8fz7p16/jv//5vfvazn9GvXz/Wr1/PuHHj3GX27t3L7bff7l7OzMwE4JFHHmHt2rU+/tSNSTLTAaoPu+5kwvmk7O2lAJgHRnkWdD2+IOlWiPDfvkkhhBBNiEqEOfuc88t06+HzOWZcZs+ezezZs5vc1lRiMWHCBPbv33/VYz7wwAM88EDzPQQTJ050Dxz2B5LMdID6t2WP7pbCxbOXAUjo32C8TI5rojx5QrYQQgSk5rqchE/JAGAfU0pR/VXdM5nMFf0BiDaHERpurCt47hCczwO9EYbc2xmhCiGEEAFJkhkfs507h6OsDLsGZ3qA8VwU0MR4GdfA3/53QGiDbUIIIYRoliQzPlZ9+DDgTGTioxK5kH8FaDC/jFJ142VSZaI8IYQQoi0kmfExy5G6LqZhEcMpOVUBNEhmTn8OpQVgCIOB/vPgLiGEECIQSDLjY/Vvyx5oHYFSYOoZSlhUcF0hVxfT4LvB2PrZH4UQQgghyYzPVX9Vd1t29CXnVNYerTJ2W+2sv8jjC4QQQohrIMmMDzksFqz5JwBnN5P9jLM1xiOZOfExXC6G0O7Q9/bGBxFCCCHEVUky40OWo0fBbqc8FCJ69uFiQRXQIJlxDfwdeh8EGRsfRAghhBBXJcmMD7kG/xbEaoxkPA6HIrx7MBE9QpwFbBbI/afzvTyLSQghhLgmksz4kHvm356QWDkYgIT+UWiup6J+nQWWMogwQx//fRqpEEKI5q3IXsGqL1Y1uW3VF6tYkb3Ct+dfsYLk5GRCQkJIS0vj448/vmr57du3k5aWRkhICH379mXVKs/YDx06xLe//W2SkpLQNI0lS5b4MHrvkGTGh6rr3ckUet75wLEb6j+PydXFlHI/6PQdHJ0QQghv0Gk6lmcvb5TQrPpiFcuzl6PTfHepXb9+PfPmzePFF1/kwIED3HrrrUydOtXj4ZL15efnc9ddd3Hrrbdy4MABXnjhBX70ox+xYcMGd5mqqir69u3LokWLiI+P91ns3iTPZvIRpRTVh/MAONkziKFnnA/kco+XsVTCkQ+c71NkojwhhPAXSimu2K60uvzMoTOpsdewPHs5NfYaZqXOYk3OGlbnrOap1KeYOXQmVTVVrTpWaFBoXet9KyxevJhZs2bxxBNPALBkyRL+85//sHLlShYuXNio/KpVq+jdu7e7tWXIkCHs3buX1157zf3k7LFjxzJ27FgAnnvuuVbH0pkkmfER2/nzOErLcGgQGT0a+0lFaISBqLjaeWSObALbFYjuC+ZRnRusEEIItyu2K4z727hr2nd1zmpW56xudrklux/aTTdD6+Ybs1qt7Nu3r1HCMWXKFHbu3NnkPrt27WLKlCke6+68807WrFlDTU0NBoOh1bH6k07tZtqxYwf33nsvZrMZTdPYuHGjx3alFAsWLMBsNhMaGsrEiRM5dOhQ5wTbRq7Bv2ejYYBtDOB8HpM74875X+fP1O9AG7JwIYQQAqCkpAS73U5cXJzH+ri4OIqKiprcp6ioqMnyNpuNkpISn8Xqa53aMnP58mVGjBjBY4895m7equ/Xv/41ixcvZu3atQwcOJCXX36ZO+64gyNHjhAREdEJEbee5YjzmUwFsRoxZX1QQIKri6nqIhz7yPle7mISQgi/EhoUyu6Hdrd5P1fXkkFnoMZRw1OpTzErdVabz91WDbullFJX7apqqnxT6wNJpyYzU6dOZerUpp9FpJRiyZIlvPjii9x///0AvPnmm8TFxfG3v/2NH/zgBx0ZaptVu5/JpCehqBuKeuNlcjeCwwbxqdBzYGeFKIQQogmaprW6q8dl1RerWJ2zmmdGPkPGiAz34F+D3kDGiAyfxBkTE4Ner2/UClNcXNyo9cUlPj6+yfJBQUH06NHDJ3F2BL+9myk/P5+ioiKPvr3g4GAmTJjQbF8ggMVioby83OPVGa7UDv493/0GHFYwhgbR44Zw58ac2lHj0iojhBABz5W4uBIZgIwRGTwz8pkm73LyFqPRSFpaGllZWR7rs7KyGD++6ek+0tPTG5XfvHkzY8aMCdjxMuDHA4BdmWNTfXsnT55sdr+FCxfyi1/8wqextcRhtWI9no8GhIaPhFIw9zeh02lQdgZOfuosKHcxCSFEwHMoh0ci4+JadiiHz86dmZnJjBkzGDNmDOnp6axevZqCggIyMpznfv755zlz5gxvvfWWM6aMDF5//XUyMzN58skn2bVrF2vWrOF//ud/3Me0Wq3k5ua63585c4bs7GzCw8Pp37+/zz5Le/htMuPS1r7A559/nszMTPdyeXk5iYmJPouvKdbjx9HsdipDIM6RCtQbL3PoHUBB73SI6ti4hBBCeN/skbOb3earLiaX6dOnc+HCBV566SUKCwtJSUlh06ZN9OnTB4DCwkKPOWeSk5PZtGkTzz77LMuXL8dsNrNs2TKPcatnz55l1Ki6u2xfe+01XnvtNSZMmMC2bdt8+nmuld8mM66JeoqKikhISHCvv1pfIDi7ooKDg30e39XUzfyrEX4hFqg3XibHNVGetMoIIYRov9mzZzN7dtMJ1dq1axutmzBhAvv372/2eElJSe5BwYHCb8fMJCcnEx8f79G3Z7Va2b59e7N9gf7CNfj3VHwCWPQEGXX07B0BF45BYTZoehj2rc4NUgghhOgiOrVlprKykqNHj7qX8/Pzyc7OJjo6mt69ezNv3jxeeeUVBgwYwIABA3jllVfo1q0bDz30UCdG3bLLec65cEqjBhBbA/F9Tej1urpWmb4TISym8wIUQgghupBOTWb27t3L7bff7l52jXV55JFHWLt2LT/96U+5cuUKs2fP5tKlS4wbN47Nmzf7/RwzVw4fRgcEhQyFmtouJqXqTZQndzEJIYQQ3tKpyczEiROv2i+naRoLFixgwYIFHRdUO9lKStBdKsMORFr7AbUPlyz6Ei58DfpgGHxPp8YohBBCdCV+O2YmUFm+qh0vE9eTIEsouiCN2KTIui6mgXdCSGQnRiiEEEJ0LZLMeFn1YeedTKcTBgAQlxRJkF6Dg+84C0gXkxBCCOFVksx42eXDzsG/5ZHOiYXMA6Lg1G4oPw3GCBgw5Sp7CyGEEKKtJJnxsorcgwDoDc5nLpkHRNUN/B1yDxja/hAxIYQQQjRPkhkvUjU1cOI01cHdMdi7o+k04vt0cz5YEqSLSQghhPABSWa8yJKfj85mp7iHs4upZ2I4xrOfQtUF6BYDyRM7NT4hhBDeV1NYyJVDh5p91TR4SrW3rVixguTkZEJCQkhLS+Pjjz9utmxhYSEPPfQQgwYNQqfTMW/ePJ/G1lH89nEGgchSO/Pv2bja8TIDu8PBNc6Nw6aBXqpbCCG6EofVSv4D38F+4UKzZfQxMfT/6EN0RqPXz79+/XrmzZvHihUruPnmm3njjTeYOnUqubm59O7du1F5i8VCz549efHFF/nd737n9Xg6i7TMeFFlnnO8zOXw2mQmORTy3nduTJEuJiGE6Go0gwFDQgI09wBkTcMQH49mMPjk/IsXL2bWrFk88cQTDBkyhCVLlpCYmMjKlSubLJ+UlMTSpUuZOXMmJpPJJzF1Bmkq8KJLh7KxGyLQ9PGgQYL6HKwVYEqExHGdHZ4QQohWUEqhrlxpdfmYjB9wes4PmzsYMRk/QF25Qmse3aiFhqI1lxg1YLVa2bdvH88995zH+ilTprBz585WHaOrkGTGi+xfH6M0yjm/TA9zOCFH/+TckHI/6KQRTAghAoG6coUjo9O8drxmE50mDNq/D61bt1aVLSkpwW63ExcX57E+Li6OIh+P0wFn0nfZYsfmcBCk0xEWrG91IuZtksx4ie3SJYwXKyntX9vF1DcUvtrs3ChdTEIIIVqh9IoVo87YpsSgYTmllM+TirIrVs6WVlNjd7jXGfQ6zFEhmEK9PzaoJZLMeIlr8O/52juZzCFfgd0CMQMhPrUzQxNC+Am7Q7En/yLFFdXERoRwY3I0el3n/E+2ta7HmLXQUAbt39emcyqlODljJpbDh8HhAJ2O4MGD6fP2Wy0mFmXVVopKLdTYHZyuUnClslWJQUxMDHq9vlErTHFxcaPWGm8qu2Ll5IWqRutr7A5OXqiiTw86PKGRZMZLKvJyqAkKxRJiBsBcusG5IeWB5geGCeEnrscLVkf74GAhv/hnLoVl1e51CaYQ5t87lG+mJHRiZM3rajFP7N+9VcfQNK3VXT31xT77LKeefNK54HAQ++yz6MPCrrpP2RUrp6qsYAz2WN+axMBoNJKWlkZWVhbf+ta33OuzsrK477772hx/ayilOFtafdUyZ0uriQwxdGiXkyQzXnI+Zy9lpn6g6YjqGUy30x84N8hEecLPdbULlj/G/MHBQp7+y/5GA0CLyqp5+i/7Wfn90X4Xd1eMefVDqfTyzU1FAITdcjMhKSlUHzxISEoKYbfc3GQ5pRSK1iUGZy5VE6TTOT+Tez/c+z/1zI94+onHGJw6grFjb+LNtWs4WVDAA99/lHPl1by84GcUnT3Lsjf+6N7v4JfZKAUXS8s5cbqQTdt2YTAY6D9oiDs26p2j7pwKhwNsDkez8YIzEbtssRMe0nEphiQzXmI58hWlppsAMHc/D+V2MI+CHv06OTLR0QKpxaArXrD8LWa7Q/GLf+Y2eSeLAjTgF//M5Y6h8X7ze9KamOe/d4ixSdHoNA2HUjhqL3ZKgUN5/nS9d5UD58+rlXNdSB0N1qNw71u/nM2meP6dnGZjBnht81e8PDmOi5etGGrqJwXO2GmwrGp3rL/sOl/des+yjkcz4PevUf3oD8grqqg9Zt2+roSktWwOB8fOVza7few37ub/zX+FV1/5FeeLz9F/0BBeX7segymOc+XVFJw6w9nTBZyvsLj3+eaE8e73OV8c4B8b/o65VyL/3vVlGyJrOe6OpCnXt9JFlZeXYzKZKCsrIzIy0ifnUDYbB0eNIDv1x5RHJjE5+Z8MuvInmPIrGD/HJ+e8XgRSYgCB1WJgdyhuefUjj1jr04B4Uwif/P9vtLrOlfL8g+9xoah9D01fHFxlG/7xr7/N5nBw3+ufUlzvD3NDPSOCefvxG0FzfkalnD9dFz+7o/ZC6FDYay+WDodqukz95drt9tp9Ha08bsHFKt774myLdXfrgBh6hBmdx1UKpZwx2R3OOmg+VuVxcW8Yq+vzO+vCuc7jmE18Fpu9bRfcQHFDhJ4Ft8cSa+6FFtTxg1SvVZBOh16noWnOf5eu7pv6y1qD5brttfvVbsOjrFZvvedy4+3O/apr7Jwpbfm29b4x4a1qmamuriY/P989g3F9bbl+S8uMF1hPngSHgfKIRADMle+BXnPeku1HJDHwLW+2GDgcCqvdQXWNHYvNgaXGgcVW+95mr12ut93WuFzT+9btX3LZ0mwiA85EorCsmsE/+zc6TavX9NxMEuInzldY+ObS5qdz91cff13S2SG0m05zXkhdPzVAV39Zcy67fupqr6K6ButdF19nmbqLr2eZ2uPrnMulVVYKLrZ8kTUG6YgINmAINtZdxBskAzRY1pxX+iYTh0Zlm0okXOdpsHzFaie/5HKLMfeO7tahXTZX082op7jC4nEXU0MGvfM27Y7kH7UT4MpzcyiPTAZNT7du1UToS6DPLRBp7uzQ3K7nxKA97A5FdY3d+apNEFxJQnWNMymorrFTZbXx0vt5V23inrc+m1v2ncZqV1hq6iUXNY2TFOtV/lB0tBp7bXNJAAkz6gk16t0XQ71Oc1/09LUXRL1Oa7DdeVHV167T6TzL6FrYR9M09LX7aLXn0WlwrqKaDw6eazHmB29MpG9MeN0xPc6F+5iu/6HrdVq983qWccevuWKsjbc2EdDr6o5b//O4jptdUMrTf93fYsx/mXUj4/vF1CYfnfsfo13HLvDgHz5rsZwpJAhz99BGrQCdITxYw6DX+V1icDWapmGOCmnybiYXc1RIh/8+SDLjBUVf7qbU5LwlOzE4z7nSjwb++kti0Fqt6a//+T8O0a9nODV2RbXNXq8Vwk51jaNRAmJxJyK1ZWy1720NytdbZ7HZay/k3lFd42BLXnGb99NpEGLQExykIzhIT7BBV/c+SFe3zVC3zrncYHuD/fPPX+bV/xxp8fzLvjeSUb27uy9YrWui9iyHRrPbXH/zGh7To1xtodZesP74yFjS+/Voc137gqs7r6isusnfaVd33svTUv2mpTR2WAgJppAWY07vF4POT2K+MTm6xZh7hgdjDJLEoL1MoUb69EDmmelqLucdojTqbgDM9k9BFwRDfXNbXFu1Z/ChUgqbQ2G1OZwvu7PLwmp3JgeN19ets9S+t9jsdeVsdWVc+1vc6+zu5dIqa4vdH8UVFu743Q5vVlWLjHpnwhBi0BNi0BESpHcnChXVNo6cq2jxGNPHJHJjcrQ78Qipn4A0kYyEBOkI0vtm9mi7Q/HWZydbvGDdPdzsNxfZ1lyw4k3OLlR/oddpzL93KE//ZT8anm1crlqdf+9Qv6lj6LoxP3N7PzSt5W6djuSPiUFrmEKNRIYYZAbgrkSXX0T5sCQAzMZc6DcJuvnHH9M9+RdbNS7i5kUfoddptUmG3Z1k+NNYiIZCDDrCgw3OxKJBguFOElzbahOH+ttcy57vXWUaJyxX+x9oa1sMpo26wW9aDLrqBcvfYgb4ZkoCK78/ulFXb7wfd/V2xZhv7d+d/Pz8Toywaf6WGLSWpml+M5bHP6IIYPayMmy2OBw6A0H6Mkz6Qkh9qbPDQinF4aIK/vLZiVaVLyq/+lwH4OzuCA7SYwzSOV96ZwuCMajuZ936euXqlW1YzljbElG/7LFzlby8Ka/FeP786I1+kxgEYosBdM0Llj/GDM647xgaH1CD8LtazNXVLf+d6yz+lBgEIqm5dirPO0hplHO8TLzxIJohFAbd1SmxWGx2dh+/yId559iSV9yq2+dc5t87lFG9u9cmGE0nHr7q7mjotgE9WfNpfkAlBoHaYgBd74Llz/Q6zW8S8NaSmEUgkGSmnU5nf+Ie/JscdAgGTYXg8A47/4VKC1uPnOfDvHPs+Oo8l61297bgIB039+vB3pOllFfXNLm/KzGYmZ7kNxeCQE0MArXFAALzj38gxiyE8A1JZtqp9OCXlJu+D8ANxkOQusin51NK8XVxJVvyzvFhXjH7Cy55jGuJjQhm0pBYJg2O4+b+MYQa9e67mUASA18L1BYDIYQIZJLMtFPVKSv2hGA0KokOL4f+k71+DqvNwZ78i84E5vA5TjWYGGqYOZJJQ+KYPCSWFLOp0UBVSQw6lrQYCCFEx5Jkph2U3Y7NEg9AuOEw2tB7ICi4hb1a5+JlK1sPF/PR4WJ2fHWeCovNvc1Y2300aUgck4bEkmAKbfF4khgIIUTXs2PHDn7zm9+wb98+CgsLeffdd5k2bVpnh9XhJJlph8oTR6kId46XSQo5CKmPX/OxlFIcLa5kS14xH+adY3/BpdoHsjnFhAczaXAsk4bEcsuAGLoZ2/7VSWIghBC+dSrvIh+v/4pbpw8kcYjvb1K4fPkyI0aM4LHHHuPb3/62z8/nrySZaYf8vdspi3I+FXuQ6Swk3dqm/Wvs9bqP8oopuOg5C+SQhEgmD4ll0pA4ht/QuPtICCGE/1BK8dnGY1wqquKzjcfoNbi7z+eKmTp1KlOnTvXpOQKBJDPtcCb7GLag/miOanqOGgO6lqfJLq2ysvVIMVvyitlxpEH3kV5Her8eTB4SyzeGxHFDVMvdR0IIIbxLKYXN2vbno53Ku0jxSedM4MUnK8j/oqTNrTNBRp3fT5bnjySZaaOawkJsFy/iUFBxzArREGI/ypWQ0egOHSKoRw8M8fEe+xw7X8mWXGfry96TFxt0Hxm5fZCz9eXWATGEBctXIoQQnclmdbB67vZ2H+ffq3LavM9TSydg8KMHSwaKgLhyrlixgt/85jcUFhYybNgwlixZwq23tq1LxxscViu50+7GWOa8m8g6Yh4AppJyCp5ZCYDF1I2h2z5l39nLfJh3jg8PFzd6xPvg+Ajn7dND4hjZK0q6j4QQQoh28PtkZv369cybN48VK1Zw880388YbbzB16lRyc3Pp3bt3h8aiGQyUmcLoUZvMlJmSASiP7Iui9jlHIUZmLtpGuaVu8jqDXuOmvj2YPCSObwyOJTG6W4fGLYQQovWCjDqeWjqh1eWVUmz87QFKTld4zPulaRDTK4JpPx7V6q6jIGPHzLTe1fh9MrN48WJmzZrFE088AcCSJUv4z3/+w8qVK1m4cGGHxuJQ8M8Bd/J4wV85kzDe+XRsoCosnovdh9DjUh7v9J1CucVOdJiz+2jykFhuHdiTcOk+EkKIgKBpWpu6egoOXeD8qYpG65WC86cqKDpWRu9hciepL/n1FdZqtbJv3z6ee+45j/VTpkxh586dTe5jsViwWCzu5fLycq/Fk30wh5d6LKEw2sSJ3nfWbVB2jiffg1n7gmWJy/nXhDv51u3pfj+HixBCiPZRSrH7veM0evaKiwa73ztO4tBonwzsrays5OjRo+7l/Px8srOziY6O7vDei87k1+1ZJSUl2O124uLiPNbHxcVRVFTU5D4LFy7EZDK5X4mJiV6Lp+LiOUJ1NdSkJmMJjanboOmpiEyiJjWZUF0NMfrLksgIIcR1wGFTVFysbjqRAVBQecmCw9ZcgfbZu3cvo0aNYtSoUQBkZmYyatQofv7zn/vkfP7Kr1tmXBpms0qpZjPc559/nszMTPdyeXm51xKaiOg4rjgMfGH4DtTYQavXDKnsfGH4Dr0d2URExzV/ECGEEF2G3qDjO8+Ppbqy6Yf5AoRGGNAbfNN2MHHiRJTyTaIUSPw6mYmJiUGv1zdqhSkuLm7UWuMSHBxMcLB3HinQ0MiUVJ7639WMtkXVPaXRRdNz3jaAOWo1q1NSfXJ+IYQQ/iciOoSI6JDODuO65tfdTEajkbS0NLKysjzWZ2VlMX78+A6PR6fBUJsBRdOTKSkcDLUZkB4mIYQQouP4dcsMOPv/ZsyYwZgxY0hPT2f16tUUFBSQkZHR4bE4bIqQ6mCaywE1dIRUB+OwKfQGyWiEEEKIjuD3ycz06dO5cOECL730EoWFhaSkpLBp0yb69OnT4bHoDTpm/uw2qitrsDsUXx07yuWyC4SZejCwX3/0Os2nfaNCCCGEaMzvkxmA2bNnM3v27M4OA/DsG41PGt3J0QghhBBCmhCEEEJcV+TuH//hre9CkhkhhBDXBYPBAEBVVVUnRyJcXN+F67u5VgHRzSSEEEK0l16vJyoqiuLiYgC6devmk1l5RcuUUlRVVVFcXExUVBR6ffueFC7JjBBCiOtGfHw8gDuhEZ0rKirK/Z20hyQzQgghrhuappGQkEBsbCw1Nc3P2it8z2AwtLtFxkWSGSGEENcdvV7vtQup6HwyAFgIIYQQAU2SGSGEEEIENElmhBBCCBHQuvyYGdeEPOXl5Z0ciRBCCCFay3Xdbs3Eel0+mamoqAAgMTGxkyMRQgghRFtVVFRgMpmuWkZTXXxeZ4fDwdmzZ4mIiPD65Ejl5eUkJiZy6tQpIiMjvXpsUUfquWNIPXcMqeeOIfXcMXxZz0opKioqMJvN6HRXHxXT5VtmdDodvXr18uk5IiMj5R9LB5B67hhSzx1D6rljSD13DF/Vc0stMi4yAFgIIYQQAU2SGSGEEEIENElm2iE4OJj58+cTHBzc2aF0aVLPHUPquWNIPXcMqeeO4S/13OUHAAshhBCia5OWGSGEEEIENElmhBBCCBHQJJkRQgghRECTZEYIIYQQAU2SmWu0YsUKkpOTCQkJIS0tjY8//rizQ/JrO3bs4N5778VsNqNpGhs3bvTYrpRiwYIFmM1mQkNDmThxIocOHfIoY7FY+OEPf0hMTAxhYWH813/9F6dPn/Yoc+nSJWbMmIHJZMJkMjFjxgxKS0t9/On8w8KFCxk7diwRERHExsYybdo0jhw54lFG6rn9Vq5cyfDhw92ThKWnp/Pvf//bvV3q2DcWLlyIpmnMmzfPvU7q2jsWLFiApmker/j4ePf2gKhnJdps3bp1ymAwqD/84Q8qNzdXzZ07V4WFhamTJ092dmh+a9OmTerFF19UGzZsUIB69913PbYvWrRIRUREqA0bNqicnBw1ffp0lZCQoMrLy91lMjIy1A033KCysrLU/v371e23365GjBihbDabu8w3v/lNlZKSonbu3Kl27typUlJS1D333NNRH7NT3XnnnerPf/6zOnjwoMrOzlZ333236t27t6qsrHSXkXpuv/fee0/961//UkeOHFFHjhxRL7zwgjIYDOrgwYNKKaljX9izZ49KSkpSw4cPV3PnznWvl7r2jvnz56thw4apwsJC96u4uNi9PRDqWZKZa3DjjTeqjIwMj3WDBw9Wzz33XCdFFFgaJjMOh0PFx8erRYsWuddVV1crk8mkVq1apZRSqrS0VBkMBrVu3Tp3mTNnziidTqc++OADpZRSubm5ClCfffaZu8yuXbsUoA4fPuzjT+V/iouLFaC2b9+ulJJ69qXu3burP/7xj1LHPlBRUaEGDBigsrKy1IQJE9zJjNS198yfP1+NGDGiyW2BUs/SzdRGVquVffv2MWXKFI/1U6ZMYefOnZ0UVWDLz8+nqKjIo06Dg4OZMGGCu0737dtHTU2NRxmz2UxKSoq7zK5duzCZTIwbN85d5qabbsJkMl2X301ZWRkA0dHRgNSzL9jtdtatW8fly5dJT0+XOvaBZ555hrvvvpvJkyd7rJe69q6vv/4as9lMcnIy3/ve9zh+/DgQOPXc5R806W0lJSXY7Xbi4uI81sfFxVFUVNRJUQU2V701VacnT550lzEajXTv3r1RGdf+RUVFxMbGNjp+bGzsdffdKKXIzMzklltuISUlBZB69qacnBzS09Oprq4mPDycd999l6FDh7r/KEsde8e6devYv38/n3/+eaNt8vvsPePGjeOtt95i4MCBnDt3jpdffpnx48dz6NChgKlnSWaukaZpHstKqUbrRNtcS502LNNU+evxu5kzZw5ffvkln3zySaNtUs/tN2jQILKzsyktLWXDhg088sgjbN++3b1d6rj9Tp06xdy5c9m8eTMhISHNlpO6br+pU6e636emppKenk6/fv148803uemmmwD/r2fpZmqjmJgY9Hp9o0yyuLi4UeYqWsc1av5qdRofH4/VauXSpUtXLXPu3LlGxz9//vx19d388Ic/5L333mPr1q306tXLvV7q2XuMRiP9+/dnzJgxLFy4kBEjRrB06VKpYy/at28fxcXFpKWlERQURFBQENu3b2fZsmUEBQW560Hq2vvCwsJITU3l66+/DpjfaUlm2shoNJKWlkZWVpbH+qysLMaPH99JUQW25ORk4uPjPerUarWyfft2d52mpaVhMBg8yhQWFnLw4EF3mfT0dMrKytizZ4+7zO7duykrK7suvhulFHPmzOGdd97ho48+Ijk52WO71LPvKKWwWCxSx140adIkcnJyyM7Odr/GjBnDww8/THZ2Nn379pW69hGLxUJeXh4JCQmB8zvd7iHE1yHXrdlr1qxRubm5at68eSosLEydOHGis0PzWxUVFerAgQPqwIEDClCLFy9WBw4ccN/OvmjRImUymdQ777yjcnJy1IMPPtjkrX+9evVSW7ZsUfv371ff+MY3mrz1b/jw4WrXrl1q165dKjU19bq5xfLpp59WJpNJbdu2zeMWy6qqKncZqef2e/7559WOHTtUfn6++vLLL9ULL7ygdDqd2rx5s1JK6tiX6t/NpJTUtbf8+Mc/Vtu2bVPHjx9Xn332mbrnnntURESE+5oWCPUsycw1Wr58uerTp48yGo1q9OjR7ttfRdO2bt2qgEavRx55RCnlvP1v/vz5Kj4+XgUHB6vbbrtN5eTkeBzjypUras6cOSo6OlqFhoaqe+65RxUUFHiUuXDhgnr44YdVRESEioiIUA8//LC6dOlSB33KztVU/QLqz3/+s7uM1HP7Pf744+5/+z179lSTJk1yJzJKSR37UsNkRuraO1zzxhgMBmU2m9X999+vDh065N4eCPWsKaVU+9t3hBBCCCE6h4yZEUIIIURAk2RGCCGEEAFNkhkhhBBCBDRJZoQQQggR0CSZEUIIIURAk2RGCCGEEAFNkhkhhBBCBDRJZoQQXV5SUhJLlizp7DCEED4iyYwQwqseffRRpk2bBsDEiROZN29eh5177dq1REVFNVr/+eef89RTT3VYHEKIjhXU2QEIIURLrFYrRqPxmvfv2bOnF6MRQvgbaZkRQvjEo48+yvbt21m6dCmapqFpGidOnAAgNzeXu+66i/DwcOLi4pgxYwYlJSXufSdOnMicOXPIzMwkJiaGO+64A4DFixeTmppKWFgYiYmJzJ49m8rKSgC2bdvGY489RllZmft8CxYsABp3MxUUFHDfffcRHh5OZGQk3/3udzl37px7+4IFCxg5ciRvv/02SUlJmEwmvve971FRUeHbShNCXBNJZoQQPrF06VLS09N58sknKSwspLCwkMTERAoLC5kwYQIjR45k7969fPDBB5w7d47vfve7Hvu/+eabBAUF8emnn/LGG28AoNPpWLZsGQcPHuTNN9/ko48+4qc//SkA48ePZ8mSJURGRrrP95Of/KRRXEoppk2bxsWLF9m+fTtZWVkcO3aM6dOne5Q7duwYGzdu5P333+f9999n+/btLFq0yEe1JYRoD+lmEkL4hMlkwmg00q1bN+Lj493rV65cyejRo3nllVfc6/70pz+RmJjIV199xcCBAwHo378/v/71rz2OWX/8TXJyMr/85S95+umnWbFiBUajEZPJhKZpHudraMuWLXz55Zfk5+eTmJgIwNtvv82wYcP4/PPPGTt2LAAOh4O1a9cSEREBwIwZM/jwww/51a9+1b6KEUJ4nbTMCCE61L59+9i6dSvh4eHu1+DBgwFna4jLmDFjGu27detW7rjjDm644QYiIiKYOXMmFy5c4PLly60+f15eHomJie5EBmDo0KFERUWRl5fnXpeUlOROZAASEhIoLi5u02cVQnQMaZkRQnQoh8PBvffey6uvvtpoW0JCgvt9WFiYx7aTJ09y1113kZGRwS9/+Uuio6P55JNPmDVrFjU1Na0+v1IKTdNaXG8wGDy2a5qGw+Fo9XmEEB1HkhkhhM8YjUbsdrvHutGjR7NhwwaSkpIICmr9n6C9e/dis9n47W9/i07nbFT++9//3uL5Gho6dCgFBQWcOnXK3TqTm5tLWVkZQ4YMaXU8Qgj/Id1MQgifSUpKYvfu3Zw4cYKSkhIcDgfPPPMMFy9e5MEHH2TPnj0cP36czZs38/jjj181EenXrx82m43f//73HD9+nLfffptVq1Y1Ol9lZSUffvghJSUlVFVVNTrO5MmTGT58OA8//DD79+9nz549zJw5kwkTJjTZtSWE8H+SzAghfOYnP/kJer2eoUOH0rNnTwoKCjCbzXz66afY7XbuvPNOUlJSmDt3LiaTyd3i0pSRI0eyePFiXn31VVJSUvjrX//KwoULPcqMHz+ejIwMpk+fTs+ePRsNIAZnd9HGjRvp3r07t912G5MnT6Zv376sX7/e659fCNExNKWU6uwghBBCCCGulbTMCCGEECKgSTIjhBBCiIAmyYwQQgghApokM0IIIYQIaJLMCCGEECKgSTIjhBBCiIAmyYwQQgghApokM0IIIYQIaJLMCCGEECKgSTIjhBBCiIAmyYwQQgghApokM0IIIYQIaP8HGYKCkl51QfEAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "for learning_rate, marker in zip(learning_rates, markers):\n", " metrics = all_metrics[learning_rate]\n", " plt.plot(metrics[\"Archive Coverage\"][\"x\"],\n", " metrics[\"Archive Coverage\"][\"y\"],\n", " marker=marker)\n", "\n", "plt.title(\"Archive Coverage of CMA-MAE at Various Learning Rates\")\n", "plt.xlabel(\"Iteration\")\n", "plt.ylabel(\"Archive Coverage (%)\")\n", "plt.legend(learning_rates, title=\"learning rate\");" ] }, { "cell_type": "markdown", "id": "0Lw3Bh7zxsug", "metadata": { "id": "0Lw3Bh7zxsug" }, "source": [ "From the plots, we observe the following:\n", "\n", "- At one extreme, with learning rate 0, CMA-MAE makes no progress in exploring the archive since it focuses solely on optimizing the objective. This leads it to have the lowest QD score.\n", "- On the other extreme, with learning rate 1, CMA-MAE stops making progress after around 500 iterations. Recall that this method is equivalent to CMA-ME; while it does explore the archive, it does not achieve the theoretical \"density descent\" property from the CMA-MAE paper, which holds for any $\\alpha$ strictly between 0 and 1. This property yields better exploration capabilities in CMA-MAE.\n", "- With intermediate learning rates, particularly 0.01 and 0.1, the algorithm makes quick progress, surpassing the performance of all other learning rate settings. Learning rate 0.001 seems to progress very slowly as it may spend too much time in high-objective regions before moving away, but it may catch up with the other learning rates given enough iterations.\n", "\n", "Let's also plot heatmaps of each algorithm to further understand their performance." ] }, { "cell_type": "code", "execution_count": 15, "id": "a2bf6db8-87ff-4156-9c4f-97a7fecd9222", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axs = plt.subplots(1, len(learning_rates), figsize=(20, 3))\n", "for i, (learning_rate, scheduler) in enumerate(zip(learning_rates, all_schedulers)):\n", " axs[i].set_title(f\"$\\\\alpha = {learning_rate}$\")\n", " grid_archive_heatmap(scheduler.result_archive,\n", " ax=axs[i],\n", " vmin=0,\n", " vmax=100,\n", " aspect=1.0)" ] }, { "cell_type": "markdown", "id": "d41d4816-d4ed-4bd5-b02b-0b571f87defb", "metadata": {}, "source": [ "These plots support our observations. We see that at $\\alpha=0$, CMA-MAE heads straight to the optimum, while at $\\alpha=1$, CMA-MAE spreads out but is unable to expand further. In intermediate values, CMA-MAE is able to balance optimization and exploration and thus fill the archive. Overall, these observations conform to our theoretical understanding of CMA-MAE." ] }, { "cell_type": "markdown", "id": "436defab-4c54-4e2e-ba6f-f447ce1ae909", "metadata": {}, "source": [ "## Conclusion\n", "\n", "In this tutorial, we introduced CMA-MAE. We showed how it is implemented in pyribs, and we compared this implementation to that of CMA-ME. Then, we demonstrated CMA-MAE on the sphere linear projection benchmark, and we concluded by seeing how different settings of the learning rate $\\alpha$ affected is performance. Overall, CMA-MAE has strong theoretical and empirical properties which enable it to excel at QD problems like this one. For these reasons, we recommend CMA-MAE over CMA-ME for most QD optimization problems.\n", "\n", "_For implementations of a wide variety of algorithms on the sphere benchmark, take a look at our [sphere example](https://docs.pyribs.org/en/stable/examples/sphere.html)._" ] }, { "cell_type": "markdown", "id": "b31610ae-18aa-430b-bc9d-ca9d75f216b0", "metadata": {}, "source": [ "## Citation\n", "\n", "If you find this tutorial useful, please cite it as:\n", "\n", "```text\n", "@article{pyribs_cma_mae,\n", " title = {Upgrading CMA-ME to CMA-MAE on the Sphere Benchmark},\n", " author = {David H. Lee and Bryon Tjanaka and Nivedit Reddy Balam and\n", " Matthew C. Fontaine and Stefanos Nikolaidis},\n", " journal = {pyribs.org},\n", " year = {2023},\n", " url = {https://docs.pyribs.org/en/stable/tutorials/cma_mae.html}\n", "}\n", "```" ] } ], "metadata": { "colab": { "provenance": [] }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.17" } }, "nbformat": 4, "nbformat_minor": 5 }