From d349ff475e0ae8363d47070278ecef0f95ceff4d Mon Sep 17 00:00:00 2001 From: GabrielRoger07 Date: Wed, 18 Sep 2024 18:33:22 -0300 Subject: [PATCH] padronizacao do notebook de metricas github --- internal_quality_analysis-github.ipynb | 790 +++++++++++++++++++------ 1 file changed, 598 insertions(+), 192 deletions(-) diff --git a/internal_quality_analysis-github.ipynb b/internal_quality_analysis-github.ipynb index ca80a57..1e207b1 100644 --- a/internal_quality_analysis-github.ipynb +++ b/internal_quality_analysis-github.ipynb @@ -2,298 +2,704 @@ "cells": [ { "cell_type": "markdown", + "id": "8a55aecd-44f1-498f-a90e-cbf5c3c96784", + "metadata": {}, "source": [ - "### LIBRARIES" - ], + "# Analytics - Product Quality - GitHub\n", + "\n", + "#### Date: 2020/02\n", + "\n", + "#### SUMMARY:\n", + "\n", + "- This notebook represents the project quality analysis of the date exposed right above. \n", + "\n", + "### TEAM:\n", + "\n", + "##### Semester: YYYY/0X\n", + "##### Professor: Hilmer Neri\n", + "\n", + "##### Members:\n", + "\n", + "- Member x\n", + "- Member y\n" + ] + }, + { + "cell_type": "markdown", + "id": "cc56e56572a75249", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "id": "cc56e56572a75249" + "source": [ + "### LIBRARIES" + ] }, { "cell_type": "code", + "execution_count": 1, + "id": "a3bcddb987f2383e", + "metadata": { + "ExecuteTime": { + "end_time": "2024-06-12T20:09:03.884001Z", + "start_time": "2024-06-12T20:09:03.878379Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# Deal with data\n", "import pandas as pd\n", "import json\n", "from glob import glob\n", + "import os\n", "\n", "# Deal with visualization\n", + "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", + "# Deal with type hints\n", + "from typing import List\n", + "\n", "# Deal with time\n", "import datetime" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-06-12T20:09:03.884001Z", - "start_time": "2024-06-12T20:09:03.878379Z" - } - }, - "id": "a3bcddb987f2383e", - "execution_count": 2 + ] }, { "cell_type": "markdown", + "id": "3a315c21-4e4f-4564-ac03-e70d83f4679f", + "metadata": {}, "source": [ - "## Github API\n", - "\n", - "A API do GitHub utiliza principalmente o protocolo HTTP, onde as operações são realizadas através de URLs e métodos HTTP, como GET, POST, PUT e DELETE. Os dados são geralmente retornados em formato JSON, tornando-o fácil de processar e interpretar." - ], - "metadata": { - "collapsed": false - }, - "id": "8b4e0d6b878f9fc2" + "### GRAPH SETTINGS" + ] }, { "cell_type": "code", + "execution_count": 2, + "id": "bbaa9a4d-8e81-4e7e-b4f9-f7e8743ba314", + "metadata": {}, "outputs": [], "source": [ - "data = glob('./analytics-raw-data/GitHub_API-fga-eps-mds-*.json')\n", - "# print(data)" - ], + "%config InlineBackend.figure_format ='retina'\n", + "sns.set(font_scale=1.5)\n", + "sns.set_style('darkgrid',\n", + " {'xtick.bottom' : True,\n", + " 'ytick.left': True,\n", + " 'grid.linestyle':'--',\n", + " 'font.monospace': ['Computer Modern Typewriter'],\n", + " 'axes.edgecolor' : 'white'})" + ] + }, + { + "cell_type": "markdown", + "id": "3792c745-e45a-4324-b724-23923c5ea39b", + "metadata": {}, + "source": [ + "### DATAFRAME SETTINGS" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "54a87689-bcbd-431a-b1bd-1892b8b155f6", + "metadata": {}, + "outputs": [], + "source": [ + "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)" + ] + }, + { + "cell_type": "markdown", + "id": "e617f606-12fe-434c-b5c4-32c851afa637", + "metadata": {}, + "source": [ + "#### Replace your repository names" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3b0dfdf1-0e1f-4eb6-86ed-785f7eef57da", + "metadata": {}, + "outputs": [], + "source": [ + "# Add your repos here\n", + "# Example: ['YourRepoName_1', 'YourRepoName_2']\n", + "repos_project = ['Admin']" + ] + }, + { + "cell_type": "markdown", + "id": "b6a105e0-2943-4a38-9e85-6cb2e6a5e613", + "metadata": {}, + "source": [ + "### GitHub\n", + "##### Path to the folder with all your jsons" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "22e8719f-2ae9-4dc6-838c-6adf689adbac", + "metadata": {}, + "outputs": [], + "source": [ + "data_runs = glob('./analytics-raw-data/GitHub_API-Runs-fga-eps-mds-*.json')" + ] + }, + { + "cell_type": "markdown", + "id": "ae407b2c-0d5c-4ea6-9daa-72f3b32a8ab4", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "id": "bfc238b8cb27fee1", - "execution_count": null + "source": [ + "# Create Workflow Runs DataFrame" + ] }, { "cell_type": "markdown", - "source": [ - "#### Unmarshall json" - ], + "id": "ffa8cabeda8ab48c", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "id": "ffa8cabeda8ab48c" + "source": [ + "#### Unmarshall json" + ] }, { "cell_type": "code", + "execution_count": 8, + "id": "26a5d6d115efe1a6", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "def unmarshall(json_path: str) -> dict:\n", " with open(json_path) as json_file:\n", " json_obj = json.load(json_file)\n", " return json_obj" - ], - "metadata": { - "collapsed": false - }, - "id": "26a5d6d115efe1a6", - "execution_count": null + ] }, { "cell_type": "markdown", + "id": "de82960a-1bed-417a-a1e7-4df4969da498", + "metadata": {}, "source": [ - "### Cálculo dos dados\n", + "#### Extract Workflow Runs Data" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f00b83fb-a256-427b-a5dc-056f0a7c5da8", + "metadata": {}, + "outputs": [], + "source": [ + "def get_workflow_data():\n", + " for json_path in data_runs:\n", + " dados = unmarshall(json_path)\n", + " table_data = []\n", + " for run in dados[\"workflow_runs\"]:\n", + " updated_at = datetime.datetime.strptime(run[\"updated_at\"], \"%Y-%m-%dT%H:%M:%SZ\")\n", + " created_at = datetime.datetime.strptime(run[\"created_at\"], \"%Y-%m-%dT%H:%M:%SZ\")\n", + " feedback_time = (updated_at - created_at).total_seconds()\n", + " \n", + " workflow_id = run[\"id\"]\n", + " conclusion = run[\"conclusion\"]\n", + " author = run[\"actor\"][\"login\"]\n", "\n", - "- Carrega dados dos arquivo JSON e armazena-os na variável data.\n", - "- Processa os dados do JSON para calcular e obter informações relevantes sobre os tempos de feedback de cada execução de workflow, separando-os em listas de feedback_times, authors_feedback_times, e ci_feedback_times.\n", - "- Calcula o tempo médio de feedback (ci_feedback_time) considerando todas as execuções de workflow.\n", - "- Calcula o tempo médio de feedback de cada autor e armazena essas informações em authors_avg_feedback_times.\n", - "- Processa novamente os dados do JSON para contar o número de execuções bem-sucedidas (success_count) e falhas (failure_count) dos workflows." - ], - "metadata": { - "collapsed": false - }, - "id": "7d100c7f5283260c" + " repo = run[\"repository\"][\"name\"].split(\"-\")[-1]\n", + " \n", + " table_data.append({\n", + " \"Workflow_run ID\": workflow_id,\n", + " \"Conclusion\": conclusion,\n", + " \"Author\": author,\n", + " \"Created at\": created_at,\n", + " \"Updated at\": updated_at,\n", + " \"Feedback Time\": feedback_time,\n", + " \"Repository Name\": repo\n", + " })\n", + "\n", + " return table_data" + ] + }, + { + "cell_type": "markdown", + "id": "8b78f114-2fb0-4930-b35e-f30a57a951a1", + "metadata": {}, + "source": [ + "#### Generate Workflow Runs DataFrame" + ] }, { "cell_type": "code", + "execution_count": 10, + "id": "0586846b-dd80-42ea-b1f0-c20774766501", + "metadata": {}, "outputs": [], "source": [ - "tabela_total = pd.DataFrame()\n", + "def generate_workflow_runs_df(data: List[dict]) -> pd.DataFrame:\n", + " df = pd.DataFrame(data)\n", "\n", - "# Processar os dados do JSON e obter as informações relevantes\n", - "success_count = 0\n", - "failure_count = 0\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9ab30a5a-8986-4fb5-bc24-323e0192440a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Workflow_run IDConclusionAuthorCreated atUpdated atFeedback TimeWorkflow .YML NameRepository Name
010712048238failurevictorleaoo2024-09-05 01:10:012024-09-05 01:11:2584.0code-analysisAdmin
110712041253successvictorleaoo2024-09-05 01:09:172024-09-05 01:10:4790.0code-analysisAdmin
210712038868successvictorleaoo2024-09-05 01:09:042024-09-05 01:10:2682.0code-analysisAdmin
310712038863successvictorleaoo2024-09-05 01:09:042024-09-05 01:09:1511.0deployAdmin
410711995645successvictorleaoo2024-09-05 01:04:392024-09-05 01:04:5011.0deployAdmin
\n", + "
" + ], + "text/plain": [ + " Workflow_run ID Conclusion Author Created at \\\n", + "0 10712048238 failure victorleaoo 2024-09-05 01:10:01 \n", + "1 10712041253 success victorleaoo 2024-09-05 01:09:17 \n", + "2 10712038868 success victorleaoo 2024-09-05 01:09:04 \n", + "3 10712038863 success victorleaoo 2024-09-05 01:09:04 \n", + "4 10711995645 success victorleaoo 2024-09-05 01:04:39 \n", + "\n", + " Updated at Feedback Time Workflow .YML Name Repository Name \n", + "0 2024-09-05 01:11:25 84.0 code-analysis Admin \n", + "1 2024-09-05 01:10:47 90.0 code-analysis Admin \n", + "2 2024-09-05 01:10:26 82.0 code-analysis Admin \n", + "3 2024-09-05 01:09:15 11.0 deploy Admin \n", + "4 2024-09-05 01:04:50 11.0 deploy Admin " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "workflow_run_df = generate_workflow_runs_df(get_workflow_data())\n", + "workflow_run_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "b80d2146-c622-475c-bebb-436f50004554", + "metadata": {}, + "source": [ + "### Create dataframe per repository" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "15cc9748-c09d-41a4-a053-084be8358ce4", + "metadata": {}, + "outputs": [], + "source": [ + "repos_dataframes = []\n", "\n", - "for json_path in data:\n", - " dados = unmarshall(json_path)\n", - " # Create a list to store the data for the table\n", - " table_data = []\n", - " # Processar os dados do JSON e obter as informações relevantes\n", - " for run in dados[\"workflow_runs\"]:\n", - " updated_at = datetime.datetime.strptime(run[\"updated_at\"], \"%Y-%m-%dT%H:%M:%SZ\")\n", - " created_at = datetime.datetime.strptime(run[\"created_at\"], \"%Y-%m-%dT%H:%M:%SZ\")\n", - " feedback_time = (updated_at - created_at).total_seconds()\n", - " \n", - " # informações relevantes\n", - " workflow_id = run[\"id\"]\n", - " conclusion = run[\"conclusion\"]\n", - " author = run[\"actor\"][\"login\"]\n", - " \n", - " # Adiciona os dados na tabela\n", - " table_data.append({\n", - " \"Workflow_run ID\": workflow_id,\n", - " \"Conclusion\": conclusion,\n", - " \"Author\": author,\n", - " \"Created at\": created_at,\n", - " \"Updated at\": updated_at,\n", - " \"Feedback Time\": feedback_time\n", - " })\n", - " \n", - " \n", - " # Cria um dataframe com o pandas\n", - " df = pd.DataFrame(table_data)\n", - "\n", - " \n", - " # table_data_global.append(df)\n", - " \n", - " # Processar os dados do JSON e obter as informações relevantes\n", + "for repo in repos_project:\n", + " dataframe = workflow_run_df[workflow_run_df['Repository Name'] == repo]\n", + " repos_dataframes.append({'name': repo, 'df': dataframe})" + ] + }, + { + "cell_type": "markdown", + "id": "d18763f3-9be7-4d12-9a5f-30f3e4e2dde0", + "metadata": {}, + "source": [ + "## Quality Aspect - Productivity" + ] + }, + { + "cell_type": "markdown", + "id": "afb1d222-4d16-4913-8ddf-a3684f32bb24", + "metadata": {}, + "source": [ + "### Factor - Testing Performance" + ] + }, + { + "cell_type": "markdown", + "id": "2ec244b8-2e00-4786-8966-740a6a9f02ff", + "metadata": {}, + "source": [ + "#### CI Feedback Time" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "00ca1f8d-78d9-4bc4-901b-a48e011aa10d", + "metadata": {}, + "outputs": [], + "source": [ + "def ci_feedback_time(df: pd.DataFrame):\n", " feedback_times = []\n", " authors_feedback_times = {}\n", " ci_feedback_times = []\n", "\n", - " for run in df.index:\n", + " # Filter for builds workflow runs only\n", + " df_filtered = df.copy()\n", + "\n", + " for run in df_filtered.index:\n", " updated_at = df[\"Updated at\"][run]\n", " created_at = df[\"Created at\"][run]\n", " feedback_time = (updated_at - created_at).total_seconds()\n", " feedback_times.append(feedback_time)\n", - " \n", - " # Calcular o CI FeedBack Time\n", + "\n", " ci_feedback_time = sum(feedback_times) / len(feedback_times)\n", - " df[\"Ci Feedback Time\"] = ci_feedback_time\n", - " \n", - " # Tabela com todas as linhas\n", - " tabela_total = pd.concat([tabela_total, df])\n", - " # print('Tabela por dia')\n", - " # display(df)\n", - "\n", - " for run in dados[\"workflow_runs\"]:\n", - " conclusion = run[\"conclusion\"]\n", - " if conclusion == \"success\":\n", - " success_count += 1\n", - " elif conclusion == \"failure\":\n", - " failure_count += 1\n", - " \n", - "print('Tabela com todas as linhas')\n", - "display(tabela_total)\n", - "\n" - ], - "metadata": { - "collapsed": false - }, - "id": "1c0aedb7ec427cd6", - "execution_count": null + " df_filtered.loc[:, \"Ci Feedback Time\"] = ci_feedback_time\n", + "\n", + " return df_filtered" + ] }, { "cell_type": "markdown", + "id": "863c66cf-61d7-4ffe-9dfa-a988eb0c313b", + "metadata": {}, + "source": [ + "#### Extra: Count of Successes and Failures Workflows" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7225f6e6-9383-448c-9bd1-2345c6b281d0", + "metadata": {}, + "outputs": [], "source": [ - "# Gerar gráficos\n", + "def count_success_failure_workflow_runs(df: pd.DataFrame):\n", + " counts = df['Conclusion'].value_counts()\n", "\n", - "- Gráfico de linhas: Mostra o \"CI FeedBack Time\" (tempo de feedback do CI) em relação à \"Data de Atualização\" das execuções de workflow.\n", - "- Gráfico de barras simples: Exibe o \"Tempo Médio de Feedback do CI\", representando o desempenho médio geral do CI.\n", - "- Gráfico de pizza: Mostra a \"Quantidade de Workflows com Sucesso e Falha\" em relação ao total de workflows executados, indicando a proporção de workflows que tiveram sucesso e falha." - ], - "metadata": { - "collapsed": false - }, - "id": "caf5e0b5aa86287a" + " num_failures = counts.get('failure', 0)\n", + " num_successes = counts.get('success', 0)\n", + "\n", + " return num_failures, num_successes" + ] + }, + { + "cell_type": "markdown", + "id": "561250db-96a5-49a6-b7d3-c691301d4c3f", + "metadata": {}, + "source": [ + "### Factor - Issues' Velocity" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "8646b168-63e8-4318-bee1-1f8183283d36", + "metadata": {}, + "source": [ + "#### Team Throughput" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "22b8bf90-2188-426a-8633-94b6979cfab2", + "metadata": {}, + "source": [ + "## Calculate measures for each repository\n", + "\n", + "Filter the dataset with the set dates in the notebook's beginning." + ] }, { "cell_type": "code", + "execution_count": 18, + "id": "5def5764-c150-4e39-aaad-2295ec0a9c02", + "metadata": {}, "outputs": [], "source": [ - "# Gerar gráfico com o CI FeedBack Time por data de atualização\n", - "\n", - "temp = tabela_total[['Created at', 'Ci Feedback Time']]\n", - "dates = temp.groupby(['Created at']).mean().reset_index() # Calcula a média dos valores por data\n", - "dates['Created at'] = pd.to_datetime(dates['Created at']) \n", - "print(dates)\n", - "\n", - "\n", - "# dates = [datetime.datetime.strptime(run[\"updated_at\"], \"%Y-%m-%dT%H:%M:%SZ\") for run in data[\"workflow_runs\"]]\n", - "plt.figure(figsize=(20, 10))\n", - "plt.plot(range(len(dates)), dates['Ci Feedback Time'], marker='o', color='b', label='Feedback Time')\n", - "plt.xlabel(\"Created at\")\n", - "plt.ylabel(\"CI FeedBack Time\")\n", - "plt.title(\"CI FeedBack Time por Data de Criação\")\n", - "plt.xticks(range(len(dates)), dates['Created at'].dt.strftime('%Y-%m-%d'), rotation=45)\n", - "plt.grid(True)\n", - "plt.legend()\n", - "plt.tight_layout() # Ajusta a disposição dos elementos para evitar sobreposições\n", - "plt.show()" - ], - "metadata": { - "collapsed": false - }, - "id": "fc0acb669d16ee73", - "execution_count": null + "def create_metrics_df() -> pd.DataFrame:\n", + "\n", + " m1_list = []\n", + " m2_list = []\n", + " m3_list = []\n", + "\n", + " repository_list = []\n", + " version_list = []\n", + "\n", + " for repo_info in repos_dataframes:\n", + " repo_df = repo_info[\"df\"]\n", + "\n", + " repo_df['Updated at'] = pd.to_datetime(repo_df['Updated at'])\n", + "\n", + " # Filter the selected date range\n", + " df_date_filtered = repo_df.copy()\n", + "\n", + " try:\n", + " m1_list.append(ci_feedback_time(df_date_filtered))\n", + " except Exception:\n", + " m1_list.append(0)\n", + "\n", + " try:\n", + " m2_list.append(count_success_failure_workflow_runs(df_date_filtered))\n", + " except Exception:\n", + " m2_list.append(0)\n", + "\n", + " try:\n", + " m3_list.append(duplication(version_df))\n", + " except Exception:\n", + " m3_list.append(0)\n", + "\n", + " repository_list.append(repo_info['name'])\n", + "\n", + " return m1_list, m2_list, m3_list, repository_list" + ] }, { + "cell_type": "code", + "execution_count": 19, + "id": "862a7f43-fa4f-4367-8852-8f33404214a3", "metadata": {}, + "outputs": [], + "source": [ + "m1_list, m2_list, m3_list, repository_list = create_metrics_df()" + ] + }, + { + "cell_type": "markdown", + "id": "92d6b400-a92b-408b-8828-8e5eef63d7aa", + "metadata": {}, + "source": [ + "## Plotting Metrics Functions" + ] + }, + { + "cell_type": "markdown", + "id": "d953bfed-a4dc-4303-9356-443fdde7a8f8", + "metadata": {}, + "source": [ + "### Generate CI Feedback Time Plots" + ] + }, + { "cell_type": "code", + "execution_count": 20, + "id": "ad0116c1-6ef7-4661-9ab0-a143f573bba4", + "metadata": {}, "outputs": [], - "execution_count": null, - "source": [ - "plt.figure(figsize=(20, 10))\n", - "bars = plt.bar(range(len(dates)), dates['Ci Feedback Time'], color='salmon', label='Feedback Time')\n", - "plt.xlabel(\"Created at\")\n", - "plt.ylabel(\"CI FeedBack Time\")\n", - "plt.title(\"CI FeedBack Time por Data de Criação\")\n", - "plt.xticks(range(len(dates)), dates['Created at'].dt.strftime('%Y-%m-%d'), rotation=45) # Exibe as datas formatadas no eixo X\n", - "plt.legend()\n", - "# Adiciona as labels em cada barra\n", - "for bar in bars:\n", - " height = bar.get_height()\n", - " plt.text(bar.get_x() + bar.get_width() / 2, height, str(height), ha='center', va='bottom')\n", - "\n", - "plt.tight_layout() # Ajusta a disposição dos elementos para evitar sobreposições\n", - "plt.show()\n", - "\n", - "# # Gerar gráfico com o tempo médio do CI\n", - "# plt.figure(figsize=(20, 10))\n", - "# plt.bar([\"CI\"], [ci_feedback_time], color='salmon')\n", - "# plt.xlabel(\"CI\")\n", - "# plt.ylabel(\"Tempo Médio de Feedback\")\n", - "# plt.title(\"Tempo Médio de Feedback do CI\")\n", - "# plt.text(0, ci_feedback_time, f'{round(ci_feedback_time, 2)} segundos', ha='center', va='bottom', fontweight='bold')\n", - "# plt.tight_layout()\n", - "# plt.show()" - ], - "id": "8f74ecd7e0bcd3bb" + "source": [ + "def ci_feedback_time_plots(df: pd.DataFrame, repo_name: str):\n", + " temp = df[['Created at', 'Ci Feedback Time']]\n", + " dates = temp.groupby(['Created at']).mean().reset_index()\n", + " dates['Created at'] = pd.to_datetime(dates['Created at'])\n", + "\n", + " plt.figure(figsize=(15, 7))\n", + " plt.plot(range(len(dates)), dates['Ci Feedback Time'], marker='o', color='b', label='Feedback Time')\n", + " plt.xlabel(\"Created at\")\n", + " plt.ylabel(\"CI FeedBack Time\")\n", + " plt.title(f\"CI FeedBack Time By Creation Date - {repo_name}\")\n", + " plt.xticks(range(len(dates)), dates['Created at'].dt.strftime('%Y-%m-%d'), rotation=45)\n", + " plt.grid(True)\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " plt.show()" + ] }, { + "cell_type": "markdown", + "id": "7024316f-eebf-4275-a3c4-e5c34359b1dd", "metadata": {}, + "source": [ + "### Generate Count of Successes and Failures Workflows Plots" + ] + }, + { "cell_type": "code", + "execution_count": 21, + "id": "dbce3363-6d61-4e4a-86b3-acfbdd73bed0", + "metadata": {}, "outputs": [], - "execution_count": null, - "source": [ - "# Gerar gráfico com a quantidade de workflows com sucesso e falha\n", - "labels = [\"Success\", \"Failure\"]\n", - "sizes = [success_count, failure_count]\n", - "plt.figure(figsize=(20, 10))\n", - "colors = ['lightgreen', 'crimson']\n", - "plt.pie(sizes, labels=labels, autopct='%1.1f%%', colors=colors)\n", - "plt.title(\"Quantidade de Workflows_runs com Sucesso e Falha\")\n", - "plt.legend(labels, loc='best')\n", - "plt.tight_layout()\n", - "plt.show()" + "source": [ + "def count_sucess_failure_workflow_plot(data: list, repo_name: str):\n", + " labels = [\"Success\", \"Failure\"]\n", + " sizes = [data[1], data[0]]\n", + " plt.figure(figsize=(15, 7))\n", + " colors = ['lightgreen', 'crimson']\n", + " plt.pie(sizes, labels=labels, autopct='%1.1f%%', colors=colors)\n", + " plt.title(f\"Quantidade de Workflows_runs com Sucesso e Falha - {repo_name}\")\n", + " plt.legend(labels, loc='best')\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "795ec12b-7ff0-4675-ad3a-137078a911cb", + "metadata": {}, + "source": [ + "## Data Visualization\n", + "\n", + "In this area you will need to plot the metrics of each repository in the selected date range." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "f934be1e-3a0c-435d-96f0-ce8b44211905", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAC28AAAU0CAYAAAD1lc63AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3xT1f/H8Xea7t2y95K9hywBwQEORMWBMgQXIgq4xcFWQRAnKktBkaUMUZQhGxQZsmTvVTZt6V5Jfn/4o1/SpG3Spg0pr+fjwUPuyb3nfNom99zK+55rsFgsFgEAAAAAAAAAAAAAAAAAAAAACpSXuwsAAAAAAAAAAAAAAAAAAAAAgBsB4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEBDeBgAAAAAAAAAAAAAAAAAAAIBCQHgbAAAAAAAAAAAAAAAAAAAAAAoB4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEBDeBgAAAAAAAAAAAAAAAAAAAIBCQHgbAAAAAAAAAAAAAAAAAAAAAAoB4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEBDeBgAAAAAAAAAAAAAAAAAAAIBCQHgbAAAAAAAAAAAAAAAAAAAAAAoB4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEBDeBgAAAAAAAAAAAAAAAAAAAIBCQHgbAAAAAAAAAAAAAAAAAAAAAAoB4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEBDeBgAAAAAAgCRpwYIFqlmzptWf06dPu7ssZPHFF1/Y/Jxgi/czAPxPr169rM6HvXr1cndJAOAyN+o5btOmTTbXu5s2bXJ3WQAAAAAAB3i7uwAAAAAAAPA/FotFx44d08mTJ3X27FklJiYqLS1NQUFBCgsLU1hYmKpXr67y5cu7u1QAAOChuN4AAAAAAAAAAPchvA0AAAAAgJslJSVp2bJlWr58ubZs2aL4+Phcj4mIiFDDhg3VsWNHderUScHBwQ6NtWnTJj3xxBNWbQ8++KDGjBmTp9qd0atXL23evNmlff7888+qXbu2S/uE87744gtNmDDBqWN8fHwUFBSkkJAQVa5cWbVr11aLFi3UqlUrGY3GAqoUhWHBggV666233DL2iy++qAEDBrhlbLjGbbfdpqioKKeOCQwMVFBQkCIiIlSjRg3VqVNHd9xxhypVqlRAVXqmwrzeAG50zlwb+fj4yNfXV4GBgYqMjFSJEiVUqVIlVa1aVQ0aNFDt2rXl4+NTwBUD9vXs2VNbtmyxaZ8zZ44aN27shooAAAAAACgaCG8DAAAAAOAmiYmJmjJlimbNmqUrV644dWxMTIzWrFmjNWvWaOTIkerUqZMGDBigChUqFFC1gGulp6crNjZWsbGxOnXqlNavX6/JkyerRIkS6tOnj3r37k1QCYBDkpKSlJSUpIsXL+rgwYNavHixxo4dq8aNG+u1115Ts2bN3F2iW3G94ZkGDx6shQsXZm6XK1dOq1atcmNFKCjp6elKT09XYmKiLl68qAMHDmjDhg2ZrwcEBKht27a6++67deedd3rs9RHvac9z/Phxu8FtSZo/fz7hbQAAAAAA8sHL3QUAAAAAAHAj+vPPP3XXXXfp66+/djpIlVVKSooWLVqku+++W++9955SU1NdVCVQ+C5evKhx48bpwQcfdHr1XQC41vbt29WjRw+NGjVKZrPZ3eW4BdcbgOdLTk7W8uXL9fLLL+u2227T9OnTlZ6e7u6ycAOYP39+tq/9/vvvSkpKKsRqAAAAAAAoWlh5GwAAAACAQjZ58mR9/PHHslgsdl8PCwtTq1atVK1aNUVGRioyMlIWi0VxcXE6ffq0du/erR07diglJcXquPT0dM2YMUN9+vRR+fLlC+NLybdq1arla/VAPz8/F1YDVypTpozCwsKyfT05OVmxsbHZhgkPHTqkHj16aPbs2SpTpkxBlYkCEBYWplq1ajl1zKVLl3Tp0iWrtuLFi6t48eJO9ePs/vAMOb2fzGZz5mq1aWlpdvf54YcflJSUpNGjRxdUidclrjeA60t210Zms1lxcXGKj49XUlJStp9ZSbpw4YJGjx6tH3/8UePHj1ft2rULsmTcwEwmk9VK6VklJiZqyZIleuihhwqxKgAAAAAAig7C2wAAAAAAFKJPPvlEEydOtPta27Zt1a9fPzVu3FhGozHHfpKTk7V69WrNmDFD27ZtK4hSC8XkyZMJfhVRAwcOVNeuXXPd78KFC1q7dq2+//57HTx40Oq1s2fPasSIEdl+ZnB9uv3223X77bc7dcwXX3yhCRMmWLU99thjGjBgQJ7r6Nq1q0PvQVz/Fi1alOs+GRkZOnz4sH777bfMsPa1FixYoFtvvVV33XVXQZV5XeF6A1nNmDHD3SXc8By5NjKZTDp69Kh27dqlXbt2acWKFTY3N0nSkSNH1K1bN3300Ufq2LFjQZWMG9jatWt18eJFqzaDwWB1c8G8efMIb7tZixYtdODAAXeXAQAAAADIAy93FwAAAAAAwI3ip59+shukKlGihL777jtNnTpVzZo1yzVIJUkBAQG65557NHv2bE2fPl01atQoiJKBAleyZEk98sgjWrhwoR555BGb11evXq0dO3YUfmEAPIq3t7dq1aqlV199Vb/88ovdG4M+++wzN1RW+LjeADyX0WhU9erV9dBDD2nEiBFavXq1xo4da/ezl5qaqpdffllr1qwp/EJR5M2bN89qOzg4WN27d7dq27Ztm44ePVqYZQEAAAAAUGQQ3gYAAAAAoBAcOXJEo0aNsmmvUqWK5syZo5YtW+a571atWmn+/Pl66qmn8lMi4Fbe3t4aMWKEatasafPasmXL3FARAE9VoUIFffLJJzIYDFbtR48e1aFDh9xUVeHgegMoWnx9fXX//fdr/vz56tmzp83rGRkZeu2113Tq1Ck3VIei6tKlS1q7dq1V21133aVu3brZ7Dt//vzCKgsAAAAAgCKF8DYAAAAAAIVg6NChSk1NtWoLDw/Xd999Z3d1UGf5+vrqzTff1Pjx4+Xj45Pv/gB3MBqNeuyxx2za9+3b54ZqAHiyBg0aqH79+jbte/fudUM1hYfrDaBo8vX11ZAhQzR06FCb1+Lj4zVy5Eg3VIWiauHChcrIyLBqe+CBB1SzZk3VqVPHqn3RokU2+wIAAAAAgNx5u7sAAAAAAACKurVr12rr1q027cOGDVOpUqVcOlbnzp1d2l9RYzKZtGfPHp05c0bR0dGKi4tTcHCwIiMjValSJdWpU8dmpVZXSU5O1s6dO3Xp0iVFR0crOTlZ4eHhioyMVK1atVShQgWXj2kymbRjxw6dPn1aFy5ckPRfiK969eqqV6+evL2vv/81ZC9seenSpTz3ZzKZdOrUKR09elTnz59XQkKCzGazQkNDFRYWpqpVq6pGjRry8irYNQ6OHz+uI0eOKCYmRjExMbJYLAoKClLJkiVVtWpVVa5cWUajsUBrgGtdvnxZO3fu1OnTp5WYmKiAgACVLVtWjRs3VokSJRzu59SpU9q9e7fOnz+vlJQURUREqGzZsmrevLn8/PwKpPajR4/q2LFjio6OVkxMjHx9fRUREaEyZcqoYcOGBTZuYatfv7527dpl1Zaf88n1zhOvN+Li4vTvv//q5MmTio+Pl9lsVlhYmNq1a6dy5co51Ic75vbz58/r6NGjOn36tBISEpSSkqLg4GCFhYWpbNmyql+/fpH5HOXkzJkz2rdvn9W5JDIyUiVLllSjRo3k7+9f4DWkp6dr165dmXOst7e3IiMjVblyZTVo0KDIza09evTQ7t27tWDBAqv2devWaePGjWrVqlWe+i1q72mLxaIDBw7o1KlTio6OVmxsrAICAhQZGaly5cqpfv361+V18PUi62ra5cuXV7NmzST9F+K+9kaoixcvas2aNbrjjjtcWkNMTIx27typ8+fPKzo6Wv7+/ipTpozq1q1bIL835eTa80xsbKwkqVixYqpbt65q1arlcD8JCQn6999/dfToUcXHxysgIEAlSpRQkyZNVLp06QKqPn9SUlK0Y8cOHT16VHFxcfL391dERIRq1KihWrVqFdjvzgAAAABwI+D/TAAAAAAAUMCmT59u09ayZUvdc889hV/MDeqvv/7SnDlztHHjRsXFxWW7X3h4uNq3b6++ffuqWrVq+R43IyNDCxcu1OLFi/XPP/8oPT09230rVqyou+++W0899ZTCw8PzNW50dLS++uor/fbbb4qOjra7T1hYmB588EE999xzioyMzNd4rhQcHGzTZjabnerj2LFj+uOPP7Rp0yZt27ZNSUlJOe4fEhKi1q1b6+mnn1bDhg2dGisn+/fv1/fff6+//vpLZ8+ezXHf0NBQtWzZUnfffbfuuOMO+fr6uqwOe7Zu3aoXXnghM4ByVe/evTV48OACD7MXhgULFuitt96yalu5cmWuqw8PHjxYCxcuzNwuV66cVq1albn9559/atKkSdqyZYvd96bRaNStt96q1157LdvziNls1i+//KJp06Zp//79dvcJDAzUfffdp5dfflkRERE51uyIY8eOafr06Vq/fr2ioqKy3c/Pz08333yznnzySbVp0ybf47qTs+eTHj16WIWfAwMDtX79erv9OGrFihV64YUXrNrefvtt9e7dO899Zud6ut7I7XO0du1aTZ8+XZs2bZLJZLI5fvTo0eratWuOYxTm3B4dHa0VK1bor7/+0pYtW3K9CcDHx0eNGjVSjx491KlTJ4fPqbfddlu2n8+oqCjVrFkz1z6+//57tWjRwqa9V69e2rx5c+Z28+bNNWPGDIfqulZcXJy+/fZb/fHHHzp8+HC2+109lzz22GO68847nR4nt3P4xYsXNXnyZC1cuFDx8fF2+wgNDdWDDz6o559/3iXn0evFsGHDtHbtWl2+fNmq/bvvvnM4vF0U3tP2/Pvvv5oxY4b+/PPPHL+moKAg3XLLLXr22WfVoEEDh/q+UWzdulXHjh2zarv//vszQ7r33Xefxo0bZ/V7zbx581wW3t68ebMmT56sjRs3Zruid40aNfTUU0/pgQceyFd4eNOmTXriiSes2q59v50/f14TJ07UokWLlJiYaLePypUr6/nnn9cDDzyQ7Tj79+/X119/rVWrViktLc3uPo0bN9brr7+upk2buvRryM4XX3yhCRMmWLUdOHAg8+8nT57U119/rSVLlig5OdluH8WLF9fjjz+up556SoGBgU7VDQAAAAAgvA0AAAAAQIE6e/asNm7caNPeo0cPN1Rz4zlw4IA++OAD/f333w7tHxsbq59//lm//vqrHn74Yb377rt5DtGuWLFCY8eO1YkTJxza/+TJk5o0aZJmzpypV155Jc/vkd9++00jR460CeVmdeXKFU2fPl0///yzxo0bp3bt2uVpPFeLiYmxaXM0XB4TE6OnnnrKajVAR8THx2vZsmVatmyZbr/9do0ZM0ahoaFO9XGtU6dOacyYMVq5cqUsFotDx8TFxWn58uVavny5atSooV9//TXP4+dm8eLFeuutt6zCI15eXnr77bfVq1evAhvX06WlpWnEiBGaN29ejvuZTCatWrVKGzZs0OjRo21WKD5//rxeffVVbdmyJcd+kpKSNHfuXP3xxx+aNm2aUys7XismJkYfffSRFi5caDckm1Vqaqo2bNigDRs2qHnz5ho3btx1uxpkbpw9n2QNbyclJenXX3/V448/nucaZs+ebbUdEBCgBx98MM/9ZcdTrjcSExP11ltvadmyZXnuo7Dn9ldffVVLly7NNkRoT3p6urZs2aItW7aoWrVq+uyzz1S9enWHj79ezZgxQ1988YWuXLmS677XnksaN26sESNGOBTUdcSyZcv07rvv5hjal/6bW7/77jstWrRIkyZNUqNGjVwyvrv5+/ure/fu+uKLL6za161bp9jY2FxvAiyK7+moqCiNGTNGy5cvd2j/xMTEzOuujh076v3338/XtV9RknXVbUlWweTIyEi1bdvW6oac9evX6+LFi049eSSrlJQUjRo1SvPnz8/1+vngwYMaPHiwFixYoM8++6xAbkRdvny53n777WxvDrnq+PHjevPNN7V69WqNGzfOan6xWCz68ssv9dVXX+V6DbZ9+3b16NFDL730kvr16+eSryGvZs6cqQ8//FCpqak57nfp0iV98cUXWrBggb799ltVrly5cAoEAAAAgCLC85fQAQAAAADgOrZq1Sqbf3wuUaKEbrvtNjdVdONYtWqVHnvsMYfDXdcymUyaO3euevXqZbOqYW4sFos+//xzvfDCCw4Ht6+VkJCgkSNHaujQoQ4FLa81d+5cvfrqq7kGt68VGxur559/XqtXr3ay0oJxbXDyKkdDq4mJiU4Ht7NauXKlHnnkEZ07dy5Px//99996+OGHtWLFCoeD21llt7KfK0ycOFGvvfaaVXA7ICBAEyZMILidg4yMDL344ou5BrevlZaWpjfeeENr167NbDtz5oy6d++ea3D7WtHR0erdu7dOnz7tVM3Sf6ttd+vWTfPmzXP6fCL9t/rlww8/rF27djl97PXA3vmkdu3a2e5/55132gTPsoavnXHixAn9+eefVm333HNPgQQEPeF6IykpSX369MlXcNsdc/v27dudCrlmdeTIET366KP666+/8tyHu5lMJg0dOlTvvfeeQ8HtrLZv367u3bvbvcHAWbNnz9agQYNyDW5fKzY2Vk8++aT27duX7/GvF927d5e3t/X6TCaTSevXr8/12KL2nt6xY4ceeeQRh4PbWS1fvlyPPvponq7bi5qEhAQtXbrUqq1x48aqWLGiVVvWm5CuPm0or1JSUtSvXz/NmzfPqevnzZs3q2fPnnk6L+Vk0aJFGjhwYK7B7WstXbrU6mkBFotF7777rr744guHr8EsFos++eQT/fDDD07X7Coff/yxRo4cmWtw+1pRUVHq3r27zp8/X4CVAQAAAEDRw8rbAAAAAAAUoE2bNtm0NWvWzCZsAdf69ddf9cYbb8hsNlu1+/j4qGXLlmrYsKFKly6tkJAQJSUlKSoqShs3btQ///xjtf+OHTv04osv6vvvv5ePj49DYw8bNkxz5861aQ8PD1fr1q1Vt25dFStWTP7+/oqPj9ehQ4e0fv16m8eTz507VyEhIXr99dcdGnfZsmUaNmyYTeDBaDSqRYsWat26tUqVKqWMjAydPXtWa9asyQxkZmRk6JVXXtFTTz3l0FgFJTEx0W5Y4c4778xTf4GBgapfv76qVaumSpUqKSQkREFBQUpPT1dcXJwOHz6sTZs26ciRI1bHHT9+XC+99JJ++OEHpz6ra9as0QsvvGA3EBUREaHWrVurXr16ioyMlK+vr+Lj43XmzBnt3r1b27dvL9DQdkZGhoYPH66ffvrJqr148eL6+uuv1aBBgwIbuygYO3asVQi7WrVqat++vSpXrqzg4GDFxsbqn3/+0fLly62C8SaTSe+8846WLl0qo9Gofv36ZYawDQaDmjZtqtatW6tMmTLy9/fX+fPntW7dOptAXGxsrEaOHKnJkyc7XPPhw4fVvXt3u4GmBg0aqEmTJqpSpYpCQ0OVnp6uixcvavv27Vq3bp3V13Dx4kX17dtXCxcuVJkyZRwe391WrFiho0ePWrWVL18+x/C2j4+PHnvsMavVbA8cOKBt27apSZMmTtcwZ84cm3NyflbxzoknXG8MGTLE6kaAkiVLqn379qpRo4aKFSumhIQERUVFWa3mei13zu1XGY1G1alTR9WrV1eVKlUUERGhoKAgSf+FHo8fP66dO3dq27ZtVnUmJSXp5Zdf1s8//5zj56hatWoKCQmR9N9q6td+fn18fFStWrVcawwMDHTqa3LEkCFD7K7G6+fnp7Zt26pZs2YqUaKEUlJSFBUVpZUrV+rAgQNW+yYkJOjZZ5/Vd999p6ZNm+apjnXr1mnUqFGZn6uQkBDdcsstaty4sYoVKyaz2ayoqCitWbNGO3futDo2KSlJb731lubNm3ddfS7yKjIyUjVr1tSePXus2rdv36777rvP4X48/T29adMmPfvsszZBUy8vLzVr1kyNGzdW+fLlFRISotTUVJ07d05btmzRxo0brQK1x44dU9++fTV//nwFBwfnWlNR9fvvvyspKcmqzd7TItq3b6/w8HCrG0bnz5+vvn375mncl19+2e7NHeHh4brzzjtVq1YtRUZGKjY2VocPH9by5ct18eJFSf/dTPDmm2/maVx7du/erU8++STzPBMaGqp27dqpUaNGKlasmFJSUnTkyBEtWbJEUVFRVscuXrxYd9xxh+6++25NnDjR6qa/cuXKqX379qpevbrCw8MVHx+vXbt2acmSJUpISLDq56OPPlL79u1Vvnx5l31djpgzZ44mTZqUuR0ZGal27dqpfv36ioyMVGpqqk6cOKEVK1bo0KFDVsdevnxZQ4cOtToeAAAAAJAzz/8/VAAAAAAAXMfsrQJMSLJgHTp0SEOGDLEKmHh7e6t379565plnsn2s9oABA7Rv3z698847VkGYbdu26eOPP3YoFDB//nyb4HZ4eLheeeUVPfDAA/Lz87N7nMVi0YoVKzRs2DCr1UCnTp2qZs2aqUOHDjmOGx0dbTe43aBBA40ePVo33XSTzTEvvPCCtmzZorffflsnT55UUlKSpk6dmuvXWFCio6P10ksv2azY1rRpU7Vo0cLhfkJDQ9WlSxd16tRJjRs3diiYt23bNr3//vvavXt3Ztv27dv13Xff6emnn3Zo3BMnTuj111+3CW4XL15cL774oh555JEcw2JpaWlav3695s6dq8OHDzs0pqMSEhI0aNAgbdiwwaq9atWqmjx5sipUqODS8YqaCxcu6Pvvv5f0Xwh/2LBhuvvuu2326969u06ePKm+ffta3Yxx8eJFzZw5UxcvXswMM9atW1cjR45UvXr1bPp58skntW7dOg0cOFDJycmZ7WvXrtX27dvVuHHjXGtOSkrSoEGDbILbHTp00Ouvv55jWO7ixYsaO3asfvnll8y2mJgYDRw4UHPnzpWX1/X/MMeNGzfaPWf369dPBoMhx2O7deumiRMnKj09PbNtzpw5Toe309LSbFYhrVevnurXr+9UP4663q83zp07p8WLF0uS/P399corr6h79+52z9Evv/yyTRDTnXO7j4+POnbsqC5duqhly5aZQdScREVF6eOPP878mqX/bsIYPnx4jsG2KVOmZP598ODBVu+hkiVLatGiRbmO7Wq///673eD27bffrmHDhqlUqVI2rw0aNEirV6/WsGHDrOb19PR0vf7661q0aJFD38esxowZI7PZLIPBoCeffFLPP/+83ZXs+/fvr99//12DBw+2ei/t27dPy5Yt07333uv02Nejxo0b24S3HXkCSVF5T1+8eFGvvPKKzfmia9euGjBggMqWLWv3uH79+unkyZMaMWKE1bXR8ePH9fbbb+vzzz/Pc02eLusTRvz8/Oxe8/j6+uqee+7RrFmzMtuOHz+urVu3qlmzZk6NuWDBApubdq5+xgcNGiR/f3+bY95++21NnjxZX331ldLT07V69Wq7++XFp59+mnkN0KtXLw0cONDueWbQoEEaM2aMZs6cadX+2WefqVy5cpnvo4CAAL355pt69NFHZTQarfZ99NFHNWjQIA0YMEDbt2/PbE9OTtbkyZM1cuRIl3xNjvrggw8k/XeOGDhwoHr37m3399dBgwZpxowZGj16tNW8vGbNGu3YsUONGjUqrJIBAAAAwKNd//+nHQAAAAAAD5WWlpa5wuq17IX14Bpms1mvvPKKVeAxMDBQ33zzjd54441sw11X1a5dW3PmzNEtt9xi1T5jxgydO3cux2NPnz6tUaNGWbVVrlxZixYtUrdu3bINbkv/BRTuvPNOzZ8/X6VLl7Z6bfz48bk+PnzcuHGKiYmxamvWrJlmzJhhN7h91c0336zZs2ercuXKkv57ZHlhSUlJ0blz57R+/Xq9//776tSpk83KsaVKldKHH37ocJ8lS5bU+vXrNWTIEDVv3tzhFVWbNGmiWbNmqW3btlbtM2bMsLuKtj2vv/664uLirNqqV6+uefPm6fHHH891lU9fX1/dfvvtmjx5cmZQ2BXOnTun7t272wS3mzdvrjlz5hDcdkB6erosFotKlCihWbNm2Q0xXVWxYkVNmTLF5vP+7bffZoZ7mjdvrh9++CHHuaBdu3Z2AzsLFixwqOaxY8fa3ATw2muvaeLEibmuclqiRAmNGzdOL774olX7rl27tHTpUofGL0xms1kJCQk6dOiQfv75Zz333HPq06ePzSqWnTt31sMPP5xrfyVKlFDHjh2t2pYuXWpzjs3NkiVLbI4pqFW3PeF64+oKt4GBgZo6dap69+6d4zn62s+QO+d26b8w4xdffKE777zT4cBxuXLlNH78eA0YMMCqfe3atTYrwl/PEhMTNXz4cJv2Rx99VF9++aXd4PZVHTp00MyZM232iYqK0qeffpqnelJTU2UwGDRmzBi9+eabdgOVV91zzz16//33bdqzPoHCk9m7GeTUqVO5HldU3tNvv/22Ll26lLltNBr10UcfafTo0dkGt6+qWLGipk6dqq5du1q1L1u2zOoJATeSQ4cO2axYf9ttt2X7ObO3Ire9Gz1yEh8frzFjxti0v/vuu3rzzTezDWR7e3urf//++uijjzID0a76Pebq00feeecdvfvuu9l+/b6+vho6dKjatGlj1X7s2DH169dPZrNZgYGB+u677/T444/bBLevKlGihCZNmmQzl/3222+F+ruZ9N851tfXV1OmTFHfvn2z/f3VYDDoiSee0KBBg2xeK0rnWAAAAAAoaIS3AQAAAAAoIOfPn7cbui1evLgbqrk+9e3bV/fff7/Tfz777DO7/S1btkwHDx60avvggw/UsmVLh2vy9fXVZ599poiIiMy29PR0TZs2LcfjvvnmG5tg2dSpU23C2DkpU6aMPv74Y6u2Q4cO2axGd63o6GirVRCl/1b7/uKLLxxaga548eKaMGFCruFiZ7311luqWbNmtn8aNmyoW2+9Vc8884y+//57m+Bzu3btnA4X+/r65nnVPT8/P3344YcKCAjIbDt79qz+/PPPXI/dsGGDTdglIiJC3377rcqUKeN0La56RPr+/fv16KOPZq72fFXnzp31zTffKCwszCXj3CjGjBmjqlWr5rpfhQoV9NBDD1m1xcbGymw2KyIiQp988okCAwNz7adLly42Qet169bletz58+dtVs7s3r27nn322VyPvdaAAQNswq7XrqBamHI6l9SuXVtNmzZV586d9eabb2rNmjVWxwYEBOill17S2LFjc111+6ru3btbbaempjocnL9q9uzZVtuhoaEFttqvJ11vvPrqq7r55pudOsadc7ukPK0QfdULL7xgFbC1WCw2n8/r2cKFC21W8K9fv75GjBjh0OepQoUK+uyzz2z2XbBggU2/jurTp48eeOABh/a97777bFag37Jli81KzZ7K3o0Lly9ftnpygD1F4T29a9cumznxlVde0X333edwHwaDQSNHjrSZaydPnuySGj2NvZ9jTp+1Bg0a2FwXLV261ObmqZz8/PPPNueC+++/Xz179nTo+LvuukvPPPOMw+M5qnPnznriiScc2tdegPnqk5TeeecdNWzYMNc+wsLC9OSTT1q1JSQkWK3GXVjeeOMNtWrVyqF9n376aZsbdLLeMAoAAAAAyB7hbQAAAAAACkjWMOpVOa0SeKM5cuSI9u/f7/Sfs2fP2u0va7CwefPmOa6Sm52QkBCbf7D/448/st0/OjraJtj39NNP52lV46ZNm9r8g/mKFSuy3X/BggWZK8Rd9cILL+S6Eum1qlevXmArwjrD19dXPXr00C+//KIpU6bkumqiqxUrVsxm9e1//vkn1+PsBVqHDBmikiVLuqw2Z61bt07du3fX+fPnrdr79eunjz76SL6+vm6qzDO1bt3aZmXFnGRdufmqPn36OBWozdrPuXPnFB0dneMx06dPtwruBQcH69VXX3V4zGv179/fanvv3r2KiorKU1+FrVy5cho6dKjWrVun559/PtsVL+1p1qyZateubdU2d+7cXJ+CcNX+/fttAlf333+/1c0hruQp1xsVK1ZUjx49nD7OXXO7KxgMBt1///1Wbdu2bSvQMV3phx9+sGkbOnSovLwc/6elxo0b26zQm5SU5PQNEdJ/57OsTwXITZcuXay2MzIybG5q8lT2PuMWi0WJiYkFNub18p6eOnWq1XalSpVswq+O8PHx0XPPPWfVtm7dOptr66IuLS1NixYtsmorXrx4rtc+9j7bv//+u8Pjzpkzx2rbz89Pb7zxhsPHS9Lzzz+vEiVKOHVMToxGo1PXTQ0aNLD7O0uVKlVsbubLyV133WXTtmfPHoePd4UKFSo4NU/7+PjonnvusWo7d+5cZngdAAAAAJAzwtsAAAAAABSQ7B5znJ/V7pC906dP2/wD9yOPPJLn/tq3b2+1HRUVlW1occ2aNTY/b1eOvWnTpmz3zbrqoK+vr8MrUl6rW7duTh/jamlpaZo1a5aGDh2qJUuWOByUdKVKlSpZbe/YsSPH/RMSErRlyxartnLlytkNYBSWuXPn6vnnn7cKb3l7e+u9997Tyy+/7PDqw/ifhx9+2Kn969SpY7fdmRBPdv0cPXo0x2OWLVtmtX333XcrODjYqXGvatKkiU04cPPmzXnqq7BFRUVp3LhxGj16tI4cOeL08VnDSydOnNBff/3l0LFZw2iSCvQGGU+53ujatavT5x93zu2uknVe2bNnT64rI18Pzp49q2PHjlm11atXz2Yla0fYe/878mSLrPJyPrNXb27nUU+R3Q0aBb2yuLvf06mpqVq9erVV24MPPujUTTrXuvXWW236z+36r6hZtWqVYmJirNo6d+6c65N5unTpYnMzh6MrsZ85c0aHDx+2arvtttucfmpEQECAUyuu56ZVq1ZO30Baq1YtmzZn57yKFSvanN+ynoML2kMPPeTUzTmS/XNsYdcNAAAAAJ7Ktc/DBQAAAAAAmbILnhKcLBhZA7TSf8HDvCpfvrxN2759+1SuXLlcxy5XrpzNI6TzM3ZUVJTi4uJsQjpms1n//vuvVVuLFi3ytNpq9erVVblyZR0/ftzpY+0pU6aMwsLCsn3dbDYrISFBly9ftgoZWSwW7dixQy+99JJatWqlsWPH5msF6/Pnz2vbtm06cOCAjh8/rvj4eCUmJiolJcXuZ/TSpUtW29mt8n7V1q1bZTKZrNruu+++PAeI8sNisWj8+PE2q9QGBQXps88+s1lVHI5r1qyZU/uHhYUpKCjIKkBfuXJlp1eGtHe+iY+Pz3Z/e0HU/JwHvby8VLZsWauVnffu3Wuz0mZBsxeKulZKSooSExN16dIlq891cnKyFixYoF9//VUvvviinnvuOYfn4Pvuu0/jxo3TlStXMttmz56tW265JcfjEhMT9csvv1i1NW/eXNWqVXNo3LzwlOuNFi1aOH2MO+f27CQmJmrr1q06cOCADh8+rNjYWCUkJCg5OVlms9lm/6SkJKvttLQ0Xb58WaVLl3b+CyhE9lZT7tSpU576atCggcqXL6/Tp09ntu3YsUMWi8Wp9+nNN9/s9Nj2noKSkJDgdD/XI1fd5OZp7+mdO3farIydn/NCeHi4QkJCrObXvXv3qnnz5nnu09PYC1w7cjNo6dKl1bJlS6ubm3bu3KlDhw6pevXqOR5rLyCf3ZNLctOxY0d9++23eTo2q7ycZ+zNIc5eO0pS2bJldfDgwcztnK75CoKrzrGFXTcAAAAAeCrC2wAAAAAAFBB/f3+77XFxcU6vKFZUrVy50m6QKi/shYxeeOEFl/R9VdYV6bIbOyYmxuaR8s7IGoq52mfWUPaxY8ds9q1bt26ex61Xr57LwtsDBw5U165dc93PZDLpyJEjWr58uWbPnm0Vnt64caN69uypGTNmOB2GX7p0qWbNmqUtW7bYDR456trQqj3bt2+3actPgCiv0tLS9Oabb9o8qr5UqVKaPHlyruFXZM/f3z9PN2NkDW9XrFgxT31klVMgxt558Ouvv9Z3333n9NhXnTx50mo7u/NgQVq0aJFD+yUkJGjHjh1auHChfv/998zPfnp6uj755BOdO3dOw4cPd6gvf39/PfTQQ1ZhsNWrV+v8+fM5vh9++eUXq5+7VLCrbkuecb1hMBhUu3Ztp49z59ye1e7du/XNN99o1apV2a527qi4uLjrPryddcVzSapfv36e+6tXr55VeDs+Pl4nT560WcU5J5UrV3Z6XHsr0BeVYGF21yjZnROy8tT3tL3zwogRI+Tj45PnPrN+/e6Y69zl7NmzNivh16hRw+Fz9gMPPGDzZIr58+dr8ODBOR5n7xyT199jateuLaPRaHNDZV646nrNmXNbdv0U9rmKcywAAAAAFC7C2wAAAAAAFJDsVh2+nsJURcm5c+ds2vbv3+/SMbILcmQdOykpyeVjx8bG2oQALl++bLNflSpV8jxGfo7NK6PRqBo1aqhGjRrq2bOnXnnlFasAyYkTJ/Tqq6/q+++/d+gx3ufPn9cbb7yhv//+2yX15bY6p72fQY0aNVwytjP69Omjf/75x6qtZs2amjx58nUfELze5WUle0k2IbK89OPtbfu/bzMyMrLd3955MGv4Or9iY2Nd2p8rBQcHq02bNmrTpo0ef/xx9evXzypANHv2bNWtW1ePPPKIQ/11795d06dPzwyBZ2Rk6Mcff9SAAQOyPWbOnDlW28WLF9edd96Zh6/GcZ5wvREYGKiAgACnj3Pn3H5Venq6Ro8erdmzZ+frZqBreUKwzd73pWrVqnnu76abbrI7hjMBx5ye6JEde4HenM6jnsReeNvLy0uBgYE5Hufp72l754UjR464dIyCmOtWrlypzz//3Klj6tWrp/fff9/ltVxrwYIFNu8DZ56w0bFjR40YMcLqxqVFixbp1VdfzTFQHx0dbbXt7e2dp+C09N8NC2XKlLG6QSSv8nKesXe9lpfrvqzfr8I+V7nqay8q51gAAAAAKGi5/4sXAAAAAADIk1KlStl9FLy9sCfyrzAChampqTZtKSkp+V6t0BH2xrAX2rG3+pmj8nOsK4SHh2vChAk2j9/esmWLfvnll1yPP3/+vHr16uWy4LaUe/jgypUrNm15DfvmR9bgdtmyZTVr1iyC2y6Qn5U8C6KfnLjrPHg9atasmcaPH2/T/uGHH+Z6U8ZVFSpUUNu2ba3afvrpp2xX9ty+fbtNsPjhhx8u8J+9J1xvBAcH5+k4d7+n09PTNWjQIM2cOdNlIVfJM4Jt9q4x8jO/2TvW3hyaE3shwRvZtU8ruapYsWI5nnOKwnva3eeFvLpy5Yr279/v1B9X34CVlcVi0YIFC6zajEaj7rvvPof7CAgIUKdOnazaoqOjtWrVqhyPy3qOCQoKsjuXOcpVv8e46jxTGNd9ruaJNQMAAACAJ+P/dAEAAAAAUEB8fX1Vrlw5mxXAdu/erZtvvtlNVRVd2T06vqA5GzxypWtXuLsqt9UWc5KfY10lMDBQzz33nN59912r9u+//14PPPBAjscOHjxYJ06csGmvXbu22rVrpwYNGqhs2bIqWbKk/P395efnZxNS+OKLLzRhwgSH67UXAnXH99Hb29sqOHXmzBlNmDAh10fWo2hx13nwenXrrbeqSZMm2rZtW2ZbfHy8fv75Z/Xs2dOhPnr06KG1a9dmbp8/f16rVq2yu5r27Nmzrba9vLzUrVu3PFbvOE+43shrGM7d7+kpU6Zo5cqVNu2lSpXS7bffrsaNG6tixYoqXbq0goKC5OfnJ19fX6t9N23apCeeeKKwSnaZrNcYBoMhT6unX2VvbrR3HQPH7dq1y6Yt6w1wWRWF97S7zwtFyd9//20zd7Ru3VolSpRwqp8HH3zQJgQ+b948m1D3tbJ+/vNzfnHF8QAAAAAAFDbC2wAAAAAAFKC6deva/IO4vaAF8s/Pz8+mbdeuXXbbXcnf39+mrWHDhvrxxx8LdFzpvxXqskpKSspzf/k51pVuvfVWm7a9e/cqOjpakZGRdo9Zs2aN/vrrL6u2YsWKaezYsWrTpo3DYzu7irq91WSTkpLs/mwK0ueff66XXnpJaWlpmW3Tpk1TUlKShg8fLi8vHsB3I7B3vpsyZYratWvnhmquDx06dLAKb0vShg0bHA5vt2vXTpUqVbK6MWT27Nk24e2YmBgtXbrUqu3WW29V2bJl81i5c4rq9Ya75nbpv5XLJ0+ebNXm7e2t119/XT179nQ4kF4YT+coCFnnMYvFouTk5DwHJO1dYxT2XFnU7Nixw6atbt262e5fVN7T9j7/v//+u6pVq+aGajzbvHnzbNrWr1+vmjVr5rvvP//8U+fPn1epUqXsvp7185+cnJyv8fJ7PAAAAAAAhY1/tQEAAAAAoAC1aNHCpm3Lli0ymUxuqKZoi4iIsGkrjMeqh4aG2oRdCms17tDQUJu2+Pj4PPeXn2NdqWTJkjYrdFosFh04cCDbYxYvXmy1bTQaNXHiRKeC25LzP7vw8HCbNnesCHn77bdr0qRJNqG6uXPn6o033rBalRtFl73zoDufDnA9qFSpkk3b/v37HT7eYDCoe/fuVm1//fWXzSr/CxYsUGpqqlXb448/7kSl+VNUrzfcNbdL0qpVq2zCgK+99pr69Onj1ErinvoZtHeNkZ/5zd41RlhYWJ77u9FdunRJhw4dsmlv0qRJtscUlfe0p851Xbt21YEDB5z6M2PGjAKr58qVK/rjjz8KrH+TyWSzGve1sp5jEhMTZbFY8jze9fJ7DAAAAAAAjiK8DQAAAABAAerQoYMMBoNV28WLF7Vq1So3VVR0FS9e3KbtzJkzBT6uwWCwCZGcP3++UMKyxYoVs2k7duxYnvvLz7GuZm9F65iYmGz3z7rqdtu2bdWgQQOnxz116pRT+9t73+UUMi9IrVu31jfffKOQkBCr9l9//VWDBg2yWpUbRZO7zoPXM2fPJfZ07drV6sYIi8WiOXPmWG3PnTvX6phy5cqpbdu2Tlabd0X1esOd7+k///zTajssLMzhFduv5ey8cr2w96SLo0eP5rm/w4cP27TZC+HCMT/88IPNzRk+Pj45nneKynuauc41fv31V5ubjlxt/vz52Qays55jMjIydPLkyTyNk5KSorNnz+bpWAAAAAAA3IXwNgAAAAAABahs2bJq1aqVTfusWbPcUE3RZi+ou2XLlkIZu2HDhlbbycnJ2rNnT4GPW6VKFZsVqvMz7u7du/NbksskJCTYtBmNRrv7pqWl6fLly1ZtTZs2dXpMk8mkXbt2OXVMo0aNbNq2bdvm9Niu0rRpU3333Xc2gbgVK1bo+eef55HyRVzWc5FUeOfB65W9lTi9vJz73+KhoaG67777rNoWLFiQeUOEvZW4H3vsMafHyY+ier3hzrn93LlzNrX4+Pg43c+OHTtcVFHhqlu3rk3bv//+m+f+sh4bGhqqihUr5rm/G1lycrLVDSRXdejQweYGrmsVlfe0O88LRcm8efNs2mrVqpWvPyVKlLDq79SpU9q0aZPd8e2dY/L6e8y+ffs8/kkTAAAAAIAbD+FtAAAAAAAKWO/evW3a/vrrLy1btswN1RRdt9xyi01bQT4K/FqtW7e2aVu+fHmBj+vl5aX69etbtW3evFlxcXFO93Xo0CEdP37cRZXlz7lz55SUlGTTbm+lRcn+Krrh4eFOj7t27Vq74+akadOm8vb2tmpbvHixWwMkdevW1Q8//GAToNmwYYOeeeYZu8F4FA01a9a0WZF/69atTq80XZTYWyk462fDET169LDajo2N1e+//y5Jmj17ttVrPj4+euihh5weI7+K4vWGO+f2rJ+bsLAwp/uIjo7ONriYm6w3LBX2vNK4cWObtry+l3bv3q3Tp09btTVs2NBmtXg4ZtiwYXbP6/bOAdcqKu/pli1b2lx7rVmzRunp6Xnq70a0Z88e7du3z6qtYcOGWrRoUb7+vP/++zZj2QuJS/ZvgMzr+b0wfu8CAAAAAMDVCG8DAAAAAFDA2rdvb3cV4KFDh+rChQsuHWvx4sU6f/68S/v0FDfddJMqV65s1bZr1y5t3LixwMdu3769TSBlzpw5eQpRO6tdu3ZW26mpqVq0aJHT/fz444+uKinfVq9ebdPm5eWlKlWq2N0/6+rjkv1Ad26mTZvm9DHBwcFq2bKlVVtUVJSWLFnidF+udNNNN2nWrFkqV66cVfvWrVvVp08fxcbGuqcwFCiDwaDbbrvNqi05OVnff/+9mypyvzVr1ti0Va1a1el+atWqpWbNmlm1zZkzR+fPn7c5Z3Xq1MkmRF8YiuL1hjvn9oCAAKvtvJw3Z82apdTU1DyNHxQUZLXt7M1F+VWmTBlVq1bNqm337t15ekqHvRXg27Rpk+fabmTff/+93eu8Dh062Jyjsioq7+ng4GA1b97cqu3cuXN5uv69UdkLVHfp0iXf/d5yyy02898ff/xh9ykYZcuW1U033WTVtnLlSpun6eQmJSVFv/76q/PFAgAAAADgZoS3AQAAAAAoBCNHjpSfn59VW2xsrPr06aOzZ8/mu/+0tDR9+OGHevXVV2/oVef69etn0/buu+8WeFC1XLlyuv/++63aEhIS9NZbb8lisRTo2F27dpWvr69V24QJE5wKLx8+fNhm5Vh3SUhI0JQpU2zaGzVqpMjISLvHhISE2ASSNmzY4NS4P/30kzZv3uzUMVc9++yzNm3vvfeey8OSzqpYsaJmzZplE3r/999/1atXL126dMlNlaEg9e3b12ZF0ilTpmjnzp1uqsh9Vq5caffrvv322/PUX9bVt7dv3673339fGRkZVu2PP/54nvp3haJ4veGuuT3rCu3btm1zKmx66NAhTZo0Kc/jh4aGWm3HxcXpypUree4vL7K+5yVp1KhRTl3b7Nq1SwsXLrRqCwwMVNeuXfNd340kLS1NI0eOtLuycXh4uIYOHZprH0XpPf3888/btI0dO1anTp3KU383ktTUVC1evNiqzcfHR/fcc0+++/b29ta9995r1ZZTuPqxxx6zqW3cuHFOjfn111/r4sWLzhUKAAAAAMB1gPA2AAAAAACF4KabbtK7775r037kyBF169Ytz6FRSdq4caO6du2qb7/9Nj8lFgldunSxWVH19OnT6tu3b55XCL0aJs5tNb/+/fvbhKhXrFihIUOGKC0tLU9jnz59WqNGjdLBgwez3ScyMlKdO3e2aouNjdXAgQMdWhnx8uXLGjBgwHUR+o+JidELL7ygqKgom9e6deuW47FZV5vdvHmz1q5d69C469at03vvved4oVm0bNnSZrXLmJgYPf300zp37pzT/Z0+fTrPtWRVunRpzZw5UzVr1rRqP3jwoHr06OGSMCeuLxUrVrQJRaanp6t///7atm1bnvo0mUz67bff9Mknn7iixEKxadMmvfHGGzbt4eHh6tixY5767Nixo0qWLGnVtmzZMqvt6tWr57r6bUEqitcb7prbs/4ck5KSNGHCBIf6P336tJ5//vk8z/+SbM7bkhye11zlgQceUHh4uFXbjh07NGrUKIeOj4qK0sCBA2U2m63aH3roIZsgL+xLS0vTzz//rIceekgzZ860ed3Hx0fjx49X2bJlc+2rKL2nmzdvrltuucWq7cqVK3rmmWd05MiRPPWZmpqqOXPm5OlJLJ5k2bJlNk8HatOmTbY3STrL3gre9lb6lv47x2Q9FyxcuNDhm0r/+OMPTZ061fkiAQAAAAC4DhDeBgAAAACgkDz66KN2V488f/68evXqpb59+2rbtm02ARd7UlJS9Pvvv6t79+7q06ePDh06VBAlexyj0ajPPvvM5rHsO3fu1IMPPqiZM2c6FGjOyMjQX3/9pSFDhqh9+/b66KOPcl2luEKFCho5cqRN+08//aRHH31Uq1evdmilyoSEBP3666/q37+/OnbsqB9++CHXml9//XVFRERYtW3evFm9e/fOMcCydetWde/eXUePHpUk+fv751qfq5lMJh04cEATJkzQvffeq7///ttmn6ZNm9qsbJ7VXXfdZdP20ksvaenSpdkek5KSogkTJqh///5KSUmRJAUHBzv5Ffxn7NixNgG3gwcP6qGHHtLcuXNtVubNKi0tTatXr1a/fv3Uu3fvPNWQnWLFimnGjBlq2LChVfvx48fVo0cPnTx50qXjwf0GDx6sGjVqWLVdunRJTzzxhMaNG+fwCpX79+/XJ598ojvvvFOvvPKK9u/fXxDlukxCQoLWr1+vV155Rb1791ZCQoLNPq+99prCwsLy1L+3t3euN5JkXUXUHYra9Ya75vaOHTvKy8v6n1C++eYbffrppzme0xcvXqzHHnsscwXgvM4rDRs2tBn/ww8/1IoVKwrthqugoCANGzbMpn3mzJkaOHBgjt+/tWvXqnv37jY3CZUrV06DBg1yea1Fhdls1pEjR7RgwQINGzZM7du315tvvmn3Rr6AgAB9/vnnatOmjUN9F7X39OjRo21uqDl+/LgefvhhTZo0SfHx8bn2YbFYtG3bNn3wwQe67bbbNGzYsCK/ere9ILW9wHVe1a9f3+aGmz179ti9hggJCdFbb71l0z5ixAh99NFH2Z7bMzIyNGnSJL388suZ7113/B4DAAAAAEB+eOe+CwAAAAAAcJWXX35ZAQEB+vTTT22CvGvXrtXatWsVHh6uVq1a6aabblJERERmKDcuLk6nTp3Snj17tGPHDiUnJ7vjS7ju1ahRQx999JEGDBhgFUS5fPmyRo4cqU8//VQ333yzGjZsqMjISIWEhCg5OVlxcXE6e/as9uzZo71799oN/eXmwQcf1JEjRzRlyhSr9n379qlfv34qW7asWrRooVq1aik8PFz+/v6Kj49XfHy8jh8/rt27d+vgwYNOB1giIyM1YsQIDRo0yOp9tX37dnXp0kUtW7ZUq1atVKpUKZlMJp05c0Zr167Vzp07M/cPDAzUU0895fAKjLn5/PPP9d1332X7utlsVmJioi5dupRj6K5q1ar67LPPZDAYchzvgQce0OTJk62CyElJSRo0aJDq1q2rDh06qGLFivLx8dHly5e1Z88erV69WrGxsZn7V69eXe3bt7f5+TmiXLlyGjdunPr372/187t06ZKGDh2qTz/9VK1bt1a9evUUEREhPz8/xcfH6+zZs9q7d6/++eefzJBRuXLlnB4/N2FhYZo2bZr69etntfJuVFSUunfvrunTp+umm25y+bhwj6CgIH399dfq1q2bVbgyPT1dU6dO1XfffafGjRuradOmKl26tMLCwpSenq74+HhdvHhR+/fv1+7dux0OeRe03G7eSE1NVUJCgi5dupTjTTK9e/fWI488kq9aunXrpokTJ9o9TwcGBuqBBx7IV/+uUtSuN9wxt1epUkVdunTRzz//bNX+9ddfa+HCherUqZNq1qypwMBAXblyRceOHdOqVaus5qGAgAC99tprGj58uNNfc8mSJdW2bVurlYkvXbqkF154QT4+PipTpowCAgJs5sf33ntP9evXd3q87Nxzzz3asGGD5s+fb9W+bNkyrV27Vu3atVPTpk1VokQJpaam6vTp01q1apX27dtn05ePj4/GjRunkJAQl9XnSbK7NjKbzUpISFBcXJwSExMdutmvRo0aGj9+vM2NOjkpau/pUqVK6auvvtITTzyhpKSkzPakpCR9/PHHmjhxopo0aaLGjRurZMmSCg0NVUpKiuLj43XhwgXt3btXu3fvtroWLOpOnTpl8wSG4OBg3XbbbS4dp0uXLvr000+t2ubNm2f3yRBdu3bVH3/8oVWrVmW2WSwWTZkyRfPmzVPHjh1Vs2ZNRUREKC4uTocPH9ayZct04cKFzP07dOigxMTEfD1dAgAAAACAwkZ4GwAAAACAQtavXz/VrVtXb7/9ttU/Ol8VGxurJUuWON2vv7+/nnjiCZsV6G5Et912m6ZPn66XX37ZJnwYFxenlStXauXKlQUy9muvvaYyZcpo9OjRNuG+M2fOaOHChQUybqdOnTR8+HANHz7cKvSTkZGhDRs2aMOGDdke6+3trfHjx7s0vHL27Fmb1Taddcstt+jDDz9UiRIlct3Xx8dHn332mbp3724TNNyzZ4/27NmT4/GlSpXSxIkT8/Xzadeunb755hsNHDjQ5nsZHR2txYsXa/HixXnuP7+CgoI0depUDRgwwCo4dfHiRfXs2VPffPON6tat67b64Frly5fXvHnzNGjQIO3cudPqtfT0dG3evNljQk75XfHb19dXL7zwgt3VqJ1VokQJdezYUb/99pvNa507d87zirQFoahdb7hjbn/33Xe1a9euzCdUXHXu3Lkcb1CS/jcv5Wc12DfeeENbtmyxCqZK/32Gs3tqQtZ9XWHUqFEyGo368ccfrdpTUlK0fPlyLV++PNc+goODNWHCBDVt2tTl9XkKV1wblS5dWs8884wef/xxeXs7/098Re09Xb9+fc2dO1cDBgzQ8ePHbY7L7Rr4RjNv3jybmwM6duzo8lWr77vvPn322WdWY/36669644035Ovra7P/J598oueee87mCTwxMTGaO3dujmNVrVpVH374oV588UXXFA8AAAAAQCHxyn0XAAAAAADgam3bttXSpUvVr18/hYaG5quvwMBAdevWTcuWLdOrr75q9x/Eb0Q333yzFixYoC5dushoNOa5H4PBoBYtWqhZs2YOH9OjRw/NmjUr3wElf39/3XvvvSpbtqxD+z/22GP66KOPFB4e7vAYYWFh+uqrr1y+4l5+1K1bV+PHj9e3337rUHD7qjp16mjq1KlOHSNJjRo10o8//qjy5cs7W6qNFi1a6KefflL79u3z3EexYsXyXUd2/Pz89OWXX6pTp05W7TExMerdu7e2bdtWYGOj8JUpU0Y//PCD+vfvn++VbqtVq6a7777bRZUVDj8/P91zzz365ZdfXBLcvqpHjx522x9//HGXjeEqRe16o7Dn9pCQEE2fPl2NGjVyqv+SJUtq2rRpuvXWW/NcoyTddNNN+vbbb1WpUqV89ZNfRqNRo0aN0jvvvKOwsDCnj2/UqJFmzZqlVq1aFUB1RV9gYKA6deqkTz/9VCtWrFCvXr3yFNyWiuZ7ukaNGpo/f7569uwpPz+/fPVVv379fH+N1yuTyWT3JsUuXbq4fKzy5curSZMmVm2xsbFasWKF3f39/f01ceJEPfTQQ06N07RpU82cOTNP5yUAAAAAANyNlbcBAAAAAHCToKAgvfzyy3ruuee0dOlSLVu2TFu3blVCQkKuxxYrVkwNGzbUXXfdpY4dOyogIKAQKvY8JUuW1Lhx4zRw4EDNmDFDGzZs0JEjR3I9LigoSM2bN1erVq10xx13qFy5ck6P3aBBA82aNUtbt27VnDlztGnTJrsrn9qruVWrVmrdurVuv/12pwOXnTt3VuvWrfXll1/q999/V3R0tN39QkJC9MADD6hfv34qXry4U2O4gsFgUEBAgIKDgxUeHq4aNWqobt26atOmjWrUqJHnfps1a6ZffvlF33zzjX788UfFxcVlu2+9evXUq1cvdenSRV5erlvjoGLFipo0aZJ27typGTNm6M8//8z253BVsWLF1Lp1a3Xu3Fnt2rVzWS32+Pj46JNPPtG7776rBQsWZLbHx8fr6aef1pdffqnWrVsXaA0oPL6+vho0aJCeeuopzZ49W6tWrdK///6rjIyMHI/z8fFR/fr11bp1a7Vv317169cvpIqd5+3traCgIAUHB6t06dKqU6eO6tWrp9tuuy3fgWV7atWqJR8fH6unKzRs2FB16tRx+ViuUNSuNwp7bi9VqpR++OEH/fjjj5o2bZpOnTqV7b7lypXTww8/rCeeeMJlq7A3btxYS5Ys0YYNG7RmzRodOHBAp06dUkJCglJSUmQ2m10yjiOeeOIJ3X///Zo2bZqWLVtms3rztfz8/NSsWTM99thj6tixY6HV6Il8fHzk4+OjoKAgRUREqESJEqpYsaKqVauWeW7Ja1jbnqL4ng4ODtaQIUP0/PPP64cfftDatWu1f//+XPvy9/dX48aNM6+7q1Wrltcv67q3YcMGnT9/3qqtdOnSatGiRYGMd//99+uff/6xaps3b57uueceu/sHBATogw8+0AMPPKBJkybp77//zvZa5aabblKfPn300EMPufQaHgAAAACAwmSwZH0+FgAAAAAAcBuz2axjx47pxIkTOnv2rJKSkpSWlqagoCCFhYVlhlzzEibGfy5duqQ9e/YoJiZGsbGxSkpKUmBgoIKCglSqVClVrVpV5cqVk8FgcPnYx44d05EjRxQbG6vY2FhlZGRkBg7Lly+vqlWrunTV5YyMDO3YsUOnT5/ODI5HRETopptuUr169eTj4+Oysa5HJpNJu3fv1qFDhxQTEyOTyaSgoCCVL19e9erVc3qF7ryyWCzav3+/Tp48qejoaF25ckVGo1FBQUEqU6aMqlWrpgoVKhTIew6wJykpSf/++68uXryo2NhYxcXFyc/PT0FBQSpWrJiqVKmiSpUqFflzRF7NnTtXQ4cOtWobM2aMHnzwQTdV5Lyidr1RmHP70aNH9e+//yomJiZznFKlSqlmzZqqWrWqC74azxEVFaV9+/YpJiZGMTEx8vHxUWRkpEqWLKlGjRpdF2F/5K6ovqevXLmi3bt36/Lly4qNjVVCQoICAgIUFBSkEiVKqEqVKqpQoUK+VvFHwYmJidH27dt14cIFxcTEyM/PT6VLl1a9evVUsWJFd5cHAAAAAEC+Ed4GAAAAAAAAAMBBXbt21Z49ezK3w8LCtH79evn5+bmxKgAAAAAAAACAp+BZUgAAAAAAAAAAOGDbtm1WwW1JeuihhwhuAwAAAAAAAAAcRngbAAAAAAAAAAAHTJw40Wrby8tLPXr0cFM1AAAAAAAAAABPRHgbAAAAAAAAAIBcrFq1SmvXrrVqu/POO1W+fHk3VQQAAAAAAAAA8ETe7i4AAAAAAAAAAIDrVXp6uhYsWKAPP/zQqt1oNGrQoEFuqgoAAAAAAAAA4KkIbwMAAAAAAAAA8P9mz56tOXPmSJKSkpJ09uxZpaen2+z32GOPqVq1aoVdHgAAAAAAAADAwxHeBgAAAAAAAADg/126dEn79+/PcZ9q1arptddeK6SKAAAAAAAAAABFiZe7CwAAAAAAAAAAwFPUrVtX06ZNU2BgoLtLAQAAAAAAAAB4IFbeBgAAAAAAAAAgGz4+PoqIiFDdunV11113qXPnzvL25n+tAwAAAAAAAADyxmCxWCzuLgIAAAAAAAAAAAAAAAAAAAAAijovdxcAAAAAAAAAAAAAAAAAAAAAADcCwtsAAAAAAAAAAAAAAAAAAAAAUAgIbwMAAAAAAAAAAAAAAAAAAABAISC8DQAAAAAAAAAAAAAAAAAAAACFgPA2AAAAAAAAAAAAAAAAAAAAABQCwtsAAAAAAAAAAAAAAAAAAAAAUAgIbwMAAAAAAAAAAAAAAAAAAABAIfB2dwGAPXFxKTKZzO4uAwUsNNRfRqOXTCaz4uJS3F0OAABwAvM4AACejbkcAADPxlwOAIBnYy4HAMCzMZffWIxGL4WG+ru0T8LbuC6ZTGZlZJjcXQYKET9vAAA8F/M4AACejbkcAADPxlwOAIBnYy4HAMCzMZcjL7zcXQAAAAAAAAAAAAAAAAAAAAAA3AgMFovF4u4igKxiYpK4IwUAAAAAAAAAAAAAAAAAAABu4+1tVEREoEv7ZOVtAAAAAAAAAAAAAAAAAAAAACgEhLcBAAAAAAAAAAAAAAAAAAAAoBAQ3gYAAAAAAAAAAAAAAAAAAACAQuDt7gIA3LgCA31lMBhksViUlJTm7nIAAIATmMcBAPBszOUAAHg25nIAADwbczkAAJ6NuRz5RXgbgNv4+/vIaPSSyWRmEgMAwMMwjwMA4NmYywEA8GzM5QAAeDbmcgAAPBtzOfLLy90FAAAAAAAAAAAAAAAAAAAAAMCNgPA2AAAAAAAAAAAAAAAAAAAAABQCwtsAAAAAAAAAAAAAAAAAAAAAUAgIbwMAAAAAAAAAAAAAAAAAAABAISC8DQAAAAAAAAAAAAAAAAAAAACFgPA2AAAAAAAAAAAAAAAAAAAAABQCwtsAAAAAAAAAAAAAAAAAAAAAUAgIbwMAAAAAAAAAAAAAAAAAAABAIfB2dwEAblzp6SaZTGaZzRZ3lwIAAJzEPA4AgGdjLgcAwLMxlwMA4NmYywEA8GzM5cgvg8Vi4d2D605MTJIyMkzuLgMAAAAAAAAAAAAAAAAAAAA3KG9voyIiAl3ap5dLewMAAAAAAAAAAAAAAAAAAAAA2OXt7gIAAAAAAAAAAAAAAAAAoLBkZKQrJSVRaWmpMptNMpvN7i4JAAA4wMvLS15eRvn6+snfP0je3j7uLilPCG8DAAAAAAAAAAAAAAAAKNIsFotSUhKVlJSg9PRUd5cDAADywGw2SUpXWlqKEhKuyMfHT4GBwfL3D5LBYHB3eQ4jvA3AbcLCAuTlZZDZbNGVK8nuLgcAADiBeRwAAM/GXA4AgGdjLgcAwLMxl7tHYuIVJSRcsfOKQV5eXoVeDwDAc10bErZYLG6s5Mbz39My/vc9T09P1ZUrqTKZTAoODnNfYU4ivA3AbYxGLxmNXjKZePwQAACehnkcAADPxlwOAIBnYy4HAMCzMZcXvqSkeKvgttHoo4CAIAUEBMnLy+hRK3UCANzPaPSSwSBZLGI+L2QWi0Vms0nJyYlKTk6UyZQuSUpIiJWXl5cCA0PcXKFjCG8DAAAAAAAAAAAAAAAAKJJSU5MVFxeduR0cHKGgoBAC2wAAeCCDwSCj0VvBwWEKCgpVYmK8EhJiJElxcdEyGr3l5xfg5ipzxzM/AAAAAAAAAAAAAAAAABRJiYnxmX8PDAxVcHAowW0AAIoAg8GgoKAQBQaGZrZdO+9fzwhvAwAAAAAAAAAAAAAAAChyzGaz0tJSJEleXkaFhIS7tyAAAOBSBoNBISHh8vIySpLS0lJkNpvdXFXuCG8DAAAAAAAAAAAAAAAAKHL+C25bJEl+foGsuA0AQBFkMBjk5xfw/1uWzBu3rmeEtwEAAAAAAAAAAAAAAAAUOampyZl/9/cPyGFPAADgyfz9AzP/fu38f70ivA0AAAAAAAAAAAAAAACgyMnISM/8u6+vnxsrAQAABenaef7a+f96RXgbAAAAAAAAAAAAAAAAQJFjNpslSQaDlwwGYlIAABRV/831BkmSxWJ2czW546oEAAAAAAAAAAAAAAAAQJFzNbx1NcwFAACKrqs3al29eet65u3uAgDcuJKS0mQwSBaLuysBAADOYh4HAMCzMZcDAODZmMsBAPBszOUAAHg2s5lJHPlDeBuA26SkpLu7BAAAkEfM4wAAeDbmcgAAPBtzOQAAno25HAAAz2bhDizkk5e7CwAAAAAAAAAAAAAAAAAAAACAGwHhbQAAAAAAAAAAAAAAAAAAAAAoBN7uLgDAjcvLy5D5d7OZR0kAAOBJmMcBAPBszOUAAHg25nIAADwbczkAAMCNjfA2ALcJDw+U0eglk8ms6OhEd5cDAACcwDwOAIBnYy4HAMCzMZcDAODZmMsBAPBsRqOXDAbJYpFMJrO7y4EH8nJ3AQAAAAAAAAAAAAAAAAAAAABwIyC8DQAAAAAAAAAAAAAAAAAAAACFwNvdBQAAAAAAAAAAAAAAAAAAADjq4Yfv07lzZzO3P/98opo0aZbt/t98M0nTpk3J3L777s56553hBVlikdWmjfX3+aefflGZMmXdVI378f1AXhDeBgAAAAAAAAAAAAAAAADAQVmDwPnRqFETTZgw2SV9ATeis2fP6JFHuhTqmAsWLFbZsgS0kXde7i4AAAAAAAAAAAAAAAAAAAAAAG4EhLcBAAAAAAAAAAAAAAAAAAAAoBB4u7sAAAAAAAAAAAAAAAAAAAA8WY8evfN0XNmy5VxcCXBjCQoKdurzd/78Oa1Yscyq7Y47OqlUqdJOjQnkB+FtAAAAAAAAAAAAAAAAAADy4fnnB7i7BOCGFBoa6tTnb9u2rTbh7S5dHlSTJs0c7sNo9Mr8+4YNWx0+DrjKK/ddAAAAAAAAAAAAAAAAAAAAAAD5xcrbANzmypUkSQZJFneXAgAAnMQ8DgCAZ2MuBwDAszGXAwDg2ZjLAQDwbCaT2d0lwMMR3gbgNiaTRfwyCgCAZ2IeBwDAszGXAwDg2ZjLAQDwbMzlAAAANzbC2wAAAAAAAAAAAAAAAABQhCSnZig6PlWpaSb5+RoVGeKnAD+iYkVBVNRpHTlyWDEx0YqLu6KAgACFh0eoatVqqlr1JpePd+VKrPbu3aPo6MuKjY2Rl5dRERERKlu2nOrUqSdvb9e9r86dO6t9+/bo4sWLSklJVmhoqCpXrqq6devLx8fHZeNkJyEhQf/+u1OnT59SUlKiQkPDVKJECTVo0EihoWEuGSMpKUknThzTyZMndOXKFSUnJykgIEAhIaEqXbqM6tSpKz8/f5eMldWJE8d1/PhRxcbGKi7uioxGo4KDQ1S+fAVVq3aTwsLCC2RcOC8pKVG7du3U6dMnlZiYKH9/f5UrV0ENGzZWSEhIrsebzWbt379XR44cVmxsrHx8vFWsWHE1bNhYJUuWcmmtly5d1P79+xQbG62YmFj5+fkqPDxSFStWVI0ateTl5eXS8YoKZmQAAAAAAAAAAAAAAAAA8HAWi0X7T8Zq1bbT2n7wksyW/63w7mUwqEmN4urQpLxqVQyXwWBwY6VwVlzcFc2e/YNWr16p06dPZrtfyZKl1KnTPerRo7eCg4PzPF5GRoZ+/fVnLVmyWPv375XZbLa7X1BQkNq0aacnn+yr8uUr5Hm8jRv/1PTpU7Vnz7/ZjnPffQ+qT59n8vV1ZefkyeOaMmWi1q9fo4yMDJvXvb29dfPNLdS37wuqXr2G0/3v2bNba9eu0rZtW3Xw4P5sv59Xx2rYsIkef7ynWrZs7fRYWUVFndbMmd9p48Y/dfHihWz3MxgMuumm6mrT5lbdc899KlOmbL7Htmf37l0aPPgVxcbGZrZFRERq7NhPVLt23QIZs6C1adPMavunn37J8fv3zTeTNG3alMztu+/urHfeGS7pv5/X1KkTtWbNSqWnp9sc6+vrp3vu6ay+ffvbvaEgJSVFc+fO1IIFP+ry5cs2rxsMBjVp0kyDBr2ar5s9UlJS9NNPc7RixTIdOXIo2/3CwyPUocMd6tPnaRUrVjzP4xVFhLcBuI2fn7cMBoMsFotSU20vfAAAwPWLeRwAAM/GXA4AgGdjLgcAwLMxl6MgnDgXr6mL9yrqUqLd180Wi7YeuKitBy6qXPEgPdO5jiqVzn31Vrjfjz/O1rffTlJCQkKu+164cF4zZkzTL78s0ODBQ9S2bXunx9uyZZPGjx+j06dP5bpvYmKili1bopUr/1CvXk/q6aefc2qs9PR0ffjhe1q69Ldcx5kz5wetXLlcH374sWrUqOXUODlZsmSxxo0brbS01Gz3ycjI0MaNf2rz5r/Vp88zevLJZx3u/6mneurgwf0O75+RkaF//tmsf/7ZrObNW2n48PcVGhrq8PFXpaSk6PPPx+u3336RyWTKdX+LxaJDhw7q0KGDmj59qtav3+L0mLlZu3aVRowYYvW9rlChosaP/0Jly5Zz+XgF6b/7XwySLLns6bhVq1bogw+GKyUlJdt90tJS9fPP87Vp09/69NMvVa5c+czXTp48rrfeek0nThzP9niLxaJ//tmip5/upffeG6tbbmnrdJ0rVizTF198bDccnlVsbIwWLvxJS5cu1gsvvKQHHnjI6fGKKtYjB+A2QUF+CgnxV1CQn7tLAQAATmIeBwDAszGXAwDg2ZjLAQDwbMzlcLU9x6I1Zua2bIPbWUVdStSYmdu051h0AVeG/MjIyNCHH76nzz8f71Bw+1pXrlzRO++8oUWLFjh13K+//qzXXhvoUHD7WhkZGZo2bYpGjRqa46rSWY8ZMuTNXIPb17p48YIGDeqvkydPOFVfdlau/EMffDAix+D2tUwmk775ZpK++upzh8e4dOliXsvT5s0b9dxzfRQfH+/UcRcunFf//s/ol18WOhTczspicV0g+aoff5ylIUMGW32v69dvqIkTv/W44LYkeXl5yWg0yMvLNRHcdevWaPjwt3MMbl/r7Nkovf76ICUnJ0uSTp8+pRdffC7H4Pa10tPTNWTImzp8OPtVs+355ptJGj78HYeC29dKTk7WRx+N1uTJXzl1XFHGytsAAAAAAAAAAAAAAAAA4IFOnIvXhAX/KjXduYBmarpJExb8q8E9mrAC93Vq3LgP9Ntvv1i1hYWF6Z57uqhZs+aqVKmKQkNDlJSUrNOnT2rDhnVatGh+ZpjTbDbr448/VOXKVdSwYeNcx1u69Dd9+OF7Vm0+Pj667bY71Lp1O9WsWUthYeEym026cOG8tmzZrPnz5+r8+XOZ+y9b9rsqVaqsJ554Ktfxvv76C23YsM6qzdfXV126dFWHDrerfPkK8vHx0fnz5/Tnn+u1cOFPunz5suLj4zR8+Dt5CiVf6/z5cxozZlRmULlGjVp68MGH1bBhY0VGFlNCQrwOHTqg339frPXr11gdO2vW96pUqbLuvbeLw+MVL15CN9/cQnXr1lflylVUunQZBQYGytvbR0lJiYqKitKePbu0dOlvOnr0SOZxp06d1JgxI/X+++McGicxMUGDBj2vU6dOWrV7e3vr9tvvVOvWbVW9ek2Fh0dIsiguLk5Hjx7R7t27tG7dGp0+fdJ+x3lkNps1YcIn+vHH2Vbt7dvfpiFDRsnPjxuZzp07q/feG5Z548Ott3ZQx453q2bN2goNDVVcXJy2b/9HP/ww3SqcffLkCX3//bfq0+cZvf32a4qO/i9QXaNGLd1/f1c1atREkZHFlJaWqkOHDuqnn+Zo06a/Mo9PS0vT+PGj9fXX3zpU5/TpUzVt2hSrtoCAAHXqdK9atGipatWqKzQ0TOnpaTpz5ow2bfpLCxb8qNjY2Mz9v//+W1WuXFUdO96Vx+9W0UF4GwAAAAAAAAAAAAAAAAA8jMVi0dTFe50Obl+Vmm7S1N/2auRTzWUwGFxcHfJj6dLfbILbnTvfr4EDX1VgYKBVe2BgkIoXL65GjZqoW7fuevvt17Rv315J/60UPWLEu5o9e778/PyzHe/48WMaP36MVVu9eg00ZMhIlStX3mb/sLBwVa9eUw8/3E3jx4+xqvWbbyapVatbVL16zWzH27t3t376yTrMW6ZMOY0b96kqV65i1R4aGqbq1Wuqa9dHNHz4O9q8+W8dPLg/274dtW3b1sy/P/HEU3r66edkNBoz24KDg1W6dBm1bdtea9eu1ogR7ygtLS3z9QkTPlXLlq1VrFjxHMe5446OuvXW23IM0AcGBqp48RJq2LCRHn+8lxYs+Emffz4+M6C+du1q7dy53aEQ/gcfjLAJbtev30DvvDNC5ctXsNk/NDRM5ctXULt27dW//0Dt3r1LM2d+l+s4jkhNTdXIke9q7drVVu2PPvq4XnzxZZetWu3ptm//R5IUFBSk9977UDff3NLq9cDAIN19d2fddtsdeuWVAdq5c3vmawsX/qTU1BQdPXpEBoNBffu+oJ49e2c5p4eoWLHiatmytT7/fLxVkP7ff3dp3749ql27bo41btu21Sa4fcstbTV48FBFRETY7B8REam6devp0Ue7a8SId7Rx45+Zr3300Wg1adJUxYuXyPV7U5Tx7gcAAAAAAAAAAAAAAAAAD7P/ZKyiLiXmq4+oi4k6cDLWNQXd4Nq0aeb0n3Xr1tj0k5ycrM8//9iqrVu3Hho8eIhNcDurEiVK6pNPvlL58hUz2y5cOK/ff1+c43Gffz4+c8VuSWrQoJE+++wru8Hta/n6+uqtt4aqQ4c7MttMJpNmzJie43FTp07MXGVYkoKDQ/Tpp1/aBLevFRoapg8++Eg1atTKsW9nPfxwN/Xt298quJ3Vrbd20DvvDLdqi4+P06xZ3+fa/8CBrzoUur7KYDDooYce1cCBr1q1Zw2727N58982QelmzZrr00+/shvctqdevQYaPXq8w/Vm58qVWL300vNW9Xh5eWngwFc0cOCrBLez8PLy0ujR422C29fy8/PX228Ps3qvJiQkZIaxn3qqr3r16pPjzTj9+w+yeS/88cfSHGuzWCwaP36M1Wr3HTrcodGjx9sNbl8rODhYo0ePV/36DTPbkpISbVZivxHxCQAAAAAAAAAAAAAAAACAbJjNFsUlpV13f5ZvOZl78Q5YvuWU27+WrH/MZotLvjZP9OuvCxUXdyVzu1q16urff6DDxwcHB2vQIOvg77x5c7Ld/9ChA9q8+e/MbT8/Pw0dOirHlbqzevXVwQoICMjcXrt2lS5dumh336io09qyZZNV2zPPPJdrUFyS/P399cYb77gs+FuyZCn16zfAoX1vv72j2rRpZ9W2ZMlvSk1NdUktWT344MNWq3pv2rTRKjxrz/fff2u1HRERqWHD3nPqZ+kKUVGn9dxzT+nff3dltvn6+mnkyNF69NHuhVqLp7j33vvVpEmzXPcrV668mja92aa9cuWqeuKJp3I93tvbW3ff3dmqbc+e3Tkes379Wp04cTxzu1ixYnrrrSEOfw69vb31+utvW4XKf/llodVK9jcib3cXAAAAAAAAAAAAAAAAAADXoy37L2jm8gOKS0p3dykFZsfhS3rp8w3uLsNKaKCPenSsqZtrlXR3KYVu0aIFVtu9evXJcVVoe1q1ukWlS5fRuXNnJUknThzXxYsXVKKE7fcz63h33XWvSpcu49R44eHhat/+di1Z8t8K3yaTSdu2bVXHjnfb7Ltq1QpZLP8L5wcHh6hLl64Oj1WrVm01bXqzTQA8L7p2fUT+/o4Hm3v06K0NG9ZlbsfFXdGWLX+rTZtb811LVl5eXqpdu07meMnJyTp69LCqV69pd/8zZ6K0Y8c2q7bHH++liIhIl9eWkz17duvNN19WbGxMZltYWJjGjPnYavVlWHvkkccc3rdBg0ZWN1xI/72XHT1PNGrU1Gr7yJFDOe6f9Rzx8MOPKzAwyKGxrqpatZoaNmyc+R5NSIjX/v171aBBI6f6KUoIbwMAAAAAAAAAAAAAAACAHdOX7Fdyaoa7y7jhxCWla/qS/R4V3u7Ro7fTx1SoUNFq+/LlS1Yr3BqNxjwHgxs2bJQZ3pakXbt26PbbO9rst23bVqvt9u1vy/N4V8PbV8ezF97eu/dfq+127drL19fXqbHuuKOTS8Lbd9zRyan969dvaBWKl/4LKzvzM7JYLDp79oyOHDmkCxcuKCkpUUlJSTKbzTb7njkTZbV9/PixbMPbWX+ORqNRnTvf73BdrrB+/RoNH/6O1WrkZcuW00cffa6KFSsVai2epHjxEqpatZrD+1eoYPu9vPnmFg4fX7Gi9XknJSVFKSkpdm9kyMjI0K5dO6za8n6OaGx1g8GuXTsIbwMAAAAAAAAAAAAAAAAAgLx5/vkB+e5j584dVtsVKlRyamXoaxUrVtxqOyrqtM0+MTExOnnyhFXbTTfZDwe7YjxJ2rdvr9V2nTp1nR6rTp16Th+TVWRkMadXGJek2rXrWoW39+7d49Bxx48f06JFC7Ry5XJFR192elxJio+Pz/a1rAHbatWqKzQ0NE/j5MX8+XP12WfjrULotWvX0dixnxb66t+epmrVm5zaPyjIetVrX18/mxtBcmJv1eyEhAS755pDhw4oOTkpczsgIEDly1dwotr/sT1HRGWz542B8DYAAAAAAAAAAAAAAAAA2NHn7lqaufyA4pLS3V3KDSU00Ec9OuYtROzJzpyxDjwfP35Ubdo0c0nfV65csTOebXjyvvvuLLDxzGazLl++ZNVWuXJVp/uuWLGSjEajTCZTnuurXLlKno6rUqWqVq/+3/blyxdz3D8jI0OTJn2pH3+cla96JSkhIfvw9sWLF6y2a9asla+xnDFp0pdasWKZVdstt7TViBGj83zzwY3E2ZB91pXqQ0JCnDrez8/Ppi09Pc3uvlnPEcnJyWrb9manxstOXFysS/rxVIS3AbiN2WyRZP7//wIAAE/CPA4AgGdjLgcAwLMxlwMA4NmYyz3LzbVKqmmNEkpIub7C2ympGXp78t9yxdvIy8ugD55tIX+/6ydKFuzvIy8vg7vLKHRxcbaBZ1exF/wtyPCkvfESExNlsVi/aUNCnF8d2mg0KiAgMMcwc26cDbxeFRxsfVx8fFy2+2ZkZGjo0Le0bt3qbPdxRnp69uehrGH50NAwl4zpiKzB7bZtb9V7742V0WgstBrcweKiadzHx8etx+fE3k0YrpKQkFBgfXuC62fGBXDDiY1Nyn0nAABwXWIeBwDAszGXAwDg2ZjLAQDwbMzlnsfLy6DQQN/cdyxEoYG+alKjhLYeyHnVX0c0qVFCJSMCXVAV8is+vuDCjGaz2e3jJSfbnv/yujJzQEBAvsLb+Rn3WklJydnuO2vW9zbBbW9vb7Vpc6uaNGmmatWqq2TJkgoJCZWvr6/Nisrvvz9cS5YsdqiupKTEHOssSN7e3srIyMjc3rp1i3bu3K4mTVyzavz1yGSyfX8XRfn5jOUmvyvRezrC2wAAAAAAAAAAAAAAAADgYTo0Ke+S8PZtjcu5oBq4gp+fn9V2yZKldOedd7mk75o1a+c6niR17/6EDIb8r3pub2XrgADbmwRSUlLy1H9ycvahaUe4atzAQPsh6bi4OM2YMc2qrXbtOnrvvbEqVaq0y2sMDAzKsc6CNGTIKH300ejMVciTk5P0+uuD9P7749SyZetCqwOul/UcERgYpAcffNglfZcte2PPPYS3AQAAAAAAAAAAAAAAAMDD1KoYrnLFgxR1KTH3nbNRrkSQalYMd11RyJfw8HCr7ZCQED3//IBCG0+SevbsrdDQsAIZLygoSAaDQRaLJbPtauDXGSaTye4q3s6Ij8/bisJZVyIOCQm1u9/ff/9lFaAODg7Rhx9+osjIYk7U6Pj3JjTUuo64uCsOH5tfderU1eefT9Qrr7yomJhoSVJqaqreeutVjRgxWu3atS+0WuBaYWHhNm0FeU66kXi5uwAAAAAAAAAAAAAAAAAAgHMMBoOe6VxHfj7GPB3v52PUM/fWcckqy3CN4sWLW21fvnypgMcrYdN26VL+V3PPjpeXl4oVs/4ajx8/6nQ/J0+ekMlkylctx48fy9Nxx45Z11usmO33UJJ27dputd2hwx1OBbcl52osWbKU1faBA/udGiu/qlevoQkTJlu9p9LT0zVkyJv644+lhVoLXCfrOSIpKVFJSfm7cQL/IbwNwG2Cg/0UGuqv4GDbR7AAAIDrG/M4AACejbkcAADPxlwOAIBnYy6HK1UqHaIXu9Z3OsDt52PUi13rq1LpkAKqDHnRoEFjq+3Y2FidOHG8wMYrV668TThz164dBTaeJNWuXcdqe+/ePU73sW+f88dkFR19WefOnc332HXq1LW73+XLl622q1at5tQ4Z85EORWkb9jQ+r1z5MghxcU5v6p5flSqVFlffjlFZcqUzWwzmUwaNWqoFi9eVKi1FDQvL0Pmn6Ksbt368vb2tmor6HPEjYLwNgC38fX1lp+fj3x9vXPfGQAAXFeYxwEA8GzM5QAAeDbmcgAAPBtzOVytbpVIDe7RROWKBzm0f7kSQRrco4nqVoks4MrgrIoVK6lUqdJWbStWLCvQMZs1a55lvOUFOl6dOvWtttevX6v09HSn+nDV92TVqj+c2n/37l02ge+6devZ3TclJdlq28fHuXO+s2HnJk2aWW2bTCb99tsvTvXhCuXKldeXX05RhQoVM9vMZrM+/PA9zZs3p9DrKSgGw3/B7aL+5IKAgADVq9fAqm3lyoI9R9woCG8DAAAAAAAAAAAAAAAAgAerVDpEI59urjceb6xmNUvIK0ug0OhlULNaJfXG44018qnmrLh9Hbv33i5W2z/9NEcxMdGFNt6OHdu0ZcvfBTbebbfdYRV4jY+P0y+/LHT4+IMH92vr1s0uqWX+/B+Vmpri8P6zZs2w2g4NDdPNN7e0u29oaKjV9smTJxwe59KlS1q4cJ7D+0tSmTJl1bTpzVZts2fPUExMjFP9uELJkqX05ZdTrFYbt1gs+vTTj/TDD9MLvR7kT9ZzxPLlS3Ts2FE3VVN0EN4GAAAAAAAAAAAAAAAAAA9nMBhUq1KE+j9YX1+81FbvPdNC7z7RTO8900KfD2qr/g/UU61KEUV+pVhP9+ij3RUc/L9wfUJCvN5++zWnQsZZRUdfzva1xo2bqnHjplZtI0a8q6io0wUyXrly5XXzzS2s2qZOnagzZ6Jy7Tc1NUXjxn0gs9mc59qudf78OU2a9KVD+65Zs1Lr1q22arv77nvl5+dnd//Klataba9cuVzJycl2971Wenq6PvhguOLj4xyq61o9e/ax2o6OvqxRo4YqLS3N6b7yKzKymL74YpJq1qxt1T5x4gRNnTqx0OtB3nXseLfKl6+QuW0ymfTWW68pNjY2z33mdI64URDeBgAAAAAAAAAAAAAAAIAiJMDPW2WLB6lq2VCVLR6kAD9vd5cEBwUHB+vFF1+yavv331169tneOnTogMP9pKSkaNWqFerf/xl9/PHYHPd96aXXFRAQkLkdGxurZ5/trdWrVzg8ntls1s6d2zVs2Nt68snuOe77zDP95OX1v+hifHycXn75BZ08eTzbY+Li4vT2229o3769DtfkiB9/nK1vvpmUYyB8/fo1GjlyqFVbSEiound/IttjWrZsbbV9+fJ/QerU1NRsj4mJidHgwa9q8+a8rXx+880t1L797VZtmzdv1Esv9Xc4jL979796663X8jR+VmFh4frss69Vv35Dq/bp06dqwoRPXTIGCp7RaNSrr74po9GY2Xb69Ek9/XRPbdu21eF+MjIytHHjn3r99UF6882XC6JUj8KsDAAAAAAAAAAAAAAAAADAdaJz5/t1+PBBzZs3N7Pt6NEjevLJHmrevKXatLlVdevWV7FixRUYGKjU1BQlJCTozJkoHTp0QLt379KWLZsyg8Lt29+W43jVqt2kt98epqFD35LFYpEkxcVd0ZAhg1WlSlV17Hi3GjRopNKlyygkJEQZGRlKSEjQxYsXdfjwQR04sE8bN/6pmJhoSVJYWFiO49WpU0+PPPK45s6dmdkWFXVaffr00P33d1WHDrerfPkK8vb21vnz57Vx4wbNnz9Xly//t1pvjRq1FBMTrYsXLzj/zf1/TZo00759e5WcnKRp06bor7826MEHH1bDho0VGRmp+PgEHT58UEuW/Kq1a1fbHP/iiy+pWLHi2fZfu3ZdNWrURDt2bMtsW7dutZ56qoe6deuhxo2bqlixYkpKStaZM6f155/rtWjRAiUkxEv6b+XqWrVq66+/Njj1db311hAdOXJIp06dzGzbtWuHevR4WHfc0UmtW7dV9eo1FB4eIYvFovj4OB07dlR79vyrdetW68SJ406Nl5vg4GB9/PEEDR78iv75Z0tm+5w5PyglJUWvvvomTwPwADff3FLPPz/AKnR//vw5DRzYT3Xr1leHDrerfv1GKlmypIKCgpWWlqbExASdO3dWhw8f1N69u7Vp00YlJCRIks2K7DciwtsAAAAAAAAAAAAAAAAAAFxHBgx4RT4+vpo9e4ZV++bNf+d5ZeacdOhwh4YNM2nMmFFKSUnJbD927KgmTfrS5eM9//wAnT59Un/+uT6zLS0tVT/9NFs//TQ72+NCQkI1fPh7euWVAfkav1Sp0rr//q4aPvwdWSwWHTiwT2PGjHLo2O7de+nee7vkut9rr72l557ro8TExMy2EyeOa+zY93M8ztfXT6NGfajFi392qJ5rBQUF67PPvtYbb7ysw4cPZrZnZGRo6dLftHTpb073mV8BAQEaO/ZTDRnyplUY/eef5yk1NUWDBw+xWtUZ16fHHuspg8Ggr776XCaTKbN9z55/tWfPv26szDN55b4LAAAAAAAAAAAAAAAAAAAoLEajUS+8MEijRo1RyZKl8txPYGCQ6tZt4NC+d9zRSZMmTVedOvXyPJ7RaFSTJjfnup+3t7fee2+sOnW62+G+ixUrrk8//UoVK1bOc33Xuv32jnr77WHy8fFxaH+j0ainnuqr/v0HObR/5cpVNHbspwoPj3C4poiISH3yyQQ1bNjI4WOyKlmylL76aqruuec+eXk5HxEtiCC1n5+fPvjgI7Vvf7tV+5IlizVixLvKyMhw+ZhwvW7deujTT79S5cpV8tyHr6+fGjVq7MKqPBMrbwMAAAAAAAAAAAAAAAAAcB3q0OEOtW3bXkuWLNaSJYu1b98epaen53hM8eIl1LTpzWrZsrXatm0vf39/h8erVu0mTZ48XVu2/K0FC37Stm1brVaOticwMEiNGjVR8+Yt1KHDHSpWrLhDY/n4+GjIkFG6445OmjZtqvbu3Z1t//fe20VPPvmsQkNDHf5aHHH33Z1Vq1YdTZnytf78c53VisJXGY1GNW/eUn379lf16jWd6r9hw8aaNm2mvv12ipYt+01paWl29wsLC9O993ZRz55PuuRrDAwM1NtvD9Pjj/fSzJnf6e+//1RsbGy2+3t5ealGjVpq1669Q6uK54W3t7dGjPhAH3wwQsuW/Z7ZvmrVH0pNTdGoUR/K19e3QMaG6zRu3FTffz9Xa9as0q+/LtSuXTuUmpqa4zFhYWFq3LiZWrZspVtvvV0hISGFVO31y2CxWCzuLgLIKiYmSRkZthMhipbIyCAZjV4ymcyKjs75Ig8AAFxfmMcBAPBszOUAAHg25nIAADwbc3nhuXDhtMxmk7y8jCpZsry7ywFcIiUlRXv37tbFixd05coVJSUlKiAgQEFBQSpTppwqVaqi4sUdC087wmQy6eDB/TpzJkpXrlxRfHycfHx8FBgYpBIlSqpy5SoqU6ZsnlZ4zurs2TPau3ePLl++qJSUFIWEhKpSpcqqV69BoYR64+LitHv3Lp0+fUpJSYkKCQlVyZIl1aBBI4WFhee7/5SUFO3atUOnT59SfHycjEajIiOLqWrVaqpevWaBrHh9lcVi0cGDB3T69EnFxsYoPj5efn7+CgkJVvnyFVW16k0uD8YXZUajlwwGyWKRTCazu8txq/T0dO3bt0fnz5/TlSuxSkhIkJ+fv4KCglSqVGlVqlRFpUqVksFgKPBaCmre9/Y2KiIi0GX9SYS3cZ0ivH1jCAryy5zEEhNzvvsGAABcX5jHAQDwbMzlAAB4NuZyAAA8G3N54SG8DQAoCF5e/wsim81EcK8XnhTe9nZpbwDgBH4JBQDAczGPAwDg2ZjLAQDwbMzlAAB4NuZyAAA8G4Ft5Ff+n1UAAAAAAAAAAAAAAAAAAAAAAMgV4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEHi7uwAAN66IiEB5eXnJbDYrJibJ3eUAAAAnMI8DAODZmMsBAPBszOUAAHg25nIAADyb0fi/dZNNJrMbK4GnYuVtAG5jMBjk5WWQwWBwdykAAMBJzOMAAHg25nIAADwbczkAAJ6NuRwAAM/HNI78ILwNAAAAAAAAAAAAAAAAAAAAAIWA8DYAAAAAAAAAAAAAAAAAAAAAFALC2wAAAAAAAAAAAAAAAAAAAABQCAhvAwAAAAAAAAAAAAAAAAAAAEAhILwNAAAAAAAAAAAAAAAAAAAAAIWA8DYAAAAAAAAAAAAAAAAAAAAAFALC2wAAAAAAAAAAAAAAAAAAAABQCAhvAwAAAAAAAAAAAAAAAAAAAEAh8HZ3AQBuXAkJKZIMkizuLgUAADiJeRwAAM/GXA4AgGdjLgcAwLMxlwMA4NnMZrO7S4CHI7wNwG3S0kzuLgEAAOQR8zgAAJ6NuRwAAM/GXA4AgGdjLgcAwLNZuP8K+eTl7gIAAAAAAAAAAAAAAAAAAAAA4EZAeBsAAAAAAAAAAAAAAAAAAAAACoG3uwsAcOPy9v7f/SMZGWY3VgIAAJzFPA4AgGdjLgcAwLMxlwMA4NmYywuPl5eXzGaTzGa+zwAAFHVX53svr+t/XWvC2wDcJjQ0QEajl0wms6KjE91dDgAAcALzOAAAno25HAAAz8ZcDgCAZ2MuLzwGw9XwlkUmk0lGo9Gt9QAAigaj0UsGg2SxSCYTNwhdD0wmkySLpGvn/+vX9V8hAAAAAAAAAAAAAAAAADjJ19cv8++pqUlurAQAABSka+f5a+f/6xXhbQAAAAAAAAAAAAAAAABFjr9/UObfU1IIbwMAUFRdO89fO/9frwhvAwAAAAAAAAAAAAAAAChyvL19ZDR6S5LS0lKUmprs5ooAAICrpaYmKy0tRZJkNHrL29vHzRXljvA2AAAAAAAAAAAAAAAAgCLHYDBYrb4ZE3ORADcAAEVIamqyYmIuZm77+wfJYDC4sSLHeLu7AAAAAAAAAAAAAAAAAAAoCMHBYcrISFdqapIki2JiLsjX11/+/oHy8wuU0Wh0d4kAAMAJJpNJqalJSklJylxxW5L8/AIVHBzmxsocR3gbAAAAAAAAAAAAAAAAQJFkMBgUHl5csbGX/j/ALaWlpfx/2CtakkFeXl5urREA4FmuXdnZYrG4sZIbj9lslmT7PffzC1R4eHGPWHVbIrwNAAAAAAAAAAAAAAAAoAi7GuBOSLiilJREmUwZ17xqkdlsclttAADP4+VlkGTQf3MI4W13Mhq95e8fpODgMI8JbkuEtwEAAAAAAAAAAAAAAAAUcQaDQSEh4QoODlNGRrpSUhKVlpYqi8X8/6t4AgDgGB8fbxkMksUipadn5H4AXMbLy0sGg5d8ff3k7x8kb28fjwptX0V4GwAAAAAAAAAAAAAAAMANwWAwyMfHVz4+vu4uBQDgoSIjg2Q0eslkMis6OtHd5cADGSwWC2u247oTE5OkjAweSVPUXXvDC2ciAAA8C/M4AACejbkcAADPxlwOAIBnYy4HAMCzMZffWLy9jYqICHRtny7tDQCcwMQFAIDnYh4HAMCzMZcDAODZmMsBAPBszOUAAHg25nLkl5e7CwAAAAAAAAAAAAAAAAAAAACAGwHhbQAAAAAAAAAAAAAAAAAAAAAoBN7uLgDAjSsgwEcGg0EWi0XJyenuLgcAADiBeRwAAM/GXA4AgGdjLgcAwLMxlwMA4NmYy5FfhLcBuE1AgK+MRi+ZTGYmMQAAPAzzOAAAno25HAAAz8ZcDgCAZ2MuBwDAszGXI7+83F0AAAAAAAAAAAAAAAAAAAAAANwICG8DAAAAAAAAAAAAAAAAAAAAQCEgvA0AAAAAAAAAAAAAAAAAAAAAhYDwNgAAAAAAAAAAAAAAAAAAAAAUAsLbAAAAAAAAAAAAAAAAAAAAAFAICG8DAAAAAAAAAAAAAAAAAAAAQCEgvA0AAAAAAAAAAAAAAAAAAAAAhYDwNgAAAAAAAAAAAAAAAAAAAAAUAm93FwDgxpWRYZbZbJHZbHF3KQAAwEnM4wAAeDbmcgAAPBtzOQAAno25HAAAz8ZcjvwyWCwW3j247sTEJCkjw+TuMgAAAAAAAAAAAAAAAAAAAHCD8vY2KiIi0KV9erm0NwAAAAAAAAAAAAAAAAAAAACAXYS3AQAAAAAAAAAAAAAAAAAAAKAQEN4GAAAAAAAAAAAAAAAAAAAAgELg7e4CANy4QkMD5OVlkNlsUVxcsrvLAQAATmAeBwDAszGXAwDg2ZjLAQDwbMzlAAB4NuZy5BfhbQBu4+3tJaPRSyaT2d2lAAAAJzGPAwDg2ZjLAQDwbMzlAAB4NuZyAAA8G3M58svL3QUAAAAAAAAAAAAAAAAAAAAAwI2A8DYAAAAAAAAAAAAAAAAAAAAAFALC2wAAAAAAAAAAAAAAAAAAAABQCAhvAwAAAAAAAAAAAAAAAAAAAEAhILwNAAAAAAAAAAAAAAAAAAAAAIWA8DYAAAAAAAAAAAAAAAAAAAAAFALC2wAAAAAAAAAAAAAAAAAAAABQCAhvAwAAAAAAAAAAAAAAAAAAAEAh8HZ3AQBuXMnJaTIYDLJYLO4uBQAAOIl5HAAAz8ZcDgCAZ2MuBwDAszGXAwDg2ZjLkV8GC+8eXIdiYpKUkWFydxkAAAAAAAAAAAAAAAAAAAC4QXl7GxUREejSPr1c2hsAAAAAAAAAAAAAAAAAAAAAwC7C2wAAAAAAAAAAAAAAAAAAAABQCLzdXQCAG5fB8L+/WyzuqwMAADiPeRwAAM/GXA4AgGdjLgcAwLMxlwMA4NmYy5FfhLcBuE1ERJCMRi+ZTGZFRye6uxwAAOAE5nEAADwbczkAAJ6NuRwAAM/GXA4AgGdjLkd+ebm7AAAAAAAAAAAAAAAAAAAAAAC4ERDeBgAAAAAAAAAAAAAAAAAAAIBCQHgbAAAAAAAAAAAAAAAAAAAAAAoB4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEBDeBgAAAAAAAAAAAAAAAAAAAIBCQHgbAAAAAAAAAAAAAAAAAAAAAAoB4W0AAAAAAAAAAAAAAAAAAAAAKASEtwEAAAAAAAAAAAAAAAAAAACgEHi7uwAAN664uGR3lwAAAPKIeRwAAM/GXA4AgGdjLgcAwLMxlwMA4NmYy5FfhLcBuE1GhtndJQAAgDxiHgcAwLMxlwMA4NmYywEA8GzM5QAAeDbmcuSXl7sLAAAAAAAAAAAAAAAAAAAAAIAbAeFtAAAAAAAAAAAAAAAAAAAAACgE3u4u4EaRmpqq7du36+zZs7p8+bJMJpPCwsJUtWpVNWzYUH5+fi4fMzY2Vjt27NDJkyeVmJgoX19flSxZUnXq1FG1atVcPh7gLF9foySDJIvS0kzuLgcAADiBeRwAAM/GXA4AgGdjLgcAwLMxlwMA4NmYy5FfhLcL2M6dO/X1119r48aNSklJsbuPv7+/7rrrLvXt29cloeqtW7dq4sSJ+uuvv2Qy2T8xVKpUST179tTjjz8uHx+ffI8J5EVwsL+MRi+ZTGZFRye6uxwAAOAE5nEAADwbczkAAJ6NuRwAAM/GXA4AgGdjLkd+GSwWi8XdRRRFycnJevfdd7V48WKHj/Hx8dHAgQP17LPPymAwOD1menq6Ro8erZkzZzp8TI0aNfTFF1+ocuXKTo9XkGJikpSRwR0pRV1kZBCTGAAAHop5HAAAz8ZcDgCAZ2MuBwDAszGXAwDg2ZjLbyze3kZFRAS6tE8vl/YGSVJ0dLR69OjhVHD7/9i78/i6yjp/4N9zb9I2adM2oaXQUval7ALFFSwgIqIoKIOAoigIKIyOjjouMyOuqAOKCCq4gCLIOKMgiuAgAiJFFtmklAJlb0uhJOmSNE2TnN8f/HrpTdPmJrnJ6aHv9+uVFzlPz/M839vcPJ/wen1zGvFS8/W5554bZ5111oD37Orqio9//OMDatyOiHjkkUfi+OOPj/nz5w94TwAAAAAAAAAAAACgcjVZF/BK093dHZ/4xCdizpw5ZeMTJkyIE088MQ466KCYNm1aREQ8++yzcfPNN8fPf/7zWL58eeneK6+8Mrbeeus4+eSTK9733HPPjRtvvLFsrLGxMd73vvfFoYceGltuuWW0trbGgw8+GJdeemk88MADpfuam5vj9NNPj6uuuirGjRs3mJcNAAAAAAAAAAAAAPQjSdM0zbqIV5KLL744zj333LKxvfbaKy666KJoamrqc86SJUvi1FNPLWv4rq2tjeuvvz622mqrfvd8+OGH46ijjoq1v5Q77bRT/OQnP4kpU6asc3+apnH22WfHz372s7LxD33oQ/Fv//Zv/e43Elpa2qOrqzvrMhhm/vkIAMgvOQ4A+SbLASDfZDkA5JssB4B8k+WblpqaYjQ21ld1zUJVV9vEtbe3x09+8pOysalTp8ZPf/rT9TZuR0RMmjQpLrnkkrJG69WrV8f5559f0b7nnXdeWeP22LFj40c/+lGfjdsREUmSxOc///l405veVDZ+xRVXxOLFiyvaEwAAAAAAAAAAAAAYGM3bVfS73/0uWltby8Y++9nPRkNDQ79zJ0yYEJ/97GfXWe+JJ57Y4Ly5c+fGTTfdVDb2sY99LLbccst+9zzrrLNizJgxpeuOjo51ms8BAAAAAAAAAAAAgOrQvF1Ft912W9n15ptvHoceemjF8w877LCYPHly6bqnpyeuv/76Dc657rrryq7r6+vjmGOOqWi/zTffPA477LCysT/+8Y8VVgsAAAAAAAAAAAAADITm7Sr6+9//Xnb96le/OorFYsXza2pq4tWvfnXZ2A033LDBOTfeeGPZ9Zvf/OYYN25cxXu+613vKrt+7rnn4sEHH6x4PgAAAAAAAAAAAABQGc3bVdLV1RUvvvhi2djOO+884HV6z5kzZ048//zzfd67cOHCeOyxx8rGejd/92efffaJ2trasrGbb755QGvAYKVpGj09aaRpmnUpAMAAyXEAyDdZDgD5JssBIN9kOQDkmyxnqGqyLuCVYunSpet8I44fP37A6/Q1Z968ebH55pv3Od7bvvvuO6D9xowZE7vttlvcf//9pbFHHnlkQGvAYLW0tGddAgAwSHIcAPJNlgNAvslyAMg3WQ4A+SbLGSpP3q6Svn6DIkmSAa/T15z58+f3ee/jjz9edl1TUxPbbrvtgPfcYYcdyq6feOKJAa8BAAAAAAAAAAAAAGyY5u0q6euJ2cuWLRvwOn3NWV/zdu/xKVOmRKEw8C/pFltsUXb95JNPRnd394DXAQAAAAAAAAAAAADWT/N2lYwaNWqdBu5HH310wOs88sgj64wtXry4z3uff/75suveTdiVmjp1atl1Z2dntLa2DmotAAAAAAAAAAAAAKBvmreraK+99iq7vuuuu6Knp6fi+T09PXHXXXetM97e3t7n/b3Hx40bV/Feaxs7dmzFe0I1jR07OsaNGx1jx47OuhQAYIDkOADkmywHgHyT5QCQb7IcAPJNljNUNVkX8Ery6le/Ov7617+WrhctWhQ333xzHHLIIRXN//Of/9znU7Yrbd4eM2bMAKrd8Ly2trYBr7Nw4cJYuHDhoGoYN25czJgxY1Bzya/Ro2uiWCxEd3dPtLWtyrocAGAA5DgA5JssB4B8k+UAkG+yHADyTZYzVJq3q+ioo46K733ve7F69erS2Nlnnx2vfe1ro76+foNzV6xYEV//+tf7/LP1NVKvXLmy7HrUqFEDrPglfTVvD+bJ27/+9a/jggsuGFQN++23X1xxxRWl6/HjN9yI3tXVE8uWlb/+8eProqam/4fJr1zZGStXvvw1SpKIxsZ1nz7el2XLVkZX18tPUx81qhjjxvXfNJ+mabS0lP+djh07OkaP7v9bsLOzK1asKD/gJ06sj0Ih6XduW9uqWLWqq3RdLCYxYcKG34trtLa2R09PWroeM6Y26uv7f491d/fE0qXlX5uGhjFRW1tc5941r6FQSKKpaWx0dKyO9vbOsnuamir72ixf3hGrV3eXrmtri9HQUNkvNDQ3l3+P1dePijFjavudt3p1dyxf3lE2NmFCXRSL/b8P29s7o6Pj5fdhoZDExImVfW2WLm2P7u6XvzajR9dU9FtcPT1ptLb2fmL/6Bg1qv/34apVXev8oNHYWB9J0v/7cMWKjujsfPlrU1NTiPHj6/qdFxHR0tIW6csvNerqaqOurv/3oTPilXFG9OaMcEb05ozI9ozoneNrc0Y4I9bmjNg0z4gNcUY4I9bmjMjujNhQlkc4I5wR63JGbFpnRH+cEc6I3pwRI39G9JflazgjnBFrc0ZsOmeEnyPW5YxwRqxtYzkjIvrP8ghnhDNiXc6ITeOM8HPEupwRzojenBHOiLVldUYMlubtKpoyZUoceeSR8Zvf/KY09vTTT8epp54a3//+92P8+PF9zmttbY2PfOQjsWDBgj7/vJJv7Fea/g7utQNxjUIhqejA7+vvs5J561mtorl91Zskle3b1+Ex+Nda2by+16qs3rT3/21G//UmSRLFYlLlr83g575UT/9zu7t71hmr/Guz7ljl9SYR8fLfc6X1RlS33kKhUFG4vVRvueH+2jgjXllnxMt7OCMq44zojzOiumfEmhzf8FrOiN6cEc6I/r0yzohKOCPW5YxwRvSvemfE+rLcGeGM6GN2OCM27JV4RqyPM8IZ0cfscEZsWLXPiDVjlfx/ea+ZzohenBHOiD5mrzOStzPCzxH9c0asyxkx8mfES7X0n+XOCGdEJZwRveX/jPBzxLqcEc6IPmaHM2LDnBEjf0ZUSvN2lf3bv/1b/O1vf4uFCxeWxu666644/PDD46STToqDDz44pk2bFhERCxYsiJtuuil++tOfRktLS0S89I08fvz4aG1tLc1fX9N3XV35b110dnb2eV9/Ojo61hnr70nhw62vA31tfX2T9vSk/c6L6DsYK5m3ntUGvWeaVrbv+l5rXyHS/76V1dv3WkOrd30hnSRJpGkaPT1plb82g5+bppX9PQ3tfbjuWOX1lk/Oqt6enp5I00p+8Kje13VkXqszYjCG44xYdw9nRGWcEf3ZeN6H+T4jeuf4htdyRvTmjHBG9C/fZ8RAOCPW5YxwRvRv6GdEf1nujHBG9DG711rOiN42nvehnyP6rm3dMWdE7z3WHXNGVLBSRmdEmqYV/395r5nOiD5rW3fMGdF7j3XHnBEVrOTniHU4I5wRfczutdamc0a8VEv/Wb7xvA+dEX3Xtu6YM6L3HuuOOSMqWMnPEetwRjgj+pjday1nRG8bz/sw/2dEtZu5k7SvV8uQPPDAA3HKKafE0qVLBzz3c5/7XFxzzTUxZ86c0tgBBxwQP/nJT9a594QTToi///3vpetZs2bFxRdfPOA9//CHP8QnPvGJsrE//elPMX369AGts3DhwrKm9YEYN25czJgxo3Td0tIeXV3dG5jBK0FT09goFgvR3d2zzj+7AQBs3OQ4AOSbLAeAfJPlAJBvshwA8k2Wb1pqaorR2FjdByJ78vYw2GuvveLKK6+Mj370o/HEE09UNKe2tjY++clPxkknnRS//OUvy/5swoQJfc7p/XTsFStWDKretrZ1D4/BPHl76tSpMXXq1EHVAAAAAAAAAAAAAACvdNV9jjcl22+/ffzud7+LL37xi7Httttu8N43vOEN8b//+7/xoQ99KCJinSd277DDDn3O23zzzcuun3vuuUHVumjRorLrUaNGxcSJEwe1FgAAAAAAAAAAAADQN0/eHka1tbVxwgknxAknnBDPPPNM3HffffHiiy9Ga2trjB49OrbeeuuYOXNmTJkypTSnubk5WlpaytbZc889+1x/++23L7tevHhx9PT0RKEwsJ783s3b2267bRSLxQGtAQAAAAAAAAAAAABsmObtETJ9+vSYPn16v/fNmzdvnbE99tijz3t7P5G7q6srnnzyyXWauvvz+OOPl11vt912A5oPAAAAAAAAAAAAAPRP8/ZG5m9/+1vZ9W677RZNTU193rvLLrusM3bvvfcOqHm7o6Mj5syZUza28847VzwfhqKzsysKhSR6etKsSwEABkiOA0C+yXIAyDdZDgD5JssBIN9kOUOleXsj8/vf/77s+phjjlnvvVOnTo0dd9wxHnvssdLYnXfeGe9+97sr3u/ee++N1atXl40ddNBBFc+HoVixYlXWJQAAgyTHASDfZDkA5JssB4B8k+UAkG+ynKEqZF0AL/vTn/4Uzz77bOl6zJgxceSRR25wzpve9Kay6//7v/+Ltra2ive8+uqry6632GKL2GOPPSqeDwAAAAAAAAAAAABURvP2RqKjoyO+/vWvl42dcMIJMX78+A3OO/zww8uu29vb49e//nVFe77wwgtx/fXXl4295S1vqWguAAAAAAAAAAAAADAwmrc3Ap2dnfHP//zPsWDBgtLYtGnT4p//+Z/7nbvbbrvFwQcfXDZ2/vnnx+LFi/ud+6UvfSk6OjpK16NHj46TTz55AJUDAAAAAAAAAAAAAJXSvD0MvvOd78SiRYsqunf+/PnxwQ9+MP7yl7+UxpIkiS996UtRX19f0Rr/8i//EkmSlK6XL18ep5xyynobuNM0jW984xtxww03lI2/973vjSlTplS0J1TDxIn10dQ0NiZOrOy9DgBsPOQ4AOSbLAeAfJPlAJBvshwA8k2WM1RJmqZp1kW80uyyyy5RKBTiVa96VcyaNSt233332G677WLChAmxevXqePHFF+Phhx+OP/3pT3HjjTfG6tWry+Z/6lOfig9/+MMD2vOb3/xm/PSnPy0ba2pqihNPPDEOOeSQ2HLLLWPp0qXx4IMPxqWXXhr3339/2b1bb711XHXVVTFu3LjBvegqa2lpj66u7qzLYJg1NY2NYrEQ3d090dzclnU5AMAAyHEAyDdZDgD5JssBIN9kOQDkmyzftNTUFKOxsbqN+pq3h8Euu+wyqHlJksSnP/3pOPnkkwc8t6urK84888y46aabBjy3sbExfvGLX8SOO+444LnDRfP2pkGIAUB+yXEAyDdZDgD5JssBIN9kOQDkmyzftAxH83ahqqsxaFtttVVccsklg2rcjoioqamJ733ve3H88ccPaN5OO+0UV1555UbVuA0AAAAAAAAAAAAAr0Sat4fBl7/85TjkkENi/PjxG7wvSZLYY4894ktf+lJcd9118brXvW5I+9bW1sZZZ50Vl19+eRxwwAFRKKz/yzt9+vT4/Oc/H1dddVVsu+22Q9oXAAAAAAAAAAAAAOhfkqZpmnURr1RpmsYTTzwRTzzxRCxatChWrFgRERHjxo2L6dOnxx577BGbbbbZsO3f0tIS9913Xzz99NPR1tYWtbW1sfnmm8fuu+++0T9pu6WlPbq6urMug2Hmn48AgPyS4wCQb7IcAPJNlgNAvslyAMg3Wb5pqakpRmNjfXXXrOpqlEmSJLbffvvYfvvtM9m/sbExDj744Ez2BgAAAAAAAAAAAADKFbIuAAAAAAAAAAAAAABgU6B5GwAAAAAAAAAAAABgBGjeBgAAAAAAAAAAAAAYATVZFwBsutraVkWSJJGmadalAAADJMcBIN9kOQDkmywHgHyT5QCQb7KcodK8DWRm1aqurEsAAAZJjgNAvslyAMg3WQ4A+SbLASDfZDlDVci6AAAAAAAAAAAAAACATYHmbQAAAAAAAAAAAACAEVCTdQHApqtYTCIiiYg0urvTrMsBAAZAjgNAvslyAMg3WQ4A+SbLASDfZDlDpXkbyMyECfVRLBaiu7snmpvbsi4HABgAOQ4A+SbLASDfZDkA5JssB4B8k+UMVSHrAgAAAAAAAAAAAAAANgWatwEAAAAAAAAAAAAARoDmbQAAAAAAAAAAAACAEaB5GwAAAAAAAAAAAABgBGjeBgAAAAAAAAAAAAAYAZq3AQAAAAAAAAAAAABGgOZtAAAAAAAAAAAAAIARoHkbAAAAAAAAAAAAAGAEaN4GAAAAAAAAAAAAABgBSZqmadZFQG8tLe3R1dWddRkMs0IhKX3e0+MoAoA8keMAkG+yHADyTZYDQL7JcgDIN1m+aampKUZjY31116zqagADILgAIL/kOADkmywHgHyT5QCQb7IcAPJNljNUhawLAAAAAAAAAAAAAADYFGjeBgAAAAAAAAAAAAAYATVZFwBsusaMqY0kiUjTiI6O1VmXAwAMgBwHgHyT5QCQb7IcAPJNlgNAvslyhkrzNpCZ+vpRUSwWoru7R4gBQM7IcQDIN1kOAPkmywEg32Q5AOSbLGeoClkXAAAAAAAAAAAAAACwKdC8DQAAAAAAAAAAAAAwAjRvAwAAAAAAAAAAAACMAM3bAAAAAAAAAAAAAAAjQPM2AAAAAAAAAAAAAMAI0LwNAAAAAAAAAAAAADACNG8DAAAAAAAAAAAAAIwAzdsAAAAAAAAAAAAAACOgJusCgE1Xd3dPpGkaPT1p1qUAAAMkxwEg32Q5AOSbLAeAfJPlAJBvspyhStI09e5ho9PS0h5dXd1ZlwEAAAAAAAAAAADAJqqmphiNjfVVXbNQ1dUAAAAAAAAAAAAAAOiT5m0AAAAAAAAAAAAAgBGgeRsAAAAAAAAAAAAAYATUZF0AsOlqaBgThUISPT1pLF/ekXU5AMAAyHEAyDdZDgD5JssBIN9kOQDkmyxnqDRvA5mprS1GsViI7u6erEsBAAZIjgNAvslyAMg3WQ4A+SbLASDfZDlDVci6AAAAAAAAAAAAAACATYHmbQAAAAAAAAAAAACAEaB5GwAAAAAAAAAAAABgBGjeBgAAAAAAAAAAAAAYAZq3AQAAAAAAAAAAAABGgOZtAAAAAAAAAAAAAIARoHkbAAAAAAAAAAAAAGAEaN4GAAAAAAAAAAAAABgBNVkXAGy6OjpWR5IkkaZp1qUAAAMkxwEg32Q5AOSbLAeAfJPlAJBvspyhSlLvHjZCLS3t0dXVnXUZAAAAAAAAAAAAAGyiamqK0dhYX9U1C1VdDQAAAAAAAAAAAACAPmneBgAAAAAAAAAAAAAYAZq3AQAAAAAAAAAAAABGQE3WBQCbrqamsVEsFqK7uyeam9uyLgcAGAA5DgD5JssBIN9kOQDkmywHgHyT5QyVJ28DAAAAAAAAAAAAAIwAzdsAAAAAAAAAAAAAACOgJusC+rJo0aK44447Yu7cudHS0hKtra3R0dERSZLEz372s6zLAwAAAAAAAAAAAAAYsI2qefv666+Piy++OObOnbvOn6VpGkmSbHD+d77znZg3b17p+ogjjoh3vOMdVa8TAAAAAAAAAAAAAGCgNorm7cWLF8fHPvaxeOCBByLipUbttfXXtL3GzjvvHBdddFHp/meffVbzNgAAAAAAAAAAAACwUShkXcA//vGPOProo+OBBx4oNW0nSVL2Uam3vvWtMW3atIh4qQF8/vz5MWfOnGGpGwAAAAAAAAAAAABgIDJt3l68eHF85CMfiebm5kjTNJIkiTRNI03TaGhoiF122SXGjBlT8XqFQiGOPPLIsid333TTTcNROgAAAAAAAAAAAADAgGTavP2pT30qlixZUnrCdpqm8YY3vCEuv/zyuOOOO+Lqq6+ObbbZZkBrHn744RERpSd233777VWvGwAAAAAAAAAAAABgoGqy2vi2226Lu+66q9S0nSRJnHnmmXHmmWcOad0ZM2bE5MmTY8mSJZGmaTzwwAPR3d0dxWKxSpUDAAAAAAAAAAAAAAxcZs3bl1xySUREqXH7He94x5Abt9fYfffd4+abb46IiK6urnjyySdjhx12qMraQPUsX96RdQkAwCDJcQDIN1kOAPkmywEg32Q5AOSbLGeoClls2tnZWXrqdkTEqFGj4jOf+UzV1t91113Lrp944omqrQ1Uz+rV3aUPACBf5DgA5JssB4B8k+UAkG+yHADyTZYzVJk0b99///2xatWqiIhIkiTe+MY3xmabbVa19SdNmlR23dzcXLW1AQAAAAAAAAAAAAAGI5Pm7UWLFpVd77PPPlVdf/z48RERpSd7t7W1VXV9AAAAAAAAAAAAAICBqsli0zVPwk7TNJIkicmTJ1d1/dra2rLrNU/5BjYutbXF0uf+CQkAyBc5DgD5JssBIN9kOQDkmywHgHyT5QxVJs3bnZ2dZde9m62HaunSpRHxcnN4Q0NDVdcHqqOhYUwUi4Xo7u6J5mZPyAeAPJHjAJBvshwA8k2WA0C+yXIAyDdZzlAVsti0sbGx7HrZsmVVXf+5557b4H4AAAAAAAAAAAAAACMtk+btzTbbLCIikiSJiIgnnniiquvffffdZdeTJ0+u6voAAAAAAAAAAAAAAAOVSfP2dtttV3Z9zz33VG3tJUuWxH333VdqDC8Wi7HnnntWbX0AAAAAAAAAAAAAgMHIrHl76tSpERGRpmk88MADVXv69qWXXhqrV6+OiJee7L3nnnvGmDFjqrI2AAAAAAAAAAAAAMBgZdK8HRFx4IEHRpqmpSdk/9d//deQ17z33nvj0ksvjSRJIk3TiIh405veNOR1AQAAAAAAAAAAAACGKrPm7Q9+8INRLBYj4qWnb990003x05/+dNDrPfDAA/HP//zP0dXVVRpraGiI4447bsi1AgAAAAAAAAAAAAAMVWbN29tuu20cddRRpadvp2ka//Vf/xVf/epXo729veJ1li5dGt/73vfife97XyxZsqS0VpIkceKJJ8a4ceOG8VUAAAAAAAAAAAAAAFSmJsvNP/3pT8ddd90VzzzzTKnp+vLLL4/f/va38da3vjX23XffaG9vjzRNS3Nuu+22aG1tjQULFsTdd98dd911V3R0dJQatiMikiSJvffeOz7ykY9k9dIAAAAAAAAAAAAAAMok6dqd0Rl44okn4rjjjotly5ZFRJQatdc0Yq891nu8r/vTNI1JkybFr3/965gyZcqw1s7waWlpj66u7qzLYJg1NY2NYrEQ3d090dzclnU5AMAAyHEAyDdZDgD5JssBIN9kOQDkmyzftNTUFKOxsb6qa2bevB0R8dhjj8XHP/7xmD9/flkTdiV6N3nvvPPO8YMf/CCmTZs2LLUyMjRvAwAAAAAAAAAAAJCl4WjeLlR1tUHacccd43//93/juOOOi5qamkjTNJIkqegj4qWm7WKxGMcee2xceeWVGrcBAAAAAAAAAAAAgI3ORvHk7bUtXrw4Lr300vjjH/8YCxcu7Pf+zTbbLA455JA49dRTY/r06SNQISPBk7cBAAAAAAAAAAAAyNJwPHl7o2veXtvChQvjnnvuieeeey5aW1tj2bJlMXr06GhsbIxJkybFXnvtFTNmzMi6TIaB5m0AAAAAAAAAAAAAsrTJNW+z6dK8vWmorx8VSZJEmqbR3t6ZdTkAwADIcQDIN1kOAPkmywEg32Q5AOSbLN+0DEfzdk1VVwMYgDFjaqNYLER3d48QA4CckeMAkG+yHADyTZYDQL7JcgDIN1nOUBWyLgAAAAAAAAAAAAAAYFOgeRsAAAAAAAAAAAAAYARo3gYAAAAAAAAAAAAAGAGatwEAAAAAAAAAAAAARkBN1gX0paWlJZ544olYvnx5LF++PLq6uoa03lFHHVWdwgAAAAAAAAAAAAAABmmjad6+//7749e//nXceuut8dxzz1V1bc3bAAAAAAAAAAAAAEDWMm/eXrhwYXz5y1+OW265JSIi0jSt6vpJklR1PQAAAAAAAAAAAACAwci0eXvevHlx0kknRWtra6lpu5rN1tVuBAcAAAAAAAAAAAAAGKzMmrdbW1vjgx/8YLS0tEREedO2pmvYNKxe3R3d3T3R0+N7HgDyRo4DQL7JcgDIN1kOAPkmywEg32Q5Q5VZ8/Z3vvOdaG5uXqdpe4cddojDDjssdtttt5g2bVqMHTs2amoyfUA4MEyWL+/IugQAYJDkOADkmywHgHyT5QCQb7IcAPJNljNUmXRFd3Z2xjXXXFNq3E7TNOrq6uLLX/5yHHnkkVmUBAAAAAAAAAAAAAAwrDJp3r7zzjtj5cqVkSRJpGkaSZLE9773vTjggAOyKAcAAAAAAAAAAAAAYNgVsth04cKFpc+TJInXv/71GrcBAAAAAAAAAAAAgFe0TJ683dLSEhFReur2gQcemEUZQMYmTKiLQiGJnp40li5dmXU5AMAAyHEAyDdZDgD5JssBIN9kOQDkmyxnqDJp3h49enTZ9ZQpU7IoA8hYsViIYrEQ3d09WZcCAAyQHAeAfJPlAJBvshwA8k2WA0C+yXKGqpDFpltssUXZ9apVq7IoAwAAAAAAAAAAAABgxGTSvL3HHntERESSJBERsWjRoizKAAAAAAAAAAAAAAAYMZk0b2+11VYxY8aM0vXs2bOzKAMAAAAAAAAAAAAAYMRk0rwdEXHSSSdFmqaRpmn8/e9/j7lz52ZVCgAAAAAAAAAAAADAsMusefud73xnzJw5MyIi0jSN//iP/4iOjo6sygEAAAAAAAAAAAAAGFaZNW8nSRLf/va3Y9q0aZGmacyZMydOP/30aG5uzqokAAAAAAAAAAAAAIBhk1nzdkTE5ptvHpdddlnsvPPOkaZp3HHHHfH2t789Lr744njxxRezLA0AAAAAAAAAAAAAoKqSNE3TrIvo6OiIc845J6644oro6emJJEkiImKbbbaJbbbZJsaPHx81NTWDWjtJkvj6179ezXIZAS0t7dHV1Z11GQyzpqaxUSwWoru7J5qb27IuBwAYADkOAPkmywEg32Q5AOSbLAeAfJPlm5aammI0NtZXd82qrjZIPT09sfnmm8f48eNj6dKlsaaf/Mknn4ynnnpq0Oumaap5GzZi7e2dkSQR2f8KCQAwUHIcAPJNlgNAvslyAMg3WQ4A+SbLGarMm7dvvfXW+PznPx9Lliwpja158nZExGAfDL72GsDGqaNjddYlAACDJMcBIN9kOQDkmywHgHyT5QCQb7Kcocq0efvaa6+Nf/u3f4uurq7SWO+ma03YAAAAAAAAAAAAAMArQWbN2/Pnz4/Pfe5z0dXVtd4nbY8dOzbGjh0bNTWZPyAcAAAAAAAAAAAAAGBIMuuKPvfcc6Ozs7PUuJ2maYwePTre/e53x2GHHRa77bZbjB8/PqvygBFQKLz8ixs9PekG7gQANjZyHADyTZYDQL7JcgDIN1kOAPkmyxmqTJq3lyxZErfcckskSRJpmkaSJLH99tvHxRdfHFtttVUWJQEZmDixPorFQnR390Rzc1vW5QAAAyDHASDfZDkA5JssB4B8k+UAkG+ynKEqZLHpvffeG93d3aXrUaNGxUUXXaRxGwAAAAAAAAAAAAB4xcqkeXvBggWlz5MkicMOOyymT5+eRSkAAAAAAAAAAAAAACMik+btjo6OiIhI0zQiIvbbb78sygAAAAAAAAAAAAAAGDGZNG+PHTu27HrixIlZlAEAAAAAAAAAAAAAMGIyad7eaqutyq6XL1+eRRkAAAAAAAAAAAAAACMmk+btvffeOwqFQiRJEhERTz31VBZlAAAAAAAAAAAAAACMmEyat5uammLmzJmRpmmkaRo333xzFmUAAAAAAAAAAAAAAIyYTJq3IyJOO+20iIhIkiTmz58f//d//5dVKQAAAAAAAAAAAAAAwy6z5u03vOEN8e53vzvSNI2IiLPOOiueeuqprMoBAAAAAAAAAAAAABhWSbqmezoDq1evjjPOOCP+8pe/RETE5MmT41vf+la87nWvy6okNhItLe3R1dWddRkMs2IxiYgkItLo7s7sKAIABkGOA0C+yXIAyDdZDgD5JssBIN9k+aalpqYYjY31VV0z0+btiIju7u741re+FT//+c8jTdNIkiRe//rXx7vf/e7Yf//9Y/LkyVmWR0Y0bwMAAAAAAAAAAACQpVdU8/ab3vSmsuvnn38+urq6Sg3ca4wZMybGjx8fNTU1g9onSZL405/+NKRaGXmatwEAAAAAAAAAAADI0nA0bw+uI7oKFixYEEmSrNOsvWZsjZUrV8bKlSsHvc/aawMAAAAAAAAAAAAAZCWz5u01+mqurlbDdUYPFQcqNHp0TekXNlat6sq6HABgAOQ4AOSbLAeAfJPlAJBvshwA8k2WM1SZNm9rroZN29ixo6NYLER3d48QA4CckeMAkG+yHADyTZYDQL7JcgDIN1nOUGXWvH300UdntTUAAAAAAAAAAAAAwIjLrHn77LPPzmprAAAAAAAAAAAAAIARV8i6AAAAAAAAAAAAAACATYHmbQAAAAAAAAAAAACAEaB5GwAAAAAAAAAAAABgBGjeBgAAAAAAAAAAAAAYAZq3AQAAAAAAAAAAAABGgOZtAAAAAAAAAAAAAIARUJN1AcCmq6cnjYie//9fACBP5DgA5JssB4B8k+UAkG+yHADyTZYzVEmaplV79yxcuLDP8alTp1Z873Doa382bi0t7dHV1Z11GQAAAAAAAAAAAABsompqitHYWF/VNavavD1jxoxIkqR8gySJhx56qKJ7h8P69mfjpnkbAAAAAAAAAAAAgCwNR/N2TVVXi4iB9IJXsW8cAAAAAAAAAAAAAGCjVvXm7bWfpt1fc/ZwP3lbczgAAAAAAAAAAAAAsLHw5G0gM+PGjY5CIYmenjRWrFiVdTkAwADIcQDIN1kOAPkmywEg32Q5AOSbLGeoqtq8ffbZZw/LvcAr06hRNVEsFqK7uycihBgA5IkcB4B8k+UAkG+yHADyTZYDQL7Jcoaqqs3bRx999LDcCwAAAAAAAAAAAACQd4WsCwAAAAAAAAAAAAAA2BRU9cnba1xwwQWlzydPnhzvec97hmMbAAAAAAAAAAAAAIDcGLbm7SRJIiJixowZmrcBAAAAAAAAAAAAgE1eYTgXT9N0OJcHAAAAAAAAAAAAAMiNYW3eBgAAAAAAAAAAAADgJZq3AQAAAAAAAAAAAABGgOZtAAAAAAAAAAAAAIARUJN1AcCma9WqrkiSiDTNuhIAYKDkOADkmywHgHyT5QCQb7IcAPJNljNUmreBzLS1rcq6BABgkOQ4AOSbLAeAfJPlAJBvshwA8k2WM1SFrAsAAAAAAAAAAAAAANgUaN4GAAAAAAAAAAAAABgBmrcBAAAAAAAAAAAAAEZATdYFAJuuxsb6KBQK0dPTEy0t7VmXAwAMgBwHgHyT5QCQb7IcAPJNlgNAvslyhsqTt4HMJEkShUISSZJkXQoAMEByHADyTZYDQL7JcgDIN1kOAPkmyxmqYX/y9gsvvBAXXHDBcG+zQWeeeWam+wMAAAAAAAAAAAAADHvz9osvvhgXXnjhcG+zQVk3b69evTrmzZsXjz32WCxbtiza2tqirq4uGhoaYptttondd9896urqqrZfT09PPPbYYzFv3rxYunRpLF++PEaPHh0NDQ2x1VZbxR577BENDQ1V2w8AAAAAAAAAAAAA6N+wN2+naTrcW2xQlo+lv+uuu+KKK66IG2+8MVatWrXe+4rFYrzmNa+JY489Ng4//PBB1zx37ty4/PLL4w9/+EO0tbWt974kSWLvvfeOf/qnf4p3vOMdMWrUqEHtBwAAAAAAAAAAAABUbtibt7Nsns6qcby1tTW+8pWvxO9///uK7u/u7o7Zs2fH7NmzY999942zzz47tt1224r36+joiHPPPTd+8YtfRE9PT7/3p2ka9913X9x3331x6aWXxte//vXYa6+9Kt4PAAAAAAAAAAAAABi4wnBvkKZpZh9ZaGlpife///0VN273ds8998Txxx8fjz32WEX3r1q1Kk4//fT4+c9/XlHjdm+PPvpovP/9748777xzwHMBAAAAAAAAAAAAgMoN+5O3J02aFMcdd9xwb7PR+OQnPxnz5s0rGxs9enS8613vikMPPTR22mmnGDduXLS3t8f8+fPjlltuiV/96lexYsWK0v3Nzc1x2mmnxbXXXhtjxozZ4H5f/vKX4/bbby8bKxaLccQRR8QRRxwRM2bMiPHjx0dHR0c888wz8de//jV++ctfxosvvli6f+XKlfHRj340rr/++pg0aVIV/hYAAAAAAAAAAAAAgN6SdBgeUT1jxoxIkiTSNI1dd901rrrqqmpvsVG64YYb4swzzywbmzp1avzoRz+KHXfccb3zFi5cGKeddlo88sgjZeP/8i//Eh/5yEfWO2/OnDnx7ne/u+wp4+PHj48f/vCHsd9++613Xmtra3z84x+Pv/3tb2Xj//RP/xRf/epX1ztvJLW0tEdXV3fWZTDMmprGRrFYiO7unmhubsu6HABgAOQ4AOSbLAeAfJPlAJBvshwA8k2Wb1pqaorR2Fhf1TULVV1tE9e7Sb1QKMSFF164wcbtiJcavC+++OKory//4l5zzTUbnHf11VdH7977s88+e4ON2xEREydOjAsvvDCmTJlSNn7ddddFZ2fnBucCAAAAAAAAAAAAAIOjebuKbr/99rLrAw88MHbbbbeK5m655Zbxzne+s2zs8ccfjyVLllS830477RSHHnpoRfuNGzcuTjzxxLKxFStWxNy5cyuaD9WwYkVHLF26Mlas6Mi6FABggOQ4AOSbLAeAfJPlAJBvshwA8k2WM1Sat6tk+fLl0d7eXjY2c+bMAa2x//77rzP2/PPPr/f+xYsXl13398Ttoe4H1dbZ2R2dnV3R2dmddSkAwADJcQDIN1kOAPkmywEg32Q5AOSbLGeoNG9XSe/G7YiIiRMnDmiNvu5fvXr1eu9fuXLliO4HAAAAAAAAAAAAAAye5u0qaWxsjEKh/K9z6dKlA1qjr/snTZq0wT1Hcj8AAAAAAAAAAAAAYPA0b1fJqFGjYqeddiob+/vf/z6gNXrfP2XKlJg2bdp6799jjz2qul9tbe06a8JwqqkplD4AgHyR4wCQb7IcAPJNlgNAvslyAMg3Wc5QeedU0dvf/vay67/85S8xb968iuY+//zz8Zvf/KZs7JhjjhnQfo888kjccsstFe3X3t4el112WdnY2972tqivr69oPlTD+PF10dg4NsaPr8u6FABggOQ4AOSbLAeAfJPlAJBvshwA8k2WM1Sat6vohBNOiC233LJ03d3dHWeccUY89dRTG5z3/PPPx+mnnx7t7e2lsa222ipOPvnkDc47/PDDY/fddy8b+8xnPhMPPPDABuetWLEiPvaxj8XChQtLY+PHj49PfvKTG5wHAAAAAAAAAAAAAAye5u0qGjduXHz3u98te3r1M888E0cddVScffbZcffdd8fSpUujq6srli9fHvfff3+cd955ceSRR8acOXNKcyZPnhwXX3xxjB07doP7FYvFOO+882Ly5MmlsdbW1jjhhBPi3//932P27NnR3NwcXV1dsWLFipg7d25cfPHFccQRR8Stt95amlNfXx8/+MEPYsqUKVX82wAAAAAAAAAAAAAA1pakaZpWe9EZM2ZEkiSlz6+66qpqb7FRe/jhh+NTn/pUPProowOalyRJHHbYYfGf//mfMWnSpIrnPfvss/HpT3867rnnnoGWGq997WvjS1/6Umy77bYDnjucWlrao6urO+syGGZNTWOjWCxEd3dPNDe3ZV0OADAAchwA8k2WA0C+yXIAyDdZDgD5Jss3LTU1xWhsrO//xoGsWdXV1jIMPeG5MWPGjPjtb38b1157bfzmN7+J22+/vd85r3vd6+ILX/hC7LTTTgPeb6uttopf/vKX8ec//zl+/etfx4033tjv3/9uu+0W//Ef/xH77rvvgPdbn4ULF8bChQsHNXfcuHExY8aMqtUCAAAAAAAAAAAAABubYXny9tpP2p4wYUIccsgh1d5iozd//vz4yU9+EjfeeGO0trZWNGfSpElx0kknxfvf//4YPXr0gPZbuHBhXHLJJXHdddfFCy+8UNGchoaGOOGEE+KUU06J8ePHD2i/vnzve9+LCy64YFBz99tvv7jiiitK193dPRu8v6urJ5YtW1k2Nn58XdTUFPrda+XKzli5cnXpOkkiGhvHVlTnsmUro6vr5dpGjSrGuHFj+p2Xpmm0tLSXjY0dOzpGj+7/9yc6O7tixYpVZWMTJ9ZHoZD0O7etbVWsWtVVui4Wk5gwobLfAGltbY+enpePhzFjaqO+flS/87q7e2Lp0vKvTUPDmKitLa5zb6GQRJIkkaZp9PSk0dGxOtrbO8vuaWqq7GuzfHlHrF798tPaa2uL0dDQ/9cmItb57af6+lExZkxtv/NWr+6O5cs7ysYmTKiLYrH/92F7e2d0dLz8PiwUkpg4sbKvzdKl7dHd/fLXZvTomhg7tv8zo6cnjdbW8vfhuHGjY9So/t+Hq1Z1RVtb+fuwsbG+9K8sbMiKFR3R2fny16amphDjx9f1Oy8ioqWlLdZOqbq62qir6/996Ix4ZZwRvTkjnBG9OSOyPSN65/janBHOiLU5IzbNM2JDnBHOiLU5I7I7IzaU5RHOCGfEupwRm9YZ0R9nhDOiN2fEyJ8Rm202boNZvoYzwhmxNmfEpnNG+DliXc4IZ8TaNoYzYs3TOvvL8ghnhDNiXc6IV/4ZEeHniL44I5wRvWV5Rqz95O00TZ0RvbwSz4hK3s8DMSxP3j766KOHY9lc6Orqiu9+97vx4x//OHp6Xn7z1dbWxh577BE77LBDNDQ0RFtbWzz55JNx//33x6pVL71hlixZEuecc05cc801ceGFF8bWW29d0Z6XXnppnHvuudHZ+fKBXSgUYsaMGTFjxoyYMGFCtLe3x4IFC+Kee+6J9vaX3tzLly+Piy66KH73u9/F+eefH3vuuWcV/yaGpr83el//81IoJBV9g/R1UA7+G6uyPfuqN0kq27evw2Pwr7WyeX2vVVm9ff0+SH/1JkkSxWJS5a/N4Oe+VE//c/v6JYPKvzbrjlVebxIRL/89V1pvRHXrLRQKFYXbS/WWG+6vjTPilXVGvLyHM6Iyzoj+OCOqe0asyfENr+WM6M0Z4Yzo3yvjjKiEM2JdzghnRP+qd0asL8udEc6IPmaHM2LDXolnxPo4I5wRfcwOZ8SGVfuMWDNWyf+X95rpjOjFGeGM6GP2OiN5OyP8HNE/Z8S6nBEjf0a8VEv/We6McEZUwhnRW/7PCD9HrMsZ4YzoY3Y4IzbMGTHyZ0SlhqV5e1PV3d0d//qv/xrXX399aSxJknjf+94Xp59+ekyaNGmdOcuWLYtLL700Lrrooujqeqlz/5FHHokPfOADceWVV8aUKVM2uOc3vvGNuOSSS8rG3v72t8e//Mu/xPTp09e5v6OjI371q1/Fd77znVIT98KFC+NDH/pQ/OIXv4hddtllwK97OPT35O2+vkl7etJ+50X0HYyVzFvPaoPeM00r23d9r7WvEOl/38rq7XutodW7vpBe+8kg1f3aDH5umlb29zS09+G6Y5XXWz45q3p7enoiTSv5waN6X9eRea3OiMEYjjNi3T2cEZVxRvRn43kf5vuM6O9pndWs1xnRe491x5wRFazkjFiHnyOcEX3M7rWWM6K3jed9OPQzor8sd0Y4I/qY3WstZ0RvG8/70M8Rfde27pgzovce6445IypYKaMzYs1TvSr5//JeM50Rfda27pgzovce6445IypYyc8R63BGOCP6mN1rrU3njHiplv6zfON5Hzoj+q5t3TFnRO891h1zRlSwkp8j1uGMcEb0MbvXWs6I3jae92H+z4hqN3MnaV+vlkG56KKL4tvf/nbpOkmS+Na3vhXveMc7+p07e/bsOPXUU2P16pcfM3/ggQfGj3/84/XO+f3vfx//+q//Wjb2yU9+Mk477bR+93v44YfjxBNPjGXLlpXGdt555/jNb34TtbX9/1MHfVm4cGEsXLhwUHPHjRsXM2bMKF23tLRHV1f3BmbwSrD2Px/R+5/dAAA2bnIcAPJNlgNAvslyAMg3WQ4A+SbLNy01NcVobKyv7ppVXW0T1tzcHN///vfLxt773vdW1LgdEfH6178+Pv7xj8c555xTGrv11lvj7rvvjpkzZ65z/+rVq+Ob3/xm2djBBx9cUeN2RMSMGTPiS1/6UnziE58ojT3yyCNx7bXXxlFHHVXRGr1NnTo1pk6dOqi5AAAAAAAAAAAAAPBKV93neG/Crrnmmujo6ChdJ0kSp5566oDWOPHEE6OhoaFs7Kqrrurz3ltuuSWef/75srHTTz99QPu99a1vje22265s7Oqrrx7QGjAULS1tsWTJ8mhp8dtHAJA3chwA8k2WA0C+yXIAyDdZDgD5JssZKs3bVXLnnXeWXc+YMSOmTJkyoDXGjBkT+++/f9nYvffe2+e9d9xxR9n1hAkTYu+99x7QfkmSxAEHHFA2dv/990eapgNaBwYrTV/+AADyRY4DQL7JcgDIN1kOAPkmywEg32Q5Q6V5u0oWLFhQdr3VVlsNap3e8xYvXlzRftOmTYskSYa8X3t7eyxbtmzA6wAAAAAAAAAAAAAAG6Z5u0o6OjrKrkePHj2oderq6squOzs7R3S/De0JAAAAAAAAAAAAAAxeTdYFvFKMHz++7Lq1tXVQ6zQ3N5ddT5w4saL9WlpaqrLfhvaEaqurq40kSSJN01i5cnXW5QAAAyDHASDfZDkA5JssB4B8k+UAkG+ynKHSvF0lkyZNKrt+8MEHo6enJwqFgT3c/P777y+7njx5ckX7Pf3009Ha2jrgxuve+02cODFqa2sHtAYMVl3dqCgWC9Hd3SPEACBn5DgA5JssB4B8k+UAkG+yHADyTZYzVAPrLGa99tlnn7Lr1tbWuOmmmwa0xoMPPhiPPPJI2dj+++/f57377rtv2XVPT09cc801A9pv8eLFMXv27Ir2AwAAAAAAAAAAAACGRvN2lcyaNWudsW9961uxfPnyiuZ3dnbGl7/85YrWjYh43etet84Tsn/wgx/EokWLKtovTdP4yle+EqtWrapoPwAAAAAAAAAAAABgaDRvV8kuu+wSb3zjG8vGnnzyyfjwhz8cixcv3uDc1tbW+OhHPxr3339/2fjee+8dr3/96/uc09jYGMccc0zZWHNzc3zwgx+M+fPnb3C/jo6O+NznPhc33HBD2fiWW24Z73znOzc4FwAAAAAAAAAAAAAYnCRN0zTrIl4pHn300Tj22GOjvb29bLy+vj6OOeaYOPjgg2OHHXaIcePGRVtbWzz55JNx6623xn//93/H0qVLy+aMGjUqLrvssnjVq1613v1eeOGFOProo+OFF14oG6+trY13vOMd8eY3vzlmzJgRDQ0N0dHREQsWLIjbbrstfvnLX8bzzz9fNidJkjj//PPjsMMOG9pfQpW0tLRHV1d31mUwzJqaxkaxWIju7p5obm7LuhwAYADkOADkmywHgHyT5QCQb7IcAPJNlm9aamqK0dhYX9U1NW9X2S233BJnnHFGrF69etBrFIvFOOecc+KII47o9945c+bEiSeeGG1tQzsAPvOZz8TJJ588pDWqSfP2pkGIAUB+yXEAyDdZDgD5JssBIN9kOQDkmyzftAxH83ahqqtthG6//fYR3W/WrFnxy1/+MrbbbrtBzZ82bVpcdtllFTVuR0TsvvvucdVVV8Xee+89qP0aGxvjwgsv3KgatwEAAAAAAAAAAADglSiz5u1vfOMbw77HvffeG2ecccaw79PbnnvuGddcc01861vfiv322y9qamo2eH+hUIg999wzvvrVr8Yf/vCH2G+//Qa03zbbbBNXXnllXHjhhXHggQfGqFGj+p2z0047xec+97m44YYb4tBDDx3QfgAAAAAAAAAAAADAwG24q3gYXXrppTF9+vR473vfOyzrz507N0499dRYuXLlsKzfn1GjRsU73/nOeOc73xkrV66MOXPmxNNPPx3Lli2L9vb2qK+vj4aGhpg6dWrsueeeMW7cuCHtVygU4tBDD41DDz00Ojs7Y+7cufHEE0/EsmXLoq2tLUaPHh0NDQ0xZcqU2GuvvWLixInVeaEAAAAAAAAAAAAAQEWSNE3TLDaeMWNGFIvFuPDCC+Oggw6q6trz58+PE088MZqbmyNJkpg7d25V12f4tbS0R1dXd9ZlMMzGj6+LQiGJnp40li3L5hctAIDBkeMAkG+yHADyTZYDQL7JcgDIN1m+aampKUZjY31V18y0eTsioq6uLn7xi1/E7rvvXpV1n3nmmTjhhBPihRdeiIjQvJ1TmrcBAAAAAAAAAAAAyNJwNG8XqrraACVJEitXrozTTjstFi5cOOT1nnvuufjABz4QL7zwQiRJUoUKAQAAAAAAAAAAAACqI7Pm7QkTJkTESw3cS5YsiVNPPTWWL18+6PVefPHFOOmkk2LhwoWRJEmkaRpJksTRRx9drZIBAAAAAAAAAAAAAAYts+btCy+8MGpra0vX8+fPjzPPPDO6uroGvNbSpUvjgx/8YDz55JNljdtvectb4mtf+1o1ywYAAAAAAAAAAAAAGJTMmrdnzpwZX//61yMiSg3Xd955Z3z+858f0DptbW1xyimnxCOPPBJJkpTWmzVrVpx77rmlMWDjM358XUycWB/jx9dlXQoAMEByHADyTZYDQL7JcgDIN1kOAPkmyxmqzJq3IyLe/va3x8c//vHSk7LTNI3f/e538d3vfrei+R0dHXH66afHP/7xj1KTdpqm8epXvzrOP//8KBaLw1k+MEQ1NYWorS1GTU2mRxEAMAhyHADyTZYDQL7JcgDIN1kOAPkmyxmqzN85p59+ehxzzDFlDdw//OEP49e//vUG561evTrOOOOMuOuuu8oat1/1qlfFD3/4wxg1atRIlA8AAAAAAAAAAAAAUJHMm7cjIr70pS/FG97whrIG7i9+8Ysxe/bsPu/v7u6OT37yk3HbbbeVNW7PmDEjfvSjH0VdnUfRAwAAAAAAAAAAAAAbl42iebtYLMb5558fO++8c0REJEkSXV1d8bGPfSweeeSRsnvTNI3Pfe5zccMNN5Q1bm+//fbx05/+NBoaGka8fgAAAAAAAAAAAACA/mwUzdsREWPHjo2LL744Jk+eHBEvNXCvWLEiTjvttFi8eHHpvi9+8YtxzTXXlDVub7XVVnHJJZdEU1NTJrUDAAAAAAAAAAAAAPRno2nejojYYost4uKLL476+vqIeKmBe9GiRXH66adHW1tbfPOb34xf/epXZY3bm2++eVxyySUxZcqULEsHAAAAAAAAAAAAANigjap5OyJixowZ8Z3vfCeKxWJp7OGHH44jjzwyLr300tJYmqbR1NQUl1xySUyfPj2DSgEAAAAAAAAAAAAAKrfRNW9HRLzxjW+M//iP/4g0TSNJkkjTNBYuXFh2PX78+PjJT34SO+ywQ9blAgAAAAAAAAAAAAD0a6Ns3o6IeM973hOnnHJKqWF7zUeaplFXVxcXXXRR7LrrrlmXCQAAAAAAAAAAAABQkZqsC9iQT33qU7FgwYK47rrrSo3bo0aNiu9///uxzz77ZF0eMEQrV3aWvrcBgHyR4wCQb7IcAPJNlgNAvslyAMg3Wc5QJelG/u7p7OyMD37wg/H3v/89ampq4nvf+14cfPDBWZfFMGtpaY+uru6sywAAAAAAAAAAAABgE1VTU4zGxvqqrlnV5u1dd921WkutI03TSJJkwPOSJImHHnpoGCpiOGneBgAAAAAAAAAAACBLw9G8XVPNxYb7Id4b+UPCAQAAAAAAAAAAAADWq6rN2xExqKdjDxfN3rBxW/u48O0KAPkixwEg32Q5AOSbLAeAfJPlAJBvspyhqnrztoZpoFKNjWOjWCxEd3dPNDe3ZV0OADAAchwA8k2WA0C+yXIAyDdZDgD5JssZqqo2b5955pnVXA4AAAAAAAAAAAAA4BVD8zYAAAAAAAAAAAAAwAgoZF0AAAAAAAAAAAAAAMCmQPM2AAAAAAAAAAAAAMAI0LwNAAAAAAAAAAAAADACNG8DAAAAAAAAAAAAAIwAzdsAAAAAAAAAAAAAACNA8zYAAAAAAAAAAAAAwAioyWrj1atXxzHHHBMrVqyIiIgkSeLnP/95TJ06ddBrLliwIE466aTo6emJiIjJkyfHlVdeWZV6AQAAAAAAAAAAAACGIrPm7RtuuCHmzZtXuj7ooIOG1LgdETFt2rTYYYcd4uabb46IiIULF8Ytt9wSs2bNGtK6wPBYtmxl1iUAAIMkxwEg32Q5AOSbLAeAfJPlAJBvspyhKmS18fXXX1/6PEmSeM973lOVdY877rjSmhER1157bVXWBaqvq6un9AEA5IscB4B8k+UAkG+yHADyTZYDQL7JcoYqk+btnp6e+Nvf/lZqsB47dmwccMABVVn7DW94QzQ0NERERJqmMXv27KqsCwAAAAAAAAAAAAAwFJk0bz/xxBOxbNmyiHjpCdn77LNP1NbWVmXt2tra2G+//SJN04iIePHFF+OZZ56pytoAAAAAAAAAAAAAAIOVWfP22vbYY4+qrr/bbruVXT/++ONVXR+ojlGjijFqVE2MGlXMuhQAYIDkOADkmywHgHyT5QCQb7IcAPJNljNUNVlsunjx4oiISNM0kiSJqVOnVnX9Lbfcsux60aJFVV0fqI5x48ZEsViI7u6eaG5uy7ocAGAA5DgA5JssB4B8k+UAkG+yHADyTZYzVJk8ebutrfzN2tDQUNX116yXJEmf+wEAAAAAAAAAAAAAjLRMmrcLhfJtV61aVdX1e6/X3d1d1fUBAAAAAAAAAAAAAAYqk+btxsbGsuuWlpaqrr9mvTRNIyJiwoQJVV0fAAAAAAAAAAAAAGCgMm3eTpIkIiL+8Y9/VHX9Bx98sOy6qampqusDAAAAAAAAAAAAAAxUJs3bO+ywQ+nzNE3j9ttvj56enqqs3d3dHbNnzy41hkdETJ8+vSprAwAAAAAAAAAAAAAMVibN29tss01sueWWpeuWlpb43//936qs/etf/zqam5tL101NTTFjxoyqrA0AAAAAAAAAAAAAMFiZNG9HRLzuda+LNE0jSZJI0zTOP//8WLx48ZDWXLx4cZx//vmlNZMkiTe84Q1VqhgAAAAAAAAAAAAAYPAya95+//vfH0mSlK6XLFkSH/7wh+PFF18c1Hpr5i9ZsqRs/H3ve9+Q6gQAAAAAAAAAAAAAqIbMmrdnzJgRhxxySOkJ2UmSxCOPPBJHHnlkXHfddZGmaUXrpGkaf/jDH+Id73hHPProo2VP3Z41a1bstddew/xKgMFK0zR6etKKv98BgI2HHAeAfJPlAJBvshwA8k2WA0C+yXKGKkkzfPc8++yzccwxx8TSpUsjIkpv5CRJYtq0afH2t7899t1339hll11i/PjxUVdXFytXroxly5bFww8/HPfcc09ce+21sWDBgrK5aZrGxIkT43/+539i+vTpWb08hqClpT26urqzLgMAAAAAAAAAAACATVRNTTEaG+urumamzdsREX/729/ilFNOie7ulxt1127E7k/ve9M0jdra2vjpT38a+++//zBUzEjQvA0AAAAAAAAAAABAloajebtQ1dUG4bWvfW1ccMEF0dDQUBpLkqT0BO3+PtbcG/FS4/aECRPi+9//vsZtAAAAAAAAAAAAAGCjknnzdkTEQQcdFP/zP/8Te+65Z6kpO+LlJu4NfUREac7MmTPjqquuigMPPDDLlwMAAAAAAAAAAAAAsI4kXdMpvZH461//Gj/60Y/i7rvvju7u7n7vr6mpide+9rXx4Q9/OF7zmteMQIWMhJaW9ujq6v/rT76NHTs6kiQiTSPa2lZlXQ4AMAByHADyTZYDQL7JcgDIN1kOAPkmyzctNTXFaGysr+6aVV2tCg444IA44IADYsWKFfH3v/897r333njxxRdj6dKlsWLFihg3blxMnDgxJk2aFK961ativ/32i7Fjx2ZdNjAIo0fXRLFYiO7uHiEGADkjxwEg32Q5AOSbLAeAfJPlAJBvspyh2uiat9cYN25czJo1K2bNmpV1KQAAAAAAAAAAAAAAQ1bIugAAAAAAAAAAAAAAgE2B5m0AAAAAAAAAAAAAgBGgeRsAAAAAAAAAAAAAYARo3gYAAAAAAAAAAAAAGAGatwEAAAAAAAAAAAAARoDmbQAAAAAAAAAAAACAEVCTdQFr6+npib/+9a/x97//Pe6///5YtGhRLFu2LJYvXx7d3d2DWjNJknjooYeqXCkAAAAAAAAAAAAAwMBsFM3bPT098bOf/Swuu+yyWLRoUWk8TdMMqwKGW2dnVxQKSfT0+F4HgLyR4wCQb7IcAPJNlgNAvslyAMg3Wc5QZd68vXjx4vjEJz4R9957b1mzdpIkkSTJkNbW/A0btxUrVmVdAgAwSHIcAPJNlgNAvslyAMg3WQ4A+SbLGapMm7eXL18e73//++Ppp5+ONE1LzdppmpYar9ce623t5m6N2gAAAAAAAAAAAADAxizT5u3Pfvaz8dRTT5Wesp2madTV1cWBBx4Y22yzTVx11VXx4osvlhq7zzjjjOjo6IilS5fGM888Ew888EC0t7dHRJTmNzQ0xPHHHx+jRo3K8qUBAAAAAAAAAAAAAJRJ0oweWf3AAw/EscceW2q6TpIkDjjggPjmN78ZTU1NERFx1FFHxbx580p/Pnfu3LI1enp64uabb45LLrkk7rrrrtKTuHfccce46KKLYurUqSP+uqiOlpb26OrqzroMAAAAAAAAAAAAADZRNTXFaGysr+qahaquNgA/+clPSp8nSRJ77LFHXHjhhaXG7UoUCoU45JBD4rLLLouvfOUrMXr06IiIePTRR+O9731vPP/881WvG6ieiRPro6lpbEycWN2DDQAYfnIcAPJNlgNAvslyAMg3WQ4A+SbLGapMmrfTNI3Zs2eXnrodEfGFL3whRo0aNeg1/+mf/inOP//8qKmpiSRJYtGiRfHxj3+8WiUDw6BQSKJYLEShkGRdCgAwQHIcAPJNlgNAvslyAMg3WQ4A+SbLGapMmrfnzZsXy5cvL13vsMMO8apXvWrI677xjW+M0047rdQQft9998U111wz5HUBAAAAAAAAAAAAAIYqk+btxx9/vPR5kiTxmte8pqJ53d3d/d7z4Q9/OCZOnFh6qvdll1026DoBAAAAAAAAAAAAAKolk+btZcuWRUSUnpC9ww479HlfkpQ/Un7VqlX9rj169Og4+OCDS2s/+OCD8eKLLw6lXAAAAAAAAAAAAACAIavJYtM1zdtrTJgwoc/7Ro8eXWrCjojo6OiI+vr6ftfffffd46qrripdP/jggzFr1qxBVgsMh5WruuKZxcujs6snRtUUotDTE3WjMzmSAIABkuMAkG+yHADyTZYDQL7JcgDIN1lONWTyjikUyh/4XVtb2+d948aNK7t+/vnno6mpqd/1e9/z7LPPDrBCYDikaRoPP90af77n2bj3kSXRs9YvZxSSJPbdeVIcvO9WMWPries8eR8AyJYcB4B8k+UAkG+yHADyTZYDQL7Jcqotk+bt3k3ZbW1tfd7X0NBQdr1gwYKYMWNGv+t3dXVFRJS+Cda3PjBynnpuefz49w/FgiV9fz/2pGncPe+FuHveCzFt0tg45e27xTZbNPR5LwAwsuQ4AOSbLAeAfJPlAJBvshwA8k2WMxwK/d9SfVOmTImIl5urly9f3ud92267bdn1Aw88UNH6Tz/9dES89NsOERHFYnEwZQJVMueJ5vjG5fesN8B6W7CkLb5x+T0x54nmYa4MAOiPHAeAfJPlAJBvshwA8k2WA0C+yXKGSybN29tvv33Z9VNPPdXnfbvssktEvNTknaZp3HrrrRWt/+c//7ns0fONjY2DrBQYqqeeWx4X/OYfsWp194DmrVrdHRf85h/x1HN9/3IHADD85DgA5JssB4B8k+UAkG+yHADyTZYznDJp3p4+fXrU1dWVrufPn9/nffvss08UCi+XOHfu3Lj99ts3uPYf//jHeOihh8rGdtxxxyFUCwxWmqbx498/NOAAW2PV6u748bUPlZ6iDwCMHDkOAPkmywEg32Q5AOSbLAeAfJPlDLdMmrcLhULsu+++kaZppGka//jHP6K7e903+ZQpU2L//fePNE1LT9/+9Kc/HQ8++GCf6/7lL3+Jz33uc2VP3R4/fnzsueeew/ZagPV7+OnWiv/JiPVZ8EJbzHu6tToFAQAVk+MAkG+yHADyTZYDQL7JcgDIN1nOcKvJauPXvOY1cdttt0VERHt7e9x7770xc+bMde47/vjj44477oiIiCRJYsmSJXHcccfFAQccEDNnzowJEyZES0tL3HbbbXHnnXeWNXonSRLHHntsWTM3MHJuuufZqqzzf3c9E1Mnj63KWgBAZf7vrqertI4cB4AsyHIAyDdZDgD5JssBIN+qleV/vndBzNimsSpr8cqSpBk9l/3JJ5+Mww8/vNRY/b73vS++8IUv9HnvBz7wgbjjjjtK965pzO5t7fE0TWPzzTeP3/72t9HY6M2fNy0t7dHVNbh/coCNw8pVXfHP590aPf7pBwAAAAAAAAAAADYxhSSJ7/3LgVE3OrPnLFMFNTXFaGysr+qahaquNgDbbrtt7LrrrpGmaaRpGtdcc010dnb2ee9//dd/xdZbbx1r+szXPFm798fajdt1dXVx3nnnadyGjDQvX6VxGwAAAAAAAAAAgE1ST5pGy/JVWZfBRijTdv5LLrkk2traSteFQt+95Jtvvnlcdtll8dnPfjZuv/32iIj1Pnk7ImLrrbeO7373u7HrrrsOQ9VAJVZ1enI6AAAAAAAAAAAAm64OfXT0IdPm7YkTJ8bEiRMrunfKlClxySWXxC233BK///3vY/bs2fHiiy+W/ryuri723XffeOtb3xpHHXVU1NR4zDxkafSoYtYlAAAAAAAAAAAAQGbG6KOjD7nrcJ41a1bMmjUrIiI6OzujtbU16uvrY9y4cRlXBqytqWF0FJIkev7/E/GHolBI4usffk2MGZ27IwsAcqljVVd8/uK/Rc/QY1yOA0AGZDkA5JssB4B8k+UAkG/VzPJiIYnGhtFDX4hXnFz/dDdq1KjYfPPNsy4D6EPd6JrYd+dJcfe8F4a81r47T47NG+urUBUAUInx9aNi350ny3EAyClZDgD5JssBIN9kOQDkWzWzfJ+dJ0edX8KiD4WsCwBeuQ7ed6uqrHPIPtOqsg4AUDk5DgD5JssBIN9kOQDkmywHgHyT5Qw3zdvAsJmx9cSYNmnskNaYNnls7LL1xOoUBABUTI4DQL7JcgDIN1kOAPkmywEg32Q5w03zNjBskiSJU96+W4yuLQ5q/ujaYpzytt0iSZIqVwYA9EeOA0C+yXIAyDdZDgD5JssBIN9kOcNN8zYwrLbZoiHOfNeeAw6y0bXFOPNde8Y2WzQMU2UAQH/kOADkmywHgHyT5QCQb7IcAPJNljOckjRN06yLGIjW1taYN29etLS0RLFYjEmTJsW2224bjY2NWZdGFbW0tEdXV3fWZVBFTz23PH78+4diwZK2fu+dNnlsnPK23QQYAGwk5DgA5JssB4B8k+UAkG+yHADyTZZTU1OMxsb6qq6Zm+bt3/72t3HZZZfFQw89FL1LLhQK8apXvSqOO+64OPLIIzOqkGrSvP3KlKZpzHu6Nf58z7NxzyNLomet7+ViIYl9dp4ch+wzLXbZeqJ/MgIANjJyHADyTZYDQL7JcgDIN1kOAPkmyzdtuW7efuCBB+KPf/xjzJ07N1544YVI0zQaGxtj1113jTe/+c2x//779znv+eefj3/913+Nu+++OyJincbttSVJEjNnzozzzjsvNttss2F5HYwMzduvfCtXdcXSts7o6OyKMaNqYsLYUVE3uibrsgCACshxAMg3WQ4A+SbLASDfZDkA5Jss3/Tksnl78eLFcdZZZ8XNN99cGluz5dq/YTBz5sz4xje+EdOmTSuNvfDCC/G+970vnn766T7nrG3tl7HjjjvGz372Mw3cOaZ5GwAAAAAAAAAAAIAs5a55e+HChfG+970vFi1atMEnZq+x5ZZbxi9/+cvYYostIiLigx/8YNx+++0Deox8mqaRJEm84Q1viB//+MeDrp1sad4GAAAAAAAAAAAAIEvD0bxdqOpqa+nq6orTTjstFi5cWGqo3tBHRMSiRYvirLPOioiI66+/fp3G7TRNI03TqKuri8mTJ8eYMWNKY2skSRJpmsZtt90Wf/jDH4br5QEAAAAAAAAAAAAADEjNcC38s5/9LB599NF1mq/7sqaBO03TuOWWW+LRRx+NSy+9tGze9OnT49RTT42DDjooJk+eXPqzxYsXx5///Of40Y9+FAsXLiztl6Zp/OQnP4kjjjhieF4gMGRjxtRGkkSkaURHx+qsywEABkCOA0C+yXIAyDdZDgD5JssBIN9kOUOVpOvrqB6Cnp6emDVrVixZsqQ0lqZp7LLLLnHcccfFnnvuGePGjYuWlpa466674vLLL4/Fixe/VFCSxHvf+964/PLLS3Nf//rXxwUXXBB1dXXr3bOtrS0++tGPxh133FFqBE+SJH73u9/FjjvuWO2XyDBraWmPrq7urMtgmDU1jY1isRDd3T3R3NyWdTkAwADIcQDIN1kOAPkmywEg32Q5AOSbLN+01NQUo7GxvqprFqq62v93++23xwsvvBARLz9t+9hjj42rrroqjj/++Nhjjz1i2223jX322SdOPfXUuO666+LVr351af7//M//RJqmkaZpbLbZZvGd73xng43bERFjx46N7373u7HZZpuVjf/1r3+t8qsDAAAAAAAAAAAAABi4YWnevuOOO8qud9pppzjrrLOiUOh7u/r6+jjvvPNi/PjxERGxatWqiHjpKdzHH398abw/EydOjOOPP7701O2IiDlz5gz2ZQAAAAAAAAAAAAAAVM2wNG/PnTs3IqLURP2BD3xgvY3bazQ1NcU73/nOssbriIi3vOUtA9r7sMMOK32epmk88sgjA5oPAAAAAAAAAAAAADAchqV5+8knnyxrwJ41a1ZF83rfN3r06Nhhhx0GtPeOO+4Yo0ePLl23trYOaD4AAAAAAAAAAAAAwHAYlubt5cuXlz4fP358TJo0qaJ5O+20U9l1U1NTWRN4JQqFQmy22WZ91gIAAAAAAAAAAAAAkJVhad5esWJF6fOJEydWPK/3vePGjRvU/mPHji193tHRMag1AAAAAAAAAAAAAACqaViat7u6ukqf19fXVzxv9OjRZdfFYnFQ+689L03TQa0BAAAAAAAAAAAAAFBNw9K8DQAAAAAAAAAAAABAuZqsCwA2Xd3dPZGmafT0eEI+AOSNHAeAfJPlAJBvshwA8k2WA0C+yXKGSvM2kJmlS1dmXQIAMEhyHADyTZYDQL7JcgDIN1kOAPkmyxmqQtYFAAAAAAAAAAAAAABsCjRvAwAAAAAAAAAAAACMAM3bAAAAAAAAAAAAAAAjoGa4N1i6dGlcffXVIzp36dKlg9oPGFkNDWOiUEiipyeN5cs7si4HABgAOQ4A+SbLASDfZDkA5JssB4B8k+UMVZKmaVrtRWfMmBFJkkSappEkyYDmrl3OQOf2tVaSJDF37twhrcPIa2lpj66u7qzLYJg1NY2NYrEQ3d090dzclnU5AMAAyHEAyDdZDgD5JssBIN9kOQDkmyzftNTUFKOxsb66a1Z1tT4MpTd8KHOH2vgNAAAAAAAAAAAAAFBNw9q8rYEaAAAAAAAAAAAAAOAlw9a8PZSnZgMAAAAAAAAAAAAAvNIMS/P2mWeeORzLAgAAAAAAAAAAAADkluZtAAAAAAAAAAAAAIARUMi6AAAAAAAAAAAAAACATYHmbQAAAAAAAAAAAACAEaB5GwAAAAAAAAAAAABgBNRkXQCw6eroWB1JkkSaplmXAgAMkBwHgHyT5QCQb7IcAPJNlgNAvslyhipJvXvYCLW0tEdXV3fWZQAAAAAAAAAAAACwiaqpKUZjY31V1yxUdTUAAAAAAAAAAAAAAPqkeRsAAAAAAAAAAAAAYATUVHOxhQsXVnO5qpk6dWrWJQAAAAAAAAAAAAAAm7iqNm8fcsghkSRJNZccsiRJ4qGHHsq6DKAPTU1jo1gsRHd3TzQ3t2VdDgAwAHIcAPJNlgNAvslyAMg3WQ4A+SbLGaqqNm9HRKRpWu0lAQAAAAAAAAAAAAByr+rN2xvTk7c1kgMAAAAAAAAAAAAAG4uN7snbvZu/N7TeQO4FAAAAAAAAAAAAAMhSVZu3zz777EHNW7BgQfz4xz+OVatWRcTLTdjbbrtt7L777rH99ttHQ0ND1NXVxcqVK2P58uXx+OOPx5w5c+LJJ5+MiJcbuevq6uLkk0+OadOmDf0FAQAAAAAAAAAAAABUSVWbt48++ugBz7n55pvjq1/9aqxatSrSNI2ampo47rjj4rjjjosdd9yx3/mPPfZY/Pd//3f88pe/jO7u7li5cmVccskl8e1vfztmzZo1mJcBAAAAAAAAAAAAAFB1hSw3v/XWW+PMM8+M9vb2SNM0ttlmm7j66qvj3//93ytq3I6I2HHHHeMLX/hCXH311bHttttGRERbW1ucccYZceuttw5j9QAAAAAAAAAAAAAAlcusebu5uTk+/elPR1dXV6lx+4orrqi4abu3HXfcMX7xi1/ENttsE0mSRFdXV3zqU5+K5ubmKlcOAAAAAAAAAAAAADBwmTVvX3zxxdHa2hoREUmSxNe+9rXYbLPNhrTmZpttFl/72tdKay5btix++MMfDrVUAAAAAAAAAAAAAIAhy6R5u7u7O6666qpIkiSSJIm99torZs6cWZW1Z86cGXvvvXekaRppmsbVV18d3d3dVVkbAAAAAAAAAAAAAGCwarLY9MEHH4ylS5dGkiQREXHQQQdVdf1Zs2bFfffdFxERy5cvjwcffDD23nvvqu4BDN3y5R1ZlwAADJIcB4B8k+UAkG+yHADyTZYDQL7JcoYqk+btRx99NCIi0jSNJEliyy23rOr6vdd79NFHNW/DRmj1ak/FB4C8kuMAkG+yHADyTZYDQL7JcgDIN1nOUBWy2LS1tbXsuqamuj3ka9Zb82TvlpaWqq4PAAAAAAAAAAAAADBQmTRv97Z48eJhWS9N04h4uYkbAAAAAAAAAAAAACArmTRvb7755hHxclP17Nmzq7p+7/UmT55c1fWB6qitLZY+AIB8keMAkG+yHADyTZYDQL7JcgDIN1nOUGXSvL3VVluVPk/TNO644454/PHHq7L2/Pnz44477ih72vba+wEbj4aGMTFxYn00NIzJuhQAYIDkOADkmywHgHyT5QCQb7IcAPJNljNUmTRvv+pVr4qmpqbSdVdXV3z+85+Pzs7OIa3b2dkZX/jCF6Krq6s01tTUFPvss8+Q1gUAAAAAAAAAAAAAGKpMmrcLhUIcccQRkaZp6QnZ999/f5x88snR0tIyqDWXLl0aH/7wh+O+++6LJElKa7/1rW+NQiGTlwkAAAAAAAAAAAAAUJJZV/MZZ5wREydOjIgoNVvffffd8da3vjUuv/zyWLFiRUXrrFixIi6//PI4/PDD48477yz7swkTJsQZZ5xR7dIBAAAAAAAAAAAAAAYsSdM0zWrza6+9Nj71qU+VrteUkiRJjBo1Kl7zmtfE7rvvHtttt100NDREXV1drFy5MpYvXx5PPPFEzJkzJ+68885YtWpV2dw0TaNQKMQ555wTRxxxRCavjaFpaWmPrq7urMtgmDU1jY1isRDd3T3R3NyWdTkAwADIcQDIN1kOAPkmywEg32Q5AOSbLN+01NQUo7GxvrprVnW1AXrb294WK1asiLPOOisiXmq8jnipiXvVqlVx6623xq233rrBNdZu2l5znSRJfPGLX9S4DQAAAAAAAAAAAABsNApZF/Ce97wnzjvvvJg4cWJZI/aaJ2j397Hm3oiXGrcbGxvju9/9brznPe/J8mUBAAAAAAAAAAAAAJTJvHk7IuItb3lLXHvttXH00UdHbW3tOo3ZG/pYc29tbW28613vimuvvTYOO+ywrF8SAAAAAAAAAAAAAECZmqwLWKOpqSnOPvvs+MxnPhO/+c1v4i9/+Uv84x//iPb29vXOqa+vjz333DPe+MY3xrve9a5obGwcwYoBAAAAAAAAAAAAACq30TRvr9HY2Bgnn3xynHzyyZGmaTz++OPR3Nwcy5Yti7a2thg7dmyMHz8+mpqaYvvtt48kSbIuGQAAAAAAAAAAAACgX0mapmnWRUBvLS3t0dXVnXUZAAAAAAAAAAAAAGyiamqK0dhYX9U1C1VdDQAAAAAAAAAAAACAPmneBgAAAAAAAAAAAAAYAZq3AQAAAAAAAAAAAABGQE3WBWzIihUroqWlJVpaWmLVqlUREbH//vtnXBVQLfX1oyJJkkjTNNrbO7MuBwAYADkOAPkmywEg32Q5AOSbLAeAfJPlDNVG17x90003xQ033BB33nlnLFiwoOzPkiSJhx56aL1zH3vssVKTd0TElltuGU1NTcNWKzA0Y8bURrFYiO7uHiEGADkjxwEg32Q5AOSbLAeAfJPlAJBvspyh2miat2+55ZY455xz4rHHHouIiDRNB7zGlVdeGZdffnnp+m1ve1ucc845VasRAAAAAAAAAAAAAGCwClkXkKZpnHvuuXH66afHY489FmmaRpqmkSRJ2UclTjrppCgUCqU1brzxxlixYsUwvwIAAAAAAAAAAAAAgP5l3rz9xS9+MX784x+XnrS9plF7TQP2QJ7AvdVWW8VBBx1Uuu7o6Ig///nPVa0XAAAAAAAAAAAAAGAwMm3evvzyy+NXv/pVRLzUtL2mWft1r3tdfPazn40LLrggtt566wGt+da3vrW0XkTE7Nmzq1s0AAAAAAAAAAAAAMAg1GS18dKlS+M73/lO2ZO2t9hii/j2t78d++67b+m+Cy64YEDrHnzwwVFbWxtdXV2RpmncfvvtVa0bAAAAAAAAAAAAAGAwMmve/ulPfxorVqwoPXF70qRJ8d///d8xZcqUIa07duzY2HnnneOhhx6KiIjnn38+mpubo6mpqRplD8rq1atj3rx58dhjj8WyZcuira0t6urqoqGhIbbZZpvYfffdo66ublj2XrVqVcyZMyeeeOKJaGlpic7Ozqivr49JkybF1ltvHTvvvHOMGTNmWPYGAAAAAAAAAAAAAF6WWfP2ddddV2rcTpIkzjrrrCE3bq+x++67x5w5c0rXjz/+eCbN23fddVdcccUVceONN8aqVavWe1+xWIzXvOY1ceyxx8bhhx9eehr5UNx+++1xxRVXxF/+8pfo6OhY7321tbWx6667xhvf+MY49thjq/Y1AAAAAAAAAAAAAADKZdK8/eyzz8bTTz9dalLebrvt4tBDD63a+tttt906+82cObNq6/entbU1vvKVr8Tvf//7iu7v7u6O2bNnx+zZs2PfffeNs88+O7bddttB7b148eL493//9/jLX/5S0f2rV6+OBx54IB544IHYfvvt421ve9ug9gUAAAAAAAAAAAAANqyQxaYPP/xw6fMkSeLAAw+s6voNDQ1l121tbVVdf0NaWlri/e9/f8WN273dc889cfzxx8djjz02qLnveMc7Km7chqytXt0dnZ1dsXp1d9alAAADJMcBIN9kOQDkmywHgHyT5QCQb7KcocrkydvNzc0REZGmaSRJEjvuuGNV11/TvL3myd4j2bz9yU9+MubNm1c2Nnr06HjXu94Vhx56aOy0004xbty4aG9vj/nz58ctt9wSv/rVr2LFihWl+5ubm+O0006La6+9NsaMGVPRvvfdd1986EMfipUrV5aN77PPPnHYYYfF/vvvH5MnT45x48ZFW1tbLFy4MB566KG4/fbb47bbbov29vahv3gYoOXLO7IuAQAYJDkOAPkmywEg32Q5AOSbLAeAfJPlDFUmzdutra1l1+PHj6/q+r0bmGtqRuZl3nDDDTF79uyysalTp8aPfvSjdRrUx44dG5MnT47Xvva1ceKJJ8Zpp50WjzzySOnPn3322bjkkkviIx/5SL/7Njc3x0c+8pGy17355pvHf/7nf8ab3/zmde4fN25cTJkyJfbZZ59473vfGytXrozf/e53scUWWwz0JQMAAAAAAAAAAAAAFSpksWldXV3Zde9m66Fa0xyepmlEREycOLGq66/PVVddVXZdKBTiwgsv7PfJ4lOnTo2LL7446uvry8avueaaivb92te+VnqaeUTEFltsEVdccUWfjdt9qauri2OPPTb222+/iu4HAAAAAAAAAAAAAAYuk+btpqamiIhIkiQioqzxuBrmzZtXdj1Szdu333572fWBBx4Yu+22W0Vzt9xyy3jnO99ZNvb444/HkiVLNjjvlltuid///vel62KxGD/4wQ9i+vTpFVYNAAAAAAAAAAAAAIyETJq3J02aVHY9Z86cqq5/xx13lBrDIyJ22GGHqq7fl+XLl0d7e3vZ2MyZ/4+9O4+Sqy7zBv7cquo1naVjAAlhUQigAdmCsrzKiKODCgIOuLAIbgiCK7jBqOMGgoowgiMMyKayKSgOjuCCyzugBIWwaRAUUAIJId3pJJ30UnXfP3i7SC9Jb9VVfenP5xwO3Jt7f7+n6OL5Uuc8dXvhqNbYe++9B51bvnz5Ju/51re+1e/4qKOOGvHAONTazJlN0draHDNnNg1/MQAwqchxAMg2WQ4A2SbLASDbZDkAZJssZ7xqMry92267RV1dXUREpGka//u//xvd3d0VWftXv/pVLF26tHy8+eabx7bbbluRtTdl4OB2xOif+D3U9T09PRu9/pFHHok//vGP/c4dd9xxo9oTaimfz0WhkI98viatCAAYBzkOANkmywEg22Q5AGSbLAeAbJPljFdN3jmNjY2x1157RZqmERGxatWq+NGPfjTudbu7u+P888+PiGeHwpMkiVe84hXjXnckWltbI5fr/69z1apVo1pjqOsHPqV8Q9dff32/4z322CO23nrrUe0JAAAAAAAAAAAAAFRHzcb+3/jGN0ZERJIkkaZpfO1rX4vly5ePa80vfOEL8ac//SmSJCmfe9vb3jauNUeqvr4+5s+f3+/cH/7wh1GtMfD6LbbYIrbaaquNXv+///u//Y733XffUe0HAAAAAAAAAAAAAFRPoVYbv/nNb45LLrkkHn/88UiSJNrb2+P444+PSy65JObOnTuqtdasWROf+tSn4uc//3l5GDxJkthrr71izz33nKBXMNjBBx8cS5YsKR//5je/iSVLlsROO+007L3Lly+PG264od+5I444YqPXd3Z2xiOPPNLv3MB91q1bF4sWLYqHH344Ojo6Ytq0aTF79uyYP39+7LLLLoOeFA4AAAAAAAAAAAAATJyaDW/n8/n42Mc+FqecckokSRJJksRf//rXOPjgg+M973lPHHHEEbH55ptv9P5SqRT3339//OxnP4trrrkm1qxZUx7ajoioq6uLT3ziE9V6ORERcdRRR8X3vve9ePLJJyMiolgsxsknnxyXXnppbLvtthu9b/ny5XHiiSdGZ2dn+dy8efPi3e9+90bveeCBB6JYLPY7t8MOO0REREdHR5x//vnxgx/8INatWzfk/bNmzYqDDz44TjzxxNhss81G/BoBAAAAAAAAAAAAgLFJ0jRNa1nAf/zHf8Q3v/nN8tD1hgPYc+fOjba2tvJQc5Iksdtuu0V7e3ssW7Ys1q9fX76n78/77v/0pz8dRx11VNVfz+LFi+P444/vN4jd3Nwcb3nLW+K1r31tzJ8/P6ZNmxbr1q2Lv/71r3HbbbfF1VdfHe3t7eXrN9tss7jiiiti++233+g+11xzTXz2s5/td+7//t//G3/729/iYx/7WDz11FMjqrepqSk++9nPxuGHHz66FzrB2to6o7e3OPyFZNrs2dMin89FsViKlSvX1rocAGAU5DgAZJssB4Bsk+UAkG2yHACyTZZPLYVCPlpbmyu7ZkVXG4MPfvCDsWLFirjuuuvKT+DuG8Z+4oknyoPcEc8OaS9evDgGzptveE1ExHvf+96aDG5HROy2225x9dVXx2mnnRZ/+ctfIiKis7MzLr/88rj88ss3eW+SJPG6170uPvOZz8ScOXM2ee2qVasGnXvkkUfixBNP3OjTtoeybt26+OQnPxlPPfVUnHTSSSO+DwAAAAAAAAAAAAAYnZoPb0dEfP7zn4/ddtstvvjFL8a6desGDWNvONC94ZO5N5SmadTX18fnP//5OOyww6pR9kbtvPPO8aMf/ShuvvnmuOGGG+KOO+4Y9p599903zjjjjJg/f/6I9ujo6Bh07iMf+Uh5cDufz8fhhx8ehxxySOy4447R0tISzzzzTCxatCi+973vxd13393v3vPPPz923nnnePWrXz2i/YeydOnSWLp06ZjubWlpiZ133nnMewMAAAAAAAAAAADAZJekAx9jXUNPPPFEXHLJJXHjjTfG+vXrI2LwU7U31Fd6Pp+PN73pTXHyySfHvHnzqlLrcB555JG49NJL4xe/+EW0t7eP6J45c+bE8ccfH+94xzuioaFhk9d+5jOfiWuvvXbIP5s1a1Z861vfij322GPIP0/TNL71rW/Feeed1+98a2tr/PKXv4zm5rE93v0b3/hGXHDBBWO6d6+99orvfe975eNisbTJ63t7S9HR0f8J4zNmNEWhkBt2r3XrumPdup7ycZJEtLZOG1GdHR3rorf3udrq6/PR0tI47H1pmkZbW2e/c9OmNURDw/Dfn+ju7o01a7r6nZs1qzlyuY3/t9Fn7dqu6OrqLR/n80nMnDmyn297e2eUSs+1h8bGumhurh/2vmKxFKtW9f/ZTJ/eGHV1+UHX5nLPPW2/VEpj/fqe6Ozs7nfN7Nkj+9msXr0+enqK5eO6unxMnz78zyYiBv3qiubm+mhsrBv2vp6eYqxevb7fuZkzmyKfH/592NnZHevXP/c+zOWSmDVrZD+bVas6o1h87mfT0FCIadM23TMiIkqlNNrb+78PW1oaor5++PdhV1dvrF3b/33Y2tq8yR7dZ82a9dHd/dzPplDIxYwZTcPeFxHR1rY2Nkyppqa6aGoa/n2oRzw/esRAeoQeMZAeUdseMTDHN6RH6BEb0iOmZo/YFD1Cj9iQHlG7HrGpLI/QI/SIwfSIqdUjhqNH6BED6RHV7xEveEHLJrO8jx6hR2xIj5g6PcL/RwymR+gRG5oMPWL27GmRz+eGzfIIPUKPGEyPeP73iAj/HzEUPUKPGKiWPaIvy4vF0kYfSDyQHpHtHjGS9/NoTIonb/fZaqut4rOf/Wx84AMfiF//+tdx5513xh//+MdYtmxZeZg7IqJQKERra2vstttusd9++8U//dM/xdy5c2tY+XN6e3vj/PPPj0suuSRKpefefHV1dbHLLrvE9ttvH9OnT4+1a9fGo48+GosXL46urmffMCtWrIivfvWrcdNNN8WFF14Y22yzzUb32djMfS6XiwsvvHCjg9sRzw7En3TSSdHW1hZXXHFF+XxbW1tcd911cfzxx4/yVVfecG/0oT685HLJiP4DGapRjv0/rJHtOVS9STKyfYdqHmN/rSO7b+i1RlbvUO/N4epNkiTy+aTCP5ux3/tsPcPfO9SXDEb+sxl8buT1JhHx3L/nkdYbUdl6c7nciMLt2Xr7m+ifjR7x/OoRz+2hR4yMHjEcPaKyPaIvxze9lh4xkB6hRwzv+dEjRkKPGEyP0COGV7kesbEs1yP0iCHuDj1i056PPWJj9Ag9Yoi7Q4/YtEr3iL5zI/lcPuBOPWIAPUKPGOLuQWey1iP8f8Tw9IjB9Ijq9ojOzu5oaChEfX1h2CzXI/SIkdAjBsp2j3i2Dv8fMZAeoUcMcXfUqkd0dnZHkkSk6bPDxXrEsKtNmR4xUpNqeLvP7Nmz4/DDD4/DDz+8fK6rqytWrVoVjY2NMWPGjBpWt3HFYjFOPfXU+OlPf1o+lyRJHHPMMXHiiSfGnDlzBt3T0dERl19+eVx00UXR2/vs5P5DDz0Uxx13XFxzzTWxxRZbDLnXxp6O/eY3vzkWLlw4ono/+tGPxs033xwrVqwon5ssw9vDPXl7qP9IS6V02Psihg7Gkdy3kdXGvGeajmzfjb3WoUJk+H1HVu/Qa42v3ur/bMZ+b5qOrN7xvdbB50Zeb/+ba1VvqVSKNB3J/3hU7udandeqR4yFHjGYHqFHDE+PGLq2wef0iIF7DD6nR4xgJT1iED1Cjxji7gFr6REDTZ73oR4xdG2Dz+kRA/cYfE6PGMFKesQgeoQeMcTdA9bSIwaaPO9DPWLo2gaf0yMG7jH4nB4xgpX0iEH0CD1iiLsHrDU1esT69T0jHkSaPO9DPWLo2gaf0yMG7jH4nB4xgpX8f8QgeoQeMcTdA9aqXr0bPi28qalOjxh+tcz3iEoPcyfpxh7hzKhddNFFce6555aPkySJc845J970pjcNe+/tt98eJ5xwQvT0PPcf9Stf+cq45JJLhrz+/PPPj29+85uDzt9www2xYMGCEdf8ta99LS6++OJ+5+64446YPXv2iNfos3Tp0li6dOmo74uIaGlpiZ133rl83NbWGb29xU3cAQAAAAAAAAAAAAATp1DIR2vr0A9cHvOaFV1tClu5cuWgYeqjjz56RIPbERH77bdffOhDH4qvfvWr5XO//e1v46677hrySdpDPXl75syZ8dKXvnRUde+zzz6DhrfvueeeOPDAA0e1TkTE3LlzY+7cuaO+DwAAAAAAAAAAAACmgso+x3sKu+mmm2L9+vXl4yRJ4oQTThjVGscee2xMnz6937kbb7xxyGtf+MIXDjq3/fbbR5KM5PH7z5k/f/6gc88888yo1oCxyuWS8l8AQLbIcQDINlkOANkmywEg22Q5AGSbLGe8DG9XyJ133tnveOedd44ttthiVGs0NjbG3nvv3e/c3XffPeS122+//aBzM2fOHNV+G7unvb191OvAWMya1RwveEFLzJpV2V8pAABMPDkOANkmywEg22Q5AGSbLAeAbJPljFeh1gVszJNPPhkPPvhgtLW1RXt7e/mp1qecckqNKxvaE0880e943rx5Y1pn4H3Lli0b8roXv/jFkcvlolQqlc+laTrq/Ya6Z7RP7wYAAAAAAAAAAAAAhjephreXLVsWl19+efzsZz8bNAzdZ1PD2z/+8Y9jxYoV5eO99torXvayl1W8zqH0DZf3aWhoGNM6TU1N/Y67u7uHvK6xsTG23Xbb+Nvf/lY+t2rVqlHvN9Q9ra2to14HAAAAAAAAAAAAANi0STG8XSwW49xzz42rrroqenp6NvoE6eGeCL1s2bL42te+Vj7eZ5994rLLLqtorRszY8aMfsft7e1jWmflypX9jmfNmrXRa1/96lf3G95++OGHI03TUT05+6GHHhp0bvPNNx/x/QAAAAAAAAAAAADAyORqXcDKlSvjHe94R3z729+O7u7u8vDxwL9G4m1ve1u0tLRERESapvH73/8+nnzyyYksv2zOnDn9ju+///4olUqjXmfx4sX9jjfbbLONXvvP//zP/Y5Xr14d991336j2u+OOO/od5/P52GOPPUa1BgAAAAAAAAAAAAAwvJoOb3d3d8f73//++MMf/tBvaDtN035/jVRLS0u8/vWvL9+Tpmn8/Oc/n6jy+xk48Nze3h633XbbqNa4//77Bz0Je++9997knltttVW/c9/73vdGvF9nZ2fccMMN/c697GUvKw/AAwAAAAAAAAAAAACVU9Ph7S996Utxzz339BvanjVrVnzoQx+KG2+8Me68887YeeedR7Xm61//+oiI8tO6b7/99orXPZQDDjhg0LlzzjknVq9ePaL7u7u74/Of//yI1u2Ty+Xi5JNP7nfuhz/8Yfzud78b0Z5f+cpXoq2trd+5Y489dkT3AgAAAAAAAAAAAACjU7Ph7b/+9a/x/e9/vzy0HRGx//77x89+9rM46aST4iUveUnMmDFj1Ou+/OUvLz85Ok3TWLRoUUXr3piddtopXvWqV/U79+ijj8Z73/veWLZs2SbvbW9vj/e///2xePHifud322232G+//TZ57+GHHx7z588vH6dpGqeccsomX3epVIrzzz9/0FO658+fXx5+BwAAAAAAAAAAAAAqq1CrjS+++OIoFovlp24vWLAgLrrooigUxldSPp+Pl7zkJeXh5bVr18bSpUtj7ty5lSh7kz7+8Y/HXXfdFZ2dneVzd999dxx00EFxxBFHxKtf/erYfvvto6WlJdauXRuPPvpo/Pa3v41rr702Vq1a1W+t+vr6OP3004fdM5fLxZe+9KU4+uijo6enJyIiVq9eHccee2wccsghccghh8ROO+0U06ZNi2eeeSbuuuuu+O53vxsPPPBAv3Wam5vjvPPOi1yupg9jBwAAAAAAAAAAAIDnrZoNb//qV78qP3U7SZL44he/OO7B7T677LJLvydP//Wvf63K8Pb8+fPjvPPOi5NPPrk8SB0R0dnZGVdeeWVceeWVI1onn8/H2WefHbvvvvuIrt9tt93inHPOidNOOy2KxWJEPPsE7ptuuiluuummYe9vamqKc889N3bYYYcR7QcAAAAAAAAAAAAAjF5NhrcffPDBaG9vLz91e6+99oqdd965YutvueWW/Y6XLVtWsbWHc8ABB8TVV18dH/vYx+Jvf/vbqO/faqut4itf+Urstddeo7rvDW94Q8ycOTM+9rGPxTPPPDPi+7bZZps4//zz46UvfeloS4VxW7WqMyKSiEhrXQoAMEpyHACyTZYDQLbJcgDINlkOANkmyxmvmgxvP/roo/2O99lnn4quP2PGjH7Ha9asqej6w9l1113jpptuiv/5n/+Ja6+9NhYvXhy9vb0bvT6Xy8WCBQvirW99axxyyCHR2Ng4pn3333//uOWWW+Kyyy6L6667Lp5++umNXrvjjjvGUUcdFUcccUTU1dWNaT8Yr2IxDQEGANkkxwEg22Q5AGSbLAeAbJPlAJBtspzxqsnwdltbW0REpGkaSZLEvHnzKrp+U1NTREQkSRIREevWravo+iNRX18fhx56aBx66KGxbt26eOCBB+Lxxx+Pjo6O6OzsjObm5pg+fXrMnTs3dt1112hpaanIvtOnT48PfvCD8YEPfCD+/Oc/x5IlS2L58uVRLBZj1qxZMWfOnNhtt91i8803r8h+AAAAAAAAAAAAAMDI1GR4e+CTsJubmyu6/urVqyPiueHwSq8/Wk1NTbFw4cJYuHBh1fZMkiRe8pKXxEte8pKq7QkAAAAAAAAAAAAAbFxNhrdnzJjR77hv2LpSVq5c2e941qxZFV0fqIyGhkIkSRJpmkZXV2+tywEARkGOA0C2yXIAyDZZDgDZJssBINtkOeNVk+Ht2bNnR8SzT4eOiHjyyScruv7ixYv7Hbe2tlZ0faAypk1riHw+F8ViSYgBQMbIcQDINlkOANkmywEg22Q5AGSbLGe8crXYdO7cuf2O77333oqt3d3dHYsWLSoPhkdELFiwoGLrAwAAAAAAAAAAAACMRU2GtxcsWBAzZsyIiIg0TeN3v/tdtLW1VWTt73//+9HR0VE+3n777ctP+gYAAAAAAAAAAAAAqJWaDG/ncrnYd999I03TiIjo6emJb3/72+Ned/ny5XHhhRdGkiSRpmkkSRL/5//8n3GvCwAAAAAAAAAAAAAwXjUZ3o6IeOtb3xoRUR60vuyyy2LRokVjXq+joyM+8IEPxDPPPFM+l8/n49hjjx13rQAAAAAAAAAAAAAA41Wz4e399tsvXvGKV5SfkN3b2xvve9/74tZbbx31Wr///e/jX//1X+Pee+/t99TtN77xjbHVVltNQPUAAAAAAAAAAAAAAKNTqOXmp59+erztbW+L9evXR5Ik0dnZGR/60Ifi5S9/ebzlLW+JPfbYY9A9PT090d7eHkuXLo1FixbFz372s7j33nsjTdOIePZJ3kmSxJw5c+JjH/tYtV8SAAAAAAAAAAAAAMCQajq8vdNOO8XXvva1OOWUU8pPy07TNO6888648847y9f1DWanaRove9nLBq3Td2/fPxcKhfj6178ec+bMqc4LAQAAAAAAAAAAAAAYRq7WBRx44IFx9tlnR2NjY0REvyHsvr82tOH5vr82vGfatGnxjW98IxYuXFjdFwIAAAAAAAAAAAAAsAk1H96OiDjkkEPiuuuuix122KE8rJ0kyYj/inh2cPvFL35xXHPNNfHqV7+6li8HGKFSKY1isRSlUjr8xQDApCLHASDbZDkAZJssB4Bsk+UAkG2ynPFK0oGPtq6hNE3jpz/9aVxyySXxwAMPDPrzJEkGPYk7ImLbbbeNk046Kd70pjdFLjcp5tEZp7a2zujtLda6DAAAAAAAAAAAAACmqEIhH62tzRVdc1INb2/oiSeeiEWLFsUf//jHeOqpp6K9vT1WrVoVjY2N0draGi94wQtit912i/333z+23377WpdLhRneBgAAAAAAAAAAAKCWptTwNlOb4W0AAAAAAAAAAAAAamkihrdzFV0NAAAAAAAAAAAAAIAhFSZi0T//+c/lf25sbIzttttuIrYBMq6lpSFyuSRKpTTWrOmqdTkAwCjIcQDINlkOANkmywEg22Q5AGSbLGe8JmR4+7DDDoskSSIi4iUveUnccMMNE7ENkHH19YXI53NRLJYiQogBQJbIcQDINlkOANkmywEg22Q5AGSbLGe8JmR4OyIiTdN+fx+pb3zjG7F06dKIiEiSJM4888yK1wYAAAAAAAAAAAAAUG0TNrzd9+Tt0frFL34RS5YsiTRNDW8DAAAAAAAAAAAAAM8buYlcfLRP3R7vfQAAAAAAAAAAAAAAk9WEDm+P1Vif2g0AAAAAAAAAAAAAMFlNyuFtAAAAAAAAAAAAAIDnG8PbAAAAAAAAAAAAAABVYHgbAAAAAAAAAAAAAKAKDG8DAAAAAAAAAAAAAFRBodYFAFNXV1dvJElEmta6EgBgtOQ4AGSbLAeAbJPlAJBtshwAsk2WM16Gt4GaWbu2q9YlAABjJMcBINtkOQBkmywHgGyT5QCQbbKc8crVugAAAAAAAAAAAAAAgKnA8DYAAAAAAAAAAAAAQBUY3gYAAAAAAAAAAAAAqIJCrQsApq7W1ubI5XJRKpWira2z1uUAAKMgxwEg22Q5AGSbLAeAbJPlAJBtspzxmvDh7Z6ennjyyScjTdMRX7+h0dy7MXPnzh3X/cDESJIkcrkk0jSpdSkAwCjJcQDINlkOANkmywEg22Q5AGSbLGe8Jnx4+5FHHokDDzxwVPf0DWunaTrqewdKkiQefPDBca0BAAAAAAAAAAAAADBeEz68Pd6nZo/3fgAAAAAAAAAAAACAyWBCh7eTpLaPhDf4DQAAAAAAAAAAAABMFhM6vG14GgAAAAAAAAAAAADgWRMyvL333ntPxLIAAAAAAAAAAAAAAJk1IcPbV1111UQsCwAAAAAAAAAAAACQWblaFwAAAAAAAAAAAAAAMBUY3gYAAAAAAAAAAAAAqIJCrQsApq41a9ZHRBIRaa1LAQBGSY4DQLbJcgDINlkOANkmywEg22Q542V4G6iZ7u5irUsAAMZIjgNAtslyAMg2WQ4A2SbLASDbZDnjlat1AQAAAAAAAAAAAAAAU4HhbQAAAAAAAAAAAACAKijUugBg6ioUnvv+SG9vqYaVAACjJccBINtkOQBkmywHgGyT5QCQbbKc8TK8DdTMjBlNkc/nolgsxcqVa2tdDgAwCnIcALJNlgNAtslyAMg2WQ4A2SbLGa/c8JcAAAAAAAAAAAAAADBehrcBAAAAAAAAAAAAAKrA8DYAAAAAAAAAAAAAQBUY3gYAAAAAAAAAAAAAqALD2wAAAAAAAAAAAAAAVWB4GwAAAAAAAAAAAACgCgxvAwAAAAAAAAAAAABUgeFtAAAAAAAAAAAAAIAqMLwNAAAAAAAAAAAAAFAFSZqmaa2LgIHa2jqjt7dY6zKYYEny3D/rRACQLXIcALJNlgNAtslyAMg2WQ4A2SbLp5ZCIR+trc2VXbOiqwGMguACgOyS4wCQbbIcALJNlgNAtslyAMg2Wc545WpdAAAAAAAAAAAAAADAVGB4GwAAAAAAAAAAAACgCgq1LgCYupqa6iJJkkjTNNat66l1OQDAKMhxAMg2WQ4A2SbLASDbZDkAZJssZ7wMbwM109RUH/l8LorFkhADgIyR4wCQbbIcALJNlgNAtslyAMg2Wc545WpdAAAAAAAAAAAAAADAVDAhT97+1Kc+NRHLjkmSJHHmmWfWugwAAAAAAAAAAAAAYIqbkOHtG2+8MZIkmYiloO2F8wAAooFJREFURyVNU8PbAAAAAAAAAAAAAMCkMCHD233SNJ3I5QEAAAAAAAAAAAAAMmNCh7dr/fRtw+MAAAAAAAAAAAAAwGQxYcPbBqcBAAAAAAAAAAAAAJ4zIcPbV1555UQsCwAAAAAAAAAAAACQWRMyvP3yl798IpYFAAAAAAAAAAAAAMisCRneBhiJ3t5SlEpplEpprUsBAEZJjgNAtslyAMg2WQ4A2SbLASDbZDnjlaRp6t3DpNPW1hm9vcValwEAAAAAAAAAAADAFFUo5KO1tbmia+YquhoAAAAAAAAAAAAAAEMyvA0AAAAAAAAAAAAAUAWGtwEAAAAAAAAAAAAAqqAwkYt3d3fHihUr+p2rq6uLzTbbrKL7PP3009HT09Pv3GabbRZ1dXUV3QeorBkzmiKXS6JUSqOjY12tywEARkGOA0C2yXIAyDZZDgDZJssBINtkOeM1ocPb55xzTnz3u9/td+5rX/tavOENb6joPnfeeWeceuqpkSRJ+dwJJ5wQH/nIRyq6D1BZhUIu8vlcFIulWpcCAIySHAeAbJPlAJBtshwAsk2WA0C2yXLGKzdRC//973+Pa665JtI0jTRNIyLine98Z8UHtyMi3vjGN8Y73/nO8l5pmsaVV14Zy5Ytq/heAAAAAAAAAAAAAABjMWHD2xdccEH09vZGkiSRJEnMnz8/PvrRj07UdvHRj3405s+fX3769vr16+M///M/J2w/AAAAAAAAAAAAAIDRmJDh7TVr1sQtt9wSSZKUn7p9xhlnRKFQmIjtIiKirq4uTj/99EjTtLzvj3/84+jq6pqwPQEAAAAAAAAAAAAARmpChrdvvfXWWL9+fUREJEkSe+65Z7ziFa+YiK362XfffWOvvfYqD4x3dnbGrbfeOuH7AgAAAAAAAAAAAAAMZ8KGtyOiPER9zDHHTMQ2Qzr66KMj4tmh8YiIn/70p1XbGwAAAAAAAAAAAABgYyZkeHvx4sXl4enGxsY48MADJ2KbIb3mNa+JpqamiHh2eHzx4sVV2xsAAAAAAAAAAAAAYGMqPrz9xBNPRFtbW0Q8+/Tr3XffPRoaGiq9zUY1NDTE7rvvXn7q9zPPPBNPPvlk1fYHAAAAAAAAAAAAABhKxYe3//KXv/Q73mWXXSq9xbAWLFjQ7/ihhx6qeg0AAAAAAAAAAAAAABsqVHrB9vb2iIhI0zSSJIl58+ZVeothbb311v2O+54EDkwu69Z1R5Ik5SflAwDZIccBINtkOQBkmywHgGyT5QCQbbKc8ar48HZHR0e/4+nTp1d6i2EN3HNgTcDksG5dT61LAADGSI4DQLbJcgDINlkOANkmywEg22Q545Wr9IJr167td5wkSaW3GLG+vQfWBAAAAAAAAAAAAABQbRUf3q6vr+93vHLlykpvMay2traIiPIj6QfWBAAAAAAAAAAAAABQbYVKLzht2rSIeO6p132D1NU0cM/m5uaq1wAMb8MH8///71oAABkhxwEg22Q5AGSbLAeAbJPlAJBtspzxqvjw9pZbbtnv+JFHHqn0FsMauOfAmoDJobV1WuTzuSgWS7Fy5dpalwMAjIIcB4Bsk+UAkG2yHACyTZYDQLbJcsYrV+kFt9lmm/I/p2kat99+e6RV/GpB357JBl9t2LAmAAAAAAAAAAAAAIBaqPjw9ote9KKYPn16+bijoyPuueeeSm+zUffcc0+sWrWqfNzS0hIvfvGLq7Y/AAAAAAAAAAAAAMBQKj68HRGx9957R5qm5adff+tb35qIbYa04V5JksRee+1Vtb0BAAAAAAAAAAAAADZmQoa3X/e615X/OU3T+M1vfhOLFi2aiK36WbRoUfz617+OJEkiTdOIiDjooIMmfF8AAAAAAAAAAAAAgOFMyPD2v/zLv8TMmTMjIsqD1Keeemo8+eSTE7FdREQ89dRTcdppp5Wf9h0RMWPGDMPbAAAAAAAAAAAAAMCkMCHD201NTfH2t7+9/PTrJEli+fLl8Z73vCdWrFhR8f1WrFgR73nPe2LZsmUR8ezTvpMkiaOOOioaGxsrvh8AAAAAAAAAAAAAwGhNyPB2RMQJJ5wQm2++efk4SZJ45JFH4uCDD45bbrmlYvv87Gc/i0MOOSQeeeSRfk/d3nzzzeOEE06o2D4AAAAAAAAAAAAAAOMxYcPbzc3NcdZZZ/U7lyRJtLe3x4c//OF417veFT//+c+jVCqNeu00TePnP/95vPvd744PfvCD0dbWVn7Kd5qmkcvl4swzz4ympqaKvBYAAAAAAAAAAAAAgPEqTOTi+++/f3zkIx+Jc889t/xU7CRJIk3TuOOOO+KOO+6IOXPmxN577x0ve9nLYpdddok5c+bEjBkzoqWlJZIkidWrV0dHR0esWLEi7r///rjvvvti0aJF8fTTT0fEs8PaGz5xO0mS+PCHPxz777//RL40AAAAAAAAAAAAAIBRSdK+R1ZPoK9//etx0UUX9Ruy3nDbDc+PxMbuTdM0TjzxxPjwhz889mKZFNraOqO3t1jrMphghcJzD//v7R39U/gBgNqR4wCQbbIcALJNlgNAtslyAMg2WT61FAr5aG1truiaVRnejoi4/vrr44tf/GJ0d3cP+rPRljBw2DtN02hoaIh/+7d/iyOPPHJcdTI5GN4GAAAAAAAAAAAAoJYmYng7N/wllXHkkUfGDTfcEHvuuWekaTro6dmj+atP3zp77bVX3HDDDQa3AQAAAAAAAAAAAIBJq2pP3t7Qr3/967j88svjd7/7XXmIe+DTtDdmw+v33XffOO644+KAAw6YsFqpDU/eBgAAAAAAAAAAAKCWJuLJ2zUZ3u7z1FNPxS9/+cv4/e9/Hw8++GD84x//iI2VkyRJbLXVVrFgwYJ4+ctfHgceeGBsueWWVa6YajG8PTXU1+cjIomINLq7/bwBIEvkOABkmywHgGyT5QCQbbIcALJNlk8tz7vh7YF6enpi2bJl0dHREevXr480TaOxsTFmzpwZW2yxRdTV1dW6RKrE8PbUMHv2tMjnc1EslmLlyrW1LgcAGAU5DgDZJssBINtkOQBkmywHgGyT5VPLRAxvFyq62jjV1dXFvHnzal0GAAAAAAAAAAAAAEDF5WpdAAAAAAAAAAAAAADAVGB4GwAAAAAAAAAAAACgCgxvAwAAAAAAAAAAAABUgeFtAAAAAAAAAAAAAIAqMLwNAAAAAAAAAAAAAFAFhrcBAAAAAAAAAAAAAKrA8DYAAAAAAAAAAAAAQBUY3gZqJk3TKJXSSNO01qUAAKMkxwEg22Q5AGSbLAeAbJPlAJBtspzxSlLvHiahtrbO6O0t1roMAAAAAAAAAAAAAKaoQiEfra3NFV3Tk7cBAAAAAAAAAAAAAKrA8DYAAAAAAAAAAAAAQBUY3gYAAAAAAAAAAAAAqIJCrQsApq5p0xoiSSLSNGLt2q5alwMAjIIcB4Bsk+UAkG2yHACyTZYDQLbJcsbLk7eBmmloKERTU300NPgeCQBkjRwHgGyT5QCQbbIcALJNlgNAtslyxsvwNgAAAAAAAAAAAABAFRjeBgAAAAAAAAAAAACoAsPbAAAAAAAAAAAAAABVYHgbAAAAAAAAAAAAAKAKDG8DAAAAAAAAAAAAAFSB4W0AAAAAAAAAAAAAgCowvA0AAAAAAAAAAAAAUAWGtwEAAAAAAAAAAAAAqqBQ6wKAqau7uzdyuSRKpbTWpQAAoyTHASDbZDkAZJssB4Bsk+UAkG2ynPFK0jT17mHSaWvrjN7eYq3LAAAAAAAAAAAAAGCKKhTy0draXNE1cxVdDQAAAAAAAAAAAACAIRneBgAAAAAAAAAAAACoAsPbAAAAAAAAAAAAAABVUKh1AcDUNWtWc+RySZRKabS3d9a6HABgFOQ4AGSbLAeAbJPlAJBtshwAsk2WM16Gt4GayeWSyOdzEVGqdSkAwCjJcQDINlkOANkmywEg22Q5AGSbLGe8crUuAAAAAAAAAAAAAABgKjC8DQAAAAAAAAAAAABQBYa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVEGh1gUAU9fatV2RJEmkaVrrUgCAUZLjAJBtshwAsk2WA0C2yXIAyDZZzngZ3gZqpqurt9YlAABjJMcBINtkOQBkmywHgGyT5QCQbbKc8crVugAAAAAAAAAAAAAAgKnA8DYAAAAAAAAAAAAAQBUUal0AMHXl80lEJBGRRrGY1rocAGAU5DgAZJssB4Bsk+UAkG2yHACyTZYzXoa3gZqZObM58vlcFIulWLlyba3LAQBGQY4DQLbJcgDINlkOANkmywEg22Q545WrdQEAAAAAAAAAAAAAAFOB4W0AAAAAAAAAAAAAgCowvA0AAAAAAAAAAAAAUAWGtwEAAAAAAAAAAAAAqsDwNgAAAAAAAAAAAABAFRjeBgAAAAAAAAAAAACoAsPbAAAAAAAAAAAAAABVYHgbAAAAAAAAAAAAAKAKCrUuYCro6emJJUuWxMMPPxwdHR2xdu3aaGpqiunTp8e2224bCxYsiKamplqXCQAAAAAAAAAAAABMoCRN07TWRTxfLVq0KL73ve/FL37xi+jq6trodfl8Pl7xilfEW97yljjooIMiSZKK17Jy5cp4/etfH+3t7YP+bMmSJRXfb7za2jqjt7dY6zKYYLncc+/1UkkrAoAskeMAkG2yHACyTZYDQLbJcgDINlk+tRQK+Whtba7omoa3J0B7e3t84QtfiP/+7/8e9b177rlnnHXWWbHddttVtKZTTz11o/UY3gYAAAAAAAAAAACA/iZieDtX0dWItra2eMc73jGmwe2IiD/+8Y/x9re/PR5++OGK1fSb3/xmzPUAAAAAAAAAAAAAAJXhydsV9s53vjNuv/32fucaGhrizW9+c/zzP/9zzJ8/P1paWqKzszMeeeSR+PWvfx3XXXddrFmzpt898+bNi5tvvjkaGxvHVU9nZ2ccfPDB8cQTT2z0Gk/eBgAAAAAAAAAAAID+JuLJ24WKrjbF/exnPxs0uD137tz4r//6r9hhhx36nZ82bVpsttlmsc8++8Sxxx4b73vf++Khhx4q//k//vGPuOyyy+Kkk04aV03nnXdeeXA7SZLYd999B9UItdLYWBdJEpGmEevX99S6HABgFOQ4AGSbLAeAbJPlAJBtshwAsk2WM165WhfwfHLjjTf2O87lcnHhhRcOGtweaO7cuXHxxRdHc3P/yfybbrppXPXce++9cdVVV5WPjzzyyNhzzz3HtSZUUnNzfbS0NEZzc32tSwEARkmOA0C2yXIAyDZZDgDZJssBINtkOeNleLuC7rjjjn7Hr3zlK+OlL33piO7dcsst49BDD+137q9//WusWLFiTLX09vbGv/3bv0WpVIqIiBe84AVx2mmnjWktAAAAAAAAAAAAAGD8DG9XyOrVq6Ozs7PfuYULF45qjb333nvQueXLl4+pnksvvTSWLFlSPv7EJz4RM2fOHNNaAAAAAAAAAAAAAMD4Gd6ukIGD2xERs2bNGtUaQ13f09Mz6loeffTRuPDCC8vH++6776CnegMAAAAAAAAAAAAA1WV4u0JaW1sjl+v/r3PVqlWjWmOo6+fMmTPqWj796U9HV1dXRETU19fHZz/72VGvAQAAAAAAAAAAAABUluHtCqmvr4/58+f3O/eHP/xhVGsMvH6LLbaIrbbaalRrXH/99XHnnXeWj9/3vvfFi170olGtAQAAAAAAAAAAAABUnuHtCjr44IP7Hf/mN7+JJUuWjOje5cuXxw033NDv3BFHHDGq/VesWBFf+cpXysfbbbddnHDCCaNaAwAAAAAAAAAAAACYGIa3K+ioo46KLbfcsnxcLBbj5JNPjscee2yT9y1fvjxOPPHE6OzsLJ+bN29evPvd7x7V/l/4whdi1apV5eN///d/j/r6+lGtAQAAAAAAAAAAAABMDMPbFdTS0hLnn39+NDc3l8/9/e9/j8MOOyzOOuusuOuuu2LVqlXR29sbq1evjsWLF8d5550XhxxySDzwwAPlezbbbLO4+OKLY9q0aSPe+5e//GX89Kc/LR8feuihse+++1bmhQEAAAAAAAAAAAAA41aodQHPN7vttltcffXVcdppp8Vf/vKXiIjo7OyMyy+/PC6//PJN3pskSbzuda+Lz3zmMzFnzpwR77lmzZr43Oc+Vz6eNWtWfPKTnxxT/VBNxWIp0jSNUimtdSkAwCjJcQDINlkOANkmywEg22Q5AGSbLGe8DG9PgJ133jl+9KMfxc033xw33HBD3HHHHcPes++++8YZZ5wR8+fPH/V+5557bjz11FPl49NOOy1mz5496nXGa+nSpbF06dIx3dvS0hI777xzhStislu1al2tSwAAxkiOA0C2yXIAyDZZDgDZJssBINtkOeNleHuCPProo/G73/0u/vSnP43o+jvuuCOOP/74OP744+Md73hHNDQ0jOi+u+++O66++ury8V577RVHHHHEmGoerx/84AdxwQUXjOnevfbaK773ve+Vj2fMaNzk9b29pejo6N8AZ8xoikIhN+xe69Z1x7p1PeXjJIlobZ02ojo7OtZFb2+pfFxfn4+Wlk3XGhGRpmm0tXX2OzdtWkM0NAz/n2B3d2+sWdPV79ysWc2RyyXD3rt2bVd0dfWWj/P5JGbObB72voiI9vbOft8Mamysi+bm+mHvKxZLg8Jp+vTGqKvLD3vv+vU90dnZ3e/c7Nkj+9msXr0+enqK5eO6unxMnz78zyYiYuXKtf2Om5vro7Gxbtj7enqKsXr1+n7nZs5sinx++PdhZ2d3rF//3Pswl0ti1qyR/WxWreqMYvG5n01DQyGmTRu+Z5RKabS3938ftrQ0RH398O/Drq7eWLu2//uwtbU5kmT49+GaNeuju/u5n02hkIsZM5qGvS8ioq1tbaQbfEGtqakumpqGfx/qEXrEQHqEHrEhPUKPGEiP0CM2pEfoEQPpEXrEhvQIPWIgPUKP2JAeoUcMpEfoERvSI/SIgfQIPWJDeoQeMZAeoUdsSI/QIwbSI/SIDekResRAeoQesSE9YuJ7xFgZ3q6w3t7eOP/88+OSSy6JUum5N19dXV3ssssusf3228f06dNj7dq18eijj8bixYujq+vZN8yKFSviq1/9atx0001x4YUXxjbbbLPJvbq7u+PTn/50eZ+6urr43Oc+N6JGMNkN17iH+nUDuVwyooY/1L+fkdy3kdVGdO9Q9SbJyPYdqnmM/bWO7L6h1xpZvWk6WX42Y783SUZWb7FYGnRu5K918LmR15tExHP/nkdab0Rl683lciMKt2fr7W+ifzZ6hB4xEnrEQHqEHjFwDz1iLPSIIXbUI0ZW4ODV9IgB9Ag9Yoi7B53RI/rTI/SIwXsMPqdHjGAlPWIQPUKPGOLu0CM2TY/QI0ZCjxhIj9AjBu6hR4yFHjHEjnrEyAocvJoeMYAeoUcMcfegM3pEf3qEHjF4j8Hn9IgRrKRHDDJZesRIGd6uoGKxGKeeemr89Kc/LZ9LkiSOOeaYOPHEE2POnDmD7uno6IjLL788LrrooujtfXZy/6GHHorjjjsurrnmmthiiy02ut/FF18cf/nLX8rH73rXu2L+/PkVfEW1M1RD39BQ/5GWSumw90UMHYwjuW8jq415zzQd2b4be61Dhcjw+46s3qHXGl+91f/ZjP3eNB1ZveN7rYPPjbze/jfXqt5SqRRpOpL/8ajcz7U6r1WPGAs9YjA9Qo8Ynh4xdG2Dz+kRA/cYfE6PGMFKesQgeoQeMcTdA9bSIwaaPO9DPWLo2gaf0yMG7jH4nB4xgpX0iEH0CD1iiLsHrKVHDDR53od6xNC1DT6nRwzcY/A5PWIEK+kRg+gResQQdw9YS48YaPK8D/WIoWsbfE6PGLjH4HN6xAhW0iMG0SP0iCHuHrCWHjHQ5HkfZr9HVHqYO0mHerWMyUUXXRTnnntu+ThJkjjnnHPiTW9607D33n777XHCCSdET89zj5l/5StfGZdccsmQ1z/yyCNx2GGHRXf3s78eYd68eXHzzTdHY+OmHy3/jW98Iy644IJ+55YsWTJsfSOxdOnSWLp06ZjubWlpiZ133rl83NbWGb29xU3cwfPB9OmNkcslUSqlg351BgAwuclxAMg2WQ4A2SbLASDbZDkAZJssn1oKhXy0tjZXds2KrjaFrVy5Mr75zW/2O3f00UePaHA7ImK//faLD33oQ/HVr361fO63v/1t3HXXXbFw4cJ+16ZpGp/+9KfLg9sREZ/97GeHHdyeaHPnzo25c+fWtAaypa4uH/l8blzfDAMAakOOA0C2yXIAyDZZDgDZJssBINtkOeNV2ed4T2E33XRTrF//3DcokiSJE044YVRrHHvssTF9+vR+52688cZB11133XXxhz/8oXz8+te/Pl71qleNsmIAAAAAAAAAAAAAoJo8ebtC7rzzzn7HO++8c2yxxRajWqOxsTH23nvv+OUvf1k+d/fddw+6buC5xsbGfk/s3pQNh777DLx36623jre+9a0jWg8AAAAAAAAAAAAAGBnD2xXyxBNP9DueN2/emNYZeN+yZcuGvWeop3OPxn/913/1O375y19ueBsAAAAAAAAAAAAAKixX6wKeL9avX9/vuKGhYUzrNDU19Tvu7u4ec00AAAAAAAAAAAAAwORheLtCZsyY0e+4vb19TOusXLmy3/GsWbPGWBEAAAAAAAAAAAAAMJkUal3A88WcOXP6Hd9///1RKpUilxvdfPzixYv7HW+22WaDrvnyl78cX/7yl0dfZER84xvfiAsuuKDfuSVLloxpLQAAAAAAAAAAAABg5Dx5u0L22GOPfsft7e1x2223jWqN+++/Px566KF+5/bee+9x1wYAAAAAAAAAAAAA1J7h7Qo54IADBp0755xzYvXq1SO6v7u7Oz7/+c+PaF0AAAAAAAAAAAAAIHsMb1fITjvtFK961av6nXv00Ufjve99byxbtmyT97a3t8f73//+WLx4cb/zu+22W+y3334VrxUmi/Xre6KzszvWr++pdSkAwCjJcQDINlkOANkmywEg22Q5AGSbLGe8CrUu4Pnk4x//eNx1113R2dlZPnf33XfHQQcdFEcccUS8+tWvju233z5aWlpi7dq18eijj8Zvf/vbuPbaa2PVqlX91qqvr4/TTz+92i8Bqqqzs7vWJQAAYyTHASDbZDkAZJssB4Bsk+UAkG2ynPEyvF1B8+fPj/POOy9OPvnk6Ol57hsVnZ2dceWVV8aVV145onXy+XycffbZsfvuu09QpQAAAAAAAAAAAABAteVqXcDzzQEHHBBXX311vOhFLxrT/VtttVVcddVV8YY3vKHClQEAAAAAAAAAAAAAteTJ2xNg1113jZtuuin+53/+J6699tpYvHhx9Pb2bvT6XC4XCxYsiLe+9a1xyCGHRGNjYxWrBQAAAAAAAAAAAACqIUnTNK11Ec9369atiwceeCAef/zx6OjoiM7Ozmhubo7p06fH3LlzY9ddd42WlpZalzmptLV1Rm9vsdZlMMFmz54W+XwuisVSrFy5ttblAACjIMcBINtkOQBkmywHgGyT5QCQbbJ8aikU8tHa2lzZNSu6GkNqamqKhQsXxsKFC2tdCgAAAAAAAAAAAABQI7laFwAAAAAAAAAAAAAAMBUY3gYAAAAAAAAAAAAAqALD2wAAAAAAAAAAAAAAVWB4GwAAAAAAAAAAAACgCgxvAwAAAAAAAAAAAABUgeFtAAAAAAAAAAAAAIAqMLwNAAAAAAAAAAAAAFAFhrcBAAAAAAAAAAAAAKqgUOsCgKlr9er1tS4BABgjOQ4A2SbLASDbZDkAZJssB4Bsk+WMl+FtoGZ6eoq1LgEAGCM5DgDZJssBINtkOQBkmywHgGyT5YxXrtYFAAAAAAAAAAAAAABMBYa3AQAAAAAAAAAAAACqoFDrAoCpq64uX/5nv0oCALJFjgNAtslyAMg2WQ4A2SbLASDbZDnjZXgbqJnp0xsjn89FsViKlSvX1rocAGAU5DgAZJssB4Bsk+UAkG2yHACyTZYzXrlaFwAAAAAAAAAAAAAAMBUY3gYAAAAAAAAAAAAAqALD2wAAAAAAAAAAAAAAVWB4GwAAAAAAAAAAAACgCgxvAwAAAAAAAAAAAABUgeFtAAAAAAAAAAAAAIAqMLwNAAAAAAAAAAAAAFAFhrcBAAAAAAAAAAAAAKrA8DYAAAAAAAAAAAAAQBUkaZqmtS4CBmpr64ze3mKtywAAAAAAAAAAAABgiioU8tHa2lzRNT15GwAAAAAAAAAAAACgCgxvAwAAAAAAAAAAAABUgeFtAAAAAAAAAAAAAIAqKNS6AGDqam6ujyRJIk3T6OzsrnU5AMAoyHEAyDZZDgDZJssBINtkOQBkmyxnvAxvAzXT2FgX+XwuisWSEAOAjJHjAJBtshwAsk2WA0C2yXIAyDZZznjlal0AAAAAAAAAAAAAAMBUYHgbAAAAAAAAAAAAAKAKDG8DAAAAAAAAAAAAAFSB4W0AAAAAAAAAAAAAgCowvA0AAAAAAAAAAAAAUAWGtwEAAAAAAAAAAAAAqsDwNgAAAAAAAAAAAABAFRjeBgAAAAAAAAAAAACogkKtCwCmrp6eYhSLpSiV0lqXAgCMkhwHgGyT5QCQbbIcALJNlgNAtslyxitJ09S7h0mnra0zenuLtS4DAAAAAAAAAAAAgCmqUMhHa2tzRdfMVXQ1AAAAAAAAAAAAAACGZHgbAAAAAAAAAAAAAKAKDG8DAAAAAAAAAAAAAFRBodYFAFPXzJlNkcslUSqlsWrVulqXAwCMghwHgGyT5QCQbbIcALJNlgNAtslyxsvwNlAz+Xwu8vlcFIulWpcCAIySHAeAbJPlAJBtshwAsk2WA0C2yXLGK1frAgAAAAAAAAAAAAAApgLD2wAAAAAAAAAAAAAAVWB4GwAAAAAAAAAAAACgCgxvAwAAAAAAAAAAAABUgeFtAAAAAAAAAAAAAIAqMLwNAAAAAAAAAAAAAFAFhrcBAAAAAAAAAAAAAKrA8DYAAAAAAAAAAAAAQBUUal0AMHV1dnZHkkSkaa0rAQBGS44DQLbJcgDINlkOANkmywEg22Q545WkqbcPk09bW2f09hZrXQYAAAAAAAAAAAAAU1ShkI/W1uaKrpmr6GoAAAAAAAAAAAAAAAzJ8DYAAAAAAAAAAAAAQBUUal0AMHXlckn5n0ultIaVAACjJccBINtkOQBkmywHgGyT5QCQbbKc8TK8DdTMrFnNkc/nolgsxcqVa2tdDgAwCnIcALJNlgNAtslyAMg2WQ4A2SbLGa9crQsAAAAAAAAAAAAAAJgKDG8DAAAAAAAAAAAAAFSB4W0AAAAAAAAAAAAAgCowvA0AAAAAAAAAAAAAUAWGtwEAAAAAAAAAAAAAqsDwNgAAAAAAAAAAAABAFRjeBgAAAAAAAAAAAACoAsPbAAAAAAAAAAAAAABVYHgbAAAAAAAAAAAAAKAKkjRN01oXAQO1tXVGb2+x1mUwwfL5JCKSiEijWNSKACBL5DgAZJssB4Bsk+UAkG2yHACyTZZPLYVCPlpbmyu7ZkVXAxiFZ4NLeAFAFslxAMg2WQ4A2SbLASDbZDkAZJssZ7xytS4AAAAAAAAAAAAAAGAqMLwNAAAAAAAAAAAAAFAFhVoXAExdDQ2FSJIk0jSNrq7eWpcDAIyCHAeAbJPlAJBtshwAsk2WA0C2yXLGy/A2UDPTpjVEPp+LYrEkxAAgY+Q4AGSbLAeAbJPlAJBtshwAsk2WM165WhcAAAAAAAAAAAAAADAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVIHhbQAAAAAAAAAAAACAKjC8DQAAAAAAAAAAAABQBYa3AQAAAAAAAAAAAACqoFDrAoCpq1RKI6L0//8OAGSJHAeAbJPlAJBtshwAsk2WA0C2yXLGK0nT1LuHSaetrTN6e4u1LgMAAAAAAAAAAACAKapQyEdra3NF18xVdDUAAAAAAAAAAAAAAIZkeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVEGh1gUAU1dLS0PkckmUSmmsWdNV63IAgFGQ4wCQbbIcALJNlgNAtslyAMg2Wc54Gd4Gaqa+vhD5fC6KxVJECDEAyBI5DgDZJssBINtkOQBkmywHgGyT5YxXrtYFAAAAAAAAAAAAAABMBYa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVIHhbQAAAAAAAAAAAACAKijUugBg6urq6o0kiUjTWlcCAIyWHAeAbJPlAJBtshwAsk2WA0C2yXLGK0lTbx8mn7a2zujtLda6DAAAAAAAAAAAAACmqEIhH62tzRVdM1fR1QAAAAAAAAAAAAAAGJLhbQAAAAAAAAAAAACAKjC8DQAAAAAAAAAAAABQBYVaFwBMXa2tzZHL5aJUKkVbW2etywEARkGOA0C2yXIAyDZZDgDZJssBINtkOePlydtAzSRJErlcEkmS1LoUAGCU5DgAZJssB4Bsk+UAkG2yHACyTZYzXoa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVIHhbQAAAAAAAAAAAACAKjC8DQAAAAAAAAAAAABQBYVaFwBMXWvWrI+IJCLSWpcCAIySHAeAbJPlAJBtshwAsk2WA0C2yXLGy/A2UDPd3cValwAAjJEcB4Bsk+UAkG2yHACyTZYDQLbJcsYrV+sCAAAAAAAAAAAAAACmAsPbAAAAAAAAAAAAAABVUKh1AcDUVSg89/2R3t5SDSsBAEZLjgNAtslyAMg2WQ4A2SbLASDbZDnjZXgbqJkZM5oin89FsViKlSvX1rocAGAU5DgAZJssB4Bsk+UAkG2yHACyTZYzXrnhLwEAAAAAAAAAAAAAYLwMbwMAAAAAAAAAAAAAVIHhbQAAAAAAAAAAAACAKjC8DQAAAAAAAAAAAABQBYa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAqSNE3TWhcBA7W1dUZvb7HWZTDBkuS5f9aJACBb5DgAZJssB4Bsk+UAkG2yHACyTZZPLYVCPlpbmyu7ZkVXAxgFwQUA2SXHASDbZDkAZJssB4Bsk+UAkG2ynPHK1boAAAAAAAAAAAAAAICpwPA2AAAAAAAAAAAAAEAVFGpdADB1NTXVRZIkkaZprFvXU+tyAIBRkOMAkG2yHACyTZYDQLbJcgDINlnOeBneBmqmqak+8vlcFIslIQYAGSPHASDbZDkAZJssB4Bsk+UAkG2ynPHK1boAAAAAAAAAAAAAAICpwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVIHhbQAAAAAAAAAAAACAKjC8DQAAAAAAAAAAAABQBYVaFwBMXb29pSiV0iiV0lqXAgCMkhwHgGyT5QCQbbIcALJNlgNAtslyxitJ09S7h0mnra0zenuLtS4DAAAAAAAAAAAAgCmqUMhHa2tzRdfMVXQ1AAAAAAAAAAAAAACGZHgbAAAAAAAAAAAAAKAKDG8DAAAAAAAAAAAAAFRBodYFAFPXjBlNkcslUSql0dGxrtblAACjIMcBINtkOQBkmywHgGyT5QCQbbKc8TK8DdRMoZCLfD4XxWKp1qUAAKMkxwEg22Q5AGSbLAeAbJPlAJBtspzxytW6AAAAAAAAAAAAAACAqcDwNgAAAAAAAAAAAABAFRjeBgAAAAAAAAAAAACoAsPbAAAAAAAAAAAAAABVYHgbAAAAAAAAAAAAAKAKDG8DAAAAAAAAAAAAAFRBodYFwFDyed8rmGoKhXytSwAAxkiOA0C2yXIAyDZZDgDZJssBINtk+fPfRMyzJmmaphVfFQAAAAAAAAAAAACAfjzeGAAAAAAAAAAAAACgCgxvAwAAAAAAAAAAAABUQaHWBQBT05///Of4/Oc/Xz7+zGc+EzvvvHMNKwIARkqOA0C2yXIAyDZZDgDZJssBINtkOZVgeBuoiTVr1sQf/vCHfscAQDbIcQDINlkOANkmywEg22Q5AGSbLKcScrUuAAAAAAAAAAAAAABgKjC8DQAAAAAAAAAAAABQBYa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVIHhbQAAAAAAAAAAAACAKjC8DQAAAAAAAAAAAABQBYa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKiCQq0LAKamuXPnximnnNLvGADIBjkOANkmywEg22Q5AGSbLAeAbJPlVEKSpmla6yIAAAAAAAAAAAAAAJ7vcrUuAAAAAAAAAAAAAABgKjC8DQAAAAAAAAAAAABQBYa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwMAAAAAAAAAAAAAVIHhbQAAAAAAAAAAAACAKjC8DQAAAAAAAAAAAABQBYa3AQAAAAAAAAAAAACqwPA2AAAAAAAAAAAAAEAVGN4GAAAAAAAAAAAAAKgCw9sAAAAAAAAAAAAAAFVgeBsAAAAAAAAAAAAAoAoMbwNMcmvWrKl1CQDAOPzqV7+K++67L9I0rXUpAMAYyHIAyC45DgDZJssBINtk+cYZ3gaYxL773e/G+eefH3//+99rXQoAMAZXXXVVnHjiiXHBBRfEgw8+6EMpAGSMLAeA7JLjAJBtshwAsk2Wb5rhbYBJ6rvf/W584QtfiKuuuiq+//3vG+AGgIz5zne+E1/60pciIuLXv/51XHHFFbF8+fIaVwUAjJQsB4DskuMAkG2yHACyTZYPz/A2wCTUN7jd59vf/nZcf/31BrgBICO+853vxBe/+MXy8axZs2L69OlRV1dXw6oAgJGS5QCQXXIcALJNlgNAtsnykSnUugAA+rv66qvLg9uFwrNtuqenJy677LKIiDjyyCNj6623rll9AMCmDfwwOnv27Dj88MPj6KOPjtmzZ9ewMgBgJGQ5AGSXHAeAbJPlAJBtsnzkPHkbYJJI0zQ6OjrixhtvjIiIxsbGKBaLUSwWo1AolAe4PYEbACavoT6MHnbYYXH00UfH3Llza1gZADASshwAskuOA0C2yXIAyDZZPjqGtwEmiSRJYsaMGbHffvtFRMT69esjTdNI0zR6e3ujvr7eADcATGIb+zB6zDHH+DAKABkgywEgu+Q4AGSbLAeAbJPlo2d4G2CSSNM0IiK23HLLiIjI5XKxzTbbxCtf+cqIiOju7jbADQCTlA+jAJBtshwAskuOA0C2yXIAyDZZPjaGtwEmiSRJIiJiv/32izlz5kSpVIoVK1bERz/60TjuuOMiwgA3AExGPowCQLbJcgDILjkOANkmywEg22T52BneBphk6uvro66uLiIiOjs744EHHohTTz01/vVf/zUiDHADwGRSiQ+jfb99AwCoPlkOANklxwEg22Q5AGSbLB8fw9sAk8wWW2wR++yzT/lJ3HfffXfU19fHZz7zmXjLW94SEQa4AWAyGOrD6KGHHjrsh9G+D6B9f+/L/J6enk1eDwBUliwHgOyS4wCQbbIcALJNlo9fodYFADDY3LlzI03TyOVy8Ze//CV6enqioaEhTj/99IiIuO6668oD3N3d3XHZZZdFRMSRRx4ZW2+9dS1LB4Ap4aqrroovfelLEfHsB8qZM2fGkUceGUceeeSwH0b7PoA+/fTTsWzZsrj11lvj6aefjlWrVkVjY2M0NDTEa1/72njhC18YCxYsKF+/4b0AwPjIcgDILjkOANkmywEg22R5ZRjeBphE+oJmzz33jIaGhuju7o77778//va3v8WOO+4YjY2NccYZZ0SEAW4AqJWf/OQn5Q+j9fX10dvbG1tssUW8+tWvjnnz5kWpVIpcrv8vOerL+L4PlNdff3388Ic/jCVLlsSaNWsG7XHLLbdEqVSK973vffGa17wmdtppp0iS5Hn5oRQAqk2WA0B2yXEAyDZZDgDZJssrx/A2wCTSFzDz588vD2/X1dXFP/7xj9hxxx2jVCpFQ0NDnHHGGZEkSVx77bWDBrjTNI23vOUt5QHuvuB6/PHHo6OjI3bZZZdavkQAyLQ0TWPNmjWx4447xkMPPRTd3d0REfHkk0/Gj3/849h8883Lv0Fj4LeA0zSN++67L66//vq4/vrry2sWCoUoFouRz+ejWCxGLpeL7u7uKBaL8R//8R9xxx13xJve9KY48sgjn5cfSgGgmmQ5AGSXHAeAbJPlAJBtsryyDG8DTDLFYjFmzZoV2223Xdx7773R1dUVv/rVr+LAAw8sh09DQ0OcfvrpERGDBrgvv/zyiHj2CdzbbLNNJEkSjz32WFx66aVxyy23xOmnnx6HHnporV4eAGRakiRx+OGHR0NDQ1x55ZXxwAMPRERER0dH/Pd//3f09PTESSedFFtuuWWkaRppmkYul4tSqRS//OUv49prr43f/va3EfFsnnd1dUWpVIo0TaO3tzcionzcl+2LFi2K5cuXx9NPPx3vf//7n3cfSgGgmmQ5AGSXHAeAbJPlAJBtsryyDG8DTDL5fD7y+XwsXLgw7r333kiSJJ5++umIiH7BM9wAd5qmcfzxx0dXV1d85zvfiZ///OexatWq+MQnPhGlUikOP/zwmrw+AMiyNE2jrq4u3vCGN0SapnHVVVeVP5SuWrUqbrnlloiI8ofSJEmiVCrFLbfcEldccUXcc8895bVyuVzMmDEjXvnKV8asWbOit7c3nnnmmXj44Yfj0Ucfje7u7igUCtHb2xuPPfZYXHPNNdHU1BTvfOc7n1cfSgGgmmQ5AGSXHAeAbJPlAJBtsryyDG8DTDJ94bLNNtuUj++66654+OGHY4cdduh37aYGuK+44oro6OiI7u7uuO2222LVqlVVfy0A8HzT90Gwrq4u3vjGN0ZEbPRD6Yknnhhz586Nu+++O6677rq45557yvfvuOOO8eY3vzle9apXxYtf/OJ+ezz22GNx++23xznnnBPr1q0r37N8+fK48cYbY4sttog3vOENmf8wCgC1IMsBILvkOABkmywHgGyT5ZVleBtgkukLl75vFq1evTp6enpizZo1Q14/1AB336+W+MEPfhCFQiG6urrK15911lmeug0A4zDSD6VJksQHPvCBuPXWW+OOO+4o37dw4cI466yz4oUvfGHU1dWVv7jV09MTdXV1se2228a2224bL3rRi+LMM8+Mhx9+uPyt5IceeihuvfXWOOCAA2LatGnPi28UA0C1yXIAyC45DgDZJssBINtkeeUkaZqmtS4CgMGWL18eb33rW+PJJ5+MiIgTTjghPvrRj0apVIpcLjfo+vXr18eZZ54Z1113XURE5PP5KBaL/a45++yz49BDD400TSNN0yHXAQBGZsMPkjfffHO/D6UREbNnz45tt9027r777vK5l7/85XHJJZdEfX39sOtGRNx1111x+umnx+OPP17+7RoREV/4whfiyCOPnKBXBgBTgywHgOyS4wCQbbIcALJNlo+fqT2ASWrzzTePfffdt3z897//PSJiyIHrNE2jsbExPv/5z5e/1dQ3uN0XaAcccEC89rWvLZ8zuA0A4zPwW8XHHntsLFiwoPznK1eujHvuuad8vNtuu8UFF1wQ9fX1g75gNXDdPgsXLowzzjgjIiK6u7vLH2R/9KMfxerVq6NUKlX4VQHA1CHLASC75DgAZJssB4Bsk+XjZ3IPYBLbfPPNI+LZYLr77rvj6aefHjLA+oLr73//e8yYMSPq6+sjSZJyUEZE3HHHHfGf//mf8dhjj1XvBQDA89xwH0r7viy17bbbxsc//vGYMWNGlEqlyOfzw67dl+EHHHBAvPvd746IiN7e3oiIeOihh6Kzs9OXsQBgnGQ5AGSXHAeAbJPlAJBtsnx8sl09wCTXFyRjve8Vr3hFNDU1RS6Xi6eeeiqeeuqpjQbYY489FldccUX85Cc/ie7u7n6/RqKhoSG6u7vj8ssvj+9///vlp3gDAJs2kizf1IfSNE2jvr4+Xve618VOO+0UEUP/Fo2Nrdtn4HodHR3xt7/9bbQvBwCmHFkOANklxwEg22Q5AGSbLJ9YhrcBKqgvtPr+3hckA88Pp+++efPmRT6fLz9te/HixRERg56+/fjjj8dVV10VP/7xj2PVqlXl8wsXLoyIiK6urqivr4+enp64/PLL47rrrjPADQBDGGuWD/WhdNddd41SqRQNDQ1x2GGHRUtLy5jres1rXhNbbLFFRET09PRERER7e/uY1wOA5ytZDgDZJccBINtkOQBkmyyvrkKtCwB4Prjvvvti2bJl8Ytf/CLWrl0bSZLEzJkzY6uttoqDDjoopk+fHrNnz+4Xaht+Q2gopVIptthii9hhhx1i8eLFkaZpLFq0KI455ph+T99+/PHH48orrxw0uP3lL385DjvssPjsZz8b1157bXR3d0d9fX35CdxJksSRRx4ZW2+99cT8SwGADKlElg/8UJqmaVx11VVx4IEHxvbbbz+i/B9K34fgXC4XaZpGoVCI3t7eEf06KQCYKmQ5AGSXHAeAbJPlAJBtsrw2DG8DjMOKFSviuuuui29/+9vR29sb69evH3TNFVdcEfPmzYu3vvWt8S//8i/R0tISSZJEsVjcZJDkcrmor6+PXXbZJe65557I5/OxdOnSWLduXTQ1NUXExge3zzzzzDjssMMiIuITn/hERMSQA9yrV6+OD3zgAzF79uwK/lsBgOyodJZv+KH04IMPjunTp8dWW21V/rOxKJVK0d7eHqtXry6fa2pqKv9qKQCYymQ5AGSXHAeAbJPlAJBtsry2DG8DjNE999wT3/72t+PWW2+NiIhCoRD5fL4cQt3d3ZHP52PlypWxcuXKuPfee+O2226LffbZp/z07FKpFLlcbsj1+/7sRS96UUREFIvFuP/++2PJkiWx++67b3Jw+81vfnP5nubm5jj99NMj4tkB7p6enmhoaIiurq5Yv369wW0ApqyJyvINP5S+5jWvGfMH0Yhnv0mcz+dj9erV0dPTU/4m8bRp06JQ8HEOgKlNlgNAdslxAMg2WQ4A2SbLay/7rwCgBu666644//zzY9GiReVzvb29/f45TdMoFosREeVh6Z///Ofxm9/8Ju6+++4466yzor6+fqN79IXbq171qpg2bVp0dXVFkiSxdu3aWLFixbCD26VSqfwNp4aGhjj99NMjSZK45pproqurKw4//PA466yzImLoX2cBAM9nE53lfbk63nxNkiS6u7vjyiuvjK6urvKH0KOOOirmzp07rrUBIMtkOQBklxwHgGyT5QCQbbJ8cjC8DTBKjzzySHzrW9+KRYsWlb8ttN1228Xee+8d++yzT7S0tMSaNWvi97//fdx///3x4IMPRldXV/nbScViMW6++eZ48skn46Mf/Wjssssu0djYOORepVIpGhsbo7m5OdauXRsREZdeemlst912cfPNN29ycHvgN5saGhriU5/6VHR0dERXV1d5cHtTT/8GgOejamZ5JTz00ENx3333RcSzv1WjqakpFixYMGH7AcBkJ8sBILvkOABkmywHgGyT5ZNHkqZpWusiALLki1/8YnznO98pH7/sZS+Ls846K+bNmxcNDQ39rn3iiSdi0aJF8fWvfz3a29v7fQuot7c35s+fH+973/vin/7pn6KlpWWje37yk5+MH/7wh5HP52P69OnR09NTHuaOGH5we0O9vb3lGgxuAzAV1SLLR6svo4vFYnzyk5+MH//4x+UPz0cccUR88YtfrNheAJA1shwAskuOA0C2yXIAyDZZPnkY3gYYhVtuuSU+9KEPlY9f+tKXxkUXXRSbbbZZv+s2HJCOiLjvvvvixz/+cfzkJz+JFStWRKFQKH8badttt43jjjsuXv/610dra+uQ+37lK1+JSy+9NHK5XKRpWg6oiNENbm8oTdNx/3oKAMiaWmX5WH3uc5+Lq6++uny89957x/nnnx+zZ8/2JSwApiRZDgDZJccBINtkOQBkmyyfXArDXwJA36DzokWLIpfLRaFQiHw+H8ccc0xsttlmgwah+wKs7/yuu+4ac+fOjQULFsQFF1wQf//738trPPbYY3HJJZfEmjVr4ogjjojZs2cP2v/tb3973HnnnXHfffdFfX19dHd3R8TYB7cjwuA2AFNKrbN8NDVGRKxZsybOPvvsuP7668t//pKXvCTe9a53xaxZsyIiMv9hFABGQ5YDQHbJcQDINlkOANkmyyen7L8CgCpIkiQ6OjriF7/4RZRKpeju7o58Ph+77rpr+c83dl+fF7zgBfHGN74xzjvvvNhhhx2it7c3crlc5PP5WLp0aVxzzTXxk5/8JFavXj1onS233DI++clPxu67714e3D7rrLPGPLgNAFNNrbN8OMViMZIkia6urvj9738fp59+er8Po9ttt10cffTRse+++8p8AKYkWQ4A2SXHASDbZDkAZJssn5yeP68EYIJ1dHREV1dXFAqFyOVyse2228b2228/qjUKhUIsWLAgLr744thxxx2jp6enX5BdddVVcdttt8W6dev63ZfP52OPPfaI0047LXbYYYf493//9zj88MMjwuA2AIxULbN8OPl8Pp555pk477zz4uyzz45bb721/Gfbb799HHPMMXHQQQdFY2PjqNYFgOcTWQ4A2SXHASDbZDkAZJssn3wKtS4AICvWrVtXDpc0TWPdunXR2dkZLS0to1onTdOYO3duXHXVVXH88cfHn/70p6irq4uIiMceeywuvvji2GyzzWLfffftN5idy+Vijz32iCuvvLL8KybSNDW4DQAjVOss35hf/epX8de//jW+853vxNKlSyPi2W8xp2kau+yySxx77LHxmte8ZtR1AsDzjSwHgOyS4wCQbbIcALJNlk8+SZqmaa2LAMiCf/zjH3HIIYeUg6ypqSmuv/762GGHHUa9VrFYjHw+Hx0dHXHsscfGkiVLoq6uLkqlUhSLxdh9993j0ksvjWnTppWvHShN043+2goAYLDJluUREUuWLIlDDz20fFwoFKJYLEaaprH//vvHKaecEgsWLIj6+vqxvWgAeB6R5QCQXXIc/l97dx5fRXX4//89d8kewiKL7BDZkUURRERxAdeCWLeCIFWr2A8WrRZo61Kt1gVaxdqvFNRW2QRBQa0KCIqsEkFEQBHZ1yAQErLd3Htnfn/kd6+5JpCFbCd5Pf+xM3fmzLkh+Hq0PTMDAGaj5QAAmI2WVz88rhUASsBxHCUkJKhRo0ayLEter1eBQEBr166VlB+l0nC73QoGg6pTp46mTJmidu3aye/3y7Isud1ubdy4UX/84x/DxxZ1nw0LtwEAKLnq2HJJ6tChg/7xj38oNjY2PM/o6Gjdcsst+te//qWePXvW2P8yCgBAadByAADMRccBADAbLQcAwGy0vHpi8TYAlIBlWapbt6769Okjx3EUCATk9/u1dOlSSacPzam43W7Ztq2zzz5bEydOVKtWrRQIBMIhW7JkiaZNmxa+PgAAKLvq2PLQ9a699lo99dRTkqT+/fvrz3/+s5588knFxMSUek4AANRUtBwAAHPRcQAAzEbLAQAwGy2vnli8DQAlYNu2JKlnz56S8l/T4HK5tGbNmjNaYO1y5f9ruH379ho7dqwaNWqkQCAgx3HkOI7Wrl2rI0eOSFKNDxIAABWpOrbcsqzwvuuuu07/+9//9Pjjj+vmm28Oz5kbuAAAyEfLAQAwFx0HAMBstBwAALPR8uqJxdsAUAKh2AwcOFAtW7YMv+pBkj7//HNt3rz5jMfv27evbrjhBsXGxobjtGrVKi1ZskQST98GAOBMVNeWF/wvpcnJyTr77LMl5f+X19CcAQAALQcAwGR0HAAAs9FyAADMRsurp5r/DQGgnASDQSUkJOiuu+5SfHy8gsGgJCklJUX/+9//lJOTI6nsT8iuV6+err32WjVp0kSO4ygmJkaS9MYbb+jgwYPl8yUAAKjFqmvLT/VfVAEAQCRaDgCAueg4AABmo+UAAJiNllc/LN4GgBJyu92SpPPOO09NmzaVJEVHR0uS/vOf/+idd96RFHlXUGl17NhRY8eOlSTl5ubKsiylpaXp2LFjZzp9AABqPVoOAIDZaDkAAOai4wAAmI2WAwBgNlpe/bB4GwBKqV27drrvvvskST6fLxyyv/71r/r4448llS1koeP79euniy66SFJ+OE+ePKl333034hgAAFB2tBwAALPRcgAAzEXHAQAwGy0HAMBstLz6YPE2AJRCKCLXXnutfve730mKDNlDDz2kpUuXSip9yEKvfEhMTFTXrl0lSbZtS5IOHz4ccQwAACgbWg4AgNloOQAA5qLjAACYjZYDAGA2Wl69sHgbAEqhYJiGDBmi6667TlJ+yLxer4LBoCZMmKDPPvus0PElEYrWJZdcori4OLndblmWpaNHjyonJ6d8vwwAALUQLQcAwGy0HAAAc9FxAADMRssBADAbLa9eWLwNAKUUuguoWbNmuummm8KvevD7/fJ4PDp58qTGjRtXpjuRXK78fy3HxMQoLy9Pfr9fjuMoLy8v/BkAADgztBwAALPRcgAAzEXHAQAwGy0HAMBstLz64CcCAGUQilLfvn112223qUePHpKkQCAgj8ejjIwMjR07VosWLZJU8tc+FIyd2+2Wx+ORlP9KCV4dAQBA+aHlAACYjZYDAGAuOg4AgNloOQAAZqPl1QOLtwGgDAreVTRo0CDdcsst6tChg6T8kHm9XgUCAY0dO1Zz5sxRXl5e+NzT3Y0UGnfVqlXy+Xzh/RdffLGioqIq6NsAAFD70HIAAMxGywEAMBcdBwDAbLQcAACz0fLqgcXbAFBGBUN24403auTIkerWrZuk/FdJREdHS5Ief/xx/fOf/9S2bdvC5wWDwULjhcbKzMzUl19+KUmybVuS1Lp16wr9LgAA1Ea0HAAAs9FyAADMRccBADAbLQcAwGy0vOpZzumWwgMAimXbtlyu/HthFi1apNmzZ2vt2rWSpOjo6PCdRP369dNll12m22+/PXxu6F/BBV8N8dhjj2nu3Lnh7UGDBumll16q8O8BAEBtRcsBADAbLQcAwFx0HAAAs9FyAADMRsurDou3AaAcFAzZypUr9fbbb2vRokWSpJiYGOXm5krKj9Wll16qwYMHq1u3bmrevLkk6eTJk9q8ebPeeecdvf/+++FxO3furCeeeELnnntuxDUAAED5ouUAAJiNlgMAYC46DgCA2Wg5AABmo+VVg8XbAFBOCkZm9+7dWrhwoV555RVJksvlCr9uwrZtxcfHKzo6Wh07dpTX69X+/fuVnp6uo0ePhsdr3bq17rrrLg0ePDj8KgoAAFBxaDkAAGaj5QAAmIuOAwBgNloOAIDZaHnlY/E2AJSB4zgRr3w41f733ntPL774otLS0pSTkyOv16tAICC3261AIBBxrsfjUTAYlOM4ateunW677TYNGTJECQkJFf59AACobWg5AABmo+UAAJiLjgMAYDZaDgCA2Wh59cDibQAopYKh2rBhgyzLUs+ePU95/NatW7VmzRrNmjVLBw4ciPgsKipKtm2HwxYMBtW3b1+NGDFCffr0UXx8fIV+FwAAaiNaDgCA2Wg5AADmouMAAJiNlgMAYDZaXn2weBsASuHnAZsyZYq++OILPfPMM7r22mtPeawkpaWlad68efruu++0YsUKZWRkSPrpzqPLLrtMnTt31m9/+9vwaygAAED5ouUAAJiNlgMAYC46DgCA2Wg5AABmo+XVC4u3AdQItm2f8l/8p/usNApGaf369XrjjTe0fPly+Xw+SdI///lPDRw4sMhzg8Gg3G53eHvfvn3KzMxUWlqaEhISlJCQoLZt2xZ5LQAAagNaDgCA2Wg5AADmouMAAJiNlgMAYDZaXjt5qnoCAFAeXC6XcnJylJOTo/T0dFmWpaZNmyoqKqrCArZs2TIFAoHwMS1atDjl+aGAhYLavHnzU0aKgAEAaiNaDgCA2Wg5AADmouMAAJiNlgMAYDZaXjvx5G0Axlu6dKm++OILffLJJ8rOztaJEyckSe3atVOTJk00dOhQtW7dWp07dw6fU5q7kooLWFxcnGbNmqWOHTsWutMIAAAUj5YDAGA2Wg4AgLnoOAAAZqPlAACYjZbXXizeBmCsPXv2aNasWXrjjTdkWZYcx1F0dLT8fr9s25bH41EgEFBUVJTcbrfGjBmjPn36qGvXrpIKv9KhKAQMAICKQ8sBADAbLQcAwFx0HAAAs9FyAADMRsvB4m0ARvryyy81bdo0LV++XJLCwQrFTMp/ZYPjOPJ4PMrLy5MkderUSQMGDNDYsWOLvQYBAwCg4tByAADMRssBADAXHQcAwGy0HAAAs9FySCzeBmCgTZs2aeLEiUpJSQnvS0hIUGxsrM4991xlZWXp5MmT2rNnj7KysiRJ0dHR8vl84eMHDRqkRx99VA0aNCj2NRLr16/Xm2++qaVLlxIwAADKAS0HAMBstBwAAHPRcQAAzEbLAQAwGy1HiKeqJwAApXHgwAFNmzZNKSkp4buNOnXqpFGjRqlnz55q2bKlgsGgHMfRqlWrlJKSoldffVU+n0+WZcnlcslxHC1evFg//vij7rvvPvXu3VsxMTFFXu/777/X5MmTtXHjRgWDQUkEDACAM0HLAQAwGy0HAMBcdBwAALPRcgAAzEbLURBP3gZglH/84x+aOnVqeLtHjx6aPHmyGjduLEnhV0eEXvsgSR9++KEmTZqkQ4cOhV8nYdu2bNtWx44ddffdd2vAgAFKSEgo8pq//vWvtWbNGkn5dzrNmDGDgAEAUEa0HAAAs9FyAADMRccBADAbLQcAwGy0HAWxeBuAMT777DONHj06vN2hQwdNnTpVjRs3luM4EeGSFLFvxYoVevbZZ7Vjx46I10XYtq22bdtq+PDh+sUvfqE6depEfBY69qabbtLmzZu1YMECAgYAQBnRcgAAzEbLAQAwFx0HAMBstBwAALPRcvycp6onAADFCcVk3bp1crlccrvdsixLt9xyixo1alRkwCSFXy9hWZb69+8v27Y1btw4paenh+9Ccrlc2rlzp9544w05jqMbbrghfCeSy+VSIBCQx+PRvHnztHfv3vDrKQgYAAAlR8sBADAbLQcAwFx0HAAAs9FyAADMRstxKq7iDwGAquVyuZSdna2PPvpItm3L7/crJiZGffv2lWVZRQYsJBQySbr00ks1btw4SVIgEIg4Zu/evZo9e7ZWrlypvLy88Gcejyd8bMuWLWXbNgEDAKCUaDkAAGaj5QAAmIuOAwBgNloOAIDZaDlOhcXbAIxw8uRJZWVlKTo6WpLUpk0btWjRQsFgsNhzC4ZsyJAhuuaaa8Kf2bYty7Lkcrm0Y8cOTZ06VRs3bgx/JuWHLKTgqycAAEDJ0XIAAMxGywEAMBcdBwDAbLQcAACz0XIUhT8NAEZITU1VRkaG/H6/pPyo+f3+Et8NFLpLyePxqEuXLhH7Qq+RcLlc2rp1q15++WXl5eXJ5XKVKJIAAKB4tBwAALPRcgAAzEXHAQAwGy0HAMBstBxFYfE2AONYliW/3x++Qyh0d1FxQscNGjRIderUkWVZ8nq9qlevngKBgNxut9xut9atW6enn35aknhVBAAAFYCWAwBgNloOAIC56DgAAGaj5QAAmI2WI4TF2wCM0KJFC9WvXz8clX379mnBggWSfrqTqDih4wKBgLKzsxUIBNSqVStNmjRJZ599tvx+f/hOpCVLluiDDz6okO8CAEBtRMsBADAbLQcAwFx0HAAAs9FyAADMRstRFBZvAzBCXFycEhMTI14ZkZKSotTU1BKPEboDKXTnkdvtVlpamjp06KDx48frrLPOkt/vl+M4On78uNauXVsh3wUAgNqIlgMAYDZaDgCAueg4AABmo+UAAJiNlqMoLN4GUO3Ztq3o6GjdeOON8ng84f2LFi3SJ598UuJxLMuS4zhatmyZcnJyFAwG5fV6FRsbq969e2vo0KGKjY0Nx27evHmEDACAckDLAQAwGy0HAMBcdBwAALPRcgAAzEbLcSos3gZQ7blc+f+q6tatm6T81z9ER0dLkv76179qyZIlxY5h27YkKSsrS+vWrQvv79u3r+Lj41W/fn1de+21atWqlSQpJiZGLpdLK1asiDgfAACUHi0HAMBstBwAAHPRcQAAzEbLAQAwGy3HqbB4G4Ax+vbtqzFjxkiSfD5fOGT333+/Pvroo4hjg8GgpJ9eGREK4UsvvaTly5eHj2vTpk34P3fq1El33nmnJCk3N1e2bWv58uXKysoKnw8AAMqOlgMAYDZaDgCAueg4AABmo+UAAJiNluPn+FMBYIRQjH7xi1/ommuukRQZsgcffFD/7//9P3333XeSJLfbLSn/lRG2bSstLU1PP/203nzzzfCYvXr10l133SXpp+gNGDBAvXv3lmVZ8ng8OnHihA4fPlw5XxIAgBqMlgMAYDZaDgCAueg4AABmo+UAAJiNlqMonqqeAADYtl3sHT6WZUmSmjVrpttuu03p6elavXp1OGQ+n08vvfSSlixZovPPP18XX3yxEhISJEnLli3T1q1btXbt2vB4rVq10vDhw+V2u2Xbdjh6derUUbt27bRu3ToFg0EdPXpU3377rZKTkyvo2wMAYD5aDgCA2Wg5AADmouMAAJiNlgMAYDZajrJi8TaAKhMMBuV2uxUIBBQVFVXoc8dxwvEqqE+fPsrOzpbb7daKFSsiQvbdd9/p22+/1bx585SXlyev1yufzxdxfsuWLfXLX/5SF198saSfXi0Riulll12m2bNnKyoqSrm5uYXOBwAA+Wg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5zhSLtwFUuo0bN2r//v1atmyZsrKy5Pf71bBhQ9WvX19DhgxRUlKSzj777HDACsYs9J8vu+wyJSUlqV69enrvvffk8/nkcrnkcrkUDAYVCARk27aCwaA8Ho9s25Zt2+rQoYOGDRuma665RomJiRHzCsUsJiZGtm0rEAhIkjIyMirxpwMAQPVHywEAMBstBwDAXHQcAACz0XIAAMxGy1FeWLwNoNKkpqbq7bff1quvvirbtpWXl1fomAULFig2NlZ33323LrroIrVu3VqWZYXvVrIsKxyy8847T+3bt1eXLl00ZcoU5ebmKicnR1L+3USSwiGSpAEDBuiee+5Rp06dFBsbe8o7nDIzMyPGKOoYAABqI1oOAIDZaDkAAOai4wAAmI2WAwBgNlqO8sbibQCV4quvvtJrr72mTz75RJLk9XrldrvlOI68Xq8CgYAsy1J6errS0tL05JNP6oILLlDfvn3129/+Vm63OzxWwagkJCTojjvu0HnnnaedO3fqrbfeUk5Ojo4cOaKYmBh5vV5dccUVSk5O1i9/+cuIOf08TqFQHj9+XJZlyePxyOVyqXPnzhX4kwEAwAy0HAAAs9FyAADMRccBADAbLQcAwGy0HBXBchzHqepJAKjZvvzyS02ePFkpKSlFfu7xeCLuFIqOjpbP5wtvDxw4UH/605/UqFGjiJhJKnQXkd/vVzAY1I8//qiEhARJUr169cKfh0J1Knl5ebr33nu1Zs2a8Fzmzp2rDh06lOIbAwBQs9ByAADMRssBADAXHQcAwGy0HAAAs9FyVBSevA2gQu3atUv//ve/lZKSEn71Q5s2bdSvXz/169dPiYmJCgaD+uyzz/T9999r1apV4YB5PB7Ztq0lS5bo6NGjGjlypPr376+EhIRwvAoGLHQ3k9frVYsWLYqcz+kCJklr1qzRzp075Xa7Zdu2rr76agIGAKjVaDkAAGaj5QAAmIuOAwBgNloOAIDZaDkqEou3AVSo2bNna8WKFZLyI9O9e3dNnDhRTZo0UVRUVPi4Pn36KCsrS59++qlef/117d69W9nZ2fJ6vZLyXz9x4sQJHT58WEOHDlXdunUL3X3089dBlJRt23K5XMrMzNT8+fOVmpoaDu655557Bt8eAADz0XIAAMxGywEAMBcdBwDAbLQcAACz0XJUJMtxHKeqJwGgZvrkk080ZsyY8HbHjh31yiuv6Oyzz44IUCgiIdu2bdPy5cv15ptv6ujRo/J6vQoGg7JtW02bNtWQIUM0fPhwnXXWWYVCdiYee+wxzZ07N7x92WWX6ZVXXimXsQEAMBEtBwDAbLQcAABz0XEAAMxGywEAMBstR0XjydsAyl0oLBs2bJDL5ZLH45HL5dJtt91WKGCSwgEL7e/QoYNatGihLl266NFHH9XBgwfDdyIdPHhQb7/9trKysnTPPfeUOWQFzzl58qQmTpwYEbDOnTvr3nvvlVQ4sgAA1HS0HAAAs9FyAADMRccBADAbLQcAwGy0HJWFPxUA5c6yLGVnZ2vJkiWybVt5eXmyLEs9evQIf36q80Li4uLUr18/zZo1S8nJyfL7/XK5XLIsS0ePHtWHH36o6dOnKy0trdQBs207PMcVK1boj3/8Y0TAWrdurWHDhqlTp06SRMAAALUOLQcAwGy0HAAAc9FxAADMRssBADAbLUdl4cnbACpEbm6ufD5f+NUPzZs3V6tWrUo1RjAYVJMmTTR9+nTde++9+uabb+R2u2Xbto4ePar3339fSUlJuvnmm5WYmFjicbOzs5WWlqaXX35ZmzZt0q5du8KfJScn67bbbtPVV1+t6OjoUs0XAICahJYDAGA2Wg4AgLnoOAAAZqPlAACYjZajMrCsHkCFyM3NVXZ2tmzblm3bOnnypNLT00s1htvtVjAYVP369TVt2jRdcMEFCgaDcrvdcrlcOnjwoObMmaNPP/1Ufr+/RGOeOHFC7777rq6//notXLhQe/bsCd/B1L17d913330aOnSoEhISSv2dAQCoSWg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5KgOLtwFUCI/HI8dxFAwGJUkZGRk6ceJEqccJhaxu3br65z//qe7duysQCIRDtmfPHs2YMUMHDhyQpPD1TiUhIUFt2rQJvxrCtm05jqMrr7xSTzzxhAYNGkTAAAAQLQcAwHS0HAAAc9FxAADMRssBADAbLUdlYPE2gHLnOI7q1aundu3aye12y+v1Kjs7W//73/8UCARk23apxisYsldeeUXt2rWT3+8Ph2zTpk16/vnnw8eebnyPx6MLL7xQ9913n84//3x16dJFDzzwgF5++WV17NhRUVFRZ/TdAQCoCWg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5KovlOI5T1ZMAUDM9/fTTmj59uizLkuM4uuCCCzR9+nRJ+Xf+uFylu38k9OqII0eOaNiwYdq/f7+8Xq+CwaBs29a9996rBx98sERjBQIBHThwQIFAQMnJyWWeEwAANRktBwDAbLQcAABz0XEAAMxGywEAMBstR0XjTwtAuQvdAXTJJZcoLi5OHo9HlmUpJSVFkydPlqQyxSJ0J1KjRo309NNPq2HDhvL7/XK5XLIsSytXrtS3335borE8Ho9atWoVDpjjOAQMAID/Hy0HAMBstBwAAHPRcQAAzEbLAQAwGy1HZeFPDEC5C8Wge/fuatKkifx+fzhkixcv1qpVq8o8ttvtliT16NFDv/nNb5SQkKBAICDHcbRly5Yyj21ZVpnnBABATUPLAQAwGy0HAMBcdBwAALPRcgAAzEbLUVlYvA2gQti2rTp16uihhx5SQkKC/H6/HMfRjh079OGHH+rgwYNnNH50dLQuvvhiderUSZIUFRUlSZoyZYp27tx5xvMHAKC2o+UAAJiNlgMAYC46DgCA2Wg5AABmo+WoDCzeBlAhQnchtW/fXt26dZMkeb1eSdL8+fP1/vvvn/E12rZtqzvuuEOSlJeXJ4/HI0lKTU2VlP9KCAAAUDa0HAAAs9FyAADMRccBADAbLQcAwGy0HJWBxdsAKlSLFi106623SpL8fr+io6MlSS+88IIWLFhQ5nFDgbryyit1zTXXhPdlZmZq/vz5knglBAAA5YGWAwBgNloOAIC56DgAAGaj5QAAmI2WoyKxeBtAhQmF5qqrrtL48eMlST6fLxyyCRMmaNGiRRHHllTBQIVeIRGSlpbG3UcAAJQDWg4AgNloOQAA5qLjAACYjZYDAGA2Wo6KxuJtABXGsizZti1JGj58uG655RZJkSEbO3asPvvsszLdLRQa+4orrlBCQkL4lRWHDh3SiRMnyuEbAABQu9FyAADMRssBADAXHQcAwGy0HAAAs9FyVDQWbwOoUKGwREVFadiwYRo0aJCkyJCNHj1aS5YsKfPYofH8fr8kye12KyYm5kynDgAARMsBADAdLQcAwFx0HAAAs9FyAADMRstRkVi8DaDSdOzYUSNHjlT//v0lRYbs/vvv18KFC8s0rmVZ8nq98ng8kqTY2Njw3UkAAKD80HIAAMxGywEAMBcdBwDAbLQcAACz0XKUN09VTwBA7dKrVy+dPHlSubm5SklJCYfM5/Np/PjxOnr0qK6//no1btxYUv4rIgreaVSUzz//XNnZ2eGIXXzxxYqPj6/w7wIAQG1EywEAMBstBwDAXHQcAACz0XIAAMxGy1GeWLwNoNI4jiPLsnTZZZfJtm1FRUVp1apVESGbOHGi9u7dq+uuu069e/eWy+VSMBiU2+0ucsycnBytXbtWksJ3HbVt27bSvhMAALUJLQcAwGy0HAAAc9FxAADMRssBADAbLUd5Y/E2gEpjWVY4ZFdccYUSExMVFxenJUuWRIRszpw5+uabbzRo0CCNHj06fAeSbduyLEuWZUmSgsGgnnnmGX322Wfhz6+44gpdf/31VfUVAQCo0Wg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5yhuLtwFUqoIh6927txISElSnTh3Nnz9fPp9PXq9Xfr9fW7du1datW5WSkqKLL75YAwcOVP369RUXF6f09HRt3LhR7733nv73v/+Fx+7UqZPuvvtuSSV77QQAACg9Wg4AgNloOQAA5qLjAACYjZYDAGA2Wo7yZDmO41T1JADUPqGQSVJmZqZmzZqlf/zjH+HPPR6PgsGgHMeRy+VSnTp11Lx5cyUkJOjQoUNKT0/XiRMnwse3bt1av/71rzVkyBDFxMRU9tcBAKDWoeUAAJiNlgMAYC46DgCA2Wg5AABmo+UoDyzeBlDhCgar4J1BBfdL0ocffqg333xT33//vbKzs+X1ehUIBOTxeOT3+yPGLBi5du3a6bbbbtOQIUOUkJBQeV8MAIBagpYDAGA2Wg4AgLnoOAAAZqPlAACYjZajorB4G0CFKhiqr776StnZ2erRo4fi4+PDxxQM244dO7Rlyxa99NJLOnTokILBoFwul2zbVnR0tGzblt/vD++76KKLdMcdd+iCCy5QXFxclXxHAABqMloOAIDZaDkAAOai4wAAmI2WAwBgNlqOisTibaAWS09PV1JSUoWNXzBgGzZs0JQpU7R+/Xo9/PDD+sUvfhFxt9DP70Y6fvy4Pv/8c61bt04pKSnat2+fXC5XOHZXXnmlOnXqpHvvvbfC5g8AQHVHywEAMBstBwDAXHQcAACz0XIAAMxGy2E6Fm8DtdRbb72lr7/+WnfddZfOOeecch+/YJTWr1+vN954Q8uXL5fP55MkPfXUU/rlL38ZEa6QYDAot9sd3k5LS1NaWppyc3MVHR2t6OhoNW/evMhrAQBQW9ByAADMRssBADAXHQcAwGy0HAAAs9Fy1ASeqp4AgMo3c+ZM/fWvf5XH41F8fLx+9atfKTk5udzGLypgy5YtUyAQCB/TtWvXU4YnFLDQayWSkpJUr169Yq8FAEBtQcsBADAbLQcAwFx0HAAAs9FyAADMRstRU7iqegIAKlcoYJIUCAT0zjvvaObMmdqxY0e5jF9cwOLi4rRgwQJ17NhRwWDwtGOFXhUR+mdRCBgAoLah5QAAmI2WAwBgLjoOAIDZaDkAAGaj5ahJePI2UIvMmjUrHDCPxyPHcZSdna0FCxZIkoYPH35GdyKVJGCzZs0KB6zgKyIAAEDxaDkAAGaj5QAAmIuOAwBgNloOAIDZaDlqGp68DdQSmZmZWrp0qSQpJiZGwWBQtm3L7XaHQ3YmdyIRMAAAKhYtBwDAbLQcAABz0XEAAMxGywEAMBstR03E4m2glkhISFDXrl0lSbm5uXIcR47jyLZteTyeMw4ZAQMAoGLRcgAAzEbLAQAwFx0HAMBstBwAALPRctRELN4GagHHcSRJbdq0kSS53W61bNlSPXv2DIfM6/Wecch27Nih119/nYABAFDOaDkAAGaj5QAAmIuOAwBgNloOAIDZaDlqKhZvA7VA6O6gXr16qUGDBgoGg8rOztaLL76oW265RbZtKxgMnnHIWrVqJbfbHQ5YfHw8AQMAoBzQcgAAzEbLAQAwFx0HAMBstBwAALPRctRULN4GagnHcRQdHa24uDhJ0tGjR7V06VI9+eSTuu666844ZKHXUEyaNEkXXXSRoqKiNHPmTAIGAEA5oeUAAJiNlgMAYC46DgCA2Wg5AABmo+WoiTxVPQEAlcOyLDVs2FB9+/bVvn37JEnffPONJOnvf/+73G633nvvPUmKCJkkDR8+XMnJyacd3+VyKRgMKioqSlOmTNGRI0fUvHlzAgYAQDmh5QAAmI2WAwBgLjoOAIDZaDkAAGaj5aiJePI2UEs4jiNJatSokaT8qG3atEnHjx+XJD3//PMaMmRIkXcizZgxo0R3IoVeHREVFaXmzZvLcRwCBgBAOaHlAACYjZYDAGAuOg4AgNloOQAAZqPlqIlYvA3UMpdccoliY2MlSfv27QtHTJKee+65IkO2cOHCEofM4/npgf6WZZX/FwAAoJaj5QAAmI2WAwBgLjoOAIDZaDkAAGaj5ahJWLwN1BKhoDRu3Fgul0uO48i2bW3dulWSlJeXJ6l0IQvd1bRv3z59/fXXysnJqeRvBQBA7UHLAQAwGy0HAMBcdBwAALPRcgAAzEbLUROxeBuoRYLBoBo3bqyePXtKkgKBgL788ktJUlRUlILBoKTiQ/bDDz9Iyg/jnj17NHXqVD3wwAP64IMPlJ2dXTVfDgCAWoCWAwBgNloOAIC56DgAAGaj5QAAmI2Wo6Zh8TZQi7jdbklSu3btJOVH6MCBAwoGg3IcR263W4FAQNLpQzZz5kwdOHBAqampmj59uj755BMdOnRITz75pN57771wDAEAQPmi5QAAmI2WAwBgLjoOAIDZaDkAAGaj5ahpPFU9AQCVx3EcWZalLl26hLc3bNigPXv2qG3btpIkj8ejQCAgj8ej5557TpK0cOFCSYoI2cmTJ2VZlj7//HOlp6dLkvx+v+Li4sKxBAAA5YuWAwBgNloOAIC56DgAAGaj5QAAmI2Wo6Zh8TZQi1iWJUnq2bOnkpKSdPLkSdm2rePHj4cjJpUsZB9//LFcLpfy8vLC5z3zzDMaPHhwJX4jAABqF1oOAIDZaDkAAOai4wAAmI2WAwBgNlqOmsZV1RMAULkcx1FUVJTq1q0r27bl8/m0ZMmS8GchoZBJka+SCAQC4ddMFAzYpEmTNHToUDmOI9u2K/dLAQBQi9ByAADMRssBADAXHQcAwGy0HAAAs9Fy1CQs3gZqGcuy1LBhQ/Xp0ye87/Dhw+HPCvJ4PPL7/ZLyQ3bllVdGRCp0fJ8+fdSvX7/weS4X/2oBAKCi0HIAAMxGywEAMBcdBwDAbLQcAACz0XLUJPymAbVM6C6js846K7xv9erV2rdvX8QdSCFer1eSlJqaqhYtWoS3C461efNmvfTSS/r+++8LhRAAAJQvWg4AgNloOQAA5qLjAACYjZYDAGA2Wo6ahMXbQC0Tisyll16q+Ph4eTwe5ebm6sSJE6cM0N69ezV16lS988478vv9chxHLpdLlmXJ6/UqKytLCxcu1OzZs7Vjx47K/DoAANQ6tBwAALPRcgAAzEXHAQAwGy0HAMBstBw1CYu3gWou9KqGsn5+KvXq1ZNt2woEAvL7/VqxYoUkKRgMRhy3d+9evfnmm/rggw+Unp4e3t+9e3c5jqNgMCiv16vs7GwtXLhQM2bMIGQAABRAywEAMBstBwDAXHQcAACz0XIAAMxGy4FT81T1BACcnmVZSk1N1c6dO7Vr1y4lJCTI4/GoTZs26tSpk1yu0t+D4TiOWrZsqfPOO09r1qyRbdvh8Ljd7vBxoYC9//77EQGbNGmSrr/+eo0fP14LFy6UpIiQuVwuDRs2TMnJyWf47QEAMB8tBwDAbLQcAABz0XEAAMxGywEAMBstB06NxdtANfbJJ59o9erVWrx4sU6ePCmfzxf+rG7dukpOTtY999yjzp07q2HDhiUeN/SaiDZt2mjVqlWyLEvbtm3TsWPHVK9ePblcrlMG7G9/+5uuv/56SdJzzz0nSYVCtmDBAp04cULjxo1T48aNz/jnAACAqWg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5cHqlv3UBQIVLTU3VCy+8oDFjxuitt97S0aNHFQwGZVmWPJ78ey4yMzO1fv16PfbYY3rxxRfDdxA5jlPs+KFXTnTv3l1SftR2796tw4cPFxuwG2+8UZKUl5cnKT9kQ4YMkW3bchxHUVFRysrKUmxsLAEDANRatBwAALPRcgAAzEXHAQAwGy0HAMBstBwoGZ68DVQz33zzjaZNm6bFixdLkjwej/Ly8sLhCQQC4TuI3G63UlNT9eGHHyo1NVUTJkzQOeecU+w1Qq+c6N69u2JjY+Xz+RQMBnXo0CHVq1dPb7zxhj744INTBsy2bUVFRSkQCMjj8ei5556Ty+XSu+++K0kaOnSonnrqKUn5UQ3NFwCA2oCWAwBgNloOAIC56DgAAGaj5QAAmI2WAyVnOSW5XQFApUhJSdG//vUvrV27NrwvJiZGjuOoY8eOioqK0v79+5WXl6djx47J4/HItm3Ztq2YmBhdffXVGjt2rM4+++xirxUMBpWenq5hw4Zp9+7dkqR+/fqpbdu2eu+9904bsFAEJYVDJkmjR4+WJE2ZMqXIYwEAqOloOQAAZqPlAACYi44DAGA2Wg4AgNloOVA6LN4GqonvvvtOkyZN0sqVK2VZlhzHUbt27XTTTTepb9++at++vSTpyJEjOn78uJ5//nmtXbtWtm2Hj2/QoIEefvhhDR06VMFgUG63u9jr/ulPf9I777wjt9ut2NhY2bat7Ozs8OenC1hIUdciYACA2oaWAwBgNloOAIC56DgAAGaj5QAAmI2WA6XHbxhQDWRlZen111/XypUrJeW/cqFHjx565ZVXdPvtt6t9+/YK3WfRqFEjdezYUVOnTtWtt94qj8cjl8slt9utY8eOadasWQoEAsUGrOB4BeeRl5cX3i5JwKT811iEXm8RGpuAAQBqE1oOAIDZaDkAAOai4wAAmI2WAwBgNloOlA2/ZUA1MHPmTL333nvh7a5du+qVV15R8+bNwzGyLCv8eTAYlMfj0SOPPKKLL75YwWBQlmXJ4/Hom2++0fz58yX9FKqihMb71a9+pXPOOUfBYFDR0dEKBAKSSh6wkIKfF5wrAAC1AS0HAMBstBwAAHPRcQAAzEbLAQAwGy0HyobF20AV++yzz/TSSy+Ft1u3bq0nn3xS9erVi7irpyC32x1+ZcPjjz+uFi1aKBAIhI/fuXOnpOJjYtu2GjdurBdffFEdO3ZUbm6uJOmZZ54pVcAAAKjNaDkAAGaj5QAAmIuOAwBgNloOAIDZaDlQdvxmAlXoyJEjev/992Xbttxut+Lj4zV06FC1bdtWkk4bD7fbLcdxVLduXZ1//vnhfZL0+eefKysrS8Fg8LTXD41/zjnnaOLEiWratKkef/xxDR06VBIBAwCgOLQcAACz0XIAAMxFxwEAMBstBwDAbLQcODP8dgJVIHSn0I4dO7RixQrZtq1gMKgGDRpo4MCBiomJKdE4lmUpNjZWAwcOlCT5/X5J0tGjR+Xz+cJRK4l27dpp4cKF+tWvfiUp/9UTBAwAgKLRcgAAzEbLAQAwFx0HAMBstBwAALPRcqB88BsKVAGXy6WMjAxNnDhRGRkZ4dc8/Pa3vw3ffVRSjuOoWbNmSkhIkGVZioqKUl5eno4cOVLqeSUmJobHLO7VEwAA1Ga0HAAAs9FyAADMRccBADAbLQcAwGy0HCgfLN4GqsiOHTu0bds2SfmvfWjdurW6dOlS6nEsy1Lbtm3VrFkzOY6jQCAgn8+ngwcPlnluBAwAgOLRcgAAzEbLAQAwFx0HAMBstBwAALPRcuDMsXgbqCI9e/bU3XffLUkKBALq16+f2rVrV6axgsGgvF5vxL7QqyQAAEDFoOUAAJiNlgMAYC46DgCA2Wg5AABmo+XAmWPxNlAFHMeRJD344IMaO3asJKl3796S8oNUWrGxsWrVqpWk/LuZJCkjI0OSZNv2Gc8XAABEouUAAJiNlgMAYC46DgCA2Wg5AABmo+VA+fBU9QSA2siyLNm2LZfLpfvuu0+JiYnhV0eEIlRa8fHxkn6KVlZWVvhaAACgfNFyAADMRssBADAXHQcAwGy0HAAAs9FyoHyweBuoIi6XKxyy22+/XZLC26UROicUr9DdTaF4ETEAACoGLQcAwGy0HAAAc9FxAADMRssBADAbLQfOXOn+tgAoVz8PVmkDVvCcevXqRWyH7kAKRa0ooc9+HkAAAFAytBwAALPRcgAAzEXHAQAwGy0HAMBstBw4MyzeBmqI0OsjQjIzMyWdOkyO48iyLOXk5GjGjBnasGGDLMuS4zjEDACAKkDLAQAwGy0HAMBcdBwAALPRcgAAzEbLURuxeBsoZ6G7eYpSEXEIjRkIBCK2PR6PpKLvaioYsHfeeUevv/66hg0bptWrV8uyLF45AQCo1Wg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5UHlYvA2UM5fLpdzcXGVkZOjQoUM6fPhw+LOKjEN0dHTENfx+f5HHFQzYvHnzNHPmzPAc77zzTm3fvr3C5ggAgAloOQAAZqPlAACYi44DAGA2Wg4AgNloOVB5PFU9AaAmWbp0qdatW6elS5eGQyZJ3bt3V/PmzXXTTTepcePGat68eficUFTKKnRunTp1wuNJ0okTJyTl3xEVugvp5wGbPXu2du7cGX5txKBBg9SuXbsyzwUAANPRcgAAzEbLAQAwFx0HAMBstBwAALPRcqBysXgbKAe7d+/WzJkzNX369HAQoqKiFAgEZNu2NmzYoJSUFC1btkyJiYl6+OGH1bNnTzVu3FiWZUWEpqxC8Qr9MxS30D+LC9jgwYP1/PPPS1K5zAcAAJPQcgAAzEbLAQAwFx0HAMBstBwAALPRcqBqsHgbOENffvmlpk6dqs8//1yS5PF45Pf75ff7w+GwLEtut1tZWVlKT0/XAw88oMsuu0wDBw7UjTfeKJfLVeZwhM4LnetyueQ4jtxutySFI0XAAAAoGi0HAMBstBwAAHPRcQAAzEbLAQAwGy0Hqg6Lt4EzsGHDBk2ePFkpKSnhfS6XSwkJCWrWrJnS0tLk9/uVlpYW/jw6Olo+n0+fffaZNmzYoJ07d+rhhx8uczhC5yUkJEjKv9PIcRylp6dLkgKBgDweDwEDAKAItBwAALPRcgAAzEXHAQAwGy0HAMBstByoWizeBsroyJEjev3115WSkhIOQseOHTV8+HD17NlTZ599tjIzM5Wbm6u5c+fqu+++06pVq+Tz+cKhyMjI0KuvvqoDBw7o97//vVq0aFHm+YTuOLJtW5KUl5cnSQQMAIBToOUAAJiNlgMAYC46DgCA2Wg5AABmo+VA1WPxNlBGc+fO1SeffCIp/66f7t2764UXXlDTpk0l5UchPj5ekvTQQw/J5/Npzpw5eu2115SWlqZAICCv16tAIKCPPvpImZmZeuCBB9SxY8dwkEqi4CsqpPyYBYNBRUVFSRIBAwDgFGg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5UPVYvA2UwaZNm/T666+Ht9u0aaOJEyeGAyb99FoHx3HkcrkUGxurUaNGqUOHDlqwYIEWL16snJwcRUVFye/3a8WKFfL5fBo9erQuuOACeb3eEs0lFK+4uLhC1/T7/Zo7d67mzJlDwAAAKICWAwBgNloOAIC56DgAAGaj5QAAmI2WA9UDi7eBMti/f7/y8vLk9Xrl9/t18cUXq0mTJkUeG4pMKBZ9+/bV2WefrbZt2+q1115TRkZGOGTr1q2T3+/XmDFjdOGFF5bqTiSv1yvbtsOvj9izZ4/efPNNzZ8/n4ABAPAztBwAALPRcgAAzEXHAQAwGy0HAMBstByoHvjtBUrBcRzZtq2lS5cqEAjIcRxJUv/+/cOvaziVgrFo3bq1hg8frscff1xJSUnhIFqWpa+++kpTpkzR1q1bw+OXhNvtlsvlCv/zxx9/1Lx58wgYAAAF0HIAAMxGywEAMBcdBwDAbLQcAACz0XKgeuE3GCgFy7LkcrmUnZ0tSQoGg5Kk6OjoUo+VkJCgq6++Ws8++6zq1q0bEbKUlBRNnjxZe/fulaQSxSw+Pl5RUVFyuVyybVtHjx7Vrl27CBgAAAXQcgAAzEbLAQAwFx0HAMBstBwAALPRcqB64bcYKIVgMCi/36/MzExJCkcnFITS3DEk5d81dNlll+mFF15QvXr1IkK2cuVK/f3vf5eUH89QME83Vl5engKBQHjb5XIRMAAACqDlAACYjZYDAGAuOg4AgNloOQAAZqPlQPXCbzJQCm63W16vVy1atJCUHy3HcfTJJ5+UOmAF9e3bV88++2yhV0ksXrxYzz77bPjap7uG2+0Oz8nr9YZfdUHAAAD4CS0HAMBstBwAAHPRcQAAzEbLAQAwGy0Hqhd+m4EyaNSokSSF7/bZtm2bLMsKv6qhLPr376/HH39cderUUV5enjwejyzL0pw5czRnzhxJ+XcinUrTpk117bXXSpL8fj8BAwDgNGg5AABmo+UAAJiLjgMAYDZaDgCA2Wg5UD3wGw2UQihQV111lc4666zwXT9r167VzJkzJZ0+NKfjcrk0YMAAjR49WrGxsfL7/XK5XMrNzdVHH32k3bt3n/b82NhYjR07VjfccIMk6frrrydgAAD8DC0HAMBstBwAAHPRcQAAzEbLAQAwGy0Hqhd+q4FSCAWqUaNGio2NVSAQCL/qYdGiRdq2bdsZjR8XF6eBAwfquuuuk9frVTAYlOM4+uKLL/TVV19J0mnvcGrRooVGjx6tv/zlL5o0aZIkAgYAQEG0HAAAs9FyAADMRccBADAbLQcAwGy0HKhe+M0GSslxHDVo0ECjR49WTEyM/H6/HMfR+vXrtXLlyvAxZdWiRQvdcMMNatq0qSQpOjpajuNo4sSJ2rlzZ7F3OLVu3Vq33XabJAIGAEBRaDkAAGaj5QAAmIuOAwBgNloOAIDZaDlQffDbDZRSKCJdu3bVOeecI0mKiopSMBjUCy+8oJUrV8qyLNm2XeZr9OrVSyNHjpQk+Xw+eTwe5eTkaOfOnZJU4rEJGAAAhdFyAADMRssBADAXHQcAwGy0HAAAs9FyoPrgNxwoow4dOmjw4MGSpLy8PEVHRysQCOh3v/udtm7dKpfLVaaQhe5eGj58uAYNGiQpP1o5OTlauHChJOIEAEB5oOUAAJiNlgMAYC46DgCA2Wg5AABmo+VA1eNvAqCfwhEMBgvtO93xI0eO1C233CIp/06hqKgoZWdna/z48fr+++/lcrlK/SqJ0B1Otm2ra9eukvKj5Xa7tWfPHmVlZZVqPAAAagNaDgCA2Wg5AADmouMAAJiNlgMAYDZaDpiJxduAfoqSz+cL7wvFpKgIWZYV3j9ixAj17dtXUv6dSG63W9u3b9djjz2mHTt2RBxbGi6XS7feequaNm2qQCCgYDCo77//Xvv27Sv1WAAA1HS0HAAAs9FyAADMRccBADAbLQcAwGy0HDCTp6onAFSlvXv36tChQ3r//feVlpamQ4cOKSkpSfXr19cVV1yhjh07qm3btkWeG4pccnKyBg8erNTUVO3cuVPBYFCWZWnz5s168skn9dhjjyk5OVmO44TPKQnbtuX1elWnTh0dPHhQXq9Xfr+/TEEEAKCmouUAAJiNlgMAYC46DgCA2Wg5AABmo+WA2Vi8jVpr9uzZmjlzpg4ePKjs7OxCny9btkzx8fH605/+pEsuuUQJCQmFjnEcRy6XS9dff71+/PFHzZ49W4cOHZLjOAoEAlq/fr0eeeQRPfHEE2rfvr1s25bLVbIH3juOo7i4ODVo0EBSfjQ9Ho9iYmLO7IsDAFBD0HIAAMxGywEAMBcdBwDAbLQcAACz0XLAfCX72wTUID/88EM4LD/88INycnLk8XhkWZaioqLk8Xjkcrnk9/t19OhRPfzww/rvf/+r/fv3FxrLsqzwnUKjRo3S9ddfr7p164Y/DwQC+uqrr/Twww9r69atcrlcJb6DyO12KysrSwcOHJCU/2oKSfJ4uOcCAFC70XIAAMxGywEAMBcdBwDAbLQcAACz0XKg5mDxNmqV9evXa9KkSZo3b54khaMSCATkOI78fr8CgYBs21YgEFB0dLRs29a//vUvzZ07V+np6YXGdLlcsm1bUVFRGjNmjK6//nolJSVFfP79999r1KhRWrNmTcQrJIoL2oYNG5SWlhaO7OWXX64WLVqU008DAADz0HIAAMxGywEAMBcdBwDAbLQcAACz0XKgZuFWBtQaX331lSZPnqx169aF95111llq3ry5Bg0apPj4eEVHR+vzzz/X9u3btW3bNvl8PkVHR8vn82natGlq2bKlbrrpJjmOExGjUMiio6P1hz/8QdHR0frf//6nw4cPhwOXkZGh3/zmNxo3bpz69++vNm3ahO9gCr1SouC4gUBACxYsUHp6uizLkuM46ty5c+X+0AAAqEZoOQAAZqPlAACYi44DAGA2Wg4AgNloOVDzWE5Jn2UPGGzv3r165pln9Omnn4aD0KVLF/3hD39Q+/btVb9+/Yjjv/32W7311luaM2eOJIVDlpCQoJkzZ6pDhw5FXicUpLy8PL3++utasGCBdu/eHTGG2+1W//79NXDgQP3yl78MnxsKmOM4ys3N1bPPPhu+viRddNFFevXVV8N3TRWMKAAANR0tBwDAbLQcAABz0XEAAMxGywEAMBstB2omFm+jVnjqqac0Y8aM8HaPHj00ZcoU1a1bV9JPAQkEAvJ48h9In52drUmTJmnWrFmSJK/Xq2AwqFGjRukPf/iDHMcJ3zlUUChkfr9fCxYs0HvvvaeUlBRJP4UsFKsBAwbo/PPP14ABA+RyueT1erV06VKtXbtWy5cvD4/Zrl07Pfzww7r00ksJGACgVqLlAACYjZYDAGAuOg4AgNloOQAAZqPlQM3E4m3UeHPmzNHjjz8e3u7UqZNefvllNWvWLOLVDUXZsWOHnnjiCa1bty78iojOnTtr3rx5pz0vNG4wGNS3336r2bNna/78+eHPPR6PAoFAxLbjOIqOjlZ2dnbEWK1bt9aIESN0ww03KD4+viw/AgAAjEbLAQAwGy0HAMBcdBwAALPRcgAAzEbLgZrr1H8LgRrg66+/1muvvRbebtKkiR544AE1a9ZMkk4bIik/ID179gwf6/F49MMPP+irr76SlH/nUlFCr3hwu93q2rWrnn76af3hD39QmzZtFB0drUAgIK/XK8uyFBUVJUkKBoPKy8uTx+MJz6tz58668847NWTIEAIGAKiVaDkAAGaj5QAAmIuOAwBgNloOAIDZaDlQs3mqegJARQjdAbRixQqlpqbK7XYrGAyqd+/e6tq1a4nGCEXojjvu0Pvvv6+DBw+GP9u7d6/OP//8077G4eef3XXXXbrgggu0ceNGTZ06VTk5OfL7/crLywsfU/CupCuvvFK/+c1v1KFDB8XExJT0qwMAUCPQcgAAzEbLAQAwFx0HAMBstBwAALPRcqB2YPE2aiSXy6V9+/Zp5syZ8vl8kqTo6GjdfvvtatCgQYnGsCxLtm0rKipKDRs21MGDB8Ovfdi9e7ek/NCdLmQhoeO6deumbt26adCgQdq+fbuWLl2q/fv36+DBg4qJiVFUVJQuvvhiJScn65prrinz9wcAwHS0HAAAs9FyAADMRccBADAbLQcAwGy0HKgdWLyNGsnv92vatGlKS0tTbGyscnJydOutt6pbt24lDo+UH8OEhAT16tVLX3/9dfh1Edu3by/VfApez7ZtNWnSRE2aNFH//v0VDAaVnZ2t2NhY+Xy+iNdEhO6kAgCgtqHlAACYjZYDAGAuOg4AgNloOQAAZqPlQO3A4m3UWM2bN5fX61VOTo4kqXv37pIKv9bhdELBS0hICG8X/GdpxgoJRSk0ttvtVmJioiTJ7XYXeSwAALURLQcAwGy0HAAAc9FxAADMRssBADAbLQdqPv6GoEbyer26+eabNWLECHk8HrVv317XXXddqccJxaply5ZyuVxyuVyyLEt5eXlnPMeiAliWKAIAUBPRcgAAzEbLAQAwFx0HAMBstBwAALPRcqB24MnbqLHq1aune++9V4FAQLm5ufL7/XK73aW6qyd07FlnnSXbtuU4jhzHUVpamvLy8hQVFVVR0wcAoNaj5QAAmI2WAwBgLjoOAIDZaDkAAGaj5UDNx+Jt1GhJSUm677775DiOvF5vmceJiYkpx1kBAICSouUAAJiNlgMAYC46DgCA2Wg5AABmo+VAzcbibdR49erVO+Mx6tSpo/j4eAUCAQUCAblcrvCrJU7HcZyIV0L8fBsAABSPlgMAYDZaDgCAueg4AABmo+UAAJiNlgM1V8mfow/UYl6vV4FAQH6/X8FgUJmZmcrLyzvtOaFg5eXlae/evZIky7JKFD8AAFC+aDkAAGaj5QAAmIuOAwBgNloOAIDZaDlQPbF4GyihYDAo27YlSYFA4LQxCgUsJydHc+bM0YsvvqiPPvpIkrgDCQCAKkLLAQAwGy0HAMBcdBwAALPRcgAAzEbLgerHU9UTAEyQmJioOnXq6OTJkwoGg3K73QoEAkUeWzBg8+fP14wZM7Rnzx4dPHhQeXl5GjJkSCXPHgAA0HIAAMxGywEAMBcdBwDAbLQcAACz0XKgeuLJ20AJuN1uuVwuOY4j27bl8/nk9/sLHVcwYPPmzdOsWbO0Z88eSdLGjRu1b9++yp46AAAQLQcAwHS0HAAAc9FxAADMRssBADAbLQeqJxZvAyXg9/uVm5sbvusoEAgUeg3EzwM2e/Zs7dy5M3zcddddpzFjxlT63AEAAC0HAMB0tBwAAHPRcQAAzEbLAQAwGy0HqicWbwMlEBMTo/j4eLlcP/2VCQaD4f98uoA5jqPBgwfr73//uyTJtu1Knz8AALUdLQcAwGy0HAAAc9FxAADMRssBADAbLQeqJ09VTwAwQWxsrGJjY8MR8/v9ysnJkeM4chxHLpfrtAF7/vnnJeUHrGAIAQBA5aDlAACYjZYDAGAuOg4AgNloOQAAZqPlQPXE4m2gGI7jyO/3y+fzhV8fYdu23G63LMsK33n09ttv66233ooI2JAhQ/Tcc8+FzyFgAABUPloOAIDZaDkAAOai4wAAmI2WAwBgNloOVF/8jQKKEXrdQyhAlmVJ+un1EQQMAIDqjZYDAGA2Wg4AgLnoOAAAZqPlAACYjZYD1Rd/q4BiuN1uRUVFKSkpKXzXUejVEVlZWZo7dy4BAwCgGqPlAACYjZYDAGAuOg4AgNloOQAAZqPlQPXlqeoJANWd4ziF7jqKj4/X0aNHtXbtWs2ZM4eAAQBQjdFyAADMRssBADAXHQcAwGy0HAAAs9FyoPpi8TZQjGAwKLfbHQ6Yy+WSz+fThx9+qK+//pqAAQBQzdFyAADMRssBADAXHQcAwGy0HAAAs9FyoPpi8TZQjNArI5KSkiRJlmUpLy9PCxcuVG5uLgEDAKCao+UAAJiNlgMAYC46DgCA2Wg5AABmo+VA9cXfMqAYoVdHREdHS8oPlGVZCgQCBAwAAAPQcgAAzEbLAQAwFx0HAMBstBwAALPRcqD64m8aUAzbtiP+6Xa75XK5FAwGCRgAAAag5QAAmI2WAwBgLjoOAIDZaDkAAGaj5UD1xd82oBihKLVq1UqSFAgEJImAAQBgCFoOAIDZaDkAAOai4wAAmI2WAwBgNloOVF/8jQNKaNSoUerbt688Ho+CwaBuuOEGAgYAgEFoOQAAZqPlAACYi44DAGA2Wg4AgNloOVD9WI7jOFU9CcAUe/fu1ZgxY9SlSxc988wzkggYAAAmoeUAAJiNlgMAYC46DgCA2Wg5AABmo+VA9cLibaCUjh07pgYNGkgiYAAAmIiWAwBgNloOAIC56DgAAGaj5QAAmI2WA9UHi7eBMnIcR5ZlVfU0AABAGdFyAADMRssBADAXHQcAwGy0HAAAs9FyoOqxeBsAAAAAAAAAAAAAAAAAAAAAKgHPvQcAAAAAAAAAAAAAAAAAAACASsDibQAAAAAAAAAAAAAAAAAAAACoBCzeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgELN4GAAAAAAAAAAAAAAAAAAAAgErA4m0AAAAAAAAAAAAAAAAAAAAAqAQs3gYAAAAAAAAAAAAAAAAAAACASsDibQAAAAAAAAAAAAAAAAAAAACoBCzeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgELN4GAAAAAAAAAAAAAAAAAAAAgErA4m0AAAAAAAAAAAAAAAAAAAAAqAQs3gYAAAAAAAAAAAAAAAAAAACASsDibQAAAAAAAAAAAAAAAAAAAACoBCzeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgELN4GAAAAAAAAAAAAAAAAAAAAgErgqeoJAAAAAAAAAAAAlEWHDh0itseMGaP777+/imYDAAAAAAAAAMVj8TYAAAAAAAAAQI7jaNeuXdq7d68OHTqkrKws5eXlKT4+XklJSUpKSlK7du3UvHnzqp4qAAAAAAAAAADGYvE2AAAAAAAAANRS2dnZWrRokRYvXqyUlBSdPHmy2HPq1aun7t27a9CgQbrqqquUkJBQCTMFAAAAAAAAAKBmsBzHcap6EgAAAAAAAACAypOVlaVp06Zp1qxZSk9PL/M4MTExuuqqq3T//ferRYsW5ThDFGXChAl69913w9vNmjXTsmXLqnBGVa9Dhw4R22PGjNH9999fRbOpeJdffrkOHDgQ3h46dKieffbZKpwRAAAAAAAAgNJyVfUEAAAAAAAAAACVZ9WqVbr66qv1yiuvnNHCbUnKzc3VwoULdc011+ipp56Sz+crp1kCAAAAAAAAAFAzeap6AgAAAAAAAACAyjF16lT94x//0KleyJiUlKS+ffsqOTlZ9evXV/369eU4jjIyMrR//35t3rxZGzduVG5ubsR5fr9f06dP16hRo9S8efPK+CoAAAAAAAAAABiJxdsAAAAAAAAAUAu88MILmjJlSpGf9e/fX6NHj1bPnj3ldrtPO05OTo4+/fRTTZ8+XRs2bKiIqQIAAAAAAAAAUGOxeBsAAAAAAAAAari33367yIXbDRs21KRJk3ThhReWeKzY2Fhde+21uvbaa7VmzRr97W9/0/fff1+e0wUAAAAAAAAAoMZyVfUEAAAAAAAAAAAVZ8eOHfrrX/9aaH+bNm301ltvlWrh9s/17dtX8+fP15133nkmUwQAAAAAAAAAoNbgydsAAAAAAAAAUIM99thj8vl8Efvq1q2rN954Q40bNz7j8aOiojR+/Hh16dJFXq/3jMcDAAAAAAAAAKAmY/E2AAAAAAAAANRQy5cv15dffllo/+OPP14uC7cLuv7668tlnIyMDH3zzTfau3evTp48Kdu2lZSUpEsuuUTNmjUr0RjBYFBbtmzRwYMHdfz4cWVkZCghIUH169dXq1at1LlzZ1mWVS7zDUlNTdXOnTu1f/9+ZWZmKjc3VwkJCUpKSlLTpk117rnnKjo6ulyvWZEcx9G2bdu0b98+HT9+XCdOnFBsbKzq16+vZs2a6dxzz5XHU/7/F8PevXv13XffKTU1VZmZmUpISFDLli3VrVs31atXr9yvV16CwaD27dunnTt3hudu27bq1KmjpKQktW3bVu3bt5fLxQtRAQAAAAAAgNqOxdsAAAAAAAAAUEP997//LbTvwgsv1LXXXlvpc5kwYYLefffd8HazZs20bNmy8Pby5cv13//+V1988YWCwWCh85955hndeOONp73G6tWr9dZbb2nNmjXKyMg45XF169bVgAEDdM899yg5ObkM30Y6fvy4PvnkE61evVopKSk6evToaY/3er3q0aOHhg8frquuuqrEi3gvv/xyHThwoMjPDhw4oA4dOhQ7xptvvqk+ffqU6HrffPONpk+frlWrVp32O8XHx6tfv376zW9+o27dupVo7FNxHEfz5s3T7NmztWXLliKPcbvd6tu3r+677z716tXrjK5XXnbt2qUlS5boiy++0IYNG5SdnX3a4xMTE3XRRRfprrvuUvfu3Ut0jf379+uKK6445efvvvtuxN+rU9m2bVuJrgcAAAAAAACg4rF4GwAAAAAAAABqoEOHDmnNmjWF9g8fPrwKZnNqWVlZ+uMf/6hFixaVeYxt27bpb3/7m9auXVui40+cOKEFCxbo/fff10033aRHHnlEUVFRJb7eQw89pI8//liBQKDE5/j9fqWkpCglJUXJycmaPHmy2rVrV+LzK9qBAwf07LPPavHixSU6PisrS4sXL9bixYs1aNAgPf3006pTp06pr7tv3z6NHz9e69evP+1xwWBQK1eu1MqVKzVixAj98Y9/lNvtLvX1ykNaWpruvPNObd26tVTnnTx5UosWLdKiRYt0xRVX6Nlnny3TzwwAAAAAAACA2Xg/HwAAAAAAAADUQMuWLZPjOBH7GjZsqMsvv7yKZlRYdna2Ro0adUYLt5ctW6bbbrutxAu3CwoGg5ozZ45GjBihY8eOlfi8r776qlQLt39ux44duuWWW7R69eoyj1GeNm7cqJtvvrnEC7d/bvHixbrlllu0Z8+eUp23b98+3X777cUu3P656dOna9y4cYV+vytLVlZWqRdu/9zSpUt188036/Dhw+U0KwAAAAAAAACm4MnbAAAAAAAAAFADffHFF4X29erVSx5P9fmfhR999FFt2rQpvN2oUSMNGDBA7du3V4MGDZSZmakDBw5o2bJlRZ7//vvva9y4cbJtO2K/1+vVhRdeqO7du6tJkyZKTExUdna2Dhw4oDVr1hRaLLxx40aNGTNGb775prxeb6m+g9vtVufOndWuXTu1adNG9erVU3x8vCQpMzNTu3fv1tdff60NGzZEzDM7O1sPPvigFixYoLPPPvuU4ycnJysxMVFS/tPU09PTI75ncnJysXOMi4s75WdffPGFfvOb38jn80Xsd7lc6tWrl3r27KnmzZsrMTFRPp9Phw8fVkpKitasWaNgMBg+fteuXbrnnns0f/58JSQkFDun9PR0jRw5ssjFy61atdLAgQPVqlUrJSQk6Mcff9RXX32l5cuXKzs7W5L0wQcfqEuXLsVepzLExcXp3HPPVXJyslq1aqXExETFx8fL7/crIyNDP/zwg7744gvt2LEj4rzdu3frgQce0IwZM07599Lr9apjx47h7R07dsjv94e3k5KSTvv7AwAAAAAAAKD6sZyqejQFAAAAAAAAAKDCXHnlldq3b1/EvvHjx+vOO++skvlMmDBB7777bnjb7XaHF//GxMTo97//vYYNG3bKxdM+n0/R0dHh7e3bt+vmm29WTk5OeJ/H49Edd9yhu+++W/Xr1z/lXL799lv9+c9/1pYtWyL233nnnRo/fnyx3+Wqq65S+/btNXjwYF144YXhxdWnc+DAAf3jH//QBx98ELF/wIAB+ve//13s+VLhn2GzZs1OubC9JH788UfdcMMNOnr0aMT+G2+8Uffff7+aNm16ynP37t2rJ554QitXrozYf9VVV+mll14q9to//y6SlJiYqAkTJuimm24q8pzjx4/r6aefDv8MY2JilJubG3HMmDFjdP/99xd7/TOxf/9+DR06VIMHD9ZVV12lnj17lmjR/4YNG/T0009r8+bNEfvHjRunu+66q0TXvvzyy3XgwIHw9tChQ/Xss8+W7gsAAAAAAAAAqFKuqp4AAAAAAAAAAKB85eXlaf/+/YX2d+3atQpmU7TQwu24uDi9+uqruuOOO067ALbgwm3btvX73/8+YuF2XFycXnvtNY0bN+60C7clqVOnTnrrrbfUr1+/iP3Tp08v8knQPzdv3jz985//1MCBA0u0cFvKX2j997//vdDC4uXLl2vnzp0lGqO8/elPf4pYuO12uzVp0iQ988wzp124LUktW7bUq6++qhtvvDFi/6JFiyKepl6UlJSUQgu3Q78Hp1q4LUn169fX3//+d40YMUKSCi3criyNGjXSihUr9Oijj6p3794lflr7eeedp1mzZql///4R+6dPn65AIFARUwUAAAAAAABQDbF4GwAAAAAAAABqmNTUVBX10sWzzjqrCmZzeg899JAuuOCCUp2zaNEiff/99xH7/va3v+nCCy8s8RhRUVGaPHmy6tWrF97n9/v1n//8p9hzS7pguyj/93//p3PPPTe87TiO5s2bV+bxymrTpk36/PPPI/b9/ve/1y9+8YsSj2FZlp588kklJydH7J86deppz3vzzTcL7fvzn/+sHj16lOi6f/7zn9WzZ88Sz7O8RUVFKSYmpkznRkdH67nnnlNsbGx436FDh7Rq1arymh4AAAAAAACAao7F2wAAAAAAAABQw2RkZBS5v06dOpU8k9Nr2bKlhg8fXurzpk2bFrHdu3dvXXPNNaUeJzExUSNHjozYt2TJklKPUxqWZWnIkCER+zZs2FCh1yzKq6++GrHdqlUr/frXvy71OF6vV/fee2/Evs8//1x5eXlFHn/kyBEtW7YsYl+XLl30y1/+ssTXtCxLjz76aKnnWl00aNCg0NO3169fX0WzAQAAAAAAAFDZWLwNAAAAAAAAADVMbm5ukfvP5InRFeHGG2+UZVmlOmf//v3asmVLxL6bb765zHMYMGBAxPaBAwd04MCBMo9XEq1atYrY3rJli/x+f4VesyCfz6dPP/00Yt/QoUPldrvLNN6ll15aaPyNGzcWeezq1asVCAQi9t10002l/j3o0qWLunbtWqpzqpOf/w6c6ucFAAAAAAAAoObxVPUEAAAAAAAAAADly3GcIveXdoFsRevTp0+pz0lJSSm077zzzivzHJo3b15o37fffqtmzZqVeIysrCx9+eWX2rZtm3744QedOHFCmZmZysnJkW3bhY7Pzs6O2M7Ly9OxY8fUpEmT0n+BMvj6668LPRn7TH6GdevWVWJiok6ePBnet3XrVvXu3bvQsUUtUh40aFCZrjto0CBt3ry5TOeWt9TUVG3YsEHbtm3T7t27dfLkSWVlZSk3N7fIv49Hjx6N2D506FBlTRUAAAAAAABAFWPxNgAAAAAAAADUMDExMUXuz8jI0FlnnVXJsymaZVnq1KlTqc/bsGFDoX3/93//Vx5TCktLSyvRcZs3b9Zrr72mZcuWnfJp5yWVkZFRaYu3i/oZPvHEE/J6vWUe8+ff/1Q/w58/Nb1x48Zl/p3s0qVLmc4rTx9//LFmzZqllJSUIhfql1RGRkY5zgoAAAAAAABAdcbibQAAAAAAAACoYZKSkorcX50Wb8fFxSk2NrbU5x0+fLjQvu+++648phRW3OJtv9+vZ555RrNnzz6jBbsFFXxqdUUr6me4Y8eOcr3GiRMnitx/7NixiO02bdqU+Rpt27Yt87lnKjU1VePGjdPatWvLZbzMzMxyGQcAAAAAAABA9cfibQAAAAAAAACoYRo3bizLsuQ4TsT+Y8eOVemC14ISEhLKdN6pFgWXJ5/Pd8rP/H6/xo4dq6VLl5brNQOBQLmOdzpV+TP8+SL1xMTEMl/jTM49E6mpqRoxYoT27NlTbmNW5p8/AAAAAAAAgKrF4m0AAAAAAAAAqGGioqLUrFkz7d+/P2L/5s2bdcEFF1TRrCJ5PGX7n6czMjLKeSalM23atCIXbjdu3FhXXHGFevbsqZYtW6pJkyaKj49XdHS0oqKiIo794osvNHLkyMqaciFV+TPMysqK2C7L09fL49wzMWHChCIXbnfq1EmXXHKJunXrpqZNm6pRo0aKiYlRdHS0vF5vxLH//Oc/9fLLL1fWlAEAAAAAAABUIyzeBgAAAAAAAIAaqEuXLoUWb2/atKmKZlN+oqOjC+3btGlTkfvL27FjxzR16tSIfR6PR3/4wx90++23l3hBem5ubkVMr8SK+ll9+OGHSk5OrvBrx8fHRywez8nJKfNYZ3JuWX322WdavXp1xL4GDRro+eef18UXX1zicar6dwAAAAAAAABA1XFV9QQAAAAAAAAAAOWvT58+hfalpKQoGAxWwWzKT7169QrtO3HiRKVce9myZYUWDD/88MMaNWpUqZ4knp6eXt5TK5WifoaVNafExMSI7ZMnT5Z5rDM5t6w++OCDiG23260pU6aUauG2VPW/AwAAAAAAAACqDou3AQAAAAAAAKAGuuyyy2RZVsS+H3/8UcuWLauiGZWPs846q9C+gwcPVsq1V61aFbGdlJSk22+/vdTj7Nu3r7ymVCZV+TNs0KBBxPauXbvKPNbOnTvPdDql9vOnbvfv31/dunUr9ThV/TsAAAAAAAAAoOqweBsAAAAAAAAAaqCmTZuqb9++hfbPmjWrCmZTfopaKJuSklIp1z58+HChuXi93lKPs3HjxnKaUdlU5c+wS5cuEdupqak6evRomcbasmVLeUypxPLy8nTs2LGIfeeff36pxwkGg9q0aVN5TQsAAAAAAACAYVi8DQAAAAAAAAA11B133FFo3+rVq7Vo0aIqmE356NevX6F9S5YsqZRrp6WlRWwnJSWVeozjx4/riy++KNP13W53xHYwGCzTOBdeeKE8Hk/Evs8++0x+v79M45VGjx49Cu0r65/f4sWLz3A2pfPzP39Jqlu3bqnHWb58ubKzs8s0h/L6HQAAAAAAAABQdVi8DQAAAAAAAAA11IABA4p8MvBjjz2mI0eOlOu1PvjgA6WmppbrmEU555xz1Lp164h9mzZt0po1ayr82rGxsRHbJ06cKPUYs2bNks/nK9P14+PjI7bLugA4ISFBvXv3jth3+PBhLVy4sEzjlcZFF11UaOH422+/LcdxSjXOt99+q82bN5fn1IoVFxdXaF9RC7qL85///KfMcyiv3wEAAAAAAAAAVYfF2wAAAAAAAABQgz355JOKjo6O2HfixAmNGjVKhw4dOuPx8/Ly9Nxzz+mhhx6qlCc3S9Lo0aML7XvkkUfKtJi6NBo2bBixvWHDhlItnt2+fbv+/e9/l/n6derUidjOyMhQenp6mca67777Cu17/vnntW/fvjKNV1KNGjXS5ZdfHrFvy5Ytevfdd0s8huM4+utf/1reUytWYmJioQX8K1euLNUYb7/9ttatW1fmOfz8d6Ci/7wAAAAAAAAAlD8WbwMAAAAAAABADXbOOefokUceKbR/x44duvXWW89oIemaNWt044036vXXXz+TKZba4MGD1bZt24h9+/fv1z333FPmp39nZmZq2rRpp336dK9evSK2s7Oz9fLLL5do/P379+u+++5TXl5emeYnSR06dCi0b/ny5WUaq3fv3urXr1/EvvT0dN19993asWNHmcb0+Xx66623in2y9IgRIwrte+qpp7Rp06YSXee5557T+vXryzTHM/XzJ9mvW7euxH8Gn3/+uZ566qkzun779u0jtrdv314uN2EAAAAAAAAAqDws3gYAAAAAAACAGu6WW24p8mnVqampGjFihO655x5t2LBBtm0XO1Zubq4+/PBDDRs2TKNGjdL27dsrYsqn5Xa7NXnyZMXHx0fs//rrrzV06FDNnDlTPp+v2HECgYBWr16tRx99VAMGDNCkSZN09OjRUx4/aNAguVyR/7P6a6+9phdffFGBQOCU533wwQe67bbbwk9JTkhIKHZuRenevXuh6z/33HP65JNPyvTU82eeeUaNGjWK2Ld7927ddNNN+ve//62TJ08WO4bjONqwYYP+9re/6fLLL9fjjz9e7NOge/furaFDh0bsy8rK0l133XXaJ3CnpaXp4YcfDi8Oj4mJKXZ+5e3qq68utO+BBx7Qxx9/fMpzcnNz9fLLL+u3v/2tcnNzJZX9d+C8886L2LZtW2PHjtU333xTpvEAAAAAAAAAVD7LcRynqicBAAAAAAAAAKh4U6ZM0YsvvqhT/c/CdevWVd++fXXOOeeoXr16qlevniQpIyND+/bt05YtW7Rx40bl5OQUef7SpUvVvHnzIj+bMGFCxMLcZs2aadmyZWf0fZYtW6b777+/yIXTderU0QUXXKDu3burfv36SkxMVE5OjjIyMnTo0CFt2bJFW7duVWZmZsR548aN01133XXKa44fP14LFiwotL9Jkya66qqr1KFDB8XFxSk9PV27du3SsmXLtHfv3vBxsbGxGj9+vP7yl79EnP/mm2+qT58+xX7ne+65p8gnPXu9Xp199tmKjY2VZVkRnz311FM699xzixzvm2++0ciRI5WdnV3os7i4OJ133nnq2bOnGjVqpDp16ig3N1cnT57UkSNHtHXrVm3evFknTpyIOG/48OF67LHHTvs90tPTdcMNN+jgwYOFPmvdurUGDhyoVq1aKT4+XkePHtXGjRv16aefRsxz/Pjxeu655yLOHTNmjO6///7TXvtM+P1+XXvttRF/piFdunTRZZddppYtW8rr9erYsWPasmWLPv3004ifUbt27TRgwABNmzYt4vxt27YVe32fz6dLLrmk0M9ckuLj49WoUSNFR0cX+ux0T5QHAAAAAAAAULk8VT0BAAAAAAAAAEDlGD16tLp06aI//elPOnLkSKHPT5w4oY8++qjU48bExGjkyJGFnuJc0S6//HL997//1YMPPqgff/wx4rOMjAwtXbpUS5cuLddrPvLII9q0aZN27twZsf/w4cN64403Tnuu1+vV5MmTz+iJ0ePGjVNKSkqhxdZ+v7/IBcWSilyYHXLuuedqzpw5uv/++7V79+5C561cuVIrV64s83xPJSkpSW+88YZGjBihw4cPR3y2e/fuQgubf+66667Tr3/960KLtyta6M9w2LBhhW5i2LJli7Zs2XLa8xs3bqwpU6ac9gnjpxMdHa0JEyZowoQJhT7LysrSrl27yjQuAAAAAAAAgMrjKv4QAAAAAAAAAEBN0b9/f3388ccaPXq06tSpc0ZjxcXF6dZbb9WiRYv00EMPKSoqqpxmWXIXXHCB3nnnHQ0ePFhut7vM41iWpT59+qhXr16nPS4xMVH//e9/1aNHj1KN36hRI/3nP//RpZdeWuY5StI555yj119/Xa1atTqjcQpq37695s+fr9tvv73IpzaXxrnnnlvi79iyZUvNmDFD5513XqmuMWzYME2cOLHQE8YrS+fOnfXqq6+qYcOGpTqvR48emjt37imfTl9SQ4cO1VNPPaX4+PgzGgcAAAAAAABA1eDJ2wAAAAAAAABQy8THx+vBBx/Uvffeq48//liLFi3Sl19+qczMzGLPbdCggbp3766rr75agwYNUmxsbCXM+PQaNWqkiRMn6ne/+52mT5+ulStXaseOHcWeFx8fr969e6tv37668sor1axZsxJdr3HjxpoxY4bmzp2r//znP9q3b98pj23WrJluuukmjRw5UgkJCSX+TqfTs2dPffTRR1q5cqU+++wzbdu2Tfv27VNmZqZyc3Nl23apx0xISNCjjz6q++67TzNmzNDy5cv13XffFTtWTEyMevbsqYsuukhXXHGFkpOTS3XdFi1aaNasWZo3b55mzZqlrVu3Fnmcy+VSnz59NHr0aF144YWlukZF6NWrl9577z299tprmjt3rjIyMk55bNeuXTVixAgNHjxYLlf5PFPn5ptv1jXXXKPFixdr7dq12r59u1JTU5WVlaXc3NxyuQYAAAAAAACAimE5juNU9SQAAAAAAAAAAFXLtm3t2rVLe/bs0aFDh5Sdna28vDzFx8crKSlJdevWVfv27Uu8wLmqHT16VFu2bFFaWppOnDih7OxsxcXFKT4+Xo0bN1bbtm3VrFmzcnl6886dO/XNN98oLS0tfJ3GjRurQ4cOatu2bTl8m6qRnp6uzZs369ixYzpx4oQyMzMVGxur+Ph4NWzYUG3atFGLFi3O6InnP7dnzx59++23OnLkiLKyshQfH68WLVqoe/fuql+/frldpzwFg0Ft3rxZ27dvV1pamoLBoOLj49W8eXN17dq11E/oBgAAAAAAAFCzsXgbAAAAAAAAAAAAAAAAAAAAACpB+byfDwAAAAAAAAAAAAAAAAAAAABwWizeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgELN4GAAAAAAAAAAAAAAAAAAAAgErA4m0AAAAAAAAAAAAAAAAAAAAAqAQs3gYAAAAAAAAAAAAAAAAAAACASsDibQAAAAAAAAAAAAAAAAAAAACoBCzeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgELN4GAAAAAAAAAAAAAAAAAAAAgErA4m0AAAAAAAAAAAAAAAAAAAAAqAQs3gYAAAAAAAAAAAAAAAAAAACASsDibQAAAAAAAAAAAAAAAAAAAACoBCzeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgELN4GAAAAAAAAAAAAAAAAAAAAgErA4m0AAAAAAAAAAAAAAAAAAAAAqAQs3gYAAAAAAAAAAAAAAAAAAACASsDibQAAAAAAAAAAAAAAAAAAAACoBCzeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgELN4GAAAAAAAAAAAAAAAAAAAAgErA4m0AAAAAAAAAAAAAAAAAAAAAqAQs3gYAAAAAAAAAAAAAAAAAAACASsDibQAAAAAAAAAAAAAAAAAAAACoBCzeBgAAAAAAAAAAAAAAAAAAAIBKwOJtAAAAAAAAAAAAAAAAAAAAAKgE/x9quEwfWGS80AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 666, + "width": 1463 + } + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 666, + "width": 781 + } + }, + "output_type": "display_data" + } ], - "id": "cebbf6eb1bf5cf89" + "source": [ + "for repo in range(len(repository_list)):\n", + " ci_feedback_time_plots(m1_list[repo], repository_list[repo])\n", + " count_sucess_failure_workflow_plot(m2_list[repo], repository_list[repo])" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.10.12" } }, "nbformat": 4,