tcga_weight_miRNA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 变量设置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置数据集名称，对应 https://xenabrowser.net/datapages/ 中缩写\n",
    "dataset_name = ['LUAD', 'LUSC']\n",
    "# 设置俩： ['LUAD', 'LUSC']\n",
    "# 单一个： ['LUAD'] \n",
    "method = 'normal' # diff是上面俩数据集的差异，normal是和正常样本的差异\n",
    "# method = 'diff'\n",
    "loglevel = ''\n",
    "# loglevel = 'debug'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据导入"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import os\n",
    "import gzip\n",
    "import shutil\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import defaultdict\n",
    "import seaborn as sns\n",
    "from sklearn import datasets\n",
    "import warnings\n",
    "import GEOparse\n",
    "from typing import Tuple, List\n",
    "from sklearn.metrics import  roc_curve, auc, precision_recall_curve, confusion_matrix, classification_report, accuracy_score, roc_auc_score, f1_score, precision_score, recall_score, confusion_matrix,fbeta_score\n",
    "from imblearn.over_sampling import SMOTE, SMOTEN\n",
    "sm = SMOTEN(random_state=42)\n",
    "from multiprocessing import Pool, cpu_count\n",
    "import ast\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.feature_selection import chi2\n",
    "from sklearn.feature_selection import f_classif\n",
    "from sklearn.feature_selection import mutual_info_classif\n",
    "from sklearn.linear_model import LinearRegression, RidgeClassifier, Lasso, LassoCV, LogisticRegression, LogisticRegressionCV, ElasticNet,ElasticNetCV,SGDClassifier,RidgeClassifierCV\n",
    "from sklearn.svm import SVC, LinearSVC, NuSVC\n",
    "from IPython.display import display, HTML\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def download_and_parse_data(dataset_name):\n",
    "    pkl_file_path = './datasets/' + 'TCGA-' + dataset_name + '.mirna_transposed.pkl'\n",
    "    if os.path.exists(pkl_file_path):\n",
    "        df_t = pd.read_pickle(pkl_file_path)\n",
    "    else:\n",
    "        url = \"https://gdc-hub.s3.us-east-1.amazonaws.com/download/TCGA-\" + dataset_name + \".mirna.tsv.gz\"\n",
    "        response = requests.get(url)\n",
    "        os.makedirs('./datasets', exist_ok=True)\n",
    "        gz_file_path = './datasets/' + 'TCGA-' + dataset_name + '.mirna.tsv.gz'\n",
    "        with open(gz_file_path, 'wb') as f_out:\n",
    "            f_out.write(response.content)\n",
    "        tsv_file_path = './datasets/' + 'TCGA-' + dataset_name + '.mirna.tsv'\n",
    "        with gzip.open(gz_file_path, 'rb') as f_in:\n",
    "            with open(tsv_file_path, 'wb') as f_out:\n",
    "                shutil.copyfileobj(f_in, f_out)\n",
    "                \n",
    "        df = pd.read_csv(tsv_file_path, sep='\\t')\n",
    "        df_t = df.transpose()\n",
    "        df_t.columns = df_t.iloc[0]\n",
    "        df_t = df_t.drop(df_t.index[0])\n",
    "        df_t = np.power(2, df_t) - 1\n",
    "        df_t = df_t.round(4)\n",
    "        df_t['Status'] = df_t.index.map(lambda x: 1 if x.split('-')[3][:2] == '01' else 0)\n",
    "        df_t = df_t[['Status'] + [col for col in df_t.columns if col != 'Status']]\n",
    "        df_t.to_pickle(pkl_file_path)\n",
    "        os.remove(gz_file_path)\n",
    "        os.remove(tsv_file_path)\n",
    "    df_t = df_t.apply(pd.to_numeric)\n",
    "    return df_t\n",
    "\n",
    "def find_healthy_samples(df):\n",
    "    healthy_samples_df = df[df['Status'] == 0]\n",
    "    return healthy_samples_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "if method == \"diff\":\n",
    "    dataA = download_and_parse_data(dataset_name[0])\n",
    "    dataB = download_and_parse_data(dataset_name[1])\n",
    "\n",
    "    A_up = dataA[dataA['Status'] == 1]\n",
    "    B_up = dataB[dataB['Status'] == 1]\n",
    "\n",
    "    B_up['Status'] = 0\n",
    "    df_transposed = pd.concat([A_up, B_up], ignore_index=True)\n",
    "elif method == \"normal\":\n",
    "    df_transposed = pd.DataFrame()\n",
    "    for name in dataset_name:\n",
    "        df_transposed = df_transposed.append(download_and_parse_data(name))\n",
    "train_data = df_transposed.apply(pd.to_numeric)#to_numeric:convert to 数字类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 函数 准备"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义存储结果的DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_results = pd.DataFrame(columns=['method', 'model', 'n', 'acc', 'auc', 'f1', 'precision', 'recall', 'confusionmatrix','coef', 'coef_rounded', 'found_coef', 'multiple_times','intercept', 'miRNA_ID'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 可接受的权重的范围筛选器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_allowed_numbers(max_n=25,allowed_factors=[1,2,3,4,5]):\n",
    "    result = []\n",
    "    for x in allowed_factors:\n",
    "        for y in allowed_factors:\n",
    "            result.append(x*y)\n",
    "        result.append(x)\n",
    "    result = list(set(result))\n",
    "    return result\n",
    "\n",
    "def is_all_in_list(list,n=25,allowed_factors=[2,3,5]):\n",
    "    for i in list:\n",
    "        if i not in get_allowed_numbers(n,allowed_factors):\n",
    "            return False\n",
    "    return list\n",
    "#以下为指定1-5小权重\n",
    "# def get_allowed_numbers(max_n=5,allowed_factors=[1,2,3,4,5]):\n",
    "#     result = [1,2,3,4,5]\n",
    "#     result = list(set(result))\n",
    "#     return result\n",
    "\n",
    "# def is_all_in_list(list,n=5,allowed_factors=[1,2,3,4,5]):\n",
    "#     for i in list:\n",
    "#         if i not in get_allowed_numbers(n,allowed_factors):\n",
    "#             return False\n",
    "#     return list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 画图"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分数分布图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_labels = ['患病', '未患病']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_score_distribution(ax, y_score, final_Status):                                 # 这个函数负责处理分数分布图这一个小图\n",
    "    ax.scatter(range(len(y_score)), y_score, c=final_Status, cmap='bwr', alpha=0.5)     # 画散点图，x轴是样本序号，y轴是分数，颜色是感染情况，颜色映射是蓝白红，透明度是0.5\n",
    "                                                                                        # x是样本序号：分开画，免得都黏在一起了，透明度的设置是一样的原因。\n",
    "    ax.set_title('分数分布图')\n",
    "    ax.set_xlabel('样本序号')\n",
    "    ax.set_ylabel('分数')\n",
    "    plt.rcParams['font.sans-serif']=['SimHei']                                          # 中文乱码\n",
    "    plt.rcParams['axes.unicode_minus']=False                                            # 负号乱码\n",
    "    labels = plot_labels                                                                # 图例标签，这里是感染情况，以后如果换了的话得改。 #todo 将这个改为传入参数\n",
    "    ax.legend(labels, loc='upper right')                                                # 图例\n",
    "    ax.plot([0, len(y_score)], [0.5, 0.5], color='black', lw=1, linestyle='--')         # 以0.5为界，画一条虚线，表示分数大于0.5的是细菌感染，小于0.5的是病毒感染，这个以后也得改\n",
    "                                                                                        # 因为不同的模型（如linear regression 和 ridge regression）的判断标准不一样，所以这个界限也不一样。\n",
    "                                                                                        # 现在的做法是直接在y_score 上做手脚，还是……蛮不优雅的，但是先这样吧。\n",
    "                                                                                        # todo 将这个改为传入参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ROC曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_roc_curve(ax, y_score, final_Status):\n",
    "    from sklearn.metrics import auc\n",
    "    fpr, tpr, thresholds = roc_curve(final_Status, y_score)\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    ax.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n",
    "    ax.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "    ax.set_xlabel('False Positive Rate 假阳性率')\n",
    "    ax.set_ylabel('True Positive Rate 真阳性率')\n",
    "    ax.set_title('ROC 曲线（受试者工作特征曲线）')\n",
    "    ax.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PR曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pr_curve(ax, y_score, final_Status):\n",
    "    precision, recall, thresholds = precision_recall_curve(final_Status, y_score)\n",
    "    ax.plot(recall, precision, color='darkorange', lw=2, label='PR curve')\n",
    "    ax.set_xlabel('Recall 召回率')\n",
    "    ax.set_ylabel('Precision 准确率')\n",
    "    ax.set_title('PR 曲线（准确率-召回率曲线）')\n",
    "    ax.set_xlim([0.0, 1.0])\n",
    "    ax.set_ylim([0.0, 1.05])\n",
    "    ax.legend(loc=\"lower left\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(ax, y_score, final_Status):\n",
    "    y_pred = np.where(y_score > 0.5, 1, 0)\n",
    "    cnf_matrix = confusion_matrix(final_Status, y_pred)\n",
    "    ax.imshow(cnf_matrix, interpolation='nearest',cmap=plt.cm.Blues) # type: ignore\n",
    "    ax.set_title('Confusion Matrix 混淆矩阵')\n",
    "    tick_marks = np.arange(2)\n",
    "    plt.xticks(tick_marks, plot_labels, rotation=45)\n",
    "    plt.yticks(tick_marks, plot_labels)\n",
    "    thresh = cnf_matrix.max() / 2.\n",
    "    for i in range(cnf_matrix.shape[0]):\n",
    "        for j in range(cnf_matrix.shape[1]):\n",
    "            plt.text(j, i, cnf_matrix[i, j],horizontalalignment=\"center\",color=\"white\" if cnf_matrix[i, j] > thresh else \"black\",fontsize=20)\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label 感染情况')\n",
    "    plt.xlabel('Predicted label 预测情况')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分数分布图、ROC曲线、PR曲线和混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_all(score, Status, title=\"分数分布图、ROC曲线、PR曲线和混淆矩阵\", feature=None, weight=None):\n",
    "    fig, axs = plt.subplots(2, 2, figsize=(12, 12))                                                     # 规定画布大小为1200*1200px，分成2*2的4个小图\n",
    "    fig.suptitle(title, fontsize=16)                                                                    # 设置标题\n",
    "    plot_score_distribution(axs[0,0], score, Status)                                                    # 第一个小图（左上角）是分数分布图 这里的axs[0,0]是指第一行第一列的小图，注意计数是从0开始的。\n",
    "    plot_roc_curve(axs[0,1], score, Status)                                                             # 第二个小图（右上角）是ROC曲线\n",
    "    plot_pr_curve(axs[1,0], score, Status)                                                              # 第三个小图（左下角）是PR曲线\n",
    "    plot_confusion_matrix(axs[1,1], score, Status)                                                      # 第四个小图（右下角）是混淆矩阵\n",
    "    if feature or weight:                                                                               # 如果有feature或者weight的话，就在图的下方加上文字\n",
    "        try:\n",
    "            # add margin at bottom\n",
    "            fig.subplots_adjust(bottom=0.12)                                                            # 调整图的下边距，这样文字就不会挡住图了\n",
    "            # add feature and weight at the bottom\n",
    "            fig.text(0.5, 0.04, '使用feature:'+str(feature), ha='center', va='bottom', fontsize=12)     # 在图的下方加上文字，这里的0.5,0.04是指文字的位置，ha='center'是指文字居中，va='bottom'是指文字在底部，fontsize=12是指文字大小\n",
    "            fig.text(0.5, 0.02, '对应权重:'+str(weight), ha='center', va='bottom', fontsize=8)          # 同上\n",
    "        except:\n",
    "            pass                                                                                        # 如果出错了就算了\n",
    "    return fig, axs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 给定 基因 权重 和数据，计算分数并画图（可能需要修改）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 筛选"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "筛选哪些基因比较有差异"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_higher_columns(data, diff=2.0):#diff是挑出来的\n",
    "    data_mean = data.groupby('Status').mean()\n",
    "    higher_columns = []\n",
    "    higher_times = []\n",
    "    #data_mean.iloc[0,0]:health=0的第零个\n",
    "    for i in range(data_mean.shape[1]):\n",
    "        if data_mean.iloc[0,i] != 0 or data_mean.iloc[0,i] != 0:\n",
    "            if  diff*data_mean.iloc[0,i] < data_mean.iloc[1,i]  or data_mean.iloc[0,i] > diff*data_mean.iloc[1,i]:\n",
    "                higher_columns.append(data_mean.columns[i])#data_mean.columns[i]第i个的id（行名字）\n",
    "            # 0\n",
    "                if data_mean.iloc[0,i] == 0:\n",
    "                    higher_times.append(1e10)\n",
    "            else:\n",
    "                higher_times.append(data_mean.iloc[1,i]/data_mean.iloc[0,i])\n",
    "    return higher_columns, higher_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "排序有差异的基因"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_higher_columns(data, higher_columns, higher_times):\n",
    "    # sort the columns and times together\n",
    "    data_higher_times, data_higher_columns = zip(*sorted(zip(higher_times, higher_columns), reverse=True))\n",
    "    # convert data_higher_columns to list\n",
    "    data_higher_columns = list(data_higher_columns)\n",
    "    # add Status column to the top of data_higher_columns\n",
    "    data_higher_columns.append('Status')\n",
    "    # get the new data\n",
    "    data_higher = data[data_higher_columns]\n",
    "    return data_higher, data_higher_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def print_best_acc(test_acc, n, gene_symbol, coef):\n",
    "#     best_acc = max(test_acc)\n",
    "#     best_i = 0\n",
    "#     i = 0\n",
    "#     print('最好的准确率为：', best_acc)\n",
    "#     for acc in test_acc:\n",
    "#         if acc == best_acc:\n",
    "#             print('='*60)\n",
    "#             print('对应的特征数为：', n[i],'方法为：', methods[i // len(models)].__name__,'特征为：', gene_symbol[i])\n",
    "#             print('模型为：', models[i % len(models)],'特征权重为：', coef[i])\n",
    "#             weights_avg = np.mean(coef[i])\n",
    "#             new_coefs = []\n",
    "#             for j in range(len(coef[i])):\n",
    "#                 # new_coefs.append(10*(coef[i][j]/weights_avg)) 保留2位小数\n",
    "#                 # new_coefs.append(round(10*(coef[i][j]/weights_avg), 2)) type numpy.ndarray doesn't define __round__ method\n",
    "#                 new_coefs.append(np.round(10*(coef[i][j]/weights_avg), 2))\n",
    "#             print('比例大致为：', new_coefs)\n",
    "#         i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一次性完成基因筛选和模型训练\n",
    "通过调控C，使用LogisticRegression or LinearSVC 一次性完成基因筛选和模型训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def percent_to_color(percent: float) -> str:\n",
    "    assert 0 <= percent <= 1, \"Percent must be between 0 and 1\"\n",
    "    if percent >= 0.82:\n",
    "        hue = int(120 - (1 - percent) * 4000 / 3)\n",
    "    else:\n",
    "        hue = 0\n",
    "    saturation = 100  # 饱和度为100%\n",
    "    lightness = 50  # 亮度为50%\n",
    "    return f\"hsl({hue}, {saturation}%, {lightness}%)\"\n",
    "\n",
    "def colored_text(text: str, percent: float) -> str:\n",
    "    color = percent_to_color(percent)\n",
    "    return f'<span style=\"color: {color}\">{text}</span>'\n",
    "\n",
    "\n",
    "def evaluate_classifier(clf, method, model, X_train, y_train, X_test, y_test, params):\n",
    "    global final_results\n",
    "\n",
    "    acc_scores, auc_scores, f1_scores, precision_scores, recall_scores, n_features = [], [], [], [], [], []\n",
    "\n",
    "    for param in params:\n",
    "        clf.set_params(**param)\n",
    "        clf.fit(X_train, y_train)\n",
    "        nonzero_coef_indices = np.flatnonzero(clf.coef_)  # Indices where coef_ != 0该行查找分类器系数非零的索引。这通常用于线性模型。\n",
    "        n = len(nonzero_coef_indices)#筛选出了几个mirnas\n",
    "        y_pred = clf.predict(X_test)\n",
    "        y_pred = np.array([1 if i > 0.5 else 0 for i in y_pred], dtype=int)#将预测概率转换为二进制预测。如果预测概率大于0.5，则分类为1；否则，分类为0。\n",
    "        \n",
    "        if 3 <= n <= 10:\n",
    "            cm = confusion_matrix(y_test, y_pred)\n",
    "            auc = roc_auc_score(y_test, y_pred)\n",
    "            f1 = f1_score(y_test, y_pred)\n",
    "            f2 = fbeta_score(y_test, y_pred, beta=2)\n",
    "            f05 = fbeta_score(y_test, y_pred, beta=0.5)\n",
    "            precision = precision_score(y_test, y_pred)\n",
    "            recall = recall_score(y_test, y_pred)\n",
    "            \n",
    "            # acc = clf.score(X_test, y_test) if method is lasso or elasticnet, score is not accuracy\n",
    "            acc = accuracy_score(y_test, y_pred)\n",
    "\n",
    "            allowed_numbers = get_allowed_numbers()\n",
    "            coef = clf.coef_#binary linear clf coef\n",
    "            # only use non-zero coef\n",
    "            #缩放因子scaling factors\n",
    "            coef = coef[coef != 0]\n",
    "            weights_avg = np.mean(np.abs(coef))\n",
    "            min_times = 0.5 / np.min(np.abs(coef))\n",
    "            max_times = 25.5 / np.max(np.abs(coef))\n",
    "            if min_times > max_times:\n",
    "                multipletimes = [max_times]\n",
    "            else:\n",
    "                multipletimes = np.linspace(min_times, max_times, num=500)\n",
    "            found_coef = False\n",
    "            coef_roundeds = []\n",
    "            deltas = []\n",
    "            for multipletime in multipletimes:\n",
    "                coef_rounded_t = []\n",
    "                differences = []\n",
    "                for coef_i in coef:\n",
    "                    # 符号问题，先存符号\n",
    "                    coef_i_sign = coef_i / np.abs(coef_i)\n",
    "                    coef_i = np.abs(coef_i)\n",
    "                    differences_i = []\n",
    "                    for allowed_number in allowed_numbers:\n",
    "                        difference = np.abs(coef_i * multipletime - allowed_number) / allowed_number\n",
    "                        differences_i.append(difference)\n",
    "                    best_allowed_number = allowed_numbers[np.argmin(differences_i)]\n",
    "                    coef_rounded_t.append(best_allowed_number * coef_i_sign)\n",
    "                    differences.append(np.min(differences_i))\n",
    "                delta = np.average(np.array(differences))\n",
    "                deltas.append(delta)\n",
    "                coef_roundeds.append(coef_rounded_t)\n",
    "\n",
    "            coef_rounded = coef_roundeds[np.argmin(deltas)]\n",
    "            delta = np.min(deltas)\n",
    "            mean_coef = np.mean(np.abs(coef_rounded))\n",
    "            times = mean_coef / weights_avg\n",
    "            if delta < 0.30: # 30%的平均误差\n",
    "                found_coef = True\n",
    "            if np.sum(coef_rounded) == 0:\n",
    "                balanced = True\n",
    "            else:\n",
    "                balanced = False\n",
    "\n",
    "            intercept = clf.intercept_\n",
    "\n",
    "            nonzero_coef_indices = np.flatnonzero(clf.coef_) # get the indices of non-zero coef\n",
    "            gene_id = list(X_train.columns[nonzero_coef_indices])\n",
    "\n",
    "            result = pd.DataFrame({\n",
    "                'method': [method],\n",
    "                'model': [model],\n",
    "                'n': [n],\n",
    "                'acc': [acc],\n",
    "                'auc': [auc],\n",
    "                'f1': [f1],\n",
    "                'f2': [f2],\n",
    "                'f05': [f05],\n",
    "                'precision': [precision],\n",
    "                'recall': [recall],\n",
    "                'confusionmatrix': [cm],\n",
    "                'coef': [coef.tolist()],\n",
    "                'coef_rounded': [coef_rounded],\n",
    "                'found_coef': [found_coef],\n",
    "                'delta': [delta],\n",
    "                'multiple_times': [times],\n",
    "                'intercept': [intercept.item()],\n",
    "                'balanced': [balanced],\n",
    "                'gene_id': [gene_id],\n",
    "            })\n",
    "\n",
    "            final_results = pd.concat([final_results, result], ignore_index=True) \n",
    "\n",
    "            # For plotting\n",
    "            n_features.append(n) \n",
    "            acc_scores.append(acc)\n",
    "            auc_scores.append(auc)\n",
    "            f1_scores.append(f1)\n",
    "            precision_scores.append(precision)\n",
    "            recall_scores.append(recall)\n",
    "\n",
    "            if loglevel == 'debug':\n",
    "                result_text = \"\"\n",
    "                result_text += f'method: {method}, '\n",
    "                result_text += f'model: {model}, '\n",
    "                result_text += f'n: {n}, '\n",
    "                result_text += 'acc: ' + colored_text(f'{acc:.3f}', acc) + ', '\n",
    "                result_text += 'auc: ' + colored_text(f'{auc:.3f}', auc) + ', '\n",
    "                result_text += 'f1: ' + colored_text(f'{f1:.3f}', f1) + ', '\n",
    "                result_text += 'precision: ' + colored_text(f'{precision:.3f}', precision) + ', '\n",
    "                result_text += 'recall: ' + colored_text(f'{recall:.3f}', recall) + '<br>'\n",
    "                coef_text = 'coef: '+ coef_rounded.__str__() + 'Gene: ' + gene_id.__str__()\n",
    "                result_text += coef_text\n",
    "                # 对 coef 和 gene_id 同样这样处理\n",
    "                # 最后，一次性打印所有的结果\n",
    "                display(HTML(result_text))\n",
    "        if n > 7:\n",
    "            break\n",
    "\n",
    "    # Plotting inside the function\n",
    "    plt.rcParams['font.family'] = 'Arial'\n",
    "    plt.rcParams['font.size'] = 10\n",
    "    plt.rcParams['axes.linewidth'] = 3      # 边框粗细\n",
    "    plt.rcParams['axes.labelweight'] = 'bold'  # 轴标签字体粗细\n",
    "    plt.rcParams['xtick.major.width'] = 3   # x轴刻度粗细\n",
    "    plt.rcParams['ytick.major.width'] = 3   # y轴刻度粗细\n",
    "    fig, axs = plt.subplots(1, 1, figsize=(20, 15))\n",
    "\n",
    "    plt.plot(n_features, auc_scores,linewidth=8)#AUC\n",
    "    plt.scatter(n_features, auc_scores)\n",
    "    plt.plot(n_features, f1_scores,color='red',linewidth=8)#, label='F1 score'\n",
    "    plt.scatter(n_features, f1_scores)\n",
    "    plt.plot(n_features, precision_scores,color='orange', linestyle='dashed',linewidth=8)#, label='Precision',\n",
    "    plt.plot(n_features, recall_scores, color='gray', linestyle='dashed',linewidth=8)#label='Recall',\n",
    "    #plt.title('Performance metrics by number of features (' + method + ')')\n",
    "    plt.xlabel('Number of features', fontsize=40)\n",
    "    plt.ylabel('Performance metrics',fontsize=40)\n",
    "    axs.tick_params(axis='x', labelsize=30)  # 设置 x 轴刻度的字体大小和旋转角度\n",
    "    axs.tick_params(axis='y', labelsize=30)\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "高表达差异基因数目： 345\n"
     ]
    }
   ],
   "source": [
    "higher_columns, higher_times = get_higher_columns(train_data, 4)\n",
    "print('高表达差异基因数目：', len(higher_columns))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "根据倍率不同进行排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_higher, data_higher_times = sort_higher_columns(train_data, higher_columns, higher_times)\n",
    "X_train, X_test, y_train, y_test = train_test_split(data_higher.drop(['Status'], axis=1), data_higher['Status'], test_size=0.2, random_state=42)\n",
    "# X_train, y_train = sm.fit_resample(data_higher, data_higher['Status'])\n",
    "# smote\n",
    "X_train, y_train = sm.fit_resample(X_train, y_train)\n",
    "# X_test, y_test= sm.fit_resample(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 训练不同的模型，使用不同的特征选择方法，选择出特征后，使用不同的方法来训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABswAAAT/CAYAAAChNtehAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXxU1f3/8fdMMkkIIYFAAFkEFAQhCCqC7KAsgkUUlyqLyNIi0tJWWoQiLoCIC1iFVqAiVIWKGsEFEBD5oiyiZauEfYewJQQSICGZSeb3R36ZZpJJMpO5Qwbu6/l45GHOnXPPfO7IhEvec86xOJ1OpwAAAAAAAAAAAACTspZ3AQAAAAAAAAAAAEB5IjADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmFpoeRcA+MvhcGj//v1ux2JjY2W1kgcDAAAAAAAAAGA2ubm5Sk1NdTvWqFEjhYYWH4sRmOGat3//fjVt2rS8ywAAAAAAAAAAAEFq165duvXWW4t9nCk4AAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjT3McM2LjY0tcmzXrl2qVq1aOVQTnOx2u7799lt169ZNNputvMsBUAzeq0Dw430KXBt4rwLXBt6rwLWB9ypwbeC96i4lJUVNmzZ1O+YpSyiIwAzXPKu16ETJatWqKS4urhyqCU52u10xMTGKi4vjhyUQxHivAsGP9ylwbeC9ClwbeK8C1wbeq8C1gfdq6TxlCW6PX6U6AAAAAAAAAAAAgKBEYAYAAAAAAAAAAABTY0lGAAAAAAAAAAAABB2n0ymHw6GcnJxi+9hsNoWEhPj9XARmAAAAAAAAAAAACCrZ2dk6deqUMjIySuxnsVhUp04dRUVF+fV8BGYAAAAAAAAAAAAIGrm5uTp8+LBCQkJUq1YthYWFyWKxFOnndDqVnJysEydOqFGjRn7NNCMwAwAAAAAAAAAAQNDIzs5Wbm6u6tatq8jIyBL7xsXF6ciRI7Lb7X4FZtYynwkAAAAAAAAAAAAEiNVaeozlaeZZmZ7LkFEAAAAAAAAAAACAaxSBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAQNBxOp2G9PEGgRkAAAAAAAAAAACChs1mkyRlZGSU2jc7O1uSFBIS4tdzhvp1NgAAAAAAAAAAAGCgkJAQVa5cWWfPnpUkRUZGymKxFOmXm5ur5ORkRUZGKjTUv8iLwAwAAAAAAAAAAABBpWbNmpLkCs2KY7VadeONN3oM1HxBYAYAAAAAAAAAAICgYrFYdMMNN6h69eqy2+3F9gsLC5PV6v8OZARmAAAAAAAAAAAACEohISF+70/mDf8jNwAAAAAAAAAAAOAaRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKkRmAEAAAAAAAAAAMDUCMwAAAAAAAAAAABgagRmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAApkZgBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3AzEsHDx7UuHHj1KZNG8XGxiosLEx16tRRu3bt9Morr+jYsWMBr+HChQuaOXOm7rvvPt14442KiIhQdHS04uPjNWLECK1fv77MY1+5ckXvv/++HnzwQTVo0ECRkZGKiopS48aN9eSTT2rFihVyOp0+j1ulShVZLBafv0JDQ8t8LQAAAAAAAAAAAL4glSiFw+HQxIkT9cYbbygnJ8ftsaSkJCUlJWnTpk16+eWXNWnSJI0dO1ZWq/E55Jw5czRhwgSdO3fO7XhWVpYSExOVmJiouXPnqmvXrpo9e7ZuueUWr8f+/PPP9cc//lHHjx8v8ti+ffu0b98+ffjhh7rjjjv07rvvqnXr1l6Ne+TIEV24cMHrOgAAAAAAAAAAAMoDM8xKkJOTo1//+teaNm1akbCsMLvdrvHjx2vAgAGG1pCbm6uRI0fq6aefLhKWebJ27Vq1atVK33zzjVfjT506VY888ojHsKywrVu3qkOHDpo/f75XY2/fvt2rfgAAAAAAAAAAAOWJwKwEL7zwgj7//HNXu2rVqpo5c6aOHj2qzMxM7d+/X5MmTVJkZKSrz8cff6wpU6YYVsPLL7+s2bNnux1r3769li5dqpSUFGVkZGjLli0aNWqUQkJCJEkXL17UQw89pE2bNpU49oIFCzRhwgS3pRabNWumRYsW6fTp07py5YoSExM1YcIERURESMoLBocPH66EhIRSa9+xY4fr+4iICNntdjmdTq++HA6H168RAAAAAAAAAACAPwjMirFr1y699tprrnbdunW1bds2/e53v3PtH9awYUNNnDhRP/30k6pVq+bqO3nyZB05csTvGjZv3qzJkye7HRs/frx++OEH9e3bV1WrVlWFChV0xx13aNasWVqxYoUrvLty5YoGDBigy5cvexz72LFjGjlypNuxQYMGadu2bXriiSdUo0YNhYeHq2nTppoyZYo2bdqkuLg4SXmz3oYPH66TJ0+WWH/BGWbNmjVjXzIAAAAAAAAAABCUCMyKMWnSJNcyjBaLRYsXL1bdunU99m3WrJkSEhJksVgkSdnZ2Zo0aZLfNUyePNlt9tfgwYM1depU1/MU1r17d82aNcvVPnz4sFu7oNdff11Xrlxxtbt27aoFCxbIZrN57N+yZUv9+9//dj33hQsXioR5hRUMzFq0aFFiXwAAAAAAAAAAgPJCYOZBSkqKlixZ4mr36NFDbdu2LfGcTp06qW/fvq72xx9/XOzsLm8kJydr+fLlrnZ0dLTefvvtUs8bMmSI4uPjXe133nnHLXST8vZm++ijj1xtq9WquXPnymot+Y/Dvffeq/vvv9/Vnj9/vtLT0z32TUtLc5tlR2AGAAAAAAAAAACCFYGZB8uXL1d2drar3b9/f6/OK9gvMzNTX3/9dZlrWLt2rVvQNWDAAMXExHh17sCBA13fnzx5Uhs3bnR7fMuWLUpLS3O1e/bsqYYNG/o8dlZWlr766iuP/QruXyYRmAEAAAAAAAAAgOBFYObBmjVr3Nr33HOPV+d17drVrV1whpivdu3aVeLYJWndurVbe/369Vdt7HwFl2OUpNtuu83r5wAAAAAAAAAAALiaQsu7gGD03//+1/V9XFyc6tSp49V51apVU+3atZWUlCRJ+vnnn8tcw7lz59zaDRo08PrcGjVquLW3bdt21cbOV3CGWb169VSlShWvnwOBYXVml94JAAAAAICryOrMkuzpkjzvqV4+rJItyv9hcrKl3Cul9ytPlhAptKL/4+RkSblZ/o8TSBabFFrB/3EcmZLT7v84gWQNl0LC/R/HcVly5kh2u0KdGUH4XpVkjZBCwvwfx35JUq7/4wRSSKRkNeDX+XbPW+wElZCKkjXEvzGcTslx0Zh6Aim0kmSx+DdGbo6Uc1my22UN9p9PQY7AzIM9e/a4vm/UqJFP5958882uwOzQoUNyOp2ylOEPfMElISUpKsr7G7WQEPcfJkePHr1qY+crOMOsRYsWys3N1apVq7R48WJt2rRJSUlJysnJUY0aNXTnnXeqb9++evzxx2WzBdlfute65E3S6naySeojSZ/+/+PdN0pxJe/LBwAAAABAQFw+Lv13okLPrlefjIPS0vIuqJCYptL9if6Pc/gD6aff+D9OINXsId2z0v9xEl+Vdr7s/ziBdPMwqc17/o+z5ffSwXn+jxNI8S9Kt73k/zjf95NOr5JN0v1S8L1XJan1P6WGw/0fZ1UbKW1X6f3KU5dvpFo9/R9nSZ3gD5J675QqN/NvDMdF6VPvtjgqV4+mSbZo/8ZI3yMtj5dNUiPbryX1NaIyUyIwKyQ1NVVXrvzv0z+1a9f26fwbbrjB9X1WVpbOnj1bZFaWN6pWrVqkLm8lJye7tfMDvECMffbsWTkcDoWG/u+PksPhUGLi/24sL1++rBYtWmjnzp1Fxjty5IiOHDmihIQEvfzyy3r33XfVvXt3n2pJSUnxun5T+XGIdGiB58dWt5PqPizd/f5VLckNn+zyXf4nu4IZn+zyXcFPdgXrp/b4ZJdv8j/ZFez8vSGXpFyHlJPh/zgBZfAnxIP1fSrxCfGy4D4iuBh5H2HPCt73qsQnxH3FfUTw8ec+4vhS6cfBkj1dfr5aAAAAhiIwK+Ts2bNu7djYWJ/Or1y5sls7NTW1TIFZ/fr13dpbt25Vu3btvDq38DKJ6enu/4jyNHb//v3LNHZubq4uXbrkdt27d+9WVtb/fslSeE+44hw8eFC9evXSrFmz9PTTT5fav3r16l6Na0rJm4oPy/IdT8j7Ki98sst3//+TXUGNT3b5rsAnu4L2U3t8sss3//+TXUEttJL0mAG/ZD29Rvq/+/wfJ5AM/oR40L5PJT4hXhbcRwQXA+8jbGm7gve9KvEJcV9xHxFc/LmPuHzcFZYBAAAEGwKzQi5duuTWrlSpkk/nF17e8OLFsv3jpXPnzm7tRYsW6Xe/+51X537yySdu7YIz5iSpXbt2Cg0NlcPhkCR9+umnmjZtmtssMW/H9jR+wf3L8kVEROjJJ5/U4MGDdcstt6hixYo6ceKEVq1apTfffFNHjhyRJOXk5OiZZ55RrVq19MADD5RaT3Hsdrvs9iD/tHAA2VZ7F66Wp9zcXOUY8P8oJDdXVgPqCaSc3BzlGnGtTmfQX6sjJ0dOA6411OkM+k+bOnIcxlyrFPTXanfYJX+v1W4Pxs/3F5H3d4ef1+oI/mt1SnIY8OfXkuMI+ptJp9Np0LXmBP215jqdhvzdas3NkZ9zQQKO+wjfcR8RXLiP8HWQ4P+7VeI+whsh2yfIeg2EZdw/+I77h+DC/YPvuH8ILtw/+KjQ/YOZfy9eUFleh2D/e/uqKzgzSpLPe2oV7l/WP5yNGzdW8+bN9csvv0iSNm3apE8++USPPfZYiectW7ZM69evL7GGqKgo9erVS1999ZUk6dixY5oxY4bGjh1b4tjbt2/X4sWLixwvPH7B/csk6aabblJCQoJatmzpdrxRo0Zq1KiRhg0bpkGDBumzzz6TlHdjOnjwYB06dEhVqlQpsabifPvtt4qJuQY+gRgg18IqtcePH9f2s8v9Hqdl1nHVM6CeQNq/f7/2HvX/WtteSVawz6v85ZdfdGyP/9faNeOSDFgsLqB++ulnJYc6/B6nt8MR9DdwP/zwgy5aPe9Z6a1QZ0beJ/2D3KpVq+SwRPo1RqXcY7rHoHoCxeFwaPly/9+rcY5tCvaPaFy8eElrDbjWG+2/6HYD6gmklJRkbTLgWhtn71cTA+oJJO4jfMd9RHDhPsI33EcEF3/uI+7NWK0oSZcstbTf9rBuz55pbHEG4f7Bd9w/BBfuH3zH/UNw4f7BN4XvH1avXu1fUdeJtLQ0n88hMCskJ8d9XX+r1bfPURTun5tb9j14xo8f77ZU4rBhwxQbG6tu3bp57P+f//xHgwcPLnI8LKzoPgDjx493BWaSNGHCBNWqVUsDBw70OPahQ4fUr18/jwFg4fFvvfVWPfTQQzp06JBSU1P1zTffqFGjRp4vUnmzzxYtWqQTJ07oxx9/lCRduHBB06dP15QpU4o9ryTdunVTXFxcmc695mWnSl+UdxGlq1u3rmq16u33OCH/+UI6bEBBAdSoUSPd3MyAa/3+79IZAwoKoObNmyv+Jv+vNXTleCnIP3jauvVdctbs4fc4oUtCJf/vdwOqY8eOUoyfSynZ04N3WawCevTo4f9SSmmJUpCvehYaGqrevf1/r1pOh0o/GFBQAFWqFKXePQ241kOnpS0GFBRA1arFqXcn/6/VmvgfKchXxeU+wnfcRwQX7iN8xH1EUCnzfUROpmyfn5YzqpHCu6xW87Sd0g/BGZhx/+A77h+CC/cPvuP+Ibhw/+CjQvcP3bt393ki0PUoOTnZ53MIzAopvCxh4QCtNPnLHOYLDy/7Bt1PPPGEPv30Uy1ZskRS3nKR9913n5566ikNHTpUzZs3V0hIiPbt26eFCxdq5syZysrKUpUqVVS9enXt3bu32Bratm2rP/zhD3r77bdddQ8aNEhLly7VyJEjdeedd6pChQo6fPiwPvvsM73xxhtKT09XWFiY4uPjtXXr1mKvcdiwYRo2bJhP12qz2fS3v/1Nd999t+vYwoULSwzM8vebS0lJUdOmTYuMZ9ofCtfIlFur1SqrEf+PfAy1y0OINUQhRlyrvxuIXwWhISGSaa411JhrvQbYQm0GXOu18VrZbAZca2jwX6tFvs+i9ygk+G8lLRaLQdca7IsMSVaLxaC/W6+Ba+U+wnfXxN+t3Edcj7iP8NF1fR+RKVW6RZZ718oWWUu6tMfo0gzD/UNZBroGrpX7B99dE3+ncv9wPeL+wUeF7h9M/bvxAsryGgT/bzmusshI9+mPhffnKk1mZqZb25/ATJLmz5+vM2fOaOPGjZLyArx58+Zp3jzPm5NXqFBBn3/+uV588UVXYFbcPmxvvPGGjh49qqVLl7qOJSQkKCEhwWP/kJAQzZ8/XytXrnQFZhaLRRUrVizr5blp06aNmjRpoj178m6ajxw5ooMHD+rmm2/22N+0M8hKY+GHIQAAAAAgyFjDpXvXSpG1yrsSAAAAj4L/IxFXWWxsrFs7Pd23ubgXL150a1etWtWvemJiYrRmzRqNGDGi1OUhW7Vqpa1bt6pLly66cOGC6/gNN9zgsb/NZlNCQoKef/75UoO9hg0bav369erfv7/b2NWqVTM0rW7Tpo1b+/DhIJ/jHozCKpd3BQAAAAAAuAsJJywDAABBjcCskBo1ashSYApu/rJ/3jpzxn1h3+rV/d8aMyIiQrNnz9b27dv17LPPqnnz5oqJiZHNZlOdOnXUr18/ffrpp9q8ebOaNMnbYvXUqVOu82vVKv6G1Gq1avLkydq9e7eef/553XnnnYqNjVVoaKhq1Kih3r176/3331diYqJrucSTJ096NXZZ1KhRw62dkpJi6PimEBIuNSi6lx0AAAAAAAAAAPCMJRkLCQ8PV61atZSUlCRJOn78uE/nF+xfq1YthYWFGVZb8+bNNX369FL7JSUluW1o16xZ6RskNmjQQJMnT9bkyZNL7JeTk6OdO3f6NLYvnE6nW9vfJS1N67bJ0okleZtbAgAAAAAAAACAEhGYeRAfH+8KzPbv36+cnByFeLFRq8Ph0IEDB9zGKQ+bN292a7ds2dKwsXfs2OG2r5unsdPS0nTmzBmdOXNGNWrU0C233OL1+IVn9FWrVq3MtZpaxbpS2w+kTU8SmgEAAAAArh1tP5Dq9C3nIgxakKnBk1K9x4wZK1Aspf++yyvNxku3PmvMWIFi1J7vd86U7phhzFiBYjXoA+idPpecObLb7Vq1apV69Ohh6NYshrBGGDNOj82Sco0ZK1BCIo0Z56ETxowTSCEV/R8jtJL0aJr/4wRaaCX/x4huIj2aJrvdrv2r1upm/0c0LQIzD9q0aaOVK1dKkjIyMrRz5061aNGi1PMKh0n5Sxj6w+l06vz587JarapcubJX53zxxReu761Wq7p27Vps37S0NDkcDq/3Wis4tiR169bNrf3ll1+qb9//3dgOHjxYCxYs8GpsSfr5559d31utVt12221en4tC6vSVeu+U/jtRzuQNslw6UPo5AAAAAABcZc6ohrLEtc9bLaVi3fIuxzghYXlfZhASnvdlBqEVJFUo7yqujtD80MIuhyVSskVLwRaYGcUWVd4VXD226PKu4OqwWMxzrdYQyRotya5coz4cYFIWZ+E18KCNGzeqffv2rvaUKVM0YcKEUs976aWX9PLLL7va69evdxvHFzk5OWrYsKGSkpJkt9s1YsQIzZ49u9Tz0tPTdeONNyotLS8979ixo77//vsi/dq3b68tW7YoKytLPXv21DfffONVTU2aNHHNorvxxht19OhRtz5HjhxRgwYNXO1atWrp+PHjslpL/3TWrl27FB8f71qW8a677tJPP/1U6nnJyclF9oo7e/as4uLiSj3XLOx2u75ZtkT39bg3eD4JZLH9/5tMPzkyJafd/3ECyWrQPxwclyVnjv/jBJI1wph/ENov6Zr4ZJfVgM+dFJgFGrSf2gupmHfz5Q+nU3JcNKaeQAqtlHdT7Y/cHCnnsjH1BJIR/3DIdUg5Gf6PE1BWY/7xm5Mt5V4J3veplPcJ8VADPomZkyXlZvk/TiBxH+E7k91H2O1ZwftelQJyHxG0uI/wjcnuI+xX0vTNqjW67/6HgvO9CkBS3r9Vly9frt69e/NeBYIY71V3ZckNmGHmwd1336169eq5wqC5c+dqzJgxiogofopvRkaG/vnPf7raN910k9q1a1fmGkJCQhQbG6sjR45Ikr766iv9/e9/L3VpyBkzZrjCMkl65plnPParWbOmsrLyfhGybt06paamKjY2tsSxP/zwQ7clJ0eOHFmkT/369RUfH+/a5+zkyZNKSEjQo48+WuLYkvTiiy+67WE2YsSIUs+B93It4dfnJ4FM+ckuEzDtJ7uu40/tmfKTXSZgDTXPtbo+IX4dv0/z8Qnx65Pp7iPCr//3qmSev1u5j7g+WUMlW3Tev1UBAACCgEGLMl9frFarRo0a5WofO3ZMv//970s8Z+TIkTp58qSrPXr0aFn8/GTZww8/7Pr+5MmTevfdd0vs/9133+mVV15xtZs2bapHHnmk1LGvXLmiqVOnljh2YmKiRo8e7WpXr15dTz/9tMe+v/nNb9zazz77rE6fPl3i+O+8844+++wzV/umm27SgAEDSjwHAAAAAAAAAADACARmxRg1apTq16/var/33nsaPny4Ll92Xxrh8uXLGjJkiD744APXsVtuucXj7Cspb8lCi8Xi9lWc4cOHKyYmxtUeM2aMFi5cWKSfw+HQu+++q/vvv18Oh0NS3gy12bNnKzTU8yTCfv36uV3fjBkz9Oabbyo3130JNKfTqc8++0wdOnTQxYv/WwLjrbfeKnZPtZEjR6pp06au9okTJ9SxY0ePyytevnxZY8aM0R/+8AfXMavVqvfff7/EGX0AAAAAAAAAAABGYUnGYkRGRmrRokXq1q2bMjLy9uaYN2+eEhIS1KdPH9WuXVsnTpzQ119/rQsXLridt3jxYoWF+b/2fvXq1TVjxgwNGzZMkpSdna2BAwfq1VdfVdeuXRUVFaWkpCR9++23OnXqlNu5M2fOVMeOHYsdOyIiQnPnzlWvXr2Uk5Mjp9Opv/zlL/rHP/6hHj16qGrVqjp16pS+//57HTx40O3csWPHqn///sWObbPZlJCQoA4dOujcuXOSpAMHDqhNmzZq166dWrdurfDwcB06dEgrV65Uevr/1t23WCx677331LlzZ59fLwAAAAAAAAAAgLIgMCtB27ZttWzZMj344IOufcEuXLigDz/80GP/ypUr64svvlDLli0Nq2Ho0KE6f/68nnvuOeXk5G3SnZiYqMTERI/9IyMjNWfOHA0cOLDUsbt3764PP/xQQ4cO1ZUrVyRJhw8f1pw5czz2Dw0N1SuvvKKxY8eWOnaTJk20du1aPfroo9q7d6/r+MaNG7Vx40aP58TExGjWrFle1Q4AAAAAAAAAAGAUlmQsRZcuXbRnzx499dRTqlDB84bgYWFhGjRokHbu3KlOnToZXsOYMWP0/fff65577im2T2RkpIYOHardu3f7FDg98cQT2rJlix588EFZrZ7/ONhsNj3yyCPavn27V2FZvubNm2vLli2aNm2aateuXWy/ypUra/jw4T7XDgAAAAAAAAAAYARmmHmhZs2amj9/vmbNmqV169bp6NGjSk1NVVRUlBo1aqR27doVu59XYfXr15fT6fS5hnbt2mnNmjVKSkrShg0bdOLECWVmZqpy5cq69dZb1aZNG1WsWNHncSWpadOmWrJkiVJSUrR+/XodOXJEly9fVqVKldSoUSO1bdvW6+srrGLFinruuec0duxYJSYmauvWrUpOTpbD4VCNGjVUr149dejQQTabrUzjAwAAAAAAAAAA+IvAzAcVK1ZU7969y7WG2rVr67HHHgvI2NWqVdODDz4YkLEtFovi4+MVHx8fkPEBAAAAAAAAAADKiiUZAQAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3ADAAAAAAAAAAAAKZGYAYAAAAAAAAAAABTIzADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmBqBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKkRmAEAAAAAAAAAAMDUCMwAAAAAAAAAAABgagRmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAApkZgBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3ADAAAAAAAAAAAAKZGYAYAAAAAAAAAAABTIzADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmBqBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKkRmAEAAAAAAAAAAMDUCMwAAAAAAAAAAABgagRmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAApkZgBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADC10PIuAMDVYc3OLu8SAAAAAABwY83KktLTJZutvEsBUBy7XaEZGbxXgWBX0nu1UiXJYimfuq4hBGbA9WzTJqldO9kk9Sl4fONGqW3bcioKAAAAAGBqx49L4/6i0FVL1Sclq7yrAVAKm6T7y7sIAKUq8b2aliZFR1/Faq5NLMkIXK+GDJHatfP8WLt20tChV7ceAAAAAACWLpUa1ZMWLZaFsAwAAAQRAjPgerRpk7RgQcl95s/P6wcAAAAAwNVw/Lj0eD8py1nelQAAABRBYAZcj4qbWVbWfgAAAAAA+GvcXwjLAABA0CIwAwAAAAAAQOCtXFLeFQAAABSLwAy43qSmBrY/AAAAAAC+ysyUzmWXdxUAAADFIjADrjcZGYHtDwAAAACAr+z28q4AAACgRARmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAAphZa3gUAAAAAAAAAbo4fl6Kjy7sKAJLsdrtWrVqlHj16yGazlXc5AIpR4nu1UqXyKeoaQ2AGAAAAAACA4BIdTWAGBAu7XY7IyLz3JIEZELx4r/qNJRkBAAAAAAAAAABgagRmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAApkZgBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3ADAAAAAAAAAAAAKZGYAYAAAAAAAAAAABTIzADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmBqBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKkRmAEAAAAAAAAAAMDUCMwAAAAAAAAAAABgagRmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAApkZgBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3ADAAAAAAAAAAAAKZGYAYAAAAAAAAAAABTIzADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmBqBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKkRmAEAAAAAAAAAAMDUCMy8dPDgQY0bN05t2rRRbGyswsLCVKdOHbVr106vvPKKjh07FvAaLly4oJkzZ+q+++7TjTfeqIiICEVHRys+Pl4jRozQ+vXryzz2lStX9P777+vBBx9UgwYNFBkZqaioKDVu3FhPPvmkVqxYIafTWebxd+zYodGjR6tly5aqXLmywsPDVb9+fXXp0kVvv/22kpOTyzw2AAAAAAAAAACAP0LLu4Bg53A4NHHiRL3xxhvKyclxeywpKUlJSUnatGmTXn75ZU2aNEljx46V1Wp8DjlnzhxNmDBB586dczuelZWlxMREJSYmau7cueratatmz56tW265xeuxP//8c/3xj3/U8ePHizy2b98+7du3Tx9++KHuuOMOvfvuu2rdurXXY1++fFmjR4/W+++/X+Sxo0eP6ujRo1q3bp2ef/55vfPOOxoyZIjXYwMAAAAAAAAAABiBGWYlyMnJ0a9//WtNmzatSFhWmN1u1/jx4zVgwABDa8jNzdXIkSP19NNPFwnLPFm7dq1atWqlb775xqvxp06dqkceecRjWFbY1q1b1aFDB82fP9+rsS9duqSePXt6DMs89R06dKjGjRvn1dgAAAAAAAAAAABGITArwQsvvKDPP//c1a5atapmzpypo0ePKjMzU/v379ekSZMUGRnp6vPxxx9rypQphtXw8ssva/bs2W7H2rdvr6VLlyolJUUZGRnasmWLRo0apZCQEEnSxYsX9dBDD2nTpk0ljr1gwQJNmDDBbanFZs2aadGiRTp9+rSuXLmixMRETZgwQREREZLygsHhw4crISGh1NpHjBihDRs2uNr16tXTggULdOrUKWVkZOiXX37RmDFjFBr6v4mOr732mj788MPSXxgAAAAAAAAAAACDWJz+bEx1Hdu1a5duu+0218yyunXrasOGDapbt26RvomJierSpYtSUlIkSWFhYdq7d6/q16/vVw2bN29W27Zt3QKt8ePH65VXXpHFYinSf/Xq1XrwwQeVkZEhSWrQoIF++eUXVaxYsUjfY8eOqXHjxrpy5Yrr2KBBgzRv3jzZbLYi/bdv364ePXq49hqrXLmyEhMTVatWLY+1r1q1Sj179nS1W7RooXXr1ikmJqZI33Xr1qlXr17KzMyUlBdMHj58WJUqVfI4dmHJycmqXr2627GzZ88qLi7Oq/OvOydOSB7+nBbr+HGpTp3A1QPAa3a7XcuXL1fv3r09/iwGUP54nwLXBt6rQBBKT5c8/E6gWGlpUnR04OoB4DX+XgWuDbxX3ZUlN2CGWTEmTZrkCsssFosWL17sMSyT8mZlJSQkuEKs7OxsTZo0ye8aJk+e7BaWDR48WFOnTvUYlklS9+7dNWvWLFf78OHDbu2CXn/9dbewrGvXrlqwYEGxb6SWLVvq3//+t+u5L1y4oMmTJxdb+wsvvOD6PiIiQkuWLPEYlklS586dNWfOHFf73Llzeuutt4odGwAAAAAAAAAAwEgEZh6kpKRoyZIlrnaPHj3Utm3bEs/p1KmT+vbt62p//PHHunz5cplrSE5O1vLly13t6Ohovf3226WeN2TIEMXHx7va77zzjgpPIszJydFHH33kalutVs2dO1dWa8l/HO69917df//9rvb8+fOVnp5epN9///tfbd682dUePHiwGjRoUOLYgwYNUsuWLV3tefPmldgfAAAAAAAAAADAKARmHixfvlzZ2dmudv/+/b06r2C/zMxMff3112WuYe3atW5B14ABA4qdoVXYwIEDXd+fPHlSGzdudHt8y5YtSktLc7V79uyphg0b+jx2VlaWvvrqqyJ9li5d6tYuy+t37Ngxt9ANAAAAAAAAAAAgUAjMPFizZo1b+5577vHqvK5du7q1C84Q89WuXbtKHLskrVu3dmuvX7/+qo0tub9+ERERpc7OK64Of14/AAAAAAAAAAAAbxGYefDf//7X9X1cXJzq1Knj1XnVqlVT7dq1Xe2ff/65zDWcO3fOrV3akoYF1ahRw629bdu2qza25P76NW/e3OsNBps3b+62LKQ/rx8AAAAAAAAAAIC3Qsu7gGC0Z88e1/eNGjXy6dybb75ZSUlJkqRDhw7J6XTKYrH4XEPBJSElKSoqyutzQ0JC3NpHjx69amOfPn1aFy5ccLV9ef3Cw8NVp04dHTt2TJJ04MABr88FAAAAAADXHntoqHIL/a5BkpSVJWVlyWazlbrnemmcTmeR34UEo7CwsDL9Dqmg3Nxc2e12gyoKnPDwcL/HuBau1WKxKCwszO9xcnJy5HA4DKiobOx2u3JycpSVlaXc3FyPfYy6VofDoZycHL/HCSSr1er1BIGS2O32Yl/PYBESEqLQUP8jhOzsbLfth4JRaGhokd99l0V5Xuu18Gcq2BGYFZKamqorV6642gVnjHnjhhtucH2flZWls2fPFpmV5Y2qVasWqctbycnJbu38AC8QY589e1YOh8P1g/PkyZNuj5fl9csPzI4fP+5VLSkpKT49BwAAAAAAKD9p0dFae889OnbjjTofG+u50z/+IUkaOXKkqlev7tfzZWdna9q0aX6NcTWMGzfO7yApJSVF7777rkEVBUZYWJjGjx/v9ziHDh3SwoULDagocOLi4vTMM8/4Pc6OHTv01VdfGVCRf3755ZdiH7v55ps1cOBAv59j/fr1Wrdund/jBNLtt9+uBx54wO9xVqxY4XH1rmDSuXNndenSxe9xPvnkEx08eND/ggKoT58+uuOOO/we57333ivyO/SrqSxZBP6HJRkLOXv2rFs7trgbt2JUrlzZre1LGFVQ/fr13dpbt271+tzCP2jT09MDNnZubq4uXbrkahv5+l25ckWZmZnF9q1evbqqV6+upk2b+vQcAAAAAACgfOxp0kTvPvOMdrRsWXxYBgAAUA6YYVZIwfBHkipVquTT+YWXN7x48WKZ6ujcubNbe9GiRfrd737n1bmffPKJW7vgjDlJateunUJDQ11TuT/99FNNmzbNq+m1hccuPH4gXr8KFSr4NIaUN/002KflB4zdLl8mhdvtdsmsrxUQZPJ/bpn25xdwDeB9ClwbeK8CQchuV0Z0tJY++KCyIiK8Ps3hcPj9Xr5WfhbY7Xa/l58sz2X7fGHE/5NgX7ZPylsO1CzXatQSmWa61mth6bycnByu1UfBsPTktfL3XqCV5XUgMCskKyvLre3rerSF+5f1D2fjxo3VvHlz11TnTZs26ZNPPtFjjz1W4nnLli3T+vXrS6whKipKvXr1ck3lPnbsmGbMmKGxY8eWOPb27du1ePHiIscLjh8sr9+3336rmJiYMp17rYtISVFPH/p/9913ulKtWsDqAeC71atXl3cJAErB+xS4NvBeBYJHaEaG7Pfc41NYJknff/99mT5IW9C18At4SVq1apXf++eUtFJPsHA4HFq+fLnf4xReUSkYXbp0yZBrPXfunAHVBFZKSooh13rq1CkDqgms48ePG3KtpW1HEwz2799fZIJEWVwLW+r88ssvRbYbKgsjXi9/cQ+cJy0tzedzCMwKKXwT5esnewr39yc9Hz9+vPr37+9qDxs2TLGxserWrZvH/v/5z380ePDgIsc9bbg5fvx4t7WPJ0yYoFq1ahW71vChQ4fUr18/jwFWwfGD5fXr1q2b4uLiynTuNe/ECZ+633PPPVKdOgEqBoAv7Ha7Vq9ere7duxuygTAA4/E+Ba4NvFeBIJSernd//NHn0zp16uT3v++zsrJK3HspWPTo0cPvPcySk5O1d+9egyoKjNDQUPXu3dvvcQ4dOqRDhw4ZUFHgREVFGXKt27dvD/pwpVq1aoZc6/fff68zZ84YUFHg1K1b15BrXbZsWZm387laGjVqpE6dOvk9zr///e8yr8R2tTRv3lwtW7b0e5wTJ04UWfHtauMeOE9Z9pIjMCuk8LKEvn4KqfDUd39udJ544gl9+umnWrJkiaS8dPq+++7TU089paFDh6p58+YKCQnRvn37tHDhQs2cOVNZWVmqUqWKqlev7rpB8lRD27Zt9Yc//EFvv/22q+5BgwZp6dKlGjlypO68805VqFBBhw8f1meffaY33nhD6enpCgsLU3x8vNu+ZwXHv5qvX/5+aSkpKUX2MbPZbOb9oVCWWX1mfa2AIGXqn2HANYL3KXBt4L0KBA+7xVKmPctCQ0P9fh9fC0uBScb8zPJmu41gYMTPZn9n410NFovFNNdqtVq51jKME+xCQkK4Vh9ZLBYDqvEP98B5yvIaXBt/i15FkZGRbm1f0+DCU9/9/WTQ/PnzdebMGW3cuFFSXgA1b948zZs3z2P/ChUq6PPPP9eLL77oCsyK20fsjTfe0NGjR7V06VLXsYSEBCUkJHjsHxISovnz52vlypWuwMxisahixYquPlfz9TPtDDIAAAAAAK4xudfIsogAAMC8gj/avcpiC33aydf1kAtPLa1atapf9cTExGjNmjUaMWJEqUl8q1attHXrVnXp0kUXLlxwHb/hhhs89rfZbEpISNDzzz9farDXsGFDrV+/Xv3793cbu1q1am5JrZGvX2hoqKKjo306HwAAAAAAAAAAwFcEZoXUqFHDbdpk/rJ/3iq8xm716tX9rikiIkKzZ8/W9u3b9eyzz6p58+aKiYmRzWZTnTp11K9fP3366afavHmzmjRpIsl9g8xatWoVO7bVatXkyZO1e/duPf/887rzzjsVGxur0NBQ1ahRQ71799b777+vxMRE3X333ZLktvlh4bFr1qzp1vbn9YuLiwuKKawAAAAAAAAAAOD6xpKMhYSHh6tWrVpKSkqSJJ831CzYv1atWgoLCzOstubNm2v69Oml9ktKSnLb0K5Zs2alntOgQQNNnjxZkydPLrFfTk6Odu7cWezY9evXl9Vqda0P7uvrd+LECbeaAAAAAAAAAAAAAo0ZZh7Ex8e7vt+/f79yvFxn2+Fw6MCBAx7HuZo2b97s1m7ZsqVhY+/YscNtX7LCY4eFhalRo0au9p49e7weOykpyW1JxvJ6/QAAAAAAAAAAgLkww8yDNm3aaOXKlZKkjIwM7dy5Uy1atCj1vMJhUv4Shv5wOp06f/68rFarKleu7NU5X3zxhet7q9Wqrl27Fts3LS1NDofD673WCo4tSd26dSvSp02bNtq7d68kad++fTp//ryqVKlS6tg//vijW9uI1w8AAAAAAFx7/jR8uMIL7ZteVmFhYRo3bpwBVQWWEasUVatW7Zq4ViPcdNNNQX+tRm010qJFC69WkAoUu92uVatWqUePHsW+J4261g4dOqht27aGjBUoVqsxc1B69eqlnj17GjJWoISEhBgyzmOPPSan02nIWIESGmpMVDJ8+PByu1a73a7Vq1eXy3NfLwjMPOjZs6cmTZrkan/99ddeBWZfffWVW7tHjx5lriEnJ0cNGzZUUlKS7Ha7RowYodmzZ5d6Xnp6uluo1b59e1WrVq1Iv/bt22vLli3KyspSz5499c0333hV06JFi1ztG2+8UbfffnuRfj179tQHH3wgKS/wW758uQYMGFDq+IVfv+7du5d6DgAAAAAAuP6Eh4UpPDzckLEsFothYwU7q9XKtV6HQkJCDAsuysJqtSokJETh4eGGhNglCQ0NNSy4CHaBfi2DiZHbFgW78rxWq9VqWKBrVrx6Htx9992qV6+eqz137ly3mWOeZGRk6J///KerfdNNN6ldu3ZlriEkJESxsbGy2+2S8sIkb5aGnDFjhtLS0lztZ555xmO/mjVrKisrS5K0bt06paamljr2hx9+6Lbk5MiRIz3269OnjypWrOhqz5w5s9RU/eTJk/rkk09c7S5duqhOnTql1gQAAAAAAAAAAOAvc8T1PrJarRo1apTGjh0rSTp27Jh+//vfuwVihY0cOVInT550tUePHu33VOSHH35YW7dulZQXKL377rv63e9+V2z/7777Tq+88oqr3bRpUz3yyCPFjv35559Lkq5cuaKpU6fqzTffLHbsxMREjR492tWuXr26nn76aY99K1WqpMGDB+sf//iHpLw91aZOnaoJEyZ47G+32zVo0CBlZma6jv3xj38sthaULDMrS6+/9JLX/cdmZalC4MoBAAAAAAAAACDoMcOsGKNGjVL9+vVd7ffee0/Dhw/X5cuX3fpdvnxZQ4YMcS1BKEm33HJLsbOvjhw5IovF4vZVnOHDhysmJsbVHjNmjBYuXFikn8Ph0Lvvvqv7779fDodDUt4MtdmzZxc7hblfv35u1zdjxgy9+eabys3NdevndDr12WefqUOHDrp48aLr+FtvvVXinmrPP/+8W+0TJ07UxIkTXTPm8iUnJ6tv37767rvvXMe6dOmivn37Fjs2Smb//38GAtUfAAAAAAAAAIDrDTPMihEZGalFixapW7duysjIkCTNmzdPCQkJ6tOnj2rXrq0TJ07o66+/1oULF9zOW7x4sSFrlVavXl0zZszQsGHDJEnZ2dkaOHCgXn31VXXt2lVRUVFKSkrSt99+q1OnTrmdO3PmTHXs2LHYsSMiIjR37lz16tVLOTk5cjqd+stf/qJ//OMf6tGjh6pWrapTp07p+++/18GDB93OHTt2rPr3719i7TfccIPmz5+vRx991DX+lClTNG/ePPXu3VvVqlXToUOH9PXXX7vNLKtevbo+/PBDX18qAAAAAAAAAACAMiMwK0Hbtm21bNkyPfjgg659wS5cuFBsoFO5cmV98cUXatmypWE1DB06VOfPn9dzzz3n2sMsMTFRiYmJHvtHRkZqzpw5GjhwYKljd+/eXR9++KGGDh3q2qPt8OHDmjNnjsf+oaGheuWVV1xLVZbmoYce0kcffaSnnnrKtV/aqVOnNG/ePI/969Spo5UrV7J3GQAAAAAAAAAAuKpYkrEUXbp00Z49e/TUU0+pQgXPOz2FhYVp0KBB2rlzpzp16mR4DWPGjNH333+ve+65p9g+kZGRGjp0qHbv3u1VWJbviSee0JYtW/Tggw/KavX8x8Fms+mRRx7R9u3bvQ7L8j3++OPauXOnHnzwQdlsNo99oqKi9Pvf/16//PKLmjZt6tP4AAAAAAAAAAAA/mKGmRdq1qyp+fPna9asWVq3bp2OHj2q1NRURUVFqVGjRmrXrl2J+3kVVL9+fTmdTp9raNeundasWaOkpCRt2LBBJ06cUGZmpipXrqxbb71Vbdq0UcWKFX0eV5KaNm2qJUuWKCUlRevXr9eRI0d0+fJlVapUSY0aNVLbtm29vj5PGjZsqCVLlujChQv6v//7P504cUJpaWmqXLmyGjdurLZt25a5dgAAAAAAAAAAAH8RmPmgYsWK6t27d7nWULt2bT322GMBGbtatWp68MEHAzK2lLdkZSDHBwAAAAAAAAAAKAuWZAQAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3ADAAAAAAAAAAAAKZGYAYAAAAAAAAAAABTIzADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmBqBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKmFlncBAAAAAAAAuP6FZWWVdwkAAADFIjADAAAAAABAQIWHh2v8q696f8K4cYErBgAAwAOWZAQAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3ADAAAAAAAAAAAAKZGYAYAAAAAAAAAAABTIzADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmBqBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGXGfCbbaA9gcAAAAAAAAA4HoTWt4FADBWeFiYXnzpJe9PGDYsYLUAAAAAACBJubm5OnTzzV73vyk3l095AwCAq4rADAAAAAAAAAFlt9u1cNAgr/uPs9sVHsB6AAAACuPDOgAAAAAAAAAAADA1AjMAAAAAAAAAAACYGoEZAAAAAAAAAAAATI3ADAAAAAAAAAAAAKZGYAYAAAAAAAAAAABTIzADAAAAAAAAAACAqRGYAQAAAAAAAAAAwNQIzAAAAAAAAAAAAGBqBGYAAAAAAAAAAAAwNQIzAAAAAAAAAAAAmBqBGQAAAAAAAAAAAEyNwAwAAAAAAAAAAACmRmAGAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKkRmAEAAAAAAAAAAMDUQsu7AADGupyZqTdfesnr/n/OzFTFwJUDAAAAAAAAAEDQIzADrjM5ubm+9U9Lk9LTA1QNAJ/Y7QrNyMh7T9ps5V0NAE/sdlmzssq7CgBesGZl8XcqEEwuXizvCgAAAEpEYAaY3b33EpgBQcIm6f7yLgJAiWyS+khy3lhb6nKvNGWKVLdueZcFIN/x49Jfxyl09Zfqc+ZSeVcDoKDwcGn8+PKuAgAAoFjsYQYAAAD4yHIsSfrgA6lpE+mLL8q7HACStHSpdEsD6aNFshCWAQAAAPARgRkAAABQVpcypIH982a1ACg/x49LTzwiXckp70oAAAAAXKMIzAAAAAB/XMqQnn++vKsAzO2v4wjLAAAAAPiFwAwAAADw17o15V0BYG6rvyzvCgAAAABc4wjMgOtNaGh5VwAAgPkcTZIyM8u7CsCcMjMl9iwDrj82W3lXAAAATIbADLjeRESUdwUAAJiT3V7eFQDmxHsPuD5VqFDeFQAAAJMhMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADC10PIuAEA5++kn6YYbyrsKAJLsdrtWrVqlHj16yGazlXc5ANLTpbp1y7sKAEY7flyKji7vKgDzycqS/vGP8q4CAACgWARmgNlFRfELAyBY2O1yREbmvScJzAAACIzoaO5/gfKQlVXeFQAAAJSIJRkBAAAAAAAAAABgagRmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAApkZgBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGqh5V0AAAAAAAAArm8Wi0VxcXFux5xOpy5duqSoqChZLJYi/QEAAK4mAjMAAAAAAAAEVFhYmJ555hm3Y3a7XcuXL1fv3r1ls9nKqTIAAIA8LMkIAAAAAAAAAAAAUyMwAwAAAAAAAAAAgKkRmAEAAAAAAAAAAMDUCMwAAAAAAAAAAABgagRmAAAAAAAAAAAAMDUCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABMjcAMAAAAAAAAAAAApkZgBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpEZgBAAAAAAAAAADA1AjMAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYWmh5F1DYjh079O233+rEiRPKyclR3bp11blzZ7Vu3bq8SwMAAAAAAAAAAMB1KOCBWW5urlauXKnMzEz169ev2H579uzRiBEjtH79eo+PN2nSRDNnztQ999wTqFKB60JERIRqnzjhU38AAAAAAAAAAMwsoIHZRx99pIkTJ+rYsWPq2bNnsYHZ1q1b1aNHD50/f15Op9Njn927d6t79+7661//qsmTJweybOCaFmazafh773l/wvTpgSsGAAAAAABJOTk52rFjR5Fj586d0/bt2xUSEuL2WIsWLYocAwAACKSABGYZGRl68skntWTJElcAtnPnTo99MzMz9etf/1qpqamyWCyyWCzFjut0OjV16lQ5nU5NmTIlEKUDAAAAAADAYA6HQ1999ZXHx44fP17kWLNmzQjMAADAVWU1ekCHw6Ff/epXrrAsPwBLSkpSWlpakf7Tp0/XwYMHXf2cTqfHL0myWCxyOp169dVX9d133xldOgAAAAAAAAAAAEzI8MBs3Lhx+r//+z9JKjJb7JdffnFrX7lyRTNnznQLy4pTODT77W9/q5ycHAMrBwAAAAAAAAAAgBkZGpgdOnSoxACs8LKMn3/+uZKTk4v0zV+aseBX4T6HDx/WsmXLjCwfAAAAAAAAAAAAJmRoYPbee+/JbrdL8jxbrPAMs08++aTYsQovx+jJ+++/X8ZKAQAAAAAAAAAAgDyGBmaff/652zKMBb+3Wq2qVq2aq52RkaGVK1e6+hScSVaxYkWtWLFC6enp+uqrr1S1alW3x/OXZVy3bp2R5QMAAAAAAAAAAMCEDAvMzp07p3379knKmx1WcBnF6tWra/v27Xr55Zdd/Tds2KCsrCxXn4LnjRw5Uj179lRUVJTuv/9+/etf/3Lrky89PV0HDhww6hIAAAAAAAAAAABgQoYFZnv27ClyLD8AS0hIULNmzdwe+7//+79ix3r44Yfd2r169dKNN94oyX3WmlR0XzQAAAAAAAAAAADAF4YFZocOHXJ9n79koiS1aNFC7du3L9K/YGBWMASLjIxUq1ativRv27atx/3MUlNT/SkbAAAAAAAAAAAAJmdYYJaenl7kmMVi0V133VXkeHZ2trZu3eoWlOXPRmvVqpWs1qJl1a1b1+vnBQAAAAAAAAAAALxlWGB26dIlj8erV69e5NjmzZuL7F+Wr127dh7HiYiI8Hg8IyPDlzIBAAAAAAAAAAAAN4YFZrm5uR6Pe1pGsaT9yzp06ODxeHGBXGRkZOnFAQAAAAAAAAAAAMUwLDCLjo72eNzTkomrV692fV9wWcaQkJBiA7N9+/b59LwAAAAAAAAAAACANwIemB04cMCtnZqaqk2bNnncv+zOO+9UpUqVioyRkZGhdevWuZ2Tr2bNmn5WDgAAAAAAAAAAADMzLDC78cYb3doWi0VOp1MbNmxQZmam6/gnn3yinJwcSUWXa+zRo4fHsadMmaLLly97POe2227zu3YAAAAAAAAAAACYl2GBWYsWLVzfFwy1Ll26pD//+c/Kzc3V0aNH9eqrr3qcKSZJv/rVr4oce/HFFzVt2jRXAFfw3NjYWNWpU8eoSwAAAAAAAAAAAIAJhRo1UOXKldWoUSMdOHDALdxyOp2aPXu2PvroI2VmZsrhcHgMv2rXrq277rrL1Z47d66mTp2q48ePF3mu/HP79OljVPnAdePS5cua/tJLXvcfc/myotgLEAAAAAAAAABgYobNMJOkxx9/3G12WcHQ7OLFi3I4HK7jhfs8/vjjbmNt2rRJx44dcxujsAEDBhhZfokOHjyocePGqU2bNoqNjVVYWJjq1Kmjdu3a6ZVXXtGxY8cCXsOFCxc0c+ZM3XfffbrxxhsVERGh6OhoxcfHa8SIEVq/fn2Zx3Y6nfrqq680ZMgQNW7cWJUrV1Z4eLhuuOEGderUSS+88IKOHj3q87hVqlSRxWLx+Ss01LAs13Ryc3MD2h8AAAAAAAAAgOuNoYHZU0895Qo68meP5QdeBb8KPp7//W9/+1u3sZo0aeJ6LD8sKzgzrXXr1rr33nuNLN8jh8Oh8ePHq3Hjxnrttdf0008/6fz587Lb7UpKStKmTZv0/PPPq2HDhpo2bVrAwoc5c+aoYcOGGj16tFauXKnjx48rKytLFy9eVGJioubOnauOHTvqnnvu0b59+3wae8+ePbrzzjv1wAMPaMGCBdq3b5/S0tKUnZ2t06dP64cfftDkyZPVsGFDjRkzRna73atxjxw5ogsXLpThagEAAAAAAAAAAK4eQwOzBg0aaOzYsUVmgxWeUVbwe4vFogEDBqhhw4Zu5zRu3NitXTBgs1qt+tvf/mZg5Z7l5OTo17/+taZNm6acnJwS+9rtdo0fP97wWW+5ubkaOXKknn76aZ07d67U/mvXrlWrVq30zTffeDX+zz//rNatW2vbtm2l9nU4HJoxY4Z69uyprKysUvtv377dqxoAAAAAAAAAAADKk6GBmSS98MIL6ty5c5GZZU6n022mWL5bb71Vs2bNKjJO/gyzwiwWi1577TW1adPG6NKLeOGFF/T555+72lWrVtXMmTN19OhRZWZmav/+/Zo0aZIiIyNdfT7++GNNmTLFsBpefvllzZ492+1Y+/bttXTpUqWkpCgjI0NbtmzRqFGjFBISIkm6ePGiHnroIW3atKnEsVNTU9WnTx9dvHjRdeyOO+5QQkKCUlJSlJWVpb1792rSpEmqWLGiq8/atWs1atSoUmvfsWOH6/uIiAjZ7XbXn4PSvvKX7wQAAAAAAAAAAAg0wwOzsLAwLV++XA888ECRkKzgkoxOp1MtW7bUsmXLVKlSpSLjNGzY0OPyjuPHj9ezzz5rdNlF7Nq1S6+99pqrXbduXW3btk2/+93vXPuHNWzYUBMnTtRPP/2katWqufpOnjxZR44c8buGzZs3a/LkyW7Hxo8frx9++EF9+/ZV1apVVaFCBd1xxx2aNWuWVqxY4Qrvrly5ogEDBujy5cvFjj9lyhSdOXPG1X744Yf1448/ql+/fqpatarCwsJ0yy23aOLEidqwYYMqV67s6vv+++9r69atJdZfcIZZs2bN2JcMAAAAAAAAAAAEJcMDM0mqUKGCli5dqk8++UQdOnSQJLfZQzfddJNeffVV/fjjj6pXr57HMUJDQ3XTTTe5zq1SpYoWLlxo6OytkkyaNMm1DKPFYtHixYtVt25dj32bNWumhIQEV7CXnZ2tSZMm+V3D5MmT3ZawHDx4sKZOneo2Q6+g7t27u83WO3z4sMfZe1LeUo8fffSRqx0XF6f58+fLZrN57N+iRQu9+eabrrbT6dQHH3xQYv0FA7MWLVqU2BcAAAAAAAAAAKC8BCQwy/fII4/o+++/17lz57R9+3b99NNPSkpK0v79+/Xcc88pLCysxPNvueUW1apVS+PHj9fBgwf1xBNPBLJcl5SUFC1ZssTV7tGjh9q2bVviOZ06dVLfvn1d7Y8//rjE2V2lSU5O1vLly13t6Ohovf3226WeN2TIEMXHx7va77zzTpE95SRp//79Sk5OdrX79OnjcaZfQU888YRboPbjjz8W2zctLc1tlh2BGQAAAAAAAAAACFYBDczyVa5cWbfddptatWqlG264wevz5syZo+PHj+uVV15RTExMACt0t3z5cmVnZ7va/fv39+q8gv0yMzP19ddfl7mGtWvXugVdAwYM8Po1GDhwoOv7kydPauPGjUX6nD171q1ds2bNUseNjIx0W3qyYOBWWMH9yyQCMwAAAAAAAAAAELyuSmBWVr6Ea0Zas2aNW/uee+7x6ryuXbu6tQvOEPPVrl27Shy7JK1bt3Zrr1+/vkif8PBwt/axY8dKHTc7O1upqamudnR0dLF9Cy7HKEm33XZbqeMDAAAAAAAAAACUh6AOzMrLf//7X9f3cXFxqlOnjlfnVatWTbVr13a1f/755zLXcO7cObd2gwYNvD63Ro0abu1t27YV6dO0aVOFhoa62suWLVN6enqJ4y5dulRZWVmudknLVBacYVavXj1VqVKl1LoBAAAAAAAAAADKw1ULzC5cuKBPPvnEq75Op1Ndu3bVq6++qt27dwe4sqL27Nnj+r5Ro0Y+nXvzzTe7vj906JDH/cO8UXBJSEmKiory+tyQkBC39tGjR4v0iYqK0gMPPOBqnz9/XsOGDZPD4fA45sGDB/WHP/zB7TmeeeaZYmsoOMOsRYsWys3N1TfffKMhQ4aoSZMmqlSpkiIjI9WgQQM98sgj+vDDD2W32729RAAAAAAAAAAAAMMEPDDbv3+/+vfvr5o1a2rAgAG6cuVKqeccPnxY69at0/PPP6/4+Hjdf//9HvfhCoTU1FS3GgvOGPNGwWUks7KyiuwV5q2qVasWqctbhfcWS0pK8tjvtddec9sX7bPPPlO7du20dOlSpaamyuFw6MiRI3rrrbd011136fTp027nxsfHexzX4XAoMTHR1b58+bJatGihXr16acGCBdq7d68uXbqkzMxMHTlyRAkJCXryySd16623avXq1V5fJwAAAAAAAAAAgBECFpjl5ORo7NixatasmRYvXqzs7Gzl5ubql19+KfXcgvt3OZ1OrVixQh07dtQf/vAHtyUBA6FwwBUbG+vT+ZUrV3Zr+xJ0FVS/fn239tatW70+t/ASjMUttdiwYUOtXLmyyDKSDz30kKpWrSqbzaYGDRro2Wef1fnz5yXlLVG5cOFCjRkzptjn3717t9v/pzVr1mjnzp2l1n3w4EH16tVLs2fPLrWvlBcMJicnKyUlxav+AAAAAAAAAAAAngQkMEtPT1fnzp01ffp0ORwOt2UJC+5tVZyCgZnFYpGUF5zNmjVL9957ry5fvmx80f/fpUuX3NqVKlXy6fzCSydevHixTHV07tzZrb1o0SKvzy289GVJs/ratGmj3bt36/nnn3fb08yTWrVq6YsvvlD//v1L7Ofp/3FERIR++9vfasOGDUpOTlZGRob27dunWbNmuYWDOTk5euaZZ/Tll1+W+BySVL16dVWvXl1NmzYttS8AAAAAAAAAAEBxSk5IyiArK0sPPPCAawnFgoGX5Htg5nQ63cbYtGmT+vTpo2+//VZWq/F5X+EZbDabzafzC/cv675cjRs3VvPmzV0z8jZt2qRPPvlEjz32WInnLVu2TOvXr/e6hvPnz2vq1Kl67733it2/LN/JkyfVrl079e/fX3//+9+LzKbLV3D/Mkm66aablJCQoJYtW7odb9SokRo1aqRhw4Zp0KBB+uyzzyTl/X8ePHiwDh06pCpVqpRYU3Hsdrtp90Szl/L/0VN/s75WQLDJfy/yngSChN0uX+4E7Xa7xPsXuPp4rwLXBF/vce12e0B+7wPAd/xbFbg28F51V5bXwfDAbPLkyfr+++9dIVdh3gRmBfe/kv4XtlksFjmdTq1bt07Tp0/XX/7yF/8LLiQnJ8et7evNWeH+ubm5Za5l/PjxbrO5hg0bptjYWHXr1s1j///85z8aPHhwkeNhYWEe+//yyy/61a9+pWPHjknKe30ff/xxDRs2THfccYciIyN1/PhxffPNN3r99dd1/PhxSXmz3bZs2aLvv/9e1atXLzLurbfeqoceekiHDh1SamqqvvnmGzVq1KjY64yIiNCiRYt04sQJ/fjjj5KkCxcuaPr06ZoyZUqx55Xk22+/ddufzUxy09J86v/9unWymvS1AoIV+zkCwSE0I0P3+9D/u6VL5YiMDFg9ADwLzchQTx/6r1q1ivcqUA4K/76lNKtWrVJISEiAqgFQFvxbFbg28F7Nk+bj78klyeIsuF6in44cOaImTZq4kruCQVd+OyYmxrUfVnEqVaqkjIwMV9vTOBUqVNDhw4c9Bjb+2Lhxo9q3b+9qjxs3Tq+++qrX5z/33HN6/fXXXe3NmzerdevWZa6nX79+WrJkiasdEhKip556SkOHDlXz5s0VEhKiffv2aeHChZo5c6aysrJUpUoVVa9eXXv37pUkxcTE6MKFC27jnjlzRrfffrtOnTolKS+0+vjjj9W3b1+PdVy6dEmPP/64li1b5jrWuXNnrV27tthw1FebN2/W3Xff7WrXr19fhw8fLrZ/Sc+blJSkuLg4Q+q61qSfPKlZCxZ43f93Tz2l6Fq1AlcQAK/Z7XatXr1a3bt393mGM4AASE+XrVq18q4CgMHsKSlSdHR5lwGYTlZWlqZPn+51/zFjxig8PDyAFQHwFv9WBa4NvFfdJScnq3bt2m7Hzp49W2JuYOgMs/fee0/Z2dmumWCepKen6+jRo6pXr57Hxy9evKi77rpLP/74o65cuSKLxeIar+DyjFeuXNGCBQs0duxYIy9BkYU+aVjS/l+eZGZmurX9vbmbP3++zpw541riMicnR/PmzdO8efM89q9QoYI+//xzvfjii67AzNM+bM8995wrLJOkv//978WGZVLe3myfffaZOnTooC1btkiS1q1bp88++0yPPvpoma+voDZt2qhJkybas2ePpLwA9uDBg7r55ps99j979qwkKSUlpcg+ZjabzbQ/FGyl7EXnqb9ZXysgWJn5ZxgQVHgfAtclm83G+xsoB76uwMM9MRB8eF8C1wbeq3nK8hoYuhj0woUL3Wb9FAy7bDab/vznP+uXX34pNiyT8sKd7777TqdOndJrr72mqKgo11gFOZ1O/etf/zKyfElSbGysWzs9Pd2n8y9evOjWrlq1ql/1xMTEaM2aNRoxYkSpy0O2atVKW7duVZcuXdxmlN1www1u/VJTU/Xvf//b1b7ttts0ZMiQUmuJiIjQ3/72N7dj7733XukX4YM2bdq4tUuaYRYXF6e4uDhV45PfAAAAAAAAAADAD4YFZqdPn9bRo0clyW0mmNPpVFRUlNatW6fXX3+9yEyg4sTExOgvf/mLNmzY4NqLKj98yx97z549ZVqHsiQ1atRwC+fyZzF568yZM25tI5aMjIiI0OzZs7V9+3Y9++yzat68uWJiYmSz2VSnTh3169dPn376qTZv3qwmTZpIktvssVqFlttbv369srOzXe3HHnvM62UVO3To4BZ4btiwwed1yEtSo0YNt3ZKSophYwMAAAAAAAAAAHhi2JKM27ZtK3IsP9x6+eWXi8wc8lZ8fLymTp2qZ555xmOo85///Ef33ntvmcb2JDw8XLVq1VJSUpIk6fjx4z6dX7B/rVq1FBYWZlhtzZs392q976SkJCUnJ7vazZo1c3v8wIEDbm1vQ8x8t912myscvXz5slJSUooEXWVVeClP1isHAAAAAAAAAACBZtgMs5MnT7q+LxhsWa1WDRs2zK+xBw4cqJCQkCJjS74HWt6Ij493fb9//36vZ1A5HA63MKrgOFfT5s2b3dotW7Z0axfely3/tfVW/jKZ+ex2u1s7LS1N+/bt0w8//KB9+/b5NHbhGX0stwgAAMoNa74D1yfe2wAAAAA8MCwwK25pxDp16ig6OtqvsaOionTjjTd6fKzgXl1GKTgbLiMjQzt37vTqvB07driFUXfffbfftTidTqWmpvp0nV988YXre6vVqq5du7o9XjiEOnbsmE81FV52Mi4uzvX9l19+qcqVK6tx48bq1KmTpk6d6tPYP//8s+t7q9Wq2267zafzAQAADFOhglSbD+8A15Wqtrz3NgAAAAAUYlhgVnBPrIKMWpKwuD22MjMzDRm/oJ49e7q1v/76a6/O++qrr9zaPXr0KHMNOTk5atCggcLDw1W1alWNGzfOq/PS09PdArP27dsXCcgaN27s1l6xYoXXdWVlZbnNYGvYsKHbsomFA67Vq1crNzfXq7F37dql3bt3u9p33nmna/86AACAcnFPr/KuAICRejxU3hUApmWxWHTzzTe7fTVo0ECVKlVSgwYNijzm7V7rAAAARjFsD7OqVat6PH7q1Cm/x3Y4HMWOExsb6/f4hd19992qV6+ea5+uuXPnasyYMYqIiCj2nIyMDP3zn/90tW+66Sa1a9euzDWEhIQoNjZWR44ckZQXxv39738vdfnEGTNmuM32e+aZZ4r0ad++vWJiYlz9Vq1apd27d+vWW28tta45c+bo8uXLrvb999/v9nj9+vUVHx/vmpV38uRJJSQk6NFHHy117BdffNFtD7MRI0aUeg4AAEBAvfKKlPCJlJFV3pUA8Fe4RXq99D2hAQRGWFiYBg4c6HbMbrdr+fLl6t27t2wslwoAAMqZYTPMCi7LVzD0uHz5sjZt2uTX2KtXr3bNJCs4duHnNYrVatWoUaNc7WPHjun3v/99ieeMHDnSbR+30aNH+/1pqIcfftj1/cmTJ/Xuu++W2P+7777TK6+84mo3bdpUjzzySJF+oaGhbkGaw+HQoEGDdOnSpRLH37Fjh/7617+62jabTaNHjy7S7ze/+Y1b+9lnn9Xp06dLHPudd97RZ5995mrfdNNNGjBgQInnAAAABFzdutKixVJkeOl9AQSvcIu0eIlUp055VwIAAAAgSBkWmNWrV6/YxyZPnlzmcXNycjRx4sRiH69bt26Zxy7JqFGjVL9+fVf7vffe0/Dhw91mV0l5geCQIUP0wQcfuI7dcsstGjlypMdxjxw5IovF4vZVnOHDh7stSThmzBgtXLiwSD+Hw6F3331X999/vxwOh6S8GWqzZ89WaKjnSYTPPfec22u3ZcsWtWnTRj/99FORvk6nU4sWLVLnzp3drv8vf/mLbrrppiL9R44cqaZNm7raJ06cUMeOHT2OffnyZY0ZM0Z/+MMfXMesVqvef//9Emf0AQAAXDV9+0p79kuDBslZx/gPawEIHGe1MOmJx6T9R/PeywAAAABQDMOWZGzZsqWqVq2q1NRUWSwWOZ1O139XrlypiRMn+hycZWdn66mnntLWrVvdxswXExOjO++806hLcBMZGalFixapW7duysjIkCTNmzdPCQkJ6tOnj2rXrq0TJ07o66+/1oULF9zOW7x4sSF7t1WvXl0zZszQsGHDJOW9HgMHDtSrr76qrl27KioqSklJSfr222+LLFk5c+ZMdezYsdixY2Ji9PXXX6tDhw66ePGipLw9xNq0aaPbb79dd955p+Li4nTmzBmtXbtWhw8fdju/T58+xf7/tNlsSkhIUIcOHXTu3DlJ0oEDB9SmTRu1a9dOrVu3Vnh4uA4dOqSVK1cqPT3dda7FYtF7772nzp07+/6CAQAABErdutIHH8hht+ubJUt03733snQUEMTsdru+WbNG9z30EO9VAAAAAF4xLDCzWCzq1q2bFi9e7Aq1CoZmU6dO1ebNmzV+/Hh17dq1xLHS0tK0ZMkSvfrqqzpw4IBrrHz54957772yWg2bJFdE27ZttWzZMj344IOu/b4uXLigDz/80GP/ypUr64svvlDLli0Nq2Ho0KE6f/68nnvuOeXk5EiSEhMTlZiY6LF/ZGSk5syZU2RdcE9uu+02bdq0SQ899JD279/vOr5t2zZt27at2POeeeYZ/e1vfyvxtW/SpInWrl2rRx99VHv37nUd37hxozZu3OjxnJiYGM2aNcur2gEAAMpLbni4FB0t8Ut4IHjZ7XnvVQAAAADwkqFp09ChQ4scKxiarVmzRt26dVNsbKw6d+6sJ598UqNGjdLo0aM1dOhQPfTQQ7r11lsVFxenYcOGaf/+/UVmlRU0ZMgQI8v3qEuXLtqzZ4+eeuopVahQwWOfsLAwDRo0SDt37lSnTp0Mr2HMmDH6/vvvdc899xTbJzIyUkOHDtXu3bt9CpyaNWum7du3a/r06SUuqxkSEqIePXrohx9+0N///nevPqXZvHlzbdmyRdOmTVPt2rWL7Ve5cmUNHz7c59oBAAAAAAAAAACMYNgMM0nq3r27OnbsqPXr17tCMsk9NJPyZmmtX79e69evLzJGwZlkBWeq5bfzx2rbtq169+5tZPnFqlmzpubPn69Zs2Zp3bp1Onr0qFJTUxUVFaVGjRqpXbt2qly5sldj1a9f3+0avdWuXTutWbNGSUlJ2rBhg06cOKHMzExVrlxZt956q9q0aaOKFSv6PK6UF7Y9++yzevbZZ7V371795z//UXJysjIyMlSlShXVrVtXHTt2dNtPzVsVK1bUc889p7FjxyoxMVFbt25VcnKyHA6HatSooXr16qlDhw4skwIAAAAAAAAAAMqNoYGZJL355pvq2LGj7Ha7x9AsX3GhUeHZZAXDsnw2m03Tp083uvRSVaxY8aqFdMWpXbu2HnvssYCN37hxYzVu3NjwcS0Wi+Lj4xUfH2/42AAAAAAAAAAAAP4wfAOwu+66S//85z89Bl1Op9PtuKcvT30LHrNYLHr33XfVpk0bo0sHAAAAAAAAAACACRkemEnSoEGDNG3aNFcAVlwYVtJXvvxz88OyKVOmXJW9ywAAAAAAAAAAAGAOAQnMJGns2LFasWKFqlWr5nFWWUkK93M6napWrZqWLVum8ePHB6pkAAAAAAAAAAAAmFDAAjNJ6t69u3bu3Klx48YpJibGqyUZC4ZkTqdT0dHReu6557Rz507dd999gSwXAAAAAAAAAAAAJhQa6CeIi4vT1KlTNWHCBCUkJGjdunX64YcfdODAgWLPuemmm9SpUyd16tRJjzzyiKKiogJdJgAAAAAAAAAAAEwq4IFZvooVK+rJJ5/Uk08+KUm6cuWKzp07p9TUVF28eFFRUVGKjY1V1apVVaFChatVFgAAAAAAAAAAAEzuqgVmhUVERKh27dqqXbt2eZUAAAAAAAAAAAAABHYPMwAAAAAAAAAAACDYldsMMwCBEVmhgu7etMn7/r//fQCrAQAAAAAAAAAg+BGYAdeZ0NBQ9Vy50pcTAlcMAAAAAACSHA6H1q9f73YsJydHp06d0vfff6+QkBC3xzp06KBQ/r0KAACuIu48AAAAAAAAEFA5OTlat26dx8fOnDlT5Fjbtm0JzAAAwFVV6p3H0KFDPR63WCyaN2+eV30DxVMNAAAAAAAAAAAAgC9KDcwWLFggi8XidszpdHoMqzz1DZTiagAAAAAAAAAAAAB84fXcdqfT6fWgvvQFAAAAAAAAAAAAypPXgVnBmWOlBWJXY5YZoRwAAAAAAAAAAACM4PMMM2/CsECHWVdr2UcAAAAAAAAAAABc/6zlXQAAAAAAAAAAAABQnsq0JKORfQEAAAAAAAAAAIDy5FVg5ssSi+wtBgAAAAAAAAAAgGtJqYFZbm6u14P50hcAAAAAAAAAAAAIBuxhBgAAAAAAAAAAAFMjMAMAAAAAAAAAAICpGRqY/fzzz3rnnXd06tQpI4cFAAAAAAAAAAAAAsbQwOyll17Sn/70J9WtW1ddunTR7NmzlZKSYuRTAAAAAAAAAAAAAIYyLDA7d+6cVq1aJUnKzc3VDz/8oFGjRqlWrVq67777tGLFCqOeCgAAAAAAAAAAADCMYYHZpk2blJOTI0myWCxyOp1yOp1yOBxavXq1QkJCjHoqAAAAAAAAAAAAwDChRg108OBBt7bFYpEkOZ1ONW7cWD169DDqqQCUIP3SJb310kte9//TpUuKjo4OXEEAAAAAAAAAAAQ5w2aYZWVlub53Op2u/1osFt1zzz1GPQ2A0vz/91/A+gMAAAAAAAAAcJ0xLDCrV69esY9VrFjRqKcBAAAAAAAAAAAADGVYYNaxY0fZbDZJ/1uOMd++ffuMehoAAAAAAAAAAADAUIYFZrVq1dKgQYNcyzFKecGZ0+nUihUrdOTIEaOeCgAAAAAAAAAAADCMYYGZJP3tb39Tq1at3EIzScrOzla/fv109OhRI58OAAAAAAAAAAAA8JuhgVlUVJTWrl2rhx9+2BWaWSwWWSwWbd++XbfeequGDx+ulStXKi0tzcinBgAAAAAAAAAAAMok1MjBUlNTJUlz5szRXXfdpZdeeklZWVmux69cuaL58+dr/vz5kqTY2FjdcMMNqlKliipVqqTIyEiFh4crNDS0yD5onlgsFs2bN8/ISwAAAAAAAAAAAIDJGBqYVatWrUjQVXCmWcG2JJ07d07nzp3zKhwrzOl0EpgBAAAAAAAAAADAb4YGZpKK7F9W8Hj+8oyFjxd3DgAAAAAAAAAAABBohgdmxc0wK/x9ft+yzC7zNBYAAAAAAAAAAABQFoYHZpL3YVZZQ6+yhmwAAAAAAAAAAABAYdbyLgAAAAAAAAAAAAAoTwGZYcYMMAAAAAAAAAAAAFwrDA/M2FsMAAAAAAAAAAAA1xJDA7Pc3FwjhwMAAAAAAAAAAAACjj3MAAAAAAAAAAAAYGoEZgAAAAAAAAAAADA1AjMAAAAAAAAAAACYmqF7mB07dszj8erVqysiIqLM46anp2v//v06ceKEjh8/7vpv7969NWDAgDKPCwAAAAAAAAAAABgamNWvX18Wi6XI8U8//VT9+vUr87hffvmlBg8eXOT43r17CcwAAAAAAAAAAADgF8OXZHQ6nW5fRujdu7fH8bdv367z588b8hwAAAAAAAAAAAAwJ8MDM4vF4voySmxsrGrVquU2vpQXnm3dutWw5wEAAAAAAAAAAID5GB6YSTJsZllBOTk5Ho8fOnTI8OcCAAAAAAAAAACAeRi6h1mgzJgxQ6dPn5bFYpHT6XSbvXbhwoXyKwwAAAAAAAClslqtuv32292O5ebm6vjx46pbt66sVmuR/gAAAFdTqYHZyZMn1bVrV9nt9jI/yTPPPKM///nPPp2Tm5urrKwspaWlKSsrS5LnmWu5ubllrgsAAAAAAACBZ7PZ9MADD7gds9vtWr58uXr37i2bzVZOlQEAAOQpNTCrVauW+vbtqzfffNOrAfNDrYL/PXv2rB8l5smfXVZYtWrV/B4bAAAAAAAAAAAA5uXV/PYXX3xRtWrVksViKfGrOKWd581Xcfui3XLLLWW7cgAAAAAAAAAAAEBeBmYVK1bU66+/XmxoFWgFn7dgMBcTE6N27dqVR0kAAAAAAAAAAAC4Tni9g2r//v3VsWNHt6UWC38Vx1NfX748jWexWPSb3/xGISEhZbhsAAAAAAAAAAAAII/XgZkkzZw50xVQXe0lGQs/x80336wJEyaU8bIBAAAAAAAAAACAPD4FZrfddptGjhzp9UywfP7OMCv8dd999+m7775TdHS03y8AAAAAAAAAAAAAzC3U1xMmT56svXv3Kjs7u8hj69atk8VicS2ZmP/fW2+9VXFxcT49j8ViUUhIiMLDwxUVFaW4uDjddttt6tq1qxo2bOhr2QAAAAAAAAAAAIBHPgdmMTExWrlypcfHrFbPE9YmTZqkfv36+fpUAAAAAAAAAAAAQMD5tCSjt0razwwAAAAAAAAAAAAIJj7PMCtN4b3MStrbDAAAAAAAAAAAAChvhgZma9eu9Xi8WbNmRj4NAAAAAAAAAAAAYBhDA7POnTsbORwAAAAAAAAAAAAQcAHZwwwAAAAAAAAAAAC4Vhi+h5k3Dh48qB07dujAgQM6deqUUlNTdeXKFeXm5urTTz919UtLS1OFChUUFhZWHmUCAAAAAAAAAADABK5aYLZ69Wr9+9//1rJly5SSklLkcafTKYvF4nbs3//+t1544QX95je/0dixYxUTE3O1ygUAAAAAAAAAAIBJBDwwW7ZsmZ577jnt3r1bUl4w5q2dO3cqJSVF06ZN07x58/S3v/1Njz/+eKBKBa4LFSMj9UiBmZql9h89OoDVAAAAAAAAAAAQ/AIWmGVmZmrEiBFauHChpP8FZYVnkeXzFKQlJia6Hjt79qwGDBigbdu26bXXXgtQ1cC1LyQkRM3+/3vHyxMCVwwAAAAAAJLsdrtWrFjhdiw3N1fHjx/XsmXLZLVa3R7r1auXbDbb1SwRAACYXEACs4sXL6pXr17atGmTx6CscDhWXIiWmJhY5Lw333xTVqtVr776agAqBwAAAAAAgNFyc3O1bds2j4+lpqYWOdazZ89AlwQAAODGWnoX3+Tm5uqxxx7Txo0bXfuSWSwWOZ1O15dUfEiW7+zZs669zgqe43Q69frrr2vJkiVGlw5cHypVktLS3L7sKSlatmiR7CkpRR5TpUrlXTEAAAAAAAAAAOXK8MBsxowZWrlyZZGgTJLrWGlhmfS/5RjzFQ7N/vjHP+rKlStGlw9c+ywWKTq6yJcjMtLjcXnxfgQAAAAAAAAA4HpmaGB27tw5vfzyy65ArODSi4VnmeWvQ11ceLZz5063cwuPd+LECS1YsMDI8gEAAAAAAAAAAGBChgZmf//733X58mVJKjKrzOl0qn379kpISFBycnKps8Pi4+N11113FdnvLJ/T6dS//vUvI8sHAAAAAAAAAACACRkamC1atMhtxlh+UCZJY8eO1Q8//KCHHnpIVatWLXWsrl27avPmzZo7d26RpRzz//vzzz8rPT3dyEsAAAAAAAAAAACAyRgWmCUlJWnfvn2S8mZ/5YdlFotFvXr10rRp08o07vDhw/XHP/7RFbwVnHHmdDq1ZcsW/4sHAAAAAAAAAACAaRkWmG3fvr3Yx1566SW/xn722WeLfezQoUN+jQ0AAAAAAAAAAABzMywwO3r0qOv7gssyxsTEqFWrVn6NXatWLdcyjgXHlqS0tDS/xgYAAAAAAAAAAIC5GRaYFbeXWPXq1Q0ZPzY21uPxK1euGDI+AAAAAAAAAAAAzMmwwMxms3k8fuHCBUPGP3PmjMfjFSpUMGR8AAAAAAAAAAAAmJNhgVmNGjVc3zudTtf3ycnJOnjwoF9jb9u2zTWDreDYkhQXF+fX2AAAAAAAAAAAADA3wwKzWrVqFfvYW2+95dfYJZ1/8803+zU2AAAAAAAAAAAAzM2wwKx169YKCwuTJFksFtd/nU6nZs+erc8++6xM4y5evFgfffSRa6z8saW8ZSBvv/12/4sHAAAAAAAAAACAaRkWmEVFRalr166uJRPz/2uxWJSbm6snnnhCf/3rX3X+/HmvxsvMzNSUKVM0aNAgt5Asf2yLxaJ27dopIiLCqEsAAAAAAAAAAACACYUaOdhTTz2llStXutoFQ7OcnBy99tprmj59um6//XbVrVvX4xgjR47UsWPHtH79el26dMkVjhXeu0ySBg0aZGT5wHXB6XTq4sWLbsfsdruys7OVnp4um83m9lilSpWKhNIAAAAAAAAAAJiJoYHZr3/9a7311lv6+eefi4Rc+W273a6ffvpJP//8syS59XE6nZo7d67b8YLjFPylfp06dTRw4EAjyweuCxcvXix2379du3YVOfanP/1J0dHRgS4LAAAAAAAAAICgZdiSjPneeecd1wyW/ICrYOBV+FhhTqfTNavM06yX/MemT59eZKYMAAAAAAAAAAAA4CvDA7PWrVtrwYIFrnbBgMxTcFZY4VCt8Owyi8Wi3/zmN3rkkUeMLh0AAAAAAAAAAAAmZHhgJkmPP/64Zs2apZCQEEmeQ7DSZpgVNyvtiSee0LvvvhuIsgEAAAAAAAAAAGBCAQnMJGnkyJFat26d6tatWyT8KmmGWeF+Ul5QFhkZqTfeeEMfffRRiecCAAAAAAAAAAAAvghYYCZJbdu21X//+1+98soruuGGG4qdPeYpSMvvFxYWpoEDB2r37t0aM2ZMIMsFAAAAAAAAAACACYUG+gmio6M1fvx4/fnPf9aXX36ptWvXav369dq5c6dyc3M9nlOnTh3ddddd6tatm5544glVrlw50GUCAAAAAAAAAADApAIemOWz2Wx6+OGH9fDDD0uS7Ha7zp07p/Pnz+vChQsKCwtTTEyMqlWrRkAGAAAAAAAAAACAq+aqBWaF2Ww21axZUzVr1iyvEgAAAAAAAAAAAIDA7mEGAAAAAAAAAAAABDsCMwAAAAAAAAAAAJgagRkAAAAAAAAAAABM7arsYZaSkqKDBw8qOTlZGRkZys7OVm5uriFjP/nkk4aMAwAAAAAAAAAAAHMKWGCWmpqqN998Ux9//LGOHj0aqKchMAMAAAAAAAAAAIBfAhKYLVu2TE899ZRSU1PldDoD8RSSJIvFErCxAQAAAAAAAAAAYA6GB2ZffPGFHn30UTkcDkmBC7UCGcQBAAAAAAAAAADAPAwNzJKSkvTUU0/J4XC4BWVGh1vMLAMAAAAAAAAAAIBRDA3Mpk6dqrS0NFegxSwwAAAAAAAAAAAABDvDAjO73a6FCxcWG5YxKwwAAAAAAAAAAADByLDA7Oeff1Z6erosFkuxYRkzzgAAAAAAAAAAABBsDAvMdu3aVeRYwaCsUqVK6tu3r26//XbVrl1b0dHRCg8Pl9VqNaoEAAAAAAAAAAAAwGeGBWapqalu7YIzzZo3b67Vq1erevXqRj0dAAAAAAAAAAAAYAjDpnfl5uZ6PG6xWDRv3jzCMgAAAAAAAAAAAAQlwwKzmjVrur7PX4pRkuLi4tSqVSujngYAAAAAAAAAAAAwlGFLMhYXikVFRRn1FAAAAAAAALgGhYSEqHPnzm7HcnJytH//fjVq1EghISFF+gMAAFxNhgVm8fHxatSokQ4cOOB2/NixY7Lb7bLZbEY9FQAAAAAAAK4hoaGh6tKli9sxu92uS5cuqVOnTvzeCAAAlDvDlmSUpGeffVZOp9PtWE5OjhYuXGjk0wAAAAAAAAAAAACGMTQw+81vfqPbb7/d1bZYLHI6nXrppZd05swZI58KAAAAAAAAAAAAMIShgZnVatUnn3yiypUrux0/duyYunXrpp07dxr5dFfVwYMHNW7cOLVp00axsbEKCwtTnTp11K5dO73yyis6duxYwGu4cOGCZs6cqfvuu0833nijIiIiFB0drfj4eI0YMULr168v89hOp1NfffWVhgwZosaNG6ty5coKDw/XDTfcoE6dOumFF17Q0aNHyzz+jh07NHr0aLVs2dI1dv369dWlSxe9/fbbSk5OLvPYAAAAAAAAAAAA/jBsD7N8N998s1asWKEePXooPT1dFotFkpSYmKiWLVuqT58++tWvfqX4+HjVqVNHVapUUUREhKxWQ7M7wzgcDk2cOFFvvPGGcnJy3B5LSkpSUlKSNm3apJdfflmTJk3S2LFjA3Itc+bM0YQJE3Tu3Dm341lZWUpMTFRiYqLmzp2rrl27avbs2brlllu8HnvPnj3q37+/tm3bVuSx06dP6/Tp0/rhhx/06quvavTo0Zo2bZrXa4tfvnxZo0eP1vvvv1/ksaNHj+ro0aNat26dnn/+eb3zzjsaMmSI13UDAAAAAAAAAAAYISApVevWrbVhwwbVqVPH7Xhubq6+/PJL/fa3v1W7du104403qlKlSrLZbAoJCfH5KzTU8LzPTU5Ojn79619r2rRpRcKywux2u8aPH68BAwYYWkNubq5Gjhypp59+ukhY5snatWvVqlUrffPNN16N//PPP6t169Yew7LCHA6HZsyYoZ49eyorK6vU/pcuXVLPnj09hmWe+g4dOlTjxo3zqm4AAAAAAAAAAACjBCQwczgc+te//qXTp0+7jlksFteeZkZ+BdILL7ygzz//3NWuWrWqZs6cqaNHjyozM1P79+/XpEmTFBkZ6erz8ccfa8qUKYbV8PLLL2v27Nlux9q3b6+lS5cqJSVFGRkZ2rJli0aNGqWQkBBJ0sWLF/XQQw9p06ZNJY6dmpqqPn366OLFi65jd9xxhxISEpSSkqKsrCzt3btXkyZNUsWKFV191q5dq1GjRpVa+4gRI7RhwwZXu169elqwYIFOnTqljIwM/fLLLxozZoxb8Pnaa6/pww8/LHVsAAAAAAAAAAAAoxgemKWnp6tLly6aPn26cnJyioRb+cGZv1+BtmvXLr322muudt26dbVt2zb97ne/c+0f1rBhQ02cOFE//fSTqlWr5uo7efJkHTlyxO8aNm/erMmTJ7sdGz9+vH744Qf17dtXVatWVYUKFXTHHXdo1qxZWrFihSu8u3LligYMGKDLly8XO/6UKVN05swZV/vhhx/Wjz/+qH79+qlq1aoKCwvTLbfcookTJ2rDhg1ue9O9//772rp1a7Fjr1q1SosWLXK1W7RooR07dmjw4MGqWbOmKlSooPj4eL355pv69ttvVaFCBVffP/3pT24hHgAAAAAAAAAAQCAZGpg5nU49/PDD2rhxo8fZX9fCrLJ8kyZNci3DaLFYtHjxYtWtW9dj32bNmikhIcEV5GVnZ2vSpEl+1zB58mS36x08eLCmTp1abGDYvXt3zZo1y9U+fPiwW7ug3NxcffTRR652XFyc5s+fX+zeZC1atNCbb77pajudTn3wwQfF1v7CCy+4vo+IiNCSJUsUExPjsW/nzp01Z84cV/vcuXN66623ih0bAAAAAAAAAADASIYGZv/85z+1Zs2aqzYLLFBSUlK0ZMkSV7tHjx5q27Ztied06tRJffv2dbU//vjjEmd3lSY5OVnLly93taOjo/X222+Xet6QIUMUHx/var/zzjseQ8b9+/crOTnZ1e7Tp48qVapU4thPPPGEW6D2448/euz33//+V5s3b3a1Bw8erAYNGpQ49qBBg9SyZUtXe968eSX2BwAAAAAAAAAAMIqhgdlrr73mCso8zQa7VpZjXL58ubKzs13t/v37e3VewX6ZmZn6+uuvy1zD2rVr3V6//8fefcdHVeX/H39POiGQEAg9dASBCBZAEGkLCLgKWJBedRGxfUURVtEVLLiKDVwQRWAVFBSxUBRERBEUBaT3TugkoaTOJPP7g1/uzk0mySRzBxLn9Xw85uGcO/ec+5mBwUzec87p379/njO0chowYIBx//jx41q7dm2uc06fPm1qV65cucBxw8PDTUtPugZurr788ktTuyiv35EjR0yhGwAAAAAAAAAAgK9YFpht3rxZBw8elKQ8g7Lsx4r7sowrV640tTt27OhRvw4dOpjarjPECmvHjh35jp2fFi1amNpr1qzJdU5oaKipfeTIkQLHzcjIUEJCgtEuW7as2/NcX7+wsLACZ+dls/L1AwAAAAAAAAAA8FSQVQNt2rTJ7XHXoCwiIkINGjRQpUqVFBERoeDgYAUFWVaCZbZs2WLcj4mJUfXq1T3qV6FCBVWrVk3x8fGSpN9//73INZw7d87ULmhJQ1eVKlUytd392TRq1EhBQUFyOBySpCVLlujChQt5hmDS5Zlj6enpRjuvIMz19YuLi8tzX7Sc4uLiFBAQoKysLEnevX4AAAAAAAAAAACesiytyrnEn2tQFh4ernfeeUeDBw9WYGCgVZf0mV27dhn369evX6i+devWNQKzAwcOyOl0FmkZSdclISUpIiLC4745X+PDhw/nOiciIkJ33nmnvvjiC0lSYmKihg8frk8++cRtiLl//3499thjpms89NBDuc47efKkkpKSjHZhXr/Q0FBVr17dmO22b98+j/sCAAAAAAAAAAAUlWWBmbtlErPDovfff199+/a16lI+lZCQoLS0NKNdrVq1QvWvUqWKcT89PV2nT5/ONePLE+XLl89Vl6dy7i2WHeDl9Oqrr2rlypU6f/68JOnzzz/X4cOH9c9//lNt27ZV2bJldezYMS1atEgTJ05UYmKiqW+TJk1yjXn8+HFTuyivX3ZgdvTo0XzPzX6eZ8+eLdQ14LmsrCzZ7farXUaBci4xWhQl4bnabDaFhIR4PU5mZqYxu7S4suq5OhwOZWZmWlCR7wQEBHg8Ezc/drvdmKFbXAUGBloyszwjI8PnyzN7KygoyJIvCZWE5xocHKyAAO9X+XadxV5cWfFeBXDlZGVlKT09XVlZWZb8W+V0OnN9sbE4CgkJ8Xrv75Lws7HE54DCKo6fA0rCz7AAAMB/WBaYVa5c2bjv+sN56dKl1adPH6su43M5Z8pFR0cXqn9UVJSpnZCQUKTArFatWqb2xo0b1bp1a4/65lyC8cKFC27Pq1evnr777jvdfffdpmUke/XqlefYMTExeuutt9SvXz+3j1v5+qWlpSk1NVWlSpVye27FihULNTYK7+zZs5o2bdrVLiNfISEhGjdunNfjHDhwQHPnzrWgIt+JiYlxO7OzsDZv3qxvvvnGgop8p27duhowYIDX46xZs0arV6+2oCLfuf7663XnnXd6Pc6yZcvyXB65uGjXrp3at2/v9TgLFizQ/v37vS/Ih+644w7dcMMNXo/zwQcf5PoiTHHTv39/1atXz+tx3njjjWL/i+iRI0eqXLlyV7sMAPk4f/68Vq1apSNHjigxMdFYLn7kyJFef37IyMjQpEmTrCjTp8aOHet1kMTngOLlr/w5IDo62vTFYwAAgKvJssAsr18KVa5c2etvt11Jly5dMrXLlClTqP45l068ePFikepo166dqT1v3jw9/PDDHvVdsGCBqe06Yy6nli1baufOnfr3v/+tSZMm5ftts6pVq+rzzz/Pc+8yyTevX16BWX7sdnux/5agr4SFheX6u+JwOPTTTz+pbdu2uWZ3hIWF5flaFbdvH+bFij/r4j4LSbr8rWZ/ea5WfdO3pD3XnP8t7DjFXWZmpiV/rv70XIv77DLJuudaEjgcDq/epwB8a/fu3Vq8eLHbGauu79+iKinve7vd7vVsOj4HFC9/1c8B0dHRuu+++7Ru3boS8/4C/BU/AwMlA+9Vs6K8DpYFZnFxcapTp44OHjxoOn7y5EmrLnFF5PxwVdild3KeX9S/nA0aNFBcXJy2bt0qSVq3bp0WLFig3r1759tvyZIlWrNmjcc1JCYm6uWXX9YHH3xQ4Iei48ePq3Xr1urXr5/efffdXLPppOLz+n3//feKjIwsUt+/qpCQEP3666+F6pOamuqjaqzjcDi0dOlSr8fJayZmcXLp0iVLnuu5c+csqMa3zp49a8lzPXHihAXV+NbRo0dzPdcVK1YUaZzibu/evbm+WFEUJWEp3q1bt+ZaprgorHi9fG39+vWm/V+LqiT8cvann34yvshTlPcpAN/JyMjQrl278vxShev7t6iKW9iQl+XLl3u9LDCfA4qXv+rngJSUFH388ceS5Hb1gFq1almyxDUA6/AzMFAy8F69LHsrqsKwLDCTpMcee0yPPfaYaUZZcnKytmzZouuuu87KS/lMzg9Bhf1mXs7zvfkW/Lhx40xLHw4fPlzR0dHq1KmT2/P/+OMPDR48ONfxvNY637p1q/7+978be4bZbDb16dNHw4cP1w033KDw8HAdPXpU3377rf79738bv4ydN2+eNmzYoJ9++inXsibF5fXr1KmTYmJiitT3r8hut2vFihXq3LlzoULMM2fOaPfu3T6szHtBQUHq3r271+McOHBABw4csKAi34mIiLDkuf7555/FPlypUKGCJc/1p59+0qlTpyyoyHdiY2ON51rU96p0+QsThdnv8mqoX7++2rZt6/U4n3zySZFncF8pcXFxatasmdfjHDt2LN+Z4sVBixYtVKdOHa/H2bFjR7FfkrFt27aKiooq8vsUgO988803+X52aNu2rdefD9LT040vNBZnXbp08XpJRj4HFC9/1c8BaWlp+f6cY8XfZQDW8OazKoArh/eqWVG2uLA0MHvwwQc1ffr0XN8ynjRpkubNm2flpXwm53J1hf0WYc5vR3vzw13fvn312WefadGiRZIuf6usa9euGjJkiIYNG6a4uDgFBgZqz549mjt3rqZMmaL09HSVK1dOFStWND7guKvh1KlTuu2224zZF2FhYfr000/Vo0cP03n16tXTww8/rCFDhqhPnz5asmSJpMvLnfTu3VurVq0yBaRX8vXL3i/t7NmzatSokemx4OBg/lFwo7CvS84/z+LKij/rkvDNRZvN5jfPNSAgwK+fa1H+DfN26aUrITAw0JI/V396riVhWWurnmtJEBQUZDxXftYAipdjx47l+7jr+7eoSsKSwJI1/z7xOaB48afPAa74fy1Q/PC+BEoG3quXFeU1sPQ3TsHBwZo/f77Cw8MlXf6hzul0av78+XrttdesvJTPZNeerbDf6s65dIW334aaNWuWWrdubbQzMzM1c+ZM3XLLLSpbtqxKly6t66+/Xq+//rrS09NVqlQpffHFF6pUqZLRx90+Yk8//bRpqbJ33303V1jmKiIiQp9//rluvPFG49jq1av1+eefm867kq9fTEyMYmJiVKFChUJdAwAAAMBfh91uV2JiokfnXrx4sUQsAQugZHxJCgAA/LVY/tNHkyZNtGjRIiPoyA7Nxo4dq27dumnNmjXFegP76OhoU7uw65nnXCKqfPnyXtUTGRmplStXasSIEQX+sHjTTTdp48aNat++vZKSkozjVapUMZ2XkJCgTz75xGhfd911Gjp0aIG1hIWF6a233jId++CDD0xtK1+/oKAglS1btlD9AQAAAPgXT2d+Xbx4UXPmzCkxe5EB/iw6OppvxgMAgCvO0nUWsvedaNu2rZYsWaJ7771XiYmJRmi2fPlyLV++XOHh4apXr54qV66sqKgohYSEFGlpAJvNppkzZ1r5FFSpUiWjXul/y/55KudeOTn3+CqKsLAwTZ8+XaNGjdLs2bO1YsUKHTlyRCkpKapUqZJatGihvn376q677jJCNdfZY1WrVjWNt2bNGtMeIb179/Z4yac2bdqoZs2aOnz4sCTpl19+UWZmpvHnV7lyZdP53rx+MTExJWIpKgAAAADF28WLF7VgwQKdO3fuapcCwAOxsbFXuwQAAOCHLA3MSpUqletYdvDkGkIlJydr8+bN2rJlS5Gv5XQ6fRKYhYaGqmrVqoqPj5ekQm+I63p+1apVFRISYlltcXFxmjx5coHnxcfHmza0a9y4senxffv2mdo59/8qyHXXXWcEZsnJyTp79qyxBGStWrUUEBBgfMuzsK+f694DtWvXLlRfAAAAAHDn448/vtolAPBQaGioOnbseLXLAAAAfsjSJRmdTmeum+tjNpvNuOV1vqc3X2rSpIlxf+/evR4v2eFwOExhlOs4V9Jvv/1majdr1szUzrmvWGFn90VERJjadrvduB8SEqL69esb7V27dnk8bnx8vGlJxqv1+gEAAAAAgCsvNDRUPXv2ZHsGAABwVVi+h5lrKJZzOT3XsCvneYW9+VLLli2N+ykpKdq2bZtH/TZv3mwKo26++Wava3E6nUpISDDtSVaQr776yrgfEBCgDh06mB6vUKGCqX3kyJFC1ZRz2cmYmBhT2/X127Nnj8cbcP/666+mthWvHwAAAAAAKN7KlSunpk2bauTIkWrYsOHVLgcAAPgpS5dkzFbQDDBvZ4j5OjC77bbbNGHCBKO9ePFiNW3atMB+33zzjandpUuXIteQmZmpevXqKT4+Xna7XSNGjND06dML7HfhwgVTYHbLLbfkCsgaNGhgai9btkwPP/ywR3Wlp6ebZrDVq1dPoaGhpnNuu+02/fe//5V0+c966dKl6t+/f4Fj53z9Onfu7FFN8J0KFSpo7NixV7uMK6JOnTrF/rla9W9f06ZNcy3VWtxY9VzbtGmjVq1aWTKWr2TvPemtbt266bbbbrNkLF8pyn6l7vTu3dvns829FRRkzY9Y999/f7F/rsHBwZaM88QTT1gyji8FBwd7vPIAgL+ekJCQYv/zoiRLtgXgc0Dx8lf+HGC327VixQr9/e9/t+xnCgAAgKLySWBW0t18882qWbOmsU/XjBkzNHr0aIWFheXZJyUlRe+//77RrlOnjlq3bl3kGgIDAxUdHa1Dhw5JuhwmvfvuuwX+svGNN97Q+fPnjfZDDz2U65xbbrlFkZGRxnnLly/Xzp07de211xZY13vvvafk5GSjffvtt+c654477lDp0qWN86ZMmaJ+/frl+0P+8ePHtWDBAqPdvn17Va9evcB64FsBAQG5AtG/Kn96roGBgZYFF8VdUFCQZcFFcedPv2Cwcn/Q4s6fnmtJ+TeYwAzwXzabrcT8W+Utf/rZ2J+ea3H8HBAQEGDZF8gAAAC85ZOfSrxdbvFqLscoXf6BbdSoUUb7yJEjeuSRR/LtM3LkSB0/ftxoP/roo17Xevfddxv3jx8/rmnTpuV7/g8//KCXXnrJaDdq1Ej33HNPrvOCgoJMQZrD4dDAgQN16dKlfMffvHmz/vnPfxrt4OBgPfroo7nOK1OmjAYPHmy0f/vtN7388st5jmu32zVw4EClpqYaxx5//PF8awEAAAAAAAAAALCK5YFZ9j5lvr752qhRo1SrVi2j/cEHH+j+++83za6SpOTkZA0dOtRYglCSrrnmGo0cOdLtuIcOHfI4ALz//vsVGRlptEePHq25c+fmOs/hcGjatGm6/fbb5XA4JF3+5tj06dPznFnx9NNPKzY21mhv2LBBLVu21Pr163Od63Q6NW/ePLVr1870/J966inVqVPH7fjPPvusqfbx48dr/PjxstvtpvPOnDmjHj166IcffjCOtW/fXj169HA7LgAAAAAAAAAAgNUsXacqKyvLyuGuqvDwcM2bN0+dOnVSSkqKJGnmzJlauHCh7rjjDlWrVk3Hjh3T4sWLlZSUZOo3f/58S5ZQqlixot544w0NHz5ckpSRkaEBAwbolVdeUYcOHRQREaH4+Hh9//33OnHihKnvlClTdOutt+Y5dmRkpBYvXqw2bdro4sWLkqQdO3aoZcuWuv7663XjjTcqJiZGp06d0qpVq3Tw4EFT/zvuuEMTJ07Mc/wqVapo1qxZuvfee5WZmSmn06kXX3xRM2fOVPfu3VWhQgUdOHBAixcvNs0sq1ixoj766KNCv1YAAAAAAAAAAABF5R8buxRRq1attGTJEvXs2dPY7yspKSnPQCcqKkpfffWVmjVrZlkNw4YNU2Jiop5++mljz4zt27dr+/btbs8PDw/Xe++9pwEDBhQ49nXXXad169apV69e2rt3r3F806ZN2rRpU579HnroIb311lsFrjPeq1cvffzxxxoyZIjS09MlSSdOnNDMmTPdnl+9enV999137F0GAAAAAAAAAACuKHZWLUD79u21a9cuDRkyRKVKlXJ7TkhIiAYOHKht27apbdu2ltcwevRo/fTTT+rYsWOe54SHh2vYsGHauXOnR2FZtsaNG+vPP//U5MmTVbNmzTzPCwwMVJcuXfTzzz/r3XffVXBwsEfj9+nTR9u2bVPPnj3z7BMREaFHHnlEW7duVaNGjTyuHQAAAAAAAAAAwArMMPNA5cqVNWvWLE2dOlWrV6/W4cOHlZCQoIiICNWvX1+tW7dWVFSUR2PVqlWrSHuwtW7dWitXrlR8fLx++eUXHTt2TKmpqYqKitK1116rli1bqnTp0oUeV7octj3xxBN64okntHv3bv3xxx86c+aMUlJSVK5cOcXGxurWW2817UlWGPXq1dOiRYuUlJSkH3/8UceOHdP58+cVFRWlBg0aqFWrVkWuHbllZWXp7NmzpmMOh0Opqak6c+ZMrn3tKlSoUOBsQQAAAAAAAAAA/soIzAqhdOnS6t69+1WtoVq1aurdu7fPxm/QoIEaNGjgk7GjoqLUs2dPn4yN/7Hb7Zo2bZrbx3bv3p3r2NixYxUaGurrsgAAAAAAAAAAKLYIzAAAAAA3nE6nMjIyTMfsdrsyMzOVnp6urKws02MhISGy2WxXskQAAAAAAGARAjMAAADAjYyMDE2aNMntY1u3bs11jFnbAAAAAACUXGxcBAAAAAAAAAAAAL9GYAYAAAAAAAAAAAC/RmAGAAAAAAAAAAAAv0ZgBgAAAAAAAAAAAL9GYAYAAAAAAAAAAAC/RmAGAAAAAAAAAAAAv0ZgBgAAAAAAAAAAAL9GYAYAAAAAAAAAAAC/RmAGAAAAAAAAAAAAv0ZgBgAAAAAAAAAAAL9GYAYAAAAAAAAAAAC/RmAGAAAAAAAAAAAAv0ZgBgAAAAAAAAAAAL9WLAKzrKwspaam6tKlS1e7FAAAAAAAAAAAAPiZoCt5sbS0NP3www9at26dNm/erH379unEiRO6cOGCJMlms8nhcBjnb9y4UYcOHVLPnj0VEFAssj0AAAAAAAAAAAD8xVyRwGz9+vV6++239fXXXyslJcU47nQ68+23fPlyPfPMM4qNjdWkSZPUp08fX5cKAAAAAAAAAAAAP+PTaVsnT57Uvffeq1atWunTTz9VcnKynE6ncbPZbMbNnW3btsnpdOrIkSPq37+/unbtqqSkJF+WDAAAAAAAAAAAAD/js8Bs7dq1uv766/XFF1+4DcjyCslcbd++3TjX6XRqxYoVatWqlY4fP+6rsgEAAAAAAAAAAOBnfBKY/fLLL7rtttt06tQpU1AmyTTDLPvmTlZWlnbt2mW0s0Oz3bt3684771RqaqovSgcAAAAAAAAAAICfsTwwO378uHr16qXk5GTT7DBPl2HMtm/fPqWnp0uSqa8kbdq0Sc8884zVpQMAAAAAAAAAAMAPWR6YPfTQQzp79qxpRpkkt7PM8rNt2za3x7MDuHfffVd79+61sHIAAAAAAAAAAAD4I0sDs19//VVff/2127Asu12uXDndfvvteuCBB0yP5bR9+3bjfs7xJMnhcGjGjBlWlg8AAAAAKIFCQkJy3QICAtweBwAAAAB3gqwcbNq0acZ91yUUnU6nIiIi9MYbb2jIkCEKCrp82ffffz/Psf7v//5PFSpU0AsvvKAzZ84YM8uk/80ymzt3rl577TUrnwIAAAAAoAQJDQ3VuHHjTMfsdruWLl2q7t27Kzg4+CpVBgAAAKAksWyGWVZWlr766isjJHMNy0qVKqWVK1fq/vvvN8KygkRERGjkyJHasGGDYmNjjTFdZ5mdOnVKBw8etOopAAAAAAAAAAAAwA9ZFpht2bJFFy5ckPS/pROzZ5mNGzdOzZs3L9K41apV08SJE/Pc82zTpk1FKxgAAAAAAAAAAACQhYHZrl27jPuu+5LZbDaNGDHCq7H79OmjwMDAXGNLl2eZAQAAAAAAAAAAAEVlWWB24sQJt8erVq2qmJgYr8YODg5W9erV3T52/vx5r8YGAAAAAAAAAACAf7MsMEtNTXV7PCwszKpLAAAAAAAAAAAAAJazLDCLiopye/zEiRPKzMz0auyUlBQdP37c7WMRERFejQ0AAAAAAAAAAAD/ZllgVqlSJeO+0+k07qekpOiHH37wauwlS5bIbrfnGltSnks1AgAAAAAAAAAAAJ6wLDCrU6eO2+NOp1PPPPOMHA5HkcZNT0/XCy+8kOfjDRs2LNK4AAAAAAAAAAAAgGRhYHb99derSpUqkiSbzSan0ymbzSZJ2rBhg/r166e0tLRCjWm32zVw4EDt2LEj15iSVL58eQIzAAAAAAAAAAAAeMWywEySbr/9dtOSidkBl9Pp1MKFC9WkSRNNnTpVu3btUnJycp7jnDlzRh999JGuv/56LVy40Bgj57h33HGHleUDAAAAAAAAAADADwVZOdjo0aM1e/ZsZWZmGiGXa2h24MABPfbYY6Y+OWeNlSpVShkZGcZjkkyPu3rggQesLB8AAAAAAAAAAAB+yNIZZg0aNNCIESNMs8Gk/4ViriFazhlj2f9NT083Pe46u8x1WcYuXbro5ptvtrJ8AAAAAAAAAAAA+CFLAzNJeumll9SoUSNJ5plhrqFX9s0d18dzhmXZypQpo+nTp1tdOgAAAAAAAAAAAPyQ5YFZ2bJltWzZMlWpUkWSTOGY6+yynLPQXOU8x7V/cHCwPv30U9WsWdPq0gEAAAAAAAAAAOCHLA/MJCk2NlarV69Ws2bNcs0sK4hrkJYzbCtTpowWLVqkrl27+qJs4C8jJCQk1y0gIMDtcQAAAAAAAAAA/F2QrwauW7eu1q1bpzFjxug///mPHA6Hx6GZq+wA7Y477tDbb7+tWrVq+aBa4K8jNDRU48aNMx2z2+1aunSpunfvruDg4KtUGQAAAAAAAAAAxZPPAjPp8iyXt956S08++aTeeustzZw5U+fPn891nussMlehoaG68847NWLECHXs2NGXpQIAAAAASqCsrCwdOHDAdCwzM1MXLlzQgQMHFBgYaHqsTp06CgjwyWIrAAAAAEownwZm2apXr67XX39dr776qjZt2qQ1a9Zow4YNOnPmjBITE5WUlKSQkBBFRkaqQoUKuu6669S8eXPdeuutioqKuhIlAgAAACYhISEaO3as6Zjdbtfy5cvVpUuXXLO2WeoYuDrsdrvmzp3r9rGcQZokjR07VqGhob4uCwAAAEAJc0UCs2yBgYG66aabdNNNN13JywIAAACFZrPZcv1SPSAgQIGBgQoNDWWZYwAAAAAA/kJYhwIAAAAAAAAAAAB+jcAMAAAAAAAAAAAAfu2KBWZJSUlasGCBR+c6nU516NBBr7zyinbu3OnjygAAAAAAAAAAAODPfB6Y7d27V/369VPlypXVv39/paWlFdjn4MGDWr16tZ599lk1adJEt99+u9auXevrUgEAAAAAAAAAAOCHfBaYZWZmasyYMWrcuLHmz5+vjIwMZWVlaevWrQX23bFjh3Hf6XRq2bJluvXWW/XYY48pPT3dVyUDAAAAAAAAAADAD/kkMLtw4YLatWunyZMny+FwyOl0Go9t3ry5wP6ugZnNZpN0OTibOnWq/va3vyk5Odn6ogEAAAAAAAAAAOCXLA/M0tPTdeedd2rt2rVyOp2y2WxG6CUVPjBzHcPpdGrdunW64447lJWVZXXpAAAAAAAAAAAA8EOWB2YTJ07UTz/9lCsoy+ZJYLZ9+3ZT2+l0GsGZ0+nU6tWrNXnyZMtqBgAAAAAAAAAAgP+yNDA7dOiQXn/9ddMyitnLMWaHXZ7sYbZr1y5jjJyhW/Y4//rXv3T69GkrywcAAAAAAAAAAIAfsjQw++CDD5SRkSFJpn3LXF24cEGHDx/Oc4yLFy+qefPmCg0NNYVtOcdMS0vT7NmzLaocAAAAAAAAAAAA/srSwGzu3LmmGWGue48FBwfrySef1NatW1WzZs08xyhTpox++OEHnThxQq+++qoiIiKMsVw5nU7NmTPHyvIBAAAAAAAAAADgh4KsGujkyZM6fPiwEZC5zgqLiIjQihUr1LJlS4/Hi4yM1FNPPaVu3bqpbdu2On/+vGlsp9OpXbt26fz584qMjLTqaQAAAAAAAAAAAMDPWDbDbNOmTbmOZYdbL7zwQqHCMldNmjTRyy+/nOcSj3/88UeRxgUAAAAAAAAAAAAkC2eYHT9+3LjvunxiQECAhg8f7tXYAwYM0COPPKKsrKxcSzMePXrUq7GBv5qsrCwdOHDAdCwzM1MXLlzQgQMHFBgYaHqsTp06CgiwdHVWAAAAAAAAAABKFMsCs/Pnz7s9Xr16dZUtW9arsSMiIlSjRg0dOnQo12NJSUlejQ381djtds2dO9ftYzmDNEkaO3asQkNDfV0WAAAAAAAAAADFlmWBWUZGhtvjISEhloyfc2ZZttTUVEvGBwAAAFxlZWXp7NmzpmMOh0Opqak6c+aMgoLMP0pXqFCBWdsAAAAAAJRQlgVm5cuXd3v8xIkTXo/tcDjyHCc6Otrr8QEAAICc7Ha7pk2b5vax3bt35zrGrG0AAAAAAEouy74CGxMTY9x3Op3G/eTkZK1bt86rsVesWGHMJHMdO+d1AQAAAAAAAAAAgMKyLDCrWbNmno9NnDixyONmZmZq/PjxeT4eGxtb5LEBAAAAAAAAAAAAywKzZs2aGcsy2mw2OZ1O47/fffddvqFXXjIyMjRw4EBt3LjRNGa2yMhI3XjjjVY9BQAAAAAAAAAAAPghywIzm82mTp06mZZMdA3NXn75ZXXp0kWrVq0qcKzz589r9uzZiouL0/z5842xco77t7/9jY3VAQAAAAAAAAAA4JUgKwcbNmyYEXBlcw3NVq5cqZUrVyoyMlJxcXGqWbOmypQpo8DAQF26dEmJiYnatWuX9u/fr8zMTCMky+6f09ChQ60sHwAAAAAAAAAAAH7I0sCsc+fOuvXWW7VmzRpTyOUamklSUlKS1qxZozVr1uQawzUYy15+MWdwZrPZ1KpVK3Xv3t3K8gEAAAAAAAAAAOCHLF/P8PXXX1dwcLAkmfYbyw66sm9Op9PtzfWc7H45xwoODtbkyZOtLh0AAAAAAAAAAAB+yPLArHnz5nr//ffdBl3ZoVj2cXc3d+e6HrPZbJo2bZpatmxpdekAAAAAAAAAAADwQ5YHZpI0cOBATZo0yQjA8grD8rtlc52RZrPZ9OKLL7J3GQAAAAAAAAAAACzjk8BMksaMGaNly5apQoUKbmeV5cfdsowVKlTQkiVLNG7cOF+VDAAAAAAAAAAAAD/ks8BMkjp37qxt27Zp7NixioyM9GhJRteQzOl0qmzZsnr66ae1bds2de3a1ZflAgAAAAAAAAAAwA8F+foCMTExevnll/XMM89o4cKFWr16tX7++Wft27cvzz516tRR27Zt1bZtW91zzz2KiIjwdZkAAAAAAAAAAADwUz4PzLKVLl1agwYN0qBBgyRJaWlpOnfunBISEnTx4kVFREQoOjpa5cuXV6lSpa5UWQAAAAAAAAAAAPBzVywwyyksLEzVqlVTtWrVrlYJAAAAAAAAAAAAgG/3MAMAAAAAAAAAAACKOwIzAAAAAAAAAAAA+DUCMwAAAAAAAAAAAPg1AjMAAAAAAAAAAAD4tSBfX2Dnzp364YcftHfvXp08eVIXL15URkaGsrKy5HQ6vRrbZrNp5cqVFlUKAAAAAAAAAAAAf+SzwGz58uV6+umntWXLFp+M73Q6ZbPZfDI2AAAAAAAAAAAA/IflgZnT6dSoUaP03nvvGW2rEZQBAAAAAAAAAADAKpYHZuPHj9f06dONNuEWAAAAAMBXbDabYmJiTMecTqcuXbqkiIiIXJ9J+YwKAAAAwB1LA7MdO3bo1VdfNX0AYYYZAAAAAMBXQkJC9NBDD5mO2e12LV26VN27d1dwcPBVqgwAAABASWJpYPb6668rMzNTNputwKCM0AsAAAAAAAAAAADFgWWBWWZmpr766qs8gzACMgAAAAAAAAAAABRHlgVmv/76qxITE93OLssOy1yPlypVSmXKlFFQUBBLZAAAAAAAAAAAAOCqsSwwO3ToUK5jrkFZ+fLl9dRTT+n2229X3bp1FRYWZtWlAQAAAAAAAAAAgCKzLDA7ceKEqe0altWoUUM///yzYmNjrbocAAAAAAAAAAAAYIkAqwbKuQxj9jGbzaY333yTsAwAAAAAAAAAAADFkmWBWcWKFY372bPLJCksLEy9evWy6jIAAAAAAAAAAACApSwLzJo1a+b2ePXq1a26BAAAAAAAAAAAAGA5ywKzpk2bqmrVqrmOX7x40apLAAAAAAAAAAAAAJazLDCTpH/84x+59jI7deqUDh8+bOVlAAAAAAAAAAAAAMtYGpg99thjqly5cq7j//nPf6y8DAAAAAAAAAAAAGAZSwOzyMhIvf/++7LZbJIkm80mp9Opt99+W6tWrbLyUgAAAAAAAAAAAIAlLA3MJOn222/X5MmTjaUZbTabMjIy1KNHD82fP9/qywEAAAAAAAAAAABeCfLFoI899pjCw8P18MMPy+FwyGaz6dKlS+rXr59eeeUV3Xnnnbr22mtVrVo1RUVFKTw8XEFBQQoIKHx+V6NGDR88AwAAAAAAAAAAAPgLSwOzRx991NRu1qyZfv/9d9lsNmN5xi1btmjr1q2WXM9ms8nhcFgyFvBXYbPZFBMTYzrmdDp16dIlRUREGEumup4PAAAAAAAAAIA/szQwmzp1qttfvjudTlNolr1cIwDrhYSE6KGHHjIds9vtWrp0qbp3767g4OCrVBkAAAAAAAAAAMWTT5ZkdBeIue5p5qtrAAAAAFYKCQnJdczhcCgoyCc/RgMogszMTG3evDnXsXPnzunPP/9UYGCg6bGmTZvmOgYAAAAAPvmk7xqK5Qy2rAi6WEIOAAAAvhYaGqpx48aZjjFrGyh+HA6HvvnmG7ePHT16NNexxo0bE5gBAAAAyOWKzTADAAAAAAAAAAAAiiOfzzADAAAAAAAAAAAAijPLAzNmlwEAAAAAAAAAAKAksTQwe/75560cDgAAAAAAAAAAAPA5AjMAAAAAAAAAAAD4tYCrXQAAAAAAAAAAAABwNRGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADAr5XYwOzUqVN68cUXr3YZAAAAAAAAAAAAKOGKfWBmt9uVmJio/fv368cff9TkyZN12223qWbNmnr++eevWB379+/X2LFj1bJlS0VHRyskJETVq1dX69at9dJLL+nIkSM+ryEpKUlTpkxR165dVaNGDYWFhals2bJq0qSJRowYoTVr1ng0zo8//iibzWbZLT/lypUr0phBQUFWvGQAAAAAAAAAAAAF8mkqsWrVKi1dulSbNm1SfHy8Tp8+rbS0NKWnp8vpdHo1ttPpLDCssYLD4dD48eP12muvKTMz0/RYfHy84uPjtW7dOr3wwguaMGGCxowZo4AA63PI9957T88884zOnTtnOp6enq7t27dr+/btmjFjhjp06KDp06frmmuusbyGwjp06JCSkpKudhkAAAAAAAAAAAD58klgdvToUd1333367bffjGPeBmSurkRQJkmZmZm677779MUXXxR4rt1u17hx47R582Z98sknltWQlZWlUaNGafr06R6dv2rVKt10001asGCBunbtalkdealbt26ej/35558+vz4AAAAAAAAAAIC3LJ8Kdfr0abVp00a//fabnE6ncbtSSwBa6bnnnjOFZeXLl9eUKVN0+PBhpaamau/evZowYYLCw8ONcz799FNL91Z74YUXcoVlt9xyi7788kudPXtWKSkp2rBhg0aNGqXAwEBJ0sWLF9WrVy+tW7fO7Zjt27c3/dl4etu7d68iIyONcSIjI7V48eI8a9+8ebNxPywsTHa73eNrORwOb142AAAAAAAAAAAAj1k+w2zYsGE6evRogeGWNzPOrkRotmPHDr366qtGOzY2Vr/88otiY2ONY/Xq1dP48eN11113qX379jp79qwkaeLEiRowYIBq1arlVQ2//fabJk6caDo2btw4vfTSS6bX4IYbbtANN9ygHj16qGfPnkpJSVFaWpr69++vrVu3qnTp0l7VIUkpKSnq1auXzp8/bxybM2eOGjZsmGcf1xlmjRs3Zl+yKyQzM9MUVmYfO3funP78808jWM3WtGnTXMcAAAAAAAAAAPAnliYY2XuWZYc5Vi7DmO1KzTCbMGGCsWeZzWbT/PnzTWGZq8aNG2vhwoXGzK2MjAxNmDBBH374oVc1TJw40fQaDh48WC+//HKe53fu3FlTp07VsGHDJEkHDx7U1KlT9fTTT3tVhyQ99dRT2rZtm9EeOXKkevTokW8f18CsadOmXtcAzzgcDn3zzTduHzt69GiuY40bNyYwAwAAAAAAAAD4NUuXZJwxY4ZxP2dYVtCyip4uwZi9ZJ8klStXzsryDWfPntWiRYuMdpcuXdSqVat8+7Rt29YUIH366adKTk4ucg1nzpzR0qVLjXbZsmX19ttvF9hv6NChatKkidF+5513vA4uV6xYof/85z9Gu06dOpo8eXK+fc6fP69Dhw4ZbQIzAABQ0mRlZWnfvn2m24EDB3ThwgUdOHAg12NZWVlXu2QAAAAAAFBEls4w++677/IMwyRziGaz2UztvEId19DM6XQqLCxMDzzwgG6//XZ16NDByvINS5cuVUZGhtHu16+fR/369eunL7/8UpKUmpqqxYsX67777itSDatWrTK9Jv379zftH5afAQMGaOzYsZKk48ePa+3atbrllluKVEdaWpoefPBB07H33ntPpUqVyrdfziUBCcwAAEBJY7fbNXfuXLePHThwINexsWPHKjQ01NdlAQAAAAAAH7AsMNu9e7eSkpJMQVj2fafTqdq1a+u+++5T7dq1tXPnTr311lvG4zabTe3bt9egQYOUmZmpjIwMJSYmatu2bfriiy+Unp5uhGbp6emqXbu2unTpYlXpuaxcudLU7tixo0f9cgZ4S5cuLXJgtmPHjnzHzk+LFi1M7TVr1hQ5MHvllVdMvxDq27evOnXqVGA/1+UYJem6664r0vUBAAAAAAAAAAB8zbLALOe3bF3DsLZt22rZsmUKCwuTJCUnJ2v69OlGEOZ0OnX27FkNHjw417jHjh1T37599csvvxjnPvXUU7rhhhvUtm1bq8o32bJli3E/JiZG1atX96hfhQoVVK1aNcXHx0uSfv/99yLXcO7cOVO7du3aHvetVKmSqb1p06Yi1RAfH6/XXnvNaJcqVUqTJk3yqK/rDLOaNWv6bPlMAAAAAAAAAAAAb1m2h1l2SOTOyy+/bIRlklS6dGm1adPGtOTgtm3bcoVEklS9enV9++23xgwlm82mzMxM3X///aZlE620a9cu4379+vUL1bdu3brG/QMHDhR5/7Cczy0iIsLjvoGBgab24cOHi1TDc889p9TUVKP9xBNPqEaNGh71dZ1h1rRpU2VlZenbb7/V0KFD1bBhQ5UpU0bh4eGqXbu27rnnHn300Uey2+1FqhMAAAAAAAAAAMAblgVmFy9eNO677mMWEhKim2++Odf5f/vb33Id+/nnn92OXbp0ab377rum8Gn//v2aNWuWNyW7lZCQoLS0NKNdrVq1QvWvUqWKcT89PV2nT58uUh3ly5fPVZenzpw5Y2rnF2bmZe/evZozZ47RjoqK0lNPPeVRX4fDoe3btxvt5ORkNW3aVN26ddPs2bO1e/duXbp0SampqTp06JAWLlyoQYMG6dprr9WKFSsKXSsAAAAAAAAAAIA3LFuS0XUmkquqVauaArRsrVu3znVs7dq16tmzp9txbrnlFl133XXasmWLsTTjnDlzNGLECK/qzilnwBUdHV2o/lFRUaZ2QkJCriUSPVGrVi1Te+PGjW5fM3dyLsF44cKFQl9/0qRJyszMNNqPP/64IiMjPeq7c+dOpaenG+2ce8LlZf/+/erWrZumTp2qBx98sMDzs4PBs2fPejQ+AACAL7n+/GM1m82mkJAQr8fJzMyUw+GwoCLfseq5OhwO08+zxVFAQICCg4O9HsdutysrK8uCinwnMDBQQUHef/zMyMjItYqHL997AAAAAPyHZYFZQID7yWqhoaFujzdv3lyBgYGmD3Zr167N9xpt2rQx7S/2+++/KzEx0dL9sS5dumRqlylTplD9cy6d6DrzrjDatWtnas+bN08PP/ywR30XLFhgarvOmPNEfHy8Pv74Y6NdpkwZPf744x73d92/LFtYWJgGDRqkwYMH65prrlHp0qV17NgxLV++XK+//roOHTok6fIvcR566CFVrVpVd955Z77XqVixosc1AQAA+Nqbb77ps7FjYmL00EMPeT3O5s2b9c0331hQke/UrVtXAwYM8HqcNWvWaPXq1RZU5DvXX399gT/zemLZsmVF3rf4SmnXrp3at2/v9TgLFizQ/v37vS8IAAAAAHKwLDDLK1g6deqU2+NhYWG69tprtW3bNmPG2IYNG5Senp5nyJZz9lZWVpbWrVun7t27e1W7q5zfTizsNz5znl/UfbkaNGiguLg4bd26VZK0bt06LViwQL17986335IlS7RmzRqvapgxY4ZpD7WhQ4d6PLtMMu9fJkl16tTRwoUL1axZM9Px+vXrq379+ho+fLgGDhyozz//XJLkdDo1ePBgHThwoMhhqN1u99s90Qr7vO12e56BN4ArK/v966//fgHFTXF6LzqdTkvqKe4zrqTLP+PzXAs/TnGXmZlZbJ4rP/8CxQc//wIlA+9VoGTgvWpWlNfBssCsbNmyxn2n02ksw5iUlKTjx4+ratWqufrccMMN2rZtm9HOyMjQqlWr1LVrV7fXOHr0aK5jJ06c8LZ0k5wfrAv7QSrn+d58oBs3bpz69etntIcPH67o6Gh16tTJ7fl//PGHBg8enOt4YZa0cTgc+uCDD4y2zWbTI488UoiqpWuvvVa9evXSgQMHlJCQoG+//Vb169fP8/ywsDDNmzdPx44d06+//irp8t+byZMn68UXXyzUtbN9//33hQr5/koK+8uh5cuXKzAw0EfVACgK9nMEiofiFLhcunRJS5cu9Xqcc+fOWVCNb509e9aS52r15wRfOHr0qCXP1d3npOJm7969uVbzKAorlmPn51+g+OHnX6Bk4L0KlAy8Vy87f/58oftYFphdc801eT729ttv69VXX811/KabbtJ///tf07G5c+e6DczOnz+vb775Jtd+aNn7WFkl57r6hf1FSc49IfKaLeeJvn376rPPPtOiRYskXf5FSdeuXTVkyBANGzZMcXFxCgwM1J49ezR37lxNmTJF6enpKleunCpWrKjdu3cXuoZvv/1Wx48fN9qdOnVSvXr1ClX38OHDNXz48EL1CQ4O1ltvvaWbb77ZODZ37twiB2adOnVSTExMkfqWdOnp6cbMRE906dLFq7+nAKxjt9u1YsUKde7c2ZI9bQB4p7D/T/WliIgIS1ZV+PPPP4t9uFKhQgVLnutPP/2U52oXxUVsbKwlz3XJkiVKSEiwoCLfqV+/vtq2bev1OJ988kmRl73Pxs+/QPHBz79AycB7FSgZeK+aFSU7siwwa9y4sRFmuf7X6XTqjTfeUGxsbK49uJo3b27czz53/vz5GjhwoLp06WI8lpaWpj59+igpKSlXYBYWFmbVU5AkhYeHm9qF3f8rNTXV1Pb2g9isWbN06tQpY3+3zMxMzZw5UzNnznR7fqlSpfTFF1/o+eefNwKzwuzD9sknn5jagwYNKmLlhdeyZUs1bNhQu3btkiQdOnRI+/fvV926dd2ef/r0aUmXv2XaqFEj02PBwcF++49CYWc1+vNrBRRXvC+B4qE4LXNns9ks+XehJMyqCQgI4LkWYZziLjAwsNg8V/4/CxQ/vC+BkoH3KlAy8F69rCivgWWfrCIiItSyZUs5nU5Jl5dlzF6aMTMzU4899piaNWumjRs3Gn1uvPFGU0Bls9nkcDj097//XSNGjND777+vCRMmqFGjRlq+fLkRqrkqX768VU9BkhQdHW1qX7hwoVD9c37b0dv6IiMjtXLlSo0YMaLAD4c33XSTNm7cqPbt2yspKck4XqVKFY+ulZaWpq+//tpoR0RE6K677ipS3UXVsmVLU/vgwYN5nhsTE6OYmBhVqFDB12UBAAA/VBJCCACFx3sbAAAAgDuWflLo06dPrmPZoZnT6dTWrVtN69YHBQWpffv2ppAtOzT74IMP9OCDD+qFF17QoUOHcgVl2a677jorn4IqVapkmsWWPYvJUzmXfalYsaLXNYWFhWn69On6888/9cQTTyguLk6RkZEKDg5W9erVddddd+mzzz7Tb7/9poYNG0oy79ngbv84d3788UfTn0/Xrl1zzbjztUqVKpnaVuxRAAAAUBTBwcEqV67c1S4DgIWio6P5ti0AAAAAtyxbklG6vHfVv//9b504ccLtbDBJatq0qal9991359roOmff7AArO1DLVq5cuVzjeSs0NFRVq1ZVfHy8pMJvoO16ftWqVRUSEmJZbXFxcZo8eXKB58XHx5vW52zcuLFH4y9btszU7tGjR+EKtEDOvzPsLQAAAK6mGjVqKDEx8WqXAcAisbGxV7sEAAAAAMWUpTPMSpcurSlTphhtm81mCrhiY2MVGRlp6tO7d2+VLVvWOD87MMnu6xqWZcsOzoYPH25l+YYmTZoY9/fu3avMzEyP+jkcDu3bt8/tOFfSb7/9Zmo3a9bMo37ff/+9cd9msxV5A/Lz589rz549+vnnn7Vnz55C9c05o4/lFgEAwNXUoUMHvsAD/EWEhoaqY8eOV7sMAAAAAMWU5Yu39+rVS++8847pWHbA5W42WOnSpfXiiy/mCsRy3iSZwrfo6Gg98cQTVpcvybyPVkpKirZt2+ZRv82bNystLc1o33zzzV7X4nQ6lZCQYNqTrCBfffWVcT8gIEAdOnQosE9CQoJ27txptBs2bJhrPzdPfP3114qKilKDBg3Utm1bvfzyy4Xq//vvvxv3AwICLF9yEwAAoDAiIyPVs2dPQjOghAsNDVXPnj2NL2sCAAAAQE4+2e141KhRWrJkiWJiYkxBWF7LJ44aNUrt2rUzgjXXYCyb60yzoKAgzZ49O9d+V1a57bbbTO3Fixd71O+bb74xtbt06VLkGjIzM1W7dm2FhoaqfPnyGjt2rEf9Lly4YArMbrnlFo9maa1bt870Z9WqVavCF63ce8qtWLFCWVlZHvXdsWOHKbS78cYbc81IBAAAuNIaNmyokSNHqmnTpuxpBpQw2cv4jxw50tjvGQAAAADcsXQPM1ddu3bV/v379dZbb+ndd9/VyZMn8wzMbDabli1bpgEDBuiLL77IMzRzOp2KiIjQvHnzdPvtt/uqdN18882qWbOmDh8+LEmaMWOGRo8erbCwsDz7pKSk6P333zfaderUUevWrYtcQ2BgoKKjo3Xo0CFJl8O4d999V4GBgfn2e+ONN3T+/Hmj/dBDD3l0vY0bN5raRZ0dV6tWLTVp0sSYlXf8+HEtXLhQ9957b4F9n3/+eVNoN2LEiCLVAAAAYLXsmWZ2u12LFy9W586dFRwcfMWu7+5n46Jo2rSpx/vbXi1WPdc2bdoU+UtgV0pAgDXfX+zWrVuuL/0VNwV9jvFU79693e6VnZPdbteKFSv097///Yq+VwEAAACUXD4LzKTLyy0+88wz+uc//6mffvop3w/nYWFh+vzzz/XRRx9pypQp+uOPP0yPV6xYUffcc4+effZZVa5c2ZdlKyAgQKNGjdKYMWMkSUeOHNEjjzxiCsRyGjlypI4fP260H330Ua8/7N99991GkHX8+HFNmzZNDz/8cJ7n//DDD3rppZeMdqNGjXTPPfd4dK2tW7ea2i1atChCxZc98MADeuyxx4z2E088oVtvvTXfP7d33nlHn3/+udGuU6eO+vfvX+QaAAAAfCUgIEChoaEl8pfwgYGBlgUXxV1QUJCCgnz6cafYKIl/F4sqJCTEo/MCAgIsCyQBAAAA+Icr8gnCZrOpXbt2Hi0NOHDgQK1fv14JCQn6/ffftW7dOu3fv18nTpzQ1KlTfR6WZRs1apRq1apltD/44APdf//9Sk5ONp2XnJysoUOH6r///a9x7JprrtHIkSPdjnvo0CFjBl1eM+my3X///aYlCUePHq25c+fmOs/hcGjatGm6/fbb5XA4JF3+Zcj06dM9/iXBnj17TO3atWt71M+dkSNHqlGjRkb72LFjuvXWW7V+/fpc5yYnJ2v06NGmgC0gIEAffvhhvjP6AAAAAAAAAAAArFJsv3IZFRWlG2+88apdPzw8XPPmzVOnTp2UkpIiSZo5c6YWLlyoO+64Q9WqVdOxY8e0ePFiJSUlmfrNnz/f428+5qdixYp64403NHz4cElSRkaGBgwYoFdeeUUdOnRQRESE4uPj9f333+vEiROmvlOmTNGtt97q8bWOHDli3I+MjPRqM+zg4GAtXLhQbdq00blz5yRJ+/btU8uWLdW6dWu1aNFCoaGhOnDggL777jtduHDB6Guz2fTBBx+oXbt2Rb4+AAAAAAAAAABAYRTbwKw4aNWqlZYsWaKePXsa+4IlJSXpo48+cnt+VFSUvvrqKzVr1syyGoYNG6bExEQ9/fTTyszMlCRt375d27dvd3t+eHi43nvvPQ0YMMDjazgcDiUmJhrt2NhY74qW1LBhQ61atUr33nuvdu/ebRxfu3at1q5d67ZPZGSkpk6dWqjaAQAAAAAAAAAAvMWi7gVo3769du3apSFDhqhUqVJuzwkJCdHAgQO1bds2tW3b1vIaRo8erZ9++kkdO3bM85zw8HANGzZMO3fuLHTglHOZSSsCM0mKi4vThg0bNGnSJFWrVi3P86KionT//fcXqXYAAAAAAAAAAABvMcPMA5UrV9asWbM0depUrV69WocPH1ZCQoIiIiJUv359tW7dWlFRUR6NVatWLTmdzkLX0Lp1a61cuVLx8fH65ZdfdOzYMaWmpioqKkrXXnutWrZsqdKlSxd6XOnyzK6i1OSJ0qVL6+mnn9aYMWO0fft2bdy4UWfOnJHD4VClSpVUs2ZNtWnTxq82KgcAAAAAAAAAAMXLFQ3MLl26pJSUFGVkZCgrK8uSMWvUqGHJOJ4oXbq0unfvfsWu5061atXUu3fvq1pDUdhsNjVp0kRNmjS52qUAAAAAAAAAAACY+DQwW758uT799FOtX79eBw4cUHp6uqXj22w2ORwOS8cEAAAAAAAAAACAf/FJYHb06FENGjRIP/30kyT5bLk/AAAAAAAAAAAAwFuWB2a7d+9W+/btdfr0aVNQZrPZLL0OIRwAAAAAAAAAAACsYGlglpqaqp49e+rUqVOy2Wy5QjKrQi6rwzcAAAAAAAAAAAD4L0sDsylTpmj37t1GoMUsMAAAAAAAAAAAABR3lgZm7777br5hGTPDAAAAAAAAAAAAUNxYFpht3bpVR48elc1myxWWuQZlzDoDAAAAAAAAAABAcWJZYLZlyxa3x11nnFWvXl3XX3+9qlWrprJlyyo0NFQBAQFWlQAAAAAAAAAAAAAUmmWB2cmTJ01t16AsOjpaH330kbp162bV5QAAAAAAAAAAAABLWDa9Kz09Pdcxp9Mpm82m6dOnE5YBAAAAAAAAAACgWLIsMIuOjjbuu+5ZVqZMGd11111WXQYAAAAAAAAAAACwlGWBWVxcnNvjFStWZJ8yAAAAAAAAAAAAFFuWJVk333yzaZZZtvj4eKsuAQAAAAAAAAAAAFguyKqBAgMD9Y9//EOTJk0yLcmYlpamH3/8Ue3bt7fqUgDyYbPZVLduXdOxrKwsnT17VhUqVMg149P1/QoAAAAAAAAAgD+yLDCTpDFjxmjWrFk6ffq06fizzz6r1atXKzAw0MrLAXAjJCREAwYMMB2z2+1aunSpunfvruDg4KtUGQAAAAAAAAAAxZOlm4tFRUVp1qxZxowVm80mp9OpdevWqX///srIyLDycgAAAAAAAAAAAIDXLA3MJKlr16569913jXZ2aPbZZ5+pbt26euedd7R//36rLwsAAAAAAAAAAAAUiaVLMmYbMWKESpUqpX/84x+y2+1GaBYfH6//+7//0//93/8pLCxMVatWVbly5RQWFqagoMKXYrPZtHLlSh88AwAAAAAAAAAAAPgLnwRmklS+fHmVL19eJ0+elCRjmUan0ylJSk1NNWaaZT9WGE6ns0j9AAAAAAAAAAAAAFc+CcyefPJJvfnmm5L+F5BJl4OxnCGX0+k0neMJgjIAAAAAAAAAAABYxfLAbMyYMXrjjTfcPpYzPHP9LwAAAAAAAAAAAHA1WBqYrVq1Sq+//ropBMtr9lhhZ5W5ImQDAAAAAAAAAACAVSwNzJ577jnjfn6BGIEXAAAAAAAAAAAAigvLArMjR47ol19+kc1mcxuWEZIBAAAAAAAAAACgOLIsMPv111/zfCxniBYeHq6IiAgFBwcrKMjybdQAAAAAAAAAAAAAj1mWVh09ejTXseygzOl0asCAARo1apSaNGmi0qVLW3VZAAAAAAAAAAAAwCuWBWbp6emmdnZYZrPZNG7cOL344otWXQoAAAAAAAAAAACwTIBVA0VHRxv3XfcrCw4O1tixY626DAAAAAAAAAAAAGApywKzJk2auD1erVo1RUREWHUZAAAAAAAAAAAAwFKWBWY333yzypUrl+v4xYsXrboEAAAAAAAAAAAAYDnLArOgoCANHTpUTqfTdPzcuXM6efKkVZcBAAAAAAAAAAAALBVk5WBjx47V7NmzlZiYaDo+ZcoUvfTSS1ZeCkAeHA6H1qxZYzqWmZmpEydO6KefflJgYKDpsTZt2igoyNJ/CgAAAAAAAAAAKFEs/S15hQoVNH36dPXu3Vs2m002m01Op1NvvvmmOnfurPbt21t5OQBuZGZmavXq1W4fO3XqVK5jrVq1IjADAAAAAAAAAPg1y5ZkzHbPPffoxRdfNJZmtNlsSktL05133qlXX31VqampVl8SAAAAAAAAAAAAKDKfTCv55z//qfDwcD355JNyOp2y2Wy6dOmS/vnPf+rll19W69at1bBhQ1WuXFlRUVEKCQnJtUycpwYNGmRx9QAAAAAAAAAAAPAnlgZmrVu3NrXLli2rpKQk0/KMFy9e1PLly7V8+XJLrklgBgAAAAAAAAAAAG9YGpj9+uuvRjBms9mM49nt7GPZyzV6y/UaAAAAAAAAAAAAQFH4ZElGKXco5rqnmRVBl1WhGwAAAAAAAAAAAPybTwKznLPLXFkRdDGzDAAAAAAAAAAAAFbxSWDG7C8AAAAAAAAAAACUFD6fYQYAAAAAAAAAAAAUZ5YHZswuAwAAAAAAAAAAQEliaWC2atUqK4cDAAAAAAAAAAAAfM7SwKxdu3ZWDgcAAAAAAAAAAAD4XMDVLgAAAAAAAAAAAAC4miwNzKZOnaobbrhB//73v3Xo0CErhwYAAAAAAAAAAAB8wtLAbMqUKdq8ebPGjRununXr6uabb9abb76p+Ph4Ky8DAAAAAAAAAAAAWMaywGzHjh3au3evJMnpdMrpdOr333/Xk08+qZo1a+r111+36lIAAAAAAAAAAACAZSwLzDZs2GDct9lsstlski6HZwEBAerTp49VlwIAAAAAAAAAAAAsY1lgduLECeO+0+k0/muz2dSxY0dVr17dqksBAAAAAAAAAAAAlrEsMCtVqlSejzVr1syqywAAAAAAAAAAAACWsiwwu+aaa/J87OLFi1ZdBgAAAAAAAAAAALCUZYHZ3/72N1WrVk2SjP3LpMvLMv72229WXQYAAAAAAAAAAACwlGWBWVBQkF588UVj/zLpf8HZpk2bNH/+fKsuBQAAAAAAAAAAAFjGssBMkgYPHqxJkyaZjtlsNjmdTg0ZMkSTJk1SSkqKlZcEAAAAAAAAAAAAvGJpYCZJY8aM0VdffaXo6GjjmM1mU3p6up555hlVqVJFffv21TvvvKMlS5Zo48aNOnjwoM6ePauUlBRlZmZaXRIAAAAAAAAAAACQpyArB3vjjTeM+8OGDdOUKVOUnp4u6X8zzS5evKgFCxZowYIFXl/PZrPJ4XB4PQ4AAAAAAAAAAAD8l6WB2ZNPPmnsW5Yte08zm81mPOa6zxkAAAAAAAAAAABwNVkamGVzF4i5C86svgYAAAAAAAAAAABQWD4JzFwDsZzBlhVBlxWBGwAAAAAAAAAAACBdwRlmAAAAAAAAAAAAQHHk8xlmAAAAAAAAAAAAQHFmeWDG7DIAAAAAAAAAAACUJJYGZoMHD7ZyOAAAAAAAAAAAAMDnLA3MZs2aZeVwAAAAAAAAAAAAgM8FXO0CAAAAAAAAAAAAgKuJwAwAAAAAAAAAAAB+jcAMAAAAAAAAAAAAfo3ADAAAAAAAAAAAAH4t6Epf8NSpU1q5cqX++OMP7d+/XwkJCUpPT1dYWJgqVqyoevXqqUWLFurYsaOioqKudHkAAAAAAAAAAADwM1csMFuyZInefPNNrV69WllZWabHnE6nbDab6VhwcLC6d++uJ554Qm3atLlSZQIAAAAAAAAAAMDP+HxJxn379qlDhw668847tWrVKmVmZsrpdJpuknIdy8jI0FdffaV27drprrvu0okTJ3xdKgAAAAAAAAAAAPyQT2eYffHFFxoyZIiSk5ONYCznTLL8ZPf56quvtGbNGi1YsEDt27f3RanAX0ZAQICuv/5607GsrCwdPXpUsbGxCggIyHU+AAAAAAAAAAD+zGeB2YcffqgRI0YoMzNTkjkoyw7C8mOz2Yw+TqdTZ8+eVbdu3bRgwQLdcccdvika+AsIDg7WnXfeaTpmt9u1dOlSde/eXcHBwVepMgAAAAAAAAAAiiefTC1ZunSpEZZlB185l2AsiOv52WOkp6frvvvu07p163xRNgAAAAAAAAAAAPyQ5YHZiRMnNGjQICMsk8wzyrLDL09u2VyXc0xLS9N9992nxMREq0sHAAAAAAAAAACAH7I8MHvyySeVkJCQZ1iWfaygm+v5OceJj4/XuHHjrC4dAAAAAAAAAAAAfsjSwGz37t369NNPc4VlrssyhoSEaNCgQZo3b5727NmjxMRE2e12nTt3Trt27dLHH3+sgQMHKiQkxFiO0VX2OB9++KEOHjxoZfkAAAAAAAAAAADwQ5YGZtOmTTNCMtewLHvW2O23365Dhw5p9uzZ6tOnj+rVq6fIyEgFBgaqXLlyuuaaa9SvXz/NmTNHBw8eVPfu3U2hmesss8zMTE2fPt3K8gEAAAAAAAAAAOCHLA3MvvjiC9OMsOywzGazadiwYfrmm29UqVIlj8aqXLmyFi9erKFDh+aaaZY97oIFC6wsHwAAAAAAAAAAAH7IssDs0KFDOnbsmCQZAVf2jLAmTZpoxowZRRp3xowZiouLyzWmJB05ckSHDx/2vngAAAAAAAAAAAD4LcsCs61bt7o9brPZ9K9//UsBAUW7VGBgoJ5//vk8H9+yZUuRxgUAAAAAAAAAAAAkCwOzI0eOGPddl08MDg5W9+7dvRq7e/fuCgkJyTV2zusCAAAAAAAAAAAAhWVZYHbx4kW3x6tUqaLQ0FCvxg4LC1OVKlXcPnbhwgWvxgYAAAAAAAAAAIB/sywwy0vOGWFWj1PUpR4BAAAAAAAAAAAAycLALDIy0u3xEydOKCMjw6uxMzIydOLEiUJdFwAAAAAAAAAAAPCEZYFZ1apVjftOp9O4n5GRoeXLl3s19rfffqv09PRcY0tSjRo1vBobAAAAAAAAAAAA/s2ywOy6665ze9zpdOqFF14o8rgF9c/rugAAAAAAAAAAAIAnLAvMateubcwys9lscjqdxr5jGzdu1GOPPVakcR977DFt2rQp15iSVKdOHVWvXt374gEAAAAAAAAAAOC3LAvMJOnOO+80LZmYHXA5nU5NnTpVAwYM0IULFzwa68KFC+rfv7/effddY4yc495xxx1Wlg8AAAAAAAAAAAA/FGTlYP/4xz80ffp00zHX0OyTTz7RkiVLNHjwYHXr1k033XSTypcvb5x77tw5/fHHH1q2bJnmzJmjCxcu5JpV5ur++++3snzgL8Fut2vZsmWmY1lZWTp69KiWLFmigABzTt6tWzcFBwdfyRIBAAAAAAAAAChWLA3MmjVrpttuu03fffedaVaYa2h2/vx5TZkyRVOmTJF0efnG8PBwpaSk5JpFlv14zvs2m01dunRRo0aNrCwf+EvIysrSpk2b3D6WkJCQ69htt93m65IAAAAAAAAAACjWLF2SUZLeeusthYaGSpJpZlh20JUdemXfsrKydOnSJWVlZZmOu56bc6zAwEBNnjzZ6tIBAAAAAAAAAADghywPzBo0aKBXX33VbdDleqygm+v5rv1tNpueeeYZZpcBAAAAAAAAAADAEpYHZpL06KOP6vHHH88zNHO9ucrrMdf+d911l55//nlflA0AAAAAAAAAAAA/5JPATJLeeOMNvfzyy0bbdeaYq7zCs5x9nE6nBg8erE8//dRXJQMAAAAAAAAAAMAP+Swwk6SxY8fq559/VuPGjXPtTVaYZRnLlSun2bNna9asWQoMDPRlyQAAAAAAAAAAAPAzPg3MJKl169b6888/NW/ePDVv3jzPZRdzHnc6napRo4YmTZqk/fv3a9CgQb4uFQAAAAAAAAAAAH4o6EpcJCAgQH369FGfPn106NAhLVmyRH/88Yf27NmjxMREORwORUREKCoqStdcc40aN26sDh06qEmTJleiPAAAAAAAAAAAAPixAgOzlStX6vjx42ratKkaNWqkoCDvMrZatWpp1KhRXo0BAAAAAAAAAAAAWKXA9GvChAlas2bN5ZODgtSwYUM1bdpUr7/+uipWrOjzAgEAAAAAAAAAAABfyjcwS09P16+//irp8h5jdrtdW7du1bZt2/Sf//wn1/nDhg1zO87DDz+sG264wYJyAQAAAAAAAAAAAGvlG5ht2bJFdrtdNptNNptN0uXgLCYmRhEREbnOnz17tnGeq7///e8EZgAAAAAAAAAAACiW8g3M9u/f7/Z4VFRUvoM6nU7jvrsADQAAAAAAAAAAACguAvJ78OTJk26PX7p0Kd9BXWekAQAAAAAAAAAAAMVZvoFZcnKy2+MnT57UsWPH8uznOsMMAAAAAAAAAAAAKM7yDcyCg4ON+64hmNPp1KBBg7Rx40alp6cXeBFmmwEAAAAAAAAAAKC4yncPs/Lly5varqHZ6tWr1bx581x9ss9x/e8999zjdaHu2Gw2ORwOn4wNAAAAAAAAAAAA/5BvYNawYcM8HyvMsoss0QgAAAAAAAAAAIDiKt/ArHnz5ipdurRSUlJks9lMs8bcLbOYVzDmiyUZCeEAAAAAAAAAAABghXz3MAsJCVHfvn3dhlNOpzPXLS/uzvXmBgAAAAAAAAAAAFgl38BMksaPH6/SpUtL8s1MMQAAAAAAAAAAAOBqKjAwi42N1ezZsxUQcPlUm82W5y0v+fUpyg0AAAAAAAAAAACwSoGBmSTdfffdWr58ua699toiLZVo9ZKMV2NZxv3792vs2LFq2bKloqOjFRISourVq6t169Z66aWXdOTIEZ/XkJSUpClTpqhr166qUaOGwsLCVLZsWTVp0kQjRozQmjVrPBrnxx9/vOIB5ubNm/Xoo4+qWbNmioqKUmhoqGrVqqX27dvr7bff1pkzZ7x5aQAAAAAAAAAAAIosyNMTO3TooG3btmnr1q36/fffdejQIZ07d07p6enKzMyUJM2ZM0c2m01Op9P033bt2qlmzZo+exK+5HA4NH78eL322mvG88wWHx+v+Ph4rVu3Ti+88IImTJigMWPGGLPxrPTee+/pmWee0blz50zH09PTtX37dm3fvl0zZsxQhw4dNH36dF1zzTWW11AUycnJevTRR/Xhhx/meuzw4cM6fPiwVq9erWeffVbvvPOOhg4dehWqBAAAAAAAAAAA/szjwCxbXFyc4uLi3D42Z84ct8cffvhh3XXXXYW91FWXmZmp++67T1988UWB59rtdo0bN06bN2/WJ598YlkNWVlZGjVqlKZPn+7R+atWrdJNN92kBQsWqGvXrpbVkZe6devm+dilS5fUtWtX/fLLLwWOc+nSJQ0bNky7d+/WpEmTrCwRAAAAAAAAAAAgX9ZPhZL+MvuMPffcc6awrHz58poyZYoOHz6s1NRU7d27VxMmTFB4eLhxzqeffqoXX3zRshpeeOGFXGHZLbfcoi+//FJnz55VSkqKNmzYoFGjRikwMFCSdPHiRfXq1Uvr1q1zO2b79u2LtAzm3r17FRkZaYwTGRmpxYsX51n7iBEjTGFZzZo1NXv2bJ04cUIpKSnaunWrRo8eraCg/+W2r776qj766KMivVYAAAAAAAAAAABF4ZPA7GrsMWa1HTt26NVXXzXasbGx2rRpkx5++GFj/7B69epp/PjxWr9+vSpUqGCcO3HiRB06dMjrGn777TdNnDjRdGzcuHH6+eef1aNHD5UvX16lSpXSDTfcoKlTp2rZsmVGeJeWlqb+/fsrOTnZ6zokKSUlRb169dL58+eNY3PmzFHDhg3dnr98+XLNmzfPaDdt2lSbN2/W4MGDVblyZZUqVUpNmjTR66+/ru+//16lSpUyzv2///s/Xbx40ZK6AQAAAAAAAAAACmJpYFa5cmVVq1ZNNWvWVI0aNYz/li5d2srLXBETJkww9iyz2WyaP3++YmNj3Z7buHFjLVy40JhZl5GRoQkTJnhdw8SJE03h4+DBg/Xyyy/nOYOvc+fOmjp1qtE+ePCgqe2Np556Stu2bTPaI0eOVI8ePfI8/7nnnjPuh4WFadGiRabZaa7atWun9957z2ifO3dOb775pgVVAwAAAAAAAAAAFMzSwGzUqFFKS0tT165dNWvWLB08eFAHDx7UbbfdZuVlfO7s2bNatGiR0e7SpYtatWqVb5+2bduaAqRPP/3Uq9ldZ86c0dKlS4122bJl9fbbbxfYb+jQoWrSpInRfuedd7ye8bdixQr95z//Mdp16tTR5MmT8zx/y5Yt+u2334z24MGDVbt27XyvMXDgQDVr1sxoz5w5s+gFAwAAAAAAAAAAFIKlgdn06dN17tw5zZgxQ3/7299UtWpVPf7443nupVVcLV26VBkZGUa7X79+HvVzPS81NTXf/b0KsmrVKlPQ1b9//zxnaOU0YMAA4/7x48e1du3aIteRlpamBx980HTsvffeMy2hmNOXX35pahfl9Tty5IgpdAMAAAAAAAAAAPAVywKzjRs3Kj4+XtLlPcycTqdOnjypKVOmqE2bNrn24irOVq5caWp37NjRo34dOnQwtV1niBXWjh078h07Py1atDC116xZU+Q6XnnlFR04cMBo9+3bV506dcq3j+vrFxYWVuDsvGxWvn4AAAAAAAAAAACesiww+/PPP437NpvNuDmdToWFhWnUqFFWXcrntmzZYtyPiYlR9erVPepXoUIFVatWzWj//vvvRa7h3LlzpnZBSxq6qlSpkqm9adOmItUQHx+v1157zWiXKlVKkyZNKrCf6+sXFxen4OBgj64XFxengID//ZX05vUDAAAAAAAAAADwlGWB2enTp4372UsJOp1O2Ww2denSRdHR0VZdyud27dpl3K9fv36h+tatW9e4f+DAgSLvH+a6JKQkRUREeNw3MDDQ1D58+HCRanjuueeUmppqtJ944gnVqFEj3z4nT55UUlKS0S7M6xcaGmoKJ/ft2+d5sQAAAAAAAAAAAEVkWWAWFRWV52PXXnutVZfxuYSEBKWlpRlt1xljnqhSpYpxPz093RQkFkb58uVz1eWpM2fOmNrZS2UWxt69ezVnzhyjHRUVpaeeeqrAfsePHze1vXn9jh49mu+5Z86c0ZkzZ3T27NlCXQMAAAAAAAAAAMCVZYFZfqFYSQo0cgZchZ0ZlzM4LEzQ5apWrVqm9saNGz3um3MJxgsXLhT6+pMmTVJmZqbRfvzxxxUZGVlgPytfv7S0NNMMt5wqVqyoihUrqlGjRoW6BgAAAAAAAAAAgKsgqwZq27at6tevr3379slms0mSsYfZzz//bCzPWNxdunTJ1C5Tpkyh+udcOvHixYtFqqNdu3am9rx58/Twww971HfBggWmtuuMOU/Ex8fr448/NtplypTR448/7lFfX7x+pUqVKtQYkmS322W32wvd76+gsM/bbreb9o4DcPVkv3/99d8voCTgfQqUDLxXgZKB9ypQMvBeBUoG3qtmRXkdLAvMbDab3nzzTd1555259u3as2eP3nnnHT322GNWXc5n0tPTTe3g4OBC9c95flH/cjZo0EBxcXHaunWrJGndunVasGCBevfunW+/JUuWaM2aNV7VMGPGDNMeakOHDvVodplUfF6/77//3uOa/2pcZwZ6Yvny5bn2vQNwda1YseJqlwCgALxPgZKB9ypQMvBeBUoG3qtAycB79bLz588Xuo9lgZkkde/eXR999JGGDRum9PR02Ww2Y5bZ6NGjtXPnTo0bN041a9a08rKWyhk2FHbmTc7zs7KyilzLuHHj1K9fP6M9fPhwRUdHq1OnTm7P/+OPPzR48OBcx0NCQjy+psPh0AcffGC0bTabHnnkEY/7F5fXr1OnToqJiSlS35IuPT3dCFo90aVLF4WGhvqwIgCestvtWrFihTp37lzoLxwAuDJ4nwIlA+9VoGTgvQqUDLxXgZKB96rZmTNnCt3H0sBMkvr27asGDRqoX79+2rNnjxGaZWVl6f3339cHH3yg5s2bq1WrVqpbt66qVKmicuXKqUyZMgoPD1doaKiCgoI8Xr6xRo0altYfFGR+SQo7W8fhcJja3gQRffv21WeffaZFixZJurzcYdeuXTVkyBANGzZMcXFxCgwM1J49ezR37lxNmTJF6enpKleunCpWrKjdu3cXuoZvv/1Wx48fN9qdOnVSvXr1PO5/JV+/7P3Szp49m2sfs+DgYL/9R6GwIaM/v1ZAccX7Eij+eJ8CJQPvVaBk4L0KlAy8V4GSgffqZUV5DSwNzB599FHjfps2bXTkyBFjib7smWZOp1Pr16/X+vXrvb6ezWbLFbB4Kzw83NQu7P5fqamppra3M3dmzZqlU6dOae3atZIuB1AzZ87UzJkz3Z5fqlQpffHFF3r++eeNwKww+4h98sknpvagQYMKVe+VfP38dQYZAAAAAAAAAACwlqWB2dSpU3PNDMvezyx7ppnrseIoOjra1L5w4UKh+l+8eNHULl++vFf1REZGauXKlXr88cf1/vvv5zt76KabbtJHH32khg0bKikpyThepUoVj66Vlpamr7/+2mhHRETorrvuKlS9Vr5+QUFBKlu2bKH6QwoMDFS7du1MxzIzM7V3717Vr18/135l7F8GAAAAAAAAAPB3li/JKLkPxNwFZ1ZfwwqVKlUyZsNJ/1v2z1OnTp0ytStWrOh1TWFhYZo+fbpGjRql2bNna8WKFTpy5IhSUlJUqVIltWjRQn379tVdd91l7AF24sQJo3/VqlU9us6PP/6oS5cuGe2uXbvmmjFWkMqVK5va3rx+MTExlvxd8TdBQUFq37696ZjdbtelS5fUtm1bpuMCAAAAAAAAAJCDTwIz15AjZ7BlRdDlyxAlNDRUVatWVXx8vCTp6NGjherven7VqlUVEhJiWW1xcXGaPHlygefFx8ebNrRr3LixR+MvW7bM1O7Ro0fhCpRUq1YtBQQEGDPhCvv6HTt2zLhfu3btQl8fAAAAAAAAAACgsAJ8MWj2XmXFeenF/DRp0sS4v3fvXmVmZnrUz+FwaN++fW7HuZJ+++03U7tZs2Ye9fv++++N+zabTd27dy/0tUNCQlS/fn2jvWvXLo/7xsfHm5ZkvFqvHwAAAAAAAAAA8C8+Ccyyl1301c3XWrZsadxPSUnRtm3bPOq3efNmpaWlGe2bb77Z61qcTqcSEhJMe5IV5KuvvjLuBwQEqEOHDgX2SUhI0M6dO412w4YNc+1H5inX12/Pnj1KTEz0qN+vv/5qalvx+gEAAAAAAAAAABTE8sDMdXaZL2++dNttt5naixcv9qjfN998Y2p36dKlyDVkZmaqdu3aCg0NVfny5TV27FiP+l24cMEUmN1yyy2qUKFCgf3WrVtnel1btWpV+KL/P9fXz+l0aunSpR71y/n6de7cucg1AAAAAAAAAAAAeMrSPcyef/55K4e7am6++WbVrFlThw8fliTNmDFDo0ePVlhYWJ59UlJS9P777xvtOnXqqHXr1kWuITAwUNHR0Tp06JCky2HSu+++q8DAwHz7vfHGGzp//rzRfuihhzy63saNG01tb2Z33XHHHSpdurSSk5MlSVOmTFG/fv3ynR14/PhxLViwwGi3b99e1atXL3INAAAAAAAAAAAAniIwcyMgIECjRo3SmDFjJElHjhzRI488YgrEcho5cqSOHz9utB999FGvl4+8++67jSDr+PHjmjZtmh5++OE8z//hhx/00ksvGe1GjRrpnnvu8ehaW7duNbVbtGhRhIovK1OmjAYPHqz//Oc/ki7vqfbyyy/rmWeecXu+3W7XwIEDlZqaahx7/PHHi3x9AAAAAAAAAACAwvDJHmZ/BaNGjVKtWrWM9gcffKD777/fmDWVLTk5WUOHDtV///tf49g111yjkSNHuh330KFDHu/Jdv/99ysyMtJojx49WnPnzs11nsPh0LRp03T77bfL4XBIujxDbfr06QoK8iwT3bNnj6ldu3Ztj/rl5dlnnzXVPn78eI0fP152u9103pkzZ9SjRw/98MMPxrH27durR48eXl0fAAAAAAAAAADAU5bOMPsrCQ8P17x589SpUyelpKRIkmbOnKmFCxfqjjvuULVq1XTs2DEtXrxYSUlJpn7z589XSEiI1zVUrFhRb7zxhoYPHy5JysjI0IABA/TKK6+oQ4cOioiIUHx8vL7//nudOHHC1HfKlCm69dZbPb7WkSNHjPuRkZEqW7asV7VXqVJFs2bN0r333qvMzEw5nU69+OKLmjlzprp3764KFSrowIEDWrx4sWlmWcWKFfXRRx95dW0AAAAAAAAAAIDCIDDLR6tWrbRkyRL17NnT2BcsKSkpz0AnKipKX331lZo1a2ZZDcOGDVNiYqKefvppZWZmSpK2b9+u7du3uz0/PDxc7733ngYMGODxNRwOhxITE412bGysd0X/f7169dLHH3+sIUOGKD09XZJ04sQJzZw50+351atX13fffcfeZQAAAAAAAAAA4IpiScYCtG/fXrt27dKQIUNUqlQpt+eEhIRo4MCB2rZtm9q2bWt5DaNHj9ZPP/2kjh075nlOeHi4hg0bpp07dxYqLJOUa5lJqwIzSerTp4+2bdumnj17Kjg42O05EREReuSRR7R161Y1atTIsmsDAAAAAAAAAAB44qrMMNu/f782b96sffv26cSJE0pISFBaWpqysrL02WefGeedP39epUqVsmR5Q29UrlxZs2bN0tSpU7V69WodPnxYCQkJioiIUP369dW6dWtFRUV5NFatWrXkdDoLXUPr1q21cuVKxcfH65dfftGxY8eUmpqqqKgoXXvttWrZsqVKly5d6HGly0swFqUmT9WrV0+LFi1SUlKSfvzxRx07dkznz59XVFSUGjRooFatWhW5dgAAAAAAAAAAAG9dscBsxYoV+uSTT7RkyRKdPXs21+NOp1M2m8107JNPPtFzzz2nBx54QGPGjFFkZOSVKtet0qVLq3v37le1hmrVqql3795XtYaiioqKUs+ePa92GQAAAAAAAAAAACY+X5JxyZIlatKkibp27ao5c+bozJkzcjqduW7ubNu2TWfPntWkSZPUoEEDffrpp74uFwAAAAAAAAAAAH7GZ4FZamqqBg0apDvvvFM7d+40gjGbzeb25s727dslXZ59dvr0afXv319PP/20r0oGAAAAAAAAAACAH/LJkowXL15Ut27dtG7dOmP2mGsolnNGWX6BWc5+r7/+ugICAvTKK6/4oHIAAAAAAAAAAAD4G8tnmGVlZal3795au3ataUZZzuUX8wrJsp0+fdrY68y1j9Pp1L///W8tWrTI6tIBAAAAAAAAAADghywPzN544w199913uYIySQUuwegqeznGbDlDs8cff1xpaWlWlw8AAAAAAAAAAAA/Y2lgdu7cOb3wwgtGIOa69GLOWWbBwcHGcXe2bdtm6ptzvGPHjmn27NlWlg8AAAAAAAAAAAA/ZGlg9u677yo5OVmScs0qczqduuWWW7Rw4UKdOXOmwNlhTZo0UfPmzXPtd5bN6XRqzpw5VpYPAAAAAAAAAAAAP2RpYDZv3jzTjLHsoEySxowZo59//lm9evVS+fLlCxyrQ4cO+u233zRjxoxcSzlm//f333/XhQsXrHwKAAAAAAAAAAAA8DOWBWbx8fHas2ePpMuzv7LDMpvNpm7dumnSpElFGvf+++/X448/bgRvrjPOnE6nNmzY4H3xAAAAAAAAAAAA8FuWBWZ//vlnno/961//8mrsJ554Is/HDhw44NXYAAAAAAAAAAAA8G+WBWaHDx827rsuyxgZGambbrrJq7GrVq1qLOPoOrYknT9/3quxAQAAAAAAAAAA4N8sC8zy2kusYsWKlowfHR3t9nhaWpol4wMAAAAAAAAAAMA/WRaYBQcHuz2elJRkyfinTp1ye7xUqVKWjA8AAAAAAAAAAAD/ZFlgVqlSJeO+0+k07p85c0b79+/3auxNmzYZM9hcx5akmJgYr8YGAAAAAAAAAACAf7MsMKtatWqej7355ptejZ1f/7p163o1NgAAAAAAAAAAAPxbkFUDtWjRQiEhIbLb7bLZbJIkm80mp9Op6dOnq3379rrnnnsKPe78+fP18ccfG2Nljy1dXgby+uuvt+opAH9p9qyrXQEAAAAAAGYZmdLFNIeCM692JQDyYrc7lObgvQoUd/m9VyNCg0zZCtyzLDCLiIhQhw4d9N1335nCLZvNpqysLPXt21cbN27UU089pXLlyhU4XmpqqiZPnqwJEybk+oPMHrt169YKCwuz6ikAfzkbDifq7mlr/38rSE/+tlyStHBka91Ys+D3IQAAAAAAVjuelKqXluzUd9tPyJEVJK3/4WqXBKBAQXr6d96rQPHn/r269V9dVCYs+CrUU7JYFphJ0pAhQ/Tdd98Z7ez9xmw2mzIzM/Xqq69q8uTJuv766xUbG+t2jJEjR+rIkSNas2aNLl26ZIRjOfcuk6SBAwdaWT7wl/LkZ5v1+YZjbh+7e9pa3Xtjdb12b9MrXBUAAAAAwJ99t/2kRny04WqXAQAAkItle5hJ0n333acWLVpIUq5ZYdmhl91u1/r16/XFF19IuhyqZYdhTqdTM2bM0LfffquLFy/mCstcx6xevboGDBhgZfnAX8aGw4l5hmXZPttwTBsOJ16higAAAAAA/u54UiphGQAAKLYsDcwk6Z133lFw8OWpfdkBl2vglfNYTtkBmuu5OR+32WyaPHmycR0AZv9bhtGa8wAAAAAA8NZLS3Ze7RIAAADyZHlg1qJFC82ePdtouwZk7oKznHKGajlnl9lsNj3wwAO65557rC4dAAAAAAAAPvLt9pNXuwQAAIA8WR6YSVKfPn00depUBQYGSnIfghU0wyyvWWl9+/bVtGnTfFE28JeQlJLh0/MBAAAAACisNHumMrPc/y4IAACgOPBJYCZJI0eO1OrVqxUbG5sr/MpvhlnO86TLQVl4eLhee+01ffzxx/n2Bfxdqj3Tp+cDAAAAAFBY9sysq10CAABAvnwWmElSq1attGXLFr300kuqUqVKnrPH3AVp2eeFhIRowIAB2rlzp0aPHu3LcgEAAAAAAAAAAOCHgnx9gbJly2rcuHF68skn9fXXX2vVqlVas2aNtm3bpqws998uql69upo3b65OnTqpb9++ioqK8nWZAAAAAAAAAAAA8FM+D8yyBQcH6+6779bdd98tSbLb7Tp37pwSExOVlJSkkJAQRUZGqkKFCgRkAAAAAAAAAAAAuGKuWGCWU3BwsCpXrqzKlStfrRIAAAAAAAAAAACAqxeYAQAAAAAAAO6sG9dREaH82gooDux2h1YsX67OXbooOJj3JVBc5fde5f+pnuFVAgAAAAAAQLESERqkMmHBV7sMAJLsgVJYkFQmLEjBwbwvgeKK96r3vA7MEhMTtX79eh09elSJiYnKyspS2bJlVbt2bTVt2lRVqlSxok4AAAAAAAAAAADAJ4oUmNntds2ZM0czZszQhg0b8j23WbNmevDBBzVkyBBSTQAAAAAAAAAAABQ7AYXtsG7dOjVt2lQjRozQhg0b5HQ6871t2rRJDz74oOLi4rR27VpfPAcAAAAAAAAAAACgyAoVmH3yySfq0KGDdu/ebQRiNpst35skOZ1O7dmzRx06dNCHH37okycCAAAAAAAAAAAAFIXHSzIuXrxYAwYMkNPplCRTGJaf7POky0s5/uMf/1CZMmV07733FqVeAAAAAAAAAAAAwFIezTA7fvy4EZZlzxzLnmFWENfzbDabsrKyNHz4cJ08edK7ygEAAAAAAAAAAAALeBSYjR8/XhcuXMh3Vpm7pRhdufZJTk7WM888U9SaAQAAAAAAAAAAAMsUGJglJSXp448/zjMsy7lXmetsMnfBWfbstP/+9786fPiw108AAAAAAAAAAAAA8EaBgdmXX34pu90uyX1Yln08PDxcN954o2644QZFRkYa4ZlraObaPysrS5999pklTwIAAAAAAAAAAAAoqgIDs/Xr1+c65rqPWUxMjD7++GMlJibq999/1x9//KGEhAQtXbpUN954Y67QzNWSJUu8fwYAAAAAAAAAAACAFwoMzA4ePGhqu84qi42N1fr169WvXz8FBQWZzuvatat++ukndenSJVdolh22bd++3YrnAAAAAAAAAAAAABRZgYHZqVOnch3LDsA++OAD1ahRI8++pUqV0pw5c1S2bFlJ/wvKsp07d07JyclFqRsAAAAAAAAAAACwRIGBWVJSkjE7zDXwatSokTp37lzgBSpVqqThw4fn2v8sm7tADgAAAAAAAAAAALhSCgzMLl26lOuYzWZTu3btPL7IrbfemudjCQkJHo8DAAAAAAAAAAAAWK3AwCwtLc3t8Zo1a3p8kXr16uX52MWLFz0eBwAAAAAAAAAAALBagYFZRkaG2+PlypXz+CIxMTF5PpaamurxOAAAAAAAAAAAAIDVCgzMMjMz3R4PCwvz+CJly5bN8zGHw+HxOAAAAAAAAAAAAIDVCgzMsrKy3B4PCQnx+CL5nZtXIAcAAAAAAAAAAABcCQUGZk6n0/Rfo2NAgV0NgYGBBY4PAAAAAAAAAAAAXA2ep145OxYiMAMAAAAAAAAAAACKK1IvAAAAAAAAAAAA+DUCMwAAAAAAAAAAAPi1IgdmNpvNkgKsGgcAAAAAAAAAAAAoiqDCnOx0Oo3/3nPPPYW+mGt/b8bJZrPZ5HA4itwfAAAAAAAAAAAAKFRg5io79PKWVeMAAAAAAAAAAAAARVHkwKywSynmFYwVdUlGgjYAAAAAAAAAAABYoUTOMGPfMwAAAAAAAAAAAFgl4GoXAAAAAAAAAAAAAFxNBGYAAAAAAAAAAADwax4vycgyiAAAAAAAAAAAAPgr8igws2q/MgAAAAAAAAAAAKC4KTAwy8rKuhJ1AAAAAAAAAAAAAFcFe5gBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZgBAAAAAAAAAADArxGYAQAAAAAAAAAAwK8RmAEAAAAAAAAAAMCvEZh5aP/+/Ro7dqxatmyp6OhohYSEqHr16mrdurVeeuklHTlyxOc1JCUlacqUKeratatq1KihsLAwlS1bVk2aNNGIESO0Zs0ar8ZPSUnRJ598onvvvVcNGzZUZGSkSpUqpdjYWPXs2VMffvih0tPTCzVmuXLlZLPZCn0LCgry6rkAAAAAAAAAAAB4ilSiAA6HQ+PHj9drr72mzMxM02Px8fGKj4/XunXr9MILL2jChAkaM2aMAgKszyHfe+89PfPMMzp37pzpeHp6urZv367t27drxowZ6tChg6ZPn65rrrmmUOMvWrRIjz32mI4ePZrrsWPHjunYsWP66quv9K9//Usff/yx2rZtW+CYhw4dUlJSUqHqAAAAAAAAAAAAuNKYYZaPzMxM3XfffZo0aVKusCwnu92ucePGqX///pbWkJWVpZEjR+rBBx/MFZa5s2rVKt1000369ttvPb7GxIkTddddd7kNy3I6evSo/va3v2nx4sUFnvvnn396XAMAAAAAAAAAAMDVQmCWj+eee05ffPGF0S5fvrymTJmiw4cPKzU1VXv37tWECRMUHh5unPPpp5/qxRdftKyGF154QdOnTzcdu+WWW/Tll1/q7NmzSklJ0YYNGzRq1CgFBgZKki5evKhevXpp3bp1BY4/efJkPffcc0Y7ODhYDzzwgNavX6/z588rISFB33zzjVq2bGmc43A4dN999+nQoUP5jr1582bjflhYmOx2u5xOp0c3h8PhycsDAAAAAAAAAADgNQKzPOzYsUOvvvqq0Y6NjdWmTZv08MMPG/uH1atXT+PHj9f69etVoUIF49yJEycWGCZ54rffftPEiRNNx8aNG6eff/5ZPXr0UPny5VWqVCndcMMNmjp1qpYtW2aEd2lpaerfv7+Sk5PzHH/z5s0aO3as0Y6MjNQPP/ygGTNmqHnz5ipbtqzKlSunv//97/rll180cOBA49yUlBQ9/fTT+dbvOsOscePG7EsGAAAAAAAAAACKJQKzPEyYMMFYhtFms2n+/PmKjY11e27jxo21cOFC2Ww2SVJGRoYmTJjgdQ0TJ06U0+k02oMHD9bLL79sXCenzp07a+rUqUb74MGDpnZOY8eONWZyZT/HNm3auD03MDBQM2bMUI0aNYxjixYt0pkzZ/Ic3zUwa9q0aZ7nAQAAAAAAAAAAXE0EZm6cPXtWixYtMtpdunRRq1at8u3Ttm1b9ejRw2h/+umn+c7uKsiZM2e0dOlSo122bFm9/fbbBfYbOnSomjRpYrTfeecdU+iWbdeuXaZ9zoYOHarbbrst37HDwsI0YsQIo22327Vy5Uq3554/f940y47ADAAAAAAAAAAAFFcEZm4sXbpUGRkZRrtfv34e9XM9LzU1VYsXLy5yDatWrTIFXf3791dkZKRHfQcMGGDcP378uNauXZvrnLlz5xr3AwMDNX78eI/GvuOOO1SpUiU1adJE7du3dxvGSeb9yyQCMwAAAAAAAAAAUHyxqZQbOWdNdezY0aN+HTp0MLWXLl2q++67r0g17NixI9+x89OiRQtTe82aNbrlllty1ZatTZs2qlWrlkdjx8XF6eTJkwWe57ocoyRdd911Ho0PAAAAAAAAAABwpTHDzI0tW7YY92NiYlS9enWP+lWoUEHVqlUz2r///nuRazh37pypXbt2bY/7VqpUydTetGmTqZ2cnGyaAda5c+ciVJg/1/Fr1qypcuXKWX4NAAAAAAAAAAAAKxCYubFr1y7jfv369QvVt27dusb9AwcO5LlkYUFcl4SUpIiICI/7BgYGmtqHDx82tbdt26bMzEyjff311xehwvy5zjBr2rSpsrKy9O2332ro0KFq2LChypQpo/DwcNWuXVv33HOPPvroI9ntdsvrAAAAAAAAAAAAKAiBWQ4JCQlKS0sz2q4zxjxRpUoV4356erpOnz5dpDrKly+fqy5PnTlzxtSOj483tfft22dq16xZ07i/c+dOPfvss2revLkqVaqksLAw1ahRQz169NCsWbM8CrUcDoe2b99utJOTk9W0aVN169ZNs2fP1u7du3Xp0iWlpqbq0KFDWrhwoQYNGqRrr71WK1as8Ph5AgAAAAAAAAAAWIHALIecAVd0dHSh+kdFRZnahQm6XOXcU2zjxo0e9825BOOFCxdM7aNHj5ralStX1sWLFzVy5Eg1btxYL730kv744w+dPn1a6enpOnr0qL7++msNGzZM1157rVavXp3v9Xfu3Kn09HSjvXLlSm3btq3Auvfv369u3bpp+vTpBZ4rXQ4Gz5w5o7Nnz3p0PgAAAAAAAAAAgDsEZjlcunTJ1C5Tpkyh+udcOvHixYtFqqNdu3am9rx58zzuu2DBAlPbdcaclHt/tPT0dN18882aPn16gUtI7t+/X507d9bHH3+c5zmu+5dlCwsL0z/+8Q/98ssvOnPmjFJSUrRnzx5NnTrVFA5mZmbqoYce0tdff51vHZJUsWJFVaxYUY0aNSrwXAAAAAAAAAAAgLwEXe0CihvXmVGSFBwcXKj+Oc8v6r5cDRo0UFxcnLZu3SpJWrdunRYsWKDevXvn22/JkiVas2ZNvjXkDPHuuece7dixQ5IUFxenp556Sh07dlRMTIzOnTun1atX69VXXzX2JbPb7Ro2bJhq1aqlNm3a5KrBdf8ySapTp44WLlyoZs2amY7Xr19f9evX1/DhwzVw4EB9/vnnkiSn06nBgwfrwIEDKleuXL7PNy92u91v90Sz2x2FPt9fXyuguMl+L/KeBIov3qdAycB7FSh+ivRZNbDg8wD4Hv9fBUoG3qtmRXkdCMxyyMzMNLUDAgo3CS/n+VlZWUWuZdy4cerXr5/RHj58uKKjo9WpUye35//xxx8aPHhwruMhISGmds6/KOvWrZMkjRgxQlOnTlVQ0P/+WlSpUkV9+vTRvffeq4ceekgzZswwxhg8eLB2795tOl+Srr32WvXq1UsHDhxQQkKCvv32W9WvXz/P5xkWFqZ58+bp2LFj+vXXXyVJSUlJmjx5sl588cU8++Xn+++/V2RkZJH6lnRJ6VJh3tqrfvhBUaE+KwdAEbCfI1D88T4FSgbeq0DxkebQ/2vvvqOjqvb3jz/phUBCSUJv0ntTCAHpCCgiICACIk2ky0WFy1VpIuJVBKlyKSqCigKiiEhVpINA6L2G3lJIIKTM7w9+zDeTZFraEOb9Wou1ss/Ze8+HYc4A88zeR/b8X3Xd2rXy5lMr4LHC36tAzsC1+lBkZKTdY/inRwopw5+UAZo1CQmm35jy8kp/EtG1a1f9+OOPWrFihaSH20W2atVKr7/+unr37q2qVavKzc1NJ06c0OLFizV9+nTFxcUpb968CgoK0vHjx22u4YUXXtDs2bPl4uKS5nk3NzfNnj1bJ06c0J9//ilJOnPmjBYvXpwqpOvTp4/69Olj1+/Vw8NDU6dOVb169YzHFi9enO7ArHnz5goMDEzX2JzuSuR9jdm72eb+TZo2VSF/7yysCICt4uPjtW7dOrVo0cLuFc4AsgfXKZAzcK0Cj5/o+wkauXujzf1btGyp3CRmwGOBv1eBnIFr1dSNGzfsHsO/PFLw9fU1aae8/5c19+7dM2lnJDCTpIULF+ratWvatm2bpIcB3vz58zV//vw0+/v4+Gj58uUaM2aMMTBLeR+2lCvOXF1dNWXKFLNhWfJ+H330kerXr288tmzZsjRXtaVH3bp1VaFCBR07dkySdO7cOZ0+fVpPPfVUmv2vX78uSbp582aq+5h5eHg47ZuCh4d921x4eLg77XMFPK6c+T0MyCm4ToGcgWsVeHx42Pd9ZP6vCjyG+HsVyBm4Vh9Kz3Ng336DTiBfvnwm7aioKLvGp7w/WP78+TNUj7+/vzZs2KD+/ftb3R6yTp062rt3rxo3bqyIiAjj8UKFCpn0y5Mnj0m7Vq1aFrdMTC4kJMRkvs2bbV/JZIu6deuatM+ePWu2b2BgoAIDA1WgQIFMrQEAAAAAAAAAADgXArMUgoODTVZaPVrFZKtr166ZtIOCgjJck7e3t+bMmaP9+/frX//6l6pWrSp/f395eHioaNGi6tChg3788Uft3LlTFSpUkCRduXLFOL5w4cIWa6pWrZpd9VStWtX4c2RkpGJjY+39LZkVHBxs0r5582amzQ0AAAAAAAAAAJAWtmRMwcvLS4ULF9alS5ckSRcvXrRrfPL+hQsXTrX9YUZUrVpVn332mdV+ly5dMtmfs3LlyibnS5UqZdLOlSuXXXUEBASYtO/cuZNqK8v0MhgMJu2MbmkJAAAAAAAAAABgDSvM0lClShXjzydPnlRiom0bbSckJOjUqVNpzpOddu7cadKuUaOGSTtlgJZ8NZot7t69a9JOGbhFRkbqxIkT+vvvv3XixAm75k65oo/tFgEAAAAAAAAAQFYjMEtD8vtoxcbG6tChQzaNCwsL0/37943tevXqZbgWg8Gg27dvm9yTzJqVK1caf3Z1dVWTJk1MzpcrV0558+Y1tg8ePGhXTWfOnDH+nDdvXpMVZ7/88osCAgJUvnx5Pfvss/roo4/smnv37t0mtdu7XSQAAAAAAAAAAIC9CMzS8Nxzz5m0V61aZdO4X3/91aTdsmXLdNeQmJioUqVKycvLS/nz59eoUaNsGhcVFWUSmIWGhqZapeXi4qJWrVoZ28ePH1dYWJhN84eHh+v48ePGdspQMGXAtW7dOiUlJdk095EjR3T06FFju3bt2vL397dpLAAAAAAAAAAAQHoRmKWhXr16KlGihLE9d+5ck5VjaYmNjdX//vc/Y7t06dKqX79+umtwc3NTvnz5FB8fL+lhGGfL1pBTpkxRZGSksT1w4MA0+/Xo0cOkPW7cOJvq+vzzz03uM9axY0eT8yVLljTZivLy5ctatmyZTXOPGTPGZO7+/fvbNA4AAAAAAAAAACAjCMzS4OrqqkGDBhnbFy5c0JAhQyyOGTBggC5fvmxsDx06VC4uLhmqI3kYdfnyZc2ePdti/40bN2rixInGdqVKlfTyyy+n2bdVq1aqXr26sb1ixQrNmzfP4vwbNmzQtGnTjO2goCC9+uqrqfr169fPpP2vf/1LV69etTj3F198oZ9++snYLl26tLp162ZxDAAAAAAAAAAAQGYgMDNj0KBBKlmypLE9b9489e3bVzExMSb9YmJi1KtXL33zzTfGY+XKldOAAQPSnPfcuXNycXEx+WVO3759TbYkHDFihBYvXpyqX0JCgmbPnq3nn39eCQkJkh6uUJszZ47c3d3TnNvFxUWzZ882Od+vXz+NHj1a0dHRqfp//fXXatu2rckqt48//lg+Pj6p+g4YMECVKlUytsPDw9WwYUPt2rUrVd+YmBiNGDFCw4YNMx5zdXXVggUL5O3tnWbtAAAAAAAAAAAAmSntNAXy9fXVkiVL1Lx5c8XGxkqS5s+fr2XLlqlt27YqUqSIwsPDtWrVKkVERJiM++GHH+Tp6ZnhGoKCgjRlyhT16dNHkvTgwQN1795dkyZNUpMmTeTn56dLly5p/fr1unLlisnY6dOnq2HDhhbnDwkJ0YIFC9SrVy9jEDZp0iTNnDlTLVu2VOnSpRUdHa0NGzboxIkTJmN79uypXr16pTmvh4eHli1bpgYNGujWrVuSpFOnTqlu3bqqX7++nnnmGXl5eenMmTP6448/FBUVZRzr4uKiefPmqVGjRvY9WQAAAAAAAAAAAOlEYGZBSEiIfvvtN7300kvG+4JFRERo0aJFafYPCAjQypUrVaNGjUyroXfv3rpz545GjhxpDLUOHz6sw4cPp9nf19dXX375pbp3727T/D169JCfn5/69OmjO3fuSJKioqJMtkdMacCAAZo+fbrFeStUqKBNmzapU6dOOn78uPH4tm3btG3btjTH+Pv7a8aMGTbXDgAAAAAAAAAAkBnYktGKxo0b69ixY3r99dfT3H5Qkjw9PdWjRw8dOnRIzz77bKbXMGLECG3evFlNmzY128fX11e9e/fW0aNH7Q6c2rdvrxMnTmjgwIHKmzev2X6hoaFau3atZs2aJTc3N6vzVq1aVf/8848+/vhjFSlSxGy/gIAA9e3bN121AwAAAAAAAAAAZBQrzGxQsGBBLVy4UDNmzNBff/2l8+fP6/bt2/Lz81PZsmVVv359BQQE2DRXyZIlZTAY7K6hfv362rBhgy5duqStW7cqPDxc9+7dU0BAgCpWrKi6desqV65cds/7SIECBTRz5kxNmzZNW7Zs0ZkzZ3T9+nW5ubmpePHiCgkJUfHixe2eN1euXBo5cqTeffddHT58WHv37tWNGzeUkJCg4OBglShRQg0aNJCHh0e6awcAAAAAAAAAAMgIAjM75MqVS23atHFoDUWKFFHnzp2zbH53d3c1btxYjRs3ztR5XVxcVKVKFVWpUiVT5wUAAAAAAAAAAMgotmQEAAAAAAAAAACAUyMwAwAAAAAAAAAAgFMjMAMAAAAAAAAAAIBTIzADAAAAAAAAAACAUyMwAwAAAAAAAAAAgFMjMAMAAAAAAAAAAIBTIzADAAAAAAAAAACAUyMwAwAAAAAAAAAAgFMjMAMAAAAAAAAAAIBTIzADAAAAAAAAAACAUyMwAwAAAAAAAAAAgFMjMAMAAAAAAAAAAIBTIzADAAAAAAAAAACAUyMwAwAAAAAAAAAAgFMjMAMAAAAAAAAAAIBTIzADAAAAAAAAAACAU3N3dAEAHOvu/QRFe8U7ugwAkuLjE3Q/QYq+nyCPREdXAyAt8fEJesD1CeQIDxL5OxV4nNyNS3B0CQAAABYRmAFOrsXnmx1dAgAT7hq5e6OjiwBgkbs+PfqXQssW0Nsty6twgI+jCwLw/12OuKfJvx/TuiNXFRvvLu3i71QAAAAAtiEwAwAAAOx0LTpOy/de0uqDV/TFKzXVsnJBR5cEOL0/Dl/VgG//UZLB0ZUAAAAAyIm4hxkAAACQTvfjkzT0+326HHHP0aUATu1yxD3CMgAAAAAZQmAGAAAAZMD9+CR9uva4o8sAnNrk348RlgEAAADIEAIzAAAAIIO2nbrl6BIAp7b2yDVHlwAAAAAghyMwA54w7q5c1gAAZLerUfd1Pz7R0WUATul+fKLucf0BTxwPN/5vCwAAshf/+gCeMN4eXNYAADhCfGKSo0sAnBLXHvBk8vZwc3QJAADAyfDJOgAAAAAAAB4bTxcLcHQJAADACRGYAQAAAAAA4LHxRfdaji4BAAA4IQIzAAAAAAAAPBbm9qitQv4+ji4DAAA4IXdHFwAAAAAAAADn5SKD6hTLq2ndaqlwAGEZAABwDAIzwMlt/3dT+XnxVgA8DuLjE7Ru7Vq1aNlSHh5cl4Cj3Y1LUMikjY4uA0Am49+/wOMjPj5BG9at1Utt28jDw8PR5QAAACfH/xIAJ+fn5a7c3vzHBHgcxLtJ3u5Sbm93PjAAACCL8O9f4PER7yZ5ujm6CgAAgIe4hxkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBtKADxwAAXZtJREFUGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnJq7owsAAAAAngR34xIcXQLglLj2AAAAAGQGAjMAAAAgE4RM2ujoEgAAAAAAQDqxJSMAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAkAYPN/6pDDyJuLYBAAAApIX/KQAAAABp8PZwU15fD0eXASATubo8vLYBAAAAICUCMwAAAMCMxuWDHF0CgEzUqnIhR5cAAAAA4DFFYAYAAACY8c5z5eXp5uLoMgBkkvfbVnR0CQAAAAAeUwRmAAAAgBmFA3w049VahGbAE2Buj9oq5O/j6DIAAAAAPKYIzAAAAAALWlYuqD/faaL2NYsoH/c0A3IUNxepTZVC2jaqqVpWLujocgAAAAA8xtwdXQAAAADwuCsc4KPPu9RQfHy8fv51tZq1aCkPD/4pDTyu4uMTtGHdWr3Uto08PAi6AQAAAFjH//IBAAAAO3i6Sbm93fkQHniMxbs9vFYBAAAAwFZsyQgAAAAAAAAAAACnRmAGAAAAAAAAAAAAp0ZgBgAAAAAAAAAAAKdGYAYAAAAAAAAAAACnRmAGAAAAAAAAAAAAp0ZgBgAAAAAAAAAAAKdGYAYAAAAAAAAAAACnRmAGAAAAAAAAAAAAp0ZgBgAAAAAAAAAAAKdGYAYAAAAAAAAAAACnRmBmo9OnT2vUqFGqW7eu8uXLJ09PTxUtWlT169fXxIkTdeHChSyvISIiQtOnT1erVq1UvHhxeXt7K0+ePKpSpYr69++vLVu2ZGj+2NhYfffdd+rUqZMqVKggf39/+fj4qFixYnrppZe0YMECxcXFpWvusLAwDR06VDVq1FBAQIC8vLxUsmRJNW7cWNOmTdONGzcyVDsAAAAAAAAAAEB6uTu6gMddQkKC3n//ff33v/9VYmKiyblLly7p0qVL2r59u8aNG6fx48fr3Xfflatr5ueQX375pf7zn//o1q1bJsfj4uJ0+PBhHT58WHPnzlWTJk00Z84clStXzq75V6xYoWHDhunixYupzoWHhys8PFwrV67U2LFj9e233+rZZ5+1ad6YmBgNHTpUCxYsSHXu/PnzOn/+vP766y+99957+uKLL9SrVy+76gYAAAAAAAAAAMgoVphZkJiYqC5duujjjz9OFZalFB8fr3//+9/q1q1bptaQlJSkAQMG6M0330wVlqVl06ZNqlOnjtasWWPzY0yYMEEdOnRIMyxL6eLFi2rWrJlWrVplte/du3f13HPPpRmWpdW3d+/eGjVqlE01AwAAAAAAAAAAZBYCMws++OADLV++3NjOnz+/pk+frvPnz+vevXs6efKkxo8fL19fX2Of77//Xh9++GGm1TBu3DjNmTPH5FhoaKh+/vln3bx5U7Gxsfrnn380aNAgubm5SZKio6PVvn17bd++3er8n332mT744ANj28PDQ/369dOuXbsUGRmp27dv69dff1XdunWNfRISEtSlSxedO3fO4tz9+/fX1q1bje0SJUroq6++0pUrVxQbG6uDBw9qxIgRcnf/v4WOkydP1qJFi6zWDQAAAAAAAAAAkFkIzMw4cuSIJk+ebGwXK1ZM+/bt0+DBg433DytTpozef/997dq1SwUKFDD2nTBhgtUwyRY7d+7UhAkTTI79+9//1t9//6127dopf/788vHxUa1atTRjxgz9/vvvxvDu/v376tatm2JiYszOHxYWZrKiy9/fXxs3btTcuXP19NNPK0+ePMqbN69eeOEFbd26VT169DD2jY2N1ciRI83OvXbtWi1ZssTYrl69usLCwtSzZ08VLFhQPj4+qlKlij799FOtX79ePj4+xr7Dhw9XdHS07U8UAAAAAAAAAABABhCYmTF+/HjjNowuLi764YcfVKxYsTT7Vq5cWcuWLZOLi4sk6cGDBxo/fnyGa5gwYYIMBoOx3bNnT3300UfGx0mpRYsWmjFjhrF99uxZk3ZKo0aNUkJCgqT/+z02aNAgzb5ubm6aO3euihcvbjy2YsUK3bhxI83+yVeteXt7a8WKFfL390+zb6NGjfTll18a27du3dLnn39utm4AAAAAAAAAAIDMRGCWhps3b2rFihXGdsuWLRUSEmJxzLPPPqt27doZ299//73F1V3W3LhxQ6tXrza28+TJo2nTplkd16tXL1WpUsXY/uKLL0xCt0eOHTtmcp+zXr166bnnnrM4t7e3t/r3729sx8fHa8OGDan6HThwQDt37jS2e/bsqVKlSlmcu0ePHqpRo4axPX/+fIv9AQAAAAAAAAAAMguBWRpWr16tBw8eGNuvvvqqTeOS97t3755WrVqV7ho2bdpkEnR169bN7AqtlLp37278+fLly9q2bVuqPosXLzb+7Obmpvfff9+mudu2bavg4GBVqVJFjRs3TjOM+/nnn03a6Xn+Lly4YBK6AQAAAAAAAAAAZBUCszSkXDXVtGlTm8Y1adLEpJ18hZi9jhw5YnFuS5555hmT9pYtW1L1SV5bgwYNVLJkSZvmrlq1qq5evaqDBw9q06ZN6tq1a6o+yZ8/b29vq6vzHsnM5w8AAAAAAAAAAMBWBGZpOHDggPHnwMBAFS1a1KZxBQoUUJEiRYzt3bt3p7uGW7dumbStbWmYXHBwsEl73759Ju2YmBiFhYUZ2y1atEhHheYlf/6qVq0qDw8Pm8ZVrVpVrq7/95LMyPMHAAAAAAAAAABgKwKzNBw7dsz4c9myZe0a+9RTTxl/PnPmTJpbFtoi+ZaQkuTn52fzWDc3N5P2+fPnTdqHDh1SYmKisV2zZs10VJi2q1evKiIiwti25/nz8vIyCSdPnTqVaXUBAAAAAAAAAACYQ2CWwu3bt3X//n1jO/mKMVsUKlTI+HNcXJyuX7+erjry58+fqi5b3bhxw6R96dIlk3bKIKpEiRLGn48ePar33ntPTz/9tIKDg+Xt7a3ixYurXbt2WrhwoeLj4y0+9uXLl03aGXn+Ll68aLHvjRs3dOPGDd28edOuxwAAAAAAAAAAAEiOwCyFlAFXvnz57BofEBBg0rYn6Eou5T3F9u7da/PYlFswRkVFmbRTBlEFCxZUdHS0BgwYoMqVK2vixInas2ePrl+/rri4OF28eFG//PKLevfurYoVK+qvv/4y+9iZ+fzdv39f9+7dM9s3KChIQUFBqlSpkl2PAQAAAAAAAAAAkJy7owt43Ny9e9eknTt3brvGp9w6MTo6Ol11NGrUyKS9ZMkSDR482KaxS5cuNWknXzEnpb4/WlxcnJ599lkdOXLE6tynT59WixYttGDBAnXv3j3V+ax4/nx8fOyaQ5Li4+OtroZ7UsXHJ9jdP97Nej8AWe/R+5azvn8BOQHXKZAzcK0COQPXKpAzcK0COQPXqqn0PA8EZinExcWZtD08POwan7J/el+c5cuXV9WqVXXw4EFJ0vbt27V06VJ17tzZ4rjffvtNW7ZssVhDyhDv5ZdfNoZlVatW1TvvvKOmTZsqMDBQt27d0l9//aXJkydr//79xvl69+6tkiVLqkGDBiZzPS7P3/r16+Xv75+usTnd/QTJnkt73dq18uadAHisrFu3ztElALCC6xTIGbhWgZyBaxXIGbhWgZyBa/WhyMhIu8fwMXkKiYmJJm1XV/t2rUzZPykpKd21/Pvf/9arr75qbPfp00f58uVT8+bN0+y/Z88e9ezZM9VxT09Pk3bKEGr79u2SpP79+2vGjBlyd/+/l0WhQoX0yiuvqFOnTho4cKDmzp1rnKNnz546fvy4Sf/H5flr3ry5AgMD0zU2p4u+n6CRuzfa3L9Fy5bKTWIGPBbi4+O1bt06tWjRwu4vHADIHlynQM7AtQrkDFyrQM7AtQrkDFyrpm7cuGH3GD4lTyF5+COlDoCsSUgw3Q7Py8sr3bV07dpVP/74o1asWCHp4XaHrVq10uuvv67evXuratWqcnNz04kTJ7R48WJNnz5dcXFxyps3r4KCgnT8+HGba3jhhRc0e/Zsubi4pHnezc1Ns2fP1okTJ/Tnn39Kks6cOaPFixebhHTZ+fw9ul/azZs3U93HzMPDw2nfFDzse8rl4eHutM8V8Lhy5vcwIKfgOgVyBq5VIGfgWgVyBq5VIGfgWn0oPc+Bfct/nICvr69JO+X9v6y5d++eSTsjgZkkLVy4UPXr1ze2ExMTNX/+fIWGhipPnjzKlSuXatasqU8//VRxcXHy8fHR8uXLFRwcbByT8j5iKVecubq6asqUKWbDsuT9PvroI5Njy5YtM2ln5/MXGBiowMBAFShQwK7HAAAAAAAAAAAASI7ALIV8+fKZtKOiouwan/L+YPnz589QPf7+/tqwYYP69+9vdXvDOnXqaO/evWrcuLEiIiKMxwsVKmTSL0+ePCbtWrVqqWzZsjbVExISYjLf5s2bTc5n5vPn7u6eqlYAAAAAAAAAAIDMRmCWQnBwsMlKq0fb/tnq2rVrJu2goKAM1+Tt7a05c+Zo//79+te//qWqVavK399fHh4eKlq0qDp06KAff/xRO3fuVIUKFSRJV65cMY4vXLiwxZqqVatmVz1Vq1Y1/hwZGanY2Fhju2DBgiZ9M/L8BQYGWl31BgAAAAAAAAAAkFHcwywFLy8vFS5cWJcuXZIkXbx40a7xyfsXLlw41faHGVG1alV99tlnVvtdunTJ5IZ2lStXNjlfqlQpk3auXLnsqiMgIMCkfefOHeNWjCVLlpSrq6uSkpIk2f/8hYeHm60TAAAAAAAAAAAgK7DCLA1VqlQx/nzy5EklJibaNC4hIUGnTp1Kc57stHPnTpN2jRo1TNopA7Tkq9FscffuXZN28sDN09PTZHvHY8eO2TzvpUuXTLZkdNTzBwAAAAAAAAAAnAuBWRrq1q1r/Dk2NlaHDh2yaVxYWJju379vbNerVy/DtRgMBt2+fdvknmTWrFy50vizq6urmjRpYnK+XLlyyps3r7F98OBBu2o6c+aM8ee8efOmWnGW/Pk7ceKE7ty5Y9O8O3bsMGlnxvMHAAAAAAAAAABgDYFZGp577jmT9qpVq2wa9+uvv5q0W7Zsme4aEhMTVapUKXl5eSl//vwaNWqUTeOioqJMArPQ0FAVKFDApI+Li4tatWplbB8/flxhYWE2zR8eHq7jx48b22mFWsmfP4PBoNWrV9s0d8rnr0WLFjaNAwAAAAAAAAAAyAgCszTUq1dPJUqUMLbnzp1rsnIsLbGxsfrf//5nbJcuXVr169dPdw1ubm7Kly+f4uPjJT0Mk2zZGnLKlCmKjIw0tgcOHJhmvx49epi0x40bZ1Ndn3/+uQwGg7HdsWPHVH3atm1rsk3j9OnTTcak5fLly1q6dKmx3bhxYxUtWtSmmgAAAAAAAAAAADKCwCwNrq6uGjRokLF94cIFDRkyxOKYAQMG6PLly8b20KFD5eLikqE6kodRly9f1uzZsy3237hxoyZOnGhsV6pUSS+//HKafVu1aqXq1asb2ytWrNC8efMszr9hwwZNmzbN2A4KCtKrr76aql/u3LnVs2dPY3vnzp366KOPzM4bHx+vHj166N69e8Zjb731lsVaAAAAAAAAAAAAMguBmRmDBg1SyZIlje158+apb9++iomJMekXExOjXr166ZtvvjEeK1eunAYMGJDmvOfOnZOLi4vJL3P69u0rf39/Y3vEiBFavHhxqn4JCQmaPXu2nn/+eSUkJEh6uEJtzpw5cnd3T3NuFxcXzZ492+R8v379NHr0aEVHR6fq//XXX6tt27Ymq9w+/vhj+fj4pDn/e++9Z1L7+++/r/fff9+4Yu6RGzduqF27dtq4caPxWOPGjdWuXbs05wUAAAAAAAAAAMhsaacpkK+vr5YsWaLmzZsrNjZWkjR//nwtW7ZMbdu2VZEiRRQeHq5Vq1YpIiLCZNwPP/wgT0/PDNcQFBSkKVOmqE+fPpKkBw8eqHv37po0aZKaNGkiPz8/Xbp0SevXr9eVK1dMxk6fPl0NGza0OH9ISIgWLFigXr16GYOwSZMmaebMmWrZsqVKly6t6OhobdiwQSdOnDAZ27NnT/Xq1cvs3IUKFdLChQvVqVMnJSYmymAw6MMPP9T8+fPVpk0bFShQQGfOnNGqVatMVpYFBQVp0aJFdj1PAAAAAAAAAAAAGUFgZkFISIh+++03vfTSS8b7gkVERJgNdAICArRy5UrVqFEj02ro3bu37ty5o5EjRxpDrcOHD+vw4cNp9vf19dWXX36p7t272zR/jx495Ofnpz59+ujOnTuSpKioKP30009mxwwYMEDTp0+3Onf79u317bff6vXXX1dcXJwk6cqVK5o/f36a/YsWLao//viDe5cBAAAAAAAAAIBsxZaMVjRu3FjHjh3T66+/bnb7QU9PT/Xo0UOHDh3Ss88+m+k1jBgxQps3b1bTpk3N9vH19VXv3r119OhRm8OyR9q3b68TJ05o4MCByps3r9l+oaGhWrt2rWbNmiU3Nzeb5n7llVd06NAhvfTSS/Lw8Eizj5+fn4YMGaKDBw+qUqVKdtUOAAAAAAAAAACQUawws0HBggW1cOFCzZgxQ3/99ZfOnz+v27dvy8/PT2XLllX9+vUVEBBg01wlS5aUwWCwu4b69etrw4YNunTpkrZu3arw8HDdu3dPAQEBqlixourWratcuXLZPe8jBQoU0MyZMzVt2jRt2bJFZ86c0fXr1+Xm5qbixYsrJCRExYsXT9fcZcqU0YoVKxQREaE///xT4eHhioyMVEBAgMqXL6+QkJAM1Q4AAAAAAAAAAJARBGZ2yJUrl9q0aePQGooUKaLOnTtn2fzu7u5q3LixGjdunOlzBwQE6KWXXsr0eQEAAAAAAAAAADKCLRkBAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1NwdXQCAzOXn5a6DY1uaHIuPT9C6tWvVomVLeXi4p+oPAAAAAAAAAIAz45Ny4Anj4uKi3N4eJsfi3SRvdym3t7s8PDzMjAQAAAAAAAAAwDmxJSMAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJyau6MLADIqKSkp1bGbN286oJLHV3x8vCIjI3Xjxg15eHg4uhwAZnCtAo8/rlMgZ+BaBXIGrlUgZ+BaBXIGrlVTaWUEaWUJyRGYIce7fft2qmOVKlVyQCUAAAAAAAAAAOBxdPv2bQUHB5s9z5aMAAAAAAAAAAAAcGoEZgAAAAAAAAAAAHBqBGYAAAAAAAAAAABwai4Gg8Hg6CKAjEhISNDJkydNjuXLl0+uruTBN2/eTHU/tyNHjqhAgQIOqghAWrhWgccf1ymQM3CtAjkD1yqQM3CtAjkD12rakpKSdPv2bZNjZcuWlbu7u9kx5s8AOYS7u7sqVqzo6DJyjAIFCigwMNDRZQCwgmsVePxxnQI5A9cqkDNwrQI5A9cqkDNwrT4UHBxsV3+W4AAAAAAAAAAAAMCpsSUjAAAAAAAAAAAAnBorzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMyAJ1BCQoK+++47denSRaVKlVKuXLnk7e2tkiVLqmPHjlq8eLHi4+MdXSYAC/bt2ydPT0+5uLjIxcVF586dc3RJgFOqUaOG8Tq091d4eLijywecisFg0Pr16zVgwABVq1ZNgYGB8vT0VHBwsBo3bqyPPvpIN27ccHSZgFNJ79+haf36888/Hf3bAZzK/v37NXz4cNWqVcv4d2qBAgVUo0YNDRkyRNu3b3d0iQAkrV69Wn369FGFChUUEBAgb29vFStWTO3atdOCBQsUExPj6BJzFBeDwWBwdBEAMs+2bdv02muv6fTp0xb7lSpVSt98840aNGiQTZUBsFVcXJzq1KmjQ4cOGY+dPXtWJUuWdFxRgBOKj4+Xn5+fHjx4kK7xFy9eVNGiRTO5KgBpOXDggAYMGKBt27ZZ7Ofr66v//ve/GjhwYDZVBjg3FxeXTJtr06ZNaty4cabNByBtUVFReuONN/TDDz9Y7du6dWstXLhQwcHB2VAZgOQOHjyoN954Qzt27LDYr2DBgvrkk0/Uo0ePbKosZ2OFGfAEWb58uRo1amQ1LJMefvjeuHFjzZo1KxsqA2CP999/3yQsA+AYhw8fTndYBiD7rF27VvXq1bMalklSbGysBg0apFGjRmVDZQAyi7e3N19CAbLB7du3FRISYlNYJkm///67ateuzY4oQDZbu3atQkNDrYZlknT16lW99tpr6t+/v1g7ZR2BGfCECAsLU9euXZWQkGA89vzzz2vDhg2KjIzUvXv3tH//fg0bNkxubm6SpMTERA0dOpStLYDHyNatW/XZZ585ugwAevh3a3Lh4eEyGAw2/+KDPSDrbd26Ve3atdO9e/eMx5o3b64//vhDV69e1d27d7V9+3Z169bNZNzkyZO1dOnS7C4XcDr2/L356Ne9e/dUu3Ztk3nmz5+vMmXKOOh3ATiPV155RUeOHDG2CxYsqJkzZ+r8+fN68OCBLl++rAULFqhEiRLGPpcuXdLzzz/PF82AbHL48GF16NBB0dHRxmP58+fXp59+qtOnT+v+/fu6ePGi5syZo8KFCxv7zJ07V2+99ZYDKs5Z2JIReELUq1dPO3fuNLbHjBmjsWPHptl31apVeumll5SYmChJKlGihE6ePCkPD4/sKBWAGTExMapevXqaq0TZkhHIfsOHD9fUqVMlPfwPyM2bNx1bEAATsbGxqlSpks6fP2889sUXX2jIkCFp9p87d6769+9vbBcpUkRnz57l38DAY6ZPnz5asGCBsT18+HBNmTLFgRUBzuGXX35Ru3btjO2yZctq8+bNKliwYKq+d+7cUbNmzbRv3z7jsSlTpmj48OHZUivgrJKSklS9enWTXYmqV6+uNWvWmL1WW7dubfKZ8W+//aY2bdpkS705ESvMgCfA33//bfLG16xZM7NhmSS98MILGjx4sLF9/vx5/fLLL1lZIgAbvP322zZtqQoge+zfv9/4c/Xq1R1XCIA0TZ8+3SQsGz16tNmwTJLeeOMNde7c2di+dOmSfvvttyytEYB9fvzxR5OwrEaNGvr4448dWBHgPL7++muT9jfffJPmB/CSlDdvXn333XfGHYzSGg8g8y1fvtwkLAsKCtIff/xh8VpduXKlAgMDjcfeeecdJSUlZXmtORWBGfAEWLJkiUl79OjRVsf07t3bpL127dpMrQmAfdauXas5c+ZIklxdXdWyZUsHVwTgwIEDxp8JzIDHS2JioqZPn25sV6hQweIXxh4ZNmyYSXvNmjWZXRqAdLp27ZoGDBhgbHt4eGjRokXy9PR0YFWA80h+L9DSpUurXr16FvuXL19edevWNbbDwsJ0//79LKsPgPTVV1+ZtD/++GMFBwdbHBMcHKyRI0ca20eOHNH69euzorwnAoEZ8ARIvrosICBAjRs3tjqmXLlyJu0zZ85kdlkAbBQREWESYo8YMUIhISEOrAjAhQsXdPv2bWObwAx4vPz555+6dOmSsT169GibtlYMCQnRU089pXLlyik0NFR58+bNyjIB2GH48OG6deuWsf3uu++qSpUqDqwIcC43btww/mxutUpKye9llnIOAJkrISFBmzdvNrb9/f1T3afXnO7du5u0f/zxx0yt7Uni7ugCAGTcnj17dOLECYWFhSk6Olqurtaz8OQ3RpckFxeXrCoPgBWDBw82fuhXsWJFjR8/nq1nAAdLvh2jRGAGPG5Wr15t/NnX11cdO3a0aZyLi4tOnTqVVWUBSKdNmzbpu+++M7ZLlSql9957z4EVAc7H09PT+FnRxYsXbRpz9epVk3aePHkyvS4AD4WHhys6OtrYDg0NtXkVdnBwsIoXL64LFy5IkrZs2ZIlNT4JWGEGPAFcXV1VoUIFdenSRX379rVpzN69e03aZcqUyYrSAFixfPlyLV68WJLk5uamr7/+Wt7e3g6uCkBYWJjxZw8PD1WqVMmB1QBIaevWrcaf69evL19fXwdWAyAjkpKSNHz4cJNjn3zyCf8mBrJZtWrVjD9fvHjR6gfqFy9eNPn7uGLFivL398+y+gBnl3wVtvTwyyX2SL5144kTJxQTE5MpdT1pCMwAJ/Xpp5+atNu1a+egSgDndf36dfXv39/YHjlypJ5++mkHVgTgkeQrzCpWrChPT09t2bJFAwcOVLVq1eTv7y9vb28VL15czz//vGbPns1/OIBsYjAYTO4xWLNmTQdWAyCjFi9ebPJFldDQUL388ssOrAhwTim3duvTp4+uX7+eZt/Y2Fj16NFDDx48MB4bOnRoltYHOLvk15sk+fn52TXezc3N+HNSUpLCw8Mzpa4nDYEZ4GTu37+vN9980+QG56GhoXruueccWBXgnN544w3dvHlTklS1alWNGTPGwRUBeCR5YObp6akGDRqoYcOGmj17tg4ePKioqCjFxcXp4sWLWr16tQYOHKgyZcpoyZIljisacBKXL1822V48+f1Trl+/runTp6tp06YqXry4vL29VbBgQT377LOaPHmy8e9dAI+HhIQEjR071uTYxIkTHVMM4OT69+9v8iWUEydOqGbNmpozZ44uXryohIQE3bhxQz/88IOefvpp/fXXX8a+7dq10xtvvOGIsgGnkT9/fpN28ntu2yLlPQaT3w8Y/4d7mAFPuMTERMXFxen06dNas2aNZs6cqfPnzxvPlyxZUsuWLXNghYBz+uqrr7Ry5UpJD7d7+/rrr23eexpA1oqOjtbZs2eN7T179tg07urVq+rWrZsOHz7Mh31AFkp5X5WCBQsqKSlJM2fO1OjRo3X37l2T89euXdO1a9f0999/a9KkSZo4caIGDRqUnSUDMOO7777TmTNnjO3GjRurUaNGDqwIcF6enp76/fff1bFjR+NWi5cvX9aAAQMsjhkxYoTGjx8vV1fWZQBZqUiRInJ3d1dCQoKk1LfbsSQyMtLk71tJioqKytT6nhS8kwFPuJYtWypXrlyqVq2a3n33XZOw7IUXXtDmzZtN9rAFkPUuXryot956y9gePXo020kBj5GwsDAZDAaTY66ururatavWr1+vK1eu6P79+zp37pwWLlyoqlWrmvT96KOPNGPGjOwsGXAqKe/f4OPjox49emjo0KGpwrKUIiMjNXjwYA0cODArSwRgo8mTJ5u033//fQdVAkB6eI+jzZs366uvvlJgYKDFvp6enpo1a5YmTpwod3fWZABZLVeuXKpTp46xvXfvXh07dsymsT/99FOq/+Pev38/U+t7UhCYAU+4CxcupHk8T548qlmzZqo3SwBZy2AwqFevXoqMjJT08L4r//nPfxxcFYDkkm/HKEmBgYFat26dlixZombNmqlgwYLy8vJSiRIl9Prrr2v//v2p7tkwfPhwnThxIhurBpxHdHS0SfvDDz80bocaGBioTz75RMeOHdO9e/d0+/ZtrV27Vh06dDAZM3v27FQf1APIXps2bdLhw4eN7WrVqqlp06YOrAhAYmKi5syZo7Fjx6bavi2lBw8eqG/fvqpXr57JtQwg63Tq1Mn4s8Fg0IgRI6x+tnv37l199NFHqY7Hx8dnen1PAgIz4AlmMBjM3sAxKipKEyZMUJkyZTRu3DiCMyCbzJgxQxs2bJD08Bt5X3/9tTw8PBxcFYDkihYtqk6dOql27doKDg7WihUrLH6A5+rqqmnTpunll182HktISND48eOzo1zA6aT8z/327dslSSEhITp8+LDeeecdlS9fXt7e3sqbN69atGihZcuW6auvvjLZLuo///mPTp48ma21A/g/s2bNMmkPGzbMQZUAkB6uwm7WrJkGDRqkc+fOSZLq1aunpUuX6vLly4qLi9Ply5f1ww8/qF69esZxu3btUkhIiLZs2eKgygHn8cYbb5jcy2z16tUaPHiwkpKS0ux/7949de7cOdV2jJK4LYgZBGbAEywhIUErV67UlStX9ODBA129elU///yzWrRoYewTHx+vsWPHpvpmPIDMd+LECY0aNcrY/uCDD1Jt5QbA8V566SUtXbpUe/bs0dWrVxUaGmrTuM8//9wkAF+2bBnbXADZpHjx4vr1118tbh/Vs2dPk1XdiYmJaX7bFkDWu337tvF+vtLDHVC6du3qwIoA52YwGNSxY0f99ddfxmOjR4/Wtm3b1KlTJxUqVEienp4qVKiQOnfurO3bt2vs2LHGvtHR0Wrfvr2uX7/ugOoB5+Hn56f//e9/JsdmzZqlOnXq6Pvvv9fVq1cVHx+v8PBwLViwQFWrVtXvv/8u6eGXy5Lz8vLKtrpzEgIz4Anm4eGhli1bqmDBgvLw8FBwcLDatWuntWvXavr06SZ9Z8yYoTVr1jioUuDJl5iYqJ49eyo2NlaS9PTTT2vkyJEOrgpAZipatKiaNWtmbN+/f994w3QAmSetb8OOGTPG5Nu25owcOVL58uUztn/++Wez38gFkHWWLVtmslq0U6dO8vHxcWBFgHP7+uuvjTuhSFL37t01ceJEubi4mB0zZswYk3uC3rx5U+PGjcvSOgFI7du31yeffGJyfe7bt09du3Y1htvFihVTnz59dPr0aUnSgAED1K9fP5N5cufOna115xQEZoCTGjx4sN59912TY9zHAcg6kydP1o4dOyQ9/BbPV199xY2RgSdQ3bp1Tdpnz551UCXAkytPnjwmbTc3N3Xs2NGmsbly5VLLli2N7YiICB04cCBT6wNg3Q8//GDSfu211xxUCQDp4ZeoH/Hy8tInn3xi07hJkyYpb968xva3336ruLi4TK8PgKl33nlH33//vYKDgy32y507t+bPn69Zs2YpIiLC5FyhQoWysMKci8AMcGLvv/++ybf4/v77b8XExDiwIuDJdODAAZNv2o0fP16VKlVyYEUAskrK/7DcvHnTQZUAT66goCCTdokSJeTv72/z+GrVqpm0L1++nCl1AbBNdHS0Nm/ebGwHBQWpQYMGDqwIcG4RERHau3evsd2wYUObP0jPkyeP2rZta2xHRUVp3759mV4jgNQ6d+6skydPatq0aWratKkKFiwod3d3+fv7q379+vroo4905swZ9e7dW1Lqf/MWLlzYEWU/9vhqO+DE/Pz8VL9+feOy+8TERJ06dUrVq1d3cGXAk2X58uV68OCBsT1y5Ei7t2MsVaqUSfvs2bMqWbJkZpQHIBMZDAaTNvvCA5kv5d+JuXLlsmt8QECASfvOnTsZLQmAHdavX2+yHWPbtm3l6sr3uQFHOXPmjMm/Ye39cmfKz5DOnz+vevXqZUptACzLnTu3hg4dqqFDh1rtu3//fuPPhQsXTvVvYjxEYAY8QRITExUfHy9vb2+bx6T8hu6j+ysBAOCsoqOjdf36dV27dk25cuWy64skKW90XqBAgcwuD3B6+fLlU8GCBXX16lVJ0pUrV+waf/fuXZO2vYEbgIxZv369Sfv55593UCUApIf33U3Ozc3NrvF+fn4m7eSBOIDHQ2Jiov755x9ju0aNGo4r5jHHV3iAHO7YsWNq1qyZSpcuLW9vb40fP96u8bdv3zZpBwYGZmZ5AADkKAcOHFCePHlUpkwZhYaGatiwYXaN3717t0m7Zs2amVkegP8v+TfXb968aVdodubMGZN26dKlM60uANZt2bLFpB0aGuqgSgBIqb/gdeHCBbvGX7t2zaSd8ovZADLfvXv37Pr37+bNm012VWjevHlWlPVEIDADcrh8+fJp48aNOnv2rBISEvTLL7/YPDY+Pl47duwwtv38/FS8ePGsKBNwamPHjpXBYLDr15gxY0zmOHv2rMl5tmMEskaFChXk4eFhbO/YsSPVzZHNuXXrljZt2mRsBwUFqXLlypldIgBJrVu3NmkvXbrUpnEGg8G4Hbn08N4rFStWzNTaAJgXFRWlQ4cOGdulS5fmw3XAwYoXL25yf/uNGzea3FLAmr/++sukzf26gazzzjvvKE+ePPL19VW5cuWUkJBg07hvvvnG+LOLi4tefPHFrCoxxyMwA3K4oKAgkxuXHz58ONUWF+Z8+eWXioyMNLZbt24tT0/PTK8RAICcwtPTUy1btjS24+Li9L///c+msR9//LHu3btnbL/xxhtycXHJ9BoBSC+//LLJh3tTpkxJtdViWlatWqWTJ08a2y+++KJJSA4ga4WFhSkpKcnY5j5HgON5e3uradOmxvadO3dMPly3JCwsTBs3bjS2q1evrqJFi2Z6jQAeKl68uKKjoyU93GZ83bp1VsecPHlS3377rbHdsmVLPfXUU1lWY05HYAY8Ad58802T9uDBg61+G37Xrl0aOXKkse3i4qJ33303K8oDACBHeeONN0zaH374oY4cOWJxzM8//6wpU6YY23nz5tXgwYOzpD4AD3dZ6Nevn7F94cIFDRo0yOSD+JQuX76c6t/N9m67CiBjDh48aNJ+5plnHFQJgOSGDh1q0h4xYoSOHz9ucUxkZKS6desmg8FgPPb2229nSX0AHnrppZfk6vp/kc64ceOUmJhotv/du3fVqVMn40o0FxcXvf/++1leZ05GYAY8Afr162dys8bjx4+radOmOnz4cKq+CQkJ+vLLL9WkSRPFxsYajw8ePFh16tTJjnIBAHisvfjii2rRooWxHRUVpaZNm2rNmjWp+sbHx2vy5Mnq1KmTyQf106ZNU3BwcLbUCzirMWPGmHyL/ZtvvlG7du10/vz5VH137NihBg0a6PLly8Zjr732Gv/+BbLZiRMnTNqlSpVyUCUAkmvZsqXJFm1RUVGqV6+evv/++zQ/jN+1a5dCQkJMPndq0KCBXn311WypF3BWxYoVU+fOnY3tnTt3qnv37sZVZ8nt27dP9erVU1hYmPFYv379uHeoFS6G5F8DAJBjnT59Wg0bNjS54aOLi4saNmyo2rVry9vbW+Hh4Vq/fn2qm0K++OKLWr58udzc3LK7bABmjB07VuPGjTO2z549y33LgGx07do1hYaG6vTp0ybHq1evroYNGyp37ty6ePGi/vjjD924ccOkz9ixY1PdhxBA1ggLC1OLFi1MrkM3Nzc1b95cFStWlIuLi3bt2qVt27aZfAO+SpUq2rZtm3Lnzu2IsgGn1aFDB61YscLY3rdvn8mXPwE4TlRUlBo0aJBqJWixYsXUqFEjFS1aVNHR0dq5c6f27Nlj0qdUqVLasWMH9yQEssGVK1dUq1YtXb161XgsICBAbdq0UcmSJXX79m2FhYVp+/btJuMaNmyodevWycvLK7tLzlEIzIAnyIkTJ9S5c2eTbw5Y4uLiorffflsfffSR3N3ds7g6APYgMAMc78KFC+rSpYt27NhhU38vLy9NmDBB77zzThZXBiC5Y8eOqX379jp27JhN/UNDQ/Xzzz+rQIECWVwZgJQaNmyoLVu2GNs3b95U/vz5HVgRgOQiIiLUvXt3/fbbbzaPadiwoX788Ud2VwCy0cGDB9WmTRuFh4fb1L9Lly5auHChyT2AkTa2ZASeIOXKldPOnTv1+eefW/xg3dPTUx06dNCePXv0ySefEJYBAJCG4sWL6++//9acOXNUrlw5s/18fX3VuXNnHThwgLAMcIAKFSrowIED+u9//2txe7fSpUtr1qxZ+uuvvwjLAAe5e/eu8WcfHx/CMuAxExAQoF9//VU//fST1XsMVqlSRd988402bdpEWAZks6pVq+rAgQMaMmSIcuXKZbZf/fr19euvv+r7778nLLMRK8yAJ9jRo0e1e/du3bhxQw8ePFD+/PlVqlQphYaGytfX19HlAQCQo5w6dUq7du3StWvXdP/+fQUFBalYsWJq0KABf68Cj5GwsDAdPHhQV69eVUJCgoKDg1WrVi1Vr17d0aUBAJCjXLt2TVu3btXly5cVGRmp3Llzq2DBggoJCVGxYsUcXR4ASbGxsdq+fbuOHz+uO3fuyMfHR0WLFlW9evVUvHhxR5eX4xCYAQAAAAAAAAAAwKmxJSMAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcGoEZAAAAAAAAAAAAnBqBGQAAAAAAAAAAAJwagRkAAAAAAAAAAACcmrujCwAAAAAA4HFy584d7dy5U6dPn1ZkZKRcXFzk5+enokWLqnz58qpQoYJcXbP++6fnzp3T3r17deHCBd29e1ceHh4KCAhQ8eLFVaVKFRUrVizLawAAAACcBYEZAAAAnE7JkiV1/vx5s+dXr16t1q1bp3v+xo0b66+//krzXKNGjfTnn3+me27Yx9KfRYkSJXTu3LnsLQiPtW3btmnChAlat26dEhMTzfbLnTu3mjVrps8//1wlS5bM1BoMBoMWL16sTz/9VGFhYRb7Fi5cWG3atNHcuXPl4uKSqXU8Ke7cuSMvLy/5+vo6uhQAAAA85tiSEQAAAEhhyJAhun//vqPLAJBNDAaD/v3vf6tBgwZas2aNxbBMkqKjo/Xzzz9nekgVGRmp1q1bq0ePHlbDMkm6fPmy1q9fT1iWBoPBoHnz5qlcuXK6fv26o8sBAABADkBgBgAAAKRw+vRpTZo0ydFlAMgmEyZM0McffyyDwWDzGH9/f5UoUSLTajAYDOrYsaP++OMPu8ZVr14902p4UuzatUt169ZVv379dPPmTUeXAwAAgByCwAwAAABIw+TJk3Xq1ClHlwEgi126dEkTJ060e1y1atUytY6ffvpJGzZscHgdOdmNGzfUt29f1atXT7t373Z0OQAAAMhhCMwAAACANMTFxWnw4MGOLgNAFlu2bJkePHhg97jMXtn13XffpWscK8ykxMREzZgxQ+XKldP8+fPtWikIAAAAPEJgBgAAAJjxxx9/6Mcff3R0GQCykC0rkTw8PFSqVCmVKlVK/v7+kjJ/ZZctdfj6+qps2bIqVqyYfHx8sqSOnOiTTz7RkCFDFBER4ehSAAAAkIMRmAEAAAAWDB8+XHfv3nV0GQCyyLlz5yyeHzhwoG7fvq0zZ87ozJkzioiI0JUrV9SlS5dMqyEhIUGXLl0ye97NzU3z58/X3bt3deLECV24cEExMTE6ffq0ypQpk2l15FRxcXGOLgEAAABPAAIzAAAAwIJLly5p7Nixji4DQBa5deuW2XP+/v6aOnWq/Pz8TI4XLFhQefLkybQabt++bXEbweeee069e/eWi4uL8ZiLi4tKly5tcgwAAABA+hGYAQAAAFZMmzZNhw4dcnQZALKApdVJ5cuXl4eHh0NrkKQqVapkeQ0AAACAsyMwAwAAAKxISEjQgAEDLK4AAZAzJSYmmj336D5hjqwhO+sAAAAAnJm7owsAAAAAcoItW7bo66+/1uuvv+7oUh5b9+7d07Zt23T06FFFRkbKx8dHpUqVUkhIiAoWLGjXHEeOHFFUVJR8fHxUpEgR1axZU+XKlcvi38FDly5d0rZt23T+/HklJCSoYMGCKly4sEJCQpQ7d+4secwjR47o+PHjunbtmm7duiVvb28FBQWpXLlyqlmzpjw9PbPkcVO6dOmS/v77b50/f15eXl566qmnFBISogIFCmTL4yd39+5dHTx4UMeOHdOdO3cUGxsrb29vBQYGqmzZsqpZsyZBkh0MBoP27dunM2fO6Nq1a4qIiJCPj48KFSqkChUqqFq1anJzc8uSxz179qwOHjyoa9euKTo6WrGxsfLy8pKPj48CAwNVrFgxValSRf7+/pn++E+6mJgYrV+/XqdPn1ZiYqKKFi2qZ555Rk899ZRd8yQkJGjPnj06f/688c8pV65cKlKkiCpVqqRKlSplyfaf4eHhCgsL07Vr1xQVFaW7d+/Ky8tLfn5+yps3r8qVK6fy5csrV65cmf7YAAAAqRgAAAAAJ1OiRAmDJLt/BQYGGm7fvm11/kaNGpmdo1GjRhmqz5bxj2zatMni72fhwoVmxy5cuNDsuC5dupj0PXv2rKFv376GXLlypdnf1dXV0Lp1a8M///xj9vHCw8MNAwYMMPj5+Zl93PLlyxtmz55tiI+Pt/k5sPRnUaJECZO+a9eutdjfy8vL0Lp1a8OaNWtsfnxLLl68aHjrrbcMpUqVsvjn5OPjY2jfvn26H9fS3Ddu3DAYDAZDVFSUoU+fPgYPD49Ufdzc3AytW7c27NixI1N+35bExsYaZs+ebWjSpInB3d3dYu0eHh6GZs2aGRYuXGiIi4uzaf6zZ8+m69q359qxhaXry55fZ8+etfpYR48eNfTr189QqFAhi3PlyZPH0KNHD8O2bdsy9Ht7ZPv27Ya+ffsa8uXLZ9PvxcXFxVCtWjXDxx9/bLh165bV+bPiz3DMmDEZfr4fycj7uKX3oR9//NFgMBgMSUlJhk8++cTs81ujRg3D4sWLrda5Y8cOQ7du3Qx58+a1+HsvUKCA4c033zQcOnTI5ufAnG3bthneeOMNQ4ECBWz6s3J1dTWEhoYaPvvsM0NkZGSGHx8AAMActmQEAAAAbHTjxg2NHj3a0WU8VmbOnKnKlStr3rx5iomJSbNPUlKSfv/9d9WtW1dTp05Ndf6bb75RxYoVNXv2bN29e9fsYx0/flwDBgxQgwYNdOXKlcz6LSgmJkavvfaaWrZsqb/++stsv7i4OP3+++9q1aqV2rZtq0uXLqXr8eLi4jRmzBiVL19eU6dO1dmzZy32v3fvnlasWKFWrVqpYcOGOnr0aLoe15y7d++qWbNmmj9/vuLj41OdT0xM1O+//67t27dn6uOmfIypU6eqePHiGjBggDZt2qSEhASLY+Lj47Vhwwb16tVLpUuX1uLFi7OsvpwoMjJSQ4YMUdWqVfW///3P6jUTFRWlRYsWqX79+mrXrl26X98RERF69dVXFRISonnz5un27ds2jTMYDDpw4IBGjRqlMmXK6JtvvknX4zuLQYMG6d133zX7/O7fv19Lly41O/7y5cvq1q2bQkJCtHjxYt25c8fi4928eVNz5sxRtWrV1KdPH0VERNhd89WrV9WxY0fVr19fc+fO1c2bN20al5SUpK1bt2rEiBF66qmntGDBArsfGwAAwBYEZgAAAIAd5s6dq927dzu6DIczGAwaMGCABg8erNjYWJvGJCQkaPjw4Zo+fbrx2HvvvaeePXsqOjra5sfeuXOnGjdurMjISLvrTunOnTtq2rSpFi1aZNe4VatWqX79+jp27Jhd4yIiIvTcc89p/PjxNj9vyW3ZskV16tTR8uXL7R5rTq9evay+pl1cXNSpU6dMe8zkwsPDFRISouHDh9v8AXpKly5dUvfu3fXyyy/b9Vp6Ul28eFGhoaGaMWOG1eAxLb/88otq1KihLVu22DXu6tWrevbZZ/Xdd9/Z/ZjJ3blzRz179tQHH3yQoXmeVDNmzNDs2bOt9uvSpUuaxw8ePKhnnnlGS5YssfvenElJSVqwYIFq165tV3h/6tQp1a5dO8PvXTdv3lSfPn309ttvZ2geAACAtBCYAQAAAMm0bt1aAQEBZs8nJSVpwIABSkpKyr6iHkNvvfWW5syZk66x//rXv7Rv3z59+OGHmjhxYrrmOHHihIYMGZKusY88ePBAL7zwgnbt2pWu8RcuXFCDBg107tw5m/rfunVLoaGhFlex2SI2NladO3fWTz/9lKF5JGn+/Pk2zdOgQQMVKVIkw4+X0pEjR1SvXr1MC6GXLVumJk2a6NatW5kyX050+vRphYSE6PDhwxma5+bNm3ruuedsDs0SExPVuXNnHTx4MEOPm9yECRO0evXqTJvvSXDkyBGbwiIfHx+1bds21fGdO3eqYcOG6V5B+MiZM2fUuHFjHT9+3GrfyMhINWvWTJcvX87QYyb32Wefadq0aZk2HwAAgERgBgAAAJgICgrSpEmTLPb5559/bPp2/5Nq/fr1+uKLL9I9PiEhQe3bt8/w6pFvv/1WR44cSff4K1euaNu2bRmq4datW+revbsSExOt9n399dczVG9yiYmJeu211zIcTowdO9amfq+88kqGHict169fV5s2bTL8wX1K//zzj55//nndu3cvU+fNCeLi4tS5c+dMe05jY2PVsWNHm4KOzz77TH///XemPG5y1t6Pnc2kSZMUFxdntd8LL7wgPz8/k2O3b99Wp06dMmV1rvTwGm7Xrp3FrXQl6T//+Y8uXLiQKY+Z3DvvvKPTp09n+rwAAMB5EZgBAAAAKbzxxhuqW7euxT7vvfeerl27lk0VPV7Mrd4JDg5WsWLF5ObmZnWO8+fPp7kVmJ+fn5566in5+PhYncNgMFi8R096uLq6qnDhwipdurRNNUjS1q1bra50mDp1qlatWmV1Li8vL5UqVUrFixe3+jzeu3dPvXv3tntLteTu379vtY+bm5tefvnldD+GOa+99prOnz9vU998+fKpbNmyypcvn039d+7cqaFDh2akvBxp5MiR2rt3r9V+vr6+euqpp1SkSBG5uLhY7Hv9+nWrqzmjo6P1ySefWH1cDw8PlShRQmXLllWBAgWs9pceXl9RUVE29XUGtlyzUtrbMfbu3VsXL160OjZ37twqW7asgoODrfY9fvy4xowZY/b83bt3rd5zrFChQurQoYPeeustvffeexo5cqReffVVFS1a1OK4+Ph4vf/++1ZrBAAAsJW7owsAAAAAHjeurq6aM2eO6tSpY3blUEREhN5++2277331pPH399fIkSP15ptvKm/evJKkGzduaOTIkVq4cKHN87Ru3Vrjxo3T008/Lenhh8JfffWV3nrrLYurKdK7nWJKefLkMd5PLSgoSNLDD2PXr1+v9957z2oIMXXqVA0bNizNkCsmJkYTJkywOL5MmTKaOHGi2rZtawzq7ty5o0WLFmnMmDGKiIhIc9yePXv0ww8/ZMoKMA8PD7Vu3VrlypVTTEyMNm7cqOPHj6tJkybG5ySzLF26VH/88YfFPl5eXho2bJj69u2rsmXLGo8fO3ZMc+fO1YwZMxQfH292/Lx589S1a1c1bdrUeCwoKEg//vijSb+BAwfqxo0bac5RqVIljRs3LtXxR6/T9GrSpIlJHTdu3NDAgQPN9u/UqZM6d+6c6njyP5eLFy9q5syZFh+3Vq1amjhxopo1ayYPDw9J0rVr1/Tll19q0qRJZsOY5cuXa8eOHapXr16a5xctWmRxG8wqVapowoQJatu2rck1cv36dX377bd67733zK4INBgM2r9/v5599lmT48mfv6VLl6b6c01u1qxZCgwMNDmW0T/Dx0VoaKhq164td3d37dy5U9u2bZOfn5+ef/55k347duzQypUrLc7VtGlTjRs3TvXr15er68PvV587d05Tp07V9OnTzW5FPH36dL311lsqVqxYqnMbNmww+2fr5uam2bNnq0+fPsbHSy4pKUlz587V4MGDzf5dvGzZMt25c8f49w8AAECGGAAAAAAnU6JECYOkNH/17NnT2G/YsGFm+z369eeff6aav1GjRmb7N2rUKEP12TL+kU2bNlmsfeHChWbHLly40OrvPSgoyLB//36zczRs2NDqHJIMw4YNMzvHzJkzLY4tV66cxefA0p/Fo1/FihUzHD9+3Owc8fHxhq5du1qd58cff0xz/PTp0y2Oq1+/viEiIsLs4586dcpQqFAhs+Pr1atn8Tmw5c+gWrVqhlOnTqUa+/vvvxtWrVplcX57JSUlGSpWrGixnoIFCxr27dtncZ6dO3caChQoYHGe2rVrW60ns663jDh79qzF38eYMWOszjFixAiLc3To0MEQFxdndvzOnTsNfn5+Zse/8sorZsdaus5KlSpluHPnjsXaZ8+ebbH2JUuWWBw/ZswYi+PPnj1rcXxmz2MwZOx1Zcv7VkBAgGHdunWpxh4+fNgwc+bMVMc7duxocb4hQ4YYkpKSzNa0cuVKg5ubm9nxo0aNSnPc1KlTzY5p1aqV5Sfx/0vr9eHq6mooV66coUOHDoYDBw7YNA8AAIA1bMkIAAAAmDFhwgQVLlzYYp+BAwdaXOXyJPv8889VvXp1s+ctrZh5pFatWpo6darZ87169TKuhEmLuZVBtnJ3d9eyZctUrlw5i32+/vprValSxeJc5lZvzJkzx+yYPHnyaPny5fL39zfb56mnntLXX39t9vyOHTt09uxZi7VZ4uXlpRUrVuipp55Kda5Vq1apVqpk1O+//66jR49arGfNmjWqUaOGxXmeeeYZ/frrr3J3N79xyj///KPNmzent9QcIyEhQfPmzTN7vlSpUlq0aJE8PT3N9nnmmWc0ZcoUs+d/+eUXxcbGpnnuww8/1BdffKE+ffqoTp06JtuZTp48WQEBARbr79Gjh8UtSK9fv25xvDOaMWOGmjdvnup4pUqVUr33Xrt2TStWrDA7V0hIiKZOnWpxe84XX3xRI0eONHv++++/T/P4gwcPzI45f/68Tfdj69u3r7p06aIRI0boq6++0j///KOYmBgdP35cy5YtU9WqVa3OAQAAYAsCMwAAAMCM3LlzWwxzJOnIkSP6/PPPs6egx0jp0qWtbgNoLWCSHt4LzhIfHx9VqFDB7HlzH+DbqkuXLjZtzebh4aEPP/zQYp8dO3akOnbjxg0dPnzY7Jg+ffrYdJ+gFi1aWPxQ+LfffrM6hzldu3ZV6dKl0z3eXuY+WH9k5MiRFoPY5OrVq6dBgwZZ7PPdd9/ZXFtOtW/fPkVGRpo9/9Zbb8nX19fqPK+//rrZ+8TFxsZq48aNaZ5r0KCBhgwZonnz5mn37t2Kjo7WkSNH9MMPP6hDhw5WHzdXrlwWt/209b5dzqJ06dLq2rWrzf03b95sdjtFSRo1alSaWyKmNHz4cLP9zp07p0OHDqU6XqRIEbPzHT16VE2aNNHPP/9sMThzd3fX999/r08//VQ9e/ZUrVq15O3tbbVeAAAAexGYAQAAABZ06tRJrVq1sthn/PjxunjxYjZV9Hho3ry51Q9YrQVB7u7ueu6556w+lqUPXC2tXrDFa6+9ZnPfNm3aWLxPzqlTp3Tz5k2TY1u2bLE4Z1orRMxJeQ+n5LZv327zPCmldW+srLR69Wqz5zw8PGxamZjc0KFDLa6MWbdunV3z5USZ9Trz8PBQSEiI2fO2vs7c3NxUsWJFde7c2eLKsUfCwsIsXsu2rEJyJi+//LJNAdcjll4fLi4uJvf5s6RAgQKqWLGi2fNpvT5CQ0MtXp/bt29X+/btlT9/fr344ov64osvdODAAYsBHwAAQFYhMAMAAACsmDFjhsVvs8fExGjYsGHZWJHjWVr19Yifn5/F86VLl7Zp1UuePHnMnjMYDFbHm+Pi4qK6deva3N/Dw0O1a9e22OfChQsm7X/++cdi/2LFitn8+Ja2Bw0LC7N5npTq1auX7rH2OnfunG7dumX2fM2aNW1acZdc6dKlVbZsWbPnT58+rTt37tg1Z06TE15nyZ09e1aLFy/Wm2++qdKlS6tGjRoWXxeEJ6YshZppsfT6yJs3r9X36uTsfX2UKFFCLVu2tDpvTEyMfv31Vw0bNkzVq1dXvnz51Lp1a33yySfavXu3EhMTba4RAAAgvcxv9g4AAABA0sN7SI0ePVoffPCB2T4rVqzQ6tWr1aZNm2yszLKs/JC5YMGCVvtYuveYJBUtWtSmx/Ly8rKpn70KFChg8d5haalUqZLWr19v9nzKYMbaPdaqVatm1+Obc/r0aRkMBosrOdKSL18+i6vmMtuJEycsnq9Tp0665q1Tp47Fuc+cOWM17MzJrL3OLIXO9jh16pTdYy5duqQdO3Zoz549+ueff7Rv375UKzGfRFn5/pvW/QYtsfT6uH37tt3vG+aYe33MmDFDtWrVUnR0tM1zRUZGas2aNVqzZo0kKX/+/Grfvr26dOmiZs2aZVrNAAAAybHCDAAAALDByJEjVb58eYt9hgwZ8ljdaycrP7ANCAiw2sfd3fL382wNauzZeswe9oZlkvWaIyIiTNrZtbLp/v37qR7bFoUKFcr8Yiyw9nwEBgama15r427fvp2ueXOK7HqdXblyxaZ+e/fu1YgRI1S+fHkVLVpUL7/8sj7++GOtW7fOKcIyKWvff+29bh39+ihTpoyWLVuWoeD21q1bmjdvnlq0aKEqVaro22+/TfdcAAAA5hCYAQAAADbw9PTUrFmzLPY5c+aMJk2alKV12LMFYXx8fJbV4enpmeE5LG1zmR3SE8Tlzp3b4vmU91pKT4iVXukJhbJzdZkkJSQkWDxvz9Zw9ox70u+BlV2vs6ioKIt/hqdPn1aLFi1Uu3ZtTZkyxeqKwpzmcXn/tfe6za7Xh6X3oBYtWmjHjh2ZsgXskSNH1KNHDzVv3tziVp4AAAD2IjADAAAAbNS0aVO9+uqrFvtMnjxZ58+fz7IarAUOyd27dy/L6nBzc8vwHNZWoGW1mJgYu8dYe05TrrzLjGDRVulZ3WgtAMxs1oKtu3fvpmveqKgoi+cdHc5mtex8nZkLH5cvX66qVata3LI0LXny5NFLL72UrhWf2e1xeP/18fGx+/03u14f1t6DKlasqO3bt2vTpk3q1q1bugPyRzZs2KAWLVooNjY2Q/MAAAA8QmAGAAAA2GHKlCkWtyOMi4vTuXPnsuzx7VkpY8/9YpzR9evX7foAXHp4Xx1LUr42sjMESExMtHuMr69vFlRinrWtPK3diyu944KCgtI1b07h6NfZrl271L17d5tCoqJFi6pLly6aOnWqdu/erdu3b2vFihU2bfPqaLa+/xoMhnQF8rZIzzWbXa8PW9+DGjdurG+//VY3btzQqlWrNHDgQJUtWzZdj7lv3z599NFH6RoLAACQkmO/0gkAAADkMMHBwZo4caIGDRrkkMe350PY69evZ2ElOV98fLxOnz5t9d50yR07dszi+fz585u0CxQoYLH/5cuXs/0+Ysl5eXll6+OVK1fO4vk9e/aka15L41xcXFS6dOl0zZtTWHqdeXp6ZumWlImJierRo4fFsKx06dIaMGCA2rVrZzYYSU/gm91sff+9efNmlt3DLD3XbIECBXT58uU0z5UrV07Hjx/PaFnp4u3treeff17PP/+8JCk8PFybN2/Wli1btH37dh08eNCm18Xs2bM1bty4TFn5DAAAnBsrzAAAAAA7vfnmm3r66aezbH5LH/rduXPH5nnOnDmTGeU80datW2dz36SkJIvBjK+vr8qUKWNyrFq1ahbnvHDhgs2PnxWye1vMQoUKWbz/0r59+3Tt2jW75jx9+rROnTpl9nylSpUyvPXb487S6+zBgwd2P6f2WLNmjcV7lTVv3lwHDx7U22+/bXEV0YMHD7KiPLtYC1xsff/Nyvfe9Fyzll4fly9ffmzCyqJFi+rVV1/VrFmztG/fPkVGRuq3335T165d5eLiYnbc7du3tXfv3mysFAAAPKkIzAAAAAA7ubq6as6cOVn2bXZLKwhu3Lhh02qRpKQk/fnnn5lY1ZNp/vz5MhgMNvXduHGjrl69avZ8nTp1Ur0mrAWra9assemxDQaDPvzwQ33//fc6ePBgpoULlj6EzipNmjQxey4+Pl6zZs2ya74vvvjC4vlWrVrZNV9OlFmvs+joaI0fP17Lli3T8ePHbQpS1q5da/acq6ur5s+fb3UbQYPBoIiICJtqTIu117Gtq72srd4KDw+3aZ6NGzfa1C890nPNWnp93L17V1u2bLFpnvPnz2vSpEn69ddfdebMGZvfOx89zj///KPFixfrgw8+UOfOnbV9+3aLY3LlyqU2bdpoyZIlevfddy32tfXPBgAAwBK2ZAQAAADSoVatWho4cKCmT5+e6XNbupdPUlKS1q9fb9zCypyvvvrK6vaBkPbv36/p06dr6NChFvslJiZq9OjRFvuEhISkOla5cmUVLFjQbNA2Y8YMDRkyRPny5bM495o1a/T+++8b2+7u7ipbtqyqVKmiypUrq1GjRmrcuLHFOR4Xbdu21fLly82enzx5sjp27Gh1dZ4k7dixQzNnzrTY59VXX7W7xpymYcOG8vLyMhumT548Wa+88orVQOjbb7/VmDFjjG0vLy9VqFBBlStXVpUqVdSiRQvVqVPHZMzp06fNzhcUFKTixYtbrf/kyZMWQ2BrgZe1Ly/YuiWltfuo/fHHH+rbt6/FPrdu3dJ///tfmx4vuzRv3tzi+QkTJujZZ5+1GsbNmjVLn3zyibHt6+urSpUqGd+HXnjhBVWoUMF4fsOGDZo0aZKOHz+eZqDl4eGR5vtmWkJDQy2ef1xWyQEAgJyNFWYAAABAOn344YdZcv+pYsWKWTz//vvvW7yXzm+//aYhQ4ZkdllPrH/961/66aefzJ43GAwaMGCAdu/ebXGeHj16pDrm5uaW5vFHbt68qXbt2lnc6i06Olr/+te/TI4lJCTo6NGj+vHHHzV27Nh03/vLETp37mwxIIyLi1OrVq0UFhZmcZ7du3erbdu2Fj8ob9KkiWrVqpXuWnOKvHnz6sUXXzR7/ujRo+rWrZvu379vts+lS5c0duxYk2NxcXEKCwvTkiVLNHr0aJ07dy7VuISEBLNz3rlzx+JjPjJt2jSL5+Pj4y2etxYE2rqVorX33uXLl1tcjXX9+nW1bt3arq1zs0OlSpUsrjLbsGGDhg0bZjGYPHDgQKoviMTGxmrPnj366quv9M477+ju3bsm54sVK6YNGzaYXf21dOlSm1c/bt682eJ5a392AAAAtiAwAwAAANIpT548+vzzzzN93ipVqlg8v2/fPjVt2jTVB4inT5/WW2+9pXbt2ik2NjbT63pSJSYmqlOnTurbt68OHTpkPG4wGLR161Y1btxY//vf/yzO0aRJE1WuXDnNc3379rW4AmbLli2qXr265s2bZ/JBe1JSklauXKn69etbXC3o6+ur3r17W6zvceLr66thw4ZZ7HPlyhXVrVtXo0aNSnV/suPHj2vEiBEKDQ3VzZs3zc7h6ur62K30yUr9+/e3eH7ZsmWqXbu2li5dahK4P3jwQIsWLVL9+vV1/fp1s+OLFi2ql156KdXxoKAgs2Pi4uK0YMECi3X99NNPmjt3rsU+KYOYlKzdo27KlCnG4O7+/ftavXp1moGstffepKQktW7dWrNmzdK9e/dM6lu4cKFq165tNVh3FGuvj+nTp6tBgwb6/fffTVbkxcTEaMaMGWrSpInJ7zmlunXrplp9WK5cOYsryBISEtSxY0ctXrzYbFj34MEDff7555oyZYrZefz9/VW9enWz5wEAAGzFlowAAABABnTp0kULFiyweB8fez377LNW++zatUuNGjVSrly5VLhwYUVFRenatWuZVoMzmj9/vubPny9/f38FBQXp+vXrioyMtGmspe0ay5UrZ3X7zosXL6pfv37q37+/ChcuLE9PT4WHh9t0r7LRo0db3dLxcTNy5Eh99913FoPAuLg4TZ48WZMnT1aBAgWUL18+3bp1S7du3bLpMd59913Vrl07s0p+7DVr1kxt27bVr7/+arbPkSNH1KVLF3l4eKhw4cKSHt77yZbt7D7++GO5u6f+COGZZ57RokWLzI4bMWKEChUqpPbt25scj46O1n//+19NmjTJ4io1Sbp9+7bF84GBgRbPL1u2TOvWrVP+/Pl18eJFJSQk6JNPPkkVshQrVkwlS5ZMcyXdI3fv3tWgQYM0dOhQFSlSRO7u7jp//vxjvyXg66+/rhkzZmj//v1m+2zfvl1t2rSRt7e3ChcurLi4OF25csWme8CZC6c//vhjNWrUyOy42NhYde/eXe+8844aNmyoEiVKyMvLS9HR0Tp9+rT+/vtvq+/Dr7zyiry9va3WCAAAYA2BGQAAAJBBM2fOVNWqVW3aeswWDRs2VPHixXXhwgWrfWNiYnTy5Mk0z+XPn18lSpTQ3r17M6WuJ03p0qV15syZVMcjIyNtDsokadCgQTbdI2j58uW6dOmSxX5JSUlmty9LS+XKlfX222/b3P9x4eXlpe+//17PPvusoqKirPa/efOmxdVkKT333HOaMGFCRkrMkaZNm6Y///xT0dHRFvvFx8fr/PnzNs/bvHlzdevWLc1z7du314gRI8yGu/fv31eHDh1Ut25dNWjQQO7u7jpx4oTWr19vtc5HLl68aPG8Lfe7i4qKMnmtmbvOunfvrg8//NDqfImJiRbfo1u2bJmpX6TIKDc3N82ePVsNGza0GlDev38/zfdGc/r27auGDRumee7ZZ5/VG2+8YXUV4ZUrV7R06VKbH/ORfPnyafz48XaPAwAASAtbMgIAAAAZVKZMGY0aNSrT5nN1dc3wB4AeHh5avHhxltxj7Ukxbtw4i/f1sUWtWrVs2vbP399fK1eutLp1nD0KFCigX3/91er9mx5X1atX18qVK5UnT55Mnbdp06ZatmxZmquhnnSlSpXSd999l6m/97Jly+qHH34we75IkSI23TNx586d+uyzzzR58mStWLEiVVhm6XUcFhZmMeQpV66cihQpYrWG5MyFcMOHD8/wis3XXntN/fr1y9AcWaFevXqaMWNGps5Zv359q3NOnz7d4iqz9PLw8NDXX39tcVtQAAAAexCYAQAAAJlg1KhRKlu2bKbN17NnT/Xo0SNdY318fPT999/rueeey7R6nkTe3t5as2ZNurftCw0N1caNG+Xj42NT/9q1a2vjxo0KDg5O1+MlV7JkSf35558qVapUhudypMaNG2vHjh2qWLFipszXp08frV69Wrly5cqU+XKi559/XitXrlTu3LkzPFeNGjW0ceNGqwHShx9+aHaFkS2qVq2q7du3y9U17Y8ooqKitHPnTotz2BLaJWduhVm+fPm0ePFieXh42DXfI927d9f8+fPTNTY79O/fX/PmzUv37y+55s2b67fffrMa2nt6emrNmjXq3Llzhh/zER8fHy1dulQvvPBCps0JAABAYAYAAABkAi8vL82aNStT51y4cKHeeustubi42DymevXq2rp1qzp06JCptTyp8uXLp82bN6tPnz42P8+urq4aNGiQ1q5dK39/f7se7+mnn9bBgwfVtWtXu/5cH3FxcVG3bt20a9cuVa5c2e7xj6OKFSsqLCxMn376qfLnz5+uOUqXLq2VK1dq3rx5OXbFXWZq06aNwsLC1LJly3SNd3d319ChQ7VlyxYVLVrUan9vb2+tWrVKHTt2tOtxXF1dNWDAAO3YsUM1a9bUM888Y7bvd999Z3Gu4cOH2xWeWNrmsVWrVlq1apVdK5f8/Pz0xRdfaNGiRY/96sY+ffpo165dFp9vS3x9fTVu3Dj9/vvvCggIsGmMt7e3vv/+e3399dd2rwZMqVGjRjpw4IBeeumlDM0DAACQEoEZAAAAkEmaN2+uV155JdPmc3Nz0+eff67t27frxRdftLgioGbNmlq4cKH27NmjmjVrZloNzsDX11fz5s3Ttm3b9OKLL5r9sNvX11edOnXS7t27NWPGDPn6+qbr8QIDA7VkyRKFhYVp0KBBKly4sNUxAQEB6tevn3bt2qVvv/1WgYGB6Xrsx5WHh4dGjBih8PBwLViwQM8995xNq1ZatmypJUuW6Pjx43rxxRezqdqcoVSpUvrjjz+0detWvf766zaFkcHBwRo+fLgOHTqkadOm2bVSL0+ePPrpp5+0YsUKNWjQwGIgHBgYqF69emnfvn2aNWuW8VqyFLgtWrRId+/eNXve09NTP//8s2bPnq0SJUpYrLV48eJ67bXXLPZp2bKljhw5olGjRlkMzgIDAzVixAidOHHC7lVujlSjRg3t3LlTq1evVqdOnWxakViqVCm99957On78uD744AO7g0EXFxe99tprOnHihBYtWqTWrVvL29vbprGFChVS3759tW3bNv35558qU6aMXY8NAABgCxeDwWBwdBEAAAAArIuMjNT27dt18uRJRUVFycvLS8WLF9czzzyjkiVLOrq8J8bt27e1detWnTx5UnFxcQoODlaxYsUUGhqa7pDMmtOnT+vIkSM6f/68oqOjlZSUpDx58igwMFDVqlVThQoVzG5X96S6d++eDh06pCNHjujWrVuKiYmRt7e3AgMDVbZsWdWqVcvm7TAhGQwGHT16VMeOHVN4eLgxfPL391dwcLBq1qypp556KtMe79atW9q2bZvCw8MVEREhHx8fBQcHG//ssvr1fODAAe3bt0/Xr19XfHy8cufOreLFi6tatWp2b2WalJSkvXv36sCBA7p+/boMBoMKFCigatWqqU6dOnJzc8ui30X2SUxM1MGDB3XixAldvnxZMTExcnNzk7+/vwoXLqxatWqpWLFiWfK4x48f1+HDh3Xr1i1FRUUpPj5efn5+xtdmjRo1uB8nAADIFgRmAAAAAAAAAAAAcGrO9RVFAAAAAAAAAAAAIAUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAODUCMwAAAAAAAAAAADg1AjMAAAAAAAAAAAA4NQIzAAAAAAAAAAAAOLX/By9yVdAbmy9XAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 2000x1500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "final_results = pd.DataFrame(columns=['method', 'model', 'n', 'acc', 'auc', 'f1', 'precision', 'recall', 'f2','f05', 'confusionmatrix','coef', 'coef_rounded', 'found_coef', 'multiple_times','delta','intercept','balanced', 'gene_id'])\n",
    "max_run_num = 600\n",
    "C_values = np.logspace(-9, 0, num=max_run_num, base=10)\n",
    "alpha_values = np.logspace(15, -5, num=max_run_num, base=10)\n",
    "\n",
    "# LinearSVC\n",
    "lsvc = LinearSVC(penalty=\"l1\", dual=False)\n",
    "lsvc_params = [{'C': C} for C in C_values]\n",
    "evaluate_classifier(lsvc, 'LinearSVC', 'lsvc', X_train, y_train, X_test, y_test, lsvc_params)\n",
    "# Elastic-Net\n",
    "#    encv = ElasticNetCV(l1_ratio=1-np.logspace(-3, -0.1, num=10, base=10), n_alphas=200, max_iter=5000, n_jobs=10, selection='cyclic')\n",
    "#    encv.fit(X_train, y_train)\n",
    "#    print('-'*60)\n",
    "#    print('ElasticNetCV')\n",
    "#    print('best l1_ratio:', encv.l1_ratio_)\n",
    "#    print('selected features:', X_train.columns[encv.coef_ != 0].values)\n",
    "#    print('n features:', encv.n_features_in_)\n",
    "en = ElasticNet(alpha=0.1, l1_ratio=0.75, max_iter=5000, selection='cyclic')\n",
    "en_params = [{'alpha': alpha} for alpha in alpha_values]\n",
    "evaluate_classifier(en, 'ElasticNet', 'en', X_train, y_train, X_test, y_test, en_params)\n",
    "# LogisticRegression\n",
    "#       lrcv = LogisticRegressionCV(penalty='l1', solver='liblinear', max_iter=10000, n_jobs=-1)\n",
    "#       lrcv.fit(X_train, y_train)\n",
    "#       print('-'*60)\n",
    "#       print('LogisticRegressionCV')\n",
    "#       print('best C:', lrcv.C_)\n",
    "# print('selected features:', X_train.columns[lrcv.coef_ != 0].values)\n",
    "# print('n features:', lrcv.n_features_in_)\n",
    "lr = LogisticRegression(penalty='l1', solver='liblinear')\n",
    "lr_params = [{'C': C} for C in C_values]\n",
    "evaluate_classifier(lr, 'LogisticRegression', 'lr', X_train, y_train, X_test, y_test, lr_params)\n",
    "# Lasso\n",
    "#       lassocv = LassoCV(max_iter=5000, n_jobs=-1)\n",
    "#       lassocv.fit(X_train, y_train)\n",
    "#       print('-'*60)\n",
    "#       print('LassoCV')\n",
    "#       print('best alpha:', lassocv.alpha_)\n",
    "#       print('selected features:', X_train.columns[lassocv.coef_ != 0].values)\n",
    "#       print('n features:', lassocv.n_features_in_)\n",
    "lasso = Lasso(alpha=0.1, max_iter=5000)\n",
    "lasso_params = [{'alpha': alpha} for alpha in alpha_values]\n",
    "evaluate_classifier(lasso, 'lasso', 'lasso', X_train, y_train, X_test, y_test, lasso_params)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 重新排序\n",
    "sort_columns = ['found_coef','f1', 'auc',  'balanced','n', 'delta']\n",
    "sort_order = [False,False, False, False,True, True]\n",
    "\n",
    "# Sort the DataFrame\n",
    "results_sorted = final_results.sort_values(by=sort_columns, ascending=sort_order).reset_index(drop=True).copy()\n",
    "results_sorted_view = results_sorted.head(5).copy().drop(['coef','gene_id','intercept','multiple_times'], axis=1)\n",
    "# results_sorted_view\n",
    "\n",
    "# 复制 'final_results' 到 'final_results_unique' \n",
    "final_results_unique = results_sorted.copy()\n",
    "\n",
    "# 将 'coef_rounded' 和 'gene_id' 列转化为字符串\n",
    "final_results_unique['coef_rounded'] = final_results_unique['coef_rounded'].astype('str')\n",
    "final_results_unique['gene_id'] = final_results_unique['gene_id'].astype('str')\n",
    "\n",
    "# 删除重复行\n",
    "final_results_unique.drop_duplicates(subset=['coef_rounded', 'gene_id'], keep='first', inplace=True)\n",
    "final_results_unique['coef_rounded'] = final_results_unique['coef_rounded'].apply(ast.literal_eval)\n",
    "final_results_unique['gene_id'] = final_results_unique['gene_id'].apply(ast.literal_eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>model</th>\n",
       "      <th>n</th>\n",
       "      <th>acc</th>\n",
       "      <th>auc</th>\n",
       "      <th>f1</th>\n",
       "      <th>precision</th>\n",
       "      <th>recall</th>\n",
       "      <th>f2</th>\n",
       "      <th>f05</th>\n",
       "      <th>confusionmatrix</th>\n",
       "      <th>coef_rounded</th>\n",
       "      <th>found_coef</th>\n",
       "      <th>delta</th>\n",
       "      <th>balanced</th>\n",
       "      <th>gene_id</th>\n",
       "      <th>reproduce</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>4</td>\n",
       "      <td>0.981651</td>\n",
       "      <td>0.966147</td>\n",
       "      <td>0.989899</td>\n",
       "      <td>0.994924</td>\n",
       "      <td>0.984925</td>\n",
       "      <td>0.986908</td>\n",
       "      <td>0.992908</td>\n",
       "      <td>[[18, 1], [3, 196]]</td>\n",
       "      <td>[-20.0, 6.0, -5.0, 8.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.034139</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-148a, hsa-mir-143, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>5</td>\n",
       "      <td>0.981651</td>\n",
       "      <td>0.966147</td>\n",
       "      <td>0.989899</td>\n",
       "      <td>0.994924</td>\n",
       "      <td>0.984925</td>\n",
       "      <td>0.986908</td>\n",
       "      <td>0.992908</td>\n",
       "      <td>[[18, 1], [3, 196]]</td>\n",
       "      <td>[-16.0, 6.0, -4.0, 6.0, -1.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.049735</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-148a, hsa-mir-143, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>6</td>\n",
       "      <td>0.981651</td>\n",
       "      <td>0.966147</td>\n",
       "      <td>0.989899</td>\n",
       "      <td>0.994924</td>\n",
       "      <td>0.984925</td>\n",
       "      <td>0.986908</td>\n",
       "      <td>0.992908</td>\n",
       "      <td>[[18, 1], [3, 196]]</td>\n",
       "      <td>[-15.0, 2.0, 9.0, -3.0, 5.0, -4.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.035638</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>6</td>\n",
       "      <td>0.981651</td>\n",
       "      <td>0.966147</td>\n",
       "      <td>0.989899</td>\n",
       "      <td>0.994924</td>\n",
       "      <td>0.984925</td>\n",
       "      <td>0.986908</td>\n",
       "      <td>0.992908</td>\n",
       "      <td>[[18, 1], [3, 196]]</td>\n",
       "      <td>[-25.0, 1.0, 10.0, -6.0, 9.0, -3.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.098082</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>6</td>\n",
       "      <td>0.981651</td>\n",
       "      <td>0.966147</td>\n",
       "      <td>0.989899</td>\n",
       "      <td>0.994924</td>\n",
       "      <td>0.984925</td>\n",
       "      <td>0.986908</td>\n",
       "      <td>0.992908</td>\n",
       "      <td>[[18, 1], [3, 196]]</td>\n",
       "      <td>[-25.0, 1.0, 10.0, -6.0, 9.0, -2.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.132341</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>4</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-12.0, 3.0, -3.0, 5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.027985</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-148a, hsa-mir-143, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>83</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-2.0, 6.0, 4.0, 3.0, 2.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.007595</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>84</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-4.0, 12.0, 8.0, 6.0, 4.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.008621</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-5.0, 15.0, 10.0, 8.0, 5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.017616</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>86</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-8.0, 25.0, 20.0, 16.0, 9.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.018380</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>87</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-3.0, 9.0, 6.0, 4.0, 3.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.020642</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>88</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-8.0, 25.0, 20.0, 15.0, 9.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.021112</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>89</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-5.0, 16.0, 12.0, 9.0, 5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.021343</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-4.0, 15.0, 12.0, 10.0, 5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.026658</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 8.0, -10.0, 16.0, -4.0, 6.0, -6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.021106</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 6.0, -8.0, 15.0, -4.0, 6.0, -5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.024976</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>106</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 9.0, -12.0, 16.0, -4.0, 6.0, -5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.030226</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>107</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 9.0, -12.0, 16.0, -4.0, 6.0, -6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.030472</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>108</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 6.0, -6.0, 15.0, -4.0, 6.0, -6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.030614</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>109</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 5.0, -6.0, 15.0, -4.0, 6.0, -5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.030664</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>111</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 6.0, -9.0, 15.0, -4.0, 6.0, -5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.030751</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>121</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>lr</td>\n",
       "      <td>7</td>\n",
       "      <td>0.977064</td>\n",
       "      <td>0.963634</td>\n",
       "      <td>0.987342</td>\n",
       "      <td>0.994898</td>\n",
       "      <td>0.979899</td>\n",
       "      <td>0.982863</td>\n",
       "      <td>0.991862</td>\n",
       "      <td>[[18, 1], [4, 195]]</td>\n",
       "      <td>[-20.0, 8.0, -9.0, 16.0, -4.0, 6.0, -6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.034874</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>138</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.972477</td>\n",
       "      <td>0.961121</td>\n",
       "      <td>0.984772</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.974874</td>\n",
       "      <td>0.978809</td>\n",
       "      <td>0.990807</td>\n",
       "      <td>[[18, 1], [5, 194]]</td>\n",
       "      <td>[-4.0, 16.0, 16.0, 15.0, 6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.020590</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>139</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.972477</td>\n",
       "      <td>0.961121</td>\n",
       "      <td>0.984772</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.974874</td>\n",
       "      <td>0.978809</td>\n",
       "      <td>0.990807</td>\n",
       "      <td>[[18, 1], [5, 194]]</td>\n",
       "      <td>[-5.0, 16.0, 15.0, 12.0, 6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.021716</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>140</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.972477</td>\n",
       "      <td>0.961121</td>\n",
       "      <td>0.984772</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.974874</td>\n",
       "      <td>0.978809</td>\n",
       "      <td>0.990807</td>\n",
       "      <td>[[18, 1], [5, 194]]</td>\n",
       "      <td>[-3.0, 10.0, 10.0, 9.0, 4.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.028865</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>7</td>\n",
       "      <td>0.972477</td>\n",
       "      <td>0.961121</td>\n",
       "      <td>0.984772</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.974874</td>\n",
       "      <td>0.978809</td>\n",
       "      <td>0.990807</td>\n",
       "      <td>[[18, 1], [5, 194]]</td>\n",
       "      <td>[-9.0, 25.0, 15.0, 1.0, 9.0, 3.0, 8.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.101183</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>7</td>\n",
       "      <td>0.972477</td>\n",
       "      <td>0.961121</td>\n",
       "      <td>0.984772</td>\n",
       "      <td>0.994872</td>\n",
       "      <td>0.974874</td>\n",
       "      <td>0.978809</td>\n",
       "      <td>0.990807</td>\n",
       "      <td>[[18, 1], [5, 194]]</td>\n",
       "      <td>[-9.0, 25.0, 15.0, 1.0, 9.0, 2.0, 8.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.108315</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>160</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.967890</td>\n",
       "      <td>0.958609</td>\n",
       "      <td>0.982188</td>\n",
       "      <td>0.994845</td>\n",
       "      <td>0.969849</td>\n",
       "      <td>0.974747</td>\n",
       "      <td>0.989744</td>\n",
       "      <td>[[18, 1], [6, 193]]</td>\n",
       "      <td>[-3.0, 12.0, 16.0, 15.0, 5.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.024177</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>165</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.963303</td>\n",
       "      <td>0.956096</td>\n",
       "      <td>0.979592</td>\n",
       "      <td>0.994819</td>\n",
       "      <td>0.964824</td>\n",
       "      <td>0.970677</td>\n",
       "      <td>0.988671</td>\n",
       "      <td>[[18, 1], [7, 192]]</td>\n",
       "      <td>[-3.0, 15.0, 20.0, 20.0, 6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.015310</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>167</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>5</td>\n",
       "      <td>0.958716</td>\n",
       "      <td>0.953584</td>\n",
       "      <td>0.976982</td>\n",
       "      <td>0.994792</td>\n",
       "      <td>0.959799</td>\n",
       "      <td>0.966599</td>\n",
       "      <td>0.987590</td>\n",
       "      <td>[[18, 1], [8, 191]]</td>\n",
       "      <td>[-1.0, 8.0, 15.0, 15.0, 4.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.038689</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>168</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>5</td>\n",
       "      <td>0.954128</td>\n",
       "      <td>0.951071</td>\n",
       "      <td>0.974359</td>\n",
       "      <td>0.994764</td>\n",
       "      <td>0.954774</td>\n",
       "      <td>0.962513</td>\n",
       "      <td>0.986501</td>\n",
       "      <td>[[18, 1], [9, 190]]</td>\n",
       "      <td>[-1.0, 12.0, 25.0, 25.0, 6.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.108549</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>171</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>4</td>\n",
       "      <td>0.944954</td>\n",
       "      <td>0.946046</td>\n",
       "      <td>0.969072</td>\n",
       "      <td>0.994709</td>\n",
       "      <td>0.944724</td>\n",
       "      <td>0.954315</td>\n",
       "      <td>0.984293</td>\n",
       "      <td>[[18, 1], [11, 188]]</td>\n",
       "      <td>[5.0, 25.0, 25.0, 4.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.031701</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-148a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>172</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>4</td>\n",
       "      <td>0.940367</td>\n",
       "      <td>0.943533</td>\n",
       "      <td>0.966408</td>\n",
       "      <td>0.994681</td>\n",
       "      <td>0.939698</td>\n",
       "      <td>0.950203</td>\n",
       "      <td>0.983176</td>\n",
       "      <td>[[18, 1], [12, 187]]</td>\n",
       "      <td>[1.0, 15.0, 16.0, 2.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.021746</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-148a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>173</th>\n",
       "      <td>ElasticNet</td>\n",
       "      <td>en</td>\n",
       "      <td>4</td>\n",
       "      <td>0.940367</td>\n",
       "      <td>0.943533</td>\n",
       "      <td>0.966408</td>\n",
       "      <td>0.994681</td>\n",
       "      <td>0.939698</td>\n",
       "      <td>0.950203</td>\n",
       "      <td>0.983176</td>\n",
       "      <td>[[18, 1], [12, 187]]</td>\n",
       "      <td>[1.0, 20.0, 25.0, 3.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.265226</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-182, hsa-mir-148a, hsa-mir-21, hsa-mi...</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>174</th>\n",
       "      <td>lasso</td>\n",
       "      <td>lasso</td>\n",
       "      <td>3</td>\n",
       "      <td>0.931193</td>\n",
       "      <td>0.938508</td>\n",
       "      <td>0.961039</td>\n",
       "      <td>0.994624</td>\n",
       "      <td>0.929648</td>\n",
       "      <td>0.941955</td>\n",
       "      <td>0.980912</td>\n",
       "      <td>[[18, 1], [14, 185]]</td>\n",
       "      <td>[20.0, 25.0, 1.0]</td>\n",
       "      <td>True</td>\n",
       "      <td>0.037647</td>\n",
       "      <td>False</td>\n",
       "      <td>[hsa-mir-148a, hsa-mir-21, hsa-mir-203a]</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 method  model  n       acc       auc        f1  precision  \\\n",
       "31   LogisticRegression     lr  4  0.981651  0.966147  0.989899   0.994924   \n",
       "33   LogisticRegression     lr  5  0.981651  0.966147  0.989899   0.994924   \n",
       "38   LogisticRegression     lr  6  0.981651  0.966147  0.989899   0.994924   \n",
       "42   LogisticRegression     lr  6  0.981651  0.966147  0.989899   0.994924   \n",
       "43   LogisticRegression     lr  6  0.981651  0.966147  0.989899   0.994924   \n",
       "78   LogisticRegression     lr  4  0.977064  0.963634  0.987342   0.994898   \n",
       "83           ElasticNet     en  5  0.977064  0.963634  0.987342   0.994898   \n",
       "84                lasso  lasso  5  0.977064  0.963634  0.987342   0.994898   \n",
       "85           ElasticNet     en  5  0.977064  0.963634  0.987342   0.994898   \n",
       "86                lasso  lasso  5  0.977064  0.963634  0.987342   0.994898   \n",
       "87           ElasticNet     en  5  0.977064  0.963634  0.987342   0.994898   \n",
       "88                lasso  lasso  5  0.977064  0.963634  0.987342   0.994898   \n",
       "89           ElasticNet     en  5  0.977064  0.963634  0.987342   0.994898   \n",
       "90                lasso  lasso  5  0.977064  0.963634  0.987342   0.994898   \n",
       "98   LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "99   LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "106  LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "107  LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "108  LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "109  LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "111  LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "121  LogisticRegression     lr  7  0.977064  0.963634  0.987342   0.994898   \n",
       "138               lasso  lasso  5  0.972477  0.961121  0.984772   0.994872   \n",
       "139          ElasticNet     en  5  0.972477  0.961121  0.984772   0.994872   \n",
       "140               lasso  lasso  5  0.972477  0.961121  0.984772   0.994872   \n",
       "146               lasso  lasso  7  0.972477  0.961121  0.984772   0.994872   \n",
       "147          ElasticNet     en  7  0.972477  0.961121  0.984772   0.994872   \n",
       "160          ElasticNet     en  5  0.967890  0.958609  0.982188   0.994845   \n",
       "165               lasso  lasso  5  0.963303  0.956096  0.979592   0.994819   \n",
       "167          ElasticNet     en  5  0.958716  0.953584  0.976982   0.994792   \n",
       "168               lasso  lasso  5  0.954128  0.951071  0.974359   0.994764   \n",
       "171          ElasticNet     en  4  0.944954  0.946046  0.969072   0.994709   \n",
       "172               lasso  lasso  4  0.940367  0.943533  0.966408   0.994681   \n",
       "173          ElasticNet     en  4  0.940367  0.943533  0.966408   0.994681   \n",
       "174               lasso  lasso  3  0.931193  0.938508  0.961039   0.994624   \n",
       "\n",
       "       recall        f2       f05       confusionmatrix  \\\n",
       "31   0.984925  0.986908  0.992908   [[18, 1], [3, 196]]   \n",
       "33   0.984925  0.986908  0.992908   [[18, 1], [3, 196]]   \n",
       "38   0.984925  0.986908  0.992908   [[18, 1], [3, 196]]   \n",
       "42   0.984925  0.986908  0.992908   [[18, 1], [3, 196]]   \n",
       "43   0.984925  0.986908  0.992908   [[18, 1], [3, 196]]   \n",
       "78   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "83   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "84   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "85   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "86   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "87   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "88   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "89   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "90   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "98   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "99   0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "106  0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "107  0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "108  0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "109  0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "111  0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "121  0.979899  0.982863  0.991862   [[18, 1], [4, 195]]   \n",
       "138  0.974874  0.978809  0.990807   [[18, 1], [5, 194]]   \n",
       "139  0.974874  0.978809  0.990807   [[18, 1], [5, 194]]   \n",
       "140  0.974874  0.978809  0.990807   [[18, 1], [5, 194]]   \n",
       "146  0.974874  0.978809  0.990807   [[18, 1], [5, 194]]   \n",
       "147  0.974874  0.978809  0.990807   [[18, 1], [5, 194]]   \n",
       "160  0.969849  0.974747  0.989744   [[18, 1], [6, 193]]   \n",
       "165  0.964824  0.970677  0.988671   [[18, 1], [7, 192]]   \n",
       "167  0.959799  0.966599  0.987590   [[18, 1], [8, 191]]   \n",
       "168  0.954774  0.962513  0.986501   [[18, 1], [9, 190]]   \n",
       "171  0.944724  0.954315  0.984293  [[18, 1], [11, 188]]   \n",
       "172  0.939698  0.950203  0.983176  [[18, 1], [12, 187]]   \n",
       "173  0.939698  0.950203  0.983176  [[18, 1], [12, 187]]   \n",
       "174  0.929648  0.941955  0.980912  [[18, 1], [14, 185]]   \n",
       "\n",
       "                                   coef_rounded found_coef     delta balanced  \\\n",
       "31                      [-20.0, 6.0, -5.0, 8.0]       True  0.034139    False   \n",
       "33                [-16.0, 6.0, -4.0, 6.0, -1.0]       True  0.049735    False   \n",
       "38           [-15.0, 2.0, 9.0, -3.0, 5.0, -4.0]       True  0.035638    False   \n",
       "42          [-25.0, 1.0, 10.0, -6.0, 9.0, -3.0]       True  0.098082    False   \n",
       "43          [-25.0, 1.0, 10.0, -6.0, 9.0, -2.0]       True  0.132341    False   \n",
       "78                      [-12.0, 3.0, -3.0, 5.0]       True  0.027985    False   \n",
       "83                   [-2.0, 6.0, 4.0, 3.0, 2.0]       True  0.007595    False   \n",
       "84                  [-4.0, 12.0, 8.0, 6.0, 4.0]       True  0.008621    False   \n",
       "85                 [-5.0, 15.0, 10.0, 8.0, 5.0]       True  0.017616    False   \n",
       "86                [-8.0, 25.0, 20.0, 16.0, 9.0]       True  0.018380    False   \n",
       "87                   [-3.0, 9.0, 6.0, 4.0, 3.0]       True  0.020642    False   \n",
       "88                [-8.0, 25.0, 20.0, 15.0, 9.0]       True  0.021112    False   \n",
       "89                 [-5.0, 16.0, 12.0, 9.0, 5.0]       True  0.021343    False   \n",
       "90                [-4.0, 15.0, 12.0, 10.0, 5.0]       True  0.026658    False   \n",
       "98   [-20.0, 8.0, -10.0, 16.0, -4.0, 6.0, -6.0]       True  0.021106    False   \n",
       "99    [-20.0, 6.0, -8.0, 15.0, -4.0, 6.0, -5.0]       True  0.024976    False   \n",
       "106  [-20.0, 9.0, -12.0, 16.0, -4.0, 6.0, -5.0]       True  0.030226    False   \n",
       "107  [-20.0, 9.0, -12.0, 16.0, -4.0, 6.0, -6.0]       True  0.030472    False   \n",
       "108   [-20.0, 6.0, -6.0, 15.0, -4.0, 6.0, -6.0]       True  0.030614    False   \n",
       "109   [-20.0, 5.0, -6.0, 15.0, -4.0, 6.0, -5.0]       True  0.030664    False   \n",
       "111   [-20.0, 6.0, -9.0, 15.0, -4.0, 6.0, -5.0]       True  0.030751    False   \n",
       "121   [-20.0, 8.0, -9.0, 16.0, -4.0, 6.0, -6.0]       True  0.034874    False   \n",
       "138               [-4.0, 16.0, 16.0, 15.0, 6.0]       True  0.020590    False   \n",
       "139               [-5.0, 16.0, 15.0, 12.0, 6.0]       True  0.021716    False   \n",
       "140                [-3.0, 10.0, 10.0, 9.0, 4.0]       True  0.028865    False   \n",
       "146      [-9.0, 25.0, 15.0, 1.0, 9.0, 3.0, 8.0]       True  0.101183    False   \n",
       "147      [-9.0, 25.0, 15.0, 1.0, 9.0, 2.0, 8.0]       True  0.108315    False   \n",
       "160               [-3.0, 12.0, 16.0, 15.0, 5.0]       True  0.024177    False   \n",
       "165               [-3.0, 15.0, 20.0, 20.0, 6.0]       True  0.015310    False   \n",
       "167                [-1.0, 8.0, 15.0, 15.0, 4.0]       True  0.038689    False   \n",
       "168               [-1.0, 12.0, 25.0, 25.0, 6.0]       True  0.108549    False   \n",
       "171                      [5.0, 25.0, 25.0, 4.0]       True  0.031701    False   \n",
       "172                      [1.0, 15.0, 16.0, 2.0]       True  0.021746    False   \n",
       "173                      [1.0, 20.0, 25.0, 3.0]       True  0.265226    False   \n",
       "174                           [20.0, 25.0, 1.0]       True  0.037647    False   \n",
       "\n",
       "                                               gene_id  reproduce  \n",
       "31   [hsa-mir-30a, hsa-mir-148a, hsa-mir-143, hsa-m...       True  \n",
       "33   [hsa-mir-30a, hsa-mir-148a, hsa-mir-143, hsa-m...       True  \n",
       "38   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "42   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "43   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "78   [hsa-mir-30a, hsa-mir-148a, hsa-mir-143, hsa-m...       True  \n",
       "83   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "84   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "85   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "86   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "87   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "88   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "89   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "90   [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "98   [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "99   [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "106  [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "107  [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "108  [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "109  [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "111  [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "121  [hsa-mir-30a, hsa-mir-182, hsa-let-7a-3, hsa-m...       True  \n",
       "138  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "139  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "140  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "146  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "147  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "160  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "165  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "167  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "168  [hsa-mir-30a, hsa-mir-182, hsa-mir-148a, hsa-m...       True  \n",
       "171  [hsa-mir-182, hsa-mir-148a, hsa-mir-21, hsa-mi...       True  \n",
       "172  [hsa-mir-182, hsa-mir-148a, hsa-mir-21, hsa-mi...       True  \n",
       "173  [hsa-mir-182, hsa-mir-148a, hsa-mir-21, hsa-mi...       True  \n",
       "174           [hsa-mir-148a, hsa-mir-21, hsa-mir-203a]       True  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reproduce\n",
    "results_sorted_found_coef = final_results_unique[results_sorted['found_coef'] == True].reset_index(drop=True).copy()\n",
    "reperduce = []\n",
    "for i in range(len(results_sorted_found_coef)):\n",
    "    gene_ids = results_sorted_found_coef['gene_id'][i]\n",
    "    # check if gene_ids are in X_test columns\n",
    "    if set(gene_ids).issubset(set(X_test.columns)):\n",
    "        X_test_selected = X_test[gene_ids].copy()\n",
    "    else:\n",
    "        # modify gene_ids to match X_test columns\n",
    "        gene_ids = [col for col in gene_ids if col in X_test.columns]\n",
    "        X_test_selected = X_test[gene_ids].copy()\n",
    "    y_test_selected = y_test\n",
    "    # calculate score\n",
    "    coef = results_sorted_found_coef['coef_rounded'][i]\n",
    "    times = results_sorted_found_coef['multiple_times'][i]\n",
    "    intercept = results_sorted_found_coef['intercept'][i]\n",
    "    model_name = results_sorted_found_coef['model'][i]\n",
    "\n",
    "    scores = []\n",
    "    predictions = []\n",
    "    \n",
    "    # determine model and calculate scores and predictions\n",
    "    if model_name == 'LinearRegression':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'RidgeClassifier' or model_name == 'RidgeClassifierCV':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'LogisticRegression' or model_name == 'LogisticRegressionCV':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            z = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            score = 1 / (1 + np.exp(-z))\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'Lasso' or model_name == 'LassoCV':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'LinearSVC' or model_name == 'NuSVC':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'ElasticNet':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    elif model_name == 'SGDClassifier':\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "    else:\n",
    "        # handle SVC\n",
    "        for j in range(len(X_test_selected)):\n",
    "            score = np.dot(X_test_selected.iloc[j], coef) / times + intercept\n",
    "            prediction = 1 if score > 0.5 else 0\n",
    "            scores.append(score)\n",
    "            predictions.append(prediction)\n",
    "        \n",
    "    # calculate evaluation metrics\n",
    "    acc = accuracy_score(y_test_selected, predictions)\n",
    "    auc = roc_auc_score(y_test_selected, scores)\n",
    "    f1 = f1_score(y_test_selected, predictions)\n",
    "    precision = precision_score(y_test_selected, predictions)\n",
    "    recall = recall_score(y_test_selected, predictions)\n",
    "\n",
    "    # 能复现\n",
    "    if acc == results_sorted_found_coef['acc'][i] and f1 == results_sorted_found_coef['f1'][i]:\n",
    "        can_reproduce = True\n",
    "    else:\n",
    "        can_reproduce = False\n",
    "    # can_reproduce = True\n",
    "\n",
    "    # if not acc == results_sorted_found_coef['acc'][i]:\n",
    "    #     can_reproduce = False\n",
    "    #     # print results\n",
    "    #     print('Model:', model_name, 'n:', results_sorted_found_coef['n'][i],'acc:', acc, 'auc:', auc, 'f1:', f1, 'precision:', precision, 'recall:', recall)\n",
    "    #     print(acc)\n",
    "    #     print(results_sorted_found_coef['acc'][i])\n",
    "    \n",
    "    reperduce.append(can_reproduce)\n",
    "\n",
    "results_sorted_found_coef['reproduce'] = reperduce\n",
    "results_sorted_found_coef_view = results_sorted_found_coef[results_sorted_found_coef['reproduce'] == True][results_sorted_found_coef['n'] <= 15].copy().drop(['coef','intercept','multiple_times'], axis=1)\n",
    "results_sorted_found_coef_view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# for results_sorted_found_coef, draw the figure\n",
    "# Group the results by method and model\n",
    "# filter by n\n",
    "results_sorted_found_coef_n = results_sorted_found_coef[results_sorted_found_coef['n'] <= 25]\n",
    "groups = results_sorted_found_coef_n.groupby(['method'])\n",
    "methods = [method for method, _ in groups]\n",
    "# Create a figure with multiple subplots\n",
    "\n",
    "    # Plotting inside the function\n",
    "plt.rcParams['font.family'] = 'Arial'\n",
    "plt.rcParams['font.size'] = 10\n",
    "plt.rcParams['axes.linewidth'] = 3      # 边框粗细\n",
    "plt.rcParams['axes.labelweight'] = 'bold'  # 轴标签字体粗细\n",
    "plt.rcParams['xtick.major.width'] = 3   # x轴刻度粗细\n",
    "plt.rcParams['ytick.major.width'] = 3   # y轴刻度粗细\n",
    "fig, axs = plt.subplots(1,len(methods), sharex=True, sharey=True, figsize=(20, 12))\n",
    "# Iterate over the subplots and plot the acc and roc values\n",
    "for i, method in enumerate(methods):\n",
    "    group = groups.get_group(method)\n",
    "    axs[i].scatter(group['n'], group['f1'], label='F1', color='blue')\n",
    "    axs[i].scatter(group['n'], group['auc'], label='auc', color='orange')\n",
    "    axs[i].set_xlabel('n')\n",
    "    axs[i].set_ylabel('score')\n",
    "    axs[i].set_ylim([0.95, 1.00]) # Set y-axis limits\n",
    "    axs[i].legend()\n",
    "    # Find the maximum acc and roc values for this method and model\n",
    "    max_acc_idx = group['f1'].idxmax()\n",
    "    max_auc_idx = group['auc'].idxmax()\n",
    "    max_acc = group.loc[max_acc_idx, 'f1']\n",
    "    max_auc = group.loc[max_auc_idx, 'auc']\n",
    "    max_n_acc = group.loc[max_acc_idx, 'n']\n",
    "    max_n_auc = group.loc[max_auc_idx, 'n']\n",
    "\n",
    "    # Add annotations with the maximum acc and roc values\n",
    "    axs[i].annotate(f'Max F1: {max_acc:.3f} (n={max_n_acc})',\n",
    "                        xy=(max_n_acc, max_acc),\n",
    "                        xytext=(max_n_acc, max_acc - 0.006),\n",
    "                        ha='center',\n",
    "                        arrowprops=dict(arrowstyle='->'))\n",
    "    axs[i].annotate(f'Max Roc: {max_auc:.3f} (n={max_n_auc})',\n",
    "                        xy=(max_n_auc, max_auc),\n",
    "                        xytext=(max_n_auc, max_auc + 0.006),\n",
    "                        ha='center',\n",
    "                        arrowprops=dict(arrowstyle='->'))\n",
    "\n",
    "    axs[i].set_title(f'{method} - selected genes')\n",
    "    # grid\n",
    "    axs[i].grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导出保存"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calthreadhold( model_name, instances, times):\n",
    "    if model_name == 'LinearRegression':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'RidgeClassifier' or model_name == 'RidgeClassifierCV':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'LogisticRegression' or model_name == 'LogisticRegressionCV':\n",
    "            threshold = (0 - instances) * times\n",
    "    elif model_name == 'lasso' or model_name == 'LassoCV':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'LinearSVC' or model_name == 'NuSVC':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'ElasticNet':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    elif model_name == 'SGDClassifier':\n",
    "        threshold = (0.5 - instances) * times\n",
    "    else:\n",
    "        threshold = (0.5 - instances) * times\n",
    "    return threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 计算f1值的60%分位数\n",
    "# quantile_60 = results_sorted_found_coef['f1'].quantile(0.6)\n",
    "# \n",
    "# # 过滤results_sorted_found_coef，只保留f1值在前60%的数据\n",
    "# filtered_results = results_sorted_found_coef[results_sorted_found_coef['f1'] >= quantile_60]\n",
    "# filtered_results\n",
    "filtered_results = results_sorted_found_coef[results_sorted_found_coef['reproduce'] == True].copy()\n",
    "filtered_results['threshold'] = filtered_results.apply(lambda x: calthreadhold(x['model'], x['intercept'], x['multiple_times']), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import excel \n",
    "import openpyxl\n",
    "# 时间\n",
    "import time\n",
    "xsl_file = str(dataset_name) + time.strftime(\"%Y%m%d%H%M%S\", time.localtime()) + '.xlsx'\n",
    "# 检查文件是否存在\n",
    "import os\n",
    "if os.path.exists(xsl_file):\n",
    "    os.remove(xsl_file)\n",
    "wb = openpyxl.Workbook()\n",
    "ws = wb.active\n",
    "try:\n",
    "    ws = wb['Results']\n",
    "except KeyError:\n",
    "    ws = wb.create_sheet('Results')\n",
    "# remove all rows\n",
    "ws.delete_rows(1, ws.max_row)\n",
    "# write column name\n",
    "for col in range(len(filtered_results.columns)):\n",
    "    ws.cell(row=1, column=col+1, value=filtered_results.columns[col])\n",
    "# write data\n",
    "for i in range(len(filtered_results)):\n",
    "    for col in range(len(filtered_results.columns)):\n",
    "        # not NaN\n",
    "        if filtered_results.iloc[i, col] == '':\n",
    "            ws.cell(row=i+2, column=col+1, value='N/A')\n",
    "        else:\n",
    "            try:\n",
    "                ws.cell(row=i+2, column=col+1, value=filtered_results.iloc[i, col])\n",
    "            except ValueError:\n",
    "                ws.cell(row=i+2, column=col+1, value=str(filtered_results.iloc[i, col]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建一个默认字典来存储每个列表的f1值的总和、计数、最大f1值和对应的其他值\n",
    "f1_dict = defaultdict(lambda: [0, 0, 0, float('inf'), 0, 0, 0, None])\n",
    "\n",
    "# 遍历filtered_results，更新f1_dict\n",
    "for _, row in filtered_results.iterrows():\n",
    "    key = tuple(row['gene_id'])\n",
    "    f1_dict[key][0] += row['f1']\n",
    "    f1_dict[key][1] += 1\n",
    "    if row['f1'] > f1_dict[key][2] or (row['f1'] == f1_dict[key][2] and row['intercept'] < f1_dict[key][3]):\n",
    "        f1_dict[key][2] = row['f1']\n",
    "        f1_dict[key][3] = row['intercept']\n",
    "        f1_dict[key][4] = row['coef_rounded']\n",
    "        f1_dict[key][5] = row['multiple_times']\n",
    "        f1_dict[key][6] = row['delta']\n",
    "        f1_dict[key][7] = row['model']\n",
    "\n",
    "# 创建一个空的DataFrame\n",
    "df = pd.DataFrame(columns=['List', 'Length', 'Count', 'Average F1 Score', 'Max F1 Score','Best Coef',  'Best Intercept', 'Best Multiple Times', 'Best Delta', 'Best Model'])\n",
    "\n",
    "# 将f1_dict的内容添加到DataFrame中\n",
    "for key, value in f1_dict.items():\n",
    "    df = df.append({'List': list(key), 'Length': len(key), 'Count': value[1], 'Average F1 Score': value[0] / value[1], 'Max F1 Score': value[2], 'Best Intercept': value[3], 'Best Coef': value[4], 'Best Multiple Times': value[5], 'Best Delta': value[6], 'Best Model': value[7]}, ignore_index=True)\n",
    "\n",
    "# 按照长度和出现次数进行排序\n",
    "df = df.sort_values(by=['Length', 'Count'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    ws = wb['Sheet1']\n",
    "except KeyError:\n",
    "    ws = wb.create_sheet('Sheet1')\n",
    "# remove all rows\n",
    "ws.delete_rows(1, ws.max_row)\n",
    "# write column name\n",
    "for col in range(len(df.columns)):\n",
    "    ws.cell(row=1, column=col+1, value=df.columns[col])\n",
    "# write data\n",
    "for i in range(len(df)):\n",
    "    for col in range(len(df.columns)):\n",
    "        # not NaN\n",
    "        if df.iloc[i, col] == '':\n",
    "            ws.cell(row=i+2, column=col+1, value='N/A')\n",
    "        else:\n",
    "            try:\n",
    "                ws.cell(row=i+2, column=col+1, value=df.iloc[i, col])\n",
    "            except ValueError:\n",
    "                ws.cell(row=i+2, column=col+1, value=str(df.iloc[i, col]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "gene_data = pd.DataFrame()\n",
    "# count\n",
    "miRNAs = filtered_results['gene_id'].tolist()\n",
    "# 统计出现次数 miRNAs_count as a dict\n",
    "miRNAs_count = {}\n",
    "for miRNA in miRNAs:\n",
    "    # miRNA is a list\n",
    "    # Add length of miRNA to miRNA\n",
    "    for miRNA_ in miRNA:\n",
    "        if miRNA_ in miRNAs_count:\n",
    "            miRNAs_count[miRNA_] += 1\n",
    "        else:\n",
    "            miRNAs_count[miRNA_] = 1\n",
    "\n",
    "miRNAs_count = sorted(miRNAs_count.items(), key=lambda x: x[1], reverse=True)\n",
    "miRNAs_count = pd.DataFrame(miRNAs_count, columns=['gene_id', 'count'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    ws = wb['Count']\n",
    "except KeyError:\n",
    "    ws = wb.create_sheet('Count')\n",
    "# remove all rows\n",
    "ws.delete_rows(1, ws.max_row)\n",
    "# write column name\n",
    "df = miRNAs_count\n",
    "for col in range(len(df.columns)):\n",
    "    ws.cell(row=1, column=col+1, value=df.columns[col])\n",
    "# write data\n",
    "for i in range(len(df)):\n",
    "    for col in range(len(df.columns)):\n",
    "        # not NaN\n",
    "        if df.iloc[i, col] == '':\n",
    "            ws.cell(row=i+2, column=col+1, value='N/A')\n",
    "        else:\n",
    "            try:\n",
    "                ws.cell(row=i+2, column=col+1, value=df.iloc[i, col])\n",
    "            except ValueError:\n",
    "                ws.cell(row=i+2, column=col+1, value=str(df.iloc[i, col]))\n",
    "# save\n",
    "# delete default sheet\n",
    "wb.remove(wb['Sheet'])\n",
    "\n",
    "wb.save(xsl_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 绘图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feature: ['hsa-mir-30a', 'hsa-mir-148a', 'hsa-mir-143', 'hsa-mir-21']\n",
      "weight: [-20.0, 6.0, -5.0, 8.0]\n"
     ]
    }
   ],
   "source": [
    "# 选择的模型\n",
    "# 实际输入的模型\n",
    "select = results_sorted_found_coef[results_sorted_found_coef['reproduce'] == True][results_sorted_found_coef['n'] <= 6].copy().iloc[0]\n",
    "feature = select.gene_id\n",
    "print('feature:', feature)\n",
    "weight = select.coef_rounded\n",
    "print('weight:', weight)\n",
    "times = select.multiple_times\n",
    "intercept = select.intercept\n",
    "model = select.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "ID = feature.copy()\n",
    "ID.append(\"Status\")\n",
    "ID = np.array(ID).reshape(-1)\n",
    "ID.astype('str')\n",
    "testdata = pd.concat([X_test, y_test], axis=1)[ID]\n",
    "# testdata = train_data[ID]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 对平均值都乘以权重\n",
    "weight = weight + [1]\n",
    "testdata_weight = testdata * weight\n",
    "weight = weight[:-1]\n",
    "testdata_weight['score'] = testdata_weight.sum(axis=1) / times + intercept\n",
    "if model == 'lr':\n",
    "    testdata_weight['score'] = testdata_weight['score'].apply(lambda x: 1 / (1 + np.exp(-x)))\n",
    "testdata_weight['prediction'] = testdata_weight['score'].apply(lambda x: 1 if x > 0.5 else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_curve, auc, precision_recall_curve, confusion_matrix, ConfusionMatrixDisplay\n",
    "def plot_metrics(testdata_weight, feature, weight):\n",
    "    # 创建一个figure并添加4个子图（ax）\n",
    "    plt.rcParams['font.family'] = 'Arial'\n",
    "    plt.rcParams['font.size'] = 10\n",
    "    plt.rcParams['axes.linewidth'] = 2      # 边框粗细\n",
    "    plt.rcParams['axes.labelweight'] = 'bold'  # 轴标签字体粗细\n",
    "    plt.rcParams['xtick.major.width'] = 3   # x轴刻度粗细\n",
    "    plt.rcParams['ytick.major.width'] = 3   # y轴刻度粗细\n",
    "    fig, axs = plt.subplots(2, 2, figsize=(12, 12))\n",
    "\n",
    "    # 在第一个子图上绘制分数分布图\n",
    "    colors = np.where(testdata_weight['score'] > 0.5, 'skyblue', 'lightgray')\n",
    "\n",
    "# 绘制散点图\n",
    "    scatter = axs[0, 0].scatter(range(len(testdata_weight['score'])), testdata_weight['score'], c=colors, alpha=0.8, cmap='bwr')\n",
    "    #axs.scatter(testdata_mean['pos_sum'], testdata_mean['neg_sum'], c=['gray' if target == 0 else 'skyblue' for target in testdata_mean['target']], s=130, alpha=1)\n",
    "    #scatter = axs[0, 0].scatter(range(len(testdata_weight['score'])), testdata_weight['score'], c=testdata_weight['Status'], cmap='bwr', alpha=0.5)\n",
    "    axs[0, 0].plot([0, len(testdata_weight['score'])], [0.5, 0.5], color='gray', lw=1, linestyle='--')\n",
    "    #axs[0, 0].set_title('Score distribution')\n",
    "    #legend1 = axs[0, 0].legend(['Threshold', 'Positive', 'Negative'], loc=\"upper right\")\n",
    "    #axs[0, 0].add_artist(legend1)\n",
    "    axs[0, 0].set_xlabel('number of sample',fontsize=15)\n",
    "    axs[0, 0].set_ylabel('score',fontsize=15)\n",
    "\n",
    "    # 在第二个子图上绘制ROC曲线\n",
    "    plt.rcParams['font.family'] = 'Arial'\n",
    "    plt.rcParams['font.size'] = 10\n",
    "    plt.rcParams['axes.linewidth'] = 2      # 边框粗细\n",
    "    plt.rcParams['axes.labelweight'] = 'bold'  # 轴标签字体粗细\n",
    "    plt.rcParams['xtick.major.width'] = 3   # x轴刻度粗细\n",
    "    plt.rcParams['ytick.major.width'] = 3   # y轴刻度粗细\n",
    "    fpr, tpr, _ = roc_curve(testdata_weight['Status'], testdata_weight['score'])\n",
    "    plt.plot([0, 1], [0, 1], color='coral', linestyle='--')\n",
    "    plt.plot(fpr, tpr, linewidth=8, color='orangered', markersize=12)\n",
    "    plt.fill_between(fpr, tpr, color='peachpuff', alpha=0.1)\n",
    "\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    axs[0, 1].plot(fpr, tpr, color='darkorange',linewidth=7)#, label='ROC curve (area = %0.4f)' % roc_auc\n",
    "    axs[0, 1].plot([0, 1], [0, 1], color='coral', linestyle='--')\n",
    "       \n",
    "    axs[0, 1].set_ylim([0.0, 1.05])\n",
    "    axs[0, 1].set_xlabel('False Positive Rate',fontsize=15)\n",
    "    axs[0, 1].set_ylabel('True Positive Rate',fontsize=15)\n",
    "    #axs[0, 1].set_title('Receiver operating characteristic')\n",
    "    axs[0, 1].legend(loc=\"lower right\")\n",
    "\n",
    "    # 在第三个子图上绘制PR曲线\n",
    "    precision, recall, _ = precision_recall_curve(testdata_weight['Status'], testdata_weight['score'])\n",
    "    axs[1, 0].step(recall, precision,color='darkorange', lw=2, where='post')\n",
    "    axs[1, 0].set_xlabel('Recall')\n",
    "    axs[1, 0].set_ylabel('Precision')\n",
    "    axs[1, 0].set_ylim([0.0, 1.05])\n",
    "    axs[1, 0].set_xlim([0.0, 1.0])\n",
    "    axs[1, 0].set_title('Precision-Recall curve')\n",
    "    axs[1, 0].legend(['PR curve'])\n",
    "\n",
    "    # 在第四个子图上绘制混淆矩阵\n",
    "    cm = confusion_matrix(testdata_weight['Status'], testdata_weight['prediction'])\n",
    "    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Negative', 'Positive'])\n",
    "    disp.plot(ax=axs[1, 1], cmap='Blues', colorbar=False)\n",
    "    axs[1, 1].set_title('Confusion Matrix')\n",
    "\n",
    "    # add margin at bottom\n",
    "    fig.text(0.5, 0.04, 'feature:'+str(feature), ha='center', va='bottom', fontsize=8)     # 在图的下方加上文字，这里的0.5,0.04是指文字的位置，ha='center'是指文字居中，va='bottom'是指文字在底部，fontsize=12是指文字大小\n",
    "    fig.text(0.5, 0.02, 'Weight:'+str(weight), ha='center', va='bottom', fontsize=12)          # 同上\n",
    "\n",
    "    #fig.suptitle('Metrics and Feature Weights', fontsize=16)\n",
    "    plt.tight_layout()\n",
    "    # 得调整图的下边距，否则会显示不全\n",
    "    plt.subplots_adjust(bottom=0.1)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAScCAYAAABayDwuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eZxcZZn//7/uc06tvXfS6ewLSQgEAoIgIggOMCKL6LiACogMP9FR5juMg9soAuLymRFBXEdnVBYZEUUdUXFBCCiyicgWQoBA9r33rvWcc//+OFXdXb1k7e7qTt7Px6Mf6apTdeqqU6cqfV913ddtrLUWERERERERERGRceRUOwARERERERERETnwKCklIiIiIiIiIiLjTkkpEREREREREREZd0pKiYiIiIiIiIjIuFNSSkRERERERERExp2SUiIiIiIiIiIiMu6UlBIRERERERERkXHnVTuAaqqpqSGXy+G6LtOmTat2OCIiIjJKtm7dShAEJJNJent7qx2OjEB/i4mIiOyfdvdvMWOtteMY14Tiui5hGFY7DBERERkjjuMQBEG1w5AR6G8xERGR/duu/hY7oCulyn8IOY7DjBkzqh2OiIiIjJJNmzYRhiGu61Y7FNkJ/S0mIiKyf9rdv8UO6KTUtGnT2LBhAzNmzGD9+vXVDkdERERGyezZs9mwYYOmhE1w+ltMRERk/7S7f4up0bmIiIiIiIiIiIw7JaVERERERERERGTcKSklIiIiIiIiIiLjTkkpEREREREREREZd0pKiYiIiIiIiIjIuFNSSkRERERERERExp2SUiIiIiIiIiIiMu6UlBIRERERERERkXGnpJSIiIiIiIiIiIw7JaVERERERERERGTcKSklIiIiIiIiIiLjTkkpEREREREREREZd0pKiYiIiIiIiIjIuFNSSkRERERERERExp1X7QAOJF2FgG3ZgFwQYoGEa5iW8miIuwAEoWVTxicfWGpjDtNSLhYohJaYMbiO6dtXRz5gey4Aa6mLOSRjDjEDFkPaM1hgc8anEFrqYy5NCYf2fEivH5J0DVOTLh2FkPZ8gAs0JV0SrsE10WN4pccKQksIeKWH3pINyPoBWd8SdwypmMOMtIdj+mMDKIaWjnxAPggpBBBYC4BjIB9YYq6hIe7SknQxg+478Dm25wNcY5ie9oi70e1yfsimjE9oYUrSpS7usKV03OriDlMSLj1+SG/RknQNDXGn7zHKx80AM2o80l6Ul7XW0lMMCSzUxBw8A9tyAbnAUus5NCX697Ej59ORDzHG0hB3KYbQUwzwQzCG0vH1qIlF+w6tZXMpvrhjqI0Zkp5DwnX6jrFjGPE47Ep7PqCn2P+6hhZ6/BA/sGSDENcYpiRdiqFlcybAAlOTLo2J0nlnLZt6/ei5xhxaU0Nfk458wI5cQGgtCdeQcB2mJF08xxBaS2jBHfQcuovReZJyDXWlc3xncn7IxoyPH1os0XFsTLjUx5zSeReS8oaPb7Bs6RwJrKUl6fWdI4XSOdIUd2jrez9E77Vd7TMILVuzPsXQAgbXWLJBdE7XeLu3j91RCCz5ICThOn3nPESfH+X3Q2vaoxBE8VhgWsqjNtb/HUMxtBRDW/GettayNRvQVQyIO4aZNbG+/RoMjQkHA3QUQqyF+rjT9zmwM225gI5CQKYY4jqmtG+P0EafQSG24nNuMGujz72eYohjoD7u4hCdl55jaEq4Qz5fBt63qxhSCGzfdWnPoSbmYG10HDsLYd9t4q6h9FGEZ6Ah4ZLyos/OYmjZkQsoWqiPOTQnHLbkAjJFS9IzzEh7GKAYAlhygcUxhhrPVLzutvQAg8+FQmDJBQHt+TD6LHANs2ti+NbSmQ9xDTQno+dqrS2dwwEhlikJj+ZkdPzKnydZ35KOGaanvBHPu95iyJZs9NljLcRdQ3PCIeU5bM/6FMLodW5OOGzOBmT8ED+EtBt9Rk1LuXQVQ7ZnA1wD09MeSW/477L80LKx1yfrB+QDS8pzSI/w/4OIiIiISJmSUmNsY2+Rp3bkeLGzQNaPBtvl4ZPnQMo1tKaigcjGTECxlKBwoW9AWiwlhpoSLq0pj+5CyOZMkWxg8cNof4YoIRJzooSStQOuL/2EQGjBDyyhiQIxBgIbbS/HFHcdpiYdPGNoy0dJjJhjCEJLxrfRAIdoMJ4oDXIObUxSG48GtdtzPivb83QUwtIArv85U4rFLSVvWlMeJ89MMy0dDZBzQcgzO3I805ansxDd2XWi27YkPToLAW35aNDsGNs3GDPW4tvoudB3LAwxJxpMHt6cYFVngbXdxVJSIYr90KYE01MeT7Xl+wb4Tun+xaC0zzAaHE9JRknCrkI06CqG/c9r4JDLc6DWc1jcGKc15fG37Tna8tF9Qhsdt5QXJZAKIWT8KHG0qD7OsikJpiSHf1sWAsuLXQVe6syTLSW4Mn406A5sdAxibjSg7fWjc6OsHGf5uZVf0ykJl3xoS7FZDFFS4LWtKQ5uTNBTDPnjpl5e6SqQLT1nU7pvbcyQ8hwyfpRkbUq4HNaUYGrS5S/bcqzrKRKUklWza2IcOy1Fa3rocwtCy6NbszzTlqO7GPad066BuGMo50Wi66LjdlxritDCivY8WzJFAqAh5tKacsn4lnW9xdJA3GIxGFP5GpkBvzmlZMBrW1PMr4sPic9ay1NteZ7cnqM9H1AIo9exzC29D6YkXY5vTbGgPjHs61e2PevzTFue1V15ckF0vjTEHGrjDpmiZUfpPecZw+KGOAc3xnl6R56Xuwulc9JGr7eJjodros+KRfVxDmlMsKIjz+rOPPkwSmCkPYemuEsmiBK1fQliosRJYG1/UseAY6L3Ta1nWNqc5KgpCdryIau7CuQCS03MYXFDdJwe2NTL+p4iGT86JuX3djlBWX7tYo5hfl2Mk2bUkB6QPFvfU+RPmzNsKyVO/P4w+p7X1KTLUVNTLGmIsTUXsr6nGH2WhZaNGZ+Npdc6sNGxTLiG+phLNgjpLoR9+xz8GcQIl10TfU5GxyLaZkvH2yntx7fRsU+4UcL8yClJ6uMOz7TlWN1VJLSWKUmPw5oStKZdntyeZ0V7nowf9h0nYyh9jkWf2THHkHQNSTdKiBdK7zW3dP3sGo/5dXGebsvRlov+rygnwsufdXVxhyWNCRbWx3hqR45VHXl6itFxHfxZ5ZjoHHNNeZulEEbP3RiIGyq+CAFIeQ5LmxIcNy3Vt60j7/Pwliyru4pkg5Cg/H9S6TM+el+kOah+6HtLRERERMTY8te6E8y2bds4/vjj+Z//+R/e8IY3DHubX//613z84x9n9erVzJ07ly996UucffbZO93nQEceeSSbNm1i1qxZrF+/ftRit6Vvsu/flGFddzRgHqyUE+r7t3zdwH9D+hNKA5NZ0D/vcvD1g3ml/ZTzEwMfbyQDY4sqLSBTSqiVtw+8TTmOmIkex7f9g7fdeSzXwKtbUkxLufx5c4b2fNj33Mu3CYe5X9ngOAbeJuZECb6ijQZYaTeq5LBEFVvZINqz5xiSjkOxVDE1MKE3+Hns6hgaosGxIRrgxRz6BnuDY3SA2liUzPNtVF1wxtxaZtXEyPlhlEjrKZL3Q7bnAvKh7RskZ0uJhLgLdZ6hqxgNKncnxsESTrmKrf94zq3zyAfRoDOwVCS5Br4ecSeqFCqGlgCLtQYH+qp0AmvJh1HF1Bvn1DKzJkbM6a/euWd9Lyva8wTWjvgYnoGGmKEQmr5Kw2gf/QNpO/j28SimnqItJXkg7UFXkb7kY1QdFO0z5kTxDR48P7wlw1+25fADGyWkRjiG5UTD4oY4J81ID5tcfKWrwO/W95DzQwphlEQd7nWKO1FCJghtKbEXvQ+zvh3yeRIrDf4LpQoz10TVPMPtO+FAfaz/XBn8GVRWfv0M0TlZDKPzMzr3bCnJF7225cdimP24QH08eiflQ8v0tMdb5teRcB029Ra5a003OT9KXheHORAO0XFwTfQ+yfq2dJ4Mf66P539m5c+HuBud75QSWJ6JIsr1Je+jRHEx7P9MHy5OFype24G380z/50fcoVRBO8zxNtH5UM54hdCX5N2dYzPwC4wyh+h9A6bvOc1Me5w5t5Yn2/I8tT1HNrBDPiPL/8bdKKk23HtrrM2ePZsNGzaM+v/xMrom5evUtQYevwG2PA69m6odjYiIyOiqmwvn3rvPu9nd/+MnZKXUgw8+yEUXXcRLL7004m1eeOEF3v72t/PDH/6Qs88+m5/+9Kece+65vPDCC8yaNWvY+0ybNm2sQu5jreWRLVke25atSOQMud2gf6H/W/mB1QLlwYRb+rc8WBhpYDyYz9B97fI5DPi9EESVW4MHHE7pW/5gwHX+gBvtbnwQDWj/sjUbVSKYoc93uJgHD5xGel5+CDhRbCa0xONREiIaLEF3KUFR4xliDnTnwyHHyjWVA/xdHUPHRI/bl7gLSxURRGPF0PbHbomqwzxjKIaWrB/wfy9388Y5Nfxpc5auQjRFsxD2J/vq4g75UhbAAMUAemzlY+7p4Dwf9g9IHaL41nRHZ0+NZ8gHtqK6o6z8upvSNKa2QlTBUR8zfdMTHRtN7WnPh/z4pS7q4g7za2O0pDxWduRZ1+MPfR8MeozAQnshembl5+cHti/5WU7Sls/H0EJXIax4DYsWOov9+w2BjnxIQ8Kh1nPo8UMe2pxhfl2sb7pRRz7gb9tzODaqUNrVcbUWXuws0JYLePP8Oqal+j9is37IHzb0kvOjyrZyxcxw+yyWqpziTpRsihtLkeHfV0ULxQFvvvJ7p3y+DTx3iyF0Ffsr3nZ2rkTThqEtH5L2DCnHkAlsXzIN+o//cElhiF6PzqKlNmao8aIplKs6CiybkuTRrdm+KXBBOeE1+HhC37mX8QMa4g5Jx9A+IAlSfq7V+nalGPSfk83x6PXKlqoiw74IK99bwxmcbCzf1lL52ZoLh1Z6lfdvbfSZH4Sl16Z0wz05NqVcb8VnVI8PDv3HfH2vz03PdwCVyWoG3MctfVaUE3IPb6l8b8nkMBZfEE56q+6E37wPij3VjkRERGS/MOEand9888285z3v4fOf//wub/f617+et771rXiex7nnnsvJJ5/Md77znXGKdHirOgs8vj1HoTyI34P7hrZywF+RCDJ7lugZbG8GbOVBYmArT5Tyviq+TTf9A6g9HXI4JhqQ+Za+6X6D9z/Y7hyLcpzlaTABlfsvJ3ai21RWfFTsZ4Rqll09bvl4FG3ldJ3BsRfCqOqpnDzoKobcubqbLRmfnG8p2iguF8BAdyHsO7/KSbx8uDev8NC4o95W/fu1RFVylOIf+PxK4YCNEmuB7Z8KmiuNsENr6SyE9JYStIGNjvvfduT53fpe1g5KSEX3qRygl+MYWD3Xd9tyHIPfH4a+6ZzlirXhhETJq6KFlOvQUQjZ0Ov3bX+xs0AxtH3JxJ2d2+XjZy2laY8ZBhaivtBZIONHvaLKVUE7O48DG50XBvrOgd15lYPyfs0w564ZvsJmOKGNkpUQvT86i2HfFNS+2zD858FA1ka9jcqfDc93FOjI+dH0zjCaajpS8nngax+diyEFO/xn0ngnpSylpN+A+NoKlh7fDnu+7WmMwU5uP9y+LPSd933334fPrsHXQf/UzOgzh4pqu8HK0wB9G03Dbc+HbM74w9xSJqoHH3yQ448/fre+ILz22mvp7Ozkmmuu4dxzz2XDhg0j3mfbtm0VP2G4L3/djLOuNUpIiYiIjLIJl5Q6/fTTeemllzjvvPN2ertnn32WZcuWVVy3dOlSnnzyybEMb6estTy1I0cQhhXfMo/KvkdpP3vzmMMNfvZ0sLOzxxg4gCsPtoab8rg3Kr6Ut1GSpKzcW6ectBh4eWA8e2zAnXaVoCvftJxgGlhxUh70lqfflIq++rcNuO9Ir9XeGrjvwQmD4R7DLzXWtrZc2WSx2FIfKts3TRPo60m2t4YdjI9wo10lTKBUhZWPmnXngpAduf6Bc2+pDCTck1SriaYWbsn6bMv1n8k7ckF/1csuDkD59R34b2nXuy2wQ99HA/e1s2My8HwyROdgOSk33H8auxpSWhs1sneMobcYsHxThl7fkt/NBFlZMYwSXCPFO94GT34fmEQb9vZjHM/g82OkhNGo7JzKhOFw2wbGEFpL1q/WKyV7aiy/IJw2bVrFz6ZNk2j62+M3KCElIiL7F7vrBanG2oSbvjd9+vTdul13dzc1NTUV16XTaXp6qvfHQjaIVm+KO6avcmWk6Tl7qlx1NZ5/0o/X443rcxowsDKlZ1iucBnYUHu07O6+RqqiGryvnY3pRiPucmPyne2r4rwoxe2H0B2G/QkzG00hypWSOgOP+ygUdQ0xOHkzeNvu3D8oBf/o1iyza2JMTXkkS5k0swdH1wAxE1UA3bu+l1wQrUpXnl61u/Z0qu5oG5y8Gm765u4otViiaMEjmv63prsw4pS/XRk4vbna9rWacyzt7fHd5f5GqAIbTvm2oY2maaa9ifCqye44/fTTOf/88/E8j3e9610j3m4ifkE4prY8Xu0IRERERk9hPhQWQ/pBcDJVC2PCVUrtrpqaGjKZygOXyWSoq6sb8T5bt26t+JkxY8boBmX7p7zsTUJnpNXXzaB/x0s5kTBcTykGXbalZMaeTlkcS4OPmyGaRlKWcPt/T7pO30pvA59ruS/PHj2n8nErXRyY5BluX+VjNtwgdnAD74EGT88Zzco1a6PmyhXbRsj4jDSVqLMQEtD/fMMByYS9OUd29VoMvN4MeA325Li4BnKB5Z4NvVhrWdgQxysllIzZ+b7K7wPPQDaIPgc2Z32yvqW7ELIt65MLLMFepitGq+qlfF7uairiSPb0/dC3KIONVkMshJa441S8/3Z7XwPuopqbSuVDM3ARjD09wuVzeKT7DewjuDvKi2x0FqMPFW/S/sVx4Jk+fTqet+vvLSfiF4RjSk3NRURkf1GYB/lXga2B4vA9ucfLpP0T8fDDD+fZZ5+tuG7FihUcfvjhI96npaWl4sdxRu/pW2tZ0Z4j44cV/YH2ZOA0cNA+0L5EOVwCZE/iKa96Nbg37eDpXMZAXczgOXtXITAar8TgfTilPkBeqQrKdUxp6XhLEFoKQRhdb/qn9dV4zj4P/K2NVtzznOixy2Pv0A5fJbSzCq1dnT876zuzt0LKr6cTJYIoHSMqm7SXbwvRsR84/dAQVcaUk2YDk2sjTffZlcEJw50+h9LAOuVV1jjtrDjVlM71tOuwIxewvtdnatLj0MYE/m4mXY2BuONEvaBMtAJgynNIew4NpVUWM/6ePZeK57WLx9+ZaFplf3nsnj7+wNdtd9+v5SRHuW60OekR2ighnPYc9jQvVT7+A881iZT7mcVKK2k6RJ8/e/I6W0b+TBluOuieKFj4xSs9bOwt7vrGMmnszReEIiIiUmXFOVFCCiD2IsRfqGo4kzYpdeGFF7J8+XLuuOMOfN/njjvuYPny5Vx44YVViWdlR4FHtuaIOaZvIL+zg2voT5bEHEi5lc3CHVPaTjQQKDfgjpeu39X+y49hS7dLOOzWALC8X7cvtmhZ+ljpceNOf/WJM+An5RpijkON5/RV2OzOyWXoXy2sfHmng/5Bl+MOpN3hp5wFNnoOjQmXN8ys4VVTEjgmmmaZCy3pmMOJ09McMSWBBXr8EN9a4q7pSybZAfuJl5JM5ddlpPg8B9Kew+HNSU6fU0tL0iXmmL4kpWNKy7aXDE5W7c6s3pGqrfamMmI4non6KTkGpqVcamKm73iUX7OB9y0nnlwTrdZXTuBY+hNXOxsg707cfim5EXOilf4GvgblZJlL9H4yQKx0wqfd/tdrpISpAepjDknXwXMMoY2m4gK8fmaaY1tS1MVGTqIYoiq8+phDNoimMdbFnNIU0YjjODTF+xN9u8MxUOsZEgOe7M6O4c6qyMr3K+xkHxWPTXSeDjwfy+eqLW1LjnCylj9HyhWAjoEjpiR4zbRU321ijqEh7pJ0zE7fT275c8f0P7Zr2KPPmbHkmOjzNTbCwU+5Zo+Tb8M9RtozNMadEefcBzZKinqOYV6txxFTEqRjhriz88+LhBudYynX7NZ5Wf6/a2ACeqT7OUTvi6aEQ2PMIeOHLN/YW9HbTya3vfmCcMyr1kVERGRkxVmQO5qoEe5qSDxT9W97J1xPqZ2pra3l29/+Nueffz6HHHIIP//5z/n4xz/OJZdcwrx587jzzjs5+OCDxz0uay1/254jtJb6mEMPIdnS6GngYDDuwCGNcRbUx0m4hrjjEFrL8x0FXu4ukghD4q7DnLoYy5oTpD2HVR0FVncV2F4aIHsOLKiLs7ghjjFRg+Z8ENJbDNmeD2nLBRTC/pXZZqQ9jp6aYk6tx4Zen1e6i2zO+BRCi2sMU5MOCTca1nUVAoyJBtbTUtH1GzMBvrU0J1wW1MVoy4dk/YBiGCVeQgsvdOZ5pbvYt1JYa8plcUOC2phDMbR4jiHhGAKiZcWfac+zsdfHt5ZC0D9ojfqNGHJ+2FeVY4kGQDGHvtXxHGBG2uXQpiRLmuKkXYe1PUVe6S6yJevjByGOY2hJesytjbGgPk68NCo8rhiyIx/gAK1pj1ipTKk9H7C2tBpYU8JlZo3Hxt4i63t9tmUDQmupiTkc3JCgMe7QWQj6GldbIOU5pFywGFxjaEm51MejEfvS5gSben26CgHt+ZCYA+mYgw3h3o29BNb2xVFuBDzwvBmsnMy0NkrUJF1DwjWYUrKrGEbX+2GIH8LChjg1noPrRM221/YUo6SSMaXXJpqylimtggb9U1BjjiHjW2akYyybnaAjF/BkW56eYogfWvwBU31SnqEm5uBgqPWi/eXDEM8x0W3D/mXuh7yHSv/2JVtLScGEazDW0uP3VwnVlqqfAtdiLNTGXbK+JSQ6jtNSHkub4tTGHCyGKQmXTZkiv1nXSzEMiTuG3mJ/s3VjoCnu9r0G5RXzytWBrjG8dnqaV01NsqHXJ+tHq9DFHMvaHp+1PT7F0OIayAfRuZtyo0H+YDHXIeGGzK6Nk3YNW7M+HYWQQulkL1eiuCZ6XWs8B6cUSMEP6PIt9XGnb9W6crK6PLUR+lfpi5n+lR/LScLyqn8xBxpjDgGGgh+QLTccL1XaxErTWeNOtL/uQkgutH0JoZTnkHAhH4BrLIc1JUjHHJ7ckSPr26j6z0bnU23M5fQ5NcypjdNdCIi7hkJoSbqGmGNoTLj4YVS9mAvCvp5RcTc6P+NO9J7KB2F03tko0dGYcFncEKcu5tBdDHm6LUd3IapQ84ztWxmuxjMc3ZKiMeZgjCGw0edUjx+SLYb0BtG5WeMZrIWCtWzLBhTDkIRjSHgOOd+SDUJCGyUvU55Drx+tJlcbi46VtdBdjCply+dW0ilPE7YkXIelTQk8E61muDkbsKm3SDGMnmv5eEerkFqKgaVQkeg1FC3EXZiT8phbH2N7NqC3aMkH0fFsSjgYx7Al4/NydxFrYWrSY36dx4yUR1fR0l0MwVgcovdKS8qlKR5VB/7fK930+NG+oqo/Q8YP+94v5Z+wlKhPuaYv3oE98VKuIekZHAyx8huaaIXL9nzI+l6fubWxYT4JZLK58MILuf7667njjjt429vexk9/+lOWL1/OjTfeOOJ9WlpaKi6PZtW6iIiI7IQF/FlECamXIfFU1RNSMMGTUnbQt6mDexScfvrpnH766eMZ0rDa8yHthYCkGw16amMO8dCSCyx+aQAE8HczaziqJTXk/nPr4qUBviXhGMyAuXLHTEtxzLQUoY0GHp5j+gbPAPMGVciH1tKWC/At1MejaUMDH2duXXynz2VTb5Fn2vL8cXMOa6E17XJYU5KD6mMYY6iJuUDlYGJhQzTY7CxECYhpKbdvID2cJU1J2nIBq7sLPLk9R2choCHm4Jb+ME27UdKhtxiS8gyLGxNszvg4BubWxjikKUFDvLJEY0F9lOzblZqYQ01s6B/ATQmXpsTgfSZYUJ8Ydj9TUh4HNezy4YAoqTG7Nsbg4wZgDfx5cyZKJJZO94ByIs70JfrKlWkN8XIvHkPGD+gpWpKeITHgj/qEC1HUDj3FgDm1MV5dOu/a8wG3v9gZVc+5/fepdcAxIV3FEAeojRmSnoMpJb429BZJeoaOfEDGD6n1HAqhpacY9sWXDyxpDzBRwst1LDWOw4kz0vxmXc9uVefEnWiapQXqPafvvRB3LT1+QD6AHt+S9gyLGhIc05JietojtFESzBAlN82g829RQ4KzHcOjW7Nsy/h9DbvjrqHWcyreU4VSInVOTeXrlfQcFjZUnmNHTI1WlXu5u0jGD0m6hgc3ZwnCck3ZUMZEibI3zOrvw+KHlqd35HhgU4aEa0oN1ivvH3MdEjbkhOlpljQm6C4G/HZtD+t7/Sg5OCABVRcz9BSj41EXc0i5hvZCgFNKJgRhdBwb4g7xuEfaWtrzAY5raBr03nJNVG3YVfDJBVGSxVpL1o+SU8e0pDlySgJjDEdNTfJSZ5QcNgampz0W1sf7jm9d3OWgujjPdeSJOVFiHOjv22UNhzfE6fUtG3qLfYn9wEYJuJgDhzYkeP2MdJQAHfA6v7olxYudBZ7vyNNZCEl7Dgc3xlnSGK8410dLdzHgRy92kfNDYiY65+rjLjE/pMePElhO6Xkf0pjktdNTQz63Xuos8Jt1PcSM6Uuce0QVaDknJB5a5tbF2JKJEuPNCYfDmtMc1pTAG9SEMLSW36/vZVV7HoiSXBhDZyHg6baQ9DSXY6YN/f+nrC4evddTrqk4XjWeS9yJFi3IlLKgCRdqYi5e6fiH1hJa6ClG//fUeM6Q+CB6nbNBSEc+UFJqEpuoXxBOGI4H9fOqHYWIiMjwbBv0WKjtAbNw+NvUzR3XkCZ0UmqyCEpNU8rjI2OiypVyjsNaS48fDvtHepnnGLydpCkdY0jtxspFjjFMTe3dy7qyPc/yjb0UQlsaZMGa7iLrenyOmprg+NZ032A/sJaXOgus7MjTkQ9JeoaDGxIsaYzvNCFV1px0aU6mmF0T46413fT6ISksnokqM7JBiOsaTphRw6FNwyeG9gdHTEkyq8ZjZXuebbmAIIT2vB/1JQv7E5oxh2jAO+DYFkOL69CXzBrM2nJlS/99mhIui+rjrOzIY7DRVDdjCMOQ3tJKeQ0Jpz/JVaq+Cq3hhY5oxbSamINroiRCbym5U55alQ1sVMlUami9uCHO0qYEf9wUJd6cUjbIAoUgqqQp9xxqTXkc05Lk/k2ZIclZzzE0xj16iwGuY3jnwnqmJPvPc8cYakeaP1Uyvy7OvNoY23IBqzoKPLE92zcdc+AxLYSWRQ1xmkeamzZI0nM4pDHOlmzAqo481lp6/RBjouqYgZOiylU6M2sq36OeYzi0OcHj23MUg+ETWkUbJeymJj08x9CU8HjnogZe6Mjzx00ZuktJKNeJEoQhUbVVVNHYX1UF0WdVIYz6q7nG4JTe71FywQ77HnYch1lJh2NakmQCS8p1mF8fI+kOTIg6LG1OsJSR37MnzEjTXgjYkvGj524MfukLiOlpj5Nm1mCAh7ZkeKGz0JcISbmGo6amec20FO4ICY9DmhIcMk6fF3Uxl1Nn1XDP+l66/bDvfRba6D2wbEqSBfVx6uMOdbHhz6WD6mMsaYzej4ViKTFlIR+GOMZwTEuK105Pl/rg0fd+Hc6LnQVe6CwQL1W5lcVdl6wf8pdtWRbUxyreNwN5pYUehut7F3MMXszBEhBzHIrWVkybNNBXFesy8jTZ8hdNWT9kRXseQ1TN25jYvfeaVMdk+YJwwqifB5e8WO0oRERE+m1dBy2z+xMWE4ySUqOgPu5EU1JKlUyD+TYaNO/uILcaOgsBD2zqJQihbkCFStKFXBDyt+15ZtbEmF+q6vrd+h5WdxWxpUFtVwG2ZHp5tj3H2fPqhlQEjGR62uOsubU8uDnDtmxArjQgbkq4HDstxZLG/TchVTYl6XHCjP63YmAta7uLbCxVrWUCS33M9A16rY2q8NzSceosBMQcO2SwWq74GVyRcPLMGnxrebm7SL40Vyq00fSbmkFVV2Vxx9BdLDeGjx7HdQzJUjVXeaplPghJOYZMEFUNHTU1qsxIuIbQUlG5Z71yUsqS8UMWNcRL0zYt3gjTORJuVKE13MB5dxhTmrKUdEm6hr9sy9Ljh31VXK4xzK2L8Xezana6n4Gstfxpc4Zn2vIUQ9uXAOosWGJOQGPCxSGaNtbrh0xJusNW9SVdhyUNcZ7YkSMWVn6WhDaa2ja7Jsa0VP97yzWGQ5qSLGlMsL7XZ013MUqSA0/vyJEqJYwGfyoZouRDMbS4pcqnaPasIRNYatzK5EextCTjsilJljQld/vYDCftObxlfh3Pd0RJ7d5iSE3M5ZDGREVV09/NquU100K253wcE1VgjkXF075YUB/nHQtdnmvPs6a7SGgtM2s8Dm1KMj296/9ejTGcMquGlpTHMztydJUqD1tTHkdMSbKkMTpPXGNwd/GR+lwpIRof5r2TdA09fsjzHQVeN33kpNT8uihBlhjm86QYguc6/N3MGh7ZmqWrEE02dTCEROfra6elWN0VVcrFjDNkHxk/pBha/rIt19dXKuYYFtTHOXlGmqSW5xMREREZXS/+DX74BTjmjfCmSyZkYkpJqVGQcKNKib9uz+EPM5jMBiHTUx4zd2OQUi3PdxTIB5Zab+hAIuk6dBcDnmvPM78uzhPbc7zUWSDpOsQGDIDKzaH/sL6Xf1hQN+I3+oPNrInxjoPq2ZoN6CmGJFzDjBqvosLnQOIa0zcd8bDmJL9a201bLgACDAZbGgAe25JiatLld+t7yQSWdCmRYK2lGEZJqYMbE0OSoXHX8KY5tWzJBrzSXYj6i2H4245cRYXFQMaYYaff1cYcMCG5IEpqBSFkQ0tjwuXkmTV9A/PFDdH7w9r+wa4xUVVFVAHkML8uRlcxqrEYeLuByisD7qzqcHcYYzhmWoqFDXFWdeTpKoTE3ei4z67xdqvar+zptjxP7sjjmf6Ebi6IpkIWQmjLRX2UDNCccDljTl3FdMGBXtOaYlsuYENvEROavsrB0Ea9zk6ZVTPscTHGMKc2xpxSArKc0By4Pe6Yvtdp8C780mvw6qlJnmzL0e1Hvbf6+lDZKAFz2F5WIZWr9srHNeE6HDElyRFTdp7giqbb7npabjU1JVxeNz3N66bv3f0dYzhySpJlzYloOqxh2M/hXWnLBX3T6QYr76s9v/P1846ckuSV7gI9flhaHbG/6rFcQbikMc68uhirOgq83F2gGFqmpTwOaUzQmvZoShT47fqeUjVd9PxsKana60fVnTFj+hYiKISW5zvyZPyQc+bVDVsFJyIiIiJ7YfVTcPsXIShC53YIQ3b5TWcVTNwsySRzzLQUW7IBG3uLmMDgOVElgl9qfj7SYHI43cWA1V1Fsn5IynNYWB81bR5L23PRVJqRYvRM1Dy3GFqebcvhGDNkYO0YQ9J12Jzx2ZINdqtSoMwYQ2vao3Xvn8J+qTHh8o6D6nmxs8DLXUUKoWVK0mVJY6Lv+J7oWx7akqHH75804xrDQfVx3jAzPex+jTFMT3t9+yiGllWdebK+HTZh4oflaV4MSSzVxVzSnqWrEDA16XHijDRza2MVg8vDm5O80FmgpxiSKq1wVx7s5kPLgro4s2o8Gv1o9cNcYIedrpoPQlrTHo3x0Xk/NCVcjmsd/hjtjsBantqRA0tFlUfSdYgZ07ei4/zaGIsbEywc0HR/OAnX4ex5dTzXkee59jzdhZCamGFJY4LDmhLD9kMbzpRSJVg+sKRLr0PKcyiEQTRdspSYipWa0GdLVVjHtaaYWxfjqR051vREjbKjPkZJDm9K4JZW43yxq8DK9jwdhSiJfHBDnEOaEhWVcABbMj5Pt+VKTbctzUmPw5sSHLyb03wPJE6pJ9XeiruGTHHkEkJLuen6yFrTHm+cU8vyDb10F8OKJPiihnjf/2Mpz3Dk1CRHTh2aVFzYEOfkIM1DW7J9U4KhtDqnE/XFG5g8S7gG19i+hTgG920TERERkb2wZkVUIeUX4OBj4B3/NiETUqCk1KhJug5nz6tlRXueFW15evyQlBv1WTp8SnK3prNZa3lsW44ntmcpDGhw/ciWDK9uSXH01OQef3u+u9wRKmHKQqLpWp35gIwfNWQfTsxA3lq2Zv09SkrJyBJulBQ4rLl/AGhLjamzfsic2hgL6ht5sbNQmspnWFAXY3ra2+3zJeYYDm1K8NjW7LDVfpkgpCXl0ltaXSw1aHqXH1ribtTUfLipaY0JlzPn1vGHDT2050uVVaXB7sENcf6uNNitjRmWNiX42/YcuSDs6y0VVRxaXMdw9NTUmL0P9lRHPqCrlJgZzHWilSx7/JCDGuK73Rst7kaVM0fuoopoZxKuw2FNCR7blqUYRonGuGP6VqoLbPTh31vqhTSrJsbpc2oxxjCzJsbMmljfVMT4gP5efmj57boeXu4uYG30udFdgG3ZDCva85w9r66vP9BLnQX+sKGHXNDfo25Tb7T654beIn83q0aJqVG0uCHBI7nMsD3B/DBabW/BLha6gKj32vkHx1jdVaAjH+A5hnm1sT3qVXhYc5KD6uO81FWgu/T+eL6jwPacj2eGJlY9x2CDkJe6CkpKiYiIiOyrdSvhtmuhmIdFR8G5HwNv4i4yo6zBKEq4DkdNTXHU1BRBGC2LvieD5yd35Hl0axaX/ukbtjQYf3hLlrgTNc8dC3NrY6zqyPc1Ph7IlpofL6iLRdN+DLtcSU1DzbGzsbfII1uybM76fUuzz6rxOG5amlcNU7mwu46emmJLxmdtTxGCKFE1sNrvTXNq2Zjx+fPmqCorVpreVW5gvqw5wfy6kT/sWtMe71rUwNqeIm25qGH5nJrYkOmFr2tN44eWlR2FiuqvpOtw/PQUiybQoLXc/3dX57vdyx5Y1kYVJOVk45zaGKnd7LtzzLQU7YWo6jIXhH29fxIO1MZd5tTESHhRwmFObWxIIiOqmKu87q/bc6zuKk/drUxctuUD/rChl7ctqCMXWO7b2EshsEN61BUCy3MdBWbVxMatKfmB4NCmOCvaor5U6QHViH5p4YgZaW+n78+BYo7Z535+Kc/h8AGJ9Gfb8zudkm0wZPyRWqSLiIiIyG7Z8AL84Foo5GDBEXDexyd0QgqUlBoze9oXoxhantiexUDFoNMYQ9oz9BRD/ro9x6HDLAU+GhbWx3k84dKWD6gp9RKBaLDZW5pGeFhzkvq4Q33MoSMfDjvNq9xce/DqYjI61vcU+fXabnKBJek4xN2oCuKV7iJbs92cPa9uryvU4q7hzHl1PNceTR3rLISkvKiS6bDmBPVxl5ZUNHXu6R15NmSKAMyoibGsOcHBDfFdJmEdEzVTnl838m1cx/B3s2o5ckrAy91Rr7O6mMPChviQ6WHV1pBwSXmGrD/8IgfFUjVRy16siLmxt8j9GzO05YO+ptBJz+GI5gTHTkvtssrIcwynz6llbXeR5zsKdBUD0p7D4oY4B9XH9/hzxA8tK3YydTflOmzJ+GzO+mzNRlV8NcP0RnIdKBZCHtycwXWiypyRemzJ7quLuZw1r47fr++hLR9igyjB45posYO/n11b1X5NDXGHjhF6WkU9xyz1ozQtV0REROSA1bY5SkjNOwze/e8Qm/hfAitzMEFs7C3S61tSI/T8SLpRYmpzxmd27ehnOuOu4cy5ddy9LmqqXS7sMECN53Dq7BqaStNylk1J8sdNveSDcMjUnnxoWVQfH3HZcdl75VXe8oOqT1zXEHcs3X7Inzdn9qjJ/GAxx/Q1oB6p2fi8ujjzSqswWsDbw4rA3dWcdGlOpkZ9v6Mp5kTTDR/d2j9NrmzginmtqT2bv70t6/PrtT1RXznXwXOc0v4sj23NElh43fRd98JyjGF+fZz5w0yp3FMdhZ1P3fUM5KxlWzagPRf0PX6ZLSW4y6s1bs8F/GZtD7UxhxOmpzn4AFhpc6y1pPqrEbdlg1IVZXT+VXvK6yGNCdZ2+0PeJxB9meGaaLq7iIiIiOyDZa+HVC3MOQTik+NvK2UOJgg/jAZtzggTgRwTDXL9vZ0HtBuaky7nLmzg5a4CG3t9QqAl6bK4IV7RxPmI5gSd+YBn2qPeWeVmuAbD7JoYfzerZsxiPJBtzvjsyAUk3aHVJ8YYko7DlqxPWz4YlaTgrgaxY1GxNxkd3ZJiey6q6soFUWVKaMFimbKTFfN25ontOTJ+WJF8dEpVk1k/5Om2HMumJKiLjV+zQgez21N3HWfo7TJ+SMa3fbcxBtKeode33Luhl7gbVdHJvtmdasRqWFgfZ0F9gdVdBYqh6VvpM1/qXXZYc4JZqrAVERER2XPb1kMiDfXN0eVFR1U3nj2kvwAniIZE1AOkGMJwPdGLpWlxjfuwOtPuiDmGgxsTO61aMMbw+hlpFjfEWdUZNcMtrxI4vy6mJb3HSI8fElo74rLvngMFH3qKIWPUekyGEXMMb5pTywsDVqRLuYbFpebmu9sDqiznh7zcXaioQhwo6Uar+r3cVeSIKeOXlGpMODTEHNp3MXV3Vk2M2pjDUzvyfU3zo2b5UUIqSrCXV11zqHGjKr+/bMsxrzZW9YoeGRuuY3jjnFoe35ZlRXu00qcBamMOy5oTvGoMF/IQERER2W9t3wA3fwbiSbjos9AwtdoR7TElpSaIKQmXGWmPtT1FPMepmPYS2mha3EF18b6VrarNGMOMmhgzaiZ207T9SaJUIRXYaKrUYEGp6XnC3b/7srTnA1Z1RD2v4o5hfn2MucM06h5PrmM4pDHBIcMkc7uLAc+3F9iUKWJMVE14cEOcdGz41ymqHGHE5KMxUYP5XDB2VZPDcUw0tfP+TZmKlRGhf+ru4oY4zUmXhoTDtJTL5oxPGgffWqyNKqRCoiqpVOk8LVf5bcv6dBTCvmnCIwmtZV1PkTU9RYIw6lV0cGOC2hGOp0wcMcfw2tY0R09N0Z4PMAaaE66qLkVERET2xo5NUUKqpx1a50Nscs46UFJqgjDGcNKMGn7xShddxZCYMbjGEFhL0Voa4i4nzth1DxmJWGtZ1+OzsiNPez4g6RoOqo9zcGN80iZtZqU9GmIOnYWQ2kGDOFvqX9SS8va4f9FkYa3lie25vv5N5ZTMM+15ZqU93jS3do+rksba6q4C927oJTtgVbGXuwo8sT3LG+fUMmuYpG7ai1a2KwZDe+9AlJSxQF0VkjCHNyfoLAQ83ZavWBnRmGglxTfMjKbuusZwxpxa7l7Xw9ZsQCEICQGn9FMXq1y9zzFQDKOV+XYmUwz57boeNmZ8Ats/FfAv23K8fkaaQyfYan6dhYCXS6sf1saiatKJdo5WQ9w1tO7lggwiIiIiArRvjRJS3W3QMgfeezWk66sd1V7RX4UTSHPS5a0L6vnb9hwvdBXwQ0vMNRzWkODIqUkaxnjq3v4itJb7N/ayor1AaC2OiaYPre0p8nRbjrPm1U3KY+k6hmOnpbh3Yy89xWhlPNcYgtCSCUI8x/CaaakJNwWmvCz9vjZEf7GrwMNbsgDUDui15IeWdb1F7lnfw9nz9r7J+2hrywXcs76HQmAr4g2tpaeUXDlvYQM1g5JLMSda8fBvO3IkSudvmbWWrG9Jew4L6se/StEYwwnT0yxqSLCqI09XISThGRbWx5lXWzl1ty7u8vaD6lnbXeSZthwvdBaIu4a05wzpnedbi+ew02onay2/X9/Dut4iKdch5jh912d8y/KNvdTEHOaOwUIQeyq0lj9vzvBMW55iaPv67j28JctrW1Mc3qz5tSIiIiKylzq3w81XQtd2mDIL3nsN1DRUO6q9pqTUBNOYcHnDrBpOmJEmH1gS7tDl1/cn1lq25aLl41OeQ0ty31eJerotz7PteWLGkPD6k0+BtWzPBdyzvpe37cMKddV0SFMCCzy6NUt3McTaEGMMDXGX46enOGgUVlkbLfkg5Jm2PCva82T8EM9EyZZlU5J7PA3VWsuT23ME1g5p7u05hqR1WNfrsy0XMC01MT7WnmvPkRu0UiJE0+BqPIfeYsiqzjxHTR26wuBRLUnW9hRpywfEHUPMGEIgV0o+Ht+aJlmlij9jDNPTHtN3o9LFNYYF9XHm1sX44Qud0ZQtCwNzUqG1FELLoY2JIQm6gTZlfDb0+qWEVP8OjDGkvajn2lPbcxMiKfXolixPbM8Rc0xfQjK0lmxgeWBThoRrWKyV5kRERERkT3XtgJuuhI6t0Dwj6iNV11TtqPbJxBi9yRAxZ/9ORgGs6yny0JYM27MBYakfUkvK5fjWNLP3cmAZWsszO3JgDYlB02RcY0i5DlsyPpsyPjMnaT+sQ5sSLG6Is66nGFXNxKKpUxOpwXzOD7lrTTebMz4OBs+JeiU9sSPHi10FzppXt0fJo14/SigmnOGTFjEH8r5lfU9xwiSl1vb4uGb4ZuXl6qf1PcVhk1J1MZdz5tfxyNYsq7sK5EKLMdCa8ji6JcWihomTfNwdrjGcNLOG36ztptuP+lE5xuCH0fTkprjLa1qHHoeB1vUUCawlNczxNCb6vNyQKZIPwqpO0c36IU+15fCMqUgcRslIQ3cx4PFtORbVxydlYlxEREREqsxxoLE1SkiVV9ybxCbG6E0OOGu7i9y9rptCYEm6Dq6JGnVvyvj8em03Z8ytY85eJKa6CiFdxZCEO8IKdQZy1rIlO3mTUhBVBy2YQFVRgz26NRs1uXadimSZtZbuYsh9G3o5d2H9bg/Kg1IfpZFuXm7+HY5v7++dCu3OgzGYncZbH3f5+9m19BZDuoshMSdqCj1ZExlza2OcM7+ev2zLsr6nSLE0ZW9JQ4JjWlLU72JKbflYjfT8HaJqpGqfA2t7iuQDS80IvaOSrkNbPqAtHzAlqf+CRURERGQP1E+B910Lvj8pV9objv4ilnFnreXPWzLkB01tcgx4xqHHD3loS4bZNbuftCgr33wC5SYOOPkgZFVnAc+YIdVbplSttj0XsDHjD9voezi1MYcaz6G7EA5bQeiHFoxh6gRq8j6zxqMtn8daO+Q8ttZisbu1emVNzNnptLbJZHra4+x5dfQWQ/JBVOW3u9MQm5PRaxtYizvM50LBWpoTDskREtLjxS9lxUZaDdIBrI0au08EWT8kF1hS3u6/FiIiIiIyjjJdsO55WHJsdLlu8ldHDaSklIy7LdmAtlxAynWGDNZNacrL9mzA1mywxys01cUc6uMO7bmQ+HDJCxtNJZo+QaZ47Y86C1HCITHCdMJytVpbLtjtpJRrDIc1J/jz5gzFsHJVOmst2SBkStKdEP2EypY2JXm+o0A2sKTc/gofay29pX5xSxonbrXbWIoSbXt2n4Pq49TFo8Rk7aA+XcXQgrUc1pyseiVZQ9ztm5roDfMeKFpLzIH6eHUTQNuyPo9vy7Kmu0hA9L5cWB/n1S2pPe75JiIiIiJjJNsDt1wDW16Bt10Oy15f7YhGnb4WlXHXWwwJrMUbYewYTeWzZPw9LyVwjGFZcxKMJR9U3j8oJS92t0mz7B3PGIzZdbXacAP2nTlySpKF9XHyYUh3MWqO3+uH9PghtTGH02bXjlidUg2taY8TpqdxTNSEO1OKt9sPiTvwd7NqJuUqkNUScwynzqol5Tl9xzMXROdCPghZ2BDn8KbqNw+fVeMxJeGSDULsoCmc5abuC+vjpEeY3jceNmWK/N8r3azqLGAhaqRv4dn2PP/3Sjft+aBqsYmIiIhISa4Xbr0GNq+GVC20zq92RGNCI3MZdykvanIcWIZNTAWlaqbUXg7aljUnaMsFrGjP01UMcDGEpRTJtKTHabNrql5NsT9rSjg0xV2253xiztCkSz60xF3D7No9+/jxHMPpc2pZ1VlgRVue9kK0Mt3ihjhLmxMTMsGzbEqSlpTHivYcG3t9DDCnNsbS5gRT1U9oj82pjfEPC+p4pi3Pi50FAmtpTXsc1pTgkMbEhGj2b4zh5Flpfr2mp5SA7G/q7lvLlOSum7qPJWstD2zMkPHDiunTMQxxx9JZCHhoc4Yz59VVLUYRERGRA14+C7d9Dja+CKm6qKn5tDnVjmpMaFQk42562qMp4bAjF1BrKqfhWGvJBSEtKY/WvewPZIzh5JlpFjbEWdkeJS+SrmFhfZxFDfGqrsx1IDDGcNTUJH/Y0EvGD0m50Qp0tlQlUgwty6YkqYvt+evrOoZDmxIcOgEqYnZXVJlXW+0w9htTkh4nz/Q4aUYay8i9m6ppRjrGW+bX8cSOHC93RcmzhGs4ojHBUVNTVe0Rtinjs2OE6dOOMSQcw9qeIp2FYEImekVERET2e4Uc/O/nYN1KSNbAe6+G1nnVjmrMKCkl484xhte2pvnduh56/JDUgNX3skHUyPq101L7VM1kjGFObWyvVvCTfbekMU7GD3lsa5aeAdMwXcewpDHBCdPTVYxO9gflFRcnqqkpj7+fXUshiJKxSdfs8ZTVsdBVDPGtJTXC56vnGLKBpbsQKiklIiIiMt78IvzwC7BmBSTScOFVMOOgakc1ppSUkqo4qD7OG+fU8tDmDB2FkNBaHGOYknQ5vjXN/PoDswH0ZJfzQ9b0FMkHlsaEy7kL63m5u0h3MSThGg6qj9OSdDV9Ug4YcdcQr/KKgAPFnSiZFwLDpZxCGzWbnEgxi4iIiBwwXA+mzYMNL8AFV8KsxdWOaMwpKSVVc1B9nPl1MTb2+mSDkLTnMCPtTcjpOLJz1lqe2J7jr9tzZEuVUQZDXdzhxOlpjm6pXg8dEek3uyZGTcwh61tqhmnqlwtCpiY9WpKqkhIREREZd8bAm/4RjjsTmmdUO5pxoaSUVJVjDLMn+BQ7ay3bcgGrOvJ0FqKKn4X1cebWxXBHOYG2I+ezNRtgDMxIe5Nm+szfduR4aEsWA9R4TqmRvaW7EPD79T14Ti3z6lT9JlJtcddw9NQUD26Omp0n3agRe2gtWd/iOoZjpiVVzSgiIiIyXgIfHr4LjjsbvFiUmDpAElKgpJTITllreWhLhid35CmGFgNYYGVHgVk1Hm+aU7vXqwQO1F0MWL6hl/W9PsUwWikw7kTJr5Nmpid0c/Z8EPLXbTkMVCxz7xpDjefQ44c8ti3H3NqYBroiE8CRUxL41vLEtiy9ftj3uZb2HF7bmmJxw+RZSEBERERkUgsC+OlX4NkHYf0qOO/j1Y5o3CkpJbITz7bn+ev2PJ6hYvl0P7Ss6ymyfGMvZ8zdt6XTc0HIr9b0sDXrk3QckqUpNfnQ8lxHnowfcvb8ulGvyhot63p8Mn5IzTDJOWMMCddhW9anPR/SrClBIlVnjOGYlhRLmxK83FUgF1hqYg4L6mITOgEuIiIisl8JA/j5V6OElOPBUadVO6KqUFJKZAShtTy5IwcWkoMSLp5jSFjDK91F2nLBPiVbnu8osC3rU+M5FYmnpGtwjWVdr8/a7iILJmjz93wQ9ZAaqReYCxQt5MORWiuLSDWkPYfDmpPVDkNERETkwBOG8ItvwtMPgOPCuVfAwa+udlRVoa9ERUbQWQj7ekgNJ+4Y/NCyobe4T4+zqiMPMGwlVMwxWGt5sbOwT48xlmpjUQWZX5p2OJhvLa6JbiciIiIiInJAC0P45X/B3+4F48A7/g0OOa7aUVWNRokiIwitjRqt7Op2+/g4Wd/udGqewZDx9/VRxs7s2hiNcYdsEGJt5QELrSUfWubVxaiLqUpKREREREQOcPfcAn/9fZSQetvlsPT4akdUVUpKiYygIe6S8gyFESuAouqmfV06vSHuENjhH8NaS4ilIT5x36quMbx+RpqEa+j2Q/JBiB9ackFIjx9SH3N4bWu62mGKiIiIiIhU3yHHQSINb7kMlr2+2tFU3cQd6YpUmecYDmtOElrbtyJeWWijpMu0lMuM9L61ZlvSmMDAsNPfCqHFM4bFjRN7Nax5dXHOmlfHvNoYIVGTdmPgkMYEb1lQT1NCVVIiIiIiIiLMPRT+5Vvwqr+rdiQTghqdi+zE0VOTbMv6vNxdIBeAZwyBBYulKeFy6uzavhX59taihjgvdMZ5pbuAGxriTv/qe6G1HNacYOY+Jr7Gw6yaGLMWxOgsBOQDS43nUKM+UiIiIiIicqD7452w+GiYviC6nK6vbjwTyMQf6YpUkecY3jSnlhc6CzzXnqejEJB0HQ5ujHNIY2JUki6eYzh9Ti2Pbc2wsiNanh2ixuCHNyc4ampynxNf46khrqooERERERERAO6/A+77Ifz553DZ16GmodoRTShKSonsgusYDmlKcEjT2E2hi7uGE2bUcMy0FG35AINhatLFcyZPMkpEREREREQG+NNPo4QUwIlvV0JqGEpKiUwgCddhRlpT3vZFeQXAyVRdJiIiIiIi+5mHfgH33Br9fsr5cMJbqxrORKWklIjsF9Z0F3imLc+GXh+AGWmPZc0J5tXFlKASEREREZHx8+iv4bffj34/+Tw46R3VjWcCU1JKRCa9J7ZneWhLliC0xEpTHl/pLrCup8hrpqU4ZlqqyhGKiIiIiMgB4blH4Nf/Hf1+4tvhDedVN54JTkkpEZnUtmZ9HtmSBQt1sf4m60kXsn7IY9uyzKr1mJGOVTFKERERERE5IBx0BMw/HGYshFPPB83a2CklpURkUlvZnqcQWuq8ob24kq6hxw9Z2Z5XUkpERERERMZeIgUXfAZcTwmp3aCOyiIyqW3N+jiYYftGGWNwjGFLNqhCZCIiIiIickB49kG4/8f9l72YElK7SZVSIjKpeY7BYkfcbi14+g9BRERERETGwnMPw0+uBxvCtLlw6HHVjmhSUaWUiExq8+viAIR2aGLKWovFsqBeU/dERERERGSUPf8Y/PjLUULqyDfAkmOrHdGko6SUiExqBzfGqY+79PghwYDEVGAtPX5IbcxhSWOiihGKiIiIiMh+58Un4I7/hNCHw0+Et1wGjlIse0pHTEQmtbTncMbcWpoSLhk/pKsY0F0MyPghDXGXM+bWURvTR52IiIiIiIyS1U/B7f8PAh8OPR7+4V/AcXd9PxlCPaVEZNKblvJ416IGVncV2JzxAWhNeRxUHyfuqp+UiIiIiIiMku42+OEXwC9E0/Xe/q/RSnuyV3TkRGS/EHMMSxoTmqonIiIiIiJjp64Z3vg+WPUXeOdHo5X2ZK8pKSUiIiIiIiIisjPWQnlV72PfBK9+o3pIjQIdQRERERERERGRkWx8CW7+DGS6+q9TQmpU6ChWURBatmR8NvUWyfphtcMRERERERERkYE2vwy3XA2vPAP3/KDa0ex3NH2vCqy1PN2W58kdOboLIRaIO7C4IcFxrSlSnnKFIiIiIiIiIlW1ZU2UkMr1wOyD4fSLqx3RfkdJqSp4eEuWx7fnwELSNRigEFqeasuxLedzzvw6Eq4SUyIiIiIiIiJVsW093HJVNGVv5iI4/zOQSFU7qv2OMh/jrC0X8OSOHC5QG3PwHIPrGFKeQ43rsDnj81x7odphioiIiIiIiByYdmyMekj1dsL0BXDBZyBVU+2o9ktKSo2zFzrzFENL0jVDtrmOwWB4tj1XhchEREREREREDnDWws9uhJ52mDYXLrwa0nXVjmq/paTUOOspRj2kjBmalALwHOgtWqy14xuYiIiIiIiIyIHOGHjb5bDwKHjvNVBTX+2I9mvqKTXOkp6DIWp2PlxiKrCQ8syISSsRERERERERGWVhAI4b/d48Ay78THXjOUCoUmqcLayP4xpDMRy6LbSW0FoOaYyPf2AiIiIiIiIiB6LuNvivf4PnH6t2JAccJaXGWWvKZWFDnHwYkvVDrI2m6hVCS68f0hh3Oaw5We0wRURERERERPZ/PR1w81WwdQ389vsQ+NWO6ICi6XvjzBjDKbNqSLqG5zvy9PhRjynPMcyuifGGWTXUxpQrFBERERERERlTvV1wy9WwfT3UT4lW2XOVJhlPOtpVEHMMJ8+s4ZiWFOt7i4QWpiRdWpKuekmJiIiIiIiIjLVMN9x6dVQhVdsEF30WmqdXO6oDjpJSVVQTc1jSmKh2GCIiIiIiIiIHjlwv/OCzsPllqGmIElJTZlY7qgOS5omJiIiIiIiIyIHj0V/DxhchXQ/vvQZaZlc7ogOWKqVERERERERE5MBx4tuiflJHnQKt86odzQFNSSkRERERERER2b8V81ETc8eNfs64pNoRCZq+JyIiIiIiIiL7s2IBfvhF+NlXIQiqHY0MoEopEREREREREdk/+UW44z9h9ZMQS8KODTBtbrWjkhJVSomIiIiIiIjI/scvwo+/BC88Dl4c3vMpJaQmGCWlRERERERERGT/EgRw5w3w/GPgxuDd/w4LDq92VDKIpu/Jfq8YWlZ3FWjPB3jGMLcuRkvSxRhT7dBERERktHWtgcdvgC2PQ++m0d2viIhMDmEAP/sKPPdQ1Nz8XZ+AhUdWOyoZhpJSsl9b013gvg29dBfDvuse3WaYXxvjlNk1JF0VC4qIiOw3Vt0Jv3kfFHuqHYmIiFTT5lfguYejVfbO/RgsPrraEckIlJSS/dbWrM9v1/WQDyxpz8E1BmstxRBe6ioQroOz5tWqYkpERGR/0LVGCSkREYnMXBhN1yvkYMmx1Y5GdkJJKdlvPbUjRy6w1HlOX+LJGEPcBYzD2p4iW7IB09N6G4iIiEx6j9+ghJSIyIHMWujthNrG6PKio6oajuwezV2S/VIQWl7uKhIzZthKqJiBwFpe6S5UIToREREZdVser3YEIiJSLdbCb74H3/432L6h2tHIHlBSSvZLvrWE1uKMMDOvnKgqhnYcoxIREZExM5pNzfdWzYxqRyAicuCxFn5/MzzyS+hug40vVjsi2QNKSsl+Ke4YamMOA/qbVwhtlIxqjLvjGJWIiIjs11qPqXYEIiIHFmvh3tvgz/8XXT77n+CIk6sbk+wRJaVkv2SM4bDmJBaLP6gaylpLxrekPIdFDfEqRSgiIiL7lXgdvPpfqx2FiMiB5f474I93Rr+f8X445o3VjUf2mJJSst86rDnB3LoY2SCktxhSCCz5IKTHD/EceP2MNClPbwERERHZR/E6eNNNUD+32pGIiBw4/ngnLL89+v30i+G4M6sbj+wVLTsmu1QMLRt7ixRDqI87tCTdYZuHTzQxx3Dm3Dqe2pHj2bY8GT/EAAvq4hw5Ncmc2li1QxQREZHx5HhQP2/09lczI5qy9+p/VUJKRGQ8+UVY8efo99MuhOPPqW48steUlJIRWWt5qi3PE9uy9PgWay2uY5ie8jhxRpppqYl/+sQcw6tbUhw1NUnWt7gOJF1VR4mIiByQ6ufBJWqAKyIy6XkxeO9n4bmH4OjTqh2N7AONzmVET2zP8adNGXqLlpRrqPUcPGNY31vkl2u6acsF1Q5xtznGUBNzlJASERERERGZrLau6/89VaOE1H5gwo3Qt27dylvf+lYaGxuZOnUql19+Ob7vD3vbG2+8kQULFlBfX88RRxzBnXfeudN9b9u2reInDEdYmk3I+CGPb8tigJqYg2sMxhjijqHOc+gphjy+PVvtMEVERERERORA8Nd74Jv/Ag/fVe1IZBRNuKTUeeedR21tLRs3buTRRx/lnnvu4YYbbhhyu7vvvpsvfOEL/OY3v6Grq4urrrqKc889l1deeWXEfU+bNq3iZ9OmTWP4TCa3l7sK5AJL0h3aO6qcnHq5q0DOV2JPRERERERExtCTy+EX3wQsdGyrdjQyiiZUU6AXX3yR5cuXs2HDBtLpNAcddBBXXnklH/vYx/joRz9acdvnnnsOay1hGEa9jlyXeDyO502op1RVgbWs6S7yYmeBXj+kLuZwcEOCObXeLhuVZ32LMdG0t+G4xuBbGyWudMhFRERERERkLDz9R/j51wALx74pWmlP9hsTKp3w7LPP0tzczMyZM/uuW7p0KWvXrqWjo4PGxsa+69/97nfz/e9/n6VLl+K60WpwP/jBD5g9e3YVIp948kHIb9f1sLbHx1qLwWCxPN9RYFFDnNNm1eA6Iyem0p6DtRBaO2xiyg+jpuEpb+KvwiciIiIiIiKT0IqH4KdfARtG/aPOeD9MgpXgZfdNqOl73d3d1NTUVFyXTqcB6Onpqbi+UCjwqle9ikcffZRMJsN3vvMdLrnkEp5++ulxi3ci+9OmDGu6iyQcQ13MpTbmUBdziRnDqo48f9m2835QC+pjJD2HbGCHbLPWUrSWRQ1xEmocLiIiIiIiIqNt5aPwky9HCakj/w7O/idwNP7c30yoV7SmpoZMJlNxXflyXV1dxfWXXXYZhx12GMceeyzxeJyLL76Y448/nptuumnE/W/durXiZ8aMGaP+HCaC7mLAi10FYo4hNqgaKu4aXGN4pi1PYZiEU1nKc3jNtBQAPcUQP7SE1pIPQrr9kPqYw9FTU2P6PERERGT8jeWiMyIiIrtt2zoIA1h2Erzlw0pI7acm1PS9ww8/nB07drBlyxZaW1sBWLFiBbNnz6ahoaHitmvXruWYY46puC4WixGPx0fcf0tLS8VlZz89qTdnfAqBpdYb/vklHEMusGzL+cyqiY24nyOaE8SM4fHtWboKIdaC68D8uhgnTq+hMeGO1VMQERGRKjnvvPOYNWsWGzduZPPmzZxzzjnccMMNQ/p7lhedeeCBB1iyZAl33nkn5557Li+99BLz588fdt/btlU2p9VKyCIiMqLXvx2mzoaDjwFHY8/91YRKSi1evJgTTzyRyy+/nO985zts376da6+9lksuuWTIbc855xy+/vWv8+Y3v5lXvepV/PSnP+W+++7jC1/4QhUin3hGroECTLTd7vRG0Sp7S5sTLGmKsyXjUwgtDXGXJiWjRERE9ktjvejMtGnTxvopiIjIZLbhhSgRlSjNyjn0uOrGI2NuQiWlAH7yk59w2WWXsWDBAhzH4b3vfS9XXnklALW1tXz729/m/PPP56qrrsJ1Xd7+9rfT1tbG4sWL+fnPf86rXvWq6j6BCaAl6RF3DIXQknCHNoErBNH1U5O7l1xyjWHmTiqqREREZP+gRWdERKRq1qyAH3wWpi+A86+EZLraEck4mHBJqdbWVn784x8Pu21gs3PP87j66qu5+uqrxymyyaMx4TK/LsaqzgKesRWr7PmhxbeWwxsSJEeY3iciIiIHpl0tOjMwKVVedOZ73/seRx55JLfddhuXXHIJS5cuZdmyZeMZtoiITHbrVsJt10IxD/EkuBMuVSFjRFmJ/dRJM2qYkfbIBCHdxYCMH/2bC0Lm1sY4rlVZZxEREak01ovOiIiIDLHhRfjBtVDIwYJl8K5PQGzkXtGyf1H6cT+Vjjm8ZX49L3Tmeb6jQMYPqYs7HNKYYGF9HM8ZOq1PREREDmxjvejM1q1bKy4feeSRbNq0aZSiFxGRSWfTarj1ashnYO5SePe/QyxR7ahkHCkptR+Lu4bDmpMc1pysdigiIiIyCYz1ojMHykrIIiKyG7asgVuuhlwvzF4C5386mronBxQlpURERESkjxadERGRcWEtGAMzF8EFV/avuCcHFCWlRERERKSPFp0REZFxMX0+XPx5qG2EZM2ubi37KdVMi4iIiIiIiMjYa9sEa5/rv9wyG1K11YtHqk6VUjIpdeQDnm3L8VJXkWJomZJ0WdqUYFFDHMeoibuIiIiIiMiE0r4Vbr4KMl1wwWdg3tJqRyQTgJJSMuls7C1y99oeev0QzxgMsK6nyPpenzXdRU6dXaPElIiIiIiIyETRuR1u/gx0boMpM6F5RrUjkglCSSmZVIqh5Z71vWT8kDrPwQxIPhUCy/OdeWbUeByuFQdFRERERESqr6stSkh1bIGm6XDRZ6GuqdpRyQShnlIyqbzcVaCzEJAelJACiLsGLDzTlsdaW6UIRUREREREBICeDrjlM1EvqcZpUUKqfkq1o5IJREkpmVS25wIA3BGm58UcQ0c+IB8oKSUiIiIiIlI1ma6oQmr7BqifGiWkGluqHZVMMJq+J5OKW8pFWWuHVEoBWMAAaiklIiIiIiJSRfFU1Dsq1xslpJpaqx2RTEBKSsmkMqsmhmNy+BZigxJP1lqKoWVeXYyEqyJAERERERGRqvFicO5HobstmronMgwlpWRSmVXjMT3tsaG3iMHBc6LMlLWWbGDxHMMRU9TkXKqnIx/wfEee9nxAzDHMr4szvy6G66h8T0RERET2c7kMPHEPvPbN0fQV11NCSnZKSSmZVIwxvHFODXev7WFrNsAGYd+2uGM4fnqa+XXxKkYoB7Int+d4eEuGQhj1NLPAcx0FWlMuZ8ytozamCj4RERER2U/ls3DbtbBuZdTg/O/fW+2IZBJQUkomnbqYy9sX1PNKd5E13QWK1tKU8Di4IU5jwq12eHKAermrwINbMmChdsDqkH5o2ZTx+f26Ht66oG7YXmgiIiIiIpNaIQ//+/koIZWsgcNOqHZEMkkoKSWTkusYFjbEWdigqiipPmstf9uRIwgtdbHKxKjnGFI4bMr4bMr4zKyJVSlKEREREZExUMzD7V+ENc9CIg0XXgUzF1Y7KpkkNJdERGQf5QPLloxPfIS+UZ6BwFrW9/rjHJmIiIiIyBjyi/Cj/4DVT0IsCedfCbMWVzsqmUSUlBIR2UelFlIYhk9KlafshdaOV0giIiIiImPLWvjJl+HFJ8CLw/mfhrmHVDsqmWSUlBIR2Ucpz1AfdyiMkHQKQovB0JLUjGkRERER2U8YA4e/HuIpeM+nYP5h1Y5IJiGNkERE9pExhsObkzywqZdCaCum8VlryQQhjQmX+XXqJyUiIiIi+5HDT4CDlkG6vtqRyCSlSikRkVFwWHOCgxsSFEJLdzEg64f0+iE9fkhNzOHvZ9fijtBzSkRERERkUggDuOdW6Nzef50SUrIPVCklIjIKXGM4bXYN8+piPNeeZ0cuIO4aFtXHWdqcoCHu7nonIiIiIiITVRjCL74Jf7sXnnsE/ukG8DQTQPaNklIiIqPEMYYljQmWNCaqHcqEY62lqxhSDC11MYeEq0JdERERkUnDWvjVt6OElHHglHcrISWjQkkpEREZU690FXh8e46tWR9rIeYaDm6Ic0xLipqYklMiIiIiE5q1cPf/wOO/Awz8w7/AYSdUOyrZTygpJSIiY2Zle577Nvbih5aE4+A4UAwsT+7IsSnjc868OtJKTImIiIhMTNbCb78Pj/4aMPDWy+CIk6odlexHNBIQEZExkQtCHtycIQih1nOIuwbPMaQ8hxrPYVvW5287ctUOU0RERERG8tAv4OG7ot/f/EF41SnVjUf2O0pKiYjImFjdVSTjh6Q9gzGVKw+6xuAaw8qOPH5oqxShiIiIiOzUstdDyxw481J49RurHY3shzR9T0RExkR3IcAYgzMoIVXmOYZ8YMkGIXWOVicUERERmXDqmuHS6yAWr3Yksp9SpZSIiIyJhOtgrcXa4SuhQmtxDMSd4ZNWIiIiIlIFD/4cnlzef1kJKRlDqpQSEZExMb8uxsNbDPnQknQrE0/WWgqhZUljgoSr70dEREREJoSH7oLf3wwYaJ0H0xdUOyLZz2kkICIiY6Ix4XJoU4JiaMn6YV/FlB9aevyQlOtw1NRklaMUERERESBaYe+334t+P/mdSkjJuFCllIiIjJkTp6dxDKxoz9PjhwAYY2hKuJw8s4ZpKf03JCIiIlJ1j/8Ofv3f0e8nvg3e8K7qxiMHDI0GRERkzLiO4fUzanjV1CRru4v4ITTEHebUxXBHaIAuIiIiIuPoiXvhrv+Kfj/+HDj1AtDfaTJOlJQSEZExVxdzOaxZK+yJiIiITCgbXoT/+zpg4TVnwhvfp4SUjCslpUREREREREQORDMXwuvOgXwWzvj/KSEl405JKREREREREZEDkTHw9xeBtUpISVVo9T0RERERERGRA8Wqv8Dt/w+KheiyMeAoNSDVoTNPRERERERE5EDw4hPwo/+AlY/AI7+sdjQiSkqJiIiI7A/a29vJ5/PVDkNERCaq1U9FFVKBD4e+NlppT6TKlJQSERERmaTuvPNOTjvtNOrq6mhpaeG3v/0td999N1dccQVdXV3VDk9ERCaKV56FH34B/AIcfCy8/SPgqsW0VJ/OQhEREZFJ6JJLLuGmm24CwFqLKTWo/etf/8r111/P/fffz7333ktdXV0VoxQRkapbuxJu+xwU87DoKDj3o+DFqh2VCKBKKREREZFJ56abbuL73/8+1lqmTZtWsW3lypVAlJz6yle+UoXoRERkwvCL8JProJiDg46E8z6uhJRMKEpKiYiIiEwy3/nOdwA49dRTWbduXcW2r33ta5x44olYa/nRj35UjfBERGSi8GJw7sfgkOPgXZ+EWKLaEYlUUFJKREREZJJ55plnMMZw0UUX4XmV3RgaGxv54Ac/CMArr7xShehERKTqwqD/99kHw7s+AXElpGTiUVJKREREZJIJwxCAXC437Pb169cDEItpioaIyAFn61r4xr/AxpeqHYnILikpJSIiIjLJLFu2DGstX//619myZUvf9dZa/vjHP3LddddhjOGII46oYpQiIjLutq2Hm6+CHRvg97dUOxqRXdLqeyIiIiKTzIc//GEeeeQRnn76aWbOnNm38t473/lOgiDoW43vkksuqXKkIiIybnZsgps/A70d0Dof3nlFtSMS2SVVSomIiIhMMhdccAEf/vCHsdZire273vf9vssXXHAB733ve6sVooiIjKf2LVFCqqcdps2F914D6bpqRyWyS0pKiYiIiExCX/va1/jFL37BWWedxdSpU3Fdl6amJk499VR++MMfcvPNN1c7RBERGQ8d26KEVNd2mDorSkjV1Fc7KpHdoul7IiIiIpPU2Wefzdlnnz3i9mw2SyqVGseIRERk3C2/HTq2QvMMuOizUNtY7YhEdpsqpUREREQmmYMOOoiFCxdyzz33DLv9W9/6FslkkrPOOmucIxMRkXF35qVw1KlRQqquudrRiOwRVUqJiIiITDKvvPIKxhgymcyw213XpVAo8MQTT4xzZCIiMi4KOYgno9/jCXjLZdWNR2QvKSklIiIiMsF98Ytf5L//+7+HXH/ppZdy+eWXV1xnrWXTpk3jFJmIiIy7TBfcfBUsORb+7t1QWoFVZDJSUkpERERkgrv00kv50pe+RGdnJwCmNADZtm3biPcxxnD00UePS3wiIjJOsj1wyzWw5RXo7YTjzoKahmpHJbLX1FNKREREZIKbMmUKn/70p7HWYq3tu758efBPOSH1la98pXpBi4jI6Mr1wq3XwObVUSLqomuUkJJJT0kpERERkUngIx/5CN3d3XR1dfUlpm6//Xa6u7srfnp7eykWizz22GMsW7asylGLiMioyGfhts/BxhchVQfvvQZa5lQ7KpF9pul7IiIiIpNETU0NAPfddx8Ahx9+eN91IiKynyrk4H8/B+tWQrI2Ski1zqt2VCKjQkkpERERkUnm5JNP3un2YrHIunXr+OlPf8oVV1wxTlGJiMiYWP0krFkBiTRceBXMWFDtiERGjZJSIiIiIpPQ5z//eb73ve+xceNGCoXCiLdTUkpEZJI75Dh4y2UwdTbMWlTtaERGlZJSIiIiIpPMf//3f3PllVdijKlofD6Y0TLhIiKTk1+Mpu2l66LLR51a3XhExoganYuIiIhMMjfddBMQJZ2OOeYYAFpbWznxxBNpaWkBIJFI8L//+7/VClFERPZW4MOPr4ObroSejmpHIzKmVCklMkAxtGzsLVIILfUxl2kp94D8ltlay6aMz8qOPDtyATHHsKA+zsENcVKectkiItX2/PPPY4zh05/+NFdffTXLli0jmUzywAMPkMlkOPHEE3nyySd56aWXqh2qiIjsiSCAO6+H5x8FNwbb10NtY7WjEhkzGl2KECVhntqR47ZVHdy1poffrO3hztVd/PTlbrZm/WqHN66stTyyJcvPX+nm2bY8WzMB63qKPLCxl5+s7qItF1Q7RBGRA15XVxcQrb4HcNJJJ/HUU0+Ry+VIp9N86EMfwlrLj3/842qGKSIieyIM4Gc3woqHwPHgvI/D/MOrHZXImFJSSgR4YnuOP27K0Fu0pFxDrecQcwwbeov88pVuduQOnMTUC50FHt+ewwFqPYeamENdzKXGc2jPB/xmXTfBTvqXiIjI2KutrQVg3bp1ABxzzDH4vs+DDz4I0Nf4/OWXX65OgCIismfCEP7v6/DMH8Fx4dwr4OBXVzsqkTGnpJQc8LJ+yOPbchigJubgGoMxhphjqPMcekrbDwTWWp5pyxNaS9J1KqYuOsaQdh3a8iFru4tVjFJERI488kistVx99dX86le/4vjjj8day2WXXcY111zD1VdfDUAqlapuoCIismthCL/8Fjy5HIwD7/i3aMU9kQOAklJywFvdVSAXhCTdob2jjDHEHcPL3QWyfliF6MZXIbRsy/rEneH7aHlOtMrT5syBUzkmIjIRXXbZZQD09PSwdu1aDjnkEA4++GBWrVrFZz/7WXbs2IExhte97nVVjlRERHYp0wUvPRklpN52OSw9vtoRiYwbJaXkgJcLLIaoEmg4rjEEFvKBpqyJiMjE8Pa3v53vfve7TJ06lSOOOAKAG2+8kXg8jrUWay2tra38v//3/6ocqYiI7FJtI7zvc1GF1LLXVzsakXGl1ffkgJf2HCwQWjtsYiqwFs8wbCXV/ibuGKamPDb2Fkm4Q7f7ocUYw/S0PjpERKrt4osv5vzzz++ban366afz9NNP88tf/pKGhgbOOeccpkyZUuUoRURkWNZGK+u1zIkuN02LfkQOMKqUkgPegroYKc8hO0wllLWWQmg5qD5O0tv/3y7GGJY1J3CMIReE2AENzUNryQQhzQmHuXWxKkYpIiJl8XicWKz/M3nRokVcfvnlXHzxxUyZMoV77723itGJiMiI7vshfOsj8NzD1Y5EpKr2/1G2yC4kPYfXTEthgJ5iiB9aQmvJByHdfkh9zOGYlgOnUezihjhHTU0SAj1+SK8f0l0M6PVDmuIup8+pxR1hqqOIiIytXC7Hvffey5133slTTz014u16enr4wAc+wN///d+PY3QiIrJb7r8DHvgxhD50tVU7GpGq0hwcEWBZc4KYY3h8W5bOQoi14DqwoC7OCdPTNA43l20/ZYzh+NYU8+pirGzPsz0XEHMMC+vjHNwYJ3UAVIyJiExEt9xyCx/5yEdob2/vu+64447jlltuYdGiRX3X/e53v+P9738/69atq1hFVUREJoA/3hlVSQG88X1w3JlVDUek2pSUEiFKxBzalODgxjhbMj7F0FIfd2k6gJJRAxljmFUTY1aNpumJiEwEf/jDH3jf+96HMaZiavXDDz/M2972Nh577DFisRhXXHEFN954YxUjFRGRET30C/jDD6LfT70AXveW6sYjMgEoKSUygGsMM5WIERGRCeaGG24Aol6HU6dOZdGiRaxcuZKOjg6effZZ7rrrLpYvX843v/nNvsRVXV0dX/nKV6obuIiIRB79Nfz2+9Hvb3gXvP7t1Y1HZIJQUkpERERkgnvqqacwxnDyySdz9913k0gk6Onp4bTTTuOxxx7j6quv5rnnnutLSL3uda/j1ltvZcGCBdUOXURErIVNL0e/v/4dcPK51Y1HZAJRcxgRERGRCW7btm0AXHLJJSQSCQBqa2u56KKLsNby3HPPYa3FdV2uvfZaHnjgASWkREQmCmPgzf8E534MTnlPdFlEAFVKiYiIiEx4hUIBiBJRA7W0tPT9PnXqVH72s59xwgknjGtsIiIygjUrYPYScF1wHFh6fLUjEplwVCklIiIiMsGVm5sPXk0vFuvvg/i9731PCSkRkYnimT/BTVfCnddD4Fc7GpEJS0kpERERkf3AKaecUu0QREQEYMVDcOcNYENIpMFo2C0yEk3fExEREZkktm7dytq1aysul+3YsYPt27cPuc/cuXPHJTYREQGefwx+8uUoIXXkG6JeUo6SUiIjmXBJqa1bt3LppZeyfPlyPM/jggsu4LrrrsPzhoZ6//3387GPfYxnn32WpqYmPvShD/HJT35yxH2Xm4SWhWE46vGLiIiIjJUPfOADQ64rT+mbP3/+sNt8X9NGRETGxQuPwx3/CWEAh78e3nKZElIiuzDh3iHnnXcetbW1bNy4kUcffZR77rmHG264YcjtVq5cyZlnnsmHPvQhuru7+dWvfsWXv/xlfvKTn4y472nTplX8bNq0aSyfioiIiMiostYO+dnZtoHbRURkDL30JNz+H1H/qEOPh3/4F3DcakclMuFNqEqpF198keXLl7NhwwbS6TQHHXQQV155JR/72Mf46Ec/WnHbb3zjG7z1rW/loosuAuCII47gz3/+M/X19dUIXURERGTMzJ07d0iTcxERmUCsBWNgyWvgHR+JVtwTkV2aUEmpZ599lubmZmbOnNl33dKlS1m7di0dHR00Njb2Xf/oo49y2mmn8e53v5vf//73tLS08K//+q9ceumlVYhcREREZOy88sor1Q5BRER2ZtGr4B+/ANPmgjuhhtkiE9qEmr7X3d1NTU1NxXXpdBqAnp6eiuvb2tr46le/ygUXXMDmzZv59re/zRVXXLHT6XsiIiIiIiIio2L9Kti+of/yzIXgxaoXj8gkNKGSUjU1NWQymYrrypfr6uoqrk8kErzlLW/hrLPOwvM8TjrpJC688ELuuOOOEfe/devWip8ZM2aM/pMQERERERGR/dvGl+DWa+D7n4YdG6sdjcikNaHqCg8//HB27NjBli1baG1tBWDFihXMnj2bhoaGitsuXbqUfD5fcV0QBDtt6NnS0lJx2dFKCCIiIiIiIrInNr8Mt1wN+Qy0zoe65ioHJDJ5TaiszOLFiznxxBO5/PLL6e7u5uWXX+baa6/lkksuGXLbD37wg/z85z/nBz/4AdZaHnjgAW677TYuvPDCKkQuIiIiIiIi+70ta6KEVK4HZi+B8z8N8WS1oxKZtCZUUgrgJz/5Cb7vs2DBAo477jje9KY3ceWVVwJQW1vLbbfdBsApp5zCL37xC2688UYaGhq4+OKLue666zjnnHOqGb6IiIiIiIjsj7ath1uugkwXzFwEF1wJiVS1oxKZ1CbU9D2A1tZWfvzjHw+7bXCz8zPOOIMzzjhjPMISEREROSBs3bqVSy+9lOXLl+N5HhdccAHXXXcdnjf0z8b777+fj33sYzz77LM0NTXxoQ99iE9+8pNViFpEZIy1bYKbPwO9nTB9AVx4FSRrdn0/EdmpCVcpJSIiIiJ7rr29fUi/zb1x3nnnUVtby8aNG3n00Ue55557uOGGG4bcbuXKlZx55pl86EMforu7m1/96ld8+ctf3ulKyNu2bav4CcNwn+MVERkXqTpomArT5sGFV0OqttoRiewXJlyllIiIiIjsnjvvvJNvfetbPPLII2SzWX76058Si8X4wx/+wGc+8xnq6+v3aH8vvvgiy5cvZ8OGDaTTaQ466CCuvPJKPvaxj/HRj3604rbf+MY3eOtb38pFF10EwBFHHMGf//znnT7mtGnT9vxJiohMBKnaKBnlF6Bmzz5bRWRkqpQSERERmYQuueQSzj33XO677z56e3v7ViD+61//yvXXX8+pp55Kd3f3Hu3z2Wefpbm5mZkzZ/Zdt3TpUtauXUtHR0fFbR999FHmz5/Pu9/9bqZOncqhhx7K8uXLmT59+j4/NxGRCaFzO/z1nv7LyTTUNlYtHJH9kZJSIiIiIpPMTTfdxPe//32stUOqj1auXAlEyamvfOUre7Tf7u5uamoqe6Sk02lgaG/PtrY2vvrVr3LBBRewefNmvv3tb3PFFVfsdPqeiMik0d0W9ZD6xTfg8d9VOxqR/ZaSUiIiIiKTzHe+8x0ATj31VNatW1ex7Wtf+xonnngi1lp+9KMf7dF+a2pqyGQyFdeVL9fV1VVcn0gkeMtb3sJZZ52F53mcdNJJXHjhhdxxxx17+nRERCaWno4oIdW2CRqnwcKjqh2RyH5LSSkRERGRSeaZZ57BGMNFF100ZFW8xsZGPvjBDwLwyiuv7NF+Dz/8cHbs2MGWLVv6rluxYgWzZ8+moaGh4rZLly4d0lg9CIK+aYTD2bp1a8XPjBkz9ig+EZEx19sFt1wF2zdA/RS46LPQ2FLtqET2W0pKiYiIiEwy5VXrcrncsNvXr18PQCwW26P9Ll68mBNPPJHLL7+c7u5uXn75Za699louueSSIbf94Ac/yM9//nN+8IMfYK3lgQce4LbbbuPCCy8ccf8tLS0VP46jP0VFZALJdMOtV8PWtVDbBBddC02t1Y5KZL+mvwREREREJplly5ZhreXrX/96RVWTtZY//vGPXHfddRhjOOKII/Z43z/5yU/wfZ8FCxZw3HHH8aY3vYkrr7wSgNraWm677TYATjnlFH7xi19w44030tDQwMUXX8x1113HOeecMzpPUkRkPPlFuPUa2Pwy1DRGFVJTVM0pMta8Xd9ERERERCaSD3/4wzzyyCM8/fTTzJw5E2MMAO985zv7ptAZY4atcNqV1tZWfvzjHw+7bXCz8zPOOIMzzjhjz5+AiMhE48XgsNdB5zZ479XQMrvaEYkcEFQpJSIiIjLJXHDBBXz4wx/GWlvRw8n3/b7LF1xwAe9973urFaKIyORz4tvgw1+D1nnVjkTkgKGklIiIiMgk9LWvfY1f/OIXnHXWWUydOhXXdWlqauLUU0/lhz/8ITfffHO1QxQRmdgKefjt9yE3YNXRmvrqxSNyANL0PREREZFJ6uyzz+bss8+udhgiIpNPsQC3fxFWPwlb1sCFV0FpKrSIjB9VSomIiIhMMgcddBCf//zn2bBhQ7VDERGZfPwi/Og/ooRULAlvOE8JKZEqUVJKREREZJJ55ZVX+MxnPsP8+fM566yz+NnPfkYQBNUOS0Rk4vOLcMeX4MW/gheH8z8Fcw+tdlQiB6x9TkqtX7+ez33uc5x55pkceeSR/OEPf+DJJ5/kl7/85WjEJyIiIiKDxGIxrLUEQcBvfvMb3vGOdzBr1iw+/vGPs2rVqmqHJyIyMQU+3Hk9rHosSki951Mw//BqRyVyQNunpNTNN9/MkiVLuOqqq/jNb37DM888Q29vL/fddx9vectbuPTSS0crThEREREp2bJlC9/85jc5/vjj+1bg27p1K9dddx2HHnooJ510ErfccgvZbLbaoYqITBx3fxeeexhcD971CTjoiGpHJHLA2+uk1J/+9CcuueQSstlsxVLEACtWrMBay3e/+12t/CIiIiIyyhobG/ngBz/Igw8+yIsvvsiVV17JwoUL+xJUDz74IBdffDEzZ86sdqgiIhPHa86A+qlw7sdg0VHVjkZE2Iek1H/8x38QhiGLFy/mqaeeqth20UUXMWfOHKy1fPvb397nIEVERERkeAcddBDXXHMNL7zwAjfffDNTpkwBwFpLV1dXlaMTEZlAps2Ff/4GLDm22pGISMleJ6UeeughjDFcfvnlHH545TzcE044gU9/+tMArFy5ct8iFBEREZERrVmzhi984QssXbqU973vfbS1tfVVsTc0NFQ5OhGRKrIWfvM9ePnp/uti8erFIyJDeHt7x56eHmDXf+wUCoW9fQgRERERGUZnZyc//vGPufXWW3nwwQf7klDlf48//nguvfRSzj333GqGKSJSPdZGPaQe/RU8/nv4l29BbWO1oxKRQfY6KbVgwQJWrVrFHXfcwXve856KbZ2dnXz9618HopJyERERERk906dP7/vir5yIampq4sILL+TSSy9l6dKl1QxPRKS6rIXf3RQlpADOfL8SUiIT1F5P33vPe96DtZa77rqLww47rO/6z3zmMyxatIinn34aYwzvfOc7RyVQEREREYnk8/m+puYnnXQSt956Kxs3buQrX/mKElIicmCzFv5wGzz0i+jy2f8ER51S3ZhEZER7XSn10Y9+lF/96lc8+uijrFy5EmMMAE8//XTfN3bLli3j3/7t30YnUhEREREBYOrUqVx00UW8//3v5+CDD652OCIiE8f9d8Cf7ox+P/P9cMwbqxuPiOzUXldKJZNJ7rvvPj7ykY9QX1/f922dtZZ0Os0HPvABli9fTjqdHs14RURERA54GzZs4Etf+pISUiIiAz37Z1h+e/T76RfDa86sbjwiskt7XSn1wAMPcPTRR3Pdddfxn//5nzz//PO0t7dTV1fHIYccQiwWG804RURERA5Yv/hFNA3luOOOo7W1lbvvvnu373vOOeeMVVgiIhPLIa+BpcfDzMVwvD77RCaDvU5KnXfeeXR1dXHllVfyiU98gkMPPXQ04xIRERGRkre+9a0YY/jZz37GOeec03d5V4wx+L4/DhGKiEwArgfvuAKcvZ4QJCLjbK/fre3t7eRyOWbOnDma8YiIiIjIbhjYOmFnPyIi+7XHfgO//C8Iw+iyElIik8peV0q97nWv4/7772fVqlWjGY+IiIiIDPLe974XYwxz586tuCwickB7/Pfwq29Hvx90ZDR1T0Qmlb1OSn3pS1/i7W9/O1/84hd55plneMMb3sC0adNIp9M4g7LT6mUgIiIisvduuummnV4WETng/O1euOtb0e+vfTMc+trqxiMie2Wvk1Kvec1rgKh0/K677uKuu+4a9nbqZSAiIiIyum655RYATjnlFGbPnj1k+2OPPcY999zD9OnTufjii8c7PBGRsfXUA/DzrwMWjj0jWmlP1aMik9JeJ6UG9ihQvwIRERGR8fO+972vr/H5cEmp5557jk996lMcdNBBSkqJyP7l2QfhZzcCFl79Rjjj/6eElMgkttdJqYsuumg04xARERGREdx3332sW7duyPX33nsvHR0dFddZa7njjjsA2Lhx43iEJyIyPrrb4WdfBRvCq06Bsz6gxuYik9xeJ6W+//3vj2YcIiIiIjKCTCbTVx0F9P37ta99bcT7GGOGraISEZm06prgbZfDqr/AOR9SQkpkPzBq7+IXXniBRx55hNWrV4/WLkVEREQEOOusszj11FOx1g5pobCzn3e9611VjFpEZJSEQf/vS4+Ht/4zOG714hGRUbPXlVJl//Vf/8XnPvc5Nm3a1Hfd3LlzufrqqzXFT0RERGSUfO1rX+O73/0uAF/+8pcxxvCWt7yFRYsWVdzOcRzS6TTHHHMMZ511VjVCFREZPaufgrv/B87/NDROq3Y0IjLK9ikp9c///M9885vfBCqbna9Zs4Z//Md/5JlnnuFLX/rSvkUoIiIiIhxyyCF9f1c99thjGGP46Ec/yute97oqRyYiMkbWrIAffgGKefjjnfDmf6p2RCIyyvY6KfXLX/6Sb3zjG32XjzzySGbNmsX69et56qmnsNZy/fXXc9ppp3H66aePSrAiIiIiAsuXL692CCIiY2vdSrjt2ighteioaJU9Ednv7HVSqpyQqq+v59e//nXFt3QPPvggZ511Ft3d3dx4440HbFKqu7ubnp6eiuuSySRNTU34vs+2bduG3GfGjBkAbN++nWKxWLGtsbGRVCpFb28vXV1dFdvi8ThTpkwhDEO2bNkyZL/Tpk3DdV3a2trI5/MV2+rq6qitrSWbzQ5ZwcfzPFpaWgAqpmiWTZ06lVgsRkdHB9lstmJbTU0N9fX15PN52traKrY5jkNraysAW7ZsIQzDiu3Nzc0kEgm6urro7e2t2JZKpWhsbKRYLLJ9+/YhMZWP4bZt2/B9v2Jb+Rj29PTQ3d1dsS2RSNDc3EwQBGzdunXIfltbW3Echx07dlAoFCq21dfXU1NTM+wxjMViTJ06FRj+GLa0tOB5Hu3t7eRyuYpttbW11NXVDXsMXddl2rSohHm4YzhlyhTi8fiwxzCdTtPQ0DDsMTTGMH36dGD4Y9jU1EQymRz2GJbP75GO4fTp0zHGDHsMGxoaSKfTZDIZOjs7K7aVz29rLZs3bx6y3/L5PdwxLJ/fuVyO9vb2im0Dz+/NmzdXVHxC//nd2dlJJpOp2FY+vwuFAjt27KjYNvD83rp1K0EQVGwvn9/6jNBnBOgzovwcZOe++tWvAvDmN7+ZBQsW9F3eHf/f//f/jVVYIiJjY8ML8INroZCDBUfAeR8HL1btqERkDOx1UqpcNn7FFVcMKRs/4YQTuOKKK/jMZz7Do48+us9BTlaPP/44999/f8V1y5Yt421vextdXV185zvfGXKfq666CoD/+7//Y/369RXb/uEf/oEjjjiCZ599lrvvvrti28KFC7ngggsoFovD7veKK66gpqaG3/72t6xatapi2xvf+EaOP/54Vq9ezU9+8pOKbdOnT+cDH/gAAN/97neHDK7/6Z/+iWnTpvHAAw/wxBNPVGw74YQTOO2009i0aRM333xzxba6ujo+8pGPAHDbbbcNGbhcdNFFzJ8/n0cffZQHH3ywYttRRx3FOeecQ3t7+5Dn6roun/70pwH46U9/OiSB8Y53vIPDDjuMp59+mt/97ncV2w4++GDe/e53k8vlhj2Gn/jEJ0gkEtx999289NJLFdvOOOMMXvOa1/DCCy/ws5/9rGLb7NmzueSSSwCG3e8///M/09zczH333cfTTz9dse3kk0/mDW94A+vWreO2226r2NbU1NQ30LjllluGJE3+8R//kTlz5vDQQw/x8MMPV2wr9xnZvn37kJji8Tif/OQnAfjxj388JDHyrne9iyVLlvDEE09w7733VmxbunQp73znO+nt7R32uX7qU5/C8zzuuusu1qxZU7HtzW9+M0cffTQrV67krrvuqtg2b9483ve+9xEEwbD7/dd//Vfq6+u55557WLFiRcW2U045hde//vWsWbOG22+/vWJbS0sLH/rQh4BoRdHBiYRLL72UGTNm8Kc//Ym//OUvFdte+9rXcvrpp7Nlyxa+973vVWxLp9N89KMfBeD2228fkgw7//zzWbRokT4j9BkB6DOi/Bxk5y6//HKMMcyfP58FCxb0Xd4dSkqJyKSyaTXceg3kMzDvMHj3v0MsUe2oRGSMGDu4NGA3pdNp8vk8N998MxdccMGQ7bfeeisXXXQRyWRyyB/CE8Xs2bPZsGFD37TD0aYqCFVBgKogBlKlVESVUhF9RkQO9M+IsaqUGuv/48eb4zgYY/jZz37GOeecg7Oby6AbY4Z8Bk0ko/o6fXcRdLy089s0LoRLXty3xxGRsWMtfP/TsHYFzDkELvgMJFLVjkpE9sLu/h+/10mpxYsXs3r1as477zz+93//d8j2d73rXdxxxx0sXryY559/fm8eYsztb3+wioiISGR/+z/+mmuuAeDd7343Bx98cN/l3VGusJyIlJQSkSF6OuCeW+FNl0AyXe1oRGQv7e7/8Xs9fe+MM87g61//Oj/60Y+or6/nAx/4ALNmzWLDhg3813/9F3fccQfGGM4888y9fQgRERERYWhiaSInmkRE9lghB/Fk9HttI7z1n6sajoiMn92r/R7GRz7yEerr6wH47//+b4455hhmzJjBMcccw//8z/8A0dSMf/mXfxmdSEVERERklwZPqRQRmdB2bIKv/zP89Z5qRyIiVbDXSan58+dzxx130NTUhLV2yE9NTQ233nor8+fPH8VwRURERASgp6eH66+/vq931yuvvMIJJ5xAKpViwYIF/OpXv6pyhCIiu9C+FW7+DHRth4fvAr+46/uIyH5lr6fvQbQi0zPPPMO3vvUt7r33XrZv305raysnnHAC73//+5WQEhERERkDO3bs4JRTTuGZZ57hhBNO4LjjjuP888/noYceAmDNmjW87W1v46GHHuLoo4+ucrQiIsPo3A43XxklpKbMgguvBi9W7ahEZJztU1IKotW0rrnmmj1quCkiIiIie+/aa6/l6aefxhjDypUrSaVSPPTQQxhjqK2tpbu7G9/3+fKXv8xtt91W7XBFRCp17YCbroSOrdA8Ay76LNQ1VTsqEamCvZ6+V7Z69Wr+8pe/VFz3pS99iWeffXZfdy0iIiIiw7j77rsxxnDsscdy1llncffddwMwd+5cduzYwfve9z6stfzpT3+qcqQiIoN0t8PNV0H7ZmhsjRJS9c3VjkpEqmSfklJf/OIXWbJkCd/73vf6rvN9n0996lMceeSR/Od//uc+BygiIiIildatWwfABz/4QaZOncqDDz6IMYbTTjsNz/P4+7//ewC2bNlSzTBFRIZ6+gHYsQHqp0YJqYap1Y5IRKpor6fv/fznP+dTn/oUAH/729/6rn/xxRf7Vn355Cc/ybJlyzjjjDP2LUoRERER6RMEAQDpdBprLX/+858BOP744wEoFAoA1NbWVidAEZGRHH8OhCEsfS00Tat2NCJSZXtdKfW1r30NgIaGBi6++OK+6+fOncu3v/1tGhsbsdbyla98ZZ+DFBEREZF+06dPB+CRRx7hvvvuo62tDYBTTjmFYrHITTfdBER/l4mIVF22F4pRshxj4MR/iHpJicgBb6+TUitWrMAYw6c+9Sne//73912fTqd5//vfz7//+78DqLeUiIiIyCg78cQT+778O/300zHGcOSRRzJ//nzOOecc7r//fowxvPWtb612qCJyoMv1wq1Xww+/AIV8taMRkQlmr5NSHR0dALS2tg67vaWlBYiWLBYRERGR0XPllVdSV1eHtZYgCLDW9q2EXK6imj9/Ppdddlk1wxSRA10+C7d9Dja+CJtWQ9f2akckIhPMXielZs2aBcAdd9wxZJu1lltuuQWAGTNUlikiIiIymg455BAefvhhPvjBD3LBBRdw99138+Y3vxmAww47jLPPPpvly5fT3KwVrUSkSgo5+N/PwbqVkKyB914NU2dVOyoRmWD2utH5GWecwTe+8Q1+/etfc9RRR3HGGWcwdepUduzYwa9+9SueeuopjDGceeaZoxmviIiIiACHHnoo3/zmN4dc/2//9m9cccUVVYhIRKSkmIcffhHWrIBEGi68CmYcVO2oRGQC2uuk1L//+79zxx13sG3bNp566imeeuqpIbdpaWnp6y0lIiIiIqPv97//PcuXL6etrY2WlhZOOeUU3vCGN1Q7LBE5UBULcPt/wMtPQTwJF1wJsxZXOyoRmaD2Oik1Y8YM7r33Xi644AKefPLJIdtf9apX8YMf/ICZM2fuU4AiIiIiMtSGDRt45zvfySOPPFJx/ec//3lOOukkbr/99hF7f4qIjJm2TbD+eYgl4PwrYc4h1Y5IRCawvU5KQdSz4IknnuCRRx7hL3/5Cx0dHTQ2NnLMMcdw3HHHjVaMIiIiIjJAT08Pp512GqtWrcJaO2T7Aw88wBvf+EYefvhhUqlUFSIUkQNW6zx47zVRT6l5S6sdjYhMcHvd6Lxsy5YtHHvssXz4wx/mU5/6FPF4nG984xtcc801dHZ2jkaMIiIiIjLAV77yFZ5//nkg+pLwhhtu4I477uD6669n6dKlWGt55plnuPHGG6scqYgcEIIAtm/ovzxrESw4vHrxiMiksU+VUtdccw1f/OIXefLJJ1myZAkf/ehHuf766/u233HHHTz88MPU1dXtc6AiIiIiEvnJT34CwLHHHsuf/vQnPK//T7rLLruME044gccee4zbb7+dT3ziE9UKU0QOBGEAP/8qrPpL1NB89sHVjkhEJpG9rpT63ve+xzXXXPP/Z+++w6Oo9j+Of3bTKyGEhECo0gXlKggoIIgCggWliwgKNmzx2gsCol7FgpWrWOhIFeQqlotSLCggihcQBUXphJZGSNs9vz/y2zFLEkgg2Ul5v55nn+yeOTvznZns7tnvnjlHOTk5+uWXX3TkyBG9/vrrkiRjjIwx2rp1q1544YVSCxYAAADS9u3b5XA4NGrUKK+ElCT5+/tr1KhRVj0AKDNut7R0svS/1Xkz7qUn2x0RgArmtJNS7777riQpIiJCNWrU0Mcff6ysrCyFhIRo7ty5Ouecc2SM0YcfflhqwQIAAEAKDAyUJGVlZRW6PDs7W5IUFBTks5gAVDFut/TRm9JPX0oOp9T/Pqn5BXZHBaCCOe2k1JYtW+RwOPTII4+oc+fOWrVqlSTpkksu0cCBA3X77bdLkn7//ffSiRQAAACSpGbNmskYo9dee01paWley1JTU/Xqq6/K4XCoRYsWNkUIoFIzRvrkHWnDf/MSUtcmSi072h0VgArotMeUSk9PlyQ1btxYkvTtt9/K4XDowgsvlCRVr15dkuR2u880RgAAAOQzdOhQff/999q2bZuaNGmiQYMGqU6dOtqzZ4/mzZunpKQkORwOXXfddXaHCqCyMUb6bKq07hNJDunqO6XWne2OCkAFddpJqYiICKWkpGj//v3as2ePtm7dKofDoS5dukiS1q1bJ0mqU6dO6UQKAAAASdJtt92mWbNmae3atTp48KA1rmd+bdq00a233mpDdAAqNVeulLQz7/5Vo6U23eyNB0CFdtqX751zzjmSpOeee06DBg2SJEVHR6tDhw569tln9fLLL8vhcKht27alEykAAAAk5Q1m/vnnn2vw4MGS/p5kxnPr3bu3PvvsM/n5+dkcKYBKxz9AGvKINORR6bxL7Y4GQAV32j2lRo0apdWrV2vPnj3as2ePHA6HRo4cKafTqbVr18rlcsnpdOree+8tzXgBAAAgKTIyUnPmzNHTTz+tL7/8UocOHVJcXJwuuugiNWnSxO7wAFQ2OzZJDc6WHA4pIEhq1s7uiABUAqedlLr++uu1Y8cOTZw4UcePH9eAAQP05JNPSpKaN2+uwMBATZkyRe3a8WYFAABQVho2bKiRI0faHQaAyuzrD6TlM6WLrpEuHZaXmAKAUnDaSSlJGjNmjB577DG5XC4FBARY5TfccIPuvvtu1apV64wDBAAAQJ7NmzfrP//5j3bt2qVq1arpkksu0aWXcvkMgDK0ZmleQkqSgsNISAEoVWeUlJIkp9Mpp9N7aKrmzZuf6WoBAACQz0MPPaQXX3xRxhir7LnnnlOvXr20aNEiBQcH2xgdgEpp7bK8mfYkqetgqXM/e+MBUOmc9kDnAAAA8I2ZM2fq+eefl9vtLjCo+aeffqp//vOfdocIoLJZ/7m07O28+537SRcPtDceAJUSSSkAAIBybvLkyZIkh8Ohdu3a6cEHH1S/fv3kcDhkjNHUqVOVkZFhc5QAKo0fv5A++nfe/Quvli4ZymV7AMrEGV++BwAAgLK1bds2ORwOXXLJJfr888/l+P8vh5MmTdJ9992n7Oxs/fbbb2rTpo29gQKoHIyR5JDa95YuG05CCkCZoacUAABAOZeeni5Juu6666yElCQNHTrUun/48GGfxwWgkjrvUmnkM1KvkSSkAJQpklIAAADlXE5OjiQpKirKqzwmJsa6n5mZ6cuQAFQ223+U0pP/fly3OQkpAGWOpBQAAEA555lxz8/Pz6s8/wzILpfLpzEBqER+XSfNeUaa/oSUkWp3NACqEMaUAgAAqCA2bdpUoLfUqZZ16dKlbIMCULFt2yDNnyi5c6W4+lJwmN0RAahCSEoBAABUEGPGjClQ5hljqqhlubm5ZR4XgArq943S3GclV67UoqN0zT2S0+/UzwOAUkJSCgAAoILwXMYHAGfsz03S+89IrhypWTup372SH18PAfgW7zoAAADlXJcuXbxm3QOAM7JrqzT7aSk3W2p8njTgAck/wO6oAFRB5S4plZSUpFtuuUUrV66Uv7+/rr/+er3wwgvy9y861E2bNumCCy7QsmXL1LVrV98FCwAA4AMrV660OwQAlUl4tBQWKUU3kwY9REIKgG3KXVJq0KBBqlOnjvbu3av9+/frqquu0qRJk/TAAw8UWj8jI0NDhgzR8ePHT7nugwcPej12u92lEjMAAAAAVBjVY6WbnpGCw6WAQLujAVCFlauk1Pbt27Vy5Urt2bNHoaGhatSokcaMGaMHH3ywyKTU6NGjdc0112jTpk2nXH9sbGxphwwAAAAA5d/+HVLyQan5BXmPI2vYGw8ASHLaHUB+mzdvVnR0tGrXrm2VtWzZUjt37lRycnKB+jNmzND27ds1duxYH0YJAAAAABVI0k5pxjhp/kRp+492RwMAlnLVUyotLU1hYWFeZaGhoZKk9PR0RUVFWeVbt27VY489pm+++UZ+fkxbCgAAAAAFHNwtTR8rZaRKtRtLdZraHREAWMpVT6mwsDBlZGR4lXkeR0REWGWZmZkaNGiQXn75ZdWrV8+nMQIAAABAhXB4rzT9CelYslSroXT9E1JI2CmfBgC+Uq6SUq1atdLhw4d14MABq2zLli1KSEhQtWrVrLJ169bpt99+08iRIxUVFWX1oLriiis0evToIteflJTkdYuPjy+zfQEAAAAA2xw9kJeQSj8qxdaTho2TQiNO+TQA8KVydflekyZN1KlTJyUmJmrKlCk6dOiQJkyYoJEjR3rV69y5c4HZ9hwOhz766CN17dq1yPXXrFnT67HTWa5ycgAAAKclKSlJe/bsUYMGDVS9enW7wwFgt/RkadoYKfWwFJMg3TBeCou0OyoAKKDcZWUWLlyo3NxcNWzYUO3bt1evXr00ZswYSVJ4eLhmz55tc4QAAAD2c7vdevHFF9W4cWPFx8erbdu2+uqrr7Rw4UL1799fu3fvtjtEAHYJjZQa/0OKjpeGj5fCo+yOCAAKVa56SklSXFycFixYUOiy9PT0Ip9njCmrkFCJGWOUm5srSfL395fD4bA5IgAATi03N1dXXHGF/vvf/1ptIM9n2KZNm/TBBx/oxx9/1Jo1axQbG2tnqADs4HRKV9wmHU/LS1ABQDlV7npKAb5gjFFqaqp27typP/74Q3/88Yd27NihI0eOyO122x0eAAAn9frrr+vzzz+XMUbnn3++17Jdu3ZJkv78809NnDjRjvAA2CE9WfrvDMmV94OrHA4SUgDKPZJSqJKOHDmiffv26fjx43I4HHI4HMrOzlZSUpL27dtHzzsAQLk2Y8YMORwODRgwQOvWrfNaNmXKFF111VUyxug///mPTREC8KljqdKMsdI3i6VP3rU7GgAoNpJSqHKysrJ06NAhSXmX7DmdTjmdTut+WlqaUlNTbY4SAICi/frrr5Kkvn37Fljm5+enwYMHS/q71xSASiwjTZo5TkraKYVXlzpeaXdEAFBsJKVQ5aSmpsoYU+jsi06nU8YYpaSk2BAZAADF4++fNyzo4cOHC13+yy+/SJLCwsJ8FhMAG2Qek2Y9Ke3fIYVVk4Y/KdWobXdUAFBsJKVQ5WRnZ8sYU+Sg5k6nU9nZ2T6OCgCA4mvbtq2MMXrxxRf1/fffW+WHDh3SzJkz9dJLL8nhcBQYb6o4kpKS1LdvX0VFRSkmJkaJiYnWpCBF2bRpk0JDQ7Vy5coSbw/Aaco6npeQ2rs9b+yoG8ZLNRPsjgoASoSkFKqcwnpI5VdULyoAAMqL+++/X5K0c+dOXXjhhdYPLTfffLNGjBihY8eOSZLuuOOOEq970KBBCg8P1969e7V27VotX75ckyZNKrJ+RkaGhgwZouPHj59y3QcPHvS6MbkIcJqMkeZPlHb/JgWHSzeMk+Lq2x0VAJQY37xR5YSHh8vhcBTaEDbGyBijyEhmKgEAlF+XX365nn/+eTkcDuuzS5LX/ccff1xXXlmysWW2b9+ulStXauLEiQoNDVWjRo00ZswYvf7660U+Z/To0brmmmuKtf7Y2Fiv2759+0oUH4D/53BIF10jRUTnJaRqNbQ7IgA4Lf52BwD4WlhYmEJCQpSRkSFJ1ux7brdbLpdLAQEBqlatms1RAgBwcvfdd58uu+wyvf3221q7dq2OHj2qiIgInXfeeRo1apTat29f4nVu3rxZ0dHRql377zFpWrZsqZ07dyo5OVlRUVFe9WfMmKHt27fr3Xff1YQJE850lwCURKNzpLv/LQUE2h0JAJw2klKocpxOp+rUqaN9+/YpIyPDq8dUUFCQateurYCAABsjBACgeM455xy99tprpba+tLS0AoOjh4aGSpLS09O9klJbt27VY489pm+++UZ+fn6lFgOAIuTmSB+9KV3YV4qtm1dGQgpABUdSClWSv7+/EhISlJmZafWYCgoKUlhYWJEDoAMAUNmFhYVZn4senscRERFWWWZmpgYNGqSXX35Z9erV82mMQJXkypUWvCD9ulb6c5N05+uSPz+iAqj4GFMKVZbD4VBISIhq1KihGjVqWGNNAQBQ3vn5+RXr5u9fst8fW7VqpcOHD+vAgQNW2ZYtW5SQkOB1afu6dev022+/aeTIkYqKirJ6UF1xxRUaPXp0ketPSkryusXHx5dsx4GqyOWSFr2Ul5DyD5SuuoOEFIBKg55SAAAAFYwxxhrkvDQ1adJEnTp1UmJioqZMmaJDhw5pwoQJGjlypFe9zp07F5htz+Fw6KOPPlLXrl2LXH/NmjW9HjPbLXAKbpe0+BVpyxrJz18a9FDeWFIAUEnQEgAAAKhgoqOjFR0dbfX2rVGjhqpVq2aN7eRwOHTeeeepR48eJV73woULlZubq4YNG6p9+/bq1auXxowZIylvBtvZs2eX6r4AKILbLX34urTpK8npJw18UGpynt1RAUCpoqcUAABABXPo0KFCy40x+uGHHzRkyBAlJyfrv//9b4nXHRcXpwULFhS6LD09vcjnlXavLaDK+2axtHGl5HBK/e+TmrWzOyIAKHX0lAIAAKgkHA6H2rZtq4kTJ+qPP/7QuHHj7A4JwOlq10uq11Lqd6/UsqPd0QBAmSApBQAAUMl4BhD/4IMPbI4EwGkLDpNGTJBadbI7EgAoM1y+BwAAUMGkpqYWKDPGKCcnR3v27NFDDz0kSTpy5IivQwNwuoyR/jtdCqsmXXRNXhmTAQCo5EhKAQAAVDBRUVFyOBwnreNwONSyZUsfRQTgjBgjfTFb+vbDvMeNzpXiG9kbEwD4AEkpAACACupUg4s/+uijPooEwBlZNV/6elHe/ctHkZACUGWQlAIAAKhg6tWrV2hPKYfDobCwMDVp0kS33HKLevXqZUN0AEpk9UJp5dy8+z1GSO372BoOAPgSSSkAAIAKZseOHae8fA9ABfDNEunL2Xn3u18vXXi1reEAgK8xch4AAEAF06FDB91www1avXq13aEAOF17f88b2FySug6WOvezNx4AsAE9pQAAACqYn3/+WevXr1fLli3VpUsXu8MBcDpqnyX1vFHKSJMuHmh3NABgC5JSAAAAFUxsbKx2796tuLg4u0MBUFJul+T0y7vf8Sp7YwEAm3H5HgAAQAXz4osvys/PT+PHj9eHH36o5ORku0MCUBwbV0pTH5eOH7M7EgAoF+gpBQAAUMG8++67io2N1c6dO3XttddKkvz9/RUSEiKn8+/fHB0Ohw4fPmxXmADy+99X0pLXJOOWNnwuXXSN3REBgO1ISgEAAFQwn332mRwOhzUDnzFGOTk5ysnJ8Spjhj6gnNiyRvrg5byE1HmXSR2ZZQ8AJJJSAAAAFZIxpkTlAGyyda208MW8hFSbS6QrbpOcjKICABJJKQAAgHJvxowZkqRLLrlECQkJcrvdNkcEoFh++0Ga/3ze4Oatu0hXjSYhBQD5kJQCAAAo50aMGCGHw6HFixcrISHB7nAAFEdujvTxW5I7V2p5odT37r9n3QMASCIpBQAAAAClzz9AGjZWWrNU6n2z5EdCCgBORFIKAAAUi8vlUlZWlowxCgoKkr8/zQgAKCA7SwoMyrsfU0e68nZ74wGAcozWJAAAOCm3260jR44oOTlZubm5kiSn06nIyEjVrFlTfvz6DwB5dm2V5j4rXZsondXG7mgAoNwjKQUAAIpkjNGBAweUkpIiSVYCyu126+jRo8rOzlZCQoKcDNzrE7fccosSExOLXd/hcOj3338vu4AA/G3PdmnWBCkrQ/ruI6nRuZLDYXdUAFCukZQCAABFOn78uFJTU+VwOLx6RPn5+cnhcCgjI0OpqamKioqyL8gq5ODBg8Wua4yRgy/EgG/s+0OaOS4vIVWvpTTgfhJSAFAM/KwJAACKlJqaKrfbXWhPKE+ZpxcVyp4xptg3AD5y4C9pxjgp85iU0Ewa+rgUGGx3VABQIdBTCkCllJubq5SUFKWlpcntdis4OFjVqlVTaGgoPQeAEsjJyZGkIl83DofDqoOyN2XKFF122WV2hwHA4+AuafoT0vE0qXZj6foxUlCI3VEBQIVBUgpApZOZmandu3crJyfH+iKdnZ2ttLQ0RUVFKTY2lsQUUEz+/v4nfb0YY5iFz4diY2NVv359u8MA4PH9MikjVarVSBo2VgoOszsiAKhQaEUCqFTcbrf27t2rnJycAl+mXS6Xjh49avWaAnBqkZGRSklJKfQSPs8lYryeAFRZl4+SQsKljlfm/QUAlAhjSgGoVNLT05WdnV1o7w7PIM3JycmMtwIUU2hoqMLDw+VyueRyuazxilwul3JzcxUcHKzIyEi7wwQA30lPltzuvPt+flL3oVIo74MAcDroKQWgUsnMzJR08vFvsrKy5Ha7vWYSA1A4h8Oh2rVr6+DBg0pJSZHL5bLKIyMjFRcXx2vJB8aOHStJat68uc2RAFVcyiFp6uNSw1bSlbdLTt7/AOBMkJQCUCUxphRQfE6nU3FxcapRo4aOHz8uY4yCg4MVGBhod2hVhicpBcBGqUfyBjVPPiD96ZCOH5PC6CEFAGeCpBSASiUkJG/Gm6KmsHe73QoLCyt0GYCT8/f3V0REhN1hAIDvpSfnJaSO7JOiYqXhT5KQAoBSwLcyAJVKeHi4goKCrLFvPDxj4DidTlWvXt3GCAEAQIVyLCUvIXV4jxQZk5eQiqppd1QAUCmQlAJQqXjGv/EkpnJzc5Wbm2uNgxMTE6PwcGbHAQAAxZCRKs0YJx3cJUVE5yWkqsfZHRUAVBpcvgeg0gkKClL9+vWVlpamtLQ0GWMUFBSkatWqKTg42O7wAABARbH3j7yEVFhUXkKqRrzdEQFApUJSCkCl5Ofnp6ioKEVFRdkdCgAAqKgat5EGP5w3jlRMHbujAYBKh6QUAAAAAHhkHZcyj0nVYvIeN21rbzwAUIkxphQAAAAASFJ2ljTnaem9R6Uj++2OBgAqPZJSAAAAAJCTJc39l/TX5ryeUsfT7I4IACo9klIAAAAAqrbcHGnec9IfG6XAYGnoGKlOE7ujAoBKj6QUAAAAgKorN0ea/7y0/UcpIEi67nGpXnO7owKAKoGkFAAAAICqyZUrLXxR+m2d5B8oDXlUanC23VEBQJVBUgoAAABA1ZSVIR3ZJ/n5S4MfkRqdY3dEAFCl+NsdAAAAAADYIjRSGj5BSvpLatja7mgAoMqhpxQAAACAqsPtlv7c/PfjsEgSUgBgE5JSAAAAAKoGt1v66E1p2uPS+s/sjgYAqjySUgAAAAAqP2OkT96RNvxXkkMKDLE7IgCo8khKAQAAAKjcjJE+myqt+0SSQ+p7p3ROF7ujAoAqj6QUAAAAgMrLGGn5TOm7/+Q9vvI2qc0l9sYEAJBEUgoAAABAZbbifembxXn3e98ind/D3ngAABaSUgAAAAAqJ2Mk48673/Mm6YLL7Y0HAODF3+4AAAAAAKBMOBzSJUOlJm2les3tjgYAcAJ6SgEAAACoXLaskbKz8u47HCSkAKCcIikFAAAAoPJYu0yaP1Ga85SUm2N3NACAkyApBQAAAKBy+OFzadnbefcTmkl+jFYCAOUZSSkAAAAAFd9PX0r/eTPvfserpe5D8y7dAwCUWySlAAAAAFRsP6+WlrwuyUgX9JF6DCchBQAVAEkpAAAAABXXljXS4lckGaltT+nykSSkAKCC4CJrAAAAABVXtZpSUIjUooPU+xYSUgBQgZCUAgAAAFBx1Wks3fKCFFVTcnIhCABUJLxrAwAAAKhYtv8k7f7t78fRtSSnn23hAABOD0kpAAAAABXHHz9Lc/8lzRgnHfjL7mgAAGeApBQAAACAiuHPzdL7z0i52VKDVlKN2nZHBAA4AySlAAAAAJR/O7dKs5+ScrKkxv+QBj4g+QfYHRUA4AyQlAIAAABQvu3+TZo9QcrJlBqdKw16iIQUAFQCJKUAAAAAlF9Ju6RZT0pZGVL9s6XBj0gBQXZHBQAoBf52BwAAAAAARaoeJyU0y0tKXfeYFEhCCgAqC5JSAAAAAMqvgEBp8MNSbo4UFGJ3NACAUsTlewAAAADKl0N7pNULJGPyHvsHSMGh9sYEACh15S4plZSUpL59+yoqKkoxMTFKTExUbm5uoXXffPNNNWvWTBEREWratKkmT57s42gBAAAAlKrD+6TpT0hfzpHWLLU7GgBAGSp3SalBgwYpPDxce/fu1dq1a7V8+XJNmjSpQL0lS5bokUce0fTp05Wamqrp06frscce06JFi4pc98GDB71ubre7LHcFAAAAQEkcPZCXkEo7IsXWk87tZndEAIAyVK6SUtu3b9fKlSs1ceJEhYaGqlGjRhozZoxef/31AnX37t2rhx9+WB06dJDD4VDHjh3VrVs3rV69usj1x8bGet327dtXlrsDAAAAoLiSD+YlpFIPSTF1pBvGS2GRdkcFAChD5Wqg882bNys6Olq1a9e2ylq2bKmdO3cqOTlZUVFRVvno0aO9npuUlKTVq1frpZde8lW4AAAAAEpD6uG8hFRykhQdLw1/UgqPsjsqAEAZK1c9pdLS0hQWFuZVFhqaN6Bhenp6kc/bv3+/Lr/8cp1//vm67rrryjRGAAAAAKUoN0eaMVY6ul+qHpeXkIqItjsqAIAPlKukVFhYmDIyMrzKPI8jIiIKfc53332ndu3aqVmzZlq6dKn8/ctV5y8AAAAAJ+MfIHW69u+EVLUYuyMCAPhIuUpKtWrVSocPH9aBAwessi1btighIUHVqlUrUP+9995T9+7dlZiYqDlz5igoKOik609KSvK6xcfHl/o+AAAAACihNpdIo1+VomLtjgQA4EPlKinVpEkTderUSYmJiUpLS9OOHTs0YcIEjRw5skDdRYsW6fbbb9cHH3yg++67r1jrr1mzptfN6SxXuw8AAABUDcfTpYUvSWlH/y4LCLQvHgCALcpdVmbhwoXKzc1Vw4YN1b59e/Xq1UtjxoyRJIWHh2v27NmSpPHjxys3N1f9+vVTeHi4dbvtttvsDB8AAADAyWQek2aOlzZ9JS14QTLG7ogAADYpdwMwxcXFacGCBYUuyz/Y+c8//+yrkAAAAACUhqzj0qwJ0t7tUkiE1OcWyeGwOyoAgE3KXU8pAAAAAJVQdqY0+ylp969ScLh0w3gprr7dUQEAbERSCgAAAEDZys6S5jwt7dwiBYVKw8ZK8Q3tjgoAYDOSUgAAAADK1ifvSH9ukgKDpeufkOo0tjsiAEA5UO7GlAIAAABQyXQdlDeOVO+bpbrN7I4GAFBOkJQCAAAAULaqxUi3vig5uVADAPA3PhUAAAAAlC6XS1o0Sdr8zd9lJKQAACegpxQAAACA0uN2SUtelf63WvrlO6n+2VJ4lN1RAQDKIX6uAAAAAFA63G7pwzfyElJOP6n/fSSkAABFIikFAAAAS1JSkvr27auoqCjFxMQoMTFRubm5hdZ988031axZM0VERKhp06aaPHmyj6NFueJ2Sx/9W9q4QnI48xJSzS+wOyoAQDlGUgoAAACWQYMGKTw8XHv37tXatWu1fPlyTZo0qUC9JUuW6JFHHtH06dOVmpqq6dOn67HHHtOiRYuKXPfBgwe9bm63uyx3Bb5kjPTJ29KG5XkJqWsTpZYd7Y4KAFDOkZQCAACAJGn79u1auXKlJk6cqNDQUDVq1EhjxozR66+/XqDu3r179fDDD6tDhw5yOBzq2LGjunXrptWrVxe5/tjYWK/bvn37ynJ34EtbvpXWfSrJIfW9S2rd2e6IAAAVAAOdAwAAQJK0efNmRUdHq3bt2lZZy5YttXPnTiUnJysqKsoqHz16tNdzk5KStHr1ar300ku+ChflSYuO0gV9pFoNpHO72h0NAKCCICkFAAAASVJaWprCwsK8ykJDQyVJ6enpXkmp/Pbv368+ffro/PPP13XXXVfWYaK8MEYy7rwBzZ1OqfcouyMCAFQwXL4HlKKsrCwdOHBAv//+u7Zv365du3YpLS1Nxhi7QwMA4JTCwsKUkZHhVeZ5HBERUehzvvvuO7Vr107NmjXT0qVL5e/Pb55Vxqr50oIXpNwcuyMBAFRQJKWAUnLs2DHt3LlTR44cUU5Ojlwul44dO6Y9e/YoKSmJxBQAoNxr1aqVDh8+rAMHDlhlW7ZsUUJCgqpVq1ag/nvvvafu3bsrMTFRc+bMUVBQ0EnXn5SU5HWLj48v9X2Aj3y1SFo5V/rlO2nbD3ZHAwCooPgpCygFLpdL+/btk8vlkr+/vxwOh9eyo0ePKiQkRJGRkcrOzlZqaqpyc3PldDoVERGh4OBgr+cAAGCHJk2aqFOnTkpMTNSUKVN06NAhTZgwQSNHjixQd9GiRbr99tu1dOlS9ezZs1jrr1mzptdjp5PfRyukbz+UvpiVd7/79VKLDvbGAwCosGgJAKUgLS1Nubm58vPzK5Bc8vPzkzFGR48e1aFDh/Tnn3/q0KFDOnr0qI4cOaKdO3dq7969TIsNACgXFi5cqNzcXDVs2FDt27dXr169NGbMGElSeHi4Zs+eLUkaP368cnNz1a9fP4WHh1u32267zc7wUda+XyZ9Pi3vftfBUud+toYDAKjY6CkFlILMzExJKrK3k9PpVEZGho4fPy6Hw2Elr4wxMsYoLS1Nfn5+qlWrli/DBgCggLi4OC1YsKDQZenp6db9n3/+2VchobxY/5n0ydt59zv3ly4eaG88AIAKj55SQCk41aV3xhirJ1T+3lQOh0NOp1MOh0OpqanKyWGgUAAAUA6lJ0ufTcu7f2Ff6ZLrJIYeAACcIZJSQCnwTJdd2CV4nt5QngRUYZxOp9xud4EZjwAAAMqF8Chp6ONSp2uly24gIQUAKBVcvgeUgrCwMAUFBSkzM1MOh8PqCWWMkcvlKvYg5szQBwAAypXsLCnw/2dVbHB23g0AgFJCTymgFDidTtWpU0dBQUFyuVzKyclRTk6OXC6XnE6n4uLi5O/vX2TSydOTKjAw0MeRAwAAFOGX76TXRksH/rI7EgBAJUVPKaCUBAYGqkGDBkpPT1d6erqMMQoODlZERIQCAwOVnZ2tI0eOWGNIeXjGmwoODlZISIiNewAAAPD/fl0nLXhRcudKG/4rXT7K7ogAAJUQSSmgFDmdTkVGRioyMrLAspiYGGVmZur48eOS5DX7XmBgoOLj44t9mR8AAECZ2bZBmj8xLyHVuovU80a7IwIAVFIkpQAf8fPzU0JCglJSUpScnKzc3Fz5+fkpMjJSUVFRXLoHAADs9/tGae6zkitXatlR6nu35PSzOyoAQCVFUgrwIT8/P0VHRys6OtoaX4reUQAAoFz4c5P0/jOSK0dqdoHU75+SHwkpAEDZISkF2IRkFAAAKDeMkb5aJOVmS03OlwbcL/nxVQEAULb4pAEAAACqOodDGvig9NVC6eJBkn+A3REBAKoAp90BAAAAALBJevLf94NCpEuHSQGMcwkA8A2SUgAAAEBVtG+H9Ppd0uqFdkcCAKiiSEoBAAAAVc2Bv6QZY6XMdOm3dVJujt0RAQCqIJJSAAAAQFVycFdeQup4mlS7sXT9E4whBQCwBUkpAAAAoKo4tEeaPlY6liLVaigNGysFh9kdFQCgiiIpBQAAAFQFR/blJaTSj0qx9aVh46SQcLujAgBUYSSlAAAAgKpgx/+ktMNSTIJ0wzgpLNLuiAAAVZy/3QEAAAAA8IHze0h+AdJZ50rhUXZHAwAASSkAAACg0ko7KvkHSiH/P25Um272xgMAQD5cvgcAAABURunJ0vQxeTPtZaTZHQ0AAAWQlAIAAAAqm2OpecmoQ3ukY8lS1nG7IwIAoACSUgAAAEBlkpEmzRwnJe2UwqtLwydI1WPtjgoAgAJISgEAAACVxfFj0szx0v4dUliUNPxJqUa83VEBAFAoklIAAABAZZCZIc1+Utr3uxQaKQ0fL9VMsDsqAACKRFIKAAAAqAyOpUjJB6WQcOmGcVJsPbsjAgDgpPztDgAAAABAKagRL934VN6g5rUa2h0NAACnRFIKAAAAqKhysqUDf0oJTfMe16htazgAAJQEl+8BAAAAFVFujjTvOWnq49K2H+yOBgCAEiMpBQAAAFQ0uTnS/Oel7Rskh0MKCLI7IgAASoykFAAAAFCRuHKlRS9Jv62T/AOl6x6TGrSyOyoAAEqMpBQAAABQUbhc0uJXpF++k/z8pcEPS43OsTsqAABOC0kpAAAAoCJwu6QPX5c2fS05/aWBD0qN/2F3VAAAnDaSUgAAAEBFYJSXmHL6SQPul5q1szsiAADOiL/dAQAAAAAoBj8/6dp7pPZ9pLrN7I4GAIAzRk8pAAAAoLwyRvrfV3k9pKS8XlIkpAAAlQRJKQAAAKA8Mkb6fFreTHsfvpH3GACASoSkFAAAAFDeGCN9MUtaszTvcb3mksNhb0wAAJQyklIAAABAebNynvT1B3n3e98snd/D3ngAACgDJKUAAACA8mT1AmnVvLz7PW+ULuhtbzwAAJQRklIAAABAefHth9KXc/LuX3qD1PEqe+MBAKAM+dsdAAAAAID/V6O25OcvdRkodbrG7mgAAChTJKUAAACA8qJZO2n0K3nJKQAAKjku3wMAAADs9PNq6cj+vx+TkAIAVBEkpQAAAAC7/LRC+uBladrjUnqy3dEAAOBTJKUAAAAAO/zvK+nD1yWZvMv2wqrZHREAAD5FUgoAAADwtc3f5vWQMm7pvMuky2+WHA67owIAwKdISgEAAAC+tPV7adFLeQmpNpdIV9wmOWmWAwCqHj79AAAAAF/542dp/guS2yW17iJdNZqEFACgyvK3OwAAAACgyohrIMXWzZthr+/dktPP7ogAALANSSkA8IHMzEylpKTo2LFjMsYoNDRUUVFRCgkJsTs0AIAvhUVKwydIgUGSHwkpAEDVRlIKAMpYamqq9u/fL5fLJcf/D2KbkpKi1NRUxcbGqnr16jZHCAAoU39ulg7vlc6/LO9xSJi98QAAUE6QlAKAMpSdna39+/fL7XbL39/fSkoZY+RyuZSUlKTg4GB6TAFAZbVrqzTnKSk7UwqNlFq0tzsiAADKDUZVBIAylJqaKpfLJT8/PyshJUkOh0N+fn5yu91KTk62L0AAQNnZs02aNSEvIdXwHKlxG7sjAgCgXCEpBQBl6Pjx45LklZDycDgccjgcVh0AQCWy7w9p5ngpK0Oqf7Y05FEpIMjuqAAAKFdISgEAAAClaf+f0oyxUuYxqW5z6brH8gY2BwAAXkhKAUAZCgsLk8PhkDGmwDJPWVgYA94CQKWRnpyXkDqeLtVpKg0dIwUxbiAAAIUhKQUAZSgyMlL+/v7Kzc31Skx5Bjp3Op2KioqyL0AAQOkKqyZd0FuKbyRd/4QUHGp3RAAAlFvMvgcAZcjf31+1a9fW3r17vRJTnoHOa9WqpaAgLukAgErD4ZC6DpIu6ssYUgAAnAJJKQAoY6GhoWrQoIFSU1OVkZEhY4xCQ0MVGRmpgIAAu8MDAJypo0nSivelK26VAoPzykhIAQBwSiSlgDJgjFFWVpaOHTsmt9utgIAARUREyM/Pz+7QYBN/f39FR0crOjra7lAAAKUp5ZA0fYyUnCQ5nVLfu+yOCACACoOkVAWSm5ur1NRUZWVlyeFwKCwsTGFhYXI6y8/QYC6XS9nZ2XI4HAoKCpLD4bA7pALcbrfS0tKUmZkpSQoODlZERESpHUe32639+/crLS3NawyhgwcPKi4uTpGRkaWyHZSu7OxsZWVlScq7tC4nJ0c5OTnKzc2VJAUEBCg4OFjh4eHl8v+6LOTm5urYsWNyuVwKDAxUaGioLe83WVlZOn78uKS812t5eG/xJJ49cYWEhCg4OLhMt3f8+HG53W75+/t7HQNjjI4dO6aUlBRlZmbK6XQqPDxc1apVU2BgYJnFVJK409LSdPz4cblcLjkcDkVERJSL+IAzlnpYmvb/CanoeOmSoXZHBABAhUJSqoJITU3VgQMH5HK5rERHcnKygoODVadOHdsvAXK5XDp06JBSU1OtLx0BAQGqXr26oqKibP8C6ZGZmak9e/YoJyfHa2yfQ4cOqU6dOqXypXL//v1KSUmR0+mUn5+fNfOay+XS/v375e/vr9BQBj0tL7Kzs5WUlKT09HSv11dh/P39FRgYqNq1a5dpAsJuxhgdPHhQycnJcrvdVnlAQIBq1arls9kCc3NztX//fqvHocPhkMPhUGhoqGrVqmXb+15OTo72799vXYopyYorPj5e/v6l+9GakpKiw4cPW+9bDodDISEhio2NVVBQkJKSkqxz5XmvzcrKUkpKimrXrm3b+01mZqZ1nPL/HzmdTmVlZSk5OVm1a9dm9klUXGlHpeljpaP7pag4afiTUiS9YQEAKIny08Xm/yUlJalv376KiopSTEyMEhMTrZ4KJ1q2bJlat26tsLAwtWjRQh999JGPo/WNjIwM7d+/Xy6XS35+fgoICFBAQICcTqeOHz+uPXv2nPSLdFlzuVzavXu3jhw5IrfbLafTKYfDoezsbB04cEAHDx60Lbb8cnNztXv3bmVnZ3sdRz8/P2VnZ2vPnj1F/q8VV1ZWltLS0rwSUtLfg1q7XC4dOXKkNHYHpSAnJ0e7du2ykqmneh25XC5lZWVp9+7dysnJ8VGUvnfw4EEdOXJExhj5+fnJ399fTqdTOTk52rNnj9U7qCy53W7t2bNHaWlpkvISgp7X1LFjx7R79265XK4yj+NEnve79PR063XtiSs9PV179uzxSsCcqeTkZO3fv9/qIXviMTh8+LCOHj0qKS9p6O/vbx2rnJwc7du3r1TjKS7P6yR/Qsrzfuh5nJubq3379tlyHoEzdixFmjFWOrxHqlYzLyFVLcbuqAAAqHDKXVJq0KBBCg8P1969e7V27VotX75ckyZNKlBv27Zt6tevnyZMmKCUlBSNHz9eAwcO1J49e4pc98GDB71udjTUT0dycrKVkMrf48iT+MjMzNSxY8dsiy8lJUXHjx+3vpw5nU45nU75+/vL4XDo6NGj1mVRdkpNTVVubq4Vl4fD4ZC/v79ycnKUmpp6RttIT0+XMabQS5wcDoecTqcyMjLOOPmF0nHkyBFlZ2fL6XSeMiHl6fHmubQvJSXFR1H6Vk5OjpKTk70SINLf7zcul0uHDx8u8zjS09O93lc8vaQ8cWRlZZ3x6/V0eC6h9iTqTozLc6laaXC73Tp06JCMMdYPEZ5ted6zPOfixPHq8r+vlVY8JXHkyBGvxG3+BL3D4ZDb7Zafn59yc3NtiQ84I8ZIC16QDu6SImpIw8dL1WPtjgoAgAqpXCWltm/frpUrV2rixIkKDQ1Vo0aNNGbMGL3++usF6k6fPl2dO3dW37595e/vr4EDB+riiy/WlClTilx/bGys123fvn1luTulwhij9PR068vIiTxfpjMyMmyILo/ny3lhiRin0ym3223Ll8cTpaenS1Khx9GTcPDUOV35L+UpjGc7dvZsQx5jjNLS0qwvyMWp7/nrcDjKxf90WUhPT7d6PJ7Il4lVz5hsRcXhqeNrnm2e7P24tOJKT09Xbm5uoRMkeJI7J+ux54nRM36er3jG7fO83xXG8z5ojPF5fMAZcziknjdKsfXyElLR8XZHBABAhVWuklKbN29WdHS0ateubZW1bNlSO3fuVHJycoG6rVu39ipr2bKlNm7c6ItQfaa4yQu7khzGGOXk5Jw0CSOpXPQMOlXiobjJiZPxDNpb1Pnw9A5gFj77ud1uawyekrx+PEmpitLTsqROvNTqRJ7jVdb77xmb7mTseF851TYdDkepXY7mWc+p3l9PxvP/6kueS2FPtV2S86jQ4htJt02SYurYHQkAABVauUpKpaWlFRjw1DNA64k9WIqqe6Y9Xcobzyx2J/u12VPHDp5LfE4Wn1Tw0hI7BAcHF9lLyVN+poNXh4eHy9/fv9Dxidxut4wxioqKKlczJlZVnstMS/rF2JOQsus1V9Y8g4ef7DXtuVStrOM4Va9CO2ZuO9k2PfGWVlyeY3yyY3Cy3peepGtISEipxFNcnsu48yemitoHzwDxQLmXdVya9aS085e/y/gsBwDgjJWrT9OwsLACl6F5HkdERBSr7on1KjqHw6GoqChJBXv6eGZ08/f3t3W/IyMjrXhO5PkCGx4e7uuwCqhWrZp1OeGJPJcrVatW7Yy24XQ6VatWLTmdTuXm5srlcsntdis3N1dut1uhoaGqXr36GW0DpcMzLX1Rl4gV9RzP7Uz/V8qrkyVWPcmPyMjIMk9KRUZGnvT1KsmWc+DZ5sneRzzviWcqLCzMGsfrRJ7eaqGhoXI6nQXOl+fzISgoyOez23mOgWeg/BMTU/n/BgYGlovPB+CksjOlOU9J23+UFr4k5VbeiS4AAPC1cpWUatWqlQ4fPqwDBw5YZVu2bFFCQkKBLx+tWrXS5s2bvcq2bNmiVq1aFbn+pKQkr1t8fMUYAyAyMlKRkZFWcsPlcik3N1e5ublWEsTOnkhRUVEKCAiwEi+eL66ehEx4eLjPf6kvTEhIiGJi8mbG8RxHz7GUpJiYmFKJMzw8XHXr1lVkZKTViyEgIEAxMTFKSEgoF73GkCc6OlqBgYHFvsTJUycyMrLSJcA9nE6nYmNj5XA4rNe02+22XiuBgYGKji77Kc9DQ0OtxEb+ODz3IyIibElmhIeHKyIiwisWz31Pwq60ev74+fkpJibG61x4klGeSRvi4+MVGxtrJcJzcnKUk5NjJaRq165tS8/M6OhoBQUFec3IKv2dkHI6nQoMDLQtPqDYcrKk95+R/toiBYVKgx6U/APsjgoAgErD3+4A8mvSpIk6deqkxMRETZkyRYcOHdKECRM0cuTIAnWHDRuml156SfPnz9e1116rDz74QCtXrtQrr7xS5Ppr1qzp9biiNIQdDofi4+MVFhamlJQUZWZmyul0KiIiQlFRUWd8ydmZCggIUEJCgvbv36/MzEyrB4Gn55HnC2554PmidPToUWtae0/vpdLsTRASEqI6depYX1hPnDkR5UNAQIDq1q2rAwcO6NixY4X2DpL+HuA7KChI1atXV1RUVKU+n55eSocPH7YGoXY4HKpevbpq1KhhXeJXlhwOh2rVqmW9Xj3JY39/f0VFRSk6OtqWc+B5Pw4ODlZycrIVV0BAgKpXr67q1auXalye/7XDhw9bg5p7LnmLjY1VcHCwgoODFRoaqtTUVOvzITw8XOHh4bYlwT2fC4cOHbIuq89/uXn16tV90uMOOCM52dLcZ6Ud/5MCg6Xrx0h1mtgdFQAAPuNyuYqcWCcgIKBU2nLlKiklSQsXLtSdd96phg0byul06oYbbtCYMWMk5f1C/dZbb2no0KFq3ry5lixZooceekgjR45U/fr1tWjRIjVt2tTmPSgbnsuFqlWrdsoZ3uwQFBSkevXqKTMzU1lZWdaXJl98eS0Jh8NhfVnzxXH0jFuE8iswMFB169ZVVlaWsrKyvAaXDgoKkr//32+T/v7+5ep1V5bCw8MVFhamnJwcud3uUvvQKQmHw6Ho6GhFRUUpOztbUt75svs15XQ6VaNGDVWvXr3M4/Jcwh0ZGanjx4/L7XbL399fwcHBXv+LQUFBBX54sZunJ5Sn95bD4SgQN1Bu5eZI8ydKv/8kBQRJQ8dIdZvbHRUAAD5hjNH+/fsLTDh3oqioKNWqVeuM2nflLikVFxenBQsWFLrsxEHMe/bsqZ49e/oirHKlvDboPQPqlodL9YqjvB5H2CMoKKjSDl5+uhwOhy2DiZ/I6XTa3iO0ML6My+l0+nxsqNISEBBQ7n6gAE5pzVJp2w+Sf6B03WNS/ZZ2RwQAgM94ElKxsbEKDQ0t8N3ZGKOMjAwlJSVJ0hkNjVTuklIAAACArTpeJe37QzrvMqlha7ujAQDAZ1wul5WQqlGjRpH1PJ1RkpKSFBsbe9pXVZCUAgAAANxuyeHIu/kHSAMfsDsiAAB8zjOGVHEm7/HUycnJOe2kFIPdAAAAoGpzu6Wlb0ifTZUKmfACAICqpiSzk58JekoBAACg6nK7pY/elH76UnI4pXO7SvGN7I4KAIAqgZ5SAAAAqJqMkT55R9rw37yE1LWJJKQAAPAhklIAAACoeozJu1xv3SeSHNLVd0qtO9sdFQAAVQpJKQAAAFQtxkjLZ0rf/Sfv8VWjpTbd7I0JAIByxBRjjMXi1DkVklIAAACoWvbvkL5Zkne/z63SeZfaGg4AAOVFQECAJCkjI+OUdT11PM85HQx0DgAAgKolvlHe+FHH06R2veyOBgCAcsPPz09RUVFKSkqSJIWGhhaYZc8Yo4yMDCUlJSkqKkp+fn6nvT2SUgAAAKga3Pka1ed0sS8OAADKsVq1akmSlZgqSlRUlFX3dJGUAgAAQOWXfZZ0oLGUeliKrGF3NAAAlFsOh0Px8fGKjY1VTk5OoXUCAgLOqIeUB0kpAAAAVG7ZDaWs1nn3t3wrdbjS3ngAAKgA/Pz8SiXxdDIMdA4AAIDKK7u+lHVu3v2IJKn9FfbGAwAALCSlAAAAYElKSlLfvn0VFRWlmJgYJSYmKjc3t9C6y5YtU+vWrRUWFqYWLVroo48+Oum6Dx486HVzu91lsQt/y6knZf0j737ANqnaAemEwVoBAIB9SEoBAADAMmjQIIWHh2vv3r1au3atli9frkmTJhWot23bNvXr108TJkxQSkqKxo8fr4EDB2rPnj1Frjs2Ntbrtm/fvrLbkZwEKdOTkPpdCtoskY8CAKBccRhjjN1B2CUwMFA5OTlyOp2Kj4+3OxwAAFBK9u3bJ7fbrYCAAGVnZ9sdToWxfft2NWnSRHv27FHt2rUlSfPmzdODDz6ov/76y6vu448/rrVr1+rzzz+3yi6//HJdcMEFGj9+fKHrP3FKaY9SaYtl7Jfcrr8fmyDJOCSHS3L8/yCtTj8p9MxmCQIAAKdW3LZYlR7o3OXKa7i43e6T/qoHAAAqJs9nPYpn8+bNio6OthJSktSyZUvt3LlTycnJioqK8qrbunVrr+e3bNlSGzduLPF2y6YtllVImUs6SpsPAABfOVVbrEonpYKDg5WZmSk/Pz/FxsaWyjrdbneBrujx8fFyOrlSsrzgHJV/nKOKgfNU/lXlc5SUlCSXy6Xg4GC7Q6lQ0tLSFBYW5lUWGhoqSUpPT/dKShVVNz09vUTbdDqdtMUqKI61b3G8fYvj7Vscb9/yxfEublusSieljh07VurrPHjwYIFG1caNG1WzZs1S3xZOD+eo/OMcVQycp/KPc4SSCgsLU0ZGhleZ53FERESx6p5YL7+kpKQCZaX9/8j/ve9wrH2L4+1bHG/f4nj7Vnk63lU6KQUAAIC/tWrVSocPH9aBAwcUFxcnSdqyZYsSEhJUrVq1AnU3bNjgVbZlyxa1bdu2yPXz5QIAAORHXzgAAABIkpo0aaJOnTopMTFRaWlp2rFjhyZMmKCRI0cWqDts2DCtXLlS8+fPV25urubPn6+VK1dq2LBhNkQOAAAqoio9+x4AAAC8HThwQHfeeadWrFghp9OpG264Qc8995z8/PwUHh6ut956S0OHDpUkffbZZ3rooYf0+++/q379+po4caJ69+5t8x4AAICKgqQUAAAAAAAAfI7L9wAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKVKWVJSkvr27auoqCjFxMQoMTFRubm5dodV5c2bN0/+/v4KDw+3bp4pq7///nu1b99e4eHhatiwod59912bo61aDh48qMaNG2vlypVW2anOyfTp09W4cWOFhYWpbdu2WrNmjY+jrnoKO0+33367goKCvF5XU6ZMsZZznnxj48aNuuyyyxQdHa1atWrphhtu0KFDhyTxWkLlV5J217Jly9S6dWuFhYWpRYsW+uijj3wcbcVWkmP95ptvqlmzZoqIiFDTpk01efJkH0db8Z3Od4pNmzYpNDTU67MaxVOS471q1Srrs7Vu3br617/+5eNoK76SHO9XXnlFDRs2VGRkpM455xwtWrTIx9FWHoW1509ky2elQanq2rWrGTp0qDl27Jj5/fffzdlnn20mTpxod1hV3n333WdGjBhRoPzIkSMmOjravP766yYnJ8d88cUXJiIiwnz//fc2RFn1fP311+ass84yksyKFSuMMac+JytWrDARERHm66+/NtnZ2eall14yMTEx5tixYzbuSeVW2Hkyxpjzzz/fTJs2rdDncJ58IyMjw8THx5snnnjCZGVlmUOHDpnevXubK664gtcSqoTitrt+++03ExwcbBYvXmxycnLMvHnzTEhIiNm9e7cNUVdMxT3WixcvNlFRUWbNmjXG7Xabb7/91kRFRZmFCxfaEHXFVdLvFMeOHTOtWrUq8FmN4inu8f7ll19MaGiomTZtmnG73Wbjxo2mRo0aZsGCBTZEXXEV93gvW7bMxMbGmq1btxpjjFm4cKFxOp1mx44dPo644iuqPZ+fXZ+VJKVK0bZt24wks2fPHqts7ty5pl69ejZGBWOM6dKli3n99dcLlL/99tumSZMmXmW33XabueGGG3wVWpU1bdo0U69ePTN37lyvN8dTnZOhQ4eam2++2Wt58+bNzXvvveeTuKuaos5TZmamCQwMNJs2bSr0eZwn39i6davp1auXyc3Ntco+/PBDExkZyWsJlV5J2l2PPfaYueyyy7zKevXqZZ544okyj7MyKMmxfuONN8yzzz7rVXbNNdeYu+++u8zjrCxO5zvF8OHDzZgxY0hKnYaSHO8777zTXHfddV5lv/76q9m3b1+Zx1lZlOR4v/jii6ZmzZpmy5Ytxu12m8WLF5vg4GCza9cuX4Zc4RXVnj+RXZ+VXL5XijZv3qzo6GjVrl3bKmvZsqV27typ5ORk+wKr4txutzZs2KCPP/5Y9evXV0JCgm655RYdPXpUmzdvVuvWrb3qt2zZUhs3brQp2qqjZ8+e+v333zVo0CCv8lOdE86ZbxV1njZu3KicnBw98cQTiouLU9OmTfXcc8/J7XZL4jz5SrNmzfTJJ5/Iz8/PKlu4cKHOP/98Xkuo9ErS7uL//cyU5FiPHj1aDz30kPU4KSlJq1ev1vnnn++rcCu8kn6nmDFjhrZv366xY8f6MMrKoyTHe+3atWrQoIGGDBmimJgYtWjRQitXrlStWrV8HHXFVZLjPWTIEMXFxally5YKCAjQgAEDNG3aNCUkJPg46oqtqPb8iez6rCQpVYrS0tIUFhbmVRYaGipJSk9PtyMkKO/a2X/84x/q37+/fvnlF3377bfatm2brr/++iLPGeer7NWqVUv+/v4Fyk91TjhnvlXUeUpJSVHXrl119913a/fu3Zo1a5ZeffVVvfjii5I4T3Ywxujxxx/Xf/7zH73yyiu8llDplaTdxf/7mTndNu7+/ft1+eWX6/zzz9d1111XpjFWJiU53lu3btVjjz2mOXPmeP1AgeIryfE+cuSIXn31VV1//fXav3+/3nrrLd1///1auHChz+Kt6EpyvLOzs9WmTRutXbtWGRkZmjJlikaOHKn//e9/Pou3MiiqPX8iuz4rSUqVorCwMGVkZHiVeR5HRETYERIkxcXFafXq1brpppsUGhqqevXqaeLEifrkk09kjCn0nHG+7FPU68hzTk61HL5x2WWX6csvv9TFF1+sgIAAXXDBBUpMTNS8efMkcZ58LTU1Vf3799esWbO0evVqa4BKXkuozErS7uL//cycThv3u+++U7t27dSsWTMtXbq0WF+IkKe4xzszM1ODBg3Syy+/rHr16vk0xsqkJP/fQUFBuvrqq9WnTx/5+/urS5cuGjZsmObPn++zeCu6khzvO++8U2effbbatWunwMBA3XjjjerYsaOmTZvmq3CrFLs+K0lKlaJWrVrp8OHDOnDggFW2ZcsWJSQkqFq1ajZGVrX9/PPPevjhh2WMscqysrLkdDp1wQUXaPPmzV71t2zZolatWvk6TPy/Vq1anfScnGo5fGPJkiV66623vMqysrIUEhIiifPkS7///rvatWun1NRUrV+/3up2zWsJlV1J2l38v5+ZkrZx33vvPXXv3l2JiYmaM2eOgoKCfBluhVfc471u3Tr99ttvGjlypKKiohQVFSVJuuKKKzR69Ghfh11hleT/u2XLlsrKyvIqc7lcXt8zcHIlOd47d+4scLwDAgIUGBjok1irGts+K8t0xKoqqFOnTmbw4MEmNTXV/PHHH+bss882Y8eOtTusKm3Xrl0mLCzMPPfccyYnJ8f89ddfpkOHDmbkyJHm0KFDJioqykyaNMlkZ2ebL7/80kRERJgvv/zS7rCrFOUbcO9U52T58uXW4+zsbDNp0iRTvXp1c/jwYRv3oGrIf54++OADExISYpYvX27NrhQTE2NmzpxpjOE8+cqRI0dMvXr1zIgRI4zL5fJaxmsJVUFx212//PKLCQ4ONvPmzbNmFAoODja//vqr74OuoIp7rBcuXGgCAwPNp59+6vsgK5HT/U4hBjo/LcU93l988YXx9/c3M2fONG6326xatcqEh4ebDz/80PdBV2DFPd6PP/64iYmJMT/88INxuVxmwYIFJjg42Pz4448+j7myONl7hF2flSSlStn+/ftN//79TY0aNUzNmjXNfffd5zUrEuyxcuVK07FjRxMREWFq1qxp7rrrLnP8+HFjjDHr1q0zF154oYmIiDCNGjUyU6dOtTfYKujEN8dTnZOZM2eaZs2ambCwMHPBBReY7777zrcBV1Ennqc333zTNG3a1ISGhppGjRqZN954w6s+56nsvfjii0aSCQ0NNWFhYV43Y3gtofI7WbsrLCzMzJo1y6r76aefmnPPPdeEh4ebs88+23z88cd2hV0hFfdYt27d2jidzgLvSbfeequd4Vc4Jfnfzo+k1OkpyfFetmyZadu2rfXZ+uabb9oVdoVV3OOdk5Njxo4daxo0aGAiIyPN+eefT8L7DJ34HlEePisd/x8YAAAAAAAA4DOMKQUAAAAAAACfIykFAAAAAAAAnyMpBQAAAAAAAJ8jKQUAAAAAAACfIykFAAAAAAAAnyMpBQAAAAAAAJ8jKQUAAAAAAACfIykF4LSNGDFCDodDDodDS5YssTucM/bNN9+oa9euioyMVGhoqFq0aKHPPvvM7rB8btq0adZ5TUxMtDscAABK3bhx46zPupPdunbtelrr//PPP611tGnTplRjL6n8n+v5b/7+/oqMjFSTJk1033336dChQz6N61TH6K+//tLLL7/sVbZy5UrrOX379vVJnEU52f9QQECAatSooXbt2um5555TZmbmGW/PGKMZM2bo559/LoXogfKDpBQASEpJSVGvXr20atUqpaWl6fjx49q6dav8/f3tDg0AAKDUuVwupaWlafv27XrppZfUuXNnHT582O6wlJmZqccee0zNmzevsD965ubm6siRI1q/fr0efvhhXXnllcrNzT3t9X333Xdq166dhg8friNHjpRipID9+LYFAJI2btyo9PR0SVJCQoL+9a9/KTs7W+3atbM5MgAAUJYGDRqkwYMHF7osJibGx9GUrW7duunuu++WMUbHjx/Xhg0b9OqrryonJ0dbt27Vs88+q+eff94nscTGxmrx4sWSpGrVqlnl27dv1zPPPFPoc1q1amU9Jz4+vuyDLKb8/0PGGLlcLq1du1YvvfSSXC6Xli9frgULFmjIkCGntf4XXnhBP/zwQ2mGDJQbJKUAQFJaWpp1v1u3brr++uttjAYAAPhK8+bNbb8UzFfq1avnta/XXXedGjRooLvuukuS9OGHH/osKRUaGlri4x4TE1Muz1Vh/0P9+/dXRkaG3njjDUnSxx9/fNpJKaAy4/I9oBzJf236d999p6VLl6pjx44KDQ1VbGysRo4cqaSkJK/nNGjQwHpOcnKy17KYmBhrmUf+a/FfeOEFff311+ratavCwsIUFxene++9V5mZmTp69KhGjx6t2NhYhYeHq1OnTlq1alWRsRtj9Oqrr6pJkyYKDg5Ws2bN9MwzzygnJ6dA3V9++UVDhgxRbGysgoKCdNZZZ+nee+/VwYMHverlHwNhxowZuuWWWxQWFqZq1app4sSJpzyeP//8s2666SY1aNBAQUFBiouL07XXXquvv/66wDG84oorrMczZ84s1jgSR48e1QMPPKDmzZsrJCREAQEBqlOnjgYOHFjo9f4HDx7UnXfeqUaNGikoKEihoaFq0KCBRowYoR07dhSIyeFwqFWrVjpy5Ihuv/12xcXFKSwsTN27d9f//vc/SdLUqVPVqlUrBQcHq1GjRnrmmWfkdrut9eQ/30899ZTWrFmj7t27Kzw8XDExMRo+fLj27NlzymOZf5/vv/9+NWzYUEFBQapVq5YGDx5sxQMAQGW2aNEide3aVdWrV7fGDbrwwgs1ZcoUGWOKtY41a9bommuuUXx8vAICAhQWFqZWrVppzJgxysjIKFB/9+7duuWWW1SnTh0FBQWpbt26GjVqlP78889S2afu3btb93ft2lVg+VdffaWBAwcqISFBQUFBSkhI0LBhwwr97D9+/LieeuopnXvuuQoPD1dAQIDi4uJ0xRVXaPXq1V51CxtTatq0aWrdurVVZ9WqVV5tssLGlLr77rutsn//+98FYhowYIC1fMWKFVZ5cdujZyL/vhw9etRr2Y4dOzR8+HDVrVtXgYGBCg8PV5MmTXTXXXd5xdCgQQMtWrTIetytWzc5HA6tXLnSp/sClBkDoNwYO3askWQkmaFDh1r38986duzo9Zz69etby44ePeq1rEaNGtYyjxUrVlhl3bp1M/7+/gW20bdvX9OyZcsC5YGBgWbz5s3WuoYPH24tO/vsswuN98orrzRut9t6zqpVq0xYWFihdevVq2f++usvq+7UqVO9luWv+/nnn5/0WE6fPt0EBgYWuh2Hw2GeffbZQo9h/tvFF19c5PozMjKK3GdJJjIy0vz0009W/dTUVNO6desi68fFxZmDBw8WiKlu3bqmefPmBerXqFHD3HLLLYWu6/HHHy/0fF966aWFnu86deqYnTt3Fnrc77nnHqt8//79pnHjxoVuMzg42Hz66acnPScAAJQX+dtcY8eOLdZz3nvvvSI/xyWZJ5980qq7Y8cOq/zcc8+1yr/44otCP4s9t0suucTk5uZa9bds2WJiY2MLrVu9enWzYcOGU8ad/3N9+PDhBZb/5z//8WqP5PfMM88Yh8NR6PYDAwPNrFmzrLput9t07969yH0LCAgwn3322UmPUf5YC2uT5W/XXH311cYYY/73v/8V2U4+evSoCQoKMpJMo0aNrDZpSdqjRSnO/9DIkSMLbVPt2rXL1KlTp8hj1bx5c5OVlWWMKbqdumLFilLbF8BOJKWAciT/h5skc/nll5tZs2aZe++916t83bp11nPOJCklybRt29ZMmzbNjB492qvcz8/PPProo2bq1KleiYiHHnrIWlf+pJSUl8yaPn26eeihh0xAQIBV7mmwZGZmWh/AISEh5vHHHzfvv/++efDBB60GWu/eva31n9gw6du3r5k1a5a58847vRpsJ/r555+thJTD4TC33HKLmTFjhnnggQe8ElUff/yxMcaYzz77zDz22GNWebdu3czixYvNV199VeQ25s6da9Xv3bu3mTFjhpkzZ44ZPHiwVd6nTx+r/ksvvWSV9+rVy8yZM8e899575vzzz7fKp02bVuh5jYiIMM8++6yZPHmy1zmVZLp3725mzpzplcTM36A88XzXq1fPvPrqq2by5MmmYcOGXse2sOOevwHVr18/r0bt7NmzzfPPP2/i4uKMJFOzZk2Tnp5e5DEDAKC8OLHNdbJEiDF5bZiaNWsaSSY8PNw8//zzZt68eWbMmDHG6XQaSaZBgwZW/aKSUr169bISNE888YSZN2+e+fe//22aNm1q1V+wYIFVv23btkaScTqd5p577jFz5swx48ePNxEREUbK+1Ew/49/hSksKeV2u01aWppZuXKladSokbV8yJAh1vM+/fRTKyEVGBho7r//fjNjxgxz6623WuUBAQHWj3DfffedV3Lo3XffNXPnzjV33HGHVd6qVauTHqO//vrLvPLKK1b52Wef7dUmKywpZYwxHTp0sMq3bdtmlb/11ltW+dNPP22dy5K0R4uS/39o0KBBZvHixWbx4sVm0aJFZtq0aeb222+3jpOfn5/ZuHGj9dy7777beu7QoUPN3LlzzVtvveXV5l65cqUxJq+d2rFjR6t8woQJZvHixebgwYOlti+AnUhKAeVI/g+3du3aGZfLZS3r1q2btWzu3LlW+ZkkpcLDw72ek79R8uCDD1rlM2bMKLSxkj8p1b17d69tP//88wWSMwsWLLDKnnnmGa/6//znP60k0p9//mmM8W5ExcTEWL8YncoNN9xgPe+pp57yWjZ79mxrWYcOHazy/L8SFvYr4oneeecdr0ZORkaGtey9994zy5cvN3v37rXK/vrrL7NgwQIzbtw4r7offfRRocck/3l95513rPInn3zSKk9ISLCOSXZ2tvVLoCSrPP/5DgwMNH/88YdXTJ7nOJ1Oc+TIEWNM4UmpAwcOWI3uHj16eB2LpUuXWvWnT59+ymMHAIDdSpqUysrKMqtXrzavv/66Wbp0qde6PImjwMBAq6yopFSnTp2MJBMVFeX1I+O2bdvMzJkzzfr1682xY8eMMcasW7fOWsctt9zitc1XX33VWrZq1aqT7mtRvY9OvIWHh5tff/3Vel6XLl2sZfl7RBljzNNPP20tGzx4sDHGmOXLl1tlo0ePNikpKVb9uXPnmk8++cRq453sGOXv+XRir/WiklL5e7Hl77XkOd5+fn5mz549xpiSt0eLUpz/IUkmKCjIqy1njDG//vqrmT17tnn66ae9koqvv/669bw5c+ZY5fl/GPT0kCrNfQHsxJhSQDnVo0cPOZ1/v0Rbtmxp3c/MzCyVbbRp00ZRUVHW4/yzmOQfX6B27drW/ePHjxe6rn79+nk9HjhwoHV/06ZNkqS1a9daZY8++qh1fb/D4dBLL70kSTLGaM2aNQXW37FjRwUGBhZnt/TFF19Y92+77TavZdddd521z2vXri1yf06lT58+1noee+wxRUdH6+KLL9YjjzyievXq6eKLL/Y6nvXq1VP//v31z3/+U19//bWefvppXXnllV4DXmZnZxe6rfxjW+VfZ+fOna1jEhAQoJo1a1rLCtuv9u3bq2HDhl4xXXjhhZIkt9t90nGh1q9fb41V9fnnn3udu6uuusqq9+233xa5DgAAyqNBgwZp8eLFBW5PPfWUVScwMFCdO3fWHXfcocaNG2vq1Km644471KpVK61fv15S0Z/j+Q0dOlSSlJycrHbt2ik+Pl79+/fXxx9/rA4dOuj8889XaGioJO9205QpU7w+e++++25rWWl89rZr106rVq1S06ZNrX3xjMEZERGh6667zqv+6NGjrfuesY0uuugiNWjQQJI0efJk1ahRQx06dNA///lPhYWFqWvXrqpfv/4Zx1qYQYMGKTIyUpI0e/ZsSXljNn3zzTeSpMsvv9xqz55Je7QkAgIC9PTTT+uXX37RyJEjvZY1bdpU1113nW699VZ9/PHHGjt2rC677DLdf//9Vp3i/D/5al+AskRSCiinqlev7vU4ODjYum+KGEjzxPLc3NyTbiN/QkqS/P3/npAzOjrauu/n53fKbdeoUcPrcVxcnHX/2LFjkgoO8FiUwgbejo2NLdZzJenQoUOSpKCgoAJxSX8n2dxud4HB4YurVq1a+uqrr9SrVy/5+fkpMzNTq1ev1rPPPqtLL71UZ511lv773/9a9Y8dO6ZRo0apZs2a6tGjhx5//HGtXbvWK9lY1LHNf56KOkfSqc/TifUl7/OUfwbCE53JuQMAoDzzzJx24q1Tp05e9T777DM1b95cLVu21E033aQpU6YoKCioRG2U2267TW+//bYaN24sSdq/f78WLVqkxMRENWnSRH369NGRI0cklc1nb7du3bR48WItWbJEy5Yt01dffaXdu3dr7dq1Ou+886x6R44csX6Mql27ttekOVJe28STPPPEGxwcrFWrVmngwIEKCgpSbm6uvv/+e02aNElXXnml6tatayWMSltoaKiV8Nu+fbu+++47zZo1y2oPjRo1yqpbFsd17NixysnJ0ZYtW9SjRw9JUk5OjmbOnOk1AY3HgQMH1L9/f8XFxenKK6/Uk08+qa1bt6pFixZWnaLahfnRPkNl4H/qKgDskD/BcDL5Gwn5Z7pzu91KT08/7W3kT34Ux969e70e55/tw5Ngi4iIsMruueeeIme3y/+B7OFp+BRHXFycdu7cqaysLB0+fLhAYsrzwezn51dooqa4WrVqpU8++USHDx/Wl19+qW+++UarV6/Wjz/+qJ07d+raa6/Vjh07FBMTo7vuuktTp06VJD3yyCMaNWqUGjVqpC+++EKXXnrpSbdT1Hkq6TnavXt3gbIDBw5Y909MUuaX/9x1795dd955Z6H18vfWAgCgsti2bZuuvvpqZWVlqWnTpnrttdfUqVMnhYaGqnPnzgVmRz6ZUaNGadSoUdq8ebNWrFihNWvWaPny5UpKStKyZct0xx136P333/f67B0yZIhXL/T8StL7qF69etasdScTExMjp9Mpt9utvXv3yhjj1eY8evSoNVNg/s/+evXqad68eUpLS9OqVav01Vdf6ZtvvtG3336rQ4cOacSIEWrTpo3OPvvsYsdcXDfffLM1+96iRYv06aefSsr7IbFPnz5WvTNpj56Mv7+/WrRooSVLlujCCy/UTz/9pK1bt+qyyy7TDz/84PWD85AhQ7RixQo5nU5NmjRJAwYMUJ06dfTuu+96JdBOpaz2BfAlekoBFVxYWJh1P/+vIBs2bJDL5fJZHLNnz/baXv6pa//xj39IktcvcCkpKV6/Rm7atElff/21jhw5UugvjvkvZTyViy66yLr/5ptvFogzJSVFknThhRcqKCio2OvNb968eRo9erQuueQS7d27VwMGDNDLL7+sDRs2qFevXpKk9PR0/fTTT5L+Ph7+/v4aP368GjVqJEn68ccfT2v7p2PDhg36+eefrcf79u2zunP7+fl5TVt8Is85lPKmi+7du7d17txutz7//HPt3r2bpBQAoFL66KOPlJWVJUkaPHiwevToodDQUGVkZOjXX38t1jrS0tL01FNPaejQoRoyZIhatmypO++8U7Nnz/b6fP7qq68kebeb9u/f79VuOnDggFasWKEDBw6UqKdWcfn7+6t9+/ZW3HPmzPFaPnnyZOv+JZdcIimvJ1liYqJ69uypb7/9VldccYWee+45ff3117r11lsl5fXiP9WlZPnbfMXpLeTxj3/8Q23btpUkTZ061Ro+Yvjw4V4/5J1Je7Q4QkJCNHfuXOsH1R07duj222+3lh89elQrVqyQJCUkJCgxMVF16tSRVHS7sKhjUtb7AvgCPaWACq5JkybavHmzJOnuu+/WxIkTtX//fj3wwAM+jWP9+vXq06ePhg0bpq1bt2rixInWsuHDh0uS+vbtq5iYGB06dEjTpk2TJF122WXauHGjnn/+eRljVLt27QLjFpTUXXfdpfnz58vlcmnMmDHatWuXOnXqpJ9//lmvvPKKpLweZk888cRpb2P37t3Wr3FXX3217r33XsXGxmrLli1avXq1tQ3PGE7VqlVTamqqcnNzdd111+naa6/V+vXr9dprr1nr9DR2y4oxRpdddpkeeughhYeHa9KkSdb4ZP369bPGYihM3bp11bNnT3322Wf67bffdOmll+qmm25SSkqKxo0bp+TkZDkcDp8m2QAA8JVq1apZ99944w3FxsYqMDBQ//73v716h2dlZRX5g1dERITmz59vjeGYmZmpfv36ye12e/2Y5/nh6qKLLlKLFi30yy+/aMWKFerbt6/69eunXbt2afz48crOzlZISIiuvvrqsthl3XvvvVYC6aabbtLGjRt1zjnn6Ouvv9aUKVMk5Q2V8PDDD0vK+zHO08768ccfdf/996tBgwb6448/tHDhwgL7V5T8veP/97//afr06ZL+bk+ezM0336z169fr8OHDVtmJ4zn5oj3arFkzvfjii1Yyat68eRo0aJCuueYahYaGKiAgQDk5Odq5c6duv/12de7cWV9++aXee+89ax3524X5j8nUqVP1+++/q0uXLj5rWwNlyudDqwMoUv5ZPCZNmuS17L777rOWTZ061SpftmxZoTN9NGzY0Jx33nnWY4+iZi0xxpiLL77YWvbjjz+e8jn5Z98bOHBgoXHceOONXtv4+OOPTWBgYJGzk3z22WdW3cJmgSuuyZMnm4CAgEK343Q6Cxzfks6+l5mZaS6//PKTzraSfwbDp556qtA6+WMcOnSoVb+oWRVPdkwKe07+c9e4cWMTHh5eIIa6det6zRRY1DZ27NhhEhISitzf8ePHn/K4AQBQHuRvc+Wfra0oBw8eNLVq1Sr08y9/u2bbtm3GmKJnlvvxxx9NdHR0kZ+l4eHh5vvvv7fqr1+/3lSrVq3Qug6Hw6tNWJT8n+vFaePk9+ijjxqHw1Fku23+/PlWXbfbbUaOHHnSttHAgQOt+kUdI5fLZWJjY72e17hxY2PMyduxxhiTlpbm1dbp0qVLoftVkvZoUYrzP9SnTx+rTlxcnDl8+LAxxphRo0ad8n/pscces9bz2muvFajrmRGxNPYFsBOX7wEV3OWXX66FCxfqvPPOU3BwsGrXrq077rhD69at8+mlVC+//LImT56s5s2bKzAwUM2aNdOkSZP0zjvveNXr3bu31q9fryFDhig+Pl4BAQFKSEjQwIEDtWbNGmtwyDN1++23a926dbrppptUv359BQYGqmbNmrr22mv19ddfKzEx8YzWHxQUpCVLluidd97RRRddpFq1asnf3181atTQpZdeqvnz5+u5556z6j/yyCN65ZVX1KJFC4WEhKhu3bq68sor9e2336pVq1aSpGXLlpVpb6mzzz5b33zzjS655BKFhISoRo0aGjFihL7//nuvWf2K0qBBA23YsEH33nuvGjdurODgYMXExKhr16764IMPzqjnGQAA5VlMTIxWrlypvn37KjY2VhERETrnnHP05JNPWj1UJOmDDz446XratGmjH3/8Uffee69atmypiIgIBQYGqmHDhrrpppu0YcMGXXDBBVb9888/Xz/99JNuvvlm1atXT4GBgapVq5Z69+6tL7/8UiNGjCijPc7z9NNPa9WqVRo0aJDq1KmjgIAA1a5dW8OGDdMPP/ygAQMGWHUdDofefvttzZ8/X927d1dCQoICAgIUFRWlTp066a233tL7779/ym06nU7NnTtX7du3V1hYmKKjo4s9BlV4eLgGDx5sPS5qfCZftUffffddqz1+4MAB3XPPPZKk1157TWPHjrXaUw0bNtTgwYP1448/WmNPLV682FrPzTffrNtuu01169ZVcHCwmjZtao0F6qt9AcqKw5gSXKgLAKhQVq5cqW7duknKu8xwyZIl9gYEAAAAAP+PnlIAAAAAAADwOZJSAAAAAAAA8DmSUgAAAAAAAPA5xpQCAAAAAACAz9FTCgAAAAAAAD5HUgoAAAAAAAA+R1IKAAAAAAAAPkdSCgAAAAAAAD5HUgoAAAAAAAA+R1IKAAAAAAAAPkdSCgAAAAAAAD5HUgoAAAAAAAA+R1IKAAAAAAAAPkdSCgAAAACAfIwxdocAVAkkpYAKoGvXrnI4HF63wMBA1atXT3fccYeOHj3qkzhGjBihBg0alFn9M1XYcXI6napWrZrat2+vuXPn+iyW/P788085HA5NmzZNkjRt2jQ5HA79+eeftsQDAADKj/Xr12vYsGGqV6+eQkJC1KhRI9188836448/ymyb8+bNU/369RUcHKxbb7211NbrcDg0bty4UlvfqbblcDj06KOPFrrc7XarTp06Xm2w4nr33Xd1//33n7Je165d1bVr1xKtG4A3f7sDAFA8//jHPzR58mTrcXZ2tn744Qc9+uij+vHHH/XNN9/I4XCUaQxjxozRPffcU2b1S8OJx8nlcmnXrl2aNGmShgwZoqioKPXq1cunMQEAABTmjTfeUGJiorp166Znn31WtWvX1vbt2/X8889r0aJFWr58uc4777xS3+4dd9yhJk2aaPr06apTp06prXfNmjVKSEgotfWditPp1IIFC/TMM88UWLZ69Wrt3bv3tNY7YcKEYiWb8rc5AZweklJABREZGakOHTp4lXXp0kXp6el64okn9P333xdYXtrOOuusMq1fGgo7TpLUu3dvxcbG6r333iMpBQAAbPfNN9/onnvu0Z133qmXX37ZKu/atav69u2r8847TzfeeKM2btxY6ts+fPiw7rjjjlLv5VPWbdETXXTRRfrqq6+0YcOGAsm7uXPnqk2bNvrpp5/KbPstW7Yss3UDVQWX7wEVXNu2bSVJf/31l6S8hsz111+v/v37KzIyUn369JEkZWZm6sEHH1TdunUVFBSkc845R/PmzfNalzFGb7zxhs4++2yFhISocePGmjhxonVN/YmX423YsEHdu3dXtWrVFBERoUsvvVTff/+9tfzE+i6XS5MnT1br1q0VEhKievXq6eGHH1ZmZqbXcy699FJNnTpVTZs2VVBQkM4991wtW7bsjI5TcHCwAgMDC5S/8847OvvssxUUFKR69epp3Lhxys3N9arz3//+V126dFF4eLji4+N16623el0yuXr1avXs2VPVq1dXYGCgGjZsqHHjxsntdp92vDk5OZowYYLOOusshYSE6Oyzz9bUqVOt5YV1F1+5cqUcDodWrlwpKe8yQX9/f73zzjuKj49XQkKCnn76aQUEBOjQoUNez/33v/8tf39/7d+/X5K0c+dODRkyRNHR0QoNDVX37t31448/nvb+AAAAb88//7yioqIK7eUTExOjl156Sf369VNaWppVPm/ePLVt21bh4eGqVauWbrvtNq82ybhx49S4cWN9/PHHOueccxQUFKSmTZtq+vTpkv5uK0jSk08+aQ0nUNiQCycOPyBJr732mpo3b67g4GDVqVNHo0eP9orvxMv39u3bp5tuukl169ZVSEiILrjgAi1dutRrOw6HQ5MnT9aoUaMUHR2t8PBw9e/fXwcOHDjlMezatavi4uI0f/58r/Lc3FwtWrRIQ4YMKfCcn3/+Wddee61q1qypgIAA1alTR3fffbeOHz8uSWrQoIH++usvTZ8+3To+hbWpNm/e7NUee/XVVwscr9WrV8vPz09jx4495b4AVRVJKaCC+/XXXyV590qaN2+eAgMDtWTJEt1zzz0yxuiaa67Rm2++qX/+859aunSpLrzwQg0ePFgzZsywnvfoo4/qnnvuUZ8+fbR06VLdfPPNevTRR/XUU08V2G5qaqp69eqlmJgYLVy4UHPnztWxY8fUs2dPpaSkFBrrrbfeqnvuuUdXX321li5dqjvvvFOvvfaarr76aq/BJNevX6/nn39eTz75pJYsWaKAgAD179+/WGNnGWOUm5tr3TIzM7V9+3aNGjVKaWlpGjZsmFX3X//6l2655RZdeuml+s9//qM777xTzz33nNfYCp988ol69eqlGjVqaN68eXr++ee1dOlS9e/fX5K0ceNGde/e3Vr+n//8RxdddJHGjx9/RmNY3XDDDfrXv/6lkSNH6qOPPlKfPn100003aebMmSVaj8vl0jPPPKN33nlHTz31lK6//nq5XC4tWrTIq96cOXN06aWXqlatWjp06JAuvPBC/fDDD3r99df1/vvvy+12q0uXLvrll19Oe58AAEAeY4w+++wzde/eXaGhoYXW6d+/v5544glFRERIkp566ikNHjxY7du316JFizR27FgtXLhQXbt2tRIqUl4i6M4779Q999yjjz/+WA0bNtSIESO0detWnXfeeVqzZo0kaeTIkVqzZo3i4+OLFfPcuXN1//3364477tBnn32mJ554QjNnztRdd91VaP0DBw6oXbt2WrlypZ5++mktWrRIDRo0UN++fTV79myvuo8++qhcLpfmzp2rF154QR9//LESExNPGZPT6VT//v21YMECr/IvvvhCmZmZuuKKK7zK9+3bp86dO+vYsWOaNm2aPvnkEw0cOFCvvfaaJk2aJElavHixatWqpd69e3sdnxPbVCf2krrrrrvUtWtX3X///Tp06JDS09M1YsQItW3bVmPGjDnlvgBVlgFQ7l188cWmS5cuJicnx7odOHDAzJ8/39SoUcN06NDBuN1uq25QUJBJT0+3nv/5558bSWbu3Lle673++utNfHy8ycnJMUePHjUBAQHm3nvv9arzz3/+01x22WXGGGOGDx9u6tevb4wxZs2aNUaS+frrr62627dvNw888IDZuXNngfqbN282ksxTTz3ltf6ZM2caSWbZsmXWcySZ7du3W3VWrVplJJmFCxee8jhJKnBzOBzmnHPOMQsWLLDqJicnm9DQUHPbbbd5reOdd94xksymTZuMMca0bdvW/OMf//Cqs3DhQtOkSROzZ88eM2PGDHP55Zcbl8tlLXe5XKZatWrmlltuMcYYs2PHDiPJTJ061RhjzNSpU40ks2PHjkL3Y9OmTUaSeeWVV7zKBw4caG688UZrXy+++GKv5StWrDCSzIoVK7y28/bbb3vV69q1q+natav1+K+//jIOh8PMmjXLGGPMo48+aoKDg82ff/5p1cnKyjKNGjUy/fv3LzRmAABQfAcPHjSSzEMPPVSs+keOHDFBQUFm1KhRXuWrV682kszkyZONMcaMHTvWSDLLly+36vz1119GknnhhResMklm7Nix1uP8bTaPE9svt956q2natKlXm2fWrFnm5ZdfLnS9Dz74oAkMDDR//PGH13q7d+9uatWqZa1HkunUqZNXnRtvvNGEh4ef9Jh4tuU5BuvXr7eWjRgxwgwdOrTAPnz22WemS5cuJiUlxWtdrVu3Nj169LAe169f3wwfPtx6XFSb6sT22B9//GHCw8PNiBEjzG233WbCwsLMtm3bTrofQFXHmFJABbF69WoFBAR4lTmdTnXv3l1vv/221yDnDRs2VFhYmPX4iy++kMPhUJ8+fbwuTbvqqqs0a9Ysbdq0Sfv371dOTo6uueYar228+OKLhcbTqlUr1axZU1deeaUGDRqk3r17q3v37po4cWKh9VetWiVJGjp0qFf54MGDNWLECK1YsUKXX365JKlmzZpePb88A2YeO3ZMkgpcXud0OuV05nX8PO+88/TWW29Jknbv3q0xY8YoJydHc+fOVYsWLaznrFmzRhkZGbrqqqu81nfllVdKyrtkr1GjRvrhhx80fvx4r+3169dP/fr1kyQNGzZMw4YNU2Zmpn7//Xdt27ZNGzZsUG5urrKzsws9Fqfy1VdfSVKBc3Hi5ZbF1bp1a6/Hw4YN080336x9+/YpPj5ec+fOVVhYmLW9L774Qm3atFGdOnWsY+N0OnX55Zdr1qxZpxUDAAD4m6fd4nK5ilX/u+++U1ZWVoF2VOfOnVW/fn2tWLFCt99+u1XesWNH6/6J7ajT1a1bN7311ls6//zz1a9fP/Xp00fXXXddkRPtrFy5Uh07dlTDhg29yq+//nrdeOON2rp1q9XbKH+8npiLG2+nTp1Up04dzZ8/X+eff76ys7O1ZMmSQtssPXr0UI8ePZSTk6PffvtNv/32m37++WclJSWpRo0ap9zWiW2qEzVs2FAvvPCCdS6mTJmixo0bF2s/gKqKy/eACuK8887TunXrtG7dOq1fv16bNm1ScnKyPv/8c9WvX9+rblxcnNfjw4cPyxijiIgIBQQEWLeBAwdKkvbu3avDhw9LkmJjY4sVT3h4uL766iv16dNHc+fO1VVXXaWaNWvq1ltv9RojyuPIkSOSpFq1anmV+/v7KyYmRsnJyVbZid3YPQ03zxhN+fchICBATz75pFU3IiJCbdu2Vdu2bdW3b1998cUXSklJUY8ePXTw4EGvYyLlDYCef12eY7d3714dOXJExpiTHpPjx49r1KhRqlatmlq3bq377rtPO3bsUEBAgNcliSVR0nNxKif+PwwYMEBBQUHW+Atz5szRtddeax33w4cP67vvvitwnN944w2lpKQoIyOjVOICAKCqio6OVkREhDUmaGGOHTtmtZ+Kakd5yvK3oyTvttSJ7ajTNWjQIM2ZM0fh4eEaN26czjvvPDVq1KjI4QqOHDlSZLySTtn2K247yuFwaMCAAdYlfJ9++qmcTqd69OhRoK7b7dbDDz+s6OhoNWvWTKNHj9aGDRsUEhJSrO2d2KYqzMCBAxUcHCx/f3/17NmzWPsAVGX0lAIqCE+y5XRERUUpPDxcK1asKHR548aN9c0330iSDh48qGbNmlnLdu3ape3bt6tTp04FntesWTPNnDlTLpdLa9eu1cyZM/Xvf/9bjRo10kMPPeRVNzo6WpK0f/9+r4E0c3JydOjQIcXExBR7f9atW+f1uHbt2kXWjY2N1RtvvKF+/frpnnvu0Zw5cyTlHRNJmj17tpo2bVrgeXFxcapWrZocDodXMkuSsrKy9OWXX+qCCy7QI488ooULF2revHm67LLLrB5qZ5JQ8sR28OBBr2mVf/31VyUlJalz585yOBwFeoylp6cXa/0RERG6+uqrNX/+fPXo0UMbN27UCy+84LX9iy++2Kssv6CgoBLuEQAAOFHPnj21YsUKZWZmKjg4uMDyqVOn6p577tHXX3/t1Y5q3ry5V719+/apUaNGZxSLw+Eo0GursHbFkCFDNGTIEKWkpOjzzz/Xc889p+uvv15dunQp0B6Ljo62JlA5MV5JJWr7ncqgQYP08ssva/369Zo3b5769etX4AoDSXr22Wf10ksv6c0331S/fv1UrVo1SdIFF1xQarHcfffdCgkJUVhYmEaNGqXPPvus1NYNVEb0lAKqgIsvvljp6ekyxli9iNq2batNmzZp/Pjxys3NVfv27RUQEKAlS5Z4Pffll1/WgAEDCnTNXrhwoWrWrKn9+/fLz89PHTt21OTJkxUVFaVdu3YVGoOkAgNbzp07Vy6Xq9CkV1Hy70Pbtm1PmpSSpGuvvVa9evXS+++/b81M16FDBwUGBmrPnj1e6woMDNTDDz+sHTt2KDw8XG3atNGHH37otb7PP/9cvXv31q5du/T111+rW7du6tu3r5WQ+uGHH3Tw4MHT/kXScyxOPBePPvqoNZhoZGRkgePsSSwWx7Bhw/Tdd9/pjTfeUO3atXXJJZdYyy6++GL9+uuvatq0qdexmTVrlt555x35+fmd1n4BAIC/3XfffTp8+LAee+yxAsuSkpI0ceJENWnSRB06dFD79u0VFBRUoB319ddfa+fOnSVqRxUmMjJShw4d8urtfmK7YtCgQbr22mslSdWqVdOAAQM0ZswYuVwu7d27t8A6L774Yq1Zs0Y7duzwKp81a5Zq1apVqpe1dejQQfXr19fs2bO1dOnSQmfdk/KO19lnn62bbrrJSkjt2bNH//vf/7zabafb1vnwww81a9YsvfTSS5o8ebI+//xza1gJAIWjpxRQBfTu3VtdunTR1VdfrTFjxqhFixZau3atxo4dq549e1q/VCUmJmrSpEkKDg5Wt27dtG7dOr322mv617/+JX9/77eLiy66SC6XS3379tXDDz+syMhIzZs3TykpKdZ4S/m1bNlSw4cP17hx43T8+HF17dpVP/30k8aNG6du3bqpV69eZXoMXn75ZbVu3Vp33XWXfvzxR9WoUUMPPvigxowZo9TUVHXt2lV79uzRmDFj5HA4dO6550rKmy75qquu0qBBg3TjjTcqKSlJjzzyiK644gq1adNGF1xwgebPn68333xTLVq00MaNG/XUU0/J4XCc9tgN5557rgYMGKCHHnpIx48f13nnnafPP/9cixcvti65u+KKK7R06VIlJiaqb9+++vrrr71mUjyVnj17qmbNmtaMjJ6u/ZL0z3/+UzNnztSll16q+++/35pZ8O2337ZmpgEAAGemQ4cOmjBhgh5//HH98ssvGj58uGrWrKlNmzbphRdeUFpampYtWyaHw6Ho6Gg9/PDDGj9+vAIDA3X11Vdrx44dGjNmjFq2bKkRI0acUSxXXHGFXn31Vd100026+eabrRjyJ2cuueQS3Xbbbbr//vvVu3dvHT16VOPGjVOTJk2sdlN++dsT48aNU0xMjKZPn64vv/xS7733nlfbozQMHDhQL7/8smJiYqwfQ090wQUXaMKECXr22WfVsWNHbd++Xc8884yysrK82m1RUVH68ccftWrVqmL3ojp06JBuvfVWXXbZZRo+fLikvBkU77//fvXo0aPA2FoA/p+do6wDKJ7CZlorad309HRz7733moSEBBMYGGgaNmxoHnnkEXP8+HGrjtvtNi+88II566yzTFBQkGnevLk1m4sxBWdmWbt2renRo4eJjo42wcHBpm3btuaDDz4osn5ubq556qmnTKNGjUxAQIBp0KBBgRiKM/tLSffd4/777zeSzKRJk6yyN954w7Rs2dIEBgaauLg4M3ToUPPXX395Pe/jjz827dq1M0FBQaZOnTomMTHRpKWlGWOMOXz4sLnuuutMjRo1THh4uGndurV55ZVXzC233GLi4+NNbm5uiWffMyZvtrtHHnnEJCQkmODgYHPuued6zR6Ym5trHnroIRMXF2eCg4NNr169zDfffFPo7HtFbScxMdFIMhs3biywbPv27WbAgAGmevXqJiQkxJx77rnm3XffLTJeAABwepYtW2Z69+5tateubYKCgsxZZ51lbrnllgLtEWOM+fe//221W+Lj483o0aPNkSNHrOWe2fdOpBNm2zvxsTHGvPDCC6ZevXomKCjIXHjhheaHH34wQUFBXu2vV1991bRs2dKEhISY6OhoM3DgQK/Zek9c7x9//GEGDhxooqKiTGhoqOnYsaP58MMPTxrbyfbjZM9bv369kWTuueceq+zENlhmZqa54447TK1atUxISIhp1qyZGTt2rBk/frwJCgqyjuWcOXNMbGysCQoKMl999VWRbar8bc8BAwaY0NBQr9kG9+3bZ6KiokzXrl2tmbIBeHMYc5oj8QIAAAAAAACniTGlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBz/nYHYKewsDBlZmbKz89PsbGxdocDAABKSVJSklwul4KDg3Xs2DG7w0EJ0D4DAKDiONM2l8MYY8ogrgrBz89Pbrfb7jAAAEAZcTqdcrlcdoeBEqB9BgBAxXO6ba4q3VPK0+hxOp2Kj4+3OxwAAFBK9u3bJ7fbLT8/P7tDQQnlb5/F1qJ9BlQmTofdEQAobfvPsM1VpZNSsbGx2rNnj+Lj47V79267wwEAAKUkISFBe/bs4fKvCsjTPoutFa8fNv9hdzgASlF0eKDdIQAoZWc1SNDeM2hzMdA5AAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyu3CalDh48qMaNG2vlypVF1lm2bJlat26tsLAwtWjRQh999NEp15n/5na7SzlqAAAAAAAAFIe/3QEU5ptvvtHw4cP1+++/F1ln27Zt6tevn95//31dccUV+uCDDzRw4EBt27ZNderUKfQ5sbGxZRUyAAAAAAAASqDcJaWmT5+uJ554QhMnTtTgwYNPWq9z587q27evJGngwIGaOnWqpkyZovHjx5dso8f2SW8lnEHUAACUgsAI6aIJUtP+dkcCAAAAlLlyl5Tq2bOnhg4dKn9//5MmpTZv3qzWrVt7lbVs2VIbN24s+UaNW0rfU/LnAQBQ2r4ZQ1IKAAAAVUK5S0rVqlWrWPXS0tIUFhbmVRYaGqr09PSSb9ThlMLjS/48AABKy7F9eT+SZKfZHQkAAADgE+UuKVVcYWFhysjI8CrLyMhQREREkc9JSkryenzuuedq3759Uli8dOvuMokTAIBieSshr9cul5SXjmP77I4AAAAAp1Bhk1KtWrXShg0bvMq2bNmitm3bFvmcmjVrej12Osvt5IMAgKom8P9/VOGS8tJh7A4AAAAAp1Jhk1LDhg3TSy+9pPnz5+vaa6/VBx98oJUrV+qVV16xOzQAAEruogl540lx+V4pIbEHAABQ3lWopFR4eLjeeustDR06VM2bN9eSJUv00EMPaeTIkapfv74WLVqkpk2b2h0mAAAl17Q/A5yXpof9JLntjgIAAAAnUa6TUsZ4970/cRDznj17qmfPnr4MCQAAAAAAAKWAQZUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAAAAAAOBzJKUAAAAAAADgcySlAAAAAAAA4HMkpQAAQOXj8LM7AgAAAJwCSSkAAFD5hMbaHQEAAABOgaQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyOpBQAAAAAAAB8jqQUAAAAAAAAfI6kFAAAAAAAAHyu3CWlkpKS1LdvX0VFRSkmJkaJiYnKzc0ttO4rr7yihg0bKjIyUuecc44WLVrk42gBAAAAAABwOspdUmrQoEEKDw/X3r17tXbtWi1fvlyTJk0qUO+TTz7RM888o08//VSpqakaO3asBg4cqD///LPIdR88eNDr5na7y3BPAAAAAAAAUBR/uwPIb/v27Vq5cqX27Nmj0NBQNWrUSGPGjNGDDz6oBx54wKvuL7/8ImOM3G63jDHy8/NTYGCg/P2L3qXY2Niy3gUAAAAAAAAUQ7lKSm3evFnR0dGqXbu2VdayZUvt3LlTycnJioqKssqHDBmiqVOnqmXLlvLz85PD4dCsWbOUkJBgQ+QAAAAATsoYOY6nFb96SITkcJRhQAAAu5WrpFRaWprCwsK8ykJDQyVJ6enpXkmp7OxstWnTRu+9957OPfdczZ49WyNHjlTLli3VunVrX4YNAAAA4BQcx9MUP6KmDrqD1fVof/074kt1CdwrSZqf2VjPZLTTXne44pwZujvkJ10xb6VMaKTNUQM4XYeOpqnHTS/q1cevU6fzm9odDsqpcjWmVFhYmDIyMrzKPI8jIiK8yu+8806dffbZateunQIDA3XjjTeqY8eOmjZtmq/CBQAAqPS2b99udwioRL7NqaWuR/vrD3c1q2xzbrRuT7tEb0V8qaSYtzUl4gvdn95Zazf9ZWOkAM7Edxt/V4+bXtSO3YfsDgXlXLlKSrVq1UqHDx/WgQMHrLItW7YoISFB1apV86q7c+dOZWVleZUFBAQoMDCwyPUnJSV53eLj40t3BwAAAEqJw+FQnz59ZIzxKp82bZoaNGjgkxgeeOABPfXUU9bj8PBwffXVV6W6DSaiqToWLf9JI1J7aFzYd17l21xRypVTbjlkjOSQkZ/cCgosVxd1ACim9z/6Tjc/Pk2P336l3aGgAihXSakmTZqoU6dOSkxMVFpamnbs2KEJEyZo5MiRBepeddVVev3117Vhwwa53W4tXLhQK1as0KBBg4pcf82aNb1uTme52n0AAAAvy5Yt0/PPP2/b9g8ePOj1OD09XZ07dy7VbcTGxnrd9u3bV6rrR/nR5byztCV6pgYEe/e+uyxwpy4I2K9Lkvsp4tDt6pbcX0+ErdW5TevYFCmAM3FJh5b6cfE4XdvjfLtDQQVQ7rIyCxcuVG5urho2bKj27durV69eGjNmjKS8X+dmz54tSRo7dqzuuOMO9evXT9WrV9ezzz6rJUuWqE2bNjZGDwAAUHruuusuPf744/r222+LrPP777/ryiuvVExMjOrXr6/HHntM2dnZ1vK5c+eqWbNmioqK0v+1d9/RUVV7G8efSW9AKKGEQELvCNIE6UXpXRERQSkCgoKIDWliuSoqKCIWmlIFRRAQvJSAIkoTlSY1dEgogYQE0vb7B5d5GRIggcnMJPl+1pq1mH3O7P2bcxKSPLPPPi1btlT//v3Vu3dvSdKlS5fUr18/lSlTRv7+/ipatKjefvttSdL48eM1Z84czZkzR/fdd5+ka7O3wsPDNX36dIWEhNjMavrss89UqVIlSdfWCR08eLCKFSumggUL6rHHHrOZCY+cKShfLnlYTKr2q8ZdYW6XtDzPEl0o8Lm+z71Mb16urV+27ZdMCg8ePLLYo1D+AHm4W649B+7A5ebEFipUSAsXLkxzW2xsrPXfHh4eGjt2rMaOHeugygAAAByrc+fOMsboscce044dO5QvXz6b7ZcvX1azZs3UvXt3LVy4UFFRUeratatSUlL0zjvvaNOmTerVq5cWLVqkVq1a6ccff9Sjjz6qHj16SJJeeeUVHT58WFu2bFGePHn0/fffq2vXrnr00Uc1atQoHTx4UJJSrdnZrVs3DR06VGvWrFGLFi2s+1yf3f7000/r0qVL2rZtm/z8/PTCCy+oU6dO2rhxoyzcTQ03GX+5tnwsyWrqdVyS1Mr7iB712ad5P21Wo7rlnVwd7Cox2dkVwJEsLjcHBi7I5UIpAAAA/L8JEybot99+U69evbR06VKbbcuXL1dCQoLefvttWSwWFStWTOPHj1fXrl31zjvvaPr06ercubPatbu2rkenTp3UqVMn6+vHjh0rDw8P5c6dW8ePH5ePj48k6eTJkypduvQta/L391f37t31Xgjf4gAAdHdJREFU9ddfq0WLFtq7d6927NihZcuWKTIyUosWLdLevXtVsGBBSdLEiROVJ08ebd++XTVqcDkHbB1PyaW8lis2bZ5KkaeHh4zrXdiBe0EonXMYw0wppAuhFAAAgAvz9vbWt99+q/vvv18ffPCBChQoYN0WERGhyMhI5c2b19pmjFFCQoIiIyN17NgxVa9e3aa/kiVL6vTp05Ku3QTm+eef1/bt21WiRAnVrFlTktK12Hi/fv3UuHFjxcbGasaMGWrfvr2CgoK0efNmSVKdOnVs9vfw8NDhw4dThVKRkZE2z++77z7Wlcph2ngd1guxDfRIwn419zymXxODNe9qOU1sXImZFtkN5zMHSbkWTAF3QCgFAADg4kqVKqUvv/xSTzzxhJ5++mlre0hIiEqXLq29e/da22JiYnTmzBkFBQUpNDRUR44csenryJEj8vb2liQ98sgjat++vVatWiUPDw+dO3dOX375ZbpqqlmzpsqUKaPFixdrzpw5+uqrr6w1SdLevXtVuHBh6/67d+9WyZIlU/UTFBRk85wb0eQ8vX33KE4eGh7bQKdT/FXMLUaTAtaraa0x4k9aAMje+KkPAACQBTz66KPq06ePPv/8c2tb27ZtFRMTo/fff19Xr15VdHS0nnzySXXr1k0Wi0X9+vXT4sWLtWrVKiUnJ+unn37S999/b339xYsX5evrK3d3d0VFRWnIkCGSZF0o3cfHRxcvXrxlTX379tWoUaPk5uamhx56SJIUHBysNm3a6Pnnn9e5c+eUmJiot956S7Vq1VJ0dHQmHBlkRfFBn6qh10nr80G+/+jvfHMVWeBLbcs3X9199jmxOgD2cmHzx6pfo6yzy4ALI5QCAADIIj766CObOw3nzp1bq1ev1rp16xQSEqKSJUvKzc3NuvZUzZo1NXXqVA0cOFB58+bV5MmT1axZM3l5eUmSZsyYoQULFih37tyqUaOGQkJCVL16df3zzz+Sri1ovnHjRhUvXjzNenr06KHIyEg99dRTNjOcvvnmGwUGBqpatWoqUKCAli9frlWrVtnMnAIAAODyPQAAABdk0liLw8fHR3/++adNW4UKFbRixYo0+9i3b5/q1KmjQ4cOWdu6dOlivWTu4Ycf1p49e25ZQ5MmTWzWfLq5psDAQMXFxaV6Xd68eW1mdAEAAKSFmVIAAADZ1K5du9S0aVMdPHhQkhQeHq6VK1eqTZs2Tq4MSCeTIs/TB51dBQAgkzBTCgAAIJvq1KmTdu/erSZNmuj8+fMKCwvTl19+qXr16jm7NODOTIpyr5km370bFf3wIF0tU9vZFQEA7IxQCgAAIBsbOXKkRo4c6ewygIwzksWkyGJSFLhqiqIlgikAyGa4fA8AAACA63Fz08Vm/RRf/kFrMOW9f7OzqwIA2BGhFAAAAADXRDAFANkaoRQAAAAA15VGMOWz/w9nVwUAsAPWlAIAAADg2v4XTEmSz77fZdw9nVwQAMAeCKUAAAAAuL7/BVOXq7ZQUqGSzq4GAGAHXL4HAAAAIGtwc7MJpNwvRsr70DYnFgQAuBeEUgAAAACyHLfL0cq3+B0FrviExc8BIIsilAIAAACQ5aT45lZC0QrclQ8AsjBCKQAAAABZj5ubLjbrq/jy9QmmACCLIpQCAAAAkDURTAFAlkYoBQAAACDrSiOY8or4y9lVAQDSwcPZBQAAAADAPflfMCVJHlFHlHjDHfoAAK6LUAoAAABA1ve/YMqSGC/j7e/sagAA6cDlewAAAACyBzc3m0DKd+c61pgCABfGTCkAAAAA2Y7X8d3Ks26GjMVN0ZKulqnt7JIAADdhphQAAACAbCchuDx35QMAF0coBQAAACD7SeOufARTAOBaCKUAAAAAZE8EUwDg0gilAAAAAGRfaQRTHueOO7sqAIBY6BwAAABAdve/YEqSknPlV1K+ok4uCAAgEUoBAAAAyAnc3HSxeV9JFsliudZmzP//GwDgcFy+BwAAACBnsLj9fwiVeFV5l77PGlMA4ETMlAIAAACQ4/j9s0beR3fK69huRUu6Wqa2s0sCgByHmVIAAAAAcpy4ai0VX/5B7soHAE5EKAUAAAAg53Fz08Vm/QimAMCJCKUAAAAA5EwEUwDgVIRSAAAAAHKum4Kp3OtnyZIQ7+yqACBHYKFzAAAAADnb/4KpFC8/xVdoIOPl6+yKACBHIJQCAAAAADc3xTTqadNkuRon4+3npIIAIPvj8j0AAAAAuInnqf0KmjWcNaYAIBMRSgEAAADATXz+/U1uVy+z+DkAZCJCKQAAAAC4SUzDntyVDwAyGaEUAAAAANzsprvyEUwBgP0RSgEAAABAWgimACBTEUoBAAAAwK3cFEz5/rtRMsbZVQFAtuDh7AIAAAAAwKX9L5hKDApVXOWmksXi7IoAIFtgphQAAAAA3Imbm+KqtZQ8vK49N0YeUUedWxMAZHGEUgAAAACQEcYo18b5yr9gNGtMAcA9IJQCAAAAgAwxcouPYfFzALhHhFIAAAAAkBEWN11s1lfx5esTTAHAPSCUAgAAAICMciOYAoB7RSgFAAAAAHeDYAoA7omHswsAAAAAgCzrf8GUJPns3ShLcqKTCwKArINQCgAAAADuxf+CqbhKjZQYXM7Z1QBAlsHlewAAAABwr9zcbAIpt8vR8j78pxMLAgDXRygFAAAAAHZkuRKrfIvfUeDySawxBQC3QSgFAAAAAHZkvPyUWKgUi58DwB0QSgEAAACAPXFXPgBIF0IpAAAAALA3gikAuCNCKQAAAADIDGkFUyx+DgBWHs4uAAAAAACyrf8FU5LkeWqfEgsUd3JBAOA6CKUAAAAAIDP9L5iyXI2V8c3t7GoAwGVw+R4AAAAAZDY3N5tAymf/H6wxBSDHY6YUAAAAADiQ5+kDyrPqM0lStKSrZWo7tR4AcBZmSgEAAACAAyUWLKkr5epyVz4AOR6hFAAAAAA4kpubLjbrp/jyDxJMAcjRCKUAAAAAwNEIpgCAUAoAAAAAnCKNYMoj8rCzqwIAh2GhcwAAAABwlv8FU5JkPL2VFBTm3HoAwIEIpQAAAADAma4HUxbLtYckGfP//waAbIrL9wAAAADA2dzc/j+ESk5S4MrJrDEFINtjphQAAAAAuBC/XeHyObBF3ge3KVrS1TK1nV0SAGQKZkoBAAAAgAuJq9xU8eXrc1c+ANkeoRQAAAAAuBI3N11s1pdgCkC2RygFAAAAAK6GYApADkAoBQAAAACu6KZgKs/aabJciXV2VQBgNyx0DgAAAACu6n/BlPHw0pUydWR8ApxdEQDYDaEUAAAAALgyNzddatLbpsmSeFXG09s59QCAnXD5HgAAAABkIR7njqvANyNYYwpAlkcoBQAAAABZiO/u9XK/HM3i5wCyPEIpAAAAAMhCYh7szl35AGQLhFIAAAAAkJXcdFc+gikAWRWhFAAAAABkNQRTALIBQikAAAAAyIpuCqb8/lkjGePsqgAg3TycXQAAAAAA4C79L5hKyhesuCrNJIvF2RUBQLq53EypyMhIdezYUYGBgSpQoICGDh2qpKSkNPddv3696tSpo4CAABUrVkzvvPOOg6sFAAAAACdzc9PlGm1lvHytTe7nTzqxIABIH5cLpbp166aAgACdPHlSmzdv1urVq/XRRx+l2m/v3r1q3bq1Bg0apJiYGC1fvlwffPCBFi1adMu+o6KibB4pKSmZ+VYAAAAAwOH8t/6oAnNfY40pAC7PpS7fO3DggMLDw3XixAn5+fmpZMmSGjVqlF566SWNGDHCZt9PP/1UHTt2VK9evSRJVatW1W+//abcuXPfsv+CBQtmav0AAAAA4FTGyOPCKevi59GSrpap7eyqACBNLjVTateuXcqXL5+Cg4OtbRUrVtTRo0cVHR1ts+/mzZsVFham7t27q0CBAqpQoYLCw8NVuHBhB1cNAAAAAC7CYuGufACyDJcKpWJiYuTv72/T5ufnJ0mKjY21aT9//rw+/vhjPfHEEzp9+rQ+//xzvfjii7e9fA8AAAAAsr2b7spHMAXAVblUKOXv76+4uDibtuvPc+XKZdPu7e2tDh06qE2bNvLw8FDDhg3Vs2dPffvttw6rFwAAAABcEsEUgCzApUKpypUr69y5czpz5oy1bffu3QoJCVGePHls9q1YsaKuXr1q05acnCxjzC37j4yMtHkUKVLEvm8AAAAAAFzFTcGUe1y0sysCABsuFUqVKVNG9evX19ChQxUTE6PDhw9r/Pjx6tOnT6p9BwwYoB9++EGzZ8+WMUYbNmzQnDlz1LNnz1v2HxQUZPNwc3Optw8AAAAA9vW/YOp8hxGKu+8hZ1cDADZcLpVZtGiRkpKSVKJECdWpU0ctW7bUqFGjJEkBAQGaM2eOJKlp06ZaunSpJk2apDx58uipp57ShAkT1L59e2eWDwAAAACuxc1NCcWrWJ9arlyW15G/nVgQAFzj4ewCblaoUCEtXLgwzW03L3beqlUrtWrVyhFlAQAA3FbVqlVvu91iseivv/5yUDUAkDZLQrzyLXlPHlFHFP3wIF0tU9vZJQHIwVwulAIAAMiKdu7cedvtFovFQZUAwK0ZD28l5QuWZ+RhBa6aomiJYAqA09g1lIqKitKECRO0b98+JScnW9stFouWLFliz6EAAABcyuHDh51dAgDcmZubLjbrJ0ny3buRYAqAU9k1lOrVq5dWrVqV6g54fDIIAACyu9DQUJvnhw4d0t9//62aNWsqT548ypUrl5MqA4CbEEwBcBF2DaU2btyoEiVK6N1331X+/PkJowAAQI5z6dIlde/eXStXrpQkTZ06VSNHjtSaNWtUpUqVO7waABwkrWDKzV1XS9VwcmEAchK7hlIFCxZU+/bt1aVLF3t2CwAAkGU899xzWrVqlR566CH9/PPPioyMVExMjIYNG6bVq1c7uzwA+H83BFNex3YpKV+wkwsCkNO42bOz//znP/r+++/1yy+/KDIyUufPn7c+AAAAcoIlS5aob9++mjx5sowxqlChgvr376/Nmzc7uzQASO1/wdS5R8cqOW8RZ1cDIIex60ypvn37KjY2Vo0bN7Zpt1gsSkpKsudQAAAALsnDw0PJyck2yxjExcXJzc2unwUCgP24uSklIJ/1qdeRv2VJuMIaUwAynV1DqTx58igwMNCeXQIAAGQpLVq00IwZM3To0CFZLBZ9+OGH2rx5s9q2bevs0gDgjjyijirv8klSSjKLnwPIdHYNpSIiIuzZHQAAQJYzceJEHTp0SOvWrZMk/fbbb6pUqZImTpzo3MIAIB2S8ofoSpk68t37K3flA5Dp7BpKSVJMTIy+/vprRUREqHTp0nriiSfk7+9v72EAAABcUsGCBbVp0yZt27ZNhw8fVnBwsOrVq8ddiQFkDW5uutisryQRTAHIdHYNpc6cOaMHHnhAR48elTFGFotFH3zwgTZt2qT8+fPbcygAAACXtW/fPq1atUqnTp1S8eLFVbx4cRUrVszZZQFA+hBMAXAQu4ZSr7zyio4cOaLevXurVq1a2rp1q2bOnKlXXnlFX375pT2HAgAAcEnLli1T165dlZiYKGOMJOmNN97QsmXLUt0MBgBcVhrB1PmAvEosUsbJhQHITuwaSq1evVrdunXT9OnTrW1xcXFatWqVPYcBAABwWa+++qqkax/WVaxYUXv37tUHH3ygF154Qdu3b3dydQCQATcEU0pOUmKhks6tB0C2Y9dQ6sKFCypSpIhNW5EiRXThwgV7DgMAAOCyDh06pP79++utt96ytsXExGjatGlOrAoA7pI1mDKSm7uzqwGQzbjZs7Nq1app+vTp+uGHH3TixAktWbJE06dP1/3332/PYQAAAFxWixYtdPr0aZu2f//9V61atXJSRQBwj9zc/j+QMinKvXa6vPdvdm5NALIFu86UGjNmjFq3bq0uXbpY2ywWi15//XV7DgMAAOBynnvuOUmSn5+fFixYoKZNm6ps2bL666+/tH37dr3yyitOrhAA7p3vnl/ltytcvrs3sPg5gHtm11CqRYsWWrNmjf7zn//o8OHDKlGihIYNG6YWLVrYcxgAAACXM3nyZJvn4eHhCg8Ptz5/8803NW7cOAdXBQD2FV++vrxO7OWufADswq6hlCQ1bNhQDRs2tHe3AAAALm3GjBnOLgEAMl8ad+WLFsEUgLtjl1Cqffv26tmzp7755ps0t1ssFi1ZssQeQwEAALikXr163Xb7sWPHHFQJAGQygikAdmKXUGrZsmWqU6eOli1bluZ2i8Vij2EAAABc3t9//61hw4bp2LFjSkpKkiRdvXpVkZGRSkxMdHJ1AGAnNwVTeVZ/obNFyyvFL7eTCwOQldgllFq3bp1KlCih+vXr26M7AACALOvZZ5/Vxo0bU7XXqFHDCdUAQCb6XzBl3D10tUR1AikAGWaXUKpRo0aSpOLFi9u0p6SkyM3NzR5DAAAAZAk7duxQ9+7d1bZtW82fP1/Tpk1T8+bNVapUKWeXBgD25+amS02ftm1LTpTcPZ1TD4Asxa6JUUxMjAYOHChjjL7//nvlypVL5cuX1/79++05DAAAgMtKTk5W8eLFVa9ePf3xxx8qUKCAHn74Ya1evdrZpQFApnO/GKkCs1+V9/7Nzi4FQBZg11Dq2Wef1RdffKFDhw7ppZdekqenp/bv368RI0bYcxgAAACXVbZsWc2ePVvGGEnSoEGDNG/ePCUnJzu5MgDIfL4718njUqQCV00hmAJwR3YNpVatWqU2bdooOTlZhw4d0uzZs/XMM8/ot99+s+cwAAAALuvNN99UVFSU3N3d1a9fP02dOlXHjx9Xp06dnF0aAGS62LqPKL58fVlMCsEUgDuyy5pS1126dEk1atTQpk2bZLFYVK9ePW3atElxcXH2HAYAAMBltW3bVhERESpcuLDeeOMNlShRQsYYPfnkk84uDQAy30135QtcNUXRkq6Wqe3UsgC4JruGUiEhIfrxxx/l5eWlKlWq6NSpU5o1a5ZKly5tz2EAAABczvnz563/9vLysj7v2LGjpGtrb+bLl88ZpQGAY90imFK1B51ZFQAXZNdQ6tlnn9ULL7wgi8WiadOmad++fTp58qTefvttew4DAADgcoKCgm673WKxKCkpyUHVAICT3RRMBWxfpuSqdSXuzg7gBnYNpYYOHar7779fXl5eeuCBB3T06FF99913rKEAAACyvWLFislisTi7jGzDzSIF+nFL+ewlY+czt6+H5GvXP1fgDG0HKDF/ISVVb6FKbUc5uxo4iIebRV6ebjoSFa+kZOPscpCJrkRG39Pr7fK//Pnz5+Xv76/Lly+rcuXK1raAgAA1atRI58+fZ7o6AADI1iIiIpxdAgC4Hjc3JT3YxaYpxCdRx68QOgOw0933goKC9MEHHygoKCjNR8GCBe0xDAAAAAAgC+te5JLW1DymVgVinV0KABdgl5lSxYsXV548eZi2DgAAAAC4BaPqua7I002aVCFS2iP9dDbA2UUBcCK7hFKHDx+WdG2hcwAAAAAAUrPolX1BslikLoViCaYA2OfyvRvNnTtX+/fvlyQtWLBA33zzjb2HAAAAAABkQSmy6OV/g/TdmQB5WK7NmOJSPiDnsmsoNWnSJPXs2VO//fabJOmnn35S79699cknn9hzGAAAAJd25MgRjRkzRh07dtSGDRs0d+5cZ5cEAC6DYArAdXYNpSZPnqwyZcqoTp06kqTXX39dlSpV0uTJk+05DAAAgMvauHGjKleurPHjx+vHH3/U77//rp49e2rq1KnOLg0AXMbNwVRZ/wRnlwTACewaSp04cUJdu3ZV+fLlJUmlS5dW+/btdfz4cXsOAwAA4LJeeOEF5c+fX59//rmMMcqdO7cqVKigjz76yNmlAYBLuR5MDdhVSJOO5HV2OQCcwK6hVFhYmJYuXaoTJ05IurYA+uLFixUaGmrPYQAAAFzW33//rR49eqhp06aSpIIFC6pDhw46cuSIkysDANeTIot+Pucv6dpd3H3dUlQvMN65RQFwGLuGUgMGDNDOnTtVvHhxeXt7q3Tp0tq7d68GDhxoz2EAAABcVrFixbR27VpFR0dLkq5cuaL169erSJEizi0MAFyct1uKvqx8WjOrnGKNKSCHsGsoNWTIEE2cOFFly5aVh4eHypUrp4kTJ2rw4MH2HAYAAMBlPfvss/rjjz9Uu3ZtWSwWPfnkk9q0aZOefvppZ5cGAC4tMcWik1c8WPwcyEE87NmZxWLRc889p+eee86e3QIAAGQZzz//vDw8PDRlyhRFREQoODhY/fv314svvujs0gDApaXIolf2BUmSuhaO1aQKkdIe6aezAU6uDEBmsetMKUn6448/1KtXL1WvXl3Lly/X22+/be8hAAAAXNqzzz6rXbt26fLly9q/f79GjBghi8Xi7LIAwOVdD6YWnQ5gxhSQA9h1ptSSJUvUtWtXJScny2KxaMeOHRo1apSSk5M1atQoew4FAADgkm41Y9xisWjSpEkOrgYAsp60ZkyZPdJKZkwB2Y5dQ6nXX39d5cuX13vvvac2bdqoaNGiqlOnjqZNm0YoBQAAcoTJkyenars+S4pQCgDS58Zgqnn+OB274unkigBkBruGUgcPHtSwYcNUtmxZSVLu3LnVtGlTffDBB/YcBgAAwGXNmDHD+u/k5GQdP35cEydO1CeffOLEqgAg67keTIX4JOkooRSQLdk1lCpVqpQWL16s2rVrS5KOHz+upUuXKjQ01J7DAAAAuKxevXqlanNzc9NXX32lHj16OKEiAMi6UmSxCaSq57qiwt5JLH4OZBN2DaVee+019ejRQ507d5bFYtGwYcNkjNGUKVPsOQwAAECWYYzR/v379ccffzi7FADI0kr4JmhmlVPydTfclQ/IJuwaSnXv3l2BgYGaPHmyzS2QH3nkEXsOAwAA4LJy585t8/zKlStKTk5W+fLlnVQRAGQPR+I9teqsv3Xxc4IpIOuzayjVv39/derUScuXL7dntwAAAFlGbKztrcs9PDxUrlw5ff75506qCACyh7TuykcwBWRtdg2lFixYoLx586pVq1b27BYAACDLOH/+vAIDA51dBgBkSwRTQPbiZs/OevXqpaVLl2rDhg06efKkzp8/b30AAADkBBUrVtS4ceOcXQYAZFvXg6lFpwPkYZEmVYhUnTzxzi4LwF2w60ypb775RpcuXVKTJk1s2i0Wi5KSkuw5FAAAgEtyd3fnAzkAyGQ3zpjK75msPy95O7kiAHfDrqFUnjx5mK4OAABytPbt2+vzzz9XTEyMSpcuLR8fH+u2F154wYmVAUD2cj2Y8rBICcbi7HIA3AW7hlIRERH27A4AACDL+eyzzyRJM2fOlMVy7Y8kY4wsFguhFADYWYosSjDXnxm9XOK8/o7xZo0pIIuwWyi1cOFCbdiwQSVKlNCQIUPk6elpr64BAABc3tGjR5U3b16NGTPG2aUAQI7UJuiynil2UUlGLH4OZBF2CaU++ugjvfjii9ZPATdu3KjvvvvOHl0DAABkCSVKlND48eMJpQDASX6K8teivAHclQ/IQuxy973JkyfL09NTgwYNUvHixfXDDz/o8OHD9ugaAAAgSzDG3HknAECmSeuufK0KxDq7LAC3YZeZUidOnNBjjz2myZMnq3379mrZsqX27dunEiVK2KN7AACALOHkyZPavn37Lbfff//9DqwGAHKeG+/Kx4wpwPXZJZRKSEhQqVKlJElhYWGSpPj4eHt0DQAAkGV89tln1oXOb2axWJSUlOTgigAg57k5mPqwfKR2bPHRqat2vc8XADuw23elh8e1rtzd3SUxhR0AAOQ8oaGhCg0NdXYZAJDjXQ+mUmTR79EEUoCrstt35htvvKF33nnHutj5E088YQ2oLBaLLl68aK+hAAAAXFLfvn312muvObsMAIBsZ0xd5y6jZFmcVBGAm9lloXNJunr1qmJjY3X58mUZYxQfH6/Y2FjFxsYqJibGXsMAAAAAAJBhQV5JWlbjOIufAy7ELjOlUlJS7NENAABAltWoUSMu3QMAF9Yz+JLK+Sey+DngQriwFgAAwA7WrVvn7BIAALcxMSKvingnqUsh7soHuAq7Xb4HAAAAAICrSpFFL/8bpO/OBMjDIk2qEMmlfICTEUoBAAAAAHIEginAtRBKAQAAAAByjJuDqRfCLsjTYpxdFpAjsaYUAAAAACBHuR5MnbnqoTmncivRWJxdEpAjEUoBAAAAAHKcFFk0ISKfTVtBryRFJvBnMuAoXL4HAAAAAMjx2gTFan3tY6wxBTgQoRQAAAAAIMerHxgvbzfD4ueAAxFKAQAAAAByvJH7C2jRae7KBzgSoRQAAAAAIMdLkUWv7AsimAIciFAKAAAAAAARTAGORigFAAAAAMD/3BxM1cpzxdklAdkW97oEAAAAAOAG14OpjdG+WhIZ4OxygGyLmVIAAAAAANwkRRYticwlySJJ8rQY1cod79yigGyGUAoAAAAAgNvwsBh9XOGM5tx3ijWmADsilAIAAAAA4DZSjBST5Mbi54CdEUoBAAAAAHAb3JUPyByEUgAAAAAA3AHBFGB/hFIAAAAAAKQDwRRgXx7OLgAAAAAAgKziejAlSa2DLutsoruTKwKyLkIpAAAAAAAy4How9cXxQB2I83J2OUCW5XKX70VGRqpjx44KDAxUgQIFNHToUCUlJd32NTt37pSfn5/Cw8MdUyQAAAAAIEdLkcUmkCrrl6CH8192YkVA1uNyoVS3bt0UEBCgkydPavPmzVq9erU++uijW+4fFxen7t27Kz4+/o59R0VF2TxSUlLsWToAAAAAIAcK9k7UnKon9UnFM6wxBWSAS4VSBw4cUHh4uN577z35+fmpZMmSGjVqlCZPnnzL1wwaNEidOnVKV/8FCxa0eZw6dcpepQMAAAAAcqjTVz207rwfi58DGeRSodSuXbuUL18+BQcHW9sqVqyoo0ePKjo6OtX+X3/9tQ4cOKAxY8Y4sEoAAAAAAP4fd+UD7o5LLXQeExMjf39/mzY/Pz9JUmxsrAIDA63te/fu1ciRI7Vx40a5u3O3AwAAAACA89x4V76uhWM1qUKktEf66WyAkysDXJdLzZTy9/dXXFycTdv157ly5bK2XblyRd26ddPEiRNVvHhxh9YIAAAAAEBa0poxVT8w7s4vBHIolwqlKleurHPnzunMmTPWtt27dyskJER58uSxtm3ZskX79u1Tnz59FBgYaJ1B1bZtWw0aNOiW/UdGRto8ihQpkmnvBQAAAACQ89wYTO245K0/Y3ycXRLgslzq8r0yZcqofv36Gjp0qL744gudPXtW48ePV58+fWz2a9CgQaq77VksFi1btkyNGze+Zf9BQUE2z93cXCqTAwAAAABkA9eDKW83o/gU/u4EbsXlvjsWLVqkpKQklShRQnXq1FHLli01atQoSVJAQIDmzJnj5AoBAAAAALi9FFlsAqkBxaJZ/By4iUvNlJKkQoUKaeHChWlui4299TewMSazSgIAAAAA4K41zXdZL5U4ryQjFj8HbuByM6UAAAAAAMhOws/76bsz/7/4OTOmgGsIpQAAAAAAyEQpsujlf4MIpoCbEEoBAAAAAJDJCKaA1AilAAAAAABwgJuDqYnlIxXqk+jssgCncbmFzgEAAAAAyK6uB1PGSLtjvXXkiqezSwKchlAKAAAAAAAHSpFFL+0LkmSxtllkZG54DuQEXL4HAAAAAIDD/X8AldsjWQurnWSNKeQ4zJQCAAAAAMCJegZf0v25r6pqhUhpj/TT2QBnlwQ4BDOlAAAAAABwos+OBmrRae7Kh5yHUAoAAAAAACdKkUWv7AsimEKOQygFAAAAAICTEUwhJyKUAgAAAADABdwcTI0seU7ebinOLgvINCx0DgAAAMD1xF269TZ3T8nb13G1AA50PZiKTnLXvFO5dDWFuSTIvgilAAAAALgc375lb7s9pXBJpVSop6THR8sEhTioKsAxUmTR24fy27Tl9UjWhSR3J1UEZA4iVwAAAABZjtvpQ/JYN1vez9eU2x8/OrscIFM1yBun9bWPssYUsh1CKQAAAABZliXukrwm9ZMl6rizSwEyzcMFLivAw7D4ObIdQikAAAAAWZol7pI85r7h7DKATDN6fwHuyodsiVAKAAAAQJbntneTs0sAMs3Nd+UjmEJ2QSgFAAAAIPO5e2Zq926nDkpX4zN1DMCZCKaQHRFKAQAAAMh83r5KKVIqc8dITszc/gEnuzmYapo/ztklAffEw9kFAAAAAMgZUirWvzajCcBdux5Mbbvko0Wnczm7HOCeMFMKAAAAgEMkPvGGjF9uZ5cBZHkpsmjB6dxKlkWSZJHRfbmuOLkqIOMIpQAAAAA4hAkqpoQXZhFMAXZkkdF/ykZpYbWTrDGFLIdQCgAAAIDDJD/QQVc+/UdJzXoppUhpZ5cDZHmW/z1Y/BxZEWtKAQAAAHAoE1RMCcNmXHtyNf6WC5Rb4i7Jt3dxB1YGZD3X15iSpK6FYzWpQqS0R/rpbICTKwPujFAKAAAAgPN4+0ryTXOTcWwlQJZFMIWsisv3AAAAAADI4q4HU4tOB3ApH7IMZkoBAAAAAJAN3Dhjqn3BWF1NsTi5IuD2CKUAAAAAAMgmrgdTX5/Mo52x3s4uB7gtLt8DAAAAACAbSZHFJpAq5pOo5vkvO7EiIG2EUgAAAAAAZFNBXkmaW/WUplQ8wxpTcDmEUgAAAAAAZFPnEty1KdqHxc/hkgilAAAAAADIprgrH1wZoRQAAAAAANkYwRRcFaEUAAAAAADZXFrBVOO8cc4uCzmch7MLAAAAAAAAme96MCVJlQIS9FeM9x1eAWQuQikAAAAAAHKI68GUv3uKYpLdnV0Ocjgu3wMAAAAAIAdJkcUmkOpe5BJrTMEpmCkFAAAAAEAOVTcwXm+VOaskI2mP9NPZAGeXhByEmVIAAAAAAORQf0T7cFc+OA2hFAAAAAAAOVRad+UjmIKjEEoBAAAAAJCDEUzBWQilAAAAAADI4dIKpsr6JTi7LGRzLHQOAAAAAACswZQknbzqoX1xnk6uCNkdoRQAAAAAAJB0LZh6eV+QjCTJ8r9Wc8O/Afvh8j0AAAAAAGBlZNH1EMrXLUWzqpxmjSlkCmZKAQAAAACANPUIvqQGeeNVNzBe2iP9dDbA2SUhG2GmFAAAAAAASNP043n03RnuyofMQSgFAAAAAADSlCKLXv43iGAKmYJQCgAAAAAA3BLBFDILoRQAAAAAALitm4OpcaXPyt89xdllIYtjoXMAAAAAAHBH14OpmCQ3fXcmly4nM88F94ZQCgAAAED2EHfJ2RXgNgJ01dklwE4+PJhL0v+f0wD3FMXeEFC5yyIv46ZcSlCSxdi8NsZ4SrI4rFa4NkIpAAAAAA63Yeu/Gj/lR+07fEZ+Pp5q36y6xg7uIF8fr7vu07dvWTtWCHv7m78+sxWTu4ASPtwkj0l95f7PeslDSq7ZSkm93pIpUlqW04fkMWes3Df9YH1N8oOdtfOxjxUSXEBnzl7ShzNWac6PvzvvTcDpmGsHAACAVJKTk3X48GFnl4Fs6uyFGHV/4XM91bm+Dq95V+u+eVkbt+/XpK//6+zSAKRDSsV6Svhwk0xw6f9vK1VdiaN+kPuyT+X9aF55fjZYicNnKblKI0lSctXGShw2U299/J1CGg7X82/N1YSXu6l6xeLOehtwAYRSAAAAWUhYWJh8fHwUEBCgXLlyyd/fX8HBwRoxYoRSUu5+wdmjR48qICBAR48elSQ99thjmjVrVprb7CkqKsrmcS/vAVlHgby5tPent/V42wdksVh04eJlXb2apPx5A5xdGoA7SG72pBJemiuPr0fatjd4VG67f5XHqmmypCTLbdevcl83R8ltBl7b3ukFuS/9WOGbdkqSft22X017vafDx886/D3AdTCBEgAAIIuZOnWqevfubX3+zz//qFmzZvLz89O4cePuqs/ixYsrNvb/b+8dFRV1y232VLBgwUzpF64vl7+PJKlKu9E6FRWtutVK6fG2Dzi5KgB34rZ9lbzXzZElJVmJryy4YYO7dOWy7c4mRSakvCQppWxtefy9TjM+HKLqlUvqROQF/eeLFdpz8JQDq4erYaYUAABAFlelShU1bNhQ27dvV3x8vF566SUVK1ZMefPmVePGjbVlyxbrvp999plKlSqlwMBAVa1aVV999ZUkKSIiQhaLRREREerbt69++eUXvf3222rXrp3NttGjR6tevXo247/88stq06aNJOnMmTN64oknVLhwYQUHB2vAgAGKiYlx3MFAlrNl0SjtXPam3N3c9NSr05xdDoA7sFw4I0tKcqp2902LlXL/Q0p+sLOMm7tSKtZTcsPHJG/fazvkyqekLiP0yYzlKtvyVb331U+a9tZTqlEp1MHvAK6EUAoAACALS0xMVHh4uNauXauHHnpIAwcO1KpVq7Ru3TqdOXNGnTp1UrNmzXT06FEdOnRIw4YN04oVKxQdHa33339fQ4YM0alTtp9Sf/XVV2rQoIFee+01/fjjjzbb+vTpoz/++EP79++XdG3tqdmzZ6tPnz5KSUlRhw4d5Obmpv379+uff/7RiRMn1L9/f4cdD2Q9vj5eKhKUR6MHt9eaTXsUfSnu/ze6ezqvMAAZ4rZnkzwn9FRSj7G6OveMkrqMkPt/Z0ixF67tkHhV7j9P0/Z/Dik5OUXL1v2lDVv+Vfum1ZxaN5yLUAoAACCLGTRokAIDAxUYGKigoCANHjxYw4cPV9++fTVv3jy98847Kl26tLy8vPT888+rfPnymjt3rjw8PGSM0dSpU7Vx40Y1a9ZMly9fVpEiRdI9dmhoqJo3b66vv/5akvTzzz8rKSlJ7dq109atW7Vt2zZNmTJFuXLlUv78+fXBBx9o/vz5OnfuXGYdDmRBm/8+pDqPjldCYpK1LSEhSV6eHvLzveHue96+SilSygkVAsgoE5BXliO75D2oqnweKyCv8Z1kgorJbf9WSZLl6G7Jw9vmNW7ubrJYLM4oFy6CUAoAACCLmTJliqKjo62PnTt3auTIkYqOjlZCQoJKlixps3+JEiUUERGh4sWLKzw8XBEREWrbtq3y5cunYcOG6cqVKxkav1+/fpo9e7aMMZo5c6aefPJJeXp6KiIiQsnJyQoJCbGGZrVr15a3t7cOHTqUZl+RkZE2j4wEZMi6KpYuqvgriXrj06VKSEzSsVPnNfqTH9Sj/QPy8rRd9jalYn0nVQkgI0zRMkr46A+llKgq4+au5IaPKqV2O7kvmyJJcl/xmZLbDlL9WhVksVjUrkk1NahRRotWbXVy5XAmFjoHAADIJgoVKiQfHx8dPHhQ5cuXt7YfPHhQ7dq1U2RkpJKTk7V48WKlpKTot99+U5cuXVS2bFnrmlDp0aFDBw0aNEg//fSTli5dqj///FOSFBISIl9fX507d07u7u6SpKtXr+rw4cMqXbp0mn0FBQXZPHdz4zPTnCDAz1vfThyokR99r/KtXlPuAF890rKWXnz64VT7Jj7xhtw3LZYl7pITKgWQXm7/bpbHtBeVOOoHmdwFZDm+V57j2snt6G5Jksd/Z8qSkqLRw97W50Xy6/jp8+ozcob+/ve4kyuHMxFKAQAAZBNubm56+umn9dprr6lcuXIqXry4PvvsM+3atUtz587V0aNH1aJFCy1fvlxNmzZVcHCwJKlAgQKp+vLx8dHFixfTHMfT01O9evXSoEGDVKNGDWsAVrt2bZUpU0bDhw/Xm2++KXd3dw0fPlxLlizRwYMH5eHBr574f+VLFtF3nzx7x/1MUDElvDBLXh/2IpgCXIxPa9tL7zxWfC6PFZ/fcn/3NV/roQXeijFet9wHOQsfRQEAAGQj77//vh5++GE1a9ZM+fPn14IFC7Rq1SqVLVtWNWvW1KeffqoBAwYoICBADRs21KBBg/Too4+m6ufJJ5/U9OnT1aBBgzTH6du3r44cOaI+ffpY2zw8PLRs2TKdPn1apUuXVpEiRXTgwAH997//lY+PT6a9Z2R/yQ900JVP/1FSs15KKZL2rDsAQNZjMcYYZxfhLCEhITpx4oSKFi2q48eZMggAQHbBz/is6/q5Cy5aVPsPHXN2OXBVV+Ol5ERnV4EMCms6wtklwAXEGE9JLG6eXVzZNVNKvHzXv3MxhxoAAABA1uLtK8nX2VUgg7hkC8DNuHwPAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAh3O5UCoyMlIdO3ZUYGCgChQooKFDhyopKSnNfadOnapy5copV65cKlu2rKZMmeLgagEAAAAAAHA3XC6U6tatmwICAnTy5Elt3rxZq1ev1kcffZRqvx9++EGvvvqqZs2apUuXLmnWrFkaOXKkvvvuu1v2HRUVZfNISUnJzLcCAAAAAACAW3CpUOrAgQMKDw/Xe++9Jz8/P5UsWVKjRo3S5MmTU+178uRJvfLKK3rggQdksVhUt25dNWnSRBs2bLhl/wULFrR5nDp1KjPfDgAAAAAAAG7Bw9kF3GjXrl3Kly+fgoODrW0VK1bU0aNHFR0drcDAQGv7oEGDbF4bGRmpDRs26MMPP3RUuQAAAAAAALhLLjVTKiYmRv7+/jZtfn5+kqTY2Nhbvu706dNq1aqVatSooccffzxTawQAAAAAAMC9c6lQyt/fX3FxcTZt15/nypUrzdf8/vvvqlWrlsqVK6elS5fKw8OlJn8BAAAAAAAgDS4VSlWuXFnnzp3TmTNnrG27d+9WSEiI8uTJk2r/6dOnq1mzZho6dKjmzp0rb2/v2/YfGRlp8yhSpIjd3wMAAAAAAADuzKWmFZUpU0b169fX0KFD9cUXX+js2bMaP368+vTpk2rf7777TgMHDtTSpUv18MMPp6v/oKAgm+dubi6VyQEAAAAAAOQYLpfKLFq0SElJSSpRooTq1Kmjli1batSoUZKkgIAAzZkzR5I0btw4JSUlqUuXLgoICLA+BgwY4MzyAQAAAAAAkA4uNVNKkgoVKqSFCxemue3Gxc7//vtvR5UEAAAAAAAAO3O5mVIAAAAAAADI/gilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAw3k4uwBXl5KSooSEBGeXgVvw9PSUu7u7s8sAAAAAAAAZRCh1GwkJCTp8+LBSUlKcXQpuIzAwUIULF5bFYnF2KQAAAAAAIJ0IpW7BGKNTp07J3d1dxYoVk5sbVzq6GmOM4uLiFBkZKUkqUqSIkysCAAAAAADpRSh1C0lJSYqLi1NwcLD8/PycXQ5uwdfXV5IUGRmpggULcikfAAAAAABZBNN/biE5OVmS5OXl5eRKcCfXQ8PExEQnVwIAAAAAANKLUOoOWKfI9XGOAAAAAADIegilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKFUNhMWFiYfHx8FBAQoV65c8vf3V3BwsEaMGKGUlBRJ0tixY+Xu7q6AgADrw8/PT6VLl9bEiROd+wYAAAAAAECOQCiVDU2dOlWxsbGKiYnR5cuXtWrVKs2aNUvjxo2z7tOgQQPFxsZaHxcvXtQrr7yiYcOGac2aNU6sHgAAAAAA5AQezi4gS5ldU7p82vHj+heWnth61y+vUqWKGjZsqO3bt99yH09PT/Xt21evvPKK/vzzTzVr1izVPpcvX9bLL7+sb7/9VgkJCapXr54+++wzhYaGKiwsTGPHjlXv3r0lSeHh4WrSpImMMYqIiFCJEiX0wgsvaPr06ercubMWLFig77//Xg899JAkKTo6WkWKFNGGDRtUq1YtzZ8/X2+//baOHDmi0qVL65133rHuCwAAAAAAsj5CqYy4fFqKPeHsKjIkMTFRGzdu1Nq1a21mSt0sPj5eX331lS5duqQWLVqkuc+zzz6rPXv2aNu2bSpYsKAGDhyoxx57TJs2bUpXLTExMTpz5ozi4uIkSbNmzbIGTfPmzVOZMmVUq1YtrVixQgMGDNDSpUv14IMP6qefflKXLl30+++/q1KlShk8AgAAAAAAwBURSmWEf+EsMe6gQYM0dOhQ6/OQkBANHz5cgwcPtrb9+uuvCgwMVEpKihISEuTu7q6WLVtq3bp1uu+++1L1mZCQoPnz52vp0qUqVqyYJOnDDz/UgQMH0l1Xr1695OXlJS8vL/Xt21fNmzdXTEyMcuXKpZkzZ6pPnz6SpMmTJ2vgwIFq2LChJKlt27Zq166dpk6dqk8++SRDxwIAAAAAALgmQqmMuIdL6BxpypQp1svobqV+/foKDw+XJP3+++965JFHVKRIET344INp7n/+/HldvXpVoaGh1rbAwEDVrFkz3XUFBwdb/123bl2VKFFCixYt0gMPPKC//vpLP/30kyQpIiJC4eHh+uyzz6z7JyUlpXlJIQAAAAAAyJpY6Bx64IEH9OOPP2ratGkaPXp0mvsULFhQ3t7eOnr0qLUtMjJSw4cPV3x8vNzd3ZWQkGDddvbs2VR9WCwWm+d9+/bV3Llz9c0336hjx47Kly+fpGszu0aPHq3o6GjrY/fu3frqq6/s8XYBAAAAAIALIJSCJKlatWr68MMP9dZbb2ndunWptru5uenJJ5/UmDFjdPLkSV25ckWvv/66Nm3aJF9fX1WoUEFLlixRfHy8Tp8+rUmTJt1xzCeffFKbNm3S119/rb59+1rb+/fvr48//lhbtmyRJG3dulU1atTQvHnz7PeGAQAAAACAUxFKwWrgwIFq06aNnnzySV24cCHV9g8//FC1atVS7dq1FRwcrLNnz2rRokWSpHfffVcxMTEqXLiwmjRpoieeeOKO4+XLl0/t27eXp6enzaV5Xbt21dtvv62nnnpKuXPnVteuXTVs2DANGTLEfm8WAAAAAAA4lcUYY5xdhLOEhIToxIkTKlq0qI4fP26z7cqVKzp8+LBKlCghHx8fJ1WI9OBcAQBudruf8XBt189dcNGi2n/omLPLAWBH+evwITOQ3VzZNVNKvHzXv3MxUwoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSt1BDl5yK8vgHAEAAAAAkPUQSt2Cu7u7JCkhIcHJleBO4uLiJEmenp5OrgQAAAAAAKSXh7MLcFUeHh7y8/NTVFSUPD095eZGfudqjDGKi4tTZGSkAgMDrUEiAAAAAABwfYRSt2CxWFSkSBEdPnxYR44ccXY5uI3AwEAVLlzY2WUAAAAAAIAMIJS6DS8vL5UpU4ZL+FyYp6cnM6QAAAAAAMiCCKXuwM3NTT4+Ps4uAwAAAAAAIFthoSQAAAAAAAA4nMuFUpGRkerYsaMCAwNVoEABDR06VElJSWnuu2LFClWpUkX+/v6qUKGCli1bdtu+o6KibB4pKSmZ8RYAAAAAAABwBy4XSnXr1k0BAQE6efKkNm/erNWrV+ujjz5Ktd/+/fvVpUsXjR8/XhcvXtS4ceP06KOP6sSJE7fsu2DBgjaPU6dOZeZbAQAAAAAAwC1YjDHG2UVcd+DAAZUpU0YnTpxQcHCwJGnBggV66aWXUt0B7/XXX9fmzZv1888/W9tatWql2rVra9y4cWn2b7FY0mx3c3NTkSJF7PQuAACAs506dUopKSny9PTkhiVZjJeXlxITE+Xm5qbC/H4GZCsnI6OdXQIAe0uMk2Tu+ncul1rofNeuXcqXL581kJKkihUr6ujRo4qOjlZgYKDNvlWqVLF5fcWKFfXXX39leNyUlJTbzrACAABZU2JioqKiohQUFOTsUpBOycnJkq79fnaS388AAMgSrv/8ziiXCqViYmLk7+9v0+bn5ydJio2NtQmlbrVvbGzsXY1dpEgRubm53NWMOUZKSkqqyyk5J87FOXE9nBPXwzlxPWmdE2QtPj4+unLlitzd3VWwYEFnl4NMwv+fQPbE93bOExkZqeTkZPn4+NzV610qlPL391dcXJxN2/XnuXLlSte+N+93o8jISEnS2bNnVbFiRZttf/31F5+iOlFUVFSqXzw5J87FOXE9nBPXwzlxPWmdE2Qtly9fdnYJcAD+/wSyJ763kVEuFUpVrlxZ586d05kzZ1SoUCFJ0u7duxUSEqI8efKk2nf79u02bbt371bNmjVv2T/fCAAAAAAAAK7BpebQlSlTRvXr19fQoUMVExOjw4cPa/z48erTp0+qfXv27Knw8HB9++23SkpK0rfffqvw8HD17NnTCZUDAAAAAAAgI1zq7nuSdObMGQ0ePFjr1q2Tm5ubnnzySb377rtyd3dXQECAPv/8c/Xo0UOStGrVKr388ss6ePCgQkND9d5776l169ZOfgcAAAAAAAC4E5cLpQAAAAAAAJD9udTlewAAAAAAAMgZCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAu6cCBA84uAYAdJCcn6/Dhw84uAy4o24dSkZGR6tixowIDA1WgQAENHTpUSUlJae67YsUKValSRf7+/qpQoYKWLVvm4Gpzhoyck6lTp6pcuXLKlSuXypYtqylTpji42pwhI+fkup07d8rPz0/h4eGOKTKHycg5Wb9+verUqaOAgAAVK1ZM77zzjoOrzRkyck4mTZqkEiVKKHfu3Kpataq+++47B1ebs0RFRal06dK3/f+In/FAxlgsFrVp00Y33xNp5syZCgsLc0gNI0aM0Jtvvml9HhAQoF9++cUhYwM5RVhYmHx8fBQQEKBcuXLJ399fwcHBGjFihFJSUu6636NHjyogIEBHjx6VJD322GOaNWtWmtuQs2X7UKpbt24KCAjQyZMntXnzZq1evVofffRRqv3279+vLl26aPz48bp48aLGjRunRx99VCdOnHBC1dlbes/JDz/8oFdffVWzZs3SpUuXNGvWLI0cOZI/7jJBes/JdXFxcerevbvi4+MdWGXOkt5zsnfvXrVu3VqDBg1STEyMli9frg8++ECLFi1yQtXZW3rPyU8//aS3335bK1eu1KVLlzRmzBg9+uijioiIcHzROcDGjRtVt25dHTx48Jb78DMeuDsrVqzQ+++/77Txo6KibJ7HxsaqQYMGTqoGyL6mTp2q2NhYxcTE6PLly1q1apVmzZqlcePG3XWfxYsXV2xsrIoXLy7J9vv55m3I4Uw2tn//fiPJnDhxwto2f/58U7x48VT7jhw50rRo0cKmrWXLlmb06NGZXmdOkpFz8umnn5r//Oc/Nm2dOnUyzz33XKbXmZNk5Jxc16tXLzNq1Cgjyaxbt84BVeYsGTkngwcPNo8//rhN27///mtOnTqV6XXmJBk5Jx988IEJCgoyu3fvNikpKWbx4sXGx8fHHDt2zJEl5wgzZ840xYsXN/Pnz7/t/0f8jAcyTpIZMmSI8fT0NBs3brS2z5gxw4SGhlqfHzhwwLRt29bkz5/fFC9e3Lz22mvm6tWr1u3z5s0zZcuWNXny5DEPP/yw6devn+nVq5cxxpiLFy+avn37mtKlSxs/Pz8THBxs3nrrLWOMMW+88Ybx8PAwHh4epmrVqtaa1q1bZ6ZNm2aKFi1qkpOTreNMmTLFVKxY0RhjzKVLl8yzzz5rQkJCTFBQkOnWrZs5ffp0Zh0qIEsLDQ01M2bMSNXepUsX07ZtWxMXF2dGjBhhQkJCTGBgoGnUqJHZvHmzdb8pU6aYkiVLmjx58pgqVaqYL7/80hhjzOHDh40kc/jwYdOnTx/j5uZmPD09Tdu2bW22jRo1ytStW9dm7Jdeesm0bt3aGGPM6dOnTY8ePUyhQoVMkSJFzDPPPGMuXbqUeQcEDpetZ0rt2rVL+fLlU3BwsLWtYsWKOnr0qKKjo1PtW6VKFZu2ihUr6q+//nJEqTlGRs7JoEGD9PLLL1ufR0ZGasOGDapRo4ajys0RMnJOJOnrr7/WgQMHNGbMGAdWmbNk5Jxs3rxZYWFh6t69uwoUKKAKFSooPDxchQsXdnDV2VtGzkn37t1VqFAhVaxYUZ6ennrkkUc0c+ZMhYSEOLjq7O/hhx/WwYMH1a1bt9vux8944O507txZzzzzjB577DGdP38+1fbLly+rWbNmqly5so4fP65ff/1Vq1evtv6OsGnTJvXq1UsTJkzQ2bNn9cwzz2jGjBnW17/yyis6fPiwtmzZotjYWH388ccaOXKkDhw4oFGjRqlHjx7q0aNHqu/Vbt266dKlS1qzZo21bebMmerTp48k6emnn9b+/fu1bds2HTp0SLlz51anTp1SXYoIILXExESFh4dr7dq1euihhzRw4ECtWrVK69at05kzZ9SpUyc1a9ZMR48e1aFDhzRs2DCtWLFC0dHRev/99zVkyBCdOnXKps+vvvpKDRo00GuvvaYff/zRZlufPn30xx9/aP/+/ZKurT01e/Zs9enTRykpKerQoYPc3Ny0f/9+/fPPPzpx4oT69+/vsOOBzJetQ6mYmBj5+/vbtPn5+Um6Nv03PfvevB/uTUbOyY1Onz6tVq1aqUaNGnr88ccztcacJiPnZO/evRo5cqTmzp0rd3d3h9WY02TknJw/f14ff/yxnnjiCZ0+fVqff/65XnzxRS7fs7OMnJOEhARVq1ZNmzdvVlxcnL744gv16dNH//zzj8PqzSkKFy4sDw+PO+7Hz3jg7k2YMEFBQUHq1atXqlBn+fLlSkhI0Ntvvy0fHx8VK1ZM48eP16effipJmj59ujp37qx27drJw8NDnTp1UqdOnayvHzt2rL799lvlzp1bx48fl4+PjyTp5MmTt63J399f3bt319dffy3p2u8nO3bsUM+ePRUZGalFixbp448/VsGCBRUQEKCJEydqy5Yt2r59uz0PDZBtDBo0SIGBgQoMDFRQUJAGDx6s4cOHq2/fvpo3b57eeecdlS5dWl5eXnr++edVvnx5zZ07Vx4eHjLGaOrUqdq4caOaNWumy5cvq0iRIukeOzQ0VM2bN7d+P//8889KSkpSu3bttHXrVm3btk1TpkxRrly5lD9/fn3wwQeaP3++zp07l1mHAw6WrUMpf39/xcXF2bRdf54rV6507Xvzfrg3GTkn1/3++++qVauWypUrp6VLl6brDxCkX3rPyZUrV9StWzdNnDiR678zWUa+T7y9vdWhQwe1adNGHh4eatiwoXr27Klvv/3WYfXmBBk5J4MHD1alSpVUq1YteXl56amnnlLdunU1c+ZMR5WLm/AzHrh73t7e+vbbb7VhwwZ98MEHNtsiIiIUGRmpvHnzWv+gfeSRR5SQkKDIyEgdO3Ys1aLoJUuWtP47MjJSjzzyiPLnz68OHTpoyZIlkpSuxZX79eunxYsXKzY2VjNmzFD79u0VFBRkXb+vTp061pqCg4Pl4eHBnb+AW5gyZYqio6Otj507d2rkyJGKjo5WQkKCzfetJJUoUUIREREqXry4wsPDFRERobZt2ypfvnwaNmyYrly5kqHx+/Xrp9mzZ8sYo5kzZ+rJJ5+Up6enIiIilJycrJCQEOv3c+3ateXt7a1Dhw7Z8xDAibJ1KFW5cmWdO3dOZ86csbbt3r1bISEhypMnT6p9d+3aZdO2e/duVa5c2SG15hQZOSfStU/YmjVrpqFDh2ru3Lny9vZ2ZLk5QnrPyZYtW7Rv3z716dPH+kNBktq2batBgwY5uuxsLSPfJxUrVtTVq1dt2pKTk7lEwc4yck6OHj2a6px4enrKy8vLIbUiNX7GA/emVKlS+vLLL/Xaa6/p999/t7aHhISodOnSNn/MHj9+XDt37lRQUJBCQ0N15MgRm75ufP7II4+oZs2aioqK0vbt2zN099iaNWuqTJkyWrx4sebMmWO9dO/6pdJ79+61qWvbtm1q27btvRwGIMcpVKiQfHx8Ut1M5ODBgypSpIgiIyOVnJysxYsX69y5c1qxYoXmz5+vadOmZWicDh066PLly/rpp5+0dOlSm+9nX19fnTt3zvq9fObMGe3YsUPVq1e32/uEkzl1RSsHqF+/vnnsscfMpUuXzKFDh0ylSpXMmDFjUu23Z88e4+PjYxYsWGASExPNggULjI+Pj/n3338dX3Q2l95zsmjRIuPl5WVWrlzp+CJzmPSek5uJhc4zTXrPyZo1a4yHh4f55ptvTEpKilm/fr0JCAgwS5YscXzR2Vx6z8nrr79uChQoYLZt22aSk5PNwoULjY+Pj/nzzz8dXnNOcrv/j/gZD2RcWt9TAwYMMJKsC51fvHjRBAcHm/fee89cuXLFXLhwwXTs2NHcf//9xhhjtmzZYnx8fMzKlStNUlKSWbFihfHy8rIudF6kSBEzZswYk5KSYiIjI0337t2NJLNq1SpjjDHPPPOM6dix4y1rmjx5sgkNDTXFihWzWfS8TZs25tFHHzVnz541CQkJ5s033zR+fn7cBARIw60WOr9u0KBBpmrVqmb//v3m6tWrZuLEidafode/x9esWWOMMebgwYOmYMGCZv78+TaLmRtjzMMPP2yGDh1qjDGpthljzIsvvmhCQ0PNgw8+aG1LTEw09913n3n++edNTEyMiYuLMwMHDjTBwcEmPj7e7scCzpHtQ6nTp0+brl27mvz585ugoCAzfPhwk5SUZIwxxt/f38yePdu678qVK819991nAgICTKVKlczy5cudVXa2lt5zUqVKFePm5mb8/f1tHs8884wzy8+WMvJ9ciNCqcyTkXOyYsUKU7NmTZMrVy5TsmRJM3XqVGeVna2l95wkJiaaMWPGmLCwMJM7d25To0YNwnUHuPn/I37GA/cmrZ/x8fHxplq1ajZ339u9e7dp1aqVKVCggMmbN6/p3LmzOX78uHX7zJkzTYkSJUyuXLlM69atTatWrUy/fv2MMde+L8uXL28CAgJMsWLFzIgRI0z16tXNhAkTjDHGrF271gQFBZlixYqlWdOFCxeMr69vqjtpnj9/3vTv39+EhISY3Llzm7p165pffvnFjkcHyD7uFEpdvnzZjBgxwhQvXtwEBASYunXrmvXr11u3T5s2zZQpU8b4+/ubokWLmrFjx5qUlJRUwdOcOXNM7ty5Tf369dMMpfbu3WskmenTp9uMf+zYMdOtWzdTqFAhkydPHtOiRQuza9cuex4COJnFGK7xAAAAAGBf+/btU0pKisqXL29t69Kli8qXL6+33nrLiZUBAFxFtl5TCgAAAIBz7Nq1S02bNrWuRxMeHq6VK1eqTZs2Tq4MAOAquI0ZAAAAALvr1KmTdu/erSZNmuj8+fMKCwvTl19+qXr16jm7NACAi+DyPQAAAAAAADgcl+8BAAAAAADA4QilAAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAJdmsVhsHh4eHsqfP79atmyp3bt3O6SGxo0by2KxaOvWrZKksLAwWSwWnT171iHjAwAAZEV79uxxdgkAXByhFACX5+XlpfHjx2v8+PEaNWqUypQpo1WrVqljx47iBqIAACCnuPnDOm9vb5UsWVIffvih3ce6+UM4i8WigICAdL32+PHjqlevnkaMGHHX40dERMhisahy5cppbp85c6YsFosGDx6crv7u9UPF3r17y2KxaNGiRXf1egBpI5QC4PI8PT31+uuv6/XXX9eYMWO0atUqSdL+/futv1gcOHBAbdu2VWBgoAoWLKihQ4cqISHB2sfWrVvVrFkzBQYGqkCBAurevbv1tZcvX9ZTTz2lggULysvLS0WLFtWrr75K4AUAAFzO9Q/rxo4dq27duun48eMaPny4FixYkKnjjh8/XqNHj07XvgcOHNCmTZsytR4A2QOhFACXZ4zRgQMHdODAAe3evVuTJk2SJBUtWlQFChRQXFycWrRoodWrV+uJJ55Q06ZNNWnSJD3//POSrn1a17RpU23atElPPvmkGjdurPnz5+uxxx6TJL3yyiuaOXOm6tatq5deeknu7u76z3/+ow0bNjjtPQMAAKTl+od1Y8aM0ddff61+/fpJkvX3lrCwMAUGBmrIkCHKnTu3+vbtK0maN2+eKleuLF9fX1WuXFk//PCDtc+EhAS99NJLCg4OVv78+TV69OhUH86NGjVKb7zxhvX5/v371aFDBwUFBSkwMFBt27bVwYMHFRERoSZNmkiSli9fLovFYh1j1KhRCgsLk6+vr5o1a6Zdu3ZZ+zt16pS6du2qwMBAlSxZUt99912Gjkt6P2ScPXu2ihUrpvz586t37966ePGiddvtjhGAzEEoBcDlxcXFqUyZMipTpowqVaqkMWPGqHr16lq8eLEsFouWL1+uiIgIPfLIIxo6dKjefPNNVapUSTNmzFBcXJzmzJmjmJgYvfLKK/r444/17bffasqUKXr55ZdljNG7776rrVu3as6cOWrdurUqVaokSTp27JiT3zkAAICt6x/W/fvvv/r555+1fPlySdfCqOsuXryon3/+Wf3791enTp20YsUKPf7440pKStLQoUNljFGXLl2ss5neeustvf/++/L391e/fv30ww8/6OjRo7esITY2Vs2bN9fy5cvVoUMHde3aVcuXL1fr1q2VN29ePf3005KkcuXKafz48ZKkkSNH6s0331Tp0qU1ZMgQ7dixQ82bN7eGQt27d9d3332n6tWrq2vXrnrnnXcydFzS+yHj+++/r8cff1wlS5bUrFmzrJf/3ekYAcgcHs4uAADuxMfHR7NmzdKWLVv00UcfKSwsTNOnT1e1atUkSYcPH5Z07ZOv2bNn27x27969OnLkiCSpVKlSkiQ3NzcNHDjQus+BAwf0/PPPa9u2bSpfvrySk5MlSUlJSZn91gAAADLk+od1N+rQoYOee+45m7apU6daZyy1adNGkvTOO++oSpUqatCggdq0aaMpU6aobt261t+ffvrpJ5UuXVrDhg1T0aJFrb8T3Wz58uU6evSonnrqKX311VeSpPr16ysoKEg+Pj7q2bOnpk+frtKlS+v111+XMUafffaZcufOrcmTJ8vDw0O+vr564403tGjRIj300ENav369QkND9d///lceHh6qU6eOunbtmu7j8u6776p3794qV66c/v77b23btk3Hjh1L9SHj7Nmz1aRJE128eFFFihTRggULNHPmTH366ae3PUYAMgehFACX5+7urkcffVSPPvqoihcvrueee06NGzfW77//rvLlyys4OFiS1L59e/Xs2VOStHPnThUvXlzFixdXaGiopGsB1XUvvPCCvLy8NHbsWLVt21YnTpzQ0aNHVbRoUT377LP6559/HP9GAQAA7sDHx0fffPON3Nzc5Ovrq7Jly1o/eLvRjcHV9Q/wOnfubLPPX3/9JenapXOenp4qXbq0JKlQoUIqUKCAzpw5k2YNN3/gJ11bCPxWoqKidPnyZUlShQoVUtVQpUoVSVLZsmXl4XHtT9TrM9fTK70fMpYrV06SlCdPHgUHB+vgwYM6d+7cHY8RgMxBKAUgSxkyZIg2bdqkefPm6ZFHHtGWLVvUoUMHFSxYUGvWrFFoaKji4uI0ffp0lS1bVr169VKPHj301ltvacKECYqOjtb58+c1d+5cNWrUSD4+PkpJSVFKSoqGDRum/PnzWz/xu3r1qpPfLQAAgC13d/d0zSDy8fGx/js4OFh79uzRRx99pJCQEF26dEknT57UfffdJ0kqVqyY9u3bpwMHDqh06dI6ffr0be9Sl9YHfm+//bbOnTunl156ybqO1PX1nPLnzy9vb2/5+Pjoyy+/lMVi0fHjx2WMUYMGDVS0aFFJ0r59+5ScnCx3d3ft3LkzQ8clvR8y7tixQ8HBwYqJidGpU6fk6+uroKCgOx4jAJmDNaUAZDlffPGFypUrp507d+rFF19Urly59PPPP+uBBx7QtGnTtHDhQrVt21arVq2Su7u7QkJCtHbtWtWtW1dff/21fv75Zz3++OP69ttvJV27pXCFChW0dOlSrVu3znpp3+bNm535NgEAAOyif//+kqSvvvpK27dv1xdffKFRo0ZZZwFdXwOqZcuWevnll9W8efPb9temTRsVL15c8+bN09NPP62BAwdq1KhRWrJkiQoUKKBcuXJJkrZv364XXnhBKSkpevrpp3Xx4kVNnz5dW7du1Ycffqjhw4crPj5eRYoUUatWrXTkyBE1adJEI0aM0KBBgzL0Hm/8kHHgwIH64osvJNl+yOjm5qZevXrpxRdfVIsWLRQXF6ennnpKFovljscIQCYxAAAAAACXJ8n4+/vfdp/Q0FAjyURFRdm0f/rpp6Z06dLG09PTFCtWzIwZM8YkJycbY4xJTEw0r7/+uilSpIjJnz+/GT16tGnatKlNPzePvW/fPtOuXTuTL18+ExgYaNq2bWv2799vjDEmOTnZdO7c2fj6+poiRYqYM2fOmPj4eDNkyBBTqFAh4+XlZSpXrmwWLFhg7S8qKsp069bN5MmTx5QqVcosWrTIuLu7m0qVKqX5PmfMmGEkmWeffdYYY8x///tfU6FCBePt7W3KlStnhgwZYiSZp59+2npc8uTJY+bNm2dCQ0NNvnz5TP/+/U1sbGy6jlGvXr2MJLNw4cI7nygA6WYx5qZ7ZAIAAAAAAACZjMv3AAAAAAAA4HCEUgAAAAAAAHA4QikAAAAAAAA4HKEUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAAAAAAAAOByhFAAAAAAAAByOUAoAAAAAAAAORygFAAAAAAAAhyOUAgAAAAAAgMMRSgEAAAAAAMDhCKUAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4QilAADZSr9+/VSiRAl98803GX7tmDFj9Msvv9i9pt69e6t48eJ6//331bhxY82cOVMzZ85U79697T5WekydOlVTp069434XL15Uhw4dVKVKFVWrVk2rV6+2bvvggw9Uvnx5lS1bVt99991t+5k5c6YaN258230sFosiIiLUu3dvzZw5Mz1vw+769u2rrVu3pnv/W53DmJgYlSpVSuHh4da2F198UZUqVVKlSpU0d+7c2/Y7duzY235tREREyGKxSJIaN25sM44jtW7dWidPnkz3/mPHjtXYsWNTtR8/flz58uVTRESEJOnYsWNq0qSJ7rvvPtWpU0c7duyQJOv3zq3c+HV2/fg42smTJ9W6det07Tt37lxVrVpVVatWVadOnXThwgWb7Td+L1w/57/88osqVqyosLAwO1cOAIBzEEoBALKVmTNnau/everZs2eGX7t+/XolJydnQlXSG2+8oREjRsjX11d+fn6ZMkZ6DRgwQAMGDLjjfm+99ZYqVaqkf/75R3PnztWTTz4pSdqyZYu+/vpr/fnnn/r111/14osv6uzZs7fsJz3v2cfHx+nH5auvvlLNmjXvuN+VK1f06quv6rnnnktz++DBg20ChrVr12rjxo36+++/tWbNGj377LOKi4u7Zf93Ol6+vr7y9fW9Y52ZbcWKFQoODr7jftHR0erbt6/ee++9VNtSUlLUt29fJSQkWNuGDx+u7t2766+//tKYMWM0aNAgSek7Ls7+GgoODtaKFSvuuN+JEyf00ksvac2aNfr7779VsWJFa2B34sQJdejQQd9++611/+vnvEGDBunqHwCArIJQCgCQbbRv315JSUmqU6eOTp48qXnz5qlmzZqqVq2aevTooZiYGEnS5MmT9cADD6hKlSqqUaOG9uzZoxkzZmjr1q3q27evduzYYTMDJSIiwjozoXfv3mrbtq0qVKigRYsW6c8//1SjRo10//33q2nTptq7d6+ka7ORRo8enarGevXqqWrVqpKkgwcPqkmTJipTpoy6dOmihIQExcfHq2vXrqpevboqVqyozz//XJK0c+dONWnSRLVr11aJEiX02WefpXkMGjdurGHDhqlOnToqU6aMfvrpJ7Vu3VrFihXTBx98IMl2xkr+/PnVunVrValSRVeuXLHp691339Ubb7whSTpy5Ijy5s0r6VoY0aVLF/n6+qpgwYJq2rSpfvzxRyUlJalfv36qW7euSpUqpY4dOyouLk6VK1dW/fr1b3vuOnXqpIIFC1r7r127tkJDQ/Xmm29Kkg4cOKAHH3xQ1apVU40aNfTbb79JkhYuXKi6deuqWrVqqlixon799dc0+w8KCtKzzz6rqlWrqmnTplq4cKEaNGig0NBQrVu3znrswsPDFR4erlq1aqlmzZrq3r17qr7WrVun5ORkvfvuu6m2LViwQLly5bKeY0lKSkrS1atXlZiYqKtXr8rb21uSdOnSJT3yyCOqW7euSpQooT59+sgYo+rVq6tOnTq3PFaFChVSp06drM9nzJihmjVrKiwsTNOmTZMk/f7776pdu7aqVq2qBx98UPv27ZOU9tf+zSIiIlS1alU9/vjjKl++vLp3764vvvhCdevWVdmyZbVr1y5JUlhYmCIiIqwzlKpWraoXX3wxVX+LFy9WmTJlNHz48FTb3nvvPTVv3lwFChSwts2fP199+/aVJB09etT6dXfj905abv46GzRokKpVq6YKFSpoy5YtkqQvv/xS9913nypVqqSuXbsqPj7+ll+3N5s5c6a6dOmiZs2aKTQ0VB9++KGGDh2qKlWqqFGjRoqPj7/t/xU3cnNz0+eff66goCBJUvXq1XX06FFJ0jfffKN27drp0Ucfte5/8zkHACDbMAAAZCPXf7Tt2bPH1K9f38THxxtjjHnzzTfNiy++aC5evGiaNGli4uLijDHGjB071gwePNgYY0yjRo3MunXrUv378OHDJjQ01BhjTK9evUyPHj2MMcYkJCSYatWqmYiICGOMMb/++qupWbNmqpp69eplZsyYYdM2Y8YMExISYqKiokxycrKpWbOmWbZsmVmyZInp1KmTMcaY48ePm549expjjHn++efNzz//bIwxJiIiwgQEBKT5/hs1amSGDBlijDFmzJgxplSpUuby5cvm0KFDJjAw0No+ZswY6/H673//e9tj2rRpU+Pu7m6mTZtmjDGmf//+5ssvv7RuHzlypHnrrbfM+vXrzYABA4wxxqSkpJimTZuaRYsW3bbvm/Xq1cu0adPGJCcnmzNnzhhfX19z6dIlM2zYMDNp0iRjjDErVqww7733nklOTjZNmjQxUVFRxhhjZs6cadq2bZtmv5LMd999Zz1G3bt3N8YYM336dNOxY0dr+7p168y6detMrly5zPnz529b64wZM0yvXr2sz48cOWIeeOABExcXZ/P1k5KSYrp06WLy5ctnvL29zcSJE40xxsydO9eMHz/eGGNMYmKiKVOmjNm6dWuGjlejRo2sx/yvv/4yBQoUMMYY06lTJ7NkyRJrnbNmzbrt1/6NDh8+bCSZrVu3mqSkJFOyZEnzyiuvGGOMGT16tBk6dKgxxpjQ0FBz+PBhM2PGDFOiRAmTkJBw21pv/LozxpitW7eaFi1amOTkZGtfNypdurTx9vY2K1euzNAxMeba+Z4/f74xxphJkyaZrl27GmOMyZ8/v7lw4YIxxpjhw4eb7du3p/vr9vr37MWLF63H6HptjRo1Mj/88MMt/6+4ncuXL5v777/fTJ8+3aY9rf83jLH9/wgAgKzOw5mBGAAAmWX16tXat2+fHnjgAUlSYmKiSpUqpdy5c2vOnDmaN2+e9u3bp1WrVqlatWoZ6rtevXqSpH///Vf79u1Thw4drNuioqKUkJAgLy+vO/bTsGFD6wyRihUr6uzZs2rRooWGDBmiVq1aqVWrVnr//fclSRMmTNCKFSv0zjvv6K+//lJsbOwt+23btq2kazNZHnjgAfn5+alEiRKKjo6+7fu5lTVr1ujIkSOqV6+e6tatq5SUFJs1e4wxcnNzU8OGDRUYGKhPP/1Ue/bs0d69e29b56106NBBbm5uKliwoIKCgnT+/Hm1atVKjz/+uDZv3qxWrVppyJAhcnNz0/fff68ff/xR+/btU3h4uDw8bv2rzY3H5fqMmhIlSqRay0eSypcvb52hkx4pKSnq06ePJk+enOrSuunTp8vDw0OnT59WVFSUmjRpojp16qh79+767bffNHHiRO3evVtRUVF3dbw6d+4sSapSpYr1MsoOHTqoX79++vHHH9WmTRu1a9dO7u7u6f7aL1KkiGrUqCFJKlasmJo1aybp2vFKaw2rmjVrytPTM901x8XFadCgQVq4cKHc3NKeuL9//37t2LFDDz30kPbu3at8+fKlu3/J9rgsXrxY0rXj8sADD6h9+/bWGYmS0v1126BBA+XOnVu5c+eWJOtxCQsLS/Pr6E7fW+fOnVPHjh11//3366mnnsrQ+wMAIDvg8j0AQLaUnJysRx99VDt27NCOHTu0efNmzZw5U0ePHlXdunUVExOj1q1bq3fv3jLGpHq9xWKxticmJtpsu75uTXJyskqWLGkd488//9Qff/yRrkBKks0f8dfHCw4O1t69ezVw4EDt3btX999/v6Kjo/XII49o6dKlqlixot555x3r61q3bq1q1aqpWrVq1kWnbxz/diHNze9n9OjR1r6WLl2qtWvXKjIyUpIUGhqqevXqadeuXQoJCdGpU6esrz99+rSCg4P1ww8/6IknnpC/v7+efvppNWzYMM1jezfHpUWLFtq9e7eaN2+uBQsWqF27doqNjVWtWrV09OhRNWrUSM8//7yMMTp58qT1fdy46HRGjsuNaxOldYxvtnfvXu3du1d9+vRRtWrVrJeCrl69Wt9//7169OghT09PBQcHq127dvrll180adIkvfLKKypYsKCee+45VaxY8Z6O141BYa9evbRlyxbdf//9+uijjzRgwIBbfu1v3brV+v6uXzZ389dwRo7X9b5uF/b+8ssvOnPmjNq3b289rq1bt9bu3bu1ZMkSxcfHW/sKDQ3VoUOHMnRMJNvjcv24Tps2TfPmzVNgYKCeeOIJzZ49+5Zft1OnTrW+j+s3Brjb45LWMT5y5IgefPBB1atXT1988UWG3x8AANkBM6UAANlS48aN9f7772vkyJEqXLiwhg0bJn9/fzVo0EBly5bV888/r/j4eI0ZM0YhISGSrv2BmZSUJOnaWkt///23mjRpYp1lcbPy5cvrwoULCg8PV+PGjTV37lxNmDBBf/75513XPXfuXK1atUqzZs1S69attWbNGh07dkxr1qzRnj17VLRoUesfyMnJyXZd9PiNN96wriElXVuwe8WKFZowYYJOnDihzZs3a8KECSpevLj69eunYcOG6fLly1q9erXeeOMNvfvuu+rWrZt69+6tw4cPKzw8XM2bN7dLbQMHDlT16tXVv39/NW3aVNWrV9e+ffvk7u6uV199VcYYPfnkk0pOTlZwcLD1jm32kJ5jXLFiRR07dsz6vHHjxho7dqwaN26stWvXauHChWrbtq3i4uK0du1aTZgwQRMnTtQzzzyjxx9/XNu2bdOOHTvsttB+69atNXToUA0cOFCVKlXSsGHDtHXr1jS/9mvWrGlzvK7fBe9upefYP/zwwzbjhIWFacWKFQoLC9NLL72kY8eOafDgwfrnn3905swZVahQ4Z5qkq7NzqpSpYp+//13vfbaa0pKStKff/6pxMTENL9ub74hwL3cFfLmY3z16lU9/PDDGjBggIYOHXr3bwoAgCyOmVIAgGzpvvvu07hx49S8eXNVqlRJ58+f1/jx4/XQQw/JGKMSJUro/vvvV7ly5ayzMNq0aaNnnnlGGzZs0Msvv6zPP/9c1atX19WrV9Mcw9vbWwsXLtTLL7+sqlWravLkyZozZ46kWy90fiedO3fWlStXVKlSJdWqVUtdunRRlSpVNHbsWNWqVUsVKlRQeHi4SpQocVezRzLizTff1KFDh1SlShW1a9dOn3zyiUJDQ1W7dm09+eSTqlWrlho0aKA333xTRYsWVb9+/TR37lyVL19eXbt21YMPPpiqxr59+2rp0qUZrmX48OGaOXOmqlWrps6dO2vq1Km67777VL16dYWFhalSpUoqUKCAIiIi7mq2UWYaOXKkLBaLypcvrzp16ujxxx9X06ZNNXToUI0ePVoVK1bU888/n+bxat26tbZu3ZrhMceMGaNXX31V999/v0aMGKEPP/zwtl/7rmTKlCn64YcfdN9996lfv36aP3++/P39rduvz4TLKD8/P40cOVKNGjVSjRo19Msvv+iFF15I19etvX399dc6cOCA9Wu6WrVqXL4HAMiRLMbVfnMDACCb6d27txo3bqzevXs7uxSn++677+Tr62tzWR1u7YMPPlCrVq1UsWJFZ5fiUp5++mlNnz7d2WU4RUREhBo3bnzPM9oAAHAFzJQCAMABRo8ebV20PCdLSUmx2yV9OUHhwoUJpG5y+fJltW/f3tllOMUvv/xCoAsAyFaYKQUAAAAAAACHY6YUAAAAAAAAHI5QCgAAAAAAAA5HKAUAAAAAAACHI5QCAAAAAACAwxFKAQAAAAAAwOEIpQAAAAAAAOBwhFIAAAAAAABwOEIpAACQ5RljnF0CAAAAMohQCgCAHO6RRx5R3rx5UwU7O3bskMVikZ+fn65cuWKzbefOnbJYLJo6dWq6xoiIiJDFYtHMmTPTXVd6X7N06VL16tXrtvv07t1bFotFFotFTzzxxG333bFjh1q3bq2goCDlz59fDz30kLZv326zT1JSkl577TUVK1ZMvr6+qlu3rjZu3Jiu95UeM2fOVJUqVeTj46OwsDCNGzdOycnJdul75cqV1mNx46Nly5b33HdSUpL+85//qEyZMvL391e1atW0YMEC6/bXX3/dOl7jxo3veTwAAJC1EUoBAJDDNW/eXNHR0dq9e7dN+8qVK5U/f37Fx8dr/fr1Nts2bNggSXrooYfSNUaRIkW0adMmtWnTxj5F3+DDDz/U0aNH77hf4cKFtWnTJo0bN+6W+xw8eFANGzZUXFycpk2bplmzZikxMVH169fXv//+a93v+eef16RJk/Tyyy/r22+/lY+Pjx5++GHt27fvnt/Pp59+qqeeekotW7bUihUr1K9fP7311lsaNWrUPfctXQvd8ubNq02bNtk8Jk6ceM99jx07ViNHjtQTTzyhJUuWqG7dunrssce0aNEiSdKAAQO0adMmVa9e/Z7HAgAAWZ+HswsAAADO1bx5c0nSxo0bValSJWv7qlWr1LlzZ61Zs0YrV67Uww8/bN22YcMGlSpVSiVLlkzXGN7e3nrggQfsW3gGpaeGSZMmydfXV8uXL5e/v78kqWnTpgoNDdUnn3yiyZMn69ixY/riiy80adIkDRo0SNK1cK5s2bJ677339NVXX911jZcvX9arr76qESNG6L333rOOf+HCBa1evVpvv/32Xfd93Y4dO3TfffdlyvmYPn26Hn/8cY0ZM0bSta+tP//8U59++qm6du2qkJAQhYSEKHfu3HYfGwAAZD3MlAIAIIcrVaqUwsLCbC4/i42N1W+//abmzZvroYce0qpVq2xe88svv9jMkjp69Ki6d++ufPnyyc/PT82aNdOff/5p3Z7WpXibNm1Sw4YN5e/vr+LFi2vSpElq3ry5evfubTPWqVOn9MgjjyhXrlzKly+f+vfvr8uXL0uSGjdurPXr12v9+vWyWCwKDw+XJIWFhd3V5WEVKlTQiy++aA2kJMnPz08hISE6ePCgJGnNmjVKSkpS586drft4e3urbdu2WrFiRYbHvNHPP/+smJgYDR482KZ9woQJ2rx58z31fd2OHTtUrVo1u/R1s6tXr6YKnAoUKKBz585lyngAACBrI5QCAABq1qyZTSi1du1aJSUlWUOpPXv2WC+RO3DggE6ePGkNpc6ePat69epp27Ztmjx5subNm6eUlBQ1bNhQe/bsSXO8vXv3qlmzZpKk+fPna9y4cXrnnXf066+/ptp31KhRKlasmJYsWaLnn39eX375pXUmzpQpU1S9enVVr15dmzZt0v333y9JWrx4saZMmZLh4zBw4ECNGDHCpm3fvn3auXOnKleuLEnas2ePAgICVLhwYZv9SpcurVOnTik2NjbD4163Y8cO5cmTR1FRUWrYsKG8vb1VuHBhjRs3TikpKXfd73VxcXHav3+/Dh48qPvuu09eXl4KDQ3VhAkT7LJY/AsvvKCvv/5aK1eu1KVLlzRnzhytXLlSPXv2vOe+AQBA9sPlewAAQM2bN9e0adN0+vRpFS5cWCtXrlStWrWUL18+NWvWTB4eHlq5cqX69++vDRs2yMPDQ02bNpUkffTRRzp37pw2btyo0NBQSVKrVq1UoUIFjR49WgsXLkw13ttvv63cuXNr5cqV8vPzkySVL19e9erVS7Vv165d9eGHH0q6dinbf//7X61du1aSVLFiRevMnBsvR7PXmkVxcXHq1auXfH199dxzz0mSoqOjlSdPnlT75sqVS5J06dIlBQQE3NV4UVFRSkpKUuvWrTV06FCNGzdOP//8s9544w3FxcXp3Xffvfs3I+nvv/9WSkqK9u/fr/Hjxytv3rxasmSJXnrpJV24cEFvvfXWPfU/ZMgQ/fLLL2rVqpW17emnn04V9AEAAEiEUgAAQNfCHovFot9++02dO3fWqlWrrHepy507t+rUqaPVq1erf//+Wr9+verUqWMNg9asWaNq1aqpaNGiSkpKkiS5ubmpVatWmj17dprjrV27Vm3atLEGUpJUt25dhYWFpdq3QYMGNs9LliyZ5oyqjEhJSbGZeWSxWOTu7m6zz6VLl9ShQwdt3bpVixcvVrFixayvtVgsqfq8PtPIze3uJ6InJCTo8uXLeuONN/TCCy9Ikpo0aaILFy5o4sSJev31163h1+0YY1Ldrc/d3V3ly5fXTz/9pFq1ail//vySrs2Si4+P14QJE/TSSy+lGbilx9WrV9WgQQOdPn1aU6dOVfny5fXrr7/qrbfeUkBAgCZNmnRX/QIAgOyLy/cAAIAKFiyoKlWqaOPGjdq/f78OHTpks7D5ww8/rPDwcBljUq0nde7cOf3+++/y9PS0eXz66ae6ePGi4uLiUo0XFRWlggULpmq/+ZI4STbrO0nXQp97vZTt6aeftqm1VKlSNtuPHTum+vXra9OmTfr222/Vtm1b67bAwEBdunQpVZ/XL9u721BH+v/ZVjeOJ0ktW7ZUQkJCqjsk3sr69etTnY/169crMDBQLVu2tAZS17Vp00YJCQm3vNwyPb777jv9/fffmjNnjp555hk1atRII0eO1Pvvv6+PP/5Y//zzz133DQAAsidmSgEAAEnXLuH7448/VKpUKeXJk0d16tSxbnvooYc0evRorVu3TocPH7YJpQIDA9WoUSNNmDAhzX69vb1TtYWEhCgyMjJVe2RkpMqVK2eHd3N7Y8eOtVlM/MYa//77b7Vs2VLx8fFauXJlqgXTy5Urp0uXLikqKkpBQUHW9gMHDigsLEy+vr53XVeZMmUkXZt1dKPExERJSnffNWrU0JYtW1LVvW3bNm3ZskXPPPOMzWyv+Ph4SdcWJb9bR44ckSQ9+OCDNu2NGjWSJO3evVtVqlS56/4BAED2QygFAAAkXbuMa+rUqSpUqJCaN29ucznb9fWlpk6dqsDAQNWqVcu6rVGjRpozZ47Kli1rc+e1oUOH6sqVK5o6dWqqsRo1aqQVK1boypUr8vHxkXRtke/Dhw+nulzvTtzd3VNdqnYnYWFhaV4qeOzYMbVo0UIeHh7auHGjKlasmGqfFi1aSJIWLVqkgQMHSroWIi1btkwtW7bMUB03a9mypSwWi+bNm2cT4CxdulT58+dXhQoV0tVPrly5VLNmzVTtf/31lwYOHKiyZcta1wSTpAULFqh48eIqUaLEXddevnx5SanvzHh9Af176RsAAGRPhFIAAEDStaAoMTFRy5Yt0+TJk222ubm5qVmzZvrhhx/Uvn17m8DqhRde0DfffKPmzZvrxRdfVP78+bVgwQJ9+eWX+uijj9Ic67XXXtP8+fPVqlUrDR8+XNHR0Xr99ddlsVgyvCZTYGCgNm3apLVr16p69erKmzev/vzzT3l7e6cZKt3Oc889p8jISE2dOlWXLl3S77//bt2WO3duVaxYUaGhoerVq5eGDRum+Ph4lS1bVh9++KGio6PveUHvkiVLavDgwXrvvffk6emphg0batmyZZo9e7Y++eQTeXp63lP/3bp10/vvv6+ePXvqzTffVJEiRTRnzhwtXbpUCxYsSLWuVka0b99ederU0RNPPKFx48apfPny+uOPP/Tmm2+qXbt2ql279j3VDgAAsh9CKQAAIOna2k0PPPBAqpku1z388MNauHBhqm3BwcH67bff9Oqrr2rAgAG6cuWKypYtq2nTpunpp59Oc6zSpUtr1apVGjFihLp27aqCBQvqtdde05tvvpnhO9cNHjxYW7duVatWrTRjxgw9/vjj6tSpk8LCwhQeHp7ufhISErRs2TJJ0oABA1Jtb9SokbW/zz//XHnz5tW7776r2NhY1ahRQ//9739VunTpDNWelokTJ6pYsWL6/PPP9Z///EclSpTQl19+qb59+95z3/7+/lq7dq1GjhypUaNG6ezZs6pcubK+//57dezY8Z76dnd3188//6yRI0dq/PjxOn/+vEqWLKnXX3/dumg7AADAjSzm+q1iAAAAHGTNmjXy8vKyuVTvwoULKlSokCZMmKDnnnvOruP17t1b4eHhioiIsGu/uDvX1+nKSGgIAACyH+6+BwAAHG779u166KGHNHHiRG3YsEHff/+92rZtq8DAQHXv3j1Txrx69ap+//13HTx4MFP6x50dP35cv//+e5p3LwQAADkPl+8BAACHGz58uK5evarPPvtMR48eVUBAgBo3bqxZs2bZ3NHOnk6fPq26deuqR48emj17dqaMgdubOnWq3nrrLUn/f1c+AACQc3H5HgAAAAAAAByOy/cAAAAAAADgcIRSAAAAAAAAcDhCKQAAAAAAADgcoRQAAAAAAAAcjlAKAAAAAAAADkcoBQAAAAAAAIcjlAIAAAAAAIDDEUoBAAAAAADA4f4PUAbD1Gg+U20AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weight_int = np.array(weight, dtype=int)\n",
    "plot_metrics(testdata_weight, feature, weight_int)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "igem",
   "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.8.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}