{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Stoke's Drift and Leeway\n",
"\n",
"Objects at or near to the ocean's surface can experience additional forces that influence their movement. These include Stoke's drift, which occurs in the presence of surface gravity waves; and direct wind forcing, which can drive the movement of buoyant objects that partly sit above the ocean surface. Experimentally, when working at sea, it is difficult to isolate the impact of Stoke's drift from direct wind forcing. For this reason, the two are often modelled together as Leeway. The effect of Leeway is heavily dependent on the type of object under consideration, and this should be reflected in empirically derived parameter values. Search and rescue models often include a suite of parameters for different types of object (e.g. ships that that escaped their moorings, people in the water). In PyLag, the contribution of different factors (e.g., ocean currents, Stoke's Drift, direct wind forcing) to a particle's velocity are pooled and combined using an object of type VelocityAggregator. The code is designed to allow flexibility in the way the different components are brought together and accounted for. By default, the particle's velocity vector is modelled as a simple linear sum of the various components.\n",
"\n",
"In real world applications, ocean circulation models are forced using surface wind data. However, the same data are not always included with the outputs of the ocean circulation model. Thus, if the impact of windage on particles is to be modelled along with the impact of ocean currents, the wind field may need to be read in separately. Furthermore, an ocean model may or may not have been run with a wave model; and even if the ocean circulation model was run with a wave model, the Stoke's drift velocity components may have been saved separately. To make it possible to read in wind and wave data that is stored in separate files, PyLag includes a suite of different data readers that can be used separately, or combined together, to read different types of data.\n",
"\n",
"In this example, we demonstrate how PyLag can be used with data for surface ocean currents, surface winds and Stoke's drift that are stored in separate files. In total, three simulations are run: i) one that uses the surface velocity field only, ii) one that uses the surface velocity field with data for Stoke's drift, and iii) one that uses the surface velocity field with the surface wind field and a parameterisation of Leeway.\n",
"\n",
"For input data, we use:\n",
"\n",
"* **Surface ocean currents** - The example uses CMEMS Product NWS_ANALYSIS_FORECAST_004_013. The product was created using the UK Met Office Forecast Ocean and Assimilation Model (FOAM). The model uses NEMO v3.6, WAVEWATCH-III v4.18 and NEMOVAR v6. The model is run on the Atlantic Margin Model 1.5 km domain, and includes tides. This is a two-way coupled model (ocean-waves) setup. The data is hourly. \n",
"\n",
"\n",
"* **Stoke's Drift** - The example uses CMEMS Product NWS_ANALYSIS_FORECAST_004_014. The product includes the outputs from WAVEWATCH-III, which was run with NEMO to generate product NWS_ANALYSIS_FORECAST_004_013. The data is three hourly.\n",
"\n",
"\n",
"* **Surface winds** - The example uses ERA5 10 m wind components from the Climate Data Store (DOI: 10.24381/cds.adbb2d47). The data is hourly.\n",
"\n",
"
\n",
"\n",
"**Note:**\n",
"\n",
"If the ocean circulation model was not coupled to a wave model when it was run, one should be wary of dynamical inconsistencies between the two.\n",
" \n",
"
\n",
"\n",
"As with the other examples, the output files needed for the example can be [downloaded here](https://drive.google.com/open?id=15UX7Y9JnuLpnPAz700mzmzd917nTClxR). If you would like to run the code in this notebook interactively, download the data into a directory of your chooising. By default, the notebook will look for these files in the directory `${HOME}/data/pylag_doc`. To change this, simply update the *data_dir* path below."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import pathlib\n",
"\n",
"\n",
"# Root directory for PyLag example input files\n",
"data_dir=f\"{os.environ['HOME']}/data/pylag_doc\"\n",
"\n",
"# Path to the ocean data\n",
"ocean_data_dir = f\"{data_dir}\"\n",
"\n",
"# Path to the wave data\n",
"wave_data_dir = f\"{data_dir}\"\n",
"\n",
"# Path to the wind data\n",
"wind_data_dir = f\"{data_dir}\"\n",
"\n",
"# Keep a copy of the cwd\n",
"cwd = os.getcwd()\n",
"\n",
"# Create run directory\n",
"simulation_dir = f'{cwd}/simulations/stokes_drift_and_leeway'\n",
"pathlib.Path(simulation_dir).mkdir(parents=True, exist_ok=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating the grid metrics files\n",
"\n",
"In this example, we must create three grid metrics files for the three data sets (i.e. for the ocean, wave and wind data). The data do not need to be on the same grid. In this example, all three data sets are on a standard Arakawa A-grid: the ocean and wave datasets use the same AMM15 grid, while the wind data are defined on a global grid with a resolution of 0.25 degrees. The respective grid metrics files are created separately below."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"Creating ocean grid metrics file ...\n",
"\n",
"\n",
"Reading the grid:\n",
"Reading variable `lon` ... done\n",
"Reading variable `lat` ... done\n",
"Reading variable `uo` ... done\n",
"Sorting axes for variable `uo`... done\n",
"\n",
"Creating the triangulation ... done\n",
"\n",
"Generating the land sea mask at element nodes:\n",
"\n",
"Sorting the adjacency array ... done\n",
"\n",
"Calculating lons and lats at element centres ... done\n",
"\n",
"Calculating element areas ... done\n",
"\n",
"Generating land sea mask at element centres ... done\n",
"\n",
"Mask elements with two land boundaries ... done\n",
"\n",
"Flagging open boundaries ... done\n",
"\n",
"Creating grid metrics file /users/modellers/jcl/code/git/PyLag/PyLag/doc/source/examples/simulations/stokes_drift_and_leeway/input/ocean_grid_metrics.nc ... done\n"
]
}
],
"source": [
"from pylag.grid_metrics import create_arakawa_a_grid_metrics_file\n",
"\n",
"# Create the ocean grid metrics file\n",
"# ----------------------------------\n",
"\n",
"# An example NEMO AMM15 ocean data file in which the data are defined on a regular Arakawa A-grid.\n",
"ocean_data_file_name = f'{ocean_data_dir}/NWS_ANALYSIS_FORECAST_004_013_uv_2021_07_01.nc'\n",
"\n",
"# Create input sub-directory\n",
"input_dir = f'{simulation_dir}/input'.format(simulation_dir)\n",
"pathlib.Path(input_dir).mkdir(parents=True, exist_ok=True)\n",
"\n",
"# The name of the output file\n",
"ocean_grid_metrics_file_name = f'{input_dir}/ocean_grid_metrics.nc'\n",
"\n",
"# Generate the file if it has not been created already\n",
"if not os.path.exists(ocean_grid_metrics_file_name):\n",
" print('\\n\\nCreating ocean grid metrics file ...\\n\\n')\n",
" create_arakawa_a_grid_metrics_file(ocean_data_file_name,\n",
" dim_names={'longitude': 'lon', 'latitude': 'lat'},\n",
" lon_var_name='lon',\n",
" lat_var_name='lat',\n",
" reference_var_name='uo',\n",
" surface_only=True,\n",
" grid_metrics_file_name=ocean_grid_metrics_file_name)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"Creating wave grid metrics file ...\n",
"\n",
"Reading the grid:\n",
"Reading variable `longitude` ... done\n",
"Reading variable `latitude` ... done\n",
"\n",
"Creating the triangulation ... done\n",
"\n",
"Sorting the adjacency array ... done\n",
"\n",
"Calculating lons and lats at element centres ... done\n",
"\n",
"Calculating element areas ... done\n",
"\n",
"Flagging open boundaries ... done\n",
"\n",
"Creating grid metrics file /users/modellers/jcl/code/git/PyLag/PyLag/doc/source/examples/simulations/stokes_drift_and_leeway/input/wave_grid_metrics.nc ... done\n"
]
}
],
"source": [
"# Create the wave grid metrics file\n",
"# ----------------------------------\n",
"\n",
"# An example WWIII AMM7 wave data file in which the data are defined on a regular Arakawa A-grid.\n",
"wave_data_file_name = f'{wave_data_dir}/NWSHELF_REANALYSIS_WAV_004_015-TDS_uv_stokes_2021_07_01.nc'\n",
"\n",
"# The name of the output file\n",
"wave_grid_metrics_file_name = f'{input_dir}/wave_grid_metrics.nc'\n",
"\n",
"# Generate the file if it has not been created already\n",
"if not os.path.exists(wave_grid_metrics_file_name):\n",
" print('\\n\\nCreating wave grid metrics file ...\\n')\n",
" create_arakawa_a_grid_metrics_file(wave_data_file_name,\n",
" lon_var_name='longitude',\n",
" lat_var_name='latitude',\n",
" surface_only=True,\n",
" save_mask=False,\n",
" grid_metrics_file_name=wave_grid_metrics_file_name)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"Creating wind grid metrics file ...\n",
"\n",
"Reading the grid:\n",
"Reading variable `longitude` ... done\n",
"Reading variable `latitude` ... done\n",
"INFO - detected longitudes greater than 180.0. Assuming longitude limits are in the range 0 - 360. Correcting these to be in the range -180 to 180.\n",
"Trimming first latitude which sits over a pole (90.0 deg.)\n",
"Trimming last latitude which sits over a pole (-90.0 deg.)\n",
"\n",
"Creating the triangulation ... done\n",
"\n",
"Identifying neighbour simplices:\n",
"\n",
"Searching for adjoining neighbours with k = 4 ... found 55.528377623971615 %\n",
"\n",
"Searching for adjoining neighbours with k = 16 ... found 89.87152270036064 %\n",
"\n",
"Searching for adjoining neighbours with k = 64 ... found 97.67742172272779 %\n",
"\n",
"Searching for adjoining neighbours with k = 256 ... found 99.86019328580066 %\n",
"\n",
"Searching for adjoining neighbours with k = 1024 ... found 100.0 %\n",
"\n",
"Sorting the adjacency array ... done\n",
"\n",
"Calculating lons and lats at element centres ... done\n",
"\n",
"Calculating element areas ... done\n",
"\n",
"Creating grid metrics file /users/modellers/jcl/code/git/PyLag/PyLag/doc/source/examples/simulations/stokes_drift_and_leeway/input/wind_grid_metrics.nc ... done\n"
]
}
],
"source": [
"# Create the wind grid metrics file\n",
"# ---------------------------------\n",
"\n",
"# An example ERA5 wind data file in which the data are defined on a regular Arakawa A-grid.\n",
"wind_data_file_name = f'{wind_data_dir}/era5_winds_2021_07.nc'\n",
"\n",
"# The name of the output file\n",
"wind_grid_metrics_file_name = f'{input_dir}/wind_grid_metrics.nc'\n",
"\n",
"# Generate the file if it has not been created already\n",
"if not os.path.exists(wind_grid_metrics_file_name):\n",
" print('\\n\\nCreating wind grid metrics file ...\\n')\n",
" create_arakawa_a_grid_metrics_file(wind_data_file_name,\n",
" lon_var_name='longitude',\n",
" lat_var_name='latitude',\n",
" is_global=True,\n",
" surface_only=True,\n",
" save_mask=False,\n",
" grid_metrics_file_name=wind_grid_metrics_file_name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tests were included which mean the files are only created if they don't exists already; the creation of the grid metrics file is relatively expensive, but only needs to be done once. It should also be noted we only generated a land mask for the ocean data, and it is this which is used to determine interactions with the land boundary. For the other two datasets, masked points are replaced by zeros during run time. See the online docs for a full list of arguments accepted by [create_arakawa_a_grid_metrics_file](https://pylag.readthedocs.io/en/latest/api/pylag.grid_metrics.html#pylag.grid_metrics.create_arakawa_a_grid_metrics_file)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setting particle initial positions\n",
"\n",
"We first create a PyLag initial positions file. For the purpose of the tutorial, we do this by placing particles in a small cloud of radius 500 m, centered on [Station L4](https://www.westernchannelobservatory.org.uk/) in the Western English Channel (-4.17 E, 50.25 N). The data on particle initial positions will be resued in each of the three model simulations, so we only create one file."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"from pylag.processing.coordinate import get_epsg_code, utm_from_lonlat, lonlat_from_utm\n",
"from pylag.processing.release_zone import create_release_zone\n",
"from pylag.processing.input import create_initial_positions_file_single_group\n",
"\n",
"\n",
"# The group ID of this particle set\n",
"group_id = 1\n",
"\n",
"# Lat and lon coordiantes for the centre of the release zone\n",
"lon = -4.17\n",
"lat = 50.25\n",
"\n",
"# Release zone radius (m)\n",
"radius = 500.0\n",
"\n",
"# Number of particles to be released.\n",
"n_particles = 10\n",
"\n",
"# Release depths\n",
"depth_below_surface = 0.0\n",
"\n",
"# Create the release zone\n",
"surface_release_zone = create_release_zone(group_id = group_id,\n",
" radius = radius,\n",
" centre = [lon, lat],\n",
" coordinate_system = 'geographic',\n",
" n_particles = n_particles,\n",
" depth = depth_below_surface,\n",
" random = True)\n",
"\n",
"# Get coordinates\n",
"lons, lats, depths = surface_release_zone.get_coordinates()\n",
"\n",
"# Write data to file\n",
"file_name = f'{input_dir}/initial_positions.dat'.format(input_dir)\n",
"create_initial_positions_file_single_group(file_name,\n",
" n_particles,\n",
" group_id,\n",
" lons,\n",
" lats,\n",
" depths)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Set the run time\n",
"\n",
"We define here the run time, based on the bottle position at different times."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"# Set a transit time of 12 days\n",
"pylag_start_datetime = \"2021-07-01 01:00:00\"\n",
"pylag_end_datetime = \"2021-07-02 18:00:00\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating the run configuration files\n",
"\n",
"The example uses three run configuration files, one for each run. These determine which PyLag components are used to compute particle trajectories. The run configuration files are based off templates, which are provided with the code. First, we generate the *ocean only* run configuration file from the template and save it in the *simulation* directory."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"import configparser\n",
"\n",
"config_file_name = './configs/stokes_drift_and_leeway_template.cfg'\n",
"\n",
"cf = configparser.ConfigParser()\n",
"cf.read(config_file_name)\n",
"\n",
"# Set paths for ocean data\n",
"cf.set('OCEAN_DATA', 'data_dir', ocean_data_dir)\n",
"cf.set('OCEAN_DATA', 'grid_metrics_file', ocean_grid_metrics_file_name)\n",
"\n",
"# Assert we are not running with wave data or trying to include the impact of Stoke's drift.\n",
"cf.set('WAVE_DATA', 'name', 'none')\n",
"cf.set('STOKES_DRIFT', 'stokes_drift_calculator', 'none')\n",
"\n",
"# Assert we are not running with atmospheric data or trying to include windage or leeway.\n",
"cf.set('ATMOSPHERE_DATA', 'name', 'none')\n",
"cf.set('WINDAGE', 'windage_calculator', 'none')\n",
"\n",
"# Set start time\n",
"cf.set('SIMULATION', 'start_datetime', pylag_start_datetime)\n",
"\n",
"# Set stop time\n",
"cf.set('SIMULATION', 'end_datetime', pylag_end_datetime)\n",
"\n",
"# Directory where the simulation outputs will be saved\n",
"ocean_only_out_dir = f\"{simulation_dir}/ocean_only_output\"\n",
"cf.set('GENERAL', 'out_dir', ocean_only_out_dir)\n",
"\n",
"# Save a copy in the simulation directory\n",
"ocean_only_config_file_name = 'ocean_only_pylag.cfg'\n",
"with open(f\"{simulation_dir}/{ocean_only_config_file_name}\", 'w') as config:\n",
" cf.write(config)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Settings for Stoke's drift are specified in two sections of the run configuration file. The first is called *WAVE_DATA*. In this section, configuration parameters allow the user to provide details about the driving wave data. For example, the type of grid the data are definted on, the names of dimension and coordinate variables etc. The second section is called *STOKES_DRIFT*. Here, the approach for calculating Stoke's Drift data is specified using the parameter *stokes_drift_calculator*."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"config_file_name = './configs/stokes_drift_and_leeway_template.cfg'\n",
"\n",
"cf = configparser.ConfigParser()\n",
"cf.read(config_file_name)\n",
"\n",
"# Set paths for ocean data\n",
"cf.set('OCEAN_DATA', 'data_dir', ocean_data_dir)\n",
"cf.set('OCEAN_DATA', 'grid_metrics_file', ocean_grid_metrics_file_name)\n",
"\n",
"# Assert we are not running with atmospheric data or trying to include windage or leeway.\n",
"cf.set('ATMOSPHERE_DATA', 'name', 'none')\n",
"cf.set('WINDAGE', 'windage_calculator', 'none')\n",
"\n",
"# Assert that we are using wave data and calculating Stoke's drift at the surface.\n",
"cf.set('WAVE_DATA', 'name', 'standard')\n",
"cf.set('WAVE_DATA', 'data_dir', wave_data_dir)\n",
"cf.set('WAVE_DATA', 'grid_metrics_file', wave_grid_metrics_file_name)\n",
"cf.set('STOKES_DRIFT', 'stokes_drift_calculator', 'surface')\n",
"\n",
"# Set start time\n",
"cf.set('SIMULATION', 'start_datetime', pylag_start_datetime)\n",
"\n",
"# Set stop time\n",
"cf.set('SIMULATION', 'end_datetime', pylag_end_datetime)\n",
"\n",
"# Directory where the simulation outputs will be saved\n",
"stokes_drift_out_dir = f\"{simulation_dir}/stokes_drift_output\"\n",
"cf.set('GENERAL', 'out_dir', stokes_drift_out_dir)\n",
"\n",
"# Save a copy in the simulation directory\n",
"stokes_drift_config_file_name = 'stokes_drift_pylag.cfg'\n",
"with open(f\"{simulation_dir}/{stokes_drift_config_file_name}\", 'w') as config:\n",
" cf.write(config)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, we create a run configuration file for modelling the impact of direct wind forcing on an object's movement. Here, we must specify settings in three different sections. The first is the section *ATMOSPHERE_DATA*, where details of the atmospheric data (specifically the wind) are given. This includes a parameter where the path to the data is specified, and parameters where dimension and variable names can be listed (among others). The second is the section \"WINDAGE\". This is where the type of *windage_calculator* is specified. The choice determins how the wind data will be used. Here, we use a windage calculator that specifies a fixed wind factor, which is applied to the wind speed. In very simple terms, this can be viewed as a model of Leeway, where the impact of waves and direct wind forcing on an object's movement are subsumed into a single parameter, under the assumption that the object moves in a downwind direction (i.e. with zero deflection). In this example, we used a wind factor of 1 %."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"config_file_name = './configs/stokes_drift_and_leeway_template.cfg'\n",
"\n",
"cf = configparser.ConfigParser()\n",
"cf.read(config_file_name)\n",
"\n",
"# Set paths for ocean data\n",
"cf.set('OCEAN_DATA', 'data_dir', ocean_data_dir)\n",
"cf.set('OCEAN_DATA', 'grid_metrics_file', ocean_grid_metrics_file_name)\n",
"\n",
"# Set paths for atmospheric data\n",
"cf.set('ATMOSPHERE_DATA', 'name', 'standard')\n",
"cf.set('ATMOSPHERE_DATA', 'data_dir', wind_data_dir)\n",
"cf.set('ATMOSPHERE_DATA', 'grid_metrics_file', wind_grid_metrics_file_name)\n",
"\n",
"# Specify the type of windage calculator we will use\n",
"cf.set('WINDAGE', 'windage_calculator', 'zero_deflection')\n",
"cf.set('ZERO_DEFLECTION_WINDAGE_CALCULATOR', 'wind_factor', '0.01')\n",
"\n",
"# Assert we are not running with wave data or trying to include the impact of Stoke's drift.\n",
"cf.set('WAVE_DATA', 'name', 'none')\n",
"cf.set('STOKES_DRIFT', 'stokes_drift_calculator', 'none')\n",
"\n",
"# Set start time\n",
"cf.set('SIMULATION', 'start_datetime', pylag_start_datetime)\n",
"\n",
"# Set stop time\n",
"cf.set('SIMULATION', 'end_datetime', pylag_end_datetime)\n",
"\n",
"# Directory where the simulation outputs will be saved\n",
"leeway_out_dir = f\"{simulation_dir}/leeway_output\"\n",
"cf.set('GENERAL', 'out_dir', leeway_out_dir)\n",
"\n",
"# Save a copy in the simulation directory\n",
"leeway_config_file_name = 'leeway_pylag.cfg'\n",
"with open(f\"{simulation_dir}/{leeway_config_file_name}\", 'w') as config:\n",
" cf.write(config)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Running the model\n",
"\n",
"With the run configuration files saved, we can now run the three model simulations. We run them one after another."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Starting ensemble member 1 ...\n",
"Progress:\n",
"100% |###########################################|\n",
"\n",
"Starting ensemble member 1 ...\n",
"Progress:\n",
"100% |###########################################|\n",
"\n",
"Starting ensemble member 1 ...\n",
"Progress:\n",
"100% |###########################################|\n"
]
}
],
"source": [
"# Change to the run directory\n",
"os.chdir(f'{simulation_dir}')\n",
"\n",
"# Run the ocean only model\n",
"!{\"python -m pylag.main -c ocean_only_pylag.cfg\"}\n",
"\n",
"# Run the ocean + windage model\n",
"!{\"python -m pylag.main -c stokes_drift_pylag.cfg\"}\n",
"\n",
"# Run the ocean + windage model\n",
"!{\"python -m pylag.main -c leeway_pylag.cfg\"}\n",
"\n",
"# Return to the cwd\n",
"os.chdir(cwd)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Visualising the result\n",
"\n",
"Having run the models, the final step is to visulise the result. Here, we produce a simple plot of particle pathlines over the course of the simulation."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAb8AAAHvCAYAAADEndGFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADswElEQVR4nOydd5xU1d24n3vv9NnZ3tjGwgLSBQQBG1iwV4xGjbHEvIkh3Zj2UxPfxFdjzJuQxDTNG0WNmpgYTbFrNFZEUCnSlr7AsmyZttPn3t8fZ2cLdQZ2d+aM9/l8LjM75d7nXs7Md077HsUwDAMTExMTE5OPEWq2BUxMTExMTIYbM/iZmJiYmHzsMIOfiYmJicnHDjP4mZiYmJh87DCDn4mJiYnJxw4z+JmYmJiYfOwwg5+JiYmJyccOS7YFZCESiRCLxbKtYWJiYmJyGGw2Gw6H45CvMYNfGkQiEerr62lvb8+2iomJiYnJYaiurmbLli2HDIBm8EuDWCxGe3s7L774IgUFBdnWSRuv1wtAcXFxVj0yQSbnrq4uNm/ezKc+9Sm6uroAKCsry7JV+nR0dADZc162bBmdnZ3U19dn9D6ZykgKGZ1BTu9gMMiCBQuIxWJm8BssCgoKpAp+nZ2dAKbzELBz506CwSBf/OIXAXpbBQoLC7OplRFtbW1A9pxPP/10/vKXv6DrekYOspSR/sjoDPJ6p4M54CWP8Xg8eDyebGtkhAzOzc3NqKrKZZdd1vtYcXGxVL+OITecL730UlavXo2u62m/R4Yysi8yOoO83ulgBr9hxswjLjerVq2ipqaGBQsWZFslL1AUhauuuoqlS5dmW8XkY4bZ7DnMLF++nG3btjFt2jR0XccwDHRd790MwyCZTO73uNVqxe1243K5eptfrVbrIY8VCAQAKCkpGY5TGxRyybm7u5vm5mYSiQR2ux2bzcacOXMYNWrUfq9N9Y2Ul5cPs+WRkyvOBQUFnHrqqSxfvpxJkyYd9vW5VEbSRUZnkNc7HczgN8zMnDmToqIiPB4Pp512WlrvMQyDaDSK3+/H5/PR1dXF3r17iUajA4LmvkG0q6sLwzDYu3fvAYOo2+2moKAAm802xGedPtnqW4jFYmzcuJFQKITD4cBut1NaWsqFF16YVrNPUVHRMFgOLrnkPGbMGHbu3MnOnTupra095Gtl7H+S0Rnk9U4HM/hlgbFjx7J9+3b++c9/cv755x/29Yqi4HA4cDgcVFZWpn2c1CCM/r/so9EoPp8Pn8+H1+ulo6ODSCRyyCC6b03UMAwsFgsul2tAELXb7ZlfjAOc61CTTCbZsmULnZ2dOBwObDZbb+0jk+vbn+HwHmxyzXnevHk8+uijlJSU4HK5Dvq6XPNOBxmdQV7vdDCDX5ZoaGigtbWVP//5z1x++eVDcgy/3w8MDH52u53Kysoj/pJP0b8m6vV66erqIhwOHzKI9v879Zimab1BtKCgAK/Xi81mG7RmFsMwaGlpYffu3VitVux2O06nk+nTp9PQ0DBoH+4DXetcJxedr7jiCn73u99x0kknHfT/JhgMAnI1xcnoDPJ6p4MZ/LJIdXU1NpuNBx98kGuvvXbQf2Ud6tfz0WK326moqKCiouKo9hONRgkEAni9XrxeL21tbfh8PmKx2H5B80ABdN8garfb6ezsRNM0bDYbNpuN8ePHc9ZZZ6GqQze+ayiv9VCRi86qqnLllVfy17/+ldmzZx/wNU6nc5itjh4ZnUFe73Qwg1+WKS0txW63c99993HDDTdgsQzef4mmaYO2r6HCbrdjt9t7ax8jR44EyDioxmIx/H4/gUCAurq6ww4GGmxkuNb7kqvOxcXFzJkzh7Vr1zJ+/Pj9nh/KHzFDhYzOIK93OuTvmUmE2+1m1qxZ3HfffYRCoUHbbygUGtT9DQdH6myz2SgvL2fUqFHDHvjg43Wth4NJkyZRWFjInj179nsuEokQiUSyYHXkyOgM8nqngxn8cgSbzcaJJ57IAw880Jsq62ixWq1ZCQRHg4zOIKd3rjufeeaZ7NixY7+E8haLZVBbSIYDGZ1BXu90MINfDqFpGqeccgpPPPEEO3fuPOr9pfq8ZEJGZ5DTWwbnq6++er8J8LketA+EjM4gr3c6mMEvx1AUhRNOOIEXXniB5ubmo9pXOBwmHA4PktnwIKMzyOktg7PFYmHhwoUsX76897FoNEo0Gs2iVebI6AzyeqeDGfxylFmzZrF06VJWrlx5xPtQVVW6DmsZnUFOb1mcq6qqmDx5Mps2bQLED0TZ5p/J6AzyeqdDfjbm5gnHHnssa9euJRQKMWfOnIzfPxiTzocbGZ1BTm+ZnI877jh27dpFZ2dnzjfVHggZnUFe73TI/Z99H3MmTJhAa2srL7/8csbvlbHJQkZnkNNbNucLLriA5uZmYrHYfoNgch0ZnUFe73Qwg58EjBkzhlgsxj/+8Y+M3peaBC4TMjqDnN4yOs+YMYOdO3dKtzqKYRjSOYO83ulgBj9JqK+vx+Vy8fjjj6ddGJ1Op3QZGmR0Bjm9ZXSeNm0aPp9PqiZb6EvmIBuyeqeDGfwkoqqqitraWh544IG0frHL2GQhozPI6S2jM8D06dPZsGFDtjUyIh6PE4/Hs62RMbJ6p4MZ/CSjpKSEyZMnc//99x+2UMpYcGV0Bjm9ZXQG0Qri8/mkao5LJBIkEolsa2SMrN7pYI72lBCXy8Xxxx/Pfffdx3XXXYfb7T7o62RDRmfIzDsWi7Fr1y62b99OV1cXuq4Tj8eZOHEikydPHkLLgch8rc8880xWrVrFlClTsq2TFg6HI9sKR4Ss3ulgBj9JsVqtnHzyySxZsoQrrriC0tLS/V6TTCazYHZ0yOgMwlvXdVpbW9mxYwd79uzp/dWcTCZ7t0QigaqqlJSUUFVVRVNTU+8+tm3bxvLly5kyZQozZswYFmcZSSaTlJeX9w7YkWGuomwDi1LI6p0OZvCTGFVVOfnkk/nLX/7CueeeS11d3YDnczVp8aHIRWfDMPD5fLS0tLBz504ikUhvIEsFtd27d6PrOmPGjKGiooKGhoaMv5RHjhzJyJEjaWlp4YEHHmDixIkHXdZnMMjFa50OKe/zzz+fp59+elh+KBwtuZ5J52DI6p0OZvCTnFQ6tBdffJGTTjqJsWPH9j5XWFiYRbMjY7idw+FwbxNkIBAgkUig6/p+tTaXy0V5eTmVlZUHzHWYWoppMBb9rKuro66ujtbWVh544AHGjBlzyMVdjxQZywf0eRcVFeF0OonH4zmff7KgoCDbCkeErN7pYAa/PGHWrFksW7aMYDDI9OnTAaQaEJBisJwTiQR79uxhx44d7N27l3g83ts0maq1JRIJLBYLZWVlR70w71Bc6+rqaqqrq2lvb+eBBx6gsbGRU089ddCCoIzlAwZ6X3DBBTz66KMcf/zxWTQ6PPlwrfMNM/jlEVOnTmXt2rWEw2FOOOEEfD4fkPnCsNnkcM6GYdDZ2dnbBBmLxQbU0FKDRwzDoKSkhIqKChobG4c8P2EwGAQ4YN/r0VJeXk55eTler5c//OEP1NfXc8YZZxx1X5eM5QMGejscDioqKgiFQjk9gGcoy8dQIqt3OpjBL8+YMGECmzdv5qWXXmLatGnZ1smI7u5u2tvb2blzJ6tXrx7Q/Ji6r+s6breb8vJyampqcmatMY/HM+THKC4uZvbs2fj9fh544AGqq6s5++yzj3hF9uLi4sEVHCb29T733HN58MEHh7R/9GgZjvIxFMjqnQ658c1hMqiMHj2aHTt28Nxzz3H22WdnW4d4PM7u3bvZvn07HR0d+41+TN232WxYLBbKy8uprq7OtnbOUlhYyOzZswmFQjz44IOUl5dz7rnn5ny/11ChaRqNjY10dnbmZQ3FZGgwg1+eUl9fT3t7Ow8//DBf+9rXhqTZT9d12tvb2bFjB7t37+7tV9s3sCmK0tsEOXr06EO6bN++XcqsI4FAABicAS/p4nK5mD17NpFIhIceeoji4mLOPffctFOWeb1eQDSrysSBvE877TT+8Ic/5GztLxvlYzCQ1TsdzOCXxzQ2NlJaWsoDDzzAddddl1Efkd/vp6WlhR07dhAOhw9YU0smkxQWFlJRUUF9ff0RN7/1R9Zmlmx6OxwOZs+eTTwe5/HHH8ftdnPeeecdNPlBinxp9gQx6nnKlCls376dhoaG4Zc6DGa5zj3M4JfnpILTfffdxw033ICu6/tlFzlQULPb7ZSXl1NRUZHXa3rlE1arlVmzZpFIJHjiiSdwOBycc845FBUVZVttWDj++OP55z//SWtrq9lsbnJYzOCXx6RGapWUlDB79myWLFmC1WqlpKSEyspKxowZk2XD/envLBO55G2xWJg5cya6rvP0009jsVg466yzKCsrG/C61KhJ2Zo9D+V9/vnn8+c//xmbzZZT/X+5VD4yQVbvdDCDXx7Tf+i31Wo9otXgh5tcHq5+KHLRW1VVZsyYgWEYPP/88xiGwRlnnEFVVRUgb5PW4bwvv/xylixZgs1my5lJ2rlYPtJBVu90yP2keCZHjKIoQz6/bbCR0Rly21tRFKZOncrUqVP597//zSOPPMKOHTty2vlQpON9zTXXsHLlypxZqT6fr7WsmMEvjwmFQtLlb5TRGeTwVhSFyZMnM23aNN555x0efvhhPvroo2xrZUwwGOxtjjsYiqJwww03sHTp0pxYkkeG8nEgZPVOBzP45TEyrsIsozPI5z1hwgSmT59Oc3MzDz30EOvWrcu2Uto4HI60ltrRNI3PfOYzvPXWW1lP0yVb+Ughq3c6mMEvj7FYLDmTASVdZHQGOb0tFgvjxo1jxowZbNiwgSVLlrBy5cpsax0Wq9Wa9oR+h8PB1VdfzRtvvJHVAChj+QB5vdMhP8/KBIBIJJJthYyR0Rnk9O7vPHr0aEAkGVixYgVTpkzhuOOOy5baIcm0Ga6wsJDLLruMp59+OmuT4GUsHyCvdzqYNb88RlVVKRb67I+MziCn94GcGxoamDlzZu9KEu+8806W7A6OpmkZJ1QoLy/nzDPPZPny5UNkdWhkLB8gr3c65OdZmQBgs9mkm6AuozPI6X0o59raWmbNmkV3dzcPPPAAr732Wtb7zVIcaT9UfX09c+fOzUrTrozlA+T1Tgez2TOPyZVh3pkgozPI6X04546ODlpaWlAUhQ8//BBN0zjppJOGye7gHE1T3Lhx4wiFQqxbt47x48cPotWhkbF8gLze6WAGPxOTjznRaJStW7fi9Xp7f+nb7XZqa2u5/PLL006ULQvTpk0jmUyybNkyRo4cSWVlZbaVTLKAGfzyGBmHKMvoDHJ4G4ZBa2srLS0taJpGJBLBZrOh6zonnHAC1dXVUkxoTmeaw+E47rjjOO6441i6dCnvv/8+Ho9nSNP9yVA+DoSs3ulgBr88RsalgWR0htzzDoVCbN68uTfApaYHNDU1MX/+fKxWKzt37gRE/55MDGZT3OzZs5k9ezabN2/mnXfeQdd1pk6dOuiDPHKtfKSLrN7pYAa/PEbX9WwrZIyMzpA972Qyyc6dO2ltbe0NcFarldLSUs4888xDJndOJpPDaDp4DIX36NGjGT16NF6vlxdffJFAIMCUKVMGrcnXLNe5hxn88pjBaB4abmR0huHx9nq9bNmyBV3XsVqt2Gw2HA4HxxxzDGeffXbGtRVZkxYPpXdxcTGXXXYZiUSC559/nj179jBq1CgqKiqOar9muc49zOCXx+RCTsNMkdEZBtc7Ho+zbds2Ojs7ewegWK1WqqqqWLhw4WEXqc3kODIyHN4Wi4XzzjsPwzB45513WLFiBUVFRTQ1NR3R/sxynXuYwS+PkXGYsozOcGTehmHQ3t7O9u3bgb45VS6Xi+OOO466urohHYAia/aO4fRWFIW5c+cyd+5cNm7cyLvvvgvAlClTMqppf5zKtSyYwS+PkbFZS0ZnOLx3OBxmy5YtdHd3D6jNNTQ0cMUVV2RlVF2urHWXKdnyHjt2LGPHjqWzs5MXX3yRYDDIsccem1bTYL6Wa5kxg18ekysZOTJBRmfo89Z1nV27drF7924sFktvkCssLGT+/Pk5NadM9mudLUpLS/nkJz9JPB7nueeeo62tjaampgOuLJ8i285Hiqze6WAGvzwmlQC4rKwsyybpI5NzIBBgy5YtxONxOjs7sVgsjBw5krFjx7JgwYKM808ON4FAACCnAnI65Iq31WrlggsuwDAM3nzzTZYvX05JSUlvkvD+yFSu+yOrdzqYwS+PkbFZK9edly5dSkFBATabjfLycs4//3wKCwtpb28HOOSv/1yjqKgo2wpHRK55K4rCSSedxEknncS6detYtmwZiUQCTdOora2lsrIy58v1wRgu72QySSQSIRwOEwqFCIfDRKPR3v5dRVFQVRWfz8e8efMG5YelGfxMTDKgvLyciy66KNsaJjnK+PHje3OGhkIh1q9fz+bNm+ns7CQej+N0OonH47hcLurr63MukB8KwzCIxWK9wSkSiRAKhYhGoyQSCVRVRVGU3kB1qNt9H1NVlYKCAgoLC6mtraWgoICCggJcLldvoAuHwzz88MOD1qJiBr88JtU8VFJSkmWT9JHRGcQcPJCr5iejM8jj7XK5mD59OtOnT6e5uRmgN4VaZ2cna9eupbm5mXg8TiKR6L0tLi6mvr7+iCfYJxIJwuFwby0qVYOKRCK9I1TTDUqtra2oqkpNTQ2qquJ0OikoKKCsrAyPx4Pb7cbtdmOz2YY8Nd5jjz3G8ccfP2j7M4NfHuPxeLKtkDEyOoOYHC0bMjqDnN77OpeWlnLiiSfu9zrDMNi5cyfr16+npaWlNygmk8neFdUPF7AsFktvgBo5cmRvLcrpdGacCCFXmvNfeuklGhoaBnVVeTP4mZiYmOQIiqJQV1dHXV1dtlVyhm3bttHW1sbUqVMHdb/mYrZ5TCAQ6G1GlAUZnUE0xaWa42RBRmeQ01tGZ8i+dyKR4Nlnnx30wAdmzS+vkXGEmYzOkHsjENNBRmeQ01tGZ8i+9+OPP86sWbOGZN9m8MtjZFibbV9kdAY5vWV0Bjm9ZXSG7Hq//fbblJWVDVn2I7PZM48JBoMEg8Fsa2SEjM4Afr8fv9+fbY2MkNEZ5PSW0Rmy5713717Wr19PfX39kB3DrPnlMYO1FtlwIqMzyJkDUUZnkNNbRmfIjrdhGPzlL3/hpJNOGtLjmMEvjxns1aiHAxmdgQNOvI3FYnz00Uds3bqVRCJBLBZD0zQ0Teud2KuqKi6Xi4qKCiorKykrK8Nms2XNWQZk9JbRGbLj/de//pVp06YNeZOrGfzyGBmXrJHRWdf13gnLRUVFxGIxYrEYAHV1dTQ1NR3ygxyNRmlvb2fTpk0EAgF0Xe8NjJqmDZi/lXrcYrFQXl5OZWUl5eXlFBQUZPxlkcrbKBsyesvoDMPv/eGHH2K1Wodlvq8Z/DJg/fr12Gy2AV9slZWVOduZPZgTQoeLXHdOLWfj9/uJx+PEYjGSySSqqlJXV0dNTU3G+7Tb7VRVVVFVVZX2e5LJJH6/n1WrVhEIBIhGo/sFzP61zNRjRUVFVFVVUV5ejsViydmyeyisVmu2FTJGRmcYXu9AIMC7777L3Llzh+V4uf1Nk2NccsklFBYWAuLX+kcffcSmTZt60xKlgmJ9fT0VFRVZ/2KR8QOX685lZWUUFxczYsSIAY93dXUNq4emaZSUlGSUBs4wDEKhEFu3buX+++9n0aJFWR/KfiQMV7PwYCKjMwyv9+OPP87s2bOH7Xhm8DtC7HZ7b96+/kQikQMGRUVRqK+vp7y8fNiCooyrMOe684GWq4Hc9wYxbN3lcvHBBx/wne98pzeLvmyYzsPHcHn/61//YuzYscPa528Gv0HG4XAwY8YMZsyYMeDxcDh80KDY0NBAWVnZoAfFbNc8jwQZnUEOb8MweOutt1i4cCEVFRXs3Lkz20pHhIyDomR0huHx3rBhA93d3YwcOXLIj9UfM/gNE06nk+OOO47jjjtuwOPhcJg1a9YMSVCUsalFRmfIfe99Ax8wZJOHhxoZvWV0hqH3jkajvPLKK0M+reFAmMEvyzidTmbOnMnMmTMHPB4KhQ4YFFVV7Q2KhyPVBykTMjpDbnsfKPCBHE21B0JGbxmdYei9H3300WHt5+uPGfxyFJfLxaxZs/bLaxcKhVi9ejXNzc29y51Eo1E0TWPkyJGUlpb2vtYwjOHWPmpkdIbc9T5Y4AMxRUNGZPSW0RmG1vvVV1+ltrY2a4PczOAnGS6X64ALOnZ3d+8XFNvb27FYLNjtdmkWhzWbhwaPQwU+kDebjozeMjrD0Hm3tLTQ0tLCtGnThmT/6WAGvzzB7Xbv13ywa9cuuru7aW9v36+maLFYaGxszLmFQePxeLYVjohc8z5c4IPcbqo9FDJ6y+gMQ+OdTCb5xz/+wcknnzzo+84EM/jlMfF4HJvNdsBJo4FAgFWrVvUGxVRWEqvVSmNjY9bmfyUSiawc92jJJe90Ah/kXsBOFxm9ZXSGofH+85//vN8Yh2xgBr885lBJaT0eDyeccMJ+jwcCAVauXElzc3NvBpN4PD5sQdHhcAzp/oeKXPFON/CBmWx5OJHRGQbf+91338Xj8eREM7AZ/PKYZDKZ8Xs8Hg8nnnjifo+nUmlt2rSpt5aYqlk2Njb2Zr45WsyBAUdOJoEPjqx85AIyesvoDIPr3dnZyerVqw84ZiEbmMEvjxnMpLSFhYUHDIo+n6+3+TRVU4zFYjgcDhobGzNOUGtmwjgyMg18YCZbHk5kdIbB8zYMgz//+c8H/A7JFmbwy2MGqzZ2KIqKig44QdXr9R5RUCwoKBhq5SEhm95HEvhgeMrHUCCjt4zOMHjeTz31FFOmTMmpTEhm8Mtjsjn3rLi4+ICjuVJNH83NzcRisd6Rp5MnT0ZRlJydL3c4sun9zjvvoCgK//nPfzJ6n8/nA8ip5Na1tbXMmTPnkK+RsYzI6AyD47169Wp0Xc+pcgZm8MtrUl9umdQGhprS0lJOOeWUAY+1tbXx6quvEgwGcTgcFBcXD5isLwPBYBAgK95HugTM9u3bAWhoaBhMnaNi3bp1h31NLpbrwyGjMxy9d3d3N2+99dYBB9dlGzP45TG5NofvYFRWVnL55ZdjGAb/+te/2LZtG16vl8mTJ0uTEHg4Ft8cbGR0BnnKdX9kdIaj937ssceylr7scJjBzyRnUBSFOXPmMGfOHBRF4ZVXXiEQCDBq1CjpfjGbmHzcef7552lqakLTtGyrHBAz+OUxXq8XgPLy8uyKZEDKecyYMVx22WUYhsHSpUv54IMPMAyDqVOn5uSHKRAIAEiTRg7kdAa5y7VMznDk3ps2baKzs5MpU6YMgdXgYAa/PEbGppZ9nfvXBr1eLy+//DI+n4+RI0dSVVWVHckDIGMToozOkB/lWhaOxDsej/PCCy9kPX3Z4TCDn4k0FBcXc+mll2IYBu+99x4rV64kkUgwdepULBazKJuY5AK53M/Xn4xGE9x+++0oijJgq66u7n3eMAxuv/12ampqcDqdzJ8/nzVr1hxyn08++SQzZ86kuLgYt9vNtGnTePjhhzM6LkBrayvnnHMONTU1LFq0aEDGjfnz56MoCo8//viA9yxevJjGxsZMLoFU+Hy+3tFaspCOs6IozJo1i6uuuopLLrmELVu2sGzZMnbt2jVMlvsTDAZ7R3zKgozOkL/lOhfJ1Pv111+nsrIy5xd3hgyDH8CkSZPYvXt377Zq1are53784x/z05/+lHvvvZdly5ZRXV3NggULevsWDkRpaSm33HILb7/9NitXruT666/n+uuv5/nnn0/7uAC33nors2bN4tlnn2Xr1q089thjA553OBzceuut0iaYPRI8Ho90TVuZOns8Hi655BKuv/56KioqWLlyJcuXLx/2/2eXyyVd/kYZneHjUa5zhUy8Ozo6aG5upq6uboitBoeM24osFst+tS4Qtb7Fixdzyy23sHDhQgCWLFlCVVUVjz76KJ///OcPuL/58+cP+PurX/0qS5Ys4Y033uCss8467HFTeL1eFixYwJQpUxg1atR+v1auvPJK/vGPf3D//fezaNGidE9XanIpm0K6HI3z9OnTmT59Ot3d3bz00kt0dXVRVVVFfX39IBoemI/btc4mMnrL6AyZeRcWFkpVuci45rdx40ZqamoYNWoUV1xxBZs3bwZgy5YttLa2cuaZZ/a+1m63M2/ePN5666209m0YBi+//DLr16/fbyL0wY6b4jvf+Q5f+cpXsNvtvP/++1xzzTUDni8sLOT//b//xw9+8AO6u7szPW0pkbFZazCc3W43F110Eddddx11dXWsXLmS9957b0jXVAuFQtLlb5TRGT6+5TobZOJttVo58cQT2bhx4xBbDQ4Z1fxmz57NQw89xLhx49izZw933HEHJ5xwAmvWrKG1tRVgvxF4VVVVbNu27ZD79fl81NbWEo1G0TSNX//61yxYsCCt45aVlQEwc+ZMdu7cSXt7+0FriIsWLeLnP/85P/3pT7ntttsyOXVAVOtjsRher5eioiIURcHv9+NyudA0jVAohNVqxWazEQ6HUVUVu91ONBpF13WcTmfvaggul4tkMkkoFKKwsBDDMPD5fL2jq7xeb+99n8+Hx+NBUZTeLChWq5VQKISmadjtdiKRCCCad6PRKMlkku7ubhKJBFu2bKGgoADDMAgEAr1phvofI1fOqb29HU3T8Hg8Bzwnl8tFPB4nEomkdU7V1dWMGDGCtrY23nvvPXw+HwUFBYwcORKr1Uo0GkVRFGw2G7FYDMMwsNvtxONxEokEDocDXdcJh8O9xwsGg71NQYFAoNc1GAzidDpRFIVQKITdbsdisRCJRFBVFZvNRjQaBcQPw1gshq7rOBwOEokE0WgUl8uFYRiEQqHefKGpY6TuFxQU9F43p9OJqqpEIhEsFktG59TR0YHb7aazs/OA5wTiy8/lcg3LOSWTSVpaWmhtbT1k2evq6kLXdTwez7B+njIte/0/T4FAAE3T2LZtW059RxzunHbv3k1hYSHt7e1pfUcUFhayZ88e3G43mqYd8efpaMpeuitRZBT8zjnnnN77U6ZMYe7cuTQ1NbFkyZLefHz7VpMNwzhs1dnj8fDBBx8QDAZ5+eWXuemmmxg9enRvk+ihjnvTTTf1ncxhmkbtdjs/+MEP+NKXvsQXvvCFtM9bVqxWa7YVMsZqtQ7JPD6Hw8GZZ56Jpml8+OGHrFu3jkQiwejRowdlbTFN06QbcWqxWLI6Z7K7u5tNmzYRDocpLi7G5XKlNTzearXmxBJSmZDta32kpH5QZcK5557LE088wbRp04ZGapBQjKPMXLpgwQLGjBnDN7/5TZqamlixYgXTp0/vff6iiy6iuLiYJUuWpL3Pz372s+zYsWO/QS8HOu5vfvObw+5v/vz5TJs2jcWLF6PrOtOmTeO0006jsbGRxYsXs3Xr1kO+3+/3U1RUhM/nkyo7ey7mbjwcw+kcjUZ54IEHOPHEE4+6T2b37t0AjBgxYjDUhoXhdt69ezctLS3Y7XbsdjtlZWUcf/zxGQ+6Mcv18HGk3ps2bWL58uVMnDhxKLQOSTAYZO7cuYf9vj6qn6rRaJS1a9dy8sknM2rUKKqrq3nxxRd7g18sFuO1117j7rvvzmi/hmH0VmcPd9xMUVWVu+66i4ULF+Z97U/GX5rD6Wy32/nEJz7BM888w4wZM45qX7LkIO3PUDonEgk2bdpEIBDoDXZjxozh9NNPP+rjmuV6+DhS76amJlavXo3f78/ZCkNGwe/mm2/mggsuoKGhgba2Nu644w78fj/XXnstiqLwta99jTvvvJOxY8cyduxY7rzzTlwuF1dddVXvPq655hpqa2u56667ALjrrruYOXMmTU1NxGIxnnnmGR566KEBNbpDHfdIOO+885g9eza/+93vcipLyGBjt9uzrZAxw+1cXl7OiBEj6Ojo6O0/PhJkmNe0L4Pp3N3dzfr16wHRxOxyuZg7dy41NTWDdowUZrkePo7G+8ILL+T+++/PyRUdIMPg19LSwpVXXkl7ezsVFRXMmTOHd955h5EjRwLwrW99i3A4zKJFi+jq6mL27Nm88MILA+aJbN++fcAvv+7ubhYtWkRLSwtOp5Px48fzyCOP8MlPfjLt4x4Jd999d87+pwwWqQ5umciG84IFC7jvvvuYO3fuETd/HqqlIlc5WuetW7fi9/ux2WyUl5fziU98YljmDZrlevg4Gm9FUTjvvPN47bXXmDp16iBaDQ5H3ef3cUDWPr+WlhYAaSadQvac29raeP755wf0V2dCarTzoQZc5RpH4/z+++8zfvx4Zs2aNdhah8Us18PHYHg///zz2O32YUvqnW6fn3wdFSZp43A4cDgc2dbIiGw5V1ZWUllZSXt7+xG9P9WvJRNH4hyPx3n99dc57bTTshL4wCzXw8lgeJ911lls2LAh51azN4NfHhONRqVrjsum81lnnXXEE3RjsdiQTqIfCjJ17ujoYMWKFXzmM5+htrZ2CM0OjVmuh4/B8r700ktZsWLFIBgNHmbwy2OSyWTaEz5zhWw7X3DBBXz44YcZv0/XdenmnmXivHnzZnw+HzfccEPWa7jZLiNHgozOMHjeZWVlNDY29ja15wJm8MtjZExcnG3n6upqysrK6OzszOh9MjZrpeu8YsUKampquPDCC4fB6vBku4wcCTI6w+B6z5s3j+3bt+fMj0Qz+OUx8XhcqkSzkBvOZ511Vu+w/XRJJBIkEokhMhoaDuccj8d54403OOOMM5g5c+Ywmh2aXCgjmSKjMwy+92WXXcayZcsGbX9Hgxn88phIJCLdEOtccFYUhfPPPz+j5k8Z+3QO5dzR0cH777/P9ddfPyRz9Y6GXCgjmSKjMwy+t8fjYfLkyezYsWPQ9nmkmMEvjykoKOhNJCwLueI8YsQISktL6erqSuv1MjZrHcx506ZN+P1+PvOZz2S9f+9A5EoZyQQZnWFovGfPnk1bW1vWW0rM4JfHGIaRc8OLD0cuOZ999tmsW7curdfmkne6HMh5+fLl1NbWcsEFF2TJ6vDky7WWgaHyvvzyy7Pe/GkGvzwmEAgQCASyrZERueScylCxcuXKw75WxrXx9nV+//33WbBgQU717x2IXCoj6SKjMwydt9Pp5Pjjj99vXdbhRK41WEwyIrUml0zkmnNNTQ1FRUUD1k47ELI2afVH07Sc6987ELlWRtJBRmcYWu9jjz2WNWvWEI1Gs9K8btb8TEwOw7nnnstHH32UbY0hR8b1H03k5vLLL2f58uVZObYZ/PIYr9eL1+vNtkZG5KJzOs2fMjZr7essS/DLxTJyOGR0hqH3tlgszJs3L+OpRYNy7GE/osmwcahmulwlV51ra2vxeDz4fL4DNgX1X7lEFvo7d3Z2SrMQb66WkUMhozMMj/cxxxzDqlWr6O7uxu12D/nxUpg1PxOTNDn//PPztvlz27ZtTJo0KdsaJh9TFi5cyAcffDCsxzSDXx4jY1NLLjsrisI555zDqlWr9ntO9mbPZDIpzaCdXC4jB0NGZxg+b1VVOfvss1mzZs2QHyuF2eyZx8g4wizXnevq6igoKNiv+VOWwNGf/s6y9PdB7peRAyGjMwyv98iRI1m1atVBuxYGG7Pml8coinLEK5NnCxmcD9T8KYP3vvR3lin4yX6tZWK4vc8777xhq/2ZwS+P8fv9+P3+bGtkhAzOiqJw9tlnD2j+DAaDBIPBLFplTn9nm82WZZv0kaGM7IuMzjD83oqicOGFFw5L/5/Z7JnHyJZrEuRxrq+vx+124/f7KSwsxOl0ZlspY1LOMo30BHnKSH9kdIbseFdXV1NTU8OqVauYPHnykNU8zZpfHqNpGpqmZVsjI2RyvuCCC1i9ejUgOuxVVa6PU8pZtpGeMpWRFDI6Q/a8TzvtNM444wxWrVrF8uXLhyQJtlnzy2NkyzUJcjmnmj/ffPNNysrKsq2TMamlamKxmFQDdmQqIylkdIbseldUVHDVVVcRCAR49tlnCQaDTJ06ddAWjZbrp6pJRlitVqkGMoB8zg0NDdTU1LBnzx4sFrl+S1osFiwWC2PGjOGZZ57Jtk7ayFZGQE5nyA1vj8fD5Zdfzqc//Wl27drF0qVLB6Uf0gx+eYzNZpNqIAPI6Txv3jwURZFunl/qi62srIxwONzbhJvryFhGZHSG3PK2Wq1ceOGFXH/99XR3d7N06VLa2tqOeH9m8MtjwuEw4XA42xoZIaMziAC4efNmqZq3+q/kfswxx/DOO+/g8/mybHV4ZCwjMjpDbnqrqsqCBQu44YYbcDqdLFu2jO3bt2e+nyFwM8kRZB6EIRuqqvKJT3yCFStWZH2F6nTZdw7X7Nmzeeyxx3J+0VUZy4iMzpD73nPnzuX666+nvr6e5cuXZ5QgO3fPyuSosdvtWVkn62iQ0RmEt9Pp5LrrruPtt9/O+QAC+zdpKYrCscceyxNPPJFFq8MjYxmR0Rnk8Z4yZQrXXnstxx13XFqLT4MZ/PKa/s1asiCjM/R5OxwOPvnJT7J06dJsKx2WWCxGLBYb8JjH48HlcuW0v4xlREZnkM+7sbGRK664Iq3XmsEvj9F1HV3Xs62RETI6w0Dv0tJSTjvttGHPUp8phmEcsIba2NjIhg0b2L17dxasDo+MZURGZ5DXOx3M4JfHOJ1O6TKPyOgM+3uPHj2aSZMmZWWRznQ5VJPW9OnTeeqpp3Ky/1LGMiKjM8jrnQ5m8MtjDtSslevI6AwH9p4+fTqlpaVHNBJtOIjH48Tj8YM+f/zxx/PYY48No1F6yFhGZHQGeb3TwQx+eczhvtxyERmd4eDep556KrFYjI6OjixYHZpEInHImp3dbqe6upqXX355GK0Oj4xlREZnkNc7Hczgl8e4XC7pEurK6AyH9r744ovZunVrzs0BdDgch00VNWLECNrb22lubh4mq8MjYxmR0Rnk9U4HM/jlMclkkmQymW2NjJDRGQ7v/elPfzrn5gCmO5hh0qRJvPLKKzkTvGUsIzI6g7ze6WAGvzwmFArlzBdWusjoDIf3VlWV6667jrfeeitn5gBmkr1j9uzZPPXUU0MrlCYylhEZnUFe73SQKxOvSUYUFhZmWyFjZHSG9LxTcwD/9re/MWfOnGGwOjSZrOSgaVrOJO6WsYzI6AzyeqeDWfPLYw42jyuXkdEZ0vcuKyvj1FNP5cMPPxwGq0OT79c6l5DRGeT1Tgcz+OUxPp9PikTF/ZHRGTLzbmpqYsKECWzYsGGIrQ5NMBgkGAxm1eFIkLGMyOgM8nqnQ260Y5gMCcXFxdlWyBgZnSFz7xkzZuD1etmxYwf19fVDI3UYPB5PVo57tMhYRmR0Bnm908Gs+ZmYZInTTjuNcDick3MATUzyHTP45TFerxev15ttjYyQ0RmO3HvhwoVs2bIlKyPqAoGAdAvwgpxlREZnkNc7Hczgl8cUFxdL12whozMcnfc111zDe++9N+zzqTwej5RNnzKWERmdQV7vdDCDn4lJllFVleuvvz6n5gCamOQ7ZvDLY2QcqSWjMxy9t9Pp5LLLLmPp0qXDFgDN0Z7Dh4zOIK93OpijPfMYGZu0ZHSGwfEuLy/nnHPO4f3330fXdQzD6L1Nbf0fBwb83T9dmWEYvbk7bTZb79I0LpcLi8WCoijS5myUsYzI6AzyeqeDGfzyGEVRsq2QMTI6w+B519bWUltbe9T70XWdUChEd3c33d3dBINBAoEAbW1txGIxDMPA6/Wi6zrt7e0DgmYqiO4bcHPl/yZXPDJBRmeQ1zsdzOCXx6SatCoqKrJskj4yOkPueauqSkFBwSFTmG3ZsgWAUaNGDZfWoJBr1zodZHQGeb3TwQx+eczhlqvJRWR0Bjm9ZXQGOb1ldAZ5vdPBDH55jNVqzbZCxsjoDHJ6y+gMcnrL6AzyeqeDGfzyGBmXIpHRGeT0ltEZ5PSW0Rnk9U4HM/jlMZqmZVshY2R0Bjm9ZXQGOb1ldAZ5vdPBDH55jN1uz7ZCxsjoDHJ6y+gMcnrL6AzyeqeDGfzymEgkkm2FjJHRGeT0ltEZ5PSW0Rnk9U4HM8OLiYmJicnHDrPml8fIOExZRmeQ01tGZ5DTW0ZnkNc7Hczgl8dEo9FsK2SMjM4gp7eMziCnt4zOIK93OpjBL48Z7iVyBgMZnUFObxmdQU5vGZ1BXu90MINfHiNj4mIZnUFObxmdQU5vGZ1BXu90MINfHhOPx7OtkDEyOoOc3jI6g5zeMjqDvN7pYAa/PEbGYcoyOoOc3jI6g5zeMjqDvN7pYAa/POZQGf1zFRmdQU5vGZ1BTm8ZnUFe73Qwg18eM1wrgg8mMjqDnN4yOoOc3jI6g7ze6WBOcs9jAoEAgUAg2xoZIaMzyOktozPI6S2jM8jrnQ5mzS+PKSoqyrZCxsjoDHJ6y+gMcnrL6AzyeqeDWfMzMTExMfnYYQa/PMbr9eL1erOtkREyOoOc3jI6g5zeMjqDvN7pYDZ75jHFxcXZVsgYGZ1BTm8ZnUFObxmdQV7vdDBrfiYmJiYmHzvM4JfHyNhkIaMzyOktozPI6S2jM8jrnQ5ms2ceI+NILRmdQU5vGZ1BTm8ZnUFe73Qwg18eoyhKthUyRkZnkNNbRmeQ01tGZ5DXOx3MZs88xu/34/f7s62RETI6g5zeMjqDnN4yOoO83ulg1vzyGBmXI5HRGeT0ltEZ5PSW0Rnk9U4HM/jlMZqmZVshY2R0Bjm9ZXQGOb1ldAZ5vdPBDH55TCgUyrZCxsjoDHJ6y+gMcnrL6AzyeqeDGfzyGKvVmm2FjJHRGeT0ltEZ5PSW0Rnk9U4HM/jlMTabLdsKGSOjM8jpLaMzyOktozPI650OZvDLY8LhcLYVMkZGZ5DTW0ZnkNNbRmeQ1zsdzOCXx6iqfDNZZHQGOb1ldAY5vWV0Bnm908EMfnmM3W7PtkLGyOgMcnrL6AxyesvoDPJ6p4MZ/PKYaDSabYWMkdEZ5PSW0Rnk9JbRGeT1TodBr9PefvvtKIoyYKuuru593jAMbr/9dmpqanA6ncyfP581a9Yccp9PPvkkM2fOpLi4GLfbzbRp03j44YcHvCYYDHLFFVcwYsQIrrjiCrq7u3ufu+6661AUhR/96EcD3vPUU0/ldfoeXdfRdT3bGhkhozPI6S2jM8jpLaMzyOudDkPSoDtp0iR2797du61atar3uR//+Mf89Kc/5d5772XZsmVUV1ezYMECAoHAQfdXWlrKLbfcwttvv83KlSu5/vrruf7663n++ed7X7N48WIKCgp44YUXcLlcLF68eMA+HA4Hd999N11dXYN+vrmK0+nE6XRmWyMjZHQGOb1ldAY5vWV0Bnm902FIgp/FYqG6urp3q6ioAEStb/Hixdxyyy0sXLiQyZMns2TJEkKhEI8++uhB9zd//nwuueQSJkyYQFNTE1/96leZOnUqb7zxRu9rvF4v48aNY8qUKYwfPx6fzzdgH2eccQbV1dXcddddQ3HKOUksFiMWi2VbIyNkdAY5vWV0Bjm9ZXQGeb3TYUiC38aNG6mpqWHUqFFcccUVbN68GYAtW7bQ2trKmWee2ftau93OvHnzeOutt9Lat2EYvPzyy6xfv55TTjml9/EvfelL/O53v8NqtfLAAw/w1a9+dcD7NE3jzjvv5Je//CUtLS2DcJa5TzweJx6PZ1sjI2R0Bjm9ZXQGOb1ldAZ5vdNh0Ae8zJ49m4ceeohx48axZ88e7rjjDk444QTWrFlDa2srAFVVVQPeU1VVxbZt2w65X5/PR21tLdFoFE3T+PWvf82CBQt6n29sbGTjxo20tbVRVVV1wL68Sy65hGnTpvH973+f//u//8v43Do6OojFYni9XoqKilAUBb/fj8vlQtM0QqEQVqsVm81GOBxGVVXsdjvRaBRd13E6ncRiMeLxOC6Xi2QySSgUorCwEMMw8Pl8FBcXA6Imm7rv8/nweDwoikIwGMThcGC1WgmFQmiaht1uJxKJAKJ5NxqNkkwmCYfDJBIJtmzZQkFBAYZhEAgEetfo6n+MXDmnzs5ONE2jvb39gOfkcrmIx+NEIpGcOqdwOIzf78fpdGb8/5Stc2pra8Pj8bB3795BL3tDeU4+nw9d13G73cP6eTqac0rte9u2bTn1HXG4c2ptbaWoqIj29vac+Y443Dklk8kDfHvvz6AHv3POOaf3/pQpU5g7dy5NTU0sWbKEOXPmAPuvEWUYxmEHnng8Hj744AOCwSAvv/wyN910E6NHj2b+/Pm9r1FVdcDgmgNx9913c9ppp/GNb3wjwzOTj0wKQq4gm2+KZDIp3cAAXdelvN6yXmsZkbWMpINiGIYx1AdZsGABY8aM4Zvf/CZNTU2sWLGC6dOn9z5/0UUXUVxczJIlS9Le52c/+1l27NgxYNDLwbjuuuvwer089dRTAJx33nlYrVauu+46LrnkEg53Cfx+P0VFRfh8PgoLC9N2zDap5ubRo0dn2SR9ZHQGOb1ldAY5vWV0Bjm90/2+HvJ5ftFolLVr13LyySczatQoqqurefHFF3uDXywW47XXXuPuu+/OaL+GYRzxHJQf/ehHTJs2jXHjxh3R+2VBpkCdQkZnkNNbRmeQ01tGZ5DXOx0GPfjdfPPNXHDBBTQ0NNDW1sYdd9yB3+/n2muvRVEUvva1r3HnnXcyduxYxo4dy5133onL5eKqq67q3cc111xDbW1t78jMu+66i5kzZ9LU1EQsFuOZZ57hoYce4je/+c0ROU6ZMoVPfepT/PKXvxyUc85VhqFSP+jI6AxyesvoDHJ6y+gM8nqnw6AHv5aWFq688kra29upqKhgzpw5vPPOO4wcORKAb33rW4TDYRYtWkRXVxezZ8/mhRdewOPx9O5j+/btA3LKdXd3s2jRIlpaWnA6nYwfP55HHnmET37yk0fs+cMf/pA///nPR36iEpCa7pGaaiIDMjqDnN4yOoOc3jI6g7ze6TAsfX6yI2ufX3t7OwDl5eVZNkkfGZ1BTm8ZnUFObxmdQU7vdL+v8zdlt4mJiYmJyUEwg18e4/V68Xq92dbICBmdQU5vGZ1BTm8ZnUFe73QwV3XIY1KTRWVCRmeQ01tGZ5DTW0ZnkNc7Hcyan4mJiYnJxw4z+OUxPp9vvwTfuY6MziCnt4zOIKe3jM4gr3c6mM2eeUz/6SOyIKMzyOktozPI6S2jM8jrnQ5m8MtjZFyoV0ZnkNNbRmeQ01tGZ5DXOx3MZs88JhgMEgwGs62RETI6g5zeMjqDnN4yOoO83ulg1vzyGIfDkW2FjJHRGeT0ltEZ5PSW0Rnk9U4HM/jlMVarNdsKGSOjM8jpLaMzyOktozPI650OZvDLY0KhULYVMkZGZ5DTW0ZnkNNbRmeQ1zsdzOCXx2ialm2FjJHRGeT0ltEZ5PSW0Rnk9U4HM/jlMXa7PdsKGSOjM8jpLaMzyOktozPI650OZvDLYyKRSLYVMkZGZ5DTW0ZnkNNbRmeQ1zsdzKkOJiYmJiYfO8yaXx4j4zBlGZ1BTm8ZnUFObxmdQV7vdDCDXx4TjUazrZAxMjqDnN4yOoOc3jI6g7ze6WAGvzwmmUxmWyFjZHQGOb1ldAY5vWV0Bnm908EMfnmMy+XKtkLGyOgMcnrL6AxyesvoDPJ6p4MZ/PKYeDyebYWMkdEZ5PSW0Rnk9JbRGeT1Tgcz+OUxMg5TltEZ5PSW0Rnk9JbRGeT1Tgcz+OUxBQUF2VbIGBmdQU5vGZ1BTm8ZnUFe73Qwg18eYxhGthUyRkZnkNNbRmeQ01tGZ5DXOx3MSe55TCAQIBAIZFsjI2R0Bjm9ZXQGOb1ldAZ5vdPBrPnlMUVFRdlWyBgZnUFObxmdQU5vGZ1BXu90MGt+JiYmJiYfO8zgl8d4vV68Xm+2NTJCRmeQ01tGZ5DTW0ZnkNc7HcxmzzymuLg42woZI6MzyOktozPI6S2jM8jrnQ5mzc/ExMTE5GOHGfzyGBmbLGR0Bjm9ZXQGOb1ldAZ5vdPBbPbMY2QcqSWjM8jpLaMzyOktozPI650OZvDLYxRFybZCxsjoDHJ6y+gMcnrL6AzyeqeD2eyZx/j9fvx+f7Y1MkJGZ5DTW0ZnkNNbRmeQ1zsdzJpfHiPjciQyOoOc3jI6g5zeMjqDvN7pYAa/PEbTtGwrZIyMziCnt4zOIKe3jM4gr3c6mMEvjwmFQtlWyBgZnUFObxmdQU5vGZ1BXu90MINfHmO1WrOtkDEyOoOc3jI6g5zeMjqDvN7pYAa/PMZms2VbIWNkdAY5vWV0Bjm9ZXQGeb3TwQx+eUw4HM62QsbI6AxyesvoDHJ6y+gM8nqngxn88hhVlW8mi4zOIKe3jM4gp7eMziCvdzqYwS+Psdvt2VbIGBmdQU5vGZ1BTm8ZnUFe73Qwg18eE41Gs62QMTI6g5zeMjqDnN4yOoO83ulgBr88Rtf1bCtkjIzOIKe3jM4gp7eMziCvdzqYwS+PcTqd2VbIGBmdQU5vGZ1BTm8ZnUFe73Qwg18eE4vFsq2QMTI6g5zeMjqDnN4yOoO83ulgBr88Jh6PZ1shY2R0Bjm9ZXQGOb1ldAZ5vdPBDH55jIxJaWV0Bjm9ZXQGOb1ldAZ5vdPBDH55TDKZzLZCxsjoDHJ6y+gMcnrL6AzyeqeDGfzyGBmT0sroDHJ6y+gMcnrL6AzyeqeDGfzymMLCwmwrZIyMziCnt4zOIKe3jM4gr3c6mMEvjzEMI9sKGSOjM8jpLaMzyOktozPI650O+Zu4zQSfz4fP58u2RkbI6AxyesvoDHJ6y+gM8nqng1nzy2OKi4uzrZAxMjqDnN4yOoOc3jI6g7ze6WDW/ExMTExMPnaYwS+P8Xq9eL3ebGtkhIzOIKe3jM4gp7eMziCvdzqYzZ55jIxNFjI6g5zeMjqDnN4yOoO83ulg1vxMTExMTD52mMEvj5FxpJaMziCnt4zOIKe3jM4gr3c6mM2eeYzH48m2QsbI6AxyesvoDHJ6y+gM8nqngxn88hhFUbKtkDEyOoOc3jI6g5zeMjqDvN7pYDZ75jHBYJBgMJhtjYyQ0Rnk9JbRGeT0ltEZ5PVOB7Pml8c4HI5sK2SMjM4gp7eMziCnt4zOIK93OpjBL4+xWq3ZVsgYGZ1BTm8ZnUFObxmdQV7vdDCDXx4j43IkMjqDnN4yOoOc3jI6g7ze6WAGvzxG07RsK2SMjM4gp7eMziCnt4zOIK93OpjBL4+x2+3ZVsgYGZ1BTm8ZnUFObxmdQV7vdDCDXx4TiUSyrZAxMjqDnN4yOoOc3jI6g7ze6WBOdTAxMTEx+dhh1vzyGBmHKcvoDHJ6y+gMcnrL6AzyeqeDGfzymGg0mm2FjJHRGeT0ltEZ5PSW0Rnk9U4HM/jlMclkMtsKGSOjM8jpLaMzyOktozPI650OZvDLY1wuV7YVMkZGZ5DTW0ZnkNNbRmeQ1zsdzOCXx8Tj8WwrZIyMziCnt4zOIKe3jM4gr3c6mMEvj5FxmLKMziCnt4zOIKe3jM4gr3c6mMEvjykoKMi2QsbI6AxyesvoDHJ6y+gM8nqngxn88hjDMLKtkDEyOoOc3jI6g5zeMjqDvN7pYE5yz2MCgQCBQCDbGhkhozPI6S2jM8jpLaMzyOudDmbNL48pKirKtkLGyOgMcnrL6AxyesvoDPJ6p4NZ8zMxMflY8LubH+ajl97MtoZJjmAGvzzG6/Xi9XqzrZERMjqDnN4yOsPhvbu27Rjwtx6P8PRt1/Kln3+SX/984xDbHZh8vdYyk1Hwu/3221EUZcBWXV3d+7xhGNx+++3U1NTgdDqZP38+a9asOeQ+77//fk4++WRKSkooKSnhjDPO4N13383ouACtra2cc8451NTUsGjRInRd731u/vz5KIrC448/PuA9ixcvprGxMZNLIBXFxcUUFxdnWyMjZHQGOb1ldIZDe//p1h8zcrKblc++iWHA2n/+nXd/P4YvL/ku4+t28L9PXDO8sj3k47WWnYxrfpMmTWL37t2926pVq3qf+/GPf8xPf/pT7r33XpYtW0Z1dTULFiw4ZIfpq6++ypVXXsm///1v3n77bRoaGjjzzDPZuXNn2scFuPXWW5k1axbPPvssW7du5bHHHhvwvMPh4NZbb83rSZsmJh9XDF1n3X2n882HLuKYEZuZNP9YfnHjVzl24Vnc+tg9tLc18cSzTdgdZmOXiSDjkmCxWKiuru7dKioqAFHrW7x4MbfccgsLFy5k8uTJLFmyhFAoxKOPPnrQ/f3xj39k0aJFTJs2jfHjx3P//fej6zovv/xyWsdN4fV6mTRpElOmTGHUqFH4fL4Bz1955ZX4fD7uv//+TE9ZWmRsspDRGeT0lsU5Hoe2j1b3/t3fO9K+m7Nn/Z0/3XYu9yydy+5dTfz+4dG8+ocJ/PcT/49xo1bw8utX8rOfWxk/PksngDzXel9k9U6HjEd7bty4kZqaGux2O7Nnz+bOO+9k9OjRbNmyhdbWVs4888ze19rtdubNm8dbb73F5z//+bT2HwqFiMfjlJaWpnXcFN/5znc477zzuPrqq5k1axZ33333gPcXFhby//7f/+MHP/gB1157LW63O9NTlw4ZR2oNt7Nh6CQSfhIJL8mkj0TCRyLhHXCbjHeRCLeTiHehK0lUi1NsmgNFsaOqNiKRJIpiY9u2UlTVjqrae5/ru29HVR04HA3Y7SNR1ewOtpalfPzua//Ltx74HOvfWEn9jKm93omObfzPt+7m+fd+zbwL7+PRR77HV25oI7irjnv+8QeiYSe7987mwgvhc5/r29+2FR/RMG08ijp8tUBZrvW+yOqdDhl9+mbPns1DDz3EuHHj2LNnD3fccQcnnHACa9asobW1FYCqqqoB76mqqmLbtm1pH+M73/kOtbW1nHHGGWkdt6ysDICZM2eyc+dO2tvb9+sPTLFo0SJ+/vOf89Of/pTbbrstk1MHoKOjg1gshtfrpaioCEVR8Pv9uFwuNE0jFAphtVqx2WyEw2FUVcVutxONRtF1HafTSSwWIx6P43K5SCaThEIhCgsLMQwDn8/X277u9Xp77/t8PjweD4qiEAwGcTgcWK1WQqEQmqZht9t70xA5HA6i0SjJZJJwOEw8HicYDFJQUIBhGAQCgd4C3f8YuXJOO3fuRNM0FEU54Dm5XC7i8TiRSOSQ55RMBuno+BCbbQ+x0HpCvrWgezGSfhIJH7rSTVINo2sHT9+kxMHSrWDxG1i6wdINSgLiVjAsoNtAtynodgXdCroVulLPWQwM68EnCCuGBatWj8XRhNM5DoulEaijqGgymlZJMBgc8v+nlpYWPB5P7//HYJa9dP+fDndOydfv4LevXcfU+rWoVbW0t7fT2tqK0bGFtZuu4bf/WM2ppzzGc3/5HiUFbZxxwTG89dEZPP/8dYwdG8Xrhbvv7mDTpi6Ki4vZ9LffccbXF3HLJ+/nhh8tHLZzCofDOfkdcbhz2rJlS+955Mp3xOHOKd2VKDIKfuecc07v/SlTpjB37lyamppYsmQJc+bMAUBRlAHvMQxjv8cOxo9//GMee+wxXn311QGLKB7quDfddFPfyfQ0jR4Mu93OD37wA770pS/xhS98IS0nmQkEAiQSCalqucFgEFVVGTFixGFfq+sxYrFthMOriEd3EetaRdj/EXu0XcRtff3M1k5w7gJLANQYqHFQkoABWC3oNhvYNZJ2VQQzJySsSZKuBIZFQS/RiBVbSChWFF2DhIKGBUVXUeNgw0IimMCIg9PiQEkqENVRE6AmdNQgOLrsONpVbJv2kND3EK5LEKrbQqhxB92NrxMpjYIKe/aAajjQrI34fMdgtzeRSIzAZpuCzTYaSO+zlO61BvZrZckVksv+wMu+5axZcz+//c0eIAFAqPkV4sbXePTdm+nqqmLK1Df4xb1X8sMfXIQlqPLzex5n1KgEGzfaefxxH+XlBl0dCTr+spAv3n8bLmuYi2+cM6znkirXTqdzWI97tKS8U5WMfEIxjjJ/zYIFCxgzZgzf/OY3aWpqYsWKFUyfPr33+Ysuuoji4mKWLFlyyP385Cc/4Y477uCll15i5syZaR/3N7/5zWFfO3/+fKZNm8bixYvRdZ1p06Zx2mmn0djYyOLFi9m6desh3+/3+ykqKsLn81FYWHjY4+UKqdr4oX4Q5BoHc47HvbS3P0l3+7uEOlcSjm0irO0FVRRfNQK2drCEet5gt2HYrOh2SDp04rYohkXnQGghsPjBEgSrX9Tw1IgIlIYCuhOSTtAtiNijgtFvQwVD6/lb67dZwLCpxD0GhkV4KoYVl7URpzISl78Q104V5/oQjvf3kNzTTMjjI1wHoXoIj7ETqoVYYd+CogUF06ir+xqVlVegqvYhuda5QPf7T/N+y8X85J6HWbHlKj545UVa3/0GXZ61xD06we4irrhiK1PGvsnmbdMYM345v7ruy3z3rxt5/kUbhgFf+xr87GcQb9/Guqdn8/sPP8Evfnkvzz+b5MyztWE9n1y+1odCRu90v6+PqtMhGo2ydu1aTj75ZEaNGkV1dTUvvvhib/CLxWK89tpr+/W/7cs999zDHXfcwfPPP59W4Ot/3ExRVZW77rqLhQsX5n3tT9OG9wM+GPR3NgwDb+tztC7/IXvtS9E1HfseEaCscbA4LMQ9CtHiBLrDIFIHSgxcLWDfFcPqj6GIygKK1QE2G9gdGA4bhkNDt0HSZpC0x0k4oiQKo4RHRtGtiUE8o30CbixO1LeRGBvpcqgkx+gwBjgPrEoxTttMXPFqXO0OSrfpFPw1iHXVdsLhZkK1SfZ8upV1wevYvPk71NQsoqbmRmy2igMe+XDkavmIbn6PD5sXEghX8Nw7l3LNp25h5c4fQS3icibhL7//NqFQAcvXnIaCwYzyAKfevA5vwMbo0Qa/+IXCOedA8P0nWbP+CjbFR3P/fT/ji19k2AMf5O61PhyyeqdDRsHv5ptv5oILLqChoYG2tjbuuOMO/H4/1157LYqi8LWvfY0777yTsWPHMnbsWO68805cLhdXXXVV7z6uueYaamtrueuuuwDR1Hnbbbfx6KOP0tjY2PtLo6CgoDej+KGOeyScd955zJ49m9/97nf79VHmE6FQ6PAvyjFCoRCJ+G68679EW/DvxB0RVA3UqIrugugIsVl84NqeoHg9OEJFWEpGYFRWEi+3ESnpoLtiF12Odgxrqv0/Ijbdj5IAxRCtnqiidjeAJANbFw3xegzAUHrvK4Yy8LmkghZX0aIKakxBTSpYIho2n4a1C6wtAQzNIFIN4RoI1xskbfSOuU7EvXQH3qNbUdALwZhuwHQoLDyJ+srvU/mPDqr+5+d0R1tpWWSw/fg72L79Tqqqrqau7mu43ZMyvtbZxjAMYrFWwm0rCG79N3t3/xF/SStGOTz9p2vRUbngzN+jRMBwACosfecsHvr7tzAMDRUd1WLlV/+4EhSwW8OsWR7GUVxK21NfZZ39F1jjbn72m6XUNVjp/zvc0HXu/9ZDXPXdiykoKx7S88yFa30kyOqdDhkFv5aWFq688kra29upqKhgzpw5vPPOO4wcORKAb33rW4TDYRYtWkRXVxezZ8/mhRde6O1UB9i+fTtqv1FWv/71r4nFYnziE58YcKzvf//73H777Wkd90i4++67OeGEE474/TJgtVqzrZARCV8r3tfPoKu2WQQfO9j2gnsTuHeB1VKNUVFOrM5GyOMj0tRBcHwQ3eoDfMC6nojGwbvGVDBsPS9LghoFS0TcajFRc1QTYrALyj7NmBoYmtHbxIlmDGj+1O2QKOrrbE/tS7eJJlAADLDFCnGFyyntcuFcG0fb1QVt7ehWXQTGWoNQHUSqAAv4/W+wxv8GykQHFU8tZMym2zjmp39g9J2vsuvTxey86M/s3v17SkrOpK7u65SWnpVWP/twlQ8R4HYT7lxJePvbhNs/JBRuJqzuIlzgQ7f11I4NoBJRu/OrPP3UIk499XE8I9ohBpufOZ0H//kTXl87refFBqg2kokEimqg61Z+fecq2l66h87Qq3gb2qlsHslftq1hxWo3b74Jqe7vZHcn93/nW3zh3t+TTD7AF352/ZBeA9k+iylk9U6Ho+7z+zgga59fe3s7AOXl5Vk2OTSBjrfZ9fattGn/Jmk30EKQLABr3IU9Xk5c7yDq6t5/Vuq+gS4BNp/ov7MGxK3db8Hud2ALF2BPlmJzVmHx1GItH41WOxqqqqCsrG8rLATDgERCTDA70BaNQiQitnAYolECGzeibdqEffcWQsG1hJQdhKrjhBoQW70IuiBGjGphoa87+wdGBUesBGekFGenC/fGJEUvtRLTO+iaCa1nQbxEvLSg4Diakv9Fyb1voP/lMdoWWGn5TCHB4jZcrgnU1X2NqqpPo2kHH2AxmOWjN8D5PiK8423Cez8gFNpIWNlJ2O0dEODUiLjV7UCqVS0pHtdtEIoX8OCDt/PEE9/g8W+cgdN5JT955Vpef8uCiIwqYKCqCnZrlPPPu5cVyxdQ4Pbxs3tPQYtC8dZiKksuoWX075l7gsq3vw133CEOFd7wGm+9chWfvGUZ0xo7ePG9KaQ5Ju+IkeWzuC8yeqf7fW0GvzSQNfjt2CFyHNbX12fZ5MB0fvh7Nm35f3QX70Xzg7vdBbpGqCJIotDoC2r7BDklDI494Nqj4QqUUcAYPGUn4Zx4KkpdPZSWikBms6XtYhg6yWSAeLyrZ35f6tZLItJGIriHRGgPiWgH8XinmAdo+EmoYVAMdL1n4I2qoaREdQMloUMyCYkkhpHAIImhGeiWnikRVnoDgBYEezuoIUiUaUQqdRTVQXXlVdQ8BZ57nsRb38WmGyEwXlwPq7WS2sLraHjUQPntffgaA7R8ZQTto3ZRUnImU6c+e9Ba4OHKx8Br0kUi3kmiu5W4r0Xc+ncQ7m4mTAthV9eAAKeFRJA3rJDsaa4EUgM2RZtTqju057lkQuWlP9/A7x//HwKRUi67XGHtOpXly3t2ioLVGiYetwMKV52/mMtvuIPVa07k1lv/ziNfuY5z5tVQdMqXaO6o4X//Fx56CCZNMnj7bQWbDTqe+wFr47fzw7v/yLsrL2XNOhs1NWkXkyMm1z+LB0NGbzP4DSKyBr9Uirja2tosmwwkuOFZdr78Fdrqm0n2WyhaiYovy54f9qghcG8RIzij5aKmkHQpJDxGX22pH5ruwqaUYLWWYbVXYXWNwOqoxmotQ1Gs6HqUZLSLWOcmooFtxJJ7SCgBEmqYpCV60KZSLSRGgloCPbeprVvFElZRdDBSzXC9kdro60vsuTWUnvv7/B0rhu5REK4TNcEBJAFFAdXAaimnMDSa0r9uw7p+D3tOh87ZokapKFbKis5l3Ntzsd1yN+1fms7q015h4sQ/UVKyoCeYd4lAFmsn4dtJV+tG9MhebGpIBLakjzh+EmqIhBYmYYsdNAeUGumZMhIDLAoJp9FbsyUpat5qXEG3QMLd77nUOQFoonZetKWQtWu/xh3//i6rNjiYNAlaW6GjI/UGA5stTCzmoKx0N6Gwh3kn/YVvf/cGXNtcfPZ/dlJWV8S//63w5ptwzz3w97+LSv3Fp6xm6Qd+nvxTFbx/A1tHvsaKv3yGb/zm/3jkEfjUpw58foNNrn4WD4eM3mbwG0RkDX651GShJ2O0v/pDdu7+Db66DmztUPG2jagnRtd0SBaR+nGP1WflmNarKZ35RdRx4+C992DrVvFt2N6O0dFO0t9KPLKHWLyduNFFTPMTrjGI1EC0AmIlkCgQUxSM1BSFw0qCoisoOj0DWxQUVBRUQBP3FQuKagHViqpaUBQrKBq6IZ6zWGziNWgiaGkair0Aq6UEi6UEi1aERfGIATfJGEYoCF0dGBvXY2xYR0zvxD8JukfSGxwsQXEeicKeHwdGv/PRRXDW7X3Np1a/ihrViVYe+lwt3T0BPTW1I66gKjYUzQqaBpqKblEwLAYJS4JYQYRYYbw3IKoh8cNEQSVhM0i6jb5mzH1qdSks7eDZZaNQP4byMZ9hXcmNfOGrDpYvB5vNIBaj5+RE86bT6SMcLqKmppmrL7ibaKSAXzz0vzz4wASOTyisLlzFZZdbueMOeOYZeOstGD8ebr4Zzh3xEy774Vi2bZnM3/77BIJj2yhYcynn/OAJTj5Z4a9/ZcibO1Pk0mcxE2T0HpapDia5TTQaPfyLhtqhaxO7X/wau2zPEStOUBR2ccyOK+l2tLJn/uvEPVC0RqX8EZ3ukdC2AOJFcVYXPQD+B9Dec2FTy7COK8fmrMHqqsNmH4HFMoHI3rV0t71FmE6i/UZNKgmwdYKjFbSQgpa0AkpPE5xOwqWTcBskXLrod0qhgqEaGAlQowZKDBQj2Td/T6X/93LfaFHoq9ElGVC7A+BAA+YMsR8lCYoOSi2oVcJdjYOjTTQXJjyQKBa1YluHCFTxIhHcUcVAHcPSExQTgAXibh3cULQCfDPAGrJRsqMa3aKjW3QSljgJe5S4LUq0IkakxugnFRWbPjAZQOoa9A9muqMn242ii6DXr5laiYPNC+5WN2WR6Xjq5uEafSqJU6bx+ochfvaHME/eWkegu+8/IB5PYrEkSCQc2O0hotECaiu2cu3F9zBi6oc88Icf8uZbF3PhrFc4bfQ9rIteyKKrwOWCW2+Fk06Cp5+GM+aupeWZq3hyk4M333mbW265imj1XiYn7uDzr94CwG9/O3yBD3Ljs3gkyOqdDmbwy2P6L+s03Bibmtnwn0torVuN4oGqTY3UFt9KwfEz2f3fc2j5ikhL1BD7BI2fexj1mjjcdx+NX15Md9luvFOSdB4P3aNDhI0Q4fgOiL8vBnWmUADHvgcWwSBaSU/Nx4B4DCUuvszVeE+AiarYYzYURQNVxVAVUEHXDHQtQdKaIOFKDmZClYH0awI1NDHQI9kvsCgJDUtEw9GWQPPrJMotRKoSxAwVZ6eTgmUhYsUG4ZEKSYchgm7q/T2fat8McRt3xtg7anvvnEe0ngn7B5rCleipbXaD1hNYk06FpBOSmjGw1qmIwG3rAudeOx5vJSWWWXiOvQp99lTCyW34N73J0nf8vPT3Kl5eVs6mbYUk9VS2EAOnI0BxcRvtHSOIx90kEhbKC/dw0nHPMPfsPzG6ZhWP/eZHfP+XD9FQm+CPfwRdn8zJ15SQyk1x+ukJvnnVk4x2/pyu6Ae8uyaEUQ//99VXGF+7gW/MnUF04m/58W8KefJJeOIJqDxUrXgIyOZn8WiQ1TsdzGbPNDCbPTNHnzqJ9xd9RGA8lLnOYOzU/8PhaIDOTowvLsK74Ql2XKXReVwcu6WWupHfYMSIz+L1il+a5R0dcN99hD96BW/FTnad2EFwtC5qOKkv+n6jPJVkTw1MI7OfdAcq/cNYI+ilv8c+cwxRODrPpBhdWvgRqIoDxWIDiwVdU0hadZHBxh4l5oiRdCTENd7HTY2BtQscnVYcoRLctrHY66aRrC8jHu8gEWol2r2NznAb69orWfHRybzxxiWsWzeLeNzReyIKSQwUHPYgkaiL1H9WocvL2fMe4YKrfsbIks1YV4/h0Td+zv0vno27QOWWW8QYpttvhy1bQFEMTjp2FV//1BcoPfYtDCvY2xRsQQeB0WGan7qG//r5Eu69Fz74AB5+WLTkfvObYh/DjYzNhyCnt9nnN4jIGvx27doFQM1wDGfbl/feQ//G12j1vMmWG20kCqC+4SYaGr6LxVIo+vAWLyb44n3suDhK2+kGKApqwoWaMDC0BLoaR++fkqwnEChRsAcdOLo9WMNOkrYo4UI/4eJwb21GDYNjN9g7wOoDNaaIKQZRUOM9TZoJemtBhrWnBmYVf+tW8ZhuozdptWHte96wQdLWN2Iz1SRopJr/Us2aBj19iH23vRPj9X4T5Om5T885xnter4v9JzyQdAnfVH+avdNO5doqDF87MXuItgU9j++GaBWiBdPRt88B6P0e79d/qMZE/58WV1EMFRQVw6YQdybQbWKkimFAV1cl27ePZ/u28bRsGs+ObePZvH0ybd5aekcsoaCqCTQ1TjzhGCChKDo1lVuYPfefnHPeHzimfCUV22rxFF7OY9u+x//8vJhIBObNMwiHI7z9to14XENVkpx0/N/58s1foNK9h+LNHjzqBLDb8avr6GrcS+2WEzjvrjfYu1fB64WaGvjyl8XKDtlKY5rVz+JRIKO3GfwGEVmDX2o1jaNJBnBUGAY8/TSJ225mx6xN7LhKQ1FtOBmB1VqJzSlurR9sJdL8Bt6x3YRrAAtYOsEa6slm5RZf/IaNg9d2UkFEB1XXUNDE4A3VhqJa+5YZ0hw99/uWJFIUFcOIo+sR9HgIPR7CSEQwklF0PYphxNCJoStxdC0xMCDvgxqhN4MMqaCX8ut/iziX/v2FqdGfhtrTj3egpsmDTeI3DvDYwTjIa9WI+KFg9YumT/x2WvdOZHvbFLZ0TmFL53g2dY5hY3s9vrCYLa4qOm5nN/GERiTmAnTs9hCxmANjnyG5bncn06a9xrlzH+LUqlcp1wtwWcbgrjkB68lX8rPfWfjfnzfg8zuw26JEYk4UJYlhqLjdPi4473d8Yd7/UNldgepqRHOH6XSupLuqG5Lg3FDCWyt/ws/+9Rl27IAxY+D734fLL89o1suQkPXP4hEio7c54MUEl8uVXQFFgYsvxnLeeYy67z5G3HQHrce2EivfTKx4M6EqkeYrUQ/s89lKlEKyUMFQDVBB6wZbm4ItYMHWpWLr0NGNONGKnqTTdjFARLeDbktiaEkMLUYyVRuz9Buwss+UgwPSk7A6U/QD9EEe+Npkvu+032eImq/uEk2V8RJwbYZQz/KXlWurqdg1lqRShGavRPdMYlNwAhv9DaxrL2fdzkLWbbXTvEkhkRAHdNjjFLr9KEoUQ4sATkBFN1RiSQXdSF0slWhUzF/R1Djjaj7ggsnPs3DGGsaML0OpaSDmmEo4aKdlVxuvfjiWf/xxHu9/eiyJhB0waKhej12NsWn3JMoKurj53Ge5fmErSaOZzlgt7fUbSHg2Y/FBWUst7s7P8ueN3+VXD1fR3g6qCscfD++8M7yDWg5F1j+LR4is3ulgBr88Jt11rYYcqxW++EUcX/wijbEYbNpE4H+uZfm8ZQB4tjoZvew4Eo4ErSNW4Z3QTdINlqCBswWsXlELipUYRMri+Meyf7/U0ZKkN2myqoPaM8pRSYpvz960ZhbQM+lXPNiXb7JnpGdCpECjZ5SnmqR3cI4WAptPxdZtxRZ2YY8VYEsUY/PZsD+znESFlfd+G6f0bTG9IzCB3oCt93SzJdxg3azR4hxB8IUqOgtPZtueEgKBL7B6tcHmZhd7O/omWxZ5unA59mIoBk5nAYGAGJwSiVqxWBRsVkjqGqqqo+viYNGom1Rbb2VRG2ce9x4Xn7GSqZM/IqFvJJzcTsjRztu6kw/fmcebb17EsqX/RXtnXe9xKzydnDxpE4qzgn+8eQyFhfA/t21l4aTv0514jjVle0ED91YLFZsm4K66BN/Yb7P4mQKWLBEJeXQdiovhppvgK1/JncAHOfRZzBBZvdPBDH55TE4mpbXZoKQE97JOmqKw8zIrgcYwzfYPCJUFxYTthEJT6BrqzrxXJI9uaxuwGVva0ONBdD2K37EVr201vpIWAnXdGBYRLD0bFBztFqwhG9aoHUvUjiVhB4sFw6phWBUMJSkyriAyr+g9t+JxXdwqSQyLioIF1bCiKBq6zQI2FcOmoVsVsWxRUgfFgt3pFvMANStKz9Z732IT9y0W4WHRwKZhuFQsliJsthHY7bXYnfVY3bUoFZUHb6/7xS+wfPXruOLf5e2a5/H8YRKtO+x8eGYN7e01dHaMoL2jho6OGrq6qtD1vvZTqzVKcXEbdnsIiy2ApyBGICg6w3yBIvSeSeWqmkRV4+i6+KXRHSom2FvDE02/blcnJ5z4T2bPfpaZM1+kqEjMTE8mNd7bMIrWDyewas0VvLbuQra0j8LoNx+ittagpkahqytJc3MpT75TysRRG7nx0ge44IIfYxnRQWsESjYVMS5wHoHqm3hbn88/Xu9m6VIHO3dasdtFtrmaGvj2t+GGG/ryd+YSOflZTANZvdPB7PNLA1n7/HJ6pJauw3PPYfzqXjo7nmXnQpXOmXpfM6EGiqFhUyqwamVo1kIs9hIs9nIs1lKsESvJfz3Bjjlbe3epxSxUh+ZTPfHr2BtniT4+xYqq9kxpGHD4GNFoC9HoDpGuLLKXRGA3iVAbiXAbiVinyIai+0kQEFlPLGF0yxH8Ek71/fVLAtN/oAuIgTWpWpthgN9XRufeRjrbG+nsqqO9o5b29iqxdVTQ3lFFR1clyWRfFVhVk5SU7KG4uI2CAi92ewhFMYhEXPj9ZezdW0ewJ8gpShJPQRdWS4xY3E6wuwSjJ7BZrWE0LUkiYSWR6Oto1dQ41SXbmVrzLseO+ICTRr7L6OIOdviOZUvXFDZ5j2Fjx2g2tNWysbWYeGJgu7HHk6ChxgfJIM3bq4jGHJSW7GbmrBeYOfMFZk5/kRHRvbjaXTgTNQTUT/G+voj/rKzk1Vdh+3ZRm2tsTBKNwq5dGuPGwXe/C1ddlf1+vUOR05/FQyCjtzngZRCRNfjt3bsXgIqKI1vvbdjYtAl++1tCr/6RjtFtJBxJQg3Q3ST6BI3B+FJLZ6qAcYD7B3isbwCL0q8eI/7dN4VZ6n4sZsPnq8DrrcDnK8frFff9/r77nZ0jRK2tc0RP/so+Skr2UFq6G4+nE6cziNUaRVEMkkkLkYiL7u5iuroq6Oio7ZlaIFDVBE5nAIslTiJuoztU3PucwxFAM3QSCRuxpB2jXyenTYtTWRjimLogZ80NMv9kg257KRv2FLN2k421a2HdOugZD9HjCA6HTiBgEAxqaEqChpptOJ1d7O6oo6urGqs1wtRJr3Pi6BeZP/ItplX5cBdMwFl1PHtcZ/J6ywRefdM6INhNmwannAJ2Ozz3HKxcCdOmxbntNisXXyz6+HIdaT6L+yCjtxn8BhFZg19zczMAY8aMybJJ+jQ3N0MyyRinE558EjZvRvd3oYc6SUa8JBMBkskgSULEHBEC9WGCI+PEygziHoi7wei/WgD01rz2rX1Bv1tl/1uj/9/0e9yA7u5CfL6eQJYKav5yfN4KvD2Pp+57fRWEwx72xWYNU1K4l2LPXgpdnbhtfhxaBI0EJFWiUSehiAdvdxltwTo6QpUDApSmJLBZIiiqTtKwEI31zyANmhbF4+xEs+uiFhcpIRzV0Pu9RlWTlJdrNDWJIDNpElRUwI4dIritXSu2zs7UPg0aG0M0jWyjyNmB359kW0spG7c1ktStVFZup6RkN93dxezcORbDUBlTuZ55497nrOl7OH1eKSXHzoXGUWzdofHqq/RuqWA3fTrMnw/z5om5fUuXwu9+Bxs2wGmnwTXX7OSEE8KMHStZuUauzyLI6W0Gv0FE1uAnY5PFoZwNw6C7azneDx+kq/0FvJ7NJB1J1DC4t4K9XcER8mBPluFQq7Fb63A4RmJ116CUlYtvdYdDRK99ly1KJDBicbx+lZY2Gy3tDlo6XWLzumnpctPqd9EedNLe7SCW3L+7vNgRpsITodwTpaIoRllRArcL7A4Fi10FTSOhWIkmrXi7LbTutbBrr4Uduy0EggOrL3a7GCcEEIvRk/Oyj8JCGDHCoKxlJc54J/4pEWIdBXjjZfhDpQT8JSSS/WuPOkVFKnV1MGrbK4wKfkjkv9qIRIoIBK5hwzoHm7Z4iEbFQZ32MCNrmxlZv5YRdetxeLwkEla83gq2b5/I+vXH4fNVYreGqC3fjJUkLR1NdMcKKHaFWHC8l7MvdLPg0kLqG8R8u7VrYc0aeP31Awe7+fOhqQmWLYMXX4SXXxYJru12OPdc+M53xCjOfCvXuYyM3mbwG0TM4Dd8HNB5wwa2vPsFdpW8TtwdR0lA0Torxd3HUDLiXDxjL0AdORqqqw/ZBtbVJebWt7QcfOvfv68oMGIE1NWJrbJSDKaw2/tGEiaTYlm/jo4wnZ0qPp+9d2yO17u/g6qKvilNE92esZjYR/9jVleL45aUiLyVFot4bSgEHR0GbW0GbW0KsdiBUsGATQvj8vgpKOjC6QyiqjrBYDHte+uJxpz9XJKUlrZSW7uRhoZ11I9YR4nmRfdb6dpTw5bdU9nYOoWtHaPRe8bGFdgjWDWDUNxGNC6q1y6XwYwZCgsWwIwZImhv2EBv0+jatSKIpc6vf7A79liRgeWll8S2dm3fa844Q2wnnQTOfqtd5E25lgAZvc3gN4jIGvxkbLI4oPPUqWw9dhWt50CkJ9GEQ6unqGweTmeTmMiuWHs2C6oq7oOV5uZSnn++geefr2X58hKMnnWGNM2gpiZGTU2csrIkHo+O3a6jKDqJBMRiCqGQSmenhfZ2C3v3WvF6959foWkGVqt4n2FAMqkSj++fNNPlilNeHqG8PERpcQC7LYymRDGSCRKJJOGwSpfPTXtHKe1dZQOCFBg9k737Z48GVY1js4l0cLGYc8CIToslRnn5TioqWnq38vKdjPa3Map1M7HJsK24iLbVJ/NRoJbWjWezdkclkZjYh8Nh4HAoRKNivV4QQXv8eJg4UYyudDhEpXnPHhHk1q0Dv7/vtePGwYQJA7dRo0Sf3YsvimC3dKkI/o2NsGCBCHannQaH+q7Nm3ItATJ6m8FvEJE1+Mn4q+2Aznv3wiuvwBtvEF35b3zqGnyTwTcFYqU9c+96MqIYWl+qsYceuoUHHrhjwP7t9m5crgCKYhCNOgmHC9D1/k2YSWy2KJqWxDAMdN1CLLZvJyJAgpKSdoqK9lBa2kZR0V7cbj82WwRNExmkdd1CNGonEimgq6uKPXsa6OioIRweWIYUEj1TAAZ2VFpUsZ+ELlalSOGwRKgpaKOWzdS627CespnRdp3JK9uo3/Af/D+PojWs5dhvGyz9QQHbV06m64WZLCsZy471M9ny0TF0IObvWZQEdlcIXbcSDouAq6owdqwIdFVVfUGurU0EuI0b+5phCwtFUBs/fv8gZ7GI1uWPPuqr2b36KgSDolZ7+ul9tbumpvTKB+RRuZYAGb3N4DeImMFv+EjL2ecT6Tt27+7trwt1G7zVXMkr62v596Z61raV4YsOXBlWVZJoipifphsquqH0BJ2hmg19qGzVB35c00SzqtMJbrdCQYEIMMXFYisrE387Onfh+N1i9BvPokX7O6WlNxO950l8iQK2nGrB11rB5t2T2dve0LNvHaezG8NQiETcvcetZxs1x1qwFLxLdfVM7PZ6Ojpg/XoxkjP17VBdvX8tbsIE0TybagI2DFELXLMGVq+G5ctFwNu9W9QETzqpr3Y3fbpo+j0S8rZc5yAyepvBbxCRNfht2rQJgKZMflZnmSNxXrtWNMWlg9Mp+tEcjr6+NxBf3PG46L8Lh0X/2oGSWyjKwC/7dD49iiL6wRyOvuM7nQM3l0u8RtfFceNxcRuLCZdgELq7xf1IBCLBOAldQWdgU+jBsGoR3I4ADlsIxQ7hiINAoJJksu+9LleUhgY7Y8bsX5MrLh64v85OEeBSgS51m1p93W6HyZNFE+aCBXDiieIcB4OPS7nOBWT0NnN7muDx7D+8Ptc5EueRI+FLXxIDWkaMEKME339/4GtSQSsc7uvDOhIOHvAOlnFavD41YjPVJ3Z0GMDA/keNBBYljmJPYOgasbi9p49QEE/a8XY7oFv8bbNFGVGVYFTrO4yelaR4zp8466wbmTXr2AH9bX6/aLbcN9Dt3i2et1jgmGPEFInTTxcBb9Ik0Yx5pDW7w/FxKde5gKze6WAGvzxGyaXkhmmSiXMwKCY9v/givPkmNDeLVFcD99cXsPYNWv1rcEdPaiCN6DPTtL77qcBrGH01u2SyLx9lOqiq2AwD9OS+Dac6CjpxxYoe6WvqdTr9NKjbaJqhUTryL8x+ugWH2876q7vx+xsIrVrIjl1JnttyLHuWzufnPxee9fWiT66jQ4yATR1/zBgR2D77WXE7ebLoGxzuzCr5Xq5zCVm908EMfnlMMBgE5MrOsK9zayv89a9iOPzKlWIh056kE4fFahVfzHZ735Zq7uzqEvuOx8XfqSbJ/pvDIfaRClwpUs2R0ah4vxgRGSMWU4nHLb2PRyLpeaaCo6KIYLhvMLZaRSBNfQ/p0TgJXSXZ8/E1UElg612jTyFJUXE7bmcAOlys3FKA//0v80iwBALAT8BqjVBo82OzjiAcAfFmtbffbvt2cV3mz4drrxXLAuVKgv98KNeyIKt3OpjBL49xOPZdXyf32dd5zBjR13UkpOavH+79g9MkeeTVn8P1Hab6/ywWsFmSFOhdOEsUtMLdVFt2U960jbKaHRQX7yW210Nr90hadk2gfUMde9SR+HbaBjSBin3a8eolWDWDWFABVKZPhy9+UeTJ3LULliwR2/XXw913w3XXwac/LaY5ZJN8KNeyIKt3OpgDXtJA1gEvMo7U2te5uVlkBBkzRnz5929O7H8/taVqUP3vp7ZYTPRZ/eIXYiTj3r0QCBw68BysadRm6xs4oygQDOoEg0q/eYRiUnxVlUgsU1YmmhKLisRE+dRgm3BYBOfUYJZQqK9fMhLp22Ix8O2N0t4OMez9/FKrq6cWK0xhYFeiFJUmKSpdy6jONqzHd1FgCVD4ssa2CQ1sba9gZ/tEursHfsG5XCIAfvazMHOmmJ7wwAOiBh6LwVlniYB44YWiNj3c5EO5lgUZvc3RnoOIrMFv+/btADQ0NBzmlbnD0TjH46K5buvWvm3Llr7bXbsGvt7lEkFy3/RhFoto9rRY+po4Y7FD989pmoHbrVNSolFWBh6P2EeqqTWdW1UVwdjvF6MpOztFgG5rg11bo+zptPbm9lTQRQYXVxBNS5CIOwgGCwlH+gYoWJUEqhYjoVtJ6n0DZGrdXVSM+pCmgk6OOW0Fp5zShcfzK957D+6/X/xAUFVxvqNHwxe+IGp8Dgf86U8iEL7zjgjqzz8vpi0MJx+3cp1NZPQ2R3uaoA3VcLshJFPneBxeeAEefRSeempgerJSsXoPyeT+TZ+1tWJE4r5bTQ38/Ofwz3+KydwJMc+c6moxnaKpSYwuHTFCZCFJJkUas+3bffj9KoZRiM/XV2OLRqG9XdwPBvumLKSeSzVpHv4n6MAqls0WRrMkURQDuy1OYWEXY6MbcYwfhV/bjNoKSpuHvbU2wlEP3d3F+P3FgIHNFSeBxkftc3nyrotZvDjJ5ZeL2tzKlWI05wMPwB/+AJs3w7e+JdbKW7AAvvpVePttMdn9mmvgnHPE36NGZfTfdlR8HMp1riCrdzqYNb80kLXmJ2OTRSbOgYCY8N0fi0XUSLxe0XRYUyNSZ40YMTBPZ2Hh/rWv5maRPLmlBa64QtRopk4VWyqQHowdO9rZtUslEChl2zZRA+2/7dgxcCSqywUNDSKQNjSIEZY1NSLIpppJk0kI/e15um+5k44TJ7P6hJ0kO1wEVTfdmotozEU8XE4oquF8p4hYspRdYy3EvDbUjxx01rjpNlx0dY0gGCzqu0ZqnIRuxWZL0NCwipEjJ7N2rZVdu0QQu/56McilpkbU7O67D/71r755jzfeKH4g+Hxwwgmi2ffNN4X3cJDv5TqXkNHbbPYcRGQNfi0949Tr6uqybJI+mTgnk/C978GHH4oAFwiIOWnvvTe4TprWN0q0d7pBvykLsVhfDTGFyNAimj+LisQk8ZISEdQqKsTfbnffBPfUxPcB9//+OK5vfxn9E1NYf8Wr2AMGsWJIFAIK2JQyYnQx6S47bm0MH3y3FWtLgClfirDuBw68k6JYLCVMn76UyCYnzdM+QfOZX+DVwmaat53Kqk3H0NlZ3buILfQl0dZ1EZgvuURcY12Hxx6DH/xANMUWF4u+WJcL5s4V1/+VV4ZnFfV8L9e5hIzeZvAbRMzgN3wcrbNhiFrWnj19/WWp27Y28XjqsdRAk32XC0oHTROBIrWparInNZnWOy0hFSRTWzIpblMrKR0oaB4Kmy2M3R7Gbg/hdESx2oKUdISpd4dwz/uIetdHnPLEepRv7MJ64kZstgJmzHgbt3sC/Pd/w1134R+bZMUvEyiKHafzBMrK7mfp0iZ++1t44w1xXg0NwrW1ta+2On68WDH9iivgzDNF4CsvhxUrxOvmzxcLzj71VN9STEPFx7FcZwsZvc3gN4jIGvxkbLIYTudYTKRGW7lSZIRZs0bUHFMTu0HU9lKpz/o/lhrMYreL4AcJFAU0zdKzukPfXMBUyrQDpUs7GCpJ7GoczRHBYomhWeNoWgJNTaJqoCgJ7J06qubG51TpDroJhQp7B8RYLFFGjoRx4+yMadJp+sMtNIVWw/dC2E58k8rKE6mpeRBVdfZe61274KGHRF/fxo0iF+c3vwk//rEY4JJMir7Sq66Cp58WzcTjxomVGZYuFWvuXX21eP9Qzo02y/XwIaO3GfwGEVmD386dOwGora3Nskn6DJfz22/Dpz4lRoGK4/Wl5kplL5kwQTRbghh5uWqVqFW2tor0Xv1vd+3S8fkGriVosYipDqn1+UpLoaBg4CT61KK1ViuoioHy5F9RXnqeaKmD5vM1uhU3kYSLWNBNOOYkligkHLFjWeskrtXRUaITCVrQd7nwuzx4u0t65/RpWs86eNEI4bild1I86NTVQX19nKamBNdc4+b00/uWQjQMkTln4UK47DIx18/nE32gHR0isPn9wjmREM2er74qRoJ++tNw++3w/e8P3f+dWa6HDxm9zeA3iMga/GQcpjzUzskk3HWX+IKeNUtM3p46df/EzZmyfft2IhGw2RoOGBx37xajPv3+vu1wcwydzgButw+P5sdR4sdd4MPjiFGzqp2ihhF0T2vGmdjF2H/6iVyokhjXgt2uU1HxYyKRcbS1we5n3mf7st1sso9hc6KRZFJMxlcUcDrFGoThsEpxsai5ff/7ojYH8Mc/iprc//4v3HSTmDJy/PHi+S99CX7/e5FHFcSPh2XLRP/gyy+LUaJDhVmuhw8Zvc2pDia4ciUfVQYMtfMLL8Btt4n7bW3ii338+IFbSUnm+3W5XLhcoh+ssTG99+i6mPrg74jj/8Rn8K1opq20kA9uLCIYLSTkLyS5qZCO0kK6u4vQOxvR34RNI05hbzBB6LljiHV48Kse4n882Gzz6cB0rHoUt9uP06lQUFBKYaGCoiSJx6GzU6W1VUwXefRRMfJ00SL4yldEs+c3vylqwmeeKfr0TjutL6fqP/8JF18MO3eKCfELFw79xHezXA8fsnqngxn88ph4/44qSRhq57POgv/8R/TtpVYf//OfB65dV1kpVipobBTD/VPbiBF9t/tmfToSb1WFwm2rKDzlFAyvl+YbIXo5zANcmyFWZiFRnEDTCpm49BzKvvknYnd8kw9nf464bztTvwobH6nEN6INqGHkyKdR1ZkEfDqB//4pgSdfoL3Mw+rPlNEdtaGqJ+FwXE5Xl8KmTbB+vUJLi9Z73qkm2JYWMbjl//0/0QQ8ZYrI7blsmZja8Ic/iCbj8ePF1JCLL4Z33xXve/xxETyHErNcDx+yeqeDGfzymEi6mZVziKF2VlU4+WSx9ScUEoM8UgFx3TrRdPfGG2IgyL6rRZSUDAyKLpeTqqokkyf3PV5V1dPndiASCRFR/vY3ImWw4kmVWIkOOpSsUOg6zgAlQWnpeUz4QzXWn/8f8f+9nZWj7iUWaGfCjzRWPVhM1NJGUdEpTJnyLyyWArHfW66DJ/9IuFZl+UMuatQgFRWfZOLEy1CUvn7JLVt2EI2CYYyiuVmcf3OzWMj2ww9F/97q1X3KEyaI3J833ihqz9/9rmgCDQZh9mzRn7lu3dCP9jTL9fAhq3c6mH1+aSBrn9/enuUPZMrInovOhiEmze/aJbbdu/e/39KSZM8elWh04DBHp1PM7SstFbdlZVAa2EbZS3+iLLkHfW4XsXPbKSzqoCzeSVFJN46GXVitNsaP/T8qv/0sPPIIsR/cxKq6ewmVRKl/zsO2T8YwiFJTs4hx434lDhaLwSc+Af/4B5E6O8sfchBXfFRUXM7EiY+iKAOzdRzuWkejYvL6XXfBa68NHPE6fbroN/zoIxEUp08XQXPdOhE0f/lL0S84FORiGTkcMjqDnN5mn58JMv6uyUVnRRE1vZIS0Qx4INraOjAMsFore4Pinj0iEHR2ituO1jgdzy9nS8BCu3IZe51lhN4uhLf331+RJ0FpYi9l4TG4Gr6I+sx2CgqOoUQLY61po+BvXhobFxAIXMSePVBsD1P8lWsoWvoalrEFvH+/nbjRQUXFZQcMfHD4a223i/69004TPwBmzxZNnxaLqBUHg2IA0fr1YkJ8V5eY0F9YKNKgNTbC+ecfwQU/DLlYRg6HjM4gr3c6mMEvjwkEAgBUVlZm2SR9ZHSGPu+mpkpKS8UAkV4MA376U/jNt0DX2XGZhU03JkAFY6+VcHcDbdgIBKopcN6M/pxB59Nv0uauYsskD+3uAsJ7imntaKQ7XEhwaQnBYBnxeP+A5gSeAEDdlMR9gY/CwjgVFZUUFyuUl4uFZ485pm/L5ForiqjNzZkjAlwwKCa2v/yyqCE+9VRPH2ahGPgybRp88pMi286ECYNxhfuQsYzI6AzyeqeDGfzymKKiosO/KMeQ0RkO4b1pE8ybBzt3Ei+A9+93EKqOgAGF62wExuu4KjYxyT2NKbEv4bjx27BmDe2frGP9ZTvQLeDeacU/QbQ5lpScwfjxD2GzaUS6wvi+/1O8v36UPcVFrLmigtYyB8FgMXAqNtvl+P0KXq+ohT788MAJ/OXloxgzRvRT9g+Ko0YduN8utYhwMikCaWqag9Uqanq/+IWYwvHSS/B//wd/+5voMx3s4CdjGZHRGeT1Tgcz+JmYDAWJBHzmMyLiADsvd7Hx8yFQI2hBsBmV+Me3ARqjqr9Hw+JWlN9dSnxqI83fs7Bn/g4KV0N4rBP/hAiq6mTs2F9RXX0diqLAiy/ivPFGHDu2w9kGe78MU90eJiZ9VFdfyzHHDBzckiIYFANb1q+H998P09yssWKFlcce61v5wmIRq1ekguGCBXD66WI6g6aJ+X/nny/m9u3cKTLYTJwoTrmqSiQGSPX3SZQYxORjhhn88hiv1wvIlZpIRmfYx/uf/xQjOcNh4h54/z4noeoQGODZ5CbQFCNMG07nWCZv/xzuK34CwSDtl9ez4bKtJBxQvL4A7+QgEKao6GQmTPgjDke9qH7ddBM88gjR2WPZcEOCjhOgqOBEfMG3egLf7w/YxwdiROb06WKbOXM3AGPGjMEwxMCd9esHbo8/Dvfc07eUU0WFmAyfyuJisYiglxoUuGePyAjz9a+L1HG2I1/gPr1rLQkyOoO83ulgBr88pvho05ZkARmdQXgrXi8ce6xIFgrs/EwFG6/aC1oYrRsc6kgCTdsAhXrP5xh162bU575JfM5kNp26l9Yzd1C4RiEythDvMT4Uxc6YMYupqfm8WKP9gQfg5psBaPvuCWyY/RaKzUF52bm0dzx12MB3IOcUiiJqcrW1YoBLCsMQIz5/9zuxqoOui+TW//VfYjpHa6t43a96BpxefLGYS/n974vX3Xmn+NsyiN80MpYRGZ1BXu90MIOficnRYhg4f/hDXL/8JRgGsQonH/zCIFS9Fwwo2lGGv76bbrbhsDcy+d0LKPjO/VBSQseFI1h/9WoSTijdVEnnpL2AD4/neCZO/BNOZyNs2ACf/zy8+irxy85i4wnv0TbtLYrbG4hWO+no/AeNjf/NyJHfTTvwpYuiiATXJ50k8pp2dook4GecIfr6dF30Ea5dK17/rW+J29QaqEuXisnyP/7xoGqZmBw1+3cKmOQNXq+3t9lCFqRzfucdKCnB/YtfALDzq6N467EwoeoIlm4Ft3IMvvoODGI0qJ/m+M+7KLjpVyRmTmT9VbtZ9fXd2LssWJ2VdDa1oSgWmpp+xowZb+PUauCHPxTJR7dto+Pmk1j2yefpHNdFmXEC3vIWNM3Ncce9R2PjrRkHvkyv9d69cOqpYi7fv//dt0rFtm3itqZG5P5MvdZiEUHvnntE8+lgIV0ZQU5nkNc7HcyaXx4j40gtaZxDITEK5J13xJ/ja1l5WyuRmi1iJKdvFIHiXXQb63HYRjPlbzNw/+RhGDOGzlPcrL9xBXEPlLSOpGvcdqANt/tYJk36Cy7XGDFM8nOfg40bSVx2Hs3jXqJ1/hYK/fXESh10RpfROPK/aWj4Nqp6ZClVMr3WO3dCXZ2oDXZ1iVpfebmYwwgiDVqqxrd3r3ju618Xoz/vuks0gw4G0pSRfsjoDPJ6p4NZ88tjFEURIwMlQgrn731PDGl85x1wudj+jVre/dVOIjVJLGErLvsk/EVbMIwEI/0LOf7SAO7fPkdi6lg2nN/Myu8HsEYcWN0j6KrehqJojB59NzNnLscVLRNNnCefDE4nXddMZtmFT7P3hAil9nn4C3disXh6a3tHGvggs2v9n/+IZY2amkTg+9Sn+p5LzYN+/nkx1gdE8KuoEIGyoEDcHyykKCP7IKMzyOudDmbNL4/x+/2AXCO1ctr5rbfEUEefDxSFyOnTWPFfHxCrEiM5HdFJRF0bCMXW4LI0MflX1bgefxImTKCrbj3rv76RaCkU+4/BO3IDGLtxuyczceITuF3HiAzbX/0qhEIkP3kRm2v+xc4LExTER6F4LHRF36Kx8ehqe/1J91p3dIgFbOfNg4suEnE5HBbPtbeL2mAkIibAf+YzotL69NPibxDZYGbMOGrdjL1zCRmdQV7vdDCDXx4j43IkOekcDIomznffBcAYPYqt5+xh28IPQAVrzI3hHEFEWYNiWBi18VQavvwGSqGfRF0Jm85Zy+4LwL2nCKvbhdexHtD6AtnW7fCl8+DZZ2H+fLyeraw//2miIzRKPKfSFXiNAss0Jk9+j4KCqYN2Wulca8OA668Xwe6RR+A3vxELAU+Y0DeV4YQTYPt2MbF9yhTRLxgIiL4+EMHv0ksHTTs3y8hhkNEZ5PVOBzP45TGaNrgj/4aDnHI2DPjRj+DWW0UHl8tFZM5oPrhhNZEaxEhO50n4eBuSzTii9Rx7awLnyjehvoGO0k1suBniHihOHIu3aiUkfbjdU5g48XHc2mi4407RIVZWRvK8M9jS+BItC8FtGYPdruANvjGotb3+pHOt770X/vEP+PvfxeX4+tfB5RJNnyCyujwsujKprITrrhODXK69ti/fZ1cXjB49vN65hozOIK93OpjBTzYMQ3ybtLWJpIrHHLP/4nI9hEKhYZY7enLG+cMP4ZxzRIZqwJh9PNuOWcbWa1eDChY8aI5qfOE3ULBQ/+xoRt2zGaVpDHFXG5s+sZnWs8Hjq8UoNPDGP0RRLDQ23kFDw80oz78IX75ILI9+9tl4vW+w/qqXiVZbKC49Ba/3VQq0aRx33ODW9vpzuGv9wQdiWuFXviIyuowbJya0z50Lr78upjp8/vNiTt+CBWIqxH33iUD4pz+Jx1NBcjCDX86UkQyQ0Rnk9U4HM/jlMs8+K8aI79kjgl3qNpHoe42miW+lY48VQ+JTt7W1WId6YbUhIOvOgQB8+csiTQlAcTHhWpVVn32X0BjxkMM+ikh0K4noRjy+EUz6YjvWqB+9pJSuqmY2/AgSbo1i+xy8RW9CHAoKpjNx4uO4Opxw2Sfhr3+F448nWV3MloZ/0nITuO0TsGsJfL7Xh6y2159DXetgUCSmnjhR1OS+/W2x1l9jowh8iiKaN7u6RLFsahK1PrcbHnpINIU2N4tcnyDmAg6Hd64iozPI650OZvDLZX7zGzF64NRTxXoyFRWizcnjEd9KdjusWQMffkh4+7t0v/w08f+EiRdBvMpBtKGQWJWT1nIrukvDWTIFt+dY3O7JuN2TcDpHD/qk6KPFNhT5sNLBMMQPjS98QQxoAYzRjeycvpXmzwE93wEWSwWR6BYUQ2PMgx5qHm9HaRxFLLCBjV+FvadBYWI8YacPb/RNFMXK6NE/oq5qEcrPfwn//d9i+OPChXg3P836mxSilTaKS07B632FgoKhre3151DX+stfFlMbli8Xtbh77hENDNu3i+cLCuD3vxfjc1wuMQ//lVfEtIYtW8RrZswQq757PGIdw+HwzlVkdAZ5vdPBDH65yF/+Ai++KJreEgkR4F59VfzMTo0rt1rFz+mGBpg+nQ+/3kJEEUPwNMONNWJH64ph2xvAuTqMmoBQ/Xq6mv5GokDMTlYVOy73JNzuST0BUQRFu70ha8Obw6lhhMPJqlUiE/N//iP+VlW6R2ms//pW/APW71NIJrxYwhaO/VoCj1KFwWba6jay8UeQdNspKTyRLv8rEAePZxYTJz6Gc9lOOGemGCFy4YUk177PltqnaPmSjts9BbsRw+d7lcbG22lo+M6Q1vb6c7Br/cc/woMPiu2990T/naKItXJ1XbzmiSfE1IaHHxZdlrffLvoDTz9d3I4eLYrofffBrFni/UPtncvI6AzyeqeDGfxykVtvFe1Fdrv4xvH7xWJpLpeYXG0YYlntDRtIbN9AZMtL6LOhtBlKV1hJ1LlJjColWOMmNs2O/bQmXL4SKrYpuF7tgpWrCHV9QPfIKN3HbaF7wm7ai/9Ckp7gqXl6A6LLNQmPZyaFhcejqkP/K1BVh3HqaSwmcm8tXiyuL4DLRcs5ITZ9TkeNK4CBmA6royWsWDpjHPuTalwRG9HAejbeAu2ngJuTiFn30OV/BUWx0dT0v9RaLkX5/LdFhDjuOFiwAG/zU6z/HyfRMiulpafR2fkibvdEZsxYhsczbfjOnQNf6+ZmuPFGuPpqcXmuu048rih9ge/WW8XqDRddBJ/9LDz6qFji6M47xfPLlok1/T7/edEk+uyzQ++d68joDPJ6p4MZ/HIRwxAdLh4P3HGHyCM1Z47o3zMM8S1UXQ3HHceHk35FILkagM4y6JwVR422ocbbUJJAB7SF3kJ3ALViU863YLVU4+wupmAjNNy3k8J3wuhlBYQunkb33Gq63RAILKe19WEMI4qqOiksPIHi4vkUF8+nsHAWqmof9FO32wd/nwekvV2Mv3/zTRH44nGMokK2Lgyw7Rqwe11Ei0MoigXDSKBGFOx74hz77mXYPvoXrXNDNH9FQXEXMmbM/7Bly+0k4+0UFMxk0oTHcT74HNwyQfyfXXUVyef/zpZTP6Ll2woFBcfgJEln5/M0NHyHxsbvDcm1PBz7XutIRGRhqa4WUxY+9znxeCrwuVwifdlNN4nbCRNE8+f69WIWiMMhGipWrBCpzh5/XCTDHjNmaL1lQEZnkNc7Hczgl23icZEav71dpMXYu1eMAFy8uO81bW0idYaqQmmpyBv1+uvw+98TfwSq11oJjFeJlCVI2pNohh1rTEP1JbGEwdJtYN8ZQ4lDuAZCIxNEK3bjc+zGNxl29qw6rughrIGlOLfFcb8KDYHRlDR+hciCiXhr9+L1/4cdO+5h69bbhiwYRqPRo97HYVmzBi64QFRLkknQdQy3i82f6mbHZQb2cBHRYh8KNoykuG4FnUVMWXo++hOPsPoW6JgLlaWfoKjsNJqbv4JhxCkp+QpTw1einHK5iAAXXwxbtuBd+SjrHygkWpigrPQCOjqew+UazYwZb1NYePzQn+9B6H+tfT6hu2YN3HCDGOACIvAZhmhdj0ZFLe/znxdF8sorRerRe+4R46xAtOyGw2KS++c+N3gpzQ7mLQsyOoO83ulgBr9sc+qpovaxL5omhtbt3i2+dXq+pOnogOJikWb/mWdIOgwCDXGSCiSdoERBj0YJFQH9kzIkwbELHO0ahVssaB8kUSMJYkUQaoB4uYpeYCNeZBCbCr6psIvNYNyD1gWODRrFgTFMrfwGyty5+JSVeL2v9guGjn2C4fFHFAz1VNvaUPHPf4p0JYYhmpCdTox4lOb/irLzoiRWvYio04eatKETQwFKkpOZdEc3QfURVj6ooHnKmTj+1+zd+2c2bvwCimKjxvNban78H5THToDJk+Gyy0j+8y9s+VYZLfMVCgrG4DSgo+Mf1NV9nVGj7kDTnEN7rochda1bW8Wsjq1b4bLL+pYnSgW+efPEb61XXhHd0U88AZ/+tAh8N90E3/hG3z7feEPcjh078PfbUHjLhIzOIK93OiiGkRpBYXIw/H4/RUVF+Hw+CgsLB3fn5eXiJ/eNN4rRnOXlMGKEGHL/ne+IgS6aBqNGkfjbIzT/qIFoBcQT7cRsIWLlwIEGE+hgC7pw7VRIGt0EjgEONLDTADUKagx0K+j9vo8Vw4KqOTH0GLoR7TtOHJwdDsoSM6mc812orMTn+w9e76t4vf8hmfQdcTBsb2/vuSyDnE7JMOAnPxFVGodDVE8qKjDa97LhZoXd5xpoSiFJw48Ws5FUYmCBSk5j/AVvEKyL8eEvrBRUzGXixCdYt+5qurpeQtOKmKH8GuclX4FoFPXSS+G550hG/axaUoO/qIXS0nPp6HgWu30E48c/SHHxyYN7bkdIe3s7W7aoXHFFKZGI+B32xz+K51RV/Nb67GfFqM477xSDWU46SYziXLoUbrtNDF7tP5ilqUmM9vzoIxg/fui8Qa6UWzI6g5ze6X5fmzW/bKLrYgTnzJliS6GqcN55IrvIqaeKn9NOJ/5bL6V18l8p3VhOoXsi1mffY8cVFnRLkvFL59M89U0Ktql4j4ng2g6edSG6J3sI1imgiN84WsyGazu41sewdmsoI2pIVjgJFQfodu9Fp2cOYRIsvgRaKICKRrLETdQdEU9YIVwVoUV5g5aW82A72NVKymsu59hjXwH0nmD4Gjt2/C9bt36vJxieSFXVp6isvBxNcx/wksRiscG/ztGoaKtbskQMIopEoLwcvWMv678De84w0LRidL0bNaaRJAZWqA2cwZhLXiY4Glb+2oW7+FgmT36atWs/RVfXi1itVczo+iHOy28gNnYsusuF48EH0S+9iDXfCuCPvIXLNYn29iepqVnE6NF3Y7EUDP75HSErVuhcfXUJJSVwyin7B7477oCf/lSkM/2v/xJFtLxcBL4774Tvfnfg/m68UaQyu/rqoQt8MERlZIiR0Rnk9U4HM/hlk0BAfMuUlAx83DDESIKf/Uy0K2kavPQScQOYA5O+0o4WEb/IQiMTdMyGTeP/TcFa8E+BkY/baLk0jmJxMGFxGc1XB0CH0k3lhCYXEGtw4x/dSVhpBWUHJMHVAsV7SikoOg5740wSoT2ENj1P0L2bwLgkhqUbWxsUrldwJqrQjjuF7too/o7/ENW6iNLGzl33snPXvYCK3V5LWdl5HHvsS4CCz/cfOjufYf36G2hu/iqVlVcwYsQNeDzHD5hWEY/HB/ca79kDl1wixuwriphwtns3eqCLtbfB3nkKqvb/2zvv8KjK7I9/7vRJMmmkh4TQQbqAFEEQUEEsa28r6ura2y7isrqWta5tF9curqv4E7tgWUVQQQHpvbdACCEhvUwmmfr+/jhMJgGUoKFcuN/nuQ8z9773zve+ebnfe857znmjsJriqA9WojTACjnbhtLmhm+p7epg1ct2nK6O9OjxPzZuvJby8q+w2TLpu/lu7DfcAp06Yd2wgWBKCqEvprOh7btUlP6Iplnx+4vp2XMWiYmjWva+fiNmz4aLLkqibVs/HTqYG9bbCwvfc8/JwvHR0fLvtdeKe9TrFXfmXXc1vd4nn8hq7+3bS5L74USLj5EjAD1yBv3ybg4M8TuaqK+Xfzdtarr/3/+W8vgFBSKEJhOkp+OPK0TzgckeC/5aCAZRDjvR7ngwKap7lWGuCZF3pQ9bIdSm17H0mR0NC1dV9i0FRDQJAn4wBzQ0LPiTNMpTKymxzQJmQRRYeziJsp1EelwfWLsOb+kGatvUUZpdBHxI1Fpotc1FQux52NsNpmTrG5SmbaU+I4RX5bN796vs3v0qoGGzZZKUdB4ZGbfjdi+nqOgtCgsnExXVjfT060lNvRqbLallC+muXAnnnSdBRSkpInyrVxOKsbHubyHKT7EQFz+Eevdm/JU7wQlYoeOcXmT+fS61fZNZ9S+Fw9maHj1msGnTHykr+wy7PYu+c6/C9pcJEBcHmzdTd9ttuO++ixLPREpKPgYUqalX06HDv7BYjq010T75RKY9BwwI4HDAtGlNXZfPPgvPPy9D77PPxKL76iv5/tprkSjQMDZulMAWh0OswsOdIqrHYst65Az65d0cGOJ3NJGaKsUTH3pIXrHDkQPXXCPfL7tMniSzZ8MFF+CPBUudBlFOeF+KJ8YvWszWAXvI9l+Kx/wl/gQPFp8NX8Y+7goF1gqwVYA/BpkrtEPQrgD/fm3RwG+ro8q0lqrqtZANtIk0MXlN+OJDFA2qYbfzcwh9jqONhdj6TrT9KZuYDxZT1L+aknOiqW/lxefbxe7dL7N798uAmejoHiQmjsHnKyI39y/k5v6FpKTzsdsvJDr6tN/et59+KlEZXbqI2XLnnVBQQDDGyrq/+ag4xUK3Hh+zYe2VKLeHUDSYTbEkLTKR+fdVeM7sxqoHy7FaE+nRYyZbttxGaeknOOw59H1/ONZ//0N+p0cPePVVqhIT2b37FmpqPsNsjqNr1/8jKemc334fLYzXXpMiNpdeChUVIWbOtDdYe2azuDqfeEKmnT/8UNqG47GmTJEubYy8PElhDAYl6b0lK7n8HILhJeR1BD1yBv3ybg4M8TvaePppWRfmnnvEErz/ftl/8cXyOj11qkQWvP8+sfeNIM+l2Hyjh06XXYL22Re0njeP4BsPsP2GDzHVaUQViyvUbHYRDNYQHX0JVmsFlZXfEkxyktPrZQpzX8RXnUeb6bE4F+3EvjNA0AlVPaC6G9R2tlDX2oTfFSBkCu0fUBMCNA2LKw1LnYVgYSH1rYLUpwaoZzPFbTbDULC6rcRuCdHm1QBRwQzy70ihtNUGlPJSW7uS2tqVAFitqTgcbaiuXojX+zFmczr19X8kLe06nM6cQ+/T55+Hu++W0MU332yYTw06YM2/HFRnBejZ7QuCi+YRjPZgNplBCxFU1SRPg7obz2PVtSswm2Lp3fs7tm+/n5KSD3DY29Hv+ZOwfPCWKMWrr8L116OAgmVX43Z/hs3Wmv79V2K1HgEVOAQoJdGZDz0kxWyKi2HmTDsWiyIQ0DCbJXn9kUdEzF5/XYbfhg1y/gcfSHc2xo4dkuLg8ch84YgRR+Ze9FhsWY+cQb+8mwMj2rMZOKzRnmE8+qisEN44hO6mm2DGDCgvl1Jma9ZQeEcnNv1uM+nf2ej0TBDt3onQqxc7P76M3FsUsSshJuokdndaj9XaBr8/jwzbJcRG9WNT5f0oAlgs8cTFnUaPHp/JK/+yZeL7evfdSPHGvQgmxVD7u5OpGp1BlW0r1azBF+1tcKUCYlXWR5OwwUHcd2X4W2mU91PUtodgFCKeey3P+FUmHCndqegewq3WIiGowUgjwGJJIxSqJBTykpAwkrS060lK+h1m84FXr2gCt1ss6nHj4OWXZT2e888Hk4m8m2PJO6+Snvl3EO/tzPqi2ykeAXZrBqbCMnxOL32/vYTVly8FTPTp8wNFRW+xffvfMJtcDH6kJ+bZC+RvM22a5AoCubkPsHPnY5hMsQwYsB67PfO3joYWRTAoc3QvvSTDbMsWseIcjhD19SY0TVybr78ut/TII+ItLiqSpPVPP2241QZs2CDFqysrpbzZxIlH7n70GIGoR86gT97NfV4b4tcMHBHxg0j5/HvvlUjPDz+U1+8rr5T8tOpquPdeis6EjdrTpH0DnZ8FLSYW/yldmH+/LLaa+hXsGQMosJWBLxGS5kPm5xbW/V0RiBJXRqbvHLKy7yXYOoF6307q63cQLN+NY/UeHNMX4fh2LdZKFTH8rFY46yyC559FVTdF6aqXKU3aiC+RpmIYkpzClDngWgv12Rplg03UdAwSjG7UpsKBObk1HlWAUnWADfChaU6UqkPTHFgscfj9e7BYEklNvYr09Bt+uejzO++I8O3YIZnZAwZIwnkwyOo3kqG6kp47byP00iTmfWUhZJHoVtseiN1ipnZkDiEC9OnzIyUln7Bt25+xmOJJ/lGj8yNuMaGmT5doXGDnzmfJzZ2Aptlo1+4bsrKG//Zx0ILw+cRV+fHHUid91Sp5J4iJkfcEkEyb6dPlXesPf5DlizweEb4vvpDlihpj+XKx8qqqxKP83/8e2XsqKSkBIDk5+cj+8G+AHjmDPnkb4teCOOzi99xz8kreurU8iR5/XOaoJk2S1/U77pCn0ocfgtuN7+YrWP2HTbjdy4ldp9HnLkXQAQs+AvseSVrHDBmfgbuzmeouQTRlhZAipjyRmlbF8rsaTVyaWkjDpKwEzZH5QrNy4iiz4thSg2O3wlEIziJwFIIjoQuWEecScJmo2PQ+xTl5VJwCgXAX7Z071ALg2gAJy8ASiKKim4fy/oAJzHU0CKKmWVHKT2Nr0GRyEgp5sFgSUcpHMOimTZsHyMn5+4GLb59xhjy1Z8+WrOyRI4VKl07Mf3ozrednkPN0IaVv/IG17f6DqR7MXhP+uBA2TwzEx9Gnz4+Ul89ky5ZbSHNeQlHdR3R/yErSAiQCZMwYAAoKXmPLlpsBjaSkN3E4htChpWt5/Qb4fOKqnDFDSo0tXCjvV9HRkuYYCsHJJ9exfLmThx8WS+7CCyUbpLpa5vBOP73pNefOFd2vq5MSZ3PmyDvRkcTWrVsBjqm+Phj0yBn0ydvI89MLCgpgwgSxKKqqZHHaV18VP1RxscxfBYMyh3XLLTBjBtuj3sNdC2hQ3U2x7jEb3R700+MBE6sfDxKzDdwdYPd5kPNtFzI+XcfWO0IEYoLUJBc31KsEM9GhHGq1bTjcsXT4NJ1Wn+4moHzUp0Ndto36ngnUd4ihvmc2FX1Lqdf2ELKG35c2YqneKIJosuAgi46fmYmas4PqU6LYfYGZ2qQalEVSMKq7ASYPmh9c20yYa6E2K0QwGuyeWKIzB+GpK6K+ft3e6ytCISm2HQzWo5QX0MjLe5Tq6oV07z4ds7lRNNquXfDdd5KVDRK5ERMDViu1aV4CLoibVQRPPknJoLVouzTMfhM2WwpBbyG+qHpO6b2MUKiOLVtuITN6HLZXPsJ0GSSs1OCLz+GsswAoKfmULVtuAaBTpzew2Y6t4BavV6aNZ80Sq27pUhE+p1OOhULQsWOAlSsdvPqqFA0aOxYyM8Vo/uij/YVvxgzJGtkbfMz06Ude+ADi4+OP/I/+RuiRM+iXd3NgWH7NwGGz/BYvljL6V18dKZkfFQUvvihPlTvvFFF84gmorYUJE6h56nq2J39Jeds9keuEINk5mi6PB6gq+pY1T0DMZnB3AmWFjMrTSP7CzapxyyEIJmUmZAlHcZlJS/sDdXWbqKr6kcSE0eRE34prmxVt3fqG9QJZvhyUQnXtjG9EH+rrtlNfsJT65CB16Rr1aYq61hreFBlO9hIzcWsUrk1QP6wrJV2K8JnKIIC8cimxCJVV/rXUgD8WNGUlPvp8UnLOpaLiW8rLvyIQKGvSbRG3qI2MjBtJT7+RmJge8NRTsrbOnj1SBi68fPjgwexOWsDmu2DoWAVbtvHTth4ElYc4Xxdq1CZsdU4srTvTr99yCgpeZevWOxgy7Y+sbvcqFo9Gj37fwKhIrt6iRZ2pq9tMdvbfaNfu0WNqbqS+Xmp2f/edGKrr1kkgscMROZ6RAaWlismTa6iqiuWuu6BPH/kzv/QS3Hpr02t+9JF4300mEciZM1u+YHVzcSz1dXOhR86gT96G5XesIxyRCBIuv2uXWHhpaeLi7NJFEq7mz5cn0ckns/HNLhS1/Q8osPjsBKxeTF4I2aGkfgYVE5Pp6n6Ebq+9wrpbCkn8CdwdYXf6j5ReJBZSnyVXs931PpXdguJZNAcpKnoDqzWd1q3voaxsOssrziM6sQfpl/6R1NRnsVoTJOjmu+/QZs7E/vk32PPzibNaITNLLNS6OoiLw6dVUnV6MlVdA1RlVlByGijLOsxucFXHEUiPo46daF6w1IK/FZg9Ul4NM5g8fqp8H1Ph/ZhYrQcdOv8Lmy2LnTsfpbLye4C9FiAo5aOg4BUKCl4kJqYv6TsKSLlsLNbYWPH5AcTGQmoqVZ0VMUUuzH26U5vgJag8EIIorS1Vto1gcxETczIANTVLiHacROj/3qDqA0Un7W4YERG+srKvqavbjMs1gLZtHwGgsrISOPoPifp6cV3Ong2ffy6lxsaPl4Biq1XqKsTHy7vUW28VMHduFK+8Ip7cr7+WYON9he/NN6XCi8kkQ/WrryRt8mjhWOnrQ4EeOYN+eTcHx+9iTcc63nkn8nnNGilzVl0tS2I/+KAEa1x/vVhdkyYRsPopartR2mtgCUSjhUyyVJEG1nIIBEpY43iQXfd3puOuSyk7FeJXQexq8EV5QEFZpxK6X1vESe7x2Dx2EUCl8HsL2bXrWWy21nTs+ApOZ0e2bfszCxZksGHD1VSa1qEuvhgmT5bkro0bZa6ye/dIBeTqamwVkDyzjg6PV9D3kTSG/K0nvcabyPrUiqXYg88j0aTKruGPR9Im7NF4EwC/BOhg1iAEnoo1bNw4jnUrxuJy9KRDh+cBE1FRXbBaU/d2XhCz2YXJE2TLxUX8dM3nrFt3OdWhvTH6ffpAmzZUdYe4RbVwwQU4nR0gBHa3A8eSPADqtRJcrr3iV7UY1/cFlPfxgxlanXpPw5/K49nEunUS89+ly9sN847x8fFH3UVUXy9TxrNnS6BKcbF4z61Wsdbcbpnvs9tl7m7OnFa88koi118v7tHrr5ep58Z4+WXZrxSceSb88MPRFT44Nvr6UKFHzqBf3s2BIX5HC717//yx778XP9Ps2fLkuvtuzPkl2KsihaHrneUoc6TiurKb6fJKIs58qKyew5acT3FFjWLPWTLfpu01hHa6ZrD0q1TM8WmcMqaU7MRbQUVqf1aXzGHL5luxa8n067eGnJyHqa5eyMqVp7FkyUnk5z+Hz18qc5N33CFP2fJyiXyYMEFSMsJhhCUlmBetJmG9jZw1vej1oIMhF5joNzGJjv9WJK2Jw1JnImCvlUBPE9QnQ8iusFaAmb33W++hIO95tm69C5erL3V1W3G5+tOhw7/RNCvBYA3VoZXE5FlITr4Qt3sFKzaMpPAsQNPwdUmlPhPiVofgggsw7SlFC4LZFkfClPV7ezBETEwfgvVV1Nauw7WwgtIRTmJi+mK3ZwDg85WyevXZmExWHI52REd3/s3DoKVQVyfpCT/+GAkMHjcOLBYpTr19u4heVJQMqw8+gNdfd3L77R7efx9Gj5ap5sYxRJ98IjmBIAL42WcingYMHA8wxO9oYW8IMSAheXF7S2CZTBKW164drF4txZhtNrTdRSTMi6ytFbUdTHuro2l+MHmCbLypnDhPRzq+YMZUG6TG+21DRKeyI1aWGTR3gDWBCWz8dxoZgbGcMnAjcfHDQckcHCgKil5j+fyemHeW07/fOnr1+o6YmN7k5t7HggWZrFt3GRUV36FUSHxqw4ZJekZursy5jR8fqVlaXy8RFzU1aGmZxOwwkzkdut/jZsif2jNgYhuyPo/Gbk5FOQAl7lBvnBcCYPVYRJxD4K5Zgc2WSkXFLMrKvqB37/lYLEkQ0nC3CVBc+gE+324cjrZsmghb+y6lKqsWAFdJokxUTZ+OuQ68jhqicwmnFxIT0xP3vLfApHDl2qjuYyU+fnhDnxcV/RefrxCzOZ7ExNFN/pxVVVVUVVW1wMA4dHg8Inzz58P//idD59JLZShNnixVXcxmEb7vvxcRe/xxuPHGCt59107PniKGlkaTIHPnSoEhpWQa9fXXmx4/mjiaff1roUfOoF/ezYEhfocba9dKUtSwYbBihewLBsViCmPePFm377334NRTIRCgYIyXlf672P5iX9Te+auqRultnrYw4G/tyPxIHlCYNVK+h5L0LeTepJG1tAMJ+y4TuDePvK4tROdCVdtalpSMpez2vvRafgXdun6IyeyU138zBG1+tgSeZsH/ogi88Twn7biaQT030a7dU9TWrmHVqlEsWtSRvLwn8XoLI7+TkiLzlcXFEnWRkSHLNXXoIHObe/bIxFNKCmzZgnN1Me2nxjDoMkVnz2ukzo/HVL9X1JWJ+uQAIRtYK8FSGcTrzQdCVFbOYevWO+jd+zvsJKEFQcNGq1bn7U2ZgF1j3WyzvQ5Abc+9k9+ffoqrNIEgHoIu0DADZszmaGo2f47mg+gN9dhjO+DzFTTcVk3NUqKju+H17iAhoWnym8vlwuVy/ZoR8pvg8UgC+k8/yVzcqafKCg3BoERjPvOMxFI5nfKnmDNHVmP405/g669jSU5WfPGFCGMYq1ZJhkgwKML50EOHv17noeBo9fVvgR45g355NweG+B1uXHWV+Jl+/FFex0FewxsvYVRYKAulJSXBDz9QOetZtlzvprIv5F3opkjSyohb1/TSq27PpZWnOwNudhC3WlE8ChwlkLA4RN6pW3CfHEtsXjImLw05d5jlsycbgrEWovPMbPu9m6Wmm/DfdDn9/zOU9NirkBy7aLHCXEHW9f+c+d6xlFzdltaXfUD/z35H7+C/iIsZRF7eIyxYkMXatRdQXPwRPt9eq1bTRPjnzJHP8fESRz9unDy1CwvFaqyra4jQTLv4btKzJjHokW5E75Aaou3bP0+MrRv+BPDHKzQfqKAfFfJTU7OIlStHkJPzdxwFoFSA6uqFDBiwld4fDCJhGdSbi0HBlkt34y/ZDnPm0Mp5JgBlo2LFIiZIKOSlpnY5MTttmE7uT0zSQNzu1Q39XVOzFLM5DjCTkNA0D0DTtAPnHR5G1NZKQvqiRRKsMnSoZGLs2iXuymBQ1tUzm2UIrlghnurbbhMh9Pvh/fermtTjXL9e6gIEApJWum8R62MBR6Ovfyv0yBn0y7s5MMTvcKO8PPI5N1f8S6GQJE099pgsWzRrljyhzjgDRo/G62paaLpoFASTXHR6Djp+3pZ2X2XR+26w1NnYcfJa8i6sp+2SHvT5sw2TH0qHhIjdbCd6QzXVbUqIie5Fh23nYq2K/LmVGUJagOrOQZxaJlYVw+Y7Qyy9dCbaO//HSS8m4KrLAg2cUZ0xmaLxJ8CWe+CHxxazOvFZrNf+ia59P2LQE33puOUs6krXsn79pfz0UwpLlvRky5a7KCmZjj8nSe5382a47jrxodXWij+t8SRSVBR4vcRdey1Wv5OeE8BWHmJX7pN0P/l/DByUR7rjUrQgDSNX80MgUM6mnbcSirUBIbzeXVRVzSXeMYBeE6DPu6eiecEb52PJmv64swMkn/wnAEqHaihN0j7cebOpTq0kdq0frrqKmJieeDybCAbr8fvLqa/PJRisJjZ24H4rNbjdbtzhuc4jgNpayctbskS69rTT4K235D0jO1uG1mWXSdsPPpChd8MNUsWltFRilt58s5D4+OqGa65dKwvV+v1iNe5by/NYwZHu65aAHjmDfnk3B4b4HW4884xYNxaLREZefjn07y9zYPfdB1dcIfl8S5bASSfBpk0kDf8rrr2BnWZzHFW9zSx6vZY9Z2pk/LeM7GfyiUschqUmQHUPKBoDW4esYdcFIWrbyZ+0pq2Xyp7Q6icTgW2r2drhC+LbX0Rm/TkRK9Akm89dQFXbWtLSriaj8BRKh2isv72c0JaNZEyHUGEuKuglOf53OJ1dwaSo6OtnyTsw/0sbu08tJ23iPPqfvpWB4xx0+bw7ru12ynZ/xLp1FzB/fiuWBq9n62ejKfPPJXDNJWIJPvSQvBy8957MD9bUSC6hwwFLl2Krs9LrtY5ohcWsWjwUTbPSeeAHDMlZw0mTYnGUWFAW9vp9LXgT5KXB4WjP6tWjKe1aCUDcJo1uD8s9+0xlLHsVKgqnYzLF4M7yY/JLn7lXfEAgBsxuBaedRnR0LyCIx7OempplANTXbyc+fth+f2aHw4EjnEh3BDB+vAyhGTPEaVBdLUs/gkRonnqqJLMPGyaBLlddJXl6d94pFt3TT0Pv3uYGzjt3SsUWn09qeZ533hG7lUPGke7rloAeOYN+eTcHRpJ7M/Cbk9zr6+UB7XRKJMHEiTJJc/rp0KmTTKyE0a8fLF2KMoE3GWy/+wO+B28nt/QJiss/JmabmQ6vaDiKLSycUt9wWuxaqD6JJq8zrd+DwnMlViRhKVT2tRCMMxMV3Q23e3mkoYpsNmsyHbq8grZ5M7s3PE1Fx0rM1RCVLzmD1lqN7OUn4TmlNUWxPxJSdXsvohFt6kCH9SNI+HynuHlra6nrEEPlRe2p7GemMiEPr7kMguCqSCa+z3UkJIwgLm4IZp8JundH5ebuvRrywpCVRV1sLSseqcSa3onevefIignr1sHw4ey42sKOc4vCFND8oKwaTmcX6t2bGHJOCHM9KLuF+e8FsKZ3pq5e1k80m+MJ+qqI2mPFk+Gj9equeAMFeO3VnJz9OYExpzNvXiydO/8Hn28PO3c+idPZjpiYvnTp8kaTP/GRTAZesEBKkf373+LGBFkU5J//hOHDRexmzJCAl3By+tlnR9yYM2ZI9GdNjXDWtCQ6dZL3kPDCtccy9Jh4rUfOoE/eRm3PFkSLV3hRSuLR77tPfE2N4XKJBRSG1SqlOf76V6r+MJCteROo8Syj1Tyo6Qq+vfM18SvAlwCenMipMZtNdJwUYs+ZsPtccBRL5ZfSwYDVDISwmOMJBCrkhEaufae5Le27vkCUrR2FP9xLEV/jdwWxVoA/QWp1dngBAq3j2HGdRk1aNWjh1AszDkcOKd6hZC5KwT5zGSxciKqtpS4DKvvs3U424UsIoYVMuDzZxAd7Evv0TOLW1mOpNaG1bScVcIDaG0ez8uqlOJxt6dXrWyyWWInMGDGC/Kui2HbBLtDAtQpqesq9mDzQ616IPf02tBnfsOmi7VT8ri2pX/rIGxVZvcJUC6FoSFhlJdk8ks1dZ3Dq+sex3nEfixZ1pFWrc6ivzycQKMPhaI/bvYx+/VY0+bPt3LsaRnZ29q8aEs2F3y/vR1arzPWZzbBtm2SeKCXi98MPMt934YURl+j06RJ/1K6drMJwzz3C2ePRGD06i7w8McQffviw0m8RHKm+bknokTPok7chfi2Iw1beLBiE//s/eX2vqZEnmKZJArnDAYMGyRNOKfFhpaaiHnmY4rOd5OZOJLRnN7GbIDpXw1yr2DFOTreVQNBlwR8fAKWR/o2F9Gl+dlwL5YPAtVHy/qp7QnRdBqmd7yS/8Dn8/kbpF3tdoya/mVamU0npfBOByt0UbXmBqoSdDWXKkuaZaPNWiOhtsh5g7u1W3O2DTXIQNc1BTExPEh2nk157Go6dHnjnHdTnn+MZ3pbKznVUti6hsntQEt8BsxucJRYcRRrOPD/O3aCsZrbdECKmNJ5eH/TFXO2FkhLKEjax5gkllW9qoMtDsPZfkVtxelJoO82Fad021j4Bp3x/HTvNH1I0TFIgtAAoiwl7cYg+yVNZqF1JtwVjSP7rV6xdeyGBQDV1dVtJSbkEh6MdW7feyZAhNU2WWCookKjQzMzDu5zRs8/Kwh+LF8u6eyBW3YwZ4kTYtk0sPpAh1Lu3BMNERUlBoSlTZL7P5YIdOwo455xk1q2zMW6cZNXoAUeqr1sSeuQM+uTd3Od1i8/5Pfzwww0RQuEtLS2t4bhSiocffpiMjAycTifDhw9n3bp1v3BFmDx5MkOHDiUhIYGEhARGjRrF4sWLm7Rxu91cfvnlpKenc/nll1NbW9tw7Nprr0XTNP7xj380OWf69OlHN5LJbJZV20tKpNxZebn4o8aMkSWx586VCNHzzpMgmdpatD/eROrgBzilfBKZff9OxalOCi91YHEmMuBaSJoH9VngKAqQNQVMPjOFo/2sfNFCzCZI+9ZBwCHCRxDqg7vJ3TkRraiS2GA3JBx0LxSELEFKzD+ybutVbC6agDlgpY3/KlJ9p6H5TZSeGmLZG7DwE43SM510exSGjQrR9zpImiNly5Sqp6Z6MXklT7Gwdiw/Jo1j2X355E0einnNdjL7PEy3wTMZ/H8X0v86OOkhaPMuuDZJukXJcI3Nd8GWO4KEnIrq1hXMv+M7VtyyiaWPlbLmMXl/i3InE3DBxgdB80DSzrYA+ENlrL9qGzvGyW1tHDKfoqG1DfdqL9FAhfC2AnuPUTjLoyl3iEUeFdUZj2cTXm8eMTG9cbn6olSA2to1Tf6Udrsdu93O4cTOnZHFaMPC9/33Im4OB2zaJHN8Pp9MobZvT0MaQ2mp5PzdfrsIXygEf/5zK9ats3LaaUd+WaLfgiPR1y0NPXIG/fJuDg5LwEu3bt0oLCxs2NasiTwonn76af75z3/y4osvsmTJEtLS0jjjjDOoaezq2wdz5szhiiuuYPbs2SxYsIDs7GzOPPPMhrcSgEmTJhETE8PMmTOJiopi0qRJTa7hcDh46qmnqKioaPH7/c2w2yUSYds2cYXOnSuW4IgRUmbj66+l4GJwbzHqvDzM519KztWzGGB5j1bZl7FlXAWrP25PqvM8ej8QjzJD/jhI+iFA2pcQMgfYeS0UjaqnLhu6LjyDjp9lE7tBLB9fKz81ah0QFKsO9lvySFmgvNU28szvsifqR6JKHCQWtcPhScCXoCg4p46FU/zM/xR2XmOm9bexnHqxje73Q6t5NKxZGwrUUeNZwY4Oc1n4EfyQfTPLNo1ka9qn1KWB3dKdrC+ddH4mRK+JFgb2Wsdpc+9nwFXQcf4AHNUxhOyKqvRi3K1KG0axx1UCGgQSQEVBafZ2AALRQVAm3J2RNA97saQ3qCA2fyxR28CsxYIZVq8ZQ1xNWypayzyi09kJn28XZnMcdXVbiY7uiaZZGgJgwqivr6e+vp7DiTvukGyRcAmyQECiN0HSKHv1kpRRk0kyR158UUqbgswPQqRW+vjxMG2aHU0T4TMdlifB4cGR6OuWhh45g355NweHpWaDxWJpYu2FoZRi0qRJ3H///Vx44YUAvP3226SmpjJ16lRuCv9P3gfvvvtuk++TJ0/m448/5rvvvmPcOHmdr6yspFOnTvTo0YMuXbo0TNSGMWrUKLZu3cqTTz7J008/3RK32fJwuaSu5y23yEoOL78sT6+TTpLaU6FQ0/YbN2If8ju6nHkmmVc/wNZOs1hz6ucknjuaLva7KPm/v1AwcDXKJOJTdtre80ywteMsTl5+KplXfkDgyw8pX/YqpSfXUTZ47/p6fqDxcjUqcm74syfZg4dclFVcrdHl8dRnmPDG1lAy3E/J8Gq0AETlQtJiMxlzXQStfqra11HVPYS7g1xP2aCms8xhFlwMsBZCUvjaWhHCNO8kyAbfS+CPXwRBcds6d8k0oxaA5KVRbL/SQ+Y0KLgI8EL8Guj+AJR8eBubXK8Ss9OOO8tLQFWCBdoUnEmFYzXlg6ux2+MIequpCq3GkZZIvd1PnXszUVFSwiw2diBlZV+Rk/MQUVHdqKlZejhGwM9i+nQpVP3RRxFBe+MNmRJNSYlEa4bz+kaPlqAYkPeoF16QYJekJJnzmzQJWrcO0qFDgHbtjs9oPgMGfgmH5X1vy5YtZGRk0LZtWy6//HJy90bwbd++naKiIs4888yGtna7nWHDhvHTTz81+/oejwe/309iYmLDvttvv53XXnsNq9XKf//7X+66664m55jNZp544gleeOEFdu3a9Rvv8DAjOVny/zZvlizmefNkATWbrWm7qiqJIN26FdfVj9B70EK6fdgdT9FSlhaeQ80l/cjp+SOplf0oOxWxvKChfNiiW+azMHcQRRnriH93DSed9H+c+nh/ev0JWn+uYdsTaQ+IFdhIf5Vlbzk0JcsRVbWupN5STkjzN2lT2wnyfh9kzX2VrL+nlt1jQ/haQXS+ldh1EL3Hga2iEb+g/E4gGuqyobqdmbIMZ8N8IGYRTE87qO0AdVmQd4kHWxkUjZZVImzVUNkX5v0PNrleAoK4syPl4QD2mL6lulURloCN/v3XEVUag7PEQdASgBBU7p6BxSJjLCqqIzU1S/D5inG5+u4nfoczJNztFqvv7LNlqSKAykr429/2dldQxO7zz0Xc/H545JHI+a+9JnmB48eLYN53nwjhrl0Wrr/et9/vHevQY/i9HjmDfnk3By1u+Q0YMIApU6bQqVMn9uzZw2OPPcbgwYNZt24dRUXiSkpNTW1yTmpqKnl5ec3+jYkTJ5KZmcmoRuur5eTksGXLFoqLi0lNTT3gXN4FF1xA7969eeihh/jPf/5zyPdWVlaGz+ejsrKSuLg4NE2jurqaqKgozGYzHo8Hq9WKzWajrq4Ok8mE3W7H6/USCoVwOp34fD78fj9RUVEEg0E8Hg+xsbEopaiqqmqooF5ZWSmfn3kGz6WXkvrvf2OfMQNlNqOsVkz19SilZIJn+3aCmZnUjxhB3MZd9L9gIwXnBMm79i0q9/wf0a1HkR79V6pyX8GTWknseguxm8wUjPVSnw5b02eydWUHYmotxN0xGnPU86S//xPtrpmGJ9PPnpEahWeHCMTTxA1KCHl90kSMVHhqQIG9yErcBhNR2wKYQrAivT3Ti67AE4jB64nC63fi9Tnx1jvx1Tnx1u/dF97vdeL1RuH1OgkGxQR1RVeSlpFLRsY2MjK2kZ4e/pxLSko+oeRghJrTIeahto+13Ih/fVoIUyiG9PafUlnpxVnXjsr41dhoT/T2MnYxFW/xE5jNyQQCI4EXycv7kPr6HGpr36a4eCfV1T7i4+MpLCykurqaUCiEpmm43W4cDgdWqxWPx4PZbMZutze4kBwOB16vl2AwSFRUFH6/n/r6emJiYlBKUVNTQ9zeeq9/+YuZsrJ4Hnmkgm3byomLi+PBB2PweOyAiYoKxQUXFDNjRiolJYqsrCBpaXsoLbVTVeXlmWfSuOQSPzNmeLjppgSuu66e2lpFSoqZbt3yKClJO/DYQ2o7ulyuFr+nxr9xqP+fduzYQThO75D/Px2le6qqqsJsNlNbW9vyz4jDeE8bN25scn9H7Ln3G+4pGIw8B34JLS5+Y8aMafjco0cPBg0aRPv27Xn77bcZOHAgwH7CpJRqduDJ008/zXvvvcecOXP2eyMxmUwHdLc2xlNPPcWIESMYP358s37vWIC/Uyeq3n4by/btMG0aMbNmYVu+XCZ99sJUWkrMO+/gHzyY8rffI2rXLrq+/AlVmQsoHfIVha2/wpRow+nOwZOTT00HL6nL2xNKS6QkawnKAp6sAG7tS3B8SfE5Gont40lYn0DW9yHavlNEeZ96Nt0N/hTEGjSzd03ARmT3Rol60/wUJ4MaDtOn38ZrLzyDw+yhlb0EW1QdlgQPNkcdTuqJs1RiySzEFlWH3e7Bbq/DrtXh1OqwOeuwuuqw2P2UlmRSsLs9hYXtmD37MoqLswmF5MfNZj9pSXm0Tsonp9Ue2rgKSE1ZRezA1QyaV4k1vZzCkTViqfoBG0QVReNJd1NV9RYuVzfscUMIxqzG7LWDH9zaIqLtQ0lPfxGfLwansw81Nd/icFwHBKmvXwt0AiAYDBLa1y3dAlizxszbb8fz1796aNMmRGUllJRovPGGg1GjapkxI4ZLLqlvcAoEAjBypKfh/E8/jaKkxMSVV9Zz8cUJjBnjYeLEOnr3TuTKK/PRtOY9KI4lhEKhw9LXhxPNfSAfawiFQrrlfjAckVSHM844gw4dOjBhwgTat2/P8uXL6dOnT8Px888/n/j4eN4+SKz1s88+y2OPPca3335Lv8a1MQ+Ca6+9lsrKSqZPnw7A2LFjsVqtXHvttVxwwQUcrAsOW6rDb0FBAXz8sUQ17M2FA8Q16vfDNddQPn48IZeLVsuWUvv9m5T6vqNkgJfa9qAFNZSmsNRAm9JzqOwToqzqKwBitkLUNqjsL3mElipotRCS5kP8Ulkhfvf5UDKUhlXZCRGpGrMXpaXpPPXUf1m69Cx+d/6L3HTTvTice5PigxGjTFloSFA3+SBkFUuSkLgw0SBop+mrmoJA0MKePW3YvbsdhbvbsbuwPbt3t2P37vbs3t2eurpIQd64uJK9lqJYi+1txXSt2kX2ePB6P8NiScRuy6TWswotZEYRBBMMHlyMzZYMwI4dfyc//18MGlTI/PkJtGv3D7Ky7t57r4cnGXjoUAkCXrEi4vWeM0fqI/TtC8uWSYnUadMii9BOmQJXXy2fb7tN4qcuukiquuzaBVOnwl13wcqV5aSlhXSVwAz6TLzWI2fQJ+9jZiV3r9fLhg0bGDp0KG3btiUtLY1Zs2Y1iJ/P5+OHH37gqaee+sXrPPPMMzz22GN88803hyR8B8I//vEPevfuTadOnX7TdY4qMjPlCXbXXbBliwTJfPddZAXzt94iYcoUfP37o910EzGPvENMdDQ533+P57P/Ulr9P/YM8lDbAbbFfYlWCjHFLvwpFtwdK3B31Ijd6SLt6xqCDkVFX9hzFmh+jYStsSStj6ftfX7K25ex6xwv9RkRapYq+OaDP/Dsx/9GM4Xo3HExudt78Kc/f4/fbycQsOH32wgEbASDVgIBC8GgbKGQhVDI1GDRKaXhdLpJbrWLzNab6NBxFW1SN5PeVlyfmZmymUyxaLW1KIKEnGaUClJVldQghoWF7Ro+r1kzhJKSLACsn/vo1WsZp5wyjQEDviErC+yVJnImB9n0F6ipWUarVrJ8UWLi2ezY8TBu9xJcrpOpqYmk2/j9TeuxtgT8fikE9NJLTad7t0sQK8uXy4IZaWky3xdGmzaRzz6fBBO/+qoIYnw8vPKKLHrbqpWXw0D7sONw9PXhhh45g355NwctLn733HMP5557LtnZ2RQXF/PYY49RXV3NNddcg6Zp3H333TzxxBN07NiRjh078sQTTxAVFcWVV17ZcI1x48aRmZnJk08+CYir84EHHmDq1Knk5OQ0zB3GxMQQExNzyBx79OjBVVddxQsvvNAyN3200bEjfPst5OfLa/+kSZLYFQphX7RIEuVNJjEVrr+eqPteIjthKtnz5lH/9RTyQ+9T2r8Od2aNWG9B0EKK6uxqqmWBB1x5DjI/kTJt7vZVbP5dFVwErtIk0kr7Yt2aQHVMPmUxW7nvuSnMnXsRmhZCKcWmLf0xEcSkhdC0EJhCmEwKzSTfTaYQoDCbA1gs8p9NKa1BJGtr46itjWfHzu7M/+lCGk/cmc0+YmMrSU/fRYcOK+nQYQFZWVvISMkjJT6P3ksrSFm+g5r74tiQ8ji9/gQx7U8i8NEbbGs1iO+/t/H11wN5441+vPzy06SlbWdEylecfNGP9A4uIjr6pIbfcrn6YrWmsGvX87jdK4iO7tZw7HCEg+/cKQG+7ds33Z+bK3FOwaDUQaitlaousbFS47NxMQ6fT/YVFUmO3/z5Uhlu0qTDw/lIQI+89cgZ9Mu7OWhx8du1axdXXHEFpaWlJCcnM3DgQBYuXEibva+j9957L3V1ddx6661UVFQwYMAAZs6c2WTNqJ07d2JqlHj08ssv4/P5uPjii5v81kMPPcTDv7Ie06OPPsqHH374q849ZpGVBfffL9uSJQRuuAHr6r1L8oRCUjx7yRKxEnv0gEsvxXHzA3Rs8wYdly7F+8UUCr2fsKdXMXXpTedUPK3qqT0bQk6wlkPKbLBUQ6FL46W8UUTFV9GzZwH/fnwm69adCoBSJvr1+4YJ428gJXUXPy04hyce/z9qPU1XRDBpQaKiqomOriY6uqphi4qqJiamiqioKjQUvnonFeWp5O/uRHFJFrW1cQQCNioqUqioSGH9+pOB6wiLo0aIGJOHdJebzIcWk9M+k3N7dqfL+LG072KlOz66JuQzsu8d5N81h9ULh7Ng1dnMXng2Ux+6DbtdMXy4xtlnS92Bjh1NOBztKC39lOTki+nQIfLy9Gtewg6GsIXXrl3T/UuWyCpQrVpJUaCXXpLysTk5EhnauBiH3y/CN2KE1FW/6ip5VxoxAsrKWp7zkcDh6OvDDT1yBv3ybg6M8mbNwDE559cMFBcXY12wgIT775fX/VatoKxs/4Ymk6wkn5XVsPBsIM3FnvZ57E5eRG18JJEcP1g9ZpQVAlFBrr9+Jbm5vQARmwzLLmqDTqpVAmYtyBNjrye6VwnTF1/JzFnXcFLXhQwa+AUWqxezxY/FFEAzhwgGrXujOhXp6dtpnbmZzIxt2OzephGmACEJ5DT5QAU18os6sHrbYLbk9mHHjm7s3t2ByspkvN4o9j957y1rAZISd9Ou/Wp69ZnDwIFf0SZ7A5oGCQvBfHYZX8+08PXXMH9+DD6fiTZtiunb9z0GDPiaG254ncTEiIlVXFwMQEpKym/7ozXC5Mlw880ibNZGOZeZmTIP6PVK6sIjj0guX9u2ktyenx9pO2KErOU3bZq4OmNipDzaAw8cHs5HAnrkrUfOoE/eRm3PFoRexW/btm0AtM/JkSfp/feLH2z0aAmYWbhQyn1ERYkpoZTUxYqPF0GsroayMoLWEHuGQd614A0H02rg89k566yIW8RkChAKHbozwWQSd6fF4icUMlNfH733J0JkJ9XQ1rSZtNAaElKKiOqkEZu0i3adlpDcZjvOxHJClgNH/gWDJkpKstixoysbN/Zn27ZerF8/iPLyDCCEyRRsxFcjOrqSk3v/wBkD36HP8O+IiakEoK4umhUrTmfx4gtZsuQCdu+Ox+EIMHKkhTFjJP8uFNrb1/v6KH8D7rsP3n1XanE2RlSU1EMoLhZ359lny/4+fcRazM+PrLyelSXvOzU1kvzeqhVMmCALizSMjxbkfCSgR9565Az65H3MBLwYOHoI5+dgNosJcemlUkHmlVfEBLjoIkhNlWjR776TOHlNk6dnICBP0zvvxDxqFBnx8Zg3VxEq2EKV61UKXT9h0oIMHvg5Py2Uxd/CQpKTvZ4LL55EwGvlhZdewGQK8pdxtzJgyGy0OB91IUVJSSZ1dem4q+OorI6iuroV1RWtqC5PorQ6nbLydKqqktld5SLP3x/oD6XA+qb3aDb5iY6pIjGxiLS0HbTJXk92mw2kpuaTnJxPSko+AwfmMWTIIoLBGpQKUFiYw4IFF7Fw4eUsX96HYNCM01lLXV0Mc+efz9z556P9U9Ghg5vzz6/h3HMtTJgQj9Vqw++v5sMPh7Fq1W0sW3Ypf/qTzKV17NiGsWN9PPigvD+0BLZvF2uuMTweeU8JZ/S0by/7lJKFaOfNkz9nx44ijgUF0K2bDAEQbpWV+4wPnUGPvPXIGfTLuzkwLL9mQK+W38+GKW/eLMt7f/oprFwpVZFHjBAzYefOSNRoTIw8WUMhnnA8wv31D2DV/DzY5SP+veMcyupjiImuptodB4Sw2eoxmUJ7LTeTBLegUMpM27arSUraTU1VAlu2ndyQuA4y5xdtryE+ppTE+EJik0uITSwj1lVGQpyH5FYmEuxlRGt5eIJ1FNalszW3N3k7ulJU1Jby8rS984gHdnE6nTWkpRWSkxOgXbsk2rVLJjtbIytLgkRWzy5h+ktLmFl0Kh5PHDHRimBIo64uco2oKBg+3Ee/fv+gd++pjBw5hdjYU6ipke765JN6pk2zYbeb+PvfpeZmY1flr8GAAVLZrnHR6fXrRcz69JH0h61boUMHOfbRR7JW8osvyrvOY49JIezzz5c/NchySH37StUXPYaxgz5565Ez6JO3YfkZoHLvK/5+A7dTJ5n0eeABCR2cNk2ejl99JQvIDh0qJofdDm43oQ2beGjpRAD8ysqjGy7Ch5RzqXbH0YUNJDn3MK/uNFq59uDz2YiKqsXndeLzOwHYvr0nWkCxY1d3XK4y2rVbjdXmo7o6kV27OlHjTqSmPp7dFdlkeLeRY1lPYmIRCUlbyWyzgaysTTgcdaCgFxaU9g4ATmdnEhPPJMo8jPKhz7Gt2+WsGXoDK1eG2LzZzM6dFqqrXWzfHkNlpcamTeCpVVRWNe6QZJKdfenWbTF9Th5FdbXGvHmSE2e3S2RlZaXiq69sfPXVA8CDtGsnc2hjxogXuXv3Xdx6q5k332zLnXdKEMo//ynHfy22b4exY5vu21spkB49RPxmzZLvDodkvAwYIIG/118vBn5ysrhIw2hs+f3s+DjGoUfeeuQM+uXdHBjidxwjXCboF9GunRR9HD8edu+Gzz4TIXz7bYkQHTwY0xWXkbZLY9feBdPDwifQSMiO5ZZOi1j3Q3/KajKwan7c7kS6pS4jr6YdtXWxKGUmN18CY+LcHkpWd8Vri8GrOQgEzZi0ECFlIhi0kZ/flaKC9iyYfw6BUPi3QiRHFdG29XradlxDm47ryWq/jjZtNuCreR1b6avY7/HT6SQz3aMWcm1fG7YysBX5qd5sYdbibny+vT8zdw/Ci4PurOE05tApZQ3e4alsjklg3fpBTJkiASZpaT7OOKMEk6mW7dujqazMxGQKkJSkqKqykpsr5Vf/+U/JwRsyJJsRI3zcc48km48fL3NxZ50Fzz0n1tqhwO2Wla72jfQMz/916ybRm99/L9/79JF3l1GjxPJbuFD+nCed1NQCjY+H8MImzRofxyD0yFuPnEG/vJsDQ/wMRJCRIWkQt9wCZWUU/t93bP5wJSdNfI6e/k7sYiwxNh+jh9fx9fw4amvFzbhLteaqb69ruIxfydN23Z6+B/yZnaEc+bA3VsZkUpjMGqGGam2KKJeNKKciGAjidmt46k2UeDIo2ZzBks0jUI3WW4qxVJEVl0uHjNV0ab+Mnv3mkN17DaEsIAvoDx2ugnsCVu5ypzBv1UDmzr2AtxeOo7Y4jox52zj11OlceeUEHnpoNevWncLSpWewdOmZbN0qxRjatt1FmzaJVFdHUV4uLDMzZS4tLw8WLbLw449W/vY3mYe7/34pRj1hgiw1dOON8Pe/iyXWHIRFLien6f5wDp/fL0L3wQfyfcgQEdmJEyUSdO8C3CQlias0jISE/QNoDBg4EWGI33GM3+KyWLWrFac9eCnV1ZfSLucxduTB2PQVTKsaiXVmJaFOXZjS4e/cMOMS8vM1TKb9V1xyOCR+pq5OgkcvvRTGjavj7LOdDW1iYip49tkx9O/vQKnzWbMmjfz8dMrL25ObG0turpPqrY3mB00hEh11OIO1+L0haojGHYhlQ1kfNpT14Ys142C6Rkx0iG7dQwwfXsXJJ2/G5fovDsdkzPEFDBv2CcOGfYLfb2XFihEsWnQz339/PR99NJ7kZA9jxpRw6aUh3ngjAbdb8f33GjNntmbWLAkgsduhSxcJKCkthSuvhFWrfKxb52DECJkf/MMfZBX1F14Q8Xn0USkr9sADIor7LtCxL8JxBo2WrAQiFuS2bXDhhZKsDlLu7JlnxKUZFQXhJTQHD4Z//AN27BAhbWz56dWlpUfeeuQM+uXdHBjidxzjt0Rqvf++ZDoA5O4wMXo0fDv7ZPKWFdFhx7cseGU1T83oTSgkla1DIbHC4mwezGYor3NSXx8OQFGkpwR5/30Lp5/uRCn48UdZddztTuDmmxeSkFDJzTf/hbZt38LlikfT4omOjub003eTkpKHFtQo3t6WgtxOFBR0Ir+kGzuLO1NanARB+R2rNUBiog8w4XZbWLzYzKJFrYBBwCCSkx9l7NgdXHJJK844oz1Wq8YZZwjDYFBchdOmRTFtWhumTJFgmLFj4YILRMSio2HjRpg5U+batm8XwZ86FZxOG0OHelm2zI5ScPfdcr2zz5ZrfPklvPee5Ni98go8+6wEovxcPffWrWVe76uv4LLLIvvdbvl3zRoRvvBLR9u20LOncBs2DBbvrbzWtavMWX7wgfy2Ee15dKBHzqBf3s2BEe3ZDBx30Z6NsHWrCNHAgTI/FMY778DedYIBsXbsdplb6t5dAjp69lAU5fuprgFf0MSLbf/Fu0UjmF/XlxiqcePiQBGY3a0bsVqhIhRHSSCe2oBzvzb7wqwFSGtVRmbrcjJyyklL201aWh7JydtRqpqaGti1K4X8/Pbs2tWJgoKO7NkjVYWio73U19sIBjWsVnEZxsXBueeKAI0eLYGtYSgl4jJtmmyrVsm9n3GGWFuXXSbWlc8HCxbAhx/CO++EqKmRSgDhMmPt2sG118Jbb4nl9cc/whVXyDrFM2fC8OFSjS4r68D3/Ne/wn/+IxVawgWPvvtO3J1Wq7g3TzkFNmwQN+fLL0v7e+8VC9PrFaH9/nsJ8F2xQr7fcYf0QVmZ/iL5QJ8RiHrkDPrkbSS5tyD0Kn7hRYTb7Rs1sRdbtkjYe02NPNx/+klyxcJ4/XUppXXmmbB6tcwp1dWJtTJ4sFgvgwfDPffAN9/IOddeK8EezRlV12V/SxfTFqLrSlhU2Zl3vBETJ9FazZ9PX8noKxMpTe5K3i4zO3bQZCssjFzLZILWrRVt2oTIzvbSurWb1q1jKC+PYvlyEYCaGhGt+nqxlqKiJJPDboeRI0UIzzsvkkMX6UdZSX3aNKmN2b69iMxpp0XabNuWy/vvx/D00ynU1Ym1Fbaczz5bROr550V0/vIXedG44Qa47jrp1wNh7lz5jYULJYoT5G90qlSP47PPxJp8/32xSIuLpf1774nIulySKN+5s4j2hg2yXXih/O1Npl8eH8cqDjauj0XokTPok3ezn9fKwEFRVVWlAFVVVXW0qRwSCgsLVWFh4c8enzxZKZEp2W677ZevV1amVJcukfaXXabUn/+slNms1H//q5TNppTVGjmuaUqNHNn0Nw60ffONUqGQUqXFQfXHq8uaHHO5lJowQamlS5UKBpvyqatTatMmOf/115W67z6lrrxSqcGDlcrIaPobJpNSyclKpaYKT1DKbheOoFRcnHzWNKUGDlTqySeV2rBh/z7YuFGpU0+Vc26/XamamqZ9XVam1A03yPGOHZVKSJDPVqtS99yj1F13yefWrZXq3Vup0aN/vr/9fqXi45V68MHIvkBA7iE+Xqmbb1bqq6/k+nfeKe3j4pR66CGlOneO9F1dnVKxsbK/tlba/PWvBx8fxyr0yFuPnJXSJ+/mPq8N8WsG9Cp+xcXFqri4+GePr14dEYLwdsEFSq1YEWmzfr1SL74o4qOUUrt2KRUTo1R0tLR3OJTKzJTt+++bih8olZio1DXXKHXGGQcXwbfeUio/v1gtWFCmfve7/Y8nJSl1xRUitAUFB7//+nqlNm9WauZMEfr771fqqquU6tQpIojh+w/z1jQRyfD+Tp1EQObPF+FRSv6dNEkpp1Optm2V+u67/fv6xx+V6tpVXgyGDZN+Ct/DG28odfHF8t1mk377OVx2mVJ9+zbdd+utImzZ2XKPVqsIolJKXXqpUv36yb2azUr94Q+y/5pr5F5CIRHt1FSlCgp+eXwcqzjYuD4WoUfOSumTtyF+LQi9it+OHTvUjh07frHN4sVKPfGEUrNni6hERclDOT5eqY8+ioicxaLUTz/JOS+9JPvMZrEwGguh1apU9+5yHatVqQEDxOowm0UAMzMPLoITJpSrsjLh1Lfvz7fr3l0sz2++UcrjObS+2bJFBGzUqIjwWSwRUQz/27u3Uikp8j0lRanrr1fq88/Fmtq6VYQNlLryymq1Zk1ek9/wepV69FGxMHNylDr//Mi1b7pJRDV8LxddJJbbvpgyRY43fvmeMydy3vr1Sp1+unxevVqp996Tz198If8OGSLnzJgh35cvl3ag1Kuv7jno+DgW0ZxxfaxBj5yV0idvQ/xaEHoVv4KCAlXQHBNpL8IutMZuy8bfL7ssYv188YVSrVrJ/vPPVyorKyIgEyYolZsrbkibTVx8N9wQsbiau912m1huS5cq9ac/KZWeHhHmTp2aujftdhHXZ5+Vh3so1Px+qqlRato0Ebbk5P3vPSFBqfHjlbr77sg9tG6t1GefiSv2pZeUiooKqowMv5oxY//rb96sVLt20n/5+fKSoGmR+7n/fvl3wYL9zy0ulrZvvhnZFwiIEJvNSj39tIgxiJXndsuLxxNPiIWekSHn+HxidU6YIN8HDlRq2LC6QxofxwoOdVwfC9AjZ6X0ydsQvxaEXsWvpKRElZSUNLv9vHlNxSdsCTXeOnYUt53XKw/asBikp0fmzKKiZAu7C8eOlTYjRyr16qtKjRhxaCL4u98pNXeuWEbffqvUddeJNQlKnXyyiNY99yh11lkR92J6urj63n1XqT17mt9noZBYR488olSvXk15OBxK/fOfIq5jxkTcxPn5Si1bVqaGDfM2iFBFRdPrnn++UmefLZ/79hW359lnyzVycuQl4dlnD8xpwAClLryw6b5bbxW3a+/eImx2u/RJKCSuz9695TxNk3k+pWSOMDtb2rz5pvz20qVlze+cYwSHOq6PBeiRs1L65G2IXwtCr+K3c+dOtXPnzkM65/HHlTrpJHmoX3eduOmsVrEyoqPlWNjy+de/lNqxQyxAlysiEvHxMrfmckVE8M03lWrfXgR1/HgRxUMRwLBIPP+8POzr6pT6+GPhabNFgmteekn233OPUj17Rs49+WSlJk4UV6rX2/z+KC5W6pVXIlZaWAQvv1xcrqmpYmE9/HC5ys3dqSZPFhHKyBDrOIwrrxQXqVIi5iNHikvTbJa+DLtVV67cn8PTT4u4lZdH9u3r+jznHPk8b55Sn34qnydNiliWSsm9g7iv3W6lXK6guv12fY1ppX7duD7a0CNnpfTJ2xC/FoRexW/Xrl1q165dv+kaO3YodcstIoA2m4hhfLxSp5wiD+5WrcSl2aaNCFB4TgvEErvllogI3nGHRDtGRSmVlqbU228rlZcn0YeNRS4jw/+LIqhp4ma9+moJNikpEWv09NPlmN0ultInn4j79e23RYzDLs3oaLFG//1vid5sjos0FFLqP/+JBMKE79NsFpempoVUr15etWyZUjt3RizDsPD88Y9ijf3nP5G+AnE/zp8vc35ms1hz+8YX7N4tx15+ObIvHPVpt8tvfPutXO/ii+XFwOUSsQ9b6+Fz0tPlb6CUUtdcU6NSUgLK5/tNQ+SIoyXG9ZGGHjkrpU/ehvi1IPQqfi3psti4UeaMmoqUWDAOh1g/w4bJwzt8PGwx3nCDWElhEbz88kiQxqBBYpHs3i0i0vj6d96p1PDhB7cIzWZ5wN92m1hbTz8tlh6IsP7hDyKSfr+4NP/xD/n9cKBLdrZSv/+9WKSPPy6W3gcfKDVrllLLlim1fbtSVVUigFu3KtWnT0S8evWSIB6LJaRatQoqk0nmJ6urRXA7d5brZWdHhLttW+mz/PxI/375ZeR+3ntv//4fO1ZeOBrj1ltFyHNy5N6ioqT/fT65n4yMCM/16+WcO+8UAQwElJo9u1yBvCToCXp0xemRs1L65G2IXwtCr+LXkm9tn33WVHBMpsicYLt24n50ucQS6dixaVubTVyBf/+7WCNhEWwsdtnZkns2dWqx6tXL2+T8a69Vavr0iGAebLNalerRQ6kbbxSLK/w7GRkiwt9/L24/t1up//1PBGHgQJm/TEpqar3uK7LJydIuHLWqaXJ/HTp4ldkcVA6H9Et8vKR5hM9r21YCZwoLlZo6VfZXV0f6t6xM9mVmRtITGuPjj+X4unWRfXPnRrjNny8vEiBCGg6C6d9fON95p5wTdjfPmSPjo1cvrzr33BYZIkcMerRG9MhZKX3ybu7z2qjw0gzotcJLfn4+AFk/Vz/rELB2rRRqDgYj+zIzpapIICCP4O7doX9/+OILKb0VfjRrmlRR8fmklNdDD0ldzI8/looj+6JzZx/nnWdj7lypbhLG8OFw552y5OATTzQ9FobFIr9VWxvZZ7PJgq/x8VIJpbxc2vXuLdVShgyRf9PTpX0oJNVgyst/eduyRSrg+HxynqYplGpazs1ulyWG3n0Xli2TkmpffCH8CgqkmozfDzNmSIHsdu2k8HReXtO6n16vLLpx/fXw9NOyTylZmnH3bvj976UkXWys1PYcMkT66qmn5HqvvCLtHA6pAzp2LPz1r/m88UYMTz6ZwJ49LbcC/eFGS47rIwU9cgZ98jYqvLQg9Gr5tbTLYto0Cdd/6ikJqgjnuMXFNY0MHTBALKzwHFvYkgpHg4JUipk7V+bHJk+WuapwjmHjLTt7/xSJnByJjMzPl7m+bt1+3gJMS4vkITYOWOnUSZLBw8EmINbZ738vbsrVq/evKHMglJcrdeaZSjmdIZWcHFAulwQKhVM/9t169hQLeMMGpVatEhdpOI+wd2/JCwRxM++LO+6Q+2mcD/jYY3KfMTFy3j33iPXdtav0dVmZzHtqmsw3KiVtkpKUKiwsUWvWlDU5pgfo0RWnR85K6ZO34fZsQehV/I5Ejs6yZUqNGxcJiGksgkOHikA2Fj+7PfKwDwdjfP65zKf5/Up99lmx+vOfq1XXrgd2O+67r1MncRO+9JLk4TUWs3231FRxPe7r1tQ0mSuLixP3bPi40yli9fvfS3DMkiXitqyvb9oH99+vVGpqQP31r5UqLe3Av52UJIJaXCxRmL17y/7kZBHAcJRnTY305QsvHLivw27NMHbujAQatWun1MKFkReM7t0j7caMEReoUnJts1mpjRt3q4KCAjV8uCT76wV6zD3TI2el9MnbEL8WhF7F70hWZ9i9W6kHHpDoT03bX6jCeXnhLS1NLK+w0CQlSW7d4sX5DZzLy6XKzFln/bygJSWJgIYf+Ckpkj83ZEikruaBNodDLMJ9E/mbu5lMYqk2FksINWlz8slipYbroTqdkbnSCy8U0T9QpOVppyl13nn77w+FZC7xoYea7g/XJe3QQa4f7vvlyyNtwnO2S5fK3ODZZ0fGx2uvyXlFRS02HA4r9Fh1RI+cldInb0P8WhB6Fb+jUZfP4xFXZNhyM5sjD+Z9o0XDrsZw2kRYQAYO9Kr33mtasiwUkojF6647sBh17iwlw+69V8QjnOweFSXimJR0YKFzuSR688Ybxf36979LzlzfvnLNzEwRHLv95wNhDiaS4ajS8AvAoEEHFprycsmdDNdK3Rf5+XL+p5/Kd59PLNLGLxQvvST3A1LCLQy/X655xRVy7P33I+OjtFQE+UDW5rEIPdab1CNnpfTJ2wh4aUHoNeClqKgIgLR91+g5AlBK1p579llZ7shkkn3Dh8uisPPmRRZV/Tk4HHDRRXDLLbJ0UuMAkNpaeOwxWaV8X7RvL8EevXvDokXyW/PmSZCKpsnafTU10ja8vl8YZjO0aSPrG150kSzn1HitvzC2bIH//U+Wepo6FczmEH6/ht/fNOBF0+Q3lIKzzpLgoG+/lcCXa66RIJuyMgn+ee894XLmmbLsUFqacC4rk3+XLJHAmOHDpe82bZIlpkACeMaMgfx8WLlS+m7CBHjkkQiX+++X5ZNsNtizB6qqIuNj7FioqpJ+OtZxNMf1r4UeOYM+eRvr+bUg9Cp+x8paXJs2yUP37bfl4R4ece3bSyRiefnBr5GSIuvf3XijiFNj1NVJNOP48T9//umnQ2KirIReWirrAZaVNW1jMokw+HwS8RlGYqKskj56NFx8sURklpSI+H32mWwAWVl+zjvPSmIiPPqoLPhrMslitwsWyCK0hYWyOG4gcPB7DiMqSjh4vSJQrVsLf4sFOnYUwVNKBP2MM2QR3HffhTlzZLHiMDZtgi5dpC++/77p+Hj5ZbjtNrn+sT7Ej5VxfSjQI2fQJ29D/FoQehW/Y20V5vJymDxZFnUtLBSrx+drKkJ2e4hQCPx+089ep1s3WTR36FCx7uz2yLHqallw9tFHRXB+K8IrqDcWw8aw20WUTj3Vy9ixPvr0cZGfLyK9ebOI04svyoK/9fWSwjBqlKy87vPJIrdnngnZ2WJ1JibKFhMjvxkIiKiVlsKf/0xDSsJNN0n6yZdfivClpMiitT/+KLyuv15SQdatk+8bN0raw1tvQb9+YkU2Hh9XXCGivG5dUwv7WMSxNq6bAz1yBn3yNsSvBaFX8SspKQEgOTn5KDNpCr8fPvkE/vUvWLwYcnIkP3D7dli+XBEKaQcVnTDMZlmNftAgWe184EC5XvgBXl8vq66/9RasWNE0TxHEiurUSbbWrUWU1q4Vi6mkJGKl/lqEeSgl7l6PRwTVbheBNJvld0pL5d/w1jhPsTGSk+U6eXlyzXbt5IXinHNE8MePl/1ZWXDJJeK6feYZ+Pxzedk47TSxRHfsAKdTxofVmkxamrhI7733t93vkcCxOq5/CXrkDPrkbYhfC0Kv4rd1r8+rQ4cOR5nJz2PBAhHBTz4Rd9vvfldBaamFH390UVMj4nEwATwQEhJkXu3cc8UVGBcnLr1p02DKFPjhB7l2UpIIUngOsHNnEdBBg0RUg0Gxpr77TixKt7upoFksYrXFx9cRFRXCZIpm40ZJ/t93PvFAsFjE1aqUWIL7ijPI8fB1nE7h26UL/Pvfcm8//SRJ+osXy0vEmjXipu3SRSy+k04Sy/PKK+U30tLENXr55TI+vv22A7fdJu7TjIxD7+sjDT2M632hR86gT97NfV5bjiAnA0cY8fHxR5vCQTFokGx5eTJH9tprcVRXm3A6IzGTAK1ayYN/167mXbeiQkRuypT9j3XrBldfLS7EDRvkX6cTunYVAf7xRzmv8WthQoIc791bBCY1VYJOcnNFwOfPt1Nb29RVGxsrv3XKKWKhxcWJpbdokQj+P/4hFl5ZmRxLSRHLLjkZXC6ZS3zjDRHtpCSxCIcOlUCffv3kNzweaed0SsWYuXPhySflWHKyBByNGRNx39rtYhG+9RbcdFM8miafR4/Wh/CBPsb1vtAjZ9Av7+bAsPyaAb1afnr01+/cWcqyZVbWrIlj3jyYPfvAwSEDBoiI7AtN++2uShCxSE4WQYiJEYuspEQsuqqqA52hAA2rVYQrLk64eL0icNXV+1uwFotc224XUVRKLLyaGjmvMbKzoVcv4VVcLIJdXCyWaGOYzcK7TZsDl38DCXYZORK++aYSp1Nx2mkJfPihiKIeoMdxrUfOoE/ehuVngMq9uQR6Grg+XyU9esAFF8QBInyrV0sI/ldfSdoENBW+Hj3E0tu1q2WED0So9uyRDUTIbDYRrH3dmcnJ0Lmzh4yMAA5HXIMwhbefc30GAiKMXm/EvbtvpClEAnoKC8U67NJF5u5iY6Uf/vc/uOMOSW347juZS7znnp+/t3B07Wuvmfj66xgyM+G8835dPx0N6HFc65Ez6Jd3c2CI33EMPbos9uVsscDJJ8t2550ibtu3y9xd+AG/Zk2kvdMpLrzycnFHhotO/xo0tiKVEpFqbJGFcwYTEsBqteBwmGjTRlySMTESxFJQIHNxGzYcOK/R75ctNlZcqR06wMSJ0KeP3ENCgliSjSMw/X4Jcnn4YbES771XfnPMGHlROPdc+MMfDnxPa9fCX/4in2fPjuH22+u5996oJhGzxzqOh3GtF+iVd3NgiJ8BXUHTZP5s/PhIXt+yZWL5LFggOX/TpkXan3mmWEnt20vk54oVYkWuWhUJLjGZItZWZqYEvbRuLRadzSZuTqtV5iYzMkRsFy8WIdm+XVIaNm+2Y7EoLBYRp2BQzgmF5HNiouTXDR4sLsnU1Kab07n/vbpcTb8rJfN7f/mLJNmPGydCN2mSzPOddpoE5QwevP+15s2TVIcvv5T7HTUK3nijnOhoSEqK+s1/FwMG9AZjzq8Z0Ouc37Zt2wBo3779UWbSfPxWzuvWwZtvwj//uf8xq1UspCFDxJIsLRURWb9exHBvVDdmc0QYo6MlwGXo0Eg6RWJi0+uWlcG0aYUsWuRg3rwENm+OiGlGhkSPduokYpqUFAlqCX+Pjj74fS1aJJbuvHkS4fnHP0rRgP/9T4JwnnxSKsi43eIeLSyUJYwKC+HTT0UUTzoJLrgAHn9cIkRTUvQ3PuDEHNdHC3rkbaQ6tCD0Kn7FxcUApKSkHGUmzUdLcVZKrLOpU6VsWFjYWgqaJhaUxRLeQtTVgc9nomdPGDFChG31asmpC+fv7RugAmL1xceLCNrtct1gMJKCUVMj7tu4OLFIPR6xOOPiRNCs1ojQ7ZsfGBUlKRsTJoTX8IP//lfalpXpb3zAiT2ujzT0yNsIeDGAdqyX6jgAWoqzpomVNmCAWIGzZ4sIfvKJuDHNZsmF69tXrMAePWSfzxfZ6utFZLZulYCasEVVUSHHfD5xcco8YCTNYfVq2cI8LBaptRkTIzl2oZCcX1srW11dpEbnL6GqKhJp6nTKtRwOSV7v31/+zciQf8Nb4/nCNWvggw8kId5s1uf4AH3y1iNn0C/v5sAQv+MY7r1mhp6qMxwOzmazzHGNGiW5hN9+K27ABQvEMnzjjcjK7oMGRZLcG1eK+SUoBatX51FYaMbna82OHZIwXlgo0Z6lpRLsUlMjFlr4nHBSu9UqQpaVJfOZbdrI56wsEbCYGBFYt1tcpenpYtE1F1u2wEMPwfvvyyrud98t+/U4PkCfvPXIGfTLuzkwxO84hsPhONoUDhmHm7PDIZbPOefI90BALKKFC0UMZ8yAF16QYykpTcWwX78Dz89pGqSk2EhJEWFqLpQSi8/pPDz1NHfulJJlb70l4vrKKxIFarXKcT2OD9Anbz1yBv3ybg4M8TuOYQ0/5XSEI83ZYpG0gj59ZOkkEEtt0SIRw4ULJUDE7Y64SsNiOHCgpCbIskWHzlvTDs2Cay6KiuCJJ+C112Re8Jln5N72fY7pcXyAPnnrkTPol3dzYIjfcQyPx3O0KRwyjgXOSUkSHDJ2rHwPBiUiNCyGs2eLFQVSdm3gQOjSxUKvXj569YqszHC4LLrG8HoluT8/X7bly0X0bDZ48EG4664Dr0cIx0Zf/xrokbceOYN+eTcHhvgdxzCbzUebwiHjWORsNktATI8eUj0FJOhl0aKIu3Ty5Fiqq5vW9rTbRRzDYtj48y99D4tmMChW3M6dEXHLz2/6PVyBJozkZPjTnyQtIiHhYPd17PV1c6BH3nrkDPrl3RwY4nccw66nsh17oRfOCQlSSWb0aPleXFzOzp0mgsFEystp2MKrsIe3NWsinysqDlyOzW4Xd2V5edO6ptHRUuMzK0vqfJ5zTuR7eDsUN6pe+npf6JG3HjmDfnk3B4b4Hceor68/2hQOGXrkDODz1ZOWBq1bJx688V6EQhIFeiChrKwUK66xsMXHt6wbVa99rUfeeuQM+uXdHBjiZ8DAUYLJFHF5GjBg4MjCEL/jGHoMU9YjZ9Anbz1yBn3y1iNn0C/v5sAQv+MY3n0XhdMB9MgZ9Mlbj5xBn7z1yBn0y7s5MMTvOEYwXJ1ZR9AjZ9Anbz1yBn3y1iNn0C/v5sAQv+MYUYcjg/owQ4+cQZ+89cgZ9Mlbj5xBv7ybA0P8jmP4f24J8WMYeuQM+uStR86gT9565Az65d0cGOJ3HEOPYcp65Az65K1HzqBP3nrkDPrl3RwY4nccI+bn6lodw9AjZ9Anbz1yBn3y1iNn0C/v5sAQv+MYelynWI+cQZ+89cgZ9Mlbj5xBv7ybA9PBmxjQK2pqaqipqTnaNA4JeuQM+uStR86gT9565Az65d0cGJbfcYy4uLijTeGQoUfOoE/eeuQM+uStR86gX97NgWH5GTBgwICBEw6G+B3HqKyspLKy8mjTOCTokTPok7ceOYM+eeuRM+iXd3NguD2PY8THxx9tCocMPXIGffLWI2fQJ289cgb98m4ODMvPgAEDBgyccDDE7ziGHl0WeuQM+uStR86gT9565Az65d0cGG7P4xh6jNTSI2fQJ289cgZ98tYjZ9Av7+bAEL/jGFpLLvt9hKBHzqBP3nrkDPrkrUfOoF/ezYHh9jyOUV1dTXV19dGmcUjQI2fQJ289cgZ98tYjZ9Av7+bAsPyOY+hxORI9cgZ98tYjZ9Anbz1yBv3ybg4M8TuOYTabjzaFQ4YeOYM+eeuRM+iTtx45g355NweG+B3H8Hg8R5vCIUOPnEGfvPXIGfTJW4+cQb+8mwND/I5jWK3Wo03hkKFHzqBP3nrkDPrkrUfOoF/ezYEhfscxbDbb0aZwyNAjZ9Anbz1yBn3y1iNn0C/v5sAQv+MYdXV1R5vCIUOPnEGfvPXIGfTJW4+cQb+8mwND/I5jmEz6y2TRI2fQJ289cgZ98tYjZ9Av7+bAEL/jGHa7/WhTOGTokTPok7ceOYM+eeuRM+iXd3NgiN9xDK/Xe7QpHDL0yBn0yVuPnEGfvPXIGfTLuzkwxO84RigUOtoUDhl65Az65K1HzqBP3nrkDPrl3RwY4nccw+l0Hm0Khww9cgZ98tYjZ9Anbz1yBv3ybg4M8TuO4fP5jjaFQ4YeOYM+eeuRM+iTtx45g355NweG+B3H8Pv9R5vCIUOPnEGfvPXIGfTJW4+cQb+8mwND/I5j6LEorR45gz5565Ez6JO3HjmDfnk3B4b4HccIBoNHm8IhQ4+cQZ+89cgZ9Mlbj5xBv7ybA0P8jmPosSitHjmDPnnrkTPok7ceOYN+eTcHhvgdx4iNjT3aFA4ZeuQM+uStR86gT9565Az65d0cGOJ3HEMpdbQpHDL0yBn0yVuPnEGfvPXIGfTLuzk4fgu3GaCqqoqqqqqjTeOQoEfOoE/eeuQM+uStR86gX97NgWH5HceIj48/2hQOGXrkDPrkrUfOoE/eeuQM+uXdHBiWnwEDBgwYOOFgWH6HgOrq6qNN4ZCQn58P6GtBSj1yBn3y1iNn0CdvPXIGffJu7nPaEL9mILysR1ZW1lFmYsCAAQMGDoa0tLSDCramjudwnhaE1+s9rpf3MGDAgIHjBTabDYfD8YttDPEzYMCAAQMnHIyAFwMGDBgwcMLBED8DBgwYMHDCwRA/AwYMGDBwwsEQPwMGDBgwcMLBED8DBgwYMHDCwRA/AwYMGDBwwsEQv6OEJ598Ek3TuPvuu3+2zaeffsoZZ5xBcnIysbGxDBo0iG+++aZJm+HDh6Np2n7b2LFjG9o8/PDD+x1PS0trcp2ioiLGjBlDRkYGt956K6FQCICJEyfStWvXJm03bNiApmlcffXVTfa/8847WK1W3G73r+mSw4aW6uvJkyczdOhQEhISSEhIYNSoUSxevLhJG6OvD97XhYWFXHnllXTu3BmTyXTAtsa4Pjhaqq9P1HFtiN9RwJIlS3j99dfp2bPnL7b78ccfOeOMM/jqq69YtmwZp59+Oueeey4rVqxoaPPpp59SWFjYsK1duxaz2cwll1zS5FrdunVr0m7NmjVNjv/tb3+jf//+fP311+zYsYP33nsPgNNPP52NGzdSVFTU0HbOnDlkZWUxe/bsJteYM2cOp5xyCjExMb+qXw4HWrKv58yZwxVXXMHs2bNZsGAB2dnZnHnmmRQUFDS5ltHXv9zXXq+X5ORk7r//fnr16nXANsa4/mW0ZF+fqOPaEL8jDLfbzVVXXcXkyZNJSEj4xbaTJk3i3nvvpX///nTs2JEnnniCjh078sUXXzS0SUxMJC0trWGbNWsWUVFR+z0kLBZLk3bJyclNjldWVtKtWzd69OhB27ZtG5YxGTJkCFarlTlz5jS0nTNnDrfddhs1NTVs3bq1yf7TTz/913ZNi6Ol+/rdd9/l1ltvpXfv3nTp0oXJkycTCoX47rvvmlzL6Otf7uucnByef/55xo0bR1xc3AHbGOP659HSfX2ijmtD/I4wbrvtNsaOHcuoUaMO+dxQKERNTQ2JiYk/2+Y///kPl19+OdHR0U32b9myhYyMDNq2bcvll19Obm5uk+MTJ07kzjvvxG63s2LFCsaNGwdAdHQ0/fv3b/KG9sMPPzBy5EhOPfXUhv35+fnk5uYeUw+Jw93XHo8Hv9+/Xxujr1sexriO4HD39Ykyrg3xO4J4//33Wb58OU8++eSvOv+5556jtraWSy+99IDHFy9ezNq1a7nhhhua7B8wYABTpkzhm2++YfLkyRQVFTF48GDKysoa2vTr14+CggLy8/P56aefmrgdhg8f3vDWtn79eurq6ujTpw/Dhg1r2D979mzsdjuDBw/+VffW0jjcfQ3ynz0zM7PJQ8jo65aHMa4jONx9DSfQuFYGjgh27typUlJS1MqVKxv2DRs2TN11113NOn/q1KkqKipKzZo162fb3Hjjjap79+4HvZbb7Vapqanqueeea9Zvz5o1SwGqoKBAvfTSS+rss89WSim1YMEClZGRoZRS6rrrrlPDhg1r1vUON45EXz/11FMqISFBrVq16hevZfT1L6M5bY1xLTgSfX0ijWtD/I4Qpk2bpgBlNpsbNkBpmqbMZrMKBAI/e+7777+vnE6n+vLLL3+2TW1trYqNjVWTJk1qFp9Ro0apm2++uVltPR6Pstls6t1331UXX3yxeuqpp5RSSvn9fhUdHa02bdqkcnJy1MMPP9ys6x1uHO6+fuaZZ1RcXJxasmRJs/gYff3zONgD2RjXERzuvj7RxrXh9jxCGDlyJGvWrGHlypUNW79+/bjqqqtYuXIlZrP5gOe99957XHvttUydOrVJmPe++PDDD/F6vfz+978/KBev18uGDRtIT09vFnen08mAAQOYM2cOP/74I8OHDwdkAnzw4MFMmTKFHTt2HDPzIoezr5955hkeffRRZsyYQb9+/Q7KxejrA/d1c2GM6wgOZ1+fkOP6iMmsgf2w75vYxIkT1dVXX93wferUqcpisaiXXnpJFRYWNmyVlZX7XWvIkCHqsssuO+DvjB8/Xs2ZM0fl5uaqhQsXqnPOOUe5XC61Y8eOZnN98MEHlcvlUi6XS/n9/ob9jz32mHK5XMrpdKr6+vpmX+9IoyX6+qmnnlI2m019/PHHTdrU1NQ0tDH6+uB9rZRSK1asUCtWrFB9+/ZVV155pVqxYoVat27dftcyxvUvoyX6+kQd14b4HUXsO3CvueaaJj7vYcOGKWC/7ZprrmlynU2bNilAzZw584C/c9lll6n09HRltVpVRkaGuvDCCw/4oPklzJ49WwFq9OjRTfbPnTtXAWrkyJGHdL0jjZbo6zZt2hywzUMPPdTQxujrg/e1UuqA/dimTZsmbYxxfXC0RF+fqOPaWMzWgAEDBgyccDDm/AwYMGDAwAkHQ/wMGDBgwMAJB0P8DBgwYMDACQdD/AwYMGDAwAkHQ/wMGDBgwMAJB0P8DBgwYMDACQdD/AwYMGDAwAkHQ/wMGDBgwMAJB0P8DBgwYMDACQdD/AwYMGDAwAkHQ/wMGDBgwMAJh/8H81wxvdtUEWsAAAAASUVORK5CYII=\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import numpy as np\n",
"import matplotlib\n",
"import cartopy.crs as ccrs\n",
"import cartopy.feature as cfeature\n",
"\n",
"from pylag.processing.ncview import Viewer\n",
"from pylag.processing.plot import create_figure, ArakawaAPlotter\n",
"\n",
"\n",
"%matplotlib inline\n",
"\n",
"\n",
"# Plot options\n",
"font_size = 10\n",
"\n",
"# Create figure\n",
"fig, ax = create_figure(figure_size=(15., 15.), projection=ccrs.PlateCarree(),\n",
" font_size=font_size, bg_color='white')\n",
"\n",
"# Configure plotter\n",
"plotter = ArakawaAPlotter(ocean_grid_metrics_file_name,\n",
" font_size=font_size)\n",
"\n",
"extents = np.array([-4.3, -4.1, 50.15, 50.4])\n",
"\n",
"# Add tracks from the ocean only run\n",
"# ----------------------------------\n",
"# PyLag file name\n",
"file_name = f'{ocean_only_out_dir}/pylag_1.nc'\n",
"\n",
"# Dataset holding particle positions\n",
"viewer = Viewer(file_name, time_rounding=60)\n",
"\n",
"# Plot final positions\n",
"plotter.scatter(ax,\n",
" viewer('longitude')[-1, :].squeeze(),\n",
" viewer('latitude')[-1, :].squeeze(),\n",
" s=8, color='r', edgecolors='none',\n",
" configure=True,\n",
" draw_coastlines=True,\n",
" tick_inc=True,\n",
" extents=extents)\n",
"\n",
"# Add high resolution land\n",
"ax.add_feature(cfeature.LAND, facecolor='lightgrey')\n",
"\n",
"# Plot paths\n",
"_ = plotter.plot_lines(ax,\n",
" viewer('longitude')[:, :].squeeze(),\n",
" viewer('latitude')[:, :].squeeze(),\n",
" linewidth=1., alpha=1, color='r')\n",
"\n",
"\n",
"# Add tracks from the ocean + stokes drift run\n",
"# --------------------------------------------\n",
"# PyLag file name\n",
"file_name = f'{stokes_drift_out_dir}/pylag_1.nc'\n",
"\n",
"# Dataset holding particle positions\n",
"viewer = Viewer(file_name, time_rounding=60)\n",
"\n",
"# Plot final positions\n",
"plotter.scatter(ax,\n",
" viewer('longitude')[-1, :].squeeze(),\n",
" viewer('latitude')[-1, :].squeeze(),\n",
" s=8, color='y', edgecolors='none')\n",
"\n",
"# Plot paths\n",
"_ = plotter.plot_lines(ax,\n",
" viewer('longitude')[:, :].squeeze(),\n",
" viewer('latitude')[:, :].squeeze(),\n",
" linewidth=1., alpha=1, color='y')\n",
"\n",
"\n",
"# Add tracks from the ocean + leeway run\n",
"# --------------------------------------\n",
"# PyLag file name\n",
"file_name = f'{leeway_out_dir}/pylag_1.nc'\n",
"\n",
"# Dataset holding particle positions\n",
"viewer = Viewer(file_name, time_rounding=60)\n",
"\n",
"# Plot final positions\n",
"plotter.scatter(ax,\n",
" viewer('longitude')[-1, :].squeeze(),\n",
" viewer('latitude')[-1, :].squeeze(),\n",
" s=8, color='b', edgecolors='none')\n",
"\n",
"# Plot paths\n",
"_ = plotter.plot_lines(ax,\n",
" viewer('longitude')[:, :].squeeze(),\n",
" viewer('latitude')[:, :].squeeze(),\n",
" linewidth=1., alpha=1, color='b')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the plot, the red coloured lines show the tracks from the Ocean only run; the mustard coloured lines shows tracks from the Ocean + Stoke's Drift run; and the blue coloured lines show the tracks from the run with Ocean + Leeway run."
]
}
],
"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.4"
}
},
"nbformat": 4,
"nbformat_minor": 4
}