generating_results.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import polars as pl\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "import numpy as np\n",
    "pd.set_option('display.max_columns', 200)\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import re\n",
    "import csv\n",
    "import os\n",
    "import re\n",
    "import itertools\n",
    "from collections import Counter\n",
    "from fpdf import FPDF\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: The file 'joana/reports/libgdx/da27e2dae56be0a159e82231e5c3a5b83b099063/com/badlogic/gdx/backends/lwjgl3/executionSummary.csv' is empty.\n",
      "Error: The file 'joana/reports/libgdx/da27e2dae56be0a159e82231e5c3a5b83b099063/com/badlogic/gdx/backends/lwjgl3/executionSummary.csv' is empty.\n",
      "Error: The file 'joana/reports/elasticsearch/3764b3ff800c94293aba0bb0fa18c7df80a764f7/org/elasticsearch/rest/action/cat/executionSummary.csv' is empty.\n",
      "Error: The file 'joana/reports/elasticsearch/3764b3ff800c94293aba0bb0fa18c7df80a764f7/org/elasticsearch/rest/action/cat/executionSummary.csv' is empty.\n",
      "Error: The file 'joana/reports/elasticsearch/3764b3ff800c94293aba0bb0fa18c7df80a764f7/org/elasticsearch/rest/action/cat/executionSummary.csv' is empty.\n",
      "Error: The file 'joana/reports/fitnesse/4d9ba9d221d879507440feb084fa7521b95111ec/fitnesse/testsystems/slim/tables/executionSummary.csv' is empty.\n",
      "Error: The file 'joana/reports/fitnesse/4d9ba9d221d879507440feb084fa7521b95111ec/fitnesse/testsystems/slim/tables/executionSummary.csv' is empty.\n",
      "Files merged successfully! File saved as 'merged_file.csv'.\n"
     ]
    }
   ],
   "source": [
    "# Name of the CSV file\n",
    "file_name = 'revList.csv'\n",
    "\n",
    "# List to store the DataFrames\n",
    "found_files = []\n",
    "\n",
    "# Open the CSV file for reading\n",
    "with open(file_name, mode='r', newline='', encoding='utf-8') as file:\n",
    "    # Create a CSV reader\n",
    "    csv_reader = csv.reader(file, delimiter=';')\n",
    "    \n",
    "    # Skip the first line (header)\n",
    "    next(csv_reader)\n",
    "    \n",
    "    # Read the remaining lines and process each line\n",
    "    for row in csv_reader:\n",
    "        project = row[0]\n",
    "        merge_commit = row[1]\n",
    "        class_name = row[2]\n",
    "        method = row[3]\n",
    "        # left_modification = row[4]\n",
    "        # has_build = row[5]\n",
    "        # left_deletion = row[6]\n",
    "        # right_modification = row[7]\n",
    "        # right_deletion = row[8]\n",
    "        # realistic_case_path = row[9]\n",
    "\n",
    "        # Generate path\n",
    "        parts = class_name.split('.')\n",
    "        class_name = parts.pop()\n",
    "        class_path = '.'.join(parts).replace(\".\", \"/\")\n",
    "\n",
    "        path_file = f\"joana/reports/{project}/{merge_commit}/{class_path}/{class_name}/executionSummary.csv\"\n",
    "        \n",
    "        if os.path.exists(path_file):\n",
    "            try:\n",
    "                df = pd.read_csv(path_file, sep=';')\n",
    "                # Add context columns to the DataFrame\n",
    "                df['project'] = project\n",
    "                df['merge commit'] = merge_commit\n",
    "                df['class'] = class_name\n",
    "                df['original method'] = method\n",
    "\n",
    "            except:\n",
    "                print(f\"Error: The file '{path_file}' is empty.\")\n",
    "                data = {\n",
    "                'project': project,\n",
    "                'merge commit': merge_commit,\n",
    "                'class': class_name,\n",
    "                'original method': [method]\n",
    "                }\n",
    "                \n",
    "                df = pd.DataFrame(data)\n",
    "\n",
    "        else:\n",
    "\n",
    "            data = {\n",
    "                'project': project,\n",
    "                'merge commit': merge_commit,\n",
    "                'class': class_name,\n",
    "                'original method': [method]\n",
    "            }\n",
    "            \n",
    "            df = pd.DataFrame(data)\n",
    "\n",
    "        # Reorder columns to have new columns at the beginning\n",
    "        columns_order = ['project', 'merge commit', 'class', 'original method'] + [col for col in df.columns if col not in ['project', 'merge commit', 'class', 'original method']]\n",
    "        df = df[columns_order]\n",
    "        found_files.append(df)\n",
    "\n",
    "    \n",
    "    # Check if there are DataFrames to concatenate\n",
    "    if len(found_files) > 0:\n",
    "        # Concatenate all DataFrames, keeping all rows and columns\n",
    "        merged_file = pd.concat(found_files, ignore_index=True, sort=False)\n",
    "\n",
    "        merged_file = merged_file.drop(columns=['Method'])\n",
    "\n",
    "        # Save the result to a new CSV file with ';' as separator\n",
    "        merged_file.to_csv('merged_file.csv', index=False, sep=';')\n",
    "        print(\"Files merged successfully! File saved as 'merged_file.csv'.\")\n",
    "    else:\n",
    "        print(\"No file was found!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading analyses execution results...\n",
      "Generating results...\n",
      "Results in results.pdf\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.ReportAnalysis at 0x138671c40>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class ReportAnalysis:\n",
    "\n",
    "    def __init__(self, path_result, path_ground_truth):\n",
    "        self.soot_results = pd.read_csv(path_result, sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "        self.loi = pd.read_csv(path_ground_truth, sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "\n",
    "        self.generate_results()\n",
    "\n",
    "    def get_method_name(self, method_declaration):\n",
    "        match = re.search(r'\\.([a-zA-Z_][a-zA-Z0-9_]*)\\(', method_declaration)\n",
    "        if match:\n",
    "            method_name = match.group(1)\n",
    "            print(\"Method name:\", method_name)\n",
    "        else:\n",
    "            print(\"Method name not found.\")\n",
    "\n",
    "    def get_loi(self, project, class_name,  method, merge_commit):\n",
    "        df = pd.read_csv(\"LOI.csv\", delimiter=';')\n",
    "    \n",
    "        # Encontrar o índice do ponto final e do parêntese\n",
    "        dot_index = method.rfind('.')\n",
    "        paren_index = method.find('(')\n",
    "\n",
    "        method_name = \"\"\n",
    "\n",
    "        # Extrair o nome do método\n",
    "        if dot_index != -1 and paren_index != -1:\n",
    "            method_name = method[dot_index + 1:paren_index]\n",
    "\n",
    "        value_LOI = (\"\", \"\")\n",
    "        \n",
    "        for project_l, class_name_l, method_l, merge_commit_l, LOI, original_sample in zip(\n",
    "            df['Project'], \n",
    "            df['Class Name'], \n",
    "            df['Method or field declaration changed by the two merged branches'], \n",
    "            df['Merge Commit'], \n",
    "            df['Locally Observable Interference'],\n",
    "            df['Original Sample'],\n",
    "        ):\n",
    "            if (project_l == project and \n",
    "                class_name in class_name_l  and \n",
    "                method_name in method_l and \n",
    "                merge_commit_l == merge_commit):\n",
    "                \n",
    "                value_LOI = (LOI, original_sample)\n",
    "\n",
    "                break  # Para parar no primeiro match encontrado\n",
    "\n",
    "        return value_LOI\n",
    "\n",
    "    def calculate_matrix_loi(self, columns):\n",
    "        results = []\n",
    "        loi_list = []\n",
    "        original_sample_list = []\n",
    "        info_LOI = ['project', 'class', 'original method', 'merge commit']\n",
    "        \n",
    "        # Limpar espaços em branco nos nomes das colunas\n",
    "        self.soot_results.columns = self.soot_results.columns.str.strip()\n",
    "\n",
    "        for index, row in self.soot_results.iterrows():\n",
    "            value = row['HasSourcedAndSink']\n",
    "                    \n",
    "            values_LOI = [row[column] for column in info_LOI if column in row]\n",
    "\n",
    "            (loi_actual, original_sample) = self.get_loi(*values_LOI)\n",
    "            \n",
    "            loi_list.append(loi_actual)\n",
    "            original_sample_list.append(original_sample)\n",
    "\n",
    "            result = \"-\"\n",
    "            # Determinar o resultado\n",
    "            if \"Yes\" in str(value) and \"Yes\" in loi_actual:\n",
    "                result = \"TRUE POSITIVE\"\n",
    "            elif \"No\" in str(value) and \"No\" in loi_actual:\n",
    "                result = \"TRUE NEGATIVE\"\n",
    "            elif \"No\" in str(value) and \"Yes\" in loi_actual:\n",
    "                result = \"FALSE NEGATIVE\"\n",
    "            elif \"Yes\" in str(value) and \"No\" in loi_actual:\n",
    "                result = \"FALSE POSITIVE\"\n",
    "            \n",
    "            results.append(result)\n",
    "            \n",
    "        df = pd.read_csv('merged_file.csv', sep=';')\n",
    "        df['LOI'] = loi_list\n",
    "        df['Original Sample'] = original_sample_list\n",
    "        df['result'] = results\n",
    "\n",
    "        # Salvar o novo DataFrame em um novo arquivo CSV\n",
    "        new_csv_path = 'results.csv'\n",
    "        df.to_csv(new_csv_path, sep=';', index=False)\n",
    "\n",
    "        return results\n",
    "\n",
    "    def generate_results(self):\n",
    "\n",
    "        print(\"Generating results...\")\n",
    "\n",
    "        FP,TP, FN, TN = 0, 0, 0, 0\n",
    "\n",
    "        list_columns = self.soot_results.columns.tolist()\n",
    "\n",
    "        result_matrix = self.calculate_matrix_loi(list_columns)\n",
    "\n",
    "        for elem, count in Counter(result_matrix).items():\n",
    "            if (elem == 'FALSE POSITIVE'):\n",
    "                FP = count\n",
    "            if (elem == 'FALSE NEGATIVE'):\n",
    "                FN = count\n",
    "            if (elem == 'TRUE POSITIVE'):\n",
    "                TP = count\n",
    "            if (elem == 'TRUE NEGATIVE'):\n",
    "                TN = count\n",
    "\n",
    "        sensitivity = 0 if ((TP + FN) == 0) else (TP / (TP + FN))\n",
    "        precision = 0 if ((TP + FP) == 0) else (TP / (TP + FP))\n",
    "        f1_score = 0 if ((2*TP + FP + FN) == 0) else (2*TP / (2*TP + FP + FN))\n",
    "        accuracy = 0 if ((FP + TP + TN + FN) == 0) else ((TP + TN) / (FP + TP + TN + FN))\n",
    "\n",
    "        df = pd.read_csv(\"results.csv\", sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "       \n",
    "        fail_results = df['result'].eq(\"-\").sum()\n",
    "        total = len(df)\n",
    "\n",
    "        # variable pdf\n",
    "        pdf = FPDF()\n",
    "\n",
    "        # add a page\n",
    "        pdf.add_page()\n",
    "\n",
    "        # set style and size of font\n",
    "        # that you want in the pdf\n",
    "        pdf.set_font(\"Arial\", size = 15)\n",
    "\n",
    "        # create a cell\n",
    "        pdf.cell(200, 10, txt = \"Results for execution\",\n",
    "                 ln = 1, align = 'C')\n",
    "    \n",
    "        pdf.cell(200, 10, txt = (\"Precision: \"+str(round(precision, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"Recall: \"+str(round(sensitivity, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"F1 Score: \"+str(round(f1_score, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"Accuracy: \"+str(round(accuracy, 2))),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"False Positives: \"+str(FP)),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"False Negatives: \"+str(FN)),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"True Positives: \"+str(TP)),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        pdf.cell(200, 10, txt = (\"True Negatives: \"+str(TN)),\n",
    "                 ln = 2, align = 'L')\n",
    "        \n",
    "        pdf.cell(200, 10, txt = (f\"Total produzed: {total-fail_results} out of {total} units\"),\n",
    "                 ln = 2, align = 'L')\n",
    "\n",
    "        cm = np.array([[TP,  FP], [FN, TN]])\n",
    "        normalize = False\n",
    "        target_names = ['Actually Positive', ' Actually Negative']\n",
    "        target_names2 = ['Predicted Positive', ' Predicted Negative']\n",
    "        title = \"Confusion Matrix\"\n",
    "\n",
    "        cmap = plt.get_cmap('Blues')\n",
    "\n",
    "        plt.figure(figsize=(8, 6))\n",
    "        plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "        plt.title(title, fontsize=16)\n",
    "        plt.colorbar()\n",
    "\n",
    "        if target_names is not None:\n",
    "            tick_marks = np.arange(len(target_names))\n",
    "            plt.xticks(tick_marks, target_names, fontsize=16)\n",
    "            plt.yticks(tick_marks, target_names2, fontsize=16)\n",
    "\n",
    "        if normalize:\n",
    "            cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "        thresh = cm.max() / 1.5 if normalize else cm.max() / 2\n",
    "        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "            if normalize:\n",
    "                plt.text(j, i, \"{:0.4f}\".format(cm[i, j]),\n",
    "                         horizontalalignment=\"center\",\n",
    "                         color=\"yellow\" if cm[i, j] > thresh else \"black\", fontsize=23)\n",
    "            else:\n",
    "                plt.text(j, i, \"{:,}\".format(cm[i, j]),\n",
    "                         horizontalalignment=\"center\",\n",
    "                         color=\"yellow\" if cm[i, j] > thresh else \"black\", fontsize=23)\n",
    "        plt.tight_layout()\n",
    "\n",
    "        plt.savefig(\"confusion_matrix.jpg\")\n",
    "\n",
    "        pdf.image(\"confusion_matrix.jpg\", x = None, y = None, w = 160, h = 110, type = 'jpg', link = 'confusion_matrix.jpg')\n",
    "\n",
    "        # Save the pdf with name .pdf\n",
    "        pdf.output(\"results.pdf\")\n",
    "        # pdf.output(\"results.pdf\")\n",
    "\n",
    "        print(\"Results in results.pdf\")\n",
    "\n",
    "path_ground_truth = \"LOI.csv\"\n",
    "path_result = 'merged_file.csv'\n",
    "\n",
    "print(\"Reading analyses execution results...\")\n",
    "\n",
    "ReportAnalysis(path_result, path_ground_truth)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading analyses execution results...\n",
      "[14840.929, 79.359, 27731.963, 27731.963, 27731.963, 93.328, 98.003, 98.003, 89.479, 11735.528, 16357.635, 164.587, 3200.744, 3200.744, 74.763, 33278.731, 788.343, 120.656, 65.571, 18920.549, 18920.549, 20312.689, 352.354, 352.354, 108470.079, 109997.919, 75.043, 75.532, 75.532, 3070.832, 3070.832, 3070.832, 3070.832, 65.923, 65.923, 91.391, 91.391, 91.391, 85.443, 122307.236, 71.781, 69.205, 69.205, 359.293, 219.393]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "path_result = 'merged_file.csv'\n",
    "\n",
    "print(\"Reading analyses execution results...\")\n",
    "soot_results = pd.read_csv(path_result, sep=';', encoding='latin-1', on_bad_lines='skip', low_memory=False)\n",
    "\n",
    "soot_results.columns = soot_results.columns.str.strip()\n",
    "list_time_seconds = []\n",
    "\n",
    "for index, row in soot_results.iterrows():\n",
    "    value = row['Time (ms)']\n",
    "    try:\n",
    "        # Ignora valores que não são numéricos, como ' -'\n",
    "        if str(value) not in ['', '-', 'NaN', 'nan']:\n",
    "            list_time_seconds.append(float(value) / 1000)\n",
    "    except ValueError:\n",
    "        continue\n",
    "       \n",
    "print(list_time_seconds)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# Exemplo de classe que utiliza a função plot_by_variable\n",
    "class Plotter:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def plot_by_variable(self, leg1, leg_x, time_list1):\n",
    "        # Define o tamanho da figura\n",
    "        fig, ax = plt.subplots(figsize=(10, 4))\n",
    "\n",
    "        # Dados\n",
    "        data_x = [time_list1]\n",
    "\n",
    "        # Cores para os gráficos\n",
    "        boxplot_color = 'yellowgreen'\n",
    "        violin_color = 'thistle'\n",
    "        scatter_color = 'tomato'\n",
    "\n",
    "        # Boxplot\n",
    "        bp = ax.boxplot(data_x, patch_artist=True, vert=False, positions=[1], widths=0.6)\n",
    "        for patch in bp['boxes']:\n",
    "            patch.set_facecolor(boxplot_color)\n",
    "            patch.set_alpha(0.4)\n",
    "\n",
    "        # Violinplot\n",
    "        vp = ax.violinplot(data_x, points=500, showmeans=True, showextrema=True, showmedians=False, vert=False)\n",
    "        for b in vp['bodies']:\n",
    "            b.set_color(violin_color)\n",
    "            b.set_alpha(0.6)\n",
    "\n",
    "        # Scatterplot\n",
    "        features = data_x[0]\n",
    "        y = np.full(len(features), 1)  # Usando apenas 1 para a posição no eixo Y\n",
    "        jitter = np.random.uniform(low=-0.1, high=0.1, size=len(features))\n",
    "        ax.scatter(features + jitter, y, s=15, c=scatter_color, alpha=0.7, edgecolor='k')\n",
    "\n",
    "        # Configurações do gráfico\n",
    "        ax.set_yticks([1])\n",
    "        ax.grid(False)\n",
    "        ax.set_yticklabels([leg1])\n",
    "        ax.set_xlabel(leg_x)\n",
    "        ax.set_title(\"Results by time (s)\")\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(\"rain_cloud_time_sdg.jpg\", dpi=300)\n",
    "        plt.show()\n",
    "\n",
    "    \n",
    "# Criar uma instância da classe ExamplePlotter\n",
    "plotter = Plotter()\n",
    "\n",
    "# Nome da variável a ser plotada\n",
    "y = \"SDG\"\n",
    "x = \"Values (seconds)\"\n",
    "\n",
    "# Chamar a função para plotar o gráfico\n",
    "plotter.plot_by_variable(y, x, list_time_seconds)\n",
    "\n",
    "#time_list = [random.uniform(0.5, 3.5) for _ in range(100)]\n",
    "#plotter.plot_by_variable(y, x, time_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33 horas, 58 minutos e 27.236 segundos\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "\n",
    "def converter_segundos(tempo_em_segundos):\n",
    "    horas = int(tempo_em_segundos // 3600)\n",
    "    minutos = int((tempo_em_segundos % 3600) // 60)\n",
    "    segundos = tempo_em_segundos % 60\n",
    "    return horas, minutos, segundos\n",
    "\n",
    "tempo_em_segundos = max(list_time_seconds)\n",
    "horas, minutos, segundos = converter_segundos(tempo_em_segundos)\n",
    "\n",
    "print(f\"{horas} horas, {minutos} minutos e {segundos:.3f} segundos\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKkAAAJOCAYAAAB80lS+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACD8ElEQVR4nOzdd5xU1f3/8fedsr2xLEvvTVBRwK5RVBCNGltETPxaEE1ijC0mRo0KaoImsSXW/CzEFjUaNRFRiIoFsYAiKqCC9Lq0XbZNvb8/Zu7sndmZ3dlll7vl9Xw8ht25c8u5c2eYu+/5nHMN0zRNAQAAAAAAAA5yOd0AAAAAAAAAgJAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAB0GoZhaNq0aa2+jcsvv7xVt9GQcePGady4cY5tP5U//elP2meffRQOh9Ne5o033lBeXp7KyspasWUAAKCtIKQCAAAtYubMmTIMI3bzeDzq3bu3LrzwQm3YsMHp5iX14Ycfatq0adq1a5fTTWmSpUuXatq0aVq9erXTTUlLRUWF7rzzTl133XVyudI//TzxxBM1ZMgQzZgxoxVbBwAA2gpCKgAA0KJuvfVWPfXUU3r44Yd10kkn6emnn9Yxxxyj2tpap5tWz4cffqjp06e3y5Bq+vTpSUOqOXPmaM6cOXu/UQ14/PHHFQwGde655zZ52Z/97Gd65JFHtHv37lZoGQAAaEsIqQAAQIs66aSTdN5552nq1Kl69NFHde2112rlypX6z3/+43TTOoWMjAxlZGQ43Yw4TzzxhH70ox8pKyurycueddZZ8vl8+te//tUKLQMAAG0JIRUAAGhVP/jBDyRJK1eujJu+fPly/fjHP1ZxcbGysrJ00EEH1QuyAoGApk+frqFDhyorK0tdu3bVUUcdpblz58bmSTUG04UXXqgBAwakbNe0adP0m9/8RpI0cODAWDdFqzpp7ty5Ouqoo1RUVKS8vDwNHz5cN9xwQ9r7/cwzz2j48OHKysrS2LFj9d5778Uee+edd2QYhl5++eV6yz377LMyDEMLFixIut6ZM2fq7LPPliQde+yxsXbPmzdPUv3nY968eTIMQy+88IKmT5+u3r17Kz8/Xz/+8Y9VXl4un8+nq666SqWlpcrLy9NFF10kn89Xb7tPP/20xo4dq+zsbBUXF2vy5Mlat25do8/DqlWrtGTJEo0fP77eY88995zGjh2r/Px8FRQUaP/999d9990XN09paalGjRqlV199tdFtAQCA9s3jdAMAAEDHZoU+Xbp0iU37+uuvdeSRR6p379763e9+p9zcXL3wwgs6/fTT9dJLL+mMM86QFAmSZsyYoalTp+qQQw5RRUWFFi5cqM8++0wTJkzYo3adeeaZ+vbbb/XPf/5T99xzj0pKSiRJ3bp109dff61TTjlFo0aN0q233qrMzEytWLFC8+fPT2vd7777rp5//nldccUVyszM1IMPPqgTTzxRn3zyifbbbz+NGzdOffv21TPPPBPbV8szzzyjwYMH6/DDD0+67qOPPlpXXHGF/vrXv+qGG27QiBEjJCn2M5UZM2YoOztbv/vd77RixQr97W9/k9frlcvl0s6dOzVt2jR99NFHmjlzpgYOHKibb745tuwf/vAH3XTTTZo0aZKmTp2qsrIy/e1vf9PRRx+tzz//XEVFRSm3++GHH0qSxowZEzd97ty5Ovfcc3X88cfrzjvvlCQtW7ZM8+fP15VXXhk379ixY/XKK680uH8AAKD9I6QCAAAtqry8XNu2bVNtba0+/vhjTZ8+XZmZmTrllFNi81x55ZXq16+fPv30U2VmZkqSLrvsMh111FG67rrrYsHNrFmz9MMf/lB///vfW7ydo0aN0pgxY/TPf/5Tp59+elzV1dy5c+X3+zV79uxYeNUUX331lRYuXKixY8dKkiZPnqzhw4fr5ptv1r///W8ZhqHzzjtPd999t8rLy1VYWChJKisr05w5c3TjjTemXPegQYP0gx/8QH/96181YcKEtK/kFwwG9e6778rr9ca29dxzz+nEE0/U66+/LilyDFasWKHHH388FlKtWbNGt9xyi26//fa4SrIzzzxTo0eP1oMPPthghdny5cslRarV7GbNmqWCggK9+eabcrvdDbZ90KBB2rZtm7Zu3arS0tK09hcAALQ/dPcDAAAtavz48erWrZv69u2rH//4x8rNzdV//vMf9enTR5K0Y8cOvf3225o0aZJ2796tbdu2adu2bdq+fbsmTpyo7777LnY1wKKiIn399df67rvv9uo+WJVBr776qsLhcJOXP/zww2MBlST169dPp512mt58802FQiFJ0vnnny+fz6cXX3wxNt/zzz+vYDCo8847b892IInzzz8/FlBJ0qGHHirTNDVlypS4+Q499FCtW7dOwWBQkvTvf/9b4XBYkyZNih2rbdu2qUePHho6dKjeeeedBre7fft2eTwe5eXlxU0vKipSVVVVXNfNVKwqvG3btqW1rwAAoH0ipAIAAC3qgQce0Ny5c/Xiiy/qhz/8obZt2xarlpKkFStWyDRN3XTTTerWrVvc7ZZbbpEkbd26VVLkSoG7du3SsGHDtP/+++s3v/mNlixZ0ur7cM455+jII4/U1KlT1b17d02ePFkvvPBC2oHV0KFD600bNmyYqqurVVZWJknaZ599dPDBB+uZZ56JzfPMM8/osMMO05AhQ1pmR2z69esXd9+q3urbt2+96eFwWOXl5ZKk7777TqZpaujQofWO17Jly2LHqqkuu+wyDRs2TCeddJL69OmjKVOm6I033kg6r2makiTDMJq1LQAA0D7Q3Q8AALSoQw45RAcddJAk6fTTT9dRRx2ln/zkJ/rmm2+Ul5cXC3quvfZaTZw4Mek6rJDm6KOP1sqVK/Xqq69qzpw5evTRR3XPPffo4Ycf1tSpUyVFggsrxLCzKpaaIzs7W++9957eeecdzZo1S2+88Yaef/55HXfccZozZ06j3dPSdf755+vKK6/U+vXr5fP59NFHH+n+++9vkXUnStXmVNOt5zQcDsswDM2ePTvpvIkVUom6du2qYDCo3bt3Kz8/Pza9tLRUixcv1ptvvqnZs2dr9uzZeuKJJ3T++efrH//4R9w6du7cKUnN6noJAADaD0IqAADQatxut2bMmKFjjz1W999/v373u99p0KBBkiSv15v0im+JiouLddFFF+miiy5SZWWljj76aE2bNi0WUnXp0kXff/99veXWrFnT6LobqsxxuVw6/vjjdfzxx+vuu+/WH//4R91444165513Gm13su6J3377rXJyctStW7fYtMmTJ+uaa67RP//5T9XU1Mjr9eqcc87Zo3a3tMGDB8s0TQ0cOFDDhg1r8vL77LOPpMhV/kaNGhX3WEZGhk499VSdeuqpCofDuuyyy/TII4/opptuiqsmW7VqlUpKSuKeOwAA0PHQ3Q8AALSqcePG6ZBDDtG9996r2tpalZaWaty4cXrkkUe0adOmevNb3eGkyHhGdnl5eRoyZIh8Pl9s2uDBg7V8+fK45b744ou0rsSXm5srSdq1a1fc9B07dtSb98ADD5SkuG2nsmDBAn322Wex++vWrdOrr76qE044Ia4aqaSkRCeddJKefvppPfPMMzrxxBPTqhZK1e7WcOaZZ8rtdmv69On1KtZM06x3jBJZVylcuHBh3PTE5VwuVyzESnyOFy1alPJqhwAAoOOgkgoAALS63/zmNzr77LM1c+ZM/fznP9cDDzygo446Svvvv78uueQSDRo0SFu2bNGCBQu0fv16ffHFF5KkkSNHaty4cRo7dqyKi4u1cOFCvfjii7r88stj654yZYruvvtuTZw4URdffLG2bt2qhx9+WPvuu68qKioabJc1uPmNN96oyZMny+v16tRTT9Wtt96q9957TyeffLL69++vrVu36sEHH1SfPn101FFHNbq/++23nyZOnKgrrrhCmZmZevDBByVJ06dPrzfv+eefrx//+MeSpNtuuy2t5/PAAw+U2+3WnXfeqfLycmVmZuq4445rlSvfDR48WLfffruuv/56rV69Wqeffrry8/O1atUqvfzyy7r00kt17bXXplx+0KBB2m+//fS///0vbpD2qVOnaseOHTruuOPUp08frVmzRn/729904IEHasSIEbH5tm7dqiVLluiXv/xli+8bAABoWwipAABAqzvzzDM1ePBg/eUvf9Ell1yikSNHauHChZo+fbpmzpyp7du3q7S0VKNHj9bNN98cW+6KK67Qf/7zH82ZM0c+n0/9+/fX7bffrt/85jexeUaMGKEnn3xSN998s6655hqNHDlSTz31lJ599lnNmzevwXYdfPDBuu222/Twww/rjTfeUDgc1qpVq/SjH/1Iq1ev1uOPP65t27appKRExxxzjKZPnx4bcLwhxxxzjA4//HBNnz5da9eu1ciRIzVz5sx63d0k6dRTT1WXLl0UDof1ox/9KK3ns0ePHnr44Yc1Y8YMXXzxxQqFQnrnnXdaJaSSpN/97ncaNmyY7rnnnljQ1rdvX51wwglptXnKlCm6+eabVVNTo+zsbEnSeeedp7///e968MEHtWvXLvXo0UPnnHOOpk2bJperrtj/3//+tzIzMzVp0qRW2TcAANB2GGaykUYBAACwVwSDQfXq1UunnnqqHnvsMaeb0yrKy8s1aNAg/elPf9LFF1/cpGVHjx6tcePG6Z577mml1gEAgLaCMakAAAAc9Morr6isrEznn3++001pNYWFhfrtb3+rP//5z7GrO6bjjTfe0Hfffafrr7++FVsHAADaCiqpAAAAHPDxxx9ryZIluu2221RSUhI30DoAAEBnRCUVAACAAx566CH94he/UGlpqZ588kmnmwMAAOA4KqkAAAAAAADgOCqpAAAAAAAA4DhCKgAAAAAAADjO43QDsPeFw2Ft3LhR+fn5MgzD6eYAAAAAAOAI0zS1e/du9erVSy4XdTxOI6TqhDZu3Ki+ffs63QwAAAAAANqEdevWqU+fPk43o9MjpOqE8vPzJUXehAUFBQ63BgAAAAAAZ1RUVKhv376xv5PhLEKqTsjq4ldQUEBIBQAAAADo9BgKp22gwyUAAAAAAAAcR0gFAAAAAAAAxxFSAQAAAAAAwHGMSQUAAAAAAIBmCYfD8vv9KR/3er1yu91prYuQCgAAAAAAAE3m9/u1atUqhcPhBucrKipSjx49Gh2gnpAKAAAAAAAATWKapjZt2iS3262+ffvK5ao/opRpmqqurtbWrVslST179mxwnYRUAAAAAAAAaJJgMKjq6mr16tVLOTk5KefLzs6WJG3dulWlpaUNdv1j4HQAAAAAAAA0SSgUkiRlZGQ0Oq8VYgUCgQbnI6QCAAAAAABAszQ2zlS680iEVAAAAAAAAGgDCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAECzmKbZ6DzhcDitdXn2tDEAAAAAAADoXLxerwzDUFlZmbp165b0Cn6macrv96usrEwul0sZGRkNrpOQCgAAAAAAAE3idrvVp08frV+/XqtXr25w3pycHPXr108uV8Md+gipAAAAAAAA0GR5eXkaOnSoAoFAynncbrc8Hk/SSqtEhFQAAAAAAABoFrfbLbfb3SLrYuB0AAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOM7jdAMAAGhPKisrVVtb63QzAADtRFZWlvLy8pxuBgC0C4RUAACkqbKyUk//8znV+ANONwXYY7mhCu1f+7G+zDpUVe4Cp5sDdFjZGV6dd+5kgioASAMhFQAAaaqtrVWNP6ADDz9KBYWFTjcH2CPZ25dq5Ot/VOG4S1XTdaTTzQE6pIryci1e8IFqa2sJqQAgDYRUAAA0UUFhoYq7ljjdDGCPZISKJEmFRUXK5vUMAADaAAZOBwAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOM8TjcAAIDWZCa5JZuuJL/bf0rSbkk+SbWSqluofUYD9xt6zD4tnXU0tF4AAACgLSCkAgC0C1aAFE7x0/o9nDAtWfCU+HtD2zRs81ZLCkrySwo0f1daVaogq6Fp9qDLSDKtofmTrb+x4AwAAABIhpAKAOAoK0QKKT54CtumJQZP9uXsIZKUPGyxfiarKkp2PxWvIv3k3dFbW5VOABduxjKppFvxlXi/oWOV7vrTDeXSWS6ddQAAAKD1EFIBAFqVFTrZA6eQ7ZZY9WRfLlnA5LJNs/9EnXSek5Z+3hoLuVoyFGtIa+17U5ZpTtfKdIK1dNeZbkhnBa3WezHV/FTFAQCAvYWQCgCwx6xKKCt0sn4Pqi6YsuazSwyfCJ7ar7ZUmdSSAViyrqLNWb4tst6XNYqMs5ZMS3YVTVXN2FCVIwAA6FwIqQAAabFXRNlvwejPxEooqe6PTwIo7E0t+RrryK9Xl+2nS+kHai1RFZfOmGaNVVAm/s7/MQAAtH+EVACAOFbYZIVPVhBlVUUlhlGJQRR/IALt0552TWyqZOFWqgsdpNOWZNVZ9v+fEqenug8AAJxDSAUAnZjVTS9o+xlQw2GU23YfAJqrOeNtJZMYZiUb466xNiQLrVLdEudrbrsBAEB9hFQA0EnYq6OsMMpeHWWhMgpAe7InA7snBlmpxs9Ltf5U4Vayyq3GxuYCAACEVADQIdkrpBoLpAijAHRWzQ249iTcolsiAACpEVIBQDtnDWhuD6SsLnthxQ88TCAFAHuuJcKtPemWaP3e1O6Iqa68iLYp8fWSalqq+41Nt0v1WkhVOZjsJwC0BEIqAGhnrG579kAqpLoqKfs38m5x8ggAbUVzA6I9GXeroe2mc7XEhpZJ9niqeVK1Z29LJ8hJNah/svuNzeuP3iolZaj+xQGSXSygsbY0NL0xya7C2xQNHWv7l2LJqgPt05NVEfIlGgCJkAoA2jyrSiqg5FVS1s0jTu4AoCPak3G3LMlCjXAjj6djT4KovfWZle6+NTZfc56jWkU+tyslZSV5vDnPX7phTnOf36Y8D8nC0sTHG9sX66f95lZdBbgVYLmSTAPQ8RBSAUAbYu+6F1Dk21drLCmLdXJGlRQAIF3JPi9a6jOkOeFNUyrBWkpj+9salV9W2JIhybsH69mb9sa5RbLqMescSIqcA1mPparks58PuRPuE2QB7RchFQA4yDohswY296mu657FJaqkAABtV3M+n/hM69yaOp5VslDLukBMqnVbQZVHdcFV4k8AbQ8hFQDsZSHVddvzKz6UouseAABAvHRDrcQxvqzKdHu3Q/s4WB7VhVj2iizOwQDnEFIBQCuzKqWSdd8jlAIAAGgZjY3XZR+s3l6JlXjhGY/qB1iEV8DeQUgFAC3MVHwoZQ10bqH7HgAAwN6XKsSyV1+FFRl+wZewnFv1wyvO54CWR0gFAHvIXk5uBVNh1Z3wEEoBAAC0XYkDslsaGgPLXg3vVXx4xXhXQPMRUgFAM1jjSvkVP66UvVQ83UtEAwAAoO1pKLyybn5Fqq4MpQ6u+LISSB8hFQCkwd6Fz6e6caVMxV/ymBMQAACAjs3+RaQ7+rOh4MqlSGhlD64Y4wpIjpAKAJKwyrrt1VJ04QMAAEAyjQVXtZJqVBdauVU/uOK8EiCkAoAYq1rKCqWsSxZLdOEDAABA06QKrsKqG8/Ums+qtspQfLUV0NkQUgHotKyTBL/iq6WssaXowgcAAICWZF0p0GJVWoVVV21lfTFqD628IrRC50BIBaBTSRxbyqqWso8txX+MAAAA2Bvs41ZJdVX8YUXOVX3R+9Y5aqYIrdCx8boG4Kjq6mp99tlnqq6ubrVthBT5ZqpC0jZJOyXtVqRyyroCi/UtFf8pAgAAwClWaJU4ZpUUOXetUORc1jqnrVJdb4DWtDfO2QGJv8cAOGz58uUaO3asli9f3mLrtKqlqhX58N4uaVf0flh130R5RXc+AAAAtG320Mr6YlWKVFntlrRDkdBql+pCK7PeWvZMa5yzA8nQqwVAhxBW3aDnPkWqp+xjS3HFFAAAAHQEVmiVOBi7fUwrlyKBlr0ai3NhtAeEVADaJVORIMoaW8oqc7aPLUWVFAAAADo6e2hlH4i9RpGeBNZ5cYbqgitrcHagrSGkAtBuWN34rGqpoOpKmamWAgAAQGeXbCB268vd6ujNGpM1U3WVVowDhLaCkApAm2ZVS1nBVFh13fisSimCKQAAAKC+ZKGVfZgM6zF7lRVf/MJJhFQA2hRTkQopqxtfQHVXK7E+ROnGBwAAADRdQ+NZ1doeT+waCOwthFQAHFPtD+rMFzap/3WvqSIY1m7VDXpONz4AaHtq/SGdffd7kqR/XXO0sjLcjSwBAGjLko1nZe8a6JIUsJ2z1wbDKdcFtARCKgBtwm5FLplrVUvRjQ8AAADYe1J1DfTb5iGiQmsjpALQJhiKlBMDAAAAcJ5VZcU5OvYmupcCAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVIBAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVIBAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVIBAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVIBAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVIBAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVK1srKyMv3iF79Qv379lJmZqR49emjixImaP3++JGnAgAEyDEOGYSg7O1sDBgzQpEmT9Pbbbydd30svvaTjjjtOXbp0UXZ2toYPH64pU6bo888/35u7BQAAAAAA0KI8TjegozvrrLPk9/v1j3/8Q4MGDdKWLVv01ltvafv27bF5br31Vl1yySXy+/1avXq1nn76aY0fP1633Xabbrzxxth81113ne666y5dccUVmj59uvr376+ysjLNnj1b119/vd544w0ndhFoEWtXr9H7s/6r9atWqs/AwTp98mQNGzEi9vi3y5bpleeeS/l4KtZyXy/+TOXlFepSVKgRB4xOa/nmbjNxHY/97W/69MMPFA4EZbrcCoeC8mZ4dfARR+niX/0qrXZY6/C43Bp9+BG6+PLLm/T8NGdfki0jqUXW0xLHtt5zdP/9+nzBhwqGQ/We21TbmPPaa3rwL3/W9k0b1bVnL512zmQt//LLlMfrrPPOa7AdWzdt0ueffqpN69eqpqZWOdnZ6tGnr0YffLBKe/aMzffGf17V/HfekcIhyeXWkcceqxN/dFqj+7l10yZ98M7bWr1yhdyGS30HDdZRxx4bt+7mstq+a3uZirp2q9fmdOZLdx172oaWXrYp7Uv1/Fvb37x+naprapSdnaWComJJpgK+2j1uU+L+9R0wQOtWr270vr09noxMbS8rk7+mWnmFRTr9sIEamrCdpUuW6N25c1RZvksZWTnqWloqr9uItb+ga+keP4+J+/XBO+9o3fcrFTLDGjB4iI469riUr72WfP2nes0kmy6p2dMaal9jx7Wh5Rt7zbfke6I57WyJ7aezjpbaz5b6/8ebmaXq6hptWb9O1dXVCpumdm1er9GjD1DXkpIG15P4WXXgwQdr8aef7tHnY0tp6LM61WPW+csHb7+l2qpKZefla98DR6uouFg1u8v3eJ/s283OK5AMo95657z2mu669VZtWLVSVbU+ZWdlqUvXrjrquON18a9+JUmNrqOltcR5TzrrtvZn64Z12rmrXIWFBdr3wDFN3t63y5bpxX++IOkgSdKa1Wt01CEHpZx/2bJlev6557R21Ur1GzhY50yerBEOvW7RPhmmaZpON6Kj2rVrl7p06aJ58+bpmGOOSTrPgAEDdNVVV+mqq66Km37LLbfo9ttv19KlSzV8+HB99NFHOvzww3XffffpiiuuqLce0zRlGEZa7aqoqFBhYaHKy8tVUFDQ5P0CWkq1P6iRN78pSeq+4B7t2zVb+/bvra9Xb9Amv6nfzrhTQ/cZru+Wf6M/XX+demYaSR9PxVouO1CtNes2qHdRrgZ176ZtAWm7vA0u39xtJq7j5isuV9maVdqvd6n6FOXrqw2btX5Hufp366o128vVrf9A3frX+xtsh7WO/ft014CSIn29sUxVuV007d6/pvX8NGdfki3z3c5KuVwuDS7K2aP1tMSxTdzGtKuuUF7VTo3s3U2rynbqq/VbY8+tpKTbOPqHp+jvf75D+/cs1qj+vTR/+Sp9uXazuuTn6oC+PZIer6JefXTYhJN08uSfqqi4a1w7yjZv1huvvKSMoF/bd+5Sl5xMlRTka3dIqpJLJ55+lrr16KG5r7+mj+e9o4ElRepdXKj1O8q1etsuHTruWE344Skp97Ns82a9+tw/Vbljm3p3KVDXvBxtLN8tX0aOfjRpsrr16JHW85Vq3W+88pIKPYZ6FRdp4/ZdKg+ZsTanM5+ktNaxp21o6WXT1dDzf+Rx4/XpB+8qT2HluaWyit3aWVWrTK9blTV+jRo2UJU1/ma3KXH/1m7drpUbN6tfaYkG9+quFRu2aF3ZNg3p1UN9S7vGHu/dtYu65WSqrGK3Nu3crdpAQP27FqpfSbHW7yxXRtVa3Vnymr4+e7aqu+2v5V99pf++8E/1KcxVYU62lq3frJL8XA3u10c7qmpVHjJ17Cln6OoXVkiSnvrVkcryuvfoOf3PC88p01+tXkX52ra7Sht37lZecYlOm3xuvddeS77+U71mDj7qGH36wbtx08tq/DLDpkrzMmPTtlb5ZLgMdcvJaHC+ho55YhsSj2NDyzf2mm/J90Rz2tkS209nHS21ny31/09eVoY+X/69SvKy1KuoQNurqrRy01Z99enHKinuohkPPZL25+Xn367S/K+/0ehhg3TkvsOa9fnYUhr6rJaSf8ZOvvTnevSeu7Rp1UoNKSnUiF6l+mLdZi3bsFUHDuytHxx0oFZs2t7sfbK3qaQgV/959yMNLi3WkWNHxdZ79A9P0SN3/lEjSos0sFsXrSnbqe/LdqhLbo62VNWqS/eeys3L0+CinJTraOnnuyXOe9JZt7U/A7t10ZAe3bR66zZtLK9Svz69VZuRk/b2rHWWZnn17tCpkqS+8/+kv//94aTB07Jly/S7X1+tnpmGRg3ooy9Wrddmv6k77rqnTQdV/H3cthBStaJgMKguXbpo6tSpuuOOO5SZmVlvnlQh1Y4dO1RSUqI77rhDv/3tb3XllVfq8ccf186dO+XxNK0Azufzyefzxe5XVFSob9++vAnhOHtIBQDYu/Y1VmlW5o062fcHfW0OdLo5AIB2YL8Fd+igccdp2vTp9R6bdsst2rzkE90+ZZI8breCoZBufOwF9TzgkKTztxWEVG0LY1K1Io/Ho5kzZ+of//iHioqKdOSRR+qGG27QkiVLGl22uLhYpaWlWr16tSTp22+/1aBBg+ICqrvvvlt5eXmxW3l5edJ1zZgxQ4WFhbFb3759W2T/AAAAAACdR5e8bK1dtTLpY2tXrdSoAX3kcUeqbD1utw4Y2Cfl/EAyjEnVys466yydfPLJev/99/XRRx9p9uzZ+tOf/qRHH31UF154YYPLNtaFb8qUKfrRj36kjz/+WOedd55SFcVdf/31uuaaa2L3rUoqoC3p885t+u05P5Tb5VIoHNajr72lgiEj9dOpF+uZRx9TxYqlmnrK8UkfT8VaLi/Lq907d+ri4w/TxrJdUnaO3ljybYPLN3ebietY9PYcDelWpPOOHC2Fg9qya7f+vXCpehUXabfPrxVluzT2uBMabIe1jkvGHy7D5dKqjWX69+dL1WfMEWk9P83Zl2TLXPfgP9S9KE/X/OSsPVpPSxzbxG2s/+xDnTl6pAb26iYzHNb/+9+C2HMrKek2Fq5YrSFFubrmR8fK63br6Xc/1YJvVmmfXt100bGHJj1eyzftUPfhI3TdnXepR68+ce343+uzVL1hjbIz3KqurNIPx4zQ9vJKyZupT75fr5ze/TX+hyfr1ut+q0Fd83XOoaPkcbsUDIX1/MdL9P323br5zj+l3M//vT5L336+UL2L8nXymBEyXC5t3r5L73+7ViXDRmr8D09O6/lKte7qDWv0w8NHy224FDLDen3B57E2pzOfpLTWsadtaOll09XQ87/blaHu2V4dMqiPFPCpa2Ge/vvpVzJMyeVxKzc/T+PG7N/sNiXu35bNW/T24q/UraSrxh90oP63cLHKtm3XcQfup+49uscez8nK1mGD+6hrYZ7uevVt9Sku0Olj95XH65Xb69GCBYslSX86b4yqu+2v//fX+5QbqNLZR4zWu1+tUGVNrcYM6Kmw26s+/fvp9QWfy9uzvx7/Nl/Snnf3+9/rs7Tt26X6wbB+6tG1SGY4rFmfLdOGXbs1bPRB9V57Lfn6T/Wa2VITUPdsb9z0F//3gXZUVevS006ITfv7q3NUnJujH48/qsH5GjrmiW1IPI4NLd/Ya74l3xPNaWdLbD+ddbTUfrbU/z/zPvtSZWXbdOTQvirOzVFWRoaefe8TzX59toyAX4eecGLan5drVq/Rc2/PV58+vfTTE8Y16/OxpTT0WS0l/4xdu7tWvp3b1D03S2ceNFIDS4v15HsLtbmiUiePHqHibqXq0btPs/fJ3qYX3vpA5Tu2a8J+w5RVkB9b78IVqzWoIEuTDtlfbsNQr+J8/f2dTxUMhRUIS0s3btPI/j10zU/OSrmOln6+W+K8J511W/tz7IiBCoXDGtqnpx576yPld+miytpA2tuz1vl/J0/Qb8pGS5J2VtbooIMGJ52/38DB+uKLTzQpFIpVUn2xar36HXDIHu0bOhdCqr0gKytLEyZM0IQJE3TTTTdp6tSpuuWWWxoMqbZv366ysjINHBgpvx86dKg++OADBQIBeb1eSVJRUZGKioq0fv36BrefmZmZtKsh0JaEMjL13/cWaP+BffTlqvUKZWXrl1dfoWEjRqgoP1e3//rqlI+nYi3n91Vp0/YdmjnnPQ3pWaqygBpdvrnbTFzH75Z/qRWrv9dLH4bUr0uBlqzbpC3by5XtllZvL1fpgEGNtsNaxzNvz9egbsX6csNWGXld0n5+mrMvyZYp7dVThsu1x+tpiWObuI0bfvG15iz+SvuXler7sh1asWFL7LmVlHQb11z/Oz34x9s0c857Gj2wt7Zu36bKqkp9v1l66cOFSY9Xt959ddgRh6swP1dZGfF/nB9y6MGa9eIq+XfXaPvOXXr5w0UqLbTGpHJr3KEHKyvDraOPPVoL3vqfXvp4sfp2LdS67eVaV7ZTRx8/vt46E9e//rvlWrtlq/7zca265eVqw67d8mXm6JDoupvLavvcjz5T75Iibdi2S1VhM9bmdOaTlNY69rQNLb1suhp6/o+fMF4fv/uOPl2xSvluaevXu7WjqkZZXo921/h0YFG+5n70WbPblLh/a7Zs0+byCmVkZurL71aofHelNpdX6NMVq9R/9+7Y4709Hi1fv1Fbv96tLI+h9dt26LVFX6p/t2Kt21EuT1WllCVleF0KZ7h1/Anj9cqzT+nlDxepS262Vm/ZosrqKg0b0FfLou0ff9BYPf7tt5KkLK97j193L6/8Ru8v/U69i/JVVlmlDTsqlN+1W73XdEu//lO9Zo4/IXIs7dN9brdy8vLipuXk5cnnMhqdr6FjntiGxOPY0PKNveZb8j3RnHa2xPbTWUdL7WdL/f+Tl52hLTvL9d5Sv/p0KdC2yipt3LFThhFWt56lTfq8XPTt91q/c5dKu3XVyjVrmvX52FIa+qyWkn/GXnfNb/Twn+7Q+pUrNHvREu3Xu7t2VlRoxfotej/Do3GH5uvT9xY0e5/sbepXUqCXv/xKZtCvYw4+MLbea67/ne6/bbre/PwrDS4t1uzPdmhN2Q4V5+Zoc2Wt+vfvLSMvr8F1tPTz3RLnPems29qfcKBWw3qWav7S77RpV6Uyc3IUyspNe3vWOmd/8LE0PBJSlYddOid6MZ1E50yerN99+rFufOwFHTCwbkyqq1LMDyTDmFQOuPvuu/XHP/5R27ZtSzkm1c0336w//vGPWr58uYYMGaIFCxboiCOO0L333qsrr7wybt558+bp2GOP1c6dO1VUVNTo9ulzi7bCPibVb8fUas3XS7i6XyPr4Op+DTxHe+nqfp9//oWOOvFkdela/ypNXN2Pq/u1t6v7nfDp5fruJ2+qtnSUpPSu7nf23e9Jkv51zdF7HAJydT+u7teU7bbnq/v9+vrf6ZAjjmhwPVzdr/lt4up+9dfd0lf3e8kfuaLfH8bU6qeTzko5f3u8uh9/H7cthFStaPv27Tr77LM1ZcoUjRo1Svn5+Vq4cKF+9atf6eSTT9Zjjz2mAQMG6OKLL9Yll1yiQCCgVatW6emnn9ajjz6qGTNm6Lrrrout79prr9W9996rK664Qmeeeab69u2rTZs26YEHHtAzzzyjXbt2pfWm4k2ItsIeUt1/Zncd3sDlbIG2YPu2bXrx+X+lDKmA9iRr6xINfXZiXEjVmFp/qEVDKqCj27l9mz54Y5Z+fM7Z6lrC5wbapxp/UEdFz9mfPrO7jupg5+z8fdy20N2vFeXl5enQQw/VPffco5UrVyoQCKhv37665JJLdMMNN8Tmu/nmm3XzzTcrIyNDPXr00GGHHaa33npLxx57bNz6/vKXv+iQQw7RQw89pMcff1zV1dXq3r27jj76aC1YsIA3FAAAAAAAaLcIqVpRZmamZsyYoRkzZqScx7p6X7omTZqkSZMm7WHLAAAAAAAA2haX0w0AAAAAAAAACKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCkCbYTrdAAAAAACAYzxONwAALMHoT1f0ZjjYFgAAAKCzMqO3sKSAw21B50JIBcAxORke/XtST40dO1alkxapQJI/egsq8sFoD6wIrQDAWVkZbv33d8c63QwAQCuwQqlw9L6hyHl4cYZHz07qqSPHjlXOpEWOtQ+dAyEVgDbBIyknegurLqzySwqprisgVVYAAADAnrNXS4VVF0plSsqQ5I3eDElZDrURnQ8hFYA2x6XIB2GWIh+cQUXCKl/0d6vKyi0CKwAAACAdyUIpQ5FQwAqlMsTA1XAWIRWANs1Q3bc4yaqsgrb56BYIAAAA1LGHUvahNLJUF0y5xfkz2g5CKgDthqHIh2h29GYN5Jg4jpVEt0AAAAB0PonjSkmpu/ABbREhFYB2y/rAzVRdt8CAIt0CA2LwdQAAAHRsqcaVylB8KEUXPrQXhFQAOoTGugUy+DoAAADaO3soZZ3bJo4rZYVSnOuiPSKkAuCoffbZR4sWLdI+++zToutNHHw9oLoqK2vwdanu2ya+XQIAAEBbkyqUcis+lGrtcaVa65wdSERIBcBROTk5GjNmTKtuw1BdyXOuIlVV9iqrsCKhlT2w4psnAAAA7G32QMrJUCrR3jhnByRCKgCdkH3wdavKygqsko1lRZUVAAAAWkOygc6t7nteORdKAU4hpALQqdmrrExFqqzsoRVVVgAAAGgJybruSfEDnVvhFOec6KwIqQAgyvrWyqP4KquGxrLiioEAAABIZIVQViBlXXnPOoe0V0l5ROU+YCGkAoAU7FVW1hUD7VVWIcVf6pdvvAAAADqfhgIp+xWoPbYb54xAcoRUAJAGa8BKt+quGBhUXZWVNZaVNa+90goAAAAdg5lwswIpKXLuZ3XXswdSVEkB6SOkAoBmsH8rZq+yomsgAABAx5A4hpSp+AqpxEDKLb6kBPYUIRUAtACXpMzoLVfJuwZaJzf2roGcxAAAADjHtP20Ainrvr063gqkrMp6KqSA1kFIBQAtLFnXwGRXDTRt8xNaAQAAtJ7Ebnr2yiip7nzMusKeVRll3ThHA/YOQioAaGXJrhpojWdlBVf2MnIqrQAAAJrGHjwp4XeLdW5lVULZu+gRRgFtAyEVAOxl9vGspIZDK2t+QisAANAZJQudklVCSfHjRVlBlBU+WV8CWr8DaJsIqQDAYalCKyu4SjamFVcPBAA4JbE6pTnzpLOOlpTO52VTP1P5DG4aM8nvqX5avzcUQNmrn1xJbhwfoH0ipAKANsYeWlndA0OKr7ayXz3QWoZqKwCAXbIgKFlQ0BTJPmMampbqscY+q5r6WZZuKJZqvuaEasm6kyUKKf4KwNZyhuqHMHYN7X+6z01zzgeaG0A2FC4lShY8Wecwbtt9e9iUeJ9zHaDjIqQCgDbOPqZVVnSadcJrD64SL49sP5HjZA4A2p/EMKCxoMUuMQiw/27ddyVMS7ZMqp+p5ku2zfakoQCmsXAm2by1ilz5N09SfpLHE7uw2ac1VHnUUHvtjzUliEw3OHQl3DcSbq4GHks2H+cpAOwIqQCgHXIpctKbGb1v7yJoBVdB1R/byjoptO4DAFpfOmFDomSBkSvhZ7L/0w0lD5YaqmxCnXQrxdLlVeQPrtzoraU0FlbtSXfKhgJHXj8AWhshFQB0AInjWkmRgCqoSFcDq9oqpLquB6m+2QQAJNecyqZUgVFiRUniY6nuA1LHqVwDgESEVADQQbkkZUR/z47+TAyurMore8WVRNUVgI5tT8Im+++J3ZWShU1UMwEAkD5CKgDoRFIFV1aFlb3LoBVoSXXjXBFeAWgrmjteU2Pd6JIFTA1VOgEAgJZDSAUAnZx1tRx7V0FTDYdXISWvvKLbIICGtNTV5tIJmuzT6EYHAED7QEgFAKjHugy0O2F6YnhlD7Gssa4S/8hM1e0FgDPSuUJZc+ZtTENXhUu3YokudAAAdGyEVACAtKUKr6TIH672gdntAVY4erPmS7zioP13/uBEupobljRluT25QlZbk/ieSrzcfaqrmiVWLTV05bjE7aR6Tze0DAAA6LwIqQAALcJQ5EMl2QeLVYFlhVf2362bNY81v33Zpv5hjNbXWHjTkpdDT9TYsU7n8aaso7nb29N2NnXedK72ZZ+WGf2ZrUjw3Nj8AAAArY2QCgDQ6uwVWN4kj1uVHOGEm717oX26lDrQsm/T/rOxaYntbU/SCYBaMjRKJwxxJTyeLGRMZ13pzpc4rbnBUWdiH8PJ1dCMAAAAewkhFQDAcYlXDWyIFVzZf6b6PZwwPbF7k32dybaTGGgEFF8B1hakG7KlExo11GUr2c9k60u1fQAAAKAxhFQAgHbFqspqDjPJTQ38roTpPkkZkrKiN6l5FUnN6Qa2J5VHhEYAAABoDwipAACdRjpjETWkRpHuihmqG88HAAAAQMtgCAIAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4zuN0AwAAaG8qysudbgKwx7J37VJvSeW7dqnGvc3p5gAdEp8XANA0hFQAAKQpKytL2RleLV7wgdNNAfZYbqhC5TnH68uPvlCVe5XTzQE6rOwMr7KyspxuBgC0C4ZpmqbTjcDeVVFRocLCQpWXl6ugoMDp5gBAu1JZWana2lqnmwEAaCeysrKUl5fndDMApMDfx20LlVQAADRBXl4ef2wAAAAArYCB0wEAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4j9MNAID2qLKyUrW1tU43AwDQgKysLOXl5TndDAAAkCZCKgBoosrKSj317GOq9u9yuinAXpUbrtSomiVakj1KVS7+8Efbl5NRpP/7ycUEVQAAtBOEVADQRLW1tar279K+h5SooDDX6eYAe03ujnU64M2PlHv0Uaoq7ut0c4AGVZRX6etPtqm2tpaQCgCAdoKQCgCaqaAwV126FjjdDGCvyQpFQtmCwlxl8NpHu7DN6QYAAIAmYOB0AAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOM7jdAMAoC0wTVMyJTNsKhwOywybMk0z9lPhyDymaapqV5UCNQH5qnyqzayVTEVukX+i62t8m4YRd08ybD+sBw0jOl/kAcOIPmZNj/60pgEAAABAe0VIBaBDMU1T4WBY4VDkZoYioVPi7/Z5rMesEEqmZEb+if89uv4dO3eoprxa1TurlSGXIrFSvZakmG49pgYeTzGfYVvCHlxZk1yuSGDlMqI3l1wuK9AyZLgS57H9TsgFAAAAwGGEVADaPKuiKRwMKxQM1f2Mhk2hQChyiz4WC5vCdRVSkiJpTjR0ioQydRVLcfddkksuW2VTXRJkGIYy/Blye9zyZLjlyWj9/0bNuF9sgZlM+12ZoXCshMs0E5eO7rys/bUm11ViGS5DLrdLhjsSbtnDLsNl1JsGAAAAAC2JkAqA48ywqVAwFB82BSLhU9AfVMgfCaTs3e9MK4WJhkixkClaFeRyuSRP5L5k6z7XDiWrnor81vR9qsuuogGXaUYKxsKmFAorGAjZui4adUsZ0a1ZoVa0SsvlcUWCLZct5HJFnn/DTYUWAAAAgPQRUgFodVYXvFAgpGAgGAmi/JEAKuiL3DfDZmw8KMPevS1a4SNDMtyGXF5XZBrBR7PUBV5GXZVYI2KZVTQcNCWZoZDCQcn0WQ/WVWoZVgWa1c3Q7ZI7Fma55HIbtp/RQNHF8QQAAAA6O0IqAC3CNE2FQ+FY+BQKhBT0BRXwBRT0BSOVUGFTZijaHS3a5S7WfSwaQHkMDwFUG2MVcEWqqRo+NpFAq65KKxw2pVBQwbgwK7pe+8DvbpfcbldcZZb9J0EWAAAA0PERUgFoEtM0YwGU1RUvUBtQoDagUDBSERUO2aqhXIp0/XJFq6AyqYLqyKwugQ1VacW6HIZtlVnR6rrkVVnxQZbhiYRWLneS7oWMlQUAAAC0W4RUAJJKDKOCvqACNQEFfIHIlfHCkcooa1Bxwx0JClxelzyZVEMhtdgrw2WrzHLXn8+UIkGWzEhxVnTMsrpR4W2DwNvHynIbcnnc0UHgjbqQ1F03ADzjZKFNiLuiqHVfsT628Y9Fp1m/102sG6MvfrLiJyaR+DYw4ifV/T9u2C4kEXuwbpg8o+7B2PvR/hjvNwAAkCZCKgAKh8JxXfMCNQH5a/x1YVT0DyV7xYrX6427Oh7Q0gwpvSDLGivLjIyVFQpKqg0o7oqGRt36XEa0e6nbHV+NFRsAvu7qhvxxDUnxFxqIBUn2Czko7nUYC5vCpsLR+eLml2KVhPZNRH+rFyrFB0/x1Ybx0xJ/b/KONrJO2zQjyVZifYPjH7eCKvuVRGVdUdQwIu9ze9ican7bxTF4bwIA0DERUgGdiDWAeaA2GkbVBuSv9ivoj4wZFQ6FY920rD/YCaPQltVdcTD16zNx4PewdSVDM5QwV92g7zKiYZYVXkW7GFqVWLGx1FxUZ7V59hAzGhaFY6FR5PGwacaCJTNaJRq5kEM0SLKHS9HXkvVr/athxm08+tOID3XqXalTqitGsnVZTQh94iY7wEx6Jz5UM233rclm2JQUjp9er+Qrca9s78nYw3X348Y0THgfRh5T5POtNiBfpU/+XH+9qkoAAND2EFIBHVSsu15tpEIqUBOQr9qnUCAUCaPCkfmsQcvdXjfd9NAhpTvwe/JB38MKxo2VJSlJoGWorquh/af1x7L1R7TVJZGKkDTYunrGQiIrSLIHR+Ho/egxiwRM0aApGjpJVq6U2H3O+sV+bKX6oZK9Gs8WJBlGsgypwzKS3okvqUrniqHpiDs8VihoCwfN6PtTsh3bhMZV7axS9a4ala0qU7g8HH2/1QVcLnfkQg0uj0vuhC7Ccd2F3XXzxt63AACgVRBSAR2AvUIqUGsLpPyRQMo0TclQ7MTbm+nlW2QggVWV1dCg75bEQMtUpKthOGj/g7l+8FFXFWKrCLGHVlalRyNdoOzj/9QbD8hav2QLUBKSlHT+yLb6n8V+1HVPC4dNhYOhuNmSjq8kRQPxJF3hEiqcTDNcFzjZusLZw6W4+3E7lBBQGInH03quOme41B7FVZ1FX69NDcDcGW65PJFxEt1ed93r0zRlBiNf5NinGYYR+xnbvD3YMozIxUCShFuxEMtdd0VSwi0AAJqOkApoh8KhhECqyhfrsmeGEwIpL4EU0NKaEmhJ9qoQK8SpC3PMULgu0Ela3ZO6EfUrW+KTlwbXkBhgSdaw3CkH2g7uqpQkVW6rVFWwoq6tKcdQaqwbXHxjk1UuxYdLsgUWQMNixY7RqqmmMG0hrWkPYMOmgqFgpPeiWRemGoYRe2/HAq0k4Zbb464XbtnDLPsYeXRLBAB0RoRUQBtnmqZC/pD8Nf7IGFJV/rhBzaW6b3WpkALapvrhS/Pfp3E5VgPjAdWbP1HYtkzSxqYWqfyyZnfVf9C2Hv5HQntkGPbwtGmv4riKLev3kKlgMKhgbTA23bo6rj3osgIt63fDZcQHW54kVVsJlVyx9QAA0A4RUgFtTDgcVqAmEBvU3FdV123PKkpweVxyZ7jlcTGGFNDZxHWDaqXxgFJuOxqCW1f6BFCf0YwwOta9NRwfcNXrlihThhlZb9KqLVfdeFturzutYIuKLQBAW0JIBTgsFAwpUB2Qv9Yvf1UklLKqpAxFBjV3eVzyZngJpAAA6ICsz3fD3Yxgy9YV0R5s+Wv8deNtKUWwFR0ryxpjy+WJhltud2xavWArerVTAABaAyEVsBdZV9zz1/gVqA6otrJWgdpA3dX2qJICAABpiAVb1rmCu/Fl4oIt27haoUBIQX8wFnRZ64wFXAldEA2XEavUcntt1Vq2qi2riotB4wEATUFIBbSi2HhS1X75anzy7fYp6AvGrrhnjTXBWFIAAKC1xQVbaRZDxY2xlVCtZYbjB4+3Aq5YmBX9GfsCzuupP76W7T5hFgCAkApoQaZpKugPKlAdkK/aJ19lXSglU7GSebruAQCA9iBujK1GqrXsY2tZ4VY4FFYoGPnCzjQjVyC2xtVKrNByeVzyZHjkzohWadkHjfdGflKZBQAdGyEVsAfiKqWqo5VS/qDCwbBMmbFvCAmlAABAR9eUsbWSVWgFfUEFagORAeSjwZhpmpExsFySy4iMkeXJ8MSFWVaAZXVBpDodANovQiqgiYL+oPw1kUHOa3fX1q+UIpQCAABoULoVWvaB4cPhsMygKZ/fp5pwTWRZQ7EgKzZelsctd2ZkOIVYeBW9ubwM/A4AbRkhFdCIcDAsX7VP/upIKBWoDUQqpaInRIRSAAAArcN+JUJXioG0rAHgzXDkFvAF5K/xq9qsjixvKhZgWYO+ezI9kRDLFmC5MyJXNeScDgCcQ0gFJAiHwwpUByKhVGWt/NV+hYKRwUFjA51nE0oBAAC0Bda4VqkGg4+NjxUOR0Ks2sh5nkxrBYqrwvJkeiK3aJdCj9dDgAUAewkhFTo90zQVrA3GBjqvraxVOBBWOByWYUS773H1PQAAgHbJqsZyu5L3K7RXYYUCIQV8tnGxTEOGuy7A8mZ55c3yRsIra2wsL+NgAUBLIaRCpxQKhOSr8slX5YuMK+UPygxGTkZc7uhlkl0evi0DAADo4AwjEkQlGxvLHmAF/ZGB3a3p1nIul0ueLI8ysjJiFVhWFZbLzfhXANAUhFRo86qrq7V8+XLts88+ysnJadY6wqFw3GDn/hq/wsH4wc5dGZRwAwAAoI49wHJ741Os2GDuYVP+Sr98FT4peippuAy53C55Mjzy5njlzfRGwqtoiNWeK69a4twcAFIhpEKbt3z5co0dO1aLFi3SmDFj0lrGuoyxryq+C58ZNiWXGFcKAAAAe8RwGUm7EJqmKTMUCbD81X75qnyR8a8MxSqvvFleebOj4VV0DCy3190uzk2bc24OAOkipEKHEQqG5K/yx7rwBXyBel34KLkGAABAazIMQ4an/tUI7eFVbWWtaipqIvO7IsGV2xv5EjUjOyMWXDEuKoDOhpAK7ZZ1dRYrlPJXRa/CZ5pyuV104QMAAECbkSy8il15MBRWMBAZ86p6Z3Vk/miXQW+WVxk5GfJmRaquvFlevngF0GERUqFdCfqDkbLpStuA56FotZQn8iHOt00AAABoD+xXHnTbRm5PrLqq3V0bm9/lccmT6YkFV97MyBUHXR6CKwDtHyEV2rxQMCRJ2rFuhzZ7NyscDMeqpdxet4xMg2opAAAAdBipqq7MsBm5IFCVX7WVtZIpuVyuyCDtmR5l5EaDq+iNiisA7Q0hFdo8f5VfkuSr8skwDAY8BwAAQKdjXWnQHjyZphmruvJX+1VbZQuuPHXBVUZWtLtglkcuF8EVgLaLkAptWrU/qJ++uUv9r3tNYa+n3qV/AQCtqzYoXfBcqSTppRPXOdwaAICdYUR7FLgUO0+uV3EV7SrockcqrjKyM+IqrjyZnrS/AK72B3XmC5vU/7rXVBsMt9p+Aei8CKkAAAAAoINIWXEVDa5qKmpUXV4dm8/tcSsjJ0OZOZmR4Co7Mr4VPRcAOIGQCgAAAAA6sLjgKiMyzTQjoVU4GFb1zmpV76iOXYzIk+FRZm6mvNleZWRn0E0QwF5DSAUAAAAAnYxhRKqo7H8RWtVWgdqAfNU+GWZduJWRk6FQBn8+Amhd/C8DAAAAAJDhMuR2uZOOb1VTXqPqQMjhFgLo6AipAAAAAAD1JHYTDBFSAWhldCwGAAAAAACA4wipAAAAAAAA4DhCKgAAAAAAADiOkAoAAAAAAACOI6QCAAAAAACA4wipAAAAAAAA4DhCKgAAAAAAADiOkAoAAAAAAACOI6QCAAAAAACA4wipAAAAAAAA4DhCKgAAAAAAADiOkAoAAAAAAACOI6QCAAAAAACA4wipAAAAAAAA4DhCKgAAAAAAADiOkAoAAAAAAACOI6QCAAAAAACA4wipAAAAAAAA4DhCKgAAAAAAADiOkAoAAAAAAACOa9Mh1cyZM1VUVOR0M9Jy4YUX6vTTT3e6GQAAAAAAAO1Sk0KqsrIy/eIXv1C/fv2UmZmpHj16aOLEiZo/f35sHsMw9MorrzS5IQMGDNC9994bN+2cc87Rt99+2+R1JaqpqVFxcbFKSkrk8/n2eH0AAAAAAABoWZ6mzHzWWWfJ7/frH//4hwYNGqQtW7borbfe0vbt21ulcdnZ2crOzt7j9bz00kvad999ZZqmXnnlFZ1zzjkt0DoAAAAAAAC0lLRDql27dun999/XvHnzdMwxx0iS+vfvr0MOOSQ2z4ABAyRJZ5xxRuzx1atXa+XKlbrmmmv00UcfqaqqSiNGjNCMGTM0fvx4SdK4ceO0Zs0aXX311br66qslSaZpaubMmbrqqqu0a9eu2Db++9//6tZbb9WXX36pvLw8/eAHP9DLL7/cYNsfe+wxnXfeeTJNU4899li9kMowDP2///f/NGvWLL355pvq3bu37rrrLv3oRz+SJIVCIV166aV6++23tXnzZvXr10+XXXaZrrzyyqTbe/LJJ3X11Vdr48aNyszMjE0//fTTlZ+fr6eeekpffPGFrrrqKi1cuFCGYWjo0KF65JFHdNBBB0mSPvjgA11//fVauHChSkpKdMYZZ2jGjBnKzc2VJD344IO65557tG7dOhUWFuoHP/iBXnzxxQafh47i25Xf6r+vv6oNa1epd7+BOvWHp0lSvWnDBg+rN+/++x2gL7/6IuV9a7l0t9PY+qz73yxdoh2VlSrMzdXIfQ9odDvWY8n2e+nXX6i8qkrFeXkaPnJUyvnTed7SWS7VumY+87i++OwTBcOmxo49VBeeN6XZ62vO9pMdm5nPPK5PP/pA28vLVVRQoMMO/4Eu/OkUSQ2/Pr5ZukQbtpVp147tqqmtVdfCQh182FEa94PjUr4+Em0p26IlX32hnTu2qUtxiXr36qMNG9fH7o/a7wB179Y96bJLv1mq9+a/q+qKXcopKNLRRx6jrsVd49bX0PINrWfk8JEp509sc0Pb2FK2RR9+/KHWr12lsGmqX/9BGj50eNr72JxtNpf9eZA3QzKlkL9GIcOlrkXFGjBgULPbKqnRaU059ulutyWfo71xDPZGu+zH2ZOdq5LirvK4jHrLNnd/03lPS/VfD/Z1W+tYvfp7bd+1Q24zrPyiro2+NxvaV/v/EYnvySMOPaLevjW0/9b7eu2a7+UyDPXpNzC2Dmu5jRvXq8bnU25mpnr06pPy+Uu2rnT+j0j2f0uy/WhpLfWZuKefzU1to1T/PGTe+28n/Txuyc/9pra5ofOelt5esvMRSfWmjzu6/me6lPz8oKn729Dyqc5Fv1m6ROvLylRdWaHcrCwdMOYQXfjTpp9L7e3jvGLVitjvjz36qHZs3axFn36itStXqN/gIZo0+VyNGDEi7fUtW7ZMLzz3z2YvD6DjMUzTNNOZMRgMqkuXLpo6daruuOOOuPDFUlZWptLSUj3xxBM68cQT5Xa71a1bN33xxRf66KOPdOSRRyozM1NPPvmk/vKXv+ibb75Rv379tGPHDh1wwAG69NJLdckll0iSevToUS+kmjVrlk477TTdeOONmjx5svx+v15//XVdf/31Kdu9cuVK7bvvvtq0aZNM01Tv3r21fPly9e/fv+5JMAz16dNHf/rTn3TwwQfrb3/7mx5//HGtWbNGxcXFCgQCuv3223Xqqaeqa9eu+vDDD3XppZfqiSee0KRJkyRFxqTatWuXXnnlFdXU1Khnz576f//v/+nss8+WJG3dulW9e/fWnDlzdOyxx2q//fbT6NGjdeONN8rtdmvx4sUaNmyYDjjgAK1cuVIHHHCAbr/9dp188skqKyvT5ZdfrgMOOEBPPPGEFi5cqMMOO0xPPfWUjjjiCO3YsUPvv/++rrjiirQOekVFhQoLC1VeXq6CgoK0lnFKtT+okTe/KUn6y4FuFeZm6+6/3KZ+qtWo0mJ9sXWHllWH5Tak4dmu2LR1ytJZ55yvl55/MjbvwvWb9d6a9Rrbu6eOGdC73n1ruWuuvUmSGt1OY+t7d/UGLdqwSUf27qFenrBW7KzQ2pqABpSWandOl5TbsdowZOCQ2POwYtUK3f2X25RfvVOrt25V/+wMDe6Sry3K0OaMgnrzJ7KWb2w76VixaoX+cNv1KqrYogO65GlFRbU+31mprr0H6uabZzR5fU2VbF+WVYfl99eqe+0uDcvN0Pe7a7Rqd4265GSpKr9EGRlZGpmT/PXR01+h0rBPCzeX6dvyao0tKdDgghx9tqNKq2qDOnZgX43t0yPuOSvuUqxX5j6tg8f1UWGXPG0t26q5c19XVwXUJz9X327fqTW7KjSsa5H6FxVq3e4q7ZBXEyb8UKXdSuP2Z/m3yzX79ZfVL8urfvnZWru7Rmtq/MrNK1D/3Ez1yc9tcPmG1rO2NqCTfniG9hm2T735E9vc0Da2lm3V7NdfUXZNhfrmZmhrTUDfV9YoLJf26dal0X1szjaby/489M7N1KryKm2u8WloYa5qgiGV+QLqVlAgf3ZBk9u6NWAqbEo9M4zYtM1+Uy5D6u41mnzsnXiOmrN+X1C69MXIY/+csEiHv3+XFo37tSqL+u5xe5rbLvtx7pLp0ZfbK1SalalhPUq11R+MLSupWc9nYntW7yrXd9t3qX9RgYZ17ZL02Ceu21pHRk2Fyioq1C3Tq9LsTG2tDWi9L5jyvdnQvlrv7e+ra5Wfm69iMxB7T66t9imvqEQnn3x6bN8ael4ladasV1S1a5v65mSqNNurdVV+1WQX6NDDj9aihR8p21+l7bsrVex1q1tulirkVrk7u97zt7Vsa711fVteo+2BkIaXpP4/Itn/Lcn2o7nKd1bq03nrdfqE81RcVByb3lKfiXv62ZzOuhs6D3l39QZ9um6j9i/M1uji/LjP4wsu+nncOdCefO43tc09/RUqlT/peU9LbjvV+UhO1x5yuwz19JXHpn+6rUK1pjR+cP/YZ3qq88d025nO6yhxHvu5YWawVu+u26LhhTkaVdJFX5VXqbygu268Kf1zqZY8v0t3e3+5e4a+OfRXkqQD596grzds0mEDeuv4wf302aYyrfPk6o/3/TWtoGnZsmW64cor1C9UrdE9Spq8PNBS2tPfx51B2iGVFOk2d8kll6impkZjxozRMccco8mTJ2vUqFF1KzQMvfzyy40OIr7ffvvp5z//uS6//HJJkSqsq666SldddVVsnsSQ6ogjjtCgQYP09NNPp72DN954o5YuXRqrtjr99NN14IEHatq0aXFt/v3vf6/bbrtNklRVVaW8vDzNnj1bJ554YtL1Xn755dq8eXOseskeUknSZZddptWrV+v111+XJN1999164IEHtGLFChmGoYKCAv3tb3/TBRdcUG/dU6dOldvt1iOPPBKb9sEHH+iYY45RVVWVXn/9dV100UVav3698vPzG30OfD5f3FhcFRUV6tu3b7t4E9pDKgCAs/Y1VmlW5o062fcHfW0OdLo5AAAH3fztfZrz1TINHzhQ008+VsFQWNf89y11/cF43TL91kaXn37LzdrxwVu665Tj5HG7mrw80FIIqdqWJg2cftZZZ2njxo36z3/+oxNPPFHz5s3TmDFjNHPmzAaXq6ys1LXXXqsRI0aoqKhIeXl5WrZsmdauXdukxi5evFjHH3982vOHQiH94x//0HnnnRebdt5552nmzJkKh8Nx89qDttzcXBUUFGjr1q2xaQ888IDGjh2rbt26KS8vT3//+98bbP8ll1yiOXPmaMOGDZIigduFF14owzAkSddcc42mTp2q8ePH64477tDKlStjy37xxReaOXOm8vLyYreJEycqHA5r1apVmjBhgvr3769Bgwbp//7v//TMM8+ouro6ZVtmzJihwsLC2K1v35b79hsAAABA57NuR7kOKe2i9Tt3SZI8bpfG9OymtStXNLxg1NqVKzS6R4k8blezlgfQMTVp4HRJysrK0oQJEzRhwgTddNNNmjp1qm655RZdeOGFKZe59tprNXfuXP3lL3/RkCFDlJ2drR//+Mfy+/1N2nZTB1F/8803tWHDhnpjUIVCIb311luaMGFCbJrX642bxzCMWJD13HPP6dprr9Vdd92lww8/XPn5+frzn/+sjz/+OOW2R48erQMOOEBPPvmkTjjhBH399deaNWtW7PFp06bpJz/5iWbNmqXZs2frlltu0XPPPaczzjhDlZWV+tnPfpa0+16/fv2UkZGhzz77TPPmzdOcOXN08803a9q0afr0009VVFRUb5nrr79e11xzTey+VUnV3lxWvFZffPaRalYs0WWHHCi3y1AobOrK/85Vr+xMXTf+6Ni0Bz9ZrJV+lwZnhGPzrt+wXv/4fKn6dO+uCw4+oN59a7nsIZHAsrHtNLa+f3z6hdZv2aIzhvZVgdtQn8I8PbDke+UVFKoiFE65HasNk8/6SWzfn3vpWdWsWKICt0uVFeX65ahBWl9eKWXn6eV1ZfXmT2Qt39h20vHcS89q62cf6KcDu2lQlyKFZer+L1ZoWaVPBx55fJPX11TJ9uXK/85VV7d09oDuKvK61TcvW/d/vUYh09T2QEjbQ9J9p05I+vo4o283BXfv0lvry7S5xqcLh/WVKVPPr9yk6lBIF43ZT31694l7zn448RS989HrOuGM/dS9R7Hefvct+TZ8r9NHDJbLZeiNZd9r266dmji0n7qVdFM4bOqVZSuV2XuQjjsmPmh/7MlHVVS9S+ft019ul0uhcFhPLl2l1dV+/f74I+RyGQ0u39B6nl6+RrtyinTx+VPrzZ/Y5oa28fa7b2nXd19qfI8i9crPU1im7lv8nfI9bp2yz8BG97E522wu+/NQVlmlUCik9zfvlNswdNbgnnpx5SYZGV4pI7vJbf3noiXaVhvUr44cE5v2t/mfqSTLo3PHjmrysXfiOWrO+u3d/X4/fof0vnTrxB2qLMrd4/Y0t1324zx33RZV+fw6uKRAYU+GevfuE1tWUrOez8T2lG0r05vfrVVJURedOGJQ0mOfuG5rHfLXyPQH9OPBPbW12ifD5dIb68pSvjcb2lfrvf3nz75RcaZXp/TvHntP/vv7DVpbFdSQ/UfH9q2h51WSVnz5ufrlenTmoN5yydDG3ZX63+Zd2pmRp14eUzkul2prKnX6wF4qq66RMrP0/pbyes/f2+++VW9d//purSr9QZ00fEDK90Ky/1uS7Udzbdm8Q3Ne/krHHvZDFeTVfTPeUp+Je/rZnM66GzoP+cenX2jt5k06Y2BPHdCjW9znsadL97hzoD353G9qm8/o202qqUx63tOS2051PvLB5l0aVpitKcP7xKb/8eOlWllRrWlHj419pqc6f0y3nem8jhLnsZ8bvr1mkwyZOqVfqTK8GfKHQ3pmVZlKxxyV9vPUkud36W6v8vtl+uK4WyRJfYsLNeerjRo+MFJZGwyF9dmmMvX7wQFpra/f4CH67P3/6bxQOFZJ1ZTlAXRMTQ6pEo0cOTLWxU2KhD2hUChunvnz5+vCCy+MDaheWVmp1atXx82TkZFRb7lEo0aN0ltvvaWLLroorbY99thjmjx5sm688ca46X/4wx/02GOPxYVUDZk/f76OOOIIXXbZZbFp9sqnVKZOnap7771XGzZs0Pjx4+sFQ8OGDdOwYcN09dVX69xzz9UTTzyhM844Q2PGjNHSpUs1ZEjqvuQej0fjx4/X+PHjdcstt6ioqEhvv/22zjzzzHrzZmZmJh1DrL0ZMXCQDttvX9054yb9+8ulGt29qz7fsl0lpT0VMhQ3zZddoF9PvVjPP/NYbPrHG8u0urpW3YIBrdi8ud59a7mrzr9YkhrdTmPr8wUDWl1dq0937FZfj6nXVq7V+pqABubkyJfTJeV2rDbYB70szM3WnTNukq96p9bv3q2HP1uqYcWF2rSzJun8iazlG9tOOgpzszVtxVL95/sNGlNcrm/Lq7Vsx26V9B2snzVjfU2VbF9KSnvK76vV2+u2aHhehv6zskbfV1SrODdbgfxuKsnMSvn6eHdjmXqEa7Vl9259W16ll1eENbQgR7UBv1bXBPTuxjId6vbEPWddi7tq5ZpPVJjrVZZHGjtqP72x4XvNWrZc/QpyVV67WxtqqvTBxs0aVFOjtRVVqpBXJ47aT1kJ/+see+QReu0//9Jzy79T//wcrdldrY21fnUpLIytr6HlG1rPhpqATpnww6TLJLa5oW2MHbWf/rt6uf63fqP65WZqS41fNcFaVQVdae1jc7bZXPbnoU9ulr4vr9Smap+GFeXqmW9WamttQKWFhfIru8ltrfZ6leXxxk3LystWtaFmHXsnnqM9XX+Gu+5nSx2z5rTLfpyLM736bme5ymurtE/P7lq8bHlsWUnN2t/E9ny/s1wbaqrkzfLoi3Vrkx77xHVb68gIBbS1slzPfFOt7tmZ2lIb0IbaYMr3ZkP7ar23/aZfVZ6suPfkmiqf8rp001jbvjX0vErS+lXL9f3OMv3rmxp1z87Q2iqfqrMLdeyRR+jTj+crULtb2yp367nlVSrNzVa53Kpw13/vjB21X7117ait1jZ/qMH3QrL/W5LtR3MV5nrVr2eJDhwxUl27dLVNb5nPxD39bE5n3Q2dh/iCAa2uinz2lddUx30eX3zJr+LOgfbkc7+pbX53Y5l6yp/0vKclt53qfKRvz14KuIy46WsqditgKu4zPdX5Y7rtTOd1lDiP/dywNMujt9duVsBfq9HdumjJriqFCns06VyqJc/v0t3ejDvruuH9Z80WfV3hk2dXhWZ+vDg2ptQvJp+b1vomTT5XNyxYoGv++5bG9OzW5OUBdExpj0m1fft2nX322ZoyZYpGjRql/Px8LVy4UL/61a908skn67HHHpMUCV7Gjx+vm2++WZmZmerSpYvOPPNMrVq1Sk888YQMw9BNN92kefPmacqUKbr33nslSSeccIKys7P14IMPKjMzUyUlJfXGpJo3b56OP/54/f73v9fkyZMVDAb1+uuv67rrrqvX3rKyMvXu3TvWNdFu9uzZOuOMM7Rx40YVFxcnHUerqKhI9957ry688EL99a9/1U033aQXXnhBAwcO1FNPPaW//vWvGjhwoBYvXiyp/phUklReXq5evXopGAzqySefjFV01dTU6De/+Y1+/OMfa+DAgVq/fr0uuOACnXXWWbrzzju1ZMkSHXbYYZoyZYqmTp2q3NxcLV26VHPnztX999+v1157Td9//72OPvpodenSRa+//rouv/xyLVmyRPvuu2+jx7I99bm1j0n1t7EeHTzqAK7ux9X9HL+63/ad2/XSGzN16PF9VdQlMi4cV/fj6n4d9ep+tUHpgucilVQvnbhIY+fdpS+P/7Wqu7RsRS5X90uNq/s1z66du/XxW+t01okXxoVUElf3ay1c3a/jX93vy2+/0SXzKyVJx+/4r8740Slc3Q/tXnv6+7gzSDuk8vl8mjZtmubMmaOVK1cqEAiob9++Ovvss3XDDTfEuuL997//1TXXXKPVq1erd+/eWr16tVavXq0pU6boo48+UklJia677jr961//0oEHHhgLqT766CP97Gc/0zfffCOfzyfTNOuFVJL073//W7fddpuWLl2qgoICHX300XrppZfqtfeuu+7S7bffrq1bt9bryuf3+9W9e3dNnz5dV1xxRaMhlc/n089//nO9/PLLMgxD5557rgoLCzV79uwGQypJOv/88zVr1ixt3LgxVs3k9/t1wQUXaP78+dqyZYtKSkp05pln6s9//rOysrIkSZ9++qluvPFGLViwQKZpavDgwTrnnHN0ww036IMPPtDvf/97LVmyRLW1tRo6dKhuvPHG2JUGG9Oe3oTJQirAaclCKqCj2lshFdDSGgqpADRPTSCkY59eLEl69szuOuKQg5xtENAC2tPfx51Bk67uh6Y7/vjjte++++qvf/2r002JaU9vQkIqtEWEVOhMCKnQXhFSAS2PkAodUXv6+7gzaMERJWC3c+dOzZs3T/PmzdODDz7odHMAAAAAAADaNEKqVjJ69Gjt3LlTd955p4YPH+50cwAAAAAAANo0QqpWknj1QgAAAAAAAKTmcroBAAAAAAAAACEVAAAAAAAAHEdIBQAAAAAAAMcRUgEAAAAAAMBxhFQAAAAAAABwHCEVAAAAAAAAHEdIBQAAAAAAAMcRUgEAAAAAAMBxhFQAAAAAAABwHCEVAAAAAAAAHEdIBQAAAAAAAMcRUgEAAAAAAMBxhFQAAAAAAABwHCEVAAAAAAAAHEdIBQAAAAAAAMcRUgEAAAAAAMBxhFQAAAAAAABwHCEVAAAAAAAAHOdxugEAAAAAgLbJNE2ZYVPhUFh+X9Dp5gDo4AipAAAAAACSIqFUOBhWOBSWGTJlypTL5ZLL41JWbqbTzQPQwRFSAQAAAEAnFKuSskIp05RhGHK5XfJkepSZm6mM7Ax5s73yZnlVGwo73WQAHRwhFQAAAAB0cPZue+FQWDIj01zuSJVUTn6OMnIy5M3yypvtldvrlmEY8SshpALQygip0KblZHj0zMQiHXXcUcp86U2nmwMAnU6WR3r+vK2SpIydDjcGAJA2eyAV123P7VJmbqYyczNjgZQ30yvDZTS6zpwMj/49qafGjh2rrEmL9sJeAOhsCKnQboQCIZlhM60PUAAAAKCzsAdS4XCkSspwRbrtebO8dYFU9ObycJF3AG0TIRXaPG+mV5JkyFCgNhBXluxyu+qXIQMAAAAdVMpAyhUdRyonMzaGlBVIcb4MoL0gpEKb58mKvEy7DuyqboO6qbaqVrUVtQr6ggr6gpIhuT1uuT1uqqwAAADQIVhjSFmhlBkyJUOSobqBzW2BlCfTk3wcKQBoRwip0G64PW5lF2YruzBbZk9TgdqA/FV+1VbWylfpU8AXkMLRb5I8Lr41AgAAQLtgmqbMkKlwODqoeXR8cnuXvYzc6KDmmVRIAei4CKnQLhmGoYzsDGVkZyivJE/hUFj+Kr981T7VVtRGAqxqvwzZAiuXwQc5AAAAHJNYHRUOhWPnp9YXrVk5WcrIzohVR3kzGUMKQOdBSIUOweV2KasgS1kFWSroXqCQPyRflU++Sp9qK2sV8ocUDkdOAlweF10DAQAA0GpM04yrjjJDkfuS5HK5ZLgNeTO9ysjJkCcrEkR5Mj3yZHg4RwXQqRFSoc3bZ599tGjRIu2zzz5pzW8YRuRDPtOj3OJcmWFT/hp/pGvg7lr5q/0MwA4AAIA9FlcZZQujDCNSwW+4DHm8HnnzvfJme+XJ8MTOU9vr+WdTz80BoCkIqdDm5eTkaMyYMc1e3nAZyszNVGZupvJL8xUKhOSv9stX5VPt7sgA7H4fXQMBAACQXFwQFe2qF+umZxgy3LYwKquuKsqT6elwY0ft6bk5ADSEkAqdjttrG4DdNCMhVbW/rmtgIBQ78aBrIAAAQOcQ1z0vGkrJlEyZsSDK5XLJk+1RRlZGLIhyZ7jlyeh4YRQAOIGQCp2aYRiRq6RkeeO7BkZDK19V5KqBZtiU4TLk9rgjpdmEVgAAAO1KbJyocMLNNCVDMmTErqbnznTHrqTnznDL442EUe4Mt1wuBjEHgNZCSAXYxHUN7JYfuWpgdSS0qt1dK3+NbTwrl6uueyDfmgEAADiqoRDKUN0V9KybJ8sT65rn9rrl9kYqotzeyJeSAIC9j5AKaIDL7VJWfpay8qNXDbTGs6qOjmdVG1SgJiCZipSAuwmtAAAAWpppRrveJYZQ0SvmxV05LxpCuTPddWNDZXjk9rhjYZTby3AOANAWEVIBTRA3nlUPM24Qdl+lT0FfUIHqgExx5UAAAIB0xIIn0zYOlBVAmdGZjMjNumKey+2SO9sdC6BcXlddCOVxy+V10S0PANohQiqgmQzDiJ0Y5RTlyDRNhfx1lVax0MofiMzvotIKAAB0DnGVT7YQSuG6aVJkHCh7+BQLoKLjP3m8ntiFbFweV6QrHl8CAkCHRUgFtBDDMCIl5Zke5XRpILSKVloxEDsAAGhP6nW5M+ODp7iqJ1OSKxo+RQOoxO52sfAp+iWeFUQZLoMACgA6KUIqoJUkDa2i3QMDNQHVVtYqUBuIDcRuGEbdN4OcnAEAgFYWC5kSutfZQ6jY+Ug0gDJc8ZVP9gqnWFc725AHcT/pfgcAaAQhFbCX2LsHqkgqVGEktKqJhFa+Kp/81X6F/CGFw2HJiAzcbt0IrQAAQCqJ3evswVOsysmUTCOaNpl1VU5x3e3cRmxMJ7fXLbc7IXRK+J1qcABASyKkAhzk9rqV7c1WdkG2JCkcCkeqq2oCsQHZg4GgQv5Q5NvMhHGtCK4AAOhY4q5Wl6zCKSFwMmQ7FzBs3esMIy5Usqqc7Fcjtn8ZRugEAGgLCKmANsTldikzN1OZuZmSIiejQV9QgZpIt0BflU+B2oBCvlDk6jcGA7IDqGM2OMFMMVMDjPhfTNsqzMRZANSTtLopWRc7RcIlmYqMW5mswskVHRYgOnZTXOBkBUyJ9xk+AADQzhBSAW2YYRjyZnnlzfLGpoWD4dhYVtag7CF/SIGaQGwe+4kqJ6dA22Na/1gVE4r+wVpvumyhUrJYyLTdT/K4UX+JPWlzOBSWJIUDYYX8oYRt2ttib1tCu4zE7MuImxb7PyvJY4BT7AFTQ6FTrLrJjAa70QulJIZO1jhOLrcr7vdUQROBEwCgsyCkAtoZl8elzLxMZebVVVuFAqG44Mpf7VcoGIpUXEW/kSW4AlpeLD8K13XPiQRL1h+v9rnsQY4pGbZOOkZdGGO4DMkV7dLrkgzDFf1p/ZFryLACHFd0GcNQLNAxbOus/2uT3v+mrXTKlJRt5EiScrvkyFWSF9m/6D7WdVGK/GMtKtNU2FY1orirglnz1i1rmuH4oq+4kC55QBe3z4Y93zLqT0enFfd6TlXZlCRsir6r696D9ivWRT9XY4OHJ1Q3GW5DLper3n261AEAkBwhFdDO2Qdkt8a2inUT9AUUrA3KXxMJrsLBsAL+uoqrWFdBtyv27S7Q2dmDJ1NmXRATC14S+8tFQ6NIWhT54XZH31+GDJdLrmhXHbkMuYzITyMaNhkuV+Rn7A/gtvs+9GREThs8mR55szNaZqX2oECKPO9mQogVli3sikw3w+G6K5CFzLirkUmSGY4GXrKHXckqz6S4iq3ocbR+jYVdRl3K1XaPUMcWdxzNBioQo4c26A8qFAwpUB2QL9MXqW6yPusSfsZdkc4Km2yfkQ39DgAAWg4hFdABxXUTLIxMM01TQX9QwdpIeGUNzh4KhBQIBqRw5ITf5bJ90+umawE6jrjwyR6ISNG/au3hhRU82YKkWHVENHhyG3VVTq7INMMWQiFNsSqnaN2Tew/XlyTkCiep4LKqusLh6PRwOPp4JACT7FVh9vAjsaLLmibZU6zEKrnYo/YKr4THbWtot+oNg2aatrtmbIbEwElxszbQtTXJc2uvQHRFq5sMl0tZwWxl5mWpqFeRunbrWvf5Zg+a+KwDAKBNIaQCOgnDMOTN9Mqb6VW26iquQoGQgr5grPLKX+NXsDby7bPpMyUjMh/jYqAts1dSxHcjsx5I6PpmhU9et9xulwx7hYTLiNx31Q1WbLhcDuwVmsVl1AVeUU3Oveyvo4TQyzRN2zTbvGHbz3D95aXo6zQsmQrHpTmpw5lkgZh9ekI1WGOSFZGllLjuxtpiX6bx8cfiu7YqbnDw2O+27q3WtLr7kYBYRjQYtlXAWfxmSJl5mcoryVNe17x0dhoAADiMkAroxOxdBZVfNz0cDseCK6v6yl/jV8gfUigQvbKgEsIrvo1GK2k4gLIetFVYxIImt9weK3xKqICKvmapeEJS1nhD0p5XdknJX7uxbol11XyJY3yl6sZWd982j5LMJ/uDqp+BJdypN55ZLPsx4qYnGwPMPk8sCLbWYR9LzRY6JYZKAAAAhFQA6nG5XMrIzlBGwpgz4VC4LrjyR6uvagKRcT9CIZl+M+6PoLjKK6qvkETdH+fJ/4C3KjjsY8e4XC65PIZc0TFk7AMRu2wVUPwBjDbDHnoBAAAgJUIqAGlzuV3KyMlQRk5CeBWOXI4+6A9Gfgbqxr4KB8J11VcJAVbczSDE6kjqVT9J0W5P1gN13YfiqivcbrncdQFU3MDj1n0qMAAAAIAOiZAKwB5zuVxyZbkiA7XbmGbkqlvBQFChQCjWXTDgCyjoi0wzQ6bCgbDC0YGKDavbln1cktjYJCLIcljK8EmyDT5ev/udYUgub+QS7YlXyIrrLsrYTwAAAECnRUgFoNUYhiHDYyjDk6HoWO1xzLCpUDASXFm3cDAc604Y8ocUDocVDoSjgxVLpmHKMA2ZMusNsBsLslxGbPtoWFzoZF3OPXbfPoPFqCticjU0+LjVDa9uEHKqnwAAAAA0hJAKgGMMl23g9iRM01Q4FAmpQsFIgBUKhhQOheuCLX8oMh5W2IxUY4UVuxKXNQKMaZh1FVoJFVlx4Zb9UvHtIFCJGzc8dvUws+6K7vUGXE46anJdxVO0y53LZQ0w7orrYherfDIiwZN1JTzCJwAAAAAtgZAKQJtlGIbcHrfcHre88qacLxZmBcORn9GbGTLr7tsCrnAw2r3QjFRzha3LwZt1AVekAZFphmHEerCZMuWv8isUDCnoj9xi86rer42qd+X5+o+kWKN9gC/7Zd5tV9uKXt7dZRixrnT2QcWT/W6/7DsAAAAA7E2EVADaPXuYlS7TNCOXfo9WYFm/x1VkhU2FzfjqLDNsKuAJKCMnQ5m5mcrMzYi/nLxVxmQmyZ3i2mz9UjcOl30Q8bjLuluXbpchuZJMN+oqmmL3jdgKmvZkAgAAAIBDCKkAdEpGtLpIbsmt9MMtSQpmBJVVkK2cLjnK7ZrXSi0EAAAAgM6FyygBAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVIBAAAAAADAcYRUAAAAAAAAcBwhFQAAAAAAABxHSAUAAAAAAADHEVIBAAAAAADAcR6nGwAA7VVFeZXTTQD2qtzoa76ivEpV7gqHWwM0jP+jAQBofwipAKCJsrKylJNRpK8/2SZpm9PNAfaa3HClqrIP05JPK1TlWuN0c4BG5WQUKSsry+lmAACANBFSAUAT5eXl6f9+crFqa2udbgrgiGFONwBIU1ZWlvLy8pxuBgAASBMhFQA0Q15eHn/4AAAAAEALYuB0AAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjCKkAAAAAAADgOEIqAAAAAAAAOI6QCgAAAAAAAI4jpAIAAAAAAIDjPE43AHufaZqSpIqKCodbAgAAAACAc6y/i62/k+EsQqpOaPfu3ZKkvn37OtwSAAAAAACct3v3bhUWFjrdjE7PMIkLO51wOKyNGzcqPz9fhmE43Zw4FRUV6tu3r9atW6eCggKnm4O9gGPe+XDMOx+OeefDMe98OOadC8e78+nIx9w0Te3evVu9evWSy8WISE6jkqoTcrlc6tOnj9PNaFBBQUGH+88PDeOYdz4c886HY975cMw7H45558Lx7nw66jGngqrtICYEAAAAAACA4wipAAAAAAAA4DhCKrQpmZmZuuWWW5SZmel0U7CXcMw7H45558Mx73w45p0Px7xz4Xh3Phxz7C0MnA4AAAAAAADHUUkFAAAAAAAAxxFSAQAAAAAAwHGEVAAAAAAAAHAcIRX2ugceeEADBgxQVlaWDj30UH3yyScp5505c6YMw4i7ZWVl7cXWYk+89957OvXUU9WrVy8ZhqFXXnml0WXmzZunMWPGKDMzU0OGDNHMmTNbvZ1oOU095vPmzav3HjcMQ5s3b947DcYemzFjhg4++GDl5+ertLRUp59+ur755ptGl/vXv/6lffbZR1lZWdp///31+uuv74XWoiU055jzed6+PfTQQxo1apQKCgpUUFCgww8/XLNnz25wGd7j7VtTjznv8Y7ljjvukGEYuuqqqxqcj/c5WgMhFfaq559/Xtdcc41uueUWffbZZzrggAM0ceJEbd26NeUyBQUF2rRpU+y2Zs2avdhi7ImqqiodcMABeuCBB9Kaf9WqVTr55JN17LHHavHixbrqqqs0depUvfnmm63cUrSUph5zyzfffBP3Pi8tLW2lFqKlvfvuu/rlL3+pjz76SHPnzlUgENAJJ5ygqqqqlMt8+OGHOvfcc3XxxRfr888/1+mnn67TTz9dX3311V5sOZqrOcdc4vO8PevTp4/uuOMOLVq0SAsXLtRxxx2n0047TV9//XXS+XmPt39NPeYS7/GO4tNPP9UjjzyiUaNGNTgf73O0GhPYiw455BDzl7/8Zex+KBQye/XqZc6YMSPp/E888YRZWFi4l1qH1iTJfPnllxuc57e//a257777xk0755xzzIkTJ7Ziy9Ba0jnm77zzjinJ3Llz515pE1rf1q1bTUnmu+++m3KeSZMmmSeffHLctEMPPdT82c9+1trNQytI55jzed7xdOnSxXz00UeTPsZ7vGNq6JjzHu8Ydu/ebQ4dOtScO3euecwxx5hXXnllynl5n6O1UEmFvcbv92vRokUaP358bJrL5dL48eO1YMGClMtVVlaqf//+6tu3b6Pf4KB9W7BgQdzrQ5ImTpzY4OsDHcOBBx6onj17asKECZo/f77TzcEeKC8vlyQVFxennIf3eseSzjGX+DzvKEKhkJ577jlVVVXp8MMPTzoP7/GOJZ1jLvEe7wh++ctf6uSTT673/k2G9zlaCyEV9ppt27YpFAqpe/fucdO7d++ecvyZ4cOH6/HHH9err76qp59+WuFwWEcccYTWr1+/N5qMvWzz5s1JXx8VFRWqqalxqFVoTT179tTDDz+sl156SS+99JL69u2rcePG6bPPPnO6aWiGcDisq666SkceeaT222+/lPOleq8zFln7k+4x5/O8/fvyyy+Vl5enzMxM/fznP9fLL7+skSNHJp2X93jH0JRjznu8/Xvuuef02WefacaMGWnNz/scrcXjdAOAhhx++OFx39gcccQRGjFihB555BHddtttDrYMQEsYPny4hg8fHrt/xBFHaOXKlbrnnnv01FNPOdgyNMcvf/lLffXVV/rggw+cbgr2knSPOZ/n7d/w4cO1ePFilZeX68UXX9QFF1ygd999N2VogfavKcec93j7tm7dOl155ZWaO3cuA97DcYRU2GtKSkrkdru1ZcuWuOlbtmxRjx490lqH1+vV6NGjtWLFitZoIhzWo0ePpK+PgoICZWdnO9Qq7G2HHHIIIUc7dPnll+u1117Te++9pz59+jQ4b6r3erqfBWgbmnLME/F53v5kZGRoyJAhkqSxY8fq008/1X333adHHnmk3ry8xzuGphzzRLzH25dFixZp69atGjNmTGxaKBTSe++9p/vvv18+n09utztuGd7naC1098Nek5GRobFjx+qtt96KTQuHw3rrrbca7N9uFwqF9OWXX6pnz56t1Uw46PDDD497fUjS3Llz0359oGNYvHgx7/F2xDRNXX755Xr55Zf19ttva+DAgY0uw3u9fWvOMU/E53n7Fw6H5fP5kj7Ge7xjauiYJ+I93r4cf/zx+vLLL7V48eLY7aCDDtJPf/pTLV68uF5AJfE+R+uhkgp71TXXXKMLLrhABx10kA455BDde++9qqqq0kUXXSRJOv/889W7d+9YX+hbb71Vhx12mIYMGaJdu3bpz3/+s9asWaOpU6c6uRtIU2VlZdw3aKtWrdLixYtVXFysfv366frrr9eGDRv05JNPSpJ+/vOf6/7779dvf/tbTZkyRW+//bZeeOEFzZo1y6ldQBM19Zjfe++9GjhwoPbdd1/V1tbq0Ucf1dtvv605c+Y4tQtool/+8pd69tln9eqrryo/Pz82FkVhYWGsAjLx//Yrr7xSxxxzjO666y6dfPLJeu6557Rw4UL9/e9/d2w/kL7mHHM+z9u366+/XieddJL69eun3bt369lnn9W8efP05ptvSuI93hE19ZjzHm/f8vPz640rmJubq65du8am8z7H3kJIhb3qnHPOUVlZmW6++WZt3rxZBx54oN54443YoHtr166Vy1VX4Ldz505dcskl2rx5s7p06aKxY8fqww8/ZPyDdmLhwoU69thjY/evueYaSdIFF1ygmTNnatOmTVq7dm3s8YEDB2rWrFm6+uqrdd9996lPnz569NFHNXHixL3edjRPU4+53+/Xr3/9a23YsEE5OTkaNWqU/ve//8WtA23bQw89JEkaN25c3PQnnnhCF154oaT6/7cfccQRevbZZ/X73/9eN9xwg4YOHapXXnmlwYG30XY055jzed6+bd26Veeff742bdqkwsJCjRo1Sm+++aYmTJggifd4R9TUY857vOPjfY69xTBN03S6EQAAAAAAAOjcGJMKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAAAAAAAjiOkAgAAAAAAgOMIqQAAAAAAAOA4QioAAAAAAAA4jpAKAAB0SOPGjdNVV13ldDP02GOP6YQTTnC6GXtk9erVMgxDixcvbnTebdu2qbS0VOvXr2/9hgEAgA6FkAoAALQpp556qk488cSkj73//vsyDENLlizZy61qntraWt1000265ZZbnG7KXlNSUqLzzz+/U+0zAABoGYRUAACgTbn44os1d+7cpJU4TzzxhA466CCNGjXKgZY13YsvvqiCggIdeeSRTjdlr7rooov0zDPPaMeOHU43BQAAtCOEVAAAoE055ZRT1K1bN82cOTNuemVlpf71r3/p4osv1vbt23Xuueeqd+/eysnJ0f77769//vOfDa7XMAy98sorcdOKioritrNu3TpNmjRJRUVFKi4u1mmnnabVq1fHHp83b54OOeQQ5ebmqqioSEceeaTWrFmTcpvPPfecTj311Lhpja3j1Vdf1ZgxY5SVlaVBgwZp+vTpCgaDscd37dqln/3sZ+revbuysrK033776bXXXos9/tJLL2nfffdVZmamBgwYoLvuuitu+wMGDNAf//hHTZkyRfn5+erXr5/+/ve/x83zySefaPTo0crKytJBBx2kzz//PO7xnTt36qc//am6deum7OxsDR06VE888UTs8X333Ve9evXSyy+/nPK5AQAASERIBQAA2hSPx6Pzzz9fM2fOlGmasen/+te/FAqFdO6556q2tlZjx47VrFmz9NVXX+nSSy/V//3f/+mTTz5p9nYDgYAmTpyo/Px8vf/++5o/f77y8vJ04oknyu/3KxgM6vTTT9cxxxyjJUuWaMGCBbr00ktlGEbKdX7wwQc66KCDYvcbW8f777+v888/X1deeaWWLl2qRx55RDNnztQf/vAHSVI4HNZJJ52k+fPn6+mnn9bSpUt1xx13yO12S5IWLVqkSZMmafLkyfryyy81bdo03XTTTfUCv7vuuisWPl122WX6xS9+oW+++UZSJAw85ZRTNHLkSC1atEjTpk3TtddeG7f8TTfdpKVLl2r27NlatmyZHnroIZWUlMTNc8ghh+j9999v3sEAAACdkwkAANDGLFu2zJRkvvPOO7FpP/jBD8zzzjsv5TInn3yy+etf/zp2/5hjjjGvvPLK2H1J5ssvvxy3TGFhofnEE0+YpmmaTz31lDl8+HAzHA7HHvf5fGZ2drb55ptvmtu3bzclmfPmzUtrH3bu3GlKMt97773YtMbWcfzxx5t//OMf46Y99dRTZs+ePU3TNM0333zTdLlc5jfffJN0+Z/85CfmhAkT4qb95je/MUeOHBm7379//7jnMRwOm6WlpeZDDz1kmqZpPvLII2bXrl3Nmpqa2DwPPfSQKcn8/PPPTdM0zVNPPdW86KKLGtz/q6++2hw3blyD8wAAANhRSQUAANqcffbZR0cccYQef/xxSdKKFSv0/vvv6+KLL5YkhUIh3Xbbbdp///1VXFysvLw8vfnmm1q7dm2zt/nFF19oxYoVys/PV15envLy8lRcXKza2lqtXLlSxcXFuvDCCzVx4kSdeuqpuu+++7Rp06aU66upqZEkZWVlxaY1to4vvvhCt956a2z7eXl5uuSSS7Rp0yZVV1dr8eLF6tOnj4YNG5Z0m8uWLas3/tWRRx6p7777TqFQKDbNPqaXYRjq0aOHtm7dGlvHqFGj4tp9+OGHx63zF7/4hZ577jkdeOCB+u1vf6sPP/ywXluys7NVXV2d8vkBAABIREgFAADapIsvvlgvvfSSdu/erSeeeEKDBw/WMcccI0n685//rPvuu0/XXXed3nnnHS1evFgTJ06U3+9PuT7DMOK6D0qRLn6WyspKjR07VosXL467ffvtt/rJT34iKTJw+4IFC3TEEUfo+eef17Bhw/TRRx8l3V7Xrl1lGIZ27twZN72hdVRWVmr69Olx2//yyy/13XffKSsrS9nZ2U1/IpPwer1x9w3DUDgcTnv5k046SWvWrNHVV1+tjRs36vjjj6/XJXDHjh3q1q1bi7QXAAB0DoRUAACgTZo0aZJcLpeeffZZPfnkk5oyZUps7Kb58+frtNNO03nnnacDDjhAgwYN0rffftvg+rp16xZXtfTdd9/FVfqMGTNG3333nUpLSzVkyJC4W2FhYWy+0aNH6/rrr9eHH36o/fbbT88++2zS7WVkZGjkyJFaunRpvcdSrWPMmDH65ptv6m1/yJAhcrlcGjVqlNavX59yX0eMGKH58+fHTZs/f76GDRsWG7eqMSNGjNCSJUtUW1sbm5YsiOvWrZsuuOACPf3007r33nvrDb7+1VdfafTo0WltEwAAQCKkAgAAbVReXp7OOeccXX/99dq0aZMuvPDC2GNDhw7V3Llz9eGHH2rZsmX62c9+pi1btjS4vuOOO07333+/Pv/8cy1cuFA///nP4yqKfvrTn6qkpESnnXaa3n//fa1atUrz5s3TFVf8/3bu2CW1MIzj+E+EhoM0R5BtgRFCBwQXramzhtKgq1iD4FIEh+RANUVFi/+AToegQRINoyWCpqYwowIJGoNoibbudsB7udZwb++98P1s57yH53k444+Ht6ynpyf1+325rqvLy0s9Pj6q0+no/v5esVjstz0dx9HFxUXw/FkNz/NUr9e1ubmpbrerXq8n3/dVqVQkSXNzc0qn08pmszo9PVW/31e73dbJyYkkaXV1VWdnZ9re3tbd3Z1qtZqq1eovW07D5PN5hUIhFYtF3dzcqNVqaW9vb+Abz/PUaDT08PCgbrerZrM58B/e3t50dXWlhYWFL/cFAAAgpAIAAP+sQqGgl5cXOY6j8fHx4H2lUpFt23IcR/Pz8xobG9Pi4uLQWvv7+5qYmFAqlVI+n9fa2posywrOLcvS+fm5otGoMpmMYrGYCoWC3t/fNTo6KsuydHt7q2w2q6mpKS0vL6tUKmllZWXo/K1WS6+vr0GPYTUcx1Gz2VSn01EikVAymdTBwYEmJyeDmkdHR0okEsrlcpqentb6+npw35Rt2zo8PJTv+5qZmZHnedra2hoI+D4TiUR0fHys6+trzc7OamNjQzs7OwPfjIyMyHVdxeNxpdNphcNh+b4fnDcaDUWjUaVSqS/3BQAACH38fDkDAAAA/pilpSXZti3XdU2P8m2SyaTK5XJwlxcAAMBXsEkFAADwF+3u7ioSiZge49s8Pz8rk8kol8uZHgUAAPxn2KQCAAAAAACAcWxSAQAAAAAAwDhCKgAAAAAAABhHSAUAAAAAAADjCKkAAAAAAABgHCEVAAAAAAAAjCOkAgAAAAAAgHGEVAAAAAAAADCOkAoAAAAAAADGEVIBAAAAAADAOEIqAAAAAAAAGPcD0Nse4FG9+dgAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Exemplo de classe que utiliza a função plot_by_variable\n",
    "class Plotter:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def plot_by_variable(self, leg1, leg2, leg_x, time_list1, time_list2):\n",
    "        # Define o tamanho da figura\n",
    "        fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "        # Dados\n",
    "        data_x = [time_list1, time_list2]\n",
    "\n",
    "        # Cores para os gráficos\n",
    "        boxplots_colors = ['yellowgreen', 'lightblue']\n",
    "        violin_colors = ['thistle', 'lightcyan']\n",
    "        scatter_colors = ['tomato', 'darksalmon']\n",
    "\n",
    "        # Boxplot\n",
    "        bp = ax.boxplot(data_x, patch_artist=True, vert=False, positions=[1, 2], widths=0.6)\n",
    "        for patch, color in zip(bp['boxes'], boxplots_colors):\n",
    "            patch.set_facecolor(color)\n",
    "            patch.set_alpha(0.4)\n",
    "\n",
    "        # Violinplot\n",
    "        vp = ax.violinplot(data_x, points=500, showmeans=True, showextrema=True, showmedians=False, vert=False)\n",
    "        for idx, b in enumerate(vp['bodies']):\n",
    "            b.set_color(violin_colors[idx])\n",
    "            b.set_alpha(0.6)\n",
    "\n",
    "        # Scatterplot\n",
    "        for idx, features in enumerate(data_x):\n",
    "            y = np.full(len(features), idx + 1)\n",
    "            jitter = np.random.uniform(low=-0.1, high=0.1, size=len(features))\n",
    "            ax.scatter(features + jitter, y, s=15, c=scatter_colors[idx], alpha=0.7, edgecolor='k')\n",
    "\n",
    "        # Configurações do gráfico\n",
    "        ax.set_yticks([1, 2])\n",
    "        ax.grid(False)\n",
    "        ax.set_yticklabels([leg1, leg2])\n",
    "        ax.set_xlabel(leg_x)\n",
    "        ax.set_title(\"Results by time (s)\")\n",
    "        ax.legend(loc='upper right', bbox_to_anchor=(1.1, 1))\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(\"rain_cloud_time_sdg_sam.jpg\", dpi=300)\n",
    "        plt.show()\n",
    "\n",
    "       \n",
    "# Criar uma instância da classe Plotter\n",
    "plotter = Plotter()\n",
    "\n",
    "# Gerar duas listas de tempos de exemplo (em segundos)\n",
    "random.seed(42)  # Para reprodutibilidade\n",
    "time_list1 = [random.uniform(0.5, 3.5) for _ in range(100)]\n",
    "time_list2 = [random.uniform(1.0, 4.0) for _ in range(100)]\n",
    "\n",
    "# Nome da variável a ser plotada\n",
    "variable = \"Execution Time\"\n",
    "\n",
    "# Chamar a função para plotar o gráfico\n",
    "plotter.plot_by_variable(\"Static Analyses\", \"SDG\", \"Values (seconds)\", time_list1, time_list2)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}