{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Initial State Estimation Using NOE-5 Ephemeris\n", "Copyright (c) 2010-2022, 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", "## Objectives\n", "This example illustrates how to optimize the **initial conditions** of a fixed dynamical model to **better match the available ephemeris of a celestial body**, using them as **\"artificial\" observations**. By adjusting the initial state, the goal is to minimize the discrepancy between the model’s predicted orbit and the ephemeris provided orbit over time. \n", "\n", "We will showcase how we can **enhance the accuracy of predicted orbits of the Galilean moons** based on the most current ephemerides (**NOE-5**) published by [Institut de mécanique céleste et de calcul des éphémérides](https://www.imcce.fr/institut/presentation/) (IMCEE).\n", "\n", "In particular, we will:\n", "\n", "1) **simulate observations** based on the ephemerides of the Galilean moons;\n", "2) **estimate an improved initial state** for all four moons, such that\n", " the propagated orbit **minimizes the observations (ephemeris) residuals**\n", "3) inspecting the (correct) representation and stability of the **Laplace resonance** between the inner three moons (Io, Europa, and Ganymede)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Import Statements\n", "Typically - in the most pythonic way - all required modules are imported at the very beginning.\n", "\n", "Some standard modules are first loaded: `numpy` and `matplotlib.pyplot`. Within this example, while no particular new functionality of `tudatpy` will be introduced, we will nevertheless explore the already known parts of the `estimation` module in more depth and how it can be applied to **intricate problems**." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:44.988957Z", "iopub.status.busy": "2025-09-15T19:13:44.988806Z", "iopub.status.idle": "2025-09-15T19:13:45.594833Z", "shell.execute_reply": "2025-09-15T19:13:45.594230Z" } }, "outputs": [], "source": [ "# General imports\n", "import math\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", "import matplotlib.dates as mdates\n", "\n", "# tudatpy imports\n", "from tudatpy import util\n", "from tudatpy import constants\n", "from tudatpy.interface import spice\n", "from tudatpy import dynamics\n", "from tudatpy.dynamics import environment, environment_setup\n", "from tudatpy.dynamics import propagation_setup, parameters_setup, simulator\n", "from tudatpy import estimation\n", "from tudatpy.estimation import observable_models_setup, observable_models, observations_setup, observations, estimation_analysis\n", "from tudatpy.astro import time_representation\n", "from tudatpy.astro.time_representation import DateTime\n", "from tudatpy.astro import element_conversion" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Orbital Simulation\n", "Entirely independent of the upcoming estimation-process, we first have to:\n", "\n", "* define the **general settings of the simulation**\n", "* create the **environment**\n", "* define all relevant **propagation settings**\n", "\n", "### Simulation Settings\n", "Besides importing tudat's standard kernels - which handily already include a version of the **NOE-5 ephemeris**, for more details see also the `load_standard_kernels` function - in terms of time-wise settings we have (arbitrarily) chosen to make use of the nominal duration of ESA's JUICE mission as scope of our simulation. Nonetheless, note that any other reasonably long time-span would have been equally sufficient." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:45.596874Z", "iopub.status.busy": "2025-09-15T19:13:45.596644Z", "iopub.status.idle": "2025-09-15T19:13:45.642162Z", "shell.execute_reply": "2025-09-15T19:13:45.641711Z" } }, "outputs": [], "source": [ "# Load spice kernels\n", "spice.load_standard_kernels()\n", "\n", "# Define temporal scope of the simulation - equal to the time JUICE will spend in orbit around Jupiter\n", "simulation_start_epoch = DateTime(2031, 7, 2).epoch()\n", "simulation_end_epoch = DateTime(2035, 4, 20).epoch()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Create the Environment\n", "For the problem at hand, the **environment** consists of the Jovian system with its four largest moons - Io, Europa, Ganymede, and Callisto - as well as Saturn and the Sun which will be relevant when creating some **perturbing accelerations** afterwards. \n", "\n", "While slightly altering the standard settings of the moons, such that their rotation around their own main axis resembles a synchronous rotation, we will also apply a tabulated ephemeris based on every current (standard) ephemeris to the moons' settings. While, at first glance, this does not add any value to the simulation, this step is crucial in order to later be able to simulate the moons states purely based on their ephemerides without having to propagate their states." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:45.644335Z", "iopub.status.busy": "2025-09-15T19:13:45.644170Z", "iopub.status.idle": "2025-09-15T19:13:51.773070Z", "shell.execute_reply": "2025-09-15T19:13:51.772404Z" } }, "outputs": [], "source": [ "# Create default body settings for selected celestial bodies\n", "jovian_moons_to_create = ['Io', 'Europa', 'Ganymede', 'Callisto']\n", "planets_to_create = ['Jupiter', 'Saturn']\n", "stars_to_create = ['Sun']\n", "bodies_to_create = np.concatenate((jovian_moons_to_create, planets_to_create, stars_to_create))\n", "\n", "# Create default body settings for bodies_to_create, with 'Jupiter'/'J2000'\n", "# as global frame origin and orientation.\n", "global_frame_origin = 'Jupiter'\n", "global_frame_orientation = 'ECLIPJ2000'\n", "body_settings = environment_setup.get_default_body_settings(\n", " bodies_to_create, global_frame_origin, global_frame_orientation)\n", "\n", "### Ephemeris Settings Moons ###\n", "for moon in jovian_moons_to_create:\n", " # Apply tabulated ephemeris settings\n", " body_settings.get(moon).ephemeris_settings = environment_setup.ephemeris.tabulated_from_existing(\n", " body_settings.get(moon).ephemeris_settings,\n", " simulation_start_epoch,\n", " simulation_end_epoch,\n", " time_step=5.0 * 60.0)\n", "\n", "### Rotational Models ###\n", "# Define overall parameters describing the synchronous rotation model\n", "central_body_name = \"Jupiter\"\n", "original_frame = \"ECLIPJ2000\"\n", "target_frames = ['IAU_Io', 'IAU_Europa', 'IAU_Ganymede', 'IAU_Callisto']\n", "# Define satellite specific parameters and change rotation model settings\n", "for moon_idx, moon in enumerate(jovian_moons_to_create):\n", " body_settings.get(moon).rotation_model_settings = environment_setup.rotation_model.synchronous(\n", " central_body_name, original_frame, target_frames[moon_idx])\n", "\n", "# Create system of selected bodies\n", "bodies = environment_setup.create_system_of_bodies(body_settings)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Create Propagator Settings\n", "Trivially, in order to **estimate 'better' initial states** for the Galilean moons (as for to the objectives discussed above), we have to include all four of them in our propagation. Acceleration-wise, they are moreover modelled in the same fashion: \n", "\n", "* mutual spherical harmonic acceleration due to Jupiter,\n", "* tidal dissipation on both the moons and the primary,\n", "* mutual spherical harmonic acceleration due to the remaining three moons,\n", "* and point mass gravity attraction by both Saturn and the Sun.\n", "\n", "The **initial states** of the moons are taken from the **NOE-5 ephemeris** and will later also serve as **a-priori information and input to the estimator**. We will use a **Dormand-Prince 8th order integrator (RKDP8)** with a fixed step-size of **30 minutes**. Note that, while this example saves the Kepler elements of all four moons as dependent variables, this is not strictly necessary for the estimation, but purely serves as means of **better post-processing visualization** of the results." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:51.775518Z", "iopub.status.busy": "2025-09-15T19:13:51.775311Z", "iopub.status.idle": "2025-09-15T19:13:51.790260Z", "shell.execute_reply": "2025-09-15T19:13:51.789548Z" } }, "outputs": [], "source": [ "# Define bodies that are propagated, and their central bodies of propagation\n", "bodies_to_propagate = ['Io', 'Europa', 'Ganymede', 'Callisto']\n", "central_bodies = ['Jupiter', 'Jupiter', 'Jupiter', 'Jupiter']\n", "\n", "### Acceleration Settings ###\n", "# Dirkx et al. (2016) - restricted to second degree\n", "love_number_moons = 0.3\n", "dissipation_parameter_moons = 0.015\n", "q_moons = love_number_moons / dissipation_parameter_moons\n", "# Lari (2018)\n", "mean_motion_io = 203.49 * (math.pi / 180) * 1 / constants.JULIAN_DAY\n", "mean_motion_europa = 101.37 * (math.pi / 180) * 1 / constants.JULIAN_DAY\n", "mean_motion_ganymede = 50.32 * (math.pi / 180) * 1 / constants.JULIAN_DAY\n", "mean_motion_callisto = 21.57 * (math.pi / 180) * 1 / constants.JULIAN_DAY\n", "\n", "# Dirkx et al. (2016) - restricted to second degree\n", "love_number_jupiter = 0.38\n", "dissipation_parameter_jupiter= 1.1E-5\n", "q_jupiter = love_number_jupiter / dissipation_parameter_jupiter\n", "\n", "# Lainey et al. (2009)\n", "tidal_frequency_io = 23.3 # rad.day-1\n", "spin_frequency_jupiter = math.pi/tidal_frequency_io + mean_motion_io\n", "\n", "# Calculate all required time lags associated with the individual tides\n", "time_lag_io = 1 / mean_motion_io * np.arctan(1 / q_moons)\n", "time_lag_jupiter_io = 1/(spin_frequency_jupiter - mean_motion_io) * np.arctan(1 / q_jupiter)\n", "time_lag_europa = 1 / mean_motion_europa * np.arctan(1 / q_moons)\n", "time_lag_jupiter_europa = 1 / (spin_frequency_jupiter - mean_motion_europa) * np.arctan(1 / q_jupiter)\n", "time_lag_ganymede = 1 / mean_motion_ganymede * np.arctan(1 / q_moons)\n", "time_lag_jupiter_ganymede = 1 / (spin_frequency_jupiter - mean_motion_ganymede) * np.arctan(1 / q_jupiter)\n", "time_lag_callisto = 1 / mean_motion_callisto * np.arctan(1 / q_moons)\n", "time_lag_jupiter_callisto = 1 / (spin_frequency_jupiter - mean_motion_callisto) * np.arctan(1 / q_jupiter)\n", "\n", "time_lag_dict = {'Io': (time_lag_io, time_lag_jupiter_io),\n", " 'Europa': (time_lag_europa, time_lag_jupiter_europa),\n", " 'Ganymede': (time_lag_ganymede, time_lag_jupiter_ganymede),\n", " 'Callisto': (time_lag_callisto, time_lag_jupiter_callisto)}\n", "\n", "acceleration_settings_moons = dict()\n", "\n", "for idx, moon in enumerate(bodies_to_propagate):\n", " other_moons = np.delete(np.array(bodies_to_propagate), idx)\n", " acceleration_settings_moon = {\n", " 'Jupiter': [propagation_setup.acceleration.mutual_spherical_harmonic_gravity(8, 0, 2, 2),\n", " propagation_setup.acceleration.direct_tidal_dissipation_acceleration(love_number_moons,\n", " time_lag_dict[moon][0],\n", " True, False),\n", " propagation_setup.acceleration.direct_tidal_dissipation_acceleration(love_number_jupiter,\n", " time_lag_dict[moon][1],\n", " True, True)],\n", " other_moons[0]: [propagation_setup.acceleration.mutual_spherical_harmonic_gravity(2, 2, 2, 2)],\n", " other_moons[1]: [propagation_setup.acceleration.mutual_spherical_harmonic_gravity(2, 2, 2, 2)],\n", " other_moons[2]: [propagation_setup.acceleration.mutual_spherical_harmonic_gravity(2, 2, 2, 2)],\n", " 'Sun': [propagation_setup.acceleration.point_mass_gravity()],\n", " 'Saturn': [propagation_setup.acceleration.point_mass_gravity()]\n", " }\n", " acceleration_settings_moons[moon] = acceleration_settings_moon\n", "\n", "acceleration_settings = acceleration_settings_moons\n", "# Create acceleration models\n", "acceleration_models = propagation_setup.create_acceleration_models(\n", " bodies, acceleration_settings, bodies_to_propagate, central_bodies)\n", "\n", "# Define initial state\n", "initial_states = list()\n", "for body in bodies_to_propagate:\n", " initial_states.append(spice.get_body_cartesian_state_at_epoch(\n", " target_body_name=body,\n", " observer_body_name='Jupiter',\n", " reference_frame_name='ECLIPJ2000',\n", " aberration_corrections='none',\n", " ephemeris_time=simulation_start_epoch))\n", "initial_states = np.concatenate(initial_states)\n", "\n", "### Integrator Settings ###\n", "# Use fixed step-size integrator (RKDP8) with fixed time-step of 30 minutes\n", "# Create integrator settings\n", "time_step_sec = 30.0 * 60.0\n", "integrator_settings = propagation_setup.integrator. \\\n", " runge_kutta_fixed_step_size(initial_time_step=time_step_sec,\n", " coefficient_set=propagation_setup.integrator.CoefficientSets.rkdp_87)\n", "\n", "### Termination Settings ###\n", "termination_condition = propagation_setup.propagator.time_termination(simulation_end_epoch)\n", "\n", "# Define Keplerian elements of the Galilean moons as dependent variables\n", "dependent_variables_to_save = [propagation_setup.dependent_variable.keplerian_state('Io', 'Jupiter'),\n", " propagation_setup.dependent_variable.keplerian_state('Europa', 'Jupiter'),\n", " propagation_setup.dependent_variable.keplerian_state('Ganymede', 'Jupiter'),\n", " propagation_setup.dependent_variable.keplerian_state('Callisto', 'Jupiter')]\n", "\n", "### Propagator Settings ###\n", "propagator_settings = propagation_setup.propagator.translational(\n", " central_bodies=central_bodies,\n", " acceleration_models=acceleration_models,\n", " bodies_to_integrate=bodies_to_propagate,\n", " initial_states=initial_states,\n", " initial_time=simulation_start_epoch,\n", " integrator_settings=integrator_settings,\n", " termination_settings=termination_condition,\n", " output_variables=dependent_variables_to_save)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Orbital Estimation\n", "Having defined all settings required for the simulation of the moons' orbits, the orbital estimation can finally be discussed - we will have to create the required **link ends** for the Galilean moons, define the observation model and simulation settings, simulate the states of the moons based on their associated ephemerides, define the estimable parameters, and finally perform the estimation itself.\n", "\n", "### Create Link Ends for the Moons\n", "Since we will be using the [cartesian_position](https://py.api.tudat.space/en/latest/estimation/observable_models_setup/model_settings.html#tudatpy.estimation.observable_models_setup.model_settings.cartesian_position) type of observable to simulate the ephemeris-states of the moons, we will have to define the link-ends for all four moons to be of the `observed_body` type. Finally, we will also have to create the complete set of link definitions for each moon individually." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:51.792707Z", "iopub.status.busy": "2025-09-15T19:13:51.792446Z", "iopub.status.idle": "2025-09-15T19:13:51.797165Z", "shell.execute_reply": "2025-09-15T19:13:51.796621Z" } }, "outputs": [], "source": [ "link_ends_io = dict()\n", "link_ends_io[observable_models_setup.links.observed_body] = observable_models_setup.links.body_origin_link_end_id('Io')\n", "link_definition_io = observable_models_setup.links.LinkDefinition(link_ends_io)\n", "\n", "link_ends_europa = dict()\n", "link_ends_europa[observable_models_setup.links.observed_body] = observable_models_setup.links.body_origin_link_end_id('Europa')\n", "link_definition_europa = observable_models_setup.links.LinkDefinition(link_ends_europa)\n", "\n", "link_ends_ganymede = dict()\n", "link_ends_ganymede[observable_models_setup.links.observed_body] = observable_models_setup.links.body_origin_link_end_id('Ganymede')\n", "link_definition_ganymede = observable_models_setup.links.LinkDefinition(link_ends_ganymede)\n", "\n", "link_ends_callisto = dict()\n", "link_ends_callisto[observable_models_setup.links.observed_body] = observable_models_setup.links.body_origin_link_end_id('Callisto')\n", "link_definition_callisto = observable_models_setup.links.LinkDefinition(link_ends_callisto)\n", "\n", "link_definition_dict = {\n", " 'Io': link_definition_io,\n", " 'Europa': link_definition_europa,\n", " 'Ganymede': link_definition_ganymede,\n", " 'Callisto': link_definition_callisto,\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Observation Model Settings\n", "As mentioned above, we will 'observe' the state of the moons at every epoch as being perfectly cartesian and handily available to the user. However, note that the `cartesian_position` observable is typically not realized in reality but mainly serves verification or analysis purposes." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:51.798833Z", "iopub.status.busy": "2025-09-15T19:13:51.798654Z", "iopub.status.idle": "2025-09-15T19:13:51.801408Z", "shell.execute_reply": "2025-09-15T19:13:51.800936Z" } }, "outputs": [], "source": [ "position_observation_settings = [observable_models_setup.model_settings.cartesian_position(link_definition_io),\n", " observable_models_setup.model_settings.cartesian_position(link_definition_europa),\n", " observable_models_setup.model_settings.cartesian_position(link_definition_ganymede),\n", " observable_models_setup.model_settings.cartesian_position(link_definition_callisto)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Observation Simulation Settings\n", "To simulate the states of the moons at every given epochs, we will have to define the simulation settings for all moons. For the problem at hand, they will be entirely identical - we have to define the correct `observable_type` that is associated with the `cartesian_position` observable, give the above-realised `link_definition`, and finally define the epochs at which we want to take the states from the respective ephemerides.\n", "\n", "Finally, realise that the default setting for the `reference_link_end_type` argument of the `tabulated_simulation_settings()` function is set to `LinkEndType`.receiver. However, to satisfy the estimators expectation when using the `position_observable_type` the default value has to be overwritten and set to `observed_body`. This might be different on a case-by-case situation and should carefully be evaluated when using different types of observables, since the estimation will crash otherwise." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:51.803095Z", "iopub.status.busy": "2025-09-15T19:13:51.802904Z", "iopub.status.idle": "2025-09-15T19:13:51.850551Z", "shell.execute_reply": "2025-09-15T19:13:51.849958Z" } }, "outputs": [], "source": [ "# Define epochs at which the ephemerides shall be checked\n", "observation_times = np.arange(simulation_start_epoch, simulation_end_epoch, 3.0 * 3600)\n", "\n", "# Create the observation simulation settings per moon\n", "observation_simulation_settings = list()\n", "for moon in link_definition_dict.keys():\n", " observation_simulation_settings.append(observations_setup.observations_simulation_settings.tabulated_simulation_settings(\n", " observable_models_setup.model_settings.position_observable_type,\n", " link_definition_dict[moon],\n", " observation_times,\n", " reference_link_end_type=observable_models_setup.links.observed_body))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simulate Ephemeris' States of Satellites\n", "In a nutshell, what we want to do is to check the ephemeris every three hours - as defined just above - and take the associated (cartesian) state of all four moons at that moment as our observable. However, in order to automatically satisfy all requirements in terms of inputs to the estimator, we have to manually create an `observation_simulator` object, since we explicitly do not want to use the (propagating) simulators that get created alongside the estimator.\n", "\n", "The way custom-implemented observation simulators are implemented is that they do not propagate any bodies themselves but simulate the observations based on the (tabulated) ephemerides of all involved bodies. To this end, while setting up the environment we have already set the NOE-5 ephemeris as tabulated ephemerides for all Galilean moons. Thanks to this, we can directly create the required observation simulator object and finally simulate the observations according to the above-defined settings." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:51.852241Z", "iopub.status.busy": "2025-09-15T19:13:51.852051Z", "iopub.status.idle": "2025-09-15T19:13:52.074126Z", "shell.execute_reply": "2025-09-15T19:13:52.073481Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Checking ephemerides...\n" ] } ], "source": [ "# Create observation simulators\n", "ephemeris_observation_simulators = observations_setup.observations_simulation_settings.create_observation_simulators(\n", " position_observation_settings, bodies)\n", "# Get ephemeris states as ObservationCollection\n", "print('Checking ephemerides...')\n", "ephemeris_satellite_states = observations_setup.observations_wrapper.simulate_observations(\n", " observation_simulation_settings,\n", " ephemeris_observation_simulators,\n", " bodies)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Define Estimable Parameters\n", "Given the problem at hand - **minimising the discrepancy between the NOE-5 ephemeris and the states of the moons when propagated under the influence of the above-defined accelerations by selection of an *optimal initial state***, we will restrict the set of estimable parameters to the moons' initial states." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:52.108612Z", "iopub.status.busy": "2025-09-15T19:13:52.108401Z", "iopub.status.idle": "2025-09-15T19:13:52.111511Z", "shell.execute_reply": "2025-09-15T19:13:52.110923Z" } }, "outputs": [], "source": [ "parameters_to_estimate_settings = parameters_setup.initial_states(propagator_settings, bodies)\n", "parameters_to_estimate = parameters_setup.create_parameter_set(parameters_to_estimate_settings, bodies)\n", "original_parameter_vector = parameters_to_estimate.parameter_vector" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Perform the Estimation\n", "Using the set of **'artificial cartesian observations'** of the moons' ephemerides, we are finally able to estimate improved initial states for each of the four Galilean satellites. To this end, we will make use of the known estimation functionality of tudat. All other settings remain unchanged and thus equal to their default values (for more details see the [API reference](https://py.api.tudat.space/en/latest/estimation/estimation_analysis.html#tudatpy.estimation.estimation_analysis.EstimationInput.define_estimation_settings) of the `define_estimation_settings` function)." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2025-09-15T19:13:52.113201Z", "iopub.status.busy": "2025-09-15T19:13:52.112953Z", "iopub.status.idle": "2025-09-16T07:27:18.820854Z", "shell.execute_reply": "2025-09-16T07:27:18.820538Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running propagation...\n" ] } ], "source": [ "print('Running propagation...')\n", "with util.redirect_std():\n", " estimator = estimation_analysis.Estimator(bodies, parameters_to_estimate,\n", " position_observation_settings, propagator_settings)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:27:18.822321Z", "iopub.status.busy": "2025-09-16T07:27:18.822169Z", "iopub.status.idle": "2025-09-16T07:27:18.824738Z", "shell.execute_reply": "2025-09-16T07:27:18.824455Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Performing the estimation...\n", "Original initial states: [ 8.63323027e+07 4.12867822e+08 1.57133735e+07 -1.69693641e+04\n", " 3.48217545e+03 -1.24928712e+02 -4.32049739e+08 5.18868750e+08\n", " 9.01917305e+06 -1.05582750e+04 -8.65408199e+03 -3.79942840e+02\n", " -4.69807789e+08 -9.61020184e+08 -4.38607022e+07 9.77839286e+03\n", " -4.76408474e+03 -2.94541424e+01 -1.56870118e+09 -1.06272769e+09\n", " -5.40329614e+07 4.59044637e+03 -6.73098048e+03 -1.47766750e+02]\n" ] } ], "source": [ "# Create input object for the estimation\n", "estimation_input = estimation_analysis.EstimationInput(ephemeris_satellite_states)\n", "# Set methodological options\n", "estimation_input.define_estimation_settings(save_state_history_per_iteration=True)\n", "# Perform the estimation\n", "print('Performing the estimation...')\n", "print(f'Original initial states: {original_parameter_vector}')" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:27:18.825629Z", "iopub.status.busy": "2025-09-16T07:27:18.825536Z", "iopub.status.idle": "2025-09-16T07:37:20.708473Z", "shell.execute_reply": "2025-09-16T07:37:20.707855Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calculating residuals and partials 133248\n", "Current residual: 2.29116e+07\n", "Parameter update 156450 -26941.3 484.569 1.25023 6.18132 0.0314845 -14194.8 -6177.25 -3364.78 0.0488357 -0.227931 0.0145456 -15432.9 1470.48 885.281 0.0173174 -0.218199 -0.0100752 -12580.4 -6333.74 -323.754 0.0330049 -0.0576689 4.98382e-05\n", "Calculating residuals and partials 133248\n", "Current residual: 77474\n", "Parameter update -151730 29785.9 -2152.12 -1.337 -6.09694 -0.228184 6626.55 8296.47 497.358 -0.0648915 0.147532 0.0107402 18747.7 -10362.6 -116.315 0.0847909 0.198994 0.00786303 867.032 -1918.9 -44.4945 0.0068624 0.00627577 0.000271204\n", "Calculating residuals and partials 133248\n", "Current residual: 134485\n", "Parameter update -6.48342 -26.0707 -1.97779 0.0011482 -0.000296344 -4.87482e-05 -0.911551 -0.367693 -0.0206819 2.31206e-05 -1.47713e-05 4.2153e-06 1.25918 -0.578644 -0.00863784 1.53491e-06 1.20813e-05 1.74112e-07 0.0183251 -0.0239473 0.00161856 1.55742e-07 5.23714e-08 -1.27473e-08\n", "Calculating residuals and partials 133248\n", "Current residual: 5459.16\n", "Parameter update -0.206586 -0.0826094 1.11849 -5.80108e-06 -9.72884e-06 5.47754e-05 0.762303 0.616409 -0.0278695 -1.21984e-05 1.48165e-05 -8.79991e-06 0.300443 -0.189273 0.00977208 1.11488e-06 3.16411e-06 4.43645e-07 -0.00164489 0.0037651 -0.00101657 -1.39578e-08 -1.31853e-08 1.98099e-08\n", "Calculating residuals and partials 133248\n", "Current residual: 5459.16\n", "Maximum number of iterations reached\n", "Parameter update 0.0180602 -0.00344149 0.00016446 1.6341e-07 7.25887e-07 2.77746e-08 -0.0100341 -0.00878103 -0.000392781 1.63212e-07 -2.09936e-07 -4.21207e-09 -0.0014097 0.000709898 4.09393e-06 -6.05297e-09 -1.30415e-08 -5.43724e-10 -0.000407504 0.000678834 1.53591e-05 -2.83783e-09 -2.12474e-09 -1.03692e-10\n", "Final residual: 5459.16\n", "Done with the estimation...\n", "Updated initial states: [ 8.63370164e+07 4.12870640e+08 1.57117051e+07 -1.69694497e+04\n", " 3.48225953e+03 -1.25125405e+02 -4.32057307e+08 5.18870870e+08\n", " 9.01630558e+06 -1.05582910e+04 -8.65416239e+03 -3.79917559e+02\n", " -4.69804473e+08 -9.61029077e+08 -4.38599332e+07 9.77849497e+03\n", " -4.76410393e+03 -2.94563539e+01 -1.56871289e+09 -1.06273594e+09\n", " -5.40333297e+07 4.59048624e+03 -6.73103188e+03 -1.47766429e+02]\n" ] } ], "source": [ "with util.redirect_std(redirect_out=False):\n", " estimation_output = estimator.perform_estimation(estimation_input)\n", "initial_states_updated = parameters_to_estimate.parameter_vector\n", "print('Done with the estimation...')\n", "print(f'Updated initial states: {initial_states_updated}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Post-Processing\n", "With the initial states updated, the estimation is finished. In the following, we will thus be left with analysing how well the propagation of the improved initial states performs compared to the ephemeris solution (selected as **\"ground truth\" solution**).\n", "\n", "To this end, we first have to save both the state and dependent variable history of the estimation's final iteration followed by a loop over all respective epochs in order to save all associated ephemeris-states and Keplerian elements. These will subsequently be used as \"ground-truth\" solution.\n", "\n", "Finally, we will graphically compare the absolute difference of our estimated solution as well as the behaviour of the **Laplace resonance** between the three inner moons - Io, Europa, Ganymede - with the ephemeris-solution." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:37:20.710313Z", "iopub.status.busy": "2025-09-16T07:37:20.710140Z", "iopub.status.idle": "2025-09-16T07:37:25.692677Z", "shell.execute_reply": "2025-09-16T07:37:25.692075Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_47680/3800375163.py:40: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " time2plt.append(time_representation.DateTime.from_julian_day(epoch_days).to_python_datetime())\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAIOCAYAAACGZP0jAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsfXWYHFX29ts9PnF3I0iCJjjBXYPDsrA4vwUWPmBhkaDB3R1CEjRIIIFA3IgSIUbc3celver7o7uqz71dVV0+M+G+zxPoaalTcuXoewKyLMsQEBAQEBAQEBAQEBAQUBGs6xMQEBAQEBAQEBAQEBCobxCGkoCAgICAgICAgICAAAdhKAkICAgICAgICAgICHAQhpKAgICAgICAgICAgAAHYSgJCAgICAgICAgICAhwEIaSgICAgICAgICAgIAAB2EoCQgICAgICAgICAgIcBCGkoCAgICAgICAgICAAAdhKAkICAgICAgICAgICHAQhpKAgIBAPcLQoUMRCATUf4WFhWjfvj1OP/10vPjii9i9e3fGbwYOHIhAIMC8F41Gcccdd6BDhw7IyclBnz59AAClpaW45ppr0LZtWwQCAVx66aU+XFX9Rffu3XHTTTe5djz++eXm5qJz5864+eabsW3bNtfkUAQCAQwcOFD9e/ny5Rg4cCA2btyY8d2bbroJ3bt39+Q8BAQEBPY15Nb1CQgICAgIZGLIkCHo1asXYrEYdu/ejRkzZuDll1/Ga6+9hu+++w5nnXWW+t3bbrsN5513HvP7Dz/8EB9//DHeffddHHXUUWjcuDEA4Nlnn8WIESMwePBg9OzZEy1btvT1uuobRowYgaZNm7p+XOX5hUIhTJs2DS+++CJ+//13/PXXX2jUqJGrsmbPno3OnTurfy9fvhxPP/00TjvttAyj6IknnsC9997rqnwBAQGBfRXCUBIQEBCohzj00ENx9NFHq39fccUV+O9//4uTTjoJl19+OdasWYN27doBADp37swoygCwdOlSFBUV4e677854v2fPnrjuuutcO9dQKISioiLXjucn+vbt68lx6fM7/fTTkUgk8Oyzz2LkyJGu3nsAOP74401/t2fPnq7KFhAQENiXIVLvBAQEBBoIunbtitdffx1VVVX4+OOP1ff51LtAIIBBgwYhFAqpKWBKStjEiROxYsUK9f2pU6cCSKbqPffcc+jVqxcKCgrQpk0b3HzzzdizZw9zDt27d8dFF12En376CX379kVhYSGefvppAMDOnTtx++23o3PnzsjPz0ePHj3w9NNPIx6Pq7/fuHEjAoEAXnvtNbzxxhvo0aMHGjdujBNOOAF//PFHxjXPmTMH/fv3R6tWrVBYWIiePXvivvvuY76zZs0aXHvttWjbti0KCgrQu3dvvP/++6buKZ96N3XqVAQCAQwbNgyPPfYYOnbsiKZNm+Kss87CqlWrTB1TC4oxs2nTJgBAOBzGgAED0KNHD+Tn56NTp0646667UF5ezvxu8uTJOO2009CqVSsUFRWha9euuOKKK1BbW6t+h6beDR06FFdddRWApIFGnz+gnXpn9lyUZz927FgceeSRKCoqQq9evTB48GDb90VAQECgPkNElAQEBAQaEC644ALk5ORg2rRput+ZPXs2nn32WUyZMgWTJ08GAPTo0QOzZ8/Gf/7zH1RUVODrr78GABx88MGQJAmXXHIJpk+fjoceegj9+vXDpk2b8NRTT+G0007D/PnzmYjRggULsGLFCjz++OPo0aMHGjVqhJ07d+LYY49FMBjEk08+iZ49e2L27Nl47rnnsHHjRgwZMoQ5x/fffx+9evXCW2+9BSCZEnbBBRdgw4YNaNasGQBg3Lhx6N+/P3r37o033ngDXbt2xcaNGzF+/Hj1OMuXL0e/fv1UI7J9+/YYN24c7rnnHuzduxdPPfWUrfv86KOP4sQTT8SgQYNQWVmJhx9+GP3798eKFSuQk5Nj+Xhr164FALRp0wayLOPSSy/FpEmTMGDAAJx88slYsmQJnnrqKcyePRuzZ89GQUEBNm7ciAsvvBAnn3wyBg8ejObNm2Pbtm0YO3YsotEoiouLM+RceOGFeOGFF/Doo4/i/fffx5FHHglAP5Jk9lwULF68GA888AAeeeQRtGvXDoMGDcKtt96K/fffH6eccorl+yIgICBQryELCAgICNQbDBkyRAYgz5s3T/c77dq1k3v37q3+/dRTT8n8cn7jjTfKjRo1yvjtqaeeKh9yyCHMe8OGDZMByD/++CPz/rx582QA8gcffKC+161bNzknJ0detWoV893bb79dbty4sbxp0ybm/ddee00GIC9btkyWZVnesGGDDEA+7LDD5Hg8rn5v7ty5MgB52LBh6ns9e/aUe/bsKYdCId17ce6558qdO3eWKyoqmPfvvvtuubCwUC4tLdX9rXI9N954o/r3lClTZADyBRdcwHzv+++/lwHIs2fPNjye8vz++OMPORaLyVVVVfKvv/4qt2nTRm7SpIm8c+dOeezYsTIA+ZVXXmF++91338kA5E8++USWZVkePny4DEBetGiRoUwA8lNPPaX+/cMPP8gA5ClTpmR898Ybb5S7deum/m32XGQ5ea8KCwuZZxwKheSWLVvKt99+u+E5CggICDREiNQ7AQEBgQYGWZZdPd6vv/6K5s2bo3///ojH4+q/Pn36oH379mp6noLDDz8cBx54YMYxTj/9dHTs2JE5xvnnnw8A+P3335nvX3jhhUxk5vDDDweQTk1bvXo11q1bh1tvvRWFhYWa5x0OhzFp0iRcdtllKC4uZuRecMEFCIfDmul8ZnDxxRdnXDM9v2w4/vjjkZeXhyZNmuCiiy5C+/btMWbMGLRr106N8vFse1dddRUaNWqESZMmAQD69OmD/Px8/Pvf/8bnn3+O9evX27oWI5g9FwV9+vRB165d1b8LCwtx4IEHmr4vAgICAg0JIvVOQEBAoAGhpqYGJSUlOOyww1w75q5du1BeXo78/HzNz/fu3cv83aFDB81jjBo1Cnl5eaaO0apVK+ZvJb0rFAoBgFobxZNUUJSUlCAej+Pdd9/Fu+++a0quWWQ7v2z44osv0Lt3b+Tm5qJdu3bMPSspKUFubi7atGnD/CYQCKB9+/YoKSkBkEyXmzhxIl555RXcddddqKmpwX777Yd77rnHNeY6s+eigL8vQPLemL0vAgICAg0JwlASEBAQaED47bffkEgkcNppp7l2zNatW6NVq1YYO3as5udNmjRh/uZ7NinHOPzww/H8889rHqNjx46WzklR3Ldu3ar7nRYtWiAnJwfXX3897rrrLs3v9OjRw5Jct9C7d2+GtZCiVatWiMfj2LNnD2OgyLKMnTt34phjjlHfO/nkk3HyyScjkUhg/vz5ePfdd3HfffehXbt2uOaaaxyfp5VzERAQEPi7QaTeCQgICDQQbN68Gf/73//QrFkz3H777a4d96KLLkJJSQkSiQSOPvrojH8HHXSQqWMo1ONax7BqKB144IHo2bMnBg8ejEgkovmd4uJinH766Vi4cCEOP/xwTblaEZC6xplnngkA+Oqrr5j3f/zxR9TU1KifU+Tk5OC4445T2fwWLFige3wr0S875yIgICDwd4GIKAkICAjUQyxdulStt9m9ezemT5+OIUOGICcnByNGjMhIlXKCa665Bl9//TUuuOAC3HvvvTj22GORl5eHrVu3YsqUKbjkkktw2WWXGR7jmWeewYQJE9CvXz/cc889OOiggxAOh7Fx40aMHj0aH330kWEanRbef/999O/fH8cffzz++9//omvXrti8eTPGjRunsva9/fbbOOmkk3DyySfjzjvvRPfu3VFVVYW1a9di1KhRag1OfcLZZ5+Nc889Fw8//DAqKytx4oknqkxzffv2xfXXXw8A+OijjzB58mRceOGF6Nq1K8LhsErFTRsO8zj00EMBAJ988gmaNGmCwsJC9OjRQ9NoNHsuAgICAn9HCENJQEBAoB7i5ptvBgDk5+ejefPm6N27Nx5++GHcdtttrhpJQDJa8csvv+Dtt9/Gl19+iRdffBG5ubno3LkzTj31VFP1UB06dMD8+fPx7LPP4tVXX8XWrVvRpEkT9OjRA+eddx5atGhh+bzOPfdcTJs2Dc888wzuuecehMNhdO7cmSFaOPjgg7FgwQI8++yzePzxx7F79240b94cBxxwAC644ALLMv1AIBDAyJEjMXDgQAwZMgTPP/88Wrdujeuvvx4vvPCCGhHq06cPxo8fj6eeego7d+5E48aNceihh+KXX37BOeeco3v8Hj164K233sLbb7+N0047DYlEAkOGDMkgbLByLgICAgJ/RwRkt+mTBAQEBAQEBAQEBAQEGjhEjZKAgICAgICAgICAgAAHYSgJCAgICAgICAgICAhwEIaSgICAgICAgICAgIAAB2EoCQgICAgICAgICAgIcBCGkoCAgICAgICAgICAAAdhKAkICAgICAgICAgICHDY5/soSZKE7du3o0mTJggEAnV9OgICAgICAgICAgICdQRZllFVVYWOHTsiGDSOGe3zhtL27dvRpUuXuj4NAQEBAQEBAQEBAYF6gi1btqBz586G39nnDaUmTZoASN6Mpk2b1vHZCAgICAgICAgICAjUFSorK9GlSxfVRjDCPm8oKel2TZs2FYaSgICAgICAgICAgICpkhxB5iAgICAgICAgICAgIMBBGEoCAgICAgICAgICAgIchKEkICAgICAgICAgICDAQRhKAgICAgICAgICAgICHIShJCAgICAgICAgICAgwEEYSgICAgICAgICAgICAhyEoSQgICAgICAgICAgIMBBGEoCAgICAgICAgICAgIchKEkICAgICAgICAgICDAQRhKAgICAgICAgICAgICHIShJCAgICAgICAgICAgwEEYSgICAgICAgICAgICAhyEoSQgICAgICAgICAgIMBBGEoCAgICAgICAgICAgIchKEkICAgICAgICAgICDAQRhKAgICAgICAgICAgICHIShJCAgICAgICAgICAgwEEYSgICAgICfytUxyL415RvMWLj0ro+FQEBAQGBegxhKAn8rbFg7zb0HfE2Rm9Z6ZmMimgYd8wYgZ83LfNMhhFkWcbLi6di4rY1dSJfQKC+4b3ls/H1ukW4fOJXnsuSZdlzGQICbqAyGq7rUxAQqHcQhpLA3xq3zxiBRSU7cOG4oZ7JeHfZTHy8cg6um/KdZzIA4Lt1i7G4ZHvG++O3rcEj88bi7DGfeSY7IUk4d8xnuGHqd0IxbOAYvWUlev/wOv7YvdlTOXrjZEnJDhzw/av4Ys2fnsneWVvl2bEV1MSiOPD71/CPyd94LksPD/zxK/77x6g6k+8HqqIRbK2pqOvT8BRbqsvx/vLZiCTinskYs2UVmn0xEC8umuKZDCNIsoRJ29Zib7jGUzkTtq7Bgr3bPJVR1xi3dTVeWzKtTvfifUkPEIaSgC42VJXiqzULPR3wO2or8dGKPxCKxzI+m7p9HU7/7RMsL9vlmfwV5bs9O7aC5SkZNfFoxmeRRBz3//ErJm9f60jG5O1rcc2UYegz4p2Mz7bXVqqvJVlyJEcP66pKMH7bGny5diG2EXluY8bOjfhg+ex9ahG2gl21VRixcalnzxEALhw3FCsr9njqPJi2Yz3aff0chq1blPHZgPljsbayBDf+/oNn8nOD3m9903ZuwJrKvfhhw18Zn8WkBM4fOxhPzB/vmfyKaBhvLJ2Bt5bOxA4P5+QLi6bglmk/ICYlPJNhhMsmfokuw17EijLv1vLySAjjtq7WXHe21lTgpw1LPV2TDvnxTdw962d0HfaSZzJumTYcAPDo/HGeyTDCqM0rcNaYQTjl1489k7G+sgTnjP0Mp/32iWcysmHStrWeZ5ecN3YwHpw7GmO3rvZMRk0simU6utnAPyeg87AXsbpij2fy/YQwlOox9oSqsbR0Z53Jv3Li17j+9+/wxl/TPZNx2/QfcefMkbj/j18zPjtrzGeYumM9Lpv4pWfyvfTQKQggoPvZhyv+wJtLZ+DM0YMcybhvdvr+GW3YNbFMg9QNVMUi6msvPYIn//oR7pr1s+YG8MjcMbh9xk+eKix3z/oZ7b56DusrSzyTYYQLxg3F5RO/wgfL//BcVmmk1rNj3zRtOPaEa3DtlG8zPltdsdczuQpyA+mtz6vxEk6k51qYcwRN3r4OY7euxnOLJjuWI8mSppFCn19lNJLxuVt4bP44DFn9J8ZsWZXx2aCVc/HK4t89kw0Ak1JOpl+3rPBMxn1/jMJ5Ywfj7WUzMz477uf3ccWkrzDUhQionrGprK+7w9WOZeghoL9NIZKIY/CqedhSXe5IRkU0jDN++wSfrpyb8dngVfMBeOu8VNaWqlgkY066idumDdfMrkhIEs4aMwiXTvgSm6rKPJOvYEtNuWfHPnP0pzj0xzc1nbxPL5yE7bWVeNnjue8XhKFUj3HQ8Ndx2E9vaUZUhqyej+umfOvpZF9QkgxPe+mVGJ3aXL9cu5B5PyFJSKS85usrSx3JCMVjmLx9LRJSphc+7qFnXgHdf/hz0PPIWMVFXXupr0s4BTeaSG++lTFvctCriCJW4VGeO910+DkRisfw8pLf8cnKuVhcusMT+QDw/vLZ2B2uxjcakRC3MGzdIhz38/vYUJU57pU5+e36xZ7JN8KsXZtw7M/vYebOjY6OQ40IHm5FJmRZxl+lO1GrEcnNC+aor6tjmZ+7AYmMV+pIAICScHqOxh1cb0KScPhPb+OoEe9mrC3UUPJqTlJHE2+MSbKE/5vxEx6eN8aVdU7LoKXvhT10en2+ZgEA4JUlmYqfErH/dbMzQ23ExqVoNPRJT1NOjUCdBzzunDkCt07/Ed2/e9mRjMGr5mHKjvX494yfMj4LGllqLiEikfEa88Z5UB2L4LPV8/Hl2oXYVM0aQ3Rv9soRFSXzgK5zbmPOni0AgM9SBq4W/NCv/IAwlOoxyiIhAGljguKWacPxzbpFGLxaf5C6BQnsBhVJxLG8bJerHpEQpzh9QjxOBTm5jo79zrKZOHP0INw162fm/WzpKLXxKL5Zu0hT0bKLau5YbkW0ujVukZbBbQBUSXLqWX59yTS8sGhKhtJCr6s8GmI+k2QJt8/4CQP/nOBINr2Ob9cvYT6jRchUCfUKW2syx044HsPukHOP77VTvsXcPVvw3rJZut/JMVBq3IKWjAvHDcG8PVtx3rjBjo5dENSf024ZLhO3rcXhP72Fi8d/kfEZNWIqOOfBjtpKHPrjm3h9yTRH8mmqLa+URYnCVuPA2bUnXINlZbvwV9lO7AyxdVel4fQ89MpQogYgr+fStcapUjhg3lh0+Ob5jIgGNY60HGFuQzKIPiYcRiZvm/4TYlLC05RTIxitKUNWJ403o+s3g90G2Qa5Hir1ChSdCshMhS+PhHDqrx/jnaWZUUMroOO+lpvbdH9wMu+NUE7mupbx+8T88Th79CDGuekEOdzEp7pBcU6eKzLqGsJQqgeQZEmzRkeBVm2LAj56AFhLJVmwdxteWDTF0IvLH+/ZhZNwyI9vovt3L2PCVneY1PhT/s+skerrolxnk+2ReWMBAB+vnMO8/9xC/bQXWZZx4bihuG7qt/jHJPvF2JIs4WsSfeBZhf4qS6dWOvEs0zGyjVPiaRTJSUSpLFKL/80djcfmj8NGzlNGFaZLJ7Cpkn+V7sQnK+fi6YWTHEVAd5FNZv7erYxBWMm8dqYUPrdwEpp8/iRm7drEvE8VMa35cs2UYejsYq3EpO3rdD9zw1OYrc5Jy8OrbMJOjRkj50dpJKT7mRW8k0qTmqSRGsIYMdycfHvpTCwr24X/zR3tSH4VuUd8RKna4DMroNfBG0N0b9CaE9+vX4LxDrMF6LlnKJ7EYRKOO3MIvbR4KnaFqvHUAtbZQuXHNAyl1RV7XGU0NYp6ODXU7BqTldEwft28gokk2IEfdXsFZN3iHa355DMnDkRZlnH3rJ/x0YrM9GS6ttRwa9iXaxdg2s4NuPePUY72YjrX+Lm9hxiKXmV30HWAd0BvqS7Hc4smY+L2tRi/zZ1MIX7cLCEZHcUOdbf6AmEo1QNcPP4LdPzmeZQSTzhVYvgJTT/jvUCPzRuH9l9net70cNTId/HY/HF4zcB7yodPnyesOC8sdochR4a+cde5UdOM96x4SBvn5Wu+/8fuLew5EGtt8vZ1mLpjPQDgVxMbbUU0jGsmf4OxXPRvzBZ2MRpJijjXV5ZgUUl6UXES7aFGQ/8JnzOfUQ/TS4un2paxmYwpnkGP3xDoGKVKoZZhbxbVcVYG3fToplPmUNF+4s8JqI5FceKoD5nNnF7j3D3s2KmORfDzpuWISQl8vY5NI7WLxaU7mGgm3bx5L140Eceiku2mnSQ/bViK5l88bdhHiPceU6W60GGUN1/H0FtetstwLbACPhJOQWtNNpFxHZcSeFkjvcoO6LPjU43+3+xf1NdOKJnpmLyaY9ejiveEbayxuL2mEv+Y/A3OHTvYUaojPfePVrCOqH9NTbN88lFmuxi+gR2vtAaDl7E3XIODfngdF44b6pqxFOTqTamj0Ks0o2yZG7dO/xH9x3+OpxdMynqscDyGFxZN0ayxpNGHXRwrZJvCRibP1hg06nbUyHeZz+id1ZoTZte2mbs24f3ls3HnzJG4c8YI5jOqN/B7EXXemM1KiCbiGQYy3cd5IhcaUXKa3XHHjBE4csQ7hhkkvO7Y9ds0GYiT1EN6zbkBdi3XIpRq6BCGUj3Ab1tWojwaZpRomlIwfddG5vt3zhypvuYXjxcWT8HucLXlIuHfd25g/n5sXpr5Jm7gKWuUq22EmIFdD9wP65eg+RcD8ezC7BsDADTJK9B8n1f2aG3Ll2sXWDqnJ+aPx3frl+D8cUOY9ydwvYvumT2KfMYqL07SU4auSZ8vNRSqYxG8v3y2+vfITcuZ30UScVw64Qu8tXRGVhnbyea5rrKEGXt8GJ+O33KLaXHheAyjNi3P6PvERzFqdbzpv252z4M8m1Bk041ladkuLCJU7BcRhjizufajt6zEf/8YZegJfnHRVPX1w3PHqK95Q+Pe2aPQd8Q7CH42wBQBzMtLfkdVLILLJ37FUCvT55jgFD+67rQqKM4qwwiFuem5R+ud3iNjFWAN7piUwNMLJuLx+eNMGRdU8XtmwUT19ZIStobtAjJnrdZjVkTDOGrEu3h03tiM9Yym3czbs1V9zZOdOEmLo4bSsrJdzJykqcZ8NP0uErEvNTEn75o5EoFBj+Ds0YMYGdRZsbBkO3OsmSQiW+5S6l9VLIJV5WkmLYWpDchU/K6ZPCx9LjvZ6LAWKqJh/LRhKVZyZALUkNxWW8kopm8sTRMdRV1k/ZuWctIBwMPzxuh+ryoawfCUMv7Wsuxr+LvLZ+Gx+ePQ8/tXmdRzSZawkjCUUUfYusoSJhLiBEaGCs284OfE2C2rUDT0CTw0J3uUl+4LH3Hjnh6XZ76bTtYhPhKjhWgijl7D30C/UR8yc4I67V7/azrj4LpmyjDN7wHA56v/xMecs8EIH6+cg4Ul23HG6E+Z9xlDySAbyUivywZ67p8b1NTxqYcNFcJQqmPcTPKRi4nRQQfYH7s3MxsQrd/R82LxA1SW5QzPA8W4rasZxY9Giow8Za0LWYVpccl23D7jJ1N9Sl77i41iUeVnvyYt1dflEXZBuXtW0hv75J8T8FsWpbgmFsUOci500zuqdSfmuxePT0dirOZiLyUpdFQRapZfqPsb3si8bfqPlmQqWLh3m2bhPwBszOKNfHXJ7/h503L8V4N1kAdvyNFFeDgXmaCeLHpsMxGlI0e+i4snfIGzx3zGbOaZhlJ6jA8mBaUjNi1jol+yLKv/rIKaPPzmPYkYutTRUGQyL/vCcUPx1tKZGcYBxVri+X2DGLN8PQRVCLQKpXnQiNiNv3+vvj5vLFt7RJnM6P1uadJQ2llbhYF/TsA2YoxVxyKM4XDSrx+pr3nnxZ+k38lHK/7AwAUT8fyiKaZ6gtH19CliKP2+c73W1wFkzpdszpzv1y/BgpJteHHxVMYwkWUZA4lMiu1cauz15P4DwGtLpmGIydpTPpKrKHhadZXK2ifJEuMwyTYnZVnGB6k0ponb1zIF6oNWzWO+q3csPtqzubocs3dlN16AzJTkdVXpObGEOAW+WruQSdmiKZe80a+FAfPG4opJX6H38Dfw5970+Lybq22law1Nz+UjcxXRMKZuX2dr3bmX9L7iowLjiDH/6SqiC5hQfL9dl67tPOO3tILNO5doSrgWhb9d8PWACuZy2R03TUvrRUtLd+L8cUMQScTx6l/Z6waN0va0WAuB5J79FSGUMqPgr67Yiw1VpZi7ZwuXysvOST0nAZMiF4/hpmk/4I6ZI9Dvlw+yjhnqQJq3ZyvTP/GsMWkG3Sf+nKB7LN7ZNG/PFgxZPT/j+3vDNZjD9dSj1xSVEhlp6gpGOSQ4qS8QhlIdg1KK0sWcn6jbdYgH9GoFvlq7kDFWbpv+Izp88zwWGjRau0inbwplTePBFwueOXoQPlk5FzeQzX9p6U7c/8evGZ5cpXZIwQDyd5dGzdTXG6vLdL0kV036WvfckjJYbxyVQRlwAGALUeb4Gops+d+dyfnS+9iioIj5Xq9mbdTX/ObNR/W0kJAkPD5/HJNKsoqjUw4GAupix5NHAFDr4SqjYTxhgWCB9yoqi2U4HstoTqqMX1mWsaYyfX5njP406yZA6WGpkcsb+rSu72tuM6dRknPGfIbgZwMQ/GwA9pDUh/JIiDGogMxNlt4/PoLZWCdSyR/joxV/oPcPrzPvDycpGdQY4pUtvRS3MVtX6SoEdE2QZTkrwQS9V7N2sxsejbbQSBk/PzZUleK/f4xiDCIgmX719MJJ6E+cEEaUsXz093SizNFUWT71UQt6zgO95wZkXhcdu1qghjSN2qzlUpvonOTXnXXku1trKvDg3NG4ZdpwU00xeYeU8ux55RpIp3Dxily2VFV+LwqReiOe/VEvxe6huWOYNfSSCZ+j36gPcS9JQQSA33esz1DM+WayRvVOE7kovRV8SGpaRm5MG5KfcFTWtSTacGiL9uprvrbu0XljcfroT9Fr+OtZazMz63XS45DuLQAbRXuXEL5YjWjRCNJ4Lnp/YLPW6ms+vZ/SQW+oKsWxP7+X8cw2VJXi5FEf4UeyzsWkBL5Yo52pwc9VGo3kzy0bKrjxrcy7Mg0jXnGE8OsWH4l546/p+IXLxvicXAvdi0ZwPZKUz3iD/yGSIUCNltm7N2MVeTaPzx+Hf04exuwNVdz85v+mWJ+6t/y+y0dgr5vyHW6ZNpwxxMsitWjz1bM4/pcPmCjnOC7yrtcSZFttJaYa1No2FAhDyUd8tOIPPDx3DNbo9AmhxsDvO1ivp17Br1EhMF1EB6+ej+pYFEeOfFc31eL/eh2rvqZK0eLSHcxv2hU1Tp8zT3ubWozmE4/cmaMH4c2lM3DEiLcNKVSnEUOBp3ql3eVpfQYf7doTqmYWhO84djTqAeUVgL6tOqqv+agAb9RRLCvbxdCbzyFKnKKw9GnVIfk3WYC1jBgFsizjh/VL1IZtu2qrsK6yBLmDH8Xzi6YwzUALctg0LEmW1WtTjItDW7RTNzxFMeIVEPp3QpIyUuv4qJOyuGulDinytVIYqCK/uGQ7Mx945Z8qcS9y9VVGaQXKCJFlGRPJxk7TK84aMwjdvn2J8d7z10L/5vPNi3K1jRiezejOmSOxsmIPbieRnv8j0UMaveRryKjifmybLsxnz+uk11Lj/MG5o9Hu6+cy5h1N3aPG2Mntu2seE2Dnx/y9W5nN8cVFU/HW0pm4ntSlzNuzRfXqLyQeT+qtBoB+bbupr/l0FKNnbIRlZbuYeUjBO34OaJpWCvmkyd7D32D+5pWNQp3oIX8dkiyrc8Fozab3lNZwJCQJd84YwRgWcSmBW7kotHJsrfumKNJ8ZLhMw7hh5n6M95DrG1ZK9F/LGaIoV7Isq7WZ7yybxWQynPbbJ7h2yrdMRIcay9nk691bLUY6o2ihUeoVVYrpfV5WtosxbpUo3OqKvUx0cfzW1Th51EdMFOD2mWwtTbfGzdXXfBSmR5M0wyndi7XOc+TGZYyDSc/x0pqLELcuSNck8feC9vx7fP54zNuzlemHJssyzho9CDN2bcSVxJHJ1++2JnVPRvUyfNaKgpiUwFN/TsjQlfj7pZz/cg2SHWW8hLh9hzINLy/bhQfm/IZLJnyhRnIqo2EmI0bRV2RZZiJTVL4Wy52S6lzL3WPFuSXLMp5fNAXfrl/MRGDLOaNcMaK05p1CgsQ/R36vUZxCC8i4PH9s2lFGo440DRtgjXQ+i4Yer6FCGEo+4rNV8/HKkt9VbwEfpaDKBE8RSr1VVHmaTTzAvHdRr5j56YXaKSHUm9uDpL4ByaaCCuhGQRVJqvDSolfaJI8aHCe2SytIAHBu5wPV17yhRBnAKONXXJKwpbpcNSzafv2c6vmPJuIZURCqFCnpKWd3OgAAqzzy9+7NpTM0vSZrK/bi0B/fzHg/LSN5r9oWJjc0upFrpUIqC93UHetx9eRvcNAPr+PdZTPR5duXsP/3r2rK0GoiqxxbMUqa5BWoCrSiKPHKVJdhL2L0lpWIJuI45Mc3mRA+r9wC6c2NGnzKxq0QL2gZUco9qIyG0WfEOzjwh9fUhZ73biu/l2U5oz+SIl9rc1DuO28MKw6AhCSpaV23TBuuGom8EmmklGmxbAHJlFK+GBoAvl//l7rR0tQFGll8kovwNSKsQXw61QydXkYtiaH0eqpZdP/xnzMezaZkM6PFuHxz5N7N26qv+Y2WGntKCtCUHetVp4petJJ3QuQR1iR+vBxM5PMkD4qSsbR0J7oMexGDiRPkO67PFFXKlPGnOC+ooWBkmO2qrUKXYS/iGkKawH9feb5a416Zi1rKvDKG+d/FpQTC8Rgaf/4kPlo5B+8sm6Ve906NSKFybK3UIcUJwSulNNq3N1yD0379GH1HvKN+f3k52wNJkaFFAqHMFy1DI5hy1PCfKdkSjxAPO+27xDNs0rnDE/XoRcde+2uaut/+VboTgUGPIHfwo2qWA9/nyYjVkRrB/PN6SmfMKw67hCTh4glfYMaujfg/4jjhPfRae6zCIKbsJQCwX1N2n/6SRDkenT8Wl038UnVebK2pyIgYqzJS13R4y2SEjD4jozQ0GglZVrYLCUnC2K2r1SgGxXZuTazVYJ5UnEF0j+fT4JVxN3zDX3hm4SSc9tsnquGgMN5RKM7KHaHMNTk9X9jnTQ1bmk66MlUfx+8Tir6ida+U97Tm/Z6UbsRHgJVnTo9HHXV8aq6y32v1ElOOxY/pqJRQDXs6/h6bP05dx6izKZ9zyGrJkGU541qctnepDxCGko9omp80RJQJw0+cQavmqcYGrxQoEzMmJRiv+5LSnSod8SUT2H4hChUnH/JVjAde0aKLBa/EdyLMc9T7MmHbGpVB5x7i7SyJ1OLPvVszjEGlf8rm6nI1vH5YKn2BTnJ+wtOaJTphZcjo+u1LeHbhJHXjUeoRtGo/qDGkLEKdipPXRjdgrdSVs8cMQlxK4PPVf+LSCV9g9q5NeMeg1w2QVqRUAyIWVZUi5flfv39f9fuKkUdzfu+ZPcqQmUqRcUm3g9W6J8V4URbHxnkFqgKtsHxpKRUXjhuKBSXbsapiDyZvX6empmmlHiqbm3Kv2hU1VjdxxbOsxeyjeK4o3bdSt8F7B5W0C60NQNkctT5TxjJv6GxLKWWXTWQpzJUC8cs4anOjQntFmZFkKcPAUHLpaS+eUCKmmXoyaNU8XaruWh2nRFKutiNErx/JCym2yhEblzJGf8fiJuprZUwqCsuhLdqpn/EbrUJGwisZF6dYF2kdkhaUuUjTRpTx0r9r79S16G9RB/zwKmrjUTy/aAq21lQw0ZWQQXqWco1dGjUHkBxHaqqqgYI8eusqbKutxHfrlyAUj+H8sYNxBxcJUK5FGf/92nZLz0ll3Y9mylDmMF83MG3nBszds4UZ4+r+oTG31NQ78kx6Nm0FwFhhC8djkGQJbb56Fr/v3IDFpTswY+dGSLLERBCoDC2lUEvB48HXnCq1NZRtcEs1G+3WkgGknRVndOyZPHZqvmvNyU9ThjSN1ClOw3O4mjfqvDgolS6tRGPofefvpR5tfyAQQE0sileW/K7u3/P2bNVNQ67QMMbO6rg/APbZ8vuUkvK+rGwX3kr1Axq5aTk2VJWiy7AXme92pVGrlIwOqb2QPj+tvVBBI2KoHvrjm2j+5UAmXZeCN5Br4zH1+hXjXYmWxaSEuufxY6nnd69gdcUepj7tuF/eB2DcCkB5Vud2PlCtsTRyLMSkBGRZZjIpDvnxTSwt3ck4tYH0HqTlWOOzO2jEX3HS8A4XxTFMj/fe8tmoiIYhyzKe5tLA0/t9ejye1K47AGooZc57hVyJr03VSmE1akmhrFtRKZGR5eOEar2+QBhKPkKJ2Nw5cyRkWcbtHHUloD3RgbShpLU5Tt+VTFnj8/aVAcsbUI1zk+dBIwZAepNfWb6bUWKBtFI2dPX8DKV9QIohj2eMOnrke2jy+VPMe4pX7FrC/qIs2MqEDsdjatRN8foqHuFQPMbUrSh4asHEDEXyU5JbflWPwwCwFNOKItcxtTkwjVk1ik4XlezAJyvn4qZpP+DnTcvRb9SHTLRMC8ozaV+UVEbjsqRulEqUkEbvFCPPTJ8cSU6mxym9RRrn5qtjrEqN9iT/3yg3T33vovFDAegXmZ5O2IC6ffsSook4TueYdYDMiFLjvAK0SqVJPLtoUuo7mTJO++0T1Maj6DPibfW9Ht+9giNHvMOwAgHJuo9IIq7JcvZZyqtGPzu9w36p60+eEz8m7p71M37etCyjyFRJHaB5+wAYQ7hp6t4qkVBlc6uJxTIcG4ryx/fi+XTlPE2q4m/WLs54D2CjdRnRFmLE0FrB4Rv+woNzRmekFj21YCJKwjW4fOJXzPtslDMp75AWbZm/k6/Ztad7Sql5ZC6bljpz1ya0/epZXRZHJUKgOAgY+anrVWoU6TXzOuWuUDUuHDcU35Lo0dTt67CtpiKDKIbKUMakMu/jsqQ+fy0jQmEApcQS9//xqyZDnmK8KwpOi4IiNeqh3EtlTl7S7WD1uSlzka+vOHP0IJzKsXMpZApaKXPKmFSUs4OatUHjlKHGK4wU+33/SgYj5eqKvWqLBAo1vY+MDcWwrVCvI3O+Kvf98T/HMe8/s3ASzuKMscf/HM/UE2odpzYeVdfSHqmG24rcymgkY07ePetn1MajzP7108ZlmLRtbUYNME3TUoymS7odDCC9tsiynBGdU9a/1dw6sqGqFI0/fxKPzmevffDq+Zp1w9SYVMZGp9ScyJa+vaxsF8N0CkBT16D3QblvitOEznUlLYxGsv5KGSk8IZGWo6EqGkEkEcf9f/yW8ZliPIXimTLUtDTOiNlSU4GDfnidyVpZXbEX6ytLNElelHNSatsa5eapa3mlgaE0bccGzNuzlZn3AHDYT29lrKFTVMNGKw2dc1rm5uOQ1NqtPGe+bvPtZTMxZsuqDNkry3dr3mPeQVKUk6eOReXZas37mKxtxNw8bXhGap6Rs7ZSY01Q6twU+V+vXYhzx3yWQWbTECAMJR+hKLEV0TAmbluLHzV6mPC0u4o3SxmIS7j0IyMMW7cYVdEIk28LJGsrhq1blFm4npJBNy1FmVHya28mhaQKjCYQX2CqeKBosaaiFClKBvUsnt/5IADp6IdZSvBfN69AgNQyKTKUBeX3HevVkHqH1OZAN3c9OtRvuZQevgYKSHvK5+/ZqtJL01xyZXNTroknfACAsAl60nAijsnb16lGbaO8fFUpUyJBygZUnJufYWDqpZXxEZpFJdpjTiHSUMZN49x89Vym79yIuJRQ7ylN4QKAdZWlzOYkQ87w0ikoi4SYRV4Zk3/s3oydtVXq3GiSV6CmlF039VtEEnGGVEQB3xAXSG4wetSsM1OedUVBUhRsZSyt4OiEgeRGp0W2MGv3Jqa+TMHi0h2a80jZeKKJuHqd9x5yIoD0GHl/+ewML95rf03DgT+8xrx3YLPWGal9AI2ChNRon2LYU8eC8gxuOfBoAEmFbEt1Od5dnhlV1Zo/cSmB0VtWqsQfXVIOEmpMK2NJUQo3VZenSQg0jG5ekT999KeavcIiibh6f7emNuoOJJJWzRn9FC8snoJZqd4sCnjaYQXl0WR0SoluNc8vVMkj+Chvk7wC9bkp3v69kew0zP1GfYjySAgnjvpQvQ7FeFeuQ1GYGuXmq8qskg6l5WzbUVvF1PIByabffDQJAMalGlUqMprkFajr67JUmp6yttF179op36I6FsGQ1Syd8J97t2k6CCdtX5fBhgYAby2dCVmWVcMuNxBUCQ+U9UaP2fDtpZmsZ7zDEEjO0xk7N2Jp6U6VmEOZ98o43BOuUcfUU33PBJCMDm+qKmMIF4wwYN5YnEWU+2v2OyJ5HbF0tF5JC1QyH5T7XhquxWSNQvlTf/1YVdzV69FgJVOityvKduOnjcuYa9SKWl23fx/1vRNHfYhwPIbBJtgZzxozCJ+snKMarg8dfqr6mbIHKHuOknUDANf//l3GuVDwPRz1GnQrv1eMsqKcPHWfVFLOFGOGpuafNWZQBvGKHhSWQmU96tm0lVp7uTuUnNPqPplXgOapferb9YsRiscyCCCAJJEO7+TeXluJKyd9lfFd1TGqZpDkq7VCypzQmstKajaP7bWVDPEVkOyfuaW6HG+S31zbsw8j4yHiGLyk68HMZ7dMG47x29bgQYeNvOsCwlDyEZTZZdj6RZrfqY3HGBakE9p2BQA89edEJCRJ07OvhGN5rK8qRdMvnsp4f/6ebUzxpYLJKSrTbcS71q4o08PEY8SmZaapXsdtXZ3BcNMt5ZlWNocXSEPbPqkC8knb16I0XItXDBrjUvQf/zmTeKEoXsqCQnN8Fc94KBHDlupySLKkFv1PvuD/mOOaoWCNptIGaA8lWuCoyFY8wi3yWUNpV20VQ2eshy/XLGTyp8sjYXVTVxZYJU2yiMsTlmXZdGNWulE1zsvPqDGhizNNbSyLhNTNmL9GvleJEapiETUy066oMUNNvStUpSouTfIKmGf+595tGR45PZRFQhlpVArWV5ViT6hG3egVZeK5RZOxN1zDNNakMEPTrSAmJZhN5tEjTgeQnFuyLDPHUtJgh6z+EwlJysjJp+dNsbpir1pgTrGgZBuiiTjjhFAUXGW+jNmySmWFVOoYAOCfU4aZzkF/duFkfL46nXqoKH6KDJqOq3wGQKWJ5x0+eqDOmZePOV99XRWNYHN1uco4SMfkuFTj0PWVyXv2fweliW0AttmuEX7fsYGJZjXLL1TrzBanHA7KfGrMeeNr41FTNP0AW2weTSRUY2hoyghRPNVN8wvUcXvnzJGISQndwnmtPUELw9Ytxu5QtRoZbZSbrzoohqz+E5XRMLbVJsdK28LG+BdJLbZCF1yQk6OmVAHAPYf0U1+P2bpKNa6a5BegecrZ9NHKOaiORTQjKEAmIYsR3lo6A0f//J76t2JYj9+2BrIs4woSVehAxuu/pn7HOAKNkB/MYSKvCpnK5upyRBNxxgnRMTXvF5XswIqy3XhgTmaEBkimvfORcS1joyYexciNy/Do/LRCrBic5SmdYmNVqerQ5ev83tKh2uYxd88Whpm1VUGxumaURUJISJJ6nZRsQhnjWvVOVvD+8tlISJJ6vwpzcrE0ZXwqtUiKwUbXNsBam5DScK26FucHc9R5d93U5LxSok2N8/LVNW/QqnmWGk6/vPh3TRbAB+b8BkmWmL5ezfKSc1Lpw6VF3T95+zrTuhuQrEW9n4w7JWqkXMNnRK9SdB4l5VVZl79Zt8hRk+u6gDCUfAT1mPNeNQWhRAx9SWdjRSmSIWdEoP7fwcmN46G5Y5hJ8OIx5xmeB1/QqdQIrazYg182sxSYSkduZaFVJsaFXXqp0S4gWbjNU4Xr4SaOqOKg1DGVzf34lHEIsArTdVO/NdUPQwGNKCnpfbRmR4GSywsAx//yAdObSfGsK5jN0WBTKF5FANhSXc6kz/UiERWFFlTxZvERpZ+5Z6CHO2aOYBYcLe/XZ6lFqig3j1Foy6MhQyY/Ctqrg2cMi0kJXJHycDXOK2BkVETDeDPV+6d5AcuEo/TCMoPyaAg/p6hZd4WqmftaHYvi1ZTx3Dy/kGnia9RPgwdv1NB0yIKcXJz868fq37RL/ffrlzAU0hd0OUh9rUeFq4W4LKk1BQAb7fh+/RKGipZ66d/TiObYwTMLJzF9mpRxv6hkB6qiEYaGv1vjNOvWzF2bmPuRTQZNcVKcF7XxGCqiYSZVltZErqncm0FuYwSqbFGCmneXz8IPJAJMvdfXTf0WO2orMWZrUjk7IpXyq8CoHxrFvX+MYmTKSPf6+U+qyauinDXiiAi+14hO64FG+gKBgEq28uuWlZBlWVXOWhUUMxT4u0LV6ljnlUIr2B2qxn0po25nqIpx1K2rLFGjtjtCVYzzwsqc5J1iR7furL7eXF2uZjeURULM83ln2ayM1HEFelFrLRTm5DLnq4x7KcVsNoM0gm9O5Ou18tBCPudk6E4Y7R6dP47x6nfk9sJpJtpJZMNlE79kor+0bunVJdPwxl/pNaEzmZMAMnrrGIE6BZoXFKr39bKJXzKKP++E21xdbnod1XNMfbl2IUPWwRM1SbKk9kArzmXl69Fea2E5cf7tDlUzBEhxKcHUxdJsip0aJBN64Jk8qX60sapM1Sv3hGuYvXgd167gtoOOUV/zJElG4BudKxlQn2n0X1LmZFUsglEctbqZ0oL6hDo1lKZNm4b+/fujY8eOCAQCGDlypO53b7/9dgQCAbz11lu+nZ/b+P6M63Q/uy4VwqyNx5g0I2p88Fz/VPm8jngDaXE2Bc8QpOCug09QX3+2ig2lK5v552sWMCkbDx1+Ch46/BT170nb16ppJJS9Tgt8qlKn4qTCpCwsSv7wa8deoHoKgWRh8/6pwmQzoIvjMalNNpSIYWdtlbog92vbjZGxvbaSSatpW9RI977xOIlQK58zdrAahWtZUMx8BrCbTMuCYvzvsPS9NBvpAViyBCUKoeDPvVtVb1yrgmJ80O8S9TOapkANPC0MW5dON4xKCRQSWmxK7dssrxD/2O9w9e/ttZWqMiHL6XozAFlruyh4NsfDWqZrcypjETX9cXn5bhxGlD+9Ghkz+O2cm9TXtfEoYwwVkc2UX/CPbMU2MTYLvp6IKky8QtScREJm7NrEGNp69L9aeJCMOd5L2Yn0bvn3jJ8Y44xSFwOZNPNGoIoIPeb+37/K1Ny05owv6iDpoLO+KaB1ZbSAfOCCiczzasc5QWjNEa8w3a/jvdcCVdp5w2Aiuc8FQfZZFeeaW2cA4ME56ehjfjCHSaulitfWmgpmzaQ9tbbVVFoaL8cRenreEKFOGsoGuTdcw6xnZhp5KuB7s9Fz5aOY1DgNcTLoOM8GOn/5e0ONCD4yS1kkW+nQWWshjyMroRT8fFoUVYoXlmxnHIFjzr3ZtMyhp1zF/E3HHXWCPDxvDJPuqpCfqOfD9XcyAnUK0L5My8p2MYZlETfv5hHDgO8nZQSF3EMBTanlCYbWVNA+duw6fGWWPo0Ua8kewY/zbaQuZ/6ebcz4pXPXyjUCwEHN085qrdptvc+oXknLB+7odZyhPJ5pkzqb+H2KfragZLtafzbtotsNZdRH1KmhVFNTgyOOOALvvfee4fdGjhyJOXPmoGPHjobfq++4sGsvzajL4S3bq4sVn3NMKTX5eh+6wFFFR28zuqzbIZrvU2YpqoRc1u0Qhp74mYWT1KhP8/wizdoaALhh/yM131dAPVg3HXAUo1h8tmqeaih2btSM+SwYCKgMTi8fcz5mX/wfQzkKhp95HaOUXTHxK7U+5/wumUYdVURbFBRh7Lm3ZJVx64FH48wUKxGQ9OAoit+/ex2b8X36vFoUFGHgkWepf1vpHaMYAzcdcBSObcv22VGoTIFk2sZNBx6l/k37MOQGg3jh6HNNyXv6yLMYlj6qBOUFg/hP7+PVv+nYjUkJTDj/NlMyAKDkX09qHgcA/plyKgCZReMjz7pefb2apHvwnkoFR7XWNmx6t2irRk/54lkaNeLnpF7Tx1eOPV/zfaUBMe/pPoQQNfAF01QpnLFzo/oMvj39n/jt3Js05Wjhmp5HqK93h6qZOjLqbBm+4S913gGswmgVVEGgit/ecI3qIAGArpxSRqPXZuajgn5cC4IcstYdwDldaH82vhGxEa4l4xEAQ4pAWQMBVokvjdQy69IOC5EImj7XNK8Ap7Tvof69gTQvzQvm4J5UTRuQ9Dor4Jv7ZsMbx1+kvl5XlVYuC3NycV3P9JrAr1+0tcVGrrGqFVADJMgx2lFKfD76x/eoMcLnp6aNCN4J0p48q6bcvaN9B2kWgt4eqWA111ORpvDxoFTgPZu2YtY+Kwr2VfsdxvxdQK6zEyefGjV8dsXna7SzYrKhU3FTxuimOlHjvHy1XQfA1ss+3ucM0zJaFhTjp7P+pf5NI0PBQAC3puosAVYf0Yt48vNYwaNHnK6um3RsR6Q4k6lCUyFzg0HGQKalDquv+p+mHL1xdBQx7Ol1NOXS0On1V97wNGPY0zpP3lDlwZOE0NYSe8M16pz57OQrmNTmSCKuOq34cdQQUKeG0vnnn4/nnnsOl19+ue53tm3bhrvvvhtff/018vKMH2JDAFWyFPx45r/U5pW/cYxYNxyQNjro5v3X5fdleM4UHNGyg+b7l+oYSrQLN5DupfLhiZeiaV56Qi0t26nWETXLL9QNn9KGeAo+PPFSze/+99CTmI3t1SXTVCWgaX4hswHKcloxPqBZKxzXpgvOIYuqHg5o2ppR0Gbt3qQeRyulRtksejdvi2AgmNGrQgv3HnoS4+ED0rUX/KYKsN7KlgVFjAebpo/RBfLmA4/Cg4edwoTNH/9zfFJGyntz0wFpY4jWUzXJK0AwENQkrggggAF9TjdsXqhcx2N9zsAAErmi3sDWhY1QmJun1tXxil/rwkZq0TcF3/kdAFoWFuO8VGSSrx3KC+aoDFR7uMhUu+ImanSWMkytvfpBJj1GAWVZ4qEUyPNsQb2at1Xp6ml++eenXpWRnqJAiyYdAB454jQAmSkV3YlnNz8nR40KfHv6PxkFl0YPjmjVgWkUqeC7M67VlE03/7ZFjdUxOPiUK5k6sAOatVYjOm8f31930/729H9qvn9Mm3TKlFKj8u9ex6IdFxlSlJT+XXujZWGxOm+KcvKYsXyYRsoYNd4VnNZhPyaNF0g/y1YFxdi/WWu8SZR/avRf2KUXPj0pc1/iI10A8I/9Dserx16g/k29t/ccciJmXHSH+jd1YnVr0gKLL7tX/ZumVl/dIx2ZVaDXDPizU67E16dfo/6t1FkBwCnte+DyHoeqaVt0vjbNL2D2FyMc26YL+rXrppLr0BqgX8+5CUe36awqvDzpxmN90+vFq6R+a9DJV2jKelIjwv3Q4afi1Pb7qX/T+3hgs9aMoUiJcB7vcwZj4FDwYwNgPfR0z3j0iNOZCAo/DhS2TYCtwxp33i0ZNOWA9n44WiMqROdocW4+nj3qbADJ9YH2GOtpMtNiwBGnZUQu2xSlr6V5QRGGpeZx7+ZtGSdqx0ZNMbP/nerfigPp3RMu1pS14NL/p74esTFNVnB2pwPw1gn9ASQds9S51KNJS8bA2UKi1bf3Pi7DaaSH548+BxelmBgBNup93f598AIpT9hE+nS92+9ixkmlQK82+UGSVUMpu5/seyazttDUt9/OuYlx3Ck1kz2btkJRbh6TYqrgOK7ZuIIBfU5TXy8lqX7v9ruY0UeUDI7CnFw0yS/Q3eu19shx592iaSh+etLlTA1XdSzNKHlR197M/JFkWZ2zZp9hfUK9rlGSJAnXX389HnzwQRxyiLaSzyMSiaCyspL5V58Q0fA479+stW7u9Entu+OiLr0AsOH+Q1u21528J7TrpmksXdr9YMZbo8po110N+X+ycq5ahNi8oIhJ7xu7dbWqzDTLL9RNg9OqWbij9/EYfMqVGe83LyhiJmdCllRlpkleAYpz81XFuyYeVdMxmuUXIhAI4BNOmfnqtH9kyGhRUJRhxCiGghI9UtIzujRqphpqShqZmZQYxctODS8lPUVRbJUNqCgnj/GIdihuypwfTTlZf/VD2H7to5BvewmDT7kKrxx3AT4+6bIM+YqM909Mp9fRzeHC1BhSvkdTZ5Sc7eFnpjcoLRzZuhNygkG0L26i1vBQpVBR+pV7QD9TZPDsbAc3b5tRdzYkNU62adCIll7/pK4MRbFurGGYdmzUlPHwKXi8b6aXUnnuyr2iBtfzqcibQodM8+cv7XYILut+aMbxAO2UuOkX3cE4AhQ8feRZCAQCaiplVSyizolezdvgyNbakfUW+UWanuUzuTQUIKmI5+fkqs8sgIBKfLFfk5ZoXlCkRttyA0E10r1/s1YIBoKa0en2xU0YAwsA/rz0/+F9kvKpQDFmFSOqT6sO6pxUFNiJFyQjkKFETGVke/24CxEIBLDsiv8yxzuvc6YD6uZUBFUxeJrkFagyFIIBmmqyLmVgXNDlIBzdpjNu04gE8wrLUa074eJuB+OBw05W31PYuO7sfTxygkH0a9dNdQZQ7/F9h5yIdsVN1GjEdNLX7pvTr8F73H176ZjMqORxKQOmc6Nmas3Rhuq0ofREanwrhhKdL5+fejVeO/bCjGP+30HHZijeP599A4DMWsMeTVrizE7JSLoSvdtZm15bpl74b1zQpZfal4viZhLhVrD26gc1HUsvH3s+coJB1bCjxtjIs25AbjAH9x2ajJxVx6KqcXL3wScwETWKu0nKOQD8cvYNyAvmqHP8k5VzVWXv/3odg7xgjtrLqElegeosGXveLcjPycUIEs1W0CK/CNuvfZRRGo9u3ZlxhChQnFhK9PREMm6USLHiJKiJR9UI6GcnX4Gi3Dx1baTgx9BZqWf10YnJPeTg5m3VhuVvH580Xg5olnz2ldGwmhLcp1UHNMsvVPdiiub57B4+9JSrUHPTMziUODQU/ebxPmcgJxhUdYTKaIRxNp3UrjujSCs1Wgq5ypxL7mJk33jAkSoLp4L9mrTEgc3aIC+Yo953xeBqmleAS7odgrZFjdVzViJBJ7Xrjk6NmuFHjX0wIcuq40zBd2dci+YFRUzmhoIn+56JXs3bqsasshcf1qI9zu58AJ5JGbxAOuVXMaa+OyPT4cTrOQAws/+daFFQjCtSew5t8H3DAUcx56v0JVP2Ia25BySdSxR9W3XEOZ0PVB2TFLf1OpYxuGhj6MZ5+Uyq5u87N6j7PJ/W3BBQrw2ll19+Gbm5ubjnnntM/+bFF19Es2bN1H9dumhb4nUFPmXgzlSqEq9gAOmCu1O5wauAps4ouLx7UoF5QkMBDAaCuJh4WYCkUhoIBFTFhaIgJxeHNNcOOTfNL0Cv5m1VRUtBcW4eejZtxdQprbzyAQDaIdfm+YUoJBOnc6NmKnObsmHyi33ys+Qi161JC4bZSkuG4v1TNqCjWnfCvL3JHkqKwv3P1L2My5KqTCnym2jUKP1KaljO73yQepyJJL1MYe1Roj2KIkGNQaOc4BePOQ/NC4oy0jGCGhEYZQEszs1XNyFFKbu8+yFqqF2heqWeXSXSyNdR8aALnHJvFMXrmDad0T610atGDIl2KFShvNJycvsezPM7p9MBuCm18fF9UPKDOWiRmieKfLpJjTrnRgD61OqfnHw5490tzMlFv3bdcCm3CSg5/FrRRoV5S/mMplQ0yStA50bNGPpbILmZ33XwCWqaHZCs8zmpfXcUaqQEKmuCMm4+X7OAMbqDgSC+PDXTIdCqsBgtC4szogQtC4ozvNWKR7tfSvGhPdgURWVAam7TomTFsfDSsZmEMZ2Km2LSBbdh+kV3YNd1jyN2y/M4snUntW8bRdvUBqukfFbFoipjkqLA0NQNhSlTObeDW7RjDN8Cja7xfVNpKYpRWxWLqNThyvMrzM1Tx7XiWdZb8wBkeGKVWjbeEUPPNRAIqM9SUZgu7tpbXfd4Zq2rehyGnGAQdx18Arb981F8fdo1iN3yfEYaIcAyWSn3S6GAP6JlB1WGkkKtGHF9W3VEn1Yd0SS/ICN18J0T+md4lpW5zRdz82lT9BqLcvLUvUvLeRYMBFF2/VO4s/fxuK5nH6y88gH0bNrKsManCbfuAOl6PuV+v7zkd3XtaJZfiKb5hfji1KuZ48wikREguTf0T60DCvFAKBFTHYPKfqNkhFDnhZKBQGsyFDQvKEL74ibYce2jeL/fJXj6yLMw95K7cACXxaGcKwAmDVrZixT9QLnGP3ZvxpRUypRiBLfgdIhLuh2ckcGiEDcpBtfucA2+35CsUVHqiBS2tIpYWE0fVwwVrXHeLL8AK658ADP734nqG5/BjQceheLcfM2ME0WGsn7XxKMqG9ydvY9HIBDQlKFEsQ9p0U6NqgFJB8/LXFozjX4ozmRl3v9jv7TOpKxlSlaGIoNGFRVc1eMwPHfUOejdvC0u6tIL665+EFenHGr8PnVGx57qNSjP9MWUfGWOnGWQCbNf01YZBmmXxs2Z+jVl7wK0xx2QXveAJEMrkGbea1FQjNs53WPTNY/glA77YcgpV+K+Q0/ET2f9C5NSziqtpu7KtSqgTsPCnFz0btFW1bmo85cnsWkIqLeG0p9//om3334bQ4cO1Zw4ehgwYAAqKirUf1u2ZPZhqEvwHjklbK2V5qF4YvXyRg9r2T6j/uWzk5Pe+Eu7HcLUizzWJ+md5j3bilKql07TrrgJ4y1VoCjrNA0MSKYEBgIBjD3vFpT860lEb3leXXi0FE9l4VC85zRftklqAdDyutNjPXj4Kbik28E4sV03nNCOXWD6tuqo3j/lfv65d5uaZqMchzZqVXJ9lc+CgSDjwW6aV6CmhQFsDZJWoXkTzuCKSglVwaFpVEFunOuljGghnxSGK+etkH9QD902Lh3ugKatmVQmxZu2+ZpHMjx1tE5EUS4VWlcqQxljX61dqL6nEIbc1Zv14r523AW4/7CTMOz0f+KmA47C50Sh4SOmNEVDSV1Q+k80zSvAKSmlrEYnJbVDcVOEbn4WNx5wJA5o2hrTUylRPF1yoYHHS7luLa+3sk7xq9WHJ16G5gVFWH7l/Xj12AvweJ8zMPeSuwEALQv1x7ainNE0yTapVEGtzTE3pZi8RVI+lPOihCTfn3EtWqaUUa05qSi1WpE5heWIr2/p1awN9m/WGn1adcRJ7bujbVFj9XyaaJyrYnAox6GpKYoCo1VDQ8fZ+PNvRdvCxsgNBHFy+x6M17V387bquNZa2+jzU1JCfkmlTFGHwH8PPYn53evHXYgPT7wU+cEcjDn35oz0QQqatqQYGAoLpFF9EK3p6dioKa7dv496L/n1ls5JvncVNXb4TAb63F877gLms8LcPGZ9W0PqJvgaW0pyojw3RSmjMvjUUvU3BUX44MRL8dXp16j7hBEZkHLf3ibU1Mp6o5XSo8xl3lN+XNsuTBrwlAvTbSC09ltlDCtz4pt1i9T7rZwTTVNXoNyDFgXF+M/BJ+DJVLRYK1WuQ8rJ15j0GlS89MqzbJ6fOZbp+KYpiAOOOI0ZA7P634k2qXmnvL+Xq2uh51wdi6r9lbTkKijIyUX74ibo165bViVYqYei418ZL3wPSQp6jY+RWqUujZtlpEH+RCJ7fLYCNdh5sh+jlLAnjzwTp3XsieVX3o9R596E/cjz41PlqDOhlCNmovuvUWSF1iwr0Ryarkd1Oz0jJhAIZDhBKHgDT8mKuenAo/Hm8f1xWfdDVeP79A6ZWQlAsuZTcZZTGndFP+TXT6DhMd4B9dhQmj59Onbv3o2uXbsiNzcXubm52LRpEx544AF0795d93cFBQVo2rQp868+gSqfzfML1eLiNkWNcVUPtshSoQ7V6pGkgE8nUhSonGAQ7594KeTbXkLtTc/iuZSXinqwFeMJMC465RlkKPiaE7rYtCwsZiYFr5Qd0qKdOqG08oKVxVQr2kYXvEAggJFn34AZ/e9EcW4+c08+ILngWp5K3lCqjkXV/hy04JGykL11Qn/kBINYfdX/MPzM65iwtNa5KvecKp5KWhlVeJXImwI9AgItUCNLuZbpKcY5Kpcv1j2kBdsI9vIeh0K+7SV0adwc7/Zjc8/p4r2ASxWlz5kvUD6yVSd1nPNKc+O8AuQGc3BNzyMw5NSrVM81AE2vqwJ+k6M0u//meuDQtJeCnFwMPfVqrL76fzg6lfZF64eu0fA4Uijj1ch583+c80JRvAKBAP53+Cl49uhz1IjKka06ZWzQyrUYORa0DDUFLQqKseLK+wFATbWlY+liMl41a/RSdVZ8nx8g7bTglRql5kALWkaBcm+1lEvFmaS1JlGDryg3Dyuvuh+brnkEbYsaM/edpp3wFMwAVENRCzTVlhIY3Hrg0WheUIQ7eh+Pqhufxnka9aYU1NDnWeLoPeFZJ43opd/kjGBa68KntdLr4I/Jsgg2VR0Zp6YU7QFHnI7H+pyOBZf+P+xP5qHWvVTAp4/XElKHFzmyGN6Yp+hQ3JRRPqmjTqu5szIXjfp5dWncHHNTaVvBQADBlHH93FHn4Mcz/8VE7bVSyvM0FHwFrQycDkZK4S+pdEYgmQGiGHVaDgrl2FpOQ7rnKOmqynHo/KItD7TWNmVN0roOI/1Aa89T0J/LYLk+Fe3Wcka1LcqMOiqgpFKBQADDz7wOV/c4HA8exkbvj2rdiSFs4UGNE95BRh0brx+XTkntUNzEcGw9f/Q57HGIM4Gv06XjgX8GdMyf3ekALL7sXnx28hVqNJSmXNMaKyO2u1yDe2EUOefBk17RjBqtfUKBVs1TQ0S9NZSuv/56LFmyBIsWLVL/dezYEQ8++CDGjRuX/QD1FGd1OgBrrvofll3xX5RezzaD1fMw8Ao+NXD4VBCttCzqIaPEBM+RzYuvw6FNAvmFkKb95Ofk4kpi4Bl5lPj0C7rJt9ZQXNKpb/obhxZomhFlstLyWKnee63NgSxk9P4ovYQOaNYaV/Q4jFGatbyRihFDF0klEkKvg2cTy0auQKGkXAJphUWJmlFFnGdF22TA7kWvuXVhI+Ye8XTWu0iaHa9o8PTRSuFztgJkvhaLblbVHLMW9YwqefgKRp19o6Ec6j3/7JR0gfmVnOOCQkthUdBTI3VCD4FAgGHE2/CPh9TXWimfyljj2fVoWgaQJJzYfd3jGJ163ke17oQ7eh2Ht46/iLmPWvMo10ApVKj083NymbRRnjKcgr+OC7v0Uq9D6z4qnnUtpZz3HrcoKFYbcVLw0RUenYv1WcL0KLNzyfw1MhgU3K5R46SArhMDSSoRoE/aAGQq0V3IfefPezWJ9vARFaVmQcFLx5yHZ486G0NSrG+N8vLx3NHnoi/HCmnUK4+nuqaK6K0HHcM4w+7V8DRT0DXkJaIU8o4eimyOpWPadMGSy+/Dhn88DCA5lx7rewYu78HWFRrdf6MoJ09idH+Wa6RtKaiDxsixoGWU0DmUF8zBz2ffgE9OuhyHtGiHnGAQ0y66HWPPu4VxQvGZLUCagVNrbFNDie4hbQob6TKHAmBSHi/u2luTDEWBEbEOZVcDgCt6HIbvzrxWdbzdm0rpfvaoczJ+S8FnbVDQSJBS7wYACcm46ew5XAT0DhLtCXHRHiqd1xV+JCQWgUAAh7fqgFsOOkbddwceeRYu7NILP5x5HbOG88YI/axKh0QI0C7d0EMwEGTS1mlKp1F0nHcU8M7ghoI6NZSqq6tVIwgANmzYgEWLFmHz5s1o1aoVDj30UOZfXl4e2rdvj4MOMvbk1Xfs36w1Dm7RLsMrTRf6swjV9EVdWK/M00emN1ZKSW0G/dp1w6cnXY7x593KvL8f8TYBbEd73sA4nqOh/j+SDmIUvm5T2Iip02hGvF18HU6/tt3UBZu/T9+fca2hR596nWlxu9YmoxgjWgYOr0QqBckXdu2lK1sLp5J0CCMZvNdKrzYNYGvQjm3ThUkF4EFD7EdwCnW2HjhKf6eXuSbG/AJIWaie4RQ/vmfSRyddhpsOOAoTzmfHII8OxU2ZzWvwyWkykPsMlJBAIMAoWmd3NmZGvPfQE/HvXsdi9sX/YYzDro2bMzV9SoNnABmkDQpZhoI3jr8I+cEcJp9eDzTyQGvs+DRJiiM55eRzrgYDSEapFeU+EAjgw5Muy1BQea8mXYO0IrD0udNIqpHRGwwEGXY3mg6iFdmh7GKUTa51YaOMgmoe9x5yInICway9wTrpsBMCbO8lILkW5waCTL85LdBxf3jL9kwkhodRr7QXj86s/6JQSBv4hrG8MkmpjvkIzhZu3jfOK8Djfc9kog5aoAokwGZIaKXZKAgEApoEBnqgEa5cRoHVl3EZcRYBbARcwWEt22elt88N5jDF7tSRodVTT9mLcoM5zJp2J1GYtUDnGnWKaclQjGCtlFt+n7q428FMdPXk9j0y0hm1jMq2Bo456jSkTLMKuYoe6Lll64FIjTG+91W26ovXj7sQW/85AOdzUV6+JpvqAPx+S40o6nDO16h/NALVD3gHFl0/Pz6RdQRmG5etChvh13NvynDg8UQPUy/8t/qaZ1GeckE6xbRtUWNDI5fHVJKeSp85/2yoAzwnyH5otjl5fUOdGkrz589H37590bdvMnpx//33o2/fvnjyyUz2lr8DaETphzPTzWmb5BcwGxQNLecEg5jZ/060K2rM9IAwwm29js1QHg9o1ppRfGhkiDeUeA/CGR174pmjzsa0i243XDQDgQDGnJeO9tA0LL62h9JuAmyoN9tkCwQCWHrFfzH3krsYA4yP2P330JMMGe26cx7CqRf+G7uue9xSz4qnjzzLsOZFD0phqx6oEpCtHwpPb01Bx5kWXjrmPKy48n7czNUrfXkaq5jT9MzuWZStA5u1wZBTr8qqlAFs5OTa/fuor49v25XZ9HgFuqOB55lH68JG+PikyzXpgqkB/dYJaWWzWX4hoyQO46ixj2/bFRU3DMTjWRR2XgYdK9TLDIBh1Wpd2IihgrcSfaRoXlDEPIdfz01H3/g5yafHHte2C1oXNsKFXXplzTunLQioIaL1OxpdptG+oadclbVe9c3jL0Lp9U9mREJ4HEyu5TVijAGZCssv59yIDdc8rElLTkEbPtMmlgAyjAQ+FY/KNkoLBIAZF92JD0+8NKMvGZ8eQxn6+EJ/vumoWezXtBXzzCij4b80KNoprChJJ7XvjsWX3YvhxMsOJPcppj6VKNTti5swBnI2Q8VQPknfvpHMM73WGwpoVKS5QdQZSM6JpnkF6N64BbOWaRESKeM+GAiqxENAsrVCro2aj0AgwDhLB6Zqp/RAjRgqL9u6Q4+pRVxDQfcxnqBBrwekgpxgULMB7mcc0y4luhnJsRTy+sHgU65E07wCTSZdHkpfJp4YiNfJ6LM7s5M1J7ce2hQ1Zgxfuo/xVPuncWUUisNVjwWP4pQO+yF+ywuQbn2ReT8UZ6NmlxMn4hkd2GvUqldtCKhTQ+m0006DLMsZ/4YOHar5/Y0bN+K+++7z9Rz9BFVE+EX2rI76XvF+7bph53WP44YDsg92I1C6VJoTzOcn8+eWG8zBE33PxMkGkRMFVIGlGwKfgsN7zqh3O1sTPyB5L4/hKGn5jYDf9KjycP3+fTPSBIpy8wy9blrgI1W8ssB7gRUYpZgArMeLFsIDmXUMRikpRlErILkB9WreNuPeXcF5tV7WoC5WsOTy+wxl2AVVmHhKVyU99bksqRjZQJVCPq2VbqxaG4BZA/m6/fvg0m4HZzBzNS8oYnqK0H5EAOu5tDouKX44M91niTLUBQNBfEZ63bzERRVbFBRj2z8HqGyDRqD3gk8VuYJsrA8edgpzn2m6p16PKookw1xmWhHt8cR7q2kj5iZ5BRm1okW5eaacI9SBxUel+JTXhzhHkKLc9MmiiAPJsXZH7+MznjnPtqjVRkDBvw4wNmqMQJ0i9LnmBnNUVjUAGRHjhw4/FY1y8/Ewd556OLxVB81ULepA4BXqbGmlZkGTreje1LygiBk/wzlHU6/mbdC9cQsc0qKdYXoukBzbq6/6H/689P9lpG9TNlk+Kk3l/06iB1bRi7C78b0UeSIfPjX+45Muw72HnKjZboSHYrD378ZGd/gm58eRTBV6Py7s0suQNMUIdPwc0bIDsx/zNYYPH34a8/fNBx6NshueyrpHAskMgheOPhfvcgy9vUivK4Atm3AThbnaqcCPabAfU1zc9WD8dfl9mvTjWsgJBjN0Ad5BQh3rTfILGOKJhkjkANTjGqW/I/61f1/c3uu4jMUXSOaEfnTiZUzDN7dxcvseOKfTAbjlwKMZr1EgEMAH/S5V/zYqbMyG/JxcrLv6Qay9+kFm0eKVUD5KQj1X/OJjF7wxRul3s1FlG2HOxeleDzz177jzbmH+5tNFvjn9Glyz3xH472HG+e1AOgWC1tUA6XxtBXx0ToGVVJhsMPKeZvPEG0HpaaTVqJnSgPMb6TmdD0TZ9U/hUYcbk1GhqpJWYYV0QwvFufkYcfYNaqEzBd3o+bTWy7odgg/6XerYEG1HHBZ8mgkl1NC6F/k5uaZZSUefezMe73NGxpinqU18c2eq7FqJEvKgKTlrOccCrft56ZjzbHnoFSjK31ROgaURrFYFxRme3YcOPwUXdemFD0/UN26ygTcQW3mU5vKf3sejQ3ETfK/RyJimL/EUyL1btEXZDU/hpWP1nSpmkM/tTRRUEXOyT9G0Rn489CYEOIdzhm1+Ti5WXvUAFl52j2a9MI92xU00I4hnk2gD74Cka4ITY7A5U4PLrmGUzOCDfpdmXMu/ex2Ht07ob2rujzj7eky/6I6MiD0l6bj3kBN175dRmqoVaDU2V3Bw87aatY5mniGQnHsD+pye1aHCH09xnJptGKyHn8++AcFAgGlPosCITTAQCODQlu0drXkdGzVlygt4Mg2+nrYhwv5KIuA68nNy8ZGOFzAQCOD23vo9d9xAQU4uxunUjdx60NGISHFTHqRs0KunmXj+bThrzCAAbE40kGTs+fzUq9C5UTNHG+Cv59yEi8YPBZCp4NJIVbZ0NiMcSzxjvKHUjRgnj/c5IyPi9M+effBPA0pPirHn3YK94RqV8lUB3byObdNFMyUBsJ+u5Sc+OvEynN3pACbqoECPFlVBttQXM/h/h/TD0DV/ZtDwA8DV+x2OeXu2GrJCOgVlleRrF3KCQdx5sP30IgWdipviiJYdsDdck1FHQKOuJzpwHgBJY4WvIQDSlOdAZh1hs/xCPHPU2cgL5mSMcyug9+4irsaQKt5O5j0ADOhzOgZkMc61utxf1v1Q3WbFdqBVK/qP/Q7Hd+uXZNRtWMXF3Q5mmBMpsunNbniUjZTRbHUwZnFMmy748tR/4OAWmU45WlurFTVysj+pMogBxGchuGUo0TlREGTPmR6Xp9i2ig7FTTNqkAGWNEJr3FzXsw++XrcI352ZaZBbwVU9DsMPG/7CrQcdrfsdN56ZHg5p0Q7LynZlNKsGko7T5xZNxgtZ6hKz4eT2PZDgUuIUdGvcgum35gWM9uKbDjgKg1bNY+rTGxqEoSRgCvk5uYaFtG7g5Pbd0bdVR8iQNetXnKYWAmweP89lQ1OCWhc488ae3ekATNi2hslJBtzdgAKBQFblkfbgUTD8zOvwzMJJGMzlb9uFFuPZaR32w9Qd602zv+mheUERbuV6xyg4s+P+GL7hr6xpik5wcIt2KL3+KU2yj8Z5BfjQIL3JDXRv0hKfnHQ5WhUUO/L6GSEQCGDWxXciIckZrGpN8wsRu+V5yPAubaJJfgEe73MGlpXt0lTinzBR55UNSi+0JaU7M9ieqGPBSfTTLNxS5rXw8OGn4pUl0zTrKl499gJ0IlTgXuDqHodjUckOhozIbVzZ41A8u2gSruuZmT54UddeuOGAI3F8G2frDqCfniiRncOov5ATUCcebygV5ebh/X6XoCoWYVgPrSIQCKBLo2bYUlOBE7gaTzonnBhjZqFVl/XV6dfgq9OvcXzs9/pdgn/3OlaT+OqeQ/rhnWWzHGceGOGr0/6Bt5fOxPNcqiEA9G3dCT9ytVJu4+0T+uOayd/g/RMvyf5lm3i0z+m4ZMIXuF6jTvHE9t0x46I7NFvANBQEZKMmPfsAKisr0axZM1RUVNS7nkoCdYOrJn2NZWW7MPeSuzIUw49W/IEV5bvx2nEXOlIMo4k4KmMRzRz7wKBHACTzlZ/TWDzdgCKjdWEj7PnXE57IGLNlFR6bPw6DT7kSfTh2n521VXhx8RTcf+jJ6NbEvRQ/ir3hGryzbCZuOuAoQ9Y/AYFs+GP3ZuysrcKl3Y2Lxp3g8fnj8M26xZhywf95NidkWcauUDVDBe0nIok4Pl4xB+d1ORAHeuhBjibipijavUBpuBZdvn0Rh7ZojzmX3JX9BzZQG4+ixRdPIz8nB5U3PG06vdUqIok4QvGYZvT9k5VzMHXHenx+6tWeOUmGrp6Pnzctx5BTrnIlA8AqwvEYttZUGDJUCpjDyvLd2K9Jyzqbl1ZhxTYQhpLA3xKyLHu2+WTDheOGYPrOjfjr8vs8U5iKhzyBUCKGt4/vj3s4Sl8BAQEBAfsoj4TQKC/f0+L0knAN8oO5DZYpTECgPkMYSgTCUBKob0hIEmrjMU83wD2haiwo2Y5zOh1QZwahgICAgICAgEB9gxXboGHEyAQE9iHkBIOeewnbFDXOaDIoICAgICAgICBgHoIeXEBAQEBAQEBAQEBAgIMwlAQEBAQEBAQEBAQEBDgIQ0lAQEBAQEBAQEBAQICDMJQEBAQEBAQEBAQEBAQ4CENJQEBAQEBAQEBAQECAgzCUBAQEBAQEBAQEBAQEOAhDSUBAQEBAQEBAQEBAgIMwlAQEBAQEBAQEBAQEBDgIQ0lAQEBAQEBAQEBAQICDMJQEBAQEBAQEBAQEBAQ4CENJQEBAQEBAQEBAQECAgzCUBAQEBAQEBAQEBAQEOAhDSUBAQEBAQEBAQEBAgIMwlAQEBAQEBAQEBAQEBDgIQ0lAQEBAQEBAQEBAQICDMJQEBAQEBAQEBAQEBAQ4CENJQEBAQEBAQEBAQECAgzCUBAQEBAQEBAQEBAQEOAhDSUBAQEBAQEBAQEBAgIMwlAQEBAQEBAQEBAQEBDgIQ0lAQEBAQEBAQEBAQICDMJQEBAQEBAQEBAQEBAQ4CENJQEBAQEBAQEBAQECAgzCUBAQEBAQEBAQEBAQEOAhDSUBAQEBAQEBAQEBAgIMwlAQEBAQEBAQEBAQEBDgIQ0lAQEBAQEBAQEBAQICDMJQEBAQEBAQEBAQEBAQ4CENJQEBAQEBAQEBAQECAgzCUBAQEBAQEBAQEBAQEOAhD6W8AWZLq+hQEBAQEBAQEBAQEGhSEobSPI7psLkr/37mIzJlQ16ciICAgICAgICAg0GAgDKV9HNVDXwIkKfl/AQEBAQEBAQEBAQFTEIbSPg65uqKuT0FAQEBAQEBAQECgwUEYSvs6cnLr+gwEBAQEBAQEBAQEGhyEobSvI5hT12cgICAgICAgICAg0OAgDKV9HAERURIQEBAQEBAQEBCwDGEo7evIERElAQEBAQEBAQEBAasQhtK+Dh8MJVmSUPXpM6ge9rbnsgQEBAQEBAQEBAT8gDCU9nH4kXoX37gC0QW/IzLtF9HcVkBAQEBAQECggUGWZYRnjUF80+q6PpV6hTo1lKZNm4b+/fujY8eOCAQCGDlypPpZLBbDww8/jMMOOwyNGjVCx44dccMNN2D79u11d8IuIzxtFKo+ew5yNOydkKD3hpIcrk3/EY95Lk9AQEBAwDskdm1B+fP/RuTPqZ7JkGUZlR89iaqhL0GWZc/kCAgImENs+TzUfPkaKl66s65PpV6hTg2lmpoaHHHEEXjvvfcyPqutrcWCBQvwxBNPYMGCBfjpp5+wevVqXHzxxXVwpt6gZthbiM6fgvD037wTkuPvI5YTwlASEBAQaMio/voNJLauQ/WgZz2TIVXsRWzxTETnTGCdbQICAnWC6MLpdX0K9RJ1Sol2/vnn4/zzz9f8rFmzZpgwYQLz3rvvvotjjz0WmzdvRteuXf04RdchhaoRWzIb+UeclH6vfK9n8mjqnSzLCAQC7guh3sBEgvkounweaoa9jcb/egB5B/V1XzaS1xX6+TPkdNoPBcec4YkMAe8gx6KI/DEeeQcfg5xW7er6dAQE/vaQa6u8FxIjTrVoBChq5L1MAQEBXUjV5XV9CvUSDYo7uqKiAoFAAM2bN9f9TiQSQSQSUf+urKz04czMo3b4h4jMGov8I09Jvykl9H/gFEESUYrHgLx892XQ80/EmY+q3hsAyDIq334QrT6Y6L5sALGVfyI0bhgACEOpASI08QeEfhmMYKsOaPHcV3V9OgICAj7UmsrRCHntYfq5gICAKeS07gDFfSFVVyC2ZgnyDz/hb99mpsGQOYTDYTzyyCO49tpr0bRpU93vvfjii2jWrJn6r0uXLj6eZXZEZo0FAEQXTFPfk2MRva87RyDNeid7VD8kx9PGkcwZSmq0ycMcdLmi1LNjC3iP2NI5AACpZEcdn4m3kCrLhEIo0CCQsY57IYPMBWo0CQgI1BGktJ5W+d4AVH8yELW/DKnDE6ofaBCGUiwWwzXXXANJkvDBBx8YfnfAgAGoqKhQ/23ZssWns7QPOeIlmQN5xF5tftQAS3gYHdOBLKe9n7KX0TkBb+BFOmg9g1RZirKHr0T5M7f6JjNRtgdSqMY3eQLuQY6EUP31G4gun1c3JxDzodaUOg0k7w0zAQGBLCC6VGLTKgBAePy3dXU29Qb13lCKxWK4+uqrsWHDBkyYMMEwmgQABQUFaNq0KfOvPiFQqJGH7bI3TaosRe3oryDHokwkR45HXZWjghhgXkWtDEGCVZ4anQLeIFjvlyHHiK1cCACQSnb6Ik+qLEX5o9eg/LF/+iJPwF2EJvyAyIzfUPXuI3UiX46GfJBBIkp14GATEBBgIdq7aKNeayiKkbRmzRpMnDgRrVq1qutTcg4NpdDtdJyyh69CaNQQlN5zPls/5JGXkDGOfEjZ4BGgTXVFalPDQ8CfZahm+AeoHTko432pthq1o7+CVFHimWyaXivLsud0yPGNK5OyQjVi82uAkEr9Mah1kfC3Rqku9g0BgfqIyJwJiK1ciET5HpQ9di1qR3+pfuZ5iqrIyNFEnRpK1dXVWLRoERYtWgQA2LBhAxYtWoTNmzcjHo/jyiuvxPz58/H1118jkUhg586d2LlzJ6JRjyIjPkCLTcjLGiU5VJ3+w6vNiB6X9wwGc+A1aLqdiCg1QPiQeidVVyA86UeExg3LSEcLjRuG0KghKH/Ru94RdFxGF0xD2UNXIrriT8/kIZeQtoj6jwaHujZu/UhhZtZqEVESqOeI/DEepY9cjfjGlUiU7EJs9WLXZSR2bUH10JdQ+fb/UP3pM5BKdyE0aigAIDzjN5TedxEii2a4LldFTFu3/rtHfOvUUJo/fz769u2Lvn2TtNH3338/+vbtiyeffBJbt27FL7/8gq1bt6JPnz7o0KGD+m/WrFl1edquw0svgVybVgr9InOo/voNVLx5f3Jy5XhvKFGGJlEs3wDhN8NWhO3ZEpmTbEMgexhRopHO6kHPQK4uR9U7D3knj4C/XoEGgLqOAvrhWWZS7/4eEaX4ljVIlO6q69MQsIHqz1+GXFGCqsHPo/qzZ1H55v2IrVroqozE3jShkRxh019rvn4DkCVUf/q0qzIp9Jz2jMP9b4g65fw77bTTDFNQ/jbduiPu5oMHCovVBn5Myo9X9UMySw8emZFsoBtdMguBnNxkrZTbIqMRhCf/iLzDTmANJRFRanjwqnaOgm4AYXa+BQoK4fVK43tDTTrvXV5fBHyAH3PCCD54kFmnloySO88EALT6cJLnsusC8W0bUPHCHQi2aIMWL4gC+YYKOVSD+J7tAIDYqkXu9oekDoOAjpPZwywdPae9Z/XtDQT1ukbp7wLXI0o0ikMnngcGCwCGTIFusNWfDPSs/iQ08QfU/vwZKp67jYsoCaWwoUH2gWGLiSjx3msfaqT8Zp9jrtdvIy0ls/L9RxFOtUMQsIbowul1ewKyD1Fe4tRKbFqdfp1SQvc1xFIMhlLZnjo+EwFHoCy7LjuhaMqtbklGHRhKvrBg1mMIQ8lH6OV5um4o6XkDvUpvoMx6MS6i41HqXXz9MiKebOoiotTwQGvMZBm1v37ueh42s+lk9PryIc3J56gOG0n2P60pPHUkYkvnoObLV32X7TXCv/+C8mduESlUDkFTQqkjwa8IaHzHRpQ9di3Cv//iizyG5W8fzZaR5WRkUIkO7otgSg3CLjvAqDObzAOpkvSK9HLs6EWUvHKyNxAIQ8lHJHZu1nzf7boavRQ776i7iaFE0ppyOu3nnfeDsgdSRVsUrruK+Ja1qB3ztbe078RQia38E6HfvkD1x0+5K4NGWGIxVH38FGp/Hpx6w3ulxfeNJla3TJT7cv+mmm/fRmLHJrXI2gvkdOjm2bHrC+RQ2lCSq8vTrz10dkXmT0F08UwAQGjct5BKd6Hm27c9k8eA7oUerqeh8d+hasiLdUIIEv1zqvpaqir3Xb4voAaMy9dInQT0+TFyPKwfzHB0KxCGkoBfiMwZn/6DMn25aCjJsqyrGHlXo0QjSmxtRCDHmzK4QB5h9aLh6r9JUbBfqHjhdoR+GYzQuGGeyWDSDSrL0q9dNGDouIyvXYLoohkIjf06KUPywVDSmeNeeZaZJsw+9jaLb16NRPke35oIV30yECV3n1snHk9PFVFuXCR2bvHkGmtGDkKNBmW+H5B1FE63I0qReZNR+cHjiG/fiOrPnkPVR09CTiQQ8IGRlYLuhV6O19oRnyA6dyJiKxd4JkMPgUZN1Nd/h9pIiexXboCmSQfyC9If0KwAD9dWUaOkDWEo+YicNp3Sf3jlxZYk/WP7oTCRDUAOhzyLKAXy0osIU4MhDCVPoPTl8QQ09S03L/22i2kNTM0OTYGpqQQk78eMrmLklcKUYAlW/EB823pUvHgnqt5/DP6YSalankQcNd+86ZPENAIFhZ4dmxphkT9/R/nTNyX74rkIKVSN8LhhCI8bBqm6wtVjmwHjPaeGkssZFtWDn0fsr9mo+eo1VrZPja5VZ0iQzAqPWoJQx0tdMMAG8tNzwsu2J/UGLmew0Iwcqq8xhkqd1Cg536fKl67Fyje/QSLa8OqdhKHkI4JNW+p+5hpPfUJ/EHrmxdKLKIWqmc3IVQ8sPW4t7RXlXVg6Mnciqoa8AOnvSJXpaeodMexpdKnKPeWNNZTS8yD651R/opB6tKtuFwNHI0iU7MpgovQD8XXJusHE1nUMQYZXkRfemPAdXpKAkDkR+nWoNzISdZyyTMYlk1rkUSSCGoNyJMQW5XvkuIxvW4+yR65GaMoIf+43uacBnwxBBnSfqKN64fiOjZBqKl09pl5fMbeNQVq3x9RCkfHidiQ0Mnci4gqZil7mgwPdMRGJYsPXYzD6sH9iwf1vYtVb3mWneAVhKPkI2cCIccuzbFi47VUfJcZQ4moj6GLtosJGJy5t4mt4jx2i+vNXEJ07CeHx33smg0ds5UKU/OfsOmeC8tSY0GH6cbX/Dxn7ie0b0u/n5LJpDR5B1mmS7aahJMdjKL33ApQ/fm1644OPZA40MkjnvVeeZTImC0+92BsZHBijz8v0QiIn94DD0/LdTEelXmqDugc5kUDVp0+j1uWaLOoclCmZQ9ijlC2aYhsJsQ4aj/bG0K+fQ64sRe3373GMZt44LRnF3efUQoDdJ+oiohXfsREVz9yKsgH/cPnAOnXfLj9HJjuGyqRzNSeI8O8/o/rrNxw7oWJrlqB6yIuoeCnZbF3vepxc56x/PYnZ/3pS/btk7jKDb9dPCEPJTxhEO1zLATXa8LxSWOiGY+ApczPPlV4LUzjuZf+P1L31k+2q8u3/AbKE8iev90yGVFuNirf+h/C0Ufpf8onMQSpPN311cxOidTqUQUiqKvcloqRbo+SioVQ7aoj6Ojp/SvoDD50HFGzaT0TztavyyHoSyM03+KaLIOPI0xoXanTSyFUkjETJLkQXz3JuNFGnlsG+EVv5J6ILpiE0+kt3Iy9UqSZj1DMFm0RZ5XAta7h4VIPBrGFMqw6P9uIscy2+faO39Xw0XczDiFJo8k8oe/SfSOzeCgCQaqqQKN+D2Io/k19w24Chc4WpL/cu9Y6Oyfj65UR+Dmq+fQeRGb+plPN2kdi1JS0vkdDf523Mj3gojLFH34Atw7m+aA2Q8VEYSj7CqKjatcXLiBHFMyOCKEj8hKIbvptc/MRDz3SN9iPNqC7qoDz0XkdmjUF81ULUDHvLQL4/aUaJbevT77tpnJH5FSgsTosOVfvzPPU8dS4aSpEZo7VleHh94d9/RtVnzyc3WVpzUptOffEszYhGyvygeAe3TnuZ2kSvhxr5tVUof/ZWVH30hONeS3Q/Mkr9Zvr+uKmAMnV0xIjxgQRADodY+R71iQkUNUqLWLM4Ld8r5wE9LjfvI/Mmo+LZW1E74hNPZAPcmPIwnbP2h/chle1GzfCPAABlj1yF8gHXJGtOvYBuRMm71Dvm+dG1hrRckR3WFgZoTbCBg8KqfhopKcekM/6D0j9X2D63+gRhKPkJI4XFrdQ7I0OJ+yw0bhjKnrwBUvley3Jiqxai7Il/IbpsLlujxC+ONM/WzYgSXZBJjdK+ynqX02k/z44t11Rl/5KHSqGsx1roYm0LM15iXMqRHxElH2qUcjr31P4gNQe9qMOo+fYdROdPRnTB70xkV6qmhpL7TRkTu7dxir5P896nAnVZx3CQQzWqQRpbMd+ZkLh2RCljnDC1NS4ytNJnxkUi5HgM0WVzPTOa4ptXM3Mytnweyp68wXWmOEo6xETLvWIRo1E6LuU2NO4bAEB4yghXRcqJBKo+ew7hqSPZ/d6H5u9ypDY5XlPjJ75lrTdy6PPiUjbdrMFkUu+oHBK9DrhZ900NJSOjywIleaSkHD+2Phslf/zl5MzqFYSh5CeMNnO3uPENJo4sSYj+9QeiqXBt7chBkPZss0X9XP3Nm5D27kDVewNoQCkjRMsoiG5GCOjGHvKHzEGFT9THjEgvU4vMULh7GlGiY5YY3W72i6Bjj0mHSfiSCqBLu+piekputwPJH2QDTMQhVZSi/NFrPKOClkM1bK0g9ey67Fmu+eZNlD91Q1IxU+ATBXqGke0VqMJLlSfK0Ohw3MqcoRRdMgsVr9wNiaTjJOXT1GYXDVIdtkk5EkLtyE9R9d4AVA99yZEI5hoDRNksKGTGZfXnL0Pasw2V7zzkSF6G/ARN1SRrqE7NomN5dP/nU249ShWNLp6J6PwpqPnuXbZG2A8yB1lm13Nyja6SyBg5st10AOvU58lMXzqifzhd98i+LlUZUJ2b1KvCu0vxY+uznZ1TPYQwlHyEkdfTtUltZCjVVKDqg8dQ9e4jzIYv1ZqIKPBiaDoGVW75DSBGPfkuKjOUsYiJKPmhMPljKDHpMLm5iG1cifJnb0NszRJ3BZlR+LxMM6Ie61qyIbjpqaPkH/S1X5EIvQ0t7B5hhR61LBJxhCZ+D6l8L8Je9cMKsPOQ6YvjoqEkRyOIzEymGIbHf5t+36c+StSzLCcSCE38HiV3nul+z5oEW09DZab/cDg/4uzaXPXhE4hvWIGqz55nvlZLjGtXiUH0lK9ETI16RBfNcCSCMTJziFJYU6kdHXPbaUIjLMRw8KxemDoQubXNq56GTNRPh6nNM0gS23sohzb1dbMmWv9Yrl6nXg9MRgYlz3J4jbQ20CCiZEY/jdeG8VO7c7N+zyuGSS8hDCU/YbTJuBZRMijKXZ5O1dBb3MwiUJCu82CMFm4DYELWDr0fsY0rEZo0PDlpaboW00fJGy8vo6Ck+mEkdm1JNtf0Cty9rP5kIBLbN6DyzQdcFcMUUseiqBnxKWIb2NzigKcMXzrRQc8iSjSP3/sIZLKprQ69rKtGhI4HNx5DdGFa4YxvWYvqr9+AVFGq/X2z8jhad8ZhQdPFXEzXSuzcpH0ufjXVpUZ2JITaHz8GAFS+/aCrYhj2MLpWJ9yMKKWvJbZsTlrEVoP0JRcdUbpOClmGW84o5t6R2xUaNdQX45pZW+mc8MFQytjXvWr+TqPXZP32hfUukeD67aXHjatrq5Gh5BHpEAUtj5BdIAWpHf0lKl67FxJ1blUb1Hdl2Yu3jJyK7xudbE54w7OT4M3MEdCGhfoh+zL0Lf/EjrSSEVs2V31tJwoTKCiEnJpjkdnj0h/wiwaTM+1sQal8+S4AQLBJC30Ph1fpMNy5S9UVKB94EwCg1YeTNH7gHMyCGAiko3huF66TSF/N8A8RmfYLwuO/Rcv3xhP5HtYoMRElstG6WqOkHVHysj4pMm8yAoXFyDvkGP3zcnO86nkjE3EEGjcFSnYAACrfuB9yuAaJPdvR7L7XNH9jCtRBIkms8ucR6x2NaATbdoK0e1vyD99S7wixgo3aTtOg62ZIxxHk1DNLSSJIBDDQtCXkSm0j2t2Iks54lSTX1nEmZYkfI34o8nEdg9ej1Dtw9Z5yLIqar99A3qHHeWYo0WclVZL0LR/mpBwLM/ND5mrd0LiZO4KMDBI39xAdx13sr9nkj/Q1RlcuQNF511oWE0pR/TP7rVF2g85eLMsyNn03AbP++Zjlc2hIEIaSjzAKObqlFBodhyoWTO63Ha86CXHTNLwM7wq9ZpdS7+Lb1ut76L2KKNH7miomVz+LhpmO5K6BXguN6Lgc3aEGWWTaL+n3aTGup6l3VCmkqXfeRJQYo4nbzGVZdiV6JlWVo3pwMoWp5Zu/6n/RzfGqt2HH48z4VDyw8Y0rHcoj5y4l2MggYzS5qJCSYwXyi9LyvCqO50EjSi6mTWaA3kvahJLOFacRpZh2tCPvwD6Izp+s/SNXI0o6Y99FRxATxeHO3ZfUMGpY0mfnkUOP2afiMYSnj0JkzgRE5kxAXu+jvJFJnSJMT0Mf6oUlid0zyPrgJpmEYdTIVcr87PNLJrV98VULHYmjUT9jQynzWUbLKjG85ZmO5DcUiNQ7P2E0odxaVIwWYD0Pj52JrvcToxC1TvGuVQRyc/UjZy5vQIldW1D18UBWqZQSTGFuYudmV2UqYO4Xud5AYSONbzsA7Q3TrFVaPq0X8tJQ0lEK3TQimI1OR0EEALmqHJEFvzuXRzYgwyJZF8erbvf4RFzbI+rU48vROzOKEUMT7CJTGn2Oce1n6iXYYvX02AkUNXZPBvcc2dTi9Jrg2KDXITjJaPRMWbZ8iCi5WpvINPBMy8vd7xBfDCXdbA2vMh+okZmIo/aHD9J/e1WjFNOJHvtRLyzLkEjqHbM+uEkmYbRWurmG68yJQOPm6T/cNEDJ3A6RPnw8eAd89fqtfxsjCRCGkr8w8pT5UKOkm8dvw1AK5JJFl2zYhrnXboWogzn61+nyBlT9xSuILpqOKsqGJEmsJ8ZN5YGC8diTsePyhkcX5/xDj0u/b4Pkw7JsiWOdo9cpS4hvWo2a799ncqltydGjQuYMpbKHr0T1p884Z4ejxpjRfXQ19U6/OF5zXjqcj8ymLksmC5GdgSHi0IkSegFV4dYpVtelZrcDfp1mrpOyuDnbvvUo8zOYtyRW+XYNhjVK7oAlwmDp5PWox12NhOjtuV5FW5gmupxs2n/HzXVHlyjHh/pPLqIkczWErskxuBZX2fV0dAk5Row+hw4u5tmbXUNSv5FlGZt/nIxfel7m4AQaXpGSMJT8hNH48KFGiWm6ST2gNlIdgi3apv8gk82w6NGthVOW9RcnlxdnpiO2Ip7fZL3yDuoxXOW4TPOq0009MmeC9rm4CaPjShIqXroT4Sk/ofaH953J0WsYqJNu4JQdjhomkkGfKleVCb088nicrXNxTR4xOCVJ91m66rnXazeQUjASu7Yw3ebdQHj6KJT+tz8icyawyjYT0XKTYctAEaLrjosRJdMKpotOIV1l3U0PvU5ESa6p1K07cTUCqne/vGqQzER1DZ6Vm9F6Or99qv9MC5fZ1Dsa3dKh2rYFo+iYm4a9XtaNQU2b5RRc8rwCZjNFJAmyJOGX/S7FjCsftiaPg2C9EzCGweLolofHyLtBPUw5HbunP5BsDFx6vvS1kcLgYOHkGbb07qW7BAA6i2M8zi7CXuWbM0QYtB+Hu4YSWwBLcvq5LudSVTnKX7gdock/uSfc0FOX/sxpI0E9A96rhpaM4ulTREmXRSwR5+j8XQLDsBU1lO8WdCNKqcL18oE3oXzgTa4yUdV88xaAVF0nVT51zsUxDJQyRol3mA6r1+POaE7IsvcRUM8aeJJxaJgO6yrds46DxqtaWvJ8jEia3ByvTI0SwyjqjaHE6AKyxLDe0Xmvx5BpS6YfPTABfePWMBvJ2nxheveZdLZEyyswLOc41GzcbknWvgJhKPkKA4PE4eYQXTQDsdWLjSeUTgqHbMO7pbeZeZZ6xzBsJXypUYounqV9KokYa1CEalD50RMIU/Y/N6BHcuB240Cd+oRgSxI1lBIIjf4KiS1rnUd3CIw3IPKMndZI6UaUDJRCG8q2LCUgVVewnk2DiJKrkTq9GqVwrScebMaQj0UNUv9cNAY1okgAACnBMG7xRr5r8hPaURhXe7YYOQ8YumuHZA56bRUM6zFcHEc+p94xMPLQO4woyVJCNR50I0qu1iZKqHj9PoRn/MY+n3icqTnVI5ZwLJ+udX6k3jHp2TIbLaephz6kxKUEuSJClmV7z8Xi2mOnbGDth8MtyTCCp61GPIIwlPyEUeTGwcKZKNuDqo+fQuWb9xsrJXQDctqPQy+iY2AoOWruybDOGRhKXimeAbYbNvXKhMZ/i9jiWaj54hX3ZAO6TSeNczitg1k4aVNEagzKMqTKElflAshCmU+esYv1GMz7fOE6/cxGXVTVJwNR9uDliG9arb4XTjVI1ZThQ42SneuwLC8W0zfUfGAvRCIBubo8/ZlXaT9UseAatroGo6yAMFHinV4jo9TqGIAZJ+DO2pNRm0jhVeodewL6v3FoKJXedQ5K770g2adML6rj4j4VnTcJ8bV/oebrNzLowalSyhItuDg/dNoCeEbmQMcHF1FiPnOTbdPQoefSfmxz3Fs1CBlni8k+TA3QtnEVwlDyEy6GTyloHY1k0F2Z/RFZxOx4RPQWeiOFwcnmwBlKugxfLm6ygfyC9OsmLdIy4nFmM9WqY3ID9FpknYJZV+TQ49E0ChqilyXDWhvbMNiAZD1D1Q70vOQGzEh2mkLGUlHI0OQf1fcSW9bo/8BNz64umYJH/WKoIW+UeuemocTRH1MZzNrnEQue7j12k0zCiJCHUB47XevYZuDaBmAG3HqWZh16DiHbYD6z8xstVH3ylG5UxU4Whx4SJTvTfzDpsDE26usRAZFMonNMGp7LEaWKV+9B6SNXc7W7bLYFc70u1igZOV5kWYIcjSBRssuZELvpkFYNJToOTM5nD9soNgj8zS/fXxgt/04WlZzW7dPHMdnbg/GA2tmY7KS+OQmFMzVR+jVKbqc0qKC5z5tXs4taAenn4pUXS4fK1xUwtR7axA6QZeMUMpswXKjJZwGnK7WdceEoAmpSnqtGhA9kCvS41JCPRvTvlx/phYk4pzA5ZIaKRVH12XOI/DGe/UC3btHFOWkU7aBz0qEnm+mjxKdR6sGtdKYsJC6uwY5B4mC+0PqZ/L4n6++tLs4J6tBjWf7irAFMIwluRnv0CE5cfI6J0t2Ir18GuaIEkXkT0/KkhG7vPXedF8aMxRUv34Xyx69FfNsG2yJs64AWxzizhpjc4xpiupybEIaSn/CIHlzPa2T4mxgbLbAs084G5MCLJjMpBQlf6iGMqFbpIpzb7cD0T9w0JhLaOeWuUyEzcqjySwkrJMd04dFFMxCZxzWyNKswOS1ctzG/vGoKycjwwYhwNQVFT14s4kvqnRHbpR45gR1EZo5GdP4UVH/+MifHe2PQcEwwNUoOFVE9hjKDe+cWY5Xh/uFmPZ0NZZ3ZGx3ICxQU+9Pvj9SsSlXl6ffjMYZFTWYiwC6m3tExQY1MN6+RyGB6GsoyuzcntJ2bbsrX+iyxPWkgRRdOsy/Dp4gS3Q8StebG+t/cThKGkq8wmmxOvC90gpn1hjGF0A5Z70zCUXEll5esS4XslYeeX8Si2kpZdNEM18TrXks85irFJqOYUYUpzKXeldpPLZATcVR9/BSqBz+fzN3XksfDzdQ7O2PPifJr9vH4UaPkZuNFRh4bhdBV8P2ImiXizJxMlOxExSt32yZYYRROXo7W+z4p93yU1wlkHXIfr1LEWeH65+5qEb6Ne+RovvBssHosgR6lo9bS/m+JONcU2j0yB6mqHJH5U5Lzntxjxlnh6tqWPt/IrLFEBptdwkS5Xa1TNKe7BXLz7EvQowbP/kNLX69Yuir9U5PGpKupdw3Q6vKmVbOANgwNJQcRJdofwmRdBZNiZWeTt3O+bhlKibgvqXcZxhkBQ3RA+1M5WCgzoKd4Kuw4bsmiCi8TnUxfo9P8ayYtKlSD6JY1qPn6DRSecYX+j+h4cXqtdsaeI+XXpILmKj24XuqdQR2WlLBNN894qGNRn1LvDCJKxFAKjRqKxM7NiG9YgcITzrUsJrb2r/QfwWBari6LmYsEK0apdzSa7GpEyedUUUMPfR2n3jlRsOmckIwceh6xB/ItJXQMB6dGROW7DyOxZS2KzruWfZbU+HaT5l2XFCPO3mOTkVFTMsO1CM8ag/y+p5jX3XIdqNQ2o3zZ7rMsy9j7x1+IVVRjxStfIm/nYhxyarJcwGyixt+9RkkYSn7CKy+aWcYiCq9qlIzgZAPk0uD8aDhr2JOKYY7xqp+KSepsp2CMULKxMvUQDgvHaZGvLKHq/UcBALU/faz/G1qjlONwqXKTsERXBDWsTc4pP+p3DKLMciTENp82gehfs1Ez7B0UnHRh+k2D1Ds/IkqQEoxByEQtbSC+elH6j7x8lfRDV2FzNaJkQOZA13eHthnLGmhy3XItku1dqwxGip2IkgP5TJ+pRFz/WH70T4vHMtli6WcOkEj1tYvMm4ycjj20v+RRf6Hcnocivm4pgFQUhq6hTI2Ss2sMjf8OoTFfITzhexSeeonu9xgHVdDBPmXXeNUYY+V/rcXyV74AAGz+fiKkaPpedDssX30dCDa86E5dQBhKfsKHiJLp1DuDaIkpmXY2EycbEL/IG6XguAUjhSVMI0rEUDVJpmEGhtfiomLGehp1Gk9Sw5qQV5gG0//GrDFPvufQULIzXi3/hvZmMemqc9WzrDdejSj7wyHAoqFU9cHjAIDQqCHp40TCuuubuzVKBmQOjJPIoUKfV6Det0BeQdppoMvs51NdTYx1ODgCXbfMerPdWneM9kI313C/siUU8Eq7H20sdNkuuXnP9Mpy6R7n5EJ3rrlat0f2KNojLR5n54FOdMsOlDR6qXyvocFN90lnqXc251ZqvG4dNQ25jYqw+p3vsPXn33W/nmPjFBtgtpyrEIaSnzBatJ0sKkw/DxuMPX4ZPW5FlGIxffleURFzYKlWiYLmZgGpUeNJSVI3Ysfpfkweu3ZEifGk26lPI2NUKt1j7jdkow84SWkAbKaKWowo0blnNlfBh9Q7Q7hE9GBIIuNH6p2UYK/FjjZAkLffIYitWgAACOTlq6qgrNeo1E3HheG6QyNKDmuU6Jw2aZw4piRPxBGe8hNyu/fW/Q5DiJOXr/s9cwJt/MalFHE5rp8irtxHWZYdM4oxRm4goI4L3lBijA279TCaJ6DXD8vNhq9k/6CkQom4vtPUoaEUKCQOQSNDiTpHHZEO2ZvPkb1lqPxrG6Zd/ICp7wdzbYy3QAB5BUDrLrnYtTEON4dPQ4AwlPyEIXGKk9Q7MmrtKOp2PHh+eOgZeXyNkvfNCo0NJUrmoN240bl8g2uRZVS8+B/I1eVo/uxXzjxZejnueixidhRfeo9og0Cj86KKr806GhW2nAEWDSU7DR1T35MqShFo2sKZ0mRjHlulDtft02ZIKe1D6l0ijsjcSeqfgdxcRzElJoUqN62syyGd5r2y7IrSmzyWwVjVqFGSo2EE8guty4nbcH7YMM4SJbsg11Yit8sBCP32JUJjvjJ0JDARA6fz3lZEyc3MBz3DXkJ0xXxUf/oMGl1zDwqOPcu2TL3m8RnOCxfrd9JCJNORZKm2GpGZo5F/9OnIadHGmhy6L/ENtPXWHqdRM2ZOGRhK9Hwc9Yq0t2KNP+EW1FaYH7N2fI4BAIefVYzWXXKxeVkUK6Z7RBBUT/E3L9HyF4bGkIMJpteY1PTv7ci2o/y4VqMU1T+WqzVKBseiESWaluaw0aUcDqH2ty8Q37HROPUuFkFi61pI5XuR2LnZkUy9jZbZgOj7UsJy7j/17sVWLTL3Gzf7//gQNWUIPkwqIrIsIzz9V5Q9chXCU0ZYkqdxMOs/sXiPa0cN1T6OUXqfH/TgksQq2CRV0xZDJFlHAjlpZd2wl5hb9TtGkWSOgKHkzjNReu+FKH/+dstibHncbcyj8oE3ouKFO5DYuwPR5fNSwg2cUDRi4PSe2pkTrmU+GOxTUgJV7zwMOVSD6iEv2pcH6I+XDEPJA3rwRMK007J25Keo/eljVL5+n2UxzLznW3Xo6DyOU1Pp7w2MmPCk4emfJOKQKkrYtHU78izAKtFCTp6diFIymgQAXQ52kbCqgUAYSn7CoxoldnG2oVzaiILYUn4cMEMxxpxRnw8pAVmSEJr4PWLrl9mWB8B06h1D5uAwv77216EI/fo5Kp6/3TBCwDTZc+p1tUPrbHVRp6kTJCoRKG6i/xs3e3LYqsOzGFGqLEv/YXYcyDJqvnkTAFD7w/uW5Gkdy/JPotY29Nwu+2sfx8hB4EfqHYCczuTcaE2bDYMgsWOT+poqaZJRLzG30u9MrjuJvTvSr7eutS7HloPMxjWm7n9s9SIkNq3K8mUOsoTEzs2Z/dcs/N4ynIxXhgkyoj8nORlyLIrYumX2+r3p7N8ZThB6L9yqAzOIKPFjJbpkdvLtkp3W5RgSnOjoPK72wdNfW6Wy3enXJTtR9sjVKH/+3y7KNobVILYdBjsqw86U6nViAfpd1SiZEd0A651E6p2f8IoSlYbbw9Y9Gba8S7YazjrpS8PVKOkhISG6aDpqf0yyqbX6cJL+d7PKNFic6SYk63u7rCK2bG7yBd8Dg4NEDSUHXleZ60NhGomEJQONeq+DxWnyAMNIBC1cd5jvbuv3VlnvaKNK04ZS3faMsXqNgcLi9B/5hWmvtZGDxg/CCoBJS6MsibEV85F/eD9LYmS+DkJ5Xy/1Dkhep0OfBcCl/fGf0f5OTg1Qn5uG24p8yzLKn74ZABBo3Az5vY+y9ns7zjkn+xTN7jAYK7xBVDPsLURmj0PxZf+HonOusSZTl8zBqG7QHUMpua7qR5SkihIkyvYgr3svBPIL7KfDGq0hunWDzqKRTNsEk+M+tuJPAIC0ZztkSULASs2S3YiSRcMj6JDpzs5y3u2wAgBA224N0+QQESVfYdzd2Y3jyrWVBt/TgU81Sq71UTJUyhKIr/lL/3MrMJsCQ9932ruB0mgbKUJuUXfbpiS1KFOPQt3ASGeNUYcpOD70/bJ1vi42DjZcX/RgVdnWa0xqyGLmT0RJqtFe+2KU6tsGmMasIYP6OreepclxJ5tlj9T7vQ/U2VSGVGaOxIUBmbfRxTMt/9xej0B7+5ScSLDRRxLxy5TBzolIqjFyaMzX1gXrzS+jzAu3apSkhK4xKicSKHvkalS+fBeqh73tjDrNKMqqNw+cOmiIoWS6PIEYIVJliTV5dtePeh5Rorw6rm53PkIYSn7CMKLkYASRhUqq9slQsqH82KoVUH7Ls97pfi+RUXBuV66hUqBLE2zjvkTDqHjrfwhN+J5dkYxS72gOtEsNEq3AcloaVTb1lG3+N1H3+jjZei5OyBzMos57xth/jmbHjh/04ADvZCB9V7r1ciaURpSM6P/depZmj+PQUPKF6ICuTbaYUokT0MhINfF707BxnqEJ36P0v/0RJ+neiT3b9U9LhxTFVhsDW5Fkl1LvJAmybkQpfS2Rab/Y8uMoMDR49Yw+p+sOiQbJOk4YHoFGTdN/JMw9SymRrPmNlOgQ5WSTaTmiZEdI+qWUsPYgqbxgTgPMu4MwlPyFEcWkE0OJpqWZnNDMz+14l2xtQC6lNBgpCIkE5Jr0ghNdNhel915gL8fd1uJsfaOLzJmI+KqFqP3pY5ZGu7pc/9QomYRLRCCW4CQSYXa8MTVKDpVQPyKgdgyluo4oOTGUzP7WJyZKcEQHrsk3ySrquHhcgdmIEnEYBdt2si7HztizXJvonqEUnW9nDffeeQCkGmfHIqj56vX0cWiaJIeEXnTN1li1cY1ukTlICf0xwV+LE+PMjqPL6dpKIkqRORPM/SZqrVVIIhLFqP0vxw9NTsWUc++2eoYAYJlpM2AjPdhJRImeX16BMJQEssFohEVCqHznIVS8eb/lOiNmObBj9NhStP3x1GmKy0JFrOQJA0DNsLeBWBTVg5+3LtOnYmfqKaUe6wwaVPob1yJK7nUDNwJNVTTLzOhW6p3TRn6m5cTsUKa6aCjZqcewOsZttR/wgR6c/4w0+rDDBEph2hHhktFr2uBirsuGAmJnvFid9zQa59SQ9Kt3n5s1dXqgrIqNm5H37aTB25n37qTeJWtc9T7jCCucpPv5nerPIZBfYOp7TMN2nRIBWZYRLa/C3jlLsfDBd1CzcTviNSHbrQWskzlYl1PU2L6pQA2zXifaaGNQD9AwK6saKgw20tC4Yerr2jFfotFlFlhTnC4IsgRZSrDFi9l+Yssbaf03oXHDUDtyEAqOPyd9GCOvLrcY22LYUX/sPVMawCoTTC2PQaoJG1GqA0PJ6rO0EVFiDA9HRrZPhpKNiJJrnt3k0az/xOp4tdOryY8+SrzMhH1DKWNtM6vguXWdpnsaUfpiO+0a7LV4kGUZSMTN9W5z2KjaMXxKvbMKlviF3Bc/onxwloXAwIgMKON5OykvqANDiZx/sHlrJIxaAyiI03VHez+Y++/nsW7Qz5kf2A22+JB6l1+cFhKqtnZf3WgtV9cQESU/YXIRTOzc4slxDWFVYfNhA5Jqq1E7chAAIPLH+PQHRql3/OJkp3IxBXuFwDY2ILJp5XTomn579zbdn8gukTnY3jAt3hvdGiWj39C+RI6YqGxumFZ7RdkwlGjBd7BVe8u/rx3zNcpfuANSbbUvaUb22gL40EeJh5Mm3Px99LAZqybszEk7v7FJ5lDz5asoe/gqSBXZi9UZR4DDyB5gw0Hnd4q4WZAULVcdCWbhJpmD3j3mdQoH7UF8cwQg2b5C5poFm86CoPdVh41P00iCAzvJoopjRyUqKLavR9mqiapn2AcuoeHA9CJv2WvrfIO2HJXwQSmLLp5hXTb/WY4Dvl6/+oyQex9s0Tb9tlFvlKgNKuossq3AssJiR3GlxqAjshObhBUOekWZBe3BEcjLt/z70C+DkdiyBuHff7Z3j6yOcb+UeD2YfZZMc02rhpLdCKRLkQhbEQI7kT57NUOR2eMg11YhPFVb4WPgILKnCatzzIf+abbgZk8jn8aLJiyx0fmcPm1jPZTK96JswD9Q+c5DHNOuyXFnkHpXvnQtRnQ8X/+3Ni0lv+nBLddEcfLsphjWJYSh5CfMTlyT0Z3oX3+g9pch7igilg0l7xcu2gvFNhxElOymplj/CVHqaFQiXz+f1zSNeDbZvtUoWY8oOZHHyPYpouR0HspSAomSnYjMmWD9nONRf7znPrAH8ogum4vSh69EdOkc80QH9FlYVdBtjxefWe+Y3/gTUWKIg8zMY2oouRDFsGxs+VCH5RiOm2nbuEa3IkqyQeodr8c4CS3YWnesP8fo4llAPIb4miXsvmzS2SJrpN6Fd5di9BHXYvRh/0Rox17L55QNfjScrUt59QGiRslPmFzQzE7Kqg8eAwDkdndIfwu4t3AawTIBvwvD04n3xE6Nki2PO1lcKUmDQcNASlhRJ2QOVp9lwgbrHYWUQHjmaCS2bUDxVf+x5pWyTeZg0Rh0zK4moerDJ5DYth7FtdUoOv0y87ITCdjx2Fodr7ZqEx3el6qPBwKxCKo/fwW5XfY39yPZetpM+gf22wlUf/kqAkWN0OjK/9g6hnIcy7Azj205u6jM7PNYr/7SNqymivpAOuSYXc1xjbEPkWQ78jPGl4O92Kc0eN3aMRsRJYUF9a9nBqF8yZqsP7UbaGlIhlI05LMTwiXsA7ZeA4LJBS2Ql4/4tg2IrVpo6vsJo8Z2JmFZwfejSNYFQylghwszBVtGj50FncqJmGM8ZML6PtOuJk/AYv0OU6NkXWGSJQk1X72O8JSfEFu5wOqPLctL/s7iGHecsiMjsW09ACC2Yr61n0Yj/kSUnI5vO0iNdbm63LwxSr3BPkWUpL07EJk1FuFJPzpLM7NFCFNPI0omitstwZfMB4u/ccMAdABb/dNcYr1LnYC57xEN27JTyScyB1r7y7w2u2eReVixeAWmXfo/rHn/B3O/tV2kZO2HTmuGzIrLzQeat89hUv0CwQC2/DTF2QnUAUREyU+YXIBzuh6AiuduAwA0HzgUOe26GP/AjZxPqwunHxuQG8XRTu6NT9SyDKVoxBzFdLBxc5UIwFEkw680I5qGYYvCPv17qVynB4kefDIGHRsE9FlYNURjPhlKdlKZ3OwVZXbc0Xtp0TC3S2PNOANqqxFo1tLWcfzynjtOnzYxjxmF3A0yBx8celYjeq7UXjmBrdQ7+8413jAza6gFgjnp+F48DuRbYNn1qUaJtmaRo8RpaZaAiHxv7YffY+ti82PDJzvJFj04gyBQ3CyIlh1zsHVlTDeR4YhzitG6cy62LE/fg4ZK7CAMJT9hNvWOKMuJ3Vt9MZQs0xTbckZ6XxyfAZ9T72x5g6nnyiy7TphQh8fjqPnhA+R06oHCfgbFolrHsavEWu6n4qxGiaYk1nzxKgpPOM/8j30yBh0XSFuVR1mZ7DS7BawrEw4cJLIsOy/k9SOSbTf1jvZAszjGZVlG6X/OAgDkHd7PunCf+u9YjgolHET2NI9n8Tr9WMNtRMhdhd8RJbsRetq0NB4z3ZsIgD1HgB2nZW1l+g87xiQZnzl5Vi0Y6+IAG4aSwyU4AOCkaxqpa/nWFdpjqXXnpHnR5eA0SZGDBJ86RQO17xoqTC5oZMPVm+zxVIpOEm5ElOpfSoMrG6uThFyfCkhBlVyTMiXSYym6bA7Ck39EzZevWZdt13vuJKJk47naNgRg85nAhhHpMPXOibzo3In2ZPpgRMiyjPiOTSh78HKmX5wt2JRvCXZZEum6bVJ5TuzdAal8L6ILflffiy2ZZUO47M+zpBHv3OwsjU5TbjNgOVXU+yhr3UeUHNaaWQUf1bMzX6w6y+wYPTbImKTqtKFki3yEjDerlQN+1Sg5VRcDwTRzXbO21iwfp4x7dQVhKPkJkx48iXomdRYIpoeFGxElt+hCjVAXESWaF201bcOviFLUek8k2ow2ttiGYqUeyG5EyWJqmNOceCdKll90z47Zq6wSZLgwZ/1Ih5VlhH4ZDLmmUu2LZhv1OaJE5qQZJUsK1aD8mVtR8fJdkMpdYMOymq5ph6GT1lCa2XfoGHWhubL11Dvv06cZA7ku4FOTWt3fmjUUaQTccmTQr4gSaSrrUP/ItRpRsgurfZScGkrkAPGY9bHXEFnw6vSUp02bhv79+6Njx44IBAIYOXIk87ksyxg4cCA6duyIoqIinHbaaVi2bFndnKwrMBtRIpuRziIYyCsgr633X8mAhUXBt3QtVwwlMsQtpo3YY/hypnyY9grrMOJZ9irXRY2SHXFOfu9Xw1mnhgs5z9jSOdnludHvxQ8jQpYQXaTTE83ysXxQCu1GWUM0HdaEoVS6C4hFkkaSG3VcPhi9jKFkRh69D24Y9pYjStZFWF1Dpapy60LchE/7VOWHT6DkzjMzrpdmNxiBWa+spqb6VKPEkMA41D9y8qx93zfWO3tiNA9gJ5U62ADT7+rUUKqpqcERRxyB9957T/PzV155BW+88Qbee+89zJs3D+3bt8fZZ5+Nqqoqze/Xd5j14DGbkc7mYuY7lmDlGLZZxPxRWBjQiJIB3bbOCViXZ8dQoh45G88y2KqD/d/bVdD8rt+xU9cUDiE8dSSkkl32ZFqO8PgdUXLBULL6HH3on5YB6uzwg2DFLutdZan62pySlV6bXFG2/ag3i2R34jEi3G47YZnO3vusACYK4QL8SKG0PO8jITUltPzx69jPzEbUnPTU8ovgxAEJDA/rNUr2TBjLxorjiFL6tR2jpyESOtQpmcP555+P88/XLj6XZRlvvfUWHnvsMVx++eUAgM8//xzt2rXDN998g9tvv93PU3UHJtczJpdb11Ci1JUuNPKzZCjZlGF5A3DBUCL30pdmhXbOmZ6XncWdLFzxDSuQd+AR5n9ru8eQVUY4h4YS+X2wbWdTP6n9eRDCU0fal2m5tsXheCX3NKdDNxPfbyARJYfrU6CgSCUvkaorrB/AsjFob4GLTB+V/sNM3xVav+NG+pYPEaVEyc70HybGn9v1O5YdLjZTRS3BzZ5EQHKtC1rJEvH+Gg11DJMtLZAg49MXUg4bTkv6G4fruV8Gge9kDg4NJcese3WAemvbbdiwATt37sQ555yjvldQUIBTTz0Vs2bp12REIhFUVlYy/+oNzEaUSOG63gIlR2jhsAteOyvH8K3mw3k6ClNMbDJFgPzaujwbmyZjGNva2NMvE9s3WPupX9FBNz3LJjfZ6OKZzuT4HlFKP0gz48iN1DvLRoGduhaOiCOxcwsq33oQsdWLTP0+2LxV+lg11r33deGgMVNILrttKFldL20ogtKe7ek/zIwdtyNKfvT9sgqXZVgmvbDDXlgHvaJkJ2ltvhHyuPcsrRoEtg0Yv8kcyO9zcm2k3tVbq0Mf9faUd+5Meq7atWvHvN+uXTv1My28+OKLaNasmfqvS5cs1Np+wuykNRNRCtmnotU8ngnFrPbXL1D57iP2603qIvUu5sBQ8in327EyIaWfR6B5a2u/tVu47nf9Dj2W2Z4WZrup6x7A4jVKDuuwqHJtxuhKuDA//GYRKyhC1ZAXEFu1AJVvPmBSJDEg7aQ5+VW3Z/UYRPlkHF82YZnly2FKpBkD1HWSIF8iSvZp+l2BxXVLtpUibrVPm8vU7pZrlGw6hSw7SdyLDtbfiJIL/OAp6F1jkOSqydxYEzVKHoB/qNl6cQwYMAAVFRXqvy1btnh9iuZhto8S3UB1jBK+j45jmNgcQr99jtjyeYgsnGZPhlUyB1cUFqp8+rHJ2ogoOdyEGMPBbBqE+mOfooOuRpRMMgPGrNakcb+3eo1uNpw1Y3Q1lNQ7Tl5i82qLMh2uA3XR6NqMEUHTgkN1EFHy4766HVHype+Xz/eRP5zJiJJa1+ZHqw56TgVF1uUB7HplVWexbSj5wHSrA7Psbm265qJZ2xz/yBxcoAdXENSJKOUQYyhjOrnA0uw36q2h1L59ewDIiB7t3r07I8pEUVBQgKZNmzL/6g3MLsDUo6RDq8ykarixUFvYHGwXr9aFwkIPZ9m72UAiSmTTsZzCY5vBMIHqL19F9ddvmBPjhjGvwCzVuIPeSwBs1Ci5ZygZjVU5HkN8yxqX6MF9VgpNnrMsSYhvWpV0IrhgnFmCK+upRSPCjR5DFs7bNnMphZn76nJEyXLKmJ3LTN0b01EMtyNKJvaD0LhhKHvoCoRn/GbvGp2kwdt9pkxqsT+pd3UZHTSTelfUJIAjLyjG8Zc38q3hrNPUO9oLqXFLbROCMaA4eQ3QTqq/hlKPHj3Qvn17TJgwQX0vGo3i999/R79+NjqX1weYjSgx7DB6ESWXezdkWSCY9JeITU+9JCO+YyMSpSZZyNzOLzexwMfWLUPJnWei+tt37OV+2+mj5DSilHBiKNlk+CrdhcissYjM+A1SZVn2H7iaemfyWE6VQcvMfi5GlAzuV+3IT1Hxwh0ITRnhTB4v0wwcGy3m7lFk+ihUvPQfVA95wXmtomWD16eIEs0ccJomCli7Tp+ca66z3vlRUyfLiMydiNL7L0Z0+XxPZBgezsRYUPqR1Xz9hv9RM79rogH/SIdcNJTMpN4VNk5/yU69D+A/PTiVV9hI+yJpRKmhNpmlqFNDqbq6GosWLcKiRYsAJAkcFi1ahM2bNyMQCOC+++7DCy+8gBEjRmDp0qW46aabUFxcjGuvvbYuT9s+zC5oVEnSiyg59ZZnHDDLgkILMS3TbKcOUVOJimduRfljJp+f6xGl7Epa5Wv3AAAiv/8MPyJKsiQ5NyJoUbhVI9ZukSwxyMxQG7uqMBncr0TZHsTWLXPHY25ZwXb4HOn6YDBWw1NGAgAi035xJg82PPRue891EJo0HAAQXTgd9lzmBFbnpAt1CrIkIfz7L4hvXaf/nTqMKLmTXmjiPrkZSQZ86vslo3rIi0AkjKr3B5g4J3f3KctGRD3uLaZ7OKvjwqb8RMlOhCb/aH7/cTOiZKIWhxod+/W12Q/TbzIHE1ZDMMdASAO0m+qUHnz+/Pk4/fTT1b/vv/9+AMCNN96IoUOH4qGHHkIoFMJ//vMflJWV4bjjjsP48ePRpEmTujplZzC7njHsMDoLitsKS5aFiDHMbBpKlJFNliQEsrlc6iCiFGjUFHJNkinRVuSsLtjg6HixGFGya1BINYRN0sw1uJmCIyV0x0/VR08isXk1mt7/pnM5ddHXSBFtdL/cqE1Sj+UPdbZVBHKYamBHx7Js+Lig+IYn/4j4uqUAgFYfTtL+Ujx7LaolWHmWbuwfZiJKVlOsXJDJfN1po1IzkcG6Zr2z0zi4DtngAJhPn07BbkpcxUt3AvEY5NpqFF90owlBPpM5EKOhcUubLAcWQ0pOU98MjSDlOwaWRUNMvatTQ+m0004znLCBQAADBw7EwIED/TspD2FrQdVbUPygPaVwhcqWPOt4FMgvNP662546E8p6TpuOiKeMgNjaJdZlWGUTcjk1RbZK5mA3olSdNpRMXYPrG612rxGFKCC6wCbhCIXV7BQ3jQi32cL0YHkd8cdQYlJYHadQ+l+cn9i2PrsYmmLlN9W7GxToZua02xElE+ctSxJCv32O3J6H+RNtqWPWOz+aMLvtILFOD25zfqTkKE6L7HL8rVHKMWF0ZJXj+Q/0IenoO0ZphMJQEsgCG54f3YiSu03usm56ZDGOzB5nU0j6+iNzJqDw5P6mZboBM2QOtG4gkJtnvX7I6obidkNGy6x3NiNKVaQuyYwH1IvoYJ5+qoIcqnYuoy7TU3xKcauL3mamQGsiHTfy9f85Bpq2UB1KukytJtpAWIKV83bjOZoxWuqgRim29A+ERn8FAAi27mBdRLXF3ot1HFGyFzWzOu9dbqprOfXOIZW92fpwn1nvcvLcEGTt627WDOkdqyFSgBuh3pI57JOwM9n1+ii5nnqX5dxcrvmI/pnd4+96mo+ZiFK7zvQELIuwGjW0nGaRDSY3NClUg+iKP21vgLFl89TXZpQht8drtuNJlpsLa8iwHInwyYhwE3VMhawLqsj7TMrhhhERoJqC3hpOo/Q+Mxi6ki5mivXO5Yi5iWuMbyL08zbGTnzjCms/cN1QMnHPqJPITiq8LKP6i1dQ8fp95kho6jqi5FS+2TR6F5+lmdQ7PXptKwgEkkZZrs0SJy9geF0NMKIkDCU/4SZ1tN81Si7Li5tITXE/opR9QwjkFaS/b3MDsgQ32K6oeJPPKfTbF6h65yHU/jLYnhymEL0OUu+yjQ27zIycjOjiWaga8oK5SJ3L0RbHLHpm4EfDWTugz9fpOlAX9OD0cHrEOzSa7HdPLJccX9XfvoPKdx/RNfRcbQsAmKsZYlpn2LhOEv3LPfAIV87JEkzM+2CTFupry43UUzIis8chvvYvc4ZhHVCgM3A4Xk0bvz5HlNxqSnvCFY1w5i1NkV+UxQrxyUjJMYgoNcTUO2Eo1XP4lXqXPaLk7kKZd+Dh2b9UBxElxmPpQ0qDGwxbDEyOi3CKVUzau8OWmEB+2n1lziPpfQRUZkhQXIjUSTKqPnoC0bmTEP79ZxPn5LYy4XK0UQPW+9L4FFFiDCWHaTd10OiaqbGKaRtKjLPBDaPYEuudC88xkUDk958RWz4P8TV/6XzH7Rql7GMhumh6+ut25BMZwUZNXTknSzC1hjtr18E0rDej0ddFGnw8htDkH5HYtQV2yhY0j5mV3dfNiJIJi8AFo6GgOIAmrZKWSefexrl8XhgpWsPHKKIkDCUBY7hJ5uC3h95leYGC4uxfclspM3MNTq+zLnq2MMfzR5GVa0jTYTPPye3z0jpe3N3ieHpdiT3bzfzAuUx6NA2vq+vpqFbHn08RJcb4droO1EWja9ojSSeixPRRcsNQsvIsXbhGiSjbuv3j3HbomTieVLo7/YdDZ4OZiJj7afAmjkdr+Gxco2S1DqsOKNDDk4aj9ocPUPHafa7sH4mdW1D6n7NQ+7NBFoXPJFluGA3dj0hnwbg93cxA6xqMIkoNMfdOGEp+wk7Ni1/04NkWQtd7GsUQW78M1cPehqRXeO/6NfoQ+ajjNJ86WSnrIMdd67650rSTIL5lrfo6YCYB3O1r1FImXC+Or2P2K73jMWlp/vZRcoURjhhHuoQwTETJeeTFUnTQjagZTXHTUdbtNOA2FmqRVTTqMCpr5rnUQYo4Y5zZIASSmfYO0axy3c58MBNRiq74M/nd6nJX1p2qIS8AAEJjv9Y/Lzd1DgN7oP3+ueh2WL7r0ZV4zPg+eRJR0jimiCgJ2IebZA5up2xljSi5zXoTQ+Wr9yAy7RfUDv9Q55xcVsrMLIKOvdd166HXu0ZZklBy55koufNM60x+2YVm/4rbG62WTKp4unBb4xtXqq8DRY2yn5PbhBVaESWrrIZZhdRBtIVCZ12Rabqa33PSDSOCzjGdWkfZ7RolS/TgbkwQQkahVydTF9EWCp20R9PizBhKbkdbTEWU3IuyyqEahCb/hNL/9kdsjU5LDNedQCb2IHrvXR6venBsWBMYGQRHnFWMXicWqilzfsGv1LscIz5tYSgJGMGOV0SXHcZtpcwP1jt6OBIpi29eo/0dnzZZORZFzXfvIrp8vvNNT5aQKN2N2MoFjs7JNnQULql8r/qaNv51A6bShlxPMdSoUaINPN1g26LpLWYULh8iSrYKt41Q1xFQE9EWx4xwlgkrXLjGmImIks3G3brwuUaJ7k1SrU5WgNuEJDpzTA7XIrpsbnKsZOvPZwVmIrhuOy19Xk9rRw1F7Q/vA7EIqj57Tkee204gEwy0Hbql/3Bo8AJAwMS4cJNAR88ooe/nFbprNWTty+RJRCnzoGZ6SDUkiD5KPqL4whsgVVcgPGm4qYaEAPRD/66nNPjLegczhcyukzloywlP+QnhqSMRnjoSeUf0cyym4sU7IFdXoMk9ryC/91HGX/aLMYkYEbE1i92V6UdKY8bxNMZGzCITXzbQzbkOCCs0I0pu992q6whoLIpAYZZ6RYeGUp1cowkjWw7ZbdytAwtriSsplHQs6kU63Z4TOser+uRpxFbMR9GFN7qbnpqII7ZqISILpqHRFXcgkF+Q+Z26qDN18b4yuohepMeLPnjZQOeQC5F0Mw4XM7wWThGkWrfLQydb/yK/IkpGckTqnYAh8g87HoUnnItgizamf+NXRMlv1jumAFWv8s8nMofEzi3kO85XLrm6AgBQ9c5D2b/reiqTTtSM1ExE5kz0RSb7He8Neyai5HItj6laCz9qlOq45sN9z7KGMci/53PDWdedQnpkDpLbjHB1F1HSM+D96vcXWzEfABCe9rOrc0ROxFH51v8QmfYLQmO0a1tc6UlFj+fzWlN4+mXpP/QsBdfTC00cjzinYql6JUcwmG+yLGPNh8O1G0PbhN6hcvLIBy4bDfXGUDKwLIShJGAOVkaKGw1n3aD/dF0JJNeld36uF47rp96l//CX9cZ1A1Sv5oMqn263za4LI0LreExvJ7f7t9SPiJL7qUw+j3ceGtEWU2mOVlBf+yj57eyy+109UMeE3jNznfUuyz1ze20j60hizzbt7/jk0JNjUYRn/IZE2R53xw4dCzq6idvGoN9RMwCGa+eCB97C/LtedlWcXvoZrd/JcaHhLEUwa+qd+1aK1iENxTRAQ0mk3tUJLIwUNyJKwSCQyEbWkK2/gMvF+Izirmco+VO/w2zyPtFrp4X71IODKGu5nXogsXm19vdsQJYSkGVZ1xsny7Iv18l4uN3uQVQXdVgaLH51zSLmuhGhFYmoa2PQ9fRCf4wIM9Hp2IYVqPniFRSccrFzgWaY13w2BgPBoKvZTKZqHX1iZw2N+xah3z5HoFkrVw0XprG6bkTJf3ZW18lxDNaVVW9+40vaHcAaR27b9dmuwQsbxbKh1AAhIkp1AQujSDev1koBqRl5fkeU6Aakt2j6lJaGuowo+UVYQY0IPQ+3XZHVlSh/7FpUf/OWpXNyJrQeRpTc7qOkdd/q2lBy3RjUULDrminND2MQHqSlmThe9WfPIbFzM2q/f89V0fpRM3/Hq+v3lDoY9WT75NCLLp6ZFFdR4ureyDw7vWtxvdbMxPn70HC+YuVG/Nr7KgAe1Sdp9RgihpLbEaWsqp4nqXdaZA4G32+ARpSpiNKRRx5p6aCBQAC//PILOnXqZOuk9nlYGSh6Cl82r2sgmF7cgjkAsnjGfN6AmJ43us0KfUppYBqVurc4B5q1yv4lv1IaEtRQcpdtK/LHOEhlexCZPgqNr73P/Dk5gJYRwUaU9oEaJa2x4ROLmP7XfTAiXE9HtXg812uUdOabz4Q8ANeM1U3RvtUoZTmel9FIvcwHt/dGveNR56irESUTpDV1YNS7HnElhpIsSQgEg5h723OoXLkRgHc9hvglNiePvHY5pyvbNfjVR8mo1mufNZQWLVqEBx54AI0bN876XVmW8dJLLyEScTnPfJ+ClYiStsKXdQMKIO3gNjEys9OD+8965zrRge41EHYdN6leZRlyLIrQmK9ReNZVCBZrzB+fimSZtAO3+yhlG19epDNq0oO7zHpHYaYJpB9Gbx1FWxIlOxHIyfUgLS1zLPquXPNfd/sa9Xqz1IXy6VXEvL6kF7rQuJcVSO6XT7W0+o5DIsdNmdSQ140oNcBeUTzo2EjEgWA+4qH0uPVLgWdS71yOKGW7iPrAetcQLSXT9uyDDz6Itm3bmvru66+/bvuEBDjoRZSyLSKBIIDkdwIBE3nbOseLLp+HyB8TkN/35GxHsATWu+NP6p2+p468dtMjmYih7KErIIdrERrzFVp9OClTtF+MSSYYquwiUJCmd5aqKxBs3Iw/KVfl6R6TaTjrf069H40n66JGSaooQfnj1wEAcvc72F35WtdTFwaEh/L1a5TcL1aPb1qFnE77IZCbl/37LkJ3TfGZzMFtJkFZo04wU6ZPaw1dD9xk9mNS73xKLzRzPLfXU6pzxGOoWLUZZQtIU3GvIkrceyyZg8vysqUP+hVR2seKekw9pg0bNqBNG/OU1suXL0fHjh1tn9S+DisUlLrFpFkjSgHt13rQWZSqBz8PuaYKsaV/ZD+GFdCFUo9owjdll/Y8cc+IkONx/f4i6pd8ol3lNglXkZteRuTaKoAzlFxXJJIHzXzP7etixNVBryjNiJL7Hvra375AsHlrFJ54geZ3qj9Ps0ElSna5Kl/bUKobModE+R7ElvyBgFbk1wn0DCWXx0to/LeIrZiPguPPQeMbH3b12NngmzGYNaLkdvNXM7W0bs97nawAKt+jGiVdZljXjcHs5+9qdgfAWCxVazZi9BE3sZ/7xAjHkjkYy5Ql2VLz1gDSRorWo/QromRkkDXAgJI5Q6lbt27Zv0TQpUsXWyfz94EV1ju9hrNmIkopmJloegtkTVXy/6Ga7MewArpQ6nkB/fIs083VDMuRWZhJA/HJ48oYR26n3sUoTbDG/XPbGASyp965jUQCsQ0rINdWIf+QY7W/40cE1GVFMLF9A+KrFgIACk44FwENGibaw0QO+9Ak1YM5EZ42CrHVi9D45gHJFEINlA+4BgAQbNnOVfF6RAdGLFx2oPQSivwx3ndDCTrphQ29Rol5Rj7V0upmGSS8MpRI6p2eAeM6mYN+un14yk/I6dDN9YgSdTrPuPSBjM89UeC1DCUS7M0WeZFla0GgQBA45brGCACY+lV1ZjjLk4iSBpmDoAcHwuEwlixZgt27d0PiFomLL3aBdnRfh5WBkohrUi9n9XBT48hUHyWXlVmtKkZGXoK8tJleaBV6xyP3UnaTLS0eS8bWjQwmv5j9yCbrdp8axjjSMjTdVnwB3yNKkCRUvnI3AKD5U0OQ076ruXNyAh9S7+Sq8vTrUA0CjZpmfCd3v4MRX788+Ue2CKlV+Vo07x5EIWqGvQUAiPY9GQVHnWb4danU3aiZb9GWOoRvfZT8rqWlkXg9I8ynfcozR5AZ1lefIkrxVQtR+8MHAIC8Q49zVya5zuje0oyPvUgX0zIYaF2SHj+IAqvqQX5RAIWNkgfNLwwgGmIP4GZDXfWYmg1nDcgcXD8D72HZUBo7dixuuOEG7N27N+OzQCCAhNuh730RVgdrIg7wOedZNiCmLskNenCryGYo0XQ73Q3InxolxlBzm1Y6W1SpLjZZlyNKtGeR5mbuCeudvxElOkYSu7boGEo+GL1eGJ0pyDVVgIahpBpJXsAHwgrLJB/Z1i6r0CNzcDu1SAeyJAGJOAJ5+d7J8C31Tst54KHByRMAaMGvzAeP1jcmoqRbo+QPmUN8x6b0Hx4+12TKG29EeCaOlU2TfbI1iLV42+nxGrcMonSb92uM1T5KDTH1zrINfffdd+Oqq67Cjh07IEkS808YSWZhcaRoKe+WapSyP2bXGeayyGSME71GsL5RZ3uUemcGfhFWUM+o26l3tLmr1mbuReqdJnW2y0YuRSStTOjePz/qzTxcY6WaSs+OrS9U4zl6ybBphhUy112DQrfWwkNFkK7n1YOeQdkjV0Mi0UPX4ReZg+ac8HDeU+juU/4YEZ45gpjaJ78iSjrHY5q/e7fWaTV69YbMQavHkIUadYvyaFpfbp61/kZ2Ybnh7N/BUNq9ezfuv/9+tGvnbh733woWZ6QmoYOVGqW6iigZgfb10e3dkGWZsDrr9TY6JiLi06aryKuDTZZerysis/Qvcr0oN3nQzLdMMFTZFhchtTkaipnrzxFwh+jAwhxJbF1n7dhuwA8yBwLdfj+havW165EXvfYHXkZCSIpkdOF0yLVViMwa45k4v/ooaR3P09pERk4dR5S8WGPA3dO6Zr0j4Ra3+/0xYjQiOX7VKGVLt6Owetu1jKMsp+MY1unBPTgJj2HZULryyisxdepUD05FQBdaC3RWevD0aAyYmZlaxfFO6hG0XDaMPBNUpxau0RT0NgGmxsZfQ8k3+lwv+yjR42kZK27TvALa1+nhs5NpRInIkSrLUPb4vxCZNsp9mVpKoVWlzMqurOO/zOl2kDWZViT60SuKyotok1HI1elomuuKt971eGgQShrkO15GDF2pUTLl0KvDiJKeg8l1I8InY0WBCUPJD4M3ifQYkMPu1kNSaKonPrHeeUmdzfZo0jqh7MegTj/JxN5tlcyhAdpJ1muU3nvvPVx11VWYPn06DjvsMOTlsbUz99xzj2snt8/ChYhS9oazFiNKGkqSVFlm4nd68i1coy6ZQ5ZJGgxa24j1apQoa5vfhpJv9OCU5tY7D6hm9NOnPkpu91Bhjk2VZ8JiVv35y5BKdqDm27c9EKrxLC1HlCykeegpJi5HIBn4QeZAUPvjxyg66+pMmWFiWLjtyfaJLY1CDtUALdpkvucVolFN0iFrhlIwe92WGyQugaCtNUk3Yu2XEeFRRMnUM/Ir84FhUHWXdIhCM/XOCwNGK6KUxYdMkTRazK/hNPXObtRMlsn3TDx2bTIHg+83QEvJsqH0zTffYNy4cSgqKsLUqVOZhTEQCAhDyRTcqFGywHpnyo3gLum+qSa3qmybBaQWVzbdFDCrxd5uwqe0Dd9SCn0ic9CMUnlZI0lTRclmnijZ6Z1MrTlu9RqDOQDMjWndVBcv76sfNUom4Ch6nu3YuhEljw0lsN5hPZpydwRKOqRDFq7RjOPLDRKXYFC/d58R7EaUrJKD6B3PK0PJjHPQ7fRp3RqlqPZrl+FX6p12RMmCIKtkDuTY1CArKA7g6IuKsX21iblCZJoZcto1SvsWm4NlG/rxxx/HM888g4qKCmzcuBEbNmxQ/61fv96Lc9z3YDWipKl8Zlm4rEaUJBlSbTVbL+TEaLB6jVozMtsGZGXBAfSNCDNNBb2C22QOuj04/DGUNMeqVcXXxNjRvE6rCr2VaEuckmGkFc6CvidbkGdxuXWDHtzKNcaiiG9ahdDE7xnl3tNaGjeMQQvIO+x4zfc9jbboec+9ZL1T5jvD6GlR8XShBtTS2LFbS2vVCWQpHZWI1tkPs2d3uLNP1YkDIRpBfMdG99On9VL8yNrqe0TJC0NJS7aVGiWLtz1ArosagwefWojGLXNw4PGF1mTajChZtyzqNyxHlKLRKP7xj38gaHOxEbABzYJn40UzEAiQMR7I6tWSynaj7IFLkNf7KDS95xUADnP1LRsxiWTPIeY941lqKWoFaN4zWZb9jyIBiC6bi9CvXyDv4KPcPbAkoeanjxHftApN73oRgfwCAD6mFGrWKFk1lMyk4Gh4li0buZkUsbqg9496Oq0ok4GANQ+h1vi3eI2W5kg0goqX/pP8XV4BCk+9JPm+hwqa3zVK/LgJzxqDQEER00/KdegZfp5G6pLHZkgWrCq7lserw2dpZi5pNpr22ABUoLdPmMp8sHAfdCNK5g/hFmp+eB+RGb8hr7fb+1QCVYOeBXLz0PjGh9UIBI16eknOo6W++kbmYCH1znpEKf06h8hp1Mymc8DEdwQ9uAZuvPFGfPfdd16cy98HVgcKt6Ga8tIxEaXsQqOLZgAAYiv+JHIdKNcBK6sBKyuxZzsSJTuz04Nb9njq9KXxKqWBA43WVb03APGNKxAa/ZXLQiSEJ3yP+OrFiC6emX7fL2YorXo6q4q2GSeMU3rwQICdEllZGrUjSpbmskXnkitRMwsyqcIZ37Ai/YHPESVPIy3xGOIbV6L8pf8gMm8yar58DdWDntUkP3ANdZF6p9xXykhp9b5aHa9O0yhNaFBSbRUqP3gcsXVL029a3adsamq6bQGypsG7sE8BvkWUaHZHZMZvADi9wAVIFaWI/jkV0TkTINdWpT+g99jD2kjN9Ld6mHpnVTOhUSRqkMXC5o/kRkRpX2O9sxxRSiQSeOWVVzBu3DgcfvjhGWQOb7zxhmsnt+/Caloat0CaWTCZPkoBS85zVYyPESU5HkcgP8nWVP7k9QCAnA7drMkIBo2VD63PfIwmydEQAkWNvRVCNm0mjcE3ZiibESUa8TSVKuq0GWsAzDzMVkfA1HqQGqU9OyyItBFlNfOeWzKpNzcSQnj6r0lPsqeGks+sd7EoKt9/DHJ1OaoHP59+n9CDuy7TLqunEyQ0IkoeeugB2Mp8oDAT/YxM+wUAEPtrNlp9OAmA9X0qELSYiZACLye+cWXy/rpeS1sHoSMKrVozl0FrAuVoBGiUes30UfJufmgr9/7k3nmZesfIIUYTZcPLLtSafO1eUUbfN38q9QWWDaW//voLffv2BQAsXbo0y7cFNGF1pPBeZDNeZWakckqhSWQt/jViD7Ia7Ukp8lL5nvRbO7dkl08RzDFcXLU89H714ACQbFrquaFErpFppOt/jZIsy0hsW2+uiJwxlOxFlCwZg4EA50ywkB5DNvPovEnmZVr1LLuRXmhhHlKlOrpoBqKLZiD3oL42UhotQGv9sGpYWxEXj0GuLs98P6xNG+4K9FJ+vVSIlblAe8RlK47nHU1uROytXKNdDcqqAWi3bICubVICFW/cD8RjyOmyv/HvXKhR8tV48sNQCmmzTHpZl0ShmXrnSTPWTA+1JTmODKX06yatjTN8JElWiSBkxlDKzrpnNaL0tzCUpkyZ4sV5/K1geZzwioopRYK+DlganbIkJXsvZVu0+Bx2YjixNVImZKZStuQQUVis9lHKdo1uUMs6gKesU9ngF+sdUVqii2ag+pOBQEFR9t9RI9d2PxWLPVv4qKtJZFU4dUU6r6mz7GW1knqncV3xVQsRaNrCvDyL1MuazabNphbbSdHTSefxlMzBYaTFDmS1Roko99loz3lHE43YZ4vWJ4Wyf8qytaiZ1SyEFB25bzVKibi6N8rhkLo/ypWlxuKszntN54F/JENyIuF9dhST+UCen097pFb6mxcKfFGTAFp2zMO2VTH1sWox7unBjYhSjhmbV0+OF6x3DRCWV4xJk/Q9qO+9956jk/k7IFpRjZ1TLeb78jVKplLvONY7KwM3ZTxkLabklbAMD70FKKkiVjy7fFVkNqVQs6u7f32T/O7RROVp9jfyRGZajpLfDjPUyxYbJMfWLEbl+48isZekvlk1lCgsVNjSjT2rN9lIZlZBNmqUjOZkNug2DXWZuSzLsU2tb3aZy3SMXLnWQepdtrXOjRRKq1DGSdxCzQf37ALMHpL9fmcYvZa1PItjJ9UE2rIDyokSp+yNZJ/K6jhxg/XOz70jJcuvKBY14G07Ey3eY8t1NTZx9EWNcMipRdjvyAJD2bpwIaJkxjDLjCJlvq+Hv0ONkuXd5oorrsC8efMy3n/rrbfw6KOPunJS+ypkWcbIThegdhPpvWKGCtlWRIntb8V+ZvzYY2uXJF9k3Vj51Leg9mszUCI7Fpo98tcVsKOweNlMk4ffzWzpvbRiEDphtKQROis7T8Da2AlP+hGxpXNQ+c5D6ntOqLPNGGcqGDIHK6x3zlOZsl4jJ8OKZ0+/WN1iLxwr0IoKmXmOLjOXOeqjlOWatZn9vDWU5HgU1UNfQmjKiPR7ZlKpmb+5iFJWoXwtrQ2WPQvjNTJ/cvKF1XQtS7RjLJTUYjliwVDSqqU1FOKyQ8/qnFT2KQ/7GDEgNZ9yxEKzZ5sZAYDOLfFQgW/TNZ28Za1GSX8OZTNkVUPJzNTVq0uyHVGy9v36Dsu7zZtvvokLLrgAy5cvV9977bXX8NRTT+G3335z9eT2NewYNxvxmhA79kxRovKeuuyKS4biZ0ERVahyTeW068mw2kdJiShZUViM5GvJ0Iwo2ejqbhd+R5SiNskcHFwjcz/t1idYkC/t2Z7+w2qNEk/mYBKMwmnBsLc8J+wo2A7mpCuGks1Ictb3eFhtP5CCbkTJScpPtudqt7+QA4dFdNFMROZMQHTOhPSbViMfFp0XGePEFl2/+eda830yg8VqKqwlpwiPlGONUeiz3lfOMMsyR6SKEpQ/938IjSfswo4YaC2SSdjJ7nAAOUYiSpQBLxsYQ96a8etGREm2QLfPBmftp95Rmdm2VyWSZOrx6xhH5ujBLZI5mDhmfYPlGqWbb74ZJSUlOOecczBjxgx89913eOGFFzBmzBj069fPi3PcZ1C1enPyBR19ZrqR20lpMEq9y7IiBAqLk2KybAAZuddBHWXXTOF1KmVLKttj/D3mBPiIVjaFxYVmhVZ7ixD4meYHcDUJVjbaYBCgQ85K4TxjKFlgvKJMVHZdTlZZ72waZwxhhSUPqMU54XbqXba6Hh3PvCVaact1JvYopQOBHHvTUC+d2EkReTAHgIHDxW6tmdX+O/TwJTsz3svmFAoEApBpjRmTlWCizibDoWc1opT6Z/JngbxUOpNlZ5d9VU29h2ELtbRaESWDKRVfn3RC1474BEXn/CMpwknqdBZ5GVBS75xEWS2AsohmraOjsFrXSn+qVaNkee0yr/Tn5qW/6aSPEiMzyzzJScm0WvLLvDaz/Ggd3zD1ruGZSpYNJQD43//+h5KSEhx99NFIJBIYP348jjvuOLfPbd+DxgCR4omsYT1bqXfMpA+wAzfLxq4qfxYjSsxmyhtmWTZNxYslVRgXxhrJz9q7SZYQnj0OOe26IG+/g1NybTAmKc/DKvOWT3VCCpiIkhVlIiMFx3zhPGMMWmlwabEeQlN2NmOQpyDnCU/MyqksRWzlgiQjnKWN3YLRAthKvctQaPmogMHvqcKS7TxMy88G20aEzYiSHpmDledo9Vy07rnlFg8WSTI0DL/skZcAa6hYzBDIiJJZpT/no7xZUNDv/KQYy32UHESUUvfQUrRFaz21Cjv905TnYbUflmIo+RVRsuvQsxrx1PlpIAi06pxrmejPytZPjSNLqXdGn0kADFSe3Pzk/00ZgBbT7SgsMwg2PDvJnKH0zjvvZLzXoUMHFBcX45RTTsGcOXMwZ84cAMA999zj7hnuQ9AasFIsgWCexY3WqplvMc1IWbiysgkZpPkw6Q1ZaLsBpOnBq8qMv8fI4z11xteV2LoONV+8AgBqDw7LG5DVqACBHKpNeuny8q3JZORbkEnTiRwRHRAFOxv7FaUjthKJcJBvriLbNVLjJKD+J/2ZSUhle1D59oMo6n+TNQXbgtGSFGQj9c5oTmSt4dNRUpyQOWQbrxrPzNO0NL0aJT0j0QSy9eXRvB6rLR4sRrI1ldxszhJ+n+BZ77KBu05Tz5E9AUtzP6BotnUQUbISbckYH1acMvFY8jptpYgrDLQWnRc+G0qIRpAo2YX4ljXaLJh6IOPTaoSZTq1uh+XjoBMKEaqyOF5tGkrZlmFZktO6YkbqHVTjKJv43HzzqXeUBly3XkkPmjVK+mO8AQaUzBlKb775pub7OTk5mDlzJmbOnAkgeXOEoWQAjRFiyubhWe9Mp20or8HQdWfd2KMmI0paCrWmfBMzQ9mArND0uuGps+r1zLhG87+v+ugJAEDzp4Zak0lhwVBiPXXmN1rDjT1bryrbNUqskW0rrcpM/Y76nQBLYW+j5iU8cbi5qKukQZlvs1dUVqPFKPUuyzXqslw6qVHKFjmzS4XswGGheRpWI0pWPPZaNUpmnAgZ9NwWlEitNF8zEVdmrbboSLBD5sCn+vEEEibWGssRpaCDsaPBepcVPOmQhfVNDtUg0KS59bRtmm5ns2+jb6l38SjKH7/W8u+oAWiVoY8aLgojXVETi5E3S/ICmq81j0vS6zJqlOjrLMtyYaMgWnTIQTyW/Ux1v+EBmUNDhClDacOGDV6fx98CSpTF8p5uawPiNzzzm56SepedzMGgSNWKJxuwReaQwXpnZQNKJBDIyTHnwSKbKeOds5r7nULNyE+t/0iVaSI6lwKbepdlo6VKiRGbYbYV0K6hZEWGDrI+S2qMZURZrRvZcsgEpTSTR68zP/SOb8eIMHAeZPMs6zZ7tOJMMIpGah7aXo0Su744N5SyknLwMpjnmiXl12Z6IeMl17yvJh0WZmFUy2pmTmbU0pptHKz3WRZHlOL8sVxn6iArwEZEyYlDT92D9aK9ZmTWReqdhfsqVZTYlJG+rmh5NfKLzF8nze7JKzC/39DGrFYsJSuZ5YascxaaweYVBHDsJY2weamJaLlejZKJZ6jZk8qIzKEBGlEOknUFrGJ3Ige7m7VEgixcZphTMvtTWExN4esxsi2cKQU7O5mDuTQfUyxDSsPZbMXxRkw3VjagaGqjs+O9tiGPImilgWfGuVhYZaiylC2iZJBEHbCw6Sb27kBo7DdJRcJuylY2xVMPVhjhuDnhiAnLCLrKponnqFWjlNUY5JwHVsarE0IDPRkWKPtlWYYUqrFAdJCCA7pn03BCne1GHRYvI9s123mWnKEUYNaE/8/eVcfJUaTtp8dnJbtxdyNOjBASNAkSSHC3CxxyuHNwOBzucthBcDnuAscHxx1HcA4nWEiChCjxbLJZmx37/tidmarqfmuqp2V2N/38foHe6e56q7tLXn/zv2OdYG/ShVIzsijJ6GUtSuaEQnJOqKwBmRglU4KSxPMiHzJZ9kwKg9x6ZnKfqr7tbGz6wzSLgpKJvbjWTKY7Y2WTWTVJwcu9Wbe0ZvgDjEUpb1A6TcNs6m4A6D08f/AV1a5pnbzkt9zJ/G22NCgNlwsuuAC1teouUZdddhk2bzYRlL+d4A/r2uH8065AVWm77G9Kk62AZA58TSHzMUp1rz2J2Puv5iEiYYpMaiNVLUpp5jlqlq3hzsU2Veelk22nwYSg5DNenAtWjZgVsArUDqYTccS+fA9VVxyH1Ob1eWhInouzSsgZptSG31D3z8dQfc/FpiwRGvWOFZDVnudxwbEyJwoGwbAo1TcqKD24qDywyNCbhY6hVxeUtt13KaoumI2G9/6ZlwzHxLuhorSSdr3QgrNcDIZEUDMkWoiFjZ4TauO1EIuS+B5NCPYZ4cGKRUmMpc2DrHBmJp282W/H0os3No0fK3FYOgWRGn1Tlh4LwmDBKcHZ92o2b0iBgpJZa4sx7TzrheJJZfIKn5t8LifqKOVvssVBabjcc889qKtT1y488MAD2LJlS6F9arPI+p0yQ0VpsBdkURKZXROud40NqH/9KQUaguWB0mKpLJqZjSCPJjSdyL2LeDUvvDdWK7hCZZARyEzHe0ksZYobULrapBJBkzBMMsQbUfPX65DatCb/tTKGoYBCwolfF5mMUSpcaMm6ippJna1zM3LGokRb4xQYlgJc76TFpZ2ymvEdEMirC2fxRV8CAJJrluenY2WtKQQavdZp+RjsVBKxz95C/fy/M7+prDuyCHAH2A2fZE6ozA9d1juF+S+bE/kE0IzQYlaIkJWxyIOc652F+mlmrC2xBmy96QxU33m+Oj2Anh8mEmaYKtUBzfx4ydBprtuoBMJF26zIYjYVuCGhAr19rVmU1OsoZWCk5NB5MhFtFW5RaluSklKMUjqdxpAhQ9S0SoAp69P2hMz8YAUllckmaiTVsglp/KHgZiSNVWhQdCuQCAqmTf/N1oBETa1UeueyvhhlhFFE46ZNiHbroxajRFmRjLTMCkHapn2yxZTkijDDQLDxEFzSAaBwi5apTHsm0gKJdGJ1QGm5QtY7YU5Q5+wEGfPR/Les8npBrncS4d0hYZANyNetLfncp0wXJc3Q5NcaPkmGDZYxEVLFU56xk4ijZu5NAIDQ6F3g79xDMbOfZnysQrMgiC7aJqyRQFZQStVuQ/U9F8FX2Tk/Ra6kBEztU0g0ovqByxH//tP8feOIEtZIpWds9nzIF9PGJnEpUKEGAKmq9Uiu+lntYnY9YZ6Rnx9QniPJDauV+8logZtgpqhqrbonCFfahFFQmDXuFKpP4eQk5g8udolA5vPkrWJCEZHQNwuxBhSZ6c5E1rv6UBibyivRa9O6NhejpCQozZ0713TDXbt2NX1PW0cm2UksmPMZNet6l06nCxDzhR0oH/NSs0WhUzBgygjtnMKqtPatT9F7/J5I1tTBF6FnkmqgYz68u/cfMO6Z+1FRlt9tg0/gIGHoFTNTpapNpEDP0owb05QhX3p3joZEGDLLMGVgJk7CxzO+ZpB11zQToyRKSk5ZIjjLg6g8KMB9ymx6cDuyCeaDzwckicKPeWOUChRqqOQfBSZYyQdd+uFClQcNtYj/slCRKPuMwrrjiJwkcUc14SoaX/IVkit/RnKlAoNvYZ9K1dUgsWRBfhoSmuzarpRiOqOoyBtLywgjOmukeipr0/WaMoo6MjmOukXJXEkJH7demUnXXWiqdU6hJxDLJ7hkPonfbO0kdrkyKVD4g01bcj6Bqsnaoxk3a4NFq4kG+BpMVIySQluZd3npSZdgU7v2uPbpuzFNo3mcNisonXjiiU73Y7tAZnws6dkfuySbBpKq692SDXVYsHQD9nn9SvhKy/PfI3UzyhNnoljLSMfQkunB8zMSy5/9Fz664p+YdpL82WQ+wmaDKxccfxb6jStF5555LqaYTZ1ftryQbwYpk653UpoSkOmeDYlILA8FulSY8+Mv3PKRc73Ll9mPjmvRxbxYzaKWa9iYpob83zKVRDqZgOZnlmkz7oU6mk5ZlCQ0HIuLomIwnBd4dX+bEJQa3v0nYv97AwhH8l7LzXsfP3Z0xb1tGK+ZZAq8dc7gmEA25XnewrYMhH3KTAp9U5YIiqbJ71gz90Zo4YiaRSkzVS1YAxPLf1S+lvQ8ENcgxTmSrjPhym4lRknVgwXg+h6r2oZMCUrd8M8zHTLNZGoNkX1Lp0lPKo4XyVP8FQD8QQ3JhELyLvIPA5oFQtWlz4xOflNzkqq7Dj4JpybugiVJroXBBad1DxlkXnbCl2N8NpVV5L8xlcQOt3+Jf7z4GlIbViOxbLHxdVINoMSNQyRXo7gBKVqUVFw2+4wIIVKm5V/DVTPC5EG0TMPEWQpCEkBr5ww0hUoww0iINE0lc7DHosTHYzglKFmIM1FMzMH3XaY9t3FZlMUK5EkmEV/yNTafPwv1776S+zHf7mgltbsZkEoRcxal5Jrl2PSHafwz5oMkvsyV7IWAYClUz7oX+98bzQcKMS7kmBQtLzZl/RMsSprZdSdFWBWlNM3NCRamsqWxVKh9UuUZ02lse/BKxH/4XH4dNz8Kz84a++D/lK/l5wGRxdREMgel8gdUu2b2iZgJqxnTbnxbTsDSKU3zLJP+gIZgGAgE84wxXdgdIVDIyQFoEsqUXgtDU8bjFJpMIl+7Zq1WIn+3paydnMdshSYlT1ByEZtT+gHSGFBI3djMALZP5VlQKA2gJvie59PUNSjGmAmTQbOgqSvv5Mfux5Xn3UNkGVnMrBt9R4fUL6Yyl5nN8FUoCkyFrPwdRRoyZteMRUnVhRMS5kWFTmajzVtQk30O0HPCb1+66ZpGZlAKz9jIBtQavNfUhtVAvBF1L96X/c1SenA7LS8yRoyln2e8JtcsAwDuGfOi2fJgSNMti1KBc8IU2DgT8XnZ12zXuqPbJ0y6w2bid/K5UpH7hPhceTwf7LAomUzmoAqNioMS6dsIzU/Q1K3nas+ZMmNREn1BzbxLM1Zl9t1JGPp8vEDHngHsNacdSitNei8QiloV607Hnn6l7VtmUSo0PbmOhqSSrSwOKpXUE91aXo47Dj6J+81vEAMXbxY3WqGc1LIFpUQigSuuuAL9+/dHNBrFgAEDcN111yFlRxrbIuDnxiZLUpoZKEnhExg92Ybvmny9S/K4dSUobWDTD7nDfFpm1Yw+ihYlMybivP67soVCCK6UwUxxOtp9yiVBSaw1ogoTmZmkyTdccW2SxH7l0yzH6pGqrzWX6EBnlShMG5oPW2LM4Be059yeoyqcmbKaAWlqvFoVBn0sEy9ZTxyZE0Yur5ljh3ZhgcOxks5enSYl5DpkUZIVJjeR9S5dn0ehR7rASixaRsjn/mZIA4LiyYn3CLmi0LHEMcY0Rbdi5cypeYswS1z6nEwc04w0s+EX6l0yZu+o9LyOd7FgeWmoSStl25PxOIXUUTImQv+Z5ixa/IUpg+DIbwYNx1eDR2b/1tIpQ8Eimbm3FQpKSjFKxcItt9yChx56CE8++SRGjBiBL774AnPmzEFFRQXOPffcYnevYLBZ78SBl4QPvmZxKYUmSfaR3zQgApSm5a5UsZSW+6C6mi2SDVAhU5shdAy1MY2G9ZsRNmHAkUG2AJrJ/2+mGne8us7wvbqlKXQ7BkOfpcmCW5wq8mlAJR8+8esi1Dx5q7VkDtx8sZD0QOhripvrPHkyOYABtsUSKA8HFJI58O38WtWIPmzfFOnlAx8/I3FDc2K8+Hw6xU8ursWZ4rP6TJDsu3So4K00zoR4fqv0LCgP0vFGpKqr8rtSkd8Oto5Rrh12j5O4baq+R1+HLvLadBLlls7zwi7FL5n2XFj37BLUJElcnEocw7VrQ2InM4pZ8W9eUMslYJChXWdzJiXdY9llURKHHDUEBRoJzY+AkC3HjxR2SK7Dj77OSGk+UGk8MnthK5STCrco/fzzz/jPf/6D+vomM7sVf0kKH3/8MQ488EDsv//+6NevHw477DDsvffe+OKLL2yn5SbYNyUKSgnmkzQ2RwdmzJhlkMd8pEj/bg0J1sJSaBYzETKGmkGy3mRMjgQyczefrtM2kohvYzZ+qabQBdc7N7SROosOc2wn40u5NOoEcPnm0vDuK2oFPHXuSxRTaIHxFe5NMi9vfS3PrLHzNZGWf9ex9yzAJ8urDa1mCc66wLezelvOCk26xhYCSngu0M2ngA4Y03BDWQG4Mifporo2ut5Jk/6Ye8aax25A1aWHIbHipzw0Keux5LkszUnaQm66jEUz8rr9qc4JO61YjMDeyO5/YnkLuyygojDIDVFn5mEqkXuwtDSWxx5+VJokwqTQ0mNoEONnlpijKbQbC5jMmKxCQyAjc8YxsigdHf8GH9Y+iD/F5gMwdrtrurdpTCRsdG13C6ZH86ZNmzB9+nQMGTIEM2fOxJo1TcUsf//73+PCCy+0tXNTp07F/Pnz8eOPTZlfvvnmG3z44YeYOXOmrXTch8yilPs73iwoBZoH3qmNn0lbZduqifOjfX0tE79RYMyLCFm1+PXvLsgep5HWFzgzAc6NTmY0Ihcxa4smebuY9MChBaDQzdwUyIQVvDUynbRRAqUYQV2WKHueWRM29o21jCurXUKEcC8vDHG9Aftet8XlY/TCVc9h8M0HI7FZXwSSVa6I1g2uZhvlLlcI7E5wYgaaj9SeO5fMQeI+5YqV1SHXO3EO2hD7la+uEbmeie5b7HVW1lbRbZISKMzMCaX04ES7TrmoMXPilypGqVpg1rv89GRj0pk5UffbxuyxTKCwS28vy6xr1rrTtb9aLnKZZ0x9KMJcp9QcQYP+e2tJOXmdkaCUwbmNHwHI8asiMrxtcnsQlM4//3wEAgGsWLECJSU56fjII4/Ev//9b1s7d+mll+Loo4/GDjvsgGAwiLFjx+K8887D0UcfTd4Ti8VQXV3N/WtpkFmU2JilRi1nUfIbuMeJwzHBLIC/bGYXStrNxxIjI9GyJtnU1GmL7rSU5kiaEcb4/sI6kDvcumhZ7g/dBuiUC47z8RCNVbkMUlXf/pI9TqeB+NZcUG/1khX2ESWtErQG2BIEpjDGBAmlKQbRJETLUIr1qRdosMM3mYd5OSL+bdNt2/Sp5bk4R6Hv7PrCMYV+i++U3ewkadcdsbboXIkdcNcSoWqVcIqmzvJjk7VFKoDZ9Iwyd0ydi5r9lkJ90p1cuxvqGAWijd9RFge8ppagaYW+8O74NYF/x8k81mt1kux3lSRYsRGUECFzUbNGT/K3TW5weqKGhwAEa48FmklR4GHaivn5iBz2nTcoFJ5inS5ZOtk9rhX63pmemW+++SZuueUW9OrVi/t98ODBWL58uW0dA4AXX3wRzzzzDJ577jl89dVXePLJJ3H77bfjySefJO+56aabUFFRkf3Xu3dvW/tkB6QxSsyilrUopVOYnNQzqAnh87GL4/KtjLubpgmaZTsXZ+O/zdY1kIFenGTaHiZOxKKgRGp4nIpRKkKGrYYNW7LHrNUonUyhfu2m3N9WNgTJ+9IooQk2uowJ7kvsnFizjWVeCmc8a4XEe+z8XlGdUx4k0vw6oNu4TIClIaPPJY+wKtTrYiD1vwNwRrMsS0XsVCZKmVVAJijaRJN9x6Kbk33KLqFdu9wLRQ2yLCMc4b5l5RnTkm+XTDvjQskpTIS+s2sNn5XSisDLz4kUad3RsDVmV0wULWTr3rldULTo2Ca4SPgYqdLWggcNr9hN8ynJ2XdsgcbWaBlPk2mK5UHrQhGOr8y3Tz1f9wweqH85+3fc4N60Q0K0kzA9mmtrazlLUgYbN25EOBy2pVMZXHzxxfjjH/+Io446CqNGjcLxxx+P888/HzfddBN5z2WXXYatW7dm/61cudLWPllBRofMaZJ1wo6x610d9JK8KChxk0ignKKEMxs1hTU/r2I7kzu0uGhRWVhkwpidFiVqQa75ZTV/oSUmXqIhVtXsWqCvmk3QmqBEMyxSiw6Xrc1C/hluY+fnyJZYzmJrhSkTLUNJbk7mjtduiwuW5cK/HbuGfLeeT83MznXu21ncrPhUxBJm0wGGSbQ80LE8sDZeWJqi8E4JanY+LymASgRFsyRkMUpUcgCzUF3PxCQVNgkRMbEsByFQ2GkZZJUi4pjk1gTmudKW3FR5iw73XFymODpu3yzqWScX4dtV2SWMCZB5l3C8gU3k9bE8xvyHnYIa567tC3AbVSNTg9MKjUCc16ix7y7JKDKWd+3J7c359qkZiZ8xM7Ek+zfLo2bv3R4Epd122w1PPfVU9m9N05BKpXDbbbdhzz33tLVzdXV18AmLl9/vl6YHD4fDaNeuHfevpYHTJOtcZfSudwGkDFODy4Qs0VLFzqmv1xDJCcxC6HvDpq05ejYuHOQCKKPBLqgWNC8iHZa+mKTC0kZLMZ6APDCYu87CRisRRrm3Z+U7imOSeZYkt7Hzz8ExOhaesYHzXuUtSrVsjJCFhVzmSpsSFBmctceCRYl1uRXps3+v/2VN9rhxW55aN/nAfiO3UyHrAsclQoNd65tqLI+d/vdkrarsf/TXmaYhc32zx5IrKh5IIVtWSNfCe42Jrmak5cW+b8fO57WCmTdFCMCWBCWfDw1MECTlQZJMy+NMzGCrUCOOdWXm6scJ/bQCKR9hk1sa16SYMIoQ1MwWvJUhFsilCF7csz83XuqYGKVNZZUF0xDf44pOPbLHSU6wFlzETYydOHwcP7tdpQe/7bbbsMcee+CLL75AY2MjLrnkEixcuBCbN2/GRx99ZGvnZs2ahT//+c/o06cPRowYgQULFuDOO+/ESSedZCsdt+ADkES+GCW9RcmPFEoMUoPHNT/XGG8izR2vrm7kFs46ThNkcuHy+XOFBWXudeKxFQbbaoySVTmJuF/3u12xAqraa7E/8BW8BlHCUMIfAJixZyUxRjIW5yqh1yWB0ixJLdt30TS/tTGFzs3Hmo9KPpofDUnk7LJCjBAbqmCFKdPXRTNmytLQmp4zbXyfOZpqCpJ1lR3RO9lkBY3X1CNYZmHHIoR3Xe0bJ5I5iAy1xEXLyniBz58rYixmnaMEe/F5NV/BXJPUamVXMgnRDU41mYOZtNbScgMCPYZmPJ3T5Fr5jqKChnIlStko1LM0vl1bj72Yc6RHhxVLdhpYXxtHJiCCy7ZZHUOH5uN0Oo1kPGkLs8oxzZqGmngqR4d6lz6/JV94qXCSzj2W61nvJBl4rRCNBUNIJXzZTHKcu3hlJwxKGhcF/tzfCxOTqwzPAfrMdnXhCDJZv9lvlxZomtmnkoInU+ZecT62BpheYYcPH45vv/0WO+20E2bMmIHa2loccsghWLBgAQYOHGhr5+677z4cdthhOOOMMzBs2DBcdNFFOO2003D99dfbSsctZF52WmCYWBilB58ZX4zn6p/XtSdK95Sbz9KqmDC/mU1ehSkkClWue5tP0y41ReenQoKMUZJcaGeqcGpxFp+x6us8aXElYL+DND22RLBN1KoXmBVBCaMJzcePV5sEXoDPzMiO3SUb+eeIsxphC0IM65sfS6bpGCELbkbinKTiEUXdQb5kDjKkCKsVwDN/nNBmlY+grEgyId8u+GQMvSioWXEZI1zqJC5qOqtywKQuUiWboGggsStGSZbZz4oArItRytHhYnkEEmtr7IkbFOfE/y2uyh6zHmJfr7FmZaXWE5mVud6K0pKBbj1j2lpclfNGidfUW7JesxCTyJCWB/Z7W1AIAerKUEuub0SWXfFPp7Lu8SHR/HslQygE/D04CjNLaINCtRCjxCIhsyhx3gtyJODj9p/MmFAputvSUJADd7du3XDttdfa3RcdysvLcffdd+Puu+92nJYr0KCbULJFNLOoVBD1k3Taa82XbV+vWaaYQskGFI6i/JSrsO3BK7OF5epTPmRqWeu0NpTlRXJOBbJ6Cdx1Lscoya4zDcrNBpAzLCz9VBq2qAqFfYLlZay8S7EoH8XgL90SA6ty4Xy24YMZlikOH4LNS/rKbYmsxnXV1kbuTbE0qhvToLcROVTdYdOC619SODajP09IBCVKG2hV4coy55pMkHekuKYoqEhcxOwSInSxNGx3aKuA5g8iHTdRR47VuEvqKHEFcC3GKGXb0cC3y1oKRRp+P5DQu4Mb0vAH+NHMZFzcEkuhfe5Kjj7vXWFu3meKtQN6JQTFbFp1SUv7fNCavS24uabRc3JTfTK7JlkVBpWey6LrXSqd0wuw32dzfVJQADNWO80Hf/PGkYCvMKYz17DxsbBeWlbo+TLt6Bg2QyI6VsjkXsyOVzF3FKVsk1l3kvBhja+cPN8QCGWfJSnsRdsipTnrEsQ9hJ2TfoRB1y9Mwmfr/ComTK+wc+fOxUsvvaT7/aWXXpJmo/PAWpRy4GMY+EU1niczVVzYOlRdcDjXA5nGd9cDERqxE7dhsnEe4uKwpaTM+JyNrm/qglLa8LiwDhgfizyfJToyFwxF9wwrPCgbx8VnxBEyJtqkKQP4MRqPxZnfRWEj9/fGBnMdoIQI2QbEBWILuDY8HQeXnIAGgm0TtbWURScNmpkxq3WVCUoUjQ3tOsAKYpurs8d8Nj2duSN3bGe9H/KcfYISLwyKlh5CUBOtJ/ksStJnIQQVE+nBo7PmoN2lD9D0dVnvCAuTgUujMiS1tdjsaDWNKW5OspbkpVvyC5v1DAvOzomYwMtRc0K6FyqAUvwoz8l6haLZJGjLQ1Jcdyw8J2ttYAXQhkSap8/QYK12KQtWM4Dfp/TJHNgOWKHBHMssSpBcZ5I+O15Xd+jC0NDI9yobr0n40CgRSTlBHiDHTppwnwP4jHZGSGiCoNT87W3KTu8qTI/am2++GZ06ddL93qVLF9x44422dKqtwsj1TjYoRUFIhCw9OGcFEDSwLI2fNxtbqwCgIR1oMkMzGxsnvAmLAxsQ6FgyB5kARliRrFuUjOn/1qEzf50VOsw7ToiaF+bc1h9+zR7r3LwsWXtyx+srckx0Slioa4MRFAq2fynwn2/jgp+Yc6KV1VhQVwEpKGmSDUii+YrDjw8CA7BRKzU8r896x9DX+LnO0mf7aVZQ4vuupj1nsyeJeCk4Cv3KL8PLgRHkNTGm7tY6qpg1IBci8oG0FPEZvmTpya25pVHJFASLlix9f76se8J50jqny3rH9pMeL6ExU+Dv1J2mL9LjjNcSS7YZK5bO9c643Z82NWDl1tx+tIkRHFTmRI2WC4Jn9856IeudqoY+HyMooiFl3JZMUGKvq0ua4yATwnNQz8WVD4hEkbAwJ9j3qme2KfrsGmgtZpFzqRcEQOo60zRkghIVBiAqAU3SZ8d3nM1sB9qiI4v1SULLhm4YntftRfzeyNPn2831OT9/muaub37G7SHr3fLly9G/f3/d73379sWKFSts6VRbh8znlGNm8gxEUTNEu/nQNGXm2xs/XI/95y4kfYxjgRBfr0hi7mfBaoVSyfwrCpUeXHcdtYgpCBCyflDtin6+VhZnVmPcKPQ32ZDTpv4aqcge69LD22TtqQlFc78DqGX+/ql734JpNDDZfMSNfWWnbtw5FilCi6kC9h3xGzvP7KaJjV3XXjN9am7KBBV9+n7jeajCFMaJ51LVXucTBmu0sNSinajJxZGtZ7PD6CxKrFVELdYuC7a4IVfgVhRUCOsOYJ/rnTQ7W+6cGPOpBfIUaBSFCKatRG0uZqbm19+Ya3j6sjhTzR+QvwPum2T/0/y3oktjvncsnI9z81BYwyxYWVkmnp/3avukOHesWHaThGJSR5+zEJijxz5vk4t0fgFQVMaa1a2RiTCE9ZxND85dl07rhBozYPepzaUVzAlIBZdsXxL5qXMxSuILomhYtijlvqXeRRvc3xnkc71rlKzfZixK1D4VzzNek1zp2dad9c60oNSlSxd8++23ut+/+eYbdOzY0ZZOtVVkxgeVHlx0x0nkGYgis6ZjBJnjNLE4yzaDei2Af/9YhS3Mosdev6j3QKFQWa7ddZW5sZAGEGc2S9ZFLKVgIVDV4shc9FJ5VDwytzVKw6Rzb7SyAxDuKABQ9U3O2sKmBxUZgM0lFlLhs88lCBAb27XPnbOwym2NMK6ZwoZdF84JYzJm36yWl0qdLVce8PSNiuY1asaWAp3rHaW8EC1a7DMqaF0bCaZQjIcoJB4jw4DJ3nUtMw655DDC2CVTuyskOdAYawufMp626OhjaSy4+kgtSuyf7Dnh2+WzokkscJs++yF7XLd6Q/Y4WRfjhKgtC3NWZh38fqlVTROFQeWsd0ybQbkwKNL/fl2u7zIrq6pCz+h6Wcp8ai+UCUo6K78BKJqyNcGsgoTqn2j5TxHPKPIY+bxWRLDMschv0O79jHtlwlopBJYIq3gTTgkxyqxiVoGEKo/B8AXLBatt3KSCRr5PmVd2JTUfYhLXO1m8rDTpEDde5c9IxihtD4LSUUcdhXPOOQfvvPMOkskkkskk3n77bZx77rk46qijnOhjm0FmvaI0BOJil8+iJC5yMr9kmRWLQmaicYIVwwg0+gNI+fjFMoMfe/Tj2qoP5YoR8xnpFKQLxWQOlBCVFl+AEQkFy5bYrrh5s+cazU4thqHaUCes5oRwJlo+WEuQCtg+8lYkfpOlGAuzSGqKG7swjikXNRWwi7nM3YCPVeAZJCPGphCLkqrvtwpTyLvA0JsnpYGUWc0yAhK1EaYArOrYlfmb0SR/9zN37UKGKWbHuKZSCJYVMliBRxYjZKPrHe0GpwnWFqYvgmCW7zljVbn0vul0Go2MSyPFsDVurUHDhi25vzfn7hGxfN47qF66mjyvj4mi3is/rrj4rTxWs5QgvNIKPXq85psTp0UPIYUO3TrNPIqMBquwaDAo+C6CakuWiVI2d/NBVJDQc51tV3TvtyacZelDr5zN9YVfA62UQmCFI51gxM0XY3d58x4swjm2Xeb3+mCYu259eYe8dFjEyfdamPIgCa0p6xx5Xm0v1iUd0ozHTp2BUJbQCUqZ61ufpGR6xN5www2YNGkSpk2bhmg0img0ir333ht77bWXF6OkCNUYJSNGhV10RNMqtQHJaMomW4MW1NFMCDSUFue0sIgys1clfXCKYBhEcAunpFCcIY0ke8wToYrc6jSVzHVmNXW/bcvFeYgbJqu9l2mUzAoRbB9/6dbbkIZMo2R2k9UL78ZjR2SezGqWWYjjlafP9o12KTGiT31fvZsNpYGlLcsq75Wd+/J5zxwrWpIzyhDKfUl0s2HpN6zdzLVVzaSA5wQPFUGJZcB19YkIht4h1zvWaqRJYpQ00QqVJ5YnLSTHSTUmuL9zf4g3wvg6AV+dfw/+NfJo+gJdhk32mLEUCtetrmE6Lmj2RSxYy6fdZsf6kk25mCQZUyjzrjgtegj+ERwtCB2KFiWJ0pAd//WEBZm6XqbQKlQYbGqLoSdRPFGuf7J1V2XdSRCWbB194vlFHic/Pf7axT36c21R4OJhTXqwpKiEEU1EDY91Y8ekG6WsMDkUxmsK/LtKosk6TCv0ZGOCOadJLErMHlSr6deApJDMYbtyvQuFQnjxxRexePFiPPvss5g3bx5++eUXPP744wiF5AumBz2kMUoGLjjsoNVZlIiYC7lZnB61DRmLErGY5tNEsH1mz23LY/lIxoXVSWYp4q4zXuDS6TyWKECa/IF/RvaYf3esFY33l8+/MmxhKpmLmYF+7ZJNICssVLSmVkU7qaIBlQUJO+UqImPKVWhSgr3eVYTadPh7jJ6Z8v82VXCWuI/tcw2M11QqqFrPhFBWM3p8ZOY462bTKPjQU21VlfIpaRNxhjNhme18sTsQrDGsBUOWWU8x652vfVMiFl+lPjGR4b1idjiKPutCCw3bfpZYcyC4/KYFeUiynnGXcYygqORJy9c+TgD0KSepqGPo5LMoyZIOqbsZ0fO+vtnaw66bVLxShg5Fn/0cLE0V3o5aa1QFNZW1rZ6xbIlxLdT+K4tRYq1mMlctoz6ylnephV7C4+SDLrOvxFWykVC+mE3sxCsvhPlEzEOZkK0igMaJGCVZNkMZ75jdp4hvKnOblFkgKWtkrcE+JVqUsuNle0jmkMGQIUNw+OGH44ADDkDfvn3t7FObRWZ40IsYf85IG8BWpFBNDy7bgGSLc4OWEZTo/irFQAgMAJvVxWjNTIrpXGXBlQzIqt0KghLLYOiuZWhui5QyP/Odr2bONXJuGyY3IIlVQsY8cBpQFZqsRpLUQGqCq4p9ghKViVG/ARv3mUKSaEvmjipzFTHqG6WpE/snUx5Q6wCrqduklRjSaSRdCnkU4nKbWVdYRozeyPm/l3btzZ1Lsow7K+woud4xMUqiixiV9U5nUTIeL8FRk1F53dMoP+MGkjyXJIFzQ6NpcstOPIH4NnkRU126Y0ogEo6p8gdirGXm7zTh4rztp5W5P7TsfwAAG7hshrz2mrNE5GE+xXVCVXmgGo9R1+z5QFmgxCQJ6llnc/cF0/lNEdRaI7orF2I1yyDGWLbiEt6Bfsf0/t+gEHdJrqeSmEtx/zJnURLHDrNOMmvCL936IM6sF1QCKJUSHjJLLtt3MY031c96A7dN0VWNf69q31W8x4hPiFEKPY2moduniKyq7J5Qq4XwdHAcR0MnKGWOW5+cZL72VzKZxBNPPIH58+dj/fr1SAkr89tvv21b59oqKBO13vVOvnCKmgqqjoMsc4roFlCPAKJo2iAzGibK3U+ulc8db4uWIEBsQPUxDUFBGVHvCyIExgWFXfQ4ToK/T7bAsXtVKpmGzy8sbAxPoKuPxDS2tEsvDMQvTddJsg7yG1AQZWl5cUaZAKQkjILfaFVoUn7Rqgt1XPPrOXMJ+LFGa0DlGzsTIwcfQgaSMzWHCvH91rveNR2z84ArbilumBIBlGIE2T7XaUHDd5xgikurutxS7jC6tpvPsf1oZL61PnMWrT1n+7ktDmRUCWkFQYkWVHhBiRPABMGIilHS/H74O/dAcu1Kw/PNN/M0ud+NBbWqb35GRZcmmirJXXQWJdJ6TjcmtYZnBKW0MX/SuKUGJd2av4XA7K6obkRl5g8fPSc21zaCL5Qg9AGaMEcIpjAjqGXGNeEqmoAGH3L58jLxQ7QlWU1QyfQ1c0WCGfMqzL2qRYlaa1Rc72JErSjZeqZf99i9OL9FqR5BlKFRRzMl7BP0c9HreT6Iewzb1oby9kBiHQCgIRhCikmvzu6FMX8oy0+YnZO6pFBcwqpOQKLJ1Tjd3LdMoXDebTOIdumci+kCXw/cFd4VT9W/mHtO9r3KEpwQ8W0paIaup7yCi9qn8sUo5UDNsVothPMjs/CX0GR8XPtAtg9pTWPmUOb61icpmbYonXvuuTj33HORTCYxcuRIjBkzhvvngYbRHBUl+Xyud7eHdssei9mx5AVnjSeYuInUazntR312AzJ2C5ILYLnj9RUdycX5hy3t8O1PQSysq8z+tiXI16hRLTgrddFjBSUDDWiC+W2LmPabOdfIuJmI75h9T40KG1Aj8V51FiWFtK/i30ZWLJmlSpYxkWKK1VxFjDd2uU+72tg1MveL98s2dlXXP6P2KAZDVixXb+U1vo5TJBBB5I2E653MoqTqmhk3iFESLUoywZYFax1btS0nuG+NK2yWhOudLD23vo4REaOUaU9XIJZKSS6k0WbIr3nr8+yxLog8z2Nybj66k8yhRCkkC1bPrHVUVk/23vqNW7k+VEZz7+LTlbVMt/g5UR/XW1v+ExiS64NEKZCWMIWcy61QooKrk6TJ9ynVGCGRiWfn4d+Do/GLrwOW+joYnhefS5ZNj4pNVBGU2HVd5vomi42k1scYYVGq01h3P8JqJq4J7POz/dQ0U2nQ9cpgiQDI0GRLWrCJiuJE/bgE4+4vd8On9wnK86GOWcPf9Q/AjLJT8bOPzxAtS5LBglJKJaHxe3MzfXZv4saObi82/naiopTbE9gYJYQATcMGX45305Defi1KL7zwAv72t79h5syZTvSnTWNEJInP6gKkKTMNCKm7cwPxT+F98HGgL3ZIrs/+JksPLmPKZAUq6xBEBzS5i2RM8VSRMVWfcp32nNEyfzlwBK6O7IOD49/h0fp/AABq/WHO3Y2quK1jClnmIUWcEM81I56WCACEL7LM8sNqIxu0gKGUXI8gQog1X09v7ByDLwnIZzeVBgNLRBw++GFcxFHVHYbS8lKo04KIppu0efrg4/yMhcgA8NaWENqnc/V8jO6nNnbZc4l1m9JNNzS30XSukbNs+bNWWGnNFknWvSQx71nFBQtZUDULyqVCvC4GP8LNYyMrDGr8M+baUbdyUqUIEkR5dl+Xnkitb47r4ZI5iBYl8H8bXQfo44wyEoPfWFDSAkGkE80CHZl2XONc2epWrUeHYU1Cu5j4JV9dVnWLkvGx+HdKdDnKWAGFOKaMRZ2998taHzrU1CMj4kRCOfZgyaYGjM3cL6znRl+yWstlAWuqp6Ih0xmZtUGF2W8a++nseM0wojKrMAuZ9pxaO7ZoUUwqOwfT4j/hxfpnATSt38Hm9TspEVRk9M2mB48xe4k478k5qUmekdmLKRdxPi6KVq6pKGXEfjbAjwhot0YxoZU8ljYHdlyzfV5X0RHtsVFHJxlPIxBsnhNsOnGx3ELa+B3n3qt+jLNeAUbhDOL1Mg8BSmlJeSiwngAxBFBisE81udcZ09BbtIzHa11zModtyM37MjSS9f5aG0z3PBQKYdCgQU70pc3jjp51AGihRaZ5+1+gH7719+C0PvpFRI0pkzE2LGOW0UZQzHlK4pfM0df4ZzZi7NjFWGeBYTZ5to6QTgCiGAvoXe9EJJPGz5i5X+yveAzwgoCKVYB91zJtP2VtkWW9M4pREsdLgsucRm0ANPMivqe3/Pp1oY6x+pgrcmd8Ll+mnabr9Zo1wMgvOwfq/SehGW7ObB0ldk7K3Gykyguiz3VaEIeWHI+HQ5Pwoy+XeCBOxAqIbCsVX5YG76oRN4hHYsdwnHM1JAoJwoABIHzva1ZtgBFe9+UsEazrnSazKFEucuJ9THa2zO+6WClGOONc/9g1sD7G1TaTCTRsdxrr9RqaQmOUuOtY4ShJ/E7EMfHrJL+er1mzNXtsNiDfJxQi5xVlakoZSvBJwGeoTEgR41mWMj8t2aeMkh6xXh7s+i0TVOTMLqFIIN5vo8E8baIhDhF63WH3ZiXXOwWLUqFK0zpiDTeiJ7Yri/n8rX3OGZRzISYsSknGS52dE0uZREoAsLB3bo+T7ZOi610GGTdRcUxQMaCiPona/5PwCfNKr9Dj9ylRGFPb/ykvg8xenGTmR2m60dAC1wpzOZgXlC688ELcc889SkFxHnj0CDa9M3IR0/hFJMBICD81M0lsPQfRNS8lMILsMbkBCWZwlqk3cmmIa+IEY+lTixhtFci0zS0mGmsi1sDGCH3bN8dI6cAxGbykxDEsfr3gkmAKYyaE97q414DssUxQoQIdt2l8jYUMWJM8x4xLiobywrDg+iHEKIkQ3Rj4GCWaPkeDEFoA4LzobJwbmY0rwvtkf6M2WV19JgmzTQnZ5l3v1JQHMrcEyqJkdK/Yrk4DSvib8wJvEO8FBuJPkf1o1wli3meeM3edwDAx59i1JDPHKVdSmeud3G2Smfcp4zH2dRXzB+d6xwpDoAujSpI5aGxh1IwAJcQwaVRKclaTWlOPZD2T1pqyZPO34aOXavHLlzF881ad8fVpgIrBlJZF4IQgY4GI1YRvCzI100TrFPO9for5DX8Xv3+d0VqjieOF6QuhZdbPNUKI0HimsCEbS2u8T+nqKJFruJjMQc+8sr/x6zftSqxa24xSKrCQrW0ytzCWNtUGpXhin5NPACTSN+6nTMiuy1OfSmZ5kQnZWxn3eVnx4Wy7CeN5Uy244acMhBEj+uwz8zxV81gV9m664KyMF+AFeSMlZiPleqdzrzOmIXuufFnvStMxQXneei1Kpl3vPvzwQ7zzzjt44403MGLECASFqtzz5s2zrXNtFdSgbDqX+9vPCEqZQd7AWZQERlkywajFmTeNarzPskEyB3GhYqnItOf53KG4xURcPDnXN2ZxEjZ5bvKLWlOmo7WRKMrTuUKPALC2rAN6Y5OufwCwLVqKTG4J2SJGaei3ahEYoZ4xyScMFrkMyMVRopUycqNIMYGVIh1Z2lUq+YcoeK3TyvBsaByOb/wy+xu7gIrxbdR4kSVE0CU6aMYyrRJ90ltwb2gqToh/mX3OFPG+0oIArso8Zd4T+64bGXcYMe22PMGK8XeltJEUkyB3vYPhOZGxaeRc+TIWJSLrnaDQSUmUJ1ScycoO3dA/+StEsP3QWO2vkPWOTaCgcfWOhJgj1irE1vvJut4J84RVojDt/vbvj9Epl+SKtPaICRg0phhtY10aP38eQ0UX5nsRrnLZv43aRZq2YhEWpaqSduie3tbUD8YdR5ommHQR57//Bq0MQwV3JnYNT2q0p4TqeBVdk0LpXPadrIs40V9xTtJMIQBivBopSNj1W688UJuTqgkojNpKaOK3M1aAqu7FlKBEebHoatQx+4uMZ9BZlCRKAHHPKqQ+lLx8QhPiTDInzvVOIqhI36tmvIZneCqZAChayij64rsw2sNYBRjltikWK9bTN37mfN4dESSM35fxJ2jRMC0oVVZW4uCDD3aiL9sNZLEC7LkgX5kVAM8Aq8coqQlNCfg4pxojf1rR3M/Tp7VYnFXAIB6HW0yYhdmPNH5r3wWdUZX3uRb2Hoz+WAZAbzVi90rxPgDY0KkTkGgSlEQBQGUDYp8F4BeoGhhblBoI3299jBKxUEkEZSOLkvjUMn9vFhRjoXNRNEidzQoz+oWdbVdtY+d9v3OL8/uBAbgmMgPViOC4+FeGfdQnczB+Zv79pw014NwGBGPNu/5Z1BgmLlCdGSNUW6oKEplmmXfpaXpGro6SxEJAMUUiTc4FhlUkIIwKxPB8cAy/pgVy60BtAsiqGyRZ7/QFVBkhKhDK9jvneicIVkRiiMYtNUCX5jgk0QpDpR9O63NLACCLW6eFtqWud+yfVHHNVBopTcPP3ftiOBMHQrmlyecEf8z+/XhoIrTGNF4LDMOw1HrsklyOfwRHYU78i+Z2jYs2Z86xx+QYFwoyR5mXYMR8UoWmxb+l+5TBmsRayti5qVd80HOCrG1GrkE5UMKr3KJDC1S6gHwDUDWpZJYimesft4YbWJTWaaXomq7V9V38WxZeQHqwEFaNH7r2x1SsaLqXmZ/mUtsbfz/W/bwh66XDj0lZLC0LWhj3GY45KqmU3sqag1wZbKwoNRKUAkgbzslWKCeZF5Tmzp3rRD+2DzRPbJlFif17o8ZnfwOEOgqKWe/SGpBOGy/I4sDnBCUDl4bCNiCJBrz5ndQTJmIAWNOhM8Yk9ILSF4NHoRcWZ/9e1akb0LgMAPBd3yHolfox2wFdkUoBYUZDqbqIqKYHp+pjcC6GZMyJnpkw6mcK/MKpVEdJUetGbea8dtF482WFGdmGLXuv1KZXy21AAVRrUV0fqRTobHC57BkBzXBe8a53khglxfTgVIwSFwehkP1Q7tPOX5cSv1nz68gwRpQrqawvum/H/Mm7RuXaey8wABdHDsAmrSTLXANAYyL35b9dX4+dsmc0sNvt8i0xdM+eEl6ASdc79voNH3+P9s1hYcrZNgVLtk/TX54irD7QB5pkEWf6ubG8Pdpvyfko1oYiQLP3QVW0DBXNyXiSKQ3zpuyDl3fZG7O23Z29nh273/Ybih6JH5vJqbtPsYLLVi2CA0vncA8+JLWBux5EW6rJHESLu4/xtsiMzRQxXuUKCp/h7yJN0qLUDF2GL01tTqYIdztxD8goExb5umJCcrWuf6JVQGb5oITBGsKiFBd4BKP+iu0mifVMXB/Z/eHa8HRMSSzDk6HxeLo5dbbOu0DG43D0aYHSCFsDJTmvESJhg9gW58Gi0e+1jsskbGxR4t6r4ErNXilTXhi5carE0soUJHplODsP8wvZhsqDVigpGXNweZBIJPDWW2/h4YcfxrZtTeb83377DTU1NXnu9ADILUrs3x8F+uGm8J44Pnpk9rd6Iq6l6V5qQaA1eglh4LNxUZnAPB1DxdCgFkcdU0q5RTRfx6UlF6whFCNWHw6T17FBm/q4DTlEplCmgWRBBTom4MO5kdl4KLQzl/CAs7ZIxoTaBihkEzKwKD0amsT3V9EvWoV5oeJZ6girmcwvWjYn2D7XGgTJ6vorcUEhY5SEjcpo7rDPyMfU0VY+GX0x/XEGYhyEYX8V3Xz478qPF64+S3NfOPdC1iVO2L5Vvx1Xj01w9dvkKwU0jbPOLfthleEzrqpuxG/bGrN/L1iTi/nRxRyxFiIF1zv2+kSdcRySOHhlViBDixLr2sMKTWnhezF/rK3MJfKIBUOcxbyBea6VlV1zv/tD+OfO0wDwY5pdw/Vz0phJ4tM9026zAABN4xi0JHzCXJdZBXKgXel82Xo1GXpN1+Sf9xk6Rudk63nWokQISj6kyfVM1ZIsK5K7Y/n52KHsImzWmFTXkmQOpOJHo+OwqMQKXNIfyZ5BxUOKCjL2K7Pr278CO+Co0uPwm6/C8F6RpsjjUOu++B0zSXG+8PfM/s5aRD4eMoagoU5fjDPNoCGbeER4roJilPhjIwVETMGipCGfRSl3lktYxe3F+eOFM8etMZmDaYvS8uXLse+++2LFihWIxWKYMWMGysvLceutt6KhoQEPPfSQE/1sE9AMLEr5FoI7wrtz52MFxCjJFlGOQdN8XFyUUR9lKUxV3bd414+m9tjFRHQpVHUzorRITUxFrgchxg3lb8HRmJJYhpeDIzEt2VRIVrQAKWtbCGYkBQ3PhsYBAJ6uez77O5V2VTXrnqjRMwpwBoATo0egTgvhA39/XBp7l6FjnISApaFbRFkXGMIKxm++dIyNCsMiSwTCLs5isgGj62UxSjxTln9zimvGG5BUA6mjD8NzYrHiXNvG3yip0XNCPnaNBZfM9+NrZuSOfWmxPoYaU0rFUvFuVbl+fBXuiP6JNbrraxpTWLGmDtMz7bIqe5nrnYFFSSxQSxZ5FYQhSnvMF8cGfAYmJc71LsXTaKrTltL1RRTeN5dXoFOzO/JX/YZhTHoBAP47VpWUI+Uz+JaSeU8J1jIh38iVuUEyJ4xif4zapcZYHP68+xRlSc7QMTonau+NsoKyLqgsk98kKFH7FA/aK4DeP7dpEWzT5JYaFSuvzLujlkisECf2Jnl6cFqRworN7P6QebeymEtaGUsLoGJij/1LTsKo1Br0TW3JWufYb8mu7arrqbifsf3ks97pLUopob+ysUMpD1IwVoZTccsyrxW5Rcl4rVYTlAqyy7QImO75ueeeiwkTJqCqqgrRaE67cfDBB2P+/Pm2dq6tQtVFzchMLBMoxAWRpElWPBc0dXmul2k7ZNYOw/TggnaOalfmKkH5tC/p2Z+7LsK42Z0RPQRjy87DVkZTJ3O9U7UGUi4KVBwRlcVMpMnV2xGuY+mz77NKK8E7gUG6LHUk46q4iCY44YQRTBk624R6Kmw71HPJ3j/v355bnKmxZ+TmCWRcJfIzZU3X6s/xaVeNhbSmvtMMC22pM97cVJ5RZi2VFUhsNLAysOOLdS8UhWd5zCVDn44rescAALukSURBVNCaUkUvGzVjhj4NcO5MCSbORxR8NtUzUomQHtwoc+uW75fm/qBquWU60Yyl3XrnfhZc6USLUl0ojC/6DTe8PgUNm0tz2vRNZRXcORYNwdy8ijHHLJNHxZaQqYglygvVuMkMxL2JhWosKzVGyH1KQSjP0MmekygZjCxUlEXJjzSZEU30NUoRShlK0OLuJee9eiZKSlG6TYvggsgBuDiyP3c9pcRLCMK7SjKFtE5Qys3JnMsv3XfqfckElYQw3qt8JXg/MJBUSMnWU1qhJyhPWPdpzqKkT5Ali81T5bGS8BnWOIoRrneixZJShurKTZgUsrmx3hpNSc0wLSh9+OGHuOKKKxAK8RJk3759sXr1ats6tr1AlgraiOnZwMQtlaGROydNncmQkW1APoNqrJS2W9UsrVtEDTSKDQIjxoJiyuRmabqfz4TGAgDe9zcJUCnNJ2hKVC1K4iJuvDiz74y9g0y7Ki5OxLeTadvY9yk+j9Hvss2Jeq/UWOBSozOJLPRZmlgaxn0R26YsSlRqXX4c0PSpTVbXnlHWO7BunvTGLlMeUMxLTDPWAhZi0aGC6MVnyNVRMma6yYrrBu2S/SQEY6Pse03HYt+Z8ZbIrVlsxioAWLQhV5C4mqmVtvGLRZjXeQaWPvF/3PW6bJnNaDAoKZBBTbiEuSd3Uxp6N5NTzrsJD8w81ridSBQNwdyY/nLgyOzxr135ei4Uw8J/M+N5IBVAC2C2jQQldtwGwRcUlVsFCMFBGC9GghJVtNmMRYm0FDZfR9Ux4u3T+SxKLH3KomS8ZsuEQdoNnhZyxcQeT4UmYG5oInc95XkgU7xQQl8KvOudkVcFZbUC5K5/KookynITJ+aQHcrgOgMXcXkJEJotJ+lr+WNp5ckcaN6NBftcYeQUzlRhdKPnao3ikmlBKZVKIZnUV1JetWoVysvLbenU9gQ9UyzfgFitQVk6xp2Tu97lZ7KaXBqMNHW0Fonvm2Z4LNI0YrDTrIuMxKJk9E6M+iNj/P8cnoZToodiTskRzPXGC6WsXZlZmmNG2FTG7CahWHBWpkXK9YW/h9OQiSmTs/0yZlz1yRSYe9jNhRgL7OJcw1iURHcYqxrQWq6YrfH9ogsk29/CmEK9pq5RYDaoe7k5qdGWMlbIpdz6qHVCFg8hWrTYKzkGUNMzLKzVTBPoUC4/Yn8owZqyKPEBzjRTxsbrfD7/W47+sq05ZdJ7K+qzx9899R/ENm3FJ3Ou4/tLxBst6Tkg1y9/gGcKmT9iTF/S0DhB6YtBTYIP5ybKXFAXjChbWSlBVUXQ5CxNUuWFeSE/A3bcBtL8FbJ2WVAKj7hopsu2Re1T6soD9sqEwbyOa7xwlIEP9NosV14Y7yeURYlSCMm8UXTrGRkvTCjUSJdy/t1RY1JUkLAWJS4TZnPb3DOaSO1OradUTa1tTNkOVQ8Bak42WbmN3zk7F7o2p+hXjb2Sjl3B9T1lcI6lLdan5Ns1piGbkxu0XI0pP7MI3huaAgC4NbS78ZhuhZKSaUFpxowZuPvuu7N/a5qGmpoaXH311Zg5c6adfWt7aB4gMu21qlBgBHnNFmMaCYFZjoApUW10vaCpY3sos7zwMUq0UADoXe+ojElNi7MxfZEpZVGvhfBycBTnbicXFNSEE15TZ6zRY5+NilGSaXtk7hnsW1azKBlvCKpWCepdxBVc72Rxc1JrJMFU89/b+B0VYmUVz2UZJiKZg0xBIB5T37KGe2e533/y5wL6Zf1lQc4J8Jpd3vVOb1HiXe+sxyhRlknOIlKA5WNB+1yANgBUbKvOHrOBzZ8MHgMjVJW2y9FhFpctJTmmYGtpOZdAgaX/0Q7jssd1kSjHFNx1yEkAeKZsdadc8oWURACRWUWMmE2AZxB5N0o6mQMLOr6OFtSM2mVjQsV2VZUXshhOo35IXe+Iea8SD9IosTZQQq668iL/3k8pgUTXO1nMJTknCdcoSuDmxoQmUcYKChp2D+RcaA1iI/XCm4zHyC+osXvDO4GB+N7XFU8Gx3PJR7gsporF39PQoKWNBcC1vpwBIaOIZvsqrqeyMUnRT8G44CwVSyvjMWThDey33KTlLOlsxsQbwtNwRMmxuC88RRgTzRal7UFQuvPOO/Hee+9h+PDhaGhowDHHHIN+/fph9erVuOWWW5zoY5sDxSCKfxsFyQLAnaFdUYMg7muW3DPgJo4isy9uWiVpvaBEmajVzdK0ts2oroGqRUm2iMhiqYwgq3vBbaySWS5zaTACxQjKtD2yxBqcEMZYlOqI1J1U3Q7dxk4wFlRNLdqiJGZMpDcdFtR3ZemMTK41vF7uKkKNSdnmqGeYZOnBZa4iLFhGtob5XqyF95bwnngmOBYHlpxoQlAxfg6RYTGqo8RlOGJoaBDHpIwpY68jLEqsqyHh2iQLHJe5rWwqr8y1zTBDGUFHXEPWVnTMtcu48dVEci7PafBxj6yyhpuffr9hMgfWer6mQ1fmd7oWjDxukLAWEe+PtrIK415iKeTWZKM1kflNVHyRTKw4d0yu5/T6z0OmPKAE0EzblNJJbEus2Ub1k3p+yrojcxGn+iJTxsa59cm4PUpwkSUCMbLCZ373ce6puesya5CqMlJqUSKy3okxwnuU/QEXRmcJ67nxvqajL4kJp/apjLu9ejKF/HtR5thIiOKy3hGJwLS0PGMj2wOR//hTeB/8NTgRn/r75O7XfHg7MBj1WiivQqW1wHTWu549e+Lrr7/GCy+8gC+//BKpVAonn3wyjj32WC65gwcaMs0RZwIlmPIbw3vhxsg03e/UAiPT3ouCT4mBRYlyS9MxhYraHlk8DqDfWKkFUCYAyRZbI8gqqZPuU5LFjmLy2DsoLam4YZEuYoKQybbNao+o+hhUXBDf3zRJX6zjYdQWy/Rz7jAabdHh3z/NvLAM3w3MfKAYLHmSCPobG1qUGNqy9OAy32+KmWjgCi7n2PCtWhTnRQ8EAJza+GmOpmLWO50GlHkDvDuWXrPLJw5JK88JSiCiGLlGwvVOZHxJNx+JkMvOiW2hKFZ26oY7DjkZ++I+w+s/2mEcjkh/r/td7P/Sbn2A2C+6fkL0bzRAQziMzJIrMptUTBcgaOIJaxH1/shaOIIELBMoZEkQROgEJUnKfvYNUG5mlLWFjJ9UdCUWP5eR653MRVxlPRH/plzvUpqm575196qt07L9zOgZRcQJhYnebZOdh5Q1UuOUP0Zru6jcSiGn0ed5AbV3LLMuZsB6YIjFtVnIvHZY8EomP64LT8PMxGI8GZpAtGu8hqWEdZqaB6LrXaaf7HpaL1HokZY64TKR/sPhyZBBpsRqTTAlKMXjcQwdOhSvvfYa5syZgzlz5jjVrzYNVYsS6XpHCFAyrYASswugGmG0Ry4AGhDM+EIhPRlNtl2K2TWaPLqsd8SCKNMUiotNPsi14jSzy/WTFZQMUssC/LNRbg8yv2xZP3mfeUYbrvH1poz6K7doGX9/qpAu+1y0653EzUhkdgm/8Dh86NTuGiCd5uYENb5lc0LdHdbIomRdeUDNHda9geqTPBOk8T2iRckoNohXiuRo+ASWUraxqjAsXIwSUddF+u4UY6RYQWlZpx548KRm4bo6dz0ntAWCWSFGNyc09h7juZv0+w2ZXRZ6SxnF7EqYUmLdoRQxVDY8XXY2Yt7LXOSMoAk7AK2VV1t3VdzSEhJmlxq74vPzwpZ+reuS5utGqno+8PfQyoNToofi/vpXcHr0EO53o/7J6eeONdBzkmJkOdc7QsiVMv7CM7LrTpD1b20eC6oZC2W8gFgf0qgvLLjscJLkPDIehwX3nTQf7g3vinvDu5L9oDImylzfxL4YjQ2+3p9x8XKRjt6ixApq5vgqozHS5l3vgsEgYrFYth6QB5PI1lGiB7vqAmsEimFQNf2noOHUksOwTivDsdGjuX5lUJjrHR0kazTZvvV15/5WddHiJzu92BhBliVIVVPIvv9GcnEmBCXFzYESGgBwLg1spqk6InUnteiqum+JSS8y+NnfGYt9nfGWfxAnKMmSOcitrMaMaPYdS9xMKYZJNUZKF49jkPVOtrGqaMKbruPpXxOegX8ERuLNwJC81yuPHemc1DPSFKPdxGyxfTG/JrDHW5mgaqrau762GUuDnrssHSrbGwtVayTFbIta/nyo12hdpYwpod4/nyjCuP9UohlVIVv8W01QMu6vTMimrJFKgpJ0Thj3RcZsG9HcO/GT0C4tHFD9lNUbejk4Cn3LL8f/BUcYXp/Q1OakLM6mkVDosVBxvQPo59c/Y66nbOa0LD3huXgaOcgsOtR7op6RsyhJXO9U6eeLqZPxfbJ1mlZu8jSSBkInFRMt9p/zahL6LRtXRqAsZa0Npm1hZ599Nm655RYkEvoB7iEP0plAvhysbEC65hXv5eoiCRvQO4FBGFF+Ef4THJr9XSWAX9Z3/WQz3iimlZ6K68PT8EhoUkHtUvUpCtV85OiYF0B5axGz8DM30a53avRFtw1WUxdmakVRKhwVJlakT8cX8JhadiaOKj2O1F6nBPaJcscR6VOacf76HMg6SqCtEnotnn78swyG3FXDeDOVbawpaLg/PAWnlRyGOMFIU+9EpjwQvxc7Xoy0kVwxakEAUJ2TtCVZw+XhffGRvy8eD+1keAeX/l2ysatqtllmiLSGEs8sVx7k18qL2NBsKfxXYBh5jfqcZAUlY/eapGY8b2SxidRak69vIkQLJL02S5hdFdc75W9HzXuBviQhAgDMDU4Q2jXuu9TzgVhDM/eLGUv5PUbMzkqt0/S3U7Eosf2iYm+lHgLCt2Bd78REH2I/VF0KpS6/kjGeQSNRv61Q936Z5U/sn7zcAg/qG6dAu+hlQGXZFemI+5RZyy4Lo3HQGuUl0zFKn376KebPn48333wTo0aNQmlpKXd+3rx5tnWurYJaqHXnTAtKxu1YXUT4AFKZtoXaAASmkNB0fuPvgW/8PXT0VbU4qvSNIHN9k7kRUNdRmjp2MSuEKUsbLDxGbRtp6kRQjJRcAGYZrvzvWDWbn+qmRwWlU6Bd73jINmCjYGC6PoUaQ6mnb268qgsqau/YyH2LYoo0SbvSAoVChs1HwjvjkfDO3PVsJkpWUNJrQHOQbd58yn7jYGYWnNCjKLxT6ykA/CFyMB5seBl/jOzH/b5X6WnomarGEn9nvl2GjGwvoBgrSmingstlTBk17wC6QKYRNKF1WvGmRp8UlBT3NZk7Kk9fLkQs9HcFG9JLrZNS5QUhqJEWTzLBSlqyT9BjlxOaFThYylNCVHxRloQUeNe7UFq/T+nXGuO+y5WxxooB0vWOsyjRHgJW6WehmB1VyuMIadSDjEdJpg32XbPeHWaUwRTPorRP5VE2tBaYFpQqKytx6KGHOtGXto+s610OqhpoFRQyiWVJDIx+j0uYB26yCxp6XrNsbnGmBRUelEZPTfOR/z2I56QxSgrJHFQtdapMGXvXJ/6+hv2n+iuPpYHhdXx6WmNwQa0arQGVMf7UM9MWJePnUo0HURHUeN9vOkiWspqJ71UWZ2MEvuI57Q5BZWzU+Z4bMGBU0L8PabLium5NIOuOGD/jBl8ZTo0eimqEOWFf1copszLT7rA5qLvDwvCcOCdfCo3Bv4NDuZotALDGV4E1vgquFp7ckilZzwmFC1WGgRIYVeMxxHP5GCDWJVh2r0wrL46dsyMH4r6Gf+KsyIGG14ips1kUojxgj+8P7YLdE7/gb8ExuL3hdePnklioVSz51PygLMmaYrtIp8nxyr6/37Ry9Giu+cMiRqx1YtyazPOAZd6fDY3DQYkf8FJwFPFcGYuS3BtHVRlM8RsNRF081XkvUwY3Kij0yDEpdFfVC8QoRilGeHdokO8TLFRdyY3u326SOQDA3LlznejHdoU0MRDTMM8wce0Sm6l8A8wPrpCfpI6ELBUye6WKGwUL2cbGLqKqlh8jSNODEwuibAOmsgM2EEyKzKJDuU+Jli92A/qfvy/mRA/HD76uoEBWhS8gtTwFOnBcrjCgrqMYQRYqWYJE4V01ViFzHcuIsb7fqhbilGxOmFQeyLXntABKXZf5ZlTiDlF7LYsHJOMmJN97XjPTtF98UY6+4tiRrXWs1piyKFGphFW/q9FaIwpJVP9k5+SCYq7PnHshsVbHCIFRZHZVlRdUWukMdMl5JEw0dZ1ojXw+NBbPB3fkNPOUEKHM7EqYUrbtayJ7wwiqY4LyCuBrChEWJeLd6VzUiOQATfRzoJIOnRE9BLc1vIZzIwdin8SS7O+cskHY7ylrqKiEY8fDO4FB2L30dCz3VWZ/E5l4vu/0mGSv5a0txnOaBV9wlrUoFUafT1CTn82mxou6NdTY9Y6N/+R5B1XvDv65zCryjcZBa3S9K0jESyQSeOutt/Dwww9j27YmrcNvv/2GmpqaPHd6EKGqbTLblqrlQzYpM6BdGmj6XLtCs5SmmoJM21KIWd4IytpjRU0hVQ38S3+v7HEhMUoyCwlno9A0/F9wBH5hipSKUBEsRaaY8tsvxPVORZsq+r6zDBPrc02B0izLmBed8sLg/bMbazWzGZlxaWBhJaZOdU4aKxma4GeyT2WyI8msooW4iphVkMhdn9SYbZZ+I5ERjgWlCJCOXUmx6nxQt17TaxJlLWLv54oLE3FMcldmeuzk+5ZxkSkjFYW0kGs4P4R3bUeCE749k/uUovWUjmVi7ifGkZhNjW5Xba5R6/OHgf6YXHY2Pgv04e6WxSjRQjYv5PqFWbrQ3w01zBoqpmBXUYrIrIEqcVgxrkC7zBqZvy/iORWLEm+NVFvP9Ps/mHNNf70eHIaVWgWeD44h10lRaaj6XGb3qWxbrVBQMm1RWr58Ofbdd1+sWLECsVgMM2bMQHl5OW699VY0NDTgoYcecqKfbQp2Wnuoe2WDWKZlN2yXWbTFzGUsKIuWPkg3v4aHo08wJXLfb3NMmYxRVXUVoVzv2A3twdBkRNIJvBkcggGpTblrJO9V1dwuam7zgd506OvMLpSUMCjTXqvGKlCFdCn6spop1LsQnzAzrlhBaSsnKBVq+TBnAaW/g4zZ5bXXLPPMBlVnrBIUgyFqr1WDj80LSsbMgyweQ8bsc7FkJpM5yAvp2rNmi5BnvTP+rjIrWAYxzXhtMqO0k1mgM7guPA0XxN7HpZH98X+1j+e9V+Y2qSKYUQH0MsWXcoyUSSuvqvWWTuZgPD4pBQkgWpGM56f4FCpzkl0naFdaev/l5455LplaD2VKU34vzr+2sv2NSZLz8MKssTUQoGMCKVDfS4zSUl13MsLmNi2CsWXnAZqG6fEfDek1UVDb180oSMRrMu+rFcpJ5i1K5557LiZMmICqqiquwOzBBx+M+fPn29q5toZMWnUZU6pi4aFAmd5l9TFU3J8ok62qi5jOlUmhGjjVruoGRLkjUe5ahbi5yFw1KM1boxbALZE9scDfUznRgCpTGEAKZqAqAPKpkM0J2VQckwbZd6Xps8xuHWFRor6XKuMnZ2yajjdpuSQ2G5lj3dhRrAFmltlWeUY9TdnYyQlKRgVn+Vpg6hYlK0I2zTzQa5347jhLipJFiWCEFN+rWS8A1e8li2+jBFpxvmXQyCUfoZ+RspSpuojfG94VA8v/iO/8YrmHHFRjlKjxzvWXXX9VY2kVhWyV70ruf9K6cGaFQeO1WGP+K95PKQUAtUQHLCilVQp0bS+zcS0s9EV9qTFJjx0VxSy3R0PiesfcrmqNbFSwRxTiIi3SJ8sRZFKFK/JuqlZeq2t4a4Jpi9KHH36Ijz76CKEQr83t27cvVq9ebVvH2jJkg1LOMBbaLg9SU0ea+40FgEJdGmSaWiNQi7MI0vTPPFeM0O7I3HwsB5AqxEMou95JGIBA2oqgpOa+JYvlMoLM35zqi9ylkS1Imt/1TlZwlqIhd69saq/KV4JzIrMRhx9VTKY2mfZadWO1sgGpu97xCBoI2ey7LvTbcQy9SSsvV8ZAMidlzDb7l0qMUl53L0P6hTOCsusppkSWMlnFQkB5BaQhWA8kz6/KACUN3I4KsSQrKfS48UInDJK52VLtmRciVOekMfNKPSMljMhc1MS22L84F3EFq5ncHRPMOWMXQfOCksjX5KAfu8b04wr101ivADbbpnpsotjv3C8xs653MuUFt0/Re7YRCnNHpftpfp9qtii1QnnJtKCUSqWQTOpz369atQrl5eW2dKrtw3ihlgVkqoAa4DL/Xdl1uXZp9ykWqkyZSqXsFHLmTnoDUWNe0gA2aiXolK7DF/7ehvRkmbuUFxE2w5ZCIT9yM5FkLpNtwGyRWRVQKdFVNatpybfIgK5jJPZFVduVA+V6R6Uz1blKMI3Jnp/rJ3PuudA4AEDnVC42s9CxIxt/RuCYY0XLh0ygCKb1Y0fMPkXRl6dCNsfEs6DiDADaoiH7do2SxCL5+ltoxsR8kLveqVlFqKyHtEBBPxfdNwnDpvDM7BUFMYUK75jepyT7hG7eqwmKxvRV+0utuzlQ3gHUt9MgznXKssjPY5U4LLb3tNWMP6m67uWDPEkF/Y7NKg+W+zrg2vB0bNGiBaWWl637KhYlSnmtqrSUWpSy15t/LulebFKwNisktySYdr2bMWMG7r777uzfmqahpqYGV199NWbOnGln39osKMYPML848+2qbdjcdRLm1agfhWXY4q9LEAICRZPegHjI6B9ScgIeD07AH6KHGNKTZZNTdzNitFgKwiB1jZzZpbXBZl3vCtEiUe+J1l7TKUkpGuL8YDeRhb6uWOjrgv8GBuuKMRqBZjbpbyfbboy+ZVyIn2HhhkVJltqeihtQEbLZbyf2iLdyqo0ds3FY1LhXZQrFX9hsVpQ7Upror0x7bzYRBwedxjoHOSNmTF+l9AO9nvOQKd7c8Hyg1kTqHcviIXn6amPH7F5Mu0qqtcsel6YbDWmkiHkn7y/dd5mHSO5uY+FRZoGi9oxCLEosSK8RcT0lrNGyPt8XnoqnQ+OVx7Yqv6USo6TKO1kRQGVFiGXtqlqZjbDdWpTuuusu7Lnnnhg+fDgaGhpwzDHH4KeffkKnTp3w/PPPO9HHtgPDGCX+2Ir2RVWgMKupo2vnqC2Uhbg0sNo9Vb9gyvUhCQ0/+LvhkugBZH9l2nbeoqOmAaVilFhwtRakmXbUNgcrMUrUmNRAv3+Vscq6B4h1j2TzgOpnXPNj99I/SFdbivmyw6XA6FuyFlIxoxPpU58b3s3tmhMi1N181Oa6keudzKJUCENPpcOnQFlNxHYpxQ8gxubkvlMtYY0k36tuvJlbQ1Ug3qlq5aZcmVXiX3hFFU1DnFOUsKEC1fWMmq9KgpKiu5eq8sKs652qVl6c908Gx+PE+Je4NbyHIQ0qRglpwfVOQQEKqGWEY0EpPjSBCDUOzQtKYuIW9lgck2w/Kbd2c8+of3dq666YgVYGH2Rjh4Ys612+68XkPCykPJYFz4ftKkapR48e+Prrr/HCCy/gyy+/RCqVwsknn4xjjz2WS+7ggYZTFiWqHdkGoLIBqWogaUuVmkDDt0Vdz9PnBCrmHpkrlzE9euMnmV2hDZ6hz88UsnTkVbONaYjmeiP3KRmo9ypCxfVBZayKiTQoTZW4GeoYNhMqKXVroBpjkzb4luxzyWrGyC1aJjcgQmMqd1ukaRiNnZREmKHnpEzILdxqZlyEUn+djGFhhdgaZr6xYO+XFVRWtYpYAWWBSwusjRhf+bG/DyYnV+CF4I7MNfnnrUxQkQlqVjwfZBnRSEFPJXV2AfEY6v1UuV5tnxTH7kWR/XF7eDes8VUY0qCsZpq0XY27jgVVR4kFq4BTZXxV14d80NJqgrUoKHBuuybXHVk4gsxDgJ2VZjk3WvGlNnZFy48RZPHNlFJKjP0ybWVlLlFRjrVUKAlK48aNw/z589G+fXtcd911uOiiizBnzhzMmTPH6f61Sahqz61sQNwkyskSBu2a2wBkhTFlQhfPFBsv9hRNTnurGEtjvuCsmvuSKrOt4nrHvhNWUCrUKmDWokSmFZY8P6WVUnrHkoVSpr23MidkQjZ1nVlmNyERlGSCChdLZdr1zvg7mGEK2a+RL75Nn0zBPLMpcxE0guqclI1dVtPNPmMd8icCKShGyDSLxEPV2kIx8SloOCl6BHqmt+Jrf0/j/kpc1FQEUNm6pwJlK69JpUyCsF4Xup7zqdbzM3mqY5JaT1PQkNZ8WKMZC0ni9aI7aCFWCZWahs8Fx+K0xk/xob+fsnJNVnzeDGSlAKT0uTGeXxhkYYeCIJ/QIqUpKGM5QUUSo5XvySjhMXN/vmP9ufwwel+t0fVOScRbtGgRamtrAQDXXnutV1jWIqQWJcWgciOomkWpRVRlcsuLsRnTl5l27cwmRKddzY/C3Jfofqq43kXSiexxDdQsSjLh5LngWADAl76eUEEhVgGVIrMUfvF15P626oKjAnssSvLnTHKCEi+sFjJ2VIJkZRpA8jrJM+YTlNhMUGK7qu/OSh0lVUFNpM+uPZ/7e2G9Vor3/f253TpGrGm8BVRtrbPieidCtk+wmtqEEOC/wVfGCUkAbb2VWSOp55KtuypIk2NXbd6rpHiWWpRIZpOHaStvAWuN2bEjfmsWqgIg1x67TxHfcaG/G4aVXYRDS44vzKJkMesdi0KEXCvuhTJLsmzsml0F+DGh5iFg1uWVrosnV16oulkbwejeVignqVmUdtxxR8yZMwdTp05FOp3G7bffjrKyMsNrr7rqKls72KaQzriI0RuQTJrP2zx3bH6hJttlLpFXjTamIfaBqlXC4hN/H+ye/BU1CCk/l0xTlw98QUseqkwR72aUP5YrhJygFFcuckd/u8dCE/GjvxO+9PcypCdCVbNLafFUfc8PLjkB3VPVOuaNoiEThqxYlJQFFbNzkPkmvjTde1kle7PMhLqrhvE9Yi8X+rph5+RKHZ33/P0xPrkarweG4U68lrufXROkbkY5WCo4K2EKZWsSS6WmufiiGFzdCD/CzYIi1V+ZoGIpmYME8nFo/G6o5DiNxPoiqwsnm5Os4GU29kBVAKOev4GwBqqmpC7EQ4B6xkw21Rj8ZDFWEdReqKIEUi4jQYxdfdY7YwZdxAZfmZSGCOrdFWZ9NP5Gym7wppNJ0P2V8W7slR8H+gIxBVIAUpCt5zwsud4Re7e8Xd5SZcXlNku/FUpKSoLSE088gauvvhqvvfYaNE3DG2+8gUBAf6umaZ6gpACnYpSUtdeE1SqhkJ1FtujI+k5mziGe8ezoQTg/9gEeCU3CMfEFzPWiqwiYvwtfnGWbvbKrCHNOJdMNVahU/l4plwYgqfnxbmBQXrq5e6hNR42xULX0fBAYQNDPgYpVSEtoqkAltkFs1844E9WNzYr2WjVjoowpvD4yDQ1aAPOCo7jfjyg5DlHEUcPUGdHTZ9rVpbZXE+iMwGn+mWNNuF8mUIjMQ8yg9taxJcfgyboXcFl0JiYmcsKiTHgmraEW/UqovUF1z6DWsXtCU7FHYiluD+/OM/Q2FKG0otCTpTim2m3QjNkWVogoxPNBfK9UKm4Wx0SPwTWx/+KqyN44pfHTXLuK66nZWFqq+LvYrqpFiW2DcoNnQY0d1bTjojCuQk/mvmz0u/i3FSWUuuKJv26Bvyf2KzkJK3zt89IT25L1kR87tEBjBCojpoy++L2sWM/bfDKHoUOH4oUXXgAA+Hw+zJ8/H126dHG0Y20RaSOLkiTOx4qbkWoyBZaGGGxvBNUNSNZ3ykeexW++ClzcnKUuHTe/OJq1CsiuoTV1NFOo8i4/9ffBVeG9scjfpcDF2RpUGQYVF7lCXI7YOwrRLKtA2R1Vcp0Yd2QGhWivVajRghIN2XU1WgRXR/bR36P5UWMo9FNCtqSfJhkWVWWHWa28iP8F+mFw+aWApmF8YhXTlnG78ixR9kFVyFfJ6vWzvzNGlV8IADg4/p3hvXqrmdpz2WbllTBl7PMvFVx4M5DVvWKhKqhQijcWXwV6YXZgju76Qlz6lFzvyBglHqpzQubemu96Vdc7K4oumTVQumdwezFdfNiQpmTcm1HGfh7ok5eWcbsFKL40g84KSBJKK1mx4jQ0aIyXhHnXO/1ztUZxScnJcdy4caiqqgIAXH311aTbnQc1qApDhZmp9ffqNGXERKTcNtSzCRnT1/XTQsVzVf9hs5luVN0IVDdAmStdFpqGv4R3wTuBQdIx4ZSgwoJenNPkIi5zeTILmQbWynMW4jYpnjMjKIm9s8o8UVC26CgqT8yCsnLKmFIrrneFWsqUnzJTuoG5gYpl0ffT+LmsMgQUUyhC5lKT7/pCMibK2lMBHSMkp39YyXG4JzQFzzTHYorgkzkw30Q2Jxybk4VYefNDHm9DPZc4J8x5d7BQdb2ja3vlfq8hUvSL9KhnUV3P45JvYQTV726XgsQHWlGn6iIOmCs4K83sa+OcMLy3FUpKppM5XHfddV4yh0KRJ0ZJlzLYQpCs6gRPQcNLze4294amGl6v4gMPiBug+UWUbJe4V64BNGfuFzUsFH31xVlBUCLuFd8d9fxmFyoR9HuVXEcx2wW4HFExZfLNwRwo5gVQd32zYlGSuW9R11lhymTKC6uWF5V2ZW6jVgQluTuqPUKueH8h384qF6DKxLMwu54WYo1Udf1Tgeq8F5//3cAgXB+ZgSRRaJrLpqqY2l02dlTjd4zaUp1r/D6lIORqakIxZRXRwI9QmSufYbuKghVleUlDw62h3QEA10Wmm6LXdL/xOdn6YL7OF3usRt9exZOa8kD8PV/WW6rwbhoaWStRWsZCYbwaWW9boZzkJXNwFWnuf83HaouNCiiGMp+bz5mRg3FNeG+s85Ubtqvu+21MQ0SSmLAUaIaFZmzMxkOoBt/K3FF4N8bcezLr0lCIRakQUIKtzCpRCDOggkJcD822W6h20JxFSSJkK7p0mHVpSMgSrChq781C3cprPMaUXGAIGqKriIzZNpumVzUuiIUswYoV8DQlgpoi82x0jdyiVIigmB+qTKEVtzTZmksz8XQ/VfYp6l5Vlz6V90i5WZopGsrCipAtVYYSdQTTAG4P7463AoPxtb9HXnqZe4zp89+Oj2/LQabcNUJhlmzzaw1JU7mYOn8cSMsFJUp4FOvSOeVymx1rrVBS8pI5FAGq8RhWNl1V5iUNDSnNh3WasZAE0JpgvbZHre9mhQhuY1EMPlbRALKQugoyx6oCWNyCpk5kIlVdOsxC1VWTeq9WhTYVc39ao10vVFCQoCS8f2sxSoVoChWECMJ9VcZsqloPVKDqU08J1irjhbKUaVB/r+ZHpXnB0k7lBQvqGbVmFVEGfG07c+upVMhW7Kf5ZzZe62T0zbqlyWJEaSGbfw6Zq5IRKCFCZ+0g525+UDFKIlTbpSy+KtfL6VPz3oeU5sNXAbXMrClYd71TeS7qXvmYdEbxJEtwQvfFXC28uBB3qvxeLSiFMtdbESiLhRafzGH16tW49NJL8cYbb6C+vh5DhgzBY489hvHjx7tC306kDVIHyy1K5lCI+VaFBl08DhAzlGWvE7JUsWhUKMbKQlUAozR1ShNTMSOa6uLAvrMGpWmmyNATrm9Wlx6ZAKjC7Nq5UagypWbblceh0YyNmYVd7F0hbpvmXe9UhVxaGDeLQiyLKinzWcjmvaqlzppFSe292imA0n2hQTGlFFT3CW5tl2mZTbuIG/eliSnM308KVAY3/Zwknl+40Cx9VUuVqAgyup9CglDAiXdS67ksO53ZZ1TNImq20DQLPUNvTCOt0d9VJZsvT4N+RkppaxWqCi2pRSmP6x3brpg5UlVpamXPz9G3T5nkFkx/6VQq5ZqQVFVVhSlTpiAYDOKNN97ADz/8gDvuuAOVlZWu0HcK6lo0sxuQeYFCjWHJQT9RRA/o/PTjFlKSqgqAZv2SWShvrDqGmqWv4S3/IPzi64CvJPWDjNqVWeq4jc1yKmLjDUG2OJvVshbSFxmDqBJvRs2hQlzv0rBoUXKhuKU8RoneWK2AF1ScsSjJXe+Mz4nt5mMeRKi2q6LlNgu926ba92K/v0pZAtU5LJuHdrkZmfF8yAfOpZARyjVJbTOZoKaazMOwXXY9VXRlNisMqmadU+2neYuSLA7ZuJ+qo+ae0BQATXFMlGCp6iIny+xoBNm4o7xLrIIW3un11Ow+Vc+URhAVCTIeh1JeFOrdoWlt1KL06quvYr/99kMwGMSrr74qvXb27Nm2dAwAbrnlFvTu3Rtz587N/tavXz/b2ncdeZM58DC7OKu676j6w+baVRXAjGnIECNqYlDtqlcDd0ZroR78rOGo0uOgpVNIq7jeFVDHyKy7lgz8pqdxR9T7lzE5ZmGnRYla2GWCJfUuU4os4be+bhidWosPAv0xJ/6FYbuqlkI1zW4OdhScNYvCrLwmkzlI3omqpS6YlrujiFBtFwVcZwUyBVpS4lJjBIo5LlRQUwFVH0lV2WKWwZUJjKrxGGbjd/h71ZLTWCs4az6uVgaz7oX59r8MzCZxAYDrIzNwW3gPNGjBpv6n9feLyj1qjMUlljcjqArvdrnZJoWZp2yNFObn+ZFZeLr+RdwS3sOQToMWxLzASFSm6/GDryvZrp0KPaO57swK6SyUBKWDDjoIa9euRZcuXXDQQQeR12mahmTS3MYkw6uvvop99tkHhx9+ON577z307NkTZ5xxBk455RTbaLiJT+ZcB1x8h1RTB+5cYRK7eGzV9Y4XQNQ2VlXEFIYgZcZXtXxYVWCQWnnJBpShryIkAXm010T9A6sLtar7EG95MrZoWbG6iDRlViQrc0I1S5M4d1Ronhk9GOOTq/BqYLhSu1L6JpUXhdWCsTZ2ZD71PP0czDJMSeKdiBpQ2dj1W7AoqY5ou+ak+FyqFg1WKaSieFKN3yCFfBuL6hbiZkyBtR7WQ19Y2Ii+6pxQS52dQyGeD6Zd7ziFlnqCExYsRSuJlcQ7aVcy9bHTYFAcmvYaUXvHKnDKDVy1HXm5BXp9eiM4DEP8F2OzVkLSOrXksLx9UHURN2tRc0p57QaURhDrbpdKpch/dgpJALB06VI8+OCDGDx4MP7zn//g9NNPxznnnIOnnnqKvCcWi6G6upr712KQx6Ikk96VmifasurSoLqxqV7HnlFxFVE1Sxdi0TKCLoOQovsUlW5aBTKNMbWIWV2o2btl2a+o5+fdocxDph2j77Hnvcqy04nH/2hOn/+Dj3Y5XuTvimdC43VMJD8mZTFS5hh0dSGXocH1zT73B3XtuUmLEjnW0mQ6W3FNCJoUlFhmW1UpIuunGRQaD2DaokQI2fr+mBcaVdpSXcPM7lN+JuuXGIOh0hfZM5p1c1ZVPFnJzioTclXHDmtxbZAIl9l2FYVXSslRyDiSWfupdlVjfoygrNASrit0N9YLSvRz5bP8bPaVFqDISJNzzU6LWvb6VigvKVmUioVUKoUJEybgxhtvBACMHTsWCxcuxIMPPogTTjjB8J6bbroJ1157rZvdNA1Vi44VZttONx+eBs0ckxYdUfAwqZ2U+bRTjLCV+BlxA1J1cwJxnQrk8RDsdYUHxgJAA/yINGfHYb+Lch0lm5hCEepW1vxgrVuqY10Wc/JUcDyW+dorp7Ol2pXOSZMbEMVsyWJp7NKAim2pxvJQSWHM0vCBjlESx0eVFs1LhwW1nkgtOsRaY6fFV6eUYX6oYxjcGi1/EU/KoqRfz9lj54Um/XXGxxRYIZdVwIkUVLXnbLplFc8HiobM2mH2vXIp0CUuZXLhJG14Tk1pydCQrTUmi8rLaRo/i7juqawJKjNSFgcrU2gWCl2CjQLTg1uBujXU7D6lb7cVyknmRnAqlcLjjz+OAw44ACNHjsSoUaMwe/ZsPPXUU4YZ3ayie/fuGD6cd2UZNmwYVqxYQd5z2WWXYevWrdl/K1eutL1fVqGuPTcHjilUjHlRofFaYBgA4At/z4IsSiL9T/19sNDXJVvoNh849x3BzYjS+ppNCcpCWrVammErh4K1LQbtqmggVcfKcSVHY4NWguOjR5L9VWUKefdGq4KS2gag8l5ZdytllwJKoNKa0ue/GxiELRKXBgqqGkgrm57MGsjC1uQbikHV7HuNm7YoydKDw/CcSP+W8B742N8Hp0QPzUsPAJ4ITkA9AnghOEbZ2pAm1t1ClFCFWFmrtCj+EDkYp0QPRa0WzktH1SrB9824X4VAxmxTVnkVmmx6ZNUkFarWBhVBiV6n6evMPiNfE0hN8SJTbn7t74EvfT3xdHCcaaWlzKOCdvk1D2q8iM9I0TfrLiblcWwUADMICVZvabkFgv+wtvtq0rFLFmY3ne2yWVBqhZKSspoknU5j9uzZ+Ne//oUxY8Zg1KhRSKfTWLRoEX73u99h3rx5eOWVV2zt3JQpU7BkyRLutx9//BF9+/Yl7wmHwwiH828WxYSqW5wVa48q462yOP/s74wdy87DJq1EWHSbppERTRlT2KgFsHvpH5RnjPoGlIMVf1i5RUdVyLXn2+nom/TbF/FuYBCGlV0MaBpGxtblbVfm0pCChpvCe+Ky2Du4JLq/6b7wQq75e1RAuWDo2zU+tgra9Y2HFZdKmUubrN0VWgX6pLdKa85QUHVtoWKUzNLg+p6m1x1xfKzxVWBW6UnKNH/xd8LQ8ktQhyCmJX4m22VBWfTstCjlW89fCo1Rble1Fo+dGmuK2bLT9a+GFRIL0MrrruME4MKTOUitrKbj9tSuVxXy41oA+5Spx3wXYg10KjuqLF6ZUliYTVghLSCue/7Cdw4Z78Yr1IzvsTY/0+Q+JVNUqoVttEKpyADKgtITTzyB999/H/Pnz8eee+7JnXv77bdx0EEH4amnniJd4grB+eefj1122QU33ngjjjjiCHz22Wd45JFH8Mgjj9hGoxhwLh5DjXkwGw8BAKt8lQCAUDqR/U2/TJhgEkwIMoVYG2RVy/NBxmzKNiqOToHaFqN2rWyshmjuG28FUhsTYiaoO8K74+HQJNRokcL6kqXJCk1qgppSW8obu5qgaBaqArCq26wRktKiocb0NQAnlxyOW+r/hWsjM5TovBQchcPj3+Gh0CRl5QEpUFkIHBfPWY2BEFHX7L7GJxGhQfXTuqCkqkgyBzbhgzxzWv7jQlAIs63yLl8NDMeBgYX40N8vD/0cZK7UKq5oVLuqHh1Jk2NXNSGKnYXJWagqAuxVGBi/I+X1gXkXKsldVHkyq+U5KMi+HaVctDonZeENKtdRoKx8rQ3Kov7zzz+Pyy+/XCckAcBee+2FP/7xj3j22Wdt7dzEiRPx8ssv4/nnn8fIkSNx/fXX4+6778axxx5rKx23obzpWCjkp8rsWXERkwbEC81amcjq2mt7FmdRy+kUE81CZtJWiQexugRRY0cmDGeYDKtCkp6+2nUqUF3YVdw7CoHczcj4nNkNhQqczkd/gb8X9i47FR8F+ivRuTAyC0dHj8H14emCVUBVyC7cosSuNZpAxw2mUNYuxViYV3TR64tMsDRLhxUAYppiGm3J2FUB1Ud1q0h+io1aAMeXHI2Hw5MF2kJfFN0j3woMxi++DngmODYvbRFOJThhk3VsYdZdWRywzEXcLArxqLA6P6k5VYjlx6wVRL//GbdbCN72DwQAfOLvLRHeafp87+wTRqUxSsyfZtfzTN/btOvdt99+i1tvvZU8v99+++Hee++1pVMsDjjgABxwwAG2t1tMUANR9FE3i0IsVVaYskwLxm1Z21iNKcjjMezSei7xdSbbNZulSBWFbED01qAGloqqAJgg0oNbheqYtCLYy+so2cPsyttV1YCanZNqGshCLMks6rQQ/hscomtXZili/0qYTOZAuc/KCs7a6zZJfxNKUDNrNVOlb6dCjX0WMfbGKSsS53onrY9FzBcLr1LG7Mpc/+q0ECaVnl0QZydlNolzKutpSvPh/MgsVKbrsdLXPvu7JrZF0NAschmFrFMJSUkRFVAKJdWkB0lNww3hvTArvghzQxPy0lP1PBAFNbOj5MLoAfhd4xe4PzQFR8W/NmxX36r9a51+fqjtv2a9O6wKlsWEsqC0efNmdO3alTzftWtXVFVV2dKptg92A3CG2bbDf9kIcibeGVDBmHZblA4pOR6TkivxemAHsl2ZFsUuTZ0Ilj7lemF1FKkKB7a4/uWlL7vOHE3Vb0fdY93NKAc7XVVYhkNeNDQHO2MFeBpq78tscU3qPTRlvTO+zjnlhdp1VgRemeLHzmdsZKxIYhptSnkCgb4VZpuakzKBxs7v6oaLuGysU9lGZW6QLJ4OjTf8nW6XfwYrNe+4ccg0K1NesOtTIbR59y3jvohfSbTa3R3eDXeHd1Oip7pOW11PV/ra43oDt+eERHh3w81XpEEJqmZpbtRK8UpgBDptXo1hBfe0OFAWlJLJJAIB+nK/349EIkGe95CDK4HjUo0WC5MTjCv8KDJlLmh2bQw0FPF+YCDeDwyU03eIKVNNSUoX4bS6AVljCgsBVUjWqkWJdUkpSHlgIXOZrN1CNJUU2CtktXOo2C87dXvqKfPNCdlUWxpkc9I+FDImrTAvYtFQir5Vq8ByrT3+GRiOLVqUq51jprYYm4rbLOTuqMZrklNKGae03KruZk4pnmRxe7YJSgUo9wqBjxwTaolArHgh6NtVu84sqOdS9ZpxykXcTmX0T/7O+H3J4Th12fM4sIA+FhOmst797ne/IzPKxWIx2zrV1mHF9U21Xbn/rj0bkOxOWzW7muriaHxstSeqi4iVFNmFLE52WpRUzf12CYoyRk+qSVbQ8F4QmYW/1v8dt4d3L0hQccr1TkqfZWwUnpGqFaWnn4M7TCEN1TTmGVDjWxQoim3lVCnI7CR909A0nFxyBADAn6aLxMv2Kb9Na10hc9I6nNl/Wcj6rrKeW4dmeKzB2l4hU1RSmQ1ltbpUwN5DW5ToGC3zll2WthrvZOc4UvWaMeu2SUFDmlzDxL3IqWdu6VAWlE488cS819iZ8a4twyk/cDdc72SQZSuz1C5zLGqvVTSw1unbsyDJoOpGkCLqaFi3KKnBrsD5tLBly76dWTo/+rtgt7IzAADjEquYdnKQa8/tG8eFuN6p0KSYEl27XN0PpwQltXlnJRWy3n3JmL6tWnmC2ZRdZ69bs7sMve4cWbNFg8+SRYkZk4oZLq2tNfTfds4JPvZJbUyaLcJMQXR9k/EVKpnfZJQyULW8yIrPK1FMs/sUvZ6xf1kRlFSvd0rxpOoNZK9FiV7DyDpKnqCkx9y5c53sx3YFO5lC/l7jY/l1Vq0CzmjiWVB+wXJti31Q9Yu2y29flT57bMWdQqSflrj02btQGgtqdioPVN3onNIUqlqUzL5Xyh1FRt+pGCXV2l4JSRpzw3a5d0Jrpa3WFlOjb14ALGR+UGuYYy6/iufEfllxvVN333IGbgSYyxRKVHyhnd4dsndsVzIH+dhh9xOWtnn42bVOeT3PwXx2NvP7hFUU4o5qb4wSe6zGn6rUqjR6l3bG5bsFZ3ZOD1LIGEG7mO1CMnyZhUiBatdaLj+ekrxAYg4ys7xZqDI/nwb6AEBBBTwLWZytLo7s3arCiaqmNB9UXQqsgmIYVDV1djJrdhacpb6dCKfmBAtZ4Uc+wNwcU5gi5r1TrsQiCorbszG+zTnXM2Maqus5wDOv5mnmIC8Cbc+aoH+uHMRvZFXhRLVLwS5BSYRsL/Y54DapKqgVsu48FNoZAPBKYIR07FDu9qbfqySWk9sbBIWiXXNUJoxS55y0KFH0C6fZ+gQlZYuSB/tAbQBpaJaGUEGuIhake5lLg51aLBZijBK9mTqz6cgWh+W+DphQdg42a1HTNOQxSjlQbkaFPK2KpkpP386N3fiZbRVOCtGA2ii0FaIBVRKUGGZHPg6c14Cqur4lTc5PypIsMrPFcIFhYZflx8x6ahtUhXfBamctmYPaeLFT6KToi25hdglKFEMt0ndOUDKmB9hnDRT7q2INLQR3hnfDx4G++MLfC/slluRoSMYup6BxLbOwPXTUFXoOKRQVE2ZtT653nkWpCJBVVHZDo0VlGzOLpnvVXICsPBfl+y3XYrH3W9W2MPTz+Fsv83VAtUVBSafF4uJMjLX3hQiiQWbDLESgcE4D6swGUEiciZ0uDTKXCrMMto+4V0bfKWZbte+mhWyWUZbMe65dW2t7GR/rr7Nn7MQFO40bFiUZZH3ZqJVYaJd+Rxp3nfGxVXBzUlf3yy5BSe3bOTd2afr3hacAaLLQmIXqXKfcYQt5woTmxweBAajXQhIrM5W+Qq9ctQLZ2LUyclTjy5wQRnkuznmLkpWaaMWCZ1EqAmh3IIv+w8oaOHs2YLkGlIddAqBMUKE2dqubn53poimotksFzhfSq198HZm2wBzTzEtC4mZlBvpEHMbHVrV0lJAtu449rteC4qWmoBrob2UDUo5Rcsg3XDXpghXXP94alSbP2SpkE4KaSMcua6SY5l11TtoF1XIPaWj4c3gauqe24fHQRNN0KGuk/jp7vquM2bTT9a6QOEezRZgpiO+Rdn0D3g0MwoiyC7FeKzVNR3U9oyzZlvdioi966mqKpHwQM9mqCjHWQI8dak1wzvWO93KSWZtU8ea4XQu6r5jwBKUiQKbtcWKhFmFXYLDMLCues+LTzkJ5Y7WRk3AqkJqFapyJnXFgzwV3ROd0Dd73D4Cq8My+f1lVe7Nwym1SVQARmbJHgzvhlPhnuC28uyX6cg1k4ZYIyqIk39idEpQUtczMuSX+zqZorNHaKbVbDCunyLwt8XXC0NRG/D04yhS9H/xd0SdVZZq+U6DWvRQ0rPW1w2GlhWW5LWyfsg9OxShRe46sRbMp8ynI4nWM+rXOV14QHVpQohl6t9wmWbAU7c1sqPbM1mjwx7yKiFZe2AWnLUoruvQo6L5iwhOUigCnNIXqriI5uBX8bKXGkOriSLkUWn1CVauEFShblAjhpBCRJan5cWezIDAwuTH7u+qmtw3GNdUKgRsxStLAcWHsXBbZD3eEd8NGX5kl+qqud2aZ4kLcwux8r7ylSFErrmmYXHomOqdr8StjzZThd9Ej0Cldi58YwUqk4BxDrdauSP+AkpMwPrkKbwcGKdE5sOREHBb/DldG9sETdS/m2nWo3IIqnNoneGaLn5OUwseqaxELaj8B7ItFKMQd1co3TkG00DsjZPMWavrb0UkfrI1kVUbdLouSCKcsSpQ7qC6+jbDoxDS66Hg+yDLbqo5d1bZbKzxBqQiQaQXsSt2pqj23AjOBhk7EXmmgN3N7XeScajcH1W9C0bdSGUOkL4uXSkHD3aGpqEg34Bd/Jwv0aPri/LDKQGQg1ywKc1LTsFGzJiQ1taVqlTA3xtYyGmE3rMcyyGrhiPjJ3xk/Qd2a9FpwuO43cS1xKm5OPZkDf12VrwRv+YYo0/ko0B8fBfobtGtMwy1QNO2M+ZRZ/p1j9nNwYz1XTXBipScpCC5SxLFVkVt1PaU9H6yBctsU22XXiISNMUqyUgT2WZT4d0fVO2SPN9iwV2WgaoHbnpI5eIJS0SEIFDZZXtxjnmgGl4Vd5m/1dLLWsMjXGcNSG7DQ18WVjVWWfYqFU0VDZQlGuOug4YbIdPvpM8eyAG/z7dLaa4q+U0yZ1CrBaRHzt/tMcBzGJNfg7cCgPEw8Q8MpQUlWM8bCeiYDn9XKHvclEWoxdO5YtNxgSmSWFzvXVrdd7xo1MfbLmfeqGpDPgo1RKtR9+pj413g4vDN2SqzM/u6UgoRdm0RrmIorsfUYJfZZ6OcKIpm7x4KLuHxOCOc0zZYFQLYXic9/fmQWZiYW45HQJOuEm1FIwg4KbcWi5GW9KwJkC3UYCQvt5qCeCatw6K0C7DGv7YnbZBqWbSx2BjoeW3IMHg9OwIklRym7b7kBOhGItc1QeWO1yfWwKZmDM4wYC1mCEzcqjqtu7Gbpx7UAzoseiFeDI6TfhNTs2viSnRLeKciUMG5YlHTME6dksNHa4hANy30pgD57h2qBYKs01zVr2f8dGGpruypQHYcJFL4vAsBFkQMwo/T3+GtwJ2FeOLSeKs41GS9gBaqWskDaqo+FCn13LEo0feDp0HgcXXIs6rVQwfTyC4OFu8O2FZuTJygVATJN5XJf+4LbLcRVxApjsdjXRfiFnuBnRw7CVoRxYeQA03TYHvIxSjyoBaaQZ1zha49Logdgma8D+b6KoS2hrCJ2annt9L2m6Ql/u8AIqhYttdcqYHwsgh1XVlxF9HOCPbbvvfJCpjMpjlVBWR6sskrKmlUXLErpIqw7FFNsPcOWMQ1AErhewLjaqexsTCg7B4v8XQX6jOLLofGqOtcSkv1MBY1aAAv8vXTKEqfmPaU0lFk+nEt7TrdrRTHL0xPh/D5JCbyAO67UoiKDV/UZx9VSsCvkotjwXO+KANlkfzi0Mzqk6/BGYAdL7crqjlidbAeWnIhxydWYLwQry6bEV4FeGFR+qSUzOCBnIqn3anWhdjtWQPYek5KF2j6a7musuQ3IRqGJtZzIsvS5wVjIarbwvvfOZBN0asuSvTs3RpJjbkbEu3NDkaDvCw8nhCW58sB4fhaCQpNkmEWtFkatpk8441S5B04AlOy/LBxzpSbatZOarO+0NdY+1zvZOHzPPwBvBgbjO183a/QUBVAN1tZX9cLk9s3DXJs85Eky1K7LwBOUPBQM2abboAVxdWQfG9pVNYubBx98TGkY9PQLF5KMAzNlrndOaXndcDOSxdJQi5N1lx/nGWqKnkhTz2wX3iN2oZalsXZKAyqriUHRtzP42A0h3+2xI6dvn9Ckmv7YzndMKnuK4MRi5zP6YVzcWpY4xo24QZH+HyP74eaGN3BzeA/T7fLWMDXkK2BeKFTdG82CbYmLDRQkBdk7tgLVMZHSfDim5FiL1ORKEZG+lTnqZ1wF1V3v7PmuGuRrDTsu2ZjTuJf1zoOTcCrOhBrsadAmU7dSZ1oB20O9q0L+Z3HKQuAUpFmSiMB166537LF9GkB1+rT23q54GvVkDvahEGbTOYuSfd9VVbPo1PjhGDaHPMhVx4Q7bpvOML4yUMx2Ic9IaZbFdumU+faBc70Txs5fQ5PwemAHad0uCmwiJtVv5FzWPeNjq+CSqChalOx123RXKSP2V66AtSAoceMezDGt0HPq+WXfKMAoPMQC2UawMxa2mPBilIoAJ8ynYrvK5ltbBSWntFjMbONcGhRdRewUQF2IwVB2adA03BuaAgA4N3KgJZpOWeBU4ZRFiW1ZFl/mxpyQzUkuna2dhXxdqMUja9cN1wtqvtgZt+dGuQVAPQbAHXc/47FTCLPrU3wuFs65VBofZ7DGV1FQ0hrq20nXL0UXPbNwSkHCJkngE1GIvbdv7LBQTbBiF8x4Plh5s6zF1W2LkghZu2w2QZU58qW/px1dKjo8i1IRQGsKraEwlwb7wLVr4xyWNUVr7HNwLouZM9BXWacthdeHp+GJ0ASssJAERKThlsaapp+DBqv1RXLvMsZs7GKQqnNZ79hjNUHJXotSDu7E8vDt+m1dYViaOVDKC8uud6RFRaZltkaTvVu2hrnjHmtMv5BnZEe0ctIh5pRTFiWn3NIK6a+dqfSd2uM3+Uqyxw0S9tEpN3jZmHDD+4FScqdhbSz9MzgCV8fewo8+vjahbJ+y62nlBWf5cf2LYqHwDB4PTYQPabwXGGChh8WHJygVAW64arhnUXLGisNRIDYQvQBo7FKxRiuHXRCZeCdgpgZWWvNhhWZNSBLhlkWJdrcTF+rCe7TU1wGPBydgo1YqjZFzztqiNtdrkEvvGrOQMlj2rpwSgFMSK6/rzAv3uzPt6q/LQZYwRAWU5UUnnLlg2XbDoqNatNQp5YFT1sBiF+N06ttt0UqwT8nJqNeCUouCqpLBLJyylNH06L/tfK8rfO0xsuwCVGlRVKQbSPqqMa9WIBu7a33tMK30VGzVIkptJTU/Hg5PtqtrRYMnKBUBTk02VVcNvriljfQJbY+d8RDc7xINXAoaLgvvi5mJxXg2NNYSfRZuWFvW+/gq27xfuFPxGO5alGS+1+Lvlty3NA2XRPOnpHfO9S4HWSrkzb5S/D56GGoRQtKm1LYi7GTeqIx9IliXEjuhor13MpkDdZ1KgLMM1HvVH7s7R9m13bkirfSa4EZhWKvgx2SxrfLOPCMAfBnobUCb7gv77cxaJGR0ZDTtgt6SK/N8sPam1/qa4uLS6ZghPZGmUyookccQn+sbfw+HKLdceIJSEWDnIvavwFDMTCzBp/7eysG3zrneObM5qC5AnEZP0/BoeGc8Gt7Z1r44qR+/OLI/RiXX4H1/f/IaN9KDi+m5nXjmuCa6F/I02d+dGFWyOeEWIyjileBI2+hmwDFvGvu7nW4+9HM54Xonc32zl44aDbY/VjMWqlqUnJiTYuA1T9OaIiEOH4IGQrNq0VI7s426YVEqRpwnLWS7L7SJSoYTokdiVuIHPBbaydZ2M3AqaYCZGCW73rKqMGjXdxVbKbY1tCXCE5SKADvrxFwUOQCfx3vjueBYjEqtyf5ejGQOTpn7VVtir3OOeXJuEZkbmmiKfmtIxEFBZChlbnjuZN5zRgB1uwCrjFoxgn+dSOagHw+UNdIa+MQpateJ1mCzoCxlsuxbToFi2AoRBo8pOQYP1s/D+ZFZ/Dotc99yZa2zD9T+I/acomnVbZOn4ZxFKR89kWYKGv4VHIZ/BYfZSkeWxtouVAsuZvIYIXvoyz2D7KamRzGKhrd0eIJSUUC7GZnFel857gtPbbo/ZbyIyBZqx6wSNrZbCNxgCltC6my7QG0ATj2jPmEFe8x/O2eYbXc0sG5rdlXj2+yE7Ot85bM/69E3Pt71w6l3zL8vyXvVfJhRegpC6QS2aCXkdSpQTY/thvWeYkrjBbiGvhMYhB3KLgY0Dbsklhm2K4KLUbJRiHAqlkg1s594ZhtCKEcjlmuVlujTrnc0L+AUWrvS8orwPtgtuRTPB3fEHQ2vGdJ0w6IkwgnlgUjPsyjp4aUHLwKcyghD0RBhb4av/K4i1jNBFeB6VwSm0A24EUvjJB4KNblC3hbeg2RwRWFwla/C8X6lFCujm4XbGtCkoA3U0sbCoFXwlg+aEZsfGISToodjp9KzLdPcs/Q0PB0ch/Ois0mGnoWdgeOi65fY9gJ/T3wa6GuJHgDcFN4LAHBvaIpkfrijohGZskeDTW5TtxRQjBWAYfC/zDbolDssT99517t8X+vEkiNxYeQAw9ifQuG20rLJRdqYklslUOwcIQ+FJ+OYkmPRqNG2BKfW85QkZbwTwmE+1ztPbPIsSkWBO/Uh3He9o/piFVQPxUQUTmmxiu3vzcGhujiq48UqrgjvgztCu6HKV4JTGz9haND0Hgjtgh6parxmg+uGET2RphtWVjuZB56erGFnNMvSuaZpeDU4whY63/m74/zobN3vbsRculVn7H+BfhhUfgm2IIqxqdWu0MxAX1uMP74sOhPXRaajXgvBLqgmybAzRomjzzRrldFlXRLN7D/vBwbifUuU9XArsYMKnNqLZXXxnAJVl05DGmu0duicrrNOQ7YXa2rXWYEbCr3WBs+iVAS4sXDJGDF7NXXOWJFUQdFxw6JUbE2LrUK2jNe1c5RqGqp8evckWYxSvRbCBdHZeDsw2L5+6OjnUKxkDnbTA/iN3Q3rtVtbqopSxGpf+GQC7m2VW7SSZoUI8+0kKdjtRD6vADuFJEDd9a41WJTuDO+GTVoUd4emSue9Wxae7DGR5MleehrZsr3ZNp1pVxUyK+8foofgY38fHFxygm00NMF+7ArvWHTOpuXBsygVAW5YKFQtBNY1dVSch31YJwmQplwcWsPGahVOac+LIeSquOG51RenglnVUhBYA1uPCaBd7+x0hy1GDAQLp1zv3LBoyMCPF/fpOyVYy9wmKfe1lI2CqlPM9m++CuxQdrGuXpu+tpjzcCOuVQYV11ir7YrrtNs12/jfgSX+LphVepJjNDJ0VK4zA70wxp4rvkK4JcATlIoAahFL2Zr1Jge9SwWrqXMq0459GtCXAyMxLrQan/j7CPR4uKFtakkJK+x8Rrdci1houiVZT989oY2FOxu7nbg+PA07JVfileAIPNjwsuE13Py0sSvFDv6lxqvVcWxvLKd5qCgS7ITYqhsxQqrJRxxzvbO7PYU93A2GXpbMyQ0E0rlU8HELBbRlEJ/Rjeekwibcihd2Y58utqtmS4QnKBUB1KZn52YgE4CcczNyBinNhz9F9jN3jwvuU04y8f/z98UuyeV4IzCUvCZToM4OUN/Oyc2Hbdtti5LoKlIMNx87GaZ7wrvmvcaN2MhiwDmGhW2LOXYpfa7bCgPxO1J1+eyE6lxrSx4CrliUSCLOUN+mhdGBic9h36vVIswUnFxPaZrGx3YqwWTZ9NxY64q9nrdEeDFKRQA1KK0WK1S1qHCaOosTnJrExQC3ULrgPuXkgvL76GH4U3gfnBk9SHfu6OgxuCy8Lxb47Uy9TAmDzm3sdHFNtlvujCmnrAeyDciJtOfyvjiDYlhb1Ip7WnS9cyhxiircTg+ub9Mp1zuWJg12fjiVHtyNPUv/Vp0ZTVSgv5N71vmRWfjW1w3Xhadzz7XU1wGvBEbg8eAEJSubKij3+uKU6nBmfqi6MttFU29J9pztRHgWpSKAtihZFZSoRUStPoZVFMNlyg1Q79XJZ1zvK8fD4cmG5/4bHGI7PVmQqlObEDcmiU3eLTjFTMji5gJIiZc7CjvdNlqSgkQWN2AFbs11Cm64vnH0BBJurOeyVMRuuD4Ww0XNKQWJxjTr1l78dGg8ng6NN+iMht+XHG47PVVlsFOg56RzFnoy7bpL7qhe1jvPolQUiILKjeE9AQBXRfaxjQY7icWF2c4N2O2MLDK44btvp3asJUGmgXRqOyJdCorAd7vheie+SX/aXUGJdCWziiJUcldhmAopjMrCKdcadfpujEmeHq0Uco4mBfZMzEadLu3y6wz0yRzcjVFyL+bUDRoyZbAb9HMotjuoXfuk+Bx6RamHtsn1tXBwi7MG3BneHX3KL8eHgf6W2lV2vXPI97zYFqWv/D2xRivH2/6BtrZbbI2KG9TlQapOaUApa4sbDBoNdxKBaAi6bFFqSYlIbAW7nmnAdeFpAIBzI/qaS2bQyDDn1QhbaqsQuB+3J/7tzD6h6iK9zNcem7UolmuVaHQhIYBbcIciZWVtO2xv0ZOtcF4QNrYr/E0x6XZ9S/285+FvW7tFQfBc74oAI6awzob6FKr+u3Zuum747KrSr9NCGFt2nuVYLxGUq4Rbm44bVOjMYc5plKg4E7cyfNHWUHc0hWdHD8S8uqezjL3TsPO5fOlib540/XvDu+Kx0E6o1awJN41aAKdGD0UkHcdmX6mltgqBzKL0bmAA9k8sxjrNvn7J6v24t9blqMa1AEaWXdj07I7FnDo/70WXesdc78j11P1v5xyNHPRWM3fXJKdcc1Vjr+x6Wv28bzvCtF3wBKWiwHmBQlXDYmc9Fbd9+o1oJCy62xiBepJip0W2E3LXO2dGKZ3MIXfsVMYkEU7Fg1Abu4Y03g8MRK/yP6FBC9pGT94Z++bnSl+F1d44gsw7tiokZTAvOEr3m5NzQqRjdAwATwQnoFqL6EomWKVHCWfFcIcFmoRVJ+HGGi7SaHCI7VJJjlNs9YZVUPxGSnPfRaz4yRycsSgVw5W6pcMTlIoAp7Q9bDCnbLA7lfWH2kzdsEg4CTqYsu2AEhScFHj5jd24L07V4BBh5zP/4uuAganNWKXx6duN5r3TQpJTY/fF4Bj0T23WuQu7NyeNYTUhTkuCzKKU1nz4R3C0a/TtXAf8LrucilDLmGgfxG/3dGg8DkwsxOuBYbbSUVFatilrgQvp6wFgkxZFx3R9E0kXvBBUx6SdFiXZur1WK0O3dA0a29Daahbb75MXEW4H6YqTIMEwn7UWGTWq925sQHa72FFoQ1sLCdmirzn0MT/39ybp3xuaAgC4OrK3I7Tl8RjWcGTJcXgqOA6HlJxYFBcYFVjtS1Lz48+R6XgvYG88oFW4ZeV13x3WfcuHU5aIX30dbGzNGooR+1WjhbFv6Sm4LzzVVjqU4knWl9YGai9ycm09LzIbjfDhlOihAk1noP4sDlmUhHOHlRyP/wSGYJ/SU2yh1xrhWZSKAKeCACmtgDidarQwzonMRhI+1GgR++hz6Umd39hX+SpdWfjdTs+pp+MuDdG65JSV4O7wrtimhfGfwFAd/esiM3BHeDfbXKjywc4nXObrgAuiTYkEeiW2GNJo7QxLS4V7gpIbrnfGCjU7awpR9ESadr7X5b4OmFXyO2w0iK9y4+txNFxwM/rNJTdVFde7mIOujE4p1DgaxLxzcp96IzgMvQN/QlLz46D49xxNo2OrKIZFScbLLPZ3xbElx9hErXXCE5SKAHcqycvxXGicLTTZxYk9tlrIVobjokdh5+QKzAuMxE34l2N08iEFDVsRRgViqIJ9AmcxQLtqOBd83KAF8UC4yXLULVWto++WkMTSFI+tgopRcgtuW3yLHbe3Tit3hY7bFiWnlGty+s65Nn0c6CelVwzYTf/cyGz0TVVhga+Hre1SkFmUXgkMx0GJH3BXaFdX+uIUZPHCTo6eZHPss+h6l4QGP9L42m/fN1Ydh23JzbilwxOUigCnNMvvB/pjga8HFvq7cr9rSLuyCbEUnKT37+AO+HdwB8faFyHWu/lvYDB2SSzDP4KjsMDfAzc1vIErIvu61h8nQBft1FDvVrKBLE13wFlANeNjO9GSYgVqHBJCi2XROSp6DDqm67DU39Fx2m65/LIrqlupkFtSXTyn4FbM6bM2KSNVwQpKouLrtOihuDm1F372OTc/illGoxgKmhQ0zCg9BSOS6/BqYLh9DTNKZlkNLrue2cmi8m0FnqDkIjqMbwredIphimsBzCg7Vfe7W0uIU0kiio1Vvkru72OiRyOCBOq1EDb5SjG97DRH6Ttl0eHALM5xzY8P/f0wNbkMT4fG4angeExL/IwXg2McI++2ECFLiepWxXM3INKcG5yAWYkf8FRwvCP0imVReis4xDVaK7VKVxgLtwPy12rlGIm1DB0wx21nPW+rWO5rnz1mx06NFkJS8+Nnf6didMtWUIlAtmgR15n9FDR86++Bb220JuUDJQxbQYPDmSXbAjzbnYvY9eVbAbgfq1AMbYFbDFPaBR/zNwJDcWN4TxxeclwzTR/qbah7pQq3a9as0cpxXMnROLTkeNwTmoqNvjJMLTvT9uBjFsWO33GKZrGVByLFi6MHYHjZRdjgK3OEnmsWpSIMkoNLTsAbgaE4L2qtkK0qWMumkxalsyIH4l3/APwlPJmnXwSLklbE+lytXRi8NbwHngvuiINLTkBa8+Hq8AzcGtodKxkBqrVjrY93rT0vMgtvBgbj0dAkBNLFK+DtFtgRmrQ4Xk+NHop1WhmOjR5NXtPa54Rd8ERJF1HauxuAn4peUdopFCMew5WNVdNwZ3h35+lQ5F2is3/JHJQgjvXNm5GbGc2K7ZbmynjV3Gc8jZByKBkAAKzXnBHAWgI+CAzAB4EBANyKUTIeL3aP1RdCY/FCaCwAYQ13Kf0yCzdShxczU6uT2KpFcU70oOzfmfjPtoSv/T1xcWRmNnPiM6HxeCbUZB0PuDx2ihNzap/ibV5wFOYFRgKahsnJFVa71qbhCUpFgNtMoQbnrEoad0yZhZ3bgtqOmEnDFdc7AJ8G+rpCxwjFsCjxc8IZIWZ70cidF5mFIamNXMp3J1Fsn3q3C86y6+n3/m6O0aRqDLknKLV2cWX7hRuCCgDMDe1k+PsbgR1wWOI7fOfranjebrgd9w2o18pUJ7B97E9W4QlKRUAxXO/c2ICKYlHaDjbWYhdodAN8KmTnPYLFOeGUxr7Y49MtITuj1d1e4Ibrn6hQm1Z6KmbFf8BdYecylxU7mYMrFqUiuve1ZRR7n7oouj8+iffBazYX8iVRBCHDqfXcrQQnrRWtKkbppptugqZpOO+884rdFUtIC3YYN+BGnIvbFc+baLZ9fBDoDwBtWlxy0rXICCn44GPeKLvJx5mCzFbhJ+adWxp6twQlt1Hsee+2RSkNDd/4e+CGyHRH0+bLMqe5gV8czMrmwVm4ZVGiUKNF8ERoIjY6FH9ZDIirDLvu7PPF+yirr9Xdc95U95JLbC9oNRalzz//HI888ghGjx5d7K7YitauqePrKOXgWZTsw7f+HpheegpWae4ULiwGOIuSC5q6TP2LDOqRS4G+RYvaRqfYWta2KygV2/XOeRTDokPV4nGL/h+ih+DK2Ft4JLSzSxRz2F7cZJ1CrPWwkwWj2OsOu2ft/9k72PPbT3DL4afhsGlDsbkujpv3649BnaLYoXMJ/vz2SqzcGlNqlywP4rnmAWglFqWamhoce+yxePTRR9G+fevP4FKMwHXnTLbGcNuVqq3ja3/PNqUpE0Fl+HIKSc3HW5G0ACaVnoWdS89Cg411oyhBqRiMb1tCCMmi0i9mjJKTeCcwCABQjXBR9qnffBX4Q/RQLPD3tLXdCyIHAADOjBxEXtM2Z4p7OCN6MH72dcQp0UOL3ZU2A3HerdvcxEvV1AIda7ai98a1WHxsLzxy6GD8/fjhGNSpScl32s7d8f0F4zB9UKUSnWILgC0drUIFcOaZZ2L//ffH9OnTccMNNxS7O5bBbYAuSexOMUwsI8hNNo0VlDythAc5eMHafYsSAPziQJ0Ruxk+s2irVshGG90jC4Hb1ge36N0c3hOrtXb4V3AHbj1PtnLN8lOhCfh7cDTqtBCOaPy62N1pk1js74qdy84udjcchduzIJBIcH9f+ORDeLdEQyLeNDfbDe2LLlN2NLy3XSSA/54yCt1v+ARrt8UBAJGADw0JvfKurSrU7EKLF5ReeOEFfPXVV/j888+Vro/FYojFcubG6upqp7pWMNx2qUhDw3uBARjZuA5ViNjaNmsrohYRZyvJe2gLcFt7noQPPhfqbqz1tcO4snOxVbN33qni7cBAPBkcj6+KLLDZjdvDu2NiciWeLlISiRsi07BT7QpHXcSK4cpcp4XwcHM9pd6pquzvyTbgFVDXXPtOxQvCgwcjuJ0I5Mj3XgOm8Gx6rC7Xh4kPXZa3jX8cNxxHPbcYd88egNnDOiJ4+Ye6a4rtIt7S0aIFpZUrV+Lcc8/Fm2++iUhEjdG46aabcO211zrcM2soRpDsTeG98KuvA/4bGGxru9/5umJUah02a1HSfOvsJu9pQtoanPyitQiiFHG8HRiE7/3dcHPDG7bPCRErDAo+ujXv05oPF0ZnuULLTaz3lWPPsj8Ujf4KX3vsWH6BozS4cgtFzrDVlrwCgoTb5ipf27S+emi9yJeEq8vu4/K2sUu/dlhxeS6l+qCOEfy8qYG7pkorKayD2wlatJroyy+/xPr16zF+/HgEAgEEAgG89957uPfeexEIBJBM6he8yy67DFu3bs3+W7lyZRF6LgdfvcUdRr9BC+KJ0ESs9lXa2u4JJUfhieB4zCw5mbymzsaYDxFtZ/vevsFX3XLuq04qOxtHR4/Bq4Hh+GtwJ0wrPRUnRo90jN72iJcDIwAALwbbVuIdtxFwKBOjKlhBqS1YlDJ4MzAEAPCtr6ke1e+iR+Cp4Dg8H9zRMZp/Du8FALg4MtMxGh7aHvwGPG4GI68+BVoBCpQfLhyPHy7gLfEvBUfjf/6+uDo8g/vdU0M3oUVblKZNm4bvvvuO+23OnDnYYYcdcOmll8Lv128e4XAY4bBz6VPtQFsy8a/0tcdFzRrrcJL3p704MhNzGr/A9eHpjtH3ghDbBtivWO+gYL3W1w5rfe2yf3/j91Kp2o3zorMxLzES7wYGFrsrrRobtdLscUMRtmq2VlSyDe1Z633l6Ff+R9ShyRXvteBwvBYc7ijNu0K74tngWKz3lTtKx0Prx4Ef/xdo0jVJXf2GXXhsQe0H/T4M61qCd04dhd//4yf8sqkBNVoYs0vnFNTe9oAWLSiVl5dj5MiR3G+lpaXo2LGj7vfWhHTb2XM4LPR3w9XhGVjZbLWaG9qJrKJtF9roq9zuUK1FcXtoNyQ1H7bamJ57e8Q14Rm4JvZfXBneuyj0a7Uw3gi6VPSxDWObFsGM0t8jDj9SmvsWneW+Svzi64AYAkWxaDmJGrdjBjUN6zVPSPIgRzRWjyM+eAMYkVPmfTu/HqOnRfHdO/XZ3zpP3RHB8lKjJpSxx8BKjOleil8ENzwPerRoQamtoi1ZlEQ8EJ7iKr23A4Owf2IxFvq6uErXg/24ObJXsbvQJnB/eApeDI7BhjacTn57wQJ/r6LRTmp+TC09Awn4uCymjtFrw/uih7YBp7PD+VJC+2lgzU9xrFsaR8qBighdy0L2N9oG0eoEpXfffbfYXbAMseK6h8JxbnQ2vmjshb8HRxW7Kx48KMPpee8JSR7sQFxzj0VoS3FQHtomAg5nh/ML0lCGVxSFpMpR9rg1XzmtD75fV4sPfm152aFbEryVqQhwWzhqy3E8W7QS3BeeijVexiIPrQgJb+n14IFDa6/V5KHtY5tmf/z70JVL0WPTOgDAMe+8qnTPjjefZQvt7u1CeP/0MXjqyKYEJxfs2hP3zB6QPd+Wsl1aQauzKLUFtF2xxYMHDypY51l8PHjg4KUo9tDS8d/AYHzr64b3AgPyX6wAXyqJq56/H2kA1SVlqKirAQDUb0shWu7DxhUJ3T17/uc+BNvZu38cP64rDhvVCdFgUyzipmeafvc8nprgCUpFhueX7cHD9oN7Q1NwXPwrPBccW+yuePDQInBm5CDMTvyAv4QmF7srHjxIUa+FsFfZ6ba0ddarT2H0r0sANCWlyghJAPDhizUIBDU01uvV6t33dqbIdUZIYuG5wzbBE5SKgLZan8KDBw9yXBeZgRvC04qSxcyDh5aIF0M74sXQjsXuhgcPrqLnpnUojdUbnkslgMaEXkgaet7RTneL74enyAfgCUpFQTUi+MjfFxqAtS6kDPWEMQ8eWg48IcmDBw8etm902bLJ9D3j7jzfgZ7QWOPV/QLgCUrFgabhwJLfOZ5ydZGvM4alNmChr6ujdDx48ODBgwcPHjzIMeHH73Dyf/6GSLzR9L2aSwlPyk+7FonVv2JqYFe8/fZKV2i2ZHiCUrHgwoC/OHIApiV+wmMOF3314MGDBw8ePHjwIMdOS75Bu/raYndDitCOUxHacSquBfDOr1u3+/ThnqDUhvFJoC8+CfQtdjc8ePDgwYMHDx62a1z4j79i7C8/FHTvvl89Y3Nv1CDWwN0e4TnLe/DgwYMHDx48ePDgIMb98kPB6RE6jB1qa19UkWYEpf136FCUPhQbnqDkoWCc/vpz2eMpC7/AdU/dnf27++b1ReiRBw8ePHjw4MGDBzuQZiSl1+aMKGJPigdPUPJQMHZd+AWuf+pO7P3lBzhh/itIM6qS2/96M857eS7CjTGc+X9P45bHbileRz148ODBgwcPHlzEDit/yR53qK4quJ0Dlvzdju4UhH2GtAcAtAvr6yxtL/BilDwo4ZCP/oN5U/bJ/u1LJQEAA9auwoC1qwAAXas2cvdM/Ok7jL/ncvjSnpOrBw8ePHjw4GH7wZXPP4BlXXpi3pS9ceR7rxfUxqDTDkG7IcWLNf/jnr3RpzKM6YPbF60PxYYnKHmQovumdTjztWfRf90qDPxtOXzpFMrr69DJQDtS3lCHux6+AWEm7aWRkORPJjFi+U/oVrUBb47f1dH+e/DgwYMHDx48FAP91q/GBS/PLejesoG9sNNDl9ncI3MIB3yYM7Fb9u9L9+iFJ75Yh3U18SL2yl14gpIHElo6hdsZl7kdf12c954uWzeT56569l40hCIY9esS+NAkQHmCkgcPHjx48OChrWDfL97Dnt98YrmdqS/eaENv7MXN+/XHTfv2w6L1dbjtvdV44st1xe6S4/AEJQ+GOPG//8AYBcHIDIauXqb77ZxXnsBze87GxortM5uKBw8ePHjw0NoQ8AHdSzT43KmB2qpw9MoFKCkDUNbVUjuNSKGhocGeTtmMARV+7NwjjHd+ND8A3HimYDAIv9+euCotnW7bASTV1dWoqKjA1q1b0a5du2J3B9qlHxS7C0p49tYLXKW3oV17/NirP/5ywHGu0vXgwYMHDx48qKNLVMPtUyPoVOIvON11W0QgmUBFbQ002MNWR7t3gi8UtKUtJ1DdkEBVfcL0fX3bRxzojR6VlZXo1q0bNE0/Ss3IBp5FyQMAYPTSRTjqvddx+ZyLEG6MuU6/c3UVAiuSrtP14MGDBw8ePKhBA3D6yCD6dyxBpLIzoHnJkzMIxRvReesm29qrHDwAmq/lvt8NtY3wbzMfq9S/W6kDvckhnU6jrq4O69c3lanp3r27pfY8QckDAGDHpYvQd8NvuO8v16IkVl+UPqQZ3dTIZUvwfb/iFFhrSbhqWh98tnIb/v1jU/KM9VdOQpfrPy1yrzx48ODBw/aIyjAwoVsQkXYdgKA7loHWAl8qjZBNVXdKe3dDpKTElracQmnKD9SbtylGIs6Pm2g0CgBYv349unTpYskNr+WKqh5cwcDfluOUN17E9AX/AwB0qNmKCJO1zk1U1G5DMB5HpLEBl770CKZ/9WFR+uE2xvcsw+V79sapO3XD44cNxjlTemTP9akM47I9ewMAduvfDp3LQty9U/vlTMbRoDedPXjw4MGDcygPagj4NMDv6dlFtKursa+xVhD81T4aQLfyUP4Li4SSZkEzHreWoc8b6dsxLn7pEQxf+QtCiZaR5tGfTuGR+66Alk7Bl07j2Hf/D8NX/oJXJs/Aii498jfQCvDrpRPR/5bPATQJNldN64M/NgtCLO796DcAQHnYj90GVGDlZTvpFqQjR3fCC8cOw5rqRrSL+BEJ+BC4bPsQLj148ODBg/vQNDT7frR8Rt5J+JNJJBkrRa+NaxG0kZcKd6iwrS2noGkaelWE0aU0iJVbY2hMplHb2HJCKIxikwqBJyhtx1BJ9+02WKEtlIhj0pJvMPaXH7CyUzdcdcL5RexZ4ejZLoS6eApXT++Dfh1yJufL9+xtKCQBwK0z++Pj5dU4ZGQnAECvyrDumgm9ygEA3dvlBKivzhmLOz5YhWcXbLDzETx48ODBgwdDhP0+xJKp7N87dC7B4g112b99moZUG8sb1nvDGsQDAWwur0T7mq22Ckll/XpA87ceD5FQwIeBHaNIp9NIpNL4Zk1tsbtkKzxBaTvF4FW/FrsLyggl4hi4dmWxu1EQ3jttNHbt3w7pNOBrNqWfMbk7/v7dRpy+Mx1gePHuvchzX587Fv/9aQvnopfB2J5leOaoHbKC0u/e/Dt2XLoI551+pcUn8eDBgwcPHvToWh5ENODDko31KA35URbOWVoqIwEM7BhBGkAilcbyqhi2NpjPlNbSoKGJN+lWZb9SMtSx5VuTjKBpGoL+tmdpbD0iq4eC4fcBJ0/M5fP/T+VKXPHCA0XsUWE48/+exrAVP2f/Pq/AatdO4YGDBup+iwR90DQtKyQ1XTcIa/40CZ1KC0v7OaZHGS7avRdCAXr6fnD6aFw9vQ/2+uYTdK6uwl/vvgxP3n4RLn/hLwXR9ODBgwcP2y/OnNwdTx85FAfs0AGdy4LoyXgyaADKIwGM6laKoZ2j3H3RzB6oaQj5fRjcKYqxPcowsGPOu6JLWRDDurTsxAUZaOk0Io0xwKYU4CIqRgy0zWXMgz3wBKXtAJP7tMPt+w8AAHQrD2Lvy45BIJXKc1fLwy6LFuDI91/P/j3xp++K2Bs9zpjcA7v05fPx9zVwmQPACU5OYGr/Clwzoy/86abvHG2MIZBKYQQjaHrw4MGDBw8quOOAAThuXBfcfsAAlAT9aF8SRKjZPaxdpMk5KRzwwdfM5O/QuQTdykOGwf5+n4b20ZyisCzkR2nIj2FdSrBD5xKUhewpFGon/Mkk+qz/Df3WrUZ46Y/YYe9dseK31dnzF9x4DU694mLLdAJRY57BCIcddhjuvPNOyzTtRodo23JW8wSl7QB+n4bKaABbr52M5X/cqdjdsYSBa1Zg6Mql2PW7z4rdFdy0bz88fthgAMDMHdoDaHK1++1Pk/DDBePx2Vk7omuRM8JMfupa3W/7fvF+EXriwYMHDx5aA54+Mlea4/cTu2HDVTsjbODBMLJrCcZ0LzU8Vxb2o1dFGH6JUnBUt1IM7BhB+2bGOuO2t4ND1qVrzj8dF518dEH3+tJp+FNJAGnc/cSj2GfXPdCnR8/s+SvPPA93/Um/3xaK999/H7NmzUKPHj2gaRpeeeUV3TVXXXUV/vznP6O6uto2unagf4cIRjtcK8lNeILSdoDTJ3UD0KT1ybhrTX7mumJ2qWD40mlc9fz9OP2NFwAA5897DCUN9Tjt9edccStbeunE7PHQzlHMmdgNy/84Ea+eOAIAEPBr6N4uhGFdSzCxd7nj/cmHzlNG63477u1X8NC9V+CI91/HkFVL8fidl2IfT3jy4MGDh+0eew+uxHHjumT/Hto5SrqJ+3waghaSDoQDPrSPBpVczbpWbUK7WhvTbyvAZ+B5U9/QgGdfnYfjDjyU+719RSVKo9YEPF8o955ra2sxZswY3H///eT1o0ePRr9+/fDss89aoms3NE1DKOBDj3YhtAUvQk9QaqM4bmwXfH72jlh4wTgcOaaz7nz/Y/crQq/sx4SfF+Lhe6/Abgu/cMStbP4po3Buc9KE86f2RH8ma11GU9anfUSqNSsmygb0QvmQPtxvGoDyhjoc+Ml8XP3c/Qgn4hi1bElxOujBQ5ERDrTMuevBg1t497RRSN08Fd+dPw7/97smpd8zRw3FEaM74axdilOao1/7CEJ+H/pUhtGhegtKYnXNFp0mdKvaaJlGYyyG26+6GHvvOABTBnXG7w/ZGwu//jJ7vu/635irm2KS5v/vAwT8fkwcvWP2zIrfVqPTxBFYuYa93jzKB+f26v322w833HADDjnkEOk9s2fPxvPPP2+JrlPo0S6MbmUtt86SKtqWI6GHLJ4+amj+i9oIfAZBldc+fTe6b16Pl3fZGwPXrMCvXXvh9Ul7cddURgPYUp/LvvPPE4fjwCd/4K7Zc2AF9hxYgTMmd8fgTnyQammodegZRl9/Oj468nLpNTsuXYTLX/gLemxej60l5fjT7y50qXcePLiLEV1LMKVvOzzy2VqM7FaCBeeMQ/Byvv7YPbMH4MtVNXjqq/W6+08c3wX920dwzVsrAABPHTkEJ7z4oyt99+DBCUSDfmiahpGMu9SxY7vg2LFdJHc1IZ1OI1nXYHufKgFUtvMBSKK0PIiaTTGUNmxEQ2MSJbF6BGP1SFd2zFqjtHQaaZPmi3tvvBJv/+tVXH3XQ+jesw9euO82nHfsgXj/9XfQpbQMQBpl9bWoiZaismYbAODjBV9gx2EjuHa+/3ExKsrboXd3Xqi8a+4juHvuI9I+vHDPw5g8djwAc/FJGey000646aabEIvFEA6bv99DfniC0naMfb94Cv+ecEKxu+EI2m/bitJYA45751UAwOTFX2N5l574vn9OgFxwzlj4NODSN5bh/F17YicDV7nMIjykc86kft2Mvli4rhZ7Dqh09iFsQu9D98p7jQZkLXLta3L+zv5kEtO+/h/eHL+rU93z4MExDO9Sgh/W13G/nTapG86e0hMX7NYTfSrDCAjpbA8Z2RFnTe6BhkQKQztHsdfASqytacTBTy0C0JTF65RJ3XDNWyswfVAljh/XVSco/fXQwVi1NZYVpjx4aCmoiPixtYEvCtrDQixtsq4BfyvbzWq3CsKgJa9DK4kiEouh47YqrO7UFGbQZcsmrK/sKL03Ub0F/3j6MVx9x4OYsufeAIA7rrgeu3z0Hv7x0nM4+/iTAACdt1ah/bZqBFJNStUVa35Dt868APn9T0swYrBeOf27Q47AgdP3kfaje+eu0vP50LNnT8RiMaxduxZ9+/a11JYTaAvVszxBqY3g6ul9sGJLDHO/WKd8T4fxwxzsUXFwzTP3oDYcRcearbpzl770CBpCYZxy3o0Amgq1hgM+PH/MDtlrpvRrh4+WVWPu4UMwgHGzY3Hl9D6Gv7dU+Px+7DrvVnxwyCWm7x3023JMWvK1Jyh5aLG458HrcO4frgIAHL1jZ1yyey8c/+ISHDKiE67duy/m/1yFB/63Bi8v3ASgSXsOAEMZ5cfYHqVY8Fst/nH8sGyR55KQH5fvpZ/rGjT0aBdG7fW7IBrUW5VfPXE4Zg3viGQqjXaRAEZ3L8HTR1yHJ2c0udBoqRSOfu81PLfnbHtfhAcPCth89WTc//FvePLL9bh2Rh/4Nc2woHlrgoY0Qok4OlZvQSCZQEmsHgAvKJXV16E0Vo9MlFPjN18gEY9jzMSdAQDdN69HJJ3EuBGj8NOvS5k701khCQAaYg0Ih3jB8vsfF2OkgaDUvqIS7SsqlZ6hYlh/petERKNNni51dXV5riwOupQGsXZbY/bv1lhnyROU2gg6lATQv0PElKAEANPfexhv7X6aQ71yH4N/W06e8yGNHjv0xrbrdkEqnTbM1PP+aaPRkEihpAWmJ7WCXgftYer6ypqt2FJWgfE/f4/yulyV7fv+ci3OPuNqm3vnwYM6Tv7P3/Dh8AlY0rup5EGnbVuy5/pWhrFjjzJ8d/747G/TBrXHtEHtccP8FZj/8xYcZ+BO9NEZY/DTxgaM6kYHY/9+Yjf89fO1uHC3pkxX7Bpx1i7dcf//1uBvx+6AWcObGDS/T8P5uzZdO+K2o/HkmzEAwJDVy7D/5+9ih5W/oCTWgA0V7XHLEacX+DY8eMiPA4dUYHTvdjh4RCf4fBrOmdIT50zpmf9GBfhLIjiixvlkQKlEElXf/sT9tt6vIQagvL5pj2pXty17LhprQH2YiSlOJeFLpRCJx9BrwxosSTfZOjRNQ6Qx1lwbqcmVUJZcokNFe2zZxmeZW/jjEuy76566a8243gVKo9LrKGzevBkA0LmzPha9JSAU8GFczzKk08DG2ng2w2FrQuvrsQcOmgb0rgjjxHFdUR72ozGRwmShlo8MHSYOd7B3LQ+Tn76WqxouwufT2pyQBDRtBgNPPhC/PPZPpetvfOIOLOk1AON/+h7+dAonvDUP7Wuq0cHAUufBgxOINDZg0OrlnLssAHSt2ogzXnsGD888Gvt+yTNoMgbniml9cMU0Y2twNOjH6O7ydLaPHjYY9x800FDBcu/sgbhqWh90JgKXu03bCf5/v4ekz4fhK5qYvYFrVwIAuldtwA4rf8Hi3rmC1ZMWf43Rvy7Go/sdBQDoUrUR69t3kvbPgwcjnD/vMdz+w1/hCzrD7mmaVjCTbxbRzu0Rr8lZTrpXbUQiEEAwEddd22XLJtSHI0hrGmrDUVQ2u5T7UikEkwn0790HoWAQiz98FzvtOQ0AEE/E8fWihTjtqOPJPowaOgx/f+P/sn9vq6nBijWrMWJI4a53Zf0LF1q///579OrVC506tdz1wadpgIail0spFJ6g1Irx7XnjMLJZA5phEE6Z1N1UG4FoBL0P2RMr571je/9aGrrNmIT2owcXuxtFw9g7zlMWlCrqarDTj99m/97nqw8lV3vwUDg6b9mEDc3xBKOXLsYBn72Nzls3o8O2LQikUvi+72B8PngU3ho3FQAQaYyh07Yt+NOLD+ra2r1/haN9NRKSgKb1lxKSMlh84VjcuN8V2N2gBtx5L8/FpzuMwdy9DwcA+NIpdNpalT1/16M34thLWl5hSQ8tE8e+/U88u9eBAIDue09yTEhyG5HunRD/KRf3pyFtKCQBTXOotKFJqCqrr9WdL42WYM6hR+KOW65Fn6Afvbp1x31PPY76hnocdyCdaW6vyVNwwwN3Y0v1VlS2q8D3Py2B3+fHDgMG6a5Vdb0Ld9SvWzU1Nfj551wm319//RVff/01OnTogD59cgqfDz74AHvvvXdeGh4KR+tI2+XBEKO6l0LTNKUaBDIMOesIm3rUsjHl+RuK3YWiIlRRBn8BWXVETFq8wIbeeGit6Fq1gTw3aPUy7u+H7r1Cd81dD9+AB++7Eod89B/c9fANuPuRP2fPTf2hKc1/l62bEWiuYTJy+U+Y89Y8HPPOq5j+1YcY0GyJyWDvT+Zi+R8n4o2TRmCfoe0tPJmzGNStHW575DQEk0ndufKGOkz/+mPM/vgthBtjOOzDf2PEip9w/FsvG9aHu/qZe7PHdz90vSEj6GH7wYH/+y/398wv3sse99hronh5q0WooszW9q486wLM2msGzrj6Mux1/OH4ddUK/O3eR1DZjla4DB80BDsOH4FX3voPAGDhT4sxuF9/XdySVXzxxRcYO3Ysxo4dCwC44IILMHbsWFx11VXZaxoaGvDyyy/jlFNOsZW2Bx6eoOQB7Yb1K3YXHMcBi19CuGNlsbtRdEx7W6+FN4vT/vUCLpj3GM555QlMWrwAj9zzJ1z4j7/a0DsPVjFdsPzt8sOXxJVAv3WrdL9d99Td0r8B4M5Hb+L+HsjEBZ785kvYt5lJa79tK8ob9AHGlTXVaFdfi0M/+g+6bG3yr5++4CP0Wf8bJi75Vnd9Bvt//i7mvDUPolqo06SR6NM+gn2HdiDvbSnoOHEE/CXGSWIA4MgP/oVH7/kTulVthAZg368+0NWHi8QaMOS3ZTj9tWdx6r+eR+fqKnTfrE9jfkxzxk8PbR+Hf/gGrnr2XvTcuBaXvdC0xofiTQH0E3rIXUpbG6wohu+/5kY8fft92b8j4TBuuuhyLPnvh1j90QK8/tdnMG7EqLztXHjy6XjkhaeRSqXw+yOOxQcvvFJwnypH6i1RALDHHnsgnU7r/j3xxBPZax577DFMmjQJO++8c8H0PeRH27DHbofY0cbFL9qtE/odPxPLnv6XbW22NLQb2q/YXWgR6LRz/k0gH8KJOMb/vBAAMKnZPW/M0sUY88sifDOw7WVSbE2Y89a8rItau9ptOPadV/G/4U2JDXpsXIuxSxch6fNj2tf/Q4/N63H8Rbch5cvF5A1cuwJXPncfHt/7cPzuv//AwLXG6a0veekRPLPXgTjtX89jwJqVOP6SOwA01TI58v1/ofeGtRjz6yLunr2//ACTlnyNUDKha2/Of/9R0PPu8e9781/UwnDQiv/DPzrNIM/70ynD30cs/xEL+w7Bnt9+AgDYlRGCz/y/Z/D8Hgfg0x2atM9dqzZi5ufvYmGfwWhXX4NdfvgKtxzRdpL2eOChARi6ehluffzW7G8P3n8VYsEQhtz8dvE65gAC5aWIV9fkv9BBzJiyG5auWI4169ehZzdz4Q4i/JHCLVHBYBD33Xdf/gs9WIInKLUCVEYDqIj4sbyqKSvL80cPxYzB9rqYVLRhq9L2lrCiGPCnU7jkH49iQ7v2uPvgOVjWtVexu9QmMa5nGaYPqsS5U3sgEvDh/v/9hhvfWYlYoimD0/T3HsZRF7+IF/Y4AKf8+0WuhsU1z96H0lg9197D916JbSWluOfAE1FR25QxaodVv3IMVwaX/u0h9N6wBgAw5tfFGPPYYgB8nQwt3ZSmd4/vPs3+dslLj+DnHn1x8EdvGhaHtoIe+0y2tT03EGxXmPvQ+S/PxeJeAzBqmb64befqKpzz6tN4ecMa/H3XmZjz5t+hAbjkH4+S7V32woPoXrUB5zSnVhcTRtz615txye//CKBJ8FrnJZNoVYjEG7HLbWdZds1vaSjr3wNV3xS/wPNpR9MJH9zCqaeeWuwubBfwBKVWgPOn9sBFu/XCYc8swuzhHXHUjvmrZZtFtHvb3QRnvC9Pz7m9Yb8Fz+CNscc50nbn6ir8+ck7vcDzAnH4qE745w+b0JhMY0q/dvhpYz3W1zQFK6+9YhI6lwbh8+UYn6um98WRYzpjh9u/RFnIjy67jcOsz07DPl99gFAiji2luSLKWlovpJQ0NqCksQF/fpL+Xrf+9WbURkow5Ldlhuc1NCVhqImWoIeBC9iYXxdjzK+LFd+AOvb57Anb23QDvmAAU1+6GR8e/kdT90UbYxi7dJH0moM/fgv7f/auodVu928/xXujJ2H00kU4+9WnUNKcDvn+v1yDcGMjShobuHnbk/mW570yF3/Z/1is7NKDa/O6p+7CVSecb+o5PFjDI/f8CX+fui9+6DMIGyo6oGN1FXlt5yljXOyZO/AFA9B8PqRTxpbX1oSS3taKzXpwB56g1AowsVc5SkJ+/OukkY7R6HfcfvhkznWOtV9M+COtu5ie3Wi/oz6NqZO44ck7ccWJF7hKsyXiDzt3x4OfNFlkRnUrwfV798NBT/3AXfO344ahPp7E0k0NGNGtFAvX1mLkXV8BoFOrDu1cgp8vmYAuZcHsb6HmTFCVtdsw+YevEEglUdLYQPZNpnPuaSD8iLjk74/kbcdO9Jy1KzpOHOESNfvR57BpGHbRcVh0+zO2t20kJAHA796ah7G//ICRy39EtFlIAoD2NdWG1wPArE/mY2tpOXpvWIO0YJmorKnGgLUr0W/dKtSFIuiz4Td8MWS0PQ/hQYceG9fimHf/D6Wxepw4/2UAQMLnh49w1Szt2x0dJ7RNb4p2w/pj68Jfit0Ny4h0bvlxlR48QanFYtawDjhjcndsiyWxrwuZnHyBAPqfsD9+fep1x2m5ib3eeqDYXWiR2P+Hv+H14c5lOzzj/57B4/schnNfeQL9163CeS/PRV04gi8Hj8SXg63HSbVG/OXgQVlBKRLwoVNpbvl94KCB2GNAU6alaNCPEd2aYhBHdCvFP08cjp7t5H7sAzvm6pjs/ekTeHPS77J/n/Wa/cy4CLede3Z75XaXKdqPsbedi2XP/hv1aza6Qi+UiGPiT9+Zuueo93P7wYSfvsOqzk3xGH3XrcKpb7wIDcD1T94FaIAvncaZZ1yDLWVNdfzO+eeT+Lb/UCzsMxhdt2zE9/30CpqRy5YY/u4hh0M++g9G/7rYsJh6IKXPoJhBr4N2d7JbRUXAhuytxUZJzy7QfG3LLbKtwhOUWihe/Z372tIdbz6rzQlK3abtVOwutEhUDOvvaPtTFn2FyYsWZGNSMgza7t9/jrsOmoMvhrRNYWnaoErM/3kLAGBwpyiWbq5HklH4HjyiI15euAkX794LE3uVo3dFGP06hHHG5B7GDQKYPbyjqT502qn1WlpUEKwoa6q03QYw6tpT8dmpNxa7G1nMefMlzN37cJz6r+d15w7+33/Rc9M6jFj+EyrqcsH0PqSzgWqse+ekJd9g0pJvkEaTIP2/YWPxwCw+ruOyvz2cdfcraahDXaTE9mdq7Tjg07cRJmoFyTDqmrYdv1IxYgC2Llxa7G4UjFD7dsXuggdFeOnBPWQR7d4JZQPbThD+nv/xssHIEOnirNmfCtw/6c2XsPu3uWD/ULwR1z/VNmKa3jplFF45YTgu3r0XFl84HudO4Suuv3TcMPx66UQcProzQgEfll46Ee+dZr+70o43n2V7my0F0997uM0EqA84aXaxu8Bh+tcf47G7/ojdv/9cdy6QSmKXRQs4IUnEua88gfK6Gpz++nPZ3zJfavKiBTh/3mPkvVc/ex/Gm7R4tTXs+c3HeOCBq3HfX67N/ka51slQNqg3QpXl+S9sxQhE6TT7LR2BaMRStjsP7sITlIqMnu1CGNo5mv9ClzD1xZaj3bSKTjs7F9PVFjDr53lFoVtRV4NT//1i9u9umzeg85bN2b9HL7U/8N9uXL5nb1w9vY/huQNHdMStM/vD59OwU2+eWfH7NPTrkNvgA37rBaONMPzSE21vs6WgcvTgYnfBNvj8fkx6/Mpid4NDpLn+TiEYvGY5Hrz/Kuy68AvdOQ3AhJ8X4vfNc//QD/8NALjp8dtw6d8eRq9N67g4qNd+NwJfnL0jHjhoILZeOxk37dtP1+aJ4+1PbOQ0+hrULzt/3mN45J4/4ff/eQmVtdvQoWYrTvzvPJz8778ZFijOhx3OP9qOrnpwCKUDeua/yEOLgScoFRnHjO2CuYcPyf596k7d8PnZOxatPx3Gt406OAN+d0DBaXi3FwTLi1uI8Irn7sfopYtx7qtPIhLPBZef/8pclEm01sXC52fviBv26YvR3Utx0W49MbIr7yZ0x/56d8YjRnfCk0cMwQ8XjHerm1n0P3F/12k6jfH3XtRmrEkZDJwzG8E2pP3P93X2/PZTPHTflTjkf28CAPpsXIPRy5YAAK45dzoAYL+h7bH/sA4Y36scZ0zugXaRgGGs7hNH5OKbhncpQTTY8liaAWtytchC8Ub86YW/ZP8+4NO3cc0z92DCzwt1qfv3XvAh9mqumWUWg/9wWGGdbWUo6dX6ssYFSqNtIsZqe0LLW1XaOB4/bDBC/txWMrVfO0zu2w4fnD4aqy7fCQ8fOhgTerWdTbNY6H3YtGJ3oVVgzE1nFo32sFVLcenfH0G3qo0IJpO4ae5tuHHu7dmMbcXCeVN74JUT9NmiJvQqx5/26oNvzhuH9iVBHDqqE+6eNQD/O2MMGm+cggt207utapqGE8Z3xbCu7sdeTPyLufTTrQGdd2mbWdUO+OFvxe6Cqyivr9X9Nvb2czFrt8FYdflO+D+DGN0de5Thg9NH66y0H58xBrfs1w/fnj8Ol+3RW3ffVdOMLb9u4fqn7xZ+ye3/e3/5gWGSBqtoa8oECtFu5uI3WwJ8oWD+izy0KHiCksuYM7Eb6m6YgqWXTsQrJwzHrGFNcSJT+1egZ0XL0DKMve2cYnfBMjpMaBuWMacx5MzDi92FLPpsWIO+G35r+oPZ6I9/62Vc/PdHcdzbr+Dmx2/FFc/dj65VfKawwxvXZI8fP2ww9hmi1z5vuGrn7PGbJ4/EXgMrsn+/PmcEPvzDaNy8Xz/cNnMADhzREcv/OBF/OWggAGBfg/Y0TcO5U3tict92CPpb3lIaKImg/Y5D8l/YSlA2sFebsXiLiHbvhPH3XlTsbhQVQ84+EgDQsyIMP5ENbGr/Crx64nAcMboT3jqlybV6577tcMkeveH3aehdmdtDR3cvxSsnDMe1e/dFr4qmeJA/7dUb/drnrhn3a64uVe/1v+ECgxiqiJBWPypYfjKY8ON32Gnx1zjyvdfQecsm7txprz+HcGMMF/7jMYQZ18ayhjrDtqxg+nsP296mB/ugtcC9woMcXta7IsDv09C/QwT9O7TMYMRhFx2PBRffW+xuFIwhZx2BaNfWp2kqBvwlLXMMnvrGC7jzkJNx1Lv/h32/+gAAsCNTbPPOR2/kimO+cPuhmPDBb/hiVQ1OGN8VX6+pxX9+5AsxdioN4qARHbF4fR12H1CBW97LxQrM3KFJYTGlX0546tM+gtN37o49BlRiUKeW+Z7yYczNZ+HdfVu/4gMAdm5hsTx2Y+jZR+LLc1p/2vNCcMCSv8OvqGnvWh7Ci8caC8zHj+uChetqsfuAChwwLLcH/HjxBGyuS6BnRRixRAq3v78aAPDezTNR/vCvAIBgMoHyOr2l69G7/4Q/nnQxVnfqhrNefQrBRAJ3HXISgKZ4o72/+giTF33FZaarqN2GR2bm4oR2W/gFpv7wJXzNWQHveORGpHxaQdns8qHLbuNsb9ODfSjpaX9c3aZNmzBs2DB89tln6NevHwDgtNNOw7Zt2/Dcc8/Jb7YRhx12GHbZZRdccEHbqpvYokXbm266CRMnTkR5eTm6dOmCgw46CEuWLCl2tzy0cIz58x+K3YVWA5/fjxn/ozNRFQvjf16Ix++8FLM+e4e8ZmCzy0qFLwWf349L9uiNvx03DH6fhmtn9MWRoztlr53U7K4z7/hhWHjBeIQCPqTTxln5WGiahmFdS1qkxUgF5W0ki2W0R+ftggHsd/zMYnfBdQw550i0G9LXlrb8Pg237T+AE5KAptpkGY8NdtqXDeiFE7s0JUs44v1/6dobtuJn+JDGtc/cg+ueuhs7L/6aSzhx45N3Yo/vPlUSeHwM4W5bNqLH5g2mns2DMcxYzc+65nJ0mjhC9++Is91JpR5sVwpf0H77xE033YRZs2ZlhaTMb48++qitNPLx41dddRX+/Oc/o7qaLmLdGtGid//33nsPZ555Jj755BP897//RSKRwN57743aWr3Wx4O9aK1uIN33newlcTCJzpNHI9iuuIkdjJCP+TjvlSewzxfv47MLJurOVUYDeOHYYdhw1c6464ABePV3TTFHmqbB1+zWc8GuTUJExv21LaJ8UG90njKm2N2wjGlv/yX/RW0Ak5+8pthdcB1jbznbVXoTevH7w9wLdsejd1+OUct/xMA1K9B7/W8Y/9N3uP8v1+CyFx8CAEQbYxi4dgU0AGOWLkLXqg2YtHgBSWPSkm/QsboKuxqkWXcSe83fPuYJC83vN3X9tMlTsfCNd7l/j/z5toLpN5rIElnaj66XVyjq6+vx2GOP4fe//z33e4cOHVBaat++rsKPjx49Gv369cOzzz5rG92WAC2tolZtIdiwYQO6dOmC9957D7vttpvSPdXV1aioqMDWrVvRrp1X4MsMntP0DGhLx8irT8HoNl5ozwl8/+fH8e0VDxa7G6ZxwOKX0G5ov4LvX7klhh7tQmRMRFvAD7c+ha8vbd01xY5Ju8twFhOtcd0tFPt8/iQ6TtAnTnES6XQaT321HhN7lWF41yZGsubX1Xh1wEFN55E/c18KGlknzsw1dsONedLQ0IBff/0V/fv3RyTSMlySt/2yCo1V+a0YZ11zObbWbMPTtxuvh2Nnz8BpRx2P0485IfvbHsccgv32mIZLT21KfDT7tN9h2MBBCAaD+Nvrr2LogEH4v0eeRKyxEdfceztefvMNbKutwY7DRuD68y/FuBGjsveNnbwTAOCZZ56B3+/HH/7wB1x//fXZ5Bv//ve/ccMNN+D777+H3+/H5MmTcc8992DgwIHkM82bNw+nnXYaNmzIWSiXLVuG/v37Y9myZejb1x5rrQiKH7/22msxf/58vP/++47QNQPZWDUjG7Roi5KIrVu3AmiSlD04j0GnHlzsLpjGiD+23foxTqLrHu6nr7YDVoQkAOhdSQeOtxUMPv2QYnfBEnrMnFLsLriKfb94qthdcAVlA3u5LiQBTVblE8d3zQpJAFDWvydGXdukYFNZDVQEILeFpEl/vcJVehmk02nUNiaL8i+j549275Snl/bihdf/iYDfj9f/+gzuvPxqAMC1996B/3v7v7j/6hvx9tMvoX+vPjjinFNRtXVL9r4nn3wSgUAAn376Ke69917cdddd+Otf/5o9X1tbiwsuuACff/455s+fD5/Ph4MPPhipFF10+P3338eECRO4377++mtUVlYaCkk33ngjysrKpP8++OCDvO+A4sd32mknfPbZZ4jFYka3tUq0mmQO6XQaF1xwAaZOnYqRI+lCorFYjPtAbc1X0k3s9PDl+PmRl4vdDWX0PnQv+CMtI3Nga0PnKWMQ7liB2Katxe6KMtoNdUZT1tYQbFeGXgftgVWvvFvsrhSEXZ69vthdcBUdxg9Dx51GYNNnC4vdFUcx40P74ifswKirTkG8uhaL72idbkMDTz6wKHTr4imUXfm/otCuuX4XlIb88JuoS/Tmh++h7268YHH2CSfjot+rxzYP6NUH15yTC0+ora/D3H+8gPuu/jOmT9kVAHDXFdfi3dkf45lX5+Hs40+CLxhA7969cdddd0HTNAwdOhTfffcd7rrrLpxyyikAgEMPPZSj89hjj6FLly744YcfSL532bJl6NGDd+n75ptvMGaMscv16aefjiOOOEL6fD17ygviyvjxnj17IhaLYe3atY5Zs9xGqxGUzjrrLHz77bf48MMPpdfddNNNuPbaa13qVdvHbv+8He8f2DrilSY9+qdid6FVo/OuY1sVMz3zuxeK3YVWgx4zd2lV3zaDSJcOCLWhYqyqmP7+I3gx0nYtaXu99QCi3dy1Aqig98F7tkpBacyfzyh2F4oKTdNQ2qcbaleszXvt1PE74bY/8hk027erIK42xphhfJ2vZatWIp5IYNKYXMKZYCCIcSNG4adflwIA/JEQdh6+M1fjavLkybjjjjuQTCbh9/vxyy+/4Morr8Qnn3yCjRs3Zi1JK1asIAWl+vp6nVvZ119/TQpKHTp0sOyVJePHo9EoAKCuzv7U98VCqxCUzj77bLz66qt4//330auXPIvTZZddxqUmrK6uRu/e+iJ0HtTQa/buxe6CMkLtvRg0Kxh19e9bFTPtRPagtoqBJx+Iz069sdjdMI19Pnui2F0oCvzhEKa8eCM+OvLyYnfFEXSbtlOxu2CI1lp/b8Tlc4pGuyToQ831uxSNdga+cEjtnmgUA3obWzp8mg9pwWUynkjorittFgYyyLgAinV+0+l0UwKhoFrq+1mzZqF379549NFH0aNHD6RSKYwcORKNjXTCiE6dOqGqii+F8c0332D27NmG199444248Ub5XvDGG29g1113NTyXjx/fvHkzAKBz585SGq0JLZrTSKfTOPvss/Hyyy/j3XffRf/+/fPeEw6HEQ577lfbG4ZddFyxu9Dq0X7HoYh06YCG9ZuL3RUPNkPz+bDX/L/g7WmtR/M86fErUdq3e7G7UTT0OWwaPip2JxzAiCtOKnYXSPjDIUx6/Ep8etL25e5pBZqmoTRkLvOcE7Ajc2vH9u2xbmMuKcK2mhqs+G113vv69+6DUDCIT77+Coft2+QGF0/E8fWihTjtqOPRblg/AMAnn3zC3ffJJ59g8ODB8Pv92LRpExYtWoSHH344K6Tk86ACgLFjx+KZZ57J/l1dXY1ly5bZ7nqnyo9///336NWrFzp1ankW40LRogWlM888E8899xz++c9/ory8HGvXNplVKyoqsuY9D85j6HlHY8ndzxe7GyQqRw/Gjre2jaKaxcYuz12Pt6efWexu5MXEB/9Y7C60OnTbq3VlUxs4x1gjur1A8/kw7JITsOjWtpXcYcz1LbvOXf/jZ7YqQan/ifsXuwstApqmIdyhArHN8jjbxsZGThgCgEAggI6V7bHrhEl4/rVXsM+ue6KyvB1uevg++BRq6JVGSzDn0CNxzb13oH27CvTq1h33PfU46hvqcdyBh/x/e3ceH9O5/wH8c2bLPklmsu+IRHZLhFiDLEQT1E6D2oJeVcRtoxtaS9PNnkvqKve2Qi1XiyC1+6kImtT2+6lWGpQiUiESITm/P1yjk3VmcmbOzJnv+/Wa10vOPOf5fmc8mcxznuc8j2oz5WvXrmHWrFlITU3F2bNnsWLFCnz66acAAEdHRyiVSqxduxbu7u4oLi7GW281/XcuISEB6enpKC0thaOjIwoLCyEWixESElJveV2n3mn6ffzYsWOIj4/Xun5jZtQdpczMZ8sVx8TEqB1fv349xo0bZ/iEzFTA34YZdUep79l/qc37Jbpz6xMFkUyKmirud4znUquJ/Ny4bOoYsRhsdTXfaTTJ3BZwaEjQnBRBdZRicpbxnUKTRBKJSXVQwz+YwncKRkPmaNdkR+nAD8cR0i9G7Zi/bwuc3LoLb4ybhKIb1zFq5jTIbW2RPmU6im9c1yj2u3+bhRqWxbT30/HwUTnaBoVgy/K1cPjL/U9jxoxBRUUFoqKiIBaLMX36dEye/Gy1RZFIhOzsbLz++usIDQ1FYGAgli9fXuf7b21hYWGIjIzEli1bkJqaisLCQrRp04bzmVWafB+vrKzEjh07sG/fPk5j882k9lHSBe2j1HyPS/7ENqc4vtNokDntsWIIpYWXkdN2NN9pNKj/xS2wD2p6Gi6pqyT/AvZFjeM7jSbR7/QLBekrcXHJBr7T4MSQPw9BZm/8G4I/efgI39iZxv25A4q/g423m8HiGeM+Ss+xLIt7Zy7xnYYaeZsWkNpaISYmBm3btsXSpUs5j7Fnzx6kpaXh/PnzEIn42/Vn1apV2LlzJ/bv389bDn9llvsoEX5YKB3gO8I4h1J77V/JdwqC4xgRwHcKDXLu1pY6Sc2g7Fj/dAxivELfm8h3Cpxom/G6SXSSAEBqa42h9w/xnYZGrDyEc9N8czEMY3T3NUpt9X+bSGJiIlJTU3HjRtP3U+mTVCrFihWmvbl5faijRDTiNdA4r665x3XiOwViQE5dwvlOweTFn1zPdwqNSsgXxugJVyRWlnjp8ja+02g2U1twRyo3/k5dty2LIRLzv5CCMbFwcuA7BRVrTxeDxZoxYwbvKzxPnjwZgYGBvOagD9RRIhpx7taW7xTq8BoYw3cKgqXoGMx3CvUK/nsK3ymYPKdODW/YbQzkAT58p2B05K1N+z2JWpNukveRdt/2Ed8pNMq5Rzu+UzA6DMNAYmUcUwKt3F+s/Hb48GG9TLsj+kcdJaIRa08X+I5K4DsNNd23Z/CdgmD1+X4V3ynU4dytLSyUDnynIQhtl/yN7xTqFZT2iklcyedDt63G/aW9MS0nmObiK94v9+Y7hQa1mjAAVq5KvtMwSrb+tHcm4Q51lIjG2n08g+8U1JjiFUpTYYxfVhkJTTHhSvCbY/lOoV6eSfVvckgAn8HG+6W9MYNLvjfp6WF2RjqaF7HY+Ldx4IvYQrMNXvXJ0kX7JbiJcaKOEtGYtYcznLsbx1C/t4l+aTAl7T4xro5x1D9o7yQuDfo9h+8U6jCWzxdjpTTyaZO1ucR0gIXCvumCRizueBbfKdTh2isSls6OfKdBGkGLbAgHdZSIVhgNNl8zBLqapn9Bs43n5msLpT3kgX58pyEof50/bwy6fbOERomb0OdgJt8paKVr9kK+U2g2SxcFIlf9ne801NGvSZMMuZBCbTJHOUQ0A0IwjONbLzEZracO5jsFAIAdzUE2iE7/fJfvFACYxkaVpHlolLhpEmtLRG+cz3caGhPKPTQB04Yi8ZzxbLreetpQvlMwenxeCLJQmvYoKlFHHSWiFd9h/G882+mf79KVZwNp9Woy3ynALyWR9v/RE7fYKL5TAAC49+tCv9MaapGSyHcKGumYKaypsg6h/nynoGKq96sZHj+fKSIZ//dIEe5QR4lozaaFB6/xjXklIiFqv3QWr/E7G8molhB1/Ec63ykAACJXzOE7BZMS8s54vlNoUuspxjH7QGikchu+UzAZDmGG79yKLWSQWBvH8uSEG9RRIlrr+d1nvMX2nzzIZHZ3FwrPl/hdiUwkkfAaX8isvV35TgFSuQ3sWnnxnYZJCZ+fyncKjTL2TY111a/gK75TQOTqN/lOwWTwsfqdzMQXLyF1UUeJaM0hpBVvsUPfm8hbbEKERiyTGs19aERzjEgEn+H8T4Ouz8iaU0a/qbGujOHe2Baj+/GdgklhRIb9mitTyA0aj+gfdZSITkLfn2TwmIqOwbyuZGOurL34e8+Tft7OW2xz4TM0ltf4Pb79lNf4pqrdx6/znUK9hHyvmcTGCiFzX+UtfsyepbzFNlUO4a0NFktiYw2JlYXB4hHDoI4S0Un4vMkGjym2pA8gPogtZIjKepuX2MZwBVfopLbWaD1tCC+xJTZWcO3ZgZfYps7G2w3+qS/znYbZ8Z88iLfYHv268hbbVBlymW5bnu/fbkxMTAzeeOONZtdTUlICFxcXFBUVqY6lpqZi1KhRza5bG0OGDMFnnxnmNhDqKBGdGXqkoVPWXIPGIy+49KCNQIWMr45SwqkveYkrFMa2spwxLaGtLza+7vB+uZfB4wa/OcbgMYVCKn9xX/Mfd+9g7ieL0XFQX3h2bYeghB7oP/EVrN+2GY8qK3SOIXOwg9hSxkW6Rm3x4sVISkqCn5+f2rGsLO42Zs7MzER4eDjkcjnkcjmio6ORk6O+Qfp7772HhQsXoqysjLO4DaGOEtFZwumNBotlH9KSNhzlkTzAF669Iw0aM+7EOoPGM2cOIa1gH9zCoDGj1s6FfXBLg8YUGoZhEJRmPBtD2/N4/6oh8bFaZNsl0w0eUyhsWz4b6Sm6fg29XhmCQ3kn8Pa0N3Do31uxbdUXmDJqDPYdO4wjeT/oHMPGz52jbI1XRUUF1q1bh4kT1e8VVygUsLHhbjVGLy8vLFmyBKdPn8bp06fRu3dvDBgwABcuXFCVCQ8Ph5+fH776Sv8LrFBHiejMkJsJ9thJ9zHwrevmxQaN5xwdbtB45k7qYGfQeP6T+JvCJCQh70zgOwUAzzaFFvL9SX9l6ewIl57t+U6DaOnvH30AiViC7zduxsC4vgho0QrB/gFI6h2P7KWZ6Nvj2UjhgRPH0H/iK2jZqzNax3bByJnTcPV6sVpdyanjkP7JIsxb/gn8+0TDw8sL8+bNUz2/ceNGKJVKPH78WO28wYMHY8yYZ6ODMTExmD59Ot544w04OjrC1dUVa9euRXl5OV599VXY2dmhVatWaqMpLMsiIyMDLVu2hJWVFSIiIrB161a1GOXl5RgzZgxsbW3h7u6OTz+t+/1Jk3pqy8nJgUQiQXR0tOpYUVERGIbBb7/91ui52khKSkJiYiICAgIQEBCAhQsXwtbWFidPnlQrl5ycjE2b9D+KTR0l0ixtP9L/VS6JrTUtH2wELJ0c4BQdZpBY5jCFx9hELJrGdwpEBzJ7W7jFd+Y1B9dekXBPiG66oIAETB9usFi9D6w2WCxtsSwL9nEFPw+W1ShHRizGvT//xKG8E5gwdARsrKzrL/ffjv6jygpMHTUWuRs2Y/uqdRAxDMbOmYGamhq18tm7dsLayhr71mcjIyMDCxYsQG5uLgBg6NChqK6uxrfffqsqf/fuXezatQuvvvpiQZANGzbAyckJp06dwvTp0zF16lQMHToUXbp0wdmzZ5GQkICUlBQ8evQIAPDOO+9g/fr1yMzMxIULFzBz5ky88sorOHLkiKrOOXPm4NChQ9ixYwf279+Pw4cP48yZM2q5a1JPbUePHkVkpPrMkoKCAjg4OMDX17dO+UWLFsHW1rbRx7FjxxqMBwDV1dXIzs5GeXm5WgcNAKKionDq1Kk6nVGuMaymLc1ElZWVwd7eHvfv34dcTss26sPXTEe91v/S/35D0+6MxK3v83Aw7m96jeHYNgD9fuR/vxJzpO/f5ef6X9hM0+449Oj6H/iP90u8xFZ2CkWCQPdNaoqhfl9GsfkGiaOJyspKXL16FS1atIClpSXYxxW49wY/bU+xdBcYCyuNyh7PPYju8X2wIWMZ+vd6sdJnQGxXPK569kV7/NCReH/67Drn3i29hzbx3XFs038Q5P9sFb3k1HGoqanGrqx/AQCUkcGIiopC7969sWTJEgDAtGnTUFRUhD179gAAli1bhuXLl+PKlStgGAYxMTGorq5WdRaqq6thb2+Pl19+GRs3Pru14datW3B3d8cPP/yAsLAwODk54eDBg2qdhokTJ+LRo0f4+uuv8fDhQyiVSmzcuBHDhz/rzN+7dw9eXl6YPHkyli5divLy8ibrqc/AgQOhVCqxbt2LafHz58/HoUOHcPjw4Trl7927h3v37jX23wJPT09YWdX9Pzx37hyio6NRWVkJW1tbfP3110hMTFQr89NPPyEiIgJFRUX1dtRqt9W/0qZvQDs5kmYLmD4cl1ds1kvd8T/8kzpJRsQttpPeY/Ax/5884zsiHr9l79d7HOokccvayxXB6eNwcfGXBo9t28rT4DGNRe/clXq/cES4IbF99mW89vTQ/V9mo4atwZR330RVVRUA4Or1Yiz+xwqcOfcTSu6Xgv3vSNL1P26qOkoAEOwfAACw+O8ms+7u7rh9+7bq+UmTJqFjx464ceMGPD09sX79eowbN04th/DwF1PMxWIxlEolwsJezNxwdX22Kfjt27dx8eJFVFZWIi5OfQ+1qqoqtGv3bMGlX375BVVVVWodIIVCgcDAQNXPmtRTn4qKijodjoKCAkRERNRbXqFQQKFQNFhfYwIDA1FQUIA///wT27Ztw9ixY3HkyBEEBweryjzvYD0fbdMX6iiRZotcnqa3jpJTZ8NM9SKaE1taoLpSf0PdjMg87nMwRlFr5+q9o+QQYbh9TcxJxMJpvHSUAv42zOAxjYUhLhz1KzDy0XWZJRRLd/EWW1OtAwLAMAx+LvoVQB/VcT+vZ1tQWFq8qGv0rNfg6eqGz9+eDzdnZ9TUsOg2YgCePHmiVqdU8uwr9POFHBiGUZue165dO0RERGDjxo1ISEjAuXPn8N1336nXIZWq/cwwjNqx552qmpoaVd27d++Gp6f6BQoLi2fbp2gySUyTeurj5OSE0tJStWOFhYVITk6ut/yiRYuwaNGiRnPJyclB9+7d6xyXyWTw9/cHAERGRiI/Px/Lli3DmjVrVGWej1Y5Ozs3GqO5qKNECNGK76gE/PrPb5suqCNFhyC91U0aJ7WzQZevP8SJUe/oLUbfM//SW93mjI+FFCycHGjRFT1zjAjgO4VGMQwDaDj9jU9KpRKxvXrji282YeLw0Q3ep3Tvzz9x+eqv+DR9HqLbPdvj7WTBmXrLPseIGr7df+LEifj8889x48YNxMbGwttb970Bg4ODYWFhgeLiYvTs2bPeMv7+/pBKpTh58iR8fHwAAKWlpbh8+bLqHE3qqU+7du3w73//W/VzWVkZioqKGhxRmjJlCoYNa/xCSu2OWkNYlq1zL9L58+fh5eUFJycnjerQFXWUCCc6rJiDM9M/5rROSxfdhmyJfkWumKO3jlLkyjmN/tEh+uc3MgE/pi1Dxe93OK9bHugLkdhwG0Cam8Rzm7AnbKTB4vX+fpXBYhmrPgczcaD3VL3UHbnq73qp11xlrl2DLp06I3bMcPx90jSEtA4Aw4jw48XzuFL0KyLaBMNBLofC3gEbd3wDVycnXL91Ex+s/LzhSpu4QDF69GikpaUhKytLdd+Rruzs7JCWloaZM2eipqYG3bp1Q1lZGU6cOAFbW1uMHTsWtra2mDBhAubMmQOlUglXV1e8/fbbEP3l76om9dQnISEB6enpKC0thaOjIwoLCyEWixESElJveV2n3s2dOxf9+vWDt7c3Hjx4gOzsbBw+fBh79+5VK3fs2DHEx8drXb+2qKNEOOEez/0UhKSft3FeJ2k+ibXm0x20ZW4rZxmrfgVfYbsL93+Aum1dwnmd5AWHUH+0mjgAv3yx0yDxjH20wxBce0UiJmcZDvebwXndzt3acl6nOWvVqhX+Z89+fPTpJ/hw1VL8fvsWZDIZAlu0wrRXXsX4oSMgEomQtfATpH+6CN1HDIS/rx8WzZ6LAVPG1VunQxN7h8nlcgwePBi7d+/GwIEDm/0aPvjgA7i4uGDx4sX49ddf4eDggPbt22Pu3LmqMh9//DEePnyI5ORk2NnZYfbs2bh//77W9dQWFhaGyMhIbNmyBampqSgsLESbNm0ana6niz/++AMpKSm4efMm7O3tER4ejr1796rdU1VZWYkdO3Zg3759nMauD616Rzizw6MfKm7e5aw+Y1rph6i7e/Ic9keP57ROt9go9M6lK9TGgusVvRiRCCOenjSbvXb4wrIsNomi9B4nbP5khL03Se9xTIU+VsAbWXPK6H5fGltJzBTUPHmK0sLLnNWnjAxuskxcXByCgoKwfPlyzuLyZc+ePUhLS8P58+fVRqkMbdWqVdi5cyf272/4nlquVr2jOS6EM6Hvc/dHMyF/A2d1Ee45dQ6DXWsfTuvsmPkWp/UR49LxH28Z3Zc+IWIYxiBTtkLfnaj3GKZE2SmU0/o6/iOdfl/0QCSVQCTlZjKVbYvG76+5d+8esrOzcfDgQbz22mucxORbYmIiUlNTcePGDV7zkEqlWLFihUFiUUeJcMY+yI+zuhzC/Dmri+hH/Ml/clZXt60fwc5f95tcCfd6/OcTTuuTOdKIvqEETBuq1/oHXt9NX+JriTuexWl9Nr5unNZHXuCi7Srat4GF0r7RMu3bt0dqaio++ugjteW5Td2MGTOatSgFFyZPnmyw95TuUSKccenRnpOlo70GxkBsIeMoK6Ivz/eO4ILP4N6c1UW44TVA89WQNKpvUAyn9RF+tPv4dVh7uvCdhtERSSQIeWc8LnzIzQUkul9Tf2xbeeH+pavNqkOTRYeKioqaFYMYBxpRIpyK/veCZtcRuSKNg0yIIYS8ze19SsS4cLWHS7tPZtBqdwbWc1cjK3U1Q1Bail7qFYKID7hZ/a7dJzNoxE6PJDbGv5w5MR7UUSKc8n65V/POH9wb1l6uHGVD9C3iw+Z/MWAk9AXaWNkHt+SknoDpwzmph2jOPaEz53VK7Gw4r5PURb8v+mflrvveOzIHmkZsTqijRDjFMAx8R+i+rLBz1/o3LiPCFXeM27n9hDuMuPl/IhzbBkAskzZdkHBKJJFgeMVxTuscdH0Xp/UJUfLV5i3Nbh/ain5fDMDKw1n3cz31u8EpMS7UUSKci1w5R+dzHdsL54ZHc2Ef2vg+Ek1x6hzGUSaEa4xIhM4b5jWrjuaeT3QntrTAkHsHOKtPKrflrC6hsvXzQOupg3U+35vu1zQIhmHg0My/XcQ8UEeJcM5C6QBLN6XW59n4usO1Zwc9ZET0qd+P/9b5XLEVtxvVEe61SElscvf5xjiGt+YwG6ItmaMcbvHNn4YXzsE0W3MhD2qh87khc1/lMBPSGLGlbn9/RFIa8TMn1FEietH7e+03Du179l96yITom0giQctxL+l0bnM6WcQwGIZBh2WzdTpX13ZBjEv0xvkIpYVbNObeV7cV6176329o2p2Rs3J3gojuqzUr1FEieuEQot2Qds/vPuN0uWliWOEfTNH6nJC5r0Ie6Md9MoRznv276nRe5Oo3Oc6E6MKjX/OWmvYayO1S8UInb+2j9RS6FmP60+chD7R9zy1dFPpJhBgt6igRvdFmeVrPl7rrMROib9ZervBM7qFxeUsXBSIWTtNjRoRLti294BKj3bTYbls/gsTKUk8ZEW0E/G2Yzuf2/n4VpLTandY6Zb2tXfl/vqunTEhjpHbWGpe19naFSErbj5ob6igRvfHs3w3yQN8my8WfXG+AbIi+tf9spsZlm7syFDG8wOmaf9lOPLeJNhE2IiKJBH3Paj/NVeYoh1ufKD1kJHwyR7lWn4m0z5jxo9Ek80QdJaJX8XlfNnk106lTqIGyIfpk18oLbnGdNCorsaaRBlPjNUjzPdIcQv31mAnRhaJdIEax+Vqd0zZjup6yMQ+BM0ZoVC7h1Jf6TYQ0ytbPo8kyjhEBtAmwmaKOEtErmb0tIlc0vFy4/+RBBsyG6FtzNvEjxo1hGNgH676aFzEOXTYt1Khcj52foNX4ZD1nI2yMSIS4//miyXLKjiEGyIY0xMLJockyf51yFxMTgzfeeKPen2s/Z0glJSVwcXFBUVGR6lhqaipGjRpl0DyGDBmCzz77zKAx9Yk6SsQgaq9u1mvfCgy8tgsd/5HOU0ZEHzwSuzRZRhEZZIBMiD50+frDJsu89H9bDZAJ0ZWfhhuCeyX3BCOirwjN5dyl8U3UdVkhluju1q1bmD59Olq2bAkLCwt4e3sjKSkJR0+dbPAcO39vjevfvn07PvjgA43Lc9mxWrx4MZKSkuDn56d2LCtLP5u6L168GAzD1Mn/vffew8KFC1FWVqaXuIZGn4LEIOTBLVX/jjv+BdzjO8Pay5WGsgXGZ1hck/uAxB5Za6BsCNccIwKQkL+h0TLygKbvSyT8Svp5e6PPu/bpaKBMzEPv3JVw6dFO7Vi7j1/HKDaf7gEzoKKiInTo0AEHDx5ERkYGzp07h71796JXr15IX54BS2fHes+TOdhpHEOhUMDOTvPyXKmoqMC6deswceLEOvnY2HC/GEt+fj7Wrl2L8PDwOs+Fh4fDz88PX331Fedx+UAdJWIQYpkUL/3fVvS/uAXOXRu/wkZMF8MwiFg4Db0PrK73+V77V9L9SSZOGRlc770uYfMnY+iDIzxkRLRl5++NLl9/WOfLOwC4xXVC920ZPGQlXG6xnepcIAp4XbP7l4wdy7Iof1LFy4NlWa1ynTZtGhiGwalTpzBkyBAEBAQgJCQEs2bNwsmTJ2Hj645jlwrQf+IraNmrM1rHdsHImdPwyy+/aByj9gjR1q1bERYWBisrKyiVSsTGxqK8vBwAMG7cOBw5cgTLli0DwzBgGAZFRUV4/PgxXn/9dbi4uMDS0hLdunVDfn7j9xfm5ORAIpEgOvrFVgBFRUVgGAa//fabVu9TUx4+fIjRo0cjKysLjo71dy6Tk5OxadMmTuPyhdY5JAZDV5rNh1vvjrByd0LFzbsAAPd+XRCz63OayiMgiT9twp7wkQCAwDdGIuy9STxnRLThNzIB3i/3wjbneDx9UI5uWxbDZ2gs32kJ2qDfc/Dw1xtw6hIumNkUj54+ge2G93iJ/XDsAthIZRqVvXfvHvbu3YuFCxfWO8Li4OAAAHgMFlNHjUWQfwAeVTzCxxuyMGjQIBQUFECk5d+vmzdvYuTIkcjIyMCgQYPw4MEDHDt2TNXBW7ZsGS5fvozQ0FAsWLAAAODs7IxZs2Zh27Zt2LBhA3x9fZGRkYGEhARcuXIFCkX9K+8dPXoUkZGRascKCgrg4OAAX9+6370WLVqERYsWNZp/Tk4Ounevu3XLa6+9hv79+yM2NhYfflj/dOyoqCgsXrwYjx8/hoWFRaNxjB11lAghehGftx47fZIAAC1SEqmTJDAOYf6QOcpRVVqGFmP6850O0YHYQobBd3PBiBiIJPR1QN+s3J1owRueXLlyBSzLok2bNo2WG54yGlV/PkDl7VJYOjvgy/gecHFxwcWLFxEaqt0KvTdv3sTTp0/x8ssvqzorYWFhquft7e0hk8lgbW0NNzc3AEB5eTkyMzPx5Zdfol+/fgCArKws5ObmYt26dZgzp/7FsYqKiuDhob56X2FhISIi6p/BM2XKFAwb1viKxJ6ennWOZWdn4+zZs02OcHl6euLx48e4detWvR01U0KfjIQQvbDxdsOwh0dx/9JVKDrQAg5CNOC3b1Hx+x2td7cnxkMsk/KdAjFh1hIpHo5dwFtsTT0fxWlqJO+XX37Bu+++i5MnT+Lu3buoqakBABQXF2vdUYqIiECfPn0QFhaGhIQExMfHY8iQIQ1OV3se/8mTJ+jatavqmFQqRVRUFC5dutTgeRUVFbC0VJ/WXlBQ0GBHSaFQNDg61ZBr165hxowZ2L9/f51YtVlZWQEAHj16pFUMY0SXeAkheiOxsYIyMlgw00yIOqmdDXWSCDFjDMPARirj5aHN35XWrVuDYZhGOxsAkJSUhJKSEmRlZSEvLw95eXkAgKqqKq3fG7FYjNzcXOTk5CA4OBgrVqxAYGAgrl692uA5DXXoWJZt9PU6OTmhtLRU7VhhYSHatm1bb/lFixbB1ta20cexY8fUzjlz5gxu376NDh06QCKRQCKR4MiRI1i+fDkkEgmqq6tVZe/duwfg2VRCU0cdJUIIIYQQIlgKhQIJCQlYtWqVajGFv/rzzz9RUlKCS5cu4Z133kGfPn0QFBRUp/OhLYZh0LVrV8yfPx8//vgjZDIZduzYoXpeJpOpdTD8/f0hk8lw/Phx1bEnT57g9OnTCApqeGZGu3btcPHiRdXPZWVlKCoqanTqXUFBQaOP2vc89enTB+fOnatTZvTo0SgoKIBYLFaVPX/+PLy8vODkZPpTTWnqHSGEEEIIEbTVq1ejS5cuiIqKwoIFCxAeHo6nT58iNzcXmZmZuHDhApRKJdauXQt3d3cUFxfjrbfe0jleXl4eDhw4gPj4eLi4uCAvLw937txR6/D4+fkhLy8PRUVFsLW1hUKhwNSpUzFnzhwoFAr4+PggIyMDjx49woQJExqMlZCQgPT0dJSWlsLR0RGFhYUQi8UICal/M2Ndpt7Z2dnVmX5oY2MDpVJZ5/ixY8cQH6/Znm3GziRGlFavXo0WLVrA0tISHTp0qDMcSAghhBBCSENatGiBs2fPolevXpg9ezZCQ0MRFxeHAwcOIDMzEyKRCNnZ2Thz5gxCQ0Mxc+ZMfPzxxzrHk8vlOHr0KBITExEQEIB33nkHn376qWqRBgBIS0uDWCxGcHAwnJ2dUVxcjCVLlmDw4MFISUlB+/btceXKFezbt6/Re5vCwsIQGRmJLVu2AHg27a5Nmza8rDhXWVmJHTt2YNIkYayEyrDaLkRvYJs3b0ZKSgpWr16Nrl27Ys2aNfjiiy9w8eJF+Pj4NHl+WVkZ7O3tcf/+fcjlcgNkTAghhBAiPJWVlbh69arq4jUxHnv27EFaWhrOnz+v9VLmXFq1ahV27tyJ/fv385YD0Hhb1aZvYPQjSp999hkmTJiAiRMnIigoCEuXLoW3tzcyMzP5To0QQgghhBDeJSYmIjU1FTdu3OA1D6lUihUrVvCaA5eM+h6lqqoqnDlzps4c0fj4eJw4caLecx4/fozHjx+rfi4rK9NrjoQQQgghhPBtxowZfKeAyZMn850Cp4x6ROnu3buorq6Gq6ur2nFXV1fcunWr3nMWL14Me3t71cPb29sQqRJCCCGEEEIExKg7Ss9ps558eno67t+/r3pcu3bNECkSQgghhBBCBMSop945OTlBLBbXGT26fft2nVGm5ywsLHhZ5YMQQgghhBAiHEY9oiSTydChQwfk5uaqHc/NzUWXLl14yooQQgghxHwZ+YLJhKCmpoaTeox6RAkAZs2ahZSUFERGRiI6Ohpr165FcXExpkyZwndqhBBCCCFmQyqVgmEY3LlzB87Ozg3eBkEIX1iWRVVVFe7cuQORSASZTNas+oy+ozR8+HCUlJRgwYIFuHnzJkJDQ7Fnzx74+vrynRohhBBCiNkQi8Xw8vLC9evXUVRUxHc6hDTI2toaPj4+zd5Tyug3nG0u2nCWEEIIIYQ71dXVePLkCd9pEFIvsVgMiUTS4IinNn0Dox9RIoQQQgghxkMsFkMsFvOdBiF6Z9SLORBCCCGEEEIIH6ijRAghhBBCCCG1UEeJEEIIIYQQQmoR/D1Kz9eqKCsr4zkTQgghhBBCCJ+e9wk0Wc9O8B2lBw8eAAC8vb15zoQQQgghhBBiDB48eAB7e/tGywh+efCamhr8/vvvsLOzUy0T2LFjR+Tn5+tUH1/n8n2+qcYuKyuDt7c3rl27pvPy8LrGN9X3zJRjN/d8U43d3HZujp+JFNu0YtNnOcU2hdjUxg17rq7nsyyLBw8ewMPDo8l9lgQ/oiQSieDl5aV2TCwW69wI+TqX7/NNOTYAyOVyg8c35ffMVGM393xTjg3o3s7N8TORYptebIA+yym2ccemNm7Yc5tzflMjSc+Z5WIOr732msmdy/f5phy7uXSNb8rvmanGbu75phy7OczxM5Fim17s5qLPcoptzOdygdo49wQ/9Y6YN212XybEVFE7J0JHbZwIHbVx42SWI0rEfFhYWOD999+HhYUF36kQojfUzonQURsnQkdt3DjRiBIhhBBCCCGE1EIjSoQQQgghhBBSC3WUCCGEEEIIIaQW6igRQgghhBBCSC3UUSKEEEIIIYSQWqijRAxm3LhxGDhwoF5jbN++HXFxcXB2doZcLkd0dDT27dtXp9y2bdsQHBwMCwsLBAcHY8eOHWrPZ2ZmIjw8XLXxW3R0NHJyclTPP3nyBG+++SbCwsJgY2MDDw8PjBkzBr///rteXx8xfkJq5wAwb948tGnTBjY2NnB0dERsbCzy8vL0+vqIcRNaG/+r1NRUMAyDpUuXcv2SiIkRWjsfN24cGIZRe3Tu3Fmvr08IqKNEBOXo0aOIi4vDnj17cObMGfTq1QtJSUn48ccfVWV++OEHDB8+HCkpKSgsLERKSgqGDRum9uXPy8sLS5YswenTp3H69Gn07t0bAwYMwIULFwAAjx49wtmzZ/Huu+/i7Nmz2L59Oy5fvozk5GSDv2ZifgzVzgEgICAAK1euxLlz53D8+HH4+fkhPj4ed+7cMehrJubFkG38uf/85z/Iy8uDh4eHQV4jIYZu53379sXNmzdVjz179hjstZoslhADGTt2LDtgwACWZVk2JyeH7dq1K2tvb88qFAq2f//+7JUrV1Rlr169ygJgt23bxsbExLBWVlZseHg4e+LECa3jBgcHs/Pnz1f9PGzYMLZv375qZRISEtgRI0Y0Wo+joyP7xRdfNPj8qVOnWADsb7/9pnWORDiE3s7v37/PAmC///57rXMkwiDENn79+nXW09OTPX/+POvr68t+/vnnWudHhEVo7fyvr4dojkaUCC/Ky8sxa9Ys5Ofn48CBAxCJRBg0aBBqamrUyr399ttIS0tDQUEBAgICMHLkSDx9+lTjODU1NXjw4AEUCoXq2A8//ID4+Hi1cgkJCThx4kS9dVRXVyM7Oxvl5eWIjo5uMNb9+/fBMAwcHBw0zo8Im9DaeVVVFdauXQt7e3tERERonB8RLiG08ZqaGqSkpGDOnDkICQnROCdiPoTQzgHg8OHDcHFxQUBAACZNmoTbt29rnJvZ4runRsxHY1czbt++zQJgz507x7Lsi6szf70acuHCBRYAe+nSJY1jZmRksAqFgv3jjz9Ux6RSKfvVV1+plfvqq69YmUymduynn35ibWxsWLFYzNrb27O7d+9uME5FRQXboUMHdvTo0RrnRoRJiO38u+++Y21sbFiGYVgPDw/21KlTGudGhEdobXzRokVsXFwcW1NTw7IsSyNKhGVZ4bXz7OxsdteuXey5c+fYb7/9lo2IiGBDQkLYyspKjfMzRzSiRHjxyy+/YNSoUWjZsiXkcjlatGgBACguLlYrFx4ervq3u7s7AKiugNja2qoeU6ZMqRNj06ZNmDdvHjZv3gwXFxe15xiGUfuZZdk6xwIDA1FQUICTJ09i6tSpGDt2LC5evFgnzpMnTzBixAjU1NRg9erVmr4FxAwIpZ336tULBQUFOHHiBPr27Ythw4bRlUgCwPTb+JkzZ7Bs2TJ8+eWXdc4j5DlTb+cAMHz4cPTv3x+hoaFISkpCTk4OLl++jN27d2v7dpgVCd8JEPOUlJQEb29vZGVlwcPDAzU1NQgNDUVVVZVaOalUqvr38w+F50PdBQUFqufkcrnaeZs3b8aECRPwzTffIDY2Vu05Nzc33Lp1S+3Y7du34erqqnZMJpPB398fABAZGYn8/HwsW7YMa9asUZV58uQJhg0bhqtXr+LgwYN18iDmTSjt3MbGBv7+/vD390fnzp3RunVrrFu3Dunp6dq8HUSATL2NHzt2DLdv34aPj4+qfHV1NWbPno2lS5eiqKhIi3eDCJWpt/P6uLu7w9fXFz///HNTL9+sUUeJGFxJSQkuXbqENWvWoHv37gCA48ePa13P8w+E2jZt2oTx48dj06ZN6N+/f53no6OjkZubi5kzZ6qO7d+/H126dGk0HsuyePz4sern552kn3/+GYcOHYJSqdT6NRDhEko717UMET4htPGUlJQ6X0wTEhKQkpKCV199VduXQgRICO28PiUlJbh27Zpq5IvUjzpKxOAcHR2hVCqxdu1auLu7o7i4GG+99RYndW/atAljxozBsmXL0LlzZ9VVGCsrK9jb2wMAZsyYgR49euCjjz7CgAEDsHPnTnz//fdqH3xz585Fv3794O3tjQcPHiA7OxuHDx/G3r17AQBPnz7FkCFDcPbsWezatQvV1dWqWAqFAjKZjJPXQ0yXENp5eXk5Fi5ciOTkZLi7u6OkpASrV6/G9evXMXToUE5eCzFdQmjjSqWyzkUuqVQKNzc3BAYGcvJaiGkTQjt/+PAh5s2bh8GDB8Pd3R1FRUWYO3cunJycMGjQIE5ei2DxdncUMTspKSns4MGDWZZl2dzcXDYoKIi1sLBgw8PD2cOHD7MA2B07drAs++LGyB9//FF1fmlpKQuAPXToUIMxevbsyQKo8xg7dqxauW+++YYNDAxkpVIp26ZNG3bbtm1qz48fP5719fVlZTIZ6+zszPbp04fdv3+/6vnn+dX3aCw/InxCaucVFRXsoEGDWA8PD1Ymk7Hu7u5scnIyLeZg5oTUxutDizkQlhVWO3/06BEbHx/POjs7s1KplPXx8WHHjh3LFhcXN+s9MgcMy7KsPjtihDzXt29f+Pv7Y+XKlXynQojeUDsnQkdtnJgDaucEAGjVO6J3paWl2L17Nw4fPlxnLjghQkHtnAgdtXFiDqidk7+ie5SI3o0fPx75+fmYPXs2BgwYwHc6hOgFtXMidNTGiTmgdk7+iqbeEUIIIYQQQkgtNPWOEEIIIYQQQmqhjhIhhBBCCCGE1EIdJUIIIYQQQgiphTpKhBBCCCGEEFILdZQIIYQQQgghpBbqKBFCCCGEEEJILdRRIoQQQgghhJBaqKNECCGEEEIIIbVQR4kQQgghhBBCavl/3v9UBd7g0RUAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "### LOAD DATA ###\n", "simulator_object = estimation_output.simulation_results_per_iteration[-1]\n", "state_history = simulator_object.dynamics_results.state_history\n", "dependent_variable_history = simulator_object.dynamics_results.dependent_variable_history\n", "\n", "### Ephemeris Kepler elements ####\n", "# Initialize containers\n", "ephemeris_state_history = dict()\n", "ephemeris_keplerian_states = dict()\n", "jupiter_gravitational_parameter = bodies.get('Jupiter').gravitational_parameter\n", "# Loop over the propagated states and use the IMCEE ephemeris as benchmark solution\n", "for epoch in state_history.keys():\n", " ephemeris_state = list()\n", " keplerian_state = list()\n", " for moon in bodies_to_propagate:\n", " ephemeris_state_temp = spice.get_body_cartesian_state_at_epoch(\n", " target_body_name=moon,\n", " observer_body_name='Jupiter',\n", " reference_frame_name='ECLIPJ2000',\n", " aberration_corrections='none',\n", " ephemeris_time=epoch)\n", " ephemeris_state.append(ephemeris_state_temp)\n", " keplerian_state.append(element_conversion.cartesian_to_keplerian(ephemeris_state_temp,\n", " jupiter_gravitational_parameter))\n", "\n", " ephemeris_state_history[epoch] = np.concatenate(np.array(ephemeris_state))\n", " ephemeris_keplerian_states[epoch] = np.concatenate(np.array(keplerian_state))\n", "\n", "state_history_difference = np.vstack(list(state_history.values())) - np.vstack(list(ephemeris_state_history.values()))\n", "position_difference = {'Io': state_history_difference[:, 0:3],\n", " 'Europa': state_history_difference[:, 6:9],\n", " 'Ganymede': state_history_difference[:, 12:15],\n", " 'Callisto': state_history_difference[:, 18:21]}\n", "\n", "### PLOTTING ###\n", "time2plt = list()\n", "epochs_julian_seconds = np.vstack(list(state_history.keys()))\n", "for epoch in epochs_julian_seconds:\n", " epoch_days = constants.JULIAN_DAY_ON_J2000 + epoch / constants.JULIAN_DAY\n", " time2plt.append(time_representation.DateTime.from_julian_day(epoch_days).to_python_datetime())\n", "\n", "fig, ax1 = plt.subplots(1, 1, figsize=(10, 6))\n", "\n", "ax1.plot(time2plt, np.linalg.norm(position_difference['Io'], axis=1) * 1E-3,\n", " label=r'Io ($i=1$)', c='#A50034')\n", "ax1.plot(time2plt, np.linalg.norm(position_difference['Europa'], axis=1) * 1E-3,\n", " label=r'Europa ($i=2$)', c='#0076C2')\n", "ax1.plot(time2plt, np.linalg.norm(position_difference['Ganymede'], axis=1) * 1E-3,\n", " label=r'Ganymede ($i=3$)', c='#EC6842')\n", "ax1.plot(time2plt, np.linalg.norm(position_difference['Callisto'], axis=1) * 1E-3,\n", " label=r'Callisto ($i=4$)', c='#009B77')\n", "ax1.set_title(r'Difference in Position')\n", "ax1.xaxis.set_major_locator(mdates.MonthLocator(bymonth=1))\n", "ax1.xaxis.set_minor_locator(mdates.MonthLocator())\n", "ax1.xaxis.set_major_formatter(mdates.DateFormatter('%b-%Y'))\n", "ax1.set_ylabel(r'Difference [km]')\n", "ax1.legend()" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "source": [ "Overall, for the inner three moons trapped in resonance (for more details see below) the above results lie within the expected range of achievable accuracy given the rather rudimentary set-up of the environment and especially associated acceleration models. However, what is striking is that the performance of Callisto falls short compared to the other satellites. Thus, hypothetically, to enhance the estimated solution of the orbit of Callisto with respect to the underlying ephemeris, one could opt to estimate its gravity field alongside the initial state, which could lead to significantly improved results. However, this path is left as an adventure to be followed and explored by the reader." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:37:25.694745Z", "iopub.status.busy": "2025-09-16T07:37:25.694588Z", "iopub.status.idle": "2025-09-16T07:37:25.698416Z", "shell.execute_reply": "2025-09-16T07:37:25.697990Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "def calculate_mean_longitude(kepler_elements: dict):\n", " # Calculate dictionary for moon-wise longitudes\n", " mean_longitude_dict = dict()\n", " # Loop over every moon of interest (Io, Europa, Ganymede)\n", " for moon in kepler_elements.keys():\n", " mean_anomaly_per_moon = list()\n", " kepler_elements_per_moon = kepler_elements[moon]\n", " # For every epoch get the mean anomaly of the moon\n", " for i in range(len(kepler_elements[moon])):\n", " mean_anomaly_per_moon.append(element_conversion.true_to_mean_anomaly(\n", " eccentricity=kepler_elements_per_moon[i, 1],\n", " true_anomaly=kepler_elements_per_moon[i, 5]))\n", " mean_anomaly_per_moon = np.array(mean_anomaly_per_moon)\n", " mean_anomaly_per_moon[mean_anomaly_per_moon < 0] = mean_anomaly_per_moon[mean_anomaly_per_moon < 0] \\\n", " + 2 * math.pi\n", " # Calculate the mean longitude as\n", " # (longitude of the ascending node) + (argument of the pericenter) + (mean anomaly)\n", " longitude_of_the_ascending_node = kepler_elements_per_moon[:, 4]\n", " argument_of_the_pericenter = kepler_elements_per_moon[:, 3]\n", "\n", " mean_longitude_per_moon = longitude_of_the_ascending_node + argument_of_the_pericenter + mean_anomaly_per_moon\n", " # Include epoch-wise mean longitude in dictionary\n", " mean_longitude_per_moon = np.mod(mean_longitude_per_moon, 2*math.pi)\n", " mean_longitude_dict[moon] = mean_longitude_per_moon\n", "\n", " return mean_longitude_dict" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2025-09-16T07:37:25.699893Z", "iopub.status.busy": "2025-09-16T07:37:25.699749Z", "iopub.status.idle": "2025-09-16T07:37:27.812857Z", "shell.execute_reply": "2025-09-16T07:37:27.812216Z" }, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_47680/563442953.py:38: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", " time2plt.append(time_representation.DateTime.from_julian_day(epoch_days).to_python_datetime())\n" ] }, { "data": { "text/plain": [ "Text(0, 0.5, 'Laplace $\\\\Delta\\\\Phi_L$ [deg]')" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "### LAPLACE STABILITY ###\n", "ephemeris_kepler_elements = np.vstack(list(ephemeris_keplerian_states.values()))\n", "propagation_kepler_elements = np.vstack(list(dependent_variable_history.values()))\n", "\n", "ephemeris_kepler_elements_dict = {'Io': ephemeris_kepler_elements[:, 0:6],\n", " 'Europa': ephemeris_kepler_elements[:, 6:12],\n", " 'Ganymede': ephemeris_kepler_elements[:, 12:18],\n", " 'Callisto': ephemeris_kepler_elements[:, 18:24]}\n", "\n", "propagated_kepler_elements_dict = {'Io': propagation_kepler_elements[:, 0:6],\n", " 'Europa': propagation_kepler_elements[:, 6:12],\n", " 'Ganymede': propagation_kepler_elements[:, 12:18],\n", " 'Callisto': propagation_kepler_elements[:, 18:24]}\n", "\n", "# Calculate propagated Laplace stability\n", "\n", "mean_longitude_dict_prop = calculate_mean_longitude(propagated_kepler_elements_dict)\n", "\n", "laplace_stability_prop = mean_longitude_dict_prop['Io'] \\\n", " - 3 * mean_longitude_dict_prop['Europa'] \\\n", " + 2 * mean_longitude_dict_prop['Ganymede']\n", "laplace_stability_prop = np.mod(laplace_stability_prop, 2 * math.pi)\n", "\n", "# Calculate ephemeris Laplace stability\n", "\n", "mean_longitude_dict_ephem = calculate_mean_longitude(ephemeris_kepler_elements_dict)\n", "\n", "laplace_stability_ephem = mean_longitude_dict_ephem['Io'] \\\n", " - 3 * mean_longitude_dict_ephem['Europa'] \\\n", " + 2 * mean_longitude_dict_ephem['Ganymede']\n", "laplace_stability_ephem = np.mod(laplace_stability_ephem, 2 * math.pi)\n", "\n", "### PLOTTING ###\n", "time2plt = list()\n", "epochs_julian_seconds = np.vstack(list(state_history.keys()))\n", "for epoch in epochs_julian_seconds:\n", " epoch_days = constants.JULIAN_DAY_ON_J2000 + epoch / constants.JULIAN_DAY\n", " time2plt.append(time_representation.DateTime.from_julian_day(epoch_days).to_python_datetime())\n", "\n", "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8), sharex=True)\n", " \n", "ax1.plot(time2plt, laplace_stability_prop * 180 / math.pi, label='Propagated', c='#A50034')\n", "ax1.plot(time2plt, laplace_stability_ephem * 180 / math.pi, label='NOE 5 Ephemeris', c='#EC6842',\n", " linestyle=(0, (5, 10)))\n", "ax1.set_title(r'Laplace Resonance $\\Phi_L=\\lambda_I-3 \\lambda_E+2 \\lambda_G$')\n", "ax1.set_ylabel(r'Laplace $\\Phi_L$ [deg]')\n", "ax1.legend()\n", "\n", "ax2.plot(time2plt, (laplace_stability_prop - laplace_stability_ephem) * 180 / math.pi, c='#0076C2')\n", "ax2.set_title(r'Difference in Laplace Resonance $\\Delta\\Phi_L$')\n", "ax2.xaxis.set_major_locator(mdates.MonthLocator(bymonth=1))\n", "ax2.xaxis.set_minor_locator(mdates.MonthLocator())\n", "ax2.xaxis.set_major_formatter(mdates.DateFormatter('%b-%Y'))\n", "ax2.set_ylabel(r'Laplace $\\Delta\\Phi_L$ [deg]')" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.13" } }, "nbformat": 4, "nbformat_minor": 4 }