From 4951cbf6c11cde8b6d4e3d03293ed88ed0b39cb2 Mon Sep 17 00:00:00 2001 From: JRT Date: Tue, 15 Aug 2023 16:31:03 +0200 Subject: [PATCH 1/3] Add simple tide elevation and current scripts --- ...SimpleScriptGetTideCurrentTimeseries.ipynb | 555 +++++++++++ ...mpleScriptGetTideElevationTimeseries.ipynb | 890 ++++++++++++++++++ 2 files changed, 1445 insertions(+) create mode 100644 notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb create mode 100644 notebooks/SimpleScriptGetTideElevationTimeseries.ipynb diff --git a/notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb b/notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb new file mode 100644 index 00000000..c089533d --- /dev/null +++ b/notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb @@ -0,0 +1,555 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "76ec5877-8851-4437-8408-4db10daa43fe", + "metadata": {}, + "outputs": [], + "source": [ + "# the aim of this notebook is to illustrate the use of the Arc2kmTM tidal model, used py pyTMD\n", + "# and to provide a short, minimalistic example of how to use pyTMD\n", + "# note that if you want to use another of the models supported by pyTMD, you may need to do small changes to the code\n", + "# see in particular for help:\n", + "# (tide): https://github.com/tsutterley/pyTMD/blob/main/notebooks/Plot%20Tide%20Forecasts.ipynb\n", + "# (currents): https://github.com/tsutterley/pyTMD/blob/main/notebooks/Plot%20Antarctic%20Tidal%20Currents.ipynb\n", + "# see the Arc2kmTM_README_v1.pdf document, Arc2kmTM: Model Summary, for units" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e6f2c46e-d4f7-4364-b0f2-c7b26e3c32be", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import pyTMD.io\n", + "import pyTMD.time\n", + "import pyTMD.utilities\n", + "import pyTMD.predict\n", + "\n", + "import os\n", + "import time\n", + "\n", + "import xarray as xr\n", + "import pandas as pd\n", + "import netCDF4 as nc4" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b33cca10-4c73-44be-b7cb-c71bfc5d3695", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'2.0.6'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# my pyTMD version, installed from conda\n", + "pyTMD.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8b8b7f39-d286-4582-b5e5-c43a483dd771", + "metadata": {}, + "outputs": [], + "source": [ + "# BELOW IS TO PREDICT TIDE CURRENT" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "50a25254-bc7f-49e1-986a-49456c89bd91", + "metadata": {}, + "outputs": [], + "source": [ + "# parameters for the prediction\n", + "\n", + "# location: lat and lon\n", + "# can be either a single value each, or 2 np arrays (lat1, lat2, ...) and (lon1, lon2, ...) so that (lat1, lon1), (lat2, lon2), ... are the positions of interest\n", + "# --\n", + "# the same location as the in-situ observation (see below)\n", + "lat_to_predict = 72.502\n", + "lon_to_predict = 19.560\n", + "\n", + "# time: either a single datetime, or a np array of datetimes\n", + "# the same time as the observation (see below)\n", + "start_day_to_predict = datetime.datetime(2008, 7, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)\n", + "number_of_hours_to_predict = 24*300\n", + "times_to_predict = [start_day_to_predict + datetime.timedelta(hours=hr) for hr in range(number_of_hours_to_predict)]\n", + "\n", + "# details about the model location and format on my disk\n", + "model_path = \"/home/jrmet/Desktop/Data/tides/resource_map_doi_10_18739_A2D21RK6K/\" # obtained from https://arcticdata.io/catalog/view/doi:10.18739/A2D21RK6K\n", + "model_name = \"Arc2kmTM\"\n", + "model_is_compressed = False\n", + "model_atlas = \"netcdf\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9b315248-80d0-4863-92b0-23f5e1aad046", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0m\u001b[01;34mArc2kmTM\u001b[0m/ bagit.txt \u001b[01;34mmetadata\u001b[0m/\n", + "bag-info.txt manifest-md5.txt tagmanifest-md5.txt\n", + "---\n", + "Arc2kmTM_FileFormat.pdf h_Arc2kmTM_v1 UV_Arc2kmTM_v1\n", + "Arc2kmTM_README_v1.pdf Model_Arc2kmTM_v1 xy_ll_Arc2kmTM.m\n", + "grid_Arc2kmTM_v1 Revision_history.txt\n" + ] + } + ], + "source": [ + "# illustrate how the input model files look like\n", + "# this is simply the un-zipping of the arcticdata model data\n", + "\n", + "%ls $model_path\n", + "print(\"---\")\n", + "%ls $model_path/$model_name" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f7c0d1bd-05a5-4032-85d0-3344bd5266f4", + "metadata": {}, + "outputs": [], + "source": [ + "# note that pytmd internally uses its own time system with a given epoch start - dont mess it up and make sure to convert to it :)\n", + "pytmd_times_to_predict = [pyTMD.time.convert_calendar_dates(crrt_time.year, crrt_time.month, crrt_time.day, crrt_time.hour, crrt_time.minute, crrt_time.second) for crrt_time in times_to_predict]\n", + "model_time_delta = np.zeros_like(pytmd_times_to_predict)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a9be13b9-81db-4185-a0a5-91f592f61e26", + "metadata": {}, + "outputs": [], + "source": [ + "# show how to also get currents at the same location\n", + "# inspired from https://github.com/tsutterley/pyTMD/blob/main/notebooks/Plot%20Antarctic%20Tidal%20Currents.ipynb\n", + "# note that you may need to adapt the code if using a different model\n", + "# note that we repeat some code from above for clarity\n", + "# note that this looks very similar to what was obtained above, but this is not strictly identical! (as expected,\n", + "# tide elevations and currents are in different phases). See the generated complex phases and constituents.\n", + "\n", + "tide_model_base = pyTMD.io.model(\n", + " model_path,\n", + " format=model_atlas,\n", + " compressed=model_is_compressed,\n", + ")\n", + "\n", + "current_model = tide_model_base.current(model_name)\n", + "# current_model.type is type ['u', 'v'], i.e. BOTH u and v components of the current need to be retrieved\n", + "\n", + "tide_amplitude = {}\n", + "tide_phase = {}\n", + "model_bathymetry = {}\n", + "tide_constituents = {}\n", + "tide_complex_phase = {}\n", + "tide_constituent_oscillation = {}\n", + "\n", + "for type in current_model.type:\n", + " tide_amplitude[type], tide_phase[type], model_bathymetry[type], tide_constituents[type] = pyTMD.io.OTIS.extract_constants(\n", + " np.atleast_1d(lon_to_predict),\n", + " np.atleast_1d(lat_to_predict),\n", + " current_model.grid_file,\n", + " current_model.model_file['u'],\n", + " current_model.projection,\n", + " type=type,\n", + " method='spline',\n", + " grid=current_model.format\n", + " )\n", + " \n", + " tide_complex_phase[type] = -1j * tide_phase[type] * np.pi / 180.0\n", + " tide_constituent_oscillation[type] = tide_amplitude[type] * np.exp(tide_complex_phase[type])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eddcc79e-19f1-40e6-a2a0-91c8c0e28382", + "metadata": {}, + "outputs": [], + "source": [ + "# actually perform the prediction\n", + "# as long as the location is not changed, this can be used many times to predict for different times\n", + "\n", + "# this is to predict a time series at a single location over many times; for more alternatives, for example predict a map at a single times for many locations, see map in\n", + "# https://github.com/tsutterley/pyTMD/blob/main/pyTMD/predict.py\n", + "\n", + "tide_current_major = {}\n", + "tide_current_minor = {}\n", + "tide_current = {}\n", + "\n", + "for type in current_model.type:\n", + " tide_current_major[type] = pyTMD.predict.time_series(\n", + " np.atleast_1d(pytmd_times_to_predict),\n", + " tide_constituent_oscillation[type],\n", + " tide_constituents[type],\n", + " #detlat=0, # this is true for the present model, but maybe not for all of them!\n", + " corrections=current_model.format\n", + " )\n", + " \n", + " tide_current_minor[type] = pyTMD.predict.infer_minor(\n", + " np.atleast_1d(pytmd_times_to_predict),\n", + " tide_constituent_oscillation[type],\n", + " tide_constituents[type],\n", + " #detlat=0, # this is true for the present model, but maybe not for all of them!\n", + " corrections=current_model.format\n", + " )\n", + " \n", + " tide_current[type] = tide_current_major[type] + tide_current_minor[type]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a4f30df7-bbea-4ed8-9996-991e405be6a5", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'u': masked_array(data=[14.585549313940035, 9.421235878278702,\n", + " 2.4450647398058365, ..., -17.748034568858703,\n", + " -11.424931491118116, -2.1466757710907207],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'v': masked_array(data=[-2.934323184852216, -6.42188455361907,\n", + " -8.794020381224104, ..., 2.4438061903377926,\n", + " 5.909640272467249, 8.295701013971106],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20)}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tide_current" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "baf376ea-928b-40df-b5d6-ebb5e25c7499", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-08-15 16:03:08-- https://arcticdata.io/metacat/d1/mn/v2/object/urn%3Auuid%3Ad5f179a3-76a8-4e4f-b45f-8e8d85960ba6\n", + "Resolving arcticdata.io (arcticdata.io)... 128.111.85.224\n", + "Connecting to arcticdata.io (arcticdata.io)|128.111.85.224|:443... connected.\n", + "HTTP request sent, awaiting response... 200 200\n", + "Length: unspecified [application/netcdf]\n", + "Saving to: ‘urn:uuid:d5f179a3-76a8-4e4f-b45f-8e8d85960ba6’\n", + "\n", + "urn:uuid:d5f179a3-7 [ <=> ] 1,21M 937KB/s in 1,3s \n", + "\n", + "2023-08-15 16:03:10 (937 KB/s) - ‘urn:uuid:d5f179a3-76a8-4e4f-b45f-8e8d85960ba6’ saved [1264327]\n", + "\n" + ] + } + ], + "source": [ + "# validate against the data from:\n", + "# https://www.nature.com/articles/s41597-020-00578-z/tables/2\n", + "# available at:\n", + "# https://arcticdata.io/catalog/view/doi:10.18739/A26M3340D\n", + "# we use the dataset for validation (from List_of_records.txt):\n", + "# bar_BSO3_a_rcm7_2008_09.nc\n", + "# note that by choosing the \"unhide nested data\", you can download files independently, instead of downloading a huge zip of all the files\n", + "# downloading 1 file independently is very recommended (I tried to download the huge zip, but it got corrupted and could not be extracted\n", + "# on each of my attempts)\n", + "\n", + "# get the file\n", + "!wget https://arcticdata.io/metacat/d1/mn/v2/object/urn%3Auuid%3Ad5f179a3-76a8-4e4f-b45f-8e8d85960ba6\n", + "# rename the file\n", + "!mv urn\\:uuid\\:d5f179a3-76a8-4e4f-b45f-8e8d85960ba6 bar_BSO3_a_rcm7_2008_09.nc" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7d79d0f6-900f-4361-bfd7-28027025c0c4", + "metadata": {}, + "outputs": [], + "source": [ + "xr_obs = xr.open_dataset(\"./bar_BSO3_a_rcm7_2008_09.nc\", drop_variables=[\"six_con\", \"all_con\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "937ae1b7-d7c0-4035-9329-aca68b14b500", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "float(xr_obs.latitude.data) = 72.502\n", + "float(xr_obs.longitude.data) = 19.560833333333335\n", + "xr_obs.time[0].data = array('2008-06-27T23:00:00.000003000', dtype='datetime64[ns]')\n", + "xr_obs.time[-1].data = array('2009-06-29T08:20:00.000002000', dtype='datetime64[ns]')\n" + ] + } + ], + "source": [ + "# where on the Earth we are getting data\n", + "print(f\"{float(xr_obs.latitude.data) = }\")\n", + "print(f\"{float(xr_obs.longitude.data) = }\")\n", + "\n", + "# when we are getting data\n", + "print(f\"{xr_obs.time[0].data = }\")\n", + "print(f\"{xr_obs.time[-1].data = }\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c3d5e7db-20b0-4081-9cdf-d37f3c8a327c", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "xr_obs_pd_timestamp = pd.to_datetime([pd.Timestamp(timestamp) for timestamp in xr_obs[\"time\"].data], utc=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "022f5c91-0b46-47b1-b0e0-6a7b46baec59", + "metadata": {}, + "outputs": [], + "source": [ + "df_xr_obs = pd.DataFrame({'utc_timestamp':xr_obs_pd_timestamp, 'xr_obs_u':xr_obs[\"u_tide_pred\"].squeeze(), 'xr_obs_v':xr_obs[\"v_tide_pred\"].squeeze()})" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e85dbd92-007f-4ec9-8faf-bdb4e7fbda4a", + "metadata": {}, + "outputs": [], + "source": [ + "df_pytmd = pd.DataFrame({'utc_timestamp':times_to_predict, 'pytmd_u':tide_current[\"u\"], 'pytmd_v':tide_current[\"v\"]})" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "40f1c2fc-5e2d-4495-9c96-57af5f3928bd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# compare the model data generated by pyTMD to the observations-based full record tidal analysis\n", + "\n", + "# time window to plot for comparison\n", + "utc_timestamp_start = datetime.datetime(2008, 9, 10, 0, 0, 0, tzinfo=datetime.timezone.utc)\n", + "utc_timestamp_stop = datetime.datetime(2008, 9, 18, 0, 0, 0, tzinfo=datetime.timezone.utc)\n", + "\n", + "def get_mask(df_in, utc_timestamp_start, utc_timestamp_stop):\n", + " mask = (df_in[\"utc_timestamp\"] > utc_timestamp_start) & (df_in[\"utc_timestamp\"] < utc_timestamp_stop) \n", + " return mask\n", + "\n", + "# plotting...\n", + "\n", + "# keeping this for now, to report issue to pandas\n", + "\n", + "# this should work but plot is empty!\n", + "fig = plt.figure()\n", + "ax = plt.gca()\n", + "#\n", + "mask_pytmd = get_mask(df_pytmd, utc_timestamp_start, utc_timestamp_stop)\n", + "df_pytmd.loc[mask_pytmd].plot(x=\"utc_timestamp\", y=\"pytmd_u\", ax=ax)\n", + "#\n", + "mask_xr_obs = get_mask(df_xr_obs, utc_timestamp_start, utc_timestamp_stop)\n", + "df_xr_obs.loc[mask_xr_obs].plot(x=\"utc_timestamp\", y=[\"xr_obs_u\"], ax=ax)\n", + "#\n", + "plt.show()\n", + "\n", + "# while both plots individually work\n", + "\n", + "# plot 1\n", + "fig = plt.figure()\n", + "ax = plt.gca()\n", + "#\n", + "mask_pytmd = get_mask(df_pytmd, utc_timestamp_start, utc_timestamp_stop)\n", + "df_pytmd.loc[mask_pytmd].plot(x=\"utc_timestamp\", y=\"pytmd_u\", ax=ax)\n", + "#\n", + "# mask_xr_obs = get_mask(df_xr_obs, utc_timestamp_start, utc_timestamp_stop)\n", + "# df_xr_obs.loc[mask_xr_obs].plot(x=\"utc_timestamp\", y=[\"xr_obs_u\"], ax=ax)\n", + "#\n", + "plt.show()\n", + "\n", + "# plot 2\n", + "fig = plt.figure()\n", + "ax = plt.gca()\n", + "#\n", + "# mask_pytmd = get_mask(df_pytmd, utc_timestamp_start, utc_timestamp_stop)\n", + "# df_pytmd.loc[mask_pytmd].plot(x=\"utc_timestamp\", y=\"pytmd_u\", ax=ax)\n", + "#\n", + "mask_xr_obs = get_mask(df_xr_obs, utc_timestamp_start, utc_timestamp_stop)\n", + "df_xr_obs.loc[mask_xr_obs].plot(x=\"utc_timestamp\", y=[\"xr_obs_u\"], ax=ax)\n", + "#\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "cb714ca6-418b-40af-aae6-01e90c787e44", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAHlCAYAAADm9LYpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAD/mklEQVR4nOz9d7htWVkljI+1czj5nHtuDpUzBVQVRU4toVSU8LWKrQ2CgLGxEf390G6l+WxBbaBUFFtUKG21jZhQCgSqilhUpHLdCjffc++5J++c1vr+mPOda669V15znzjH89xnn7vDWeHsvedY4x3veA3LsixoaGhoaGhoaGwDpDZ6BzQ0NDQ0NDQ0VEETGw0NDQ0NDY1tA01sNDQ0NDQ0NLYNNLHR0NDQ0NDQ2DbQxEZDQ0NDQ0Nj20ATGw0NDQ0NDY1tA01sNDQ0NDQ0NLYNMhu9A0lRLpfRbDaRTqcxOzu70bujoaGhoaGhEQLz8/Po9XooFAqo1WrKfq+x1QP60uk0TNPc6N3Q0NDQ0NDQiIFUKoVer6fs9215xYaITSqVwt69ezd6dzQ0NDQ0NDRCYG5uDqZpIp1OK/29W57YzM7O4syZM9i7dy9Onz690bujoaGhoaGhEQIHDhzAmTNnlNtItHlYQ0NDQ0NDY9tAExsNDQ0NDQ2NbQNNbDQ0NDQ0NDS2Dba8xyYser0eOp3ORu/GjkA2m1VuBtPQ0NDQ0AiDbU9sLMvCuXPnsLKystG7sqMwMTGBPXv2wDCMjd4VDQ0NDY0dhG1PbIjUzM7OolQq6YV2yLAsC/V6HfPz8wCgW/A1NDQ0NNYV25rY9Ho9QWqmp6c3end2DIrFIgCWKjk7O6vLUhoaGhoa64ZtbR4mT02pVNrgPdl5oHOufU0aGhoaGuuJbU1sCLr8tP7Q51xDQ0NDYyOwI4iNhoaGhoaGxs6AJjYasfD2t78db3zjGzd6NzQ0NDQ0NBzQxGabQhMPDQ0NDY2dCE1sNDQ0NLYzeh3A7G30XmhorBs0sdmkeOUrX4mf+Zmfwc/8zM9gYmIC09PT+G//7b/Bsix86EMfwnXXXTfwmhtuuAG/8iu/gg9+8IO47bbb8I//+I8wDAOGYeCOO+7A8ePHYRgG/vqv/xove9nLUCwWcdNNN+Ho0aO45557cOONN2JkZASvf/3rceHCBfF7e70e3ve+94n9+MVf/EVYlrWep0NDQyMOOg3gky8Gfu8FQLe10XujobEu2NY5Nm6wLAuNzvpfvRSz6cidQrfddhve+c534u6778a9996Ld7/73Th8+DDe8Y534H/8j/+Be+65BzfddBMA4KGHHsIDDzyAv/mbv8Hs7Cwef/xxrK2t4dOf/jQAYGpqCmfPngUA/Oqv/ipuvfVWHDp0CO94xzvw1re+FWNjY/jt3/5tlEol/MAP/AB+5Vd+BZ/85CcBAB/96EfxJ3/yJ/jjP/5jXH311fjoRz+Kz372s3j1q1+t8AxpaGgox/1/CiwcZT8f/ypw6Xdt7P5oaKwDdhyxaXR6uPpXbl/37T72odehlIt2ug8ePIiPf/zjMAwDV1xxBR5++GF8/OMfx7ve9S687nWvw6c//WlBbD796U/jFa94BS6++GIALCSv1Wphz549A7/3/e9/P173utcBAN773vfirW99K770pS/hJS95CQDgne98Jz7zmc+I59966634wAc+gLe85S0AgD/4gz/A7bev/znU0NCIiAf+zP75ic9pYqOxI6BLUZsYL3zhCx0qz4te9CI89dRT6PV6eNe73oW//Mu/RLPZRKfTwZ//+Z/jHe94R6jf+5znPEf8vHv3bgBwlLZ2794tRiKsrq5ibm4OL3rRi8TjmUwGN954Y6Jj09DQGDIsC1h42v7/sa9u3L6sBx75O+DO32LHrbGjseMUm2I2jcc+9LoN2a5KvOENb0A+n8dnP/tZ5PN5tFotoagEIZvNip+JOPXfZ5qm0v3V0NBYZ1TOAd2G/f/VU2zR347hmY/+A/C3/MLuopcDh27e0N3R2FjsOGJjGEbkktBG4Vvf+tbA/y+77DIxe+ltb3sbPv3pTyOfz+OHfuiHHKMjcrkcer3kXqLx8XHs3bsX3/rWt/Dyl78cANDtdnHffffh+c9/fuLfr6GhMSQsPctuR/cBlTmg2wTqi0B5ZmP3axi454/sn099SxObHY6tscLvUJw6dQrve9/78J73vAf3338/fvd3fxcf/ehHxeM//uM/jquuugoA8PWvf93x2iNHjuD222/Hk08+ienpaYyPj8fej/e+9734yEc+gssuuwxXXXUVPvaxj2FlZSX279PQ0FgHELGZvRKwTKB6jqk225HYLDxl/3zybuAlG7crGhsPTWw2Mf7zf/7PaDQaeMELXoB0Oo2f/dmfxbvf/W7x+GWXXYYXv/jFWFxcxM03O69Q3vWud+GOO+7AjTfeiGq1iq985Ss4cuRIrP34+Z//eczNzeHtb387UqkU3vGOd+BNb3oTVldXkxyehobGMEHEZuoSoLnGic1pYN/zNna/VKO5yo6NcPrbG7cvGpsCmthsYmSzWdx6662i7boflmXh/PnzeM973jPw2K5du/CFL3zB9TUyXvnKVw7c9/a3vx1vf/vbxf8zmQxuvfVW3HrrrdEPQkNDY2OweprdThwEaheAM/cCq2c2dp+GATJIZ0tAp86OtV0HciX/12lsW+iuqC2K+fl5fOxjH8OZM2fwYz/2Yxu9OxoaGpsN9QV2W54Fxg+wn1dPbdz+DAuU07P/BiBTZD/LCo7GjoNWbLYodu/ejZmZGfzhH/4hJicnN3p3NDQ0NhtqPD28vAsY3ct+rmzDBX/5OLudupipVMvH2HFOXbyhu6WxcdDEZpPijjvu8H1cjzTQ0NDwRY0UmxmgNsV+bixv3P4MCzWWuYXRPYzAEbHR2LHQpSgNDQ2N7QbLkhSbGaBIxGZp4/ZpWKhyYlPeBYyywFFNbHY2NLHR0NDYmXj634Fzj2z0XgwHzRXA7LKfSzNAiROb+jYkNq4lt7mN2x+NDYcmNhoaGjsPx78O/J+3ALe9Aeg0N3pv1KO2yG7zY0C2ABS5D6+xsmG7NDQQsRmZZeUoAKie37j90dhwaGKjoaGx8/C1j7HbxhLw5L9u7L4MA7TYl6bZLZWiWqtAr7sx+zQsVEmxmQVGOLHRis2OhiY2GhoaOwvdNvDMV+z/P/YPG7YrQ4NcngGA4oT92HYyEHcaQLvCfi5LJbftdIwakaGJjYaGxs7CygnAkuaoyXH82wV1Xoqi8QmpNFDgY1W206JPxuF0jh1fYYL9v6FT0XcyNLHZgrjjjjtgGIae16ShEQdEZHIj7Hb5OOsi2k5orrBbWuiB7dkZVZNCCA3DVqaamtjsZGhio6GhsbOwyCP4L34lYKTsGP7tBFrYC9Lw2+3YGUXKFB0bEbnWKmD2XF+y5WGaG70Hmx6a2GhoaOwsELHZfQ0wxkcNLB3buP0ZBtyIjeiM2kbEho6TlBr5eLejavPw3wIf3g/c/svbT2VUCE1sNilarRb+y3/5L5idnUWhUMBLX/pS3HPPPY7nfP3rX8f111+PQqGAm2++GQ8//LB47MSJE3jDG96AyclJlMtlXHPNNfjXf92G3R8aGlEhT72ePMx+plj+7QI3YkNqRnNt3XdnaBAlN36cmRwbhik/tp3w0F8xhfGbnwCe/tJG782mxc4bqWBZ7I2x3siWWA04JH7xF38Rf/d3f4fbbrsNhw8fxm/+5m/ida97HZ5++mnxnF/4hV/Ab//2b2PPnj34pV/6JXzf930fjh49imw2i5/+6Z9Gu93GXXfdhXK5jMceewwjIyPDODINja0FMpyO7WXE5vhXmaF4O8GN2ORH2W2rsv77Myy4eYkKE+w7frspNpYFnLnf/v/cg8Bl37Vhu7OZMVRic9ddd+G3fuu3cN9992Fubg6f/exn8cY3vlE8/va3vx233Xab4zU333wzvvWtbw1vpzp14Nf3De/3e+GXzgK5cqin1mo1fPKTn8RnPvMZ3HLLLQCAT33qU/jiF7+IP/7jP8ZNN90EAPjVX/1VvOY1rwEA3HbbbThw4AA++9nP4gd+4Adw8uRJvOUtb8F1110HALj4Yj0QTkMDgB3eVp4FRngE/3b12Mht3nl+YdPaToqNmzI1DlTObr8wwuVj9sR2wJ5qrjGAoZaiarUarr/+enziE5/wfM7rX/96zM3NiX+6XAI888wz6HQ6eMlLXiLuy2azeMELXoDHH39c3PeiF71I/Dw1NYUrrrhCPP5f/st/wa/92q/hJS95CX71V38VDz300PodgIbGZkW3ZV/lj8yycQOA3V2zXeCq2Iyx23Z1/fdnWBDHOWHfJzqjVtZ5Z4aMsw86/3/hiQ3Zja2AoSo2t9xyi1AcvJDP57Fnz55h7oYT2RJTT9YbVPcNAZrcbfSVrizLGrivH/T4j//4j+N1r3sdPve5z+ELX/gCPvzhD+OjH/0ofvZnfzbijmtobCOQMpPKMjMt5bzUdwKx2YalKFJlZGVKeIm2WSlq7Qy73Xs9MPcdFltgmkBKW2X7seFn5I477sDs7Cwuv/xyvOtd78L8/Lzv81utFtbW1sQ/K6oz3DBYSWi9/0Xw11x66aXI5XL42te+Ju7rdDq49957cdVVV4n75JLd8vIyjh49iiuvvFLcd/DgQfzET/wE/v7v/x4///M/j0996lPRzpWGxnYDlaFGeO4JERuarbRdsFOIjVcpCth+pag1Pibi8EsAI81sFVU9xdwNG0psbrnlFvz5n/85vvzlL+OjH/0o7rnnHrz61a9Gq9XyfM2HP/xhjI+Pi39nz26A+jJklMtl/ORP/iR+4Rd+AZ///Ofx2GOP4V3vehfq9Tre+c53iud96EMfwpe+9CU88sgjePvb346ZmRnhYfq5n/s53H777Th27Bjuv/9+fPnLX3aQIg2NHQmaKzQyy25FKWobeWw6TaDLB3tue2Kzwm4dbe0Tzse2Cyp8rRs/aI/K2E7vW4XY0K6oH/zBHxQ/X3vttbjxxhtx+PBhfO5zn8Ob3/xm19d84AMfwPve9z7x/6uuumpbkpuPfOQjME0TP/qjP4pKpYIbb7wRt99+OyYnJx3Pee9734unnnoK119/Pf7pn/4JuVwOANDr9fDTP/3TOH36NMbGxvD6178eH//4xzfqcDQ0NgeEYsNNw6IUtbh9ZH1hDjaA3Kh9PyUtbyti4+KxEQRuG3mJAFuxGdvLiE31nCY2HthU7d579+7F4cOH8dRT3rNb8vk88vm8+H+Q52SrolAo4Hd+53fwO7/zOwOPvfKVrxQluO/93u91ff3v/u7vDnX/NDS2JKjVm654afq11WNX+JRgu5VBi31+zEnUyDy83buiiMBtJ5M0YCs2o/uAMn/fbjfTuyJsqsuTxcVFnDp1Cnv37t3oXdHQ0NiO6B8OmcnbC359m/hsKICvMOa8f7spGabpQWx4rMZ2IjaWBVS4n2Z0jy5FBWCoxKZareLBBx/Egw8+CAA4duwYHnzwQZw8eRLVahXvf//78c1vfhPHjx/HHXfcgTe84Q2YmZnBm970pmHuloaGxk4F+S6KdknXNhBvk0WizUtNub5ATtljsx3i+Ds1wOJzk1y9RNuI2NSXgF6b/Ty6VxObAAy1FHXvvffiVa96lfg/eWPe9ra34ZOf/CQefvhh/Omf/ilWVlawd+9evOpVr8Jf/dVfYXR01OtXamhoaMRHY5ndDky9fnb7dNHQgp73IDZmh+X5ZAvru1+qQV4hIwVki/b9QrGprf8+DQtEYAoTbGxEeZvmLynCUImN7AVxw+233z7MzWtoaGg4QcRGVmzoan+75J5QCSbfd4EoKzityjYgNvw4c6POOI3t6LGh9y15wIRio4mNGzaVx2ZYiJx1o5EY+pxrbEqIQDeZ2HAvynYhNi2PUlQqJXVGbQMDMZXcvJSp7Uhsiv3ERpei3LCtiU02mwUA1OsbMPRyh4POOf0NNDQ2BcQCMWHft1MUG/m+7dDyLRSbPmJDpajt5LHpVxq36ygQRdhU7d6qkU6nMTExIdKMS6XStm0P3yywLAv1eh3z8/OYmJhAOp3e6F3S0GCwrJ1RivJa8AF7tEtnG1zstT28RNu5FEXvWxFCuE3es4qxrYkNADGHKmhUg4ZaTExMrO8MMA2NILRrzDgLOM3D243YeC34AJDjxKa9DYhNkGLTawPdNjPbbnX0Exs5k2i7BEsqxLYnNoZhYO/evZidnUWn09no3dkRyGazWqnR2HygVu9U1l78AJvYtLYJsfFTbLaTmiE8Nj4m6XYVyGyD0MXGErslYiMyiix2jP2ZRTsc257YENLptF5sNTR2MuSrXrkknd9uio3Hgg+sXynq/KOMYB26eXjb8CJwmRyQzjHFpl3bHmnS/YpNpsAIutlhqo0mNg5o/UpDQ2NnwM04DGy/UpRXVxQglaKGmPFy/lHgky8BPvPdwMqp4W3Ht+S2jZQpYJDYGIbUzbcNOtwUQxMbDQ2NnQFq9Zb9NcA2JDZhFvwhEpt//yAACzC7wDNfHt52/Epu+XU4zvVEf44NsD1nfymCJjYaGho7A6Rk9Mv2243YtDe4K2ruO/bPz35leNvxyrEBtt8kc9duPq3YeEETGw0NDRudJvDVjwKn7tnoPVEPurLN9xMbaYEYZrCkZQEP/iVw9AvD2wYgKTYuvothjxuoLwHV8/b/T3xzONsBnMnD/dhupSi3YZ9asfHEjjEPa2hohMDnfh548P8A4weB934HSG0jw33Lw1RLi4XVYwuhm+lWBe74CHDnR4B0HvjFZ4a3HV8lY8jEZuEou80UgG4TqJ5jc6kyefXb8vPY0OyoTkP9dtcbliW9dyWyut2URoXQio2GhgZD5TwjNQCwego4dufG7o9qiKvePiUjW2KDFIHhLfimCXzr99nPvRZw/OvD2Q5gH4Pc0k4YdinqwhPs9tCLGLkBgLWzw9lWqCDCbUBsOnV7irlM4rRi4wlNbDQ0NBjmHnT+//F/2ZDdGBrcrnoB1mEybFPtygnnAjQs70mvy9qcAXtxlzFsxWbxaXa76wpgbB/7ee3McLZFx7DdFRvHFHPpb6o9Np7QxEZDQ4Nh7iHn/6mssF3g5bEBpAV/SJ6M8484/3/q28PZTkciLG6KzbCJTYX7a8b2s38AsDosYuOn2BCx2Q4Jy1IJ1ZG/pBUbL2hio6GhwXCOd7Nc8yZ2S1ff2wVeHhtg+Av+OU5sdl/LbleHlO9CCoWRYiF1/Rh2KYqMwyO7gfED7Oe108PZFh2rmzJFxKbbHM621xNhTO8aDmhio6GhwUCL7zVvZreVue3TLgvYC4BbSuuwic2Fx9nt5a9jt7ULwymT0P5ny86re4I4zmETm9nhKzZhiM12U2xk0P+3S+eXQmhio6Ghwcytq/zKet9zgfIu9vN2Um18FZshtweTgXbvc+2FeBimWlrIcy6LPTD8kptDseHEpjI3nG1R2Y1IjIz1MA+368C//FfgT14/3M4kr/ftdmtpVwhNbDQ0NIDaPJs7Y6SA0b3A9GXs/sVnNna/VCKMx6Y1LGLDF/exfayVHhhOOUqoGC6LPTDcUlS3ZQfJje4BStPs5/qS+m31OizZGHAncdSR1RliKerO3wDu/RPg5DeBo7cPbzuexGbI6tsWhiY2GhoadrlgdC+Qzg7/ansj4NUVBQy3FGWaLM8FYAs+eU+GMUdJLkW5YZiLYe0Cu01l2dgKSsltDIHYyMTMtRS1DgnLJ6SW/VN3D287XsQmuw5zv7YoNLHR0NCwDZ7kixjZzW4r5zZmf1TDNL1HKgDDLdHULnB1wXCaaoei2IQsRXVq6lOWK5K/JpUCinyuEak4KkHEzNMkPeR2b9ME5h+3/78RxIZKUR1NbPqhiY2Ghobtr6FFd3QPu5Xj8bcy2lUAfCH39dgMYZGocC/NyCxTwyjfpTqvflt+hlrALtFYJivnqIRsHAYkxWZZPYkiAudlkhZdUUMiNqsnnST4/KPDK3t5KY3DNrxvYWhio6GhYZeiiNiMcGKzXRQbEXKWthd3GcNcJOgcju5lt8J7sqh+W6IU5UFsZO+N6jINlZxKM/yWKzZmV33WSqCXaMiKzflH2e3u69j7yTKHV7b1VGx0KcoLmthoaGjY6bBUihrlpajtotjQIp4f8WiDHqJiQ91PpNSQkjEMU21QKSqds8dHqM54EROoJ9httghkis7HVCHoOIfd7r30LLvddblNWNed2PD3bLcJmL3hbHuLQhMbDQ0NoLbAbkd4m7dQbLYJsfFLqZXvH5bHBrBLNKTYDMNUG6TYGIZNNpQrNivsloib/LNqEidKUV4ltyErNrIKR8RmaDOxOLHpf+/KydJatXFAExsNDQ178aX8GlJsWqvbY96O32BI+f5hLBC0qBOhGWYpKshjA0hqxrAUG4nYUDlKNYkj83BgKWpIvhc5r2dsyIpNx+O9m86x0iqgiU0fNLHR0NAYJDb5Mfuqdzv4bDaU2HAC40ZshmWq9SrRAMPznzRX2G1hwr5PGIhX1G4rSLEZdrt3RWrfF4rNkIhN2+NY5eGt2yFhWSE0sdHQ2Onode0raiI2hjHcgLX1xkaWoujcUvvzME21QTk2wPA6htwUm6GVogKUqWzB+TzVcCg23Ds1NMXGh6wOO0l6i0ITGw2NnQ5REjH6yghDDFhbb2wmxSZbtBfkoS34HiUaQErlXQ9iM+F8TBU6QaUofn67DfWqGGB7z2TFZtjExo2s6s4oV2hio6Gx00FlqNI0kErb95PCsC0Um83gsZmy7xuWGhaqFDWkOUrCPDxh30fZK23Fw1TFcXr8PWXCo7r7q9Ng3jOAKTYUZjmMXCLA30+kxyq4QhMbDY2djjrviKIyFKE0xORYgmUBf/Zm4DcuAr728eFtR5SiNguxIdKo2EAcqhS1jooNERvVU+KDlKlMcfC5qkD+mkwRKIzbRI48RqrhR1azuhTlBk1sNDR2OqjVuzzjvL84pI4WGecfBZ75EtvGXR8dXh6HUGxCeGxUli46TburhVQawJnKqxJBJRrAWaZRBdO0J1w7iA3PXlFNbASB8zjOdIbNrALUE5uadCFgGE6DtOqyl2X5k1WdPuwKTWw0NHY6REdUH7EprUMp6pkv2z+3K8D5R4aznbClKFhqO0yIFKYyzkh8oWSoTuQNUYoahsemtQoxskLuihoWsRGKjZ8yNaySGyej5EEjYmP11B9ntwVxXv1KUborygFNbDQ0djrcgtWA9VFsnr3D+f8T3xzOdoKIjdxdo/Lql0pNxSln4jEN4iSVQxXaPkZTwjAWfDqObAnISEMph05s/JSpIQURUsmJPi/ZIpDOOx9TBXnf3d67uivKFZrYaGjsdLjljwDro9jQhOTLX89uz9w3nO0EtXunUsNp+XbznQBAfpzdDkux8V3wh6DYNPlx9A9qHBqxCSCqgH2cQxsd4dLWrrq0SCQ7nXca+wlCfRtSEOEWhSY2Gho7HaTYFMad9w9bsWnX7cnXl72G3a6cHNK2QiyEw/Ar0IJf6FvwhWIzrFLUOufYeM0zGlrJLYxiM6SQPiIvjiBC/rPyIMKQwz6HNcV8i0ITGw2NnQ5h+pxw3i8UmyF1RS0fZ7eFcWDvc9nPq6eGs62NIjYtLyVjSAu+V0qtjGHMUfIkNsMyD4dRpoaUsLyeik2QMrUeis3SMeCJz9mm6S0ATWw0NHY6vEpRw/qyJiwfY7eTFwHjB9nPlTmg11G/raB2b/kxlaUoWtDXQ7HpdQCTn7tQIxUULoaCwPkQG6XdZiG8RMMahOlGbOizo9pjE0RURbltiIrN4/8E/N8fBv75vcPbhmJoYqOhsdPhVYqSw9WG0Ya99Cy7nbqYtc6m84BlAmtn1G8rqN1bfmwYpaj1KNHIJZcwQzCVlqI8Sm503GZXrdclknl4Kys2AV1uotw2RMXm5N3s9uDNw9uGYmhio6Gx0yG6PCac98uLlOpSAmCXoiaPMPPu+AH2/5UhlKM2WylqGIoNXd0baTb52QvDWPBFKarvOGUiqfI9RCWaUFPMh+SxkT8vGzXsMzNkxcaygFOc2Bx64XC2MQRoYqOhsdNBHpv+UlQmb7exqvaCAHaCKw0RnODlqGH4bDYbsRmmYpMrO1vL+zGMEo2XMpVKAbkh+Gxo38OU3JR3Ra2w2/WYiRVYihqSKkVYfIYlk6fzwN7rh7ONIUATGw2NnYxu214Q+xUbwFYWhqHYELEZ3cNv9znvVwXTjFiKUuix8eyKGnc+rgJBabyEoSo2o4OPCZ+NShK3yUpRdIyq82SEeThAsRlWKWr+MXa751p2obNFoImNhsZOhmx27FcVAPsLW3VbMgBU+YTkEU5syjQYUvH8pG4DIr113RUbjxLNMPxLYrH3UTGAIbd7+7yHVJHjoDEDhGG0e1uWu9meSPHQur8CFJthlaLI70bm/i0CTWw0NHYyqAyVH3cPABtWW7Jl2cRmlE9HLvGRDqrbSmWikvG5widi01LZFeVRohmGfylMaB0wJMXG4zgBW21QNYE6aMwAYRijIzoNZoQGnH9DQd5UKzYBZHXYig0Rm7H9w/n9Q4ImNhoaOxnCLzDu/viwguQay0CvzX4e4cSGZlXR7CpVoPJAtsw8H14Qio3Cq26vdu9h+JfCZLsAksdGZbu3TymKVJWOIiUsdPfXEEZHCBJqONWiPJUx1zlhediKzSopNprYaGhobBUIWd2D2AjFRvFMI/LRFCft2j0pNvUhKTZBSgaVE9Zj1AAgLYaKlIyopSiVJRovkzSgXrGh/U7n2BRvLwzbSyST5GEYpIEI5uFhKTY8GZwM/lsEmthoaOxkiAybCffHifCo/sKucmJD/hqAZdkAQE2xxyYssRlqicZlwc8q9vSELkUNYYaSlzIFqD+vYYzDju0Og8B5BREOqxTlcayZIbW0E0Qp6sBwfv+QoImNhsZOhleGDWFY5uHqPLslfw0gmYcX1KbUBg3AJKg2m5qm/4KvOuk4bClKPk5V55mO0+0cqy5FtUNk2ADDaff2NIMPyTwcWIoa0qBPgJnaK3PsZ63YaGhobBmELkUpJjZkECaVBrBLUd2m2s6ktpTv4gfVykK7CmFydTXVDkmxCVrwyXBqmerGV9Ax5F2IjfJSVNSS2zq0tROh67XUjgQJKkVlJPKm8mIAAOpL3Cht2D64LQJNbDQ0djICS1HDMg/zieGlafu+XNledFX6bCKXohQtwEQGU1n7uGTQ/qjaXtQFX9W2zZ4UDuim2ChWwoLSeIe1XSC4FAUoDiIMUOGy0vtKtWpDsQuFcX8v0yaEJjYaGmFgWXZr9HaC12RvwrAUG/rSLE7Z9xmG1PKt0GcTZgAmoL6LRi5DuSUBqy5FhfWepHOAwb/6VSyGsuLkdo6VK1MB85MIw2iF9lJs0hJ5HQax8ZzuLZNU1UGELhcfWwSa2GhoBKG2CPz2c4CPHALu+I2N3hu18JrsTRhW8jARm9KU834iWCqnJIdJHQbUly68xgwQlC/4IYmNYag1ndL+G2l3ZUo1YQxtHl5HxQYYTnJ1UCkqnWGKIKCe2Hh9RrcANLHR0AjCo38PrJxkP9/zR0Cvu7H7oxJBpaj8kEpRdY+rQdqPoRCbsIqNqlKUTxqvvD9Kg+vgTi76obJNWCaObsqU2JZixSawFDWEgL5QCcsKiU2UYZ/KS1FasdHQ2L54/J/sn2vzwPG7Nm5fVCOwK2pIOTbiarCf2HATs8opyRvV7k3nzMuYnVVciuqGVDLk56g4Vgql8zq/qgkckbEgAkeP91pqtgsEzMQaQmdU273s9tkHTuMzXz/G/jOMhGXALkUVtWKjobG90GkAx7/Ofj78EnZL/98O8JrsTRiWediL2IhSlEIiFbXdu9tkrdpJse6lqJALPqA2sTaIOKpWwroRiU13CMTGtX2fBmEOYYq5pNi0uj384t8+hA/+82M4tlAbXsu3LkW546677sIb3vAG7Nu3D4Zh4B/+4R8cj1uWhQ9+8IPYt28fisUiXvnKV+LRRx8d5i5paETDwlHA6rGrlqu+j903//jG7pNKNAJUhbzksVHVTmpZG1SKitAtpGLBD1uKUrbg830OQ2xUXuX7tXoD6gkcLeDZsMRGYSt0qCnmCod9upiHTy3V0emx43no9Irkl1LtseFTzDWxcaJWq+H666/HJz7xCdfHf/M3fxMf+9jH8IlPfAL33HMP9uzZg9e85jWoVBQbFTU04oJIzOzVwO6r+X3bhHybpm2G9CI2dGVq9dQtwM1V9vuAwS/NYZSigjpLCKo7TMS5DfLYqOqKCrngA2oNvUGKmGrzcGjFJm//THPJksIviDA3DJP04LDPYwv25/Ch06vDU2y2cClqqM3pt9xyC2655RbXxyzLwq233opf/uVfxpvf/GYAwG233Ybdu3fjL/7iL/Ce97zH9XWtVgutVsvxezQ0hob5x9jt7FWM3ADA8nF29Rm0UG52yAFyXotvtsS6XaweK62oOGaSuLNl5+IDDKcUFdZsmkqxxbLbVEPi/K7ugSEoGaTYhPHYDEGxCRrUqEyZIpN03v95MvHpNoOfHwa+wz5V5/VIfxvpvXt8wX6/PHx6dTijIwBdioqDY8eO4dy5c3jta18r7svn83jFK16Bb3zjG56v+/CHP4zx8XHx7+zZs+uxuxo7FaTY7L6aTZ8uz7L/X3hy4/ZJFUSbbsr76tcwpJZvRT4bKjO5fWGSYqOyFBW2PVh+jooF328AJjAEYsMX/CiKjZKSW0BO0LDa2oMIXDoLgHdpqfLZ+JE4eu8oM0nzbWUKQCot7j6+aJ/HR86uwhrWIMwGL0VtQcVmw4jNuXNsCN7u3c6o5t27d4vH3PCBD3wAq6ur4t++fVtrhoXGFsPiM+x2+jJ2O3URu6X2760MUUIYdW/TJaieF9X08fUIj80wFJswxEbhVbdf5gkwhCGYERSbYXhsAktR66zYGIbTZ6MCvsRG8XF6zP6SiU293UPN5Dk2KkiqDL/P6SbHhndFGX1fqJZlDdwnI5/PY2xsTPzze66GRiKYJrB6mv08cYjdjvMpt6un1mf7w0TYRN48TfhWRDZ8ic0wPDYhRw0AahWbIP/SRplqgfX12NBx9tpqMqDCemwAm/yoUmxCjY5Q5bGhDBvn5/M499iUc0zFWW5zNUe1YtMM8IhtYmwYsdmzZw8ADKgz8/PzAyqOhsaGoDbPMjCMNDC2n903fpDdEuEZFhafAW69DrjtDcMjOFRC8OpmIahu+RahgC4L/jCSh2OVohRcdW/qdu/19NhIhFLFeY1C4FQqNpblfzGg2utCfxupm6/Z6eHsKrv/NVezdXKhSeU2hYpNr2P/Pq9S6ibGhhGbiy66CHv27MEXv/hFcV+73cadd96JF7/4xRu1WxoaNla4KjO2zx4CJxSbIRObv/0xYO00cOwu4LHPDmcbYfNd8orHKoQtRalqDAhrHpafsx4lmo1s91aaYxOg/GXyEF4XlcTG4zjvPHoBH/j7h3FisWYrNirUjG6TTUQH/GdiqSY20nGeWqrDsoDRfAavvIL5/c436NwqVGzki5gtSGyG2hVVrVbx9NNPi/8fO3YMDz74IKampnDo0CH83M/9HH79138dl112GS677DL8+q//OkqlEn74h394mLuloREOKyfYLZWh5J+H6bFZOQXMfcf+/32fAa59i/rthE3kVW4e9iE2pG5YJlsgVHRhbZR5OGhYo9zubVn+PqcgmD27pTnMcWYUGk6DiI1hsMfaVTXqlIfH5un5Kj70L4/hrqMXAAAj+TR+WaViI++7G0lWnVwtlCm51Zvtw5GZMp5zgH1+ztbAJAqlM7H4ZzRb3nKTvYEhE5t7770Xr3rVq8T/3/e+9wEA3va2t+Ezn/kMfvEXfxGNRgM/9VM/heXlZdx88834whe+gNFRD+lWQ2M9QT4aKj8B66PYHP8au80U2RX12e8kX/jcENSOTFhP83CuDHZ1b7FSWVJiY5rSAhFFsVE4HDIb0C1k8X0MQ0i8IHtIInlPVBA4Kpn4/K2yJUZsVJxXD5P0u//sXjx7wSYf59Zaaj02ROCyJUeXkoDqrigXAndikf3uw9MlHJkuYzSfQbWXZcRGZY7NFvbXAEMuRb3yla+EZVkD/z7zmc8AYMbhD37wg5ibm0Oz2cSdd96Ja6+9dpi7pKERHkReiMwAttemsaTuC6wfRGxueieQzrGrp+Xj6rcTVrFRPbXYb4yDYajdnrxwbzbFRiZaSd9L8qIW5ThVLPhhFDE6Byo+My4LvmlaOMkX/Xe//GIAwIVKU63HJtBLNKxSlKTY8I6oi2bKSKUMXLt/HE0r53y+CgSlZm9ybHhXlIbGpkX1PLsd3WPfVxi3vyxr88PZ7rmH2O3hFwO7r2E/zz2ofjuhPTaKh/sFtZGK7SlQiOQv+1DBdYoMoL2uVBryIDaptL1PSUkcHWcq664m9ENlu3cYD5PKRd9l2Odas4OuyTxZL7l0BgAwX5EVm/UgNkMqRUkEjsL5jkyzfTgyU0YLOefzVSAoNXuTQxMbDQ0vVFmtHiOz9n2GYf+/OgRiY5rAIvelzVwB7HkO+/n8EMY4iKuyAGIjhvupUmxW2K0nsaGZOwq2RwtppsCShYOgyjzckfwYfoqYqs6oKC3QgKTYKFgMw3RjqewYclFsFqrsvrFCBvsn2LYuVFpqB2GGHh2hOHBROq9Uijoyw7Y1VsygiSEoNkHhkpscmthoaHiBFJvyrPP+kd3Ox1Vi7Qz78k9lgcnDww0EDOraIQgFRXUpyivfRWEpKopxWH5e0kWCSi5GmpUTvSBKNAkXQ3GcIYmNym6hMIqN0lLUIJG6UGHq2MxIHrNj7NgqzS566XVUbFTPiupTbORWb1JsxgpZuxQ1DMUmyH+3SaGJjYaGF2ouig0wXGKzcJTdTl3MIuHJuDwUYhOyFDU0j01QKUpB6StKq7f8vKTKgjx408/0Tec26VW+WARDEjh6nkrzsB95FKUoBWqGi0K0WGPqxsxIHqP5DPIZtrQ1LUrlVaHYrHcpikZksN97klq9CxlMlRmZGS9mh6vY6FKUhsY2QrtmL+QDxGaIpaiFp9jtDB/hMHGY3a4MIek4rHl4vRUblbk5G6bYSB00flBdigqr2GQVlmiimIdVLL4uis1ChROb0RwMwxCqTcPKOF+TBEFt7VlJfVORwSRyidixyP4aStwfK2bRBCdvSs3D/DOqS1EaGtsIRFoyxUFFY5iKDXU/TV/Cbie4YlM5y9JAVSJsu7fw2KggGk17kVmXUlSEOVGAOsWGSi5eHVH920tcivL3uaw1O/jwvz3OQusAKcdmvczDio6z12WT5oE+j41digKAXfy23iNio1KxCfDYwFKzvT6PzXKdHeOuUfu4xwoZNKCw3EYQis3WmxMFaGKjoeEOIjYjs4OlhGEqNv3ZOeVZ5tGwTGBN8ST7yF1RCoiG6HQyvK8GVW4vypwoQJ1i4zHnZwCCxCVVbPxVk09/7Tj+953P4jc/z6fSq+oW6nVsouGnFqkijB7t+2Qeni6z45odZftS7fEOsfXsigIUJyzbniGAlaIIY8XscNq9w343bFJoYqOh4YaaRGz6QYpNxXsKfWz0E5tUys7RUe2zCV2KUtgVJeZEjXl3KYmuqI0oRSkqmYRVbFSVojrORbAfj55lpYX7TiyzO5QROGkBXw/zsKyEpF0Um1G2yJOqUekOQbHxOs50lpn+AcXdX+xvteZGbArZ4bR7tyWP2BaEJjYaGm6gMhORGBkllpOB+qL67fqFAqoufYUdgklXbd1m8unMQf4aeXtKSl+bwDzsB2UeG/c0XsLj55hSdm6tibnVhro2aCJGRsq/+0uVeZgW73TOQYxJsaFS1CwnNqudlPN1SRBG/VPpJRIBfaTYsFL0aCErnsLavdn/LZUjFYL8RJscmthoaLiBMmzKuwYfK02z28ay2m226zZZkokN7YNqYhO63Vvy4CQlG2GIjdIcm40yDwdc3RPkeVFJ0PE2D1eaHZxaso/n/hMrziGYSYyuMnH07f5SlQ/k3v3VT2xIsVnpUClKpUl6HUpuwIDHZq3BLirGZGIjt3urHIIZlphvUmhio6HhBl/FZordttaAblvdNtfOsNvcqHPhH4anx7JskhJEbNJZW/ZPSjZEON+E93Nyw2j3jliKSlwaiqjYJPaeeLd7P3HOeR4fOLlsl6wsM5kpPSxxzKoqRQ2W3CzLkogNW+SpK2qppVCxCVDFAKidF9XX/WUrNnYpqpBNo8cfN3otFvCpAmHL1JsUmthoaLhBZNi4KDaFcSa9A2xmlCoIf80B59UvKTa0TyrQabBFDQguRcnPSaosRFFslAb0rbN5uB2yBLYO7d6Pz7EyVDbN3lP3n1x2Ls5Jsmw8FJQBqErldUnjrbd7aHbYe9nuimKPL7UM5+uSQKhiYfJ6FCo2WSI2gx4bAMjlJfKhymcj3r+a2GhobB/4KTapNFCcZD/XFRKbistsKnkfVCo28kIa5ssrp6hTKRSxGUZX1DqXojohr3iFkqFoVpQLwSBi89pr2PvqkbNraCEDNkUdyRb9sIqYMvPwYDmI1JpiNo1yni36pNgsqlRswhyrypA+oRBxYtNiio1cigKAXFEizz0FBA7QHhsNjW0JIhH94xQI5LNRaSD2IlOiFKXQY0NlqGw53AylvKIsm1ClKJW5OQnMw0m8J5EVG/UlGsLjc+w8vv6aPZgq59DumnhsrqJmEGbUUpSyktvgnKjpEdu8PF3OwTCAhqmwKyrMPK4hzsTyUmxGSwV0rZTzNUkRNJl+k0MTGw2NfliWlGPjUooCgCL32agkNl4jHIZRiopaQ19XxWYj273586xeQu9JxIC+xAqR+3H2TAtPco/NVXvH8LyDEwCAB06uqMmyCUscVR2nSymqP5wPADLpFKbLObQolXfduqJUlqL6PTZEbJyKDWv5VnicZk8qbWrFRkNje6BdtWXgzaTY1C6oMweGbfUmrKvHRmUpKqZiI782DkRXVMhSlDIlw6kmnFisodHpoZBN4aKZMp53aAIA99moKJuEVmwUqEPy6zODpSiZ2ND/7YwXhYqNb1eUylKUrdhYliXMw2NFp2IzVpSJjcK8HkCXojQ0tg1IrcmWvBd+6oxSaR4WxKZfseH/N7t2KScpwrZ6E5QrNj4zaGhbZkddzkpYxSadZRO55dfG2m5YxUbRQth1N7ZSGeqK3aNIpww8/xDzhjHFRkGWTUDisQARuKRDN90UmwqNGnDm6OwazaNlDUGxCdMVpUKxkbbX7Jjo9FhpdFCxyagN6aN9N1KegY+bHZrYaGj0g9JxqdzkBqHYqCQ2HmnHmZztO1GVnRO21ZuQVxSaJ+ZThSA28vPjIiqxMQw1KkpYj42yUpS7YkPG4av2svN9xR72Pjqz0oAliM06KDbCz5Nw4fXz2JSdi/DsaGFIpSg/xUaRZwpwKDak1qQMoJxLO542VsxKBE7xTCy/bKJNDE1sNDT60eTkoTjh/ZzSEDw2gti4dGJRF5YqYhO1FJVTFJoXZrvpjL3gJyY2EUtRgKISTdiuKNrWcGZF9ROb8aJ9td9NcSKQhGyE7YpSFQjookwt1pwZNoRdo3m1xMZDFXNAlQJnWY7yIo1TGMlnxGRvwlghizZUTjEPGS65iaGJjYZGP8Q8ownv56hWbLptu6zl5uspck+KMsUmonlYlccm9ERxRduLqtjIz02yOIXuilKt2DhVi+N8mvels+x8ZtIpjPGuGkFslCg2IUtuQLLF102xqdCcqH7FJq/Oe2JZNonzLUUp8kz1OgA4AZQUm/4yFMA8N0Px2GxRfw2giY2GxiDIx+Kr2Cg2D1PHUypjqzMyhGKzomZ7UUtRqjw2YrsBxEaVgTiWYqNgcYrcFZWwvdwjFXe1wRbEqbKtZkzyn9uGAmNt6FKUPPk6AZFy7YpyNw8zj40i70mvYwda+pWicqrM4M4p5l6t3sAQBmEKtVErNhoa2wdhFBvV7d5kHC7PuufKqC5F0VVZkHJCUOGxsSxJsQk5n2q9PTbycxMpNmG7ohQpGS6zoizLwkqdEZvJkk1sJvjPTVoMlXRFBSyC6Yw0+VrB9lyJjbMU5VBseu1kHYUOouFzrKrMw44p5jlBbMaKborNED02WxSa2Gho9COSYqOoFOU3wgEYnscmdI6NAo+NY4xDUClKUUhfiIXXsix86fHz+MqT887nrodio0zJGBxtUGv30DWZCjRRshfESf6zko4hF6LhCeGzSVKKcio2rW5P+E/6FZspOccGSJbKK3xIRsAUc1V5PZIZ3DDsVm9XxSaj1ksUtoy6iTF4ljQ0djpCeWy4YtOuMH9MxufLLgz8RjgAQ1BsiNisY46N/NogJUN5KcpdsVmstvDLn30En3/0HLJpA/f999dgLKliEyXgLJ1hC2Wvza6USz6deH5wyVhZrjHvST6TQiFrd9KQelO3VCgoEYaMZgpscGwSwtiX17PIw/kyKcNhjAaAcj7jJDbdZjTlToZ8nH6dQsqGfTpTh9d8PTZZnFNKbOi7YesSG63YaGj0I4xiU5hQOwjTK8OGMDRiEzV5OIGC0pL8NUFjHFRsr9dh2T+A64I2v9bE63/7q/j8o+cAAJ2ehRML9eTlBEfAWYjFQcVVvsswSvLXyGqN/P+6qaB8EWXIqDivCszDnMDJ4xT6u4VGChl0kUbPUjATK0xHFDCEwEW2PT+PzbgU0GcmbacHJLVRl6I0NLYPwig2qZQ0CFOBz8av1VveF1UBfaLtOqLHJomCEtZfA6iZ8C0vLi4L778+PIcLlRYOThVxeJo9fnKpnpxoiO0aIUs0ChZDYR62yzHkr5koOtVEUmxqgtisQ46N/Jwk2+tTbJZdPESEco4N+lRirA0TzgcoHKLq7P7yIzajhYwwSbebChKPt0EpShMbjfh4+kvAn7weuO8zG70nahFGsQHUdkYFDd0clnk4dFeUAs9LK0InVl6BYkOLi5Fy9UXMrbLF4zVX7REzlBixSbg4ye2yYQLOVJS+em3n7wKw0mD3jfcpNuSxqXQpYTmJghJBsVEydNNJbGotbqp1KdGkUwaK2bSaVugw4XyAwq4o53H6laLymTS6Kfb+bjUVBANu8cnegPbYaMTF0jHg/7wFgAWc+jaw97nAvudu8E4pQoNi/yf8nzcMYrNZS1GyYmNZ8RJJ2xFUIkGkEgTXya3eLvt7lhObveMFjOTZIn9yqQ6UEi5OSSaKx4GsREgKka3Y9Jei2CK41qVQNxWKTRRlSp1iU+VKRjmfdn36SCGDVluB/8SjnX4AykpR4SZ7C2TygAm0VRAbUYrausRGKzYa8fCdv4QIkLJ6wLc/taG7oxRhFRtq+VZBNtbbYxO1FEUqi9WLv0BESTumL9VExMa/TDK3wh7fO1HAwSm2IJ1SotiE7IgiJL3Kl5WIbLDHhso2q6TYJFIyIpA4FYMw+xb8aouIjfuCP5LPqGmF7oT12PDHE5uHnduzu6IGFRsAguh12ipKUTqgT2On4qG/ZrfP/RF2+8yXkgWMhYFpAse/Dpx/bIjb6LHODSBYsREeGwXmYTIgkwrkta3GsprzHNc8DMT32dB59ZsTJba3DsRGKDZFHJqSPTYJzcMUcBbUEUVISqTodakskLKVi5U6K0X1+0+I6Ky0M8m2K782VFeUCo+Nc3tUivJSMsr5tJpW6DCTvQHnMaoYHRFSsUll2fN6LT1SAdDERiMO1s4Cy8eYd+E1/4N9mCtzwPwQCQcAfPY9wGe+G/jUq1gpbBig6dNACI+NIhXF7AUP3iRiY3aTLfaEqO3eqZQ04C+m7yXKNlWMVPBRE3qmhfNrbBHYN1HAIW4ePrPSQC+zzoqNqlJUH7mgUtSAx4YnD6+0qVtIgal23bqiPBSbnI9io8RjE2KcAuAkPiq6sEJ4bAAgxc9tL6lpGdCKjcYOxalvs9vd1wDlGeDQzc77h4FzjwAPc5Wo2wS+9KHhbIdISrYMpD1kX4KqMQfNVYiynts4BYAtCmSATUqkum3bbBp2CKb83NiKTcg5UYCk2CQMBARc1YSFagtd00I6ZWB2tIDdowXk0in0TAur3YRKRlSPgirFpm9O1ErDqyuKva9rpsrk4TBdUVSKUpdjQ8RmxEPJGMln7IRlJcnOEUZHKOn+cio2bgF9AJDOse2abZXt3prYaOwknL6H3R7khGbPdez2/CPD2+a9f8JuJw6z26O380FxihHWXwOo871QKSs36h30ZxjqtieThShZFUlVlHX32HgrNme5v2b3aB7plIFUysCBKbY4LDTTztdHRdhxCoSkpS+X1GHALkX1e2yK2TRymRSaSZWMXgcw+WcwSlu7CoLRT2yG7bHxmJ4+gHTWzrdSokwVYVmWVIpyv9jK5Nn5MPV0bwCa2GjEwdkH2O3+G9ntbiI2jw5vm898id3e8husXNOpAWcfVL+dMBk2BGEeTuixIaLipdaI7akiNvyLK50PVqVkJFVsogzeFCRqOB4b4a+ZsB8jn835Ji1MSRWbsKUoInFxPT3unUleXVGGYWCylJWUjIRKEbB+7d59ik0twDzM0odV5tgEEDjDUOMlklS4RqeHHh+N4eWxyeQUlPkIelaUxo6DZQHzj7Ofd1/Nbvdcy27PPzocA/HyCWD5OJt8feSlwJGXsPuP36V+Wxuh2Ajj8HoRm5g5FUmzbEQpKop5WIXHZpDYkGKzd9xeqIjYzNUN5+ujImrAWdJSlMvEa8AuRfV7bABmKBaTr+MuhmJ/jYEymCtUhNd5tEH7KjYqzMNxggiVKDYFcYzplIFSzr2tPV9g7zUjyTwsgiA2WrHR2CmozrOF2EgBM5ez+2YuZx0ZrTVg9bT6bR7/KrvdfwPzZxx8Ifv/3HfUbyuSYqO4FOVlHO7fXtL04SglIRmJPTYb1e49+AVNis0+F8XmDB1ebMUmovkysXl4cNG1LAurpNi4pPJOlLJSKSousfHPCRpA0iGYljXYFdWOQmzWYaSC/BxFHpuKMA5nBsZGEHIqiY322GjsOFzgas3kEfsDnM4Ck9z7svSs+m2euZ/dkqdn15V8X55Uv60oig0NLKwvJVOqhGITktgoU2xCZtgQknpsogT0EfnptZnZOQ58S1GDio3IsiFBKmlX1HopNn3x+wDQ6PTQ7rFJ6v2lKIApNolNtVEWe8Au0cQ9zp70PuDHWmv1AHibh8sOj806jFQApJKbGsVmLSicD0CBE5tUUmJjWdE9YpsQmthoRMP8E+x211XO+6cuZrfDIDZzD7JbSjbexZWixWeAXlfttuIoNmYnmbIQVrGhfdqoUpSqrqgwtXv5S7UT89z6moft1GECKTbH10zn6yNvN6KUL4hNzON0ScUlf00unXItX0zIxCZ2KSoqgUvosXFJWKYyzfDbvaMkLPPnKMnrKWCNlxRH895+uHyR/Q0yZsyLAEKnAdGhqUtRGjsGS8+w25nLnPcPi9j0OqzVG2BjGwBg7AD7MjU7LE9HJaIoNtmSmhbsjTIPB5SEfu8rT+P9f/MdtLt8oReKTVyPTQTFJpOzz21c0hhKsbEfI8VmXnRFJVVswoYflpNtT7QiD45TGC9lXcsXU+WspGQkNA+HWewBqSsq4XHCEO+NoIC+kYIi83DYrihAUqbUemz8FJtcgW0zYyUlNv6DY7cKNLHRiAYiLtOXOO+fusT5uCosPAX0WsxwOnkRuy+VsomV6nJUFMXG0YKdoDMqdCmK71NSYiOUE++Ft9rq4qNfeBJ/e99p3P7oOXYnEZLEycNhxzgk9Nl4mIc7PRPzFbZw7J2wF+WRfAYzIzk0LKlbyDTjbzeyYhNXyXBRbPgATLcyFNBXijK78ZTPKIZaIHlXlNwRZRjo9kw0OqwU5d8Vxc9BEqIhyn0R8npUJB07iI23YkMem6yVMAKD1NxM0ZFivdWgiY1GNBBxIZJBGJZis8CJy64rGaEhTF/KbpePq91eFMUGUDMvKnQpapzdNtfibwsI5bG5/8QyeIcp/uLuk/z5CTw2lhU97Tipp8fDPHx+rQnLArJpAzNlZzfPwakS6pDui6MuRM0BSWwe5lf3LopNf4YNwVGKAuItwpFLUaq6v7i/pt0TD3kOwVTtsQmjTgnFJkkQoX2s9pwob8UmL4hNQsWmvfWNw4AmNhpR0OsAK3yRIyJDIPPwykm1Ld8LT7Hb/tLX+AF2u3pK3baAaIoNoKY8FFaxIWLTSkpsgktR9x63FahvPruIZy9Uk3lsui2mDADrqNi4KwrneEfUnvECUilnmWbfRNG54MdZhDcseXjQYzNeHOyIAlj6sFAygJjEJqJ5OGlXlMecqFw6hXzGh9go6YqKYB4WXiI1ZmWROuyhvgFAgXts8ujASvL9G5WsblJoYqMRHqun2OKUKQCje52Pje1nt+2qc95SUngSm4PsdkUxsYms2CgYhCnmRAV4bCj/Jen5bQWbh7/NiU0hy74i/vLbJ5MpKC3JlxNasVFVinJ+SZ+Vhl/2Y6qUg4UUuqm883dEQVzFJm5AX1/8PiCVonwUGwsptJFgfETURTBpV5TnZG/vkomyIZhRSJySYZ+Dio1vVxQRG6ODVqfn+bxARPVNbVJoYqMRHjR4cvKIsywEMD8BTaZWmWWzcJTdTvcRm4lDfFuqFRtOGsIqNioGYYpSVACxEaWohMQmoCTU7pp48NQKAOC/fhfrQPvb+06jneZEoxXDPEyG42x58L3jhSEpNnM8nG/f+OCXN81RahtEbOKUoqIqNglLUS7HueqROkyg42xaCYy1YdN4CYlLUdHmRAGsk4jMw2YiBcU77HEAKhQbV4+N93EWCza5bDTUzeLaqtDERiM8iLAQqegHqTZrZ9Rsz7KAxafZz16KjUpiY/aAFicNURWbuMSm27LbfMOWopprycp9AcTmkbOraHZMTJayeMdLL8Le8QKW6x18e67tfH0URBmASUjssXFXFNzGKRDGeZhd0+Bf7HFIVSeqYqN2wQeCPTaTdJxJOoaiLPZAclNt/5yogFZvgCs23GPTSzIgMsqCr1ixWQthHs7kFRGbqIbwTQpNbDTCg4gN+Vv6oZpsVObYomakB83KtA+N5fhdOv2QlZD18tiQWmOkgPy4/3OJ2JidZLH0AQnA5K+58cgUsukUbrmWlR0fXeg5X69wm64YkmJzNoRiY2e8JFFsYpiH4xBWl+O0S1HuHpuxYhaGATStBB1DPsnOrpBNtXGO02NOlFfqMABk0ilYvDW8p2SKeYhjVanYZIuo83Rlr3EKAIBUBj0wv1irmSBTSys2GjsOgcRmv/N5SUH+mskjg1OvC2P2Qq9qe+SvyZa8p2z3I2lXlJxhE1SiyZUZyQOSlaMChtx9+xjbp5uOMNJ2eJon8tb4tuMoKFFShwlDIjaLNbbo7xodnG9ECkfdilmKMk3J5BrRPAwrnsHVZVZUkGKTThkYL2aljJcYi37U5GF6nmWyRoTI2+ubExWiFAUABicalhKisV6Kje2bou4vP2UKhoE2/1s2tWKjiY1GBJASQ8pMP0SnkqJSFPlraCZVP0b2sNvavJrtRe2IApIrNo2Q/hqA5eYUuIE4SWeUz5Rt07Rw3wm2TzcdYaSN5ikdr/AOonY1er5LlNRhwpBKUas8ydWty4QUjrpQMiIuEvLzoyo2cbYHuIbH0TFOeHRFAZRlk0SxidnuDcQkUu5dUV4ZNoQUn3xtxS2BmaZENNbfY9MIo9gAgti0mipKYFqx0dgpCFRsDjiflxTCX3Op++Mjs+y2qojYRO2IAtSVooIybAgqDMQ+7d7PXKhiud5BIZvCNfvYtvZzYvPsqvR1ETX+P8pkb8KQFBta9MfdiA2/r9qLWYqSiUmYRRAA0hk7ZTkOsXGZFRWk2NBjyTw2ETto0jkANDk9DrHpy7Gh1OEAYpMW3p6Y7d7yuQk1UiFhwjLgONY6V2yKAcSma7C/daeZxDysFRuNnQTTtE3BXsRmTDGxCVRsiNicV7O9OIqNPAgz1jZDZtgQVLR8+7R7Hz3PHrt67xhyGfb1sH+SfcmdrQOWkXL+jtDbJGITw2MTx9NjWZKi4DxOP2JDptqKSUQjIqmSW73Ddn8ByQzELhkry3VWbnM7RsJoIZuwKyqiYmMYkp8oQemLH2clpGKT5oqNoYLYrMcQTMtyHCsRm6Dj7PCIgnYriZdIe2w0dhJqF9h0XSM1mGFDIMJTOcs6jJKCUoX7jcOEkd3sVhWxSarYxDFEbohi490VNV8ZzHgZK2S4QdOAmY1ZHoqaOgxIik2cQED5Kts+lmanJ2ZfuS36ZKptxDUPxw04S9Ly3TcrqtnpocWP0U+xGXWMG4iTYxPj6j7JIMw+ZSpsKSqb58Qm7uRr+pukskxd60O3Z+I3P/8E7jp6gW8wocem12E+JIArNuw4i1l/xaaXYu9ZJYqNJjYaOwKkwozuBdIeX5aje5i51ewmJxumaYfvUapxP4RicyHZtghJPDZxJ3yHHYBJSEpszJ79Re1i5KUZSrKx1jAMUY7qZPgCHDXLJsoATILw2MRpuZYWFRfvSTpluHbTpFMGxgpZNIR5OOIiEbUjqn8fFSgZVIbKeBwjoZxPKypFRSE2Cco0/Tk2zXClKCI2qdjExt8k/aUn5vH7dzyDX/6Hhx37F1uxkf4WvXQezQ4jOUEeGyI23SRt7S4DVbciNLHRCIcg4zDAhqaN7ePPT2ggrp5jZCGVAUb3uT+nrLgUFUexcUz4jlGOEqWodSI2MklwKUWdX2NfbLNjzo6hfXxYZMuglNyopSgagLlO7d5ESNJ5xzA/YRwuZFynXgN93pPIig2VoiLO2skmONa+jh251OZ1jAANiFRBbCKQuCSLft9xVlvhSjTZAju3aTNuKcqfwD10egUAcGqpgcVqS8rrSZiwDKBh2scWdJw9XorqtpN4eyKMjtjE2HBi88EPfhCGYTj+7dmzZ6N3S6MfQcZhgqoZTjSTamy/q/wLQCpFbWBXlGEka/muk2KzTqUoWjiNtKvcfIErNrOjzsfIZ1M3+BdeVN+LaPdeJ/NwDOMwYaKUswdhRiU2cYcIJlFs+iZPV1vsGIPaoEfzGdtjkyTHJkrZIkkpyivHJuA4CzyVN21145XIA3wnD5+xOxQfOrMq5fUkVGwyBdT5eATDAPIZ/+XaTLP3bKIgQq3YqMM111yDubk58e/hhx/e6F3S6EdYYkPpw0kNxERsvFKOAbsUpardO45iAyTrjIpqHk46CFP2urhczc+vEbFxKjb7J9jiUDEpkTemeTiSx2Y03rYA71bveghiU5RKUVFJVWcjSlFEMGiGUojcE5BiQ3OU1mFWlPzcRKUo56yoEZ9ZUQCQk8YNxOqM8klYtiwLj5yxLzIeOrWaPGFZOs4GNw6Xsmlf9Q0ALE5szCRBhFHa2jcx/N/564RMJhNapWm1Wmi17DdnokmmWx3P3gnc+8fARa8AbvixaF0YUSFKUUGKDSc2lblk21s5wW4nPPw1gERsLrArsZT/F1wg4ig2QLJBmI2Iik3SriihnLgTDDIPe5WiVnr8/tgem/UqRbkrNis+GTaEyVI2vnm4HbcUFdM8bPaYqR9wyXfx/zyU8xmsQYFiE8Vjk6QU1adM2cnD3n9LACgUJPWh24xOOn2CCM+uNrHEAx8BXpa6jv/tFYzIqHGSWgooQwEQCcumitERWrFJjqeeegr79u3DRRddhB/6oR/Cs88+6/ncD3/4wxgfHxf/zp49u457uonw9JeAP/1+4LF/BD73PuBbvzfc7QnFxsdjA6ibFxVGsSnNADBYB0F9Mdn2gEiKzUq9jb++9xRW6m1bbYlViooQ0AckL0W1vLuT2l0Ty1zR6C9FHeClqMUOXwjjdkWtV/JwQDhfUCmqKUpRMQP61kuxcbQiO4dDBnkyRuRSVBx1QXhPoig20liFyNtzKjaVkARupFRAx+LPiaXYePtOHj7NPodUJvrO6VVYgrwln2Le6IQL52PP5wnLiaaYa4+NEtx888340z/9U9x+++341Kc+hXPnzuHFL34xFhfdF6oPfOADWF1dFf/27fMwlm4UqvNA5dxwt9FtMzIDCyLw6isfTjZhOghrnECOebR6E1SZh5dJsfEhNukMUJ5hP6vw2YRUbL7xzAJef+tX8Yt/+xA+9sWjNhGKev4tK34pqpm0FDWoKFyosi/UbNoQM5MIVIpa6PD7I+fY8P3NxeiK6jaieyMSeWyyaFhJFZuIxIaIUNTcHHmhjpjIO5LP2MnD69YVRa3QcYiUMxU3zKwooL/kpjaIkMpQr792DzIpAwvVFs43+Hdyt5F4JhYpNkGt3gBgZBnhUzI6IpP3f94mx4YTm1tuuQVvectbcN111+G7vuu78LnPfQ4AcNttt7k+P5/PY2xsTPwLqjuuK07fC/zO84GPXQ189WPD284T/8wyXkZ2A///k8DMFewL8cnPD2d7vS4r9wDeGTYEIjZrCZW0MIoNoDbLJoRi86ffPI7/9Ed34xzvHvra0wvxPTatCmuNB9bfPOxSEprnx7RrJD/wudo1mkcmZaBqxfXYJFBsgBheF/dFdy0MsSlmUUfMq+5OXPNwzOA6en4qK0qxYsEP5bGJSeB63YESWChkFCg22QJ6piWC64KIzYiD2MSZxeWj2HBic+PhSVy+m723H5nn24g7E0syK4cN5wMAg5SiuEGEgJ4VNSyUy2Vcd911eOqppzZ6V6LB7AF/9042h8fqAV/5n/birBr3fprd3vBjbHbQNW9k/3/8n4azvdo8AIt10pRm/J9LpajqOfblFwdmzy59BRGb8i6+vYSKjWnaKoiHYmNZFn7735+CZQFvfO4+GAbw7IUaqinue4lKbEityRTCly4KCT02PiZekWEzNnhlmk4Z2DtRQNWirqioHpsYycOZvD30Myqx8VBOwig2k+Wc1O4ddbtxA/oSlqKkhShsGzRTbGKWomTzb6yAvgTt3pkCam37uyXMcSZTbNw9NrJx+Nr947j+ILvoePCcRCwS5vVEKUWl+Lk1empmVG1lbDpi02q18Pjjj2Pv3gBlYLPh6O1MRSlMAPuez67E7/7f6rdTnQeOf439/LwfYbdXfg+7ffZONYm//aDS2sjuYINyeRfLnrHM+CpKRc6wCXgfqFJsWqtgpT14KjYXqi0s1tpIGcBH3vIcXLWHkYxnqpRjE5XYRAznAxR0RXlP9p4Xrd7uMvS+8SJqiKHYdFvs7+mxXU8YRvyQvgSlqHG5Kypujk1kj01M87DwRNh/s1rIbqGRQgZNK+aCL5+XSO3earqi6BizaSOwDbqcz6BlKVBs+kpRc6tNLNbayKQMXLV3DM85MAEAeOBMHfZMrCQELm+bh8MQmxyV+ZIoNv5hhFsFG05s3v/+9+POO+/EsWPHcPfdd+P/+X/+H6ytreFtb3vbRu9aNHznL9nt838UeOl/ZT8fvV39dp78NwAWsO95wAQ38u6+li0AnRpw4Un12yRiMxqicy2VtslI3HJUmAwbgtwZlQTkr8kUPevLT8wx1eHIdBmFbBovvHgaAPDoMv8YRSU2UccpADax6dSZ1yoqfLqiLlA4nwex2T8pEZsoHhv5uVFKUUD8sQoJzMOTpVyCrij3+VSBoIWkHZHYuLTnhvXYyMnDkX0Zcjifix3Asix88o5n8PlH+vyGSYy1UlcUpQ6X895Bi4QRRxBhgtERfaUoKkNdtnsUhWwazznAPpsPnVmzDcSxCJztJRLt3gFlRcBWbGInLAN6pIIqnD59Gm9961txxRVX4M1vfjNyuRy+9a1v4fBhnzbfzYZeB3jmK+zna94EXPRyJqEvPqW+HEVk6Yrvse9LpRnRAYAz96rdHsDKSkA4YgNIPpuYBmJqLQ8qQwHqBmGG8Nc8eY4Rmyv3ssX55osZIbnvAv9ijdruTUQorHEYcAbcxVFtRClqcOGd9wjnIxyYKMYrRdF+ZkvRW/LjdkYlNA/X43ZFtTdIsZHUhChdUVSiiZx9EuDFeOTMGn7j80/gZ/7ifjx1XnqvJMrrsRd8cYwhFnz5OHtxUnk9jpXKUNftZ5/Jy3ePIp9JodLswlSUsBx2sjcAZLhikzZjXPCIbfNzrBWbZPi///f/4uzZs2i32zhz5gz+7u/+DldfffVG71Y0nPwW89aUdwF7n8cWxwM3sseO3aVuO6YJnPg6+/mSVzkf2/98dnt6CMQmimIDJDcQEyEiv44fVJWiQnREPcGJzRW72RfZzRdNwTCAx5b5l05sxSZCKSqVtjuL4vhsxMLrPSeqP8OGsG8iZikqTqs3ITaxcQ9VWw2RYyO3e1tRFZTYIxVimof7OoUACP9JkKm2mE2jTYpN1AU/IJzvmQvsb941LfzqPz1q540l6oqySzREbEYDUocBRvBImWo2kpiWne+l44vsd5FpOJtOYe84+zv0UkkUG9k8TAQuBLHJs23GHh0BxEuT3oTYcGKzLXD8q+z2klfbHpSDL2C3Zx9Qt535x5iykC0De693Pkb/n39c3fYIwmMTltgkzLIJ21oOACVWDkItYY5NCMXmiXNMebhiD/simyjlcOWeMaxYvKwTdcJ3HI8NkKwzyqfdW4Tz+ZSi4ik2MVKHCcJjE7UU5Z6xEkaxGZVKF0a3wS4owmK9h2C6zDEKax42DAMGv8qPnH0SsAAeW7CJ6DeeWcTnHp5zPj/JSIVsMXS5DQBymRQ6XLFpxZl87XGsK3WmjEyWcuK+yTKfsJ0ixS8ZgbMVm+DjzOTZey4TV7Exe7YXTis2Gjh1N7s99EL7vr3PZbdnH1S3nRPfYLcHXzA4YXvmcna7cDRedoIf1l2xIWITQrGhHJv6QrxtEQIUm27PxFPzbHG9co+tPNx80RRWwEmC2Ym2AEfNsCEk6Yzybff2L0XNjhbiKTZxWr0JCktRzU4P7S4jKeMlb2KTShnIFaXzE2XRjzNmQH5+5FLUYBdLPWRwHQCk4hKqgFLUiUX299rDO+x+7V8eZ+pDXGUKcCz4lWY4VYpAAyLbSYhNf4o1D7OcLNvvJSI5HSOBp0dS4ert8ObhHCepWauNbi8CGSc4DOE6x2Znw+zZ5Z+DN9v3E7E5/0j8tud+nL1/cDuE6UsBGEx5qCVc5PtB4xHWi9iI7YVRbIjYLCYjdAGKzfHFOtpdE8VsGoem7EXrhRdPo4E82tROGqUcFcc8DCRTbDzUk55pYaHqX4qaKudQA7/Cj2IeblOrdxJik9w8TGpNygjOeCkWJUUryiIsSn1xh2BGNQ8Pqglhg+sA25dhRFZs/AncMV6m+f/dcgV2j+Vxbq2Je44vx5+jZJp2bk6mEOkYAaCXTkBsPEpRy1yxmZAUmwlOmFtEbBK2tUcpRWULbP/yRkcMz4y1XUAnD+94XHiCfenmRoFdV9r3T13M7us2mYlYBUj9IaOwjGzRNtsuKO6MIv9KaGJDpaikik2IVGlSbMyuTU7iIECxoTLU5XtGkUrZXRjPPzQBwMCyxReyKMQmtmKToOVbHoIpYbHagmmxBpfpcs7lhWyGEgX0Gb1W+PCxRKWouMRm8Cpb9tfIf0M3jJULdit0FLIRV7Gh44yr2MQwDwNAmpcvUlGzT3zmJwG2YnPF7jFcyWMRzq814wf09Y2OqIngunBmdFJsurHMw3xfMx6KjURspvjP9qiKJN1fhUilqGyeExt0RDdVtO3yfU3nhjt3cB2wtfd+M+DcI+x2z3XOjo9UCtgllYeSol2zCcu+57o/Z9cV7FZly3eva4ffhfbYcEJSORvNnyC2d975e/yQydtG2CQ+mwDFRnRE7XaqDrtG8yhkU7bPJkpnVFzFJskgTI9SFBmHp8t5ZNLuXwuZdAqZonT8YX02iUpRcXNsBs3DYfw1BNbyHaMzaqM8NnzRtSxLLPph1IwsERuzE+2z6kPgVuptsegfmSkJz9b8WlM6zphECgAyBakUFfy3BOzJ1/G6ogbJY6dnCgI5Ib2fyGPTEKQ4mWLTiFCKouThPDqCEMXb7tZWawBNbJJj/lF2O3vV4GPTl7HbBQWKzblHWOjdyB5v5WTqEna7fDz59gi1CxCpw6SOBGFkN2CkmIoSNV+mep4dp5G2U4WDUOYG4iQ+m0DFxtnqTTAMA4emSliBZCAOvc0NMA+33M3DQcZhwvhI2Q47C6uixEkdJiT22EilqHp4YjPumPAdkthYlrTgxy1FxeyK4otuq2uiZ7KSbBjFJluQiEkkL5H3/CQyDu8ey6OUy2A399mcX2slKLnx4zTSQDoTOoSQQO3XZhxi4zLsk4ibYTg77Ei9qZkqPDZ50eEWZQhmHm1Rwoq23UECt1WhiU1SnH+M3e52aVGfuZTdLj6dfDsXnuDbucb7OZM8+2flRPLtEcjvMjIbPoMknbXbsKN2Rsn+mrDbI59NEm9RgGLT3xEl49BUydkZFRZJS1FxBmF6tHsL47CHv4YwXc6jGjWkb0Pavb1LUaEVm6jpw50GRHp1khybKF6xvvA4UhEAoBRicGI+NrFxb6cHgBPcX3Nkmv3tdvP31HylaXuB4o5wiDjok0CKTawBkS4GbeqIGi9mkZbKmjQ8tmZmnK+NAqnMFyWgTxAbI24panuMUwA0sUmOeU5sZl0Ih0rFhspZVG5yA3lslhUSm6j+GkJcA7HIsIkwUkNFZ5SPYlNtdXFqiX2xkl9AxkEHsQlZiup1bcVlvczDliUZed1LUUGKzVQ5h1rUQZjCY5OkFKXOPOyXYUOYKGajl6Lk58WdFWWZ0SLx+66yacEv5dKBPiIAKBXy6FicAEVRizza6QFbsSFiM+tQbIjARSU2tooBwO4WCkls6PyYsYjNIEledvHXALaRuNLLOF8bBfJIhUiKDTs38UtR22MAJqCJTTI0lu2F2K0UNcOJzeJTyVuwyTdDv9MNE6TYKEw7FopNMLGxLAsPnV5Bs9NLQGz49sL4awjl4So2z/A275mRPKZcjLWHpkpYFqWolWjbA2KUomJ6bLpNtnACnqWo3S4DMGVMjdidUeE9NglKUfm4Hptkis1EOcZYBdrHTCF6wrJMECKZlZ1dUVGMw/S8WIMwfdq9yTh8ZIYTG4fHhnJs4o6O4ASOFvwQqpT8unjBgIOdZ8uSYiODvh/WuhnnayNtb9A8HK0UFZPYaMVGA4Adhjd2wL2EMXUxWAv2avIWbFJsZnwUGypFNZaiT1/2Au33SLDf5c++dQLf94mv42f+4gFYozHHKtDzRyMQG7nlOy58FJu5VfbldGDS/Urm0FQJq1FLUfS8/FjwPKx+xO2KkktHfR6QxSr7op4Z8VdsZso5uxQVVkXZ0FLUoGITitjIgzDDpg+H7IiyLAu3P3oOH/m3J+ySQToLpMhwGmEx7F/wW+GNwwAfhBln8rWfYsNLURfNsMeILM9XWjDT/DNkdqIN7O1bdBsRu6KMJMTGZTDkqlBsnO8l+v9aJ0kpiqlTVjoXsRRlKzY0FTzadrdH6jCgiU0yzPv4awD2QRjngyqTtHx3GrYKQ0F8bsiP2mUNVeUoMv8GGHkXqy381u1MVfr3x8/jyTpXFaIqNpUNUGxMUyoLTQw8fJ77T/Z4qBmHp0sipM8KW4qKM06BELcURWWobHmgnZPMkBM+wXUAlaJIsYlailrPdu9BD8haBGIzXszaSkZYdUF0RHkbh08t1fHO2+7Fe/7sPvzBnc/g84/O2Q/GCa/rU05qEcL5gL4BkVEWYR/F5jgvRR3mpahdXLHpmhaWO9L7LgmBi9AGDdiTr1OxiM3ge2nZJXUYsEtRDUEW4ys23VQeXW4EDzMrSvbY1FsxiI1L99dWhSY2SUDG4Vmf2VZkIE7is1l8GoDFFsGgziSa+B13nEE/QhKbj33xKCrNLnK8VfjPH+cZJ5FLUREybAjCPBxzwndrDcL06aLYnFujMo27mnFg0vbY9KohVaO4xmEAyMclNt6pw25hY26YGslHV2zWu92713GNho+i2IwWMtIgzLDmYZoT5a7YNNo9/MD//ia+/MS8uO+Zeem44nQM9c2KijIckp4nutyiLMKe2S5tcZ7JY5NNpzAzwt5X5+uS7ycSsXF2fzUiBNcB9uRrI+rk614HsLiy5ChF0YWA8/OSy6Qwks/YOTYJzMqCcCKaxwYA2s0E3V+63XuHgzqV/IjNtOSzib0d8tdczvoL/TAa09viBVJBfIjNY2fX8JffZorSH73tRhyeLuEJodhELUXx/Q6TOkxIah4mv0um4Hq1cp6Izbj7lUwhm4ZRYspLtxZVsYlBbOIqNqLVe5DY0GI0EbDoTzsUm5DlTiXJwxGIjbxgxixFjRakUpQixeaZC1XMrTYxWsjgR17IjP7yTKV4xMZdsYlWilLnsaHj2TNWcKgMu/iYjvPVtuR3iUJsnGWSWoSp1wCQzrHXpaISG4/30oq4EBh8L02UJON5AsWGsnBy6RSyHtlSDkjEq9VSk9ezVaGJTRIsPctupy/1fg6ZfRcStHwLf41PGYpA3USVOf/nhYUgNt5K0a3/fhSmBXzPc/bi5Zfvwq+98VrMgS3Y1trZ8MZpy4pXiko6CDMgw4aIjVcpCgBK47ucvytwm9xjE0exER6bSsQBjd5x/24pqm6YHslFnxelpBQVh9gYjqvYKMRmrGgv+KEnX3e8zy8AnFxihOWy2RG86opZAH3EJk76cJ/3JKp5eEQ2D0dRFzw6aI4L47BTtRIt32tSy3ek7Tm7ooTHJqQylebt9+moxEaQPed7acXDYwOwcm2scyq2yfaxabFjC0vekM7CArvwbcchNn0BfT3Twv+6/Un8wZ3PoNWNYUbeQGhiExedhr0IT13k/bxpHppHJCgOwrR6E0jpUKbY+JeiLMvCPceZ+vDul10MAHjZZbuQn2RjFYxeK3wab2PZ/nDFVWzidJ8FZNiQx8avY2hsii1U2XbICd+NJB4bajm3ohmIPZSTZqeHBp8t4zccEmBf2lSKMkN7bBSVosKSONnEKymckYhNwb7q7jTDKlP+5mEiNoemSriIdwwdW6jBovdLnJC+fiUj5GRvQjkvl6KSm4ePLzgzbAi7uWIzHzekT8rrYenKEdqgAWT4uIG0GVWxoZJbwfFe8ivdTpRy9jiOBIpNnWfhhC23wTDQTbH96SYhNlmbJH/iK0/jI//2RPTftcHQxCYuyMybH/NfnKbYYo/lY9G6AGSQPyeMYjOqULExe3ankQexObvaxHK9g2zacKTyPu+i3bhgcWUhbDmKyFhpOpocSh6bXjteN1iQYrMa3Ao9NcPa4dNWL5ySkaQUlcnbV71RylEeqcNr0nDI0YAFcbJkl6LatRDb7rYBukpOkjwMK/wi4VEmiUJs8pkU2gYRm4hdUR7hfDKxOThVQjploNHpCeIci9j0lQ9owQ+byOtUbOKblgk0SLX/s0LBj+crTfs1UYiUpNi0uqa4dgibY0NzlDJWO/w2AdeOKMDfbD9VyiZUbIjYsN8RWrGBNBMrVinK6bGhsmYunUI+EzG+YIOhiU1cLB1jt5NH/H0vYwdYG2evHU9FsSx7W0SS/EClqDUFxKa+BGaqNTwX4IdPs8Xt8t2jjjf/Cy6awpzFXxP2uIW/JkIZCmALCV05xvHZ+Cg2tVYXFf4B9zIPA8D+XZP2lW+Ylu8k5mEgXsu3KEU5CcaKtOAHhbpl0yn0eKt4txFi2zLJixPQlykCXF4PXY5yUROanR5aXab4hAnoMwwDvQx7fbcVcru0fx7jFE5xYnNwqoRsOiWmxD+7UHXubxyPTV/ycJxSlKUgedirROMI6YszCFPqiqpJHT/FkDk2OZ6wnI2q2HiU3Ly6ogCm2Ajjb1TFxrLEsdZMdmxh/5YAYBKxSRgMCNjvpZFCxDiKTQBNbOKC5jFNHvF/Xjpj58vEKUfVF3nt3rBbx/1ApKCioBRFZajSlGfWyqNnGbG5dt+44/4XHJnCOU5sOsunw22P9jmKv4YgOqNi+Gx8FBvy15RzaYwWvBfEQ9Nl0fIdqvSWRLEB4g3C9EgdXq6F64gipAqMoHTDlGhIQcsUo+f1AKwtPWrLt1urd9Oe7ROkShEM/nozbI6NII7Big0ARzmK7S9/XdjtAQPdQlHNw+V8WhCbbitGachrwe8LstyddBCmVCah8LlCNuUYZ+AHmomVjazYDGa7WJblq9hMlhJ4bMyuCNGs8fTisOQNAMw0267ZTp6wXI0YHbCZoIlNXIQlNoCttMQhNrSdsX3hyjOk2DSW48V5ywjR6v3IGU5s9jtHDRyeLmEly143fybkcYtW7wj+GkKSQZg+ik0Yfw3ArsKXLbbgd6ohiA2RqTgeGyBeZ1SAYhOUYUNIc2JjNUMQjVaCjihCVAOxy6IrpkHnMqFGDbDtssXQDL1db49Nt2fizDLbr0PTfcTmQh+xiWUepvJBRI+N1O7dDltyAzw9Niseg0blkD67FBUvx6YeJbSOg2ZiZdEJv03A9b3U6PTQ7jHy4abYTJWzdrt3VMVGUs2qnNiE9REBgMUJWKwp5n1ZQdVmtOiAzQRNbOJimcpDPsZhggpiQ+MSglCYsK8uKueib09GGGJzlpUjrtnvVGwMw0BukilMlfMRiU3UUhSQbBBmCMUmiNjsGsmjYjDCsLx4PsQ2qRSVlNhEKEV5tHtTimpQqzchW2Qk1miHUGxE6nCwv2at2cG/PTwnplMLRCY2gwSDvqRHI8jqKU5srMiKzWApam61ia5pIZdOCSPtkQHFJoF5uE+xCUtsUikDvXREL5G8jwOlKPcSzawYhNkSi2+sHJtMXkyujrLgFwrsXOejKjbdQY8NZdhk04brPkwkUWykOWGVDvvdoedhIemwT/fogCifmc0CTWziYr0VmzDbAbjWrshATCSB2qn7ML/WxIVKCykDuMplOOTkPt4RthqyFBUnnI+QJMvGR7GhcL49Hhk2BMMw0M4ysrGyFILYJC1FxVJs3M3DK41opah8mW071Q1BNEK2eluWhR+/7V785J/fj7+595TzQdrfsF1YLotuHL8AERsjdECft2JD/poDU0WhGF1MxGaxn9iEJBhmj3n3gIEZSqE7aQCYafbabtirfLNnG8L7jtVrOOTMSB6GwVqIyZQdy6ycKUabn8SRL3LFxujB6kVQbVxKUXLp1nDxV7JSVIxOM3l76Tzq3BMWeh4WIPwxsYZ9eoU9RiBWmwWa2MSBaUYkNtTyfSz6tqISGyD+AMp+BCg2j3B/zaWzI67O/YMXXwkAGG+eRbcXolVXZNjEKEWJLJvhKDazPsZhQo+/vrkasA+dhn2lHds8HMdj466eeJUPvFAaYcQm2w2xAItS1CDxlfHZB87g28cY2fva033nL+qEbxePTYV7bMJ6TwAgW2DbNcKWE0RA3yCx6ffXAHYp6uRinX0+opai5EUzwWJkcWLTC+uxkQmJtODLsQETZed7KZtOYbrMM2jitJc7FJvopahiySbzzUYyZcovwwYAJuVSVFQ7gEQu6q3oBM4gu0KUCfFi2+4emyifmc0CTWzioHqefSiNdChDb6XMn7P0bPSclTjERpViQ+qHF7E5w8og/cZhwuFL2MTzWSzhidMhTL3UFj62P9p+ApJiE8M87OuxCQ7nI1hcfWkHjVWgrikjHbjgeyJOV5QoRTn9LlE9NqVRtu1crxb8fg5RilptdPDr//q4+P89x5fsbBcggcfGJhEVUYoKd4wAkOXli3TYBViMVBgsRbkRmz1jBRSyKXRNC6eXGzYhCq0QSfsVM3kYAKxsRF+GB7Ghdvp0ynA1aFNXIbUxx50VFacUVSzY571RjxD26FKKClI4HeZhswP0IsxtkjqTBIGL8Le0h33GIDZ9YY9x3kubBZrYxAGRjfEDbCqvByzLwv++8xnc8LtPoIcUY8RRfS8rfJjlZEiPDaCu5Tsgddg2DrsTm/TobrSNHNKGhSefetJ/W+26rT5ECecjDM1jE848DADZMldfgrqi5AGYQSMyvCBKUSvhX+PhAYnqsRkZY76gNMzgq+4Q5uGPf/EoFqptXDRTRiZl4Pxaiy30BAXm4TilqFyRbTfTG45ik0oZIsju2EItvmKTygIptshHNQ8D9mJohiUacou5NExVhNYVs64lmlneGVUxE0wxz8YzD6cyGbQtdo5iKTaZQY+N1+fFQWyAiCZpu8uNJnRHKUWlcjQTK04pyunXqmhis8NA4Xw+ZKNnWviVf3wUH/63J9C2MjhlctUjis+m17H9KZEUG0Ut30GlqABiA8NAJc9IytKZgFlZpC5ly/aiHQW0j6o9NiHC+Qi5UVYOSwWRjaQZNkDMdm939cSrRdcL4+OS4TnI9+Iznwpg5Ys/v5uR9w99/zXivXTvCYkcxi5FDZqHxyIQm3yJkbGMGVax8fbYnJQybGRcvIsRm2cXatHNw31qgpzIG6VFl9raQxtOvVq9a/7KH32G1roZ5+8JA5ccm6htyC3u7Wk1Y4znkDpSV2reGTYAC9QzslLpOs6oikxBkNQoAX0p/jdJ9Vow+034QfBQbLTHZqcgRMnkf33hSfzZt07AMIDvvm4PTli7AQDPPvmd8NtZPcUyDTIFYGR3+NeN7uH7mVSx8SY2S7U2zvJF/+p93uUUk5fqGhcC/EXinO6Np2KQqhQ1x8Y0bXLQp9hYloX5ChGbYI/NyCQfq9AJIBtJjcOAva+xkoeTeWymRwuo0YDIoM4oKpV5lKKOL9bQ6VkYLWTw0ktncNMRRpruOS6FHKpo945x9VkosX3OW81wJWSfrig3xQaQs2yq0YlNn7G13u6J3YxynOl8xPZrDwLn1RFFoJC+Vd7tE0vJyOTFnKgopSgA6HBDbyvK5GuXiddCsSl7f14mSoV4U9NdSlFRiEWGKzZ5dITfKfq2ucemqRWbnYWAQY2WZeHv7mNKy0fefB1+/z/dgPQMMxB/9e5viw9mIORW7yiLPe2Xqq4oF2JDLar7xgu+b/z8LtYRll476W8gJhIWpwwFSObhC9Fe166IQKx+xWap1kanx1aK2dFgxWZskp2nUnfN6RHphwrFJk67d9ud2IjJ3iG7oqbLOdTAw+uCQvqESuROfp/lGS4X7xqBYRi48Qg7J/ced1Ns4rd7ixybfHiPTaksnacwPhuPBX+10RHksV+xOTzFiM2ppYYU0BfyOLvuV9gpI1qoWyrH/pZGWF+GV6t3gFdrit+/1qNSVIzZVJmimOwdpRQFAB2Dvb+j5fW4eGwCCBw91og1XNQ2D4tSVAQCl+Z/y1jEpk+dqnLFSCcP7xSIvBX3RfjRs2uYr7RQyqXxxucxVecFN9wIAJjpnMEXHw/RDgwAy+SvORJt/0jdqZ6PNxQSYB9Gutp28dicXqb2VfeUVXtXGLHZa11gcrsXhGITo9Vb3sduI9okaPLXpPMDX9Tkr5ku55DLBH9UaF7UGCpYa/oYBsk8HDecD1DcFWV7I8JgspxD1eJffpUV/ycHlKKevcAev4QrFzceZufk6Pmq2K/YycOS16UaI5OjVJJ8QWFUFOGxcSo21Oo9Xc4NXARMj7DFb7neljw2UWdi9XVE5TKuHhcvZPhimAptkiYC5yT7foMhAXuURUWUomIkLGfyaMQwDwNAJxUjr8dlpIIgcD6fl8myNC8qZhChKEVFIKnkl8obnfAX0C7bBoBqix2nLkXtFIi8FfdS1JcenwcAvOyyGTE/KbfrUgDAEeM8/vGBkEMh43REAXYpqtuMZi6VQV6VVNbV80LmzoOT/sQmNXkIAHDAuIDH53zUBSI24wei7yvAFk4eThXJQByiIyqMvwYACmOMXE2ghrkVny9P2TwcF1FzbLptO/NEWnjbXVNcAYftisqmU2imuFy9FjAXi8hxwUOxWSDFhu3T9Ehe/Hz/Sf67oyo2Ysq2S7t3BGIzJpcTgrZtWVJXlPMzccrDXwPYvqbFaju+eTjmZG9CNs/zenphFRtSMdxTh73aoKnUuULEJlK7t7Tgx1Rsulyx6UQZEOmWYxNA4ABuILZiKDaSz6URoxSFDNtmHh1RygqNPs8WvZ/CjiDZTNDEJg4Cov+//CQjNv/hSskXw0P6DhvncefReSxWQ3yJCGIToSMKYG9MWvgqIdWhfsj+GperP/vLujjwmAM8MfmAcQGPnfUhNmSSjktsDCNeSF+IDJugcD4BTlSyRg/ziz77QMTGI/hQxl1HL+DNv/91MWxUQG73DuX/kIdR2uoJlaEMI1ordDvFyEdtLYBYUanMoyuKSlEXzdj7dNNhVo4SPpvIHpvBtmuRPBzhS3q0kEEdIcPkui27pNnXFSUuAlyIzXRZVmySmYfjzvahOUrhTdJe5uFwio3w2MTsiorrsenyC5/QQYRArBwb9lguoWKTR52XoqKYh4mA5dGOVorqddmcKul36IC+nYReh5V4AFfF5kKlhe+cWgEAvPJKyZsyeRiAgRGjiUlzBZ97OIT/ZSVmKQpInmUj/DXui+8pXooKUmwwwRSbPVjGk2d9jL2C2IQY9OkF4bOJYCAOkTocxjgMAMgWRefFyrxPW7/IB3JvoxfbX23iZ//yAdx/cgW/95WnnQ+SZ8XshrvCJ1KQzjsiCqjcM17Mhh4oCABdPvm6VQ/w+Ajz8KBiY1mWKEWRSgMAN3AD8f0nYhIbl7ZruxQVnryNFjLCJ9EL2rb8N+jLsVngFzG7RgbfR6TY1Ns98d6JnGOTMHeE8noyYSdfe3iJln0GQwK2YrPcTkBsMgXR+RWV2IjJ11GGfbqOVAjuIhwvZu304ZgemzgBfZQ8nEfEUpRMvnRA3w5E9TwAi5VoSoML01e4WvOcA+NOw2kmL+ZKXZo6g8+GKUfFLUUBTp9NHAS0ep9a8r4KdaC8C2Y6j5RhYfnss96m2lUeox9XsQGUKzbzFb4ghTAOAwAMA7UsUxtqyz6t9mJqujexMU0Lv/C33xGKypefnBflFABssTf4F16YcpSXvyaEX8ANvSz7Pa1awLYpx8alFLVUa2Ot2YVh2N1BAHAJJzlnVviXrYJ2b2EejlCKGi1k0eDdX41awLYFccwNTDFf5EoG+Wkc28hnkE0zQrncIe9JiOBDYMD/Ybd6R1uIxIDI0MTGXbFZbfibasc4qVwkYrOOycMAYHLFphdrlAP7DrAsC2uN4C7CkUIGrYQeG9EVFeU4JY9NM4piI5Mvfp50QN9OgmwcTg2evq88wYjNq66YHXzt7NUAgKtSJ/HAyRWcWPS5Cmyu2ibTsAMwZShTbAaJTc+0cHaFiE1AKcowBKGbaJ4WZMGB5pq9OMdJHSbECenzUWwWxZV2uG4hAGjnp/iv9SGUpCj5KDZ/+s3j+OpTCyhkU9gzVkC7a+LfZdO5YUTrjApq9Q7ZEUWwuIrSbQRsW5SiBn1az4rOuiIKkkFSTIJeazEiHFmxGWy7jjNSIZdJCRWlXgvo/vLJsKH30bTLFb5hGIIILBGxsUzbD+W7TbtsAcQvHRCxyVghZyjRsWb6SlEBis1Yke1XPU5An2NWFFdsIpbciNiYCUpR9XYPFA/jZ0QfLWTieWw4sbEyBVFKilaKkhSbKMSGyFc6D6RS6JmW1G4e7TxvBmhiExU+/ppOz8RXn2KL6n+4ypvYvGycPeefv+NzVU9qTWnGN45+qdbGfSeWB5WQUa7YqPDY9GFutTEwqdgPqWkyTp/DY24GYjIOF8Y9TaahoFixWazSlXbIUhQAs8TOl+l33mn/PDw2pmnh4//OAg1/6buvwg/exMpz//ydPpIaxUDs0eodtSOKYHDPTM+v3ds0pVLUoMfGrQwF2K317Z6JpVo78UgFy7LEoh8loA+wO2ma9aC2du8MmyWu2Ex5lC7o/sWWtICEKS/2ZazEvcIu8DlKBbRCKkWD5RkguA26mE0jmzakydchCUavC1h8kZYVmyjDIQExVTzSgMgBQ224lvqRfCaRx6abss9htFKUlGMTpRTVsT1MgK3+Abrde2fAZwL1sYUaqq0uRvIZ9/lJs2x20nVZtpB/8TGfxW/xGXY7fYnnU+5+dhGv/fideMsnv4H/fVdforEyxWZQVaAy1P5Je1KxL/gxXGTMuRuIVfhrAOUeG1qQ3K60vZAeZYTW8CJX7bq9aHkoNs8uVLHa6KCQTeGHX3AIb7ie/S3vOnrBboEGorV8e5SiViPOiSKkC5yo+CUPt6sA+ELpQlhFR9SMkwzkMinMcJXs3Fozfo4NJxnyVXbUL+kO7/5qNwJKUX6KTc2fIBOxWWpaQCpCKm9fxkq1Fe8Ku1CU83pClKNchoxaliXUP6/3kmEYGCtk0SBDdtgFv2/YZz1m9xeVWEInLAMD6lRFUsX8WurHClK7dwyPTZt3cBkGUMiso2LTF86XTRuis3crQRObqKAxBaODxOaJc+yq7vLdI+4LPldspmrPALDwndOrovNmAILYXOr68J998zj+0x/djQWuKvzG55/AHdzfA2CoHhsyDh+YDChDEfgxXGzMuSs2Efw1a80OvvDoOfzeV54WqcACihUbMn1GUWzyE4yE5JuL7n4i2rd0zjO07sFTjKhct38cmXQKl86O4so9o+iaFm5/VDIlRxmE6aEorEScE0XIlNi+G37Jw+SvSWUd7bIEOZyvH6TanF9rOnNsghQFy7KPtc8EmU4ZkTJBAKCTZkSlE6jYuGfYAJLy50GQyYS6VIuYZdNHpupSjk0UlKTJ16HIhsuQ0Wqriy5nj37BdePFrO09idr9BTiGYEYq0QBS11mM9mvKCgrZXTcil6JiKDaUklzMpsNdPBKEx6YdzWMjzagCtra/BtDEJjp8FJsn+KJ95V6Pcsr0JUAqi1SnhtfsY192nqrNEic2vE1cxndOreC//+Oj6JoWvv+5+/AfbzgAywJ+9i8fEPJ+csXGm9ic9snlcMUUU2yOGOfwuK9i409sPvyvj+O5/+MLePef3Yffuv1J/L//8rjzCYk8Ns5MmXbXFCF7MxE8NuUpliE0YS1jreES0kf7VprxTJOmrrrrD0yI+95wPXu/OcpRUQZhEsnoL0UFTCr2Qp4Tm3THR0WRM2xcjtWrFAXYLfbn11o2WbB6wYpCr22XLfjCW5Gi4aME1wFAj3d/dcImLPcRm0a7J66cpzzeR1MlmdjwxTeMOtXn/4hrHi4VC+hZ7Lz02mESlr1boAvZlMMv1Y/RYlZa8EOOqiBik84BqVQ8Uy0AgwIFI5mWnSQu7Pyk0UImXlcUf26LKzZRDdKxu6L6hn1WtnCrN6CJTXRQ9L+Lx+ZJrthcucdjknE6C+y6AgDw/fvYVfm/e6UQL/L2XhfF5ne/zPwX33f9Ptz6g8/Fr73pWtxweBKVZhe/+Xk+RVv22MRJH/YrRYUM5xPgx3DAWMCZxRVxxSUQgtjMrzXxR187BtOyDctfePQc1uROoSSKjcs4BQDIpAzRzREG2TF23meMNZxddblSq5Nx2DvD5jun2T4995C9T6++clY8JpSgfAyPTZ/XJcjw6YXCCNt2tudngPf213R7ppifdNHMILEhA/G51aaTLAR1RsmEgL8ujnGY0OOt24GjIzxKUYs1RsRy6ZTnVf5UXMWmbxpzNWaJZkQqmzSCSm6AaylqOcSYAYApNg3H5OsQi77oiCqi3TWFMhRVsUllafJ1yO4vYKClvhJySnxSj03LImITUZWSPDb1SIpNn8dGKzY7DGR09SlFXbnHxwDLfTYvHGGE5htPLwqp3AEPYvPo2VX8++PzMAzgvd91GQyD1UB/9Q2szPW1pxfQ6ZnACKUPN6LF7gOMCPmVosKG8xFGZoHcKFKGhYM4L86TQAiPzd/cdxo908KNhydx1y+8CpfOjqDVNfH5R6TSjFBsYnhs+kpRVIaaLOeiScFlRkBmsIo5N2IjKzZuu9PpiYRmWbE5Mk2LdFdcHUczD7uXolZjEpvSCNu3XM/H5OqTYXN6uYFOz0Ihm8K+8cH30Z4xqRSVStsdOEHEhhbdVFbk9cQZp0CwiNi0AhQUl+wcwGkc9lKL3IlNCPNwx11NGInosclnUmIRbtbDKEVu2S7hBqmOFaQFHwhZciM1Ie+4KIq66NNMrFQvpIJiWQMt9WEHQ45KZLEXKTeHfe80wX5/EmKTRLHZygMwAU1sosGybM8KjS3gWGt2RO7GFbs9FBtAEJvp2tM4Ml1Cu2firqN9gxvrS3ard18pioLavvc5+3CJ5E24dt84pso5VFtdFmyWK9lX9FF9Nq0KQFc1Lgtw6HA+gmEA0+w4LjLODRqIAzw2pmnhL799EgDw1hccgmEYeBOfwfUPch4QqSDtSjgTJOCp2CzGMA6zfWBEcMZYxdyqyxdoQDjfY3Nr6PQsTJdzDg9TMZcWi/1xigmI1O7NyWQfyRClqGK04yyPTbD9shpodT2+QEUpyq3VmxGUI9NlV+K4Z5xJ6hSSGLozyi2crxmf2Bhktg4M6BtMOwZsf41XR5T8mKMUFWXBH0gejliiMQwxILLZCENsBtWpMIMhAUZ8ekijZ0QwScuhdXyxzqVTyKajLV80IDK0YiOrSX3lvqAFfySfEapLJ0YgYJOP8ohObHgpKmqOjZR4DGzt1GFAE5toaFXsN8CIs537KFch9o4XMO539bvnegCAceZ+vOZqVrYY8NmQcXhsv+ML+qnzFfwbVyh+5lVOJSeVMvCyy9hieddTnCgR+ar4pOC6gdSa3MjAFWiz0xPDIUN7bAChPF3UbyA2e7ZvyYPYfO3pBZxebmCskMH3PIeVAL+Pe06++eyirYwUJuyukjA+G8uy1Y4+xYayR2YiGIcBiPfFuFHH/JIL4QhQbMhf89yDEwNX+Ien2fk+sci/KKN0RQli4yTddo5NNMWmzEtRI0YTyzWP/JOmt2JDnXWkRPVjVi5FAeGJjVh05Qyb+FefqTz7PUYnqATmrtj4hfMRplzHKsRXbOIsRm2uLrRCERufMQPlAMWGKzodSlkOVYqyS25xM2wAe9hnJvRMLIl0kfck5HspnTLQS7P3cLSkY67YiFJUVI9NzJEK/X6tkCW3zQpNbKKgyruOcqMDkv7jQf4awv7ns9ulZ3DLpexN+MXHzjvZtShDOVu9//CuZ2FZwOuu2Y0rXLbz8suYWnDXUb54Cp9NVGLjnbNCqlQ5l/adlTIAQWz6FJu1M2wsQCprl8/6QGrNm563XxgTD06V8IIjU7As4J8e5MTIMKRy1AW3X+VEq2IbTT08Nn4LkisKE+jxROC1JRfjtlBs3D02wjh8cGLgMSIBg4pNGGLj7ndZjdkVRTk2ZTTEuQq7TQDCf7R3wj0HidQpEegYNn3YZbK37YuIdowAkOKKja9JWt5utr8U5R3OR5h0mIdjlKISjlQA7LyeViMKoRr02ASZ0KlU1RbjI8Lk9Ujzk2Jm2AA2sUlHTVhOZUSadDXKgs/PT6RAQE7iaib7/ZE7v2KPVOif7M2PMyqx2iTQxCYKqKTTp9YAwJPn2Jf4FX7+GgAoTYkuoecaz+LAZBHVVtfZxksdUZK/ZqHawj/yQL93v9w92+Zll7NF/ZGzq0xxoM6oakRiIxZfP39NKVqHCT+WS1Jn8cS5NfQoWIRI3NRFA1H0ADtuUrTeevMhx2Nv5OUox3iKKAZi8tek8wNhYwuiRTeiYpNKoZ1npKW57HLeyf/jodg86ENsDs/0KzYR2r1d1JNuzxSLftSuKPo9ZaOF5arHF3dT6orqAykxez0GjBKxWaq1WakrailK+nsmKUVlioyUpbsBC7CHImaXorzfR0Sel+sdWAnavYV5OMZi1OXEJlTZxCV5OGxsABnx7blYUczDBTFxuhSDvGXzXLExQ6Q6A9Jibx9nFPJo8PdgLxKxYcfa4MSmHNNjUzA6aPQ3afhhoKzJzrNWbHYCBLHZPfDQE3Psi+2qvQGKDQAcuBEAkDrzbbyZL85/d7+0OLsYh//i7pNod01cf2Acz5e6ZWTMjhZw1d4xWBYr34j9jFuKcs2wYR+AA2H9NWLnmLfoSuMUmp0ejvFwNizQsV7m+rIvPz6Prmnh2v1jA6bs117Dju+JcxXbgB0lpM/DXwNIMfhRFRsAFictnTUXb5OPx2al3sZxTlquPzDoS0mm2AwuvBTOB0RP5JV9M5VVj3Pt4esBIPxHe1yMwwAzM+cy7OtpXm75juF1oa6oKJO9CTne1p71M0nL+9Wn5IYpRZFxu2daaKciKBle5YM43V98u+1mBAXFUYoK77EBYLdCR8nNyRTQ6MQbgAnYwz6zVtt7Zp3bdl1IcphzTGblOMM+az1SbOK1ewNAN+bwTQCotthnRntsdgKoFDXiXPAtyxKt3m4logEcfjG7PfZVvPn5zFfytacu2GF980+wW77Yt7sm/uxbbNL3O156ka9S8nKu2tx59IKUZROX2AwuvmcEsQnZEUWYuRxIZTBm1LEPi6Lzx6vsRqChov/hykEyOTOSx65R9kF+6nzFuc9RFBu3cQp8QYqSYUNI8RJgqr6Abs90PugzAPOh04ygHJkuuSooAx6bfDKPDRGb0XwGmYhGTGRyaBrsS7Cx6nGuW96KDfmi9nkoNoZhCNXm3FrTTkwObPd2MQ8nWPAprydnBixOgtg4c4LCpFfnM2lBupqUyhup3buEnmkJT0Wc2T49GhDZjqDYSGW3sLEBNC+qIeYohTlOm0jV4ky85sgV2HdWDm20+z+Xvtu136Nh270Bm9hYkYgNIxgVM1lXFBAyk0hst58ks/Mc52JgM0ATmyioEbFxLrJnVhqotLrIpAxcPOM910ngyMv4C+/FkTEDNx6ehGnxDp92HVjgWTR7rgMAfO7hs7hQaWH3WB63XDuYnyPjFZLPxoqt2HiXos7RguThjfBEJg/MsAyfK1MnbQPxIsvkccvrkWdvUY5LP6gD7SgRmyghfSEUG78Sghdy4+y8T1krON8/9FMMwBw8t3QMV+9zL2ce5ooNm4rdidkVNUhsxiL6awjNDNvPZsVDsfHIsTFNC+dX2XnZ40FsALscxbJsonYnDXps4pSi8mW27/lAYuMe0Ge/j/wJMqUPi4yXSAF9BcdsnzhX2aYwukbvxgKkmWMhFZu6GYHYyIpNzMnegD3sM7T/xKXkFkUVy+bZ9owogYD8WGvdmKWotH3+zSjEpj+vp6m7onYOPDw2pNZcOjsi5HNfTF3MOp56beDkN/CWG5hq83f3n4Z1/lE23be8Cxjdg07PxB/cweZA/ecXHQn8/TccmUQ2bWCh2sIFg6fpRvXY+JSizgaUEHyx+xoAwNXGCdtAfIGTuJnBUtQ9x5dQbXUxXc7huv0us7dgK2RPnuMLiyLFRnhs4ig2I3bLNylcANjVGI0gcDEPPz3PjuHSWXfVbySfEQrSycW6TWy6jeD2dh9iE5Q94oV2lhGbTnXJY5vuXVFLdXbFbBh2EJ8bZscYqXSOVQjb7m0TDFE+iGEeLpXZOS5aIYlNv8cmpAmdiE3NjKDYSASDFtxMykA+zHdQH8SAyCA/iGlKSobU7s3fS0ENBeSxIXNs5ONsxy9FZTjRKKAtTMj+2x0suUVR/2h7oXNzAFuxiVuKMgx7inmchOV+I7r22OwAVN0VG1qQLvPLr5FhGMCl/4H9fPR2fPd1e5HPpHD0fBWP3v81dv+e5wCGgT/66jE8eb6CyVIWP/yCQ96/kyOfSQvV6Ok6v8qtnIuWPuxDbMj06VVC8MW+5wEAnpd6mik21XkeeGgAu68dePodT7L9eMUVuzxD8gYVmygeG54V5KbY8G6WmRiKjQjpM1ZxelmS9klFSmVcydRT9D6a9Vb9Dss+G3kR9VNtzJ6tZEgkIymx6eXYot+rLbs/wSPHZm6FvYd2jeR9s0gcIX2hPTaDc4ySJA+XRycAACU00e76lC88PDZ2Kcr/fUSlqqpJMfwBC75lOY5VbvWOOjYCgFjQzKDtyp4YacEP+14idbBKik0Yj43UsSO6omIQGznjJRSx6Q4qU1E8NrkCEZsIScf8WCtd9rmIc5wWV9+iDfvsm4kVM+xxs0ATmyjwMA+f4J1CR6YjGGovv4XdPvl5jBcyeOdLLwIAHHvgK+z+fc/F8YUabv33owCA//Y9V4uruiCQivFIRcrEoCv2MPAYp2CaliA2fiUETxy6GQBwQ+ooFioNLD39bXb/zGWuPoyvPMGIpFcZCgAuJ8UmjsemzpWG4pTz7nYXzQ5bxOIoNjRHbI+x7FRs6P1T3jUwO8myLOETumy3H7GRfDapdDifjfy3l8jQWkJiY9F8raYHsfHIsSF/jVdHFIHeY+fWWhHavQdLUfQlHdkgDaA8yj02Rg+Vmt9crMFSVKPdEwuo15woApluV7tEbAK8Lr2ONBOraHexxCwdUDeWFeSxkRdLToYsyxKli6CyJv0NIk2+lhQbkWMTpw1ZSuUNFV7X104PRGv3JmKTMUMSjF5X/E1XOzE9NoAgcJGIjYdiE6fDbjNAE5soqLorGSe5mfNQlMC6i1/JvnxXTwKn78HPfdfluHbfKG6yHgIAPJi+Du//m++g1TXx0ktn8Obn7w/9q4nYPHqhay8qUXw2HopN2BKCJ/Y8B8iWMGHUcIlxFnOPf5Pdz5UcGaeW6nhqvop0ysDLLhtUjgikblyotNjVcSSPDSc2JSexoRbdQjYV74uFE5u9WMRpmdjQQNLRQZ/UhUoLa80uUob77CSC6IyirjLR8h2C2GQKQMZeYJMqNgZXulJepMojx4bShIPIMb3Hzq9GUGx8kofjyOrpvE0yqxWfcywUG/tYSfXLpo1AEyYR6LVuyBKNTHwyRUmxiXeFbfDzZQQRKuE7KQAptnzU2z0R3xA0Vy2TTqGcS9uDMCPl2CRVbHgrdOhSlItiE6EUlS+x904mbG6OpF6tdtjxJSFw6LbCdX8BA2W3KCbpzQhNbMLCND3Nw9R+e8RnQRpArgRc/f3s5wf/HLlMCr/3ujHsMZbRsrL4wc8D955YRj6Twv9807WR5OUrhe+kYqcPh/XZmD1pUKOTUIQtIXginQUO3AQAeHXqAeRPfZXdv/+Ggafewbuhbjg86bvwlvMZMbPqyXOVmIqNc7I3zYmaLufjyfpjjITuMZZwRi5F+UyGpzLUkeky8hnvL+1YnVEeBCNu6jAhw31C2fbK4IOW5Zljc3aFMmz8fVq2YhOlFDXYsZMkeRjpLFq8Nble9TjHluVqHpbLUEHvIxHS1yFiE0Qw+CJopIF0Viy4sRZCAClObFJBpSGXxZ4G0WZSBgrZ4O8FxyDMMD4QqeRWjznok+2gNCCy5ZGWLaOvrb1nWoIQhXkvFYvUXt5h60fg9mwCtNZh75c4BM7I2iF9Lb/yqWPbTvOwHoK5U9BYZgm5gGPBb3dNnOVpvIejKDYA8NwfZrff+SugegGHz/4bAOA+XIlDs1P4/ufuw5++4wXCVxEWpNg8c6EKM2pnVGOZmZeBASVDlBAmYhiHCde8EQDw7szncHH9Ib7D3z3wtH99mO2vXxmKcMVutnAePV+xFZvmKpPr/UAem76EZVJs4rR6AwBG98KCgbzRRUUO6SNi46LYkEfoUh9/DRAzy8YjPC6pYpMbYYQw160MXhl2m4DJz39fKepcyFLU7lHbY0PDKENP9+YEwzQtVNvUFRWz+4u3tXsSm27TLgtJxGZRGoAZhCk+imCpHZLYSK3eMIzECxGNjggMInQhjmsNuwwV5kJgrJiVSlFR2r0LYmJ1MUbyMPlHUoaFVjMCoco450QB4ZSMYkn63g41OoI/J51DrcM+T/GIDTvOXFgvkbztbDEygduM0MQmLMgfUZxyyPlnVhowLfZBo0yV0DjyMmDf89mX1N//OHD3HwAAXvwf/yu++L5X4Ld/6Hm4+WL36H0/7J8oYiSfQadnoZrlC31YYkMlnOKkmI5MoFC1vXHKUISr3wgrlcWMsYYULNR33wBMOKd6n19r4lvHmGr0Pdf5t7cDwBV7GBl48nyF7bfB39akPHmh7lGKqoVr0fVEJgezxMivsXoWJqUsUylqbPCYhHHYx18D2MRmvtJifoMwLd8BxCZuu3dxnB3jmFUZ/AIVvh5jINtlLqRPi7qiWl0TNfDnRlRs6p2e8M3HafcGgFaK/a5m1eMcy/skE5sInXUUK7DYDluKslu9AaDWjp9hA9glt3RQB4+LYiMCEEOe37FiFq0oxEYiGPUkJTfJK9MME0TYd46ppJlNG76qKqFUkj5voYiNNOxT5PXEGNwqT/gOOy9KavdOGh2wGbApiM3v//7v46KLLkKhUMANN9yAr371qxu9S4PwMg7zK+dDUUcMAMxA+poPsYX42TtY+/H4QeDKNyTaVcMwcDlfIM9bE+zO0MTGr9Xbf75PKJSmYLz2/2WbsvL40oGfHnjK5x6ag2UBzz80EWrQ5uXUGXWuwur+ZAYO8tkQ8ekzD9ut3jE6ojhS46wcNWMt4AIvbdmKzWAp6unz1BHl31k3XsqKELQTi/VwgzA92q5VKTbjRm1wXpScYZNyfs0QsdkXoPwVsmmxb8tkqo3osalIZZI4bdAA0CZiU/MiNlxFypaYoZsjzJwoAik2F5r8OyRsKaovdTjuQpThqbyZXsiuqMxgKSrIX0MYK2TtgL5IpSjbYxO5DRoA0jmYYOe3HSavp68rKmrQ40gpj5YVUoEDHGZlMklHnhXFXw9EnBclHSu9lxiB2xQUITI2fK//6q/+Cj/3cz+HX/7lX8YDDzyAl73sZbjllltw8uTJjd41J2jB70sdJq/D4SgdUTIuehnwfZ9ghGn8EPCf/sahCMUFzaw61eFX9GE9NuQj8mn1DiohBOKFP4l/vuFP8Lr2b+JvLxwcePif+EwsmuAdhCukzijLssL5bCwr0DwcqyOKw+DEZp+xYBuIPRQby7JwdD64I4qwj3tTzq02lZSiog7AFODepDG4EBsyM/eRKcuSOutCKH9ECla6IYPr+qZ7y3OiYvmlAHQz7LPdaXh0FoqOKOffzi5FBRNkes6FJl/IwpqH+yZ7xy0d0LiBwIRlV8UmWgDiuKMUFcY8LCk2berWibHgGwa6BttupxkmAJFUjD5iE/I4RwsZSZmKptgkSZG2B2G2w3V/yfuXyYvPTOzogE2ADSc2H/vYx/DOd74TP/7jP46rrroKt956Kw4ePIhPfvKTrs9vtVpYW1sT/0K7vpPCU7FJSGwA4Hn/CXj/UeC/PixmKiUFGYifqnNpPKxiI7J6Br0tcyFNn2Fw+U2vxWlrF+4+tsiGHHKcXKzjwVMrSBnAdz8nuAwFABfPjCCTMlBpdpnRNExnVKtie6aK7qWoWBk2hMkjAIDDxjzLsrEsYJXPAxtzdrgt1tpYqXdgGMAlu4KJzW45uC7MIEwPYpO03ZuyeCaMGpbqfcTGI9V5qRats47KgcsdvkAExRaIBV9dd0ePE5tu02PbXnOiopSiuHl4sc0XsrBt131qQlzFJsfLJjkreimK3kehFZtiJmK7t+SxSZA8DADdFCc2kRKWnaWosC3Qo3n7OK0IBM7KFNDpcY9NNoFJ2ohQipLIY3WLt3oDG0xs2u027rvvPrz2ta913P/a174W3/jGN1xf8+EPfxjj4+Pi39mzZ9djVz2JzcklXoqKaPAdNkjFeGiVfwGFJjbegz7n1sKZPsPg8t0jmB3No9kxcd9xOwflnx9if88XXTKN2dFw28llUqJF2tEZ5UdsSK3JFBytwYDUzZJAscHUxQCAw8Y5pthU51nGipECJpxBi0/xMtShqRIKIUyRdF7mK60NNQ+TYjOOGpb7FRsRfujsOKMy1MxIPlRKN2U3LbSjlqLY+8HuiIp5jIAwLnsTG3fFJsycKMJoIYOUAdQt/p7v1P1DNfvi/pMqNnk+xTxvBbQI9xFHAFiLodjYpagIJaFMMVm7N+xhn6FGR/SV3aoRR3OMFrJoWnzoZyO8QkTJwUDcUpTdFRW6FCWRx6jHuRmxocRmYWEBvV4Pu3c7F9Hdu3fj3Dn3hfgDH/gAVldXxb99+8KVKxLDQ8kQik3UjqghgxJ5H6WQvspcuPRhj+OUw/kSdUVxGIaBV1zOyl2/8fkn0O6aWGt28Nf3ngIQvgxFoFb7U8sNm5T5ld88wvkANR4bGup5kXEOZ1YawNIz7P7xA44JvADwNJWhAjqiCA7FJkpAn1QW6vRMYTiNT2wmAAAlo4WVSl+3kkeq81zEciaRgoUW/5I1O0C37f2CvoC+asRF1xWcJFktj8VJjFPwKkUFE5tUymALISkZVs+/q2/AY8NLFzEX/ALv4Cmi5d8iTMRR7opqRjOhjxUidkVJ6pQoRcU0SROx6QWNjujbLhAtdRhgOVh0nI16CGLDiRQNJM2mjXAjevoR1TxsWQ4Sl9SvtRmwKfa8v45nWZZnbS+fzyOftxeGdasBuigZpmnhpEgd3lyKzWQ5h9nRPOYqvKuqU2eLTWlwIXdAHOcex92LtTY6PQuGAcxG7f7ywM+95nJ84bHz+M7pVfzPzz2GJ85VcGKxjpmRPF4fMOyzHzRt/PRy3fawrM15v8DDXwPYgwvDXGl7YooRm4PGPM4uVYGlZx33yzh63n9GVD9mx9wUG59SlMswSiofAPG7opAfhwUDBiw01/o60EQpynl+qdU7jL8GsBWb801pIWtXgYzH+7jPPFxt2RPM48IgwtKquj/BoxS1HFH5Gy9mMdeQPludurffzsPYGncxKvAp5iW0UGt1vZVDIo6SyhnPYxNhJpbU7l1rs/dyLPMwbDWkG2aKecJzbBgGOpxINeoBMQWAIFJd/ppYLe2AQ7EJ5bExu3bER7aASpPt61Zt9QY2WLGZmZlBOp0eUGfm5+cHVJwNh0vq8PlKE62uiUzKiD7teh1wxZ5RtJBDI8/3eeVE8Isq7qUoyrCJHc7ngv0TRfyv/3g9AOC2b57A3ceWMJrP4DM/dlNkFeHAJPuiPb3UsLuOKj5lyrp7qcQ0LTWlqLH9MFM55IweuksngEWu2PASlYzH+aRzalsPAhHLedljEzGgj8pQo/kM0h5zuAKRSqGVYb+zsdpX9vMoRZ0N2RFFEIpN07InF3uVo0xTWoz6SlEJFJtUgf1djI6XYuNPbCYDJl4TxotZdJCGaYQwEPfNxEpaikrzHJsCWv7ZJ0KxsY81uscmaycPR+iK6qTyYl5XXGXK4ot+qMnXfSMV4pRoiKS0wrSX8/cuvSa2YiI8Nu2QU8yl95mCFOvNgA0lNrlcDjfccAO++MUvOu7/4he/iBe/+MUbtFcecFFsqAy1f7KIjKLFXiUu5uWZxSxXX1ZCdJp5TDCfU1iGkvGaq3fj7S8+AoB5Zf7wP9+Iaz0mefvhoCLFZq3ZQZfnzsTOsQGAVArdyUsBAGNrR2ERsZl2KjamaQlic82+cMctRg2stUK2ew+WolYSZtgQOnwQZrPSr9i4pzpHnTUmEnlr7eD0YdmgyRWFqP4PN2QLjLyluh7bpfMrjVNod01hXI5CbAADvbTks/GC8Lo4F93YiyE/Xzmjh2rdj1ANjqwIOyeKwBSbkMM+pec0Tfs8xj1OGhAZOOxT3jcqa8Ygj70U214rgseGVJ5Y/hrA6bEJo9jI5DKTtzORtrB5eMP3/H3vex9+9Ed/FDfeeCNe9KIX4Q//8A9x8uRJ/MRP/MRG75qNXsfOPJGITawZUesI8p3MYQYHgGBiY/bsFul+xYanKycK5/PAL333VTg8XcL1Byfw/EOTwS9wgVBslhvA6BF2Z8WH2Hh4bMhfM1rIhArh8kPm0E3A4mN4jnUUvVP3sQ9b3xTz44s11No95DMpQUSDQMTmQrUFMzfOrk4imocTG4c5rMI4UD+FHp1Pgqd5OJoBncglIzYj7PeGITbc8FmJmLHihizvGMp4GV1dFJsV3iWWMqIt+ADQSRWRRS2A2PQpNu2ExEbyzLTqFQAewaB0rLJiEzmgL4NG2FKU5P+ociNuLpOKrxrT4M5Q7dd2CQyIRx576TzQBTqhFBtObAx2buIapGWPTSXqsE/DkHxMG04PYmPD9/wHf/AHsbi4iA996EOYm5vDtddei3/913/F4cOHN3rXbNQWAFhsLot0hX+Cd0RtNn8Ngfbr2c40bgKCiU3tAqu1GqmByd5za6TYqCc2uUwKP/aSixL9jv1csVmstVHL70IZYF6MVmWgGwiATVQHMmx4q3cS4zBH6uBNwAO34XvT30SmugCkMmJWFuHRs0ytuXLvWGjVb2YkB8Ngs2uWzCJmAKBdYcQ05fJl6EJsErd6cxicGJr1FecDYlxF/1iOaJEBot271gbGaMK3R3eS3CnEQwEp7j/uOAUAyHH/Sa5Xd/f/uZiHqf19opQLXeojAtRO5VECAkpRTmNrLeF0b6Rz6CGFNEw06j4t9S6KTeRSlGQetrpN+J6dXkf4P2omO7ZE3o8sDYgMU4pydp5FNQ8DtkLUaYUnNpR9E7elXVZsLoQpRQ3MiUqWYr0ZsCnqJz/1Uz+F48ePo9Vq4b777sPLX/7yjd4lJ0Ro3Yxj4TiuIsNmiCDF5rHGBLsjiNhQGaq8a2CBtDNsNp+XCGAL9Bi/YjxTT9tlF69ylChFOa9Mo7ToBuLgCwAABwyugu173kBrORGba/Y5g+z8kEmnMM0zdubb0n56ZdkMUbHJ8vThdGtFTHgG4KrYWJYVuSuKiM1irQ0rtIlXLpNEUxPcUCyzv03Barh3DLkMwFyuse1ORhgwSn+LllAzwpSinGWS2IuRYaDFZ2K1/YyuQrGJbx52eGyC2tollazKJ5/HVjIApIjYRMzPAeJ5bCz+2l4YYsOJbMsgYpNQsQmbY9PXYUeKTWxitQmwKYjNpkfF3Xey2UtRByaLSKcMHOvyxTuQ2HiH852LeKW9EbDLUXV70KSXgdirFKXCOEyYuRyLo1fa/7/0uwae8uhZVkKKQmwA20B8vmbZ8fZe5Sg3YsMne0/EnOxNyI0yZW8MNRFsCMCV2CzXO8L8SXOggkDEptU1YeYC/EQuCcBR/R9uyPNS1IjRdHSTCQhCZW93uR6+1ZtAxCZUx5BUPuj0TMlUG38xags/SAhikxssRYUlyeVcWizehmUGtLUTATEEsUmi2Ahi02v5PxGQSlH95DHC9jnJCNVeTooNL7nFJza2YhNqCGa/YiM8Nlqx2d6gPJS+qcw0Jyrq9O31QjadwoHJIk5b1BV10v/qyCec72xEb8RG4OAUGYgbwQZiz3EKvNVbQSkKhoHzL/kQ2lYaDxlXAi/5OcfDlmXhsbPRjMMER5YNkQciEzJM0y7dSOZhVYpNim97AhXMr/HFwrJcic1Z7tOaGcmH9i+VcmmR5dHkHViexKbtUnJToNgYnLCU0BTnzQEXQrUUsSMKsP8WDcp48QsjlILyqIsFSOaL6HBi0236EBtRimLfee2uiWaHkaqw59gwDGTy0sWgnzIltVxXxaDPBMSGq3mpSKUoZ/JwFGJl8O2ZoXJzuEk6aSkqbY9UiKXY8PdTaQt7bDSxCQNK7ZUW/JV6W3RcbFbFBmCk64zF/TLtqvviR3A5ToB17pwXHpvNr9icWgqj2NDC6zEnSkUpCsCB574aL259Am9u/BJWOs6P2/m1FhZrbaRThhiBERa75SwbKqe5TTOX/SgupaikXVEUfzBjrOJChROb5orruIo4s8YMwxB/i2aKE4c4ik2SgD5eAisZLUGUHHBRMaK2egM2salZIRQbSU0gJSGXTsULdOPopIv8V/spNs4SWEU6H1EW/EK+CNPi7ho/kiFNnbZLJPGVhEyOvfdSZkDCcq9rv4f7cmyikOQUf60VIa+noVCxCZVjI82oArAtuqI0sQkDWvBH7dA68tfsHsvHb8tbB1w0XUILOVSzVI7yybLxKEUt1FrKw/mGATukryERG4/0YS/FJsJE5jAYK2RRnNqDLjJ4bM7pgaEy1KW7RkKNUpAhSlFrTfsYai7EhkhAOm8bJ6FOsaH3yoyxhvkKX4Qo8yk/7timMKBHVP2IHFQNThy8vEQuJl4VXVFElEZRd1dsXEYqkHl4MkYpqmaGGB8hXWWrMnv2OLHp+YXXdZwkriLmJ6UjRV6MFrO2MuVbchtUppKUotJ5doxZq+OfsCx3wPVNUI8yniNNylSE9vI6b2uP3+4teWxClaI8PDbaPLzNQSUaidiIMtTU5ixDEahMNp/iKoyfz8YjdZiutGdH1YXzDQOOlu8xHtK35qLYdBr2YtRHbJSMU+jD1XtZCYjKToQ4xmHCrJxl46fYeLRdqyM27H21Cyu2YkNm+xHnhHgRGRCR2JDfqQK+SIRUbCzLkoytCY6TK11lNLFW9yE2EqFa4c+bKkc3D6/0+Pnx6v4CHAt+4gwbDpN7tUyv0RHAgGITdZwCYawYcqyC5P+otpKXorK8NFRA299/IpuLOVGoxDBoU8nNCDUTi31+iNjGVkyijlSQVDEAqLe0YrMzQHko0oIvjMObtCOKQMMhT5q8HOVLbNwVm7MrFKq2ectQQN9YBaHYuHhs6DjTeTGhmmB7bNQoNgBw9V7mn/FSbK6OQWxElk2labfmuxKbFXY7NGJDis0qK4sBUned831kh/NFex+RYrNiBhAb4bFhBKPR6YmwxUSzorg3KWOYqNdc1CKXUlQSj81yl5Nqr+4vwHV+UtIIfJNPMfeciQUMtHtH7YgijBWkLBu/Rd+hTNnqUFykeCmKEZuu9xNlf41hoN21DdqjERSbDHl6emFyc9ixUlu7ilJUo+OjSvVt1y5FJS/5bTQ0sQmDiotiI2ZEbW5iQ63oT7T4VT0l4LqBTNJ9Hhua77NvExuHAZvYLNc7qBf4oupmHpZN0n2ZJLQgqcixIRBxeXzOeQX+aEzjMCCXosIqNhOOu1UTmzGjgeUVvuhTKapfsRHjFKK9j0RIHykZnsSGCAZTWGjRTaeMZF/SuTJ6YK9vVlw8aoq7olZM/t5rhzDxZkvqhhZyFcbyMvNa1kBAX9QMG8JoISu6f3xbryXFJnEIISD2u2gEjI7o2sQRQJ9BO/x7KVckYhOiC4ufhypXbBKXotBGM9RIBWdbe12BMrbR0MQmCJblWoqyFZvNXYo6MFlCygCe6HIFY+Go+xMty9VLBNgLUtgY/I3CaCEr2pfP9jhZqJ5nRkAZ4u/pJHDdnollXkJQ5bEBbGLz9HxFXPU9cW4Np5cbSKeMZIpNtQWTDLobUYrKj6GXYueqvcbfPyL3qX8sR7QBmASRZdOjtvYV9ye2nCUhOcMm0bBcw0A7zT7nnf4gQtN099jUonts2H4CVYsfZ8uvFCV1C6laiLi6YHgRm24TgOV4blzFZrSQCVeKclNsEhEbdm6DS1H2tGvANg4XsqlIXqJcgZ2njBmmvZwnLPO29vilKK7YhM2xkSZ7W5ZlE0it2Gxj1JcAk9fVpS/q48Jjs7kVm1wmhQOTJTxl7Wd3XHjC/Yn1JfsqcGy/4yFxpb3JS1GArdocb44CqSxg9QbLUR7dX0tSDP5EhBJCEPaNFzBWyKDTs/DUPFus/s+3mIn7ddfsjkUu5PThaoqTuP6xBoBNAqSSW6dnii/1xMTGMNAtcWWGCKNLSdMZzhexFMXJwbkWVzI8FRsnwVhtxFt03dDJst/Zrfdt2zGfarArairC+yiVMjCaz6AGIjZ+io29GNmm1mQLEbUmp7yIhmwqTuixGQ1bipKUk8TpyoDY7yJaoq3ZFYJQcX9NM7pxGAAKRfa+CUVsuHJS6bG/Y3LFJqLHJltgeVGcu+p27+0MWhRL00CGfUk12j3hJ9isqcMyDk+X8Iy1DxYMdlVfWxh80uopdluedXSyANKV9iZXbADgwAQ3EK+2gPED7M7+TjCx8DqJDbV6T5XDx+CHgWEYYrDn399/BtVWF5+9/wwA4Edujjc6RE4fXrS4UhBSsZE7exK3ewNAmZ3HdP0Ca6Gl81u2S1ErdbsLZfd4tDIfqWfn2gHEpuX02AjFJuJi5IZulpW3eo0+jw2RKSMl1IBWtydaZqN4bABgvJS1FRs/87Cc7yK8J8kWohQnZqmeh2JDHVGZgkgmp1JUdMUmi2aYUpQURKjE+8HJWymwFOVUbGjbUY+zUGTnNGe10OkF+F34NitJE5bldu+IAX1yya0YsVNzM0ETmyC4hPOd5P6a8WJW6ZX9sHDRTBlN5LGa58dw4cnBJxGxmTg48FBcb8RGgBSbU8sNYJKThn7DtEcQoUxsVOPHX8ZmYf3J14/hV/7hEdTaPVy8q4wXXeIxbDAEKKTvQo+IjQth9SE2o4WMEgKXmWAdaLvMBTabyWVCPAU8zozkIg8XJXJwusH/Lq0KKwH1Qyg2To/NWDH5lafJf6fVT6qanOjkx4Rfizqi0ikj8kI4XsyiCv458ypFmT2gx96ryko0ANIF9j5Ke+XK9HVEAfb09KgeG3leVLhhn2ravYl8FtEWZMV3u5wIUThf1Jb6YpkRmwLaDtLgvk123le6bBvxZ0XJik3ANgGHKkZkr5hNK724W29oYhOEyuAiaCcOb361BrBbvk+lOWlxK0etnma3pHJwyOF8m70rCujrjJrgxGa5X7Fx99jYGTbqs3pefeVu/MCNB2BZwN8/YKs1SbwfZCA+25EUG7PvCk10RU2Iu5T5azjSU0cAAAeNeZZlQ0Ry4pB4zrkEPi3qUDtd5/trme7G2j6PjZ06rOA4C8wHlWr3KTZEdAq2T8ruiMoiFXFxGC9mUbMCSlFyvo1kHk7aFZXNs++JrOlRGurLsAHin2PmsaFSVDjzsBIvUZbavVv+GS99abyVmOeYuqIKRkcQbU/wdu+1jhrFJmVYMMxusFIkqWKJZ45tEmhiEwQqRTkybDb3jKh+XDTD9vPJHvls3BQbIjZOxWahysL5Ups8nI+wn2fZzK027YW1X7ER7ftOYmNn2AxHhfvv33s19vPk5kI2hbfccCDgFf4gA/HJVgmAwRb8/nKUj2Kjithg8ggA4JAxj6XFBTv8cMIus51NMGuMFJv5pgEr7VOO6vPYxDW2uiEliE2fitIiYmN3tsVJHSYwxYZKUQHExkgDmbwy83CmGEBsfAZgRlXFnObhcIpNva1g0eVEpWS0RLnQFX3dX3HC+eTtFdB2T62WwUtRKx1SbJJ5bICQYxUk8rgdBmACmtgEwy2cb2lrKjYPNHhpwE2xocW/T7GhMtSuTR7OR6By2dmVhlhwBzw2LooCACxxxUZlq7eM0UIWH/uB6zGaz+CdL70oMbEQLd/Vrt3yTf4WgotiszYkYnPQuID6PI8TKE07VIxzCWaN0YRsywIsmnflRmw8uqISpQ5zpIqMuGQ7fWRDKDYT4q44qcOEsUKIUpTIkhkBDEOZeThfZOW2vNlE1+0qn0pR0vR022MTvd27ISZ8h2z3VtIVxdu90UYjTCmKxik0Y57jjJ2bU/VTbKTy4nI7aSnK/v7KI0T6sGSUJoP2Vs6wAYCtTcvWA6KDZlCx2azDL/txkLd8P9rZB+ThrthQvs3UxY6758SCtPnLUACEIrJQbaM1dpiJ3XJ2T3PNVjH61CnVc6LccPPF03jog69N1n7MsUuE9LWYn6W+wIn4tfaTSD2Rp2wnUBRcwZWZA8YFnFp4lt1HpJIjSWRAJp3CeDGL1UYH3dwYcvULHooNJwL9HhsFik22xIhNrluFaVp2iYn2QxowGqcjiuAoRbWrzEuU6rugEMoUVxNU5LsAyPEOnqLRRq3dw3ixb7sdp4oBxD/HY5EVm5Iak7RQUAIUm47TTyRKUVHfS+TpMdqouI3jIEjlOHsIZkxyYRgsfLTXCkdsBHmUVbGtTQ02/yX4RkNku9hlCzIPb/ZWb0Iuk8L+ySKetviYgeo5Z2uwaQJLfPGfvtTx2rkYgws3EuPFrPhCOJvh6lP1nL0AkUm6OOlQFIDhjFNwgwpSAwC7+H5eqLZso27tgv0Ey7L/L3UoLXFz62SEuH9fcOVr1GigvPAQu6+f2Kwkiwwgstn2mvBtmrbCwf+ucdUEN+TKjBiOGnVU5St9Mg/LpagE53esmEUF0jnq1Aaf1Jd0TAt+0vJBtsB+Xwktx3BLe7suik1Mj81YMYs6V6Ysv9lUfNHtpfNiirgK83DO6KHV8mnB7ktYjl2KkspC9YYfgbOJTYsTm0RdSfK8qKBSlNTuvV0UG01sgiA8NqyjqNMz2SwibB3FBgCOTJdRRQnVEl/s5x60H1w9xb5AUlmHLwJA7OyRjYJhGNjHVZsz9azdzbbwFLsVZajBNmthHh6Sx0Y1ZnlX1Pxay/YLUekUYIs/dc9IxCaJouCKbAFrBebfumrhdnZfH7E5txZfsQHssk4jzY3S/YMw21XmMQIEyVDpsSHFZhR1QZgABJiH4yk2LWTRo69mt3JUH7FRZR6m31dEy93o2qdiAPY5Ho/hsaEp5t3mmvcTuWLTTtkXG4mGM0rG504jRE5Q0lJU1v7ebNR9tsf9NVYqCxMpFLPpyMZzBxxjFYIUG7u1XdV4jo2GJjZ+6HXtIYq8bHFmuYGeaSGfSW0JMy3hCCdhJ4tXsTtO32c/uMgX/amLgbTzDb3VFBsAgticXWkAM5exOylx2cNfA6xPKUolZMXGIuIie2xIrcmNOr5gk3hAvLCy60YAwFSXb//gzeIxFs4X32MD2C34dZrw3a/YENFJZe2hhcLYqkCZ4h6lcaPmnPDddDEPxxinQGC+JwMNg5MHt86o/lKUouneIrzOaDnJm9iuk1CxIaPxFJtiNo2GwaeJN4MJBqkY2bQROS7AgXQOJl/2ui0/BcVJ4qpxyWM6K8ZxNBp+M7jY96zJ37uJFZMoYxV4NxayBVGe0+bh7YzKHEuuTWXFFfEzF9iH8OJdI8kY9TrjCB+G+ajBF/ozErFZeJrdEgmQICYyb4EMG8J+vq9nVhrAND8m8hUtH2e3rsSGFJutQVh3cWLd7ppo5vkgTDdi0zezSSg2ColN+8CL7P+kssDhl4j/LtXaooywO+I4BQKpS54TvmWCwUt9a9JIhcTgHqVx1FhWD6E1WIpKqtgAsNOH3UL6REmIfabjkosBSKm8YRSbWrsnUmqjGrQNw0CPe3V8iQ1XEyjML7H3wzDQS7P3oOmX7Cwye5wjFUZinOMuV5tafsSGH6fJu/4SqVJANMVGSrGu63bvHQDyY4zvFwY+IjaX7No6ZSjAHtb5jRYLisOpu+2QMypLzV418LotqdiMS4rN7qvZnXPfYbfnH2G3u650vKbZsdNit0opqpBNi0V7Nc3nRVGgJOCaAAzYC69KYpO/7FXiZ+vQC0VnEgAcPc8+MweniijE9A2QurRqhSA2HHYpSoViw87vhFF1tu26mYcTKzbw74ySlBPTtISxNXEQIaXyooVKs+2yXafvhFSdTMpAIRtjKeHExvKdicW+f6iDKmm6MgD0+BTznp+3R5ViA6DLiVTbz2PDVZNeiis22YTHGcVj05U8Nlqx2QFwyXZ5Zp59qVyya8TtFZsWpNh8aXUfrNwI65Y5xxf70/ew2wMvcLymJ4XzbRWPDSCVolYbwH5WIsGZ+xmRm+Pm1r3PcbxmkS/2uXQKo1uovkzl0IU0V2xWz9gPuhiHgWSKghf2Hr4cP9j9EH6j80M4+7IPOx574hxTNa7cE33YJ4HKg8smEZsV5xNciM0wFJtJVLFalxZ9t1JUjczD8YlNxSRi41+Kqra7sGKqJgPgi3jGMFFruGTZ9HVFyXOiYhniify2g5WMhlBskisJFhl622GGbzqTh+MQG1JhOiFKbqTuxJ4TRZAVm7Dt3lKOzVYegAloYuMPke0iERtSbGa3FrE5MFlEygDW2gbaB3mZ4Jkvs+6oRV6KOnCj4zWL1Ra65tYJ5yPsnyTFpgnsvoZdvbRWgWe/whbEVGZAsbHLUDllXUvrASpHzVmc2KydgVjpXIiNZVmJFAUvZNIp1HffgE/2vg8PN2Ycjz0xx67Ir9ozGvv3E0lY6PJFyWu0AScYpmmJq2wVOTYoMcUmb3RQq0kKg2tXVLJ2bwBYI2LjFtInhceRKpVLp2KrYQLSdPJmzcXQ26fYJDVnpzixSfVnA8ngik3N5IqNgosOi5MVy7fN3KsUFYfYsL+lr6eHqyZEbBITOGmsQjNCQJ/oitpCF3du0MTGD6IUZYfWbdVSVD6TFkrG3MxL2Z2PfBZ49g7289Ql4subcIb7a2ZHC8hsgXA+AmXZnFlpwEplgL3PZQ98/VZ2u+sqR4gVwLNgsHXKUIRdo+wL7FR3AoDBvqQofdhlyna11UWnx4iPSsUGAK7kxOXxOWdpQSg2e5MrNvMdL2Lj7E6SlQwlik1uRJhAW2tSurOYns622+z0xLydiZjt3gDs9OGAUhSVg1TMw0I6g47B2+r7p5gDA+WZ1XqyoMdUgb1fUn4Egy+6VZMdn4pSFO2/73Y7Th9TklIUkYxOK1ghovNfTFyKIsUmIHnYstzTnbVis42xxMPGppgvZanWFhkVF89sLcUGYMMwAeDB8VezD9v5h4G//TH24DVvGni+GB2xRRKWCbvHCjAMZqpdrLWBK7+HPXDsLnZ7ySsHXiPakWOaWzcK1Bl1vm7aLd9EyEW4pE1sqExSzKaTy919uIoTFyIyACtnPnmeLc5XKlBszjVppILXzCZnq7cSJQMADAPN7AQAoLXGh41alk0iS0ylIrUmkzJilTTT/HU1y8dj03EhNipUKQCdDPuOaNf8CBX77ks6miPDk46zXb9uIfYdVO2pK0WJDsFumFJUEZZlJSM2fHtmiLyeFic2SVOkHR6bts+sqF4bgCVeoxWbnYBFIjaXALDVmv0TReWLwnqARkAcXcsA1/1H54PP+5GB5x9bYF84F22hvB6ABRKKAZErDeD6t7K5OoTnv33gNee5STpu185GgbJsLqy1mMkdsH02orX9iHj+0hDKUIQr9w4qNicWa2h2TBSz6US5T6TYnGlxYkPp0QShnDBio1TJ4Ojm2e9uVTiZaVftnCA+0oIiAybL8UuaY0HzoiSCoTKrBwC6GUZaem7ZMn2hdSsJiU2+yIhw2uoAXRezMiDKX5WeulJUKs/2P+1HbKRJ5q2uiR5v/4pTijKI2HSCiRS1tSc2vEsem7rf6Ah5AKlWbHYA2nVgjZuHeRrvM/Nb019DoCybE4t14HX/Ezj4Qsbsv/t/CVVKhphiPrO1FBugL8tmZBfwPf+LZau87P3AzKUDz9+K3V9AX/owlUxXTzM1gWZkSa3tYpyCqtRhCVdxc/DJpbq4wiWSc/meUaQTxCMIxabLyVH/sM++tmulHVEcFp8HZVJqd40rN9mSWOznK0SQ43vSHIMwg0pRkoFXBagF22r6bJdKUUmJTUlS8NwSls2eUFVWe6RkKCA2XHHKWU20ux5qhlR2o/eSYQClGOpfKsf+lpYfseEEo2kRsVHTFZVDR5RGXSESjw0gnds2XVFbe++HieVj7LYwLrwnW9VfQyBic2yhxo7rx/4N6LUc4W0yjvFS1FZTbABGbB44uYIzPMofN76D/fOAnYy7dbq/ANs8fKHSAg5yArP0LFM06Gp/wja/D6MjijBZzmHPWAHn1pp48lwFNxyeFGWpJMZhgF1B5jIpLHW5T6ddZV/K2T7PDScfFZUdURwGV2UMmr9FBIcGkAI4v8a8WrtH4xPk8WIWVZoX5doVRcSmhLVVtaUoiy/6ri3YfQF91B02UYq37XKphJaVQd7osuOU5pkBcMyQWunS/KTkf890nvJ62mi0e8hlXK7vpVKUPKMqTnZZmpNeo9OEZVnuSh4nNnXe/aVSsVnwVWykhGXD0Dk22x5iKOQlIvDrmQtbs9WbQC3fJxZrsCyLZfN4kBp6HrC1RkcQ9suKTQicW92iHhuZ2FCn14XH7SDCkd2Ov/EwOqJk2OWoNX6b3F8DsEC3qVIOFRRhpviXfn3BfgJNMed5MvZwRnWKTWaEXeBkWivs80PbdxAb9j6aTfA+Gi9mUaMcG9eAPmr3Vl+KMninkuFWAus3DydUbEYLGek43WZiEbExsNphC21i7wlsolE0WmKAqAOW5TjWpCMrMnn2+ctaLRFUOQCunNRNdi7jlLycG5U9Nn6KjXN0xHZRbDSx8YIYCnmJuMtWbLYmsTk4xVq+a+2e6ALywkq9jRVulD6yFUtRvKQUmdhssVIUeYkWa210p69gd84/4TkTa5iKDWBn1ZBSo6IjisDImIFOnl/Z1yRi06eeKM2w4ciP7wEATForLH1YGIddFJsEpajJsqzYuBAbUnGGUIoyeHeXawt2X+IxeWwmivHeS6MFexCmq5eoY5e+qm0aG6GiK4pP3EbLvUzTbUIYanN2KSou2chwhaiADiotjwnfXDmpcWKTeCK9pNj4TzF35vXY0721YrM9cfNPAD/5DeDlvwCAtXGe4lO9L5ndegoGwFq+qRxFnSpeIOPw7rH8lmTv+yIoNtVWV6S3bjViM1nKCe/KYvFidmdtHjj5Lf6EI47nD1uxuUoyEK81O2Jg7FUJwvkItM/UneRQbOjnMiMZqpUMAMiMs4Gqs8YK8zQRsSnbuT0XuMdmNkEpaqKUkzw2Lgs++YnyY2K8Q+KFkCPNW7Az/Z4Xy3IQDcBWbOKSqtFCxiZwriZp26xck8pBiSGGfbbdjbWyFyYjlaJikioyDxeMtvuoCkAoNtTWrspjk0dHlJfct2uH87W6PREFsRW/82VoYuOFbJGFu+1iV8EnFuswLfaG27VFZgm54QpeEnjynD+xoVbvrViGAmxiIzw2PiC1ZjSf2XJTbVMpAzM8e2e+lQHGuc/mnk+x24PONGmh2AyN2DAC8+S5Ch4/yxbgfeMFjMf0Ycigfa6mJ9gdNU4sLMtWb3jb9Zqq+UkyeDv9rLHMFM+aWylKgWJTkktRbsSGf3YLY0IBUHWcGd6plDPr6Pakskm7Jk1PZ8+hHJu4HpuxYhZ18PPkRuDkctCQFBtqb3aAymLpHJDOCFIVO5Gck4wC2iLBeABcsal2idio89iEU2yKqEvnIvEQzg2GJjYhIZehtlIybT+I2DwRQGy2aqs34QBPH16otgKTN7dqGYpA6sCFahM49EJ2p8m/QA+9yPFcyrGJk4obBhfNlJFLp1BtdfEjf3w3APs9lxTU8r2W4im/pNK01gCTS/xcPbGVDIXEZpQrNljBgqzYSMGW5LFJEhswUcx5l6J6HXvBlxUbRW3tuRI7tyNoCKXCsR9GWq3HxvLz2Nhm5ZpKU6s0xbzR8VFs+PMqCT029HsKCFZs1rqKFRvDQ5US25XJI89+yqSQ3UKBrG7Y2nu/jniCmyG3qr+GcGVoxWbrtnoD7MuWvhxOLvkEYwGYW2VfZFuV2JCBeH6tBVz7FvuBwjgwe7XjuZRjM4x2bwDIplO47gBbHDs9C/sninjHSwejBOKAfEHL4GUtUkxE23VZXI0PoysKo6TYrODCWhOonmf3l1kAYrdnMsIDO18oDiZKWe9SlEx08qO2x0YRgaNSVNloOhdh2m5+FDAMWJZle2xiKjbMPMwzXlyDCAcNvGoUG7srylWx6R+A2Uy47axNMipNf4/NWpcRN6WKjdsxEhypw1wV2+JqDaDbvUPjnuMsEOx5hyY2dkcS4grudTh6voKeaXlmi2zlVm+AddEcmS7j4TOrOL5Qw+W7vVWD81s0dZggsmwqLeD5rwamL2Ppw6/7dTGVnrA8hMne/fjof7wedx9bxA2HJ5UqnFO85HbB5H9LUmyE18UuCQ3DY4MRZh4uGS2srS4BKzzhmbfTL9baMC0gZQDT5STmYUmxaVfY8Fb6O5K/JlsC0ln1eT28K2oEDaw2OhBBAYLYsO+PWrsnQuviKjZjhSxqvBTVbqxh4NMnKzZi0VVbilp0K9P0zYkSpai47yWunhTRFurP4DbJY0Pt3uo8No2wig3ft63urwE0sQmFTs/EA6cYsXnBRVMBz97cODRVQiGbQrNj4sRiDRd7KFBbudWbcHi6hIfPrAq/kBe2ajgfQbR8V1tAJge85072QM75tzNNK9GAxrA4MlMW0QIqQft8tsdLUTQyos9fA0B5txAAIFdCK11GvldDe+WsNCSX+Zrmub9m12g+WRhhKYs1cKXUMhmZKU6w/1MicJ6RO+UJy/z3jqBfsXFul8pQuXQKxZgjK/KZFBpcsWnXK/7EJmk5SAZXYkpe7d59CcuJxikA4nNYQgtznh4bZ0BfYgLHFZsC2qh3ejBNyz2Dx02x2eIdUYAuRYXCI2dW0eyYmChlcekWL0WlU4ZQL7zKUVu91ZtAHWDHF31m0UD22GytcD6CGKtALfy58gCpAdhizy+yMTFEYjMskMp0ojPB7qDREaIjyiY2SQc0eqFVYGWnkZUn7S4hnviswl8DsL9NCzk0+CInxkUADuXEsizlpSjkqBTVcJZN5FIU2HcEwIhjXEXOMAx0M+z7pdvwHuFgZUtqF92c7Xlxbffu99gkLUVRF5bR8jEP81lRyGEkn0lEjAFIPqI2LAtodj3KUZI6pbTct8HQxCYE7jnOMjJuPDwVK3lys+GK3f4G4uNc4diqrd4EGt4Z5LGxU4e3ZrcblaLmA7KJqCNqNJ9xT1vd5CBi81STKzZrnNi4KDaL/FinFZfc2uNHAACXVpgxmgUgMiJzXkGrNwBMcDK2An4RJc/FkpSTVtcU7bnKSm6cuIyi7u2xgWwcTrbdHh+62W14t3t30vb5VOuxafm3e/eVomKH5vExFWU0vT02/FgbyCmaRm8fIwBvnw3NipLJ4xb+zidsvW+3DcC3j1EZajLgmVsDdmeUy1USgOMLW78MBcRQbMa2pmLjSB/2gShDjWw9tQawic3RJjcPN1dYuYJMvCO7ALDSMS2804qjGcxdVwEAbmjdw+4Yt8dVUKt3EuMwAGTSKYwWMli1+OePUpUBR6s3laFShsLFiM/aGjPqvoqN3eqd7L1k8kXf3TzMPredFPtcplMG8ioIOScsJcMjoE/MxGL7Vk3a7i1yc1rOTjMZ/FjrVl4NsRHlNvaZ9+yMkkgcleW2eqs3oIlNIEzTwr0nmGJz05Gt7a8hUDqsVylqq7d6E45wxebMcsNz2F2r2xNX91vVY0MKwfk1NovGC0u81XtYqcPDBnXfVKwSTD7TCKtngGUa9slSlskgnTJs9UMVsnuvAQBMY4Vv0x4wSuF8SeZEESZLOayCiI2k2NBMLKkjarSQVackcy/PGOqCOAHwUWySnV8a4WC5zsRiKkY7xc5nOZdWY0SX2q/rrl1RTsUmcbs3V08GOs1cttlAQY0RXPIRAT6KjWQepnOhS1E7AE9fqGKl3kExm8a1+8c3eneUgBSbE0t1Vyb/wKkVx/O2KnaN5lHMpmFawOll93IUGT5zmVTsttWNxp7xAgwDaHVNUW5yw3p0RA0T2XRKLKSd8j5259oZe4r5JCM2i9LYCNWl45ED1znvoNwgqAnnI0yWsrZi4+qxGcfaMDq/uGKTNXpo1iVFt2UTKkAep5DsM5MqcILqGtDHLrCaBic2qhbcwFKUsyuqyglkfI8NO8YSWt5dUZzE1aFKsbE7vwC45/UAEokraMVmJ4H8Nc87NLHlQ4sIu0bzmC7nYFnAU+edXyidnol7+TG/6JJpt5dvGRiGgcNctfHqjJI7orZq8GIukxIzo874jJAQGTZbVLEBbFLWKLLWa6yeHlBsFqvcXzOEklt29xXOOy79LvGjKvMwwEo8dinK3WMjOqJUhhBmS+gZbGHt1lek7VIJjBGfpOMUxOZ4irHRP8IBEIt9k3dOqSM27PdlDBPtlsvnpS/HhtSO2IRDdEU1UWl4XHjw429YOTWdX3ybBbQAWOEUG5XpzhuM7bFSDxH3HNteZSiCl8/modOrqLd7mCxlhcl4K8MmNu4+GxHOt0UzbAhhZmPZis3WVKYApmQAwGqRdSLhxDek7iTKk2FXqUNRprIFfKLwbgBAbeJyx5Dc81K7d1JMlrKSeXjFfoDavQtjQrFR1uoNAIaBdoZ97i03YiO6opKF8xFyJfb70l2XCw/udWnwrBtlC67UMdhruWyXVAxV7d6cIGUME82my+ez2xZJ4UyxUVGK4r4kmGxeVBiPTUsrNjsGFMy31fNr+kFBg3cdXXDc/61nWdjZzRdNb4sOMNtA7K7YiHC+LeqvIYSZjTXsOVHrgSkefDdX5MrJ4//Mbkf2iO6kJdERNZwut69Pvhk/3P4lfP2m3xP3dXumIFRDVWzo5+KklK6slqh2c0xFMV1LYM78nKQem0KZl77ciA3fZoUrNqoGfSKdhclVqV7L5YJHUjFM00o8BNNBpJo+2wPz2Cg5zqwd01HwSlgGPJKHtWKzrWFZFv77916Nd770oi2fONyP11/D5t58+Yl5NKTOACI2L7x4exA56uzyVmy2B7HZH0KxWapth1IUW0hPZLlS0uYLrqScCGIzpO6vXWMFfMO8FidNu718ocryQtIpQ0mL+WQpZys2MsEQ86mmhzMPC4CZZ2QjRUZlYCAYcIWXVJIqNqVRtq2c6U1slnsFvi11f0+TJ/OabZfPS9v22NSlOXOxS1GpNEzesu43OqKHNDrIqPHYpLNAiv1tSl5eIsCR2SMUGx3Qt71hGAZef+0e/PfvvXpL57m44dr9YzgwWUSj08OdR+cBAO2uiXu5QvWiS2b8Xr5lEOSxofuJGGxV0P6fWfYmNoLEbeGyGyk2T+MgkJI+k5e8Wvy4UB2uSXqGRlhU7fZ6Uv5mR/NKlM7JchZrbu3eDVYaR3FK6opS+91kEbFpS8RG2i6griuqzIlN3mqyKe0yuJ9oqcv+jpMKzf0WVzRcvT2SYkOBepmkreak2nTqYhSFACdSLd79pUyBoywbo+U94VsrNhrbCYZh4JZrmQHzXx9m0fQPn1lBo9PDVDmHy2a3dsIygYjNqWWXLxQAj55lX95X7R1b1/1SDeGxWfUmNtQZRpPPtyJIsbnQsIAjL7MfuOK7xY9LvCSkOpyP4JYbJBMbFZgo5bAI7nGrSeXiOicYpSlRilI6NgKAwVu+s21JXZC2C8jEJtk5Hh1l20rDtBdZQps1Niy02TZUKjYWz6hJddy6sWwVo9qyO6KSNBcY1PKN5mCWDSdSLe4lUkZUs3Z+jmtej7RtdqzaY6OxDXDLdXY5qtnp4ZvP2GWo7eCvAYC940Xk0il0etZAmWah2sL5tRYMYzsQG3a151WKWmt2hNl0/5YmNuzLf6neAd78h8C+5zNSM3uVeI5dihqOx2aGl7hIGQKA8xUK51Ojhk2WsliweLwEBRBalkcpSu0Vdro0AQDId9fs7UreHsA2DydVbMbHJ+z/tN0nmc+31Ss2VFJLd6qD2U9Su3eVe1OSdioZ1PJtuIT08e01eFu7kq4owNHyXfcMBrQVm2rShOVNBE1sdjCee2ACe8cLqLa6+Iu7T+LfHmHKzQsv3tpt3jLSKQMHp9gHvL8c9dhZ9sV9ZLqs7stkg0ClqIVqG83O4NUZlaimyrktXVYlxWap1gJGZoF3fwV4618C0tX04pBLUaTYzK/ZRm0ilKoUm8lSDhesCfafxhLQ67AFkCLwS9Pq50RxZMpsuyWzhk6PD+G0+HuqOIWeaYmguaTEZnIkjwqfZN6srtgPdFtAj/0dz7fYNlR6w1I8GLBgNtDqD+8UQzDLohSVWEWRW777xyq07dRhti21pahSqFJUyVYAFb+fNgKa2OxgpFLMQwQAH/qXx/AoX+hfeun28NcQaIL543PO1nY63qv3bW21BmALTJlLyG6qzWlObLZyGQqQ/C0+4yOGNSeKcBmPQXhqvirIBWU/XacoxHOilMUyRtC1+Fd07YKt1qTzQK4syIXSdm8A2TIrN00YFbYNKkNlS0C24EgkTkpsRvIZVPgk88rKBfsByWQ7V2fHpzJAM12gYZ9NZ8Iy4DAPy6WoRBClqNZg+jAnUjU+9FRdKYqCCNs+5mF+rJmCIHFb/SIP0MRmx+PNzzuAdMpAOmXgP1w5i0//2E2CCGwX3HSEyefU8UUgf80124DYGIYhZdkMtnxvB38NYHevzVdaTE3owzDnRBH2TxRx0UwZPdPC3c8uodbq4oGTKwCAlyi6KJgs5WAhhUXw92Z13lGGgmEMJ6APQHqUTTCfRoVtQxiH2eeIzm8pl048TNUwDFQN9n1TW1uyHyBiky1jscHUBpWKjcFLUWU0BDkVoJJYbkRZKYrSh4tGazAdnKsmVZMdn7K/p5Sw7Nru3esAJjv2XqYoVJ3tUIra+kegkQjXHRjHv7/vFRjJZ5QEi21GUGnt28eW0DMtpLl/iEpR1+zbHqMy9k0U8dR8FWdWBjvAbMWmNPDYVsJMOY9s2kCnZ+H8WnPgeIY5J0rGSy6dxrGFGr7+9AL+v/bOPD6q+ur/nztrJttkgyyEAGFHVhE0bCJQKViWX90AFRQbtdSlCCrWNuJTKLV1w7o8ltqKT6vWx9+j1ioPKC7VH1gpsq8iQhKykmWSTCaznt8fd5kJW7Pcm8l8Oe/XKy8ydyZzvx/uJPOZc873HKtZQiBE6J3mQO80ff5/421m2MwmnCYnMqV6OWKjptvi5ddzg0F9bJAgG5sMySVHF1rU+ho5kqPXOAWVFnMiEAS8DREfPLS+OYmocxnQpkBJRSWiBS7PGdEMdbyDPUkbp9DpN3truHj4LGOjpKLcIYMiNpIXVReaYg6gKRS+lnrvsosGHLFh0C8jQVhTA8jGJcluQaM3oEVp3N4AvlN624gQsQHCRcHnatInSsTGZJK0qI06lT0SI+dERaKma784dhrblKL7Cfn6pXAlSULKmQXE2s4kOXJiVCoKCbKOdKlBrrtormt1Xr3GKah4LfLvn7cpcnSEbGxCtiS0+OXIXIqeHbOVCEqC1NI6YhMKhXsj2ZPCBbWdrUtTjFQCPKhpOiON6g/PiQJ0jJioNTbn2xWl1mtBQlNATmPbzCbYLbwrimG6PWaTpHWOVtNRh8obQCQPLMwwKGXR1VyoSZ86QyrW+/UA8k43ACg7h7ExujmfSkF+BiQJOFbVhL/vKQMATBigb9F9arwN1UiRbzRVAQ3yeZCYBX8wpL1Z6V7smaimolznTEXVN+vTnE/Fb5PTQgH32amogLJl2WKSkKRn7YeSikqEp3WNTWRfm8hUVGfNhj1c0xO5m04+p2JsyI44q0m/mYTKrqi489XYtNrq3cl5WN2MqBqbvn37QpKkVl+rVq2K5pIYQVEHeqpb2g8IloYCwlu+z9WkT5RUFADkKBGb8nMYuNNNBs6JisAZb8VIpVBYNVh6D41NibeiWo3YNJa3mmIeWYCqe01EvByxsUlBeBprIrZ6yx8O9BqnoBKyyRpDnoiGgIqx8ZvlSEdKvFXfIbWtIjYRb/pqGkoytSoe7nyNjWxskuDRoooa2rBPneZEqSimMF5qOXeNTcRW70a9Um7dhKir+I//+A8UFhZqtxMTxSpcZboHap3NjhN1CARDQhUOq+Q4z92kr7HFr/UdieUeNipZis7yC0VsDJoTFcnEARnYUyq/jgZlJqJnkr4dnVPjbThByhTz2uPhO1LytDeieJtZv0/4KtY4eEyJcISa0FJXAZDSRyehB4CIAZidbM6nQnEpAAApcnSEkg5qMcnXWs/mfABapYZKIyM2WuFwEiBJ+u0UUiNEkkdrIBk+p7LdG3Z9IyatUlEXjtg0dnbQZzcj6qmopKQkZGVlaV9sbBgjGJqdjOQ4C5q8Aew95cK+U2rERhxjo5qW8voWhCK6LKtpqNR4qxB/uC7UjLDWbWwPm0gi2yJMMGAESWqCFd+FFGNTcwyoL5a/T8kzbE6Uiscmp51a6isA1yn5oLMXgIiuwzqlokxKQ0CTN6IdgxKx8Ujym3Oa3sZGidgknlljE1G0DEC/pnWtamzOjNjIZqqJHDpHbMKpqHP2sWkVsdGpX083IerG5vHHH0d6ejpGjx6NtWvXwufzXfDxXq8XDQ0N2tdZXSMZ5hyYTRIuV6I2S17+SutpI1IqKjM5DiYJ8AVDWkoGAEprxUlDAeEam3NFbNT6BaNrbADg0j6p2vygCTqnoQA5SvEdyd3BUXdSNjcAkNIHdUqdi17poDPxx8lGzd9QCbhK5YPJuQCAWp3PbUmQTZTVHzmbSk5/NZnCqShdidzuHbkrytfU6v66Zp12gCnPlyR5zq6xUcxUExz6dpHWUlFe+AIhBM5sjxDZdViLTMV+cz4gysbmvvvuwxtvvIFPPvkEd999N5555hksW7bsgj+zbt06OJ1O7ausrKyLVsvEOmo6qtEbQKLdghXfG6Tb9tzugNVsQqbS0v9URDRD/T7Wd0SpZKs1NueYi2X0nKhI4qxm/Gz2UFx7aS6uHNxD9+dPjbeiGk54TAkACKCQXPvhzNV2hBk1lZ6ULd/mpgqgQTE2SsSmXNl1p0bOOostUa7dsQUiRiooO8Bcyrws3SfSqzU2OKNBn1pjo9wfLpTu5PkjipXrmn2tIqqqmXJTnL4Rk4iRCgBaTSoHcMboCGMGqkYL3VWsXr0ajz322AUfs2PHDlx22WVYvny5dmzkyJFITU3Fddddp0VxzsXDDz+M+++/X7s9dOhQNjdMm7hxXG8cq2pEXloCFl2eZ9in3WjSNz0B5a4WHCpvxJg8+ZOwutVbhB1RQHjg5+kmH7yBYKvtqeFUVNfsdFsyoa9hzy3XsEgot/RCvu+ofDAtHzBbtWhVtkHGBun9gVNAjucIEFIiKcmysVFruNSars7iSJKNTXwwYuimshOrVplwrutWbyDcx+bfpKLUeqLUzp7fpkaIWhAMEVweP1JV862YKTfikKpnxMQWjtgAQLM32Dp1KXAqSncVd999NxYsWHDBx/Tt2/ecx6+44goAwLFjx85rbOx2O+z28B8tXSvlGaFJtFuw7ocjo70MQxnfLw3bj9dg+/EaLLo8D4A44xRUUuOtsFtM8AZCqHR5kZcejrrVdNF2765A1fCleSzyoRibYfMBABUN8jU1KmITlzUY2AuMCe4FJAB2JxCXjFCINFOVo5NRdjjlaFcSRdTYeOoBAKeD8puzcRGbM7Z7qz1sbIkgIq0ZYafPr0Rskk3ydatxe8PGRq2xgQO9DYjYJJhkDe4zC4hbzYkSq3hYdxUZGRnIyOhYId2uXbsAANnZ2XouiWEuGgr6p2P91m/w5fEaEBEkSRJqqzcQHh/x3Wk3ylye1sZGrbHpglSU0ajF4H9omY5FeF0+OPIGAOGxGUZFbBJ7DQEAZEnKVm8lDVXj9sEXCEGSoKU9O0tyuvz33gk3/D4vrDa7loqqCqjGRueIjbITK0HyoskTsUspoutwQ0sAQSVl1OnobkQqCpBfpwN6queUzZT+qSil23FExKYV54zYiBHFjpo92759O7788ktcddVVcDqd2LFjB5YvX465c+ciLy8vWstimJhmdO8U2C0mVDd68W21GwN6Joa7DqeJEbEB5Df07067W9XZRM6J6opdUUajpg6Pe+LRfNdWxIeagB6DAYS7LmfrlA46E0uPQa0PZMi3I6eYd3ZOlEpyWk8ESYJZIjTUVCA9u4+WiirzGrTdOy68G5Ii++dEFA+r9TUOqxlx1k5241VSWzb4YUWgdS+biOJhfXdFqdu95XOdHbGJqLFpFquPTdSKh+12O/76179i6tSpGDZsGIqKilBYWIjXX389WktimJgnzmrGpXnhoZ/VjV5tZ4coNTZARPfhiPER6k4hk2TAG2EUSIqzaruBiuMGAflTtftUQ2dYjU18GuqllPDt/tNanVevNBQAmM1m1Emy0WiqLZcPKruiTnllfbqnosxWhJRdQ5K3Pry7NqJ4WKuv0SNapNTYAGeMVSA6Y7u3/n1sHGrE5gKpKHVbu67dnaNI1FRceuml+PLLL6N1eoYRloL+6VqdTUmt/KlsVK5TmDAzcO6dUWrH5fREuzboNNbJTXWgvtmP0loPhmTJb/5ub0DrlmtUjQ0AbHPOwux65YPmgOkAwnPI9CocVqk3pSIj5IKnrkLuxKvMMSr2qMbGgNdunBPwuxEfcqPFH4LDZo6YE5WoGWVdTLLZIkdQ/M1IjNzyHfACIflauhFnyHZvO6nGpi2pKDY2DMN0Qwr6pwMfAv/v2Gl4lQGC980YGOVV6Ut2ijpWIRyx2a+MyRiaLU7TxdyUeOw/1aClE4Fw/55Eu8VQs7ojrxDWmiPIyOmHMU65h42aitJrq7dKkzkFCAG+hkotDUUmC8o98luUERE4yZECNJbBKbnR0OKXjY1StIw4p347olRsibKxiZzw7QtvcXcjTt/Uotqgj+TXy9k1NhGzogQrHo56gz6GYfRlZK4TcVYT6pv98PiDGJXrxFWDe/77H4whcs4xCHO/Mt5gRC+BjI1SQFwaMf+rwuit3goZqU4U+lfiz+n3aceMSEUBgMcmb/kONlRphcMUlwoiOfKme4M+AJJSQJwMd3hnVItSbxOXom/EBgg36UMzatSxClrhsB0Ek747F5VUlAUBWBC4wK4ohzZSQZSoLhsbhhEMu8WMy/qkabd/OmOQcG0RtIhNRCpq7ynV2KREY0mGcC5jo2o2Mg0FAFnKrqfKhrB5PFVvTNGyz66093BXA83yoNqAXa4VS7Jb9J+HBcipKADJUnO4l4028DNFv67DZ53PHU5Fqc354IDData36N0a3i3ogO/sVFRAeU1Z4rTZY6KkotjYMIyATFTmGI3KdWKqAV1xo436xlrf7IfHF0SLP4hvKuVPvyNyxRmToW7RL60Pp6K6KmKjGqeKCGOjpqL0LkQPOOTXq9lzWhvh4ImX52Tp3pxPxZECQN5mro1VUFNRjlS4lIiNboXLEefTUlHqjiiKQ69Uh74fQMw2QJJ3cznghdt7RsRGmSoesDjQoqSsRUlFiaGCYZhW3DqhL0JEmDc6R7hoDQAkx1mQYDPD7QuizOVBY0sAgRAhLcGGHIPf8LsSdYt+ZMSmzOCt3ipqn5pK5XzeQBDVjXIKRe8aG0rIBADEeSoBVwkAoNEu97fRfQCmSkQExaWlouqV+1JQ1yzXbOmWBlNSXymSO7wrKqLrsO4NNCVJjtr4GuGQvGdHbJSp4i0In5e3ezMM021x2Mz4yVUDhGnKdyaSJGFwllyz8MnhKuxT0lDDezmFMnJqZKS+2a+lCyqM3uqtoEZsGr0BNHkDqHTJb8Z2i0n3PkGU2g8AkNpSqkVs6qyy2TFs675iNJyQi4cR9IeLeR2pWo2NfhEbObXmlNyoa/bLQymVXVhuOIzpDG5Te9l4z97u7VMnqMvXOc5qMiblFwXEUMEwzEXHtWPlnTpv7CjBvtJ6AGIVDgOte9mow0zLDR6AqZJot2ipiQpXi3b+nBSdUyYA0vPkTsdpwSqg5lsAwGmzXPBuyFZvoHWNjccfTkMp9+m+KyoiFQUok8OVc9ZTojEfQiIGYbrPE7FpIvkxohQOA2xsGIaJUeaMykGc1YRjVU34YF8FALEKh1W0AuLa1sbG6FQUAGQmy3P5KhtaInZE6W+o8vv2QxPFwYwQUCL3NyuHXHdjXMRGMTZolvsCqWkoezJgMmsRG6dDp/MrEaIe1vC8KLVY2UUJxkRslF42DsmL5rNqbGRj00iyPlGa8wFsbBiGiVGS46y4ZkQOAGidU0UqHFbJTVEKiOua0ewLaPUg2QYYjDPRCohdLeEeNgYYqpQEO06ZWs8ILA7Jxkb3rsMq8fLOwVSpsXXERjEgLj07DwNaxCbdLBft1jT5NGNTjwRjOoNHpKLOitgo9T2NIdm8ilJfA7CxYRgmhrlxXG/te9EKh1Uit3yrO6ISbOYu+YStFhBXNLSEuw4bNJqjPi58LWF34juvnFbULRV0JglyqitDcsk1NmrExpECfzCk9XbRzVgphilNkiMlp5u8CDbL55QjNgakorQp5i2ta2xCIcAvr8MVlK+xKFu9ATY2DMPEMOP6piI/Qw63i1Y4rHIuY5PljOsSrZG9bIzqOqxS3XOi9j0NnIGdJfKupMGZSef7kc6RKLdByIALDc3+Vj1s1PoaSQKS9epjo0RskhVjU+v2wdt4GgDgNiUhI9GAyJQ6VVzytO48rJgaAKgPyucVZas3wMaGYZgYRpIk3HllPgDge8Myo7waY4jsZdNVW71V1FTUF8dO42C5bDSMiti0DLseAZLfksry5uJ0kw92iwmj81IMOZ8asbFLAQQ99VrHYzhStcneTodVv7ljSsQmISSngGqafPA3yWbKkpBqjFFVjQ082nwxAFp9DSQTXD65102iXZziYXEsGsMwFyU3jsvD9KGZSNd5C3J3Qe1lU1LrwZEK2VwYvdVbZUBPOZVxvDr8Cd8oYzOoVzpm+9ZhvOMUBgdGATiIsX1SYbeYDTkfrHEIWJNg8TfC4jkNNCqTxZOy9e86DGjbveODjQAIx6qaQMpcLHtShn7niSQiYlPf7AMRyQZKNTa2pIhxCuLYAXGUMAxz0ZKRaI/2EgxDLSp1efzY8Pl3AIBsg8zFmRTkp2Pj0vHYeaIWhyoakZcWr6X+9GZAz0R8g9442twb45VdbgX56YacSyUUnwG4GmH31gCN8jmRlKVFbHTdkaUYGzP5EQ8vPj5cBSm+HgCQkGKwsYEHgRChyRuQt3UrHY9hS9AK79nYMAzDMF1CUpwVl+Qk40BZA5wOK8bkpeB6pYeP0UiShCsH9cCVg4wfyxFvsyAvLR4na5rx1XdyJOOK/sYaGyT0BFzfweGtATWWQwKApOxwDxs9e+jYEuROwP5mTMwK4cOKEKy+BkACnGkG/f8qxcNOk9xcsc7tl42NFrFJ0CZ7s7FhGIZhuoz/++MJqHX7kN1FRcPRYnBmEk7WyNuh46wmjMpNMfR8piTZUKSiHtQQNjZ1JTp3HQbkSuTETKDuO1w32Ip/VPgQL8mGIz3DoPowJWKTZmkBfEBtsw956fHhDsv2RK32RqQaGy4eZhiG6ebEWc2GdPztbqhjMgDgsj5psFmMfYsyJ8mGoofkAprUVFREjY3ePXQS5fNNyQ4h0yoXgodIQmbPnvqeR8Uub5l3muVz1blbTxWHLRFNXlkr97FhGIZhGJ0ZFLG1u8DoNBQAKbUPAGCYdBImr1yY3brGRucoRqJsYBy+GvyfgfJz1yIJuWnG1C2pEZskSTE2zaqxUVNRiWgUMBXFxoZhGIbpFgyJiNhckZ9m/Al7yDOqJpr2y7etCYA9yZgaG0CL2KCpEnPyCQBQhXRkJBhU/G5XG/TJPYhq1YiNV43YRBQPC9THRhwlDMMwTEzTLyMBA5Ut5iMNrq8BAGQMAgDESbKRQVo+IElaZMOoVBSaKjEgRx4H0jO3H0x69co5EyViE09y3VI4YhNhbLSIjTg1NmxsGIZhmG6BxWzCpvsmI0SA1dwFCYWUPPgkG2ykvOH3Hg8AEREbvY2NUkvTVAU0yH1zMrL76nuOSBRjExeSjU2tWzFwLS753zinloriGhuGYRiGMQCL2WR40bCGyYw6R9/w7d6XA0BExMagVFRjOdBQJn+fnKPvOSKxycbGFmyGhJBWO6Qam4AtCb5gSF6aQKkoNjYMwzDMRUvp4NvCN/KuABFpERvdjU1qX/nfmm+BhlPy90kGGht7uGYpAS0RNTZyoXSLOVG7XyRjI44ShmEYhmkn9stuwm3/rEWmPYBfp/ZBg8evRTF0T0Wl5QMmi1zjUvov+ZiRERuLHTDbgKAPyWgO19goERu3JBubRLtFv5lY3QCO2DAMwzAXLf17JOJTGoM3PONQ0+TFvlL5Tb93mgMJekcxLDYgrb/8vU8Za5CSp+85IpEkbfimU3Jr/XlUY1MblEdz9EwWayQJGxuGYRjmosVhMyM3VX6DP1bVhF3F8sTtMb1TjTlhj8Hh7xN6ylEcI1FmVKVITahzy4MwVWNT5ZcNTWZS1wxV7SrY2DAMwzAXNQN6yCmZb6qasLukHgAwuneKMSfLvCT8fd4VclTFSBRj44QbgRDJ07wVY1PulQ1NVhdNi+8q2NgwDMMwFzUDlY7Hx6qasEsxNmPyUow52dhb5TobABgw3ZhzRKIYmx4WpZdNk1czNmUeuTg6M1ksY8PFwwzDMMxFjRqx+fhwFWrdPtjMJgzLSTbmZElZwD07gW8+BEbfZMw5InGkAACybPIgTFdDAxCSe9ecdMvGJkuwGhs2NgzDMMxFzYBM2dgU18pRjUt6JcNuMRt3wtS+wPhC454/EiVi01OJ2DTWn5aPS2YUKw2IORXFMAzDMAIxoGdiq9uGFQ5HA8XYZJjlwZfuhlr5eJwTlQ1eAOKlotjYMAzDMBc1yXFWZEakYwyrr4kGirFJlWRj09IoGxuKc6KqUTY2HLFhGIZhGMGIjNoYtiMqGqh9bCDnnQJNNfK/tmQEQgSTBPRIFKvGho0NwzAMc9EzsKe8Myoj0a71tRECJWKTQLKxoaZqAIDHlg5A1mvpioGjXYhYahiGYRimA4zMdQIACvqnQzK6t0xXohqboLzF2+KRjU2jWT4uWhoK4F1RDMMwDIP5o3vBajahoH96tJeiL0nyRHGHtwYSQrC1yLuiak0pAMQrHAbY2DAMwzAMTCYJc0YZOJAyWiRmApBgogDS0AiHXy4erg7JEaosAY0Np6IYhmEYRlTMViChBwAgS6pDkl+ehVUWkGuKRExFsbFhGIZhGJFJygIA9JTq4CTZ2BR7EwCImYpiY8MwDMMwIpMsp9gypTpkQC4i/rY5HgCnohiGYRiGiTWUiE0/Sw1SlEZ9R93ylvYsp1g9bAA2NgzDMAwjNknZAIArTIcBAAFLPEpa5EhNT47YMAzDMAwTU6T0AQCMokMAgCPBXAAS4m1mJNnF2xzNxoZhGIZhRCZndKube/29AMj1NUI1I1RgY8MwDMMwIpMxCLCFZ2EdpVwAYu6IAtjYMAzDMIzYmMxAzhjtZqNzEAAxe9gA3HmYYRiGYcRn3I8AVykw5BosHroIxR98gxvH9Y72qgyBjQ3DMAzDiM4l8+UvACMBvHlXRjRXYyicimIYhmEYRhjY2DAMwzAMIwxsbBiGYRiGEQY2NgzDMAzDCAMbG4ZhGIZhhMFQY7N27VpMmDAB8fHxSElJOedjiouLMWfOHCQkJCAjIwP33nsvfD6fkctiGIZhGEZQDN3u7fP5cP3116OgoAAvv/zyWfcHg0Fcc8016NGjB7744gvU1NRgyZIlICL87ne/M3JpDMMwDMMIiKHG5rHHHgMAvPLKK+e8f8uWLTh48CBKSkqQk5MDAHjyySdx6623Yu3atUhOTjZyeQzDMAzDCEZUa2y2b9+O4cOHa6YGAGbOnAmv14udO3ee82e8Xi8aGhq0LyLqquUyDMMwDNPNiaqxqaioQGZmZqtjqampsNlsqKioOOfPrFu3Dk6nU/sqKyvriqUyDMMwDBMDtNvYrF69GpIkXfDrX//6V5uf71wj04novKPUH374YbhcLu0rMtrDMAzDMMzFTbtrbO6++24sWLDggo/p27dvm54rKysL//znP1sdq6urg9/vPyuSo2K322G327Xb5zNADMMwDMNcfLTb2GRkZCAjQ5/hWQUFBVi7di3Ky8uRnZ0NQC4ottvtGDt2rC7nYBiGYRjm4sHQXVHFxcWora1FcXExgsEgdu/eDQAYMGAAEhMTcfXVV2PYsGG45ZZb8Nvf/ha1tbVYuXIlCgsLeUcUwzAMwzDtRiIDtxXdeuut2Lhx41nHP/nkE0ydOhWAbH6WLVuGjz/+GA6HA4sWLcITTzzRKt10IWw2G/x+P0wmkxb1YRiGYRime1NeXo5QKASr1aprY15DjU1XYDabEQqFor0MhmEYhmE6gMlkQjAY1O35DE1FdQVxcXFoaWmB2WxGz549dXteIkJZWRlycnKELFAWXR/AGkVAdH2A+BpF1weIr9EofVVVVQgGg4iLi9PtOQEBIjZG0dDQAKfTCZfLJWS9j+j6ANYoAqLrA8TXKLo+QHyNsaaPp3szDMMwDCMMbGwYhmEYhhEGNjbnwW6349FHH23z7qxYQ3R9AGsUAdH1AeJrFF0fIL7GWNPHNTYMwzAMwwgDR2wYhmEYhhEGNjYMwzAMwwgDGxuGYRiGYYSBjQ3DMAzDMMLAxoZhGIZhGGFgYxNFeENa7HMxXEPRNYquDxBXYyAQiPYSDOf06dOorq6O9jJiCjY2XYzH40FLSwsACDlT5GIg8o+pqNewubkZdXV18Hq9QmosKSnBF198AUC+hiK+8e/btw8PPvggADFfp4cOHcKKFStQUlIi5PUDgIMHD2LGjBnYtm0bADEN6unTp7Fjxw4cPHgQ9fX1ujwnG5suZP/+/Zg9ezamTJmC4cOH48UXX8Tx48ejvSxdOX78OD755JNoL8Mwjhw5gh/96Ee4+uqrMXv2bBQXFwOAUBPmDx48iPnz52P69Om45JJLsHXrVgDi/FGtqKjAmDFjUFRUhI8++giAeG/8e/bswfjx4xEfH9/quCjXcN++fZgyZQqam5vh9/uFu36AfA0vv/xy7N27F8888wwA8V6n+/btw9SpU7F48WJMnToVTz75JDweT6efl41NF3H8+HFMmTIFgwcPxj333IMJEybgxRdfxMqVK7Fr165oL08Xjh49iqFDh2L69OnYtGlTtJejO/v378ekSZNgsVgwZswY1NfX46qrroLP54PJJMav0v79+zF58mQMGjQIRUVFGDFiBJYuXaq9eYjwxlhVVYVQKISSkhI8/vjj+PjjjxEMBgGIYVD37NmDiRMn4u6778bq1atb3SfCG2NNTQ0WL16MRYsWYcOGDcjPz4fL5UJtbS18Pl+0l6cLe/bsQUFBAe69915s3rwZZWVl2LJlCwBxzOmxY8cwffp0zJ49G++//z7uuecebNiwAY2NjZ1/cmK6hCeeeIJmzJjR6thf/vIXmjFjBl199dW0d+/eKK1MH+rq6mj+/Pm0aNEiWrx4MSUkJNDf//73aC9LN8rLy2ncuHG0YsUK7Vh1dTX179+fXn311SiuTD9KS0tp1KhRtHLlSu3Y3r17ad68eVRWVkaNjY3U0tISxRXqQ0tLC91+++309ddf07hx4+iqq66izz//nIiIvv322yivrnOcOHGCnE4nLVmyhIiI/H4/rV27lpYuXUrz5s2jzZs3U01NTXQX2UlOnjxJkydPpurqavL5fHTDDTfQhAkTKDs7mwoLC2nHjh3RXmKn2LFjB8XHx9MjjzxCRPLfmfz8fLrjjjuivDJ9eeihh+jaa6/VbgeDQZo5cyZ9/vnntHPnTiouLu7wc4vxMTMG8Pl8KC0thcvl0o4tWrQIP/7xj+H3+/Hiiy/qll+MBlVVVRg4cCAWLFiAjRs34uabb8aNN96I999/P9pL04Xdu3cjEAigsLBQO5aeno60tDRhCvsOHTqEqVOn4qc//al27PXXX8fHH3+MadOmYcyYMXj00UdRXl4evUXqgN1ux86dO+F2u/HXv/4V9fX1+NWvfoVp06bh+uuvh8/ni9lPxV999RWys7Nhs9lw5MgRzJ49G5s3b0ZDQwNcLheWLl2K3//+92hqaor2UjtMaWkp9u/fD7fbjVtuuQX19fVYtWoV7rnnHpw6dQrLly/HwYMHo73MDvPcc89h6dKlWLNmDUKhEDIyMrB69Wr8z//8D7Zv3x7t5emGx+NBY2MjamtrAQBr1qzBli1bcNddd2HBggVYsGABvv766449uQ7Gi2kDr776KvXq1Yt27txJRPInKZX169dTz5496ejRo9Fani4cOnSo1e0777yTEhIS6L333tOOBYNBcrlcXb20ThMIBOj3v/+9dtvn8xER0dy5c+lXv/pVq8eGQqEuXZueHD58WPv+hRdeIEmSaMOGDbR//356/PHHKS8vjzZt2hTFFXaOQCBARESFhYX03HPPERGRy+Wi9PR0cjgc9OKLL2qPjdXr+Morr9CUKVMoNTWVZs2aRZWVlZqWVatWUXp6On3zzTdRXmXHKS8vp0mTJtGzzz5Lc+bMof3792v3ffjhhzRhwgR65ZVXorhC/dm7dy8NHDiQnnrqKSIKv45jmd/85jc0ZMgQmj9/Pt12221ksVjorbfeorq6Ovr000/p6quvpgceeID8fn+7fxfZ2BhM5AWZMmUKjRw5kurq6oiotbnp1asXPfHEE129PF0IBoPnvX3HHXdoaalAIEA/+9nP6Je//GUr7d2dM/+IROqbP39+q9TNc889R5999lmXrU0vztTo9XrpnXfe0VI0Kvn5+a3ScbHKU089RXfeeScRES1dupR69uxJQ4YMoVmzZsWscYv8nfrjH/9IixYt0tIyka/ZxMREzdTFKosXLyaTyUROp5MOHjzY6r6pU6fS4sWLo7SyznEhw7JixQrKysqi6urqLlyR/kS+Fp944glat24dXXvttbR8+fJWj7vhhhto5syZHToHp6IM4PTp0ygtLQUgF+v5/X4AwMaNGxEIBPC9730P5eXlsFgsAAC3241evXohJycnamtuL5Eazyycjbz90ksv4eabb8bNN9+M2bNnY926dZg3b56mvbsSqc9sNre6z2QyaUWmoVAINpsNAFBUVIR77rkHGRkZXbvYDnIhjTabDXPmzMGkSZMAAMFgEDU1Nejfvz/Gjh3b5WvtCJH6VEhJMeXm5qKsrAyFhYX44IMP8NVXX2Hr1q04dOgQXnrpJTQ3N0djye0mUqPFYtGKoG+77TY8+OCDGDFiBAD5NUtEOHbsGPr164dhw4ZFbc3t4cxrqOrbuHEj5s+fj4aGBrzzzjtoaGjQHpObm4shQ4Z0+Vo7yoV+D4FwQfuSJUuQlpaG119/HUBsFRGf+X6htsxYsWIFVq1ahdzc3LPeExITE9G/f/+O9SrquO9izsWBAwcoLS2Nli5dSmVlZWfdv3fvXho1ahTl5+fTCy+8QG+//TY99NBDlJ6eTseOHYvCitvPv9N4Jl6vl/r160fp6em0e/fuLlhh52iLPjUVNW/ePHr66afpqaeeIofDoaUauztt0Xhm+LeoqIgGDx5MJ06c6Ioldorz6VM1nTp1irKysqhPnz709ddfa/cXFxfT8ePHu3y9HeF8Gi/0qf/nP/85jRo1ik6dOtUVS+wU59OnRqbq6+tp1qxZ5HQ66c4776QXXniB7rvvPkpNTT0rLd5dac/f0mAwSPPmzaOxY8d20er04XwaIyM3q1atotzcXPr888/pn//8JxUVFVFqaiodOHCgQ+dkY6Mj5eXldMUVV9DEiRMpLi6OfvSjH53zxep2u2nx4sU0atQo6tevH11++eWt/rh2Z9qqUcXv99OyZcvIZDLRvn37unClHaO9+m666SYymUyUkJAQM7sx2qvxgw8+oBUrVlBKSgrt2rWr6xbaQdqiz+Px0JtvvtnqDTCW6hbaew3fe+89Wr58OSUnJwtxDSPfFH/xi1/QrFmzaNiwYTR79uyY+PBE1L5rqOr99NNPKS8vr1XdVHemPddx2rRplJSURAMGDKDRo0d36nXKxkYnQqEQbdmyha677jr69ttvaevWrWSxWC54IcvKyqiiokKruenutFVjJKWlpbRs2bKYiGR0RN8tt9xCkiR1+JNFV9NejcFgkNasWUOTJ0+OCWPaHn2x8MZwLjpyDX/+85/T2LFjY6KtRFv1qVFTInkLv8vloubm5mgsud105G8NEVFtbS1VVVV14Uo7Tls1RtaGbd68mXbu3EkVFRWdOjcbGx0pLy+nf/zjH9ofzA8//FC7kJGh38hfyFijrRojDZzH4+nydXaUtupTfxlra2tjIjUTSVs1RkYwamtru3ydHaUjr9FYoyPX8PTp012+zo7S3t/DWIRfp2GNXq9X1/OysTEI1bx89NFHrVxqIBCg3/3ud7R169Yor7Dz/DuNH374YZRX2Dn+nb6PPvooyivsPBf7NeTfw+4PX0PW2F6699aUGMZqtSIYDGL69OnYvHkzZs6cCUBuSvTuu+92vPFQN0J0jaLrA8TXKLo+QHyNousDWKPuGnWzSMxZxYehUEgLI27evJkkSaKUlJSYqDc5H6JrFF0fkfgaRddHJL5G0fURsUYjNXIfm05CSi+BYDAIs9mMsrIyvP322/D5fJAkCSaTCS0tLfjf//1fJCcnY9u2bbj00kujvOr2IbpG0fUB4msUXR8gvkbR9QGssas0srFpJy0tLWhqatKaBkmSBJ/PB7PZjJMnT2L48OHYu3ev1rQNkCcmv/XWW9iyZQuGDh0araW3GdE1iq4PEF+j6PoA8TWKrg9gjVHTqGv8R3D27dtHP/jBD2j06NE0f/58bfoqEVFVVZXWKOrMbaQejydmtnSLrlF0fUTiaxRdH5H4GkXXR8Qao6mRjU0bOXz4MKWlpdHy5cvp1VdfpZ/97GeUnp5O8+bNo/r6eqqsrKQ//OEPMdsbg0h8jaLrIxJfo+j6iMTXKLo+ItYYbY1sbNpAIBCg+++/n+644w7tWHNzM82fP58kSaIZM2Zox2O154DoGkXXRyS+RtH1EYmvUXR9RKyxO2jkGps2YDabcezYMbjdbgDyUDKHw4Err7wSd9xxBw4dOoTbbrsNwNkDIWMF0TWKrg8QX6Po+gDxNYquD2CN3UFjbP6vdiHBYBCBQACDBg1CQ0MDdu3aBZPJhBMnTuCXv/wlxo4di1WrVmH37t2orKyM9nI7hOgaRdcHiK9RdH2A+BpF1wewxm6jsctjRDGCGj5T84Pbtm2j4cOH06hRo2j69OnkcDjozjvvJCKi48ePk9Vqpe3bt0dtvR1BdI2i6yMSX6Po+ojE1yi6PiLW2N00cufhc3DkyBH84Q9/QF1dHXr37o077rgDBQUFeO211/Dhhx+ipqYGS5YswS233AIiwunTpzFs2DDk5OREe+ltRnSNousDxNcouj5AfI2i6wNYY7fUGBU71Y05cOAAOZ1OuvHGG2n69Ok0fvx4SktLo/fff/+8P/PAAw/QmDFjYmbInOgaRddHJL5G0fURia9RdH1ErPF8RFsjG5sIAoEALViwgBYuXEhEcsitoqKCli5dSg6Hg9566y0iCofkvv76a1qyZAmlpKTQrl27orXsdiG6RtH1EYmvUXR9ROJrFF0fEWvszho5FRWBJEmorq7GpEmTtGOZmZl4+eWXERcXh1tvvRX5+fkYM2YMvF4vLBYL7HY7/vGPf2DEiBFRXHnbEV2j6PoA8TWKrg8QX6Po+gDW2K01Rs1SdVMWLVpEY8eO1Qqk1CFewWCQ5s+fT5deeim53W7t8eoo9lhCdI2i6yMSX6Po+ojE1yi6PiLW2F018nZvBVIGd910000IhUJYs2YN/H4/zGYzAoEATCYTCgsLUVtbi5KSEu3nrFZrtJbcbkTXKLo+QHyNousDxNcouj6ANXZ3jWxsFCRJAgBMmzYNkyZNwnvvvYdnn30WLS0tsFjkjF2fPn0AAF6vN2rr7AyiaxRdHyC+RtH1AeJrFF0fwBq7u0Y2NhH4fD7ExcVh3bp1GDt2LN58803ce++9cLlcKCsrw2uvvQabzYbs7OxoL7XDiK5RdH2A+BpF1weIr1F0fQBr7NYao5YE62aoecMTJ07Qf//3f5PX66V169bR6NGjyWw204gRIyg7O5t27twZ5ZV2HNE1iq6PSHyNousjEl+j6PqIWGN31ygRKYm0i4Tq6mqUl5cDAEaOHAlAbhFtNptx8uRJTJw4EQsXLsRvf/tbBINBeDwefPTRR8jIyECfPn3Qu3fvaC6/TYiuUXR9gPgaRdcHiK9RdH0Aa4xZjdF2Vl3J3r17adiwYTR8+HCSJIkeffRR7b7y8nLKzMyku+66K6ZHyYuuUXR9ROJrFF0fkfgaRddHxBpjWeNFY2y++eYbyszMpEceeYQOHTpEf/rTn0iSJCopKSEiooqKCnryySfJ7/dHeaUdR3SNousjEl+j6PqIxNcouj4i1kgU2xovGmPzyCOP0A9+8APtdmNjI82ePZt27txJn332GTU1NUVxdfogukbR9RGJr1F0fUTiaxRdHxFrjHWNF03n4VOnTsFkMsHv98NqteLZZ5/F5s2bUV1djcOHD2P69Ol4+OGHMX78+GgvtcOIrlF0fYD4GkXXB4ivUXR9AGuMeY3RdlZdxcsvv0wmk4luvvlmuummm8hms9E777xDLpeLdu3aRYMGDaKioqJoL7NTiK5RdH1E4msUXR+R+BpF10fEGmNd40W1K2rDhg0oKyvD3r17kZWVheeffx6hUAgmkwm33XYbTp48iS1btmjNh2IR0TWKrg8QX6Po+gDxNYquD2CNsawxtlbbRo4ePYqXXnoJdXV16NevHxYtWoT8/HwUFhYCAJYuXYoePXoAgHYRvV4vLrnkEphMsdGzUHSNousDxNcouj5AfI2i6wNYIyCGxlZEO2SkNwcOHKDk5GS65ppraOHChZSRkUGTJk2i//zP/9RGq69Zs4YcDgdt27aNdu7cSUVFRZSRkUEHDx6M8urbhugaRddHJL5G0fURia9RdH1ErFEUjWcilLHxer20YMECuv3227Vj1dXVdP3119MVV1xBTz31FAWDQaqsrKQFCxaQJEk0dOhQGjFiBO3atSt6C28HomsUXR+R+BpF10ckvkbR9RGxRlE0nguhjA0R0fe//31atmwZEYVbQtfU1NDixYupoKCAPvjgAyIiCoVC9Pnnn9Pu3bupsrIyauvtCKJrFF0fkfgaRddHJL5G0fURsUZRNJ6JMMXDoVAIwWAQCxYsQDAYxDvvvAMA2la2mpoazJ07F8nJydi0aVN0F9tBRNcouj5AfI2i6wPE1yi6PoA1iqLxvETbWenNtm3bSJIkeuqpp7RjXq+XiIh27dpFdru9Ww7tag+iaxRdH5H4GkXXRyS+RtH1EbFGUTSeSUzviiouLsa+fftQXl6O2bNnIykpCQUFBVizZg0efPBB2Gw2/OQnP4HNZgMgO9i+ffvC6XRGeeVtR3SNousDxNcouj5AfI2i6wNYoyga20S0nVVH2bNnD2VmZtKYMWMoJSWFevfuTStXrqSSkhIKBoP0yCOPkNlspocffpi++eYbqqyspEceeYQGDBgQM/lD0TWKro9IfI2i6yMSX6Po+ohYoyga20pMGpu6ujoaO3YsPfDAA1RbW0tERI899hhNmjSJ5s2bRydPniQioj/96U/kdDopNzeXBg0aRL169YqZkJvoGkXXRyS+RtH1EYmvUXR9RKxRFI3tISaNzcmTJ6lPnz60efPmVsc3btxIkydPpkWLFlFFRQUREZWWltKmTZto8+bN2tTSWEB0jaLrIxJfo+j6iMTXKLo+ItYoisb2EJM1NmazGQ6HA2VlZQCAQCAAi8WCxYsXo6WlBc899xw2b96MxYsXo1evXujVq1eUV9x+RNcouj5AfI2i6wPE1yi6PoA1iqKxXUTbWXWUOXPm0OjRo6muro6IiPx+v3bfddddRwUFBVFamX6IrlF0fUTiaxRdH5H4GkXXR8QaRdHYVmJiCITb7UZjYyMaGhq0Y3/84x/hcrlwww03wOfztRrSNXPmTBARfD5fNJbbIUTXKLo+QHyNousDxNcouj6ANYqisTN0e2Nz8OBB/PCHP8SVV16JoUOH4i9/+QtCoRAyMjLw2muv4fDhw7j66qtx5MgRtLS0AAC++uorJCUlgWKk96DoGkXXB4ivUXR9gPgaRdcHsEZRNHaarg4RtYcDBw5Qeno6LV++nF577TW6//77yWq10tdff609Zt++fTRixAjq378/XXbZZTRnzhxKSkqi3bt3R3HlbUd0jaLrIxJfo+j6iMTXKLo+ItaoEusa9aDbjlSora3FwoULMWTIEKxfv147Pm3aNIwYMQLr168HEUGSJADA888/j9LSUjgcDtx4440YPHhwtJbeZkTXKLo+QHyNousDxNcouj6ANYqiUS+67a4ov9+P+vp6XHfddQDkDokmkwn5+fmoqakBAEiShGAwCLPZjJ/85CfRXG6HEF2j6PoA8TWKrg8QX6Po+gDWKIpGvei2NTaZmZn485//jMmTJwMAgsEgAKBXr14wmcLLNpvNaGxs1G530wDUORFdo+j6APE1iq4PEF+j6PoA1iiKRr3otsYGAAYOHAhAdqZWqxWAfDErKyu1x6xbtw4bNmxAIBAAAC0MFyuIrlF0fYD4GkXXB4ivUXR9AGtUiXWNetBtU1GRmEwmLXcoSRLMZjMAoKioCGvWrMGuXbtabW2LRUTXKLo+QHyNousDxNcouj6ANYqisTN064hNJGo4zWw2o3fv3njiiSfwm9/8Bv/6178watSoKK9OH0TXKLo+QHyNousDxNcouj6ANYqisaPEjKVTc4hWqxUbNmxAcnIyvvjiC1x66aVRXpl+iK5RdH2A+BpF1weIr1F0fQBrvOgxci+5EezYsYMkSaIDBw5EeymGIbpG0fURia9RdH1E4msUXR8Ra7xY6bZ9bC6E2+1GQkJCtJdhKKJrFF0fIL5G0fUB4msUXR/AGi9GYtLYMAzDMAzDnIuYKR5mGIZhGIb5d7CxYRiGYRhGGNjYMAzDMAwjDGxsGIZhGIYRBjY2DMMwDMMIAxsbhmEYhmGEgY0NwzAMwzDCwMaGYZiYZfXq1ViwYEG0l8EwTDeCjQ3DMDHL3/72N8ybNy/ay2AYphvBxoZhGMMJhUJ4/PHHMWDAANjtduTl5WHt2rU4ceIEJEnCm2++icmTJ8PhcGDcuHE4evQoduzYgcsuuwyJiYn4/ve/j+rq6lbPWVJSgv3792PWrFkA5OhNXl4e7HY7cnJycO+990ZDKsMwUSZmpnszDBO7PPzww9iwYQOefvppTJo0CeXl5Th8+LB2/6OPPopnnnkGeXl5WLp0KRYuXIjk5GSsX78e8fHxuOGGG1BUVIQXX3xR+5m//e1vmDJlClJSUvDWW2/h6aefxhtvvIFLLrkEFRUV2LNnTzSkMgwTZdjYMAxjKI2NjVi/fj2ee+45LFmyBADQv39/TJo0CSdOnAAArFy5EjNnzgQA3HfffVi4cCG2bt2KiRMnAgBuv/12vPLKK62e991339XSUMXFxcjKysKMGTNgtVqRl5eH8ePHd41AhmG6FZyKYhjGUA4dOgSv14vp06ef9zEjR47Uvs/MzAQAjBgxotWxqqoq7XZDQwM+++wzzJ07FwBw/fXXw+PxID8/H4WFhXj77bcRCAT0lsIwTAzAxoZhGENxOBz/9jFWq1X7XpKkcx4LhULa7U2bNmHo0KHo06cPAKB37944cuQInn/+eTgcDixbtgxTpkyB3+/XSwbDMDECGxuGYQxl4MCBcDgc2Lp1q27P+e6772rRGhWHw4G5c+fi2Wefxaeffort27dj3759up2TYZjYgGtsGIYxlLi4ODz00EN48MEHYbPZMHHiRFRXV+PAgQMXTE+dj0AggE2bNuGjjz7Sjr3yyisIBoO4/PLLER8fj//6r/+Cw+HQIjoMw1w8sLFhGMZwfvGLX8BisaCoqAhlZWXIzs7GXXfd1aHn+uyzz5CYmIixY8dqx1JSUvDrX/8a999/P4LBIEaMGIH33nsP6enpeklgGCZGkIiIor0IhmGYtnLvvfciEAjghRdeiPZSGIbphnDEhmGYmGL48OEoKCiI9jIYhummcMSGYRiGYRhh4F1RDMMwDMMIAxsbhmEYhmGEgY0NwzAMwzDCwMaGYRiGYRhhYGPDMAzDMIwwsLFhGIZhGEYY2NgwDMMwDCMMbGwYhmEYhhEGNjYMwzAMwwjD/wezX4llQu2SHgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot by hand instead\n", + "timestamp_pytmd = df_pytmd.loc[mask_pytmd][\"utc_timestamp\"].values\n", + "timestamp_xr_obs = df_xr_obs.loc[mask_xr_obs][\"utc_timestamp\"].values\n", + "\n", + "u_pytmd = df_pytmd.loc[mask_pytmd][\"pytmd_u\"].values\n", + "u_xr_obs = df_xr_obs.loc[mask_xr_obs][\"xr_obs_u\"].values\n", + "\n", + "v_pytmd = df_pytmd.loc[mask_pytmd][\"pytmd_v\"].values\n", + "v_xr_obs = df_xr_obs.loc[mask_xr_obs][\"xr_obs_v\"].values\n", + "\n", + "plt.figure()\n", + "plt.plot(timestamp_pytmd, u_pytmd, label=\"pytmd\")\n", + "plt.plot(timestamp_xr_obs, u_xr_obs, label=\"obs\")\n", + "plt.xticks(rotation=45)\n", + "plt.xlabel(\"cm/s\")\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.figure()\n", + "plt.plot(timestamp_pytmd, v_pytmd, label=\"pytmd\")\n", + "plt.plot(timestamp_xr_obs, v_xr_obs, label=\"obs\")\n", + "plt.xticks(rotation=45)\n", + "plt.xlabel(\"cm/s\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "a3eba025-0ba8-460a-932b-c2c5350896ef", + "metadata": {}, + "outputs": [], + "source": [ + "# a bit underestimated, but not so bad for a global model!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a7235eb-f435-4844-868a-4f54d1b6f0cb", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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": 5 +} diff --git a/notebooks/SimpleScriptGetTideElevationTimeseries.ipynb b/notebooks/SimpleScriptGetTideElevationTimeseries.ipynb new file mode 100644 index 00000000..c6399d93 --- /dev/null +++ b/notebooks/SimpleScriptGetTideElevationTimeseries.ipynb @@ -0,0 +1,890 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "34ea519b-42ea-4ea4-92b8-bd8c04e97670", + "metadata": {}, + "outputs": [], + "source": [ + "# the aim of this notebook is to illustrate the use of the Arc2kmTM tidal model, used py pyTMD\n", + "# and to provide a short, minimalistic example of how to use pyTMD to predict tide elevation\n", + "# note that if you want to use another of the models supported by pyTMD, you may need to do small changes to the code\n", + "# see in particular for help:\n", + "# (tide): https://github.com/tsutterley/pyTMD/blob/main/notebooks/Plot%20Tide%20Forecasts.ipynb\n", + "# (currents): https://github.com/tsutterley/pyTMD/blob/main/notebooks/Plot%20Antarctic%20Tidal%20Currents.ipynb\n", + "# see the Arc2kmTM_README_v1.pdf document, Arc2kmTM: Model Summary, for units" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "32180f38-d38c-496a-b7b1-f1ef1a626b0a", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import pyTMD.io\n", + "import pyTMD.time\n", + "import pyTMD.utilities\n", + "import pyTMD.predict\n", + "\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "efb1ebad-3b41-4f2a-9278-fbbf8b3b8a6b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'2.0.6'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# my pyTMD version, installed from conda\n", + "pyTMD.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8da259b1-fad7-4979-ab65-5a67adec4db3", + "metadata": {}, + "outputs": [], + "source": [ + "# BELOW IS TO PREDICT TIDE ELEVATION" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4dd1fba7-0e3b-4ed5-ac55-31a34dea0656", + "metadata": {}, + "outputs": [], + "source": [ + "# parameters for the prediction\n", + "\n", + "# location: lat and lon\n", + "# can be either a single value each, or 2 np arrays (lat1, lat2, ...) and (lon1, lon2, ...) so that (lat1, lon1), (lat2, lon2), ... are the positions of interest\n", + "# --\n", + "# Ny-Ålesund close\n", + "lat_to_predict = 79.029\n", + "lon_to_predict = 11.178\n", + "# --\n", + "# Ny-Ålesund far\n", + "# lat_to_predict = 79.056\n", + "# lon_to_predict = 9.183\n", + "\n", + "# time: either a single datetime, or a np array of datetimes\n", + "start_day_to_predict = datetime.datetime(2023, 7, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)\n", + "number_of_hours_to_predict = 24*31\n", + "times_to_predict = [start_day_to_predict + datetime.timedelta(hours=hr) for hr in range(number_of_hours_to_predict)]\n", + "\n", + "# details about the model location and format on my disk\n", + "model_path = \"/home/jrmet/Desktop/Data/tides/resource_map_doi_10_18739_A2D21RK6K/\" # obtained from https://arcticdata.io/catalog/view/doi:10.18739/A2D21RK6K\n", + "model_name = \"Arc2kmTM\"\n", + "model_is_compressed = False\n", + "model_atlas = \"netcdf\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ec0d91a9-71d9-43de-b669-55c899ce1430", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0m\u001b[01;34mArc2kmTM\u001b[0m/ bagit.txt \u001b[01;34mmetadata\u001b[0m/\n", + "bag-info.txt manifest-md5.txt tagmanifest-md5.txt\n", + "---\n", + "Arc2kmTM_FileFormat.pdf h_Arc2kmTM_v1 UV_Arc2kmTM_v1\n", + "Arc2kmTM_README_v1.pdf Model_Arc2kmTM_v1 xy_ll_Arc2kmTM.m\n", + "grid_Arc2kmTM_v1 Revision_history.txt\n" + ] + } + ], + "source": [ + "# illustrate how the input model files look like\n", + "# this is simply the un-zipping of the arcticdata model data\n", + "\n", + "%ls $model_path\n", + "print(\"---\")\n", + "%ls $model_path/$model_name" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0de92cd7-f457-48a1-a4d0-380b6bcb70eb", + "metadata": {}, + "outputs": [], + "source": [ + "# note that pytmd internally uses its own time system with a given epoch start - dont mess it up and make sure to convert to it :)\n", + "pytmd_times_to_predict = [pyTMD.time.convert_calendar_dates(crrt_time.year, crrt_time.month, crrt_time.day, crrt_time.hour, crrt_time.minute, crrt_time.second) for crrt_time in times_to_predict]\n", + "model_time_delta = np.zeros_like(pytmd_times_to_predict)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7fa9d9e7-6f2a-4e3b-bf6e-a509b3ea1c7c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tidal constituents used in the present model are: list_time_constituents = ['m2', 's2', 'k1', 'o1', 'n2', 'p1', 'k2', 'q1']\n" + ] + } + ], + "source": [ + "# extract the mode data and prepare the tooling for tide computation at the location of interest\n", + "# needs to be run just once at a given location to extract the tidal components and phases\n", + "# if using another model, some changes may be necessary; see: https://github.com/tsutterley/pyTMD/blob/main/notebooks/Plot%20Tide%20Forecasts.ipynb\n", + "\n", + "tide_model_base = pyTMD.io.model(\n", + " model_path,\n", + " format=model_atlas,\n", + " compressed=model_is_compressed,\n", + ")\n", + "\n", + "tide_model = tide_model_base.elevation(model_name)\n", + "# tide_model.type is type 'z', i.e. just tide elevation and a single output\n", + "\n", + "tide_constituents = pyTMD.io.OTIS.read_constants(\n", + " tide_model.grid_file,\n", + " tide_model.model_file,\n", + " tide_model.projection,\n", + " type=tide_model.type,\n", + " grid=tide_model.format\n", + ")\n", + "\n", + "list_time_constituents = tide_constituents.fields\n", + "print(f\"tidal constituents used in the present model are: {list_time_constituents = }\")\n", + "\n", + "tide_amplitude, tide_phase, model_bathymetry = pyTMD.io.OTIS.interpolate_constants(\n", + " np.atleast_1d(lon_to_predict),\n", + " np.atleast_1d(lat_to_predict),\n", + " tide_constituents,\n", + " tide_model.projection,\n", + " type=tide_model.type,\n", + " method='spline',\n", + " extrapolate=True\n", + ")\n", + "\n", + "tide_complex_phase = -1j * tide_phase * np.pi / 180.0\n", + "tide_constituent_oscillation = tide_amplitude * np.exp(tide_complex_phase)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "79b4cdfc-03e1-474e-a236-6e8970f3f126", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "masked_array(data=[[-0.06247963011264801j, -0.8489143252372742j,\n", + " -4.426159326230184j, -1.9878078699111938j,\n", + " -5.8797287980662745j, -4.337969724331991j,\n", + " -0.9130497574806213j, -0.13438604772090912j]],\n", + " mask=[[False, False, False, False, False, False, False,\n", + " False]],\n", + " fill_value=1e+20)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tide_complex_phase" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b729a118-b6ed-4eb1-9ca6-c8e9407d12e3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "masked_array(data=[[(0.4193906777417112-0.02623752448442905j),\n", + " (0.11027994327238795-0.1252607341628475j),\n", + " (-0.021702359288938156+0.07373947356111339j),\n", + " (-0.009038692517654344-0.02040369718874693j),\n", + " (0.09739921697848977+0.041577151688825885j),\n", + " (-0.009088566077462234+0.0231287115947422j),\n", + " (0.03052787815040282-0.03951826579226765j),\n", + " (0.015726358087985122-0.0021262181018126764j)]],\n", + " mask=[[False, False, False, False, False, False, False,\n", + " False]],\n", + " fill_value=1e+20)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tide_constituent_oscillation" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4c14daa9-cf46-4c44-8f7e-2494b3428de8", + "metadata": {}, + "outputs": [], + "source": [ + "# actually perform the prediction\n", + "# as long as the location is not changed, this can be used many times to predict for different times\n", + "\n", + "# this is to predict a time series at a single location over many times; for more alternatives, for example predict a map at a single times for many locations, see map in\n", + "# https://github.com/tsutterley/pyTMD/blob/main/pyTMD/predict.py\n", + "tide_meters = pyTMD.predict.time_series(\n", + " np.atleast_1d(pytmd_times_to_predict),\n", + " tide_constituent_oscillation,\n", + " list_time_constituents,\n", + " deltat=model_time_delta,\n", + " corrections=tide_model.format\n", + ")\n", + "\n", + "minor_constituents = pyTMD.predict.infer_minor(\n", + " np.atleast_1d(pytmd_times_to_predict),\n", + " tide_constituent_oscillation,\n", + " list_time_constituents,\n", + " deltat=model_time_delta,\n", + " corrections=tide_model.format)\n", + "\n", + "tide_meters.data[:] += minor_constituents.data[:]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "077d124d-9e35-4f9c-abf5-c98cebd729ae", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "masked_array(data=[0.2406398705548227, 0.08826629940393739,\n", + " -0.07795319872284782, -0.2126689208886907,\n", + " -0.2787148849660027, -0.256772788163883,\n", + " -0.15061935784936764, 0.013441425104574078,\n", + " 0.19291182185961755, 0.33969109216654775,\n", + " 0.41231297240858183, 0.3867581597566102,\n", + " 0.2630771136085127, 0.06606864719546335,\n", + " -0.16027011276605818, -0.36324040023082965,\n", + " -0.494334239046328, -0.5213252827477448,\n", + " -0.4365101330814285, -0.25897211682527277,\n", + " -0.03021007334238477, 0.19586664304478923,\n", + " 0.366144786250789, 0.44144430411703506,\n", + " 0.40628849967210595, 0.27281458841269546,\n", + " 0.07777653205025441, -0.12667925764885954,\n", + " -0.28620475716689114, -0.35811689483269915,\n", + " -0.32243687752959155, -0.1872698954863637,\n", + " 0.012911234787026202, 0.22573675219178227,\n", + " 0.3941076249790837, 0.4707845297232434,\n", + " 0.43071669301831467, 0.2779494174668162,\n", + " 0.045276380085246815, -0.21338785600632212,\n", + " -0.43609971824779004, -0.5682215965835636,\n", + " -0.5761683477427382, -0.4560833862138902,\n", + " -0.23519582309143977, 0.03457331068742232,\n", + " 0.2892402024659793, 0.4685189767011065,\n", + " 0.5307872141153755, 0.4634882618633595,\n", + " 0.2863138947038937, 0.04630508672336058,\n", + " -0.19396088633397326, -0.3721724664555676,\n", + " -0.4421154823008852, -0.38553050260520993,\n", + " -0.21695931792303338, 0.019710860242856395,\n", + " 0.2622079336859768, 0.4456345724549238,\n", + " 0.5190791073794647, 0.4588740645095528,\n", + " 0.27510402321142, 0.009637639884429509,\n", + " -0.2739154315517648, -0.5058763503901431,\n", + " -0.6279042621862861, -0.6077683745919477,\n", + " -0.4477367501208618, -0.18440816951402353,\n", + " 0.12004963778794686, 0.39312739714687606,\n", + " 0.5698937238023339, 0.60912617273873,\n", + " 0.5035912397976737, 0.28185641521464105,\n", + " 0.0011332764477786639, -0.2670925013632158,\n", + " -0.45505966479634, -0.5158381349716097,\n", + " -0.43522303945066904, -0.23538690706348672,\n", + " 0.030674531710535816, 0.2925466219487702,\n", + " 0.4803016726646304, 0.5423999312219974,\n", + " 0.45905265156566266, 0.24763320676061254,\n", + " -0.04128979115955553, -0.3363631308706785,\n", + " -0.5632308757038251, -0.6632398594225646,\n", + " -0.6083604666654288, -0.4085401591744887,\n", + " -0.10959157160379712, 0.2179103806066145,\n", + " 0.49598338966390937, 0.6585207895404627,\n", + " 0.6676759893943031, 0.5232322739352586,\n", + " 0.26259130318605667, -0.04863521280013212,\n", + " -0.33308392431522815, -0.5210236801452036,\n", + " -0.567796102670226, -0.4649249247385277,\n", + " -0.24209317964806917, 0.040516339188104024,\n", + " 0.30759365175661024, 0.4879153680389413,\n", + " 0.5325517632768606, 0.427463795993447,\n", + " 0.19729228183920738, -0.10064385031138916,\n", + " -0.3906562582831106, -0.5977210612046852,\n", + " -0.6664564387180252, -0.5752651054946523,\n", + " -0.3420683532877413, -0.02016505293736986,\n", + " 0.3147724587367807, 0.5833269479848882,\n", + " 0.7219357450750298, 0.6985612240541355,\n", + " 0.5205165218735041, 0.23249795166806478,\n", + " -0.09466877086612213, -0.38173508405313905,\n", + " -0.5607428011688073, -0.5918038471433672,\n", + " -0.4727535222595707, -0.2392832697947248,\n", + " 0.04444396163287225, 0.3023013466329021,\n", + " 0.46564963390249553, 0.4908230591269052,\n", + " 0.3702459740059056, 0.1343883224341433,\n", + " -0.15592114966864903, -0.42487813197627705,\n", + " -0.6009033729303522, -0.6348271730533868,\n", + " -0.5124857739452228, -0.2585665779799205,\n", + " 0.0692611357325699, 0.3944574261773502,\n", + " 0.6404316289353207, 0.7493685324344106,\n", + " 0.6963702783074229, 0.4954094254631462,\n", + " 0.19564708275354553, -0.13091874377630877,\n", + " -0.4073505136238227, -0.5707234205225179,\n", + " -0.5874054065837536, -0.4608850536517216,\n", + " -0.23025516754966502, 0.04019045822563011,\n", + " 0.27756867085879866, 0.41901214332724657,\n", + " 0.42758207438139817, 0.3015078681194855,\n", + " 0.07447190621322254, -0.19308263182700924,\n", + " -0.4293909986563835, -0.5696433507398397,\n", + " -0.5724976996254236, -0.4306931861456377,\n", + " -0.1731243741188492, 0.14211509954703122,\n", + " 0.44195360692743113, 0.6562591009332388,\n", + " 0.7349847659113683, 0.6602944302258625,\n", + " 0.4506968984255701, 0.1562259270657964,\n", + " -0.1540658836193318, -0.4091338862118068,\n", + " -0.5532307735400385, -0.5591771566622399,\n", + " -0.43437452917091895, -0.21816014564680808,\n", + " 0.02872793212400604, 0.23985195646034846,\n", + " 0.3599612708928524, 0.35883195902723497,\n", + " 0.23863204950074934, 0.03303644090853985,\n", + " -0.20160662103531035, -0.4007738913902078,\n", + " -0.5082535713801964, -0.49047948203709335,\n", + " -0.3451447887613694, -0.10198185114393157,\n", + " 0.18443856216346252, 0.4480512150055814,\n", + " 0.6274375326868227, 0.6807545253809028,\n", + " 0.5957796998929428, 0.39264359878563476,\n", + " 0.11865265328747196, -0.1634368455220439,\n", + " -0.3907343404008696, -0.5153130615249009,\n", + " -0.5153873237289648, -0.3998833336430392,\n", + " -0.20538546789401738, 0.013663127027269892,\n", + " 0.19897321494042103, 0.30309829911088165,\n", + " 0.3011466592648496, 0.19665312504406152,\n", + " 0.020234387972879762, -0.17854048581005183,\n", + " -0.34395584411215246, -0.42838976175415083,\n", + " -0.40443048664390985, -0.2718777697375145,\n", + " -0.05793700549762899, 0.18938498726073372,\n", + " 0.41299616097236724, 0.5606197210546644,\n", + " 0.597446381548931, 0.5144515992305644,\n", + " 0.330390677061932, 0.08705772356738097,\n", + " -0.16095231092900647, -0.35941253663822553,\n", + " -0.4673187542032857, -0.46630976302659277,\n", + " -0.3644201879115945, -0.1933527164096702,\n", + " -5.35850557905615e-05, 0.16524452595875827,\n", + " 0.26151920597764, 0.26691863596131876,\n", + " 0.18378106403424382, 0.037559299299809806,\n", + " -0.12998993935799727, -0.2715885925870736,\n", + " -0.34647758605629936, -0.33072809780488255,\n", + " -0.22329930818627866, -0.04639217975500748,\n", + " 0.15993674795854548, 0.3475324530939063,\n", + " 0.4718473341013003, 0.502724722098278,\n", + " 0.4316446481610651, 0.2737057484525516,\n", + " 0.06391475467867579, -0.1512596261968467,\n", + " -0.32497621395445236, -0.42104862407894816,\n", + " -0.4222548898873664, -0.3339669245123749,\n", + " -0.18229600331555312, -0.007288174664565633,\n", + " 0.14710618580546303, 0.24380787131309137,\n", + " 0.2615029783035479, 0.1995221645498664,\n", + " 0.077575144836669, -0.0695243602035645,\n", + " -0.20079098221094516, -0.27943037651497077,\n", + " -0.28208046193511926, -0.20467754721362913,\n", + " -0.06353560420355327, 0.10859635460764674,\n", + " 0.27051039477611005, 0.38258716265333026,\n", + " 0.4164618073857427, 0.36196226170009616,\n", + " 0.2296476644403271, 0.04834853874014355,\n", + " -0.1416780726580666, -0.29830953623214707,\n", + " -0.38751922898741975, -0.39133998488017757,\n", + " -0.3119265205031979, -0.17076631186161206,\n", + " -0.0032647791642067825, 0.14995422766304858,\n", + " 0.25290641373916495, 0.28287018720148877,\n", + " 0.23569474824012976, 0.12652807880197486,\n", + " -0.014181896071880078, -0.14841012259962233,\n", + " -0.24009579562811217, -0.2641596921733993,\n", + " -0.21278805665587552, -0.09744417252948268,\n", + " 0.05388650096861897, 0.20354688508724886,\n", + " 0.3134817221690112, 0.3546658658891043,\n", + " 0.314376247006172, 0.19951680064410368,\n", + " 0.03516436144848266, -0.1413320664434924,\n", + " -0.28927909094551085, -0.37442976502843,\n", + " -0.37725449383101, -0.29767097743076265,\n", + " -0.15506924447333645, 0.01638734312201497,\n", + " 0.17604994204603985, 0.2866444459092663,\n", + " 0.32329624135487967, 0.2795086252203645,\n", + " 0.1686243033769022, 0.02040413746896765,\n", + " -0.12644256567807421, -0.23394105449670438,\n", + " -0.27435822390602016, -0.2371767378975273,\n", + " -0.13179372477679419, 0.014749138254289217,\n", + " 0.16446922899741448, 0.27794085974793586,\n", + " 0.3242415234317362, 0.28887032143205255,\n", + " 0.17764580819111936, 0.015572906855984545,\n", + " -0.15908915393898573, -0.30412997652153484,\n", + " -0.3837823172243467, -0.3776346815992817,\n", + " -0.28583373869305845, -0.12925027353650909,\n", + " 0.05547673737822985, 0.224829688703996,\n", + " 0.3390580969117735, 0.3719476532053935,\n", + " 0.317277156794393, 0.19033502135882283,\n", + " 0.024088130728300884, -0.139070575036216,\n", + " -0.25795611485398123, -0.3029552739004178,\n", + " -0.2635159873474332, -0.150859675329846,\n", + " 0.004800143631620093, 0.16187254960320116,\n", + " 0.2779531225352144, 0.3206919336360721,\n", + " 0.2762187852235723, 0.15296861356292454,\n", + " -0.020110164901681153, -0.20057332256152624,\n", + " -0.3430094196569982, -0.4104592840451588,\n", + " -0.3838536127058927, -0.26706595326656113,\n", + " -0.08626002159516574, 0.11636323024105903,\n", + " 0.29289932035357885, 0.40159099302240076,\n", + " 0.41722599711283864, 0.3374524491117343,\n", + " 0.18339104963806221, -0.005648578600037939,\n", + " -0.1820508013588542, -0.30190540141758093,\n", + " -0.3361189031095258, -0.27780258656553136,\n", + " -0.14403767899678485, 0.02846765513945324,\n", + " 0.1927653579387984, 0.30374186296770683,\n", + " 0.32981897854614234, 0.2612891092282345,\n", + " 0.11312388746325319, -0.07851535982040846,\n", + " -0.2652382714535302, -0.39862734826564916,\n", + " -0.44260359873503374, -0.3828070720637841,\n", + " -0.23057361626961626, -0.020442340981902958,\n", + " 0.19823516494599921, 0.3735071675713634,\n", + " 0.4637894938122626, 0.44830565356110874,\n", + " 0.33233412521086614, 0.1458992997770358,\n", + " -0.06379843595713675, -0.24432193694859533,\n", + " -0.35128925153164586, -0.3596383440705927,\n", + " -0.26998152380060436, -0.10840331223446112,\n", + " 0.08027870124900914, 0.24409808165527958,\n", + " 0.3374258055065469, 0.3329087327667175,\n", + " 0.22878307570497441, 0.0496489077182819,\n", + " -0.15954658704624897, -0.3448308567020168,\n", + " -0.4569757395763728, -0.4642089276493418,\n", + " -0.36060423235023387, -0.16796816641382117,\n", + " 0.06931324303868447, 0.2952083811018395,\n", + " 0.45601056243354116, 0.5138079685363732,\n", + " 0.45602219890612444, 0.29856902963070203,\n", + " 0.08181036775469504, -0.13969680936743756,\n", + " -0.3110597414207669, -0.3909896966864319,\n", + " -0.36226009010556626, -0.2359984203936498,\n", + " -0.04869692724571436, 0.1473106379139388,\n", + " 0.2974793506064919, 0.35929915318879474,\n", + " 0.31349128661989456, 0.16925593579929665,\n", + " -0.037814176907616404, -0.25466238190660984,\n", + " -0.42428666712188345, -0.5004049518827711,\n", + " -0.4595098649221393, -0.30720439742087474,\n", + " -0.0771584942169559, 0.17709218512526648,\n", + " 0.39545111383629855, 0.5263005691078735,\n", + " 0.5394501416308216, 0.4336891289294751,\n", + " 0.23700676938627072, -0.0005867069434057626,\n", + " -0.21981371811678618, -0.36720416605918593,\n", + " -0.4086390203447129, -0.337897532810835,\n", + " -0.17801945371300323, 0.024865857671503993,\n", + " 0.21365801423350972, 0.33523620222829614,\n", + " 0.35439274643235125, 0.2631545749993058,\n", + " 0.0830756461056032, -0.14011462584774187,\n", + " -0.3481575315461328, -0.48523391013908973,\n", + " -0.5124203866961954, -0.4179171588861764,\n", + " -0.2204048626267848, 0.0353580596595229,\n", + " 0.28960052815490595, 0.4824616017279187,\n", + " 0.5689738471022785, 0.5302898984209427,\n", + " 0.37829209783038087, 0.15241562262784547,\n", + " -0.09049376357113117, -0.2906858613301764,\n", + " -0.40066105237843813, -0.39709842551743313,\n", + " -0.2865142438793219, -0.10322082803615432,\n", + " 0.09986552957906783, 0.26518309779555904,\n", + " 0.3456430031666381, 0.31700612640858356,\n", + " 0.1843256183753342, -0.019209401027588592,\n", + " -0.24073752906098406, -0.42132442117747576,\n", + " -0.5112040741485139, -0.4827443069329659,\n", + " -0.3378007656854757, -0.1075619718548435,\n", + " 0.15508752677811355, 0.38874253891256527,\n", + " 0.5388311070180998, 0.5712329617491563,\n", + " 0.48069808880664866, 0.2919368480105357,\n", + " 0.0531312963832302, -0.1764451920068217,\n", + " -0.3415128952457723, -0.40470948425131403,\n", + " -0.3558009309085754, -0.2138516123800259,\n", + " -0.02184208366370232, 0.16483614226259632,\n", + " 0.29301256529389, 0.325708667815993, 0.251844612601001,\n", + " 0.08918831890145545, -0.12019907612471946,\n", + " -0.3208337973363699, -0.45818576952119605,\n", + " -0.4928547177944924, -0.4108988541191564,\n", + " -0.22766412322688337, 0.01586501043327608,\n", + " 0.26325340219701954, 0.45673010481720544,\n", + " 0.5516222651732504, 0.5274315958457596,\n", + " 0.3927502107269886, 0.18279968935044646,\n", + " -0.04973233366129873, -0.24817571919464165,\n", + " -0.36621071194801863, -0.3793860923204433,\n", + " -0.29090500813225745, -0.13025063364051576,\n", + " 0.054929968037240894, 0.21153817916887077,\n", + " 0.29502130679694544, 0.2810362232422984,\n", + " 0.17178367497582714, -0.0045927164528277425,\n", + " -0.20135478917263688, -0.36534193873956006,\n", + " -0.4508117031919113, -0.4313789714079079,\n", + " -0.3069881109150001, -0.10414067612050104,\n", + " 0.1306615334453215, 0.34256039151686285,\n", + " 0.48208180633044856, 0.5174626530122513,\n", + " 0.44243656286367117, 0.2775308220707958,\n", + " 0.0645963335612581, -0.14397878430938518,\n", + " -0.29857710390284686, -0.3647677397503542,\n", + " -0.33167608872387305, -0.21421789333204036,\n", + " -0.04869801933242256, 0.11702165319573682,\n", + " 0.23620045459654784, 0.275452797338999,\n", + " 0.2233912819413245, 0.09348260872808528,\n", + " -0.0795747664357648, -0.2489718838870465,\n", + " -0.3680243598087525, -0.4023532984983569,\n", + " -0.3388793625175304, -0.1893353668877103,\n", + " 0.012577978269853358, 0.21963601743167896,\n", + " 0.3829505511068698, 0.4642068653872918,\n", + " 0.4451644643404181, 0.33203101207787244,\n", + " 0.1536449023147215, -0.04601276076036589,\n", + " -0.21901854368307389, -0.32553725838383657,\n", + " -0.34362068594908984, -0.27431524069207097,\n", + " -0.1408426950725817, 0.017856640216492674,\n", + " 0.15749422233029664, 0.24001425988956454,\n", + " 0.24340449846039197, 0.1672422271857014,\n", + " 0.03259899051664503, -0.12361469944817298,\n", + " -0.2583615543882206, -0.3337202148482182,\n", + " -0.3267639668467411, -0.23555522897745212,\n", + " -0.0797487345321438, 0.10431632961175727,\n", + " 0.27275077777798323, 0.38512859418522943,\n", + " 0.4145748942613466, 0.35438564125287614,\n", + " 0.21953939961566488, 0.04277071111321057,\n", + " -0.13374694440097307, -0.268963656531843,\n", + " -0.33307498957464676, -0.31466249691391257,\n", + " -0.22309814012949816, -0.08567772450017225,\n", + " 0.05971232952259483, 0.17447257580099942,\n", + " 0.22917320356561796, 0.21093616304441767,\n", + " 0.12647815582058067, 9.921917563085643e-05,\n", + " -0.13280870872842354, -0.23503108652212,\n", + " -0.27719243424380335, -0.24535282337801154,\n", + " -0.14463088664548845, 0.002030972669124641,\n", + " 0.159608921293996, 0.28976581862598555,\n", + " 0.3604179141749553, 0.353695957053925,\n", + " 0.2703247241640978, 0.12936281631767685,\n", + " -0.03658447287939022, -0.1894390234349111,\n", + " -0.29496750621578594, -0.33101764833873154,\n", + " -0.2926492481698205, -0.19293686061925616,\n", + " -0.05931457060905483, 0.07355744740302342,\n", + " 0.1725758770305219, 0.21441654539530752,\n", + " 0.19115938441991295, 0.11195615931294028,\n", + " 0.0003853726771896951, -0.11178370422393234,\n", + " -0.19281316794684195, -0.21912790495830606,\n", + " -0.1813283464291388, -0.0866067455195768,\n", + " 0.043002635196614125, 0.17607215773141707,\n", + " 0.2795525092297537, 0.3269333998710911,\n", + " 0.3047830913026641, 0.2160745293379867,\n", + " 0.07950864327666272, -0.07496887073461247,\n", + " -0.2133352730583769, -0.3055803375237167,\n", + " -0.33275129183446717, -0.29126314376844475,\n", + " -0.19346739930947449, -0.06439025226626631,\n", + " 0.06452093907488493, 0.16309132143237431,\n", + " 0.20967231440191347, 0.19620529103517076,\n", + " 0.1298960472349162, 0.031134866046758684,\n", + " -0.07179033875370804, -0.14986944755090054,\n", + " -0.1806704394862532, -0.1539845138691601,\n", + " -0.07444839668888323, 0.039485507278586573,\n", + " 0.1599757082589215, 0.2565411875355426,\n", + " 0.30350323147435193, 0.28632466775718335,\n", + " 0.20531737242974912, 0.07581916738841182,\n", + " -0.07521519914222627, -0.21540859769644538,\n", + " -0.314476599088077, -0.35128181887149135,\n", + " -0.31875313211189343, -0.22549976852289658,\n", + " -0.09373304085805736, 0.04601548989114561,\n", + " 0.1621286085548579, 0.22937263978468925,\n", + " 0.23482230899774842, 0.1808241334813157,\n", + " 0.08428203336853113, -0.027575493227671125,\n", + " -0.1239436828573793, -0.17809146570703183,\n", + " -0.17406871581540884, -0.11083495605625493,\n", + " -0.002776473839749334, 0.12356314282266692,\n", + " 0.23580249039776868, 0.3036073696451004,\n", + " 0.306254305991266, 0.23803030438993328,\n", + " 0.11011559117214456, -0.05158005466537585,\n", + " -0.21219001297445456, -0.335955137067297,\n", + " -0.3946826774436001, -0.3745694379120458,\n", + " -0.27971303827949523, -0.1314019496519327,\n", + " 0.0367224429685901, 0.18653747416121658,\n", + " 0.28449368765681565, 0.30967829003276187,\n", + " 0.25891243613526127, 0.14759151330854975,\n", + " 0.005991556000916463, -0.12813118968306444,\n", + " -0.21889475860682964, -0.24133060591258546,\n", + " -0.18786708777350103, -0.07059817238258433,\n", + " 0.08131805123961575, 0.22859691350482195,\n", + " 0.33148003648105795, 0.35977024754950476,\n", + " 0.3007623333559513, 0.16304265047894728,\n", + " -0.02489620246368579, -0.22102000626045104,\n", + " -0.3796506539439821, -0.46253762403752546,\n", + " -0.44839315823702575, -0.33849486434551823,\n", + " -0.15687630495434557, 0.05506661013071819,\n", + " 0.24834375154008065, 0.3781898375090734,\n", + " 0.41504910041753545, 0.35198458368417007,\n", + " 0.20660233074310524, 0.01690769998009592,\n", + " -0.16798642530428254, -0.3000737910721979,\n", + " -0.34458770941020234, -0.289007077288577,\n", + " -0.14661066244693555, 0.046424630088777175,\n", + " 0.23978375539541685, 0.3815470333348654,\n", + " 0.43141692215397304, 0.37131582311269246,\n", + " 0.21062175163623337, -0.015400836806231284,\n", + " -0.25373554527054965, -0.4464158507392978,\n", + " -0.5448798277451768, -0.522305650407479,\n", + " -0.3807880492661894, -0.15144811311434242,\n", + " 0.11269314073330183, 0.3494314546527288,\n", + " 0.5026034245736656],\n", + " mask=[False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False],\n", + " fill_value=1e+20)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the predicted tides, in meters, is just a numpy masked array\n", + "\n", + "tide_meters" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ffbc0943-a5fb-40fc-9f43-b058eb850fc3", + "metadata": {}, + "outputs": [], + "source": [ + "# put in pandas for more flexible plotting later on\n", + "df_pytmd = pd.DataFrame({'utc_timestamp':times_to_predict, 'pytmd_tide_m':tide_meters})" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7bb40d0f-8862-4734-87e1-f03d2d7c929d", + "metadata": {}, + "outputs": [], + "source": [ + "# for cross validation, compare to the observation + harmonic modeling from Ny-Ålesund, available at https://www.kartverket.no/til-sjos/se-havniva/resultat?id=587933&location=Ny-%C3%85lesund" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "831dd723-071f-4abd-8734-2373270037d1", + "metadata": {}, + "outputs": [], + "source": [ + "# read; note that I added a line \"timestamp observation astronomical_tide\" under the line 15 (i.e. new line 16) to have easy parsing with pandas\n", + "df_kartverket = pd.read_csv(\"./data_Kartverket_NyAlesund_Juni_2023.txt\", skiprows=15, delimiter=r\"\\s+\") # parse ignoring file header and considering several spaces in a row as a single space\n", + "df_kartverket[\"utc_timestamp\"] = pd.to_datetime(df_kartverket[\"timestamp\"], utc=True) # actually get UTC timestamps out of the ISO datetime strings\n", + "df_kartverket[\"kartverket_astronomical_tide_m\"] = df_kartverket[\"astronomical_tide\"] / 100.0 # cm (Kartverket) to m\n", + "df_kartverket[\"kartverket_observation_m\"] = df_kartverket[\"observation\"] / 100.0 # cm (Kartverket) to m" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6b8c0042-4755-408c-934b-f452b7e20056", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# compare the model data generated by pyTMD to Kartverket astronomical tide computed over a long time series\n", + "\n", + "# time window to plot for comparison\n", + "utc_timestamp_start = datetime.datetime(2023, 7, 10, 0, 0, 0, tzinfo=datetime.timezone.utc)\n", + "utc_timestamp_stop = datetime.datetime(2023, 7, 18, 0, 0, 0, tzinfo=datetime.timezone.utc)\n", + "\n", + "def get_mask(df_in, utc_timestamp_start, utc_timestamp_stop):\n", + " mask = (df_in[\"utc_timestamp\"] > utc_timestamp_start) & (df_in[\"utc_timestamp\"] < utc_timestamp_stop) \n", + " return mask\n", + "\n", + "# plotting\n", + "fig = plt.figure()\n", + "ax = plt.gca()\n", + "\n", + "mask_pytmd = get_mask(df_pytmd, utc_timestamp_start, utc_timestamp_stop)\n", + "df_pytmd.loc[mask_pytmd].plot(x=\"utc_timestamp\", y=\"pytmd_tide_m\", ax=ax)\n", + "\n", + "mask_kartverket = get_mask(df_kartverket, utc_timestamp_start, utc_timestamp_stop)\n", + "# df_kartverket.loc[mask_kartverket].plot(x=\"utc_timestamp\", y=[\"observation_m\", \"kartverket_astronomical_tide_m\"], ax=ax)\n", + "df_kartverket.loc[mask_kartverket].plot(x=\"utc_timestamp\", y=[\"kartverket_astronomical_tide_m\"], ax=ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "51c58282-8fc5-4a03-9de2-5131f213bf26", + "metadata": {}, + "outputs": [], + "source": [ + "# success, the comparison is very good - this is a global model for the whole Arctic!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "100fb03a-61c1-4410-b02d-718d265a706f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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": 5 +} From 40492f1a4a40c0415be29b821b2d36b7acc732ed Mon Sep 17 00:00:00 2001 From: JRT Date: Tue, 15 Aug 2023 21:22:01 +0200 Subject: [PATCH 2/3] Add necessary datafile to compare with tide station --- .../data_Kartverket_NyAlesund_Juni_2023.txt | 761 ++++++++++++++++++ 1 file changed, 761 insertions(+) create mode 100644 notebooks/data_Kartverket_NyAlesund_Juni_2023.txt diff --git a/notebooks/data_Kartverket_NyAlesund_Juni_2023.txt b/notebooks/data_Kartverket_NyAlesund_Juni_2023.txt new file mode 100644 index 00000000..8575e806 --- /dev/null +++ b/notebooks/data_Kartverket_NyAlesund_Juni_2023.txt @@ -0,0 +1,761 @@ +#Site name: Ny-Ålesund +#Abstract: Tidevann og observert vannstand fra Ny-Ålesund +#Provider: Statens kartverk sjø (Norwegian Hydrographic Service) +#Latitude: 78.92589000 +#Longitude: 11.93140000 +#Datum: EUREF89 +#Time interval: 3600 seconds +#Reference level: MSL (Middelvann (1996-2014)) +#Z0: 95.2 cm +#Start time: 2023-07-01T01:00:00+02:00 +#End time: 2023-08-01T01:00:00+02:00 +#Unit: cm +#Series1: Water level observations +#Series2: Predicted tide (astronomical) +#Series3: Forecast +timestamp observation astronomical_tide +2023-07-01T01:00:00+02:00 16.2 34.8 +2023-07-01T02:00:00+02:00 7.3 25.3 +2023-07-01T03:00:00+02:00 -10.1 8.6 +2023-07-01T04:00:00+02:00 -29.0 -10.7 +2023-07-01T05:00:00+02:00 -45.7 -27.2 +2023-07-01T06:00:00+02:00 -54.3 -36.7 +2023-07-01T07:00:00+02:00 -54.4 -36.5 +2023-07-01T08:00:00+02:00 -43.8 -26.7 +2023-07-01T09:00:00+02:00 -27.3 -9.8 +2023-07-01T10:00:00+02:00 -7.0 10.2 +2023-07-01T11:00:00+02:00 9.6 27.9 +2023-07-01T12:00:00+02:00 19.7 38.3 +2023-07-01T13:00:00+02:00 18.9 38.6 +2023-07-01T14:00:00+02:00 8.3 28.2 +2023-07-01T15:00:00+02:00 -12.1 9.1 +2023-07-01T16:00:00+02:00 -35.7 -14.5 +2023-07-01T17:00:00+02:00 -57.5 -36.6 +2023-07-01T18:00:00+02:00 -72.1 -51.8 +2023-07-01T19:00:00+02:00 -77.1 -56.4 +2023-07-01T20:00:00+02:00 -68.8 -49.2 +2023-07-01T21:00:00+02:00 -50.8 -31.7 +2023-07-01T22:00:00+02:00 -27.5 -8.1 +2023-07-01T23:00:00+02:00 -3.2 16.1 +2023-07-02T00:00:00+02:00 15.2 35.0 +2023-07-02T01:00:00+02:00 24.9 44.2 +2023-07-02T02:00:00+02:00 21.5 41.9 +2023-07-02T03:00:00+02:00 9.5 28.7 +2023-07-02T04:00:00+02:00 -12.4 7.7 +2023-07-02T05:00:00+02:00 -34.5 -15.3 +2023-07-02T06:00:00+02:00 -53.7 -34.2 +2023-07-02T07:00:00+02:00 -60.7 -44.1 +2023-07-02T08:00:00+02:00 -59.7 -42.7 +2023-07-02T09:00:00+02:00 -44.7 -30.2 +2023-07-02T10:00:00+02:00 -24.7 -9.8 +2023-07-02T11:00:00+02:00 -1.9 13.2 +2023-07-02T12:00:00+02:00 18.3 32.9 +2023-07-02T13:00:00+02:00 27.8 43.6 +2023-07-02T14:00:00+02:00 26.9 42.4 +2023-07-02T15:00:00+02:00 11.3 29.3 +2023-07-02T16:00:00+02:00 -10.9 6.7 +2023-07-02T17:00:00+02:00 -37.6 -20.0 +2023-07-02T18:00:00+02:00 -62.1 -44.0 +2023-07-02T19:00:00+02:00 -74.8 -59.0 +2023-07-02T20:00:00+02:00 -77.5 -61.5 +2023-07-02T21:00:00+02:00 -65.8 -50.6 +2023-07-02T22:00:00+02:00 -43.4 -28.8 +2023-07-02T23:00:00+02:00 -15.4 -1.1 +2023-07-03T00:00:00+02:00 11.2 25.8 +2023-07-03T01:00:00+02:00 31.0 45.2 +2023-07-03T02:00:00+02:00 37.1 52.7 +2023-07-03T03:00:00+02:00 32.4 47.0 +2023-07-03T04:00:00+02:00 13.0 29.2 +2023-07-03T05:00:00+02:00 -11.7 3.7 +2023-07-03T06:00:00+02:00 -38.2 -22.8 +2023-07-03T07:00:00+02:00 -57.9 -43.2 +2023-07-03T08:00:00+02:00 -66.5 -52.5 +2023-07-03T09:00:00+02:00 -62.2 -48.7 +2023-07-03T10:00:00+02:00 -45.3 -32.8 +2023-07-03T11:00:00+02:00 -21.3 -8.8 +2023-07-03T12:00:00+02:00 4.3 17.2 +2023-07-03T13:00:00+02:00 24.5 38.1 +2023-07-03T14:00:00+02:00 34.6 48.2 +2023-07-03T15:00:00+02:00 29.7 44.9 +2023-07-03T16:00:00+02:00 14.1 28.6 +2023-07-03T17:00:00+02:00 -14.3 2.6 +2023-07-03T18:00:00+02:00 -42.6 -26.7 +2023-07-03T19:00:00+02:00 -68.0 -51.4 +2023-07-03T20:00:00+02:00 -80.3 -65.2 +2023-07-03T21:00:00+02:00 -80.3 -64.6 +2023-07-03T22:00:00+02:00 -64.2 -49.5 +2023-07-03T23:00:00+02:00 -37.5 -23.3 +2023-07-04T00:00:00+02:00 -6.4 7.8 +2023-07-04T01:00:00+02:00 21.9 36.1 +2023-07-04T02:00:00+02:00 39.6 54.6 +2023-07-04T03:00:00+02:00 45.0 59.3 +2023-07-04T04:00:00+02:00 33.8 49.3 +2023-07-04T05:00:00+02:00 10.8 26.8 +2023-07-04T06:00:00+02:00 -18.8 -2.9 +2023-07-04T07:00:00+02:00 -46.7 -31.9 +2023-07-04T08:00:00+02:00 -66.2 -52.6 +2023-07-04T09:00:00+02:00 -73.7 -60.3 +2023-07-04T10:00:00+02:00 -65.4 -53.6 +2023-07-04T11:00:00+02:00 -44.4 -34.1 +2023-07-04T12:00:00+02:00 -18.0 -6.9 +2023-07-04T13:00:00+02:00 11.4 21.1 +2023-07-04T14:00:00+02:00 30.0 42.3 +2023-07-04T15:00:00+02:00 39.3 51.0 +2023-07-04T16:00:00+02:00 31.8 45.1 +2023-07-04T17:00:00+02:00 13.0 25.7 +2023-07-04T18:00:00+02:00 -17.6 -3.1 +2023-07-04T19:00:00+02:00 -47.3 -33.7 +2023-07-04T20:00:00+02:00 -72.1 -57.9 +2023-07-04T21:00:00+02:00 -82.5 -69.2 +2023-07-04T22:00:00+02:00 -78.3 -64.8 +2023-07-04T23:00:00+02:00 -57.2 -45.6 +2023-07-05T00:00:00+02:00 -27.7 -15.7 +2023-07-05T01:00:00+02:00 5.7 17.5 +2023-07-05T02:00:00+02:00 33.3 45.7 +2023-07-05T03:00:00+02:00 49.4 62.1 +2023-07-05T04:00:00+02:00 48.4 63.2 +2023-07-05T05:00:00+02:00 34.6 48.8 +2023-07-05T06:00:00+02:00 6.4 22.0 +2023-07-05T07:00:00+02:00 -26.3 -10.7 +2023-07-05T08:00:00+02:00 -55.7 -40.8 +2023-07-05T09:00:00+02:00 -75.3 -60.7 +2023-07-05T10:00:00+02:00 -80.1 -66.2 +2023-07-05T11:00:00+02:00 -69.1 -56.4 +2023-07-05T12:00:00+02:00 -46.7 -34.0 +2023-07-05T13:00:00+02:00 -16.1 -4.5 +2023-07-05T14:00:00+02:00 11.3 24.2 +2023-07-05T15:00:00+02:00 32.0 44.4 +2023-07-05T16:00:00+02:00 36.9 51.0 +2023-07-05T17:00:00+02:00 27.4 42.5 +2023-07-05T18:00:00+02:00 6.5 20.5 +2023-07-05T19:00:00+02:00 -27.0 -9.8 +2023-07-05T20:00:00+02:00 -55.9 -40.3 +2023-07-05T21:00:00+02:00 -79.4 -62.4 +2023-07-05T22:00:00+02:00 -85.6 -70.4 +2023-07-05T23:00:00+02:00 -77.8 -62.1 +2023-07-06T00:00:00+02:00 -53.9 -39.2 +2023-07-06T01:00:00+02:00 -21.7 -7.0 +2023-07-06T02:00:00+02:00 12.2 26.7 +2023-07-06T03:00:00+02:00 38.9 53.4 +2023-07-06T04:00:00+02:00 51.9 66.7 +2023-07-06T05:00:00+02:00 48.4 64.0 +2023-07-06T06:00:00+02:00 29.6 45.9 +2023-07-06T07:00:00+02:00 -0.4 16.0 +2023-07-06T08:00:00+02:00 -35.5 -18.3 +2023-07-06T09:00:00+02:00 -63.8 -48.0 +2023-07-06T10:00:00+02:00 -83.1 -66.1 +2023-07-06T11:00:00+02:00 -83.9 -69.0 +2023-07-06T12:00:00+02:00 -72.3 -56.7 +2023-07-06T13:00:00+02:00 -46.2 -32.3 +2023-07-06T14:00:00+02:00 -16.2 -2.3 +2023-07-06T15:00:00+02:00 11.2 25.6 +2023-07-06T16:00:00+02:00 29.6 43.8 +2023-07-06T17:00:00+02:00 31.9 48.0 +2023-07-06T18:00:00+02:00 20.9 37.2 +2023-07-06T19:00:00+02:00 -2.9 13.8 +2023-07-06T20:00:00+02:00 -35.0 -16.6 +2023-07-06T21:00:00+02:00 -63.2 -45.3 +2023-07-06T22:00:00+02:00 -82.7 -64.2 +2023-07-06T23:00:00+02:00 -86.0 -68.4 +2023-07-07T00:00:00+02:00 -74.6 -56.6 +2023-07-07T01:00:00+02:00 -48.2 -31.3 +2023-07-07T02:00:00+02:00 -16.5 1.6 +2023-07-07T03:00:00+02:00 16.4 34.0 +2023-07-07T04:00:00+02:00 39.3 58.0 +2023-07-07T05:00:00+02:00 49.0 68.0 +2023-07-07T06:00:00+02:00 41.4 61.9 +2023-07-07T07:00:00+02:00 20.7 41.1 +2023-07-07T08:00:00+02:00 -11.6 9.7 +2023-07-07T09:00:00+02:00 -45.3 -24.2 +2023-07-07T10:00:00+02:00 -72.4 -52.2 +2023-07-07T11:00:00+02:00 -87.7 -67.8 +2023-07-07T12:00:00+02:00 -88.1 -68.4 +2023-07-07T13:00:00+02:00 -74.0 -54.4 +2023-07-07T14:00:00+02:00 -48.2 -29.6 +2023-07-07T15:00:00+02:00 -19.7 -0.5 +2023-07-07T16:00:00+02:00 5.8 25.1 +2023-07-07T17:00:00+02:00 20.4 40.7 +2023-07-07T18:00:00+02:00 21.8 42.5 +2023-07-07T19:00:00+02:00 11.6 30.2 +2023-07-07T20:00:00+02:00 -13.0 6.7 +2023-07-07T21:00:00+02:00 -40.3 -22.1 +2023-07-07T22:00:00+02:00 -66.3 -47.7 +2023-07-07T23:00:00+02:00 -80.0 -62.9 +2023-07-08T00:00:00+02:00 -80.3 -63.6 +2023-07-08T01:00:00+02:00 -66.0 -49.3 +2023-07-08T02:00:00+02:00 -37.6 -23.3 +2023-07-08T03:00:00+02:00 -6.2 8.6 +2023-07-08T04:00:00+02:00 25.4 38.4 +2023-07-08T05:00:00+02:00 46.2 59.1 +2023-07-08T06:00:00+02:00 51.6 65.8 +2023-07-08T07:00:00+02:00 43.7 57.3 +2023-07-08T08:00:00+02:00 20.4 35.2 +2023-07-08T09:00:00+02:00 -9.4 4.2 +2023-07-08T10:00:00+02:00 -42.1 -27.8 +2023-07-08T11:00:00+02:00 -66.0 -52.9 +2023-07-08T12:00:00+02:00 -78.9 -65.9 +2023-07-08T13:00:00+02:00 -77.6 -64.6 +2023-07-08T14:00:00+02:00 -62.7 -50.1 +2023-07-08T15:00:00+02:00 -40.0 -26.3 +2023-07-08T16:00:00+02:00 -12.9 0.5 +2023-07-08T17:00:00+02:00 8.8 23.1 +2023-07-08T18:00:00+02:00 21.7 35.8 +2023-07-08T19:00:00+02:00 20.6 35.8 +2023-07-08T20:00:00+02:00 8.9 23.1 +2023-07-08T21:00:00+02:00 -13.1 0.8 +2023-07-08T22:00:00+02:00 -39.8 -25.1 +2023-07-08T23:00:00+02:00 -60.6 -46.9 +2023-07-09T00:00:00+02:00 -72.6 -58.4 +2023-07-09T01:00:00+02:00 -70.1 -56.5 +2023-07-09T02:00:00+02:00 -55.4 -41.3 +2023-07-09T03:00:00+02:00 -29.9 -16.2 +2023-07-09T04:00:00+02:00 -0.9 13.0 +2023-07-09T05:00:00+02:00 25.1 39.4 +2023-07-09T06:00:00+02:00 41.6 56.6 +2023-07-09T07:00:00+02:00 45.4 60.7 +2023-07-09T08:00:00+02:00 34.9 51.0 +2023-07-09T09:00:00+02:00 13.5 29.2 +2023-07-09T10:00:00+02:00 -16.1 0.2 +2023-07-09T11:00:00+02:00 -44.7 -28.7 +2023-07-09T12:00:00+02:00 -66.2 -50.6 +2023-07-09T13:00:00+02:00 -75.8 -61.1 +2023-07-09T14:00:00+02:00 -73.3 -58.7 +2023-07-09T15:00:00+02:00 -58.6 -44.8 +2023-07-09T16:00:00+02:00 -38.1 -23.1 +2023-07-09T17:00:00+02:00 -14.5 0.6 +2023-07-09T18:00:00+02:00 5.2 20.1 +2023-07-09T19:00:00+02:00 14.2 30.5 +2023-07-09T20:00:00+02:00 13.3 29.5 +2023-07-09T21:00:00+02:00 1.1 17.6 +2023-07-09T22:00:00+02:00 -17.7 -2.4 +2023-07-09T23:00:00+02:00 -40.8 -24.8 +2023-07-10T00:00:00+02:00 -58.8 -42.8 +2023-07-10T01:00:00+02:00 -67.1 -51.5 +2023-07-10T02:00:00+02:00 -62.9 -48.4 +2023-07-10T03:00:00+02:00 -48.5 -33.9 +2023-07-10T04:00:00+02:00 -25.9 -11.3 +2023-07-10T05:00:00+02:00 0.4 14.4 +2023-07-10T06:00:00+02:00 21.9 37.0 +2023-07-10T07:00:00+02:00 37.0 51.2 +2023-07-10T08:00:00+02:00 37.9 53.7 +2023-07-10T09:00:00+02:00 29.5 44.0 +2023-07-10T10:00:00+02:00 7.6 23.8 +2023-07-10T11:00:00+02:00 -16.6 -2.1 +2023-07-10T12:00:00+02:00 -42.8 -27.4 +2023-07-10T13:00:00+02:00 -59.4 -46.1 +2023-07-10T14:00:00+02:00 -68.8 -54.8 +2023-07-10T15:00:00+02:00 -64.1 -52.2 +2023-07-10T16:00:00+02:00 -53.4 -39.6 +2023-07-10T17:00:00+02:00 -33.3 -20.5 +2023-07-10T18:00:00+02:00 -14.3 0.2 +2023-07-10T19:00:00+02:00 2.6 17.1 +2023-07-10T20:00:00+02:00 9.5 26.0 +2023-07-10T21:00:00+02:00 9.0 25.2 +2023-07-10T22:00:00+02:00 -1.4 15.0 +2023-07-10T23:00:00+02:00 -17.6 -2.1 +2023-07-11T00:00:00+02:00 -36.9 -21.0 +2023-07-11T01:00:00+02:00 -51.5 -36.2 +2023-07-11T02:00:00+02:00 -58.0 -43.4 +2023-07-11T03:00:00+02:00 -53.4 -40.6 +2023-07-11T04:00:00+02:00 -40.2 -28.2 +2023-07-11T05:00:00+02:00 -19.9 -8.9 +2023-07-11T06:00:00+02:00 2.0 13.0 +2023-07-11T07:00:00+02:00 22.5 32.3 +2023-07-11T08:00:00+02:00 34.7 44.4 +2023-07-11T09:00:00+02:00 36.6 46.3 +2023-07-11T10:00:00+02:00 27.4 37.6 +2023-07-11T11:00:00+02:00 11.1 19.9 +2023-07-11T12:00:00+02:00 -12.0 -2.7 +2023-07-11T13:00:00+02:00 -32.3 -24.6 +2023-07-11T14:00:00+02:00 -48.7 -41.0 +2023-07-11T15:00:00+02:00 -54.8 -48.6 +2023-07-11T16:00:00+02:00 -52.9 -46.5 +2023-07-11T17:00:00+02:00 -41.6 -35.6 +2023-07-11T18:00:00+02:00 -26.0 -18.8 +2023-07-11T19:00:00+02:00 -7.3 -0.3 +2023-07-11T20:00:00+02:00 6.4 15.1 +2023-07-11T21:00:00+02:00 13.3 23.8 +2023-07-11T22:00:00+02:00 13.3 24.1 +2023-07-11T23:00:00+02:00 4.3 16.0 +2023-07-12T00:00:00+02:00 -9.3 1.6 +2023-07-12T01:00:00+02:00 -26.6 -14.8 +2023-07-12T02:00:00+02:00 -39.7 -28.6 +2023-07-12T03:00:00+02:00 -46.3 -35.9 +2023-07-12T04:00:00+02:00 -45.1 -34.7 +2023-07-12T05:00:00+02:00 -34.3 -25.1 +2023-07-12T06:00:00+02:00 -19.1 -9.2 +2023-07-12T07:00:00+02:00 -0.5 9.6 +2023-07-12T08:00:00+02:00 14.9 26.6 +2023-07-12T09:00:00+02:00 26.8 37.7 +2023-07-12T10:00:00+02:00 28.2 40.0 +2023-07-12T11:00:00+02:00 21.2 32.9 +2023-07-12T12:00:00+02:00 5.8 17.7 +2023-07-12T13:00:00+02:00 -14.4 -2.0 +2023-07-12T14:00:00+02:00 -32.7 -21.6 +2023-07-12T15:00:00+02:00 -47.9 -36.6 +2023-07-12T16:00:00+02:00 -53.2 -44.1 +2023-07-12T17:00:00+02:00 -52.2 -42.7 +2023-07-12T18:00:00+02:00 -41.5 -33.1 +2023-07-12T19:00:00+02:00 -27.2 -17.6 +2023-07-12T20:00:00+02:00 -9.7 -0.1 +2023-07-12T21:00:00+02:00 3.6 15.2 +2023-07-12T22:00:00+02:00 12.8 24.7 +2023-07-12T23:00:00+02:00 13.6 26.5 +2023-07-13T00:00:00+02:00 6.9 20.3 +2023-07-13T01:00:00+02:00 -5.9 7.6 +2023-07-13T02:00:00+02:00 -20.8 -7.9 +2023-07-13T03:00:00+02:00 -34.8 -21.9 +2023-07-13T04:00:00+02:00 -41.3 -30.6 +2023-07-13T05:00:00+02:00 -44.7 -31.6 +2023-07-13T06:00:00+02:00 -36.2 -24.7 +2023-07-13T07:00:00+02:00 -24.7 -11.3 +2023-07-13T08:00:00+02:00 -7.6 5.5 +2023-07-13T09:00:00+02:00 7.2 21.6 +2023-07-13T10:00:00+02:00 18.2 32.7 +2023-07-13T11:00:00+02:00 20.4 36.0 +2023-07-13T12:00:00+02:00 15.3 30.5 +2023-07-13T13:00:00+02:00 1.2 17.1 +2023-07-13T14:00:00+02:00 -17.1 -1.0 +2023-07-13T15:00:00+02:00 -34.9 -19.6 +2023-07-13T16:00:00+02:00 -50.2 -34.3 +2023-07-13T17:00:00+02:00 -57.2 -42.0 +2023-07-13T18:00:00+02:00 -56.4 -41.0 +2023-07-13T19:00:00+02:00 -46.5 -31.7 +2023-07-13T20:00:00+02:00 -33.2 -16.2 +2023-07-13T21:00:00+02:00 -15.4 1.9 +2023-07-13T22:00:00+02:00 -1.4 18.2 +2023-07-13T23:00:00+02:00 9.5 28.9 +2023-07-14T00:00:00+02:00 10.7 31.9 +2023-07-14T01:00:00+02:00 5.5 26.4 +2023-07-14T02:00:00+02:00 -7.0 13.8 +2023-07-14T03:00:00+02:00 -22.8 -2.5 +2023-07-14T04:00:00+02:00 -38.2 -18.0 +2023-07-14T05:00:00+02:00 -48.2 -28.6 +2023-07-14T06:00:00+02:00 -50.8 -31.6 +2023-07-14T07:00:00+02:00 -46.4 -26.5 +2023-07-14T08:00:00+02:00 -33.6 -14.2 +2023-07-14T09:00:00+02:00 -18.6 2.4 +2023-07-14T10:00:00+02:00 -1.4 18.8 +2023-07-14T11:00:00+02:00 10.8 30.6 +2023-07-14T12:00:00+02:00 15.3 34.8 +2023-07-14T13:00:00+02:00 11.6 30.1 +2023-07-14T14:00:00+02:00 0.1 17.2 +2023-07-14T15:00:00+02:00 -17.8 -0.9 +2023-07-14T16:00:00+02:00 -36.5 -19.7 +2023-07-14T17:00:00+02:00 -50.0 -34.8 +2023-07-14T18:00:00+02:00 -58.4 -42.4 +2023-07-14T19:00:00+02:00 -56.0 -40.9 +2023-07-14T20:00:00+02:00 -46.4 -30.6 +2023-07-14T21:00:00+02:00 -28.7 -13.5 +2023-07-14T22:00:00+02:00 -9.4 6.3 +2023-07-14T23:00:00+02:00 7.4 24.1 +2023-07-15T00:00:00+02:00 19.6 35.8 +2023-07-15T01:00:00+02:00 22.4 38.9 +2023-07-15T02:00:00+02:00 16.0 32.5 +2023-07-15T03:00:00+02:00 2.1 18.2 +2023-07-15T04:00:00+02:00 -16.1 -0.2 +2023-07-15T05:00:00+02:00 -33.9 -17.9 +2023-07-15T06:00:00+02:00 -47.6 -30.2 +2023-07-15T07:00:00+02:00 -51.4 -34.3 +2023-07-15T08:00:00+02:00 -47.6 -29.2 +2023-07-15T09:00:00+02:00 -33.9 -16.3 +2023-07-15T10:00:00+02:00 -16.7 1.5 +2023-07-15T11:00:00+02:00 0.9 19.0 +2023-07-15T12:00:00+02:00 13.3 31.5 +2023-07-15T13:00:00+02:00 18.2 35.8 +2023-07-15T14:00:00+02:00 12.9 30.6 +2023-07-15T15:00:00+02:00 -0.1 16.6 +2023-07-15T16:00:00+02:00 -21.0 -2.8 +2023-07-15T17:00:00+02:00 -39.0 -22.7 +2023-07-15T18:00:00+02:00 -55.8 -37.9 +2023-07-15T19:00:00+02:00 -60.6 -44.7 +2023-07-15T20:00:00+02:00 -57.7 -41.3 +2023-07-15T21:00:00+02:00 -43.1 -28.4 +2023-07-15T22:00:00+02:00 -23.1 -8.6 +2023-07-15T23:00:00+02:00 -0.7 13.6 +2023-07-16T00:00:00+02:00 18.4 32.5 +2023-07-16T01:00:00+02:00 30.7 43.9 +2023-07-16T02:00:00+02:00 32.1 45.4 +2023-07-16T03:00:00+02:00 23.5 36.4 +2023-07-16T04:00:00+02:00 5.9 19.0 +2023-07-16T05:00:00+02:00 -15.5 -2.3 +2023-07-16T06:00:00+02:00 -35.4 -21.8 +2023-07-16T07:00:00+02:00 -47.1 -34.7 +2023-07-16T08:00:00+02:00 -50.2 -38.1 +2023-07-16T09:00:00+02:00 -43.3 -31.3 +2023-07-16T10:00:00+02:00 -28.2 -16.1 +2023-07-16T11:00:00+02:00 -7.8 3.6 +2023-07-16T12:00:00+02:00 10.4 22.3 +2023-07-16T13:00:00+02:00 22.6 34.8 +2023-07-16T14:00:00+02:00 26.7 37.8 +2023-07-16T15:00:00+02:00 19.2 30.4 +2023-07-16T16:00:00+02:00 2.8 13.9 +2023-07-16T17:00:00+02:00 -18.6 -7.6 +2023-07-16T18:00:00+02:00 -38.8 -28.4 +2023-07-16T19:00:00+02:00 -53.2 -43.0 +2023-07-16T20:00:00+02:00 -58.1 -47.4 +2023-07-16T21:00:00+02:00 -50.5 -40.7 +2023-07-16T22:00:00+02:00 -33.9 -23.9 +2023-07-16T23:00:00+02:00 -9.0 -0.8 +2023-07-17T00:00:00+02:00 13.6 23.2 +2023-07-17T01:00:00+02:00 33.4 42.0 +2023-07-17T02:00:00+02:00 41.6 51.5 +2023-07-17T03:00:00+02:00 40.1 49.6 +2023-07-17T04:00:00+02:00 26.6 36.5 +2023-07-17T05:00:00+02:00 4.3 15.2 +2023-07-17T06:00:00+02:00 -18.8 -8.5 +2023-07-17T07:00:00+02:00 -41.0 -28.7 +2023-07-17T08:00:00+02:00 -50.8 -40.5 +2023-07-17T09:00:00+02:00 -53.5 -41.3 +2023-07-17T10:00:00+02:00 -41.7 -31.2 +2023-07-17T11:00:00+02:00 -24.6 -12.9 +2023-07-17T12:00:00+02:00 -2.9 8.9 +2023-07-17T13:00:00+02:00 14.6 27.8 +2023-07-17T14:00:00+02:00 26.2 38.7 +2023-07-17T15:00:00+02:00 24.7 38.9 +2023-07-17T16:00:00+02:00 15.2 27.9 +2023-07-17T17:00:00+02:00 -6.8 8.1 +2023-07-17T18:00:00+02:00 -29.6 -15.4 +2023-07-17T19:00:00+02:00 -51.0 -36.1 +2023-07-17T20:00:00+02:00 -62.2 -48.4 +2023-07-17T21:00:00+02:00 -62.7 -48.9 +2023-07-17T22:00:00+02:00 -50.5 -37.5 +2023-07-17T23:00:00+02:00 -27.8 -16.4 +2023-07-18T00:00:00+02:00 -2.2 9.6 +2023-07-18T01:00:00+02:00 22.7 34.0 +2023-07-18T02:00:00+02:00 39.1 50.9 +2023-07-18T03:00:00+02:00 45.0 56.6 +2023-07-18T04:00:00+02:00 37.7 49.8 +2023-07-18T05:00:00+02:00 19.8 31.9 +2023-07-18T06:00:00+02:00 -4.5 7.2 +2023-07-18T07:00:00+02:00 -29.8 -17.8 +2023-07-18T08:00:00+02:00 -48.0 -36.9 +2023-07-18T09:00:00+02:00 -56.4 -45.5 +2023-07-18T10:00:00+02:00 -53.0 -42.1 +2023-07-18T11:00:00+02:00 -39.5 -27.9 +2023-07-18T12:00:00+02:00 -18.3 -6.4 +2023-07-18T13:00:00+02:00 3.8 16.4 +2023-07-18T14:00:00+02:00 20.9 33.9 +2023-07-18T15:00:00+02:00 28.0 41.6 +2023-07-18T16:00:00+02:00 22.9 37.5 +2023-07-18T17:00:00+02:00 8.0 22.1 +2023-07-18T18:00:00+02:00 -15.4 -0.9 +2023-07-18T19:00:00+02:00 -40.4 -25.2 +2023-07-18T20:00:00+02:00 -58.7 -44.1 +2023-07-18T21:00:00+02:00 -66.9 -52.4 +2023-07-18T22:00:00+02:00 -62.0 -47.7 +2023-07-18T23:00:00+02:00 -45.1 -31.0 +2023-07-19T00:00:00+02:00 -19.4 -5.9 +2023-07-19T01:00:00+02:00 8.4 21.5 +2023-07-19T02:00:00+02:00 31.8 44.4 +2023-07-19T03:00:00+02:00 45.2 57.3 +2023-07-19T04:00:00+02:00 43.9 57.7 +2023-07-19T05:00:00+02:00 32.2 45.3 +2023-07-19T06:00:00+02:00 8.3 22.8 +2023-07-19T07:00:00+02:00 -17.2 -4.1 +2023-07-19T08:00:00+02:00 -42.4 -28.3 +2023-07-19T09:00:00+02:00 -56.7 -44.2 +2023-07-19T10:00:00+02:00 -61.0 -48.1 +2023-07-19T11:00:00+02:00 -50.7 -39.6 +2023-07-19T12:00:00+02:00 -33.0 -21.1 +2023-07-19T13:00:00+02:00 -8.8 2.4 +2023-07-19T14:00:00+02:00 12.9 24.5 +2023-07-19T15:00:00+02:00 27.9 38.9 +2023-07-19T16:00:00+02:00 29.3 41.8 +2023-07-19T17:00:00+02:00 21.3 32.6 +2023-07-19T18:00:00+02:00 0.6 13.0 +2023-07-19T19:00:00+02:00 -23.9 -12.0 +2023-07-19T20:00:00+02:00 -47.9 -35.3 +2023-07-19T21:00:00+02:00 -63.9 -50.5 +2023-07-19T22:00:00+02:00 -66.3 -53.3 +2023-07-19T23:00:00+02:00 -55.9 -42.7 +2023-07-20T00:00:00+02:00 -32.7 -21.1 +2023-07-20T01:00:00+02:00 -4.8 6.4 +2023-07-20T02:00:00+02:00 22.8 33.2 +2023-07-20T03:00:00+02:00 41.7 52.5 +2023-07-20T04:00:00+02:00 49.2 59.9 +2023-07-20T05:00:00+02:00 42.9 54.2 +2023-07-20T06:00:00+02:00 25.1 36.3 +2023-07-20T07:00:00+02:00 -1.5 10.6 +2023-07-20T08:00:00+02:00 -28.1 -16.5 +2023-07-20T09:00:00+02:00 -50.6 -37.9 +2023-07-20T10:00:00+02:00 -61.0 -48.8 +2023-07-20T11:00:00+02:00 -58.6 -47.0 +2023-07-20T12:00:00+02:00 -45.0 -33.5 +2023-07-20T13:00:00+02:00 -23.2 -11.9 +2023-07-20T14:00:00+02:00 0.2 12.0 +2023-07-20T15:00:00+02:00 18.8 31.4 +2023-07-20T16:00:00+02:00 27.3 41.1 +2023-07-20T17:00:00+02:00 23.9 38.6 +2023-07-20T18:00:00+02:00 9.8 24.4 +2023-07-20T19:00:00+02:00 -12.8 1.6 +2023-07-20T20:00:00+02:00 -38.6 -23.5 +2023-07-20T21:00:00+02:00 -58.2 -43.8 +2023-07-20T22:00:00+02:00 -67.9 -53.6 +2023-07-20T23:00:00+02:00 -64.4 -50.2 +2023-07-21T00:00:00+02:00 -48.7 -33.9 +2023-07-21T01:00:00+02:00 -24.1 -8.8 +2023-07-21T02:00:00+02:00 4.6 19.1 +2023-07-21T03:00:00+02:00 27.8 43.0 +2023-07-21T04:00:00+02:00 41.5 57.0 +2023-07-21T05:00:00+02:00 42.4 58.2 +2023-07-21T06:00:00+02:00 30.6 46.4 +2023-07-21T07:00:00+02:00 8.4 24.3 +2023-07-21T08:00:00+02:00 -19.3 -2.9 +2023-07-21T09:00:00+02:00 -43.2 -28.0 +2023-07-21T10:00:00+02:00 -60.5 -44.8 +2023-07-21T11:00:00+02:00 -64.8 -49.9 +2023-07-21T12:00:00+02:00 -58.0 -42.4 +2023-07-21T13:00:00+02:00 -40.9 -24.7 +2023-07-21T14:00:00+02:00 -17.0 -1.6 +2023-07-21T15:00:00+02:00 3.9 20.6 +2023-07-21T16:00:00+02:00 19.7 35.7 +2023-07-21T17:00:00+02:00 23.2 39.9 +2023-07-21T18:00:00+02:00 14.9 32.0 +2023-07-21T19:00:00+02:00 -2.4 13.9 +2023-07-21T20:00:00+02:00 -26.5 -10.1 +2023-07-21T21:00:00+02:00 -50.0 -33.2 +2023-07-21T22:00:00+02:00 -64.9 -48.8 +2023-07-21T23:00:00+02:00 -69.2 -52.5 +2023-07-22T00:00:00+02:00 -58.2 -43.0 +2023-07-22T01:00:00+02:00 -38.6 -22.5 +2023-07-22T02:00:00+02:00 -11.9 4.1 +2023-07-22T03:00:00+02:00 13.9 30.2 +2023-07-22T04:00:00+02:00 33.1 49.5 +2023-07-22T05:00:00+02:00 41.0 57.3 +2023-07-22T06:00:00+02:00 35.4 52.3 +2023-07-22T07:00:00+02:00 18.7 35.6 +2023-07-22T08:00:00+02:00 -6.3 11.0 +2023-07-22T09:00:00+02:00 -33.3 -15.4 +2023-07-22T10:00:00+02:00 -54.8 -36.7 +2023-07-22T11:00:00+02:00 -66.5 -48.0 +2023-07-22T12:00:00+02:00 -65.5 -47.2 +2023-07-22T13:00:00+02:00 -54.1 -35.0 +2023-07-22T14:00:00+02:00 -33.6 -14.9 +2023-07-22T15:00:00+02:00 -11.2 7.7 +2023-07-22T16:00:00+02:00 8.0 26.6 +2023-07-22T17:00:00+02:00 17.6 36.7 +2023-07-22T18:00:00+02:00 16.3 35.5 +2023-07-22T19:00:00+02:00 4.9 23.3 +2023-07-22T20:00:00+02:00 -15.2 3.0 +2023-07-22T21:00:00+02:00 -38.1 -20.1 +2023-07-22T22:00:00+02:00 -58.6 -39.4 +2023-07-22T23:00:00+02:00 -66.7 -49.3 +2023-07-23T00:00:00+02:00 -64.3 -47.1 +2023-07-23T01:00:00+02:00 -51.6 -32.9 +2023-07-23T02:00:00+02:00 -29.0 -10.1 +2023-07-23T03:00:00+02:00 -3.4 15.7 +2023-07-23T04:00:00+02:00 18.9 38.1 +2023-07-23T05:00:00+02:00 33.2 51.8 +2023-07-23T06:00:00+02:00 34.5 53.7 +2023-07-23T07:00:00+02:00 25.1 43.5 +2023-07-23T08:00:00+02:00 5.2 23.6 +2023-07-23T09:00:00+02:00 -19.9 -1.4 +2023-07-23T10:00:00+02:00 -42.4 -25.1 +2023-07-23T11:00:00+02:00 -59.2 -41.6 +2023-07-23T12:00:00+02:00 -64.7 -47.3 +2023-07-23T13:00:00+02:00 -59.0 -41.6 +2023-07-23T14:00:00+02:00 -43.0 -26.3 +2023-07-23T15:00:00+02:00 -23.4 -5.7 +2023-07-23T16:00:00+02:00 -1.8 14.6 +2023-07-23T17:00:00+02:00 12.2 29.3 +2023-07-23T18:00:00+02:00 19.2 34.6 +2023-07-23T19:00:00+02:00 12.4 29.1 +2023-07-23T20:00:00+02:00 -0.6 14.4 +2023-07-23T21:00:00+02:00 -22.1 -6.0 +2023-07-23T22:00:00+02:00 -42.3 -26.6 +2023-07-23T23:00:00+02:00 -57.4 -41.1 +2023-07-24T00:00:00+02:00 -61.9 -45.6 +2023-07-24T01:00:00+02:00 -54.9 -38.6 +2023-07-24T02:00:00+02:00 -38.1 -21.8 +2023-07-24T03:00:00+02:00 -15.8 1.0 +2023-07-24T04:00:00+02:00 6.7 24.1 +2023-07-24T05:00:00+02:00 24.6 41.9 +2023-07-24T06:00:00+02:00 31.9 50.2 +2023-07-24T07:00:00+02:00 29.5 47.1 +2023-07-24T08:00:00+02:00 16.0 33.5 +2023-07-24T09:00:00+02:00 -4.5 12.4 +2023-07-24T10:00:00+02:00 -28.3 -11.2 +2023-07-24T11:00:00+02:00 -47.1 -31.1 +2023-07-24T12:00:00+02:00 -60.4 -42.6 +2023-07-24T13:00:00+02:00 -59.3 -43.7 +2023-07-24T14:00:00+02:00 -51.6 -34.7 +2023-07-24T15:00:00+02:00 -34.6 -18.2 +2023-07-24T16:00:00+02:00 -16.3 1.3 +2023-07-24T17:00:00+02:00 2.0 18.5 +2023-07-24T18:00:00+02:00 12.2 29.2 +2023-07-24T19:00:00+02:00 14.0 30.6 +2023-07-24T20:00:00+02:00 6.5 22.5 +2023-07-24T21:00:00+02:00 -9.0 7.2 +2023-07-24T22:00:00+02:00 -28.4 -11.7 +2023-07-24T23:00:00+02:00 -45.5 -28.6 +2023-07-25T00:00:00+02:00 -55.6 -38.5 +2023-07-25T01:00:00+02:00 -55.4 -38.7 +2023-07-25T02:00:00+02:00 -45.8 -29.2 +2023-07-25T03:00:00+02:00 -27.9 -11.8 +2023-07-25T04:00:00+02:00 -7.2 9.2 +2023-07-25T05:00:00+02:00 11.4 28.5 +2023-07-25T06:00:00+02:00 24.7 41.7 +2023-07-25T07:00:00+02:00 28.2 45.5 +2023-07-25T08:00:00+02:00 22.0 39.2 +2023-07-25T09:00:00+02:00 6.3 24.0 +2023-07-25T10:00:00+02:00 -14.0 3.5 +2023-07-25T11:00:00+02:00 -34.2 -17.4 +2023-07-25T12:00:00+02:00 -49.6 -33.3 +2023-07-25T13:00:00+02:00 -56.2 -40.8 +2023-07-25T14:00:00+02:00 -55.2 -38.8 +2023-07-25T15:00:00+02:00 -43.2 -28.3 +2023-07-25T16:00:00+02:00 -28.4 -12.2 +2023-07-25T17:00:00+02:00 -9.6 5.3 +2023-07-25T18:00:00+02:00 3.6 19.6 +2023-07-25T19:00:00+02:00 11.8 27.2 +2023-07-25T20:00:00+02:00 9.6 26.4 +2023-07-25T21:00:00+02:00 1.6 17.7 +2023-07-25T22:00:00+02:00 -14.4 3.3 +2023-07-25T23:00:00+02:00 -29.8 -13.0 +2023-07-26T00:00:00+02:00 -44.9 -26.4 +2023-07-26T01:00:00+02:00 -49.8 -32.9 +2023-07-26T02:00:00+02:00 -49.2 -31.0 +2023-07-26T03:00:00+02:00 -37.2 -20.9 +2023-07-26T04:00:00+02:00 -22.9 -4.9 +2023-07-26T05:00:00+02:00 -4.0 13.2 +2023-07-26T06:00:00+02:00 10.6 28.9 +2023-07-26T07:00:00+02:00 21.5 38.4 +2023-07-26T08:00:00+02:00 21.6 39.5 +2023-07-26T09:00:00+02:00 13.8 31.8 +2023-07-26T10:00:00+02:00 -1.4 16.9 +2023-07-26T11:00:00+02:00 -20.3 -1.9 +2023-07-26T12:00:00+02:00 -37.8 -19.9 +2023-07-26T13:00:00+02:00 -51.1 -32.8 +2023-07-26T14:00:00+02:00 -55.6 -37.8 +2023-07-26T15:00:00+02:00 -51.0 -34.5 +2023-07-26T16:00:00+02:00 -40.5 -24.1 +2023-07-26T17:00:00+02:00 -24.6 -9.2 +2023-07-26T18:00:00+02:00 -9.5 6.4 +2023-07-26T19:00:00+02:00 3.9 18.8 +2023-07-26T20:00:00+02:00 9.3 25.0 +2023-07-26T21:00:00+02:00 8.3 23.9 +2023-07-26T22:00:00+02:00 0.2 16.0 +2023-07-26T23:00:00+02:00 -11.7 3.5 +2023-07-27T00:00:00+02:00 -26.7 -10.3 +2023-07-27T01:00:00+02:00 -36.8 -21.4 +2023-07-27T02:00:00+02:00 -41.2 -26.6 +2023-07-27T03:00:00+02:00 -39.1 -24.6 +2023-07-27T04:00:00+02:00 -29.6 -15.8 +2023-07-27T05:00:00+02:00 -16.3 -2.1 +2023-07-27T06:00:00+02:00 -0.6 13.1 +2023-07-27T07:00:00+02:00 12.2 26.2 +2023-07-27T08:00:00+02:00 19.2 33.8 +2023-07-27T09:00:00+02:00 19.8 34.1 +2023-07-27T10:00:00+02:00 11.7 26.7 +2023-07-27T11:00:00+02:00 -1.8 13.1 +2023-07-27T12:00:00+02:00 -19.7 -3.7 +2023-07-27T13:00:00+02:00 -33.9 -19.7 +2023-07-27T14:00:00+02:00 -46.4 -31.0 +2023-07-27T15:00:00+02:00 -48.1 -35.4 +2023-07-27T16:00:00+02:00 -46.4 -32.5 +2023-07-27T17:00:00+02:00 -34.9 -23.0 +2023-07-27T18:00:00+02:00 -21.6 -9.2 +2023-07-27T19:00:00+02:00 -6.3 5.4 +2023-07-27T20:00:00+02:00 5.4 17.5 +2023-07-27T21:00:00+02:00 13.2 24.3 +2023-07-27T22:00:00+02:00 12.4 24.4 +2023-07-27T23:00:00+02:00 6.9 18.2 +2023-07-28T00:00:00+02:00 -5.8 7.4 +2023-07-28T01:00:00+02:00 -17.6 -5.2 +2023-07-28T02:00:00+02:00 -29.1 -15.9 +2023-07-28T03:00:00+02:00 -33.8 -21.9 +2023-07-28T04:00:00+02:00 -34.0 -21.6 +2023-07-28T05:00:00+02:00 -27.3 -15.1 +2023-07-28T06:00:00+02:00 -15.5 -3.7 +2023-07-28T07:00:00+02:00 -2.8 9.8 +2023-07-28T08:00:00+02:00 10.9 22.0 +2023-07-28T09:00:00+02:00 16.4 29.8 +2023-07-28T10:00:00+02:00 18.3 31.0 +2023-07-28T11:00:00+02:00 11.0 25.1 +2023-07-28T12:00:00+02:00 -1.0 13.1 +2023-07-28T13:00:00+02:00 -17.6 -2.6 +2023-07-28T14:00:00+02:00 -32.8 -18.1 +2023-07-28T15:00:00+02:00 -43.5 -29.9 +2023-07-28T16:00:00+02:00 -49.5 -35.4 +2023-07-28T17:00:00+02:00 -46.6 -33.8 +2023-07-28T18:00:00+02:00 -38.0 -25.2 +2023-07-28T19:00:00+02:00 -23.2 -11.6 +2023-07-28T20:00:00+02:00 -8.8 3.8 +2023-07-28T21:00:00+02:00 5.1 17.5 +2023-07-28T22:00:00+02:00 12.9 26.3 +2023-07-28T23:00:00+02:00 15.1 28.5 +2023-07-29T00:00:00+02:00 9.6 23.9 +2023-07-29T01:00:00+02:00 -1.3 13.6 +2023-07-29T02:00:00+02:00 -14.1 0.3 +2023-07-29T03:00:00+02:00 -27.3 -12.3 +2023-07-29T04:00:00+02:00 -34.8 -20.8 +2023-07-29T05:00:00+02:00 -37.5 -23.3 +2023-07-29T06:00:00+02:00 -32.0 -19.0 +2023-07-29T07:00:00+02:00 -21.4 -8.8 +2023-07-29T08:00:00+02:00 -7.4 4.7 +2023-07-29T09:00:00+02:00 5.2 18.2 +2023-07-29T10:00:00+02:00 15.8 28.1 +2023-07-29T11:00:00+02:00 18.0 31.5 +2023-07-29T12:00:00+02:00 13.9 27.3 +2023-07-29T13:00:00+02:00 0.9 16.1 +2023-07-29T14:00:00+02:00 -14.5 0.1 +2023-07-29T15:00:00+02:00 -31.2 -16.9 +2023-07-29T16:00:00+02:00 -44.5 -30.9 +2023-07-29T17:00:00+02:00 -50.9 -38.6 +2023-07-29T18:00:00+02:00 -50.3 -38.3 +2023-07-29T19:00:00+02:00 -41.6 -29.8 +2023-07-29T20:00:00+02:00 -25.5 -14.8 +2023-07-29T21:00:00+02:00 -8.6 3.2 +2023-07-29T22:00:00+02:00 8.2 20.0 +2023-07-29T23:00:00+02:00 20.0 31.8 +2023-07-30T00:00:00+02:00 23.4 35.9 +2023-07-30T01:00:00+02:00 20.2 31.7 +2023-07-30T02:00:00+02:00 7.3 20.1 +2023-07-30T03:00:00+02:00 -7.2 3.9 +2023-07-30T04:00:00+02:00 -23.3 -12.3 +2023-07-30T05:00:00+02:00 -34.8 -24.6 +2023-07-30T06:00:00+02:00 -39.6 -29.8 +2023-07-30T07:00:00+02:00 -35.7 -26.7 +2023-07-30T08:00:00+02:00 -23.6 -16.0 +2023-07-30T09:00:00+02:00 -8.1 -0.4 +2023-07-30T10:00:00+02:00 9.4 16.3 +2023-07-30T11:00:00+02:00 22.3 29.5 +2023-07-30T12:00:00+02:00 26.8 35.5 +2023-07-30T13:00:00+02:00 23.9 32.5 +2023-07-30T14:00:00+02:00 10.6 20.8 +2023-07-30T15:00:00+02:00 -7.5 2.6 +2023-07-30T16:00:00+02:00 -29.2 -17.6 +2023-07-30T17:00:00+02:00 -44.7 -34.8 +2023-07-30T18:00:00+02:00 -55.7 -44.9 +2023-07-30T19:00:00+02:00 -54.6 -45.1 +2023-07-30T20:00:00+02:00 -44.1 -35.1 +2023-07-30T21:00:00+02:00 -26.9 -17.0 +2023-07-30T22:00:00+02:00 -3.4 5.1 +2023-07-30T23:00:00+02:00 16.7 26.0 +2023-07-31T00:00:00+02:00 31.8 40.6 +2023-07-31T01:00:00+02:00 37.3 45.5 +2023-07-31T02:00:00+02:00 30.7 40.0 +2023-07-31T03:00:00+02:00 16.5 24.9 +2023-07-31T04:00:00+02:00 -4.8 4.1 +2023-07-31T05:00:00+02:00 -24.0 -17.0 +2023-07-31T06:00:00+02:00 -40.9 -33.1 +2023-07-31T07:00:00+02:00 -46.9 -40.2 +2023-07-31T08:00:00+02:00 -43.6 -36.7 +2023-07-31T09:00:00+02:00 -28.9 -23.6 +2023-07-31T10:00:00+02:00 -9.8 -3.9 +2023-07-31T11:00:00+02:00 11.6 17.2 +2023-07-31T12:00:00+02:00 25.4 34.1 +2023-07-31T13:00:00+02:00 33.9 42.1 +2023-07-31T14:00:00+02:00 28.5 39.0 +2023-07-31T15:00:00+02:00 16.0 25.1 +2023-07-31T16:00:00+02:00 -9.5 3.3 +2023-07-31T17:00:00+02:00 -32.4 -21.1 +2023-07-31T18:00:00+02:00 -53.3 -41.7 +2023-07-31T19:00:00+02:00 -63.3 -53.2 +2023-07-31T20:00:00+02:00 -63.6 -52.4 +2023-07-31T21:00:00+02:00 -49.7 -39.3 +2023-07-31T22:00:00+02:00 -26.6 -16.5 +2023-07-31T23:00:00+02:00 1.0 10.6 +2023-08-01T00:00:00+02:00 25.5 35.3 +2023-08-01T01:00:00+02:00 41.4 51.6 From 62ce9328653fb578be211427da284f1b229fdb76 Mon Sep 17 00:00:00 2001 From: JRT Date: Thu, 17 Aug 2023 12:59:52 +0200 Subject: [PATCH 3/3] Fix plots labels and titles --- .../SimpleScriptGetTideCurrentTimeseries.ipynb | 16 +++++++++------- .../SimpleScriptGetTideElevationTimeseries.ipynb | 5 ++++- 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb b/notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb index c089533d..9f474e5b 100644 --- a/notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb +++ b/notebooks/SimpleScriptGetTideCurrentTimeseries.ipynb @@ -266,16 +266,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2023-08-15 16:03:08-- https://arcticdata.io/metacat/d1/mn/v2/object/urn%3Auuid%3Ad5f179a3-76a8-4e4f-b45f-8e8d85960ba6\n", + "--2023-08-17 12:58:27-- https://arcticdata.io/metacat/d1/mn/v2/object/urn%3Auuid%3Ad5f179a3-76a8-4e4f-b45f-8e8d85960ba6\n", "Resolving arcticdata.io (arcticdata.io)... 128.111.85.224\n", "Connecting to arcticdata.io (arcticdata.io)|128.111.85.224|:443... connected.\n", "HTTP request sent, awaiting response... 200 200\n", "Length: unspecified [application/netcdf]\n", "Saving to: ‘urn:uuid:d5f179a3-76a8-4e4f-b45f-8e8d85960ba6’\n", "\n", - "urn:uuid:d5f179a3-7 [ <=> ] 1,21M 937KB/s in 1,3s \n", + "urn:uuid:d5f179a3-7 [ <=> ] 1,21M 1,12MB/s in 1,1s \n", "\n", - "2023-08-15 16:03:10 (937 KB/s) - ‘urn:uuid:d5f179a3-76a8-4e4f-b45f-8e8d85960ba6’ saved [1264327]\n", + "2023-08-17 12:58:29 (1,12 MB/s) - ‘urn:uuid:d5f179a3-76a8-4e4f-b45f-8e8d85960ba6’ saved [1264327]\n", "\n" ] } @@ -465,7 +465,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -475,7 +475,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAHlCAYAAADm9LYpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAD/mklEQVR4nOz9d7htWVkljI+1czj5nHtuDpUzBVQVRU4toVSU8LWKrQ2CgLGxEf390G6l+WxBbaBUFFtUKG21jZhQCgSqilhUpHLdCjffc++5J++c1vr+mPOda669V15znzjH89xnn7vDWeHsvedY4x3veA3LsixoaGhoaGhoaGwDpDZ6BzQ0NDQ0NDQ0VEETGw0NDQ0NDY1tA01sNDQ0NDQ0NLYNNLHR0NDQ0NDQ2DbQxEZDQ0NDQ0Nj20ATGw0NDQ0NDY1tA01sNDQ0NDQ0NLYNMhu9A0lRLpfRbDaRTqcxOzu70bujoaGhoaGhEQLz8/Po9XooFAqo1WrKfq+x1QP60uk0TNPc6N3Q0NDQ0NDQiIFUKoVer6fs9215xYaITSqVwt69ezd6dzQ0NDQ0NDRCYG5uDqZpIp1OK/29W57YzM7O4syZM9i7dy9Onz690bujoaGhoaGhEQIHDhzAmTNnlNtItHlYQ0NDQ0NDY9tAExsNDQ0NDQ2NbQNNbDQ0NDQ0NDS2Dba8xyYser0eOp3ORu/GjkA2m1VuBtPQ0NDQ0AiDbU9sLMvCuXPnsLKystG7sqMwMTGBPXv2wDCMjd4VDQ0NDY0dhG1PbIjUzM7OolQq6YV2yLAsC/V6HfPz8wCgW/A1NDQ0NNYV25rY9Ho9QWqmp6c3end2DIrFIgCWKjk7O6vLUhoaGhoa64ZtbR4mT02pVNrgPdl5oHOufU0aGhoaGuuJbU1sCLr8tP7Q51xDQ0NDYyOwI4iNhoaGhoaGxs6AJjYasfD2t78db3zjGzd6NzQ0NDQ0NBzQxGabQhMPDQ0NDY2dCE1sNDQ0NLYzeh3A7G30XmhorBs0sdmkeOUrX4mf+Zmfwc/8zM9gYmIC09PT+G//7b/Bsix86EMfwnXXXTfwmhtuuAG/8iu/gg9+8IO47bbb8I//+I8wDAOGYeCOO+7A8ePHYRgG/vqv/xove9nLUCwWcdNNN+Ho0aO45557cOONN2JkZASvf/3rceHCBfF7e70e3ve+94n9+MVf/EVYlrWep0NDQyMOOg3gky8Gfu8FQLe10XujobEu2NY5Nm6wLAuNzvpfvRSz6cidQrfddhve+c534u6778a9996Ld7/73Th8+DDe8Y534H/8j/+Be+65BzfddBMA4KGHHsIDDzyAv/mbv8Hs7Cwef/xxrK2t4dOf/jQAYGpqCmfPngUA/Oqv/ipuvfVWHDp0CO94xzvw1re+FWNjY/jt3/5tlEol/MAP/AB+5Vd+BZ/85CcBAB/96EfxJ3/yJ/jjP/5jXH311fjoRz+Kz372s3j1q1+t8AxpaGgox/1/CiwcZT8f/ypw6Xdt7P5oaKwDdhyxaXR6uPpXbl/37T72odehlIt2ug8ePIiPf/zjMAwDV1xxBR5++GF8/OMfx7ve9S687nWvw6c//WlBbD796U/jFa94BS6++GIALCSv1Wphz549A7/3/e9/P173utcBAN773vfirW99K770pS/hJS95CQDgne98Jz7zmc+I59966634wAc+gLe85S0AgD/4gz/A7bev/znU0NCIiAf+zP75ic9pYqOxI6BLUZsYL3zhCx0qz4te9CI89dRT6PV6eNe73oW//Mu/RLPZRKfTwZ//+Z/jHe94R6jf+5znPEf8vHv3bgBwlLZ2794tRiKsrq5ibm4OL3rRi8TjmUwGN954Y6Jj09DQGDIsC1h42v7/sa9u3L6sBx75O+DO32LHrbGjseMUm2I2jcc+9LoN2a5KvOENb0A+n8dnP/tZ5PN5tFotoagEIZvNip+JOPXfZ5qm0v3V0NBYZ1TOAd2G/f/VU2zR347hmY/+A/C3/MLuopcDh27e0N3R2FjsOGJjGEbkktBG4Vvf+tbA/y+77DIxe+ltb3sbPv3pTyOfz+OHfuiHHKMjcrkcer3kXqLx8XHs3bsX3/rWt/Dyl78cANDtdnHffffh+c9/fuLfr6GhMSQsPctuR/cBlTmg2wTqi0B5ZmP3axi454/sn099SxObHY6tscLvUJw6dQrve9/78J73vAf3338/fvd3fxcf/ehHxeM//uM/jquuugoA8PWvf93x2iNHjuD222/Hk08+ienpaYyPj8fej/e+9734yEc+gssuuwxXXXUVPvaxj2FlZSX279PQ0FgHELGZvRKwTKB6jqk225HYLDxl/3zybuAlG7crGhsPTWw2Mf7zf/7PaDQaeMELXoB0Oo2f/dmfxbvf/W7x+GWXXYYXv/jFWFxcxM03O69Q3vWud+GOO+7AjTfeiGq1iq985Ss4cuRIrP34+Z//eczNzeHtb387UqkU3vGOd+BNb3oTVldXkxyehobGMEHEZuoSoLnGic1pYN/zNna/VKO5yo6NcPrbG7cvGpsCmthsYmSzWdx6662i7boflmXh/PnzeM973jPw2K5du/CFL3zB9TUyXvnKVw7c9/a3vx1vf/vbxf8zmQxuvfVW3HrrrdEPQkNDY2OweprdThwEaheAM/cCq2c2dp+GATJIZ0tAp86OtV0HciX/12lsW+iuqC2K+fl5fOxjH8OZM2fwYz/2Yxu9OxoaGpsN9QV2W54Fxg+wn1dPbdz+DAuU07P/BiBTZD/LCo7GjoNWbLYodu/ejZmZGfzhH/4hJicnN3p3NDQ0NhtqPD28vAsY3ct+rmzDBX/5OLudupipVMvH2HFOXbyhu6WxcdDEZpPijjvu8H1cjzTQ0NDwRY0UmxmgNsV+bixv3P4MCzWWuYXRPYzAEbHR2LHQpSgNDQ2N7QbLkhSbGaBIxGZp4/ZpWKhyYlPeBYyywFFNbHY2NLHR0NDYmXj634Fzj2z0XgwHzRXA7LKfSzNAiROb+jYkNq4lt7mN2x+NDYcmNhoaGjsPx78O/J+3ALe9Aeg0N3pv1KO2yG7zY0C2ABS5D6+xsmG7NDQQsRmZZeUoAKie37j90dhwaGKjoaGx8/C1j7HbxhLw5L9u7L4MA7TYl6bZLZWiWqtAr7sx+zQsVEmxmQVGOLHRis2OhiY2GhoaOwvdNvDMV+z/P/YPG7YrQ4NcngGA4oT92HYyEHcaQLvCfi5LJbftdIwakaGJjYaGxs7CygnAkuaoyXH82wV1Xoqi8QmpNFDgY1W206JPxuF0jh1fYYL9v6FT0XcyNLHZgrjjjjtgGIae16ShEQdEZHIj7Hb5OOsi2k5orrBbWuiB7dkZVZNCCA3DVqaamtjsZGhio6GhsbOwyCP4L34lYKTsGP7tBFrYC9Lw2+3YGUXKFB0bEbnWKmD2XF+y5WGaG70Hmx6a2GhoaOwsELHZfQ0wxkcNLB3buP0ZBtyIjeiM2kbEho6TlBr5eLejavPw3wIf3g/c/svbT2VUCE1sNilarRb+y3/5L5idnUWhUMBLX/pS3HPPPY7nfP3rX8f111+PQqGAm2++GQ8//LB47MSJE3jDG96AyclJlMtlXHPNNfjXf92G3R8aGlEhT72ePMx+plj+7QI3YkNqRnNt3XdnaBAlN36cmRwbhik/tp3w0F8xhfGbnwCe/tJG782mxc4bqWBZ7I2x3siWWA04JH7xF38Rf/d3f4fbbrsNhw8fxm/+5m/ida97HZ5++mnxnF/4hV/Ab//2b2PPnj34pV/6JXzf930fjh49imw2i5/+6Z9Gu93GXXfdhXK5jMceewwjIyPDODINja0FMpyO7WXE5vhXmaF4O8GN2ORH2W2rsv77Myy4eYkKE+w7frspNpYFnLnf/v/cg8Bl37Vhu7OZMVRic9ddd+G3fuu3cN9992Fubg6f/exn8cY3vlE8/va3vx233Xab4zU333wzvvWtbw1vpzp14Nf3De/3e+GXzgK5cqin1mo1fPKTn8RnPvMZ3HLLLQCAT33qU/jiF7+IP/7jP8ZNN90EAPjVX/1VvOY1rwEA3HbbbThw4AA++9nP4gd+4Adw8uRJvOUtb8F1110HALj4Yj0QTkMDgB3eVp4FRngE/3b12Mht3nl+YdPaToqNmzI1DlTObr8wwuVj9sR2wJ5qrjGAoZaiarUarr/+enziE5/wfM7rX/96zM3NiX+6XAI888wz6HQ6eMlLXiLuy2azeMELXoDHH39c3PeiF71I/Dw1NYUrrrhCPP5f/st/wa/92q/hJS95CX71V38VDz300PodgIbGZkW3ZV/lj8yycQOA3V2zXeCq2Iyx23Z1/fdnWBDHOWHfJzqjVtZ5Z4aMsw86/3/hiQ3Zja2AoSo2t9xyi1AcvJDP57Fnz55h7oYT2RJTT9YbVPcNAZrcbfSVrizLGrivH/T4j//4j+N1r3sdPve5z+ELX/gCPvzhD+OjH/0ofvZnfzbijmtobCOQMpPKMjMt5bzUdwKx2YalKFJlZGVKeIm2WSlq7Qy73Xs9MPcdFltgmkBKW2X7seFn5I477sDs7Cwuv/xyvOtd78L8/Lzv81utFtbW1sQ/K6oz3DBYSWi9/0Xw11x66aXI5XL42te+Ju7rdDq49957cdVVV4n75JLd8vIyjh49iiuvvFLcd/DgQfzET/wE/v7v/x4///M/j0996lPRzpWGxnYDlaFGeO4JERuarbRdsFOIjVcpCth+pag1Pibi8EsAI81sFVU9xdwNG0psbrnlFvz5n/85vvzlL+OjH/0o7rnnHrz61a9Gq9XyfM2HP/xhjI+Pi39nz26A+jJklMtl/ORP/iR+4Rd+AZ///Ofx2GOP4V3vehfq9Tre+c53iud96EMfwpe+9CU88sgjePvb346ZmRnhYfq5n/s53H777Th27Bjuv/9+fPnLX3aQIg2NHQmaKzQyy25FKWobeWw6TaDLB3tue2Kzwm4dbe0Tzse2Cyp8rRs/aI/K2E7vW4XY0K6oH/zBHxQ/X3vttbjxxhtx+PBhfO5zn8Ob3/xm19d84AMfwPve9z7x/6uuumpbkpuPfOQjME0TP/qjP4pKpYIbb7wRt99+OyYnJx3Pee9734unnnoK119/Pf7pn/4JuVwOANDr9fDTP/3TOH36NMbGxvD6178eH//4xzfqcDQ0NgeEYsNNw6IUtbh9ZH1hDjaA3Kh9PyUtbyti4+KxEQRuG3mJAFuxGdvLiE31nCY2HthU7d579+7F4cOH8dRT3rNb8vk88vm8+H+Q52SrolAo4Hd+53fwO7/zOwOPvfKVrxQluO/93u91ff3v/u7vDnX/NDS2JKjVm654afq11WNX+JRgu5VBi31+zEnUyDy83buiiMBtJ5M0YCs2o/uAMn/fbjfTuyJsqsuTxcVFnDp1Cnv37t3oXdHQ0NiO6B8OmcnbC359m/hsKICvMOa8f7spGabpQWx4rMZ2IjaWBVS4n2Z0jy5FBWCoxKZareLBBx/Egw8+CAA4duwYHnzwQZw8eRLVahXvf//78c1vfhPHjx/HHXfcgTe84Q2YmZnBm970pmHuloaGxk4F+S6KdknXNhBvk0WizUtNub5ATtljsx3i+Ds1wOJzk1y9RNuI2NSXgF6b/Ty6VxObAAy1FHXvvffiVa96lfg/eWPe9ra34ZOf/CQefvhh/Omf/ilWVlawd+9evOpVr8Jf/dVfYXR01OtXamhoaMRHY5ndDky9fnb7dNHQgp73IDZmh+X5ZAvru1+qQV4hIwVki/b9QrGprf8+DQtEYAoTbGxEeZvmLynCUImN7AVxw+233z7MzWtoaGg4QcRGVmzoan+75J5QCSbfd4EoKzityjYgNvw4c6POOI3t6LGh9y15wIRio4mNGzaVx2ZYiJx1o5EY+pxrbEqIQDeZ2HAvynYhNi2PUlQqJXVGbQMDMZXcvJSp7Uhsiv3ERpei3LCtiU02mwUA1OsbMPRyh4POOf0NNDQ2BcQCMWHft1MUG/m+7dDyLRSbPmJDpajt5LHpVxq36ygQRdhU7d6qkU6nMTExIdKMS6XStm0P3yywLAv1eh3z8/OYmJhAOp3e6F3S0GCwrJ1RivJa8AF7tEtnG1zstT28RNu5FEXvWxFCuE3es4qxrYkNADGHKmhUg4ZaTExMrO8MMA2NILRrzDgLOM3D243YeC34AJDjxKa9DYhNkGLTawPdNjPbbnX0Exs5k2i7BEsqxLYnNoZhYO/evZidnUWn09no3dkRyGazWqnR2HygVu9U1l78AJvYtLYJsfFTbLaTmiE8Nj4m6XYVyGyD0MXGErslYiMyiix2jP2ZRTsc257YENLptF5sNTR2MuSrXrkknd9uio3Hgg+sXynq/KOMYB26eXjb8CJwmRyQzjHFpl3bHmnS/YpNpsAIutlhqo0mNg5o/UpDQ2NnwM04DGy/UpRXVxQglaKGmPFy/lHgky8BPvPdwMqp4W3Ht+S2jZQpYJDYGIbUzbcNOtwUQxMbDQ2NnQFq9Zb9NcA2JDZhFvwhEpt//yAACzC7wDNfHt52/Epu+XU4zvVEf44NsD1nfymCJjYaGho7A6Rk9Mv2243YtDe4K2ruO/bPz35leNvxyrEBtt8kc9duPq3YeEETGw0NDRudJvDVjwKn7tnoPVEPurLN9xMbaYEYZrCkZQEP/iVw9AvD2wYgKTYuvothjxuoLwHV8/b/T3xzONsBnMnD/dhupSi3YZ9asfHEjjEPa2hohMDnfh548P8A4weB934HSG0jw33Lw1RLi4XVYwuhm+lWBe74CHDnR4B0HvjFZ4a3HV8lY8jEZuEou80UgG4TqJ5jc6kyefXb8vPY0OyoTkP9dtcbliW9dyWyut2URoXQio2GhgZD5TwjNQCwego4dufG7o9qiKvePiUjW2KDFIHhLfimCXzr99nPvRZw/OvD2Q5gH4Pc0k4YdinqwhPs9tCLGLkBgLWzw9lWqCDCbUBsOnV7irlM4rRi4wlNbDQ0NBjmHnT+//F/2ZDdGBrcrnoB1mEybFPtygnnAjQs70mvy9qcAXtxlzFsxWbxaXa76wpgbB/7ee3McLZFx7DdFRvHFHPpb6o9Np7QxEZDQ4Nh7iHn/6mssF3g5bEBpAV/SJ6M8484/3/q28PZTkciLG6KzbCJTYX7a8b2s38AsDosYuOn2BCx2Q4Jy1IJ1ZG/pBUbL2hio6GhwXCOd7Nc8yZ2S1ff2wVeHhtg+Av+OU5sdl/LbleHlO9CCoWRYiF1/Rh2KYqMwyO7gfED7Oe108PZFh2rmzJFxKbbHM621xNhTO8aDmhio6GhwUCL7zVvZreVue3TLgvYC4BbSuuwic2Fx9nt5a9jt7ULwymT0P5ny86re4I4zmETm9nhKzZhiM12U2xk0P+3S+eXQmhio6Ghwcytq/zKet9zgfIu9vN2Um18FZshtweTgXbvc+2FeBimWlrIcy6LPTD8kptDseHEpjI3nG1R2Y1IjIz1MA+368C//FfgT14/3M4kr/ftdmtpVwhNbDQ0NIDaPJs7Y6SA0b3A9GXs/sVnNna/VCKMx6Y1LGLDF/exfayVHhhOOUqoGC6LPTDcUlS3ZQfJje4BStPs5/qS+m31OizZGHAncdSR1RliKerO3wDu/RPg5DeBo7cPbzuexGbI6tsWhiY2GhoadrlgdC+Qzg7/ansj4NUVBQy3FGWaLM8FYAs+eU+GMUdJLkW5YZiLYe0Cu01l2dgKSsltDIHYyMTMtRS1DgnLJ6SW/VN3D287XsQmuw5zv7YoNLHR0NCwDZ7kixjZzW4r5zZmf1TDNL1HKgDDLdHULnB1wXCaaoei2IQsRXVq6lOWK5K/JpUCinyuEak4KkHEzNMkPeR2b9ME5h+3/78RxIZKUR1NbPqhiY2Ghobtr6FFd3QPu5Xj8bcy2lUAfCH39dgMYZGocC/NyCxTwyjfpTqvflt+hlrALtFYJivnqIRsHAYkxWZZPYkiAudlkhZdUUMiNqsnnST4/KPDK3t5KY3DNrxvYWhio6GhYZeiiNiMcGKzXRQbEXKWthd3GcNcJOgcju5lt8J7sqh+W6IU5UFsZO+N6jINlZxKM/yWKzZmV33WSqCXaMiKzflH2e3u69j7yTKHV7b1VGx0KcoLmthoaGjY6bBUihrlpajtotjQIp4f8WiDHqJiQ91PpNSQkjEMU21QKSqds8dHqM54EROoJ9httghkis7HVCHoOIfd7r30LLvddblNWNed2PD3bLcJmL3hbHuLQhMbDQ0NoLbAbkd4m7dQbLYJsfFLqZXvH5bHBrBLNKTYDMNUG6TYGIZNNpQrNivsloib/LNqEidKUV4ltyErNrIKR8RmaDOxOLHpf+/KydJatXFAExsNDQ178aX8GlJsWqvbY96O32BI+f5hLBC0qBOhGWYpKshjA0hqxrAUG4nYUDlKNYkj83BgKWpIvhc5r2dsyIpNx+O9m86x0iqgiU0fNLHR0NAYJDb5Mfuqdzv4bDaU2HAC40ZshmWq9SrRAMPznzRX2G1hwr5PGIhX1G4rSLEZdrt3RWrfF4rNkIhN2+NY5eGt2yFhWSE0sdHQ2Onode0raiI2hjHcgLX1xkaWoujcUvvzME21QTk2wPA6htwUm6GVogKUqWzB+TzVcCg23Ds1NMXGh6wOO0l6i0ITGw2NnQ5REjH6yghDDFhbb2wmxSZbtBfkoS34HiUaQErlXQ9iM+F8TBU6QaUofn67DfWqGGB7z2TFZtjExo2s6s4oV2hio6Gx00FlqNI0kErb95PCsC0Um83gsZmy7xuWGhaqFDWkOUrCPDxh30fZK23Fw1TFcXr8PWXCo7r7q9Ng3jOAKTYUZjmMXCLA30+kxyq4QhMbDY2djjrviKIyFKE0xORYgmUBf/Zm4DcuAr728eFtR5SiNguxIdKo2EAcqhS1jooNERvVU+KDlKlMcfC5qkD+mkwRKIzbRI48RqrhR1azuhTlBk1sNDR2OqjVuzzjvL84pI4WGecfBZ75EtvGXR8dXh6HUGxCeGxUli46TburhVQawJnKqxJBJRrAWaZRBdO0J1w7iA3PXlFNbASB8zjOdIbNrALUE5uadCFgGE6DtOqyl2X5k1WdPuwKTWw0NHY6REdUH7EprUMp6pkv2z+3K8D5R4aznbClKFhqO0yIFKYyzkh8oWSoTuQNUYoahsemtQoxskLuihoWsRGKjZ8yNaySGyej5EEjYmP11B9ntwVxXv1KUborygFNbDQ0djrcgtWA9VFsnr3D+f8T3xzOdoKIjdxdo/Lql0pNxSln4jEN4iSVQxXaPkZTwjAWfDqObAnISEMph05s/JSpIQURUsmJPi/ZIpDOOx9TBXnf3d67uivKFZrYaGjsdLjljwDro9jQhOTLX89uz9w3nO0EtXunUsNp+XbznQBAfpzdDkux8V3wh6DYNPlx9A9qHBqxCSCqgH2cQxsd4dLWrrq0SCQ7nXca+wlCfRtSEOEWhSY2Gho7HaTYFMad9w9bsWnX7cnXl72G3a6cHNK2QiyEw/Ar0IJf6FvwhWIzrFLUOufYeM0zGlrJLYxiM6SQPiIvjiBC/rPyIMKQwz6HNcV8i0ITGw2NnQ5h+pxw3i8UmyF1RS0fZ7eFcWDvc9nPq6eGs62NIjYtLyVjSAu+V0qtjGHMUfIkNsMyD4dRpoaUsLyeik2QMrUeis3SMeCJz9mm6S0ATWw0NHY6vEpRw/qyJiwfY7eTFwHjB9nPlTmg11G/raB2b/kxlaUoWtDXQ7HpdQCTn7tQIxUULoaCwPkQG6XdZiG8RMMahOlGbOizo9pjE0RURbltiIrN4/8E/N8fBv75vcPbhmJoYqOhsdPhVYqSw9WG0Ya99Cy7nbqYtc6m84BlAmtn1G8rqN1bfmwYpaj1KNHIJZcwQzCVlqI8Sm503GZXrdclknl4Kys2AV1uotw2RMXm5N3s9uDNw9uGYmhio6Gx0yG6PCac98uLlOpSAmCXoiaPMPPu+AH2/5UhlKM2WylqGIoNXd0baTb52QvDWPBFKarvOGUiqfI9RCWaUFPMh+SxkT8vGzXsMzNkxcaygFOc2Bx64XC2MQRoYqOhsdNBHpv+UlQmb7exqvaCAHaCKw0RnODlqGH4bDYbsRmmYpMrO1vL+zGMEo2XMpVKAbkh+Gxo38OU3JR3Ra2w2/WYiRVYihqSKkVYfIYlk6fzwN7rh7ONIUATGw2NnYxu214Q+xUbwFYWhqHYELEZ3cNv9znvVwXTjFiKUuix8eyKGnc+rgJBabyEoSo2o4OPCZ+NShK3yUpRdIyq82SEeThAsRlWKWr+MXa751p2obNFoImNhsZOhmx27FcVAPsLW3VbMgBU+YTkEU5syjQYUvH8pG4DIr113RUbjxLNMPxLYrH3UTGAIbd7+7yHVJHjoDEDhGG0e1uWu9meSPHQur8CFJthlaLI70bm/i0CTWw0NHYyqAyVH3cPABtWW7Jl2cRmlE9HLvGRDqrbSmWikvG5widi01LZFeVRohmGfylMaB0wJMXG4zgBW21QNYE6aMwAYRijIzoNZoQGnH9DQd5UKzYBZHXYig0Rm7H9w/n9Q4ImNhoaOxnCLzDu/viwguQay0CvzX4e4cSGZlXR7CpVoPJAtsw8H14Qio3Cq26vdu9h+JfCZLsAksdGZbu3TymKVJWOIiUsdPfXEEZHCBJqONWiPJUx1zlhediKzSopNprYaGhobBUIWd2D2AjFRvFMI/LRFCft2j0pNvUhKTZBSgaVE9Zj1AAgLYaKlIyopSiVJRovkzSgXrGh/U7n2BRvLwzbSyST5GEYpIEI5uFhKTY8GZwM/lsEmthoaOxkiAybCffHifCo/sKucmJD/hqAZdkAQE2xxyYssRlqicZlwc8q9vSELkUNYYaSlzIFqD+vYYzDju0Og8B5BREOqxTlcayZIbW0E0Qp6sBwfv+QoImNhsZOhleGDWFY5uHqPLslfw0gmYcX1KbUBg3AJKg2m5qm/4KvOuk4bClKPk5V55mO0+0cqy5FtUNk2ADDaff2NIMPyTwcWIoa0qBPgJnaK3PsZ63YaGhobBmELkUpJjZkECaVBrBLUd2m2s6ktpTv4gfVykK7CmFydTXVDkmxCVrwyXBqmerGV9Ax5F2IjfJSVNSS2zq0tROh67XUjgQJKkVlJPKm8mIAAOpL3Cht2D64LQJNbDQ0djICS1HDMg/zieGlafu+XNledFX6bCKXohQtwEQGU1n7uGTQ/qjaXtQFX9W2zZ4UDuim2ChWwoLSeIe1XSC4FAUoDiIMUOGy0vtKtWpDsQuFcX8v0yaEJjYaGmFgWXZr9HaC12RvwrAUG/rSLE7Z9xmG1PKt0GcTZgAmoL6LRi5DuSUBqy5FhfWepHOAwb/6VSyGsuLkdo6VK1MB85MIw2iF9lJs0hJ5HQax8ZzuLZNU1UGELhcfWwSa2GhoBKG2CPz2c4CPHALu+I2N3hu18JrsTRhW8jARm9KU834iWCqnJIdJHQbUly68xgwQlC/4IYmNYag1ndL+G2l3ZUo1YQxtHl5HxQYYTnJ1UCkqnWGKIKCe2Hh9RrcANLHR0AjCo38PrJxkP9/zR0Cvu7H7oxJBpaj8kEpRdY+rQdqPoRCbsIqNqlKUTxqvvD9Kg+vgTi76obJNWCaObsqU2JZixSawFDWEgL5QCcsKiU2UYZ/KS1FasdHQ2L54/J/sn2vzwPG7Nm5fVCOwK2pIOTbiarCf2HATs8opyRvV7k3nzMuYnVVciuqGVDLk56g4Vgql8zq/qgkckbEgAkeP91pqtgsEzMQaQmdU273s9tkHTuMzXz/G/jOMhGXALkUVtWKjobG90GkAx7/Ofj78EnZL/98O8JrsTRiWediL2IhSlEIiFbXdu9tkrdpJse6lqJALPqA2sTaIOKpWwroRiU13CMTGtX2fBmEOYYq5pNi0uj384t8+hA/+82M4tlAbXsu3LkW546677sIb3vAG7Nu3D4Zh4B/+4R8cj1uWhQ9+8IPYt28fisUiXvnKV+LRRx8d5i5paETDwlHA6rGrlqu+j903//jG7pNKNAJUhbzksVHVTmpZG1SKitAtpGLBD1uKUrbg830OQ2xUXuX7tXoD6gkcLeDZsMRGYSt0qCnmCod9upiHTy3V0emx43no9Irkl1LtseFTzDWxcaJWq+H666/HJz7xCdfHf/M3fxMf+9jH8IlPfAL33HMP9uzZg9e85jWoVBQbFTU04oJIzOzVwO6r+X3bhHybpm2G9CI2dGVq9dQtwM1V9vuAwS/NYZSigjpLCKo7TMS5DfLYqOqKCrngA2oNvUGKmGrzcGjFJm//THPJksIviDA3DJP04LDPYwv25/Ch06vDU2y2cClqqM3pt9xyC2655RbXxyzLwq233opf/uVfxpvf/GYAwG233Ybdu3fjL/7iL/Ce97zH9XWtVgutVsvxezQ0hob5x9jt7FWM3ADA8nF29Rm0UG52yAFyXotvtsS6XaweK62oOGaSuLNl5+IDDKcUFdZsmkqxxbLbVEPi/K7ugSEoGaTYhPHYDEGxCRrUqEyZIpN03v95MvHpNoOfHwa+wz5V5/VIfxvpvXt8wX6/PHx6dTijIwBdioqDY8eO4dy5c3jta18r7svn83jFK16Bb3zjG56v+/CHP4zx8XHx7+zZs+uxuxo7FaTY7L6aTZ8uz7L/X3hy4/ZJFUSbbsr76tcwpJZvRT4bKjO5fWGSYqOyFBW2PVh+jooF328AJjAEYsMX/CiKjZKSW0BO0LDa2oMIXDoLgHdpqfLZ+JE4eu8oM0nzbWUKQCot7j6+aJ/HR86uwhrWIMwGL0VtQcVmw4jNuXNsCN7u3c6o5t27d4vH3PCBD3wAq6ur4t++fVtrhoXGFsPiM+x2+jJ2O3URu6X2760MUUIYdW/TJaieF9X08fUIj80wFJswxEbhVbdf5gkwhCGYERSbYXhsAktR66zYGIbTZ6MCvsRG8XF6zP6SiU293UPN5Dk2KkiqDL/P6SbHhndFGX1fqJZlDdwnI5/PY2xsTPzze66GRiKYJrB6mv08cYjdjvMpt6un1mf7w0TYRN48TfhWRDZ8ic0wPDYhRw0AahWbIP/SRplqgfX12NBx9tpqMqDCemwAm/yoUmxCjY5Q5bGhDBvn5/M499iUc0zFWW5zNUe1YtMM8IhtYmwYsdmzZw8ADKgz8/PzAyqOhsaGoDbPMjCMNDC2n903fpDdEuEZFhafAW69DrjtDcMjOFRC8OpmIahu+RahgC4L/jCSh2OVohRcdW/qdu/19NhIhFLFeY1C4FQqNpblfzGg2utCfxupm6/Z6eHsKrv/NVezdXKhSeU2hYpNr2P/Pq9S6ibGhhGbiy66CHv27MEXv/hFcV+73cadd96JF7/4xRu1WxoaNla4KjO2zx4CJxSbIRObv/0xYO00cOwu4LHPDmcbYfNd8orHKoQtRalqDAhrHpafsx4lmo1s91aaYxOg/GXyEF4XlcTG4zjvPHoBH/j7h3FisWYrNirUjG6TTUQH/GdiqSY20nGeWqrDsoDRfAavvIL5/c436NwqVGzki5gtSGyG2hVVrVbx9NNPi/8fO3YMDz74IKampnDo0CH83M/9HH79138dl112GS677DL8+q//OkqlEn74h394mLuloREOKyfYLZWh5J+H6bFZOQXMfcf+/32fAa59i/rthE3kVW4e9iE2pG5YJlsgVHRhbZR5OGhYo9zubVn+PqcgmD27pTnMcWYUGk6DiI1hsMfaVTXqlIfH5un5Kj70L4/hrqMXAAAj+TR+WaViI++7G0lWnVwtlCm51Zvtw5GZMp5zgH1+ztbAJAqlM7H4ZzRb3nKTvYEhE5t7770Xr3rVq8T/3/e+9wEA3va2t+Ezn/kMfvEXfxGNRgM/9VM/heXlZdx88834whe+gNFRD+lWQ2M9QT4aKj8B66PYHP8au80U2RX12e8kX/jcENSOTFhP83CuDHZ1b7FSWVJiY5rSAhFFsVE4HDIb0C1k8X0MQ0i8IHtIInlPVBA4Kpn4/K2yJUZsVJxXD5P0u//sXjx7wSYf59Zaaj02ROCyJUeXkoDqrigXAndikf3uw9MlHJkuYzSfQbWXZcRGZY7NFvbXAEMuRb3yla+EZVkD/z7zmc8AYMbhD37wg5ibm0Oz2cSdd96Ja6+9dpi7pKERHkReiMwAttemsaTuC6wfRGxueieQzrGrp+Xj6rcTVrFRPbXYb4yDYajdnrxwbzbFRiZaSd9L8qIW5ThVLPhhFDE6Byo+My4LvmlaOMkX/Xe//GIAwIVKU63HJtBLNKxSlKTY8I6oi2bKSKUMXLt/HE0r53y+CgSlZm9ybHhXlIbGpkX1PLsd3WPfVxi3vyxr88PZ7rmH2O3hFwO7r2E/zz2ofjuhPTaKh/sFtZGK7SlQiOQv+1DBdYoMoL2uVBryIDaptL1PSUkcHWcq664m9ENlu3cYD5PKRd9l2Odas4OuyTxZL7l0BgAwX5EVm/UgNkMqRUkEjsL5jkyzfTgyU0YLOefzVSAoNXuTQxMbDQ0vVFmtHiOz9n2GYf+/OgRiY5rAIvelzVwB7HkO+/n8EMY4iKuyAGIjhvupUmxW2K0nsaGZOwq2RwtppsCShYOgyjzckfwYfoqYqs6oKC3QgKTYKFgMw3RjqewYclFsFqrsvrFCBvsn2LYuVFpqB2GGHh2hOHBROq9Uijoyw7Y1VsygiSEoNkHhkpscmthoaHiBFJvyrPP+kd3Ox1Vi7Qz78k9lgcnDww0EDOraIQgFRXUpyivfRWEpKopxWH5e0kWCSi5GmpUTvSBKNAkXQ3GcIYmNym6hMIqN0lLUIJG6UGHq2MxIHrNj7NgqzS566XVUbFTPiupTbORWb1JsxgpZuxQ1DMUmyH+3SaGJjYaGF2ouig0wXGKzcJTdTl3MIuHJuDwUYhOyFDU0j01QKUpB6StKq7f8vKTKgjx408/0Tec26VW+WARDEjh6nkrzsB95FKUoBWqGi0K0WGPqxsxIHqP5DPIZtrQ1LUrlVaHYrHcpikZksN97klq9CxlMlRmZGS9mh6vY6FKUhsY2QrtmL+QDxGaIpaiFp9jtDB/hMHGY3a4MIek4rHl4vRUblbk5G6bYSB00flBdigqr2GQVlmiimIdVLL4uis1ChROb0RwMwxCqTcPKOF+TBEFt7VlJfVORwSRyidixyP4aStwfK2bRBCdvSs3D/DOqS1EaGtsIRFoyxUFFY5iKDXU/TV/Cbie4YlM5y9JAVSJsu7fw2KggGk17kVmXUlSEOVGAOsWGSi5eHVH920tcivL3uaw1O/jwvz3OQusAKcdmvczDio6z12WT5oE+j41digKAXfy23iNio1KxCfDYwFKzvT6PzXKdHeOuUfu4xwoZNKCw3EYQis3WmxMFaGKjoeEOIjYjs4OlhGEqNv3ZOeVZ5tGwTGBN8ST7yF1RCoiG6HQyvK8GVW4vypwoQJ1i4zHnZwCCxCVVbPxVk09/7Tj+953P4jc/z6fSq+oW6nVsouGnFqkijB7t+2Qeni6z45odZftS7fEOsfXsigIUJyzbniGAlaIIY8XscNq9w343bFJoYqOh4YaaRGz6QYpNxXsKfWz0E5tUys7RUe2zCV2KUtgVJeZEjXl3KYmuqI0oRSkqmYRVbFSVojrORbAfj55lpYX7TiyzO5QROGkBXw/zsKyEpF0Um1G2yJOqUekOQbHxOs50lpn+AcXdX+xvteZGbArZ4bR7tyWP2BaEJjYaGm6gMhORGBkllpOB+qL67fqFAqoufYUdgklXbd1m8unMQf4aeXtKSl+bwDzsB2UeG/c0XsLj55hSdm6tibnVhro2aCJGRsq/+0uVeZgW73TOQYxJsaFS1CwnNqudlPN1SRBG/VPpJRIBfaTYsFL0aCErnsLavdn/LZUjFYL8RJscmthoaLiBMmzKuwYfK02z28ay2m226zZZkokN7YNqYhO63Vvy4CQlG2GIjdIcm40yDwdc3RPkeVFJ0PE2D1eaHZxaso/n/hMrziGYSYyuMnH07f5SlQ/k3v3VT2xIsVnpUClKpUl6HUpuwIDHZq3BLirGZGIjt3urHIIZlphvUmhio6HhBl/FZordttaAblvdNtfOsNvcqHPhH4anx7JskhJEbNJZW/ZPSjZEON+E93Nyw2j3jliKSlwaiqjYJPaeeLd7P3HOeR4fOLlsl6wsM5kpPSxxzKoqRQ2W3CzLkogNW+SpK2qppVCxCVDFAKidF9XX/WUrNnYpqpBNo8cfN3otFvCpAmHL1JsUmthoaLhBZNi4KDaFcSa9A2xmlCoIf80B59UvKTa0TyrQabBFDQguRcnPSaosRFFslAb0rbN5uB2yBLYO7d6Pz7EyVDbN3lP3n1x2Ls5Jsmw8FJQBqErldUnjrbd7aHbYe9nuimKPL7UM5+uSQKhiYfJ6FCo2WSI2gx4bAMjlJfKhymcj3r+a2GhobB/4KTapNFCcZD/XFRKbistsKnkfVCo28kIa5ssrp6hTKRSxGUZX1DqXojohr3iFkqFoVpQLwSBi89pr2PvqkbNraCEDNkUdyRb9sIqYMvPwYDmI1JpiNo1yni36pNgsqlRswhyrypA+oRBxYtNiio1cigKAXFEizz0FBA7QHhsNjW0JIhH94xQI5LNRaSD2IlOiFKXQY0NlqGw53AylvKIsm1ClKJW5OQnMw0m8J5EVG/UlGsLjc+w8vv6aPZgq59DumnhsrqJmEGbUUpSyktvgnKjpEdu8PF3OwTCAhqmwKyrMPK4hzsTyUmxGSwV0rZTzNUkRNJl+k0MTGw2NfliWlGPjUooCgCL32agkNl4jHIZRiopaQ19XxWYj273586xeQu9JxIC+xAqR+3H2TAtPco/NVXvH8LyDEwCAB06uqMmyCUscVR2nSymqP5wPADLpFKbLObQolXfduqJUlqL6PTZEbJyKDWv5VnicZk8qbWrFRkNje6BdtWXgzaTY1C6oMweGbfUmrKvHRmUpKqZiI782DkRXVMhSlDIlw6kmnFisodHpoZBN4aKZMp53aAIA99moKJuEVmwUqEPy6zODpSiZ2ND/7YwXhYqNb1eUylKUrdhYliXMw2NFp2IzVpSJjcK8HkCXojQ0tg1IrcmWvBd+6oxSaR4WxKZfseH/N7t2KScpwrZ6E5QrNj4zaGhbZkddzkpYxSadZRO55dfG2m5YxUbRQth1N7ZSGeqK3aNIpww8/xDzhjHFRkGWTUDisQARuKRDN90UmwqNGnDm6OwazaNlDUGxCdMVpUKxkbbX7Jjo9FhpdFCxyagN6aN9N1KegY+bHZrYaGj0g9JxqdzkBqHYqCQ2HmnHmZztO1GVnRO21ZuQVxSaJ+ZThSA28vPjIiqxMQw1KkpYj42yUpS7YkPG4av2svN9xR72Pjqz0oAliM06KDbCz5Nw4fXz2JSdi/DsaGFIpSg/xUaRZwpwKDak1qQMoJxLO542VsxKBE7xTCy/bKJNDE1sNDT60eTkoTjh/ZzSEDw2gti4dGJRF5YqYhO1FJVTFJoXZrvpjL3gJyY2EUtRgKISTdiuKNrWcGZF9ROb8aJ9td9NcSKQhGyE7YpSFQjookwt1pwZNoRdo3m1xMZDFXNAlQJnWY7yIo1TGMlnxGRvwlghizZUTjEPGS65iaGJjYZGP8Q8ownv56hWbLptu6zl5uspck+KMsUmonlYlccm9ERxRduLqtjIz02yOIXuilKt2DhVi+N8mvels+x8ZtIpjPGuGkFslCg2IUtuQLLF102xqdCcqH7FJq/Oe2JZNonzLUUp8kz1OgA4AZQUm/4yFMA8N0Px2GxRfw2giY2GxiDIx+Kr2Cg2D1PHUypjqzMyhGKzomZ7UUtRqjw2YrsBxEaVgTiWYqNgcYrcFZWwvdwjFXe1wRbEqbKtZkzyn9uGAmNt6FKUPPk6AZFy7YpyNw8zj40i70mvYwda+pWicqrM4M4p5l6t3sAQBmEKtVErNhoa2wdhFBvV7d5kHC7PuufKqC5F0VVZkHJCUOGxsSxJsQk5n2q9PTbycxMpNmG7ohQpGS6zoizLwkqdEZvJkk1sJvjPTVoMlXRFBSyC6Yw0+VrB9lyJjbMU5VBseu1kHYUOouFzrKrMw44p5jlBbMaKborNED02WxSa2Gho9COSYqOoFOU3wgEYnscmdI6NAo+NY4xDUClKUUhfiIXXsix86fHz+MqT887nrodio0zJGBxtUGv30DWZCjRRshfESf6zko4hF6LhCeGzSVKKcio2rW5P+E/6FZspOccGSJbKK3xIRsAUc1V5PZIZ3DDsVm9XxSaj1ksUtoy6iTF4ljQ0djpCeWy4YtOuMH9MxufLLgz8RjgAQ1BsiNisY46N/NogJUN5KcpdsVmstvDLn30En3/0HLJpA/f999dgLKliEyXgLJ1hC2Wvza6USz6deH5wyVhZrjHvST6TQiFrd9KQelO3VCgoEYaMZgpscGwSwtiX17PIw/kyKcNhjAaAcj7jJDbdZjTlToZ8nH6dQsqGfTpTh9d8PTZZnFNKbOi7YesSG63YaGj0I4xiU5hQOwjTK8OGMDRiEzV5OIGC0pL8NUFjHFRsr9dh2T+A64I2v9bE63/7q/j8o+cAAJ2ehRML9eTlBEfAWYjFQcVVvsswSvLXyGqN/P+6qaB8EWXIqDivCszDnMDJ4xT6u4VGChl0kUbPUjATK0xHFDCEwEW2PT+PzbgU0GcmbacHJLVRl6I0NLYPwig2qZQ0CFOBz8av1VveF1UBfaLtOqLHJomCEtZfA6iZ8C0vLi4L778+PIcLlRYOThVxeJo9fnKpnpxoiO0aIUs0ChZDYR62yzHkr5koOtVEUmxqgtisQ46N/Jwk2+tTbJZdPESEco4N+lRirA0TzgcoHKLq7P7yIzajhYwwSbebChKPt0EpShMbjfh4+kvAn7weuO8zG70nahFGsQHUdkYFDd0clnk4dFeUAs9LK0InVl6BYkOLi5Fy9UXMrbLF4zVX7REzlBixSbg4ye2yYQLOVJS+em3n7wKw0mD3jfcpNuSxqXQpYTmJghJBsVEydNNJbGotbqp1KdGkUwaK2bSaVugw4XyAwq4o53H6laLymTS6Kfb+bjUVBANu8cnegPbYaMTF0jHg/7wFgAWc+jaw97nAvudu8E4pQoNi/yf8nzcMYrNZS1GyYmNZ8RJJ2xFUIkGkEgTXya3eLvt7lhObveMFjOTZIn9yqQ6UEi5OSSaKx4GsREgKka3Y9Jei2CK41qVQNxWKTRRlSp1iU+VKRjmfdn36SCGDVluB/8SjnX4AykpR4SZ7C2TygAm0VRAbUYrausRGKzYa8fCdv4QIkLJ6wLc/taG7oxRhFRtq+VZBNtbbYxO1FEUqi9WLv0BESTumL9VExMa/TDK3wh7fO1HAwSm2IJ1SotiE7IgiJL3Kl5WIbLDHhso2q6TYJFIyIpA4FYMw+xb8aouIjfuCP5LPqGmF7oT12PDHE5uHnduzu6IGFRsAguh12ipKUTqgT2On4qG/ZrfP/RF2+8yXkgWMhYFpAse/Dpx/bIjb6LHODSBYsREeGwXmYTIgkwrkta3GsprzHNc8DMT32dB59ZsTJba3DsRGKDZFHJqSPTYJzcMUcBbUEUVISqTodakskLKVi5U6K0X1+0+I6Ky0M8m2K782VFeUCo+Nc3tUivJSMsr5tJpW6DCTvQHnMaoYHRFSsUll2fN6LT1SAdDERiMO1s4Cy8eYd+E1/4N9mCtzwPwQCQcAfPY9wGe+G/jUq1gpbBig6dNACI+NIhXF7AUP3iRiY3aTLfaEqO3eqZQ04C+m7yXKNlWMVPBRE3qmhfNrbBHYN1HAIW4ePrPSQC+zzoqNqlJUH7mgUtSAx4YnD6+0qVtIgal23bqiPBSbnI9io8RjE2KcAuAkPiq6sEJ4bAAgxc9tL6lpGdCKjcYOxalvs9vd1wDlGeDQzc77h4FzjwAPc5Wo2wS+9KHhbIdISrYMpD1kX4KqMQfNVYiynts4BYAtCmSATUqkum3bbBp2CKb83NiKTcg5UYCk2CQMBARc1YSFagtd00I6ZWB2tIDdowXk0in0TAur3YRKRlSPgirFpm9O1ErDqyuKva9rpsrk4TBdUVSKUpdjQ8RmxEPJGMln7IRlJcnOEUZHKOn+cio2bgF9AJDOse2abZXt3prYaOwknL6H3R7khGbPdez2/CPD2+a9f8JuJw6z26O380FxihHWXwOo871QKSs36h30ZxjqtieThShZFUlVlHX32HgrNme5v2b3aB7plIFUysCBKbY4LDTTztdHRdhxCoSkpS+X1GHALkX1e2yK2TRymRSaSZWMXgcw+WcwSlu7CoLRT2yG7bHxmJ4+gHTWzrdSokwVYVmWVIpyv9jK5Nn5MPV0bwCa2GjEwdkH2O3+G9ntbiI2jw5vm898id3e8husXNOpAWcfVL+dMBk2BGEeTuixIaLipdaI7akiNvyLK50PVqVkJFVsogzeFCRqOB4b4a+ZsB8jn835Ji1MSRWbsKUoInFxPT3unUleXVGGYWCylJWUjIRKEbB+7d59ik0twDzM0odV5tgEEDjDUOMlklS4RqeHHh+N4eWxyeQUlPkIelaUxo6DZQHzj7Ofd1/Nbvdcy27PPzocA/HyCWD5OJt8feSlwJGXsPuP36V+Wxuh2Ajj8HoRm5g5FUmzbEQpKop5WIXHZpDYkGKzd9xeqIjYzNUN5+ujImrAWdJSlMvEa8AuRfV7bABmKBaTr+MuhmJ/jYEymCtUhNd5tEH7KjYqzMNxggiVKDYFcYzplIFSzr2tPV9g7zUjyTwsgiA2WrHR2CmozrOF2EgBM5ez+2YuZx0ZrTVg9bT6bR7/KrvdfwPzZxx8Ifv/3HfUbyuSYqO4FOVlHO7fXtL04SglIRmJPTYb1e49+AVNis0+F8XmDB1ebMUmovkysXl4cNG1LAurpNi4pPJOlLJSKSousfHPCRpA0iGYljXYFdWOQmzWYaSC/BxFHpuKMA5nBsZGEHIqiY322GjsOFzgas3kEfsDnM4Ck9z7svSs+m2euZ/dkqdn15V8X55Uv60oig0NLKwvJVOqhGITktgoU2xCZtgQknpsogT0EfnptZnZOQ58S1GDio3IsiFBKmlX1HopNn3x+wDQ6PTQ7rFJ6v2lKIApNolNtVEWe8Au0cQ9zp70PuDHWmv1AHibh8sOj806jFQApJKbGsVmLSicD0CBE5tUUmJjWdE9YpsQmthoRMP8E+x211XO+6cuZrfDIDZzD7JbSjbexZWixWeAXlfttuIoNmYnmbIQVrGhfdqoUpSqrqgwtXv5S7UT89z6moft1GECKTbH10zn6yNvN6KUL4hNzON0ScUlf00unXItX0zIxCZ2KSoqgUvosXFJWKYyzfDbvaMkLPPnKMnrKWCNlxRH895+uHyR/Q0yZsyLAEKnAdGhqUtRGjsGS8+w25nLnPcPi9j0OqzVG2BjGwBg7AD7MjU7LE9HJaIoNtmSmhbsjTIPB5SEfu8rT+P9f/MdtLt8oReKTVyPTQTFJpOzz21c0hhKsbEfI8VmXnRFJVVswoYflpNtT7QiD45TGC9lXcsXU+WspGQkNA+HWewBqSsq4XHCEO+NoIC+kYIi83DYrihAUqbUemz8FJtcgW0zYyUlNv6DY7cKNLHRiAYiLtOXOO+fusT5uCosPAX0WsxwOnkRuy+VsomV6nJUFMXG0YKdoDMqdCmK71NSYiOUE++Ft9rq4qNfeBJ/e99p3P7oOXYnEZLEycNhxzgk9Nl4mIc7PRPzFbZw7J2wF+WRfAYzIzk0LKlbyDTjbzeyYhNXyXBRbPgATLcyFNBXijK78ZTPKIZaIHlXlNwRZRjo9kw0OqwU5d8Vxc9BEqIhyn0R8npUJB07iI23YkMem6yVMAKD1NxM0ZFivdWgiY1GNBBxIZJBGJZis8CJy64rGaEhTF/KbpePq91eFMUGUDMvKnQpapzdNtfibwsI5bG5/8QyeIcp/uLuk/z5CTw2lhU97Tipp8fDPHx+rQnLArJpAzNlZzfPwakS6pDui6MuRM0BSWwe5lf3LopNf4YNwVGKAuItwpFLUaq6v7i/pt0TD3kOwVTtsQmjTgnFJkkQoX2s9pwob8UmL4hNQsWmvfWNw4AmNhpR0OsAK3yRIyJDIPPwykm1Ld8LT7Hb/tLX+AF2u3pK3baAaIoNoKY8FFaxIWLTSkpsgktR9x63FahvPruIZy9Uk3lsui2mDADrqNi4KwrneEfUnvECUilnmWbfRNG54MdZhDcseXjQYzNeHOyIAlj6sFAygJjEJqJ5OGlXlMecqFw6hXzGh9go6YqKYB4WXiI1ZmWROuyhvgFAgXts8ujASvL9G5WsblJoYqMRHqun2OKUKQCje52Pje1nt+2qc95SUngSm4PsdkUxsYms2CgYhCnmRAV4bCj/Jen5bQWbh7/NiU0hy74i/vLbJ5MpKC3JlxNasVFVinJ+SZ+Vhl/2Y6qUg4UUuqm883dEQVzFJm5AX1/8PiCVonwUGwsptJFgfETURTBpV5TnZG/vkomyIZhRSJySYZ+Dio1vVxQRG6ODVqfn+bxARPVNbVJoYqMRHjR4cvKIsywEMD8BTaZWmWWzcJTdTvcRm4lDfFuqFRtOGsIqNioGYYpSVACxEaWohMQmoCTU7pp48NQKAOC/fhfrQPvb+06jneZEoxXDPEyG42x58L3jhSEpNnM8nG/f+OCXN81RahtEbOKUoqIqNglLUS7HueqROkyg42xaCYy1YdN4CYlLUdHmRAGsk4jMw2YiBcU77HEAKhQbV4+N93EWCza5bDTUzeLaqtDERiM8iLAQqegHqTZrZ9Rsz7KAxafZz16KjUpiY/aAFicNURWbuMSm27LbfMOWopprycp9AcTmkbOraHZMTJayeMdLL8Le8QKW6x18e67tfH0URBmASUjssXFXFNzGKRDGeZhd0+Bf7HFIVSeqYqN2wQeCPTaTdJxJOoaiLPZAclNt/5yogFZvgCs23GPTSzIgMsqCr1ixWQthHs7kFRGbqIbwTQpNbDTCg4gN+Vv6oZpsVObYomakB83KtA+N5fhdOv2QlZD18tiQWmOkgPy4/3OJ2JidZLH0AQnA5K+58cgUsukUbrmWlR0fXeg5X69wm64YkmJzNoRiY2e8JFFsYpiH4xBWl+O0S1HuHpuxYhaGATStBB1DPsnOrpBNtXGO02NOlFfqMABk0ilYvDW8p2SKeYhjVanYZIuo83Rlr3EKAIBUBj0wv1irmSBTSys2GjsOgcRmv/N5SUH+mskjg1OvC2P2Qq9qe+SvyZa8p2z3I2lXlJxhE1SiyZUZyQOSlaMChtx9+xjbp5uOMNJ2eJon8tb4tuMoKFFShwlDIjaLNbbo7xodnG9ECkfdilmKMk3J5BrRPAwrnsHVZVZUkGKTThkYL2aljJcYi37U5GF6nmWyRoTI2+ubExWiFAUABicalhKisV6Kje2bou4vP2UKhoE2/1s2tWKjiY1GBJASQ8pMP0SnkqJSFPlraCZVP0b2sNvavJrtRe2IApIrNo2Q/hqA5eYUuIE4SWeUz5Rt07Rw3wm2TzcdYaSN5ikdr/AOonY1er5LlNRhwpBKUas8ydWty4QUjrpQMiIuEvLzoyo2cbYHuIbH0TFOeHRFAZRlk0SxidnuDcQkUu5dUV4ZNoQUn3xtxS2BmaZENNbfY9MIo9gAgti0mipKYFqx0dgpCFRsDjiflxTCX3Op++Mjs+y2qojYRO2IAtSVooIybAgqDMQ+7d7PXKhiud5BIZvCNfvYtvZzYvPsqvR1ETX+P8pkb8KQFBta9MfdiA2/r9qLWYqSiUmYRRAA0hk7ZTkOsXGZFRWk2NBjyTw2ETto0jkANDk9DrHpy7Gh1OEAYpMW3p6Y7d7yuQk1UiFhwjLgONY6V2yKAcSma7C/daeZxDysFRuNnQTTtE3BXsRmTDGxCVRsiNicV7O9OIqNPAgz1jZDZtgQVLR8+7R7Hz3PHrt67xhyGfb1sH+SfcmdrQOWkXL+jtDbJGITw2MTx9NjWZKi4DxOP2JDptqKSUQjIqmSW73Ddn8ByQzELhkry3VWbnM7RsJoIZuwKyqiYmMYkp8oQemLH2clpGKT5oqNoYLYrMcQTMtyHCsRm6Dj7PCIgnYriZdIe2w0dhJqF9h0XSM1mGFDIMJTOcs6jJKCUoX7jcOEkd3sVhWxSarYxDFEbohi490VNV8ZzHgZK2S4QdOAmY1ZHoqaOgxIik2cQED5Kts+lmanJ2ZfuS36ZKptxDUPxw04S9Ly3TcrqtnpocWP0U+xGXWMG4iTYxPj6j7JIMw+ZSpsKSqb58Qm7uRr+pukskxd60O3Z+I3P/8E7jp6gW8wocem12E+JIArNuw4i1l/xaaXYu9ZJYqNJjYaOwKkwozuBdIeX5aje5i51ewmJxumaYfvUapxP4RicyHZtghJPDZxJ3yHHYBJSEpszJ79Re1i5KUZSrKx1jAMUY7qZPgCHDXLJsoATILw2MRpuZYWFRfvSTpluHbTpFMGxgpZNIR5OOIiEbUjqn8fFSgZVIbKeBwjoZxPKypFRSE2Cco0/Tk2zXClKCI2qdjExt8k/aUn5vH7dzyDX/6Hhx37F1uxkf4WvXQezQ4jOUEeGyI23SRt7S4DVbciNLHRCIcg4zDAhqaN7ePPT2ggrp5jZCGVAUb3uT+nrLgUFUexcUz4jlGOEqWodSI2MklwKUWdX2NfbLNjzo6hfXxYZMuglNyopSgagLlO7d5ESNJ5xzA/YRwuZFynXgN93pPIig2VoiLO2skmONa+jh251OZ1jAANiFRBbCKQuCSLft9xVlvhSjTZAju3aTNuKcqfwD10egUAcGqpgcVqS8rrSZiwDKBh2scWdJw9XorqtpN4eyKMjtjE2HBi88EPfhCGYTj+7dmzZ6N3S6MfQcZhgqoZTjSTamy/q/wLQCpFbWBXlGEka/muk2KzTqUoWjiNtKvcfIErNrOjzsfIZ1M3+BdeVN+LaPdeJ/NwDOMwYaKUswdhRiU2cYcIJlFs+iZPV1vsGIPaoEfzGdtjkyTHJkrZIkkpyivHJuA4CzyVN21145XIA3wnD5+xOxQfOrMq5fUkVGwyBdT5eATDAPIZ/+XaTLP3bKIgQq3YqMM111yDubk58e/hhx/e6F3S6EdYYkPpw0kNxERsvFKOAbsUpardO45iAyTrjIpqHk46CFP2urhczc+vEbFxKjb7J9jiUDEpkTemeTiSx2Y03rYA71bveghiU5RKUVFJVWcjSlFEMGiGUojcE5BiQ3OU1mFWlPzcRKUo56yoEZ9ZUQCQk8YNxOqM8klYtiwLj5yxLzIeOrWaPGFZOs4GNw6Xsmlf9Q0ALE5szCRBhFHa2jcx/N/564RMJhNapWm1Wmi17DdnokmmWx3P3gnc+8fARa8AbvixaF0YUSFKUUGKDSc2lblk21s5wW4nPPw1gERsLrArsZT/F1wg4ig2QLJBmI2Iik3SriihnLgTDDIPe5WiVnr8/tgem/UqRbkrNis+GTaEyVI2vnm4HbcUFdM8bPaYqR9wyXfx/zyU8xmsQYFiE8Vjk6QU1adM2cnD3n9LACgUJPWh24xOOn2CCM+uNrHEAx8BXpa6jv/tFYzIqHGSWgooQwEQCcumitERWrFJjqeeegr79u3DRRddhB/6oR/Cs88+6/ncD3/4wxgfHxf/zp49u457uonw9JeAP/1+4LF/BD73PuBbvzfc7QnFxsdjA6ibFxVGsSnNADBYB0F9Mdn2gEiKzUq9jb++9xRW6m1bbYlViooQ0AckL0W1vLuT2l0Ty1zR6C9FHeClqMUOXwjjdkWtV/JwQDhfUCmqKUpRMQP61kuxcbQiO4dDBnkyRuRSVBx1QXhPoig20liFyNtzKjaVkARupFRAx+LPiaXYePtOHj7NPodUJvrO6VVYgrwln2Le6IQL52PP5wnLiaaYa4+NEtx888340z/9U9x+++341Kc+hXPnzuHFL34xFhfdF6oPfOADWF1dFf/27fMwlm4UqvNA5dxwt9FtMzIDCyLw6isfTjZhOghrnECOebR6E1SZh5dJsfEhNukMUJ5hP6vw2YRUbL7xzAJef+tX8Yt/+xA+9sWjNhGKev4tK34pqpm0FDWoKFyosi/UbNoQM5MIVIpa6PD7I+fY8P3NxeiK6jaieyMSeWyyaFhJFZuIxIaIUNTcHHmhjpjIO5LP2MnD69YVRa3QcYiUMxU3zKwooL/kpjaIkMpQr792DzIpAwvVFs43+Hdyt5F4JhYpNkGt3gBgZBnhUzI6IpP3f94mx4YTm1tuuQVvectbcN111+G7vuu78LnPfQ4AcNttt7k+P5/PY2xsTPwLqjuuK07fC/zO84GPXQ189WPD284T/8wyXkZ2A///k8DMFewL8cnPD2d7vS4r9wDeGTYEIjZrCZW0MIoNoDbLJoRi86ffPI7/9Ed34xzvHvra0wvxPTatCmuNB9bfPOxSEprnx7RrJD/wudo1mkcmZaBqxfXYJFBsgBheF/dFdy0MsSlmUUfMq+5OXPNwzOA6en4qK0qxYsEP5bGJSeB63YESWChkFCg22QJ6piWC64KIzYiD2MSZxeWj2HBic+PhSVy+m723H5nn24g7E0syK4cN5wMAg5SiuEGEgJ4VNSyUy2Vcd911eOqppzZ6V6LB7AF/9042h8fqAV/5n/birBr3fprd3vBjbHbQNW9k/3/8n4azvdo8AIt10pRm/J9LpajqOfblFwdmzy59BRGb8i6+vYSKjWnaKoiHYmNZFn7735+CZQFvfO4+GAbw7IUaqinue4lKbEityRTCly4KCT02PiZekWEzNnhlmk4Z2DtRQNWirqioHpsYycOZvD30Myqx8VBOwig2k+Wc1O4ddbtxA/oSlqKkhShsGzRTbGKWomTzb6yAvgTt3pkCam37uyXMcSZTbNw9NrJx+Nr947j+ILvoePCcRCwS5vVEKUWl+Lk1empmVG1lbDpi02q18Pjjj2Pv3gBlYLPh6O1MRSlMAPuez67E7/7f6rdTnQeOf439/LwfYbdXfg+7ffZONYm//aDS2sjuYINyeRfLnrHM+CpKRc6wCXgfqFJsWqtgpT14KjYXqi0s1tpIGcBH3vIcXLWHkYxnqpRjE5XYRAznAxR0RXlP9p4Xrd7uMvS+8SJqiKHYdFvs7+mxXU8YRvyQvgSlqHG5Kypujk1kj01M87DwRNh/s1rIbqGRQgZNK+aCL5+XSO3earqi6BizaSOwDbqcz6BlKVBs+kpRc6tNLNbayKQMXLV3DM85MAEAeOBMHfZMrCQELm+bh8MQmxyV+ZIoNv5hhFsFG05s3v/+9+POO+/EsWPHcPfdd+P/+X/+H6ytreFtb3vbRu9aNHznL9nt838UeOl/ZT8fvV39dp78NwAWsO95wAQ38u6+li0AnRpw4Un12yRiMxqicy2VtslI3HJUmAwbgtwZlQTkr8kUPevLT8wx1eHIdBmFbBovvHgaAPDoMv8YRSU2UccpADax6dSZ1yoqfLqiLlA4nwex2T8pEZsoHhv5uVFKUUD8sQoJzMOTpVyCrij3+VSBoIWkHZHYuLTnhvXYyMnDkX0Zcjifix3Asix88o5n8PlH+vyGSYy1UlcUpQ6X895Bi4QRRxBhgtERfaUoKkNdtnsUhWwazznAPpsPnVmzDcSxCJztJRLt3gFlRcBWbGInLAN6pIIqnD59Gm9961txxRVX4M1vfjNyuRy+9a1v4fBhnzbfzYZeB3jmK+zna94EXPRyJqEvPqW+HEVk6Yrvse9LpRnRAYAz96rdHsDKSkA4YgNIPpuYBmJqLQ8qQwHqBmGG8Nc8eY4Rmyv3ssX55osZIbnvAv9ijdruTUQorHEYcAbcxVFtRClqcOGd9wjnIxyYKMYrRdF+ZkvRW/LjdkYlNA/X43ZFtTdIsZHUhChdUVSiiZx9EuDFeOTMGn7j80/gZ/7ifjx1XnqvJMrrsRd8cYwhFnz5OHtxUnk9jpXKUNftZ5/Jy3ePIp9JodLswlSUsBx2sjcAZLhikzZjXPCIbfNzrBWbZPi///f/4uzZs2i32zhz5gz+7u/+DldfffVG71Y0nPwW89aUdwF7n8cWxwM3sseO3aVuO6YJnPg6+/mSVzkf2/98dnt6CMQmimIDJDcQEyEiv44fVJWiQnREPcGJzRW72RfZzRdNwTCAx5b5l05sxSZCKSqVtjuL4vhsxMLrPSeqP8OGsG8iZikqTqs3ITaxcQ9VWw2RYyO3e1tRFZTYIxVimof7OoUACP9JkKm2mE2jTYpN1AU/IJzvmQvsb941LfzqPz1q540l6oqySzREbEYDUocBRvBImWo2kpiWne+l44vsd5FpOJtOYe84+zv0UkkUG9k8TAQuBLHJs23GHh0BxEuT3oTYcGKzLXD8q+z2klfbHpSDL2C3Zx9Qt535x5iykC0De693Pkb/n39c3fYIwmMTltgkzLIJ21oOACVWDkItYY5NCMXmiXNMebhiD/simyjlcOWeMaxYvKwTdcJ3HI8NkKwzyqfdW4Tz+ZSi4ik2MVKHCcJjE7UU5Z6xEkaxGZVKF0a3wS4owmK9h2C6zDEKax42DAMGv8qPnH0SsAAeW7CJ6DeeWcTnHp5zPj/JSIVsMXS5DQBymRQ6XLFpxZl87XGsK3WmjEyWcuK+yTKfsJ0ixS8ZgbMVm+DjzOTZey4TV7Exe7YXTis2Gjh1N7s99EL7vr3PZbdnH1S3nRPfYLcHXzA4YXvmcna7cDRedoIf1l2xIWITQrGhHJv6QrxtEQIUm27PxFPzbHG9co+tPNx80RRWwEmC2Ym2AEfNsCEk6Yzybff2L0XNjhbiKTZxWr0JCktRzU4P7S4jKeMlb2KTShnIFaXzE2XRjzNmQH5+5FLUYBdLPWRwHQCk4hKqgFLUiUX299rDO+x+7V8eZ+pDXGUKcCz4lWY4VYpAAyLbSYhNf4o1D7OcLNvvJSI5HSOBp0dS4ert8ObhHCepWauNbi8CGSc4DOE6x2Znw+zZ5Z+DN9v3E7E5/0j8tud+nL1/cDuE6UsBGEx5qCVc5PtB4xHWi9iI7YVRbIjYLCYjdAGKzfHFOtpdE8VsGoem7EXrhRdPo4E82tROGqUcFcc8DCRTbDzUk55pYaHqX4qaKudQA7/Cj2IeblOrdxJik9w8TGpNygjOeCkWJUUryiIsSn1xh2BGNQ8Pqglhg+sA25dhRFZs/AncMV6m+f/dcgV2j+Vxbq2Je44vx5+jZJp2bk6mEOkYAaCXTkBsPEpRy1yxmZAUmwlOmFtEbBK2tUcpRWULbP/yRkcMz4y1XUAnD+94XHiCfenmRoFdV9r3T13M7us2mYlYBUj9IaOwjGzRNtsuKO6MIv9KaGJDpaikik2IVGlSbMyuTU7iIECxoTLU5XtGkUrZXRjPPzQBwMCyxReyKMQmtmKToOVbHoIpYbHagmmxBpfpcs7lhWyGEgX0Gb1W+PCxRKWouMRm8Cpb9tfIf0M3jJULdit0FLIRV7Gh44yr2MQwDwNAmpcvUlGzT3zmJwG2YnPF7jFcyWMRzq814wf09Y2OqIngunBmdFJsurHMw3xfMx6KjURspvjP9qiKJN1fhUilqGyeExt0RDdVtO3yfU3nhjt3cB2wtfd+M+DcI+x2z3XOjo9UCtgllYeSol2zCcu+57o/Z9cV7FZly3eva4ffhfbYcEJSORvNnyC2d975e/yQydtG2CQ+mwDFRnRE7XaqDrtG8yhkU7bPJkpnVFzFJskgTI9SFBmHp8t5ZNLuXwuZdAqZonT8YX02iUpRcXNsBs3DYfw1BNbyHaMzaqM8NnzRtSxLLPph1IwsERuzE+2z6kPgVuptsegfmSkJz9b8WlM6zphECgAyBakUFfy3BOzJ1/G6ogbJY6dnCgI5Ib2fyGPTEKQ4mWLTiFCKouThPDqCEMXb7tZWawBNbJJj/lF2O3vV4GPTl7HbBQWKzblHWOjdyB5v5WTqEna7fDz59gi1CxCpw6SOBGFkN2CkmIoSNV+mep4dp5G2U4WDUOYG4iQ+m0DFxtnqTTAMA4emSliBZCAOvc0NMA+33M3DQcZhwvhI2Q47C6uixEkdJiT22EilqHp4YjPumPAdkthYlrTgxy1FxeyK4otuq2uiZ7KSbBjFJluQiEkkL5H3/CQyDu8ey6OUy2A399mcX2slKLnx4zTSQDoTOoSQQO3XZhxi4zLsk4ibYTg77Ei9qZkqPDZ50eEWZQhmHm1Rwoq23UECt1WhiU1SnH+M3e52aVGfuZTdLj6dfDsXnuDbucb7OZM8+2flRPLtEcjvMjIbPoMknbXbsKN2Rsn+mrDbI59NEm9RgGLT3xEl49BUydkZFRZJS1FxBmF6tHsL47CHv4YwXc6jGjWkb0Pavb1LUaEVm6jpw50GRHp1khybKF6xvvA4UhEAoBRicGI+NrFxb6cHgBPcX3Nkmv3tdvP31HylaXuB4o5wiDjok0CKTawBkS4GbeqIGi9mkZbKmjQ8tmZmnK+NAqnMFyWgTxAbI24panuMUwA0sUmOeU5sZl0Ih0rFhspZVG5yA3lslhUSm6j+GkJcA7HIsIkwUkNFZ5SPYlNtdXFqiX2xkl9AxkEHsQlZiup1bcVlvczDliUZed1LUUGKzVQ5h1rUQZjCY5OkFKXOPOyXYUOYKGajl6Lk58WdFWWZ0SLx+66yacEv5dKBPiIAKBXy6FicAEVRizza6QFbsSFiM+tQbIjARSU2tooBwO4WCkls6PyYsYjNIEledvHXALaRuNLLOF8bBfJIhUiKDTs38UtR22MAJqCJTTI0lu2F2K0UNcOJzeJTyVuwyTdDv9MNE6TYKEw7FopNMLGxLAsPnV5Bs9NLQGz49sL4awjl4So2z/A275mRPKZcjLWHpkpYFqWolWjbA2KUomJ6bLpNtnACnqWo3S4DMGVMjdidUeE9NglKUfm4Hptkis1EOcZYBdrHTCF6wrJMECKZlZ1dUVGMw/S8WIMwfdq9yTh8ZIYTG4fHhnJs4o6O4ASOFvwQqpT8unjBgIOdZ8uSYiODvh/WuhnnayNtb9A8HK0UFZPYaMVGA4Adhjd2wL2EMXUxWAv2avIWbFJsZnwUGypFNZaiT1/2Au33SLDf5c++dQLf94mv42f+4gFYozHHKtDzRyMQG7nlOy58FJu5VfbldGDS/Urm0FQJq1FLUfS8/FjwPKx+xO2KkktHfR6QxSr7op4Z8VdsZso5uxQVVkXZ0FLUoGITitjIgzDDpg+H7IiyLAu3P3oOH/m3J+ySQToLpMhwGmEx7F/wW+GNwwAfhBln8rWfYsNLURfNsMeILM9XWjDT/DNkdqIN7O1bdBsRu6KMJMTGZTDkqlBsnO8l+v9aJ0kpiqlTVjoXsRRlKzY0FTzadrdH6jCgiU0yzPv4awD2QRjngyqTtHx3GrYKQ0F8bsiP2mUNVeUoMv8GGHkXqy381u1MVfr3x8/jyTpXFaIqNpUNUGxMUyoLTQw8fJ77T/Z4qBmHp0sipM8KW4qKM06BELcURWWobHmgnZPMkBM+wXUAlaJIsYlailrPdu9BD8haBGIzXszaSkZYdUF0RHkbh08t1fHO2+7Fe/7sPvzBnc/g84/O2Q/GCa/rU05qEcL5gL4BkVEWYR/F5jgvRR3mpahdXLHpmhaWO9L7LgmBi9AGDdiTr1OxiM3ge2nZJXUYsEtRDUEW4ys23VQeXW4EDzMrSvbY1FsxiI1L99dWhSY2SUDG4Vmf2VZkIE7is1l8GoDFFsGgziSa+B13nEE/QhKbj33xKCrNLnK8VfjPH+cZJ5FLUREybAjCPBxzwndrDcL06aLYnFujMo27mnFg0vbY9KohVaO4xmEAyMclNt6pw25hY26YGslHV2zWu92713GNho+i2IwWMtIgzLDmYZoT5a7YNNo9/MD//ia+/MS8uO+Zeem44nQM9c2KijIckp4nutyiLMKe2S5tcZ7JY5NNpzAzwt5X5+uS7ycSsXF2fzUiBNcB9uRrI+rk614HsLiy5ChF0YWA8/OSy6Qwks/YOTYJzMqCcCKaxwYA2s0E3V+63XuHgzqV/IjNtOSzib0d8tdczvoL/TAa09viBVJBfIjNY2fX8JffZorSH73tRhyeLuEJodhELUXx/Q6TOkxIah4mv0um4Hq1cp6Izbj7lUwhm4ZRYspLtxZVsYlBbOIqNqLVe5DY0GI0EbDoTzsUm5DlTiXJwxGIjbxgxixFjRakUpQixeaZC1XMrTYxWsjgR17IjP7yTKV4xMZdsYlWilLnsaHj2TNWcKgMu/iYjvPVtuR3iUJsnGWSWoSp1wCQzrHXpaISG4/30oq4EBh8L02UJON5AsWGsnBy6RSyHtlSDkjEq9VSk9ezVaGJTRIsPctupy/1fg6ZfRcStHwLf41PGYpA3USVOf/nhYUgNt5K0a3/fhSmBXzPc/bi5Zfvwq+98VrMgS3Y1trZ8MZpy4pXiko6CDMgw4aIjVcpCgBK47ucvytwm9xjE0exER6bSsQBjd5x/24pqm6YHslFnxelpBQVh9gYjqvYKMRmrGgv+KEnX3e8zy8AnFxihOWy2RG86opZAH3EJk76cJ/3JKp5eEQ2D0dRFzw6aI4L47BTtRIt32tSy3ek7Tm7ooTHJqQylebt9+moxEaQPed7acXDYwOwcm2scyq2yfaxabFjC0vekM7CArvwbcchNn0BfT3Twv+6/Un8wZ3PoNWNYUbeQGhiExedhr0IT13k/bxpHppHJCgOwrR6E0jpUKbY+JeiLMvCPceZ+vDul10MAHjZZbuQn2RjFYxeK3wab2PZ/nDFVWzidJ8FZNiQx8avY2hsii1U2XbICd+NJB4bajm3ohmIPZSTZqeHBp8t4zccEmBf2lSKMkN7bBSVosKSONnEKymckYhNwb7q7jTDKlP+5mEiNoemSriIdwwdW6jBovdLnJC+fiUj5GRvQjkvl6KSm4ePLzgzbAi7uWIzHzekT8rrYenKEdqgAWT4uIG0GVWxoZJbwfFe8ivdTpRy9jiOBIpNnWfhhC23wTDQTbH96SYhNlmbJH/iK0/jI//2RPTftcHQxCYuyMybH/NfnKbYYo/lY9G6AGSQPyeMYjOqULExe3ankQexObvaxHK9g2zacKTyPu+i3bhgcWUhbDmKyFhpOpocSh6bXjteN1iQYrMa3Ao9NcPa4dNWL5ySkaQUlcnbV71RylEeqcNr0nDI0YAFcbJkl6LatRDb7rYBukpOkjwMK/wi4VEmiUJs8pkU2gYRm4hdUR7hfDKxOThVQjploNHpCeIci9j0lQ9owQ+byOtUbOKblgk0SLX/s0LBj+crTfs1UYiUpNi0uqa4dgibY0NzlDJWO/w2AdeOKMDfbD9VyiZUbIjYsN8RWrGBNBMrVinK6bGhsmYunUI+EzG+YIOhiU1cLB1jt5NH/H0vYwdYG2evHU9FsSx7W0SS/EClqDUFxKa+BGaqNTwX4IdPs8Xt8t2jjjf/Cy6awpzFXxP2uIW/JkIZCmALCV05xvHZ+Cg2tVYXFf4B9zIPA8D+XZP2lW+Ylu8k5mEgXsu3KEU5CcaKtOAHhbpl0yn0eKt4txFi2zLJixPQlykCXF4PXY5yUROanR5aXab4hAnoMwwDvQx7fbcVcru0fx7jFE5xYnNwqoRsOiWmxD+7UHXubxyPTV/ycJxSlKUgedirROMI6YszCFPqiqpJHT/FkDk2OZ6wnI2q2HiU3Ly6ogCm2Ajjb1TFxrLEsdZMdmxh/5YAYBKxSRgMCNjvpZFCxDiKTQBNbOKC5jFNHvF/Xjpj58vEKUfVF3nt3rBbx/1ApKCioBRFZajSlGfWyqNnGbG5dt+44/4XHJnCOU5sOsunw22P9jmKv4YgOqNi+Gx8FBvy15RzaYwWvBfEQ9Nl0fIdqvSWRLEB4g3C9EgdXq6F64gipAqMoHTDlGhIQcsUo+f1AKwtPWrLt1urd9Oe7ROkShEM/nozbI6NII7Big0ARzmK7S9/XdjtAQPdQlHNw+V8WhCbbitGachrwe8LstyddBCmVCah8LlCNuUYZ+AHmomVjazYDGa7WJblq9hMlhJ4bMyuCNGs8fTisOQNAMw0267ZTp6wXI0YHbCZoIlNXIQlNoCttMQhNrSdsX3hyjOk2DSW48V5ywjR6v3IGU5s9jtHDRyeLmEly143fybkcYtW7wj+GkKSQZg+ik0Yfw3ArsKXLbbgd6ohiA2RqTgeGyBeZ1SAYhOUYUNIc2JjNUMQjVaCjihCVAOxy6IrpkHnMqFGDbDtssXQDL1db49Nt2fizDLbr0PTfcTmQh+xiWUepvJBRI+N1O7dDltyAzw9Niseg0blkD67FBUvx6YeJbSOg2ZiZdEJv03A9b3U6PTQ7jHy4abYTJWzdrt3VMVGUs2qnNiE9REBgMUJWKwp5n1ZQdVmtOiAzQRNbOJimcpDPsZhggpiQ+MSglCYsK8uKueib09GGGJzlpUjrtnvVGwMw0BukilMlfMRiU3UUhSQbBBmCMUmiNjsGsmjYjDCsLx4PsQ2qRSVlNhEKEV5tHtTimpQqzchW2Qk1miHUGxE6nCwv2at2cG/PTwnplMLRCY2gwSDvqRHI8jqKU5srMiKzWApam61ia5pIZdOCSPtkQHFJoF5uE+xCUtsUikDvXREL5G8jwOlKPcSzawYhNkSi2+sHJtMXkyujrLgFwrsXOejKjbdQY8NZdhk04brPkwkUWykOWGVDvvdoedhIemwT/fogCifmc0CTWziYr0VmzDbAbjWrshATCSB2qn7ML/WxIVKCykDuMplOOTkPt4RthqyFBUnnI+QJMvGR7GhcL49Hhk2BMMw0M4ysrGyFILYJC1FxVJs3M3DK41opah8mW071Q1BNEK2eluWhR+/7V785J/fj7+595TzQdrfsF1YLotuHL8AERsjdECft2JD/poDU0WhGF1MxGaxn9iEJBhmj3n3gIEZSqE7aQCYafbabtirfLNnG8L7jtVrOOTMSB6GwVqIyZQdy6ycKUabn8SRL3LFxujB6kVQbVxKUXLp1nDxV7JSVIxOM3l76Tzq3BMWeh4WIPwxsYZ9eoU9RiBWmwWa2MSBaUYkNtTyfSz6tqISGyD+AMp+BCg2j3B/zaWzI67O/YMXXwkAGG+eRbcXolVXZNjEKEWJLJvhKDazPsZhQo+/vrkasA+dhn2lHds8HMdj466eeJUPvFAaYcQm2w2xAItS1CDxlfHZB87g28cY2fva033nL+qEbxePTYV7bMJ6TwAgW2DbNcKWE0RA3yCx6ffXAHYp6uRinX0+opai5EUzwWJkcWLTC+uxkQmJtODLsQETZed7KZtOYbrMM2jitJc7FJvopahiySbzzUYyZcovwwYAJuVSVFQ7gEQu6q3oBM4gu0KUCfFi2+4emyifmc0CTWzioHqefSiNdChDb6XMn7P0bPSclTjERpViQ+qHF7E5w8og/cZhwuFL2MTzWSzhidMhTL3UFj62P9p+ApJiE8M87OuxCQ7nI1hcfWkHjVWgrikjHbjgeyJOV5QoRTn9LlE9NqVRtu1crxb8fg5RilptdPDr//q4+P89x5fsbBcggcfGJhEVUYoKd4wAkOXli3TYBViMVBgsRbkRmz1jBRSyKXRNC6eXGzYhCq0QSfsVM3kYAKxsRF+GB7Ghdvp0ynA1aFNXIbUxx50VFacUVSzY571RjxD26FKKClI4HeZhswP0IsxtkjqTBIGL8Le0h33GIDZ9YY9x3kubBZrYxAGRjfEDbCqvByzLwv++8xnc8LtPoIcUY8RRfS8rfJjlZEiPDaCu5Tsgddg2DrsTm/TobrSNHNKGhSefetJ/W+26rT5ECecjDM1jE848DADZMldfgrqi5AGYQSMyvCBKUSvhX+PhAYnqsRkZY76gNMzgq+4Q5uGPf/EoFqptXDRTRiZl4Pxaiy30BAXm4TilqFyRbTfTG45ik0oZIsju2EItvmKTygIptshHNQ8D9mJohiUacou5NExVhNYVs64lmlneGVUxE0wxz8YzD6cyGbQtdo5iKTaZQY+N1+fFQWyAiCZpu8uNJnRHKUWlcjQTK04pyunXqmhis8NA4Xw+ZKNnWviVf3wUH/63J9C2MjhlctUjis+m17H9KZEUG0Ut30GlqABiA8NAJc9IytKZgFlZpC5ly/aiHQW0j6o9NiHC+Qi5UVYOSwWRjaQZNkDMdm939cSrRdcL4+OS4TnI9+Iznwpg5Ys/v5uR9w99/zXivXTvCYkcxi5FDZqHxyIQm3yJkbGMGVax8fbYnJQybGRcvIsRm2cXatHNw31qgpzIG6VFl9raQxtOvVq9a/7KH32G1roZ5+8JA5ccm6htyC3u7Wk1Y4znkDpSV2reGTYAC9QzslLpOs6oikxBkNQoAX0p/jdJ9Vow+034QfBQbLTHZqcgRMnkf33hSfzZt07AMIDvvm4PTli7AQDPPvmd8NtZPcUyDTIFYGR3+NeN7uH7mVSx8SY2S7U2zvJF/+p93uUUk5fqGhcC/EXinO6Np2KQqhQ1x8Y0bXLQp9hYloX5ChGbYI/NyCQfq9AJIBtJjcOAva+xkoeTeWymRwuo0YDIoM4oKpV5lKKOL9bQ6VkYLWTw0ktncNMRRpruOS6FHKpo945x9VkosX3OW81wJWSfrig3xQaQs2yq0YlNn7G13u6J3YxynOl8xPZrDwLn1RFFoJC+Vd7tE0vJyOTFnKgopSgA6HBDbyvK5GuXiddCsSl7f14mSoV4U9NdSlFRiEWGKzZ5dITfKfq2ucemqRWbnYWAQY2WZeHv7mNKy0fefB1+/z/dgPQMMxB/9e5viw9mIORW7yiLPe2Xqq4oF2JDLar7xgu+b/z8LtYRll476W8gJhIWpwwFSObhC9Fe166IQKx+xWap1kanx1aK2dFgxWZskp2nUnfN6RHphwrFJk67d9ud2IjJ3iG7oqbLOdTAw+uCQvqESuROfp/lGS4X7xqBYRi48Qg7J/ced1Ns4rd7ixybfHiPTaksnacwPhuPBX+10RHksV+xOTzFiM2ppYYU0BfyOLvuV9gpI1qoWyrH/pZGWF+GV6t3gFdrit+/1qNSVIzZVJmimOwdpRQFAB2Dvb+j5fW4eGwCCBw91og1XNQ2D4tSVAQCl+Z/y1jEpk+dqnLFSCcP7xSIvBX3RfjRs2uYr7RQyqXxxucxVecFN9wIAJjpnMEXHw/RDgwAy+SvORJt/0jdqZ6PNxQSYB9Gutp28dicXqb2VfeUVXtXGLHZa11gcrsXhGITo9Vb3sduI9okaPLXpPMDX9Tkr5ku55DLBH9UaF7UGCpYa/oYBsk8HDecD1DcFWV7I8JgspxD1eJffpUV/ycHlKKevcAev4QrFzceZufk6Pmq2K/YycOS16UaI5OjVJJ8QWFUFOGxcSo21Oo9Xc4NXARMj7DFb7neljw2UWdi9XVE5TKuHhcvZPhimAptkiYC5yT7foMhAXuURUWUomIkLGfyaMQwDwNAJxUjr8dlpIIgcD6fl8myNC8qZhChKEVFIKnkl8obnfAX0C7bBoBqix2nLkXtFIi8FfdS1JcenwcAvOyyGTE/KbfrUgDAEeM8/vGBkEMh43REAXYpqtuMZi6VQV6VVNbV80LmzoOT/sQmNXkIAHDAuIDH53zUBSI24wei7yvAFk4eThXJQByiIyqMvwYACmOMXE2ghrkVny9P2TwcF1FzbLptO/NEWnjbXVNcAYftisqmU2imuFy9FjAXi8hxwUOxWSDFhu3T9Ehe/Hz/Sf67oyo2Ysq2S7t3BGIzJpcTgrZtWVJXlPMzccrDXwPYvqbFaju+eTjmZG9CNs/zenphFRtSMdxTh73aoKnUuULEJlK7t7Tgx1Rsulyx6UQZEOmWYxNA4ABuILZiKDaSz6URoxSFDNtmHh1RygqNPs8WvZ/CjiDZTNDEJg4Cov+//CQjNv/hSskXw0P6DhvncefReSxWQ3yJCGIToSMKYG9MWvgqIdWhfsj+GperP/vLujjwmAM8MfmAcQGPnfUhNmSSjktsDCNeSF+IDJugcD4BTlSyRg/ziz77QMTGI/hQxl1HL+DNv/91MWxUQG73DuX/kIdR2uoJlaEMI1ordDvFyEdtLYBYUanMoyuKSlEXzdj7dNNhVo4SPpvIHpvBtmuRPBzhS3q0kEEdIcPkui27pNnXFSUuAlyIzXRZVmySmYfjzvahOUrhTdJe5uFwio3w2MTsiorrsenyC5/QQYRArBwb9lguoWKTR52XoqKYh4mA5dGOVorqddmcKul36IC+nYReh5V4AFfF5kKlhe+cWgEAvPJKyZsyeRiAgRGjiUlzBZ97OIT/ZSVmKQpInmUj/DXui+8pXooKUmwwwRSbPVjGk2d9jL2C2IQY9OkF4bOJYCAOkTocxjgMAMgWRefFyrxPW7/IB3JvoxfbX23iZ//yAdx/cgW/95WnnQ+SZ8XshrvCJ1KQzjsiCqjcM17Mhh4oCABdPvm6VQ/w+Ajz8KBiY1mWKEWRSgMAN3AD8f0nYhIbl7ZruxQVnryNFjLCJ9EL2rb8N+jLsVngFzG7RgbfR6TY1Ns98d6JnGOTMHeE8noyYSdfe3iJln0GQwK2YrPcTkBsMgXR+RWV2IjJ11GGfbqOVAjuIhwvZu304ZgemzgBfZQ8nEfEUpRMvnRA3w5E9TwAi5VoSoML01e4WvOcA+NOw2kmL+ZKXZo6g8+GKUfFLUUBTp9NHAS0ep9a8r4KdaC8C2Y6j5RhYfnss96m2lUeox9XsQGUKzbzFb4ghTAOAwAMA7UsUxtqyz6t9mJqujexMU0Lv/C33xGKypefnBflFABssTf4F16YcpSXvyaEX8ANvSz7Pa1awLYpx8alFLVUa2Ot2YVh2N1BAHAJJzlnVviXrYJ2b2EejlCKGi1k0eDdX41awLYFccwNTDFf5EoG+Wkc28hnkE0zQrncIe9JiOBDYMD/Ybd6R1uIxIDI0MTGXbFZbfibasc4qVwkYrOOycMAYHLFphdrlAP7DrAsC2uN4C7CkUIGrYQeG9EVFeU4JY9NM4piI5Mvfp50QN9OgmwcTg2evq88wYjNq66YHXzt7NUAgKtSJ/HAyRWcWPS5Cmyu2ibTsAMwZShTbAaJTc+0cHaFiE1AKcowBKGbaJ4WZMGB5pq9OMdJHSbECenzUWwWxZV2uG4hAGjnp/iv9SGUpCj5KDZ/+s3j+OpTCyhkU9gzVkC7a+LfZdO5YUTrjApq9Q7ZEUWwuIrSbQRsW5SiBn1az4rOuiIKkkFSTIJeazEiHFmxGWy7jjNSIZdJCRWlXgvo/vLJsKH30bTLFb5hGIIILBGxsUzbD+W7TbtsAcQvHRCxyVghZyjRsWb6SlEBis1Yke1XPU5An2NWFFdsIpbciNiYCUpR9XYPFA/jZ0QfLWTieWw4sbEyBVFKilaKkhSbKMSGyFc6D6RS6JmW1G4e7TxvBmhiExU+/ppOz8RXn2KL6n+4ypvYvGycPeefv+NzVU9qTWnGN45+qdbGfSeWB5WQUa7YqPDY9GFutTEwqdgPqWkyTp/DY24GYjIOF8Y9TaahoFixWazSlXbIUhQAs8TOl+l33mn/PDw2pmnh4//OAg1/6buvwg/exMpz//ydPpIaxUDs0eodtSOKYHDPTM+v3ds0pVLUoMfGrQwF2K317Z6JpVo78UgFy7LEoh8loA+wO2ma9aC2du8MmyWu2Ex5lC7o/sWWtICEKS/2ZazEvcIu8DlKBbRCKkWD5RkguA26mE0jmzakydchCUavC1h8kZYVmyjDIQExVTzSgMgBQ224lvqRfCaRx6abss9htFKUlGMTpRTVsT1MgK3+Abrde2fAZwL1sYUaqq0uRvIZ9/lJs2x20nVZtpB/8TGfxW/xGXY7fYnnU+5+dhGv/fideMsnv4H/fVdforEyxWZQVaAy1P5Je1KxL/gxXGTMuRuIVfhrAOUeG1qQ3K60vZAeZYTW8CJX7bq9aHkoNs8uVLHa6KCQTeGHX3AIb7ie/S3vOnrBboEGorV8e5SiViPOiSKkC5yo+CUPt6sA+ELpQlhFR9SMkwzkMinMcJXs3Fozfo4NJxnyVXbUL+kO7/5qNwJKUX6KTc2fIBOxWWpaQCpCKm9fxkq1Fe8Ku1CU83pClKNchoxaliXUP6/3kmEYGCtk0SBDdtgFv2/YZz1m9xeVWEInLAMD6lRFUsX8WurHClK7dwyPTZt3cBkGUMiso2LTF86XTRuis3crQRObqKAxBaODxOaJc+yq7vLdI+4LPldspmrPALDwndOrovNmAILYXOr68J998zj+0x/djQWuKvzG55/AHdzfA2CoHhsyDh+YDChDEfgxXGzMuSs2Efw1a80OvvDoOfzeV54WqcACihUbMn1GUWzyE4yE5JuL7n4i2rd0zjO07sFTjKhct38cmXQKl86O4so9o+iaFm5/VDIlRxmE6aEorEScE0XIlNi+G37Jw+SvSWUd7bIEOZyvH6TanF9rOnNsghQFy7KPtc8EmU4ZkTJBAKCTZkSlE6jYuGfYAJLy50GQyYS6VIuYZdNHpupSjk0UlKTJ16HIhsuQ0Wqriy5nj37BdePFrO09idr9BTiGYEYq0QBS11mM9mvKCgrZXTcil6JiKDaUklzMpsNdPBKEx6YdzWMjzagCtra/BtDEJjp8FJsn+KJ95V6Pcsr0JUAqi1SnhtfsY192nqrNEic2vE1cxndOreC//+Oj6JoWvv+5+/AfbzgAywJ+9i8fEPJ+csXGm9ic9snlcMUUU2yOGOfwuK9i409sPvyvj+O5/+MLePef3Yffuv1J/L//8rjzCYk8Ns5MmXbXFCF7MxE8NuUpliE0YS1jreES0kf7VprxTJOmrrrrD0yI+95wPXu/OcpRUQZhEsnoL0UFTCr2Qp4Tm3THR0WRM2xcjtWrFAXYLfbn11o2WbB6wYpCr22XLfjCW5Gi4aME1wFAj3d/dcImLPcRm0a7J66cpzzeR1MlmdjwxTeMOtXn/4hrHi4VC+hZ7Lz02mESlr1boAvZlMMv1Y/RYlZa8EOOqiBik84BqVQ8Uy0AgwIFI5mWnSQu7Pyk0UImXlcUf26LKzZRDdKxu6L6hn1WtnCrN6CJTXRQ9L+Lx+ZJrthcucdjknE6C+y6AgDw/fvYVfm/e6UQL/L2XhfF5ne/zPwX33f9Ptz6g8/Fr73pWtxweBKVZhe/+Xk+RVv22MRJH/YrRYUM5xPgx3DAWMCZxRVxxSUQgtjMrzXxR187BtOyDctfePQc1uROoSSKjcs4BQDIpAzRzREG2TF23meMNZxddblSq5Nx2DvD5jun2T4995C9T6++clY8JpSgfAyPTZ/XJcjw6YXCCNt2tudngPf213R7ppifdNHMILEhA/G51aaTLAR1RsmEgL8ujnGY0OOt24GjIzxKUYs1RsRy6ZTnVf5UXMWmbxpzNWaJZkQqmzSCSm6AaylqOcSYAYApNg3H5OsQi77oiCqi3TWFMhRVsUllafJ1yO4vYKClvhJySnxSj03LImITUZWSPDb1SIpNn8dGKzY7DGR09SlFXbnHxwDLfTYvHGGE5htPLwqp3AEPYvPo2VX8++PzMAzgvd91GQyD1UB/9Q2szPW1pxfQ6ZnACKUPN6LF7gOMCPmVosKG8xFGZoHcKFKGhYM4L86TQAiPzd/cdxo908KNhydx1y+8CpfOjqDVNfH5R6TSjFBsYnhs+kpRVIaaLOeiScFlRkBmsIo5N2IjKzZuu9PpiYRmWbE5Mk2LdFdcHUczD7uXolZjEpvSCNu3XM/H5OqTYXN6uYFOz0Ihm8K+8cH30Z4xqRSVStsdOEHEhhbdVFbk9cQZp0CwiNi0AhQUl+wcwGkc9lKL3IlNCPNwx11NGInosclnUmIRbtbDKEVu2S7hBqmOFaQFHwhZciM1Ie+4KIq66NNMrFQvpIJiWQMt9WEHQ45KZLEXKTeHfe80wX5/EmKTRLHZygMwAU1sosGybM8KjS3gWGt2RO7GFbs9FBtAEJvp2tM4Ml1Cu2firqN9gxvrS3ard18pioLavvc5+3CJ5E24dt84pso5VFtdFmyWK9lX9FF9Nq0KQFc1Lgtw6HA+gmEA0+w4LjLODRqIAzw2pmnhL799EgDw1hccgmEYeBOfwfUPch4QqSDtSjgTJOCp2CzGMA6zfWBEcMZYxdyqyxdoQDjfY3Nr6PQsTJdzDg9TMZcWi/1xigmI1O7NyWQfyRClqGK04yyPTbD9shpodT2+QEUpyq3VmxGUI9NlV+K4Z5xJ6hSSGLozyi2crxmf2Bhktg4M6BtMOwZsf41XR5T8mKMUFWXBH0gejliiMQwxILLZCENsBtWpMIMhAUZ8ekijZ0QwScuhdXyxzqVTyKajLV80IDK0YiOrSX3lvqAFfySfEapLJ0YgYJOP8ohObHgpKmqOjZR4DGzt1GFAE5toaFXsN8CIs537KFch9o4XMO539bvnegCAceZ+vOZqVrYY8NmQcXhsv+ML+qnzFfwbVyh+5lVOJSeVMvCyy9hieddTnCgR+ar4pOC6gdSa3MjAFWiz0xPDIUN7bAChPF3UbyA2e7ZvyYPYfO3pBZxebmCskMH3PIeVAL+Pe06++eyirYwUJuyukjA+G8uy1Y4+xYayR2YiGIcBiPfFuFHH/JIL4QhQbMhf89yDEwNX+Ien2fk+sci/KKN0RQli4yTddo5NNMWmzEtRI0YTyzWP/JOmt2JDnXWkRPVjVi5FAeGJjVh05Qyb+FefqTz7PUYnqATmrtj4hfMRplzHKsRXbOIsRm2uLrRCERufMQPlAMWGKzodSlkOVYqyS25xM2wAe9hnJvRMLIl0kfck5HspnTLQS7P3cLSkY67YiFJUVI9NzJEK/X6tkCW3zQpNbKKgyruOcqMDkv7jQf4awv7ns9ulZ3DLpexN+MXHzjvZtShDOVu9//CuZ2FZwOuu2Y0rXLbz8suYWnDXUb54Cp9NVGLjnbNCqlQ5l/adlTIAQWz6FJu1M2wsQCprl8/6QGrNm563XxgTD06V8IIjU7As4J8e5MTIMKRy1AW3X+VEq2IbTT08Nn4LkisKE+jxROC1JRfjtlBs3D02wjh8cGLgMSIBg4pNGGLj7ndZjdkVRTk2ZTTEuQq7TQDCf7R3wj0HidQpEegYNn3YZbK37YuIdowAkOKKja9JWt5utr8U5R3OR5h0mIdjlKISjlQA7LyeViMKoRr02ASZ0KlU1RbjI8Lk9Ujzk2Jm2AA2sUlHTVhOZUSadDXKgs/PT6RAQE7iaib7/ZE7v2KPVOif7M2PMyqx2iTQxCYKqKTTp9YAwJPn2Jf4FX7+GgAoTYkuoecaz+LAZBHVVtfZxksdUZK/ZqHawj/yQL93v9w92+Zll7NF/ZGzq0xxoM6oakRiIxZfP39NKVqHCT+WS1Jn8cS5NfQoWIRI3NRFA1H0ADtuUrTeevMhx2Nv5OUox3iKKAZi8tek8wNhYwuiRTeiYpNKoZ1npKW57HLeyf/jodg86ENsDs/0KzYR2r1d1JNuzxSLftSuKPo9ZaOF5arHF3dT6orqAykxez0GjBKxWaq1WakrailK+nsmKUVlioyUpbsBC7CHImaXorzfR0Sel+sdWAnavYV5OMZi1OXEJlTZxCV5OGxsABnx7blYUczDBTFxuhSDvGXzXLExQ6Q6A9Jibx9nFPJo8PdgLxKxYcfa4MSmHNNjUzA6aPQ3afhhoKzJzrNWbHYCBLHZPfDQE3Psi+2qvQGKDQAcuBEAkDrzbbyZL85/d7+0OLsYh//i7pNod01cf2Acz5e6ZWTMjhZw1d4xWBYr34j9jFuKcs2wYR+AA2H9NWLnmLfoSuMUmp0ejvFwNizQsV7m+rIvPz6Prmnh2v1jA6bs117Dju+JcxXbgB0lpM/DXwNIMfhRFRsAFictnTUXb5OPx2al3sZxTlquPzDoS0mm2AwuvBTOB0RP5JV9M5VVj3Pt4esBIPxHe1yMwwAzM+cy7OtpXm75juF1oa6oKJO9CTne1p71M0nL+9Wn5IYpRZFxu2daaKciKBle5YM43V98u+1mBAXFUYoK77EBYLdCR8nNyRTQ6MQbgAnYwz6zVtt7Zp3bdl1IcphzTGblOMM+az1SbOK1ewNAN+bwTQCotthnRntsdgKoFDXiXPAtyxKt3m4logEcfjG7PfZVvPn5zFfytacu2GF980+wW77Yt7sm/uxbbNL3O156ka9S8nKu2tx59IKUZROX2AwuvmcEsQnZEUWYuRxIZTBm1LEPi6Lzx6vsRqChov/hykEyOTOSx65R9kF+6nzFuc9RFBu3cQp8QYqSYUNI8RJgqr6Abs90PugzAPOh04ygHJkuuSooAx6bfDKPDRGb0XwGmYhGTGRyaBrsS7Cx6nGuW96KDfmi9nkoNoZhCNXm3FrTTkwObPd2MQ8nWPAprydnBixOgtg4c4LCpFfnM2lBupqUyhup3buEnmkJT0Wc2T49GhDZjqDYSGW3sLEBNC+qIeYohTlOm0jV4ky85sgV2HdWDm20+z+Xvtu136Nh270Bm9hYkYgNIxgVM1lXFBAyk0hst58ks/Mc52JgM0ATmyioEbFxLrJnVhqotLrIpAxcPOM910ngyMv4C+/FkTEDNx6ehGnxDp92HVjgWTR7rgMAfO7hs7hQaWH3WB63XDuYnyPjFZLPxoqt2HiXos7RguThjfBEJg/MsAyfK1MnbQPxIsvkccvrkWdvUY5LP6gD7SgRmyghfSEUG78Sghdy4+y8T1krON8/9FMMwBw8t3QMV+9zL2ce5ooNm4rdidkVNUhsxiL6awjNDNvPZsVDsfHIsTFNC+dX2XnZ40FsALscxbJsonYnDXps4pSi8mW27/lAYuMe0Ge/j/wJMqUPi4yXSAF9BcdsnzhX2aYwukbvxgKkmWMhFZu6GYHYyIpNzMnegD3sM7T/xKXkFkUVy+bZ9owogYD8WGvdmKWotH3+zSjEpj+vp6m7onYOPDw2pNZcOjsi5HNfTF3MOp56beDkN/CWG5hq83f3n4Z1/lE23be8Cxjdg07PxB/cweZA/ecXHQn8/TccmUQ2bWCh2sIFg6fpRvXY+JSizgaUEHyx+xoAwNXGCdtAfIGTuJnBUtQ9x5dQbXUxXc7huv0us7dgK2RPnuMLiyLFRnhs4ig2I3bLNylcANjVGI0gcDEPPz3PjuHSWXfVbySfEQrSycW6TWy6jeD2dh9iE5Q94oV2lhGbTnXJY5vuXVFLdXbFbBh2EJ8bZscYqXSOVQjb7m0TDFE+iGEeLpXZOS5aIYlNv8cmpAmdiE3NjKDYSASDFtxMykA+zHdQH8SAyCA/iGlKSobU7s3fS0ENBeSxIXNs5ONsxy9FZTjRKKAtTMj+2x0suUVR/2h7oXNzAFuxiVuKMgx7inmchOV+I7r22OwAVN0VG1qQLvPLr5FhGMCl/4H9fPR2fPd1e5HPpHD0fBWP3v81dv+e5wCGgT/66jE8eb6CyVIWP/yCQ96/kyOfSQvV6Ok6v8qtnIuWPuxDbMj06VVC8MW+5wEAnpd6mik21XkeeGgAu68dePodT7L9eMUVuzxD8gYVmygeG54V5KbY8G6WmRiKjQjpM1ZxelmS9klFSmVcydRT9D6a9Vb9Dss+G3kR9VNtzJ6tZEgkIymx6eXYot+rLbs/wSPHZm6FvYd2jeR9s0gcIX2hPTaDc4ySJA+XRycAACU00e76lC88PDZ2Kcr/fUSlqqpJMfwBC75lOY5VbvWOOjYCgFjQzKDtyp4YacEP+14idbBKik0Yj43UsSO6omIQGznjJRSx6Q4qU1E8NrkCEZsIScf8WCtd9rmIc5wWV9+iDfvsm4kVM+xxs0ATmyjwMA+f4J1CR6YjGGovv4XdPvl5jBcyeOdLLwIAHHvgK+z+fc/F8YUabv33owCA//Y9V4uruiCQivFIRcrEoCv2MPAYp2CaliA2fiUETxy6GQBwQ+ooFioNLD39bXb/zGWuPoyvPMGIpFcZCgAuJ8UmjsemzpWG4pTz7nYXzQ5bxOIoNjRHbI+x7FRs6P1T3jUwO8myLOETumy3H7GRfDapdDifjfy3l8jQWkJiY9F8raYHsfHIsSF/jVdHFIHeY+fWWhHavQdLUfQlHdkgDaA8yj02Rg+Vmt9crMFSVKPdEwuo15woApluV7tEbAK8Lr2ONBOraHexxCwdUDeWFeSxkRdLToYsyxKli6CyJv0NIk2+lhQbkWMTpw1ZSuUNFV7X104PRGv3JmKTMUMSjF5X/E1XOzE9NoAgcJGIjYdiE6fDbjNAE5soqLorGSe5mfNQlMC6i1/JvnxXTwKn78HPfdfluHbfKG6yHgIAPJi+Du//m++g1TXx0ktn8Obn7w/9q4nYPHqhay8qUXw2HopN2BKCJ/Y8B8iWMGHUcIlxFnOPf5Pdz5UcGaeW6nhqvop0ysDLLhtUjgikblyotNjVcSSPDSc2JSexoRbdQjYV74uFE5u9WMRpmdjQQNLRQZ/UhUoLa80uUob77CSC6IyirjLR8h2C2GQKQMZeYJMqNgZXulJepMojx4bShIPIMb3Hzq9GUGx8kofjyOrpvE0yqxWfcywUG/tYSfXLpo1AEyYR6LVuyBKNTHwyRUmxiXeFbfDzZQQRKuE7KQAptnzU2z0R3xA0Vy2TTqGcS9uDMCPl2CRVbHgrdOhSlItiE6EUlS+x904mbG6OpF6tdtjxJSFw6LbCdX8BA2W3KCbpzQhNbMLCND3Nw9R+e8RnQRpArgRc/f3s5wf/HLlMCr/3ujHsMZbRsrL4wc8D955YRj6Twv9807WR5OUrhe+kYqcPh/XZmD1pUKOTUIQtIXginQUO3AQAeHXqAeRPfZXdv/+Ggafewbuhbjg86bvwlvMZMbPqyXOVmIqNc7I3zYmaLufjyfpjjITuMZZwRi5F+UyGpzLUkeky8hnvL+1YnVEeBCNu6jAhw31C2fbK4IOW5Zljc3aFMmz8fVq2YhOlFDXYsZMkeRjpLFq8Nble9TjHluVqHpbLUEHvIxHS1yFiE0Qw+CJopIF0Viy4sRZCAClObFJBpSGXxZ4G0WZSBgrZ4O8FxyDMMD4QqeRWjznok+2gNCCy5ZGWLaOvrb1nWoIQhXkvFYvUXt5h60fg9mwCtNZh75c4BM7I2iF9Lb/yqWPbTvOwHoK5U9BYZgm5gGPBb3dNnOVpvIejKDYA8NwfZrff+SugegGHz/4bAOA+XIlDs1P4/ufuw5++4wXCVxEWpNg8c6EKM2pnVGOZmZeBASVDlBAmYhiHCde8EQDw7szncHH9Ib7D3z3wtH99mO2vXxmKcMVutnAePV+xFZvmKpPr/UAem76EZVJs4rR6AwBG98KCgbzRRUUO6SNi46LYkEfoUh9/DRAzy8YjPC6pYpMbYYQw160MXhl2m4DJz39fKepcyFLU7lHbY0PDKENP9+YEwzQtVNvUFRWz+4u3tXsSm27TLgtJxGZRGoAZhCk+imCpHZLYSK3eMIzECxGNjggMInQhjmsNuwwV5kJgrJiVSlFR2r0LYmJ1MUbyMPlHUoaFVjMCoco450QB4ZSMYkn63g41OoI/J51DrcM+T/GIDTvOXFgvkbztbDEygduM0MQmLMgfUZxyyPlnVhowLfZBo0yV0DjyMmDf89mX1N//OHD3HwAAXvwf/yu++L5X4Ld/6Hm4+WL36H0/7J8oYiSfQadnoZrlC31YYkMlnOKkmI5MoFC1vXHKUISr3wgrlcWMsYYULNR33wBMOKd6n19r4lvHmGr0Pdf5t7cDwBV7GBl48nyF7bfB39akPHmh7lGKqoVr0fVEJgezxMivsXoWJqUsUylqbPCYhHHYx18D2MRmvtJifoMwLd8BxCZuu3dxnB3jmFUZ/AIVvh5jINtlLqRPi7qiWl0TNfDnRlRs6p2e8M3HafcGgFaK/a5m1eMcy/skE5sInXUUK7DYDluKslu9AaDWjp9hA9glt3RQB4+LYiMCEEOe37FiFq0oxEYiGPUkJTfJK9MME0TYd46ppJlNG76qKqFUkj5voYiNNOxT5PXEGNwqT/gOOy9KavdOGh2wGbApiM3v//7v46KLLkKhUMANN9yAr371qxu9S4PwMg7zK+dDUUcMAMxA+poPsYX42TtY+/H4QeDKNyTaVcMwcDlfIM9bE+zO0MTGr9Xbf75PKJSmYLz2/2WbsvL40oGfHnjK5x6ag2UBzz80EWrQ5uXUGXWuwur+ZAYO8tkQ8ekzD9ut3jE6ojhS46wcNWMt4AIvbdmKzWAp6unz1BHl31k3XsqKELQTi/VwgzA92q5VKTbjRm1wXpScYZNyfs0QsdkXoPwVsmmxb8tkqo3osalIZZI4bdAA0CZiU/MiNlxFypaYoZsjzJwoAik2F5r8OyRsKaovdTjuQpThqbyZXsiuqMxgKSrIX0MYK2TtgL5IpSjbYxO5DRoA0jmYYOe3HSavp68rKmrQ40gpj5YVUoEDHGZlMklHnhXFXw9EnBclHSu9lxiB2xQUITI2fK//6q/+Cj/3cz+HX/7lX8YDDzyAl73sZbjllltw8uTJjd41J2jB70sdJq/D4SgdUTIuehnwfZ9ghGn8EPCf/sahCMUFzaw61eFX9GE9NuQj8mn1DiohBOKFP4l/vuFP8Lr2b+JvLxwcePif+EwsmuAdhCukzijLssL5bCwr0DwcqyOKw+DEZp+xYBuIPRQby7JwdD64I4qwj3tTzq02lZSiog7AFODepDG4EBsyM/eRKcuSOutCKH9ECla6IYPr+qZ7y3OiYvmlAHQz7LPdaXh0FoqOKOffzi5FBRNkes6FJl/IwpqH+yZ7xy0d0LiBwIRlV8UmWgDiuKMUFcY8LCk2berWibHgGwa6BttupxkmAJFUjD5iE/I4RwsZSZmKptgkSZG2B2G2w3V/yfuXyYvPTOzogE2ADSc2H/vYx/DOd74TP/7jP46rrroKt956Kw4ePIhPfvKTrs9vtVpYW1sT/0K7vpPCU7FJSGwA4Hn/CXj/UeC/PixmKiUFGYifqnNpPKxiI7J6Br0tcyFNn2Fw+U2vxWlrF+4+tsiGHHKcXKzjwVMrSBnAdz8nuAwFABfPjCCTMlBpdpnRNExnVKtie6aK7qWoWBk2hMkjAIDDxjzLsrEsYJXPAxtzdrgt1tpYqXdgGMAlu4KJzW45uC7MIEwPYpO03ZuyeCaMGpbqfcTGI9V5qRats47KgcsdvkAExRaIBV9dd0ePE5tu02PbXnOiopSiuHl4sc0XsrBt131qQlzFJsfLJjkreimK3kehFZtiJmK7t+SxSZA8DADdFCc2kRKWnaWosC3Qo3n7OK0IBM7KFNDpcY9NNoFJ2ohQipLIY3WLt3oDG0xs2u027rvvPrz2ta913P/a174W3/jGN1xf8+EPfxjj4+Pi39mzZ9djVz2JzcklXoqKaPAdNkjFeGiVfwGFJjbegz7n1sKZPsPg8t0jmB3No9kxcd9xOwflnx9if88XXTKN2dFw28llUqJF2tEZ5UdsSK3JFBytwYDUzZJAscHUxQCAw8Y5pthU51nGipECJpxBi0/xMtShqRIKIUyRdF7mK60NNQ+TYjOOGpb7FRsRfujsOKMy1MxIPlRKN2U3LbSjlqLY+8HuiIp5jIAwLnsTG3fFJsycKMJoIYOUAdQt/p7v1P1DNfvi/pMqNnk+xTxvBbQI9xFHAFiLodjYpagIJaFMMVm7N+xhn6FGR/SV3aoRR3OMFrJoWnzoZyO8QkTJwUDcUpTdFRW6FCWRx6jHuRmxocRmYWEBvV4Pu3c7F9Hdu3fj3Dn3hfgDH/gAVldXxb99+8KVKxLDQ8kQik3UjqghgxJ5H6WQvspcuPRhj+OUw/kSdUVxGIaBV1zOyl2/8fkn0O6aWGt28Nf3ngIQvgxFoFb7U8sNm5T5ld88wvkANR4bGup5kXEOZ1YawNIz7P7xA44JvADwNJWhAjqiCA7FJkpAn1QW6vRMYTiNT2wmAAAlo4WVSl+3kkeq81zEciaRgoUW/5I1O0C37f2CvoC+asRF1xWcJFktj8VJjFPwKkUFE5tUymALISkZVs+/q2/AY8NLFzEX/ALv4Cmi5d8iTMRR7opqRjOhjxUidkVJ6pQoRcU0SROx6QWNjujbLhAtdRhgOVh0nI16CGLDiRQNJM2mjXAjevoR1TxsWQ4Sl9SvtRmwKfa8v45nWZZnbS+fzyOftxeGdasBuigZpmnhpEgd3lyKzWQ5h9nRPOYqvKuqU2eLTWlwIXdAHOcex92LtTY6PQuGAcxG7f7ywM+95nJ84bHz+M7pVfzPzz2GJ85VcGKxjpmRPF4fMOyzHzRt/PRy3fawrM15v8DDXwPYgwvDXGl7YooRm4PGPM4uVYGlZx33yzh63n9GVD9mx9wUG59SlMswSiofAPG7opAfhwUDBiw01/o60EQpynl+qdU7jL8GsBWb801pIWtXgYzH+7jPPFxt2RPM48IgwtKquj/BoxS1HFH5Gy9mMdeQPludurffzsPYGncxKvAp5iW0UGt1vZVDIo6SyhnPYxNhJpbU7l1rs/dyLPMwbDWkG2aKecJzbBgGOpxINeoBMQWAIFJd/ppYLe2AQ7EJ5bExu3bER7aASpPt61Zt9QY2WLGZmZlBOp0eUGfm5+cHVJwNh0vq8PlKE62uiUzKiD7teh1wxZ5RtJBDI8/3eeVE8Isq7qUoyrCJHc7ngv0TRfyv/3g9AOC2b57A3ceWMJrP4DM/dlNkFeHAJPuiPb3UsLuOKj5lyrp7qcQ0LTWlqLH9MFM55IweuksngEWu2PASlYzH+aRzalsPAhHLedljEzGgj8pQo/kM0h5zuAKRSqGVYb+zsdpX9vMoRZ0N2RFFEIpN07InF3uVo0xTWoz6SlEJFJtUgf1djI6XYuNPbCYDJl4TxotZdJCGaYQwEPfNxEpaikrzHJsCWv7ZJ0KxsY81uscmaycPR+iK6qTyYl5XXGXK4ot+qMnXfSMV4pRoiKS0wrSX8/cuvSa2YiI8Nu2QU8yl95mCFOvNgA0lNrlcDjfccAO++MUvOu7/4he/iBe/+MUbtFcecFFsqAy1f7KIjKLFXiUu5uWZxSxXX1ZCdJp5TDCfU1iGkvGaq3fj7S8+AoB5Zf7wP9+Iaz0mefvhoCLFZq3ZQZfnzsTOsQGAVArdyUsBAGNrR2ERsZl2KjamaQlic82+cMctRg2stUK2ew+WolYSZtgQOnwQZrPSr9i4pzpHnTUmEnlr7eD0YdmgyRWFqP4PN2QLjLyluh7bpfMrjVNod01hXI5CbAADvbTks/GC8Lo4F93YiyE/Xzmjh2rdj1ANjqwIOyeKwBSbkMM+pec0Tfs8xj1OGhAZOOxT3jcqa8Ygj70U214rgseGVJ5Y/hrA6bEJo9jI5DKTtzORtrB5eMP3/H3vex9+9Ed/FDfeeCNe9KIX4Q//8A9x8uRJ/MRP/MRG75qNXsfOPJGITawZUesI8p3MYQYHgGBiY/bsFul+xYanKycK5/PAL333VTg8XcL1Byfw/EOTwS9wgVBslhvA6BF2Z8WH2Hh4bMhfM1rIhArh8kPm0E3A4mN4jnUUvVP3sQ9b3xTz44s11No95DMpQUSDQMTmQrUFMzfOrk4imocTG4c5rMI4UD+FHp1Pgqd5OJoBncglIzYj7PeGITbc8FmJmLHihizvGMp4GV1dFJsV3iWWMqIt+ADQSRWRRS2A2PQpNu2ExEbyzLTqFQAewaB0rLJiEzmgL4NG2FKU5P+ociNuLpOKrxrT4M5Q7dd2CQyIRx576TzQBTqhFBtObAx2buIapGWPTSXqsE/DkHxMG04PYmPD9/wHf/AHsbi4iA996EOYm5vDtddei3/913/F4cOHN3rXbNQWAFhsLot0hX+Cd0RtNn8Ngfbr2c40bgKCiU3tAqu1GqmByd5za6TYqCc2uUwKP/aSixL9jv1csVmstVHL70IZYF6MVmWgGwiATVQHMmx4q3cS4zBH6uBNwAO34XvT30SmugCkMmJWFuHRs0ytuXLvWGjVb2YkB8Ngs2uWzCJmAKBdYcQ05fJl6EJsErd6cxicGJr1FecDYlxF/1iOaJEBot271gbGaMK3R3eS3CnEQwEp7j/uOAUAyHH/Sa5Xd/f/uZiHqf19opQLXeojAtRO5VECAkpRTmNrLeF0b6Rz6CGFNEw06j4t9S6KTeRSlGQetrpN+J6dXkf4P2omO7ZE3o8sDYgMU4pydp5FNQ8DtkLUaYUnNpR9E7elXVZsLoQpRQ3MiUqWYr0ZsCnqJz/1Uz+F48ePo9Vq4b777sPLX/7yjd4lJ0Ro3Yxj4TiuIsNmiCDF5rHGBLsjiNhQGaq8a2CBtDNsNp+XCGAL9Bi/YjxTT9tlF69ylChFOa9Mo7ToBuLgCwAABwyugu173kBrORGba/Y5g+z8kEmnMM0zdubb0n56ZdkMUbHJ8vThdGtFTHgG4KrYWJYVuSuKiM1irQ0rtIlXLpNEUxPcUCyzv03Barh3DLkMwFyuse1ORhgwSn+LllAzwpSinGWS2IuRYaDFZ2K1/YyuQrGJbx52eGyC2tollazKJ5/HVjIApIjYRMzPAeJ5bCz+2l4YYsOJbMsgYpNQsQmbY9PXYUeKTWxitQmwKYjNpkfF3Xey2UtRByaLSKcMHOvyxTuQ2HiH852LeKW9EbDLUXV70KSXgdirFKXCOEyYuRyLo1fa/7/0uwae8uhZVkKKQmwA20B8vmbZ8fZe5Sg3YsMne0/EnOxNyI0yZW8MNRFsCMCV2CzXO8L8SXOggkDEptU1YeYC/EQuCcBR/R9uyPNS1IjRdHSTCQhCZW93uR6+1ZtAxCZUx5BUPuj0TMlUG38xags/SAhikxssRYUlyeVcWizehmUGtLUTATEEsUmi2Ahi02v5PxGQSlH95DHC9jnJCNVeTooNL7nFJza2YhNqCGa/YiM8Nlqx2d6gPJS+qcw0Jyrq9O31QjadwoHJIk5b1BV10v/qyCec72xEb8RG4OAUGYgbwQZiz3EKvNVbQSkKhoHzL/kQ2lYaDxlXAi/5OcfDlmXhsbPRjMMER5YNkQciEzJM0y7dSOZhVYpNim97AhXMr/HFwrJcic1Z7tOaGcmH9i+VcmmR5dHkHViexKbtUnJToNgYnLCU0BTnzQEXQrUUsSMKsP8WDcp48QsjlILyqIsFSOaL6HBi0236EBtRimLfee2uiWaHkaqw59gwDGTy0sWgnzIltVxXxaDPBMSGq3mpSKUoZ/JwFGJl8O2ZoXJzuEk6aSkqbY9UiKXY8PdTaQt7bDSxCQNK7ZUW/JV6W3RcbFbFBmCk64zF/TLtqvviR3A5ToB17pwXHpvNr9icWgqj2NDC6zEnSkUpCsCB574aL259Am9u/BJWOs6P2/m1FhZrbaRThhiBERa75SwbKqe5TTOX/SgupaikXVEUfzBjrOJChROb5orruIo4s8YMwxB/i2aKE4c4ik2SgD5eAisZLUGUHHBRMaK2egM2salZIRQbSU0gJSGXTsULdOPopIv8V/spNs4SWEU6H1EW/EK+CNPi7ho/kiFNnbZLJPGVhEyOvfdSZkDCcq9rv4f7cmyikOQUf60VIa+noVCxCZVjI82oArAtuqI0sQkDWvBH7dA68tfsHsvHb8tbB1w0XUILOVSzVI7yybLxKEUt1FrKw/mGATukryERG4/0YS/FJsJE5jAYK2RRnNqDLjJ4bM7pgaEy1KW7RkKNUpAhSlFrTfsYai7EhkhAOm8bJ6FOsaH3yoyxhvkKX4Qo8yk/7timMKBHVP2IHFQNThy8vEQuJl4VXVFElEZRd1dsXEYqkHl4MkYpqmaGGB8hXWWrMnv2OLHp+YXXdZwkriLmJ6UjRV6MFrO2MuVbchtUppKUotJ5doxZq+OfsCx3wPVNUI8yniNNylSE9vI6b2uP3+4teWxClaI8PDbaPLzNQSUaidiIMtTU5ixDEahMNp/iKoyfz8YjdZiutGdH1YXzDQOOlu8xHtK35qLYdBr2YtRHbJSMU+jD1XtZCYjKToQ4xmHCrJxl46fYeLRdqyM27H21Cyu2YkNm+xHnhHgRGRCR2JDfqQK+SIRUbCzLkoytCY6TK11lNLFW9yE2EqFa4c+bKkc3D6/0+Pnx6v4CHAt+4gwbDpN7tUyv0RHAgGITdZwCYawYcqyC5P+otpKXorK8NFRA299/IpuLOVGoxDBoU8nNCDUTi31+iNjGVkyijlSQVDEAqLe0YrMzQHko0oIvjMObtCOKQMMhT5q8HOVLbNwVm7MrFKq2ectQQN9YBaHYuHhs6DjTeTGhmmB7bNQoNgBw9V7mn/FSbK6OQWxElk2labfmuxKbFXY7NGJDis0qK4sBUned831kh/NFex+RYrNiBhAb4bFhBKPR6YmwxUSzorg3KWOYqNdc1CKXUlQSj81yl5Nqr+4vwHV+UtIIfJNPMfeciQUMtHtH7YgijBWkLBu/Rd+hTNnqUFykeCmKEZuu9xNlf41hoN21DdqjERSbDHl6emFyc9ixUlu7ilJUo+OjSvVt1y5FJS/5bTQ0sQmDiotiI2ZEbW5iQ63oT7T4VT0l4LqBTNJ9Hhua77NvExuHAZvYLNc7qBf4oupmHpZN0n2ZJLQgqcixIRBxeXzOeQX+aEzjMCCXosIqNhOOu1UTmzGjgeUVvuhTKapfsRHjFKK9j0RIHykZnsSGCAZTWGjRTaeMZF/SuTJ6YK9vVlw8aoq7olZM/t5rhzDxZkvqhhZyFcbyMvNa1kBAX9QMG8JoISu6f3xbryXFJnEIISD2u2gEjI7o2sQRQJ9BO/x7KVckYhOiC4ufhypXbBKXotBGM9RIBWdbe12BMrbR0MQmCJblWoqyFZvNXYo6MFlCygCe6HIFY+Go+xMty9VLBNgLUtgY/I3CaCEr2pfP9jhZqJ5nRkAZ4u/pJHDdnollXkJQ5bEBbGLz9HxFXPU9cW4Np5cbSKeMZIpNtQWTDLobUYrKj6GXYueqvcbfPyL3qX8sR7QBmASRZdOjtvYV9ye2nCUhOcMm0bBcw0A7zT7nnf4gQtN099jUonts2H4CVYsfZ8uvFCV1C6laiLi6YHgRm24TgOV4blzFZrSQCVeKclNsEhEbdm6DS1H2tGvANg4XsqlIXqJcgZ2njBmmvZwnLPO29vilKK7YhM2xkSZ7W5ZlE0it2Gxj1JcAk9fVpS/q48Jjs7kVm1wmhQOTJTxl7Wd3XHjC/Yn1JfsqcGy/4yFxpb3JS1GArdocb44CqSxg9QbLUR7dX0tSDP5EhBJCEPaNFzBWyKDTs/DUPFus/s+3mIn7ddfsjkUu5PThaoqTuP6xBoBNAqSSW6dnii/1xMTGMNAtcWWGCKNLSdMZzhexFMXJwbkWVzI8FRsnwVhtxFt03dDJst/Zrfdt2zGfarArairC+yiVMjCaz6AGIjZ+io29GNmm1mQLEbUmp7yIhmwqTuixGQ1bipKUk8TpyoDY7yJaoq3ZFYJQcX9NM7pxGAAKRfa+CUVsuHJS6bG/Y3LFJqLHJltgeVGcu+p27+0MWhRL00CGfUk12j3hJ9isqcMyDk+X8Iy1DxYMdlVfWxh80uopdluedXSyANKV9iZXbADgwAQ3EK+2gPED7M7+TjCx8DqJDbV6T5XDx+CHgWEYYrDn399/BtVWF5+9/wwA4Edujjc6RE4fXrS4UhBSsZE7exK3ewNAmZ3HdP0Ca6Gl81u2S1ErdbsLZfd4tDIfqWfn2gHEpuX02AjFJuJi5IZulpW3eo0+jw2RKSMl1IBWtydaZqN4bABgvJS1FRs/87Cc7yK8J8kWohQnZqmeh2JDHVGZgkgmp1JUdMUmi2aYUpQURKjE+8HJWymwFOVUbGjbUY+zUGTnNGe10OkF+F34NitJE5bldu+IAX1yya0YsVNzM0ETmyC4hPOd5P6a8WJW6ZX9sHDRTBlN5LGa58dw4cnBJxGxmTg48FBcb8RGgBSbU8sNYJKThn7DtEcQoUxsVOPHX8ZmYf3J14/hV/7hEdTaPVy8q4wXXeIxbDAEKKTvQo+IjQth9SE2o4WMEgKXmWAdaLvMBTabyWVCPAU8zozkIg8XJXJwusH/Lq0KKwH1Qyg2To/NWDH5lafJf6fVT6qanOjkx4Rfizqi0ikj8kI4XsyiCv458ypFmT2gx96ryko0ANIF9j5Ke+XK9HVEAfb09KgeG3leVLhhn2ravYl8FtEWZMV3u5wIUThf1Jb6YpkRmwLaDtLgvk123le6bBvxZ0XJik3ANgGHKkZkr5hNK724W29oYhOEyuAiaCcOb361BrBbvk+lOWlxK0etnma3pHJwyOF8m70rCujrjJrgxGa5X7Fx99jYGTbqs3pefeVu/MCNB2BZwN8/YKs1SbwfZCA+25EUG7PvCk10RU2Iu5T5azjSU0cAAAeNeZZlQ0Ry4pB4zrkEPi3qUDtd5/trme7G2j6PjZ06rOA4C8wHlWr3KTZEdAq2T8ruiMoiFXFxGC9mUbMCSlFyvo1kHk7aFZXNs++JrOlRGurLsAHin2PmsaFSVDjzsBIvUZbavVv+GS99abyVmOeYuqIKRkcQbU/wdu+1jhrFJmVYMMxusFIkqWKJZ45tEmhiEwQqRTkybDb3jKh+XDTD9vPJHvls3BQbIjZOxWahysL5Ups8nI+wn2fZzK027YW1X7ER7ftOYmNn2AxHhfvv33s19vPk5kI2hbfccCDgFf4gA/HJVgmAwRb8/nKUj2Kjithg8ggA4JAxj6XFBTv8cMIus51NMGuMFJv5pgEr7VOO6vPYxDW2uiEliE2fitIiYmN3tsVJHSYwxYZKUQHExkgDmbwy83CmGEBsfAZgRlXFnObhcIpNva1g0eVEpWS0RLnQFX3dX3HC+eTtFdB2T62WwUtRKx1SbJJ5bICQYxUk8rgdBmACmtgEwy2cb2lrKjYPNHhpwE2xocW/T7GhMtSuTR7OR6By2dmVhlhwBzw2LooCACxxxUZlq7eM0UIWH/uB6zGaz+CdL70oMbEQLd/Vrt3yTf4WgotiszYkYnPQuID6PI8TKE07VIxzCWaN0YRsywIsmnflRmw8uqISpQ5zpIqMuGQ7fWRDKDYT4q44qcOEsUKIUpTIkhkBDEOZeThfZOW2vNlE1+0qn0pR0vR022MTvd27ISZ8h2z3VtIVxdu90UYjTCmKxik0Y57jjJ2bU/VTbKTy4nI7aSnK/v7KI0T6sGSUJoP2Vs6wAYCtTcvWA6KDZlCx2azDL/txkLd8P9rZB+ThrthQvs3UxY6758SCtPnLUACEIrJQbaM1dpiJ3XJ2T3PNVjH61CnVc6LccPPF03jog69N1n7MsUuE9LWYn6W+wIn4tfaTSD2Rp2wnUBRcwZWZA8YFnFp4lt1HpJIjSWRAJp3CeDGL1UYH3dwYcvULHooNJwL9HhsFik22xIhNrluFaVp2iYn2QxowGqcjiuAoRbWrzEuU6rugEMoUVxNU5LsAyPEOnqLRRq3dw3ixb7sdp4oBxD/HY5EVm5Iak7RQUAIUm47TTyRKUVHfS+TpMdqouI3jIEjlOHsIZkxyYRgsfLTXCkdsBHmUVbGtTQ02/yX4RkNku9hlCzIPb/ZWb0Iuk8L+ySKetviYgeo5Z2uwaQJLfPGfvtTx2rkYgws3EuPFrPhCOJvh6lP1nL0AkUm6OOlQFIDhjFNwgwpSAwC7+H5eqLZso27tgv0Ey7L/L3UoLXFz62SEuH9fcOVr1GigvPAQu6+f2Kwkiwwgstn2mvBtmrbCwf+ucdUEN+TKjBiOGnVU5St9Mg/LpagE53esmEUF0jnq1Aaf1Jd0TAt+0vJBtsB+Xwktx3BLe7suik1Mj81YMYs6V6Ysv9lUfNHtpfNiirgK83DO6KHV8mnB7ktYjl2KkspC9YYfgbOJTYsTm0RdSfK8qKBSlNTuvV0UG01sgiA8NqyjqNMz2SwibB3FBgCOTJdRRQnVEl/s5x60H1w9xb5AUlmHLwJA7OyRjYJhGNjHVZsz9azdzbbwFLsVZajBNmthHh6Sx0Y1ZnlX1Pxay/YLUekUYIs/dc9IxCaJouCKbAFrBebfumrhdnZfH7E5txZfsQHssk4jzY3S/YMw21XmMQIEyVDpsSHFZhR1QZgABJiH4yk2LWTRo69mt3JUH7FRZR6m31dEy93o2qdiAPY5Ho/hsaEp5t3mmvcTuWLTTtkXG4mGM0rG504jRE5Q0lJU1v7ebNR9tsf9NVYqCxMpFLPpyMZzBxxjFYIUG7u1XdV4jo2GJjZ+6HXtIYq8bHFmuYGeaSGfSW0JMy3hCCdhJ4tXsTtO32c/uMgX/amLgbTzDb3VFBsAgticXWkAM5exOylx2cNfA6xPKUolZMXGIuIie2xIrcmNOr5gk3hAvLCy60YAwFSXb//gzeIxFs4X32MD2C34dZrw3a/YENFJZe2hhcLYqkCZ4h6lcaPmnPDddDEPxxinQGC+JwMNg5MHt86o/lKUouneIrzOaDnJm9iuk1CxIaPxFJtiNo2GwaeJN4MJBqkY2bQROS7AgXQOJl/2ui0/BcVJ4qpxyWM6K8ZxNBp+M7jY96zJ37uJFZMoYxV4NxayBVGe0+bh7YzKHEuuTWXFFfEzF9iH8OJdI8kY9TrjCB+G+ajBF/ozErFZeJrdEgmQICYyb4EMG8J+vq9nVhrAND8m8hUtH2e3rsSGFJutQVh3cWLd7ppo5vkgTDdi0zezSSg2ColN+8CL7P+kssDhl4j/LtXaooywO+I4BQKpS54TvmWCwUt9a9JIhcTgHqVx1FhWD6E1WIpKqtgAsNOH3UL6REmIfabjkosBSKm8YRSbWrsnUmqjGrQNw0CPe3V8iQ1XEyjML7H3wzDQS7P3oOmX7Cwye5wjFUZinOMuV5tafsSGH6fJu/4SqVJANMVGSrGu63bvHQDyY4zvFwY+IjaX7No6ZSjAHtb5jRYLisOpu+2QMypLzV418LotqdiMS4rN7qvZnXPfYbfnH2G3u650vKbZsdNit0opqpBNi0V7Nc3nRVGgJOCaAAzYC69KYpO/7FXiZ+vQC0VnEgAcPc8+MweniijE9A2QurRqhSA2HHYpSoViw87vhFF1tu26mYcTKzbw74ySlBPTtISxNXEQIaXyooVKs+2yXafvhFSdTMpAIRtjKeHExvKdicW+f6iDKmm6MgD0+BTznp+3R5ViA6DLiVTbz2PDVZNeiis22YTHGcVj05U8Nlqx2QFwyXZ5Zp59qVyya8TtFZsWpNh8aXUfrNwI65Y5xxf70/ew2wMvcLymJ4XzbRWPDSCVolYbwH5WIsGZ+xmRm+Pm1r3PcbxmkS/2uXQKo1uovkzl0IU0V2xWz9gPuhiHgWSKghf2Hr4cP9j9EH6j80M4+7IPOx574hxTNa7cE33YJ4HKg8smEZsV5xNciM0wFJtJVLFalxZ9t1JUjczD8YlNxSRi41+Kqra7sGKqJgPgi3jGMFFruGTZ9HVFyXOiYhniify2g5WMhlBskisJFhl622GGbzqTh+MQG1JhOiFKbqTuxJ4TRZAVm7Dt3lKOzVYegAloYuMPke0iERtSbGa3FrE5MFlEygDW2gbaB3mZ4Jkvs+6oRV6KOnCj4zWL1Ra65tYJ5yPsnyTFpgnsvoZdvbRWgWe/whbEVGZAsbHLUDllXUvrASpHzVmc2KydgVjpXIiNZVmJFAUvZNIp1HffgE/2vg8PN2Ycjz0xx67Ir9ozGvv3E0lY6PJFyWu0AScYpmmJq2wVOTYoMcUmb3RQq0kKg2tXVLJ2bwBYI2LjFtInhceRKpVLp2KrYQLSdPJmzcXQ26fYJDVnpzixSfVnA8ngik3N5IqNgosOi5MVy7fN3KsUFYfYsL+lr6eHqyZEbBITOGmsQjNCQJ/oitpCF3du0MTGD6IUZYfWbdVSVD6TFkrG3MxL2Z2PfBZ49g7289Ql4subcIb7a2ZHC8hsgXA+AmXZnFlpwEplgL3PZQ98/VZ2u+sqR4gVwLNgsHXKUIRdo+wL7FR3AoDBvqQofdhlyna11UWnx4iPSsUGAK7kxOXxOWdpQSg2e5MrNvMdL2Lj7E6SlQwlik1uRJhAW2tSurOYns622+z0xLydiZjt3gDs9OGAUhSVg1TMw0I6g47B2+r7p5gDA+WZ1XqyoMdUgb1fUn4Egy+6VZMdn4pSFO2/73Y7Th9TklIUkYxOK1ghovNfTFyKIsUmIHnYstzTnbVis42xxMPGppgvZanWFhkVF89sLcUGYMMwAeDB8VezD9v5h4G//TH24DVvGni+GB2xRRKWCbvHCjAMZqpdrLWBK7+HPXDsLnZ7ySsHXiPakWOaWzcK1Bl1vm7aLd9EyEW4pE1sqExSzKaTy919uIoTFyIyACtnPnmeLc5XKlBszjVppILXzCZnq7cSJQMADAPN7AQAoLXGh41alk0iS0ylIrUmkzJilTTT/HU1y8dj03EhNipUKQCdDPuOaNf8CBX77ks6miPDk46zXb9uIfYdVO2pK0WJDsFumFJUEZZlJSM2fHtmiLyeFic2SVOkHR6bts+sqF4bgCVeoxWbnYBFIjaXALDVmv0TReWLwnqARkAcXcsA1/1H54PP+5GB5x9bYF84F22hvB6ABRKKAZErDeD6t7K5OoTnv33gNee5STpu185GgbJsLqy1mMkdsH02orX9iHj+0hDKUIQr9w4qNicWa2h2TBSz6US5T6TYnGlxYkPp0QShnDBio1TJ4Ojm2e9uVTiZaVftnCA+0oIiAybL8UuaY0HzoiSCoTKrBwC6GUZaem7ZMn2hdSsJiU2+yIhw2uoAXRezMiDKX5WeulJUKs/2P+1HbKRJ5q2uiR5v/4pTijKI2HSCiRS1tSc2vEsem7rf6Ah5AKlWbHYA2nVgjZuHeRrvM/Nb019DoCybE4t14HX/Ezj4Qsbsv/t/CVVKhphiPrO1FBugL8tmZBfwPf+LZau87P3AzKUDz9+K3V9AX/owlUxXTzM1gWZkSa3tYpyCqtRhCVdxc/DJpbq4wiWSc/meUaQTxCMIxabLyVH/sM++tmulHVEcFp8HZVJqd40rN9mSWOznK0SQ43vSHIMwg0pRkoFXBagF22r6bJdKUUmJTUlS8NwSls2eUFVWe6RkKCA2XHHKWU20ux5qhlR2o/eSYQClGOpfKsf+lpYfseEEo2kRsVHTFZVDR5RGXSESjw0gnds2XVFbe++HieVj7LYwLrwnW9VfQyBic2yhxo7rx/4N6LUc4W0yjvFS1FZTbABGbB44uYIzPMofN76D/fOAnYy7dbq/ANs8fKHSAg5yArP0LFM06Gp/wja/D6MjijBZzmHPWAHn1pp48lwFNxyeFGWpJMZhgF1B5jIpLHW5T6ddZV/K2T7PDScfFZUdURwGV2UMmr9FBIcGkAI4v8a8WrtH4xPk8WIWVZoX5doVRcSmhLVVtaUoiy/6ri3YfQF91B02UYq37XKphJaVQd7osuOU5pkBcMyQWunS/KTkf890nvJ62mi0e8hlXK7vpVKUPKMqTnZZmpNeo9OEZVnuSh4nNnXe/aVSsVnwVWykhGXD0Dk22x5iKOQlIvDrmQtbs9WbQC3fJxZrsCyLZfN4kBp6HrC1RkcQ9suKTQicW92iHhuZ2FCn14XH7SDCkd2Ov/EwOqJk2OWoNX6b3F8DsEC3qVIOFRRhpviXfn3BfgJNMed5MvZwRnWKTWaEXeBkWivs80PbdxAb9j6aTfA+Gi9mUaMcG9eAPmr3Vl+KMninkuFWAus3DydUbEYLGek43WZiEbExsNphC21i7wlsolE0WmKAqAOW5TjWpCMrMnn2+ctaLRFUOQCunNRNdi7jlLycG5U9Nn6KjXN0xHZRbDSx8YIYCnmJuMtWbLYmsTk4xVq+a+2e6ALywkq9jRVulD6yFUtRvKQUmdhssVIUeYkWa210p69gd84/4TkTa5iKDWBn1ZBSo6IjisDImIFOnl/Z1yRi06eeKM2w4ciP7wEATForLH1YGIddFJsEpajJsqzYuBAbUnGGUIoyeHeXawt2X+IxeWwmivHeS6MFexCmq5eoY5e+qm0aG6GiK4pP3EbLvUzTbUIYanN2KSou2chwhaiADiotjwnfXDmpcWKTeCK9pNj4TzF35vXY0721YrM9cfNPAD/5DeDlvwCAtXGe4lO9L5ndegoGwFq+qRxFnSpeIOPw7rH8lmTv+yIoNtVWV6S3bjViM1nKCe/KYvFidmdtHjj5Lf6EI47nD1uxuUoyEK81O2Jg7FUJwvkItM/UneRQbOjnMiMZqpUMAMiMs4Gqs8YK8zQRsSnbuT0XuMdmNkEpaqKUkzw2Lgs++YnyY2K8Q+KFkCPNW7Az/Z4Xy3IQDcBWbOKSqtFCxiZwriZp26xck8pBiSGGfbbdjbWyFyYjlaJikioyDxeMtvuoCkAoNtTWrspjk0dHlJfct2uH87W6PREFsRW/82VoYuOFbJGFu+1iV8EnFuswLfaG27VFZgm54QpeEnjynD+xoVbvrViGAmxiIzw2PiC1ZjSf2XJTbVMpAzM8e2e+lQHGuc/mnk+x24PONGmh2AyN2DAC8+S5Ch4/yxbgfeMFjMf0Ycigfa6mJ9gdNU4sLMtWb3jb9Zqq+UkyeDv9rLHMFM+aWylKgWJTkktRbsSGf3YLY0IBUHWcGd6plDPr6Pakskm7Jk1PZ8+hHJu4HpuxYhZ18PPkRuDkctCQFBtqb3aAymLpHJDOCFIVO5Gck4wC2iLBeABcsal2idio89iEU2yKqEvnIvEQzg2GJjYhIZehtlIybT+I2DwRQGy2aqs34QBPH16otgKTN7dqGYpA6sCFahM49EJ2p8m/QA+9yPFcyrGJk4obBhfNlJFLp1BtdfEjf3w3APs9lxTU8r2W4im/pNK01gCTS/xcPbGVDIXEZpQrNljBgqzYSMGW5LFJEhswUcx5l6J6HXvBlxUbRW3tuRI7tyNoCKXCsR9GWq3HxvLz2Nhm5ZpKU6s0xbzR8VFs+PMqCT029HsKCFZs1rqKFRvDQ5US25XJI89+yqSQ3UKBrG7Y2nu/jniCmyG3qr+GcGVoxWbrtnoD7MuWvhxOLvkEYwGYW2VfZFuV2JCBeH6tBVz7FvuBwjgwe7XjuZRjM4x2bwDIplO47gBbHDs9C/sninjHSwejBOKAfEHL4GUtUkxE23VZXI0PoysKo6TYrODCWhOonmf3l1kAYrdnMsIDO18oDiZKWe9SlEx08qO2x0YRgaNSVNloOhdh2m5+FDAMWJZle2xiKjbMPMwzXlyDCAcNvGoUG7srylWx6R+A2Uy47axNMipNf4/NWpcRN6WKjdsxEhypw1wV2+JqDaDbvUPjnuMsEOx5hyY2dkcS4grudTh6voKeaXlmi2zlVm+AddEcmS7j4TOrOL5Qw+W7vVWD81s0dZggsmwqLeD5rwamL2Ppw6/7dTGVnrA8hMne/fjof7wedx9bxA2HJ5UqnFO85HbB5H9LUmyE18UuCQ3DY4MRZh4uGS2srS4BKzzhmbfTL9baMC0gZQDT5STmYUmxaVfY8Fb6O5K/JlsC0ln1eT28K2oEDaw2OhBBAYLYsO+PWrsnQuviKjZjhSxqvBTVbqxh4NMnKzZi0VVbilp0K9P0zYkSpai47yWunhTRFurP4DbJY0Pt3uo8No2wig3ft63urwE0sQmFTs/EA6cYsXnBRVMBz97cODRVQiGbQrNj4sRiDRd7KFBbudWbcHi6hIfPrAq/kBe2ajgfQbR8V1tAJge85072QM75tzNNK9GAxrA4MlMW0QIqQft8tsdLUTQyos9fA0B5txAAIFdCK11GvldDe+WsNCSX+Zrmub9m12g+WRhhKYs1cKXUMhmZKU6w/1MicJ6RO+UJy/z3jqBfsXFul8pQuXQKxZgjK/KZFBpcsWnXK/7EJmk5SAZXYkpe7d59CcuJxikA4nNYQgtznh4bZ0BfYgLHFZsC2qh3ejBNyz2Dx02x2eIdUYAuRYXCI2dW0eyYmChlcekWL0WlU4ZQL7zKUVu91ZtAHWDHF31m0UD22GytcD6CGKtALfy58gCpAdhizy+yMTFEYjMskMp0ojPB7qDREaIjyiY2SQc0eqFVYGWnkZUn7S4hnviswl8DsL9NCzk0+CInxkUADuXEsizlpSjkqBTVcJZN5FIU2HcEwIhjXEXOMAx0M+z7pdvwHuFgZUtqF92c7Xlxbffu99gkLUVRF5bR8jEP81lRyGEkn0lEjAFIPqI2LAtodj3KUZI6pbTct8HQxCYE7jnOMjJuPDwVK3lys+GK3f4G4uNc4diqrd4EGt4Z5LGxU4e3ZrcblaLmA7KJqCNqNJ9xT1vd5CBi81STKzZrnNi4KDaL/FinFZfc2uNHAACXVpgxmgUgMiJzXkGrNwBMcDK2An4RJc/FkpSTVtcU7bnKSm6cuIyi7u2xgWwcTrbdHh+62W14t3t30vb5VOuxafm3e/eVomKH5vExFWU0vT02/FgbyCmaRm8fIwBvnw3NipLJ4xb+zidsvW+3DcC3j1EZajLgmVsDdmeUy1USgOMLW78MBcRQbMa2pmLjSB/2gShDjWw9tQawic3RJjcPN1dYuYJMvCO7ALDSMS2804qjGcxdVwEAbmjdw+4Yt8dVUKt3EuMwAGTSKYwWMli1+OePUpUBR6s3laFShsLFiM/aGjPqvoqN3eqd7L1k8kXf3TzMPredFPtcplMG8ioIOScsJcMjoE/MxGL7Vk3a7i1yc1rOTjMZ/FjrVl4NsRHlNvaZ9+yMkkgcleW2eqs3oIlNIEzTwr0nmGJz05Gt7a8hUDqsVylqq7d6E45wxebMcsNz2F2r2xNX91vVY0MKwfk1NovGC0u81XtYqcPDBnXfVKwSTD7TCKtngGUa9slSlskgnTJs9UMVsnuvAQBMY4Vv0x4wSuF8SeZEESZLOayCiI2k2NBMLKkjarSQVackcy/PGOqCOAHwUWySnV8a4WC5zsRiKkY7xc5nOZdWY0SX2q/rrl1RTsUmcbs3V08GOs1cttlAQY0RXPIRAT6KjWQepnOhS1E7AE9fqGKl3kExm8a1+8c3eneUgBSbE0t1Vyb/wKkVx/O2KnaN5lHMpmFawOll93IUGT5zmVTsttWNxp7xAgwDaHVNUW5yw3p0RA0T2XRKLKSd8j5259oZe4r5JCM2i9LYCNWl45ED1znvoNwgqAnnI0yWsrZi4+qxGcfaMDq/uGKTNXpo1iVFt2UTKkAep5DsM5MqcILqGtDHLrCaBic2qhbcwFKUsyuqyglkfI8NO8YSWt5dUZzE1aFKsbE7vwC45/UAEokraMVmJ4H8Nc87NLHlQ4sIu0bzmC7nYFnAU+edXyidnol7+TG/6JJpt5dvGRiGgcNctfHqjJI7orZq8GIukxIzo874jJAQGTZbVLEBbFLWKLLWa6yeHlBsFqvcXzOEklt29xXOOy79LvGjKvMwwEo8dinK3WMjOqJUhhBmS+gZbGHt1lek7VIJjBGfpOMUxOZ4irHRP8IBEIt9k3dOqSM27PdlDBPtlsvnpS/HhtSO2IRDdEU1UWl4XHjw429YOTWdX3ybBbQAWOEUG5XpzhuM7bFSDxH3HNteZSiCl8/modOrqLd7mCxlhcl4K8MmNu4+GxHOt0UzbAhhZmPZis3WVKYApmQAwGqRdSLhxDek7iTKk2FXqUNRprIFfKLwbgBAbeJyx5Dc81K7d1JMlrKSeXjFfoDavQtjQrFR1uoNAIaBdoZ97i03YiO6opKF8xFyJfb70l2XCw/udWnwrBtlC67UMdhruWyXVAxV7d6cIGUME82my+ez2xZJ4UyxUVGK4r4kmGxeVBiPTUsrNjsGFMy31fNr+kFBg3cdXXDc/61nWdjZzRdNb4sOMNtA7K7YiHC+LeqvIYSZjTXsOVHrgSkefDdX5MrJ4//Mbkf2iO6kJdERNZwut69Pvhk/3P4lfP2m3xP3dXumIFRDVWzo5+KklK6slqh2c0xFMV1LYM78nKQem0KZl77ciA3fZoUrNqoGfSKdhclVqV7L5YJHUjFM00o8BNNBpJo+2wPz2Cg5zqwd01HwSlgGPJKHtWKzrWFZFv77916Nd770oi2fONyP11/D5t58+Yl5NKTOACI2L7x4exA56uzyVmy2B7HZH0KxWapth1IUW0hPZLlS0uYLrqScCGIzpO6vXWMFfMO8FidNu718ocryQtIpQ0mL+WQpZys2MsEQ86mmhzMPC4CZZ2QjRUZlYCAYcIWXVJIqNqVRtq2c6U1slnsFvi11f0+TJ/OabZfPS9v22NSlOXOxS1GpNEzesu43OqKHNDrIqPHYpLNAiv1tSl5eIsCR2SMUGx3Qt71hGAZef+0e/PfvvXpL57m44dr9YzgwWUSj08OdR+cBAO2uiXu5QvWiS2b8Xr5lEOSxofuJGGxV0P6fWfYmNoLEbeGyGyk2T+MgkJI+k5e8Wvy4UB2uSXqGRlhU7fZ6Uv5mR/NKlM7JchZrbu3eDVYaR3FK6opS+91kEbFpS8RG2i6griuqzIlN3mqyKe0yuJ9oqcv+jpMKzf0WVzRcvT2SYkOBepmkreak2nTqYhSFACdSLd79pUyBoywbo+U94VsrNhrbCYZh4JZrmQHzXx9m0fQPn1lBo9PDVDmHy2a3dsIygYjNqWWXLxQAj55lX95X7R1b1/1SDeGxWfUmNtQZRpPPtyJIsbnQsIAjL7MfuOK7xY9LvCSkOpyP4JYbJBMbFZgo5bAI7nGrSeXiOicYpSlRilI6NgKAwVu+s21JXZC2C8jEJtk5Hh1l20rDtBdZQps1Niy02TZUKjYWz6hJddy6sWwVo9qyO6KSNBcY1PKN5mCWDSdSLe4lUkZUs3Z+jmtej7RtdqzaY6OxDXDLdXY5qtnp4ZvP2GWo7eCvAYC940Xk0il0etZAmWah2sL5tRYMYzsQG3a151WKWmt2hNl0/5YmNuzLf6neAd78h8C+5zNSM3uVeI5dihqOx2aGl7hIGQKA8xUK51Ojhk2WsliweLwEBRBalkcpSu0Vdro0AQDId9fs7UreHsA2DydVbMbHJ+z/tN0nmc+31Ss2VFJLd6qD2U9Su3eVe1OSdioZ1PJtuIT08e01eFu7kq4owNHyXfcMBrQVm2rShOVNBE1sdjCee2ACe8cLqLa6+Iu7T+LfHmHKzQsv3tpt3jLSKQMHp9gHvL8c9dhZ9sV9ZLqs7stkg0ClqIVqG83O4NUZlaimyrktXVYlxWap1gJGZoF3fwV4618C0tX04pBLUaTYzK/ZRm0ilKoUm8lSDhesCfafxhLQ67AFkCLwS9Pq50RxZMpsuyWzhk6PD+G0+HuqOIWeaYmguaTEZnIkjwqfZN6srtgPdFtAj/0dz7fYNlR6w1I8GLBgNtDqD+8UQzDLohSVWEWRW777xyq07dRhti21pahSqFJUyVYAFb+fNgKa2OxgpFLMQwQAH/qXx/AoX+hfeun28NcQaIL543PO1nY63qv3bW21BmALTJlLyG6qzWlObLZyGQqQ/C0+4yOGNSeKcBmPQXhqvirIBWU/XacoxHOilMUyRtC1+Fd07YKt1qTzQK4syIXSdm8A2TIrN00YFbYNKkNlS0C24EgkTkpsRvIZVPgk88rKBfsByWQ7V2fHpzJAM12gYZ9NZ8Iy4DAPy6WoRBClqNZg+jAnUjU+9FRdKYqCCNs+5mF+rJmCIHFb/SIP0MRmx+PNzzuAdMpAOmXgP1w5i0//2E2CCGwX3HSEyefU8UUgf80124DYGIYhZdkMtnxvB38NYHevzVdaTE3owzDnRBH2TxRx0UwZPdPC3c8uodbq4oGTKwCAlyi6KJgs5WAhhUXw92Z13lGGgmEMJ6APQHqUTTCfRoVtQxiH2eeIzm8pl048TNUwDFQN9n1TW1uyHyBiky1jscHUBpWKjcFLUWU0BDkVoJJYbkRZKYrSh4tGazAdnKsmVZMdn7K/p5Sw7Nru3esAJjv2XqYoVJ3tUIra+kegkQjXHRjHv7/vFRjJZ5QEi21GUGnt28eW0DMtpLl/iEpR1+zbHqMy9k0U8dR8FWdWBjvAbMWmNPDYVsJMOY9s2kCnZ+H8WnPgeIY5J0rGSy6dxrGFGr7+9AL+v/bOPD6q+ur/nztrJttkgyyEAGFHVhE0bCJQKViWX90AFRQbtdSlCCrWNuJTKLV1w7o8ltqKT6vWx9+j1ioPKC7VH1gpsq8iQhKykmWSTCaznt8fd5kJW7Pcm8l8Oe/XKy8ydyZzvx/uJPOZc873HKtZQiBE6J3mQO80ff5/421m2MwmnCYnMqV6OWKjptvi5ddzg0F9bJAgG5sMySVHF1rU+ho5kqPXOAWVFnMiEAS8DREfPLS+OYmocxnQpkBJRSWiBS7PGdEMdbyDPUkbp9DpN3truHj4LGOjpKLcIYMiNpIXVReaYg6gKRS+lnrvsosGHLFh0C8jQVhTA8jGJcluQaM3oEVp3N4AvlN624gQsQHCRcHnatInSsTGZJK0qI06lT0SI+dERaKma784dhrblKL7Cfn6pXAlSULKmQXE2s4kOXJiVCoKCbKOdKlBrrtormt1Xr3GKah4LfLvn7cpcnSEbGxCtiS0+OXIXIqeHbOVCEqC1NI6YhMKhXsj2ZPCBbWdrUtTjFQCPKhpOiON6g/PiQJ0jJioNTbn2xWl1mtBQlNATmPbzCbYLbwrimG6PWaTpHWOVtNRh8obQCQPLMwwKGXR1VyoSZ86QyrW+/UA8k43ACg7h7ExujmfSkF+BiQJOFbVhL/vKQMATBigb9F9arwN1UiRbzRVAQ3yeZCYBX8wpL1Z6V7smaimolznTEXVN+vTnE/Fb5PTQgH32amogLJl2WKSkKRn7YeSikqEp3WNTWRfm8hUVGfNhj1c0xO5m04+p2JsyI44q0m/mYTKrqi489XYtNrq3cl5WN2MqBqbvn37QpKkVl+rVq2K5pIYQVEHeqpb2g8IloYCwlu+z9WkT5RUFADkKBGb8nMYuNNNBs6JisAZb8VIpVBYNVh6D41NibeiWo3YNJa3mmIeWYCqe01EvByxsUlBeBprIrZ6yx8O9BqnoBKyyRpDnoiGgIqx8ZvlSEdKvFXfIbWtIjYRb/pqGkoytSoe7nyNjWxskuDRoooa2rBPneZEqSimMF5qOXeNTcRW70a9Um7dhKir+I//+A8UFhZqtxMTxSpcZboHap3NjhN1CARDQhUOq+Q4z92kr7HFr/UdieUeNipZis7yC0VsDJoTFcnEARnYUyq/jgZlJqJnkr4dnVPjbThByhTz2uPhO1LytDeieJtZv0/4KtY4eEyJcISa0FJXAZDSRyehB4CIAZidbM6nQnEpAAApcnSEkg5qMcnXWs/mfABapYZKIyM2WuFwEiBJ+u0UUiNEkkdrIBk+p7LdG3Z9IyatUlEXjtg0dnbQZzcj6qmopKQkZGVlaV9sbBgjGJqdjOQ4C5q8Aew95cK+U2rERhxjo5qW8voWhCK6LKtpqNR4qxB/uC7UjLDWbWwPm0gi2yJMMGAESWqCFd+FFGNTcwyoL5a/T8kzbE6Uiscmp51a6isA1yn5oLMXgIiuwzqlokxKQ0CTN6IdgxKx8Ujym3Oa3sZGidgknlljE1G0DEC/pnWtamzOjNjIZqqJHDpHbMKpqHP2sWkVsdGpX083IerG5vHHH0d6ejpGjx6NtWvXwufzXfDxXq8XDQ0N2tdZXSMZ5hyYTRIuV6I2S17+SutpI1IqKjM5DiYJ8AVDWkoGAEprxUlDAeEam3NFbNT6BaNrbADg0j6p2vygCTqnoQA5SvEdyd3BUXdSNjcAkNIHdUqdi17poDPxx8lGzd9QCbhK5YPJuQCAWp3PbUmQTZTVHzmbSk5/NZnCqShdidzuHbkrytfU6v66Zp12gCnPlyR5zq6xUcxUExz6dpHWUlFe+AIhBM5sjxDZdViLTMV+cz4gysbmvvvuwxtvvIFPPvkEd999N5555hksW7bsgj+zbt06OJ1O7ausrKyLVsvEOmo6qtEbQKLdghXfG6Tb9tzugNVsQqbS0v9URDRD/T7Wd0SpZKs1NueYi2X0nKhI4qxm/Gz2UFx7aS6uHNxD9+dPjbeiGk54TAkACKCQXPvhzNV2hBk1lZ6ULd/mpgqgQTE2SsSmXNl1p0bOOostUa7dsQUiRiooO8Bcyrws3SfSqzU2OKNBn1pjo9wfLpTu5PkjipXrmn2tIqqqmXJTnL4Rk4iRCgBaTSoHcMboCGMGqkYL3VWsXr0ajz322AUfs2PHDlx22WVYvny5dmzkyJFITU3Fddddp0VxzsXDDz+M+++/X7s9dOhQNjdMm7hxXG8cq2pEXloCFl2eZ9in3WjSNz0B5a4WHCpvxJg8+ZOwutVbhB1RQHjg5+kmH7yBYKvtqeFUVNfsdFsyoa9hzy3XsEgot/RCvu+ofDAtHzBbtWhVtkHGBun9gVNAjucIEFIiKcmysVFruNSars7iSJKNTXwwYuimshOrVplwrutWbyDcx+bfpKLUeqLUzp7fpkaIWhAMEVweP1JV862YKTfikKpnxMQWjtgAQLM32Dp1KXAqSncVd999NxYsWHDBx/Tt2/ecx6+44goAwLFjx85rbOx2O+z28B8tXSvlGaFJtFuw7ocjo70MQxnfLw3bj9dg+/EaLLo8D4A44xRUUuOtsFtM8AZCqHR5kZcejrrVdNF2765A1fCleSzyoRibYfMBABUN8jU1KmITlzUY2AuMCe4FJAB2JxCXjFCINFOVo5NRdjjlaFcSRdTYeOoBAKeD8puzcRGbM7Z7qz1sbIkgIq0ZYafPr0Rskk3ydatxe8PGRq2xgQO9DYjYJJhkDe4zC4hbzYkSq3hYdxUZGRnIyOhYId2uXbsAANnZ2XouiWEuGgr6p2P91m/w5fEaEBEkSRJqqzcQHh/x3Wk3ylye1sZGrbHpglSU0ajF4H9omY5FeF0+OPIGAOGxGUZFbBJ7DQEAZEnKVm8lDVXj9sEXCEGSoKU9O0tyuvz33gk3/D4vrDa7loqqCqjGRueIjbITK0HyoskTsUspoutwQ0sAQSVl1OnobkQqCpBfpwN6queUzZT+qSil23FExKYV54zYiBHFjpo92759O7788ktcddVVcDqd2LFjB5YvX465c+ciLy8vWstimJhmdO8U2C0mVDd68W21GwN6Joa7DqeJEbEB5Df07067W9XZRM6J6opdUUajpg6Pe+LRfNdWxIeagB6DAYS7LmfrlA46E0uPQa0PZMi3I6eYd3ZOlEpyWk8ESYJZIjTUVCA9u4+WiirzGrTdOy68G5Ii++dEFA+r9TUOqxlx1k5241VSWzb4YUWgdS+biOJhfXdFqdu95XOdHbGJqLFpFquPTdSKh+12O/76179i6tSpGDZsGIqKilBYWIjXX389WktimJgnzmrGpXnhoZ/VjV5tZ4coNTZARPfhiPER6k4hk2TAG2EUSIqzaruBiuMGAflTtftUQ2dYjU18GuqllPDt/tNanVevNBQAmM1m1Emy0WiqLZcPKruiTnllfbqnosxWhJRdQ5K3Pry7NqJ4WKuv0SNapNTYAGeMVSA6Y7u3/n1sHGrE5gKpKHVbu67dnaNI1FRceuml+PLLL6N1eoYRloL+6VqdTUmt/KlsVK5TmDAzcO6dUWrH5fREuzboNNbJTXWgvtmP0loPhmTJb/5ub0DrlmtUjQ0AbHPOwux65YPmgOkAwnPI9CocVqk3pSIj5IKnrkLuxKvMMSr2qMbGgNdunBPwuxEfcqPFH4LDZo6YE5WoGWVdTLLZIkdQ/M1IjNzyHfACIflauhFnyHZvO6nGpi2pKDY2DMN0Qwr6pwMfAv/v2Gl4lQGC980YGOVV6Ut2ijpWIRyx2a+MyRiaLU7TxdyUeOw/1aClE4Fw/55Eu8VQs7ojrxDWmiPIyOmHMU65h42aitJrq7dKkzkFCAG+hkotDUUmC8o98luUERE4yZECNJbBKbnR0OKXjY1StIw4p347olRsibKxiZzw7QtvcXcjTt/Uotqgj+TXy9k1NhGzogQrHo56gz6GYfRlZK4TcVYT6pv98PiDGJXrxFWDe/77H4whcs4xCHO/Mt5gRC+BjI1SQFwaMf+rwuit3goZqU4U+lfiz+n3aceMSEUBgMcmb/kONlRphcMUlwoiOfKme4M+AJJSQJwMd3hnVItSbxOXom/EBgg36UMzatSxClrhsB0Ek747F5VUlAUBWBC4wK4ohzZSQZSoLhsbhhEMu8WMy/qkabd/OmOQcG0RtIhNRCpq7ynV2KREY0mGcC5jo2o2Mg0FAFnKrqfKhrB5PFVvTNGyz66093BXA83yoNqAXa4VS7Jb9J+HBcipKADJUnO4l4028DNFv67DZ53PHU5Fqc354IDData36N0a3i3ogO/sVFRAeU1Z4rTZY6KkotjYMIyATFTmGI3KdWKqAV1xo436xlrf7IfHF0SLP4hvKuVPvyNyxRmToW7RL60Pp6K6KmKjGqeKCGOjpqL0LkQPOOTXq9lzWhvh4ImX52Tp3pxPxZECQN5mro1VUFNRjlS4lIiNboXLEefTUlHqjiiKQ69Uh74fQMw2QJJ3cznghdt7RsRGmSoesDjQoqSsRUlFiaGCYZhW3DqhL0JEmDc6R7hoDQAkx1mQYDPD7QuizOVBY0sAgRAhLcGGHIPf8LsSdYt+ZMSmzOCt3ipqn5pK5XzeQBDVjXIKRe8aG0rIBADEeSoBVwkAoNEu97fRfQCmSkQExaWlouqV+1JQ1yzXbOmWBlNSXymSO7wrKqLrsO4NNCVJjtr4GuGQvGdHbJSp4i0In5e3ezMM021x2Mz4yVUDhGnKdyaSJGFwllyz8MnhKuxT0lDDezmFMnJqZKS+2a+lCyqM3uqtoEZsGr0BNHkDqHTJb8Z2i0n3PkGU2g8AkNpSqkVs6qyy2TFs675iNJyQi4cR9IeLeR2pWo2NfhEbObXmlNyoa/bLQymVXVhuOIzpDG5Te9l4z97u7VMnqMvXOc5qMiblFwXEUMEwzEXHtWPlnTpv7CjBvtJ6AGIVDgOte9mow0zLDR6AqZJot2ipiQpXi3b+nBSdUyYA0vPkTsdpwSqg5lsAwGmzXPBuyFZvoHWNjccfTkMp9+m+KyoiFQUok8OVc9ZTojEfQiIGYbrPE7FpIvkxohQOA2xsGIaJUeaMykGc1YRjVU34YF8FALEKh1W0AuLa1sbG6FQUAGQmy3P5KhtaInZE6W+o8vv2QxPFwYwQUCL3NyuHXHdjXMRGMTZolvsCqWkoezJgMmsRG6dDp/MrEaIe1vC8KLVY2UUJxkRslF42DsmL5rNqbGRj00iyPlGa8wFsbBiGiVGS46y4ZkQOAGidU0UqHFbJTVEKiOua0ewLaPUg2QYYjDPRCohdLeEeNgYYqpQEO06ZWs8ILA7Jxkb3rsMq8fLOwVSpsXXERjEgLj07DwNaxCbdLBft1jT5NGNTjwRjOoNHpKLOitgo9T2NIdm8ilJfA7CxYRgmhrlxXG/te9EKh1Uit3yrO6ISbOYu+YStFhBXNLSEuw4bNJqjPi58LWF34juvnFbULRV0JglyqitDcsk1NmrExpECfzCk9XbRzVgphilNkiMlp5u8CDbL55QjNgakorQp5i2ta2xCIcAvr8MVlK+xKFu9ATY2DMPEMOP6piI/Qw63i1Y4rHIuY5PljOsSrZG9bIzqOqxS3XOi9j0NnIGdJfKupMGZSef7kc6RKLdByIALDc3+Vj1s1PoaSQKS9epjo0RskhVjU+v2wdt4GgDgNiUhI9GAyJQ6VVzytO48rJgaAKgPyucVZas3wMaGYZgYRpIk3HllPgDge8Myo7waY4jsZdNVW71V1FTUF8dO42C5bDSMiti0DLseAZLfksry5uJ0kw92iwmj81IMOZ8asbFLAQQ99VrHYzhStcneTodVv7ljSsQmISSngGqafPA3yWbKkpBqjFFVjQ082nwxAFp9DSQTXD65102iXZziYXEsGsMwFyU3jsvD9KGZSNd5C3J3Qe1lU1LrwZEK2VwYvdVbZUBPOZVxvDr8Cd8oYzOoVzpm+9ZhvOMUBgdGATiIsX1SYbeYDTkfrHEIWJNg8TfC4jkNNCqTxZOy9e86DGjbveODjQAIx6qaQMpcLHtShn7niSQiYlPf7AMRyQZKNTa2pIhxCuLYAXGUMAxz0ZKRaI/2EgxDLSp1efzY8Pl3AIBsg8zFmRTkp2Pj0vHYeaIWhyoakZcWr6X+9GZAz0R8g9442twb45VdbgX56YacSyUUnwG4GmH31gCN8jmRlKVFbHTdkaUYGzP5EQ8vPj5cBSm+HgCQkGKwsYEHgRChyRuQt3UrHY9hS9AK79nYMAzDMF1CUpwVl+Qk40BZA5wOK8bkpeB6pYeP0UiShCsH9cCVg4wfyxFvsyAvLR4na5rx1XdyJOOK/sYaGyT0BFzfweGtATWWQwKApOxwDxs9e+jYEuROwP5mTMwK4cOKEKy+BkACnGkG/f8qxcNOk9xcsc7tl42NFrFJ0CZ7s7FhGIZhuoz/++MJqHX7kN1FRcPRYnBmEk7WyNuh46wmjMpNMfR8piTZUKSiHtQQNjZ1JTp3HQbkSuTETKDuO1w32Ip/VPgQL8mGIz3DoPowJWKTZmkBfEBtsw956fHhDsv2RK32RqQaGy4eZhiG6ebEWc2GdPztbqhjMgDgsj5psFmMfYsyJ8mGoofkAprUVFREjY3ePXQS5fNNyQ4h0yoXgodIQmbPnvqeR8Uub5l3muVz1blbTxWHLRFNXlkr97FhGIZhGJ0ZFLG1u8DoNBQAKbUPAGCYdBImr1yY3brGRucoRqJsYBy+GvyfgfJz1yIJuWnG1C2pEZskSTE2zaqxUVNRiWgUMBXFxoZhGIbpFgyJiNhckZ9m/Al7yDOqJpr2y7etCYA9yZgaG0CL2KCpEnPyCQBQhXRkJBhU/G5XG/TJPYhq1YiNV43YRBQPC9THRhwlDMMwTEzTLyMBA5Ut5iMNrq8BAGQMAgDESbKRQVo+IElaZMOoVBSaKjEgRx4H0jO3H0x69co5EyViE09y3VI4YhNhbLSIjTg1NmxsGIZhmG6BxWzCpvsmI0SA1dwFCYWUPPgkG2ykvOH3Hg8AEREbvY2NUkvTVAU0yH1zMrL76nuOSBRjExeSjU2tWzFwLS753zinloriGhuGYRiGMQCL2WR40bCGyYw6R9/w7d6XA0BExMagVFRjOdBQJn+fnKPvOSKxycbGFmyGhJBWO6Qam4AtCb5gSF6aQKkoNjYMwzDMRUvp4NvCN/KuABFpERvdjU1qX/nfmm+BhlPy90kGGht7uGYpAS0RNTZyoXSLOVG7XyRjI44ShmEYhmkn9stuwm3/rEWmPYBfp/ZBg8evRTF0T0Wl5QMmi1zjUvov+ZiRERuLHTDbgKAPyWgO19goERu3JBubRLtFv5lY3QCO2DAMwzAXLf17JOJTGoM3PONQ0+TFvlL5Tb93mgMJekcxLDYgrb/8vU8Za5CSp+85IpEkbfimU3Jr/XlUY1MblEdz9EwWayQJGxuGYRjmosVhMyM3VX6DP1bVhF3F8sTtMb1TjTlhj8Hh7xN6ylEcI1FmVKVITahzy4MwVWNT5ZcNTWZS1wxV7SrY2DAMwzAXNQN6yCmZb6qasLukHgAwuneKMSfLvCT8fd4VclTFSBRj44QbgRDJ07wVY1PulQ1NVhdNi+8q2NgwDMMwFzUDlY7Hx6qasEsxNmPyUow52dhb5TobABgw3ZhzRKIYmx4WpZdNk1czNmUeuTg6M1ksY8PFwwzDMMxFjRqx+fhwFWrdPtjMJgzLSTbmZElZwD07gW8+BEbfZMw5InGkAACybPIgTFdDAxCSe9ecdMvGJkuwGhs2NgzDMMxFzYBM2dgU18pRjUt6JcNuMRt3wtS+wPhC454/EiVi01OJ2DTWn5aPS2YUKw2IORXFMAzDMAIxoGdiq9uGFQ5HA8XYZJjlwZfuhlr5eJwTlQ1eAOKlotjYMAzDMBc1yXFWZEakYwyrr4kGirFJlWRj09IoGxuKc6KqUTY2HLFhGIZhGMGIjNoYtiMqGqh9bCDnnQJNNfK/tmQEQgSTBPRIFKvGho0NwzAMc9EzsKe8Myoj0a71tRECJWKTQLKxoaZqAIDHlg5A1mvpioGjXYhYahiGYRimA4zMdQIACvqnQzK6t0xXohqboLzF2+KRjU2jWT4uWhoK4F1RDMMwDIP5o3vBajahoH96tJeiL0nyRHGHtwYSQrC1yLuiak0pAMQrHAbY2DAMwzAMTCYJc0YZOJAyWiRmApBgogDS0AiHXy4erg7JEaosAY0Np6IYhmEYRlTMViChBwAgS6pDkl+ehVUWkGuKRExFsbFhGIZhGJFJygIA9JTq4CTZ2BR7EwCImYpiY8MwDMMwIpMsp9gypTpkQC4i/rY5HgCnohiGYRiGiTWUiE0/Sw1SlEZ9R93ylvYsp1g9bAA2NgzDMAwjNknZAIArTIcBAAFLPEpa5EhNT47YMAzDMAwTU6T0AQCMokMAgCPBXAAS4m1mJNnF2xzNxoZhGIZhRCZndKube/29AMj1NUI1I1RgY8MwDMMwIpMxCLCFZ2EdpVwAYu6IAtjYMAzDMIzYmMxAzhjtZqNzEAAxe9gA3HmYYRiGYcRn3I8AVykw5BosHroIxR98gxvH9Y72qgyBjQ3DMAzDiM4l8+UvACMBvHlXRjRXYyicimIYhmEYRhjY2DAMwzAMIwxsbBiGYRiGEQY2NgzDMAzDCAMbG4ZhGIZhhMFQY7N27VpMmDAB8fHxSElJOedjiouLMWfOHCQkJCAjIwP33nsvfD6fkctiGIZhGEZQDN3u7fP5cP3116OgoAAvv/zyWfcHg0Fcc8016NGjB7744gvU1NRgyZIlICL87ne/M3JpDMMwDMMIiKHG5rHHHgMAvPLKK+e8f8uWLTh48CBKSkqQk5MDAHjyySdx6623Yu3atUhOTjZyeQzDMAzDCEZUa2y2b9+O4cOHa6YGAGbOnAmv14udO3ee82e8Xi8aGhq0LyLqquUyDMMwDNPNiaqxqaioQGZmZqtjqampsNlsqKioOOfPrFu3Dk6nU/sqKyvriqUyDMMwDBMDtNvYrF69GpIkXfDrX//6V5uf71wj04novKPUH374YbhcLu0rMtrDMAzDMMzFTbtrbO6++24sWLDggo/p27dvm54rKysL//znP1sdq6urg9/vPyuSo2K322G327Xb5zNADMMwDMNcfLTb2GRkZCAjQ5/hWQUFBVi7di3Ky8uRnZ0NQC4ottvtGDt2rC7nYBiGYRjm4sHQXVHFxcWora1FcXExgsEgdu/eDQAYMGAAEhMTcfXVV2PYsGG45ZZb8Nvf/ha1tbVYuXIlCgsLeUcUwzAMwzDtRiIDtxXdeuut2Lhx41nHP/nkE0ydOhWAbH6WLVuGjz/+GA6HA4sWLcITTzzRKt10IWw2G/x+P0wmkxb1YRiGYRime1NeXo5QKASr1aprY15DjU1XYDabEQqFor0MhmEYhmE6gMlkQjAY1O35DE1FdQVxcXFoaWmB2WxGz549dXteIkJZWRlycnKELFAWXR/AGkVAdH2A+BpF1weIr9EofVVVVQgGg4iLi9PtOQEBIjZG0dDQAKfTCZfLJWS9j+j6ANYoAqLrA8TXKLo+QHyNsaaPp3szDMMwDCMMbGwYhmEYhhEGNjbnwW6349FHH23z7qxYQ3R9AGsUAdH1AeJrFF0fIL7GWNPHNTYMwzAMwwgDR2wYhmEYhhEGNjYMwzAMwwgDGxuGYRiGYYSBjQ3DMAzDMMLAxoZhGIZhGGFgYxNFeENa7HMxXEPRNYquDxBXYyAQiPYSDOf06dOorq6O9jJiCjY2XYzH40FLSwsACDlT5GIg8o+pqNewubkZdXV18Hq9QmosKSnBF198AUC+hiK+8e/btw8PPvggADFfp4cOHcKKFStQUlIi5PUDgIMHD2LGjBnYtm0bADEN6unTp7Fjxw4cPHgQ9fX1ujwnG5suZP/+/Zg9ezamTJmC4cOH48UXX8Tx48ejvSxdOX78OD755JNoL8Mwjhw5gh/96Ee4+uqrMXv2bBQXFwOAUBPmDx48iPnz52P69Om45JJLsHXrVgDi/FGtqKjAmDFjUFRUhI8++giAeG/8e/bswfjx4xEfH9/quCjXcN++fZgyZQqam5vh9/uFu36AfA0vv/xy7N27F8888wwA8V6n+/btw9SpU7F48WJMnToVTz75JDweT6efl41NF3H8+HFMmTIFgwcPxj333IMJEybgxRdfxMqVK7Fr165oL08Xjh49iqFDh2L69OnYtGlTtJejO/v378ekSZNgsVgwZswY1NfX46qrroLP54PJJMav0v79+zF58mQMGjQIRUVFGDFiBJYuXaq9eYjwxlhVVYVQKISSkhI8/vjj+PjjjxEMBgGIYVD37NmDiRMn4u6778bq1atb3SfCG2NNTQ0WL16MRYsWYcOGDcjPz4fL5UJtbS18Pl+0l6cLe/bsQUFBAe69915s3rwZZWVl2LJlCwBxzOmxY8cwffp0zJ49G++//z7uuecebNiwAY2NjZ1/cmK6hCeeeIJmzJjR6thf/vIXmjFjBl199dW0d+/eKK1MH+rq6mj+/Pm0aNEiWrx4MSUkJNDf//73aC9LN8rLy2ncuHG0YsUK7Vh1dTX179+fXn311SiuTD9KS0tp1KhRtHLlSu3Y3r17ad68eVRWVkaNjY3U0tISxRXqQ0tLC91+++309ddf07hx4+iqq66izz//nIiIvv322yivrnOcOHGCnE4nLVmyhIiI/H4/rV27lpYuXUrz5s2jzZs3U01NTXQX2UlOnjxJkydPpurqavL5fHTDDTfQhAkTKDs7mwoLC2nHjh3RXmKn2LFjB8XHx9MjjzxCRPLfmfz8fLrjjjuivDJ9eeihh+jaa6/VbgeDQZo5cyZ9/vnntHPnTiouLu7wc4vxMTMG8Pl8KC0thcvl0o4tWrQIP/7xj+H3+/Hiiy/qll+MBlVVVRg4cCAWLFiAjRs34uabb8aNN96I999/P9pL04Xdu3cjEAigsLBQO5aeno60tDRhCvsOHTqEqVOn4qc//al27PXXX8fHH3+MadOmYcyYMXj00UdRXl4evUXqgN1ux86dO+F2u/HXv/4V9fX1+NWvfoVp06bh+uuvh8/ni9lPxV999RWys7Nhs9lw5MgRzJ49G5s3b0ZDQwNcLheWLl2K3//+92hqaor2UjtMaWkp9u/fD7fbjVtuuQX19fVYtWoV7rnnHpw6dQrLly/HwYMHo73MDvPcc89h6dKlWLNmDUKhEDIyMrB69Wr8z//8D7Zv3x7t5emGx+NBY2MjamtrAQBr1qzBli1bcNddd2HBggVYsGABvv766449uQ7Gi2kDr776KvXq1Yt27txJRPInKZX169dTz5496ejRo9Fani4cOnSo1e0777yTEhIS6L333tOOBYNBcrlcXb20ThMIBOj3v/+9dtvn8xER0dy5c+lXv/pVq8eGQqEuXZueHD58WPv+hRdeIEmSaMOGDbR//356/PHHKS8vjzZt2hTFFXaOQCBARESFhYX03HPPERGRy+Wi9PR0cjgc9OKLL2qPjdXr+Morr9CUKVMoNTWVZs2aRZWVlZqWVatWUXp6On3zzTdRXmXHKS8vp0mTJtGzzz5Lc+bMof3792v3ffjhhzRhwgR65ZVXorhC/dm7dy8NHDiQnnrqKSIKv45jmd/85jc0ZMgQmj9/Pt12221ksVjorbfeorq6Ovr000/p6quvpgceeID8fn+7fxfZ2BhM5AWZMmUKjRw5kurq6oiotbnp1asXPfHEE129PF0IBoPnvX3HHXdoaalAIEA/+9nP6Je//GUr7d2dM/+IROqbP39+q9TNc889R5999lmXrU0vztTo9XrpnXfe0VI0Kvn5+a3ScbHKU089RXfeeScRES1dupR69uxJQ4YMoVmzZsWscYv8nfrjH/9IixYt0tIyka/ZxMREzdTFKosXLyaTyUROp5MOHjzY6r6pU6fS4sWLo7SyznEhw7JixQrKysqi6urqLlyR/kS+Fp944glat24dXXvttbR8+fJWj7vhhhto5syZHToHp6IM4PTp0ygtLQUgF+v5/X4AwMaNGxEIBPC9730P5eXlsFgsAAC3241evXohJycnamtuL5Eazyycjbz90ksv4eabb8bNN9+M2bNnY926dZg3b56mvbsSqc9sNre6z2QyaUWmoVAINpsNAFBUVIR77rkHGRkZXbvYDnIhjTabDXPmzMGkSZMAAMFgEDU1Nejfvz/Gjh3b5WvtCJH6VEhJMeXm5qKsrAyFhYX44IMP8NVXX2Hr1q04dOgQXnrpJTQ3N0djye0mUqPFYtGKoG+77TY8+OCDGDFiBAD5NUtEOHbsGPr164dhw4ZFbc3t4cxrqOrbuHEj5s+fj4aGBrzzzjtoaGjQHpObm4shQ4Z0+Vo7yoV+D4FwQfuSJUuQlpaG119/HUBsFRGf+X6htsxYsWIFVq1ahdzc3LPeExITE9G/f/+O9SrquO9izsWBAwcoLS2Nli5dSmVlZWfdv3fvXho1ahTl5+fTCy+8QG+//TY99NBDlJ6eTseOHYvCitvPv9N4Jl6vl/r160fp6em0e/fuLlhh52iLPjUVNW/ePHr66afpqaeeIofDoaUauztt0Xhm+LeoqIgGDx5MJ06c6Ioldorz6VM1nTp1irKysqhPnz709ddfa/cXFxfT8ePHu3y9HeF8Gi/0qf/nP/85jRo1ik6dOtUVS+wU59OnRqbq6+tp1qxZ5HQ66c4776QXXniB7rvvPkpNTT0rLd5dac/f0mAwSPPmzaOxY8d20er04XwaIyM3q1atotzcXPr888/pn//8JxUVFVFqaiodOHCgQ+dkY6Mj5eXldMUVV9DEiRMpLi6OfvSjH53zxep2u2nx4sU0atQo6tevH11++eWt/rh2Z9qqUcXv99OyZcvIZDLRvn37unClHaO9+m666SYymUyUkJAQM7sx2qvxgw8+oBUrVlBKSgrt2rWr6xbaQdqiz+Px0JtvvtnqDTCW6hbaew3fe+89Wr58OSUnJwtxDSPfFH/xi1/QrFmzaNiwYTR79uyY+PBE1L5rqOr99NNPKS8vr1XdVHemPddx2rRplJSURAMGDKDRo0d36nXKxkYnQqEQbdmyha677jr69ttvaevWrWSxWC54IcvKyqiiokKruenutFVjJKWlpbRs2bKYiGR0RN8tt9xCkiR1+JNFV9NejcFgkNasWUOTJ0+OCWPaHn2x8MZwLjpyDX/+85/T2LFjY6KtRFv1qVFTInkLv8vloubm5mgsud105G8NEVFtbS1VVVV14Uo7Tls1RtaGbd68mXbu3EkVFRWdOjcbGx0pLy+nf/zjH9ofzA8//FC7kJGh38hfyFijrRojDZzH4+nydXaUtupTfxlra2tjIjUTSVs1RkYwamtru3ydHaUjr9FYoyPX8PTp012+zo7S3t/DWIRfp2GNXq9X1/OysTEI1bx89NFHrVxqIBCg3/3ud7R169Yor7Dz/DuNH374YZRX2Dn+nb6PPvooyivsPBf7NeTfw+4PX0PW2F6699aUGMZqtSIYDGL69OnYvHkzZs6cCUBuSvTuu+92vPFQN0J0jaLrA8TXKLo+QHyNousDWKPuGnWzSMxZxYehUEgLI27evJkkSaKUlJSYqDc5H6JrFF0fkfgaRddHJL5G0fURsUYjNXIfm05CSi+BYDAIs9mMsrIyvP322/D5fJAkCSaTCS0tLfjf//1fJCcnY9u2bbj00kujvOr2IbpG0fUB4msUXR8gvkbR9QGssas0srFpJy0tLWhqatKaBkmSBJ/PB7PZjJMnT2L48OHYu3ev1rQNkCcmv/XWW9iyZQuGDh0araW3GdE1iq4PEF+j6PoA8TWKrg9gjVHTqGv8R3D27dtHP/jBD2j06NE0f/58bfoqEVFVVZXWKOrMbaQejydmtnSLrlF0fUTiaxRdH5H4GkXXR8Qao6mRjU0bOXz4MKWlpdHy5cvp1VdfpZ/97GeUnp5O8+bNo/r6eqqsrKQ//OEPMdsbg0h8jaLrIxJfo+j6iMTXKLo+ItYYbY1sbNpAIBCg+++/n+644w7tWHNzM82fP58kSaIZM2Zox2O154DoGkXXRyS+RtH1EYmvUXR9RKyxO2jkGps2YDabcezYMbjdbgDyUDKHw4Err7wSd9xxBw4dOoTbbrsNwNkDIWMF0TWKrg8QX6Po+gDxNYquD2CN3UFjbP6vdiHBYBCBQACDBg1CQ0MDdu3aBZPJhBMnTuCXv/wlxo4di1WrVmH37t2orKyM9nI7hOgaRdcHiK9RdH2A+BpF1wewxm6jsctjRDGCGj5T84Pbtm2j4cOH06hRo2j69OnkcDjozjvvJCKi48ePk9Vqpe3bt0dtvR1BdI2i6yMSX6Po+ojE1yi6PiLW2N00cufhc3DkyBH84Q9/QF1dHXr37o077rgDBQUFeO211/Dhhx+ipqYGS5YswS233AIiwunTpzFs2DDk5OREe+ltRnSNousDxNcouj5AfI2i6wNYY7fUGBU71Y05cOAAOZ1OuvHGG2n69Ok0fvx4SktLo/fff/+8P/PAAw/QmDFjYmbInOgaRddHJL5G0fURia9RdH1ErPF8RFsjG5sIAoEALViwgBYuXEhEcsitoqKCli5dSg6Hg9566y0iCofkvv76a1qyZAmlpKTQrl27orXsdiG6RtH1EYmvUXR9ROJrFF0fEWvszho5FRWBJEmorq7GpEmTtGOZmZl4+eWXERcXh1tvvRX5+fkYM2YMvF4vLBYL7HY7/vGPf2DEiBFRXHnbEV2j6PoA8TWKrg8QX6Po+gDW2K01Rs1SdVMWLVpEY8eO1Qqk1CFewWCQ5s+fT5deeim53W7t8eoo9lhCdI2i6yMSX6Po+ojE1yi6PiLW2F018nZvBVIGd910000IhUJYs2YN/H4/zGYzAoEATCYTCgsLUVtbi5KSEu3nrFZrtJbcbkTXKLo+QHyNousDxNcouj6ANXZ3jWxsFCRJAgBMmzYNkyZNwnvvvYdnn30WLS0tsFjkjF2fPn0AAF6vN2rr7AyiaxRdHyC+RtH1AeJrFF0fwBq7u0Y2NhH4fD7ExcVh3bp1GDt2LN58803ce++9cLlcKCsrw2uvvQabzYbs7OxoL7XDiK5RdH2A+BpF1weIr1F0fQBr7NYao5YE62aoecMTJ07Qf//3f5PX66V169bR6NGjyWw204gRIyg7O5t27twZ5ZV2HNE1iq6PSHyNousjEl+j6PqIWGN31ygRKYm0i4Tq6mqUl5cDAEaOHAlAbhFtNptx8uRJTJw4EQsXLsRvf/tbBINBeDwefPTRR8jIyECfPn3Qu3fvaC6/TYiuUXR9gPgaRdcHiK9RdH0Aa4xZjdF2Vl3J3r17adiwYTR8+HCSJIkeffRR7b7y8nLKzMyku+66K6ZHyYuuUXR9ROJrFF0fkfgaRddHxBpjWeNFY2y++eYbyszMpEceeYQOHTpEf/rTn0iSJCopKSEiooqKCnryySfJ7/dHeaUdR3SNousjEl+j6PqIxNcouj4i1kgU2xovGmPzyCOP0A9+8APtdmNjI82ePZt27txJn332GTU1NUVxdfogukbR9RGJr1F0fUTiaxRdHxFrjHWNF03n4VOnTsFkMsHv98NqteLZZ5/F5s2bUV1djcOHD2P69Ol4+OGHMX78+GgvtcOIrlF0fYD4GkXXB4ivUXR9AGuMeY3RdlZdxcsvv0wmk4luvvlmuummm8hms9E777xDLpeLdu3aRYMGDaKioqJoL7NTiK5RdH1E4msUXR+R+BpF10fEGmNd40W1K2rDhg0oKyvD3r17kZWVheeffx6hUAgmkwm33XYbTp48iS1btmjNh2IR0TWKrg8QX6Po+gDxNYquD2CNsawxtlbbRo4ePYqXXnoJdXV16NevHxYtWoT8/HwUFhYCAJYuXYoePXoAgHYRvV4vLrnkEphMsdGzUHSNousDxNcouj5AfI2i6wNYIyCGxlZEO2SkNwcOHKDk5GS65ppraOHChZSRkUGTJk2i//zP/9RGq69Zs4YcDgdt27aNdu7cSUVFRZSRkUEHDx6M8urbhugaRddHJL5G0fURia9RdH1ErFEUjWcilLHxer20YMECuv3227Vj1dXVdP3119MVV1xBTz31FAWDQaqsrKQFCxaQJEk0dOhQGjFiBO3atSt6C28HomsUXR+R+BpF10ckvkbR9RGxRlE0nguhjA0R0fe//31atmwZEYVbQtfU1NDixYupoKCAPvjgAyIiCoVC9Pnnn9Pu3bupsrIyauvtCKJrFF0fkfgaRddHJL5G0fURsUZRNJ6JMMXDoVAIwWAQCxYsQDAYxDvvvAMA2la2mpoazJ07F8nJydi0aVN0F9tBRNcouj5AfI2i6wPE1yi6PoA1iqLxvETbWenNtm3bSJIkeuqpp7RjXq+XiIh27dpFdru9Ww7tag+iaxRdH5H4GkXXRyS+RtH1EbFGUTSeSUzviiouLsa+fftQXl6O2bNnIykpCQUFBVizZg0efPBB2Gw2/OQnP4HNZgMgO9i+ffvC6XRGeeVtR3SNousDxNcouj5AfI2i6wNYoyga20S0nVVH2bNnD2VmZtKYMWMoJSWFevfuTStXrqSSkhIKBoP0yCOPkNlspocffpi++eYbqqyspEceeYQGDBgQM/lD0TWKro9IfI2i6yMSX6Po+ohYoyga20pMGpu6ujoaO3YsPfDAA1RbW0tERI899hhNmjSJ5s2bRydPniQioj/96U/kdDopNzeXBg0aRL169YqZkJvoGkXXRyS+RtH1EYmvUXR9RKxRFI3tISaNzcmTJ6lPnz60efPmVsc3btxIkydPpkWLFlFFRQUREZWWltKmTZto8+bN2tTSWEB0jaLrIxJfo+j6iMTXKLo+ItYoisb2EJM1NmazGQ6HA2VlZQCAQCAAi8WCxYsXo6WlBc899xw2b96MxYsXo1evXujVq1eUV9x+RNcouj5AfI2i6wPE1yi6PoA1iqKxXUTbWXWUOXPm0OjRo6muro6IiPx+v3bfddddRwUFBVFamX6IrlF0fUTiaxRdH5H4GkXXR8QaRdHYVmJiCITb7UZjYyMaGhq0Y3/84x/hcrlwww03wOfztRrSNXPmTBARfD5fNJbbIUTXKLo+QHyNousDxNcouj6ANYqisTN0e2Nz8OBB/PCHP8SVV16JoUOH4i9/+QtCoRAyMjLw2muv4fDhw7j66qtx5MgRtLS0AAC++uorJCUlgWKk96DoGkXXB4ivUXR9gPgaRdcHsEZRNHaarg4RtYcDBw5Qeno6LV++nF577TW6//77yWq10tdff609Zt++fTRixAjq378/XXbZZTRnzhxKSkqi3bt3R3HlbUd0jaLrIxJfo+j6iMTXKLo+ItaoEusa9aDbjlSora3FwoULMWTIEKxfv147Pm3aNIwYMQLr168HEUGSJADA888/j9LSUjgcDtx4440YPHhwtJbeZkTXKLo+QHyNousDxNcouj6ANYqiUS+67a4ov9+P+vp6XHfddQDkDokmkwn5+fmoqakBAEiShGAwCLPZjJ/85CfRXG6HEF2j6PoA8TWKrg8QX6Po+gDWKIpGvei2NTaZmZn485//jMmTJwMAgsEgAKBXr14wmcLLNpvNaGxs1G530wDUORFdo+j6APE1iq4PEF+j6PoA1iiKRr3otsYGAAYOHAhAdqZWqxWAfDErKyu1x6xbtw4bNmxAIBAAAC0MFyuIrlF0fYD4GkXXB4ivUXR9AGtUiXWNetBtU1GRmEwmLXcoSRLMZjMAoKioCGvWrMGuXbtabW2LRUTXKLo+QHyNousDxNcouj6ANYqisTN064hNJGo4zWw2o3fv3njiiSfwm9/8Bv/6178watSoKK9OH0TXKLo+QHyNousDxNcouj6ANYqisaPEjKVTc4hWqxUbNmxAcnIyvvjiC1x66aVRXpl+iK5RdH2A+BpF1weIr1F0fQBrvOgxci+5EezYsYMkSaIDBw5EeymGIbpG0fURia9RdH1E4msUXR8Ra7xY6bZ9bC6E2+1GQkJCtJdhKKJrFF0fIL5G0fUB4msUXR/AGi9GYtLYMAzDMAzDnIuYKR5mGIZhGIb5d7CxYRiGYRhGGNjYMAzDMAwjDGxsGIZhGIYRBjY2DMMwDMMIAxsbhmEYhmGEgY0NwzAMwzDCwMaGYZiYZfXq1ViwYEG0l8EwTDeCjQ3DMDHL3/72N8ybNy/ay2AYphvBxoZhGMMJhUJ4/PHHMWDAANjtduTl5WHt2rU4ceIEJEnCm2++icmTJ8PhcGDcuHE4evQoduzYgcsuuwyJiYn4/ve/j+rq6lbPWVJSgv3792PWrFkA5OhNXl4e7HY7cnJycO+990ZDKsMwUSZmpnszDBO7PPzww9iwYQOefvppTJo0CeXl5Th8+LB2/6OPPopnnnkGeXl5WLp0KRYuXIjk5GSsX78e8fHxuOGGG1BUVIQXX3xR+5m//e1vmDJlClJSUvDWW2/h6aefxhtvvIFLLrkEFRUV2LNnTzSkMgwTZdjYMAxjKI2NjVi/fj2ee+45LFmyBADQv39/TJo0CSdOnAAArFy5EjNnzgQA3HfffVi4cCG2bt2KiRMnAgBuv/12vPLKK62e991339XSUMXFxcjKysKMGTNgtVqRl5eH8ePHd41AhmG6FZyKYhjGUA4dOgSv14vp06ef9zEjR47Uvs/MzAQAjBgxotWxqqoq7XZDQwM+++wzzJ07FwBw/fXXw+PxID8/H4WFhXj77bcRCAT0lsIwTAzAxoZhGENxOBz/9jFWq1X7XpKkcx4LhULa7U2bNmHo0KHo06cPAKB37944cuQInn/+eTgcDixbtgxTpkyB3+/XSwbDMDECGxuGYQxl4MCBcDgc2Lp1q27P+e6772rRGhWHw4G5c+fi2Wefxaeffort27dj3759up2TYZjYgGtsGIYxlLi4ODz00EN48MEHYbPZMHHiRFRXV+PAgQMXTE+dj0AggE2bNuGjjz7Sjr3yyisIBoO4/PLLER8fj//6r/+Cw+HQIjoMw1w8sLFhGMZwfvGLX8BisaCoqAhlZWXIzs7GXXfd1aHn+uyzz5CYmIixY8dqx1JSUvDrX/8a999/P4LBIEaMGIH33nsP6enpeklgGCZGkIiIor0IhmGYtnLvvfciEAjghRdeiPZSGIbphnDEhmGYmGL48OEoKCiI9jIYhummcMSGYRiGYRhh4F1RDMMwDMMIAxsbhmEYhmGEgY0NwzAMwzDCwMaGYRiGYRhhYGPDMAzDMIwwsLFhGIZhGEYY2NgwDMMwDCMMbGwYhmEYhhEGNjYMwzAMwwjD/wezX4llQu2SHgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -499,15 +499,17 @@ "plt.plot(timestamp_pytmd, u_pytmd, label=\"pytmd\")\n", "plt.plot(timestamp_xr_obs, u_xr_obs, label=\"obs\")\n", "plt.xticks(rotation=45)\n", - "plt.xlabel(\"cm/s\")\n", + "plt.ylabel(\"cm/s\")\n", "plt.legend()\n", + "plt.title(\"tidal current N-S: pyTMD/Arc2kmTM vs. in-situ mooring data\")\n", "plt.show()\n", "\n", "plt.figure()\n", "plt.plot(timestamp_pytmd, v_pytmd, label=\"pytmd\")\n", "plt.plot(timestamp_xr_obs, v_xr_obs, label=\"obs\")\n", "plt.xticks(rotation=45)\n", - "plt.xlabel(\"cm/s\")\n", + "plt.ylabel(\"cm/s\")\n", + "plt.title(\"tidal current E-W: pyTMD/Arc2kmTM vs. in-situ mooring data\")\n", "plt.legend()\n", "plt.show()" ] diff --git a/notebooks/SimpleScriptGetTideElevationTimeseries.ipynb b/notebooks/SimpleScriptGetTideElevationTimeseries.ipynb index c6399d93..529c8ecf 100644 --- a/notebooks/SimpleScriptGetTideElevationTimeseries.ipynb +++ b/notebooks/SimpleScriptGetTideElevationTimeseries.ipynb @@ -813,7 +813,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -844,6 +844,9 @@ "# df_kartverket.loc[mask_kartverket].plot(x=\"utc_timestamp\", y=[\"observation_m\", \"kartverket_astronomical_tide_m\"], ax=ax)\n", "df_kartverket.loc[mask_kartverket].plot(x=\"utc_timestamp\", y=[\"kartverket_astronomical_tide_m\"], ax=ax)\n", "\n", + "plt.ylabel(\"astronomical tide elevation [m]\")\n", + "plt.title(\"Ny-Ålesund station: tide from Kartverkets long-term frequency vs. pyTMD/Arc2kmTM\")\n", + "\n", "plt.show()" ] },