{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access SOOP Tropical Research Vessel data in Parquet\n",
    "\n",
    "A jupyter notebook to show how to access and plot SOOP TRV data available as a [Parquet](https://parquet.apache.org) dataset on S3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_name = \"vessel_trv_realtime_qc\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install/Update packages and Load common functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: uv in /home/lbesnard/miniforge3/envs/AodnCloudOptimised/lib/python3.12/site-packages (0.2.31)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using Python 3.12.4 interpreter at: \u001B[36m/home/lbesnard/miniforge3/envs/AodnCloudOptimised/bin/python3\u001B[39m\n",
      "Creating virtualenv at: \u001B[36m.venv\u001B[39m\n",
      "Activate with: \u001B[32msource .venv/bin/activate\u001B[39m\n",
      "\u001B[2mAudited \u001B[1m127 packages\u001B[0m \u001B[2min 87ms\u001B[0m\u001B[0m\n"
     ]
    }
   ],
   "source": [
    "# only run once, then restart session if needed\n",
    "!pip install uv\n",
    "\n",
    "import os\n",
    "\n",
    "\n",
    "def is_colab():\n",
    "    try:\n",
    "        import google.colab\n",
    "        return True\n",
    "    except ImportError:\n",
    "        return False\n",
    "\n",
    "if is_colab():\n",
    "    os.system('uv pip install --system -r https://raw.githubusercontent.com/aodn/aodn_cloud_optimised/main/notebooks/requirements.txt')\n",
    "else:\n",
    "    os.system('uv venv')\n",
    "    os.system('uv pip install -r https://raw.githubusercontent.com/aodn/aodn_cloud_optimised/main/notebooks/requirements.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import os\n",
    "if not os.path.exists('parquet_queries.py'):\n",
    "  print('Downloading parquet_queries.py')\n",
    "  url = 'https://raw.githubusercontent.com/aodn/aodn_cloud_optimised/main/aodn_cloud_optimised/lib/ParquetDataQuery.py'\n",
    "  response = requests.get(url)\n",
    "  with open('parquet_queries.py', 'w') as f:\n",
    "      f.write(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from parquet_queries import create_time_filter, create_bbox_filter, query_unique_value, plot_spatial_extent, \\\n",
    "    get_temporal_extent, get_schema_metadata\n",
    "import pyarrow.parquet as pq\n",
    "import pyarrow.dataset as pds\n",
    "import pyarrow as pa\n",
    "import pandas as pd\n",
    "import pyarrow.compute as pc\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.collections import LineCollection\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Location of the parquet dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "BUCKET_OPTIMISED_DEFAULT=\"aodn-cloud-optimised\"\n",
    "dname = f\"s3://anonymous@{BUCKET_OPTIMISED_DEFAULT}/{dataset_name}.parquet/\"\n",
    "parquet_ds = pq.ParquetDataset(dname,partitioning='hive')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding the Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get partition keys\n",
    "Partitioning in Parquet involves organising data files based on the values of one or more columns, known as partition keys. When data is written to Parquet files with partitioning enabled, the files are physically stored in a directory structure that reflects the partition keys. This directory structure makes it easier to retrieve and process specific subsets of data based on the partition keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "platform_code: string\n",
      "timestamp: int32\n",
      "polygon: string\n"
     ]
    }
   ],
   "source": [
    "dataset = pds.dataset(dname, format=\"parquet\", partitioning=\"hive\")\n",
    "\n",
    "partition_keys = dataset.partitioning.schema\n",
    "print(partition_keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List unique partition values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['VMQ9273', 'VNCF']\n",
      "CPU times: user 7.9 ms, sys: 1.74 ms, total: 9.64 ms\n",
      "Wall time: 8.98 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "unique_partition_value = query_unique_value(parquet_ds, 'platform_code')\n",
    "print(list(unique_partition_value)[0:2])  # showing a subset only"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualise Spatial Extent of the dataset\n",
    "In this section, we're plotting the polygons where data exists. This helps then with creating a bounding box where there is data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_spatial_extent(parquet_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get Temporal Extent of the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similary to the spatial extent, we're retrieving the minimum and maximum timestamp partition values of the dataset. This is not necessarely accurately representative of the TIME values, as the timestamp partition can be yearly/monthly... but is here to give an idea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(datetime.datetime(2008, 9, 1, 10, 0), datetime.datetime(2022, 10, 1, 10, 0))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_temporal_extent(parquet_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read Metadata\n",
    "\n",
    "For all parquet dataset, we create a sidecar file in the root of the dataset named **_common_matadata**. This contains the variable attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'platform_code': {'type': 'string'},\n",
       " 'timestamp': {'type': 'int64'},\n",
       " 'polygon': {'type': 'string'},\n",
       " 'filename': {'type': 'string'},\n",
       " 'LATITUDE_quality_control': {'type': 'double',\n",
       "  'long_name': 'LATITUDE quality control',\n",
       "  'standard_name': 'latitude status_flag',\n",
       "  'quality_control_conventions': 'IMOS standard set using the IODE flags',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 9.0,\n",
       "  'flag_values': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],\n",
       "  'flag_meanings': 'no_qc_performed good_data probably_good_data bad_data_that_are_potentially_correctable bad_data value_changed not_used not_used interpolated_values missing_values'},\n",
       " 'LATITUDE': {'type': 'double',\n",
       "  'long_name': 'latitude',\n",
       "  'standard_name': 'latitude',\n",
       "  'units': 'degrees_north',\n",
       "  'axis': 'Y',\n",
       "  'valid_min': -90.0,\n",
       "  'valid_max': 90.0,\n",
       "  'reference_datum': 'geographical coordinates, WGS84 projection',\n",
       "  'ancillary_variables': 'LATITUDE_quality_control'},\n",
       " 'LONGITUDE_quality_control': {'type': 'double',\n",
       "  'long_name': 'LONGITUDE quality control',\n",
       "  'standard_name': 'longitude status_flag',\n",
       "  'quality_control_conventions': 'IMOS standard set using the IODE flags',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 9.0,\n",
       "  'flag_values': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],\n",
       "  'flag_meanings': 'no_qc_performed good_data probably_good_data bad_data_that_are_potentially_correctable bad_data value_changed not_used not_used interpolated_values missing_values'},\n",
       " 'LONGITUDE': {'type': 'double',\n",
       "  'long_name': 'longitude',\n",
       "  'standard_name': 'longitude',\n",
       "  'units': 'degrees_east',\n",
       "  'axis': 'X',\n",
       "  'valid_min': -180.0,\n",
       "  'valid_max': 180.0,\n",
       "  'reference_datum': 'geographical coordinates, WGS84 projection',\n",
       "  'ancillary_variables': 'LONGITUDE_quality_control'},\n",
       " 'DEPTH': {'type': 'double',\n",
       "  'long_name': 'depth',\n",
       "  'standard_name': 'depth',\n",
       "  'units': 'metres',\n",
       "  'positive': 'down',\n",
       "  'axis': 'Z',\n",
       "  'reference_datum': 'sea surface',\n",
       "  'valid_max': 30.0,\n",
       "  'valid_min': -10.0},\n",
       " 'CPHL': {'type': 'double',\n",
       "  'long_name': 'mass_concentration_of_inferred_chlorophyll_from_relative_fluorescence_units_in_sea_water_concentration_of_chlorophyll_in_sea_water',\n",
       "  'units': 'micrograms per Litre',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 3.0,\n",
       "  'ancillary_variables': 'CPHL_quality_control',\n",
       "  'sensor_depth': 1.9},\n",
       " 'CPHL_quality_control': {'type': 'double',\n",
       "  'long_name': 'mass_concentration_of_inferred_chlorophyll_from_relative_fluorescence_units_in_sea_waterconcentration_of_chlorophyll_in_sea_water status_flag',\n",
       "  'quality_control_conventions': 'IMOS standard set using the IODE flags',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 9.0,\n",
       "  'flag_values': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],\n",
       "  'flag_meanings': 'no_qc_performed good_data probably_good_data bad_data_that_are_potentially_correctable bad_data value_changed not_used not_used interpolated_values missing_values'},\n",
       " 'TURB': {'type': 'float',\n",
       "  'long_name': 'sea_water_turbidity',\n",
       "  'standard_name': 'sea_water_turbidity',\n",
       "  'units': '1',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 1000.0,\n",
       "  'ancillary_variables': 'TURB_quality_control',\n",
       "  'sensor_depth': 1.9},\n",
       " 'TURB_quality_control': {'type': 'float',\n",
       "  'long_name': 'sea_water_turbidity quality control',\n",
       "  'standard_name': 'sea_water_turbidity status_flag',\n",
       "  'quality_control_conventions': 'IMOS standard set using the IODE flags',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 9.0,\n",
       "  'flag_values': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],\n",
       "  'flag_meanings': 'no_qc_performed good_data probably_good_data bad_data_that_are_potentially_correctable bad_data value_changed not_used not_used interpolated_values missing_values'},\n",
       " 'TEMP': {'type': 'float',\n",
       "  'long_name': 'seawater_intake_temperature',\n",
       "  'standard_name': 'sea_water_temperature',\n",
       "  'units': 'Celsius',\n",
       "  'valid_min': 15.0,\n",
       "  'valid_max': 32.0,\n",
       "  'ancillary_variables': 'TEMP_quality_control',\n",
       "  'sensor_depth': 1.9},\n",
       " 'TEMP_quality_control': {'type': 'float',\n",
       "  'long_name': 'seawater_intake_temperature quality control',\n",
       "  'standard_name': 'sea_water_temperature status_flag',\n",
       "  'quality_control_conventions': 'IMOS standard set using the IODE flags',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 9.0,\n",
       "  'flag_values': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],\n",
       "  'flag_meanings': 'no_qc_performed good_data probably_good_data bad_data_that_are_potentially_correctable bad_data value_changed not_used not_used interpolated_values missing_values'},\n",
       " 'TIME': {'type': 'timestamp[ns]',\n",
       "  'long_name': 'time',\n",
       "  'standard_name': 'time',\n",
       "  'observation_type': 'measured',\n",
       "  'axis': 'T',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 9999999999.0},\n",
       " 'PSAL': {'type': 'float',\n",
       "  'long_name': 'sea_water_salinity',\n",
       "  'standard_name': 'sea_water_salinity',\n",
       "  'units': '1e-3',\n",
       "  'valid_min': 10.0,\n",
       "  'valid_max': 36.0,\n",
       "  'ancillary_variables': 'PSAL_quality_control',\n",
       "  'sensor_depth': 1.9},\n",
       " 'PSAL_quality_control': {'type': 'float',\n",
       "  'long_name': 'sea_water_salinity quality control',\n",
       "  'standard_name': 'sea_water_salinity status_flag',\n",
       "  'quality_control_conventions': 'IMOS standard set using the IODE flags',\n",
       "  'valid_min': 0.0,\n",
       "  'valid_max': 9.0,\n",
       "  'flag_values': [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],\n",
       "  'flag_meanings': 'no_qc_performed good_data probably_good_data bad_data_that_are_potentially_correctable bad_data value_changed not_used not_used interpolated_values missing_values'},\n",
       " 'dataset_metadata': {'metadata_uuid': '8af21108-c535-43bf-8dab-c1f45a26088c',\n",
       "  'title': 'FILL UP MANUALLY - CHECK DOCUMENTATION'}}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# parquet_meta = pa.parquet.read_schema(os.path.join(dname + '_common_metadata'))  # parquet metadata\n",
    "metadata = get_schema_metadata(dname)  # schema metadata\n",
    "metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Query and Plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a TIME and BoundingBox filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_time = create_time_filter(parquet_ds, date_start='2010-01-01 10:14:00', date_end='2010-03-01 07:50:00')\n",
    "filter_geo = create_bbox_filter(parquet_ds, lat_min=-23, lat_max=-20, lon_min=150, lon_max=155)\n",
    "\n",
    "\n",
    "filter = filter_geo & filter_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 800906 entries, 0 to 800905\n",
      "Data columns (total 18 columns):\n",
      " #   Column                     Non-Null Count   Dtype         \n",
      "---  ------                     --------------   -----         \n",
      " 0   filename                   800906 non-null  object        \n",
      " 1   LATITUDE_quality_control   800906 non-null  float64       \n",
      " 2   LATITUDE                   800906 non-null  float64       \n",
      " 3   LONGITUDE_quality_control  800906 non-null  float64       \n",
      " 4   LONGITUDE                  800906 non-null  float64       \n",
      " 5   DEPTH                      800906 non-null  float64       \n",
      " 6   CPHL                       211652 non-null  float64       \n",
      " 7   CPHL_quality_control       211652 non-null  float64       \n",
      " 8   TIME                       800906 non-null  datetime64[ns]\n",
      " 9   TURB                       210179 non-null  float32       \n",
      " 10  TURB_quality_control       210179 non-null  float32       \n",
      " 11  TEMP                       212770 non-null  float32       \n",
      " 12  TEMP_quality_control       212770 non-null  float32       \n",
      " 13  PSAL                       166305 non-null  float32       \n",
      " 14  PSAL_quality_control       166305 non-null  float32       \n",
      " 15  platform_code              800906 non-null  category      \n",
      " 16  timestamp                  800906 non-null  category      \n",
      " 17  polygon                    800906 non-null  category      \n",
      "dtypes: category(3), datetime64[ns](1), float32(6), float64(7), object(1)\n",
      "memory usage: 76.4+ MB\n",
      "CPU times: user 799 ms, sys: 319 ms, total: 1.12 s\n",
      "Wall time: 5.86 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# using pandas instead of pyarrow so that filters can directly be applied to the data, and not just the partition\n",
    "df = pd.read_parquet(dname, engine='pyarrow',filters=filter)\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='LONGITUDE', ylabel='LATITUDE'>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk8AAAGwCAYAAACw64E/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC7W0lEQVR4nOy9eZwdVZn//z6n6i69dzrppLOTEEjYwhIRQUUQZBEcQQcQGRBERCfoyDIjDCri/MboyLihE/Q7I+CMzIDjoDPMuESWiICyiRIggYSEhCSdvfe+91bVOb8/quouvaWX21vyvHldutZT51S6b33qeZ7zPMpaaxEEQRAEQRAGhR7vDgiCIAiCIEwmRDwJgiAIgiAMARFPgiAIgiAIQ0DEkyAIgiAIwhAQ8SQIgiAIgjAERDwJgiAIgiAMARFPgiAIgiAIQ8Ad7w4cCBhj2LZtGzU1NSilxrs7giAIwgTFWkt7ezuzZs1C69GzX2QyGXK5XFnaSiaTpNPpsrR1oCDiqQxs27aNuXPnjnc3BEEQhEnCli1bmDNnzqi0nclkmFlRTQtBWdprampi48aNIqCKEPFUBmpqaoDwj6G2tnaceyMIgiBMVNra2pg7d27+uTEa5HI5Wgj4NguoGGF0TjeGTzdvJJfLiXgqQsRTGYhddbW1tSKeBEEQhP0yFiEeVUpTqZwRtaEtIEXceiHiSRAEQRAOQLQGPUKNpi2Uyft3QCHiSRAEQRAOQEQ8jR6SqkAQBEEQBGEIiOVJEARBEA5AymZ5Enoh4kkQBEEQDkC0KoN4Kk9XDjjkvgiCIAiCIAwBsTwJgiAIwgGIuO1GDxFPgiAIgnAAIuJp9BC3nSAIgiAIwhCYFOJp06ZNXH311SxYsICKigoOPfRQbrvttl5FD//0pz/xzne+k3Q6zdy5c/mHf/iH/ba9efNmzjvvPCorK5k+fTp//dd/je/7ozUUQRAEQRgTtC7PR+jNpHDbrV27FmMM3/ve91i0aBFr1qzhmmuuobOzkzvuuAMI6wWdddZZnHnmmdx11128+OKLfPSjH6W+vp6Pf/zjfbYbBAHnnXceTU1NPPnkk2zfvp0rrriCRCLBl7/85bEcoiAIwqB4YstelOvgKEtD2sd1QFmNozwgR2DhkFopVC6AKoPbTonbrk+UtXZS3pqvfe1rrFy5ktdffx2AlStXcuutt9Lc3EwymQTg5ptv5qc//Slr167ts42f//znnH/++Wzbto0ZM2YAcNddd/HZz36WXbt25dvpSTabJZvN5tfjQo+tra1S204QhFHhlxt2UJNMgOuQVJYpFT5agesEOOTwbRWBcfCMCyjA4qosC+saxrvrQhFtbW3U1dWN6vMivsZ/1h9K1Qhr23XagD9v2SDPtx5MWoNca2srDQ2FL4WnnnqKU089tUTwnH322axbt459+/b12cZTTz3FMccckxdO8TltbW289NJL/V57xYoV1NXV5T9z58pbniAIo8O/v9zMrzbuoSKZoDKdRAN1aY3WGleDq0LhlPUTQEBC+yS1h6t9lNK81tIyziMQxgutyuC2G/36xZOSSSme1q9fz5133sm1116b39bc3FwigoD8enNzc5/tDOccgFtuuYXW1tb8Z8uWLcMahyAIQl9s2NDMv7+8nX9/uZmGSpeUq0hYyAQGR6nwoYgBFRBYF4uDqwMsCXyTJGeSeCaJb1K4WtHa1j3eQxLGAYl5Gj3G9bbcfPPNKKUG/PR0uW3dupVzzjmHiy66iGuuuWZc+p1KpaitrS35CIIgjJTVa7bywz9t5ZksgAqdb1bhaEWv+AobCihjE+R8g29cun1Np+fR5Xl0ex6eMeRMkj1GxNPBiIin0WNcA8ZvvPFGrrzyygGPWbhwYX5527ZtnH766Zxyyil8//vfLzmuqamJHTt2lGyL15uamvpsu6mpiaeffnpI5wiCIJSb59bt5MWMF8YwFT2tlAp9JhYwCiodTSYIMFZhNRjC/RpLu2dIOpaGlI9SFt9qujxFtxdAou/4TUEQhse4iqfGxkYaGxsHdezWrVs5/fTTWbZsGXfffTe6hxw++eSTufXWW/E8j0QiAcCqVatYvHgxU6ZM6bPNk08+mb//+79n586dTJ8+PX9ObW0tRx555AhGJgiCsH+2bt3J460BGc8AoLVC9QgyUUAusNSnHDozObTrgDFYHYB10SqLTxX1yRbqUztJOR4AnnGpcKbQlmvAM6mxHpowAYg9OCNtQ+jNpDDIbd26ldNOO4158+Zxxx13sGvXLpqbm0vikj784Q+TTCa5+uqreemll7j//vv51re+xQ033JA/5sEHH2TJkiX59bPOOosjjzySyy+/nD/+8Y/88pe/5HOf+xzLly8nlZIvG0EQRgff9/nhn7bxRLtFqfBrWBX9P8ZaixcEeIGl0wuoSbv4fsCurMIPUngGrDV0eS2k7D62dy1hU9sxbGpfyo6uw0iondQmd5ANgjEfozD+iNtu9JgUeZ5WrVrF+vXrWb9+PXPmzCnZF2daqKur41e/+hXLly9n2bJlTJs2jS984QslOZ5aW1tZt25dft1xHB566CE++clPcvLJJ1NVVcVHPvIRvvSlL43NwARBOOj4wR/exNGKdNJFKUWvbDHWQpG7riNnqEsrujyNZ3ySjiKlLTu6IPwKr2FGxTbe6D6Exoowt4/nw56Mojt3DLOq11DpzEAQhPIxafM8TSTGIm+HIAiTm39+ZjPKUbiORilFOumglMIYS3fORxG57ZTC1QXxBAV7VMIBa+D8BfWk0+l823/a1Ybfw5GQVIaMZ6lJKZKqiwVTJI5zIjCWeZ5+PmsRVXqEeZ5MwLnb1svzrQeTwvIkCIIwWfnukxtxHIXrOji6dwyK1gqtFMZajLE4GnxDeGx0TCyiPri4twB6fnsLyaRLrRs+JBWQ9Q0Zo0m6hn1ZS2Ni9MYnTFzK4XYTr13fiHgSBEEYBb7/9Ca6c4aEq3EcjVKlwbdF3jmSribjBVggMDbcbm2ohAz8xdJZ/V4nlUqgAUUAKHJB2G6Vq+j0NQkCDp0mVidBKCcingRBEMrInU9uBMAYm8/QXJxyIJZPxhiUCl14jqOpUIqcFxBYi7UWY+HKY2cPeK2X93aS0hatPTRh6gLXSaIJyAWahAInIbOlDlbE8jR6iHgSBEEYIXv37uVHa1vz645WkXjqPXvOEoopL7CgDE70dFMKUkkHpeCixYML8E7pLNpxMUGCANCOwcXDWIWjLQ6KfVm/XMMUJhkinkYPEU+CIAjD5PvPvEEmF6YBcByFMQVXXIwlnhUcCqooM0EooHyLRyGNwBUDuOd6sqltH63ZBF5gwPgFk5ajmV4ZWq6UVpw0UwoDC0K5EfEkCIIwBH783GZaLLiuzgunMOUA+eWYILAoJ0xHEB8TxzRpFZ5grOUjS2fhOEObFbW3W9GS86lyoaFaAYrAGLZ1BuzscphWkaMjJ5HiBzOqDJYncfr2jYgnQRCEQfDDP20jk/XRGhIJh0zkDus5e85GkeA6ct1Za/EDcKzJu/GshcAa3jvTZfbsOb2uNRhac5ZZVdDuubR74CgwVlOThJyXQ6M4trFmZIMWJjValcFtJ8mM+kTEkyAIQj+0t7fzs01toDR+YEKLke77XTxOeBnPoovFkx9YlLJYVFigDkujVlz81kNG1LdqFzo8l4Sy2JyhnTA+pcLVOIkEXiCxTgc7ZYl5EvHUJyKeBEEQ+uAHf3iTZMLBcRw83xBE4qm/Wl+KwlMmdtMlXI0FfN/g+xYHy3XvWNjn+UPF0Q7GGLpyOXZ4MC3tkAkMO7stDSkHGFlyREEQ+kfEkyAIQhF79uzhZ5u7cbSi2MhUnJcJyO+LhVIQJbYMTGh9Ki7eUOVqPva2Q8raTwu0dOaorkoyOwlaWyoTDtVJ8IFsVGxYOHjRCvoxlA6pDaE3Ip4EQZi0/GbjHtqtIT+FDThvwdRht/enV5p5NhO6u1yndyZwG2cBdxTJpIuxkPOCvFAKIr2iVShultZoTj16/rD7MxDGWCork6Q1pJMOOc/iA2kHEi40d+RG5brC5EHcdqOHiCdBECYlP31tJwnXyQsnDaDgl5v2YCwcmYL5swYvpF58ZQcvlTwoCuJJa4XranK5IC+gtFakU+FXqOebKN4pnEm3/OTyuOYGwjcBaVejlUNrt0eYXTwcQCrQVGj5eheE0UL+ugRBmHQ88PIaqipm5te1glSYyju/bb1v2fDGHt49f/8C6v5XdmCtJekqurPhNmMMWkdlVQCtQgHl+wZrDdaqfGLLZMLhsiMbSaVS5R5qv8xRmo6ES0cuoMOzWCy1SYWykPEDMuK1O+gRy9PoIeJJEIRJRzpVyMCto0/WWCgK2naUwt3Pk+PxV5rZWvxwKFr2A0tSh7FL8Qw7rR1cJ5x5Z4xlQQrefdTwUg2MlLmz6nlmWwttniGJYWunR864uFE+qZaMx6o39vKe+ZMzSeZjb67jmGk+hlC8pp35VCeqx7tbkwoRT6OHiCdBECYNGzbu4rdtOaZWJwsbFRjCuWVahaLJWItnLb6BR7bs5d1zewuIB9buCLNwx3XnrMULLFVpTWfGYAnjmRIJjYqCxeMKdR89fnwEU088Y1HA7ozPlMokWkHCcQDLFKXwg2B/TUwo9u3bx3NtlmOnbeewKSlyxuBqn2yQId35IF2ED63k1MvHu6vCQY6IJ0EQJjz79u3jsT0+uVxATYWbF0sxjgpntDWmffZmE3gWqrF0eB7Y0q+5R9ftYDdhwHUxKhJdCe2Qcg1Zn0hAFfxflxw+haqqqlEb51BRQHt3lsp0krTr0FTpY4hcjdayq0vx6GvbOf2wmftta7zYt6+FF7sgFxg0MLOmlRwpkiqDdpKAT42bpCP9DhK6k7Tbier6b9zu2aipy8a7+xMarVW/eckG3YaV6XZ9IeJJEIQJzYOv7QSlcBT4xpJQCs+04+haQKEJhVOlguZMggpXgw2FT5XjkPOy+bb+/eXtuI6OrE22V84mBeQCi+u6VKY1Od/HWktgFJcdPfi6c2PFyXOm8LPXmkm5DtMqDDmbpDubo8Oz1LmKKRUOuQnod+nu7ubxHV0kHYXrOExxW6ir1STdAEd5eH4FnaYRZVw07aSdTlJuB1hNV64Wkg5abcVBxNNAKEehnJGJHyUFWvpExJMgCBMSz/N4aNO+KEVAwb3mB5YgqMDF4LqhEJqR9tmWSZB0NN2+ocSopBL825rtOPns4P0/DJQKHxXWWjKeATQKuOzoplEc6chIuw4zKn3a2gx/2NkGhA88GwVwHTe9cjy7V8LDr++iqcqjrlpz9HQFZFForNV0elPpDhQp3UFlopOk2kmHNxWjasgGCq3B1R34wTQCa/AT9eg9/4oSF54wDoh4EgRhwrFhw06e9yHR461ZKcjkAmoqE3RlA5LsIp1oylucOiMXmxcY/Cj3UkuXVzi5h3CKE1z2JBZRAJccMaPX/olEJutjgjR/2NnB9LpKlLbUJ12ygaE9F/DCzi7m1O5jTsOUcenfj57ZxGlLNIF1WdCQRmtFt5ekItEBpKNEjllqkzvp8KaTNdU4QUDKcahw2ukOUgQqje93o9wkle4+AutgSIGTHpcxTRaUVqgRuu2UuO36ZIRx+IIgCOXlJ6/t5AUTZUcu2m6txVEKR2s6uzzSSQetGsmZAANEKY7IRcKppcujpcsjiIKqKWkLHEfn26XHdQDeUjPxhRPA+5fM5A9vtDKtNk1DVZJqpWjL+XjGUKMVh0+v5jfrW8e0T79/dTMbW/exsa2Vty1uJMcUtM5Rn95NQmdIkKPLq0URYKzGkMCQosINLWe5oAowJJ1uIIBoP2i0suRFsJlcAfFjjlJ5ATXcD/2UIzrYEcuTIAgTgp+8trPXtniaOoQxTOmUQ3c2IEDT3u2hgG4NValw9p2xln1dHqaHICr++i+2NjmOJghMiYBSanKIpmI6DMypTqOtz7S6ShI6rLSngJwJ2JdOjHofjDG82tIJaKZMa0A7WVzlociSC5Lk7Ayst5eqRCdekKZCZ8gFlVS4HVgSOGRQKkBRh7HhjMHYAQkWRQAYAuOACtBkIHH2qI9rMlOWmCexPPWJiCdBEMadPoWTDS1PjlIE1ubXq1IOGc8QmIJASCsPQ4o9sYuuZ1uEs/OMtWgUqsh6EVqgwvWLFk8fjeGNOlNrUnRns8ypr8IawPpUJ8NYMT+nOHRmzahde2vLekhUAd3MrtxDgMPuzHy6vTQJZUknukk6HtnAwWcKAd1UJtvp9uoIjIsmLCuDsiV5thRh/8N/MQ9HZ3FUjm6/nqrELnTnLlTd+LgiBUHcdoIgjBue5/GTV3sLpxhrLb6x+QKnBvAtuK4mlXS49MgmPnRkE2+d1Ugu8HqlH4CiwqaRdclYizFhqoK41ArGTlrhBOBqmFFbhTEWg2V7h8/LezzW7vVo78yVpHUoB09u2Mbjb+7l92/upTVooi1XR6c3nX3eQrKmmllVr5JQWTyj8G0CS4Crc1irCEwSrQzWFh4/CgtWE+BiAVdnsCgyfi1KaRKqC60zZLxKKhM7qGxfS6Luz8s8qgOPkbrshhMztXLlSpYuXUptbS21tbWcfPLJ/PznP8/vz2QyLF++nKlTp1JdXc0HP/hBduzYMWCb1lq+8IUvMHPmTCoqKjjzzDN57bXXhnVPyoVYngRBGFOy2Sz/vSmMwVEDhFRoHRba1cqCDgO4NaHoufDw3kLn1NlTub+t8CUcJiOIZulZS2BBW4vSquDWs5ZLj5y4OZAGy1EpRVYrOrty7PMtOVPITbUXaOvwsLSytLFu2Nd4ZuN2SKVIKkX9lDqssSRcgx9kae9W1FakyQRJFFPJ6Ax1yV3szc3B913chBvFKoUOOKxCKw9lFTkb7gtw6PJqAUPabccGATk7lYTaSYX2mJI6CuLqN1PfOvybdRAxHm67OXPm8JWvfIXDDjsMay333nsv73//+/nDH/7AUUcdxfXXX8///u//8uMf/5i6ujquu+46PvCBD/DEE0/02+Y//MM/8O1vf5t7772XBQsW8PnPf56zzz6bl19+mXR6fCYNKNszWlIYMm1tbdTV1dHa2kptbe14d0cQJhxPvb6TN3t41AYSTsWYHjXaBrIQ3f9KKJ56xjwBBH1Ypf7i6MkvnGJe3N3B663dWAtHTw3wgiRaWdpyPls7NUlH894Fgy+UDPDm1m28lEviKkWn5wMwq9JhU4dhQY1LOhVmNbc2i++7JJMJUq5P2tnHlOR2NncsRVlLZbIbrCFraqhKbCXrVZMzSSoS3VhcXJWjM1eNj2FKqp3pFYeMwh2aGIzF8yK+xh/fcRQ17sjsju1+wLG/fYktW7aU9DeVSg26lmNDQwNf+9rX+PM//3MaGxu57777+PM/Dy2Ha9eu5YgjjuCpp57ibW97W69zrbXMmjWLG2+8kZtuugmA1tZWZsyYwT333MOHPvShEY1vuIjlSRCEUeFX63fSbiNv2Qhe0Yprc33wsMG51rRSvQSUU+R+uPTIiZu3abgEFiq1h9VpWnMpKt2wxExV0qE+Z2j1Bzczbd++fWzxLKlEEqeyhrlpS3vWpzqRoMvA5k6PmZUur7f7LHEdrHaoTmo2dQbMTCbCvE0kCZ2skeUQH8+kUSoDFnLWJZXIoJXDzMooOD+fjmpoAk/on7JkGI/Onzt3bsn22267jS9+8YsDnhsEAT/+8Y/p7Ozk5JNP5rnnnsPzPM4888z8MUuWLGHevHn9iqeNGzfS3Nxcck5dXR0nnXQSTz31lIgnQRAmN5lMhv/d3BaGYauCXurPtj3UGdCDE04+8ddaXwIK08qlRy8e2oUnCRUalE4zs9pFGYNCE0Y7BTRUa6YFZsDzn3z9FRY1JnASXcxKJ8kEmubOGaQdh8aqBB05C14A6QS7Mx7zah12dGaZXV+FbxJ4Nls0q9Gj26/CWoubyGCNJkDh+LuYUXMYk2su4+SlLHmeovP7sjz1x4svvsjJJ59MJpOhurqaBx98kCOPPJIXXniBZDJJfX19yfEzZsygubm5z7bi7TNmlP7WDHTOWCDiSRCEYbFz714e3xO6cowJxZATiaZi4aTo2/Bk7eAE1GCtTQCXHDE777qDUECV7D9AhRNAR2s39ZUplDEYnSDttFGb6KDLn0rGS2J1mjW7mzl6WsHq9vC6rRw+J0wLcEhTBZ5JkFMOrtFUqb0sqN3ExvZD0IFL2g3oyAZUJlz2dUHSUbTnCmkgVJRMwOKR1rvZk5mHsjk62z2OnBm7R4cfcyWML3EA+GBYvHgxL7zwAq2trfznf/4nH/nIR1i9evUo93BsEfEkCMKg6SulQGzcCRN4q/5NTUNkDnDSEIRTzCVHzOD+V7ZTPJnYcRR/3keQ+YFEdaUhSBhcpUF1knB99nTPpN0LyPhhslBLktdbt3J8owsKFs6qxhgfpRxc20ZWVZDSWbKBA6qBCr2Pmeld7OqeTiqtqE2l8IyhIungBSqcAWlB6xxTE6AJSOp97OyYxpJp08b7lhz0jFeep2QyyaJFiwBYtmwZzzzzDN/61re45JJLyOVytLS0lFifduzYQVNT3670ePuOHTuYOXNmyTnHHXfckPtWLkQ8CYIwID9et3PA4O7YgtTfV2x/UqpYY8Vtx20NxdrUF5ccceAEgg+WxU0zWLenhax1aKpsZU/3LNo9ny4vgFw3vpsGDAknxUt7FTP0PhZOb6bdm4FnXTKqkQp2kTENJHUOR/tkcjVUJjrxu8FaB8cxeAYyfgAWZlU5YCzbOi1TqxOk27Yye/4SqBrvuyEAKKVRemQZiZQa+cuQMYZsNsuyZctIJBI8/PDDfPCDHwRg3bp1bN68mZNPPrnPcxcsWEBTUxMPP/xwXiy1tbXx+9//nk9+8pMj7ttwEfEkCEIJe/bs4bG9QX6W22C+e/sSVnFeJmvJWyh6UpQxABh4Jp2wf9a3+TgEbG9vAJVFA761WDcdpnpQmljm7rJT2LWjniMrt+KkZwOWjJ2GqzrRyuAbF0MayAGgVEBLxicXgKvgzU7D4VMqeXNPO2ctjsTqFJltfLBzyy23cO655zJv3jza29u57777eOyxx/jlL39JXV0dV199NTfccAMNDQ3U1tbyqU99ipNPPrkkWHzJkiWsWLGCCy+8EKUUn/nMZ/j//r//j8MOOyyfqmDWrFlccMEF4zZOEU+CIPDg+l354OpiHTTYl9ae8UvFYklFy/159GYDp4hoGjH/u3EPSa1QSoWutCJrHpTGf2kApbBW8XLXbI6uyJC19TgqIO124JnQdKTwQHkkAN9YTBCwNxOQBD4QWQePnlY9ZmMUhkZZ3HZmaOfv3LmTK664gu3bt1NXV8fSpUv55S9/yXve8x4AvvGNb6C15oMf/CDZbJazzz6bf/qnfyppY926dbS2Fuox/s3f/A2dnZ18/OMfp6WlhXe84x384he/GLccTyB5nsqC5HkSJhuPb9jF7qK//GLhZGFIVicbpSPQOjxfKRXVj4tEU9Rm/E3ToODdI3TLCaX878Y9JFQ4rTy+50qFua0MoVhSSkWiqff5xnoc1lCDo3JUJ3YQmCQWg0s7b7TPpdJNsrsjw9vnNY7puA5ExjLP09pzT6AmMcI8T17Akp8/L8+3HojlSRAOAtrb2/lVczdA0QO0PAU/Y4uSMaGAstbmrR7xFeYpOFEE06gRi6X8zLfY6lS0v3jBVaGFKogUrUMCosK7nX49yga4NsOOzBSmJ1PMrq9mccPo1ccTRodypioQShHxJAgHKPmaccXuNBgwP0BsNRoqoWgqygau4D1NaXlTHVN6/7tqiNIHkK9vl9AKP6rrFxsWA+D1fR5HNuwC0mhrmVGzkCbRS4LQJyKeBOEA4bfrdrK9aL2nyy00Ng38FhkLJ60jIWQZtIHq/QumkEgkBtlboZzEVeNs9I8Vx6BprfKuO0eFYso3loQCx9H5c42FwBhe3tvIGfMaxmcQQtlRDmWIeSpTZw4wRDwJwiRl167d/LbV4ge9LUWxcCpOUKmU6jdhZcm5RZm5jaVXnEz8YH5rDcxtElfcRCGwoXUpDtaP/8k00axHY0kmNKiCaCI6XgFKa7z9ZCEXJhflLM8ilCLiSRAmET9bvysMAI4ekH0VwC02LvXc259wygd1A9jQfhELsLwFCjhzeoIpU6YMfwBFNO/7PanKWsBijceOzAKOkKnuw+K8BVP53417UMSuuELguKMUU9NuyS+GsaHoNpCfmacAVx6UgjAoRDwJwgTmkfW7aCV0p4V5elS+BIqxthBj1A/FlqZwBlzf1icVRX33rOGrFXywzGkE2r09tHtt2OQiOv2wqIdWGaZXbmPdvhdBncBUBdPqKsp63QOdUEBtAlsDWJrSAclkJdYLyBpDUimyJoN2K9FKkXAgF9i8206hhlxvUJjYSMD46CHiSRAmEC0tLTy62yvZFschKRU+3OKH3WCwPZcjn1upgAoDm2Jh9dZqmN00elPS92Z9oAaNjf5LgU1hrEtjZcCOLo89JNjT0kXS8VlQI9aowXLegkMAeH7HbrRJ0Z71cbQCpckA6DQ5L0cykUQphaPDGCjhwGQ88jwdLIh4mgA0t3WxqcvHNzaqP1VAK5jlwqIZ9ePVPWGU+en6XYOKQxqsVWCggruxgMrHgStFjVKceejY5O95o2M34ddOGhP1SJFDYfBtFTnTRUptxONwQBEYl43tbSiSAMyvToVWMqFPMpkML7bkqHQSOAmLnwOfML9TwtF4xpJOJMkEhqSj6ZnGK9ifKVMQBEDE07izra2LzZFwit8A45wtxoZvhZtzsHnLvl7naqWYkxBhNdnoy7rUH/2lDcgHA2v6dN0ZE2WY7kNnWOB98+tJJpOD6kN5SRJ+7cTjcrCksWQBj8BUMSXRwW4vCnKmqPisUrzRkcVaS5eX5aip9ePQ/4lLNptlU1eGuhQkHIPFYYqrAcuerhxekCTlaLLGUpPQZE0Py6Q1nDZXZtodSChVBredvKz0iYincWZzl4+1tiTDcyyc+gwGpvSXeXPO9imsAJbVaurq6kaj28IQeXD9ziKL0OC/jPrKu6SVwmDRqD5/R2JMUQDTW2pgwazxnRn3RkcLoCNLU0jYRQ2kcFUXgXXZ7feMyYqdjCr/u1+dTPHq3k4Ob5AKtDEvt3ZTnYSE9glIkfE1DpaE6zC1MkEuCO+2n7PEk+qC2GVnLe+YXZ6JAMIEogxuO0Z6/gGKiKdxJH7wFZeuGEjk6x47+3pw2qI2n2kNsC178+uxMItZWquZXl8/vM4LA/Lcxp28HtZTLSlbMlxs/D9F/pdFx0JM23yJlJgq4L0TsF5cgvboTVihMAQGAqqw+PjWRdGGbxew35dlpUglNC/tbeOoBomJAqhOOLjaw5Ai62uSyqIdh1xg8YzBGEuFm6OpshtjFds6KzEo3jFLXrAEYaiIeJokDOWxW5hdFZ2r+j7/T20G2vYO2FYaOKbOEQvWfshkMvzPG229tmvdW/QOBxubrYqSVoaz7wrtv3+M4paGi6ILnxoocTNmSahOPFuFxaXT24dWhXFopdBYTD9/AZqR1e06kDAoHAwe4a9JQThZrAmoSHQBNXQEKUBTX5GjOtEOyN/2gYrSGjXY6t4DtCH0ZlKIp02bNvF3f/d3PPLIIzQ3NzNr1iz+4i/+gltvvbUkbuNPf/oTy5cv55lnnqGxsZFPfepT/M3f/M2AbfdlDfj3f/93PvShD5V9HD0px0O1GGtLg80t7PcNfn9JEzOEFixa+xdZrlZopVhSCdOn1A+6v5OdX2zYRZbQ9VGcWzCu9dafaB0qsesu/+8btf22GsXMGRNbMMVs7tgK1GB7iB1FCs9aIIvxfbQ6PL9PK3CUh2/7uY9lur8HCnGVulBSRhZoa0OLU6KD6oQlsF0AuDoM0m/LTWVb51ZmVc0er24Lo4ikKhg9JoV4Wrt2LcYYvve977Fo0SLWrFnDNddcQ2dnJ3fccQcQVpE+66yzOPPMM7nrrrt48cUX+ehHP0p9fT0f//jHB2z/7rvv5pxzzsmv14+hK2telcsbHV7+gTvQTKm+GEj87NfzwQhqmQGODmNQjDG0e4ZnckDLnhJ3Yk/XolYq+kAtsHRqkpqayVFAa8u2XTwbPnvyotTYPhJRDvHfcDAopZgCnLZocoilnlhqgAwuHqgEYDDWYKhGkcalnW7CvE4KcLTF1X6UkiGZf8kp+V21EBCM8UgmLsr4GB2AsnnhHoc0VbgaG3gofBzVTWBqsChqk3toy0nc2IGKdhR6hDFLIz3/QGVSiKdzzjmnRNwsXLiQdevWsXLlyrx4+tGPfkQul+MHP/gByWSSo446ihdeeIGvf/3r+xVP9fX1NDU1jeoY+mNWTSWKTjZ2+HhBkWWhx3H5zM89nsr9yZ7B6CGlBg447o9QOOm8QOj0+xZLxUHw8VR7XWQu2Gssj+3Kondle5V9L37ZWVQJh02fOuR+DpeNu3bx/L7Sf4Q4XmwwiQTLKZwuOHTaATLbpQNXJfFNJdgEEKC1h0sXvq0GCxUugEdgExirMSYR5bYqFU4qivvyjZV4pyIWT61nfcselLL4VuW/3LXyyHrVoBWeb/FtDUlHUZ3ch2fS0CthgSAI+2NSiKe+aG1tpaGhMK32qaee4tRTTy1x45199tl89atfZd++fQOWlFi+fDkf+9jHWLhwIZ/4xCe46qqrBnxgZbNZstlsfr2trXesy1CYWVPFzMj4YozhD9vaaCcsqxAUiZH+BFRfxJas0aA455DnFd78bT/CKX4AFgsi39heQdRxDI/NtxH+fKXd8HL7rugaA7sZtYKkUlQDvrV0WcgU30Pb86fNrysVf1Sh7/RY73Hr+7PaFYcoDfbfDGAesGySWpcGxCbxrYOjMjiqi8AqApPGkATVRhZQ1kGrAEd5WOti0FhjsYGH67pREs/wF8ALLFlJ7tiLRfVTea1lN4oUEJDWnVS6AagsHkkclcJa6PAsKldPRSJLpdMJ1I9zz4XRQNx2o8ekFE/r16/nzjvvzFudAJqbm1mwYEHJcTNmzMjv6088felLX+Ld7343lZWV/OpXv+Iv//Iv6ejo4NOf/nS/11+xYgW33357GUbSG601y+bU97t/TfM+dvth1LDuYTkqLrERM2DCxOGqq2IRVNxeX4dGWauLuxA/84oFRVxbS/cQjMaYXmKqL+LzAXLWsruPVA99CSelwpxIsWiKBVQ8zP2Jnr7cniWepaIZcsUWlOKUBRceiGKpiHUt26hwQmslaAyh1dJVHsYGWJJ4fiWOo7BWh/fHwsL6dEk7f9qzFfBwVIqjGmaOy1gmOnvbO1EqScqJ/l50LZ0GXJ0lqbtJuN3k/FqqE5pOz1KTaCcbpMa728IoUZYM4+K265NxFU8333wzX/3qVwc85pVXXmHJkiX59a1bt3LOOedw0UUXcc0114y4D5///Ofzy8cffzydnZ187WtfG1A83XLLLdxwww359ba2NubOnTvivgyGo5v6FoHt7e080+KXCKj9xVGFAeXDcN31mPE1HFQfywrywikWSn3lO+4Z55WvCj9A/FZP4VS8vcTaNMR4s4HoeU2twoWj04rF8w5swVRMEhdHWwwJFN2hddFGViTlYo0mYwwEgFIsndp3DM7SqRLU3JO9bV3sswFaWYwxZI2LwiHlGBxlwfoEOPgmBSjSThdJp5NMEJq6XWuo1OL6FIShMq7i6cYbb+TKK68c8JiFCxfml7dt28bpp5/OKaecwve///2S45qamtixY0fJtnh9KPFMJ510En/3d39HNpsller7jSyVSvW7b7yoqanh3f3EXfu+zwvb2mjpY99wYp6MtSirIuuBimZLjS95qw4DJBjtw5U5kGWuP6tTLN7i2YzW9p/pGyCh4YLDJl7OpbFCax9DGujG2BqsLXL1ApoujElyXGP1uPVxMrGptZNCfnqDFygUGq1cKlxDzgRkAoe0Y1HK4FhDgENgkgTKQ+tcWK4F8JTD9BoJGD9QEbfd6DGu4qmxsZHGxsG9gW/dupXTTz+dZcuWcffdd6N75J44+eSTufXWW/E8j0QiAcCqVatYvHjxgPFOPXnhhReYMmXKhBNHI8F1Xd4yb+CyC57n8dLOdvYEA8cUQWQNMgZHK1xXQy58GBZbsfICI1InRcYqoMR41Wvf/lBR40M9b6jYHrFKJYkqi3C0CqvS64LL9NzZ1VRWVo5i7yYPrlYouvFtDYoArWLxFJYOsaREOA1ANptlc6agzLVy8iHexmoSjsUPDAbwjSbtGDqNJbCahLYEsQUUsLgofFDgAVP0wSvqDwrCfB8jb0PoxaSIedq6dSunnXYa8+fP54477mDXrl35fbFV6cMf/jC33347V199NZ/97GdZs2YN3/rWt/jGN76RP/bBBx/klltuYe3atQD8z//8Dzt27OBtb3sb6XSaVatW8eUvf5mbbrppbAc4AUgkEhw3e3B1rbbt3cvLHWCMxcFSnXDo9IISN2A+NxFAXH5GF9IUGFsqTqwFq8LH6f5Kk+4vaHyg83qidamrr9gS1Vewd15ARcShSzMUnLJIHkR9YjS+douEk0M0kZ4wds+ytWM3GQOH1k4b375OALLZLG9mTL9/B8YWJluEf2/gOhovsATWYrRDUnv4JkHCUYQO0lLVbyykdAeVleMzy1gQJjuTQjytWrWK9evXs379eubMmVOyL37w1dXV8atf/Yrly5ezbNkypk2bxhe+8IWSNAWtra2sW7cuv55IJPjud7/L9ddfj7WWRYsW8fWvf70ssVQHMrMaGpg1hPqhu1tbWbPHoz00RaGUwtUK34SJHzWhcIqLvwJ5gdUzvoke64V47ILIiQPPS4Pp+5t9aKPtseArHJ+/Vs8T1cER6F0ucgocUmjlE8rjUDgpZVBYFAFGWdLKZWtnmIzVM1kOqTk4gsI3t2UoLRMdKnhNabmlHkfkpVA4KxfCiofhHXVUYTKHjZyjAAoPS4DNWRZPE+F0oCNuu9FD2WFPuRJi2traqKuro7W1ldpaCb4cLp7n8Ydtbewp+o00FvyiYKL+ZtwVB40ba/uMe+oraLw4VQEUzbSLRVzkH6lT8M65dQeUO3cs2dzRhqNyhO9rsXAKH+YGsDa8r0qF/9a5ACwprFVYs5dD6+eNV9fLiu/7vNHplViVBlNpoGf1ACidDWqsxZgAYxUpF3zjY22CpBNuMzg4yiPtdOKbKubVyPfUeDEWz4v4Gts/fQa1qZHZSNqyPjO//bA833owKSxPwsFBIpHgrfMHnwzzxW27WB9l/I6tVCpKAxAXze1pfcovR+dM14rjZ6Skdt8ok8m1U1UkPMN/igAUWJMO7SUqTEuRDSrwjcY3oVUS1ci6lm6wBtQeFk8iIbWjYx854ozf4e9i0nUIjMI3YU46Y21ZSjUFNrbrGXzjktIBgbWEdzFH2uliVtXBYc0ThNFGxJMwaTlmViPHjHcnhEFxeMNstrTvpnieRyhgI8dsZHHKBqm8cHKiiQYmjpkDlJ3Kun2dYQO2ncUNE8f1tKW9FT+KMCoke1WAg7YGg8VRFkf5oDWaHDmTjO5DYbx9MVAajuguAQpXQ9Y3JLTFKpibLp4ZLC8IBx1ajTzgW9x2fSLiSRCEMWFuzbR8TFMhZieOxYnFhou14KpQDhQLJ1eHjr5w3ZB2HTZ3bEORwlofVwfMqpo1JmPZ1bmPHJ1o5eOwk6Ttpiqogooa6PZodbrQanE+9s7goAki97DGUYZAaxwCAuPk70lMz1i/voRT7LILrMULLEkdsKheBJJQQDkjT3KpnP0fczAi4kkQhDFjVuUUtnW1hKkmFISZMQtfQ9aGYsDpUc+uWDgpAmqSHQS2CldBt+eQM2kSGl7ZF/pxQ4G1k6aqFnJBIwn2UZNoJ1AaQwqsSxhKHU8ScLF9TE8IY7AMruogqXME1sUGLlMT+8BxMSoRbqMClfbQNNNZMZ0pNGByzXQwM++iNCg0ChVmAw0nNhDg0/vpNLhAVItj4dA6SYkh9INYnkYNEU+CIIwZSilmV01hY8teUgnQyhBQVMamB8UiIrZAVSW6CWwFCZWly0uSNS5JR+GZwjHWQkJNpy0zg4wBY6fQ3N3OoTWbcHU3RlWEZWKI5/75hKV0dZGVx2KtRimFb2vBdJLS3fiOIhs0kDb7cJwwWaxvFZYkBqhO7KTDn4lOOlSb1+g0i7A2dN9ZTK9UYX3NKC25Bz2CxWc6iurqdL/HC4Iw+oh4EgRhzFlQH+a62Ny+G1dlsSqFsgalAnSffoJQYigsrvLwbQIfRc64VLiQCUqFU2VC4xno9A0Nqd2kE2Eh76ytC8OrrI5KGOVwdBhSbawBHJSKRVPsZguv7ds0rs3iKA8cjW8dXBOAo9E2IIhTBVhw6CZQVaDrwBTLo6KcYoDpw+pUOCA8dlYCKisrhnmnhYMapwxJMqW2XZ+IeBIEYdyYV1NIirmlfSdJlSFQlXgmnMJfkB2F8GulLMoajHUjARJmKteEM87SbhhH5RvD1NReUolcWI5YWSwOYCCfKsHNl9UxQC4Ik72mnfhqNqzDp0Inm7EOOgpuD0wVCd2ez1OmbCjvFIqk7qbbxGVP4mI+AcTOQRsGdQXGySeXhTACbEGtWJWE8qBUGfI8lWEm6IGIiCdBECYEc2sKGdpfa92Cb6YWMtVHfj2DwkZWo14ohbIWR0E2sFgbUJHsxlgVWpPyRU1sPjM8hAae7iAB1GCsAwR0+zm0yuEQlpKxypDs9QZemsCy2KZkbGFaYTijEHSUjgEMfuDi2RT1wLQ6sSoJwmRDxJMgCBOOw+rm5pdf2bedwNZEM/AUuSCB0gmUyqFI0DvIO/yZdkKrkc6HgmvyebeLdFAucCkIJx9XZXC1F4md+CgXYyFjp+XrByl2kyJyJtpCpUalIGtrw27lgsjKZVHKMj1RTTKZLN+NEoSBcHT4GWkbQi9EPAmCMKE5YkohsePWll20BWmqVAeKBC4BxoS18kwUWB1noTfFhQj7icq2VhFQkbcOOcrDVT5axfXjSmspFjRXgKKedlNH3u+nfFzVRjYIZ/MZoKFmMUOoZCQIZUXKs4weIikFQZg0zK5vpCrhgUrTmvFIud34xsNVBWXkBwZXKXLGyZcfHnjufwLycVM2L5x6UiKclEEpi1YGRxtcbXCUxrdT8FUNWudwdSdt3h/p9lvLMXRBECYQYnkSBGHCsrWzDWMNnTloyYGyinQiSUorUok0PoqKRKiNXAe6vBw5o0k5BqUULd011FZ0YgmgpKJcMcVRSza/XigOXTpbTuXrKMZB5+ExgVWEX6k5XMKZg2ETr5Hx45bDwHOYQ6UrhaWFUUZm240aIp4EQRh3fL8dv+txHK8Vz9PsSr8LX9eQC1w8Y+nyAhwsyYRDQoHj6HA2niotXVKVSOZnB6nA0G1qyXRople3oglQKgwIj5MtKWWBbqAS8tFRA2EomfkXCTKTF05+QTipgrfQWocATSGjejMdfnNRKgQFVFCTWFieGyoIIOJpFBHxJAjCmNGZ24I1G3EcF4J20q3b2KmnEFS9Hdy3ETgKk0oQGAffQGAMXmAw1lKZdMIcSo7OS5zinz09c45WoVhy6tiTqc0fV6W2kE4GaBVal9JOhkyQxlgHYx0Cq3GVwdrY+rS/fN8qL7o0JnLpFQsn3UM4xfFYpVETlgxt3iuFdUuUWmE69cn6Qd5hQRDGAhFPgiCUHW/Lf0HQjJ0yl1xVI4okmhwdgcbYRSijwgijmrcQiogwuaS1DuAQ2KiuHeCbWJooikvnFqefKXa8DZS92wKddi5dOZUPCFdY0mxCu2mMrcYzPoosjg4FTGkbqqil3kRFZUr6YHsIp/DMnsJJFc62YKyDxY3Gs4uW7BZCJ2AlYIqC2MNagGEeKxPmmwKM1QRWAwkUBs8oIE34lW/yqRpKbQqxWzNyNyrTKyjW9BN5rzEoDH4AORuwp6uWTBa62MGZ847o814Jo48EjI8eIp4EQRge2S4IfotVmeh5aiCXgc5W3GwnVNWyPbMI6zSio6ewwsNREFgnsqqEwik6G4uOXGB9i5PSYrn0IQDCciZKqbAoL6HKiJNQxjPyrA0lzcLaOMdS7wf83syrQFTaS8XCTGNtEK6XWKZKcz4VUL3WTI+DioVTuB4LJ4XCw9VZPFMZn42xSUIB5eAoD6UNxfIysEmM1SgMgdUYG7okQ1Fk8pfqKZwyAVibJBZ2jta9jupvXKGsslFtQk1NGqZUKmABzza30hX8mlNnf7CftoRRQ9x2o4aIJ0EQBqSt63V0sIlksIuEdiHXBcYrTNEHqJjCvmSCbPIkTKIGU++i8UPXWP6gcD08K34w9/xi7v1FXYhpClVHYGz0NmzR4SM7FEq2IGCsLZIkChylqAQah1ATriF9eMm67/t0mNcBBywYDKBRKsxebmw4Nm0VNj9jbzAlfouEk9VRElAVlaLJ4pkEoSwyBDYZHRcJJ2Xyx4IisE4knMLSLyYvhkJrUncQXykFKJyon8ZCNijY9VwdhP/GJPtJ82MptZ7psMyyMjjKoKzGNxZXK6ZVpdjWfuYg7oNQdpQm/+YykjaEXoh4EgQBgE7vNQy7sSSBLAksmaCODPVY52hwMiRVK1PMGrRTyb7uNqg+CdcNyJo0vqnC2DQGB0WQL8Ye50rKJ520A1k0bIlrTgOuVhiryPoBKdfBMza0oBS5E1RkbSqWKrPTDolEomz3x3Vd6ikVVB1eG9a+QVTcBUgSYFCRdQqIxmPzS/snvj/x/UpFEjGeqecDblFcVZgINEBhbYIOD6AGrdyobkz4D9Db9RiWs9HKorWlQlmyviIgLBujnbDUzOAFoM27TeMrGGNxtKIh7fDI5mbePa9pUHdAECY6Ip4EYQKz8+sfoOG0Y1B+AIEPnV0oazGOg064UFMDiQTkcgCoVAqSCXBcSKSgthGSadAuGJ+sSqA9Q8LbF17AicSFm6RSu5hkJZ61QIJs4KB0ggrdBXQRWjYq2Zc+Ca08SBpc7eOZJMZWRqIrLHSr6CMtwH6s/2GmpTDISCuFo8Co0HoRGIVvLNYLSLsOOWNRxuJGAqLS0cyvH/syJ9WJWuCYkm1t3lY8uxPHBpHHI4ikRRTDpPI1fyN6Rmr1RBWJJwgC6AxcoI7eFrxCO7F7UBNeNPYw9pRChQShkHIt3X4o8nzjkHQyGJtGq8EKqFj0WRylMDa0HCYcTXVCavaNNcpRqBG63UZ6/oGK2OMEYYKSfebzTHvXMTh+gMplUe0dKK3BcdAVFTC1AeU6qFwOpTWqogJSyVA0paugYQ4qmUY5SZTxybpVJP0cCa8lvICTQCmNSqTBSWBS1fi2EkiSDVwsNRQexprAhpm8teoGHBwVRilZmwyDv4ssSn3VEg0DwiG00sTiqmdpFR8IcHVosUhoTUIrKlxNVdIFpenyDXOUYem0ao6cWs0RU6uZX19Zxjs/MmoTs6lNHE9V4i2k3bdQ4b4FVx2Cxqcw7oK4LA2Ct8TRX7u64c2OeezsmkZzVxM7u5rY091Auz8DY+uw1oWSuLG+H3LFMVaxtao34flKFeLDrA2j0uzgzGW9KTrP2NDdKowxWpXnM0hWrFjBiSeeSE1NDdOnT+eCCy5g3bp1Jcds2LCBCy+8kMbGRmpra7n44ovZsWPHgO1+8YtfDIscF32WLFkyrFtSLsTyJAgTkC0//AtmLz0MlfOwSkFXN7jRn2sqCVWVqGQS2jvCJ2IyCQkXHCe0OlXWhXFBToI4OgfjorJt4fFOInyIaheUwibSGKOjOm0QzszSKAIsKv8A7vIVVW4qmqkW2oqKg75jCsHURdvQQDiDyygDVlEo1hs9uC1o5RFYH1c7uBpAM7+6qrw3eIxJOVOAKSXbuvwufLORXZl6jKkLZ7LZvl17sfMstAiF1rj+7FX7c7T1tnyVi6LAeRu6/1wdxqu1ZDwSagc974FwYLF69WqWL1/OiSeeiO/7/O3f/i1nnXUWL7/8MlVVVXR2dnLWWWdx7LHH8sgjjwDw+c9/nve973387ne/Qw8Qn3XUUUfx61//Or/uuuMrX0Q8CcIEZObRh6LigGzPKygRpcBxUQkXPL+wLd6vI/EUu0i0Bt/DJCpIBp2liiYOJlUalIOxLmFkUjjbq7iiWyxyUioWS8WWo9CSpJSNArtVXihBQUhZ6xBYg6PCqe1GWbA6Oja2WCnqSVNZNXEsSeVia2dbwd6Uz+F0CAkdhiZZFL4JhWpe28SzAykVRcaGBgFjw2D54n3D10U2SpMQtuBohW9ja9j+z83nYrelcwmyvo8XGE6ZPb6WgoOSMs62a2trK9mcSqVIpVIl237xi1+UrN9zzz1Mnz6d5557jlNPPZUnnniCTZs28Yc//IHa2jD32r333suUKVN45JFHOPPM/icWuK5LU9PEiZkTt50gTEBUIlH0NOwRP6R1DxHUwxejVGGGjC0IoOKfw/06DVsz0Yw2EyWF9NAYyJdAsVHKgcLlC5aOBIF1CWzoFkoqh1mV05hVOTX6NFBZObmF0+aOzujTkf+5JRJOccanUO/GNfLCf1KtLK4u9ZSoOFYpWo6xIzAd9X1qKH4CW7BoaZUDUv14bYptYdG/vbUEFnJGExA6FHe1Z9nS3sIps8XiNB7EeZ5G+gGYO3cudXV1+c+KFSv2e/3W1lYAGhrC8tjZbBalVInoSqfTaK357W9/O2Bbr732GrNmzWLhwoVcdtllbN68ebi3pSyI5UkQJiAmk0W7Dvg2dMUVq5AgAD8I3XTxtrzQivfnIJEkjlBWfg5fpUhYE7rpCGeohecasAEKH4uLIojcdYWZamHGJI1nkyRpwVKJtQ5GGRI6G06dJ5RP2rpYHAwJQhNLaCFLKGiqnDY2N3CU6erqYp/NRVai2HIWCtaCNnEoWGMclLKYyG0Z6xHbw04Uiiknn2oh/OcrlJ8Z7Ny3oREWOPYDyEZpoBJODq0KwkkBtUB99dCC8hfWVRAGtguTnS1btuStRUAvq1NPjDF85jOf4e1vfztHH300AG9729uoqqris5/9LF/+8pex1nLzzTcTBAHbt2/vt62TTjqJe+65h8WLF7N9+3Zuv/123vnOd7JmzRpqamrKM8AhIuJJECYgzbVHMjvzWmh5cJNYrUJfiNbg5bC5HCqVDNeNAd8PK+MGfmjWyHZgEw2owAM3geNl8dxqcCvAZCHwsE4i3K9SKD+Lk3AwxkT13zKAk7c0aaUja5HCMylcncPgYo3BUQFJpxPfZNE2HWXH1tTQQFXF5I5V2te1j25sFAzfm1BchJa40N3lFAmj2NYUrlkbBrqaEkdlYYK/ipSRpuCq60l/wql4e0+BVWw5KsRs2/y+KQrqe8WUTW7rnxDhaPpJ1DW0NoDa2toS8bQ/li9fzpo1a0osSo2Njfz4xz/mk5/8JN/+9rfRWnPppZdywgknDBjvdO655+aXly5dykknncT8+fN54IEHuPrqq4cxqJEj4kkQJiAzFk2n4/mXqXad0MpUUwvt7aGlyA+gqwurNVSkUV3dYVwUhMHkAF2tYfBxzZTQCuUmSAUtZNPTSHbtROHlBRReJswlZDtJJCyeTZPUlpxpx1Id9Si0mFQmsnT5NVjbRUJlsNrBtwmyXoCPS0KnaKqYPR63bETszuzGWC+MSbJQKBIclVVReWdWn26v0M1lInHi5LcVxytRsrVv+opbiq1Oxa662IWne0bl07dwmq6hqkpSBRx0OJQh5mnop1x33XU89NBD/OY3v2HOnDkl+8466yw2bNjA7t27w9xp9fU0NTWxcOHgi2LX19dz+OGHs379+qF3rkyIeBKEiYgx+Evfw24zi+o195JwHExtLdYPMJkcNmcxbV2YbIqa2kqUq0DVYN0kSluoqkHVT8G27w2FlNaQSJGiBeUmwUmCCcAarO9DrgvlJtCp9+a/K/tz0EyNrPVbOraDSWHtHlxdw9zKiS+a2nK7MezNp01Qyo0ET2gVcqKyKBCn67RgQ/dblIsbpfoXUH3PZBucsy1Ooh7E3lRCwdRTUIVCrTRuzQEOqRVxJIwv1lo+9alP8eCDD/LYY4+xYMGCfo+dNi104T/yyCPs3LmTP/uzPxv0dTo6OtiwYQOXX375iPs8XEQ8CcIEJJl4D/XmYVq8gMzSj5CLtkfz19DKo8JpYV/uEGqSL6GyndjA4CenkDSd4LpYYyHbSegLiiSR1oXlOOLGBuFT3x04hqEnc6tnRksNIxvsKNDl78bYrZEAisYbWZS0iuKUlMLi46gwR1VY984HFRbPzWdCV5HLLe9w659CnNJAgdmFpTiSKRZzgdFYa/PuteImEsCiKeJOEwaPUmUoDNxX0rZ+WL58Offddx8/+9nPqKmpobm5GYC6ujoqKsLXsbvvvpsjjjiCxsZGnnrqKf7qr/6K66+/nsWLF+fbOeOMM7jwwgu57rrrALjpppt43/vex/z589m2bRu33XYbjuNw6aWXjmhsI0HEkyBMUDqzFss+HCdNGIMSluGATlI6R9bXYfkMPwfKwRLg+G2QTGGVA/u2QeAV0hegULFwMn74YPYjWaY02Mn3dZAJdgJb8ikS8m42Qm+FRWPxo59h+gQb1aOLa9TZyJoUT7MvzuYdEh1bxP5yJfXOIB7/tMTZsULrUngdY8CL4qoalaJ+HLKlCwcgY1wYeOXKlQCcdtppJdvvvvturrzySgDWrVvHLbfcwt69eznkkEO49dZbuf7660uOj916MW+++SaXXnope/bsobGxkXe84x387ne/o7GxcXhjKgPKjmTOqwCE+S/q6upobW0dUkCdIOyPna3/RTI5i4qkjSwoFk1ALtB0BLOh801mVO7AD0BrjU4mobMduvZF06bS+aSYqHjWnsUagzJhnJRxE+iKxajUCeM51AHJBHuAjUAscHoESSsobHV6iBcdJVAoZEEvlA3WkYiJrE9obBTwHu5TGBTWhuKpsL13H8OgcU0stGKrUlzbTilT0u8aHOqrJndAvTB0xuJ5EV9j7z2XUluZHFlbXTkarvx3eb71YPK9agrCQcT0ug/Q3L2JTE6ToB2lLDlbSRyR1DTtZABKyt/WR58B6BkvM1HIBHvAbiwSRnHyzMIx+Xyh0Xro8oqtSQoIoun+8RkmstkVW4D2H4dUnAEiPmsgwhpxTqmoIyxyM6W6up+zBEGYjIh4EoQJTlPFIWzf9iO8Ke8uPMFbfk7TzI+Oa79GQrffBrxOnGQxFETR4FRc7y0UONaqaJp/0THxgdjIhab6LAlTfKQiNFkNaGvvJZhUUZqC3han2P0GmgblUC2WJGECIYWBRw8RT4IwCZg567LSDRWTQzhl/G4sr+RzGRXsRUUlWfJuNhNZj6Ao9Doq+1J8bu/5Z0qZ6BgotasVjizU7Svanp/VpgtlUaKSMfF63sVnw6izWVX1w7wbgjDG6KgE00jbEHoh4kkQhLLS7a8HWoq26HzcT4hTlEAytjFZCgklewsoMFGWboq29XSq7e8NuZCCACjEMdmwnpyxmrCmXxjX1FQ5Y/CDFgThoELEkyAIZaPTf5aeNiKLQRfmmIXWJaspzcAdHR9l4S6EW/ec+t933u3Q6lTs6iveG2ZHLwSHFwodQyVTUnN6NigIBwZieRo1RDwJglAWOv0/oEoKj4QogqimWyigrLW9pvrb/Ky0vuktnHoKJRVlAS+UUolnv4Vn1VOTmD/CEQrCJEPE06gh4kkQhLIQTerPr8UOMouDIijaCr3lUt/CqZBvSefFUWGnzdunCrFS9VS4i8oxHEEQhH4R8SQIQlkIk0uGyTgLGBRBPkdVMT3nzRW2FgWEW5UXW6Vn1JB2FyMIwgBoVVoZerhtCL0Q8SQIwojp9jcRRNmmdJFtyUbOutDypAuyyBZ/Idv8J29BsnGW7xoqRCQJwvBQZXDbKXHb9YWIJ0EQRkzAbhROSfh3VFYXg8YhoDCLLhZRYbmUUEYlqXCPGsMeC4IgDB8RT4IglAGHvt5Pw5l3pijCySGlj0VLEKogjD4SMD5qiHgSBGHEhF+vAfkScxQyb+vIBlXhvmWceicIBykinkYNEU+CIIyYMCg8jHFStjCjTmOwaFyWjnMPBeEgRKsyiCcJGO8LEU+CIIwYm8/vpItmx4GJ0hQk3ZFVdhcEQZhIiHgSBGFEdPnPAg6B1VCUkkApE1meBEEYF8RtN2pMiruyadMmrr76ahYsWEBFRQWHHnoot912G7lcLn9MJpPhyiuv5JhjjsF1XS644IJBtb13714uu+wyamtrqa+v5+qrr6ajo2OURiIIByKKwLqoKLpJqSgZptVFgkoQhDEnFk8j/Qi9mBSWp7Vr12KM4Xvf+x6LFi1izZo1XHPNNXR2dnLHHXcAEAQBFRUVfPrTn+YnP/nJoNu+7LLL2L59O6tWrcLzPK666io+/vGPc999943WcAThgCKwThQoXmRjUoTz62yYjkAQBOFAYlKIp3POOYdzzjknv75w4ULWrVvHypUr8+KpqqqKlStXAvDEE0/Q0tKy33ZfeeUVfvGLX/DMM8/wlreEM4HuvPNO3vve93LHHXcwa9as8g9GEA44HIiSWxa/o8YJCgLx2wnC+CAZxkeNSWuPa21tpaGhYURtPPXUU9TX1+eFE8CZZ56J1prf//73/Z6XzWZpa2sr+QjCwYqKZtVpPBRZNNnopxdZoybt14wgTG7EbTdqTMq7sn79eu68806uvfbaEbXT3NzM9OnTS7a5rktDQwPNzc39nrdixQrq6uryn7lz546oH4IwubGAh8IBElgSQCLKOJ6ltNadIAjC5GdcxdPNN9+MUmrAz9q1a0vO2bp1K+eccw4XXXQR11xzzbj0+5ZbbqG1tTX/2bJly7j0QxDGg4zfTrf/h/zHUQZFkt4iSaFIoFQwHt0UBEEsT6PGuMY83XjjjVx55ZUDHrNw4cL88rZt2zj99NM55ZRT+P73vz/i6zc1NbFz586Sbb7vs3fvXpqamvo9L5VKkUqlRnx9QZioeKYLWEM+2LsobkkrhbVhqd/QwlR8gCpattF6YVasIAhjh1IaNcLCviM9/0BlXMVTY2MjjY2Ngzp269atnH766Sxbtoy77767LLWxTj75ZFpaWnjuuedYtmwZAI888gjGGE466aQRty8IY0FLtoWAdojkTKxdLGG6ABslr4wNzcbGSS0dwMdai7UJLA7GKHZ2N3PstGaUShaaK/oCVVEucdAE1sPmBVS4t6QTKJzJMS9FEARh0EwKSbl161ZOO+005s2bxx133MGuXbtobm7uFZf08ssv88ILL7B3715aW1t54YUXeOGFF/L7n376aZYsWcLWrVsBOOKIIzjnnHO45pprePrpp3niiSe47rrr+NCHPiQz7YQJzZ7sbnZntrA7swXftmMtWOsAOq7GG1VmMGhlUMoQW5G0UqGrTfmAi1IujvbQ2sdxDDOrm9jedRwb97QA5C1LJQJJhSLKKToixCAxToIwQVBlcNmJ5alPJsUr4apVq1i/fj3r169nzpw5JfusLfgT3vve9/LGG2/k148//viSY7q6uli3bh2e5+WP+dGPfsR1113HGWecgdaaD37wg3z7298ezeEIwojYlXkT8takGBMlplSRmd3knWb5YnOq9O9FYaNtCpRG2wCjNNaCoyFZ8Q6sXYNSALZIPsUZxKNtdqBcBBZJkikI44RkGB81lLUDfvMJg6CtrY26ujpaW1upra0d7+4IBzC7Mptiw1LolkMRihNFLKCAyNJkC8dFVqnYlRe3YHCidYvGJyCBteE7lbWK7m6fBVPXhevokogmUBirCGyih62p+ChFhXtcme+CIExexuJ5EV+j5Tc3U1s9svjcto4s9ad+RZ5vPZgUlidBEGB3Zn0+X52K/q+sg8WP0gOUipaSKO9BUnKWAjeZLtlf3KK18Ybis3pmFC9NBSIIgnAgIOJJECYBe7Kv4kbCKbQphaZ0pXywLhZDKFyKZ7qVYnusRc63kvWSY6zCGJs/t0RYRZ7AoFfLsXASi5MgjDth4OPI2xB6IeJJECYwLbkNBDYAXAIsigBHgbWGIHLDoQzY4hioggwK3XSF9opdduG+2IYVYNH5dQhl0LTE74EKQOXbic8LojxOIYdT4VaV/wYIgjB8JOZp1BDxJAgTlD3ZV3EgsjgFWGsJAN9qXGXQ1mBIUGptsihVUDlxvJMtSlUANqo3FwofhYdFYawDOPm4qGwWKqdURJFTCtQCEnrGWAxdEARhQiPiSRAmIPuyr6LzQsaglUUpcFEE1hBYhaMspsS0FOSFk6KS+uS0PvOhWWvZ170PTxmUDYPEuzMaNxHngdLY3E4Om7YIOGVMxisIwigglqdRQ8STIEww9mbXo4rilywOgQWFj1ahDSmIElyG+xWQpDE9c1DtK6VoqOxRVLuy51Eyq0YQJj0inkYNEU+CMEFoye3A2vbQuVYUo6kwWKuwuICPUgpsXDYlYFp60Tj0VhAE4eBFxJMgTABacq8DJhRGeYoyKimLtQpjC5NffAtTRTgJgtAfYnkaNUQ8CcI405JbHy31zJcEpWkAoi02rC3XkDp8DHonCMKkRauRpxqQVAV9IuJJEMaRvdn15IvREdadCwVTnLcJSi1QEFiYKsJJEIT9ocpgeZLadn0id0UQxom92dcJ/wSLcivlM3aH5Vby2PB/SoSTIAjCuCOWJ0EYY1qyG7AERYHhOgoID0VUGNdU5MKzoYxSuNSlDh2XPguCMAmRmKdRQ8STIIwhLbm1KEVeOOVTNCnA6nzZlTyRcGpISWC4IAhDRMTTqCHiSRDGiDbvVTQqDFyKCJNaGrA6ElM9qsgpS0NShJMgCMJEQsSTIIwBbd5Lheq6eTTgAKCUwVpQUVbxeH99cuFYdlMQhAMJpUYe8K1ktl1fiHgShFGm3Xsp1Ew9voNsPiDcobiQbzzTToSTIAgjQukyiCdx2/WF3BVBGEXavZf63ReFhxfWopl2DalFIpwEQZh0rFixghNPPJGamhqmT5/OBRdcwLp160qO2bBhAxdeeCGNjY3U1tZy8cUXs2PHjv22/d3vfpdDDjmEdDrNSSedxNNPPz1awxgUIp4EYZQIhZMi/DMrTUnQE2ttFBguokkQhDIRB4yP9DNIVq9ezfLly/nd737HqlWr8DyPs846i87OTgA6Ozs566yzUErxyCOP8MQTT5DL5Xjf+96HMabfdu+//35uuOEGbrvtNp5//nmOPfZYzj77bHbu3DniWzRclLW2dwpjYUi0tbVRV1dHa2srtbVSUFWANu8VSt9NTCSdLMVJL8P0TS4GS31yyRj2UBCE8WAsnhfxNVrWfp3amoqRtdXeTf2SG4bV3127djF9+nRWr17Nqaeeyq9+9SvOPfdc9u3bl2+rtbWVKVOm8Ktf/Yozzzyzz3ZOOukkTjzxRL7zne8AYIxh7ty5fOpTn+Lmm28e0fiGi1ieBKHMtHlrKVia4o8T5XEqZBMH8skvRTgJgjCRaWtrK/lks9n9ntPa2gpAQ0MDANlsFqUUqVQqf0w6nUZrzW9/+9s+28jlcjz33HMlwkprzZlnnslTTz01kiGNiCGJp/2ZyHzfH3c/pCCMF23eelpzr2JtlPSyl01X9a5UpzS1IpwEQRgN4oDxkX6AuXPnUldXl/+sWLFiwEsbY/jMZz7D29/+do4++mgA3va2t1FVVcVnP/tZurq66Ozs5KabbiIIArZv395nO7t37yYIAmbMmFGyfcaMGTQ3N5fhJg2PIYmnmTNnlgioY445hi1btuTX9+zZw8knn1y+3gnCJKE1tz7K0aQpjnEqFVC9Y55qE0eMSf8EQTgIKaN42rJlC62trfnPLbfcMuClly9fzpo1a/iP//iP/LbGxkZ+/OMf8z//8z9UV1eHrsWWFk444QT0JEvGOaRUBT3DozZt2oTneQMeIwgHOq25V4vWin//wy8Da22PVCnhMTWJo0a7a4IgHMyUMcN4bW3toGOerrvuOh566CF+85vfMGfOnJJ9Z511Fhs2bGD37t24rkt9fT1NTU0sXNj3ZJlp06bhOE6vGXk7duygqalpGAMqD2WXekoSagkHEa25dYBBqfhTLJ7CinQFi1OUTZxaEU6CIBxwWGu57rrrePDBB3nkkUdYsGBBv8dOmzaN+vp6HnnkEXbu3Mmf/dmf9XlcMplk2bJlPPzww/ltxhgefvjhcfV0SZJMQRgmrblVQBrIYO18ICy3opTF2p4vEeEsu1oRTYIgjBVjnCRz+fLl3HffffzsZz+jpqYmH5NUV1dHRUU46+/uu+/miCOOoLGxkaeeeoq/+qu/4vrrr2fx4sX5ds444wwuvPBCrrvuOgBuuOEGPvKRj/CWt7yFt771rXzzm9+ks7OTq666amRjGwFDEk9KKdrb20mn05ErQtHR0UFbWxtA/qcgHMi05lZR4VRR6VYBoKjC2t10B91YO7cPARVanCS+SRCEMWWMxdPKlSsBOO2000q233333Vx55ZUArFu3jltuuYW9e/dyyCGHcOutt3L99deXHB+79WIuueQSdu3axRe+8AWam5s57rjj+MUvftEriHwsGVKeJ611iVsuFlA914MgKG8vJziS5+ngwgue7KNGnUVh6fR9lGoCYvEUFvmtSx4+Hl0VBGGCMaZ5nl6/qzx5nhZ+Qp5vPRiS5enRRx8drX4IwoTHN38iMJ1hviYLjgoDwW1Ui85iSTkJskFxLU0RToIgjBNKjbywr8Qx98mQxNO73vWu0eqHIExosv7jOBpcrbBxEV/rEBiFo21eQGkModUpPE+EkyAI44cqQ2FfEU99MayA8dbWVlatWsWmTZtQSrFgwQLOPPNMMekJByS+CYVT6IALVZECUAEah8CAo+mRAFOJcBIEQThAGbJ4+rd/+zeuu+66XsHhdXV13HXXXVxyySVl65wgjDe+WR0JpXBdocCGmcJjAWWtSyydTOCjlKI2IcJJEIRxpox5noRShnRXnn/+ea666iouuOAC/vCHP9Dd3U1XVxfPPvss73vf+7j88sv54x//OFp9FYQxJS+cACxR2RULykZWqFKsNaSTp4pwEgRhQqCULstH6M2QLE933nknF1xwAffcc0/J9hNOOIEf/vCHdHV18a1vfYsf/OAH5eyjIIwpgX0D7OvovHKKvzwMWB3+DCPF8xgDSfeUse2oIAiCMC4MSVI+8cQTXHvttf3u/8QnPtFvZWRBmAwY+wSaUDjFiQYUBjCRm85gbZiaoIAV4SQIwsSjjLXtJjPZbJbOzs6ytjmku7Jt2zYOP7x/l8Thhx/O1q1bR9wpQRgPrH0UbBZrba8ajb3mm0S7A6NJi3ASBGEicpCLp127dnHuuedSXV1NbW0tb3vb21i/fn1Z2h7SXenq6iKdTve7P5VKkclkRtwpQRhrTLAKjI+2AdoGKCxY0yOuyfQ4S5Fy3z52nRQEQRgKcZ6nkX4mKZ/97Gd54YUX+NKXvsQdd9xBS0sL11xzTVnaHvJsu1/+8pfU1dX1ua+lpWWk/TkoCew2sBvy6xawFiwJLDr/AFd4uJHHyEbzvaxVhPncXRQ+jjIoFeTPIB/abCPriS4SBBpoBBpx1JTRHOKExgSrUOE8ujzKhvcsXOn5jmGwzMbVi8aoh4IgCMJQWbVqFffccw9nn302AOeffz5HHHEE2WyWVCo1oraHLJ4+8pGPDLhfTWKVOh4EdjPYN8JcZoSP6ziixuJjcbFWY1BYUhibi+JxwqOVsiirMNbHkCCwPg4KpULrSSErkYMlQGGic1WU2HEHsIPAEAk1RXG5EQiKZpY5kF8uFRQls89syQ8MutfxPc7otaewz+Y/uuRXq5KEXtrfbR08war83UBp6KNaUT4tAeFuV0uyWEEQJgEHeaqCbdu2ceyxx+bXDzvsMFKpFNu3b+eQQw4ZUdtDEk/G9HRbCCOmSDhB0U9FFHdjUSqe5aUIrA4FUD75UFgiRAPGBlicood9LKDiVmMBFR5RIl9UFBhtHULLio6OckAF+fasdaLl8Jj45OKrFHIiRWIw7/4Kj7f5/0cz1yg+0Rb1rrgVi7GmSEB14Zk/ktDHMlxssAqUC0phrQEbjzMal1Ioa8MeKYUR4SQIwmRijAsDT0Qcx+m1PoSSvv0yrAzjQnkwNtevO9kSuZptKEtKrT99i9hQikR2Gxv6qhVxTiITnVtq8YnXClvDMiORLIva0qGAIxZ1pecOZEWKzyl2NZaeV3xuQVAVW3sKS4URhmd093vN/RGYR0HHv/4KpRyU0lgTRLPrVFGfw7vi6tOHfT1BEARhbLHWcvjhh5d4xDo6Ojj++OPRRRa1vXv3DrntIYmnb3/7231ur6ur4/DDD+fkk08ecgeEsWZgt6pStg/P1f5csaXyq+eZsRAM1X7Ptnqe158IG1igDQVjHu3lXraRJU1rJ0zaVHRdpRRaiXASBGGScZBbnu6+++5Ra3tI4ukb3/hGn9tbWlpobW3llFNO4b//+79paGgoS+cOdLRKEkRGjr4khbFF1p/8noD+KLVHFQKeB54x1pPxjlkrn0jqi8Cuzn8ZFEZqUehIQIXWMBW5Iq0IJ0EQJisHuXjaX4z2SBjSXdm4cWOfn3379rF+/XqMMXzuc58brb4emKh5kXsoJP/TQuzWslG8E4DOxzsVjrY2FFrgoKKYJqVsDxlUCEMvpvd1e4q13mt9DGK/x/TvYh6sUBqZoDI2IBc8GlqVjCEwhsDGMw+LnZTx+C2KKrQ+Y0TXFQRBEA48yhbztHDhQr7yla/w0Y9+tFxNHhQ4aj4BDtiNRbPT4lQFblGqAosih9MjfigMIg+PLaQqMChKg7RDgh4CoZRQOKn8fhWnOFCm6Jii4/tY6kkh7UKhL6XnFZ+riC1jve1f/VnS9o9vdtLmbQOm5kPbteqmxu0iMC6ONnlpWphleCg4C4d4JUEQhAmEVmWYbTfe3ojhs3Dh4L7DX3/99SG3XdaA8Xnz5tHc3FzOJg8KHDUH1Jxhnx//IxrbBuzEsrNIYGjAj4KgKZohR4+UAiraFwsnQygkTJFgcnq0W2ior1QF8WLfqQp6zrQrPrGXrAtb6fE3nNBvYzC0edtJ6uKAeIAErV4dNW5rFBAfNW4MOO8ZVLuCIAgTmoPcbbdp0ybmz5/Phz/8YaZPn17Wtssqnl588UXmz59fziYPGjL+HmAT4SP+MNJu3ZDb0KoWqAUGmbxxHF4octn/QyXimDhT5DDrY96eBeN1kDMaD5dAzSKwVXi2mrlVg7s/e7PPk9ChRckSAMnQEmZD+dZtoCIy51lrcJx3l2+wgiAIwrhx//3384Mf/ICvf/3rnHvuuXz0ox/lve99b8lMu+EypBba2tr6/GzZsoWf/vSnfOYzn+GSSy4Zcad6smnTJq6++moWLFhARUUFhx56KLfddhu5XC5/TCaT4corr+SYY47BdV0uuOCCQbV9yCGHoJQq+XzlK18p+xj6IwgC9nW/SJvn0ebNps2bQ4vXSXP3q+zsfnnM+jFWJFPvJdO5B2yYEiF2xAV+QEsuyb7cfHZ2z2dH93z2ZBfQYo6iWx2Bx2H4tgbPphgoaL4nCaVR5NB4JPFI0IlDNwafgBTZYA4tublYDI6kIhAE4UDiIC/PctFFF/Hzn/+c9evXs2zZMq6//nrmzp3LzTffzGuvvTaitodkeaqvr+83g7hSio997GPcfPPNI+pQX6xduxZjDN/73vdYtGgRa9as4ZprrqGzs5M77rgDCEVIRUUFn/70p/nJT34ypPa/9KUvldS7qampKWv/B6I1tw6fRorNQBoHSx0G2N61I9rqMLNy2pj1azSpqTmv17ZEEuKqiVs6dwNJPBu6G5WNI55cQKPJ9Tq/PxIqh1WhSzJ2XLra4NgcvrHkqAR89mYXAG/SmB6++1QQBGFCcZC77WJmz57Nrbfeyq233srq1av54he/yNe+9jV2797NlClThtXmkMTTo48+2uf22tpaDjvsMKqrq4fVif1xzjnncM455+TXFy5cyLp161i5cmVePFVVVbFy5UoAnnjiiSHV2aupqaGpqWnQx2ezWbLZbH69ra1t0OcWY0yATwN9+c/isG2T92MFbMsLKZhVOWNY15wMuAp86wGpKH1AjAayg34RygRPY5QTxVwVrFXGumh8HO3jBll8atDKw1in/8YEQRAmGyKe8mQyGf7zP/+TH/zgB/z+97/noosuorKyctjtDUk8rV69mptuumlEFywXra2tZcsn9ZWvfIW/+7u/Y968eXz4wx/m+uuvx3X7vzUrVqzg9ttvH/F1jcmx36SVQJQ9IPSx2jDF99bOHUBY2HB2Vf2I+zKRmFk5je1du/FtBkhQSCWQwQkTf7O5o5V51f3HPXmmG2sdDJYkHShdyGYeGIVPCo3F0Qbf+AAoAjoyHVSnR+clQBAEQRhbfv/73/Mv//IvPPDAAyxcuJCPfvSj/OQnPxm2xSlmSOLp9ttv5xOf+MS4i6f169dz55135q1OI+HTn/40J5xwAg0NDTz55JPccsstbN++na9//ev9nnPLLbdwww035Nfb2tqYO3fuMK6+/9tfHEAdCikLKi7Rm0FbyxsdXUA1GphbXTuMfkw8rA0tUOCVbo/+p4DNHW0oZZjbh3g09jUCIKU60SqgIFLDSHHHGDwqis4I3648MoCIJ0EQJj9WaewILUcjPX88Oeqoo9i5cycf/vCHWb16dUmR4JEyJPFUjmJ6xdx888189atfHfCYV155hSVLluTXt27dyjnnnMNFF11UEqc0XIpF0NKlS0kmk1x77bWsWLGCVCrV5zmpVKrffUPBdRPg9VWypMBAd1xFqckrHIAOrFW82dGJUhUoYNYktkgVV9jriUVHSjL8o97S2UI1MKVkvAmgFW2z6Fxo4VM6ql3nOAQuGKOxNrZshbX/EvnIK0EQhMmNtTpKsjyyNiYrr7zyClVVVfzwhz/kX//1X/s9btRr2wH9BowPhxtvvJErr7xywGOKk1xt27aN008/nVNOOYXvf//7ZetHMSeddBK+77Np0yYWL148KtcoxsElwKc/AbV/uVpUPldZko4CuvEMbO30AU1KwbTKyVUyx+JirUGpHrnOrY5imErvVyfQ1bmX2VXhOFPOEejgYVTOw6aqMDaMnYqjmpxsF66boNu64VZrsLjishMEQThAmDC17YBeFYr7YrAqrrGxkcbGxkEdu3XrVk4//XSWLVvG3XffXZY8DX3xwgsvoLUue0Kt/phaMY1d3bswhK6lIudSL/rIhNQvCQ3GehgS5PDY0bUNlMVVaaamp5ar+6PG3Kp6tnS2oKyKMn5DmLqzkAG98DOsS6dQvNmxF4VmdnU9Tq6bXLIKP6ik268llKqtVCR9kklQgYehAqL7pEvceIIgCJMbi4NlZBNhRnr+eDKate2GLJ5uv/126uqGnsBxJGzdupXTTjuN+fPnc8cdd7Br1678vuJZci+//DK5XI69e/fS3t7OCy+8AMBxxx0HwNNPP80VV1zBww8/zOzZs3nqqaf4/e9/z+mnn05NTQ1PPfUU119/PX/xF38x4mCyodBYEQrInd07Cjm3B/bm7RelomIj1gcS4VwzC4FtZ3emDYWlSs0inZq4biqNxliLVcWSMSotY6E0Q3lUYEWFhWvWt7QwpyZNW24+GoMTaW1jp9CW09Qmd9AZ7MEoBVRIigJBEA44Dna33dNPP82yZctwnL4FYDab5Wc/+xkXX3zxkNtWdgiBTFprmpubx8wqE3PPPfdw1VVX9bmvuPuHHHIIb7zxRr/HPPbYY5x++uls3LiRQw45hOeff56//Mu/ZO3atWSzWRYsWMDll1/ODTfcMKSYpra2Nurq6mhtbaW2tjwB23khlTe69G1xKlSLiz8qf3hcMNiSyNeWC2u7RWVX6CTMrhQwq3JiigfP89ie7Q5HFYnJuAZfoeZe+FMTui6tVVgLHbkEvt3HrOpMJLbCkjBKgW80U9mEUyEZxQVBGDtG43nR3zX27Ps1tbVVI2yrk6lTzhzV/o4WjuOwffv2vGapra3lhRdeyIcD7dixg1mzZhEEg0+8HDMky1M5452GwpVXXrnf2CgIM5EPxGmnnVYitk444QR+97vfjbB3o8P0ikIep+buHYWKvEX/BKXCqSCYiom3FVtuQgHloAiTgRqTYHPHbmzktppfPbI/tnKSSCSYl0iwuaOtkLMBWxQL1bP8cSgglYJUAnK5KbzZYalPZQgjnjqpcLNRAeWJ774UBEEYLjZfs3RkbUxWetqG+rIVDXci3LjOthMGR1ORkNrZvT1a6mmJspFFJlqLdhnb1y9+IecRhEW3wz+vboyB19u6gSoUigW1E8OtN6+6li2dLZRWFCotLKziVORFuAqU0rRkK6hKKMAB3wC7mVpdvmmrgiAIEw1jNWaEbreRnj/RGa5RaEjiyRiz/4OEUWV6xUwAdmW2F4nZ4iDqAj1tMn3t7YnWUKEBOrFBwKb2Viy1aGB+zfgGVMf5nEIRVTrqUDjZXm9JilD0RxFRQCeeqcDV09iVeZ3G9EIEQRAEYSgMSTx94AMfGNRx//Vf/zWszgiDpzE9M7+8q3s7xpbWb7SWaEp/wblXyv5m7SmU45DComjDN7C5oxNIohjfZJxzq+pp62qj3fqF2Yk27HMsp3wDfqAIrMXRCmUt1locPYVc0AIk6PblZUAQhAOXg322HYQTyZqbm4HwRXrt2rV0dHQAsHv37mG3OyTxVFtbO25xT0L/NFYUhNT2rl3YPlMe6HieGr3tMzF9CSqFReE6YG0A5MB6bO3shChGajzKw9RW1lILbO1oCaOcigbkGwhsCt/aKPVl6agcVUul24pnxnbWqCAIwlhysM+2AzjjjDNKQo7OP/98IHTXWWvHxm13zz33DOsiwtgxszJMe9DR1UEbOQrhfjb6fzwjr/9MUr0JM3DHv2OWBI4KUHSBsWzr7CQgxdyqaWUcyeCYXV0PwNo9nSQTgIWcUVhr8OISLzYctVZxOgNFa1ZTmRj6DAtBEITJgkWXIWB88oqnjRs3jlrbQxJPPaf9CROX6srqfIW2bV17CYOrVYmQGgnWhiVStA5IYEmQZUfnVjJWoahhXnXNiK8xFJZMrWLNns4ohDz8c0/ocKphXkRRkI2WFPMi4SUIgiAceNx7773cdNNNo1KPd0iSUmbbTU5mVTYwq3IasyqHNzW/Z4mUUiunyocaaQcqHUg77WzvepNtXW+yrWvLsPs9VI6eWsXSqWGaBQN4JhROSa1Iu06YtoEoHsyI+1kQhAMbgy7LZ7Jy++235+Obys2QM4wLk5uZlQXX2vau/oLlit16xck3B3LrFfJQhQkBwiBDY+HNth1kcdFUjUnqg6VTq3htXxeu2/uP3lqLby2+mbxfCIIgCIPhYI95Gk2Dz5DF0z//8z9TXT1w8dRPf/rTw+6QMHb0L6QKwqmQxbvwSziU30etwE2Aa30sHWxu7yDAZWYiTTo9ekIqsBbfN6QcVXDVWcIgcgtai+VJEAThQGe0JrkNWTzddddd/daJgbCjIp4mH8VCqrl7R7hQWvEFcCLhFIuq0izfxZRmO4/yKNiAhOPgWp89fhd+excGzYKa+rKPJyCcZZcNbK+Zh4ER97MgCAc+kqoADj/88P0KqL179w653SGLp2effVYCxg9wijOaN3ftjkyf8S+fiWKgwnkcPeOh+qL419aiwnMUJCxYDG92tJALNAaHRXXlKQ1jjAGtcZTCUdGcQ2vxIkUn8XuCIBzohHU+R+q2m9xW+ttvv526uvKnpZkUte2E8aOpxCK1nXgmW1iot3dOqJj9aROFxSoVNqEg6RqMhTfaOwkCsAYObRi+kDq00uH1bkuAJYisZeSrt1hyph0Y2xmBgiAIwtjyoQ99aFQMPmWdbWeM4aGHHhpRh4SJS1PFTJoqZjG9YlZBOBXqEufp/aai+k+OoMJGFGF8lNbguuAmFBvbulm3p5O9LV1D7mtlZSVL6lKlJYVUmOcqE2R4y/RZQ25TEARhMhHneRrpZ7CsWLGCE088kZqaGqZPn84FF1zAunXrSo5pbm7m8ssvp6mpiaqqKk444QR+8pOfDNjuF7/4RZRSJZ8lS5bstz+jafAZkuXptttu6zNYfP369fzgBz/gnnvuYdeuXXieV7YOChOTxvTs/PKu7m1YQ88cBkBRRe4iq09I72PDwO4oWklZtFKkkpo2FK1t3fgWDqsbfH0913U5ZlpoXdrYvoUFNXOjPQNPeBAEQTgQGOvCwKtXr2b58uWceOKJ+L7P3/7t33LWWWfx8ssvU1UVehKuuOIKWlpa+O///m+mTZvGfffdx8UXX8yzzz7L8ccf32/bRx11FL/+9a/z6667f/kyYWbb3Xbbbfnl7u5ufvzjH/PP//zPPPHEE7zzne/kC1/4AhdeeGHZOylMbBorClacHd3bCy47Ff3R5YVTIfCwR+aoftsO9VhouXIVbGzPgLXkAsviKYNPfFYQToIgCMJo8Itf/KJk/Z577mH69Ok899xznHrqqQA8+eSTrFy5kre+9a0AfO5zn+Mb3/gGzz333IDiyXVdmpqahtSfEs9DmRmyJH3mmWe49tpraWpq4pvf/Cbvf//7UUrxT//0T3ziE59gxowZ+29EOGCZUTGTpsrwY63CGB3N1igWToVfu+IXg3Cx71/J0ryciqSr2dieYWNbN5v2Dd2tJwiCcODj5GfcDfcTf3e3tbWVfLLZ7H6v3traCkBDQ0N+2ymnnML999/P3r17McbwH//xH2QyGU477bQB23rttdeYNWsWCxcu5LLLLmPz5s3DvivlYEjiaenSpVx00UVMnTqVJ598kueff54bb7xRAsmFPplZOZ1ZVY3MrJyGRYdCyhZZoyzEv4Khbx0KMqn0d6rf3zGlsEVC6o2OTPkHIgiCMAmJk2SO9AMwd+5c6urq8p8VK1YMeG1jDJ/5zGd4+9vfztFHH53f/sADD+B5HlOnTiWVSnHttdfy4IMPsmjRon7bOumkk7jnnnv4xS9+wcqVK9m4cSPvfOc7aW9vL8+NGgZDctutW7eOSy65hNNPP50jjzxytPokHIDMqiy8eWztbMGYyCWngLxwCvNIlYqoSFwNwnettcZay6b2DMYYHK2ZXzP6Gc0FQRAmIuUsDLxlyxZqa2vz21Op1IDnLV++nDVr1vDb3/62ZPvnP/95Wlpa+PWvf820adP46U9/ysUXX8zjjz/OMccc02db5557bn556dKlnHTSScyfP58HHniAq6++erhDGxFDEk+vv/4699xzD5/85Cfp7u7m0ksv5bLLLhPLkzAkZlfV55c3tHbi6kKseX+uu8GE/Vlr87+LWmsMsKGtGxMEpB2XuWNQGkYQBOFApLa2tkQ8DcR1113HQw89xG9+8xvmzJmT375hwwa+853vsGbNGo466igAjj32WB5//HG++93vctdddw2q/fr6eg4//HDWr18/9IGUiSFJ0tmzZ3Prrbeyfv16/vVf/5Xm5mbe/va34/s+99xzD6+++upo9VM4QDm0ror5NVXMq66iM0vk2oPwVzO0JI1kxoRWCsdxyQEb2jKs2zN+Zl5BEISxpJxuu8Fdz3Ldddfx4IMP8sgjj7BgwYKS/V1dYXyq1qVtOo4zpODujo4ONmzYwMyZMwd9TrkZtj3v3e9+N//2b//G9u3b+c53vsMjjzzCkiVLWLp0aTn7JxxEHDG1igW1FVQrhe/7GGv7SiPVi77snv1ZQ91EgtfbMrze1s3LO0VICYJw4GJwyvIZLMuXL+ff/u3fuO+++6ipqaG5uZnm5ma6u7sBWLJkCYsWLeLaa6/l6aefZsOGDfzjP/4jq1at4oILLsi3c8YZZ/Cd73wnv37TTTexevVqNm3axJNPPsmFF16I4zhceumlZbtXQ2XE5ZLr6ur4y7/8S5599llWr17NiSeeWI5+CQcx06rTHFpfxYKaNFgwwcBvJHHxmP4EU/HmuEgwKCoqEmyKAs1fFyElCIIwIlauXElrayunnXYaM2fOzH/uv/9+ABKJBP/3f/9HY2Mj73vf+1i6dCk//OEPuffee3nve9+bb2fDhg3s3l0oVv/mm29y6aWXsnjxYi6++GKmTp3K7373OxobG8d8jDHKljGL1B//+EdOOOEEgiAoV5OTgra2Nurq6mhtbR20T1gYOq/u68JRFt2jMHV+fl6RSrKR1SomrgWsVbgciq3Cz7x9KzAkHM2s6sEn4xQEQRgsY/G8iK+xbvtGakZ4jfa2NhbPXCDPtx4MuTCwIIwXhxclxXxlXxcpXfCdDySc9vd6YG2RdcrReMCm9m7A55AaqX8nCMLkpJyz7YRSRDwJk5IjioTU0zvamZZ2ULqPWXqWIQipIqeeAnDZ1N6NtWAwHFo7/ELFgiAIwoGDiCdh0vPWGaF1yPd9XtrTTXXaKU4ilSeWRppSQRVarWyPo+J94U+Nw8a2bgITHnFovbj1BEGY2Ax1tlx/bQi9GZJ4+sAHPjDg/paWlpH0RRBGhOu6HBsJqdbWDrbkoCLloKLaeHFguaVnDWPbz3KIUiq0WCmF1mCxrG/txjO2xAImCIIwkRjqbLn+2hB6MyTxVFdXt9/9V1xxxYg6JAjloK6umvi3dfPOdjJOmKYACsKpV7B4CT0sUBREl7UKpSCh4bXW7sgXqDhMrFGCIAgHBUMST3ffffdo9UMQRo150wtB3y/taqcioXEcXeTVixf6skD1nz1fhUoqrK9HKKSMhSSwQISUIAjjjLjtRg+JeRIOKo5qLAip53fuY2rlwPWZIJ69N3AJonw8lQLfWtbu6yRnYElNgmQyOcJeC4IgDB2ZbTd6iHgSDlpOmD4FgK5MF7v8DNjIWlRkkeopnHrO1gvjoXptRKNIOZYNnT6mLUu3gbdMl7QHgiCMHcZazAhTOY70/AMVEU/CQU9lupL5hIHf27t2kgkqKPxpFFmcbO/oqLgYcSygesZGaSw4DlUOvLSng07P4Co4YYYkmxMEQZisiHgShCJmVk7PL29o68QajcpbrUtdd8UWJ9vjZ544LoowoWdVUhEYy9PbWskB01IuS6ZK/ihBEMqPsYXqCiNpQ+iNiCdB6IfipJiv7OvCVbZX/bw+3XZQoqJ6ZpFytCKZdFB+wK6Mx9bNe1HAnIokhzdWl3sYgiAcpNgyuO3KWMHtgELEkyAMgjifUy6X4/VOH0eHIqq/L5b+MkfFYksrcB2NMoako/GMZUt3jvUbd2GBpdUVzBUhJQiCMCER8SQIQyCZTLIkmj33Wkt3uLHHRLzikjA9xVVhXYVWKCBQCkdZAhRJx8ELLH9s6+ax7W0o4LJjZvayeAmCIOwPcduNHiKeBGGYFCfFfGVfF7pH3qieBYpLKd0T54zSSqGVxWhNfVWCtm6Pf31xGzkvwBi4+oTZOI5k/BUEYf/IbLvRQ8STIJSB2K336r4ufBP0U6Q4FFPWxtYpi+mjLa1AWdBKkXQ0GWtIuA6eH/Avz28Fwripq5fNHcURCYIgCP0h4kkQysjhRbXuXtrZjnJDERW/uxlbCOLMBSYSU7aQP6rYWqUU2lXoQGEVuK5DLhfk2/vn57bgeT453/JX71g4BqMTBGEyIZan0UPEkyCMEkdFSTFf29NBV2BA60g4QdY3BJBfj7+gDJHAgtLgqSKUAmMsjqNIJByUMnzrt6/jB6Ed68Z3LRqT8QmCMLEJgGCE2icoS08OPEQ8CcIoc9jUwqy5J7a1YowJ6+FFVqb4yy1+S4xf9AyQ8/t/c4yDyB1Ho3xDwtV4vuEfV6/HmADfg1vOWjyKIxMEQTg4EfEkCGPI22fV5Zef3LKXrsCCCg1MxoZCKnblZT0/L6ZsHCjVD0lXk/MNrqPxA4PWDskU3PHYaxhj8H34WxFSgnBQIW670UPEkyCME6fMbcgvP7JxD5kgAKXwjSHjWQJjMAbC0HLw/NAtZy3ofJ6p0jZ7ZjRQSqGUJpGAL/96HdYaHJvj5rOOHb2BCYIwIZBUBaOHiCdBmAC8e8HU/PJvX9vG+pwJE2oC1hg8P6qdpwriKc4ZZS3k/L7m7YVorTAmTIOAdoAKvvLIq+FOY7n5TLFICcKBiFieRg8RT4IwwXjHYbN4R7T89IYtvLC39MvLdXV+hp61FmNMXlAFQf8iynUUfs/XSK342qOvkvUsWitOmKo45/jDyjwiQRCEA4veyWgmIJs2beLqq69mwYIFVFRUcOihh3LbbbeRy+Xyxzz22GO8//3vZ+bMmVRVVXHcccfxox/9aL9tb968mfPOO4/KykqmT5/OX//1X+P7/mgORxAGzVsPncvHT5zHx0+cx1sbQtEUBAZjQtHk+QFZz+QtUcEwbOyBhYQTzuB7YZ/lK4+8mv+0tbWNwqgEQRgLYrfdSD9CbyaF5Wnt2rUYY/je977HokWLWLNmDddccw2dnZ3ccccdADz55JMsXbqUz372s8yYMYOHHnqIK664grq6Os4///w+2w2CgPPOO4+mpiaefPJJtm/fzhVXXEEikeDLX/7yWA5REPbLcYfO4bhDw+WHn32dFzMGpTRKge8H/X7Jxe69gYSV1hqCMMYqzu+pgX96thloxlGKOSm49BSxSgnCZEEKA48eyk7SO/O1r32NlStX8vrrr/d7zHnnnceMGTP4wQ9+0Of+n//855x//vls27aNGTNmAHDXXXfx2c9+ll27dpGMapj1JJvNks1m8+ttbW3MnTuX1tZWamtrRzAqQRg6P3pyPc1ef3ttFHQOvrG9AspjHKXyFqzi5OiaMGWCE50Yx1zNcOGKd4qQEoSh0tbWRl1d3ag+L+Jr/PrVLVTVjOwane1tnHm4PN96Mincdn3R2tpKQ0PDiI556qmnOOaYY/LCCeDss8+mra2Nl156qd/zVqxYQV1dXf4zd66UyRDGj8tOWcSN7wo/CrDWRLFQNj9bbyDhFDJwLqni4HTHUewM4GuPvsaKVWv5/361Ttx7gjABiQPGR/oRejMp3HY9Wb9+PXfeeWfeZdcXDzzwAM888wzf+973+j2mubm5RDgB+fXm5uZ+z7vlllu44YYb8uux5UkQxpsbirKLf+WRVzHG5AVQXLC4J45SBKb/QPOBcF0H/IBv/247Wjfjarjy6HqmT58+rPYEQSgfkqpg9BhX8XTzzTfz1a9+dcBjXnnlFZYsWZJf37p1K+eccw4XXXQR11xzTZ/nPProo1x11VX8v//3/zjqqKPK2meAVCpFKpUqe7uCUE5ufvfh+eWvP/IyXT64bumffCyc/DDFFFqHEqtQaq/3N2coxmzehee6Dl42QGuFb+Del1qwa1pQSvHXp4trTxCEA49xFU833ngjV1555YDHLFxYKHi6bds2Tj/9dE455RS+//3v93n86tWred/73sc3vvENrrjiigHbbmpq4umnny7ZtmPHjvw+QThQuOHdR+aXb/zB76idWY3ruvg2tEYVxzrFcslRisDG+aUKVqv9h0kqLBZF6NpTCqZWpbjqxHllGo0gCINB8jyNHuMqnhobG2lsbBzUsVu3buX0009n2bJl3H333eHsoB489thjnH/++Xz1q1/l4x//+H7bPPnkk/n7v/97du7cmXczrFq1itraWo488sj9nC0Ik5N//Ojb8ssf/+ffMaXeZUp9NcUhkI4iL5yGExjpaFWS/bwt6/P9ZzbjuprT6hwWLpw5zN4LgjBYxG03ekyKmKetW7dy2mmnMX/+fO644w527dqV3xdbiB599FHOP/98/uqv/ooPfvCD+ZilZDKZDxp/8MEHueWWW1i7di0AZ511FkceeSSXX345//AP/0BzczOf+9znWL58ubjlhIOC73+sIKSuuPNxAA4/bAokEqBUfpZdjOOE2cohdNmFrruBv12thcAYPC/AdTW/7bA8uWY7jlZceqRYeAVBmHxMCvG0atUq1q9fz/r165kzZ07JvviL+95776Wrq4sVK1awYsWK/P53vetdPPbYY0A4+27dunX5fY7j8NBDD/HJT36Sk08+maqqKj7ykY/wpS99afQHJQgTjB9+6p1AmIrjU/f+AQNUV8KcOQ0opTAGgqAQ6wThz2zO5GvtxYR/l8WuvoI7MDBh4eLAWP7j5WYcBxrQnLFYgswFoZyI2270mLR5niYSY5G3QxDGg/b2dq7/95fQGqqrNDOb6olFkbWGTM5G8VLhtoRTSG1QHCflOIqk61BZkQAgmXDC7VqRiMrNABiT4ZIj5o/R6ARh7BnLPE8/XbOxLHmeLjh6gTzfejApLE+CIIwPNTU1/PPHQ9deW1sbf/OT0OXtOIoZ01K4yTQAWoVCCHoLJ6XA0RpHF9aLCddVVJ8vzf2v7AAsabeD9x+2CEEQhofEPI0eIp4EQRgUtbW13HXVW/Prn/rXZ0F7JFMOtRUJKiKrUk/hpLUKBZQTW5sGCkFXKGWxVuHZWn68rpnNW3dy+rxqTli0cIDzBEEQxg4RT4IgDIs7L39LfvmWn/6JnDF0dPjMnVmd355wHbRWpBIOrju4eXtxTFUQWFIJzbzZM3g1Z3jhD2/w2httHDHF4Yp3yWxYQdgfxhZmzY6kDaE3Ip4EQRgxKy5Yml/+6kN/YPNeH6UUJxxdmE3naIVShfgoRyvcfIxUfy0rHA3GaJJugsPmT0G7mpseeAHfWio1fPmi40drWIIwqRG33egh4kkQhLLy2fMLYub2B55la1vAiUsbSVZWAGG4udahKNI98kFBbyGlCK1RCdfBNxZj4bgjplNTkSDwPT5933OgQKH41qUnjO7gBEEQEPEkCMIoctvFBdfejf/6O5K11Rx72BQcJ/zq6V1Sz+bFUxwrVfzmqwhTHTiuJusHVCSTvOekeQTW8uRvX+fq7z0FwAlzKlh+3nGjNi5BmAxIqoLRQ8STIAhjwj9eXkjI+ZkfPceCWQlmzZpOIfVBqdXJdUKrlLGxoLL5XFFaqRKRFQTw9nceigb2tXezavUb/O5bYdLP686awUlHFOr8CcLBgoin0UPEkyAIY843L1uWX771Z2tYevg0YhEVuug0CktgC9YpzwsXtFKUfp0rHGUx0cn1NRWce8ah5HzD3pZWvvG/2+B/twHwHzedNsojEwThYEDEkyAI48rfv//o/PJ/rNlCIpnEGBMGu0bCKQgCfGsxxpJMOPiBzSfaBChOe66UIp0M46MaptRz9pl1BIHh1Ve3cek/ribMda749xvfNXaDFIRxQALGR4/h1PwUBEEYFT509Fw+cPgMaoMAzwvw/YCs55MLQuHkOhplLY6CRFFJGNvjG15rhatjS1Y4w+/ww2fznncfyllnLKK20nDJPzzKJf/wKMvvfGwMRygIY4fB5l13w/4wePW0YsUKTjzxRGpqapg+fToXXHBBSUk0gObmZi6//HKampqoqqrihBNO4Cc/+cl+2/7ud7/LIYccQjqd5qSTTuLpp58e8v0oJ2J5EgRhwvGeI2bll//txW1hCRjH4hvQGtJJNwwoJ8xobiiupNcbrTUmMmNZC6eccjiOo8Eafv3Ya3zoa48BMKtO8/WPnzpq4xKEA5nVq1ezfPlyTjzxRHzf52//9m8566yzePnll6mqqgLgiiuuoKWlhf/+7/9m2rRp3HfffVx88cU8++yzHH9832lH7r//fm644QbuuusuTjrpJL75zW9y9tlns27dOqZPH5+amFLbrgxIbTtBGH0een13FDIeyiRN6IDzTVisWMeZza0lGxi6swFBkUXK9wsFjOPUB0SteV5Azvf59SMb88efc2wjHz2n4FIUhHIwlrXt7nl2PZXVNSNqq6ujnSvfsmhY/d21axfTp09n9erVnHpq+FJSXV3NypUrufzyy/PHTZ06la9+9at87GMf67Odk046iRNPPJHvfOc7ABhjmDt3Lp/61Ke4+eabhzmykSGWJ0EQJgXnL5wGhJamn23YTRBtLxFOgG8tnh+6+fL08Y5orUVHLj034WCAs84Ma+kFgc+qx99g1UuPAYovf2AeCxYsGJ2BCcIoYUyPv4NhtgGhICsmlUqRSqUGPLe1tRWAhoaG/LZTTjmF+++/n/POO4/6+noeeOABMpkMp512Wp9t5HI5nnvuOW655Zb8Nq01Z555Jk899dRwhlQWRDwJgjCpUEpxwaJGAH7++m68KMeBsRbfWLKewQtKIzX6m25dXKQ44SgCBX5gcRyXM047FAjjp76+egu7/2szAP942WJmNTX11ZwgTCjKmapg7ty5Jdtvu+02vvjFL/Z/njF85jOf4e1vfztHH12w4D7wwANccsklTJ06Fdd1qays5MEHH2TRor6LgO/evZsgCJgxY0bJ9hkzZrB27dphjmrkiHgSBGHScm5kjQK4549b+zzGWtsrGadSYakYa4sEVJzKHFs8eQ9jLMcfGz44tFb8v99v47VN6zAG7rteZuwJBwdbtmwpcdvtz+q0fPly1qxZw29/+9uS7Z///OdpaWnh17/+NdOmTeOnP/0pF198MY8//jjHHHPMqPR9NBDxJAjCAcGVx84GYPPmbfxqV1AigIB8vBMU3Hw2Wg6KMpsDvc6NMcayYEETiw6dSTrl8P+eeo2HfhXGSf3strPKPiZBGAnG2JK4v+G2AVBbWzvomKfrrruOhx56iN/85jfMmTMnv33Dhg185zvfYc2aNRx11FEAHHvssTz++ON897vf5a677urV1rRp03Achx07dpRs37FjB03jaAEW8SQIwgHFvHmz+Ni8cPnx9W/yWnthn9YqH+cEYXFiPzAoQnddzECeDmMtGoXnGaZOq+Ojf3E8QWC45/mNPPg/r6KV5sEvvGcURiYIQ6OcMU+DwVrLpz71KR588EEee+yxXnGCXV1dQBizVIzjOPnZsD1JJpMsW7aMhx9+mAsuuCDqk+Hhhx/muuuuG8JIyouIJ0EQDljeuWgO74yWf/bydtqLvp8drfJv5Z4foLXC902/VicouPjCGnuFcjGOo6mrqeKKDx8PWO7702b+639fY8G0BF+7RlIfCAcHy5cv57777uNnP/sZNTU1NDc3A1BXV0dFRQVLlixh0aJFXHvttdxxxx1MnTqVn/70p6xatYqHHnoo384ZZ5zBhRdemBdHN9xwAx/5yEd4y1vewlvf+la++c1v0tnZyVVXXTUu4wQRT4IgHCS8/8iZ+eX7X95GxgswhkgAWYJg/2/YJTFSEcaCjmb8hcG1iorKCi67aClg+Y8XN/Nf/7eBa0+fyRlvXVLGEQnCwIx1bbuVK1cC9Jo5d/fdd3PllVeSSCT4v//7P26++Wbe97730dHRwaJFi7j33nt573vfmz9+w4YN7N69O79+ySWXsGvXLr7whS/Q3NzMcccdxy9+8YteQeRjieR5KgOS50kQJi//8vyWAd10ELn7tMIYi6NVmOlcQSrphG5AFVqjfFNavLgYYw179rTzs/9Zzy0XHcY7jjt0VMYjTGzGMs/Td37zMhUjzPPU3dHOdaceKc+3HojlSRCEg5qrTyhMwf6X57aUpDiIY6Ni4aQj4WQBV2sUodVpMLhaM/X/b+/O46Oo78ePvz4zs7u5E64kXCL3UfGAthRaFRQxFhSEikcVD0SLaH8ebdVv8WqtVKVqay3aCqitKFKMB1qVW6mASkFFEQxyk4CCJBCS7M7M5/fHbDZZckDIbi7fz8djNDvzmc/M5/OA7JvP2SaNqyYMIB+Yt34Hz7/8BaN/0Jarz6t+ZWUhRNMkwZMQQoRNHFgRSL31xS52l3ihVHng5DO9ga6mobAsb7mDcq7WR90FzFJgG173n/YFuOqyUwlYBo+9/SnLVhcw7KRW/L+x3495ucR3U0MPGP8ukeBJCCGqkdOnY+Tntdvy+fwgkZYnwyDSXQfAEbvXH9llFxEejV7eTehoTdB26denI9/r0xETl/F/XILran416kR+dLJ07YnjJ8FT/EjwJIQQR3Fal/aUd6zt2vU1H5USbj7yBpzXNtbcW3azZi7eFG+UwjAtbrh8AKApLC1j/INLAZh6YVdO7nViDEoihIgFCZ6EEKIOOnZsR3mbVFFREQv3lEauVdfi5C3E6f18tJlLWmtv9XMUgYQEJl92KmjNk298yrevb8UwDJ6/RZY+EMemoWfbfZdI8CSEEMcpLS2NceEZSMXFxbyTfxgvXKoIoiI9e1rjanBdL5gq7w05Mtyq/FkphQYuGnUySkFZaRlX/vU90PDsTacjRG0cXf8Vxh0JnqolwZMQQsRAcnIyF/ZIBrwWqcV7SylfR9kJrydVvoiyq4mMm/KbRmTgecX/qy7UaShFICHAhPO/h6NdJvz1PZyQlpYoUSMZ8xQ/EjwJIUSMpaWlcWG4RWrv3r0s/za6Rak8cDIBs9Kq5RAeH1V5n73K96HABNcxuPz8ftiOy29f/JDsBLhpzA/iVh4hRDQJnoQQIo4yMzO5KNP7+eDBgyzdU4qhvC1dzEpjpHymERlcXh47KbwB5REK0AoDjYvCMAyGDOqK7bhMmrGMf0we2gAlEs2FjkHLk5aWp2pJ8CSEEA0kNTWVC1K9FZ837jxAPlB5jFTVryld40eF12qlUGjDYNQ5/Zi/aQ/ZSvHjnpnxeH3RzMiA8fiR4EkIIRpB704Z9A7/vGznAY4caI7WkVan8rFQ3mfvfPTAcu8/SkEBMH/THtKVYrgEUULEhQRPQgjRyIZ2ygAgGAyyYk9xlRl3lWfnlTcEuHjnytNGzdpTikJg/sYC/C6c3zc7nq8vmigZMB4/EjwJIUQT4ff7OauzH4B3dx1Au643S688YHI1ji7vvdORa1rXsBCnYXDIcZmzfjdpjmbUKR2rSyVaKNetf/DjukdP810kwZMQQjRBZ3TMiPz8zrZ9qMrjorTGCX/QaG+F8hr4fYpQyOCAdnj2412kKs3YkzvF89WFaPEkeBJCiCZuRJc2ALy5ZR8q3MbkQnhPPW8MlOPqyKip6FDKO2OaJrbrUKQVs9buIC2g+Fk/CaJaMkfrei9yKYtkVk+CJyGEaCZ+2tULonLXb8NISASlvOnoVARMR37VKbwtX8pbpwylcFEUlWhmrd1JUsDgkn4dGqwMouF43Xb1z0NUZRw9iRBCiKbkwpO6MLpHJoWFB3GofePhslC4W69SC4KhvIU6/ZYiaMNzn+zmpc93xf29hWgpJHgSQohmasKAbjzx2PsUFh6q9rprly9u4HW/WOEpeVqDMkApA8dx8VkGIdfgmXU7efuTHQ309iLeymfb1fcQVUm3nRBCNGNLnhjDWb94Ge1qxl7al/YdWuO64FRaxsB1NbajvS477Y2NCtlgmdFp/D6TXUGH5z7ZTaZPkdO3fSOVSsSCLFUQP9LyJIQQzdySJ8cC8O9/fsZfp69g585vcB0X23UJhhxCjosRHvekXe112wGudlFGxSw+pRSGAbbj8I2tmfNZPm9/ubfxCibqRaMjq4wf76Fr7RT+7pLgSQghWoClfx8XaUZ65fnP+ftjK8jP3xe57mqNE25FsB1NIGARsr3B5IpKi2xWWoxTKShyYf6Xe/nPlm8arCxCNHUSPAkhRAuxfOZFgAbHBQ0L5m/i2b9/yN5d32LbLtrVmAoS/CZlIQfLNPBZBkHba4HS2muVwssF01CRbpugq1nw1Te88ZUEUc2FjHmKHwmehBCiBVn2j4tIS8Mb9BSeq/7G3M/4519Xsnf3PjAMXA0+ywucQraLYXhbwARtb0VzI7xPnj7ii1OFm6he3/w1r27+ujGKJ+rAcXVMDlGVBE9CCNHCLHjiEl784xkQCve9AcoweHPuBv7+h2Xs3rYHhfflapkVgRPhL0vDMFCAiyq/PUJ7g6NQwKubv2aBBFHiO0iCJyGEaIHat2/P8tnjcRy74qQLmLDgXxt46uF3yS/YTzDoUBZ0cBwXF41lmhgKTNP7elBKVfqi8CIpAzDDUZXWsGzHflbsLmyoooljJN128dMsgqetW7cyceJEunbtSmJiIt27d+eee+4hGAxG0ixbtozRo0fTvn17kpOTOfXUU3n++eePmrdSqsrx4osvxrM4QgjRYJY/dRHKZ6IdByCyR54ZsHjz5U089/RHFB84SMBn4rdMLMMLnLTWWKaBYUBF85OO/Lf8jDIUxSEXx3FYsbuQ/0oQ1WTUd6Zd+SGqahbrPH3xxRe4rstTTz1Fjx49WL9+PZMmTaK4uJjp06cD8P7773PyySdz++23k5WVxYIFC5gwYQLp6emMGjWq1vxnz55NTk5O5HNGRkY8iyOEEA1q2dM/4y/PLGPeonxvHJPhBT1KKXBdXv73F2hHc/Hl36NNu1aAtwI5eOOfDAWWocIz8FRkP71yjq6Y0O43FSt2F+K6mjM6ZTRkMYVoMErXth13E/bwww8zY8YMvvrqqxrTjBw5kqysLGbNmlVjGqUUubm5jBkz5rjfpaioiPT0dAoLC0lLSzvufIQQIp6CwSBnXfFvAHwZAZRleoPKDQNMUFphJfn42ZgeZGa2itxXOXDSWqMU2OHuHMtQuBrSfAamaeIzvODK0RrXhaDjMrxL60Ypb1PUEN8X5c+46Z//JZCUUq+8yg4f4vErfizfb0doFt121SksLKR169r/Qh5LGoApU6bQtm1bfvjDHzJr1iyOFk+WlZVRVFQUdQghRFPn9/tZMfcygKjuGO24kcBJGZD7Rh5/uncxGz7ZjhVeu0BVuqfyOJiQo0k0wKn0nMgdCizTYPH2/by9dR+iYcmYp/hplsFTXl4ejz/+ONdff32NaV566SU+/PBDrr766lrz+t3vfsdLL73EwoULGTduHDfccAOPP/54rfdMmzaN9PT0yNG5c+fjKocQQjSGFXMvg0Oh6NWjw4M4TEtxaGsR2tUseHEjf5y6kLfeWIcdHv/iVOqyU+HJfJZlRsaAGEpFcjXwAimlFIZSLNy2n7e37OPw4cMNUk4h4qVRu+3uuOMOHnzwwVrTbNiwgT59+kQ+79q1izPPPJOhQ4fy9NNPV3vP0qVLGTVqFDNmzGDChAl1eqe7776b2bNns2NHzZtjlpWVUVZWFvlcVFRE586dpVlTCNGsPPT0It76qAgNBDICKENRcvAw7rc2bshF+cLjopQXAPXom8EFPxsQCY4STUXAZ6K0xgzP0vMZCtvVOBpvOxjttVjZrhd8GYbCdryuvxFdWnv5f4c0ZLfd5NnvxaTbbsbVp8v32xEaNXj6+uuv2bev9qbcbt264ff7Adi9ezdDhw7lRz/6Ec888wyGUbXhbPny5YwcOZJHHnmE6667rs7v9MYbbzBq1ChKS0sJBALHdI+MeRJCNFe2bXPOja9iJlv4/H6KdxR6gZOlUGY4eDKMyCBzFPTpkcYll34fAMs0ATAU+A1FyNW4unxfNbyfw1vDlAdPrsa7YHhjp37atW0j1kDDasjg6fqn341J8PTUtWfI99sRGnW2Xbt27WjXrt0xpd21axfDhg1j4MCBzJ49u9rAadmyZYwaNYoHH3zwuAIngHXr1tGqVatjDpyEEKI5syyLpU+O46ybcnF9Ff+WjrQIGUZ0IAVs2lbM76Ytp1Wq4jc3D0MpLxYKhVucCAdO5Wr6F7rCm8n35pZ9hFyX0d2P7ftAHCPXRbvu0dMdJQ9RVbMY87Rr1y6GDh3KCSecwPTp0/n6668pKCigoKAgkmbp0qWMHDmSX/7yl4wbNy5yff/+/ZE0ubm5UV2Ar7/+Ok8//TTr168nLy+PGTNm8MADD3DTTTc1aPmEEKKxLXn8QtxQCPwV5yJdduXLGhjhVqhwNPTtQc2dv1+M5YQIOV7rktbhwCnc6uRqDVqj0dV20ZnKO/xK8ermr3ldViwXzUCzWOdp4cKF5OXlkZeXR6dOnaKulfc6Pvvssxw+fJhp06Yxbdq0yPUzzzyTZcuWAd7su40bN0au+Xw+nnjiCW655Ra01vTo0YNHHnmESZMmxb9QQgjRxCz802hu+fNCPny/IoBRZjhoKt/YTmui92xR/OqBFbRNgid+M4zPShwIL22gCc/4wvtgGIQDL+1tOlz54YbCcLxuvVc3f42hFOd3++5058WDq+s/W04Wyaxes13nqSmRMU9CiJbmJ5fNwfCZGH4TwzLCLU6VAicDDJ+BYRqYlhcVhQ7bLPrzaFzXZeH2b4GK2XZK4bVG4W04bJpePo6rvX328MY/GeG1pBzt/Qy0qCCqIcc8TZyxBH9i/cY8BUsOMXPyWfL9doRm0W0nhBCiYa2Ycxnadr0VyY9kgJVg4U/0eYO+gw52mQuG4pxbX8cwDM49sQ3nntiGcA9eRRdeeDNiHR5I7kJ4nFSlLV+OeNzrX33Dou37EaKpkOBJCCFEtd57/lJwXI7snzB8BqbPwA46uEEX7Whcx/WWJnA1Z9/8Ku8s/hyAc09s4y1JgLc8gTK8IEqjsb0Jd2gIL29QNVArD6TKHM3yHd/y7q4D8SxyiyKLZMaPBE9CCCFqtPyZixnSKxA168rrqjPRjjeWqTxocktsnFIbHXKYNv8LzrpxfuSec7q04ZwubbBdL2jy1oHyuvHKB5WXq25+l6s1ttZYCt7ddYD3d38bx1K3DK4DrqPreTR2KZomCZ6EEELU6g+3jmTJjLFUXnTAcRx0eHad1hoddFA+g+R2SaS0SyGpTRKJGcnk3LEgKq/zurbljHYJBB0Xx3WxHTeysbBlGJH8jGpm5imInLe1Ytn2/byxeW8cSy5E9SR4EkIIcUyW/G0saI1jV2qOUKDLHJTfIKVtEq6jKS0OEiq1CZXZuA6M+HV0AJWcnMzo7u0YlOp9BVlKYaqKDYUrdxRpooMmlIp05fl9JgmWybwvCpi3fne8it1sSbdd/EjwJIQQ4pgt+duF+LW3wCVUrAXlT/bjumCHvMBKuxrtaOzDQeyDQc664WWmPbMkKq/MzDac370dJ5kVXXVGeB+8yjTe6uVmeCZeZaZh4LdMbAX//HQ38zcWIDza1TE5RFUSPAkhhKiT/zw2mhnX9UMZ5cGMwp9gESoLB06OxikN4QRDGD4LI8HCSLRY/Mkhht/8WpX8unRpy/nd2vK9Gra5swxvqQPTDHfrVbqmFAQMhWV528SUhlxe+LyAN2WxzQY3bdo0fvCDH5CamkpmZiZjxoyJWltx69at4WUrqh7z5s2rMd+rrrqqSvqcnJyGKFKNJHgSQghRZ126dGHhI+d7zUKVWoO0qyNT5AzL8rZ2MRRO0MY5HMIpDTHshvnV5tmtqxdE9bUMAqZBgmmQaBkkmQYJlokRnqFXmRMedG6En1nezVdsaxZt28fbW2vfP7Ulc103JsexWr58OVOmTGHVqlUsXLiQUCjEiBEjKC4uBqBz587k5+dHHffddx8pKSmcd955teadk5MTdd8LL7xQr7qpr2axwrgQQoimafGfR3PW5JcJlYUo//e4U+q1OClLgQv24SChb8u8VirH+zL+8bh/8t/5V1SbZ48TWtMD2JB/gG9cLxjSWmNXSmMqFdkOJuhW7KWnNZEFOMtsl4Bl8MZX32C7LqN7ZManEpqoWIxZqsv9b731VtTnZ555hszMTNasWcMZZ5yBaZpkZ2dHpcnNzWX8+PGkpNS+mGcgEKhyb2OSlichhBD1smTGWDoFKg0ir9RYYZeGAyfbAVNjtknAsVzskM2gS2fz4Yef1Zhv3/YZnN4xAx/Rmwtbhje4POS4lNre+lK27T1UqYqGMK9FSmEaCtMwmP/lXl7asCdm5W7qXLe+yxRUBF9FRUVRR1lZ2VGfX1hYCEDr1q2rvb5mzRrWrVvHxIkTj5rXsmXLyMzMpHfv3kyePJl9+xq3RVGCJyGEEPX2j3tH8/yvf4gyVMU3iwbbdrzAKcHAweXQZ18T3FqMXRxCF2l+8X//5ZapNY93ARjUMYMzOmZgOzZB26EkaFMStDkYdChzHIK2ix3+kveZXosUhF8jPDvPCG9AbFqKuRv28K9PdrJ3ryxzcKw6d+5Menp65Ki8h2x1XNfl5ptv5sc//jEnnXRStWlmzpxJ3759GTJkSK155eTk8Nxzz7F48WIefPBBli9fznnnnYfjNN4iVNJtJ4QQIibatm3LOw+P4pxbX8d1XRQKXeaABuUzCG4qBFOR0C2VQOskjICJUopPDmuGXTGHpf+8rNb8zzrB2+Nu/oZ8bLwWJtupGEDu7V+sQINlgM8yK83O82bxOVpjGN7G8O/ssSndsYPhbQxOPLFj3OqlsegYdNuVz7bbsWNH1N52gUCg1vumTJnC+vXrWbFiRbXXS0pKmDNnDnfddddR3+GSSy6J/Ny/f39OPvlkunfvzrJlyzj77LOPpRgxJy1PQgghYmrhI+ejcNB4K5BjQuibUnAgoWMKiZmpWEl+TNPE8pskJPtJ7NKKEb9+/ZjyH9e3PRf3bU+C6235YihI8JsYhoHjgmUaWIaKDCIvVx5HqfBSCD7LwDIVi/a5PL1mG6s2bY9hLTS+WK7zlJaWFnXUFjzdeOONLFiwgKVLl9KpU6dq0/z73//m8OHDTJgwoc7l6tatG23btiUvL6/O98aKBE9CCCFibtFjY/nt+N4ov+EFUCGNkWLhb5WE4TdRgC/B4vDuQxzcVkhR3rcUby/i9J8f+yyqMSd14OcndaCtzwIUPssgwWeQ4jdI9HnPsF3tbQNTzRIH4I2HArAsi0+L4IlVW/nfRllw83horbnxxhvJzc1lyZIldO3atca0M2fO5IILLqBdu3Z1fs7OnTvZt28f7du3r8/r1osET0IIIeJi2KDevPf0xZH1A4yAhRmwUIA/0eLgtgPYh8qwDwVxQzbKUmg0Q8Y+V6fnnNs7k4t6Z5KdaJLiM/EZCtfVhMKz8GytcVzt7aGH1wJVzR7EWKbCVLDy2yD//GQ3H33ZvBfcbOhFMqdMmcK//vUv5syZQ2pqKgUFBRQUFFBSUhKVLi8vj3fffZdrr7222nz69OlDbm4uAIcOHeLXv/41q1atYuvWrSxevJjRo0fTo0cPzj333OOvnHqS4EkIIURc/Xf+Fag2PpxSO/KtU1ZchhNeVNNM9BHISiGQlUxK53TSerXhrFteqfNzftK5Deec2IY0V1NqO4Qcl5DrYrsV++e5LpFxUI7rUjk2MAyFEW6JCtk22zB4fn0+8zc2zxl6Db09y4wZMygsLGTo0KG0b98+csydOzcq3axZs+jUqRMjRoyoNp+NGzdGZuqZpsknn3zCBRdcQK9evZg4cSIDBw7kvffeO+q4q3hS+si17kWdFRUVkZ6eTmFhYdSAOiGEEBUGDP4b6d9vjy/BR+meQ9iHgii/SaBNEv5UP76AFRXAuK7L/WM70L9//+N63ueb9/K5rSPLF1ReC0qjCdkuwZCD1mBZBq6rsW2HkKNJ8ClSkhIiGxX7fAaOAxf3zapXHTTE90X5M8bc+zq+hOR65RUqLeaVe8+X77cjSMuTEEKIBvG/lTdQsmlfxdgjS2H4TawkH/4EC8sy8PksLJ+J1qCUwV25BVw2bfFxPa9f90x+1juLcb2ywkGSFwg5rktZ0CFUKXCC6EUlyweVW5bC0eA43s9zN+xhw+5v6lsVDaLeazyFD1GVBE9CCCEazKq3r6Vfe1Cp3tePmezDCpgYhsI0TWzboazUpqzE5tCBEg7tL2HvnmKG31p1T7y6uOykDlzcN5uDh0McLrUJ2V6XXXng5Djh7UjC6S3L8gaVHxE7GAZ8WtR46wvVRUNvz/JdIsGTEEKIBvXnW0fx5P87DWxvKQOvq87AML2B3mUlNsFDQeyDlY7CIEMn/rvez752YGeuHdgZA2+JA8dxCYUcQrbrrRmlwWd4C2uapsJ2NZVXPChf/mDBl7LA5neZBE9CCCEaXN9ePXn/5QkEvz0cmfkWDNo4jot9OIRzOOTtr2IpbzFNv4HyGwz9RfWbCtfVNQM7c82AzpQGvRXKHdcbUJ7gUyQk+EgIWGhX4zjaW508/G1Z3hB19M1JGl9DDxj/LpHgSQghRKN5f+4VlBaHNw3WYAddbzsXAJ8Kb/eiUKaBMg0Mn8lZN77C5VPr141XbsqPTqRD22RapQRom55IWkoiKYkWWruUhVwMBYZheO+BN1uvuXB1DIInmVNWLQmehBBCNKrFj4wmGAxFPru2C8pbyFKFm3yUpTATLawECyvRYm+ZwfBb6hdAzduQT27eXrTWJCdaWJYiFHIoKXNwHI0Z7k60rPLAyevWMwzFWe2T6vXshiAtT/EjwZMQQohG98bvf4pR+RvJALQXtChTYYZXDFeGgTIMb9FNn8GIXy+o87O2b9/Bcx/vxLJMTFUxokkBiQGThIC31YtlKi9w0hrb1riuFzgpBa1SUupVXtG8SfAkhBCiSXh56jm0TbEiywRghoOn8Iw4ZRho7aJdFzfk4gZdXNtl+M2vcf/s5cf0jCdWbWXhN5rEBB9KRV8zlMLFGxTusyrWm9IoTNM7DAPG9cyMSXnjTTs6JoeoSoInIYQQTcbzd43grzf3BYfIHiqG4Y19Kh8X5Ybcii9311u7aenaA5x906u15v3Eqq0A+CwzfCYcnClvVl05V3tdhuFdZTDDXYg/65XZbAInAO3Wv+tON6MxXg1JgichhBBNyvf69WPZzJ8d0erhdZ+5thsJogC0rb0jHEidNeWVavN88oNtgPelV97ipAkHSuWJtMZUymuB0hVpUmg+rU2iYUjwJIQQokla9tQ4tONULNRYvmil6/0ctWmt4+KW2jglIc68Zh5PvbQ6Ki+nUlrH8cYvob01nLzWJa/LzgnvGmyF047rmck5zTRwkgHj8SPBkxBCiCZr6YxxmK5GVw6gKgdOCtygFzS5ZTZuqY1bZvOvV7/i9MteAGD2up2RW128Kfy242K7GhcdWbvJUgrLUCilGN2zeXXRVUe7bkwOUZUET0IIIZq0tx8dzd+nnIQXNR1x0XbRQccbB4XGTPFhBCyMBAsj1ceZ18wDwjFXuH+urMyhLOQdwZBLKLw1S9BxaK81Y3q0a8jiiWbIOnoSIYQQonGdeOKJvPPQiZxz6+tRY6Fcxxs8jgIryY9ru5hJvvBSB/CLmwZy2AHLNAg53qKXroaSMptQSOHzGWitKQ26TPnRiY1WvniIxWw5mW1XPWl5EkII0WwsfOT86BPa68JTlqoInBTgaHAhIRDAMg1v42FDRQ0Qt11NSZmD1QIDJ/DqJRaHqEqCJyGEEM3K4sdHc9vFPbwP4UjICFjgVygz3LSE5vopP8AGEv0Wfp+BZRr4KgVSpqEI+EyubIGBk4gvCZ6EEEI0OyNPP4klT4zBsCq+xkzTqmgpcQFlhTf7NUgIB1B+n0FCwCTBb5KUYNGtdaBR3r8haDcGi2RKy1O1JHgSQgjRbC2ZMRbDZ+AcDnnrPwEoxbU3fD+SptR2SQ6YtElNID0lQHpygFapAdISfZzVtXnPqKuNdNvFjwRPQgghmrXlz17MjDt+iFtqR5YFN62At0p4OKAqtV1sx8FngIXGdjXvr93GDc9+0LgvH0+OG5tDVCHBkxBCiGbvpJO6s3zWRTi2zbXXnQaAaSgcxwugLAW2hjJHE9Jg2y4HilzskOa6p1fzl9c/bOQSiOZEgichhBAtxvInf4ZpJQDeuHHL8gKo0pDGtr0jZGv++9+v+Dq/iD27CinYWciiNd8y+r53GvntY0u67eJHgichhBAtxnPh1cQtS4W3FwHLVFiWd5imNz1v++5iHEd7M+/Kr/sMxvyu5QRQ9R4sHoN1oloqCZ6EEEK0GIGAiWl6gZNheP+3HW+PNsfWOI5mw6bNuK72AikDwtvZEQq6uC5ccO877Ny5s7GLIpowCZ6EEEK0CDP/twPwtmHRLoCOtDp5LUzeuXUfF0fu0Q6RQMuyvDWgDENx46wNXPHHRY1RjJiRbrv4keBJCCFEs/fJ+l0YCkLhYMi0FK4LjhtudXI0tgNr1m4DwLIMtPYCLZ/PwHF0ZO87ANNUFNuaMb9b2EgligHXjc0hqpDgSQghRLP3P0ej8VpbXNfFdXVkjFP5uCatHYrKVMX+LIDjaLT2giXH0ZiWgetqgkEHx3FRBpx/z9uNVi7RNEnwJIQQollbu2F3pf3qXEKOJhhyscNjnGzbpaTM4QcBePLqH5KZlYJtV7SolLdMmaYiFHQwjPLWKxOFwuczGXv/IrY0s3FQssJ4/EjwJIQQoln7win/SaG1JmS7OK63KGbIdigL2ZQFbbp37wDA368bzH0TekR10wHYjuvdH3QJBCyCZSGKDwYpK7EJBm1uemo9I3/7nwYtW33ImKf4aRbB09atW5k4cSJdu3YlMTGR7t27c8899xAMBiNpNm7cyLBhw8jKyiIhIYFu3boxdepUQqFQrXlv376dkSNHkpSURGZmJr/+9a+xbTveRRJCCBErSmEoA8tUlAdQtu1SFnIpCzmEbM3EAZ2jbjmtWzdy7zonKoDSLvgDBolJfoLBEK4DCUkW/gQLyzKxfCa+gMWFv2/G46BETFiN/QLH4osvvsB1XZ566il69OjB+vXrmTRpEsXFxUyfPh0An8/HhAkTGDBgABkZGXz88cdMmjQJ13V54IEHqs3XcRxGjhxJdnY277//Pvn5+UyYMAGfz1fjPUIIIZqOj/IPEHLCaw0osAyFq719gQEUCqOWZoJX7xnBBfe+g2F4UZTjaAzlEirTJCSYGIaq2DMvTGsYd/8i5k8dHqdSxYZ2NNqoX8uRrPNUvWYRPOXk5JCTkxP53K1bNzZu3MiMGTMiwVO3bt3o1q1bJE2XLl1YtmwZ7733Xo35vvPOO3z++ecsWrSIrKwsTj31VH7/+99z++23c++99+L3++NXKCGEEPWmlMJvKLRShBzXC4J0dLfKhJM71prHa/eO4OI/LKKkUheV5VMYPiO85EFVjqspDYZI8PtiUIr4iEW3m3TbVa9ZdNtVp7CwkNatW9d4PS8vj7feeoszzzyzxjQrV66kf//+ZGVlRc6de+65FBUV8dlnn9V4X1lZGUVFRVGHEEKIhlUSDFHmahITLRxHEwjPlCtf9NILotRR8wGY+9vhTM45saKVSSnQtd/76qrt9SxBnDk6BhsDS/BUnWYZPOXl5fH4449z/fXXV7k2ZMgQEhIS6NmzJ6effjq/+93vasynoKAgKnACIp8LCgpqvG/atGmkp6dHjs6dO9eYVgghRHwYCgwNWYk+UpN9KBQohVIKUymSEywuP7nDMed33o968erd5xKybRzbrTKg/EgZydI78V3VqMHTHXfcgQr/Qa/p+OKLL6Lu2bVrFzk5OVx00UVMmjSpSp5z587lf//7H3PmzOGNN96IdOvF0p133klhYWHk2LFjR8yfIYQQonYBnw9XeeObOib7aZfiJzPFR2aKj84ZCbRPCRxXvq/fm4PGW66gNiMGdDqu/BuKzLaLn0Yd83Tbbbdx1VVX1Zqm8jim3bt3M2zYMIYMGcLf//73atOXtwL169cPx3G47rrruO222zC9dfmjZGdn88EHH0Sd27NnT+RaTQKBAIHA8f2lFEIIETvt/Sa7gw64Gr9pEKg0TmlIx4zjzvftaT/loRdWsDKvBF1N/DC4XzvU0ZqmGpkMGI+fRg2e2rVrR7t27Y4p7a5duxg2bBgDBw5k9uzZGLVNnwhzXZdQKITrutUGT4MHD+YPf/gDe/fuJTMzE4CFCxeSlpZGv3796lYYIYQQDa5r21TSi0vYfMjGCG8lYlkGP8xKrXfev7n0JwBc/MAiymwviFAKbhjZm3MGnFDv/EXz1Sxm2+3atYuhQ4fSpUsXpk+fztdffx25Vt5C9Pzzz+Pz+ejfvz+BQICPPvqIO++8k4svvhifz5sNkZuby5133hnpChwxYgT9+vXjiiuu4KGHHqKgoICpU6cyZcoUaVkSQohmonVyIq2T45f/3P9r2ksS1ERm28VPswieFi5cSF5eHnl5eXTqFN3HXD4zwrIsHnzwQTZt2oTWmi5dunDjjTdyyy23RNIWFhaycePGyGfTNFmwYAGTJ09m8ODBJCcnc+WVV9Y6yFwIIYRoFsLbs9Q3D1GV0keu/iXqrKioiPT0dAoLC0lLS2vs1xFCCNFENcT3RfkzBp79BKaVWK+8HLuENYunyPfbEZpFy5MQQggh6sh1vaO+eYgqJHgSQgghWiDtaLSS2Xbx0CwXyRRCCCGEaCzS8iSEEEK0QDLbLn6k5UkIIYRogbSjY3Icq2nTpvGDH/yA1NRUMjMzGTNmTNQM961bt9a4m8i8efNqLofW3H333bRv357ExESGDx/Ol19+Wa+6qS8JnoQQQoiWqHzAeH2PY7R8+XKmTJnCqlWrWLhwIaFQiBEjRlBcXAx4O4Dk5+dHHffddx8pKSmcd955Neb70EMP8Ze//IUnn3yS1atXk5yczLnnnktpaWm9q+h4SbedEEIIIWpVVFQU9bm6bcreeuutqM/PPPMMmZmZrFmzhjPOOAPTNKtsfZabm8v48eNJSUmp9rlaax577DGmTp3K6NGjAXjuuefIysrilVde4ZJLLqlv0Y6LtDwJIYQQLVAsu+06d+5Menp65Jg2bdpRn19YWAhA69atq72+Zs0a1q1bx8SJE2vMY8uWLRQUFDB8eMUq7+np6QwaNIiVK1fWpTpiSlqehBBCiBZI6xgMGA+vo71jx46oRTKPtoWZ67rcfPPN/PjHP+akk06qNs3MmTPp27cvQ4YMqTGfgoICALKysqLOZ2VlRa41BgmeYqD8D9eRzZpCCCFEZeXfEw2xuYfj1H9MUHkeaWlpdVphfMqUKaxfv54VK1ZUe72kpIQ5c+Zw11131fsdG4METzFw8OBBwGvWFEIIIY7m4MGDpKenxyVvv99PdnY2n62bGpP8srOz8fv9x5z+xhtvZMGCBbz77rtV9qMt9+9//5vDhw8zYcKEoz4bYM+ePbRv3z5yfs+ePZx66qnH/E6xJsFTDHTo0IEdO3aQmpqKUuq48ykqKqJz585VmkeFR+qndlI/tZP6qZ3UT+1iVT9aaw4ePEiHDh1i+HbREhIS2LJlC8FgMCb5+f1+EhISjppOa81NN91Ebm4uy5Yto2vXrjWmnTlzJhdccAHt2rWrNc+uXbuSnZ3N4sWLI8FSUVERq1evZvLkyXUqRyxJ8BQDhmHUGF0fj7o2j37XSP3UTuqndlI/tZP6qV0s6ideLU6VJSQkHFPAE0tTpkxhzpw5vPrqq6SmpkbGJKWnp5OYWLFBcV5eHu+++y5vvvlmtfn06dOHadOmceGFF6KU4uabb+b++++nZ8+edO3albvuuosOHTowZsyYhihWtSR4EkIIIUS9zZgxA4ChQ4dGnZ89ezZXXXVV5POsWbPo1KkTI0aMqDafjRs3RmbqAfzmN7+huLiY6667jgMHDvCTn/yEt956q8GDw8qUbohRa+KYFBUVkZ6eTmFhofzLrxpSP7WT+qmd1E/tpH5qJ/UjKpN1npqQQCDAPffcc9QpoN9VUj+1k/qpndRP7aR+aif1IyqTlichhBBCiDqQlichhBBCiDqQ4EkIIYQQog4keBJCCCGEqAMJnoQQQggh6kCCpxh49913Of/88+nQoQNKKV555ZWo61dddRVKqagjJycnKs3+/fv5+c9/TlpaGhkZGUycOJFDhw7V+tzS0lKmTJlCmzZtSElJYdy4cezZsyfWxYuJxqij/fv3c9NNN9G7d28SExM54YQT+OUvfxm1fkhT0Vh/hspprTnvvPOqfXZT0Jj1s3LlSs466yySk5NJS0vjjDPOoKSkJJbFq7fGqp+CggKuuOIKsrOzSU5OZsCAAcyfPz/Wxau3WNTPH/7wB4YMGUJSUhIZGRnH9FytNXfffTft27cnMTGR4cOH8+WXX8aoVKIxSfAUA8XFxZxyyik88cQTNabJyckhPz8/crzwwgtR13/+85/z2WefsXDhwsieQNddd12tz73lllt4/fXXmTdvHsuXL2f37t2MHTs2JmWKtcaoo927d7N7926mT5/O+vXreeaZZ3jrrbeYOHFizMoVK431Z6jcY489Vq+theKtsepn5cqV5OTkMGLECD744AM+/PBDbrzxRgyjaf3qbKz6mTBhAhs3buS1117j008/ZezYsYwfP561a9fGpFyxEov6CQaDXHTRRXXaEuShhx7iL3/5C08++SSrV68mOTmZc889l9LS+m/YKxqZFjEF6Nzc3KhzV155pR49enSN93z++eca0B9++GHk3H/+8x+tlNK7du2q9p4DBw5on8+n582bFzm3YcMGDeiVK1fWqwzx1lB1VJ2XXnpJ+/1+HQqF6vraDaah62ft2rW6Y8eOOj8/v9pnNzUNWT+DBg3SU6dOre8rN6iGrJ/k5GT93HPPRZ1r3bq1/sc//nFc794Qjqd+Kps9e7ZOT08/ajrXdXV2drZ++OGHI+cOHDigA4GAfuGFF+rwxqIpalr/fGrBli1bRmZmJr1792by5Mns27cvcm3lypVkZGTw/e9/P3Ju+PDhGIbB6tWrq81vzZo1hEIhhg8fHjnXp08fTjjhBFauXBm/gsRRrOuoOuWrA1tW89uZKB71c/jwYS677DKeeOKJyO7lzVWs62fv3r2sXr2azMxMhgwZQlZWFmeeeSYrVqyIe1niIR5/foYMGcLcuXPZv38/ruvy4osvUlpaWmV7juagtvo5Hlu2bKGgoCDqd3R6ejqDBg1qtr+jRYXm9w3SDOXk5DB27Fi6du3K5s2b+b//+z/OO+88Vq5ciWmaFBQUkJmZGXWPZVm0bt06srHikQoKCvD7/VX63rOysmq8pymLRx0d6ZtvvuH3v//9MXdlNSXxqp9bbrmFIUOGMHr06HgXIa7iUT9fffUVAPfeey/Tp0/n1FNP5bnnnuPss89m/fr19OzZM+7lipV4/fl56aWXuPjii2nTpg2WZZGUlERubi49evSId5Fi6mj1czzK6y0rKyvqfHP9HS2iSfDUAC655JLIz/379+fkk0+me/fuLFu2jLPPPrsR36zpiHcdFRUVMXLkSPr168e9995b7/waWjzq57XXXmPJkiVNbnzK8YhH/biuC8D111/P1VdfDcBpp53G4sWLmTVrFtOmTav/izeQeP39uuuuuzhw4ACLFi2ibdu2vPLKK4wfP5733nuP/v37x+LVG4T8jhZ1Jd12jaBbt260bduWvLw8ALKzs9m7d29UGtu22b9/f41dKdnZ2QSDQQ4cOBB1fs+ePc2++wViU0flDh48SE5ODqmpqeTm5uLz+eL23g0lFvWzZMkSNm/eTEZGBpZlRboyx40b1yy7XSqLRf20b98egH79+kWd79u3L9u3b4/DWzecWNTP5s2b+etf/8qsWbM4++yzOeWUU7jnnnv4/ve/X+vA7ObgyPo5HuX1duQM6JbyO/q7ToKnRrBz50727dsX+eU8ePBgDhw4wJo1ayJplixZguu6DBo0qNo8Bg4ciM/nY/HixZFzGzduZPv27QwePDi+BWgAsagj8FqcRowYgd/v57XXXiMhISHu794QYlE/d9xxB5988gnr1q2LHACPPvoos2fPjnsZ4ikW9XPiiSfSoUMHNm7cGHV+06ZNdOnSJX4v3wBiUT+HDx8GqDLz0DTNSKtdc3Vk/RyPrl27kp2dHfU7uqioiNWrV7eI39HfeY09Yr0lOHjwoF67dq1eu3atBvQjjzyi165dq7dt26YPHjyof/WrX+mVK1fqLVu26EWLFukBAwbonj176tLS0kgeOTk5+rTTTtOrV6/WK1as0D179tSXXnpp5PrOnTt179699erVqyPnfvGLX+gTTjhBL1myRH/00Ud68ODBevDgwQ1a9mPVGHVUWFioBw0apPv376/z8vJ0fn5+5LBtu8HroDaN9WfoSDTR2XaNVT+PPvqoTktL0/PmzdNffvmlnjp1qk5ISNB5eXkNWv6jaYz6CQaDukePHvr000/Xq1ev1nl5eXr69OlaKaXfeOONBq+D2sSifrZt26bXrl2r77vvPp2SkhLJ7+DBg5E0vXv31i+//HLk8x//+EedkZGhX331Vf3JJ5/o0aNH665du+qSkpIGLb+IPQmeYmDp0qUaqHJceeWV+vDhw3rEiBG6Xbt22ufz6S5duuhJkybpgoKCqDz27dunL730Up2SkqLT0tL01VdfHfWXcsuWLRrQS5cujZwrKSnRN9xwg27VqpVOSkrSF154oc7Pz2+oYtdJY9RRTc8E9JYtWxqw9EfXWH+GjtRUg6fGrJ9p06bpTp066aSkJD148GD93nvvNUSR66Sx6mfTpk167NixOjMzUyclJemTTz65ytIFTUEs6ufKK6+sNo/K9QHo2bNnRz67rqvvuusunZWVpQOBgD777LP1xo0bG6jUIp6U1lrHsCFLCCGEEKJFkzFPQgghhBB1IMGTEEIIIUQdSPAkhBBCCFEHEjwJIYQQQtSBBE9CCCGEEHUgwZMQQgghRB1I8CSEEEIIUQcSPAkhhBBC1IEET0IIIYQQdSDBkxDN3FVXXcWYMWOqvVZSUsI999xDr169CAQCtG3blosuuojPPvssKt29996LUopf/OIXUefXrVuHUoqtW7dGnZ8/fz5nnXUWrVq1IjExkd69e3PNNdewdu3aSJpnnnmGjIwMAIYOHYpSqsZj6NChACileOWVV45axsr5BQIBOnbsyPnnn8/LL79c5d6anvniiy9WX6FCCHEUEjwJ0UKVlZUxfPhwZs2axf3338+mTZt48803sW2bQYMGsWrVqqj0CQkJzJw5ky+//LLWfG+//XYuvvhiTj31VF577TU2btzInDlz6NatG3feeWe197z88svk5+eTn5/PBx98AMCiRYsi56oLeo5m0qRJ5Ofns3nzZubPn0+/fv245JJLuO6666qknT17duRZ5UdNAacQQhyN1dgvIISIj8cee4yVK1eydu1aTjnlFAC6dOnC/PnzGTRoEBMnTmT9+vUopQDo3bs3mZmZ/Pa3v+Wll16qNs9Vq1bx0EMP8ec//5lf/vKXkfMnnHACAwcOpKatMlu3bh35ubS0FIA2bdqQnZ193OVLSkqK3N+pUyd+9KMf0adPH6655hrGjx/P8OHDI2kzMjLq9SwhhKhMWp6EaKHmzJnDOeecEwmcyhmGwS233MLnn3/Oxx9/HHXtj3/8I/Pnz+ejjz6qNs8XXniBlJQUbrjhhmqvlwdijeXKK6+kVatWx9WSJYQQx0qCJyFaqE2bNtG3b99qr5Wf37RpU9T5AQMGMH78eG6//fYa8+zWrRuWVdFo/cgjj5CSkhI5CgsLY1SCujMMg169elUZo3XppZdGvWNKSgrbt29vnJcUQjR70m0nRAtWUzdabe6//3769u3LO++8Q2Zm5lHTX3PNNVxwwQWsXr2ayy+//LieGUta6yotYI8++mhUNx5Ahw4dGvK1hBAtiLQ8CdFC9erViw0bNlR7rfx8r169qlzr3r07kyZN4o477qgSCPXs2ZOvvvqKUCgUOZeRkUGPHj3o2LFjvd85NTW12parAwcOkJ6eftT7Hcfhyy+/pGvXrlHns7Oz6dGjR9RRufVMCCHqQoInIVqoSy65hEWLFlUZ1+S6Lo8++ij9+vWrMh6q3N13382mTZuqTOe/9NJLOXToEH/729/i8s69e/dmzZo1Ueccx+Hjjz+uNtA70rPPPsu3337LuHHj4vJ+QggB0m0nRItQWFjIunXros5dfvnlvPrqq5x//vn86U9/YtCgQezZs4cHHniADRs2sGjRohoHeGdlZXHrrbfy8MMPR50fPHgwt912G7fddhvbtm1j7NixdO7cmfz8fGbOnIlSCsM4/n+T3XrrrUycOJE+ffpwzjnnUFxczOOPP863337LtddeG5X28OHDFBQUYNs2O3fuJDc3l0cffZTJkyczbNiwqLQHDhygoKAg6lxqairJycnH/a5CiO8wLYRo1q688koNVDkmTpyoi4uL9W9/+1vdo0cP7fP5dOvWrfW4ceP0p59+GpXHPffco0855ZSoc4WFhbpt27Ya0Fu2bIm6NnfuXD106FCdnp6ufT6f7tSpk77sssv0qlWrImlmz56t09PTq7zvli1bNKDXrl1bbXmef/55PXDgQJ2amqqzsrL0T3/6U/3xxx9HpTnzzDMj5fT7/bp9+/Z61KhR+uWXX66SX3V1A+hp06bVXKlCCFELpXUjj+4UQgghhGhGZMyTEEIIIUQdSPAkhBBCCFEHEjwJIYQQQtSBBE9CCCGEEHUgwZMQQgghRB1I8CSEEEIIUQcSPAkhhBBC1IEET0IIIYQQdSDBkxBCCCFEHUjwJIQQQghRBxI8CSGEEELUwf8HUfp0I2PxBI4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.plot.scatter(x=\"LONGITUDE\", y='LATITUDE', c=\"TEMP\", cmap='RdYlBu_r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/lbesnard/miniforge3/envs/AodnCloudOptimised/lib/python3.12/site-packages/cartopy/io/__init__.py:241: DownloadWarning: Downloading: https://naturalearth.s3.amazonaws.com/10m_physical/ne_10m_coastline.zip\n",
      "  warnings.warn(f'Downloading: {url}', DownloadWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cartopy.crs as ccrs\n",
    "from matplotlib.colors import Normalize\n",
    "\n",
    "norm = Normalize(vmin=df['TEMP'].min(), vmax=df['TEMP'].max())\n",
    "\n",
    "fig, ax = plt.subplots(subplot_kw={'projection': ccrs.PlateCarree()})\n",
    "sc = ax.scatter(df[\"LONGITUDE\"], df[\"LATITUDE\"], c=df[\"TEMP\"], cmap='RdYlBu_r', norm=norm, transform=ccrs.PlateCarree())\n",
    "\n",
    "# Add a coastline\n",
    "ax.coastlines()\n",
    "\n",
    "cbar = plt.colorbar(sc, ax=ax, orientation='vertical', fraction=0.046, pad=0.04)\n",
    "cbar.set_label('Temperature')\n",
    "\n",
    "ax.gridlines(draw_labels=True)\n",
    "ax.set_title('Scatter plot with Coastline')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a TIME and scalar/number filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_time = create_time_filter(parquet_ds, date_start='2010-01-31 10:14:00', date_end='2010-02-01 07:50:00')\n",
    "\n",
    "expr_1 = pc.field('platform_code') == pa.scalar(\"VNCF\")\n",
    "filter = expr_1 & filter_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 11038 entries, 0 to 11037\n",
      "Data columns (total 18 columns):\n",
      " #   Column                     Non-Null Count  Dtype         \n",
      "---  ------                     --------------  -----         \n",
      " 0   filename                   11038 non-null  object        \n",
      " 1   LATITUDE_quality_control   11038 non-null  float64       \n",
      " 2   LATITUDE                   11038 non-null  float64       \n",
      " 3   LONGITUDE_quality_control  11038 non-null  float64       \n",
      " 4   LONGITUDE                  11038 non-null  float64       \n",
      " 5   DEPTH                      11038 non-null  float64       \n",
      " 6   CPHL                       3931 non-null   float64       \n",
      " 7   CPHL_quality_control       3931 non-null   float64       \n",
      " 8   TIME                       11038 non-null  datetime64[ns]\n",
      " 9   TURB                       3091 non-null   float32       \n",
      " 10  TURB_quality_control       3091 non-null   float32       \n",
      " 11  TEMP                       3953 non-null   float32       \n",
      " 12  TEMP_quality_control       3953 non-null   float32       \n",
      " 13  PSAL                       63 non-null     float32       \n",
      " 14  PSAL_quality_control       63 non-null     float32       \n",
      " 15  platform_code              11038 non-null  category      \n",
      " 16  timestamp                  11038 non-null  category      \n",
      " 17  polygon                    11038 non-null  category      \n",
      "dtypes: category(3), datetime64[ns](1), float32(6), float64(7), object(1)\n",
      "memory usage: 1.1+ MB\n",
      "CPU times: user 415 ms, sys: 131 ms, total: 546 ms\n",
      "Wall time: 6.12 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# using pandas instead of pyarrow so that filters can directly be applied to the data, and not just the partition\n",
    "df = pd.read_parquet(dname, engine='pyarrow',filters=filter)\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_sorted = df.sort_values('TIME')\n",
    "\n",
    "# Create a list of segments\n",
    "points = np.array([df_sorted['LONGITUDE'], df_sorted['LATITUDE']]).T.reshape(-1, 1, 2)\n",
    "segments = np.concatenate([points[:-1], points[1:]], axis=1)\n",
    "\n",
    "# Create a LineCollection with segments colored by temperature\n",
    "norm = plt.Normalize(df_sorted['TEMP'].min(), df_sorted['TEMP'].max())\n",
    "lc = LineCollection(segments, cmap='RdYlBu_r', norm=norm)\n",
    "lc.set_array(df_sorted['TEMP'])\n",
    "lc.set_linewidth(2)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.add_collection(lc)\n",
    "ax.autoscale()\n",
    "ax.set_xlabel(metadata['LONGITUDE']['standard_name'])\n",
    "ax.set_ylabel(metadata['LATITUDE']['standard_name'])\n",
    "ax.invert_yaxis()\n",
    "\n",
    "# Adding color bar\n",
    "cbar = plt.colorbar(lc, ax=ax)\n",
    "cbar.set_label('Temperature')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}