tutorials/multi_objective_bo.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "61330204-a407-449f-af77-fcd868546651",
        "showInput": false
      },
      "source": [
        "## Noisy, Parallel, Multi-Objective BO in BoTorch with qEHVI, qNEHVI, qNParEGO, qMPI\n",
        "\n",
        "> **Note**\n",
        "> Botorchex supports qMPI.\n",
        "\n",
        "In this tutorial, we illustrate how to implement a simple multi-objective (MO) Bayesian Optimization (BO) closed loop in BoTorch.\n",
        "\n",
        "In general, we recommend using [Ax](https://ax.dev) for a simple BO setup like this one, since this will simplify your setup (including the amount of code you need to write) considerably. See [here](https://ax.dev/tutorials/multiobjective_optimization.html) for an Ax tutorial on MOBO. If desired, you can use a custom BoTorch model in Ax, following the [Using BoTorch with Ax](./custom_botorch_model_in_ax) tutorial. Given a `MultiObjective`, Ax will default to the $q$NEHVI acquisiton function. If desired, this can also be customized by adding `\"botorch_acqf_class\": <desired_botorch_acquisition_function_class>,` to the `model_kwargs`.\n",
        "\n",
        "We use the parallel ParEGO ($q$ParEGO) [1], parallel Expected Hypervolume Improvement ($q$EHVI) [1], and parallel Noisy Expected Hypervolume Improvement ($q$NEHVI) [2]  acquisition functions to optimize a synthetic BraninCurrin problem test function with additive Gaussian observation noise over a 2-parameter search space [0,1]^2. See  `botorch/test_functions/multi_objective.py` for details on BraninCurrin. The noise standard deviations are 15.19 and 0.63 for each objective, respectively.\n",
        "\n",
        "Since botorch assumes a maximization of all objectives, we seek to find the Pareto frontier, the set of optimal trade-offs where improving one metric means deteriorating another.\n",
        "\n",
        "[1] [S. Daulton, M. Balandat, and E. Bakshy. Differentiable Expected Hypervolume Improvement for Parallel Multi-Objective Bayesian Optimization. Advances in Neural Information Processing Systems 33, 2020.](https://arxiv.org/abs/2006.05078)\n",
        "\n",
        "[2] [S. Daulton, M. Balandat, and E. Bakshy. Parallel Bayesian Optimization of Multiple Noisy Objectives with Expected Hypervolume Improvement. Advances in Neural Information Processing Systems 34, 2021.](https://arxiv.org/abs/2105.08195)\n",
        "\n",
        "**For batch optimization (or in noisy settings), we strongly recommend using $q$NEHVI rather than $q$EHVI because it is far more efficient than $q$EHVI and mathematically equivalent in the noiseless setting.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "f01416cb-e83e-4263-b599-b2a3221d144d",
        "showInput": false
      },
      "source": [
        "### Set dtype and device\n",
        "Note: $q$EHVI and $q$NEHVI aggressively exploit parallel hardware and are both much faster when run on a GPU. See [1, 2] for details."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649461840,
        "executionStopTime": 1668649461848,
        "originalKey": "41c30177-379b-4e63-9996-41bc17d70769",
        "requestMsgId": "7e4820a5-df3b-45a6-9826-42541ee0f4f4"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import torch\n",
        "\n",
        "tkwargs = {\n",
        "    \"dtype\": torch.double,\n",
        "    \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
        "}\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "8d895a93-397c-4d2c-b6f5-96f589312538",
        "showInput": false
      },
      "source": [
        "### Problem setup\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462081,
        "executionStopTime": 1668649462087,
        "originalKey": "a8741d41-72b7-42e8-bd5d-3972be9995f7",
        "requestMsgId": "bceaa0af-ffe5-415a-a5b1-93fc9cf7f71a"
      },
      "outputs": [],
      "source": [
        "from botorch.test_functions.multi_objective import BraninCurrin\n",
        "\n",
        "\n",
        "problem = BraninCurrin(negate=True).to(**tkwargs)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "fc047039-c2a9-4ea8-920e-c057547cfb11",
        "showInput": false
      },
      "source": [
        "#### Model initialization\n",
        "\n",
        "We use a list of `FixedNoiseGP`s to model the two objectives with known noise variances. Homoskedastic noise levels can be inferred by using `SingleTaskGP`s instead of `FixedNoiseGP`s.\n",
        "\n",
        "The models are initialized with $2(d+1)=6$ points drawn randomly from $[0,1]^2$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462312,
        "executionStopTime": 1668649462318,
        "originalKey": "47170c31-65e4-4f2d-949c-d91544e065fc",
        "requestMsgId": "8a44b7cb-cc5f-419e-849f-2b4d1dc3abe1"
      },
      "outputs": [],
      "source": [
        "from botorch.models.gp_regression import FixedNoiseGP\n",
        "from botorch.models.model_list_gp_regression import ModelListGP\n",
        "from botorch.models.transforms.outcome import Standardize\n",
        "from gpytorch.mlls.sum_marginal_log_likelihood import SumMarginalLogLikelihood\n",
        "from botorch.utils.transforms import unnormalize, normalize\n",
        "from botorch.utils.sampling import draw_sobol_samples\n",
        "\n",
        "NOISE_SE = torch.tensor([15.19, 0.63], **tkwargs)\n",
        "\n",
        "def generate_initial_data(n=6):\n",
        "    # generate training data\n",
        "    train_x = draw_sobol_samples(bounds=problem.bounds,n=n, q=1).squeeze(1)\n",
        "    train_obj_true = problem(train_x)\n",
        "    train_obj = train_obj_true + torch.randn_like(train_obj_true) * NOISE_SE\n",
        "    return train_x, train_obj, train_obj_true\n",
        "\n",
        "\n",
        "def initialize_model(train_x, train_obj):\n",
        "    # define models for objective and constraint\n",
        "    train_x = normalize(train_x, problem.bounds)\n",
        "    models = []\n",
        "    for i in range(train_obj.shape[-1]):\n",
        "        train_y = train_obj[..., i:i+1]\n",
        "        train_yvar = torch.full_like(train_y, NOISE_SE[i] ** 2)\n",
        "        models.append(\n",
        "            FixedNoiseGP(train_x, train_y, train_yvar, outcome_transform=Standardize(m=1))\n",
        "        )\n",
        "    model = ModelListGP(*models)\n",
        "    mll = SumMarginalLogLikelihood(model.likelihood, model)\n",
        "    return mll, model"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "6bfaef9a-3f34-4d51-9700-fbddc79eccf1",
        "showInput": false
      },
      "source": [
        "#### Define a helper functions that performs the essential BO step for $q$EHVI, $q$NEHVI and $q$MPI\n",
        "The helper function below initializes the $q$EHVI acquisition function, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
        "\n",
        "For this example, we'll use a relatively small batch of optimization ($q=4$). For batch optimization ($q>1$), passing the keyword argument `sequential=True` to the function `optimize_acqf`specifies that candidates should be optimized in a sequential greedy fashion (see [1] for details why this is important). A simple initialization heuristic is used to select the 10 restart initial locations from a set of 512 random points. Multi-start optimization of the acquisition function is performed using LBFGS-B with exact gradients computed via auto-differentiation.\n",
        "\n",
        "**Reference Point**\n",
        "\n",
        "$q$EHVI requires specifying a reference point, which is the lower bound on the objectives used for computing hypervolume. In this tutorial, we assume the reference point is known. In practice the reference point can be set 1) using domain knowledge to be slightly worse than the lower bound of objective values, where the lower bound is the minimum acceptable value of interest for each objective, or 2) using a dynamic reference point selection strategy.\n",
        "\n",
        "**Partitioning the Non-dominated Space into disjoint rectangles**\n",
        "\n",
        "$q$EHVI requires partitioning the non-dominated space into disjoint rectangles (see [1] for details). \n",
        "\n",
        "*Note:* `FastNondominatedPartitioning` *will be very slow when 1) there are a lot of points on the pareto frontier and 2) there are >5 objectives.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462539,
        "executionStopTime": 1668649462641,
        "originalKey": "b7effe94-1327-405d-9148-c8e93470b846",
        "requestMsgId": "40a5edda-3bee-43c9-b84b-c669c288eb80"
      },
      "outputs": [],
      "source": [
        "from botorch.optim.optimize import optimize_acqf, optimize_acqf_list\n",
        "from botorch.acquisition.objective import GenericMCObjective\n",
        "from botorch.utils.multi_objective.scalarization import get_chebyshev_scalarization\n",
        "from botorch.utils.multi_objective.box_decompositions.non_dominated import FastNondominatedPartitioning\n",
        "from botorch.acquisition.multi_objective.monte_carlo import qExpectedHypervolumeImprovement, qNoisyExpectedHypervolumeImprovement\n",
        "from botorch.utils.sampling import sample_simplex\n",
        "\n",
        "\n",
        "BATCH_SIZE = 4\n",
        "NUM_RESTARTS = 10 if not SMOKE_TEST else 2\n",
        "RAW_SAMPLES = 512 if not SMOKE_TEST else 4\n",
        "\n",
        "standard_bounds = torch.zeros(2, problem.dim, **tkwargs)\n",
        "standard_bounds[1] = 1\n",
        "\n",
        "\n",
        "def optimize_qehvi_and_get_observation(model, train_x, train_obj, sampler):\n",
        "    \"\"\"Optimizes the qEHVI acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    # partition non-dominated space into disjoint rectangles\n",
        "    with torch.no_grad():\n",
        "        pred = model.posterior(normalize(train_x, problem.bounds)).mean\n",
        "    partitioning = FastNondominatedPartitioning(\n",
        "        ref_point=problem.ref_point, \n",
        "        Y=pred,\n",
        "    )\n",
        "    acq_func = qExpectedHypervolumeImprovement(\n",
        "        model=model,\n",
        "        ref_point=problem.ref_point,\n",
        "        partitioning=partitioning,\n",
        "        sampler=sampler,\n",
        "    )\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        bounds=standard_bounds,\n",
        "        q=BATCH_SIZE,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "        sequential=True,\n",
        "    )\n",
        "    # observe new values \n",
        "    new_x =  unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj_true = problem(new_x)\n",
        "    new_obj = new_obj_true + torch.randn_like(new_obj_true) * NOISE_SE\n",
        "    return new_x, new_obj, new_obj_true"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "ccaf56e2-f0e0-4d1c-bf07-247d984535a5",
        "showInput": false
      },
      "source": [
        "**Integrating over function values at in-sample designs**\n",
        "\n",
        "$q$NEHVI integrates over the unknown function values at the previously evaluated designs (see [2] for details). Therefore, we need to provide the previously evaluated designs (`train_x`, *normalized* to be within $[0,1]^d$) to the acquisition function.\n",
        "\n",
        "**Efficient batch generation with Cached Box Decomposition (CBD)**\n",
        "\n",
        "$q$NEHVI leveraged CBD to efficiently generate large batches of candidates. CBD scales polynomially with respect to the batch size where as the inclusion-exclusion principle used by qEHVI scales exponentially with the batch size.\n",
        "\n",
        "**Pruning baseline designs**\n",
        "To speed up integration over the function values at the previously evaluated designs, we prune the set of previously evaluated designs (by setting `prune_baseline=True`) to only include those which have positive probability of being on the current in-sample Pareto frontier."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649462860,
        "executionStopTime": 1668649462867,
        "originalKey": "f2749e5f-eb94-4150-8f52-057f90e08b39",
        "requestMsgId": "f9e71b3c-2eb6-4b79-92c5-72d16d368233"
      },
      "outputs": [],
      "source": [
        "def optimize_qnehvi_and_get_observation(model, train_x, train_obj, sampler):\n",
        "    \"\"\"Optimizes the qEHVI acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    # partition non-dominated space into disjoint rectangles\n",
        "    acq_func = qNoisyExpectedHypervolumeImprovement(\n",
        "        model=model,\n",
        "        ref_point=problem.ref_point.tolist(),  # use known reference point \n",
        "        X_baseline=normalize(train_x, problem.bounds),\n",
        "        prune_baseline=True,  # prune baseline points that have estimated zero probability of being Pareto optimal\n",
        "        sampler=sampler,\n",
        "    )\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        bounds=standard_bounds,\n",
        "        q=BATCH_SIZE,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "        sequential=True,\n",
        "    )\n",
        "    # observe new values \n",
        "    new_x =  unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj_true = problem(new_x)\n",
        "    new_obj = new_obj_true + torch.randn_like(new_obj_true) * NOISE_SE\n",
        "    return new_x, new_obj, new_obj_true"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "ad78607d-d910-441c-903b-b15dc77a432f",
        "showInput": false
      },
      "source": [
        "#### Define a helper function that performs the essential BO step for $q$NParEGO\n",
        "The helper function below similarly initializes $q$NParEGO, optimizes it, and returns the batch $\\{x_1, x_2, \\ldots x_q\\}$ along with the observed function values. \n",
        "\n",
        "$q$NParEGO uses random augmented chebyshev scalarization with the `qNoisyExpectedImprovement` acquisition function. In the parallel setting ($q>1$), each candidate is optimized in sequential greedy fashion using a different random scalarization (see [1] for details).\n",
        "\n",
        "To do this, we create a list of `qNoisyExpectedImprovement` acquisition functions, each with different random scalarization weights. The `optimize_acqf_list` method sequentially generates one candidate per acquisition function and conditions the next candidate (and acquisition function) on the previously selected pending candidates."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649463087,
        "executionStopTime": 1668649463185,
        "originalKey": "806b115f-a15f-44df-b7f9-d2f098969e02",
        "requestMsgId": "514d162f-78e0-447a-a483-c923cba18b80"
      },
      "outputs": [],
      "source": [
        "from botorch.acquisition.monte_carlo import qNoisyExpectedImprovement\n",
        "\n",
        "\n",
        "def optimize_qnparego_and_get_observation(model, train_x, train_obj, sampler):\n",
        "    \"\"\"Samples a set of random weights for each candidate in the batch, performs sequential greedy optimization \n",
        "    of the qNParEGO acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    train_x = normalize(train_x, problem.bounds)\n",
        "    with torch.no_grad():\n",
        "        pred = model.posterior(train_x).mean\n",
        "    acq_func_list = []\n",
        "    for _ in range(BATCH_SIZE):\n",
        "        weights = sample_simplex(problem.num_objectives, **tkwargs).squeeze()\n",
        "        objective = GenericMCObjective(get_chebyshev_scalarization(weights=weights, Y=pred))\n",
        "        acq_func = qNoisyExpectedImprovement(  # pyre-ignore: [28]\n",
        "            model=model,\n",
        "            objective=objective,\n",
        "            X_baseline=train_x,\n",
        "            sampler=sampler,\n",
        "            prune_baseline=True,\n",
        "        )\n",
        "        acq_func_list.append(acq_func)\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf_list(\n",
        "        acq_function_list=acq_func_list,\n",
        "        bounds=standard_bounds,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "    )\n",
        "    # observe new values \n",
        "    new_x =  unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj_true = problem(new_x)\n",
        "    new_obj = new_obj_true + torch.randn_like(new_obj_true) * NOISE_SE\n",
        "    return new_x, new_obj, new_obj_true"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Define $q$MPI"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "from botorchex.acquisition.multi_objective.monte_carlo import qMultiProbabilityOfImprovement\n",
        "\n",
        "def optimize_qmpi_and_get_observation(model, train_x, train_obj, sampler):\n",
        "    \"\"\"Optimizes the qMPI acquisition function, and returns a new candidate and observation.\"\"\"\n",
        "    # partition non-dominated space into disjoint rectangles\n",
        "    with torch.no_grad():\n",
        "        pred = model.posterior(normalize(train_x, problem.bounds)).mean\n",
        "    partitioning = FastNondominatedPartitioning(\n",
        "        ref_point=problem.ref_point, \n",
        "        Y=pred,\n",
        "    )\n",
        "    best_f = torch.amax(train_obj, dim=0)\n",
        "    acq_func = qMultiProbabilityOfImprovement(\n",
        "        model=model,\n",
        "        sampler=sampler,\n",
        "        best_f=best_f\n",
        "    )\n",
        "    # optimize\n",
        "    candidates, _ = optimize_acqf(\n",
        "        acq_function=acq_func,\n",
        "        bounds=standard_bounds,\n",
        "        q=BATCH_SIZE,\n",
        "        num_restarts=NUM_RESTARTS,\n",
        "        raw_samples=RAW_SAMPLES,  # used for intialization heuristic\n",
        "        options={\"batch_limit\": 5, \"maxiter\": 200},\n",
        "        sequential=True,\n",
        "    )\n",
        "    # observe new values \n",
        "    new_x =  unnormalize(candidates.detach(), bounds=problem.bounds)\n",
        "    new_obj_true = problem(new_x)\n",
        "    new_obj = new_obj_true + torch.randn_like(new_obj_true) * NOISE_SE\n",
        "    return new_x, new_obj, new_obj_true"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "f8ffd86a-f4bb-4984-9330-04ff4d62f189",
        "showInput": false
      },
      "source": [
        "### Perform Bayesian Optimization loop with $q$NEHVI, $q$EHVI, $q$NParEGO, and $q$MPI\n",
        "The Bayesian optimization \"loop\" for a batch size of $q$ simply iterates the following steps:\n",
        "1. given a surrogate model, choose a batch of points $\\{x_1, x_2, \\ldots x_q\\}$\n",
        "2. observe $f(x)$ for each $x$ in the batch \n",
        "3. update the surrogate model. \n",
        "\n",
        "\n",
        "Just for illustration purposes, we run one trial with `N_BATCH=20` rounds of optimization. The acquisition function is approximated using `MC_SAMPLES=128` samples.\n",
        "\n",
        "*Note*: Running this may take a little while."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649463513,
        "executionStopTime": 1668649856754,
        "originalKey": "c29b731a-64e7-401d-a5b2-3879d8d39327",
        "requestMsgId": "43e1021f-9ecd-4d2c-a7ba-21e26051ce66"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Batch  1: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (0.00, 0.00, 0.00, 0.00, 0.00), time = 35.88.\n",
            "Batch  2: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (18.88, 2.37, 2.37, 0.00, 0.00), time = 31.88.\n",
            "Batch  3: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (18.88, 23.18, 28.63, 2.37, 0.00), time = 37.97.\n",
            "Batch  4: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (18.88, 29.44, 44.16, 40.38, 0.00), time = 28.19.\n",
            "Batch  5: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (18.88, 36.92, 48.27, 49.89, 30.86), time = 35.59.\n",
            "Batch  6: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (18.88, 45.21, 50.88, 51.70, 30.86), time = 35.85.\n",
            "Batch  7: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 45.21, 52.32, 53.17, 30.86), time = 29.31.\n",
            "Batch  8: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 45.41, 52.83, 53.81, 30.86), time = 29.12.\n",
            "Batch  9: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 45.41, 54.30, 54.41, 30.86), time = 32.08.\n",
            "Batch 10: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 45.88, 54.47, 54.60, 39.78), time = 25.55.\n",
            "Batch 11: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 47.11, 54.62, 54.80, 39.78), time = 28.27.\n",
            "Batch 12: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 50.17, 54.98, 55.00, 40.10), time = 23.26.\n",
            "Batch 13: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 51.32, 55.69, 55.94, 40.10), time = 26.13.\n",
            "Batch 14: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 51.32, 55.82, 55.94, 40.10), time = 32.17.\n",
            "Batch 15: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 51.32, 55.82, 55.94, 40.10), time = 28.28.\n",
            "Batch 16: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 52.03, 56.09, 56.22, 40.41), time = 28.62.\n",
            "Batch 17: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 52.05, 56.12, 56.65, 40.41), time = 30.99.\n",
            "Batch 18: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 52.05, 56.16, 56.75, 40.41), time = 27.71.\n",
            "Batch 19: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 52.05, 56.22, 57.21, 40.41), time = 28.09.\n",
            "Batch 20: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = (32.94, 52.65, 56.29, 57.35, 40.41), time = 32.66."
          ]
        }
      ],
      "source": [
        "import time\n",
        "import warnings\n",
        "\n",
        "from botorch import fit_gpytorch_mll\n",
        "from botorch.exceptions import BadInitialCandidatesWarning\n",
        "from botorch.sampling.normal import SobolQMCNormalSampler\n",
        "from botorch.utils.multi_objective.box_decompositions.dominated import (\n",
        "    DominatedPartitioning,\n",
        ")\n",
        "from botorch.utils.multi_objective.pareto import is_non_dominated\n",
        "\n",
        "\n",
        "warnings.filterwarnings(\"ignore\", category=BadInitialCandidatesWarning)\n",
        "warnings.filterwarnings(\"ignore\", category=RuntimeWarning)\n",
        "\n",
        "N_BATCH = 20 if not SMOKE_TEST else 10\n",
        "MC_SAMPLES = 128 if not SMOKE_TEST else 16\n",
        "\n",
        "verbose = True\n",
        "\n",
        "hvs_qparego, hvs_qehvi, hvs_qnehvi, hvs_qmpi, hvs_random = [], [], [], [], []\n",
        "\n",
        "# call helper functions to generate initial training data and initialize model\n",
        "train_x_qparego, train_obj_qparego, train_obj_true_qparego = generate_initial_data(\n",
        "    n=2 * (problem.dim + 1)\n",
        ")\n",
        "mll_qparego, model_qparego = initialize_model(train_x_qparego, train_obj_qparego)\n",
        "\n",
        "train_x_qehvi, train_obj_qehvi, train_obj_true_qehvi = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_obj_true_qparego,\n",
        ")\n",
        "train_x_qnehvi, train_obj_qnehvi, train_obj_true_qnehvi = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_obj_true_qparego,\n",
        ")\n",
        "train_x_qmpi, train_obj_qmpi, train_obj_true_qmpi = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_obj_true_qparego,\n",
        ")\n",
        "train_x_random, train_obj_random, train_obj_true_random = (\n",
        "    train_x_qparego,\n",
        "    train_obj_qparego,\n",
        "    train_obj_true_qparego,\n",
        ")\n",
        "mll_qehvi, model_qehvi = initialize_model(train_x_qehvi, train_obj_qehvi)\n",
        "mll_qnehvi, model_qnehvi = initialize_model(train_x_qnehvi, train_obj_qnehvi)\n",
        "mll_qmpi, model_qmpi = initialize_model(train_x_qmpi, train_obj_qmpi)\n",
        "\n",
        "# compute hypervolume\n",
        "bd = DominatedPartitioning(ref_point=problem.ref_point, Y=train_obj_true_qparego)\n",
        "volume = bd.compute_hypervolume().item()\n",
        "\n",
        "hvs_qparego.append(volume)\n",
        "hvs_qehvi.append(volume)\n",
        "hvs_qnehvi.append(volume)\n",
        "hvs_qmpi.append(volume)\n",
        "hvs_random.append(volume)\n",
        "\n",
        "# run N_BATCH rounds of BayesOpt after the initial random batch\n",
        "for iteration in range(1, N_BATCH + 1):\n",
        "\n",
        "    t0 = time.monotonic()\n",
        "\n",
        "    # fit the models\n",
        "    fit_gpytorch_mll(mll_qparego)\n",
        "    fit_gpytorch_mll(mll_qehvi)\n",
        "    fit_gpytorch_mll(mll_qnehvi)\n",
        "    fit_gpytorch_mll(mll_qmpi)\n",
        "\n",
        "    # define the qEI, qNEI and qMPI acquisition modules using a QMC sampler\n",
        "    qparego_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "    qehvi_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "    qnehvi_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "    qmpi_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))\n",
        "\n",
        "    # optimize acquisition functions and get new observations\n",
        "    (\n",
        "        new_x_qparego,\n",
        "        new_obj_qparego,\n",
        "        new_obj_true_qparego,\n",
        "    ) = optimize_qnparego_and_get_observation(\n",
        "        model_qparego, train_x_qparego, train_obj_qparego, qparego_sampler\n",
        "    )\n",
        "    new_x_qehvi, new_obj_qehvi, new_obj_true_qehvi = optimize_qehvi_and_get_observation(\n",
        "        model_qehvi, train_x_qehvi, train_obj_qehvi, qehvi_sampler\n",
        "    )\n",
        "    (\n",
        "        new_x_qnehvi,\n",
        "        new_obj_qnehvi,\n",
        "        new_obj_true_qnehvi,\n",
        "    ) = optimize_qnehvi_and_get_observation(\n",
        "        model_qnehvi, train_x_qnehvi, train_obj_qnehvi, qnehvi_sampler\n",
        "    )\n",
        "    (\n",
        "        new_x_qmpi,\n",
        "        new_obj_qmpi,\n",
        "        new_obj_true_qmpi,\n",
        "    ) = optimize_qmpi_and_get_observation(\n",
        "        model_qmpi, train_x_qmpi, train_obj_qmpi, qmpi_sampler\n",
        "    )\n",
        "    new_x_random, new_obj_random, new_obj_true_random = generate_initial_data(\n",
        "        n=BATCH_SIZE\n",
        "    )\n",
        "\n",
        "    # update training points\n",
        "    train_x_qparego = torch.cat([train_x_qparego, new_x_qparego])\n",
        "    train_obj_qparego = torch.cat([train_obj_qparego, new_obj_qparego])\n",
        "    train_obj_true_qparego = torch.cat([train_obj_true_qparego, new_obj_true_qparego])\n",
        "\n",
        "    train_x_qehvi = torch.cat([train_x_qehvi, new_x_qehvi])\n",
        "    train_obj_qehvi = torch.cat([train_obj_qehvi, new_obj_qehvi])\n",
        "    train_obj_true_qehvi = torch.cat([train_obj_true_qehvi, new_obj_true_qehvi])\n",
        "\n",
        "    train_x_qnehvi = torch.cat([train_x_qnehvi, new_x_qnehvi])\n",
        "    train_obj_qnehvi = torch.cat([train_obj_qnehvi, new_obj_qnehvi])\n",
        "    train_obj_true_qnehvi = torch.cat([train_obj_true_qnehvi, new_obj_true_qnehvi])\n",
        "\n",
        "    train_x_qmpi = torch.cat([train_x_qmpi, new_x_qmpi])\n",
        "    train_obj_qmpi = torch.cat([train_obj_qmpi, new_obj_qmpi])\n",
        "    train_obj_true_qmpi = torch.cat([train_obj_true_qmpi, new_obj_true_qmpi])\n",
        "\n",
        "    train_x_random = torch.cat([train_x_random, new_x_random])\n",
        "    train_obj_random = torch.cat([train_obj_random, new_obj_random])\n",
        "    train_obj_true_random = torch.cat([train_obj_true_random, new_obj_true_random])\n",
        "\n",
        "    # update progress\n",
        "    for hvs_list, train_obj in zip(\n",
        "        (hvs_random, hvs_qparego, hvs_qehvi, hvs_qnehvi, hvs_qmpi),\n",
        "        (\n",
        "            train_obj_true_random,\n",
        "            train_obj_true_qparego,\n",
        "            train_obj_true_qehvi,\n",
        "            train_obj_true_qnehvi,\n",
        "            train_obj_true_qmpi\n",
        "        ),\n",
        "    ):\n",
        "        # compute hypervolume\n",
        "        bd = DominatedPartitioning(ref_point=problem.ref_point, Y=train_obj)\n",
        "        volume = bd.compute_hypervolume().item()\n",
        "        hvs_list.append(volume)\n",
        "\n",
        "    # reinitialize the models so they are ready for fitting on next iteration\n",
        "    # Note: we find improved performance from not warm starting the model hyperparameters\n",
        "    # using the hyperparameters from the previous iteration\n",
        "    mll_qparego, model_qparego = initialize_model(train_x_qparego, train_obj_qparego)\n",
        "    mll_qehvi, model_qehvi = initialize_model(train_x_qehvi, train_obj_qehvi)\n",
        "    mll_qnehvi, model_qnehvi = initialize_model(train_x_qnehvi, train_obj_qnehvi)\n",
        "    mll_qmpi, model_qmpi = initialize_model(train_x_qmpi, train_obj_qmpi)\n",
        "\n",
        "    t1 = time.monotonic()\n",
        "\n",
        "    if verbose:\n",
        "        print(\n",
        "            f\"\\nBatch {iteration:>2}: Hypervolume (random, qNParEGO, qEHVI, qNEHVI, qMPI) = \"\n",
        "            f\"({hvs_random[-1]:>4.2f}, {hvs_qparego[-1]:>4.2f}, {hvs_qehvi[-1]:>4.2f}, {hvs_qnehvi[-1]:>4.2f}, {hvs_qmpi[-1]:>4.2f}), \"\n",
        "            f\"time = {t1-t0:>4.2f}.\",\n",
        "            end=\"\",\n",
        "        )\n",
        "    else:\n",
        "        print(\".\", end=\"\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "72232578-0908-4292-aca4-d52197890dd6",
        "showInput": false
      },
      "source": [
        "#### Plot the results\n",
        "The plot below shows the a common metric of multi-objective optimization performance, the log hypervolume difference: the log difference between the hypervolume of the true pareto front and the hypervolume of the approximate pareto front identified by each algorithm. The log hypervolume difference is plotted at each step of the optimization for each of the algorithms.\n",
        "\n",
        "The plot shows that $q$NEHVI outperforms $q$EHVI, $q$ParEGO, and Sobol.\n",
        "\n",
        "> **note**\n",
        "> qMPI doesn't show outperming results, comparing to other acquisition functions and randoms. However, qMPI shows more computational efficency."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649857076,
        "executionStopTime": 1668649858100,
        "originalKey": "c9560130-5c74-4b2b-b24a-fd7618ee7822",
        "requestMsgId": "d6978d53-90e4-476b-bb1d-75010f65dcd6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7fafac1b7090>"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "\n",
        "iters = np.arange(N_BATCH + 1) * BATCH_SIZE\n",
        "log_hv_difference_qparego = np.log10(problem.max_hv - np.asarray(hvs_qparego))\n",
        "log_hv_difference_qehvi = np.log10(problem.max_hv - np.asarray(hvs_qehvi))\n",
        "log_hv_difference_qnehvi = np.log10(problem.max_hv - np.asarray(hvs_qnehvi))\n",
        "log_hv_difference_qmpi = np.log10(problem.max_hv - np.asarray(hvs_qmpi))\n",
        "log_hv_difference_rnd = np.log10(problem.max_hv - np.asarray(hvs_random))\n",
        "\n",
        "\n",
        "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
        "ax.errorbar(\n",
        "    iters, log_hv_difference_rnd, label=\"Sobol\", linewidth=1.5,\n",
        ")\n",
        "ax.errorbar(\n",
        "    iters, log_hv_difference_qparego, label=\"qNParEGO\", linewidth=1.5,\n",
        ")\n",
        "ax.errorbar(\n",
        "    iters, log_hv_difference_qehvi, label=\"qEHVI\", linewidth=1.5,\n",
        ")\n",
        "ax.errorbar(\n",
        "    iters, log_hv_difference_qnehvi, label=\"qNEHVI\", linewidth=1.5,\n",
        ")\n",
        "ax.errorbar(\n",
        "    iters, log_hv_difference_qmpi, label=\"qMPI\", linewidth=1.5,\n",
        ")\n",
        "ax.set(xlabel='number of observations (beyond initial points)', ylabel='Log Hypervolume Difference')\n",
        "ax.legend(loc=\"lower left\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "originalKey": "824c329c-6c02-4f67-bce0-a4c57ea655d8",
        "showInput": false
      },
      "source": [
        "#### Plot the true objectives at the evaluated designs colored by iteration\n",
        "\n",
        "To examine optimization process from another perspective, we plot the true function values at the designs selected under each algorithm where the color corresponds to the BO iteration at which the point was collected. The plot on the right for $q$NEHVI shows that the $q$NEHVI quickly identifies the pareto front and most of its evaluations are very close to the pareto front. $q$NParEGO also identifies has many observations close to the pareto front, but relies on optimizing random scalarizations, which is a less principled way of optimizing the pareto front compared to $q$NEHVI, which explicitly attempts focuses on improving the pareto front. $q$EHVI uses the posterior mean as a plug-in estimator for the true function values at the in-sample points, whereas $q$NEHVI than integrating over the uncertainty at the in-sample designs Sobol generates random points and has few points close to the Pareto front."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "collapsed": false,
        "customOutput": null,
        "executionStartTime": 1668649858641,
        "executionStopTime": 1668649859522,
        "originalKey": "cf610a77-3e82-4c30-ac7b-f7a97fa91fa5",
        "requestMsgId": "afb07e9c-ebaf-4a8e-90e3-ca426532de20"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Iteration')"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAB8kAAAJwCAYAAAAKp1ASAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5wdVf3/8deZuX173/TeQ0uAUBNCC026SlOxN/Br4fuTryLNAiiCqIgiSFFARHondAKBQCBAIKT3vputd2+dOb8/NllYdhNSNrnZzfv5eFxhZ+ae+559yLmz85lzjrHWWkRERERERERERERERERERPYATq4DiIiIiIiIiIiIiIiIiIiI7CoqkouIiIiIiIiIiIiIiIiIyB5DRXIREREREREREREREREREdljqEguIiIiIiIiIiIiIiIiIiJ7DBXJRURERERERERERERERERkj6EiuYiIiIiIiIiIiIiIiIiI7DFUJBcRERERERERERERERERkT2GiuQiIiIiIiIiIiIiIiIiIrLHUJFcRERERERERERERERERET2GCqSi+xCAwcO5KSTTuqy9pYsWYIxhttvv73L2hQRERERERERERERERHpyVQkF/kM77//PmeeeSYDBgwgEonQp08fjjnmGP70pz/lOpqIyB5r4MCBGGO48MILO+x78cUXMcbw3//+t23b7bffjjGm7RWJRBg+fDgXXHABa9eu7dJsn/ycT7++853vdDj+lVde4Qtf+AJ9+vQhFApRVFTEhAkTuPLKKzvNZq3ln//8JxMnTqS4uJhYLMZee+3FlVdeSTwe79JzERHZnW36Lujsddxxx7Udd/nll2OMoaamZrPtbHqQ9YEHHsAYwy233LLZz506dSrGGP74xz8CcP7555Ofn9+FZyYi0jPs6DX7p1+vv/5627HGGC644IJOP3dTO2+99RYAe++9N/3798dau9mshx56KFVVVWSz2bYBCddee+32nrqIyB5lU39/9NFHd7r/73//e1tfvqlvho+v0ze9YrEYo0eP5pJLLqGxsbHtuE/36yIiXSWQ6wAiu7PXXnuNyZMn079/f775zW9SXV3N8uXLef3117nhhhs6/UNPRER2nb///e/83//9H717996q46+88koGDRpEMplk2rRp3HTTTTzxxBPMnj2bWCzWZbmOOeYYvvzlL3fYPnz48HY/X3rppfzyl79k8ODBnH/++QwePJhkMsnMmTP5/e9/zx133MHChQvbjvc8j3POOYf//Oc/HH744Vx++eXEYjFeeeUVrrjiCu677z6effZZqqqquuxcRER2Z/vuuy8/+clPOmzf2u+FTzvxxBMpKiri7rvv5hvf+Eanx9x99924rstZZ521XZ8hIrKn2d5r9k8bOnTodn3+ueeey8UXX8wrr7zCxIkTO+xfsmQJ06dP54ILLiAQ0K1SEZHtEYlEeOGFF1izZg3V1dXt9t11111EIhGSyWSn773pppvIz8+nubmZZ555hl//+tc8//zzvPrqqxhjdkV8EdlD6cpPZAt+/etfU1RUxJtvvklxcXG7fevWrctNKBERAWDMmDHMnTuXq6++um0032c5/vjj2X///QH4xje+QVlZGddddx0PP/wwZ5999nZn8X2fdDpNJBIBWovh55133hbfc++99/LLX/6SL3zhC/zzn/8kFAq123/99ddz/fXXt9v229/+lv/85z9cdNFF/O53v2vb/q1vfYsvfOELnHrqqZx//vk8+eST230uIiLdSZ8+fT6zv90W4XCYM888k9tuu41Vq1Z1KOgkk0kefPBBjjnmGCorK7vsc0VEeqodvWbvCueccw7/93//x913391pkfyee+7BWsu5557bZZ8pIrKnOfTQQ3nzzTe59957+Z//+Z+27StWrOCVV17htNNO4/777+/0vWeeeSbl5eUAfOc73+GMM87ggQce4PXXX+fggw/eJflFZM+k6dZFtmDhwoWMGTOmQ4EcaHdTLJvN8stf/pIhQ4YQDocZOHAgP/vZz0ilUp22+8wzz7DvvvsSiUQYPXo0DzzwQIdjFi1axOc//3lKS0uJxWIcdNBBPP744112biIiu6tp06ZxwAEHEIlEGDJkCH/729/apuD6pIEDB/LlL3+Zv//976xatWq7PuvII48EYPHixQBce+21HHLIIZSVlRGNRhk/fny7KSA32TS941133cWYMWMIh8M89dRT2/TZl156KeXl5dx6660dCuQARUVFXH755W0/JxIJfve73zF8+HCuuuqqDsd/7nOf4ytf+QpPPfVUu6koRUS6o639LtgZzjvvPHzf59///neHfY8//jgNDQ0qpIjIHm9XXrPvqH79+jFx4kT++9//kslkOuy/++67GTJkCBMmTMhBOhGR3dvW9veRSITTTz+du+++u932e+65h5KSEqZMmbLVn/npezUiIjuLiuQiWzBgwABmzpzJ7Nmzt3jcN77xDS699FLGjRvH9ddfz6RJk7jqqqs6nYJx/vz5fPGLX+T444/nqquuIhAI8PnPf56pU6e2HbN27VoOOeQQnn76ab73ve/x61//mmQyycknn8yDDz7Y5ecpIrK7eP/99zn22GNZt24dl19+OV/96le57LLLNtv3/fznPyebzXL11Vdv1+dtmsq8rKwMgBtuuIH99tuPK6+8kt/85jdtfXRnDyk9//zz/OhHP+KLX/wiN9xwAwMHDmzbl0wmqamp6fBKp9MAzJs3j3nz5nHqqadu9Tq206ZNo66ujnPOOWez00BumuL9scce2+rfgYjI7mZbvgsymUyn/W0ikehw7IYNGzo91vf9dsdNnDiRvn37drjBB62FlFgsxqmnntpl5ysi0t3s7Gv2hoaGDn11bW1th+M2d83d3Nzc4dhzzz2X2tpann766Q7nMnv2bD38JCLSiW3t78855xxmzJjRbtm4u+++mzPPPJNgMLjVn/vpezUiIjuLplsX2YKLLrqI448/nn333ZcDDzyQww8/nKOOOorJkye3fbG/++673HHHHXzjG9/g73//OwDf+973qKys5Nprr+WFF15g8uTJbW3OmzeP+++/n9NPPx2Ar3/964wcOZKf/vSnHHPMMQBcffXVrF27lldeeYXDDjsMgG9+85vsvffe/PjHP+aUU07BcfSMi4j0PJdeeinWWl555RX69+8PwBlnnMFee+3V6fGDBw/mS1/6Uts6h7169dpi+5tuuCWTSV599VWuvPJKotEoJ510EtDaR0ej0bbjL7jgAsaNG8d1113HiSee2K6tuXPn8v777zN69OgOn3Prrbdy6623dth+zz33cNZZZ/HRRx8BMHbs2Hb7rbUdbgAWFxcTCAT48MMPAdhnn302e36b9s2ZM2ezx4iI7O625bvgmWeeoaKiosP2q666iosvvrjdthEjRmz2M/fee++2f3cch7PPPpvf/e53zJs3j+HDhwPQ2NjIE088wWmnnbbVDziJiPREO/ua/eijj+6wLRwOd1jLdnPX3J0588wzufDCC7n77rvbrv2BtgeiVCQXEeloW/v7I488kurqau655x4uueQS5syZw6xZs7jhhhtYtGjRZj9nw4YNAG1rkv/lL3+hqqqKww8/vOtPSkTkE1RlE9mCY445hunTp3PyySfz7rvv8tvf/pYpU6bQp08fHnnkEQCeeOIJAH784x+3e+9PfvITgA6jD3v37s1pp53W9nNhYSFf/vKXeeedd1izZk1bmwceeGBbgRwgPz+fb33rWyxZsqStUCIi0pN4nsfTTz/Nqaee2vbHF8CoUaO2OC3XJZdcstUjU44++mgqKiro168fZ511Fvn5+Tz44IP06dMHoF2BvK6ujoaGBg4//HDefvvtDm1NmjSp0wI5wCmnnMLUqVM7vDY9NNXY2AjQocjS0NBARUVFu9esWbMAaGpqAqCgoGCz57dp36b2RUS6m239LpgwYUKn/e3ZZ5/d4dj777+/02Orqqo6HLtpnfNPjia///77SSaTKqSIyB5tV1yz33jjjR366ieffLLDcZu75v7f//3fDseWlJRwwgkn8MgjjxCPx4HWB1T//e9/s//++7c9ECUiIq22p793XZcvfOEL3HPPPQDcdddd9OvX7zOL3SNGjKCiooJBgwbx7W9/m6FDh/L4448Ti8W67oRERDqhkeQin+GAAw7ggQceIJ1O8+677/Lggw9y/fXXc+aZZzJr1iyWLl2K4zgMHTq03fuqq6spLi5m6dKl7bYPHTq0w5otm/4YW7JkCdXV1SxdurTTtbBGjRoFwNKlSzuMPhQR6e7Wr19PIpFg2LBhHfaNGDGi7aGkT9s0MuXmm2/uMGrw02688UaGDx9OIBCgqqqKESNGtJuZ47HHHuNXv/oVs2bNIpVKtW3vbA3cQYMGbfZz+vbt2+kImE02FbM/PRVkfn5+2/IbzzzzDL/73e86vGdTsbwzW1NIFxHZnW3rd0F5efkW+9tPmjhxIuXl5R22RyKRDtv23ntvxo4dyz333MPll18OtBbMy8vLt2k9RRGRnmZXXLMfeOCB7L///p+ZZXPX3CtWrOj0+HPPPZcHH3yQhx9+mHPOOYfXXnuNJUuW8D//8z+f+VkiInua7e3vzznnHP74xz/y7rvvcvfdd3PWWWd1ek/lk+6//34KCwsJBoP07duXIUOGdMk5iIh8Fo0kF9lKoVCIAw44gN/85jfcdNNNZDIZ7rvvvrb9n/VlLyIiO8+mdQ6vueaaLR534IEHcvTRR3PEEUcwatSodgXyV155hZNPPplIJMJf/vIXnnjiCaZOnco555yDtbZDW58cdb6tRo4cCcDs2bPbbQ8EAhx99NEcffTRHUapb3pQ6r333ttsu5v2bW6Eu4iIbL3zzjuPefPm8dZbb7FmzRpeeOEFvvCFLxAI6FlzEZHtsbXX7DvLSSedRFFRUdssIXfffTeu63LWWWflJI+ISE80YcIEhgwZwg9/+EMWL17MOeec85nvmThxIkcffTSTJk1SgVxEdikVyUW2w6YnmlevXs2AAQPwfZ/58+e3O2bt2rXU19czYMCAdtsXLFjQodgyb948AAYOHAjAgAEDmDt3bofP3bSG7afbFBHpCSoqKohGox36U6DTPvGThgwZwnnnncff/vY3Vq9evV2ff//99xOJRHj66af52te+xvHHH7/VoxO31YgRIxg2bBgPPfRQ23SPn+Wwww6juLiYu+++G8/zOj3mzjvvBGi3zqKISHeyI98FXe3ss8/GGMPdd9/Nvffei+d5mmpdRPZ4ub5m3xHhcJgzzzyTZ555hrVr13Lfffe1rZ8rIiLt7Uh/f/bZZ/Piiy8yatQo9t13352UUERkx6lILrIFL7zwQqejBzdNJzNixAhOOOEEAP7whz+0O+a6664D4MQTT2y3fdWqVTz44INtPzc2NnLnnXey7777tv1hdsIJJzBjxgymT5/edlw8Hufmm29m4MCBGiEoIj2S67pMmTKFhx56iGXLlrVtnzNnDk8//fRnvv+SSy4hk8nw29/+drs/3xjTrgC9ZMkSHnrooe1q77Ncfvnl1NTU8M1vfpNMJtNh/6e/f2KxGBdddBFz587l5z//eYfjH3/8cW6//XamTJnCQQcdtFMyi4jsbDv6XdCV+vfvz+GHH869997Lv/71LwYNGsQhhxyySzOIiOxucn3NvqPOPfdcMpkM3/72t1m/fr0efhIR2Ywd6e+/8Y1vcNlll/H73/9+Z8cUEdkhmidOZAsuvPBCWlpaOO200xg5ciTpdJrXXnuNe++9l4EDB/LVr36V4uJivvKVr3DzzTdTX1/PpEmTmDFjBnfccQennnoqkydPbtfm8OHD+frXv86bb75JVVUV//jHP1i7di233XZb2zEXX3wx99xzD8cffzw/+MEPKC0t5Y477mDx4sXcf//97aYHFhHpSa644gqeeuopDj/8cL73ve+RzWb505/+xJgxY7Y4zTh8PDLljjvu2K7PPvHEE7nuuus47rjjOOecc1i3bh033ngjQ4cO/czP/rR58+bxr3/9q8P2qqoqjjnmGKB1na7Zs2dz1VVXMWPGDM466ywGDRpEPB5n9uzZ3HPPPRQUFFBSUtL2/osvvph33nmHa665hunTp3PGGWcQjUaZNm0a//rXvxg1atR2n7+IyO5iW74LVq5c2Wl/m5+fz6mnnrrDWc477zy+9a1vsWrVqk4fUBIR2RPt7Gv2J598sm0mvU865JBDGDx48A5lnzRpEn379uXhhx8mGo1y+umn71B7IiI92fb29wMGDODyyy/fdUFFRLaTiuQiW3Dttddy33338cQTT3DzzTeTTqfp378/3/ve97jkkksoLi4G4JZbbmHw4MHcfvvtPPjgg1RXV/N///d/XHbZZR3aHDZsGH/605/43//9X+bOncugQYO49957mTJlStsxVVVVvPbaa/z0pz/lT3/6E8lkkr333ptHH320w8h0EZGeZO+99+bpp5/mxz/+MZdeeil9+/bliiuuYPXq1VtVqL7kkkv417/+tdnpyLfkyCOP5NZbb+Xqq6/mhz/8IYMGDeKaa65hyZIl21wknzp1KlOnTu2wfdKkSW1FcoDf/OY3TJkyhT//+c/84x//oKamhmg0yvDhw/nJT37Cd77znXbTP7quy3/+8x/uvPNObrnlFn7xi1+QTqcZMmQIl112GT/5yU/Iy8vb5nMXEdmdbMt3waxZs/jSl77UoY0BAwZ0SZH8zDPP5MILLySVSmm0oYjIRjv7mv3SSy/tdPttt922w0Vyx3E4++yz+d3vfsfnPvc5CgoKdqg9EZGebEf7exGR3Z2xnc0lLSIiIrIbufzyy7niiis6XQJDRET2DPouEBHZvamfFhHZM6i/F5GeQnM2i4iIiIiIiIiIiIiIiIjIHkNFchERERERERERERERERER2WOoSC4iIiIiIiIiIiIiIiIiInsMrUkuIiIiIiIiIiIiIiIiIiJ7DI0kFxERERERERERERERERGRPYaK5CIiIiIiIiIiIiIiIiIisscI5DrA7sb3fVatWkVBQQHGmFzHERHZLtZampqa6N27N46zZzwPpf5bRHoK9eHqw0Wke9oT+29QHy4iPYP6cPXhItJ97al9eK68+OKLTJ48mRdeeIEjjjgi13F2iIrkn7Jq1Sr69euX6xgiIl1i+fLl9O3bN9cxdgn13yLS06gPFxHpnvak/hvUh4tIz6I+XESk++quffjtt9/OV7/6Vd588032339/nnjiCWbMmMHll1+e01x/+ctfiMVinH/++TnNsTOpSP4pBQUFQOt/TIWFhTlOIyKyfRobG+nXr19bn7YnUP8tIj2F+nD14SLSPe2J/TeoDxeRnkF9uPpwEem+elof/sQTT3DjjTfuFkXy8vLyDkXyiRMnkkgkCIVCuQnWhVQk/5RN08oUFhbqwkBEur09aaos9d8i0tOoDxcR6Z72pP4b1IeLSM+iPlxEpPva0/rwbWGtJZlMEo1Gd7gtx3GIRCJdkCr3NDm/iIiIiIiIiIiIiIiIiEgOnX/++dx4441Aa9F/02sT3/f5wx/+wJgxY4hEIlRVVfHtb3+burq6du0MHDiQk046iaeffpr999+faDTK3/72NwBuu+02jjzySCorKwmHw4wePZqbbrqpw/s/+OADXnrppbYMm9Yff/HFFzHG8OKLL7Z7z3333cf48eOJRqOUl5dz3nnnsXLlyg7nl5+fz8qVKzn11FPJz8+noqKCiy66CM/zuuJXuE00klxEREREREREREREREREJIe+/e1vs2rVKqZOnco///nPTvdvWsP8Bz/4AYsXL+bPf/4z77zzDq+++irBYLDt2Llz53L22Wfz7W9/m29+85uMGDECgJtuuokxY8Zw8sknEwgEePTRR/ne976H7/t8//vfB+APf/gDF154Ifn5+fz85z8HoKqqarO5N2U64IADuOqqq1i7di033HADr776Ku+88w7FxcVtx3qex5QpU5gwYQLXXnstzz77LL///e8ZMmQI3/3ud7vi17jVVCQXEREREREREREREREREcmhgw8+mOHDhzN16lTOO++8dvumTZvGLbfcwl133cU555zTtn3y5Mkcd9xx3Hfffe22L1iwgKeeeoopU6a0a+ell15qN+36BRdcwHHHHcd1113XViQ/9dRTueSSS9pGhG9JJpPhpz/9KWPHjuXll19um4r9sMMO46STTuL666/niiuuaDs+mUzyxS9+kV/84hcAfOc732HcuHHceuutu7xIrunWRURERERERERERERERER2U/fddx9FRUUcc8wx1NTUtL3Gjx9Pfn4+L7zwQrvjBw0a1KFADrQrkDc0NFBTU8OkSZNYtGgRDQ0N25zrrbfeYt26dXzve99rt1b5iSeeyMiRI3n88cc7vOc73/lOu58PP/xwFi1atM2fvaM0klxEREREREREREREREREZDc1f/58GhoaqKys7HT/unXr2v08aNCgTo979dVXueyyy5g+fTotLS3t9jU0NFBUVLRNuZYuXQrQNp37J40cOZJp06a12xaJRKioqGi3raSkpMO66ruCiuQiIiIiIiIiIiIiIiIiIrsp3/eprKzkrrvu6nT/pwvPnxwxvsnChQs56qijGDlyJNdddx39+vUjFArxxBNPcP311+P7/k7J/kmu6+70z9haKpKLiIiIiIiIiIiIiIiIiOSYMabT7UOGDOHZZ5/l0EMP7bQAvjUeffRRUqkUjzzyCP3792/b/ump2reU49MGDBgAwNy5cznyyCPb7Zs7d27b/t2R1iQXEREREREREREREREREcmxvLw8AOrr69tt/8IXvoDnefzyl7/s8J5sNtvh+M5sGsVtrW3b1tDQwG233dZpjq1pc//996eyspK//vWvpFKptu1PPvkkc+bM4cQTT/zMNnJFI8lFRERERERERERERERERHJs/PjxAPzgBz9gypQpuK7LWWedxaRJk/j2t7/NVVddxaxZszj22GMJBoPMnz+f++67jxtuuIEzzzxzi20fe+yxhEIhPve5z/Htb3+b5uZm/v73v1NZWcnq1as75Ljpppv41a9+xdChQ6msrOwwUhwgGAxyzTXX8NWvfpVJkyZx9tlns3btWm644QYGDhzIj370o6775XQxFclFRERERERERERERERERHLs9NNP58ILL+Tf//43//rXv7DWctZZZwHw17/+lfHjx/O3v/2Nn/3sZwQCAQYOHMh5553HoYce+pltjxgxgv/+979ccsklXHTRRVRXV/Pd736XiooKvva1r7U79tJLL2Xp0qX89re/pampiUmTJnVaJAc4//zzicViXH311fz0pz8lLy+P0047jWuuuYbi4uId/p3sLMZ+cky90NjYSFFREQ0NDRQWFuY6jojIdtkT+7I98ZxFpGfaE/uzPfGcRaTn2VP7sj31vEWkZ9lT+7I99bxFpGdRXybbS2uSi4iIiIiIiIiIiIiIiIjIHkNFchERERERERERERERERER2WOoSC4iIiIiIiIiIiIiIiIiInsMFclFRERERERERERERERERKRLXXXVVRxwwAEUFBRQWVnJqaeeyty5c9sdk0wm+f73v09ZWRn5+fmcccYZrF27dovtWmu59NJL6dWrF9FolKOPPpr58+dvUzYVyUVEREREREREREREREREpEu99NJLfP/73+f1119n6tSpZDIZjj32WOLxeNsxP/rRj3j00Ue57777eOmll1i1ahWnn376Ftv97W9/yx//+Ef++te/8sYbb5CXl8eUKVNIJpNbnS2w3WclIiIiItID+b7P3HeX8/6MRWTSWXr1L2PCkaPIK4jmOpqIiHyGlniKB+58ldnvLMVaGLtff874ymHE8sK5jiYiIp8h3pzijWnzWLW8lmAwwNj9BjBqr744jsl1NBEREdlOTz31VLufb7/9diorK5k5cyYTJ06koaGBW2+9lbvvvpsjjzwSgNtuu41Ro0bx+uuvc9BBB3Vo01rLH/7wBy655BJOOeUUAO68806qqqp46KGHOOuss7Yqm4rkIiIiIiIbNdbFufGKh5jz9lKyWa9t+39veYmv/78TGH/4iBymExGRLXnjpY+45hcPkEhksBu3vTdrGQ/++w3+94rTOHjyqJzmExGRzZv5+kJu+eNU6jbEMYAFHv3vm4zaqy8X/PREiopjuY4oIiLSrSSTSdLp9E5p21qLMe0fYguHw4TDn/1wckNDAwClpaUAzJw5k0wmw9FHH912zMiRI+nfvz/Tp0/vtEi+ePFi1qxZ0+49RUVFTJgwgenTp6tILiIiIiKytRYtq+GF6XN55rF3aFjXRElBkNJgFNc4eFmf+g1xbvrlw1x8/bkMHdMn13FFRORTVi2r5aqf308ylSXgGhyndXU53/dpSWS4+pL7+cvd36HPgPIcJxURkU1S6SxvvruEZ174gDffWAgZn6qSKPnBINZaUsks77+9lD9d/Tg/+82ZGlEuIiKylZLJJIMG5LNmnffZB2+H/Px8mpub22277LLLuPzyy7f4Pt/3+eEPf8ihhx7K2LFjAVizZg2hUIji4uJ2x1ZVVbFmzZpO29m0vaqqaqvf0xkVyUVERERkj5XJZLn/yVk88NQ7NDcnaW5KYmIBksZQj0dvzxJxHUor8qlZ28jU+99SkVxEZDd0999fJJnKEgwYjHHatjuOQ9D4pNIed938Iv/v12fmMKWIiGxSWxfn6r88xbzF64g3J0n7Pk4QlmWSlFmPymCYSDSIMfDR7BXMeX85Y/bpn+vYIiIi3UI6nWbNOo+lMwdSWOB89hu2QWOTz4DxS1i+fDmFhYVt27dmFPn3v/99Zs+ezbRp07o00/ZSkVxERERE9ihe1ueV5z/k+afeZ87SdawnSzgcIOQYAp7FCThkfEuTgQU2SyRhKQw4RKJB3n51Hpl0lmBIl9EiIruTWTMWA7QrkG/Sus1j1puLd3EqERHpjLWWG/7xPB8tXEtxYYx4XQtBYzAGfKAmmyHsuBQHgoTCAZoaE7z71hIVyUVEdmPJVIY33lnMrA9XkM54DOxbxqSDhlFZVpDraHu0/AJDfkHXzsTi09peYWFhuyL5Z7ngggt47LHHePnll+nbt2/b9urqatLpNPX19e1Gk69du5bq6upO29q0fe3atfTq1avde/bdd9+tzqS7eyIiIiKyR7A2g581/O2GZ5n2/If41qcharBY0i0ZUrZ1BdustVjAWPBdg+f41Gc8XMdQ6Xl4WZ9gKLfnIiKyJ/E8nw/fXc6a1fVEIkH2GjeA4pK8dsekMx5buvVjgExm50w1KCIim5dKZpj5xkIWzVuLMTBybF+ipVE+mL+agvwIwYDDxstwjDG4QMb3qc2kKXIDG9c7NWTS2VyehoiIbNSYSvH84oV8VFuDawz7VvViSKSY629+jmUrN+D7Fgy8MmM+Dz41i2+ecyiTDx6R69iSQ9ZaLrzwQh588EFefPFFBg0a1G7/+PHjCQaDPPfcc5xxxhkAzJ07l2XLlnHwwQd32uagQYOorq7mueeeayuKNzY28sYbb/Dd7353q7OpSC4iIiIiPZa1GUg+jU08At4SWuIe/cpLGDp0LGvrqlmXiONicF1DJu3hbRyAaAC7qZGAQ8D3SVtLKhYmHA3m6GxERPY8H81ewa1/fo5Vy2vxPAtY8vIjHHPiPpz5pUMIBFwAqnsX0zh3DdbajQWVj9mNDz9VVRft+hMQEdmDLZi7mj9f8wRrV9e3FcIff2AmwcoYKTyKCiIYDMGQSyqZxXFb+2/HGFLWJ2stjt/a9/fqW5q7ExEREQDeWrWSK156nnXxONa2FsP/++EHeA1ZStdBdWE+wY3X57611Ne3cNM/X6aqvJDRw3p9RuuyM3jWx7Offdy2trktvv/973P33Xfz8MMPU1BQ0LZmeFFREdFolKKiIr7+9a/z4x//mNLSUgoLC7nwwgs5+OCDOeigg9raGTlyJFdddRWnnXYaxhh++MMf8qtf/Yphw4YxaNAgfvGLX9C7d29OPfXUrc6mIrmIiIiI9EjWZrCNv4bUs7SWvKOkk00celAN+49bzr8fPJL575e3He8GHLysB9aCMW2Fckvr/zi+JRN0qalpoqJi66eTEhGRrZdMZkilMuTnR1i+uIbrfvkIjfUtFBbHCIUD+L5Pc1OSh/8zg0zG40vfOgKAk79wINf96hE8z28rnG/ieT6OaT1GRER2jdr1TVz/y0eorWmiuCSPQLC1b86ks6yoaaYlYrBlBRgXCgqjpFNNWN9inI+vw31radqQoKg4j4MmahSiiMjOtGZVPS89M5u3ZyzC83yGj+rNEceOZfjo3gAsb2jgFy88y4ZEgrJYjIDTOsqgoSnBKuJkBwXoVWvaRhw4xlBSHKNmQzNPvfiBiuQ54mPx6doq+ba2d9NNNwFwxBFHtNt+2223cf755wNw/fXX4zgOZ5xxBqlUiilTpvCXv/yl3fFz586loaGh7ef/9//+H/F4nG9961vU19dz2GGH8dRTTxGJRLY6m4rkIiIiItLtWWuZ995yXn/+Qzasa6S4rICjT1hJn/JnweSDiWGxNDQkgQAlxQlOP+llXl5wMnWJAC6b/o7beEvOWiwGDJi0j+9ZYvlhAkGXdetVJBcR6WoLF63j8Sfe5a2Zi/E8n8LCKCELdXVxKqsK20aHO45DYVGMpsYEzz35HlNO3o/K6iKOPGkfXn52Nm++voh0xmPjPTt8H4yB8QcM4uhT9svhGYqI7Flemjqb2vVNlFYU4Dgfz/ARDAUozY/QnEpSXx+ntCyfgqIoiZY08eYUxrN4DgQxNNbGicXCfPV7R1JYFM3h2YiI9GzvzVzCn3/7BA31LQQCDsYYViyp4dUX5vD5Lx/KSWfsz6PzPqI20UJlXj7OJ2ZuyqSzBDKQDHvURtJUJT4uUBpjCIcCzHx/Gb5v230fyJ7D2s8uqkciEW688UZuvPHGrW7HGMOVV17JlVdeud3ZVCQXERERkW4tk87yj989yWvPvE86ncWY1gvncWNfoCiUIK+ogtaVDFv/x1pDU3OMwoIWjtx7Bfe/MRDP2rb9zsbKim8tjmcJuy5FZTFC0SCpVJZIRNOti4h0pffeX851f3iKpqYEkXAIN+BQW9tEXW2coGPwrcX91BTq+QURatc389b0BZxw2ngcx+HyP5zLXX99gacefpv6+gQApSVRjjtlP8777pFt/buIiOx8b762ACfgdFoQKQwGCSSSNDYnKSqJ4ToOlb2KaGpIUFffgpf1KDQuhx0xjGM/ty8jxvTJwRmIiOwZGupbuOn3T9HYkKC8sqDt4VRrLU0NCf5zx6sMGlrJy8uWEHCcdgVyaB1wYDD4QF24fZEcWguZvrUbC5wqku9qPj7bNjn61rXZU6hILiIiIiLd2iP/fJWXH59FNC9MYUkMYwyBQJrK6maaGiCVbqSssggwxPLCNDcm8P3W6R4HVzdQ7AZo8LJ4tK6nZQ04LpT1aaG6NEggE8WriVFT28zAAeUMGliR2xMWEelBMhmPm//+As1NScrLPr4pFwq61Nc2k/FhQ0uKivz2IwiNMRhjiDen2rY5jsOXvncUX/reUTTUxbG+pbgsf5eej4iItEols7ibGTFojKEkA8n8ABvq4jiOQ8B1SHse+UVRDhk3iAu+cgSxWHgXpxYR6ZmyGQ+gbemLT3rtxY+o2xCntCyv7VocWvvqwuIYNesaef6p98kM8nBMx4dOw6EAG0ck4JuOI4ZT6Sx7j+qD6+qBVdn9qEguIiIiIt1WS3OS5x56m0DQJZb/8U00a13AwQ1kaW5IUFyWj+u6FBXFaGlOkc36gCWbDdAnFCGaTFOTTmHDLoVDNtD3kJVEy1IYx4JvSK6Lkf/6YE475ThNDyYi0oXefmcJa9c1UlQUa3dTznUdXNclm/VoTKQpy4u0G7Xiea39eHllQaftFpXk7ezoIiI9XmNDgvVrGwiHg/TuV7pN18EDh1SwasWGTvdZa3E9OOWQUZQOLmPamwuIt6Tp16uEIw8dwUH7DVIxRURkB1lrmfnKPJ59cCYLZq8AAyP27s8xZ+zPvgcPbTtu0bw1WGtxNtPvhkIB5ry/gr5j+zBvfQ2JeBpjIC8SoiAaJj8vTG19nKz1ycu0LznGW1I4jmHKxNE79Vxl8zxr8bZiuvNtbbOnUJFcRERERLqtRR+tprEuTmFxrN12z3OZP68Pe++ziGQiTTa1ATcSJByOUFFVSEPdBjIZw9tvl1C7rgk34HDwiD6c+MM+PLX+dhKpBNmWANZzMAGfSHUzQ7+4mL4jvBydqYhIz7R6dT1YS/BTo1qMMeQXRKivi+P5lqznEwq0HmOtpbG+hcKiGAccMiwHqUVEerb6ujgP3DWd116aSzKRxnEMfQeUc9KZ+3PIpJFb1cakY8cy47X5xJuT5OW3n3q3qSFBNBri2OP3YcDgCs44fr+2fdZaUukZ1Dc+RCr9Lsa4RMKTyI+dRjA4pEvPU0Skp1lf08SHH64km/VY8PZSpj0yCy/rEYkGwcI7r81j9luL+fw3J3HSuYe0vsls+QEoC6wPZamdtYpkNEuKLI41NCfT1DUn6FVSQKQwhNeUIrA6S73fgnEM6bRHwHU48ci9OGS8+m/ZPalILiIiIiLdlu/5WNv533TvzhzCuP3n06dfEuPEwW9dmTwvEibaK8D6DaMZMGIKQ8YG2XvcQEbv24fbl15OOArF0d4kwmk83yfgukRjQZr9Ol5Z/yD9Yxe3G+0oIiLbLxwOYG1rUeTTfWtxSR7NzUkyGY+W5hQmFsLzfJqbkoRCQc766mHkF0Q207KIiGyPxoYE1/ziARbNX0skEiQvP4znWRbPX8tN1z5FU0OCKSfv95nt7D1uAMedPI4nH5pJsqWJSCyItZBMpAmGAnz+y4cwYHD7ZYystTQ130JD881Ym8KYMFifpuydxBMPU1b8S6KRI3bSmYuIdF/JZIbb73yFV1+bT0tLGi/jEW9KEAoa+pXkE3JaR4nnF0VprItz/60vM2b8IAaN7MXIMX145bkP8Ty/wywe1loaTJa6ogCxJPSKxFjnJrAGjA8JL8uSunqqCvP57mEH4PdNM2PWYjIZjyGjKjj68FEcuM9AzciXQz4Wn64d+d3V7eWSiuQiIiIi0m31G1JJNC9ESzxNQdHH69W6rschEz/AWvB9Q8DZdAFvgRYcU0zVsN/wtdED2t6zuPkD6tLribqFBByXgmD79W+jJp/ViSWsT62kMtJ3F5ydiEjPt+8+AwhHgsRbUuTntS94O44hEgtTGQvjxtPEm1M4jsPQkb05+fMHcOChGkUuItLVnnr4bRYvWEdJWR6BjTN4BIFINEj9hjj33fkqEw4bTnHplpe1MMZwztcnMnhYFVMff5clC9fhGNjvgMEcc9K+jJswuMN7UunXaWi+GXAIuL3atltr8fx1bKi/guqKsbhueVeesohIt7NqxQZmzVhMIpGmvKqQ6TMX8+bMxUQjQcpK86ldWw++Je06LE+mGRAJE9hYqC4ojlGztpGXn3yXQSN7cdDE4Tx07xusX9NASXl+W6HcWkv9hjjxChc35FKaHwMP8myIGjdB3GRwjCGUcPjSfvvwtYMOgIPgG2cdmsPfjMi2UZFcRERERHapTDrLrJfnsPD95QAM3WcA+xw2gmBo2y9NS8oLmDB5NM8//DaRaLCtjeEjlzNo8Go21ESJxKJUVDlAGjBABEhgMjMh+HGRvMVrwiOLazrP4ZogKZugxWvc5pwiItK5Xr2KOeyQYTz3/IcYDLFYCGMMnufT0NBCLBrkf340haGDKlm/rpFIJEivvtu2Lq6IiGwdL+vz0tQPCASctgL5JxUWR9lQE+eNafO2ajS54xgOOWIkhxwxkmRyYzElvPlr/uaWB7A21a5ADq0Fd9epwPPX0pJ4goL8L2/7yYmIdGPWWpYsreGttxYz/eW5rFi0HjI+rmNI+z5N+JSU5JG/cXmLdCqLYwyOgbS11Gc9yjfeLzHG4LoOS+auASAvP8IP/u8kbvj1o9Ssb2w7xvctsfwQgV4RImG3bdanEj9MiR/GbhxNvK4xTqI+vat/JbKVfCyeRpJvlorkIiIiIrLTJbwUb9bO4YPli3njsVm0TI/jLrcYHIwx9BlaxYW/O5d+w6q3ue2zvnskK5fUMO/95RgDwVCAIUPnAz6OG6G0sgScT93k85LY1FRM7PS2TXmBQlwTwLNZAibY4XM8m8E1AfLcwm3OKCIim/fV8yfieT6vvb6A2tpmjDFYLEWFUb503mGM228gAIXFsdwGFRHp4eLxFPHm5GYL2Y7jYAzUrm/a5rYjkY7X15+WTs/CmM6X0TDGASypzAcUbPOni4h0X4lEmr/e/DxvvrmY+vo46VQWDARdl6rCCJlkBr8lRf2GOJFoiGi09aFTrMUYB2MtjdlsW5EcwPctoU/0y8NG9uI3fzqPV1/8iPdmLiGb9Rg6sheHHjmKC25/lKzndchlaC2aW8C3PadoKnsWFclFREREZKd6p24+f1/4CDXJeprqWvD29XH3NsSWhah6Jg+/wWPZ3FVc94PbufLuCyko2fLUjZ9WUBzjp9edzbSn3+eVJ95jw/pGqnobIrEohWVlOBvX3srYLL71cY3bWgT369q10y82nJJgBbXptRSYknZr41prSXrN9IuNoDzcZ8d/KSIi0iYSCXLB94/hcyftx8y3l5BIpKmqKmLCgUMo0JrjIiK7TCQSJBBwSaezne631mKtJS8/vJMSuIC/xSMMHUe4i4j0VNZabvrbc7z62gLCoQBe2iPgOBgHsr7PmoYWwoHWUd7WWhrq4kSjIWIFEZKJNNjW+fS8T9SwPc8HC+M+tXRRYXGM408dx/Gnjmu3fVS/Kt6cv4zOhgtkPR/HwPA+FV1/8tIltCb5lqlILiIiIiJdwlpLKpkhEHAJBFtvXi1qXsWf5v+XeDZJIO7ABp9g0IGgIT4kzZrjLL0fKqC0sog1S2t47Yl3mHLuYdv82dG8MMecvj/HnL4/AH5jEpKPgDEk/TR16SaSXhqLxWCoCKYwzph2o1BcE2BS5Rk8tuoWmrIbiLoFuCZA1mZIek1EnDwmVpzWrnguIiJdZ8CAcgYM0DqzIiK5EgoHmHDYMJ594j38gkiHpS3izSnC4SDjDxq6Uz4/Ej6M5pb/YK3tcM1tbRaDQzi8/075bBGR3dGSJTW89dYS8mIhshkPa8F1DRgIOJD1LRnPB9M6sjuZyOB5PgWFURrr4mQzHrgOQbe1T81mPOpqm6nqU8ohx4zdqgwnHTiKdxatpLElSWHs4wdYfWvZ0NRCRXE+E8cM2innL7KzqUguIiIiIjskk87y0uPv8vzDb7N2RR2u67DvIUM59swDeCY0g6ZMC+WhItY01QDg4ECm9d8S/bMke2eJrgpijOGt5z/YriL5p5nIsdjkk6S8etakknjWxzUODg6uyZD2Pf6zBo6PrGZQ/sdrHo4oHI9jHF5e9xC16dV41sM1AXpHh3BE5Zn0zxuxw9lERGTnSWeyLFpaQ9bz6durmOJCTdEuIrItjj91PG+/sYgNNU0UFEUJh4P4viXelCSdynL0ifvQd0DZTvns/NjptCSewPfX4zjlGOPg+Rbfz2BMLQG3H7HIMTvls0VEdkfvzFpKOpOloCCfhlRL68aNzxCZjWuOe76Ps3G5IqzF932CwQBVfUpZ0lhHQ7khW2BYbjMU1HqMLC/lRz//PAVbuZTRIaMG8MXD9+E/095lbX0zoYCLby1Zz6e0IMbFn59MfnRnzTAiO8qzFq+Lp8Pv6vZySUVyEREREdlumXSWv1z5EDNe+AiASDRIJp3hlafeY+b0uSQuThIJt66H5fsWPjEixGTARiwtgzJEVwVxXIdkS7rDZ1jrQ2YmpN/A2jQmMBDCR2Kc4s0HC+4LkeNINf2HfMcnZcOAT8TJEDAeHyb78XJDEfXLpvKz0V9u99ZhBfsxJH8fViUWkfCayQ8UUR0ZqBHkIiK7Md+3PPrsezz23PvU1sWx1hKNBDn8wKGce+qBFBZEcx1RRKRb6DugjJ9cdgq3/ulZli+poakhCVjy8iIcfeI+nPXVw3faZ4dCoyktvoy6hl+Ryqwmkc7geR4WQ2NLGXWJb3JsSZRIaKdFEBHZaeJNCaY/+yEfzlyC53kMHtmbQ6fsRXl10Wbfk0xlgNaCeHDjjH32E7dWDGCNoTAcpK4lhXEMnm8hk2VFLMm6vkFMwBBxXTCQqHRYlBdlvt/MAKq2KrcxhvOP3p99BvXiqZlzmbtyPaFggENGDeC4cSPoVdrZROwi3YOK5CIiIiKy3V58bBYzXviIvIIwkejHd6vyraW2von6uua2P/jCkSDpxMdTnpuNjz/7gda1Db2sx4ARvdu1b71abONlkHkPyIJt/QOQ+D+g4CJM+IhOcxnjMNd+kdfq3mdSwRKK3AQAcT/CzMRQXmoaSzTgMadxKasSNfSOtp/e1zEOfWM7ZxpJERHperffN51Hpr6LcQz5eWEcY2hJZnjihQ9YvLyWy354InkxjXAREdkaQ0f04td/PI857y9n9co6QqEAe+03gJKy/J3+2bHoFKbPjfH2/NupLl6FIcjidYN4a+FQ4ql1vDF/KpeefQzhoG5ri0j3sfij1dxwyX9Zt6q+dUkJ4M0XP+Lxe17nGz89kQMnj+r0fb17FQOt64jH8sIEgg7ZjE8g4IBpnfI86DqUREKkExlipXkkkxmaIx5ryj2ikRC9SwsJuA7QukxeTUuCa194hdHVFfQu2roCtzGGcUP7Mm5o3674dcgu5G98dXWbPYWuJkRERERku1hreeGRdwDbrkAOrX9AFRfmUb+hkabCFvKLouQX59Hc0ILvWVzXYI0FA8E6l+aGFkKRIIefPP4T7fsbC+QzwZSA2bj2lfXAr8U2/gaKKzDBMZ3mq0k382TDEN5J7E11qBGDZV22iLQNAhByDIlMippUQ4ciuYiIdB+Ll9fw5IsfEAoHKMj7eJ3EwnyXaDjI7MVruOWpNzhiwnBGVJYTUWFFROQzOY5hzD79GbNP/136uRuaWvjzY4uIJw+irCDaNptTXgQCbpYZc5fz5FsfcerBW7eWrohIrsWbktxwyf2sW1lHSXkBbqC1YO37lrqaZm6+6jGq+pYwYFh1h/ceeMBgSkryqK9vobQkj/KKQtataSCb9TAbp1gPWWisT7DXqD786BenUN/Ywl/feovalcuoLshvNyueMYayWJR1zXGe+mg+X5swvsNniuxJnFwHEBEREZHuKZXIsHbFhg4F8k0Crkt4VgjP90l5GSKxEEVlBVhryWSyZKI+phnS0xJ4WY+TvjqJ4fsN+LiBzMzWEeSfLJADGBdMBdgmbOL+zebLC0RxjUPKOqzMlLEiU95WIAfI+h6ucckPaApeEZHubNqbC0mlM+R/aqR4xvgsL0iwrHeaWz58hwvvf5Rz7ryXu956F8/vSeMfRER6jhffX0hTIklpfrTDckfhYAAMPPHWR9getB6qiPRsbzz/IetWtS+QQ+vDSKUV+cQbExsHIHQUi4X5+lcnEYkEqaltwreWkvJ8AqEAHpaQ41BVUsBpZx/E/7vydMrK8xkyuJLliUbCgUCny8Y5pnVevw/XrNtZpyy7EQ+7U149hR6fFhEREZHt4gYcHNchm8l2ut9aS2RWiKKj8qjLayLuJYiWhSmMWJqSLfgtPkVPhxgzZiDHnHUwE6bs3f4PuPSbQLZ9gXwTY8DGIPUa1mYwJtjhkDGFAykLF1GbaqQ0VNAhW1M2waD8XgzM6/i0toiIdB+ta5DT7jski8/caBPNbhbjgZOFgnCY2ngLf3n1DdY3x/mfSQd3euNQRERyZ9WGRqxtLR51JhIMsKauiVTGIxLSrW0R2f198NZirLXtCuSbGGMIhQO8+/rCzb7/oAlDKCqM8tgTs3jv/eU4OAwcXMFhBw9j4mEjqKwqIhRu3x+6jrPFh4ksEHQ0hlZEVxIiIiIie6DlDQ0sa6wnEggwtqKKcGDbLwuDoQD7HjyUaU+/T36h7VBoSCczBE2A7/Y7lWXVa3lu7Uw2pBuJ5oXZv9cojioZx6jjBhDN76QIDlibZssPpzqAt/HVsUgecoOc3ncS/1j0GHXpJgqCMQLGJet7NGbjhN0gZ/Q9AsfoD0MRke6ssCACpvUBqE3fReuDaZrdLEHfwfdb120MB1zCgRiNyRQPz57DCaOHM7xSy22IiOxOIsHW6/pP9umf5PmWSMgl2EmxSURkd+T7rWuQb5YBL7vlWY5GjerNqFG9icdTpNJZCgsiBALuZo8/eGB/7q59t9O+dNOMSuP79dnaU5BuzLOtr65us6dQkVxERERkD7KisYE/vjGdN1auIJXN4jiGqrx8zh67N2eOHouzjSPqjj3zAN55dT51Nc0Ulebhuq1PK6eTWRrrE4w9YBB77TeYfZyhnND7YOLZBAHjEgt0Xhj/JBMYgDWmdQ1y09kffy3gjgDCnexrdWTlOHzrc/+Kl6hLNwEWg6E8XMTZ/Y/hwLJR23S+IiKy+zlov0E8/tz7JJIZYhuXAFkfTGGsabshWfCJB7IKwiHWNsd5bv4iFclFRHYzBw7vx39ffY9kJks01P5BWGstqUyWY/YbhqsRkCLSTQwe1ZvXn/8Q37edzpKRSWUZvnffrWorLy9MXt7m74FsctKYETz2wUesi7dQkRdru9fj+T7r4y1UF+Zz9Iih23YiIj2QiuQiIiIie4i1zc388KnHWdrQQEE4RFkshmcta+PNXP/6azSmUnxj3P7b1OawsX351s8/x23XPkldTTNsnM4rEHQZs/8gvn/5aTgbb2C5xqEwmLf1jYePhPg/wK8FKlqnWN/EtgAGEz15i1PlGmM4pvoADivfm1n182nOJigO5rNP8VBCbsfR5yIi0v2MGlrNIfsP4aXX55HN+uTnhUg7HlhLNmsJhVwKP1EkN8ZgraWmOZ7D1CIi0pmxA6oZN6QPb8xdhrWWaCiIMYaM51HXnKQoL8LJE8bkOqaIyFY79NixPHbXdOpqmimtyG93D6OxvoVQOMgRn9uvSz9zYGkJvzh2Mr959iXWbbzmtbTOx9ersIArjz+K4uhnD16Q7s/f+OrqNnsKFclFRERE9hD3fvAeyxobqMzLaxt54QLlsTzqEgnunv0uJw0fQXV+wZYb+pQDjxjFqP0G8Mbzc1i1tIZgKMBeBw5m9LgBbQXy7WGcIij4X2zjr8GuBRvZmLi1QE74aIicuFVtRQNhDi4fu91Z3qlZySNLZ/Ne3WpcYzikciAnDxjL4MKy7W5TRES6hjGGC75yBEX5EZ5/bS61dXGIWPwgFMZCVJQWEHA//j5qXZ/R6MagiMhuyHEMF39+Mtc+8BJvLVpKuHgJpX3XEYym6OPlMbn/0fSrys91TBGRrVZaWcg3Lj6Rm3/9KDVrGwkGXYxjyKQ8QuEAp31tImP3H9Tln3vo4AHccc4ZPP3RAj5cuw7HGPbr24ujhw+hMKLrYBFQkVxERERkj5D2PJ5aMJ+wG+h0asKiSIT18WZeWLKYs8fuvc3tFxTFOPq08V0RtR0TngjF5djEA5B6FciCOxITPQUix2PMzh8NfteCmdz80XSSXpaQ42Kt5Z6F7/D48g+5ZL9jmdRryE7PICIiWxYOBfjG2Ydxxgn78cG81TyzZCFPL1tEZWE+gU9977VkMoQDLkcM7fqbkSIisuMKYxEuPusQ7pz/BqtTi7HWEnBDBN04c7xHaFo2hzP6XkA0oGK5iHQPB0waSXXfUp5/5G3enb4Qz/MZvldfjvjcfowZP3CnfW55fh7n7r/PTmtfdn8+Bo9tW1pxa9rsKVQkFxEREdkDxNNpWrIZQm5na3uDYwwGQ21Lyy5O9tlMcDQmOBprPcADglucYr0rvV2zgps/mo61UBX5eFo0ay3rk3GumvUsI4srqYpu2+h7ERHZOUqK8jjsgKGMHtOHRfc3srBmAwXhEHmhIL61NKXSpLJZjh05jLG9qnIdV0RENuOFtfdR6y0iP1hI0AkRDLT+HZP1MyxvmcsL6+7jhN5fzXFKEZGt129IJV/50XHwo1wnkT2Jb1tfXd1mT7H981+KiIiISLeRFwoRDQRJe16n+31rsUBJNLprg20DY1yMCe2yAjnAI0tnk8xmKQ5F2n2uMYbySB516QTPrJi7y/KIiMjWKY1F+d0px3Ho4P5krc+a5jjr4y2EAi5njdubi4+euEu/T0REZOvNr1nG9DWvUNecZcWGZpbU1LG8tp6WVJqAEyToRPiocSaNmQ25jioiIiLdmEaSi4iIiOwBQq7LMYOH8u/Z7+H5focp1xtTSWLBAEcM1NSzn/TuhlWEXLfTQoqzcdsHdWt2dSwREdkKvQoLuPaU41lcW8eCmlqCrss+vaspie2+D4SJiOzpVtU3ctUzD1A6NEE2E8E1Bgu0pDMk6xrpVVxALBwlnm1gXXIZhcHSXEcWERHZbXk7Ybr1rm4vl3rMSPIlS5bw9a9/nUGDBhGNRhkyZAiXXXYZ6XQ619FEREREdgtfHLsXfQsLWRePE0+n8a0l43nUtrSQ8Ty+OGYv+hQU5jrmbsU1DlucRcq2HiMiIruvQWUlHDNiKIcPGoBrfTLZbK4jiYjIZvxz2tusb4zjGAfXbZ3ByTGGoOtgrWVdYxxrW6/Qjel8KSkRERGRrdFjRpJ/9NFH+L7P3/72N4YOHcrs2bP55je/STwe59prr811PBEREZGc61NQyHVTTuD611/lnTWraY6ncIyhLJbHF8fsxbl77ZPriLudgyoHcN/id7HWdhhN7vk+xsC48r45SiciIltjXX0dd7zxEB9m3sMLpTDZAAP9YZy93+cY2WdgruOJiMhG9S1JXp67BOuW4meDOG4WPxsCwNrWmZwynkdDqpGCcB69IgNzG1hERGQ3p5HkW9ZjiuTHHXccxx13XNvPgwcPZu7cudx0000qkouIiIhsNLC4hBuOO4lFdRtY1tBA2HXZt7oX0WAw19F2S6cMGMtTKz5ifTJOeSSvbYp1z/dZn4rTK1rIMX2G5ziliIhszsra9Vz+6rUk8+shYDCegx/KsMidzTWzFvC95Lc5YMjoXMcUERGgpilOKpslz4nRvL4vRb0W4ZssmYyD7/sAOK5HPJVmdOQwYoGCHCcWERGR7qzHFMk709DQQGnpltelSaVSpFKptp8bGxt3diwREekC6r9FdszgklIGl2j9vs8yrKiCn+17NFfPeo51iWaMaR3FYgz0ihby6wNOoDAUyXXMbkd9uIjsKje+9k+SBfU4ySCONeQHEwA0JcJkY0lumf1Pxg/6NY6jpTO2lvpwEdlZCiJhXMch4/vUrRiBCbQQK1lDMOKDNWAs1jesX1jGIzN99v7+OoYNrMx17G5FfbiIyJ7Ftwbfdu3I765uL5d6bJF8wYIF/OlPf/rMUeRXXXUVV1xxxS5KJSIiXUX9t4jsKkf2Hsao4iqeXjGXD+rWEDCG8RX9OLr3cIrD0VzH65bUh4vIrrCqroaVoYU4WRhetIrBRSvJCyYBiGcjLGyoZp4HL3/0NkeM3j/HabsP9eEisrNUFeWzd79q3li4jFgon/emDyVSWESv/rWEohmSySDrV5RTtaY/DbUJbrv3NX79/07psCySbJ76cBERkY8Za63NdYgtufjii7nmmmu2eMycOXMYOXJk288rV65k0qRJHHHEEdxyyy1bfG9nT8/169ePhoYGCgsLdyy8iEiONDY2UlRU1KP7MvXfItJTqQ/vmecsIrveSx/O5JbVN3NA0WIGF63BAmmvdaxAyM1igEXxCmKN3+EbEz+/w5+3J/TfoD5cRHauWUtX8bP/Pk1jS5KWxhSOMRjHkMVigV42Qm8bI5HMkE5n+e3PTmNw/4od/lz14T37vEWkZ9tT+vBtsel38tLsPuQXdO2sWc1NPpPGruwRv+/dfiT5T37yE84///wtHjN48OC2f1+1ahWTJ0/mkEMO4eabb/7M9sPhMOFweEdjiojILqb+W0RypSa1isbMBsJOlF7RgTjGzXWkbkd9uIjsCuFgkKpwAwOL1pDxXTL+x7dAElmXgJNlYP56EpnlOUzZ/agPF5Gdad8Bvbn0lKO46uEXaGxK0roahiWAQ6UNU21bZ3IKhwI0x1OsrWnqkiL5nkJ9uIiIyMd2+yJ5RUUFFRVbd6GzcuVKJk+ezPjx47ntttu0ppiIiIiIdJm1yaW8sPa/rGiZT9ZmcIxLWaiaQytOZmShpukVEdndjBs0ircbN+AYn6TfsSCQtS4hsgzttSYH6UREZHMOGtqfK044kv/350cIRF3CToBCggT4+F5v1vNxHUMsGsphUhHpSeLZOIuaF5O1WXpHe1EVqcp1JJEd5uHg0bW1Uq9LW8ut3b5IvrVWrlzJEUccwYABA7j22mtZv359277q6uocJhMRERGR7m5dcjn/WfYHmrL1RJw88twYnvVYl1rBYytvIeunGVt8SK5jiojIJ4QCQfrFwvjWAWNpt9icAYwFL4gbqM1VRBER2YwxQ3szpLiE1esaKC1pfdAp5XhkHUvANzQ3J6ksK2D00F45Tioi3V3Wz/LE6qeYXvsGcS+OtZawG2J4/nDO6HsqZeGyXEcUkZ2kxxTJp06dyoIFC1iwYAF9+/Ztt283X3ZdRERERHZz09Y/QlOmnsJgGcYYABzjEjClNGfreWn9AwwvHE/I0dSFIiK7k0Flw1nesIIEgPOJewPW4KdcfDdLXaMDerZeRGS3Egy6nHnCOP5y50usSjRRX+3TGMniG4v1LPlRl1MOHkcwqKWPRGT7WWv5z/L/8vqGGQRNgMJAAQ4OST/J+w2zqUnXcMHQ71EYLMh1VJHtYq3Bt6bL2+wpesx85Oeffz7W2k5fIiIiIiLbqzGzgcXxDwi70bYC+SbGGGKBApoydSxunp2jhCIisjnlsUlYz8U2B7HJEDYVxCaD0BIlmA2Dtbz6ZgXZbE+aNFBEpGc48pARHHfKXizvn6YmksLzfMhYHMeQLnf4z/o5fLh+Xa5jikg3tqxlOTPr3ibihMkP5OMaF2MMUTdKUbCQ1Yk1TK99PdcxRWQn6TFFchERERGRnaEl24hnswRM5+sduiaAxdKcrd+1wURE5DO1NIxj7bpS8mNJQtbgpMM4mTBBxyMajVNfX8nMd3vz3sLVuY4qIiKfkvE8nokvxY9BOBwgnBekpCTG4Ooy+pcWU5to4YY3XtMgKRHZbu81vE/azxBxIh32ucbFNS4zat/MQTKRruFhdsqrp1CRXERERERkM3zrsyS+gXg2SU1qA7WpBlJeut0xnvUwGGKupl8TEdndNMYNTz49hdVrBuIGsuTlN5BftIFQLE5tcynTZxxPSzJAQ1Mi11FFROQTGlNJvvXYw7yzZjUZ3yeNT8JmqU0nWJ+I4wCF4Qgfrl/PvA21uY4rIt1Uc7YZoMOscZsETIBmrxnf+rsylojsIj1mTXIRERERka6U9NL8ef79vF03j7KQS8xtpsXL0JiJUxCMUR4qAmNIeE3kBYoYnL9XriOLiMinFOdHSaWKeO6VYxh37LNUl6wmYD2SfpBEfpYBRzxLy2vjKCqI5jqqiIh8wu9fe5VZa1djgIDjtBWwfGupSyYJui7FkShNqSRrm5sZUVae28Ai0i0VBgowpnVt8s4K5VmboSRQiWM03lS6J886eLZr///r9aAJXPRftoiIiIhIJ+5a8gwzaucQcULAQAwhgo6Pg6UxE2dDuoGmTB0Gw6HlnyPsqsAiIrK7GdCrhOH9yxh6xEsUFG8gZQOErU+500K120xZrIFxR0ynqFpr2oqI7C6WNzTw0tLFxAJBjDF88l68s7GIVZdIkvGyuI5DXiiYm6Ai0u3tW7IvIRMi4XWcVShrs/j4HFR2QA6SiciuoJHkIiIiIiKfsiHVyLSa9wi7QSJuCM+GiHvDiLjLcJ0WjPWJe030C/XjsIrPsXfx4bmOLCIinTDGcNSUEAv9tfQONDAoVEfIeG37U77L0mwJMzbcwZCicTlMKiIim7y7djUt2QwVsTwaUynSvtdWHPetxdC6XnltS4KBxSXsVVmd28Ai0m31ifbmkPKDeXH9y2QzWWJuDGMMSS9Fyk/RP9aXg8om5DqmyHbzMfhdPF7ap+cMJVeRXERERETkUz5qWkY8m6Q09PE6454tIJ4djWvi+DZBi5flSwO/w5iiITlMKiIinyUVe4t+qUaGhmrAthbGLQaDJeR4DAvVMDf9Olk/RcAJ5zquiMgez7OtN98dYyiLxVjT3ETa81oL5JbWW/MGmlIpDu3Tn5Dr5jSviHRvp/Y5maJgIS+vn0ZDphGLJeyEmFB2ACf3Pom8QF6uI4rITqIiuYiIiIjIp/jWB8Dw6TXJDJ7NJ+tHSXotGHRDTkRkd5f16xgSrMMBUgTBsLF3N6StQ9hk6B9cTyK7gYJQr9yGFRERRpZXEHEDtGQyFEUixNNpNiQTYMFuvDw3QMQL8PisuRzefyD79+uT08wi0n05xuGoqiM5rPxQlrcsJ2s9qiNVFIeKcx1NZId5GLwO97Z2vM2eQkVyEREREZFPGZhXTdgNkvBSxAKRDvtbNm7vG6vIQToREdkWFQGPiJclbV0MkGcM0Y0zDiZ8aLEOMZPF9ZcCKpKLiOTa8NIy9uvVi+nLlxNyXRLpDAFrcByDby0+UBGIUR3KZ01znNveeJvxfXtjTM+5aS8iu17YDTO0YGiuY4h0Kc86eLZrp1vfNONLT9C1vxkRERERkR6gb6ySvYuHEPeSNCeSrFnfyOLltSxeXsPK9XXE00kOLd+LwqCmXRMR2d0NKzigdWp1AwMDDn2DDmVO66tv0GFAIEDEBDBkch1VREQAYwwXHzqJYWVlrGluIuV5WCDj+Xi+xUkBcUsq61EUDvPhmnUs2VCf49QiIiLS3WgkuYiIiIhIJ7466EQ+WrOS5Yl1WGsxQQccnxabIbA0ChuKsIOsRqyIiOzmyiL70+JEqXIsQWPIWovFAK1r20Ych0rHxTV68ElEZHfRq6CAv5xwMle9+BL//fADLBbHMwSzDm4ammyKlkSG8pI8POvTmEzmOrKI9FCLZi/nxQff5KO3FuO4hn0OG8Gk0w6g96DKXEcT+Uw+Br+Lp0fv6vZySUVyEREREZFOtNR6ND5USKi3D4Pi+KEsTjxIekMe6zcEudGbybq8LF87dH8q8/JzHVdERDYjGBxFWWgwIW8RGQutkwPajbd2HDwgaAK43iJgXO6CikiP9OGMhTx33+vMeXMRxsCYg4Zx1OcnMGLcoFxH2+0VRSIUx4MEmx2CGFyzcVLUjf/Iej7r65spL8mnPF8POolI13v23unc9bvHSMRTBIMuFlg6ZxXP3/cG3/nNFxk/eUyuI4rIDlCRXERERKSHSWWzrGxqBKBfYRFB181xou7pxenzSDV6VAZ7YWoMdeE084uaSLs+Jmbx/Cz/+uhdXlq/lEsnTubgfv1zHVlERDphjCHfrcD6S3GxbeVxAIMFE8QxeZCeBrEzc5hURHqaJ+98hX//4UnSiTShSBCAVx5+ixnPvMeXLz6FIz8/IccJd2/ZrMecD1YT9A1ewOJYi+9aMmEfayzGAz8JffIK6FNUmOu4ItLDzH93Kf/67aN4WZ/yXsVts8hZa9mwroG/XfIfrvrvjyjrVZzboCJb4OPgdfHK2z49Z01yFclFREREeoi05/Hv2e/x4EcfUtMSBwy98vM5Y/RYzhw1Btfp2ovinm7h0vUYx2CMIel6zC9uIuP4hD0HgyHr+bjAhkSCK156nn+ccjq9C3RzTkRkd+SYINaUYk0Gz2/Gtz7WQsZGcZ0KgoEk2ESuY4rkTNb3WdXcCAZ65xUS0HXjDlvw3jLuveFJrO9T9qniSkNNE//67SMM27c//Yb1ynHS3Vd9c5LGpiS9QlFWBhI0FabxIhbMxzfnTT6UxMI5TCkiPdWLD8wglUhTVl3cbpk1YwwlFUVsWFvPq4+/zcnfODKHKUVkR6hILiIiItIDZH2fX778As8sXIDrGPJDIayF5Y2NXP/6qyxrqOeigw/T+tnbIBwKYjfef1sXTZH+RIF8E8cYKvLyWBdv5on58/jGuP1zlFZERLYoMAwyc1mfKKI5HcLg4fkOnnUwJkGfvASR4CAiuc4psot5vs9982fz3/mzWR1vBAx98gs5c9hYzhiqhyx3xMsPvUWqJd2uQA6txZWi8gJqVtfz8sMzOfeik3KYcvcWDroYY8jLBAhXOMSjPviADwaDA1hjeTW5nFnrV7NvhR44EJGuM+fNRQSCgU7vozhO67a5by/ZxalEto1nW//m6do2e85Icl3pioiIiPQAryxbwrOLFlIQDlMeyyMSCBINBqnIyyMaCPLw3Dm8s2Z1rmN2K/uN7QeA5/nUh9MYa9oK5JbWUUB5sTCOMTjGYcbKFTlMKyIiW2IixxHPGrJeA+ksJDMuGc/g+5Y8N0lTGm7/qCLXMUV2Kd9arn7zJX7/9issa6onEggQdl2WNNZx7cyX+d3MV/B70E3QXW3erCW4G4u8n2aMwXUdFry7LAfJuo+CvAh7D+tNnZ+gOZIm5LtEbYAoAaK4hHyXYNbBc3zu+mhWruOKSA/jbMWDYo6rEptId6b/gkVERER6gCfnz8O3PrFgsMO+/FCItOfx9ML5OUjWfR1+wFB6VxVRWxdvd4PYWvCyPgHXoSAvgrWtq9v2pCdpRUR6mrTZi/sXjyFgslRE4uQFU+QFU1TGmgk4Hv+cO5q/vdPCyqbGXEcV2WVeX72MRxd/RF4gRGWs9cHKWDBIZSyPWCDIwws/5K21eghwewXDAay/+etDay3BsCb5/CynHbEXmRLI4uP6BgeDYw3WB9/3yY+GKQxHmLFmOQ2pZK7jikgPstchw8iks9hO/tb3PR+AUfsP3tWxRLaJj7NTXtvi5Zdf5nOf+xy9e/fGGMNDDz3Ubr8xptPX7373u822efnll3c4fuTIkdv8+1GRXERERKQHWNZQT9B1O91nNo50Xt7QsItTdW/5eWEu/t4U+vUuIdho8a1POpvF83wc1xAKB1i+to6FK2uoa24hmnTIZL1cxxYRkU4srK/junfHcOVbh/LuhgqMAWPgnZpqrnjrMG6Zuw+N6TTPzVuQ66giu8wTS+aS9X3yQ6EO+/JDYTK+xxOL5+UgWc+w7+Gj8Dwfv5NCue/5WGvZ59AROUjWvewzrA+HjRuMMQbP88lmfbKeh7WW/GiYqtICAo6D51uS2Uyu44pID3LEGQeSVxChbl1ju0K57/tsWNdAaVURh5y4Xw4TinQP8XicffbZhxtvvLHT/atXr273+sc//oExhjPOOGOL7Y4ZM6bd+6ZNm7bN2fS4ooiIiEgPUBiOkK2v3+x+a32KIlppdVsN7FvG9b84k4emz+a3s18lE/KJOQGaEmniyQzGQNa1mAx89OYqrm58lp9+5ShCQV1mi4jsThLpDMmMx9SVg3hu5SDyAq2FlHg2SOvKthYLvLFwOV8ePy6nWUV2lSWN9QS2MJWs6zgsbarbhYl6lomn7s+z/57OhnUNlFQU4m6cktfLemxY10h5r2IOPUnFla0xceRgpm5YSNi6+J7FYIiEAoQ2TmefyGYoiUQpicRyHVVEepABI3rzjSvO5NYr7qd2TX3r8hkWLJaSykK+/9tzKC4vyHVMkS3yrMGzHZd+2dE2t8Xxxx/P8ccfv9n91dXV7X5++OGHmTx5MoMHb3mmhkAg0OG920p370RERER6gKMHD+HdtWvI+n6Hm51pL4vBMHngoByl656s9QCHcDjIF4/Yj/zeMX772iusqW/EGnCCBt9AwDoMTBWQH3SZPnsJT742h1Mm7ZXr+CIi8gmV0bzWEUAGsIZ4tuPIWSysb2zZ5dlEcqUwFMbz/c3u93xLYSi8CxP1LBW9S7jw2nO58ad3s2FtQ+vU6waM41DRp4QfXHsexRWFuY7ZLRzRdxDVeQWsa2kmYl0am5M0NLRgATfgYKKG80buR2gzM2uJiGyvg4/fl0Fj+jLtkbeZ984SnIBhzIRhHHbSOEoq1YfLnq2xsf1SVeFwmHB4x64d165dy+OPP84dd9zxmcfOnz+f3r17E4lEOPjgg7nqqqvo37//Nn2eiuQiIltgrWVZyzLmNs0jY7NUhavYq2gMYVc3CkRk93Lc0GE89NEcFtTVUhiOEA20Xua1ZDI0pVLsU13NpAEqkn8W36ZZF3+atfFHacksxTEhyqJH0Cv/VE4cPoL1qxr580vTyeSB8aEwG6IiHSHPC0II4okUT02fw+cOH4vjdO2TuiIisv2qCwtwMwY/ZPGtZVMPvbFmjjVgshAJ6DaJ7DmO6jeEGWtWkPE9gk774mLG8zDA5H5DchOuhxh94BCufuDHTH9yFvPfXYZxYPh+Azn4uH3IK9So560VC4a4aPzh/HjqY6xKteB44LgG34E0WWI1Dol3mvD3troGF5EuV92/nDMvODbXMUS2i4eD18Urb3u0Lj/Qr1+/dtsvu+wyLr/88h1q+4477qCgoIDTTz99i8dNmDCB22+/nREjRrB69WquuOIKDj/8cGbPnk1BwdbP8KC//kRENiOejXPX0n/zUdNcsjaD2XgrrSRUwln9vsDIQq0dJiK7j8JwhN8dexy/fvlF3l+3hqZUEoCwG+DwAQP5v8MmEdaN/y3ybZp5tb+kJvEiWIvjRPD8ZtY0P0Bt4nlGlF2B1+hRuSFMuc3vtI1IKMTaDU3EEykK8jS9vYjI7uLplz4k2GTIFlpskNbbOnbjPw04HgRSDsOry3MbVGQXOnbAMP47fzbz6msoDkeIuK3XiolsloZUklGlFRzTf2iOU3Z/BSV5HHvOoRx7zqG5jtKt9UrFqPoggFvp01zYens+7BuqmqKUrgnw2vyFTBo3jAP2GZjrqCIiInuE5cuXU1j48YwKOzqKHOAf//gH5557LpHPWDLyk9O377333kyYMIEBAwbwn//8h69//etb/Xm6Uyoi0gnf+ty59C4+bJhDzI2S7+ZhjCFrs2xI1XHHkn9ywbDv0SfaO9dRRUTa9Cko5MYTPscH69cxp2Y9jjHsXVnNsLKyXEfrFtY0P0JN4gUCpgDXjbZtt9aS9tYzf8NVhIM/wmKx1rauR/Ypvu/jOA7BgKZ6FBHZXayvbeKuB2dQEg6SDqaxabAhi3UAC07aEMhAfl6YKaOH5TquyC5TEArz+4kncPnrzzG7Zi2NqRQAQcflgOq+XH7QUeQFO1maQCQHXpg+j1A97O2Ukq2zeI4l5Dk41kAI1jc18/xrc1UkFxER+QTfOvi2a0eS+7Z1JHlhYWG7IvmOeuWVV5g7dy733nvvNr+3uLiY4cOHs2DBgm16n4rkIiKdWNi8iHlN88kLxAg7Hz8BFTABioNF1GXqeWX9NM7q/4UcphQR6cgYw9jKKsZWVuU6Srdirc+a+MOAwXWi7fYZYwi6paS8tYwasYLAsy7JdJZoOPipNiyJVIaJ+w0h8ql9IiKSO6+8uYB4Is2AaD4ttokWL4ttMRuHkbcyrmHy8MGM79cnd0FFcqB3fiF/O+pU3q9Zw+zatQDsVV7N2LKqTh8IFMmVlWvqcByn9drcNwT99vuDAYdlq+pyE05ERER22K233sr48ePZZ599tvm9zc3NLFy4kC996Uvb9D4VyUVEOjGn6SM8P0vI7TidrjGGkBPk3fr3+UK/M3FM1z6JJSIiu17WbyKVXYNrOl8b0jGtl82lJXXsM7Q/b81ZjgHCoQDGGDzfp74pQSwS4uSJY3dhchER+Sxr1zcBlrBxGdlSwOJInIZImkxBFhvyML4hryHIDyYehKOioOyBjDHsXdGLvSt65TqKyGbFomF83+JjaY4mGDpgMRX5TZCIsHTRUGo2QH5sx6d5FRER6Ul25prkW6u5ubndCO/Fixcza9YsSktL6d+/PwCNjY3cd999/P73v++0jaOOOorTTjuNCy64AICLLrqIz33ucwwYMIBVq1Zx2WWX4bouZ5999jZlU5FcRKQTaS8NsNkn5x3j4tksWesRUpFcRKTbc0wQMIDX6X5rLWBxnCAXfelIfnvnc7y/YDVNLcm2Y4ryo3z3jEMZO0Q3mEVEdifRaOvsHtZaIriURlzqe6fA9TEAPsTzfH701sNcc+BJDC7UMiUiIrubCfsN5KUPFxIe+x4/GPc61bFmDGAMxA96hRfeHE1F5Q9yHVNEREQ+5a233mLy5MltP//4xz8G4Ctf+Qq33347AP/+97+x1m62yL1w4UJqamrafl6xYgVnn302tbW1VFRUcNhhh/H6669TUVGxTdlUJBfpwXxrmbVyNTOWriDteQwsLWby0MEURPRk7WcpD5cDrWuTdzZSPO2n6R3tRdCoGxUR6QlcJ0ZReBy1iVdwTUGHh6R8m8QQpDhyAEXhKFd++3heWTCD2csW4mUCDCoYyRH7jaAoP7qZTxARkVw5cJ+BPDr1PZKpDJlSy+LeDVgDkXQAA2SzPoWFEZbF6/jZW49z+8SziQS0bIaIyO5k5JheVE1Yxf8e9BJ5gQx1qQhZ38VgKQglOemQWUTzXwHG5TqqiIjIbsMHPNu1s2X5n31IO0ccccTGwSeb961vfYtvfetbm92/ZMmSdj//+9//3sYUnVN1R6SHqmtJcOXTz/P2itVkPa91cJw13DL9LS468nAmDhmY64i7tXEl+/L0mmdoyjZRGChsVyxJ+2nAcnDZBK3RJiLSg/QuOJP61Jtk/FqCTilm40NSnp8k6zdQHDmQwtBeLI1/xPNr/8N6fwVenwwOLquDs1iW/Rxj7SH6bhAR2c2MHFLN+L0G8Po7i1g3KInn+IQyLljIej6BgENJQQxcWNpUx8trFnFs3xG5ji0iIp/w3NJFfHH0+xQE06yJ5wGm9VYXhqZ0FCeSIpp5COudi3HLcx1XREREugEVyUV6IN9arnjqed5YtoLiSJhINNK2XmptS4JfPfMi1596PGN6VeU66m6rMFjIqX1O4b4V91OfqSfsRnAwpPwUPpaxhaM5qOygXMeUHZRMZvhwzkqSyQxVVUUMHlSx2xW31q5r4LnnP2TGjEWk0lkGDSznyMmjGbffQBxn98oq0t0VR/ZnSMlPWFz/J9LeeiwWMDgmQFFkPMPLLmVFYiEPrLiRpBcn6uYTMIV4Nkt9poanVt+Jbz32KZmY61PZI9QmWnivZg2+tYwoKadvQVGuI4nIbspxDD/8+pH85Z8utwVmQtbiea1TrYdCASrLCggGXaD1b6l3N6xSkVxEZDfz8rwZXLLvKprTIYxtLY9jDMYYgkGXpoyhINQE6dcgenKu44qIiOwWfBz8Ll6TvKvbyyUVyUV6oFkrV/POylUUR8JEgx9PE+g6DhV5MdY0x7n/vQ9VJP8ME8oOoChYyEvrX2Zh8yI8fMrD5RxcdhCHVxxGyNEUjN2V71ueePJdHnnsHerq4vi+TygUYNjQar56/uEMGrhta5fsLHM+WsXvr3+SuroWAq6D4xjeWNfIzLeXcNyxe/GVLx+uQrlIF6vKO4GSyIGsb3mWRGYZjglTEjmI4sj+GOPy6vrbSGSbKQyWtT1UEzBBCpwSmjJ1TFv/CKOKJhBytLTJzpLIZrhx1nQeXzKPpnQKsEQDIQ7rPYCfjD+M8mheriOKyG4oFg3x428ezeOPziOeShM1AULBANFoiE9eTVksnt3WCQRFRGRnWrFiA+vXrcY1Phk/SOtluMEC1rdkMx64BmsBG89tWBEREek2VCQX6YHeWLqCjOcTiXb8T9wYQywQ4LXFS0l7HiHXzUHC7mNk4QhGFo6gJdtC1mbJD+R3uka5dC8PPPQW/7nvDYwxFBVGcV2HZCrDBx+s4OprHuMXPz+Fvn1Lc5oxkUjzpz9Ppb6+hbLS/HbF8Hg8xVNPv8+QIVVMPFyjnES6Wsgtp0/BWR22b0ivZUXLfCJuXqezTsQCBTRl61jc/AEjCrUW4s7gW8tl05/l+eWLiAQCVERjGGOIZ9I8s2w+q+KN/HnyyRSE9JCCiHTkGMO+FX2Yvm4JxdFY23aLxdA685ZjDMMLd48HJkVEpNXTU9+nYX2ERDZIJJAl6QXAgAUwFs9agvi4jgNOda7jioiI7DY86+DZrq1ndHV7udRzzkRE2qSzWQxsdtpoxzF4vsXzNUJia8UCMQqDhV1WIM9kPV6bs4R7X36Xh17/gJU1DV3Srny2DRuaeeTRd3Bdh5LiPAIBF2MM0UiIsrICamqaeOzxWbmOyRszFrFufSPFRbEOo8Xz8sJ4vs/UZ2fnKJ3InimRbcbDwzWdP2fqmgAWS8Jr2sXJ9hwz1izn5ZVLKAyFKQ5HcB0HxxgKQmHKIzE+qF3HU0vm5TqmiOzGTh24FwHHpTEdJ+PUkgwsJBmYTyKwkAa7mvJIhKP7DM91TBER2cj3LdOnLyC2No8XVgwkEsjiOD5+6zhyAKyxFIeSNCQLsUEtjSciIrKJj9kpr55CI8lFeqD+JcUAeP7Gp2g/JZHJMrS8lEhAXUAuzFq0ij889AorNzSABR9LNBTkyL2H8t0TDyYa0jTuO9OMNxfR0pKitCS/wz7HMUQiQaa/sYAvf+lQYrHcjURcsmQ9AIFA57M9RCIhliytIZXKEA7r/zMiu0JeoBDXBPBshgAd/7vz/CwGh/yA1sbeWZ5bvpCM7xELxjrsC7ouBnhiyVw+P3yvXR9ORLqFidWDOWPgaB5d+ywpJ03rUEQDeEQiaXrn5ZH0ExQSyXVUEREBfN8nnc5S4geY+tY49q1czaCCBlqyAZJZl4DjUxDKkEiH+OuMA5icWM6UvfSwk4iIiHw2jSQX6YGOHDaYkliM2pYE1tp2+xKZDAAnjx212ZHmsvMsWF3DL++ZyvKaeopiESqK8qgszMMAj781hz89Mi3XEXu8pqYkxpjNruUdDAbIZDzi8dQuTtae42xcT20zrLUYwOnkQRgR2TmKQxUMiI0k6bd0+H611tLiNVIULGNg3pgcJez5alriOFt4YjnkutQmWnZhIhHpbowxuOE6CsMO+W6MACGCTpDScCF9Y+XUZRq4Y8mTuY4pIiIbBQIulZWFpNMerCrmp08dw0MLh5PxXfKCWYLGMnN5b254+XheXz6IR96e0+FaXUREZE+1abr1rn71FBpGKtIDFUUjXHTkYfxm6ousbY4TDQZwjUPLxgL5xCEDOWnsyByn3DM98Or71MWTVBV9vJ6tMYaCaBhjDC/OXsQZh+7NkF5lOU7acxUVxbDW4vt+pwXmdDpLOBwgPz+3o4dGjerDY4/PIp3OEgq1/7q21pJMZjjwgMEEg52PNBeRnePwilNYnVxMU7aWsJNH0Anh2SwJr5mgE+aIyjMIOJrdYWepyivAYlsfFOrkYb+051EZ6zhTiIjIJjWpemZumEthMEp+INphv7Vh3q9fxKpEDb2j5TlIKCIin3bUkaO59baXaSRLfW0Btzx9GPdED6A8L05zPEBNSyH9+pYSC2VYtH4D8VSa/EjuZoYTERGR7qHnlPtFpJ0jhg7iulNP4NiRQwk4LhYYXFbKj444lMuPP4qQq8LarpZMZ3nto6VEQ4FOb+znhYOk0llen7s0B+n2HBMOHEx+XoTGxmSHfb7vk0pnOOTgYUSjoRyk+9h++/ZnwMByGhpayGa9tu3WWhoaEoTDAY47VtMJi+xq1dGBfL7f/zAgbzS+zRLPNpD2k1RF+nNyn28yqujAXEfs0Y7uP5Sg49KSzXTYl/ayAJw4aMSujiUi3ciKlvWk/DRRt/PiScQNk/TSLG9Zt4uTiYjI5hw5eTT77tOfdCqL9S3WQnM8zKI1xayPF1Bamkcg4GBBM66JiIh8goezU149hUaSi/RgY3tVMbZXFWnPI+N5xIJBTbGeQ6lMlqznE9jMH2vGGIwxtKQ63viXrlNUFOPMMw7gn3e9Su2GZgryI7iuQzKVoSWeorq6iJNP3i/XMQkEXH78P8fxu98/wbLltVgLxoC1EIuGOO/cQ9hnn/65jim7uQ2pRmZsmEN9uomCYIwDSkdRGSnJdaxur1d0EGf3v4ja9GoaMxuIuHlURwbgmJ7zR8Lualxlb44dMIzHF88l5WUpCLbOxNKcSZPIZhhf2YfjBmoNShHZvIDjYjD41sftpN+2+BhjCBg9VCwisrsIh4Nc9OMTCP37Re6Z8wFe1sfBEI2GKCqKkpfX+uBTSzrDAYP6EgtpZicRERH5bCqSi+wBQq6rkeO7gfxoiOK8KOsbmsmLdByl7Pk+Fkt1cUEO0u1ZTjxhH6LREA8/8jZr1zXg+5ZQKMCECUM495xDqKosynVEAHr1KuY3v/o8b8xYyDuzlpJKZRnQv4zDDx9Bn94qdMrmWWt5dNWrPLjiZVq8JGCwWP6z7AWO7zWBL/Q/UgXdHWSMoTzcm/Jw71xH2aM4xvDzAyfTO7+QBxd8QF0ygQXygiFOHDqC7+1zENGAboqKyOYNze9LcSifhnSc4lA+nt+6DI/rOjjG0JxNUhiMMbJQDyOKiOxOIpEgP/7SUcy7vZGPVq2jNBYjHA5gaP37p74lSdB1OW382FxHFRER2W341uDbrh042dXt5ZKK5CIiu4jrOEwZN4Lbn32TTNYjGPj4wQVrLXXNSYpiESaOHZzDlHsGYwxHHTmaSRNHMH/BWlKpDFWVRfTqVZzraB1EIkEmTRzJpIkjcx1FupHn1s7k38uexeBQEizAMQ6+tcSzCR5a+QoRN8ypfQ/PdUyR7RJyXb6914GcO2If5tStx/ctQ4vLKIvGch1NRLqBiBtiSvUE/rX4GVbU1ZJs8cEaMJZozCUUdTi5z6HkdbJeuYiI5FbAdbj8tKO55P5nWLx+A37CYlrL5MTCIb46cTyHDh+Q65giItIJ31reWbOK5xYtYm28mfJYjKMGDWH/3n1wNPut5IiK5CIiu9BpB4/hzfnL+WDpGkIBl2goiOf7NCfTREIBvn3cQRTlRXIdc48RCLiMGqlRoNKzZPwsj656Fd9aSkN5bdsdYygIxqjPNPPk6teZUn0g0UDn67GKdAf5oTAHVPXNdQwR6YaGpAaTnpdHvLoWIj524/amTBZ3ZRF79R+d03wiIrJ5fUuL+PWZU7jh6Wm8On8p6WyWcCDAuIG9OWBQv1zHExGRTqQ9j6umvcTUhQtI+x5m44yHj82by6QBA7l00mQimhVup/B3whrifg9ak7znnImISDeQHw3zqy9N4exJ+1EQC5PIZMn6lv2G9ObSs49hyvgRuY4oIt3cwuaVrE/Vk7+ZEXD5bpSGTDMfNi7ZtcFERER2A75v+dsD06n7IJ+GdyppWVJIelUBqaVFNLxTxZo5efzwzsdpTqZyHVVERDpR29zC5Q9M5fWFy4kGA1QW5pEXDjJt3lJ+fPdjzF6xJtcRRUTkU/7xzkyemD+PcCBAVV4+Vfn5VOcXEA0GeW7xQv761pu5jih7KI0kFxHZxQpjEb4x5UDOnbwftY1xQsEAFYV5GE0rIyJdIO1n8a2Pu5k1x13j4FuflJ/ZxclERERy74NFq1m0upbmsIeNhzAtEbIb9zlAwPisaW7mX9Pe4TtHH5TLqCIi0ok7p73N3DU1lOVHsT60JNNYC3nBIBviCX7/5DRu+frpuI7GhomI7A6aUikenjuHoOuSFwq12xcLBkl7WR6fP5ev7LMfJVEtedTVfOvg2y4eSd7F7eVSzzkTEZFuJhoK0re8mMqifBXIRaTLVEdKCTlBkl7nRfCknybkBOkVKd3FyURERHJvzYYmGsngYwnQ8RrcNQYsPPX+PHzfdtKCiIjkSmMiyfNzFhIOuGyob2HZ2jrW1zVT0xBnTW0TLfE0C9bU8M7SVbmOKiIiG82pWU99MknBpwrkmxSEwjSlUsxet3YXJxPRSHIR+Qy+7zN/5iLWLFlPJBZizKEjyS/O++w3iohITlRGSti3eBjTa2cTdoJk4hm8rIcTcAjnhYhnk4wuGsjAvF65jioiIlsQb2xh9rSPSDYnqRxQwYgDhuBoVNwOi4WDeE5r8dsYg+N6lFbWEY6myaYDrF9TjJNyaU6laUmnyY+Ec5xYRLqjmlUbmDtjAb7nM2BMP/qP7JPrSD3C6vomWlIZEok0LYk0juMQCLR+N1pr8bIejS0e7yxcxf6D+uY4rYh0V8s+WsnSD5bjuA4jDhxKeW8NMtgRvrVY7GYHiRnTuj551vq7ONmewcPgdfJw8I622VOoSC4im7Xw3SX842d3s2T2cjLpDBhDUVkBU742mdN+cAKu6+Y6ooiIdOK8gcfywcqFLNuwGpv0IW2xQYPT7FARLeGr+56oGSxERHZTvu/z6E3P8PjNU2lY34i1lkAoQP9Rffnqr85mxP5Dch2xW9tneB/yQiHifgvlfdYzZOxSwpEUGDDA4FSAZQv64NWPIhTQLRMR2TaJeJJ/XXkfrz40g5bGBNZCJBZm9CHD+cbV51HRtyzXEbu1SDCA7/u0JNO4joPjfPw3jTEG13XI+h7vL1gFR+cwqIh0SzUra7nl4rv44NW5JFtSGAOxwiiHnnog5136eaJ5kVxH7JaGlpaRFwwRT6cpinT8HcbTaaLBIMPLynOQTvZ0egxdRDq1Yt4qfnv+n5n/9iIi+WHK+pRSUlVES3OC/177KP+++qFcRxQRkc1Y8sISkv9vJcFn0rhpByfsEvAcgi+kyfx8DSumLs11RBER2Yz7//A491z1IM0NLRRXFVHWp5RoQZRF7y7h2q/dyOLZy3IdsVvLj4Y59cAxVFTVM2K/BYQjKdKpIKmWMMlEEDfgMWT0Mg4eHycU0EPBIrL1fN/nxgv/wdQ7X8b3LKW9SyjvW0og5PL2c+9zzZf/ROOGplzH7Nb6lRZTEAjhYdsVyDfxsLjGsGLpBjJZLwcJRaS7atzQxNVf+hMzn32PQMilvG8ppb1L8D3L1Dtf4s8X3orva6Tz9iiPxThq0GAS2Qxpr33fnPE84pk0h/cfSJ+Cwhwl7Nk2rUne1a+eoueciYh0qcf+9gwbVtdT2ruUcCzc+kRuwKWovJBgJMgzt7/IuuU1uY4pIiKf4vs+9137CNnVafpOz6P/n4L0+3OQ/n8M0vflPOyKDPf9/lGymWyuo4qIyKfUra3niZufJRByKa4oxA24GGMIR0OU9S6lfl0jj/zl6VzH7Pa+c9LB7LNvDW7AI5kM4tvWKR6xhmwmhGMcwhVzSXmJXEcVkW5k9rSPePvZ98gvySO/JA/HcTDGEC2IUlJVzLKPVvLSva/lOma35jiGMRWVGAwZ62Nt6/IZ1lo86+MDhTYEHqTS+ntHRLbeS/+ZzrKPVlJSVUy0INq6LI/jbOzT83nn2feZPe2jXMfstr5/wEHsV92LukSCdfHm1n82N7MhkWBsRRU/nHBIriPKHkpFchHpIBFPMuOJd4jkhTt9MjevOI9EPMlbT83a9eFERGSLFs5awsoFa8gvzW/9o84zBOIGJ2swxlBQWsDapeuZ++bCXEft1nzf8s7SVVz35Cv87L6nue7JV3h7yUp83+Y6moh0Y2898y7xxhbyS/I67DOOIVoQ4Z1n39NIxB1Ul11DSUUC3AAm5kPMw8Q8TLh1Kt/KvFIyxFkc/yDXUUWkG5nxxNtkM1kieeEO+wJBF8cxTHvwjRwk61kOGdqfokwAAyTCHo35GRqLMrTke+SHAuSnHUoKo8QioVxHFZFuZNoDr+M4hkCw40xCkbww2UyWNx5/OwfJeoaiSITrp5zIxYdOZK/KakqjUcZUVnHRIYdxw3EnUhaL5Tpij+Xx8brkXffqObTAloh00NKYIJvJEgh13kU4TmuhpakuvouTiYjIZ2mqi+Nlvc324cFQAC+TpbmueRcn6znS2SzXPP4yL85ZRMbzcAz4Fh5/dy6TRg7i4pMmaR1bEdkuzXXxtlErnQmGAqQSaeINLRSWFuzidD3HE6veojHTgmdcgq6Lb23rSHLXJxx0iIbCNGXjGkkuItukobYJTMeBBpsEwkEa1ushpx11+L5DuO2pGTTkNZKJWjY9ouobqI2mSRuXLx04otNBHyIim9NQ27TZ+ygAGENDTeOuC9QDxYJBThs1mtNGjc51FJE2unsnIh3kF8cIxyK0NCWI5kc67Pe91imtSquLd304ERHZotLqYoKhAJlkGjevYx+eTqYJhoKUqA/fLhnf46oXp/L0srnkFUSo9PNwjIO1lkQ6y3MfLKCqMJ9vHzkh11FFpBsqrS4Ga/GyHm4n62GnkhlCkRCFZSqQb68VLRt4aNkcBhc5hBzwMbjWYAGLpTmbpCHjEnBcCoOluY4rIt1IeZ9SrLVYazGdFMszyTQVY/rlIFnPUlwQJX9sAck19eBZjGPwMfjW4ltLc4nBq9TkqbuzNWvqeWfWUhKJDFVVRew/fiDhcDDXsWQPV9G3nLo19Z3u29S3V/Qt27WhRLrAzlhDXGuSi0iPFo6GOez0A8kk03jZjpNnNNY2UVCSx4QTx+UgnYiIbMmA0X0ZvM8AmuribWv0bWKtpWlDM/1H92HofoNylLD7enHtHL7+2q080jyDRL866vqsZVX1CloiLRhjiIWDhIMuj787l4ZEMtdxRaQb2n/KPhRVFNJY23Gkoef9f/buO0yuszr8+Pe9ZfrMzvbVatW7ZBXLkuXebdnGNq5gugkQekggIUBIAZIfCR1CAiGUAMHYlNDcLfcidzVbvZfV9jJ9bnt/f6wsW96VLdmrndXqfJ5neNi5O/eeK1l37n3P+54T4BTKnHHVEuIpKUf4et3ftoGMC45Xg1IefhDg+S4xnSFBBh04ZNw+akNNTIrPrnS4QojjyBlXLSUcCVHIDK5C4ZRdQHHODaePfGBjzI6+XnaV+wnbFoGp8DlQDQRQpsJXmlvXr8P1x1Ix2LHBcTx+8MMH+NSnb+FHP36YX976BN/6zt385Sd/wdPP7Kh0eOIEd+4NpwMKp+QO2lbIFAlHQpzx5qUjH5gQ4piSJLkQYkhXfPASxk8fR8/+PnJ9eTzHo1x06G7tRSnFDZ+6SlawCCHEKKSU4h1/dx2p2iRde3soZgdaaBRzJbr29hBPx3nH568/bClfMbQH2jbw1RfuZFeuG+2B5VsobVAOlWmvbaMYLgCQCIfJFEtsaO2ocMRCiONRvCrOjX97NaZp0r2vh3KhjOd65PsL9LT20jSlgas+srzSYR7X9hZ6AOhzplDybE6K7uKG2me5vnYV19es5u11zzEntJdc+xyUDJkIIY7C9JOncP7bzqSUL9Pb3o9TcnEdj0x3lkxnhnlnzOLs606rdJjHvdX799NfKlEOPGzTIGxbhG2LSMgiZJlordnS3c22nu5Khype4Sc/fYR77nkeBdTWJqitSVCVitLZleXf/+NeNmxsrXSI4gR21rXLmHfGLDJdGTLdWVzHwym59Lb3U8qXOf9tZ8piA3Fc8rVxTF5jxdg5EyHEsKodV81nb/4E59xwGoZSZHtylHIlJs5u5kNffw/L33t+pUMUQghxGLOWTudvf/oxFp43F8/1yXbn8Moe88+ezd/85KOcdKasjDsabuDxk22PUA48UmYUpRUGCkMbmL5FYPj0VPWg0SgFGvB9/Zr7FUKIoVzw9rP5yLffy6R5Eyjly2S7c6A1Z169lM/d/Jc0TKyvdIjHtag5UM41W7aYrLtZEttNyizhaQNHm4TxWBRtpdq/mVX7dlc4WiHE8UQpxU1fupF3fv46asalKWQK5HrzRGJhLv/ARXzqRx8mEgtXOszjnq8DSq4HGgxDodShreBNZeAHAc/skYTraNK6v4+HH9lEJGKTSEQOtiSwLJPamgT5fInbbltd2SDFCS0SC/OpH32Yyz9wEZFYmFxvnkKmQM24NO/4u+u46Us3DtlKQwhxfJOe5EKIw2qYUMfH//39dO/vpX1XJ5FYmEnzWjDNwf0RhRBCjC4zT5nG52/5JK3b2ujr6CdVl2L89CZ5qHsd1vTuoa3URzoURWkDQyl8rTGVQqEwApNyqIxrO5QyEAvZTG+UXmVCiNfvjKuWctoVp7DrhT0U82UaJtZR1yz9sYfDsrrp3LlvLVXs5MyarRS8MEU/jKGCgUlOWhFFM79pM2v33Mrilk9XOmQhxHHENE2u/PBylr/3fHa+sIfADxg/YxzJ6kSlQxszJqSqCA7T9x1AK43Sip784LL3onKee24n5bJLbc3gfwtKKaLREGvX7SGTKZJKRSsQoRAQT8W46Ys3ct1fXcG+LfsxTIPJ8yYQioQqHZoQr5tGETC8Y4F6mPdXSZIkF0K8ptpx1dSOq650GEIIIV6H5mlNNE9rqnQYx7V+p4AXBNjKRBmKRCRMf7GEcWBwTmmFNgLK2qXgwPL5M2mskoFQIcQbYxgGU+ZPqnQYY87S2inMTY9nIg9iK5+ibxO3S9iGB0CgFZ4bxUBTE3oEkCS5EOLohSIhZp4yrdJhjElz6+oJK5OS9tCvSJYHWqM1RLVFxJRh79GkWHQGnp0OM7nBMk0c16NcdgFJkovKSlYnmH3qjEqHIcSwOBbl0aXcuhBCCCGEECeIdCiOZZi42gegPhknatv4QYDn+/j4BL4mm3M5aXwjH71Qek0KIcRoZRsm/zD/zYwPlVBKkwyVCJsuioE2GZbSREIFDMujNib9bIUQYrRJhMOc1jgBQys8rXF1gKcD3CDARxM3bFJGmAXNMlF4NGlsrEJrjecFQ24vlV0S8TBVVbERjkwIIcSJTJLkQgghhBBCvIoF1RNojqbpcwporbFMg5aaKhpSCcK2BaYmrZN88rzz+OrbLicdl5UPQggxmtWEE0yJTiFseBho/MAg0AY6UPiBItBgGx7RsLSZEkKI0UYpxbtOOZkGFSelQoQxUYEipE3qVIywZzG7oZ6lE8dXOlTxMkuXTKG2JkF/ZuCZ6uU8z8d1fc49ZzahkFQAEEKI4RRodUxeY4UkyYUQQgghhHgVtmHy/unnEjFtOkpZSr4LShMJm0TiBhOrqvn2hW/l2iUnEQ9LrzIhhDgeJKtmggKtgRdfL9KgFPSrOFoPveJNCCFE5Zw9dRI3nbIYLxvg9vroPo3b79PdU8DPenxoyVJMQ4a9R5NoNMR7bzqHSNimqztHPl+mVHLp7y/Q21dg+rQGrrzi5EqHKYQQ4gQjdwtCCCGEEEK8hrMaZvK5k65ieqqRgufQXc5RCjzmV0/giwuvZX66pdIhCiGEOAr9QZpeL0bE8LCUz4uZclP5RE2XjBdme9HECfKVDlUIIcQreF7Ayvu2oNo9rAJYLthlCGfBa3f5/PfvoKdPrt+jzWnLpvG3n34TSxZPRqNxHI9EIsI1bz6Fv/vsVaRSUpFLCCGGm49xTF5jhdQvEUIIIYQQ4gicUT+d0+qmsinTRsYtUhtOMC3RgFJjp8yUEEKcKLb3Fuj1xjEz1MW4cJaQ4aIZKB3YWU6wrtBECU3BCQjLmL0QQowqDzy9hTXt7ZiGIpI3Drkf91RARzHP937/GH930yUVjFIM5aR5LZw0r4Xe3jzlsks6HScSsSsdlhBCiBOUJMmFEEIIIYQ4QoYymFPVfMh7WmvWdrVx587NbO/vIWmHOW/CFC6cMI2YLeXXhRBiNNq2I0WsOcRz2QnEch51dg6loNeN0utGiUfL7O6oIztFUy1JciGEGFV+98hafKUH+pG/YsKqpQw8FfDA89v5uwrFJ15bdXW80iEIIcQJ4Vj0EB9LPcklSS6EEEIIIcTrFGjNd1ev5NbNayn7PoZSBFrz8L4d3LJpLV8753LGxZOVDlMIIcQrdO9J0xupZVJdJwXHZlupFpRCaU08UsbxLNZtn0j8dJnsJIQQo01XrgBw2IpOhlZkHYcg0BjG2BnIF0IIIcTwGjuF44UQQgghhBhht+/YyC82rsFUisZYnIZYnKZ4gppIlI09nfzDynsJtK50mEIIIV5hqlnFA6sWsKunDivkEY+WiEeKxKIlCr7Nis3zKO6pJx2JVDpUIYQQr5CKR0DDgf8ZRKMJWSbSFUkIIcSJLsA4Jq+xQlaSCyGEEEII8ToEWvOrzevQOiAVjh2yzTZN0pEIz3e1s7pzP4sbmg+zFyGEEJWwaNYEzHvX8n+bT2Z8qpfJVd1YRkBvKcam7kbKXoil9SlMc+wMAAkhxFix/NRZrN7bhhsERC2YN76NVLREbz7Gun31aAVLp7ccdqW5EEIIIQRIklwIIYQQQojXpbOQY2eml3ho6FK8EdMiUy6zRpLkQggx6iw+ZTL+cwoVKPb11bCvvwYNKEAFYGjorvcoeS4Ry650uEIIIV7mmnMWcPODq5hSv4p3nbmapqoclhHg+gZ7elLc/Php/PmV76h0mEIIIUTF+VrhD3MP8eHeXyVJklwIIYQQQojX6dUqqcvKFSGEGL12FHqh2sLoc9GANgcS5OgDSXIFPW6RZztaObN5UoWjFUII8XK2ZfKfH63Czz2OZXj0OhHcwCBkBExu6ONzVz9Cff3VQEOlQxVCCCHEKCZ1w4QQQgghhHgd6mMJWpIp8q475PaS52EaBnNrZHBOCCFGm5zrUCg7aAUoheEfeGmFUgofyBbLZEulSocqhBDiFbR2cAo/IGT59LpJNDamYaKVTa+bxFB5Wju/hX61Ga1CCCHECSDQ6pi8xgpJkgshhBBCDBPfD2Qg5gRiKMX1M+YDkHOcQ7b5QUBvqcjMdB1Lm1oqEZ4Q4ihorfH9oNJhiBFkuwrXDdDGwMCIUgdeHHgpCAJNV3uuwpEKIV6L1ho/kGv4iaS971EiRidZN4ZpGFimgW0amIaBoQyyXgQ72I7rbKx0qEKI1xAEAYFcw4UQFSLl1oUQQggh3oBSocwDv32KB//vKbpa+4jGw5xx+SIuuvF0GlpqKx2eOMaumTaXzb1d/HH7BnL5MrZh4ukArWFyVTVfPOMiDCm7LsSo1dOZ5b7fPcujd68jny2Srk1w3hWLOP+qk4kno5UOTxxD2a4SZh7cJOhAo3jpWq3RBBZYBUX7niycXsFAhRCHtW1/N7c9tZ5H1+/E8Xwm1ae5bMlsLjp5BrZpVjo8cQzt6t/JVOXjY4I6MEn5ZavafG2jyLM/u5dJ4TkVilIIcThaa9Y8son7frWSDc/uQCmYs2QaF994OvPPmFnp8IQYU7Q2CPTwrpfWw7y/ShqTSfJyucyyZctYs2YNq1atYtGiRZUOSQghhBBjUD5b5Jt/8VPWP7UNpSAUCZHpyfGnHz3I43eu5q+/+14mzxlf6TDFMWQaBp9Zei7ntEzh9u0b2d7fQzIU5sIJ07hsykzSYUmyCTFa7d/dzdf+5hb27+7Gsk0s26RtTw83/8d9PPnABv7mqzeSqo5XOkxxjGiliLVb5CIega1RgUYFoI2Bl+kpYm0maqJMdBJiNHp6yx6+fOv99BVKRGwT0zBYv6edDXs7eG7bPj59/XmSKB/DSjqNpwwss4T74iQnDVqbKG0RNjzcwMQlXdE4hRBD+9OPHuA3370H1/EIR0MAPL1iHWse2chb//IyLn/PORWOUAhxohiTSfJPf/rTNDc3s2bNmkqHIoQQQogx7E8/fIAXntxKqiZBKGwffD8IArpb+/jB3/+Kf/7VJzCMsTPDUgxmKMVZzZM4q3lSpUMRQhwhrTU/+dqdtO7qpqYhiWm+dJ32XJ+tz+/jV//1AO//zBUVjFIcS/OnNhELLNipcRs0pWSANgENkYxBuFNhlU2Wzp5Y6VCFEK+QLzl843cPkymWaayKow5U7UlGwxTLLg+u28aCyeO4ctncCkcqjpU2akm6USaEs3S5kZc2GB5B4BEzHTZkJ3Jqy8LKBSmEGNKW1bv4v/9cgTIUdeOqD76fTMfp787x63+/izlLpzJlrrQtE2I4+Ch8hnfi73Dvr5LG3IjtnXfeyT333MPXvva1SocihBBCiCForenPFcnmS8d1/+5SvsxDv38GO2QdkiAHMAyDZHWcPZvb2PD09gpFKIQQ4nB2bm5j89o9JKoihyTIASzbJBKzeeL+DfR1Sz/qsaq+KsGyWRMxHYN4u2ZcyaFZFWj2yiR7AoySorkmxWlzJEkuxGjz6As76OzPUZOIHkyQvygattEabn96w3H9rCEOL+cWWdH1JLd2z6LoW9TZJcLKx0ATUT4NoSL9ns0tW07F9aXPsRCjzUO/f4ZS0SGZHlyxKVUTp5gv8/Dvn6lAZEKIE9GYWkne3t7OBz7wAX7/+98Ti8WO6DPlcplyuXzw50wmc6zCE0IIMYzk+n38Wb+9jR/8fiVrNu/D8XxCtsnMifW889IlnLVo6qABrtGuY18P+f4CkXh4yO2hiE2uv8DerW3MWzZ9hKMTYnSTa7iotH07uiiXXJLpoVsiRGNhMn0F9u/uJl2bGOHoxEj56+vOZUuwnUJzByrkgwYUhKYqVEeKvz3jainXPAS5hotK29nRC4BlDr32Jxa22dfdT77kkIgOfa8ujl9P9qwn4+bIB9P42l54a/1WpkQyxJWHpw2eL9Twy7bZrNtVxx3rN3Pj4gWVDnlUkWu4qLTtL+zBss0hx4CUUpiWyfYX9lYgMiHGpkBDoId3zDUYQ/MQx0ySXGvNTTfdxIc+9CGWLFnCzp07j+hzX/7yl/nCF75wbIMT4nXa097LA89upbWzn1jE5tR5k1gyewKWJQM1Qsj1+/hy9xMb+befrSBfdFFoUIpiKWDN5la27b2L9111Om9bvnjE4wq05rmOVvbl+olZNqc2TaAqHHntDzKw0lAZCn24O0M9cH9i2nLNPlForenpyeN6PjXVcUKhMXOrPezkGi4qzbINlAIdaJQ5eMAgCAIMQ2GH5Bo+lrXq/RhTOjB9H79oAArQGKbGHpdlrb+GM5lS6TBHHbmGi0qzDyTHtdZDJlmCQA9cw2XsZExqL/UAirIbsK7QyJr+OibFsiRNh143zD4nhqVMlKW5a+MWSZK/glzDx7582aG/UCIRCZGKHtn4xkiyQxY6OHyVBx1oQhH7sNuFEGI4jfqRu8985jP827/926v+zoYNG7jnnnvIZrN89rOfPar9f/azn+WTn/zkwZ8zmQwTJkx4XbEKMVy01vz2/jXcfPezFEruwffvXrmRuVOb+NxNF1OdOrJqCUKMVXL9Pn7sae/lO7c8RKHoYpkK0xgYrNKA7wfkiw7/e9fTLJk7gRkT6kcsrtWd+/nKMw+zvb8H78ADWjoc4cZZC/izeUswXmNle9OkOsZPbWDnhlYiscErVAq5EpFYmJNOm3FM4hejy9PP7OC221axdXsHOtCkqqJceP5crnjTIqLRUKXDG3XkGi4qbfaiScRTUXLZEqn04PvqfKZE/bg0k2Y0VSA6MRK01vzwudspew6hgokyTDR6oLueD17gcefOJ7lh2nnURdIVjnZ0kWu4qLSTp4/n1kfWUHY9IqFDEylaa4qOyzknTSVsj/phT/E6RMzQwN9zuUwQaDQGu3JVB7crK8APNLmCS1coX8FIRye5ho9drX0Zblm5hgc2bKfseVimwZkzJnPjaQuY1lBb6fAOOvncOWx6bueBSamHVgTx/QCtNSefM6dC0YmRprVmbU8rz3XvwwsCpqfqOLNxCiGp5jRsAm0Q6OHtvD3c+6ukUX+3+KlPfYqbbrrpVX9n6tSp3H///axcuZJw+NBB6iVLlvCOd7yDn/70p0N+NhwOD/qMEJX26Jod/PSOp1Eo6qsTB2dGl12PdVv38/VfPMCXPnT5cVeaWIjhJNfv48d9T28hky+hFJgvewBSgGkauK5PNl/m/qc3j1iSfGNPJ3/z8B30lItUh6NELAs/COh3yvxg3VO4vs+HF572qvswDIPL33MO//X5X5HpyZFMxwdWlmtNqVCmkCtx7jVLaJpYNyLnJCrnnnvX8T8/fRTH8YjFQhiWSW9vnlt/9SQbNrby6b9+ExGZCX8IuYaLSkvXJjj3TQu545dPUsiVicZDKDVwDc9lSmgNy9+yDFsqQoxZ+3Jd7HU6MByFaSgaqzqJhkuUAot9uVpUyaSMw4rNz3HjggsqHe6oItdwUWkLJzczf3ITz21rpVqpg8nwIND05ApEwzZXnz6vwlGKY2Vx9Uz+b89DlL3Si1ObXkZjmAGFzhilcoBtSJLlleQaPjbt6enj07fcyb6eDNGQRdgycX2fu9dt5pkde/l/NyxnTnNDpcME4OyrTmHFLSvpbusjXZ86WDHVc336ujLUj6/mzCtOrnCUYiR0lfJ88bm7WdW9DzfwUQeu6RMSaf7h5Es4qWZchSMcGwIUwaDvyze+z7Fi1D/x19fXU1//2gPm3/nOd/jnf/7ngz+3trayfPlybr31VpYtW3YsQxRiWGmt+cND6/A8n/rq5CHbwrZFMhZm7dZWNu/uZNak0XFzI4QQr2bjznb8YOhSiAowDIUfBOxq6x2xmH6+YRXdpSLj4i9NRDINg5pIlN5SkVs3r+Pa6fNojCdfdT9nXrGYno4Mv//+Crrb+9ADleSxbItTL57PTZ+7egTORlRSd3eOX/xyJX4QUFv70n9PkYiN43isXbeHFfe/wBWXL6psoEKIQd7ywQvI9RdZed968u0ZDnQDIRwNccU7z+Di606pdIjiGNq3vxtfB0xOdXHxhHW0RHoJqQBXG7Q5Se7tmsOm/mb2tnaBVOoVYlQxDMXn3nIhX7plBS/sbqcvXxrYoCAVDfPRK85k4ZTmygYpjplJsSamBhPYbz2PCgzwFaBAaQzbJ3AN8vsTaMBwxlDTVHHCCgKNHwSv2kLiBw88xb7eDPWp2MHFCVFsEhFNRybPd+55nP98z5tHxYKr2qY0n/jmu/ju3/yCjr09aD3w79QwDJom1vHxr7+TqtpXH4sRxz838Pm7p2/nua59WJ7CLw+kXa2QyY6gh888fTvfP+t6WuLpSocqxrhRnyQ/UhMnTjzk50QiAcC0adNoaWmpREhCvC692SLb9nYRiww9qzMStskVy6zd0ipJciHEccEyD/R9fZXxCa0hGhqZlbb95RKPtu4iYdtDPiBWhSN0FPI80rqL62ec9Kr7Ukpx1fvOZ9klC1h5x2q69vcSjUdYcuE8Zp48eVQ8gIpj6/GVW8jnytTUJAb9fYdCFkop7rt/PW+6bKH89yDEKBMKW3zw81dx8XVLefqhjeT6C1TXJ1l2wVxapoxc+w9RGWkryaRQF++d/gg1VgnFSzcqNdEy45uf5H+tJWS7l1QwSiHE4dQkY3ztfVfw7Ja9PLN1L2XXY0J9mgsWTKcmKe3pxjKlFGe5S3hwz3bMliKEXupt7Jct+nekcYohDA+C0uH7Hgsx2m3b18Vtj7zA42t34vkBLQ1VLD9tNhcvm3VIwry1L8PT2/eSCNuHVO8DMJSiKhpmS3sXG1o7mDu+caRPY0gzFk7iX//vkzy94nm2rt0NauC9pRedNGQ7OzH2PNGxi1Wd+yj1OwTugftwBRTAMBX7/D7+uOsFPjL3zIrGORb4WuHr4R2POtr9Pfzww3z1q1/l2WefZf/+/fzud7/j6quvPrj9pptuGlQNfPny5dx1112vut//+I//4Ktf/SptbW0sXLiQf//3f+fUU089qtjGTJJciLHC8300GuMw15mBAfaBVZdCCHE8WDx7Ao+u2U7Z8dD60BXlmoFZ0ZGwxWnzJ49IPFmnjBcERA4zC9tQCkMpMuXSEe+zcUItV3/wwuEKURwHcuUy927axo83rmbfVI8uVaChFKK6bB0sEQYDk9u6urK4rk9IyjYLMeoopZg2t5lpc2XF4YlmSksj15efo84qDgwccWAlIqDQpM0y19et5ubiJYPuX4QQo4NpGJw6ayKnzpr42r8sxpS6qiT+6lpy+xyi4/LMbd7NSfV7SNlFcrVR1u2YwppN06hNyIQJcXx6dsMe/u1nK8jky4RDFqZhsGVPJ1v2dLJq814+/a4LDybK2/qylD2P6lh0yH1FbIv+Ypl9vZlRkyQHiCYinHP1Es65WiYknoge3LOFTKGE6Sosy4CD4yga3w8o5l1u37FekuRjRD6fZ+HChfzZn/0Z11577ZC/c+mll/KTn/zk4M+v1Rrk1ltv5ZOf/CTf//73WbZsGd/61rdYvnw5mzZtoqHhyBeXjtmRusmTJx8s1SHE8aQmFac+naC1K0M0Ehq03XE9DEMxpbm2AtEJIcTRO++U6fz6vtXs3N+D5weYpoGhBtZruZ6PUjCtpY6zFk0dkXiqI1GilkXRc4lag1eve0GA1pqGWGJE4hHHn/2ZLH/7x7vZ1tVN0XUph6HTdOmOuNQXQ0zPRDEOPOB5fkA0ah/ssyaEEGJ0KOtNTIj3EGiIKJO4YWKi8NDkAh9Xe9RbBaKRVfS7RdIhSbQIIcRoMf+kCbSEEuxwurl+6tNMad6PBjzfJB0uMOHkLhZP3k5j7IxKhyrEUSuUHL59y0NkCw711S9VLEvEwpTKLo+t2cGd0zZw1TkDle+iIRtTGXhBgGUag/bnBxpDKWKhwePMQlTK1tYugkATtkw4pL+1wjQNvMCjK5urVHhjSqANAj342vBG93k0LrvsMi677LJX/Z1wOExTU9MR7/Mb3/gGH/jAB3jve98LwPe//31uv/12fvzjH/OZz3zmiPczvH8yQog3zDINLjtjLlprSmX3kG1BoOnLFmlpSHPKbGkjIIQ4PtSkYvz9+y5hYmM1SilcL6DsegOTfpRizpRG/vlDbyIaHply63E7xCWTZlDyvEFVObTW9JaKVEdinNsyZUTiEccXrTX/cs+DbOnqpjYWozGVwPYVIVdhaEVHzGF/zDn4u47jccZpMzAOVyJGCCFERWzv/SO2Cqg3wzRZIVKGSdwwqDJMmq0QNWYIU2mmx3bgBn6lwxVCCPEytm3y4WvP4pIFa5nS3Eq+FCabj1MsRcjk42QLMVrqepnS/IdKhyrEUXts7Q46+/JUp2KDKtlEDoyb3LVyA0EwsEBwZlMd42tSZIpDV8PrL5aoScRYNGncsQ1ciKPgdnsoYOhlrgptgtE/sjGJo5fJZA55lcvl172vBx98kIaGBmbNmsWHP/xhuru7D/u7juPw7LPPctFFFx18zzAMLrroIlauXHlUxx2zK8mFOJ5defY8Nu5s57E128kVSoRsGy8I8Dyf+uoEf/3O82VFmhDiuDJ3ShM//Lu38sCzW3nw2S30ZYs01CS5/Iy5nLVo6ognEN8z52SeatvD9v5eErZNxLLxdUB/uUzYNPnowmUkQ9IHSwz2QlsHz+9vpyoSxjINTNMgFguRz5cxMPAVtMXK1PUbZPpLpKtiLF8+v9JhCyGEeIUtvbs5PxUibpj4Wh8yQGcAKcMiQGMrl2pZRS6EEKPOmWc0429rp79k4fkWmoG1iMqASChMVSxOwVtN3t1O3B6ZqmVCDIc9bX0oGHJVOEA0HKKtO0O+WCYZj2AaBu8442S+cvtDdOcKpGMD7wWBpr9YItCaty6bTzwsK8m11uzMr2d138O0FrdjKpNpiQUsSp9DfUQWpI2kSaUqVkVa8awA2zs0z+EbAQpFQ2+8QtGNLQGKYJh7kgcHVv9PmDDhkPf/8R//kX/6p3866v1deumlXHvttUyZMoVt27bxuc99jssuu4yVK1dimoPzYF1dXfi+T2PjoS0kGhsb2bhx41EdW5LkQoxCtmXy6XddwMMnTeLuJzayp72PWCTEOYunsXzZbBprk5UOUQghjloyHuGqc046WBKskhrjSb5z3pV8f+1TPLRvBxmnPLCqvaaBm+Yu5sKJ0yodohil1rd14Pg+1dEIMDAQV1+fQqks+XwZ5WoKpk9PucSk8dV8+IMXMKGlprJBCyGEGKTsNRJXFsErEuQAAaA0JJRFnzMdy5AJykIIMdoUvZ1Eoi7x+DjyhYCi42KYikQ0TNS20FpT9tvJO1skSS6OK5ZloNForQetJAcIdICh1MGe5AAXz5tOoezwk0eepStXQKHQWpOIhHnnsgXcsHTBSJ7CqKS15tHOP/JE9x142sVSNhrNM9338nz/Sq5ofh8zkosqHeYJ45TJE3n0iR10Ty/j2B5GYKA0+KYGNIl2i3Mb5No92u3Zs4dUKnXw59fqI344N95448H/P3/+fBYsWMC0adN48MEHufDCC99wnK9GkuRCjFKWZXLB0plcsHRmpUMRQogxqTmR4otnXERnMc/+XIaoHWJaVQ3GEA+hQrxoqEEK01A0NqRwXJ++XBE38PnA+89h+elzsG1JrAghxGh0Wt1k0AYBQ5dSD9AoDM6vu2jI7UIIISpt4L7c8T0K+ORUGR1AueyTJkLcsgCFQu7HxfHl5Jnj+fWK1ZQd72B59RdprSmWXM5aNPWQbUoprj5lHufPncZjm3fRncuTikY4a+ZkahNSEQdgR/55VnbfgaEMUlbtwfe11uS8Xu5s/R/GTfsnEla6ckGeQM47bSa/v2cNoeez5KZ45GIuWkG0ZFHValPTHuXSN8+rdJhjgkYdXPk9nPsESKVShyTJh8vUqVOpq6tj69atQybJ6+rqME2T9vb2Q95vb28/qr7mIElyIcQQSn4fObcdU4VIhyah1NDlfYQQYiyoj8apj0oJJ3Fk5jU1ELJMiq5HLPTSoIRm4OHaUwGT6qq59Ky5WIZ8fwohxGg1tXocmS4Lw9CYBIO2ByjcIMTiphkViE4IIcRridszKPtJ+sttZNwoL955Z50yOadMXVSTDsdJhaX1kTi+zJs6jvnTx/Hcxr2gIHLguTMIAnqzRaJhm6vOHrpCX1U0wuULZ73mMXqdLGv6tlLyHRoi1SyomjbmK+es7nsEX7vEX5Ygh4EJBnErTc7rZX3/k5xau7xCEZ5Y6moSfPw95/GdnzxA5ukijdEwytb4GYiGw7zr2mXMnTGu0mGKCtm7dy/d3d2MGzf0fwOhUIhTTjmF++67j6uvvhoYuEbed999fOxjHzuqY0mSXIiXcQKPDf07yXlFasIpZiUnYJxACeKC18O63pvZnXscT5dRKFJ2C3PS1zA5cc6Qq+eEEEKIE8mcxnoWjR/Hk7v2YpsGtmmSy5Xo7clT9n18A3KbOvnv3nt4y7vPpLZeWqQIIcRolPcnkyvHsewCtuljK5+B4qYKRxtobRIE9WBJmUchhBiNess+9+yezGlN+4hbLk4Q4sXV5YZycPwSJf9cwlbjq+9IiFHGMBSffteFfPmnK3hh+34yuRIvDsmm4hE+dO2ZLJjR/Lr27Qc+t+65n3vbnqbglwCFgaIpUsN7p76JBemx23puX2Erlhq6L7uhBu4C20q7RjiqE9uyk6fwmboSd235A932RjB8IirFoupzWD5TJqoOl0Afg57kR7m/XC7H1q1bD/68Y8cOVq9eTU1NDTU1NXzhC1/guuuuo6mpiW3btvHpT3+a6dOns3z5S5NWLrzwQq655pqDSfBPfvKTvOc972HJkiWceuqpfOtb3yKfz/Pe9773qGKTJLkQDKz8eqhzNb/d8yBd5X487WMbFhNiDbxz0iXMH8M3CC8q+X08uP+L9DrbsVSUkJFAa59eZydPdP47TpBlVtUVlQ5TCCGG1da+bh5r3UXRc2lJVHFuyxSSodfXP0ecGJRSfPaic/nsbfewqb2TUtmjnHcIlMY0FeP6Teo7NA/uep5tm9r43P+7npq6RKXDFkII8QortvsEuSbOHLebbidCyPYwlcbXCs8zSRg+j+6fzbUT5BouhBCj0T27tnDf3pnEzD7m1W4kZpYBUAq0NtnUN5Hu8hLOn1ThQIV4HdLJKF/+yBWs3rKP5zbuwXF9muurOPfkaVSnXn/59F/uXsGfWh/HVhbVdhJDGbiBx75iF9/a/Cs+N+ddTE+2DOOZjB6GMhmoAXcYGgxpzzCi9ha28kDxB7hNfdSqCIYycYMyG/U95Pbs4PoJf0HElHYBY8EzzzzD+eeff/DnT37ykwC85z3v4Xvf+x5r167lpz/9KX19fTQ3N3PJJZfwpS996ZAe59u2baOrq+vgz29961vp7OzkH/7hH2hra2PRokXcddddNDYe3eQ4SZILATzQ8Rw/2n47vvZJWjEsZVJyHTZ07eIzO39A3f0NTBofYuJZAY0TE9SEG5hbtYzqUANaa/CeB3cdoMGaBfbi465E+ab+2+h1dhA1azDUgUuDsrGMCEW/l7U9v2Ri/EyiVnVlAxVCiGFQ9Fz+7emHWbF7KyXfQzHwqFQfjfHXp5zNhROnVyQurTWOu4aysxqAkD2XcGjJcfedMtY1JhN897oruXPtRr75y/sxgRQ2jTmLdNFApRSxeJi9u7q443fP8M4PnFfpkIUQQrzCY7t38cjepXwllmNmVQ9BoHC1SUj5hIyAJzua+erTM7hwYYl0PFrpcIUQYlTzg4DHO3Zyz95NtBYy1IZjXDh+BueNm07YHN7h5/ZiP/e2vcBPtj1Bwc7xy22zad7ZxMK6PVRH8+TKEV7omMCOQgvjqnuG9dhCjCTDUCye1cLiWcOTtO4s9bGi/RlCyiJpv5R4tA2L2lCKLqefP7U+xl/NeuuwHG+0mZY4iVW9D6G1HlQt1dcehjKYGH/tUvViePja5679PyXv9ZGyag/+nUTMGF7gsqewmSe67+C8husrHOnxL9AGgR7eccWj3d955503kEc7jLvvvvs197Fz585B733sYx876vLqryRJcnHCK/kOv97zIL4OqAmlAHAcj67WLI7rY1S5xN+8jpJVYovW7Gw1icXDPNF9JxfUncdC82FwnwfcA3u0wJoJqb9HWRMrdVpHJdAe27P3Yyj7pQT5y0SMKgp+N7vzjzOr6k0ViFAIIYbXV595mNt2bCRu2zSG4yil8IKA7lKRLzx5P1XhKEsaxx/RvgLt0evsRGufpN1M2Hx95bU9v42evs8PJMi1CyhQJiFrDjXV/4JtyRKI0SRsmCT3+7S84FFdG8c0D31AME0DO2zxyP0beMu7zyIUlttuIYQYTXZm+mjzI3zkuQu5dNwOljftpDZcorUY547Wqdy3ezKBA//+4wf4zIeWY9uyskiI4ZDpzdO6qxvLNpg4vUnukcaAsu/xpVX38EDrVjwdYCkDXwc80radk+ue5/8teRPp8PBMNnqiaxtfeeEOuks5+r0iZlhjhhQdfpw/7V6IX7QBjdKgTZ+untyQCTEhTkTP9m6i4JepsVODtimliJphVvdtJePmSdnxCkR4bC1Kn8v6/qfIe33EraqDixF87ZP3+qgJNTEreUqFozxx7Myvp7u8n5hZNegabRk2ZmCzru9xzqi7kpAhFR/FsSN3ouKEt65vG71OhpT10pd/V3sG1/WxLZPxqU4S8TxkwuisSSkIiARhVJVDsvh1PNvHMuuBF1dYl8F7Ht3/t1D9PZSRrsRpHRUnyOME+cP2ZVHKQKEoeN0jHNno4OuA53p28XTXdsqBx/hYNec3zqE+In1mhTge7ejv4Z7dW4nb9iGl1S3DoD4ao62Q5xcbV79mklzrgC2Zu9nU/ydyXgegsY0YkxPnML/6xqNKlgdBga6ev8Jxn8dQaZRRM3AMSpTdtXT1fIKGup9gGlLNo9JWP72De29fw8Z1e8lkipQKDtFYiFg8NOjBLhS2KBVdstkitWH5zhBCiNGks5hF25B1Qvx61yx+vetlK4cUYEHYgGfX7OKRp7dywRmyskiINyLbV+DX//0gK1e8QClfRhmKmoYUy284leU3LMUwpHLS8ep/Nj/Nin2bSdphYtZL40pl3+PZzr184/mH+OIpl77h4+wr9PKVF24n45agpFCOSWAFoDWGGRCpLVNsMwk8g0BptAl+u8eGHe3Mndr0ho8vxPGu4JcwUBiHmTRiKRNHexT98phMkjdFJ3PZuPdwd9vPyXq9AAcn0dSEmrim5SOETakeNFK6y61oNJZhD7k9ZIQp+Xkybjd14eYRjm5sGQ09yUczSZKLE17WKxy4IA+sDCgVXcplD9M0CIcdktECnm9g+QbKUBAospkSi+sdGswc2SBOtRVhYCQFIALUg78LSndB7MZKndoRs1QEExtPOwz1taS1RqMJmydeP75eJ8+/rPsj6/r24gUBGo1CcfOOlXxwxvlcNn5BpUMUQhyllft3U/I8GmODH/qUUiRsm2fb99FbKlIdOfwD0tqeX/JC328ACBkJlDJwgyKb+m+jp7yN88b9AyHjyHonFUsrcNz1mEYd6mUTlhRRlGHjedspFG4nmXjnUZ6tGE5/+s3T/Ppnj+E4PpGIhQJc16Njfx/pmjjpmvghiXLP9bEsk1hMZj0LIcRo013IweEuzxowIDACnCDgvsc2SpJciDegkCvxtU/fyua1e4hEbZLpGEEQ0N3ezy++cy89HRne8fGLKx2meB3yrsMfdz2PbZiHJMgBwqZF3A7xyP5t7M330RJPv6Fj3bP/efqdArWhBDvKvZha4QWgDYX2QFkaK+5S7g+hbTB8CO+H+5/eLElyIYC6UBUaja99TDW4Qo4TuEStMFX22B3/nVN1Ks2xaazvf4K20i4MTCbH5zIrdYr0vh5hlrLR6MNW+wh0gEJhqaGT6EIMF0mSixNe2k6gULiBh21YlMsuaI1SBvFoEUNp/MCAYOBibRgK3w+YYLajUJQD/8DNxcv+OSkLtIEu3c8T2dO4bfd6NvZ3EDEtzmmaxpUT59Icr6rQGQ9mGWEmJM5gS+YutE4M6n3rBHksI0JLbFmFIqwMrTX/+vztrOrZRVUoRsQc+FIOtKbXyfPdTSuojyRZUjulwpEKIY5G0RvoQX64knumMnACn6LnUs3QSfJ+ZzcbM3/EVDZh86VSZaZp42uXztJGtmdWMDt91RHFVCjdD3BIgvxFSlmAQaF0ryTJK2j7lnZ+878rAahrGFgVHomGKOTL+EFAX2+BaCxEJDrwd6i1plR0OX/5LKKxoSu1CCGEqIxS0aHoexAM/GwYAUppfN/gpcnPoBxNv3bZtV962grxRjx422q2PL+XdG0cO/Ti2IlJKGyTyxRZ8X/PctalC5g0o7GicYqjty3TRZ9TJGUPPesoboXoKOZ4obftDSfJV/XswlQGL29pajiKIKTRSgEaI+ahiyGUB6ndFlYOuntyb+i4QowVS2pmU20n6XPzVNuJQ8ZEfO3jBB4X1S0hYo7t59cqu5bT66SdaKVNTswjZIQpBwUi5uBFLOWgQEt0OlV2XQWiG1sCFAHDvJJ8mPdXSVLLSJzw5qenUR9Ok/EKB2cuvXS/rdEKlGuigpcNlgAh5R4sK6Ff9omXmOzLtfLpp/7Efa2b6Shm2Znt4cebn+QDj/6KNd37jvGZHZ3ZVVcSs2op+N14QQmtNYEOKPn9eLrE1OSFpEJH1p93rHi+fx9reneTsqMHE+QAhlLUhOKUfJff7Xm2ghEKIV6PCcmBSUpu4A+5vei5pMJhaqOHn0W8K/cYXlAiZAwuoW0qG4ViW/a+I45JBxnUq96WWQRB9oj3J4bfwyteoFx0SFa9NHHCsk1SB34O/IBMfxGtNeWSS3dHlnRNnMuvkZ5mQggx2vRnihiOJhJyaG7qYcmM7SydsY3pk9tIp/MoFYAGu6jwdUDe9yodshDHtYfvWIOh1MsS5C+JJyOUSy5P3r++ApGJN+ql8bBjP1ge6ACUwjQMDKXQGlQAZllhugoVgOEpYvsNUlstoj0KFDTWSNsjIQBiVoR3TF6ObVh0OxmKfhkncMm6BXqcHBNiDbx5/NmVDlOcIGpCjcxOnYoTlCj7A2MpMHCtz3v9WMrm1Nrlh13gIsRwkZXk4oRnGxZvn3Qx39v6e7qdDJFwCGWCZ3oUDRMCheW8dDEOgoBQ2CZLknGqGxPj0FXkB5T9Es/1pbGUQULZ6ICBB0IDOko5/um5u/nF+e8cVI6qUqpCEzi38XM81fU9+pxdlA8kY0JGgllVV7Cw5h0VjnDkre7Zhaf9IcvtKKWIWSHW9u4h55ZI2JEKRCiEeD3OHj+ZxniS9nyWhtih5bEd38cNAq6aOoewefjbpILfDQxdEgrAVCEKXidaB4OqcwzFsqZScp45bJkpjYNtTX3tkxPHzI6tHRiWMejvp7ouiVKK3p48+WwZw8hiWSZTZjTyZx+7iIlT6isUsRDiRa3bO+hs7SWWjDD1pAmYpswVP9E5rkeNLnH6nOdZmt5BvZ1HAX1ehLW5Fh5sncXevXVE+gYmyjoEBIHGMGSQToijpbWmuz1DKDz0vbVSCq0DejozIxyZGA7TUnVUhaJk3RI1Q4yd5D2HmGUzN/3Gy53PT09gQ38rSkEqFqYnW0QpBpLlnqYmWmKOzqOqbLaVaunriRMyTa67eNEbPrYQY8XZ9QuIWxH+sPcRtudbcQKPsGlzTsNCrm05l+qQTCoRI+fiprfjBmW2ZFeR9QoH34+Ycc6tv4ZZKVl0MBykJ/mrkyS5EMDpdSdhGxa/3vMAewudmFUKtxjgbE+jJxSxUgUCxyTwNaBIpWNsduuZau0mYVqoV86Y1XkKns9d+yfRv6uPbndgtaJhGiTTMWpqE+wvZHlw/zYunzBn5E/4MGojM7h0/NfoLG0g47ZiqhDjYguJmOlKh3aIkp9nV34jrnaothtojk49JrPKBlaZqsPu21AKX2s8HQz7sYUQx07UsvnMknP4+8fvpa2QI27ZmIZB0fPwgoCF9U28ffaiV91H2Eig4fC9k/CIGFVHlCAHiMfeRL74B7TOoNSh7TiCIIdSFvHYFUd6iuIYCIcttD+4coxSUF2XwA8C6huruOy6Jdgxm5mzxzGhuaYCkQohXrRrUyu//PrtbHxmB47jYpoG4ybXc80HL+L0yxdVOjxRQUYErjz7SS5q2kiV4WAcWAk53s4yIdTPuFAf/9N3DqqvBts0CIUsPN8nZMgQihBHS6mBMZSO1r4ht794P52skl6wx6OEHebKiXP56ZanKXouUeulKnyO75F3HS4eP5MJifQbPtalzfO5vXUN3U6edDxKvuRSclzCyuF9057nwrq9xAMPpaHo2DyxYSId2XdRLyvJhTjE4uqZnJyeQXupl1JQpjZURdKWa7AYeSEjzJvHf5C20k62ZFfjBCVSdi1zUktJ2tWVDk+cIOQJT4gDltTMZnH1THbm2+jo7+O2nzzLjpWddNSHqH/LVqyqEoZnEItFIFpkt2OwN7KQecZOCDpAJQZ2pHNorbmzdSIPb6vFdDyMA6tVAj+gryuLU3KhPszGvvZRlSQHUMqgITqPhui8SocySKB9Hu+6ned67ifvZ9E6wDJCjItM4pJx76AxMmlYjzc5UYdiIFluG+ag7QXPYVK8ltQwriJ3HY8tz++lXHRpbKmmeZL0XRHiWDhr/GS+c/6V/GLjGp7YvxsvCKiPxrly6mzeNmshydDQPfVe1BJfxsb+2/B0EVsd+jAZaJ9Ae0xJnnfE8YTsRSRiN5LL/y+e346hEoBC6xygiceuJhI+5+hPVAybxcumsva5Xfh+MGgVahAEBEB0YhW/fGANhUIZpRQTmqu5+pKFnLNshpQIE2KE7dnSxlc+9CO62/pIpGLEkhE8z2fv1na+/3e3Ui45nHftqZUOU1TIZmcFl49bT43pEVUWtjLwgWLgY5plliX3sGHCVh5PLCOpwtRXJ7Ctwc8DQogjc9al8/nVDx7E9wJM69D7qFLBwQ5ZLDl3doWiE2/Un81axq5cLw+3bSPjlrCUgacDFIpFtc18asF5w3KcSYk6PjHrYr698V563BzxlIVZ9vjric9wetV+SmWb7lwMtCIZdrh8yS7iqXvQ+lKUir72AYQ4gSilaIqOzKRurR0cdz1aF7HMSVhWMwBdfXkeW7Od7v4CyViYMxZMZnxDekRiEqOHUopx0SmMi06pdChjlqwkf3WSJBfiZQxlMDXRzNREM0s/M5t1q3bx7BNb6d80C3P2XoIJe8H2qAk1siB9FnNSp2M4K9DF34C/e2An5iQ6e8/hK8+1gaEw7ZcGU0wDdBBQzJUwUwM9lMSRe7Dj/3iq+y4MZZGwqlAYuNphb3ELv97977xt0l9TG37jJbxedHr9dBojKdpK/dSHk4ckOIq+A8Dl4xdiHOFK0Vejtea+3z/H7TevpKutn8AfKOs/Z/Ek3v6xi2iRcr1CDLv5dU3861lNZJ0yJd+jKhQhZB7ZAHhdeDYT4qexK/cIgfYJGXFA4ekSTpAlaTczPXXJEceilCKd+itsewq5/C143i5AY1lTSMRvIBF7yxGvShfHxhnnzeGO3z1H+/4+qmviWAe+3z3Pp6cnTzZpsn5vJ5GITSwaIgg023d38Z2fPEBfpsibL1lY4TMQ4sTyu/9aQff+PmrHpTGMgeunaZmEm0L0dPTzq+/czWnLFxKJv/qkKDE2aecWWmxN0oi8rCqYJmkYlLSJ6ZU5p3ELD6SX0lko8Z7F02SykxBvwPlXLeaxu59n384uEqkIkVgIrTX5bIly0eOMS+Yxc35LpcMUr1PYtPjnJZfzaPt27tqzkf2FDDXhGBe3zOL8cdMPWV3+Rl04bh6TE/Xc1bqW1b27mVu/k/Nre9BBLWARTpYxTIhHU0QsE7y1UFoB0SuHLQYhxJHRWpMv/Jps/md4/n7QAUpFiITPYuULl/LT23eTL5YPtN3Q3Hz3s1x6+hzed9UyLJmcKIQYIZIkF+IwTMtg0dIpLFp66CymQaV1o1dA5PKB1eQEYDRw30/uItK1l+ysMNrjkGLsyjAICAiKLgtrxo/IuYwFvU4Hq3ofwDJCRM3EwfdDKoytbDJeN0/33MOl4949bMeMmiE+Nfcy/nndH+koZQiZNpZSFH0XheKshplc2bJoWI51+81PcOv370drTbIqimkalEouqx7bwt4dnXzu2++kaYKU7RXiWEiGwiQ5uiSJUorT6j9GyEiwM/fQgR7lA73IG6LzObXuw8Sso6sEoZRBInYt8ejV+P5+QGOaTSglt2ujQaoqyif//iq+8+Xb2L+vF601aFCGwqyNYtiamnQc+2WT4yIRm75MgVv++AxnLplGXU3iVY4ghBgufZ0ZVj+0gWgicjBB/nKp6gR9nRlWPbyB0y9bNPIBioqbaGwgZdhorfF5qZWGAqLKpM4K0RLOoD2FZ8Pmvp7KBSvEGJCuTfA3X7uRH3/tTjat3k0uk0EpiCWjXPqWxbz1wxfIRJTjnGUYnDduOueNm37MjzUt2cBHZ10EQND/BSjZOMoiMHvxtYtGUwj6KXshEobCLN2DkiS5ECMum/sR/bn/BK0xjCpQJloX6MveTtR+hLD9FiKhBgxjIEmeK5T5w0PriIQt3vMmqfgkxHCRleSvTkZdhThKQz24KWWA+dIK5q7WXurXuxSmRXAjYJdeSpQHCry4QbLL54yGSeSdrXhBhpDVSNQaW0nz9l2dbHhiM4EfMGX+RCafNPF1P/huzq7CCUokrcGJYqUMbBVmY+YZLmx8K7YxfCuCTq6ZxDdOeRt/3LuKhzs24QQes1PNXD5+ARePm4c9DH0J+7pz/OFnj2IYiqqXJVBi8TCRqE1nax+3//IJ3vfpy9/wsYQQw8cyIpxa/yFOqr6e9uLzBNojHZpETXj6GxrkU8rAqvD3gdaa7Wt3seuFPZiWyZzTZ9IwQdo/TJ7WwJe/+y6efXIbW9a3ooEpMxv5xb2rKPXkDkmQvyiViNLdm+PRp7dy9fJFIx6zECei/p4cnusTjQ/dEufFShB9ndmRDGvE+L7PC49tomN3F7FklAXnziWRjlc6rFHD913qTQ8F+K/YpgFfB0SUScIICOo0Rjfcv2kb/xgEmENMuhBCHJnGlho+8823s3trO7u3dmDZJnNOnkS6ViYRvlypUGbtQ+vJdGdJN1Sx4Ny5hMLDtxJ7zAm68fDIuR1oNIYyMVBoArygTEkHhLzdRzklWgjxRnl+G5ncjwET03zZWK5K0dXvUF/dxfmLn+fhNRcOvK0UyXiEQBe547ENXH3ufKoSx1+bhP6uDGsf3oBTdGia0sCc02YMOWlXiJEkSfJXJ0lyIY6BZDpOapfHjOdg68lQjjMw4qJAaYh0BVye7WVj90fIO1vR+ChlUxU+hclVf048dOxn3h5L+UyBn3z+Fp668zlKuTIAoYjNnNNm8IF/eycNE4++dHjJz6FQh008mcrC1y7loDisSXIY6Hv18dkX87FZFxGgMYe55PEzD28iny1RUzd4cMAwDCJRmyfvX8/bP3ohUSkJKsSoE7Pqjqr/+Gi3f0c7P/ibn7Pl2e04pYHWEtFEhNOvWsJ7vvBWosfhg+pwCkdszjh3Nmcc6JtZLDl873crCYeGvq02DAUoOntyIxilECe2ZDqOaZm4jkcoMjix4Hs+Gk2yprKJ4572fnas34syFNPnTyQ1DNUmnn9sI//z97ewb2sbgTeQAk7VJrns/Rdy9ccvk0E6oC3/FNVKEehgyO0HHttAR3CaHCzbJNdhsLenn0l11SMZqhBjjlKKSTOamDRj+NqkjRVaax745aP8+ut/oqetD7RGGYr6llpu/Mw1nHm1rKp8UXe5h625bQTaZw5hQkEejYlG4QY+ioF2ioYyUbj0eDmaXlkVUghxTBWL9xLoPKbRcMj7ZcfDcSFs2cybsoZH155HoF+abJ6Ihenpz7NmSyvnnDxtpMN+3TzX41df/QMr/vdhcn0F0GCFTCbMHs/7v/wOZiyeWukQhRCHIUlyIY6BJRfO4/7fPEnd6jLp9jBtUyCXBtOH6j0B09jKWZ/aTqassY0qlLIJdIme4qPknU3Mq//6cZso9z2fb3/4B6y+/3miySi1zdWgoJQvs+bBF/i3m/6D6/7jXRRNSEXCLBw/7oh6ACesNACBDobsAe5pl6gZI2Icu8FOpRQmw/9QlenNo5TCMIcetLRDFk7ZI5cpSpJcCHFM9Xb085V3f5e9W/eTrI6TrE2gNRQyBe6/+VGyvXk+9cMPS5LlZUK2Rci2KBSdIbdrrQFNPBoa2cCEOIHVNFZx0ukzeHrFOmLJyKBB8WxvnqqaJCefO6ci8eX6C9z8tdt48p61FA9MKI2nopx91Sm85ROXEom9vvu9rat28I0PfJ9cX55UbYJQJITvB+R6c/zqq3/A9wNu+KSUm23PvUAKA8XQSfIX7S1VoXzwqn3IafxAv+rvCyHEG/HQrx7nR5+7Gd8PqKpPYtkWruPRubeb73/qp9hhm1MvO7nSYVZU2S/zf3t/z3N9qykHJbSGRdF93FAVgNb4DIwtaSDQPtaBiQbbHIOYu4+qkPS9F2Kk+EEncKD66su82LbM9S1CdplwqEyxHDu43VAKraHseq95jCDIEugippFGqco+b//8i7/mrh8/gB22qGlKowyFU3LZsXYXX33vf/APv/4ULTObKxqjOHFpIBjmnMZYejKSJLkQx8C802aw8MxZPPfQeqKez7TeKCgoFxzy+Synf3sH4RiEzcaDg3aGSmCqGGW/g92ZHzOn7v9V+CxenzUPvsC6hzeQrEkQftkAXzQRodAS54FpJo/8/k6sqI1pGDSnkvzZaaewfPaMV93vrNQpPNz5e4p+jriVOmRboH187TCv6iIs4/grQ5aqjqO1JgiCIRNPruthhywSqRN79aYQ4th78JbH2LetjZqmNKY1MMikFCTScSzbYtWKdbzw2Cbmn12ZxNJoZJoGZy+dzh9XrCUINFPG7ee0OeuY1bILpTSb9zTx0Jo5nLpoSqVDFeKEcs2HLmLzqp107e8jmY4RjobwXJ9sXx7DUFz9wQuJJ0f+3qpUKPONv/gpG57aRiQWJl2fAq0pZEvc8bNH6NzXw19+690Hr8FH4/ffvZNsT466lpqDzximaVBVlyLTneWOH6zgoneeQ3VD1XCf1nFl606fpokW1UYAQyTKFeBrg8e7WyAAbWusOmiuTg36XSGEGA5O2eW337wN3/OpGfdSxQo7ZFHdlKantZfffONPLFm+8ISdrBrogJ/v+gVr+tYRMcKkDyyk2O32sdsNM8ku4WlwtIEGQirAVpp9XpS9XoyZfj8gSXIhRophDFzLtA4OSZTblolSYBoenh/BcQ9Nbpcdj5Bt0tKQPuy+y84asvmfUyo/DtrHMNLEY28mGX8nhjHy92v7t7fzwC8fIxwLHdLiKBwNYTfX0L2vh9t/sIIPfu3dIx6bEOK1nZh3VkIcY6Zp8NGvvJ1zrl6C1tDd3kf3/j7KZZfTbohQP1UTtqsHrWpRysAyEvSVnqLstVP2XbrLOYr+0KvTRqMn73gO3/MPSZAD9NXYbDqlmlJtBD9bojERpyocZl9/hn9d8TB3b9zyqvtNWGnOrLsS0GTdHtzAwdceJT9P1uulNtzM0pqLjuGZHTtLzplFPBEh218ctC0IAkoFl1PPnyOryIUQx9yj//ckpmkMmZyJxMO4rsfTd62qQGSj2+UXnERdTYI5Lc/ygct/y9JZLxAJlbCtEifP2Mqn3novU+vvrHSYQpxQps5r4VP/fhMzFk6kXHTo2t9Hti9PbVOa9/zd1Sx/x5kVievJu9ey8ZntpGoTJNKxg9fcZHWcZDrOqoc2sObRTUe9377OftY9vIFYKjpkOdlEOk4hU2DVirXDcRrHta2bFJuKcTxMPD1QnvdFA//fpMMPcfv+GQQHvg6bm1JEbFljIIQ4NjY8sZmufT0kh2i7oZQiUZNg35b9bF+7qwLRjQ5bc9t4IbOBuBkjZsVQaqAdX8bTPFJIs6aUxNGKiPKJKp9AKzaUU6zI1eBog4iZrvQpCHFCiUYuxFBRtM4c8r5lGiRiNpbl8sKOufjBS/dXQaDJ5EtMb6ln9qSGV+4SgGLpUTp7PkqheDfoALDx/S76s/9FZ8/H8IP+Y3laQ3rm7tWUCmXiVbFB2wxDEYmHefKO5ygVyiMemxDwUk/y4X6NFfKUJ8QxEktG+PD/u5HrPnIxG5/Zge/5TJzVTGzyc2zrfRjjMGVgDBWi7Pdz8447uX3/QII8pEzObpzF9ROXMjFeO8JncnSyPTmUcehFUgO7psfxbIWddcE2UUoRskwaEnE6cnn+e+UznD99CiHr8JelpTUXEzFjPNl9F71OB1oH2EaYk1Knc27DtSTt47NHYLo2wRXvOJ1f//eD9HZlSVQNDJiWSw65/hJ1TVW86W2nVzpMIcQJINubwzpMb20YWF2X7ZXe2q80vinNP358PpHi9zDw6OyLAQpDKYxEhKq4B4WfoO2FqNDCSocrxAlj5smT+eIvP87Wtbvpau0llowyZ8nUIfuUj5RHb3sOrTWh8OAYIrEQub48K+9czeLz5h7VfvP9hYGJqoeZVGmYBspQAz0ST3C5zgae2dNM3VSHSaESGgMffWAFgaI3MLmlYzK9bgKsgYoqM+rrKhy1EGIse/Eafrj7cMs28V2ffP+Jew1f1/88XuCRtF+aSFBwHdpLIVrCNmucOKtLSWqMAK2hxwvhGhZhs4RPA0lbyhwLMZJsayLx2FvI5X+GH3RjqCrAROsCNakc+zprufepBeRKBcK2hev5lB2P+uoEH7n+TJRSA6XZvfXg7wUVRVtz6O3/Z4Igi2mMe9nE0DhaO5Sd1eRyP6cq9bERPddcX+HgxJ2hWCELz/Eo5Uuvu62SEOLYkSS5EMdYQ0stDS0vJba7CttAKQLtYajB/wTdoEyvU+a2vVso6BrChoUTeNy2dzVPdm3jXxZdz/Rk40iewlFpmFiHDgZ6zLx4c1CIm2SrLCxHo7XGfsWDXzoaoS2T5Zk9rZwxZeJh962UYkH6LOZVnU57aTduUKY61EDKrjmm5zQSrnr3mURiYW6/eSU9nRmCQBMKWcw/dSrv/IuLaZ40uidHCCHGhvoJtWxbvXPIbQO9taFuvFyPhjKp9ml0HoruOOxwgFKKWNTGMk3QGnQ7uvQnSZILMcKUUsxYOIkZCydVOhQAejsyg+6FX84wDXraj34FTLqhilA0hFN0CEcHT8b1XB+tNTXj0ke977Fm6sRGHnnwZKJJh6lVvUwNF6gyPRyt2OlGWZVL8+sdA9dqhUYDT+5prWzQQogxrXZcNXbIHriGD5FAcUouVtiidtzxuTBgOBS8gQkCSilKJZdS2aXHKaLDsLNYz8x4G4YR0OqFCbTCICCsSriBjWWeftjklRDi2EmnPoFhJMnlbyYIutH4KBUhGjmNGZP+kuWnF1jx1CbyJYdoyOaSZbO4+tz5jG9Io91N6Nw3wd0IlAGDAJuI30nRaBiiOmsIRYh88Q8kk+/HUJERO8/a5uqBNpp+gGEOLtzsFB2SNYkhV5oLMRKOxcpvWUkuhHjd0pGlhIw63KCHkHnoigStNTm3hz3FOixrHNXqxXK3IZJa01HK8J2N9/LtJe8YtTf4Z7x5KSt+/jCFTPHgl78bMtCGgrIHQLL60BJiIdPE15q+4uBy40MxlUlzdGz1dlVKsfyGpZx35SI2r91DqejQ0FzNxOmDb/yEEOJYOe8tZ7J11U6ckjtopWW+v0A4FuaMNy+tUHSjm/bWgzKJRsJEX/k8rhToELjrKxKbEGL0qGmsYt+29sNuD/yA2qb0Ue83nopx+pWncO/PHiJ2oCrRi7TWZLoyVDemOeUSmahzwRmzuOfh9Tz7p7PJLNvC1qb9eGEXLzDY3l/P0+2T6HNiA0XYFSjfYH8hy5Ote1jWPKHS4QshxqAZp0xlwpzxbF+zk1A0dMgYgA40+b4888+Zy/gZ4yoYZWWlQ2mCQLNvfy/lkkeAphzWWJaiy0mgVAMt4V4SysE2fcqBRVc5wc7SZD7ceGqlwxfihKSUSVXyAyTjN1J2nkXrMpY1CduahVKKm66Ad156CrmSQyxsEzrQ2kZ7O9H9nwa/A4w0UA34EOwjqVxMCuQZPClUGVGCoJ/A78KwWkbsPJe9aTG3fuX3ZLqzpBuqDtnmuT5u2eWc60/HDlWumpUQ4vCkJ7kQI8wy4kxIvRswcPwuAu0CEOgyRb+dnGeyNrsIUx3aD9ZQiqpQlC3ZNjZm9lcg8iMzY/FULnzH2ZTyZXrb+ygXHYxsGe36eApiySjx9KEz5xzPxzIMauMyoy4csZl/6lSWnjubSTMaJUEuhBhRZ19/GiedOYtMV4b+rixu2aVcdOhp68MpulzynvOYPE8SBEMLHeiJdjgBKHkoFuJEd9YVi1FK4ZTdQdtKhTKmZXDaZa8vkf3mj13GuKmN9LT2kuvL4x4o69i9rwc7bPOOz19PND5yq2pGq6kT63jnNcvIdtTyxP8t4Z7bLuTmNafx0xdO5549c+lz4wP9RRQo38R0QgQa7t65pdKhCyHGKMMweNc/3ECiOk7X3h4K2SKu41HIFOja10NVfRVv/9y1J/T4wNzIPAoZl1JQGmhpZBkDVRpdA9CYgaZBF1kS3ccpkYFXDUXiVLG4emalwxfihGYYSaKR84hFlxOyZx9yLbMsk3QiejBBDqALtxxIkDeCig5MOlcWWiXQQJQshvYGH0j7gIkawVXkAFV1KW746zejlKK7tYdSoYxbdsn25uht62PinBYu/8CFIxqTEC8nPclfnSTJhaiApsQ1TK3+S0JmHW7QR8lrwwtyKNXCnR1n0ucNnYCIGDZl36O10DvCER85pRTv/sJbePc/3kB9Sy2lXAm/NUu6z8OujtIwsQ7j5bOitaa3WGJ8VYrFLdIjSgghKikSC/OpH32EKz+ynFgyQr6/QClXomlyPTd98a284/PXndCDc69GhU4dSKpof/BGHQAeKnTmSIclhBhlli1fwNxTp9HfnSPbl8f3fHzPJ9ObI9dfYPH5c1l41uzXte+GCXX83S//knPfcjqGocj35nFKLjOWTOMT3/tzzr522TCfzfHrqosX8PmPX8bpi6fiOHG68ikK2ThmOYTpDryschjLDaMG1pQTHGg7IoQQx8K8M2bxtz/9OIvOnzfQf7w3T+Brll66iM/94i+YtnBypUOsqJ2r85RWpTFDGuIuhhFgqADD0LTY/bylZjUnJ/aA1pR8C0v5nJveyofGPY4KOiodvhDiCOmgAOUHQcVAHZq6MowEAQZK+4Q5tBqp1ppA5wiHlmC+onLrSLj0vefz0W//GZNPmohTcMj3FbAsi4veeQ6fu/kTpOurXnsnQoiKkHLrQlSAUopxiatpiC2nr/wsXpAhbDayv9TAvvKtxK0AC3PQ5wKtMZQibI7ulWimafKmP7+YS246j72bWvH9gEzK5PP3PkBHIU9VOELYMnF8n/5Smaht86EzT8UyDNY9tZ2Hbl/D9g2t2CGLU86eyblXLKJx/Inbe0sIIUZSLBnlXX9/A9d+4k3s39aOaZtMmNWMZctt46uKXATFW8BrBaMO1IE/L+2D7gKjBiKXVzZGIUTFhaMh/urb7+aX37iDlXeuoa8rCwoSVTEuvvEMbvj48kNKpR+thon1fOw776O3o5+uvd1EExHGzxgnE5yGsGjeBBbNm8D7cjnO+tUP8LSPaRiYIQfDdkFB4Jo4RQtDm5zWPHJlO4UQJ6ZZS6fzd7/8K9p2dpDtyVFVn6Jhwsgne0ajJ57chru6kbhK4c1og3gZ2whwfcV5oW1EA5ceJ45hDnzflV0DW5tMqOqgP/sf1Fb/S4XPQAhxRHQWcIeswqYIYxhpdNADuoAmgVIKrT2CoBtDxUkm3nVEhwm0Znt/D2XfY3wiRTocfcOhn/HmpZx25Sns3byfcqFM46R6UrXJN7xfId4o6Un+6mS0U4gKMo0otdGzDv6cCPk0x9LsyfdQP0QiPOMVSdsxFlVPHMkwXzc7ZDNl/qSDP//blcv5/uNPs76tg5zjYBkGsxrqeN9pSzhzykR+/d8PcvsvVuI6PnbIJAgCdm9r54E/ruLjX7qWuYsnV+5khBDiBBNPxZh+8pRKh3HcUEYaUv+Mzvw9+K0vK72uwKhHpT6PGsG+aEKI0SueivH+f7qe6z96CTs3tKIUTD1pAsnq+LAdo7qhiuoGWbFyJBoSCc5omsCjnduwq3IYhubFNeOm5RGJlIm6aS6cNL2icQohThxNkxtomtxQ6TBGlWyuRLnJZ79h4+8aR1QFhPptjJr91I/P0l+M4hsmgaHRaDA0UctEK4ti6QF8vxPTrK/0aQghXotRNVBiPcgPrCZ/BctoINAFAg1+0I5CodGYZh3Vqb8lEj71VXevteauXVv4xYZVbM/0EmhNzLK5eOJ0PjB/KXXRN3Y/bhgGE2ePf0P7EEKMLEmSCzGKWIbJWyct45sb7qannCcdimIog0Brsm4JLwi4ZvIpJOzjs5fg/OYmvnvdFWzr7qErVyAVCTO7sR5DKZ55eBO3/e9KLMugqumlG5Ig0PR0ZvneF//Av/78g8STx+e5CyGEGPuUPRuq/wfKD6DdtUCAsuZA5MKBJLoQQrxMuj7FovpUpcMQwD+dfQHXPrABnwDb8DAUeIGB4xuYhkGqymNjfyvzq4duiyWEEOLYyboltixoo1X1oQ6sFFeAUV/mIp0hZARkQgrD9HhxXZvCoBSUaS1CU0Th+XslSS7EcUCpCDp8ERRvHajKpl5RaVX3Y5jNpFL/D9tdi9YFLLOFaOQCDCPxmvu/dfM6vr3qMbwgIBUOYyqDgufymy3P80J3O9+94KphWVUuxGiitUIP88rv4d5fJUmSXIhR5pJxJ5H1Svzv9sfpKucOzoiLmiHeMulUbpxyWqVDfEOUUkyvq2V6Xe0h79//++fwPJ907aEz9gxDUV2boLsjw1MPbOD8q04eyXCFEEKIo6KMOESvQEWvqHQoQgghjtDavl3UxB1mRvczP96FpQL2leM8lR2HqZooeJrb962RJLkQQlTANzfeTVcqh9ljYJYVhmGg0Xh2QE+dA1ZAKPAJGGhXogBNgEKBDsi4mmZkwYUQxwsVexvaeQK8XaASAyvL8UBnABMVfy92eDF2ePFR7bezmOe/1j0FQGP8pYR6yDSJ2zYbezu5ZdNaPrRg2TCejRBitJMkuRCjjFKK6ycu5YLGOTzSsZkeJ0fSjnJW/UyaokdXMrHoF+kqd2Mri4ZIA4Y68v6GxXyJZ+5eQ9v2dkLREIvOn8ekucdmUCgIAjY/v5dwZOhe66ZloAPN9o37JUkuhBBHoLejn2fuWk1vex/JmgRLLzuZuuaaSoclhBDiCLRua+PZe9dSzBapn1DHqZefTDw1uNykGD6PdDzAZ1seZUGsm7DhYagAjaLX28B/t8/n6excVvXuqnSYQohRTmvN5me3s/7xTXiuz8Q541l80Xzs0NBjHeK17cx18mTnNqoiMUJxh0ymSOD7GIbCdBSbCrXktU3MdMn7LyXCBxLlmphVorVch5cJsUTauwtxXFBmI6S/gc59D5yVoHsBA8xJqNg7IHLZ69rvfbu3kXXKNMQGl1S3DRPLMLl19SqqV7RjGyazl01n9rIZGMaRj6cLMRoFKAKGuSf5MO+vkiRJLsQoVRNO8OYJRzcj7kU5L8fdbffybO8qSn4RhaIx0sgFDedxSvVilHr1i9hzK9byw8/8gu79vcDAg95vvv4nlly6iD//yjuJJoa/7IxhKHytD/8LCkxz7Fx8hRDiWNBac8d/r+C337yNXH8BZSh0oLn1K7/nsvdfxA2fulIe8IQQYpRyyi4//YdbeeS3T1AqlFGGgkDzyy//H+/6x7dw9rWyquVYyDhZrkrdxsJYO5oADw3aQBFQZxX5ZPMz/Mtei93lpZUOVQgxivV29POfn/gx61duxnU8lFIoBeOmNPKRb7+XGYunVjrE49Lq3t2UfJeGSJJ4bZhQyCLTX8T1fAB8y+SR/qlcWrOJmFGmEIQAhSIgaZbxtMH9fXM4K9bHksqeihDiKCizGVX1JbTfBv4+UBGwZqHU609ntRdyA60ahhgXd4ou2dY+ej2fX/1gFVYhwLQtZiyewsf/4/2y6ECIMUxGSYUYY4p+kR9s+xEPdjxM2S8RMSLYymZvcR83776FBzsfftXPb3luO//+sR/Rvb+HqvoUtc3V1DZXY9omj/3+Sf7rr3+GfrVk9utgGAYnLZ1CueQOuW/PHZglPHOBlDcUQohX88Atj/GLf/ktpaJDTVOa2nHV1IxL47k+v/v2Hdz2/XsrHaIQQojD+N8v/poVP38IFAP34OOqSTdWkenJ8d+f/hmrH3i+0iGOSdt6/8S8aCcBPh6KAIMA8DEoBAZhFfDuxueYWyWDo0KIoXmux7c++F+sefAFwrHQwXGUZG2Sfdv28/X3f4/2XZ2VDvO45AUBSnFw0kFVKkpLSw0TWmpoaakmHNHc2zeLB/pmEaCotgrUWDlq7DyONvljz3xW51uwDVknJsTxSJlNqNApKHveG0qQA6RCYTQMGnv2HJ+2nR24vo+Joq42TU1zNdFEmPVPbOYb7/8e5WL5DR1biEoKtDomr7FCkuRCjDGPdj7OzsJOUlaShJXANmzCZphqOw3AnW130+v0Hvbzd/zwPvL9eWrGVWPZJjDwMBJLRYmlYjxzzxp2Pr972OO++NolhKMh+nvyh9ys+J5Pb3eO5kl1nHL2rGE/rhBCjBWe6/HH/7ybwA9I16cwzIHbPMMwSNUmMUzF7T+4l2KuWOFIhRBCvFLHni4e+tXjhGNhEun4wcpPpmVS3VhFKV/mj/9597BPVhUQ89cQMjwCFIP+dBV4WjHRLnNGbaES4QkhjgOrH3iBzc9sI1WXJBKPHLyG2yGLmnHV9Ozv5b5fPFLhKI9PUxL1mMqg7LsH31MKbNvEtkw0GtvQrMxP5JH8FLa71ez2qtjs1LGq1IxheaQshyU1kyt3EkKIUeHclilETIus6xzyfrY3h+t46IhJ0y4XMxgYCw/HwqQbqti2ZhfP3L2mQlELIY41SZILMYYEOuCJ7icxMLGGmCUbN+OUvCKr+ob+Yi/mS6y6f90hD3UvF01EcEouq+57Hq0dXHcrrrsNrZ0h9nZ05pw8iXd94hLskEVXe4bu9gxdbf30dudpnljLX3zpusP2LBdCCAHb1uyiY3cnierB/bUAEtUJ+jszvPD45hGO7MSgtaZUforu3s+xv+NK9ndeR1/m27ie9LAVQry2NQ+8QClfJlY1uPe4UopYVYytq3bQ3dpTgejGtrjpHVg7PjQNGAomRTMjF5QQ4riy6r51+J5PKBIatM0wDKyQxco/Pg1AT2eW229eyQ//9TZ+9s27Wb1yK/6B0uFisEU1E5mcqKfPKRLoQ6/VTlCmKlSkIZLjlKpdxOwyu9wqdji17HaqKWib2lCO8+p3kg7JELgQJ7qpVTVcMXU2Bdelr1wi0BqtNZlsATdlESloJmw8dMW4HbLQQcCz90qSXBy/tFbH5DVWSK0ZIcYQN3DJellCxtDJZEMZoDjsSnK35BL4AaY19MODUgrT0qQn3Mv+jv/ADwbKhVlmE4nYW0jE345S5uuO/4I3L2b2okk8etdadm5uww5ZLDxtGssumEs8GXnd+xVCiBNBuVA+cA0f+jpsWga+H+AU3/jEJnEorTWZ3A/I5H6I1mWUCoHWZNwt5Au/o7b6y0TCp1c6TCHEKFYqlEEpDGPowQbTMvHKHqWCXMOHndEMPmg0MPjP31KabKDwvdf/nCOEGNtKhfLgShQvY1ompXyZR+5cy8+/dTe5TGmgMoiCe3/7NNPnt/CJf76edG1ixGJ+pbzr8HDbNvbl+4laNmc0TmZKsrZi8bzIVAZ/PedS/mHN7+goZbANE8sYWFmejrQRt32qrQIpq8gUq8zscJ6U4aOBvU6E9U4KzyyzM/cQs6quqPTpCCEq7JOLzyJsmvxx2wY6CnkAHEsTb3c46TmHeGbwxEllKArZ0qvu1wtK9Dm7AU06NAnLkHFsIY4XkiQXYgyxDRvbsCn6Q39xv1ieMWpGh9weT8dI16fo3NtNNDn4d4LA5cq/fIGJi/rx/QiOGyFfcNBspqvnS7R3PkRL8xeZPa35dZ9D86Ra3vLB81/354UQ4kTVNLmeUCREKV8mPsRKxHKhTDgaomlKQwWiG9tK5cfI5P4bMNGqgX63SNYrobVJ2tpPvvNvmDLuD9hm5QcahRCjU9PkepQC1/GwQ4Mf00v5MrFkhNpx6ZEPbozSWuMGPo93NXJhyiSifIr60ES5eSBx3upZdPSnmdtYsXCFEKPYuCkNKKXQgUYNMdnJKTk0zmzhx1+9A8/xqGlIYBgDixPKJZeNq3bz3X/8Pz73nXcefH8kPdC6lW+se5DOUh7FwKShH2x8gouaZ/DXC84nalW2qt+MVBPfXPJ27ti3hvva1pP3yrSkwkStEoti7cwNv8DkkE9SGfgYlLSBQjE1XGRK2GWVY7Ar96gkyYUQhEyTv1p8Fu+aczJPtu2l7Hs88q172fu77VQ11wz6fa01OtC0zBw35P587bK+77dszdxDye8HIGJWMT11CXOrrsU0BlcYEWKkHYse4tKTXAgxKhnKYHH1ybiBO6gMFUApKGErm5Oq5g35edM0ueBtZxN4AU7ZPWSb1pr6Sds56fx2wpFqsvkErR1l+jIBmVyCYilETfUj/PhX/8E9j2w4JucHUPJcnm7by6Otu9ib7T9mxxFCiONNw8R6Fl1wEoVMEd8/9DsgCAKyPXmmLZrMlPkTKxTh2JUr/GagDYmOs6fQQ3c5hxv4eFrT5YQoevv54/Zv4A/x3SyEEACLLjiJxkn19HdmBvUd9xwPt+RwzvWnE00MPdlVHLleJ8/Ptz/Gux77Adc//F1+07mZO/rGE6CIKY2NxkITUZqQgk5fsb6QwHFnVzp0IcQodeY1pxJNRMh0ZwdtK+XLA1X5qpKUCg7pusQhifBwxCaVjrJ57R42rt49kmED8FzXXr606h66SnlqwzEaogkaIglMpbh9z3q+vvbBEY9pKE3RKv5s+jn84qwP8btz/4LrW2q4Jv04S2NrGGc7pAwDjUbhYysfRxvkAxMDzYJQJwTdlT4FIcQoUheN86Yps7h2+jxuvPwcLMOgmC0O+r1sT45IPMzZ1y4btC3QPk90fIe1Pb+k5PcTMuKEjDglv5+1Pb9kZee3CbS00xBitJMkuRBjzNl1Z5EOVdHn9eMEDlprAq3JewVKfomT04uYEG057OeXv/c85p05m2xXlt72foq5Evn+At37elh4SQfxdATXj9DTlwcNlmVgGgrPjxCyA+bNeIEf3/IYu4e5X2KgNb/YuJrrb7uZjz3wR/7qwdt425238reP3EVrTvoDCiEEwNs/dy3N0xrp2d9LpjtLMVci25Oju7WXuvE1vPef34ZSY2e252jhOKtRKkJbsR8v8LEME1MZAy/DRgE9xVXc3bqu0qEKIUYpO2Tzvi+/g0Q6Tve+HnJ9eYq5En2dGfo6+pm2cDJv/uillQ7zuNdRyvDp527lf7Y9Smc5g0ZT8Azu6J/Cb3rH0+GZGApMBYUAtjgmT+STPNK2gPnN0yodvhBilBo3pZG3fvpqlFJ07+shnylQzJXo2d9LIVNg6WUn09WVJxoPDXkvHorYeF7A80/vGPHYf7ntOfKeQ30kjnUgea+UImmHiVkhVrRuZmd2eMd33iilFLXBr6g1+ykGMRJqYKWmj0IDFgERNbDwo4xNCI9JtvsqexRCnMiWXrqIc244/eB1u5gtUsgU6W7tIfADrvmLNzFp7oRBn9tfWMWu/GOEjARRsxpThTBViKhZTchIsDu/ktbCsxU4IyEOJT3JX50kyYUYYxoi9Xxg6vuYEG2hFJTp8/rpd/swlOKsujN5y8TrXzVBEk1E+ZuffIS3/M2bqW2uxnc9AE69bDGLLqwmFI6SzZUIAo1pHrqfIDBorM9SKDo8uHLzsJ7X99Y8ybdXPU5XqUBVOEJdNIahYMXurfzFg7fRWcwP6/GEEOJ41DS5gc/f+kkuf/9FROIRPMfDDltc9M5z+Pytf8XkeYMf7MQwUCYl38UJPMwhSmQqFBrFbXtXD1ohKoQQL1pwzlw+d/MnOPPqUzEMA8/xqKpNcs1fvInP3vwJUrXJSod43PvvLQ+yLdtBbThObThB0o6QtBvw/DD3Zqbxr62L+WHnRH7fV8fve5v4Xccc7u5YSCy/iCkN0jJDCHF4l7//Qj7x/T9n3pmzIND4rkfztCbe/Y9v4f3/9k60BmOIUuzAwTEazx3ZFYd95SLPdu0lbg2dvE9YIYq+y+PtO0c0rtfiultJqh2UdYgACKmBhRUA+kCi3Fb+QOn4A+83haorFq8QYnQzDIM//8q7+LN/eTsTZjXj+QGeETBz6TQ+9u/v4+qPXzbk53bkHkRrH9sYXOnJNqJo7bMj++CxDV6II6APlFsfztdYSpJLT3IhxqCJsQn89ay/YmtuGx2lDizDYmZyJjVH+FAQTUS57q+u4KqPLifTnSMcDZFIx+nofo5SeR+lsstQeXZlaErlKMpUPLZnO8YWC6UUJ1U3saCm+XWvXtyd6eOWzWsJmSbpcOTg+8lQmKhlszPTw2+3PM+HFgwufSOEECea+pZa3vulG3nbZ68h15cnXhUjGo+89gfF6xYJnUGu/GsghOLQ7zoDH41in9PCnkIPWa9EypZyyUKIoU1fNIVPfO/PyWcKlPJlkjUJQuHK9oIdK9qK/azs2kbcCmMZJgBaQ3sxR9FPMz7ZRcaM8WRuClorDKUxfINQpom/OfsdFY5eCHE8WLp8EUsuWUi2J4fnelTVpzBNkyAIaGypZvfWDmKJwfflnjeQHG+ZWj+i8RZ9F18HhA5cE19JKYWBouSPrlXYjreJkPLxCRHoAI1CYQADrY00A6vCDHw8DcqwSdqTKhmyEGKUMy2T+W9ZxLbTfLbve4Gy9tgdSbB7vM8Cr0zCHnztzrltGAx9/QQwsMh57ccybCHEMJAkuRBjlKEMZiZnMDM543Xvww7Z1I57KbEei1xCqfw0huHzynVwpjGw4nz93pnsWpBle02WNes7AY1tmJxUPY6/X3wJzbHUUcdx355tFD2Xxlh80DbLMLANkz9t38ifzz8VQ8oICyEEAJFYmEgsXOkwKqInV+DxrbvJlco0pBKcPn0i0dCxSzIl4tfRnv0TKStPIUjAgUS5IiBp5unxqnk+NxUAA/meEkK8tngqRjwVq3QYY8qefDdl36Um/NIzRb9bpM8polSIvdkGkqEcKctBqYC8Z6PKjfzo3I/RkDz6ZxghxIlJKTWo8odhGFzw5sX8z9fvolRwiMRCB7dprenrzlPbkGLpubNHNNaacIyUHaHXKRKzQoO2u8FA8n58vGpE43otChtQVNtV9Lh99Po+ddbASjkFB9aSg8bECyxyWpHXJzGyUxCEEMeT7dkOPr/mt7QX+wmZFpZhsr/Uzw+3PsSjHVv4l0XXURU69N48YqYJOHwFkACPiFGF1lra3omK0gxMDh7ufY4VkiQXQhyxWPQycoXfUpVai99rEugwGgjbDpFwidbO8fxR11Go8qgNxamPDAxAlXyPZ7v28LdP/onvnXU9CfvokjY9pcLAg84rbigCrdFaYxsGObdM0XOJ24Mf7IQQQpwYgkDzs8ee4zdPrSNbKh/83qhLxvnQBcu4aN70Y3LccGgRfvhjOPmvkzKzDCTJNaDo9dL8vvsK+lxYUjt+yBnoQgghjj3bGKhyFegAUxloDb3l4kD/WqXwA4ueUgpl1hE1ovi+R79bZlO+S5LkQog37PwrT2bTmt2sXLGefLZEOGrj+wFO2SOVjvPnn7uSaHxkJ7iGTYsrJs7jx5ufxAn8Q1aUa63pLReojyY5p2naiMb1WhxjBoXAwPE70Nqm01OkTY2NwmUgSR6gCLRB3AhYl29ku2Nzk1zKhRBDCHTANzfcTXsxQ30kiaEGWqglGZgstKF/Hz/f8Rgfm3XxIZ+blDiTfYVn8LWDqV42+QnoL+UoeGXuX+3xjZ7/5dzpU7h6/hym10n7HiFGG0mSCyGOmGEkqav5FiXnc9jhlRhWCQDHt1izZwq/Wnc+vTWasGdSm4gdTE5ELRvLMNiS6eT+1i1cNemkozpudTh6YMbTwMy7oufSUyqSc5yDv1MbjcnaPCGEOMH9YuUqfvros9iGQX0yjmEoPD+gO5vnq3c8RCxkc8aMY1NqcV7Dn/EPqwok9SNMj/USYLOjNJn1+Rm0O5qQqXnzhMXH5NhCCCFe26yqJmpDCXqcHLXhBL4OcHz/YCWqgAADg7AaSFKFTAvtlFjf287ZTVMrGboQYgywbJMPff7NzD91Kg/8aTV7t3cQjoY474rZXHj1KUyc3liRuN4+7WSe6drNup79WMokall4QUDBc0mGwvzNgvOJWqOn7Uef08f3tv+aKUYt86P92EpRDBQ7HZgcCggduKb7WhE1XNr9MPdkm8jo3dw0unL9QohRYn1/K1uy7aRC0YMJ8hfZhknEtLm/bQPvnnrWIa3TJsTPoD5yNx2l9YSMOLaKoYH2XDeeztPZV8vejhYcr8xv17zAfZu38YVLL+TUSS0jfIbiRBegBrUGHI59jhWSJBdCHJVAN/DDlTeyvW0iTYk9EMCWjiZ29dRRmuKgDE1zTRrTHHxTAfBA69ajTpJfMHEaP1n/LBmnjKEUrbksvtaYamB2nh9oMk6Jzz52N/921qVERtEDnBBCiJGRKZb49VPPYxkG6fhLD66WaVCXjNGeyfO/j6/i9OkTj0mpM0MZfGzOe/intSnu3ddxYGIXaO0StULcNPUszqg/NivZhRBCvLaoGeKaiafw31seJOMWiRkhUKDRBAfqD8aNxCGDoxqknZMQYthYtsm5b1rEuW9aRBAEKKVGtARvqVDmmftf4JkVz1PIlhg3tZ6zrljM10+9ilt2rOb23evpd0oYSnFB83TeNm0xC2qbRyy+I3Fn2920Flsp2adRbWnGW3uwTRdT+ezzNFFlUQji7HOT7HNj9AYhGmJt4GyrdOhCiFFqd74bV/tUG0OkyrRLTDlk3BK7cz2cVD3+4CbLCHNO02d4uvMHtBafpeB3UfI8Sl5AV+9Etu05nXgoSjw0sPCrI1fgyyse4n/fdQPxkFRCFWK0kCS5EOKo3Ll2E49u3kUyMoVy/wyy+RKlskc6oukIuWhDYdvGkJ81lUHWLR/1MSenqrlu+kn8fMMq+pwSWmssZRxcXR6xLBqiCR5v3c2vtzzPu+ac/AbPUgghxPHmmR376C8WqUsM7uGrlCIVDbO1vZtdXX1Mrq8+JjE0Rav41pJ38HjnFp7s2kbJd5kYr+WipnlMStQdk2MKIYQ4ctdPXEKfk+cPe1fR7eYxlMYNfAxlElcJUsZLtXhLvoepFAtrRleCSAgxNhjG0OMmx0r3/j6++Ymfsv2FvWitMQyDdSs38+Bvn+LSd57F+//yMm6acSq9ToGoaZMKjb4WQVk3y+q+NYSNMKgwjxfPpd5sp5a1NIe7QEN/EKHTTdDhJdEHVs7FLY9JsT3SF1gIMaQXF3bpA1cNAEvlqTU3Mi62D1P5BChuWbWPk6tv4JqF52EYA78XMdOc3fRp+p29dJU28f3HnuL5vTZRY9whx1BKURuP0pHN8dDWHVw+d9bInmQF9OeKPPjsVp7duBfP95k1qYELl86kpSFd6dBOOFortB7e77/h3l8lSZJcCHHEtNbctmoDANHQwGrtdOql1Xolw6GXPJlimeqXreJ78bOeDpiUfH2JiY8vOp09uX5+t/UFAPwDDzeJUIjGWIKQaVL0XH6/bT1vn7UQc4QfOIUQQlRWvuyA5rDXf8swKAYuhZe16jgWIqbNBU1zuaBp7jE9jhBCiKNnKIM/n3E+y5sX8HD7RlZ17+HRtl2ECZO2EgeTJ27g01cuclJNE0vqJ1Q4aiGEeGO01vzn525h67rdpOtS2CHr4Pv5TJHbf/IQzVMaOPeapTRGkxWO9vC6nR6cwCFqvDgpVrGrXEPYtqgyS4SVTyM5pod7yPph1hWb6PCSuIFFrZmhHPQTMdOVPAUhxCi0qHoScTNMziuTsqPYKsfM+CMk7TxeYOBpA0tpGuu2sK30Tf7rkV4+dM41h0y6qQq1YNHA6h27AQ3hwcexDoxVbOvqGaEzq5zNuzr4l/+5l46eLDAwSeC5jXv548PP88FrzuCS02ZXOEIhXiJJciHEEXN9n319GaKhoS8dtU6cPrtA3itTzaFJ8pznEDJMLmuZ87qObRoGU1LV1ESiJOwwGgiZJmHTPPg7Mdumo5An65ZJh6OH35kQQojXpLVm/Y42nnphN8WyS1NtinNOnkpdOlHp0IbUVJXENAzKnkfYGvw9VXIH3m9Ijc74hRBCjJxJ8VreNfVM3jlF86NNT/Lzrc/QXsxhKEWARgHTq+r4wimXSrl1IcRxb8vqXWxZtZNkOn4wQQ4DSYtEVYzutj7uvvkxzn7zKSO+wv1ohIwQBgYBPi8OaU+0NnJaYieW8ikHJlqB0pAyS5wa38MT+Ynkg/iB5JRcz4UQg9VHklwybh6/2/scpjKYl1hH0s5TcMMEL142PBvtG0QjOTqLv2ZD65nMHd94yH4sw0ApCILDH0sD1svGsseiXLHMl3+6gvbuLLXp+MGFDFprejMFvvfbx5jQVM2cyY2vsScxXAKtUMO88juQleRCiBORZZhYhkHJ9YbcHnfCRIMwbsino5gjYQ/0V8m5DkrBtZMXcEpdy+s+fti0AEXctocskeUHAaYyCBlj+2ZDCCGOtXzR4Ru/eICnN+zGcf2B8SQNv7z7WW66chlvOnP0rZI+eVIzE2qr2NnZS0Mqfsj3hB8EFByXS06aQV0yXsEohRBCjCZKKd4/+zTObJzCnXs3sC3TTdwKcfa4qVwwbgZxW/pFCiGOf5tW7cR1fFI1Q1/TYskIrds76Gnvp27csWlLNByaIo00RhrZW9xH2Ahj4rIkth6toYyFPvDMEqAoBAYx5TIn0snqUoi0PYnwy1pqCCHEy31gxnkUfIeVnauojbThBCaBGhgKMX0L0x+YaOO5EVKpXu7f+jBzx99wyD7ClsXSiS08sGU7yXBo0Nh1yfWwDIOlE8czlj26ejtt3Vlqq+KHVPpTSlGditHVl+OOx9ZLklyMGpIkF0IcMcNQnD1zCn9avWHIXk6O51ObT/CmJTN5NruHfYV+AKamarlu8gKunjz/4Gc683n+uHkjK7ZvJes4TK5Kc8XM2Vw4ZSr2YWbUnTZuAj9Z/ywFzx00YKW1Ju+6XDRxOjEZzBJCiDfku79+hMfW7iARC1OViKKUIgg0fbkiP/jd49SkYpw+f3KlwzyEZRr8xcVn8I+/W0F7Js//Z+++4+yoy8WPf74zZ04/Z3tL770nJAQISUjoHaSJgoD6uyoWbNjrVa+igqioV696uYog0gQECaGEQCghhPTeyybbTy8z8/39sbCw7CZkYXdPsnnevo5mZ875zjMxO+eceb7f5wn7LDymSTZvk87ZDCgt4vpTZxQ6TCGEEEehsSVVjC2RG3VCiL6p9f4Nh+zHrVCgQbu6lyPrGkMZLKxawF923kUsH2O0v5GImSFm+/CbeUzl4mIABgrIa5NSM0XYcBhVdK70IxdCHJLPtPjSuHNY3hBm2f4lpG0PHu3BcM12K3Bd14PXytCc2dvpOB+YPJ4Xd+ymPpmiLBRsq0iUtW2aMxmmDujHtAH9euWcCmXdtlpc7WKaHSuTKKXwWh5e27inAJEdv7RufXT3mH2FJMmFEF1y8YxxPLtxGwdjKcrCATymgdaaTN6mJZ3lhGEDuGn6XDSaA+nWviNVgUi7mWNbGxv40qLH2ROP4TEMTGXwSnIvr+7fx5Kd2/nOvAV4O0mUTyirYnb1IJ7Zuw2AoKd1RbnjujRk0oS9Xq4aM7l3/iKEEKKP2lnbxLLV2wkFvAT9b006MgxFSSRAfXOSB55ZxYkTBh91N5qmDx3Aj684m78tW8ny7XtJ5/L4LA8LJ4zk6pOm0K9YVo8IIYQQQojjy7BxAzBMg2wmh8/fcVFBKpGh37BKSquLez+4LppWMoWUk+LRff/C0c2ARitFxrXwGzaGcjFw0LSWNVbKpdgzhSHhUwsbuBDiqKeUYmi4hpe1B9M2UJ2kzpTSaK0IWJ23+Zw6oB9fOu0Ubnv2BQ4mkq3XIVrbiE7qV813zjqt11v5tOQb2BBbTsJuJmCGGR2ZRpmvpseO5+o3z/owzznKJ2WJ44skyYUQXTKiqpxvXbSAWx5dwsF4AoVCo7FMk5nDBvCNC07DMBSg6Bcq6vB6V2u+u+Rp9sRiVITal11J5/Ms3r6NsRWVfHjSlA6vVUrx7dkL0Ms0L+7fTTyXe7MCMGX+IF+eMYcpFT33Ji+EEMeD1zbsJptzKC/2d9inlCIU8LJ5Vx31zUkqSo6+/t7j+1fxnx84k4ZEing6S2k4QDTQ8VyEEEIIIYQ41rnaZU9qM7tSG3G1Q4V/ACPCk7GMt5Lh42YNZ8iYfmxZvZvSShPT89aihHQig0az4PITO131dzQ6pfwkphRPYn3DX/Hl1xPQXhJ5lzwajwEGGpTGQGNrDxPLLzrqJvcKIY5Opb5hBMwqHGsv+bzFO5O9Hk+GbM7HCf0PPfHmrLGjmD6wP09u3MKu5ha8psnMwQOYNXggHqP3rrNaa15s+BfL6v9F1k233cN/of4RJhefwmlVV2Cq7k8PjhpUyeJXNrW2Re3kfHN5mxMnDO7244pD01qhu7mHeHePV0iSJBdCdNnMYQP588cvY+mmHeysb8YyDaYPHcDEAVXv+sVj+b69bGlsoDgQ6PBGGbAskvkcD25YxxXjJ3a6mjzq9fGzU89hTcMBnt+3k6xjMyhSzIJBI4h6fd16nkIIcTzK2c5hyzEaSpHXmrzt9HJkXVMWDlIWDhY6DCGEEEIIIXpEIt/MP/f+N3vSW3C03Vo2HSj2VnBuvxsYGBwJgGEYfOJHV/KzT/+Z/TvqMAyF6THJ52xMj8mpF87g9CtnF/JUuizsCTOj8jpq6x7BUjvQ5HC0xtat95mU1vhMh/35EjYcfJia8BRCno4LOYQQ4u0M5eGEyit4dv8vMD0p7LwfpQxAY3qyoFzSzdM4edqow45TEQ5x1fTCVjt9vXkJS+oexMAg4ilBqdZqsFk3xauNT+E1AsytvKTbjzt32nDuWfQajS1JyovDbfeWtNbEkhm8loczZ4/t9uMK8V5JklwI8Z6EfF7OnHj4DwSd2dRQj+tq/J7OLz8hy0tdMsmBRIKBRZ1/gVFKMbG8monl1V0+vhBCiMMbVF2CAnJ5B6/VcbJSOpunJBKgvDjU+8EJIYQQQghxnDqwp5Edm2pRhmL4hBr+Fb+D3anNBDwRgsrb2o5O2zTlDvLAnjv40OCbKfW13jfpP7yKb//fJ1n68Ape/Pcq0vE0/YZVcepFM5g2byxGL65u7C5KeSmK3sTe+s8RMDJkXBNHKzyGi085pFwvKzIDyOiDrG15iZllZxQ6ZCHEMWBC+Zkk8i28evAuTF+a1sLgGsexyDbP5tMn3YzVycKuo4mjbV5u+Ddaa4LWW23nlFL4zRCudljZ9CwnlJ5O0BPp1mMXhQN84UPzueXOxdQ1JTBNo3Wxhe3g93q4+qwZTBs9oFuPKQ5PVpIfniTJhRC9yjSM1t5QWne6SlGjUYo3SrYLIYTobdPHDKRfRRG7DzZT8bZZv9BaFst2HM48cQxeSz5GvpOrXV6s38a/961iS/wgPtPDKRWjOKvfJPoFiwsdnhBCCCGEOAY1NyT431sfZ+ULW8imc6AUJdMylF2zk9JIKZbxVlU9U3mIeEqJ2w2sbH6O06oua9tXVBbh3I/M5dyPzC3EafSIoP80XslMpr/xKqVmCp8CB8XefCmvZwbTYAcwVYZN8dckSS6EOCJKKWb3u4IplWewbPcT7I/vxSTM5P7zGVs1stDhHZEDmV005+vxm50vbvCbIRJ2M7tSGxkTndHtx582egA/+9xFPPnKJl5asxPbcRg7pJrTZ41i/DBplSqOLnJ3UwjRq6ZU1+A1TVL5PCGvt8P+RC7HmLIKasLdO4tNCCHEkbE8Jp+7ai7/+cdF1DUl8FoePKZBJmejtWbqqAFcclphy4YdjVztcsemp3h4z2s42qHEypJ389y7cy+P71vNNyddyMRimS0thBBCCCGOXDKe4adfuput6/YRDPsorYyitcYctp9sNkdTKkVlPy+8bWKrUgpTWWyMLW+XJO+rtmT8rHbGUWraeA2btOsl7gYAMBW42qEh21DgKIUQx5qAp4TThl5R6DDeE9vNo7WLoTqvEqJoLb1u63yPxdCvoohrzjmBa8454bDPsx2XpS9vYdHS9eze10TAb3HyjOGcceo4qiuih32tODKuVqhuXvntykpyIYR4b8aUlXNCv/4s3b0Tj2Hge6PsutaaWDaLoRSXj5+AoRRaa9bVHuSJjVvY0dhM1O/j1OFDOHX4kLbXCSGE6H7jh9Xw4xvP55Gla3nuta3kbIdB1cWceeIYzp49Fr/PKnSIR52natfzzz2vMSDQyMjIdsJmM0ppHG2yO1XGbesy/GrWpwmYHSeICSGEEEII0Zmlj69m24b9lJSH8bS1QlL4IgZKtSbR06kcgZCv3esMTHJupvcD7mWN2Rgtdh5LaepsL4byYyiDt27da1prFvoLF6QQQvSyUm8VluEj52YJmB3voed1FsvwUuotbCvTfN7hF396iqWvbMV1NT6vSSKV5d5HV/DMsk185ZNnMmpYVUFjFH3fsddwRghxTFNK8Y1T5zG1uoZYNkNtIs6BRIIDyQQA102extkjRuFqzW+ef5kb73uEe1eu4dXde1m8aSvfffwpbvzHw9QnkgU+EyGE6NsGVZfwyQ+cwl+/fw13ff8afnPzZVw8b5IkyDuhtebhvSup8e9javFrRD0NuBjkXQuFZmhoPyPCz7Kk9uVChyqEEEIIIY4hSx9fhVLqbQnyVm5T4I22SC7JeMdkuK1zVPj691KUhbExtouvr/49TTnjjRVtLrbrkndtXO3SmiB30BiUegcXOFohhOg9YauYkZGp5J00jnba7XO1S8ZJUhMYSo1/SGECfMPjz67luZe3EAx4qSgLE40EKCkKUl4apr4pwW3/8xT5vPPuA4nD0rpnHl2xZMkSzj//fPr164dSigcffLBtXz6f5+abb2bixImEQiH69evHNddcw759+w475ne+8x2UUu0eY8aM6fLfjyzFFEL0utJAkF+efT7Ldu9iyc4dJPI5BhUVccawkYwsKwPgkTUb+NuKVShAO5p4PgeAz2Oycm8tP1z0LD+76OxO+5oLIYToPoah8HmPrY+Mruuy7qWtrHphE/mcTf9hlcw6cxKR4s77cb1fGTfPrsR+Ti7fjFIuWTcAb6xfsbWJrT2ErSQ7k48Cp/RIDEIIIYQQou9pbkxgvSNBDmCvK8c6YS9G2MGx2ycQcm4GhWJSyZzeCrPXJfJpfrHpXhqyLYStUhKOTcRM41EuGo2rHZQyUBjkdTHji6cWOmQhxHHkQKaRpXWrqM004jd9TCsZxaSiYZhGx+t5T5lbeQkHMruoy+7BVB48ysLRNnk3R7G3nDOqP1TQ++qO4/LvZ9ehlCLgb78YwzAUxdEg+w42s3z1TmZPG1agKEV3SSaTTJ48meuvv55LLrmk3b5UKsWKFSv45je/yeTJk2lqauKzn/0sF1xwAcuXLz/suOPHj+fJJ59s+9nzHqoPH1t3PIUQfYbXNJk7ZChzhwztsM/VmvteX0M6lyeTs3G1bit7kXBaZwM/v20n6w/UMa66slfjFkIIcXRrrovxyy/fxaZXt2O/7YbhP379BNd/8xJmnj6x249poKjwH8BvZsi/LUH+9mc4rokyN5BzknjNnknWCyGEEEKIvqWsqojGg/EO23WLn9ySQXjmbIdIhoyTQqHaSqyPi85kbHRmb4fba5Y1rKEh10KJNwJ4STkJDFxCZgZTtS5v09ol5/op9Q1mYtGEwgYshDhuPLb/Re7etZi0nUWjUSierH2FsdHBfHbUZRR5w70SR9Qq5arBX+DVxqdY3fw8GTeFzwwwpWQeM0oXUOIt7D315liagw3xDgnyN1mWidawY0+DJMnfp9aV3907IeLNleSxWKzddp/Ph8/n6/D8s88+m7PPPrvTsYqKili0aFG7bb/61a+YOXMmu3btYtCgQYeMw+PxUF39/toGSJJcCHHUqY3F2dbQRDqbB8BjGLiui+O4oMFV0JLO8NjqjZIkF0II0cZ1XX755btY++JmoiVhfIHW/t+O49JcH+N337iHksooIyd3b7lFn2kxPBzA1aA76WaktcZRJl5Dk3aaJEkuhBBCCCGOyKlnT2Lzqt3kczbWO6o7xZ4vRe2FmZ8KE2cfGpcKXz8ml8xlaslcTNV7KxZ724bYLrQGUxlAgKjhJWBmUEpjaxP9xqdyn5mlypdHaynXK4Toea80rOevO55AoynzRttWamfdPGtatnPHlgf5ytire20Fd8hTxKmVF3NKxQXk3AyW4cNUHlxX8+qWPazeUYvWmpH9ypk1ehCWp/feNzweA6UU+hB1u7XWaK3xmH33vay3aK16IEneOt7AgQPbbf/2t7/Nd77znfc9fktLC0opiouLD/u8zZs3069fP/x+P7Nnz+ZHP/rRYZPqnZEkuRCiVzTEkjyzehu1TXGCfovZowczekBFpx8KHK1J5fK4aCzDwM47uG9/w9TganhoyWqunzGNkhJJNgghhIB1L29l04rt7RLkAKZpUFpZRP3+Zhb97YVuT5IDTC0dxcaWF7BdG4966yO2RmNrl5Bp4Df9eA15zxJCCCGEEEfmpDMm8Py/V7PutZ34AxaBkA/talKJLPm8w6mDZnPDxPPJ6jSutgmYEQzVcdJmX6Pf+A+AIkvQbABMXG0CbuuqOWVQ4S2nLruL15qe4cTyzlewCSFEd9Ba8+j+ZeS1TZm3qN0+n2HhevysbdnG1sReRkQG9GpshjLxvzFZf39jjB/cs5jN++pxXE3OZ5MP2JQ9F+KLp89j3vDhvRJTNOxnxJAKVm/YSyjYceVxJmtjeUwmju7XK/GI92b37t1Eo9G2nztbRd5VmUyGm2++mauuuqrd2O80a9Ys/vznPzN69Gj279/Pd7/7XebMmcOaNWuIRCJHfDxJkgshetzDL63jf554mXgmi6J1htjfn3ud2WOG8MVLTiXo87Z7fnUkjKFBA47t4rqazibYJVJZ/u+vL/CZG0/vnRMRQghxVFv9wibsvIO3k3JdSin8QS8rnlmHnbfxWN37MfiUynPYk3wAVyfIOApF6/uYAvymSdRyqAlMJuAp6dbjCiGEEEKIvssf8HLTf13OPb99mhefXEusMQUKoiUhFlw0jQs+fDKGYRDg+JqIOTIygKV1q3C0S8BsJGzGKTIzGEDC9VOXDxEwg1imj6ybYlXzc8wsO/O4mEAghCiMlnySbYl9BIzOk4R+w0vKybCmZVuvJ8nflM7l+fZfn2DL/gbCUYsDFTHiviyOcqnXCT657B+cVTuab844gxJfsEdjUUpx/sJJbNh6gOZYiqJIoG0xXS5nE09kmDp+IKOHV/VoHMcD/caju8cEiEajh01kd1U+n+fyyy9Ha81vfvObwz737eXbJ02axKxZsxg8eDB///vfueGGG474mJIkF0L0qOfX7eA3/1qG47pUREIYhiKXyZPMZHnqtU34PAY3X3Zau9dYpkn/cJRYQx22S7sEuQa0AYYDXkfxyivbqKuPU1F+5LODhBBCvDeu67Jr/V6SLSnK+5dSNbii0CG1k8/aAIcsXWYYBq6rsfNOtyfJg55Sppdewqqmv5N1XXKuB4VJ0DQwjSw+o4hxxZd06zGFEKIr8rk8O9a0luztP6KaovLuu5khhBCi54SjAa78j3lMnjaAg/taqBlexZgpgwmE3v9qrXdj521WPb+JtS9uwbYdBo6sZtaZk4gUFzYpf3L5RB7as5Rkvo7ZkVepsOpRbb3IIenzUe9ORAMew0fCbsHWebyq5//OhBDHJ1s7rRPlO6uamnfI52wcXHKO3fvBvWHJmm1sq22gOOpjR3UDSSuHxzXwuiYayGuHJ/duJunmuf2ki/GZPZs+PHHqUK65ZBZ3PfQK9Y2J1sSrbq0GOH5UDTd99LReK00vCu/NBPnOnTt56qmnupx8Ly4uZtSoUWzZsqVLr5MkuRCix2it+cfzq8jaNlVFYbLpHI21zWSSGbSrcSyTBxe/xlR/mDPOn9nutRdPHMuWpxrIKRetWr/kAKDAcMHKQJn2kc7k2LmzvkeS5FprXtm3l0c2bWBTQz0By2Lu4KGcM3IUlaFwtx9PCCGOZq/8eyX33/YIuzbsw7UdLJ/FhDljuOorFzNwdP9ChwdAv+GVKKVwHBfT7LhKJJPOMmRMv3al2LvTxNIrUcpkU+wRsk4ccFHKJGoNZEbZxyj3j+6R4wohxOG4rsu///Q0//rDYhr2NaJdjT/kZ/YF07ny5ouJlslkUyGEOFplUln+8fOHefbvL5BoSoJSFFdEWXD1HC688Swsb8cKSt2lbl8Tt3/+/9i2dg+u47Ztv+/XT/Cx713GtHnjeuzY7yZqhfjUiAtZfuDTVFh1OFrhaA8ahYlL1MwSMtexxzkBV9v4jEC7lkhCCNHdSqwwZd4otZlGAmbrhBw779BY20SqJY1ruOiwYtGdT1Jxuo95V5zU6wnglzbuQmtIRLKkrDyWY2LQGoMCTNeAHKxq3Mez+7dyxoCev4dx4RmTmTFpMEte3sze2mYCfosZEwczbcIgLEv6kXeHnuxJ3l3eTJBv3ryZp59+mrKysi6PkUgk2Lp1Kx/+8Ie79Lo+9+ng0Ucf5Xvf+x6rVq3C7/czd+5cHnzwwUKHJcRx6WBLkk176wj7vGTTOfZvP4iTdzA8BobHQLmanO1w+88eoNTnY8YZk9tee/ak0dy1dCW7W2JggWuC0mDlFTgar2tQmvWQUQ4eT/eXy3K15lcvv8jf160m7zhYponjatbVHeT+DTyiTAAA6RlJREFUDev48YIzGFtR2e3HFUKIo9HzD77M7774v2SSWcKlYTyWSTad45XHVrJ99S6+ftfnGDCq8H2iTjxzMvf96gma62OUVha1+8KZSWUBOO2yE3vsi6ihTCaVXsmoonPYn3oNW6cJeaqoDkzEkJtyQogCufu/HuCfd/wbpRSh4iCGYZBOZHjy/5awc90evvbXzxIqOr7K9AohxLEgn8tz23/8jhWLVmH5vYRLw6A1LQ1x7v3pP9m//QCf+sX1GEb33xPJ52x+cdP/sWXVLorKwnh9rcl4x3Fprotxx1f/xjf+9AmGjCncd4AB/gaagknSTjF5N4nSYCgDU3lwAEtlKFK7adRlTI6eiqEk2SKE6DmmYbKgajp/2fkEGSeHpU1qtx8gl86jPApdbGIdhJZF9fz+yf8j0Zzk/P84o1djTGXzGErRFEgCui1B3kaB0gqN5ql9m3slSQ7Qv7qYqy44oVeOJQojkUi0W+G9fft2Vq5cSWlpKTU1NXzgAx9gxYoVPPLIIziOQ21tLQClpaV4va0LXRYsWMDFF1/MjTfeCMAXv/hFzj//fAYPHsy+ffv49re/jWmaXHXVVV2KrU81Yrnvvvv48Ic/zHXXXcfrr7/O888/zwc/+MFChyXEcStv22gNpqForG3GyTt4vCaGYaCUwjAMDNMgreD3P7yfWCzV9tqKaJhvX7yAYN7AkwFfSuFNK5QNPtdgRDqIHc9TFA0wckR1t8e+aNsW7l67CsswqQpHKA0EqQiFqAiFqU3E+dYzi8nahSuPI4QQvSWbznLXD+8nl8lT1r8Uf9CHx/IQigYp619C/Z5G7rvt0UKHCUC4KMgN376UQMhP/f5m4k1JkrE0DQeaScbTnHjmZOZd0vNfvPxmlKGRuYyMnkW/4FRJkAshCmbPpn08/sensPwWJdXFeP1ePF4PkdIwxZVFbFmxnafuWlroMIUQQnTipUdXsPKpNUTKIhSVR7C8HiyfRXFFlGBRkGX/XM6apRt65NivP7eB7Wv3tEuQQ2sJ3NKqIpItaRbfs6xHjn2kGjPLUDgUe0sImx58ho1X2W1rIl2tCKq9hD0lTC897V1GE0KI9++smlnMLB1Lysmwv6WerJmHEhNdauCJQ+UjHsqrSlBKcf8vHqXpQHOvxjeksgRXa/KGg+pkJbDW4LXM1kR6NtXJCOKYpHvo0QXLly9n6tSpTJ06FYDPf/7zTJ06lW9961vs3buXf/7zn+zZs4cpU6ZQU1PT9njhhRfaxti6dSv19fVtP+/Zs4errrqK0aNHc/nll1NWVsaLL75IRUXXWkP2mTt2tm3z2c9+lltuuaVdU/Zx4wpX+keIQtrUVM9rdftwXJcxpZVMqajB6OUSLuXRMNGgj8aWJJlkBsM04G0z1PKmwjEU2YpiNqRcPvrFOznn9Mlcdu40QkEfs0cP4f9Nmcrdz7xGPqgwPSYRx0NZ3oOdsknZDgsXjCfUzX24tNbcv34tjquJBNuPbShFWSDI7lgLz+3awcJhI7r12EIIcbRZ+fRaGvY1Ei2LdFiBbRgGgYifFU+uoulgCyWVRQWK8i0zFkzgq7+P8sTfXuC1Z9bhOC5DxvTntMtmMffiE464F/n2eCP/3rOBzS11+E2Lk6qGML/fCIKeninVLoQQPeGFh14hk8pR1q+kwz6P14MyDZ655wXO/8SZBYhOCCHE4Tx334torTttFRQI+0m2JHn+gZeYdGr33/tcvWwzjuO2S5C/SSmF12fxyuI1XP+tSwrWL9Z24jhuipQbx8DBa2i01miy5F0frgKvYXBJzaco89UUJEYhxPHFMjx8ZtQHeLb2NX55/99QJQpPVhFap4iuMLGaWq+XkbIwjfubeenRFZx1fe9N4lk4dSQPv7wOlVG4kfZZTkdrlIKioJ+4ztI/VNxrcYm+b968eWh96Mz64fa9aceOHe1+vvvuu99vWEAfSpKvWLGCvXv3YhgGU6dOpba2lilTpnDLLbcwYcKEQ74um82SzWbbfo7FYr0RrhA9pjGT4gcvPcOLtbvIOg4K8BgGY0or+PaJCxgS7XiDrKf4vR7OnD6aP//7FRzAY7RPkOe9JkZe4027uLZLKp3j/sdfY8uOg3zjM+fg91lce8XJZGJZnn9+M7m8Dbi0kMNrmZw2byyX9sCKwLRts7mhgaDVeW8vyzTRGtbX10mSvIDk+i1E72iqbUZrjcfb+cdGr99LOpam+UDzUZEkBxgxaRAjJg3CsR3svIPXb3Xp5t0/tr3OHeufJ5nPoVTrbOrF+zZx15YV/GjmuQwKt76X2q5LxskT9HjbJqLtamrmodXreWbLdtL5PMPKSjl/whgWjBqOpwdKYR6r5BouRO9oOtACWh/yGuj1WzTWNuG6bo+U6xV9k1zDhegddXsaMA8zwdMwDA7ubuiRY9s5m8MtEzMMAzvnoA/zHtPTUvZOXDIoPCg8GErh4gIOpplHEaA0MI3+weEFie9oJddwIXqWZXg4wTuaol/kME2DQKTj/eU3q6w21jb3amwjasq5et40fvPyCyRDOfI4GNrAdTUKKAr5wQTLMTmzl0qti17QAz3J6e7xCqjPJMm3bdsGwHe+8x1+/vOfM2TIEH72s58xb948Nm3aRGlpaaev+9GPfsR3v/vd3gxViB6TcxxuXvo4Kw7uI+r1UezzA5BxbFbV1/L5Z//F7xdeTFkg2GsxXXbyJF5es51XmpPkAFODNiDvMVGOJtKQx3BbZ/tGgj48QS+rN+zjyec2cN7CiViWyac+sZDTF0xg2YtbaGpKUlISYvaJIxg1qrpHvoy9OeK7zV/q7ZX5oj25fgvRO8IlIdDg2A6mp2MfPztnY1om4ZJwAaI7PNNjdhrz4bx4cCe/XPscLpqqQLjtfSbvOmyJ1fPN5Y/xrWln8MCO1Szet5msY1PiC3L+oPGM8lXyw38/S2Mqjdc0MZXitb37eX1fLS/t3MPXTp8rifI3yDVciN4RLgmBUodMYtg5m6KaEkmQiy6Ra7gQvaOoPMrezfsPud91XYoroj1y7P7Dq1BK4TruG1UB28tkcoybOLxg7x9Z+wDp/Hbe7CT65nucoQy0VmjyQJ7K4LkFie9oJtdwIXpeIOzH8lpk01kCnezXb9wLDxeHej22q+ZOoV95lO+99gR7zGZc18Hn8RAJ+MADCTvHuYPGckLFoF6PTYhCOOq/CX/lK19BKXXYx4YNG3BdF4Cvf/3rXHrppUyfPp0//elPKKW49957Dzn+V7/6VVpaWtoeu3fv7q1TE6LbLd23g9frain1BwhZ3rbfkYDHojIQYme8mUe290y/qkMJB3z89D8uZGwKPIlsawJaK7wJl6IDeaycxnFcPJZJIBLAa3lQCp58fn3bGEopRo+u4SPXzuGmz53FR66dw+jRNT02WzlgWUysqiKdz3e6P+fYGEoxqbL7e6GLIyfXbyF6x9QFE4mWR4k3Jjrs01qTbEkx7qRRVAwoK0B03e++7a+TdW1KvIF27zOWYVLiC7C++QA3LLmbe7e93rrSHKhNxfjNuuf51NL7aEgnqQyHKA0GKAr4qQqHCFkWT2zYzMNrevc9+Ggm13AhesfMs6fi9Vmk45kO+xzbwc7ZnPqB2QWITBzL5BouRO84+aKZAORzdod92XQOwzA48fwZPXLsk86ZQqQ4RHNDvEMJ1HQig2ko5n9gZo8c+0g0ZV7C1Vm8RmvfUa1ttHZBt64kBzCUSbF/asFiPFrJNVyInuf1e5l9wQyy6Vxb3urtki0p/EEfM8/p+jXqSMpSH45SinkThvOvqz7KZyfNYUR5OdGIH8NSVAUifHLcSXxl8gJZHNaHaN0zj77iqF9J/oUvfIGPfOQjh33OsGHD2L+/dWbl23uQ+3w+hg0bxq5duw75Wp/Ph8/Xvf2MhSiUZ/dsx9EuPrPjr7ZpGJhK8cTOLVw7blqvxhXy+7j5E+dxyw13kEplSY/sRzwSwLRdbMdFASVVxag3yrF7vR4O1MdxXY1hFOYN+QNjJ/Dq/n00pdMU+/1tiRLbdWlIpRldXs6JAwYWJDbRSq7fQvSOUDTIxZ8+m798/x80HWgmUhrG9JjkMnnijXEipSEu/kzfWKGRdWxeq99LwOxYnt11NUorWnIZ0naeIZHSti+NYctHYypNo4rhLfZg2O1fG/RaJHI5Hlq9jgsnjpUvm8g1XIjeMmLqUGZfOINn/74M23YIFwVRhiKTzJJoTtJ/eDULPjSn0GGKY4xcw4XoHSdfdAJP372Uza9uIxANEIwE0BpSsRSZRIbJ88YzbeHEHjl2cUWU6755Mb//1j9o2N+ML+Btff9IZTFMg7kXz+Ckc6b0yLGPhKNToBQ+swzT9ZJzmnB1Bg0oZeFRIQxloek4weB4J9dwIXrHuR9byKtPvE79vkYiJWF8QS+u45JoTmLnbM79+OlUD6l813G0s59E8t/sSa1mS+og2/NRSnwDmFw8h/FFJ2Kq95bi83ssPjXxFK4fO4udiUYAhkbKOs0rCNGXHfX/4isqKqioqHjX502fPh2fz8fGjRs55ZRTAMjn8+zYsYPBgwf3dJhCHBVashkMDn3j3TIM4rmOq0h6w4RTxvK533ycv3z/H6xPZdEhH7btYnlNSiqLiZS+VabXdlyKIoGCJcgBThk0mP83fSZ/WLGcA8lEa28rrVEohpWU8J/zF2KZXSvhK4QQx6qzP7oAw2Py0K8eo6m2GcdxsXwehowbxDXfvZzRM/pGnz+t9Rs31t56/7Edl8Zkilg6i4OLbbkYWpHN2wS8b/UWc1wXtCJhZXBsF/MdBZuClsWelhixTJbigL+3TkkIcZxTSvGxH3+YSEmYZ+55nsb9TWgNvqCXyXPHccMPr6a0uqTQYQohhOhEIBzgi3/8FH/6xt9Y+dQaGvY2tm2fd+XJXPudy7G8HXvddpfZZ0+hvKaERfcs47Vn1+M6LqOnDeW0y2Zx8nnT3lOpddt2WL1iJwdrW/AHvEyePoTi0q6XG/abNYDC1Xk8RgSPEcHVrX3UlfJgOy2YRgCv+e73lIUQoifUDKvi5js/zR+/fhdbV+4g3pjAMBTR8ghnfGQ+l3zmnMO+XuscOvFr7NSD4DTST7v08yumegM8m6rlX/u2sDWxivP7fQyP8d7fCwIeizHFVe/59eLop3ugJ3m39zgvoKM+SX6kotEo//Ef/8G3v/1tBg4cyODBg7nlllsAuOyyywocnRC9Y1CkmOfYcciegznHYWCkuPcDe8PU0yYy6dRxPPrAS/zun8vxeT0Ul4TbVpBDa0+tfN5h7okjCxYntN5Q/PCkKczqP4B/bd7ElsYGApbFyQMHs2DoMCIy61YIcRxRSnHWdfOZd8VJrFm6gWRLivL+pYw9cWSf6mPr91iMLCpnZcNeIpYP23HZ09hC1nYwFGiztZ6Uk9PsycXoVxwh5PMCrX9HylU4Hpe8YWO63nZjv/neLD3JhRC9zeuzuObbl3PBJ89k3bJNOHmHAaP7MWT8wB5rXySEEKJ7lFQW8fn//g/2bzvAlpU7MAzFyOnDqBxY3ivHHzllMCOnDMZ1XVzHxWO991vJq1/byZ9+vZjafc2t/XjRhMJ+Tj9vCpd96CRMz5F/Ti4JzMZv1pCx9+E1K1BKYbyxmtLVNo7OUBU4D48RfpeRhBCi5wwZP5DvPvBltry2ndrtB/H6LcafPOaIepHrxO3o9P0k7RQp7cFUHgztUmRkOCu0ncdSk9gYW8GAwDOcUHZ6L5yNEH1Tn0mSA9xyyy14PB4+/OEPk06nmTVrFk899RQlJTIzXhwfzhoyivu2rCWWy1Lka79KLW3nUUpx/rAxBYqulekxOe/S2aw9GGPZim0k0zlCwdZEQjZnE09kqK6Mcuap495lpN4xqqycUWW98+VTCCGOdv6gjxlnTC50GD3q4iETWd24n3g+SyqdJ2s7eEwD0OSN1iS5pQwcR3MglmBoeSlKta4Ux2jty6TeMaNWa00yn+ekoYMI+7ydHFUIIXpecUURJ11wQqHDEEII8R7UDKuiZljhVvoZhvG+Jsdu3rCfX/zwERLxNEXFQSyvB9d1ScQzPHTPS7iuywevP/XI41FehpXcxMaG75J1DuAxQig8uDqDo7OEvCMZWHTte45XCCG6i1KKkdOGMXLasCN+jbZ3QeYx8togrQ1M1VrN1MUgqX2EVZbJvr3syQ9mZfMSppcuwFAyIV8cglatj+4es4/oU785lmXx05/+lAMHDhCLxVi0aBHjx48vdFhC9JqxpRVcNXoSOcfhYCpJKp8nbeepTyeJZbPMHzCMBYMKXxLXMBSfu+E0Tj9lLAD1jQnqGxNkMnlGD6viGzeeTUVZpMBRCiGEOB6d3n80lw2dTNaxacyl0KaLbTjkDQev68FyTFwFHlORt12S2RzQ2nfc41EYeQOdf2s8V2saU2n8Hg8fmDyhQGclhBBCCCFE4Tz8j1eIt6Qpq4hgeVvXbBmGQbQoiNfn4clHXqehLt6lMUsDsxlf8RPKA3MBcMliGiH6R65iQsXP8Zpl3X4eQgjRK3IvgE6T1Z2tcVXktEl/s56wYRLL15NyYr0eohB9RZ9aSS7E8U4pxScnn8iASBH3bFzFrngLGk1VMMJFw8fxwTGTsYyjo492wO/l09fN57LzprNqw14c22FQ/zLGjqju9l7k8XyWJfu3sj8VI2R5mVM9jAGh4m49hhBCiL7BUIrPTDiVAVYJ31+6CMfnYDoGRbkgpdkQdf4Y9f4kCtBo8o6DqzXNuTTF/gBVFFPXnKFJZ+GNEuthn5dPnDyLE4cMLPTpCSGEEEII0atizSlWv7qTYNjbaZuPUNhPY32CFS9t5fTzpnRp7KhvEtGKSeScRhw3hdcswzQC3RS5EEIUiE4CBuoQa1xdFB6l8SibrPZhSppPHIbWrY/uHrOvkN8eIfoYQykuGj6OC4aNZU+8BUe79A8X4TWPjuT4O1VXRKmuiPbY+P/es4Hb1zxHQzaJQqHR/Pf6ZZw3aByfHn/qUfv3IoQQonAMpZhTM4zqphI8hmrrOw5QkyrGUZoWbwrX4xJzsuQyNmHLx8fGncjFQybx0o7dvLhzN+m8zeCSIk4fPYJ+RT33XieEEEIIIcTRKpXM4jguXn/nt6ENQ2EoRTKRfc/H8JqlYJa+59cLIcRRxagBNF5lAa0t3N4+ycijXLLaIuY4DAkNxW8/j5t4DOw9YBSh/AvBfzbKKC5M/EIcQyRJLkQfZSjFoGhxocMoqBcO7OBHKxeTdWzKfCE8hoGrNYl8lnu3v46pDD43cW6XxozF0ryyfBtNzSmiET8nzBhGSUmoh85ACCFEoVQVhZk4oIqXt+0h6LXavpAaGAxMluJr9pIN5jl/zFiGFZeyoN9IKgOtrULmDB/CnOFDChi9EEIIIYQQR4eikhCBoEU6lcPvtzrst20Hjaa8UiaVCiEEAL5TIflbvG4jXsNH1s1gaBOlFAYuJi4bcmV4lcWZwS3o2EOABrzg1qIT6yH9KBT/GGX2L/TZiELTbzy6e8w+QpLkQog+SWvNXzYvJ+3kqfKH30puKCj3GTTnNA/vWstVI6ZRFXj3/udaax57fBX3/uNl4olM66p0rfnrXcu48IJpXHTh9G4vEy+EEKKwrpo9hbV7D1IXT1ES8mOZJq6riWeyKNvg+ikz+fj0WYUOUwghhBBCiKNWIOhl9twxPP7gChzbxfS8VT5Ya02sOU1JaZjpJw4vYJRCCHH0UEYYwp9Gx/+LYjNJHJO8m8eDi0e5HLRDrM0N5tLyciL6WVBFoPxvDaBtcLaiYz+C4l922upCCNFKkuRCiD5pfzrOuuYDRDw+lFIoXCZG1jOz6DWqfHUAbEpUsuZgiKrB177reM88u4E7//I8aE1JcQjTNHBdl3g8w91/fwmfz+Lccyb39GkJIYToRdOH9Odr58/jl4te4GAsCbTeyAv5fVw1YwLXn3pCu+c3tSR5etkmlq/aSS7vMHJwJaedPJqRQysLEb4QQgghhBBHhQsum8ma13axe2c9/oCFz2/h2C7JRAaf38vVHz2VQND77gMJIcRxQvlPBxXFSP2VqL0W282QdWG/HkVL4Gw+WHUS0fiNoD3tE+QAygMUQX4N2OvAGl+QczhStQ0xnnx5E6+s20Xedhg7pIrTZ41mzJCqQofWJ2it0Lp7J0p093iFJElyIUSflLHzONrFZ3oAzZnlT3NiyasYuGTd1i9e4yO7CKifE08oIuFrDjmWbTs88OCrOI5LWWm4bbthGBQVBWlqSvLQwytYcNq4TkuHCSGE6F6udsi5WbyGD0OZPXqsOaOHcsKwgSzbspMDLQlCPi8nDh9IRTTc7nmbth3gx795grrGeGsJNEOxcesBFr+wgQ9eeAIXnTmlR+MUQgghhBDiaFVaHuarP7iU+/66jJeWbiKVyGKaBmMmDODCy2cydeawQocohBBHHeWbBd6ZKPcgXp3Ga1QQNVrbfmp7C9ptBnWoNqABIAb2xqM6Sb5y015+fOdimuIpTMNAKcW2vQ0sXr6Ja8+dycXzJhU6RNHHSZJcCNEnVQTChDxeUnaeiZGdzCpeQd71kHFbZ9ZprUloLxEvtMTvwOc7Ea81qtOxNm85wIGDLUTC/k73RyJ+mpqSrFu/l2lTh/TUKQkhxHEvlm/k1cbFrGlZRs7N4DMCTCiezfSSBUSskh47rt/yMH/socs/ptI5fvrfT1LXGKesJIRhtJaQ1FoTi2f4ywMvM6h/KdMmDOqxGIUQQgghhDialVVE+PjnzuDK6+bQWBfHH7Co6lcsZYCFEOIwlFJgvrWi2tUu2xP12PmDDNMa810voW8tLDiYjtOSy1DmD1HqC/ZMwF3Qkkjz0788RXM8RUXxW+1Stda0JDL8+ZGXGd6/nEkj+xU40j6gD/UQ726SJBdC9EkRy8cZA0Zzz9aVTI6uwlQOCeetmXW21vhME7+nFNetJZl6BG/R5zsdK5vN47oa0zQ63d9ael2TyeR75FyEEEJAY+4Af991G025WkzlxaM8pJw4y+r/xabYCi4fdBPF3oqCxLZsxTZq62KUFL2VIIfWL7NF0QB1DQkef2adJMmFEMcl13VZtXQTSx5azr5tBwkVBZh5+kROOncqkeJDrXwRQgjRV0WLAkSLAoUOQwghjjlLDmzkbzteZEeyHqVtfjxUM9B3kIDVD8t4R6pPJ1vLsFuTWNO4n//d/ArL63ZjaxevYTKnehjXjZ7F4HDPLTh4N8+u2Ep9c5Ky4lC7CVNKKYojAQ42xXnshXWSJH+fpNz64UmSXAjRZ1078gRWNuylwltLzjVwtUYDrtaYSlEViGAohcYgb28+5DiVlUV4vSbZbJ5g0Ndhfyabx+s1qaoq6sGzEUKI49vi2rtpytUS9pS0lVj30Vp6vT67n8UH/s6lAz9VkNg2bTuI1hqPp/PJVD6fh7Wb9uG6GsPoO18khBDi3TiOyx+/ex9LHlyObTt4LA+O7bDu5a0sunsZX/zVdVQPLi90mEIIIYQQQhzVHt+3its3LCLr2ES9fjzKx+LmsXyw4iVSmVrK/NVvJcp1FoiDdwErmi2++vJDtOTShC0fIdNL1rH51+71vNawl9tmX8TQSFlBzmnjzoMAmMYh7qVYHlZv3d+bIYnjUOf/+oQQog8o84e4bfbFlPnK8BitCXIFRL0+BoaLCXlae5NrXAx16FnM/WqKmThhIIlkFtd12+1zXU0ikWHE8CqGDS3MCkYhhOjr6rP72JnagM8IdehBbigTnxlkR3INTbmDBYpQCCFEZ568+wWevv9lvAEv5TUlFJdHKKsupqQiyp4ttdzx1bs7fL4WQgghhBBCvCWRz/CHLUuwtUOlP0LA9GIZJq+kJvNsbAJgk7P3krf3ksptJ57fy+ZMMUvSs7ht9SJi+QxVgQhhy4fP9BD1+qkKRNifivHbdS8U7LxaF48fug641q338sX7pHvo0UdIklwI0aeV+oKMKr+YMp+PoeFihkfL6R8sImBaAGidBxR+/6mHHefDV59MdVUR9Q0JYvE0mUyeeDxDfUOcstIw131kjvTREkKIHtKQrSXvZvEaHat5AHgNP3k3R2O2tpcjazVqWCVKKWy780RPNptnwuh+sopcCHFccRyXJ+95EYUiGPa322d6TKIlYbav3cOG5dsLFKEQQgghhBBHv2X1W2jOJSmx2pcl1ygeaDqJ/9pzBk809+P1VJDlqXLubp7E7xpGc8/eJ8lZKyj10+G+taEUYcvHy3W72Jds6e1TAmDc0GqUMnCcjvdStNbk8zZTRg8oQGTieCJJciFEnxcKXoTHrMGgHgO7bbvWWRy3HssznKD/9MOO0b9/Cd/6xoWcdcZEvJaHXN7G4zFYcNo4vvmNixg2tLKnT0MIIY5blmGhMHDpPAntageFwjSsXo6s1expw6iuiNLUkmy3IlJrTUssjdfycObccQWJTQghCqVhfxN1exoJRvyd7vf6LRzbYeua3b0cmRBCCCGEEMeO+kzijXsenaXzFLVugAdi/fhby0yezsxhnzuCiFWKlwAeM0dxeCedLf31mx6yrkNtOt7j59CZU6cOp6o0TGNLEucd91Ka4mn8PouzTxpbkNj6FtVDj76hSz3J//Wvf3H//fdTWlrK9ddfz5gxY9r2NTU1cemll/LUU091e5BCCPF+eMxqykp+SmPz17DtPeg3PhQoDLzWWMpKfoJhhN51nOrqYj7+sfl86OqTiCcyhEN+QqHOVzUKIYToPgOCIwl7ikg5cUKeog77M26SiFVC/8CwAkQHwYCXL358IT/+zRPUNcZRSmEYCsd28fstPnjhCUybMKggsQkhRKG8uVpFH6YUnz7cTiGEEEIIIQQRy4+LxtUuhnpnolxjGo0oIORp307UNEwcx8RjpvF4WrDt4nb7bdfF88aK8kIIB3185dqF/PBPi6hrTgAKpRSu6xL0e/n4xbMZN7S6ILGJ48cRJ8nvuusurrnmGs466yw2btzIL3/5S/7whz9w9dVXA5DL5Xj22Wd7LFAhhHg/fN5JVFXcSybzLLn8OkDh807F7zsZpbq28jAY9OHzWaxcsp6lD6+gbm8jRWURTjxrMjNPn4gv4O2ZkxBCiOOU1/AzqfhUltQ9gJNvImxGMQwTrTUZJ4nWmhmlC7EOUY69N4waVsVPv3EJTy/bxKurdpHN24wcXMlpp4xm5BCpNiKEOP6U1RRTPbicXZv3E+hkYmk2ncPyehg1ZXABohNCCNFXaO3Skl1BIrcRpUyi3kmEvWOlJZ4Qos+YXTGC3295hlg+Q7E32G6f1jZKZfEZPsx3JNBDlhfT8KDJYprJdklyrTWxfIaxxVWMiJb3xml0asyQKn7xhUt4ZsUWXl2/m5ztMHZIFaedMIrB1SUFi6tP6Yke4n1orvMRJ8lvueUWfv7zn/OZz3wGgL///e9cf/31ZDIZbrjhhh4LUAghuouhAgQDZxEMnPW+xsll8/z2a/fw8hOrcBwX02Pi2A6vPbuep+59kZt+cS3R0nA3RS2EEMe3nJvj8f1P8FLDcnKuiUfFSNgxLGXhM3x4TT8nlp7NjNLDt83oDSVFIS45ayqXnDW10KEIIUTBGYbBGR88mf/53n0kY2mCEX9bwsLO28SbU4yfOZxRU4cUNlAhhBDHrFR+B5saf0AytwmNA1pjKC9R/1RGlX4Nr1m4xI8QQnSXMl+YSwbO4C/bX6AplyRqBTCVQdbJE8vHqbYUYatjiyMDRakvSGMuS9LOo1wX0zDIuw5N2TQ+08NHRs3E6IVJRVprdu5qoK4uTiBgMXpUDZZlAlASDXLxvElcPG9Sj8chxDsdcZJ88+bNnH/++W0/X3755VRUVHDBBReQz+e5+OKLeyRAIYQ42vzz90+z7LGVhIuC+INvrYrJZ/OsX76dP/3nA3z25x8uYIRCCNE3ONrhzh1/5fXmVViGRcDoD+TIuY1kyRO1+vPhIZ+gwt+v0KEKIYToxLxLT2DP1lqevHsZDbXNGKaB67igYNj4/vzHj66UlX5CCCHek5zTyLr6m0nnd2MZxRiq9f6Mq9M0pV9kff03mFh5O4aSan9CiGPfh4edhMcweWDXchqyCTTgUQZDI/0YELaoz9V2+rqw5SGrfcTdIg5mU0BrN+mKQJhPjTuZuTXDezz27dvr+N//W8qmTbXk8jamYVBZGeXii6Yzf55U/uhxspL8sI44SR6NRjlw4ABDhw5t2zZ//nweeeQRzjvvPPbs2dMjAQohRHfKOzEaM0vJO01YZgml/pOxzI79bQ8lk8zy1D9ewvJ62iXIASyfRTDiZ+WS9ezfUUfNkIruDl8IIY4ra1vWsaZlDSFPEF9bKXUPHiNI1s2xK51iX6ZekuRCCHGUMgyDD998AScsnMjSf77K3u0HCUUCzDx9IrPOmIS/kzLsQgghxJE4mHyMTH4PPrMCpcy27aYKopSHeG4tDennqAguKGCUQgjRPQxlcPXQ2VwwYCorGneQdnJU+4uZVDKA15pX8pedd5G0kwTN4FvVm7RDwk4yOjKMn0z8OC8e3EVzLk2FP8RJVUMJeLrWgvS92LW7gR/++GEaGxKEw37CYR+27VJ7oIX//sMz5HI2Z50pK8hF4RxxknzmzJk89thjnHjiie22z507l4cffpjzzjuv24MTQojuorWmNvEAu2J/JO82g1agNJZRxIDoNfQLX35Es9Z2b6kl1pggHA10uj8Y9lO/v5ktq3ZJklwIId6nV5tW4Gr3bQnyt/gMLyk7yauNK5hcLF+ohBDiaKWUYuyMYYydMazQoQghhOhD6lNPgTLaJcjfZCgvWrs0SpJcCNHHRCw/c6vGtNs2rXgqB9IHWXzwaZrzzShl4GoXpRT9Av24dsiHKPYFOWvgmEOM2nMeePBVGhoSlJdFMIzWe+9er0FZaZim5iT3/uMV5pwympBMnu05WrU+unvMPuKIk+Q33XQTL7zwQqf75s2bx8MPP8ydd97ZbYEJIUR3Oph6jG3NtwMar1GGUiZaO+TdFnY030FTLstrsUo2xHdjKsWk4hGcWjGZSn9J+4H6UCkRIYQ42jXkGjE6uen1JlOZNOYbezEiIYQQQgghxNHAduMYh7m1rZTCdhO9GJEQQhSGUopz+p3F+KKxvNL4Kvsz+/GbASYUjWdK8SQCZueLvY5E0q5nZ+I5WnK7MJWXmuBU+gWnY6p3X4Xe0pJi+fLtBAPetgT520UjAZqak7y6Yjunzun9BL4Q0IUk+dy5c5k7d+4h98+fP5/58+d3S1BCCNGdXJ1jT+z/0Dj4zLdWdytl4jVLief3s7bhdzxaNw+lLDSaDbFd/Lv2ZT498lImFb/Vm2XgyGqipSESzSmKfB0/DKQSGfxBLyMmDeqVcxNCiL6syCpiF7vf+EkTNeopNmsxlUPaDZPMR4h4ogWNUQghxNFHa82G/XWs3lOL1prR1RVMGljT6c05IYQQx6aANZiMs6/TfVpr0JqAZ2AvRyWEEIUzODSYwaHB7/q8nOPw4o7dbK6rRynF1P41TO5fg/GOKqvb4k/zav0fyLkJNBoFbIk9QalvOHOqbiZkHb6KaiyewbYd/H5vp/tN00ChaG5OH/E5iq574y2x28fsK444SS6EEMeqeHYdGXsfltExkZJ18zTmHIJmmpGhDA12KQCu1jTlYvxq8338ePInKPFGAPCHfMy/dBb3/2YRmVS2XV/yfDZPKp5m9tlTpNS6EEJ0g6nFU1jTsgbtJhgXWEnUrEPhtu3vZ5lUhscVMEJI5A9Ql1mPxqXUOwTH3UdL5lU0NkFrOOWB+VhmUUFjFEKI40l9PMmPH32WlTv3kbMdQOExDUZVl/O1C+YxsLS40CEKIYToBlWhc2jKvITjpjCNYLt9to5jGD4qgmcUKDohhDg6bThQx/efeJqdjc2tBVO1xmOaTKip4ltnzqcqEgbgQHoNr9T/FsfNEzTLUMoAwNE56rObWHrgFk7v/6PDVv+LRvx4PCb5vI3P1zEV6TguGk1R0Xtf6S7E+yVJciFEn+foFBoH1cklL5ZPYWtFALCU3bbdUIoSb4TGfJyldas4v//Jbfsu/Php7Nt+kFcWrSbRksL0mDi2g1KKMTOGcd03Lu6N0xJCiD5vUvFERjQMJ+L+gyKzAVv7cDFxtcbFIWxo3Nx9NGVmUuI/oVdjyzkJXq3/A7tSy7DdNAZ5io06fMrGMgIoDECxy/wjI0u/QmngpF6NTwghjkfZvM0371vE2r0HiPp9FAf9rdtth7V7D/C1v/+bX374AopDciNOCCGOdWWBU6kILqAutQjbSeFRIUBju0mUUvSPXE3YK+V7hRDiTQfiCb76yBMciCcoDQTweky01mRsmxV79vH1Rxfx6w+cj8/jYVPLv7DdDEGzHPW2Feam8uI3imjIbaE2/Tr9gtMOebyioiDTpw1hydKNBIO+DlWdYvE00WiA6dOH9NQpC2htH9vdK7/70Epyo9ABCCFET/N7ajCUF0dnOuzLOFks5eJiknLD7fYZygANG+K72m33+ixu/MkHuen2aznxzMkMHtOPqXPH8okfXclXfvdRoqXtxxFCCPHeeA2LK/qfSD9fkrxrkdNgaweAkCdM1DsArbPsi/+9V+NydJ6lB25hW+JplFYEzTJKzUYs0uS0Q9Z18JoVeM0y8k4jmxq+TzK3pVdjFEKI49HSTTtYv+8gpaEAQZ+FUgqlFH7LQ3kkyK6GZp5Ys7nQYQohhOgGSpmMLP0qQ4s+RcDTH5csLnlC3hGMKLmZwUUfb5fYEUKI490jazdyIJ6gMhzC62ldAa6UImBZlAUCbDhQx9JtO3F0ntr0SjzK3+l11GP40NrhQHrVux7z4oumU1oaoqExTjqdw3U1+bxNY2MCBVx26QmEQ/7uPlUhjpisJBdC9HlBayhR7xSaMi9iqkBbeZhWGp+RpdGuIeaUAJBO5chk8gDYXgftdpwaZXpMps8fz/T549/1+A3ZFrYk9gKa4eH+lPuKu+GshBDi+JC11xA0LML+avK69drsNbx42kp6BYllX8d243iMSK/EtC/1KrXpVfiMKB7Dh0c3YpJCKy8GCltnyboJ/GYUr1lBzjnA/sRDjCj9Qq/EJ4QQx6vnNu1Aa9120+/tPIaBoRRPrd/K5bMmFSA6IYQQ3c1QXvpHr6Im8gGy9gGUMvCZ1e+47yOEEALg6c1b2z4Tv5PX01q17/ntu5g7ov8bPcgPP9HI1fZh9wMMHlzOV28+nzvvXMqmLbUkk1kM06CyMsrFF03ntPmFbaF3XNCq9dHdY/YR7zlJvmXLFrZu3cqpp55KIBBAay2z84QQR62hxZ8kVb+drH0A0whi4MUlR9jM0JwPsC45jXze5WBtC7lsHjS4aHTEZeOrtewJNTBgcFmXjpm0M/xlx79Z1rCWlNO6ij1g+phZOpZrhpxFxAq+ywhCCCFcnQNlYBkerE4/uppo7Nbn9ZJdiRfQuHgM3xsRtNBaa8pAAQrIuXH8ZhSlFIby0Zh+DpAkuRBC9KR4OnvY+xKmaRBPZ3sxIiGEOL5l7DwJO0vY48PvsXrsOIayCFgDemx8IYToC1J5G9M49GdlBaRyOUzlo8gaSH12E146Vkx1tQMoir1Djui4w4dV8p1vX8zOXQ3UHYwRCHgZPboGyzp0P3MhekuXk+QNDQ1cccUVPPXUUyil2Lx5M8OGDeOGG26gpKSEn/3sZz0RpxBCvC8h7wgmVNzKnthfaEg/h6vTKGVREljAw/VQl/ORrG0in3MwTQMM0EEbM+0htjTPz9c/xHd+dhXRoiPrX5h3bW7b+Hdeb96C3/RSarWubkw5WZ49uJK6bDNfHfshfKa3J09bCCGOeUFrKACuzmOojjfWHJ0i4OmPZRT3WkwZp+WNnuNvct/xDPXGl8Y3fzRwycmkUiGE6GEDy4p5ZfueQ15v87bDoLLi3g9MCCGOM3uTLfxt6wqe3LuJjGPjNy1O7z+Kq4ZPpV+oqNDhCSHEcWlYWQnLYvFO92mtcYHBpSUopRhRdCYNBzeTd1NYRrDd89JOI0FPGQPDJx3xsZVSDBlczpDB5e/3NEQXKd366O4x+4ou15656aab8Hg87Nq1i2DwrV+OK664gscff7xbgxNCiO4UtIYwquwbzKi5hynVf2ZGzd85ofonXDr4KpysS9aXg4iLE3JwgjZmxkP1izWUB4vYt6eJF55Zf8THWtG0kdUtW4lYQcKeAIYyMJRB2BOgyAqxPraTFxvW9eDZCiFE31DqPwWfWU3eaULr9p/CHTcD2qUqdD5K9d4M5LBVicZti8flzc/E+o3/1phvS+i7OkvYGiUJciGE6GFnTBiBz/IQz3SsLpLK5TENg7MnjS5AZEIIcfzYHm/kxhfu495tr5Oy81iGQcrO8fdtK7nxhfvZEW8sdIhCCHFcOnfcaAzDIJnr+Fm5OZMhaFmcMXoEAEPD8xgWOY28myZp15N14mScZlJOPT4zyokVn8ZrSJVUcezrcpL8iSee4Mc//jEDBrQvYTNy5Eh27tzZbYEJIURPscxigtZgLLMYgHmVUxm9bCT+FSH8jX4C9X5KV5cx4ImBBA8EMU0DpeDl57cc8TFeqF+DqzU+o+OqR8vwoLXm+frV3XVKQgjRZ5mGn5GlN+Mxi8g5B8k7zdhunKxTh63jlAZOpiZ8aa/GNDg8B0NZ2DoNgE0ZGg+KPFo7KMD7Rn90202iMKgKn9erMQohxPFobL9KLpk+npztcDCWJJXLk87lqY8nSWRynDZuOCePGlzoMIUQok+7bc2z7E3GqAiEKPEFCHq8lPgCVARC7Ek2c/va5wodohBCHJdOHT6Es8aMJJnLczCRJJnLkcjmOBBP4mq4ftZ0hpeXAmAok5kVn+SkypuoDkzCNLz4zCJGF53Hwn4/oCY4tcBnI46Y7qFHH9HlcuvJZLLdCvI3NTY24vP5uiUoIYTobUa9SWRTMSVbOvZZgdb+henUkfcvbMzFMdWh5yF5lElTrvPyNkIIIdor9s9gYsUv2J94gIb0s7g6T8gaQXXofKrC52Go3m1dUeWfwNDwXLbGF2PrLF4jRJqB+PUOFDk8yo+hXLL2QZQyqAqdT3ngtF6NUQghjkdKKf7f/FkMLCvm/uVr2NPYAkBNcZQLpo3lkhkTMI0urxUQQghxhLbHG1jZsJeo5etwT8RUBhHLx4r6PWyPNzI0UlqgKIUQ4vhkGgY3LzyVsdUVPLhqPXtbYigFUwfU8IEpE5g7fEi75xvKZEjkVIZETu2xmHa1NPPIpo28sHsXeddhQkUV548ew5Tqmh475nFHq9ZHd4/ZR3Q5ST5nzhzuvPNOvv/97wOtX0Jd1+UnP/kJ8+fP7/YAhRCiNwwcUs6mdfs67V+otcbOOwwcUnHE45X7itkY23XI/Q4O5T7pwyWEEEcq5B3BiNIvMVx/AY3d64nxt1PKYGbFJwhbNWyJPU7aaSKHhWuMotzyY+oGQBP1TaY6fAEVwdNRh5k4JYQQovsYhuK8KWM4Z9JoalviONqluiiCZfZeWw4hhDhe7U40k3Vson5/p/sDHov6TIo9yWZJkgshRAF4DINLJo3noonjaEqlMQ2DIr+vIO3hXtqzm289s5imTBqPYWAoxY7mJhZt28JHp83gmsmyWl30vC4nyX/yk5+wYMECli9fTi6X48tf/jJr166lsbGR559/vidiFEKIHjdn4XieW7yOZCJLONL+y1wqmcXyeph7+rgjHu/k8gm8WL+GjJPDb7ZP5GTdPArFnIpJ3RK7EEIcT5QyUBQuQf4mQ3mYUPIBxhSdT3NuBwBRawBeM4TWLhoXQ3X5o7YQQohuYhiKfiXRQochhBDHFb9pYSgDW7t4VcfJSY6rMZQiYHZsTSeEEKL3GEpRFipcT/GmdJrvPvsUzZkMlaEwxhtJeq01LdkMv1+xnDHlFczsP+BdRhLvqifKo/ehcutdXtIyYcIENm3axCmnnMKFF15IMpnkkksu4bXXXmP48OE9EaMQQvS40eP6cdZF08jnbBrq4qSSWVLJLA0H4+SyNmecP4VxkwYe8XhTi0cyo3Q0CSdNLJ/Edh1s1yGWTxHPp5hcPIITSsf24BkJIcTxTWvNmsb9/HPnWh7fvYGD6Z5pceExfJT7R1PuH43XDAGtiXxJkAshhBBCiOPNpNIaKvwhYrlMp/tj+QxVgTATS6WMrhBCHM+e2LaFhnSK8mCwLUEOrZWri/0Bco7DQxvXFzBCcbx4T3fvioqK+PrXv97dsQghRMEopbjqujkMHFLOE/9cye6d9aBh+OhqTj9vCnMWjOtS2RnTMLlx5KVU7X6GZ+teI5ZPAZqwJ8Dp1TO4fNBpWIYkUIQQoidsjzfwXysXs675ADnXASDs8XH2wDHcOO4U/B5ZuSKEEEIIIUR383ssrho+jdvXPkdTNk2R14+hFK7WtOQyaOCDw6fhM+V+iBBCHM/W1R3E1a190jvj85isrN3fy1H1UbKS/LC6/IlkxIgRfOhDH+Lqq69m5MiRPRGTEEIUhFKKOaeN45T5Y4m3pNFAtCjwnnuy+EwvHxpyBhcPmMP2xH40msGhaqJWqHsDF0II0aY2FeMLL/6TvckWirx+SrwBNBDPZ7l3++vE8lm+O+3MgvTbEkIIIYQQoq+7fNgUknaOu7a8Sl0mgUKh0YQ8Pq4bOZNLh04udIhCCCEK7FDJ8Tdpjdy3Eb2iy0nyT33qU9x1111873vfY/r06XzoQx/iiiuuoLq6uifiE0KIXqeUIlrcfT1ZQp4AE4qHddt4QgghDu2BHavZm2qhIhDCVK1fuhRQ5PXjyRs8vW8zlw+dzAQp8SiEEEIIIUS3M5TihtGzOG/QOJ7dv5WmbIpSX5C5NcOpDEQKHZ4QQoijwOSqah7dtBHbdfG8I2GutSZr25zY/8hbn4rDkJXkh9XlnuQ33XQTr7zyChs2bOCcc87h17/+NQMHDuSMM87gzjvv7IkYhRBCCCGEeFdaax7fswFLmW0J8rcLeixyrsOS2m0FiE4IIYQQQojjR1UgwuXDpvD/xp7EZcOmSIJcCCFEm9OGDKN/JEJ9Konjum3btdY0pFMEvRYXjRlbwAjF8aLLSfI3jRo1iu9+97ts2rSJ5557jrq6Oq677rrujE0IIY4L2mlA515D59eida7Q4QghxDHL0ZpkPod1iLJdSinQEMtnuvW4yVyOA4kEGTvfreMKIYQQQghxLNNa42q70GEIIYQ4ykR8Pn5w2un0i0SpT6WoTcQ5mExwIJkg4LH40uw5TKisKnSYfYNWPfPoI7pcbv3tXn75Ze666y7uueceYrEYl112WXfFJYQQfZ52GtDJ30H2WdApwACzBoJXgP8i6bsihBBd5DEMKgJhdiYaO92vtQYFlf5wtxxvW1Mjf131Os/u2k7ecQlaFmcOH8EHJ06mMtQ9xxBCCCGEEOJYE8/vZ3PL4+xMPkfezRD2VDA8ejrDIwvxGP5ChyeEEMeFbS2NPLtnO8l8jupQhNMGDqPU330tRt+vsRWV/PnCS1i0bSsv7dlNznEYX1nJ2SNGMaiouNDhieNEl5PkmzZt4q9//St/+9vf2L59O6eddho//vGPueSSSwiH5WagEEIcCe02o1u+CPYGIAiqGHDB2YuO/xzlNkHo+gJHKYQQx57zB43j9rVLybkOXsNst68lnyFoWizsP+p9H2dd3UG++MRj1KVSBC0LyzRI5HLctWYVL+zexW1nnUu/SPR9H0cIIYQQQohjSUN2C0tqf0TKrsdUFgoPzbldLK//A3uSL3Fq9VexjKMnSSOEEH1N1rH56avP8dj2TWQcG0VrC+nfrHqJT00+kUtGjD/s6xOZLE+s2cwTqzdTn0hREQlyxsRRnDFhJCGft1tjLfYHuGzcBC4bN6FbxxVvUbr10d1j9hVdTpKPGTOGE044gU996lNceeWVVFVJyQMhhOiy9P1gbwRVDsp6a7uqALcZnboL/GeizP6Fi1EIIY5B5w+ewNP7t7CqYT9+00PQY+GiieWyKKW4ftRMBoVL3tcxXK356QtLqU+nqAqHMd6o/BG0wHZdtjc387tXX+G78xZ0xykJIYQQQghxTHC1w0sHf0XKridolqHUm22Qwjhujtr0KtY1P8Dk0qsLGqcQQvRlv1y5jAe2rCNoWVT5QiilcFyXpmyGn736HMU+P6cNHN7paxsTKb72j3+zfu9BlFJ4PQb18STr9tXx5Jot/OCyMykOSkUQ0Xd0uSf5xo0beemll/jsZz8rCXIhhHgPtHbRmX8BnvYJ8jepaGv59cxTvR6bEEIc6yKWj5/OuoArhk8h4LGI57Ok7DyDIyV8edJ8bhg9630fY/WBWjY11FPk87clyN/kMQxCXovndu7gYDLxvo8lhBBCCCHEseJAejUt+V34jOjbEuStTMOLoSy2xRdju5kCRSiEEH3bgWSch7dtIODxEPX62tp5moZBeSBI1rG5c91rre3oOnHH4hdZt/cgpeEAldEQxcHW/y0J+lm9p5bfLH6xN09HdAfdQ48+ossryUeOHNkTcQghxHEkC24L4Ot8tzLABe3WI13JhRCi64q8AT4/cR43jJ7F7kQzlmEyPFqOx+jy/NBO7YnFyLkOJZ5Ap/sDHouWTIZ98bj0JhdCCCGEEMeNltwuXO3iMTu/32GpAFknTtI+SJF3UC9HJ4QQfd+LtbtJ5nNUBkOd7o94fWxubmB3vIVB0eJ2+/Y3x1m6aQchr4Vltm9f5/WYBL0Wz23czkfnzqAiKvc6RN9wRHcKS0tLqa+vB6CkpITS0tJDPoQQ4li2ramR+9av5Z41q3h1/17cQ8yqe398oAJAvvPdWoMCZUgvWyGEeD+KvAEmlNYwuriy2xLkAH7Lg4JDvkc42sUwFD5Pl+ejCiGEEEIIccwylAXoQ65Q1LiAeuN5QgghulvGsQE6VL17k8cwcLXb9ry323qwgXQ+T9DX+TU65LNI5fJsrWvsvoDFcWHJkiWcf/759OvXD6UUDz74YLv9Wmu+9a1vUVNTQyAQYOHChWzevPldx/31r3/NkCFD8Pv9zJo1i5dffrnLsR3Rnbtbb72VSCTS9md1iF8wIYQ4VsWyGf5r6RKe372TjO0ArR8aRpWV8c1T5zOspPsmASlloH1nQPqvoB1Q7WfmoROg/OCb223HFEII0X1O6NefEn+AlmyG0kCww/5YJsuw0lJGlZYVIDohhBBCCCEKozowCY/hJ69TeFXHVYw5N0mZbyRhj7TwFEKInjA4UoypFFnHxmd2TP+l8nlClpeaUKTDPtNQKNQhK2lrDUqBqbpvEYI4PiSTSSZPnsz111/PJZdc0mH/T37yE26//Xb+93//l6FDh/LNb36TM888k3Xr1uH3+zsd85577uHzn/88v/3tb5k1axa33XYbZ555Jhs3bqSysvKIYzuiJPm1117b9uePfOQjRzy4EEIcCxzX5RtPPcmLe3cT9nqpDLVeeLOOzdq6g3zxicf47XkXHrZk7q5kA7uSDeBAKB0kYFgMriklcIiZdyp4KTr3DDh7gSIgQGuN9RiQA9+FKM+I7j5VIYQQ3SDq83PZuAn8/rXlNGcyRH0+DKVwXJfmTAaPaXDNpKmY3bh6XQghhBBCiKNd1NufgcHZbE88jcLAo/wopdBak3VbMJSHMcXnd+hXLoQQonucUDWAoUUlbGlupDIYareiPO84ZBybi0eMJ+Lt2BZjbL8qogEfiUyW4mDH9nLxTJaigJ+x/Sp69BxE91KA6uZiuV1dRn322Wdz9tlnd7pPa81tt93GN77xDS688EIA7rzzTqqqqnjwwQe58sorO33dz3/+cz72sY9x3XXXAfDb3/6WRx99lD/+8Y985StfOeLYulwD0jRN9u/f3yET39DQQGVlJY7jdHVIIYQoqJf27mH5/r0U+/34PW8ltf0ei4qgyZ54jH9u3MBHp83o8Nr96Wbu2LiYVxt30pJOkc3ZqKxBcH+QAU2VnD17HJcvnILXan+5VWYNFN2Cjv8M8muBFlprrBdB4HJU6IYePmshhBDvx0emTCPjOPxj3Rrqkok3bv5Bkd/Hx6adwFkjRhY6RCGEEEIIIXrdjIqPY+s0e1OvknMTaDQKhWUEmFhyJYNDcwodohBC9FmmYfDVE+bxpece40AyQcCysAyDjG2Td13GlVZyw/iO97gBioN+zp40mrtffJ1UNk/A62mb6JTK5cnZDlfMGkPY3zHBLo5PsVis3c8+nw+fr2v/PrZv305tbS0LFy5s21ZUVMSsWbNYtmxZp0nyXC7Hq6++yle/+tW2bYZhsHDhQpYtW9al43c5SX6onjLZbBav19vV4YQQouCW7tqJ7bjtEuRvMg0Dj2HwxNYtHZLkDdkEX3vtXnYmG8inHbIJBwwDbWkSQxLssjR/fTzFztpGbr5mIR6z/Uxp5RkKxb8EeyM4OwELvNNQRnEPnq0QQojuYBoGnzphFhePGctzO3fQks1SEQwxb8hQSgIdZ1wLIYQQQghxPPAaQeZU3UxdZj17U6+Qc1OEPJUMCc8hbEmZdSGE6GmTK2q447QL+dvG13l69zbyrkuZP8h5w8Zw5ehJFPsOfc/i+lNnUBdP8uyG7cQyWZRqLbPuNU1OnzCSa06Z3otnIrqFVq2P7h4TGDhwYLvN3/72t/nOd77TpaFqa2sBqKpq/xmhqqqqbd871dfX4zhOp6/ZsGFDl45/xEny22+/HQClFH/4wx8Ih98qO+w4DkuWLGHMmDFdOrgQQhwNYtnMYWuEeAyTeC7bYfs/97zGrmQjQe0jnq1nYtVBqsMtgOZgOspWswpfYxEvrNrBy2t3ctKkoR3GUEqBNab1IYQQ4pjTLxLligmTCh2GEEIIIYQQRw2lDCoD46kMjC90KEIIcVwaUVzGN2edxpemzyFl54l4fViG+a6v81kevnHBaZw/dT/PrN9GfSJJeTjE/LHDmDSwBsPo5mSrOKbt3r2baDTa9nNXV5EfDY44SX7rrbcCrSvJf/vb32Kab/1Ceb1ehgwZwm9/+9vuj1AIIXpYv0jrhVxr3Zq0foesbTO6rLzdNq01i/avwTJMQs5+5oxcTcDK8WatjZpwI6NL97AuDQdeGMxTyzd3miQXQgghhBBCCCGEEEIIIbqb32N1Wj31cAxDMXVwP6YO7ve+j++6mjU7a6lrSRDye5k8rB8Bb9fiEe+TfuPR3WMC0Wi0XZL8vaiurgbgwIED1NTUtG0/cOAAU6ZM6fQ15eXlmKbJgQMH2m0/cOBA23hH6oiT5Nu3bwdg/vz53H///ZSUlHTpQEIIcbQ6c/gI7lm7mpZslmK/v92+jG2jFJw3anS77TnXpimVRGWamTZoFX5PnmTOC+rNkuqaoJVl4qiVpNaVs7++fX8OIYQQQgghhBBCCCGEEOJo0JRrIuNkKbKiBD3B9z3eym37+M2jL7DjYBN5x8U0FOXREB+cO5XzZo7tdLGaOP4MHTqU6upqFi9e3JYUj8VivPTSS3ziE5/o9DVer5fp06ezePFiLrroIgBc12Xx4sXceOONXTp+l3uSP/300119iRBCHNWGl5bxoYmT+dPrKziYSBD2+TCUIpnLYbsuJw8cxFnDR7Z7zdN3v0hLoplRw/YQ8ORJ5LxAa5MWpRQoRdL2EvXk6Dd8O6Hk6M4PLoQQQgghhBBCCCGEEEIUwJb4FhYdfIptiW042sVreJlWMoXTqxZQ4n1vi2XX7KzlO3c9QTyVpTjkx+sxsV2XxliKXz3yPI7rctHsCd18JqJTPbiS/EglEgm2bNnS9vP27dtZuXIlpaWlDBo0iM997nP853/+JyNHjmTo0KF885vfpF+/fm0JcIAFCxZw8cUXtyXBP//5z3PttdcyY8YMZs6cyW233UYymeS6667rUmxdTpJfeumlzJw5k5tvvrnd9p/85Ce88sor3HvvvV0dUgghCu6j02ZQE4lwz9rV7GxuRqMpCwa5YNQYrp44GZ/nrcvl2pe28LefPUbRbKieEkNreHtT89ay7aC0Qjsm5f0OMCsyovdPSgghxPumdRbXTWIYYZTytm3fv6OOJQ8tZ+OKHZgegwknjuSU86dRVl1cuGCFEEIIIYQQQgghjtCalrXcueMvpJ0MAdOPz/CSc/M8V/c8m+Nb+OSI//eeEuV/fXoFsVSWqqJQ24pxyzQpiwZpiKe465nXOH3qKEJ+77uMJN4vpVsf3T1mVyxfvpz58+e3/fz5z38egGuvvZY///nPfPnLXyaZTPLxj3+c5uZmTjnlFB5//HH8b6v6u3XrVurr69t+vuKKK6irq+Nb3/oWtbW1TJkyhccff5yqqqouxdblJPmSJUv4zne+02H72Wefzc9+9rOuDieEEEcFpRTnjRrDOSNHsyfWgu269ItEOu3ZsvjvL5LL5Bi0owgrB4R4e468dUE5YNomrnIIByzmTBnWS2cihBDiSLnuG5OaOinxlbd3Ek/8hXTmCbTOoowwocD5REJXs+yxXfz5Px8g0ZLGNA201qxZtpnH/7KUT99yNeNmDi/A2QghhBBCCCGEEEIcmbyb5749D5Jxs5RYxW33RryGF0f7qc3U8kTtk1wx6LIujbu/McaqHfuJ+L3t7rcEvCkmDFzF2AGr8HkS7Nj3KEOqP0gwcCZK+br13MTRZd68eWh96My6Uorvfe97fO973zvkc3bs2NFh24033tjl8urv1OUkeSKRwOvtOLvDsixiMem5K4Q4thlKMaio+JD7tdasfWkLXr8Xb8ZAvVKCubAZhUa/+abvgsoZmI6Bv0gxrvpk/L6OyXYhhBC9z3Zcnlq1hceWb2B7bSNej8nJ44Zy3syxDK8pAyCX30h946exnf0oFUBh4brNxBJ/oLnxCf7+y1GkkxblNW99iXRdl8YDLfzqy3/lh/d+juKKaCFPUwghhBBCCCGEEOKQ1sU20JhrIGKGOyweMJWJ1/DxWvPrnNfvXEJd6FEeT2dxXE3Aa7ZtiwaauWz236goOojWipxtYJmraWz+Fqn045SV/BTDeP990EUnjoJy60czo6svmDhxIvfcc0+H7XfffTfjxo3rlqCEEOJoprVuWziefLEamr1E83kCLRp/i8Kq10QcD1WVBsWhYiaUn13QeIUQQrSyHZefP/AsP73vGVbvqMV2HBLpLA+9tJYv/s8jvLJ5N1prmlp+gO3sxzSqMY0SDCOMaZRhGpVk85s58fwVlFRE232JNAyD0soimg7GeP7R1wp4lkIIIYQQQgghhBCH15hrBMBjdL6W1mt4ybk5WvItXRq3NBLEMg2yefuNLZqzpj5CZdEBEukwsXSEZCYIuhLDKCKdXUos8fv3cypCvGddXkn+zW9+k0suuYStW7dy2mmnAbB48WL+9re/ST9yIUSfp5Ri7IxhvPzEaiIlIXINQfbfP5qaSzbgD+ZwXIUTALw2TXEvZsvpNPqjlNQUOnIhhBBPvLaJRSs3E/J5Cb6twofWmtpEgi/961/MmpTkisHLAT9hr03YequCklIe0nGDUSfs5/WnUqRaQu3GN8zW+acblm/j3I/M7ZVzEkIIIYQQQgghhOgqv+lHA652MVTH9bSOtjGUgd/0d3zxYZRHQ5wwahDPrNpCyOeluuQAg8p3ks4FcLWJ47hYpkHIb6GUQikfydRDRMM3YBjhbjo70UZWkh9Wl1eSn3/++Tz44INs2bKFT37yk3zhC19gz549PPnkk1x00UU9EKIQQhxdFlx+Il6/Rawxgdaa2OpKtv92GluWD6Y+FqE5FmH71pE8//Q87l9k8vk/PMwL63cWOmwhhDiuaa159OV1aE27BDlAxrQ52C/NLn+MlsxmDHI0ZTW74y3sT8bbffbPZz1YPoei8vghj+W6fejbghBCCCGEEEIIIfqc8dGxBEw/KSfVYZ/WmrSTYVhoKKXeki6P/eH506goDnMwlqA4uBuPmSebt7AdB6WgvCjUVp3PUCFc3ULe3va+z0mIrurySnKAc889l3PPPbe7YxFCiGPCpJNH84FPn8l9v3qChv3NmJZJLO9l34qxmCsU/fuX4Q96MYHKIk19LMXPH3iWsQMvoyQcKHT4QghxXMrkbXbXtxD0tv/4q9FsDbWQ9TiYeQWOH4XCayhsrWjOZvB7PJT4Wq/fgZCFnU+Tz3Wca+q6LgCjpw/t+RMSQgghhBBCCCGEeI+iVpQ55aew6MCTJOwEQTOIoQxs1ybuJAiYfhZWnfaexh5aXcoPrzmbPy56mVxuHa6jyeVsTK0IWRZe3t4DXQMK9d7SleJdKN366O4x+4ouryQHaG5u5g9/+ANf+9rXaGxs7VuwYsUK9u7d263BCSHE0er86+fx9T/9PxZeOZuBI6txRpfhD/sZPKQSf/DtpXkVZZEATck0T6/aUsCIhRDi+OYxDJRSuLr9J/mYJ0fazONxDRSKzbEBJJ0gQU8a841ZzU2ZdNvzQ0U2zXURtq30ot82lnY1TQdjRMvCnHzu1N45KSGEEEIIIYQQQoj36Jyas1hYtQCP4aEl30JzvpmEk6TUW8JplaeTthV7UnXvaezhNWWcVVxJyyMm+YRBVGWwUjaZ5hT7d9QRb0oC4LpxTKMSyxrenacmxBHp8tSMVatWsXDhQoqKitixYwcf/ehHKS0t5f7772fXrl3ceeedPRGnEEIcdUZOHszIyYPRWnPpD++kKG/jscwOzzMMA+1qtu5vKECUQgghACyPyYwRA3hm9VYiAd1W1ivpybfOWdagAG0W8WL9DBZUPUfATONoHznXIefYmKoFj9dLwHsVhqeprZoIWmPbLtHSEJ/4wZWUVRcX8lSFEEIIIYQQQggh3pWhDM7vdy6nVpzCupb1ZNwsBzIxXmnYwf/teA5Hu1iGhzGRwXxw8OkMDdcc8dj7th3kzz94gGzKYtfrQxkzazPKMbHzHhzbpaG2CV8gh2k5REJXopSvB8/0OKZV66O7x+wjupwk//znP89HPvIRfvKTnxCJRNq2n3POOXzwgx/s1uCEEOJYoJTCYxhk9GHqjCjwmO+peIcQQohucuGJ43lp0y4a4ilKw0EMo/VDvQZsxyXoswj6LJ45eDI+M8vM0tco8cbRGtA2yogSDX+MAfOvoer/9vHsA6+wfvk2TI/JpJNHMfeiE6geXF7QcxRCCCGEEEIIIYToiiKriNnlJ7Lk4Eoe3beEnJsnbAbxGCY5N8/K5s3sTh3gq+M+zOBQdbvXajcFuefA2QvKD97ZKM9Qljy0nFQsQ1lNMS/cfyLBaJoBo/fhtzJoU4OpaXGypMyTQc0j0mlkQvSsLifJX3nlFX73u9912N6/f39qa2u7JSghhDjWzBo9iH8t34DWb61OfFPedjCVwZRh/QsUnRBCCIBJQ2v43IVz+PUjz1MXS6KBnM+GKo3X66GmNAoKXEwe2386LzdMZ4B/FcOiHi4bPY9Q4AxMswKAIWP7M2SsXNeFEEIIIYQQQghx7Ms4Of62azF516bUirbd4w6YPnyGl4ZcC/fvWcJNoy9ve43OLkXHfwpuHa31+VxQf0D75rNldQTDbG19l8t4eey/T6fmjK0MWbCZoC9LcyLAplQ/YsESAg2/4bKBl3JC6YzCnHxfpt94dPeYfUSXk+Q+n49YLNZh+6ZNm6ioqOiWoIQQ4lhz3sxxPLtmG/XxFGVvW52YdxwaEmmGVZcye8zgAkcphBBi4ZSRTB3Wj6dWbWF3XQumUjyZ3caeXKx9j3Gt2RYPsqH5BL41ZAHR8OgCRi2EEEIIIYQQQgjRc15v3kxjLkaRJ9RhEZihFEHTx8qmzTRkWyjzFaHzq9Cx74FOgioD5QGtQScg8xinnzuAdS+9dT/cKXbYNNbPxobxEDdwbRdfwEtNUQkxO8a9u+9nQGAANYHqd4YmRI/pcu3fCy64gO9973vk83mgtczwrl27uPnmm7n00ku7PUAhhDgWjB5QwecvPpWI30ddLEltU5za5gRNiQzDqkr51lWn4/d2eV6SEEKIHlAWDXHxiRMYq8Ls+tcWgvc3ofdk2VHXyK7GZg4mk9SmErhac+24aZwzZFShQxZCCCGEEEIIIYToMU25BAAew+x0v2VY2NqmJZ8EQKfuATcOqrI1QQ6gFBgRIMS4KbupHhDDdVsXJOQnJtABF+IGCoXWEAj5UUoR9UTJuGleani5x8/zeKN0zzz6ii5nbH72s5/xgQ98gMrKStLpNHPnzqW2tpbZs2fzgx/8oCdiFEKIY8K8icOZMLiaxSu3sK22AY9pMG14f2aPHURer2d781JsN4nfrKI8uICANbDQIQshxHHJcVz++7ZFPLd4LUopIiEvU14z2RvN0lyTo2pomDmTRnL2kFFMKKvqMINaCCGEEEIIIYQQoi+JWiEAHO1gqo6J8rxrYyqTqBVEuwnIvQwq1JoYfycVJhBMMGNOgkf+1kxJZRHOwGxrNXYUdt7B9BiES4KtT1cKA4Mtya09eo5CvFOXk+RFRUUsWrSIpUuXsmrVKhKJBNOmTWPhwoU9EZ8QQhxTyqMhrjh1ctvPtptkc8N3aMwsw9V5QKNQ7In/lQHRaxgQ+ZAkX4QQope9+uJWnn96HcGQj0DQ27Z9dM5HfHUaViW49JRRDC+XEl9CCCGEEEIIIYTo+6YUj6DIChHLpyjxRtrt01qTcjLMKB1Dua8Y7dTRmvG2Oh9MKQzTZP4lE3luUY7GAy2Y6TzKdSEPpsekon8JltU+RWl0vfi1eDfSk/yw3nPt31NOOYVTTjmlO2MRQog+Z1vTrTSkl+AxIlhGCUoptHax3Ri7Wv6Az6ygMnRWocMUQojjypJFa3Ec3S5B/qZwxE/DwThLn1rP8FGSJBdCCCGEEEIIIUTfF/T4+cDAefzv9sdozMWIeIJ4lEnOzRO300StEJcOmNv6ZKMIVBG4DaCCHQfTNqCpHjaZH/3jZJ5/5DWeSz1HnW8P4eow4aIQHs9bq9W11jjaZXRU2t2J3nVESfLbb7+dj3/84/j9fm6//fbDPjccDjN+/HhmzZrVLQF2xaZNm/jSl77E888/Ty6XY9KkSXz/+99n/vz5vR6LEEKk87upTz+DaQQxjbc+LChlYJnFZO2D7I3fQ0XwDJSSWXJCCNFb9uxqwPJ23mNLKYUyFPv3NPZyVEIIIYQQQgghhBCFkXdamBDaxQ39t1Kb2c/BXJAtqQFk3EpGhPtzzdCzGBEZAIBSXgich07+D+gcqLctQtAadCMY5eA9leKKEOdeN5cTsxP52aZbSdhJDNN429M1LXaMsCfEzNIZvX3afV9P9BA/3laS33rrrVx99dX4/X5uvfXWwz43m81y8OBBbrrpJm655ZZuCfJInXfeeYwcOZKnnnqKQCDAbbfdxnnnncfWrVuprpaVQEKI3tWcfRXXTeM1Kzvd7zEipO2dpO09BK1BvRydEEIcv4IhHwdrWw65X7uaYNjfixEJIYQQQgghhBBCFEYqv5319V8nnd+JF8WggEGNL8akSANR/wVMrfgopvGOxQaByyH3CuRXgfaACoB2QCfACKMiN6GMUNvTy3ylfHjw1fxl51202M2gW1uQajQRT5gPDr6SCl9FL561EEeYJN++fXunfz6URYsW8cEPfrBXk+T19fVs3ryZ//mf/2HSpEkA/Nd//Rd33HEHa9askSS5EKLXaW0Dh+k3rgy0q9E632sxCSGEgBPnjGLbplocx8U021fyyOdtlKGYceLwAkUnhBBCCCGEEEII0TtcbbOx4buk8jvwmeUo1Zo29BoaW8fJ5h6lMT2VitDp7V6njDAU3QLpe9DpR0E3gzLBNw8VuALlndLhWGOjY/ji6Jt4pfFVtiS2otGMCA/nhNLplHpLe+Fsj0PSk/yw3nNP8sM55ZRT+MY3vtETQx9SWVkZo0eP5s4772TatGn4fD5+97vfUVlZyfTp0w/5umw2Szabbfs5Fov1RrhCiD4o68RpyG7C1Q4l3iEEraEoZeLqLKbquCLRcZNYRhF+T78CRHvsk+u3EOK9OnXheJ56fDW1e5uIFgfw+iy01mQzeeKxDCPH9mO6JMl7lFzDhRDi2CXXcCGEOHbJNVwI8U7NmZdJ5bfhNUvaEuTQ2o7OUlGy9kH2Jx6gPLgQpdovCFNGGEI3QPDD4DaB8qOMosMer8RbwhnVCzmDhT1yPkJ0xXtKki9evJhbb72V9evXAzB27Fg+97nPsXBh6z/qQCDAZz/72e6L8ggopXjyySe56KKLiEQiGIZBZWUljz/+OCUlJYd83Y9+9CO++93v9mKkQgitNRu3HeCV13eSSueoLIswZ+YIykvDhQ7tPXHcHKub7mZr/EmyTgwNeAw//QMnEPAMJp3fiqG87fqOuzqLJk9l6BxMI1C44I9hcv0WQrxXxaUhvvjti7jjp4+xc1sd8VgGrcGyTCZNG8x/fOEsfH6r0GH2aXINF0KIY5dcw4UQ4tgl13AhxDvFc2vR2sVQvk73m0aQZH4zthvHMqOdPkcpL5hVPRmmeK9kJflhKa11l07njjvu4LOf/Swf+MAHmD17NgAvvvgi//jHP7j11lv51Kc+1a0BfuUrX+HHP/7xYZ+zfv16Ro8ezUUXXUQ+n+frX/86gUCAP/zhD/zzn//klVdeoaamptPXdjZ7buDAgbS0tBCNdv4LL4R479KZHL/809O89PpO8nm7bXso4OPqi2Zy3sKJBYyu67R2eaHuF+yIP4OpvHiNEKCw3TQ5naLCW0OJcYCsU4ehLJTy4OosaE2Rfxpjy3+Ix+j+yQGxWIyioqI+fS2T67cQ4v1yXc3albvYtrkWwzAYM6E/I8bUdJgZ3dvkGt43z1kI0fcdD9dvkGu4EKJvkmt43z5vIcSh7Wz5b3bH7sRnVna633YTgGZGzX2HTJIX2vFyDe+KN/9Ohn39h5j+jlVu3w8nk2HbD77WJ/6+u7yS/Ic//CG33norN954Y9u2z3zmM5x88sn88Ic/7PYk+Re+8AU+8pGPHPY5w4YN46mnnuKRRx6hqamp7f+UO+64g0WLFvG///u/fOUrX+n0tT6fD5+v8xkyQoju9993LWXp8q2Egj6KIn6UUriuJhZP86d7X6C4KMApJ4wodJhHrC6znl2J5/EaISwj2Lbda4YxtY/6XC0DSi+jUiWoS/0b200TsgZQFTqPqtC5sor8fZDrtxDi/TIMxcRpg5k4bXChQznuyDVcCCGOXXINF0KIY5dcw4UQ7xT2jgMMXJ3DUN4O+x03RdQ3EY8R6f3gxPumdOuju8fsK7qcJG9ubuass87qsP2MM87g5ptv7pag3q6iooKKiop3fV4qlQLAMIx22w3DwHXdbo9LCNF1e2ubeX75VgJ+L8HAW2+4hqEoLgpS15DgoUWvc/KM4QVfxXekdiaex9V5PJ30WjGVhcJgW/xl+ocvwvUNocyqZFh4Ih5DyvgKIYQQQgjRnbTW7NhUy/JnN5KMpykpj3DignFUDSgtdGhCCCGEEEIclUr8swhZQ0nkNuMzK1DKBFo/W9s6jlIm1eGLj5n79UJ0RZeT5BdccAEPPPAAX/rSl9ptf+ihhzjvvPO6LbCumj17NiUlJVx77bV861vfIhAI8Pvf/57t27dz7rnnFiwuIcRbVm3YSyZrU14a6nR/OORlx+5Gauti1FR2TDofjdJOI0CnHxI0mqybIZZez5pEAoUCFKXeSs6suYbBoTG9HK0QQgghhBB9Uz5n8+efPc7z/15NLmu3Lm/Q8NCdz3Pe1bO5+Lo5cmNPCCGEEEKIdzCUxeiy77C+/quk7d2gFUqZuNrGVF76Ra6kInh6ocMUokccUZL89ttvb/vzuHHj+MEPfsAzzzzTrif5888/zxe+8IWeifIIlJeX8/jjj/P1r3+d0047jXw+z/jx43nooYeYPHlyweISQrwll7NRqvOEMrRWftDaIW877+s4LYk0z722jW37GrA8JpNH9uOEcYOwPOb7GrczAbN1VYrWusN5teQbyLlpNAEinlKUUthunoZcLQ/u+Q1XDv4CVf5B3R6TEEKI3hVrSrL036t5+en1pJNZBgyrYM7Zk5k0a1iHKkdCCCF6xr3//TRPP/wagaCXsuIISim0q4nH0tz/xyUUlYZYcNH0QocphBBCCCHEUSdoDWVS5W+pSy2iIb0Ex00T8g6nMngWUd8UmWx6LNNvPLp7zD7iiJLkt956a7ufS0pKWLduHevWrWvbVlxczB//+Ee+8Y1vdG+EXTBjxgz+/e9/F+z4QojDG9ivBMNQ5HI2Xm/Hy086kyMS8lNZ9t77m7y4Zge3372EpngKrUEBDz+3huH9y/jadWdQUx59H2fQ0eDwyWyJP4Gt01jqrZ7k/5+9+46zo7rv//8+M7ffvdubeu8FiS7Re7MBF2LjgnscG/J1jOOfjeMYDHFIHNuE2E5cYhvHmBgXwDFgekeiCgGqSIC6dlfavnv7zPn9sSCQtRIS3N3Z8nr6MY/kzpk79339kEdX85lzPgWbV9brkSMjmfo9PyRCTlgpU63uYqueabtP5439ZEnzAAAG17ZXd+l7X7lZTdvaZYzkuo62vtyipx9ap1POP1wfu/wsCuUAMMA6Wnv04J9WKhINKZmK7dlvHKPyyoTaWrr15988qZPOW6RQuPQPzgIAAADDXdit1NjURRqbuijoKMCgOagi+auvvjrQOQCMAofNGa/xY6q0eVuraqrK5DhvPIGWLxRVKHg67bjZikXfXr/ul7fv1ndvfFC92byqK5JyXytK5AtFbdi6W9/6xT363t9dqEj4kDtN7FddbI4mlR2nV7sfkmcLijhJSUbpYpuMirKmTL727oFojFHYxLSh+zkV/JzCTrRkeQAAg8fzfP3nN2/Tzq1tqq5LyXXfKIane7K6/7ZnNWlGg0694PAAUwLAyLdu5Wb1dmVVXVfW73iyPKaWHR3avKFZ0+aOHeR0AAAAABAMY/u2Up9zpHjb01p2796t3bt3lzILgBHOdR397cdOVnVlUrvbetTZlVFPb06t7b3q6s5q/syxeu/Zi972+f+8bK260znVvKlALkmRcEhV5Qm9sr1VT63eUoJv8gZjHB1Td5nmVb5fYSeurNepjNcuKylvUypqumT2Lco7xpVnPRX8fEnzAAAGz4tPvaKtL7eooiqxV4FckhJlMVkr3Xfrs/J9P6CEADA65HNFWVkZp/9lIF3XkbVWxUJxkJMBAAAAAIaqQyqSd3R06NJLL1Vtba0aGhrU0NCg2tpaXXbZZero6BigiABGkplTG/StL1+g809fqGQ8ImOMxjVW6hMXLdHX/9+5Sibe/qzqJ17cpEg41G+PlHDIle9bPffStncSv1+uCWtRzUf17gn/qZPH/KNObvy65lR+Rj1+nXz1v5xjweaUcFOKuYl+xwEAQ9+r63bI93xF9rMCSiIZ0c4treps6x3kZAAwuoybXKdIJKRcptDveCadUzQeUeOEmkFOBgAAAAABsyXeRpCDXnO4ra1NS5Ys0fbt2/XhD39Yc+bMkSStWbNGN9xwg+6//34tW7ZMVVVVAxYWwMgwrrFSn/nQ8frUB49ToegpEnb7LWwfqkLR22sJ979kXztmoETcMo1N9C2pWxWdpSdaH1C62KVkqGKv71f0C/Ktp4WVx8sx9EQEgOHL9P37wNp+/x6zVjJSSf6OAwDs39Q5YzRt3jitfW6zItGQnDet7lEseMqmCzrtwgWqqE4GmBIAAAAAMJQcdJH86quvViQS0csvv6yGhoZ9xs4880xdffXVuu6660oeEsDI5DhG0Ujp+oNPH1+nFeu3SsnYPmO+b+VImjxmcGaPJEIpndJwke7ZeaO6i22KOgk5xlHez8mzeY2Lz9AR1acOShYAwMCYsWC8QiFH+VxR0di+s8kzvTlNmzuOogwADDBjjD755XP1nS//Rs3b2hWJhhQKu8rnCvKKvqbOGav3f+bkoGMCAAAAI9bajTt132PrtO7lZrmO0ZELJ+m042ZrXGNl0NFGt4GY/T2CZpMf9HLrt912m77zne/sUyCXpMbGRn3729/WrbfeWtJwAHAozloyW67jqDezd59va63au9MqL4vppMOnDVqehZXH68Lxn9PExCz58lTwc4q7SR1bc64umvgFxVyKJgAwnM09fJKmzB6rrva0ioU3Viqx1qqnMyPHdXTG+45kJjkADILxU+r0D9//qM6/5DiVVSQkGdU2VuoDf3OqvvrvH1JlTVnQEQEAAIAR6ba7V+ob371d9z66VjtbOrV1Z7t+f8cKfeXaW/Xsi1uCjgfs10FP4dy5c6fmzZu33/H58+erqampJKEA4O04/rCpemHJDt21fK3S2bxikZB8a5UrFJWMRnTpRSeopmJwC9PTU4dpWtlCdRXbVPQLSoWrFHHeft91AMDQ4TiOLr3qQn3vK7/VlpdbJCs5rtnTp/xdH16i489eEHRMABg16sZU6uLPn6YP/M0pKuQ9RaIhHlQCAAAABtCL67br17c9JWul2uqyPb+/rbVqbevVf/z8Af37VRepapDvy6OPsX1bqc85Uhx0kby2tlabNm3S+PHj+x1/9dVXVV1dXbJgAHCoHMfo8+8/XvOnjdGfl63Ry9tbFXGMTlw8TecdN1ezJ++7EsZgMMaoIjw4y7wDAAZX/dgqXfmjj+vJB9fqmUfWK9Ob07jJtTrhnIWaPm8cxRkACIDjOIrGDnrhPAAAAABv0z2PrlUuX1RdTWqv/cYYVVcl1Nreq0ee3KgLzjwsoITA/h10kfyss87SP/zDP+jee+9VJBLZayyXy+kf//EfdfbZZ5c8IAAcCscxOvmI6Tr5iOnyfF9GRo5DgQIAMHDiyahOftcinfyuRUFHAQAAAAAAGDSrX9qhSLj/UqPjOLJWWv9K8yCnwh70JD+ggy6SX3311TryyCM1Y8YMXXrppZo9e7astVq7dq3+8z//U7lcTr/61a8GMisAHBLXYfYIAKC0Xtq+S/c+t0Ev72xVLBLSsbMn6uQF01SeiAUdDQAAAAAAYFC5jiP7FlVT7tNjqDroIvn48eO1fPlyff7zn9cVV1wha/v+0BtjdMYZZ+gHP/iBJkyYMGBBAQAAgKBYa3Xzo8/rVw88q2y+KNcx8qzVUy9t0S2Pr9JVHz5DkxtoPQQAAAAAAEaPRXPH6+5H1shau0/LOc/z5RijuTPHBJQO9CQ/sIMukkvSlClT9Oc//1nt7e3asGGDJGn69On0IgcAAMCItnzdFv3yvmdkjFRfkdzzDz/P87V1d4f+6eb79V+ff6/CITfgpAAAAAAAAIPjzJPm6tGnNqqtI63qysQb90t8X20dvaqvLdcJR00POCXQv0Mqkr+uqqpKRx99dKmzAMCol80W9OyKV9Xc0qV4LKIjDp+s+vryoGMBwKj3pyfXKF/01FBZttd+13VUVRbX5pZ2PbF+i06YNyWghAAAAAAAAINrxuR6fe6jJ+rHv35Uu9t6ZIx5bSVqo7qalL782TNUlowGHXP0oif5Ab2tIjkAoPSefOpl/eKGR9Xa2i2p78fEr/93mU47Za4+8uHjFA4zOxEAgpAvFLV6S5MS0XC/45GQK2utVm9uokgOAAAAAABGlZOOnakZU+r10PKX9NKrLXJdR4vnTtCJx0xXeSoedDxgvyiSA8AQsGr1Nv3gh/cpmyuooiKhUMiV71v19uZ0x5+flzFGH//YCUHHBIBR6WAekLV2RD1ICwDDWsuOdj33+Aale7KqbazUESfMVKIsFnQsAAAAYMQa21CpD13ICtRDDjPJD4giOQAMAbf9cYXS6Zxqa1N7+rY4jlEqFZO6pfsfXKPzzlukutpUwEkBYPSJhkOaOa5WK1/ZoVR83yXCCp4nxxjNGlcXQDoAwOuKBU83/fA+PfSnlcpm8nuWeqyqLdOHLj1dx521IOiIAAAAAIAhwgk6AACMdm1tPVq7bocSyeieAvmbJZNRZTJ5PffcpsEPBwCQJL376LlyHUdd6dxrvbX6+L5VW3dGY2vKddzcycEFBADotz9+QHf/9inJWtXUpVRTn1JVTVKdbb3673+9QyuXbww6IgAAAAAMGmMHZhspmEkOYEgpeJ6efmWbVm1rliTNGlOrJdMnKRIauf24M5mCfN9XJNx/r1vHMTIyymQKg5wMAPC6E+dP1Yadu/WHx19QS2evwq4jz1r5vlV9ZZm+9lenKRrmpzUABKWtpUsP/N9zikRDKqt4o++hG3JVVVum1uYu/enGZTrs2Gn9PpgKAAAAACMOy60fEHfyAAwZW1o7dPVt9+vlllb5rzV3NcZoQk2F/vGC0zSzsTboiCXlFT2tfnaTmra1Sb5VJptXNLpvobxQ9CRJ9fXlgx0RACBpY/dGPbp7mTY2vqRZ5+fldZUpvbVW8fQYHT9nik5fPEO15cmgYwLAqPb8Ey8r3ZNTdV3ZPmPGGCVTMb2ydod27exQ/diqABICAAAAAIYSiuQAhoSebE5f//092rS7XdXJmCKhvstTvuhp8+4O/eMf7tEPL7lAtamRUYR4/omNuvE/7lXTllZ5nlVPxFE24soWfVXVvNF33Fqrzs606uvKdcThk4MLDACj1PLdT+gP229Tzssp4kQUch35lR0qr+rWKXUT9O6xhzEjEQCGgFw2LyPJcfrvKueGHOVzRWXT+cENBgAAAGAf1lr51srdz+93lAgzyQ+IIjmAIeHBta9oc2uHassSCrlv/MUYCbmqSyXU1NGte1Zt0IeWLAouZImsWbFJ3//GLUp3Z1VelexbErJQ1NZ0Xq2tPcrlPVVWJ+UVfaXTOSWTUX3yEycqEuGSDQCDqSW7S7du/6M8v6iqcOWeYnhSCaWLaT206xHNSM3QnPLZAScFANSPrZJxjAr5osL9/G7OZgqKxiOqaWB1JgAAACAoGzta9YcNq/TA1leU94qaVFGlC6fN1XlTZinsjNyWqxiaeEQDwJDw+IbNkrV7Fchf5zqOHMfo0fWbBj9YiVlrdesvHlVvV1Y1DeWKRPtu4MXCIU1JxZX0rLK9WWWzBVlZHXXUVF3xlXfryCOmBJwcAEafp9ufUcbLKhVK7TNbPBFKqOgX9UTrUwGlAwC82YKjp6phfLU629Kydu+pDcWip1ymoCVnzFMyFd/PGQAAAAAMpCd3btXf3H+bfvvSi+ou5ORZX6t3N+ufn3pI/7jsXuU9L+iII46xA7ONFExLBDAkZPIFOc7+l6t1jVEmXxjERAOjZXu7Nq7arrLy2D4Fl5BjNL4srrbWHn30s0dpyalzVVU1MpaXB4DhaHt6u4zMfpdTDzlhbUlvHeRUAID+hCMhffzys/Uf//gH7W7qUjwZUSjsKpctKJ8ratKMBr3n4ycEHRMAAAAYldKFvK556kF15LJqTJbtuddSHpUyxYLu3/KyFteP1QdmLgw4KUYTZpIDGBKm1dfI8+0+sz5el/d8TW+oGeRUpdfTlZXneQqF+186xg05MpIijkOBHAACFnbCsgdotGStr7DDM6cAMFQsOHqqvvK9D+nY0+fKGKN8rqhEMqZ3fWiJvvrvH1ZlTVnQEQEAAIBR6cFtr6q5t1u18cQ+kxHiobCMMbp14xr5+6kP4G2yA7SNENzVAzAknLVghu5YuVadmZwqE7G9xrqzOUVCrs5eODOgdAfPt7429GzUyvbn1VXsVkW4XIdXLtLUsqlyjKOq2jKFwiHlc/33Sizki3KMUVVtKoD0AIA3m52apec6Vsqznlyz98NN1loVracFFfMDSgcA6M/0eeP0hX96v7o708qm80pVJhSLR4KOBQAAAIxqr3a2SZJCTv9zdxOhsHb0dKk7n1NFNNbvMUCpMZMcwJAwa0ydPnrc4fJ9q+bOHnVnc+rJ5tTS1atcwdN7jpinIyaPCzrmAeX9vH656Vf60cs/1WO7l+nFjlV6dNfj+s+Xf6ybNv9GRb+o6vpyLVoyTemenHzf3+v91lp1dWRUO6ZCC4+ZGtC3AAC8blHVYWqINqiz0KWiX9yz37OeOgqdKg+ndGzN0QEmBADsT6oioboxlRTIAQAAgCEg5Dh9k5D3M1Pct74cYxTeTxEdb89Q6Ek+efJkGWP22S699NJ+j7/hhhv2OTYWG5gHJ5hJDmDI+PDSRZpYU6nbVqzW2h27ZCXNH9+gCw6fq9PmTt9vT9ih4o4df9aK9pVKuAmVR/pmgltrlfNzeqr9GVVFqnTe2HP03k+dpA2rtmt3U6cSZVFFYmF5BU/dnRnFk1F96LLT+51lDgAYXHE3rk9N+bh+sel/1JRtll/se7jJGKPKSKU+Muli1UXrAk4JAAAAAAAwtB3dOEG/XLNCWa+oeCi815i1VuliUSePn6JEmIdcR5qnn35anufteb1q1SqdccYZuuiii/b7nvLycq1fv37P64GqDVGFATBkGGN04uwpOnH2FPXm8rLWKhmNDPniuCT1FHr0ZNvTijgRxdzonv3GGMXcmAq2oGWtT+jUhpM1fkqdvnLdh/T7nz6kF558RT2dGbmuo1mHTdR7PnG8Djt2eoDfBADwZo3xRn1p1he1qnO1Xul5Rb58TYiP16KqwxR340HHAwAAAAAAGPIW1Y3R4rqxerJpq0zMKBbqK0/61qo1k1Y8FNIHZi4MOOUINBA9xA/xfHV1e08w+Zd/+RdNmzZNJ5100n7fY4xRY2Pj20l3SCiSAxiSktHh9cTYq+lNSntplYfK+x2PO3H1Fnu0Jb1Vs1IzNX5Knf7uny/Srp0damvpUrI8rnGTa4fFAwEAMNpEnLAOr1qkw6sWBR0FAAAAAABg2HGM0TVLz9DXHr9bz+9qUkcuI2v7iqHlkaguP/x4HdU4PuiYOARdXV17vY5Go4pGo/s5uk8+n9eNN96oyy+//IC1kJ6eHk2aNEm+7+vwww/XP//zP2vevHklyf1mFMkBoAR860uy2t9l3RgjK/vacW+oG1OpujGVAx0PAAAAAAAAAIDA1MQT+s9TL9BTzdu0bMdm5TxPk8ordeakGaqLJ4OONzIN4EzyCRMm7LX7yiuv1FVXXXXAt952223q6OjQxz/+8f0eM2vWLP385z/XwoUL1dnZqe985ztaunSpVq9erfHjS/sgBUVyACiB8fFxijpRZf2cEv0sv5v1soq5MY2Ljw0gHQAAAAAAAAAAwXIdR0vGTNSSMRODjoJ3aOvWrSovf2Nl3beaRS5JP/vZz3TOOedo7Nj910mWLFmiJUuW7Hm9dOlSzZkzRz/+8Y91zTXXvLPQf4EiOQCUQE20RvMq5unZthWKmLBCzhuXV+OnNT2yTkenetXT9gFl3Hol4+9SIn6eHCcRYGoAAAAAAAAAADASmde2Up9TksrLy/cqkr+VzZs367777tMtt9xySJ8XDoe1ePFibdy48ZDedzAokgNAibx33AVqze3W5vRWGc8oZFyF1KuzUss1NtyluJOU50dU9HYqn1+p3swdqq3+d7lOZdDRAQAAAAAAAAAABsQvfvEL1dfX67zzzjuk93mepxdffFHnnntuyTM5JT8jAIxS5eFyfX763+j949+jiYkJSoaSOrNikyZF0yqLjFc41CjXqVbIbZDjVCuXf1adXdcHHRsAAAAAAAAAAIw0doC2Q+T7vn7xi1/oYx/7mEKhvedvX3LJJbriiiv2vL766qt1zz336JVXXtGKFSv0kY98RJs3b9anP/3pQ//gt8BMcgAoobgb14l1J+jEuhNULG5X0667JFXJMXv34zAmIscklc7eqwrv83LdumACAwAkScXiDmWyD8i3nXKdOsVjp8p1a4OOBQAAAAAAAAxr9913n7Zs2aJPfvKT+4xt2bJFjvPGnO729nZ95jOfUVNTk6qqqnTEEUdo2bJlmjt3bslzUSQHgAGSL66XtWk5Tn2/48Yk5futyhfWK06RHAACYa2vzu4fqqf3f+XbXhkZSVYd3d9XRdlnVZb8sIwpdfcmAAAAAAAAYGAZ27eV+pyH6swzz5S1/b/xoYce2uv1ddddp+uuu+5tJDt0FMkBYICYPR0tfPXf3cJKMjLGHbxQAIC9dPf8XN09P5NMRK5TL2McWevJ9zvU0f3vcpxyJRPnBx0TAAAAAAAAQAnRkxwABkgkvFDGKZdvu/sd9223HKdSkfD8QU4GAJAk3+9Wd++vJYXkOlUypu+nsTGuXLdGskV19fxC1haDDQoAAAAAAAAcqiHSk3yookgOAAPEdauVjF8ga7Py/fSe/dZa+X6vrM0rmXiPHCcVYEoAGL2y+afl+21ynIp9xqysHKdCRW+r8oU1AaQDAAAAAAAAMFBYbh0ABlBF+aXy/GZlsg+o6HVKr/W6NSasZPxcVaQ+G3REABi1rM3IypfU1/bCswVlvU7l/R7J+nKMq6hjVPS6FA02KgAAAAAAAHDoRtDM71KjSA4AA8gxcdVU/qty+SeVztwrz98l12lQIn6WopEj9iztCwAYfCF3goyJyiojzzrqLjTJ94vyrWStFHbyylpp2a7f6+TxRyjsxIOODAAAAAAAABwUY/u2Up9zpKBIDgADzBhHsegSxaJLgo4CAHiTSHiBIuF5yuVXqMcryPMLKnpGspIxkitf29OVeim/VhH9r06a+MmgIwMAAAAAAAxLXYVePbbrRT3Zulq9XlYT4vU6sX6RDqucJofJZAgARXIAAACMSsYYVVV8VTt2f0qu3SrfOgoZR67jyzVWPcW4XuqZoKLj6bnmO3TMmIsVCzObHAAAAAAA4FDszOzWt9f9r7ZndslYyXVcbelt1pNta3RK/WJ9cuq75FIoLz2r0i+3PoJmkvMnDgAAAKNWJDxH6cgl2parkm8dOcaqaF292luvp9pmKuPF5HsRyenVUy+vCjouAAAAAADAsOJbXz/YcIu2p3epKpxSTbRCleEy1UYrFDEh3d/8rO5reibomBiFmEkOAACAUS1brNfadKNeyE5U1JHyvitf7p5xx7GyMnplZ5dOnB1gUAAAAAAAgGFmTecmvdq7U6lQYp/Z4olQTNl8Xvc2P63TG49kNnmJ0ZP8wCiSA0CJ+X63srmnZG1GodA4RcKHyfCXOwAMWXXRBfI8V8b1lfVi+4yHwnntaqlVlakIIB0AAAAAAMDwtbFnuzzrKeL0X5KMu1E1Z9vUlutSXaxycMNhVKNIDgAlYq2v7t4b1N1zo3y/VVa+jIkqHJqpqoqvKhpZGHREAEA/xldMV7ZjmhI162XkyvNCkowkq3A0K89z9eqGmXr3GY1BRwUAAAAAABhWjDEH0cfayJjBSDPK0JP8gJjaCAAl0tX9Y3V2fV++3yXHqZXrjJExCeULq7S77e+UL6wPOiIAoB/GGB1R81k1bR8n4xYUjfcqGu9RNN4r33P1wnMLlNJhWjx1XNBRAQAAAAAAhpWZqQkKOa5yfqHf8YyX09h4jaoj5YOcDKMdM8kBoASKXou607+WTFiuU7Vnv1FcxonK85vU3fM/qqn6VoApAQD7c9rC+dq66/O677EHVF23TZGwp56ehLZvHa8x5eN1xYdPlePwSDMAAAAAAMChmJWaoOll47Wma7NCxlXIcSVJ1lr1elkZGZ3VeLQcWpaWHD3JD4wiOQCUQDb7kKzfLcep32fMGEeOSSqTe+i1WeY8EQcAQ40xRh8/7SgdO2uS7n1ugzY1t6s+FtYFZ0/WSfOnKhmLBB0RAAAAAABg2HGMo8tmvE/fWf+/2tS7U7J998x96yvihHTu2CU6uX5x0DExClEkB4AS8PwO9fVN2c/TbiYs2RxFcgAYwowxmjOhQXMmNLztczRnu/Rs66vK+0VNSNRoUfVEuTwJDQAAAAAARrG6WKWumv9JPdm6Rk+3rlWvl9W4eK1OqDtMs1IT+/qWo/ToSX5AFMkBoARct28GubWejHH3Gbc2J8fE5LxpKXYAwMiR8wr6yYaHdO/OVer18jIyco3RpGSNvjjnbM2pGBt0RAAAAAAAgMDE3ahOrl/MrHEMGUxrAYASiMdOkeNUyffb9hmz1pO1GcVjZ8txkgGkAwAMtP9Yf69u27ZCvqzqoinVx1IqC0X1cvcuXfn8rdrcszvoiAAAAAAAABhN7ABtIwRFcgAoAdepUEXqc5JxVfSa5NuMrC3I97vk+c0KhyapvOxjQccEAAyAl7tb9GDTWiXdiMrDcTmvLREWdcOqi6W0O9et27atCDglAAAAAAAAgNex3DoAlEhZ8q9knDJ19/xcheImWfkyiioRP1sVqf+nUGhc0BEBAANg2a4NyvlFVURT+4w5xijmhvVw8zp9fuapCjv8/AYAAADeqd7urB798/N67K4X1b67W9V15TrhnIU6/uwFSpTFgo4HAMCQYGzfVupzjhTcpQOAEkrGz1UidpYKhfXybVqh0DiF3DFBxwIADKDeYk5GknltBvlfCjuuCr6nrFekSA4AAAC8Qx2tPfrOl3+jV9btlDFSOBJSR2uvXl67Q4/f/aK+9O0PqLyKdncAAODAWG4dAErMGFeRyFzFokdSIAeAUaA+Vi4rybd+v+NZr6CKcELJUGRwgwEAAAAj0I3/cY9eXrNDldVJ1dSXq7wyoZr6lCqqEnrpxW363x/eH3REAACGBnqSHxBFcgAAAOAdOKlhtlKhmDrymX3GCr4nz/o6a+wCOYaf3gAAAMA70bKjXSse26BEWVShsLvXWDgSUjwZ0VMPr1NbS1dACQEAB8taq43dzfr5xkf03TV/1n9vfFgvdTXJ2hFUhcWQxnqPADAI2nsz6khnVBGPqbosEXQcAEAJ1UTL9PFpJ+jHGx5Qc6ZLqXBMrnGU8fLKeQXNqRinCyYsDjomAAAAMOxt2diibCav6rqyfsfjyag6Wnu05eUWVdeXD3I6AMDBKvqe/mvDA/rz9heU84qysjIyumXLMzpjzDxdNusMhR33rU+EAzLWypT4oYNSny9IFMkBYAC90tKmG5c9p+Ubt6jgeQq7ro6dNkEfXrpY0xtqgo4HACiRCyccrqpIQr/d/JRe7dkl31olQ1GdN+4wfWTKUpWH40FHBAAAAIY9xzEyRrK++l0j1fpWxhi5Lqs4AcBQ9tvNT+mPW1co7kZUH0vJGCNrrXqLOd2x/XlVR8r0sWnHBx0TIxxFcgAYIBuadusrv71Lu7p6lIxGlIiEVSh6um/NRq3cslP/8ldna9aYuqBjAgBK5KSG2TqhfqZ2ZDqU84pqiJWrLBwLOhYAAAAwYsyYP15l5Qn1dmdVXrXvSn293VmlKhOaOmdsAOkAAAcjXczpj9tWKGRcpd5038QYo7JwTAXr6U/bn9P7Jh7JfZV3aiB6iI+cieT0JAeAgWCt1X/e/4R2dfWooaJM5fGoYuGQUvGoGsrL1NqT1n/e/wT9VQBghHGMo/GJak1L1fMPOQAAAKDEUpUJnfSuw5TPF5Xpze25r2KtVbonp0LB0ynnL1YyxW9xABiq1nbuVHuud68C+ZulQjF15jNa07ljkJNhtGEmOQAMgFd2tWn19mZVxKNyjNlrzDFG5fGo1mxv0cbmVs1orA0oJQAAAAAAwPDy/k+frPZd3XrygbXq6c7KqG9SWyQS0onnLNR7Pn5C0BEBAAdQtJ58aZ/75q9zjJEvq4LvDW6wEcjYvq3U5xwpKJIDwABo6uhRruipPBbtdzwWDqk7k1NTZw9FcgAAAAAAgIMUiYb0uW9coFMvOFxPPrBG7bt7VF2f0rGnztXMhRNk9lN0AQAMDZOStYq5YaWLeZWFYvKtlWOMXr98p4t5xd2wJpdx3/wdY7n1A6JIDgADIBkNyzVGBd9T1Nn3Ulv0fLmOo2Q0HEA6AAAAAACA4ctxHM1ZPElzFk8KOgoA4BA1xit0WMVE3d+0RjsLPbJWchyjymhMqWhUPcWcTmyYpXGJqqCjYoSjJzkADIC54xo0pjKlznSu3/HOTFaNFSnNH984yMkAAAAAAAAAAAjGpo52vbixR7msVDRF+Y6noi1qV7Zbm3vaND5eo8/PPC3omCPC68utl3obKSiSA8AAiIRcfeS4xQq5jnb3pFX0fUlS0ffV2pOWaxx9aOkiRUJuwEkBAAAAAAAAABh41lp9d/njaupKqzE3XlWFWoVtWK5xFFZEtiuhxvx41cfKg46KUYDl1gFggJy9YKZyhaJuePRZtfakZWRkZVWViOtjxx+h8w6bFXREAAAAAAAAAAAGxca2Nj3ftFOpSFRhE1a4UKVUoUpWVkZGXYWcnt66XU093WosSwUdd/ijJ/kBDZsi+be+9S3dcccdWrlypSKRiDo6OvY5ZsuWLfrc5z6nBx98UGVlZfrYxz6ma6+9VqHQsPmaAEYQY4wuPGKeTp83Xcs3blF7b0aVybiWTJ+oVCwadDwAAAAAAAAAAAbN5s52Zb2iKmKxvfYbGUlSIhxWeyatLZ2dFMkx4IZN9Tifz+uiiy7SkiVL9LOf/Wyfcc/zdN5556mxsVHLli3Tzp07dckllygcDuuf//mfA0gMAH3KYlGdMX9G0DEAAAAAAAAAAAhM1A3JkZFnrULG7DPu+b6MMYq6tCkthYHoIU5P8gB885vf1Be/+EUtWLCg3/F77rlHa9as0Y033qhFixbpnHPO0TXXXKMf/vCHyufzg5wWAAAAAAAAAAAAwOsWNY5RZTymrly23/HufE4NyTLNqasf5GQYjYZNkfytLF++XAsWLFBDQ8OefWeddZa6urq0evXq/b4vl8upq6trrw0AMPRx/QaA4YtrOAAMX1zDAWD44hoOIGipaFTvnzNfRc9XVy4ra/umJfvWqiObkbXSxfMXKsJM8tKwA7SNECOmSN7U1LRXgVzSntdNTU37fd+1116rioqKPduECRMGNCcAoDS4fgPA8MU1HACGL67hADB8cQ0HMBR8fNHh+sD8BbJWau7tUXNPj3b19sg1Rp9YdLjeP3d+0BExSgRaJP/qV78qY8wBt3Xr1g1ohiuuuEKdnZ17tq1btw7o5wEASoPrN4Ag5D1Pa5pa9MKOJnVk+l8aDG+NaziAIGS8jF7t3aRNvZuV83JBxxm2uIYDCEJbV1qrX9mpjVt3yfP9oOMMW1zDAQTB83y9urFZ61ZvV0dbr0KOoy8ee5x+eeH79Pkjj9EH5y/QZUcv0Y3v/Sv99RFHyemnVznevtf7kpdqG0lCQX74l770JX384x8/4DFTp049qHM1Njbqqaee2mtfc3PznrH9iUajikajB/UZAIChg+s3gMHkW6tbX1ij3z73opq6e2StVSIS1hmzpuvTxx6pings6IjDCtdwAIMp5+V0d9O9erLtaaW9XklGqVBKx9cu1an1JyvkBHprZNjhGg5gMO1q79H/3Pm0lr3wqnL5ohzHaFxdhd5/2iKdeuQMGQoph4RrOIDBZK3VI/et0e1/eFpN2zvk+76isYiOWjpdH/jY8ZpcW6WPL6oKOiZGsUD/JVhXV6e6urqSnGvJkiX61re+pZaWFtXX10uS7r33XpWXl2vu3Lkl+QwAeKd2bGvTA39+QU89tkG5fFGTptTplLMW6JgTZspxjFa17dQdW9dqXUezIm5IxzdM0TkTZqs2VhZ0dAAY1X667Gnd+OxKyUrlsaiMMUrnC/r986v1UstufffCc1TGzSYAGHKKflG/3PQrvdi1WmETVtxJSLLqLnTr9p13qiXXog9N/KAcM2K60QHAiNHWldY//vhObdrRpng0rFQyJs/3tbmpXf/+vw+ruzerC09eGHRMAKOMbzMqFDZI8hUOTZfjcN92f/586wrd9PNH5Hm+ylIxua6jdG9O9/zfc3rgjuc1dXylps8ZpxPOWahZh03gwaeBYG3fVupzjhDD5nHpLVu2qK2tTVu2bJHneVq5cqUkafr06SorK9OZZ56puXPn6qMf/ai+/e1vq6mpSV//+td16aWX8nQcgCFh9fNb9R/X3q7O9l6FIq5cx9ELKzZr9fNb9MKKTYqdW62fb3hS2WJRIceRb61Wtm7X7159Xv985LmaXz0m6K8AAKPSq63t+u3KFxVxXVXE3pgxHom7SnieVu1s1u2r1+uDh3ODDgCGmpUdL2h111qVuUlFnMie/WEnrKyX1bPtz+no6qM0MzUjwJQAgP7c9tCL2rSjTdUVSYXcvoeZwnIVi4TV3pXWr+9+VicePl3V5YmAkwIYDawtqLvnl+pJ/1ae3yrJyjGVSiYuUHnZZ+Q4XIverG13j/5w03IZY1RTl5Ik5bNFdbb2KJ/3ZCVt2NCiLRua9djdL+q8Dx2riz5zMoVyDKph86j0N77xDS1evFhXXnmlenp6tHjxYi1evFjPPPOMJMl1Xd1+++1yXVdLlizRRz7yEV1yySW6+uqrA04OAFI2k9ePvvdn5TKdqm1IqrIqqVRFXLX1KcXiYf3fiy/oh88/KmulhniZamNJ1cfLVB9LqjnTrStX3KV0MR/01wCAUen+l15WplBUeT8PXkZcV44xumPN+gCSAQDeyjPtz8jK7lUgf13UicqzRT3bviKAZACAAykUPd3/9EuKhN09BfI3qyiLqyed1+PPvxJAOgCjjbW+2jqvVmf39+V5rXJMSo6pkG+71dXzM7W2f0XWcu/2zZ56/CX19uSUqohLkqxv1bKjXYW8p3DYkesYFY1UU5+S6xj96VfL9OQDawJOPfKUuh/5SOtLPmxmkt9www264YYbDnjMpEmTdOeddw5OIAA4SL7XrnVPfEeXffpBlaXyKhRCenH1TD21YqHa2lOKxiPaPbVbvbmixlRW7PVexziqjSa0vbdTD+7YqPMm0j4CAAaT7/tau36LMr05tfcWFYlHlCiPy3nTk83RUEgt3b3yrd1rPwAgWPlsXq/u2Kycn1dbsUPxZEzxsjdWBDHGyMhRa641wJQAgP7s3NGq1l2d8j1fHem8EuUJReJvPPDkOEbGSLs7egNMCWC0yOWfVjrzZxlTttfy6q6plm+zyuYeVTp7n5LxcwNMOXQ0b96l5XeuVLY3q25jlaxIKpPJK5crykrKF3xJfat2Fz2rsoq4djd36d4/PKNjTp3LbHIMmmFTJAeA4SjTvV3NL3xcExqaVCg6KuRdRcNZLT1mpWbM3ajrnzpCbWOsJtUVVfQcOSqoWKyXteE95wg5rqyVVrc3USQHgEG0a1urrv/8T/Ws063c3Aq19RZlJIWjYdVPqFEs0TezvOB5qkzEKZADwBCy7qkN+uEXfqH2DzbLmSWl2zLqMF2KJSKqn1inUNiVJPnWVyqcCjgtAODNHv7tMv3yn36v7pl18h2jdMFTe0unyiqTqh1XLeM4stbKWqtUMvbWJwSAdyid+bOszctxqvcZc0xMnjqUTt8x6ovkvu/rN/9yq+7+xYPqUEi5VLlyXWm1NXfKhkPy/+J4z1o1d6Q1pjqpeCKiTS81KdObU6KMa3vJ2Ne2Up9zhKBIDgADaM19/5+mzNihjva4Cn5IRlbWMbIFqa6hS5888xn9+5YFKhijSLgo19muSKRd6fQMWbv3sr48QQcAA2vFth26ffV6vbCjSY61yj6xVXbDFtXXpdRmjEw8LLfgq5ArqHnzLo2d3ijHdVTwfZ0zh162ADBU7Hy1Wdf99Y/V3tyh1NqEinMzcmJ9v8Ezvbm+a/i0BhVsUY5xtKjysKAjAwBes+L+F/XfV/xahXxRVelKtVXF5Roj6/nqbuuRjFQ3vlY96ZxikbCWLpgcdGQAo0DR2y4jd//3Z01YRW/b4IYagv7vh3fr//7zboWjYdVVRrXTMZLjyvMl6/VVVo1jJNtXZ3WMlCv42t2VVSo0bLpDYwShSA4AA2T7S6vVOHa1crmQ5Pf9JW8l+a4jN1lQ2rqaGO3VRGW0MZdSIWxVLEqxaFqx2BZlMn0Fl6LvyTFG86oaA/w2ADCy/fqZ5/XfTzyjXLGoiOsqm86pq9ZR+PzJmrmqW7VNObWMjckaRyEjFQqeWlu7ZJMRTays0Pnz5wT9FQAAr3ngpsfU3tyh6rHVMqus/GMK8icUZTJGbsZRLp1Te3eHFJNml8/SvHJWawKAocBaq9t/dLdymbxqxlYp0ZlVdyqqQqjvN7iR1NOelpPskTXShSct0Ni6irc8LwC8U65TIytvv+PWFuU6NYOYaOhJd2f055/dLyfkKlXdtyR9mTx1GVfWNZJvJWNkX5uFbIwUch35VkpnizLGav7hkxVPRg/wKThUxu/bSn3OkYJHMwBggLzy3DJFYkUV8mEZ6bVZ5I7kWjkxXznfVdj4aoim5eQkIyNrjApFo1CoS46TkWd97c6mNS5ZoVPGTA/6KwHAiLRi2w799xPPSLJqKEuqOhFXKF1UqLcgP2y0cX5KEzf2auzmjBwr5eOuimVh9WZyOnL8WP3bBWerriwZ9NcAALzmyTueVSgS6utXm3MUvTEld3VEciVVW6lGymXyOrr6SH1i8iUKOcwfAIChoHVnuzY+t0mJ8riMMYrlPU3Z3qVktiDfceRFQyqGHalQ1AfPOFyfPP/YoCMDGCXisTNk5Mra7D5j1hYkWSXiZw9+sCFk3ZMb1LmrS2WVb9wfqVZBydcfLnh9Fr61cowUdh0ZY+QYyfN9yTE6471HsJoqBhX/EgSAAZLLWFnfyHGsfElhWeWMZEJWMlbG65tZXvAdRRSSV7TKhzwVrVFInrqKberNlWtMolzXHHGO4qHwW30kAOBt+NOqdcoVi2pMle3Z5/tWRlIoa5WPO2ptiGn62h5NeCWtzuqwenuzqjNh/cc17+IfcAAwxGR7c3JD7p7XTpej2I0p+fWe/HFFde3u1oKps/XR73w4wJQAgL9UyBbke77C0TduWSdyRU3f0qneeEj5sKue1h599JPz9YHzjgowKYDRJh47QdHo0crmlssxSRlTJsnI2l75tluR8Dwl4ucEHTNQuUxevu/LfdOy6UZSSp7SciVZ+Z5VKBKW71v5Xt90ZN/2HXjs6fN0zKms8FRy9CQ/IGaSA8AASdYs0K6dMcWTeUl9Pwrc1xuuyCgZKirthfRqrlaOaxQuOIpmXIUKjkLG0Yzyev2/eSfqZyd+QHOqGoL8KgAwor2wo0lR191rXyTW92CSee263V3Zd6MumvNVvzOn1Np2zRvbSIEcAIagSXPHK5/N77PfaXHlPhuRv9xo6tjJgx8MAHBAVY2VSlYklO3N7bXfSCrLFJXa1aOy3T2aOnNsMAEBjFrGRFRb9W9Kxt8tSfL8Znl+k6Si4rFTVVt9vRwnFWzIgI2d1qBIPLLPNTwqv69E7lu5shozsVq1DeWKJaKKxsKKJSKqH1OpT33xbO6xDABjB2YbKZhJDgAltqWrQ4/v3KyeCY7Sd8/Wh8atVCKVV7onLMdaFQtGcRUVdn090jJOvX7kjTd7UirpqD5ZrX+Yc4mSoURwXwQARgnXceT/xWOwZVVJde7uklf0JePu1W8p3Z2RG3J18gePG+SkAICDcfIHjtOqx9Yp05NVvCy2Z7+1Vp2t3Yqn4jruPUcHmBAA0J9YIqqT/mqpbvv+nSrkiwpH3rh1ba1V1+5uNU6t16JT5weYEsBo5Tjlqqn6lorFbcrlV0qyioTnKhyeFnS0IWHinPGaddR0vfDwGkXjETlu3xxdR1LSy6tDYUUSEUViYUXjEaWqEspm8urtyenM8xervJL74Bh8zCQHgBLJFAu6+okH9OG7btZ3n31MP1n7jG5oOEL//fJC5XypvCqjqspe1ZWnZQpGj3c06K7OyXp9fZKi58mJ+IrEHC2pOZYCOQAMkiWTJ6jg+bL2jUJ5JBpWVWOlrJF8z1d8W4/SXRm17WhXtienUz6wVEedvSi40ACA/Tr23Ufo+Pcdo0x3Rm0725Xuyqi3M63WHe1yHKMPfe29GjOFlZoAYCi64NKzNOvo6erc1aX25k5lujPqbuvR7u1tSlWX6TP/+lGFI7SjAxCcUGi8kol3KZl4NwXy1/Rm81q+bovmfOIElc1u1O6d7epq7VamO9M3AWHnLlVFjBIVCbW2dGt3S5d2t3Qrn/N0/ClzddFHlwb9FUYuawdmOwRXXXWVjDF7bbNnzz7ge373u99p9uzZisViWrBgge6888538t/CfjGTHABK5F+ffkS3v7pOsbCjsqQnzynKT0g39xyuh1ZO1/t2rFJdqFcFpbSie5FeHZ9ReEarTKxvCRrXGKXiCR1ff4zOaTwr4G8DAKPHu+fN1l1rN2hXb1q1yYSc15b3SlWXqVuekl0FVW1Ny/q+piycqDM+epJO/uBxchyeNwWAoch1Xf3Ndz6mmUdM0303PqKmV5pljNHiU+fr7E+eqsWnLgg6IgBgP5IVSX31V/9Pd//8QT34m8fU1dqtUCSkU959pM759GmaMn9i0BEBAK/xfaubH12pW5atUntPRr61Ch83UWWLx0rLN8lrTausIqkTPnWszv7kqWrryOqJR9ervbVXlVUJHXPCTM2cO06OwzLrI928efN033337XkdCu2/PL1s2TJdfPHFuvbaa/Wud71LN910ky688EKtWLFC8+eXdjUZiuQAUAIvte/WfVs2KhzLKxvplq/X1uV1JbfCqDkf0YZpn9AHF5ykZEVC75PRC+u26/GXXlBLdLOi5VYzx43TMQ1HaEJ8PP1XAGAQTa+r0VdPP1Hfvv9RtfT07tlvJE2qr9bVHztdk75SJt/zVVaZ5BoNAMOAG3J1xkdP0mkfPkG9nWm5IVeJVDzoWACAg5AsT+i9f3eeLrjsbPV2pRWNRxSNR4OOBQD4Czfc97T+95GVch1H1WVxuY5RJl9Uu7UKX7hQV73vFE2bVL9nBZDasdLMuWMDTj26DEQP8bdzvlAopMbGxoM69vrrr9fZZ5+tL3/5y5Kka665Rvfee69+8IMf6Ec/+tGhf/iBcpX0bAAwSj2+Y7PS6pWJdMvKypErIyP72n9MOK+HO1bpm6kz5bquJGnxvAlaPG9CwMkBAJJ0yoypmtNQr3vWb9Dapha5jqMjJozTaTOnqjwWe+sTAACGJMdxlKoqCzoGAOBtcEOuyqtTQccAAPRjZ1uXbl2+SpGQq4rEG/dNEtGwYuGQWjp7dfeaV/WFGeMCTImB1NXVtdfraDSqaLT/h9o2bNigsWPHKhaLacmSJbr22ms1cWL/q8MsX75cl19++V77zjrrLN12220lyf1mFMkBoAR6C3nZSFp6U4Fcksxr/7GyKjhZre1s0hG1LA0GAENRY3mZLjlqcdAxAAAAAAAAhrTH125SJl9QbXlynzHHMYpHQnp41cv67DnHKhahFBkY+9pW6nNKmjBh7wmAV155pa666qp9Dj/mmGN0ww03aNasWdq5c6e++c1v6oQTTtCqVauUSu37MFxTU5MaGhr22tfQ0KCmpqaSfYXX8ScTAEqgMh6VdYtyrOl3GV7fSo4jvdS9gyI5AAAAAAAAAGDY6urNSjLyi756erLyPV+hSEiJVEyOMQqHHOWLntK5PEXyEWrr1q0qLy/f83p/s8jPOeecPf//woULdcwxx2jSpEn67W9/q0996lMDnvNA+JMJACVwTON4OS8ZedbKkaQ31cmttZKVYm5Ifskf2wIAAAAAAAAAYPBUJGLK9GS1dUenrO/v2R8Kh1QzplJ5Y5WMRVUWiwSYEgPZk7y8vHyvIvnBqqys1MyZM7Vx48Z+xxsbG9Xc3LzXvubm5oPuaX4onJKfEQBGocmpao1NVMgYq4Lvyfd9+daq6Psq+r5iIVfxUFgTkzVBRwUA9CPvtaort0q9hVdkrf/WbwAAAAAAABhlrLV6Zut2/e6Rp9WeLKhrjKNCVUhOxJUbclUsFNWyrU3pTE6nL5quSJi5uthbT0+PXn75ZY0ZM6bf8SVLluj+++/fa9+9996rJUuWlDwLfzoB4CC1NHVq08stMsZoxuwxqqx+o99K2Anp4qnH6McvPaiiZ5UtepK1ChlH5dGorONrfKJKx9ZODfAbAAD+Ura4U5s7/1ttmUfl25yMXCXCUzW+/KOqTZwUdDwAAAAAAIAhwbdW1z+8TLesXK22TLdsSPJco56YlCkzKt/tS66rvKRk2tN7j1sQdGRY27eV+pyH4O///u/17ne/W5MmTdKOHTt05ZVXynVdXXzxxZKkSy65ROPGjdO1114rSfrCF76gk046Sd/97nd13nnn6Te/+Y2eeeYZ/eQnPynt9xBFcgB4S10daf3PTx7SM8s3KpvJSzJKJqM67tQ5+tAnT1As3rdkzHsnHqEX27fqmbZXFQ+HFHFCkqxyflHVkaS+NPcchR0uuwAwVOSKzVq960tKFzbJdRIKOSlZ66k7v1YvtX1Tnv17NSTPDTomAAAAAABA4P60ap1ueWG1/HxR4d6i3LCroivlQ0ZeROqqdZTaZVXZnlfDtk6Fsp5UEXRqBG3btm26+OKL1draqrq6Oh1//PF64oknVFdXJ0nasmWLHOeNhc+XLl2qm266SV//+tf1ta99TTNmzNBtt92m+fPnlzwb1RoAOIBsJq/vXP1HvbR6u+KJiKprU7LWKt2b0z3/95xaW7p0+T9eIDfkKO5GdNVh79Gft7+gO3c8r+ZMl8KOq7MbFuqC8Ys1uawu6K8DAHiTbV2/VrqwSVG3Tsa4fTuN5JiY8n6rNnX8SDXxExVyyoINCgAAAAAAECDfWt3ywmpZK0XlqFeSkRT2rEKeVcEz8l1pcmtBFTuyymaKyvbmgo496g1kT/KD9Zvf/OaA4w899NA++y666CJddNFFh/ZBbwNFcgA4gGUPr9eGNTtUUZ1UOPxaAUVGqfK4IpGQVj7zqp5/dpMOP6ZvGfWYG9Z7Jh6hCyccroLvKeQ4coyz/w8AAASi6PdqV+Y+uSb2RoH8NcYYRZxK5f02tWUeVX3ynIBSAgAAAAAABK+lu1dbOzpVFonI+kVJfatuG/NasbxolXONsgmjWCaveCKiyrryYEMDb4HKDQAcwGMPrJWkNxXI3xCNheV5vp54dP0+Y8YYRdwQBXIAGKIKXrt8m5Vjov2OGxOSZJTzdg1uMAAAAAAAgCEsnoopFHHlFb19xnzfVy5b0NLzFiuRigWQDnuxA7SNEFRvAOAA2tt6FOqnQP46xzFqb+0ZxEQAgFIIOWUyCsmq0O+4tb4kq5DDU88AAAAAAGB0q08lNaGyQj35vBxjVNNYJcd1VCx48n2roqzkWdnN3Zo4s1Hnf/rUoCMDb4kiOQAcQG1dSoXCvk/Evc73rWrqUgd9vh27OrVi/Tat29Qsz/dLEREA8DaE3UpVxY5V0U/L2n0fgS36XXJNUtWxpQGkAwAAAAAAGDocY/SehXNljNSdyymZiqlhQo0SqZh8WRXDRqluX+87+yhd8dO/VlU9kw6Ggtd7kpd6GynoSQ4AB3D8qXO1auUW5XNFRaJ7XzKzmbxc19XSk2a/5Xm2NLXrF396Us+9tF2FQlGO42h8fYX+6ozFOuWIGQMVHwBwAOPLP6TO3LPKeS0Ku5VyTVTWeir4XbIqanzZxYqG6oOOCQB4h3o603riruf10nObZK0047CJWnLOIqWqkkFHAwAAAIaN8+fP0Su72/XHVWvV1N2jkOPIVMUUr4hqZiqlfz73TE0fVxd0TOCgUSQHgANYcuIsPXr/Gr343GbFYmHFkxHJSr29ORXynpacNEvzF0864Dm2t3ToH398p5pau1QWjyqZSqjo+dq0s13X3fSQsrmCzlk6d5C+EQDgdWWR2Zpd8y293HGdMoVNKtoOSUZht0Jjyt6vCeWXBB0RAPAOrV+xSd//8o1q3dnRt3KIlR7707P6408f0KXf/pDmHjUt6IgAAADAsOAYoy+evFQnTJuku9dt0Kut7UpFozpp+hSdMWuayqLRoCPiL/m2byv1OUcIiuQAcACRaEhf/Pr5uvmGR7Xs4fXq6shIklLlcZ38nvl634eXyHHMAc9x873Pqam1S3WVqT3Huq6jukiZ2jp79T93PqMTFk9TWZwfEQAw2Cpii7S44efqzD2nbHGnXCeuyuhRCrsVQUcDALxD7S1d+v7f36jWpg5V1ZXLDbmSJM/z1dbcqe9/6de65ua/Ve2YqoCTAgAAAMODMUZHTRyvoyaODzoK8I5RJAeAt5Asi+qTl52u931kqba8sksy0tQZjUqWvXVRu6s3q2UvblI8Gum3mF5RFldbV1pPrtqs046aORDxAQBvwRhXlbEjg44BACixx25fodamDlXXV8hxnT37XddRdUOl2po79Ogfn9V7/ub0AFMCAAAAwACxr22lPucIQZEcAA5SRWVCCw4/8NLqf6mzJ6NCwVM02v/l1nUdGUntXekSJAQAAADwuucfWydjzF4F8tc5jpHjOFr56DqK5AAAAMAAadnRrkfueF4rl29UseBp+vzxOum8wzRjPjPRETyK5AAwgFLJmFzXUaHoKxbZd9zzfdnXjgMAAABQOoVcUeYArZGMY1TIFwcxEQAAADB6rHr6Vf3wqlvV2dYjx3XkOEZbNjbr8bte1EWfPVnnfvDYoCOOeEaSKfHM7wM3nx1e9n2cGgBQMpVlcR01d4LS2bys3fdvo+7erMqTUR0z/9BmqAMAhgbf+tqS3qo1nWu1I7Mj6DgAgDeZsWiS/KLf7+9wa628gqcZi/gdDgAAAJRad0da/3XNbeps71VNfbmq61KqrClTTUO5fOvrtz9+UGtWbAo65shn7cBsIwQzyQFggP3VGYv1wsYd2tXeo/JkTNFISJ7nq6s3K0m66LRFqiyLB5wSAHCoVrY/r1u236admSYVbVHGGFWGK3Re4zk6peFkOYbnUQEgSCecf4Tu/+0T6mztUUVNmYzpm/NgrVVXW49iyYhOuvCogFMCAAAAI8+ye1erfVePqurK9lrdyRijiqqkdjd16oE/Pqe5h08OLiRGPe7cAcAAmzauVld++mzNntygbL6gXe096ujJqKo8oc9cuETvO/WwoCMCAA7Rk61P66ev/Fxb0lv7CuQystaqLd+mX2/9jW7a/Jt+Zy4CAAbPpFlj9eEvv0tuyFFrU4e62nrU1daj1qYOOY6jD37xXE2dRy9EAAAAoNReXrNd1lq5bv9lyEg0rLXPbR7kVKOPsQOzjRTMJAeAQTB7coOu++KFWr+5RU2t3UrEwlo4faxi0XDQ0QAAhyjrZXXr9tuU9tJy5Mh13DcGrVXBFvXo7sd0RPXhmlM+O7igAACd/ldLNGF6o+7/3ZNa/cQGWSsddfQ0nXrRMZp71LSg4wEAAAAj01s0rrayMiOpuTWGJYrkADBIjDGaPblBsyc3BB0FAPAOrOlaq7Z8uyTtu6S6MXLlKufn9diuxymSA8AQMOvwKZp1+JSgYwAAAACjxuzDJuqxu16UV/Tlhva+d2KtVT5X1IKjpgaUbhSxr22lPucIwXLrADAEWK9ZNv+sbGG1rC0EHQcAcACdhS751pcxZk9/2zczrz0uvTWzbbCjAQAAAAAABO6YU+eorrFC7bu75Xv+nv3WWnW09ioej+jUCw8PMCHATHIACJT1mmV7/kvKPybZnCRHcsdIiQ9JsXf3W3wBAAQr4SYk9f3Drr/lw6ysjIxibmyQkwEAAAAAAAyszT27dffOF/VixzY5MjqiZorOGDNPY+KVe45JpuL622veq+v/4Q9qbe6SjJVjHHm+r0Qyqo9+4UzNmD8+uC8xShhrZWxpp36X+nxBokgOAAGxXqtsx+WS94qkpGSqJHmSt022+zsyfqeU/GjQMQEAf2FexRwlQ0l1Fjplrd37gSYredZTyIR0eOWiwDICAAAAAACU2r07V+n76+5TbzEr13FkrbSqY7v+uHWFvjrvPB1V+8YS6tPnjdc1P/uUlt27Si8+9YoKeU/T543T8Wcv0PgpdQF+C6APRXIACErmt30FclMnmdcvxyHJ1Et+u2z6V1LsTBmXHuYAMJSUhcp0TuNZ+u2236toi3KtK8c4srIq2qKMjGqjNTq65uigowIAAAAAAJTExu5mfX/dfcr6BdXHyvdMGrDWaleuW/+65k7959GXqD5Wvuc9lTVlOveDx+rcDx4bVOzRzX9tK/U5Rwh6kgNAAKwtyGbvkhR9U4H8TUyFZHuk3IODng0A8NbOajxDF449XxEnIk+eCrbQVzA3rsbEGvXZaZ9RdaQq6JgAAAAAAAAlcdeOF9RbzKkmktxrVT1jjGqjKbXnenX/zjUBJgQODTPJASAItrdvM9H+x40jWSP5rYObCwBwUIwxOn/cu3Ra/Sm6f9eD2pbepqgT1cLKBVpYsUBRdz/XdwAAAAAAgGHoubYtCjvO3m3nXuMYI2OkFzu26mIxa3yooCf5gVEkB4AgmISkqGTTkknuO26tJNs3oxwAMGQlw0mdP/ZdQccAAAAAAAAAcAhYbh0AAmBMRIqdLikn2X6aeNguycSl6ImDng0AAAAAAAAAgDdbXD1RBd+X7WcmsW+trJUWVE4IIBn2yw7QNkJQJAeAgJj4RZLTKNmWvhnl1kq2KPltkrJS7EKZ0MSgYwIAAAAAAAAARrmzxy5UMhRVa753r0K5tVa7c92qiiZ12pi5ASYEDg3LrQNAQExovFT5b7Ld35MKqyV1SnIkp1KKvU8meUnACQEAAAAAAAAAkKanGvT/Zp+hn228VZNiL2hSvFmOfO3I1SrhzNXfzLpI9bHyoGPizax9rbVric85QlAkB4AAmdA0qfIHUnG95G2RTFQKHy7jpIKOBgA4CLu7e3XH8+t1/+qN6srkNL66XGcvnKUz5k1XNMxPbQAAAAAAMHIcWZVRbPIypYu7VPB9SUZTk52KhXZpYvxISVODjggcNO7cAUDAjDFSeHbfBgAYNjbtatfXfn+3trV1KuQ4CruOXtzWpFXbmvXIulf1zfeerngkHHRMAAAAAACAdyzvteql1qsl26XKyDgZ09fR2Vqrgt+mV9qvUyI8VakI97mHCmP7tlKfc6SgJzkAAABwiHzf6l/veFjb2jpVl0qoNpVQRSKmhvIylcejevLlLbpp+cqgYwIAAAAAAJTErvR9ynutiri1ewrkUt8ksLBTLc9Pq7nnTwEmBA4NRXIAAADgEK3a3qwNTbtVEY/Kdfb+SR0LhxQOufrzC+uVyRcCSggAAAAAAFA6XdmVkrRXgfx1xhgZE1ZH7tlBToUDer0neam3EYIiOQAAAHCINjbvVsH3FdtP3/FkJKyOdFbb27sGORkAAAAAAACAt0KRHAAAADhEIcc54JOzvrUyMn3HAQAAAAAADHPl0YWSJGv9fcastfJtXpXRIwY7Fg7A+AOzjRTctQMAAAAO0WETxyoWCak3l+93vDub17jqck2oqRjkZAAAAAAAAKVXlzxTYbdaeW/3XoVya60KfptCTkINyXcFmBA4NBTJAQAAgEM0qbZSx82YrJ5cQdnCG33HrbXqzGRljNH7j5y/T79yAAAAAACA4Sji1mhmzTcUdquU93Yp5+1S3tutnNcix0Q0pfLvlIrOCTom3oye5AfUfxNFAAAAAAf0xbOPV082r2de3aaOdG7P/ngkpA8vOUznLZodYDoAAAAAAIDSqoodpcMafqKW3rvUnn1SVp7KIwvVkDxHycj0oOPhL9nXtlKfc4SgSA4AAAC8DalYVNf+1Vl6dtN2Pf7SZnVlshpTWa5T507T9IaaoOMBAAAAAACUXCw0RhMrPqGJFZ8IOgrwjlAkB4AhYFNbu+5dv1Gb2jqUiIS1dPJEHTdloiIhLtMAMJS5jqOjp07Q0VMnBB0FAAAAAAAA2MNYK1Pi5dFLfb4gUX0BgABZa3Xzcy/qv594Rul8X09bK6s/r3lJcxrq9K3zzlB9qizglAAAAAAAAAAAACOHE3QAABjNHnl5k370+FPyPF8NZUk1pso0JpVSZSymVTtbdPXdD8ofQU9mAQAAAAAAAACAQWDtwGwjBEVyAAiItVa/X7lKBc9XVSIuY8yesUjIVWU8qhd3NuvFHU0BpgQAAAAAAAAAABhZKJIDQEA6szmtbdmlZCTc73gsFFLR87Ri285BTgYAAAAAAAAAAIY1K8kv8TZyJpJTJAeAoHi+L2ulN00g34sxRjJGvvUHNxgAAAAAAAAAAMAIRpEcAAJSlYhrXEVKvflCv+N5z5ORNL22ZnCDAQAAAAAAAACAYc1YOyDbSEGRHAAC4hijCxbMlSSl/6JQ7lurtnRGE6oqtGTKxCDiAQAAAAAAAAAAjEihoAMAwGh2wYI5WtPUonvWb1R3LqdoKKSi76vo+6ovS+ofzzxFEdcNOiYAAAAAAAAADJrWTFp3b35Jj+/YorzvaV51vc6dMkszq2qDjgYMH1ZSqWd+j5yJ5BTJAYxcnp9RT36dfBWVDE9VxB16y5aHHEdfO+MkLZ0yUbevXqdXW9sVj4R16oypete82RpTngo6IgAAAAAAAAAMmtWtzfrKo3epKd0jqW9FzhXN23XLxtX620VLdNHMBQEnBDASUCQHMOL4tqjt3TdpZ8+tKnitsrJyTVK1iZM1ueJvFHYrg464F9dxdNrMaTpt5rSgowAAAAAAAABAYHryOf3D4/doZ7pb9fGkXKeva7C1Vm3ZjK5/bpmmVFTryIZxAScFhgFrB2Am+ciZSk5PcgAjirVWr7T/uzZ3/EQFr10hp1xhp0pWRTX1/J/W7P6Kin5P0DEBAAAAAAAAAH/hga2vaHtPl+reVCCXJGOMqmNxZbyCbt24OsCEAEYKiuQARpSe/Fq19N4p14kr4lbLMRE5JqSwU66IW6Pu/Gq19P456JgAAAAAAAAAgL/wwu4m+dYq5OxbvjLGKOaG9HTzNtkRNJsVGDD+AG0jBEVyACPK7swD8m1OrinbZ8wxYUlGzRTJAQAAAAAAAGDIsTpw8duYEbXaM4AADZsi+be+9S0tXbpUiURClZWV+4w///zzuvjiizVhwgTF43HNmTNH119//eAHBRConLdbVlbGmH7HHUWU91oGORUAAAAAAAAA4K3Mq2mQMUZFv//pqtliUYfXj93v/V8AbzDWDsg2UoSCDnCw8vm8LrroIi1ZskQ/+9nP9hl/9tlnVV9frxtvvFETJkzQsmXL9Nd//ddyXVeXXXZZAIkBBCHiVMnIyNr+C+W+Coo540r2eUXP1zMbtmrDjt1yHKP5kxq1YNIYOQ4/0gAAAAAAAADgUJwxcbp+vuoZNaV7VJ9IynntHq+1Vh25rCJuSO+ZPjfglABGgmFTJP/mN78pSbrhhhv6Hf/kJz+51+upU6dq+fLluuWWWyiSA6NITeJk7ey5VZ5NK2SSe435tihZT/XJs0ryWS/vbNW//u5BbWppl2+tJKuQ62ruhAZ99a9OUX3Fvku+AwAAAAAAAAD6l4pEdc3SM/S1x+9WS7pXjjFyjFHB9xR3w/rsgqN17JiJQccEhgdrS9+f4BDPd+211+qWW27RunXrFI/HtXTpUv3rv/6rZs2atd/33HDDDfrEJz6x175oNKpsNvu2Iu/PsCmSvx2dnZ2qrq4+4DG5XE65XG7P666uroGOBWAAlUcWqDZxinal75H1Cgo5KUlGnk2r6PcoGZmhhuR57/hzWrt6deWv79HOti5VJWOKhEOy1ipXKGrlqzt01a/v0fc+fb5ikRF9mQ0U128AGL64hgPA8MU1HACGL67hGC4W14/VL858v+54db0e27FJec/TvJoGvXvqbC2obQw63rCU99Pa2rNMHfktckxIjfEFaowfJmOGTVdmDFMPP/ywLr30Uh111FEqFov62te+pjPPPFNr1qxRMpnc7/vKy8u1fv36Pa8HosXCiK3eLFu2TDfffLPuuOOOAx537bXX7pmlDmD4M8bR9KqvKuxUq6X3TuX9Vsn6cpy4auMnaWrV3ynsVr7jz7l7xUva2dal2vKEXMd57bONYpGwahxHG7bv1rK1m3TqYdPf8Wehf1y/AWD44hoOAMMX13AAGL64hmM4aUym9Kn5R+pT848MOsqwtzP9nJ7Y9QOli7v37FvXeZtqorN0XMOXlAzVBpgOA2oAZ5L/5YNW0WhU0Wh0n8PvuuuuvV7fcMMNqq+v17PPPqsTTzxxvx9jjFFj48A+FBPoIyJf/epXZYw54LZu3bpDPu+qVat0wQUX6Morr9SZZ555wGOvuOIKdXZ27tm2bt36dr8OgCHCdaKaWvW3OmLMTZpT8y3Nqr1Gixp+oTl11yoaaijJZzyy6hW5jtlTIH+zcMiVb62Wr9tcks9C/7h+A8DwxTUcAIYvruEAMHxxDQdGn478Zj3e8j2li7sVd6uVDNUpGapT2CTVkl2tx5q+3dem9G3IFndoe/fN2tTxY+3o/r3yXmuJ0+Mde71IXupN0oQJE1RRUbFnu/baaw8qUmdnpyS95UrgPT09mjRpkiZMmKALLrhAq1evfmf/XfQj0JnkX/rSl/Txj3/8gMdMnTr1kM65Zs0anXbaafrrv/5rff3rX3/L4/f3ZAOA4S/sVqkmcdKAnDudy/dbILeScpm88tmC1q3epuce36CFx0yVG3IHJMdoxvUbAIYvruEAMHxxDQeA4YtrODD6bOi8WzmvUwm3bq/lqkNOVHFVqjW/QTvSKzQ+efRBn9NaT5s6f6Kmnlvk2cxrO6Utnf+tCeUf09jUBwdkaWwMLVu3blV5efme1wfz94vv+/q7v/s7HXfccZo/f/5+j5s1a5Z+/vOfa+HChers7NR3vvMdLV26VKtXr9b48eNLkl8KuEheV1enurq6kp1v9erVOvXUU/Wxj31M3/rWt0p2XgD4S5MaqrW9be/lRIpFX7t2tCuTKagQlpo29+i7D9yscZPr9PkrL9CkGfTLAQAAAAAAAAAMPGuttqaXyzXRfovWrhORX/S0M/PcIRXJt3bdqO3dv5ajqCJOrYxxZK2vgt+hTZ0/kuuk1Fj2rlJ+FbxdvqRSP6/g9/2f8vLyvYrkB+PSSy/VqlWr9Nhjjx3wuCVLlmjJkiV7Xi9dulRz5szRj3/8Y11zzTWHHHl/Al1u/VBs2bJFK1eu1JYtW+R5nlauXKmVK1eqp6dHUt8S66eccorOPPNMXX755WpqalJTU5N27doVcHIAI9FZi2fKdRz15vKSJN9aNW9vVyadlx8yCsnRRCemsvK4trzcrO999bdqbe4MODWAgVQoetrc0q7NLe0qFL2g4wAAAAAAAGCU8/y8zAFKgea1Yw5W0e/Rzp7fySiksFshY/rObYyjiFstK1/bu29620u4Y+S67LLLdPvtt+vBBx885Nng4XBYixcv1saNG0uaKdCZ5IfiG9/4hn75y1/ueb148WJJ0oMPPqiTTz5Zv//977Vr1y7deOONuvHGG/ccN2nSJG3atGmw4wIY4ZbOmawzFs/QPSteUjpXkONZpXN5KerIkdG4HqNk0UjRkGrqUmrZ0aFH7nxe7/nEiUFHB1BiBc/TrctW6fan1mpXV9/De3XlZXr3MXP0niULFHKHzTOJAAAAAAAAGCGMMaqMTlZLZrWiSu0zbm3fNOPyyMEXLDuzK1TwOxRx+u8nHXLKlS3uUG9+vVLReW83OkrEWCvzWg/xUp7zUFhr9bd/+7e69dZb9dBDD2nKlCmH/Jme5+nFF1/Uueeee8jvPZBhc9f2hhtukLV2n+3kk0+WJF111VX9jlMgBzAQHMfo8gtP1N+++zhNrq9SOp2XjFGqYDStw2hcz5uOdR2FQo6efGBtcIEBDAjft7ru1kf0k7ueVHN7t+LhsOLhsJrau/XjPz+p7932iHy/tD9EAQAAAAAAgIMxPXWGjBwV/Mxe+621yngdijhlmlx2wkGfz7PZ14rrbr/jRq6sfHk2+05iYwS59NJLdeONN+qmm25SKpXasxJ4JvPGn8lLLrlEV1xxxZ7XV199te655x698sorWrFihT7ykY9o8+bN+vSnP13SbMOmSA4AQ43rODr/mHn68WXv11mRGk1dn9G8VqParJH5i0Yfruso05sLKCmAgfLMhq26//mNSsbCqilPKBYJKRYJqbY8oWQ0rPtXbtCzG7cFHRMAAAAAAACj0KSyEzQldZIKflrp4m7l/V7lvG6lvd1ynbCOqP20EqHagz5fPDRBronK308R3LcZuSaqeOjQltPGALF2YLZD8F//9V/q7OzUySefrDFjxuzZbr755j3HbNmyRTt37tzzur29XZ/5zGc0Z84cnXvuuerq6tKyZcs0d+7ckv1XIw2j5dYBYKhyHKOpk+u1+rGNkpX+oj4uScrnPY2bUjfo2QAMrPtWblDR85WMRvYZS8Yi6snldd/KDTpq5oQA0gEAAAAAAGA0c4yrY+ouVV1srjZ23a2uwnYZ42pi4jjNrDhXDfH5h3S+sshslUXmqDO3Uo6J7ulJLknWeir6vapLnqFoqKHUXwXDlD2IovpDDz201+vrrrtO11133QAlegNFcgAogePOXKB7//CMujszKq9M7DWWSefkOEYnnntYQOkADJRtrZ0H7Dkechxt2905iIkAAAAAAACANzgmpOnlZ2ha6nQVbVaOXLnOvhM+DoYxRlOrvqg1u/8/5YrNck1MxkRkbU6ezSkRnqzJFZ8t8TfA2+ZbyZS4FeQIai3JcusAUAKTZjTogkuOl+/52t3cpXRPTpl0Tm0t3Ur35HXcmQt01Mmzg44JoMTKEzEVPX+/455vVZGMDWIiAAAAAAAAYF/GGIWd+NsukL+uLDJDC+r+Q2PK3ivHicmqKNdJaVzqQ5pfd51iobElSgwMLGaSA0CJXPCx49Q4oUp3/e5pbXmpSdaTxk2p1akXHKHT33O43APMNgUwPJ04f6qe2bBNBc9T2HX3GisUPUlWJ86fGkw4AAAAAAAAYADEwxM0vfrvNcW/TJ7tVchJyTHvrPiOAfA2eogf1DlHCIrkAFAixhgde9o8HXPqXHW29coreqqsTVEcB0awkxdM1Z+eXKP123epPB5VPNL30yqTL6ork9OscXU6iSI5AAAAAAAARiDXickVqyhieKJyAwAlZoxRZU2ZahoqKJADI1wiGtE3P3KmjpoxXvmip5bOXrV09ipf9HT0zAm6+iNnKh4NBx0TAAAAAAAAwKhj35hNXqpNzCQHAACApPqKMv3Lx8/Vhh27tXZriyRpzoR6zRhbK2NMwOkAAAAAAAAAAH+JIjkAAMA7ZIzRzHF1mjmuLugoAAAAAAAAAEBP8rfAOsAAAAAAAAAAAAAAgFGDmeQAAAAAAAAAAAAAMJL4A9BD3GcmOQAAAAAAAAAAAAAAww4zyQEAAAAAAAAAAABgJLF+31bqc44QFMkBjCob21p154b1WrN7lyKuqyXjJ+qsadNVHU8EHQ0AAAAAAAAAAACDgCI5gFHjD2tX6wdPLVdvoSDHOLLW6oltW3Xzqhd07Wlnak5dfdARAQAAAAAAAAAA3jlr+7ZSn3OEoCc5gFHh2Z3bdf2Ty5T3fDUky1SfTKqhrEx1iaR2dHfrHx64V735fNAxAQAAAAAAAAAAMMAokgMYFW5du0a5YlHV8biMMXv2u46j2mRS27u79OCmVwJMCAAAAAAAAAAAUCK+HZhthKBIDmDEs9bq6R3bFQ2F9iqQvy7kOLJWerGlOYB0AAAAAAAAAAAAJfb6cuul3kYIiuQARoW+y/a+BfI3j9sRdHEHAAAAAAAAAOBQeL7PfXKMGqGgAwDAQDPGaHHjGD206RVJsX3Gi74vxxjNrWsY/HAAAAAAAAAAAAQkWyzo9i1r9H9bVmtHb6diobDOGDdT75m8QBPLqoKOh3eib3Zg6c85QjCTHMCo8J7ZcxVxQ2rPZPZ6Es63Vq3pXjUkkzptytQAEwIAAAAAAAAAMHgyxYK+8vTt+u6LD2lD5y551ldnPqObNq7QpY//Qavbm4KOCAwYiuQARoVjx0/QZw4/UsZIzb09ak2ntau3Vy29PapNJHX1KacrFY0GHRMAAAAAAAAAgEFx08sr9GTLZlVEYqqPl6k8ElN1NKH6eJlasj361nP3quj7QcfE20VP8gNiuXUAo8Ylhy3WosYxuv2ldVqza5cirqPjJk7WeTNmqrEsFXQ8AAAAAAAAAAAGRc4r6v82r1LIOIq6e5cLHWNUFYlrU0+7ntq1RUsbJgcTEhhAFMkBjCoLGxq1sKEx6BgAAAAAAAAAAASmOdOtjlxGiVCk3/GoG5LNZ/VK126K5MOV70sq8UoAI2hlAYrkAEaVol/Q2q6n9HzHo2rN7VTEiWl2+VFaVHWiqiL1QccDAAAAAAAAAGDAhR1Xxhj5+1k+21orK6uw4w5yMmBwUCQHMGoU/YL+tOOnWt/1rKyksIko52f0xO47tLpzud4z/vMal5gWdEwAAAAAAAAAAAZUYzylGRV1erFth5LhfWeT9xbzirohHV0/MYB0KImB6CE+gnqSO0EHAIDBsqL9Aa3velZRN6nycLXioTIlQxVKhavVXWzXHTt+rqJfCDomAAAAAAAAAAADyhiji6ctVthx1ZZL75lRbq1VulhQTyGvExqmakqqJuCkwMBgJjmAUcGznla2PyzJKOJE9xozxlHCLVdbvlmv9L6omanDgwkJAAAAAAAAAMAgOXXsDLVkevSTdcvVkunp22n6lmI/vnGKvrLotGAD4p1hJvkBUSQH8Lbs2t6mtuZOJVIxjZ/eKGNM0JEOqLfYqa5iu6JOvN/xkBOWPKuW7DaK5AAAAAAAAACAUeGD0xbrxDHTdO+29dqZ6VLCDeu4xqlaXDNOzhC/7w+8ExTJARySbRub9dv/uEsvLntJhVxRbsjRpDlj9d6/OUOLTpwddLz9co0rIyMrv99x+9rTT65xBzMWAAAAAAAAAACBGpso18dmHhV0DJSabyWVeOa3P3JmktOTHMBB2/5ys/7lr3+qp+55QcYYpaoSisTC2vDcJl1/+a/05D0vBB1xvxJuuRpjk5TzM/2OF2xOrglpYmLoFvoBAAAAAAAAAADwzlEkB3DQ/vBf92r3jnbVjKlUsjyuUDikWCKqmjFVymXyuuk7dyifKwQds1/GGB1ZfYZCJqzeYteemeOSVPDzyno9mpicrbHxqQGmBAAAAAAAAAAAeOes9QdkGykokgM4KO0tXXru4bVKpGJynL0vHcYYlVeXadeONr3w+EsBJXxrs8oP18n171fIuOoutqmzsFtdhd3Keb2amJitd4391JDvrQ4AAAAAAAAAAIB3hp7kAA5K+64uFfNFJVPxfsfDkZCsldqaOwc52aE5quYMTUst1JrOJ9Web1bEiWta2QJNKZtPP3IAAAAAAAAAADAyWFv6HuJ25PQkp0gO4KCUVcTlhlwVCp7C0fA+417Rk5GUqkgMfrhDVB1p0PF15wcdAwAAAAAAAAAAAAFguXUAB6V+fI1mHT5ZvV3pvfp5v667o1flNWVaeMKs/Z7Dt56yXocKfmYgowIAAAAAAAAAAIxu1g7MNkIwkxzAQbvws6dr4wtb1drUofLqMkWiYRULnro7eiVJ53/qlH6XYy/4aa3vvFMvd9+rrNchI0djE0dodsW7VRvbf1G9FNrbe/Xqq7skI02f1qDy8v6XiwcAAAAAAAAAYCTIFneopfcutWefkmRVHlmo+rJzlAxPDToaMGRQJAdw0OYcOVVf+N5H9Kt//ZN2btqlrkKPjGNUWVeu8z99is768HH7vKfgp/Vw0z+rOfOiHLkKOTH51tPmnke1M71CS+q/qPHJo0qetbc3pxtvWqbHl21QJp2TjFEyGdVJJ87WxR84VrHYvkvGAwAAAAAAAAAwnLVllmtD27dU8Nol48jIqDu3Sk29f9S0qi+qPnlO0BExWHxfMn5pz2lLfL4AUSQHcEgWHjdL/3LLdK156mW1NnUokYprwZIZipfF+j1+feftas68qJhbIddE9uyP2DKlvVY9vftHaojPV9gp3QzvfL6o73zvTr3w4jbFomFVViYl9RXOb79jpXbt6tKXvniOXJeOEwAAAAAAAACAkSFXbH6tQN6hiFsnY/rugVtrVfBb9XL7dUqEp6ssMiPgpBgU1koq8fLoLLcOYDRzQ64WLJ35lsf5tqiXu+6To9BeBXJJMsYo7lYqXWzVtt4nNSV1csnyLX9io1at2qaK8rgikTcuc+XlcfX2ZPXE8o26b/ZKnXneYhljSva5AICBY63V9g07le7OqHZctaobq4KOBAA4SMVCUVvXbVex4GnstAYlK5JBRwIAHKRMT0bbNzTJcR2NnzVWkSgr8wHAULYrfa/yXruibp18z6qQz8txjMKxsMJOjXJei5p7b1dZ5ItBRwUCR5EcwIDJep3K+p0KOf3PMndMSEZSd2FHST/3kcfWy1rtVSDPZfNqb+pQpierouvoB1f/QU/9z4N63+Xv1txj37rgDwAIzor7XtAt19+pTau3yC/6CsfCOvz0hfqrL5+vMVMago4HANgP3/d1368e0Z3/fZ92bW2VtVbJ8oSOf+8xev+X3q1keSLoiACA/cimc7rtP+7Ug795XN3tPTIyqh5TqTM/drLO/czpckNu0BEBAP3ozD0v61vt3tmu3s60fN/KGCkcC6uyrkKRVEid2WeDjolBYn1ftsTLrdsRtNw6aw0DGDAhE5WRI2u9fsettbKyck20pJ/b1tqj0Jv+sZbL5NX0SrN6O9OSJMcY+eGQXnhkrf7t4z/UC4+sKennAwBKZ9kfn9a//81P9NIzGxWJhZWsSspaq8dueVL//KHr1bSpJeiIAID9+M2/3qZffP1/1bRpl2JlMSUrEsr0ZnXHT+7Vv338h8r0ZoOOCADoRyFf0PWf+4lu+Y871dPZq0RFQvHymHbvaNON//R7/fxrN8mOoKVWAWAkyWfz6unoVVdbj6y1clxHxjHKZ/LatXW3sr25oCMCQwZFcgADJuKWqTG+UAWb7vcfTwWblmuiGps4vKSfW11dpqL3RmG+raldxYKnUCTU14fcGEVdo9rx1ertSutXV/9Ovj9ynn4CgJEim87pxn/6vfLZvGrGVSuWjCkcCamsMqmasVVq2tSi275/Z9AxAQD92LJuu+762f0KRUOqbqxUNB5ROBpWeU1KFXXlWvvES3r45mVBxwQA9OOJ21fouftfVKq6TBW15YpEw4rEIqpqqFS8LKaHfrtM657aGHRMAEA/Xl0eku95CkUcOSFXxjEyjiM3HJK1VtlMr+J2YdAxMVisHZhthKBIDmBAzap4t8JOQhmvTf5rM8qttcr7aRX8tMYnj1ZVdEpJP/OE42dJkvL5ogq5grK9ObkhR0aSL8nIKlUoyBij8uoybX9pp9Y9uaGkGQAA79xz97+otp3tKq9NyRiz15jjOoolo3ryjufU1dYdUEIAwP4s/79nlO3Nqaxy3/7j4WhYxjF66ObHA0gGAHgrj/x+uaxvFY1H9hmLp+Iq5Ap6/LanAkgGADiQfK6gh/8rp2xHRPHqnKQ3FzOtkrVF5XocbX9iQlARgSGFIjmAAdUQn69j6/5WMbdCGa9NvcXdSnut8m1Bk8qO1zF1ny/5Zy5dMl3z541XZ1dGXV0Z+b6VjJFnjDzHUaJQVKJYlNTXi6WQL6p1Z0fJcwAA3pm2ne2SpFA41O94NBZRPptXR0vXYMYCAByE3dtbZa32ecjpdeFYWLu2tbJcLwAMQS2bdykU7f83uDF9MxKbaXsEAENOT3uP2rdaPfOTucp3R5SozipW2bfFq7Py8q6e/vFUtW5MBB0Vg8W3A7ONEP3/2gGAEppYdpwa44u0tXe5ugs7FHJiGps4UlWRKfu9afZORCIh/f2XztGvbnxcjzy8TjbsyjNGrqTKfE412axe/1Sv4MkNOUpW8MMAAIaassqkrG/le74cd99nOwuFotywyzUcAIagssqkZPpWkervN38x76m6sXJA/j0AAHhnUjVlat68a7/j1vdVXpsaxEQAgIMRT8UVCoe0/dkKPXbtEo0/dodq5+6WMVZtG6q09fFx2rKioONP5D4KIFEkBzBIIm5S08pPH7TPK0vG9LnPnqaL3neUvvHh72vHy02qq0oo/BfHdbX1qGZsteYfN2vQsgEADs7i0xYoWZlUd3uPKmrL9xqz1irdmdGRZx2mmjFVASUEAOzPUWcv0j03PKRsb07xstheY57nyysUdcJ7jw0oHQDgQI674Gi99MwrKhY8hcLuXmO5TF6O6+rY844IKB0AYH/iyZiOPGuRHrz5caVbqrXh9unacPv0PePd7T2KJqM66uxFwYXE4LJWfU1oS33OkYHl1gGMCJ7vaUX7S/rJxj/quvU366bN92pzb5Nqa8v1qb9/l8pl1bWjXYV83zLrxYKn9uYOuY6j937hPEVi+/bZAgAEq7wmpXd99gz5RV+du7rkFT1JUj6bV+uOdpVVJXXhZecEnBIA0J/Zx8zQ4WcuVG9Hr3o6euX7vqy1yvZm1b6zXWOmNujUDx0fdEwAQD9OeN+xmjx3gtqbO5TpzshaK+tb9Xam1d3arfnHz9KiU+cHHRMA0I/zPnuGKusq1LqjTblMXtZaeZ6vrtZu5TMFnf6RE1U/sS7omMCQwExyAMNedyGt61/6nVZ3virPvvFU1J93Pql3jVmivzr9VF16/Sd04z/9Qbu2tsr3fBlHqm6s0nv/7jxuzgHAEHbh354jN+Tq9h/fo47mTlkruSFH42eO0cev/qBmHTX9rU8CABh0juPo0us/qVRVmZbd9pTadrRLksKxiOYumaW//rePqrqRlUAAYCgqq0zq//ufy/STL/9Ka5avV+/2NklSLBnTCe87Vp/4p4sVjvzlWn0AgKFg0pzx+vIvPq+ffe0mbV23Xd1tPTKSyqqSetdnz9BFXzo/6IgYRNa3sqa0M7/tCJpJTpEcwLD301f+pBc6XlYqlFDU7ftHmrVWPcWMbtv+qOpiVTr1vCN0+BkL9eIja9Xe3KmyqqQOO3meYolowOkBAAfiOI4uuPRsnf6RE/T8w2uU7cmqdnyN5i2dJTfkvvUJAACBiSWi+utvf1Tv/cK5Wr3sJXmFoibOGa9piybTixwAhrjasdX62q+/oM1rturl5zfLdR3NPGqaxkxpCDoaAOAtzDximq798z9o7RMb1LypRZF4RAtPnKvymlTQ0YAhhSI5gGFta7pFz7W/pIQb3VMglyRjjFLhhFrzXbpr55M6uX6RwpGwDj99YYBpAQBvV7IiqaXnHxV0DADA21A7rkYnXbQk6BgAgLdh0twJmjR3QtAxAACHyHEczVs6S/OWzgo6CoJkfZW+J3mJzxcgepIDGNZWd76qnFdQ3O1/RnjSjWlHdreas22DnAwAAAAAAAAAAABDEUVyAMOab60OtFKjkZGs3atXOQAAAAAAAAAAwEhmfTsg29vxwx/+UJMnT1YsFtMxxxyjp5566oDH/+53v9Ps2bMVi8W0YMEC3XnnnW/rcw+EIjmAYW1yslGucZX3C/2OZ7ycKsJlqo9WDXIyAAAAAAAwGuWzBW3b2Kydm3bJ93loHwAAjG4333yzLr/8cl155ZVasWKFDjvsMJ111llqaWnp9/hly5bp4osv1qc+9Sk999xzuvDCC3XhhRdq1apVJc1FT3IAw9rs8omakhyjDd3bFHJCcs0bz/7kvII8eTql4XBF3tSvHAAAAAAAoNSy6ZzuuOERPfiHJ9XV2iPjGI2ZXK+zP3KcTnrPUTIHWgoPADCqWGu1bucuPbFxi9L5gsZUpnTy7KmqLksEHQ0jyRDpSf69731Pn/nMZ/SJT3xCkvSjH/1Id9xxh37+85/rq1/96j7HX3/99Tr77LP15S9/WZJ0zTXX6N5779UPfvAD/ehHP3pn+d+EIjmAYc0xjj43/UJ9e91Nasq0yTWOXOOqYIsykg6vmqV3j10adEwAAAAAADCC5XMFff/vf60VD61RKBxSPBmVtVZb1u/Qf1/5e+3a3qaL/vbsoGMCAIaAdL6gb9/xsB5/aZPyRU+SkWT1i0ef1d+ccozOWzQ76IgYIYoqSG9vdfQDn1NSV1fXXvuj0aii0eg+x+fzeT377LO64oor9uxzHEenn366li9f3u9nLF++XJdffvle+8466yzddttt7zD93iiSAxj2xifqddW8T+qhluf0+O4X1VvMqDFeo5PrF+u42gUKO1zqAAAAAADAwFl2x3N67uG1SlUlFY1F9uyPJaLq7ujVHTc8omPOOkwTZ44JMCUAYCj497sf04NrXlZZLKLKREzGGHm+r/berK6/53HVlCV07PSJQcfEMBaJRNTY2KjHmkrfx1uSysrKNGHChL32XXnllbrqqqv2OXb37t3yPE8NDQ177W9oaNC6dev6PX9TU1O/xzc1Nb2z4H+ByhGAEaE6Wq73TjhJ751wUtBRAAAAAADAKPPQrU/LSnsVyF9XVpFQa1OHlt3xHEVyABjlNu9u18PrXlEyGlYy+sbfGa7jqKYsrpauXv3myed1zLQJtOnA2xaLxfTqq68qn88PyPmttfv8+exvFvlQR5EcAAAAAAAAAN6B5s27FY2G+x0zxkhWat7WOsipAABDzdOvblM2X1R9eXKfMWOMkrGI1u7Ypd3dvaorLwsgIUaKWCymWCwWdAzV1tbKdV01Nzfvtb+5uVmNjY39vqexsfGQjn+7nJKeDQAAAAAAAABGmWRFQsWit99xKylZHh+8QACAISlX8GSM2e8scdcYWWuV9/b/dwownEQiER1xxBG6//779+zzfV/333+/lixZ0u97lixZstfxknTvvffu9/i3iyI5AAAAAAAAALwDS85ZpGLBk+f5+4zlMnmFQo6OPGV+AMkAAEPJxJpKGUn5/TxYlckXVB6PqrZs35nmwHB1+eWX66c//al++ctfau3atfrc5z6n3t5efeITn5AkXXLJJbriiiv2HP+FL3xBd911l7773e9q3bp1uuqqq/TMM8/osssuK2kullsHAAAAAAAAgHfglPcdrUf/+Iyat7QqVZVUJNa39HqmJ6t0d1YLjpupBUtnBJwSABC0Y6ZN0Niqcm1r61RdeVLOm2aU54ueCp6vcxbOUjRM+Q4jxwc+8AHt2rVL3/jGN9TU1KRFixbprrvuUkNDgyRpy5Ytcpw35nUvXbpUN910k77+9a/ra1/7mmbMmKHbbrtN8+eX9oFD/lcGAAAAAAAAAO9AdUOF/v6Hn9SPv36zNq3drp7OtKy1isYiOubshfrUle+TG3KDjgkACFgk5OrL556oK2+5Ty1dvYqFQwo5jrKFgnwrLZo0Vh84ZmHQMYGSu+yyy/Y7E/yhhx7aZ99FF12kiy66aEAzUSQHAAAAAAAAgHdo/PQGffOmy7Tu2Ve1ed0OuSFXc4+apvHTG4KOBgAYQhZNGqvvfug83frMaj2y/lUVfU9jKsv1rkVzdP7hc5SMRoKOCIwKFMkBAAAAAAAAoAQcx9Hco6Zp7lHTgo4CABjCpjfU6MvnnagvnHWc8sWiEpGIHMe89RsBlAxFcgAAAAAAAAAAAGCQRUKuIrTjAALhvPUhAAAAAAAA/3979x5bdX3/cfx1CrS0dG2RFsq1CITLEARUujK2cVNkZg5cuA0RpiIiUxDGLWwQMCiDCVsYIC6hLBmXyZzBhbsdRoN0ImmRSwEFK3cMdkDJoAi8f3/469FjT9vT0nP59DwfSbOdnm+/ffW7/p6/pt+WAgAAAABQOzhzk3zBggXq1auXEhISlJKSUuGxX375pVq0aCGPx6NLly6FZB8AAAAAAAAAAAAAIPI5c5P8xo0bGjp0qCZMmFDpsU899ZS6du0aglUAAAAAAAAAAAAAAJc4c5N83rx5evHFF9WlS5cKj1u5cqUuXbqk3/zmNyFaBgAAAAAAAAAAAABwRd1wD6hJhw8f1vz58/Wf//xHJ06cCOhtSkpKVFJS4n185cqVYM0DANQg+g0A7qLhAOAuGg4A7qLhAAB8w5nfJK9MSUmJRo4cqcWLF6tVq1YBv90rr7yi5ORk70vLli2DuBIAUFPoNwC4i4YDgLtoOAC4i4YDAPCNsN4knzlzpjweT4UvR44cCehcs2bNUqdOnfT4449XacOsWbN0+fJl78upU6eq86EAAEKMfgOAu2g4ALiLhgOAu2g4AADfCOs/tz516lSNHTu2wmPatGkT0Ln+/e9/68CBA/rHP/4hSTIzSVJqaqpmz56tefPm+X27uLg4xcXFBT4aABAR6DcAuIuGA4C7aDgAuIuGAwDwjbDeJE9LS1NaWlqNnOvNN9/UtWvXvI/37t2rJ598Uu+//77atm1bI+8DAAAAAAAAAAAAAOC2sN4kr4qTJ0+qqKhIJ0+e1K1bt5Sfny9JateunRITE8vcCL948aIkqVOnTkpJSQnxWgAAAAAAAAAAAABAJHLmJvmcOXP017/+1fu4e/fukqRdu3apT58+YVoFAAAAAAAAAAAAAHBJTLgHBGrNmjUyszIv5d0g79Onj8yM3yIHAAAAAAAAAAAAAHg5c5McAAAAAAAAAAAAAIA7xU1yAAAAAAAAAAAAAEDU4CY5AAAAAAAAAAAAACBqcJMcAAAAAAAAAAAAABA1uEkOAAAAAAAAAAAAAIgadcM9INKYmSTpypUrYV4CANVX2rDSpkUD+g2gtqDhAOCmaOy3RMMB1A40nIYDcFe0Nhx3jpvk31FcXCxJatmyZZiXAMCdKy4uVnJycrhnhAT9BlDb0HAAcFM09Vui4QBqFxoOAO6KtobjznmMH63wcfv2bZ09e1bf+9735PF4auScV65cUcuWLXXq1CklJSXVyDmDzcXNkpu7Xdwsubk7mjabmYqLi9WsWTPFxETHX9YIRr+l6Pq8CScXN0tu7nZxs+TmbhoeOL4G/4aLu13cLLm5m82hU53d0dhviYZ/m4u72Rw6Lu52cbNEw6uChn/Nxc2Sm7td3Cy5uTuaNkdrw3Hn+E3y74iJiVGLFi2Ccu6kpCRnYlTKxc2Sm7td3Cy5uTtaNkfbT80Fs99S9HzehJuLmyU3d7u4WXJzNw2vHF+Dl+Xibhc3S27uZnPoVHV3tPVbouH+uLibzaHj4m4XN0s0PBA03JeLmyU3d7u4WXJzd7RsjsaG487xIxUAAAAAAAAAAAAAgKjBTXIAAAAAAAAAAAAAQNTgJnkIxMXFae7cuYqLiwv3lIC5uFlyc7eLmyU3d7MZ1eHi/wZsDh0Xd7u4WXJzt4ubaxNXr7+Lu13cLLm5m82h4+ru2sLV6+/ibjaHjou7Xdwsubu7tnDx+ru4WXJzt4ubJTd3sxmonMfMLNwjAAAAAAAAAAAAAAAIBX6THAAAAAAAAAAAAAAQNbhJDgAAAAAAAAAAAACIGtwkBwAAAAAAAAAAAABEDW6SAwAAAAAAAAAAAACiBjfJa9Cjjz6qVq1aqX79+mratKlGjx6ts2fP+hzz8ccf60c/+pHq16+vli1batGiRWXOs3HjRnXs2FH169dXly5dtGXLlqBtLiws1FNPPaW7775b8fHxatu2rebOnasbN274HOPxeMq85ObmhmV3IJulyLvWkrRgwQL16tVLCQkJSklJ8XuMv2u9YcMGn2Peffdd9ejRQ3FxcWrXrp3WrFkT1s0nT57UI488ooSEBDVu3FjTpk3TzZs3w7bZn9atW5e5rgsXLvQ5JpDPmVBbvny5Wrdurfr16yszM1MffvhhuCfVWjSchlfExX4HupuGBw8NDx3XGu5ivwPdLUXWtZZoeDgbTr8RCBpOwyviYsNrQ78lGo7A0PDI2CxF1nUuRcNpeFXRcIScocYsWbLE9uzZY4WFhbZ7927LysqyrKws7/OXL1+2Jk2a2KhRo+zgwYO2fv16i4+Pt1WrVnmP2b17t9WpU8cWLVpkhw8ftt/+9rdWr149O3DgQFA2b9261caOHWvbt2+348eP26ZNm6xx48Y2depU7zGfffaZSbJ33nnHzp075325ceNGWHYHsjkSr7WZ2Zw5c2zJkiU2ZcoUS05O9nuMJMvOzva51teuXfM+f+LECUtISLApU6bY4cOHbdmyZVanTh3btm1bWDbfvHnT7rnnHhswYIDl5eXZli1bLDU11WbNmhW2zf5kZGTY/Pnzfa7r1atXvc8H8jkTahs2bLDY2FhbvXq1HTp0yMaNG2cpKSl24cKFsG2qzWg4Da+Ii/0OZDcNDx4aHlquNdzFfge6O9KutRkND2fD6TcCQcNpeEVcbHht6LcZDUdgaHhkbI6061yKhtPwqqDhCAdukgfRpk2bzOPxeP8f6IoVK6xhw4ZWUlLiPWbGjBnWoUMH7+Nhw4bZI4884nOezMxMGz9+fGhGm9miRYvs7rvv9j4u/cIgLy+v3LcJ9+7vbo70a52dnV3hFwZvvfVWuW87ffp069y5s8/rhg8fbgMHDqzBhWWVt3nLli0WExNj58+f975u5cqVlpSU5L3+4dr8bRkZGbZ06dJynw/kcybUevbsaRMnTvQ+vnXrljVr1sxeeeWVsG2KJjSchvvjYr/NaHg40PDwcrHhLvbbjIbT8IrRb1QHDafh/rjYcJf7bUbDUT00nO+j+EPDaXggaDjCgX9uPUiKioq0du1a9erVS/Xq1ZMk7dmzRz/+8Y8VGxvrPW7gwIE6evSo/vvf/3qPGTBggM+5Bg4cqD179oRs++XLl3XXXXeVef2jjz6qxo0bq3fv3nr77bd9ngv37u9uduVal2fixIlKTU1Vz549tXr1apmZ97lI271nzx516dJFTZo08dlz5coVHTp0yHtMJGxeuHChGjVqpO7du2vx4sU+/wxOIJ8zoXTjxg3t27fP57rFxMRowIABEfE5WtvRcBpeXS71W6LhwULDw8vVhrvYb4mG0/DK0W9UBQ2n4dXlUsNd6bdEw1E1NJzvo1QXDQ8OGg5UjpvkNWzGjBlq0KCBGjVqpJMnT2rTpk3e586fP+8TT0nex+fPn6/wmNLng+3TTz/VsmXLNH78eO/rEhMT9eqrr2rjxo3avHmzevfurcGDB/t8cRDO3f42u3CtyzN//ny98cYb2rlzp37xi1/oueee07Jly7zPl7f7ypUrunbtWqjn3tG1DuXmF154QRs2bNCuXbs0fvx4vfzyy5o+fbr3+UA+jlC6ePGibt26FZGfo7UZDQ/97trUcNf6XdGm0ucqOoaGl4+Gh4fLDXex3+XtjvRrXR4aHhz0G4Gi4aHdXN7uSL/W5XGt4S70W6LhCBwND//mSL/OFaHhwUHDgcBwk7wSM2fOlMfjqfDlyJEj3uOnTZumvLw87dixQ3Xq1NETTzzh85NPkbpbks6cOaOHH35YQ4cO1bhx47yvT01N1ZQpU5SZmakHHnhACxcu1OOPP67FixdH7OZQqs7uivzud7/TD3/4Q3Xv3l0zZszQ9OnTI+JaR6KqfBxTpkxRnz591LVrVz377LN69dVXtWzZMpWUlIT5o0Aw0XAaXtObKxKKfgdjd7jQcFTGxYa72O+a3h0qNDx86DcCQcNpeE1vrgjfRwkcDUcgaDjfR6np3RWh4YGj4UDNqxvuAZFu6tSpGjt2bIXHtGnTxvvfU1NTlZqaqvbt26tTp05q2bKlcnNzlZWVpfT0dF24cMHnbUsfp6ene//T3zGlzwdr99mzZ9W3b1/16tVLr7/+eqXnz8zM1M6dO72Pa2J3TW6O5GtdVZmZmXrppZdUUlKiuLi4cncnJSUpPj4+oHPW5Ob09HR9+OGHZfaUPlf6n3e62Z87+TgyMzN18+ZNFRYWqkOHDgF9zoRSamqq6tSpUyOfo9GMhvtHw6u3uaqC0W+Jhks0PFq42HAX+13TuyP1WlcVDS8f/UYgaHhZNLz6m6uK76OUj4YjEDS8LL6PUv3dVUXDy0fDgZrHTfJKpKWlKS0trVpve/v2bUny/nROVlaWZs+era+++sr7d1l27typDh06qGHDht5jcnJyNHnyZO95du7cqaysrKDtPnPmjPr27av77rtP2dnZiomp/B8YyM/PV9OmTb2Pa2J3TW6O1GtdHfn5+WrYsKHi4uIkfb17y5YtPscE81pXJisrSwsWLNAXX3yhxo0be/ckJSXp+9//fo1t9udOPo78/HzFxMR4NwfyORNKsbGxuu+++5STk6PBgwdL+ropOTk5+vWvfx3yPa6i4f7R8Kpvro5g9Fui4RINjxYuNtzFftf07ki81tVBw8tHvxEIGl4WDa/e5urg+yjlo+EIBA0vi++jVG93ddDw8tFwIAgMNSI3N9eWLVtmeXl5VlhYaDk5OdarVy9r27atXb9+3czMLl26ZE2aNLHRo0fbwYMHbcOGDZaQkGCrVq3ynmf37t1Wt25d+8Mf/mAFBQU2d+5cq1evnh04cCAou0+fPm3t2rWz/v372+nTp+3cuXPel1Jr1qyxdevWWUFBgRUUFNiCBQssJibGVq9eHZbdgWyOxGttZvb5559bXl6ezZs3zxITEy0vL8/y8vKsuLjYzMzefvtt+8tf/mIHDhywTz75xFasWGEJCQk2Z84c7zlOnDhhCQkJNm3aNCsoKLDly5dbnTp1bNu2bWHZfPPmTbvnnnvsoYcesvz8fNu2bZulpaXZrFmzwrb5uz744ANbunSp5efn2/Hjx+1vf/ubpaWl2RNPPOE9JpDPmVDbsGGDxcXF2Zo1a+zw4cP2zDPPWEpKip0/fz5sm2orGk7DK+NivwPZTcODh4aHjosNd7Hfge6OtGttRsPD1XD6jUDQcBpeGRcb7nq/zWg4AkPDI2dzpF3nUjSchlcFDUc4cJO8hnz88cfWt29fu+uuuywuLs5at25tzz77rJ0+fdrnuP3791vv3r0tLi7OmjdvbgsXLixzrjfeeMPat29vsbGx1rlzZ9u8eXPQdmdnZ5skvy+l1qxZY506dbKEhARLSkqynj172saNG8O2O5DNZpF3rc3MxowZ43f3rl27zMxs69at1q1bN0tMTLQGDRrYvffea6+99prdunXL5zy7du2ybt26WWxsrLVp08ays7PDttnMrLCw0AYNGmTx8fGWmppqU6dOta+++ipsm79r3759lpmZacnJyVa/fn3r1KmTvfzyy94v2EsF8jkTasuWLbNWrVpZbGys9ezZ03Jzc8M9qVai4TS8Mi72O5DdZjQ8mGh4aLjYcBf7Hehus8i61mY0PFwNp98IBA2n4ZVxseGu99uMhiMwNDxyNptF1nUuRcNpeFXRcISax8zM32+YAwAAAAAAAAAAAABQ21T+BzcAAAAAAAAAAAAAAKgluEkOAAAAAAAAAAAAAIga3CQHAAAAAAAAAAAAAEQNbpIDAAAAAAAAAAAAAKIGN8kBAAAAAAAAAAAAAFGDm+QAAAAAAAAAAAAAgKjBTXIAAAAAAAAAAAAAQNTgJjkAAAAAAAAAAAAAIGpwkxz4f61bt9Yf//jHOz7mTq1Zs0YpKSlBfR8AUJvQbwBwFw0HAHfRcABwFw0HAG6SIwqcOnVKTz75pJo1a6bY2FhlZGRo0qRJ+vLLL6t8rr179+qZZ56psW3+vtAYPny4jh07VmPvw5/r169r7Nix6tKli+rWravBgwcH9f0BQHXQ77LoNwBX0PCyaDgAV9Dwsmg4AFfQ8LJoOIDycJMctdqJEyd0//3365NPPtH69ev16aef6rXXXlNOTo6ysrJUVFRUpfOlpaUpISEhSGu/Fh8fr8aNGwf1fdy6dUvx8fF64YUXNGDAgKC+LwCoDvrtH/0G4AIa7h8NB+ACGu4fDQfgAhruHw0HUB5ukqNWmzhxomJjY7Vjxw795Cc/UatWrTRo0CC98847OnPmjGbPnu1zfHFxsUaOHKkGDRqoefPmWr58uc/z3/1pt0uXLunpp59WWlqakpKS1K9fP+3fv9/nbf71r3/pgQceUP369ZWamqohQ4ZIkvr06aPPP/9cL774ojwejzwejyTff2Lm2LFj8ng8OnLkiM85ly5dqrZt23ofHzx4UIMGDVJiYqKaNGmi0aNH6+LFi+VelwYNGmjlypUaN26c0tPTA7uYABBC9Ns/+g3ABTTcPxoOwAU03D8aDsAFNNw/Gg6gPNwkR61VVFSk7du367nnnlN8fLzPc+np6Ro1apT+/ve/y8y8r1+8eLHuvfde5eXlaebMmZo0aZJ27txZ7vsYOnSovvjiC23dulX79u1Tjx491L9/f+9P5W3evFlDhgzRT3/6U+Xl5SknJ0c9e/aUJP3zn/9UixYtNH/+fJ07d07nzp0rc/727dvr/vvv19q1a31ev3btWv3yl7+U9PUXJ/369VP37t310Ucfadu2bbpw4YKGDRtWvQsHAGFGv+k3AHfRcBoOwF00nIYDcBcNp+EAqsGAWio3N9ck2VtvveX3+SVLlpgku3DhgpmZZWRk2MMPP+xzzPDhw23QoEHexxkZGbZ06VIzM3v//fctKSnJrl+/7vM2bdu2tVWrVpmZWVZWlo0aNarcjd8+X6ns7GxLTk72Pl66dKm1bdvW+/jo0aMmyQoKCszM7KWXXrKHHnrI5xynTp0ySXb06NFy33epMWPG2M9//vNKjwOAUKHf9BuAu2g4DQfgLhpOwwG4i4bTcABVx2+So9azb/10XGWysrLKPC4oKPB77P79+3X16lU1atRIiYmJ3pfPPvtMx48flyTl5+erf//+1R8vacSIESosLFRubq6kr39yrkePHurYsaN3x65du3w2lD5XugMAXES/AcBdNBwA3EXDAcBdNBwAAlc33AOAYGnXrp08Ho8KCgq8f/vk2woKCtSwYUOlpaVV6/xXr15V06ZN9e6775Z5rvTvqHz3n7apjvT0dPXr10/r1q3TD37wA61bt04TJkzw2fGzn/1Mv//978u8bdOmTe/4/QNAqNFv+g3AXTSchgNwFw2n4QDcRcNpOICq4zfJUWs1atRIDz74oFasWKFr1675PHf+/HmtXbtWw4cPl8fj8b6+9CfUvv24U6dOfs/fo0cPnT9/XnXr1lW7du18XlJTUyVJXbt2VU5OTrkbY2NjdevWrUo/ltK/GbNnzx6dOHFCI0aM8Nlx6NAhtW7dusyOBg0aVHpuAIg09Jt+A3AXDafhANxFw2k4AHfRcBoOoOq4SY5a7c9//rNKSko0cOBAvffeezp16pS2bdumBx98UM2bN9eCBQt8jt+9e7cWLVqkY8eOafny5dq4caMmTZrk99wDBgxQVlaWBg8erB07dqiwsFAffPCBZs+erY8++kiSNHfuXK1fv15z585VQUGBDhw44PNTbq1bt9Z7772nM2fO6OLFi+V+HI899piKi4s1YcIE9e3bV82aNfM+N3HiRBUVFWnkyJHau3evjh8/ru3bt+tXv/pVhV90HD58WPn5+SoqKtLly5eVn5+v/Pz8QC4rAAQd/abfANxFw2k4AHfRcBoOwF00nIYDqKKw/kV0IAQKCwttzJgx1qRJE6tXr561bNnSnn/+ebt48aLPcRkZGTZv3jwbOnSoJSQkWHp6uv3pT38qc8zSpUu9j69cuWLPP/+8NWvWzHvuUaNG2cmTJ73HvPnmm9atWzeLjY211NRUe+yxx7zP7dmzx7p27WpxcXFW+n+O2dnZlpycXObjGDZsmEmy1atXl3nu2LFjNmTIEEtJSbH4+Hjr2LGjTZ482W7fvl3udcnIyDBJZV4AIFLQb//oNwAX0HD/aDgAF9Bw/2g4ABfQcP9oOAB/PGZmQb4PD9QaTZs21UsvvaSnn3463FMAAFVAvwHAXTQcANxFwwHAXTQcQG1XN9wDABf873//0+7du3XhwgV17tw53HMAAAGi3wDgLhoOAO6i4QDgLhoOIFrwN8mBALz++usaMWKEJk+erKysrHDPAQAEiH4DgLtoOAC4i4YDgLtoOIBowT+3DgAAAAAAAAAAAACIGvwmOQAAAAAAAAAAAAAganCTHAAAAAAAAAAAAAAQNbhJDgAAAAAAAAAAAACIGtwkBwAAAAAAAAAAAABEDW6SAwAAAAAAAAAAAACiBjfJAQAAAAAAAAAAAABRg5vkAAAAAAAAAAAAAICowU1yAAAAAAAAAAAAAEDU+D+i7ucHw1PduwAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 2300x700 with 6 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from matplotlib.cm import ScalarMappable\n",
        "\n",
        "\n",
        "fig, axes = plt.subplots(1, 5, figsize=(23, 7), sharex=True, sharey=True)\n",
        "algos = [\"Sobol\", \"qNParEGO\", \"qEHVI\", \"qNEHVI\", \"qMPI\"]\n",
        "cm = plt.cm.get_cmap('viridis')\n",
        "\n",
        "batch_number = torch.cat(\n",
        "    [torch.zeros(2*(problem.dim+1)), torch.arange(1, N_BATCH+1).repeat(BATCH_SIZE, 1).t().reshape(-1)]\n",
        ").numpy()\n",
        "for i, train_obj in enumerate((train_obj_true_random, train_obj_true_qparego, train_obj_true_qehvi, train_obj_true_qnehvi, train_obj_true_qmpi)):\n",
        "    sc = axes[i].scatter(\n",
        "        train_obj[:, 0].cpu().numpy(), train_obj[:,1].cpu().numpy(), c=batch_number, alpha=0.8,\n",
        "    )\n",
        "    axes[i].set_title(algos[i])\n",
        "    axes[i].set_xlabel(\"Objective 1\")\n",
        "axes[0].set_ylabel(\"Objective 2\")\n",
        "norm = plt.Normalize(batch_number.min(), batch_number.max())\n",
        "sm =  ScalarMappable(norm=norm, cmap=cm)\n",
        "sm.set_array([])\n",
        "fig.subplots_adjust(right=0.9)\n",
        "cbar_ax = fig.add_axes([0.93, 0.15, 0.01, 0.7])\n",
        "cbar = fig.colorbar(sm, cax=cbar_ax)\n",
        "cbar.ax.set_title(\"Iteration\")"
      ]
    }
  ],
  "metadata": {
    "captumWidgetMessage": {},
    "dataExplorerConfig": {},
    "kernelspec": {
      "display_name": ".venv",
      "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.11.1"
    },
    "outputWidgetContext": {},
    "vscode": {
      "interpreter": {
        "hash": "d0d89edb180f9a014a8549f8e4186c509ca0c02c5f4c9da0e8aa0d2a082e25b9"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}