{ "cells": [ { "cell_type": "markdown", "id": "59d19f73", "metadata": {}, "source": [ "# US Arb Freight Breakevens vs Spot Freight Rates\n", "\n", "This script is used to compare the US Arb Freight Breakevens with Spark30S Spot Freight Rates.\n", "\n", "For a full explanation of how to import our Arb Breakevens or Spark30S data, please refer to our Python Jupyter Notebook Code Samples:\n", "\n", "https://www.sparkcommodities.com/api/code-examples/jupyter.html\n", "\n" ] }, { "cell_type": "markdown", "id": "b0a05be4", "metadata": {}, "source": [ "### 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__" ] }, { "cell_type": "markdown", "id": "9e00ae34", "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": 21, "id": "705cbb25", "metadata": {}, "outputs": [], "source": [ "# Importing libraries for calling the API\n", "import json\n", "import os\n", "import sys\n", "import pandas as pd\n", "from base64 import b64encode\n", "from urllib.parse import urljoin\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\")" ] }, { "cell_type": "code", "execution_count": 22, "id": "1161e807", "metadata": {}, "outputs": [], "source": [ "# Defining functions for API request\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", " 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", " \"\"\"\n", " OAuth2 authentication requires a POST request with client credentials before accessing the API. \n", " This POST request will return an Access Token which will be used for the API GET request.\n", " \"\"\"\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, format='json'):\n", " \"\"\"\n", " After receiving an Access Token, we can request information from the API.\n", " \"\"\"\n", " url = urljoin(API_BASE_URL, uri)\n", "\n", " if format == 'json':\n", " headers = {\n", " \"Authorization\": \"Bearer {}\".format(access_token),\n", " \"Accept\": \"application/json\",\n", " }\n", " elif format == 'csv':\n", " headers = {\n", " \"Authorization\": \"Bearer {}\".format(access_token),\n", " \"Accept\": \"text/csv\"\n", " }\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", " # Storing response based on requested format\n", " if format == 'json':\n", " content = json.loads(resp_content)\n", " elif format == 'csv':\n", " content = 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:netbacks,read:access,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\"]" ] }, { "cell_type": "code", "execution_count": 23, "id": "ada4f167", "metadata": {}, "outputs": [], "source": [ "# Define the function for listing all netbacks\n", "def list_netbacks(access_token):\n", "\n", " content = do_api_get_query(\n", " uri=\"/v1.0/netbacks/reference-data/\", access_token=access_token\n", " )\n", "\n", " print(\">>>> All the routes you can fetch\")\n", " tickers = []\n", " fobPort_names = []\n", "\n", " availablevia = []\n", "\n", " for contract in content[\"data\"][\"staticData\"][\"fobPorts\"]:\n", " tickers.append(contract[\"uuid\"])\n", " fobPort_names.append(contract[\"name\"])\n", "\n", " availablevia.append(contract[\"availableViaPoints\"])\n", "\n", " reldates = content[\"data\"][\"staticData\"][\"sparkReleases\"]\n", "\n", " dicto1 = content[\"data\"]\n", "\n", " return tickers, fobPort_names, availablevia, reldates, dicto1" ] }, { "cell_type": "markdown", "id": "b46f962b", "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. Instructions for downloading your credentials can be found here:\n", "\n", "https://www.sparkcommodities.com/api/request/authentication.html" ] }, { "cell_type": "code", "execution_count": null, "id": "3acdfe86", "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.eyJ0eXBlIjoiYWNjZXNzVG9rZW4iLCJzdWIiOiIwMWMyMzU5MC1lZjZjLTRhMzYtODIzNy1jODljM2YxYTNiMmEiLCJzdWJUeXBlIjoib2F1dGgtY2xpZW50IiwiZXhwIjoxNzU3NDI5OTUwLCJoYXNoZWRTZWNyZXQiOiJwYmtkZjJfc2hhMjU2JDYwMDAwMCRoTXRMNDlrMUZUaVVzTE42Njlqc2pPJHVCSXNxcml5b1NHVzJTS1AvaHVLNHh3eTZ4d3VDN001aUdGRm43N2l4S1U9Iiwib3JnVXVpZCI6IjQ5MzhiMGJiLTVmMjctNDE2NC04OTM4LTUyNTdmYmQzNTNmZiIsImNsaWVudFR5cGUiOiJvYXV0aC1jbGllbnQifQ.lfXNaKkcYdx9zEOgAhBDd4E2zyY5a4RI-Ik2t1UDVwY\n" ] } ], "source": [ "# Input the path to your client credentials here\n", "client_id, client_secret = retrieve_credentials(file_path=\"/tmp/client_credentials.csv\")\n", "\n", "# Authenticate:\n", "access_token = get_access_token(client_id, client_secret)\n", "print(access_token)" ] }, { "cell_type": "markdown", "id": "7adcc5ed", "metadata": {}, "source": [ "### Fetching Netbacks reference data" ] }, { "cell_type": "code", "execution_count": 25, "id": "aaefce45", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>>> All the routes you can fetch\n" ] } ], "source": [ "# Fetch all contracts:\n", "tickers, fobPort_names, availablevia, reldates, dicto1 = list_netbacks(access_token)\n", "\n", "# Define formatting data function\n", "def format_store(available_via, fob_names, tickrs):\n", " dict_store = {\n", " \"Index\": [],\n", " \"Ports\": [],\n", " \"Ticker\": [],\n", " \"Available Via\": []\n", " }\n", " \n", " c = 0\n", " for a in available_via:\n", " ## Check which routes have non-empty Netbacks data and save indices\n", " if len(a) != 0:\n", " dict_store['Index'].append(c)\n", "\n", " # Use these indices to retrive the corresponding Netbacks info\n", " dict_store['Ports'].append(fob_names[c])\n", " dict_store['Ticker'].append(tickrs[c])\n", " dict_store['Available Via'].append(available_via[c])\n", " c += 1\n", " # Show available Netbacks ports in a DataFrame (with corresponding indices)\n", " dict_df = pd.DataFrame(dict_store)\n", " return dict_df\n", "\n", "# Run formatting data function\n", "available_df = format_store(availablevia,fobPort_names,tickers)" ] }, { "cell_type": "markdown", "id": "e447d6b2", "metadata": {}, "source": [ "## Fetching Netback UUID for an individual port" ] }, { "cell_type": "code", "execution_count": 26, "id": "a4480909", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "003dec0a-ce8f-41db-8c24-4d7ef6addf70\n" ] } ], "source": [ "# Choose route ID and price release date\n", "\n", "# Here we define which port we want\n", "port = \"Sabine Pass\"\n", "ti = int(available_df[available_df[\"Ports\"] == port][\"Index\"])\n", "my_ticker = tickers[ti]\n", "my_via = 'cogh'\n", "\n", "print(my_ticker)" ] }, { "cell_type": "markdown", "id": "2d1bf4c0", "metadata": {}, "source": [ "## Data Import \n" ] }, { "cell_type": "code", "execution_count": 27, "id": "eb563eb4", "metadata": {}, "outputs": [], "source": [ "from io import StringIO\n", "\n", "def fetch_breakevens(access_token, ticker, via=None, breakeven='freight', start=None, end=None, format='json'):\n", "\n", "\n", " query_params = breakeven + '/' + \"?fob-port={}\".format(ticker)\n", "\n", " if via is not None:\n", " query_params += \"&via-point={}\".format(via)\n", " if start is not None:\n", " query_params += \"&start={}\".format(start)\n", " if end is not None:\n", " query_params += \"&end={}\".format(end)\n", "\n", " uri = \"/v1.0/netbacks/arb-breakevens/{}\".format(query_params)\n", " print(uri)\n", " content = do_api_get_query(\n", " uri=\"/v1.0/netbacks/arb-breakevens/{}\".format(query_params),\n", " access_token=access_token, format=format,\n", " )\n", " \n", " if format == 'json':\n", " my_dict = content['data']\n", " else:\n", " my_dict = content.decode('utf-8')\n", " my_dict = pd.read_csv(StringIO(my_dict))\n", "\n", " return my_dict\n" ] }, { "cell_type": "code", "execution_count": 28, "id": "30d317eb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/v1.0/netbacks/arb-breakevens/freight/?fob-port=003dec0a-ce8f-41db-8c24-4d7ef6addf70&via-point=cogh\n" ] } ], "source": [ "# Fetching data in CSV format\n", "\n", "## Calling that function and storing the output - JSON version\n", "break_df = fetch_breakevens(access_token, my_ticker, via=my_via, breakeven='freight', format='csv')\n", "\n", "break_df['ReleaseDate'] = pd.to_datetime(break_df['ReleaseDate'])\n", "break_df = break_df.rename(columns={'ReleaseDate': 'Release Date'})" ] }, { "cell_type": "code", "execution_count": 29, "id": "7a80e89c", "metadata": {}, "outputs": [], "source": [ "length = len(break_df['Release Date'].unique())" ] }, { "cell_type": "markdown", "id": "de4957ed", "metadata": {}, "source": [ "# Fetching Spot Freight Prices" ] }, { "cell_type": "code", "execution_count": 30, "id": "08ec1036", "metadata": {}, "outputs": [], "source": [ "def fetch_historical_price_releases(access_token, ticker, limit=4, offset=None, vessel=None):\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", " print(\"/v1.0/contracts/{}/price-releases/{}\".format(ticker, query_params))\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": "code", "execution_count": 31, "id": "64897525", "metadata": {}, "outputs": [], "source": [ "import datetime\n", "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", "\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", "\n", "\n", "\n", " ## Storing values in a Pandas DataFrame\n", "\n", " historical_df = pd.DataFrame({\n", " 'Release Date': release_dates,\n", " 'ticker': ticker,\n", " 'Period Start': period_start,\n", " 'USDperday': usd_day,\n", " 'USDperdayMax': day_max,\n", " 'USDperdayMin': day_min})\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", "\n", " historical_df['Release Date'] = pd.to_datetime(historical_df['Release Date'])\n", " \n", " return historical_df" ] }, { "cell_type": "code", "execution_count": 32, "id": "efcb7515", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/v1.0/contracts/spark30s/price-releases/?limit=1007&vessel-type=174-2stroke\n", "freight_df columns: ['Release Date', 'ticker', 'Period Start', 'USDperday', 'USDperdayMax', 'USDperdayMin']\n" ] } ], "source": [ "freight_ticker = 'spark30s'\n", "\n", "spark30_174 = fetch_prices(freight_ticker, length, my_vessel='174-2stroke')\n", "\n", "print(\"freight_df columns:\", spark30_174.columns.tolist())" ] }, { "cell_type": "markdown", "id": "3567b011", "metadata": {}, "source": [ "# Plotting" ] }, { "cell_type": "code", "execution_count": 33, "id": "1fd3546a", "metadata": {}, "outputs": [], "source": [ "# fetch front month breakevens only\n", "front_df = break_df[break_df['LoadMonthIndex']==\"M+1\"]" ] }, { "cell_type": "code", "execution_count": 34, "id": "6c736ee6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "sns.set_style(\"whitegrid\")\n", "\n", "fig, ax = plt.subplots(figsize=(15,7))\n", "\n", "ax.plot(spark30_174['Release Date'],spark30_174['USDperday'], color = '#48C38D', linewidth=2.5, label='Spark30S (Atlantic)')\n", "ax.plot(front_df['Release Date'],front_df['FreightBreakeven'], color='#4F41F4', linewidth=2, label='US Arb [M+1] Freight Breakeven Level')\n", "\n", "ax.set_xlim(datetime.datetime.today() - datetime.timedelta(days=380), datetime.datetime.today())\n", "ax.set_ylim(-100000, 120000)\n", "\n", "plt.title('Spark30S (Atlantic) vs. US Arb [M+1] Freight Breakeven Level')\n", "\n", "sns.despine(left=True, bottom=True)\n", "plt.grid(True)\n", "plt.legend()" ] }, { "cell_type": "markdown", "id": "e5002787", "metadata": {}, "source": [ "## Plotting with Conditional Shading" ] }, { "cell_type": "code", "execution_count": 35, "id": "76361e74", "metadata": {}, "outputs": [], "source": [ "spark30_174['Release Date'] = pd.to_datetime(spark30_174['Release Date'])\n", "merge_df = pd.merge(spark30_174, front_df, left_on='Release Date', right_on='Release Date', how='inner')" ] }, { "cell_type": "code", "execution_count": 36, "id": "328faa9b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABPMAAAJZCAYAAADMN3AcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3yNZ+PH8c99sgcZQkLsvYmR2Fu1VaNK26ceSnf5dQ+UUlVtdVf70IkOqkUpVWp0UFW1964VIwkZssc55/fHaU5yJEjIlO/79crLufd1n3M5cX9dw7BarVZERERERERERESkxDMVdwFEREREREREREQkbxTmiYiIiIiIiIiIlBIK80REREREREREREoJhXkiIiIiIiIiIiKlhMI8ERERERERERGRUkJhnoiIiIiIiIiISCmhME9ERERERERERKSUUJgnIiIiIiIiIiJSSijMExERkSuyWq035LVESjv9fRERESmbFOaJiEipcOjQIZ566ik6duxI06ZN6dSpE08++ST79u0r0nKMHTuWHj16XHGf8PBwnnjiCdq1a0fr1q0ZPXo0x44dy7HfDz/8QN++fWnevDl9+vRhwYIFOfY5ffo048ePp2vXrjRt2pR27drx8MMP89dff+W5zFOmTOHdd9/NsX7jxo00aNCAW2+9NdfjLl68yJgxY9iyZYt93bBhwxg2bFier51X586d4+GHH+b06dP2dT169GDs2LF5PsczzzzDZ599VuBlu1ZXqyu5vZcF8Xk///zzNGjQgE8++STPx4SHh9OgQQO+//77PB8DsGnTJho0aGD/ycjI4IMPPqBBgwY0a9aMhISEXI/75ptvaNCgwVX/Ll3N2rVradCggcO6Z5991l6eK9WfS8t+6c+IESOuq2yA/b0o6GPS0tJ47bXXWLZs2RX369Gjh8M9NWzYkLCwMB555BEOHDiQr3Jdr8L67ihK1/J5FqaSVh4RESk6zsVdABERkas5fPgwd911F82bN2f8+PEEBARw7tw5vv76a+666y6++uorWrZsWdzFBCAhIYH77rsPJycnXnrpJVxdXZkxYwbDhg3jxx9/xNfXF4AVK1YwZswYhg8fTufOnVmzZg0TJkzAzc2N/v37AxAVFcVdd91FpUqVeOqpp6hSpQrR0dEsWLCAESNGMH36dG666aYrluevv/5i1apV/Pzzzzm2LVq0iPr163Po0CH+/vtvQkNDHbbv37+fJUuWMGjQoIJ5c67gzz//5LfffuPFF1+0r/vwww/x9vbO8zmef/55+vXrR/fu3alTp05hFLNQFcTnnZCQwKpVq6hfvz7fffcdDz74IIZhFHrZJ06cSJMmTXB2zvqnZUZGBmvXrmXAgAE59v/pp5+u+5obN27k2WefzbH+8ccf57///S//93//l6fzZJb9UuXKlbvuMg4ZMoTOnTtf93kuFRkZyZw5c3jttdeuum/Xrl0ZNWoUYPtMIiMjmTVrFvfeey8//fQTFSpUKPDyiYiISOFSmCciIiXe7Nmz8fX15bPPPsPFxcW+vlevXtxyyy3MmDEjX62QCtOKFSs4ceIEy5cvp27dugDUr1+fnj17snLlSu6++24A3nvvPfr06cMLL7wAQOfOnYmLi+ODDz6wh3nfffcdFy9eZMWKFQ7BQu/evRkyZAjvv//+VcOd1157jeHDh+Pp6emwPj4+ntWrVzNhwgTmzJnD/Pnzc4R5xa1x48b52j8wMJBbb72Vt956i5kzZxZSqQpPQXzey5cvx2w2M2HCBIYPH84ff/xRKGHSperWrZsjUG/VqhUrVqzIEeZFRESwZcsWGjVqxMWLF3M937BhwwgODub111/PsS0hIYGPP/6Yzz//nHLlypGUlOSwvXr16lSvXh1XV9drLntBCQoKIigoqFDOnVf+/v457q9Zs2b06tWLlStXMnTo0OIpmIiIiFwzdbMVEZES7/z580DO8aE8PT0ZN24ct9xyi33dsGHDGDt2LB9//DEdO3akVatWPProo5w6dcrh2DVr1nDPPfcQEhJC06ZNufnmm/n666/t2zO74M2fP5/u3bvToUMH/vjjjxxl27dvH23atOH+++8nLS2NPn36MH/+fHuQB9gDyLS0NMDWpfH48eM5gpk+ffpw8uRJe5fc8+fPYxgGFovFYT8nJyeeeeYZ7rzzziu+b7/99hsHDx7ktttuy7Htxx9/JC0tjS5dutC/f39WrVpFdHS0w/0PHz4cgOHDh1+2e1x0dDSTJ0+me/fuNG3alNDQUEaPHk14eLh9n2HDhjF+/Hg++eQTunXrRrNmzbj77rvZuXMnAN9//z3jxo0DoGfPnvaukZd2s01MTOS1116jS5cutGzZkkGDBvHLL784lKd///78+uuvHDp0KNfyLlu2jAYNGuToYvj777/ToEEDdu3aBcBXX33FzTffTLNmzejcuTMvvfTSZbuMFpTr/bzB1toyLCyMsLAwatWqxfz583PsM2zYMJ599lkef/xxWrVqxUMPPWTfFhERwcMPP0zz5s3p2rUr06dPx2w2X9P93HrrrWzYsIH4+HiH9StXrqRWrVo0bNjwms67cOFCFi5cyMSJE/nvf/97TefIj++//57GjRuzYMECOnXqRJcuXTh8+DBg+x4ZNGgQzZo1o2PHjrzyyisO4WJu3SA///xzevbsSfPmzbn77rv55ZdfaNCgAZs2bXLY77fffqN///40a9aMPn36sGTJEsD2/dGzZ08Axo0bd01dlTNbCGfXo0cPXn31Ve69915atWrFxIkTAYiNjWXixIl06NCBZs2aceedd7Jx40aHY/PyPXCp9evX07RpU8aNG2f/bj9z5gxPP/00oaGhtGjRgnvvvddhKIU+ffowevToHOcaMmSIQz3Oy+fSu3dvfvvtN/r160fTpk3p06cPixcvztsbeBVFdR8iIlJ2KcwTEZESr1u3bpw5c4a7776buXPncvToUfvD380338ztt9/usP/atWtZtGgR48eP5+WXX+bAgQMMHz7c/hD022+/MXr0aJo0acKMGTP44IMPCA4OZsqUKWzbts3hXO+++y5jxoxhzJgxOVq3HD16lPvvv5/mzZszY8YMXF1dKV++PCEhIYAtvDtw4ABjx47Fz8/PHjoePXoUgJo1azqcr0aNGgAcP37cft8pKSnceeedfP755+zbt88erHTs2JF77733iu/b0qVLadmyJZUrV86xbdGiRXTo0IHAwEAGDhyIxWJh4cKF9u1NmjSxP8xPnDiRSZMm5TiH1Wrl4YcfZsOGDTzzzDN8/vnnjBo1ij///NN+bKaff/6ZtWvXMmHCBN555x3Onz/P448/jtlsplu3bjz66KOArWttZpfA7CwWCw888ACLFy/moYceYubMmdSvX5//+7//cwhBQkJCCAwM5Mcff8z1PenduzdeXl4sX77cYf2PP/5IrVq1aN68OcuXL2fatGkMHTqUzz//nNGjR/PDDz/wyiuvXO6tLhDX+3kfPXqUnTt32v8+DBo0iF9//ZWIiIgc+65YsQIXFxf+97//2UNbsIUc/v7+/O9//+OOO+7go48+Yvr06dd0P3369MFsNrN27VqH9T/99BN9+/bNsX9GRob9x2q1YrVa7cvZA8UePXrwyy+/2Fu5Xi+LxeJw7UuvB2A2m/noo4945ZVXePLJJ6lbty7Lli1j9OjR1K5dm//973/83//9H0uXLmXUqFGXnZjiww8/5K233rK3KG7RogVPPfVUrvtOnDiRESNGMHPmTCpVqsTYsWM5cOAAlSpV4sMPPwTg0Ucftb++nOzvY1paGmfOnGHq1KkEBAQ4/EcIwNy5c2nQoAEffPABAwYMIDU1lXvvvZe1a9fy1FNP8eGHHxIUFMQDDzxgD/Ty8z2QafPmzfzf//0fffv2ZerUqRiGQXR0NHfffTd79+7lxRdf5O2338ZisTB06FD7d+aAAQNYt26dQ7B+8uRJdu3aZW8BmtfPJSoqipdffpnhw4fzySefULVqVcaOHWu/1rUq6vsQEZGySd1sRUSkxLvnnnuIiori888/5+WXXwbAz8+PTp06MWzYMFq0aOGwf1JSEosWLaJ69eoA1K5dm9tvv53FixczdOhQjhw5wsCBAxk/frz9mJCQEMLCwti8eTOtWrWyr7/77ru5+eabc5Tp1KlTjBgxggYNGjBjxgzc3Nxy7PPwww/z559/YjKZmDx5MhUrVgSwt1S6dDw4Ly8vAPsDXteuXZk4cSLvvPMOb7zxhv2Y9u3bc/fdd9OpU6crvm9//fVXrqHJ4cOH2b17t31SjMDAQDp27Ogwxpq3t7e9dWHdunUdWhpmioyMxMPDgzFjxtCmTRsAwsLCCA8Pz9EiLCMjg88//9x+z4mJiYwZM4b9+/fTtGlT+2fVqFEjqlatmuNa69atY9u2bcyYMcPeKqldu3acOHGCv/76i7CwMAAMw6Bp06Y5Wg5lcnd3p0+fPvz0008888wzAKSkpLB27VoefPBBwNYqMTg4mKFDh2IymQgNDcXT05OYmJgrvd3X7Xo/74ULF1K+fHl69eoFwMCBA3nvvfdYsGBBjvHjTCYTU6ZMsXe/zmxB1b59e/s4bJ07dyYhIYEvv/yS++67Dx8fn3zdT0BAAG3btmXlypUMHDgQsE3wsXPnTqZNm8ZHH33ksP+l49Zt3rzZ3hotODjY3gozs64UlNwmuqhevTqrV692WPfII4/QrVs3wBZgvfXWW3Tu3Jm33nrLvk/NmjUZMWIEv//+u33fTElJSXz66acMHTrUPtZfp06dSE5O5ttvv81RhldeeYUuXboAUK1aNW666Sb+/vtvGjZsSKNGjezlvFp39CVLltjfx0yGYfDmm2/i7+/vsD4zNDSZbP/f/91333HgwAG+++47+/dsly5dGDZsGG+99RaLFi3K1/cAwK5du3j44Ye56aabeO211+zX+uKLL4iNjeWbb74hODjYfq1bb72V999/n+nTp9O/f3+mT5/O6tWr7aH1smXL8PLyomfPnvn6XJKTk5k6dSrt27e379O9e3d+//336xpzs6jvQ0REyiaFeSIiUio88cQTjBgxgvXr17Nx40Y2bdrEsmXL+PHHHxk3bpxDq6WQkBCHB/7GjRtTrVo1tmzZwtChQ3nggQcA28N1ZrfW3bt3A5Cenu5w3dxmCkxMTGTEiBFERUUxd+5c3N3dcy3z6NGjefjhh1mzZg0vvvgi0dHRPPLII/ZulJdOTJDZ2iLz4RZg6NChDBo0iD/++IONGzfy999/s3r1alavXs3IkSMvO1tncnIyFy5cyDUYW7hwIV5eXoSGhtrHLLv55pt54YUX8jXGWmBgIF9++SVg61Z24sQJjh49yrZt23K8j3Xr1nUILwMDA+3lzIstW7bg4uJC9+7d7esMw+Cbb77JsW9wcHCOFpbZ9e/fn++//56dO3fSokULfvnlF5KSkujXrx9gCwm//fZbBg0axE033US3bt3o169fvieSuJaJJ671887IyGDp0qX06tWL1NRUUlNTcXd3JywsjAULFvDoo4/i5ORk379q1ao5xlEEcsxsfNNNN/HFF1+wY8cOunbtmu/7ufXWW5kyZQrx8fGUK1eO5cuX06RJkxytUgGHlqGTJk2iUqVK9q6IeR3/7lpMnjw5R5CYWzhfv359++t//vnHPgNzRkaGfX3btm3x9vZmw4YNOcKWHTt2kJKSkuM/B2677bZcw7zMYAxsYR5w2TEGr6R79+7299FqtRIdHc2KFSt49tlnSU5Odui+XadOHYfvn40bN1KxYkWaNGnicJ/du3fnjTfeIC4uLl/fA2fOnOHBBx/EarUyadKkHNdq1KgRgYGB9muZTCa6dOnC0qVLAVu9bd26NcuXL7eHYMuXL6dPnz64u7tz9OjRfH0u2VtbZ45teL3dWIvjPkREpOxRmCciIqWGj48Pt912m30MuH379vH888/z1ltv0b9/f/z8/ABb65JLVahQwf4gHB0dzaRJk1izZg2GYVCjRg1at24N5ByXL7eZHmNjY6lVqxYJCQm88cYbl+3mlvkw3q5dOy5evMjMmTN54IEHKF++PECOMdgyHyIvbbHn4eFB79696d27NwAnTpxg/PjxzJ49m0GDBjmEDJky7/XSwCY9PZ2lS5eSmJhIx44dcxw3f/78fE2YsHTpUt555x3Onj2Lr68vDRs2zDXc9PDwcFjOfIi/dHy4y4mNjcXX19fh4f9yPDw8cozTll27du2oXLkyy5cvp0WLFvz444+0adPGHnzeeuutWCwW5s2bx4cffsj7779PcHAwzzzzTK4tHa9UjsxxEnOTlpaW69hl1/J5//bbb5w/f57vv/+e77//Psf2X3/91d5iD2yt5nJz6frMlltxcXGXvY8ruemmm3j55ZdZs2YNt99+OytWrLCHppdq1qyZ/bWXlxe+vr4O6wpLrVq18nSd7N8FsbGxgC0InDx5co59IyMjc6zLHJPy0tZwl/sssv/dzaz319K9Mrf3sVu3bkRGRvLmm29yxx132IPeS8sSGxtLVFRUrrP9gq2rqo+PT56/B8LDw+nUqRObNm3igw8+sI+VmXmtEydOXPZaycnJeHh4MHDgQF566SViYmI4d+4cR48edRjfD/L+uWT/Xrqe9zi74rgPEREpexTmiYhIiRYREcEdd9zBE088wZAhQxy2NW7cmCeffJLRo0dz6tQpe5iX+SCU3fnz5+2t9Z599lmOHj3K7NmzadWqFa6uriQnJ7NgwYI8lcnX15fPP/+c5cuX8+KLL7Jq1Sr7ZBa7du0iPDw8RwunZs2a8cMPPxATE0OtWrUAW0iTvYvciRMnAFsrNrPZTO/evRk4cCCPP/64w7lq1KjB+PHjGThwIEeOHMk13Ml8Ly5tyfPrr78SHR3NSy+9RO3atR22fffdd6xYsYKIiAh7y7kr2bJlC2PGjOG///0v999/v71lyxtvvMHWrVuvenx+lCtXjtjYWCwWi0Ogt3//fjIyMhzCiosXL9rvPzeGYdCvXz9++OEHRo8ezbp163KMCZgZGsfHx/PHH3/w6aef8txzz9GmTZs8vTdgC0ZiY2NJS0vLtWXZuXPn7N2Xr/fzXrhwIcHBwfYustk9/vjjzJ8/3yHMu5xL60vm5DO5hdp54efnR7t27Vi5ciUhISHs37+/VM40fKnMQP7555/PdRbo3LokZ/79iI6Odvi7l33imaLUsGFD/vzzT2JiYi4bKJYrV46aNWs6dPXMrmrVqvn6HqhXrx4ff/wxH3zwAZ9++il9+/alefPm9muFhoby/PPP53qtzL9DN998M1OmTGH16tWcOHGCypUr2z+Da/lcCtqNch8iIlKyaQIMEREp0QICAnB2dmbevHmkpqbm2P7PP//g5uZmnzwCYPv27Q4PyHv37iU8PNw+NtLWrVvp06cP7dq1sz9YrVu3DshbSzEvLy+8vLwYMmQIISEhvPzyy/YQ5Ndff+XZZ5/lzJkzDsesX7+eihUrUqFCBWrUqEG1atX4+eefHfb5+eefqVmzJsHBwTg5OVGpUiUWLVqU61htmTPe5hbsgO2BsWLFipw9e9Zh/aJFi6hUqRJ33XWXfdbTzJ97770Xs9lsDzWzd8vMzfbt27FYLDz++OP2B3iz2cyff/4J5L3VHXDVFndt2rQhPT2d33//3b7OarUyfvz4HOHQ2bNn7WNVXc6AAQOIiIjggw8+wDAMh66PTz75pH2MuXLlynHLLbcwatQozGZzvlrEhIaGkp6ezpo1a3Js27lzJ+fOnaNdu3YA1/V5nz9/nvXr19O3b98cn2lYWJh9VtlLZ3TOzfr16x2Wly9fjoeHR45xKfMj8/oLFiygTZs29rpSmtWuXZsKFSoQHh5Os2bN7D9BQUG8/fbbDjOXZmrYsCHlypVj1apVDusv/R7Ii6v93cyLnTt34uPjc8XgOzQ0lLNnz1KhQgWH+9y4cSOfffYZTk5O+foe8PPzw9nZmUcffZQqVaowfvx4e1fc0NBQjh07Zm8pmfmzdOlSFixYYL/ncuXK0b17d9auXcvKlSvp16+f/fvjWj6Xgnaj3IeIiJRsapknIiIlmpOTEy+99BKjR4/mjjvuYOjQodSpU4fk5GQ2bNjA3LlzeeKJJxxaKiQnJ/Pggw/y6KOPkpiYyLvvvkv9+vXt3XObN2/OsmXLaNKkCUFBQWzfvp2PP/4YwzDyPIYb2Fp4TZ48mUGDBjFt2jSmTp3Kf/7zH7777jsefvhhRo0ahaenJ0uWLOH333/nrbfesj+sjRo1inHjxuHr62ufnXPFihX2SSkAJkyYwLBhwxg0aBDDhw+nUaNGWCwWNm/ezJw5c7j77rtznZgiU8eOHR3GjouMjGT9+vUMGzYs1/CsefPm1KlTxz7GWrly5QBbF04fHx8aNmyYY3+Al19+mTvuuIOLFy/y9ddfc+DAAcDWbfjSLsOXk9kSZfXq1XTp0iXHAPTdunUjJCSEcePG8cQTT1CjRg2WLVvGoUOHePHFF+37Wa1Wtm/fzrBhw654vbp169KkSRPmzZtH79697fcKtm64kyZNYtq0aXTp0oWLFy/y4YcfUrNmTft7cPLkSaKjo3PMcJxdmzZt6NGjB+PGjePo0aO0adMGk8nEvn37+Oyzz2jdurVDC85r/bwXL15MRkbGZbsA33777cybN4/vvvvOPunH5axatYrAwEA6dOjAH3/8wbfffssTTzyR588xN71792bSpEl88cUXDpPOXMlXX311zdcrCk5OTjz11FNMnDgRJycnunfvzsWLF5kxYwYRERG5drH09vbmgQceYPr06Xh4eBAaGsrff/9tH/cxL13IM2XW140bN1KnTp0rhq3R0dHs2LHDvpycnMySJUvYunUrTz/99BWDwUGDBvH1118zcuRIHnnkESpXrsyff/7Jp59+yn//+19cXFyu6XvA3d2dF198kYceeohPP/2UUaNGMWLECH744QdGjBjBfffdh5+fHz/99BPfffedQ3dcsE3uMnr0aMxmM/3797evv5bP5VrMmTMnxzpvb28GDx5cqu5DRERKL4V5IiJS4nXr1o3vvvuOzz//nI8++ojo6GhcXV1p3Lgx7777rr2La6Y2bdrQrl07e3DQo0cPnn/+eXsrvNdff50pU6YwZcoUwDZD4OTJk1m6dClbtmzJV9kaNGjA8OHDmTVrFrfddhvt27dn3rx5vP3220yZMoWEhAQaN27MJ5984jCBwKBBg0hLS2PWrFksWrSIatWqMW3aNIdwp2nTpixZsoSPP/6Yr7/+mqioKJycnKhbty4vvPACgwcPvmLZ+vTpw7Jly4iMjKRSpUosWbIEs9lsDzVzM3DgQN5++21+/fVXevTowW233cbcuXNZv349P/74o8O+YWFhTJw4kdmzZ7Ny5UoCAgIICwvjww8/ZPTo0WzdujXPkyaEhYXRoUMH3n77bTZu3Mgnn3zisN3JyYlPP/2Ut99+mw8++ICkpCQaNmzIZ599RkhIiH2/Xbt2ERsbm+sMxJcaMGAAe/fudXiIBtsMxunp6cyfP5958+bh7u5O+/btee6553BxcQFgxowZLF68mIMHD17xGtOnT2f27NksX76c2bNnY7FYCA4O5p577uGBBx5wCFKu9fNevHgx9erVyxG2ZmrevDm1a9dm0aJFPPbYY1cs79ixY1m5ciVz5syhYsWKOSaXuRbly5enU6dOrF+/nj59+lzXuUqSIUOG4OXlxWeffca3336Lp6cnrVq14q233rJPWHGphx9+GIvFwrfffsvnn39OixYtePbZZ3nttddynZDkcry9vRk5ciTffvstv/32Gxs2bLjsJCG///67Q4tWT09PatWqxaRJk7jnnnuueB1PT0/mzp3L22+/zZtvvkl8fLx9/Mj77rsPuPbvga5du9KnTx9mzpxJnz59qFOnDvPnz+ftt9/mpZdeIjU1lZo1azJ16tQcdb9z5874+PgQFBREvXr1HLZdy+eSX7l1Zw8ODmbw4MEEBgaWmvsQEZHSy7Be7yivIiIiJUhmi6yS3rKnKFitVgYMGECfPn3ss1ne6MaNG0dcXBwzZswo7qKUCZs2bWL48OF8+eWXhIWFFXdxHPTo0YPQ0FBef/314i4KYJtx+McffyQsLIzKlSvb18+dO5dXXnmFTZs22VuoioiIiFyJxswTERG5QRmGwbPPPss333yTY+bcG9GZM2dYtWoVTzzxRHEXpcw5cuSIQ1fO4nTy5El27NhxxZmEi4Ozs7O9S+mqVavYvHkzX331Fe+++y4DBw5UkCciIiJ5pm62IiIiN7AuXbrQs2dPPv7446uOl1bavfXWWzz00EM0aNCguItS5rz88suAbbIZZ+fi/efl9OnTWbZsWbGW4XI++ugj3nnnHV566SUuXrxIlSpVGDFiBA8//HBxF01ERERKEXWzFRERERERERERKSXUzVZERERERERERKSUUJgnIiIiIiIiIiJSSijMExERERERERERKSUU5omIiIiIiIiIiJQSCvNuEBaLhV27dmGxWIq7KCKFSnVdygLVc7nRqE5LWaB6LmWF6rqURSWt3ivMu0FYrVbS09PR5MRyo1Ndl7JA9VxuNKrTUhaonktZobouZVFJq/cK80REREREREREREoJhXkiIiIiIiIiIiKlhMI8ERERERERERGRUkJhnoiIiIiIiIiISCnhXNwFEBEREREREckLs9lMenp6cRejTDObzQCkpKTg5ORUzKURKTwuLi4lto4rzBMREREREZESzWq1cu7cOWJjY4u7KGWe1WrF2dmZEydOYBhGcRdHpFD5+voSFBRU3MXIQWGeiIiIiIiIlGiZQV6lSpXw9PRUiFSMrFYrycnJeHh46HOQG5bVaiUpKYnIyEgAKlWqVMwlcqQwT0REREREREoss9lsD/IqVKhQ3MUp86xWKxaLBXd3d4V5ckPz8PAAIDIyssR992gCDBERERERESmxMsfI8/T0LOaSiEhZk/m9U9LG6lSYJyIiIiIiIiWeWoGJSFErqd87CvNERERERERERERKCYV5IiIiIiIiIlKiHD9+vFDOazabOXXqVKGcW6SoKMwTERERERERKQRxcXG89NJLdO3alZYtW9KpUyfGjBnDuXPnCu2aPXr04Pvvv8912/79+xk+fDitW7cmLCyM5557jpiYGPv2Y8eOce+99xISEkKnTp346KOPHI7funUr9913H126dKFVq1bcdtttzJo1C6vVesUyrVq1iokTJzqsi4mJoUWLFgwYMCDH/vv27eO2226zL48dO5axY8de9d7z4qmnnmLJkiUAnDlzhpCQEM6cOXPFY9LT07n77rsJDw8vkDKIXC+FeSIiIiIiIiKF4KmnniImJoaFCxeyY8cOlixZQlpaGiNHjiQjI6NIy5KWlsaDDz5IWFgYmzZtYvXq1URFRfH6668DtsDqkUceoVmzZmzatIlPPvmEuXPnsmLFCgBOnTrFyJEjGTBgAGvXrmXLli288sorzJ49m5kzZ172utHR0UybNo0nn3zSYf2CBQvo0qULUVFRbNiwwWFbfHx8oU04kD28rFKlCtu3b6dKlSpXPMbFxYXHH3+cMWPGFEqZRPLLubgLICIiIiIiIpJfZquFY4lRpJiLJhRzd3KmlldFnIy8t4nZunUrU6dOpWLFigAEBATwwgsv8Pbbb3Px4kX8/f3p0aMHgwYNYtmyZURGRtK4cWMmT55M3bp1AVi4cCHz5s3j9OnTpKWlERoaymuvvYa/vz8ffPAB27dvJy4ujlOnTvG///3P4frr16/nySef5JVXXuGWW25h1apVuLu7YzKZiIuLIzk5GX9/fwA2b95MZGQkjz/+OK6urjRu3Jhhw4Yxd+5cbrnlFnbv3o2Liwu33HILGRkZmEwmWrZsybhx467YYu3TTz+lU6dO9usAWCwW5s+fz9ixY6lduzazZs2iY8eOgC00fPDBBwEICQlh1qxZDudLS0vj3Xff5bfffuPcuXO4u7tz6623MmHCBAzDYNiwYbRs2ZJt27axb98+goKCeOyxx7j11lsZP348W7ZsYfv27ezdu5cJEybQs2dP1q5dS9WqVTl16hRTp05l8+bNuLq60qdPH1544QVcXV3p0KEDU6ZM4ffff6dr1655rgMihUFhnoiIiIiIiJQq6RYzz+36loMJhdddNTcNvIN4s/lduJic8rR/3759mTRpElu2bCE0NJQWLVoQHBxsbw2X6dtvv+WTTz6hVq1avPrqqzzyyCOsWLGC/fv388orr/Dll1/SvHlzzp07x7333suXX35pb+m2ceNGZs2aRfPmzXFzc7Of8/fff+fZZ5/lnXfesYdPnp6eANx9991s376dunXrcv/99wNw+PBhatWqhaurq/0cdevW5ZNPPgEgLCwMDw8P7rjjDnr37k1oaCjNmjXj1ltvvez9Z2RksGDBghzddX/55RfMZjM9evSgefPm9OrVi4MHD9KgQQOqVavGp59+yvDhw9m+fbv9/cn0xRdfsH79er744gsqVarE9u3b+e9//0uvXr1o3749AN999x2zZ8+mbt26/O9//2PixIn07NmTqVOncvLkSUJDQ3nsscccQsiMjAzuv/9+wsLCWLduHSkpKdx///188MEHPPPMM/bPc968eQrzpNipm62IiIiIiIiUKhEpcUUe5AEcTDhHREpcnvd/5ZVXmDhxImfPnmXixIn06NGD3r17s3TpUof97r//fho1aoS7uzvjxo3j7NmzbNu2jfr16/Pjjz/SvHlz4uLiiIyMxN/fn4iICPux1apVo3379nh5eeHsbGuv8/vvvzN69GgmT56ca/A0Z84c/v77b+rXr8/IkSMxm80kJibi4eHhsJ+HhwdJSUkAVKhQgR9++IFevXrx66+/2oOvBx988LKTVezdu5fk5GSaN2/usP7rr79m6NChODs7ExQURO/evZkzZ06e3tM777yTOXPmULFiRSIjI0lJScHLy8vhPenTpw+NGzfG1dWV22+/nfj4eC5cuHDF827bto3Tp0/zwgsv4OXlRYUKFfjwww8ZMmSIfZ9WrVqxadOmq44RKFLY1DJPRERERERESpVAdx8aeAcVS8u8QHefPO9vMpkYMGAAAwYMwGq1cvToUX744Qeef/55KlasaG9JVqNGDfsxHh4e+Pr6EhUVhclk4ssvv2TZsmV4enrSoEEDEhISHMKkSpUq5bjuxo0badKkCYsXL8615Zy7uzvu7u5MmDCBDh06cPDgQTw9PUlOTnbYLzk5GS8vL/tyhQoVeOKJJ3jwwQcxDIMdO3bw4Ycfct9997F69WqcnBxbLJ45cwZfX1+H1n5Hjx5l48aN7Nmzh88//xywdZ1NT0/nqaeeyvV+Li3Tyy+/zObNmwkKCqJx48ZYrVYsFot9n8xuzYA94My+PTdRUVH4+fk5BJpVq1Z12CcwMJDk5GRiYmIcug2LFDWFeSIiIiIiIlKquJiceLvF3SV6zLz169fz+OOP8+uvv+Lr64thGNStW5dnnnmGDRs2sG/fPnuYl71VWWJiIjExMVSuXJk5c+awYcMGli1bRkBAAACPPPKIw3UMw8hx7WeeeYZu3brRt29f5s+fb5+Jdfjw4cyfP98emKWlpQHg4+NDvXr1OH78OBkZGfYA7MiRI9SrVw+A5557jrS0NN577z3AFjp26NCBChUq0L9/f+Li4nIEXCaTKUeI9vXXX9O1a1defvllh/UjR47k66+/5umnn77i+zphwgR8fHz4448/cHNzw2Kx0LZt2ysekxdBQUHExMSQnJxsD/S2bNnCnj17GDFiBABmsxkgR2gpUtTUzVZERERERERKHSfDRF3vQJr6BBfJT13vwHxNftG2bVsqVKjAuHHjOHjwIOnp6SQkJLB06VKOHz9Ot27d7PvOnj2bEydOkJyczGuvvUbt2rUJCQkhISEBZ2dnXFxcyMjI4IcffmD9+vVXnenVxcWFwMBAxo0bx7Rp0zh58iTBwcH4+vry2muvkZiYSHR0NJMnT6ZLly4EBwcTFhaGn58fb7/9NqmpqRw4cICvvvqKwYMHA3Dbbbexdu1avvzyS6KiorBarZw5c4ZPP/2Utm3b5tpSrUqVKsTGxpKamgpAQkICS5Ys4c477yQoKMjh584772T+/PkkJSXZx/6Lj4/Pcc6EhATc3NwwmUwkJCTwxhtvkJCQkOfZb11dXXM9b/PmzalZsybTpk0jOTmZ8+fP89prrxEdHW3fJzIyEk9PT3x88t46U6QwKMwTERERERERKWDu7u7MmzePihUr8uijj9KmTRu6devG0qVLmT17NnXq1LHv27p1a0aPHk3Hjh2Jiorik08+wWQycd9991G5cmW6d+9O586dWbp0Kffccw+HDh3KUxnuuOMO2rZty5gxY7BarcyYMYOMjAx69OjBgAEDqFy5Mu+88w5g6446a9YsDh06RMeOHXnooYcYNmwYgwYNAqBr1658/PHH/PbbbwwZMoSWLVtyzz334Ofnx4wZM3K9fuPGjfH19bVPZPH999/j7u6e6zh+AwcOJDk5mYULF1K/fn1at25N586d+f333x32mzBhAgcOHCA0NJSbb76ZhIQEOnfunOf3ZODAgSxatIh77rnHYb2LiwsfffQRERERdOvWjQEDBtC2bVsef/xx+z5bt26lc+fOebqOSGEyrBq58YZgNpvZsWMHLVu2VJNfuaGprktZoHouNxrVaSkLVM8LT0pKCseOHaNWrVq4u7sXd3EKXI8ePfi///s/e2hW0lmtVpKSkvD09My1i++lpk2bRlJSEpMnTy6C0hWuW265hXHjxtGlS5fiLooUkczvn+rVq3PgwIES8x2vlnkiIiIiIiIiUigefPBBfv31V4fuqqXR77//ToUKFRTkSYmgME9ERERERERECoW/vz9jx461d+ctjdLT0/nwww957bXXirsoIoBmsxUREREREREpNr/88ktxF6HQ3Xrrrdx6663FXYxr5uLiwoIFC4q7GCJ2apknIiIiIiIiIiJSSijMExERERERERERKSUU5omIiIiIiIiIiJQSCvNERERERERERERKCYV5IiIiIiIiIiIipYTCPBERERERERGRAnT8+PHiLoLcwBTmiYiIiIiIiBSCHj168P333+dY//3339OjRw/7clxcHC+99BJdu3alZcuWdOrUiTFjxnDu3Lkrnj8mJoYWLVowYMCA6ypPbsLDw2nQoAEtW7Zk6tSp9uUWLVoQHx+fY/9XXnmFBg0a5Pn82c2ePZthw4Y5LIeEhNCgQQM2bdp02Xtp1qwZISEhDj/33Xdfvq8PsHTpUvr27ZunfT/44AOH8l5q7ty5vPjii5fdnr3sLVu2pFWrVgwfPpyDBw/mu9x5NXbsWMaOHVto5y8IV3tfb7TrXg+FeSIiIiIiIiLF6KmnniImJoaFCxeyY8cOlixZQlpaGiNHjiQjI+Oyxy1YsIAuXboQFRXFhg0bCqVsP/74I+PHj7cve3p68vPPPzvsk5aWxvLly/H09MxxfGYImJukpCRef/11Xn/9dYf1I0eOZPv27Vct2+TJk9m+fbvDz6xZs/JyWzn079+f5cuXX9Oxl4qOjr7qPpll37FjBxs3bqRmzZqMGjUKi8VSIGWQG5vCPBEREREREZFitHXrVnr37k3FihUBCAgI4IUXXqBFixZcvHgx12MsFgvz58+nX79+DBkyJEeI9cEHH3Dfffdxxx13EBoayubNmwHYu3cvgwYNIjQ0lPvvvz/f3UH79evHjz/+6LBuzZo1NG7cGD8/v3yda8CAAURFRfGf//wnX8flxbBhwxg7dizdu3enW7duJCQkcPLkSR555BHCwsLo3r077777LmlpaUDO1pJ//vknAwcOpFWrVtx99928+eabDq23EhMTmTBhAp06dSIsLIx3330XgMWLF/Pxxx+zZcsW2rRpk6eyurm5MXToUMLDw4mNjb2m8lutVj755BP69etHmzZtaNu2Lc888wwpKSk5rnf69Gl69uzJq6++itVqJS0tjffff5+ePXsSGhrKgw8+yIkTJwB4//33ufvuux2Of/PNN3nooYcAOH/+PM8++ywdO3akU6dOTJw4kYSEBAA2bdpEjx49mDlzJp07dyY0NJTHHnvMvj2/rnStoUOH8s477zjsP2TIED777DPAVu+HDRtG27Ztuemmm5gzZw5Wq/WaylESOBd3AURERERERETya8NvGXwzJ43kpKK5nocn3DPSlQ5dC/4xum/fvkyaNIktW7YQGhpKixYtCA4OztFiLbtffvkFs9lMjx49aN68Ob169eLgwYMOreA2btzIrFmzaN68OW5uboAtePvkk0+oWbMmr776Kg8//DDLly/H2Tlv99WvXz/mzZvHsWPHqF27NgCLFi3ijjvu4K233nLY7+zZs/aWZpnBVuvWrfn4448B+OqrrwgKCuKDDz7g6NGj+XjH8ubPP/9kwYIFeHh4YDKZGDFiBH379uX9998nOjqaxx9/HIvFwjPPPONwXHh4OI888gjjx4/njjvuYMeOHTzyyCM0atTIvs++ffu49957mTJlCps2bWLEiBF069aN22+/nfDwcP7++2+++uqrPJUzKSmJJUuW0KZNG/z9/a+p/CtWrODLL7/k66+/pmbNmhw9epR77rmHZcuWMWTIEPs5T506xb333svAgQN5/PHHAXj33Xf566+/mDNnDpUqVeLTTz/lvvvu46effmLw4MF89NFHHD9+nJo1a2I2m1m6dCkvvvgiFouFUaNGUbNmTX7++WfS09MZN24cEydOtAdrp0+fJiIigtWrVxMREcHQoUOZN2+ePQzMq6tda8iQIbz33ns8+eSTmEwmjh49yv79+5k5cyYRERHce++9PPXUU8yaNYsTJ04watQo3N3dcwSVpYVa5omIiIiIiEips+TbdMJPWrlwvmh+wk9aWfxteqHcyyuvvMLEiRM5e/YsEydOpEePHvTu3ZulS5de9pivv/6aoUOH4uzsTFBQEL1792bOnDkO+1SrVo327dvj5eVlD+vuu+8+GjRogJubG2PHjiU8PJxdu3bluax+fn507tyZxYsXA3D27Fn27dtHr169HPZbtmwZW7Zssd/Dli1b2LJliz3IAwgKCsrzdXMzefJk2rRp4/CTlJSV7nbp0oXAwEDKly/Pb7/9RlpaGk8//TRubm5UrlyZJ554grlz5+Y477Jly2jUqBF33XUXzs7OtGnThjvvvNNhn3r16jFgwAAMw6Bdu3YEBARw8uTJfJe9devWtGrViq+++op7773XYZ/8lL9Lly4sXLiQmjVrEh0dTUxMDL6+vkRERNjPd/r0aYYNG0aXLl3sQZ7VamX+/Pk8/fTTVKtWDTc3N0aPHk16ejq//fYbwcHBdOjQgSVLlgDwxx9/YDab6d69O3v27GHv3r1MmjQJb29v/Pz8GDNmDMuXLycmJsZ+3dGjR+Pu7k6NGjUICwvj2LFjeX6fMl3tWjfffDOJiYn2MRa///57unbtSkBAAEuXLqVOnToMHToUFxcX6taty/3335/rZ19aqGWeiIiIiIiIlDq33+3CvNlF2zLv9rtc8nWMq6srZrM5x3qz2Yyrq6t92WQyMWDAAAYMGIDVauXo0aP88MMPPP/881SsWJH27ds7HH/06FE2btzInj17+PzzzwHbuHXp6ek89dRTVKpUCcD+Z3ZVq1bNuicPjxyBT17079+fadOm8dRTT/H999/Tt29fh/spKpMmTWLQoEGX3Z79/k+fPk10dDRt27a1r7NaraSnp3PhwgWH486ePUtwcLDDumrVqrF79277sq+vr8P2y33WeSl7WloaK1as4Omnn2b69On27r75Kb+rqyvvvvsuv/76K/7+/jRq1Ij09HSHrqRbtmyhY8eOrF27lqeeegofHx+io6NJSkriiSeewGTKau+Vnp7O6dOnAVt31TfeeIMnnniCxYsXM2DAAFxcXAgPD8dsNtO1a9cc78WpU6fsy5ndxwFcXFyuqXvr1a7VvHlz+vXrx5IlSwgNDWXp0qVMmTLF/t7t3bvXoduzxWLByckp3+UoKRTmiYiIiIiISKnToatzoXR5LUiVK1e2ByLZnThxwh4WrV+/nscff5xff/0VX19fDMOgbt26PPPMM2zYsIF9+/blCPO+/vprunbtyssvv+ywfuTIkXz99dc8/fTTABiGkePakZGR9tcJCQnExMTkCK6upmPHjqSnp7Nx40YWL17Mhx9+mK/ji0r2+w8KCqJ69eqsXLnSvi4hIYELFy44dG0FCA4O5tdff3VYd+bMmUIrp6urKwMGDOCLL75g3bp19jAvP+V/6aWXOHPmDL/88gve3t6AratzdrfeeitvvPEG//nPf5g8eTLvvPMOfn5+uLm5MWvWLFq2bGnf959//iEwMBCAnj17MnnyZNatW8cvv/xib5UZFBSEu7s7mzZtsgdjaWlpnDp1iho1arB169YCe4+udi2AO++8k//85z/07t0bwzDo3Lmz/diwsDB78A22maATExMLrHxFTd1sRURERERERArBgAED+Oabb9iwYQMWi4W0tDTWrVvHggUL7K2y2rZtS4UKFRg3bhwHDx4kPT2dhIQEli5dyvHjx+nWrZvDORMSEliyZAl33nknQUFBDj933nkn8+fPd+hqeqlZs2bxzz//kJyczNSpU2nUqBFNmzbN1305OzvTr18/Xn/9dXx8fGjYsOFl961atSoHDx7M1/kLQ/fu3UlMTOSzzz4jLS2NixcvMmbMGJ566qkcoeeAAQPYv38/S5YswWw2s3PnTr777rs8X8vNzY2EhIQ8t0CzWq38/vvvHDp0yKHlXX7Kn5CQgJubG05OTqSmpjJr1iwOHTpEenpW13AXFxecnJx47bXXWLNmDT/99BMmk4nBgwfz9ttvc+7cOSwWC4sXL+a2226zT4Lh4uLCwIEDmTx5Mk2aNKFOnToANG/enBo1avD666+TmJhISkoKr776KiNGjMhXK8Xs0tLSOHfunMNPbGxsnq7VsGFDateuzauvvsrtt99uD/369evHjh07WLp0KRkZGURGRvLII49ccUzKkk5hnoiIiIiIiEghGDhwIM8++yxvvfUWbdu2JSwsjPfee48XXniBvn37AuDu7s68efOoWLEijz76KG3atKFbt24sXbqU2bNn24OTTN9//z3u7u45uhtmXi85OZmFCxdetky9evXikUceoUuXLsTFxTFjxgyH7pV5NWjQIA4dOsQdd9yR72OLg7e3N3PmzGHTpk106dKFXr16YTKZmDlzZo59g4KCmD59Op9++ilt2rRh2rRpdOrUCReXvHWz7t69O7GxsbRu3fqysxFPmjSJkJAQQkJCaNWqFW+88Qbjxo2z14v8lv/JJ58kJSWFDh060KNHD3bs2MGAAQM4dOhQjnPVqVOHxx57jMmTJxMREcGYMWNo0aIF99xzD23atGHOnDlMnz6dxo0b248ZMmQIp0+fZvDgwfZ1zs7OfPzxx5w/f56bbrqJTp06cfLkSWbPnm2fcCW/duzYQdeuXR1+Jk+enOdr3XnnnZw5c8ahnMHBwXz22Wd8++23dOjQgQEDBlC7du1SHeYZ1tI8F6/Ymc1mduzYQcuWLUt1v2+Rq1Fdl7JA9VxuNKrTUhaonheelJQUjh07Rq1atXB3dy/u4pQZ4eHh9OzZk7Vr1zqMs2e1WklKSsLT0zPXbrwFqUGDBnz55ZeEhYUV6nUudfbsWWJiYhzCrNdff52oqCjefvvtIi2LFK/M75/q1atz4MCBEvMdr5Z5IiIiIiIiIiL/iomJ4Z577mHPnj0AHDhwgKVLl9K9e/diLpmIjcI8EREREREREcnVbbfdxtSpU4v0mrNnzyYkJKRIr5ld48aNGT9+PE8//TQhISE89thjPPTQQ9x2223FViaR7AotzIuOjqZ3795s2rTJvm7nzp0MGTKEkJAQevTowYIFCxyOWbx4Mb1796Zly5YMGjSI7du327eZzWamTZtGhw4dCAkJ4dFHH3WYhefChQuMGjWKNm3aEBYWxtSpU8nIyMjztUVERERERETEJnPiih07djB+/PgivfbIkSPZvn07Bw8eLPIutpmGDBnCqlWr2L59O6tXr2bEiBHFUg6R3BRKmLd161buuusuTp48aV8XFxfHQw89xMCBA9m8eTNTp07ltddeY9euXQBs2rSJKVOm8Prrr7N582b69+/Po48+SnJyMgAzZ85kw4YNLFq0iPXr1+Pu7s6ECRPs53/yySfx9PRk/fr1LFy4kI0bNzJnzpw8XVtERERERERERKQ0KPAwb/HixTz77LM89dRTDutXrVqFr68vQ4cOxdnZmfbt29OvXz/mzp0LwIIFC+jbty+tW7fGxcWFESNG4Ofnx08//WTf/uCDD1K5cmW8vb0ZP34869at49SpU5w4cYK///6b5557Dg8PD6pVq8aoUaPs577atUVEREREREREREoD54I+YadOnejXrx/Ozs4Ogd7hw4epX7++w75169a1T5l95MiRHFNa161blwMHDhAfH8+5c+ccjg8ICMDHx4eDBw8C4OvrS2BgoH17nTp1OHPmDBcvXrzqtfPCYrFQkif+NZvNDn+K3KhU16UsUD2XG43qtJQFqueFx2w2Y7VaS/wzWVmR+Rnos5CyIPN7x2KxADm/44trZtsCD/MqVqyY6/rExEQ8PDwc1rm7u5OUlHTV7YmJiQB4enrm2J657dJjM5czj7/StfNiz549pKen53n/4rJ79+7iLoJIkVBdl7JA9VxuNKrTUhaonhcOk8lEbGysAqQSJHNILJEbWVxcHKmpqRw6dAjI+R3funXr4ihWwYd5l+Ph4UF8fLzDupSUFLy8vOzbU1JScmz38/OzB3GXfllkHm+1WnNsy1z28vK66rXzomnTpiX6F4fZbGb37t00a9as2JJhkaKgui5lgeq53GhUp6UsUD0vXOfOnSMuLg5XV1c8PT0xDKO4i1RmWa1WUlJScHd31+cgNyyr1UpSUhJxcXFUqlSJihUrlqjv+CIL8+rXr8+GDRsc1h05coR69eoBUK9ePQ4fPpxje5cuXfDx8SEwMJAjR47Yu8tGRUURGxtL/fr1sVgsxMbGcv78eQICAgA4evQoQUFBlCtX7qrXzguTqdAm/i1QTk5OJaJiiRQ21XUpC1TP5UajOi1lgep54ahSpQomk4moqKjiLkqZZ7VaSU9Px8XFRWGe3PB8fX0JCgqyd7MtKd/xRRbm9e7dmzfffJM5c+YwdOhQtm7dyrJly5gxYwYAgwcPZvTo0dxyyy20bt2auXPncuHCBXr37g3AoEGDmDlzJs2aNcPPz49XX32V0NBQqlevDtiaNr766qu8/PLLxMTEMGPGDAYPHpyna4uIiIiIiEjJZRgGlStXplKlSqVi+KMbmdls5sCBA9StW7dEhBoihcXFxaXE1vEiC/P8/PyYNWsWU6dOZfr06fj7+zNhwgTatWsHQPv27Zk0aRIvvfQSERER1K1bl08//RRfX18ARo8eTUZGBkOHDiUxMZGwsDDee+89+/mnT5/Oyy+/TM+ePTGZTAwcOJBRo0bl6doiIiIiIiJS8pWUVjFlWeYEAO7u7vosRIqJYS3JA8FJnpnNZnbs2EHLli31hSo3NNV1KQtUz+VGozotZYHquZQVqutSFpW0el86BoITERERERERERERhXkiIiIiIiIiIiKlhcI8ERERERERERGRUkJhnoiIiIiIiIiISCmhME9ERERERERERKSUUJgnIiIiIiIiIiJSSijMExERERERERERKSUU5omIiIiIiIiIiJQSCvNERERERERERERKCYV5IiIiIiIiIiIipYTCPBERERERERERkVJCYZ6IiIiIiIiIiEgpoTBPRERERERERESklFCYJyIiIiIiIiIiUkoozBMRERERERERESklFOaJiIiIiIiIiIiUEgrzRERERERERERESgmFeSIiIiIiIiIiIqWEwjwREREREREREZFSQmGeiIiIiIiIiIhIKaEwT0REREREREREpJRQmCciIiIiIiIiIlJKKMwTEREREREREREpJRTmiYiIiIiIiIiIlBIK80REREREREREREoJhXkiIiIiIiIiIiKlhMI8ERERERERERGRUkJhnoiIiIiIiIiISCmhME9ERERERERERKSUUJgnIiIiIiIiIiJSSijMExERERERERERKSUU5omIiIiIiIiIiJQSCvNERERERERERERKCYV5IiIiIiIiIiIipYTCPBERERERERERkVJCYZ6IiIiIiIiIiEgpoTBPRERERERERESklFCYJyIiIiIiIiIiUkoozBMRERERERERESklFOaJiIiIiIiIiIiUEgrzRERERERERERESgmFeSIiIiIiIiIiIqWEwjwREREREREREZFSQmGeiIiIiIiIiIhIKaEwT0REREREREREpJRQmCciIiIiIiIiIlJKKMwTEREREREREREpJRTmiYiIiIiIiIiIlBIK80REREREREREREoJhXkiIiIiIiIiIiKlhMI8ERERERERERGRUqLIwrylS5cSEhLi8NO0aVOaNm0KwKRJk2jatKnD9m+//dZ+/OLFi+nduzctW7Zk0KBBbN++3b7NbDYzbdo0OnToQEhICI8++iiRkZH27RcuXGDUqFG0adOGsLAwpk6dSkZGRlHduoiIiIiIiIiISIEosjCvf//+bN++3f6zcuVKfH19mTp1KgC7d+9mypQpDvvcddddAGzatIkpU6bw+uuvs3nzZvr378+jjz5KcnIyADNnzmTDhg0sWrSI9evX4+7uzoQJE+zXfvLJJ/H09GT9+vUsXLiQjRs3MmfOnKK6dRERERERERERkQJRLN1srVYrzz33HN26dWPAgAGkpaVx6NAheyu9Sy1YsIC+ffvSunVrXFxcGDFiBH5+fvz000/27Q8++CCVK1fG29ub8ePHs27dOk6dOsWJEyf4+++/ee655/Dw8KBatWqMGjWKuXPnFuUti4iIiIiIiIiIXLdiCfN++OEHjhw5wtixYwE4cOAAGRkZTJ8+nQ4dOtCnTx8++eQTLBYLAEeOHKF+/foO56hbty4HDhwgPj6ec+fOOWwPCAjAx8eHgwcPcvjwYXx9fQkMDLRvr1OnDmfOnOHixYtFcLciIiIiIiIiIiIFw7moL2ixWJg5cyaPPPII3t7eAMTHxxMaGsqwYcN455132L9/P6NHj8ZkMvHAAw+QmJiIh4eHw3nc3d1JSkoiMTERAE9PzxzbM7ddemzmclJSEuXLl89zua1Wa/5vuIiYzWaHP0VuVKrrUhaonsuNRnVaygLVcykrVNelLLpcvXdyciqO4hR9mLdp0yYiIyMZPHiwfV3Hjh3p2LGjfbl58+bce++9/PTTTzzwwAN4eHiQkpLicJ6UlBT8/PzswVzm+HnZt3t5eWG1WnNsy1z28vLKc7n37NlDenp6nvcvLrt37y7uIogUCdV1KQtUz+VGozotZYHquZQVqutSFl1a71u3bl0s5SjyMO/nn3+md+/eDi3p1qxZw/nz57n77rvt69LS0nB3dwegXr16HD582OE8R44coUuXLvj4+BAYGOjQFTcqKorY2Fjq16+PxWIhNjaW8+fPExAQAMDRo0cJCgqiXLlyeS5306ZNS3zLvN27d9OsWbNiS4ZFioLqupQFqudyo1GdlrJA9VzKCtV1KYtKWr0v8jBv69atDB8+3GGd1Wrltddeo0aNGrRr144dO3bw5ZdfMm7cOAAGDx7M6NGjueWWW2jdujVz587lwoUL9O7dG4BBgwYxc+ZMmjVrhp+fH6+++iqhoaFUr14dsCWlr776Ki+//DIxMTHMmDHDoWVgXphMxTK8YL45OTmViIolUthU16UsUD2XG43qtJQFqudSVqiuS1lUUup9kYd54eHhVKpUyWFd7969GTduHC+99BIREREEBATw2GOPMWDAAADat2/PpEmT7Nvr1q3Lp59+iq+vLwCjR48mIyODoUOHkpiYSFhYGO+99579/NOnT+fll1+mZ8+emEwmBg4cyKhRo4rqlkVERERERERERAqEYS3JfUclz8xmMzt27KBly5YlIiUWKSyq61IWqJ7LjUZ1WsoC1XMpK1TXpSwqafW+dPQdFREREREREREREYV5IiIiIiIiIiIipYXCPBERERERERERkVJCYZ6IiIiIiIiIiEgpoTBPRERERERERESklFCYJyIiIiIiIiIiUkoozBMRERERERERESklFOaJiIiIiIiIiIiUEgrzRERERERERERESgmFeSIiIiIiIiIiIqWEwjwREREREREREZFSQmGeiIiIiIiIiIhIKaEwL492xp4s7iKIiIiIiIiIiEgZpzAvj17cu5iNF44UdzFERERERERERKQMU5iXR+lWM6/sX8ZvUQeKuygiIiIiIiIiIlJGKczLBwtW3j38M9FpicVdFBERERERERERKYMU5uVTmsXMsrM7irsYIiIiIiIiIiJSBinMy6Nqbr721z+e3UGyOa34CiMiIiIiIiIiImWSwrw8GlSxmf11QkYqqyL2FmNpRERERERERESkLFKYl0c9/Ori5+xhX15yehtmq6UYSyQiIiIiIiIiImWNwrw8cjU50y+giX35XGocf144UowlEhERERERERGRskZhXj70rdAIN5OzfXnuyY1EpFwsxhKJiIiIiIiIiEhZojAvH8o7u3OTX3378omkCzy8bQ7fnNpEmiWjGEsmIiIiIiIiIiJlgcK8fLqjUnPKObnZl1MtGXx5YgNP7JjLmeSYYiyZiIiIiIiIiIjc6BTm5VOgazneqHMbjT0DHdYfT7rAEzvmsSXmWDGVTEREREREREREbnQK865BTQ9/3qzbj6erdcXH2d2+PsGcysS9i3nn0M+sPLebIwmRBTLjbao5/YacOTf6goWnH0rmsZFJnAm/8e5PRERERERERKSgOV99F8mNyTDo7V+fNuWq8uqJtexJPAeAFVgduZfVkXsB8HByoUn5YJr7VKO5T1XqegfiZOQ9Q/353B4+O/47JkyMrNmJm4OaFcbtFIsvP0nnnyO2EO/tV1J5/QN3XFyMYi6ViIiIiIiIiEjJpTDvOvm5ePJanb58cnojyy7sy7E92ZzOlpjjbIk5DuQv3Pvp3C4+OLLGvvz+kdUcTojgkdrdcTE5Fcr9FJWjh8z8tjoj27KFb2anM/wh12IslYiIiIiIiIhIyaYwrwA4GyZGVe1IM+/K/Hh+H4eTz5NsSc9136uFe5XdfTGAdecP8eHRtTmO/+ncLo4mRtK9YiPqewdSy6si7k4uhXh3uUu3mHE2TBhG/lvSWa1WZn+UlmP94m/TCWnrRLOQggsqrVYrFqz5ag0pIiIiIiIiIlJSKcwrQJ19a9PZtzYWq5UzqXEcSIpkd+JZdiWc5VxafK7HXBru5cXB+HMcjLd16zVhUN3Tn7pelXDPSMctPpC65QJxNTlzNiWWwwkRnE/NuraXsxvt/Ovg5+p1TfeYZsngo39+ZeW53Xg6uVHXuxJ1vSsR6l+b5j7V8nSOLX+Z2bPD1r22UmUrXXpbWfilCasV3nstlfc+86Bc+auHhGarhaSMVOIzUknISCEh25/n0+I5khDJkYQIYtOTqO1ViVuCmtGtYkO8nN2uem4RERERERERkZJIYV4hMBkGVd19qeruSy//+gBEpMWzO8EW7O1OvHy4l5u7KrWkmXdlXj/xCwnmVIdtFqwcT7rA8aQLAPy45wgmDNycXEg252z9BvCp0zqGVe9A/yot89ViLSo1nin7l3I4IQKARHMqO+NOsTPuFItOb6W9fx0ert2NQHefy57DbLbyxcdZ5br7PiutO8D+XVb27jC4cN7Kd1+lcf9ox8DNYrWyPfYEP0fs4XB8BPEZKSSZU7HmsexHEyP58OhaPju2joHBrRhWvQOma2hVKCIiIiIiIiJSnBTmFZFA13IE+pfLd7h3V6WW3BvUBsMwmF5vIHPObWZH/BkumlMuey0L1ssGeQDJ5jQ+OfYbP0fspr53UJ7vYXPMMWLTky67fWP0UbbGHueeau0ZUrVtrmHZ6uUZhJ+0RXD1Gltp0xEMAx562sqzD0B6msHPyzIY9B8X/PxNWKxWlp3dweLTW4lIvZjnsl5OiiWd+ac2cSE1gSfr3aRAT0RERERERERKFYV5xSS3cG9/YgRJ2cbaq+bmSzPvyvblym7lGVejJ1arlaj0RA4nRXE4+TxHks9zOCmKi5e02ruaE0kXOPFvi7788nF2p135GhxNvsA/yRew/NtGLs1iZs6JP0jISOH+Wl0cjklKtPLNF1kh4z0PWMnM0vwrQs++sHIxpKXB4vnp3DfKjc+Pr+P701vzXT4DqOrmSz3PALyd3Pg99ihxGVkBaOZswwr0RERERERERKQ0UZhXQgS6liPQtVye9jUMg0qu3lRy9aajby0AMjIyWLd7Cy41KnI0NZokcxo1Pfyp6xFADXc/nA0TZquVVdEH+eLcZhKu0HLvaup5BPBizd5UdPUG4J/kC/wvfAP7kiLs+yw8vYXqnhXoHdjEvm7x/HTiYmyvw7pYqdvI8bx9B1tZu9zWOm/l0gz8e/7D91GOQZ4TBqHlq1PZrTzeTm6Uc3LD28kVbyc3249z1mvnbF2I768cxi8xh/kw/A/M/waPqyP3YrFaGFWnJ57OmkVXREREREREREo+hXk3CMMw8MON5j416exUJ9d9nAy4LaAxnXxqMS9iGzsTzmC2WvJ8DWeTE+3L1+DuwBDcTFlVp7ZHBd6q24+fLuznw9Mb7OunH1lDFQ9fmpQP5nyUhR8W2FodOjlbuXNEztHufP0dW+fN+ioObs7a/t/A1txaoSF+Lp55LnMmV5MTN1doSHlnd149vsYe6K2N2s+OuJM8UKsrXQMaXNPsvCIiIiIiIiIiRUVhXhnk6+LBqKodC/SchmHQN6AxceYUvjpna02XYTUzZvcCXE3OWBZ2hrS6AJjD9vLcmb/hTM7zWOt7gPMQyHDG+LsRRouDWCtf4N6gNtwdGHLd5ezgU5MXavZyCPQupCUy7eBPvH949VXDvEblKvNQra7U8Aq47rKIiIiIiIiIiORX3qcyFcmD/1QKoatvVstAs9VCyqnyWHfY1lk9UkjtvIVkS3quPyleF8louw8AI8MZ15mDCZhzF5X3h2DJeyPCK+rgU5MptW8h8N9uwplSLOkkm9Ou+LMt9gRP7vyGDecPF0xhRERERERERETyQWGeFCjDMHiqWhcaeFa0rbCC88/tMKy2Fm/mrtvA88oTdZg778DqlzVzbfw/vrz7romlPxRcOUPKBfNxgyHcE9gKF8MpX8emWNJ55cAyvjixAYs1Z3dhEREREREREZHCom62UuDcTM68WvtWVkYf4OB2dzYdCwbAs2IqPW73wMml7VXPkT7lGFF/BXFmfSCnT9jW/fKLwcDbCy48czM5MyyoNb386rE+7h8SrzIpyIHESHYlnrUvzz+1ifOp8TxZ7yacDOXiIiIiIiIiIlL4FOZJofB0cmWAf3Oe+CFrDLrRj5anY71OeT9JY7COtDL2sRQO7rNw8qTBqZNWqlUv2LJWdivPnZVaXnU/s9XCF2e3sCBqp33dmsh9GBg8Ua+3Aj0RERERERERKXRKH6TQrFkN4eG2MK9BYxMduuavOyvYuu127JaVOW/4s8CKl29Ohon7qoQypnoPnLMFd6sj9/L+4dX5mhlYRERERERERORaKMyTApecDHv3wrx5Wa3yRj7qetWZYi8newj454ZrO0dB6uZXhxdq9MSJrLIo0BMRERERERGRoqAwr5BYrXD8OFy8eNVdbxjh4fDsMwb3/Mdg/Asm4uJsYVeHrk40bJL/VnmZAiqaaNjEVlVPnjQ4dapAintd2vvUZHzNXrkGepoUQ0REREREREQKi8bMKyQffmiwdo0t6KlZ00rTptC0qZXGTaB8+WIuXCFZtNDgyBHHlnPuHjDsAdfrPneHrs4c2GuboOLPDXDX3dd9yuuWGehNPb4GM7YAb3XkXgCerHcTpmtsiSgiIiIiIiIicjkK8wrBb79hD/IAjh83OH4cfvzxxg739thyLJxdoPtNztStbyKkrROVgq6/AWiHrk7MmmF7vWGDwV13l4zWb+19avJCzV68ekmgF+henqHV2xdz6URERERERCAjw8qWjWZq1TURWFkd9ERKO4V518lqhagoqFABnJwgIgI+/igryKte0yD8pBVLtqHUrhTutWgBHp5FfBMFICoKoiJt99OwiYnRz7gV6Pkzu9oe2PvvrLanrFSrVqCXuGYdcgn0Fp3eysAqrfByLtj3QUREREREJL++mZ3Oom/S8fGFT+Z54uauXkQipZnCvOv0wXSDX34xqFjRSq/eVrZtNUhOtn0xdr/JmSfGupGQYGX/bjN7dpjZs9PCsSOWy4Z7fn5WJk6yUqtW8dzPtdq/P+t142bXPj7elWTvart+ncE9Q0tG6zywBXqjqnbkg/A/AEg2p7Hi3G4GV21TzCUTEREREZGyLCPDyqrl6QDExcLxfyw0aFw4z2wiUjTUvvY6pKTA77/bXkdFGXwzz8TBg7YgL7CywUOP28aK8/Y2aNvemZGPuvH2Rx58ucST8VPdGDDEmTr1TZiyfQoxMQYTX7SFe6XJvn1Z/7NTeGGek/29+vHHkje5yE3+Dajg4mVfXnJmG+kWczGWSEREREREyrrtm83EZ3t2OnXCcvmdRaRUUJh3HQ4cALM5Z/NkkwmemeCGh2fuTZcvF+7Vb2T7OOLjDV6cULIDveRkWxfjTPv22f40maBB48KpVgEVTfS82daYNCnJ4Nv5JatpuLNhYmBAU/vyhbQE1p0/WIwlEhERERGRsu73NRkOyyePK8wTKe0U5l2HPbuzwqQRD7ty13AXmrU08dQLbtRvlPfWaZnh3ktvuNuDsMxA78yZAi/2dVu7BobeY/DSJAOzGeLj4eQJ23tRq67psiFmQfjPSBfc3G2vV66E06cL7VLX5JYKDfEwudiXF4VvwWotOd2BRURERETkxmW2WghPjuFCagIAyUlW/v7TsbfQqeN6PhEp7TRm3nXYsyfrdZdeTvhXuL5s1NPLYNI0dyaPSeHgPgvx8QZTX4Fpb1jx9r7Owhag1asNLBaDnTth459WXLPN8dC4WeHmw/4VTNx+lwvzv0jHbDb46ksYO67k/DLycnLl1gqNWBS1C4BjSedZf/4QnQPqYxglqyWhiIiIiIjcGCxWK79F7efLE38SkWrrU+vn4kWFvS1IS23msK+62YqUfkXaMu+nn36icePGhISE2H+ee+45AHbu3MmQIUMICQmhR48eLFiwwOHYxYsX07t3b1q2bMmgQYPYvn27fZvZbGbatGl06NCBkJAQHn30USIjI+3bL1y4wKhRo2jTpg1hYWFMnTqVjAzHpsb5lZIChw/bXgdXM647yMvk6WUw8XV3qte0BT+nTxu89aatBVxJkb214LffGuzdW/jj5WU38E4X/CrYrvnXXwZ79xb6JfNlQEATnMh6T147uJzHdsxl+dmdJGakFmPJRERERETkRmK1Wvk7+h/+b/tXvHlopT3IA4hJT+TERl/7sqe3rRHE+UgrSYklp0GEiORfkYZ5u3fvZsCAAWzfvt3+8+abbxIXF8dDDz3EwIED2bx5M1OnTuW1115j1y5b66ZNmzYxZcoUXn/9dTZv3kz//v159NFHSU5OBmDmzJls2LCBRYsWsX79etzd3ZkwYYL9uk8++SSenp6sX7+ehQsXsnHjRubMmXNd95J9vLymLQs2wPLyNnjhFXfK+9iWd+wwmPV5yWjVlZAAFy9mleXUKYOVK7K2NyqCMM/dw+CekVldWefMNhxmBy5uFV296eZXx2Hd0cRIPjy6lv/+/QnvH17Fofhz6n4rIiIiIiLXbP/FMzy/+zsm7VvCsaTzOXeI98D4J9j22jeepu3S7JvUOk+kdCvyMK9p06Y51q9atQpfX1+GDh2Ks7Mz7du3p1+/fsydOxeABQsW0LdvX1q3bo2LiwsjRozAz8+Pn376yb79wQcfpHLlynh7ezN+/HjWrVvHqVOnOHHiBH///TfPPfccHh4eVKtWjVGjRtnPfa2yj5fXtEXBB1hBVUyMmeyO878doZcvNzh0qMAvk2+5jeGXmmp7L4KrGfj6FU3o2KOPM9Vr2a51+LDBhj+K5LJ5dn/lMNqUq5pjfYolnZURe3hi5zwe2zGXn87uIikjLZcziIiIiIiI5HQi8Twv7/uBp3fNZ89Fx0HE3UzO3FWpJQ9VaUfNw20wrLZH/ozmhznklTU5n8I8kdKtyMbMs1gs7N27Fw8PDz777DPMZjNdu3bl2Wef5fDhw9SvX99h/7p167Jw4UIAjhw5wh133JFj+4EDB4iPj+fcuXMOxwcEBODj48PBg7YvK19fXwIDA+3b69Spw5kzZ7h48SLly5e/pvvJPl5ekxaFk4k2ae7EXfe6MPfzdAD+OQqXvE1F7my2MM8wHGe0LYoutpmcnAxGPuLK5DG2bqtffmUQ1s6Kq2uRFeGK/Fw8mVL7Fk6nxrHywgFWRR/iojnFYZ+jiZF8cHQNnxz7jfreQdTzDqRBuSDC/Gvj5uRymTOLiIiIiEhZFJUaz1cn/mRt5D4sOPbyccLglgqN+E9gCP4ungD8fdDg7L/bLS0OExnnhSvNAc1oK1LaFVmYFx0dTePGjenTpw/Tp08nJiaGMWPG8Nxzz1GxYkU8PDwc9nd3dycpKQmAxMTEy25PTEwEwNPTM8f2zG2XHpu5nJSUlOcwz2Kx2LtF2sbLs711VaoZ+PhaMRfSoHbVa2a9jomxYjbn/qWbef0rlSM6Gv75x6BZMytubpfd7YrCT2cFlzf3d2LFD1nXa9DEKLT3ITfNWxm0aG1i51YLUZEGPy6zMGBgyfqlFOTszYjANgytGMLG+BOsjD7IrsSzDvukWjLYfTGc3RfDAWhcrjKvNRmMk6HJpnOTl7ouUtqpnsuNRnVaygLVcylMm6L/4e0jP5Nkztmrp4tPLf5bqTVV3GzPtmazmeRkOHTo38f9CnFYK8aCW9axOw5eJCmtPG5O+Y8EVNelLLpcvXdyKrpGTdkVWZgXEBDg0LXVw8OD5557jjvvvJNBgwaRkuLYaiklJQUvLy/7vrlt9/PzswdzmePnXXq81WrNsS1zOfP8ebFv3z7S020t5I4eLYfZbGsiFxQczY4dEXk+T35FRrkDNf+97gV27Tp1xf33XmY2CHOGwfTpTbl40QVf31T63HyKBg3iyO8Eq/v31QL8AahR7zBVawQRfsITw7BiOB9gx470/J3wOoV1cWPntppgNfj2WyuBgXvx9CqZv1R8gbsJphcV2GxEsZULJBk5J2LZF3+WL7auopVzUJGXsTTZvXt3cRdBpNCpnsuNRnVaygLVcylIFquV3zJO8EvGCbACyW7gaeudVM9anj7WqlSJ8eR8zHGyj5p3+FB5zOZ6ANSqm8QBgHJJWN1TMVLcOHHCzNC/P6alUyBtnSsTaMr7s3Em1XUpiy6t961bty6WchRZmHfgwAF+/PFHnnnmGYx/E6S0tDRMJhPNmzfniy++cNj/yJEj1Ktn+/KpV68ehzOnjs22vUuXLvj4+BAYGMiRI0fsXW2joqKIjY2lfv36WCwWYmNjOX/+PAEBAQAcPXqUoKAgypUrl+fyN27c2N4yb/furBZTXXtUomXLyvl8N/KuahUrn2P7snZyDqB5c79c9zObzezdu5cmTZrkmgz/cxQuXrR13YyNdePb+XVp1crC/z1mxscn7+X5+ivbuU0m6NajES1D4OvP0mna0kS3Hk3yeXcFoCUc2Z/OLyvNpKY6s3dfM+6/v2S1zstNDyDdYuav+BPsTDjL0ZQLHE2+YG8u/xvh3NOsJ+7qbpuD2Wxm9+7dNGvWrNj+F0SksKmey41GdVrKAtVzKWhWq5U3D69k3YUTADgv7obTjgZ4tjjFk49Ba//L/+f/tq1Zz6x39KnO4eC2fHd6M9aKMRingjDiypGSYvCX+2n+Mp+mpmcADbyDqOtdibpelajpWQEXU+5xgeq6lEUlrd4XWZjn6+vL3Llz8fHxYeTIkURGRvLmm29y++2306dPH95++23mzJnD0KFD2bp1K8uWLWPGjBkADB48mNGjR3PLLbfQunVr5s6dy4ULF+jduzcAgwYNYubMmTRr1gw/Pz9effVVQkNDqV69OmBLSl999VVefvllYmJimDFjBoMHD85X+U2mrC/DfXuzmrM1C3HGyanwukP6V8gaCyEu1rhqpXFycsp1n+Mncu67bZuJzz4zeP75vM2qarXCmTO2e68YaODu7kxQZXj2xSKrRrn6730GG35LJjUFfl5p4rbbDKpUKdYi5YmTkxPd/OvRzd8WWs+L2MZX57YCEJ2eyNJzO/hP9XbFWcQS7XJ1XeRGonouNxrVaSkLVM+loPwd/Q/rLvw7C2K6E6adtsYrSTursehNK/VfsOLrm/uxu/fYntsMA1q0cqFT+c50q9SQt2omcPrfzl5GlB/WapEAHE86z/Gk8/xsW8TZMFHTM4C63oHUKxdIPe9AanoG4GLKqtuq61IWlZR6X2SDcgUFBfHxxx+zdu1aQkNDueOOO2jWrBkTJ07Ez8+PWbNmsXLlSsLCwpgwYQITJkygXTtbkNG+fXsmTZrESy+9RGhoKMuXL+fTTz/F999vrtGjR9O1a1eGDh1K165dSU1N5b333rNfe/r06WRkZNCzZ0/uvPNOOnfuzKhRo67pPqKisM8qG1zNwL9C4b6FLq4GXt6217Gx136ef45mBZAD73TB899W1Fs2Q3oee8bGxUFycubMtSVnPDf/ABMD77S1YDObDb78smhm1C1ogwKaUcE5a+zH78I3E52WWIwlEhERERGR4rIzLmuIJdMFXwxr1nPOwYMGY8YYnA7PeVxsLBw/Ztu3Vl0T5cr/+9qrIn2aVbXvVyWuxmWvnWG1cCQxkpURu/ngyBoe3zGXoX9/zPbYk9d5VyJSEIq0SVVoaCjz58/PdVuzZs0uuw1gwIABDBgwINdtLi4uPPvsszz77LO5bg8ICGD69On5L3AuVv1sYLHYvgw79yiat8/P3yAxwXp9Yd4/Wa8H/9eFuFgrv67KIC3N4OBBK02bXv0cp7PNel45uGQFZgPvcmHVjxnERFv5a6PBvn1WGjcu7lLlj7uTC8Mrt+HdU+sASLGkM/fkRh6r26uYSyYiIiIiIkXtUPw5++ugi1W5cMn2iHMGY8bAuBesNMk24tGebEN6tWjt2IKoes2sRhkdUkPoXr86v8Yc4VByJEeSLpBoyTnBRqb4jBTeO/wzH7Ucfk33IyIFp+Q0ryoF0tNh1SrbaycnuKlv0YR5Pn624CwlxeCSeUDyxGyG48dtrwMrG3h7GzRvlfXR79qZt2DuzJms11Wqlqyq4+FhcM/IrPHlZs8ysOat93CJ0tOvHrXc/e3LK8/t5kTSpb+2RURERETkRma2WjiSEGlf9onJGh/vgf9zpWZt2/NYQoLBpIkG69ZlHbtzV9bzXfMQx+e26jWztoWfgloe/txXJZTX69zGd02H81nDOxlTvQd3VGxOC+/KeJocx/COTI1n6dkdBXGLInIdSlYiU4LFxMDGjRAXZ/vyC+vkhH9A0bx9vn5ZX7jX0jrv7FlITc1qZg3QolXW/9Ds3JnH85zJKkeVqiWrZR5Aj5udqV7LVq7Dhw02/FHMBboGToaJB6qE2ZctWJl1bN0VjhARERERkRvNqaRoUixZ4yE5nc+aCLFFKydefd+dkLa2Z7qMDIN33jaxcKFtnPNdu2z7ObtA42aOLfP8Khj2IZdOXtJj1mQYBLv50M2vDg9UCeP1OrexoOm9fNJgCL7OHvb9vju9mURrHsdqEpFCoTAvjz6YbrDip6wA65YBRTfL6PWGedm72NapZ/vI/QNMVK2eGXxBUtLVz1OSW+YBODkZjHjY1b68bFnJCxzzolW5qrQplzWWxd8xxzQ2hYiIiIhIGXIo4ZzDcnKELYEzmSCoioGnl8H4qW70ztZb7OuvTEybZhBxzvYc1KCxCTd3x2ciwzDsXW3Pnzeu+hxoMgyqufsyLKi1fV2SOY1f03OZYVFEikzJS2RKqG3bDPbvt30RVq9p0LRF0b11vv7XGeZlm/wis2UeQPMQ2//SWCwGe/de/Txnztr+dHaBgEolMygLaetkL9vZs8VcmOtwf+UwTGS9x58d+x1Laew3LCIiIiIi+XYoPsL+2g1nos7ant0CKxu4uNqeE5ydDUY97crwB7Mamvy1MesZIntvrOyq18p6Jjx6JG/l6ePfgOpuvvblv81nOJ0ck7eDRaTAKcy7BjcPcMEwii7Myt4yLy42/8dnb5lXu162MK919q62V74fiwXO/tsyL6iKgZNTyQzzDMMgoKKtbBcvGqRdfvzWEq2mhz83+TewL/+TGMXKc7sV6ImIiIiIlAHZW+bVTKtmHzYpuJrjI7xhGAz6jyvPvuiG8yWdx5pfJsxr1DTrHHv25u25zskwcf8lwwF9cHQt6RZzno4XkYKlMC+f3D2gW68inQTYIcyLic3fsVYrHDuWdR7/ClkfedOWTpj+XcwcV+Fyzp+H9HRbOUpiF9vsKlTMer8ulOK5I4YFtcbdlFXXPji6hiF//Y8xu7/jhzPbSTFrnAoRERERkRtNmiWDY4lR9uVKccH211Wr5/4s1qm7My+/5U658rZlP3+Deg1z37dpi6yQb8+evJerbblqtPSuknVs/Glm/vMLVjU4EClyJTuVKUEaN7O9VYOHuuDpVbSt0hzHzMvftc+fh/h42zHZW+UBeHsb9jH0Tp4wrtiF92wJHy8vu+xhXnR0MRbkOvm7eDK4YguHdUnmNHbFhfPRP79y7+ZPmXtyIxfTk4uphCIiIiIiUtCOJUaRYbXYlz2jK9pfB1e//PNg42ZOvPWRB/8Z6cKEV90u25uqYqCJwMq2bYcOkufeTIZhMLpqR7xMWeOUrzi3m6Vnt+ftBCJSYEp2KlOCTHnHnVnfeXDHf4pu4otM1zNmXvYuttnHy8uUven1lVrnnc4e5gWXzC62mQKyzTJ8/nwxFqQA3FGxGQ08K+a67WJGCl+f3MjwzZ/y8T+/EZUaX8SlExERERGRgpZ9vDwAS5SP/fXlWuZlCgwycdcwV+rUz72LbaamLW3b09MNDh7Me9mquvkyplp3jGyN8T7553c2Rx/L+0lE5LoVbX/RUszJycA/oHhCLF/fax8zL/vkF3Xq5RLmtXZi0Te27pqff2aw/Efw8gYvL/D2Am9v8PK2snNH1nmqVCvZGfCN0s0WwN3JhXfqDuCf5AscTj7P4aQoNl48QWxGVmu8VEsGS85sY9nZHXSv2JDBVdtSw7NCMZZaRERERESuVfbx8so7uRF9Nqsl3KVj5l2rpi1MrF1he71nj0GzZnnvKtuqXDB9rdX40TgF2MbPe+XAUl5qPJAQ3xoFUj4RuTKFeaWAi6uBlzckJkBMPicMulrLvIZNTLi6QVoqxMUZxMXldhbHELOkt8xzCPPOG0DpHsPBZBjU9QygrmcAt1RoyMOW9qyJPsTCqF2cS8tqjWe2WlgTuY81kfto71+He6q3o653YDGWXERERERE8utgfFaYV9+zIuHhttflfaC8T8E8i13ruHmZ2lOJDD9PVsbYmvWlWcy8tG+JAj2RIlKym1iJXea4edfazdbTC/u4CNm5uRk89LgrlYMNPL2ufr4qVQ38KpTwMC/gxmmZlxs3kzN9AxrzWcM7GVu9B7Xdc7bC2xh9lCd2zONIQmQxlFBERERERK5FUkYa4clZA3/XMoKIifl3JturdLHNj2sdNy+TgcEjVdrT0aeWfV1moLclRl1uRQqbWuaVEr7+BqdPWUlJMUhNteLmdvVj9u+HCxdsX9C16pgwmXIP4Xrd4kKvW2xjAZrNVhITIDHBSkK87ScxAeIvWsnIgNAOThhGyQ7z/CoYGIZtJt8bMczL5GSY6OpXhy6+tdmWcJoFkTvYmXDWvt2Cle9Pb+H5BrcWYylFRERERCSvjiREOPQr8osLsr+uWsDDHTVt6UTE2QzS0w0OHbLStGn+jnc2TIyt0YPXT/zChjhbgJdmMTNp7xJG1uzEHcFtSvyzo0hppTCvlHCc0RYCr9J7MjISXn8t65jWYVceADWTk5NRoM23i4Ozs4Gvv0HMBWupCvP27oWdOwxu62elfPm8H2cYBq3LVaV1uaocTIpk+qk/+CfFduPrzx/moVpJ+Lp6FlKpRURERESkoOy9eNph2fV8Vi+cgmyZB5eOm0e+wzzIPdCzYOXz4+s5khDJ6Lo9KefsXoClFhFQN9tS49Iw70qSk+HVqQZxcbZjmrcy0X9I0c/CW5wC/u1qGxMDGRnFXJg8iImByS8ZfPedwQfTrz1IbeBZiXsrt7EvZ1jN/BxxDYNgiIiIiEiRsVitRKclkmpOL+6iSDHbGnvC/rqqmw8xZ7O6ZFWtXrANLhzGzdt97efODPRurdDQYf3v5w9yz6aPmLh3Masj9hKfkXLN1xARR2qZV0pkD/OuNAmGxQLvvmtw/Lht/8rBBs9NdMfZufS2tLsWFSoaHD4IVqtBTIyVihWLu0RXtno1pKXZPqMtWyAqimsuc5ty1QhyLWefHOOnczsZXLUNToayexEREZHiFJ+RwunkGMKTYjidEvPv62jOpMSSasnAhEF1T3/qegfSsUI9wvxrq5tiGZKYkcr+i2fsy63LVSU8W0O9gprJNlPmuHkRZ60c/HfcPFfXqx+XG2fDxGNVO1PXoyIzTm8gw2oBIMNqYXPMMTbHHMP5iIkQ3xp0DqhP+wp18FaLPZFrpjCvlPD1z/olHhd7+f3mzTPx9ybbvp5eMH6qO+XKl71/APhfMglGSQ7zzGb4eWVWea1Wg99+tTLkzms7n8kw6FuhEZ+f/RuAyNR4Nkcfo12FOgVRXBERERG5ijRLBttiTnAy+YItsEu2BXdx6clXPM6CleNJFziedIE1kfsYWKUVD9XqqkCvjNgRexJLthHzWpWrylf/zmTr7AKVggq+HmQfN+/nn63063d957ulQkNquvvx+olfiExPcNh2abDXyrcGnQLq0yWgPm5OZasnmcj1UlOdUiIv3Wx37vBn8fe2ptImEzw30Y2qBTyuQmkRULH0zGi7+e+siUoyrVlrYLFc+zlv8m+Ai5HVbH7Z2R3XfjIRERERybMjCRE8uHU2k/f/wOzjf7AqYi/7Lp65apCXmyVntvHJsd+xWq1X31lKvW3Zutg6GyaqJFXmzL8N9apUNXByKvgwr/ctWe17vv7KICLi+s/ZyCuQzxreyeRafejtVx9vp5zN/TKsFv6OOcY7h3/msR1zuZCakMuZRORyymbSUwo5hnk5v8QPHDBYtqyGffm+Ua6EtC27DS8rVMyq2iU9zFuxIuvz9Pu3BWbEOYO9e6/9nOWd3enqW9u+vC32BOHJV+ifLSIiIiLXbXvGOZ7bs4DI1Pir7uuEQVU3H8LKV2dQxWaMDu7IXZVa0so7mOz/2legVzZYrVa2xhy3LzfxDOKLz1wxm221IaRN3iY0zK+GTZ24ZYDtuTE11WDG/wwKoqq5mJwILV+dp6t3ZV7j/9qDPS9TzmDvVHI0Y/YsUKAnkg9lN+0pZRzGzIt13BYZCW9Mc7J/0ffp50zf28v2R1vBoWWeAZTMf/ycDoedO7PGN7x7hCvvTk0FYO0ag2bNrr3ctwU0YU3MYfvyr5H7GVajw/UVWERERERysFpts3cuTj+YY1sFZ0+C3XwIdvOhqvu/f7r5EuhaDufLjGm8Nvowb5/6zf4v2CVnthGbnsgTdW/CXd0Rb0inU2KJSL1oX650pAnrNtueE/z8DYYMu8bB7PJg+IOubNloJirSys6dBmvWWOndu+DOnxnshZavzmOWTmxPOM362H/YGHeCREsaAKeTYxizZwHTmg6hgpt3wV1c5AallnmlRPYwL/uYeZfOXNuspYkHH3Mt8+NqVMg+Zt75YizIVWRvlXdzfxfad3bCu5xt+c8/ITHx2s/dwLMiNdz97MubY45d+8lERERE5LIWhG9m8dltDus6+NTkuybD+LrJUKbVvY3Hq3VmUMXmhJWvQbCbz2WDPICe/vV4plo3hxZ6v0Ud5Jld8zmXEldIdyHFKXurPFJc2PltVq+r+//PFW/vwnu+8/A0GPVMVlg4e7ZBdCH1bsoM9p6p3o2ZDe6gsmt5+7bTyTGM37uINEtG4Vxc5AaiMK+UcHE18Pr3Pygyx8yzWOC9bDPX+gek8cyLLmVu5trcVCgFY+alpcEvv9heu7pBz5udcXU16NLT+d/tBn+sv75rhJarbn99OCGC6DQ1XRcREREpSBsvHGHOiT/sywYwPKg142v0otx1zNbZ078ez1bv7hD6/ZMYxeM75rIgfDOJGanXU2wpYbKHeV6/ticu2tattlWoEx27Fk4X2+xC2jrTvY/tOSQp0eCjjwqmu+2VVHT1Zlqdvg6B3omkC2w4f/gKR4kIKMwrVTJb52WGeXPnGmzKNnPtXSPDy+TMtblxdTUo9+/vhPMlNMw7fRqSkmyfV1gHJ7zL2V73ujWri/SyZQZm87VfI7R8dYflzdFqnSciIiJSUP5JiOKNgyscBnT5vyod+U9gK0wF0FOmh19d3qhzG/7OnvZ18RkpzDq+nuGbP2X28fVEp11HVw4pEdIsGeyKOwWAcboiGX81BGz/4f/wE0XX6+q+R13tz5x//22w4Y+rHFAAMgM9D1NW9/FVEdcxeLhIGaEwrxTJ/GJNTjZYtQoWLbQtm0zwzAQXAiqlFWfxSpzMSTBiormumWELS8S5rNfVamb9Vaxd14lGTW3L4eEGa1Zf+zUaeVXC28nNvvy3utqKiIiIFIhjiVFM2reYFEu6fV1HayB9/BsU6HUaeQUyvf5AGnlWclifZE7ju/DNjNj8GR8cWcMZTXZWau29eIZUSwaYDZyXdgar7Tnv7ntdCKxcdI/s5cobPPREVnfbTz81uHjxCgcUkIqu3nT1rWNf3hF3kgh1Jxe5IoV5pYhPtnHzPpqZ9fq+Ua60LKTZjUqzgH+72mZkFM0vofw6l23a98Aqjn8V730465fovHkGyUnXdg0nw0SbclXty9tjT2gMChEREZHrtC7qIE/t/Ibz2YYwaeNdlVusVa9w1LWr4OLFtDq38VCVdgS4eDlsS7ea+encLh7cOofXDvzIkYSIy5xFSqqNF44A4LSpKaazFQGoUdug/+Cin+ykQxdn2nexPVvGxRl89mnRtAq8yb++w7Ja54lcmcK8UsTPP+uL1GKxvb7pNs1ceznZx807XwInwYg4l1W+oMqOvyQbNnGiQ9esX6LfL772X6Jts3W1TTans/fi6Ws+l4iIiEhZFpESx4yjv/DaweW2llT/qunux/PVumGi8IIPF5MTt1dsxqyGd/F0ta5Uc/N12G7Byrrzh3hsx1zG71mkiTJKiQyLmXXnD0KcF06/tAXAMODRp9yKbSz0hx53tU/Kt26dwebNhX/Nhp6VqJ6tTq+O3IvZWgK7V4mUEArzSpHsM9oCNG1p4qHHNXPt5TjMaFsCx82LyN4yL5fm88MecMX535z2hyXXHki2KVfV4R+Wf2vcPBEREZE8i01L4tfI/by493tGbvmcZWd3OGxvW64ab9bth6eTa+4nKGAuJid6+9fnowaDmVizNw0v6X4LsC32BON2LyQ2/Rq7d0iR2R57krj0ZJyXd8RIs7XE63ObMw2bFF/PKz9/E/eNyqrPH800SCzkoRkNw+CmbF3Uo1Lj2RF7snAvKlKKqUlXKeKfLZwKqmLw/CR3zVx7BQ5hXklsmfdvmOfuDj6+ObdXDjZx60Bnli7MIC3NYP438H+P5X9KqfLO7jT0rMS+JNsFN0f/w8O1u117wUVERERuYCnmdPZcDGd77Em2x5zgWNLl/yF5d6WW/DeoNU6GCfP1zFp2DUyGQXufmrQrX4M9ief4LnInW+JP2befS41j6v5lvNp0MC4mDclTUv0StR/jdABOB2oB4OMH/32waILhK+l+kzN//Gpm299mLlww+OILGDWqcKe37elXj9ln/8b875QyqyL20tqvZqFeU3JntVqJSo3ncEIEhxMiOJIQQUTqRSq5laeedyD1vANp7lvNPmN3usXMkjPb+CVyP1U8fOkT2JTWfjVxMgqu/diRhAjmnfyLY0nncTc54+Hkmu3HBQ8nVzwvWfZwcsFstXI0MZIjCRHEpSdzU2BTBlQJKbByFReFeaVI+87O/LQkA3MGPDvRjfI+CvKuJHMCDIALFwygkOdWzweLJSvMC6xiXLZ15ZD/urJmRQZJifDnRnh0FDjl499iRw7Dhx8auNbuAF0XgwGnU2IJT46hqodfAdyJiIiISOlmtlo4nBBhD+/2x58h4yrd+2q4+zEiqC3tfGoUUSkvzzAMmnlXppl3Zf5JvsCrJ9ZyOtXWxXbPxdN8eHQNT9a9Sb15SqBkcxobLxzB6e9O9nX3jHTF27v4PyvDMHj0KVceuy+ZlGRY9bNB505WmjW/+rFnz8Lcrw1OnIDataF5CystWkBAwJWP83XxIMynBn/GHQfgzwtHiE1LwtfV88oHigOz1YKJyz9jXiq34O5wQiQXM5Jz7BueHMO22BMAuJqc6FyhPi18q/Nd+N+E/zsJz/Gk8/x54QgV3crRsFzlfA0+UM7Zg7relajrHUhldx9MhkGyOZ35p/5i+dldWArgmf6jf34l2MOXNn61rvtcxUlhXini6WXw9kceWK1W/TLOg+xj5pW0brbR0baJOSD3LraZypU3aNHaiY3rzCQlGhw/bqVOncvunsPChQbHjxtwvBJGQ3+sQdEAbI4+RtVghXkiIiJStoUnxzBx7/eczcP4cm4mZzr71OKWCo1o5FmpRP57vLZHBV6qdRNPHf6BBHMaYGvdlJiRRr/KLWjuU61Elrus2njhKKkJTrjutv0D383TQrdeJecRvWKgieEPufLJ+7a69OH/DN5/34rLZeblSE2F7xcZfP89pKfb6tmpU/D777bXVataad4CWraw0qQpeHnlPMdN/vXtYV6G1cys4+t5un6fAr+30ijDYmZzzDGOJ10gISPl359U+5/x/65LNqfj4+JB/8ohDK7aBlfT5etUXHoy0w7+xPZ/A7r8SLOYWRu1n7VR+3PdHpUaT1RqfL7PWxT+d+QXZrYajrtT0U8yU1BKzjeF5Jl+AedNQAkO87KPl3fp5BeXatrCFuYB7NlDvsK8Q4eyXnufrEn8v2HevounuT24Vd5PJCIiInIDWnJ622WDPBMG9Twr0so7mJblgmnoWQnXUtBdtaqbLy/U6MWEf1bYW7FsuHCYDRcOU9XDj8fq9KK5b7ViLqUA/Bq1H6ftDTAybI/lPW92xs29ZD3r3dzPmT9+yWDfbgsR5wx++cVKn2zZ2u5dsPEvg6NH4NgxSEu7fPnDww3Cw+Gn5QYmk5V69aBlCNxyixVfX9s+bcpVo4a7HydSbK28VkfupVelxmWizh5LjGJ//FmOJERwIvECQe4+DKvRgSB3H6LTEpi6/0f2xZ/J07ni0pP56uSfrIncy0O1utHWv1aOLq/pFjOv7F/KnqtMkGjCoJq7L1XdfDidGsfJlNjLtpDzdnIlxZJx1dbN1yPEO5hyzm4km9NJtqST9O+fmT/ZJyfKfg9+zh5cyLCNI3ouNY5vTv3FyJqdC62chU1hntywPDwNPL0gKREio4q7NI7Onct6faWWeQBNW2b9o3HvHoMBA/LWtDj6AkRHZ/0y9TxZnfjQbQAciD+bj9KKiIiI3JhOXDIeXrCbDyHewYSUC6a5d2W8ndyKqWTXJ6RcMKOrduSD8D8c1ocnxzBx32Lean4Xdb0Di6l0AnAhNYFtF07gvPku+7q+A0pefTOZDB74P1eefjgFgA0bDHuYd+IETJpkYLE4BnhOTtBvsAt3/MeFUycs7NxqZudWM4f2W7D8m/FYLAYHD8LBg7BvH0yZYnvGcTJMPFa1E88eWWY/3wdH1/C/kGFXbGFWmiVkpPD2oZ/5K/qow/p98Wf448Ihbqvckt+iDhCdlv9ZSM6mxDF5/w+4mZyp5VWRBt5BdK3YgIblKvO/o2tzBHmZwV09jwDqegRQz7Mitd39HVqwpVgy2BYfzsoLB9gSfworYAC3VmjEvUFtsABrog+x8eJxks3peS6rFTiXFk+yJfdjgt18eDS4A63LVb3iecxWCymWDJLMaSRb0jFbrVRxK0+G1cLDBxdyId32Pi46vZVuFRtSy6tinstYktyYfxtE/lW1uolD+23/ixQTY8WvhPQsjTiX9Qsv8Cot86rVMCjvAxfjYO9eMJvzNm7e4SOOy0lHK4AFMMH5tATOp8YT4FbuGkovIiIicmM4mxJrf93Lrx7PVO9WbGUpaLdWaERVNx+WRO1h08WT9pY0qZYMXtr3A9Nb3oO/q3cxl7LsiUlL5Icz2/nx7E6sR6tiRPsAULtFGsHVcul3WgLUqmsiuJrB6VNW9u2FGFtnH1avMjkEeUFVDBo2ceKO/7hQraatwULjZk40bubEf0ZAUqKVPTttwd7ObWbCT9jq5O5dBqdPWwkOtp2niVcQN/s3ZGX0AcAWQi8I38zQ6u2L7J6LyomkC0zZ9wOns30XZZdmMfP96a051nuZXPF2dsXbyY1yTm54239ccTE5sfLCAWKyjXmXasngQPxZDsSf5Yez2wly8+FcalarZG8nV16o0YtGnpWu2vXU3eRMB5+adPCpSURaPLsTzlLPsyI13LMetu+o1Jw7KuVhgMVLWKxWzqTGcTj5PBczUuzrA1y9aFuuep5aRzsZJrycXPG6ZIZxN+DR4Pa8cnwNYAv9Xty7mFa+NajjXYkAV2/KObvj7eyOt7Mb3s7ueDi5lNiekQrz5IbWLMSJQ/tt//2zaxd07VrMBfpX9m62V2uZZzIZNPm3q21iosGJE1Zq1776NQ4fcvzSSUt0xojMGjfvYPw5hXkiIiJSZqWY07mQraVLVTff4itMIWnuXYXm3lU4n57I+6fW22e7vZCWwMv7ljKt2RDcSvGYUaXJ2ZRYFoVvZVXEHtKttiF0nDc1sW8fckfJDVYNw6BDV2cWfJ2O1Wrw1yYTgZUM1q+3Pce4usFHX3vgX+HKzzWeXgahHZwJ7WCLIRbPT+OLT2ytsH5ZazBseFYPpPsqt+WviyeI/TeQmn/qb7pXbEQVD98CuaekjDRi0vPX0s3b2R0fF4/LbjdbLUSlxmP+t4upxWq97Lh2met2xJ3M0XrN0+SCn7MHp9Mu5rhGTXd/JtbsTWW38lcs6x0Vm/P1ua0sPb831y6x2YM8EwYv1OhFSLngK54zN4Gu5Qj0L7hnSpNhUNXdl6ruvgV2zuw6lK9JWPnqbLp4ErB9F66O3MvqyL257u9kmOzBnreTG8HpbjS3tqAkDLigME9uaM1bObFonu3LcddOg65dS8aMttm72VYKunrS7zBu3m7yFuYdybnO6XgVMv4N8w7En6VjQL08lVdERETkRnPukrHyKt/A/8kZ4OLFuBo9eObIUo7/OxbZwYRzvHVoJWMb9s0xlpYUnKMJkSwI38z684ccQ5XocpgOVwfAJ8BMaPuS/Wje8d8wD2DjnwYNG/qSkGB7junQxfmqQV5uuvdx4evP0zGb4Zdf4J6hWT2Qyjm782CVdrx58lfANhnG/FObrmsyDIvVyo7Yk6w4t4uN0UftoVt+tPOvw8O1uxHk7mNfF5lykZ8j9vBzxB4upCVcc/kCXb0ZU70HDTwrYQC/xBzhs7Ob7IFmF5/aPFWtS54mbfBycuXh4PbcXrEZuxLOcCT5PAeTojiQFJlj30eC219TkFcaGYbBqOCO7Ek4R6Il7ar7m60W4tKTiUu3fQYHgdDoI3St1LCQS3p1JfsbQ+Q6NWpqwtUV0tJsLfOsVigJrWQzW+b5VzBwc8tDmJdt3Lw9ewz6X2XcPKsVjv4b5jk52brmgm0SjNh2ewCNmyciIiJl25lLurVVcfXJfccbhKeTKy/V6sPjh5Zw0WzrvvbHhcO8dWgFz9a/pVgDvaSMNP5JjCQ+W7c6Lyc3antXxNvZvdjKdT12x4Xz7alNbL3MLKG+f4WSbLU9B/Qb6I6TUwl4SLmCGrUNqlQ1OBNuZd8+gwsXguzbet16bbGCr59B2/ZO/PWHmZgYg23brLRtm7W9u28dlp/fx74k28PT2sh93F0tLN+t82LSElkdsZcVEbtzhPj59Vf0UbbFHue2yi1Js2RwOCGCQ/HnLjMdRN6FeAcztkYPymer7z396xHmU52NcSfwc/agdbmq+e7yWcnVm17+9elFfQDOpl5kZfQBVkcfIi4jhf8EhtAvoMlVznJjqeTqzXv1BrAm5jCHk6I4knyei+bUPB9vomT8XVWYJzc0V1eDhk1N7NpmISrK4Nw5K5UrF2+ZUlIgNtb2BRBYJW9fBPkdN+/cOez/U9ayjRMH95lJiIeMY5Xs4+YdTojAbLXof2JFRESkTDqTHOuwfLVua5m+/spg/R/w8MNWWrUqhIIVokDXcrxYszcv/POTvavnb1EHAYOn6/XBpQhm603KSONoYiSHEyI4nBDBkYQITifHXDYMqeLuS5Pywfy3ensqueftMypuC8M38/nx9blua+BZib5urfhkq61Vnocn3Ny/5Hd1NgyDjt2yutqeO+cJ2MbJa9L82p8net7izF9/2OrimtUGbdtm1QTDMPhvUGte+OcnACxY89w6z2K1sjPuJD+dvfZWeJdzuXHs8sLAFlR7O7lS7t/x7kLLV+e2gMa5Ppd5O7nR27/+dZY4S2W38oysHMrIyqFkWC04l9FnwaruvoyobEuOrVYrMRnJxJtTiM9II8Gc+u9P1ut4cypJ5nT8k51p71+nmEtvozBPbnjNWzmx6//Zu+/wtsrz4ePf52h7xHvHWY6z9yYJCSvsPQqUUspboAXKKpSWTgqFFtpCof2VskrLKHvPsJIQEsje01lO4h3vLUs67x/H1oi3LdtScn+uy5ePpKOjR9LRGfe5n+deb2y8N22EtDQ4eBDefFMxb57OrFn92x7/8fJSOxkvr0V3x83LyfFNjxqnYTbDqhVummot3nHzGj0uDtQeISsquYfvRAghhBAifPkXvxhksrcaLL0tNTXw5pug64pXX4Fp00JjCJfumBCVym+HLeK+A5/5BfR2srRkJw6TxTs2lP8g8NFmO5FmmzfYYFIa02KHMiKq4yqQLYG7PTVF7O5C4K4t+Q0V5DdUUNhQycOTvtPTt91vVhzJaTOQNyM6k8uSJzMxMpUXX9RoajIuvJ9xnoWoqNDI9OmMf1fbFqeeae5VgYBps0zEJSjKS3XWroWKCoiN9T0+JSqdcREpnWbnNbibKGheT/bXHuHz4m0UtJOFZ0Ixp7mAg6WLwSy3rvNh6Xa21ha2O0+mLZYz4keT3FxYRqGINFmJMjUXqjDbiNCsaKHQVQyO20De0ZRSxFsiiLdEdDifG9iUkxMyBTEkmCeOeZOmmoDmcfM2KxaepHPf7xVHjii+WQn/fk4nqh/Hmy3y2/53VsnWX3fGzfMvfpE9WiMiQrFqhfFc7UA6br9x8ySYJ4QQQojjkX8wr6tZeYWFRiAP4MCBzntLhKoZgzJbBfQA6t1N1LubKKG602U8C5yeMp5rh51IrN9JcGljDYuLtrLsyC4O1ZX2uvthiy1Vh8mtK2VoREKQlhh8e2uK+fPujwPuWxibxXeSJzPCYbS7thY+NhLNMFvg/EvC55Tcv6stgKbByWf0rv0mk+KU0828+XITbrdi6VKdCy/0Pd5Wdt4/937BqOhUChsqvX/lTXWdvlaqNZoz48ewKH5Up4GbtiyMHcGSij08k7+Kclc9ds1MliOBbEcS82KGMT4yNWQCPeLYFz5bDiF6KGuURkQk1NXCli3w8v+MQB6A06lYuVLn9NP7rz2FAZVsuxHM8xs3b8kSxZixOtnZbY8BuMev+MXI0SbiEnxp5ZYDg3H7jZt3TtrkrjdeCCGEEOIYUVDvy9pJt3Y9mNeisVGRn6+TmRnslvWN6mpjyJaMwcbtloDeHw58RqNfQK87Pi3axsoje5gZPxwNRaWrnvXluW1Wz2xLvDmCkRGJZDsSGelIbC5CogCdYmct22sLeaV4o3f+z4q2ct3whT1qa18rc9by+x3v0uhxee+7OGki16fPCZhv8WKoqzMO4E9eZCY+MXyyo/y72gJMnq6RmNT79p9yphHMA1jypeLCCwPXn6Oz89ZV5LY7FuHRWrLwzkoYw9SojF5lxSmlOCUumxNjRlDmqiPREilDFokBI8E8ccwzmRQTp5hYtcJNdbXivfcCH1+2THH66f3XRaKo0LcDSU3v+sY/c6giJhYqK2D/fsXdP1MMH65z+hk6CxdCRPPFJbcb9u41plPSFINiFFHRGlHRUFMN2oE077h5u6rbTxMXQgghRM/ous7GykMUN1Q1d1Ns6bJodFuMMFkDsjfKnLXsqSmi2tXAkIgEhkYkYNXkML0vNXncFDdWeW93NTOv6KhDp3378Abz9uQoPv4ok/h4GDo0WC0Njro6uPtnioICxc03e1jUfCF7xqBM/jP2Sr6pyqXa1UD1UeNE+U/Xup1thuhq3I0sKdnZaRuODtxlRySSYIlsd/6h9nhmDspkXfVhcuqPAPBF8Q5+MHQ+5n4Y2687Kprq+NXWNylp9GU0zorO5P+lBY7n43TC++8Zv32l4MLLQ3+svKOddraZj99tor7Ow8VXdt41vSsyMjWyx2jk7PSQm6s4ckQnMdH3+NHZeV2RZh3E6fGjOD1+dI+y8Dpi0UykWI/d6tciPMhRgjguTJpm8nYzbaFp4PHAtq2KkhKdpI6H/Aiaoh5m5mma4gc/tvLU407qm7PI9+9XPPkvxX//o3PiiXD6GTpms5FxCJA9RvM+d/wk4zNw11lRJXHoKeUcqi+j2tVAdJhWCRNCCCFC0X9zV/Dq4dXtPq6hmschs9HgcVHqrAl43Kw0Rkal8P2h85gaO6Svm3tcKm6sCsge63pmXuCx2/59ioULdXQd/vIXEyUlyeTk6DzxLx17CB1erVwJBQVG219/XXHqaTpa8zXlWIuDsxLGdGt5W2oK+GfeSg40lLU7T4Z1EAvishjlSOo0cNeRM+JHk5NnBPMqmupYXb6fuQkje7SsvlDRVMc9W97gQN0R731D7XHcPfSUVllbS5ZAebnxPZxwoomMzPDL6kpJ1Xj83zY2bdzGuIkTgrbcabNM5Ow0ehNt2ACLFgU+PiUqnVPiRvJludEFSUORbI0izTqINFs0qdZBpFqjSbMOItUWTZTJFrS2HeuKimDXLpgyBQaFR40ZgQTzxHFi8vTAq3eZQxVzF5p59XkjnXv5V3DxJf3TlpbuGVYrxMV3L8375NMtnHCimeVLXHz6gcu7w2toUHz2GXz2mSImxndgOnK0732PneALaKq8ZPSUcgB2VxcyPW5YL96REEIIIVp8XrS9w0AeGGM+VbnqqXLVt/m4S/ews7qA32x7iwfGX8xkCegFXU8r2foPlwJGZh5Abi6UlBjHdeXlinff0bn8it62MniWLfMdcxYXK7Zs0Znci5FWJkal8Y9RF/HBke0sqdhLndsJGB1kRzgSODNhDJMi04IyftjCuCyeyv8WZ3NX4E+LtoZMMO9wXRkP7PwgIJCXZInk98PPaFVQxe2Gd972fR4XXxl+WXktYmIVg2Jdnc/YDVNnmLznZhs2KBYtCswDVUpxZ+ZJXJUyHQ1IskZJF9cgKCqCn96hqK1VREToXHSxznnnEVIXI0TbJJgnjgsZmYqEREXpEWOn8OM7bCQkKu8OY9kyxcWX9H1XW48HiouN6ZQ01aMDHLtDsehsC4vOtrBvj5tPP3Cx7HOXN1uvstKv+MUY3w5upN+0lpeEZ9ouAHZU5UswTwghhAiC7VX5PLbns6Atz617eGDnB/xt8pWkO+KCtlwRWPwCejZmHsD+/aDrsHlT4P1vv61YdLpOfHwvGhkkpaVG8TR/X3yumDy5d8e+JqVxQdIELkgKXnZWW6JMNubFDGdJhZGRtaZsP2XOGuKtfVvBTtd18hoq2FiRy4aKg+yqLsCuWRgZlcLQiAQ2VBxkS9XhgOckWSJ5KOvcNrtgfvutLzty8nQt4KK7gOyxvnHON29qu7iMphTpXQy8i8653fC3R41AHhhjOb70ouKjD3W+c7nOokVglohRyJKvRhwXlFL88GYr/3vOyennWhg/ydgzjB6nsWu7MTbDgQM6w4b1bTsqyn1dYFPSen8lacRIEz++3cQPfmRtla0XEQlZ2b7XyMrWUMo44LTlp9FyLW1FaQ7fGzq3120RQgghjme5tUe4f8d7uPwKCVyZPJWFcVm+8cdcvvHHqpv/68BwewLZEYnEmR3sqy9jSXkOq6sPAVDtauDe7e/y6OQriTRLt7FgyfcL5jk0CzFdGHKkqQlKjwTeV11tDNeyeXPgBdqGBsXLL8PNN/c8YKbrRvAw9wDExsHo0W0XPuvM8q98FXhbfPMN1NRAVN/Gw4Lm9PhR3mCeB50Hd37IsIhE73iU0d5xKY3/cdaIHgX7Kpx1bKw8yIaKXDZWHKS4sXVV37yjAsEtWgJ5bWV56jq8+aZ/Vl5wxpo7lphMisnTTXzzlZuaGsWePTqjRw90q/rP11/Dv59VjB0LP71T75cq2W+8Djt2GOtlVLQRSPV4jOziJ/9lZBhfdZXOvPl4u+WL0CHBPHHcmLvQzNyFgav8wkVmdm03ugUsW6YYNqxvs/P8u2akpgevbPnR2XrrvnUzcaoJu8P3Go4IxeAhikO5Ou6CWGgygcXNgbpS9teWMDyynwYNFEIIIY4h9W4n/zv4LW/nr8et+6rHL4gdwdWp07udhT/EHsfcmGHcs/dDb+XGQ/Vl3LfjXX499nwZ5zZI/CvZppoHUV+vvMXE2lNSAh5P6+8zJwe2bjWmIyJd6LqZ+jr44nM499zuF8MoLYVnnlZs2gx1tb7Xy8gwCp9NmdL5iXV8PEQ2D1Hn38V2xhwTa79109Sk+OornbPP7lqbdB0qKiA2tmcBxd6aFJVOqjWaQqcRXNtWlce2qrwOnzMyMpmzUidxUtIYIsytg2e6rlPcWMXumiJ2VhewseIg+2pLetS+cREp3DXkpHa7a2/aBPv2Gh9c1iiNSVMlMtKWqTOMYB4Y4+YdL8G8Zcvgsb8pPB7FihUwZ47OiQv69jV37oRXXzXWSU2DXz9oJypa8eKzTr5dbnwHhYWKv/5V8fbbOldfrTNlqvH7d7uN6tgxMQOzPRAGCeaJ49r8k8w8+w8nbje8/x7s26eYMlln8hQYNiz4VyACi1/0zU58xEgTI0a2fSkne4yJQ7kudI+GKkxAzzT6/H5ZvIMfDpdgnhBCCNEdGyoO8tfdn7QqYJHtSOSnmQt7PF6YVTPxm2GLuC3nHYqbjGVvrjzMbRtf4rdjL2BYZGInSxCd8XazbbBw5G/ncF2D4mc/05k6rf3n+HexTR+syD9sXAT+dLGiocH4rkeMqmXytAReetaFx6P41S9h+gyYOVNn6lRfgK09Lhf86Y+KnJzW605enuK5f3dtnbJYdK76ns60aUbBNDCGX7nqhxbWfmucqH/+ueLsszu/kL1vHzz1pGLnTsWILJ0f/aj/M6Y0pTg7YSz/Luh4PEp/e2qL+fvez3lq/1Ki2shqbXC7qHU3dmlZsWYHk6PSafS4yKkrodRVh0OzcHJcFmfFj2VkRMe/Sf+svEuutARlLMFj0dSZvnOYDesVV1zR98MgDTT/QF6LV19VzJ3Xd9l5TU3w6KO+17z8+xbGjDde7Be/t7N7h5sXnnayZaNxgWrfPsXvf68YM0bH44EDB4zeZiedpHP7Hcf+dxSqJJgnjmuDYhTT55hYvcKNy6XYtBE2bVTwXxg0SGfSJJg8WWfSZEhJ6f3r9bSSbbCMHKPx5eLm1y8ZTmFzMG9pyU6uHXYimhxYCCGEEJ3SdZ238tbx7wPLAyqiAsyIHsydmSdh03p3mB1rcXDv8NO5c8/71HuMMX4LGiq5Y9PLXJE5mxlxwxgemST77h5w6x4KGozMPG1PJs4yB07g0Ufhb4+1P86dfzBv7kIzb7xkfC+bNvm+g+Ej6zjnomQ+fd9NSbFOTY1i2VJYtlRhMumMHw8zZ+nMnAmpqa1f45WXfYG8yCgYN9HEsBEaO7a52brR0/oJ7WhqUvznOcX77/nWz4WnmRmeZSJrlMbe3R727VXs26czYkTby6ipgf/9T/HJx76MxH17FT+/26iGe801er9Wvrw4aSJ1bidbaguocTupcRnd1Z1+Xdvb0uhx0ejsXrEGm2ZmYmQqU6MzmBqVwVB7fMBvrdbtxK6Zu1SAYfdu2NLcDTt9sGL2fBkrrz1JKRqDhygOH9TJyQmvruBHW7zY+D03Ojuer77O1w3e7oCGejh8WLFyRd9l561cCUXNlbnHjNe49KrAYiyjxpq47692Nq518/zTTezfY2x7du4M3N8sXar43tU6iXJ9aUBIME8c9350q5WYmCbWr3FTWuI74KmqUnz9NXz9tbHRSk3VGT8BsrJ0Ro6E4cPB0s0iVC0bTYDUPsrM60j2aN9rxhUNoZBVABxx1rC18jCTYjP7vU1CCCFEOGlwN/HYnk9ZWrIr4P5kSxQ3ZMxh7qBhQcu6Ge5I4JGR53Pfgc8ocFYZr+9p4j+5X/Of3K+JsTiYEjOEqbFDmBo7lGS7DAzfFaWNNd6xDVWZ7zOrqlI8/hj89nd6m70zCv2O4yZNNfHRO03U1QbOMzy7FptN8YdH7fz3SSfr17hpaC5a7HYrNm+GzZsVzz4DmZlGUG/mLJ1Ro4xub2++acxrMsG9D9vJHuML/OQd8rD0MxdlRzrOhKmr071dFUtLfd3o5p9knPqddpaZvbuNCMMbbxgZif6rrMcDS5fCf/+jAgqrWa3gbA5MfPG5Iu8w/PFPer91szMpjWvSZra63+lxUeN2esehrHE3srWmkE/LdlPlbujSsjUU2RFJTI1KZ2r0YMZEJGPV2g+6HV2ptiNvveX7gC663ILJJAH4jkyZYeLwQSOzdfMmnbnzBrpF3dfQAM/925ex2xVnnmdm9nwTv/+5kS362mt9l533yce+dn3vOmub66RSiqkzzUyebmLFUjcv/dtJYb6x7YmMgtrmhPTVq+lyd30RXBLME8e9hCSNm++yoes6+Yd0Nq13s2mdmy0b3QEHaIWFisJC4+AFICVV55FH9E67S/grHODMvGEjNMxmowtH/cFYNJQ3o2BJyQ4J5glxDNB1ncP15SRYo9ocI0gI0XNFDZXct+O9VuNqnRk/hh9lnIC9l9l4bRnmiOex7At56OCXrKsOrJxZ2VTPsiO7WHbECCxm2GOZEjuUqbFDmBE3DJupm1cdjxP+lWz9g3kAGzcqPvhA5/zzWz+vyC8zLzVdMXykxrZNnoD7YuKMDLCUNI2777XT5NTZttnDmm9crPnGTXGhLxB36JDi0CEj2BMdrTcXKjOOD797rSUgkAeQkalx1f/r2nb9m69cPPZQozeQOGWGidh4Y9knnmrm+aed1NfByhWKt7N0Lr7EmM+/S20Lmx0uv9rCORdZ+OwjF/97zkldrZGlk5vb9wXkOmPVzMRrZuItvkEPZw8aytWpM/im8gA76orx6K2zGjWlyLDFkO1IYrgjvtfZtG05fBhWfWtMxyUoTlokp9+dmTrTxAdvGb+jDRuMgFa4WbUKbyAvJhaiB7V/3mcyw4JTzFx0hQWlYOwEjR1bPRw6pPhmpc78E4Pbtv37fUUvhgxTjJ/UcYKJpilOPMXM3IUmCvN0YuIVR4p0br/e2LisWtW17voi+GRrIkQzpRQZQxQZQzTOvtCC262zZ5eHTeuM4N6u7R5cfhn6RYWKjRt15nXjalHLQWBsnMJm7/9gnsWqGJ6lkbPLQ2G+YoJpCJvduQAsP5LDjVmnYO2DAxkhRP/IrSvl0d2L2VVTiE0zsyBxNGelTmRMdJqMzyNEL22oOMifdn5AlcuX6WNWGjdmzOXshLF9+trRZhu/H34GbxZv5sPSHd5x9I6W11BBXmEFHxZuIs0ew4MTLiXVHtOnbQtH+QHBvNafz/P/VUycqDN8eOD9Ld1szWZISFKMOCqY11ZRA4tVMWWGiSkzTFz3E52DB3QjsLfSze4dHvTmc+Dqat82evxkjQsv710g9oQFZjIyNR55sJHiQg/f+Z5veVFRilvutvHwvUYG0AsvKOLidfbkKD7+OLDIx9yFJq690UpSsvHezr3YgmaCpx4zUvRWfcuAB/PaY9VMLIzLYmFcVp+9hq4bw+hYrbTZPfvtt5U3QHvBpRYsVtkXd2bCZBMWizGu2/r1xmccbocw/kVn7v6dnfGTu55ed8U1Vn73M2M/88orRjDTP1O4rBRcbkhO7lnbPvbLyjvrgq6P32gyGefKYIz9mZKmKCrQ2bolvLtDhzM5axeiHSaTYvQ4E6PHmfjO1dDYoLN/r4cln7pY/L4R1Sst7fryGhuhrKw5q28AsvJajBxjBPN0XTG2Yhybo41gXq27kVs3vkSmI55Uewxp9ljSHDGk2mNIskZj7qCrgRBiYLl1D28eXssLB7/xdh1r9Lj4rHgbnxVvY8KgDH499nxiLI4BbqkQ4UPXdQ7UHWFDxUE2VOSyvjw3YHy8OLODXw9bxLjIIAyq2wUmpfGdlClcljyZAmcVG6rz2FCTx6aafGrcrQdlKmio5Pfb3+Evk64gso3B/49nLePlgS8zL3oQnHyGmfded+FyKR75K/zlrzq25o+uJWgDkJyqMJkUI7IDg3eTpnWc4aKUYuhwxdDhVi79LlSU66xbZWTsbVxrdMeNjVPcfo8tKF0xhwzXePQpOx4PrZY3d4GZ717r4X/PNaHrisf+Fvh4+mDFDbfamDKj9fHfrLkmnnrMmF61SnH5cVCk4Gi1tfDVV7B4seJAc4GRyVN0zjhDZ9YsI+B75AgsW2rMHxkFp58rp95dYbMrJkwxsWGNm9JSY1zHrL6LxwZdRQVs3GBMJyYrxk7s3tBKk6Zp3uy8w4cVu3bpjG2+XrRzB/zqVwq3WzFsuM68eUZiSXp615ZdU+NbJx0R9DhTVCnFrLkm3n/ThdutWLdOZ+HCHi1K9IJsUYToIptdMWa8iSYn3mCeEZzr2gFMcbFvOjV9AIN5fuPm2QvSsA0y0dh88p9bV0puXesIpYYi2TaI4ZGJXDp4JuMGdXGPcRzTdZ1Gjwuz0iQQKvpUbl0pj+z+hN01Re3Os7Uqjz/seI8HJ1yKRdZHIdpV0ljNhopcNlQcZGPFQSqa6tqcb0xEMr8edhoJlm6MtREkSinSbTGk22I4J3Ecbt3DnvpSNlQfZmNNHttqi3A1dyk8UFfKw7s+4rfjLujSQP3Hi4MtxzpNJlSVkU6SlqFx9Q+tbNngYf8eo4vbf/8DN/zIOM6rrPR1m0tNNz7L4SN921OlYMIUjb37ut6O2DjFqWdaOPVMC01O46JxSppGTGzwjhOVUu2OuXXZ9ywcyvWw/EtfAQmbHb7zPQvnd5BFlpikMXK0xp5dHvbtUxQX6z3OEgonug45OUb14uXLobEx8PPZtFGxaaMiNlbn1FOhvBxcLmOesy+wEBEZZullA2j2PCOYB7B6lSIrK3wCxitW+LJbF5xiRtO6970rpTjlTDM7thoXaTZvwhvM++QTI5AHcGC/EUh+6UUYPlxnbhcCe0uX+NbbkxeZcUT0fJ2cPd/M+28a58SrVikWLgyf7+hY0a979Z07d3Lttdcya9Ys5s2bx913301ZWRkAv/vd75gwYQJTp071/r366qve57799tssWrSIKVOmcPHFF7NhwwbvY263m4ceeoi5c+cydepUbrzxRor9IielpaXcdNNNzJgxg9mzZ/PAAw/gcnWvopEQLeITfRu9sm5k5gVWsh24A+rs0b4juty9Zk6PH93pczzoFDZW8k3ZXu7c/AqP7F5MhbPtExwBHl3nrzmLueibv3Pl6n/xaM5i1pbvx+XpuNqaEN3h1j28dng1P9nwYqtA3rSoDKZFZQTct7Uqj//b+wW6LgdbQvgraazmn3u/5Pp1z/H9NU/zaM6nLC3Z2W4g78z4MTyUde6ABPLaYlIaoyOSuCJlKn/KOpf/jr2SJL+2rS7fz3MHlg9gC3uvpMhDkzM42y6Xx83mSmPsQVUe7b0/NV1hsSp++isb1uZh6T76SLFmjTFdWOBbRmpzD4vMoYqI5o965Citw3GxOmOxKkaNNQU1kNcZpRQ/+ZmNydM1lIITFpj4x3MOLvmutdPuoLPn+Y4nV6/q65YOvMOH4a47FXf/TOPzz1VAIC97tBbQ66aiQvHmm4ovvzTus1rhnItl/MrumDXXt36tCrP1a9lS37qwsIeZb5On+d7/5uZKyB4PbNxo3Hd0z9j9+xUvvahx040ad9yueP31wOrbYASj/bvYnnl+79bJsRM0opuHHF2/zlccR/SffosoNDQ0cN111zF16lS+/vprPvjgAyoqKvjlL38JwJYtW7j//vvZsGGD9+/yyy8HYNWqVdx///386U9/Ys2aNZx//vnceOON1Ncbgy4+8cQTrFixgjfffJPly5djt9v59a9/7X3t22+/nYiICJYvX84bb7zBN998w3/+85/+euviGOMfzCst6/rz/DeoA9nNNmOIwt7c027PHrgufQ53ZZ7EBYnjmTVoCENssVhVx5k7nxVv47p1z/Hs/q/Iry/vh1aHl7Xl+/mieDsANa5GPi3axm+2vc13Vz8pgT0RFLl1pdy56RWeO/C1t1stQKRm5Y7MBfxhxFk8kHU2/xx1CVF+FfcWF23lnfz1A9FkIUJSfn05N294gfcLNnK4g/1ZoiWSRXGjuH/4mdyWeWKHVS4HWrwlgt8NPyNgMP8389bxjz1f0BSG+563XnZy/ZX1/PDyOl76t5Oy0taFDLpjR3UB9c3dkv3Hy0vLME6LModqXHujb7v5j78rysuPKmLWnJlnMhldYk882cSP7wjPgkM2m+Leh+28/EEEP7/XTlJK104PZ8/zrV+rVh3bGWfV1XD/fYq9e33vMyISzrrAzKNP2/nzEw6eeMHBvQ/bmbvA1CoT8tSzzMTGHdufUbDFJ2qMGmusiwcOqFaBqVBVUAC7dxvf9bARGkOH9yzckpyqeXty7dplVMc9cMAIFANMn23iyf85+MGPrGSPCXyNlsDezTcptm713b9zJ+TlGc+fMEVjSA/b1sJkUsw8wdgONDQYlbpF/+q3brb5+fmMGTOGm2++GZPJhNVq5fLLL+fuu+/G6XSye/duJkyY0OZzX3/9dc455xymT58OwA9+8ANeffVVPvroIy655BJef/117rrrLtLS0gD41a9+xfz58zl06BAej4fVq1fz1Vdf4XA4yMzM5KabbuLPf/4z1113XX+9fXEMcTiMq7B1tVDejWBeUaFvJ546gJl5JpMia5QxYHNJiaKuysSp8dmcSrZ3Ho+uU+6qo6CxmkJnFYXOavbWl/JtVa53nlp3I2/kreWNvLVMjR3CWamTmBOfJV34gDfz1rZ5f7WrgU+LtvFp0TaizXZOSMhiQeJoJsdkSldc0SVu3cObeWt5IfebgCAewIzoTG4dPJ8kq28E4uGOeH459DR+ve9j71hfz+z/igRrFAuSOs/KFeJYVuNq4N7t71LtV9CiRYRmYXJUOlOjM5galUGGLSasishkORL4WeZJ/CH3c+99HxZu4kDdEX455lziraGRVdgVy5cY27qqSnj9xSbefqWJE08xc96lZkaM7P6+c135Ae+0fyVb/yFQzjzfzIY1blavdFNZqfj745A9ijbnnTXXzKy5ximV2x1+wVIwMvTs3RxSNXOYIi1DUZCns22bEfCKju78eeHG7YZHH1EUFRnfefpgxcVXWph/khm7w7ceaJqv0ElFmc4XnzTx1ZcuIiIUl18dnoHegTZ7nondO4zg/epVcP4FA9ygLvhqmW96wWm9O7afNM1EYb4xhueO7Tr79/semzrTREqqxoWXG8Vyigo9fLPMzYqlLnJ2GZ+Z26344AOYMME4/luxwre+nnpmcMJAs+eb+HKx0ePxxRcVb75hZLFOnQq33KpjkYTUPtVvwbwRI0bwzDPPBNy3ePFixo8fz86dO3G5XDz++OOsW7eO6OhoLrnkEq677jo0TWPPnj1ccsklAc8dOXIkO3fupLq6msLCQkaN8u1hExMTiYmJYdeuXQDExsaSkuIbnDgrK4v8/HyqqqoYNCiwHH17PB5PSHdNajl4CNeDiHATn6Coq9UpLQWXy92lCkuFhSbAmDEpRR/Q7yorW7FtkzG9d6+HKVNar9uxmp1Yh52xjiTvfVtrC/lX/jccaAzMXjAGBz9IrMXBaUnjuCR9BtEWe5+0PdTX9ZyaIm/3HYBEcyTlrjrcR42t6B/YS7EN4qHxl5JoOwaPgvuZruvsrClga1Ue7uZttkkpMuxxZEelkGiNCosT8rbW81JnDX/a/RE7qgsC5o3UrFyXNovTYrNRSrX6bUyKSOWGtNn8q+BbwOg2/9Cuj9B1nfkJ2QjRH0Jt2+3WPfxxx4ccqvddlRtsi2FhTBZTo9LJdiQGjDHn8fQuG2wgzIkewo/S5vBUwbfePdC2qjxuXP88pyeP44yUCaTZYweyiZ3SdZ2i/MDP3uWCJZ+6WPKpi/GTFOdeYmb6bK3LBSP8g3mDKpNp6UydnBq4fv74DjO7d7qpKIP16xW7d/v24+0dx4Xaet7XZs7VeO91Nx6PYvVqNyedFHis09gIJpNRDCJcvfyyxvr1xrZgUCz87iErickK8NDe1xwdAxdebuLCy1uCOe3PG676Y12fcYLihebwwbffwjnnhvaHqOuwdKmxsisF8xZqvfp8JkxRfPqBMb1ho84+v8zQSdMCP/vEJDjvUo3zLrVSVODhl7c5qSiHtWugqsqNwwErVxhtM5th+uzWx4s9MXEKWG3gbMRbCAaM4jA1NTp3/9x9TAX0Wj6xoz87U3sDk/axAdm06rrO3/72N5YsWcKLL77IkSNHmDVrFldffTWPPPIIO3bs4Oabb0bTNK677jpqa2txOAIvF9ntdurq6qitrQUgIiKi1eMtjx393JbbdXV1XQ7mbd26laamph693/60ZcuWgW7CccFizQQiaWxUrFm9Dbuj841hbu44wIHJ5OHgoU0cyuvzZrbLTQxgZLKuX5eHph3p8nN/yAjWc4RvVTEFqj7gsYqmet7IX8c3Bbv5sW1qnwZNQnVdf9W5PeD2Vc5hRGNhOxVsVWXsoRqPCjzYLWqs4rFNH3KJdUx/NvWY4tF1dnlK+cp1iEOeqnbni8TCTHMap5qHhUVQr2U9P+iu5H/O7dQQOCDJKH0QF7mGEXOogS2H2v9NDAFOUMl8o4zxZD3oPLz7I7ZZRpKoItp93tGilZVkLXwyekToCZVt90fOPax3+3bEsbqV79cPI6pew0kh2wiTPl2dGApcQzavqH00qOYMN5exr34jfx2jtHjOtIwI2d91Xa2JujrjokPK4FqGZFWzeXUijfXGKcy2zTrbNjcRl+Bk1vxyJs+oxGZvP/BaqzvZ2+AbV9tS4ruIdqRsGxs3Bh7PnX1xBP97ZggANTW+fUZRyRbKK9u/yB8q63lfi09yYKxl8Pln1cTH+6p/7NgRy+uvjSAlpZ5rrtndpWPlULNrZwxvvD4SAKV0Lrj8EIfz6zicP8ANCyF9va4nJA2ntMTGjh2Kb77ZTmRk6I57f/BgJAUFxrH8kBG1HM7f2at1RZlN0NxzasXXTZSXGxmesfFOikp2UtzB6duo8cms/joel0vx+mt5JCY1UFZmtG14dg05e3b2vGFHGTc5lY2rY33t1nR0j2L9eo3f/Lqa71y+F7M5dJOiukNZLGCztVrvW3qQ9rd+D+bV1NRwzz33sG3bNl588UVGjx7N6NGjmTdvnneeSZMmcc011/DRRx9x3XXX4XA4aGgI7ALR0NBAXFycNzDXMn6e/+ORkZHout7qsZbbkZFdP3CZMGFCyGfmbdmyhYkTJw5YZPh4sny4k/17jIPFtPTxZGZ2PL+uQ2Wl8XNLSTcxddqUPm5hxzSPmw/fMILTJvNgJk3qXnXaqcD/03V21x9hcfkullXso1H37Vzz9GpiRg1mRGRS+wvpoVBe14saqti24Svv7ZnRmSwaOhuAOc33Vbsa+aY6l68r97OpJt+bsbfJXcyNo88k3RHbz60Ob00eN18d2cWb+es46Oy833stTSx1HWRcZhZnp07y3u/WPbj6IPPG6XFR426gxtVIjav5v9tv2tVIg6f1hSJd16moqCA2NhYdnW/K9uLC174IzcL1abO92XhdMUGfyD/zV/JJuZG17gHeb9rT7fd0cfp0rh0yLyyCoSJ0hNK2e1PlIVZu9/WFsmtm7h9xNsPt8QPYqr4zCZjXOJk/HPyC3KMy63d7ytjrrOCC1ClckTmbCFNodQc0utgZFzHGTrDzg59YaWzQWfGlm0/f1ShsHv+pvNTK4ndTWP55CqedZeKsC80kp7TeRi0t2Ynut9nTqozv3O6AefMntNquTZkCVeVNfPCmLxAVGw+zZk1us72htJ73h4kTdd76XyNVFbB3byxDhkwiNhaamuD//mFG1xWFhRF8/fUk7vhp13qyhIr8fPjze75T5e9fb+H8S0d18IzjS3+t6yee0sQ7r7rRdUV93XhOOCF0z8eXf+X7HM6/JJYpUxJ6vcy3shrZv1entNTX42nWXAdTp07p8HlRDg+rvza2nfv2D8Hj8X1uZ54Xx5Qpib1uW4uxY3Q2rPHgiIAR2RoH9+s88GsnjQ2QkxPDW29N4aqrPIwdG7rfXVe5ga379oXMNr5fg3kHDx7k+uuvJz09nTfeeIP4eGMH+vnnn3PkyBGuuOIK77xOpxO73Vhps7OzycnJCVjWnj17WLBgATExMaSkpLBnzx5vV9uSkhIqKioYNWoUHo+HiooKjhw5QmKisdLu3buX1NRUorsxsIOmDdwYZ91hMplCYsU61iUkmaD5xLqiwsSwYR3PX1HhKwOemqYN+HeUnqkAI4BQXNT1rilHGxedyrjoVG7IOIHPynbzZP433sdWlO0he1BqMJrbplBc198r3Ogdlwzg0uRJrdoYa4rgLNtYzkocy4bqPH657yPAyJR6LX8Nd446s1/bHK7q3U4+KdzK2/nrKGmsbnMerblbu4fWBw/P5i5nctwQUu0xPHfgaxYXbaHeHYLZ16XFre4aYY/nN8MWkWrrWmZ5CxNwS+aJaJrio9KeX5F9K38dKLhu2AIJ6IluG+htt9Pj4p/7vgy47+dDTmFkH1x8CiWDI+J4bNSFfFa2m49Ld7CvwXfxw617eKtgPR8UbSLVHkuqLYY0ewxpjhjjtj2GFNsg7Kb+7ytVUuTbfqekK0wmExGRsOg8OPUcnc1rdT55R7Ftg7EtqquF995w88FbbubMN3H+pRZGj9e826oNVYe8y7PpFqpKjVOh1HQNczt9Qa+5XmPrhgYO7DOO+7pyHDfQ63l/MZlgwSluPnjLhdOpeP01Mz++UeezT+HIEd/+YcUKjRkz4ORTurZcXYc334S6WsWV3+3/cbfq6+HhhxR1dcZ7mHeSiQsvt8o+rw19va6fcCK886oRTF+zxsSi00MzIFRfBytXGutHRCTMP8nS4/Mrf5Ommdi/NzAbcdosc6ef+aixGumDm8g/rLN9m+JgrtEWsxlmzw9O21pERMK8k3y3Y+PgN3/UuP+eBhobYMd2jV//SmPMGJ2LL9GZMQPCJLTSrlDZxvdbMK+yspJrrrmGOXPm8MADDwQEx3Rd549//CNDhw5lzpw5bNy4keeff5577rkHgEsvvZSbb76Zs846i+nTp/PSSy9RWlrKokWLALj44ot54oknmDhxInFxcTz44IPMmjWLIUOMtPjp06fz4IMPct9991FeXs4///lPLr300v566+IYFJ/gV9G2tPP5/SswpQ5gJdsWiUkKk8kY1Ne/OltPRZqsXJg0gc/KdrOvwfhAvj6ym2uGHj/ZOyWN1Swu8pWMynYkMjEyrcPnTIlKZ0JkKltrjRXky+IdXJk5m3RHXJ+2NZyVOWv4qGAz7xVsbHPQeosysSg+m0uSJpFuM6oUNrib2NtQyvKKfbx7ZBsAjR4XD+36CJtmbjUGXSg7KTaL2zIXYNd6tvvWlOLmjPmY0Hi/dHvnT2jHW3nrAAnoifDz6qHV5DVUeG+fnTCGOTFDB65B/cimmTk3cRznJIxld30JLxWuZ021L7jl9Lg5WFfKwbq2D2zirZHEWnzd8hOt0VyYMY2psUP6rM2FfuPlpRy1S9U0mDILpszSObTfCOp9swSamhQeD6z8ys3Kr9xkj9G48gcWps40sb7cV8hrjHMEO93G9isto/3tmMWquPPXNu68sR5nI0ycMvAncKHk0qusfPGJi/o6+PRTOP0MeOON1p/nk08qxozVSev40AiADRvgxReMc8WYWJ0L+rHwga7D3/+uOHTIeA9Dhil+8jOb7OsGSPYYjbh4RXmZzsaNRtZnKI7BtmKlUdEV4MRTzNjswVlfJk838e7rvmCeyQSTpna+DVJKsfA0My//pwldV1Q3X/eeMsNEVFTfr8sTJpv47Z/s/O2Pjd6LMjt3Kh58QJGZqXPRxToLFoT3eJqhoN8+vrfeeov8/Hw+/vhjPvnkk4DHNmzYwD333MO9995LUVERiYmJ3HLLLVzQvOU+4YQT+N3vfud9fOTIkTz99NPExsYCcPPNN+Nyubjqqquora1l9uzZ/O1vf/Mu//HHH+e+++7j1FNPRdM0LrzwQm666ab+euviGJSQ6NsIlnWhom2RXzAvJX3gL0WYTIrkVKMCWWGBceASjGOUE2OHs6/QOAnIa6hgX20JWVHJvV9wiHPrHv66+5OA7pKXJE3q9MBPKcV3U6YFZOe9fGiVZOf5qWyqZ0nxDjZXHiKnpogjzpo254vQLJybOI4LEicQbzlqDFWThfGRqYyNSOFwYyXrqo0CJftqS/q8/R1xaBaiTFYcmqXVuqLrOg0NDdjtdpRSRGpWTosfxZnxo3t9QqEpxU2D53Fh0gSqXI1dft6uumKezP/Gm+f4Vt46tlXmcVbqJBYmjR6QrB0huuNQXRmvHV7tvR1ndvCD1FkD2KKBoZRidEQyvx9+BquqDvKv/JUUtbNt9VfmrKXMWeu9va+2hNXl+1iQOIrrhi8kqbmIU3VTPXtqi8mpKaLSWU+iLZo0ewypzX/d2VYUFfiycJI7CAJlDofr79D5zrXw5Yc6X3yoqCw3tpU5Oz384ZeN/ORPDZQ3+do/pG4ILTnKqZ0cm2UO03jsGQe7d3iYM1+Cef5i44zqri8924THo7j3d1BVZXz2M+aYGBSj+HKxi4YGxaOPwIN/1Ds9gd+2zbefW/6V4oIL+i8b6913YOUKX4bVL+6z43BIIG+gtFQJXvKpkf25Z4/O2LED3arWPv8s+JViAcZNNGE2G4V/AEaP04iI7Nr6uOBUI5jnb95J/bf9Gj/JxBMvOFj+pYu3X2ni4AHjd3zokOLxxxT/e0nnggt1Fi0Cu91IMsnPh8hIiD82R70Iun4L5l177bVce+217T5+xRVXBHSzPdoFF1zgDe4dzWKxcNddd3HXXXe1+XhiYiKPP/549xosRAfi/YN5pQra6Mbnzz/7LSUEMvMAUtI0CvLcNDQoqqp0YmJ6v8wTY0fw38K13tvLj+w+LoJ5b+WtY1OlL7thlCOJ+bHDu/TcKVHpjI9MYVutsZJ8WbyDKzJnkxHG2Xm6rlPYWMm+mhIa2xgPrivcus76igN8fWQPLr39QbPjzA4uSprI2QljiexkrCdNKX6auZAbd71JlTswq2+QycYlyZOwqOAe5FiUiSiTlSiTzfgz+6bNqv2TR7fbzebNm5mU3bqrdrCk22JIt3V9/jGRyUSYrDx6aJl3i7erppBdewp5ev8ybstexImJMp6QCE26rvP3PZ/j0n2ZXjekn0C0uRs/gmOMUoo5MUOZEp3Bysr97K8vo9BZTaGzmoLGKmo9zs4XAnx1ZDfLj+zG1Lz97GibDRBniQwI7iXbBmFp7rFT725iX20JOTVFlDRWo3LOAYyzuuQujNwREwsXXQXnXqbz7TIjW+/gPiNT75236+Es37yxVSne6bT0zo/N0jI00jIG/oJsKDr/EgufvOeitET3BvIArrjGQkamxvYtbgrzdXbvVrz2Knz3qo6Pm/f4ja60Z4+iqEgnJaX9+YNl82Z4/nlf+2+/x0b6YPnOB9q4iRpLPjWmt28jJIJ5mzfDhg2KKVN04uONrDOAIcMV2WOCt87YHYpRYzW2bzH2XVNndv2YMC1DY/Q4jV3bjeeazTBzbv+mwpnNipNPt7DwNDPrVrl56+Umdmw12nPkiOLZZxSvvaqTng7794PTqbBadX71a53JfkOTtpQukATZQJLYKEQP+AfzSruUmeebPzUtNA4KUv0OXAsLCUowL8MWwwh7vHcsnuOhq21OTRH/zV3hvW3XzPx86MmYOgjU+FNKcVXK9IDsvKf2LePecReEzedW1FDF7ppCcmqK2FNTRE5NETXdyPjqiXTrIC5JnsRpcdlYu9HlNN4SwU+HLODe/Z967xthT+C3wxeRYu36OKrHq0XxRrDusUNfeYu3ANS6G3lo10fEmB1Miu2kIpAQA+Dr0hy2VB323p4ePZiFsSMGsEWhw66ZOSUuG/yuIem6To27kQJnNYXOKgoajf+1biPA1+Bxsbb6kHcroNN5EK9FeVMt5U21bK/uvMyjtcRqjH4a0cA/8pcSbbYzyOJgkNnGILOj+bbd+G+2Y9PMKKWwWOHERTBnoc4t34PaakXummg4yQoOJynWKBpKHN7X6SwzT3TMZld874cWHvuTLwA8Y46JkaONwMNPf2XjF7c04PHAG2/AlKkwblzby9J12HNUbaYVK+Dii/uq9YaSEvjLnxUej3Hs9Z2rLczq58CHaNu4ib4A1vbtiks6SaLoa7m58Pt7FW634u23FDabrz2nndm6t0VvzZ5vZvsWJ5oGs+d1b51ccKqZXduN32V/dbFti6YpZp5gZuYJZrZvMYJ6a7819hnV1Ypdu3zzOp2KPz8MDz2sk5FhfN6PPWZ0Fb73dzoZgwfkLYQk2UIJ0QNx8QqljAOO8q4E80IwM88/qFhYCKNHB2e5J8aOYF+h8aEcq11td1Tls6RkBzk1xeyrLcbtl+lxY8Zc71htXTUlKp2JkWlsqTXGbltdvo+VpXuYl5gd1HYHU73byVclu/iocDO7a4Iw8GInEswRjI9MJTsikVERyYyPTOlywPRoswcN5eaMeXxYuoPJUWn8IG1Wj8egOx4tih/F2MhkPjyyg8/Lc6hxG4Fbt+7hDzvf52+TvytVmUVIcXpc/PvAcu9tizJxU8axfaGpt5RSRJuNINmoiLaLg+yuK+GfeSvYVdf+kAV2zUyDx9Xu4x1qMkF1JACeuErWVOR28gTjux1kMQJ7g5rbb5mSBcuHo1xmtC0j8czazhnxY9jvd6G1ozHzRNcsPM3Me2+42L/HOCa64hpfd+pRY01c+QMLL/3b6Ir76KPw6KM6UVGtl1NQALW1gd/HyhWKiy/uuwCO0wkP/Ul5swqnzTJx+fdl6IhQkZ6piImDynLYsRM8noEroODxwBP/NAJ5LVqKHJrNsHBR8I8nz77QjMVinEMOGd69N75wkZl3X2+i7IjOBZeFxjo9bqKJcRNN5O738PYrTXz1hQuPx3h/FiscztWpqVE88Ae45BKdp59W3vEIX34Z7vpZaBZBGQhy9iJED5hMitg4YzDWrhTAaAnmxcSCIyI0DhiPzswLlqO72r58aBVjo9OocTdS42po/mukusmY9qAzI24YVw2ZS4zF0cGSe6+ksTpgnLQIk5URkUlEdrGblUfXefnQt7x48Js2H58fM5xFcd3vZqiU4qaMufxk91vebKcn9n3JlNghXW5bf/HoOm/mreXlQ6uod3etC1ZPaShmDRrCWQljmB49uMfBu7acmziOcxPbSQsQnRpsi+VHGSfwg7SZPH54OV+WG2kU1a4G7t3+Do9OvjLk1l1x/PqwYBOFDZXe2xcmTiC9m9WgRWujIpJ4ZOQFrK46yJ76I977rZqJLHsCWRGJxJodVLsaKXRWGd13nVUUNlZ7p4udNa0qjjs0C1mOBBxliWzWjWMVPb6qS21q0t2UOmsp9RvbT00sx7rcGPrCtH40Z58FlyVP5qfNxz5mS2CPC9Ezmqa4+3c2Xvq3k0lTfVl5LS6+0sKGNW62b/FQUqx48kn46U/1Vt3mcna3XnZfd7V98UXFnj1GQ1LSFHf80hbUap+id5RSjJ1g4tvlbupqFQcP6gwb1rXnejzw2adQUwMjsiArCwb1YvP/2We+LrUpaYqUNMXm9UYA++QzzMTEBn+9sVgUZ1/Ys0BcVJTin887aGyAyAHKymvP0OEat99j48e3W3G5ICpaUV+n8/Nb6jm4Xyc/X/H3vwe2+ZtvoLwc4sJ3NKKgkmCeED0Un2gE8yoqjAE72xvWqqnJV/E2JUS62AKk+AXzjG7AwbnKcXRX2xWlOawozenwOe8XbGJJyU6uHXoiZ6ROCGrQBoyMoX8fWO6twHm0dHsswyITGWR2EGW2EW22E2W2E2W2ef87TFaeO7Ccb8r2trmMNOsgbh08v8eZHsMc8VyaPJlXizcCUOqs5fncFdyYdUqPltcX6lxO/przCStL97T5uIZimD2OkRGJZDuSGOlIJOGoYhTdEWWy4ZCiCiHNppm5bfACChur2V5nXLU4VF/GXZtf4easU5kQI30hxMCqbqrnf4e+9d4eZLJzecqUgWvQMUZrHnevo4rA0WYb0eYkstvI8HPpHipc9ejNAyJpShFnjkBTirVrYXPzfGnpJmyRyVS66qlsqsPp6VqXXgA9tQxPWglaQRJafjLnuBLRdN+FzNQ0JYGbIEnL0LjrN/Y2HzOZjCDZbdfVU1drFLaYPl3npJMC58vZ4/suxk/W2LbJCJSsXAEX9UFX26Ym+PxzY9pqhV/cZyN6kKwPoWbcRCOYB8a4eV0N5n38MTz9VOB5xejROr/5bduZoR0pL4fn/+tbN26+08akaSYK8jwUFehMmBI653n+zGaFuZvvtT/Z/QrMOCIUv3rAzs9urKfKdw2OpGRFSbGO26349FOdyy8fgIaGIAnmCdFDCYmKvbvB41FUVujEJ7Q9X3Ex6M1XllNSQ+fg4OhutsHk39W2q2pcjfx97+d8UrSFm7NOYXR0B2XruqGyqZ4/7fyQjZUH250nv6GC/IaKbi97bEQyoyKSyHYkMSdmaKcFGDpzRcpUllXspdBp1I9/v2AjpySPY3R0F0b97mOH68u5f8d7HKwLTEWNNtk4LS6bE2NHMMKRgE26qx53rJqJ3wxbxG0571DcZFTEPFBXys+2vMYpSWOZmzCSNHssqfYYIsy9+40I0V0vH1oVMIbn91Kn9XpbLYLHrDQSLZFtPlZY4Ju+fNIYTp060Xu7wd1EZZMR2Kty1VPVVN982/ircjX/b77tmJNHxdtGMPHzzxUXXaTjdBrHZDJeXv9JStG46ac2/nK/8Zt88l+KMWN0Uv0Oc/yLX1xzg5W7bzYKVq1cqbioD7rabtwIdc3deucuNDM8S6oVh6JxE32/0+3bFWef07V1wb/KbItduxRLluicd17XXruuDrZugfffV94u4CefbmbSNGNdMYrjdG1ZonMpqRq/uM/OA79qoLEBrvmRldnzTPz4e/V4PPDpYsWll+rtJtK0qK2F7dth61ZFYQGkZ0BWlk52Nv1SUKc/yFmXED0UnxBYBKO9YF7AeHkhdMDoiPCNP1EU5CHPzk0cxxflORxu9F1S8a/qGW2yGdNmG3vqjnCwscI7X05NEXdsepkzUibyg2Hze9X1dm9NMffveI+ixq51z+kqqzJx6+ATOTU+uGPa2TUzP8mYx6/3fwIYuZJ/3/M5j035btCzFbvKo+t8ULCRfx9YTqPfuEcWZeKG9DmcHj+qWwUoxLEp1uLg3uGn84u9HwVUCv6yZAdfluzw3o6xOEi1xzRXsowl1RZDhiOWsYPSB2wdF31jZ3UBL+SupKKpjmiznUiTlUZnLetzaxhkcQRkPhsXAVqfcCXZokmxB/aHqnM5OVRfRkTzPiTKbMeitT6ir3Y18HzuCj4q2Oy9L8MWw1kJIVAGUXRJYZFf8bCjjp/sJgt2k6XV+tGemvE6135QZ2RhfQbr1/kvO3QutB4P5p9sVLVc8qmL+nrFo4/Ag380TsxdLti3z5gvNV0xaqyJESM19u3xkJPTN11tV67wff9zF0ogL1QNH6lhd0BDvRGg0fXOK5sePAj79xszDR6imDDZxCfvG8eya9cqzjuv7YCgywW7dsHmTYpNm2B3c/JGi+hB8IMfy0WhvjRuookn/xeBpiAi0vjsZ8wxsXqlm9JSxZrVOnNOCHxObS3s2AFbtii2bjGq4/p/bwbj9okLdG66ScfRtyM89Tk5AxOih/zHVynrIAnNP+stVIpftEhN06gs91Baqmhs1LEFaYirKJONJ0dfRqGzGptmIspkazdjy6V7eO/IVl4sXE+9pwkwglifFG1hVdk+HpxwCcMiE7vdhqUlO/lbzqcBASiHZuHWwfMZao8HdEqaatlTf4Q9dUcodFYb4/q5nd52tCXZEsVvhi1iZET329QV0wdlsjA2i2UVRnfevbXFvJe/gYsypvfJ63WkoKGCR3d/GlABEiDREslvhi1qd1B0cXwa7kjgydGX8u+C1XxW3sagR+DNmtlVHZgOPDIymb9MuhybdKs+ZjyyezGH6lvvHNfldy8VfF7CSG4YfhIxFgdv5K3l1UOraTqqaqpdswQEB6PNdrZV5VPlqg+Y74dpszBL0DhsBBw/9TLgFhWtmHOiieVfumloUOT7FdIdniXrRH+7/hYr27e4KSrQ2bVL8dprcOWVOgcP4s2YzB5tfC9zTzKxr7moxtIlcPkVwWtHUxOsWm1MR0TC1BkSzAtVJpNi9DiNTes8lJUZgd3UTjquLFvm226ceb6Fcy4yAsklxTrbtkJ9Pd5gTlERrFplBPC2bsVbcOFodjvccretT8bGE4GOrrx71gVmVq809v8ffaSYOElnxw7YusX4zvbtayt417blXykO5sI9v+x8PQplEswToocS/IJ5HRXBKPK/shxCY+aBcdVz13ZjurgIMocEb9maUl0aYNysNC5OmsTC2CyeyV/F0grfmHTlTbX8Yuvr/GnCZZ0G9HRdp6KpjsKGSpYd2cW7+RsCHh9si+G3w04n0x7rvW+4I4FZg1q/aZfuaQ7sNVLjclLjbqTa3YiOzuxBve9O25kb0uewtuoQtR6jwMTzuSuZl5BNchczEHrLo+t8WLCJfx9YTsNRgc3JUWn8YsipxPZxsRIRnmItDn46ZCFnJYzh6fxv2VFX3KXn7akt5t38DXwnc1Yft1D0hyON1W0G8npiReke1pYfIMbioLixus15GjxNNDibOOKsaXc55yWMY86g9sd1E6GnqDmYZ7EE9oboqQsus/DNcjeuJmOc46HDNabOMnHiqXI61N8iIhU//ZWNe25twOOB11+DKVPg0CHfPCPHGIG1E08x879/N+HxGN0czztfJ6Lnw/EG8O9iO2uuGYtVAjShbNwkE5vWGYHd7dvpMAjj8cBXXxnTmgbzTzKjlGL6HBOfvOfC5VJs2qQzZw7kHYY77lDeQPLRBg9RTJpmYsp0E+Mnm0KukMTxYvJ0E2kZioI8nc2bFVd/r+Pg3dARRjbmhMkmhgzXyDvoIWeXhw/fbqKuFnJzFXfdCeeepzNypDEOo64bxVJqaqC2BmpqW6YVNTVQ3wjJQ6KYPLn/3ndHZO8lRA8FZOaVtl9AoiiEM/OMghzGFY7CIAfzuivBEsnPh57CmQlj+L/DKzjU3PW2sqmeX2x9nV+MPodYSwRNbhe73KUcKthEsbOKgoZKChsqKGioDMjC8zdr0BDuHnJyl4NwZqURa3YQa3bAABTkjLdE8P/SZ/H3w18DxonqE/uW8LtxF/T5axc2VPJozmI2VwZm49k0M/8vbRbnJoxD62GRD3H8GBuZwiPZF1DrdlLorKawsYoCZxUFzdOFzmqKnNXe6s0ArxxezempE4jtRdEUERqOzrwc5UjCpbspq6+h0aR3mP3clkaPq91AXmcybDHcmDGX6dFSjCWceDy+IUBS0hSa1vv9zsjRJp54wUFVhU7mMA2rBG4G1OhxJi6/xsLLzzXh8RjdbbP9Ri8Z2ZyZl5KqsXCRmSWLXdTUKD78QOey7wSnDdLFNryMm2gCjP3Hju2KU05pf9y8nTuhpNj4fqfMMBEb7+uq+cl7xvnCurWKOXN03norMJAXG6eYPF1j0jQTk6ebSEwKrWSM45WmKc4838JzTxjJDkcH8vyDd+MnmxgUE/h4RqbGrHlw0mlmHvxNA3mHdGpqFK+83L19gcmcxvkXd7+ASl+QYJ4QPRSf6Nuwd9jNtvlg1GSChKTQOnD0Hycm2EUwempyVDqPZl/Ar/d9zM7mrJ7Kpnru2fpG4IwHura876ZM46qUaWEXgDozfgyfl+32ZjZ9W7aXb0r3cELCyD55vY6y8SZGpnF75oIuZVoK4S/SZCXLkUCWo/Wgom7dwwdHtvOv/G8AqHc7+d/Bb7gp69T+bqYIspwa30CsGoqHss7BgsbmzZuZNG4SaIoat9ObAd3URmXSeo+LV4o2eKskt4gzO/he6nSiTbaAZbRkUlc3T2tKY17MMC5InIC1jTH1RGirKKdPClQkJWskJQdtcaKXLv2uhY1r3ezY4qG4WFHcnMytaZCV7fvev/M9C8s+c+HxwLvvKs45t/fZedLFNvyMGqthNhtj2q1eDYmvQlYWjBwJsbGB8y5b6jvuX+CXfTtxqgmrDZyNsHYtlJXCsmXGY5FR8IdH7QwboaHC7LzheHHaWWa++LiJgwf0ToN37ckYovHw/zn4+58bvRWSuyNzWD12e2j0UJJgnhA9dHQBjLboui8zLzlVYTKF1o4hxa/bb1Fh+9mF/S3SZOUPI84KCOh1V7w5gpsHz2NuzLDgNq6faEpxy+ATuWX3W97spRcPfsOc+KygH2AUNlTyt5xP2VR5KOB+ycYTfcmkNM5NHMfHZTvJbSgH4MOCzZyfNpXBEfED3DrRG7trfFeHhtrjsJssuN2+A2aT0ogx24kx2ztczvTowXxRnsPzhWupdjdyVvwYvpc6XarRHgcKQrhXgwgek0lx+z027ri+nrpa3/2ZwxR2h+97T8vQWHiamSWfBi87b9Mm6WIbbmw2RdYojV3bPVRWKl7+n+87S0jQyRppVCvNyoKVK5ufY4fZ800By5g01cTab92Ulyv+8Q9wuYzlnHmeRaoZh7jIKMVjzzpwOo3vsjfL+cXv7RTkedi728OeXR4OH/RgsRpj9UUNUkRFGeOtRkYr475ocER6KCjciVLtVL7sZxLME6KHoqLBagWn07iq05bqaqivNzY0KSE2Xh5AWghm5rVoCej9dt8nrTIzWjg0C2nWaFJtg0i1RpNmNf6n2qJJtQ4K+4HOhzviOTdxPO8e2QrAvtoSNlYeZGpscMZ9cnpcvJW3jlcOrWrVRXlCZCp3ZC6UbDzRp0xK47q02fymuYKzB51/H1jOb/uhS7noGx5dJ6fat83uTaEcTSkWxY/itLhs3Ohhv00XXVfkt9sPZmaeCD0pqRo/vt3GIw80eu8bObp1QOWy71lY9rkvO++EuTrp6UYWX3d4PMZYef6BIOliGz4u/76Fv/2xkarKwPtLSxWlpbB6VWCAZ/Y8Ew5H4H3TZxvBPID1643HzGY45yIJjYQDpVTQijamZWikZWjMP7lr87vdvl53oUDWWCF6SClFfKKiMF9vt5utf4AsNQSvLMfGK29AMtSCeWAE9B4aeS7bagupdxtdPz0eD0cOHGb+uKnEWSOP+TT4S5Im8sGRbd7svDcPr+1xMG9XdQHry3PxoOPRdZaV7CSvoSJgHptm5trUmZyXOF6y8US/mB49mKlRGWyoyQPgm7K97K8tYXikVEsOR/kNFdS4fSflwah6rZTCjGyPjieFBb7vWzLzjn0LTjWzbpWLZZ8bAZaxE1pH6NIHB2bn/eRmRUSkTtYIyBoJI7OMzKzUVGjv8GXtWnjqSUVxsW8G6WIbXqbNMvOfN00U5Ons3e1h7243e3OM7Kr6utbzLzytdbhjxhwTTz4WeN+CU80BQygJEQ4kmCdEL8QnGMG82lpFY6Pe6ipBKBe/AGMg0ZQ0xaFcnaIi42pld69w9jWz0pgcle697Xa72UwFMWbHMR/IA0iyRrEgNoslFXsAWFeR2+1Ah1v38Oz+r3g7f32H80k2nhgISimuTZvJhpw8733bqvIkmBemdrdR/EKI7vLPzEuTzLzjwo9vtxER6UTX4aRFbZ+iXvY9CyuWunAa499TV6vYsgW2bAGaA/6RkTojsmDMaDjnXN07llpuLjz0J0VTk+/YMS5B8cObrdLFNsxomiIjU5GRqXnHw/N4dG+Ab89uN4cO6GSP0Zg2q3WgNilFY+gIRe4+3/BCF37H0m/tFyJYJJgnRC8k+FW0LS2F9PTAx/3TcFNC9GA0JU3jUK6bpiZFeblOQmgMASD8XJI8yRvMA3grbx13jjqz3fndugdnc7fZWlcjf9n9Savx8PzFmO38MG02p8ZlSzaeGBAjHYlEmWzejC7/AgoivPiPl2dRJoY5ZPxD0T0b1sOatb7bySF4MVQEnyNC8aPbOu47lz5Y46H/s7Pqa3dz0MZDeWngeM+1tYotm2HLZli+HO7/g05MDPz1r75A3riJGudfZmHmCaaQG89a9ExbAb6OzJhtJnef0etn2iwTQ4aH5nmaEB2RYJ4QvRDvF8wrK2sdzDOKShhCsZstBFa03bsXCeaFoCxHQkA3xKUlOxlkcVDnaqTa1UCN3/8aVwN1bmeHy2sZdypCs3JyXBbfS51OlClIg08I0QNKKbIdid51fE9NzwrfiIHnn5mX5Ug4Jse5q6yEN15XpKTqnHvuQLfm2KHr8PZb8OKLCo/HODaZeYKpV4Oci2PP8CxTQJGCslJPc3dLYxD7vTm+AF9hoeI3v4YxY+BgrrEeDR2huPfPdqySjXdcO+1sMx+/14THA1f+QLLyRHiSYJ4QvZDgN7bC558pxo/XA8bp8O8mEooFMACyx5gAI4vrmaeN9xAZObBtEq1dkjTRG+hw6R7eylvX7WU4NAt3DzmZOTHBKaAhRDCN9Avm5daV4vS4sGpymBJOXB43e2t9gdhgjJcXaioq4De/Vhw6pABFVpaHsWMHulW943bDt99CXByMGzdw7XjuOcV77/oOombNNXH7PXKhSXQsPkEj/gSNmSf47ivI83DfLxooyNMpLFTecaEtFvjprySQJ4zCB0++FIHbDbFxsj6I8BSa0QUhwsSseSaszceZS5cq3nk78PGWbrbRg4wS2KFo/skmxk40NgXFxYqnngzNdh7vpkUPZpg9rsfPH2yL4bHsCyWQJ0JWdkSid9qte9hfWzKArRE9YQRh3d7bx9p4eYGBPMPaNeG/z1y6FP78sMYv79F49hmF293pU4IuLw8+eN93+8ofWPjFfTYiIsP/8xX9Ly1D4/5H7KRlBK4/P/ixlaHSnVI0ix6kJJAnwppc8haiF1LTNW79uY2/3GeM8/T884qMwTqzZkFTE5QeMeYL1aw8AJNJccc9Nm6/vp66Wli2TDFtms7Ckwa6ZcKfUorbMxfyhwOfcaSplgjNQpTJRpTJRrTZ6p2OMtmINtmw+2U0JVgimTkoE5tkOYkQNtKRGHA7p6aI0dFpA9Qa0RP+4+XBsZWZV1XVOpAHsGEDXP39AWpUkOzc4XtP77+v2L8ffna3Mc5Yf3n9NV/X2iuvtXD51db+e3FxTEpMMgJ6v72zgfzDOrPmmTj7QjkOEkIcO2SLJkQvzT/JzOFcD6/8twldVzzyV3j0b8ZYHS0HpqFYydZfcqrGj2+38cgDRlDyyScVY8bqpKQMcMNEgNERSTw/9ko86JiOwXGoxPEt1RotRTDCnP94eRGahQxbP0aD+thzz/kCeQlJCqsVCvJ09u1TVFT4KmaGo+KjhqjculVx153wi3t0srK6t6zDh42/mTPB1LqIZJvy8uCrr4zp6EFw/iUyfpUIjsQkjUefcrBnt4cx4zWUFPkSQhxD5GxQiCC4/PsW5p1kHLU2NCg+eN83PgdAaghn5rVYcKqZkxYZ8f26OsWjjwxMVxvRMaWUBPLEMamlCEYLKYIRfnb7BWCzI5KCUh1b1+GFFxQPP6yorOz14nqkoACWLTWmo6LhD4/YmbvAdz1848YBaVbQlDT3aLdYIC5eNd+nuOcXyvu+O6Pr8MEHcNutij/9UeOtN7v++v5ZeRd8x4IjQgIuInhsdsX4SVK1Vghx7JEzQiGCQCnFjT+1YW3uFbJsmXFlukVyiGfmtbjhVqs3i3DnTsXrrw9wg4QQxxX/rrYtRTBEeKh3OzlQe8R7O1jj5e3dC2++oVi5QvHOOwOzL33NP9h0mYW0DI0pM31pZxs2hMc+vi0ejy+Yl5qu+Ou/7Iwaa5weOJ2KRx/V+PezHV/cczrh8ccVzzyt4XYbn8VHH3XtguDRWXnnXChZeUIIIURXSDBPiCCJilKcsMA4uK+pUXz4ge/gPhwy8wAiIhV3/NKG1tzc115V7NwROE9jIzz8sOL22xWffWacCAghRDBIEYzwtaOqAA+69/bYyOSgLNc/y33H9qAssluOzso75yIj2DRmvIbdYdy/cUP47gsrK6GpyTheSU7ViE/UeOBRO4vO9mUevvee4t57FVVVrZ/vdBpjCS75MjCgWV6u2LCh49euqICnnpKsPCGEEKInwiPCIESYOO1s3xXlwkLfAWmoj5nnb8x4E5d/33gfHo/ikUcUdXW+x99/H1auUBzYr/i/f2j84ueKPXv6tk01NVBUZPyVlIAepidNA03Xob5+oFshRPtaF8GQrrbhYltVXsDt8ZGpQVlueblvet8+o7hUfzo6K6+luqrFopg4xbiAV1mpOHCgf9sVLCV+P7GklOb3ZlXcdKeVH99uxdwc09uyWXHnnYp9+wKf/+mnsGuX8TybHc483xcE/Pyzto993G746EO4+SbFpo3GPJKVJ4QQQnSPBPOECKLxk7RWgTtNg8Tk8AnmAVx6lYWxE4zNQ3Gx4sknjfZXVBjdnfzt3q342V2KZcv6pi1ffQU/uEbxoxs0fnSDxo9/ZOGZZ8b0+wlduPN44Le/VVz13b77roTorZYiGC32SBGMsOEfzBtii2WQ2R6U5ZaX+fY5Tqci90BQFtsl7WXltZjq39V2ff+1K5j8i18kp/g+a6UUZ55v4f5H7MTGNY+jV6z4xc8Vu3YZ8zidgccEv3/YzvW3WIlLMO5bs8Y4bvC3cyf87C7FU09p1NYa80VEwm2/sElWnhBCCNENEswTIog0TXHqmYFFopNSFGZzeB2gmkyK239pIyLSuL1sqREAevUVRX298V6mzTIxeKgxreuKJ/6pKCgIflu++ELhcgV+fvn5kXz7Tfc+U6cTHnxQ8dvfKGpqgtnC8HDggJFZ4fEo3ns3vNZHcfxQSjHSkeC9LRVtw0OTx83Oat8OYEJUcLLyIDAzD2DX7qAtulP+WXnnX+rLymsx9RgYN6/Yryd7Ukrr04KxE0ytxtF75K9Gxv6nnxrdaQHmzDcxZoJRZOCU043jILfbd/GoogL+/rjiFz/X2LfP91mdcoaZfz4fwYw5gcdOQgghhOiYBPOECLJTzjTjX8AvnLrY+ktJ1fjR7b4MmX89oVi82Ji2O+CWu608+pSDhaf5qvg+8leFK8jj1ZeVGv/NZpg113fi9Mkn3dt8LV8Oq1cpNm9WfP55MFsYHvzHPty3jwGrCilEZ6QIRvjZU1NEo9/3ND4yLWjLLisLvL17d9f2qb2txt5ZVh5AWobmVzQqPIcxKCn2fZ5JKW1/tglJxjh6Y8Yb+92iIuMC3ltv+ub/zvd9n88pZwZ2tf3oI6NL7Rdf+OYflqXxx8ft3PpzmzfzTwghhBBdJ8E8IYIsMUkLuFqfEibFL9qy8FSzN1hXX+/LULj4Cgtx8RoWi+LHd9hIH2zcn5OjePWV4B6Ut2RlJCQp7rnfxpBhLSdOGvv3d305O7b72rVv7/F34rBzp+8967pi48aBa4sQHTm6CMaasm780MWAOHq8vAlBGi8PWmfm7d7V8fxVVfDAHxRXXqH47NOev+7rR2XlRUa1vd9o2d+7XIrtA1Cgo7dK/DLzklPb3zdarEaBrJaM/eXLFWVlvqy8ESN9xz0ZmRrjJhrHPocOKZ56MrBL7XU/sfLXf9kZO8GEEEIIIXomfKMMQoSw0/yqwA0dHt4/sx/dZgvILoxPUFxwme8KvMNhHOCbmo/J33iDoJ3QNDYalYEB4hMVSinOON938P/RR10Pyu3c6ZsO14HKe8P//QNsDNMuYeLYNzoisArqw7s/Yn157gC1RnTFVr9gXrIlimRrVNCWfXQwr6Cg7aqqAPv3w113KtasUTiditdeU+h62/N2pKAAli41ptvLymsxbqJvn7R3b/dfa6C1dLM1W+g0Qy4lTeNHt9la3e+fldfi1LNad5s9+XQz//xvBOdebMFkkn2QEEII0RvhHWUQIkSdcKKJq35o4dyLzW0e0IaTiEjFHffYsFqN2//vJis2e+BBePYYE1deaxzM67ri3XeCc5DufxIXF28sc+GpJqw2o//UV8vo0vh31dVw+LCvTYcPG2PoHS/KSo1CJv42bqRHJ7lC9LUUazRnxI/23nZ63Px+xzsS0AtRHl0PyMwLVhVbMCrXVle33p/sbmPcvOVfwc/vVgHbupISRV5e63k709WsPIAR2b5Daf+x4MKBrvuq2SYlKzSt8/YvPM2XsQ+ts/JazFtoJiHJWN6wERoPPmbntl/YiI0Pr89ICCGECFXhHWUQIkQppbjsKutANyNoxkww8ffnHNTXGePctOWiyy2882oTNdVGFpiuEzB2YE/4B/Pim6vjOSIUk6ZXsXZlHI2NiiVLdM47r+Pl7DqqW5bHozh4UGfkyN61L1zsbKNbWnm54sABneHD+789QnTmJ4PnU+d2srzS6GLr9Lj57fa3uSh9Gt8dMgeH6djZvoa7g3Wl1Lgavbf7qviFxYK3ivnuXYoZM4yrEW43vPC84h2/i0iOCKivM6Y3bIDBg7v+mt3JygNIy1DY7dDQAPv3df11QkFNDd6iVu2Nl9eWG261UVvTSGW5zrU3tf1btDsUf33CweFDHsZO0CQTTwghhAgyycwTQnRJSprWbiAPjAq4o8cZV+crKxWFhb1/Tf+Bz1uCeQAz5vrO8D7+qPNuVLt2tj6JOJ662vqPlzdlhn/1xYFozcDZvBn+9Cd13L3vcGRWGncPPYUTY3zRZrfu4Y28tVy/7j+sOJIzgK0T/rYeNV5eMDPz/IN5/tuuloq2VVVw3+8DA3mnnmnm/r/avbe7W2XWPyvvvE6y8sDY97XsG4uKwqtaekknlWzbExml+PWDdv78hIOU1PafFxuvmDDZJIE8IYQQog9IME8IETQtle4AduzoYMYuKvcL5sX5BfOSUpyMn2y8Vn6+YvOmjpdz9HhxAPvDrDtUb/hXsr3iGl+WSXdPcsPZ7l1w/32Kb79R/OPvx8/7DmctAb2TYrMC7i911vCHne/zXr5EZUPBtqrD3ulBJhtDbLFBW7b/PmDUWM073EJOjlGV+2d3KTZtMu4zmeCGW6385GdWskZp3gtAW7d0fVgF/6y8yCg4t5OsvBYjRvr2feGUnVdc7JtO7kZmnhBCCCEGngTzhBBBM2a8L3NiZxvZcN3VUikPID4hcHN1VhcLYbhcvvGVogf57j9WM/OcTnj4YcUdtyv27TOKiOxrPrnMyFSMHqd5Kxbu2G50DTvWlZTAgw8qmpqM911a2v4A+iK0mJXG3UNO5tfDTiPZElhU4Yl9S/i8KAzLhx5D1pfnsrb8gPf2uMhUVG/HV/BTdtRQC9ljjf1AXa3i7p8pioqM14qJg/v+YufsCy0oZRRLasnkczoVO7q4mrzxut9YeZd1npXXYrj/uHlhVHy5q5VshRBCCBF6JJgnhAiakWM0tOatSlvZcN3V1ph5LWbO9WVerFkTeFLi78ABaGw05psyw0RCojG9/8CxWQDitVcVK1co9u9XPPSQYutWcLmM9zxmvAmlFFNnGie5Lpfx+LGoqsropl1SAn98UFFREbj+5OcPUMNEtymlmBcznCfHXMbFSRMDHns0ZzErS/cMUMuOTzWuBjZWHOTBnR/wq21vBo6XF8QutmCM7dkiLkExeqzvsLVluzZytMZfnnAwfnJgEYaW7Rx0LQu5oACWLDGmu5OVB4GZeeFUBKOk2D/jXU4JhBBCiHAiBTCEEEHjcBhjB+3L8XDooDG4dlRU589rT1k73WwBzGbF6eeaeeW/TXg8ik8Xw1Xfax2d8w8qjhlvor4OSo+4qatVFBfrpKT0vH2hZt8+eOst3+2iQsXfHvXdbukGPXWGicXvuwDYsN43kPyx4tFHFcuWdnxCnZcHY8b0U4NEUNg1M9enz8GExuslRt96Dzp/3Pkh942/iKmxQwa4hccmt+5he1U+y4/sZl35AfIbKtqcL8ESyclxwa0qdPRQCxaLCWjy3nfKGWZ+fIcVq7X1733ydBNKGRdtNmyAH1zb8Wv1NCsPYMgwDbPZyAQP12623SmAIYQQQoiBJ5fhhBBB1RIw0nVFzu7eLaslmGe1GpkSRzv9HDOm5uSLTz/1VTr051/8Ysz4wCIex1JXW5cL/v6472S0RXW1//s3PqwJU30ZKwdy+6d9/WX7dtoM5Dki4Ac/8lVdzM+TE9dwdW3aTM5O8EViXbqb+7a/y87qggFs1bHFrXvYUnmYf+79ku+veZq7t7zG+wUb2wzkKeDchHE8Mepi4i0RQW2Hf3Z2XLzGuEkaE6ZoRETC9bdYueXutgN5AINiFCNHGdv73FxFWWn7r9ObrDwAi1WROcx4rcOHjeENwkFxc0a7puHNWhdCCCFEeJBgnhAiqLo6bp7bDStXwlNPKva0U5iy5UQuLkG1OQ5TfKLG7Pm+CrrffNN6GS2ZeTY7DMs6KpgXRmMbdeadd2D/fuMzGjpCcfNd1oDHo6IhY4jxeFSUwtJ8rlobRpUXu+KN133ryYQpGnPmmzjxFBO/e8juXVcA8qSbbdhSSnFTxryAwhgNniZ+s+0t9te2099edKq9AF6Zs7bd50yITOXx7Iu4efA8os32dufrqZZ9gMkEg2KMyrF/eMTBC+9EcM5Flk7H55vi39V2Y/vzvfN2z7PyWrR0tfV4FLkHuv30AVHSnJkXn6gwmyWYJ4QQQoQT6WYrhAiqsRN8wbK2xs1raoKlS+DttxX5+cbJw7r18K9/6fiflzU2Qk2NccfR4+X5O+sCCyuXuQH4+CPFggW+LqNHjkBJifHcUWM0TCbFcL9gnhH8Cv8upocPw6uvGO9T0+And9kYOVpj8zo3y5cYn83ocSY0zfc5RkYpKsp1ats/Tw87e3Jg/XrjPSanKu592B5wgup265gt4GqC/LyBaqUIBpPSuHPISdS5nayuPgRAjauRX219i79M+g7pjrgBbmHoa3A3sbe2mD01ReRUF7Gh8mCHgTsFTIhMY2p0OiMdSWQ7Eom1OPq0jS3BvNg4FbD9Mpm6FniaOtPE6y8aKdsbNyhOPbXt7f2WLcZ/i6X7WXkthgeMmwejRvdoMf2mocGXuS2VbIUQQojwI8E8IURQJSYrEhIVpUd0du0yMvBMJqirg8WfwHvvqYBBzcEY2+3wIZ1MvyGvKip800ePl+dvwmSNzKGKQ7k6O3Yo9u/XGT7ceGzbNt98LRmDqekKmx0aG4wiGOHO7YZ//N1XqfX8yyxkjzHe64/usFGY38D+vR7OvThwcx8VDRXlHFPBvDfe8K0nl1xpaZVpYjIp0tKNdaWgwLduivBkVhq/HHYav9n3CVtqjS625U213LP1Tf466XISbdED3MLQ0uBuYvmR3WyqOEhObTGH68rwdHIxoyWAd2LscObFDA96N9qOuN2+/UBH+4COjBprdMmtq4WNG9v+zTudUFhoTGcO1XqUlQcwIqCibdcuFFVWGkWLCgvh+ht0UoNbP6RDJTJenhBCCBHWJJgnhAgqpRSjx2usXOamoUGxebPOtq2Kjz6GutrAE4aWoB8YA5T7B/P8i190lJmnlOKsCyw89bgTgI8/Vtx0k7HMzz/zPW/SNOMMzmRSDB2usXuHh6JCRV2dTkT/nZ8G3ccf+bozp2UorvyBL6skKkrxp3/Y8biNMZ38GSesOnV1CrdbD/ugVm4ufPutL5PzlDPa3r2lD9Y4lOumqUlRUtK/J88i+Gyamd8NP5179n5ITv0RAIobq/jl1jf586TLienjzLFQ1+huYl9tCUtKdvBl8U5q3Z0P5qaA8ZGpLIgd0e8BPH+VFcbYqwBx8T0LNpnNiklTTXz7tZvqasW+fTrZ2YHz5OXh7WKbOaznQa3hWZq34EZnRTDcbli8GF56UVHbvF+MehnuuKP/MsWL/XqkJ0slWyGEECLsSDBPCBF0Y8abvF1ff39v4EmCUjB7nomLr7Rgtytu/WE9ABs2KM6/wHciU97FYB7ASYvMPP+0k4Z6WLYUrrnGCAZu2WI8L32wYvxkXzuGjzSCeWAUwRg3rqfvdGAVFcELL/g+m5/cZcNma52N1lagzj/7pL6+d1WHQ4F/Vt6Fl1taBS9bZGRqgLFu5ucjwbxjQKTJyv0jzuJne97nUGMFAIfqy/jNtre4d9wFxFvDfOVupus6myoPsbRkZ4fdYQF0dEoba8itK+00+w4g1uxgpCORmYMymT+AATx/Zf7FL3qYmQdGV9tvvzZ+8xs20CqYd+iQb7qliEVPOCIUaRmK/MM6ubntZ/7u2gVPPqnYtzfwPa1f17/ZwlLJVgghhAhvEswTQgRdS0Vbf2YzLFxk5qLLLQwe0lLxVvdm523bZoyTZ7MZ8/tn5nV2IhcRqTj5dDMfv+uisVGx5Eud/ALfc8483xIw3tKwEb727doZnsE8XYd//p+isdF4X2eeb2b85K6fBUZG+qZra8M7mJefDyu+NqZjYo0qx+3JyPStB3l5MG1aHzdO9IsYs50Hs87mrj3vUeQ0qrrk1BRx3br/cPWQuZyRMoGD9aXsqSmmuqne+7wMRxxzErKwat0/HNJ1ncLGSvbUFHOksYYTErJItccE5f2UNtbwTdkeqpsaAGj0uFh+ZHeb1WS7K1KzMjYyhWxHIiMjEsl2JJJoiey0mER/C6xk2/O2BRTB2KD4zncCg5uHDvqWPWRo7zLURmRr5B9243QqDh70DfkARpfa559XfPF54HuJiTWyEKurFbt364wd26smdFlJsa8dEswTQgghwo8E84QQQTd8pEZCkqK0RMfugDPONXP+pRYSko7O0lNMmWnii49dOJ2K7dt0pjYHV8rKfCcX8Qmdn2Cddb6Fj991AfDhh8o71pLVBqecGbipGzfJd3L37ruKM8/UcQx8Ikq3fPEFbNpkfEaJyYrvX2/t5BmB/DPzamogJSWozetXb77pq0R53qUW7I72T0yNzDxDXt6xUQBFGBItkTw44mzu2vM+5S4jYFfvdvLU/qU8tX9pu88bGZnMb8aeT7J9ULvzNLibKGqs4mBdKTnNBSP21BZR4/J1W30+dwV3jjqD+YmjOmynruvUu5uocTVQ42qkxt2ARzfWw1pXI1+W7ODb0r1dyqjrjnERKZydMJb5scOx9SB42d/8g3nxiT0PNqWkaqQPNjLmdu00Ll74X8wIVmYeGMG8r5uLDj30J8U9v9QZPBg+/RRefMHXpRaMi0o33GalIM/D3x82holYu1Yxdmz/bJP8M/OSU6WbrRBCCBFuQv9oTggRdiwWxR8fs7N7h4cpM0xERbd/Ija1OZgHRtbE1GnGiUzAiVwXulgNGa4xfrLGtk0eCvyy8haeaibqqAHNhw7XmLvAxMqv3FRUKN5+G757VfgEdcpK4d//9r2nG++wEhHZvZPdSL/vJJyLYBQXG9WRASKj4OwLOq5EmR4QzOvLlomBkG6L4aGsc3no4JfsrS/t0nP21BZzy8aXuHPUGUSYbBQ2VFLYUEFhQyUFjZUUNlR22q0VoMHTxAM7P+DywbOYGDOYPTXF5NYdodrVQHVL4K75v1v39Pg9aiiyIxIx0XEAJsJkYYQjgWxHEqMikkgOs+7G/kMt9CYzD4z9TP5hFx6PYstmnTkn+B47eND4b7UaVbB745TTLbz7WhOVFVBYqPj53UZX/gMHfMuNiITvXmvlrAvMmEyK9AwNMIJ569bC1Vcb8734gmL1Grj+Op2Jk3rVrDYVFRn/lZJqtkIIIUQ4kmCeEKJPJKdqXbraP3maCU0Dj8cYz6hFd7rZtjjrAgvbNgUO8H7WhW1v5q6+3srqlfW4XPDOO3DGmZCQ0KWXGVC6Dv96UnmLiZy0yMz02d3flEf6ndeHczDv7bcUbrfxWZx7saXToOagGEX0IKiugnwJ5h2TMu2xPJZ9IR+X7uS/hWuocTsDHleAQgVkvlW56vnd9neC8vqvHl7Nq4dXB2VZLW0FSLVGc1p8NqfHjybBEtnxE48B/lXPu3JBpyNTZ5r48G3fRaM5JxjffVOTr5Lt4CEaJlPvXic2XvHnfzr4028b2bfHQ0OD4sAB3+Mnn27m+zdYiIvXAp6TPVojZ5eHAweMwjx5eb5xQN94AyZOCv7FppbMvPgE1e4Yo0IIIYQIXRLME0IMqOhBiuwxGru2ezh0yDiRSUryZeZZrYGBp47MmW8iLl5RXmac+IwZrzFiZNvjyKVlaJx1gZn33zS6+P7vJbjl1tDPzluxAlavMk68YuLg/93Uve61Lfy72YZrMK+sDD7/3Ji2O+CcizrOymuRPthY30pLFQ0NOnZ7HzZSDAiT0jg3cRzzY4bzYekOmnQ3WY4EI0PNEoVSihJnDX848Dm760s6X6D/slEMtceTHZHISEci2RGJrKg4wOslm4LSdrPSmDtoGGcmjGFyVDpaiI1l11/KgjRmHsCEySbMFnA1GReNdN3ISAtWJVt/yakaf/y7nX/+tZFlnxtdboeOUNxwq43xk9reH804wUTOLiNbc+1aWPyJry3+3YCDpaEBKitVc3uPz/VLCCGECHcSzBNCDLgpM0zs2m6cyGzcCIsW+TLz4hJUlwdmN5sVZ5xn5pX/NgFw1oUdB3cu+56VLxe7qK2BL7+Ec86FESN6/Db6XFUVPP2U77P40a02BsX07ETsWAjmvfuuoqmppQCIpcufRUam5l3f8vND+zsXvRNrcXBVattVTpKsUfx55Ln84/AKPivfHfCYhiLJGkmadRCp1kGkWaNJtUWTZh3EUHtcq4IZoyOSGRmRwCOHvqLR4/Len2yJItESSZTJSrTZRpTJ/8/q/W9WRpBHKUi3DiLaLBHmlm62ShnZa71hdyjGTtDYssFDcbEiP18nI8PXxRZ6P16eP5tNcfs9Nuaf7MbZCHNONHWY9Td9jomX/2Pst156UVFT45u3rExRX6/jcASteUeNlyfBPCGEECIcSTBPCDHgps408erzxonMhg2KhQt178lMd7tXXfJdCy4XREUpFpzScXXXQTGKy75n5T//cqLrijdeh7t/HrrZea+8orzZFHNONDF3Yc834f4DwBufdei+77ZUVcEnHxvTVitccFnXP4uAiraHJZh3PLNqZu7IXMDJcSMpclaTbI0i1TqIZGsUZtW94M6C2CxGRySzvjqPZGsU2Y5EBklQrst0HT75xKhqfs45vuzsQbH0uvsrGPuZLRuMIP6GDZCRAYcOBa+S7dGUUsw8oWvbpREjNW9WuX8gr0V+PmRlBa9tLePlAaSkSfELIYQQIhxJME8IMeCyx2hERkFtDWzcAIcP+x7rbvcqi0XxvR92vevp2ReaeftVJ5Xl8O23RsZCcnK3XrJf5B2GxZ8Y03Y73HBLz7rXtgj3zLz331M0NhrvYdE55oAxqDqTPtg3b35+0JsmwoxSiqnRGUFZVoo1mrMSxgRlWcebdevgyX8Zv80tm3VvRfLu/LY7MnWmieefar5otF5x7rk6h/ooM6+7NE0xbbavGBTg7RYMRnfgPgvmSWaeEEIIEZbkcpwQYsCZTIoTFhjXFurqFC887zfweWLfnmhYrYqzzje643o8ig8/DM0Tm+ef9xV6uOgKC/GJvdt8R4VxNduaGvjwQ2PabIYLL+/aWHktMgIq2obm9y3E8WbDet9vcd06hcvVs+zs9gwboXmLKW3YAAUFvvHoglHJtrdmzvFlkmsafPcHvu1asLdTxcW+5XWlUJUQQgghQs9xtQcvLS3lpptuYsaMGcyePZsHHngAl8vV+ROFEH3ukistaM1bpA0bglfFsCvOPN+Cpfm86bNPob6uz1+yW7Ztg1XNRS/iEhQXXNa94FVbwjkz7+OPjKAvGNUhk5K7tytLy1DedS1PKtoKERK2b2/7/t4Wv2ihlOLM842LRh6P4uX/KQoKjMcyglDJtrcmzzCRlGy04fxLLcyc6+s8E+wM4mK/zLzkNLmgIYQQQoSj4yqYd/vttxMREcHy5ct54403+Oabb/jPf/4z0M0SQmBUlz359NY9/+P6IZgXG6dYcJovM/CLL/r8JbvM44H/POf7DK76fxbsjt5/JhF+Y+aFUzCvvh7ee894/5oGF1/Z/cCmxapISjGWkZdnjNUlhBg4tbVw4IAxHZegsPkNNRjMfcC5F1m81dG/+kp5K9kOCVIl295wOBR//Lud+/9q55ofWUhN77uLDi3dbDUNEpMG/r0LIYQQovuOm2Bebm4uq1ev5mc/+xkOh4PMzExuuukmXnrppYFumhCi2aVX+bLzWsQn9M9m6rxLfEGh9z9QuN398rKd+vhjyMkxTraGjlBtBjx7wmLxnTCHUzBv8WKorjY+jxNPMZGW0bP1o2XcvIYGRWVl0JonhOiBnTtB143f9QknmvjNH+1ERoHJBHPmd1zIqDsioxTnt5HZPJDj5flLTNKYONWEUgqLRZHSnDWXH+SLDkXN1WyTUtSAZyQKIYQQomeOmwIYOTk5xMbGkpKS4r0vKyuL/Px8qqqqGDRoUIfP93g86CGcvuFujjy4QyUCIUQPJKfCSYtMfLnYtx4PivUEBNb6al3PHAqTpmlsXu+hqFCxerWbWbMG9je/aZPi2Wd8J7Lfv94MeIIWaIyMhMYGqKkOj22H0wnvvO3bbV10hanH7U5O9U0X5HuIjg6t7bts08WxpqN1ettWXzBtzATF2Anw5P9suJogelBwfwdnXaDx3utGwaUWGZmh+VtLH6woyNNpaFCUlLhISOj9Mmtroa7WCGgmpaiQfN/hTLbd4ngh67o4HrW33ptMwbvw2B3HTTCvtrYWh8MRcF/L7bq6uk6DeVu3bqWpqanP2hcsW7ZsGegmCNErY6dYWPLZCPTm7k95+Vspq/C0mq8v1vVxUyLZvD4TgFdersdu3x301+iq0iM2nnlmjLcb2AknlYK5hI0bg/caJvNwwEZ1tYfNmzcHb8F9ZP26BCoqhgEwZkI1peV5lJb3bFluPR4wyhavXnOIhsay4DQyyLZt2zbQTRCix0pK7ERGNhER4TvobWudXrt2FBANgEdtZ+PGvj05nDE3gWWfJnlv19TtZOPG0DvGM1uTgXgAvv56H8OH13T8hC4oKHAA44zlW8rYuLGw18sUrcnxuDheyLoujkdHr/fTp08fkHYcN8G8iIgI6uvrA+5ruR0ZGdnWUwJMmDAh5DPztmzZwsSJEwcsMixEsOTmNPHBW26yxyjmnDARpXzdgPpyXZ80Seerz5zkH9LJzY0mKmoSI0YE9SW6pLYWnn7KTEOD8b5nzNG44xfpmEwZQX2dhMRGSop0mppMjBs3CXMI7xE8HnjmaV8Dr/1xAiNHJ3XwjI411rj5/APj5N1mHcKkSYN73cZgcrvdbNu2jfHjx8s2XYSlpUsV//w/M1arziWXejj33CZ27269TjudkJ9v/LZT0xUnLpjY523LztZZu7KR2hqw22HhyeNCsrtp8WEXq5Ybhdrs9pFMmuQhJ0exbKkiNQ0mT/YweDCobjS9pXgQwNjxiUyZktrB3KK75HhcHC9kXRfHo1Bb70P41C24srOzqaio4MiRIyQmJgKwd+9eUlNTiY6O7vT52tEDeYUok8kUEiuWEL3x/27SOOl0D5lDNczmts9S+mJdN5ngvIt1nnzMCcCHH5i5/Y7+D+J/9ink5/vGybvz13as1uCfaEZFa4CRAdPYaMJmC/pLBM26dZCXZ3wG4ydpjB7Xu4q+6YMVYATziooHvpJle2SbLsLVNyuN35TTqXj5fyaWLNE49ZRBTJoUuE7v2wculzHvuIn9s74PGgQ/uQtefaGJs843Y7WG5uHw4KEARjCvIF/D41H88UFFZWXL9spEXJzO5MkweYrO5EkQ30lX3JIS33Rqumxf+opsu8XxQtZ1cTwKlfU+NI9e+sCwYcOYPn06Dz74IPfddx/l5eX885//5NJLLx3opgkhjqJpipGjBmYDefLpZl76t5Oaavj6a/j+NRAf379t2LHTF1i645d2HBF9E2hqqeoIRjZgJ6MNBF11NTzztAIFP/6RjiOi/Xnffcf3GVx4ee8CeYB3YHmAIullJkRQ6Trk5ATeV1igeOmlbPbs8fDD6yDZ6OXO9u2+ecZN6r8LpycsMHPCgtA+DM4Y7NtO5eXDqlX4BfIM5eWKpUuNTEiAzEydyVNg8mSdKVPActTmsrjY9/yU1NC8iCGEEEKIzoVHulmQPP7447hcLk499VS+853vcOKJJ3LTTTcNdLOEECHE7lCcca5x9uNyKT7+uP9PdvbuMf5HRsHQ4X33+pGRvmXX9H4opm5xueDhhxXLlhldxl5+pf33uXs3bNtmPD54iGL67N4Heh0Ripg4Y7pQgnlCBFVJiS/oNGKkxriJvsPNVas0fnKz4vXXoKkJduzw/fbHTRz4q9yhJC5BYW8e7jk/D7743PdZnXORmWmzTN6q5C0OHVJ88L7igT9o3HuvalUFt7jIN50swTwhhBAibIX2JckgS0xM5PHHHx/oZgghQtzZF5p557Um3G5Y/Alcein91gW1rNTItAAYka0FjBcYbJHRvmXX1vbZy7Si60ZG3pbNvtf/6EM4+2xIbWP4pnf8svIuuMyCpgXnM0lN06gs91BWpmhs1EO6m7EQ4WSPX1be9DkmvnuthSWfNvHs/9VTW2PG6VS89JJiyRKdsubaM7FxirQMCS75U0qRkamxd7eH4mIoag7EpaQpfnizFU1TNDXp7N7uYeM6N5vXu8nZ6cHTXDNq21ZFZaVObKxvmS3LsFggNl4+byGEECJcHVeZeUII0RUJSRrzTjIyRKqqFMuW9d9r79nrmx45um+zVCKjBiaY99FH8MkngSeRLpfihedbn1gePAjffmNMx8YpFi4K3jWo1HTf6/lnqwghemd3ju+3lT3GuCix8DQTN929j3MuMtEyDHF+vvIW+hk3sW8vXoSrjEzjM/F4FLpuTJ9yptl7UcNiUYyfbOKq/2floX84eP6dCOaf7Nt35OX5lqXrUFxsTCenqqBdGBFCCCFE/5NgnhBCtOH8S30DDb3/XuuuSn1l717fyVXWqL7dRB89Zl5/2LgRnn3G9x5vuNXq7e66YoVi507fvB4PPPGEwuMx5j/3EnNQC4GkpPk+3wLpaitE0Phn5mWP8f3O7A4P/+8mC4886WDsxMDt27hJ0sW2LemDAz8npeCU09u/qBEVpQI+y8OHfY9VVkJjo7EN9d/+CSGEECL8yJ5cCCHaMHK0ibETjE3koUOKjRv653X3+mXmZWX3dTDPLzOvH8bMyztsjJPXEpy7+AoLZ19o4cprrN55/vOcL3D6xRewY7sxb1qG4rxLel/4wp9/Zl6RZOYJERQej287lpCkiItvvR0blqXx4N/s3PYLKylpiiHDFAtOPa5GfumyjMzAz2/ydBNJKR3vGwb7PSfvcNsZyMkpkpUnhBBChDMJ5gkhRDvO88/Oe79/Tnz8i1/4B5v6QmA32759repqeOABRV3z68yaa+J71xmf76JzzAweYty/c6fiT39U7MmB//7H16Yf327DZgtuG/0zUwoL5MRWiGDIy4P6euP3lD26/cNMpRQnn27hyZcieOxZB4Ni5DfYlpZuti1OO7vzoGfL9hTgsF83W/+LFslp8nkLIYQQ4UyCeUII0Y7Z80zean/r1ysOHerb1ysr67/iFwBRft1sa/qwm63LBX9+WJGfb7yfoSMUd/zS5h2vyWRS/ODHvuy8VasUd92lUVNjPL7wNBOTpwe/C16aZOYJEXQ57XSx7YiMldc+/2620YNg9tzOt4VxCQpHhDGd59fNtqjYN52SKqcAQgghRDiTPbkQQrTDZFKce1H/ZecFdLEd1ffjR/VXAYxnn1Fsbq5cGxMLv/qDHUdE4Gc5Y46ZO39tIzYu8P6oaLj2xr4pMxsbr7A2xxALZcw8IYJij1/xi5FjZBy83rI7FGecZ8Zshit/YMXShXFDlVLerrbFxdDYaNxfVOh7bopk5gkhhBBhTYJ5QgjRgdPONnszHJYugaqqvnst/2DeyD4ufgH9E8z76EP4+GPjdcwW+MV9dpLbyQg58RQz//dfB+debEbTQNPgup+0DvAFi6Yp7wltUZEx1pcQous8HtiwAZ55RrF6tXGff2ZeXxfxOV7ceIeNVz6K4OwLuz5uaMYQ47PXdUVBgXHf7t3Gf01rPRafEEIIIcKLjDYshBAdiIhUnHaWmfffdOF0KhYv1rnssr55rb17+q+SLUBEpG+6LwpgbNxonOS3uPlOK2MndJypExmluO4nNi6+wkJ9ne+EtK+kpmscynXT1KQoK9NJTOzTlxPimNDQAB98AJ99qigqMn7jH7yvuP4GD/v3G/NkZCqioiT7K1jM5u59lhl+4+bl5UFiIhw8aNwelqW1yo4WQgghRHiRy3JCCNGJcy6y0DKk04oVfXcC1JKZ1x/FL8DoRtySdRjszLyCAmOcvJbKtRddYeHk07ueVRKfqPV5IA8Cu5rJuHlCdM0TTyhefEHzBvJaPP2Uhstl3Deyg+IXou/5V7Q9fBh27DCy9ADGTZTvRgghhAh3sjcXQohOpKZrjMg2NpcH9isqK4P/GmVlUFbWf8UvWrR0tQ12MO+tN5W3Qu7ME0x874ddD+T1p9R0/4q2A9gQIcKExwPr1hrTSsHUmSZOPqN1R49sGS9vQA32uxiSd1ixfbtvnzJuknw3QgghRLiTYJ4QQnTBpGm+k58tW4K//P4uftEiqg+CeW433vGzrDa445c2TKbQ7NLlnwFZWBSabRQilBw8iLfS9My5Jn73kJ1b77Zy4XcCA/aSmTewUtMVWvNXcDgPtm/zPTauk+EOhBBCCBH65EhLCCG6YNJU3+Zy06bg9xnGBAAATmZJREFUB3329XPxixaRUcZ/p1PhdHb/+QUF8Ogjii++8N23ezdUVhqf0bSZJiIiQzdIFpCZJxVthejU9u2+6XETjaCQUoprfmThkiuNIQmGjdAkmDfALFblvVhx+JDvglH6YEVsfOhuk4UQQgjRNVIAQwghumDcRBNmC7iaYPPm4C8/P993cjV0RH8G83yvW1cHVmv3nv/y/xRffaVYtkyRne1hyBBY9a1vmbPnh3YGSHKqQinQdSiSYJ4Qndrh313Tb+w1pRRXX2/lnIvNxMSqkM3GPZ5kZGrkH3bjdPq+i7ETQ3ubLIQQQoiukcumQgjRBTa7Ysx4Y5NZVKiCXiyhuNg3nZzafyfB/sG8nlS0zc31Tb/7rkLX4dtvjduaBtNnh/Y1I6tVEZ9ofAYFBcZ4YEKItum6LzPPZsc7lqi/+ARNAnkhoq0iQlL8QgghhDg2yB5dCCG6aNJUX0bD5k3BXXZLMC82TmGz9Wcwzzfd3XHzdD2wa+qypcbnUlhotH/8JI1BMaF/Up+RabSxulrxf/9QEtAToh3FxVBaavxeRo/TMJtD//d9PBs8pPX3M04y84QQQohjggTzhBCii/yLYGzeHLyT2KYmo5ot9G9WHgRm5tV0M5hXXg6Njb7nu1yKRx/172Ib2ll5LS6+wuodKP6LLySgJ0R72hovT4SuwZmBh/lxCSqg6I8QQgghwpcE84QQoouyx2g4IozpzZuNLplut5Gdpus9X+6RI6DrxgnWQAbzutvNtq2CERUVvuXNmhseJ/tTZpi46zc2CegJ0YntAePlhcfv+3iWflQwb9xEDaUkmCeEEEIcCySYJ4QQXWQyKSZMNk5gKysVH3wAP7lZ8eMfaTz7bM9PkIr9xt9LTunfzXJvutkWFPim7fbAx4aP1EhODZ9dzNyFZgnoCdGJHc2ZeSaT0c1WhLZBMYqYWN9tCcAKIYQQxw45EhNCiG7w72r772c1CgqMIN6aNT1f5kAVv4CjMvO6GcxrGRsP4DtXWwIemz0v/E4aJaAnRPsqK+HwYeM3nzVKw2aXDK9wkOGXnTdukhz2CyGEEMcK2asLIUQ3TJ7WdpCqob7nyywu9p0UD2wwr3uvXeiXmTdrnplps3yfzZwwGS/vaG0G9P5PAnpC7Njhm5YMr/BxyplmlDIKEg0dLof9QgghxLEiPM+2hBBigGQOUwwZpjh4QCc2TuF261RXQUNDz5cZmJnXvydbUdG+6e4WwGgZM08pSElV/OQuK/950snocSaGZYXvSePchWbuAv5yfyMeD3zxuRHkvPlm3RvkE+J4EzhenvwQwsVpZ1mYNddM9CBkvDwhhBDiGCLBPCGE6AalFPf91cHObW4mTjHx+583UF3lobFR4fH0LNjjH8xLSunnzLzInhfAaBkzLzFJYbEq4hMVP/2VveMnhYm5C83cqcNf/yABPSEAtm31TY+ZIJl54WRQjATxhBBCiGONBPOEEKKbYuOUtxup3eG7v7ERHI52ntSBlmBebJzCZguPMfOqq6GmxnhuasaxeaI47yTjOw4I6Olw4006Ztl7iuNIWRns3Wv8zodlaRIcEkIIIYQYYJJfIIQQvWB3+E5qGxu7//ymJuNEGfo/Kw/AEWFUpgTYvh3Wru3a81q62AKkph+7u5J5J5m589eBY+j97neKiooBbZYQ/Wqd33Zh5gmSlSeEEEIIMdCO3TMwIYToB3a/XqX1PSiCceQI6LoRxOvv4hcAmqY45QwjzczpVPzxQcXyrzp/nn/xi7RjNDOvRUtAryUbb9tWxV13KvbsGdh2CdFf1qzx/cYlmCeEEEIIMfAkmCeEEL3gn5nXkyIYxUW+6f4uftHihtuszD/ZOEF3uxWPPKJY/EnHzyk4TjLzWsw7ycwfHrUTl2B830eOKH77G8nQE8e+xkbYtMmYjo1TjBx97P/ehRBCCCFCnRyRCSFEL/hn5jX2JJjnX8l2ALrZAlgsijt+aeP0c43UM11XPPGExptvtP+cwgJfW4/1zLwWY8ab+Ou/7IweZ+w66+oUG9YPcKOE6GNbtkBjo/Ebnz7HhKYdH793IYQQQohQJsE8IYToBf/MvPoeBfN8zx+IbrYtTCbFjXdYufgKi/e+F17QeP6/Cl1vPX9AZl7a8bMriU/QuPz7vs8oN1cCG+LYtla62AohhBBChJzj5wxMCCH6gH812x51s/XPzBugbrYtlFJ8/wYrV1/nC1a99ZbiX08o3O7AeVvGzIuNUzgijq+A1tDhvu8pN3cAGyJEH9N1WLPGmLZYYPJ0CeYJIYQQQoQCCeYJIUQv2O29HDMvBLrZHu2S71r58e1WVHNzFi9WPPqIoqnJuN3QAOXlxoPHSxdbf/GJiqhoY1qCeeJYtn8/lJYav/GJU004HMff710IIYQQIhRJME8IIXohWJl5MXFgs4fOifKZ51u445c2TM2JOF9/rfjjHxWNjVB4nBW/OJpSypudV1amqK4e4Aa1ob6eNrtHC9EdLVl5ADOki60QQgghRMg4/s7ChBAiiAKq2dZ377lNTVBWZkwnp4Te5njBqWbuud+G1WrcXr/OqOC6fbtvntTjMDMPQrur7eJP4MorNH77G9WjALMQLQLGy5sjwTwhhBBCiFARemePQggRRvyr2TY0di+wdeSIUTkWBrb4RUdmzDHz24fsOCKM27t2KZ560rfrOB4z8wCGZoVmMM/thldfNdalLVsUjz+m8HgGuFEiLJWVQU6OsS4NG6GRFIIXHIQQQgghjldyZCaEEL0QkJnXzSyo4iLf9EAXv+jIhMkmHnjUTmJy64BjWnpoBiH7WmBmXuh8Btu3G11/W6xcqXj1lY7bV1sLzz2neOdtJPAnvNat801LFVshhBBCiNASumePQggRBvwz8xq7G8wLweIX7RmRbeIvTzgYPzlwt3HcZub5B/MODFw7jrZ8eev16NVXFV8vb3t+lwse+pPi3XcU//mPxocf9nEDRdhY49/Fdq4E84QQQgghQsnxeRYmhBBB4p+ZV9/tYJ7vuaHazdZfbJzi93+2c/6lZswWOPl0M4NiQr/dfcERobzfWW5uaGS0NTXBNyuNaZsdrrzW4n3s8ccVhw61fs6zzyg2b/Z9hy88rzh8uK9bKkKd0wmbNhrTMXEwcrQcLgohhBBChBI5OhNCiF4IqGbbzQIYBw/6pkO5m60/s1nx/26y8fIHEdz2C9tAN2dAtWTnNTQoSkoGuDHAxo1QXW0E5mbNNfGd71k49UwzAE6n4pG/KpqafPN/9BF8/HFgMNbpVDz2N4Xb3V+tFqFoyxZobB4DdMZsM5p2fAbthRBCCCFCVXicPQohRIiy2/3GzGvs+vNcLti82ZiOHgTpg8PrZNliCa/29oWhI0Krq+3yr3zfyYJTzSiluOFWK4OHGvfv36946UWFywXvvgvPPO2b/0e3Wb3rYE6O4q03+7ftIrQEdLGV8fKEEEIIIUKOBPOEEKIXbP7VbLuRmbdrF9TXGyfMU2eaMJkkOBZuAotgDGBDgMZGWL3amI6KhikzjACMza746a9smJt73L7zjuLWWxTP/VvD4zHWuQsvt3DWBRZu+4UNrfktvfqqYt++/n4XIhToOqxdY0ybLTB5hgTzhBBCCCFCjQTzhBCiF0wmhbW5t2l3qtmuX+cL3k2dKSfL4SiUKtquWW109wU4YYE5IHNyxEgTV19n9d7OzzceUwrOvtDM1dcZkb7R40xcfKUx7XIpHn8ssFuuOD7s3w9HjhjryKSpJhwOudAghBBCCBFqJJgnhBC91FLRtjvdbNev901PnWkOboNEv0jPVN6Mt4HOzPvKv4vtKa3Xp/MuMTN5um+XP3K0xkP/sHPDrbaArNDLr7YwrLn78IEDildekUDO8WbtWt/0jDlyoUEIIYQQIhRJME8IIXqppaJtV7vZlpUZ45cBZI3SiI2TgEk4MpsVg4cYu9G8PAYsi62mxhccjktQjJvUeteuaYpf/N7OVT+0cMevbDz0DzujxrYO1FisitvusWJujge+/ZbRJVwcP9as9m2PJJgnhBBCCBGaJJgnhBC95M3M62I32w0bfNPTpIttWBs63Ah8eDyKw4cHpg3ffGN0iwWYf1L74y86IhSXXWVl4anmDsdoHJ5l4vJrjJRDj8eobtvYjaxTEb7Ky40CKADDRmhhU2VbCCGEEOJ4I0dpQgjRSy2ZeY2NCo+n8/k3rPcFUqbNlmBeOAuoaDtAXW2PrmIbDBdfYWHUWOO95ecrXnheskePB/5dbKWKrRBCCCFE6JJgnhBC9JLd4ZvuLIPJ7YaNG43piEi8ARMRnvyLYBw40P8Br7Iy2LrVmE5NV4wcHZz1yWRS3PZzG9bmuhkffKDYsjkoixYhbO0avy62EswTQgghhAhZchYphBC9ZLf7ToA7C+bl5EBNjTH/lOntd4kU4cE/M+/gAGTmrVhhdIUFOPEUM0oFb33KGKJx9fW+KriP/11RVxe0xYsQ43T6LjTExEH2GDlEFEIIIYQIVXKkJoQQveSfmVffSREM6WJ7bElIVERGGdMD0c12eSdVbHvrnIvMTJhiHCqUFCv+/awEn49VW7YYQwUAzJhtRtPkuxZCCCGECFUSzBNCiF6y+WXmdVYEo6XqKMDUGRLMC3dKKW9X29JSRU1N/712YSHs3u0rVpA5LPi7dE1T3HK3zRuw/vxzxbZtQX8ZEQLWrJEqtkIIIYQQ4UKCeUII0UsO/zHzOgjmVVbCnj3G9LARGglJsgk+FgwboCIYy5f7phec2nfBl5RUje/f4Otuu26tZGwda3Qd1q4xps0WmCJVtoUQQgghQpqcSQohRC+1VLMFqO8gmLdxA+i6Me/UWXKyfKwIqGh7oP9e17+L7fyTg9/F1t90vy7hhw/36UuJAXDgABw5YqxPE6eYcDgkYCuEEEIIEcokmCeEEL1kt/umO+pmu36D33h5kvlyzPCvaJub2z9BkAMH4OBB47XGjNdITu3b3XlSssLWvJ4fOtSnLyUGwJo1vumZUsVWCCGEECLk9Vsw7/Dhw/zkJz9hzpw5zJ49m5tuuolDfmcETz31FOPHj2fq1Knev0cffdT7+LJlyzjvvPOYMmUKZ511FkuWLAlY/tNPP82CBQuYMmUKV199Nfv27fM+VldXxz333MPs2bOZPn06d999N7W1tX3/poUQxwX/zLz2gnkej5GZZ8wPYybItZRjxZDh/d/Ndvly3zp3Yh8UvjiapikyBhvvs6jIqHwqjh1rVst4eUIIIYQQ4aTfziZvvvlmYmJi+PLLL/nyyy+JjY3lpptu8j6+detWbrzxRjZs2OD9u+OOOwA4cOAAt9xyC7fddhtr167llltu4fbbb6eoqAiAt99+mxdeeIFnn32WVatWMX78eG699VZ0XQfg/vvvp6CggMWLF/Ppp59SUFDAX/7yl/5660KIY5x/Ndv2gnn79kJlpXHCPGmaCYtFurEdKyIiFUkpxveZm2uMP9aXdB2Wf2VMaxrMW9j3wTyAzGHGe/R4FPn5/fKSoh9UVfnG8hw6QvV5lqcQQgghhOi9fjliq6ysJDExkdtuu42IiAgiIyP5/ve/z+7du6msrARgy5YtTJgwoc3nv/3228yYMYPTTjsNs9nM2WefzcyZM3n11VcBeO211/jud79LdnY2NpuNO++8k/z8fFatWkV9fT3vv/8+t956K7GxsSQkJHDXXXfx1ltvUV9f3x9vXwhxjLP7VbNtrwDG+g2+aelie+xp6WpbX68oLu7ZMg4fhmVLoamp4/l27YLi4ubxzaZqxMb3T2B48BDfIYOMm3fs2LLFbyzPGf0TGBZCCCGEEL0TtGBeQ0MDubm5bf5ZLBaeffZZkpOTvfMvXryYjIwMYmJiKC0tJT8/n9dee4358+dzyimn8PDDD9PY2AjAnj17/n97dx4fVX3vf/x9Mkv2kEBYBIRESEAhyBIEq2BFioQKtuitK6JYFKUgvbheF1rR2/owil6KFVxoq9xel8LjVsXCrVJqW38sFSFSgwkQFkGEhCV7Jsn5/XEyWwjZGDIzmdfz8eDByXzPOXNm8mE4eee7KDMz0+/5Bg4cqPz8/CbbHQ6H0tLSlJ+fr3379snlcvm1DxgwQFVVVSoqKgrUywcQwXx75lVWNR2sbPvM+ziLX3Q+/c9yRduqKunxxwwtWRKlZ581mu3d57vwxfirOi58IczrnHZs99bTsJH0ygMAAAgHAfspYPv27brtttuabFu2bJkmTpzo+fr3v/+9Xn/9df3617+WJB09elTZ2dmaPn26XnjhBR04cEALFixQZWWlFi1apPLycsXGxvqdMyYmRhUVFZLUbHtZWZkkKS4uztPm3rct8+bV19d7hu2Gorq6Or+/gc4qFGvd4fR+NlRW1Kuurt6vvaxM2rXL+rjtc76h1O5mSF0/zt75/b3bRXtNjRpVf+adm7Brl6Hjx60a2bzJ0F/+Yqpbt9PrvK5O+vvfrf0cDmn0d4wOq6Xe53vrfP++0Po3iPbbvsOqJ7tdGnTRufu+huJnNxBo1DkiBbWOSHSmurfZgtNRI2Bh3pgxY7Rr165m96mpqdEvfvELrV27VsuXL9fYsWMlSYMHD9aqVas8+w0YMED33nuvfvazn2nRokWKjY1VVaOJqKqqqhQfHy9Jzba7Q7zKykrP/u7htQkJCa1+fV988YVcLY19CgF5eXnBvgSgQ4RSrR/+OlpSuiTp60Ml2rFjv1/7zp3Jqq8fIEnqm1aszz9v5zhMhKzKGqekCyRJO3acVEbm3jYd/7e/9ZTU1/P1q69E6d65du3cudNvvz27E3XihNXT/IJBpSooyD+r626LujopKmqQ6usNFRZWaceOLzvsuXFunDjh1DeHsyRJvftVKH/Xua+nUPrsBs4V6hyRglpHJGpc96NGjQrKdXTY+JySkhLdc889qqmp0bvvvqvzzz/f07Z582Zt27ZNd999t+exmpoaxcTESJIyMzNP+4GmsLDQM8deRkaGCgoKdOWVV0qSXC6XioqKlJmZqfT0dDkcDhUWFuriiy+WJO3evdszFLe1hg4dGvI98/Ly8pSVlRW0ZBjoCKFY6z1S6yVZy3vGx3fTsGHJfu2f/NV7nZOm9NTw4b078OrQEWprTb32YrVqa6WTJ1M0bFhim47/cK1/LVdV2fXB+/315OIY2e3eNt9auuYHXTV8ePezu/A26t23Wgf3mzp+PFZDhgxTiPwTRDt99JF3iO2llydp+PDh5+y5QvGzGwg06hyRglpHJAq1uu+QMM/lcunHP/6xUlJStGzZMk9I5xYbG6ulS5eqd+/e+v73v6/du3frpZde0g033CBJmjZtmlauXKm1a9dq0qRJWr9+vTZv3qxHH31UknTddddp6dKlGj9+vNLT07VkyRKlpqYqOztbDodDOTk5ys3N1YsvvihJys3N1TXXXHPadTQnKio85pGx2WwhUVjAuRZKtR4f77sAhuF3XaYpbdtmtTujpawRDtlsrGTb2dhsUt9+LhXtqdehQ1J9vU0OR+uONU2poMCqidg4KTra0InjpnbtStbf/16rCROs/3+Ki6W//c3aLyZWuuSyjq+lvv2jdHB/nVwuQ8XFNp13Xoc+PQLsizxv/QzPtnfIZ2oofXYD5wp1jkhBrSMShUrdd0hCtWHDBu3cuVNbtmzRpZdeqhEjRnj+HDp0SFlZWXr++ef16quvatSoUbrzzjs1depUzZkzR5I17HbZsmVavny5Ro8erZdeeklLly5Vero1rO3666/X7bffrrlz52rs2LH617/+peXLl8vR8JPUokWLlJaWpqlTp2ry5Mnq27evnnjiiY546QAiQEys9wfiqmr/tn37pOPHG1YeHW6T00mQ11n1v8D63tbVGfr669Yfd+yYt0YyL4zSnAVOT9vrr9lUUmJt//cqQzU11n4Tc+yKju74Wjq/v/e24cCBDn96BJBpWivZSlY4nDE4PH5pCQAAgA7qmTdp0qQW59ObNGmSJk2adMb2cePGady4cU22GYahWbNmadasWU22JyQkaPHixVq8eHHrLxoAWinap5NvVaV/22f/9G6PGB383+Dg3OmfHiXJmhB3X5HU2pkcfP97zLzQprHj7Lr8Spf+tqFeZWWGXv61dNPNpj7+2NonLl760Qxn0yc7x/r6hHkHD0iXXBKUy0AAHDjgDZGHXmyT3c4vGgAAAMJFh82ZBwCdlc1myOmUamqkRmvx6LPPvD8gj7yEMK8z65fuDbr27TMktW6e1a++8tbIoIusc9w516FtW8pVXmbX5s2Gdu+WTNPa70e3OpXUJTjBy/n9vM974GDrXyNCz/bt3u1hI/hsAgAACCeMqQCAAIiJtf72HWZbWSF92bDgZ6/ehnr35SO3M+t/gff7W7Sv9cd95dMzL2OwFaokdTE0Zfo3nseLi60QrUcvQ1N+GLzfw/U5P0pGQ553kGG2YW3Hdm8wO2wkYR4AAEA44SdLAAiA6BjrB2PfYbbbd1jzp0nSSIbYdnqp3Q3FxVvb+4pad4zLJe3ZY2336m2oS7I3YBmcVabLvuv/3/SMHzuDOu9idIyhHr2s5z940Jp3DeGnrk7audPa7pIi9UtniC0AAEA4IcwDgACIbeiZV+3TM2+bzxDbEQyx7fQMw/D0zisuNlRW1vIx+4rkWdTCPcTW149/4lBKV2/75VcGv4769rOus7LS8CzOgfBy+LBUUWHV1UVZNkVFEeYBAACEE8I8AAgA94q2VVWG6uutHkuffWa12R3WSrbo/NIu8J03r+X9d33l3XYPsfWV1MXQM7+K0d33OfX4L2JkGMEPXfr6zpvHUNuwtN+nNtMGcCsIAAAQbriDA4AA8F3RtrraGoJ49KgVegwZFuUJ+9C59U9vW5jX1OIXjfXoFaWcax1KSAyNGmq8oi3Cz7793lrqn8atIAAAQLjhDg4AAiDWJ6yrrpa2feZtG3kJC4dHCt9FMPbvazl8cy9+4XCETw8p38By797QCBjRNr4983xXYQYAAEB44A4OAALAvZqtJFVWStu2eUMOFr+IHP3SWt8zb/t26fBhq04uyIiSwxEewVjagCjZGkq6oDC414L22b/f+tvplHqeFx51BwAAAC/CPAAIAPdqtpJUVSUVNoQcySmG+vbnh+VIEZ9gqHsP6/u9b/+ZV3vdvl16+ilvXWRfGj6Br9NpeHrnHTxghdcIH9XV1gIYkjVk2mbj8wkAACDcEOYBQADE+vTM+/qgVFrq7XEVCosWoOO4h9pWlBs6duz0dneQ517F9pLv2PSDHzk68hLP2sDB1musrze0Z0+QLwZt8vXX1vdN8h8yDQAAgPDBXRwABIBvz7wvv/Ru+65uisjgG5AUFfm37dhxepD3wKLosBli65Yx2PsaCwqCeCFoM9/h3/3SwqvuAAAAYOGnTAAIAN+eeV/me7fTB/IxG2n6XdD0vHk7dkhPLQ7/IE+SMgZ5hwUXfBV+1x/J9vusZMviFwAAAOGJuzgACIAYn9Vsi/Z6Hw+XFUoROGl+YZ5VF50pyJOk89MMOaOt7UIWwQgrrGQLAAAQ/riLA4AAiI7xbrvno3I6pd59wzOsQfv1Od+Q3W5t79vX+YI8SbLZDA3ItG4hjhwxdOpUkC8IreZeyTYuXkrtHr41CAAAEMkI8wAgAGJjT/+huH86K0VGIrvdUJ9+1vf94AH/IG/0peEf5LllDGLevHBTUSEdPepd/ILFeQAAAMITYR4ABEBM7OmPMcQ2crkXwaiv9w/yHvxZ5wjyJGmgz7x5hYR5YcHdK09iiC0AAEA4404OAALAdzVbN8K8yNW/UVDS2YI8qdGKtoWd53V1Zn5hXhqfTwAAAOGKOzkACIDYJnrmsZJt5BpysbfXWmcM8iSpV29DCYnWdmGBZJrBvR60bF8RK9kCAAB0BvZgXwAAdAZN9sy7gB+WI9XgITb9+6PRKi8zNXGKvdMFeZJkGIYGDrLp8611OnHC0LFjprp3D/ZVoTHTlMrLpfh4euYBAAB0FoR5ABAAjXvm9TzPUFx85wtw0Hrjr+r8/8VmDIrS51vrJFmLYBDmhZbaWumRhw0VFBhKTjZVXm49npxiqEsyn08AAADhil/LAkAAxDRazTad+fIQAXznzduyhXAo1OTnSwUF1vflxAlDLpe13S+d7xUAAEA446dNAAiA6Bj/r1n8ApHgomE2z0rOGz429OWXwb2ezq6mRlq1ytA7b0t1dS3vf/CAd9vu01H0iomdv9coAABAZ8bdHAAEgM1myOm0ftiWWPwCkSEh0dCtdzr16q+swv/1S4aee96Uw9G644uKpIKvpDFjpaSkc3edncWrrxpav86QZMjhrNcPftD8/gcOeHvgLXomRj16GTIMqXtPeuYBAACEM37aBIAAifGZN4+eeYgUOdfaNSDTqvf9+w397/82v391tfTRn6WHHjS04L4oLVsWpdxnCZda8v8+VUOQZ3nnbUOlpc0fc/Cgd/v8/lHqeV6UevSKkmHwfgMAAIQzftoEgABJTLJ+QE5IlHrQ8wURwmYzdO+/OxXVcEfx9luG36qpbkVF0ooVhu64w9DSpVHatcvwa8OZlRRLy5b5f6aUlxt65+3mP2fcYV5iktQl5VxdHQAAADoaYR4ABMiPbnOqb39Dt89x0vMFEWVApk3XTLdm7qipMbTw3w39/r8NnTolffSRtxfe2g8MVZSf/m+jrEyqr+/oqw4P9fXSCy8YKi213reLR0XJ6bTa1q6VDh9u+rjycqm42Dqmbz964wEAAHQmhHkAECBXXGXXr1bGaWJOKycMAzqRm+6wwmxJcrkMvfWWodtmRGnpf/n3wnNGSxOutuuZX8Xo4lHWbUh9vaHKyqBcdsj79FNpxw7r/euWamjhYzG69t+sz5jaWkNvvtF0SPe1zxDbvv243QMAAOhMuLsDAABnLTbW0LMvxeqHNzpks53e3v8CQ3fNd+r1d+I0/6FoDbrIpqQkbxDV0vxvkWrPbu97dMe9TiV1MTT9Jodn2Ozf/24oP//04w74hnn9ud0DAADoTLi7AwAAAREba2jmXU698GqsRl5iU0KitxfeC6/EasoPHEpI8IZTCT5hXhlhXpNOnfJu9z3fum2LjTN000yn5/HfrDRkmv7HHTzofW/P788QWwAAgM7EHuwLAAAAncv5/aP0xC9jWtwv0bdnXtm5vKLw5RvmJXXxbn/v+3a9v9qlg/tN5ecb+vRTU9/5jrf9wAHvNsNsAQAAOhfu7gAAQFAkJDLMtiWnfN4X3/DTZjM0825v77zf/daQy+Xd92BDmBcdI6X2oGceAABAZ0KYBwAAgiIxybvNMNumlTb0zIuNkxxO/1Aue6xNWcOtW7lvvjH0pz9Zj9fUSN9+a2337RelqCjCPAAAgM6EMA8AAASFX888htk2yT3MNqnL6YGcYRi6fY63d97bbxkqK5MOHbJWCJakvv0I8gAAADobwjwAABAUiX4LYBA6NVZXJ5U1hJy+K//6GpBp03e/Z02BXFpq6N13DB3Y721nJVsAAIDOhzs8AAAQFInMmdes8nJvD7vEJnrmud0yyyFnQwe999+X/vlPn5VsWfwCAACg0+EODwAABEWCb888htmeptRvJdszh3nde0Zp6vUOSVJtraG//MUnzKNnHgAAQKfDHR4AAAiKhETvNj3zTue7km1Sl+b3ve4mh7ok+z9mt0u9+jB8GQAAoLMhzAMAAEFhsxmKi7e26Zl3ulM+PfMSzzBnnltcvKEbZzr9HjuvjyGbjTAPAACgsyHMAwAAQeMOqeiZd7pTrRxm6/a979v9Vq9l8QsAAIDOibs8AAAQNAkNi2CUlUn19UG+mBDjG3A2twCGm91u6La7vL3zMgZzmwcAANAZ2YN9AQAAIHK5e+bV1xuqrDQVHx/kCwohp055A7zW9MyTpEu+Y9d9D5v65pCpnGsd5+rSAAAAEESEeQAAIGgSGy2CQZjn5beabQtz5vm6chIhHgAAQGfG+AsAABA0CT4hVRnz5vlp65x5AAAAiAyEeQAAIGjcc+ZJUikr2vrxDfMSkoJ3HQAAAAgthHkAACBoEumZd0buBTDiE6zFLQAAAACJMA8AAARRok+Ps1LCPD/unnkMsQUAAIAvwjwAABA0DLNtWl2dVFZmvTeEeQAAAPBFmAcAAIImMdF3mC2hlZtvL8XENqxkCwAAgM6PMA8AAASN35x59MzzKGUlWwAAAJwBYR4AAAiaBJ8wjznzvE75vBeEeQAAAPBFmAcAAIImIdG7TZjndcqvZ17wrgMAAAChp8PCvO3bt2vw4MEaMWKE588tt9ziad+7d69mzpypESNG6PLLL9fLL7/sd/zGjRs1depUDR8+XDk5OdqwYYNf+yuvvKLx48dr+PDhmjFjhvbs2eNpq6io0COPPKIxY8Zo1KhRevDBB1VeXn5uXzAAAGiRzWYoLt7aDsQw2+pqadWbhj744OzPFUy+YV4iPfMAAADgo8PCvLy8PI0ePVrbtm3z/Fm1apUkyeVyac6cOcrKytKmTZu0YsUKrVq1Sh9++KEkqaioSPPmzdN9992nrVu3at68eVqwYIGOHDkiSVqzZo3eeOMNvfbaa9q0aZOGDBmi+fPnyzRNSdLixYt1+PBhrVu3TuvXr9fhw4eVm5vbUS8dAAA0wz1vXiB65n38sfTOO4ZeWRGlwoKzP1+wnGLOPAAAAJxBh4Z5Q4cObbJty5Yt+vbbbzV//nw5nU5ddNFFmjFjhifsW7NmjbKzszVx4kTZ7XZNmTJFo0eP1ltvvSVJevvtt3XzzTcrIyND0dHRWrhwoQ4dOqRNmzapsrJS7733nubPn6/k5GR169ZN999/v1avXq3KysqOevkAAOAMEhpWtC0rk+rrz+5c+/d5g6+vD53duYKp9JT3dRDmAQAAwJc9UCeqqqry9JRrrHv37srLy1NqaqomTZqksrIyXXLJJXr44YfVq1cvFRQUKD09XU6n03PMwIEDtWLFCklSYWGhMjMz/c45cOBA5efne9pnz57taXM4HEpLS1N+fr6Sk5Plcrn8jh8wYICqqqpUVFSkCy+8MFBvAQAAaAf3vHn19YYqK03Fx7f/XCUl3m3fFWHDjV/PvCTCPAAAAHgFLMzbvn27brvttibb/uu//ks9evTQd77zHd10001yuVxavHix7rrrLq1Zs0bl5eWKjY31OyY2NlYVFRWS1GR7TExMq9rLGibgiYuL8zu3+7jWqq+v9wzbDUV1dXV+fwOdFbWOSBBpde67CMbJk3WKiWn/uYqLbZKs8OvESVN1dWfZ1S9ITp7yvo74xHrV1YXuPUhrRFpNIzJR54gU1Doi0Znq3mazBeNyAhfmjRkzRrt27Tpj+9VXX+339eOPP65LL71Uu3fvVlxc3GlDXisrKxXf8Kv52NhYVVVV+bVXVVW1qt0d4vmez/1cCQkJrX59X3zxhVwuV6v3D5a8vLxgXwLQIah1RIJIqfPq6p6SUiRJ2z4rVO8+Fe0+15EjWZKsnv5FRcXaseNAAK6w4x35ZrCkeBmGqYLC7YrqsIlRzq1IqWlENuockYJaRyRqXPejRo0KynUELMxrzuHDh/Wb3/xG8+fP9wRqNTU1kqwedBkZGSoqKlJtba3sduuSCgsLlZGRIUnKzMzUzp07/c5ZWFjomYMvIyNDBQUFuvLKKyVZC2oUFRUpMzNT6enpcjgcKiws1MUXXyxJ2r17t2cobmsNHTo05Hvm5eXlKSsrK2jJMNARqHVEgkir8y8/d2nrp9ZvOXudl6Fhw9r3/21dnVRe7r21cTpSNWxYSkCusaPV1lmvIzHJ0MiRw4N7MQEQaTWNyESdI1JQ64hEoVb3HRLmpaSk6IMPPlBdXZ0eeOABlZeX6+c//7kuvfRS9evXT71791ZKSoqee+45LViwQHv37tUbb7yhn/70p5KkadOmaeXKlVq7dq0mTZqk9evXa/PmzXr00UclSdddd52WLl2q8ePHKz09XUuWLFFqaqqys7PlcDiUk5Oj3Nxcvfjii5Kk3NxcXXPNNYppwzieqDD5lbjNZguJwgLONWodkSBS6jwpqV6SFeZVlEepvS/55Alr3j230jIjbN8/93x/SV3C9zU0JVJqGpGNOkekoNYRiUKl7jskoYqJidGrr76q3bt36/LLL9fVV1+thIQEvfDCC5Iku92u119/XV999ZUuu+wy3XXXXZoxY4amT58uyVqwYtmyZVq+fLlGjx6tl156SUuXLlV6erok6frrr9ftt9+uuXPnauzYsfrXv/6l5cuXy+FwSJIWLVqktLQ0TZ06VZMnT1bfvn31xBNPdMRLBwAALUjs4t0uLW3/eXwXvzjbcwVCfb3Unk79LpdUWWmFkomsZAsAAIBGOqRnniQNHjxYK1euPGN7//799dprr52xfdy4cRo3blyTbYZhaNasWZo1a1aT7QkJCVq8eLEWL17ctosGAADnXEKib2+69p+nuHGYF8TVbN99V3rzjSjl5Ji6e07bEr1SVrIFAABAM8Jj7CgAAOi0En3CvLLS9odXxcX+X5861b6ecWerpET6n99br+PDDw3t2NG240/59ChMomceAAAAGiHMAwAAQZXg0/us7Cx65h0v8Q++XC5D1dXtP197ffCBodpa77X8ZqWh+vrWH3/Kt2ceYR4AAAAaIcwDAABBlegT5p3NPHeNe+ZJ/sFYR6iskP70of9je/YY2rix9efwvWbmzAMAAEBjhHkAACCoEhK922cV5pWc/lhHh3l//kgqL7cCuAsGem+z3nyj9b0E/XvmBfLqAAAA0BkQ5gEAgKCy2QzFxVvbZzfM9vTHOnJF27o66Y9/9PakW/BItLLH2iRJxcWG3nuvdef59lvvORhmCwAAgMYI8wAAQNC5h9qeTU+6YA+z/fQf0tGGIG7kJTb1S4/SzLucimq42/rDu4ZOnGj+HDt3Su/7hH59zudWDQAAAP64QwQAAEGXnGKFYKWlhlyuth9fXe0d3uqrtAPDvP/9X+/z/+BHDknS+WlR+t737ZKkykpD//M/Z+5p98030i9/4V0845rpdp3Xh1s1AAAA+OMOEQAABF1qD2/IdexY248v8RliG5/g3S4t7ZhhqgcPSgUF1nOlDYhS1gjvLdZNM52KibW216+TDhw4/fiKCunppwzP9Y4YbdMd9zjP+XUDAAAg/BDmAQCAoEvtfnZhnu8Q27QLvLc3HTXMduNG7/VPmGSXYXi/Tu5q6LqbrJ569fWGfvfb0wPGt94ydOCA9Xif8w0tfDxaNhvz5QEAAOB0hHkAACDoUnt4b0nOtmde/3Mc5m3dKi1daujrg9bXpin9daO1HRUlXT7Bdtox0653qFuqFc5t2WIob4e3zeWSPv7I2nY4pEefjlFCAkEeAAAAmkaYBwAAgu5se+aV+PTMSx/gvb0J9Gq2dXXS888b+ujPhp56ylBNjbQrXzpyxLr+rBFR6trt9Nur6BhDt9zp8Hy98jeG6uut7c2bvcOBx46zqXdfbs8AAABwZtwtAgCAoPOdM6/4WNt7pRUXe4/pfX6U7NaaEzoV4DCvpESqaFho4/BhQ+++Y/gNsb1iov2Mx14x0a70gdat157dhv76V+vxj/7sPX5ijqOpQwEAAAAPwjwAABB0gVwAo1uqocQuDavjBniY7dGj/l+vXi1tbAjlnE5p7OVnDvNsNkO3z/EuavHmG4YOHZK2bbO+7t7T8Fs4AwAAAGgKd4wAACDouiQbnt50ZxvmdU01lNTF2i4ttea0C5TGYV5treHpqTf6OzbFxTffq/DikTaNGmPNqXfsmKEnf27INK1jrppsV1QUc+UBAACgeYR5AAAg6KKiDHVrmDfvbFazTUySnE5DiUnWuWpqDFVXB+oqpWKfa4tqdBfV3BBbXzPvcnqO/eYb6zoNQ5pwdeuOBwAAQGQjzAMAACHBvQhGWZmhqqrWH2ea3p55XRtWjE1K8vZwC+SKtkePes97w0zv/HaJSdKI0aevYtuUfulRmjjFP7gbNjJKPXpxWwYAAICWcdcIAABCQnvnzSsttYa7SlK3VOvWJqmL4dceKEd9rut7U+y66XaHunYzNOtepxyO1g+Rvel2h2JivF+z8AUAAABaizAPAACEhNTu3tuStoR57iG2kpTSzQrUErucm555xxrmzLPbpeQUQzfc5tTr78TpykltC+NSukZp5t3WYhjpA6M05vLW9eoDAAAAmJwFAACEhG4+PfMaLzTRnMYr2UryzJknBTjMawgZu3U3znqxipxrHbrkOzYlJBlyOln4AgAAAK1DmAcAAEKCe848yVrpVWrdMrQlPj3zujb0zDsXw2wrK6z5/CT/IcFno1t3BkkAAACgbbiDBAAAIaG9c+YV+/TM8yyA0cX7WOmpwARvvtfUvQe3UAAAAAgO7kQBAEBIaO+ceSUl3rDuXA6z9Q/zGBYLAACA4CDMAwAAISExSXJGW9vFbQnzfIfZpp67Yba+K9kGapgtAAAA0FaEeQAAICQYhuHp8XbsmGS2bso8zwIYNpvUJfn0MC9QPfOOHvWekzAPAAAAwUKYBwAAQoY7JKuqMlRe3rpjiht65qV0864wGxMr2RuW+ToVoJ55x3xW2GXOPAAAAAQLd6IAACBktHXePJdLOnnSCvDcK9lKVi+/xIbeeaXnYM48euYBAAAgWAjzAABAyGjrirYnTni33fPlublXtC0tbf2Q3eYcbeiZFxcvxcUT5gEAACA4CPMAAEDISO3uE+YdbWbHBsW+i190axTmNaxoW1NjqLr67K6rvt4bLnbvSZAHAACA4CHMAwAAIcO/Z17LoZnvSrbdGvXMS0wK3Iq2J09KtbXW+ZgvDwAAAMHE3SgAAAgZbZ0zz72SrdTUMNvArWjrN19ed3rmAQAAIHgI8wAAQMho65x5xSXe/bum+t/WJAYwzDvqM+Q3lWG2AAAACCLCPAAAEDJi4wzFxVvbreqZ18wwW7+eeSfP7rp85+9jmC0AAACCibtRAAAQUty984qLW16F1neYbeMwLznF+/XxE2d3TUePes/l23sQAAAA6GiEeQAAIKR0SbbCMpfLUFVV8/u6V7ONibV69flK8Vnd9vjxswvg/ObMI8wDAABAEBHmAQCAkJKQ6A3LysrOvJ9penvmNe6VJ0kpXb2P+fbgaw93mGcYTT8XAAAA0FEI8wAAQEhJSPCGZeXlZ96vslKqqrL2bbySrSR19e2Zd5ZhnnsBjK7dDNnthHkAAAAIHsI8AAAQUuJb2TOv2GfxC9/gzi02zlBMrLV9/Hj7r6esTDpxwjo/Q2wBAAAQbIR5AAAgpCQkerebC/P8F79o+pbGHfKdTZi3+g/eAC99ILdOAAAACC7uSAEAQEjxG2bbXJjn2zPvDPPYuefNq6gwVF3d9mv59lvpvfesbbtD+uGNjrafBAAAAAggwjwAABBS/BbAaGbOvGKfnnlnDPO6nd0iGKveNORyWee4ZrpDPXtx6wQAAIDg4o4UAACElPgE73ZZ2ZnnqCsp8badaYVZ3xVt2zrUtrBA2rjROj4xSbr+FnrlAQAAIPgI8wAAQEjx7ZnX6mG2TSyAIfn3zGtLmGea0srfeI+94Tan3/BfAAAAIFgI8wAAQEhJaONqtobhH9r58uuZ14Zhtls2Szu/sI49r4+hq6faW38wAAAAcA4R5gEAgJASn9C6OfPcc+B1STZktzcd5nXt5r3VOX68dT3ramul3/7Wu+9ts51yOOiVBwAAgNBAmAcAAEKK75x5ZxpmW1fnHTZ7piG2kn/PvJJWDrNdv176+mvruAuzojR2nK11BwIAAAAdgDAPAACEFJvNUFy8tX2mYbYnT0r19VbgdqaVbKVGc+a1Yphtebn0P7/3HnPHHKcMg155AAAACB2EeQAAIOS4h9qeKcwr8QnmmgvzEhIlR8MitK1ZAGP1akOnTlnnG3elTZkX0isPAAAAoYUwDwAAhBz3IhhlZdbKso35rmTbrZkwzzAMJTcMtW0pzDt6VHrvj9a23SHd+mNnm64ZAAAA6AiEeQAAIOQkNMybV1dnqKrq9PbW9syTvHPqnTplyOU6836r3jRUU2Pte80PHep5HrdJAAAACD3cpQIAgJATn+izom0TQ22LS7ztzS2AIfkvgnHiRNP77N4t/eUv1n6JSdL1tzhaf7EAAABAByLMAwAAISfBJ8wrLz+93X+YbfO3My0tgmGa0srXvfv8aIbT7/kBAACAUEKYBwAAQk5CQvM989oyzNa3Z15JE/Pmbd0qffGFtU+v3oYmT7O37WIBAACADtQhYd7WrVs1YsQIvz9Dhw7VoEGDdOTIEUnSihUrNGTIEL99lixZ4jnHxo0bNXXqVA0fPlw5OTnasGGD33O88sorGj9+vIYPH64ZM2Zoz549nraKigo98sgjGjNmjEaNGqUHH3xQ5U39mh8AAISE+ETvdtPDbK2/HQ5rWGxz/HrmNQrz6uqk3/7G237bXU45HPTKAwAAQOjqkDAvOztb27Zt8/z55JNP1L9/f913333q2bOnJOmLL77QPffc47ffT3/6U0lSUVGR5s2bp/vuu09bt27VvHnztGDBAk8QuGbNGr3xxht67bXXtGnTJg0ZMkTz58+X2bD83eLFi3X48GGtW7dO69ev1+HDh5Wbm9sRLx0AALSDb8+88qZ65jUMs+2aasgwWt8z73iJ/77/2ikdPGg9NnhIlC4dZ2vnFQMAAAAdIyjDbJ966in17NlT9957r+exvLw8DR06tMn916xZo+zsbE2cOFF2u11TpkzR6NGj9dZbb0mS3n77bd18883KyMhQdHS0Fi5cqEOHDmnTpk2qrKzUe++9p/nz5ys5OVndunXT/fffr9WrV6uysrJDXi8AAGgb3znryhp1pq+ulsrKrPaWhtg23qdxz7y9e73bV+XYWwwGAQAAgGAL2KQwVVVVnp5yjXXv3l1xcXGSrCG3a9eu1YcffuhpLy4u1qFDh/T222/rsccek9Pp1OTJk3XfffcpOjpahYWFyszM9DvnwIEDlZ+fL0kqLCzU7NmzPW0Oh0NpaWnKz89XcnKyXC6X3/EDBgxQVVWVioqKdOGFF7bq9dXX13t6+oWiuro6v7+BzopaRySgzqXYuHrPdukpU3V13q+PHZPcv49M6dry+9Ql2fv/d0mJ6bf/3r3ennj90iL7PT+XqGlEAuockYJaRyQ6U93bbMEZ1RGwMG/79u267bbbmmxbtmyZJk6cKElaunSpbrrpJvXp08fTfvToUWVnZ2v69Ol64YUXdODAAS1YsECVlZVatGiRysvLFRsb63fOmJgYVVRUSFKz7WUNE+24w0RJnn3bMm/eF198IZfL1er9gyUvLy/YlwB0CGodkSCS6/zQ4RhJaZKkffuKtWPHAU/bvqIESYMkSXX1x/T55982ey6zXjKiBsmsN3ToUKV27Mj3tOXnD5YULxmmjp/M0+efh+4v7jqDSK5pRA7qHJGCWkckalz3o0aNCsp1BCzMGzNmjHbt2tXsPvv379fmzZv19NNP+z0+ePBgrVq1yvP1gAEDdO+99+pnP/uZFi1apNjYWFVVVfkdU1VVpfj4eElqtt0d4lVWVnr2dw+vTUhIaPXrGzp0aMj3zMvLy1NWVlbQkmGgI1DriATUudQjtV5SjSQpJiZVw4aleNpOnfIOhR10YQ8NH967xfOlpFSppFiqqorTsGHDJFmLXxQXW7dCvftEafQlFwfwFcAXNY1IQJ0jUlDriEShVvcBC/NaY926dRo5cqT69u3r9/jmzZu1bds23X333Z7HampqFBMTI0nKzMzUzp07/Y4pLCz0zLGXkZGhgoICXXnllZIkl8uloqIiZWZmKj09XQ6HQ4WFhbr4Yusmfffu3Z6huK0VFRWU6QXbzGazhURhAecatY5IEMl13iU5Su4wr7zC8HsffOe9S+3euvcopVuUSorrdfKkJNlks0mHD0s1NVYwmHZBVMS+1x0pkmsakYM6R6Sg1hGJQqXuOzSh+uc//6ns7OzTHo+NjdXSpUv13nvvqb6+XgUFBXrppZd0ww03SJKmTZumzZs3a+3ataqtrdXatWu1efNmXXvttZKk6667Tm+++aby8/NVXV2t5557TqmpqcrOzlZsbKxycnKUm5urkpISlZSUKDc3V9dcc40nLAQAAKEl3qfzfOPVbEuKvT3zurViAQzJu6Jtfb2hU6esx/bt87b3vyA8fmkHAAAAdOid68GDB9WzZ8/THs/KytLzzz+vV199VaNGjdKdd96pqVOnas6cOZKsYbfLli3T8uXLNXr0aL300ktaunSp0tPTJUnXX3+9br/9ds2dO1djx47Vv/71Ly1fvlwOh0OStGjRIqWlpWnq1KmaPHmy+vbtqyeeeKLjXjgAAGgTm81QnDU7hsoah3kl3u3WrGYrSSndTl/RtqjI+xhhHgAAAMJFhw6zff/998/YNmnSJE2aNOmM7ePGjdO4ceOabDMMQ7NmzdKsWbOabE9ISNDixYu1ePHitl0wAAAImvgEQxXl5mlhXnE7wryuPmFeSYl0wQXSviJvexphHgAAAMIEd64AACAkJSRaAVx5ueS7BpW7Z15CohQd3bZhtpI1V57kHWYbEyP16NW68wAAAADBRpgHAABCknvR+dpaQ9XV1rZpSiXF1rZvb7uWDBriveX560ZDFRXSkSPW8f0viFJUFGEeAAAAwgNhHgAACEnxid6AzT3UtrRUcrmsx7umtv42Jn2ATRcMtPYvKDD0ySfeNubLAwAAQDjh7hUAAISkhCbCPL/FL9rQM0+SrsrxThX836t8Fr9I53YIAAAA4YO7VwAAEJISEpoP87q1cvELt/FX2dWw0L1OnvQey+IXAAAACCfcvQIAgJAUn+jddod5xcXex1q7kq1bYpKhsZfbTnucYbYAAAAIJ9y9AgCAkOTbM6+8qWG2bQzzJOmqHIff1926G37DeQEAAIBQR5gHAABCkt+ceeXW3yXF3sfaOsxWkoaNjFL3HgyxBQAAQPjiDhYAAISkBL9htlYAV3yWPfOiogxNmOxdCIPFLwAAABBuuIMFAAAhKb6ZYbZRUVKX5PYNj82Z5lD3Hobi4qUrvmdv+QAAAAAghHAHCwAAQpLfMFt3mNewAEZKV0M2W/vCvOSuhpb/d6xqayWnk/nyAAAAEF4I8wAAQEhqPGdeba108qT1dXuG2PqKijLkdJ7VKQAAAICgYJgtAAAISfEJ3u3yMun4cck0rRCvazd61AEAACAyEeYBAICQZLMZio2ztsvKvPPlSe1byRYAAADoDAjzAABAyEpoWASjcZiXQpgHAACACEWYBwAAQlZ8w7x55eXSnj3eAI+eeQAAAIhULIABAABCVmKS9XdtraF33vY+3i2V30cCAAAgMnEnDAAAQtaEq+2KauJuhQUwAAAAEKnomQcAAELWlZMcuijLpv9bW6uPPqzV8RJT3XsYOq8vYR4AAAAiE2EeAAAIaT3Pi9Ktdzp140yHdn9Vr/P6RMluJ8wDAABAZCLMAwAAYcFuNzToIluwLwMAAAAIKubMAwAAAAAAAMIEYR4AAAAAAAAQJgjzAAAAAAAAgDBBmAcAAAAAAACECcI8AAAAAAAAIEwQ5gEAAAAAAABhgjAPAAAAAAAACBOEeQAAAAAAAECYIMwDAAAAAAAAwgRhHgAAAAAAABAmCPMAAAAAAACAMEGYBwAAAAAAAIQJwjwAAAAAAAAgTBDmAQAAAAAAAGGCMA8AAAAAAAAIE4R5AAAAAAAAQJggzAMAAAAAAADCBGEeAAAAAAAAECYI8wAAAAAAAIAwQZgHAAAAAAAAhAnCPAAAAAAAACBMEOYBAAAAAAAAYYIwDwAAAAAAAAgThHkAAAAAAABAmCDMAwAAAAAAAMIEYR4AAAAAAAAQJgjzAAAAAAAAgDBBmAcAAAAAAACECcI8AAAAAAAAIEwQ5gEAAAAAAABh4pyEeZWVlbrhhhu0evVqv8f37t2rmTNnasSIEbr88sv18ssv+7Vv3LhRU6dO1fDhw5WTk6MNGzb4tb/yyisaP368hg8frhkzZmjPnj2etoqKCj3yyCMaM2aMRo0apQcffFDl5eWtfm4AAAAAAAAg1AU8zCsoKNAtt9yizz//3O9xl8ulOXPmKCsrS5s2bdKKFSu0atUqffjhh5KkoqIizZs3T/fdd5+2bt2qefPmacGCBTpy5Igkac2aNXrjjTf02muvadOmTRoyZIjmz58v0zQlSYsXL9bhw4e1bt06rV+/XocPH1Zubm6rnhsAAAAAAAAIBwEN8z799FPNnDlTP/zhD9W7d2+/ti1btujbb7/V/Pnz5XQ6ddFFF2nGjBlatWqVJCusy87O1sSJE2W32zVlyhSNHj1ab731liTp7bff1s0336yMjAxFR0dr4cKFOnTokDZt2qTKykq99957mj9/vpKTk9WtWzfdf//9Wr16tSorK1t8bgAAAAAAACAc2Nuyc1VVlaenXGPdu3fX4MGDtWHDBkVHR2vlypV+7QUFBUpPT5fT6fQ8NnDgQK1YsUKSVFhYqMzMTL9jBg4cqPz8fE/77NmzPW0Oh0NpaWnKz89XcnKyXC6X3/EDBgxQVVWVioqKWnzu1qivr/f0AgxFdXV1fn8DnRW1jkhAnaOzoaYRCahzRApqHZHoTHVvs9mCcTltC/O2b9+u2267rcm2ZcuWaeLEiWc8try8XLGxsX6PxcbGqqKi4oztMTExrWovKyuTJMXFxfmd231cS8/dGlFRob1WiM1m06hRo4J9GcA5R60jElDn6GyoaUQC6hyRglpHJAq1um9TmDdmzBjt2rWrXU8UFxenyspKv8cqKysVHx8vyQrXqqqq/Nqrqqpa1e4O8XzP536uhISEFp8bAAAAAAAACAcd1t0sIyNDRUVFqq2t9TxWWFiojIwMSVJmZqYKCgr8jvFtz8jI8Gt3uVwqKipSZmam0tPT5XA4VFhY6GnfvXu3ZyhuS88NAAAAAAAAhIMOC/PGjBmjlJQUPffcc6qurlZ+fr7eeOMNXX/99ZKkadOmafPmzVq7dq1qa2u1du1abd68Wddee60k6brrrtObb76p/Px8VVdX67nnnlNqaqqys7MVGxurnJwc5ebmqqSkRCUlJcrNzdU111yjmJiYFp8bAAAAAAAACAeGeY5WdZgwYYJ+8pOfaPr06Z7H9u3bpyeffFLbt29XXFycbr31Vt11112e9k8++US5ubnav3+/+vTpowceeEBXXHGFJMk0Ta1cuVKrVq1SSUmJsrKy9POf/1zp6emSpLKyMj3zzDP6+OOP5XK5dNVVV+nxxx/3DMFt6bkBAAAAAACAUHfOwjwAAAAAAAAAgRXaS7QCAAAAAAAA8CDMAwAAAAAAAMIEYR4AAAAAAAAQJgjzAAAAAAAAgDBBmNeB8vPzdccdd+iSSy7RZZddpgcffFAlJSWSpO3bt+vf/u3fNGLECE2YMEHvvPOO5zjTNLVs2TJNmDBBI0eO1NSpU/WnP/2pyedYsmSJJkyY0OK1bNy4UVOnTtXw4cOVk5OjDRs2eNpqamr07LPPavz48Ro9erTmzp2rw4cPn+WrRyQJpVp3W7duna666qom25566ik9/PDDbXiFwLmr82PHjmnQoEEaMWKE509Ltd7cZ7ovah3NCZeaPnnypO6//36NGTNGI0eO1MyZM/Xll18G+N1AZxUudV5fX68RI0Zo+PDhfuesqKgI8DuCzipcat33PCNGjNDFF1+sQYMG6f333w/wO4JIEC51H5DMxUSHqKysNC+77DLzxRdfNKurq82SkhJz9uzZ5t13322eOHHCvOSSS8w333zTdLlc5j/+8Q9zxIgR5vbt203TNM2VK1eaEyZMMAsLC836+nrzo48+MrOysjztbv/4xz/MIUOGmFdeeWWz17J3714zKyvL/L//+z/T5XKZH3zwgTls2DDzm2++MU3TNP/zP//TnDhxovnVV1+Z1dXV5jPPPGNeffXVZnV19bl5c9CphFKtm6Zp1tTUmCtWrDAvuuii0/YvKSkxFy5caGZmZpoPPfRQ4N4EdHrnss4//vjjVtW2W0uf6aZJraNl4VTTP/nJT8y7777bPHnypFlTU2Pm5uaa3/3udwP/pqDTCac637VrlzlkyBDuv9Eu4VTrjT3wwAPmrFmzTJfLdfZvBCJKONV9IDIXeuZ1kEOHDmnw4MGaO3eunE6nUlJSdMMNN2jLli1av369kpOTdcstt8hut+vSSy/V1KlTtWrVKknSqVOnNHfuXA0YMECGYWjChAkaMGCAPvvsM8/5jx07pscee0wzZsxo8VrWrFmj7OxsTZw4UXa7XVOmTNHo0aP11ltvSZLef/99zZ07VxkZGXI6nVq4cKGOHDmiTz/99Ny8OehUQqnWJWnWrFnatGmTZs+e7fd4eXm5Jk+erKSkJF199dWBewMQEc5lnefl5Wno0KGtvpaWPtOpdbRGONX0888/rxdffFFJSUmqqKjQqVOnlJKSEvg3BZ1OONV5Xl6eBg0aJKfTGfg3Ap1eONW6r9WrV+sf//iHcnNzZbfbA/NmIGKEU90HInPhX0gHueCCC/Tqq6/6PbZu3ToNGTJEBQUFyszM9GsbOHCg3n33XUnS/Pnz/dp2796tgoICDRkyRJLVDf/+++/X7Nmz5XQ6tW7dumavpbCwsMnny8/PlyTV1dUpNjbW02YYhiRp7969uuKKK1r7khGhQqnWJenZZ59Vr169tHr1ar/Ho6Oj9cEHHyg1NZVhh2izc1nneXl5OnnypK655hodO3ZMWVlZeuihhzRw4MAmr6Wlz3RqHa0RTjXtcDgkWdMtLF++XPHx8Vq+fHk7XzkiSTjVeV5enqqrq3Xdddfp66+/1oABA7Rw4UKNHDmy/W8AIkY41bpbaWmpnnnmGS1atIhf0KBdwqnuA5G50DMvCEzT1JIlS7RhwwY9+uijKi8v9/tGSlJMTEyTc2Ls3btXs2fP1rRp0zR69GhJ0q9//WslJibqxhtvbNXzt/R8kyZN0ssvv6z9+/erurpaL774oqqrq1VVVdWel4sIFuxal6RevXo1+bjdbldqamobXg3QtEDXeVJSkkaNGqXf/e53+vOf/6y0tDTdcccdKi0tbfL5W3o+ah1tFeo17XbPPfdox44d+slPfqLZs2frwIEDZ/OyEWFCvc5jYmI0bNgwvfTSS/rLX/6iCRMm6M4776TO0WahXutuv/vd79SnTx/l5OSczcsFJIV+3Qcic6FnXgcrKyvTI488op07d+rNN9/UoEGDFBsbe1oRVFVVKT4+3u+xjz/+WA8//LCmT5+uhx56SJK0ZcsWrV69+rReR24vv/yy32+rX3nlFcXGxp5WJL7P9/DDDys3N9fTBfX6669XZmamkpKSzvr1I3KEQq1nZ2cH+FUB/gJd55L03HPP+e33yCOP6A9/+IO2bt2qXbt2tfkzHWiLcKrpmJgYSdIdd9yhd955Rx999JFuv/32dr92RI5wqPPGPanvvPNOrV69Whs3btStt97a/hePiBIOtS5Zwcu7776r+fPne3ooAe0VDnUfiMyFMK8D7d+/X7Nnz1bv3r317rvvqmvXrpKkzMxM/f3vf/fbt7CwUBkZGZ6vly1bpldffVVPPvmkpk6d6nn8j3/8o0pKSjyrdLpcLlVXVys7O1svv/yy5syZozlz5vid+5NPPtHOnTtPez73GPAjR47onnvu0RNPPCHJWjVu+fLlbRojjsgWKrUOnEvnos7Lysq0bNky3XrrrerTp48kqxt+bW2tYmJi2vWZDrRWuNT0jTfeqNtvv12TJ0/2tNfU1KhLly4BeBfQ2YVLnS9ZskRXX321LrroIk97TU2NoqOjA/AuIBKES61L1hDG4uJiv891oD3Cpe4Dkrm0eqkMnJUTJ06Y3/3ud82HH37YrKur82srKSkxs7OzzZUrV5o1NTXmp59+ao4YMcL89NNPTdM0zddff90cNWqUuXPnzhaf5w9/+EOLq6wUFhaaWVlZ5gcffOBZWSUrK8vcs2ePaZqm+cQTT5izZs0yy8rKzBMnTpg//elPzRtvvLGdrxyRJpRqvbX7P/TQQ6zwiTY5l3U+bdo0c968eeapU6fMsrIy8/HHHzdzcnLMmpqaJvdv6TPdF7WOMwmnmn766afNKVOmmAcPHjSrq6vNF1980Rw3bpx54sSJAL4j6IzCqc7nzJlj3nzzzea3335rVldXm0uXLjXHjh1rHj9+PHBvCDqtcKp193Py8ybOVjjVfSAyF8M0TbP10R/aa+XKlfrlL3+p2NjY07oOb9u2TXl5eXr66af11VdfqWvXrrr33ns1ffp0maap0aNHq7Ky8rTVrO6+++7TEuDVq1frV7/6lT7++ONmr+eTTz5Rbm6u9u/frz59+uiBBx7wTLRYVlamRYsW6W9/+5sk6fLLL9djjz3GRKRolVCr9dbs7x7K8stf/rItLxUR7FzW+ddff61f/OIX2rJli1wul8aMGaPHHnvM85vApjT3me6LWseZhFNN19TUaMmSJXrvvffkcrk0fPhwPfzww0pPTw/8G4NOJZzq/MSJE3rmmWe0ceNGVVZWKisrS//xH/+hwYMHB/6NQacTTrUuSU8++aRKSkr0wgsvBPR9QGQJp7oPROZCmAcAAAAAAACECVazBQAAAAAAAMIEYR4AAAAAAAAQJgjzAAAAAAAAgDBBmAcAAAAAAACECcI8AAAAAAAAIEwQ5gEAAAAAAABhgjAPAAAAAAAACBOEeQAAAAAAAECYIMwDAAAAAAAAwgRhHgAAAAAAABAmCPMAAAAAAACAMEGYBwAAAAAAAISJ/w+iiynRxBBXngAAAABJRU5ErkJggg==", "text/plain": [ "
" ] } ], "source": [ "fig2, ax2 = plt.subplots(figsize=(15,7))\n", "\n", "ax2.plot(merge_df['Release Date'],merge_df['USDperday'], color = '#48C38D', linewidth=2.5, label='Spark30S (Atlantic)')\n", "ax2.plot(merge_df['Release Date'],merge_df['FreightBreakeven'], color='#4F41F4', linewidth=2, label='US Arb [M+1] Freight Breakeven Level')\n", "\n", "ax2.fill_between(merge_df['Release Date'], merge_df['USDperday'], merge_df['FreightBreakeven'], \\\n", " where=merge_df['USDperday']>merge_df['FreightBreakeven'], facecolor='red', interpolate=True, alpha=0.05)\n", "\n", "ax2.fill_between(merge_df['Release Date'], merge_df['USDperday'], merge_df['FreightBreakeven'], \\\n", " where=merge_df['USDperday']