From 323bd17ad517926b84a921728052f9f229cd7414 Mon Sep 17 00:00:00 2001 From: Tristan Date: Sun, 5 Nov 2023 01:36:47 +0100 Subject: [PATCH] Estimation example 99% done --- estimation/estimation_with_mpc.ipynb | 805 +++++++++++++++++++++++---- 1 file changed, 682 insertions(+), 123 deletions(-) diff --git a/estimation/estimation_with_mpc.ipynb b/estimation/estimation_with_mpc.ipynb index 1309689..9eb48cd 100644 --- a/estimation/estimation_with_mpc.ipynb +++ b/estimation/estimation_with_mpc.ipynb @@ -8,7 +8,7 @@ "Copyright (c) 2010-2023, Delft University of Technology. All rights reserved. This file is part of the Tudat. Redistribution and use in source and binary forms, with or without modification, are permitted exclusively under the terms of the Modified BSD license. You should have received a copy of the license with this file. If not, please or visit: http://tudat.tudelft.nl/LICENSE.\n", "\n", "## Context\n", - "This example highlights a simple orbit estimation routine using real, angular observation data from the [Minor Planet Center](https://www.minorplanetcenter.net/) (MPC). We will estimate the initial state of [Ceres](https://en.wikipedia.org/wiki/Ceres_(dwarf_planet)) the largest body in the asteroid belt. We will use the Tudat BatchMPC interface to retrieve and process the data. For a more in depth explanation of this interface we recommend first checking out the [Retrieving observation data from the Minor Planet Centre](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/retrieving_mpc_observation_data.html) example." + "This example highlights a simple orbit estimation routine using real, angular observation data from the [Minor Planet Center](https://www.minorplanetcenter.net/) (MPC). We will estimate the initial state of [Eros](https://en.wikipedia.org/wiki/433_Eros) a near-Earth asteroid visited by the NEAR Shoemaker probe in 1998. We will use the Tudat BatchMPC interface to retrieve and process the data. For a more in depth explanation of this interface we recommend first checking out the [Retrieving observation data from the Minor Planet Centre](https://docs.tudat.space/en/latest/_src_getting_started/_src_examples/notebooks/estimation/retrieving_mpc_observation_data.html) example." ] }, { @@ -35,11 +35,15 @@ "# import MPC interface\n", "from tudatpy.data.mpc import BatchMPC\n", "\n", + "# import SBDB interface\n", + "from tudatpy.data.sbdb import SBDBquery\n", + "\n", "# other useful modules\n", "import numpy as np\n", - "import pandas as pd\n", "import datetime\n", - "import matplotlib.pyplot as plt" + "\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.lines import Line2D" ] }, { @@ -49,7 +53,7 @@ "## Preparing the environment and observations\n", "\n", "### Loading Spice Kernels.\n", - "We use SPICE kernels to retrieve the ephemerides the planets as well as to verify our results for Ceres. The ephemerides for Ceres and other asteroids are loaded in with the standard kernels." + "We use SPICE kernels to retrieve the ephemerides the planets as well as to verify our results for Eros. The ephemerides for Eros and other asteroids are loaded in with the `codes_300ast_20100725.bsp` kernel included with Tudat's standard kernel." ] }, { @@ -66,14 +70,88 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Retrieving the observations\n", - "We retrieve the observation data using the BatchMPC interface. By default all observation data is retrieved, even the first observation from Piazzi in 1801. We filter to only include data between January 2018 and July 2023." + "### Setting some constants\n", + "Let's setup some constants that are used throughout the tutorial. The MPC code for Eros is 433. We also set a start and end date for our observations, the number of iterations for our estimation, a timestep for our integrator and a 1 month buffer to avoid interpolation errors in our analysis.\n", + "\n", + "We use a spice kernel to get a guess for our initial state and to check our estimation afterwards. The default spice kernel `codes_300ast_20100725.bsp` contains many popular asteroids, however they are not all identified by name (433 Eros is `\"Eros\"` but 16 Psyche is `\"2000016\"` etc.). To ensure this example works dynamically, for any single MPC code as input we use the SDBD to retrieve the name and SPK-ID used for the spice kernel.\n", + "\n", + "For our frame origin we use the Solar System Barycentre. The data from MPC is presented in the J2000 reference frame, currently BatchMPC does not support conversion to other reference frames and as such we match it in our environment. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Direct inputs:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, + "outputs": [], + "source": [ + "target_mpc_code = 433\n", + "\n", + "observations_start = datetime.datetime(2018, 1, 1)\n", + "observations_end = datetime.datetime(2023, 7, 1)\n", + "\n", + "# number of iterations for our estimation\n", + "number_of_pod_iterations = 6\n", + "\n", + "# timestep of 20 hours for our estimation\n", + "timestep_global = 20 * 3600\n", + "\n", + "# 1 month time buffer used to avoid interpolation errors:\n", + "time_buffer = 1 * 31 * 86400\n", + "\n", + "# define the frame origin and orientation.\n", + "global_frame_origin = \"SSB\"\n", + "global_frame_orientation = \"J2000\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Derived inputs:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPK ID for 433 Eros is: Eros\n" + ] + } + ], + "source": [ + "target_sbdb = SBDBquery(target_mpc_code)\n", + "\n", + "mpc_codes = [target_mpc_code] # the BatchMPC interface requires a list.\n", + "target_spkid = target_sbdb.codes_300_spkid # the ID used by the\n", + "target_name = target_sbdb.shortname # the ID used by the\n", + "\n", + "print(f\"SPK ID for {target_name} is: {target_spkid}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Retrieving the observations\n", + "We retrieve the observation data using the BatchMPC interface. By default all observation data is retrieved, even the first observations from Witt in 1898. We filter to only include data between our start and end dates." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -82,24 +160,22 @@ "\n", " Batch Summary:\n", "1. Batch includes 1 minor planets:\n", - " ['1']\n", - "2. Batch includes 272 observations, including 117 observations from space telescopes\n", - "3. The observations range from 2018-01-20 10:01:17.183998 to 2023-06-14 13:23:15.993581\n", - " In seconds TDB since J2000: 569714546.3684946 to 740021065.178199\n", - " In Julian Days: 2458138.91756 to 2460110.057824\n", - "4. The batch contains observations from 27 observatories, including 1 space telescopes\n", + " ['433']\n", + "2. Batch includes 3095 observations, including 1733 observations from space telescopes\n", + "3. The observations range from 2018-05-01 03:22:18.336012 to 2023-06-27 00:37:43.680017\n", + " In seconds TDB since J2000: 578417007.5214744 to 741098332.8642726\n", + " In Julian Days: 2458239.64049 to 2460122.5262\n", + "4. The batch contains observations from 53 observatories, including 3 space telescopes\n", "\n" ] } ], "source": [ - "codes = [1]\n", - "\n", "batch = BatchMPC()\n", - "batch.get_observations(codes)\n", + "batch.get_observations(mpc_codes)\n", "batch.filter(\n", - " epoch_start=datetime.datetime(2018, 1, 1),\n", - " epoch_end=datetime.datetime(2023, 7, 1),\n", + " epoch_start=observations_start,\n", + " epoch_end=observations_end,\n", ")\n", "\n", "batch.summary()" @@ -114,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -122,20 +198,26 @@ "output_type": "stream", "text": [ "Summary of space telescopes in batch:\n", - " Code Name count\n", - "1225 C51 WISE 117.0\n", + " Code Name count\n", + "1225 C51 WISE 111.0\n", + "1231 C57 TESS 1620.0\n", + "1232 C59 Yangwang-1 2.0\n", "\n", "Initial and Final Observations by WISE:\n", - " number epochUTC RA DEC\n", - "6467 1 2018-04-03 11:44:59.711984 2.288533 0.539532\n", - "6724 1 2023-05-23 17:39:40.896011 3.138465 0.233569\n" + " number epochUTC RA DEC\n", + "10523 433 2018-07-25 00:09:44.063981 0.468337 0.388395\n", + "13536 433 2023-05-15 12:31:37.344004 5.690128 -0.311711\n" ] } ], "source": [ "print(\"Summary of space telescopes in batch:\")\n", "print(batch.observatories_table(only_space_telescopes=True))\n", - "obs_by_WISE = batch.table.query(\"observatory == 'C51'\").loc[:, [\"number\", \"epochUTC\", \"RA\", \"DEC\"]].iloc[[0, -1]]\n", + "obs_by_WISE = (\n", + " batch.table.query(\"observatory == 'C51'\")\n", + " .loc[:, [\"number\", \"epochUTC\", \"RA\", \"DEC\"]]\n", + " .iloc[[0, -1]]\n", + ")\n", "\n", "print(\"\\nInitial and Final Observations by WISE:\")\n", "print(obs_by_WISE)" @@ -145,7 +227,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "While the observations from WISE appear to be useful, including them requires setting up the dynamics for the WISE spacecraft which is too advanced for this tutorial and its observations will be excluded automatically later on in this example. The observations can also be filtered out explicitly by excluding the observatories with the .filter() method. Note that all the observations are given in an angular format, Right Ascension (RA) and Declination (DEC)." + "While the observations from WISE appear to be useful, including them requires setting up the dynamics for the WISE spacecraft which is too advanced for this tutorial and its observations will be excluded later on in this example. The observations can also be filtered out explicitly by excluding the observatories with the .filter() method, specifying their codes (C57 etc.). Note that all the observations are given in an angular format, Right Ascension (RA) and Declination (DEC)." ] }, { @@ -153,14 +235,14 @@ "metadata": {}, "source": [ "### Set up the environment\n", - "We now set up the environment, including the bodies to use, the reference frame and frame origin. The epherides for all major planets as well as the Earth's Moon are included retrieved using spice. For our frame origin we use the Solar System Barycentre. The data from MPC is presented in the J2000 reference frame, currently BatchMPC does not support conversion to other reference frames and as such we match it in our environment. \n", + "We now set up the environment, including the bodies to use, the reference frame and frame origin. The epherides for all major planets as well as the Earth's Moon are retrieved using spice. \n", "\n", - "BatchMPC will automatically generate the body object for Ceres, but we still need to specify the bodies to propagate and their central bodies. We can retrieve the list from the BatchMPC object." + "BatchMPC will automatically generate the body object for Eros, but we still need to specify the bodies to propagate and their central bodies. We can retrieve the list from the BatchMPC object." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -178,19 +260,16 @@ " \"Neptune\",\n", "]\n", "\n", - "# define the frame origin and orientation. \n", - "global_frame_origin = \"SSB\"\n", - "global_frame_orientation = \"J2000\"\n", + "# Create system of bodies\n", "body_settings = environment_setup.get_default_body_settings(\n", " bodies_to_create, global_frame_origin, global_frame_orientation\n", ")\n", "\n", - "# Create system of bodies\n", "bodies = environment_setup.create_system_of_bodies(body_settings)\n", "\n", - "# Retrieve Ceres' body name from BatchMPC and set its centre\n", + "# Retrieve Eros' body name from BatchMPC and set its centre to enable its propapgation\n", "bodies_to_propagate = batch.MPC_objects\n", - "central_bodies = [\"SSB\"]" + "central_bodies = [global_frame_origin]" ] }, { @@ -198,26 +277,38 @@ "metadata": {}, "source": [ "### Convert the observations to Tudat\n", - "Now that our system of bodies is ready we can retrieve the observation collection and links from the observations batch. With the links we just need to define the observation settings, this is where you would also add corrections. For the purpose of this example, we will keep it simple and use the plain angular position settings, which can process observations with Right Ascension and Declination. We can also retrieve the times for the first and final observations from the batch object." + "Now that our system of bodies is ready we can retrieve the observation collection from the observations batch using the `to_tudat()` method. Note that by setting the included_satellites to `None`, space telescope observations are filtered out. From the observation collection we can also retrieve observation links. We use the links to define our observations settings this is where you would also add bias settings. For the purpose of this example, we will keep it simple and use the plain angular position settings, which can process observations with Right Ascension and Declination. We can also retrieve the times for the first and final observations from the batch object in seconds since J2000 TDB, which is what tudat uses internally. We here add our buffer, set previously, to avoid interpolation errors down the line." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Transform the MPC observations into a tudat compatible format.\n", - "observation_collection, links = batch.to_tudat(bodies=bodies)\n", + "# note that we explicitly exlude all satellite observations in this step by setting included satellites to None.\n", + "observation_collection = batch.to_tudat(bodies=bodies, included_satellites=None)\n", "\n", "# set create angular_position settings for each link in the list.\n", "observation_settings_list = list()\n", - "for link in list(links.values()):\n", - " observation_settings_list.append(observation.angular_position(link))\n", + "link_list = list(\n", + " observation_collection.get_link_definitions_for_observables(\n", + " observable_type=observation.angular_position_type\n", + " )\n", + ")\n", + "\n", + "for link in link_list:\n", + " # add optional bias settings here\n", + " observation_settings_list.append(\n", + " observation.angular_position(link, bias_settings=None)\n", + " )\n", + "# Retrieve the first and final observation epochs and add the buffer\n", + "epoch_start_nobuffer = batch.epoch_start\n", + "epoch_end_nobuffer = batch.epoch_end\n", "\n", - "# Retrieve the first and final observation epochs\n", - "epoch_start = batch.epoch_start\n", - "epoch_end = batch.epoch_end" + "epoch_start_buffer = epoch_start_nobuffer - time_buffer\n", + "epoch_end_buffer = epoch_end_nobuffer + time_buffer" ] }, { @@ -225,12 +316,12 @@ "metadata": {}, "source": [ "### Creating the acceleration settings\n", - "Ceres will be propagated and as such we need to define the settings of the forces acting on it. We will include point mass gravity accelerations for each of the bodies defined before, as well as Schhwarzschild relativistic corrections for the sun. With these accelerations we can generate our acceleration model for the propagation. A more realistic acceleration model will yield better results but this is outside the scope of this example." + "Eros will be propagated and as such we need to define the settings of the forces acting on it. We will include point mass gravity accelerations for each of the bodies defined before, as well as Schhwarzschild relativistic corrections for the Sun. With these accelerations we can generate our acceleration model for the propagation. A more realistic acceleration model will yield better results but this is outside the scope of this example. " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -238,7 +329,7 @@ "accelerations = {\n", " \"Sun\": [\n", " propagation_setup.acceleration.point_mass_gravity(),\n", - " propagation_setup.acceleration.relativistic_correction(use_schwarzschild = True),\n", + " propagation_setup.acceleration.relativistic_correction(use_schwarzschild=True),\n", " ],\n", " \"Mercury\": [propagation_setup.acceleration.point_mass_gravity()],\n", " \"Venus\": [propagation_setup.acceleration.point_mass_gravity()],\n", @@ -266,37 +357,46 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Retrieving an initial guess for Ceres' position\n", - "We use the SPICE ephemeris to retrieve a 'benchmark' initial state for Ceres at the final epoch. We can also use this initial state as our initial guess for the estimation. To ensure a working estimation we add a random uniform offset of +/- 1 million kilometers for the position and 100 m/s for the velocity. We take the final time to retrieve the 'latest' position." + "### Retrieving an initial guess for Eros' position\n", + "We use the SPICE ephemeris to retrieve a 'benchmark' initial state for Eros at the first epoch. We can also use this initial state as our initial guess for the estimation. We add a random uniform offset of +/- 1 million kilometers for the position and 100 m/s for the velocity. We take the final time to retrieve the 'latest' position. Adding this random offset should not have a strong influence on the final results, it is added in to keep the tutorial representative. In real-world cases we might not have such a good initial guess." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Error between initial state and initial guess:\n", - "[7.98046732e+08 8.62237736e+08 8.50100872e+08 5.27311579e+01\n", - " 5.32961124e+01 1.28071015e-01]\n" + "Error between the real initial state and our initial guess:\n", + "[-3.78859469e+08 5.60837941e+08 -5.28780595e+08 8.82288517e+01\n", + " 1.78014500e+01 -3.83983190e+01]\n" ] } ], "source": [ "# benchmark state for later comparison retrieved from SPICE\n", - "initial_states = spice.get_body_cartesian_state_at_epoch(\"Ceres\", \"SSB\", \"J2000\", \"NONE\", epoch_end)\n", + "initial_states = spice.get_body_cartesian_state_at_epoch(\n", + " target_spkid,\n", + " global_frame_origin,\n", + " global_frame_orientation,\n", + " \"NONE\",\n", + " epoch_start_buffer,\n", + ")\n", "\n", "# Add random offset for initial guess\n", "np.random.seed = 1\n", "\n", + "initial_position_offset = 1e6 * 1000\n", + "initial_velocity_offset = 100\n", + "\n", "initial_guess = initial_states.copy()\n", - "initial_guess[0:3] += (2*np.random.rand(3) - 1) * (1e6 * 1000)\n", - "initial_guess[3:6] += (2*np.random.rand(3) - 1) * 100\n", + "initial_guess[0:3] += (2 * np.random.rand(3) - 1) * initial_position_offset\n", + "initial_guess[3:6] += (2 * np.random.rand(3) - 1) * initial_velocity_offset\n", "\n", - "print(\"Error between initial state and initial guess:\")\n", + "print(\"Error between the real initial state and our initial guess:\")\n", "print(initial_guess - initial_states)" ] }, @@ -305,25 +405,28 @@ "metadata": {}, "source": [ "### Finalising the propagation setup\n", - "In this example we set up the propagation to run in reverse. We set the timestep to minus 20 hours. For the integrator we use the fixed timestep RKF-7(8) setting our initial time to the time of the batch's final observation. We then set the termination to stop at the time of the batch's oldest observation. These two settings are then the final pieces to create our propagation settings. " + "For the integrator we use the fixed timestep RKF-7(8) setting our initial time to the time of the batch's final observation - buffer. We then set the termination to stop at the time of the batch's oldest observation plus buffer. These two settings are then the final pieces to create our propagation settings. " ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "# timestep of 20 hours\n", - "dt = -(20 * 3600)\n", - "\n", "# Create numerical integrator settings\n", "integrator_settings = propagation_setup.integrator.runge_kutta_variable_step_size(\n", - " epoch_end, dt, propagation_setup.integrator.rkf_78, dt, dt, 1.0, 1.0\n", + " epoch_start_buffer,\n", + " timestep_global,\n", + " propagation_setup.integrator.rkf_78,\n", + " timestep_global,\n", + " timestep_global,\n", + " 1.0,\n", + " 1.0,\n", ")\n", "\n", "# Terminate at the time of oldest observation\n", - "termination_condition = propagation_setup.propagator.time_termination(epoch_start)\n", + "termination_condition = propagation_setup.propagator.time_termination(epoch_end_buffer)\n", "\n", "\n", "# Create propagation settings\n", @@ -332,7 +435,7 @@ " acceleration_models=acceleration_models,\n", " bodies_to_integrate=bodies_to_propagate,\n", " initial_states=initial_guess,\n", - " initial_time=epoch_end,\n", + " initial_time=epoch_start_buffer,\n", " integrator_settings=integrator_settings,\n", " termination_settings=termination_condition,\n", ")" @@ -345,12 +448,12 @@ "## Setting Up the estimation\n", "With the observation collection, the environment and propagations settings ready we can now begin setting up our estimation. \n", "\n", - "In this example we will simply estimate the position of Ceres and as such only include an initial states parameter." + "In this example we will simply estimate the position of Eros and as such only include an initial states parameter." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -369,12 +472,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The `Estimator` object collects the environment, observation settings and propagation settings. We also create an `EstimationInput` object and provide it our observation collection retrieved from `.to_tudat()` as well as setting the maximum iteration steps to 6." + "The `Estimator` object collects the environment, observation settings and propagation settings. We also create an `EstimationInput` object and provide it our observation collection retrieved from `.to_tudat()`. Our maximum iterations steps was previously set to 6." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -384,15 +487,15 @@ " estimated_parameters=parameters_to_estimate,\n", " observation_settings=observation_settings_list,\n", " propagator_settings=propagator_settings,\n", - " integrate_on_creation=True, \n", + " integrate_on_creation=True,\n", ")\n", "\n", "# provide the observation collection as input, and limit number of iterations for estimation.\n", "pod_input = estimation.EstimationInput(\n", " observations_and_times=observation_collection,\n", " convergence_checker=estimation.estimation_convergence_checker(\n", - " maximum_iterations=4,\n", - " )\n", + " maximum_iterations=number_of_pod_iterations,\n", + " ),\n", ")\n", "\n", "# Set methodological options\n", @@ -403,34 +506,40 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Performing the estimation and analysing results\n", + "## Performing the estimation\n", "\n", "With everything set up we can now perform the estimation. " ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Calculating residuals and partials 310\n", - "Parameter update-1.08327e+09 -7.78785e+08 -8.4091e+08 -63.339 -57.7383 22.0243\n", - "Current residual: 0.0423254\n", - "Calculating residuals and partials 310\n", - "Parameter update 2.85268e+08 -8.3927e+07 -9.21733e+06 10.6255 4.42586 -22.1284\n", - "Current residual: 0.000974167\n", - "Calculating residuals and partials 310\n", - "Parameter update -145925 115769 -22324.8 -0.0121336 0.0209935 -0.0126181\n", - "Current residual: 8.07591e-06\n", - "Calculating residuals and partials 310\n", - "Parameter update 3.77798 2.24511 -0.886078 1.31622e-07 7.26865e-08 -4.2434e-07\n", - "Current residual: 4.11982e-06\n", + "Calculating residuals and partials 2724\n", + "Current residual: 0.0228631\n", + "Parameter update 3.43463e+08 -6.32367e+08 5.81376e+08 -89.308 -18.473 39.1299\n", + "Calculating residuals and partials 2724\n", + "Current residual: 0.000935478\n", + "Parameter update 3.53284e+07 7.14645e+07 -5.25227e+07 1.08415 0.670775 -0.732472\n", + "Calculating residuals and partials 2724\n", + "Current residual: 2.233e-06\n", + "Parameter update -1.67755 50452.1 -120381 -0.000737334 -0.00361628 0.00205047\n", + "Calculating residuals and partials 2724\n", + "Current residual: 1.78958e-06\n", + "Parameter update -0.043044 0.00605575 0.110483 6.7061e-09 -4.26772e-09 -3.99199e-09\n", + "Calculating residuals and partials 2724\n", + "Current residual: 1.78958e-06\n", + "Parameter update -0.00780409 -0.00347095 -0.00244698 4.71677e-10 -4.14827e-10 -1.7473e-10\n", + "Calculating residuals and partials 2724\n", + "Current residual: 1.78958e-06\n", "Maximum number of iterations reached\n", - "Final residual: 4.11982e-06\n" + "Parameter update 0.00717496 0.00170747 0.00162746 -4.77043e-10 3.73814e-10 1.11164e-10\n", + "Final residual: 1.78958e-06\n" ] } ], @@ -443,54 +552,62 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The estimator appears to converge within 4 steps. Lets check how close our initial and final guesses are compared to the benchmark state." + "The estimator appears to converge within ~4 steps. Lets check how close our initial guess and final estimate are compared to the benchmark initial state." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Ceres initial radial error: 1450173.78 km\n", - "Ceres final radial error: 374.87 km\n" + "433 Eros initial guess radial error to spice: 858884.52 km\n", + "433 Eros final radial error to spice: 83.92 km\n" ] } ], "source": [ - "# retrieve the final estimated state.\n", + "# retrieve the estimated initial state.\n", "results_final = pod_output.parameter_history[:, -1]\n", "\n", "vector_error_initial = (np.array(initial_guess) - initial_states)[0:3]\n", - "error_magnitude_initial = np.sqrt(np.square(vector_error_initial).sum())/1000\n", + "error_magnitude_initial = np.sqrt(np.square(vector_error_initial).sum()) / 1000\n", "\n", "vector_error_final = (np.array(results_final) - initial_states)[0:3]\n", - "error_magnitude_final = np.sqrt(np.square(vector_error_final).sum())/1000\n", + "error_magnitude_final = np.sqrt(np.square(vector_error_final).sum()) / 1000\n", "\n", - "print(f\"Ceres initial radial error: {round(error_magnitude_initial, 2)} km\")\n", - "print(f\"Ceres final radial error: {round(error_magnitude_final, 2)} km\")" + "print(\n", + " f\"{target_name} initial guess radial error to spice: {round(error_magnitude_initial, 2)} km\"\n", + ")\n", + "print(\n", + " f\"{target_name} final radial error to spice: {round(error_magnitude_final, 2)} km\"\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Lets also take a look at the residuals over time:" + "## Visualising the results\n", + "Lets create some plots to interpret our estimation results.\n", + "\n", + "#### Change in residuals per iteration\n", + "We want to visualise the residuals, splitting them between Right Ascension and Declination. Internally, `concatentated_observations` orders the observations alternating RA, DEC, RA, DEC,... This allows us to map the colors accordingly by taking every other item in the `residual_history`/`concatentated_observations`, i.e. by slicing [::2]." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -500,28 +617,63 @@ "source": [ "residual_history = pod_output.residual_history\n", "\n", - "fig, axs = plt.subplots(2, 2, figsize=(9, 7), sharex=True, sharey=False)\n", + "# Number of columns and rows for our plot\n", + "number_of_columns = 2\n", + "\n", + "number_of_rows = (\n", + " int(number_of_pod_iterations / number_of_columns)\n", + " if number_of_pod_iterations % number_of_columns == 0\n", + " else int((number_of_pod_iterations + 1) / number_of_columns)\n", + ")\n", + "\n", + "fig, axs = plt.subplots(\n", + " number_of_rows,\n", + " number_of_columns,\n", + " figsize=(9, 3.5 * number_of_rows),\n", + " sharex=True,\n", + " sharey=False,\n", + ")\n", "\n", - "# a little trick to retrieve the UTC times from the batch, table retrieves all observations in pandas format\n", - "times = (\n", - " batch.table.query(\"observatory != 'C51'\")\n", - " .set_index(\"epochJ2000secondsTDB\")\n", - " .loc[observation_collection.concatenated_times]\n", - " .epochUTC\n", - " .sort_values()\n", - " .tolist()\n", + "# We cheat a little to get an approximate year out of our times (which are in seconds since J2000)\n", + "residual_times = (\n", + " np.array(observation_collection.concatenated_times) / (86400 * 365.25) + 2000\n", ")\n", "\n", + "\n", + "# plot the residuals, split between RA and DEC types\n", "for idx, ax in enumerate(fig.get_axes()):\n", " ax.grid()\n", - " ax.scatter(times, residual_history[:, idx], marker=\"+\", s=60)\n", + " # we take every second\n", + " ax.scatter(\n", + " residual_times[::2],\n", + " residual_history[\n", + " ::2,\n", + " idx,\n", + " ],\n", + " marker=\"+\",\n", + " s=60,\n", + " label=\"Right Ascension\",\n", + " )\n", + " ax.scatter(\n", + " residual_times[1::2],\n", + " residual_history[\n", + " 1::2,\n", + " idx,\n", + " ],\n", + " marker=\"+\",\n", + " s=60,\n", + " label=\"Declination\",\n", + " )\n", " ax.set_ylabel(\"Observation Residual [rad]\")\n", " ax.set_title(\"Iteration \" + str(idx + 1))\n", "\n", "plt.tight_layout()\n", "\n", - "axs[1, 0].set_xlabel(\"Year\")\n", - "axs[1, 1].set_xlabel(\"Year\")\n", + "# add the year label for the x-axis\n", + "for col in range(number_of_columns):\n", + " axs[int(number_of_rows - 1), col].set_xlabel(\"Year\")\n", + "\n", + "axs[0, 0].legend()\n", "\n", "plt.show()" ] @@ -530,17 +682,61 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Lets also look at the orbit error over time compared to spice:" + "As seen previously, the estimation converges around iteration 4." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Orbit error vs spice over time\n", + "Next, lets take a look at the error of the orbit over time, using spice as a reference.\n", + "\n", + "We saw in our previous graph, that there are two large gaps in observations, in 2022 and around Jan 2020. Lets collect those gaps and overlay them on to our error plot." ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Largest gap = 1.263 years\n", + "[(2019.7692566946516, 2020.46532939287), (2021.9181437117866, 2023.1810429863324)]\n" + ] + } + ], + "source": [ + "# lets get ranges for all gaps larger than 6 months:\n", + "gap_in_months = 6\n", + "\n", + "gaps = np.abs(np.diff(sorted(residual_times)))\n", + "num_gaps = (\n", + " gaps > (gap_in_months / 12)\n", + ").sum() # counts the number of gaps larger than 0.5 years\n", + "indices_of_largest_gaps = np.argsort(gaps)[-num_gaps:]\n", + "\n", + "# (start, end) for each of the gaps\n", + "gap_ranges = [\n", + " (sorted(residual_times)[idx - 1], sorted(residual_times)[idx + 1])\n", + " for idx in indices_of_largest_gaps\n", + "]\n", + "\n", + "print(f\"Largest gap = {round(max(gaps), 3)} years\")\n", + "print(gap_ranges)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -550,40 +746,55 @@ } ], "source": [ + "# Now lets plot the orbit error\n", "fig, ax = plt.subplots(1, 1, figsize=(9, 5))\n", "\n", + "# show areas where there are no observations:\n", + "for i, gap in enumerate(gap_ranges):\n", + " ax.axvspan(\n", + " xmin=gap[0],\n", + " xmax=gap[1],\n", + " color=\"red\",\n", + " alpha=0.1,\n", + " label=\"Large gap in observations\" if i == 0 else None,\n", + " )\n", + "\n", "spice_states = []\n", "estimation_states = []\n", "\n", - "# buffer to avoid interpolation at the edges of the estimated ephemeris\n", - "buffer = 86400 * 2\n", - "\n", - "times = np.linspace(epoch_start + buffer, epoch_end - buffer, 1000)\n", - "times_plot = times/(86400*365.25) + 2000 # approximate\n", + "# retrieve the states for a list of times.\n", + "times = np.linspace(epoch_start_nobuffer, epoch_end_nobuffer, 1000)\n", + "times_plot = times / (86400 * 365.25) + 2000 # approximate\n", "for time in times:\n", " # from spice\n", - " state_spice = spice.get_body_cartesian_state_at_epoch(\"Ceres\", central_bodies[0], \"J2000\", \"NONE\", time)\n", + " state_spice = spice.get_body_cartesian_state_at_epoch(\n", + " target_spkid, central_bodies[0], global_frame_orientation, \"NONE\", time\n", + " )\n", " spice_states.append(state_spice)\n", - " \n", + "\n", " # from estimation\n", - " state_est = bodies.get(\"1\").ephemeris.cartesian_state(time)\n", + " state_est = bodies.get(str(target_mpc_code)).ephemeris.cartesian_state(time)\n", " estimation_states.append(state_est)\n", "\n", "# Error in kilometers\n", "error = (np.array(spice_states) - np.array(estimation_states)) / 1000\n", "\n", + "# plot\n", "ax.plot(times_plot, error[:, 0], label=\"x\")\n", "ax.plot(times_plot, error[:, 1], label=\"y\")\n", "ax.plot(times_plot, error[:, 2], label=\"z\")\n", "\n", "ax.grid()\n", - "ax.legend(ncol=3)\n", + "ax.legend(ncol=1)\n", "\n", "plt.tight_layout()\n", "\n", "ax.set_ylabel(\"Carthesian Error [km]\")\n", "ax.set_xlabel(\"Year\")\n", "\n", + "fig.suptitle(f\"Error vs SPICE over time for {target_name}\")\n", + "fig.set_tight_layout(True)\n", + "\n", "plt.show()" ] }, @@ -591,7 +802,355 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The final result is within the radius of Ceres, but there is clearly plenty of room for improvement in both the dynamical model and the estimation settings. Consider for example adding weights and biases on observations and links as well as improved integrator settings and perturbations." + "Please note that a lack of observations in an area of time does not necessarily result in a bad fit in that area. Lets look at the observatories next." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Final residuals highlighted per observatory\n", + "This plot shows the final iteration of the residuals, highlighting the 10 observatories with the most observations." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# 10 observatories with most observations\n", + "num_observatories = 10\n", + "\n", + "finalresiduals = np.array(residual_history[:, -1])\n", + "# if you would like to check the iteration 1 residuals, use:\n", + "# finalresiduals = np.array(residual_history[:, 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# This piece of code collects the 10 largest observatories\n", + "observatory_names = (\n", + " batch.observatories_table(exclude_space_telescopes=True)\n", + " .sort_values(\"count\", ascending=False)\n", + " .iloc[0:num_observatories]\n", + " .set_index(\"Code\")\n", + ")\n", + "top_observatories = observatory_names.index.tolist()\n", + "\n", + "# This piece of code creates a `concatenated_receiving_observatories` map\n", + "# to identify the observatories by their MPC code instead of an internally used id\n", + "residuals_observatories = observation_collection.concatenated_link_definition_ids\n", + "unique_observatories = set(residuals_observatories)\n", + "\n", + "observatory_link_to_mpccode = {\n", + " idx: observation_collection.link_definition_ids[idx][\n", + " observation.LinkEndType.receiver\n", + " ].reference_point\n", + " for idx in unique_observatories\n", + "}\n", + "\n", + "# the resulting map (MPC code for each item in the residuals_history):\n", + "concatenated_receiving_observatories = np.array(\n", + " [observatory_link_to_mpccode[idx] for idx in residuals_observatories]\n", + ")\n", + "\n", + "# mask for the observatories not in top 10:\n", + "mask_not_top = [\n", + " (False if observatory in top_observatories else True)\n", + " for observatory in concatenated_receiving_observatories\n", + "]\n", + "\n", + "# get the number of observations by the other observatories\n", + "# (divide by two because the observations are concatenated RA,DEC in this list)\n", + "n_obs_not_top = int(sum(mask_not_top) / 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 1, figsize=(13, 9))\n", + "\n", + "# Plot remaining observatories first\n", + "# RA\n", + "axs[0].scatter(\n", + " residual_times[mask_not_top][::2],\n", + " finalresiduals[mask_not_top][::2],\n", + " marker=\".\",\n", + " s=30,\n", + " label=f\"{len(unique_observatories) - num_observatories} Other Observatories | {n_obs_not_top} obs\",\n", + " color=\"lightgrey\",\n", + ")\n", + "# DEC\n", + "axs[1].scatter(\n", + " residual_times[mask_not_top][1::2],\n", + " finalresiduals[mask_not_top][1::2],\n", + " marker=\".\",\n", + " s=30,\n", + " label=f\"{len(unique_observatories) - num_observatories} Other Observatories | {n_obs_not_top} obs\",\n", + " color=\"lightgrey\",\n", + ")\n", + "\n", + "# plots the highlighted top 10 observatories\n", + "for observatory in top_observatories:\n", + " name = f\"{observatory} | {observatory_names.loc[observatory].Name} | {int(observatory_names.loc[observatory]['count'])} obs\"\n", + " axs[0].scatter(\n", + " residual_times[concatenated_receiving_observatories == observatory][::2],\n", + " finalresiduals[concatenated_receiving_observatories == observatory][::2],\n", + " marker=\".\",\n", + " s=30,\n", + " label=name,\n", + " zorder=100,\n", + " )\n", + " axs[1].scatter(\n", + " residual_times[concatenated_receiving_observatories == observatory][1::2],\n", + " finalresiduals[concatenated_receiving_observatories == observatory][1::2],\n", + " marker=\".\",\n", + " s=30,\n", + " label=name,\n", + " zorder=100,\n", + " )\n", + "\n", + "\n", + "axs[1].legend(ncols=3, loc=\"upper center\", bbox_to_anchor=(0.47, -0.15))\n", + "\n", + "for ax in fig.get_axes():\n", + " ax.grid()\n", + " ax.set_ylabel(\"Observation Residual [rad]\")\n", + " ax.set_xlabel(\"Year\")\n", + " # this step hides a few outliers (~3 observations)\n", + " ax.set_ylim(-1.5e-5, 1.5e-5)\n", + "\n", + "axs[0].set_title(\"Right Ascension\")\n", + "axs[1].set_title(\"Declination\")\n", + "\n", + "fig.suptitle(f\"Final Iteration residuals for {target_name}\")\n", + "fig.set_tight_layout(True)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Residual Boxplots per observatory\n", + "Let's visualise these residuals as boxplots as well, again splitting for right ascension and declination. Note that some low level Matplotlib is used for this plot. Consider using the [seaborn boxplot](https://seaborn.pydata.org/generated/seaborn.boxplot.html) implementation if this format is relevant to your use case." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_observatories = 6\n", + "\n", + "data_per_observatory_list_RA = []\n", + "data_per_observatory_list_DEC = []\n", + "names = []\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(10, 1.2 * num_observatories))\n", + "\n", + "# we retrieve the observatory names again\n", + "observatory_names_box = (\n", + " batch.observatories_table(exclude_space_telescopes=True)\n", + " .set_index(\"Code\")\n", + " .sort_values(\"count\", ascending=False)\n", + " .iloc[0:num_observatories]\n", + ")\n", + "\n", + "top_observatories_box = observatory_names_box.index.tolist()\n", + "\n", + "# retrieve the data for RA and DEC seperately\n", + "for observatory in top_observatories_box[::-1]:\n", + " name = f\"{observatory} | {observatory_names_box.loc[observatory].Name} | {int(observatory_names_box.loc[observatory]['count'])} obs\"\n", + " names.append(name)\n", + " data_per_observatory_list_RA.append(\n", + " finalresiduals[concatenated_receiving_observatories == observatory][::2]\n", + " )\n", + "\n", + " data_per_observatory_list_DEC.append(\n", + " finalresiduals[concatenated_receiving_observatories == observatory][1::2]\n", + " )\n", + "\n", + "# positioning the boxes\n", + "pos = (np.arange(0, len(top_observatories_box)) + 1) * 10\n", + "widths = 2.8\n", + "offset = 1.6\n", + "\n", + "# box colors\n", + "RA_color = \"tab:blue\"\n", + "DEC_color = \"tab:orange\"\n", + "\n", + "# boxes for RA and DEC\n", + "RAplots = ax.boxplot(\n", + " x=data_per_observatory_list_RA,\n", + " vert=False,\n", + " positions=pos + offset,\n", + " widths=widths,\n", + " patch_artist=False,\n", + " capprops=dict(color=RA_color),\n", + " whiskerprops=dict(color=RA_color),\n", + " flierprops=dict(color=RA_color, markeredgecolor=RA_color),\n", + " medianprops=dict(color=RA_color),\n", + ")\n", + "DECplots = ax.boxplot(\n", + " x=data_per_observatory_list_DEC,\n", + " vert=False,\n", + " positions=pos - offset,\n", + " widths=widths,\n", + " patch_artist=False,\n", + " capprops=dict(color=DEC_color),\n", + " whiskerprops=dict(color=DEC_color),\n", + " flierprops=dict(color=DEC_color, markeredgecolor=DEC_color),\n", + " medianprops=dict(color=DEC_color),\n", + ")\n", + "# custom ticks\n", + "ax.set_yticks(ticks=pos, labels=names)\n", + "\n", + "# custom legend\n", + "place_holder_lines = [\n", + " Line2D([0], [0], color=RA_color, lw=4),\n", + " Line2D([0], [0], color=DEC_color, lw=4),\n", + "]\n", + "ax.legend(place_holder_lines, [\"Right Ascension\", \"Declination\"])\n", + "\n", + "ax.grid()\n", + "ax.set_xlabel(\"Observation Residual [rad]\")\n", + "\n", + "fig.suptitle(\n", + " f\"Residual boxplots of the {num_observatories} observatories with the most observations for {target_name}\"\n", + ")\n", + "\n", + "# reducing whitespace\n", + "ax.set_ylim(10 - 4, int(len(top_observatories_box) * 10) + 4)\n", + "\n", + "fig.set_tight_layout(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Histograms per observatory\n", + "Finally, lets get the residual histogram for the top 6 observatories, splitting again for right ascension and declination." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAN2CAYAAABAU5A9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1gUx/8H8PcCx9ERkC4CKsUCWLA3EMEeW6zRiMbYMMYWa1SwYYu9pahYIxoRO4oK2A0aib1EsYsdUZB68/uD792P4w64Pe6AOz+v5+HR252d/ezc7s7N7uwsxxhjIIQQQgghhBCiVXTKOwBCCCGEEEIIIapHjT1CCCGEEEII0ULU2COEEEIIIYQQLUSNPUIIIYQQQgjRQtTYI4QQQgghhBAtRI09QgghhBBCCNFC1NgjhBBCCCGEEC1EjT1CCCGEEEII0ULU2COEEEIIIYQQLUSNPSVERESA4zi5fxMnTsTDhw/BcRwiIiLUGkdwcDBcXFzUug5F8dnm0NBQcBxXIeKJj48Hx3H466+/SsxTmfJ+/vw5QkNDkZSUxGs5UrzIyEjUrl0bhoaG4DiuyPK9efMmQkND8fDhQ5l5fn5+qFOnjnoD/R/GGDZt2oRGjRrB2NgYZmZmqF+/Pvbt26eydZTl9pSHjIwMhIaGIj4+Xi35i8/r8vaVisbPzw9+fn6Sz8WVjfh8++bNG6XWtWPHDixfvlxmuvgcu2TJEqXy1VTz589HdHS0yvPlOA6jR49Web4VRXHn4or0W0aeEydOwNfXF8bGxuA4Ti3ff1Fu3rwJoVAIjuNw6dIlqXnHjx9HYGAgHBwcIBQKYWNjgzZt2uDw4cMy+UyfPh316tWDpaUlDAwMUK1aNQwbNgyPHj1SKI6ifvNyHIfg4GBVbCpRI73yDkCTbdq0CZ6enlLTHBwcYGtri/Pnz6N69erlFFnZs7e31/ptnjFjBn788Udeyzx//hxhYWFwcXFB3bp11RPYF+b169cYOHAg2rdvj7Vr10IoFMLd3V1u2ps3byIsLAx+fn7l+mNi5MiRiIiIwLhx4xAeHo7c3Fxcu3YNGRkZ5RaTpsnIyEBYWBgASDV0VKVTp044f/487O3tVZ63qq1du1bqszrLZseOHbh+/TrGjh2r0nw11fz58/H111+jW7du5R2KRinuXKxM3VpWGGPo3bs33N3dsX//fhgbG8PDw6NM1p2Xl4chQ4agcuXKeP78ucz8t2/fonbt2hg6dCjs7Ozw7t07rF+/Hp06dcLWrVsxYMAASdrU1FT069cPNWvWhKmpKW7evIm5c+di//79uHHjBqysrEqM5+uvv8aECRNkpltbW5duQ4naUWOvFOrUqQNfX1+585o0aVLG0fCTkZEBIyMjleUnFAor/DaXliY2ZBljyMzMhKGhYXmHojJ3795FTk4OBgwYgNatW5d3OCWKjo7Gr7/+isjISPTu3VsyvV27duUYlfrk5eUhNzcXQqGwvENRyOfPn2FgYABra2uN+dFSq1at8g6BaCnx8aDu3jcFVeS69fnz53j37h26d++OgIAAleSpaBkvW7YMT58+xeTJk+U2hvv06YM+ffpITevcuTNcXV3x22+/STX21qxZI5XOz88Prq6u6NixI/bt24chQ4aUGLetra1Sv/NU/XuT8EfdONVAXhdCcVeaGzduoF+/fjA3N4etrS2GDBmCDx8+SC2/Zs0atGrVCjY2NjA2NoaXlxcWLVqEnJwcpeIRd+86deoUmjVrBiMjI8mBnZaWhokTJ8LV1RX6+vpwdHTE2LFjkZ6eLpXH7t270bhxY5ibm8PIyAjVqlWTOjkU1W3y0KFDqFu3LoRCIVxdXeV2+SmuyyXHcQgNDZV8/u+//zB48GC4ubnByMgIjo6O6NKlC65du6ZU2Yjl5ORg+vTpcHBwgJmZGdq2bYs7d+5IpZHX1aS4comPj0fDhg0BAIMHD5Z0eSi4Pfv370fTpk1hZGQEU1NTBAYG4vz58zLx7du3D97e3hAKhahWrRpWrFghtzusuCvQ+vXrUbNmTQiFQmzevBkAEBYWhsaNG8PS0lLSjXDDhg1gjEnl4eLigs6dO+PgwYOoV68eDA0NUbNmTRw8eBBAfne3mjVrwtjYGI0aNZLpWvLgwQP07dtX0rXE1tYWAQEBCnVlLak8goOD0aJFCwD5FR3HcUXeyYiIiECvXr0AAP7+/pLyL7yfJSYmomXLlpLvb8GCBRCJRFJpFD1O5FmxYgVcXFykGnp8iEQiLFq0CJ6enpKuOt9++y2ePn0qN/3p06fRpEkTGBoawtHRETNmzEBeXp5UmnXr1sHHxwcmJiYwNTWFp6cnpk2bJpUmJSUFw4cPR5UqVaCvrw9XV1eEhYUhNzdXkkZ87C5atAhz586Fq6srhEIhdu3aBX19fcyYMUMmvtu3b4PjOKxcuRJA/p3aUaNGoVatWjAxMZF0RTp9+rTUesQNsbCwMLndh86cOYOAgACYmprCyMgIzZo1w6FDh6TWLe6qeezYMQwZMgTW1tYwMjJCVlZWkd04jx8/joCAAJiZmcHIyAjNmzfHiRMnpNK8fv0aw4YNg5OTE4RCIaytrdG8eXMcP35c7ncEADdu3ADHcdi9e7dk2uXLl8FxHGrXri2V9quvvkKDBg0knwt241SkbADg5cuXJdY9hfn5+eHQoUN49OiRVLetwpYuXQpXV1eYmJigadOmuHDhgkyaS5cu4auvvpJ0I6tXrx527dpV7PrF28dxHBYvXoyFCxfCxcUFhoaG8PPzk1z4mTJlChwcHGBubo7u3bvj1atXUnkoegxduXIFnTt3ho2NDYRCIRwcHNCpUydJOo7jkJ6ejs2bN0vKoqQ7qe/evcOoUaPg6OgIfX19VKtWDdOnT0dWVpbc9L/++ivc3d0hFApRq1Yt7Ny5U2p+RkaG5FxkYGAAS0tL+Pr64s8//+Rd3kUdD5GRkeA4TmY/B/LPHRzH4erVq5L19O3bV/K9uLi4oF+/flLdA0s6F8urWzMzMzF16lSpc25ISAhSU1Ol0onrq5iYGNSvXx+Ghobw9PTExo0blSq3gkJDQ1GlShUAwOTJk8FxnFScpT3nFOfevXuYOXMm1q5dCzMzs2LTFiQQCFCpUiXo6ZV8L0d83lAkraKCg4NhYmKCa9euISgoCKamppJGsqLHQkm/N4kSGOFt06ZNDAC7cOECy8nJkfpjjLHk5GQGgG3atEmyzKxZsxgA5uHhwWbOnMliY2PZ0qVLmVAoZIMHD5bKf9y4cWzdunUsJiaGnTx5ki1btoxVrlxZJt2gQYOYs7NzifG2bt2aWVpaMicnJ7Zq1SoWFxfHEhISWHp6Oqtbty6rXLkyW7p0KTt+/DhbsWIFMzc3Z23atGEikYgxxti5c+cYx3Gsb9++7PDhw+zkyZNs06ZNbODAgZJ1yNvm48ePM11dXdaiRQsWFRXFdu/ezRo2bMiqVq3KCu568pYVA8BmzZol+ZyQkMAmTJjA/vrrL5aQkMD27t3LunXrxgwNDdnt27cVyrOguLg4BoC5uLiwb775hh06dIj9+eefrGrVqszNzY3l5uYWWd4llcuHDx8k+8rPP//Mzp8/z86fP8+ePHnCGGNs+/btDAALCgpi0dHRLDIykjVo0IDp6+uz06dPS9Zz5MgRpqOjw/z8/NjevXvZ7t27WePGjZmLiwsrfAgDYI6Ojszb25vt2LGDnTx5kl2/fp0xxlhwcDDbsGEDi42NZbGxsWzOnDnM0NCQhYWFSeXh7OzMqlSpwurUqcP+/PNPdvjwYda4cWMmEAjYzJkzWfPmzVlUVBTbu3cvc3d3Z7a2tiwjI0OyvIeHB6tRowbbunUrS0hIYHv27GETJkxgcXFxxX4XipTHf//9x9asWcMAsPnz57Pz58+zGzduyM3v1atXbP78+QwAW7NmjaT8X716xRjLPy6srKyYm5sbW79+PYuNjWWjRo1iANjmzZsl+Sh6nMiTk5PDhEIh6969O/vll19Y1apVmY6ODnN1dWWLFy8udlmxYcOGMQBs9OjRLCYmhq1fv55ZW1szJycn9vr1a0k68fY4ODiwlStXsqNHj7IxY8YwACwkJESS7s8//2QA2A8//MCOHTvGjh8/ztavX8/GjBkjSfPixQvm5OTEnJ2d2a+//sqOHz/O5syZw4RCIQsODpakEx9njo6OzN/fn/3111/s2LFjLDk5mXXv3p05OTmxvLw8qe2ZNGkS09fXZ2/evGGMMXb79m02cuRItnPnThYfH88OHjzIvvvuO6ajoyPZZzIzM1lMTAwDwL777jvJd/nff/8xxhiLj49nAoGANWjQgEVGRrLo6GgWFBTEOI5jO3fulKxbfDw6OjqyYcOGsSNHjrC//vqL5ebmSuYlJydL0m/dupVxHMe6devGoqKi2IEDB1jnzp2Zrq4uO378uCRdu3btmLW1Nfvtt99YfHw8i46OZjNnzpRatzz29vZs2LBhks8LFixghoaGDAB79uwZYyx/HzIzM2OTJk2S+q5bt26tUNnwqXsKu3HjBmvevDmzs7OT5Hv+/Hmp797FxYW1b9+eRUdHs+joaObl5cUsLCxYamqqJJ+TJ08yfX191rJlSxYZGcliYmJYcHCwQudo8XqcnZ1Zly5d2MGDB9m2bduYra0tc3d3ZwMHDmRDhgxhR44cYevXr2cmJiasS5cuUnkocgx9+vSJWVlZMV9fX7Zr1y6WkJDAIiMj2YgRI9jNmzcZY4ydP3+eGRoaso4dO0rKoqjzD2OMff78mXl7ezNjY2O2ZMkSduzYMTZjxgymp6fHOnbsKJUWAHNycmK1atVif/75J9u/fz9r3749A8B2794tSTd8+HBmZGTEli5dyuLi4tjBgwfZggUL2KpVq3iXd1HHQ2ZmJrOxsWHffPONzDY1atSI1a9fX/J59+7dbObMmWzv3r0sISGB7dy5k7Vu3ZpZW1tLyrakc3HhulUkErF27doxPT09NmPGDHbs2DG2ZMkSZmxszOrVq8cyMzMlacX1Va1atdiWLVvY0aNHWa9evRgAlpCQwKvcCnvy5AmLioqSnC/Pnz/P/vnnH8aYas45RRGJRKxVq1asV69eUnkkJibKTZ+Xl8dycnLYs2fP2MyZM5lAIGAHDx6UmzYnJ4dlZGSwf/75hzVv3py5u7uzjx8/FhmLGAA2atQomd+8OTk5UvXYoEGDmEAgYC4uLiw8PJydOHGCHT16VOFjQZHfm4Q/auwpQXzgyfvLyckptrG3aNEiqbxGjRrFDAwMivzRJz6It2zZwnR1ddm7d+8k8/g09gCwEydOSE0PDw9nOjo6MieQv/76iwFghw8fZowxtmTJEgZAqvIuTN42N27cmDk4OLDPnz9LpqWlpTFLS0ulG3uF5ebmsuzsbObm5sbGjRunUJ4FiRt7hSveXbt2MQCSHzaMyZa3IuWSmJgoN468vDzm4ODAvLy8pH4Mf/z4kdnY2LBmzZpJpjVs2JA5OTmxrKwsqXRWVlZyG3vm5uZS+4k84v1q9uzZzMrKSmr/c3Z2ZoaGhuzp06eSaUlJSQwAs7e3Z+np6ZLp0dHRDADbv38/Y4yxN2/eMABs+fLlxa5fXjyKlof4Oyv4A6gou3fvZgDkNjTFx8XFixelpteqVYu1a9dO8lnR40SeFy9eMADMzMyMValShW3evJmdOHGCjRgxggFg06ZNKzb+W7duSSrZgi5evCizvHh79u3bJ5X2+++/Zzo6OuzRo0eMMcZGjx7NKlWqVOx6hw8fzkxMTCTLiIn3efEPXPFxVr16dZadnS2Vdv/+/QwAO3bsmGRabm4uc3BwYD179ixy3bm5uSwnJ4cFBASw7t27S6a/fv26yPNBkyZNmI2NjdSPltzcXFanTh1WpUoVyf4tPnd/++23MnkUbuylp6czS0tLmYZDXl4e8/HxYY0aNZJMMzExYWPHji1ym4oyYMAAVq1aNcnntm3bsu+//55ZWFhILjicPXtWphwLNvYYK75slK17xDp16iS3nhF/915eXlI/XP/++28GgP3555+SaZ6enqxevXqSC6JinTt3Zvb29jIXBOStx8fHRyrd8uXLGQD21VdfSaUfO3YsA8A+fPjAGFP8GLp06RIDwKKjo4stD2NjYzZo0KBi04itX7+eAWC7du2Smr5w4UKZ7xQAMzQ0ZCkpKZJpubm5zNPTk9WoUUMyrU6dOqxbt27FrlfR8i7ueBg/fjwzNDSUqt9u3rzJABTbQMrNzWWfPn1ixsbGbMWKFZLpxZ2LC9et4osXhffZyMhIBoD99ttvkmnOzs7MwMBA6lz1+fNnZmlpyYYPHy6Zpki5ySPe/xYvXiw1XRXnnKKsWrWKWVhYSPaFkhp77dq1k/wGNTMzY1FRUXLTiesj8V/jxo0lF5VKUtRvXgBs69atknSDBg1iANjGjRulllf0WFDkdxXhj7pxlsKWLVuQmJgo9VfS7fCvvvpK6rO3tzcyMzOlup1cuXIFX331FaysrKCrqwuBQIBvv/0WeXl5uHv3rlKxWlhYoE2bNlLTDh48iDp16qBu3brIzc2V/LVr1w4cx0lGdhN3Rezduzd27dqFZ8+elbi+9PR0JCYmokePHjAwMJBMNzU1RZcuXZTaBgDIzc3F/PnzUatWLejr60NPTw/6+vq4d+8ebt26pXS+8r4XAMWOVKVMuYjduXMHz58/x8CBA6Gj8/+HoYmJCXr27IkLFy4gIyMD6enpuHTpErp16wZ9fX2pdEWVY5s2bWBhYSEz/eTJk2jbti3Mzc0l+9XMmTPx9u1bmW5PdevWhaOjo+RzzZo1AeR36yrY9148XVxOlpaWqF69OhYvXoylS5fiypUrMl0iS1MeqmZnZ4dGjRpJTfP29pb63hU9TuQRb3taWhp2796Nb7/9Fm3atMG6devQrVs3LF26FJ8+fSpy+bi4OACQ6ZLXqFEj1KxZU6ablampqcy+3L9/f4hEIpw6dUqyrPhh/X379skdpfHgwYPw9/eHg4OD1DZ36NABAJCQkCCV/quvvoJAIJCa1qFDB9jZ2WHTpk2SaUePHsXz589luuSsX78e9evXh4GBAfT09CAQCHDixAmFjun09HRcvHgRX3/9NUxMTCTTdXV1MXDgQDx9+lSmS3bPnj1LzPfcuXN49+4dBg0aJFUGIpEI7du3R2JioqQbb6NGjRAREYG5c+fiwoULCne5DwgIwIMHD5CcnIzMzEycOXMG7du3h7+/P2JjYwHkdyMVCoWS7svKUqTuUUanTp2gq6srlS/w/+eE//77D7dv38Y333wDAFJl2bFjR7x48ULm+5GnY8eOUucG8bmnU6dOUunE0x8/fgxA8WOoRo0asLCwwOTJk7F+/XrcvHlTsQIoxsmTJ2FsbIyvv/5aaro4lsLHb0BAAGxtbSWfdXV10adPH/z333+SrqSNGjXCkSNHMGXKFMTHx+Pz589SeShT3vKOhyFDhuDz58+IjIyUTNu0aROEQiH69+8vmfbp0ydMnjwZNWrUgJ6eHvT09GBiYoL09HSl6+STJ08CkP3OevXqBWNjY5lyq1u3LqpWrSr5bGBgAHd3d6nzeEnlxoe6zjlA/nEzdepULF68WGpfKM6qVavw999/Y9++fWjXrh369Okjt3tq5cqVkZiYiDNnzuD333/Hu3fv4O/vjxcvXii0nt69e8v85k1MTETHjh1l0hbeXkWPhdL8riJFo8ZeKdSsWRO+vr5SfyUpPOKReBAD8Ynn8ePHaNmyJZ49e4YVK1bg9OnTSExMlDxcq+wJSt4Icy9fvsTVq1chEAik/kxNTcEYk/wIbNWqFaKjo5Gbm4tvv/0WVapUQZ06dYrt6/7+/XuIRCLY2dnJzJM3TVHjx4/HjBkz0K1bNxw4cAAXL15EYmIifHx8SnXyLul7kUeZchF7+/YtAPnfi4ODA0QiEd6/f4/379+DMSb3pF9URSAvz7///htBQUEAgN9//x1nz55FYmIipk+fLnc7LS0tpT6LG5pFTc/MzAQAyXMe7dq1w6JFi1C/fn1YW1tjzJgx+Pjxo9x4AcXLQ9XkjUAmFAqlykPR40QeCwsLcBwHMzMzmQfbO3TogMzMzGJ/VJZULuL5YvL2CfHxJk47cOBAbNy4EY8ePULPnj1hY2ODxo0bSxoX4m0+cOCAzDaLnyUrvM3y4tPT08PAgQOxd+9eyXM2ERERsLe3lxqcZunSpRg5ciQaN26MPXv24MKFC0hMTET79u0VOqbFx0hRZVRw24uLt7CXL18CyB+BrnA5LFy4EIwxvHv3DkD+q0AGDRqEP/74A02bNoWlpSW+/fZbpKSkFLuOtm3bAshv0J05cwY5OTlo06YN2rZtK/nxc/z4cTRv3rzUgywpc45TRb7icpw4caJMOY4aNQqA7P4kj7LnJEWPIXNzcyQkJKBu3bqYNm0aateuDQcHB8yaNUvp5+Xfvn0LOzs7meccbWxsoKenJ7NfFldfitOuXLkSkydPRnR0NPz9/WFpaYlu3brh3r17AJQrb3llU7t2bTRs2FBysSYvLw/btm1D165dpcq8f//+WL16NYYOHYqjR4/i77//RmJiIqytrZXet96+fQs9PT2ZAZM4joOdnZ1MuSlyHi+p3PhQ1zkHAEJCQlCnTh307NkTqampSE1NlVzo/PTpk9znbN3c3NCwYUN89dVX2LVrFwICAhASEiJzoVVPTw++vr5o3rw5hg4dipMnT+LBgwdYsGCBQrFZW1vL/Ob19fWVOQaNjIxknjNU9Fgoze8qUjQajbOCiY6ORnp6OqKiouDs7CyZXtr3tMl7qL5y5cowNDSUeZC54Hyxrl27omvXrsjKysKFCxcQHh6O/v37w8XFBU2bNpVZVvwjV96PncLTxHf+Cj+kW/hkCQDbtm3Dt99+i/nz50tNf/PmDSpVqiR3O9SJb7mIiSsneVfUnj9/Dh0dHVhYWIAxBo7jJBV4QUX9kJT3Xe/cuRMCgQAHDx6UutOqjvcFOTs7Y8OGDQDyR87ctWsXQkNDkZ2djfXr18tdRtHyKA98jpPCDA0N4ebmJve7Yv8bGKfg3YrCCpaLeKAAsefPn8usu7j9pOAPosGDB2Pw4MFIT0/HqVOnMGvWLHTu3Bl3796Fs7MzKleuDG9vb8ybN09uXOIfNGJFjSo3ePBgLF68GDt37kSfPn2wf/9+jB07VupO0LZt2+Dn54d169ZJLVvcxYGCLCwsoKOjU+S+A8h+R4qMNCheZtWqVUWOQCduXFeuXBnLly/H8uXL8fjxY+zfvx9TpkzBq1evEBMTU+Q6qlSpAnd3dxw/fhwuLi7w9fVFpUqVEBAQgFGjRuHixYu4cOGC5LUKmkhcjlOnTkWPHj3kplHnUPZ8jiEvLy/s3LkTjDFcvXoVERERmD17NgwNDTFlyhSl1n3x4kXJeVzs1atXyM3Nldkvi6svxdthbGyMsLAwhIWF4eXLl5K7VV26dMHt27eVKu/ijt9Ro0bh1q1bePDgAV68eIHBgwdL5n/48AEHDx7ErFmzpMonKytLciFEGVZWVsjNzcXr16+lGnyMMaSkpEju/vBRUrnxoa5zDgBcv34djx49klvf+fv7w9zcXGaQmsIaNWqEmJgYvH79uti7g1WqVIGDg4PSPcaKIm9b+RwLyv6uIkWjO3sVjPggKDhsOWMMv//+u8rX1blzZ9y/fx9WVlZyr9bIey+ZUChE69atsXDhQgD5XU7lEY/UGBUVJbnCCuT/gDtw4IBUWltbWxgYGEhG9xKT98JpjuNkhnQ/dOhQud/qL6pcirp67uHhAUdHR+zYsUNqNMz09HTs2bNHMiKlsbExfH19ER0djezsbEm6T58+SUbHVATHcdDT05P6kf3582ds3bqV/8by4O7ujp9//hleXl74559/ikynaHnwpYq7F8ocJwX17NkTaWlpOHfunNT0w4cPw8TERGbkxYLEXa+3bdsmNT0xMRG3bt2SGQr848eP2L9/v9S0HTt2QEdHB61atZLJ39jYGB06dMD06dORnZ2NGzduSLb5+vXrqF69utxtLtzYK0rNmjXRuHFjbNq0CTt27EBWVpbUj0VA/jF99epVmVFpi/oujY2N0bhxY0RFRUnNE4lE2LZtm6RBxVfz5s1RqVIl3Lx5U24Z+Pr6SnWtFqtatSpGjx6NwMDAYvd5sbZt2+LkyZOIjY1FYGAggPzjpmrVqpg5cyZycnIkdwCLoqq7dEXlXZp8PTw84Obmhn///bfIcjQ1NVVhxNL4HkNA/j7p4+ODZcuWoVKlSlLfI5/yCAgIwKdPn2Quqm3ZskUyv6ATJ05IXbDJy8tDZGQkqlevLtNQBfLrzuDgYPTr1w937txBRkaGSsu7X79+MDAwQEREBCIiIuDo6CjpIQLklxNjTOb4/eOPP2RGAOazj4rLpfB3tmfPHqSnp5f6FQjyyo0PdZ1zgPwLs3FxcVJ/kydPBpDf3b2kep8xhoSEBFSqVKnEd+eJuwfXqFFDqVj54HssAIr/3iQlozt7FUxgYCD09fXRr18/TJo0CZmZmVi3bp1aurCNHTsWe/bsQatWrTBu3Dh4e3tDJBLh8ePHOHbsGCZMmIDGjRtj5syZePr0KQICAlClShWkpqZixYoVEAgExb7nbM6cOWjfvj0CAwMxYcIE5OXlYeHChTA2Npa66sdxHAYMGICNGzeievXq8PHxwd9//40dO3bI5Nm5c2dERETA09MT3t7euHz5MhYvXiy3IlQ3RcqlevXqMDQ0xPbt21GzZk2YmJjAwcEBDg4OWLRoEb755ht07twZw4cPR1ZWFhYvXozU1FSpbhWzZ89Gp06d0K5dO/z444/Iy8vD4sWLYWJiovDV006dOmHp0qXo378/hg0bhrdv32LJkiUqfxfa1atXMXr0aPTq1Qtubm7Q19fHyZMncfXq1WKvjOvo6ChcHnzUqVMHAPDbb7/B1NQUBgYGcHV1VegFsmKKHidFmThxIrZv345evXphzpw5qFKlCv766y/s378fS5YsKbZ7noeHB4YNG4ZVq1ZBR0cHHTp0wMOHDzFjxgw4OTlh3LhxUumtrKwwcuRIPH78GO7u7jh8+DB+//13jBw5UvJMy/fffw9DQ0M0b94c9vb2SElJQXh4OMzNzSVXzGfPno3Y2Fg0a9YMY8aMgYeHBzIzM/Hw4UMcPnwY69evV/iYGzJkCIYPH47nz5+jWbNmMncVOnfujDlz5mDWrFlo3bo17ty5g9mzZ8PV1VXqNQ+mpqZwdnbGvn37EBAQAEtLS1SuXBkuLi4IDw9HYGAg/P39MXHiROjr62Pt2rW4fv06/vzzT6XeGWZiYoJVq1Zh0KBBePfuHb7++mvY2Njg9evX+Pfff/H69WusW7cOHz58gL+/P/r37w9PT0+YmpoiMTERMTExRd5ZKSggIABr167FmzdvsHz5cqnpmzZtgoWFhdRrF+QprmxKy8vLC1FRUVi3bh0aNGgAHR0dhR5ZKOjXX39Fhw4d0K5dOwQHB8PR0RHv3r3DrVu38M8//0i9fkLVFD2GDh48iLVr16Jbt26oVq0aGGOIiopCamqqpBEO5JdHfHw8Dhw4AHt7e5iamhZ5Z/Lbb7/FmjVrMGjQIDx8+BBeXl44c+YM5s+fj44dO8o04itXrow2bdpgxowZMDY2xtq1a3H79m2p1y80btwYnTt3hre3NywsLHDr1i1s3bpV6oKYqsq7UqVK6N69OyIiIpCamoqJEydK9UQwMzNDq1atsHjxYsn+lpCQgA0bNsj0tOFzLg4MDES7du0wefJkpKWloXnz5rh69SpmzZqFevXqYeDAgQrFX5Ai5caHOs45gPx3NItfB9OgQQOpY69r167w8fFB3bp1YWVlhefPnyMiIgIJCQlYs2aNZAyJq1evYty4cfj6669RrVo16Ojo4Nq1a1i2bBmsrKwwceJEhWJ7+fKl3NeqmJmZlfjuT0WPBWV/b5ISlPWIMNqgpJGRihuNs+BQ6QXzKjjc94EDB5iPjw8zMDBgjo6O7KeffmJHjhyRGcmKz2ictWvXljvv06dP7Oeff2YeHh5MX1+fmZubMy8vLzZu3DjJSFAHDx5kHTp0YI6OjkxfX5/Z2Niwjh07Sr0eoKjRL/fv38+8vb2Zvr4+q1q1KluwYIGkLAr68OEDGzp0KLO1tWXGxsasS5cu7OHDhzIjzL1//5599913zMbGhhkZGbEWLVqw06dPy4xOx3c0zsIjO8pbvnB5K1IujOUPde/p6ckEAoHM9kRHR7PGjRszAwMDZmxszAICAtjZs2dl4ty7dy/z8vKSKscxY8YwCwsLqXQoNMx+QRs3bmQeHh5MKBSyatWqsfDwcLZhwwaZ/c/Z2Zl16tRJZnl5eRceqezly5csODiYeXp6MmNjY2ZiYsK8vb3ZsmXLih1qmk958BmNk7H8UftcXV2Zrq6u1Hda1HEh77hS5DgpzuPHj1nfvn2ZhYUF09fXZ97e3jKjlRUlLy+PLVy4kLm7uzOBQMAqV67MBgwYIHmFh5h4e+Lj45mvry8TCoXM3t6eTZs2TWpUvs2bNzN/f39ma2vL9PX1mYODA+vduze7evWqVH6vX79mY8aMYa6urkwgEDBLS0vWoEEDNn36dPbp0yfGWNEj1RX04cMHyesEfv/9d5n5WVlZbOLEiczR0ZEZGBiw+vXrs+joaLnfw/Hjx1m9evWYUChkAKRGRTx9+jRr06YNMzY2ZoaGhqxJkybswIEDUssXd+6Wdy5mLP91L506dWKWlpZMIBAwR0dH1qlTJ8n+l5mZyUaMGMG8vb2ZmZkZMzQ0ZB4eHmzWrFlSI9cW5f3790xHR4cZGxtLjWgqfhVJjx49ZJYpfL4rrmz41D3yvHv3jn399desUqVKjOM4ybm7uO++8HmOMcb+/fdf1rt3b2ZjY8MEAgGzs7Njbdq0YevXry92/UWtp6jzgLzvWJFj6Pbt26xfv36sevXqzNDQkJmbm7NGjRqxiIgIqfyTkpJY8+bNmZGREQMg8z0U9vbtWzZixAhmb2/P9PT0mLOzM5s6darU6wPEZRYSEsLWrl3LqlevzgQCAfP09GTbt2+XSjdlyhTm6+vLLCwsJOfycePGSV5lIqZIeZf0W4Yxxo4dOyYZdfHu3bsy858+fcp69uzJLCwsmKmpKWvfvj27fv06c3Z2lhm1tKhzsbxj/fPnz2zy5MnM2dmZCQQCZm9vz0aOHMnev38vla6o+qrwMaJouRVW3H5e2nOOoorKY+HChaxhw4bMwsKC6erqMisrK9auXTuZ1y6kpKSwAQMGsOrVqzMjIyOmr6/PqlWrxkaMGMEeP36sUAzifUDeX/PmzSXpBg0axIyNjeXmocixoOjvKsIPx1ihNyoTQiq8nJwcyYiZx44dK+9wCCGEEEJIBUTdOAnRAN999x0CAwMl3e7Wr1+PW7duYcWKFeUdGiGEEEIIqaCosUeIBvj48SMmTpyI169fQyAQoH79+jh8+HCJAzcQQgghhJAvF3XjJIQQQgghhBAtRK9eIIQQQgghhBAtRI09QgghhBBCCNFC1NgjhBBCCCGEEC1EjT1CCCGEEEII0ULU2COEEEIIIYQQLUSNPUIIIYQQQgjRQtTYI4QQQgghhBAtRI09QgghhBBCCNFC1NgjhBBCCCGEEC1EjT1CCCGEEEII0ULU2COEEEIIIYQQLUSNPRXjOE6hv/j4eMkyq1atgqenJ4RCIVxdXREWFoacnByZvOPi4hAYGAgbGxuYmJjA29sbK1euRF5eXolxPXz4UGa9iqhfvz44jsOSJUsk0+Lj4xXeTgCIiIgAx3G4dOlSqdZb2MWLF9G9e3dUrVoVQqEQtra2aNq0KSZMmKDQOoKDg8FxHExNTfHp0yeZ+Y8ePYKOjg44jkNoaKjM9v/111/F5s8Yw44dO9CmTRtYWFhAKBSiWrVqCAkJwZMnTxSKsSji8g0ODpY7f/bs2ZI0Dx8+LNW6KgoXFxd07ty5vMMAAPj5+RVZ9gWdPHkSQ4YMgaenJ4yNjeHo6IiuXbvi8uXLMmnPnDmDoUOHokGDBhAKhUV+d+np6ejbty88PDxgamoKY2Nj1K5dG3PnzkV6eroKti6fovs5IYD66j5x/SHvLyUlpcS4qO6TFRwcDBMTkyLnm5iYSJ3fxGVYOKa8vDwMGTIEHMdh3rx5kulPnjzB6NGjUb16dRgYGMDCwgJ+fn7Yvn07GGMKxShPaGgoOI7Dmzdv5M6vU6cO/Pz8lMrbz89P6WUVVVK586WOmDmOQ0RERInpbty4gVGjRqFp06YwNjYu9hhzcXGRe4yMGDFCbvozZ86gY8eOsLCwgKGhIdzc3DBnzpxSbJW0kvYjbaRX3gFom/Pnz0t9njNnDuLi4nDy5Emp6bVq1QIAzJs3DzNmzMCUKVMQFBSExMRE/Pzzz3j27Bl+++03Sfrjx4+jXbt2aNWqFX7//XcYGxtj//79+PHHH3H//n2sWLFC5duSlJSEK1euAAA2bNiAiRMnAsivjApvZ/fu3VG9evViK6jSrregQ4cO4auvvoKfnx8WLVoEe3t7vHjxApcuXcLOnTvxyy+/KLQugUCA3NxcREZG4rvvvpOat2nTJpiamiItLY33NohEIvTv3x+RkZHo168fIiIiYG5ujqtXr2Lx4sXYsWMHDh48iObNm/POW8zU1BS7d+/GqlWrYGpqKpnOGENERATMzMyUip2ozrp16/D27Vv8+OOPqFWrFl6/fo1ffvkFTZo0wdGjR9GmTRtJ2hMnTuD48eOoV68ezMzMiqw4c3JywBjD+PHj4erqCh0dHZw6dQqzZ89GfHw8jh8/XkZbR8j/U1fdJ7Zp0yZ4enpKTbOyslLxVuT7Euq+0srOzka/fv0QHR2NtWvXYuTIkQCAs2fPonPnzjAxMcFPP/0Eb29vfPjwAbt27cKAAQNw4MAB7NixAzo6dK9Bk126dAnR0dGoV68eAgICcODAgWLTN2/eXOYYsbW1lUm3Y8cODBw4EL1798aWLVtgYmKC+/fv4/nz5yqN/4vDiFoNGjSIGRsby5335s0bZmBgwIYNGyY1fd68eYzjOHbjxg3JtG+++YYJhUL26dMnqbRBQUHMzMysxDiSk5MZABYXF6dw7CEhIQwA69SpEwPAzp49W2RaZ2dn1qlTJ7nzNm3axACwxMREla23VatWrHr16iwnJ0dmXl5enkLrEX83ffv2Zc2aNZOaJxKJmLOzM/v+++8ZADZr1izJvLi4OAaA7d69u8i858+fzwCwBQsWyMxLSUlhzs7OzNbWlr1//16hWAsDwAYMGMAMDQ3Zb7/9JjXv+PHjDIAk9uTkZKXWUdEUt4+VtdatW7NBgwaVmO7ly5cy0z5+/MhsbW1ZQECA1PSC++3ixYt5f3eTJk1iANj9+/cVXqY4iuznhBRFVXUf3/qjMKr7ZBX33TDGmLGxsdT5TVyGixcvZowx9unTJ9a2bVsmEAjYn3/+KUn3/v17ZmNjw5ydnVlKSopMvgsWLGAAWHh4uEJxFjZr1iwGgL1+/Vru/Nq1a7PWrVsrlXfr1q2VXlZRJZU7X+qIGQDbtGlTiekK7mu7d+8u9hhTtO5++vQpMzY2ZiNHjlQ0XKWUtB9pI7q0Uo5iYmKQmZmJwYMHS00fPHgwGGOIjo6WTBMIBNDX14ehoaFU2kqVKsHAwEDlsWVmZmLHjh1o0KABli1bBgDYuHGjytej7Hrfvn2LypUrQ09P9uY03yuGQ4YMwblz53Dnzh3JtOPHj+PRo0cy340isrOzsXjxYtSsWROTJk2SmW9ra4vw8HC8fPkSGzZs4J2/mLm5Obp37y5TPhs3bkTz5s3h7u4us0xsbCy6du2KKlWqwMDAADVq1MDw4cNlujMEBwfDxcVFZnlx94eCOI7D6NGjsXXrVtSsWRNGRkbw8fHBwYMHpdL9999/GDx4MNzc3GBkZARHR0d06dIF165dU7IEZGVmZmLq1KlwdXWFvr4+HB0dERISgtTUVKl0kZGRCAoKgr29PQwNDVGzZk1MmTJFpd0gAcDGxkZmmomJCWrVqiXTlbe0V7qtra0BQO4xUdj169fRtWtXWFhYwMDAAHXr1sXmzZvlps3MzMT48eNhZ2cHQ0NDtG7dWnL3QezBgwfo27cvHBwcJN3KAgICkJSUVKptItqJT91X1r6kuk8Z79+/R9u2bXH27FlER0ejb9++knl//PEHXr16hQULFsi9azNp0iR4enpi8eLFch9VUYewsDA0btwYlpaWMDMzQ/369bFhwwaFupNmZ2dj7ty5kq7G1tbWGDx4MF6/fi2VrjT1ydmzZ1G5cmV07txZkr40MZdmWT7Usa/98ccfSE9Px+TJk5XOY//+/WjatCmMjIxgamqKwMBAmbvxYk+ePEGPHj1gZmYGc3NzDBgwQOa7PXnyJPz8/GBlZQVDQ0NUrVoVPXv2REZGhtIxlgdq7JWj69evAwC8vLykptvb26Ny5cqS+QAwYsQIZGdnY8yYMXj+/DlSU1OxdetW7N27V26DorSioqLw/v17DBkyBG5ubmjRogUiIyPlPttWHutt2rQpLl68iDFjxuDixYulqjjatm0LZ2dnqYp1w4YNaNWqFdzc3Hjnd/nyZbx//x5fffWVTMNIrEuXLtDR0UFsbKzScQPAd999hwsXLuDWrVsAgNTUVERFRcl0SRW7f/8+mjZtinXr1uHYsWOYOXMmLl68iBYtWpSqDA8dOoTVq1dj9uzZ2LNnDywtLdG9e3c8ePBAkub58+ewsrLCggULEBMTgzVr1kBPTw+NGzeWamgrizGGbt26YcmSJRg4cCAOHTqE8ePHY/PmzWjTpg2ysrIkae/du4eOHTtiw4YNiImJwdixY7Fr1y506dKl1HGU5MOHD/jnn39Qu3btUuXDGENubi7S0tIQExODX375Bf369UPVqlWLXe7OnTto1qwZbty4gZUrVyIqKgq1atVCcHAwFi1aJJN+2rRpePDgAf744w/88ccfeP78Ofz8/KS+244dO+Ly5ctYtGgRYmNjsW7dOtSrV0+mkU0IwK/uE+vcuTN0dXVhaWmJHj16yE2jCl9S3Zebmyv3rygvXrxAq1atcOvWLRw7dgwdO3aUmh8bGwtdXd0iz6Mcx+Grr77Cu3fv5D63rKi8vDyF43748CGGDx+OXbt2ISoqCj169MAPP/xQ4jNgIpEIXbt2xYIFC9C/f38cOnQICxYsQGxsLPz8/PD582dJWmXrk127diEgIAC9e/fGvn37YGxsXKqYS7usOp06dQqmpqYQCASoVasWfvnlF5nxJk6dOgVLS0vcvn0bdevWhZ6eHmxsbDBixAiFHknZsWMHunbtCjMzM/z555/YsGED3r9/Dz8/P5w5c0Ymfffu3VGjRg389ddfCA0NRXR0NNq1ayc5ph4+fIhOnTpBX18fGzduRExMDBYsWABjY2NkZ2erpmDKSjneVfwiFHfb/vvvv2dCoVDuPHd3dxYUFCQ17ezZs8zBwYEBYACYrq4uW7RokUJx8O3K0qZNG2ZgYCDpZijujrJhwwa56VXVlUXR9b5584a1aNFCUhYCgYA1a9aMhYeHs48fPyq0jQW/m1mzZjE7OzuWk5PD3r59y4RCIYuIiGCvX7/m3Y1z586dDABbv359seu3tbVlNWvWVCjWwgCwkJAQJhKJmKurK5s4cSJjjLE1a9YwExMT9vHjxxK7AopEIpaTk8MePXrEALB9+/ZJ5g0aNIg5OzvLLCPu/lA4FltbW5aWliaZlpKSwnR0dIrtrpObm8uys7OZm5sbGzduXInbXFJXkJiYGAZA5piIjIxkAGS6u4qJyyEhIYEBYP/++2+JsSjajVOeb775hunp6bFLly4VmUaRbpx//vmnZP8HwAYPHiy3a1dhffv2ZUKhkD1+/FhqeocOHZiRkRFLTU1ljP3/fl6/fn0mEokk6R4+fMgEAgEbOnQoYyz/WATAli9fXuK6yZdDVXXfkSNH2PTp09mBAwdYQkICW716NatSpQozNjZmSUlJJcZBdZ+sQYMGSZ075P3J68Yp/jt27JjcfD09PZmdnV2x6163bh0DwCIjIxWKtSBx/VPcX3HdGvPy8lhOTg6bPXs2s7KykjqvFe4SKT6/7tmzRyqPxMREBoCtXbtW7jqKq08KHhMLFixgurq6bOHChcVuM5+Y+SxbFCjYjbOgkrpxjho1im3cuJElJCSw6Oho9s0330geRSnIw8ODGRgYMFNTUzZ//nwWFxfHFi1axAwNDVnz5s2LjT8vL485ODgwLy8vqS6mHz9+ZDY2NlKP6oj3o8K/O7Zv384AsG3btjHGGPvrr78YAIXOMxUd3dkrZ0Xd+Sk87/Lly+jevTsaNGiAAwcO4OTJk5g6dSp+/vlnlV+xSU5ORlxcHHr06IFKlSoBAHr16gVTU1O1dmfhs14rKyucPn0aiYmJWLBgAbp27Yq7d+9i6tSp8PLyknRLFIlEUlf+ihq5dPDgwXj58iWOHDmC7du3Q19fH7169VLbtgL5d2aK+/4VIR6Rc+vWrcjNzcWGDRvQu3fvIkf8evXqFUaMGAEnJyfo6elBIBDA2dkZACR3B5Xh7+8vNUiMra0tbGxs8OjRI8m03NxczJ8/H7Vq1YK+vj709PSgr6+Pe/fulWrdYuKBIAqPktmrVy8YGxvjxIkTkmkPHjxA//79YWdnB11dXQgEArRu3RpA6cqhJDNmzMD27duxbNkyNGjQoFR5tWvXDomJiTh58iTmzZuHPXv2oGfPnhCJRMUud/LkSQQEBMDJyUlqenBwMDIyMmS6vPTv319qP3V2dkazZs0QFxcHALC0tET16tWxePFiLF26FFeuXCkxBkIUrfvat2+PuXPnonPnzmjVqhVCQkJw+vRpcByHmTNnqjSmL6nuMzQ0RGJioty/wo+LiLVr1w5CoRDjx4+X6e6mKPa/7oSlqfuOHz8uN+7q1avLpD158iTatm0Lc3Nzybl+5syZePv2LV69elXkOg4ePIhKlSqhS5cuUuVYt25d2NnZSQ2gxac+YYxh+PDhmDVrFnbs2CG3Z5ayMZd2WXVZs2YNBg8ejFatWqFr167Ytm0bRo8ejW3btkk9EiASiZCZmYlp06Zh6tSp8PPzw08//YTw8HCcPXtWqg4v7M6dO3j+/DkGDhwo1cXUxMQEPXv2xIULF2S6Xn7zzTdSn3v37g09PT1J3Va3bl3o6+tj2LBh2Lx5s1RvFk1Djb1yZGVlhczMTLl9f9+9ewdLS0vJ55CQENja2mLv3r3o3Lkz/P39MWfOHEyZMgWhoaEq3Qk3btwIxhi+/vprpKamIjU1FTk5Ofjqq69w9uxZ3L59W2XrKu16fX19MXnyZOzevRvPnz/HuHHj8PDhQ0l3tNmzZ0MgEEj+5FUGQP4P2ICAAGzcuBEbN25E3759YWRkpNR2iLvRJScnF5kmPT0db968kfnBrQzxMwTz58/HP//8U2QXTpFIhKCgIERFRWHSpEk4ceIE/v77b1y4cAEApLql8CVvVDyhUCiV5/jx4zFjxgx069YNBw4cwMWLF5GYmAgfH59SrVvs7du30NPTkzy7JsZxHOzs7PD27VsAwKdPn9CyZUtcvHgRc+fORXx8PBITExEVFQWgdOVQnLCwMMydOxfz5s3D6NGjS52fhYUFfH194e/vj2nTpuG3337D/v37sW/fvmKXe/v2Lezt7WWmOzg4SOYXZGdnJ5O2YHlyHIcTJ06gXbt2WLRoEerXrw9ra2uMGTMGHz9+VHbziBbjU/fJ4+LighYtWkjOXaryJdV9Ojo68PX1lftX1PNYbdu2xd69e3Hv3j34+/vLNB6qVq2K169fF/usmvh1MqWp+3x8fOTGXXj8gr///htBQUEAgN9//x1nz55FYmIipk+fDqD4c/3Lly+RmpoKfX19qXIUCARISUmRNKr51ifZ2dmIjIxE7dq10aFDB5n1libm0ixb1gYMGAAAUsew+HdEu3btpNKKy+mff/4pMj9xfVRU3SYSifD+/Xup6YXrNj09PVhZWUnyql69Oo4fPw4bGxuEhISgevXqqF69ulpGv1c3evVCORI/r3Dt2jU0btxYMl18IqlTp45kWlJSEvr16wddXV2pPBo2bAiRSIRbt26hWrVqpY5JJBJJ3rHSo0cPuWk2btwo99me8l6vQCDArFmzsGzZMsnzHMOGDZN6N5tQKCxy+SFDhmDAgAEQiURYt26dEluRr0GDBrCwsMD+/fsRHh4u9wrm/v37IRKJEBgYqPR6xJycnNC2bVuEhYXBw8MDzZo1k5vu+vXr+PfffxEREYFBgwZJpv/3338yaQ0MDKSecRMrzXtptm3bhm+//Rbz58+XyVN8Nbs0rKyskJubi9evX0s1+BhjSElJQcOGDQHkX/l8/vw54uPjJVdfAaj1+bKwsDCEhoYiNDQU06ZNU8s6GjVqBAC4e/dusemsrKzw4sULmenioa0rV64sNV3eu8xSUlKkGvjOzs6SwYbu3r2LXbt2ITQ0FNnZ2Vi/fj2/DSFaj0/dVxTGmEoHifiS6z4+OnTogH379qFbt27w9/fHyZMnJYOxBAYG4tixYzhw4IDUwC1ijDHs378flpaWpe7ZoIidO3dCIBDg4MGDUg1BRQYAqly5MqysrBATEyN3vrgnC9/6RCgUIi4uDu3atUPbtm0RExMDCwsLlcRcmmXLmvgOb8Fj2NvbW+4FHHlpCxPXR0XVbTo6OlLlDOSfbxwdHSWfc3Nz8fbtW6m6rWXLlmjZsiXy8vJw6dIlrFq1CmPHjoWtra3cfbyiojt75ah9+/YwMDCQeYGl+EWs3bp1k0xzcHDApUuXZLpiiLtcValSRSUxHT16FE+fPkVISAji4uJk/mrXro0tW7YU+xB3WaxX3gEN/H+XCfFdCgcHB6krf4UHBCioe/fu6N69O4YMGYImTZoovS36+vr46aefcOvWLSxevFhm/qtXrzB16lTY2tpi6NChSq+noAkTJqBLly6YMWNGkWnEjc7Clf6vv/4qk9bFxQWvXr3Cy5cvJdOys7Nx9OhRpWPkOE5m3YcOHcKzZ8+UzrOggIAAAPmNyoL27NmD9PR0yXw+5aAKc+bMQWhoKH7++WfMmjVLLesAIOl6UqNGjWLTBQQESH6gFLRlyxYYGRnJ7Pt//vmn1Ehujx49wrlz54p8ma+7uzt+/vlneHl5FXsllny5+NR98iQnJ+Ps2bOlOk8X9iXXfXy1a9cO+/btw4MHD+Dv7y+5IDR06FDY2Nhg6tSpcrsMLlq0CLdv38akSZMgEAhUFk9ROI6Dnp6e1EXyz58/Y+vWrSUu27lzZ7x9+xZ5eXly7yJ6eHhI1gHwq0/q1auHhIQEPH36FH5+flJlVZqYS7NsWduyZQsASB3DPXv2BAAcOXJEKu3hw4dl0hbm4eEBR0dH7NixQ6q+Sk9Px549eyQjdBa0fft2qc+7du1Cbm6u3LpNV1cXjRs3xpo1awAUf5exIqI7e+XI0tISP//8M2bMmAFLS0vJi2VDQ0MxdOhQyctnAWDcuHEYM2YMunTpguHDh8PIyAgnTpzAL7/8grZt28LHx0clMW3YsAF6enqYNm2apNIoaPjw4RgzZgwOHTqErl278sr75MmTki4cBYlHseKz3nbt2qFKlSro0qULPD09IRKJkJSUhF9++QUmJib48ccfecUG5N/N+uuvvxROX1QXotatW2Py5Mn4999/Jf/26dNH6qXqHz9+xMGDB2Fubi5ZLj4+Hv7+/pg1axZCQ0N5xR4UFCTpvlEUT09PVK9eHVOmTAFjDJaWljhw4IDcEUH79OmDmTNnom/fvvjpp5+QmZmJlStXFvnMoyI6d+6MiIgIeHp6wtvbG5cvX8bixYt5XahISUmR+x25uLggMDAQ7dq1w+TJk5GWlobmzZvj6tWrmDVrFurVq4eBAwcCAJo1awYLCwuMGDECs2bNgkAgwPbt2/Hvv/8qvW1F+eWXXzBz5ky0b98enTp1ktlnClZer1+/RkJCAgBIXkdx5MgRWFtbw9raWnLV+Ndff8Xp06cRFBQEJycnpKen4/Tp01i1ahWaNWtW4nE5a9YsHDx4EP7+/pg5cyYsLS2xfft2HDp0CIsWLZLaJ4H8ixPdu3fH999/jw8fPmDWrFkwMDDA1KlTAQBXr17F6NGj0atXL7i5uUFfXx8nT57E1atXMWXKlNIVINFKfOq+tm3bolWrVvD29oaZmRmuXbuGRYsWgeM4lT6v/iXXfcoICgrC/v370bVrV8kdPnt7e0RFRaFz585o0KABfvrpJ/j4+CAtLQ2RkZHYvn07+vTpg59++kkqLz8/PyQkJKj89QCdOnXC0qVL0b9/fwwbNgxv377FkiVLFLrL2bdvX2zfvh0dO3bEjz/+iEaNGkEgEODp06eIi4tD165d0b17d6Xrk5o1a+L06dOS/fv48eOoUqVKqWIuzbJ8ZWRkSBph4notISEBb968gbGxsaTr5Y4dOxAVFYVOnTrB2dkZqamp2L17N3bu3Ing4GCp365BQUHo0qULZs+eDZFIhCZNmuDSpUsICwtD586d0aJFiyLj0dHRwaJFi/DNN9+gc+fOGD58OLKysrB48WKkpqZiwYIFMstERUVBT08PgYGBuHHjBmbMmAEfHx/07t0bALB+/XqcPHkSnTp1QtWqVZGZmSl5hrZt27aqKciyUvZjwnxZFHmJ5ooVK5i7uzvT19dnVatWZbNmzWLZ2dky6fbs2cNatGjBKleuzIyNjVnt2rXZnDlzZF60Lo8iI5K9fv2a6evrs27duhWZ5v3798zQ0JB16dJFaroiI5IV9ZeYmMh7vZGRkax///7Mzc2NmZiYMIFAwKpWrcoGDhzIbt68WUxJ/D9FvpviRuMs6k9cxiKRiG3fvp35+fmxSpUqMX19febq6spGjhzJHj16JLOuAwcOKDSKJ2P/PxpnceSN6Hjz5k0WGBjITE1NmYWFBevVqxd7/PixzDYyxtjhw4dZ3bp1maGhIatWrRpbvXp1kaNxyovF2dlZakS39+/fs++++47Z2NgwIyMj1qJFC3b69GmFXwzr7Oxc4shxnz9/ZpMnT2bOzs5MIBAwe3t7NnLkSJmX1587d441bdqUGRkZMWtrazZ06FD2zz//KDwSmaKjcbZu3brYfaWg4varguVz9uxZ1rlzZ+bg4MD09fWZkZER8/HxYXPmzGHp6eklxsQYY9euXWNdunRh5ubmTF9fn/n4+MhstzierVu3sjFjxjBra2smFApZy5YtpUYSffnyJQsODmaenp7M2NiYmZiYMG9vb7Zs2TKWm5urUDxE+6iq7hs7diyrVasWMzU1ZXp6eszBwYENGDCA3blzR6E4qO6TVdqXqhd0/PhxZmhoyDw8PNizZ88YY4w9fvyYhYSEsGrVqjF9fX1mbm7OWrVqxbZt2yZ3RMUGDRqUOIonY8q9VH3jxo3Mw8ODCYVCVq1aNRYeHs42bNggUzfKq4dycnLYkiVLmI+PDzMwMGAmJibM09OTDR8+nN27d0+STtH6RF65P336lHl6ejIXFxd2//79Uses6LJFUbQOLDxCa8G/giN5nz9/ngUEBDA7OzsmEAiYkZERa9iwIVu7dq3UqJliGRkZbPLkyczJyYnp6emxqlWrsqlTp7LMzMwSY2KMsejoaNa4cWNmYGDAjI2NWUBAADt79qxUGvF+dPnyZdalSxdmYmLCTE1NWb9+/djLly+lYu/evTtzdnZmQqGQWVlZsdatW7P9+/crFEtFwjGm4ksppEJ6+PAhXF1dERcXV2T3K1K+Jk2ahD///BP37t2TedCcVCx+fn5wcXGR6YZGCKlYqO6r2D5+/AhLS0ssX74cISEh5R3OF4/jOGzatElmVGui2eiZPUIqiLi4OMyYMYMaeoQQQr4Ip06dgqOjI77//vvyDoUQrUXP7BFSQSQmJpZ3CIQQQkiZ6dSpEzp16lTeYRCi1ejOHiGEEEIIIYRoIXpmjxBCCCGEEEK0EN3ZI4QQQgghhBAtpPXP7IlEIjx//hympqaSl18SQgjRTowxfPz4EQ4ODtDR+XKuZ1JdRwghXwa+9ZzWN/aeP38OJyen8g6DEEJIGXry5AmqVKlS3mGUGarrCCHky6JoPaf1jT1TU1MA+QViZmam9vXl5OTg2LFjCAoKgkAgUPv61Im2peLRlu0AaFsqKk3flrS0NDg5OUnO/V8KddR1mrQvaEqsmhInoDmxUpyqpymxakqcgGpj5VvPaX1jT9ydxczMrMwae0ZGRjAzM6vwO15JaFsqHm3ZDoC2paLSlm350royqqOu06R9QVNi1ZQ4Ac2JleJUPU2JVVPiBNQTq6L13JfzQAMhhBBCCCGEfEGosUcIIYQQQgghWogae4QQQgghhBCihbT+mT1CiHqIRCJkZ2crvXxOTg709PSQmZmJvLw8FUZW9mhbyo5AIICurm55h0EIIYRoBGrsEUJ4y87ORnJyMkQikdJ5MMZgZ2eHJ0+eaPxgGrQtZatSpUqws7OrsPERQgghFQU19gghvDDG8OLFC+jq6sLJyUnpF1eLRCJ8+vQJJiYmGv/ya9qWssEYQ0ZGBl69egUAsLe3L+eICCGEkIqNGnuEEF5yc3ORkZEBBwcHGBkZKZ2PuBuogYFBhWtU8EXbUnYMDQ0BAK9evYKNjQ116SSEEEKKQY09QrTMvEM3lVpueqdaCqUTP8elr6+v1HoIKS3xRYacnBxq7BHNEBee/y/TAeAJnF4KcEp0g/efqtKwCCHar+JdtiWEaAR6XoqUF9r3CCGEEMVQY48QQgghhBBCtBA19gghhBBCCCFEC9Eze4QQleD7rCBjQHZ2FvT1hVCmV56izxjyxXEc9u7di27duimUPj4+Hv7+/nj48CHMzMzUEpMm4Vt+hBBCCFEfurNHCPkiBAcHg+M4cBwHPT09VK1aFSNHjsT79++l0r148QIdOnRQ6bpDQ0NRt25dhdM/ffoU+vr68PT0VGkcZUEd5UcIIYQQ5VBjjxDyxWjfvj1evHiBhw8f4o8//sCBAwcwatQoqTR2dnYQCoXlFGG+iIgI9O7dGxkZGTh79my5xsJXRSg/QgghhOSjxh4h5IshFAphZ2eHKlWqICgoCH369MGxY8ek0nAch+joaMnnc+fOoW7dujAwMICvry+io6PBcRySkpKklktKSkKjRo1gZGSEZs2a4c6dOwDyG25hYWH4999/JXcWIyIiioyRMYZNmzZh4MCB6N+/PzZs2CA1Pzs7G6NHj4a9vT0MDAzg4uKC8PBwyfzU1FQMGzYMtra2MDAwQJ06dXDw4EGp7WnVqhUMDQ3h5OSEMWPGID09XTK/WrVq+OWXX/Ddd9/B1NQUVatWxW+//abw+guX37Vr19CmTRsYGhrCysoKw4YNw6dPnyTzg4OD0a1bNyxZsgT29vawsrJCSEgIcnJyiiwjQgghhCiGGnuEkC/SgwcPEBMTA4FAUGSajx8/okuXLvDy8sI///yDOXPmYPLkyXLTzp07F4sXL8alS5egp6eHIUOGAAD69OmDCRMmoHbt2njx4gVevHiBPn36FLnOuLg4ZGRkoG3bthg4cCB27dqFjx8/SuavXLkS+/fvx65du3Dnzh1s27YNLi4uAPJfiN6hQwecO3cO27Ztw82bN7FgwQLJu+iuXbuGdu3aoUePHrh69SoiIyNx5swZjB49WiqGNWvWwNfXF1euXMGoUaMwcuRI3L59u8T1F5aRkYH27dvDwsICiYmJ2L17N44fPy6zvri4ONy/fx9xcXHYvHkzIiIiim0QE0IIIUQxNEALIeSLcfDgQZiYmCAvLw+ZmZkAgKVLlxaZfvv27eA4Dr///jsMDAxQq1YtPHv2DN9//71M2p9//hmtW7eGjo4OpkyZgk6dOiEzMxOGhoYwMTGBnp4e7OzsSoxxw4YN6Nu3L3R1dVG7dm3UqFEDkZGRGDp0KADg8ePHcHNzQ4sWLcBxHJydnSXLHj9+HH///Tdu3boFd3d3APl36sQWL16M/v37Y+zYsQAANzc3rFy5Eq1bt8a6detgYGAAAAgMDMTIkSOho6ODyZMnY9myZYiPj4enp2ex65dXfp8/f8aWLVtgbGwMAFi9ejW6dOmChQsXwtbWFgBgYWGB1atXQ1dXF56enujUqRNOnDght5wJIYQQojiV3NlLTU1VRTaEEKJW/v7+SEpKwsWLF/HDDz+gXbt2+OGHH4pMf+fOHXh7e0saQQDQqFEjuWlr164t+b+9vT0A4NWrV7ziS01NRVRUFAYMGCCZNmDAAGzcuFHyOTg4GElJSfDw8MCYMWOkuqEmJSWhSpUqkoZeYZcvX0ZERARMTEwkf+3atYNIJEJycrLcbeE4DnZ2dpJtKW79hd26dQs+Pj6Shh4ANG/eHCKRSNLNVbw+8d1HIL/8+JZdWaC6jhBCiKbh3dhbuHAhIiMjJZ979+4NKysrODo64t9//1VpcIQQokrGxsaoUaMGvL29sXLlSmRlZSEsLKzI9IwxcIXeC8EYk5u2YHdQ8TIikYhXfDt27EBmZiYaN24MPT096OnpYfLkyTh//jxu3sx/tUX9+vWRnJyMOXPm4PPnz+jduze+/vprAIChoWGx+YtEIgwfPhxJSUmSv3///Rf37t1D9erV5W6LeHvE21Lc+guTV34F81RkfeWF6jpCCCHagHdj79dff4WTkxMAIDY2FrGxsThy5Ag6dOiAn376SeUBEkKIusyaNQtLlizB8+fP5c739PTE1atXkZWVJZl26dIl3uvR19dHXl5eiek2bNiACRMmyDTG/P39pe7umZmZoU+fPvj9998RGRmJPXv24N27d/D29sbTp09x9+5dufnXr18fN27cQI0aNWT+9PX1Fd6eotZfWK1atZCUlCQ1AMzZs2eho6NT5N3HioLqOkIIIdqAd2PvxYsXkgrw4MGD6N27N4KCgjBp0iQkJiaqPEBCCFEXPz8/1K5dG/Pnz5c7v3///hCJRBg2bBhu3bqFo0ePYsmSJQBQ5B0reVxcXJCcnIykpCS8efNGqvEolpSUhH/++QdDhw5FnTp1pP769euHLVu2ICcnB8uWLcPOnTtx+/Zt3L17F7t374adnR0qVaqE1q1bo1WrVujZsydiY2ORnJyMI0eOICYmBgAkdwlDQkKQlJSEe/fuYf/+/cV2ZS2suPUX9s0338DAwACDBg3C9evXERcXhx9++AEDBw6UPK9XUVFdRwghRBvwHqDFwsICT548gZOTE2JiYjB37lwA+d11FLlyTQjRTtM71eKVXiQSIS0tDWZmZtDRKb+BgcePH4/Bgwdj8uTJkh/3YmZmZjhw4ABGjhyJunXrwsvLCzNnzkT//v2lnuMrSc+ePREVFQV/f3+kpqZi06ZNCA4OlkqzYcMG1KpVS+6L1Lt164aRI0fiwIEDMDExwcKFC3Hv3j3o6uqiYcOGOHz4sKQM9+zZg4kTJ6Jfv35IT09HjRo1sGDBAgCAt7c3EhISMH36dLRs2RKMMVSvXr3Y0UELK2n9BRkZGeHo0aP48ccf0bBhQxgZGaFnz57FDopTUVBdRwghRBvwbuz16NED/fv3h5ubG96+fYsOHToAyL8qXaNGDZUHSAghqlDUUP79+/dH//79JZ8LP5PXrFkzqWe0tm/fDoFAgKpVqwLIvzuYl5eHtLQ0SZq6detK5SMUCvHXX38VG9+qVauKnGdtbY3c3FzJ5+JGqbS0tJTq8llYw4YNix1U5cGDB1LbAkDqnYLff/99sesvXH5eXl44efJkkenlfS/Lly8vMn1ZUVVdt27dOqxbtw4PHz4EkD8YzcyZMyX5McYQFhaG3377De/fv0fjxo2xZs0aqUFyCCGEEGXxbuwtW7YMLi4uePLkCRYtWgQTExMA+V1eRo0apfIACSGkPG3ZsgXVqlWTDMwxefJk9O7du8TBUIhmU1VdV6VKFSxYsEDSQNy8eTO6du2KK1euoHbt2li0aBGWLl2KiIgIuLu7Y+7cuQgMDMSdO3dgamqqlm0jhBDy5eDd2BMIBJg4caLMdPF7mwghRJukpKRg5syZSElJgb29PXr16oV58+aVd1hEzVRV13Xp0kXq87x587Bu3TpcuHABtWrVwvLlyzF9+nT06NEDQH5j0NbWFjt27MDw4cOLzDcrK0vq2U/x3dicnBzk5OTwirEo4nxUlZ86VfhYWX4355xC//JWhttX4cv0fyhO1dOUWDUlTkC1sfLNQ6mXqt+9exfx8fF49eqVzPDYM2fOVCZLQgipkCZNmoRJkyaVdxikHKi6rsvLy8Pu3buRnp6Opk2bIjk5GSkpKQgKCpKkEQqFaN26Nc6dO1dsYy88PFzua0OOHTsGIyMj3rEVJzY2VqX5qVPFjVX6WdzYT0qORnv4sApi4afilqk0ilP1NCVWTYkTUE2sGRkZvNLzbuz9/vvvGDlyJCpXrgw7OzupEek4jqPGHiGEEI2nyrru2rVraNq0KTIzM2FiYoK9e/eiVq1aOHfuHADIjExqa2uLR48eFZvn1KlTMX78eMnntLQ0ODk5ISgoCGZmZgrHVpycnBzExsYiMDBQ5l2IFU2Fj/V0/qBEOUwHsZ/cEWhyFwJOiXdJthxfchoVqfBl+j8Up+ppSqyaEieg2lgLP1dfEt6Nvblz52LevHmYPHky30Vl0IPrhBBCKiJV1nUeHh5ISkpCamoq9uzZg0GDBiEhIUEyv/BrPIp7Gb2YUCiEUCiUmS4QCFT+o0cdeapLhY21UMNOwImUa+yVw7ZV2DIthOJUPU2JVVPiBFQTK9/leXcaf//+PXr16sV3MbnED65funQJly5dQps2bdC1a1fcuHEDACQPrq9evRqJiYmws7NDYGAgPn78qJL1E0IIIfKosq7T19dHjRo14Ovri/DwcPj4+GDFihWws7MDkP9caEGvXr2q8O8hJIQQohl439nr1asXjh07hhEjRpR65ep4cL0sHlovjiY9LFoS2paKR5Ht0GHKvQNM0bLJyckBYwwikUjmOSY+xEP0i/PSZLQtZUskEoExhpycHOjq6krNU9Uxrsq6rjDGGLKysuDq6go7OzvExsaiXr16AIDs7GwkJCRg4cKFKl8vIYSQLw/vxl6NGjUwY8YMXLhwAV5eXjK3EseMGaNUIKp6cL0sH1ovjiY9LFoS2paKp7jt4Pdq8/93+PADhdLp6enBzs4Onz59QnZ2tpJr+3/adKeetqVsZGdn4/Pnzzh16pTU+wcB/g+uF0VVdd20adPQoUMHODk54ePHj9i5cyfi4+MRExMDjuMwduxYzJ8/H25ubnBzc8P8+fNhZGQk9e5HQgghRFm8G3u//fYbTExMkJCQIPXMAZD/3AHfxp6qH1wvi4fWi6NJD4uWhLalnPzvQX55iny4v8BD+0uO3lZqtRPbeZacCEBmZiaePHkCExMTGBgYKLUuIP/uxsePH2Fqalri80kVHW1L2crMzIShoSFatWolsw/yfXC9KKqq616+fImBAwfixYsXMDc3h7e3N2JiYhAYGAggf7TXz58/Y9SoUZJn048dO0bv2PsCnLr3WuG0rdys1RgJIUSb8W7sJScnqzQAVT+4XpYPrRdHkx4WLQltSxlT4KF9mYf7C2yTiNOVs0TJFC2XvLw8cBwHHR0d6OgUeOw3LpzX+hhjMMjKgo5QqFyjwn8q/2XURNzdUVwuLi4uGDt2rOSdbBzHYe/evejWrZta44iPj4e/vz/ev3+PSpUqKZVH4W2piHR0dMBxnNzjWVXHt6rqug0bNhQ7n+M4hIaGIjQ0VCXrI4QQQgoqVU3OGJM836EsenCdEFJWgoODwXGcpKFga2uLwMBAbNy4Ua3Pp7148UIyyrCq+Pn5ybzgu1mzZpI7SER1VFHXEUIIIeVBqcbeli1b4OXlBUNDQxgaGsLb2xtbt25VSUDyHlwXEz+43qxZM5WsixDy5Wnfvj1evHiBhw8f4siRI/D398ePP/6Izp07yzz/pSp2dnZyexyomr6+vsw74Yjy1FnXEUIIIWWBd2Nv6dKlGDlyJDp27Ihdu3YhMjIS7du3x4gRI7Bs2TJeeU2bNg2nT5/Gw4cPce3aNUyfPh3x8fH45ptvpB5c37t3L65fv47g4GB6cJ0QUipCoRB2dnZwdHRE/fr1MW3aNOzbtw9HjhxBREQEAODDhw8YNmwYbGxsYGZmhjZt2uDff/+Vymf//v3w9fWFgYEBbGxsMHDgwCLXyXEcoqOjAQAPHz4Ex3GIioqCv78/jIyM4OPjg/Pnz0vSv337Fv369UOVKlVgZGQELy8v/Pnnn5L5wcHBSEhIwIoVKyR3Kh8+fIj4+HhwHIfU1FRJ2j179qB27doQCoVwcXHBL7/8IhWbi4sL5s+fjyFDhsDU1BQuLi6ScviSqbKuI4QQQsoL72f2Vq1ahXXr1uHbb7+VTOvatStq166N0NBQjBs3TuG86MF1QuQr6sF9xukCNsC5+2/AFXjFwumMm2UVmlZq06YNfHx8EBUVhe+++w6dOnWCpaUlDh8+DHNzc/z6668ICAjA3bt3YWlpiUOHDqFHjx6YPn06tm7diszMTERFRfFa5/Tp07FkyRK4ublh+vTp6NevH/777z/o6ekhMzMTDRo0wOTJk2FmZoZDhw5h4MCBqFatGho3bowVK1bg7t27qFOnDmbPng0AsLa2xsOHD6XWcfnyZfTu3RuhoaHo06cPzp07h1GjRsHKygrBwcGSdL/88gvmzJmDadOmYffu3ZgwYQKCgoJQq5ayY7tqPlXWdYQQQkh54d3Ye/HihdxulOJnRfigB9cJIRWFp6cnrl69iri4OFy7dg2vXr2SdL1csmQJoqOj8ddff2HYsGGYN28e+vbtK3nNi0gkgqurK6/1TZw4EZ06dQIAhIWFoXbt2vjvv//g6ekJR0dHTJw4UZL2hx9+QExMDHbv3o3GjRvD3Nwc+vr6MDIykjzfLM/SpUsREBCAGTNmAADc3d1x8+ZNLF68WKqx17FjR4waNQpA/kW2ZcuWIT4+/otu7KmyriOEEELKC+9unDVq1MCuXbtkpkdGRsLNzU0lQRFCSFkTj/R7+fJlfPr0CVZWVjAxMZH8JScn4/79+wCApKQkBAQElGp93t7ekv/b29sDyB+ACsgf8XTevHnw9vaWxHHs2DE8fvyY1zpu3bqF5s2bS01r3rw57t27h7y8/78zXDAWjuNgY2OD168VHxZeG1FdRwghRBvwvrMXFhaGPn364NSpU2jevDk4jsOZM2dw4sQJuRUjIYRoglu3bsHV1RUikQj29vaIj4+XSSN+nYGhoWGp11fwFQHiAVXEI4L+8ssvWLZsGZYvXw4vLy8YGxtj7NixvF9iL+9VNfJGlSz8ugKO49Q6OqkmoLqOEEKINuDd2OvZsycuXryIZcuWITo6Gowx1KpVC3///Tfq1aunjhgJIUStTp48iWvXrmHcuHGoUqUKUlJSoKenBxcXF7npvb29ceLECQwePFgt8Zw+fRpdu3bFgAEDAOQ3Au/du4eaNWtK0ujr60vdnZOnVq1aOHPmjNS0c+fOwd3dHbq6yr2P8UtBdR0hhBBtwLuxBwANGjTAtm3bVB0LIYSoXVZWFlJSUpCXl4eXL18iJiYG4eHh6Ny5M7799lvo6OigadOm6NatGxYuXAgPDw88f/4chw8fRrdu3eDr64tZs2YhICAA1atXR9++fZGdnY3o6GjJs3GlVaNGDezZswfnzp2DhYUFli5dipSUFKnGnouLCy5evIiHDx/CxMQElpaWMvlMmDABDRs2xJw5c9CnTx+cP38eq1evxtq1a1USp7ajuo4QQoimU6ixl5aWBjMzM8n/iyNORwgB5h3iP0pmy2f8n5Vq+ewP3ssAwGnHoUotJ5f/VF7JmUiEzLQ06JuZgdNR6pWfSomJiYG9vT309PRgYWEBHx8frFy5EoMGDYLO/+I4fPgwpk+fjiFDhuD169ews7NDq1atYGtrCyD/hea7d+/GnDlzsGDBApiZmaFp06Yqi3HGjBlITk5Gu3btYGRkhGHDhqFbt2748OGDJM3EiRMxaNAg1KpVC58/f0ZycrJMPvXr18euXbswc+ZMzJkzB/b29pg9e7bU4Czk/1FdRwghRNso1NizsLDAixcvYGNjg0qVKsl9Ya/42ZCSuhURQkh5iYiIUOgdcqampli5ciVWrlxZZJoePXqgR48eAPK7WRZsHBR+BULB5+RcXFxknpurVKmS1DRLS0vJe/mK4u7uLvVuvqLy7tmzJ3r27FlkPoVjBfK7kX6JjRmq6wghhGgbhRp7J0+elHQRiouLU2tAhBBCSHmguo4QQoi2Uaix17p1a8n/XV1d4eTkJHeEtydPnqg2OkIIIaSMUF1HCCFE2/B+UMbV1VXu+5fevXvH+6XChBBCSEVEdR0hhBBtwLuxJ++9TQDw6dMnGBgYqCQoQgghpDxRXUcIIUQbKPzqhfHjxwPIf9nujBkzYGRkJJmXl5eHixcvom7duioPkBBSMcl7OTchZUGdL3ynuo4QQog2Ubixd+XKFQD5P/CuXbsGfX19yTx9fX34+Phg4sSJqo+QEFKhCAQCcByH169fw9raWu7dD0WIRCJkZ2cjMzNT8soDTUXbUjYYY8jOzsbr16+ho6MjVQ+pCtV1hBBCtInCjT3xyGSDBw/GihUrvshhuQkhgK6uLqpUqYKnT5/KHbZfUYwxfP78GYaGhko3GCsK2payZWRkhKpVq6qlMUp1HSGEEG2icGNPbNOmTeqIgxCiQUxMTODm5oacnByl88jJycGpU6fQqlUrCAQCFUZX9mhbyo6uri709PTU3hBVVV0XHh6OqKgo3L59G4aGhmjWrBkWLlwIDw8PSZrg4GBs3rxZarnGjRvjwoULKomBEELIl4t3Yw8AEhMTsXv3bjx+/BjZ2dlS86KiolQSGCGkYtPV1YWurm6pls/NzYWBgUGFbFTwQduinVRR1yUkJCAkJAQNGzZEbm4upk+fjqCgINy8eRPGxsaSdO3bt5dqYKqjiyohhJAvD+8+MDt37kTz5s1x8+ZN7N27Fzk5Obh58yZOnjwJc3NzdcRICCGElClV1XUxMTEIDg5G7dq14ePjg02bNuHx48e4fPmyVDqhUAg7OzvJn/jl7oQQQkhp8L6zN3/+fCxbtgwhISEwNTXFihUr4OrqiuHDh8Pe3l4dMRJCCCFlSl113YcPHwBApjEXHx8PGxsbVKpUCa1bt8a8efNgY2NTZD5ZWVnIysqSfE5LSwOQ3w23NN2rCxLno6r81KnCx8ryr63nFPiXcYr3jBAvhzLcvgpfpv9DcaqepsSqKXECqo2Vbx68G3v3799Hp06dAORfiUxPTwfHcRg3bhzatGmDsLAwvlkSQgghFYo66jrGGMaPH48WLVqgTp06kukdOnRAr1694OzsjOTkZMyYMQNt2rTB5cuXIRQK5eYVHh4uN4Zjx45JvS5CFWJjY1WanzpV3Fg9pT7FfnIHbNwVXvrwR/F/DqswJsVU3DKVRnGqnqbEqilxAqqJNSMjg1d63o09S0tLfPyYf9ZxdHTE9evX4eXlhdTUVN4rJ4QQQioiddR1o0ePxtWrV3HmzBmp6X369JH8v06dOvD19YWzszMOHTqEHj16yM1r6tSpkncCAvl39pycnBAUFKSyEURzcnIQGxuLwMDACv/8ZkWJdcnR23KnN3uxBQDAOF18sG4K89fnwbE8hfNtVr1y/n9aji8+oQpVlDItCcWpepoSq6bECag2VnFPDkXxbuy1bNkSsbGx8PLyQu/evfHjjz/i5MmTiI2NRUBAAN/sCCGEkApH1XXdDz/8gP379+PUqVOoUqVKsWnt7e3h7OyMe/fuFZlGKBTKvesnEAhU/qNHHXmqS3nHKiqia2bhhh3H8ng19gSc6H//KfttK+8yVRTFqXqaEqumxAmoJla+y/Nu7K1evRqZmZkA8q8sCgQCnDlzBj169MCMGTP4ZkcIIYRUOKqq6xhj+OGHH7B3717Ex8fD1dW1xGXevn2LJ0+e0HPwhBBCSk2pbpxiOjo6mDRpEiZNmqTSoAghhJDypKq6LiQkBDt27MC+fftgamqKlJQUAIC5uTkMDQ3x6dMnhIaGomfPnrC3t8fDhw8xbdo0VK5cGd27d1fZ9hBCCPky8X71gr+/PzZs2CAZUYwQQgjRNqqq69atW4cPHz7Az88P9vb2kr/IyEgA+e81vHbtGrp27Qp3d3cMGjQI7u7uOH/+PExNTVWxKYQQQr5gvO/seXl54eeff8bo0aPRsWNHDBw4EB07dqQXwBJCCNEaqqrrGGPFzjc0NMTRo0dLEyoh/MSFK5aO6QDwBE4vBcTPDIr5T1V5WIQQ9eB9Z2/lypV49uyZpEvKoEGDYGdnh2HDhiEhIUEdMRJCCCFliuo6Qggh2oB3Yw/If34hKCgIERERePnyJX799Vf8/fffaNOmjarjI4QQQsoF1XWEEEI0He9unAWlpKRg586d2LZtG65evYqGDRuqKi5CCCGkQqC6jhBCiKbi3dhLS0vDnj17sGPHDsTHx6NatWro378/du7ciRo1aqgjRkI0U1w4Wj57Xd5REEKUQHUdIYQQbcC7sWdrawsLCwv07t0b8+fPpyuchBBCtA7VdYQQQrQBr8YeYwwrVqzAgAEDYGRkpK6YCCGEkHJDdR2RoujolYD6e3PwiIUQQgCeA7QwxjB69Gg8e/ZMXfEQQggh5YrqOkIIIdqCV2NPR0cHbm5uePv2rbriIYQQQsoV1XWEEEK0Be9XLyxatAg//fQTrl+/ro54CCGEkHJHdR0hhBBtwHuAlgEDBiAjIwM+Pj7Q19eHoaGh1Px3796pLDhCCCGkPFBdRwghRBvwbuwtX75cDWEQQgghFQfVdYQQQrQB78beoEGD1BEHIYQQUmFQXUcIIUQb8H5mDwDu37+Pn3/+Gf369cOrV68AADExMbhx44ZKgyOEEELKC9V1hBBCNB3vxl5CQgK8vLxw8eJFREVF4dOnTwCAq1evYtasWSoPkBBCCClrVNcRQgjRBrwbe1OmTMHcuXMRGxsLfX19yXR/f3+cP39epcERQggh5YHqOkIIIdqA9zN7165dw44dO2SmW1tb0zuJCNFg8w7dVDhty2d/SP7fys1asYX8p/INiZByQ3UdIYQQbcD7zl6lSpXw4sULmelXrlyBo6OjSoIihBBCyhPVdYQQQrQB78Ze//79MXnyZKSkpIDjOIhEIpw9exYTJ07Et99+q44YCSGEkDJFdR0hhBBtwLuxN2/ePFStWhWOjo749OkTatWqhVatWqFZs2b4+eef1REjIYQQUqaoriOEEKINeDf2BAIBtm/fjnv37mHXrl3Ytm0bbt++ja1bt0JXV1cdMRJCCCFlSlV1XXh4OBo2bAhTU1PY2NigW7duuHPnjlQaxhhCQ0Ph4OAAQ0ND+Pn50esdCCGEqATvAVrEqlWrhmrVqiEvLw/Xrl3D+/fvYWFhocrYCCFqVnCgFUKIrNLWdQkJCQgJCUHDhg2Rm5uL6dOnIygoCDdv3oSxsTEAYNGiRVi6dCkiIiLg7u6OuXPnIjAwEHfu3IGpqam6No0QQsgXgPedvbFjx2LDhg0AgLy8PLRu3Rr169eHk5MT4uPjVR0fIYQQUuZUVdfFxMQgODgYtWvXho+PDzZt2oTHjx/j8uXLAPLv6i1fvhzTp09Hjx49UKdOHWzevBkZGRlyRwMlhBBC+OB9Z++vv/7CgAEDAAAHDhzAgwcPcPv2bWzZsgXTp0/H2bNnVR4kIYQQUpbUVdd9+PABAGBpaQkASE5ORkpKCoKCgiRphEIhWrdujXPnzmH48OFy88nKykJWVpbkc1paGgAgJycHOTk5SsVWmDgfVeWnTmqNlSl+XZxxxXfxFc8vKV1hOTxiUBXxOuWuuwLtE5qyn2pKnIDmxKopcQKqjZVvHrwbe2/evIGdnR0A4PDhw+jduzfc3d3x3XffYeXKlbzyCg8PR1RUFG7fvg1DQ0M0a9YMCxcuhIeHhyQNYwxhYWH47bff8P79ezRu3Bhr1qxB7dq1+YZOCCGEKESVdZ0YYwzjx49HixYtUKdOHQBASkoKAMDW1lYqra2tLR49elRkXuHh4QgLC5OZfuzYMRgZGSkVX1FiY2NVmp86qSdWT8WT2iiW7IN1U14RHP7IK7lKxX5yl514+HDZB1ICTdlPNSVOQHNi1ZQ4AdXEmpGRwSs978aera0tbt68CXt7e8TExGDt2rWSFfMdoIWeZSCEEFIRqbKuExs9ejSuXr2KM2fOyMzjOE7qM2NMZlpBU6dOxfjx4yWf09LS4OTkhKCgIJiZmSkVX2E5OTmIjY1FYGAgBAKBSvJUF7XGenqpwknP3X9T7HzG6eKDdVOYvz4PjuUpnG+z6pUVTqsqOUwHsZ/cEWhyFwJOJD2z5Xj5C5UDTdlPNSVOQHNi1ZQ4AdXGKu7JoSjejb3Bgwejd+/esLe3B8dxCAwMBABcvHgRnp48rn4h/1mGgjZt2gQbGxtcvnwZrVq1knmWAQA2b94MW1tb7NixQ273lrLo2lIcTbqlXBLallJiOry76pSYpZJdgNRJ4e5Fhcqe9q+KSdO3RVVxq7KuA4AffvgB+/fvx6lTp1ClShXJdPHdw5SUFNjb20umv3r1SuZuX0FCoRBCoVBmukAgUPmPHnXkqS5qibVwQ6e4pAo24DiWx6uxJ9PYKkMCTiS7/gq4P2jKfqopcQKaE6umxAmoJla+y/Nu7IWGhqJOnTp48uQJevXqJalsdHV1MWXKFL7ZSVHFswxl2bWlOJp0S7kktC3K8lS4Sw9ffLsAqZPC3YuK6PZD+1fFpKnbwrd7S1FUVdcxxvDDDz9g7969iI+Ph6urq9R8V1dX2NnZITY2FvXq1QMAZGdnIyEhAQsXLlTJthBCCPlyKfXqha+//lpm2qBBg0oViKqeZSiLri3F0aRbyiWhbSml00tL7NLDl7JdgNRJ4e5Fhbr90P5VMWn6tvDt3lIcVdR1ISEh2LFjB/bt2wdTU1NJvWZubg5DQ0NwHIexY8di/vz5cHNzg5ubG+bPnw8jIyP0799fJdtBCCHky6VUY+/EiRNYtmwZbt26BY7j4OnpibFjx6Jt27ZKB6KqZxnKsmtLcTTplnJJaFuUxInU1iDj2wVInRTuXlREudP+VTFp6raoMmZV1HXr1q0DAPj5+UlN37RpE4KDgwEAkyZNwufPnzFq1CjJQGTHjh2j59IJIYSUGu/G3urVqzFu3Dh8/fXX+PHHHwEAFy5cQMeOHbF06VKMHj2adxCqfpaBEEIIKQ1V1XWMsRLTcByH0NBQhIaGliZkogbzDt1Ey2evyzsMQghRGu/GXnh4OJYtWyZV0Y0ZMwbNmzfHvHnzeDX26FkGQgghFZEq6zpCCCGkvPB+S2daWhrat28vMz0oKIj3sxIhISHYtm0bduzYIXmWISUlBZ8/fwYAqWcZ9u7di+vXryM4OJieZSCEEKJWqqzrCCGEkPLCu7H31VdfYe/evTLT9+3bhy5duvDKa926dfjw4QP8/Pxgb28v+YuMjJSkmTRpEsaOHYtRo0bB19cXz549o2cZCCGEqJUq6zpCCCGkvCjUjXPlypWS/9esWRPz5s1DfHw8mjbNH/79woULOHv2LCZMmMBr5fQsAyGEkIpCXXUdIYQQUl4UauwtW7ZM6rOFhQVu3ryJmzdvSqZVqlQJGzduxM8//6zaCAkhhJAyQHUdIYQQbaNQYy85OVndcRBCCCHliuo6Qggh2ob3M3tib968wdu3b1UZCyGEEFKhUF1HCCFEk/Fq7KWmpiIkJASVK1eGra0tbGxsULlyZYwePRqpqalqCpEQQggpO1TXEUII0RYKv2fv3bt3aNq0KZ49e4ZvvvkGNWvWBGMMt27dQkREBE6cOIFz587BwsJCnfESQgghakN1HSGEEG2icGNv9uzZ0NfXx/3792FrayszLygoCLNnz5Z5wJ0QQgjRFFTXEUII0SYKN/aio6Px66+/ylR+AGBnZ4dFixZhxIgRVAESQgjRWFTXEW1w6t5rhdO2crNWYySEkPKm8DN7L168QO3atYucX6dOHaSkpKgkKEIIIaQ8UF1HCCFEmyjc2KtcuTIePnxY5Pzk5GRYWVmpIiZCCCGkXFBdRwghRJso3I2zffv2mD59OmJjY6Gvry81LysrCzNmzED79u1VHiAhFcG8QzdLTlRIy2eKd6PRZIp2FzqdIV2Gk4Lc1BEOIaVCdR0hhBBtonBjLywsDL6+vnBzc0NISAg8PT0BADdv3sTatWuRlZWFrVu3qi1QQgghRN2oriOEEKJNFG7sValSBefPn8eoUaMwdepUMMYAABzHITAwEKtXr4aTk5PaAiWEEELUjeo6Qggh2kThxh4AuLq64siRI3j//j3u3bsHAKhRowYsLS3VEhwhhBBS1qiuI4QQoi14NfbELCws0KhRI1XHQgghhFQYVNcRQgjRdAqPxkkIIYQQQgghRHNQY48QQghRo1OnTqFLly5wcHAAx3GIjo6Wmh8cHAyO46T+mjRpUj7BEkII0SrU2COEEELUKD09HT4+Pli9enWRadq3b48XL15I/g4fPlyGERJCCNFWCj2zV79+fZw4cQIWFhaYPXs2Jk6cCCMjI3XHRgghhJQZddV1HTp0QIcOHYpNIxQKYWdnp3CeWVlZyMrKknxOS0sDAOTk5CAnJ0e5QAsR56Oq/NRJXbHqsDwwTldl+Ynz4ptnDuN3bZ5P/kXlLZ4ud34F2ic0ZT/VlDgBzYlVU+IEVBsr3zwUauzdunUL6enpsLCwQFhYGEaMGEGNPUIIIVqlPOu6+Ph42NjYoFKlSmjdujXmzZsHGxubItOHh4cjLCxMZvqxY8dUHnNsbKxK81MnVcdaC0CqTQuV5gkAH6yb8kp/+CPPFRS96/DOO/aTu5yFKt6dZ03ZTzUlTkBzYtWUOAHVxJqRkcErvUKNvbp162Lw4MFo0aIFGGNYsmQJTExM5KadOXMmrwAIIYSQiqC86roOHTqgV69ecHZ2RnJyMmbMmIE2bdrg8uXLEAqFcpeZOnUqxo8fL/mclpYGJycnBAUFwczMTCVx5eTkIDY2FoGBgRAIBCrJU13UFeuSo7fR7MUWleXHOF18sG4K89fnwbE8hZdrVr0yr/Wcu/+m1HnnMB3EfnJHoMldCDiR9MyW4+UuUx40ZT/VlDgBzYlVU+IEVBuruCeHohRq7EVERGDWrFk4ePAgOI7DkSNHoKcnuyjHcdTYI4QQopHKq67r06eP5P916tSBr68vnJ2dcejQIfTo0UPuMkKhUG5DUCAQqPxHjzryVBdVxyridHk1yhTFsTxe+co0thTIX1V5CziRbJoKuD9oyn6qKXECmhOrpsQJqCZWvssr1Njz8PDAzp07AQA6Ojo4ceJEsd1LCKmolhy9DRHPZyVaPvsDLdUUDyGk4qgodZ29vT2cnZ0lL3QnhBBClMX7peoiEb+rS4QQQoimKc+67u3bt3jy5Ans7e3LLQZCCCHagXdjDwDu37+P5cuX49atW+A4DjVr1sSPP/6I6tWrqzo+QgghpFyoqq779OkT/vvvP8nn5ORkJCUlwdLSEpaWlggNDUXPnj1hb2+Phw8fYtq0aahcuTK6d++u6k0ihBDyheHd2Dt69Ci++uor1K1bF82bNwdjDOfOnUPt2rVx4MABBAYGqiNOQgghpMyosq67dOkS/P39JZ/FA6sMGjQI69atw7Vr17BlyxakpqbC3t4e/v7+iIyMhKmpqcq3i2imU/del3nejNMFbPIHeyn4DGArN2sgLrz0K/afWvo8CCEl4t3YmzJlCsaNG4cFCxbITJ88eTI19gghhGg8VdZ1fn5+YIwVOf/o0aNKx0kIIYQUh99bOpH/HqLvvvtOZvqQIUNw8+ZNlQRFCCGElCeq6wghhGgD3o09a2trJCUlyUxPSkqiEToJIYRoBarrCCGEaAPe3Ti///57DBs2DA8ePECzZs3AcRzOnDmDhQsXYsKECeqIkRBCCClTVNcRQgjRBrwbezNmzICpqSl++eUXTJ2a/3Ctg4MDQkNDMWbMGJUHSAghhJQ1qusIIYRoA96NPY7jMG7cOIwbNw4fP34EABoxjBBCiFahuk5LlHLUyJbP1DcKJiGElAWl3rMnRhUfIYQQbUd1HSGEEE3Fe4AWQgghhBBCCCEVX6nu7BFCiKJaPvtD6vO5CF3ApgXORUyTemFvYacdh0p9nt6pllriI4QQQgjRNnRnjxBCCCGEEEK0EK/GXk5ODvz9/XH37l11xUMIIYSUK6rrCCGEaAtejT2BQIDr16+D4zh1xUMIIYSUK6rrCCGEaAve3Ti//fZbbNiwQR2xEEIIIRUC1XWEEEK0Ae8BWrKzs/HHH38gNjYWvr6+MDY2lpq/dOlSlQVHCCGFB3ZBnLViC/pPVX0w5ItBdR0hhBBtwLuxd/36ddSvXx8AZJ5noC4vhBBCtAHVdYQQQrQB78ZeXFycOuIghBBCKgyq6wghhGgDpV+98N9//+Ho0aP4/PkzAIAxprKgCCGEkIqA6jpCCCGajHdj7+3btwgICIC7uzs6duyIFy9eAACGDh2KCRMmqDxAQgghpKxRXUcIIUQb8G7sjRs3DgKBAI8fP4aRkZFkep8+fRATE6PS4AghhJDyQHUdIYQQbcD7mb1jx47h6NGjqFKlitR0Nzc3PHr0SGWBEUIIIeWF6jpCCCHagPedvfT0dKmrnGJv3ryBUChUSVCEEEJIeVJlXXfq1Cl06dIFDg4O4DgO0dHRUvMZYwgNDYWDgwMMDQ3h5+eHGzdulCZ8QgghBIASjb1WrVphy5Ytks8cx0EkEmHx4sXw9/fnlRdVgIQQQioiVdZ16enp8PHxwerVq+XOX7RoEZYuXYrVq1cjMTERdnZ2CAwMxMePH0u1DYQQQgjvbpyLFy+Gn58fLl26hOzsbEyaNAk3btzAu3fvcPbsWV55iSvAwYMHo2fPnjLzxRVgREQE3N3dMXfuXAQGBuLOnTswNTXlGzohhBCiEFXWdR06dECHDh3kzmOMYfny5Zg+fTp69OgBANi8eTNsbW2xY8cODB8+XO5yWVlZyMrKknxOS0sDAOTk5CAnJ4dXfEUR56Oq/NSpyFiZ0oOO5y/O6ZZq+aLyU3W+6lBUrDmlLNP/z+jL2k81JU5Ac2LVlDgB1cbKNw/ejb1atWrh6tWrWLduHXR1dZGeno4ePXogJCQE9vb2vPJSRwVICCGElJYq67riJCcnIyUlBUFBQZJpQqEQrVu3xrlz54qs68LDwxEWFiYz/dixY3K7n5ZGbGysSvNTJ9lYPUuXoU3pFi/KB+um6slYDQrHelhVN5wPH1ZRRvk0ZT/VlDgBzYlVU+IEVBNrRkYGr/S8G3sAYGdnJ7eSUSVlK8CyuNpZHE26ylASbdwWHSbivWxFugKrSVeFS6Lstih8VbkM91ttPFY0dVtUGXdZ1HUpKSkAAFtbW6nptra2xQ4EM3XqVIwfP17yOS0tDU5OTggKCoKZmZlKYsvJyUFsbCwCAwMhEAhUkqe6FBnr6aUyac/df1OGkUljnC4+WDeF+evz4FheucWhiKJibVa9smpW0HJ8yWkUoCn7qabECWhOrJoSJ6DaWMVtG0Up1dh7//49NmzYgFu3boHjONSsWRODBw+GpaWlMtnJpWwFWJZXO4ujSVcZSqJN2+Ipesh7mVSbFqoPpJQ06apwSfhui8JXlVV81VgR2nSsaOq28L3iWZyyqOvEOI6T+swYk5lWkFAolDtQjEAgUPmPHnXkqS4ysXKyF/gqQiOLY3kVIg5FFI5VIKdMlfKF7qeaEiegObFqSpyAamLluzzvxl5CQgK6du0KMzMz+Pr6AgBWrlyJ2bNnY//+/WjdujXfLIvFtwIsi6udxdGkqwwl0cZtua3jAhHH73mDZi+2lJyojGjSVeGSKLstCl9VVtFVY0Vo47GiqdvC94pnUcqqrrOzswOQf4GzYPfQV69eyVzsJIQQQvji3dgLCQlB7969Jc8xAEBeXh5GjRqFkJAQXL9+XSWBKVsBluXVzuJo0lWGkmjTtog4HYh4dhusiI0qTboqXBK+26LwVeVy2Ge16VjR1G1RVcxlVde5urrCzs4OsbGxqFevHgAgOzsbCQkJWLhwoUrWQQgh5MvFe0il+/fvY8KECZLKDwB0dXUxfvx43L9/X2WBFawAxcQVYLNmzVS2HkIIIaQwVdZ1nz59QlJSEpKSkgDkP5OelJSEx48fg+M4jB07FvPnz8fevXtx/fp1BAcHw8jICP3791flJhFCCPkC8b6zV79+fdy6dQseHh5S02/duoW6devyyuvTp0/477//JJ/FFaClpSWqVq0qqQDd3Nzg5uaG+fPnUwVICCFE7VRZ1126dEnq3XziRw0GDRqEiIgITJo0CZ8/f8aoUaPw/v17NG7cGMeOHaNXDBFCCCk1hRp7V69elfx/zJgx+PHHH/Hff/+hSZMmAIALFy5gzZo1WLBgAa+VUwVICCGkolBXXefn5wfGWJHzOY5DaGgoQkNDlYqbEEIIKYpCjb26deuC4zipymrSpEky6fr3748+ffoovHKqAImy5h26ySu9DstDLeQPtqItz7qREsSF81/Gf6rq4yAaQ111HSGEEFJeFGrsJScnqzsOQgghpFxRXUcIIUTbKNTYc3Z2VncchBBCSLmiuo4QQoi2Ueql6s+ePcPZs2fx6tUriETSw6CPGTNGJYERQggh5YnqOkIIIZqOd2Nv06ZNGDFiBPT19WFlZSX1gnOO46gCJIQQovGoritnfJ+5ZToAPIHTSwFF38VJypcyz1XL02KiavIhREvxbuzNnDkTM2fOxNSpU6Gjw/s1fYSoRMtnf/BKzzhdpNq0UFM0RGso++ODfmxoHarrCCGEaAPeNVhGRgb69u1LlR8hhBCtRXUdIYQQbcC7Fvvuu++we/dudcRCCCGEVAhU1xFCCNEGvLtxhoeHo3PnzoiJiYGXlxcEAoHU/KVLl6osOEIIIaQ8UF1HCCFEG/Bu7M2fPx9Hjx6Fh4cHAMg8tE4IIYRoOqrrCCGEaAPejb2lS5di48aNCA4OVkM4hBBCSPmjuo4QQog24P3MnlAoRPPmzdURCyGEEFIhUF1HCCFEG/Bu7P34449YtWqVOmIhhBBCKgSq6wghhGgD3t04//77b5w8eRIHDx5E7dq1ZR5aj4qKUllwhBBCSHmguo4QQog24N3Yq1SpEnr06KGOWAghhJAKgeo6Qggh2oB3Y2/Tpk3qiIMQQgipMKiuI4QQog14P7NHCCGEEEIIIaTi431nz9XVtdh3DD148KBUARHNM+/QTaWXbfnsDxVGQgghqkF1HSGEEG3Au7E3duxYqc85OTm4cuUKYmJi8NNPP6kqLkIIIaTclGVdFxoairCwMKlptra2SElJUel6CCGEfHl4N/Z+/PFHudPXrFmDS5culTogQgghpLyVdV1Xu3ZtHD9+XPJZV1dX5esghBDy5VHZM3sdOnTAnj17VJUdIYQQUuGoq67T09ODnZ2d5M/a2lrl6yCEEPLl4X1nryh//fUXLC0tVZUdIYQQUuGoq667d+8eHBwcIBQK0bhxY8yfPx/VqlUrMn1WVhaysrIkn9PS0gDkdzfNyclRSUzifFSVHy+M37XonP+lz1FgOcaV311T8brLMwZFFRWrImVclsp1P+VBU+IENCdWTYkTUG2sfPPg3dirV6+e1EPrjDGkpKTg9evXWLt2Ld/sCCGEkAqnLOu6xo0bY8uWLXB3d8fLly8xd+5cNGvWDDdu3ICVlZXcZcLDw2We8wOAY8eOwcjISKXxxcbGqjQ/xXgqtVTsJ/eSE9kolbVKfbBuWt4hKKxwrIc/llMgRfnf/lk++yl/mhInoDmxakqcgGpizcjI4JWed2OvW7duUp91dHRgbW0NPz8/eHoqd3ImhBBFnbr3WullW7lR1ziimLKs6zp06CD5v5eXF5o2bYrq1atj8+bNGD9+vNxlpk6dKjUvLS0NTk5OCAoKgpmZmUriysnJQWxsLAIDAyEQCFSSp6LORUxTOG2z6pWRw3QQ+8kdgSZ3IeBExed9/01pw1Ma43TxwbopzF+fB8fyyi0ORRQVa7PqlcsxKlk5TX4ot/2Uj/I8nvjSlFg1JU5AtbGKe3Ioindjb9asWXwXIYQQQjRKedZ1xsbG8PLywr1794pMIxQKIRQKZaYLBAKV/+hRR54l4dMQKti4E3CiEht7FaGRxbG8ChGHIgrHWlL5lrn/7ZvlsZ8qQ1PiBDQnVk2JE1BNrHyXr1gdrwkhhJAvXFZWFm7dugV7e/vyDoUQQoiGU/jOno6OTrEvmAUAjuOQm5tb6qAIIYSQ8lAedd3EiRPRpUsXVK1aFa9evcLcuXORlpaGQYMGqWwdhBBCvkwKN/b27t1b5Lxz585h1apVYIypJChCCCGkPJRHXff06VP069cPb968gbW1NZo0aYILFy7A2dlZpeshhBDy5VG4sde1a1eZabdv38bUqVNx4MABfPPNN5gzZ45KgyOEEELKUnnUdTt37lRpfmVl3qGbasu7JY+0p+69zn89gE3+4Cua8izcl4DvgFpKDaJ1eikAz/x/lX2e0H+qcssRogGUes/e8+fPMWvWLGzevBnt2rVDUlIS6tSpo+rYCCFEpZQdyZNG8fwyUV1HCCFE0/EaoOXDhw+YPHkyatSogRs3buDEiRM4cOAAVX6EEEK0BtV1hBBCtIXCd/YWLVqEhQsXws7ODn/++afcri6EEEKIJqO6jhBCiDZRuLE3ZcoUGBoaokaNGti8eTM2b94sN11UVJTKgiOEEELKEtV1hBBCtInCjb1vv/22xOGoCSGEEE1GdR0hhBBtonBjLyIiQo1hEG3Q8tkf5R0CIYSUCtV1hJQfPoNo0cBZhCiG1wAthBBCCCGEEEI0AzX2CCGEEEIIIUQLUWOPEEIIIYQQQrQQNfYIIYQQQgghRAtRY48QQgghhBBCtJDCo3F+6eYduqlQOh2Wh1oAlhy9DRGnCwCY3qmWGiNTncLbKG9bCCGKU/S8UVix54y4cOWC8Z+q3HLky1Jw/2I6ADyB00sBTiSTtOUzxUdOJKQ8lTTK5+kM6XO1pvxuI0QRdGePEEIIIYQQQrQQNfYIIYQQQgghRAtRY48QQgghhBBCtBA19gghhBBCCCFEC1FjjxBCCCGEEEK0EI3GWYEpO5IfIaSMnV4KeaMWKj1aYZy1auIqT8qMGkojhhJCykHLZ39IfT71m+LLtnL73/laDecvvr8DaRRRNVN2NGxAenTjNpNVFpIi6M4eIYQQQgghhGghjWjsrV27Fq6urjAwMECDBg1w+vTp8g6JEEIIUSmq6wghhKhahW/sRUZGYuzYsZg+fTquXLmCli1bokOHDnj8+HF5h0YIIYSoBNV1hBBC1KHCN/aWLl2K7777DkOHDkXNmjWxfPlyODk5Yd26deUdGiGEEKISVNcRQghRhwo9QEt2djYuX76MKVOmSE0PCgrCuXPn5C6TlZWFrKwsyecPHz4AAN69e4ecnBzlY0n/oFA6HSZChigD2TppEHH5bem3b9+qdZ3qIm9bivMpM7cMolIO4xgyMjKgl5kLjuWVdzhK05btADRrW95+yi52fg7TQUZGBt5y2RAUGKBF2WOipPUpl6li56GcnJz8bXn7FgKBQPn1KbMNSp4rC/r48SMAgDFW6rzKSkWq6wp+b0Xt15KkFeicrynnE02JEyg6Vj7nJ3XuI+I4StpPyyqOks5fypxb+f4OVPb3ZmEqqwfUrMzjLEXdLLWflvJ74lvPVejG3ps3b5CXlwdbW1up6ba2tkhJSZG7THh4OMLCwmSmu7q6qiVGRcwutzUTQohYaHkHoIBQleX08eNHmJubqyw/ddKWuo6QL1toeQdAvzc1xkyV5KJoPVehG3tiHMdJfWaMyUwTmzp1KsaPHy/5LBKJ8O7dO1hZWRW5jCqlpaXByckJT548gZmZmdrXp060LRWPtmwHQNtSUWn6tjDG8PHjRzg4OJR3KLxVtLpOk/YFTYlVU+IENCdWilP1NCVWTYkTUG2sfOu5Ct3Yq1y5MnR1dWWubL569UrmCqiYUCiEUCiUmlapUiV1hVgkMzOzCr/jKYq2peLRlu0AaFsqKk3eFk25oydW0es6TdoXNCVWTYkT0JxYKU7V05RYNSVOQHWx8qnnKvQALfr6+mjQoAFiY2OlpsfGxqJZs2blFBUhhBCiOlTXEUIIUZcKfWcPAMaPH4+BAwfC19cXTZs2xW+//YbHjx9jxIgR5R0aIYQQohJU1xFCCFGHCt/Y69OnD96+fYvZs2fjxYsXqFOnDg4fPgxnZ+fyDk0uoVCIWbNmyXSv0US0LRWPtmwHQNtSUWnTtmiSiljXadK+oCmxakqcgObESnGqnqbEqilxAuUbK8c0aXxqQgghhBBCCCEKqdDP7BFCCCGEEEIIUQ419gghhBBCCCFEC1FjjxBCCCGEEEK0EDX2CCGEEEIIIUQLUWNPBebNm4dmzZrByMhI4ZfaBgcHg+M4qb8mTZqoN9ASKLMdjDGEhobCwcEBhoaG8PPzw40bN9QbqALev3+PgQMHwtzcHObm5hg4cCBSU1OLXaaifCdr166Fq6srDAwM0KBBA5w+fbrY9AkJCWjQoAEMDAxQrVo1rF+/vowiLRmfbYmPj5cpf47jcPv27TKMWL5Tp06hS5cucHBwAMdxiI6OLnGZivi98N2OivydEPXQlHqgIp/jNeUcrinnZ005/2rK+TU8PBwNGzaEqakpbGxs0K1bN9y5c6fE5cq6TJWJs7zKdN26dfD29pa8ML1p06Y4cuRIscuUZXlSY08FsrOz0atXL4wcOZLXcu3bt8eLFy8kf4cPH1ZThIpRZjsWLVqEpUuXYvXq1UhMTISdnR0CAwPx8eNHNUZasv79+yMpKQkxMTGIiYlBUlISBg4cWOJy5f2dREZGYuzYsZg+fTquXLmCli1bokOHDnj8+LHc9MnJyejYsSNatmyJK1euYNq0aRgzZgz27NlTpnHLw3dbxO7cuSP1Hbi5uZVRxEVLT0+Hj48PVq9erVD6ivq98N0OsYr4nRD10JR6oKKe4zXlHK5J52dNOf9qyvk1ISEBISEhuHDhAmJjY5Gbm4ugoCCkp6cXuUx5lKkycYqVdZlWqVIFCxYswKVLl3Dp0iW0adMGXbt2LfKiV5mXJyMqs2nTJmZubq5Q2kGDBrGuXbuqNR5lKbodIpGI2dnZsQULFkimZWZmMnNzc7Z+/Xo1Rli8mzdvMgDswoULkmnnz59nANjt27eLXK4ifCeNGjViI0aMkJrm6enJpkyZIjf9pEmTmKenp9S04cOHsyZNmqgtRkXx3Za4uDgGgL1//74MolMeALZ3795i01Tk70VMke3QlO+EqF5Frgcq8jleU87hmnp+1pTzryadX1+9esUAsISEhCLTVIQyVSTOilKmjDFmYWHB/vjjD7nzyro86c5eOYqPj4eNjQ3c3d3x/fff49WrV+UdEi/JyclISUlBUFCQZJpQKETr1q1x7ty5covr/PnzMDc3R+PGjSXTmjRpAnNz8xLjKs/vJDs7G5cvX5YqTwAICgoqMu7z58/LpG/Xrh0uXbqEnJwctcVaEmW2RaxevXqwt7dHQEAA4uLi1Bmm2lTU70VZ2vCdEPUoj3qgop7jNeUcru3nZ007/5Z3mX748AEAYGlpWWSailCmisQpVp5lmpeXh507dyI9PR1NmzaVm6asy5Mae+WkQ4cO2L59O06ePIlffvkFiYmJaNOmDbKysso7NIWlpKQAAGxtbaWm29raSuaVh5SUFNjY2MhMt7GxKTau8v5O3rx5g7y8PF7lmZKSIjd9bm4u3rx5o7ZYS6LMttjb2+O3337Dnj17EBUVBQ8PDwQEBODUqVNlEbJKVdTvhS9t+k6IepRHPVBRz/Gacg7X9vOzppx/K0KZMsYwfvx4tGjRAnXq1CkyXXmXqaJxlmeZXrt2DSYmJhAKhRgxYgT27t2LWrVqyU1b1uWpp/IctURoaCjCwsKKTZOYmAhfX1+l8u/Tp4/k/3Xq1IGvry+cnZ1x6NAh9OjRQ6k85VH3dgAAx3FSnxljMtNUQdFtkReTInGV1XdSEr7lKS+9vOnlgc+2eHh4wMPDQ/K5adOmePLkCZYsWYJWrVqpNU51qMjfi6K07Tv5UmlKPaAt53hNOYdr8/lZE86/FaFMR48ejatXr+LMmTMlpi3PMlU0zvIsUw8PDyQlJSE1NRV79uzBoEGDkJCQUGSDryzLkxp7RRg9ejT69u1bbBoXFxeVrc/e3h7Ozs64d++eyvIE1LsddnZ2APKvUNjb20umv3r1SuaKhSooui1Xr17Fy5cvZea9fv2aV1zq+k6KUrlyZejq6spcWS2uPO3s7OSm19PTg5WVldpiLYky2yJPkyZNsG3bNlWHp3YV9XtRBU39Tr5kmlIPaPo5XlPO4dp+ftbk829ZlukPP/yA/fv349SpU6hSpUqxacuzTPnEKU9Zlam+vj5q1KgBAPD19UViYiJWrFiBX3/9VSZtWZcnNfaKULlyZVSuXLnM1vf27Vs8efJEqrJUBXVuh6urK+zs7BAbG4t69eoByH8WICEhAQsXLlT5+hTdlqZNm+LDhw/4+++/0ahRIwDAxYsX8eHDBzRr1kzh9anrOymKvr4+GjRogNjYWHTv3l0yPTY2Fl27dpW7TNOmTXHgwAGpaceOHYOvry8EAoFa4y2OMtsiz5UrV8qs/FWpon4vqqCp38mXTFPqAU0/x2vKOVzbz8+afP4tizJljOGHH37A3r17ER8fD1dX1xKXKY8yVSZOecprP2WMFdlFvMzLUy3DvnxhHj16xK5cucLCwsKYiYkJu3LlCrty5Qr7+PGjJI2HhweLiopijDH28eNHNmHCBHbu3DmWnJzM4uLiWNOmTZmjoyNLS0srr83gvR2MMbZgwQJmbm7OoqKi2LVr11i/fv2Yvb19uW4HY4y1b9+eeXt7s/Pnz7Pz588zLy8v1rlzZ6k0FfE72blzJxMIBGzDhg3s5s2bbOzYsczY2Jg9fPiQMcb+j737DoviatsAfi8IS1dQqSJgUBErligYBTVg12gssUQsMUZN7Bq7oBEUjSXWGA0aY42KJhaEREFjb8TeQY1KVGzYqOf7w499XXaBXdhll/X+XReX7szZOc+cnZ1nz8yZGTF+/Hjx+eefy8rfvHlTWFhYiJEjR4qLFy+KVatWCRMTE7Fly5Ziizkv6q7L/PnzRVRUlLh69ao4f/68GD9+vAAgtm7dqqtVkElNTZV9HwCIefPmiTNnzohbt24JIUrO56LueujzZ0LaUVLygL7u40vKPrwk7Z9Lyv63pOxfBw8eLEqXLi3i4uLE/fv3ZX+vXr2SldGHNi1MnLpq0wkTJogDBw6IxMREcfbsWTFx4kRhZGQkYmJilMZZ3O3Jzp4GBAcHCwAKf/v375eVASAiIyOFEEK8evVKBAUFifLlywsTExNRsWJFERwcLG7fvq2bFfh/6q6HEG9vuz1t2jTh6OgopFKpaNq0qTh37lzxB59LSkqK6NWrl7C2thbW1taiV69eCrfi1dfPZMmSJcLNzU2YmpqKunXryt1mODg4WPj7+8uVj4uLEz4+PsLU1FS4u7uLZcuWFXPEeVNnXWbPni0++OADYWZmJmxtbcVHH30kdu3apYOoFeXczjn3X3BwsBCi5Hwu6q6HPn8mpB0lJQ/o8z6+pOzDS8r+uaTsf0vK/lVZjLm/0/rQpoWJU1dt2r9/f9l3qXz58qJFixayjp6yOIUo3vaUCPH/VwQSERERERGRweCjF4iIiIiIiAwQO3tEREREREQGiJ09IiIiIiIiA8TOHhERERERkQFiZ4+IiIiIiMgAsbNHRERERERkgNjZIyIiIiIiMkDs7BERERERERkgdvZIL7m7u2PBggW6DkNj4uLiIJFI8PTpU12HUmQSiQTbt2/Pc35SUhIkEgkSEhI0Wm9B20Tfvn0hkUgKjK8oAgICMGLECLnXOXVqen1LigMHDqB9+/ZwdnbWatu/6+7du+jduzfKli0LCwsL1KlTB6dOndJ6vUSaxlynv5jrRsi9Zq4rubmOnT0qVnfu3MGAAQPg7OwMU1NTuLm5Yfjw4UhJSdF1aBqTeycJAH5+frh//z5Kly6t1brfTQKlSpVCxYoVMXjwYDx58kRjddy/fx+tW7fW2PI0qVWrVsUa37Zt23D8+PFiqUtfvXz5ErVr18bixYuLpb4nT56gcePGMDExwZ49e3Dx4kV8//33KFOmTLHUT6QK5jrmOm1irit+JTnXldJ8eETK3bx5E76+vqhSpQo2bNgADw8PXLhwAWPHjsWePXtw9OhR2NnZ6SS2rKwsSCQSGBlp5/iHqakpHB0dtbLs3Fq1aoXIyEhkZmbi4sWL6N+/P54+fYoNGzZoZPnFtR6FIZVKC4wvIyMDJiYmGqnPzs4Oz58/18iySqrWrVvn+4MjPT0dkydPxrp16/D06VPUqFEDs2fPRkBAQKHqmz17NlxdXREZGSmb5u7uXqhlEWkDcx1znbYx1xW/kpzreGaPis3QoUNhamqKmJgY+Pv7o2LFimjdujX+/PNP3L17F5MmTZIrn5qaip49e8LKygrOzs5YtGiR3PyQkBBUrFgRUqkUzs7OGDZsmGxeeno6xo0bBxcXF1haWqJhw4aIi4uTzV+9ejXKlCmDnTt3wtvbG1KpFD/99BPMzMwUhp8MGzYM/v7+AICUlBT06NEDFSpUgIWFBWrWrCmXWPr27Yv4+HgsXLhQdtQxKSlJ6dCWrVu3onr16pBKpXB3d8f3338vV6+7uzvCwsLQv39/WFtbo2LFilixYkWB7ZyTBCpUqICgoCB0794dMTExcmUiIyNRrVo1mJmZwcvLC0uXLpVru6+//hpOTk4wMzODu7s7wsPDZfNzD184fvw4fHx8YGZmhvr16+PMmTNydeW09bu2b98OiUQie33jxg107NgRDg4OsLKyQoMGDfDnn38WuK4FyRlms3nzZgQEBMDMzAy//vprgZ8j8PYoXp8+fWBlZQUnJyeFz4dU069fPxw6dAgbN27E2bNn0bVrV7Rq1QrXrl0r1PJ+//131K9fH127doW9vT18fHzw008/aThqosJjrmOuy8Fc9/7Q61wniIpBSkqKkEgkIiwsTOn8gQMHCltbW5GdnS2EEMLNzU1YW1uL8PBwceXKFfHDDz8IY2NjERMTI4QQ4rfffhM2NjZi9+7d4tatW+LYsWNixYoVsuX17NlT+Pn5iQMHDojr16+LOXPmCKlUKq5evSqEECIyMlKYmJgIPz8/cejQIXH58mXx4sUL4eDgIFauXClbTmZmpnBwcBA//vijEEKIf//9V8yZM0ecOXNG3LhxQxbX0aNHhRBCPH36VPj6+oqBAweK+/fvi/v374vMzEyxf/9+AUA8efJECCHEyZMnhZGRkZg+fbq4cuWKiIyMFObm5iIyMlJWt5ubm7CzsxNLliwR165dE+Hh4cLIyEhcunQpz3YODg4WHTt2lL2+ceOG8Pb2Fg4ODrJpK1asEE5OTmLr1q3i5s2bYuvWrcLOzk6sXr1aCCHEnDlzhKurqzhw4IBISkoSBw8eFOvXr5e9H4CIiooSQgjx4sULUb58edG9e3dx/vx58ccff4hKlSoJAOLMmTOyti5durRcnFFRUeLd3U9CQoJYvny5OHv2rLh69aqYNGmSMDMzE7du3ZJrj/nz56u87kIIkZiYKAAId3d32frevXu3wM9RCCEGDx4sKlSoIGJiYsTZs2dFu3bthJWVlRg+fLjSOnLW93327rYhhBDXr18XEolE3L17V65cixYtxIQJEwpVh1QqFVKpVEyYMEGcPn1aLF++XJiZmYk1a9YUJXQijWCuY657F3OdYSppuY6dPSoWR48eVfhyvGvevHkCgPjvv/+EEG93dq1atZIr0717d9G6dWshhBDff/+9qFKlikhPT1dYlipfusjISAFAJCQkyJUZNmyYaN68uez13r17hampqXj8+HGe69amTRsxevRo2Wt/f3+FnWTuBNizZ08RGBgoV2bs2LHC29tb9trNzU307t1b9jo7O1vY29uLZcuW5RlLcHCwMDY2FpaWlsLMzEwAEADEvHnzZGVcXV3lEpoQQsyYMUP4+voKIYT45ptvRPPmzWU/RnJ793P88ccfhZ2dnXj58qVs/rJly9ROgMp4e3uLRYsWyV4XJQEuWLAg37qEkP8cU1NThampqdi4caNsfkpKijA3N2cCzEfu7/jmzZsFAGFpaSn3V6pUKdGtWzchxP/aL7+/oUOHypZpYmIi21ZzfPPNN6JRo0bFso5E+WGuY657F3OdYSppuY7X7JFeePvdgdxwB19fX7kyvr6+sjtUde3aFQsWLEClSpXQqlUrtGnTBu3bt0epUqVw+vRpCCFQpUoVufenpaWhbNmystempqaoVauWXJlevXrB19cX9+7dg7OzM9atW4c2bdrA1tYWwNvrHWbNmoVNmzbh7t27SEtLQ1paGiwtLdVa30uXLqFjx45y0xo3bowFCxYgKysLxsbGACAXn0QigaOjIx48eJDvsps1a4Zly5bh1atXWLlyJa5evYpvvvkGAPDw4UPZjQMGDhwoe09mZqbsgvq+ffsiMDAQVatWRatWrdCuXTsEBQXluR61a9eGhYWFbFruz00VL1++RGhoKHbu3Il79+4hMzMTr1+/xu3bt9VeljL169eXe13Q53jjxg2kp6fLrYudnR2qVq2qkXjeF9nZ2TA2NsapU6dk23QOKysrAICLiwsuXbqU73Jyvn8A4OTkBG9vb7n51apVw9atWzUUNZH2MNcx1zHXGR59z3Xs7FGx8PT0hEQiwcWLF/HJJ58ozL98+TJsbW1Rrly5fJeTkyBdXV1x5coVxMbG4s8//8SQIUMwZ84cxMfHq/SlAwBzc3O5hAsAH374IT744ANs3LgRgwcPRlRUlNzFsd9//z3mz5+PBQsWoGbNmrC0tMSIESOQnp6uVnsIIRTqzvkR8K7cF1dLJBJkZ2fnu2xLS0t4enoCAH744Qc0a9YMoaGhmDFjhuy9P/30Exo2bCj3vpy2qlu3LhITE7Fnzx78+eef6NatGz7++GNs2bJF6XoUxMjISKFcRkaG3OuxY8di7969mDt3Ljw9PWFubo4uXbqo3a55yf0DpaDPUZX1ooL5+PggKysLDx48QJMmTZSWMTExgZeXl8rLbNy4Ma5cuSI37erVq3BzcytSrESawFwnj7mOue59oO+5jp09KhZly5ZFYGAgli5dipEjR8Lc3Fw2Lzk5GevWrUOfPn3kksLRo0fllnH06FG5L4q5uTk6dOiADh06YOjQofDy8sK5c+dU+tLlp2fPnli3bh0qVKgAIyMjtG3bVjbv4MGD6NixI3r37g3g7dGca9euoVq1arIypqamyMrKyrcOb29v/P3333LTDh8+jCpVqigk7aKaNm0aWrdujcGDB8PZ2RkuLi64efMmevXqled7bGxs0L17d3Tv3h1dunRBq1at8PjxY4U7yHl7e2Pt2rV4/fq17DPN/bmVL18eqampePnypSwR5X5Oz8GDB9G3b1906tQJAPDixQskJSUVcc3zVtDn6OnpCRMTExw9ehQVK1YE8PY2yFevXpXdwIDeevHiBa5fvy57nZiYiISEBNjZ2aFKlSro1asX+vTpg++//x4+Pj549OgR9u3bh5o1a6JNmzZq1zdy5Ej4+fkhLCwM3bp1w/Hjx7FixQqVbuhApG3MdfKY6xLkyjDXlVwlOdfxbpxUbBYvXoy0tDS0bNkSBw4cwJ07dxAdHY3AwEC4uLhg5syZcuUPHTqEiIgIXL16FUuWLMFvv/2G4cOHA3h716tVq1bh/PnzuHnzJtauXQtzc3O4ubnJfem2bduGxMREnDhxArNnz8bu3bsLjLNXr144ffo0Zs6ciS5dusDMzEw2z9PTE7GxsTh8+DAuXbqEQYMGITk5We797u7uOHbsGJKSkvDo0SOlRydHjx6Nv/76CzNmzMDVq1exZs0aLF68GGPGjClM0+YrICAA1atXR1hYGIC3d3YLDw/HwoULcfXqVZw7dw6RkZGYN28eAGD+/PnYuHEjLl++jKtXr+K3336Do6Oj0me79OzZE0ZGRhgwYAAuXryI3bt3Y+7cuXJlGjZsCAsLC0ycOBHXr1/H+vXrsXr1arkynp6e2LZtGxISEvDPP/+gZ8+eBR7VLYqCPkcrKysMGDAAY8eOxV9//YXz58+jb9++WrtdeUl28uRJ+Pj4wMfHBwAwatQo+Pj4YOrUqQDe3g2vT58+GD16NKpWrYoOHTrg2LFjcHV1LVR9DRo0QFRUFDZs2IAaNWpgxowZWLBgQb4/6IiKE3Pd/zDXrZYrw1xXcpXoXKf2VX5ERZCUlCT69u0rHB0dhYmJiXB1dRXffPONePTokVw5Nzc3ERoaKrp16yYsLCyEg4OD3IXHUVFRomHDhsLGxkZYWlqKRo0aiT///FM2Pz09XUydOlW4u7sLExMT4ejoKDp16iTOnj0rhFB+IfW7GjRoIACIffv2yU1PSUkRHTt2FFZWVsLe3l5MnjxZ9OnTR+5i6StXrohGjRoJc3NzAUAkJiYqXLQuhBBbtmwR3t7ewsTERFSsWFHMmTNHoQ1yX6Rdu3ZtMW3atDzjVnbhthBCrFu3Tpiamorbt2/LXtepU0eYmpoKW1tb0bRpU7Ft2zYhxNs7mNWpU0dYWloKGxsb0aJFC3H69GnZspDrwuQjR46I2rVrC1NTU1GnTh2xdetWhYu4o6KihKenpzAzMxPt2rUTK1askLtoPTExUTRr1kyYm5sLV1dXsXjxYoWL/4ty0XruC8pV+RxTU1NF7969ZdtfRESE0hsS8KJ1IsqNue6JrBxzHXMd6ZZECA7YJaKSr2/fvnj69Kncc5GKQ1JSEjw8PHDmzBnUqVOnWOsmIqL3C3MdqYvnaYnIYOzcuRNWVlbYuXNnsdTXunVrVK9evVjqIiIiApjrSD08s0dEBuHBgwd4/vw5gLe3LFb3FuGFcffuXbx+/RoAULFiRZiammq9TiIien8x15G62NkjIiIiIiIyQBzGSUREREREZIDY2SMiIiIiIjJA7OwREREREREZIHb2iIiIiIiIDBA7e0RERERERAaInT0iIiIiIiIDxM4eERERERGRAWJnj4iIiIiIyACxs0dERERERGSA2NkjIiIiIiIyQOzsERERERERGSB29oiIiIiIiAwQO3tEREREREQGiJ09IiIiIiIiA8TOnh7p27cvJBJJnn9Hjx6VK3/69Gl8/PHHsLKyQpkyZdC5c2fcvHlTrszLly/x2WefoWrVqrC2toalpSWqV6+O7777Di9fvlQproCAAPTt21fl9Th79iz69esHDw8PmJmZwcrKCnXr1kVERAQeP36s8nJy7N69GyEhIWq/7119+/aFu7u73DR3d3e11kuT7ty5gyFDhqBKlSowNzeHnZ0datasiYEDB+LOnTuycn379oWVlZVWY7l06RI+//xzVKpUCWZmZihXrhzq1q2Lr7/+Gs+fP9dq3boWEhKisF3kZcGCBejcuTM8PDwgkUgQEBCgtNy///6LESNGwN/fH2XKlIFEIsHq1asVyiUlJeX7fW/VqlXhVywXiUSCr7/+WmPLI8pt9erVkEgkOHnyZJ5lJk+eDIlEgho1aijM27lzJ/r06YOaNWvCxMQEEolErfpV/S7n/t4ZGRmhbNmyaNOmDY4cOaJWnTn1qhtrSZDTPnnlyOnTp8vKJCUlFWtsedHWbwVtCQgIyDcH5OSZnO9WQX85cedsk8r+Fi9enG9McXFxKn+m6nxnJ0+ejHbt2sHFxSXf7QoAbt68ic6dO6NMmTKwsrJCYGAgTp8+XWA86ggICFC6HzJUpXQdAP3PlClT8NVXXylMb9++PaRSKRo0aCCbdvnyZQQEBKBOnTrYvHkz3rx5g6lTp6JJkyZISEhA+fLlAQAZGRkQQmDUqFHw8PCAkZERDhw4gOnTpyMuLg5//vmnRtfhp59+wpAhQ1C1alWMHTsW3t7eyMjIwMmTJ7F8+XIcOXIEUVFRai1z9+7dWLJkSZF34rlFRUXBxsZGo8tUxb///ou6deuiTJkyGD16NKpWrYpnz57h4sWL2Lx5M27evAlXV9diieXMmTNo3LgxqlWrhqlTp8Ld3R2PHj3CP//8g40bN2LMmDE6aSN9tHz5clhaWqJ58+b4448/8ix3/fp1rFu3DnXq1EGbNm2wYcMGpeWcnJyU/rjcvn07Zs+ejU6dOmksdiJdS0hIwNy5c+Hg4KB0flRUFI4ePQofHx9IpVKcOnVKq/F888036NmzJ7KysnDhwgWEhoaiWbNmOHLkCHx8fLRad0lhbW2N3377DYsWLYK1tbVsuhACq1evho2NjV4dENTEb4UpU6Zg+PDhmgsqH0uXLs2z/cLDw/H777+jU6dOaNu2rUKu8PX1RZcuXTB69GjZNKlUKlcmOjoapUuXlpvm4eGhoejV+87Onz8ftWrVQocOHfDzzz/nWe7hw4do0qQJbG1t8fPPP8PMzAzh4eEICAjAiRMnULVqVY3F/14RpNfi4uIEADF58mS56V27dhXlypUTz549k01LSkoSJiYmYty4cQUud9y4cQKAuHHjRoFl/f39RXBwcIHlDh8+LIyNjUWrVq3EmzdvFOanpaWJHTt2FLic3IYOHSqKuqkGBwcLNze3Ii1DU6ZOnSoAiJs3byqdn5WVJft/cHCwsLS01Fosffr0EZaWluL58+dK52dnZ2uknvT0dJGRkaGRZWnStGnTVN4u3v1cqlevLvz9/Qssd+LECQFAREZGqhxTQECAsLCwkPtuFxUAMXToUI0tjyi3yMhIAUCcOHFCYV5GRoaoU6eOGDZsmPD39xfVq1dXKPPu96Yw+3xVv8uJiYkCgJgzZ47c9L/++ksAEF988YXa9ZbEn1IF7ZMBiN69ewtzc3OxYsUKuXl//vmnACAGDhwoAIjExEQtR6saTfxW0Adbt24VEolE9OjRI88y+e3Tc7bJhw8fql33/v37Vf5M1fnOvlvW0tIyz9+UY8eOFSYmJiIpKUk27dmzZ6JcuXKiW7duBa+AivLaDxkqDuPUc6tWrYJEIkH//v1l0zIzM7Fz5058+umncmdd3Nzc0KxZM5XOnOWc+StVSnMnd8PCwiCRSLBixQqFI0wAYGpqig4dOsheb9q0CUFBQXBycoK5uTmqVauG8ePHyw0v7du3L5YsWQIAckMRcoYYLFmyBE2bNoW9vT0sLS1Rs2ZNREREICMjo8B4cw/jzBm+sGHDBkyaNAnOzs6wsbHBxx9/jCtXrsi9NzY2Fh07dkSFChVgZmYGT09PDBo0CI8ePSqw3pSUFBgZGcHe3l7pfCOj/L+Whw4dQrly5dCuXTvEx8fLYs7tl19+gUQiwYkTJ/KNxcbGJs+hou8Oy8hr2GtAQIDckMacdly7di1Gjx4NFxcXSKVSXLhwARKJBKtWrVJYxp49eyCRSPD777/Lpl27dg09e/aEvb09pFIpqlWrJtsWAODFixcoU6YMBg0apLC8pKQkGBsbY86cOXmuu7oK+lzULafMjRs3EB8fj27duql0RvXx48cYMmQIXFxcYGpqikqVKmHSpElIS0tTWv7HH39ElSpVIJVK4e3tjY0bN8rNf/XqFcaMGSMbgm1nZ4f69evneXaSSBWzZs3C48ePMXPmzDzLFOV7owmNGjUCANy6dQuAavkpL9nZ2YiIiICXlxekUins7e3Rp08f/Pvvv3LlcoaSHTlyBH5+fjA3N4e7uzsiIyMBALt27ULdunVhYWGBmjVrIjo6Wu79169fR79+/VC5cmVYWFjAxcUF7du3x7lz5+TK5bVPvn79er7rUbp0aXTq1EnhTMzPP/+Mxo0bo0qVKkrf9/PPP6N27dqyfUinTp1w6dIlhXVXNhQ+9zDKnGG3c+fOxbx58+Dh4QErKyv4+vrKXdqiqd8KyoZx5gyDX7t2LapVqwYLCwvUrl0bO3fuzK/5CuXixYsIDg5GzZo1sXLlSo0vX5PU+c6qWjYqKgrNmzeHm5ubbJqNjQ06d+6MP/74A5mZmfm+X9XvXo6DBw+iUaNGMDc3h4uLC6ZMmYKsrCy5MsuWLUPt2rVhZWUFa2treHl5YeLEiSqtj75gZ0+PPXv2DFu2bEGLFi3kTr3fuHEDr1+/Rq1atRTeU6tWLVy/fh1v3ryRmy6EQGZmJp4/f47o6Gh8//336NGjBypWrKiRWLOysrBv3z7Uq1dP5SGI165dQ5s2bbBq1SpER0djxIgR2Lx5M9q3by8rM2XKFHTp0gUAcOTIEdmfk5MTgLdt0bNnT6xduxY7d+7EgAEDMGfOHKUdAFVNnDgRt27dwsqVK7FixQpcu3YN7du3l9sB3LhxA76+vli2bBliYmIwdepUHDt2DB999FGBHU1fX19kZ2ejc+fO2Lt3r1rDYDZv3owWLVqgW7du2LFjB/z9/eHj4yPXCcqxePFiNGjQQG74r7JY7t+/j169eiE+Ph6vX79WOZaCTJgwAbdv38by5cvxxx9/wNXVFT4+PrIfMu9avXo17O3t0aZNGwBvE16DBg1w/vx5fP/999i5cyfatm2LYcOGITQ0FABgZWWF/v37Y926dXj27Jnc8pYuXQpTU1O5gyQlwc8//wwhBL744osCy7558wbNmjXDL7/8glGjRmHXrl3o3bs3IiIi0LlzZ4Xyv//+O3744QdMnz4dW7ZsgZubG3r06IEtW7bIyowaNQrLli3DsGHDEB0djbVr16Jr165ISUnR6HrS++PixYv47rvvsGzZMq1ff1wUOR2fnAOhquSnvAwePBjffvstAgMD8fvvv2PGjBmIjo6Gn5+fwgHB5ORk9OvXD1988QV27NiBmjVron///pg+fTomTJiAcePGYevWrbCyssInn3yCe/fuyd577949lC1bFrNmzUJ0dDSWLFmCUqVKoWHDhgoHKAHFfXJeBxzfNWDAABw9elTWWXv69Cm2bduGAQMGKC0fHh6OAQMGoHr16ti2bRsWLlyIs2fPwtfXF9euXSuwvrwsWbIEsbGxWLBgAdatW4eXL1+iTZs2sn2/tn8r7Nq1C4sXL8b06dOxdetWWSc2930SiuLZs2fo1KkTSpUqhW3btsHCwqJIy8vKykJmZqbsL3cnRt+8fv0aN27cyPO37evXrwtsb3W/e5999hl69eqFHTt2oEuXLvjuu+/khvFu3LgRQ4YMgb+/P6KiorB9+3aMHDlS5Xte6A1dn1qkvC1btkwAEBs2bJCbfujQIaXThRAiLCxMABD37t2Tm75hwwYBQPbXr18/lYfVqTKMMzk5WQAQn332mUrLzC07O1tkZGSI+Ph4AUD8888/snmqDs3IysoSGRkZ4pdffhHGxsbi8ePHsnnKhnG6ubnJrVfO8IU2bdrIldu8ebMAII4cOZJv7Ldu3RIAChyqmp2dLQYNGiSMjIwEACGRSES1atXEyJEjFYZOvDuMc9asWcLY2FjMnj1brkzO8KkzZ87Iph0/flwAEGvWrMk3ljdv3ohPPvlEtl0YGxsLHx8fMWnSJPHgwQO5srnbK4e/v7/ckMacdmzatKlC2R9++EEAEFeuXJFNe/z4sZBKpWL06NGyaS1bthQVKlRQGMr49ddfCzMzM9lne+PGDWFkZCTmz58vK/P69WtRtmxZ0a9fv3zXXQj1hnG+K79hnO9SZxhnZmamcHFxEV5eXirFsHz5cgFAbN68WW767NmzBQARExMjmwZAmJubi+TkZLn6vLy8hKenp2xajRo1xCeffKJS/UTvUjaMMysrSzRs2FBuOJoqw6eKYxjn7NmzRUZGhnjz5o04deqUaNCggQAgdu3apfCe/PJT7mGcly5dEgDEkCFD5JZx7NgxAUBMnDhRNs3f318AECdPnpRNS0lJEcbGxsLc3FzcvXtXNj0hIUEAED/88EOe65aZmSnS09NF5cqVxciRI2XT89sn5wX/P0wwOztbeHh4iDFjxgghhFiyZImwsrISqampYs6cOXJD/p48eSLMzc0Vcujt27eFVCoVPXv2lFt3ZfvQ3Lk65/OqWbOmyMzMlE3PyXHv/g7S1m8FAMLBwUHucofk5GRhZGQkwsPDC6xPFdnZ2aJ9+/bCyMhI6TaYW87no0zONpn7z8XFpcDlqjOM813qfGfzGsZ59+5dAUBpm65fv14AEIcPH85zuYX57uX+vTZw4EBhZGQkbt26JYR4+5ujTJkyKq2XPuOZPT22atUqlC1bNs8bNeR356Pc81q2bIkTJ05g3759mDlzJrZu3YpPP/0U2dnZGo1ZHTdv3kTPnj3h6OgIY2NjmJiYwN/fHwAUhnzk5cyZM+jQoQPKli0rW0afPn2QlZWFq1evFiqud4eaApAdZcoZ3gMADx48wFdffQVXV1eUKlUKJiYmsmEHBcUukUiwfPly3Lx5E0uXLkW/fv2QkZGB+fPno3r16oiPj5crL4TAoEGDMG3aNKxfvx7jxo2Tm9+jRw/Y29vLnd1btGgRypcvj+7du+cbi1QqRVRUFC5evIj58+fjs88+w8OHDzFz5kxUq1ZN6dFhVX366acK03r16gWpVCp3d8oNGzYgLS0N/fr1A/D2jNVff/2FTp06wcLCQu7IZJs2bfDmzRvZ8J1KlSqhXbt2WLp0KYQQAID169cjJSWlxN19Mjo6Gnfv3s3ziHlu+/btg6Wlpexodo6cobZ//fWX3PQWLVrI3RzD2NgY3bt3x/Xr12VDXD788EPs2bMH48ePR1xcnEbP9NL7Z968ebh27RoWLFig61AUfPvttzAxMYGZmRnq1auH27dv48cff5SNLihsftq/fz8AKAx5//DDD1GtWjWF76WTkxPq1asne21nZwd7e3vUqVMHzs7OsunVqlUDIJ+HMjMzERYWBm9vb5iamqJUqVIwNTXFtWvXlMaobJ9ckJw7J65duxaZmZlYtWoVunXrpvQs7ZEjR/D69WuFdXd1dUXz5s0V1l0dbdu2hbGxsey1srycn6L+VmjWrJncTWocHBxgb2+v8Hm8+5eTk/Ka/q6QkBD88ccfCAkJkW2DRfXnn3/ixIkTsr/du3drZLnaps5v23ep+92ztrZW+L3Xs2dPZGdn48CBA7L3Pn36FD169MCOHTtUulRHH7Gzp6fOnj2LkydPonfv3grXv5UtWxYAlA6tevz4MSQSCcqUKSM33dbWFvXr10ezZs0wceJErFixAr///jt27NihkXjLlSsHCwsLJCYmqlT+xYsXaNKkCY4dO4bvvvsOcXFxOHHiBLZt2wYAKv3IvH37Npo0aYK7d+9i4cKFOHjwIE6cOCHr9BT2h2pO++bIaf+c5WVnZyMoKAjbtm3DuHHj8Ndff+H48eOyDoiq9bq5uWHw4MFYtWoVrl27hk2bNuHNmzcYO3asXLn09HRs2rQJ1atXR+vWrRWWI5VKMWjQIKxfvx5Pnz7Fw4cPsXnzZnzxxRdKr51Uplq1ahgxYgR+/fVX3L59G/PmzUNKSgqmTJmi0vuVyRk+8y47Ozt06NABv/zyi2xIyerVq/Hhhx+ievXqAN5u15mZmVi0aBFMTEzk/nKS4Ls73OHDh+PatWuIjY0F8Ha4j6+vL+rWrVvo2HVh1apVsh8gqkhJSYGjo6NC8rO3t0epUqUU9g+Ojo4Ky8iZllP2hx9+wLfffovt27ejWbNmsLOzwyeffFKk4Vf0frp9+zamTp2KadOmwdTUFE+fPsXTp0+RmZmJ7OxsPH36VKcHE4YPH44TJ07g1KlTuHHjBu7fv48vv/wSQNHyU853Sdn+z9nZWeF7aWdnp1DO1NRUYbqpqSkAyF2iMWrUKEyZMgWffPIJ/vjjDxw7dgwnTpxA7dq1lcaoLCZV9OvXDw8fPkRYWBhOnz6d5wEpddddHQXl5fxo4rdC7vpzYsh5b1JSkkK+yjlwm3v6mjVr5JaTM9ywffv2mDx5coGxqKp27dqoX7++7E/Z8Eh9YmtrC4lEkudvW0D59yWHutufsjsD586Jn3/+OX7++WfcunULn376Kezt7dGwYUPZ742Sgo9e0FM5N7FQdu3OBx98AHNzc4WLsAHg3Llz8PT0hJmZWb7L//DDDwGg0Ge/cjM2NkaLFi2wZ88e/Pvvv6hQoUK+5fft24d79+4hLi5OdrQUeHs9gKq2b9+Oly9fYtu2bXIX8yYkJKgbvlrOnz+Pf/75B6tXr0ZwcLBsekEXuxekW7duCA8Px/nz5+WmS6VS7N+/Hy1btsTHH3+M6Oho2NraypUZPHgwZs2ahZ9//hlv3rxBZmam0sd4qEIikWDkyJGYPn26XCxmZmZKb/zx6NEjlCtXTulylOnXrx9+++03xMbGomLFijhx4gSWLVsmm29rawtjY2N8/vnnGDp0qNJlvHsNa/PmzVGjRg0sXrwYVlZWOH36NH799VeV11cfPHjwADt37kSHDh1Uuo4GePvj49ixYxBCyLX1gwcPkJmZqfCZJCcnKywjZ1rODxlLS0uEhoYiNDQU//33n+wsX/v27XH58uXCrh69h27evInXr19j+PDhSm9lb2tri+HDh+vsrF+FChVQv359pfOKkp9yvkv3799XyIP37t1Tuq8srF9//RV9+vRBWFiY3PRHjx4pHPAF8j8rkh9XV1d8/PHHCA0NRdWqVeHn56e03LvrnlvudTczM1O41jondk0rjt8Kzs7OCjdDy3lMQO7p7+avK1eu4PPPP4enpyfWrl1rkM9sVJW5uTk8PT3z/G1rbm6OSpUq5fl+db97//33n8IycudE4O1vln79+uHly5c4cOAApk2bhnbt2uHq1aty25M+45k9PZSWloZff/0VH374odKHPpYqVQrt27fHtm3bkJqaKpt++/Zt7N+/X+nNGXLLOd3t6empsbgnTJgAIQQGDhyI9PR0hfkZGRmy55Pl7NByn3n68ccfFd6X1xE8ZcsQQuCnn34qwloUTJ3YlVGWCIG3R5Pv3LkjN3Qnh4+PD+Lj4/Hvv/8iICAADx48kJvv5OSErl27YunSpVi+fDnat2+v0s138orl3r17eP78uVws7u7uOHv2rFy5q1evqj3UMygoCC4uLoiMjERkZCTMzMzQo0cP2XwLCws0a9YMZ86cQa1ateSOTOb85T7KOmzYMOzatQsTJkyAg4MDunbtqlZMuvbLL78gIyND5SGcwNthmS9evMD27dsVlpUz/11//fWXXHLLysrCpk2b8MEHHyg9OOPg4IC+ffuiR48euHLlCl69eqXGGtH7rk6dOti/f7/CX+3ateHu7o79+/fr7VDrouzjmzdvDgAKB5xOnDiBS5cuKXwvi0IikSjEuGvXLty9e1djdeQYPXo02rdvn+9oD19fX5ibmyus+7///ot9+/bJrbu7uzuuXr0qdwAxJSUFhw8fLnSMuvytYGpqqpCncoZ95pW/UlNT0alTJ2RnZyMqKkrhmXjvo06dOmHfvn24c+eObFpqaiq2bduGDh065HsHeXW/e6mpqXJ3AAfeXgZiZGSEpk2bKizf0tISrVu3xqRJk5Ceno4LFy6ovX66wjN7emj79u14/PhxvnfkCw0NRYMGDdCuXTuMHz9e9lD1cuXKyT1k88cff8TBgwcRFBQEV1dXvHz5EgcPHsSiRYvg5+eHjh07aizunLtTDhkyBPXq1cPgwYNRvXp1ZGRk4MyZM1ixYgVq1KiB9u3bw8/PD7a2tvjqq68wbdo0mJiYYN26dfjnn38UlluzZk0AwOzZs9G6dWsYGxujVq1aCAwMhKmpKXr06IFx48bhzZs3WLZsGZ48eaKxdVLGy8sLH3zwAcaPHw8hBOzs7PDHH3+ofFp/5syZOHToELp37446derA3NwciYmJWLx4MVJSUvJ8XEC1atVw8OBBfPzxx2jatCn+/PNPuR/pw4cPR8OGDQFA6R0vlfnyyy/x9OlTfPrpp6hRowaMjY1x+fJlzJ8/H0ZGRvj2229lZT///HP07t0bQ4YMwaeffopbt24hIiJCdvc6VRkbG6NPnz6YN2+e7JbKuZPcwoUL8dFHH6FJkyYYPHgw3N3dkZqaiuvXr+OPP/7Avn375Mr37t0bEyZMwIEDBzB58mTZkCdNOnnypOw23s+fP4cQQnYnywYNGsgd4cuZnnPnsJMnT8quccl9jR3w9ky+q6srWrZsqXI8ffr0wZIlSxAcHIykpCTUrFkTf//9N8LCwtCmTRt8/PHHcuXLlSuH5s2bY8qUKbC0tMTSpUtx+fJluccvNGzYEO3atUOtWrVga2uLS5cuYe3atfD19S3yneHo/VKmTBmlt9YvU6YMMjMzFebdunVLdgbkxo0bAP73PXJ3d8/zLJw2qJOfcqtatSq+/PJLLFq0CEZGRmjdujWSkpIwZcoUuLq6YuTIkRqLs127dli9ejW8vLxQq1YtnDp1CnPmzClwZE1hBAUFISgoKN8yZcqUwZQpUzBx4kT06dMHPXr0QEpKCkJDQ2FmZoZp06bJyn7++ef48ccf0bt3bwwcOBApKSmIiIhQ6ZEzedG33woF6dOnDy5duoQxY8YgNTVV7lESOaRSKXx8fHQQXcHU+c7Gx8fj4cOHAN4eaLx165asrL+/v+x3xJgxY7B27Vq0bdsW06dPh1QqxaxZs/DmzRuEhITkG4+6372yZcti8ODBuH37NqpUqYLdu3fjp59+wuDBg2UHywcOHAhzc3M0btwYTk5OSE5ORnh4OEqXLp3vnc71jq7uDEN5CwwMzPdB1zlOnjwpWrRoISwsLISNjY345JNPxPXr1+XKHDp0SLRr1044OzsLU1NTYWFhIWrXri1mzJghXr58qVI8qj5UPUdCQoIIDg4WFStWFKampsLS0lL4+PiIqVOnyt3h8fDhw8LX11dYWFiI8uXLiy+++EKcPn1a4e6FaWlp4osvvhDly5cXEolE7k5Rf/zxh6hdu7YwMzMTLi4uYuzYsWLPnj0CgNi/f79sGercjfO3336TK5dzN7B3Y7p48aIIDAwU1tbWwtbWVnTt2lXcvn1bABDTpk3Lt32OHj0qhg4dKmrXri3s7OyEsbGxKF++vGjVqpXYvXu3XFllD1X/999/hZeXl3B3dxc3btyQm+fu7i6qVauWb/3v2rt3r+jfv7/w9vYWpUuXFqVKlRJOTk6ic+fOCncfzc7OFhEREaJSpUrCzMxM1K9fX+zbty/Pu3Hmbsd3Xb16VXaHsNjYWKVlEhMTRf/+/YWLi4swMTER5cuXF35+fuK7775TWr5v376iVKlS4t9//1V5/dW5G2dwcLDSO5zl3jaEEHmWU7bLzbm77tSpU1WOO0dKSor46quvhJOTkyhVqpRwc3MTEyZMEG/evFGIZ+jQoWLp0qXigw8+ECYmJsLLy0usW7dOrtz48eNF/fr1ha2trZBKpaJSpUpi5MiR4tGjR2rHRu+X/B6q/q687saZ835lf6rkn6I+VD03VfOTsoeqZ2VlidmzZ4sqVaoIExMTUa5cOdG7d29x584duXJ5tYWbm5to27atwvSc73GOJ0+eiAEDBgh7e3thYWEhPvroI3Hw4MFC7ZMLqkuZ3HfjzLFy5UpRq1YtYWpqKkqXLi06duwoLly4oPD+NWvWiGrVqgkzMzPh7e0tNm3alOfdOJV9XrnzrbZ+K+TVFnndoVpV+eWJnL+8tun8Pp/ieqi6Ot/ZnLtfKvt7t/2FEOL69evik08+ETY2NsLCwkK0aNFCnDp1SqX41f3uxcXFifr16wupVCqcnJzExIkT5e5Uv2bNGtGsWTPh4OAgTE1NhbOzs+jWrZs4e/asSvHoC4kQSm4LRPSOgIAAuLu7y91BkfTP2bNnUbt2bSxZsgRDhgzRdTjFKj09He7u7vjoo4+wefNmld8XEhKC1atXy87YEVHJxO8yUdHFxcWhWbNmSExMVHi4PJVcHMZJVMLduHEDt27dwsSJE+Hk5KRw22FD9vDhQ1y5cgWRkZH477//MH78eF2HRERERKQ3eIMWohJuxowZCAwMxIsXL/Dbb7+9V9dW7dq1C02aNMGePXuwdOnSEve4BSIiIiJt4pk9ohJu9erV7+0Q2759+75XZzKJiIiI1MFr9oiIiIiIiAwQh3ESEREREREZIIMfxpmdnY179+7B2tpa9mBNIiIyTEIIpKamwtnZGUZG78/xTOY6IqL3g7p5zuA7e/fu3YOrq6uuwyAiomJ0584drTxcWl8x1xERvV9UzXMG39mztrYG8LZBbGxstFZPRkYGYmJiEBQUBBMTE63VY4jYdoXHtisctlvh6XvbPX/+HK6urrJ9//tCnVyn759hbiUtXqDkxVzS4gVKXsyMV/tKWsyFjVfdPGfwnb2c4Sw2NjZa7+xZWFjAxsamRGxg+oRtV3hsu8JhuxVeSWm7920oozq5rqR8hjlKWrxAyYu5pMULlLyYGa/2lbSYixqvqnnu/bmggYiIiIiI6D2i085eZmYmJk+eDA8PD5ibm6NSpUqYPn06srOzZWWEEAgJCYGzszPMzc0REBCACxcu6DBqIiIiIiIi/afTzt7s2bOxfPlyLF68GJcuXUJERATmzJmDRYsWycpERERg3rx5WLx4MU6cOAFHR0cEBgYiNTVVh5ETERERERHpN5129o4cOYKOHTuibdu2cHd3R5cuXRAUFISTJ08CeHtWb8GCBZg0aRI6d+6MGjVqYM2aNXj16hXWr1+vy9CJiIiIiIj0mk5v0PLRRx9h+fLluHr1KqpUqYJ//vkHf//9NxYsWAAASExMRHJyMoKCgmTvkUql8Pf3x+HDhzFo0CCFZaalpSEtLU32+vnz5wDeXgSZkZGhtXXJWbY26zBUbLvCY9sVDtut8PS97fQ1LiIiIl3QaWfv22+/xbNnz+Dl5QVjY2NkZWVh5syZ6NGjBwAgOTkZAODg4CD3PgcHB9y6dUvpMsPDwxEaGqowPSYmBhYWFhpeA0WxsbFar8NQse0Kj21XOGy3wtPXtnv16pWuQyAiItIbOu3sbdq0Cb/++ivWr1+P6tWrIyEhASNGjICzszOCg4Nl5XLfWlQIkeftRidMmIBRo0bJXuc8iyIoKEjrj16IjY1FYGBgibjdqz5h2xUe265w2G6Fp+9tlzOag4iIiHTc2Rs7dizGjx+Pzz77DABQs2ZN3Lp1C+Hh4QgODoajoyOAt2f4nJycZO978OCBwtm+HFKpFFKpVGG6iYlJsfwwKa56DBHb7n9m7rqoUjkjkQVvAAv33UC2xFhu3qS23lqIzLBwmys8fW07fYyJiMjQqPo7JS/8jVJ8dHqDllevXsHISD4EY2Nj2aMXPDw84OjoKDdcKD09HfHx8fDz8yvWWImIiIiIiEoSnZ7Za9++PWbOnImKFSuievXqOHPmDObNm4f+/fsDeDt8c8SIEQgLC0PlypVRuXJlhIWFwcLCAj179tRl6ERERERERHpNp529RYsWYcqUKRgyZAgePHgAZ2dnDBo0CFOnTpWVGTduHF6/fo0hQ4bgyZMnaNiwIWJiYmBtba3DyImIiIiIiPSbTjt71tbWWLBggexRC8pIJBKEhIQgJCSk2OIiIiIiIiIq6XR6zR4RERERERFpBzt7REREREREBoidPSIiIiIiIgPEzh4REREREZEBYmePiIiIiIjIAGmks/f06VNNLIaIiEhvMdcREVFJo3Znb/bs2di0aZPsdbdu3VC2bFm4uLjgn3/+0WhwREREusBcR0REhkDtzt6PP/4IV1dXAEBsbCxiY2OxZ88etG7dGmPHjtV4gERERMWNuY6IiAyB2g9Vv3//viwB7ty5E926dUNQUBDc3d3RsGFDjQdIRERU3JjriIjIEKh9Zs/W1hZ37twBAERHR+Pjjz8GAAghkJWVpdnoiIiIdIC5joiIDIHaZ/Y6d+6Mnj17onLlykhJSUHr1q0BAAkJCfD09NR4gERERMWNuY6IiAyB2p29+fPnw93dHXfu3EFERASsrKwAvB3yMmTIEI0HSEREVNyY64iIyBCo3dkzMTHBmDFjFKaPGDFCE/EQERHpHHMdEREZArU7ewBw9epVxMXF4cGDB8jOzpabN3XqVI0ERkREpEvMdUREVNKp3dn76aefMHjwYJQrVw6Ojo6QSCSyeRKJhAmQiIhKPOY6IiIyBGrfjfO7777DzJkzkZycjISEBJw5c0b2d/r0aW3ESEREVKw0mesOHDiA9u3bw9nZGRKJBNu3b5eb37dvX0gkErm/Ro0aaXBtiIjofaV2Z+/Jkyfo2rWrNmIhIiLSC5rMdS9fvkTt2rWxePHiPMu0atUK9+/fl/3t3r1bI3UTEdH7Te1hnF27dkVMTAy++uorbcRDRESkc5rMda1bt5Y9uiEvUqkUjo6OKi8zLS0NaWlpstfPnz8HAGRkZCAjIyPf9+bML6icvihp8QIlL+aSFi9Q8mI2tHiNRNGeN6qNdjC0Ni7ofapSu7Pn6emJKVOm4OjRo6hZsyZMTEzk5g8bNkzdRRIREemV4s51cXFxsLe3R5kyZeDv74+ZM2fC3t4+z/Lh4eEIDQ1VmB4TEwMLCwuV6oyNjS10vLpQ0uIFSl7MJS1eoOTFbCjxehdxubt33yziEvJmKG2cl1evXqlVXu3O3ooVK2BlZYX4+HjEx8fLzZNIJOzsERFRiVecua5169bo2rUr3NzckJiYiClTpqB58+Y4deoUpFKp0vdMmDABo0aNkr1+/vw5XF1dERQUBBsbm3zry8jIQGxsLAIDAxU6sfqopMULlLyYS1q8QMmL2dDinbv3cpGWP6alV5Her4yhtXFeckZyqErtzl5iYqK6byEiIipRijPXde/eXfb/GjVqoH79+nBzc8OuXbvQuXNnpe+RSqVKO4ImJiYq/2hQp6w+KGnxAiUv5pIWL1DyYjaUeLMlxkVerrYYShvnV14dat+g5V1CCAghirIIIiIivVbcuc7JyQlubm64du1asdVJRESGqVCdvV9++QU1a9aEubk5zM3NUatWLaxdu1bTsREREemMrnJdSkoK7ty5AycnJ63XRUREhk3tYZzz5s3DlClT8PXXX6Nx48YQQuDQoUP46quv8OjRI4wcOVIbcRIRERUbTea6Fy9e4Pr167LXiYmJSEhIgJ2dHezs7BASEoJPP/0UTk5OSEpKwsSJE1GuXDl06tRJG6tGRETvEbU7e4sWLcKyZcvQp08f2bSOHTuievXqCAkJYWePiIhKPE3mupMnT6JZs2ay1zk3VgkODsayZctw7tw5/PLLL3j69CmcnJzQrFkzbNq0CdbW1ppbISIiei+p3dm7f/8+/Pz8FKb7+fnh/v37GgmKiIhIlzSZ6wICAvK95m/v3r1qx0dERKQKta/Z8/T0xObNmxWmb9q0CZUrV9ZIUERERLrEXEdERIZA7TN7oaGh6N69Ow4cOIDGjRtDIpHg77//xl9//aU0MRIREZU0zHVERGQI1D6z9+mnn+LYsWMoV64ctm/fjm3btqFcuXI4fvw4LyYnIiKDwFxHRESGQO0zewBQr149/Prrr5qOhYiISG8w1xERUUmnUmfv+fPnsLGxkf0/PznliIiIShLmOiKi4jFz18UivX9SW28NRWL4VOrs2dra4v79+7C3t0eZMmUgkUgUygghIJFIkJWVpfEgiYiItI25joiIDI1Knb19+/bBzs4OALB//36tBkRERKQLzHVERGRoVOrs+fv7y/7v4eEBV1dXhSOeQgjcuXNHs9EREREVE+Y6IiIyNGrfjdPDwwMPHz5UmP748WN4eHhoJCgiIiJdYq4jIiJDoHZnL+d6hdxevHgBMzMzjQRFRESkS8x1RERkCFR+9MKoUaMAABKJBFOmTIGFhYVsXlZWFo4dO4Y6depoPEAiIqLiwlxHRESGROXO3pkzZwC8Pdp57tw5mJqayuaZmpqidu3aGDNmjOYjJCIiKibMdUREZEhU7uzl3JmsX79+WLhwIZ8xREREBoe5joiIDIna1+xFRkZqNPndvXsXvXv3RtmyZWFhYYE6derg1KlTsvlCCISEhMDZ2Rnm5uYICAjAhQsXNFY/ERFRbprOdURERLqg8pm9d504cQK//fYbbt++jfT0dLl527ZtU3k5T548QePGjdGsWTPs2bMH9vb2uHHjBsqUKSMrExERgXnz5mH16tWoUqUKvvvuOwQGBuLKlSuwtrYuTPhEREQF0lSuIyIi0hW1O3sbN25Enz59EBQUhNjYWAQFBeHatWtITk5Gp06d1FrW7Nmz4erqisjISNk0d3d32f+FEFiwYAEmTZqEzp07AwDWrFkDBwcHrF+/HoMGDVJYZlpaGtLS0mSvnz9/DgDIyMhARkaGWvGpI2fZ2qzDULHtFBmJLBXLZcv9+y62Z964zRWevredpuLSZK4jIiLSFbU7e2FhYZg/fz6GDh0Ka2trLFy4EB4eHhg0aBCcnJzUWtbvv/+Oli1bomvXroiPj4eLiwuGDBmCgQMHAgASExORnJyMoKAg2XukUin8/f1x+PBhpZ298PBwhIaGKkyPiYmRu6uatsTGxmq9DkPFtvsfbzXLe2UnKUzbvfumRmIxZNzmCk9f2+7Vq1caWY4mcx0REZGuqN3Zu3HjBtq2bQvgbcfr5cuXkEgkGDlyJJo3b660o5WXmzdvYtmyZRg1ahQmTpyI48ePY9iwYZBKpejTpw+Sk5MBAA4ODnLvc3BwwK1bt5Quc8KECbJbZwNvz+y5uroiKChIq9dfZGRkIDY2FoGBgTAxMdFaPYaIbado7t7LKpUzEtnwyk7CZSN3ZEvkL8Ed09JLG6EZBG5zhafvbZczmqOoNJnriIiIdEXtzp6dnR1SU1MBAC4uLjh//jxq1qyJp0+fqn1ENTs7G/Xr10dYWBgAwMfHBxcuXMCyZcvQp08fWbncD7bN62G3wNukLJVKFaabmJgUyw+T4qrHELHt/idbYqxmeSOF97AtC8ZtrvD0te00FZMmcx0REZGuqH03ziZNmsiG73Tr1g3Dhw/HwIED0aNHD7Ro0UKtZTk5OcHbW37AWrVq1XD79m0AgKOjIwDIzvDlePDggcLZPiIiIk3RZK4jIiLSFbXP7C1evBhv3rwB8HbIpImJCf7++2907twZU6ZMUWtZjRs3xpUrV+SmXb16FW5ubgAADw8PODo6IjY2Fj4+PgCA9PR0xMfHY/bs2eqGTkREpBJN5joiIiJdKdQwzhxGRkYYN24cxo0bV6jKR44cCT8/P4SFhaFbt244fvw4VqxYgRUrVgB4O3xzxIgRCAsLQ+XKlVG5cmWEhYXBwsICPXv2LFSdREREBdFkriMiItIVtYdxNmvWDKtWrcKzZ8+KXHmDBg0QFRWFDRs2oEaNGpgxYwYWLFiAXr16ycqMGzcOI0aMwJAhQ1C/fn3cvXsXMTExfMYeERFpjSZzHRERka6o3dmrWbMmJk+eDEdHR3z66afYvn27wsNm1dGuXTucO3cOb968waVLl2SPXcghkUgQEhKC+/fv482bN4iPj0eNGjUKXR8REVFBNJ3riIiIdEHtzt4PP/yAu3fvYseOHbC2tkZwcDAcHR3x5ZdfIj4+XhsxEhERFSvmOiIiMgRqd/aAt9cvBAUFYfXq1fjvv//w448/4vjx42jevLmm4yMiItIJ5joiIirp1L5By7uSk5OxceNG/Prrrzh79iwaNGigqbiIiIj0AnMdERGVVGp39p4/f46tW7di/fr1iIuLQ6VKldCzZ09s3LgRnp6e2oiRiIioWDHXEZGhm7nrYp7zjEQWvAHM3XsZ2RLj4guKNE7tzp6DgwNsbW3RrVs3hIWF8QgnEREZHOY6IiIyBGp19oQQWLhwIXr37g0LCwttxURERKQzzHVERGQo1LpBixACX3/9Ne7evauteIiIiHSKuY6IiAyFWp09IyMjVK5cGSkpKdqKh4iISKeY64iIyFCo/eiFiIgIjB07FufPn9dGPERERDrHXEdERIZA7Ru09O7dG69evULt2rVhamoKc3NzufmPHz/WWHBERES6wFxHRESGQO3O3oIFC7QQBhERkf5griMiIkOgdmcvODhYG3EQERHpDeY6IiIyBGpfswcAN27cwOTJk9GjRw88ePAAABAdHY0LFy5oNDgiIiJdYa4jIqKSTu3OXnx8PGrWrIljx45h27ZtePHiBQDg7NmzmDZtmsYDJCIiKm7MdUREZAjU7uyNHz8e3333HWJjY2Fqaiqb3qxZMxw5ckSjwREREekCcx0RERkCta/ZO3fuHNavX68wvXz58nwmERERGQTmOgO0P7xo7282QTNxEFGRzdx1UWGakciCN4C5ey8jW2Kc53sntfXWYmT6R+0ze2XKlMH9+/cVpp85cwYuLi4aCYqIiEiXmOuIiMgQqN3Z69mzJ7799lskJydDIpEgOzsbhw4dwpgxY9CnTx9txEhERFSsmOuIiMgQqN3ZmzlzJipWrAgXFxe8ePEC3t7eaNq0Kfz8/DB58mRtxEhERFSsmOuIiMgQqH3NnomJCdatW4cZM2bg9OnTyM7Oho+PDypXrqyN+IiIiIodcx0RERkCtTt7OSpVqoRKlSohKysL586dw5MnT2Bra6vJ2IiIiHSKuY6IiEoytYdxjhgxAqtWrQIAZGVlwd/fH3Xr1oWrqyvi4uI0HR8REVGxY64jIiJDoHZnb8uWLahduzYA4I8//sDNmzdx+fJljBgxApMmTdJ4gERERMWNuY6IiAyB2p29R48ewdHREQCwe/dudOvWDVWqVMGAAQNw7tw5jQdIRERU3DSZ6w4cOID27dvD2dkZEokE27dvl5svhEBISAicnZ1hbm6OgIAAXLhwQVOrQkRE7zG1O3sODg64ePEisrKyEB0djY8//hgA8OrVKxgb5/0AQyIiopJCk7nu5cuXqF27NhYvXqx0fkREBObNm4fFixfjxIkTcHR0RGBgIFJTU4u8HkRE9H5T+wYt/fr1Q7du3eDk5ASJRILAwEAAwLFjx+Dl5aXxAImIiIqbJnNd69at0bp1a6XzhBBYsGABJk2ahM6dOwMA1qxZAwcHB6xfvx6DBg1S+r60tDSkpaXJXj9//hwAkJGRgYyMjHzjyZlfUDl9obF4hdrHt3MHokbR97SNi1FJi1kf4zUSWfnMy5b7tyRQNWZ9+QwKu02oW17tzl5ISAhq1KiBO3fuoGvXrpBKpQAAY2NjjB8/Xt3FERER6Z3iynWJiYlITk5GUFCQbJpUKoW/vz8OHz6cZ2cvPDwcoaGhCtNjYmJgYWGhUt2xsbGFC1pHih5vEQ9I796t9lvevzYufiUtZn2K11uFMl7ZSdoOQ+MKinn37pvFE4iK1N0mXr16pVb5Qj16oUuXLgrTgoODC7MoIiIivVQcuS45ORnA22Gj73JwcMCtW7fyfN+ECRMwatQo2evnz5/D1dUVQUFBsLGxybfOjIwMxMbGIjAwECYmJkWIvnhoLN6D84oWSJNRBZf5f2rHXFBsatRdGCVtmwBKXszK4p2797KOo8qbkciGV3YSLhu5I1tSxLPixUTVmMe01I+RiIXdhnNGcqiqUJ29v/76C/Pnz8elS5cgkUjg5eWFESNGyK5pICIiKumKM9dJJBK510IIhWnvkkqlsrON7zIxMVH5R4M6ZfVBkeOVFHE4WiHqVjnmgmIrps+ppG0TQMmL+d14syX6f6+LbIlRiYjzXQXFrG/bi7rbsLrxq91VX7x4MVq1agVra2sMHz4cw4YNg42NDdq0aZPnxedEREQlSXHlupw7fuac4cvx4MEDhbN9RERE6lL7zF54eDjmz5+Pr7/+WjZt2LBhaNy4MWbOnCk3nYiIqCQqrlzn4eEBR0dHxMbGwsfHBwCQnp6O+Ph4zJ49WyN1EBHR+0vtM3vPnz9Hq1atFKYHBQWpPYaUiIhIH2ky17148QIJCQlISEgA8PamLAkJCbh9+zYkEglGjBiBsLAwREVF4fz58+jbty8sLCzQs2dPTawKERG9x9Tu7HXo0AFRUVEK03fs2IH27dtrJCgiIiJd0mSuO3nyJHx8fGRn7kaNGgUfHx9MnToVADBu3DiMGDECQ4YMQf369XH37l3ExMTA2tq66CtCRETvNZWGcf7www+y/1erVg0zZ85EXFwcfH19AQBHjx7FoUOHMHr0aO1ESUREpGXaynUBAQEQQuQ5XyKRICQkBCEhIYWKm4iIKC8qdfbmz58v99rW1hYXL17ExYsXZdPKlCmDn3/+GZMnT9ZshERERMWAuY6IiAyNSp29xMREbcdBRESkU8x1RERkaAr9lMRHjx4hJSVFk7EQERHpFeY6IiIqydTq7D19+hRDhw5FuXLl4ODgAHt7e5QrVw5ff/01nj59qqUQiYiIig9zHRERGQqVn7P3+PFj+Pr64u7du+jVqxeqVasGIQQuXbqE1atX46+//sLhw4dha2urzXiJiIi0hrmOiIgMicpn9qZPnw5TU1PcuHEDP/74I0aMGIGRI0dixYoVuH79OkxMTDB9+vRCBxIeHi573lAOIQRCQkLg7OwMc3NzBAQE4MKFC4Wug4iIKD/aznVERETFSeXO3vbt2zF37lw4ODgozHN0dERERITSZxKp4sSJE1ixYgVq1aolNz0iIgLz5s3D4sWLceLECTg6OiIwMBCpqamFqoeIiCg/2sx1RERExU3lYZz3799H9erV85xfo0YNJCcnqx3Aixcv0KtXL/z000/47rvvZNOFEFiwYAEmTZqEzp07AwDWrFkDBwcHrF+/HoMGDVK6vLS0NKSlpcleP3/+HACQkZGBjIwMteNTVc6ytVmHoWLbKTISWSqWy5b7911sz7xxmys8fW+7osalrVxHRESkCyp39sqVK4ekpCRUqFBB6fzExESULVtW7QCGDh2Ktm3b4uOPP5br7CUmJiI5ORlBQUGyaVKpFP7+/jh8+HCenb3w8HCEhoYqTI+JiYGFhYXa8akrNjZW63UYKrbd/3irWd4rO0lh2u7dNzUSiyHjNld4+tp2r169KtL7tZXriIiIdEHlzl6rVq0wadIkxMbGwtTUVG5eWloapkyZglatWqlV+caNG3H69GmcOHFCYV7OkdPcQ2kcHBxw69atPJc5YcIEjBo1Svb6+fPncHV1RVBQEGxsbNSKTx0ZGRmIjY1FYGAgTExMtFaPIWLbKZq797JK5YxENryyk3DZyB3ZEvlR2WNaemkjNIPAba7w9L3tckZzFJY2ch0REZGuqNzZCw0NRf369VG5cmUMHToUXl5vf0hevHgRS5cuRVpaGtauXatyxXfu3MHw4cMRExMDMzOzPMtJJBK510IIhWnvkkqlkEqlCtNNTEyK5YdJcdVjiNh2/5MtMVazvJHCe9iWBeM2V3j62nZFjUnTuY6IiEiXVO7sVahQAUeOHMGQIUMwYcIECCEAvO2MBQYGYvHixXB1dVW54lOnTuHBgweoV6+ebFpWVhYOHDiAxYsX48qVKwDenuFzcnKSlXnw4IHSC+eJiIiKStO5joiISJdU7uwBgIeHB/bs2YMnT57g2rVrAABPT0/Y2dmpXXGLFi1w7tw5uWn9+vWDl5cXvv32W1SqVAmOjo6IjY2Fj48PACA9PR3x8fGYPXu22vURERGpQpO5joiISJfU6uzlsLW1xYcfflikiq2trVGjRg25aZaWlihbtqxs+ogRIxAWFobKlSujcuXKCAsLg4WFBXr27FmkuomIiAqiiVxHRESkS4Xq7BWXcePG4fXr1xgyZAiePHmChg0bIiYmBtbW1roOjYiIiIiISK/pVWcvLi5O7rVEIkFISAhCQkJ0Eg8RERFRke0P13UE+Ts4D4DX238lis9tRbMJxR4SkbbM3HWxSO+f1FbdB2Tpll519ohIdU3uroSQGOOp/Ufwu/8LJAoPYp+nk7iIiIiISD8YFVwEqFu3Lp48eQIAmD59epEfWktERKRvmOuIiMjQqNTZu3TpEl6+fAng7TOIXrx4odWgiIiIihtzHRERGRqVhnHWqVMH/fr1w0cffQQhBObOnQsrKyulZadOnarRAImIiIoDcx0RERkalTp7q1evxrRp07Bz505IJBLs2bMHpUopvlUikTABEhFRicRcR0REhkalzl7VqlWxceNGAICRkRH++usv2NvbazUwIiKi4sRcR0REhkbtu3FmZyu5JS8REZEBYa4jIiJDUKhHL9y4cQMLFizApUuXIJFIUK1aNQwfPhwffPCBpuMjIiLSCeY6IiIq6VS6G+e79u7dC29vbxw/fhy1atVCjRo1cOzYMVSvXh2xsbHaiJGIiKhYMdcREZEhUPvM3vjx4zFy5EjMmjVLYfq3336LwMBAjQVHRESkC8x1RERkCNTu7F26dAmbN29WmN6/f38sWLBAEzERkSbsD89/frMJxRMHUQnEXEdERIZA7c5e+fLlkZCQgMqVK8tNT0hI4F3LiIjIIDDXkdrePcAmjAB4AQfnARIN3OynoIN3BeHBPaL3ltqdvYEDB+LLL7/EzZs34efnB4lEgr///huzZ8/G6NGjtREjERFRsWKuIyIiQ6B2Z2/KlCmwtrbG999/jwkT3h4pcnZ2RkhICIYNG6bxAImIiIobcx0RERkCtTt7EokEI0eOxMiRI5GamgoAsLa21nhgREREusJcR0REhqBQz9nLwcRHRESGjrmOiIhKKrWfs0dERERERET6j509IiIiIiIiA8TOHhERERERkQFSq7OXkZGBZs2a4erVq9qKh4iISKeY64iIyFCo1dkzMTHB+fPnIZFItBUPERGRTjHXERGRoVB7GGefPn2watUqbcRCRESkF5jriIjIEKj96IX09HSsXLkSsbGxqF+/PiwtLeXmz5s3T2PBERER6QJznQ7sD1c+XRgB8Cr8+6noCmrbZhOKJw4iUpvanb3z58+jbt26AKBwPQOHvBARkSFgriMiIkOgdmdv//792oiDiIhIbzDXERGRISj0oxeuX7+OvXv34vXr1wAAIYTGgiIiItIHzHVERFSSqd3ZS0lJQYsWLVClShW0adMG9+/fBwB88cUXGD16tMYDJCIiKm7MdUREZAjU7uyNHDkSJiYmuH37NiwsLGTTu3fvjujoaI0GR0REpAvMdUREZAjUvmYvJiYGe/fuRYUKFeSmV65cGbdu3dJYYERERLrCXEdERIZA7TN7L1++lDvKmePRo0eQSqUaCYqIiEiXmOuIiMgQqN3Za9q0KX755RfZa4lEguzsbMyZMwfNmjXTaHBERES6UJy5LiQkBBKJRO7P0dFRo3UQEdH7Se1hnHPmzEFAQABOnjyJ9PR0jBs3DhcuXMDjx49x6NAhbcRIRERUrIo711WvXh1//vmn7LWxsbHG6yAioveP2p09b29vnD17FsuWLYOxsTFevnyJzp07Y+jQoXByctJGjERERMWquHNdqVKleDaPiIg0Tu3OHgA4OjoiNDRU07EQERHpjeLMddeuXYOzszOkUikaNmyIsLAwVKpUKc/yaWlpSEtLk71+/vw5ACAjIwMZGRn51pUzv6ByxU4ov7Ik4/+nFxhvHu/XGDXql8Ws7ZhUVdA2UdR4dbAt6e12nAdl8RqJLF2FUyAjkS33b0lQXDFrapsr7DasbvlCdfaePHmCVatW4dKlS5BIJKhWrRr69esHOzu7wiyOiIhI7xRXrmvYsCF++eUXVKlSBf/99x++++47+Pn54cKFCyhbtqzS94SHhyvtiMbExCi9sYwysbGxRYpb87zynVtwvPm/v8h271a7/tgXVbQTi7oKjP1tnIWOt8Dla4/+bcf5ezdebx3GoSqv7CRdh6A2bce8e/dNjS5P3W341atXapVXu7MXHx+Pjh07wsbGBvXr1wcA/PDDD5g+fTp+//13+Pv7q7tIIiIivVKcua5169ay/9esWRO+vr744IMPsGbNGowaNUrpeyZMmCA37/nz53B1dUVQUBBsbGzyrS8jIwOxsbEIDAyEiYmJZlZCEw7OUzo5Qxgh9kWVguPN4/0a00T5Z6GsflnMVldhItGDMyMFxJ5xYEHR4i2obbRAH7bjuXsvq1zWSGTDKzsJl43ckS3RkzO++Shp8QLFF/OYlpo5sFTYbThnJIeq1O7sDR06FN26dZNdxwAAWVlZGDJkCIYOHYrz58+ru0giIiK9ostcZ2lpiZo1a+LatWt5lpFKpUofAWFiYqLyjwZ1yhaLAjoZBcar7U5VQW2lpH4TSbZ+dPZUjL3Q8epwO9LldpwtUf9GStkSo0K9T1dKWryA9mPW9Pam7jasbv1qd3tv3LiB0aNHy90pzNjYGKNGjcKNGzfUXRwREZHe0WWuS0tLw6VLl3jTMyIiKjK1O3t169bFpUuXFKZfunQJderUUWtZ4eHhaNCgAaytrWFvb49PPvkEV65ckSsjhEBISAicnZ1hbm6OgIAAXLhwQd2wiYiIVKbJXFeQMWPGID4+HomJiTh27Bi6dOmC58+fIzg4WKP1EBHR+0elYZxnz56V/X/YsGEYPnw4rl+/jkaNGgEAjh49iiVLlmDWrFlqVR4fH4+hQ4eiQYMGyMzMxKRJkxAUFISLFy/C0tISABAREYF58+Zh9erVqFKlCr777jsEBgbiypUrsLa2Vqs+IiKivGgr1xXk33//RY8ePfDo0SOUL18ejRo1wtGjR+Hm5qbReoiI6P2jUmevTp06kEgkEELIpo0bN06hXM+ePdG9e3eVK4+OjpZ7HRkZCXt7e5w6dQpNmzaFEAILFizApEmT0LlzZwDAmjVr4ODggPXr12PQoEEq10VERJQfbeW6gmzcuFFjyyIiInqXSp29xMREbccBAHj27BkAyG5rnZiYiOTkZAQFBcnKSKVS+Pv74/Dhw0o7e0V59lBRlLTnvegTtp0iVZ69IyTGEP9/AbJQciFygc9Leo/bm9tc4el72xUlruLKdURERMVFpc5ecQwlEUJg1KhR+Oijj1CjRg0AQHJyMgDAwcFBrqyDgwNu3bqldDmaePZQUZS0573oE7bd/6jy7J2n9h/J/v+svK/C/N2pBSxAh89F0hfc5gpPX9tO3ecPvYvDJomIyNAU6qHqd+/exaFDh/DgwQNkZ8vfonfYsGGFCuTrr7/G2bNn8ffffyvMk0gkcq+FEArTchTl2UNFoQ/Peymp2HaKVHl2j9/9XyAkxnhW3helHx6BJNfZQL8PyuW/AB08F0lfcJsrPH1vO3WfP5QfbeQ6IiKi4qR2Zy8yMhJfffUVTE1NUbZsWblOl0QiKVQC/Oabb/D777/jwIEDqFChgmy6o6MjgLdn+N69BfWDBw8Uzvbl0MSzh4pC755bVIKw7f5HlefDvNu5k4gshc5egc9KYltzmysCfW07TcWkjVxHRERU3NTu7E2dOhVTp07FhAkTYGRUtKfTCyHwzTffICoqCnFxcfDw8JCb7+HhAUdHR8TGxsLHxwcAkJ6ejvj4eMyePbtIdRMREeVFk7mO/t/+cF1HoFUHrj2U/V9IjAF74PCNRwoH4vLStHJ5bYVm0ObuvVykB2hPaqvKhRNEJZfanb1Xr17hs88+00jyGzp0KNavX48dO3bA2tpado1e6dKlYW5uDolEghEjRiAsLAyVK1dG5cqVERYWBgsLC/Ts2bPI9RMRESmjyVxHRESkK2p39gYMGIDffvsN48ePL3Lly5YtAwAEBATITY+MjETfvn0BvL3t9evXrzFkyBA8efIEDRs2RExMDJ+xRwatyd2Vug6B6L2myVxHRESkK2p39sLDw9GuXTtER0ejZs2aCtdHzJs3T+Vlvfsso7xIJBKEhIQgJCRE3VCJiIgKRZO5joiISFfU7uyFhYVh7969qFq1KgAoXLRORERU0jHXERGRIVC7szdv3jz8/PPPsmGWREREhoa5joiIDIHaV55LpVI0btxYG7EQERHpBeY6IiIyBGp39oYPH45FixZpIxYiIiK9wFxHRESGQO1hnMePH8e+ffuwc+dOVK9eXeGi9W3btmksOCIiIl1griMiIkOgdmevTJky6Ny5szZiISIi0gvMdUREZAjU7uxFRkZqIw4iIiK9wVxHRESGQO1r9oiIiIiIiEj/qX1mz8PDI99nDN28ebNIAREREenae5vr9ofnP7/ZhKK9vygOzgMk2dpbfkG0uW4ADlx7qLVlH3x1Md/548y1VjUR6Zjanb0RI0bIvc7IyMCZM2cQHR2NsWPHaiouIiIinWGuIyIiQ6B2Z2/48OFKpy9ZsgQnT54sckBEJd3MXfkfQVVFEw3EQUSFx1xHRESGQGPX7LVu3Rpbt27V1OKIiIj0DnMdERGVJBrr7G3ZsgV2dnaaWhwREZHeYa4jIqKSRO1hnD4+PnIXrQshkJycjIcPH2Lp0qUaDY6IiEgXmOuIiMgQqN3Z++STT+ReGxkZoXz58ggICICXl5em4iIiItIZ5joiIjIEanf2pk2bpo04iEjDCrqNd0G34s4xqa23JsIhKlGY64iIyBDwoepEREREREQGSOUze0ZGRvk+YBYAJBIJMjMzixwUERGRLjDXERGRIVG5sxcVFZXnvMOHD2PRokUQQmgkKCIiIl1griMiIkOicmevY8eOCtMuX76MCRMm4I8//kCvXr0wY8YMjQZHRERUnJjriIjIkKh9gxYAuHfvHqZNm4Y1a9agZcuWSEhIQI0aNTQdGxFpUZO7K/Odf9Dli2KKhEg/MdcpsT9cq4tXdmMpITEG7IHDNx5BIrK0VnfTyuW1tmxdK2h/D08H7VVe0DbTbIL26lbBzF2q3ayMqKRS6wYtz549w7fffgtPT09cuHABf/31F/744w8mPyIiMhjMdUREZChUPrMXERGB2bNnw9HRERs2bFA61IWIiKgkY64jIiJDonJnb/z48TA3N4enpyfWrFmDNWvWKC23bds2jQVHRERUnJjriIjIkKjc2evTp0+Bt6MmIiIqyZjriIjIkKjc2Vu9erUWwyAiItI95joiIjIkat2ghYiIiIiIiEoGdvaIiIiIiIgMUKGes0dE7w9NPINoUltvDURCREREROrgmT0iIiIiIiIDxM4eERERERGRAeIwTiIiInrvHbj2UNchlFz7wwv91sJeKmAkssALBEgXinp5S3Ff2sIze0RERERERAaIZ/aISOt4kxciIiKi4scze0RERERERAaIZ/aISKkmd1cWWOagyxfFEAkRERERFQbP7BERERERERkgdvaIiIiIiIgMEIdx0vunCLeIlmk2Id/ZqgyBNAQFrSeHeRIRERHpTok4s7d06VJ4eHjAzMwM9erVw8GDB3UdEhERkUYx1xERkabp/Zm9TZs2YcSIEVi6dCkaN26MH3/8Ea1bt8bFixdRsWLFYoujoFvH5zzcc+7ey8iWGOdZThO3jy/Rt7FXdlZNGAHwAg7OAyTZxR5SoeRzdrDJXT6YN4cmz/wVdrt/N4amlcu//c+721zzbwu1XJJXovdLekBfch0RERkWvT+zN2/ePAwYMABffPEFqlWrhgULFsDV1RXLli3TdWhEREQawVxHRETaoNdn9tLT03Hq1CmMHz9ebnpQUBAOHz6s9D1paWlIS0uTvX727BkA4PHjx8jIyCh8LC+f5TvfSGTjVfYrpBs9R7Yk7z50SkpKoWNQNRZVaCKOQnmRrjApQxjh1atXSJGkw6SknNnLx4s3mcVWl5AIvHr1CqXeZEIisoqtXk3RxLZckHc/j5T/3/7ktjldfRdKqIyMjLdtl5ICExMT2XR92S+lpqYCAIQQRV5WcSnuXJfXZwhA6T66OCnbf5bE/VxJiznlRbrO8nD668LtO1T93aUvGK/2lZSYc3JdvvvifKib5/S6s/fo0SNkZWXBwcFBbrqDgwOSk5OVvic8PByhoaEK0z08PLQSo7qm6zqA/6cvcdD7bpGuAwAwVdcB0P/T5H4pNTUVpUuX1uAStccQcx2R6kJ0HQBRsdJUrlM1z+l1Zy+HRCKRey2EUJiWY8KECRg1apTsdXZ2Nh4/foyyZcvm+R5NeP78OVxdXXHnzh3Y2NhorR5DxLYrPLZd4bDdCk/f204IgdTUVDg7O+s6FLUVV67T988wt5IWL1DyYi5p8QIlL2bGq30lLebCxqtuntPrzl65cuVgbGyscGTzwYMHCkdAc0ilUkilUrlpZcqU0VaICmxsbErEBqaP2HaFx7YrHLZb4elz25WUM3o5dJXr9PkzVKakxQuUvJhLWrxAyYuZ8WpfSYu5MPGqk+f0d0ArAFNTU9SrVw+xsbFy02NjY+Hn56ejqIiIiDSHuY6IiLRFr8/sAcCoUaPw+eefo379+vD19cWKFStw+/ZtfPXVV7oOjYiISCOY64iISBv0vrPXvXt3pKSkYPr06bh//z5q1KiB3bt3w83NTdehyZFKpZg2bZrCsBoqGNuu8Nh2hcN2Kzy2nXYUZ64raZ9hSYsXKHkxl7R4gZIXM+PVvpIWc3HFKxEl6f7UREREREREpBK9vmaPiIiIiIiICoedPSIiIiIiIgPEzh4REREREZEBYmePiIiIiIjIALGzpwVJSUkYMGAAPDw8YG5ujg8++ADTpk1Denq6rkPTezNnzoSfnx8sLCzUfkDw+2bp0qXw8PCAmZkZ6tWrh4MHD+o6JL134MABtG/fHs7OzpBIJNi+fbuuQyoRwsPD0aBBA1hbW8Pe3h6ffPIJrly5ouuwSA2F2bcKIRASEgJnZ2eYm5sjICAAFy5c0G6g/+/Jkyf4/PPPUbp0aZQuXRqff/45nj59mu97+vbtC4lEIvfXqFEjrcWo7j44Pj4e9erVg5mZGSpVqoTly5drLTZl1Ik3Li5OoS0lEgkuX75cLLEWZl+t6/ZVN2ZdtnFh9+m6bOPCxKzLNl62bBlq1aole2C6r68v9uzZk+97tNW+7OxpweXLl5GdnY0ff/wRFy5cwPz587F8+XJMnDhR16HpvfT0dHTt2hWDBw/WdSh6bdOmTRgxYgQmTZqEM2fOoEmTJmjdujVu376t69D02suXL1G7dm0sXrxY16GUKPHx8Rg6dCiOHj2K2NhYZGZmIigoCC9fvtR1aKSiwuxbIyIiMG/ePCxevBgnTpyAo6MjAgMDkZqaqsVI3+rZsycSEhIQHR2N6OhoJCQk4PPPPy/wfa1atcL9+/dlf7t379ZKfOrugxMTE9GmTRs0adIEZ86cwcSJEzFs2DBs3bpVK/EVNd4cV65ckWvPypUrF0u86u6rdd2+QOHziy7auDD7dF23cVHykC7auEKFCpg1axZOnjyJkydPonnz5ujYsWOeB8y02r6CikVERITw8PDQdRglRmRkpChdurSuw9BbH374ofjqq6/kpnl5eYnx48frKKKSB4CIiorSdRgl0oMHDwQAER8fr+tQSE2q7luzs7OFo6OjmDVrlmzamzdvROnSpcXy5cu1GKEQFy9eFADE0aNHZdOOHDkiAIjLly/n+b7g4GDRsWNHrcaWQ9198Lhx44SXl5fctEGDBolGjRppLcZ3qRvv/v37BQDx5MmTYoguf6rsq3XdvrmpErM+tbEq+3R9a2NVYtanNhZCCFtbW7Fy5Uql87TZvjyzV0yePXsGOzs7XYdBBiA9PR2nTp1CUFCQ3PSgoCAcPnxYR1HR++TZs2cAwH2aAUtMTERycrLcfkYqlcLf31/r+5kjR46gdOnSaNiwoWxao0aNULp06QLrjouLg729PapUqYKBAwfiwYMHGo+vMPvgI0eOKJRv2bIlTp48iYyMDI3H+K6i5AwfHx84OTmhRYsW2L9/vzbDLBJdtm9R6UMbq7JP17c2VicP6bqNs7KysHHjRrx8+RK+vr5Ky2izfdnZKwY3btzAokWL8NVXX+k6FDIAjx49QlZWFhwcHOSmOzg4IDk5WUdR0ftCCIFRo0bho48+Qo0aNXQdDmlJzr5EF/uZ5ORk2NvbK0y3t7fPt+7WrVtj3bp12LdvH77//nucOHECzZs3R1pamkbjK8w+ODk5WWn5zMxMPHr0SKPx5VaYeJ2cnLBixQps3boV27ZtQ9WqVdGiRQscOHBAq7EWli7bt7D0pY1V3afrUxurGrOu2/jcuXOwsrKCVCrFV199haioKHh7eystq832LVWkd79nQkJCEBoamm+ZEydOoH79+rLX9+7dQ6tWrdC1a1d88cUX2g5RLxWm3ahgEolE7rUQQmEakaZ9/fXXOHv2LP7++29dh/LeK459qyb3M6rGq6xeVeru3r277P81atRA/fr14ebmhl27dqFz586Fijk/6raNsvLKpmuLOvFWrVoVVatWlb329fXFnTt3MHfuXDRt2lSrcRaWrttXXfrSxurs0/WljVWNWddtXLVqVSQkJODp06fYunUrgoODER8fn2eHT1vty86eGr7++mt89tln+ZZxd3eX/f/evXto1qwZfH19sWLFCi1Hp7/UbTfKX7ly5WBsbKxwRPbBgwcKR4WINOmbb77B77//jgMHDqBChQq6Due9p819q6OjI4C3R5udnJxk04uyn1E13rNnz+K///5TmPfw4UO16nZycoKbmxuuXbumdqz5Kcw+2NHRUWn5UqVKoWzZshqNLzdN5YxGjRrh119/1XR4GqHL9tWk4m5jdfbp+tLGRc1DxdnGpqam8PT0BADUr18fJ06cwMKFC/Hjjz8qlNVm+7Kzp4Zy5cqhXLlyKpW9e/cumjVrhnr16iEyMhJGRu/viFl12o0KZmpqinr16iE2NhadOnWSTY+NjUXHjh11GBkZKiEEvvnmG0RFRSEuLg4eHh66Domg3X2rh4cHHB0dERsbCx8fHwBvr/2Kj4/H7NmzC7VMVeP19fXFs2fPcPz4cXz44YcAgGPHjuHZs2fw8/NTub6UlBTcuXNHrrOqCYXZB/v6+uKPP/6QmxYTE4P69evDxMREo/FpIl5lzpw5o/G21BRdtq8mFVcbF2afrus21lQe0uV2LITIc1i5Vtu3yLd4IQV3794Vnp6eonnz5uLff/8V9+/fl/1R/m7duiXOnDkjQkNDhZWVlThz5ow4c+aMSE1N1XVoemXjxo3CxMRErFq1Sly8eFGMGDFCWFpaiqSkJF2HptdSU1Nl2xQAMW/ePHHmzBlx69YtXYem1wYPHixKly4t4uLi5PZnr1690nVopCJV9q1Vq1YV27Ztk72eNWuWKF26tNi2bZs4d+6c6NGjh3BychLPnz/XerytWrUStWrVEkeOHBFHjhwRNWvWFO3atZMr8268qampYvTo0eLw4cMiMTFR7N+/X/j6+goXFxetxFvQPnj8+PHi888/l5W/efOmsLCwECNHjhQXL14Uq1atEiYmJmLLli0aj00T8c6fP19ERUWJq1evivPnz4vx48cLAGLr1q3FEm9B+2p9a9/CxKzLNlZln65vbVyYmHXZxhMmTBAHDhwQiYmJ4uzZs2LixInCyMhIxMTEKI1Vm+3Lzp4WREZGCgBK/yh/wcHBSttt//79ug5N7yxZskS4ubkJU1NTUbduXd4GXwU5t2HO/RccHKzr0PRaXvuzyMhIXYdGKlJl35r7M83OzhbTpk0Tjo6OQiqViqZNm4pz584VS7wpKSmiV69ewtraWlhbW4tevXop3D793XhfvXolgoKCRPny5YWJiYmoWLGiCA4OFrdv39ZajPntg4ODg4W/v79c+bi4OOHj4yNMTU2Fu7u7WLZsmdZiK2q8s2fPFh988IEwMzMTtra24qOPPhK7du0qtlgL2lfrY/uqG7Mu21iVfbq+tXFhYtZlG/fv31/2fStfvrxo0aKFrKOnLFYhtNe+EiH+/+o/IiIiIiIiMhjv74VkREREREREBoydPSIiIiIiIgPEzh4REREREZEBYmePiIiIiIjIALGzR0REREREZIDY2SMiIiIiIjJA7OwREREREREZIHb2iIiIiIiIDBA7e6SX3N3dsWDBAl2HoTFxcXGQSCR4+vSprkMpMolEgu3bt+c5PykpCRKJBAkJCRqtt6Btom/fvpBIJAXGVxQBAQEYMWKE3OucOjW9viXFgQMH0L59ezg7O2u17XOEhITI2jznz9HRUat1EmkLc53+Yq4bIfeaua54cx0A3L17F71790bZsmVhYWGBOnXq4NSpU2ovh509KlZ37tzBgAED4OzsDFNTU7i5uWH48OFISUnRdWgak3snCQB+fn64f/8+SpcurdW6300CpUqVQsWKFTF48GA8efJEY3Xcv38frVu31tjyNKlVq1bFGt+2bdtw/PjxYqlLX718+RK1a9fG4sWLi63O6tWr4/79+7K/c+fOFVvdRKpgrmOu0ybmuuJX3LnuyZMnaNy4MUxMTLBnzx5cvHgR33//PcqUKaP2skppPjwi5W7evAlfX19UqVIFGzZsgIeHBy5cuICxY8diz549OHr0KOzs7HQSW1ZWFiQSCYyMtHP8w9TUtNjOPrRq1QqRkZHIzMzExYsX0b9/fzx9+hQbNmzQyPL1+SyKVCotML6MjAyYmJhopD47Ozs8f/5cI8sqqVq3bp3vD4709HRMnjwZ69atw9OnT1GjRg3Mnj0bAQEBha6zVKlSer0d0vuNuY65TtuY64pfcee62bNnw9XVFZGRkbJp7u7uhVoWz+xRsRk6dChMTU0RExMDf39/VKxYEa1bt8aff/6Ju3fvYtKkSXLlU1NT0bNnT1hZWcHZ2RmLFi2Smx8SEoKKFStCKpXC2dkZw4YNk81LT0/HuHHj4OLiAktLSzRs2BBxcXGy+atXr0aZMmWwc+dOeHt7QyqV4qeffoKZmZnC8JNhw4bB398fAJCSkoIePXqgQoUKsLCwQM2aNeUSS9++fREfH4+FCxfKjjomJSUpHdqydetWVK9eHVKpFO7u7vj+++/l6nV3d0dYWBj69+8Pa2trVKxYEStWrCiwnXOSQIUKFRAUFITu3bsjJiZGrkxkZCSqVasGMzMzeHl5YenSpXJt9/XXX8PJyQlmZmZwd3dHeHi4bH7u4QvHjx+Hj48PzMzMUL9+fZw5c0aurpy2ftf27dshkUhkr2/cuIGOHTvCwcEBVlZWaNCgAf78888C17UgOcNsNm/ejICAAJiZmeHXX38t8HME3h7F69OnD6ysrODk5KTw+ZBq+vXrh0OHDmHjxo04e/YsunbtilatWuHatWuFXua1a9fg7OwMDw8PfPbZZ7h586YGIyYqGuY65roczHXvD03nut9//x3169dH165dYW9vDx8fH/z000+FC04QFYOUlBQhkUhEWFiY0vkDBw4Utra2Ijs7WwghhJubm7C2thbh4eHiypUr4ocffhDGxsYiJiZGCCHEb7/9JmxsbMTu3bvFrVu3xLFjx8SKFStky+vZs6fw8/MTBw4cENevXxdz5swRUqlUXL16VQghRGRkpDAxMRF+fn7i0KFD4vLly+LFixfCwcFBrFy5UraczMxM4eDgIH788UchhBD//vuvmDNnjjhz5oy4ceOGLK6jR48KIYR4+vSp8PX1FQMHDhT3798X9+/fF5mZmWL//v0CgHjy5IkQQoiTJ08KIyMjMX36dHHlyhURGRkpzM3NRWRkpKxuNzc3YWdnJ5YsWSKuXbsmwsPDhZGRkbh06VKe7RwcHCw6gFtTxwAAfIFJREFUduwoe33jxg3h7e0tHBwcZNNWrFghnJycxNatW8XNmzfF1q1bhZ2dnVi9erUQQog5c+YIV1dXceDAAZGUlCQOHjwo1q9fL3s/ABEVFSWEEOLFixeifPnyonv37uL8+fPijz/+EJUqVRIAxJkzZ2RtXbp0abk4o6KixLu7n4SEBLF8+XJx9uxZcfXqVTFp0iRhZmYmbt26Jdce8+fPV3ndhRAiMTFRABDu7u6y9b17926Bn6MQQgwePFhUqFBBxMTEiLNnz4p27doJKysrMXz4cKV15Kzv++zdbUMIIa5fvy4kEom4e/euXLkWLVqICRMmFKqO3bt3iy1btoizZ8+K2NhY4e/vLxwcHMSjR4+KEjqRRjDXMde9i7nOMBVHrpNKpUIqlYoJEyaI06dPi+XLlwszMzOxZs0a9eMtVAREajp69KjCl+Nd8+bNEwDEf//9J4R4u7Nr1aqVXJnu3buL1q1bCyGE+P7770WVKlVEenq6wrJU+dJFRkYKACIhIUGuzLBhw0Tz5s1lr/fu3StMTU3F48eP81y3Nm3aiNGjR8te+/v7K+wkcyfAnj17isDAQLkyY8eOFd7e3rLXbm5uonfv3rLX2dnZwt7eXixbtizPWIKDg4WxsbGwtLQUZmZmAoAAIObNmycr4+rqKpfQhBBixowZwtfXVwghxDfffCOaN28u+zGS27uf448//ijs7OzEy5cvZfOXLVumdgJUxtvbWyxatEj2uigJcMGCBfnWJYT855iamipMTU3Fxo0bZfNTUlKEubk5E2A+cn/HN2/eLAAIS0tLub9SpUqJbt26CSH+1375/Q0dOjTPOnN+uH7//ffaXj2iAjHXMde9i7nOMBVHrjMxMZFtqzm++eYb0ahRI7Xj5TV7pBfefncgN9zB19dXroyvr6/sDlVdu3bFggULUKlSJbRq1Qpt2rRB+/btUapUKZw+fRpCCFSpUkXu/WlpaShbtqzstampKWrVqiVXplevXvD19cW9e/fg7OyMdevWoU2bNrC1tQXw9nqHWbNmYdOmTbh79y7S0tKQlpYGS0tLtdb30qVL6Nixo9y0xo0bY8GCBcjKyoKxsTEAyMWXc9fBBw8e5LvsZs2aYdmyZXj16hVWrlyJq1ev4ptvvgEAPHz4UHbjgIEDB8rek5mZKbugvm/fvggMDETVqlXRqlUrtGvXDkFBQXmuR+3atWFhYSGblvtzU8XLly8RGhqKnTt34t69e8jMzMTr169x+/ZttZelTP369eVeF/Q53rhxA+np6XLrYmdnh6pVq2oknvdFdnY2jI2NcerUKdk2ncPKygoA4OLigkuXLuW7nJzvnzKWlpaoWbNmkYaFEhUX5jrmOuY6w6ONXOfk5ARvb2+5+dWqVcPWrVvVjo+dPSoWnp6ekEgkuHjxIj755BOF+ZcvX4atrS3KlSuX73JyEqSrqyuuXLmC2NhY/PnnnxgyZAjmzJmD+Ph4lb50AGBubi6XcAHgww8/xAcffICNGzdi8ODBiIqKkrs49vvvv8f8+fOxYMEC1KxZE5aWlhgxYgTS09PVag8hhELdOT8C3pX74mqJRILs7Ox8l21paQlPT08AwA8//IBmzZohNDQUM2bMkL33p59+QsOGDeXel9NWdevWRWJiIvbs2YM///wT3bp1w8cff4wtW7YoXY+CGBkZKZTLyMiQez127Fjs3bsXc+fOhaenJ8zNzdGlSxe12zUvuX+gFPQ5qrJeVDAfHx9kZWXhwYMHaNKkidIyJiYm8PLyKnQdaWlpuHTpUp7LJypOzHXymOuY694H2sh1jRs3xpUrV+SmXb16FW5ubmrHx84eFYuyZcsiMDAQS5cuxciRI2Fubi6bl5ycjHXr1qFPnz5ySeHo0aNyyzh69KjcF8Xc3BwdOnRAhw4dMHToUHh5eeHcuXMqfeny07NnT6xbtw4VKlSAkZER2rZtK5t38OBBdOzYEb179wbw9mjOtWvXUK1aNVkZU1NTZGVl5VuHt7c3/v77b7lphw8fRpUqVRSSdlFNmzYNrVu3xuDBg+Hs7AwXFxfcvHkTvXr1yvM9NjY26N69O7p3744uXbqgVatWePz4scId5Ly9vbF27Vq8fv1a9pnm/tzKly+P1NRUvHz5UpaIcj+n5+DBg+jbty86deoEAHjx4gWSkpKKuOZ5K+hz9PT0hImJCY4ePYqKFSsCeHsb5KtXr8puYEBvvXjxAtevX5e9TkxMREJCAuzs7FClShX06tULffr0wffffw8fHx88evQI+/btQ82aNdGmTRu16xszZgzat2+PihUr4sGDB/juu+/w/PlzBAcHa3K1iAqFuU4ec12CXBnmupKruHPdyJEj4efnh7CwMHTr1g3Hjx/HihUrVLp5UW68GycVm8WLFyMtLQ0tW7bEgQMHcOfOHURHRyMwMBAuLi6YOXOmXPlDhw4hIiICV69exZIlS/Dbb79h+PDhAN7e9WrVqlU4f/48bt68ibVr18Lc3Bxubm5yX7pt27YhMTERJ06cwOzZs7F79+4C4+zVqxdOnz6NmTNnokuXLjAzM5PN8/T0RGxsLA4fPoxLly5h0KBBSE5Olnu/u7s7jh07hqSkJDx69Ejp0cnRo0fjr7/+wowZM3D16lWsWbMGixcvxpgxYwrTtPkKCAhA9erVERYWBuDtnd3Cw8OxcOFCXL16FefOnUNkZCTmzZsHAJg/fz42btyIy5cv4+rVq/jtt9/g6Oio9NkuPXv2hJGREQYMGICLFy9i9+7dmDt3rlyZhg0bwsLCAhMnTsT169exfv16rF69Wq6Mp6cntm3bhoSEBPzzzz/o2bNngUd1i6Kgz9HKygoDBgzA2LFj8ddff+H8+fPo27ev1m5XXpKdPHkSPj4+8PHxAQCMGjUKPj4+mDp1KoC3d8Pr06cPRo8ejapVq6JDhw44duwYXF1dC1Xfv//+ix49eqBq1aro3LkzTE1NcfTo0UId7STSBua6/2GuWy1Xhrmu5CruXNegQQNERUVhw4YNqFGjBmbMmIEFCxbke/AiT2pf5UdUBElJSaJv377C0dFRmJiYCFdXV/HNN98o3EnPzc1NhIaGim7dugkLCwvh4OAgd+FxVFSUaNiwobCxsRGWlpaiUaNG4s8//5TNT09PF1OnThXu7u7CxMREODo6ik6dOomzZ88KIZRfSP2uBg0aCABi3759ctNTUlJEx44dhZWVlbC3txeTJ08Wffr0kbtY+sqVK6JRo0bC3NxcABCJiYkKF60LIcSWLVuEt7e3MDExERUrVhRz5sxRaIPcF2nXrl1bTJs2Lc+4lV24LYQQ69atE6ampuL27duy13Xq1BGmpqbC1tZWNG3aVGzbtk0I8fYOZnXq1BGWlpbCxsZGtGjRQpw+fVq2LOS6MPnIkSOidu3awtTUVNSpU0ds3bpV4SLuqKgo4enpKczMzES7du3EihUr5C5aT0xMFM2aNRPm5ubC1dVVLF68WOHi/6JctJ77gnJVPsfU1FTRu3dv2fYXERGh9IYEvGidiHJjrnsiK8dcx1xHuiURggN2iajk69u3L54+fSr3XKTikJSUBA8PD5w5cwZ16tQp1rqJiOj9wlxH6uJ5WiIyGDt37oSVlRV27txZLPW1bt0a1atXL5a6iIiIAOY6Ug/P7BGRQXjw4AGeP38O4O0ti9W9RXhh3L17F69fvwYAVKxYEaamplqvk4iI3l/MdaQudvaIiIiIiIgMEIdxEhERERERGSB29oiIiIiIiAwQO3tEREREREQGiJ09IiIiIiIiA8TOHhERERERkQFiZ4+IiIiIiMgAsbNHRERERERkgNjZIyIiIiIiMkDs7BERERERERkgdvaIiIiIiIgMEDt7REREREREBoidPSIiIiIiIgPEzh4REREREZEBYmePiIiIiIjIAGmls7d69WpIJBKYmZnh1q1bCvMDAgJQo0YNuWmTJk2Cj48P7OzsYGZmhkqVKuHLL79U+v7JkyejXbt2cHFxgUQiQd++fdWKz93dHSEhIQWWCwkJgUQiyfMvKSkp3/cnJSVBIpFg9erVasWnaaNGjYJEIkG7du0KvYzDhw8jJCQET58+1VxgeiwuLg4SiQRxcXFaWb6628adO3fw9ddf44MPPoCZmRlsbW0REBCAdevWQQghVzYn9i1btmghcv2we/dulb7D+iJnn3jy5EmNLE8ikeDrr7/WyLK0LSAgQOV99PHjx9GyZUtYW1vDysoKzZo1w6FDh/J9jxACTZs21UqbuLu7F2m/WZxytrG89ltCCHh6ekIikSAgIEA2/f79+5g8eTJ8fX1Rrlw52NjYoF69elixYgWysrLklrFv3z70798fXl5esLS0hIuLCzp27IhTp06pHGdhcmLnzp0VPt+cfagqf0lJSYXaLyqrN7dLly7h888/R6VKlWBmZoZy5cqhbt26+Prrr/H8+fMC6zh27Bg6deqEihUrQiqVwsHBAb6+vhg9erTKcRbGvXv3EBISgoSEBIV5ffv2hZWVlUbqqVu3LiQSCebOnat0flJSEtq2bQs7OztIJBKMGDEi3+VpOzera+/evQgKCoKzszOkUimcnZ0REBCAWbNmFWp5+f3WKs79ka5/vwYEBMjtp/KSs99T1aNHjzB8+HC4u7vLvm+tW7fG48ePZWVytjFlf0ePHi3M6iiV08d49OiRxpaZF62e2UtLS8PkyZNVKvv06VP06NEDa9asQXR0NMaMGYOdO3eiYcOGSElJkSs7f/58pKSkoEOHDjA1NdVG6HKio6Nx5MgRhT8nJyet111UGRkZ+PXXXwG8XY+7d+8WajmHDx9GaGjoe9PZq1u3Lo4cOYK6devqOhQcOnQItWrVwo4dOzB8+HBER0dj9erVcHFxQe/evdGjRw9kZ2frOsxitXv3boSGhuo6DNKgEydOoGnTpnj9+jXWrl2LtWvX4s2bN2jRogWOHDmS5/uWLFmC69evF2Ok+s3a2hqrVq1SmB4fH48bN27A2tpabvqpU6fwyy+/oEWLFvjll1+wdetW+Pv7Y/DgwRg4cKBc2WXLliEpKQnDhw/H7t27sXDhQjx48ACNGjXCvn37tLI+Dx48wM6dOwEA69atw5s3bwAATk5OCjnZx8cHlSpV0kiuzqved505cwb16tXDxYsXMXXqVERHR2P58uVo27Yt9u7dK/cDUpldu3bBz88Pz58/R0REBGJiYrBw4UI0btwYmzZtUjtmddy7dw+hoaFKO3uakpCQgDNnzgCA0m0SAEaOHIljx47h559/xpEjRzBy5Mh8l6lPuXn58uVo1aoVbGxssHjxYuzduxezZ89GtWrVCn2w9X37rVWc7t27h4YNGyI6OhpTpkxBbGwsli1bBk9PT6SnpyuUDwsLU9iX5D5RVVKU0ubCW7VqhfXr12PMmDGoXbt2vmWXLFki9zogIAAeHh5o06YNduzYgf79+8vmpaamwsjobT917dq1mg88l3r16qFcuXJar0cbduzYgYcPH6Jt27bYtWsX1qxZg4kTJ2q93tevX8Pc3Fzr9WiLjY0NGjVqpOsw8PTpU3Tu3BmlS5fGsWPH4ODgIJvXsWNH1KpVC+PHj0edOnUwfvx4HUaq3KtXr2BhYaHrMFRW0rdbTXr9+jXMzMzUOmpaFFOmTEGZMmUQHR0t22Y+/vhjVKpUCWPGjFF6hi8pKQkTJkzAL7/8gs6dOxdLnPque/fuWLduHZYsWQIbGxvZ9FWrVsHX11fhbFPjxo1x48YNmJiYyKYFBgYiPT0dS5YsQWhoKFxdXQG8zdP29vZy72/VqhU8PT0RFhaG5s2ba3x9fvnlF2RkZMhy2LZt29CzZ09IpVKFfbSNjQ3S09M1su/Oq953LViwAEZGRoiLi5PrRHfp0gUzZsxQGHWRW0REBDw8PLB3716UKvW/n2OfffYZIiIiirwOurZy5UoAkLXh4cOH4efnJ1fm/Pnz+PDDD/HJJ5/ku6yMjAxIJBK9yc0AEB4ejqZNmyp07D7//PMSewA2KysLmZmZug5DK4YMGYK0tDScPHkStra2sul55Y7KlSvrzbZWVFo9szdu3DiULVsW3377baHeX758eQCQ2wkCkHX09Mm9e/fQrVs3WFtbo3Tp0ujevTuSk5OVlj158iQ6dOggG7Lq4+ODzZs3y5XJOTW9f/9+DB48GOXKlUPZsmXRuXNn3Lt3T+W4Vq1aBVNTU0RGRsLV1RWRkZEKCSg7OxvfffcdqlatCnNzc5QpUwa1atXCwoULAbw91Tx27FgAgIeHh8JQoZyhBdu2bYOPjw/MzMxkZ13Onz+Pjh07wtbWFmZmZqhTpw7WrFkjV3/OKfMNGzZg0qRJcHZ2ho2NDT7++GNcuXJFYZ1+/vln1K5dG2ZmZrCzs0OnTp1w6dIluTI5w1AuX76Mli1bwtLSEk5OTrKhFUePHsVHH30ES0tLVKlSJc+Ycg8VOXbsGNq3b4+yZcvCzMwMH3zwgdywk+vXr6Nfv36oXLkyLCws4OLigvbt2+PcuXMqfFqKVq5ciQcPHmDWrFlyHb0c48aNg5eXF+bMmYOMjAy5eW/evMGoUaPg6OgIc3Nz+Pv7y46y5rh58yY+++wz2RAUBwcHtGjRQuFo76ZNm+Dr6wtLS0tYWVmhZcuWCsvKafNz584hKCgI1tbWaNGiBUaMGAFLS0ulQ5q6d+8OBwcHWeybNm1CUFAQnJycYG5ujmrVqmH8+PF4+fKlXD05B4eUDat+8+YNJkyYAA8PD5iamsLFxQVDhw5VOFKa13bbokULeHl5KXxPcobBtW3bVmE9NOHNmzcYPXo06tSpg9KlS8POzg6+vr7YsWNHnu9Zu3YtqlWrBgsLC9SuXVt2JuJdf//9N1q0aAFra2tYWFjAz88Pu3btkiuTs7+JiYlB//79Ub58eVhYWCAtLQ2Aap9/UR06dAgBAQFyBwesra3RtGlTHD58GPfv31d4z5dffonAwEB06tRJrbpU3UZyREVFoVatWrJLDH744Qe5+QXtQ4tTjx49AAAbNmyQTXv27Bm2bt0qd9A0h62trVxHL8eHH34IAPj3339l03J39ADAysoK3t7euHPnTpFjV+bnn3+Gg4MD1qxZA3Nzc/z8889aqacw9aakpMDGxibPIY8FHShJSUlBuXLlFH7jAIq/c7KzsxEREQEvLy9IpVLY29ujT58+cp8P8Ha/pmzY9LvD4uLi4tCgQQMAQL9+/WT70NxD469fv442bdrAysoKrq6uGD16tGyfUJA3b95g/fr1qFevHubPnw8Acm2Yk2OvX7+OPXv2KB1yu3btWowePRouLi6QSqW4fv263uRm4O3nl9dZ43c/v/yGRL7b7gX91soRHR2NunXrwtzcHF5eXkq3zeTkZAwaNAgVKlSAqakpPDw8EBoaKteRy4krIiIC3333HTw8PCCVSrF//36l66RqG6rzm04IgYiICLi5ucHMzAx169bFnj17lNZfFElJSfj9998xcOBAuY6etvz+++/w9fWFhYUFrK2tERgYmOcIlTt37qBz586wsbFB6dKl0bt3bzx8+FCuzL59+xAQEICyZcvC3NwcFStWxKeffopXr16pFI9We03W1taYPHky9u7dq/IQj8zMTLx+/RpnzpzBiBEjUKVKFZ0fsc050vHu37vXMrx+/Roff/wxYmJiEB4ejt9++w2Ojo7o3r27wrL279+Pxo0b4+nTp1i+fDl27NiBOnXqoHv37kp3BF988QVMTEywfv16REREIC4uDr1791Yp7n///RcxMTHo2LEjypcvj+DgYFy/fh0HDhyQKxcREYGQkBD06NEDu3btwqZNmzBgwADZD58vvvgC33zzDQBg27ZtstPZ7w6jOH36NMaOHYthw4YhOjoan376Ka5cuQI/Pz9cuHABP/zwA7Zt2wZvb2/07dtX6VHLiRMn4tatW1i5ciVWrFiBa9euoX379nJtHR4ejgEDBqB69erYtm0bFi5ciLNnz8LX1xfXrl2TW15GRgY6d+6Mtm3bYseOHWjdujUmTJiAiRMnIjg4GP3790dUVBSqVq2Kvn37Fnjdyd69e9GkSRPcvn0b8+bNw549ezB58mT8999/sjL37t1D2bJlMWvWLERHR2PJkiUoVaoUGjZsqLTjWpDY2FgYGxujffv2SudLJBJ06NABjx8/Voh/4sSJuHnzJlauXImVK1fi3r17CAgIwM2bN2Vl2rRpg1OnTiEiIkI2pMHHx0fuR29YWBh69OgBb29vbN68GWvXrkVqaiqaNGmCixcvytWZnp6ODh06oHnz5tixYwdCQ0PRv39/vHr1SuGAxtOnT7Fjxw707t1b9mPz2rVraNOmDVatWoXo6GiMGDECmzdvllv/KVOmoEuXLgCgMFRLCIFPPvkEc+fOxeeff45du3Zh1KhRWLNmDZo3b67wQ0XZdjt8+HBcuXIFf/31l1zZPXv24MaNGxg6dGh+H1mhpaWl4fHjxxgzZgy2b9+ODRs24KOPPkLnzp3xyy+/KJTftWsXFi9ejOnTp2Pr1q2yAx/vfr7x8fFo3rw5nj17hlWrVmHDhg2wtrZG+/btlQ4T69+/P0xMTLB27Vps2bIFJiYman3+RZGeng6pVKowPWda7h8UK1euxPHjx7F48WK16lF3G0lISMCIESMwcuRIREVFwc/PD8OHD5e7BqmgfWhxsrGxQZcuXeR+AG7YsAFGRkZKc1Je9u3bh1KlSqFKlSr5lnv27BlOnz6N6tWrFzrmvBw+fBiXLl1Cnz59ULZsWXz66afYt28fEhMTNV5XYer19fXF/fv30atXL8THx+P169dq1ePr64tjx45h2LBhOHbsmMIBu3cNHjwY3377LQIDA/H7779jxowZiI6Ohp+fn9rX/NStWxeRkZEA3t4DIWcf+sUXX8jKZGRkoEOHDmjRooVsdNX8+fMxe/ZslerYtm0bnjx5gv79+6Ny5cr46KOPsGnTJrx48UIWw5EjR+Do6IjGjRsrHXI7YcIE3L59G8uXL8cff/yh9GADoJvcDLz9/LZu3YqQkBD8888/Cte4qkuV31r//PMPRo8ejZEjR2LHjh2oVasWBgwYIPe7Ljk5GR9++CH27t2LqVOnYs+ePRgwYADCw8MVhmYDwA8//IB9+/Zh7ty52LNnD7y8vJTGp24bqvKbLjQ0VLZdb9++XTZ8vLCfSV4OHjwIIQScnZ3Ro0cPWFlZwczMDAEBAXl2woYOHYpSpUrBxsYGLVu2xN9//61SXevXr0fHjh1hY2ODDRs2YNWqVXjy5AkCAgKULqNTp07w9PTEli1bEBISgu3bt6Nly5ay/UHOda2mpqb4+eefER0djVmzZsHS0lLp8FOlhBZERkYKAOLEiRMiLS1NVKpUSdSvX///2rvz8Jiu/w/g75uYmewIspFERGJfUhRRjdCEKLVHS22lpaglVZoqQpGilrZaS6uhRWlraauKqLX2LfZdgpIUsSRCk0jO7w+/ma/JTJK5ySzJeL+eJw93/9wzd+7nnrnnnityc3OFEEKEhISIOnXq6CyXnJwsAGj+mjZtKm7cuFHgthwdHUW/fv1kxefr6ysmTZpU6HyTJk3SiufZP39/f818CxYsEADEr7/+qrX822+/LQCIuLg4zbiaNWuKoKAgkZ2drTVvhw4dhKenp8jJyRFC/K8Mhw4dqjXfzJkzBQCRnJxcaPxTpkwRAMSmTZuEEEJcuXJFSJIk+vTpo7Pthg0bFriuWbNmCQAiMTFRZ5qvr6+wtbUV58+f1xr/+uuvC5VKJa5du6Y1PiIiQjg4OIj79+8LIYTYvn27ACDat2+vNd9PP/0kAIh9+/YJIYS4d++esLe315nv2rVrQqVSiV69emnG9evXTwAQa9as0YzLzs4WlSpVEgDE0aNHNeNTU1OFra2tiIqK0oxTx7R9+3bNOH9/f+Hv7y8eP35cUFFpefLkicjKyhIBAQFi9OjRmvGJiYk6x4Y+NWvWFB4eHgXOoz7+Vq9erRX7Cy+8oPnOCSFEUlKSUCgUYtCgQUIIIe7cuSMAiHnz5uW77mvXrokyZcqI9957T2t8enq68PDwEJGRkZpx6jL/7rvvdNbzwgsviODgYK1xX3/9tQAgTp48qXfbubm5Ijs7W+zcuVMAEMePH9dMGzZsmNB3+tq0aZMAIGbOnKk1fvXq1QKAWLx4sWZcfsdtTk6OqFatmujUqZPW+IiICOHv769VpoZ69pxoqCdPnojs7GwxcOBAERQUpDUNgHB3dxdpaWmacSkpKcLGxkbExsZqxjVr1ky4ubmJ9PR0rfXWrVtXVKlSRbMv6vj69u2rtR05n39+QkJCDDpHN2zYUAQGBmrOgUI8/c5Wq1ZNABArV67UjP/nn39E2bJlxaJFizTjAIhhw4YVuh25x4gkSSIhIUFr3rCwMOHi4iIyMjKEEIadQ03t2WNMfQ44deqUEEKIJk2aiP79+wshhKhTp44ICQkpcF2bN28WNjY2Wues/PTu3VuUKVNGHD582KA4DTnvqb311lsCgDh79qwQ4n/ntgkTJuidP79ri2eX/fnnn4223f/++0907txZc11ga2srgoKCxPjx48WtW7cK3c6dO3fESy+9pFleoVCI4OBgERsbq/WdPXv2rN7rgQMHDggA4qOPPtKM8/X11ft9CwkJ0frcDx06lO9noT6X//TTT1rj27dvL2rUqFHofgkhROvWrYWdnZ24d++eEOJ/x+eSJUu05vP19RWvvvqq1jh1eb/88ss66zV1bpbj0qVLom7duprPz97eXrRp00bMnz9fZGVlaeYrKN8D0LoeLexay87OTly9elUz7vHjx8LV1VUMHjxYM27w4MHCyclJaz4hhPjss88EAHH69GmtuPz9/bXiLSxmtfzKUM41nZ2dnejSpYvWfHv27BEACj1PCfG/46owsbGxAoBwcXERnTp1Eps2bRJr1qwR9evXF3Z2dlrXF0ePHhUjR44U69atE7t27RLfffedqFWrlrC1tdVcT+cnJydHeHl5iXr16mnlsvT0dOHm5qZ1HaSuY+Q9/lasWCEAiOXLlwshhPjll18EAJ08JIfJ20MqlUpMnToVhw8f1vllP6+KFSvi0KFD+Pvvv/HNN9/g7t27CA0N1dt8x5y2bt2KQ4cOaf2tX79eM3379u1wdnbGa6+9prVc3vb9ly5dwrlz59C7d28A0LpT2L59eyQnJ+v8mpF3nfXr1wcAvb2UPksIoWm6GRYWBuBps4BWrVphzZo1Wk3qXnzxRRw/fhxDhw7F5s2bDepBLK/69evr/AK8bds2tGnTRvO8h1r//v3x6NEjnV9TCtvXffv24fHjxzpNVLy9vdG6dWudOzGSJKF9+/aa4TJlyqB69erw9PREUFCQZryrqyvc3NwKLNMLFy7g8uXLGDhwIOzs7PKd78mTJ5g+fTpq164NpVKJMmXKQKlU4uLFizpNTY1F/H9zw7xNhnr16qU1ztfXF8HBwZomGq6urvD398esWbMwZ84cHDt2TOc5g82bN+PJkyfo27ev1vFqZ2eHkJAQvT2idevWTWfcgAEDsHfvXq3jOy4uDk2aNNF64PnKlSvo1asXPDw8YGtrC4VCgZCQEAAwqPzULQjyHiM9evSAo6OjzjGi77i1sbHB8OHDsWHDBly7dg0AcPnyZWzatAlDhw416TNsP//8M1q0aAEnJyeUKVMGCoUCS5Ys0bvvoaGhWs8Jubu7ax3HGRkZOHDgALp3767VzMzW1hZ9+vTBP//8o3O+yfvZFeXzL6r33nsPFy5cwPDhw3Hjxg1cv34dQ4YM0ezPs82ihgwZggYNGuj9lbowco+ROnXq6Dxz3qtXL6SlpeHo0aMAjHMONaaQkBD4+/vju+++w8mTJ3Ho0CG9TTj1OXr0KCIjI9GsWTPExsYWOO+ECROwYsUKzJ07F40aNTJG6BoPHz7ETz/9hODgYM2dBvV+LV261GTPRMnZrkqlwrp163DmzBnMnTsXr7/+Om7fvo1p06ahVq1ahd6dqFChAnbv3o1Dhw7h008/RadOnXDhwgVER0ejXr16mjt26nN23mP2xRdfRK1atXSOWWOQJEmnRUn9+vULvfYAgMTERGzfvh1du3ZFuXLlADz9fjk7O8tqhqsvl+Rlydzs7++P48ePY+fOnZg8eTJeeeUVHDp0CMOHD0fz5s31dupTXA0bNoSPj49m2M7ODoGBgVqfy4YNGxAaGgovLy+t83ZERASApy0+nvXaa6/pbcqdl9wyNOSa7r///tNcE6sFBwfD19e30HjkUH9vq1SpgjVr1qBt27bo2rUrNm3aBBsbG63WZkFBQZg3bx46d+6Mli1baq5fPD09MXbs2AK3c/78edy8eRN9+vTRyllOTk7o1q0b9u/fr9P0Mu/+R0ZGokyZMprvfcOGDaFUKvHOO+9g2bJlWq13DGWWh99ef/11vPDCCxg/fnyBzRTKlCmDxo0bo0WLFhg0aBC2bduGK1euFLkLW2Np0KABGjdurPX37AVqamqq3uepPDw8tIbVTQrGjBkDhUKh9Td06FAA0GmOUaFCBa1hdZOmwpqLqJuc9OjRA2lpabh//z7u37+PyMhIPHr0SOt5jujoaHz22WfYv38/IiIiUKFCBbRp00ZWN/H62q3n157dy8tLM/1Zhe2rev781pl3fQ4ODjonf6VSCVdXV53llUplgSdmdfvpKlWq5DsP8PQ1FxMmTEDnzp3x+++/48CBAzh06BAaNGggu4kPAPj4+OD27dtaz6zlpX5WLW+lOu/xpx6nLidJkvDXX3+hbdu2mDlzJl544QVUqlQJI0aMQHp6OoD/HbNNmjTROWZXr16tc7w6ODhodQqh1rt3b6hUKk1T5TNnzuDQoUMYMGCAZp6HDx+iZcuWOHDgAKZOnYodO3bg0KFDWLt2LYDCj3ng6TFSpkwZzfO+apIkae27Wn7PW7z11luwt7fHwoULATztmMLe3t7gC+aiWLt2LSIjI1G5cmUsX74c+/bt01yk6zs2835fgKffGXU53bt3D0IIWd/BvPPK/fyL46233sKnn36KH374AVWqVIGPjw/OnDmDMWPGAAAqV64MAPjll1+wadMmzJw5Ew8ePNCc24CnTUHv379fYJ6Re4zk9z1SrwswzjnUmCRJwoABA7B8+XIsXLgQgYGBaNmyZaHLHTt2DGFhYQgICMDGjRv1NqtVmzx5MqZOnYpp06aZ5DUg6iZ/kZGRms/4wYMHiIyMxPXr1xEfH2/0bRZ1u7Vq1cKoUaOwfPlyTVPC1NRUTJgwwaBtNm7cGOPGjcPPP/+MmzdvYvTo0UhKStJcgMrNfcagL3+qVCqDKjDfffcdhBDo3r27pgzVzUL37NmDc+fOGRSDIb2oWio3q9nY2ODll1/GxIkT8dtvv+HmzZvo2bMnjhw5YpLnSws77wNPz9u///67zjlb3dQ673nb0N5q5Zahodd0BZ1jjUUdyyuvvAJbW1vNeE9PTzRo0EDzw11+ypUrhw4dOuDEiRMFHi+FfVdzc3Nx7949rfF597VMmTKoUKGCZl3+/v7YunUr3NzcMGzYMPj7+8Pf31/WM+Em7Y1TTZIkzJgxA2FhYVi8eLHBy1WpUgVeXl64cOGCCaMrvgoVKuDgwYM64/N20KLu0TM6Ojrf5xBr1KhhlJjU3RzPmTMHc+bM0Tt98ODBAJ4eWFFRUYiKisL9+/exdetWfPTRR2jbti2uX79uUG+K+u52VKhQQe9dWXUHM3J7OFV/WfNbpyl7TFVfGOZ9GD6v5cuXo2/fvpg+fbrW+Dt37mh+4ZQjLCwMW7Zswe+//47XX39dZ7oQAr/99htcXV11flnX10FQSkqK1gnY19dXc6xcuHABP/30E2JiYpCVlYWFCxdqyvSXX34x6Je2/O56lS9fHp06dcL333+PqVOnIi4uDnZ2dprOJICnP1DcvHkTO3bs0NzNAyDruacKFSrgyZMnuH37ttbFvBACKSkpmk4JCou3bNmy6NevH7799luMGTMGcXFx6NWrV5E+Q0MtX74cfn5+WL16tVZchnaIkFf58uVhY2Mj6zuYtzzkfv7FNW7cOIwaNQoXL16Es7MzfH19MXjwYDg6OmqO71OnTuHJkyd6e0n75ptv8M0332DdunX59u4n9xjJ73ukXhdgnHOosfXv3x8TJ07EwoULMW3atELnP3bsGF555RX4+vpiy5YtKFu2bL7zTp48GTExMYiJiTFZ787q89KoUaP0vnttyZIlaNu2bYnbriRJGD16NKZMmYJTp07J3r5CocCkSZMwd+5czfLP5r68lZq8uc/Ozk7vOePOnTtm6VU8NzdX86Neftc53333nUG9jRrSisJSuTk/jo6OiI6OxurVqzWfn7rSnPdzMUUlHXh63q5fv36+33v1j31qhrZWMXYZqo/r/M6xVatWlb3O/KjvKuojhDCo48f8WlE9q7DrVBsbG50OYlJSUjQ/ZgJP76CmpqZqXau1bNkSLVu2RE5ODg4fPowvv/wSo0aNgru7u95rw7zM1q3lK6+8grCwMEyZMkXzgG5hLl26hH/++QfVq1c3cXTFExoaivT0dPz2229a41euXKk1XKNGDQQEBOD48eM6dwrVf3nfgVQU9+7dw7p169CiRQts375d56937944dOiQ3kRUrlw5dO/eHcOGDcPdu3c1d40MvaP4rDZt2mgu4J/1/fffw8HBQXaXts2bN4e9vb3mvYFq//zzj6bJqKkEBgZqmkUVdPEtSZLOr+F//PFHkd9vOGjQILi5uSE6Ohq3bt3SmT5z5kycO3cOY8eO1WmG8eOPP2r1KHn16lXs3bs33xeVBgYG4uOPP0a9evU0v3K1bdsWZcqUweXLl/M9Zg01YMAA3Lx5Exs3bsTy5cvRpUsXrQShPoHmLb9FixbprCu/41F9DOQ9RtasWYOMjAxZx8iIESNw584dza/Tpn6JuSRJUCqVWokkJSWlwN44C+Lo6IimTZti7dq1WuWUm5uL5cuXo0qVKoV2vmHMz99QKpUKdevWha+vL65du4bVq1fj7bff1rwSo3///nrPawDQuXNnbN++HS+99FK+65d7jJw+fRrHjx/XGrdy5Uo4OzvrfddXfudQc6tcuTI++OADdOzYEf369Stw3oSEBLzyyiuoUqUK4uPjC+yt7pNPPkFMTAw+/vhjTJo0ydhhA3jaZHvfvn3o1q2b3s9a3WmIsS+W5W43v0dMbt68ibS0NJ2L6rzyW17dJE69vPqVFnmP2UOHDuHs2bNax2zVqlVx4sQJrfkuXLig06S0KDndEJs3b8Y///yDYcOG6S3DOnXq4Pvvvzda9/6Wys2A4Z+fu7s77OzsdD4Xfed2Y3wuHTp0wKlTp+Dv76/3nF3YcZkfY5dhs2bNYGdnhxUrVmiN37t3r0HNheVo2rQpqlSpgi1btmh1EHPz5k0cP3680OvRe/fuYcOGDWjYsGGBzYVr1KiBypUrY+XKlVrXXxkZGVizZo2mh85n5d3/n376CU+ePNF7rWZra4umTZtqeiQv7I6kmlnu7KnNmDEDjRo1wq1bt7R67jpx4gRGjx6N7t27o1q1arCxscHJkycxd+5cVKhQQdOMR23nzp2aW/c5OTm4evWq5j0nISEhOs1ziuvIkSN6f+WsXbs2XFxc0LdvX8ydOxd9+/bFtGnTNE1gNm/erLPMokWLEBERgbZt26J///6oXLky7t69i7Nnz+Lo0aP4+eefix2v+gWwI0aM0HuwVKhQAStWrMCSJUswd+5cdOzYEXXr1kXjxo1RqVIlXL16FfPmzYOvry8CAgIAAPXq1QMAfP755+jXrx8UCgVq1KhRYOV00qRJmrbjEydOhKurK1asWIE//vgDM2fOLPCXY33KlSuHCRMm4KOPPkLfvn3xxhtvIDU1FZMnT4adnZ3JLjzUvvrqK3Ts2BHNmjXD6NGj4ePjg2vXrmHz5s2aL2uHDh2wdOlS1KxZE/Xr18eRI0cwa9asQpuY5KdcuXJYu3YtOnTogEaNGuGDDz5AgwYNkJaWhtWrV2PFihXo2bOnprvmZ926dQtdunTB22+/jQcPHmDSpEmws7NDdHQ0gKffu+HDh6NHjx4ICAiAUqnEtm3bcOLECc07+6pWrYopU6Zg/PjxuHLlCtq1a4fy5cvj33//xcGDB+Ho6Gjwy83Dw8NRpUoVDB06FCkpKVpNOIGn7fTLly+PIUOGYNKkSVAoFFixYoXOhTbwv+NxxowZiIiIgK2tLerXr4+wsDC0bdsW48aNQ1paGlq0aIETJ05g0qRJCAoKQp8+fQwu+8DAQLRr1w5//vknXnrpJb3vCu3fvz+WLVuGxMREg36F3LZtm96L//bt22teAzF06FB0794d169fxyeffAJPT0+dnmYNFRsbi7CwMISGhmLMmDFQKpX4+uuvcerUKfz444+F/qJrzM+/MKdOncKaNWvQuHFjqFQqHD9+HJ9++ikCAgLwySefaMWUX1lXrlw53x8z1OQeI15eXnjttdcQExMDT09PLF++HPHx8ZgxY4YmaRtyDrUEQx6BOH/+PF555RUAwLRp03Dx4kWt483f31+TU2fPno2JEyeiXbt2ePXVV7F//36tdRnrnVTqu2tjx47VvALiWenp6fjrr7+wfPlyjBw5Uta688asFhISInu777zzDu7fv49u3bqhbt26sLW1xblz5zB37lzY2NgU+tqptm3bokqVKujYsSNq1qyJ3NxcJCQkYPbs2XByctLsW40aNfDOO+/gyy+/hI2NDSIiIpCUlIQJEybA29tb60Xkffr0wZtvvomhQ4eiW7duuHr1KmbOnKlzXeTv7w97e3usWLECtWrVgpOTE7y8vIpcEVBbsmQJypQpg48++kjvugYPHowRI0bgjz/+QKdOnYq1LTVj5+ZWrVph586dhb4nsU6dOmjTpg0iIiLg7++P//77DwcOHMDs2bPh7u6OgQMHAnhaSXrzzTfx3Xffwd/fHw0aNMDBgwd1bggARbvWymvKlCmIj49HcHAwRowYgRo1auC///5DUlISNm7ciIULFxbpmsTY1zfly5fHmDFjMHXqVAwaNAg9evTA9evXERMTY/RmnDY2Npg7dy4iIyPRqVMnvPvuu8jIyMAnn3wCpVKpuS4Cnj6T7ePjg8aNG6NixYq4ePEiZs+ejX///Vdvr/l5tzNz5kz07t0bHTp0wODBg5GZmYlZs2bh/v37es/Ja9euRZkyZRAWFobTp09jwoQJaNCgASIjIwEACxcuxLZt2/Dqq6/Cx8cH//33n6aJsPrcXagid+1SgIJ6nuvVq5cAoNVjVkpKinjzzTeFv7+/cHBwEEqlUlSrVk0MGTJEpydHIZ72KoV8esl8toem/BijN04AIj4+XjPvP//8I7p16yacnJyEs7Oz6Natm9i7d6/e3oyOHz8uIiMjhZubm1AoFMLDw0O0bt1aLFy4sNAy1NcTVV4NGzYUbm5uIjMzM995mjVrJipWrCgyMzPF7NmzRXBwsKhYsaJQKpXCx8dHDBw4UCQlJWktEx0dLby8vISNjY1WDPp601I7efKk6NixoyhbtqxQKpWiQYMGOuWRXy9p+fUG9e2334r69esLpVIpypYtKzp16qTpXUqtX79+wtHRUSee/Hpry7sP+ZXzvn37REREhChbtqxQqVTC399fqyele/fuiYEDBwo3Nzfh4OAgXnrpJbF7926dntAM7Y1T7dq1a2LYsGGiWrVqmv1++eWXxfLly3V6h1TH/sMPP4gRI0aISpUqCZVKJVq2bKnVY96///4r+vfvL2rWrCkcHR2Fk5OTqF+/vpg7d6548uSJ1jrXr18vQkNDhYuLi1CpVMLX11d0795dbN26VTNPfmX+rI8++kgAEN7e3lo9Vant3btXNG/eXDg4OIhKlSqJQYMGiaNHj+qUVWZmphg0aJCoVKmSkCRJq/eyx48fi3HjxglfX1+hUCiEp6enePfddzW9wqkVdNyqLV26VAAQq1at0ju9W7duwt7eXmfdeam/z/n9qWP/9NNPRdWqVYVKpRK1atUS33zzjeY89Czk0/Okvp74du/eLVq3bi0cHR2Fvb29aNasmfj999/1xpdfb6GGfP75MbQ3zvPnz4uXX35ZuLq6CqVSKapXry4+/vhj8fDhw0KXFcLw3jiFkH+M/PLLL6JOnTpCqVSKqlWrijlz5mjNZ+g51JQM7fE1b2+chR2bz37vCsq9hl5OFHbey8rKEm5ubgX2bvrkyRNRpUoVUa9ePa3xhvTGmd/fli1bZG938+bN4q233hK1a9cWZcuWFWXKlBGenp6ia9eumh4HC7J69WrRq1cvERAQIJycnIRCoRA+Pj6iT58+4syZM1rz5uTkiBkzZojAwEChUChExYoVxZtvvimuX7+uNV9ubq6YOXOmqFatmrCzsxONGzcW27Zt08lBQgjx448/ipo1awqFQqHVK2R+53J956Jn3b59WyiVStG5c+d851H3qt2xY0chRMG9cerrOdXUuVkIIRo1alRoL9hCCLFo0SLRtWtXUa1aNc21q7+/vxgyZIjO5/LgwQMxaNAg4e7uLhwdHUXHjh1FUlKSTm+cQsi/1tK3D7dv3xYjRowQfn5+QqFQCFdXV9GoUSMxfvx4zTlVfR0ya9YsnXXqu0YxtAzlXNPl5uaK2NhY4e3tLZRKpahfv774/fff9e6TPob2xqm2fv160aRJE2FnZyfKli0rXnvtNZ3rx9jYWNGwYUNRtmxZYWtrKypVqiS6dOkiDh48KGs7TZs2FXZ2dsLR0VG0adNG7NmzR2se9ffpyJEjomPHjpr6wxtvvCH+/fdfzXz79u0TXbp0Eb6+vkKlUokKFSqIkJAQ8dtvvxkcjyREIT9dWCH1S0fzvkCUiOhZ6t6zkpKS9PZW5uHhgT59+mDWrFkWiK50aNWqFapWrVroL6L0fJAkCXFxcXpf/E1kaenp6XB1dcW8efNM9k5VMp6lS5diwIABhd6Ffd6ZtRknEVFJl5mZiaNHj+LgwYNYt24d5syZo7eid/r0aTx69KjQplpERFQ67Nq1C5UrVy7Sa12ISipW9oiInpGcnIzg4GC4uLhg8ODBeO+99/TOV6dOHYu/T42IiIzn1VdfxauvvmrpMIiMipU9IqJnVK1alU1CiIiIyCo8l8/sERERERERWTuzvWePiIiIiIiIzMfqm3Hm5ubi5s2bcHZ2LvSdUkREVLoJIZCeng4vLy/Y2Dw/v2cy1xERPR/k5jmrr+zdvHkT3t7elg6DiIjM6Pr160V+2W9pxFxHRPR8MTTPWX1lz9nZGQCQmJiIffv2ITw8XG836qVVdnY2tmzZwv0qJbhfpQv3q3TJzs7G+vXrMWjQIM25/3mh3t/r16/DxcVFa5q1ft7FwTLRxTLRj+Wii2Wiy5xlkpaWBm9vb4PznNVX9tTNWZydneHg4AAXFxerOjCzs7O5X6UI96t04X6VLur9AvDcNWVU76+Li4veyp41ft7FwTLRxTLRj+Wii2WiyxJlYmiee34eaCAiIiIiInqOsLJHRERERERkhVjZIyIiIiIiskKs7BEREREREVkhVvaIiIiIiIisECt7REREREREVoiVPSIiIiIiIitk9e/ZIyLTmPbHGc3/bUQOagP4bPM55Eq2Jt3u+Fdrm3T9RETYHlu85UOjjRMHEVEx8c4eERERERGRFWJlj4iIiIiIyAqxskdERERERGSFWNkjIiIiIiKyQqzsERERERERWSFW9oiIiIiIiKwQK3tERERERERWiJU9IiIiIiIiK8TKHhERERERkRUySmXv/v37xlgNERFRicVcR0REpY3syt6MGTOwevVqzXBkZCQqVKiAypUr4/jx40YNjoiIyBKY64iIyBrIruwtWrQI3t7eAID4+HjEx8fjzz//REREBD744AOjB0hERGRuzHVERGQNyshdIDk5WZMAN2zYgMjISISHh6Nq1apo2rSp0QMkIiIyN+Y6IiKyBrLv7JUvXx7Xr18HAGzatAmvvPIKAEAIgZycHONGR0REZAHMdUREZA1kV/a6du2KXr16ISwsDKmpqYiIiAAAJCQkoHr16kYPkIiIyNyMletiY2PRpEkTODs7w83NDZ07d8b58+e15hFCICYmBl5eXrC3t0erVq1w+vRpo+4PERE9n2RX9ubOnYvhw4ejdu3aiI+Ph5OTE4CnTV6GDh1q9ACJiIjMzVi5bufOnRg2bBj279+P+Ph4PHnyBOHh4cjIyNDMM3PmTMyZMwfz58/HoUOH4OHhgbCwMKSnpxt9v4iI6Pki+5k9hUKBMWPG6IwfNWqUMeIhIiKyOGPluk2bNmkNx8XFwc3NDUeOHMHLL78MIQTmzZuH8ePHo2vXrgCAZcuWwd3dHStXrsTgwYP1rjczMxOZmZma4bS0NABAdnY2srOzteZVD+cd/zwrtExEMd9MVQrLmseJfiwXXSwTXeYsE7nbkF3ZA4ALFy5gx44duHXrFnJzc7WmTZw4sSirJCIiKlFMkesePHgAAHB1dQUAJCYmIiUlBeHh4Zp5VCoVQkJCsHfv3nwre7GxsZg8ebLO+C1btsDBwUHvMvHx8UWK2ZrlXyY1i7fijRuLt7wF8TjRj+Wii2Wiyxxl8ujRI1nzy67sffPNN3j33XdRsWJFeHh4QJIkzTRJkljZIyKiUs8UuU4IgaioKLz00kuoW7cuACAlJQUA4O7urjWvu7s7rl69mu+6oqOjERUVpRlOS0uDt7c3wsPD4eLiojVvdnY24uPjERYWBoVCITtua1RomeyeU7wNtIwqfJ4ShseJfiwXXSwTXeYsE3VLDkPJruxNnToV06ZNw7hx4+QuSkREVCqYItcNHz4cJ06cwN9//60z7dnKJPC0Yph33LNUKhVUKpXOeIVCke+FRkHTnlf5lomUqztO3oqLt7wF8TjRj+Wii2WiyxxlInf9shul37t3Dz169JC7GBERUalh7Fz33nvv4bfffsP27dtRpUoVzXgPDw8A/7vDp3br1i2du31ERERyya7s9ejRA1u2bDFFLERERCWCsXKdEALDhw/H2rVrsW3bNvj5+WlN9/Pzg4eHh9ZzHllZWdi5cyeCg4OLvX0iInq+yW7GWb16dUyYMAH79+9HvXr1dG4ljhgxwmjBERERWYKxct2wYcOwcuVK/Prrr3B2dtbcwStbtizs7e0hSRJGjRqF6dOnIyAgAAEBAZg+fTocHBzQq1cvo+8XERE9X2RX9hYvXgwnJyfs3LkTO3fu1JomSRIre0REVOoZK9ctWLAAANCqVSut8XFxcejfvz8AYOzYsXj8+DGGDh2Ke/fuoWnTptiyZQucnZ2LvR9ERPR8k13ZS0xMNEUcREREJYaxcp0QotB5JElCTEwMYmJijLJNIiIitWK9NVQIYVAiIyIiKq2Y64iIqLQqUmXv+++/R7169WBvbw97e3vUr18fP/zwg7FjIyIishjmOiIiKu1kN+OcM2cOJkyYgOHDh6NFixYQQmDPnj0YMmQI7ty5g9GjR5siTiIiIrNhriMiImsgu7L35ZdfYsGCBejbt69mXKdOnVCnTh3ExMQwARIRUanHXEdERNZAdjPO5ORkve/+CQ4ORnJyslGCIiIisiTmOiIisgZFes/eTz/9hI8++khr/OrVqxEQEGC0wIiIDLY91vB5Q6NNFwdZDeY6IiKyBrIre5MnT0bPnj2xa9cutGjRApIk4e+//8Zff/2Fn376yRQxEhERmRVzHRERWQPZzTi7deuGAwcOoGLFili/fj3Wrl2LihUr4uDBg+jSpYspYiQiIjIr5joiIrIGsu/sAUCjRo2wfPlyY8dCRERUYjDXERFRaWdQZS8tLQ0uLi6a/xdEPR8REVFpwlxHRETWxqDKXvny5ZGcnAw3NzeUK1cOkiTpzCOEgCRJyMnJMXqQREREpsZcR0RE1sagyt62bdvg6uoKANi+fbtJAyIiIrIE5joiIrI2BlX2QkJCNP/38/ODt7e3zi+eQghcv35d1sZ37dqFWbNm4ciRI0hOTsa6devQuXNnzfT+/ftj2bJlWss0bdoU+/fvl7UdIiKiwpgq1xEREVmK7N44/fz8cPv2bZ3xd+/ehZ+fn6x1ZWRkoEGDBpg/f36+87Rr1w7Jycmav40bN8oNmYiISBZj5joiIiJLkd0bp/p5hbwePnwIOzs7WeuKiIhAREREgfOoVCp4eHjIWi8REVFxGDPXERERWYrBlb2oqCgAgCRJmDBhAhwcHDTTcnJycODAATRs2NDoAe7YsUPzsHxISAimTZsGNze3fOfPzMxEZmamZljdo1p2drbWv9aC+1W6WNN+2YicZ/6fq/WvKektOyGjkYKMsremz+tZ1r5fxWGpXEdERGQKBlf2jh07BuDpr50nT56EUqnUTFMqlWjQoAHGjBlj1OAiIiLQo0cP+Pr6IjExERMmTEDr1q1x5MgRqFQqvcvExsZi8uTJOuO3b98OBwcHxMfHGzXGkoL7VbpYw37V1jOuZm6Sybe7ceMVfVuWswLZ27SGz0sfa92v4rBEriMiIjIVgyt76p7JBgwYgM8//9ws7xjq2bOn5v9169ZF48aN4evriz/++ANdu3bVu0x0dLTml1ng6Z09b29vhIaG4sCBAwgLC4NCoTB57OaSnZ2N+Ph47lcpYU379dnmc5r/24hc1MxNwjmbqsiVZD8KLMuYtnoqdrvnGL6CllGFz/P/rOnzepY179evv/5arHVYItcRERGZiuxn9uLi4kwRh0E8PT3h6+uLixcv5juPSqXSe9dPfUGjUCis6uJGjftVuljDfuVKtnrG2egdb0x6y02S0Xy0COVuDZ+XPta6X8ZgyVxHRERkLLIrewBw6NAh/Pzzz7h27RqysrK0pq1du9YogemTmpqK69evw9PT02TbICIiAiyX6+ipaX+cKXSe8a/qa1BORERqsttbrVq1Ci1atMCZM2ewbt06ZGdn48yZM9i2bRvKli0ra10PHz5EQkICEhISAACJiYlISEjAtWvX8PDhQ4wZMwb79u1DUlISduzYgY4dO6JixYro0qWL3LCJiIgMZsxcR0REZCmyK3vTp0/H3LlzsWHDBiiVSnz++ec4e/YsIiMj4ePjI2tdhw8fRlBQEIKCggA87QUtKCgIEydOhK2tLU6ePIlOnTohMDAQ/fr1Q2BgIPbt2wdnZ2e5YRMRERnMmLmOiIjIUmQ347x8+TJeffVVAE+fj8vIyIAkSRg9ejRat26ttyfM/LRq1QpCiHynb968WW54RERExWbMXEdERGQpsu/subq6Ij09HQBQuXJlnDp1CgBw//59PHr0yLjRERERWQBzHRERWQPZd/ZatmyJ+Ph41KtXD5GRkRg5ciS2bduG+Ph4tGnTxhQxEhERmRVzHRERWQPZlb358+fjv//+A/D0nXYKhQJ///03unbtigkTJhg9QCIiInNjriMiImsgu7Ln6uqq+b+NjQ3Gjh2LsWPHGjUoIjIPQ7o2N5aWN741eN7dlQeZMBKiwjHXERGRNZD9zF5oaCiWLFmCBw8emCIeIiIii2OuIyIiayC7slevXj18/PHH8PDwQLdu3bB+/Xqdl80SERGVZsx1RERkDWRX9r744gvcuHEDv/76K5ydndGvXz94eHjgnXfewc6dO00RIxERkVkx1xERkTWQXdkDnj6/EB4ejqVLl+Lff//FokWLcPDgQbRu3drY8REREVkEcx0REZV2sjtoeVZKSgpWrVqF5cuX48SJE2jSpImx4iIiIioRmOuIiKi0kn1nLy0tDXFxcQgLC4O3tzcWLFiAjh074sKFCzhw4IApYiQiIjIr5joiIrIGsit77u7uGD9+POrUqYO9e/fi/PnzmDRpEqpXr26K+IiIiMzOmLlu165d6NixI7y8vCBJEtavX681vX///pAkSeuvWbNmRtoTIiJ6nslqximEwOeff44333wTDg4OpoqJiIjIYoyd6zIyMtCgQQMMGDAA3bp10ztPu3btEBcXpxlWKpXF3i4REZHsyt7w4cMRGhqKgIAAU8VERERkMcbOdREREYiIiChwHpVKBQ8Pj2Jvi4iI6FmyKns2NjYICAhAamoqK3tERGSVLJHrduzYATc3N5QrVw4hISGYNm0a3Nzc8p0/MzMTmZmZmuG0tDQAQHZ2NrKzs7XmVQ/nHV/S2YicQucp6j4VWiaiSJ2VP7uB4i1vAaX1ODE1losulokuc5aJ3G3I7o1z5syZ+OCDD7BgwQLUrVtX7uJEREQlnjlzXUREBHr06AFfX18kJiZiwoQJaN26NY4cOQKVSqV3mdjYWEyePFln/JYtW/JtehofH2/UuE2ttgHzbNx4pVjbyL9MahZrvdi4sXjLW1BpO07MheWii2Wiyxxl8ujRI1nzy67svfnmm3j06BEaNGgApVIJe3t7rel3796Vu0oiIqISxZy5rmfPnpr/161bF40bN4avry/++OMPdO3aVe8y0dHRiIqK0gynpaXB29sb4eHhcHFx0Zo3Ozsb8fHxCAsLg0KhMFrcpvbZ5nOFzjOmbdEqZYWWye45RVqvUbSMKnweEyitx4mpsVx0sUx0mbNM1C05DCW7sjdv3jy5ixAREZUqlsx1np6e8PX1xcWLF/OdR6VS6b3rp1Ao8r3QKGhaSZQr2RY6T3H3J98ykXKLtd5isfBnVNqOE3NhuehimegyR5nIXb/syl6/fv3kLkJERFSqWDLXpaam4vr16/D09LRYDEREZB2K9ATy5cuX8fHHH+ONN97ArVu3AACbNm3C6dOnjRocERGRpRgr1z18+BAJCQlISEgAACQmJiIhIQHXrl3Dw4cPMWbMGOzbtw9JSUnYsWMHOnbsiIoVK6JLly7G3iUiInrOyK7s7dy5E/Xq1cOBAwewdu1aPHz4EABw4sQJTJo0yegBEhERmZsxc93hw4cRFBSEoKAgAEBUVBSCgoIwceJE2Nra4uTJk+jUqRMCAwPRr18/BAYGYt++fXB2djb6fhER0fNFdjPODz/8EFOnTkVUVJRWIgoNDcXnn39u1OCIiIgswZi5rlWrVhBC5Dt98+bNRY6TiIioILLv7J08eVJv05JKlSohNTXVKEERERFZEnMdERFZA9mVvXLlyiE5OVln/LFjx1C5cmWjBEVERGRJzHVERGQNZFf2evXqhXHjxiElJQWSJCE3Nxd79uzBmDFj0LdvX1PESEREZFbMdUREZA1kP7M3bdo09O/fH5UrV4YQArVr10ZOTg569eqFjz/+2BQxElE+pv1xxqjra3njW1nz7648yKjbNyiO7ZVMsk2iZzHXERGRNZBd2VMoFFixYgU++eQTHD16FLm5uQgKCkJAQIAp4iMiIjI75joiIrIGsit7atWqVUO1atWQk5ODkydP4t69eyhfvrwxYyMiIrIo5joiIirNZD+zN2rUKCxZsgQAkJOTg5CQELzwwgvw9vbGjh07jB0fERGR2THXERGRNZBd2fvll1/QoEEDAMDvv/+OK1eu4Ny5cxg1ahTGjx9v9ACJiIjMjbmOiIisgezK3p07d+Dh4QEA2LhxIyIjIxEYGIiBAwfi5MmTRg+QiIjI3JjriIjIGsiu7Lm7u+PMmTPIycnBpk2b8MorrwAAHj16BFtbW6MHSEREZG7MdUREZA1kd9AyYMAAREZGwtPTE5IkISwsDABw4MAB1KxZ0+gBEhERmRtzHRERWQPZlb2YmBjUrVsX169fR48ePaBSqQAAtra2+PDDD40eIBERkbkx1xERkTUo0qsXunfvrjOuX79+xQ6GiIiopGCuIyKi0q5Ilb2//voLc+fOxdmzZyFJEmrWrIlRo0ZpnmkgIjKVXRdvF3nZlwMqGTESsnbMdUREVNrJ7qBl/vz5aNeuHZydnTFy5EiMGDECLi4uaN++PebPn2+KGImIiMyKuY6IiKyB7Dt7sbGxmDt3LoYPH64ZN2LECLRo0QLTpk3TGk9ERFQaMdcREZE1kH1nLy0tDe3atdMZHx4ejrS0NKMERUREZEnMdUREZA1kV/Zee+01rFu3Tmf8r7/+io4dOxolKCIiIktiriMiImtgUDPOL774QvP/WrVqYdq0adixYweaN28OANi/fz/27NmD999/3zRREhERmRhzHRERWRuDKntz587VGi5fvjzOnDmDM2fOaMaVK1cO3333HT7++GPjRkhERGQGzHVERGRtDKrsJSYmmmTju3btwqxZs3DkyBEkJydj3bp16Ny5s2a6EAKTJ0/G4sWLce/ePTRt2hRfffUV6tSpY5J4iIjo+WWqXEdERGQpsp/ZU7tz5w5SU1OLtfGMjAw0aNAg326sZ86ciTlz5mD+/Pk4dOgQPDw8EBYWhvT09GJtl4iIyBDGyHVERESWIuvVC/fv38f48eOxevVq3Lt3D8DTZi6vv/46pk6dinLlysnaeEREBCIiIvROE0Jg3rx5GD9+PLp27QoAWLZsGdzd3bFy5UoMHjxY73KZmZnIzMzUDKt7TcvOztb611pwv0oXY++XjcgxynrUhGRbpO3biFytf42xblPIFjaAjLLncVi6GGt/jJ3riIiILMXgyt7du3fRvHlz3LhxA71790atWrUghMDZs2exdOlS/PXXX9i7dy/Kly9vlMASExORkpKC8PBwzTiVSoWQkBDs3bs338pebGwsJk+erDN++/btcHBwQHx8vFHiK2m4X6WLsfartlHW8j/33V6St/2cK1rDNXOTjLZuU9iYDmDjRtnL8Th8fpg71xEREZmSwZW9KVOmQKlU4vLly3B3d9eZFh4ejilTpug84F5UKSkpAKCzLXd3d1y9ejXf5aKjoxEVFaUZTktLg7e3N0JDQ3HgwAGEhYVBoVAYJcaSIDs7G/Hx8dyvUsIo+7V7jua/ey/fKXT2vZ59DV51cPL3skJRr9tG5KJmbhLO2VRFrqS/dbjcdZtCsH9FoGVU4TP+Px6HpUt2djZ+/fXXYq3D3LmOiIjIlAyu7K1fvx6LFi3SSX4A4OHhgZkzZ2LIkCFGT4CSJGkNCyF0xj1LpVJBpVLpjFdf0CgUCqu6uFHjfpUuxdov6X9NJSUDmnHmymg+acj6Clp3rmST7/bkrtsUFFIuUIRy53H4/LBUriMiIjIFgztoSU5OLrAXzLp162ruxhmDh4cHAOis89atW3qTMBERUXGZO9cRERGZksGVvYoVKyIpKSnf6YmJiahQoYIxYgIA+Pn5wcPDQ+uZkqysLOzcuRPBwcFG2w4REZGauXMdERGRKRncjLNdu3YYP3484uPjoVQqtaZlZmZiwoQJaNeunayNP3z4EJcuXdIMJyYmIiEhAa6urvDx8cGoUaMwffp0BAQEICAgANOnT4eDgwN69eolaztERESGMEWuIwvZHgsA2HXxts4kIdkCbi9h79KPIIkcvBxQydzRERGZhcGVvcmTJ6Nx48YICAjAsGHDULNmTQDAmTNn8PXXXyMzMxM//PCDrI0fPnwYoaGhmmF1xyr9+vXD0qVLMXbsWDx+/BhDhw7VvFR9y5YtcHZ2lrUdIiIiQ5gi1xEREVmKwZW9KlWqYN++fRg6dCiio6MhhADwtAOVsLAwzJ8/H97e3rI23qpVK8169JEkCTExMYiJiZG1XiIioqIwRa4jIiKyFFkvVffz88Off/6Je/fu4eLFiwCA6tWrw9XV1STBERERmRtzHRERWQtZlT218uXL48UXXzR2LERERCUGcx0REZV2BvfGSURERERERKUHK3tEREQmtGvXLnTs2BFeXl6QJAnr16/Xmi6EQExMDLy8vGBvb49WrVrh9OnTlgmWiIisCit7REREJpSRkYEGDRpg/vz5eqfPnDkTc+bMwfz583Ho0CF4eHggLCwM6enpZo6UiIisjUHP7L3wwgv466+/UL58eUyZMgVjxoyBg4ODqWMjIiIyG1PluoiICEREROidJoTAvHnzMH78eHTt2hUAsGzZMri7u2PlypUYPHiw3uUyMzORmZmpGU5LSwMAZGdnIzs7W2te9XDe8SWdjcgpdJ4C90k8/T1bSLa6k/5/nPrfbFGCfvu20OdUWo8TU2O56GKZ6DJnmcjdhkGVvbNnzyIjIwPly5fH5MmTMWTIEFb2iIjIqlgi1yUmJiIlJQXh4eGacSqVCiEhIdi7d2++lb3Y2FhMnjxZZ/yWLVvyjTk+Pt44QZtJbQPm2bjxSgFTn74jEW75z/GgUvOn6ylJN1E3brTo5kvbcWIuLBddLBNd5iiTR48eyZrfoMpew4YNMWDAALz00ksQQuCzzz6Dk5OT3nknTpwoKwAiIqKSwBK5LiUlBQDg7u6uNd7d3R1Xr17Nd7no6GhERUVphtPS0uDt7Y3w8HC4uLhozZudnY34+HiEhYVBoVAYJW5z+GzzuULnGdO2Zv4Td88BAOy9fEdnkpBs8aBSc5S9vQ+SyEGwf8Uix2l0LaMKn8cESutxYmosF10sE13mLBN1Sw5DGVTZW7p0KSZNmoQNGzZAkiT8+eefKFNGd1FJkljZIyKiUsmSuU6SJK1hIYTOuGepVCqoVCqd8QqFIt8LjYKmlUS5eppf5lXg/ki5T/8poDmoJHIgiRwo/n/eEsHCn1FpO07MheWii2WiyxxlInf9BlX2atSogVWrVgEAbGxs8Ndff8HNrYB2EURERKWMJXKdh4cHgKd3+Dw9PTXjb926pXO3j4iISC7ZTyTn5uayokdERFbNXLnOz88PHh4eWs95ZGVlYefOnQgODjb59omIyLoZdGcvr8uXL2PevHk4e/YsJElCrVq1MHLkSPj7+xs7PiIiIoswVq57+PAhLl26pBlOTExEQkICXF1d4ePjg1GjRmH69OkICAhAQEAApk+fDgcHB/Tq1cvYu0RERM8Z2Xf2Nm/ejNq1a+PgwYOoX78+6tatiwMHDqBOnTrslYeIiKyCMXPd4cOHERQUhKCgIABAVFQUgoKCNM/9jR07FqNGjcLQoUPRuHFj3LhxA1u2bIGzs7PR94uIiJ4vsu/sffjhhxg9ejQ+/fRTnfHjxo1DWFiY0YIjIiKyBGPmulatWkEIke90SZIQExODmJiYooZLRESkl+w7e2fPnsXAgQN1xr/11ls4c+aMUYIiIiKyJOY6IiKyBrLv7FWqVAkJCQkICAjQGp+QkMCOW4iIyCow15UO0/7Iv+Ld8sZtM0ZiRNtji7d8aLRx4iAiqyC7svf222/jnXfewZUrVxAcHAxJkvD3339jxowZeP/9900RIxERkVkx1xERkTWQXdmbMGECnJ2dMXv2bERHP/31yMvLCzExMRgxYoTRAyQiIjI35joiIrIGsit7kiRh9OjRGD16NNLT0wGAPYYREZFVYa4jIiJrUKT37Kkx8RERkbVjriMiotJKdm+cREREREREVPKxskdERERERGSFWNkjIiIiIiKyQrKe2cvOzkZ4eDgWLVqEwMBAU8VE9FyZ9scZtLzxraXDKBJ13EKyxX23lxCc/D0kkWPhqIiKh7mOiIishazKnkKhwKlTpyBJkqniISIisijmOtMr6GXoRERkPLKbcfbt2xdLliwxRSxEREQlAnMdERFZA9mvXsjKysK3336L+Ph4NG7cGI6OjlrT58yZY7TgiIiILIG5joiIrIHsyt6pU6fwwgsvAAAuXLigNY1NXoiIyBow1xERkTWQXdnbvn27KeIgIiIqMZjriIjIGhT51QuXLl3C5s2b8fjxYwCAEMJoQREREZUEzHVERFSaya7spaamok2bNggMDET79u2RnJwMABg0aBDef/99owdIRERkbsx1RERkDWRX9kaPHg2FQoFr167BwcFBM75nz57YtGmTUYMjIiKyBOY6IiKyBrKf2duyZQs2b96MKlWqaI0PCAjA1atXjRYYERGRpTDXERGRNZB9Zy8jI0PrV061O3fuQKVSGSUoIiIiS2KuIyIiayC7svfyyy/j+++/1wxLkoTc3FzMmjULoaGhRg2OiIjIEpjriIjIGshuxjlr1iy0atUKhw8fRlZWFsaOHYvTp0/j7t272LNnjyliJCIiMivmOiIisgay7+zVrl0bJ06cwIsvvoiwsDBkZGSga9euOHbsGPz9/U0RIxERkVkx1xERkTWQfWcPADw8PDB58mRjx0JERFRiMNcREVFpV6TK3r1797BkyRKcPXsWkiShVq1aGDBgAFxdXY0dHxERkUUw1xERUWknuxnnzp074efnhy+++AL37t3D3bt38cUXX8DPzw87d+40RYxERERmxVxHRETWQHZlb9iwYYiMjERiYiLWrl2LtWvX4sqVK3j99dcxbNgwowYXExMDSZK0/jw8PIy6DSIiorzMmeuIiIhMRXZl7/Lly3j//fdha2urGWdra4uoqChcvnzZqMEBQJ06dZCcnKz5O3nypNG3QURE9Cxz5zoiIiJTkP3M3gsvvICzZ8+iRo0aWuPPnj2Lhg0bGisujTJlyvBuHhERmZW5cx3pannjW0uHQERU6hlU2Ttx4oTm/yNGjMDIkSNx6dIlNGvWDACwf/9+fPXVV/j000+NHuDFixfh5eUFlUqFpk2bYvr06ahWrVq+82dmZiIzM1MznJaWBgDIzs7W+tdacL9KF337ZSNyICTb/BYpNhuRY/C8RY1DvZwp98MYsoUNIOOYep6OQ2tQ3P2xZK4jIiIyBUkIIQqbycbGBpIkobBZJUlCTo7hF5aF+fPPP/Ho0SMEBgbi33//xdSpU3Hu3DmcPn0aFSpU0LtMTEyM3q6yV65cCQcHB6PFRkREJc+jR4/Qq1cvPHjwAC4uLrKWtVSuM4a0tDSULVtW735nZ2dj48aNaN++PRQKhYUi1DbtjzOFzmPKO3tCssV9t5dQ7tbfkEQOXg6oZLJtmV1odJEWK4nHSUnActHFMtFlzjIp6Hyvj0F39hITE4sdWFFERERo/l+vXj00b94c/v7+WLZsGaKiovQuEx0drTUtLS0N3t7eCA0NxYEDBxAWFmZVB2Z2djbi4+O5X6WEvv36bPM5BCd/b7Jt7vXsa/C8RY1DSLZ4UKk5yt7eB0nGnURzC/avCLTUf+7Q53k6Dq1BdnY2fv311yIvb6lcR0REZCoGVfZ8fX1NHYdBHB0dUa9ePVy8eDHfeVQqFVQqlc549QWNQqGwqosbNe5X6fLsfuVKtiatIOXKaFpZ3DgkkVOiK3sKKRcowvH0PByHVHJyHRERkbEU6aXqN27cwJ49e3Dr1i3k5uZqTRsxYoRRAtMnMzMTZ8+eRcuWLU22DSIiIsByuY6IiMhYZFf24uLiMGTIECiVSlSoUAGSJGmmSZJk1AQ4ZswYdOzYET4+Prh16xamTp2KtLQ09OvXz2jbICIiysucuU7fs+bu7u5ISUkx2jaIiOj5JLuyN3HiREycOBHR0dGwsZH9mj5Z/vnnH7zxxhu4c+cOKlWqhGbNmmH//v1sakNERCZlzlwHPH2n7NatWzXDz77fj4iIqKhkV/YePXqE119/3SzJb9WqVSbfBhERUV7mzHWA/HfKFvSaobyvoCiJr9ow5JUwpnyVS97XxWQL83zOZlHEz7kkHiclActFF8tElznLRO42ZFf2Bg4ciJ9//hkffvih3EWJiIhKBXPnOrnvlI2NjdX7mqEtW7bk+5qh+Ph4o8VbXLUNmOe+20smj+NBpeYAgI3pJt+U+WzcWKzFS9JxUpKwXHSxTHSZo0wePXoka37Zlb3Y2Fh06NABmzZtQr169XR6cpszZ47cVRIREZUo5sx1TZs2xffff6/1Ttng4OAC3ymb32uGwsPD9b5nr6S9auOzzecKnceUr6SR+7qYYP+Khc6z9/Ido6yn2GS8XuZZJfE4KQlYLrpYJrrMWSbqlhyGkl3Zmz59OjZv3owaNWoAgM5D60RERKWdOXNdUd4pW9BrhvK70ChJr9ow5JUw5niNi6Gvi1FIuYXOY6z1FFsxP+OSdJyUJCwXXSwTXeYoE7nrl13ZmzNnDr777jv0799f7qJEz4/tsfrHCxsANYHdc4D/T/otb9w2aSgtb3xr0vU/L6b9cabIy45/1ZBGa1SSWDLXGfJOWSIiIkPIfiJZpVKhRYsWpoiFiIioRLBkrlO/U9bT09Mi2yciIushu7I3cuRIfPnll6aIhYiIqEQwZ64bM2YMdu7cicTERBw4cADdu3fnO2WJiMgoZDfjPHjwILZt24YNGzagTp06Ou1G165da7TgiIiILMGcuY7vlCUiIlORXdkrV64cunbtaopYiIiISgRz5jq+U5aIiExFdmUvLi7OFHEQERGVGMx1RERkDWQ/s0dEREREREQln+w7e35+fgW+Y+jKlSvFCoiIiMjSmOuIiMgayK7sjRo1Sms4Ozsbx44dw6ZNm/DBBx8YKy4iIiKLYa4jIiJrILuyN3LkSL3jv/rqKxw+fLjYAREREVkacx0REVkDoz2zFxERgTVr1hhrdURERCUOcx0REZUmsu/s5eeXX36Bq6ursVZHRGQa22MNn1fYAKhpslCo9GGuIyKi0kR2ZS8oKEjroXUhBFJSUnD79m18/fXXRg2OiIjIEpjriIjIGsiu7HXu3Flr2MbGBpUqVUKrVq1QsyZ/ASciotKPuY6IiKyB7MrepEmTTBEHERFRicFcR0RE1sBoz+wRERERTfvjjKVDMLpdF29bOgQioiIxuLJnY2NT4AtmAUCSJDx58qTYQREREVkCcx0REVkTgyt769aty3fa3r178eWXX0IIYZSgiIiILIG5joiIrInBlb1OnTrpjDt37hyio6Px+++/o3fv3vjkk0+MGhwREZE5MdcREZE1KdJL1W/evIm3334b9evXx5MnT5CQkIBly5bBx8fH2PERERFZBHMdERGVdrIqew8ePMC4ceNQvXp1nD59Gn/99Rd+//131K1b11TxERERmRVzHRERWQuDm3HOnDkTM2bMgIeHB3788Ue9TV2Inld5e59reUN/z21CsgXcgL2X70ASOeYIjYhkYK4jIiJrYnBl78MPP4S9vT2qV6+OZcuWYdmyZXrnW7t2rdGCIyIiMifmOiIisiYGV/b69u1baHfUREREpRlzHRERWRODK3tLly41YRhERESW97znOkNeiD7+1dpmiISIiIyhSL1xEhERERERUcnGyh4REREREZEVYmWPiIiIiIjICrGyR0REREREZIVY2SMiIiIiIrJCrOwRERERERFZIYNfvfC8M6Q76vywm2p5pv1xBjYiB7UBfLb5HHIlW4OXlV3W22M1/9118ba8ZZ/RsshLkjnJ/YyFZAu4PT0OIeM4zCu/80fLG98WeZ0F2V15EIAScu555jtWqNBo08VBRET0HOKdPSIiIiIiIivEO3tEREREJYQhLRBeDqiU/0Q5d9OfJWwA1CzasmZgSAurEtGagayfvu+Y+vuzew4g5Ra8vJlbsfDOHhERERERkRViZY+IiIiIiMgKsbJHRERERERkhVjZIyIiIiIiskKlorL39ddfw8/PD3Z2dmjUqBF2795t6ZCIiIiMirmOiIiMrcRX9lavXo1Ro0Zh/PjxOHbsGFq2bImIiAhcu3bN0qEREREZBXMdERGZQomv7M2ZMwcDBw7EoEGDUKtWLcybNw/e3t5YsGCBpUMjIiIyCuY6IiIyhRL9nr2srCwcOXIEH374odb48PBw7N27V+8ymZmZyMzM1Aw/ePAAAHD37l08evQIqampUCgU8mPJeCB7GbXU1NQiL1uY7OzsYu1XSZSV8QA2IhePch8hyyYNuZLhv0nILuuHWf/7739P5C1bBEISePToEcr89wSSyDH59szF2vdL7nFoKFMdc+rzVX7fB7OeN575jhWqmOdK9X4BgBCiWOsyJ2PnuuzsbK155XzehuS6ws6zxcmXzzLlOdlS56xUA74Phuy3IeuRK1vYlOjrCWMcm0VhjddZxfXcl4me75/m+yNlQVHYe/aKeZymp6cDMDzPlejK3p07d5CTkwN3d3et8e7u7khJSdG7TGxsLCZPnqwzPjAw0CQxGmKKxbb8/GFZEwHAlwBK4/chxmhrSk9PR9myZY22PlMyZq7z8/MzSYzPKn3HFT0veGxS6RBjlLUYmudKdGVPTZIkrWEhhM44tejoaERFRWmGc3NzcffuXSgUCvj4+OD69etwcXExabzmlJaWBm9vb+5XKcH9Kl24X6WLer/OnDkDLy8vS4cjmzFyXYUKFXSWsdbPuzhYJrpYJvqxXHSxTHSZs0yEEEhPTzc4z5Xoyl7FihVha2ur88vmrVu3dH4BVVOpVFCpVFrjypUrh7S0NACAi4uLVR6Y3K/ShftVunC/SpfKlSvDxqbEP5KuYcxcVxBr/byLg2Wii2WiH8tFF8tEl7nKRE7LlRKdDZVKJRo1aoT4+Hit8fHx8QgODrZQVERERMbDXEdERKZSou/sAUBUVBT69OmDxo0bo3nz5li8eDGuXbuGIUOGWDo0IiIio2CuIyIiUyjxlb2ePXsiNTUVU6ZMQXJyMurWrYuNGzfC19dX1npUKhUmTZqk0+yltON+lS7cr9KF+1W6lOb9Mlau06c0l4upsEx0sUz0Y7noYpnoKsllIonS1D81ERERERERGaREP7NHRERERERERcPKHhERERERkRViZY+IiIiIiMgKsbJHRERERERkhZ77yl5mZiYaNmwISZKQkJBg6XCK7bXXXoOPjw/s7Ozg6emJPn364ObNm5YOq1iSkpIwcOBA+Pn5wd7eHv7+/pg0aRKysrIsHVqxTZs2DcHBwXBwcCj0hcgl2ddffw0/Pz/Y2dmhUaNG2L17t6VDKrZdu3ahY8eO8PLygiRJWL9+vaVDKrbY2Fg0adIEzs7OcHNzQ+fOnXH+/HlLh1VsCxYsQP369TUvs23evDn+/PNPS4dVIlnLOae4rPGcVRzWeL4rDms9VxYHz7OFi42NhSRJGDVqlKVD0fLcV/bGjh0LLy8vS4dhNKGhofjpp59w/vx5rFmzBpcvX0b37t0tHVaxnDt3Drm5uVi0aBFOnz6NuXPnYuHChfjoo48sHVqxZWVloUePHnj33XctHUqRrV69GqNGjcL48eNx7NgxtGzZEhEREbh27ZqlQyuWjIwMNGjQAPPnz7d0KEazc+dODBs2DPv370d8fDyePHmC8PBwZGRkWDq0YqlSpQo+/fRTHD58GIcPH0br1q3RqVMnnD592tKhlTjWcM4pLms9ZxWHNZ7visNaz5XFwfNswQ4dOoTFixejfv36lg5Fl3iObdy4UdSsWVOcPn1aABDHjh2zdEhG9+uvvwpJkkRWVpalQzGqmTNnCj8/P0uHYTRxcXGibNmylg6jSF588UUxZMgQrXE1a9YUH374oYUiMj4AYt26dZYOw+hu3bolAIidO3daOhSjK1++vPj2228tHUaJVZrPOcX1PJyzisNaz3fFYc3nyuLgefap9PR0ERAQIOLj40VISIgYOXKkpUPS8tze2fv333/x9ttv44cffoCDg4OlwzGJu3fvYsWKFQgODoZCobB0OEb14MEDuLq6WjqM515WVhaOHDmC8PBwrfHh4eHYu3evhaIiQz148AAArOq7lJOTg1WrViEjIwPNmze3dDhUwvCcRUVhjefK4uB5VtuwYcPw6quv4pVXXrF0KHqVsXQAliCEQP/+/TFkyBA0btwYSUlJlg7JqMaNG4f58+fj0aNHaNasGTZs2GDpkIzq8uXL+PLLLzF79mxLh/Lcu3PnDnJycuDu7q413t3dHSkpKRaKigwhhEBUVBReeukl1K1b19LhFNvJkyfRvHlz/Pfff3BycsK6detQu3ZtS4dFJQzPWSSXtZ0ri4PnWV2rVq3C0aNHcejQIUuHki+rurMXExMDSZIK/Dt8+DC+/PJLpKWlITo62tIhG8TQ/VL74IMPcOzYMWzZsgW2trbo27cvhBAW3AP95O4XANy8eRPt2rVDjx49MGjQIAtFXrCi7FdpJ0mS1rAQQmcclSzDhw/HiRMn8OOPP1o6FKOoUaMGEhISsH//frz77rvo168fzpw5Y+mwzOJ5POcUF89ZZChrO1cWx/N8ntXn+vXrGDlyJJYvXw47OztLh5Mvq7qzN3z4cLz++usFzlO1alVMnToV+/fvh0ql0prWuHFj9O7dG8uWLTNlmLIZul9qFStWRMWKFREYGIhatWrB29sb+/fvL3G32uXu182bNxEaGormzZtj8eLFJo6u6OTuV2lWsWJF2Nra6vwifuvWLZ1fzqnkeO+99/Dbb79h165dqFKliqXDMQqlUonq1asDeHouP3ToED7//HMsWrTIwpGZ3vN0zikunrNIDms8VxbH83ye1efIkSO4desWGjVqpBmXk5ODXbt2Yf78+cjMzIStra0FI3zKqip76kpOYb744gtMnTpVM3zz5k20bdsWq1evRtOmTU0ZYpEYul/6qO/oZWZmGjMko5CzXzdu3EBoaCgaNWqEuLg42NiU3JvSxfm8ShulUolGjRohPj4eXbp00YyPj49Hp06dLBgZ6SOEwHvvvYd169Zhx44d8PPzs3RIJiOEKJHnPVN4ns45xcVzFhnieTpXFsfzdJ7Vp02bNjh58qTWuAEDBqBmzZoYN25ciajoAVZW2TOUj4+P1rCTkxMAwN/fv1T/cnPw4EEcPHgQL730EsqXL48rV65g4sSJ8Pf3L3F39eS4efMmWrVqBR8fH3z22We4ffu2ZpqHh4cFIyu+a9eu4e7du7h27RpycnI073qsXr265rgs6aKiotCnTx80btxYc9f12rVrGDJkiKVDK5aHDx/i0qVLmuHExEQkJCTA1dVV5xxSWgwbNgwrV67Er7/+CmdnZ83djbJly8Le3t7C0RXdRx99hIiICHh7eyM9PR2rVq3Cjh07sGnTJkuHVuJYwzmnuKz1nFUc1ni+Kw5rPVcWB8+zupydnXWe43R0dESFChVK1vOdFuoFtERJTEy0ilcvnDhxQoSGhgpXV1ehUqlE1apVxZAhQ8Q///xj6dCKJS4uTgDQ+1fa9evXT+9+bd++3dKhyfLVV18JX19foVQqxQsvvGAV3VNv375d72fTr18/S4dWZPl9j+Li4iwdWrG89dZbmuOvUqVKok2bNmLLli2WDqtEspZzTnFZ4zmrOKzxfFcc1nquLA6eZw1TEl+9IAlRAnvuICIiIiIiomIpuQ8+ERERERERUZGxskdERERERGSFWNkjIiIiIiKyQqzsERERERERWSFW9oiIiIiIiKwQK3tERERERERWiJU9IiIiIiIiK8TKHhERERERkRViZY9KpKpVq2LevHmWDsNoduzYAUmScP/+fUuHUmySJGH9+vX5Tk9KSoIkSUhISDDqdgs7Jvr37w9JkgqNrzhatWqFUaNGaQ2rt2ns/S0tdu3ahY4dO8LLy8ukZf+sGzdu4M0330SFChXg4OCAhg0b4siRIybfLpGxMdeVXMx1o7SGmetKb65jZY/M6vr16xg4cCC8vLygVCrh6+uLkSNHIjU11dKhGU3ekyQABAcHIzk5GWXLljXptp9NAmXKlIGPjw/effdd3Lt3z2jbSE5ORkREhNHWZ0zt2rUza3xr167FwYMHzbKtkiojIwMNGjTA/PnzzbK9e/fuoUWLFlAoFPjzzz9x5swZzJ49G+XKlTPL9okMwVzHXGdKzHXmV5pzXRnjh0ek35UrV9C8eXMEBgbixx9/hJ+fH06fPo0PPvgAf/75J/bv3w9XV1eLxJaTkwNJkmBjY5rfP5RKJTw8PEyy7rzatWuHuLg4PHnyBGfOnMFbb72F+/fv48cffzTK+s21H0WhUqkKjS87OxsKhcIo23N1dUVaWppR1lVaRUREFHjBkZWVhY8//hgrVqzA/fv3UbduXcyYMQOtWrUq0vZmzJgBb29vxMXFacZVrVq1SOsiMgXmOuY6U2OuM7/SnOt4Z4/MZtiwYVAqldiyZQtCQkLg4+ODiIgIbN26FTdu3MD48eO15k9PT0evXr3g5OQELy8vfPnll1rTY2Ji4OPjA5VKBS8vL4wYMUIzLSsrC2PHjkXlypXh6OiIpk2bYseOHZrpS5cuRbly5bBhwwbUrl0bKpUK33zzDezs7HSan4wYMQIhISEAgNTUVLzxxhuoUqUKHBwcUK9ePa3E0r9/f+zcuROff/655lfHpKQkvU1b1qxZgzp16kClUqFq1aqYPXu21narVq2K6dOn46233oKzszN8fHywePHiQstZnQSqVKmC8PBw9OzZE1u2bNGaJy4uDrVq1YKdnR1q1qyJr7/+Wqvshg8fDk9PT9jZ2aFq1aqIjY3VTM/bfOHgwYMICgqCnZ0dGjdujGPHjmltS13Wz1q/fj0kSdIMX758GZ06dYK7uzucnJzQpEkTbN26tdB9LYy6mc1PP/2EVq1awc7ODsuXLy/0cwSe/orXt29fODk5wdPTU+fzIcMMGDAAe/bswapVq3DixAn06NED7dq1w8WLF4u0vt9++w2NGzdGjx494ObmhqCgIHzzzTdGjpqo6JjrmOvUmOueHyU61wkiM0hNTRWSJInp06frnf7222+L8uXLi9zcXCGEEL6+vsLZ2VnExsaK8+fPiy+++ELY2tqKLVu2CCGE+Pnnn4WLi4vYuHGjuHr1qjhw4IBYvHixZn29evUSwcHBYteuXeLSpUti1qxZQqVSiQsXLgghhIiLixMKhUIEBweLPXv2iHPnzomHDx8Kd3d38e2332rW8+TJE+Hu7i4WLVokhBDin3/+EbNmzRLHjh0Tly9f1sS1f/9+IYQQ9+/fF82bNxdvv/22SE5OFsnJyeLJkydi+/btAoC4d++eEEKIw4cPCxsbGzFlyhRx/vx5ERcXJ+zt7UVcXJxm276+vsLV1VV89dVX4uLFiyI2NlbY2NiIs2fP5lvO/fr1E506ddIMX758WdSuXVu4u7trxi1evFh4enqKNWvWiCtXrog1a9YIV1dXsXTpUiGEELNmzRLe3t5i165dIikpSezevVusXLlSszwAsW7dOiGEEA8fPhSVKlUSPXv2FKdOnRK///67qFatmgAgjh07pinrsmXLasW5bt068ezpJyEhQSxcuFCcOHFCXLhwQYwfP17Y2dmJq1evapXH3LlzDd53IYRITEwUAETVqlU1+3vjxo1CP0chhHj33XdFlSpVxJYtW8SJEydEhw4dhJOTkxg5cqTebaj393n27LEhhBCXLl0SkiSJGzduaM3Xpk0bER0dXaRtqFQqoVKpRHR0tDh69KhYuHChsLOzE8uWLStO6ERGwVzHXPcs5jrrVNpyHSt7ZBb79+/X+XI8a86cOQKA+Pfff4UQT0927dq105qnZ8+eIiIiQgghxOzZs0VgYKDIysrSWZchX7q4uDgBQCQkJGjNM2LECNG6dWvN8ObNm4VSqRR3797Nd9/at28v3n//fc1wSEiIzkkybwLs1auXCAsL05rngw8+ELVr19YM+/r6ijfffFMznJubK9zc3MSCBQvyjaVfv37C1tZWODo6Cjs7OwFAABBz5szRzOPt7a2V0IQQ4pNPPhHNmzcXQgjx3nvvidatW2suRvJ69nNctGiRcHV1FRkZGZrpCxYskJ0A9aldu7b48ssvNcPFSYDz5s0rcFtCaH+O6enpQqlUilWrVmmmp6amCnt7eybAAuT9jv/0008CgHB0dNT6K1OmjIiMjBRC/K/8CvobNmyYZp0KhUJzrKq99957olmzZmbZR6KCMNcx1z2Luc46lbZcx2f2qER4+t2BVnOH5s2ba83TvHlzTQ9VPXr0wLx581CtWjW0a9cO7du3R8eOHVGmTBkcPXoUQggEBgZqLZ+ZmYkKFSpohpVKJerXr681T+/evdG8eXPcvHkTXl5eWLFiBdq3b4/y5csDePq8w6efforVq1fjxo0byMzMRGZmJhwdHWXt79mzZ9GpUyetcS1atMC8efOQk5MDW1tbANCKT5IkeHh44NatWwWuOzQ0FAsWLMCjR4/w7bff4sKFC3jvvfcAALdv39Z0HPD2229rlnny5Inmgfr+/fsjLCwMNWrUQLt27dChQweEh4fnux8NGjSAg4ODZlzez80QGRkZmDx5MjZs2ICbN2/iyZMnePz4Ma5duyZ7Xfo0btxYa7iwz/Hy5cvIysrS2hdXV1fUqFHDKPE8L3Jzc2Fra4sjR45ojmk1JycnAEDlypVx9uzZAtej/v4BgKenJ2rXrq01vVatWlizZo2RoiYyHeY65jrmOutT0nMdK3tkFtWrV4ckSThz5gw6d+6sM/3cuXMoX748KlasWOB61AnS29sb58+fR3x8PLZu3YqhQ4di1qxZ2Llzp0FfOgCwt7fXSrgA8OKLL8Lf3x+rVq3Cu+++i3Xr1mk9HDt79mzMnTsX8+bNQ7169eDo6IhRo0YhKytLVnkIIXS2rb4IeFbeh6slSUJubm6B63Z0dET16tUBAF988QVCQ0MxefJkfPLJJ5plv/nmGzRt2lRrOXVZvfDCC0hMTMSff/6JrVu3IjIyEq+88gp++eUXvftRGBsbG535srOztYY/+OADbN68GZ999hmqV68Oe3t7dO/eXXa55ifvBUphn6Mh+0WFCwoKQk5ODm7duoWWLVvqnUehUKBmzZoGr7NFixY4f/681rgLFy7A19e3WLESGQNznTbmOua650FJz3Ws7JFZVKhQAWFhYfj6668xevRo2Nvba6alpKRgxYoV6Nu3r1ZS2L9/v9Y69u/fr/VFsbe3x2uvvYbXXnsNw4YNQ82aNXHy5EmDvnQF6dWrF1asWIEqVarAxsYGr776qmba7t270alTJ7z55psAnv6ac/HiRdSqVUszj1KpRE5OToHbqF27Nv7++2+tcXv37kVgYKBO0i6uSZMmISIiAu+++y68vLxQuXJlXLlyBb179853GRcXF/Ts2RM9e/ZE9+7d0a5dO9y9e1enB7natWvjhx9+wOPHjzWfad7PrVKlSkhPT0dGRoYmEeV9T8/u3bvRv39/dOnSBQDw8OFDJCUlFXPP81fY51i9enUoFArs378fPj4+AJ52g3zhwgVNBwb01MOHD3Hp0iXNcGJiIhISEuDq6orAwED07t0bffv2xezZsxEUFIQ7d+5g27ZtqFevHtq3by97e6NHj0ZwcDCmT5+OyMhIHDx4EIsXLzaoQwciU2Ou08Zcl6A1D3Nd6VWacx174ySzmT9/PjIzM9G2bVvs2rUL169fx6ZNmxAWFobKlStj2rRpWvPv2bMHM2fOxIULF/DVV1/h559/xsiRIwE87fVqyZIlOHXqFK5cuYIffvgB9vb28PX11frSrV27FomJiTh06BBmzJiBjRs3Fhpn7969cfToUUybNg3du3eHnZ2dZlr16tURHx+PvXv34uzZsxg8eDBSUlK0lq9atSoOHDiApKQk3LlzR++vk++//z7++usvfPLJJ7hw4QKWLVuG+fPnY8yYMUUp2gK1atUKderUwfTp0wE87dktNjYWn3/+OS5cuICTJ08iLi4Oc+bMAQDMnTsXq1atwrlz53DhwgX8/PPP8PDw0Ptul169esHGxgYDBw7EmTNnsHHjRnz22Wda8zRt2hQODg746KOPcOnSJaxcuRJLly7Vmqd69epYu3YtEhIScPz4cfTq1avQX3WLo7DP0cnJCQMHDsQHH3yAv/76C6dOnUL//v1N1l15aXb48GEEBQUhKCgIABAVFYWgoCBMnDgRwNPe8Pr27Yv3338fNWrUwGuvvYYDBw7A29u7SNtr0qQJ1q1bhx9//BF169bFJ598gnnz5hV4QUdkTsx1/8Nct1RrHua60qtU5zrZT/kRFUNSUpLo37+/8PDwEAqFQnh7e4v33ntP3LlzR2s+X19fMXnyZBEZGSkcHByEu7u71oPH69atE02bNhUuLi7C0dFRNGvWTGzdulUzPSsrS0ycOFFUrVpVKBQK4eHhIbp06SJOnDghhND/IPWzmjRpIgCIbdu2aY1PTU0VnTp1Ek5OTsLNzU18/PHHom/fvloPS58/f140a9ZM2NvbCwAiMTFR56F1IYT45ZdfRO3atYVCoRA+Pj5i1qxZOmWQ9yHtBg0aiEmTJuUbt74Ht4UQYsWKFUKpVIpr165phhs2bCiUSqUoX768ePnll8XatWuFEE97MGvYsKFwdHQULi4uok2bNuLo0aOadSHPg8n79u0TDRo0EEqlUjRs2FCsWbNG5yHudevWierVqws7OzvRoUMHsXjxYq2H1hMTE0VoaKiwt7cX3t7eYv78+ToP/xfnofW8D5Qb8jmmp6eLN998U3P8zZw5U2+HBHxonYjyYq67p5mPuY65jixLEoINdomo9Ovfvz/u37+v9V4kc0hKSoKfnx+OHTuGhg0bmnXbRET0fGGuI7l4n5aIrMaGDRvg5OSEDRs2mGV7ERERqFOnjlm2RUREBDDXkTy8s0dEVuHWrVtIS0sD8LTLYrldhBfFjRs38PjxYwCAj48PlEqlybdJRETPL+Y6kouVPSIiIiIiIivEZpxERERERERWiJU9IiIiIiIiK8TKHhERERERkRViZY+IiIiIiMgKsbJHRERERERkhVjZIyIiIiIiskKs7BEREREREVkhVvaIiIiIiIis0P8BMIMIvc1SFd4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_observatories = 6\n", + "nbins = 20\n", + "number_of_columns = 2\n", + "transparency = 0.5\n", + "\n", + "number_of_rows = (\n", + " int(num_observatories / number_of_columns)\n", + " if num_observatories % number_of_columns == 0\n", + " else int((num_observatories + 1) / number_of_columns)\n", + ")\n", + "\n", + "# we retrieve the observatory names again\n", + "observatory_names_hist = (\n", + " batch.observatories_table(exclude_space_telescopes=True)\n", + " .set_index(\"Code\")\n", + " .sort_values(\"count\", ascending=False)\n", + " .iloc[0:num_observatories]\n", + ")\n", + "\n", + "top_observatories_hist = observatory_names_hist.index.tolist()\n", + "\n", + "\n", + "fig, axs = plt.subplots(\n", + " number_of_rows,\n", + " number_of_columns,\n", + " figsize=(4.5 * number_of_columns, 3 * number_of_rows),\n", + ")\n", + "\n", + "axs = axs.flatten()\n", + "\n", + "for idx, observatory in enumerate(top_observatories_hist):\n", + " name = f\"{observatory} | {observatory_names_hist.loc[observatory].Name} | {int(observatory_names_hist.loc[observatory]['count'])} obs\"\n", + "\n", + " axs[idx].hist(\n", + " finalresiduals[concatenated_receiving_observatories == observatory][0::2],\n", + " bins=nbins,\n", + " alpha=transparency + 0.05,\n", + " label=\"Right Ascension\",\n", + " )\n", + " axs[idx].hist(\n", + " finalresiduals[concatenated_receiving_observatories == observatory][1::2],\n", + " bins=nbins,\n", + " alpha=transparency,\n", + " label=\"Declination\",\n", + " )\n", + "\n", + " axs[idx].grid()\n", + " axs[idx].set_title(name)\n", + " axs[idx].set_ylabel(\"Number of Observations\")\n", + " axs[idx].set_xlabel(\"Observation Residual [rad]\")\n", + "\n", + "axs[0].legend()\n", + "\n", + "fig.suptitle(\n", + " f\"Final residual histograms of the {num_observatories} observatories with the most observations for {target_name}\"\n", + ")\n", + "fig.set_tight_layout(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's it for this tutorial! The final estimation result is quite close to spice at times, but there is clearly plenty of room for improvement in both the dynamical model and the estimation settings. Consider for example adding weights and biases on observations and links as well as improved integrator settings and perturbations. \n", + "\n", + "Consider rerunning the script for some other object by changing the `target_mpc_code` variable and seeing how the results change." ] } ],