{ "cells": [ { "cell_type": "markdown", "id": "25c8380d", "metadata": {}, "source": [ "# Seasonality Charts\n", "\n", "This script allows you to plot seasonality charts for Spark30S and Spark25S freight rates.\n", "\n", "This script uses elements from our API code samples. If you'd like a more basic and informative example of how to pull data via the Spark API, please visit our Github or API website:\n", "\n", "- Github: https://github.com/spark-commodities/api-code-samples/blob/master/jupyter_notebooks/\n", "- API Website: https://www.sparkcommodities.com/api/code-examples/jupyter.html\n", "\n", "\n", "### Have any questions?\n", "\n", "If you have any questions regarding our API, or need help accessing specific datasets, please contact us at:\n", "\n", "__data@sparkcommodities.com__\n", "\n", "or refer to our API website for more information about this endpoint:\n", "https://www.sparkcommodities.com/api/request/contracts.html" ] }, { "cell_type": "markdown", "id": "c5716130", "metadata": {}, "source": [ "## 1. Importing Data\n", "\n", "Here we define the functions that allow us to retrieve the valid credentials to access the Spark API.\n", "\n", "__This section can remain unchanged for most Spark API users.__" ] }, { "cell_type": "code", "execution_count": 13, "id": "33fb0640", "metadata": {}, "outputs": [], "source": [ "import json\n", "import os\n", "import sys\n", "import pandas as pd\n", "import numpy as np\n", "from base64 import b64encode\n", "from pprint import pprint\n", "from urllib.parse import urljoin\n", "from datetime import datetime\n", "\n", "\n", "try:\n", " from urllib import request, parse\n", " from urllib.error import HTTPError\n", "except ImportError:\n", " raise RuntimeError(\"Python 3 required\")\n", "\n", "\n", "API_BASE_URL = \"https://api.sparkcommodities.com\"\n", "\n", "\n", "def retrieve_credentials(file_path=None):\n", " \"\"\"\n", " Find credentials either by reading the client_credentials file or reading\n", " environment variables\n", " \"\"\"\n", " if file_path is None:\n", "\n", " client_id = os.getenv(\"SPARK_CLIENT_ID\")\n", " client_secret = os.getenv(\"SPARK_CLIENT_SECRET\")\n", " if not client_id or not client_secret:\n", " raise RuntimeError(\n", " \"SPARK_CLIENT_ID and SPARK_CLIENT_SECRET environment vars required\"\n", " )\n", " else:\n", " # Parse the file\n", " if not os.path.isfile(file_path):\n", " raise RuntimeError(\"The file {} doesn't exist\".format(file_path))\n", "\n", " with open(file_path) as fp:\n", " lines = [l.replace(\"\\n\", \"\") for l in fp.readlines()]\n", "\n", " if lines[0] in (\"clientId,clientSecret\", \"client_id,client_secret\"):\n", " client_id, client_secret = lines[1].split(\",\")\n", " else:\n", " print(\"First line read: '{}'\".format(lines[0]))\n", " raise RuntimeError(\n", " \"The specified file {} doesn't look like to be a Spark API client \"\n", " \"credentials file\".format(file_path)\n", " )\n", "\n", " print(\">>>> Found credentials!\")\n", " print(\n", " \">>>> Client_id={}, client_secret={}****\".format(client_id, client_secret[:5])\n", " )\n", "\n", " return client_id, client_secret\n", "\n", "\n", "def do_api_post_query(uri, body, headers):\n", " url = urljoin(API_BASE_URL, uri)\n", "\n", " data = json.dumps(body).encode(\"utf-8\")\n", "\n", " # HTTP POST request\n", " req = request.Request(url, data=data, headers=headers)\n", " try:\n", " response = request.urlopen(req)\n", " except HTTPError as e:\n", " print(\"HTTP Error: \", e.code)\n", " print(e.read())\n", " sys.exit(1)\n", "\n", " resp_content = response.read()\n", "\n", " # The server must return HTTP 201. Raise an error if this is not the case\n", " assert response.status == 201, resp_content\n", "\n", " # The server returned a JSON response\n", " content = json.loads(resp_content)\n", "\n", " return content\n", "\n", "\n", "def do_api_get_query(uri, access_token):\n", " url = urljoin(API_BASE_URL, uri)\n", "\n", " headers = {\n", " \"Authorization\": \"Bearer {}\".format(access_token),\n", " \"Accept\": \"application/json\",\n", " }\n", "\n", " # HTTP POST request\n", " req = request.Request(url, headers=headers)\n", " try:\n", " response = request.urlopen(req)\n", " except HTTPError as e:\n", " print(\"HTTP Error: \", e.code)\n", " print(e.read())\n", " sys.exit(1)\n", "\n", " resp_content = response.read()\n", "\n", " # The server must return HTTP 201. Raise an error if this is not the case\n", " assert response.status == 200, resp_content\n", "\n", " # The server returned a JSON response\n", " content = json.loads(resp_content)\n", "\n", " return content\n", "\n", "\n", "def get_access_token(client_id, client_secret):\n", " \"\"\"\n", " Get a new access_token. Access tokens are the thing that applications use to make\n", " API requests. Access tokens must be kept confidential in storage.\n", "\n", " # Procedure:\n", "\n", " Do a POST query with `grantType` and `scopes` in the body. A basic authorization\n", " HTTP header is required. The \"Basic\" HTTP authentication scheme is defined in\n", " RFC 7617, which transmits credentials as `clientId:clientSecret` pairs, encoded\n", " using base64.\n", " \"\"\"\n", "\n", " # Note: for the sake of this example, we choose to use the Python urllib from the\n", " # standard lib. One should consider using https://requests.readthedocs.io/\n", "\n", " payload = \"{}:{}\".format(client_id, client_secret).encode()\n", " headers = {\n", " \"Authorization\": b64encode(payload).decode(),\n", " \"Accept\": \"application/json\",\n", " \"Content-Type\": \"application/json\",\n", " }\n", " body = {\n", " \"grantType\": \"clientCredentials\",\n", " \"scopes\": \"read:prices,read:routes\",\n", " }\n", "\n", " content = do_api_post_query(uri=\"/oauth/token/\", body=body, headers=headers)\n", "\n", " print(\n", " \">>>> Successfully fetched an access token {}****, valid {} seconds.\".format(\n", " content[\"accessToken\"][:5], content[\"expiresIn\"]\n", " )\n", " )\n", "\n", " return content[\"accessToken\"]\n", "\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "691c889f", "metadata": {}, "source": [ "## Defining Fetch Request\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "5e341bdf", "metadata": {}, "outputs": [], "source": [ "def list_contracts(access_token):\n", " \"\"\"\n", " Fetch available contracts. Return contract ticker symbols\n", "\n", " # Procedure:\n", "\n", " Do a GET query to /v1.0/contracts/ with a Bearer token authorization HTTP header.\n", " \"\"\"\n", " content = do_api_get_query(uri=\"/v1.0/contracts/\", access_token=access_token)\n", "\n", " print(\">>>> All the contracts you can fetch\")\n", " tickers = []\n", " tick_names = []\n", " for contract in content[\"data\"]:\n", " print(contract[\"fullName\"])\n", " tickers.append(contract[\"id\"])\n", " tick_names.append(contract[\"fullName\"])\n", "\n", " return tickers,tick_names" ] }, { "cell_type": "markdown", "id": "fd3171a8", "metadata": {}, "source": [ "## N.B. Credentials\n", "\n", "Here we call the above functions, and input the file path to our credentials.\n", "\n", "N.B. You must have downloaded your client credentials CSV file before proceeding. Please refer to the API documentation if you have not dowloaded them already.\n", "\n", "The code then prints the available prices that are callable from the API, and their corresponding Python ticker names are displayed as a list at the bottom of the Output." ] }, { "cell_type": "code", "execution_count": 15, "id": "fd7e89bf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>>> Found credentials!\n", ">>>> Client_id=01c23590-ef6c-4a36-8237-c89c3f1a3b2a, client_secret=80763****\n", ">>>> Successfully fetched an access token eyJhb****, valid 604799 seconds.\n", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0eXBlIjoiYWNjZXNzVG9rZW4iLCJzdWIiOiIwMWMyMzU5MC1lZjZjLTRhMzYtODIzNy1jODljM2YxYTNiMmEiLCJzdWJUeXBlIjoib2F1dGgtY2xpZW50IiwiZXhwIjoxNzMwODIyNjY2LCJoYXNoZWRTZWNyZXQiOiJwYmtkZjJfc2hhMjU2JDYwMDAwMCRoTXRMNDlrMUZUaVVzTE42Njlqc2pPJHVCSXNxcml5b1NHVzJTS1AvaHVLNHh3eTZ4d3VDN001aUdGRm43N2l4S1U9Iiwib3JnVXVpZCI6IjQ5MzhiMGJiLTVmMjctNDE2NC04OTM4LTUyNTdmYmQzNTNmZiIsInNjb3BlcyI6WyJyZWFkOnByaWNlcyIsInJlYWQ6cm91dGVzIl0sImNsaWVudFR5cGUiOiJvYXV0aC1jbGllbnQifQ.rKN_pI3GMiLFReVbfOggLtmCiYpt6JPWpNHcg82nMFk\n", ">>>> All the contracts you can fetch\n", "Spark25F Pacific 160 TFDE\n", "Spark30F Atlantic 160 TFDE\n", "Spark25S Pacific\n", "Spark25Fo Pacific\n", "Spark25FFA Pacific\n", "Spark25FFAYearly Pacific\n", "Spark30S Atlantic\n", "Spark30Fo Atlantic\n", "Spark30FFA Atlantic\n", "Spark30FFAYearly Atlantic\n", "SparkNWE DES 1H\n", "SparkNWE-B 1H\n", "SparkNWE DES 2H\n", "SparkNWE-B 2H\n", "SparkNWE-B F\n", "SparkNWE DES F\n", "SparkNWE-B Fo\n", "SparkNWE DES Fo\n", "SparkNWE-DES-Fin Monthly\n", "SparkNWE-Fin Monthly\n", "SparkSWE-B F\n", "SparkSWE DES F\n", "SparkSWE-B Fo\n", "SparkSWE DES Fo\n", "SparkSWE-DES-Fin Monthly\n", "SparkSWE-Fin Monthly\n" ] } ], "source": [ "#Insert file path to your client credentials here\n", "client_id, client_secret = retrieve_credentials(file_path=\"C:/Users/Qasim/Downloads/client_credentials.csv\")\n", "\n", "# Authenticate:\n", "access_token = get_access_token(client_id, client_secret)\n", "print(access_token)\n", "\n", "# Fetch all contracts:\n", "tickers, tick_names = list_contracts(access_token)\n" ] }, { "cell_type": "markdown", "id": "a0e0e030", "metadata": {}, "source": [ "# Importing Data\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "ff4d0dcc", "metadata": {}, "outputs": [], "source": [ "def fetch_historical_price_releases(access_token, ticker, limit=4, offset=None, vessel=None):\n", " \"\"\"\n", " For a selected contract, this endpoint returns all the Price Releases you can\n", " access according to your current subscription, ordered by release date descending.\n", "\n", " **Note**: Unlimited access to historical data and full forward curves is only\n", " available to those with Premium access. Get in touch to find out more.\n", "\n", " **Params**\n", "\n", " limit: optional integer value to set an upper limit on the number of price\n", " releases returned by the endpoint. Default here is 4.\n", "\n", " offset: optional integer value to set from where to start returning data.\n", " Default is 0.\n", "\n", " # Procedure:\n", "\n", " Do GET queries to /v1.0/contracts/{contract_ticker_symbol}/price-releases/\n", " with a Bearer token authorization HTTP header.\n", " \"\"\"\n", " print(\">>>> Get price releases for {}\".format(ticker))\n", "\n", " query_params = \"?limit={}\".format(limit)\n", " if offset is not None:\n", " query_params += \"&offset={}\".format(offset)\n", " \n", " # '174-2stroke' or '160-tfde'\n", " if vessel is not None:\n", " query_params += \"&vessel-type={}\".format(vessel)\n", " \n", " \n", " content = do_api_get_query(\n", " uri=\"/v1.0/contracts/{}/price-releases/{}\".format(ticker, query_params),\n", " access_token=access_token,\n", " )\n", "\n", " my_dict = content['data']\n", " \n", " return my_dict\n" ] }, { "cell_type": "markdown", "id": "99be9416", "metadata": {}, "source": [ "### Formatting into a Pandas DataFrame\n", "\n", "Here we define a function that calls the data and formats it into a Pandas Dataframe." ] }, { "cell_type": "code", "execution_count": 17, "id": "399cc46f", "metadata": {}, "outputs": [], "source": [ "def fetch_prices(ticker, my_lim, my_vessel=None):\n", " my_dict_hist = fetch_historical_price_releases(access_token, ticker, limit=my_lim, vessel=my_vessel)\n", " \n", " release_dates = []\n", " period_start = []\n", " ticker = []\n", " usd_day = []\n", " usd_mmbtu = []\n", "\n", " day_min = []\n", " day_max = []\n", " cal_month = []\n", "\n", " for release in my_dict_hist:\n", " release_date = release[\"releaseDate\"]\n", " ticker.append(release['contractId'])\n", "\n", " release_dates.append(release_date)\n", "\n", " data_points = release[\"data\"][0][\"dataPoints\"]\n", "\n", " for data_point in data_points:\n", " period_start_at = data_point[\"deliveryPeriod\"][\"startAt\"]\n", " period_start.append(period_start_at)\n", "\n", " usd_day.append(data_point['derivedPrices']['usdPerDay']['spark'])\n", " day_min.append(data_point['derivedPrices']['usdPerDay']['sparkMin'])\n", " day_max.append(data_point['derivedPrices']['usdPerDay']['sparkMax'])\n", "\n", " usd_mmbtu.append(data_point['derivedPrices']['usdPerMMBtu']['spark'])\n", " cal_month.append(datetime.strptime(period_start_at, '%Y-%m-%d').strftime('%b-%Y'))\n", "\n", "\n", "\n", " ## Storing values in a Pandas DataFrame\n", "\n", " historical_df = pd.DataFrame({\n", " 'ticker': ticker,\n", " 'Period Start': period_start,\n", " 'USDperday': usd_day,\n", " 'USDperdayMax': day_max,\n", " 'USDperdayMin': day_min,\n", " 'USDperMMBtu': usd_mmbtu,\n", " 'Release Date': release_dates})\n", "\n", " historical_df['USDperday'] = pd.to_numeric(historical_df['USDperday'])\n", " historical_df['USDperdayMax'] = pd.to_numeric(historical_df['USDperdayMax'])\n", " historical_df['USDperdayMin'] = pd.to_numeric(historical_df['USDperdayMin'])\n", " historical_df['USDperMMBtu'] = pd.to_numeric(historical_df['USDperMMBtu'])\n", "\n", " historical_df['Release Datetime'] = pd.to_datetime(historical_df['Release Date'])\n", " \n", " return historical_df" ] }, { "cell_type": "markdown", "id": "9dbbdc7f", "metadata": {}, "source": [ "# Yearly Comparisons\n", "Pulling Spark30s and Spark25s historical data" ] }, { "cell_type": "code", "execution_count": 18, "id": "b425755f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>>> Get price releases for spark30s\n", ">>>> Get price releases for spark30s\n", ">>>> Get price releases for spark25s\n", ">>>> Get price releases for spark25s\n" ] } ], "source": [ "spark30_174 = fetch_prices('spark30s', 1000, my_vessel='174-2stroke')\n", "spark30_160 = fetch_prices('spark30s', 1000, my_vessel='160-tfde')\n", "\n", "spark25_174 = fetch_prices('spark25s', 1000, my_vessel='174-2stroke')\n", "spark25_160 = fetch_prices('spark25s', 1000, my_vessel='160-tfde')" ] }, { "cell_type": "markdown", "id": "59589a6d", "metadata": {}, "source": [ "## Sorting Data\n", "\n", "We then create new columns to categorise the data we have. \n", "- By creating the 'Years' column, we can filter the data by year.\n", "- By creating the 'Day of Year' column, we can plot the yearly data on the same x-axis range.\n", "- Similarly, creating the 'Quarters' and 'Seasons' columns" ] }, { "cell_type": "code", "execution_count": 19, "id": "a93ecb24", "metadata": {}, "outputs": [], "source": [ "from datetime import datetime\n", "\n", "def sort_years(df):\n", " \n", " reldates = df['Release Date'].to_list()\n", "\n", " years = []\n", " months = []\n", " days = []\n", " monthday = []\n", " dayofyear = []\n", " for r in reldates:\n", " rsplit = r.split('-')\n", " years.append(rsplit[0])\n", " months.append(rsplit[1])\n", " days.append(rsplit[2])\n", "\n", " dayofyear.append(datetime.strptime(r, '%Y-%m-%d').timetuple().tm_yday)\n", "\n", " df['Year'] = years\n", " df['Month'] = months\n", " df['Day'] = days\n", " df['Day of Year'] = dayofyear\n", " \n", " seas_check = [['04','05','06','07','08','09'], ['10','11','12','01','02','03']]\n", " quart_check = [['01','02','03'],['04','05','06'],['07','08','09'],['10','11','12']]\n", "\n", " seasons = []\n", " quarters = []\n", "\n", " for i in df['Month'].to_list():\n", " if i in quart_check[0]:\n", " quarters.append('Q1')\n", " if i in quart_check[1]:\n", " quarters.append('Q2')\n", " if i in quart_check[2]:\n", " quarters.append('Q3')\n", " if i in quart_check[3]:\n", " quarters.append('Q4')\n", "\n", " if i in seas_check[0]:\n", " seasons.append('Summer')\n", " if i in seas_check[1]:\n", " seasons.append('Winter')\n", "\n", " df['Quarters'] = quarters\n", " df['Seasons'] = seasons\n", "\n", " return df" ] }, { "cell_type": "code", "execution_count": 20, "id": "af3c1d24", "metadata": {}, "outputs": [], "source": [ "spark30_174 = sort_years(spark30_174)\n", "spark30_160 = sort_years(spark30_160)\n", "\n", "spark25_174 = sort_years(spark25_174)\n", "spark25_160 = sort_years(spark25_160)" ] }, { "cell_type": "markdown", "id": "d6209b17", "metadata": {}, "source": [ "# Plotting" ] }, { "cell_type": "code", "execution_count": 21, "id": "647e2de6", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "\n", "sns.set_style()" ] }, { "cell_type": "markdown", "id": "6f410c0d", "metadata": {}, "source": [ "## Spark30S" ] }, { "cell_type": "code", "execution_count": 22, "id": "e8e314cb", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\Qasim\\AppData\\Local\\Temp\\ipykernel_21608\\1642173433.py:34: UserWarning: FixedFormatter should only be used together with FixedLocator\n", " plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABQIAAAMICAYAAACTkpidAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXxU9b3/8ffMJJlMdgJkYQ+LCGIRwSKoELRE0FatWq1UlKotiKDCw+tPRCsu4HKpl1oXaq+CS7G2RS+2tVyoIEpZpIjKdcEtCBIiECB7Mtv5/XGYSUIWkjDJmeX1fDzymMk5Z875TDiJ5p3P9/u1GYZhCAAAAAAAAEBUs1tdAAAAAAAAAICORxAIAAAAAAAAxACCQAAAAAAAACAGEAQCAAAAAAAAMYAgEAAAAAAAAIgBBIEAAAAAAABADCAIBAAAAAAAAGIAQSAAAAAAAAAQAwgCAQAAAAAAgBhAEAgAACLWD3/4Q2VkZGjv3r2N9h0+fFi5ubk655xz5Pf7O7yW3bt3y2azafny5SE979dff61Zs2bplFNOkcvlUlJSkk477TTdc8892rdvX0ivFY4WLFggm81mdRknbffu3br44ouVmZkpm82m22+/vdljKysr9eijj2r48OFKS0tTamqqBgwYoKuuukobNmzovKKPM23aNKWkpJzwuCeeeEJnn322unXrJqfTqT59+uinP/2pPv744yaP/+1vf6tTTz1VTqdTeXl5uv/+++XxeBod97//+78qKChQjx495HQ61aNHD+Xn5+uRRx456fcGAECsiLO6AAAAgPb67//+bw0bNkw33XST/vd//7fBvlmzZqm8vFwvvPCC7PbI/Nvn3/72N/30pz9Vt27dNGvWLI0YMUI2m007d+7U888/r7///e/asWOH1WV2qJtuukmTJk2yuoyTNmfOHG3dulXPP/+8cnJylJub2+RxPp9PBQUF2rlzp/7jP/5D3//+9yVJX3zxhf7617/q3Xff1fjx4zuz9DYrKSnR5MmTNXz4cHXp0kVff/21HnnkEY0ePVrbt2/X4MGDg8cuXLhQ9957r+666y4VFBRo27ZtwZD72WefDR63dOlS3Xzzzbriiiv05JNPKjMzU3v37tWmTZv0l7/8RXfddZcVbxUAgIhjMwzDsLoIAACA9vrTn/6kq6++WkuXLtX06dMlSa+//rouv/xyPf3007r55ps79Po+n09er1f79+9XXl6eli1bpmnTpp30eQsLC3X66afrlFNO0fr165Went5gv2EYwfcZjaqqqpSUlGR1GSEzaNAgDRo0SG+++WaLx61fv17nn3++nn/+ef385z9vtN/v93d6sB34t5g2bZr+8pe/qKKios3n+PTTTzV06FDde++9euCBBySZgWGvXr103XXX6Xe/+13w2EWLFumee+7R//3f/2no0KGSpL59+6pfv35NdkRa8TUBACBS8V9MAAAQ0a666ir99Kc/1R133KHdu3erpKREM2bM0MSJE3XzzTfr3//+ty655BJlZmYqMTFRI0aM0J/+9KcG5zh48KBmzpypoUOHKiUlRVlZWTr//PP17rvvNjguMPz3scce00MPPaS8vDw5nU6tX7++UV3vvvuubDabXnnllUb7XnzxRdlsNm3btq3Z9/X444+rsrJSTz/9dKMQUJJsNlujEPD555/X8OHDlZiYqMzMTP34xz/Wp59+2uCYwPDOzz77TBdeeKGSk5OVm5sbHF65ZcsWnXvuuUpOTtYpp5yiF154ocHrly9fLpvNprVr1+rnP/+5MjMzlZycrB/96Ef6+uuvGxy7du1aXXrpperVq5cSExM1cOBATZ8+XYcOHWpwXGD47/vvv68rr7xSXbp00YABAxrsq2/dunXKz89X165d5XK51KdPH11xxRWqqqoKHnP48GHNnDlTPXv2VEJCgvr376/58+ertra20ddx1qxZeumllzRkyBAlJSVp+PDh+tvf/tbsv019e/bs0bXXXqusrCw5nU4NGTJEv/71r4PD0d9++23ZbDZ9+eWX+sc//iGbzSabzabdu3c3eb6SkhJJarZjsH7g1dn/Fk3517/+pW7duumHP/yhKisrmz2ue/fukqS4uLoBSatXr1ZNTU2jwPPnP/+5DMPQ//zP/zT4urTmawIAAFrGfzUBAEDEe+qpp5SamqobbrhBM2fOlNvt1vPPP6/169frnHPO0dGjR7V06VKtWrVKZ5xxhq6++uoGc/kdPnxYknTffffp73//u5YtW6b+/fsrPz9fb7/9dqPrPfHEE1q3bp0WL16sf/zjHzr11FMbHXPeeedpxIgReuqppxrte/LJJ3XWWWfprLPOavY9rVmzRtnZ2Tr77LNb9TV4+OGHdeONN+q0007Ta6+9pt/85jf66KOPNGbMGH3xxRcNjvV4PLr88st18cUXa9WqVZo8ebLmzZunu+++W9dff71uuOEGvf766xo8eLCmTZum7du3N7rejTfeKLvdrhUrVmjJkiV67733lJ+fr6NHjwaP+eqrrzRmzBg988wzWrNmjX71q19p69atOvfcc5ucA+7yyy/XwIED9ec//1lLly5t8n0G5tpLSEjQ888/r9WrV+uRRx5RcnKy3G63JKmmpkYTJkzQiy++qLlz5+rvf/+7rr32Wj322GNNdlD+/e9/15NPPqkHHnhAK1euDIaox4dpxzt48KDGjh2rNWvW6MEHH9Qbb7yhH/zgB7rjjjs0a9YsSdKZZ56pzZs3KycnR+ecc442b96szZs3NxtqjRo1SvHx8brtttv0hz/8Qfv372+xBsm6f4s//elPuuCCC3TVVVdp1apVSk5ObrDf5/OptrZWn332mW666SZlZWU1CP3+7//+T5J0+umnN3hdbm6uunXrFtwvSWPGjNHKlSu1YMECffjhh/L5fCf8ugAAgCYYAAAAUeDNN980JBmSjJdeeskwDMM49dRTjREjRhgej6fBsT/84Q+N3Nxcw+fzNXkur9dreDwe44ILLjB+/OMfB7cXFhYakowBAwYYbre7wWsC+5YtWxbctmzZMkOSsWPHjuC29957z5BkvPDCCy2+n8TEROPss89uzVs3jhw5YrhcLuOiiy5qsH3Pnj2G0+k0pkyZEtx2/fXXG5KMlStXBrd5PB6je/fuhiTj/fffD24vKSkxHA6HMXfu3Ebvqf7XxTAM41//+pchyXjooYearNHv9xsej8f45ptvDEnGqlWrgvvuu+8+Q5Lxq1/9qtHrAvsC/vKXvxiSjA8++KDZr8fSpUsNScaf/vSnBtsfffRRQ5KxZs2a4DZJRnZ2tlFWVhbcVlxcbNjtduPhhx9u9hqGYRh33XWXIcnYunVrg+0333yzYbPZjF27dgW39e3b17j44otbPF/Ac889Z6SkpATv59zcXOO6664z3nnnnQbHdfa/xfXXX28kJycbhmEYjzzyiOFwOIxHH3202ffhdDqD7+GUU04xPvnkkwb7f/GLXxhOp7PJ155yyilGQUFB8PMvv/zSGDZsWPB8LpfLuOCCC4wnn3yy0fciAABoHh2BAAAgKkyePFlnn322Bg0apGuvvVZffvmlPvvsM/3sZz+TJHm93uDHRRddpP3792vXrl3B1y9dulRnnnmmEhMTFRcXp/j4eL311luNhtZK0iWXXKL4+PgT1nTNNdcoKyurQVfgb3/7W3Xv3l1XX311CN61afPmzaqurm40N2Hv3r11/vnn66233mqw3Waz6aKLLgp+HhcXp4EDByo3N1cjRowIbs/MzFRWVpa++eabRtcMfF0Dxo4dq759+zYYJn3gwAHNmDFDvXv3Dn5N+/btK0lNfl2vuOKKE77XM844QwkJCfrlL3+pF154ocmuvXXr1ik5OVlXXnllg+2Br8/xX48JEyYoNTU1+Hl2dnaz7/v46wwdOjS4oEf96xiGoXXr1p3w/TTlhhtu0LfffqsVK1bo1ltvVe/evfXyyy9r/Pjx+s///M9Gx3fmv4VhGJo+fbruu+8+rVixQnfeeWez72PTpk3avHmzXn75ZaWmpmrChAmNVg5uaUXo+vsGDBigDz/8UBs2bND999+vH/zgB9q2bZtmzZqlMWPGqKamptnzAACAOgSBAAAgajidTiUkJEiSvvvuO0nSHXfcofj4+AYfM2fOlKTg/GiPP/64br75Zo0ePVorV67Uli1btG3bNk2aNEnV1dWNrtPcsM6m6pk+fbpWrFiho0eP6uDBg/rTn/6km266SU6ns8XX9unTR4WFha26TkvzyvXo0SO4PyApKUmJiYkNtiUkJCgzM7PR6xMSEpoMWXJycprcFriW3+9XQUGBXnvtNd15551666239N5772nLli2S1O6v64ABA/TPf/5TWVlZuuWWWzRgwAANGDBAv/nNb4LHlJSUKCcnp1HIlJWVpbi4uEZfj65duza6jtPpbLLG+pqbt65Hjx7B/e2Vnp6ua665Rr/5zW+0detWffTRR8rOztb8+fMbDPmVOvffwu1269VXX9Vpp52myZMnt/gezjzzTJ199tn62c9+pvXr18swDN19993B/V27dlVNTU2DuR0DDh8+3Oh+tNvtGjdunH71q1/pjTfeUFFRka6++mpt375dzz//fIu1AAAAU9yJDwEAAIg83bp1kyTNmzev2ZV1Bw8eLEl6+eWXlZ+fr2eeeabB/vLy8iZf11IX0/FuvvlmPfLII3r++edVU1Mjr9erGTNmnPB1F154oX77299qy5YtJ5wnMBBkNTWfXFFRUfBrEUrFxcVNbhs4cKAkc/63Dz/8UMuXL9f1118fPObLL79s9pyt/bqed955Ou+88+Tz+fTvf/9bv/3tb3X77bcrOztbP/3pT9W1a1dt3bpVhmE0OOeBAwfk9XpD9vXo2rVrs19zSSH9up922mn66U9/qiVLlujzzz9v0IXYmf8WgcVxLrzwQv3gBz/Q6tWr1aVLlxPWn5qaqlNPPVWff/55cFtgbsCdO3dq9OjRDWo/dOiQhg0b1uI5k5OTNW/ePL366qsN5hMEAADNoyMQAABEpcGDB2vQoEH68MMPNWrUqCY/AsNBbTZbow69jz76SJs3bz7pOnJzc/WTn/xETz/9tJYuXaof/ehH6tOnzwlfN2fOHCUnJ2vmzJkqLS1ttN8wDL3++uuSzIUUXC6XXn755QbHfPvtt1q3bp0uuOCCk34fx/vDH/7Q4PNNmzbpm2++UX5+vqS6IOn4r+vvfve7kNXgcDg0evTo4NDr999/X5J0wQUXqKKiosGqs5K5WnNgfyhccMEF+uSTT4LXrX8dm82mCRMmtPmcJSUlwUVPjvfZZ59Jqus4DOjsf4sRI0Zow4YN+vbbb5Wfn68DBw6c8DWHDh3Szp07g+GkJE2aNEmJiYkNFu6R6lZDvuyyy4Lbmls0JTCs+fivCQAAaBodgQAAIGr97ne/0+TJk3XhhRdq2rRp6tmzpw4fPqxPP/1U77//vv785z9Lkn74wx/qwQcf1H333afx48dr165deuCBB5SXlyev13vSddx2223Bjqdly5a16jV5eXn64x//qKuvvlpnnHGGZs2aFZy/75NPPtHzzz8vwzD04x//WBkZGbr33nt1991367rrrtM111yjkpIS3X///UpMTNR999130u/heP/+979100036Sc/+Yn27t2r+fPnq2fPnsFh16eeeqoGDBigu+66S4ZhKDMzU3/961+1du3ak7ru0qVLtW7dOl188cXq06ePampqgsNCf/CDH0iSrrvuOj311FO6/vrrtXv3bp1++unauHGjFi1apIsuuih43MmaM2eOXnzxRV188cV64IEH1LdvX/3973/X008/rZtvvlmnnHJKm8+5fv163XbbbfrZz36msWPHqmvXrjpw4IBeeeUVrV69Wtddd5169erV4DVW/FsMGTJE7777rn7wgx9o3Lhx+uc//6levXqptLRUEydO1JQpUzRo0CC5XC59/vnn+s1vfqPa2toG92JmZqbuuece3XvvvcrMzFRBQYG2bdumBQsW6KabbtLQoUODx5522mm64IILNHnyZA0YMEA1NTXaunWrfv3rXys7O1s33nhju98LAACxhCAQAABErQkTJui9997TwoULdfvtt+vIkSPq2rWrhg4dqquuuip43Pz581VVVaXnnntOjz32mIYOHaqlS5fq9ddf19tvv33SdXz/+99Xv3795HK52tSN9sMf/lA7d+7Ur3/9ay1dulR79+6V3W5XXl6eJk2apNmzZwePnTdvnrKysvTEE0/o1VdflcvlUn5+vhYtWqRBgwad9Hs43nPPPaeXXnpJP/3pT1VbW6sJEyboN7/5TXBet/j4eP31r3/VbbfdpunTpysuLk4/+MEP9M9//rNVHZHNOeOMM7RmzRrdd999Ki4uVkpKioYNG6Y33nhDBQUFkqTExEStX79e8+fP13/+53/q4MGD6tmzp+64446QhqLdu3fXpk2bNG/ePM2bN09lZWXq37+/HnvsMc2dO7dd5zz77LN1ww03aP369XrppZd06NAhuVwuDR06VL/97W918803N3qNVf8W/fv3D4aB5513nt566y317NlTw4cP17PPPqu9e/eqpqZGOTk5ys/P18qVKxuEe5L5vZeamqqnnnpKixcvVk5Oju666y7Nnz+/wXGPPPKI/vd//1cLFy5UcXGxvF6vevfurSlTpmj+/PmtnrcTAIBYZzMMw7C6CAAAgGj20Ucfafjw4XrqqaeCXVqRavny5fr5z3+ubdu2adSoUVaXE9P4twAAAG1FRyAAAEAH+eqrr/TNN9/o7rvvVm5urqZNm2Z1SQAAAIhhLBYCAADQQR588EFNnDhRFRUV+vOf/6ykpCSrSwIAAEAMY2gwAAAAAAAAEAPoCAQAAAAAAABiAEEgAAAAAAAAEAMIAgEAAAAAAIAYQBAIAAAAAAAAxACCQFjG4/Fo1apV8ng8VpcCnBD3KyId9zCiAfcxog33NCId9zAiVSzfuwSBAAAAAAAAQAwgCAQAAAAAAABiAEEgAAAAAAAAEAMIAgEAAAAAAIAYQBAIAAAAAAAAxIA4qwsAAAAAAABA9DEMQ16vVz6fz+pSGvB4PIqLi1NNTU3Y1dYch8OhuLg42Wy2kzoPQSAAAAAAAABCyu12a//+/aqqqrK6lEYMw1BOTo727t170sFaZ0pKSlJubq4SEhLafQ6CQAAAAAAAAISM3+9XYWGhHA6HevTooYSEhLAK3Px+vyoqKpSSkiK7PfxnzTMMQ263WwcPHlRhYaEGDRrU7roJAgEAAAAAABAybrdbfr9fvXv3VlJSktXlNOL3++V2u5WYmBgRQaAkuVwuxcfH65tvvgnW3h6R8W4BAAAAAAAQUSIlZIsUofh68i8CAAAAAAAAxACCQAAAAAAAACAGEAQCAAAAAAAAMYAgEAAAAAAAAJD08MMP66yzzlJqaqqysrJ02WWXadeuXQ2OMQxDCxYsUI8ePeRyuZSfn6+PP/64wTHPPvus8vPzlZaWJpvNpqNHjza61vvvv6+JEycqIyNDXbt21S9/+UtVVFR05NsjCAQAAAAAAAAkacOGDbrlllu0ZcsWrV27Vl6vVwUFBaqsrAwe89hjj+nxxx/Xk08+qW3btiknJ0cTJ05UeXl58JiqqipNmjRJd999d5PXKSoq0g9+8AMNHDhQW7du1erVq/Xxxx9r2rRpHfr+4jr07AAAAAAAAIAkn2FYcl2HzdbqY1evXt3g82XLlikrK0vbt2/XuHHjZBiGlixZovnz5+vyyy+XJL3wwgvKzs7WihUrNH36dEnS7bffLkl6++23m7zO3/72N8XHx+upp54Krgb81FNPacSIEfryyy81cODANr7L1iEIBAAAAAAAQIfyGYbeLCs/8YEd4KK01DaFgfWVlpZKkjIzMyVJhYWFKi4uVkFBQfAYp9Op8ePHa9OmTcEg8ERqa2uVkJAQDAElyeVySZI2btzYYUEgQ4MBAAAAAACA4xiGoblz5+rcc8/VsGHDJEnFxcWSpOzs7AbHZmdnB/e1xvnnn6/i4mL953/+p9xut44cORIcRrx///4QvYPG6AgEAAAAAABAh3LYbLooLdWya7fHrFmz9NFHH2njxo2N9tmOO6dhGI22teS0007TCy+8oLlz52revHlyOBy69dZblZ2dLYfD0a56W4MgEAAAAAAAAB2uvYGcFWbPnq033nhD77zzjnr16hXcnpOTI8nsDMzNzQ1uP3DgQKMuwROZMmWKpkyZou+++07Jycmy2Wx6/PHHlZeXF5o30QSGBgMAAAAAAAAyO/tmzZql1157TevWrWsUyuXl5SknJ0dr164NbnO73dqwYYPGjh3brmtmZ2crJSVFr776qhITEzVx4sSTeg8toSMQAAAAAAAAkHTLLbdoxYoVWrVqlVJTU4Pz/qWnp8vlcslms+n222/XokWLNGjQIA0aNEiLFi1SUlKSpkyZEjxPcXGxiouL9eWXX0qSdu7cqdTUVPXp0ye48MiTTz6psWPHKiUlRWvXrtV//Md/6JFHHlFGRkaHvT+CQAAAAAAAAEDSM888I0nKz89vsH3ZsmWaNm2aJOnOO+9UdXW1Zs6cqSNHjmj06NFas2aNUlPr5kBcunSp7r///uDn48aNa3Se9957T/fdd58qKip06qmn6ne/+52mTp3acW9OBIEAAAAAAACAJHNo8InYbDYtWLBACxYsaPaYE+2XpBdffLGN1Z085ggEAAAAAAAAYgBBIAAAAAAAABADCAIBAAAAAACAGEAQCAAAAAAAAMQAgkAAAAAAAAAgBrBqMAAAAAAAEcbjkXbtksrLpYwMKTNT6tJFSkiwujIA4YwgEAAAAACACHLwoPTBB1JNjfn5oUN1+5KTzVAwEAympEg2myVlAghDBIEAAAAAAESIr7+WPv7YfJ6cLOXlSWVl0uHDUkWFVFlpfuzdax4THy8NHGh+AABBIAAAAAAAEaKw0Hzs00caNkxyOOr2eTzSkSNmKHjkiPnh8Uiffy4NGEBnIACCQAAAAAAAIkZtrfk4cGDDEFAyu/+ysswPSfL7pdWrJZ/P7BJMSencWgGEH1YNBgAAAAAgAvh85ofUukVB7HYpLc18XlracXUB0eThhx/WWWedpdTUVGVlZemyyy7Trl27GhxjGIYWLFigHj16yOVyKT8/Xx8HxuxLOnz4sGbPnq3BgwcrKSlJffr00a233qrS474Rjxw5oqlTpyo9PV3p6emaOnWqjh492qHvjyAQAAAAAIAI4PGYjzab2f3XGhkZ5mMHZwudZvduadMmqahIMgyrq0E02rBhg2655RZt2bJFa9euldfrVUFBgSorK4PHPPbYY3r88cf15JNPatu2bcrJydHEiRNVXl4uSSoqKlJRUZEWL16snTt3avny5Vq9erVuvPHGBteaMmWKPvjgA61evVqrV6/WBx98oKlTp3bo+2NoMAAAAAAAEcDtNh9b0w0YkJ5uPkZDR2B1tblQit8vlZSY3Y6nniplZ1tdGVrN77PmunbHiY85ZvXq1Q0+X7ZsmbKysrR9+3aNGzdOhmFoyZIlmj9/vi6//HJJ0gsvvKDs7GytWLFC06dP17Bhw7Ry5crgOQYMGKCFCxfq2muvldfrVVxcnD799FOtXr1aW7Zs0ejRoyVJv//97zVmzBjt2rVLgwcPDsEbb4wgEAAAAACACBCYH7C9QaBhRPaCIZ9/boaAycnm16KsTHrvPalLFzMQ7NbN6grRIr9PKnzTmmvnXdSmMLC+wHDezMxMSVJhYaGKi4tVUFAQPMbpdGr8+PHatGmTpk+f3ux50tLSFBdnRnGbN29Wenp6MASUpLPPPlvp6enatGkTQSAAAAAAALGsPR2BKSnmXIFer1RVZYZokaiyUtq713x+xhnm+/rqK3MV5SNHpM2bzSDw1FPNYBAIBcMwNHfuXJ177rkaNmyYJKm4uFiSlH1cK2p2dra++eabJs9TUlKiBx98sEFIWFxcrKzAyj71ZGVlBa/REQgCAQAAAACIAO0JAgMLhhw9anYFRmoQ+PnnZkdjVpZ0rDFLQ4ZIeXnSl19K33wjHTokbdxoDhUeMkRKTbW2ZhzH7jA786y6djvMmjVLH330kTZu3Nhon+249lrDMBptk6SysjJdfPHFGjp0qO67774Wz9HSeUKFxUIAAAAAAIgA7QkCpbrhwZG6YEhFhbRvn/n8+NGSiYnSsGHS+edLffqYQ5+/+84MBANDqRFG7A5rPtph9uzZeuONN7R+/Xr16tUruD0nJ0eSGnXtHThwoFGXYHl5uSZNmqSUlBS9/vrriq+3yk9OTo6+++67Rtc9ePBgo/OEEkEgAAAAAAARoL1BYGDl4EhbMKSiQvrkE+lf/zK7AXNy6t7L8VwuafhwacIEswPS6zW7CIG2MgxDs2bN0muvvaZ169YpLy+vwf68vDzl5ORo7dq1wW1ut1sbNmzQ2LFjg9vKyspUUFCghIQEvfHGG0pMTGxwnjFjxqi0tFTvvfdecNvWrVtVWlra4DyhxtBgAAAAAAAiwMl2BHZGEOj3m9141dXmMN6sLHPuPqezbef56iszBAxwuaShQ0/8uuRks0Nw0yZzuHD//pE7HBrWuOWWW7RixQqtWrVKqampwc6/9PR0uVwu2Ww23X777Vq0aJEGDRqkQYMGadGiRUpKStKUKVMkmZ2ABQUFqqqq0ssvv6yysjKVlZVJkrp37y6Hw6EhQ4Zo0qRJ+sUvfqHf/e53kqRf/vKX+uEPf9hhC4VIBIEAAAAAAESEQBDY1lAtNdWcK9DjMRcMSUpq+rjSUjM88/tbPl9ionTKKU3vC8xFKEnffmt+BF6Tnt7ww+Vq/hyffmo+z86W+vY1A8XWTpvWtat5/IED0mefSSNHmsOECwvNhUQ6cNQlosAzzzwjScrPz2+wfdmyZZo2bZok6c4771R1dbVmzpypI0eOaPTo0VqzZo1Sj01MuX37dm3dulWSNHDgwAbnKSwsVL9+/SRJf/jDH3TrrbcGVyC+5JJL9OSTT3bQOzMRBAIAAAAAEAHa2xFot5thYGmp+XF8EOj3mwtuBBbkaI3kZHOo7vFKSszHzEzz48ABqaxMqqkxP+pPiZaQUBcK9uljntPnk3bsMOvo0cMM8dpjyBDz2kVFZgi5Z485XFgyhxD36dO+8yL6Ga34JrDZbFqwYIEWLFjQ5P78/PxWnSczM1Mvv/xyW0s8KQSBAAAAAABEgPYGgZIZtpWWSocPm0N1/X6pvNzctm9fXRdfTo7ZNdec0lIzXNu9u+UgsEcPc0XfIUPMAK6srC6ILC01r+12SwcPmh9ff20e7/OZcwM6ndLpp7f9fQakpUm9epkdiV9/bW5LTDTDyA8/NN//saYsIKYQBAIAAAAAEAFOJgjMyDC74r7+ui4Yqy8+3gzeevZs+Ty1tVJxccMhwAGGIR05Yj7PzKzbHhdX1yEY4PfXhYPFxWb33ldf1e0/44z2vc/6Tj3VPK9kBpK9e5vzDn79tbRzp3TokPl1ycgwhxO3dugxEMkIAgEAAAAACHNeb93cfe0JyLKyzC672tq6bUlJdUNze/c2O+ZOxOmUcnPNLsLduxvuKysz64yLMzvyWmK314Vwffuagd3//Z9UWVk3J+DJcrmkCy4wr2W3m9tOO818/uWX0v795odkvqeRIwkDEf0IAgEAAAAACHOBbkCHw/xoK5dLmjix4bb2hl79+plBYFGRTV5v3Unqzw/Y1nNnZUn5+WaYGFjlOBTimkg9hgwxFwwpKTGvV1xsBoJffikNGhS6awPhiCAQAAAAAIAwdzLDggNC1e2WmWkuPnLkiFRSUrf07+HDdfvbI9Al2BnqD1Xes8ecN/Czz8wQMhTdiEC4sltdAAAAAAAAaFkogsBQCiy0ceBA3RLEgSCwa9fOr+dk9OljDkeWpPffl6qqrK0H6EgEgQAAAAAAhLlwCwJ79TKH3VZXO/T11+bcfrW1ndvVF0rDhpmrJXs80rZt5urFQDQiCAQAAAAAIMyFWxAYFyedeqohSfr0U5s+/9zcnpFRtzBHJLHbpVGjzMVQysrMocJANIrAb08AAAAAAGJLuAWBkjk8uFu3GhmG9O235rZIGxZcX2Ji3crB+/ZJhYVWVwSEHkEgAAAAAABhLhyDQEnq27dUaWl1n7d3oZBw0bWrNHSo+fzjj+vmPQSiBUEgAAAAAABhLlyDQIdDGjXKUEKCWVukB4GS1L+/1LOnZBjSv/8t1dRYXRE608MPP6yzzjpLqampysrK0mWXXaZdu3Y1OMYwDC1YsEA9evSQy+VSfn6+Pv744+D+w4cPa/bs2Ro8eLCSkpLUp08f3XrrrSotLW1wnoULF2rs2LFKSkpSRidNrkkQCAAAAABAmAvXIFCSkpKkCROk/Hxz7sBoMHy4lJZmLoCyfbvk91tdETrLhg0bdMstt2jLli1au3atvF6vCgoKVFlZGTzmscce0+OPP64nn3xS27ZtU05OjiZOnKjy8nJJUlFRkYqKirR48WLt3LlTy5cv1+rVq3XjjTc2uJbb7dZPfvIT3XzzzZ32/qLkWxQAAAAAgOgVzkGgFL51tZfZ6Si9+645PPjjj6XTT7e6qsjn91mTqNodre+DW716dYPPly1bpqysLG3fvl3jxo2TYRhasmSJ5s+fr8svv1yS9MILLyg7O1srVqzQ9OnTNWzYMK1cuTJ4jgEDBmjhwoW69tpr5fV6FXcsMb///vslScuXLz/Jd9h6BIEAAAAAAIS5cA8Co1FysjRihPTee9Lu3VJurtStm9VVRS6/z68v3vzCkmsPumhQm8LA+gLDeTOPjXsvLCxUcXGxCgoKgsc4nU6NHz9emzZt0vTp05s9T1paWjAEtApDgwEAAAAACGOGQRBolexsc75ASTpyxNpa0PkMw9DcuXN17rnnatiwYZKk4uJiSVJ2dnaDY7Ozs4P7jldSUqIHH3yw2ZCwM9ERCAAAAABAGPN6zTBQIgi0QkqK+VhVZW0dkc7usGvQRYMsu3Z7zJo1Sx999JE2btzYaJ/NZmvwuWEYjbZJUllZmS6++GINHTpU9913X7vqCCWCQAAAAAAAwligGzAuTrIzrq/TuVzmY3W1tXVEg/YGclaYPXu23njjDb3zzjvq1atXcHtOTo4kszMwNzc3uP3AgQONugTLy8s1adIkpaSk6PXXX1d8fHznFN+CyPkXAAAAAAAgBjEs2FpJSeYjHYGxwTAMzZo1S6+99prWrVunvLy8Bvvz8vKUk5OjtWvXBre53W5t2LBBY8eODW4rKytTQUGBEhIS9MYbbygxMbHT3kNL6AgEAAAAACCMEQRaq35HoGFITYz+RBS55ZZbtGLFCq1atUqpqanBef/S09Plcrlks9l0++23a9GiRRo0aJAGDRqkRYsWKSkpSVOmTJFkdgIWFBSoqqpKL7/8ssrKylRWViZJ6t69uxwOhyRpz549Onz4sPbs2SOfz6cPPvhAkjRw4EClBMakhxhBIAAAAAAAYYwg0FqJiWb45/dLtbXm54hezzzzjCQpPz+/wfZly5Zp2rRpkqQ777xT1dXVmjlzpo4cOaLRo0drzZo1Sk1NlSRt375dW7dulWSGevUVFhaqX79+kqRf/epXeuGFF4L7RowYIUlav359o+uHCkEgAAAAAABhjCDQWna7Gf5VV5sfBIHRzQiszNMCm82mBQsWaMGCBU3uz8/Pb9V5li9fruXLl7exwpPDHIEAAAAAAIQxgkDrMU8gogVBIAAAAAAAYYwg0HqsHIxoQRAIAAAAAEAYCwSBTqe1dcQyOgIRLQgCAQAAAAAIYzU15iMdgdahIxDRgiAQAAAAAIAwZRhSebn5PCXF2lpiGR2BiBYEgQAAAAAAhKnqasnnM1euTU62uprYRUcgogVBIAAAAAAAYap+N6DNZm0tsSwQBPp8Um2ttbUAJ4MgEAAAAACAMBUIAlNTra0j1tntUmKi+ZyuQEQygkAAAAAAAMIUQWD4YJ5ARAOCQAAAAAAAwhRBYPhgnkBEA4JAAAAAAADCkGFIFRXmc4JA69ERGBsefvhhnXXWWUpNTVVWVpYuu+wy7dq1q8ExhmFowYIF6tGjh1wul/Lz8/Xxxx8H9x8+fFizZ8/W4MGDlZSUpD59+ujWW29VaWlp8Jjdu3frxhtvVF5enlwulwYMGKD77rtPbre7Q98fQSAAAAAAAGGoqqpuxeBACAXrBDoCCQKj24YNG3TLLbdoy5YtWrt2rbxerwoKClRZWRk85rHHHtPjjz+uJ598Utu2bVNOTo4mTpyo8mMtvEVFRSoqKtLixYu1c+dOLV++XKtXr9aNN94YPMdnn30mv9+v3/3ud/r444/1X//1X1q6dKnuvvvuDn1/cR16dgAAAAAA0C6sGBxeAmEsQ4Pbz+ez5roOR+uPXb16dYPPly1bpqysLG3fvl3jxo2TYRhasmSJ5s+fr8svv1yS9MILLyg7O1srVqzQ9OnTNWzYMK1cuTJ4jgEDBmjhwoW69tpr5fV6FRcXp0mTJmnSpEnBY/r3769du3bpmWee0eLFi0/uDbeAIBAAAAAAgDDE/IDhhaHBJ8fnk95805prX3RR28LA+gLDeTMzMyVJhYWFKi4uVkFBQfAYp9Op8ePHa9OmTZo+fXqz50lLS1NcXPNRXGlpafA6HYWhwQAAAAAAhCGCwPASGBrs80kdPI0bwoRhGJo7d67OPfdcDRs2TJJUXFwsScrOzm5wbHZ2dnDf8UpKSvTggw82GxJK0ldffaXf/va3mjFjRoiqbxodgQAAAAAAhCGCwPBit0tOp1Rbaw4PTkiwuqLI4nCYnXlWXbs9Zs2apY8++kgbN25stM923Hh9wzAabZOksrIyXXzxxRo6dKjuu+++Jq9TVFSkSZMm6Sc/+Yluuumm9hXbSgSBAAAAAACEGVYMDk/JyWYQWFoqpadbXU3kaW8gZ4XZs2frjTfe0DvvvKNevXoFt+fk5EgyOwNzc3OD2w8cONCoS7C8vFyTJk1SSkqKXn/9dcXHxze6TlFRkSZMmKAxY8bo2Wef7aB3U4ehwQAAAAAAhJmqKsnvN4MTVgwOH927m4/NjABFFDAMQ7NmzdJrr72mdevWKS8vr8H+vLw85eTkaO3atcFtbrdbGzZs0NixY4PbysrKVFBQoISEBL3xxhtKTExsdK19+/YpPz9fZ555ppYtWya7veNjOjoCAQAAAAAIM6wYHJ5yc6Vdu6SDByWvV2ph3QdEqFtuuUUrVqzQqlWrlJqaGpz3Lz09XS6XSzabTbfffrsWLVqkQYMGadCgQVq0aJGSkpI0ZcoUSWYnYEFBgaqqqvTyyy+rrKxMZWVlkqTu3bvL4XCoqKhI+fn56tOnjxYvXqyDBw8Gawh0HXYEblkAAAAAAMKEzyfV1JhBk8Sw4HCTmmoOD66slA4ckHr0sLoihNozzzwjScrPz2+wfdmyZZo2bZok6c4771R1dbVmzpypI0eOaPTo0VqzZo1Sj33Dbt++XVu3bpUkDRw4sMF5CgsL1a9fP61Zs0ZffvmlvvzyywZDjyWzK7GjEAQCAAAAABAGvvxS+uwzc37AAILA8JOba/5b7d9PEBiNWhPC2Ww2LViwQAsWLGhyf35+/gnPM23atGCw2JmYIxAAAAAAAIt9/bX06admCBgXZ3adZWVJxzUKIQwE1oc4cMCcxxGIJHQEAgAAAABgoW+/lT7+2Hw+eLB0yinW1oOWpadLiYl1Q7iPWygWCGt0BAIAAAAAYJHiYumDD8zn/fsTAkYCm62uK3D/fmtrAdqKIBAAAAAAAAscOiRt324OB+7dWxo61OqK0FqBILC4uOGcjkC4IwgEAAAAAKCTHT0qvfeeOcdcTo40fLjZaYbIkJkpxcdLHo9UWmp1NUDrEQQCAAAAANCJysulLVskn0/q1k0aOZIQMNLYbJLLZT73eKytBWgLgkAAAAAAADpJVZUZAno8Upcu0llnSXZ+M49IcceWXyUIRCThxw0AAAAAAJ2gpsYMAWtqpNRUafToujAJkSc+3nz0eq2tA2gLgkAAAAAAADqYzydt3SpVVkpJSdLZZ9cFSYhMgRCXIBCRhCAQAAAAAIAOVlwslZVJTqc0ZoyUmGh1RThZDA1GJCIIBAAAAACggwVWlu3Rw+wIRORjaHB0evjhh3XWWWcpNTVVWVlZuuyyy7Rr164GxxiGoQULFqhHjx5yuVzKz8/Xxx9/HNx/+PBhzZ49W4MHD1ZSUpL69OmjW2+9VaXHLTF9ySWXqE+fPkpMTFRubq6mTp2qoqKiDn1/BIEAAAAAAHSwsjLzMS3N2joQOgwNjk4bNmzQLbfcoi1btmjt2rXyer0qKChQZWVl8JjHHntMjz/+uJ588klt27ZNOTk5mjhxosrLyyVJRUVFKioq0uLFi7Vz504tX75cq1ev1o033tjgWhMmTNCf/vQn7dq1SytXrtRXX32lK6+8skPfH9OSAgAAAADQwQKNQASB0YMgsB18Pmuu63C0+tDVq1c3+HzZsmXKysrS9u3bNW7cOBmGoSVLlmj+/Pm6/PLLJUkvvPCCsrOztWLFCk2fPl3Dhg3TypUrg+cYMGCAFi5cqGuvvVZer1dxx26eOXPmBI/p27ev7rrrLl122WXyeDyK76BJRAkCAQAAAADoQDU1ktst2WzmasGIDoGchjkCW8nnk95805prX3RRm8LA+gLDeTMzMyVJhYWFKi4uVkFBQfAYp9Op8ePHa9OmTZo+fXqz50lLSwuGgMc7fPiw/vCHP2js2LEdFgJKDA0GAAAAAKBDBYYFp6S0O4tAGKIjMPoZhqG5c+fq3HPP1bBhwyRJxcXFkqTs7OwGx2ZnZwf3Ha+kpEQPPvhgkyHh//t//0/Jycnq2rWr9uzZo1WrVoX4XTRERyAAAAAAAB2IYcHRiSCwjRwOszPPqmu3w6xZs/TRRx9p48aNjfbZbLYGnxuG0WibJJWVleniiy/W0KFDdd999zXa/x//8R+68cYb9c033+j+++/Xddddp7/97W9NnisUCAIBAAAAAOhAgY7A9HRr60BoBYJAhga3QQS1xM6ePVtvvPGG3nnnHfXq1Su4PScnR5LZGZibmxvcfuDAgUZdguXl5Zo0aZJSUlL0+uuvNznkt1u3burWrZtOOeUUDRkyRL1799aWLVs0ZsyYDnlfDA0GAAAAAKAD0REYnQKZDh2B0cUwDM2aNUuvvfaa1q1bp7y8vAb78/LylJOTo7Vr1wa3ud1ubdiwQWPHjg1uKysrU0FBgRISEvTGG28oMTGxVdeWpNra2hC9m8bCpiNw2rRpWr58udVlAAAAAAAQMl6vVFlpPicIjC71hwYbhrkYDCLfLbfcohUrVmjVqlVKTU0NzvuXnp4ul8slm82m22+/XYsWLdKgQYM0aNAgLVq0SElJSZoyZYoksxOwoKBAVVVVevnll1VWVqayY63B3bt3l8Ph0Hvvvaf33ntP5557rrp06aKvv/5av/rVrzRgwIAO6waUIrAj8O2335bNZmv08dlnnzU4buXKlRo6dKicTqeGDh2q119/vdG5nn76aeXl5SkxMVEjR47Uu+++e8Lrb9iwQSNHjlRiYqL69++vpUuXNjqmo64NAAAAAIgs5eXmY2Ki5HRaWwtCq/7irz6fdXUgtJ555hmVlpYqPz9fubm5wY9XX301eMydd96p22+/XTNnztSoUaO0b98+rVmzRqnHlgXfvn27tm7dqp07d2rgwIENzrN3715Jksvl0muvvaYLLrhAgwcP1g033KBhw4Zpw4YNcnbgDwtLg8BDhw7p+uuvV58+ffTKK69o4MCBuuqqq+R2u0/42l27dmn//v3Bj0GDBgX3bd68WVdffbWmTp2qDz/8UFOnTtVVV12lrVu3Bo959dVXdfvtt2v+/PnasWOHzjvvPE2ePFl79uxp9pqFhYW66KKLdN5552nHjh26++67deutt2rlypUdfm0AAAAAQORhWHD0cjjqugAZHhw9DMNo8mPatGnBY2w2mxYsWKD9+/erpqZGGzZsCK4qLEn5+fnNnqdfv36SpNNPP13r1q1TSUmJampqVFhYqGeeeUY9e/bs0Pdn6dDgOXPmaNu2bXrppZe0ZMkS3XrrrVq9erX8fv8JX5uVlaWMjIwm9y1ZskQTJ07UvHnzJEnz5s3Thg0btGTJEr3yyiuSpMcff1w33nijbrrppuBr/vd//1fPPPOMHn744SbPu3TpUvXp00dLliyRJA0ZMkT//ve/tXjxYl1xxRUddu3a2tpG48PtdnuHJsSdwXNsRlUPM6siAnC/ItJxDyMacB8j2nBPx4aSEsnrtSkpyYi6RSW4hyXJJq9XqqoyImkdjA7n8XhkGIb8fn+rMp7OFpiLL1BjpPD7/TIMQx6PR44mbrimFiM5nqVB4I4dOzR16lSNHz9ey5Yt04QJEzRhwoRWvXbEiBGqqanR0KFDdc899zR43ebNmzVnzpwGx1944YXBAM/tdmv79u266667GhxTUFCgTZs2NXvNzZs3q6CgoNF5n3vuOXk8HsXHx3fItR9++GHdf//9DbZdffXVuuaaa5qtNZLUn2ATCHfcr4h03MOIBtzHiDbc09Htk08yVVERr6NHS/X11zVWl9MhYvke/vDDbqqtdaiq6rBSUmI5EG0oLi5OOTk5qqioaNWoT6uUB8buRwi3263q6mq988478jbRhnrppZee8ByWBoHnnHOOli1bpuHDh7f6Nbm5uXr22Wc1cuRI1dbW6qWXXtIFF1ygt99+W+PGjZNkLuF8/JLN2dnZwQkeDx06JJ/P1+IxTWnuvF6vV4cOHVJubm6HXHvevHmaO3dug23R0hG4du1aTZw4sVWpNWAl7ldEOu5hRAPuY0Qb7unoZy4gYZPPJ+XnG0pJsbqi0OIellJSbCork0aPNtS9u9XVhI+amhrt3btXKSkprVott7MZhqHy8nKlpqbKFkGrvNTU1MjlcmncuHHt/rpaGgQ+/vjjWrRokebMmaOvvvpKH3zwgWbMmKEZM2Y0+5rBgwdr8ODBwc/HjBmjvXv3avHixcEgUFKjf0jDMBpta80xx2vqNcdvD/W1nU5nxId+LYmPj4/Z/2gg8nC/ItJxDyMacB8j2nBPR6/ycnMOOadTysiI3lVlY/keTkyUqqrMf9sY/RI0yefzyWazyW63y24Pv3VqA8OBAzVGCrvdLpvNdlLfc5a+2+TkZC1cuFBffPGFLrnkEt18882aO3eunn322Tad5+yzz9YXX3wR/DwnJ6dRd92BAweCXXjdunWTw+Fo8ZimNHfeuLg4de3atUOvDQAAAACILIFf+zIzozcEjHWBLCamp0lERAmb2DMjI0PTp0/X5MmT9e6777bptTt27FBubm7w8zFjxjSao2DNmjUaO3asJCkhIUEjR45sdMzatWuDxzSlufOOGjUqmMR21LUBAAAAAJFl717zsYMXAYWF4o6Ns2TVYEQKy1cNvuyyy3TGGWfI5/Np/fr12rBhg+65555mX7NkyRL169dPp512mtxut15++WWtXLlSK1euDB5z2223ady4cXr00Ud16aWXatWqVfrnP/+pjRs3Bo+ZO3eupk6dqlGjRmnMmDF69tlntWfPnhaHJc+YMUNPPvmk5s6dq1/84hfavHmznnvuueBqwB15bQAAAABA5DhyRKqslBwOqV7fCqIMQSAijaVBYJ8+fTR37lx98cUXqqys1Ntvv60bbrhBs2fPbvY1brdbd9xxh/bt2yeXy6XTTjtNf//733XRRRcFjxk7dqz++Mc/6p577tG9996rAQMG6NVXX9Xo0aODx1x99dUqKSnRAw88oP3792vYsGF688031bdv3+AxCxYs0PLly7V7925JUl5ent58803NmTNHTz31lHr06KEnnnhCV1xxRcivDQAAAACIXN9+az7m5taFRYg+DA1GpLG8I3DOnDmSpGnTpmn58uUnfM2dd96pO++884THXXnllbryyitbPGbmzJmaOXNms/t3796t/Pz8BtvGjx+v999/v8OvDQAAAACITH6/tG+f+bxXL2trQceiIxCRhr9LtGDDhg165513rC4DAAAAABBBDhwwO8QSE6Vu3ayuBh2JIBCRJmwWC2lNN2BnKywsVO/eva0uAwAAAAAQQeovEsJqwdGNIDD6PPzwwzrrrLOUmpqqrKwsXXbZZdq1a1eDYwzD0IIFC9SjRw+5XC7l5+fr448/Du4/fPiwZs+ercGDByspKUl9+vTRrbfeqtLS0iavWVtbqzPOOEM2m00ffPBBR749OgIBAAAAAAgVj8fsCJQYFhwLmCOwdfyGoTJvtaU1pMW5ZG9FMr9hwwbdcsstOuuss+T1ejV//nwVFBTok08+UXJysiTpscce0+OPP67ly5frlFNO0UMPPaSJEydq165dSk1NVVFRkYqKirR48WINHTpU33zzjWbMmKGioiL95S9/aXTNO++8Uz169NCHH34Y8vd9PIJAAAAAAABCpKTEnCMwJUVKS7O6GnQ0OgJbp8xbrWu2LrW0hldGz1BGfNIJj1u9enWDz5ctW6asrCxt375d48aNk2EYWrJkiebPn6/LL79ckvTCCy8oOztbK1as0PTp0zVs2DCtXLkyeI4BAwZo4cKFuvbaa+X1ehVXbwWhf/zjH1qzZo1Wrlypf/zjHyF6t80Lm6HBAAAAAABEupIS85G5AWMDQWD0CwznzczMlGROI1dcXKyCgoLgMU6nU+PHj9emTZtaPE9aWlqDEPC7777TL37xC7300ktKSjpxSBkKBIEAAAAAAITIoUPmY9eu1taBzhEYGkwQGJ0Mw9DcuXN17rnnatiwYZKk4uJiSVJ2dnaDY7Ozs4P7jldSUqIHH3xQ06dPb3DuadOmacaMGRo1alQHvYPGGBoMAAAAAEAIeDxSWZn5nCAwNgSau5gjMDrNmjVLH330kTZu3Nhon+24+QYNw2i0TZLKysp08cUXa+jQobrvvvuC23/729+qrKxM8+bNC33hLSAIBAAAAAAgBALDglNSJKfT2lrQOeqN8pTX2/Bz1EmLc+mV0TMsr6EtZs+erTfeeEPvvPOOetVb+ScnJ0eS2RmYm5sb3H7gwIFGXYLl5eWaNGmSUlJS9Prrrys+0EIqad26ddqyZYucx/2wGDVqlH72s5/phRdeaFO9rcUtCgAAAABACDA/YOxxOCSbTTIMgsCW2G22Vi3UEQ4Mw9Ds2bP1+uuv6+2331ZeXl6D/Xl5ecrJydHatWs1YsQISZLb7daGDRv06KOPBo8rKyvThRdeKKfTqTfeeEOJiYkNzvPEE0/ooYceCn5eVFSkCy+8UK+++qpGjx7dYe+PWxQAAAAAgBBgfsDYFBdnDg1mnsDocMstt2jFihVatWqVUlNTg/P+paeny+VyyWaz6fbbb9eiRYs0aNAgDRo0SIsWLVJSUpKmTJkiyewELCgoUFVVlV5++WWVlZWp7Ni8Ad27d5fD4VCfPn0aXDclJUWSucJw/Q7EUCMIBAAAAADgJDE/YOyKjzf//ZknMDo888wzkqT8/PwG25ctW6Zp06ZJku68805VV1dr5syZOnLkiEaPHq01a9YoNTVVkrR9+3Zt3bpVkjRw4MAG5yksLFS/fv069D20hCAQAAAAAICTxPyAsSswHJiOwOhgGMYJj7HZbFqwYIEWLFjQ5P78/PxWnae+fv36tfk17WHv8CsAAAAAABDlAsOCmR8w9hAEIpIQBAIAAAAAcJICHYEMC449gYVgCQIRCQgCAQAAAAA4CT4f8wPGskBHIHMEIhIQBAIAAAAAcBKqq83HuDjmB4xFDA1GJCEIBAAAAADgJNTUmI+JidbWAWsQBDavMxa/iCWh+HoSBAIAAAAAcBJqa81HgsDYFJgjkKHBdeKPfVGqqqosriS6BL6ega9ve8SFqhgAAAAAAGIRHYGxjY7AxhwOhzIyMnTgwAFJUlJSkmw2m8VV1fH7/XK73aqpqZHdHv49coZhqKqqSgcOHFBGRoYcDke7z0UQCAAAAADASSAIjG0EgU3LycmRpGAYGE4Mw1B1dbVcLldYBZQnkpGREfy6thdBIAAAAAAAJyEQBLJQSGwKjNIkCGzIZrMpNzdXWVlZ8oTZuGmPx6N33nlH48aNO6lhtp0pPj7+pDoBAwgCAQAAAAA4CYEg0OWytg5YI9ARGGZZV9hwOBwhCbBCyeFwyOv1KjExMWKCwFAJ/4HQAAAAAACEMToCYxtDgxFJCAIBAAAAADgJzBEY2xgajEhCEAgAAAAAQDu53ZLfbz4nCIxNdAQikhAEAgAAAADQToFuwIQEyc5v2DEpEAQaBmEgwh8/pgAAAAAAaCeGBcPhkGw28zlBIMIdQSAAAAAAAO1EEAjJ7AiVzKHiQDgjCAQAAAAAoJ1qa81HgsDYFvj3r662tg7gRAgCAQAAAABoJzoCIUkul/lIEIhwRxAIAAAAAEA7EQRCqgsCA/cDEK4IAgEAAAAAaKdA8ON0WlsHrMXQYEQKgkAAAAAAANopEAQGOsIQm+gIRKQgCAQAAAAAoB0Mo26xEDoCYxsdgYgUBIEAAAAAALRDba0ZBtpsBIGxjsVCECkIAgEAAAAAaIf68wPabNbWAmsFOgL9fsnttrYWoCUEgQAAAAAAtAMrBiPAbq/rCmWeQIQzgkAAAAAAANohMD8gQSAk5glEZCAIBAAAAACgHQKBD0EgJOYJRGQgCAQAAAAAoB3oCER9gSCQocEIZwSBAAAAAAC0A3MEoj6GBiMSEAQCAAAAANAOBIGoj6HBiAQEgQAAAAAAtJHXK1VVmc8Dq8UitjE0GJGAIBAAAAAAgDb66CMzDExMlFJSrK4G4YChwYgEBIEAAAAAALTB7t3Svn2SzSaNHCnZ+c0aqgsC/X7J7ba2FqA5/LgCAAAAAKCVjh6VPv7YfD5kiJSZaWk5CCN2e90wcboCEa4IAgEAAAAAaAW3W/r3v82Or9xcacAAqytCuGHBEIQ7gkAAAAAAAE7AMKQdO8yAJzlZGj7c6ooQjgLDg1kwBOGKIBAAAAAAgBP44gvpwAFz+OeoUVJ8vNUVIRzREYhwRxAIAAAAAEALDh6Udu0yn3/ve1JamrX1IHwFgkA6AhGuCAIBAAAAAGhGdbX0/vvm8z59pN69ra0H4S0wNJiOQIQrgkAAAAAAAJrg90vbt5uLhKSnS6efbnVFCHd0BCLcEQQCAAAAANCETz+Vjhwx5wMcNcqcHxBoCR2BCHf8GAMAAAAA4DjFxdLXX5vPR4yQkpKsrQeRITFRcjjMbtKyMqurARojCAQAAAAA4Di7d5uP/ftL2dmWloIIYrdL3bqZz7/7ztpagKYQBAIAAAAAcJyKCvMxN9faOhB5AsHxgQPW1gE0hSAQAAAAAIB6fL66Od5SUqytBZEnEAQePmwuNAOEE4JAAAAAAADqqaw0H+PjpYQEa2tB5ElMlNLSzOd0BSLcEAQCAAAAAFBPIAikGxDtFegKZJ5AhBuCQAAAAAAA6gnMD5icbG0diFyBIPDgQXMFYSBcEAQCAAAAAFAPHYE4WRkZ5rByj0c6csTqaoA6BIEAAAAAANRDRyBOls0mZWWZzxkejHBCEAgAAAAAQD10BCIUmCcQ4YggEAAAAACAY9xu80OiIxAnp3t3szOwoqIuXAasRhAIAAAAAMAxgcAmMVFyOKytBZEtPl7q2tV8TlcgwgVBIAAAAAAAxzAsGKEUGB584IC1dQABBIEAAAAAABzDQiEIpUAQWFIieb3W1gJIBIEAAAAAAATREYhQSk42P/x+6eBBq6sBCAIBAAAAAAiiIxChxurBCCcEgQAAAAAASDIMOgIRevXnCTQMa2sBCAIBAAAAAJBUUyP5fJLNJrlcVleDaJGZKcXFSbW1Ummp1dUg1hEEAgAAAACgum7A5GTJzm/LCBG7Xere3XzO8GBYjR9tAAAAAACI+QHRcZgnEOGCIBAAAAAAANUFgcwPiFDLyjIfS0vNIeiAVQgCAQAAAAAxzzCk/fvN5126WFsLoo/TWXdfHThgbS2IbQSBAAAAAICYd/Cg2akVH183jBMIpUBXIMODYSWCQAAAAABAzNu713zs1YuFQtAxAgHzwYOS329tLYhd/HgDAAAAAMQ0j0cqLjaf9+ljbS2IXunpUmKi5PNJhw5ZXQ1iFUEgAAAAACCmffut2aGVlmZ+AB2F1YNhNYJAAAAAAEBMCwwLphsQHS0wTyALhsAqBIEAAAAAgJhVViaVlprzAvbsaXU1iHbdu5v3WlWVVF5udTWIRQSBAAAAAICYVVRkPmZnSwkJ1taC6OdwSN26mc8ZHgwrEAQCAAAAAGJWSYn5GJi7Deho9VcPBjobQSAAAAAAICb5/dLRo+bzzExLS0EMSU42H91ua+tAbCIIBAAAAADEpKNHzTAwIaEunAE6Wlyc+ej1WlsHYhNBIAAAAAAgJh0+bD7SDYjORBAIKxEEAgAAAABi0pEj5mPXrtbWgdhCEAgrEQQCAAAAAGKOYdR1BHbpYm0tiC2BINDvNz+AzkQQCAAAAACIOZWV5mINDoeUnm51NYglgSBQoisQnY8gEAAAAAAQcwLdgBkZkp3fjNGJbLa6e44gEJ2NH3cAAAAAgJjDQiGwEvMEwioEgQAAAACAmEMQCCsRBMIqBIEAAAAAgJhSW2vOESixUAisEQgCfT5r60DsIQgEAAAAAMSUkhLzMS1Nio+3thbEpkAQ6PFYWwdiD0EgAAAAACCmfPON+di9u7V1IHYxNBhWiTvxIQAAAAAAhLevv5bcbqlvX8nlav64o0elQ4fMlVvz8jqtPKABgkBYhSAQAAAAABDRKiuljz82n3/5pdSjhzRggJSe3vjYL780H3v2bDkwBDoScwTCKgSBAAAAAICIFpjzz+Ewg5V9+8yPbt3MQDAry9xfWSnt328+HzjQmloBiY5AWIcgEAAAAAAQ0Q4dMh8HDJBycqSvvpKKiszthw5JqanmvkBgmJ1tbgOsQhAIqxAEAgAAAAAiWiDg69bNHA585pnSkCHmvIF79kjl5dIHH9QdTzcgrEYQCKsQBAIAAAAAIlZlpVRTI9ntUpcuddtdLum006RTTjFXCS4sNI/r2lXKzLSuXkAiCIR17FYXEDBt2jSrSwAAAAAARJhAN2CXLmYYeLz4eLMD8IILpDFjpLPO6tz6gKYQBMIqYRMEtse//vUvxcXF6Ywzzmi0b+XKlRo6dKicTqeGDh2q119/vdExTz/9tPLy8pSYmKiRI0fq3XffPeE1N2zYoJEjRyoxMVH9+/fX0qVLO+3aAAAAAICGAvMDdu3a8nF2uzl0OD6+42sCToQgEFaxNAg8dOiQrr/+evXp00evvPKKBg4cqKuuukput/uEry0tLdV1112nCy64oNG+zZs36+qrr9bUqVP14YcfaurUqbrqqqu0devW4DGvvvqqbr/9ds2fP187duzQeeedp8mTJ2vPnj3NXrOwsFAXXXSRzjvvPO3YsUN33323br31Vq1cubLDrw0AAAAAaKz+/IBApCAIhFUsDQLnzJmjrVu36qWXXtJFF12k3//+98rLy5Pf7z/ha6dPn64pU6ZozJgxjfYtWbJEEydO1Lx583Tqqadq3rx5uuCCC7RkyZLgMY8//rhuvPFG3XTTTRoyZIiWLFmi3r1765lnnmn2mkuXLlWfPn20ZMkSDRkyRDfddJNuuOEGLV68uMOvDQAAAABoqLn5AYFwRxAIq1i6WMiOHTs0depUjR8/XsuWLdOECRM0YcKEE75u2bJl+uqrr/Tyyy/roYcearR/8+bNmjNnToNtF154YTCMc7vd2r59u+66664GxxQUFGjTpk3NXnfz5s0qKChodN7nnntOHo9H8fHxHXLt2tpa1dbWNthmt9vldDqbrTUSeDyeBo9AOON+RaTjHkY04D5GtOGePnnFxZLXa1PXrpLPZ8jns7qi2MI93H6GYd67NTWSx2NYXU7MidZ7N74Vcx9YGgSec845WrZsmYYPH97q13zxxRe666679O677yourunyi4uLlZ2d3WBbdna2iouLJZlDkn0+X4vHtOW8Xq9Xhw4dUm5ubodc++GHH9b999/fYNvVV1+ta665ptlaI8natWutLgFoNe5XRDruYUQD7mNEG+7p9vvqq3SVlCSqZ89KHTlSYXU5MYt7uO3cbrs++KC7bDbJ7//O6nJiVrTdu5deeukJj7E0CHz88ce1aNEizZkzR1999ZU++OADzZgxQzNmzGjyeJ/PpylTpuj+++/XKaec0uK5bTZbg88Nw2i0rTXHtOa8x28P9bXnzZunuXPnNtgWLR2Ba9eu1cSJE1uVWgNW4n5FpOMeRjTgPka04Z4+ef/8p9lRNWaMccLFQhB63MPt5/VKcXFmBnDhhYYcDosLijGxfO9aGgQmJydr4cKFWrhwoS677DJNnjxZc+bMkd1u1y9/+ctGx5eXl+vf//63duzYoVmzZkmS/H6/DMNQXFyc1qxZo/PPP185OTmNuusOHDgQ7MLr1q2bHA5Hi8c0pbnzxsXFqeux/+p0xLWdTmfEh34tiY+Pj7lvPEQu7ldEOu5hRAPuY0Qb7un28fsDYYq5YjBfQutwD7ddfHzdPIE2G/evVWLx3rV0sZD6MjIyNH36dE2ePFnvvvtuk8ekpaVp586d+uCDD4IfM2bM0ODBg/XBBx9o9OjRkqQxY8Y0au9cs2aNxo4dK0lKSEjQyJEjGx2zdu3a4DFNae68o0aNCt44HXVtAAAAAECd+lN7NTNrFBDWWDAEVrD0x+WcOXN02WWX6YwzzpDP59P69eu1YcMG3XPPPU0eb7fbNWzYsAbbsrKylJiY2GD7bbfdpnHjxunRRx/VpZdeqlWrVumf//ynNm7cGDxm7ty5mjp1qkaNGqUxY8bo2Wef1Z49e5odlixJM2bM0JNPPqm5c+fqF7/4hTZv3qznnntOr7zySodfGwAAAABQJxAExsebHVVApImLM0NAgkB0JkuDwD59+mju3Ln64osvVFlZqbfffls33HCDZs+efVLnHTt2rP74xz/qnnvu0b333qsBAwbo1VdfDXYMSuZiGyUlJXrggQe0f/9+DRs2TG+++ab69u0bPGbBggVavny5du/eLUnKy8vTm2++qTlz5uipp55Sjx499MQTT+iKK64I+bUBAAAAAM0LBIF0AyJS0REIK1jeEThnzhxJ0rRp07R8+fI2n2PBggVasGBBo+1XXnmlrrzyyhZfO3PmTM2cObPZ/bt371Z+fn6DbePHj9f777/f4nlDcW0AAAAAQPMC4UmMTe+FKEIQCCvwt5MWbNiwQe+8847VZQAAAAAAjuN2m48EgYhUBIGwQtgEge3pBuxohYWFVpcAAAAAAGgCHYGIdASBsELYrBoMAAAAAEBr1V8sBIhEBIGwAkEgAAAAACDiEAQi0hEEwgoEgQAAAACAiEMQiEhHEAgrEAQCAAAAACIOQSAiHUEgrEAQCAAAAACIOASBiHQOh/lIEIjORBAIAAAAAIg4BIGIdHQEwgoEgQAAAACAiEMQiEhHEAgrEAQCAAAAACJOIAgMhClApCEIhBUIAgEAAAAAEScQBCYkWFsH0F6BINDns7YOxBaCQAAAAABARPH5JMMwn9MRiEhFRyCsQBAIAAAAAIgogW5Am40gEJErcO8G7megMxAEAgAAAAAiCguFIBoEgkC/v67DFehoBIEAAAAAgIhCEIhoUL+bleHB6CwEgQAAAACAiEIQiGhgt5sfEkEgOg9BIAAAAAAgohAEIlqwYAg6G0EgAAAAACCiEAQiWhAEorMRBAIAAAAAIkogCGTFYEQ6gkB0NoJAAAAAAEBECQSBCQnW1gGcLIJAdDaCQAAAAABARKEjENHC4TAfCQLRWQgCAQAAAAARhTkCES3oCERnIwgEAAAAAESUQGhCEIhIRxCIzkYQCAAAAACIKHQEIloEgkCfz9o6EDsIAgEAAAAAEYUgENGCjkB0NoJAAAAAAEBEIQhEtCAIRGcjCAQAAAAARAzDIAhE9AgEgYF7GuhoBIEAAAAAgIhRv3OKIBCRzuk0H2tqrK0DsYMgEAAAAAAQMQKdU3a7+QFEsqQk87G62to6EDv4sQkAAAAAiBiBjsCEBGvrAELB5TIfa2slv9/aWhAbCAIBAAAAABHD7TYfA3OrAZEsIUFyOMzndAWiMxAEAgAAAAAiRqAjkPkBES0CXYFVVdbWgdhAEAgAAAAAiBisGIxowzyB6EwEgQAAAACAiEEQiGgT6AgkCERnIAgEAAAAAEQMgkBEG4YGozMRBAIAAAAAIgZBIKINQ4PRmQgCAQAAAAARgyAQ0YahwehMBIEAAAAAgIhBEIhoUz8INAxra0H0IwgEAAAAAEQMgkBEm8REyWYzQ8CaGqurQbQjCAQAAAAARAyCQEQbm43hweg8BIEAAAAAgIgRCALj4qytAwglgkB0FoJAAAAAAEDE8HrNRzoCEU0CQWBVlbV1IPoRBCJq1Byt0b5t+1R9hD+hAAAAANHIMOqCQDoCEU2SksxHOgLR0QgCETVK95SqorhC327+VtWH+ekJAAAARBufr+45HYGIJgwNRmchCETU8Naafxr0+/z6dgthIAAAABBtAt2Adrv5AUQLhgajs/CjE1HD7/FLkhwJDsJAAAAAIAqxUAiiFUOD0VkIAhE1fG5znEDO8Bwld08mDAQAAACiDPMDIloFOgJ9PsnttrYWRDeCQEQNn8cMAuNccepxVg/CQAAAACDKEAQiWtntktNpPqcrEB2JIBBRI9AR6EhwyO6wEwYCAAAAUSYwNJiFQhCNWDAEnYEgEFHB7/XL8BuSJEe8Q5IIAwEAAIAoQ0cgoolhGDL8hvxev3xunxIcXvk8PhYMQYfixyeiQmBYsM1ukz2uLt8OhIFF24pUebBS3275Vr3O7iVXpsuqUgEAAAC0E0EgIonf69d3H32nmqM1MvxG4w/DaHD8oT0J2l8cr+6JKerfP8OaohH16AhEVAgOCz7WDVgfnYEAAABAdGBoMCKFYRjav2O/yvaVyV3plqfaI2+t2fHn9/kbhYCS5Eo0t+3fVSZvrbezS0aM4O8oiAr15wdsCp2BAAAAQOSjIxCRomRXiSqKK2Sz25Q7IlfxSfGy2W3NfsgmZR6yqfC5A6qsqtHhLw8r67Qsq98GohAdgYgKfo9fUvNBoERnIAAAABDpCAIRCcq+LVPJFyWSpJzhOUrtkarEjEQ505xKSElQfFK84hLjzIUu4+xmGGizKTlZSuuVpppau44UHpWn2mPxO0E0IghEVAh0BNrjW76lG4WBW7+Vt4aWawAAACASEAQi3FUfqVbxh8WSpMyBmUrrldbq17pcUlKXRMWnOFVTI5V8XtJRZSKGEQQiKgQWC2mpIzAgEAYmpifK7/Xr6DdHO7g6AAAAAKHAHIEIZ55qj4q2FcnwG0rJSVG3U7u16fU2m5SUZHYFVtXYVbbXnF8QCCWCQESFE80ReDy7w64uA7pIkkq/KZXhbzxRKwAAAIDwQkcgwpXf59e+9/bJW+uVM82p3BG5stlsbT5PcrLkTHXKnpoiwzBUsouuQIQWQSCiQkurBjcnNTdVcYlx8tZ6Vb6/vKNKAwAAABAiBIEIR4ZhaP/7+1VbVqs4Z5x6fr+n7HHti1uSk83HhJxMSVLZvjLVltWGqlSAIBDRoa0dgZJks9uU0TdDknS08GgHVAUAAAAglBgajHBUf4XgHqN6KN7V/hs0EAR67QlK7ZEqSTq061AoygQkEQQiSrRm1eCmpPdNl81uU/WRatUcremI0gAAAACECB2BCDdl+xquEOzKdJ3U+QJBYEWF1G1wN9lsNlUUV6j6SPXJlgpIIghElGjtqsHHi3PGBf/KcqTwSMjrAgAAABAahkEQiPBSc7RGxR+0b4Xg5gSCwKoqKT45IXhO5gpEqBAEIiq0Z2hwQJc8c9GQ8qJyeWu9Ia0LAAAAQGj4fHXPCQJhtfKicu3dvNdcITi77SsEN8flkux2ye+Xamqkrqd0lc1uU+XBSlUdqgrJNRDbCAIR8QzDkM/T/iAwMSNRri4uGX5Dpd+Uhro8AAAAACEQ6Aa02yVH2/+3HwgJw2/ou53fqWh7kfxev5K6Jin3zPatENwUm01KSjKfV1ZK8UnxSu+TLkk69BlzBeLkEQQi4gXmB5TatmpwfRl5GZKko98cleE3QlEWAAAAgBAKLBRCNyCs4qnyaM/GPTq6+6gkqeugruo1ple7VwhuTmB4cGWlgtexO+yqPlKtiu8qQnotxB6CQES8QDegPc4um719f4VJzU1VnDNO3hqvyveXh7I8AAAAACHA/ICwUkVxhb555xvVlNbIEe9Qr9G91O3UbiHrBKzv+CAwLjEu2Lxy6LNDMgyaV9B+BIGIeMH5AdvZDShJNrtNGf0yJElHC4+GoCoAAAAAoUQQCCsYfkMHPj6gfdv2yefxydXFpb7j+yo5K7nDrnl8EChJmQMyZY+zq7asVhX76QpE+xEEIuKdzEIh9aX3TZfNblP1kWrVHK0JRWkAAAAAQoShwehsnmqP9m7aqyNfH5FkhnG9x/ZWvCu+Q6/bVBDoSHAoc0CmJLoCcXIIAhHxAnMEnmwQGOeMU2puqiTpSOGRk64LAAAAQOgEOgLjOzaDASRJFd9V6JsN36j6SLUc8Q71PKunug/t3u7pqNqifhBYP+/r0r+LHAkOuSvdKt/HlFZoH4JARLxQdQRKdYuGlBeVy1vrPenzAQAAAAgNhgajMxh+Qwc/Pah975lDgRMzEtV3XF+l5KR0Wg0ul7k6tt8v1dQbrGaPswe7Aku+KKErEO1CEIiIFwgC7fEnfzu7uriUmJEow2+odE/pSZ8PAAAAQGgQBKKj+dw+7d28V4e/PCxJ6pLXRX3O6aP4pM5tQ7XZzDBQajg8WJIy+mXIEe+Qu8KtimLmCkTbEQQi4gVWDQ5FR6Bk/rCXpKO7j8rw8xcWAAAAIBwE5ghkaDA6SsnnJao+XC17nF09RvVQ1rCsThkK3JSUYw2IxweB9jh7cKHLw18c7tyiEBUIAhHxQrFqcH2pPVIV54yTt8bLX1gAAACAMEFHIDqSYRgqLzLn3cs9Mzc4f7xVmlowJKBL/y6yO+yqKa1R5cEmDgBaQBCIiBfKOQIlyWa3Kb1vuiQWDQEAAADCBUEgOlLVoSp5a71yJDiU3D3Z6nKUlGQ+NhUEOhIcwd9Z6QpEWxEEIuKFOgiUpIy+GbLZbKo+XK2a0poTvwAAAABAh2JoMDpS2bdlkswRYlYNB64v0BFYVdX0/swBmbLZbaoqqVL14erOKwwRr81BYH5+vl588UVVV3OjITz4PX5JoVksJCAuMU6pPcxW8KOFR0N2XgAAAADtQ0cgOorf5w9OC5XWM83iakwtdQRK5u+sab3MWgOLmwCt0ebkZOTIkbrzzjuVk5OjX/ziF9qyZUtH1AW0Wkd0BEoKTsDKPIEAAACA9QgC0VEqv6uU3+tXfFK8XJkuq8uRVBcE+nxSbW3Tx2QOzJTNZlPFdxWqLWvmIOA4bQ4Cf/3rX2vfvn168cUXdfDgQY0bN05Dhw7V4sWL9d1333VEjUCzDL8hv8/sCAx1EJiYkSib3Safxyd3pTuk5wYAAADQNoGhwQSBCLWyfeaw4HDpBpQku11yHcskm+sKTEhOCI5kK/mipJMqQ6Rr11hKh8OhSy+9VP/zP/+jffv2acqUKbr33nvVu3dvXXbZZVq3bl2o6wSaFOgGtNlssseFdspLm90mZ5pTklRbyl9XAAAAACsFOgKZIxCh5PP4VHnATNpSe1q7UvDxTjRPoGR2BUpSeVE5DSxolZNKTt577z396le/0uLFi5WVlaV58+YpKytLP/rRj3THHXeEqkagWYEg0B5vl80W+gldE9MTJYkFQwAAAAALGQZDg9ExyovKZfgNOdOccqY6rS6ngRPNEyhJzjSnUrJTJDFXIFqnzUHggQMH9Otf/1rDhg3Teeedp4MHD+qPf/yjdu/erfvvv1/PPvusVq1apaVLl3ZEvUADPs+x+QHjQzssOCAx41gQeJQgEAAAALCKz1f3nCAQoVS+r1xSeA0LDmhNR6AkZQ4yuwLL9pbJU+3p4KoQ6dr8I7RXr14aMGCAbrjhBk2bNk3du3dvdMz3v/99nXXWWSEpEGhJRy0UEuBMZ2gwAAAAYLVAN6DNJjk65n/9EYM81R5VlZgpW7gNC5Za1xEoSa4uLiV1S1LVoSod+eqIsoZldXxxiFhtDgLfeustnXfeeS0ek5aWpvXr17e7KKC1/J6OWSgkwJnqDC4Y4qnyKD6JCUkAAACAzsZCIegI5UVmN2BS1yTFu8Lvd73WdgRKUtdBXVV1qEqle0qVOShTcU6+WdC0Ng8NPlEICHSmju4ItNltwXkiGB4MAAAAWIOFQtARyr41VwsOx25Aqa4jsLa27nug2WO7JSkxI1F+n19HC492eG2IXO2KiP/yl7/oT3/6k/bs2SO3u+GqNO+//35ICgNao/5iIR0lMSNRNaU1qimtCS7NDgAAAKDzsFAIQq22vFa1ZbWy2W1h+3tefLyUkCC53WZXYNoJpjHsOqir9m3bpyOFR9RlQJcOm0sfka3N6ckTTzyhn//858rKytKOHTv0/e9/X127dtXXX3+tyZMnd0SNQLOCi4V0UEegxDyBAAAAgNUIAhFqgUVCkrOSwzowa+08gZKUnJ0sZ6pTfq9fR3cf7dC6ELnaHAQ+/fTTevbZZ/Xkk08qISFBd955p9auXatbb71VpaWlHVEj0KyOHhossXIwAAAAYLXAHIEMDUaolO0zhwWH42rB9bVlnkCbzRZcQfjI10fk9/k7sDJEqjYHgXv27NHYsWMlSS6XS+XlZoo+depUvfLKK6GtDjiBYBDYgX/BOX7BEAAAAACdi45AhFL14Wp5qjyyx9mVnJ1sdTktaktHoCSl9khVfFK8fG6fSvfQrIXG2hwE5uTkqKSkRJLUt29fbdmyRZJUWFgowzBCWx1wAp3REdhgwZBSugIBAACAzkYQiFAKdAOm5KTI7ui4+eZDoS0dgdKxrsCBZlfg4S8Py/CT06ChNt/x559/vv76179Kkm688UbNmTNHEydO1NVXX60f//jHIS8QaInfY7Y6d2QQKNXNE8jwYAAAAKDzBYYGEwTiZBl+Q+VF5sjGtF7hPSxYqgsCW9sRKEnpvdMVlxgnb403uDIyENDmH6PPPvus/H4zfJkxY4YyMzO1ceNG/ehHP9KMGTNCXiDQks5YNVgy5wks3VPKgiEAAACABQIdgcwRiJNVdahKPrdPcc44JXVLsrqcEwoMDa6ulvx+yd6KX31tdpu69O+ig58c1OEvDyutd5psNlvHFoqI0eYg0G63y17vzrvqqqt01VVXhbQooDX8Xn9wOHpHdwQmprNgCAAAAGAVhgYjVAIdcqk9UiMiHEtMlBwOyeczw8DkVk5pmNE3Q4e/OCx3pVsV+yuU2iO1YwtFxGjVj9GPPvqo1Sf83ve+1+5igLYIdAPa7LYOn9fBmeaUzXZswZBqj+Jd/CkSAAAA6CwEgQgFv8+viuIKSVJqz8gJxpKSpPJyc57A1gaB9ji7uvTvokO7Dunwl4cJAhHUqh+jZ5xxhmw2mwzDOGFi7vP5QlIYcCKdsVBIgM1uU0JqgmrLalVztIYgEAAAAOhEgTkCGRqMk1FRXCG/z6/4pHi5urisLqfVkpPNIPCLL6T0dCkhoXWvy+iXoUO7DqmmtEZ+r1/2uPBeGAWdo1V3QWFhob7++msVFhZq5cqVysvL09NPP60dO3Zox44devrppzVgwACtXLmyo+sFgnyezgsCJXOeQEnMEwgAAAB0MrfbfCQIxMko33dskZCe4b9ISH0DB5rdsCUl0saNrV84xJHgCP6+7KnydGCFiCSt6gjs27dv8PlPfvITPfHEE7rooouC2773ve+pd+/euvfee3XZZZeFvEigKcGOwPhOCgLTE1WqUuYJBAAAADqRYZhzo0mSK3KauBBmvLVeVR4wE7RIWC24vi5dpHPPlbZuNUPAd9+VRo2SunU78Wvjk+Llc/vkqfLImebs+GIR9trcF7pz507l5eU12p6Xl6dPPvkkJEUBrdGZQ4Oluo7AmlKCQAAAAKCzuN3maqk2m7lwAtAexR8UyzAMJWYkKiGllWNrw0hqqnTeeWYo6PFIW7ZIe/ac+HUJyeZ7dVe6O7hCRIo2B4FDhgzRQw89pJqaujCktrZWDz30kIYMGRLS4oCW+D1+SZ0XBAYXDHGbC4YAAAAA6HhVVeaj0ynZmeIM7XDk6yOqPFApm92mnOE5VpfTbk6nNHas1LOn2Sn74YfSJ5+Yz5sTn2SOp2doMALavObS0qVL9aMf/Ui9e/fW8OHDJUkffvihbDab/va3v4W8QKA5nd0RWH/BkNrSWhYMAQAAADpBYFhwUpK1dSAy1ZTW6OCnByVJWadlRfzwWLtdOvNMKSVF2rVL+uorc7jwiBFNr6odDAIrCQJhanMQ+P3vf1+FhYV6+eWX9dlnn8kwDF199dWaMmWKklu7jjUQAoEg0B7feX8WTMxIDK4cnJKT0mnXBQAAAGIV8wOivfxev/Zv3y/Dbyg1N1UZ/TKsLilkTjnFXE34gw+k4mLpX/+SRo9uPHw+PpmOQDTU5iBQkpKSkvTLX/4y1LUAbdLZqwZL9RYMYZ5AAAAAoFMEhgYTBKKtvvvoO7kr3Yp3xSt7eLbV5YRcz55mp+y2bVJZmbmi8IQJkqPer8j1hwYbhiGbzWZRtQgXzLCAiNXZqwZLkjPdbCNn5WAAAACgczA0GO1RurdUZfvKZLPZlHtmbqf+3tiZAisKx8eb3yvl5Q33xyXGyWa3yTAMeau91hSJsEIQiIjV2XMESiwYAgAAAHQ2hgajrdwVbh3YeUCS1HVwV7kyo/vmSUqq+/5wH7c4sM1mY8EQNBA2QeC0adOsLgERprNXDZYku8OuhFRz+fXa0tpOuy4AAAAQqwgC0RaG31DR9iL5fX4ldUtS5sBMq0vqFM5ja6AcHwRKrByMhtoUBPp8Pm3YsEFHjhzpqHpOaOPGjTrnnHPUtWtXuVwunXrqqfqv//qvRsetXLlSQ4cOldPp1NChQ/X66683Oubpp59WXl6eEhMTNXLkSL377rsnvP6GDRs0cuRIJSYmqn///lq6dGmnXRt1DMOwZI5AyZwnUGJ4MAAAANDRPB7zQ2JoMFrn4CcHVVtWK0eCQ7kjcmNmTrwEs19FtU30qyQkmzvdlU2khIg5bQoCHQ6HLrzwQh09ejQkFz906JCuv/569enTR6+88ooGDhyoq666Su6mIuxjkpOTNWvWLL3zzjv69NNPdc899+iee+7Rs88+Gzxm8+bNuvrqqzV16lR9+OGHmjp1qq666ipt3bo1eMyrr76q22+/XfPnz9eOHTt03nnnafLkydqzZ0+z1y4sLNRFF12k8847Tzt27NDdd9+tW2+9VStXruzwa6OhQDeg1LmrBkvmysGSWDAEAAAA6GCBbsCEhIYLIABNqSiu0JFCs3Epd0Su4hLbtT5qRKIjEK3V5gTl9NNP19dffx2Si8+ZM0dbt27VSy+9pIsuuki///3vlZeXJ7/f3+xrRowYoWuuuUannXaa+vXrp2uvvVYXXnhhg466JUuWaOLEiZo3b55OPfVUzZs3TxdccIGWLFkSPObxxx/XjTfeqJtuuklDhgzRkiVL1Lt3bz3zzDPNXnvp0qXq06ePlixZoiFDhuimm27SDTfcoMWLF3f4tdFQ/YVCOvsvPIEFQxgaDAAAAHQshgWjtbw1XhV/UCxJ6tK/i5Kzki2uqHO11BEYDAIrCQIhtTkeX7hwoe644w49+OCDGjlypJKTG35zpaWltfpcO3bs0NSpUzV+/HgtW7ZMEyZM0IQJE9pUz44dO7Rp0yY99NBDwW2bN2/WnDlzGhx34YUXBsM4t9ut7du366677mpwTEFBgTZt2tTstTZv3qyCgoJG533uuefk8XgUHx/fIdeura1V7XHfzXa7Xc5A5B+hPMd6/AOPbVFTWSOf1ydbgq1drz8ZdpddPp9PvkqfqsurY+qvTLHsZO5XIBxwDyMacB8j2nBPn1hpqeT12hQfL3k8htXl4Djhcg8bhqF97+2Tu9otZ7pTGQMzLK+ps9nt5vdKVVUT3ysJks/rU3VZdcx9XZoTLvduqMXHx5/wmDYnGJMmTZIkXXLJJQ06sQzDMFdT9flafa5zzjlHy5Yt0/Dhw9tahnr16qWDBw/K6/VqwYIFuummm4L7iouLlZ2d3eD47OxsFRebfx04dOiQfD5fi8c0pbnzer1eHTp0SLm5uR1y7Ycfflj3339/g21XX321rrnmmmZrjSRr165t82s8Rzyq+qJKjmSHPq35tAOqalnFxxXyVfn0Sekniu9y4m80RI/23K9AOOEeRjTgPka04Z5u3t69qdq/P0k5OVU6cKDc6nLQDKvv4Zp9NardVyubw6bk05L1f6v/z9J6rHDkiFNffJGh5GSPDh483GCf4TNUtr1MkvRZ7WeyxcXGvImtYfW9G2qXXnrpCY9pcxC4fv36dhXTlMcff1yLFi3SnDlz9NVXX+mDDz7QjBkzNGPGjBO+9t1331VFRYW2bNmiu+66SwMHDmwQjB0/XDQQVNbXmmOO19Rrjt8e6mvPmzdPc+fObbAtWjoC165dq4kTJ7Yqta6vbG+Zvkv/TklZSer5/Z4dVGHzvuvxncq+LVPmoEx1Hdy106+Pzncy9ysQDriHEQ24jxFtuKdP7P33paIim4YONdS/v9XV4HjhcA9XlVRp35Z9Uq6UMyJHqT1TLanDaocPS+npNiUlSeef37h7ttBVKG+NV73P7R2c9z6WhcO9a5U2B4Hjx48P2cWTk5O1cOFCLVy4UJdddpkmT56sOXPmyG6365e//GWLr83Ly5Nkzln43XffacGCBcEgMCcnp1F33YEDB4JdeN26dZPD4WjxmKY0d964uDh17dq1w67tdDojPvRrSXx8fJu/8WyGTY44h5wupyXftMndklVZXClvpTfmfmjEuvbcr0A44R5GNOA+RrThnm6exyPFxUlpaRJfovBl1T3sc/t0aOchORwOpfdOV2a/zE6vIVykpJjfKz5f098riWmJqvZWS57WDR+NFbH487ddy62+++67uvbaazV27Fjt27dPkvTSSy9p48aN7S4kIyND06dP1+TJkxss/NEahmE0mENvzJgxjdo716xZo7Fjx0qSEhISNHLkyEbHrF27NnhMU5o776hRo4I3TkddGw0FVg12JFizdFjgLygsGAIAAAB0nKoq8zEpydo6EJ6+2/mdvDVeJaQkKGtYltXlWCqwWIjPZ34cL7BgiLuyiWWFEVPaHASuXLlSF154oVwul95///1gAFdeXq5Fixa16Vxz5szRhg0bVFpaKp/Pp/Xr12vDhg0aOXJks6956qmn9Ne//lVffPGFvvjiCy1btkyLFy/WtddeGzzmtttu05o1a/Too4/qs88+06OPPqp//vOfuv3224PHzJ07V//93/+t559/Xp9++qnmzJmjPXv2tDgsecaMGfrmm280d+5cffrpp3r++ef13HPP6Y477ujwa6Oh4KrBFgWBzjSnbDabvLVeeWu8ltQAAAAARDO/v24FVFYNxvG8tV5V7K+QJOWemSt7XLv6nKJGfLy5YIgkuZvI+hKSzaTQUxVdi2Og7do8NPihhx7S0qVLdd111+mPf/xjcPvYsWP1wAMPtOlcffr00dy5c/XFF1+osrJSb7/9tm644QbNnj272df4/X7NmzdPhYWFiouL04ABA/TII49o+vTpDWr54x//qHvuuUf33nuvBgwYoFdffVWjR48OHnP11VerpKREDzzwgPbv369hw4bpzTffVN++fYPHLFiwQMuXL9fu3bslmcOR33zzTc2ZM0dPPfWUevTooSeeeEJXXHFFyK+NlgWCQHu8NT/s7Q67ElISVFteq5qjNUrJSbGkDgAAACBaVVebjw5HXbcTEFBeVC7DMOTq4lJiOnPeSeb3SU2NGaAfH54HOgI9lQSBsa7NQeCuXbs0bty4RtvT0tJ09OjRNp1rzpw5mjNnjiRp2rRpWr58+QlfM3v27BaDwoArr7xSV155ZYvHzJw5UzNnzmx2/+7du5Wfn99g2/jx4/X+++93+LXRMp/H2o5AyRweXFteq5pSgkAAAAAg1ALDgukGRFPKi8xVpFN7xObiIE0JBIFNdQTGJx8LAukIjHltDgJzc3P15Zdfql+/fg22b9y4Uf2jbBmnDRs26J133rG6DDTB6qHBkuRMd0p7mScQAAAA6AiBjkDmB8TxPNUeVR82bxCCwDqBNUabDAIDHYHVHhl+Qza7rRMrQzhp87jK6dOn67bbbtPWrVtls9lUVFSkP/zhD7rjjjtOqsOtNd2Ana2wsFC9e/e2ugw0IRgExlvYEXis/bzmaI1lNQAAAADRKhAE0hGI4wW6AZO6Jikusc39TVErMIS+tolelThnnOwOMwLyVNMVGMva/B1z5513qrS0VBMmTFBNTY3GjRsnp9OpO+64Q7NmzeqIGoFGwqUjsP6CIfwHCAAAAAgdgkA0h2HBTWupI1AyhwfXltXKU+kJLh6C2NOu5GLhwoWaP3++PvnkE/n9fg0dOlQpKcyRhs7h9/ll+A1J1gaBDRYMKa1RSiLfAwAAAECoVFaajwwNRn3uSrdqjtbIZrMpJZffweprqSNQMocH15bVMk9gjGt3C1NSUpKys7PNbz5CQHQiv8cvSbLZbJYvEe9Md9atHJzN9wEAAAAQKhUV5iO/bqK+4LDgbkmKczIqq74TdgQemyfQXdnMAYgJbU5RvF6v7r33XqWnp6tfv37q27ev0tPTdc8998jjIVVGxwuHYcEBiRnmPIEsGAIAAACEjttdF2YQBKI+hgU370QdgYHhwHQExrY2x+ezZs3S66+/rscee0xjxoyRJG3evFkLFizQoUOHtHTp0pAXCdQXCALt8dZ2A0r1FgwpZcEQAAAAIFQC3YAul+Sw/u//CBPuCrdqy2plszMsuCmBIPBEHYGeSoLAWNbmIPCVV17RH//4R02ePDm47Xvf+5769Omjn/70pwSB6HDh1BHoTDN7r701LBgCAAAAhEq52fSlVJq+UE/ZvjJJUnL3ZDnirf99MNwEhgY3O0dg8rEgkI7AmNbmlqrExET169ev0fZ+/fopIYFVZ9DxfJ7wCQLtceaCIRJdgQAAAECoMD8gmsKw4JYFIhmfz/w4XrwrXjabTX6fX95ab+cWh7DR5iDwlltu0YMPPqjaehFzbW2tFi5cqFmzZoW0OKAp4dQRKDFPIAAAABBqdATieLVltXJXuM1hwTkkxE2Jj5fsx1KepoYH2+y24Cg2hgfHrjaPY9yxY4feeust9erVS8OHD5ckffjhh3K73brgggt0+eWXB4997bXXQlcpcEwwCAyTVvDE9ESVfVummqN0BAIAAAChQEcgjhcYFpySnSJ7nPXzxYerhASppsYcHuxyNd4fnxwvT7VHniqPXJlNHICo1+YgMCMjQ1dccUWDbb179w5ZQcCJ+D1+SeHXEcjQYAAAAODkeb1SdbX5nCAQAQwLbp1AEHjCBUOYJzBmtTkIXLZsWUfUAbRauA0NbrBgSK1XcU4WDAEAAADaq7LSfExIqJvzDLGt5miNPFUe2R12JWcnW11OWDvRgiEJyeY3lbuymaQQUY9+WkScQBBojw+P27fBgiEMDwYAAABOCvMD4njBYcE5KbI7wuP3wHAVCM/pCERz+A5CxAmnVYMDEtNZMAQAAAAIBeYHRH2GYTAsuA0CHYHNBoHJx4JAFguJWQSBiDjhtliIxDyBAAAAQKgEOgIJAiFJNUdq5K3xyh5nV3IWw4JPJNAR2NzQ4EBHoLfWK7/P30lVIZwQBCKiGIYRdouFSJIz3fyzC0ODAQAAgJMT6AhkaDCkumHBqbmpstltFlcT/k7UEeiIdwSbahgeHJsIAhFR/F6/DMOQFF5BYGBocGDBEAAAAABt5/fXLRZCEBh9Ar/LteX4iv1mMsyw4NY5UUegVG+eQIYHx6Q2LW/q9/u1fPlyvfbaa9q9e7dsNpvy8vJ05ZVXaurUqbLZSOfRsYILhTjsYfXXoMCCIe4Kt2pLaxWXxcrBAAAAQFtVVUmGIcXFSYmJVleDUHJXuLVn4x7ZHDal5KQoJSdFSV2TWvy9rrqkWt5arxzxDiV1S+rEaiPXiToCJXOewJrSGjoCY1Sr0wrDMHTJJZfozTff1PDhw3X66afLMAx9+umnmjZtml577TX9z//8TweWCigshwUHJKYnyl3hVs3RGuauAAAAANqB+QGj16Fdh8yFHz3S0d1HdXT3UTniHUrOTlZqbqqSuic1WhE4uFpwbkpYNYKEs7Z0BLorW0gLEbVaHQQuX75c77zzjt566y1NmDChwb5169bpsssu04svvqjrrrsu5EUCAcGOwPjwG9XuynSpbF+Zqg9XW10KAAAAEJFYMTg61ZbVBlf+zf5etmqO1qiiuEI+t09l35ap7Nsy2R12JXVPUmpuqpKzk2V32IPDgtN6pllZfkQJBIE+n/nhaKKHJiHZPIiOwNjU6iDwlVde0d13390oBJSk888/X3fddZf+8Ic/EASiQwVXDA7DjkBXV5ckqfpwtQy/wV+sAAAAgDYKdAQyP2B0Kfm8RJK54EdG3wypr2R8z1DNkRqV7y9Xxf4Keao9qiiuUEVxhWw2m5xpTvk8PsU544K/a+HE4uPN8M/nk2pqpOQmBqsxR2Bsa3Vb1UcffaRJkyY1u3/y5Mn68MMPQ1IU0JxwDgKdqU45Ehzy+/ysHgwAAAC0Ax2B0ae2rFbl+82Et+vgrsHtNptNrkyXsk7LUv8f9FffcX3V9ZSucqY6ZRiGakrN36lSclNYj6CNAvNr1jTza2l88rEgsNrT5gVcEPla3RF4+PBhZWdnN7s/OztbR44cCUlRQHN8nvANAiUpqWuSyveXq6qkSq5M/moFAAAAtJZh1AWBdARGj0O7DkkyV/11pjqbPS4xPVGJ6YnqNrib3JVuVeyvkLvSra6ndG32NWiay2Wuvt1cEBiXGCeb3SbDb8hb41W8K75zC4SlWt0R6PP5FBfXfG7ocDjk9XpDUhTQnGBHYHyYBoHHVrKqLmGeQAAAAKAtqqvN4Yx2u5TEArFRobasVhXFZrrblkAvITlBmQMzlTM8R3HOVvcv4ZhAR2B1M7+W2my2YPjHPIGxp02rBk+bNk1OZ9MJfm1LS9IAIRLOqwZLzBMIAAAAtFegGzA5WWIkaHQIdAOm9UxrsRsQoeU6NjituSBQMucJdFe6zXkCabqMKa0OAq+//voTHsNCIeho4TxHoFQ3T6DP7VPN0RqGBwMAAACtxPyA0aWmtCa48AfDezvXieYIlI7NE3iQjsBY1OogcNmyZR1ZB9AqgSDQHt/qUe2djnkCAQAAgLZjxeDoUrLr2ErBPVKVkJJgcTWxpTUdgQnJ5r+Ju9LdCRUhnJx0mvLNN9/ok08+kd/vD0U9QIvCfbEQiXkCAQAAgPagIzB61BytUcV3x7oBB9MN2NkCQWCLHYFJzBEYq1odBL7wwgtasmRJg22//OUv1b9/f51++ukaNmyY9u7dG+r6gAbCfWiw1HieQAAAAAAnRkdg9Cj5/Fg3YM/UYOcZOk9gaHBtrdRcz1YwCKwkCIw1rQ4Cly5dqvT09ODnq1ev1rJly/Tiiy9q27ZtysjI0P33398hRQKSZPgN+b3HFgsJ01WDpbp5Av0+v2qOtvAnGAAAAACSzMDCcyyPSE62thacnAbdgMwNaImEBHP1ban5rsBAEOjz+IIj7xAbWh0Efv755xo1alTw81WrVumSSy7Rz372M5155platGiR3nrrrQ4pEpDU4IdTOM8RKJnzBEpSVUmVxZUAAAAA4S8wLDgpSXKE79/80QrBlYJ7pdENaKETDQ+2x9kV5zSXjWB4cGxpdZpSXV2ttLS04OebNm3SuHHjgp/3799fxcXFoa0OqCc4LDjeIZvNZnE1LWOeQAAAAKD1mB8wOlQfqVblgUrZbDZlDsq0upyYFhge3NKCIQwPjk2tDgL79u2r7du3S5IOHTqkjz/+WOeee25wf3FxcYOhw0Co+T3HhgWH8fyAAcwTCAAAALQe8wNGh8BKwWm96Qa0WqsWDElmwZBYFNfaA6+77jrdcsst+vjjj7Vu3TqdeuqpGjlyZHD/pk2bNGzYsA4pEpAiY6GQgMA8gT63TzVHa+TKdFldEgAAABC26AiMfNWHq1V50OwG7DqIuQGt1paOQHeluxMqQrhodRD4//7f/1NVVZVee+015eTk6M9//nOD/f/61790zTXXhLxAICAQBIb7/IABSV2TVL6/XFUlVQSBAAAAQAsCHYEEgZHJMAwd+uzY3IC904IBE6wT6AhsKQgMdG3SERhbWh0E2u12Pfjgg3rwwQeb3H98MAiEWiR1BErmPIHl+8vNeQIHWV0NAAAAEJ683rrhiwwNjjyG31Dx+8WqLqmWzU43YLgIdAS2ODQ4iaHBsajVQSBgtcCqwZESBB4/T6DNHt4LnAAAAABWCAwLdjqleBrJIorf51fVl1WqUIXiEuLUY2QPugHDRKvmCDz2b+Wt9vI7awxp9RhLu90uh8PR6KNLly46++yz9dprr3VknUDEdQQG5gn0+/yqOdrCT18AAAAghjE/YGTye/0qeq9I3qNe2Rw29fx+T6Xk8I8YLup3BPr9TR8Tlxgnu8MuwzDkqaYrMFa0uiPw9ddfb3L70aNH9d577+naa6/VCy+8oJ/85CchKw6oLxgExkdGECgxTyAAAABwIqwYHHl8Hp++3fKtORzYYVPP0T2V3D3Z6rJQT0KCZLebIWBtbV2H4PHik+JVW14rT5WHlZ5jRKuDwEsvvbTZfddff72GDh2qxYsXEwSiw/g95p8xIqUjUGKeQAAAAOBE6AiMLN5ar77d8q1qy2rlSHAo+dRkmh7CkM1mdgVWVZkLhjQbBCYfCwIrPVL3zq0R1gjZ8qsFBQX6/PPPQ3U6oJFIWzVYajxPIAAAAICGWDE4cniqPdr7r72qLatVnDNOPcf0lCM5cho1Yk1b5glkwZDYEbJEpbq6WomBQehAB4i0OQIl5gkEAAAAWuL3mx1LEkODw5270q29/9ord6Vb8a549T6nt5ypTqvLQgsCEU11dfPHBIJAd6W7EypCOAhZEPj73/9eI0aMCNXpgEYibdXggKSuSZKkqpIqiysBAAAAwktlpWQYUlxcXWiB8FNbXqu9m/bKU23OI9f7nN7MJxcBWtMRmJhhfuNVl1TLMBjFFgtaPUfg3Llzm9xeWlqqf//73/rqq6/07rvvhqwwoD6/1x8cWhtJi4VIzBMIAAAANIf5AcNfTWmNvt3yrXxun5ypTvUa00txzlZHCbBQazoCEzMS5Yh3yOfxqba0NhgMInq1+rt3x44dTW5PS0vTpEmTNHPmTPXt2zdkhQH1BboBbXab7HGRM0eg1HieQJvdZnFFAAAAQHhgxeDwVn24Wt9u/VZ+r1+JGYnqdXaviGvMiGWt6Qi02WxydXWporhClQcrCQJjQKuDwPXr13dkHUCLInF+wIDAPIE+t081R2tYUQsAAAA4ho7A8FV9pFrfbvlWfp9fSV2T1PP7PSOuKSPWtaYjUJKSuyerorhCVQer1HVQ144vDJbiuxgRIRgERuhfn5gnEAAAAGiMFYPD15Gvjsjv8yu5e7J6jiYEjET1OwJ9vuaPS+pu/r5afaRafp+/EyqDlfhORkTwe8wfRpHYESiZ8wRK5gSsAAAAAMxFQiorzecMDQ4/gVVku/TvIruD6CASOZ3mhySVlTV/XEJyguJd8TL8Br+zxgC+mxERkrolqc85fdR9aHerS2mX4+cJBAAAAGJddbXZpWS3S0lJVleD43kqPZKk+KR4iyvByUhPNx9LS1s+LtAVWHmwsoMrgtUIAhERHAkOuTJdETtxaWCeQL/Pr5qjLczUCgAAAMSIwPyAycmSjfX0woq31hscIkoQGNlaGwQmd0+WJFUdZDqraEcQCHQS5gkEAAAA6rBicPgKdgO64mWzk9JGslZ3BB6bzqq2vFbeGm8HVwUrEQQCnYR5AgEAAIA6rBgcvjxVx4LAZLoBI10gCCwvl/wtrAPiSHAoMd0cgVd1iOaVaEYQCHQS5gkEAAAA6hAEhq/AQiEMC458SUlSfLwZAga+55o9lnkCYwJBINBJmCcQAAAAqMPQ4PAVGBqckJxgcSUIBeYJRH0EgUAnCgwP5i8sAAAAiGW1tZLHYy4SkpxsdTU4HkODo0tamvl4oiDQlemS3WGXt9ar2rLaji8MliAIBDoRf2EBAAAA6roBk5Ikh8PaWtAYQ4OjS0aG+XiiINBmtwWntGKewOhFEAh0osCcCzVHa+Tz+CyuBgAAALAG8wOGL7/XL5/b/F2FocHRoX5HoHGC6eoDzSuMYoteBIFAJ4p3xSshJUGGYfAXFgAAAMSsQGdSIKBA+Ah0AzoSHLLHERlEg5QUs/PW55MqT5DvBaazqi5hkctoxXc10MmSsxgeDAAAgNgWCAIDixggfATmB6QbMHrYbK2fJ9CZ5lScM05+n1/Vh6s7vjh0OoJAoJMFW60P0GoNAACA2OP3180RSBAYfgIrBjM/YHRp7crBUt2UVoxii04EgUAnc3V1yWa3yVPtCbbdAwAAALGivNwMA+PjzcVCEF6CC4WwYnBUaUsQyDyB0S3O6gKAWGN32OXKdKnqUJWqDlbRcg8AAICYcsJhwR6PtG+f9M035oRm55xD62AnYmhwdGpTR2C3eotcun1yJLC0dzShIxCwAH9hAQAAQKxqNgg8elT68ENp7Vpp506prMxc3WD37k6uMLYxNDg6BVbo9nik2tqWj41LjJMz1SmJ4cHRiCAQsED9ORdYiQkAAACx5OhR8zEjQ5LXK+3ZI73zjvTuu+Zzn09KTZXy8swD9+83xxKjwxl+Q57qY0EgQ4OjisMhJZv9KME5OlsS+J2V5pXow9BgwALONKccCQ753D7VHK2RK9NldUkAAABAh/P7zUa/uKoyZezdLX24zwwDJclul3JzpX79pMxMyTCkoiKzfengQSk728rSY0JgWLDdYVeck7gg2qSmmqPty8qkbt1aPja5e7KOfH1EVQfpCIw2fGcDFrDZbErunqyyfWWqPFBJEAgAAIDo5/Opctf/Z++/gyRNzPvO8/u69Fnet/dmemZ6PHocMAABClToAAUZQEixkBigg8CgmdmLXXFFRZDaIHmM2KUgLr2OC9yKtxBug+JRugAlDMkxPd61nfamqrvLV5ZJ7973vT+eyso21dXlM7Pq+URklMvKfLs6Kyvzl48ZouXsAKHcFOEwYCBlSjt2wLZtELhtLp1hQF8fXL8ugaAGgWuuEgRqNeDGFI/DyMjiKgLvXnKpMyM3Dg0ClaqRSGdEgsDxDB0HH/ByjFJKKaWUUo0qlZLFH7dukR8q4aQh0mRgbOmVAHCh0qRKEDgyIi3Dli4tWEtzG4N1PuCG1NQkbxcTBJqWSbg1TDahSy43Gg0ClaqRysKQ/HQet+RiOfqgRimllFJKbRCeJ7P9+vthcnLu02kvQmrrDmJPb4PHgg++nNZWCIchl4OxMWkdVmtGNwZvbPG4vF1MEAhSvJJNZMmMZ2jZ2bJmx6XWlwaBStVIZRNTIVUgO54l3hev9SEppZRSSim1MpmMVP/dvAlFqS7DMKStd+dOhi52kJ0yaO5a5OVV2oOvXpX2YA0C19TcxmBtDd6QolEZxVkuS7YefsCEqmhnlIkLE7Lk0vcxDGN9DlStKQ0ClaqhSGeEQqpAZjyjQaBSSimllGpc5TKcOCEtvBXhMGzfLqdQCN+HmQ/lS83NS7jsLVskCBwdleux9WnsWtHW4I3NNCUMTKXk9KAgMNgcxHIs3NLskstWnW2/EZi1PgClNrNol7QH6yYmpZRSSinVsMpleP/9agjY3Q1PPw1f+ALs3w+hEADpdHXMXzS6hMtvbpZvcF0JA9Wa8H1fW4M3gUp7cDL54PMahkGkIwLoc9aNRINApWoo3HbbJqZ0sdaHo5RSSiml1NJUQsDJSXAceOEFCQG7u6Wt9zZjY/K2ufmeLz3Yli3ydnBw5ces5lXOl/E9af+0w1p1uVEtZWEISBcbQGY8s0ZHpNabBoFK1ZBpmUTa9Y5VKaWUUko1oLtDwGPHoKVl3rOWSnDliry/bdsyrquvT96Oj8uFqVVXqQZ0Io7OgtvAlrowZG7J5VQer+yt0VGp9aRBoFI1VnmFRUutlVJKKaVUw5gvBFxg8N/Vq7I7JBZbZhAYj0spU2UbsVp1c4tCdD7ghnZ7EOj7Dz6/E3EIRAP4vk82oc9ZNwINApWqscorLNmJLL63iHtipZRSSimlaunuEPAzn1kwBMzn4do1ef/QoWW0BVdUqgKHhpZ5AWohcxWBujF4Q4tEZGmI50F2kbmezgncWDQIVKrGAvEAdtDGcz1yU7laH45SSimllFL3N18IeJ924IpLl2TPR1sb9PSs4LorQeDEBBQKK7ggNZ/KxmBdFLKxGcbS24N1TuDGokGgUjVmGIa2ByullFJKqfq3jBAwnYYbN+T9Q4dWeP3RqFyf72t78BrQ1uDNYymbg0EqAg3DoJguUsrpjM5Gp0GgUnWg0h6cGdNXWJRSSimlVB1aRggIcPmy5Hbd3VIRuGK6PXjNaGvw5rHUikDLsQi1hAAtXtkINAhUqg5UZi7kZ/K4RbfGR6OUUkoppdRtymX44IMlh4CZTDWv279/lY6lt1feTk7K8EG1Ktyii1uS5yFaEbjxVUZ6jo0t/tdobk7ghAaBjU6DQKXqgB2yCTYFAZ27oJRSSiml6ojrSgiYSIBtLzoEBLhyRaoBu7oW/S0PFg5XSwt1aciqqVQD2iEb09KYYKPr6IDWVsn4T59e3PdEu2a72MYz+ItZN6zqlv6GK1Un5rYHa6m1UkoppZSqB64r7cCVEPDYsUUnerkc3Lwp7+/bt8rHpe3Bq66yKESrATcHw4BHH5XtwaOji/tVCrWEMG0Tt+hSSOqynkamQaBSdUI3MSmllFJKqbpxdwi4hEpAqFYDdnSs0mzA2/X2SpIxPQ1ZfRF9NVQqAnVj8OYRj1db9s+cefAibsM0iLTrksuNQINApepEuC2MYRqU82UKKX2FRSmllFJK1ch8IWBr66K/9fLl6qbgVZsNeLtgUBJG0KrAVTK3MVgXhWwqe/ZAUxOUSnD27IPPXyle0TmBjU2DQKXqhGmZ+gqLUkoppZSqrflmAi4iBPQ8GBiAv/s7uHBBPu7pgfb2NTrOvj55q3MCV4W2Bm9OpglHj0qB7dAQDA8vfP65cVaJLJ7rrf0BqjVh1/oAlFJVkc4ImfEMmfEMrbsX96qrUkoppZRSq6ISAk5MLCkEHBqS8C8zO+EmEoGDB6tZ3Zro7ZV+xmQSUinpc1TLpq3Bm1dzM+zdK5W8Z85Isa1znzw4EAtgh2zK+TK5ydxcMLgouUmYuQZuAUxbToYNpjX7tvI5q/q+aUOgSc6jVo0GgUrVkWhnlHHGySVy+J6PYRq1PiSllFJKKbUZLCMEnJiA8+dlVB9AICCtwDt2SKXRmnIc6OyUTQdDQ3DgwBpf4cbluR7lfBnQisDNav9+qQZMp6VF+LHH7n/eaFeUmRszZMYyiwsCs+MwdRnyiWUenQHBFgi3QWj2ZGlgvRIaBCpVR4JNQeygTbkgr7BEOiK1PiSllFJKKbXR3R0CPvPMgiHgzIwEgOPj8rFtw+7dMm/MXs9nmFu2VFeeahC4bJVqQMuxsAJaebUZVVqE33oLbt2SX62urvnPG+uOMXNjhvRImq6H7nMmgMyoBICFKfnYMCG+DcId4Lngl8Er3/V+GXy3+r5bBDcvl1GYAq7KZTkxCLdXg0FHnzcvhQaBStWZSGeE5K0kmfGMBoFKKaWUUmptzRcC3mfNbzYrLcCV/RymKdV/+/bJ/o51190tB5HJSDrZ3FyDg2h8c4tCtBpwU2ttlUD/2jU4dQpeemn+YD/SEcEwDUrZEsV0kUDstuo834fsKExdgsKMfM4woWkHtOwFO7T0AyvlpJowPymnYgpKaTklB+Q8VujOYDAQl8GHal4aBCpVZ6JdUZK3krIw5FCtj0YppZRSSm1YrgsffrioEHBgQFoGvdn9AFu2yBzASC1ft7ZtCQOHh6U9WIPAZalUBOrGYHXwIIyMSOh/7hw88si95zFtk0hHhMxYhvRImra9s/cZuUmYOC1BHcisv+ad0LwH7BW8UuCEwdkK8a3ysVushoK5SShMS9VgelBOAKZTDQVDbRBqkUBSARoEKlV3KlWA+Zk85UIZO6i/pkoppZRSapVVQsDx8QeGgL4vrcCeJ2P5Dh+GpqZ1Pt772bJFgsDBQTikr6IvR2VjsC4KUZYFjz4K774r4X9fnywPuVusOyZB4OhsEOj7MPpRdRFI0y5o2b02s/ysAER75ATSWpyfqoaD+UnwSlKZmB2V8ximzBkMtcuswfA8/6hNRBMGpeqMHbQJNgUpJAtkJ7I0bamXR1lKKaWUUmrDuHBhUSEgyFLeUklCgqefXodFIEvR1SX/hlwOpqYWteVY3Ulbg9XtOjqk5X9gQFqEP/c5+d2/XbQ7CmcgP5XHLblYXroaAm7/MbDW8bZkWhDpkBNIKFmYuS0YTNxZRThjwq4vr9/x1SENApWqQ9GuqASB4xoEKqWUUkqpVZZKwfXr8v4TTywYAgJMTsrbtrY6CwFBEoqeHtlwMDioQeAyaGuwutvhw7KHJ5uF11+HvXth2zb5/S+XAduZK17JjGVoik7IN4ba1zcEnI9hSCtwqAXYLZ8rZSA3O2fQ92bbhN3aHWONaRCoVB2KdkaZvDJJZjxT60NRSimllFIbzdmzUjXT03P/1aC3SSTkbXv7Gh/XcvX1SRA4NAQPPaRLApbA9/1qEKgVgWqWbctrBB99JGHg6dPV8QCuK79i+9rjQIHMaIamntkV4vXacutE5dS0vdZHUhfq7fUcpRQQbgtjWiblfJlCqlDrw1FKKaWUUhvF8LAsBzFNCc0Woe6DwM5OcBwoFKrli2pRyrkyvu9jmAZ2SOuEVFVbG3zhC3I3EQrJeAB3tojO92EgEcP3ITOaws/O3knUaxCo7qC/6UrVIcM0CLeHyYxlyI5nCcZXsGVJKaWUUkopkGfxn34q7+/du6iVv+m05GumCS0ta3t4y2aa0NsLN25Ie3DdJpb1p7IoxIk4GFpJqe5iWbB7N+zcCcmk5O2mKe3C+VKAiVSAzmCC3HSRSEcUgjrWqhFoRaBSdSraGQUgM6btwUoppZRSahVcuSJLNcJhCQIXoVIN2Npah/MBb9fXJ2+Hh6V/US1KpS1YNwarhVReCIhGq3cfhmEwnG7GyydJj5e0GrCB1PNduVKbWqRTXqHNTebwPb/GR6OUUkoppRpaNitBIEiv391rQO+j7tuCKzo6IBiEYlFan9WizG0M1kUhagl275Z2YT8UYnCoTCZR1iCwgWgQqFSdCsaD2EEbz/XIT+drfThKKaWUUqqRnTsnlXIdHdJGu0gNEwQaRvXfNTRU22NpILe3Biu1WJYFBw5AMO4wMGSTTXkUPW0LbhQaBCpVx8LtYQCyE9kaH4lSSimllGpY4+PSMmsYcOTIor8tm4V8XtoCW1vX8PhWy5Yt8lbbgxdNW4PVcm3bBk3hNGbIZnimlcykdrE1Cg0ClapjkXZpD84mNAhUSimllFLL4Hlw9qy8v2sXxOOL/tZKNWBLy6I7iWurtVX6FctlGBur9dE0BG0NVstlGLC7Z5xQk8Wt6U5Sw+laH5JapLoJAn/6p3+61oegVN2JdOicQKWUUkoptQL9/bL6NxCA/fuX9K2VILCtbfUPa00YRrUqcHCwtsfSAMqFMp7rYRgGTliDQLV0W1uHibeZ5Pw4t64VcUturQ9JLULdBIGL9Z/+03/ii1/8Ip2dnTQ1NXHs2DH+23/7b/ec7y//8i85fPgwwWCQw4cP81d/9Vf3nOeP/uiP2LVrF6FQiCeeeILjx48/8PrfeOMNnnjiCUKhELt37+ZP/uRP1u261eYTiAWwgza+55ObytX6cJRSSimlVCMpFODiRXn/0CFwFh/2lMvSYQvQ2bkGx7ZWKtuDR0fB1VBiIZVqQDtkY5hGjY9GNRy3iOUm2b0zjxNv4uaITWYsU+ujUotQ0yBwYmKCf/7P/znbt2/n+9//Pnv37uVrX/saxWLxvt/z5ptv8sUvfpEf/vCHfPzxx7z00kv8o3/0jzhx4sTced59912+/vWv841vfINTp07xjW98g6997Wu8//77c+f5wQ9+wK/+6q/yr/7Vv+LEiRO88MILfPnLX+bGjRv3ve7r16/zEz/xE7zwwgucOHGC/+l/+p/45V/+Zf7yL/9yza9bbV5zVYEJDQKVUkoppdQSnD8viV5Liwz0WoJbt+Rbo9EGWBRyu5YWOWjXhZGRWh9NXavMB9S2YLUsOdnOvXO3RagtxmTSYuy6jrRqBDUNAl9++WXef/99/sN/+A/8xE/8BP/+3/97du3ahbfAYNfvfOc7/A//w//AU089xb59+/jt3/5t9u3bx3/5L//ljvN88Ytf5Nd+7dc4ePAgv/Zrv8YXvvAFvvOd78yd5/d+7/f4mZ/5GX72Z3+WQ4cO8Z3vfIdt27bxx3/8x/e97j/5kz9h+/btfOc73+HQoUP87M/+LN/85jf5X/6X/2XNr1ttXrowRCmllFJKLdnUFNy8Ke8fOSJts0tw/bq83bVryd9ae5WqQN0evCDdGKxWZDYIjLS1s2N/EICLZ4r4vo60qnd2La/8xIkTfOMb3+Czn/0s3/3ud3nppZd46aWXlnQZnueRSqVou21wxbvvvsvLL798x/l+/Md/fC6MKxaLfPzxx/zLf/kv7zjPl770Jd555537Xte7777Ll770pXsu98///M8plUo4jrMm110oFCgUCnd8zjRNgsHgfY+1EZRKpTveqvk5zQ5u2SU9nqZYKGrZfo3o7VU1Or0Nq41Ab8dqo1mz27TvY5w8CeUy/tatEIvBEq5jfBympw1sG3p6/KV8a33o6sI4fx6GhvCz2SW1RG8muZkcbtnFCBjLvg2u+Dacz8P16xijoxCL4ff0QHe3/p81ACM1IvcxTjN7DpucfRNuDsIHb2bYti9Ie7tsHK9XG/UxhbOI352aBoHPPfcc3/3ud3n00UeXfRn/6//6v5LJZPja174297mRkRG6u7vvOF93dzcjs6XhExMTuK674Hnmc7/LLZfLTExM0NvbuybX/Tu/8zv85m/+5h2f+/rXv84/+Sf/5L7H2kheffXVWh9C3UudTuEVPc4lz2E31fTXdtPT26tqdHobVhuB3o7VRrPat+nw+DhN16/jWxYTrou3xMq4S5damJ4O0t2d5Uc/Sq3qsa2X9k8/xc7lmBkfJ99QQw7XT/pcGjftEpmO4FxaWfC21NuwnckQHR0llEjA3RVkpkmxqYl8ayuFlhY8DQXrjukV6MydAgzGIj6+YTE6HWFmxOLauIPT4WCaPs3NRVpaCjQ3FwgE7t/5WUsb7THFV77ylQeep6aJwu/93u/x27/927z88stcvXqVkydP8q1vfYtvfetbi/r+73//+/zGb/wGf/3Xf01XV9cdXzPuql/3ff+ezy3mPHeb73vu/vxqX/ev/dqv8corr9zxuY1SEfjqq6/yxS9+cVGp9WY20jtCajBF27422g800pCWjUNvr6rR6W1YbQR6O1YbzZrcpksljNdeg/Z2/MOHYffuJX17NgueJ89LPvc5n1hsdQ5r3e3di3HpEnR14T/9dK2Ppi5ds6/hFl22v7idYNPynlsu6Tbs+zA2hnH9Onge7Nwpp7Y2/O3bIZPBGBmB1F3hc2srfnc39PZCOLys41SrLHUTY9yBUCt+33MAPPtwinOvTTBTCmJv38JdTY3EYtDV5bNtm4zxrLXN/JiipkFgNBrlt37rt/it3/otvvrVr/LlL3+Zl19+GdM0+fmf//kFv/cHP/gBP/MzP8P/9X/9X/zYj/3YHV/r6em5p7pubGxsrgqvo6MDy7IWPM987ne5tm3TPjtBdy2uOxgMNnzotxDHcTbdL95SNfU0kR3NUpwp6s+qxvT2qhqd3obVRqC3Y7XRrOpt+tIlCVlaWmDfviX35g0NgW3LpuDW1tU5pJrYuROuXZNZib4PgUCtj6iueGUPPLBsi0hzBNNeWQ/ngrdh15XtM1evQiZT+QaZ5bh7t9xWK44cgXRaVlaPjMD0NMzMyOnSJTlvT4+EgmuZUnueHGsqJad0WrZwNzfL9py2ts19mypNyx1FrGeujbttWzO93RP0+Hl2vuiRdwOMjsLYmPwaZrPQ3w83bsAjjyx5f9Ga2YyPKeqmx7ClpYVf+IVf4Ec/+hHHjx9fMAj8/ve/zze/+U2+//3v8w//4T+85+vHjh3j1VdfvWNW349+9COeffZZAAKBAE888QSvvvoq//gf/+O587z66qsLllEeO3bsjqUklct98skn5244a3XdanOrLAzJT+fxXA/TquNhC0oppZRSqjZSqeqWjyNHljWga3RU3m7fvorHVQvRqIQ2MzMSKu3YUesjqiuVRSFWwFpxCHhfhYLcHgcGoCjXh+PIjWvXrvtX98ViEmLv2we5XDUUnJyUYHB6Gi5cgHi8Ggo2Ny/vGD1PEqpK4Fc5ZTLytbslEhIwV46zra0aDEYiyzuGRjS7KIRwx9ynLMci3B4mO5ElO5ahdXeA5mbYv1/++8fGZH/RxAScPCnh4DLvptQK1TQIfPnll/nqV7/K0aNHcV2X1157jTfeeINf//Vfv+/3fP/73+ef/bN/xr/7d/+Oz3zmM3OVdeFwmObZX/5f+ZVf4cUXX+R3f/d3+cpXvsJf//Vf87d/+7e89dZbc5fzyiuv8I1vfIMnn3ySY8eO8Wd/9mfcuHFjwbbkb33rW/zBH/wBr7zyCj/3cz/Hu+++y5//+Z/z/e9/f+48a3XdanMLRAPYIZtyvkx+Kk+kYxP9kVFKKaWUUotz9qxUv/X0SEnfEuXz1a7MDTFWb8sWCQIHBzUIvE05X2byyiQgzzNWXTIpYdngYDVMi0Sk+m/bNqkkW6xwWL5v924JFkdHJRicmKiGdpcvy+VXQsHW1ntXXS818IPZireYBI7xuFQATk1JIFmpEkynpcQNIBSSQLASDsbjDbhyexGKaXALYJgQbrvjS7HuGNmJLJmxDK27qyXFgQBs3Sq/kpcvw8WLkg9PTkoY2NFx95WotVTTIHD79u288sorXL58mUwmw+uvv843v/lNfumXfum+3/Onf/qnlMtlfvEXf5Ff/MVfnPv8P//n/5zvfe97ADz77LP8x//4H/n1X/91/vW//tfs2bOHH/zgBzzzzDNz5//6179OIpHg3/ybf8Pw8DBHjhzhhz/8ITtu+wPxG7/xG3zve9+jv78fgF27dvHDH/6Ql19+mT/8wz+kr6+P3//93+cnf/In575nta5bqbtFOiIkbyXJTmQ1CFRKKaWUUneqhCOmCQ89tKyLmJgt8mlu3iBLW/v64Nw5qeLK5yWo2cTcksvk5Ummrk/hezLrPtazSu21s/P/uHZN1k5XtLVJiNfTs/JQLBiUasLt22UL9tiY3O7HxiTku3ZNTsGgXF8otLzAr3Kar2Kx0s9aKkmKlUjI25kZuY0NDckJ5JeotbUaDLa0bIzyt9zs/2+oTcLA20S7o/ApZBNZvLJ3T7WpYUiFYEsLnDgh/zXvviv57ZEjm/5XdN3UvCKw0kL70z/903NB3kJef/31RV32T/3UT/FTP/VTC57n29/+Nt/+9rfv+/X+/n4+97nP3fG5z372s3zyySdrft1K3S3SPhsEJrK1PhSllFJKKVVPXBc+/VTe37t32S2KlSBwQ1QDggQ5bW0S1AwNLXlxykbhuR7T16eZvDKJW3IBCLeF6TzUSbhthcs3XJfw+DjGG29IEAaS9vT2ys97rQZNOo6Ul23ZIrf/8XEJBUdHpXJwYODe77Gse8O+eFzSp6WGlI4D3d1yAjmG6elqODg1VQ0rx8bkPKYpCVglGGxtbczEfZ624IpANEAgGqCYKZIZzxDvjc97EV1d8PnPS4f3wID81+Xz8Pzza3ngqqJuZgTWozfeeIM333yz1oehFMBcFaDOCVRKKaWUUne4ckVmqYXDEgQuU6WQa0O16fX1bdog0Pd9kjeTTFycoJwvAxCMB+k41EGse4WVgIUC9PdjXLlC0/XrEmyFQtX5f+s5L8+ypAKwp0eq/hIJmSnoutWwLxaT34+1atW1LPkZtLfLbEPflxbpSsXg5KT8zCrvX7ki37dtGzz8sHx/I/B9yCXk/fD8rxjEemJMXp0kPZK+bxAIkoE+/LB07b/1lmSn4+Mb6IWIOlY3QeBiqgHX2/XKoF2l6oATcXDCDqVcidxkjmhnHexcV0oppZRStZXNVkOFhx5adqCQyUhFjmlKwdKG0dcn1ZKVtaWbZKFDeiTN+PlximlZ0uGEHToOdhDfEsdYaRh2+XJ1O3W5jBcM4h8+DHv2LG3+31owTUmSap0mGYb02Dc3VwPoTObOduJMRrZnpFLw1FON0RdbmAGvBKYDwfkXtES7o0xenSQzlsH3/Qfe3pqaJAy8dk1uVrX+r9sM6iYIVEo9WLg9TOlWiVxCg0CllFJKKYWEXJ4nZXy9vcu+mEo1YGtr4xQnLUowKFVaExNSFbiCislGkE1kmTg/QW4qB8hW4PZ97bTsbMEwV6EabmBA+jkBWlvxt21j3DAk7Kp1CFjvolE5VeYMTkzARx9JS/Hx4xIGtrTU8ggfbK4tuP2+1ZXh1jCmZeIWXYrpIsF48IEXu2cP9PdXc9L29lU8ZnUP7S1UqoFU2oOzEzonUCmllFJq0xsflxZIw5BJ+yuw4eYD3m7LFnk7OFjb41hDhVSBW+/f4uY7N8lN5TAtk/Z97ez6/C5ad7euTgg4Pg5nzsj7Bw7IQLe+vo25GXc9dHTAiy9K63I+D2+/Dbdu1fqoFrbAfMAKwzQINkn4V0wVF3WxoVA1H710aUVHqBZBg0ClGkik/bY5geX7bL1SSimllFIbn+fB2bPy/q5dEiYsk+9Xg8ANNR+worKxNpmEdLrWR7OqyvkyI6dGGHhjgMxYBsMwaNnZwq4v7KLjYAeWs0rlnamUVK/5PmzdKqtf1cpFIhKoVuYbnjgB58/Lz7ne+B7kK/MBF76jqASBhWRh0Re/b5/8mk5M3Ll4Wq0+rd1VqoE4EQcn4lDKlshNaXuwUkoppdSm1d8voVYgsOJQZmZGFpzadv13Ji5LICCljmNj0h5cByFWKVti+MQwdtAm3BYm3B4m2BRc9Pw+r+wxdW2KySuTeK4UCMR743Qc6iAQDazuwRYK8P77UC5Lz+ajj67u5W92tg1PPgkXL8r8xStXJHh9/PH6arfOTUoYaAUhsPALD8sJAsNhqQq8cQPee09mlW7fLm8jES08XU11dKtSSi1GpD3CTHaG7ERWg0CllFJKqc2oUJDQAODQIVm/uQK3VwNu2CfbW7ZIEDg4WBdB4NT1KXKTMscvNZwCwHKsuVAw3BYm1By6p6V3bhPwhQnKBdkEHG4N03m4k3BbePUP1HXhww9lK3U0KoGVqY2Fq84w4OBBqew9eRJGR2Vu4NNPy8+9HiyiLbhiOUEgyN1ZsSj//MqCZZC5pfG4LBapvG1qkoxfLZ0GgUo1mEhHhJmbM+QSuVofilJKKaWUqoXz56U6q6WlOlhrBSpPtjf0gP6eHgmw0mlpEW5qqunhpIelRbl5WzPlQpncZA635JIeTZMela+ZljkXDEbaI7gll4nzExRSEq44EYfOQ53E+5bfFr4g35dW1akpCZufeUaTl7W2ZYsEfx9+KLfV48clfK2Hnv0lBIGBuNxOSrkSbslddIt6ICA7U/J5Wag8PCzFka4rO1Wmp+88fzB4ZzgYj8tpQy08WgMaBCrVYMLt8kpfZU6gaesrckoppZRSm8bUlDxDBlkQsgolfFNT8ra1dcUXVb9sG7q6ZLnKjRsrXq6yEvmZPKVcCdMy6Xq4C9My8X2fQrJALpEjm8iSS0gwmBnPkBnP3PH9lmPRvn8VNwHfz4ULksSYpqQz9VKZttG1tMALL8hMxqkp6ZN96CGZBVorXhkK0/J++MEbhSzHwgk7lHIlCsnC3Kz7xQqFZGbgvn2SR2cykt8nkxIMJpOQzUpx9Pj4vTMFo1HJTg8frq/u6nqhPxKlGowTvm1O4GSOaJf+QVZKKaWU2hR8v7ogZNu2VUnusllpxTNNaG5e8cXVt23bJAi8fl0WMxw5UpM210o1YLQrimnJ9RuGQag5RKg5ROvuVnzfp5gqSig4mSOXyOGVPVp2ttC2r231loDcz40bMqsOZCbghi4XrUOhEDz7LJw6JZuEz56V9Ovhh2vTmp1LAD7YEXAW14IebAouOwi8nWFALCanvr7q58tlCQUrwWDlbbEowWEmI2MPnnpqRbuUNiQNApVqQJGOCDM3ZucEahColFJKKbU53LwpvXG2LcO0VkGlGrCpaROMfuvpkTlsFy7AwICkBk8+KaHLOqrMBIz1xu57HsMwCDYFCTYFad0lga/v+4teJrIiExNw+rS8v3+/bAlW68804bHH5Jfz/HkJZ9Npuc0Gg+t7LEtoC64INgVJj6aXPCdwsWxbXgu5+/WQQkHu186elTDw+HE4evTOEHGz2+h39UptSJVXVLKJbI2PRCmllFJKrYtSScIAgAMHVi0I2BRtwbfbt09m3TmO/OPffLM6JHEdFNNFiukihmkQ675/EDifdQkB02lpSfV9mVd34MDaX6da2J49sjTEtuW2evy4hNjrqRIERh7cFlxRWRhSTBXX4ojuf71ByfxffFHag10XPvlk/X9k9UyDQKUaUKRDgsDCTAG35Nb4aJRSSiml1Jq7dEl63mIx2Llz1S520wWBILMCX3hBKq0KBXjnHejvX5errlQDRjoi9Tfru1iE99+X0LmtTcqoVH2o3GajUdng/NZbMr9xPZQLUJxN0ZZYEQiyOdj3/bU4sgUFAvCZz0B3t+TaZ86s+yHUrTq751FKLYYdsglEA/i+T25StwcrpZRSSm1omYzMtYNVnWvnedUqmU0VBIIEKs8/L/2ClZTg5EkpH1pDlfmA8d46G1rmebKpNpuFSEQGq234XvEGE4tJGNjZKbfTjz6SFwjWOmSrVAMGmsBa/NZoJ+pgmAae61HKltbo4BZmGDJW0bKkmPLWrZocRt3R32ylGlRle3AuoUGgUkoppdSGdu6cPNnv7pYQYJXMzEj+EwxK9rPpWBY88YSsFjUMmcH49ttScbUGStkS+Zk8hmEQ61laW/CaO3lSkhLHkdbpwOIDH7WOKv8/u3fLxxcvwscfr22AvYz5gDA75zJerQqslXBYJgKA3JWWapNJ1hUNApVqUJX24OyEzglUSimllNqwEgnZdGsYElitokpbcEvLql5s49mzR3oIAwFJR998UxZmrLL0iFQDhtvCWIE13vq7FBcvwuCg3MaefFIqz1T9Mgx46CHZ5mya0iL81ltrFmAvNwiEO9uDa2nPHrlZFwpyc9/sNAhUqkFVFobkZ/I6J1AppZRSaiPyfSlhAdi+fdUDmk05H/B+Ojpku0Bzs8zKe+89uHZtVa9iMduC192tW9JeChIsdSw97FE1sn07HDsmJb3J5NosvilloZwFDAi3L/nb6yUINE2ZqgAyDjS7yWtpNAhUqkHZIZtATEr2tT1YKaWUUmoDGhqC6WnZFroG21s1CLxLOAzPPQdbt0oI++mnsm50Fdouy4Xy3GzvumkLTiTg1Cl5f+9e2Lattsejlq6trbr4pliUxTenTkE+vzqXX6kGDLaAaS/522u1OXg+nZ1yM3/mmU06CuE2GgQq1cAqVYHZxCZ/SUMppZRSaqNxXTh/Xt7fu1eqflZRPl/tJNz0rcG3syx47DEpHzIMaZl96y1Z2LIClbbgUEsIJ+ysxpGuTCYjy0E8TxamHDxY6yNSyxUOy+KbSoB94wb8/d/DhQsrH4i3grZguC0IzBTxyt7KjmUVHDq0qmNWG5YGgUo1sMrCkPzUKr3io5RSSiml6sP165LUhULVxQCroFCA8fFqN2hTkxQcqrvs2gXPPlttuzx+HMbGln1xdbUtuFiE99+XkKi1FY4eldBTNa5KgP3cc1Il6Lpw+bIEgteuSeC7HJUgMLK89MwKWNghuYMppGrbHqyq9C5fqQYWagkBMifQ93wMU/+AK6WUUko1vGJRnsSDlLBY8y+W8DzZE+A40NV179fzeeksnpmpnu7uGGxrW91D31Da2mRu4EcfSR/1++9L5VxlBekiuSV3bsFfzecDep5UAmYyUkn21FP3vX2pBtTWJmHgyIhUFKfT0uJ+/brcdvv6Fh/6FlPgFsCwILT8+QHBeJByvkwhWSDcGl725ajVo0GgUg0sEA1gBSzcokshWZgLBpVSSimlVAO7eBHKZVlcsWXLPV/2POn+u3y5Gux9/vMQjcr7lV0XMzPzX3wsJhfd3Cz7BtQCQiGpDDx7FgYGpN1yelqqrxZZSpkZzeD7PsF4kEA0sLbH+wCTH31MeXQU17bJHT2K64OXz+MBng8e/uxb8PFxDIN9wSAhU5sJG0pPD3R3w82bcn+Szcq8y6tXZfv4YpbCZMflbagNjOX//webgmTGMzVfGKKqNAhUqsGFW8OkR9PkpnIaBCqllFJKNbp0WgInkCfs81TvvP8+TEzc+blr1+Dhh+X9q1clBDQMiMeroV9zs7YCL4tpwiOPyDDFM2ek2ur4cammW8Qm53rZFjz56TmuXLuGbxhMP3qUohOQXvEHSJRdno9FsbV9uLEYhiT9W7bIHcSVK3LH8O67Mijv8GG5Q7ifFc4HrAg218fmYFWlfwKUanChlhDp0bTMCdxV66NRSimllFIrcv68DPzv7p63aieblRDQMGSfRSQiweDNm9L55/vSBQiSU3V3r/Pxb2Tbt0uy+tFHEtgePy6VgT099/0Wz/XIjMmikZrOBxwcZOb8OTmmI0fo7O3BxMAATANMjNm31fcN4EqhSMrz+Dib4+lIGEPDwMZjWdLOvmOHDAcdGJBBoW+8IQtGDh6UNvHb+d5t8wHnmTuwBMF4/WwOVkKDQKUaXKh1dk7gtC4MUUoppZRqaImEVJsZhlTrzKNSCdjaCjt3yvvNzVLo098vOwJcVz6nIeAaaG2tzg2cnJR5e7t3V0PCu2TGMviejxNx5jaorrvJSTh5kmnXI7NrFw/t30+Xs7gooM2yeSeTYaxc5mw+z8N3B0aqcQQC8urBrl3S4j40BLduydtduyQsdGY3WuenwHfBCkJgZQF2IBbAMA3ckkspV6qPrdmbnAaBSjW4SjtwMVPELbpYAR32q5RSSinVcHxfhvqDVO7cp+W0EgS2t1c/t3s3nDghlYCuK59b4j4LtRTBIBw7BufOyQ/92jU5RaOSvvb0yNIGw6jdtuB8Xqq+xsdhdJRsqUSqq5PcgQN02It/vtBiWzweCfNhNkd/sUTUNNkdrFGgqVZHNApPPAF79kgF8sSEzBO4cQP27pVQMDu7ITvcueKN0oZpEIgFKCQLFJIFDQLrgAaBqv74vq6vXwLLsQjEAhTTRXJTOWLdNd5EppRSSimllm5wUMr6bBsOHLjv2RIJeXt713BfnzyfrywOiccX7FZVq8E0pbqqo0NaLScmZBNvJRQMBPA7OsldyEG0Ze3nA3qeVP6Nj8PYGCSTd3x5It7EzKNH6XEczCU+1+pxHA6HPM7lC3yaLxAxTXocDXMaXkuLBNpjY3IHkkzK2/5+aJqGtgBEOlflqoJNwbkgUJ+v1p4Ggaq++D68/ba8xLlvn04yXqRwa5hiukh+Oq93rEoppZRSDWY64TLz/ztPdxPEn94nLXzzSKcl7DNN6VCtME0p4jl/Xj7et09fV183PT1yKpclhBsZgdFRKBYpnLtK4NIE4aBDqCcFvb1SMRhapQV/mUw1+JuYqJaDVjQ3Q1cXdHUx4ATA8+heZEvw3fYEg2Q8j4FiiU+yOZ6LmTRb2om0IXR1yfKQW7ekZTidhGunIBaBzz0Gq1DMWmmL14Uh9UFTFlVfRkdhakpOt27BoUMywFQtKNQSYubmjCwMUUoppZRSDSOTsTnz19eJDeaZmAjT/MguDngS7t3t9vmAd2cwO3ZIIU8oJBWCap3ZtgR9vb1S3DA5SeqNs/jBLKFmE6PSpgtSidXTI6HgQltb71Yuy42gEv5ls3d+PRiUQKcS7MwGygXPYzolLcpdKyi0OBIKkfU8xssuH2SyvBCLolHgBmEYsG2b3HmceRcmLcgDH5+ETH7FswY0CKwvGgSq+tLTA08/DWfPyh+2EyekxP2RR2p9ZHXt9oUhvu/rNi+llFJKqQaQTsPVc1F2GldxHJjYeojx6xajE/D44/dmRPO1BVc4DnzhC/K+PhSsMcPAb2tjJroF99Ee2h9uhXJSqgWnpmB6Wk4XLsja59vnCt6eAPu+tGtWgr+pKWkBrqiUhs5W/RGPz/ufP1ouA9BiWYTmS5gXyTQMnohEeDudIeV5vJ/J8nRw/upV1aAsC/piEHoUJkyYAi5elI69trZlX2xlc3ApU8JzPUxr+bdDtXIaBKr6090tr2BduSJ3OjdvyvyNFfzR2uiC8SCmZcompkyJQEz/ICullFJK1bN8Ht5/36B59BbRHTEeer6diQN9nDoNqRS8+aaMCty7V7Id369WBM4XBIIGgPUkN5mTRX6ORXhHJxhd8p9ZKEgX1MiIBHzZrCwcuX5d0tyuLglcpqbk64W7Kqii0WrVX3v7okYpjZYkCOxehbFLjmHwdDTCW+kMSc/jRC6Pv+JLVXUlOw6ODY9/Bi7clPmlJ07Ituxlzoa0QzZWwMItuhTTRULNq9Qer5ZFg0BVn0wT9u+X/oZCQV4xW8ErEBudYRoEm4PkJnPkpnIaBCqllFJK1blLl6A4maYrP8SBA/uwHz5MT7tBaxucPi050YUL8vaxx6QQrFiUgp2WllofvXqQyrbgWE/szm6dYBC2b5eT685t9WVkRP6DBwflVGFZkvxW2n2j0SUdh+f7jM9WBC53PuDdIqbJU5Ew72SyjJbLXHMCXC0UcW6vVrwPA2lPjul8wfpUTIGbB8OCcDs83CKhdDYLZ85IqfIyBZuCZCeyFJIFDQJrTINAVd/a2mB4WPogNAhcULg1TG4yR346T/O25lofjlJKKaWUug/Xlayn6dY54p1Z7K09Ut2F5ERPPSXjss+eldfD33ij+lD47u5RVZ9SwymAhbcFW1Z12cgjj0jgMjoq26Mriz5aW1f0H54ou7hAyDBWdblHq23zeCTMe8kUk7bF+UIB++5lJfdx1SjyUjyGrSWs9Sc7Jm/D7WCY4JgS/r39ttxpdXUte4b/7UGgqi0NAlV9qwSBk5O1PpK6F2qZnROoC0OUUkopperayAiYkxM05cYohMv4hw7dc56tW6UQ7ORJKRp7UFuwqh/56TzlfBnTNol2LrKCzzDkuc8qFz+MlEvA6lUD3q7XcXgyHKa/7LLFcXAW0Xo8US6T930u5QscDmtVWN3Jzi60CXdWP9faKt16Fy9KVWBr65IrU0EXhtQTDQJVfZt9ZZTJSRmMoq8a3VdlYUghWdABrEoppZRSdezGgE/8xqe0d/hcdbvu+6Q6FILPfAYGBuDTT6WSsKtrnQ9WLVmlGjDaFcUwa/v8ZTXnA86nx7HZXSryWDiEs4j5caOlEh9kc1wrFtkWcIhri3D98FzIz24kinTe+bV9++QViclJmRf47LNLrlTVILB+aFKg6ltTkwzALZdlY5a6LyfsYIdsfN+nMKN3rkoppZRS9SiXg/SFW9jZJB3dNum+vgd+z44d8PnPwwsv3LtJWNWfynzAeG+8pseRdF1yvo8JdKxRELhU3Y5Dj23jA2dy2slUV/KT4HtghSBw123XMKRF2HGkhf3SpSVffCAWwDAM3KJLOV9epYNWy6FBoKpvlRJ50PbgRai0B+emcjU+EqWUUkopNZ+b/S6xWxdoaoLAQ3vxF7mFMxTSJSGNoJAsUMwUMUyDaNfS2ydXU6UasNO2seqos+qhcAgTSLgug8VSrQ9HVeRm24LvrgasCIdlliXA5csyx38JTMvEicr9XSGlhSu1pEGgqn+VIHCJdzSbUbg1DOicQKWUUkqpeuT7MPHBNaxSnvatYdi9u9aHpFbZ7W3Bpl3bp9ujq7wteLVETJP9QWkTPZfPU/b9Gh+RAqrzASMLzB/o64Nt2+T9Tz6B0tKCXG0Prg8aBKr6d/ucQLWgypzA/LQGgUoppZRS9SYxVMC6dhnLgrbnDun63w2oXtqCi57H1OwW37WaD7gSe4IBoqZJ3ve5mNdQqObKeSjOjuIKP2Aj0ZEjMtc0n4dTp5Z0NRoE1gf9y6PqX0uLPEgqFCCTqfXR1LVQcwjDMCjlSjp3QSmllFKqjvg+DLx6EcNzadnZgrV9S60PSa2yYqZIIVXAMAyi3bVtCx6brQZsMk1CdRg4m4bBwyEpYrheLJKcDS1VjVSqAYMtYAUWPq9ty7xAw4DhYbhxY9FXo0Fgfai/ewSl7maa1YEo2h68INM2CcTljlurApVSSiml6sfQxRTlazewLNj64w/V+nDUGkgNSVtwpCOC5dR2G+7IbBDYU2dtwbfrdGx6HV0cUhcq8wHD95kPeLeWFjh4UN4/exbS6UV9WyUILKaL+J62hNeKBoGqMWh78KLpwhCllFJKqfriunDrR+cwfJ+uR3sJ9rbV+pDUGkiPzLYF99W2LdjzfcZnF4V024tbRlMrD4VCWMCk63KrWKz14WxOvv/gRSHz2bMHOjrkDu6TT8DzHvgtTtjBtE18z6eY1v/vWtEgUDWGysKQqanaHkcD0IUhSimllFJry/dlak2pJM+BH7TroP/DcYzxMQIhgy0/dmh9DlKtq1KuRH46XxdtwYmySxkIGgbNVn0/5Q+bJvtDlcUhBUq6OGT9FZPgFsG0IdS6+O8zDHjsMXAcmJmBCxcW9W1z7cG6Obhm6rdOWKnbNTfL23RaHm1ZtS21r2dzC0Nm8vi+j2EYNT4ipZRSSqnG4XmQzUIsNv/XBwfh3DmZk387w5CTad51MnxCH5zDArY8twszXtuQSK2NypKQcFsYO1jbp9mV+YDdtt0QzwV2BwLcLJZIex4X8wWOhEO1PqTNpTIfMNwBxhKD41AIjh6FDz+Eq1ehs1NOCwg2BclN5mROoI5KrYn6fnlAqYpgUO5kAJLJ2h5LnQvEApi2iVf2KKa03FoppZRSailOn4bXXpNlmLfvL5iZgbfflg64u0NAkKpAz4NyGYpFOU82C+X+W1iZJLFWh85n963fP0Stq9SwzAeM9d4nQV5HI+USAN11PB/wdqZh8PBs+NdfLDKji0PW11LnA96tpwd27JD3T56UO8AF6MKQ2muMewalQKoC83l5FNa6hJLlTcYwDEItIbITWfLT+bk7WqWUUkoptTDXhaEhef/GDXnYuX+/vD86Kp+3LNi3D3bvlgpAz5MQsNIi7Hm3nUou1hsX4CBEntwHgQds41QNqZwvk5uU+dzx3trOB0y7LlnPxwQ67MZ5ut9h2/Q5NkOlMmdyeZ6LRhqimrHheWXIz87hX8p8wLs99JAs9kyn5VWUp56671k1CKw9rQhUjaOpSd7OzNT2OBpAZU6gLgxRSimllFq88XEJ9AIBOc3MSMfb6KiEflu2wEsvSRBoWdL6a9syIisUgnAYolGIx+U17NbJqzQF8jT1RLD37ar1P0+tkcqSkHBrGDtU2/Ctsi24w7axGyxIqywOmXJdTufyFBexfEKtUC4Bvgd2BJwVjC2wLHjiCblTHBmB/v77njUYlyCwnC/jFrX6sxY0CFSNo6VF3moQ+ECVzcG6MEQppZRSavFGRuTtli3w4ovShGIYsG2bBICPPy5h36Lk83Dlirx/6JA8QVYbUj21BY+WqvMBG03INDk8Ow7qRqnE36czXC0U8HSByNpZzrbg+2lqkvs6gE8/hVRq3rOZtkkgKtXRWhVYG41376A2r0pFYColvRb6YOq+KgtDCqkCXtnDtPVnpZRSSim1EM+rBoG9vRL4Pf/8CvbUXbwo39zaCn19q3qsqn64RZdcQrpwYj21DQKLnsfU7Hy9RpkPeLedwQAxy+TTXJ6k53EuX6C/WORwKESv49T68Dae7ArnA95t1y4prR4bk4GqL7ww7/P2QDxAMVOkkCwQ6YisznWrRdN0QDWOSET6Ljzvvq8uKGEHbZyw/KHMT2tVoFJKKaXUgyQSUCpJS3BbW/XzSw4BPQ8uXYKbN+Xjw4dX7RhV/UmPpvF9n2BTcK7KqVbGyy4+0GSahBu4aKLDtnkxFuXRcIiQYZD1fD7K5ng7nWG6rK2kq6aUg1IaMGRj8GowDNkiHAjIks/z5+c9m84JrK3GvXdQm1Nzs7zV9uAHqlQF6pxApZRSSqkHq1QD9vTIc9llmZqCN9+UakDfl02at6eKasNJD8t8wFovCQEYbbBtwQsxDIPtgQAvxWPsDwawgEnX5XgmwyfZLDmdH7hylbbgUCtYq1htGQzCY4/J+9euSXXg3WfRILCmNAhUjUWDwEWrLAzRikCllFJKqYX5PgwPy/u9vcu4gHIZzp6Ft96SzpVgUAbnP/LIqh6nqi9e2SMzngFqPx8w43oNPR/wfmzD4EAoxOfjMbbNtgYPlsr8fSrNhXyess4PXL7cKrcF366rS9qEAU6ehMKdgd9cEJgq4Ov/4brbOPcQanPQIHDRdGGIUkoppdTiTE3J81Tbho6ldsiNjcHp05Cb7cLYtg0eekhG2qgNLT2axvd8ArHA3CbUWsh7Hu9lM5SBZsukZVlDLetbyDQ5Ggmzyw1wLp9nouxyuVDkRrHEnmCAVssiZpoEGrglel35fnU+4GosCpnP4cMycyGZlDDw6afnyq2diINpmXiuRylTIhCrbVv9ZqNBoGoslSAwmZQ7r2X3bWx8weYghmFQLpQp5UpzMwOVUkoppZTwPLh1q7rct7t7CfvoCgXZjDk4KB9HIlIB2LlGT6pV3amHtuCi5/FeJkvW84maJs9EIhgb+DlSs2VxLBplpFTiXL5AZnahSEXAMIibJjHLJG5KOBi3TEIaEFb5HkxeAK8EpgPBlrW5HtOUVetvvikvmFy/Drt3A9L6HWwKkpvKUUgWNAhcZxoEqsYSjcrEZteFTAZitS3Br2emZRJsCpKfyZOfymsQqJRSSik1q1SC/n55XlrpWHMc2LNnkRdw65a0ApdK8sL07t1w4MAy1wurRuS5Hpmx2rYFl32f97M5Up5HyDD4TDRCcJMEXj2OQ5dtc6NYYrRcJuW65Hyfou+TcF0SrguU5s7fZJocCYdo30Bt08tSSMLYCSgm5ePm3WtbXBOPS4X0mTOyOKSjA5qaANkcXAkC4321n7G5mWzy3wLVcAxDqgInJ6U9WIPABYVaQ+Rn8uSmcnrnqpRSSqlNL5uV2fU3bsjrygChkOR4O3ZIa/ADL+D0aRifbalrapINmZWuFbVpZMezeK6HE3EINYfW/fo93+fDbJZp1yUwGwJGNkkIWGEaBjuDAXYGpZrM9X3SnkfKdWffeqQ8j6znkfQ83slk6XNsDodCDb1VeVl8H6avwNQlqQi0AtDxCMSWMxR1iXbulIrA0VH45BN44QWwLF0YUkMaBKrG09QkQWAiAVu21Ppo6lq4Ncx0/7QuDFFKKaXUpjYzI+2/w8PyfBjkIeWePdDXt4h2YN+X8sELFyRBNE2pANy9ewm9xGojSQ2lAIj1rH9hgu/7fJzNMVF2sYFnIhHiWo2KZRg0WxbNd/0sip7HxUKBgWKJoVKZ0VKavcEge4IBrA3cRj2nlIHRE1CYko+jPRIC2us41/LoUXjjDVmmdO4cPPywBoE1pEGgajzt7dLLMTAgL9seOqSzAu8j1Dq7MGQ6j+/5GKb+nJRSSim1uQwNwccfVz/u7JQAcNGj/JJJOHUKpqfl4/Z2ePRRGVmjNiXf80mP1mY+oO/7nMzlGSmXMYGnohFabA0BFxIwTR4Oh9kRCHA2lyfhulwsFLhRLPJQOETvRl3s4/uQ7IfEefBdMG1oPwJN29b/WAIBCQPfew9u3oS9e+eCwFKuhFtysRy9Ha8XDQJV4+nthX374PJluHpVXlV4/HHdzDaPQDSA5Vi4JZdCqlCTtgWllFJKqVrJZiXDA+jpkSK+2fFUD+Z5cOmSlBL6vjzWPHwYtm9fs+NVjSE7kcUre9ghe+6F9/Xyab7ArVIJA3giEqZjs8+8W4Imy+LZWJShUolPc3lyvs9H2RwddpEjodDGqqos5WD8JOQm5ONwB3QeBSdcu2Pq7IQjR2ROYDiMBThhh1KuRDFVJNxWw2PbZPReQzUew4CDB+VR3MmTMm/g+HFZR64zA+8RagmRGc+Qn8prEKiUUkqpTcPzpBKwXIa2NnjyySU0kSQSkiBmZBkEvb3yBDakj6UUpIarbcHruaH3Ur7A9WIRgKPhED1aCLEsfY5Dt21zpVDgSqHIRNnljXSGnYEAB0JBnEbvNkvehMRZ8MpgWNB+GJp21EcX3a5dd3wYbApSypUoJAsaBK4jDQJV4+rrk5aMDz+UB2nHj0tlYHd3rY+sroRaJQjMTeVo2dlS68NRSim1SgoFGVUWDtfHY3ul6s3Fi9LN6zjyEHFRvyelksyvunFDPg6F4OGHpZxQKaQ1Nz2y/m3B1woFLs6uuD4SCrE1EFi3625I5Tx4JTAdWYxh3DnL0zIMDoRCbAsE+HS21fp6schgqcTBUJDtjrOuIe+qKBdg4jRkRuTjYCt0PwZO/Y4xCDYFSY+mdU7gOtMgUDW25mbZOvTRR7JA5IMPpFpw375aH1ndCLfKKyv5KV0YopRSG0GpJN2K169Lt6JlSUF8PF59G49DJKIBodq8JieloxdkLFV4MYUmIyNw5gzkZx8z7dghs6i16krdJpfI4RZdrIBFuH19KphuFot8mpeg5EAwyK6ghoDzKmUgPQyZYShM3/k1w5JAsBIMzr4fMQM8ZQVI+BZnzWaSvsnpXJ6RUpnHI+HGqQ7MT8HIh+AWJPRsPQAte+r+gUAgLrdlDQLXlwaBqvEFg3DsGHz6qSwRuXBBhjofPSrPjja5UIu0sBQzRR3CqpRSDWhyEsbH5X3Pk0Kl2c4wTFOqAmdm5HQ705TC+fZ2KZZvb5d8Y2ZGvn/rVtm5pdRGdP68vN22bRHFfJ4nAWClCjAalWUg7e1reoyqMa13W/BIqcSpnITTuwMB9ofWcdNrIyimJfhLD0ExeefXrAC4JcCXZRnlHJCb92LagRecGP0dT3Kh5DNWLnM8neHpSJhYvT+nTN6AiTPgexCIQ9fjEFzsMNTamtscnCrg+37jVWE2KH34pzYG05S2jaYmeSA3NATptASEm7xs3gpYBKIBipki+ak80a76LQ1XSil1p7u3nVbEYtV529ms7M1KpeRPX+Wt61Y/399/72WUy7B375r/E5RadyMjEqBbljSKLKhYlDEzk5NSObN3L+zfL48tlbrLarYFT5bL3CyWcPHvf33ASKmMD2xzHA5v1BDQ9yE7Jq28i1XKSABYTN32SQPC7RDrg0gP2EG5bK8sl+0WwStKOOgVZz+e/XxuArOUZnfiEzq6n+aDfJmM53E8neHxSJjueqwM9j1InIOZ6/JxtBe6jsp24AYRiAUwTAOv7FHOlXEidfhz3oAa5xai1GLs2CH9UB99JFWB/f3yYG6TC7WGJAic1iBQKaUaxfg4nDgh73d2SpESyGte27ZVc4poVE63Vz35PuRy8qdwbAxGR6Ua0DSly7FQkLBQqY3G96U5BGD37gfs9kilZKxMNivlsU88AV1d63KcqjHlp/KU82VM2yTSEVny9/u+z2i5zNVCkUnXXfT39dg2j4ZD9VMt5Xsyj241NtD6Hox+XJ1rt1SGKRtxo70Q7ZEqwDu+boDlyMlZ4P+slIHBd6CYpGn0A17seYaPCi4J1+WDbI6DQY999RTEukX5uVW2ArcegNZ9dd8KfDfDMAjGg+Rn8hSSBQ0C14kGgaou+L6P63vY5iqUXbe1wYEDcPq0PPvRIJBQS4jkrSS5qflL4ZVSSq2ObFZm91kWtLRAa6tMsFiqyUkpUvI82Y216EUHswxDZgRGItWAMJ+XYxkclIAxp38S1AZ086bke44De/YscMaxsepK4UgEnnlGSm2VWkClGjDWHcMwF3+n7Pk+t0olrhaKpD0PABPY6jg0PaDtNGAY9Dp2/YSAnguDb0kbbtMOiK+gtNz3YPQTCQENE0Lti/9jZ9oQ6ZaTtQrhkROFvmMwJGFgYOR9PtP7GT4tmfQXS1woFEh6LkfDYaxa/18UkjIPsJyVn0PXYxKCNqhgUzUIjPXo/fB60CBQ1VzZc0mVipS8Ml3BptX5I1d5NXd6Wqaq12Mp9zrShSFKKbX2btyQcbXl8p2fD4clEGxtlXCwuXnhEbaTk/D++9La29UFjz22Oi/wVyqjIrMFEdnsyi9TqXrhutISXKkG3L9/gYd/167JZmDflzmATz656UfJqMWZmw/Yu7iwouz7DBSLXCsUyfvSAuwYBjsDDrsCAYKN2II+fro6iy85gJEcJFCeXvrlzIWAwxIC9jwFkRpX5AZi0PfsXBhoDr/Hw33P0mRZnMnlGSqVSbsZno5GCNfq/y49DGMnZOahE5WfW2D9tlevhcqcwNykvkK5XjQIVDVnGSZlr8hAdgLLMOkIrsIdWTgsLcKplPRW9fWt/DIbWLApiGEauCWXYqZIIKoPdpVSarXk81KEPjoqH7e1SWHR1JT8Gcrl5DQ0JF83DGnvrVQMtrZKa69hQCJRDQEr+cRqP9eobE/N5SQHqXVhg1IrdfGiVOKWZseLRaOwc+c8Z7x7Kcj27TJjuhHDGLXu8jN5StkSpmU+cNRO3vO4XiwyUCxRmg0AQ4bB7mCAHYEAdqPe8SYHIH0LMKD9MCT7ITdDa+ESjJ+E7qOLq87zfQmz6ikErLgrDGT4XXb0HiMejfBhNkfS83gzneHJSJj29dy45fswdUlOAOFO6H5idaohayzSGcEwDDLjGVJDKeJ9jR1sNgINAlXNGYZB0LTJlIvcyk3RHlilDVxdXfIMbGxs0weBhmkQag6Rm8qRn8prEKiUUqtkcFByhVJJsoSDB2UuWeXPWLksxelTU9W3hUJ1y+/AgJzPcaRScGpKQsDOTnjqqYUrB5crFJLj8305lgVnqClV527dgkuV58VhyfZ27Jgn2ysWZYZ0IiG/AIcPyy+rUouUHpa24GhXFNOaPzzOeh6X8wVulUp4s5+LmSZ7gwG2OA5mowaAAIUZmDgr77cdhJbd0LQDf+wM8BFG6hYUp6Hz4YXbVH0fxj6RLb+GCd1P1k8IWBGIVduECzMw/C5tvcd4MRblw2yWGdfjnUyWdsuiz3Hoc2wCa/GCgleWGYCZUVmm4s52dzXvliC2kW9PtwnGg7TtayNxKcHomVHC7WHsoEZVa0l/uqouBC0HA4OJQoqJYprO1agK7OqCq1clCNSSB0Kts0HgdJ6mrY2xTl4ppepVLiedhZUqv+ZmaeGN3/Xny7Zls29Hx53fe3swODMjQeLE7Lzvri6pBFyLEBDkz2E4LK3B2awGgapxFQpwdjaX2L9fTvM+3EunZSlIJiO/lI8/Dt3d63qsqvHNzQe8T1uw6/u8nc7MtQC3WhZ7gwG67Tqa77dcbglGPpJ23mgPtM7OBTQtaH+IydBZcGISVI18CLEt0HHk3sUdlUrA20PAaJ3+Lgbi1crAwgwMv0e49zM8F41yOpfnVqlEwpVlImfz0GFLKNjrODgr+f8uZarBXz4hP/MK04aOhyG+deX/vjrTvq+d9EiaQrLA6OlRtjy1pdaHtKFpEKjqRtC0yZQK3MpO0uZEsVb6qkpbmzzYKxRkbWJz8+ocaIMKtcgzPV0YopRSy1cqwZUrMmLM8yR02LdPTov9sxUOy6lSrO55UsA+PS3VgDt3rn2nYiUI1IUhqpF9+qn8TjY1ye/gvM+9x8dlKUipJAMyn3763sReqQco5UoUUgUMw7hvW3Ci7JL3fYKGwZORMG3r2Ta6lirhXTkLdgQ6j95zlpIVx9/6IqSuwfRVSA9CblxCq1jfnZeTHpwNAZ+o3xCwIhCH3mMw/C4UpmH4Payux3gsEuOgF2SoVGKoVGbadRkvy+lMLk+nbdPn2PQ4zoPbwH0PcgkJ/rKjEgTezolKxWSkG8Lt8rPbgAzToPexXgaOD5AeSZO8ldTilTW0Qe6d1EbgmBZNTohEMU2imKIrtMLgzjSlBGNkRKoCN3kQWFkYUkgW8D1/SZvOlFJqs/M8aeO9dEk6DEFm+D300Mr/vJimXMZ6/pmqzAnUhSGqUY2OSmu+YcDRo/cJz69fl7TQ9+UF4qee0qUgalkyYxLOhFpDWM785drjs5uium1744SAANNXJKAyTOh58v4z6QwT2g9BtFfmBRZTMPqxVP91HIHEeQkBMWZDwAbZchtsujMMvPkaRLoIN+9mT6STPcEgGdebDQVLJD2P0XKZ0XIZM5eny7bZEnDotu07tw3np2DmmgSA3u1bxgwJ/CLdEgAGNs8W3WBTkPb97UxcmGDs7Bjh9jBOuPFnINajDXQPpTaCuB0iV05xMztFeyC+8qrArq5qELhv3+ocZINyIg520KZcKJOfzhNuC9f6kJRSqiEMD8P589JVCLII5PDhxu4srGwO1opA1UgyGQkAx8Zk1B/ImL97QnTPkwCwv18+3rYNHnlEl4KoZasEgQstCRmbDQK7nA30FDs7AZMX5f2OhyG4iFesQi2w9UWYuiynzLAEib4HGBImNkoIWBFsgr7nYPI8ZEZmq/fGpGKweTfR2Bb2hYLsCwVJuy6Ds5WCac9jpFxmpFwmapoci0YIF6Zk4Uduonr5VrAa/EU6pQV4k2rb20ZmNENuKsfoqVG2fmbjtUHXg817C1N1yTFtmgNhJosZxgspesIrLI/omh08OzUlLSHO5n5FIdweJjWUIj2a1iBQKaUeYGpK5gBOTsrHwSAcOCDLCBp93JNWBKpG4HkS+I2NSQCYuatjrq1NfifvUCrJUpDK0M3Dh2HPnnU5XrUx+Z5PdlzuLO8XBOY8j7TnYQAdG6UasJyXpR74EN8GTdsX/72GCW0HqtWBhRkarhLwboGYbDcuZWCmH1I3pOpx/JQEhPEd0LyTmB3igGVxIARJ12WoVOJmsUQpM8anI1d5hOzsYhFj9ue6QwLWRn9gsUoMw6DnaA/9b/STGc8wPTBNy46WWh/WhrNB7qXURhK3w8wUc9zMTdIZXGFVYDgspRvptMyI2eTbg2M9MQkCR9J0Huqs9eEopVTdunABLl+W9y1LcoQ9e2T07EagFYGqns3MSBv+xIRs3q4wDGnJ7+6W13pjd3fMZTLw/vvy1rJkKUhPg4YOqm5kE1k818MO2YSa59+uVGkLbrGslS2KqBe+J229bgECTVINuBzBJtjyPKQGZdZduG11j7MWnCh0PASt+yF1E2auy/zE6cvSRh3rk62+oRaaLIum/AS7Zi5yYWaEgudz3rI42LmPYOt+cLQwYz6BWIDOQ52MfTrG+KfjRDujOJHNXdCz2jbIw1m1kTimRXMgzHQxw2ghSV+4ZWUX2NMjk91HRjQI7I5hmAbFdJFiukggpnNylFLqbuWy/NkA6Sg8eHDjbdatVARqEKjq0alTEgaCVOJWgr/OzgXC+IkJqQQsleQG/vTTskVEqRWaawvuvH9bcCUI7LTXaN37ekuch/yktKj2PCnbgZfLMKFp2+odW72wHGjZDc27pF145pr8zNKDcgq1ge9CYYYgcDAU5oTTza3YThKBCM9aQTbYQ4tV1bKrhfRImmwiy/CJYbY9u63xt2/XER2UoepS3JZnKIO5KUqeu7ILq7wSPDoqPSabmGmbRDqkDCQ1nKrx0SilVH2ampLdApGILCHYaCEgVINA14VCobbHotTtUikJAQ0Dnn8evvhFePRR6O1dIAQcGID33pMQsLUVXnhBQ0C1auaCwO75g0Df9xkvy/OVzo1QNp4ckFALoOsxqYBT92cYEOuFLc/JbMTYVgk/85PSEm1Y0LKH4M4v8ei2JwkFwmQ8j3cyWfKb/LnpQiotwqZlkpvMMX19utaHtKFoEKjqklQFRpkuZhjPJ1d2YS0t8nJyuVydLL2JxXvjAKRH0jU+EqWUqk+V0WLt7bU9jrVkmtWAU6sCVT0ZHJS3XV2S6S1YAOL7cPYsnD4t72/dCs8+K4/7lFoFpWyJYrqIYRhzL6bfbcb1KPk+NtBqNXBFoO/B+BkYPy0ft+xp3Hl+tRJshu7HYPsXoO0gtB2CHT8G7YfBDhI2TY5Fo4QNg4zn8a6GgQtyIg6dD8k4q/Hz4xTTxRof0cahQaCqWzFbHsQN5qbwfX/5F2QY1dWOIyOrcGSNrfJqZn46TylXqvHRKKVU/akEgR0dtT2OtaYLQ1Q9qgSBW7Y84IylkswDvH5dPj54EB57TDcDq1VVqQYMt4WxnPlDvkpbcIdtN27rYrkAQ+9Bsl8+bj0gIZZaHjsErfugdS9Yd45iipgmz8YkDEzPhoEFDQPvq2VHC9HOKL7nM3xieGW5gJqjfylV3XJMi6gdIu3myZRX2LdUaQ/WIBA7aM9tDNaqQKWUulOpVJ1NttGDQF0YourN1JQE05b1gB0fpRK8844sgrMseOop2Ldv3Y5TbR5zbcH32RYMMDYbBHY5DdoWXJiBweOQT8zOBHwK2vbrFts1dHcY+I6GgQvqOdqD5Vjkp/NMXpms9eFsCBoEqroWthyKnkeynF/ZBXV2ygPFfB6mp1fl2BrZXHvwsAaBSil1u0RCOgyj0Y05G/B2ujBE1ZtKNWBvrzxsm5fnyVKQZFJ+SZ97TjcDqzXhez7ZCSmZvl8QWPZ9ptwGng+YugWDb0E5J7MAt7yg7cDrJDLbJhzSysAHskM2XUe6AEhcSlBI6nDjldIgUNU1x7QwgJnSCvuWTFOGzYBWBQKxnhgAuckcbnGFy1iUUmoDqYyS3ejVgFCtCNTWYFUPPG+RbcFnzkj/vmXBM89Ac/O6HJ/afLKJLJ7rYYdsgk3zz52cKJfxgahpEmmktnTfh4lPYeyEzAaMdEsIGIjV+sg2lahl8uxsGJjyPF5LZ7haKOBp++s9mrY2EeuJVVuEPf0ZrUQD3Vupzcg2LRzTYqqYxVvpKyTaHjzHiTgEm4L4vk96VKsClVKqYrPMBwStCFT1ZWICikUIBKSRY15XrsCNG9Ky+MQTuhlYranM6IPbgivzATvtBloS4hZh+L3qZuCWfdIObDm1Pa5NqhIGNpkmJd/nXL7Aa+k0wyWd5X637ke6sQIWhWSBxCVdAroSGgSqumYZJiHLIecWSLsrLAHu7pYHjqmUtgej7cFKKXW3YlG6DWFjbwyu0IpAVU9urwacdzTZ8DCcPy/vP/RQdRGcUmukMh8w1n3/KrnxcoO1BReScOs45CbAsKD7SWg/qPMAayxqmbwYi3I0HCJkGGQ9n4+yOd5OZ5gua/dWhR206X5E7vsnr0ySn17h+LBNTINAVfdCpkPZ80iVV1iy4DgydAbg449l0PQmFuuVBzWZ8QxeWedRKKVUpS04Hofg/F1gG0qlIrBc3vR/ElWN+T6Mjsr7lYdqd5iehk8+kfd37ZKTUmuomClSzBQxTINIR2Te82Q9j4znYSAbg+teemh2HmBW5gFufQFi8/3CqVowDINtgQAvxWPsDwawgEnX5XgmwyfZLDmdHwhIMUvTliZ8X1qEPVd/LsuhQaCqe45pYxgGM6VV6F165BEpgchmJQzcxPMXgvEggWgA3/PnXvFUSqnNbDO1BYOMWAsE5H1tD1a1NDkpYXQgAG1td30xl4MPPpAhgl1dUg2o1BqrPDYOt4Ux7fmfMlfagtssC7veK+oSF2D0Y/BdCHfOzgOM1/qo1Dxsw+BAKMTn4zG2OdKuPVgq8/epNBfyecqb+PlrRdfDXdhBm2K6SOKitggvhwaBqu7ZpknAtJkqZnFX+kqI48BTT8mzn/FxuHhxdQ6yQVWWhqRHtD1YKbW5FYswNCTvb5YgEKpVgdoerGqpMr65MsVlTqkE778PhYLMA3ziCW1hVOuiEgQuNB9wrFSZD1jn1YD5KZi+LO+37IXeZ3QeYAMImSZHI2FejEXpsC084HKhyN+n0gwUi/ibOBC0HIvuR2dbhK9OkpvUVzOXSoNAVRdG8jP3/ZplmAQtm5xbJF1ehVXhTU1SGQhw+TKkN28IVmkPTo+mdfOSUmpT+/RTCQPj8eqS+c0gPlsQcu6cVgWq2hkelreVvW6AdG18/LHMdg6F4Omnod4DF7UheK5HdkJeHblfEOj5PhPlBgkCc7Pl7tEeaD+kYXqDabYsjkWjPBUJEzVNCr7P6VyeN9IZJmdvg5tRrDtG83bZGj98YlhHXS2RBoGq5s4kb/HtE/8H/9+hT0iV5x/4GbECqzMnsGLr1uozvcp06k0o1BLCDtl45eoDHqWU2mzGx+HWLXn/0UfB3ESPjg4elIkZmQy8/bZWBqr1l0xKCG1Zd20LPnNGfjktS0LASvmqUmssl8jhez5O2CEYn39g7LTrUgYChkGzVed/NHKzrZPh+63jVo2gx3H4XCzKkVAIxzBIeR5vZ7KczW3eduHOw504YYdStsT4+fFaH05DqfN7LbXRefj8Wf+b+MDH0wP87oUf8trYBVz/zkTfNi1MwyBRTJMrF1fnyrdulbebOAg0DGOuPTg1nKrx0Sil1MqUyxJoJRLS5nvtmiwZPXEC3nsPjh+XfQPXrsk8wExGOg5PnZLv370bWltr+29Yb+EwPPssRKMSxrz9tsxrU2q9VNqCOzsl8wPkl3RgQN5//HFobq7JsanNKT0q3UILtQVX5gN22BZGPVfY+R7kZ+/Uw+21PRa1YqZhsCsY4AvxGNtn5wdeLxZ5PZVmvLT5qgNvbxGe7p8mM65z7xerzuuY1UZ3LphkIFcd8Jn3SvzV0Me8k7jMf7f9GDuiMqjJMSziTojRfBLX99gabqM9GMMyVpBld3fLI85MRrbRtbSs7B/ToGI9MbnjHM3g+359P5hRSql5JBIS9i2mtXV6ev7Xf8JhOHBg1Q+tIVTCwHfflWkZb78tS1kPHtROTLX2KkHgXFvwyIj06oMsBrmjX1iptbeY+YDjZRdogLbg/LQsCLECuhxkA3EMg0cjYfpKDqfzObKez3vZLNsch4fCUjG4WUQ7o7TsbGG6f5qRkyPs/NxOLMd68DducloRqGoubN47rHa0kOQ7V17lrYlLc+FURzBORyjOWCHFhdQw19LjpEuF5Q9Kte3qg8tNXBUYaY9gORblQpn81Pyt2UopVa+GhqTarxICWpZUt7W1QV+fVPkdOgRHj8quqIMHobdXzlN5/mYY0hJc78/n1lIoBM8/D9u3y8fXr8Prr0tnplJrJZeDmRn5HezuRj745BP54o4d8gus1DoqpouUsiUM0yDSEZn3PCXfZ9qVILCr3v9w5GcLLkJaDbgRdTo2n43F2BUIAHCzVOK1VJrhUqnGR7a+Og93EogGKOfLjH+qD1wWo87vudRGd6TQzM88+o/4f918h9cn7tzg6/oe/59bH9KfSfC1bU8RMG3idohIxGG8kOZaZoxkKUtfuI3OYAzbXEbyv2WLhICDg3D48KYcnmuYBtHuKMlbSVLDKcJtOoNHKdUYrl6VJRcgr+scPSrL4Rdyd3GR64LnPfj7NgPHkUC0rw9On5Z5ge+9B9u2SWGW/ozUaqtUA7a1QcDLwwcfyC9lZyccOVLbg1ObUqUaMNIewbTnr5mZKJfxgbhpEqr3obJz8wE7anscas3YhsGRcIg+x+ZULk/a8/gom6PXKfFQKES43m+jq8C0THqO9nDj7RvM3Jwh1hsj1h2r9WHVtY1/q1B1rz0Q41f2fYmf2/kiW8L3Dmf6YOoaf3Dl7+YWiVimRU+4mZ5QMxPFNBfTw1xNj5Eq5ZZeHdjZCYGADImamFiNf05DqswJTI9s3g3KSqnGMjFRDQF37YInn1xeUGVZGnDdrbMTPvvZajHWzZvw2mvVza5KrZZKQ0ZPRxnefx/yeVll/cQTm2trj6obi2kLHis1yLZgnQ+4qbTZNp+NRdkXDGAAw6Uyf5tK88OZJK+l0ryfyXI6l+NKocBgscRkuUze85bfXVdnwm1h2va0ATB6ahS36Nb4iOpbnd97qc1ke6SdX977Y/xo9Cx/N3b+jq/1Zyf4zqUf8a09L9EZlPkWETvIzmgnE8UU/ZkJkuUcfaFWmpzQPZdtGAZRK3jv/DvTlNKH/n55NNq5ObdpRbuimJZJKVuikCwQbJp/Q5pSStWLi7NF5Nu3a+HQWrBtqQLs7ZVlKuk0fPSRfPzwwxDUPxNqhdJpmJoCA5+tY5/I+uBgEJ55RtN5VRNe2SObkNXpi1kUUvdBoM4H3HRMw+BgKESf43A6l2fKdXGBtOeR9rz5vwcImyZh0yBmmsRMi7hlEmuEite7dBzsID2appguMnpmlL4n+mp9SHWrzu+91GZjGSZf6XucHZEO/t833qXgVbcfjRdT/N6l/8a393yebRFJ+03DoCvYRNwKMVKYIV0uELODGNzb4rs72klbcJ4S4S1bJAgcGpLyh6amtfrn1S3TMol0RkiPpEkNpzQIVErVtbEx2Wxrmpt3wcd6aWuT6sBLl+DKFakKnJqCz31Osxq1Mrduydsd6U8JMCq/0E8/LdtrlKqBbCKL7/k4EYdALDDvedKuS873MYF2u84XEuh8wE2rybJ4PhbF831ynk/W88j5nrz1fHKevJ/3fTwg43lkPJjABarzBR1DwsG4aRKbDQcDhkHAMAmYBjbU1aJJwzTofayXG2/dIDWUItWbIt6nIfh8NAhUdeloy3a6g038ybXXmCpl5z6fcQv80dW/51f3fZHuUPPc58N2gB1WB6lS7o7wEKDsuWTcIh3B+PxBYGurPNOZnIR33oFjx6C5+d7zbXDx3jjpkTTpkTQdB3SOiFKqflWqAXftkiUXam2ZpixZ6euDDz+U2YGXLknFoFLL4fsSBIZHrtPnXIcY8Pjj0NJS60NTm1hmdPHbgttsC6uOApB56XzATc80DKKWQdSav7LP933yvgSFWc8j43mkXI/U7Mcl32fKdZly3dvzwTkGEhY6hjEbEN75ftQy6bJt7HX8XQm1hGjb10biUoLRM6OE28PYQY297qY/EVW3esMtvLL/x/mTa68zmJua+3zGLfCHs2FgW6Aa7JmGQXPg3u1eBbdMMTdFunyfjbiGIa9Av/++lDm8+660pbTeO69wI4t2RzEMg0KyQDFTJBCd/5VQpZSqpZERmJ6W2X5799b6aDaXpiZpC37/fSmk37lTti8rtVSTk+AOjdI++CktR5HV3r29tT4stcktZj5gpS247rcF63xAtQiGYRA2DMKmyd23Es/351qKU65LejYoLHo+Jd+nDPhA0fcp+j6Z+1yHibTR9zo2PY6Dsw6hYPu+dtIjaQrJAqOnR9ny1JY1v85GU+f3YGqza3Yi/MreL/Lvr7/B5fTo3OenS1n+8Orf8yt7v0iTs3ALiWUY2KZFply4/5kcBz7zGXl2MzkpaxKfeUYqBTcJy7EIt4fJTmRJj6Tnhq0qpVS9SCTg/OwI2d27ZdeTWl9dXXIaG5NlLU89VesjUo1o6EKSlmuf0N7mY+3arqm+qrlCqkApV8IwDSId9xYWgAQjEzofUG0SpmHQZFk03WermjcbAJbuelv0fYqevJ10XTKex2i5zGi5jJHL02Fb9DkOPbZNYI1mEFZahAeOD5AeSTNzc4bmbdLx5/s+LlD2fXKuR67eK3vXSJ3fgykFIcvh53Z9lj+8+ncMZBNznx8vpPjja6/xS3t+jIh9/2eDpmHimBY5r0TRLROw7nOzt20JAz/4QNZRVsLA9s3zKlq8Ny5B4LAGgWvt2jUYHZVOKB26r9TCbtyQ+XSZ2ZebHQf27KntMW1mhw/D+LhUZ05MQId2naklcDN5cq+/j+GWaT/QIWWmStWI7/kkB5NMXZXuo0h7BPM+bZSVxQtBwyBe70sUdD6gWmOmYRAyDB40oSXlugyXygyVSqQ8j/Gyy3jZ5TTQZlnE7vP7tly+D2V8yhYkt0ZIXkxw5oMbRANb8EM2t+8SLpfLXAlszidiGgSqhhCyHL61+yV+/8qrDOdn5j4/mJviz66/zrf3fJ6AOf/N2TQMAoZNrpwj6xbvHwSC9Jo9/bQMQRoflwrBp57aNNuEYz0xRs+MkpvKkU1kibTP/4qoWplCQaqaPA8uXIBHH631ESlVv0ZGZGstyOs1W7ZINaAuqqideFzagq9fh7Nn4fnn5f+mESUS8sJMSwt0d2/KfWHrwvchlYKxYZfMjz6AfB67JUb8pSdlCKVS66xcKDMzMMN0/zTlglT5mZZJ2977vxA+WqpWA9bTgoR56XxAVSfilkXcstgfCpJxPYZKJYbLJWZcj4TrknDdB1/IMvk74hSHU5Sn85TPjBN9qjqCojLf0MRfs+uvZw36sE1tWJ6LlZsAwwTDwMecez9uWPzitmf4t/1vkbhtgci1zDj/+/U3+dkdz2Ob82/vCpgmHj55twg8INy6PQwcG5MKwaeekl6oDc4O2bTsaGF6YJrR06Ps/OxODLPOH+g0oIEBCQEBbt6UUCOuXRtqE3FdmcIQjUJkgbvkXA5OnpT3d+6USjSrzpc0bhb798PQkIQ7n3wifybr8Xnx9LTczuYLjjMZ+VNfKkngfOGCLJ/p7pY/+Z2dentbrnJZfvZTU/K7PjUFpaJP85VPCE3N4NkB2r78DEZAE321vgrJAlPXpkgOJvE9CQDskE3rrlaadzRjOff+0o+XylwuFOYCC50PqNTyRC2TfVaQfQTJeh6jpTIlf3WDOAOwDQPbkLf+MzsYPj6AmfbomSzTvqMF2zAwDYNSqYRbWGB82AZWN/diP/3TP833vve9Wh+GqjHDKxIaP33fr4eB/3soxP+jnGfG9+Y+fy41zPcv/md+PhLHnOeZiIlH2rcplpPQtheCrWAt8ODTNOVZzccfy7ODDz+EJ5+UZwcbXMehDtIjaYrpIpNXJ2nfpw8gVpPnyZB9kCec+bxUBz79dE0PS6l143kyeWFy9jmK48ii9ttPlQUUn3wiIU1Li2yo1cKh+hEIyJ/Jd96RMQfnztXfFuGrV+W4gkF45BHo6al+zXXho4/k9tXcLPfHExNynzwwICfTlOkg3d3yveGFRxJvaoWC/PwqwV8yKVWAt2sePEe3N0LLLpP4jz9NZIt2Haj14fs+mbEMU9emyE5UiwlCLSFad7cS743f88K37/sMlcpcKRRIzr56awLbAw59Tt08hZ6fzgdUDSBimuwKrsOw51aH8JEexj4dI30+QUd3HDOiL0I13EPq4eFh/uk//accOHAA0zT51V/91XnP95d/+ZccPnyYYDDI4cOH+au/+qt7zvNHf/RH7Nq1i1AoxBNPPMHx48cfeP1vvPEGTzzxBKFQiN27d/Mnf/In63bdm4UbasUNNuMG4niBGJ4TwbPD+HYQ33LodAK8Em8hclfg92GpwF/k0vjzvKpg+gaBUori5BUYfh/6/xvcehMmPoXMCLjFew/ENOGJJ6CvT565fvihPNvZ4CzHovMhaYVOXEpQzMzzs1HLNjQkT5hCIRlJaRhys5qYqPWRKbU+zp2ToMA05VQqye3/6lUJ/l57Df7rf4XXX5fz2bbcFWsIWH9aW+Gxx+T9a9eqL3LUg+np6mKZQkH+hJ88Kbe1dFrazZNJCQmfflpOP/7jMhp4506pVPU8mRJy9iz8/d9Xw+vNLJWSn+3tEgn5+XzyibSLz8xICBgOw5Yel0fbbvKSfZzn+65x4AB0/4PHiGxprcnxq83FK3tMXZ+i/7V+Bj8YJDuRxTAM4n1xtj+/nR0v7KBpS9MdIaDn+wwUi/x9Os0nuRxJz8MCdgcCfCEe4+FwuP7bgnU+oFJ3aNnVQqQ9gud6DJ8Ynjcv2Gxq+nLGxMQE//1//9/z2muvMTo6yltvvcXjjz/OX/zFXxC4zyrAQqFAZ2cn/+pf/Sv+7b/9t/Oe59133+XrX/86//P//D/zj//xP+av/uqv+NrXvsZbb73FM888A8APfvADfvVXf5U/+qM/4rnnnuNP//RP+fKXv8y5c+fYvn37vJd7/fp1fuInfoKf+7mf4y/+4i94++23+fa3v01nZyc/+ZM/uabXvVn4dph8z4NXELYCv5CZ4A+v/h1Frzz3+TeKeZzmXfzfeu8cuuaWchRTt5gppfHtEEY5C4UZOc1ckzMF4vIHM9wOwRaww/LM8/HHJa0ZHJRnsJugKrBpSxPJm0ky4xnGzoyx9TNba31IG8a12Zvbzp13ztk6dw5eeKE+W+uUWi23bsntHSTc6+qSYGFmpnpKJqWtMJ2W8z3yyMLtw6q2+vqkxfbCBQnetm2bv53WLbokbyXxXO/eLy5BuVSmMFRg8vIktmMTiAWIdcfueCJfLktBv+9Db6/cfq5elVEMN29WL8swpNg/NDvp3LKqW5FhdqbdmPz5n5mRy3zxxXsXPKXTcOmSBF/792+8dmLXld/dGzeqIeD27VIBOjUlIavrQiwmP7vWVmgNZgmP9ss3lUryTbYJhw7JjUapNVbOlxk4PkA5L88TLMeieUczLTtbcML3VgOVZgPAa4UihdmQIGAY7AoE2BUM4DTSAzSdD6jUHQzDoOdoD/1v9JObzDF9fZrW3Zv7BSnDr2Ec+o1vfIMPP/yQP/3TP+U73/kOv/zLv8x//a//ld/8zd8kFHrQ/hn43Oc+x9GjR/nOd75zx+e//vWvk0wm+Zu/+Zu5z/2Df/APaG1t5fvf/z4AzzzzDI8//jh//Md/PHeeQ4cO8dWvfpXf+Z3fmff6/sf/8X/kP//n/8z5ykvMwLe+9S1OnTrFu+++u6bXvRGVSiV++MMf8uUvf5kcLueSg4RtB+c+Sz8AHMO641W4i6lh/uTa67j+nU8svrX7cxxu2jL3se/7jBVSlD2Xz7TvIeS78kcyn5AZGsXUvVdmWBCIgRMHIwhvfgxmEL78jzZFf1AxU6T/9X58z6f38V6atmzuCeqV2+tP/MRP4CxzS8HkJLz9tuTLX/yitNYVi/B3fydPXB9/XBYhKLUWVuM2vBIzM3L7d13Ytw8OHpz/fL4vwcrMjFQD3t7OqeqT70tFWDYrFYJb73rtKD2aZvTU6NxA/pVIpT3eevcsjz7yKJYtiZsVtGje1kzT1iYsx2JoSKZ6hMPw2c9K+/nkJFy+LMdYKMh97sMPw44dD77OchneekuCwbY2OHZM7sfLZQkAr12rtsFGo/IzaN0gzy98X35vp2ShKoZR/beGw/Kz9DwJAJ960sdMjEtp6O0dFOGwvOq1fbv84VN3qPV980Y1+OEg6ZE0TtihbW8bTVubMO17S8vznsf1YpH+QpHKPVTYMNgTDLI94GA1UgAIMh/w+n+V1uBtn1uX1mC9DatGUZmDb5gGu17aBQ6b9rZb04rAEydO8I1vfIPPfvazfPe73+Wll17ipZdeWvHlvvvuu7z88st3fO7Hf/zH5wLDYrHIxx9/zL/8l//yjvN86Utf4p133lnwcr/0pS/dc7l//ud/TqlUwnGcNbnuQqFA4a4hlqZpErz7JekGU5p9hbhUKjHjZskU86SKWUzj/v1fQcOmIxibCwP3hjv5Z1uP8b2b7+DftvHn+PglDkTurNyzfYNsqUQ6n8UKRCDUJSeQ1uDZUNCoBIN+GUoFYPZVtcINjGQG/8MUbNuBH+uDpt1wnwUljc4IGDTtbGLy0iTDp4YJtAbmHaC8Wdx+e12uS5cMymXYts3HMKRIwjDkiejFiwZnzkBHh68tkGpNrMZteLkyGXjnHYNCQQKD3bt9FjqMUKhapVWDw1XL0NMj93HXr0N3t/w99soe42fHSd5KAuDEHCJtyy/v9Dx4722bwVw3selmLNMiP5PHK3lwJoVhpol0RIh2R3HCNo88IsdRKkkF9uOPVy/L95m7H16MRx+Ft94yGBuD48cl0E6lqoufOjur1a1vvAF9fT4dHdDR0divHfb3w/i4gW3Dvn0+W7dWWqsNUrOvofZ2lDgaH8D7uxt4mUz1mzs78XfskE6KSpiiv9D3qOV980aVHk4zc2sGwzToeryLYDyI67u4pep20ozncbVY5FapxOzOEOKmyZ5ggD7bxjQMvHKZldUw10B+EqNUACuAb4TW5XdOb8OqUUT7ooSHw0Q6IuBs3NvuYkLNmgaBzz33HN/97nd59NFHH3zmJRgZGaH7rvbN7u5uRkZGAGlJdl13wfMs5XLL5TITExP09vauyXX/zu/8Dr/5m795x+e+/vWv80/+yT+577E2klf/9lUKxoP/zHqzUd8wBkG/GkgFgc+E2ng3mpj73PnkEKfffP+O8+UNFxef1/0rOA8aj+n7WH4B28tjezlsL0d8ZJzo8DDFqTGyO6W/0zMCpJ0+cnaHbDfeYHzPJ/1pGi/nceLyCcI7G/jZzCp59dVXl/V9hYLF6dMd+D4UCgkGB6uVMa4LZ850Uiya9Pen6O3NLnBJSq3Mcm/Dy1Usmpw/306hYBKJlPG8Sf7mb3Q2y0ZTKJicOiXzZYeHJ7AKBXLXc3gF+fse7A0S3BLEyC6/uiaVcrg03kaoxyHhXgQX/LCPWyxTmizj5V24CRjQuaXA8aSH3bx6D3WnpoJcvtxyx+fCYZdt25KYZpFy2WBgoIlE4s6ullDIpampSFNTkXi8gOM0xu2/VDI5c6aDctlgx44knpfj4kX5musaTFz1iSdG8eybnJjtzPBtm1xHB9muLtxEQgYIqkVZ7/vmjcov+6TOpPBLPsEtQS4dv3TH112g3wkwaVn4s3dHcdejt1zC8DxOA/dfW1j/osUhYqVbFKw2pj9deRX2UuhtWDWMUeDT6ocb7bb7la985YHnqWkQ+Hu/93v89m//Ni+//DJXr17l5MmTfOtb3+Jb3/rWii/77iGuvu/f87nFnGcxl3v351f7un/t136NV1555Y7PbZSKwFdffZUvffFLi0qtS57LtcwYN7OTdIWaidrV9pLtbpEPLvz1XIuwZ0Du4U4ead09d568W2I4N82eeDe7IsuYmTE+jvHeexC08Y8dwZi+DKXZwMaJ4rcdhGjv0i+3zmWPZRl8dxCArce2Em7dnGFg5fb6xS9+cVml4+fOgeMYdHbCM8/c+yTw6FGpsHAc+PznfTZZdbpaByu9DS/vOqUS8OGHpWXy2Wf9e+arqY2jt9dgfMynw5ykw0nAw2BHbLof7SbSvvJBj5cvQyjkMTDwHv/iXzx1z+04m8gyfX2azEi1Ki0QDdCyq4X4ljimtfIX7IaGZI5lZcP1fPMrJydltmAiYTA9fe/23FgM2tt9Wlurl1GP3YcnT4JlGTQ3w/PPSyU7ngdDQxgDA2BMwd5OoBOamvB37pT5FhttSOIaq8V980Y2emqUpJnEiTnseHHHPduAz+bzGMUSu4Bu22ZPIECbvXFus8bw+5Drwe84Ak071+U69TasGtVmvu3WNAiMRqP81m/9Fr/1W7/FV7/6Vb785S/z8ssvY5omP//zP7/sy+3p6bmnum5sbGyuCq+jowPLshY8z1Iu17Zt2tvb1+y6g8Fgw4d+C3EcZ1G/eA4Ou60eCobHeD5FyGkjYMlNOGbbHI73cSZ5a+78J5O3eLZzf/X7TbDLDjm/tLxf9K4umW3j+RDqgV07ITkAU5fALUDiFKQHoO0QLCdorFPNPc3kduWYuTnD5PlJdrxw74OqzWSxt9fblcswPMxsaxXzhny7dskQ+2RSWrEOH16d41Xqbsu5DS/X1auQy0nw8fzzjd0iqR6sty3HxTdmmPFLdD1q0bqzhc7DnfPO5VqOZBIsq0w8Xpz3dtzc00xzTzPFTJHp69PM3JzBzbkkziWYvjJNy44WWne3YgWW/6R/MTMFu7ure8VKJQkGJybklEzKnMJstrq4xHFkfN6ePfcuIqmVyUmZs2jbMvMw4OZgYEBOxaKcKRCQbSw7d8rwRLUi63nfvFFlJ7JkhjNYtsXWJ7YSCN45kzLlugx6PrZt83QkTPdG+3n7HpST8osb75n/Aeca0tuwalSb8bZbN72MLS0t/MIv/AJf/vKXOX78+Iou69ixY/eUd/7oRz/i2WefBSAQCPDEE0/cc55XX3117jxLudwnn3xy7oazVtetRMQOsCvaQdwJM5yfxrvtZfbHW+98dH4pNUK6nJ/72DJMHNMiUy4sb2W4bVenf09MSCtw8y7Y/gVo3S/LRQrTMPwuDL0nG4k3iM7DnViORSFZYOr6VK0Pp+HcuiVPBqPR6jbKuxmGLFME2aqa1e5gtQFUXvM6fFhDwI3G93xK2RLZRJaZmzOMnR2jdOUmfrlMybcJ79tK9yPdqxYCep6EUwDxeHHB8waiAbqOdLH7x3bT9VAXTtjBLbokLie4/tp1UkPzLAhbI44joeBDD8niki99STZm79wpDylMU/4+XL0Kf/u3cPasjIuopcomYIBdsXFar3woW60uX5YQMBSSbT8/9mMyeFFDQFUHPNdj9LQsqWnZ2UK47d4/OmfzeXyg17E3XggIkJ+WJSFWYF2WhCilGldNKwJffvllvvrVr3L06FFc1+W1117jjTfe4Nd//dcX/L6TJ08CkE6nGR8f5+TJkwQCAQ7PltD8yq/8Ci+++CK/+7u/y1e+8hX++q//mr/927/lrbfemruMV155hW984xs8+eSTHDt2jD/7sz/jxo0bC7Ylf+tb3+IP/uAPeOWVV/i5n/s53n33Xf78z/98bhvwWl73ZjUwIC0znZ3Vz7U6UXZE27icGmW8kKQ71AzAkaYtOIZFyZdH0B4+p6Zv8lzHPgBMDGzDouCVyXslwtYyNtd1dFRf2t++XT5n2tB2QMrvpy9LlWBuHG6NQ2wLtB0EZ+UtUbVkBSw6D3cycmqExMUE8b44TngDPoBaA74vGyUBdu9euP2rq0tu6+PjcOHCnYPtlWo02awsTzCM+wfgqn75vgR9pWyJcq48934pJx+X8+V7XlQzTdh9KEgq0MbAuEVTz+ptz52ZkYDMccAwFjf3ynIsWne30rKrhfRImsTFBIVUgaGPh4gNxuh+uBs7tL4PhYNB6OuTE8jfiPFx2T48NVV9Ieipp2rTLjw4KC3B9tQ428fPcHBnBtKzX+zokASzp6c+e5mB1HCKySuTGKZBy84W4r3xTd3FsJkkLiUoZorYIZvOQ533fH24VGKi7GICh0Ohey9gI8jPzuQMtdf2OJRSda+mQeD27dt55ZVXuHz5MplMhtdff51vfvOb/NIv/dKC3/fYY4/Nvf/xxx/zf/6f/yc7duygv78fgGeffZb/+B//I7/+67/Ov/7X/5o9e/bwgx/8gGeeeWbu+77+9a+TSCT4N//m3zA8PMyRI0f44Q9/yI7bej5+4zd+g+9973tzl7tr1y5++MMf8vLLL/OHf/iH9PX18fu///v85E/+5Nz3rNZ1KwkBT5+WB82f/Wy1XcYwDHpDLeTKJa5nxpkp5mgOhAlaDkeat3Bi+sbcZXwyPTAXBBqGQdC0yZULpEv55QWBsy3g8w6/toPQcUSqBCcvQnpQTplhaNohLcMNvGG4eXszyVtJsoksY2fG2PL0llofUkMYH5eNqY4DW7c++PyHDsn3DA5KcNjSsuaHqNSaGJXCDNra1r07Sa2QW3IZ/GCQ3GRuwfMZpoETdnAiDnbYJtYTozcc4/hxCe7eekte3Ni9W96uJDuqVAO2t8v8vaUwDIN4b5xYd4zE5QSTVyZJj6TJJXJ0Hu6keXvz8g9shSpBeVeX/M589JG8PXdOqgjX08WLEkgCbM+cZ/+uDFbQhm3bJACMxdb3gJagkCowdnaM7ES1nD43mWM8OE7z9mZadrase+ir1k9+Js/UVelY6X743kpk1/f5NCddQnuDASJm3TTFra7c7POT8MYZUaSUWhs1rwh8+eWXAfjpn/5pvve97y3q+xbT1vlTP/VT/NRP/dSC5/n2t7/Nt7/97ft+vb+/n8997nN3fO6zn/0sn3zyyZpft5LQ5Pp1qSg5cQKeeab6JMIyTLaF28i4BUZyM4Qsm6Dl8HjLzjuCwCvpUaaLWVoCUpEXsQNMFtIM5WfoCMYfuBzmHm1tUvKQz0M6Pf+DYicK3Y9Dyx5InJfqwJnrUEhC79NSQdiguh/ppv+NftKjadIjaWI99fukoF5UqgG3b5fu8gdpbpbb/q1b8kRQJwaoRlUJAhcYvavqkFtyufXeLfLTeQzTIBANYIdtnIhzR+jnhB2soDXv39HPfQ6uXJEZeOPjcgqF5H5w27b5F2w8SOX1t7Y2f8lBYIVhGnQc6CDeG2fk1Aj56Twjp0ZIDibpebQHJ1LbxLq7W+bxffyx/O2IRiV/W2uuC6dOyQtQAHt2eRw0Uhg+8OKLciB1yi25JC4mmO6flsV7pkHbnjYMy2C6f5pyvjwX/sZ6Y7TsbFmVxTWqfvi+z+ipUXzfJ94Xn/ex6ZVCgZzvEzYM9tbLIM7V5nuQn33FJKwVgUqphTVuIrEO3njjDd58881aH8amZVkyR+f4cXkScfUq7N1b/XrIdtgZ6SDvlhjKT7Ej0sHhpj6Cpk3Bk7YhH/jf+4/zi3s+T9BycAyLuBNmopBkopimM7jE+RmmKWFgZer3Qq+OB5uh7zOQHYfRj6Rcf/h96H2mYcPAQCxA2542EpcTjJ4ZJdIRWbX5TxtRKiW3XcNY2pO5gwdlM2UiIWFKvQYpnieD7x2nfrdeqtool6vBTU9PbY9FLZ5X9hh8f5D8dB7Lsdj27DaCTUt/0hyNwqOPynKk69clEMznpdrs0iWpDty+XW4biynM8f1qReBqjKMLNgXZ/vx2pq5NkbiYIDOR4fLrV2na30J024NfJLRMk6gVxFyDO72+Pqkiv3BB5gValoSna6VQkHmAU1NyH/7II7C9JQ3XPblzr9MQ0Pd9Zm7MMHFhArcoI2FiPTGZCTkb6LbtaSM9mmb6+jTZRJbUUIrUUIpgU5CWnS00bW1alU3Sqramrk2Rn5H7rK4j986hyHoeVwoyV/RwOIS1UR+s6HxApdQS1E0asdhqwPV0/fr1Wh/CphePw5Ej8kr1hQvSEnT7vKFmJ8z2SDuX02VG8kl6Q8081rKD9yavzp2nPzvB/7P/TX5+1+dwTIvmQJhUJs+t7CQdgdjSqwI7OiQEHBtbXLoT6YTeYzD8nrxSN/SehIFWY/bKte1rIzWUopgpMnFxgq6HdPjX/VTuQnp6llYBEw5LK92VKzKrqadHnjh3dMiSxuVIp2VzcTIplx+LyfO7aFQqdRbD96Xdr5KDT05Wh9qbplxmU5P83lZO4bAGhJvR2JgExZXbmap/Xtnj1nu3yE3lVhQC3i4SkfbWQ4fk/uf2CsHxcbk/27pVQsH4As9bk0lZwHUu5AAAu5hJREFUqGHbUjW9WmK7mqDDZvDMMDOTKYbOTFO6BpEDTVjR+/+NtgyT7eFWesOtaxIG7tsn27YHBuRvQDYLBw6s+tWQSsH778t1OQ48+aT8neHGtJxhNX/Yqyg3mWPs7Bj5GWn1DMaDdD7USbTzzjsbw5SW8HhvnEKywHT/NMlbSQrJAqOnR5m8PEnHoQ7ifcvoEFF1oZgpMnFhAoDOhzqxg/c+tT2Xz+MB7ZZF30aeU6HzAZVSS1A3QaBS97N9uzxhGBqCTz6RLpXK33HDMOgONZF3i1xNjzFVyvIPex/hfGqImVJ1ttHF1Aj/x8DbfHPnCwRMm+ZAiEQxzXgxRVewaWkH1NsrqeToqLxsv5hnuaEW6DsGQ+9CYUo2C/d+Rl61azCmZdL1cBe33rvF9PVpmrY2EWreoEOXV6BYlCe9IKHeUu3dK0+cMxm4cUNOIM/LKqFgW5tUi9xPMimXMTwsT/jux7LkZnx7OFh5v1CoBn+JhDwZv10gIGGg68r1JZP3XnY8fmdA2Ny8/EBTNQZtC24sXtnj1vvVEHDrsa0rDgFvZ5qwZYucslm5P6tUCV67JqeuLti/f/7lItW24OW9sOD6HueTQ1xKjeL6LqZhYmDg4+P6HoWtJXKhHKWbOYIzFtZH00R2xIlvidMeiN4REvlAqpTjSmYcH+hbozDwkUfkfvLyZamiTKXkRaF4XO6fF7rvX4yxMWlBLpflvv6ZZ257OFO5I6+zILCcLzN+bpzkoByf5Vi072+nZWfLAxeCBJuCdD/STcehDpI3k0xdm6KUKzH8yTBT16boeqhr3i2zqr6Nnh7F93wiHRGat917e50olxkulTGAI+EN/lhV5wMqpZZAg0DVEB55BKan5QnE6dPSMlxhGSZbI21kykUGc1P0hVv4xT1f4N9dfpWMW5g736mZm3wyPcATrTuJO2FmSnluZidxfW/B645YAZpv3/obi8kzlrExKfk6cmRx/4hgM/Q9KyFgYUZCwb5jDRkGRjujNG1pIjmYZPT0KNuf366vpt9lYEAqopqbl9fK5jiyJCeRkCB8YkKem83MyOnKFXly3d4uoWBnp4RtMzPV8C+TqV6eacr52tvlyXcmI6ds9v4h3nxsu3o5nZ3ypNT3qxtibz+l03LZ09Nyul04LD+b208bdYnfZuP7GgQ2krkQcLIaAq7lizuRiIw/OHBA/ozeuCG3l7ExuDlWIBAvUnY9ikW5LcXiPsWCQdaHjiafkXyZjFFmJD+D7c7/MDbvlriVnaQ/m+BKeoyzyVtk3eKDD+72RaN54Co0WSEON29hb6wLZ3bhl4VJzi0xU85ScEtEnKWHpgYGLXaEkH3/CqWDB+W+8syZ6v16RThcfXElFpO3t7/AUizKCzmFgvwtAnmbTsv9ceX+vr1dNhTfUSg1MyNv6yQI9D2fyauTTF6exHPlH9O8vZnOQ51YgaUlopVN0s07mpm6NsXklUny03luvH2DeG+cjkMdBKKN97hsM5q5OUN2IothGnQ/cucfm7LvM1YucyEvzwN2BgI0rTQ9r2c6H1AptUQaBKqG4Djw+OPw9ttSGViZL1QRMG12RNvJe0USxTRbI238iz0v8b9d+du5eYEAfzNyhqMt2wmYNi1OhIl8iuRtlYPzCVsBnmzdiX37xt/du6vPYA4cWPxKzGCThIFD70IxCUPvSNuw3XiDizsf6iQzliE/nWdmYIaWnS21PqS64Xkwu2x8WdWAFZZV3SYJ1eq8SltdPl99//x5Cfu823Jt05Tv7e2VQGa+m6nnSYhXCQbT6er7uVx1LGYlbGxuvrcixzCqlYS3z4OrXHYyWQ0Hk8nqZedyMDJSPX8wKJff3g67dq284kWtnsr/meNUT7Z9720hl5PXR0olOc9qzHNTa+eeEPAzaxsC3s4w5H6pu1tuX6cv57lyI8+N8dQdf7e5rZq52SmSTUtZ8qX0CKZlkXdLjOZnGC0kGS0kGcnPMFXKslqSbp73Jq/eMXLkdgHD4kC8h0ebt9Mbal7Si2IdgRhHmrcu+D07dkjId+uW3D+nUhLyVe5Dl7s4BeRx1MMP3zWnsTIDAmoeBPq+T/JmksSlBKWc/L+HW8N0Pdy14tupaZm072uneXsziYsJZm7MkBpOkR5N07Kzhfb97ViO/hGqV5mxDKOn5RWnjoMS3hY8j9HZCsCJcpnKw6GAYXAg1HiPs5dE5wMqpZZIg0DVMFpb5dXx8+dlgHZr650zhcJWgFYnymRRyqC2R9r5p9uP8d3+43PnGSsk+Xiqn6fbdtMWjBK1g3gLVAQmyzlSpTypcp7WwG0twJXyq2RSSr9u32LyIIE4bHkOBt+BYgqG3pZw0G6scig7aNNxsIPRM6NMXJggviWuD5pnDQ9LSBcMyuD31RIMVtvrQJ4UVoLAREJavCxLnlj39koI+KBNxZXZfvPtvXFdebK+mGH+S7nscll+daanqxWO6bQEnWNjcurvh8OHV/fnp5ZuZkbaEkdGwC27lHNlyvkyhmnghB3CcZtA0MC25f97ZkZyBJAFB1ooXL8812Pwg0FykzlM25QQsGX9/w75vo8XLLD9QJZC5ySRSZ94MMCF0jVuFRLkih6FsotnuPTPlClNuuSaMjAwRsl3ySym0m8NFX2XM8lBziQH6QrEeaZtN4+17CC64At8PtPlHOOFFIlimo4HLC5ra7szVC8Wq6Fg5W0qJfetFY4jfzNCoep9eOVFm0oVdni+TthMRu78KzMjasD3fVJDKRIXExQz8v9rh2w6D3fStGWJ41wewA7adD/STcuuFsY/HScznmHq2hTJm0naD7TTsuPBbcdqfaWGUwx/Mozv+VgdERJbIpxLZ5iqDC2eFTVNemybHYEAzkb/Y6TzAZVSS6RBoGooe/ZUK6I++QSef75aNWQbJmErgGWY5NwiYSvA0eZtbA23cSs3OXcZfzNyhidad2IZJkFr4V8BH8iUCvcGgSClXidPSvnL7t1LS0ucKGyZrQwsZaqVgU5jzadp3tHMdP80hVSBySuTdB7qfPA3bQKVJSE7dy4/RFuMSsi2a5dU32Uy0na3WpV0a1WRZ9v3PrGttCdPT8uG8FxO5lf190v3fdPqPvfbEMplua2Vy/JkPxCQCsxKsBqLVedJLuX5fLlQJpUocvIjl1s3XEq5EuVcmaBVwnUNyq7BbHcehmFgBy3ssIMTdnAiNt1bHHYfsNm6dYM/8Wpgbsll6MMhsolszUPAdDnPTCnHjewkpuMS6SzyH268xkQxfdeZgUoBv82dqdcitQeiRMwAviHX7foeZd+j5LuUPJey71KeLav2AR9/SZc/VkzxX0ZO8cPRMzzavI1j7XvYF+uZd4agZVrczEwymJumfYmLywKBe+9DV02lGrCpqSZJfno0zcSFCQpJaem0AhZte9to2dmypht+g/EgWz+zlcxYhvFz4xRSBcbOjjF9fZrOw53EeuZ5tUytu5mbM1z9ZJipcplMZxgONmEUqi8GtFgWPbZNj2MT3yxtBb4P2dnSYJ0PqJRaJA0CVUMxDHjsMXjjDQkNzp2Tthb5mkHUDhKyAmTLEgQahsE/7H2EP732+txlJIpp3p+8xrPtD67is00T0zCYKmbYHrnrVbYtW6Q8MZ+XErBKmdZiOdFqm3ApA4NvQcdDEGucEijDMOg41MHgB4NMXZuiZWcLTngDb2RbhKkpOZmmtHStF9NceOtmvbMsqfJtbZV2tatXZQ5iIgFvvik/ywMHdMlIRSIBJ05IYHo/qRTcuumSS+QI2i7xcIHBCz43OkYIOSZe2ZOT682977s+owmTi/1BSmUDw4CutjI7theJRXzskE0wHqRc8shMFSnkPcquQblsUHYhHvGI5Hxypw0GrgUIxoMEYgEMa+FAwQ7asrlTK2/WVCFV3Zzqlb25EDDcuv4vQlVCwOlSjhvZBFOFDJ+mh3hj/MIS47f5GUBXsInOYJyuYBMH4z3sjXXj+zBRTJErFzFNg5gVJuYECZgWpnFn0DSWT/JpcpBzU4MkMil8V46sZHukjSLefY7U9T0+mR7gk+kB2gJRnmvfx+c6D87NGARwDItmJ8x4IclEMU3nA6oC102N2oKzE1kmLkyQm5I7NdM2advTRuvuVkx7DV9Ru0u0K0qkM8LMjZm5isTBDweJdETofqRb5wfWgO/7TJRdrl6dYODUCEXfJ7C1ifCRDkzDoMO26LEdehyb0Fq++lqPcpOQOCuzx0GDQKXUomkQqBpOMChh4HvvSbVQR4e0QQIELZsmO8REMUU78urt4XgfOyMd9Gcn5i7jvwydJGTaPNayY8FX4W3DJGg5JEs5Sp57x4N4TFNKsS5cgIsX5SCW+gDEicwuEHkPSmkY/Rhm+qHjiMwTbACx7hiR9gjZhDyI732st9aHVFOVasAtW+S2qpbOsmR76LZtEvYPDcnv+uCgjAfYsWPztpx6nrz+cO2afByJSCt4Pi/tgqGQPH+PxWD4WpZL700xM+Xj+zDsely50oRf8GmOu7Q1y6k5Ju1UiRmLobEAiRkLO2jT2W3x+BMG7T3OXKB39xPycr5MIVWgmCpSSBUoJOV9z/UoJAtzVT2LMXV9it7He/WJ9irzPZ/0SJrp/mmyiersvEAsQM/RnnULAX3fp+RXW/fybonh3DRvTFzk9MxNrmUmllyBV2H5sKVksaNks8VpoqdvB/F4O7lsilC5zM5oD+2xDkKRGNg2uXKRiUKa0cIM06UsM6UsIcsh7oQIWQ4GcgfT5kR4qesQL3Udwvd8UldmSF2dwfd9zKAJhyKctUZ4N3GVxN0VjLMmixn+y/BJPpq6zn+3/Vm2RaSMzzAMmgJhktk8t7KTtDtRzHoIMdYhCPRcj1KmRDFTpJQpkRnLzN02TcukZVcLbXvbajZuxDAMWna00LSlickrk0xenSQ7kWXgjQE6D3fSvGNpsyDV8mVcj09yOUavJMhdkPbXyI5mdjzSTa8ToMuxN37b73zKeUicg/SgfGw60H4YAlq5qpRaHA0CVUPq7JSxfFeuwKlT0NIis25swyJqBxjJu/i+j2EYs1WBj/KHV/9u7vszboHvDbzN8YnLfLH7MAfivVjGvQ/ATcMkZDnMFHMkyzna7/4Du2uXJD+ZjLzds2fp/xgnDFtfhOmrMH1Z5nzcehOadkDbQbDqv8Ku86FOBt4cIHkrSevu1nUbNl9v8nkJrWBlS0KUCIdlQ/jOnTIXNJmU7ZkDA/Kr1tIiLa+b5TlAPg8ffSQVpyCB6OHD986B9MoeY5+OEZ6Y4dG9YIYCFJwYE5MwmoWmbU3YQYe0aZD2DOysgRM0KYUNArtMtjom+/Yb7N//4Nc27JCNHbKJdlZ7j33fp5yrBoTFTBHfWzjgyYzK4qGBNwfofqR71eeAbUblfJnpgWlmBmb4/7P3X0F2rGt6Jvb86Zf35QveY3t7XJ/DdmySrRbZQwZJBSlNaCaoUHBmdKULXelCd4rQjEYRGmrECAZnpkekKJJDDptstuPp08dte862wIZ35auWd+kzdfGvckAVUAAKQAHIJyIjl1+5XK4/3//73jdwZRutEILsRJbikSLpavrpbUsU0g9dBoGDHfh83LrJzxvXuDFYva/0dzRKcV7JoWkGegzmwEEZ2nTmlqlMj4MisIKIsUiHbBa110dENqxdwo9DJoTBYSNPVmttPmgqRapQYDafZzoI6Dh9WnaXltPFcYd4QYQeRoggIBaCVKVGamySaHyM/Kki1liK1pd1/L4Pn/d5Z3Kc704eZT7d5cPmdT7vzBHu4D285HT4L6/8IX9x/BV+fewspqpjKBoFPUXDk6LkhFV89gLTPgmBcRTjDzfFPq/vbZxeD/7YilCk+FY+WUYzD8bhiaIpVM9UKRwqsPzFMsP6kJWvVugv9xl/ffyl74B40ix4Pl/aNv2rTYLrbcY0jSOna5x8ZXzHdvuXgjiSxwutqzIcBCB3CCpnZVBIQkJCwh45GP+0CQmPwOnT0i+w3ZbiwHvvyQo+SzXQhIoT+aRGf4qnsuOczk1wube87TGuD1a5fmOVrGbyVvEI75SOcDhd2TYQt1SdZjyg5zn3CoGaBmfPSq/AK1dkCdOj9C4qKpRPQW4WGhdgsATdW3Kmr3JW/skf4EGPVbDIT+fpLnRZu7jG7Ldnn/UmPRNu3pRWLZVK4mm3n1Qq8P3vSwHw0iUpCH72mbxOVWVS8cmTz3dr9G5EkWz/7XTkfs7zZAjAm2/KSsC7GTaGLH++jD+UB9qlYyWqZ6ooqoLv+3TUHr/2axk6HZ21NbkPdRx530xG7sIOH368jAAhBHpaR0/rsMM27oRv+yz9cgm7abP0yyWGa0PGXhl7qi2BLwqDtQHtW20GKwPiUXKLZmoUDhcoHi6iWU9v6BfHMcPQYxC4tLwBd+wGv7/4BVcHK/e9nxbDX+1l+Ev9FIKIAAdfxPgCnEBltadgZkqo5QpmuQb5HAhB7Drot+fRFxapxIKpbA0jnZF+go4jzUi3RJYrQGm0eJFCOzLohA5+HINQ8WPori4S1tcofWMQHj5EfOI41e9M0L3Spn+ry3BpwHBpQE5T+J3aaf7K2Hm+1pb5qHWDRae97XVFxPzhylf8uH6ZX62d4fu10+T1FD3f5vqgjiJUxszcsxMDh0MZ+f2QXhOhF+J0HNyOrAJ22g7+0N/4/u2EqqvoGR0ja2BkDfIz+QMrrOlpnZlvzdC+1ab+TZ3B2oBbP7rF2CtjFGafbbLyi0gQx3xtO8z5PvY3dcw7fc5aFlPnxyifeImj6AfLUL8Awaiy2yxB7VUwk+9gQkLCw5MIgQnPLYoiD4Z/9CNYWZEHtNWqIKdamKpB33c3hEAhBP/bw9/jH9/6KZf7y/c8Vj9w+XH9Mj+uX6Zm5Hi7dIR3ykcYM/OoQkFVBG1/eM/9AJiZkQpQpyNVitdee/QXpadg4h0Y1qXnh9eDtS8324VTBzcNrHqmSm+px7A+ZLA6IDP2bNIGnxVhKIUqSKoBnwRCyMrAqSnpH9hsyp9cGMqW4YUF2Z1/7Nh2A/04lgW7pikFtINIFMkJjeFQLoPB5ul1kW6dfB7efVe2BG97jDCifqlO64asfNLTOhNvTJCu3Fv1ZVnyGH9mRp7v9WRic7n8ZMNt7oee0pn9ziyNKw2aV5t05jrYTZupd6Yw80mP/YOI45jO7Q6tG62NlFWAdCVN8UiR7ET2qfsv+lHIIJBhW8tOm5v9NX5/6Qvq/s4ttABGBO/ZJn9hmGJcy9A5M4sf+PjOEDcOcHMZRK5IJ32L99//HpVUnoxmbhfOJs9uRlffLaj5vpxJWE/UUVW5Y9B1DF1nbLSsX+bYA27duUJz8RZet4d++wbx0hz+7AxRNY9WyeKuubDqozghw6UBLMEpJc2rtXeoV13+jf01805r22YMQ49/t/wlf16/zH98+LscTdeYt1tc7a8QxzEFY+/t2qpQMJR9Gs53u3Kdze66MwicQIp9HQenLcW/nSr8QLb5boh9GWPbadV4voIchBCUjpbIjGVY/mwZu2Wz/PmyrA58bfzAVDE+73TDkE+HNv0wxPm6Tm3FZtIyGH91nNLR0rPevGeD14f612CvyfOqJduAcw/pTZ6QkJCwheRfK+G5JpuV4sDNm3Dhgqwa0lWVvGax6nWAzRnttGby94//Gl925vhXi7+k6Q12fMw1r8cfrnzFH658xeF0hW+Vj3M0XaUb2HhhgHF30rAQcP48/PzncOeO3KDHLQdLVyH1A1kV2LwMXlcmC2enoXz2QKYL62md0tESzetN1i6uka6ln32L01NkcVEeY657tiU8GQxDFuGCPNZfTxleWtpcslnp0djryYRxf3SMqmny87l7yWTkejcRbDCA+Xn5OKnU9sU0H69Yt9mU1Y3DXeYZQGoV6bS0RDhz5t40Z6ftsPTZEl5fCkCFQwXGzu+9mi6XOxjVlEIIqqerpKtpln65hDfwuP0T6cn10h4A7oEoiFj6bIn+shTYFE2hMFugcLiAmXv6IurWKsCG22fF7XJjsMa/WfoMN7o36VeL4Yyr85ZtcMYzCeOQ4fQENw/PECsKURxjqWOUjAzHzDxZNP7syzmmUiX03dT93X6Uui5LjCt7m1SzLIuTxfeZP3GS+flrRJevotg24upVNOQg2shmcGoFQqsIToq4HhDbEc6KTXYF/rZylg9KC/zcuEMstlfI9QOXf3D9z/grtVf4C+NnWXTaXBusUnHTqCsrKJ0O8UisjDUNNI1Y00EfndY1hKIynSqR1czNykfXBcchtm1i20EI9vZ/vC4EFouEXih9Prd4gHo9j9APd7yrkTEwCyZWwcIsmJg586lWnz4tjIzB7HdnaV5r0rjSoL/cx27ajL82Tm5S7kjjKCZwAgI3IHACQje853zoh6SraRmGYr08lc9xHOPGMXYUYY/WThQzjCLsOKIXRoRRTPjVGseaHnnTYPz18Zez8jL0oXUFOjeBGIQChWNQOgn7Jf4nJCS8tCR7kYTnnlOn5EF6twtzczA1o5LWDAIn3vAJXEcIwevFQ5zNT/Fh4zqftG5ye9jY9bFvDxvcHjb4Vvk43ykfpxfYVNQdjpgrFVmOtLQknfzff//xX5gQUDgqxb/mJejelq3Cg2U5CCgel4OCA0T5ZJnOnQ5uz6U7332pBm7rtkqTkwe6i/uFQgiZMvzOO1L0u35dCrL9vszvWUdVZeVgEMj9xPqx7lY0TfqOHj8uBcEwhOVlWeXZ2H0XgaLICru7BcKty90efiAf//Jluc0gBc58fmehcrfQmTiKaVyVFXRxLBN9J16feO6rcdOVNEd+cERW26z0Wf16lWF9yMTrE89dFdGTJnAC5j+ax+26CEVQO1ujcKjwzFqqvShgELh0A4dlu03Pd7jUXeQPVr+6xwswHQn+TifLG1EW/7VX6WUt6v6QlG5RG9lwCAEFPU3JyGCN/HJ9f+fqsyeFKhQOZ6pMnigSHn0Dcfs2rK4huh1wXVw/orXYoRWu4EZSjNd8Fa0TQScgtmN+W1F5s2Dwp8cCLtW2C2kxMf9u7Su+uXKBd7slxv00weoiWuDJ6OOR17FQhDy//tFGEEUxPjEdYTAWp0iHClEYE0cyATyKpFehEAJFU1ANFVVXUXRFro3RWlXwHZ/ADvBtn0G7gHvn2o7vhxACPaNjFa1N0S9vPrNgj2eBEILKyQrZ8SxLny3hdl0WP13EyBiEXrirWHo3nTsdOnc6WBWLoHuvSP684kYR3VAKe8Mowo7WhT8p+t3roLlJHMWkvqoz1QrQNY3JtybJTR2AmaqnzWAF1r6AcBS4lR6H6nnQn+//94SEhINDIgQmPPcYhhQDL1yQnblTUypp1cBQFNreAFPVEULBUrQNUdBQNL5fO833a6dZdbv8onWLT5u3WPN6Oz7HL1o3ebd0hI7vUDF3GZCcPSuVg9XV9T7l/XmBqgG112R4SP1rcJpSGLQbMPn+gVKdVF2lfLLM2sU16pfq5KZyKOrBEiufFP1Rt1s2CWx7JuRy8MYbsjh3cVH+DHM5WZ1ZLG567W1tu926BIHcf8zNSV1/aWmzkhBgbEwKdev2YrYtC2+iaPMxdkPX5X0LBSkarq1JcXF0jM7srNzuh2ldtps2y18sb1QB5qfzjL069sIcjKuGyvR707Rutli7uEZ/uc+t9i0m35rcsd35ZcRpOyx8skDgBGimxtS7U08tAXgn+oHDIHCp95p0r1xE7/b4RO/wY+ve6vtZT+U/aecoZkv0X38FV9doewMyRopX8tPkjYP3GRuqBqoGJ0/LBcBxMNfWyK+uMrmyRMcd0gxt+sLFrsZoNQPTV7DcmHN+zJk5lTvLAb8/7fNNebs0eqMUcaPUIOvWmc1CydHIiRwlV6U8FJQHMZYfIoIAJQwQo8VWYjpKD0/1GFMypFSL2EwT6waRbhDrxu6ThsFoWUeHOK0T5GvybFrHzMvqPiNnbKSHP6028ziOCeIIP5LCmqXqTzwk4u4J5Pth5k0O/8phaWlwrbmtLV8oAs2UYUqqqW4EK2mmPC+EoHOnQ2+px2BlwODSgDs/vcPY6TGyk9ldtyGOZbb2QQ3LmPc8vrQd7ieFCsASgpSikFJGa6FgRjHdXy5DJ0BoClPvTJEdfwkHVe0b0i8cpPBXfQXSY892mxISEl44EiEw4YXgyBG4dUse5F+/DpPHTFKqScMboAqFOIaymaG4w8HFmJnnL0+8xl8af5U7wwaftG7xy/Yt+oG7cRs/jlh1ukyYxd03IpORLvu3bsmqwF/5lf19kWYBpr8LvQU5S2ivydSw8qn9fZ7HpHS0RPtWG3/o07rRonLy4Poa7ieJEHgw0HX5Mzx8ePvlqio/m90+n4UFuHhR7kMGI90ilYJDh6RQl9pBX4ljKQZuFQfvXnxfLo3GvZWFmYxM/Z2Y2PvrC/2Q+jd12rfbgAyBGHtl7IWtmCgdLZGupFn8xSJe32P+g3nKJ8tUTlVeKuuBu+kt9Vj+bJkojDBzJtPvTctwlmeEE/p0fZv5pVuIzz8j54X846rDReve6r13lRJ/rXyc4YTKnVIOYpfItckbaSkCHkDri12xLLmDmJ3FiGNqYUgtiug5A+pOl9VhizXfIQ4DpowcZqxwGPj7ccyfDG7x+71r91RK9k3BNxMAMbC9fDmNTkmkGaPEW/osR/UyhipI49OI+ohMgcO5CrVUHkVT5KIqREEkW1PvblcdnY78CD2jbxf8csYzmcgLohA/DgmiEC8KcCIfJ/RxgoC8YTFpFdGU/Z/wCOKYr2yHBd/HEIK8qpBTVPKqQl5VySoK6g77HKEIqmeq5Gfz+EN/Q/Dby6RMZiyDN/BYu7wGvwS37bL4i0VptXKsRGG2gFAFnTCiEQY0g5BGGBLEMSVVpaKpVDWNkqruuG1PkyiOueA43PLkbz6jKGTvEvrWT1ujKtetrIfN4QQoqsL0e9NPNdn8QBBHcsK/OzKczh2SYSAHrPsnISHhxSARAhNeCBRFFuR9+qkUAmcPWRzL1LCtIlEc0wmGLDttcpqFuosRmBCCw5kqhzNVfnf6Lf5vl/+QhS0G3/N2iyPZGk7ob7Qo3cN6n3K7LcuSpqb2/8XmpoEYVj+T3iFWWXoKHhDWB8VLv1yiea1J4VDhhTfRXg+ihMdLW014dkxPy+rBGzfkZzk1JYt673dsJcRm++9uBIGsFux05GLbMpRjbOzhffl6Sz1Wv14lcGQJT+FQgdq52gtTBbgb61U3q1+v0pnr0LjSwGk5TL83/dQDMA4CjasN6pfqgBQSpt6eejatwHEM164RDwbYpkJr2Ea/8g2xofNfTtosq/e2Ov6Vidf49dpZOoHD0Lc5nh1DEyoCQdlIk9Wtp/869gshNnwAcoZBLl9iNpplxe1ye1jntmcznS5ijULMfoNxZnuH+B9u/5xe4NzvkTcY4jOMOyzQ4TNvgRP6GL9Ve4WT2QkyYZ5lp8NtrQu6StXMExMTEiIMgW5KD7+nKaDHcYwfh/dNDwYpefpxiBcGuCPhbxB4dAMHN/JGjxNheip24DObLmOoGuo+CSTtIOSXts1gVKbtxjFrQcjalro2AaQVRQqDikputE4rUtQyMjIE5WEI45gwpWGeqxDfKuAfy9Oc6+G2h1z9xQDviwXi8xXEDnYPzTCkGYZcdT0UoKiqVLcIg0+zYtCJIj4d2rRC+X6dMg1OmXv7rjkdh9WvV7GbchClp3Um35p8ptXNz4TQh5VPwZb7dirnoZgkzyUkJDw5Xuyj84SXislJeYDdbMLlS4I339wM7FhxurT9IS1/QHW31t4tqELhdG5imxB4x27ihQH9wNldCDRNaTJ2+bLsM7Qe4qDmQYrCVnIzcrDQm4PVX8LMD0A7OMmauakcrestnI5D40qD8Vdf7PSM9QoyXd/dzy3h4KNpUsvf78fM5+UyO/toj+HbPqtfr26EQRgZaZ7+MrXIKpoiU5BraVa+XGGwNmD5i2Um35x81pv21IijmJUvV+jMSUPS0tEStfO1Z1cZefs2XLqES4Qdu7h2m7oJ/7DWYyC2NwbqQuXvHPoWb5WO0A8c+r7NmJnjaKZ2YFsc9wNNUZhOFbEUjav9FRaG7W1i4OncJP/ns3+Vz9q3+aB5jZuD+kM9/rXBKteu/5CsZnIuN8XhdJUwbjJvNzmTmyQ9GqsoQqAKFV1RMISGoeqoQqCgoAiBIgSC/fscYmL8KMQJfYahhxv6xPfUPm7HC0N6oYMTeoTEqEKQVk2KRgFdqMRA3e1ya7jGMPIo6mksRZPjsR2+Q7pQSanGfb9fcRxzw/O45LhEQEoI3kinUIHeyOeuG4b0oggvjhlEEYMoYmlLP7UK5FSVnKJg7TIxEcTgxfIxvDjGi+R6/VcSBAFXsinyM2nU2SzeQh/vZptw6CN+uULufI3JoyUqmkpF1dCFoBEGNIKQehDgxPGGMHhlJAyWR7etairFJygM1oOAXwxtvDhGF4I3Uxbje/C5CL2Q+qXN6nZFVSifLFM+Xn75Jnj8ASx9DH4fhArjb0PmxR43JyQkPHsSITDhheL8efjJT2RR3tGj0hsMoGSkqRk55uwmJT2za1XgVk7nJvjh2jcb5+ftJk4Y0PXt+4uJx45t9in/7GcP9wKqVdmLODm5e4Tpxm1fBbcNXk9WBx4gv0AhBLVzNeY+mKNzu0PpWOmhZ8qfJ9aFwKQtOGE/ieOY9q029Ut1oiBCKILyiTKVk5WX70BpRH46j2qoLHy0QHe+i5ExqJx68e0HQi9k8dNFho0hQgjGXhmjeKT47DZoMICLF4mJsacnaHldPh0O+TdGi/AuwSenWfy9oz/gSKY6EocCQHAoXXmhRcCtVEz557AuBk6li6RGYqCpanyrcpxvVY6z4nS4OajT8Po0vD5Nb0Dd7dMN7Ps+fj9w+bh1k49bNzcuUxGcyk7wamGGaasEAlQhUBUVTaikVA1LGGiKgq6oiH1uPwyjkJY/oB84BHG8ITTGxPQCh5bbJxp9VwQKJSPFRKpIxciOvJ23fzcEMGYV6Pk2a06XVaeLrqjoirajiGkoCmNmgTEzR0q7d/zhRhGf2w6rgRT1JnWN11Mp9NHz3p1T7kQy0bYbhdvWIdAOQ9rh3gJC7kYBLEWQjmKqmkpa1zFOVNCPVxh+XUcs9knd6FFRDapnqhvvS0Y1ODR6WYNR63A9CKgHIW4cUw9C6kHIZVeKlevCYOURhcEojnHW035HASCDKGLe94mBvKLwbiZN+gFj1/X/tcblxkaoSn46T+1c7YVMmX4gdgOWP4HIB9WSY3kz/+D7JSQkJDwmL+EeN+FFpliEmRkpBF68CN/5jrzcUDTGzJwcWPsDanuoCjyWGUMVCmEsW0ViYNntMOXmOZa9j2mvpsGrr8qKwAe0w2wQx7J/sF6Xi2lKQfHIkZ0jRwGU0azh/E8OpF9gupomO56lv9Jn7eIa0+9OP+tNemKs+wMmbcEJ+4XbdVn5cgW7JQWAVDnF+GvjmLmk5DRTyzD+2jjLXyxTv1xHz+jkp1+MA6c4jvEHPm7Pxe26eD0Pt+fiD3ziOEYZGehnas9wZxPH8NlnEIY4lTL90yf413c+4KdB856bTllF/nfHfkB5lALsRD5932bcKlA0Xq4d5lYxcGnYYSJVIH2XQDVuFRi3Cvfc14sCWt6AhtdnwW7zk/oV2v59EoqAkJhv+kt8019CFzJEzVQ0UqqOoeiYqoYhVHla08koBhnNIK3u3NKpo5LV9t5aLASkVJ2qkafpD7jQXeBqf4W5YZNB6O54H1UojJk5xq0CE2aBCavAhJWnZubRR76AOT1FTk8RRiFOFOBFAXcXG8ZA13dou0NWzD55I0tKzxAgNhJsm2GIF8cowCspi8PG/ScrLUXBUhRqWw6d4lGVoKweDPF3GfJpAgwhRosi14o8rwmB7/t4rsO30mn0rdV0783SuNKgfrlO81qTwA6YeGPinomgjKqMhEH5GvqhFAGlOChf51oQshaEMBIGS3cJg2EcY28IfZspv+unnfuMZ2d1nVdT1gN9Cof1Iatfr+L25Odv5k3GXhl7qarbt9Gdg/qX0hvQLMLEu6A9x/YICQkJzxWJEJjwwnHmjLTnazRkiO+6EX/BSFM1ctwZNlD32AIzbRW5Y28e3CzYTU5lx7FDb2M2f0cmJ+XyMNg23LkjY0ttWwaOXLsmKwTHx2Xf892DLCMnE4UPqF9g9WyVweqA/nKf+uU65ePlZ+Nl9YRJgkIS9osojGhebdK81twQfmpnaxQOF17qcIy7KRwq4PU9mtebLH++jJ7SSZWfL08pf+jjdl3c3qbg5/U94mjnA24jazD1ztQzF4O7V7/Bba0QqyrRuZN82r7FTxtX7rnd+fwU//Hh721YaXhRgBP6CAQz6fJLUw24lYqZRTASA+02RSO954ZcXahSHDMLvF08zIXuIj9pXGHZ6Tzwvn4c0nlAVeFeSKkGM6kSY2bu/vujGAahS9e3qXt9Ov7enjuMI5acDkt3vSYFQdnIUNDTFPQUk1aBb1dOkNUsYkXHjcAZVay5kVw7QqMdunS6bQzRo6inKBlZLM1EGVU/5hSFt9Mpcuqj+awKIciqKllVZfJhYt8fgsqpClpKY+WLFboLXQInYOrdqft6w65v0xHkOLU3EgbrQbAhgK5XDLKzJrsjCmwm/Y7CP4qqet9W4DiOGawMaF5vbvgAqoZK9UyVwqGX6H8tjiH0IHQhdGC4Bp0b8rrMJIy9KSf4ExISEp4SiRCY8MKRSkmbvqtXZVXg2JjssjUUjTErR9Mf0PX3Zsw9bZW2CYG3h3W8SLYH31cIfNQNP30aTp6UEaZXr27GIF+/Lg3oikWZMJDLSdUplzvQfoFmzqR4tEjrRovGlQad2x0qpypy8PcCtTYmrcEJ+0HgBsx/OI/blUdmuckcY6+MvZztUnugeraKN/DoL/dZ+GSBQ987dOAtCJy2Q2+pR3+pjzfwdryNoin3pLeaOfNAfA+cudsMLl1k1enQO3MCz2vyrxd/ec/t/kLtDH9t6s0NwcWPQgaBS9ezmUoVKekvaQUQUDaznBaCq/0V2t6jiXMxMceyNb5bPUHTG3Cxu8il3jJNr08vcOgHzgMc+R4NO/S42l/han/lCTz67kTE1L0+da+/cdmfrl7i/anvULZ2n/y0NBNLNfBCG9vvYeFTVnLMWHnKmkVN154LQbowW0CztA17gLmfzTH9/jR6am/iY05VyakqR81NYbAZhjQC6TO4Xu1nCnGP0JdWlFHqr8DYg63OOnEU013o0rre2qgAFIqgeLhI5XTlxQu5Chxp1xO68vRO651+lcWTUD59YKx9EhISXh6e/agyIeEJcOKELK4bDKRd37FR8FbVzPG2ZuJHe/VyifmgdX3j3Irboxc4dEetTU8ERZGpAjMzsqRxeRlWV8HzYG1NLlsxTUinZHuwEQEfw+HvHZhBRe1cjVQpRf1SHW/gsfLVCq0bLSqnK+SmHlBVsJ94noxtHQwgimTUbxjK03ef39oCUyhsfoF24Zm1Bg8Gsmq0UJCVow8xSE84WARuwPwH87g9F83UGH9tnOxEoizfDyEEk29NMvfzOZy2w8LHUgw8SAeYcRzjtDbFP9/2N64TisDIGph5c7vgl9IOZJVMPDeH/eVn9AIbe6xC9tBRftG6xarb23a73554jd+aeHXjvB+F9AOXljukamY5lZs4kK/vaVI0MrxRPIwd7iwG3484jml4A24P11i020yminyvepLvVU9u3KYXuHzavMkHjWuser37PNqzQ1M0dEUKWWEU4kUP9164kcdPF37Me+PvcSI/i6kILAGWEKPTQopXAoSw8KOAVaeH77UY4pGzCkRaAUUcnP3F/cjUMhz67iHmP5L/E3d+eoeZ92cw8w8/8bsuDK63Q7tRhD4KjXlcoiCifbtN60ZrI+Fe0RSKR4qUjpYOxITGvuIPpTVPf162+D4I1ZBegJoFuUOQfXkCrxISEg4WL9jeOCFBommyRfiLL+DKFamprdu/pFSD1B7HfefyU+hCxY83hcMlp81M6m4b6SeAEJstxnEsRaxuF3o9qTz1erKF2HXl4mehcQGuzcHZLrz16/dPLY5jCGwZNuL15OAkf+gJvAxBbipHdiJL506HxpUG3sBj6ZdLtK63qJ6t7o/f1cqKrKL0/XuvCwJw9lYFeg/LyzId8+TJ7Zf7PrjSx4sGaIpKJlRgoEpBTt2yfpjB9WAgt1XXN5edfCJv3ZIlr+sG5VevylLYI0cSQfA5I3AC5n4+hzfw0CyN2e/MHvjKtoOCoipMvzvNnZ/ewet7LH6yyMy3Zva94ti3fbz+3oWKOIwZrA3oL/UJ3M2EUUVTyIxlyE3myIxlDrZVgutK79rhEDod3OtXcWKPZq2Adf51NKHwxytfb7vLuJnnN8bPb5wPRpWALW9AyUhzvjC90Sr8siODLh6tnT2rWyhCcHOwxvywuZFCvJVXCjOcz0/TDoYMfBcn8uUSri8BTuThhD526NEPXfq+ixcHOzzj41PQ05zPT3MiO854qkRay+ADXhTjxtANHFadLg23S9Pr0HV79Pwu9n1amqM44qPlD4m9Vb5TOcGRdHVXkVlXNKbTJYaBy4rbpePbuJHP8ezzk85q5k0Ofe8QCx8tSDHwZ3f2xTPU3IcxQ+AGtG+2ad9qb4SAaJZG6WiJwuHCgZqg2Re8/kgAXGCj0s/Ig5aSIp9qbq7XhT/VgH0O5UlISEh4VBIhMOGFZXYWbt6U2tnVqzJR+GFJqSaH0mWuDzar8ObtFufz0wwDl/TTasEVQrYFr8cgrxMEUhRcFwZvK3DnC/j6I1juwDvfk5VigTMS/Lqbwp/Xg/iuyki/D5VzT+YlKILikSL5mTytGy2a15s4HYf5D+dJV9PUztawio9gkhzHcPmy/JAfRCYj26lVdXO5W7RTlE0hLQzhxg0YDhGffcb4L36BiGMpzI2qBr0elC/Jwkz1p7s8r6pCpSK9Hms12Qa+/hy2LUXeel2KmcMdDOCF2C4MRpH8YgOUSlI4tG24cEG2lb/3ntyghAOPb/vMfzCPN/DQUzoz355JRMCHRLM0pt+b5s7P7jBsDFn5coWJNyb25bG9vkfjaoPeQo94r+FPd6HqKplxKf6la2kU9YAdCA6HcsJjXfQbDOT+ZEsKakyMLSKatTL20SlKusG/Wvgl3WD7BMvvTr+FOjrQDdYrAb0BRT3F+fz0/ltqvKSoQuFQuoKKwq3hGsF9uhxyqkVO3ft/axhHhHFEEEfEyLTfgJi657LgdFlxewxDFxAoQpELAoFAVQT6qAovpxpUjRQlPcWkVWTCeoAfnJmFTBaYGm3HukDoseR0aPsDgsDhcm+RK/3ljbvFwEfNG3zUvMG4mefVkQB6JFPd+C5uJa2ZHFYrLNhtlpwOh9LVjSCS5wE9pTP73VnZJlwfsvDRAuOvjVM49IS6VB6AN/BoXW/Rmets+JsaWYPy8TL5mfwLZQMDyEFf6wr0FzcvS4/JFt9U+dltV0JCQsJDkgiBCS8sQsC5c/Dhh1IQPHLk4Vs3dUXheGZ8mxB4Z9jEjwK6vvP0hMDd0LTtAuHZs3ChAhc+huZV+OEczFbgyDjYLtxehM4AdA1MXYpFmSKkcxB1YHhBiovjrz2xTVY0hcqpCsUjRRpXG7RvtRnWh9z+yW1yUzmqZ6p7E0IcB5pN2QO+3i595AhMTd17WyGkAPgoZt6HD0uPxm++keLf+gKg6wwVk8CCbC4Ec0ubcbSlRSQMZXv36urmZevbcncFo6JIoTAI5HXrrcqeJ5ettzt7Fo4eldfPz8ttbLfhpz+F999PTAsPOP7QZ+6DOfyhj57Wmf3O7J49nxK2Y+ZNpt6eYuHjBTpzHfSMTuVk5ZEfz+26UgBc3GyrNLLGQx3UWkVLin/V9ME8GO73pbXA/PzOCfdCyKrydBo3ZTLImazlVbq+wz+58kfM29tTgs/mJjmXl+nwYRwxCFza3oCcbnE+P01GTyYn9hNFCGYzZabSRaJHFKl3Io5jnNDntjfktuvQCiLsKAIDJoxxJoCICDtw0fAxiMkqUFI1irpBSjHQFPWeNtMgjna0SAMQSHFzq1CoCkFaQNowmTDGNi7/tbHT/PP5T/h549o9j7PidllZvcifrl4kq5l8r3KKX6mdIndXEqsiFHKaSdsb0vEGVK3nK3Vc1VVm3p9h+YtluvNdlr9Yxrd9qqefXlicb/vUv6nTXehuXJYqpSifKJMZz7x47f9uRwqAg00RmsyEFACt4jPbrISEhIRHJRECE15oajVZhLWyIrso33334e6vCIVT2XH+eHWz/anlD+j5Lk1vQM3K7Tjj/Ew5+33ICykK3VqE631YrYMTjdoTShCnIEgBFngCWjEMbOheAr6E/M9h7JQUCvN5+SZWKrKybZ9QDZWx82OUjpaoX67Tne/SW5Q+WqVjJWrnaps3jmNZAddsQqsl1/aWdiFVhddfh+npfdu+DRQFTp4knp1lzXWJf+M3NivzVJXGRWhkIH8UeGXL/eJ403/QtjeFwFZLXrYuAK6LlMWifJ+r1e2twGEob7t1CQJZCZhObz7GoUPyM/roI1nRsy4Glp5CG3vCQ+MNPOY/mMe3fYyMwex3Zl8876SnTGYsw9grY6x8tUL9Uh1/4GPkDIyMgZ7RMTIPFvKcjkPjSoP+8mYoQXYiS+Vk5dEqlg8iYSj/H27e3LysWpX7oHR6cxlVLgdRyMC3WRs2+POlz/iweeOeh1QQ/LXpt+XDj0TAljcgo5m8kp8mq78g790BRBUK6j5pLnEcsxwGXHFDupEOmk5BgwKQURRKqkpRVSmpKjlFYIcevcCh49s0vQHDwKUb2SAEhqIi9pyJDJaqUzTSDxxTqULhb828R9XI8u+WvyTcxZetH7j84cpX/IfVi7xXPsqv1s4ytkXws1SDMB7Q9IbPnRAIssti8s1J9JRO42pD2q70PMonyk90XxVHMc3rTZpXm0ShfO+z41nKJ8rPXXL7PcSR9PzzB6OlL9deXyb9rpOdkgKg+fx9bxISEhLWSY46El54zp2T+svysuy+rD7EhKlAcDhdxhAq3pY22jW/R8lpo43acyztAFXxKCpMvA/ZaZhpweVb0qMkq8gI5UOH5IGg68qquvV1JiMFqOZ16C5AGEN+Roput25Jsa1alY8xNibPO46sUtM0WTlimg/tT6endSbfnKR8vMzaN2sMVgc0rzfRDIWSaG+KZ+FdrU9CSJGyVJKVgLncPr2Bu6CqRIYhX+eWysJdE4OF2Gw/1nW5rSdOyOt8X753cSzveL/3bP0x7uf3uE4mA9/9Lnz8sawM/PBD2SZcefTKqIT9x+t7zH0wR+AEGFmD2W8nIuB+UTxSlK1qN2Sr2t3oaX2bMGhk5enQDWlcbTBYHWzcNjeVo3Ky8khm/AeWVgs++2xzxzU+DqdO3Ws7McKPQrq+zYrd4Z/Pf8pnnds73u53pt5g0ipsiIBNb4A1EgFz+nMuDrwExHHMoh9w1XXpjarZNeCQYVDTNEqair5DhVdWscjqFpOpIlEU0Q9dur5Nxx/SC9w9P38UR/R8h17gMGbmSKnGfSvKhBD8xvh53i0f5aPmDT5sXN+WKLwVPw75WeMaP29c49XCDL82do5jmRq6omKqGmtej+PRGOpz6q1bPVNFS2msfrVKb6lHb6mHmTcpHCqQn8nvqzdff7nP6oVV/KGcyEyVU4y9MoZVeM6E/jgGpyntctZFP68vfbN3zdsWUgAsnQTjCY83ExISEp4CyZFHwgtPNiu7O2/dkhZq3//+3rMbFCEwVJ3pVImbw/rG5Q23j5Gf5tZwjWHkMWZupt+mFIO0ZmAoz/DnpafkYKUEjB2DpSVpmrjLwd42mtdg4TPwfDnbGZVkSaXjyPXKygOeW5ei1bowePd6vdLkLsy8ycz7M7RutKh/coP+v/iEzOEURtbYfNxSSS7lsnwtO4VoPGUeKTF4vaLwSWCa8J3vwCefyJbpjz6SYuDDKOAJTwy35zL/wTyBG2DmTGa+PYNmPvvv8YtE7VyNdCWN03HwBz7ewMPre0RBhD/05UHs2s73FUKQm5YC4Ma+50VheRk+/RTimMgy8V57hXh9v7BLeu0wcFm2u/zenZ/xRXf+nuvHzTx/feYdzuQmiTYqAYdYqs4r+WnyRvpJvqKEfWDe87jiegxGAqAuBEcNnaOGgfEQ4piiKOSVFHk9xQwP55UWxTGLdpvbwwZLdoe8YVHSM2h3effFccww9AiikKxuUdDT/MXxV/iNsfPcGta50FngQneBRad9z3PEwJedeb7szHMkXeXXx84xkyrS813awZCK8fxaaRQPF7EKFq0bLXpLPdyuy+rXq6xdXCM3maNwqECqknpgu64T+gwCl6xmYm4J9fH6HqtfrzJYkxMImqVRO1cjP/2cVcTFMQyWZIvvbmnaQgU9A0YWtMzmaT0LSdBRQkLCC0Ry9JHwUnD6tMxQ6HalHdLs7N7upwiBJhSmU8VtQuCNwRp/c/Y9Op7Nst2h5W1WkeiKRtXIUNDT5PUUlqo/2/bhavXhRKDyCVmh1rgAdKE0Aa/9pnzzVlelENhqyQGVaco45iCQlYXrLa++L8NLdiOblVWFhYKsKHQc+RhAKYqIli5gDwY0bgeM/UffQ50cl/c5YJ4zUXSfisBniarKPvhPP5Wf2UcfyejsnVqPE54aw/qQxV8sEnohZt5k9tuzqMbzY1L/vCCEIDuRJTux/UcZuME2YXD9tD/wiaOY/Gye8onyixnWEkVyJiyOCScm6J0/RSf2cQaNnW8exzS8Pp+0bvJh8wbdu5JbBYLfmXyd98rHiOOYjjckBnqBja4onM9NU0pEwOeCRhAyiCJ0IThuGBwxjR2r/54kihDMpEuUjDQ3B2ssOx0GvkvVypFRzQ0Byw49+oGsOuyHLpNWEUUIFCE4lqlxLFPjd6beYNFu82dr3/Bp69aOrcO3hnX+0a0fM2EW+Evjr9ByB8+1EAjSk3TyrUnG/DG68106dzq4XZfuQpfuQhc9rVM4VMAqWiiagqIqcj1afGT175zdJK9ZnMxNEPohjSsN2jfbxHGMUATl42XKJ8oHO/H8buJYpvu2rsp2XwBFg1RVCn16drTOyHTfhISEhJeA5Ggw4aXAMODkSekTeOmS1J/ye5jIlN47CtPW9tntJafNMPAoGCmymoE3SuyLiekHLreHdQxFI6+nKelpSkaGtCqrBJ8LA+XiMbluXJAzpwgon9psbw1DKRZufS1xLAXAu1uO19frp4fDzaTj3Z7+cB5Hz9ObPE7USTF96mC2Ydi2fNl77dx9qqyLgb/4hawEunNHLooiW4XHxqQw+LAJOgkPjd20qV+uM6zLRGiraDHzrZl9bdlKeDCaqaGZ2j0+VnEcQ8zBDPTYL27dguGQ0DLpvXqGZiAP+N0woOMPaXgD6l6fpten4Q5oeH1CdvZeUxD8nUPf4nRuko5v40UBysgLzlJ1zuenKJvJfuV54YRpklUVDhsG2jMen2Q0k3P5aSpGltvDBit2l6xuUjaysu089Bj4DpNWkYbXo+72qG3pyFhnKlXk7xz6Nr898To/rl/mZ/Wr2JF/z/Mtux3+1eIvKBkZjmVqKM9pe/BWVF2ldLRE6WgJp+PQud2hu9DFH/rUL9V3vE9IRF94tCObetgna1ioOZvIDgk9Ob7NTmSpnas9XxMlcQS9eSkABvL/F0WHwjEoHE0q/BISEl5qEiEw4aXh6FG4fVtWcP35n0urvNOn7y/gKAg0RWHKKqAiCEfeITFwc7DG+cI0qqKS2tK+ktZManGOfuDS9oY03B5pzaSkZyjoKUp6mrRmHnxBcJsYeFmeLp+S651CQ4SQiqth3N+vz/elWePKihQF19uGNW1DWFTzeSqpIoOf3qG/3Kd1o0Xp2MELvdjaFnwgP05FgXfe2Xy/V1flD2BtTS4XLsiNHx+HyUnZcp2wbzhth/rl+obvnFAEhUMFqmeqiQh4gBBC8BCZBk8UPwrxooB4V5+qR3nQAK5eAhHSOzbDB43LfNy8yaLdoukPdw1b2AkFwd899G2OZWs03D4pzeRcbnLDCsNU9CQd+DkjoyocVw/OZ6YIwWSqSFFPcWvQYNltMz9sktUtup7N0WyVI+kqtwYGt4d1VKGQUu8VpzRFoWik+V9Ovclvjr/Ch41r/GjtEi1/uO12ncDhf7jzM45lxphIPb1WV4HsOHmSNjJWwcJ6zaJ2vkZvsUdvoUfgBgRBiBP4hGFEFEUEhHS8IS23j6VoDF2bht8lr1oYWYOxV8bI1J4jcT+OoHsH2tdGvn+AakDhOBSOyGrAhISEhJecZE+Y8NKgKPDtb8uqwMVFWRy1sADHjskit526JYUQ6ELD0HRm02VuDTfbqK4PVjlf2DmlVghBTrfI6RZ+FNDxbObtFstOm7ye4mR2guLz0DZVPAbE0LgoxcDIg9Lpx5tF1XUpOk1O3vdmFtLra/XrVda+WSNVTh241M51IfBAtQXfjRAyPrs2SmHu9zdbvBsNKQzeuCGX8+flDyLhsXC7LvXL9Y3kWSEE+dk8lVMV9FRSgZCwO/3AYdnu4MXBvj2mdu0mXXuFf1tw+WLp5saE1sMybZX47cnXmLCKNN0B41aeU9mJJBE44YmQ0kzO5CcpuxluD+o0vSFTqSLHMmPoisqRTAUvCli0W3QY3nN/IQRFQ1q0pFSdXx07y/drp/msfZs/XP6KVXfTvqThDfi/XPqfebd4hDO5yR2rDJ8EutDI6xZZYRDtp/h/F4qqUJgtUJgtEMcx3cCh7Q/peENEHKEGEcJROUoNNRYs9lsYVo6Z7Djpavr5qZaOY+jNQfPyZsqvakHxOOQPyzC9hISEhAQgEQITXjJSKXj7bal1XLwoA3GvXpWi4OnTskrw7rGfoaioCGbTlXuEwL2gKxpVK0eVHF3PZtXtYigNCvqDjZsPBMXjcnDV/AY6N+Ugq3BMLk+4raJ0tITdsOkt9Vj8dJHDPzh8oCqpngsh8G6yWbkcOyZ9GdfWpDK+uLjhIcbx4896K59L3J5L40qD3qI8wBRCkJ/JUz75gvrOJewrXhRghx4rbocYwX40Kfr2kC9WvuJHZY/gER4wo5q8UZzl25UTVI0sw9Cn4w05nK5yMjeOnhxYJzxBhBCMWwWKepqG16diZDe+c6aqczI3TsFIEe1Q1dr0BtTdPoPApWpksTQDVSi8UzrKqewE/49rf8LaFjFwze3xBytf8QcrX1E1srxemOWV/AypJzjOcaMA1RFkhIEtQhpun6KSxXyCNjKD0KXn29wZNvDDEFUIhBCUszlyukUYR2Qsj4ESYZVTz48IOFiGxjebHoBaCoonIH8InqVPd0JCQsIBJRECE15KSiX47ndlmO4338iiqC+/lEVR587JTsl11FHrxkxqe2vqnWETLwoeqq0jp1u4UUDd7dLw+lTNg+l9t04cyxlqUToBRg6al8DrSt/Azk0pEhaOPtE2i/HXx2X659Bn+fNlpt/duQrzWbAeFPLc2uxp2mZ1ZjYLV65IhdxxYGpKekLu1AaesA1v4NG43KC70N24LD8tKwBfuOTZhCeGFwX0A5cwjplNlx5ZCPCigI+bN7jQXeBKdwm/8OBKo4xqMmblGTNzjBm50ek82ZGNRQwMQo+uZ3MkU+FkbuLZhmAlvFSYqs5U6l57EEvVOZSu7HifmVSZebvFnN1kwW5TMjIUjBSqUMjrKf6z47/Of331j2n791YT1r0+/2HtG35Uv0zNzG14PZf0DCVDni6P7F7uTjbeiSiO+bo7z9edBUpGmndKR6mNxn8D36XpyP+Oy70lKkGBgmFR1NOYqr7hv7kfeFFIL3CYt1vEccTMDvsZVShkVJNeYNMNbErG0xvgxHFMEEeEcUQQh4TxzvsuMdpOTSioblsKgG5bXqkaIwHwsBQA4xiV+PmYeE9ISEh4iiRCYMJLzeSkFP1u35YaSL8PH38MExOyclBRQBEKpqozYeQRiA3vpjCOuD1scDI7/oBn2UQIQcFI0Rs4LNhtKkb2wA5OnNCnHzj4cciEWUBkxiE9BoMl2Xbh96Uw2LkxGnQdeSJtF6quMvXOFHcOoF/gc1kRuBunT8sv/KVLm63CQkjV/MSJ7ep4AgBRGLH69Srdue6GaJ6bzFE5XcHMHRzPrYSDTxzHuKFP0xuQegwP2Ybb5/95/T/Q8HYPYxLAkXSVmVSZSTNP2cxiKfcK1nbgYwebAQtCxBzL1jieHUtEwIQDj6aoHMlUKetpbg7rrDpd+oFL1cySUnXKRob/7Piv8Q9v/vm2ysCthHHEstNh2enseL0AclpqmzhYMtKU9AyWqiMQtPwBP1z9hkWnvXG/f7/8Faey45zJTZLXU2QVA0cJCYhYsJssuwo5zaJkZDD3eaJ1ze3R820URWFxZFeTUU2ULfuclGbQ8ga0vMETFwKDKMSPQ/woxI8C7NAfhRf16PpD8lqKzA5JvqnQJdubw3BbUipVVOLcIaLcIdmtsuUz04TKmJVPKpgTEhIStpAIgQkvPYoig0RmZuDaNal/LC/DV1/B669L42pD0VAVlelUiXm7uXHfS92lhxICAXShUjAs1twuda+/MSt8UIjjWLaOBA4rTpeeb6OiMGblpTCUnYLMJPQXpW+gP5Aegu3rUDq5OQu7j1gFi7HzY6x8tXJg/ALXA5LhBRECQUZrp1LSPLPTkS+w2ZTqeKEAhw9DsSjDYF6AdMXHIY5jlj9bprckDyCz41kqpytYhcQvLeHh8aKAYegzDF3GrcIjPUbXt/kH13+4qwgoEHy7coxfqZzCDUNKRprZdHnPoqMmFEpGJhEBE54r8kaa89o0ZSPD7WGTJbtFYSTcjVsF/k+nf5tveotc7C5yobtAx7f3/Ngx0B1Vzt3eYh2zF670V7jSX9m8oAhcn0cVClnVJKMZaIqGHXgMAhd3S+rxepfK0UyN2VQZZY+/yWHo8U1vkUu9JYaht3G5KhRmUiXO5ac5n59i0iygKyprbo8j6epjpSl3fJur/WWu9Ve5NagzCFycyMeLAtwwwI0DvDDAi0KCKMCLg3vyyvOaxaRV5NXCDOdSJazeLaL+Is1YTs17mSnc3CyxasCWMfo6CoK2P+RIpkpGSybpEhISEiARAhMSNtB1OHtWBqd+/LH0DczlYPqwTHaL44jjmdo2IfBPVi+Q0Ux+tXZmzwdTMkgkRcd3mB82KWopdPXZ/xSDKMQbJVb2AocFu0U/sAmjmNvDOgU9hbnulSME5KalKNibl4JgYEP9a2hdk+nCudl9FQSLR4oM68MD4xe43hZsmjsHzTy3zMzIBcC24eZNuHVLCoNffikvF0IKhpa1mfq8vl4/bZqbYqGivHAtxvVLdXpLPYQimH5v+vlKVEw4cLhRQNe3EbF4pBTRXuDwD67/kDXv3somgeBMboK/PPEaBd2i6Q6pmFleKUzvmLaakPCioSkqs+kKRT3DzcEaK06XfuCQ16RX82yqzGyqzG+Onef2YI1ftO9wobvwRAM8diOMIzqBTSfYXZC0I5+rg1Wu7tGrei/PeXvY4Pawwb9f/pIpq8iv186ClWfBaT+ST2LD6/P/nfuIj5o3Hvtd7AYO3f4yl/vLTCgqv22leVdPIbITuIUTRPru4XtxHNPyB8wPmziRz5RVfGBlYEoxSGvGge3YSUhISNgPXqTD14SEfWF8XPoEXrwoFyujoGVUIgFvFA/x5/XL227/rxd/yarb5bfGX6W0xyRgQ9Eo6Cnqbo8bgzqH0xUs7emniQZRiBsF+FGIHXkMA49e4ND2hqhCBqT0fZe622Nu2OR4dmz7wEgIyM9KUbA3B80rMqlt7UspCE68C2Z+37Z3q1/g3M/nGHtljHTl2aQvv1BtwbuRSskfw4kTsn++0ZCCoOfBcCiXvSCErCY8d+6FEAQ7dzo0r8kJgYnXJxIRMOGxiOIYJ/Rp+UMy+oOrVQbDHguNBel/5nWYC/qs4t5zuylf5S+On+f01Cl0RWUQODTdITUzx/nCNNYTDntKSDho5HSLVwozlM02c8MG3R2q/8pGlt8cO8f3q6dYc7p0Q4eeb0sxyrelV6Zv48XhQz9/SU8zDDzcfUwFfxIsOm1+b+4DjqdrHH/IrheQ1cmftm5yb23f47MchfyjYY/fE0NOxRYn4zsP9GmsGFmmraJsiw4cxAN8F7OqwVSqTM3M7skDMiEhIeF5JBECExJ24PhxKfTcuQOf/VJw9G0FEcORTJW/UDvDj9Yubbv9zxvX+KBxnbP5SU5lJ6gYWSpGhoqZ3bXiomRkCOOQ28M17MhjNlXG2KEyUEGgKyq6UB95djLaYrgcxhFeFOBFAU7oMQw9OqNBbhhH6EKhoKfI6rLFMatb9EOXeadFXrdI7dZWkR6HVE0Kgu0b4PVg+VOY+va9Ucw7oAnlgdUp636B8x/M43Zd5n4+R3YiS+1c7amnsq4Lgc9tUMjDYBiybfjkSXnetuXiOLJ9eKe1t9l2RBzLqsK1NXjjDVl2+5wyrA9Z+VK2c1VOVcjP7J/QnfBiEMYRTujvuZooimMGoYcX+lTNe2cWvCjgw8Z1rvSXmes3aIUPbl2sBYL/PPsK6dnzBHFIP3BouUPGrBzn8okImPDyogjBTKpEzcjibGm3fRBeGLDsdKh7fZzQR1cUQmDgO7QDe8NTr+UPaXkDvEgKhULAhFng3fJRxowcOT3FJ62brDgdhoFHN7Dp+Db2Q2zL0+L6cI3rw7Vn9vwKYtf9qBeHMoClO7+nx8pqJu8Uj/JW6RAVY3dLniiOaHgDeoFLxy8wnSqS1aykOjAhIeGFIxECExJ24dVXZftno6Fw4QuVwlkFPwr43am3yGkWv7/0+bbbx8Rc7Eqfma2kVWMkDGapmBnGzDyvFmbIahZjVoGOZ7Nsd7BDD1O59+BMFYK0apBSDbKahaFo6IqKJpQHDkyCKGQQetihRziavY5jsEOPbiBnucM4wlB0ilqalGZsM4wGOWiumlnmB01uDuroD2pbExbkT2Atf4KwO/iKRZB9cNKvKgQzqTKVHQ6Et2IVLI786hEalxt07nToL/cZrA4oHilSOVV5au3C663BL3RF4G6kUnK5H3EMcQSdW3DnIly4Bg0f7vwCCnmoVWC8JpOJhbJ90TOj1vKDNfD2+h6Lny4SxzH56TzV09VnvUkJBwx/lMrZ9oZ0/OGeW+KCOEBVlHv899rekP/2xp9tCxp4EHnF5O+e+h5DI83Q7cnEX99NRMCEhC2Yqr5pd7IXdKiaOdrekEWnzarbJQgDamaeE9lxmfC7y39WGEe0vCHDwOVUdpyMZrJid0hrBlowQOsusvb5p1jHJ+kDPQTN1Bi2apDRDLKqRUozNirZVt0ONwZ1rvVXHroyMa+leL0ww2vFQ0xYeaIoZtntcrG7wNfdhfsGDT0qGgrjVoFJq0Bet9CEiqYo6EJFFSq6UFAVudYUlYxqkgVSzW9oOh3uxCE/D2HpIfwb76YfuPyofokf1S/xWmGW3xp/hdn0zpOSOT1F3etxe1CnF9hMp0rUzCRsJCEh4cUiEQITEnZBUeCdd+AnP4HeQOHaBYvSOxGWKfjN8fOUjDT/nzsfEsb3b30Yhh5Du8ncFm/Bf7nwKd+rnOJXx85SMFJYqkbHtxmE29u7YiCKIpajLqoQWKpBTjPJaqY8rVroqrpjm0MQhwwDj7Y/ZMXp4EayFWU9+dhSdEpGhpT6YB8UQ9GYTBXpBjZeuLdBp5+ZJNW+Sty8REdL04+lj5UX3tsSExMTxhHt7IC3SkfJ6fcPXNBMjfHXxikeLbJ2cY3B6oDWjRbduS6VUxWKR4oI5cmKSC9Fa/CjEkfbW8WzwFtH4OodWKrDWhfW5uEiUCvByUOQuqvStHsLam/I1vI4hiCQZozPSBwMvZD5j+YJ/ZBUOcXEGxPPZDsSng1xHBMRE8UxUbxzjUoUx/QDhzW3x6rbRRFizyb+AkH1ruCoRbvFf3vjR7T9vbXgKwjO5qf4S+OvAjKFWAj57zBu5Tibn3o44SMhIWEbQghKZoaSmWHGK7Ngt1h1uyzaLdKaSVFP7ygIelGIHboU9BRVM0dGUdF7CwyaN1G9PlEYoROQVQ2yhsm01wdvFSd/BC9370Rq1cxyKjtJOHYOLw42xoAb+6VYJhrHYnShQP6PIjAUFVUoKELQcPqUjDRnchOczU/yu/FbfNC4zr9d+uKe8eij8mp+ml+pniK7Q/LvbqheH6t5ARF6lDWdVOkVjpkFrg/W+KIzz43B6mP5Dn7ZmePLzhzn81P81virHMlsn9RThGDMzJNTLVbcDv3Ape3ZzKRL5JLqwISEhBeERAhMSLgPhgHvvQd/8jOdQUfj0gX41lvyundKR5lJlfnR2iV+0bq1IbTtBS8K+eHaN/y4fpnfGDvPXxw/L1N574MT+gwCl4bXZ8XpoAoFSzXJaxamqt0jBcZA0xswCBzyeprKloPMvVQT3k1KM0hpm+23cRzzWfs2n7XvMAhc/DjEj0KC0dqPQ4LQw49jwt4P9/w8JT3NkUwVSzEwFHW0aBiKiq5oo9MaNTPH8UyN8XcmGDaG1C/WcXsuixeWqd9qUj1bJTsuVToB++rzEsfPf0VgFMcPFLEfmjhGHy5D64pMkwZQLZkmrVkw875sG15dg9VVWFkBJ4ILTZgYkwKi70FnETwXgh+DOQapcVkpaFnSZ3D6wRWm+/qyopiFTxbwhz56Wmf63eknJjRHcUxMnCSzPkXiOMaPw433Ptoi+q1fF8QhYRQRxpvLTnQDh7Y3oGLk9uT3txMNt8+Hzev8+drlXVsXdaEylSoymyozky4zkyoxaRURyJTOrm/zenGWwsi3VhX3VhsmJCQ8OgUjRcFIMe2VWLbbLHtdFuwWKc2gpKex1M0OCz8K8MKQCS1ErH5OerDIuSgkMNJgZgnMCj+6k+b82b+BrmuIxgXo3IZoCGGXuPYGbBnDhFGEHfnYgez4iIk3xEBFKKijCQCBgqLI04oQCASqUDYq2+4MmyzabWIgr8sq//fLx3g1P8OP65e5OVh7pHFCDJSNDKdzk5zIjnE+N4Wl7dG+pTeP6F6FVBGMLPHEu4RaikW7TRjHvF8+TkDEN12ZftzyBvd9OCcMWHBaO153obvIhe4ip3MT/JWJ1ziaqW27PqUZHFKrtLwBd4YNuoHNdKrImJnfmORRhEj2rQkJCc8liRCYkPAAcjl46w3B3E9VFhci7hRVDh2TVXETVoG/Pfs+vzv1Np937nC1t0LD69HwBntqCwviiD9c+Yqvu/P83UPfYSpV3LiuHzgsOR00oTBu5klrJpaqUyFLHMc4kU/fd1n1Ouz2RJZqYKo6a16PmJiint4QAOM4xg59uoE8aJQ+gfJ017fpBA6DwKFkZPh2+TivFmY3BrUdf8g/vfMRF3uLOz/xY9Dyh7Tad/Z8e0vRyWgGpEEYgkNOnm/1Z8h/3MQspSidLGPkZSVlycjsy4DNcSAMZXFa+tlklTwSURxv8Yf0sSOfKI5ZcTq0vCE5zSSvp3AinzvDBnN2CyfY9PpLayYTVoEpq8i4ld/WJi6GKyidm6RDh7JqoGgWFE9A4cj29OgsUD0G54BeDy5ckN6BXQAV0EE7DMPb4LTAmYPBGhSOyfv/8pfSb/D0aek1qDzZAXgcxyx/vozdtFF1lZn3Z1CNxxCV170VHQf8TZHHi0PcKMSOfbzQZ1zPoyuKTF+uVF6waOqDRT906fpDnDAgjCOCOMIfhSi5UUgUhwRxtOG1Kg+6d0YTKpOp0kO3kPlRyFedOT5oXOdyf3nH24yHGr858wYz+XHGrfyO+7J+4NALbGpmloqZ27VVMSEhYX9YFwSn/CKLdpsVt8viqO133MpD4BK3b1DqzUnrk5EgJsw8eu4Q5GYgEnhqHUPV0VUdxt4EqwxrX8FwFZY+hIn3YCTWoUAKA4zHMyk+lZUVwkt2m2HobdtfvFU6zFulw4/82E7oU9TTnM9Pb3hO35c4huY30L4uB1eZKRh/C0bjjHEzT9Prs+b2OJSp8F75GO+Vj+1pW1acDh80rvNB8zp26N1z/eXeMld6y/yt2ff5TuXEtusUIaiYWbKayYrT4UpvmY7nbJvoqRrZB3ayJCQkJBw0kiOLhIQ9UKsKTp2Bz7+MuHZJJZWJqY1vzpKaqsb75WO8v2VQ4kchLW9Aw+tvLCtOl4vdxXvMj+ftFv/Xy39AQU+R11P0fJvWXe1gec1iwiowbhXk2swzYRWomlm6gcP8sMmqKwU/gJY34GJ3kTWvt/EYGdWkambpBy5d38bfg7fMktPhYneRSavAufwUPd/h6+4Cwx0GU88CJ/JxvE1BpW70+aK8xKudGucXqmgLi+jjKcbO15jKlJmyitsqGx+FrUEhB/04O4yjkaAR4IY+w9Bj4Lssum2+aN3hy+4ca4/oCVTQUlQ0g/HIZzz2qSoKh4w03thrTIy9hvKgNsRcDr71LVkZ2GyCrm9Zvg9uA7pXQARS8GursBbK237wgbxdrQZjY3IxH60Caxu2LZORXRdcl/b1JsPFIZphMvn2FEZ7FdZ8KeLttKwH8wghvyCFglSLG41RBaSz8VQhMS4xrohwogA79On5DkEcYBlFqtr6QZ8ixcD8HoJJNE2WMuu6XG89nXAPUSxbaO8MWwwC+dmoCFRFeldpQkFTNXShoikq6qjdN4hC/mjla35Sv4ImVE7nJjifnyanWyx15ugFzraQpp0I4pCe79Dxba70l++7Tz3hafy9Q79Canxq19v4UYgTBhDDoXQlEQETEp4iOT3FaT3FTFBiYdhi0W6ztvY1Y4MlYt+hoGlYmiWFv/whsEqbd96p8jd/GPQcrHwCXhcWfgzj70Cqsm/bbKo6p7Lj6IpK091fb8CcaXEqO7E3ETD0YeUXYI+CSYonoXx62wArrZkbHo2DwCWzW3DdDoxbBf7a9Fv81sSr/KR+mT9bvbSjFc8/m/sIS9F3FEBNVWc2XaHlDVl0Wghn8351I82RdI2KmU32uwkJCc8NiRCYkLAHVKFw5JBgvuERrcCFzzXe+bZPNr/7gZ6uqIxZ+Xtafutujz9dvciHjevbBMGYmLY/3NUPqhs4dPsOV/or259HqHsS9AAGoctg+Gi+L0tOhyWn80j3XUdDkNGsHatpuoGz55TNBxES83lhlbnCgL++coZcXaN7o4tzNJCtHVaJipl95OrAR/UHXK/IexrExHhRiBN6DEKPljfgQneBG/1V7gybLLudx363O4FNJ7C5seWytB/zN4OQ77o9plKlvQ2Kx8flcg81CI9D/Wvoz0M1hKIKrTR0XJlMvLgoF4BiUbYPK4o8gNi63umyrWvHkUJdTwrnoRcybAwZzHUwgdLREunrzR228T50u7C0tO2iWBF4poFr6TiayjD06AcOgyCCSEdTLIaRT98qUDVLcnuGQ1k1ufZ46Y0iiqh99hkik5FhL6YpxcVCQb53+yGkPmd4UcAg9BgGHlN7rORbsFv83u2fbwvw+KR1k09aN5/INn5raPK3sqcJamO4O3isruPFAX3fZszKUzKeU8+ChITnnIxmccLKk218xVL3Du0owNczTI29jqid26hw2xOpMkx/X4qBbgcWP4DqK7LSfp8wVZ0zuUnYPUj3yREFMNhiJyJUGHsDsvdOeChCMGbkaBh96m4PTTx8Zb6C4AfVM3y7fIIPGtf50do39LcIgjHwe3d+jioUXi1M3+PxKoSgbGYom5uVmMPAZcnp4EYhh6My06lyIgYmJCQ8FyRCYELCHlCEQBMKh055dIKYVkPwxS903v2Oh/GQx85VM8ffnn2f71ZO8j/e+flji2t7FQGfFHktxa+NnSWl6uiKulE5owt1lG6skrbXKLVvECgK9err+DsMhMM4puH2WHF72KFHMGrHC9fXUYQfR4Sj6raG18fexT9rnQYD/tnkRf7m0lkqK1lyp7OsOF36vsOkX2QyVSS9h7CUu1n3B8w8RFdOGEd0fZu2b+M/BTEwjCOu9le40Fng5rDOgt3aN6H1fgwjj//f/MekVJ0YmN6rGLgbqg7jb0JuGta+BGyo9WC2Cp4B3QDaNnR70G4/0lPEUYw39PD7Pu7Aww0NfDRiPQu1LMXJFJmJUVXDtqrFHZb11xpFUsTrdKSQVyjg1ar0CxkGcUDXt2n5A9zQR1c0CnqatGYQRCEdp82KanKkclw+Vr8vPRW3VBPuynploudtrj1Pbk8Uofi+3C57lL64LlQKAVNTcOrU82t8+Qh4UUDfd1AQ9xUBW96Qi90FLnQX+aa3uP/+mneRUnS+FeT4QT1m0siycuIwfbf7wOcVCGaTasCEhGdH9w5K4wIToY+SKnLDqOJnximWjj2cCLiOnoKp78LaF9BfgPpX4Lal967+eK3Bz4Q4BrsOvXkYLMH6GFZLyfZnc/fK95RmUjNztLwhS057V4uGvXA6N875/BSftG7yw7VvNi4P44h/dOvHGIrKlFViNl1mJlVmNlViwirc4zed1kwOpSssOS2u9VeJY5hNl5NAkYSEhANPIgQmJOwBTaijJDg4/vqACx9lsAeCL3+h89a3/EeyKZtNl/k/nvrL/MHyl/x47fKOgp4uVMI4emwBRxXKfQ8gU6pBXrM2WpPzmlxrQuFnjau7ipVvFw/zN2befWCLRmgV8O01hsM1Ut1bFMff3PF2E1ae83t4PVEc0/aGtANZPbn+7lzsLvDzxrVt71Ynsvmnta/5m/XzFNdKHJmssOb2uDFYpRPYTKdKVI3sQ4WJPGxFYBhHdHybuttjbtjg+qDOZ+3b1N3eg+/8iDihT8DexQpD0fCjYOO9y2oms6kyFSMLQo7dW/6AFadL4wGtxMPQ45/Pf4IpdKI4ZiZdenxvxvQYzP4FaHwjE4Wd+mhDgZwK5GCogpaV7VTrGx1F96x928NrO7hdB7dt4/VdYjTCwhjB4TJoOkIIjJxBbjJH4WT50XrAx8Y2TsZxzMAfMj9s0vB6xLEgP0qQ3PreqELBVHRZKeg7sq0qm318cS4MiQcDGo5D/K1vyffCcaRQ2elIcXBhQS5bPQmFkKdVVa63Ljtdlk4f/H75EVEc44Q+LX9IRjfuui7i1qA+MpNf2Fb99yQ5mR3nO8YE712vY9keCGi+coahCFEQlI37l+3ktRQl/TkyLk1IeFEIHCnWDVcBUFIVxmtvIKIQN/RIP44liaJKvzwjL330enNyMUuy1Tg7LSfNDjJeT4p/vXkIt0xq6RnIzsgqR/X+75EiBBNWAScKcB7TnsaPIlpen1+rncWPQ35Sv7J9c6OQW8M6t4b1jctUoTBlFZlOlSjqafK6xaRV5FimxnSqzILd5tawjqFqTFiFx9q+hISEhCdNIgQmJOwBRQgKepqcbtGPhrz+jsGnPzfotgXffKlx/o2Hr/CK4hhFCP7q1Jv8xfFXWHW7G0EdhqIxkypttBXX3R7LTkcubpdlp8Oq090mHhpCZTJVwFDkYFATCtOpMmdzE0yliiNfkzb9wCGrWeQ0i7yWIqubGHfNUmujaj6A71VP8VVnnq+783hRsCESnsqOM5uu4EXBjubLW/HCgE56mprT4ljskTUzj+VzE8Uxi3aLG4M1vCigZuYQQnAiO863yif4J3MfbBMv+4rHP659xqGlm7xrnOC1wix5PcWy06EXOEyaBSZShY1WEynGaHcFq3i4IpTJzf0IF1BSMHjAR++GPtcHa9we1rk1aHCxu8CS+3hVoPuFguBcfor3ysc4mR0jBvq+iyIEWc3cdUY77K/SXv2clSjkjlVjNfSYHzbpBPbGbepen3+19Ev+F7xGTEzN3Ke+o9IpyExLLyGnCW4LMwrQRA9SAG0ZTmIWwarI75lVAkWjfbtN40qDwNGBDBjAmFxUQyVVSmGVLLkuWija/gWRuFFAP3Bp+X2KemZX3yQhBGnVYBC49AJnb/5Ke0FVIZUiSKehWpXVi1vpdODKFVheln6Gj4plweysXB6mZPYZsL7v8kKfipFhELh805Mpkt90F/fkgzplFXmvfIzLvSVuDNYQiNFkivXAyQVFCHKjfXHJyHAmN8nU7RWMr2WzfZROYb9yDjufwnb7nM1PcPiuVMuEhIQDQG9UqRf58v+nfAYKxxBCsJPpxSNTOiH/2zrXYbgGbksujQtysiw3K9cHJcU2cGUVY39etjavo+hSvMzNbPdK3AOmqnM6N/HYm2YHHpf6S6w6Xf6jqbexQ49PW7fue58wjpizm8zZ221CDqcr/L2jP2DKKjA3bHK9v4aKsiH+ric1J+nCCQkJB4lECExI2CNp1aBsZLgxWGMiHfHKmz5ffKKzsqjg2DpjkyFjExHmHo7bozimHzjYoUdJz5BSdQ6ndxfGxkchIa+PzodxhB14LDtdVt02hqJT2pIIfDcrTheQyWbVLd5RbuTjuve21woEE6kCKdVAEYLXi7O8Xpzddps4jhmELn3feeABcxRDIV3hmPYqWXtVDphnvv/Ig1VFCKZTJQRwY7DGot1BGb30jGbyfzjxm/w313/I/JbBWizgttbm9sKn/IuFTzmSrvJ6YYbZVIVbYYNuYJNSjI3XXzLTVM0ccRwzDD1abp+AmBu9Oje6BpEIuR34LHd33sYVt8fHzZt83r6N94zbt7cynSpxNF1hJlWmtqUabf07sk4/2KUNNQ7I1b8gFXtM5qYp5Y8C4EQe/2zuk20hN7eHdf7f13/EG6VD/Nb4qxTXwy/2AzUjhabMDFbkcViA7rXBbkDoSpHQaUL7KnEcs3rFoT0vvYCEEJg5lVTRxDp0ktThU+iZJ+ePty4kN7w+UcwDxT1dUYmBru8wuY9v2X0pFODdd2Vl4NYW6yiCIJAx2UGwudx9PghkK7LjwNWrctF1KQxalgyGKRSkJ6FpyuuecOLzg/CigJ7vcKG7wL9Y/JRbg8ZG2NKDUIXCr9bO8JcnXkNXVH5t7Oxjb4/xzSX0mzIx3T80g3fmFLaIGLgDcrrFZOrhDpgTEhKeMIELja+hP/KpNQsy8fcBlbuPRboql3WRrTcnw0QGy3J5DJFtX4hCuR39eSlWru9ThSJFyuwMZMafuVhpqToTZkF2l/hD/s6hbzNpFflJ/cquXt27cXvY4L+68kf874//KpOpIgvDFjcGq2RUOa4QCFK6QUFLkdYMDEVLRMGEhIRnTiIEJiTsEV1RKegpLEWnG9iUqxlOvxJw+WuNTkvQaWlcvQj5YszYRERtIiS1S4eWE3oMAhc39HFCj9l0dU+eTmEc4YQ+buTLyi3gTG6Kqpnft268KI5oeQOW7A4zqRKGuvNuwg59BoGHE/ocy9RQ71P9ogBVI0dWOQJzP5QtIp1bUDy2630ehBCCqVQJSzVGlWgxw8BjyW6T11L858d/nf/XjR9ye7hzddPWlo9pq8iJ7Bjn8tPkNQsnClj1urTcIXkjRdPrc7E1zwWryx/f+CErtTYI+MPrj7z5T41xM8/xTI1D6QqTVnF0aUxas6gYGcyHbCfSGhdRdZM4VcabfE+2LI0o6ln+66t/jLPFuzEg4tPWLT5v3eE7lRO8Wz76SCbfuxHGIWEcE6arnBg7KgfX/kAKgnaDsLfG0udNBk25TdXjFqVZE0Vd/8HcgmYDlFf3NY1xK07ky2pAr//A1k4ATVExFJWW3yeO46frNZTLyeVRiCIZuHLnjvQ0XPcr7PV2DjpR1Z19FlMpmQZdKj0xsXC9LfifL3zKx60bD74D0kLhbG6S8/lpzuYnyWr7VK0ZxxgXL6HfngPAfeUswaFZojjC8eU+9nimdk/ldkJCwlMk9GRVm9serTsQrAtGQlarl048PYFLM+UYqngM3K4U3noLsu22e0su6223uRl4kpYB675//QXp+7fVB3mjfXnqga2/TxMhBBUzy5ibZ85pUtBT/Ob4eX5z/Dw932F+VPk3P2wxZzcfaInS9Af836/+MX/v6PeZTZdpen3s0AdigigidmIsVSevp8hpKfK6RVo1MdVEFExISHg2JKPKhISHIK+nKBpp1tweRSPD1GxEueqxuqyytqzQaQm6bUG3rXLtkkouH1ObiChXI+IYwgCcIKLjBbTtkKpWou7YLEc2eZEnDORtUpmYqdmIbE7OpAajgAw38un5DlEcUzIyzKbK1Kzcvg8iGm4PL1ph0WkxbZVQ7joY96OQYegx8B1O5iY4mqnuXawon5U+Oq3LcmD4GAfT6wO5iimrHHu+wzBwqbs9ZjMV/v7xX+f3Fz/j49bN+6b1LjhtFpw2P65f5WxukreKhzFUjWW7w5zd5MvOHA1/AGkggMdyqB5RNbJ8r3LyiaV7CgElPY2uqDhhgEBWS1aNLFUzR15P7SkhdRt2A/yuNPOe+s49wtm4ked/fejb/He3f3aP52VAxI8bV7jQW+RkdhxVCFShoAhl8zQK6pbz68v6bYp6mqOZ2rbtjuKYNbfLnN3AVDUOpysIPQN6Bl+bZOGbBVxtiDIJE2+Mk5vc8n4PV6F5UQrTiz+XVRSV8/IA6wGsJ0D7cUgcb1aRbd9uMaoG9Gl4fQRiTz5R6z6B9mjC4O4KwiiOt1WurZ+PY3lpTLx52eg2lvIU/KMUBSYn5bJeHeg4Mpik2930IvRHQnEYymWnEJT1isJSabOqsFjcJV16b/ijFO0YiIj5oHntgSLglFXkXH6K8/lpjmSq2/a1URzhhAGqENsE9Wg0YbP+3gvHhoGN8H0Ux0V4LsLzEI6H8F2E4+EGIa4A99xpwqkxCFyiOGYQOOSNFOOpxG8qIeGpETibYp/XAae93dduK2YBaq/L9bPCzIN5To6vtgZx+AM51mpdBqssBbnM5P4Jcm5HPld/cfv7o6U3qxIPcIK5oWiMp/K0ggF1r7/h65fTLc7qU5zNb6YXDwOXebvFvN1ize3R9W3u2A06/qYlih16/DfXf8jfPfRt3i4d2fZcfhTQCxzqbp8Vp4OlGhs2ElnNIqOZqEJBE8pDeVYnJCQkPCqJEJiQ8BCYik5RT7PmdHECD01RUU2YPBwyeRg8F+orCvUVjXZT0OlCtyu4fmX9pxbjKj7dIKaoVsiYZZywzarbJaf4GOgIBKwJ7twSFCohtVmPbNmlHzrEcUTVzDGTKlMxs09sFrFsZDmWCbnaX2HBaWEp9w4aB4HD4XSVw5nKw1Us5Wahe2fka3NRGmDvE2nNoGbm6fgr2IFHSjP4m7Pv8dem3+JSd4mPrl3milLHVXZu1Y2Judhb5GJvcd+2CaRuKI2lU5T0DOfyUxzPjtHz7CcarBDFMbqiMWWVqJgZ8lrq0QeYUSgFXID84R2r51Kawbulo0TEfNa+zeftuXuCbhpen0bz/jPr98NQNE5nJzieHZPhNlqKspFFEcFGhWdJTxN2A9Z+sQxejJYxmX5vGqtwl+icn4XMhDRf796W1QzDFenvlD9yz2ezLv55UYAT+tihRz9wGWxpo1YVlbRqYCraxnvtRwFNb8DYQ/gkplSdnm/Tvcsn0A19+oHDMPQ3ZL54tG1RHI2WmJCYKIrw45AwjmT4i7G3NrGtwubDsrEvWK/u26m6MI43W4l3WrpdWVHoeXK9lUoFXnlFthg/BH4U0vWHrDo9eoFNx7P572797J7b6ULlVG6C8/kpzuWnKRv3+hzGcYwbBdijz8INA8atPDndIooj+oFL17fxAo/U9VsYCw/en8SKin36OH4lC1va9AUxp7ITSTVgQsKTJnCl915vXtpL7ISelYKfWQBjtD5IIR1CQLoml+hV2aLbm5Pi4LpdRv3rUYvuNKTHt1X135cokO9L4MjH6c2Dv+W/XNHl5G52BlLlJ/P6ngAFPc2YmefmYI0oiu6Z+F4nrZmcyk1waos/Yc93+Ic3f7St8ySMI/772z+j6Q34VuU4GdVEEQJd0SgbWcpGliAK6QUODbfPqtPFVHWymklGNaTVj5GmtMN/T0JCQsJ+kowsExIeAkUISoY0+l92u1iKTki0vSJoDCbGBVUfWmsarTWVwUCgKgJNBVUJGFMVzmVL5FI6h5UCc55DK2iRMXU0VdBtqtTXBJ16zM16iGbEnD6c550TRSZzmSfeRiCEYNwqEMQRdwYNwh18s6ZTJU7kxh9+W4SA2qsw/xMpvGgpKbzsgyCmCoWamaPu9VhzexzSpFhlKBqvFWc5MV1m7bMV5rI97hy2+ao7z2C3Af8+UDGyfKt8jPfKxykZsi3HCX0GgUvbGzCZKjJmPpyg8TCst6Hsy/eldVlWF6iWrDrYAWVUoXk0U6Ogp/mdyTf5o5Wv+ah5/TFzrzfxooCvuvN81Z3fdnlGNaiaOUp6moyrk16DQpRiLJvn/OvHiTIyOXv9vVivsk2rBqL2GuQOSe9Kty0PlLp3oPoqoVXEj8IN8U9Wwrq0giFOINv0W96AFa9Dw+1jKDpVM8eYmaOop1CEggAMRd9WNRbGEV3foRvYGyFBHd+mG9hoQuHd0lGEEHT8IVOp4oZXZS9wWHY6NLz+tv3OeguxEAKBQMTyd6wqgjCKaXp9PN/f8bcMUkh0Ix83DHAin/g+KeP3I6NZ5PUHGBsKsSkU7kYcS6/CbhdcF4ZDmWjcaMCPfwxHj8KZM7K9+AFIL0CbZbvLsttBEQr/YvHTbS3sAL8z+QY/qJ3eVXQLohA/DmVFdOCNqvXSFDSLVadLRIRAfmaa6/P6lQW0jgNGmTiTAdMgNq3R2gTLIjYMYkue3khq3oIqlI2K54SEhCdA4ED7mpwM2tjvCenzt030y8PzJMgrmqzIy83I19hfkOLdNj9BTVYIZqcAIW8XurK6b130W1/v5HUsFDmZlp0+WCElD4GuqOQ0C0NRsUOPjLL3LpWcbvFfnPgN/vtbP7tnTPL7S5/z+0ufoyComlmOpGscy9Y4mq4ybhUoGRlKRoYgihgEzsg+ZEgYhxT0NGfzkxSSBPiEhIQnyHP0j5aQcDBIqwYVPStbvwSYQkMVAlm7AXEUExGj6RETUyHjUyHRqG0PpGnw6dwkk6n1KjuDE36F670QO/QI4ojyhMu0q9FY1OgsZchFecR8ii+WBGtTcOTIwxXECPHwVluKEMymy0ylijtfj3h07zKzAOXT0LwkB+B+Xxps78MgO62ZVM0cbW9I3e2hb/Gji0vgWTHVocVxMcVfOvUqtwZ1KSx15h4Y6pEJVcaDIxQHM7x+Ik25srtYogmFjLqZvNvxpJeQH0e0vQHTqRJn81MP3577LHDa0B61UNZeu28FREo1GDPztLwBURzx2xOv8WbhEH+w8gW3h81d7/e4DEKPwbDBbUYz81sL0S5+gADymkVGs+j6Dv1RG5OKQtFIUdTSFI00RWKyXg/BKvHaNRwtTVdN0QscuoGDE/pyifwHfl8EMn05p1lo6wJkHNENbAaBe19x9Of1a/zm+HnSmknd7QECO/SYGzZZsJsU9DRlM0NaNVGFQLnPAVgcxzS9AYtOG0eENLw+erT9MwzjiEHo0fWHtH2b6BEDbizV5GxuguLjVjMIIduCS1uqGE+fhgsXYGkJbtyQfoRvvrn9NltY9wEchi63Bw1uDleZH7b5aePqPRMArxdm+Y2xc/fs07aKf04oU4bDKMTSdE7lJphJl/GjEKW/zIrdRVUEqXafV68uU4hVSBfkNj5GS3NCQsITwB/K8UdvblMANEtQOgmp6t4r5Z4HNAuKx+Xi9aSXYH8eAlu+/t7c3h5H0UA1pfdgZgqyk8+XOLoLOd0io5p0A4fMA8K87sZQNP7To7/Cv1z4BT+pX7nn+oiYVbfHqtvbsKJIqQZH01WOZqoczdQ4nK5QGE0W24HLot3hWm+Fc4VpUgfIVzEhIeHF4vnfeyckPGV0ReV4dozDmYpsDd7lAHyrX1ccS3EwiuRg07rLJ6yop3m7fIQ4jvEj2cqnKSrajEIcCxYX4eZNWSAzPy+Xh0FV4dvf3vV4+f73fVIzvKWT0kdm7XM5M73wM5h497ENrRUhGDPyNIw+LW9wz/X+uMLwpotzs0GxDGUjzQ+qp/h25ThXeitc7i3S8of0A5eIGBXByewE57OTpC7WuW2fI4oVTNO5bwulH4e0o52T5w6lypzKTz4fImAcyc+IWM76Z+4vaAghqJk5Gl6fNafLABdL1fmrk2+xYLdZdTuEo99EGEcy6GPU0rp+Pooj2doaR4TIy/woYNXtPfrLADqBQ+euNOSQiIY3oOENYMePq/MYzxnTCxx6uyUw34eAiH+/8hV3hg2OZKpEccSc3eJGf41htJnSrSAe2DaqCMGkWeBoukpK9fmmu4i2Q/WZF4XExBhCRUEh2PhMIoJotN562ajteP1XEMWyIk4Ar+Snd0xHXt8XuqFPw+3T8Ac0vD5+FHI0U+VYuoY+CiiyQ4+mN2DV6bLm9nCjAG3GQC/W0G7fQXd7aB/+EXqpjJ7JomWyaOkseiaHS8gvmzf5tH2b6/1V3Hh3j9CSnuZ/Nfv+hggYxhFeFOJHgWwBDjz8KMRQVSpGmjGzQMlIkx55Scp29UkEAvf6Vc7eaZHXTDlb8+67kE6qOhISDgz+AFpXZXXc+t7Lqsiwj3T1mW7aU8HIQeWMnIx1WpvpvooqK/5VUwqHG2tL+uaq1osljm7BUDQKepr2yF7kYVGEwt+YfoeykeF/Xvzsgbe3Q2+bDY2C4I3iIf769DvkdIualWPN6XGtv8KZ7OTGf2JCQkLCfpLsWRISHgFVUVC5v0AmW/QAxGa4xAM0NSHEPSm9QsDMjFzabSkILi7KgM69EoZw8SJ897t7v89TITcthb/lT2S7ysJPYPzdx/aXyegmrxRmsIN7237DbMSd5VvEXsyUmMQqbgZDfKd8fON0HMfYkY+laChCIQhC/uzzP+ewOoGqqnx3MtpLV+I9KEKQ3a923adB66qsIFANqL6yp7tYqs65/BSD0ecYEdP2bfJ6msNBmUe1oOu6NnOdBgt2i15g04tc+rj4yqO1sT4PXOgtcuE+npUR8T0trjtxfbjG9eEaFOD3ry+SUQ2yqrUhfgVRSD909/RYD+L3lz7ndG6CY9kaAkEYR7T8IS1vSMsb0PaHu7bkayiUzSxdf4hzn4AfzNECECxKvfYRNFsNhf/N4e9iqjpO6OOPWsbt0MULQ3RFpainGbPylPUMac3YsRI6LVTOX1kiXuxiaCbMzsKrr+6pdTkhIeEp4NvSD7a/yIYAmKpJAfA58rTbN4SQr/tlfO13oQuVrGahCoVh4G5M8jwMQgh+fewcNTPHv1/+igW7tef7RsT8sn2butvjvzjxm+T1FEEUsmS3yWkpjmReAoE6ISHhqZMIgQkJzxHFouwye/31vQuBngd/9mfQbErf/bGxJ7qJD49Vgpnvw/LHMoFu6QOovgr5Q4/3sKqOtVMLqwnB4TE6cx1Y8CiN3xt6sRO+4uM5GplMilxOo/oyFPm4Xdk6BfIzeYgWFUPRMLZ4m1XMHIfSFTr+kOABbadxFOP3Pby+h9f15emeh2nH6GGKyVDdCCGJgb7m0c56dCwPJxNhq9LLrx+4DEPvvs+1H6gIJlJFxswcXd9m0e5gR3t7XtmynCKnW2RVi5iYy/3lJ7vBjFqpn9B748YBX3bn+bL7kKXLyErIVbf74BvuAycyY/za2FnyeoqGO8CNfPwwQFNUCnqK8Wyekp4ho5n3t0FwXfjoI/ROB3RDhpkcPvxUXkNCQsIDiCNpbdG6sulzlx6XXQnWI7RJJLxwCCFke/DIOuRhhcAojhmELmEU8Wp+htcKsxs+wG1/wJ1hk5uDNW4O1mj5O3eKANyxm/zenZ/znxz5FQpGmn7gsuJ0mE2VUR/W3ychISHhASRCYELCc4ii7N3zT9Okr/7163DpEtRqTzSo9tHQLJj6rmxB7S/KdFqvB5VzT2Rji0eLdOY69JZ61Nwamrm3XaHjaGQykH0ZvPvjWH4OcTQyA5+67827812a15oIRaBndIysgZExNk6ruoquqFR3SM6N4xi36zJYGTBYHeC0N9uuVaTQZmGS100msyW8dEyYEegZDT1voGcMhDKqbIsjhoHHMHLxwgA38un5Dr3AZRC6uFFAStXJqBYpVcMJffqhy8B36QYug8DGjUPW63lVITAVHUsIcl6XTDDAEgJLCEw9h5KqYmSqoFioQqApigz2iHwGvjQAH0YeQRShKio51SQ78iNKqzqa0AiQbahRBIiYY70af7xygZAXt9LxWWFGcMw3+FaUZzrIIJwVIqMJhkFBsxgzc5TMDGmRQrEBZwiKs2m0evfaceDTT2WYiWHAe+89mgdDQkLC/mM3YO3LzXRbqywr283Cs92uhAOHpeoU9fS2BOC9EMURg8Cj69sMQg9FiI2QNpn+m+ZopsYPaqcBaHnDDVHw5rDO/LBJtMUx+MvOHL+/9Bl/deotsrpF17Np+YMdx04JCQkJj0MiBCYkvAScOAG3b0OnI332p+6v6TwbFBXG3wY9JxNqOzdGISJv3Tec4lGwChapcgq7adO53aFyam9VgY4jd5kvhRDYuSETdBVdVgPuQuAGrHy5Qn+5v3GZ07nXE0/VVYzsSBjMGBhZWV04WJXiX+BubwNVNAUzb2LmTLnOmxg5KSjulTCOcEIfLwo2Un+9KMRQVNKqQVo1UUZCc0SMM6qSswOPaJf+ZcVtobeuILzR63Xr6H4TM13DyM1iZKelsL31PYojVp0uC06LYeChCkEUx3hRCApYqkHNyJLTUqRVg3O5aWbSJT5sXKfpDTccBbK6xencBOfy05T0NL3ApRfYhA9I+O0HDpd7y1zoLNAO7D2/f+uoCFShoAnpiaopCppQUEeLMhJN3Shg1Xs4H0cFQVo1EUAv3NlL0RAqeT2FqWgbPoVBHBFF66elV+HdichZ1eRMboKzuSlm7ZjK7SXSvSG6UEgLHVOJUHEAB4FAU1QUsfrQ7w8AmQy8/75cJyQkPFsCFxoXpf8dyGr2ynmZoJuQsAOyPViGbw0D94Heu+vYoU/HHxLGETUjQ8cfktdTu95eioOHeaskq8ZXnA7/1dU/xt5Sof8fVr9hNlXhfH6KVjyg6fYTITAhIWHfSYTAhISXAMOAY8fgyhW4fBkmJw9gVeA65VPSzHr1MxiuwsJPYfI9mVK3jxSPFLGbNu1bbconyhsVZffDtqUI9cILgf5AJjqDrMrUdk7R6y/3Wf5imdALEYqgcrKCmTfxBrKt1x/4eAOPwAkI/RC7ZWO3dhaiFFUhXUuTHc+SrqbR048v/qpCIaOZZNhbm09GM3mwJDwFY+fle9RfhMGSbGmPXOhck4tZkmmK2Rlpso5MJayZORYc6RuU0yzSmklaNTAUbUOQBFkhqSknGDPzDAPvnhb39RRgAEt58PuUUU0Op6v87vibfPnTjxl79zT92GMQbB54qEKQ1kx0oaEgvSzXRb6HSQfvBg7X+yss2O0NgVIgUxItRSOtmWQ0k5KepmLkmLDy5PUUmlC51l/hcm+ZYeSRUQ1OZyd5tThz34Oqu9+XMI7wR8Lg1tRuAM4A/T7YtmzndZzNtedJv4U4frg1QLUKb78td7QJCQnPjjiG7m35/7Xud5o/AuUz+z6hmPBiIYQYTcaZrDpdzD1+X7woRBVwPj/NMPRo9W2CKELbY9vOuFXgPz3yK/yD6z/cVhn4Py38gtO5CSxVZ9XrcSSq7VmcTEhISNgLyR4lIeEl4fhxGTTS78vU4dnZZ71F9yE7KUNElj6WVYHzP4Hxd/Y10S83mWPNWiNwAnpLPfLT+Qfex3XlLvOFLvqJY1gdtQSnqjt6NYZ+yOrXq3TnpZebmTeZfHMSM7+z4BaFkRQF+x7eYFMgjIKIdDVNZixDupLekxh7YNAz0mOqdBL8oRQE+0vgtjaX5iXIHYLiMdAz5I0UeePBopYQggmrgCoUbg7q+PdJvN0LcRzT9gYMUTFjlelUCfWu1GA3DBiGHh1vgKaoj5xoXdRTvF06wttbumMFYAiNvJ4atUUbpEYC6FahrmpmOZqpsex2mDSLTKYKDyVCCiHQhIrGfbY9m91fJT+OD/CsSkLCS4TThvqXcmIGZPtv9TWwis9yqxKeI9KaQdXIEj2ELUdGNTiZG6Nq5ll1uliqTi+wKRl7Hyieyk3wt2bf55/OfbhxWTew+aOVr/mNsXM03D5Nd8BEKmlpT0hI2D8SITAh4SVB0+DkSZkefPkyTE/v3WfwmWAWYOZXYPlTKaosfQjV83J2fx8OvIUiKB4uUr9cp32z/UAhMIrAcV6CisDeHXAaIFSovX7P1YO1AcufLxM4AUIISsdLVE9X7yviKaqy0d77QqKnoXhcLoEjRcHevGyt7t6SFSrZSSie2LM3lRCCMStPbR/agYI44vagzu3+Go4IaXpDtGhTLIuRbdRdz6ZsZDiTmyC3xyq8vbIXQU9TVKbTJabTz5HHXiICJiQ8W0JfTrp0b8nzii4rAPOHk99nwkOhKyqn8hOcjMcf6n7r/29ZzaKgp2i4/YcSAgG+VT7GF507XOwublz247XLvF2ULcSrbjcRAhMSEvaVRAhMSHiJOHIEbtyQnXF37sjzBxrNgunvyAq1/jzUv4bBihSo9kGoKBwu0LjawG7ZOG0Hq7hzCyzI9yyOQVXB2v1mzzduB+oX5OnyGSlwjYjCiLWLa7RvtQEwMgYTb0yQKu+vYPTco1lQOCoXuyFTl4erso24vwipmhQM07U9PdzDVMTthi5UjmXHMGOFFS7T9x1EdO8swGyqxInc+J5bohISEhKeKb0FaHwN6/5q2ZmRncULOumU8FR41P9dU9XIaxarTocgCtEeorJeCMFfn36HK71/SzCy1YiI+Z8WfsHfnnmPpj9gELhkku92QkLCPpEIgQkJLxGqKqsCv/pK+gXOzsrLDjRCgfE3ZXtP4xuw12D+z2Xy32Maf2umRm4qR3e+S+tmi8k3J3e9bX+UDZHJvKBFBoEjW7HjUIpVhaNEYcSwPmSwMqC/0idwZItq6WiJ6tkqinqQS0oPAKmKXNyuFAT7i/L7a6/JysDCcZnG/BS+UIoQTKSKpGKVd0pH0PTtf/8CQVozUEXymSYkJBxw4hia30D7ujyvZ6H2mtzfJiQ8I1ShkNdTWKpBL3AeuiqwZub4jbHz/OHKVxuX3RzWuTlsMGHmabj9RAhMSEjYNxIhMCHhJePQIbh+HYZD6Rl44sSz3qI9UjgK6TFY+Uy2Cq9+Jlswq6891ux/6WiJ7nyX3mKPwqEC6Up6x9utC4HZ7M5pss81UQBLH0Ho4IdpBvZx+h8vMKwPiaPN16undMZfHydTe5FNEp8AZh7G34LyWehch+4dWX25+kvZ0lY8DrlZmZz9hFEQ5HQLXU+q/hISEp5DolDuOwfL8nzxpAwZSyYxEg4AGc2koKdYc3tY6sMHSH2vepKPmzdo+oONy35Sv8LfmnmXVbfLbLq8L50CCQkJCYkQmJDwkqEocOoUfP45XLsGhw/Dc6MJ6BmY/q6srmpdkQcCTlOKgdndq/nuh1W0yI5n6a/0mf9wnsm3JslN3uvLtrUi8EUiDiPsSx8ymFuh3xJ41mHQmhvX6ymdzHiGzFiGTC3zfAV6HDT0lKxkLZ2Czi3o3oRgCPWvoHVZVggWjkCSDJiQkJBwL4EDyx/LiRShQO0NyE0/661KSNjAUDRyeooVp8uS3X6kx/jVsTP8y4VfbJxfcFo0vD6qUOj4NkVj5wnrhISEhIchOdpISHgJmZmRImC/Lz0DT59+1lv0EAghk1rT47Iq0OvCyqcwmIbqq/AI/maTb0+y9Msl+st9Fj9dZPzVcYpHittuMxxKAexFEQKHjSHtW22G1y4SdpbkQVX5DEK3SJVTUvgbz2DmkjaUfUc1ZAVL8bgMZ2nfkIJg8xspcheOyQrYxKsvISEhQeJ2pH1F6Mh96Pi7kCo/661KSNiGKhQmzAIQE8cP10ESxzGD0CeKI8p6mqY/3Ljuk9YtfnPsHA2vnwiBCQkJ+0IiBCYkvIQIAWfOwKefSiHw6FEwHr6D4dli5mWqcPPKyH9tQYYzjL2x5yCGdRRVYeqdKVa/WqV9u83KVysETkD1THXjNputwfv4Gp4BURhR/6ZO62ZLBq90l1B1hcyp18gePUK6lkbVD7px5AuCokrBL39Efn9bV8Hvy+rAznXIH4XiMXnQm5CQkPCy0l+SE39xCEYOJt7bFmaVkHCQSGsGx7SxR7rvqtOl5Q94v3Kcf7+86RV4sbfIdyonWHG6HE5X0ZSkFT4hIeHxSITAhISXlIkJKBSg05HVgefOPestegSEApUzkBlVB/oDWPoQiiegfPqhPIOEEIy/No5madQv12lcbRC4AeOvjeM4AteVt3uehUC7ZbP82TLewAO3QyG7TOFUFuvIK4jyyWe9eS8vQsjgm+y09L1sXQGvB+2r0Lkh24ULx5MkzISEhJeP1jVZLQ3SJ3j87cQ+IeGFJadbFPU0JzLjpJRL2JG/cd2XnTnyWoqW16dm5Z/hViYkJLwIJNMJCQkvKetVgSBDQxzn2W7PY2GVYOYHkD8sz7evwcLPYUtbxV6pnKow/to4QggWLvX4k3+yxp/+SQSAYURoz+HxRxzF1C/VmfvZHN7AQ1M8Zo4sM3E2RWrmWCICHhSEkCnCMz+AiXdlsnAcymTMO38Kq19IX8woeNZbmpCQkPDkiGMIXFj9fFMELByVlYCJCJjwAmMoGnk9hS4U3i8f23bdZ+3bDEKHNa//jLYuISHhRSL5N01IeIkZG4NyGZpNuHwZXn/9WW/RY6CoUHsNUjVY+0ImC8//Ofz/27vzuKjK/Q/gnzMLMzDDDrIoixtqSRB6r2nXXcPQLlY3y8w0tPK2Y2Y/c6Msl35X00qtnwX485ZmpbZq9TMXsjT3lSsuqKggCMrOrM/vjwMDI7uiCPN5v17nNTNnfY4+ZzjnO9/neXwj5OBKAwkBlGk8cE444eTRKxDCCI0+FyE93NChQ/5NPIGbw1BgQOb+TBgK5JRGN38t2nicgVIhAc4+gG94M5eQqpEkQOcvTyXZcvN3wxW5P8HCc3Kmq9ZbzoR1aSMPokNEdDszlcpdH1iMgNVY/mqSX6u+t5rkyUaSB1lyD22ukhPdMkpJAU+1C5xVTojwCMb2y2mwQu5r0CSs2JaTBi+1DjlOrlArau/GRalQQK/UcIRhIqoVA4FEDq5rV+D334Fz54CcHLnJsL8/4O0txyNaHH2AnEl1aZ8cPLm0FyjJkR8k6rhpMpuBjAw5O7K4GABc4NtNCVVuNgK8r8IL+SjQtJy0SSEE8k7mITctF8IqoHRSwq+7D1zFIcBgBNR6wK9no5pPUzNwaSNPpblys+HiS/LAIqU58gTI/5cubeQBdJy9+H9KRM1DCPn7yVgkd29gqvJ6PZnMKhf5B75G9vtL1JI5K53gqdKh1GzC3Z4h2HvljG3Zf4oysfuKR70BPpVChWAXLwRoPaBokTfzRHSzMRBI5OC8vYHOneVBQ0pL5UBYero8eIifHxAQAPj6Ai2qX2K1C9C2T/lAIifkLCrDFaBNlDzISBUlJfL5njsnBwMBQK0GQkKA9u01kExtcH7neRgKDShOLYZhiAFqr+YfzVUIAavJCovJAotRnqwmq+19cU4xyq7KgUu9nw5+HQVUxfvlBzKlExDQi6PStiTO3vLk011+yC65JAcFy/Lk/9P8Irk/QYVKzoqtCAyyX0EiakpmgxzsM5fKk6nifYncT6+w1rKhJGcvq7Ty3yCFGlA4Vb6v+lrxngEMckAahQpuTlpkGoD72tyJ1IKLKLEYbcu35hxHqM4HbbRucJLU1QJ9AgL5phKcKsoGhECAsycUkiTfN0LAbLXALKxwUqjqzCokotaNgUAiQteucjAwJwfIypIno1HOkMvIAJRKuRlxQID8qr4N40dCyCP75ufLU1GRApLUFQqjP5T5qVAII5TK/VB4dYLSoy0UCnm9rCx5W0AeCKRDB6BdO/mcAQBaDYL/Fowzv52B1WjF+d/PI6RPCJy9nG/q+VgtVhiLjDAWGmEsMsJQaIC5zFwZ7DNZ6t2HQqWAX0cJbs6ngKsF8kylE0dcbOmc9PLk0RGwmOTMwJJsebIYyjMHMwFIgNZLzpLVBQDgDT/RbaHkMlB0Xs7m1Qfe3O9jIWpvglvvthb7QJ+5tI5AXzlJIZ+Xk6s8VbxXuzBbmagBJEmCu9oFepUWpRYjRrfrhU/PptiWm2HFJ2fkzxIArUINZ6UTnFVOcFE6wVnpBHeVM3w0OhisZhiEBc7lfWsKAGVWM4wWM5SSAqEu3lArGQ4gckS88okIgBz4qmgWLASQmysHyTIz5YFEMjPlSaGQswj1evm9Ulnzq0IBWCxyll3FdO3nqvMUCnmfrq72rzVlIlqtQGGhHMi7ehUoKJDfW2t8PvEALD3lbClDPpBxAdCWAG7tgfKbH19fOQDo61tzAoLaWY2ge4Pw554/YTVZkfFHBvzC/eAW5NYk/a8Yi4wozSu1BfyMhUaYShvwkAY52Kd0UkKpVsqvTkoo1AqorFfh5nIeakURYIScKebeEfDowM7WWxOlWg4k6APlC9eQL2cLllyS35flytPlI5BUbnAxZckP87djNJ+otbNa5MEv8tMr5+WlAhrPyutYpW38fg358kBCpuJ6+ttrChKg1MiBPZWz3HxXXfHqIr8yk4/ohuhUGrTRuOFUUTYCnT3R1ycMKZfTqq0nAJRaTfLowqbiasuVkNDOWW4i7OfshjZOrnBTaSEgZw5ahRWdXP2gZJCeyOHwaZCIqpEkwMdHnrp3l4NtFUHBoiI5czAnp+mPW1goH6NqOVxcKoOCRqNclsLCyiy+qlQqwN1dnlxd5XlWK2CxqGG1hMFyNQPWK+mwWEpglXKhatMNwWHutnXrolQroeuig85Ph7LcMmQdzELeyTx4dfaCW1s3SIrGPfiYSkwouFCAwouFtoE8qh3TSQmNqwZOeic4uTpB7ay2Bfoqgn/VjluSA+Qdl5tCA3LQz629nD3GpsCtmyQBWg958uoiZ/IUZwJFmXJ9KMuDq/EcpHObAZ233HRYoZazdGqaIAGSUt5vxeeaKNRyE2Q+SBDVruwKkL2/8mFd31bO4C29LF+fhitA7lF5ICB9oJzFW1vTfiEAw9XK69tcUv/xFerqTW9ru6YrSIryYF/5pHaRA5W81oluKqWkQLCLFwxWEzJKcjHQpytOFl5CpqFxg9ZZIHC2NBdnS3OB8ttCZ6Ua7bSeaOfiBQEJGqUK7Zy9GrVfhaRg34NELRwDgURULw8PeeraVQ4EZmfLQTk5yFbzq9UqZweqVJVTXZ/NZnnfhYWVryaTPHBHcfUfOaFWy2WqCPy5u8tBw9rvSyQAwUCZG5C9DzDlAMgBrroBpgC5+aRT3RFBSSkhoGcAis4VIe9UHozFRmQdyELu8Vx4dfaCe5B7nQFBU6kJRZlFKLhQYOu/D5CbgTh7O8tBP1cnW/BP6dSIppyluXIAsCy3orDyKIseneSHPnI8ahc5AOzRETCXQVw9B6MiTb5IDPny1JQU6vL+v7RyxpCqlldmpJIjEdby/mpPAhDy9dEmsnIADHNZeUDvotznZ5UsXjj7VAYFFSp5eUXwz1Jl8CpJKfcLqvWs3u8e+9sjapFUCiU66HxhtJqRWZqPkW2j8EPmQZwvzUM9DfTrVGox4URxNk4UZyO7rBAahQoWIaBqRH+Bvk6ucFHx3pKoJePdOBE1il4vTzdDmzb2nw2GysBgUZEcMKwI/jlfbxd9Wg+gXT/5IavwPGAskKcrx+W+jHQB8oPXNYOKVJAkCV6dvOAR6oGrZ6/iyqkrMJWacOnQJeSm5cKrkxfcg92hUMoZE2aDGYUXC1F4sRCleaV2+3H2doZbWzfo/fWNC/pVVZoHXEmrHEFWUgBuIYBHZw4UQZVUWsC9Pa44d4UIGgyYcuUMJWGteYJVzjqym1dDGi4gNz0UVvnVaAJQWHdZFCo5IKjUlvd3WKUfsetpFkl0uzIUyFmAxvI+WvXt5AF/qmZnl1+bcG8PmEqB4otyUNBwtXJ08JxD8jZVBgyAQiVn9eoC5CAgO/0nanU0SjU66f1gFQJFZgOeCO4Dq7DCYDWjyGxAicUAg8UMgzDBaLXAZLWgzGJERulVnC/Nre2vts3RwgvoqPeFWdTf73QFpaSAxk3FQCBRC8dAIBHdtjQaefLxaeIdK1RyRob3HXK/SsWZcvMsU5E8yvDVE/LohroAOcNCUgIWAZW1fJREBaBQKuHVUQ4I5p/LR97JPJjLzMg+ko28E3lwC3JD2dUylOaWQlRpx+zi7QLXQFfoA/RQaa7zK9hUKnc0X3QBMJYHXSQF4BoEeIYxmEJ1U2kA5xA5YNxULEa5maO5zP7VUmY/T1gAq1meTMWVGawVFCpA7VolQKirPqIomyXS7U4IOQPwSpocJFc6AT53yZnndVE7V2bxmorlgGDRRTmQaDHK14DOvzz458trgcgB6FQaRHoEw1olrGeyWmCwmGAQZjkQaDWjxGxEqVUODJqsZhSaS5FVVohcYxEuGQpwoeQKSqzGavvfnJ2Kv3iGwlXdsF/Ycw1FUEv84YGopWMgkIgcl9IJcAuWJ4tJHnW1+KL8aioub8olk8xmeJcehnROI6cmAoCkgEJSwlOhgkeYEvmZZuRlCJiK1MjLL+88XekEZy85+Oca6AqV9jq/di0muWyFF+yDJ5JCzjLx7MyRgKn5VDRBrKd5PazmyqCguRQwFgGmQjmgbSqRl1f0l1YbhapKcNBJzpSqaA5Zb2BEkoOLFUFGNpdsHcyG8jpUVPla3+i2N5PFUNkXoM5fDgI2NkNbrZO/1z07y9eJxShntDP4R+RwJEmCskqfnkqlAtpa+n02Wy0oMhtw2VAIH00BSs0GCMh9A1qFwNHCi/gu84Bt/WKLAavO/YFuboEwWS0wCzmz0GS1wFT+XgIQ7OKNO93asm9AolaCgUAiIkAOJri2lSeruTwomCUHJ4QZkAywQm3/EFbRZNJqggTAwxdw9xYoyCpEcZ4ZWr0Crv4aqN3c5MBDiR4w6coHYLh2UIZaBmsoy5Oz/0qy7R9std6Aazs5M4SDgFBLoVCVZ/3pqi8TVjl4YiysDOaYSgGrsXIEVKAyo9BcWn0fjSEpKpsk2yY3eVCE2+1BR1jlYJelrHrmZUMCXgql/O8uqaq/l1SV/y8Klfz9dMtVNEMXkJul19RcvXwdo0Ee/TrnICDKA4BNPjJuE1CoAJ9w+Xv6RjndpP44iKjVUSmU8HBygYeTC4J13sgzFiO7rAC5xiKUWUyIcg/GmeLLOFxw3rZNWtElpBVdqnO/e6+exfqL++Cl1qGnZ3sMatMVER7BN/t0iOgmYSCQiOhaCpXcT6A+0DZLmEzIOVwG0T4GUCkBa3kTR2GufG81QTIVwd2tCO6mQjmLQ1gqAxs3yslNHmlS31ZuQkbUmkiKyoBcTYQov86qBAYt17yvr0ckq6U82FhQfm0WVPbfZiuHsrIcKmfUO7JqUxOW6s2rLdWbczkqyWyWR78ubFOZnQ1JzohWV+lzsrl/INF4sp9WImpWTgoV/LXu8Ne6I99YirMlOcgqK8BA3244XZyN4uv425JnKsbP2Udw1VTMQCBRC8ZAIBFRY0kKQKmo/0FTCDlrqaK5mrEIMJfUnulS03yVc2Xwr5YBTIgcgiTJ15xSXXNGYWNUXJsVQXpjoRwQNJUH7w1X5el2IinKB1mpMgKzUtuwQSKslvIfLcqnqn01Xvu53u7lbyK7jOhrs6Sl8v5aLTAovSA8OwPOnlX6kmSfVUREtXF3csYdqrbQqbQ4V5KLwW3uwLdVmgg31l+8OjRd4YjolmMgkIjoZpEqslRc5FEdG0uI26+JIlFrUPXa1PlVzhdCDtYbCuTgoMXQDGWrIeCn0sr9It6K74Nm6VtPavC5CZMJV7VXAM8ugJrdIhARNZRKoUQHnS9cVE5wUqhhslpwsjgbViGglhRQKZRQS0rbq1qhhFqhQKHJgNTCTBRU6ZLjr57tm/FMiOhGMRBIRHS7YhCQ6NaSygcTUesA1DPCa2vFwSiIiFotSZIQoPWAs0INrVKFLnp/OClVUNbz3f/3gEhcNZdi95V0mKxmtNGylQpRS8ZAIBEREREREZGD8HDS4U6lE86qLuOyofZ+rAUAIQSyDYUIdPFAP58whOn9b11BieimYCCQiIiIiIiIyIFolWp0cQ1AF9e6M+DzjSVIK8rCxdKrcFE63aLSEdHNxEAgEREREREREVXj7uSCUBdfGK1WFJpLYGmWvmSJqCkxEEhERERERERENfLR6GEUZpwpFjALS3MXh4huEAOBRERERERERFSjikFGdEon6FXa5i4OEd0gBgKJiIiIiIiIqFYKSYKHk665i0FETaDuccKJiIiIiIiIiIioVWAgkIiIiIiIiIiIyAEwEEhEREREREREROQAGAgkIiIiIiIiIiJyAAwEEhEREREREREROQAGAomIiIiIiIiIiBwAA4FEREREREREREQOgIFAIiIiIiIiIiIiB8BAIBERERERERERkQNgILCJjB8/vrmLQEREREREREREVCsGApvBtm3b0KNHD2i1WnTo0AEfffRRcxeJiIiIiIiIiIhaOQYCb8Dly5cxbtw4BAcHY/Xq1ejUqRNGjRoFo9FY6zbp6emIiYlB3759sX//frzxxht46aWX8PXXX9/CkhMRERERERERkaNhIPAGxMfHY9euXVi1ahViYmKwYsUKtG/fHlartdZtPvroIwQHB2Px4sXo1q0bJk6ciLi4OPzrX/+6hSUnIiIiIiIiIiJHo2ruArRk+/fvx9ixY9G/f38kJSVh4MCBGDhwYJ3b/PHHH7jvvvvs5kVHR+PTTz+FyWSCWq2uto3BYIDBYLCbp1AooNFobvwkmpHJZLJ7Jbqdsb5SS8c6TK0B6zG1NqzT1NKxDlNL1Vrrbk0xpWsxEHgD7r33XiQlJSEiIqLB22RlZcHPz89unp+fH8xmMy5fvoyAgIBq28ybNw9vvvmm3bxHH30Uo0ePvr6C32Z++eWX5i4CUYOxvlJLxzpMrQHrMbU2rNPU0rEOU0vV2upubGxsveswEHgDFi1ahLlz5yI+Ph6nTp3CgQMHMGnSJEyaNKnO7SRJsvsshKhxfoVp06Zh8uTJdvNaS0bgL7/8gqFDhzYoak3UnFhfqaVjHabWgPWYWhvWaWrpWIeppXLkustA4A3Q6XR455138M4772DkyJG4//77ER8fD4VCgWeeeabGbfz9/ZGVlWU3Lzs7GyqVCt7e3jVuo9FoWnzQry5qtdrhLjxquVhfqaVjHabWgPWYWhvWaWrpWIeppXLEusvBQpqIh4cHnn32Wdx///1ISUmpdb3evXtXSz39+eef0bNnT4erfEREREREREREdOswEHgD4uPjsW3bNuTn58NisWDLli3Ytm0bevToUes2kyZNwtmzZzF58mSkpqYiMTERn376KaZMmXILS05ERERERERERI6GTYNvQHBwMCZPnowTJ06guLgYW7duRVxcHF588cVat2nfvj1+/PFHxMfHY+nSpQgMDMT777+Phx9++BaWnIiIiIiIiIiIHA0DgTcgPj4e8fHxAIDx48cjOTm5Qdv1798f+/btu4klIyIiIiIiIiIissemwURERERERERERA6AgcAm0tBsQCIiIiIiIiIioubAQCAREREREREREZEDYCCQiIiIiIiIiIjIATAQSERERERERERE5AAYCCQiIiIiIiIiInIADAQSERERERERERE5AAYCiYiIiIiIiIiIHAADgdRsrFYr9u/fD6vV2txFIaoX6yu1dKzD1BqwHlNrwzpNLR3rMLVUjlx3JSGEaO5CkGMqKCiAu7s78vPz4ebm1tzFIaoT6yu1dKzD1BqwHlNrwzpNLR3rMLVUjlx3mRFIRERERERERETkABgIJCIiIiIiIiIicgAMBBIRERERERERETkABgKp2Wg0GsyePRsajaa5i0JUL9ZXaulYh6k1YD2m1oZ1mlo61mFqqRy57nKwECIiIiIiIiIiIgfAjEAiIiIiIiIiIiIHwEAgERERERERERGRA2AgkIiIiIiIiIiIyAEwEEhEdBNJkoQNGzY0dzGIiFoVfrcSyc6cOQNJknDgwIHmLgpRo4wfPx4jR45s7mIQ3TIJCQmIjIxs7mIAYCCQ6sAvZ2rpxo8fD0mSMGnSpGrLnnvuOUiShPHjx9/6ghE1AdZvak14z0G3SnZ2Np599lkEBwdDo9HA398f0dHR+OOPP5rsGKzPdCtU3AfMnz/fbv6GDRsgSVIzlYro+gghMGTIEERHR1dbtmzZMri7u+PcuXO3pCyhoaGQJKnadO211pIxEEgtnslkau4i0G0sKCgIa9asQWlpqW1eWVkZVq9ejeDg4BvaN+seNbebWb+JiFqjhx9+GAcPHsTKlSuRlpaGb7/9FgMGDEBeXl5zF+22YjQam7sI1ABarRYLFizAlStXmrsotwUhBMxmc3MXg66DJElISkrCrl278PHHH9vmp6en4/XXX8eSJUua/N62rme5t956C5mZmXbTiy++2KTHb04MBFKDbNq0CX/729/g4eEBb29vjBgxAqdOnbItr2iWsG7dOgwcOBAuLi6IiIiw+3W1plTYxYsXIzQ01PZ59+7dGDp0KHx8fODu7o7+/ftj3759dttIkoSPPvoIsbGx0Ol0ePvtt9GpUyf861//slvvyJEjUCgUduUkxxMVFYXg4GCsW7fONm/dunUICgrC3XffbZvX0Dq+du1aDBgwAFqtFv/+978BAImJibjzzjuh0WgQEBCAF154wa4Mly9fxoMPPggXFxd07twZ33777U0+a3IUTVW/Bw0aVK3e5ubmQqPR4Ndff735J0JURWhoKBYvXmw3LzIyEgkJCTWuz/pLDXX16lX89ttvWLBgAQYOHIiQkBD89a9/xbRp0zB8+HAAQH5+Pp555hm0adMGbm5uGDRoEA4ePGjbR8X97Mcff4ygoCC4uLjgkUcewdWrV23LV65ciW+++caWRbJ161YAwIULF/Doo4/C09MT3t7eiI2NxZkzZ2z7rsgknDt3Lvz8/ODh4YE333wTZrMZr732Gry8vNCuXTskJiZWO7f//Oc/6NOnD7RaLe68807bMSscO3YMMTEx0Ov18PPzw9ixY3H58mXb8gEDBuCFF17A5MmT4ePjg6FDhzbNPzrdVEOGDIG/vz/mzZtX6zpff/217T41NDQUCxcutC2bNm0a7rnnnmrb3HXXXZg9e7btc1JSErp16watVouuXbti2bJltmVV75H79u0LZ2dn/OUvf0FaWhp2796Nnj17Qq/XY9iwYcjJyal2rDfffNN2vT377LN2QWghBN5991106NABzs7OiIiIwFdffWVbvnXrVkiShJ9++gk9e/aERqNBSkpKw/8B6bYSFBSEJUuWYMqUKUhPT4cQAhMmTMDgwYPx17/+tc7vsBt5lquJq6sr/P397SadTgegst5t3rwZPXv2hIuLC/r06YPjx4/b7WP+/Pnw8/ODq6srJkyYgLKysib+F7t+DARSgxQXF2Py5MnYvXs3Nm/eDIVCgQcffBBWq9VuvenTp2PKlCk4cOAAwsLCMHr06Eb9KlNYWIhx48YhJSUFO3fuROfOnRETE4PCwkK79WbPno3Y2FgcPnwYcXFxiIuLQ1JSkt06iYmJ6Nu3Lzp27Hj9J06twlNPPWVXPxITExEXF2e3TkPr+Ouvv46XXnoJqampiI6OxvLly/H888/jmWeeweHDh/Htt9+iU6dOdtu8+eabGDVqFA4dOoSYmBiMGTOGmQfUZJqifk+cOBGff/45DAaDbZvPPvsMgYGBGDhw4K05EaLrxPpLDaXX66HX67Fhwwa7+lJBCIHhw4cjKysLP/74I/bu3YuoqCgMHjzY7u/2yZMnsXbtWnz33XfYtGkTDhw4gOeffx4AMGXKFIwaNQrDhg2zZZH06dMHJSUlGDhwIPR6PbZv347ffvvNFhypGvj49ddfcfHiRWzfvh2LFi1CQkICRowYAU9PT+zatQuTJk3CpEmTkJGRYVf21157Da+++ir279+PPn364O9//ztyc3MBAJmZmejfvz8iIyOxZ88ebNq0CZcuXcKoUaPs9rFy5UqoVCrs2LHDLiOHbl9KpRJz587FBx98gPPnz1dbvnfvXowaNQqPPfYYDh8+jISEBMycORPJyckAgDFjxmDXrl12AZOjR4/i8OHDGDNmDABgxYoVmD59Ot555x2kpqZi7ty5mDlzJlauXGl3rNmzZ2PGjBnYt28fVCoVRo8ejalTp2LJkiVISUnBqVOnMGvWLLttNm/ejNTUVGzZsgWrV6/G+vXr8eabb9qWz5gxA0lJSVi+fDmOHj2K+Ph4PPHEE9i2bZvdfqZOnYp58+YhNTUVd9111w39m1LzGjduHAYPHoynnnoKH374IY4cOYIlS5bU+x12vc9yN2L69OlYuHAh9uzZA5VKZXf/vXbtWsyePRvvvPMO9uzZg4CAALsAerMTRLUYN26ciI2NrXFZdna2ACAOHz4shBAiPT1dABCffPKJbZ2jR48KACI1NVUIIcTs2bNFRESE3X7ee+89ERISUmsZzGazcHV1Fd99951tHgDxyiuv2K138eJFoVQqxa5du4QQQhiNRuHr6yuSk5MberrUClXU4ZycHKHRaER6ero4c+aM0Gq1IicnR8TGxopx48bVuG1tdXzx4sV26wUGBorp06fXWgYAYsaMGbbPRUVFQpIksXHjxhs/QXJoTVm/y8rKhJeXl/jiiy9s60RGRoqEhIRbcSpEdvccISEh4r333rNbHhERIWbPnm37DECsX79eCMH6S43z1VdfCU9PT6HVakWfPn3EtGnTxMGDB4UQQmzevFm4ubmJsrIyu206duwoPv74YyGEfD+rVCpFRkaGbfnGjRuFQqEQmZmZQoia76E//fRT0aVLF2G1Wm3zDAaDcHZ2Fj/99JNtu5CQEGGxWGzrdOnSRfTt29f22Ww2C51OJ1avXi2EqLw/mT9/vm0dk8kk2rVrJxYsWCCEEGLmzJnivvvusytPRkaGACCOHz8uhBCif//+IjIysqH/jHQbqFrP7rnnHhEXFyeEEGL9+vWi4jH/8ccfF0OHDrXb7rXXXhN33HGH7fNdd90l3nrrLdvnadOmib/85S+2z0FBQeLzzz+328ecOXNE7969hRA1PweuXr1aABCbN2+2zZs3b57o0qWLXfm9vLxEcXGxbd7y5cuFXq8XFotFFBUVCa1WK37//Xe7Y0+YMEGMHj1aCCHEli1bBACxYcOG+v65qAW5dOmS8PX1FQqFQqxbt65B32HXauizXE1CQkKEk5OT0Ol0dtOWLVuEEJX17v/+7/9s2/zwww8CgCgtLRVCCNG7d28xadIku/326tWrWjykuTAjkBrk1KlTePzxx9GhQwe4ubmhffv2AFCtw86qv8AEBAQAkDtlbqjs7GxMmjQJYWFhcHd3h7u7O4qKiqodp2fPnnafAwICMHz4cFtTie+//x5lZWV45JFHGn6S1Gr5+Phg+PDhWLlyJZKSkjB8+HD4+PjYrdPQOl617mVnZ+PixYsYPHhwncevel3odDq4uro26rogqktT1G+NRoMnnnjC9h164MABHDx4kIONUIvA+kuN8fDDD+PixYv49ttvER0dja1btyIqKgrJycnYu3cvioqK4O3tbcse1Ov1SE9Pt8uYCg4ORrt27Wyfe/fuDavVWq1ZWFV79+7FyZMn4erqatuvl5cXysrK7PZ95513QqGofETz8/NDeHi47bNSqYS3t3e1+4jevXvb3qtUKvTs2ROpqam2Y2/ZssXunLp27QoAdse+9v6aWo4FCxZg5cqVOHbsmN381NRU3HvvvXbz7r33Xpw4cQIWiwWAnBX42WefAZCzYlevXm3LBszJyUFGRgYmTJhgV3/efvvtat0vVb3f9fPzAwC7uuvn51et3kZERMDFxcX2uXfv3igqKkJGRgaOHTuGsrIyDB061O7Y//u//1vt2Ky7rUubNm3wzDPPoFu3bnjwwQcb9B12Pc9ydXnttddw4MABu6lXr15269QV+0hNTbX7XgZQ7XNzUjV3AahleOCBBxAUFIQVK1YgMDAQVqsV3bt3r9aRsFqttr2vGK2qIh1XoVBACGG3/rUddI4fPx45OTlYvHgxQkJCoNFo0Lt372rHqWifX9XEiRMxduxYvPfee0hKSsKjjz5q94eFHFtcXJytD6mlS5dWW97QOl617jk7Ozfo2FWvC0C+Nq5NUye6EU1RvydOnIjIyEicP38eiYmJGDx4MEJCQm7ZORBVaMj9wrVYf6kxtFothg4diqFDh2LWrFmYOHEiZs+ejeeeew4BAQHV+tcDAA8Pj1r3V3HPW9dIrVarFT169LAFXKry9fW1va/pnuF67yOq3os/8MADWLBgQbV1Kh5egZrvr6ll6NevH6Kjo/HGG2/Y/QgihKhWL6/9fn388cfxX//1X9i3bx9KS0uRkZGBxx57DEDlc9yKFSuqBUGUSqXd55qeA6+d19D736rr/vDDD2jbtq3dco1GY/eZdbf1UalUUKnkcFVDvsOu51muLj4+PtW6e7pWXbGP2x0DgVSv3NxcpKam4uOPP0bfvn0BAL/99luj9+Pr64usrCy7P0gHDhywWyclJQXLli1DTEwMACAjI8OuE9C6xMTEQKfTYfny5di4cSO2b9/e6DJS61W1D55r+4O43jru6uqK0NBQbN68mf1QUbNqivodHh6Onj17YsWKFfj888/xwQcf3PyCE9XA19cXmZmZts8FBQVIT0+vcxvWX7oRd9xxBzZs2ICoqChkZWVBpVLZDWZ3rXPnzuHixYsIDAwEAPzxxx9QKBQICwsDADg5OdmyrSpERUXhiy++sA2K0NR27tyJfv36AQDMZjP27t1r+4EoKioKX3/9NUJDQ20P1tT6zJ8/H5GRkbZ6CMh1+9q/+b///jvCwsJsgbx27dqhX79++Oyzz1BaWoohQ4bYMvr8/PzQtm1bnD592pYl2JQOHjyI0tJS24/rO3fuhF6vR7t27eDp6QmNRoNz586hf//+TX5sajnq+w5rqnhFU+rWrRt27tyJJ5980jZv586dzVgie2waTPWqGNnsf/7nf3Dy5En8+uuvmDx5cqP3M2DAAOTk5ODdd9/FqVOnsHTpUmzcuNFunU6dOmHVqlVITU3Frl27MGbMmAZnXSmVSowfPx7Tpk1Dp06dbqvUW2p+SqUSqampSE1NrfYL5o3U8YSEBCxcuBDvv/8+Tpw4gX379vEBlG65pqrfEydOxPz582GxWPDggw/eiqITVTNo0CCsWrUKKSkpOHLkCMaNG1etXteE9Zfqk5ubi0GDBuHf//43Dh06hPT0dHz55Zd49913ERsbiyFDhqB3794YOXIkfvrpJ5w5cwa///47ZsyYgT179tj2o9VqMW7cOBw8eBApKSl46aWXMGrUKPj7+wOQR74+dOgQjh8/jsuXL8NkMmHMmDHw8fFBbGwsUlJSkJ6ejm3btuHll1+ucZCHxlq6dCnWr1+P//znP3j++edx5coVW8f1zz//PPLy8jB69Gj8+eefOH36NH7++WfExcVVC1hSyxUeHo4xY8bY3Ye++uqr2Lx5M+bMmYO0tDSsXLkSH374IaZMmWK37ZgxY7BmzRp8+eWXeOKJJ+yWJSQkYN68eViyZAnS0tJw+PBhJCUlYdGiRTdcZqPRiAkTJuDYsWPYuHEjZs+ejRdeeAEKhQKurq6YMmUK4uPjsXLlSpw6dQr79+/H0qVLqw1UQq1bfd9hTRWvqKqwsBBZWVl2U0FBQYO3f/nll5GYmIjExESkpaVh9uzZOHr06A2VqSkxEEi1slqtUKlUUCgUWLNmDfbu3Yvu3bsjPj4e//3f/93o/XXr1g3Lli3D0qVLERERgT///LPaH6HExERcuXIFd999N8aOHYuXXnoJbdq0afAxJkyYAKPRWG3ETCIAcHNzq/FX+Bup4+PGjcPixYuxbNky3HnnnRgxYgROnDjR1EUnqldT1O/Ro0dDpVLh8ccfh1arvdlFJrKpuOcAgGnTpqFfv34YMWIEYmJiMHLkSHTs2LHefbD+Un30ej169eqF9957D/369UP37t0xc+ZMPP300/jwww8hSRJ+/PFH9OvXD3FxcQgLC8Njjz2GM2fO2DKkAPmH64ceeggxMTG477770L17d7vRIJ9++ml06dIFPXv2hK+vL3bs2AEXFxds374dwcHBeOihh9CtWzfExcWhtLS0STIE58+fjwULFiAiIgIpKSn45ptvbP3FBgYGYseOHbBYLIiOjkb37t3x8ssvw93d3a4/Qmr55syZY9f0NyoqCmvXrsWaNWvQvXt3zJo1C2+99Va1PlQfeeQR5ObmoqSkBCNHjrRbNnHiRHzyySdITk5GeHg4+vfvj+TkZFsfbDdi8ODB6Ny5M/r164dRo0bhgQceQEJCgt35zJo1C/PmzUO3bt0QHR2N7777rkmOTS1Hfd9hTRWvqGrWrFkICAiwm6ZOndrg7R999FHMmjULr7/+Onr06IGzZ8/in//85w2VqSlJ4tpOAojKDRs2DJ06dcKHH37Y3EVpsB07dmDAgAE4f/683Q0bERHVLyMjA6Ghodi9ezeioqKauzjkQJrinoP1l26FhIQEbNiwoVr3NkRERC0FfwKiaq5cuYIffvgBW7duxZAhQ5q7OA1iMBhw8uRJzJw5E6NGjWIQkIioEUwmE86dO4fXX38d99xzD4ModMs0xT0H6y8RERFRw7G3WKomLi4Ou3fvxquvvorY2NjmLk6DrF69GhMmTEBkZCRWrVrV3MUhImpRduzYgYEDByIsLAxfffVVcxeHHEhT3HOw/hIRERE1HJsGExEREREREREROQA2DSYiIiIiIiIiInIADAQSERERERERERE5AAYCiYiIiIiIiIiIHAADgURERERERERERA6AgUAiIiIiIiIiIiIHwEAgERERkQMaMGAAXnnlleYuRr1aSjmJiIiIWgIGAomIiIhasPHjx0OSJEiSBLVajQ4dOmDKlCkoLi6uc7t169Zhzpw5N61cW7dutZVLkiR4e3tj0KBB2LFjx007ZnO59v/Az88PQ4cORWJiIqxWa6P2lZycDA8Pj5tTUCIiInJ4DAQSERERtXDDhg1DZmYmTp8+jbfffhvLli3DlClTalzXZDIBALy8vODq6nrTy3b8+HFkZmZi69at8PX1xfDhw5GdnX3Tj3urVfwfnDlzBhs3bsTAgQPx8ssvY8SIETCbzc1dPCIiIiIADAQSERERtXgajQb+/v4ICgrC448/jjFjxmDDhg0AgISEBERGRiIxMREdOnSARqOBEKJak1uDwYCpU6ciKCgIGo0GnTt3xqeffmpbfuzYMcTExECv18PPzw9jx47F5cuX6y1bmzZt4O/vj/DwcMyYMQP5+fnYtWvXde/XaDRi6tSpaNu2LXQ6HXr16oWtW7falufm5mL06NFo164dXFxcEB4ejtWrV9vt46uvvkJ4eDicnZ3h7e2NIUOG2GVQJiUloVu3btBqtejatSuWLVtW73lW/B+0bdsWUVFReOONN/DNN99g48aNSE5Otq23aNEihIeHQ6fTISgoCM899xyKiooAyFmUTz31FPLz820ZhgkJCQ06byIiIqKGYCCQiIiIqJVxdna2Zf4BwMmTJ7F27Vp8/fXXOHDgQI3bPPnkk1izZg3ef/99pKam4qOPPoJerwcAZGZmon///oiMjMSePXuwadMmXLp0CaNGjWpwmUpKSpCUlAQAUKvV173fp556Cjt27MCaNWtw6NAhPPLIIxg2bBhOnDgBACgrK0OPHj3w/fff48iRI3jmmWcwduxYW/AxMzMTo0ePRlxcHFJTU7F161Y89NBDEEIAAFasWIHp06fjnXfeQWpqKubOnYuZM2di5cqVDT7XCoMGDUJERATWrVtnm6dQKPD+++/jyJEjWLlyJX799VdMnToVANCnTx8sXrwYbm5uyMzMRGZmpi2zs77zJiIiImoIVXMXgIiIiIiazp9//onPP/8cgwcPts0zGo1YtWoVfH19a9wmLS0Na9euxS+//IIhQ4YAADp06GBbvnz5ckRFRWHu3Lm2eYmJiQgKCkJaWhrCwsJqLU+7du0AyIFAIQR69OhhK1tj93vq1CmsXr0a58+fR2BgIABgypQp2LRpE5KSkjB37ly0bdvWrln0iy++iE2bNuHLL79Er169kJmZCbPZjIceegghISEAgPDwcNv6c+bMwcKFC/HQQw8BANq3b49jx47h448/xrhx42o9z9p07doVhw4dsn2umoXZvn17zJkzB//85z+xbNkyODk5wd3dHZIkwd/fv1HnTURERNQQDAQSERERtXDff/899Ho9zGYzTCYTYmNj8cEHH9iWh4SE1BoEBIADBw5AqVSif//+NS7fu3cvtmzZYssQrOrUqVN1BgJTUlKg0+mwf/9+vP7660hOTrZlBDZ2v/v27YMQotp8g8EAb29vAIDFYsH8+fPxxRdf4MKFCzAYDDAYDNDpdACAiIgIDB48GOHh4YiOjsZ9992Hf/zjH/D09EROTg4yMjIwYcIEPP3007b9m81muLu713qOdRFCQJIk2+ctW7Zg7ty5OHbsGAoKCmA2m1FWVobi4mJbGa/VkPMmIiIiaggGAomIiIhauIEDB2L58uVQq9UIDAy0Bdoq1BZgquDs7FzncqvVigceeAALFiyotiwgIKDObdu3bw8PDw+EhYWhrKwMDz74II4cOQKNRtPo/VqtViiVSuzduxdKpdJuWUUwceHChXjvvfewePFiW198r7zyCoxGIwBAqVTil19+we+//46ff/4ZH3zwAaZPn45du3bBxcUFgNw8uFevXnb7v/Z4DZWamor27dsDAM6ePYuYmBhMmjQJc+bMgZeXF3777TdMmDDBrin39Zw3ERERUUMwEEhERETUwul0OnTq1Om6tw8PD4fVasW2bdtsTYOrioqKwtdff43Q0FCoVNd/+zh27Fi89dZbWLZsGeLj4xu937vvvhsWiwXZ2dno27dvjeukpKQgNjYWTzzxBAA5iHbixAl069bNto4kSbj33ntx7733YtasWQgJCcH69esxefJktG3bFqdPn8aYMWOu+zwr/Prrrzh8+DDi4+MBAHv27IHZbMbChQuhUMhdda9du9ZuGycnJ1gslkafNxEREVFDcLAQIiIiIgcXGhqKcePGIS4uDhs2bEB6ejq2bt1qC1I9//zzyMvLw+jRo/Hnn3/i9OnT+PnnnxEXF1ctaFUXhUKBV155BfPnz0dJSUmj9xsWFoYxY8bgySefxLp165Ceno7du3djwYIF+PHHHwEAnTp1smX8paam4tlnn0VWVpZtH7t27cLcuXOxZ88enDt3DuvWrUNOTo4tUJiQkIB58+ZhyZIlSEtLw+HDh5GUlIRFixbVeW4GgwFZWVm4cOEC9u3bh7lz5yI2NhYjRozAk08+CQDo2LEjzGYzPvjgA5w+fRqrVq3CRx99VO3/oqioCJs3b8bly5dRUlLSoPMmIiIiaggGAomIiIgIy5cvxz/+8Q8899xz6Nq1K55++mkUFxcDAAIDA7Fjxw5YLBZER0eje/fuePnll+Hu7m7LbGuouLg4mEwmfPjhh9e136SkJDz55JN49dVX0aVLF/z973/Hrl27EBQUBACYOXMmoqKiEB0djQEDBsDf3x8jR460be/m5obt27cjJiYGYWFhmDFjBhYuXIj7778fADBx4kR88sknSE5ORnh4OPr374/k5GRb897abNq0CQEBAQgNDcWwYcOwZcsWvP/++/jmm29szXkjIyOxaNEiLFiwAN27d8dnn32GefPm2e2nT58+mDRpEh599FH4+vri3XffbdB5ExERETWEJIQQzV0IIiIiIiIiIiIiurmYEUhEREREREREROQAGAgkIiIiIiIiIiJyAAwEEhEREREREREROQAGAomIiIiIiIiIiBwAA4FEREREREREREQOgIFAIiIiIiIiIiIiB8BAIBERERERERERkQNgIJCIiIiIiIiIiMgBMBBIRERERERERETkABgIJCIiIiIiIiIicgAMBBIRERERERERETmA/wfK3ogu8+ASRgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(15,9))\n", "year_list = ['2019','2020','2021','2022','2023', '2024']\n", "colour_list = ['darkturquoise', 'darkorange', 'purple', 'blue', 'red']\n", "\n", "for y in year_list:\n", " hdf = spark30_174[spark30_174['Year']==y]\n", " if y != '2024': \n", " ax.plot(hdf['Day of Year'], hdf['USDperday'], color= colour_list[year_list.index(y)], alpha=0.3)\n", " else:\n", " ax.plot(hdf['Day of Year'], hdf['USDperday'], color = '#48C38D', linewidth=3.0)\n", "\n", " ax.plot(hdf['Day of Year'], hdf['USDperdayMin'], color = '#48C38D', alpha=0.1)\n", " ax.plot(hdf['Day of Year'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.1)\n", " ax.fill_between(hdf['Day of Year'], hdf['USDperdayMin'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.2)\n", "\n", "\n", "ax.set_title('Yearly Comparison of Spark30S')\n", "plt.xlabel('Price Release Date')\n", "plt.ylabel('USD per day')\n", "plt.legend(year_list)\n", "\n", "# Setting custom x-axis ticks location and labels.\n", "xlabels = ['January', 'March', 'May', 'July', 'September', 'November', 'Year End']\n", "\n", "# xpos gives the first day of every other month in terms of 'day of year'\n", "#xpos_allmonths = [1,32,60,91,121,152,182,213,244,274,305,335]\n", "xpos = [1,60,121,182,244,305,365]\n", "\n", "#plt.ylim(0, 100000)\n", "\n", "plt.xticks(xpos, xlabels)\n", "\n", "current_values = plt.gca().get_yticks()\n", "plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n", "\n", "\n", "sns.despine(left=True, bottom=True)\n", "\n", "plt.grid(True)" ] }, { "cell_type": "code", "execution_count": 23, "id": "9b9d46bf", "metadata": {}, "outputs": [], "source": [ "mainpath = 'C:/Users/Qasim/Downloads/'\n", "\n", "spark30_174.to_excel(mainpath + 'Spark30_174.xlsx')" ] }, { "cell_type": "markdown", "id": "7e8bc38f", "metadata": {}, "source": [ "## Spark25S" ] }, { "cell_type": "code", "execution_count": 24, "id": "95569391", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\Qasim\\AppData\\Local\\Temp\\ipykernel_21608\\1319271460.py:33: UserWarning: FixedFormatter should only be used together with FixedLocator\n", " plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig2, ax2 = plt.subplots(figsize=(15,9))\n", "year_list = ['2019','2020','2021','2022','2023', '2024']\n", "colour_list = ['darkturquoise', 'darkorange', 'purple', 'blue', 'red']\n", "\n", "for y in year_list:\n", " hdf = spark25_174[spark25_174['Year']==y]\n", " if y != '2024': \n", " ax2.plot(hdf['Day of Year'], hdf['USDperday'], color= colour_list[year_list.index(y)], alpha=0.3)\n", " else:\n", " ax2.plot(hdf['Day of Year'], hdf['USDperday'], color = '#48C38D', linewidth=3.0)\n", "\n", " ax2.plot(hdf['Day of Year'], hdf['USDperdayMin'], color = '#48C38D', alpha=0.1)\n", " ax2.plot(hdf['Day of Year'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.1)\n", " ax2.fill_between(hdf['Day of Year'], hdf['USDperdayMin'], hdf['USDperdayMax'], color = '#48C38D', alpha=0.2)\n", "\n", "\n", "ax2.set_title('Yearly Comparison of Spark25S')\n", "plt.xlabel('Price Release Date')\n", "plt.ylabel('USD per day')\n", "plt.legend(year_list)\n", "\n", "# Setting custom x-axis ticks location and labels.\n", "xlabels = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Year End']\n", "#xlabels = ['January', 'March', 'May', 'July', 'September', 'November', 'Year End']\n", "\n", "# xpos gives the first day of every other month in terms of 'day of year'\n", "xpos = [1,32,60,91,121,152,182,213,244,274,305,335, 365]\n", "#xpos = [1,60,121,182,244,305,365]\n", "\n", "plt.xticks(xpos, xlabels)\n", "\n", "current_values = plt.gca().get_yticks()\n", "plt.gca().set_yticklabels(['$ {:,.0f}'.format(x) for x in current_values])\n", "\n", "\n", "sns.despine(left=True, bottom=True)\n", "plt.grid(True)" ] }, { "cell_type": "code", "execution_count": null, "id": "e9cee9a6", "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.5" } }, "nbformat": 4, "nbformat_minor": 5 }