notebooks/openml.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "import openml\n",
    "import sklearn\n",
    "from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import re\n",
    "\n",
    "import pickle\n",
    "import category_encoders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprocessing Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1793/1793 [20:20<00:00,  1.47it/s]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Downloading additional data from OpenML\n",
    "'''\n",
    "df_openml = pd.read_csv('df_openml_all2.csv', index_col=[0])\n",
    "\n",
    "uniq_task_id = list(set(df_openml['task_id']))\n",
    "tasks = pd.DataFrame(columns = openml.tasks.list_tasks(task_id = [uniq_task_id[0]], output_format=\"dataframe\").columns)\n",
    "for i in tqdm(uniq_task_id):\n",
    "    tasks = tasks.append(openml.tasks.list_tasks(task_id = [i], output_format=\"dataframe\"))\n",
    "\n",
    "datasets = openml.datasets.list_datasets(output_format = 'dataframe')\n",
    "# tasks = openml.tasks.list_tasks(output_format=\"dataframe\")\n",
    "flows = openml.flows.list_flows(output_format = 'dataframe')\n",
    "suites = openml.study.list_suites(output_format=\"dataframe\", status=\"all\")\n",
    "\n",
    "datasets = datasets.rename(columns={'did': 'data_id', 'name': 'data_name'})\n",
    "tasks = tasks.rename(columns={'did': 'data_id', 'tid': 'task_id', 'name': 'data_name'})\n",
    "flows = flows.rename(columns={'full_name': 'flow_name', 'name': 'flow_name_type', 'id': 'flow_id'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Downloading data from OpenML\n",
    "'''\n",
    "# df_openml = pd.DataFrame()\n",
    "# tasks.task_id.unique()\n",
    "\n",
    "# for i in tqdm(tasks.task_id.unique()):\n",
    "#     try:\n",
    "#         df_openml = df_openml.append(openml.evaluations.list_evaluations(\n",
    "#             function = 'area_under_roc_curve',\n",
    "#             tasks = [i],\n",
    "#             output_format='dataframe',\n",
    "#             size = None))\n",
    "#     except:\n",
    "#         None\n",
    "\n",
    "# df_openml.to_csv('df_openml_all2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Отавляем модели только с sklearn\n",
    "df_openml_sklearn = df_openml[df_openml['flow_name'].str.startswith('sklearn')]\n",
    "# Удаление одинаковых моделей для каждого task_id, оставляя с лучшим score\n",
    "data_with_best_model = df_openml_sklearn.groupby(['task_id','flow_name']).apply(lambda x: x.nlargest(1,['value'])).reset_index(drop=True)\n",
    "\n",
    "data_with_best_model.loc[data_with_best_model[data_with_best_model['value']>=0.8].index, 'label'] = 1\n",
    "data_with_best_model.loc[data_with_best_model[data_with_best_model['value']<0.8].index, 'label'] = 0\n",
    "\n",
    "# TOP_POS = 3    # количество лучших моделей для каждого task_id\n",
    "# TOP_NEG = 7    # количество худших моделей для каждого task_id \n",
    "\n",
    "# # Оставляем только те task_id, для которых количество samples >= TOP_POS + TOP_NEG \n",
    "# temp = data_with_best_model['task_id'].value_counts()\n",
    "# data_with_best_model = data_with_best_model[data_with_best_model['task_id'].isin(list(temp[temp>=TOP_POS+TOP_NEG].index))]\n",
    "\n",
    "# # POSITIVE_SAMPLES\n",
    "# df_top_positive = data_with_best_model.groupby(['task_id']).apply(lambda x: x.nlargest(TOP_POS,['value']))\n",
    "# df_top_positive['label'] = [1]*len(df_top_positive)\n",
    "# # NEGATIVE_SAMPLES\n",
    "# df_top_negative = data_with_best_model.groupby(['task_id']).apply(lambda x: x.nsmallest(TOP_NEG,['value']))\n",
    "# df_top_negative['label'] = [0]*len(df_top_negative)\n",
    "\n",
    "# df_top = pd.concat([df_top_positive, df_top_negative])\n",
    "\n",
    "# Объединение различных таблиц с OpenML (например, доп информация о датасете и тд)\n",
    "df_top_merge = pd.merge(data_with_best_model, datasets[list(set(datasets.columns) - set(data_with_best_model.columns)) + ['data_name', 'data_id']], on = ['data_name', 'data_id'])\n",
    "df_top_merge = pd.merge(df_top_merge, tasks[list(set(tasks.columns) - set(df_top_merge.columns)) + ['task_id', 'data_id']], on = ['task_id', 'data_id'])\n",
    "df_top_merge = pd.merge(df_top_merge, flows[list(set(flows.columns) - set(df_top_merge.columns)) + ['flow_id', 'flow_name']], on = ['flow_id', 'flow_name'])\n",
    "\n",
    "# Преобразование информации о модели\n",
    "df_top_merge['flow_count_transformes'] = df_top_merge['flow_name_type'].apply(lambda x: x.count('='))\n",
    "df_top_merge[\"flow_main\"] = df_top_merge[\"flow_name_type\"].apply(lambda x: re.findall(r'(.*?[(])', x)[0][:-1] if re.findall(r'(.*?[(])', x) else None) \n",
    "df_top_merge[\"flow_main\"] = df_top_merge[\"flow_main\"].apply(lambda x: 'sklearn.pipeline.C...' if str(x).startswith('sklearn.pipeline.C') else x) \n",
    "df_top_merge[\"flow_model\"] = df_top_merge[\"flow_name_type\"].apply(lambda x: x.split('.')[-1].rstrip(')')) \n",
    "df_top_merge['flow_list_of_transforms'] = df_top_merge[\"flow_name_type\"].apply(lambda x: frozenset([i[1:-1] for i in re.findall(r'([(,].*?[=])', x)]) if re.findall(r'([(,].*?[=])', x) else None)\n",
    "\n",
    "# df_top_merge.to_csv('OpenML_neg+pos.csv')\n",
    "\n",
    "# Удаление дубликатов по модели\n",
    "df_top_merge_sort = df_top_merge.sort_values(by=['value'], ignore_index=True, ascending=False)\n",
    "df_top_merge_sort.drop_duplicates(subset=['flow_model','flow_list_of_transforms','task_id'], inplace=True)\n",
    "\n",
    "temp = df_top_merge_sort['task_id'].value_counts()\n",
    "N = 2\n",
    "df_top_merge = df_top_merge_sort[df_top_merge_sort['task_id'].isin(list(temp[temp>=N].index))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('pipelines.pickle', 'wb') as file:\n",
    "#     pickle.dump(np.array(df_top_merge[\"flow_name_type\"]), file)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1606\n"
     ]
    }
   ],
   "source": [
    "count_str_pipeline = []\n",
    "branch_pipelines = []\n",
    "\n",
    "for i in df_top_merge['flow_name_type']:\n",
    "    count_str_pipeline.append(i.lower().count('pipeline'))\n",
    "    if [True for cond in ['columntransformer', 'featureunion', 'make_union'] if cond in i.lower()]:\n",
    "        branch_pipelines.append(i)\n",
    "\n",
    "several_pipeline = len([x for x in count_str_pipeline if x > 2]), len(df_top_merge['flow_name_type'])\n",
    "#pd.Series(count_str_pipeline).value_counts()\n",
    "print(len(branch_pipelines))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_top_merge = pd.read_csv('OpenML_neg+pos.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Удаление неинформативных столбцов\n",
    "columns = set(df_top_merge.columns) - set(['ttid', 'cost_matrix', 'Unnamed: 0.1', 'target_feature_left','function', 'format', 'Unnamed: 0', 'run_id',\t'setup_id',\t'flow_id', 'flow_name', 'data_id', 'data_name', 'upload_time',\n",
    "                                            'uploader', 'uploader_name', 'values',\t'array_data', 'version', 'status', 'target_value',\t'target_feature_right',\n",
    "                                            'target_feature_event',\t'quality_measure',\t'source_data',\t'source_data_labeled',\t'number_samples', 'external_version',\n",
    "                                            'estimation_procedure', 'task_type', 'target_feature', 'flow_main']) #'flow_name_type'\n",
    "X_columns = list(columns - {'label'}) #{'value', 'task_id'}\n",
    "Y_column = ['label']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_dataset = df_top_merge[set(X_columns)-set(['flow_list_of_transforms', 'flow_count_transformes','flow_model','flow_name_type', 'task_id', 'evaluation_measures', 'value'])]\n",
    "X_dataset.to_csv('X_dataset.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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>NumberOfInstances</th>\n",
       "      <th>MinorityClassSize</th>\n",
       "      <th>MajorityClassSize</th>\n",
       "      <th>NumberOfMissingValues</th>\n",
       "      <th>NumberOfNumericFeatures</th>\n",
       "      <th>NumberOfInstancesWithMissingValues</th>\n",
       "      <th>NumberOfFeatures</th>\n",
       "      <th>MaxNominalAttDistinctValues</th>\n",
       "      <th>NumberOfSymbolicFeatures</th>\n",
       "      <th>NumberOfClasses</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2126.0</td>\n",
       "      <td>53.0</td>\n",
       "      <td>579.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1372.0</td>\n",
       "      <td>610.0</td>\n",
       "      <td>762.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2796.0</td>\n",
       "      <td>274.0</td>\n",
       "      <td>680.0</td>\n",
       "      <td>68100.0</td>\n",
       "      <td>32.0</td>\n",
       "      <td>2795.0</td>\n",
       "      <td>35.0</td>\n",
       "      <td>57.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>8124.0</td>\n",
       "      <td>3916.0</td>\n",
       "      <td>4208.0</td>\n",
       "      <td>2480.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2480.0</td>\n",
       "      <td>23.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>23.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8124.0</td>\n",
       "      <td>3916.0</td>\n",
       "      <td>4208.0</td>\n",
       "      <td>2480.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2480.0</td>\n",
       "      <td>23.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>23.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   NumberOfInstances  MinorityClassSize  MajorityClassSize  \\\n",
       "0             2126.0               53.0              579.0   \n",
       "1             1372.0              610.0              762.0   \n",
       "2             2796.0              274.0              680.0   \n",
       "3             8124.0             3916.0             4208.0   \n",
       "4             8124.0             3916.0             4208.0   \n",
       "\n",
       "   NumberOfMissingValues  NumberOfNumericFeatures  \\\n",
       "0                    0.0                     35.0   \n",
       "1                    0.0                      4.0   \n",
       "2                68100.0                     32.0   \n",
       "3                 2480.0                      0.0   \n",
       "4                 2480.0                      0.0   \n",
       "\n",
       "   NumberOfInstancesWithMissingValues  NumberOfFeatures  \\\n",
       "0                                 0.0              36.0   \n",
       "1                                 0.0               5.0   \n",
       "2                              2795.0              35.0   \n",
       "3                              2480.0              23.0   \n",
       "4                              2480.0              23.0   \n",
       "\n",
       "   MaxNominalAttDistinctValues  NumberOfSymbolicFeatures  NumberOfClasses  \n",
       "0                         10.0                       1.0             10.0  \n",
       "1                          2.0                       1.0              2.0  \n",
       "2                         57.0                       3.0              6.0  \n",
       "3                         12.0                      23.0              2.0  \n",
       "4                         12.0                      23.0              2.0  "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_dataset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_146820/62334551.py:7: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  X[cols] = X[cols].fillna('nan')\n",
      "/tmp/ipykernel_146820/62334551.py:8: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  X[cols] = X[cols].astype(str)\n",
      "/tmp/ipykernel_146820/62334551.py:9: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  X[list(set(X.columns)-set(cols))] = X[list(set(X.columns)-set(cols))].fillna(-1)\n",
      "/tmp/ipykernel_146820/62334551.py:20: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  X[cols] = enc.transform(X[cols])\n"
     ]
    }
   ],
   "source": [
    "X = df_top_merge[X_columns]\n",
    "y = df_top_merge[Y_column]\n",
    "\n",
    "# Заполнение пропусков и преобразование категориальных данных\n",
    "cols=X.select_dtypes(include='object').columns.to_list() \n",
    "    \n",
    "X[cols] = X[cols].fillna('nan')\n",
    "X[cols] = X[cols].astype(str)\n",
    "X[list(set(X.columns)-set(cols))] = X[list(set(X.columns)-set(cols))].fillna(-1)\n",
    "\n",
    "# enc = OneHotEncoder() #OrdinalEncoder(dtype = int)\n",
    "# enc.fit(X[cols])\n",
    "# transform_X = pd.DataFrame(enc.transform(X[cols]).toarray())\n",
    "# transform_X.index = X.index\n",
    "# X = pd.concat([X[set(X.columns) - set(cols)], transform_X], axis = 1)\n",
    "# X.columns = X.columns.astype(str)\n",
    "\n",
    "enc = OrdinalEncoder(dtype = int)\n",
    "enc.fit(X[cols])\n",
    "X[cols] = enc.transform(X[cols])\n",
    "\n",
    "dict_category = dict()\n",
    "for col in cols:\n",
    "    dict_category[col] = X[col].nunique()\n",
    "# with open('dict_category_2.pkl', 'wb') as f:\n",
    "#     pickle.dump(dict_category, f) \n",
    "\n",
    "# enc = category_encoders.BinaryEncoder(cols=cols)\n",
    "# data_binary = enc.fit_transform(X[cols])\n",
    "# X = pd.concat([data_binary, X[list(set(X.columns)-set(cols))]], axis=1) \n",
    "\n",
    "# Разделение данных на train и test по task_id\n",
    "task_id_uniq = df_top_merge['task_id'].unique()\n",
    "SIZE_TRAIN = 0.8\n",
    "train_task_id = random.sample(list(task_id_uniq), round(len(task_id_uniq)*SIZE_TRAIN))\n",
    "test_task_id = list(set(task_id_uniq) - set(train_task_id))\n",
    "\n",
    "X_train = X[X.index.isin(list(df_top_merge[df_top_merge['task_id'].isin(train_task_id)].index))]\n",
    "y_train = y[y.index.isin(list(df_top_merge[df_top_merge['task_id'].isin(train_task_id)].index))]\n",
    "\n",
    "X_test = X[X.index.isin(list(df_top_merge[df_top_merge['task_id'].isin(test_task_id)].index))]\n",
    "y_test = y[y.index.isin(list(df_top_merge[df_top_merge['task_id'].isin(test_task_id)].index))]\n",
    "\n",
    "# X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(X, y, test_size=0.2, random_state=42, stratify=X[['task_id']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X_train.to_csv('X_train_2.csv')\n",
    "# X_test.to_csv('X_test_2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_top_merge.groupby(['flow_model','flow_list_of_transforms','task_id']).size().max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval(y_pos, y_neg):\n",
    "        hits1_list = []\n",
    "        hits3_list = []\n",
    "        hits7_list = []\n",
    "        mrr_list = []\n",
    "        for y_pred_neg,y_pred_pos in zip(y_neg, y_pos):\n",
    "                y_pred = np.concatenate([y_pred_pos, y_pred_neg])\n",
    "                # ranking_list = (len(y_pred) - y_pred.argsort().argsort())\n",
    "                ranking_list = (len(y_pred) - y_pred.argsort().argsort())[:len(y_pred)//2]\n",
    "                hits1_list.append(int(any(ranking_list[:1] <= 1)))\n",
    "                hits3_list.append(int(all(ranking_list[:3] <= 3)))\n",
    "                hits7_list.append(int(all(ranking_list[:7] <= 7)))\n",
    "                # mrr_list.append(np.mean(1./(np.where(ranking_list == 1)[0]+1)))  \n",
    "                mrr_list.append(np.mean(1./ranking_list))   \n",
    "        return np.mean(mrr_list), np.mean(hits1_list), np.mean(hits3_list), np.mean(hits7_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import rankdata\n",
    "import math\n",
    "def dcg(order):\n",
    "    log = 0\n",
    "    for i,o in enumerate(order):\n",
    "        log += o/math.log(1+i+1,2)\n",
    "    return np.array(log)\n",
    "\n",
    "def ndcg(y_true_list, y_score_list):\n",
    "    _ndcg = []\n",
    "\n",
    "    for y_true,y_score in zip(y_true_list, y_score_list):\n",
    "        rank = rankdata(y_true, method='min')\n",
    "        rank_true = rankdata(y_true[(-1*rank).argsort()], method='max')-1\n",
    "        rank_pred = rankdata(y_score[(-1*rank).argsort()], method='max')-1\n",
    "        \n",
    "        idcg = np.mean(dcg(rank_true))\n",
    "        _dcg = np.mean(dcg(rank_pred))\n",
    "\n",
    "        _ndcg.append(_dcg/idcg)\n",
    "\n",
    "    return np.mean(_ndcg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1-score: 0.41269841269841273\n",
      "NDCG_sklearn: 0.9309437136431487\n",
      "NDCG_my_implementation: 0.7650036217632606\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.16\n",
      "HITS@3: 0.0\n",
      "HITS@7: 0.4\n",
      "MRR: 0.3203121693121693\n"
     ]
    }
   ],
   "source": [
    "test_data = X_test.copy()\n",
    "test_data['prob'] = [random.random() for _ in range(len(test_data))]\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "preds_class = [1 if i>0.5 else 0 for i in test_data['prob']]\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(list)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(list)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "print(f'F1-score: {sklearn.metrics.f1_score(y_test, preds_class)}')\n",
    "print(f'NDCG_sklearn: {sklearn.metrics.ndcg_score(y_true, y_pred)}')\n",
    "print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Popular "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1-score: 0.0\n",
      "NDCG_sklearn: 0.9810297047808503\n",
      "NDCG_my_implementation: 0.9422144397332325\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.56\n",
      "HITS@3: 0.44\n",
      "HITS@7: 0.8\n",
      "MRR: 0.4948624338624338\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "rating = np.array(X_train.groupby(['task_id']).apply( lambda x: x.sort_values(['value'], ascending=False) )['flow_name_type']).reshape(-1,10)\n",
    "rating_dict = defaultdict(float)\n",
    "\n",
    "for i in range(len(rating)): \n",
    "    for j in range(TOP_POS):\n",
    "        rating_dict[rating[i][j]] += 1*TOP_POS/(j+1)\n",
    "    for j in range(TOP_POS, TOP_NEG+TOP_POS):\n",
    "        rating_dict[rating[i][j]] += -1*(j+1)/TOP_NEG\n",
    "\n",
    "# plt.bar(rating_dict.keys(), rating_dict.values())\n",
    "\n",
    "preds_proba = [rating_dict[i] for i in X_test['flow_name_type']]\n",
    "preds_class = [1 if i>0 else 0 for i in preds_class]\n",
    "\n",
    "test_data = X_test.copy()\n",
    "test_data['prob'] = preds_proba\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(list)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(list)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "print(f'F1-score: {sklearn.metrics.f1_score(y_test, preds_class)}')\n",
    "print(f'NDCG_sklearn: {sklearn.metrics.ndcg_score(y_true, y_pred)}')\n",
    "print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "def norm(data):\n",
    "    def f(x):\n",
    "        scaler1=MinMaxScaler()\n",
    "        x['norm'] = scaler1.fit_transform(x[['value']])\n",
    "        return x\n",
    "\n",
    "    data_ = data.groupby(['task_id']).apply(f)\n",
    "    y = data_['norm']\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_146820/3596457889.py:22: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
      "/tmp/ipykernel_146820/3596457889.py:23: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NDCG_sklearn: 0.9394645137499098\n",
      "NDCG_my_implementation: 0.9182987022408455\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.36904761904761907\n",
      "HITS@3: 0.32142857142857145\n",
      "HITS@7: 0.5833333333333334\n",
      "MRR: 0.45083008690376464\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from catboost import CatBoostRegressor, Pool\n",
    "\n",
    "y_train_norm = norm(X_train)\n",
    "y_test_norm = norm(X_test)\n",
    "\n",
    "\n",
    "pool_train = Pool(X_train[list(set(X_train.columns) - {'value', 'task_id'})], y_train_norm, cat_features = list(dict_category.keys()))\n",
    "pool_test = Pool(X_test[list(set(X_test.columns) - {'value', 'task_id'})], cat_features = list(dict_category.keys()))\n",
    "\n",
    "model = CatBoostRegressor(random_state=1, iterations=1000, verbose=False)\n",
    "model.fit(pool_train)\n",
    "preds_proba = model.predict(pool_test)\n",
    "\n",
    "test_data = X_test.copy()\n",
    "test_data['prob'] = preds_proba\n",
    "test_data['value'] = y_test_norm\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(np.array)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(np.array)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "plt.plot(model.evals_result_['learn']['RMSE'], color = 'black', linewidth=1)\n",
    "plt.title('CatBoost')\n",
    "plt.xlabel(\"iteration\")\n",
    "plt.ylabel(\"loss\")\n",
    "\n",
    "ndcg_score_skl = []\n",
    "for idx in range(len(y_true)):\n",
    "    ndcg_score_skl.append(sklearn.metrics.ndcg_score([y_true[idx]], [y_pred[idx]])) \n",
    "\n",
    "print(f'NDCG_sklearn: {np.mean(ndcg_score_skl)}')\n",
    "print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_146820/4185440585.py:21: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
      "/tmp/ipykernel_146820/4185440585.py:22: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NDCG_sklearn: 0.7865257265121461\n",
      "NDCG_my_implementation: 0.7229960354185071\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.07608695652173914\n",
      "HITS@3: 0.2717391304347826\n",
      "HITS@7: 0.5\n",
      "MRR: 0.3084439888725718\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAHWCAYAAABACtmGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABS+0lEQVR4nO3deVxU9f7H8fcAsqiAigqiICq4MaSmaWp7lnvLrZuVZdn2q59maqvd1OuttO6trpWmv+yW1S/T8paVmv7Mn9W1bNMsXM+AIKaCW7KpoDPz+6PfcCUXEGG+s7yej8c8Yg7nzHnTRPDmnPM5Nrfb7RYAAAAA4JRCTAcAAAAAAF9HcQIAAACAKlCcAAAAAKAKFCcAAAAAqALFCQAAAACqQHECAAAAgCpQnAAAAACgChQnAAAAAKgCxQkAAAAAqkBxAgAAAIAqUJwAAH5t7ty5stlsstlsWr169Qmfd7vdSkpKks1m05AhQyqW22w2jR49+rSvfckll1S8ts1mU5MmTXTeeefp9ddfl8vlqvWvBQDguyhOAICAEBkZqXnz5p2w/IsvvtAvv/yiiIiIGr1uq1at9Pbbb+vtt9/WxIkTdezYMd155516/PHHzzYyAMCPUJwAAAFh0KBBev/993Xs2LFKy+fNm6fu3bsrISGhRq8bGxurW265RbfccovGjRunr776Sq1atdKMGTN09OjR2ogOAPADFCcAQEC46aabtH//fq1YsaJiWXl5uRYuXKibb7651vZTv359nX/++SotLdXevXtr7XUBAL6N4gQACAgpKSnq3bu33n333Ypln376qQoLC3XjjTfW6r62bdum0NBQNWrUqFZfFwDguyhOAICAcfPNN2vRokU6fPiwJOmdd97RxRdfrMTExBq/ptPp1L59+7Rv3z5t2bJFDzzwgNatW6dBgwapfv36tRUdAODjKE4AgIBxww036PDhw1q8eLGKi4u1ePHisz5Nb8uWLWrWrJmaNWumTp066eWXX9bgwYP1+uuv11JqAIA/COri9OWXX2ro0KFKTEyUzWbTokWLzmj7P//5z5XG1HoeDRo0qJvAAIDTatasmfr166d58+bpgw8+kNPp1PXXX39Wr5mSkqIVK1bos88+0+rVq5Wfn6/FixeradOmtZQaAOAPwkwHMKm0tFRdunTRHXfcoT/84Q9nvP1DDz2ke++9t9Kyyy+/XOedd15tRQQAnKGbb75Zd999t/Lz8zVw4MCzvg6pQYMG6tevX+2EAwD4raA+4jRw4EA99dRTuvbaa0/6+bKyMj300ENq2bKlGjRooF69eunzzz+v+HzDhg2VkJBQ8SgoKNCmTZt05513eukrAAD83rXXXquQkBB98803tTpNDwAQ3IL6iFNVRo8erU2bNmn+/PlKTEzUhx9+qAEDBigzM1NpaWknrP/aa6+pffv2uvDCCw2kBQBIv/1Ra9asWcrNzdXQoUNNxwEABAiK0ynk5eXpjTfeUF5eXsU0poceekjLli3TG2+8oalTp1Za/8iRI3rnnXf02GOPmYgLADjObbfdVq31fvjhBz311FMnLL/kkkt0wQUX1HYsAIAfozidQmZmppxOp9q3b19peVlZmeLi4k5Y/8MPP1RxcXG1f1gDAMz79ttv9e23356w/Mknn6Q4AQAqoTidQklJiUJDQ7V27VqFhoZW+lzDhg1PWP+1117TkCFDFB8f762IAABJt99+u26//fYq18vNza303O12V7nN8de1AgCCG8XpFLp16yan06k9e/ZUec1STk6OVq1apY8//thL6QAAAAB4U1AXp5KSEmVlZVU8z8nJ0fr169WkSRO1b99ew4cP14gRI/T888+rW7du2rt3r1auXKlzzjlHgwcPrtju9ddfV4sWLTRw4EATXwYAAACAOmZzV+dchQD1+eef69JLLz1h+W233aa5c+fq6NGjeuqpp/TWW29p586datq0qc4//3xNmTJFGRkZkiSXy6XWrVtrxIgRevrpp739JQAAAADwgqAuTgAAAABQHUF9A1wAAAAAqA6KEwAAAABUIeiGQ7hcLu3atUvR0dGy2Wym4wAAAAAwxO12q7i4WImJiQoJOf0xpaArTrt27VJSUpLpGAAAAAB8xI4dO9SqVavTrhN0xSk6OlrSb/9yYmJiDKcBAAAAYEpRUZGSkpIqOsLpBF1x8pyeFxMTQ3ECAAAAUK1LeBgOAQAAAABVoDgBAAAAQBUoTgAAAABQBYoTAAAAAFSB4gQAAAAAVaA4AQAAAEAVKE4AAAAAUAWKEwAAAABUgeIEAAAAAFWgOAEAAABAFShOAAAAAFAFihMAAAAAVIHiBAAAAABVoDgBAADgBFu2bNG3335rOgbgM8JMBwAAAIDvmTRpkjZt2qQNGzaYjgL4BI44AQAA4ARbt27V1q1bVV5ebjoK4BMoTgAAAKjE5XIpKytLx44dk2VZpuMAPoHiBAAAgEp27dqlQ4cOSZIyMzMNpwF8A8UJAAAAlXiOMoWFhXGNE/D/KE4AAACoxLIshYWF6aKLLqI4Af+P4gQAAIBKLMtS27Zt1a1bN4oT8P8oTgAAAKjE4XAoLS1Ndrtd27ZtU2lpqelIgHEUJwAAAFRiWZbat28vu90uSdq4caPhRIB5FCcAAABUOHr0qLZt26b27durU6dOstlsnK4HiOIEAACA4+Tm5urYsWNq3769GjRooLZt21KcAFGcAAAAcBzPKPK0tDRJUkZGBsUJkOHi9OWXX2ro0KFKTEyUzWbTokWLqr3tV199pbCwMHXt2rXO8gEAAAQbh8OhqKgotWzZUpJkt9spToAMF6fS0lJ16dJFM2fOPKPtDh48qBEjRujyyy+vo2QAAADBybIspaWlKSTkt18T7Xa7du/erf379xtOBpgVZnLnAwcO1MCBA894u3vvvVc333yzQkNDz+goFQAAAE7PM1HPwzNZb8OGDbr44otNxQKM87trnN544w1t27ZNkydPrtb6ZWVlKioqqvQAAADAyf2+OLVv31716tXjdD0EPb8qTg6HQ4899pj++7//W2Fh1TtYNm3aNMXGxlY8kpKS6jglAACAfzp06JB27NhRMRhCkurVq6eOHTtSnBD0/KY4OZ1O3XzzzZoyZUqlv4JUZcKECSosLKx47Nixow5TAgAA+K/s7GxJOuF3LQZEAIavcToTxcXF+uGHH/Tjjz9q9OjRkiSXyyW3262wsDD9z//8jy677LITtouIiFBERIS34wIAAPgdzyjykxWnTz/9VG63WzabzUQ0wDi/KU4xMTHKzMystOyVV17R//7v/2rhwoVq06aNoWQAAACBwbIsNW7cWHFxcZWW2+12HTx4UDt37lSrVq0MpQPMMlqcSkpKlJWVVfE8JydH69evV5MmTZScnKwJEyZo586deuuttxQSElIx1cWjefPmioyMPGE5AAAAzpxnMMTvjyodP1mP4oRgZfQapx9++EHdunVTt27dJEnjx49Xt27dNGnSJEnS7t27lZeXZzIiAABA0HA4HJUGQ3ikpKSoQYMGXOeEoGZzu91u0yG8qaioSLGxsSosLFRMTIzpOAAAAD6jefPmuv/++zVx4sQTPterVy916tRJc+fO9X4woI6cSTfwm6l6AAAAqDu//vqr9u7de8rpxUzWQ7CjOAEAAEAOh0PSiRP1POx2uzZt2iSn0+nNWIDPoDgBAACgYhR5amrqST9vt9t1+PBhbdu2zZuxAJ9BcQIAAIAcDodatGih6Ojok37++Ml6QDCiOAEAAKBiFPmpJCQkKC4ujuKEoEVxAgAAQJXFyWazMSACQY3iBAAAEOTcbneVxUlish6CG8UJAAAgyOXn56ukpOSkN789nt1u19atW1VWVualZIDvoDgBAAAEuapGkXvY7XY5nU5t3brVG7EAn0JxAgAACHKWZSkkJERt27Y97XpM1kMwozgBAAAEOcuylJKSooiIiNOu16hRI7Vq1YrihKBEcQIAAAhy1RkM4cGACAQrihMAAECQczgcVQ6G8LDb7crMzKzjRIDvoTgBAAAEMafTqaysrDM64pSbm6vi4uI6Tgb4FooTAABAEMvLy1N5eXm1i1NGRoYkadOmTXUZC/A5FCcAAIAgZlmWpKpHkXt06tRJNpuN65wQdChOAAAAQcyyLIWHhyspKala60dFRSk1NZXihKBDcQIAAAhiDodDqampCg0NrfY2TNZDMKI4AQAABLEzGUXuwWQ9BCOKEwAAQBCraXEqKCjQ3r176ygV4HsoTgAAAEGqrKxMubm5Z1ycPJP1Nm7cWBexAJ9EcQIAAAhS2dnZcrvd1b75rUdqaqrCw8O5zglBheIEAAAQpBwOh6TqjyL3qFevnjp27EhxQlChOAEAAAQpy7IUHR2t+Pj4M96WAREINhQnAACAIOUZDGGz2c54W89IcrfbXQfJAN9DcQIAAAhSNZmo55GRkaGioiL98ssvtZwK8E0UJwAAgCDlcDjOeDCEh91ulySuc0LQoDgBAAAEoeLiYu3evbvGR5ySk5PVsGFDihOCBsUJAAAgCNV0op5HSEiI0tPTKU4IGhQnAACAIGRZliTV+FQ9icl6CC4UJwAAgCBkWZaaNWumRo0a1fg1MjIytGnTJjmdztoLBvgoihMAAEAQcjgcNT5Nz8Nut6usrEzZ2dm1lArwXRQnAACAIHQ2o8g9mKyHYEJxAgAACDJut7tWilPz5s3VtGlTihOCAsUJAAAgyOzbt08HDx486+Jks9kYEIGgQXECAAAIMrUxUc/DbrdzxAlBgeIEAAAQZDz3cEpNTT3r18rIyJDD4dCRI0fO+rUAX2a0OH355ZcaOnSoEhMTZbPZtGjRotOu/8EHH+iKK65Qs2bNFBMTo969e2v58uXeCQsAABAgLMtScnKyoqKizvq17Ha7nE6ntm7dWgvJAN9ltDiVlpaqS5cumjlzZrXW//LLL3XFFVdo6dKlWrt2rS699FINHTpUP/74Yx0nBQAACBy1MRjCIz09XRKT9RD4wkzufODAgRo4cGC1158+fXql51OnTtVHH32kTz75RN26dTvpNmVlZSorK6t4XlRUVKOsAAAAgcKyLF144YW18lqxsbFKSkpiQAQCnl9f4+RyuVRcXKwmTZqccp1p06YpNja24pGUlOTFhAAAAL7F5XIpKyurVgZDeDAgAsHAr4vTc889p5KSEt1www2nXGfChAkqLCyseOzYscOLCQEAAHzLzp07dfjw4Vo7VU/6bUAExQmBzm+L07x58zRlyhS99957at68+SnXi4iIUExMTKUHAABAsPKMIq/N4mS327V9+3YuiUBA88viNH/+fN11111677331K9fP9NxAAAA/IZlWQoLC1NKSkqtvabdbpckbdq0qdZeE/A1flec3n33XY0cOVLvvvuuBg8ebDoOAACAX7EsS23btlVYWO3NCOvYsaNCQkI4XQ8BzehUvZKSEmVlZVU8z8nJ0fr169WkSRMlJydrwoQJ2rlzp9566y1Jv52ed9ttt+nFF19Ur169lJ+fL0mKiopSbGyska8BAADAnzgcjlo9TU/67Xex1NRUJushoBk94vTDDz+oW7duFaPEx48fr27dumnSpEmSpN27dysvL69i/VdffVXHjh3TqFGj1KJFi4rHAw88YCQ/AACAv6nNezgdjwERCHRGjzhdcsklcrvdp/z83LlzKz3//PPP6zYQAABAADt69Ki2bdtWJ8XJbrdr1qxZtf66gK/wu2ucAAAAUDM5OTlyOp11Vpz27NmjPXv21PprA76A4gQAABAkPKPIa/Pmtx6eyXobN26s9dcGfAHFCQAAIEg4HA7Vr19fiYmJtf7aqampioiIYEAEAhbFCQAAIEhYlqW0tDSFhNT+r4BhYWHq1KkTAyIQsChOAAAAQaKuJup52O12ihMCFsUJAAAgSHirOJ1uajLgryhOAAAAQeDQoUP65Zdf6mQwhIfdbldxcbF27NhRZ/sATKE4AQAABIGsrCxJqvMjTpI4XQ8BieIEAAAQBDyjyOuyOCUnJys6OprJeghIFCcAAIAgYFmWmjRpori4uDrbh81mY0AEAhbFCQAAIAh4RpHXNYoTAhXFCQAAIAg4HI46PU3Pw263a/PmzTp27Fid7wvwJooTAABAEKjrUeQedrtdZWVlys7OrvN9Ad5EcQIAAAhwBw4c0L59+7xWnCQxIAIBh+IEAAAQ4BwOh6S6najn0bx5czVv3pzrnBBwKE4AAAABzjOKPDU11Sv7Y0AEAhHFCQAAIMA5HA4lJiaqYcOGXtkfxQmBiOIEAAAQ4Lw1GMLDbrfL4XDoyJEjXtsnUNcoTgAAAAHORHFyuVzavHmz1/YJ1DWKEwAAQABzu91eL07p6emSxOl6CCgUJwAAgAC2e/dulZaWKi0tzWv7jImJUevWrSlOCCgUJwAAgADmzVHkx2NABAINxQkAACCAWZalkJAQtW3b1qv7pTgh0FCcAAAAAphlWWrTpo3Cw8O9ul+73a68vDwVFRV5db9AXaE4AQAABDDLsrx6fZNHRkaGJAZEIHBQnAAAAAKYw+Hw+vVNktShQweFhoZSnBAwKE4AAAAByul0Kisry0hxioyMVFpaGsUJAYPiBAAAEKC2b9+uo0ePGilOEgMiEFgoTgAAAAHKsixJ3h9F7kFxQiChOAEAAAQoy7IUERGhpKQkI/u32+3au3evCgoKjOwfqE0UJwAAgADlcDiUmpqqkBAzv/IxWQ+BhOIEAAAQoCzLMnaaniS1a9dOERERFCcEBIoTAABAgDJdnEJDQ9W5c2eKEwICxQkAACAAHTlyRNu3bzdanCQGRCBwUJwAAAACUHZ2ttxut9LS0ozm8BQnt9ttNAdwtihOAAAAAcjhcEgyN4rcIyMjQyUlJdq+fbvRHMDZMlqcvvzySw0dOlSJiYmy2WxatGhRldt8/vnnOvfccxUREaHU1FTNnTu3znMCAAD4G8uyFBMTo+bNmxvNYbfbJTFZD/7PaHEqLS1Vly5dNHPmzGqtn5OTo8GDB+vSSy/V+vXrNXbsWN11111avnx5HScFAADwL57BEDabzWiOVq1aKSYmhuIEvxdmcucDBw7UwIEDq73+7Nmz1aZNGz3//POSpE6dOmn16tX6+9//rv79+9dVTAAAAL9jWZbx65skyWazMSACAcGvrnFas2aN+vXrV2lZ//79tWbNmlNuU1ZWpqKiokoPAACAQOdwOIxf3+RBcUIg8KvilJ+fr/j4+ErL4uPjVVRUpMOHD590m2nTpik2NrbikZSU5I2oAAAAxhQVFSk/P99nilNGRoY2b96so0ePmo4C1JhfFaeamDBhggoLCyseO3bsMB0JAACgTvnKRD0Pu92u8vJyZWVlmY4C1JjRa5zOVEJCggoKCiotKygoUExMjKKiok66TUREhCIiIrwRDwAAwCdYliVJPnGNkySlp6dL+m2yXqdOnQynAWrGr4449e7dWytXrqy0bMWKFerdu7ehRAAAAL7Hsiw1b95csbGxpqNIkpo1a6b4+Hiuc4JfM1qcSkpKtH79eq1fv17Sb+PG169fr7y8PEm/nWY3YsSIivXvvfdebdu2TY888oi2bNmiV155Re+9957GjRtnIj4AAIBP8qXBEB4MiIC/M1qcfvjhB3Xr1k3dunWTJI0fP17dunXTpEmTJEm7d++uKFGS1KZNGy1ZskQrVqxQly5d9Pzzz+u1115jFDkAAMBxPPdw8iUZGRnKzMw0HQOoMaPXOF1yySVyu92n/PzcuXNPus2PP/5Yh6kAAAD8l9vtlmVZuu6660xHqcRut+vFF1/U4cOHT3ltOuDL/OoaJwAAAJze3r17VVhY6HNHnOx2u9xutzZv3mw6ClAjFCcAAIAA4msT9Tw6d+4sSVznBL9FcQIAAAggDodDNptN7dq1Mx2lkujoaKWkpFCc4LcoTgAAAAHEsiwlJyf75HVETNaDP6M4AQAABBBfnKjnwWQ9+DOKEwAAQACxLMvnrm/ysNvt+uWXX3Tw4EHTUYAzRnECAAAIEC6XS1lZWT57xMlut0uSNm7caDgJcOYoTgAAAAHil19+0ZEjR3y2OHXo0EGhoaFc5wS/RHECAAAIEJ5R5L5anCIiItS+fXuKE/wSxQkAACBAWJalevXqqXXr1qajnBIDIuCvKE4AAAABwrIstW3bVmFhYaajnJJnJLnb7TYdBTgjFCcAAIAA4XA4fPY0PQ+73a79+/eroKDAdBTgjFCcAAAAAoQv38PJwzNZj+uc4G8oTgAAAAGgvLxcOTk5Pl+c2rZtq6ioKIoT/A7FCQAAIADk5OTI6XT6fHEKDQ1V586dKU7wOxQnAACAAOAZRZ6WlmY4SdXsdjuT9eB3KE4AAAABwOFwqH79+kpMTDQdpUp2u10bN26Uy+UyHQWoNooTAABAAPAMhrDZbKajVMlut6u0tFTbt283HQWoNooTAABAAPCHiXoeTNaDP6I4AQAABADLsvzi+iZJatmypRo1akRxgl+hOAEAAPi50tJS7dy502+OONlsNgZEwO9QnAAAAPxcVlaWJPlNcZJ+O12PI07wJxQnAAAAP+cZRe5vxWnLli06evSo6ShAtVCcAAAA/JxlWYqLi1OTJk1MR6k2u92uo0ePyuFwmI4CVAvFCQAAwM/502AIDybrwd9QnAAAAPycw+Hwq9P0JCkuLk4tWrRgQAT8BsUJAADAz/nTPZyOx4AI+BOKEwAAgB/bv3+/9u/fT3EC6hjFCQAAwI95hiv42zVO0m/FKTs7W4cOHTIdBagSxQkAAMCPeUaRp6amGk5y5ux2u9xutzZv3mw6ClAlihMAAIAfczgcatmypRo2bGg6yhlLT0+XxGQ9+AeKEwAAgB/z18EQktSgQQO1bduWyXrwCxQnAAAAP+bPxUliQAT8B8UJAADAT7ndbjkcDr8cDOFBcYK/oDgBAAD4qd27d6u0tNTvjzjt3LlTv/76q+kowGlRnAAAAPyUZ6KePxenjIwMSdLGjRsNJwFOj+IEAADgpyzLUmhoqNq0aWM6So21b99eYWFhDIiAzzNenGbOnKmUlBRFRkaqV69e+u677067/vTp09WhQwdFRUUpKSlJ48aN05EjR7yUFgAAwHdYlqU2bdooPDzcdJQaCw8PV4cOHbjOCT7PaHFasGCBxo8fr8mTJ2vdunXq0qWL+vfvrz179px0/Xnz5umxxx7T5MmTtXnzZv3jH//QggUL9Pjjj3s5OQAAgHmWZfn1YAgPBkTAHxgtTi+88ILuvvtujRw5Up07d9bs2bNVv359vf766ydd/+uvv1bfvn118803KyUlRVdeeaVuuummKo9SAQAABCKHw+HX1zd5eIqT2+02HQU4JWPFqby8XGvXrlW/fv3+HSYkRP369dOaNWtOuk2fPn20du3aiqK0bds2LV26VIMGDTrlfsrKylRUVFTpAQAA4O+OHTum7OzsgChOGRkZOnDggPLz801HAU4pzNSO9+3bJ6fTqfj4+ErL4+PjtWXLlpNuc/PNN2vfvn264IIL5Ha7dezYMd17772nPVVv2rRpmjJlSq1mBwAAMG379u06evRoQBQnu90uScrMzFSLFi0MpwFOzvhwiDPx+eefa+rUqXrllVe0bt06ffDBB1qyZImefPLJU24zYcIEFRYWVjx27NjhxcQAAAB1wzOKPBCucWrTpo2ioqK4zgk+zdgRp6ZNmyo0NFQFBQWVlhcUFCghIeGk20ycOFG33nqr7rrrLkm/HdYtLS3VPffcoz/96U8KCTmxB0ZERCgiIqL2vwAAAACDLMtSRESEkpKSTEc5ayEhIUpPT6c4wacZO+IUHh6u7t27a+XKlRXLXC6XVq5cqd69e590m0OHDp1QjkJDQyWJiwkBAEBQcTgcSktLO+kfjv0Rk/Xg64x+p40fP15z5szRm2++qc2bN+u+++5TaWmpRo4cKUkaMWKEJkyYULH+0KFDNWvWLM2fP185OTlasWKFJk6cqKFDh1YUKAAAgGBgWVZAXN/kYbfbtXHjRrlcLtNRgJMydqqeJA0bNkx79+7VpEmTlJ+fr65du2rZsmUVAyPy8vIq/RXliSeekM1m0xNPPKGdO3eqWbNmGjp0qJ5++mlTXwIAAIARlmXppptuMh2j1mRkZOjQoUPKzc1V27ZtTccBTmBzB9k5bkVFRYqNjVVhYaFiYmJMxwEAADhjR44cUf369fXaa6/pjjvuMB2nVuzatUstW7bUokWLdPXVV5uOgyBxJt2gRqfqvfnmm1qyZEnF80ceeUSNGjVSnz59tH379pq8JAAAAKopOztbbrc7oE7Va9GihRo3bsx1TvBZNSpOU6dOVVRUlCRpzZo1mjlzpv7617+qadOmGjduXK0GBAAAQGWeUeSBVJxsNhsDIuDTanSN044dO5SamipJWrRoka677jrdc8896tu3ry655JLazAcAAIDfsSxLsbGxatasmekotcput+tf//qX6RjASdXoiFPDhg21f/9+SdL//M//6IorrpAkRUZG6vDhw7WXDgAAACfwTNSz2Wymo9SqjIwMbdmyReXl5aajACeo0RGnK664QnfddZe6desmy7I0aNAgSdLGjRuVkpJSm/kAAADwO5ZlKS0tzXSMWme323Xs2DFZliW73W46DlBJjY44zZw5U71799bevXv1z3/+U3FxcZKktWvXBtRYTAAAAF/kcDgC6vomj/T0dEniOif4pBodcWrUqJFmzJhxwvIpU6acdSAAAACcWmFhoQoKCgKyODVp0kSJiYkUJ/ikGh1xWrZsmVavXl3xfObMmeratatuvvlm/frrr7UWDgAAAJU5HA5JgTVR73hM1oOvqlFxevjhh1VUVCRJyszM1IMPPqhBgwYpJydH48ePr9WAAAAA+DfPKPJAvMZJ+m1ABMUJvqhGxSknJ0edO3eWJP3zn//UkCFDNHXqVM2cOVOffvpprQYEAADAv1mWpfj4eMXExJiOUifsdru2bdum0tJS01GASmpUnMLDw3Xo0CFJ0meffaYrr7xS0m/npXqORAEAAKD2BepgCA+73S63261NmzaZjgJUUqPidMEFF2j8+PF68skn9d1332nw4MGSfvsLSKtWrWo1IAAAAP7Ncw+nQNWpUyfZbDZO14PPqVFxmjFjhsLCwrRw4ULNmjVLLVu2lCR9+umnGjBgQK0GBAAAwG/cbnfAF6cGDRqobdu2FCf4nBqNI09OTtbixYtPWP73v//9rAMBAADg5Pbs2aOioqKAHQzhwYAI+KIaFSdJcjqdWrRokTZv3izptxuWXXXVVQoNDa21cAAAAPg3z0S9QD7iJP12ndPrr79uOgZQSY2KU1ZWlgYNGqSdO3eqQ4cOkqRp06YpKSlJS5YsUbt27Wo1JAAAAH4bDGGz2QL+dy273a5du3bpwIEDatKkiek4gKQaXuM0ZswYtWvXTjt27NC6deu0bt065eXlqU2bNhozZkxtZwQAAIB+O+LUunVrRUZGmo5Sp+x2uyRxuh58So2OOH3xxRf65ptvKv0FIC4uTs8884z69u1ba+EAAADwb4E+GMIjLS1N9erV04YNG3TRRReZjgNIquERp4iICBUXF5+wvKSkROHh4WcdCgAAACeyLCvgB0NIv90ztEOHDhxxgk+pUXEaMmSI7rnnHn377bdyu91yu9365ptvdO+99+qqq66q7YwAAABBz+VyKSsrKyiOOElM1oPvqVFxeumll9SuXTv17t1bkZGRioyMVJ8+fZSamqrp06fXckQAAADs2LFDZWVlQVOc7Ha7MjMz5Xa7TUcBJNXwGqdGjRrpo48+UlZWVsU48k6dOik1NbVWwwEAAOA3wTKK3MNut+vgwYPatWuXWrZsaToOUP3iNH78+NN+ftWqVRUfv/DCCzVPBAAAgBNYlqV69eopOTnZdBSvOH6yHsUJvqDaxenHH3+s1no2m63GYQAAAHBylmWpXbt2Cgur0QlDficlJUUNGjTQhg0b1L9/f9NxgOoXp+OPKAEAAMC7HA5H0JymJ0khISFKT09nQAR8Ro2GQwAAAMC7guUeTsez2+0UJ/gMihMAAICPKy8vV05OTlAWp40bN8rpdJqOAlCcAAAAfN22bdvkcrmC4ua3x7Pb7Tp8+LBycnJMRwEoTgAAAL4u2EaRexw/WQ8wjeIEAADg4xwOhxo0aKAWLVqYjuJVCQkJiouLozjBJ1CcAAAAfJxnMESw3fbFZrMxIAI+g+IEAADg44Jxop6H3W5XZmam6RgAxQkAAMDXWZYVdIMhPOx2uyzLUllZmekoCHIUJwAAAB9WUlKiXbt2BfURp2PHjlUMyABMoTgBAAD4sKysLEnBN1HPIz09XRKT9WAexQkAAMCHeY60BOupeo0bN1arVq0oTjCO4gQAAODDLMtSXFycmjRpYjqKMUzWgy8wXpxmzpyplJQURUZGqlevXvruu+9Ou/7Bgwc1atQotWjRQhEREWrfvr2WLl3qpbQAAADeFcwT9TyYrAdfYLQ4LViwQOPHj9fkyZO1bt06denSRf3799eePXtOun55ebmuuOIK5ebmauHChdq6davmzJmjli1bejk5AACAdzgcDoqT3a6cnByVlJSYjoIgZrQ4vfDCC7r77rs1cuRIde7cWbNnz1b9+vX1+uuvn3T9119/XQcOHNCiRYvUt29fpaSk6OKLL1aXLl28nBwAAMA7OOL0W3GSpE2bNhlOgmBmrDiVl5dr7dq16tev37/DhISoX79+WrNmzUm3+fjjj9W7d2+NGjVK8fHxstvtmjp1qpxO5yn3U1ZWpqKiokoPAAAAf7B//34dOHAg6ItT586dZbPZuM4JRhkrTvv27ZPT6VR8fHyl5fHx8crPzz/pNtu2bdPChQvldDq1dOlSTZw4Uc8//7yeeuqpU+5n2rRpio2NrXgkJSXV6tcBAABQV4J9op5HVFSUUlNTKU4wyvhwiDPhcrnUvHlzvfrqq+revbuGDRumP/3pT5o9e/Ypt5kwYYIKCwsrHjt27PBiYgAAgJrzFKfU1FTDScxjQARMCzO146ZNmyo0NFQFBQWVlhcUFCghIeGk27Ro0UL16tVTaGhoxbJOnTopPz9f5eXlCg8PP2GbiIgIRURE1G54AAAAL3A4HGrVqpUaNGhgOopxdrtdc+bMMR0DQczYEafw8HB1795dK1eurFjmcrm0cuVK9e7d+6Tb9O3bV1lZWXK5XBXLLMtSixYtTlqaAAAA/BmDIf7NbrcrPz9f+/btMx0FQcroqXrjx4/XnDlz9Oabb2rz5s267777VFpaqpEjR0qSRowYoQkTJlSsf9999+nAgQN64IEHZFmWlixZoqlTp2rUqFGmvgQAAIA6Q3H6t4yMDEnSxo0bDSdBsDJ2qp4kDRs2THv37tWkSZOUn5+vrl27atmyZRUDI/Ly8hQS8u9ul5SUpOXLl2vcuHE655xz1LJlSz3wwAN69NFHTX0JAAAAdcLtdsvhcGjEiBGmo/iE1NRUhYeHa8OGDbr44otNx0EQsrndbrfpEN5UVFSk2NhYFRYWKiYmxnQcAACAk9q5c6datWqlTz75REOGDDEdxyd06dJFvXv3Pu1gMOBMnEk38KupegAAAMHCM1GPU/X+zW63M5IcxlCcAAAAfJBlWQoNDVWbNm1MR/EZnuIUZCdMwUdQnAAAAHyQZVlq06aN6tWrZzqKz8jIyFBhYaF27txpOgqCEMUJAADABzFR70R2u12SOF0PRlCcAAAAfJDD4aA4/U5ycrIaNmxIcYIRFCcAAAAfc+zYMWVnZ1OcfickJETp6enKzMw0HQVBiOIEAADgY3Jzc3Xs2DGK00kwWQ+mUJwAAAB8jGcUeVpamuEkvsdut2vTpk1yOp2moyDIUJwAAAB8jGVZioyMVKtWrUxH8TkZGRk6cuSItm3bZjoKggzFCQAAwMc4HA6lpaUpJIRf1X6PyXowhe9GAAAAH8Mo8lNr3ry5mjZtyoAIeB3FCQAAwMdQnE7NZrMxIAJGUJwAAAB8yOHDh5WXl8dgiNOgOMEEihMAAIAPyc7OliSOOJ1GRkaGLMtSWVmZ6SgIIhQnAAAAH+IZRU5xOjW73S6n06mtW7eajoIgQnECAADwIZZlqVGjRmratKnpKD4rPT1dEpP14F0UJwAAAB9iWZbS0tJks9lMR/FZsbGxSkpKYrIevIriBAAA4EOYqFc9DIiAt1GcAAAAfIjD4aA4VUNGRgbFCV5FcQIAAPARBw8e1J49eyhO1WC325Wbm6vi4mLTURAkKE4AAAA+wuFwSGKiXnXY7XZJ0qZNmwwnQbCgOAEAAPgIzyhybn5btY4dOyokJIQBEfAaihMAAICPsCxLCQkJio6ONh3F50VFRSk1NZXrnOA1FCcAAAAfwWCIM8OACHgTxQkAAMBHMIr8zDCSHN5EcQIAAPABbreb4nSG7Ha7CgoKtHfvXtNREAQoTgAAAD6goKBAxcXFDIY4A57Jehx1gjdQnAAAAHwAo8jPXGpqqsLDwylO8AqKEwAAgA+wLEs2m03t2rUzHcVvhIWFqVOnThQneAXFCQAAwAdYlqWUlBRFRESYjuJXmKwHb6E4AQAA+ADLsri+qQY8k/XcbrfpKAhwFCcAAAAfwES9mrHb7SoqKtIvv/xiOgoCHMUJAADAMKfTqezsbIpTDXgm62VmZhpOgkBHcQIAADBsx44dKisrozjVQHJysqKjo7nOCXWO4gQAAGCYZVmSGEVeEzabreI6J6AuUZwAAAAMsyxL4eHhSk5ONh3FL1Gc4A0UJwAAAMMsy1K7du0UGhpqOopfstvt2rRpk5xOp+koCGA+UZxmzpyplJQURUZGqlevXvruu++qtd38+fNls9l0zTXX1G1AAACAOuRwODhN7yzY7XaVlZUpKyvLdBQEMOPFacGCBRo/frwmT56sdevWqUuXLurfv7/27Nlz2u1yc3P10EMP6cILL/RSUgAAgLrBKPKz45msx+l6qEvGi9MLL7ygu+++WyNHjlTnzp01e/Zs1a9fX6+//vopt3E6nRo+fLimTJmitm3bejEtAABA7SorK1Nubi7F6Sw0b95czZs3pzihThktTuXl5Vq7dq369etXsSwkJET9+vXTmjVrTrndX/7yFzVv3lx33nlnlfsoKytTUVFRpQcAAICv2LZtm1wul9LS0kxH8WsMiEBdM1qc9u3bJ6fTqfj4+ErL4+PjlZ+ff9JtVq9erX/84x+aM2dOtfYxbdo0xcbGVjySkpLOOjcAAEBtYRR57aA4oa4ZP1XvTBQXF+vWW2/VnDlz1LRp02ptM2HCBBUWFlY8duzYUccpAQAAqs/hcKhhw4ZKSEgwHcWv2e12ORwOHTlyxHQUBKgwkztv2rSpQkNDVVBQUGl5QUHBSf/nkZ2drdzcXA0dOrRimcvlkiSFhYVp69atateuXaVtIiIiFBERUQfpAQAAzp5nMITNZjMdxa/Z7XY5nU5t2bJFXbt2NR0HAcjoEafw8HB1795dK1eurFjmcrm0cuVK9e7d+4T1O3bsqMzMTK1fv77icdVVV+nSSy/V+vXrOQ0PAAD4HcuyuL6pFqSnp0tish7qjtEjTpI0fvx43XbbberRo4d69uyp6dOnq7S0VCNHjpQkjRgxQi1bttS0adMUGRlZMW7So1GjRpJ0wnIAAAB/YFmWLrroItMx/F5MTIxat25NcUKdMV6chg0bpr1792rSpEnKz89X165dtWzZsoqBEXl5eQoJ8atLsQAAAKqlpKREu3fvZjBELWFABOqSze12u02H8KaioiLFxsaqsLBQMTExpuMAAIAg9uOPP+rcc8/Vt99+q549e5qO4/cee+wxzZ8/X7m5uaajwE+cSTfgUA4AAIAhnlHkXONUO+x2u7Zv3859O1EnKE4AAACGWJalpk2bqnHjxqajBATPNe8bN240nASBiOIEAABgiGcUOWpHx44dFRoaynVOqBMUJwAAAEMcDgfFqRZFRkYqLS2N4oQ6QXECAAAwwO12a+vWrRSnWsZkPdQVihMAAIAB+/fv18GDBylOtcxutyszM9N0DAQgihMAAIABTNSrG3a7XXv37tWePXtMR0GAoTgBAAAY4ClOqamphpMEloyMDEnidD3UOooTAACAAQ6HQ0lJSapfv77pKAGlXbt2ioiIoDih1lGcAAAADGAUed0IDQ1V586dKU6odRQnAAAAAyzL4vqmOsJkPdQFihMAAICXuVwu7uFUhzzFye12m46CAEJxAgAA8LJdu3bp8OHDFKc6kpGRoeLiYuXl5ZmOggBCcQIAAPAyz0Q9ilPdsNvtkpish9pFcQIAAPAyy7IUFhamlJQU01ECUqtWrRQTE0NxQq2iOAEAAHiZZVlq06aN6tWrZzpKQLLZbAyIQK2jOAEAAHgZo8jrnt1uV2ZmpukYCCAUJwAAAC9jol7dy8jI0ObNm3Xs2DHTURAgKE4AAABedPToUW3bto3iVMfsdrvKy8uVlZVlOgoCBMUJAADAi3Jzc3Xs2DGKUx1LT0+XxGQ91B6KEwAAgBd5RpGnpaUZThLYmjVrpvj4eIoTag3FCQAAwIssy1JUVJRatmxpOkrAY7IeahPFCQAAwIscDofS0tIUEsKvYXWNyXqoTXzHAgAAeBGjyL0nIyNDWVlZOnz4sOkoCAAUJwAAAC+yLIvrm7zEbrfL5XJpy5YtpqMgAFCcAAAAvOTQoUPasWMHR5y8pHPnzpKYrIfaQXEyrKyszHQEAADgJdnZ2ZJEcfKS6OhopaSkUJxQKyhOBv34449KTU3V2rVrTUcBAABe4BlFTnHyHgZEoLZQnAxq3769EhMTNWjQoIq/QAEAgMBlWZYaN26suLg401GCRkZGBkecUCsoTgY1aNBAS5YsUaNGjdS/f3/t2bPHdCQAAFCHPIMhbDab6ShBw263a8eOHQyIwFmjOBnWtGlTLVu2TKWlpRo0aJBKSkpMRwIAAHWEUeTeN2TIEHXq1EmDBw/W3r17TceBH6M4+YA2bdro008/lWVZuu6661ReXm46EgAAqAMOh4Pi5GUxMTFaunSpSkpKdPXVV3NPJ9QYxclHdO3aVYsWLdKqVat05513yuVymY4EAABq0a+//qq9e/dSnAxISUnRJ598ovXr12vEiBH8noUaoTj5kMsuu0xvv/22/vu//1sTJkwwHQcAANQih8MhiYl6pvTs2VPvvPOO/vnPf/J7FmokzHQAVDZs2DDl5+dr7NixatGihcaOHWs6EgAAqAWeUeSpqamGkwSva6+9Vs8//7zGjx+vdu3a6Z577jEdCX6E4uSDHnjgAe3atUvjxo1TQkKCbrzxRtORAADAWbIsSy1atFB0dLTpKEFt7Nixys7O1n/+538qOTlZAwYMMB0JfoLi5KOmTZum3bt3a8SIEWrevLkuu+wy05EAAMBZYDCEb7DZbJo+fbpyc3P1xz/+UatXr1aXLl1Mx4If8IlrnGbOnKmUlBRFRkaqV69e+u6770657pw5c3ThhReqcePGaty4sfr163fa9f1VSEiI/vGPf+iyyy7TNddco/Xr15uOBAAAzgKjyH1HWFiY5s+fr7S0NA0ePFg7d+40HQl+wHhxWrBggcaPH6/Jkydr3bp16tKly2lvBvv555/rpptu0qpVq7RmzRolJSXpyiuvDMj/4OvVq6eFCxeqQ4cOGjhwoHJyckxHAgAANeB2uytufgvf0LBhQy1evFghISEaMmSIiouLTUeCj7O53W63yQC9evXSeeedpxkzZkiSXC6XkpKSdP/99+uxxx6rcnun06nGjRtrxowZGjFixAmfLysrU1lZWcXzoqIiJSUlqbCwUDExMbX3hdShPXv2qE+fPgoJCdHXX3+tpk2bmo4EAADOwO7du5WYmKhFixbp6quvNh0Hx8nMzFTfvn114YUX6qOPPlJYGFeyBJOioiLFxsZWqxsYPeJUXl6utWvXql+/fhXLQkJC1K9fP61Zs6Zar3Ho0CEdPXpUTZo0Oennp02bptjY2IpHUlJSrWT3pubNm2v58uUqLCzUkCFDVFpaajoSAAA4A4wi910ZGRlauHChli9frjFjxsjwMQX4MKPFad++fXI6nYqPj6+0PD4+Xvn5+dV6jUcffVSJiYmVytfxJkyYoMLCworHjh07zjq3Ce3atdPSpUu1YcMG3XDDDTp69KjpSAAAoJosy1JISIjatm1rOgpO4sorr9SsWbM0a9YsvfDCC6bjwEf59bHIZ555RvPnz9fnn3+uyMjIk64TERGhiIgILyerG927d9cHH3ygwYMH6z/+4z/0j3/8QzabzXQsAABQBcuylJKSEjC/kwSiu+++W9u2bdPDDz+slJQUXXfddaYjwccYLU5NmzZVaGioCgoKKi0vKChQQkLCabd97rnn9Mwzz+izzz7TOeecU5cxfcqVV16pN954Q7feeqsSExP11FNPmY4EAACqwGAI//D0008rJydHt9xyi1q1aqVevXqZjgQfYvRUvfDwcHXv3l0rV66sWOZyubRy5Ur17t37lNv99a9/1ZNPPqlly5apR48e3ojqU2655Rb97W9/09NPP62ZM2eajgMAAKrAKHL/EBISorlz5+rcc8/V0KFDtW3bNtOR4EOMjyMfP3685syZozfffFObN2/Wfffdp9LSUo0cOVKSNGLECE2YMKFi/WeffVYTJ07U66+/rpSUFOXn5ys/P18lJSWmvgQjHnzwQY0bN07333+/Fi5caDoOAAA4BafTqezsbIqTn4iMjNRHH32k2NhYDR48WL/++qvpSPARxq9xGjZsmPbu3atJkyYpPz9fXbt21bJlyyoGRuTl5Skk5N/9btasWSovL9f1119f6XUmT56sP//5z96MbpTNZtNzzz2n3bt3a/jw4WrWrJkuvvhi07EAAMDv5OXlqby8nOLkR5o2baqlS5fq/PPP1x/+8ActX75c4eHhpmPBMOP3cfK2M5nV7g/Kyso0ePBg/fDDD/rXv/6ljIwM05EAAMBxli9frgEDBignJ0cpKSmm4+AMrF69WpdffrmGDRumN998k6FcAchv7uOEsxcREaEPPvhAbdq00YABA5SXl2c6EgAAOI5lWQoPD/fLe0kGuwsuuEBz587V22+/rSlTppiOA8MoTgEgJiZGn376qSIiItS/f3/t37/fdCQAAPD/LMtSamqqQkNDTUdBDdx000166qmnNGXKFL311lum48AgilOASEhI0LJly7Rv3z4NHTpUhw4dMh0JAABIcjgcXN/k5x5//HHdcccduuuuu/T555+bjgNDKE4BpH379lqyZIl++ukn3XTTTTp27JjpSAAABD1Gkfs/m82m2bNn6+KLL9a1116rzZs3m44EAyhOAaZnz55auHChlixZov/8z/9UkM3+AADAp5SVlSk3N5eb3waAevXqaeHChWrZsqUGDRqkgoIC05HgZRSnADRw4EC99tprmjNnDhcyAgBgUHZ2ttxuN0ecAkRsbKyWLFmiI0eO6KqrruLSiCBDcQpQt99+u6ZOnaopU6bo1VdfNR0HAICg5HA4JIniFEBat26tTz75RBs2bNCtt94ql8tlOhK8hOIUwB577DGNHj1a9913nz766CPTcQAACDqWZSk6Olrx8fGmo6AW9ejRQ++++64+/PBDPfLII6bjwEsoTgHMZrNp+vTp+sMf/qAbb7xRX331lelIAAAEFc9gCG6cGniuuuoqTZ8+Xc8//7xeeeUV03HgBRSnABcaGqq3335bvXr10tChQ7Vp0ybTkQAACBqWZTEYIoCNGTNGY8aM0f33368lS5aYjoM6RnEKApGRkVq0aJFatWqlAQMG6JdffjEdCQCAoMAo8sD3wgsvaMiQIRo2bJh+/PFH03FQhyhOQaJRo0b69NNPZbPZNHDgQP3666+mIwEAENCKi4uVn59PcQpwoaGhmjdvnjp16qQhQ4Zox44dpiOhjlCcgkjLli21bNky7dq1S1dffbWOHDliOhIAAAGLiXrBo0GDBvrkk08UFhamwYMHq6ioyHQk1AGKU5Dp1KmTFi9erB9++EHDhw+X0+k0HQkAgIBkWZYkcY1TkEhISNDSpUu1fft23XDDDTp69KjpSKhlFKcg1Lt3by1YsECLFi3SmDFj5Ha7TUcCACDgWJalZs2aqVGjRqajwEvS09P1z3/+UytXrtTo0aP5HSvAUJyC1NChQ/Vf//VfeuWVVzR16lTTcQAACDgMhghO/fr106uvvqpXX31Vf/vb30zHQS0KMx0A5tx1113atWuXnnjiCbVo0UJ33HGH6UgAAAQMh8Oh9PR00zFgwMiRI5Wdna1HH31UKSkpuuGGG0xHQi2gOAW5iRMnateuXbrnnnvUvHlzDRkyxHQkAAD8ntvtlmVZuvbaa01HgSFPPvmktm3bphEjRqhVq1bq06eP6Ug4S5yqF+RsNptmzpypoUOH6oYbbtA333xjOhIAAH5v3759OnjwIIMhgpjNZtMbb7yhnj176uqrr1Z2drbpSDhLFCdU3H/g3HPP1ZAhQ7R161bTkQAA8GueiXpc4xTcIiIi9OGHH6px48YaNGiQ9u/fbzoSzgLFCZKkqKgoffzxx4qPj1f//v21a9cu05EAAPBbnns4paamGk4C0+Li4rR06VIdOHBA1157rcrKykxHQg1RnFChSZMmWrZsmY4dO6ZBgwapsLDQdCQAAPySZVlKTk5WVFSU6SjwAampqfroo4/03Xff6Y477mBMuZ+iOKGSpKQkLV++XNu3b+evIgAA1BCjyPF7ffr00VtvvaV58+Zp0qRJpuOgBihOOEF6ero+/vhjff311xoxYoRcLpfpSAAA+BXLshgMgRPccMMNeuaZZ/TUU0/pjTfeMB0HZ4jihJO68MIL9e6772rhwoUaN24ch5QBAKgml8slh8PBESec1COPPKK7775b99xzjz777DPTcXAGKE44pWuvvVYzZ87USy+9xJ2vAQCopp07d+rIkSMUJ5yU51Ywl112ma677jpt3LjRdCRUE8UJp3Xvvfdq4sSJevTRR/XWW2+ZjgMAgM9jFDmqUq9ePb3//vtq3bq1Bg0apPz8fNORUA0UJ1RpypQpuvPOO3XnnXdq2bJlpuMAAODTLMtSWFiYUlJSTEeBD4uJidGSJUt07NgxDR06VKWlpaYjoQoUJ1TJZrNp9uzZGjBggK6//np9//33piMBAOCzLMtS27ZtFRYWZjoKfFxSUpIWL16szZs36+abb5bT6TQdCadBcUK1hIWFacGCBcrIyNDgwYMrbuwHAAAqYxQ5zkS3bt20YMECLV68WA8++KDpODgNihOqrX79+vrkk0/UpEkT9e/fn/NxAQD4f263W7m5ufrkk0+0fv16ihPOyODBg/XSSy/pxRdf1Msvv2w6Dk6BY8g4I02bNtWyZcvUp08fDRo0SF988YWio6NNxwIAwGuKioq0YcMG/fzzzxWPzMxMFRUVSZIaN26sK6+80nBK+JtRo0Zp27ZtGjt2rFq3bq2rrrrKdCT8js0dZDfoKSoqUmxsrAoLCxUTE2M6jt/66aefdNFFF6lnz55asmSJwsPDTUcCAKBWOZ1OZWVlVSpHP//8s3JyciT9dhp7x44ddc4551Q8MjIy1LJlS9lsNsPp4Y9cLpeuv/56LV++XF9++aW6d+9uOlLAO5NuQHFCja1atUoDBgzQH//4R7311lsKCeHMTwCAf9q3b19FMfI8Nm7cqMOHD0uSWrRooYyMjEolqWPHjoqIiDCcHIHm0KFDuvTSS5WXl6dvvvlGrVu3Nh0poFGcToPiVLvee+893XjjjXrwwQe5SS4AwOeVl5dry5YtJ5xmt2vXLklSZGSk0tPTTziK1KxZM8PJEUwKCgp0/vnnq0GDBvrqq68UGxtrOlLAojidBsWp9r388ssaM2aMunXrpoSEBDVr1uykj6ZNm6pZs2aKiYnhFAYAQJ1yu93atWvXCUeRNm/erGPHjkmSUlJSTihIqampjBGHT9i8ebP69OmjHj16aOnSpapXr57pSAHJ74rTzJkz9be//U35+fnq0qWLXn75ZfXs2fOU67///vuaOHGicnNzlZaWpmeffVaDBg2q1r4oTnVj7ty5+uqrr7R3795Kj4MHD56wbnh4eEWJOt3Ds06TJk04DRAAcEqHDh3Sxo0bKxWkn3/+WQcOHJAkRUdHVxQjT0my2+38FR8+b9WqVerfv79uvfVWvfbaa/zhuQ74VXFasGCBRowYodmzZ6tXr16aPn263n//fW3dulXNmzc/Yf2vv/5aF110kaZNm6YhQ4Zo3rx5evbZZ7Vu3TrZ7fYq90dx8q6jR49q37592rdv3wml6vcPz3oul6vSa4SEhCguLq7KgnX8c/4qAwCBx+VyKTc394RhDQ6HQ263WyEhIUpLS6t0FOmcc85R69at+YUTfuvNN9/U7bffrqefflqPP/646TgBx6+KU69evXTeeedpxowZkn77n2JSUpLuv/9+PfbYYyesP2zYMJWWlmrx4sUVy84//3x17dpVs2fPrnJ/FCff5nK59Ouvv1ZZsI5/Xl5efsLrNGrUqFoly/OIiooy8NUCZ8/lcunYsWMVj6NHj57yeXU/V9V6TqdTYWFhqlevXsXj98/PdplnOb/sBq/CwsITTrPLzMxUSUmJJCkuLk5dunSpdJpd586dVb9+fcPJgdo3efJk/eUvf9G8efN00003mY4TUM6kGxg9ibe8vFxr167VhAkTKpaFhISoX79+WrNmzUm3WbNmjcaPH19pWf/+/bVo0aKTrl9WVqaysrKK5557LMA3eY4uxcXFqWPHjlWu73a7VVxcXGW5+umnnyo+Li0tPeF1GjRoUFGiYmNjZbPZZLPZFBISUvHx75+f6cfe2ub32/s7t9stz993PB+f7OEPn3e5XLVebH5/hLa2hYaGVhSbsLAwhYWFKTQ0tCKHJ8vRo0frbP91WdB+fxrw8d8zp/rYm+udyWvUNW/8ndVzyl1mZqa2b98uSapXr546d+6sjIwMXXvttRVFKSEhISD+HwdUx5///Gfl5OTo9ttv1/z58yWp0s8ef/xn9+7d9corr9Tw34gZRovTvn375HQ6FR8fX2l5fHy8tmzZctJt8vPzT7p+fn7+SdefNm2apkyZUjuB4XNsNptiYmIUExOjdu3aVWubw4cPn7RceR5FRUWVfuF1uVyVPvY8//1yX/w4UH6pOL4EHl8Kf//w9c/bbLZKv8BHRUWdUEqqeu7NdUNDQ6v935Db7ZbT6TyhTB3/ONmyM1m3Jq9ZVlamkpKSU657fBk41cdVPa/p52r7dbzx/V7X+wgPD1enTp104403VhSkDh06cPo1gp7NZtOcOXPUqFGjivuIeb4fPX8AOv7n0Mn+WZ11vPnPtm3b1uxfhkEBPzZmwoQJlY5QFRUVKSkpyWAimBYVFaXk5GQlJyebjgIEDJvNVlG6OPUVAGpfRESEXnrpJdMxgprR4tS0aVOFhoaqoKCg0vKCggIlJCScdJuEhIQzWj8iIoKb0wEAAAA4K0ZnPIeHh6t79+5auXJlxTKXy6WVK1eqd+/eJ92md+/eldaXpBUrVpxyfQAAAAA4W8ZP1Rs/frxuu+029ejRQz179tT06dNVWlqqkSNHSpJGjBihli1batq0aZKkBx54QBdffLGef/55DR48WPPnz9cPP/ygV1991eSXAQAAACCAGS9Ow4YN0969ezVp0iTl5+era9euWrZsWcUAiLy8vEpTj/r06aN58+bpiSee0OOPP660tDQtWrSoWvdwAgAAAICaMH4fJ2/jPk4AAAAApDPrBkavcQIAAAAAf0BxAgAAAIAqUJwAAAAAoAoUJwAAAACoAsUJAAAAAKpAcQIAAACAKlCcAAAAAKAKFCcAAAAAqALFCQAAAACqQHECAAAAgCqEmQ7gbW63W5JUVFRkOAkAAAAAkzydwNMRTifoilNxcbEkKSkpyXASAAAAAL6guLhYsbGxp13H5q5OvQogLpdLu3btUnR0tGw2m+k4KioqUlJSknbs2KGYmBjTcYIe74fv4T3xLbwfvof3xPfwnvgW3g/f40vvidvtVnFxsRITExUScvqrmILuiFNISIhatWplOsYJYmJijP+Hg3/j/fA9vCe+hffD9/Ce+B7eE9/C++F7fOU9qepIkwfDIQAAAACgChQnAAAAAKgCxcmwiIgITZ48WREREaajQLwfvoj3xLfwfvge3hPfw3viW3g/fI+/vidBNxwCAAAAAM4UR5wAAAAAoAoUJwAAAACoAsUJAAAAAKpAcQIAAACAKlCcDJo5c6ZSUlIUGRmpXr166bvvvjMdKWhNmzZN5513nqKjo9W8eXNdc8012rp1q+lY+H/PPPOMbDabxo4dazpKUNu5c6duueUWxcXFKSoqShkZGfrhhx9MxwpaTqdTEydOVJs2bRQVFaV27drpySefFDOfvOfLL7/U0KFDlZiYKJvNpkWLFlX6vNvt1qRJk9SiRQtFRUWpX79+cjgcZsIGgdO9H0ePHtWjjz6qjIwMNWjQQImJiRoxYoR27dplLnAQqOp75Hj33nuvbDabpk+f7rV8Z4riZMiCBQs0fvx4TZ48WevWrVOXLl3Uv39/7dmzx3S0oPTFF19o1KhR+uabb7RixQodPXpUV155pUpLS01HC3rff/+9/uu//kvnnHOO6ShB7ddff1Xfvn1Vr149ffrpp9q0aZOef/55NW7c2HS0oPXss89q1qxZmjFjhjZv3qxnn31Wf/3rX/Xyyy+bjhY0SktL1aVLF82cOfOkn//rX/+ql156SbNnz9a3336rBg0aqH///jpy5IiXkwaH070fhw4d0rp16zRx4kStW7dOH3zwgbZu3aqrrrrKQNLgUdX3iMeHH36ob775RomJiV5KVkNuGNGzZ0/3qFGjKp47nU53YmKie9q0aQZTwWPPnj1uSe4vvvjCdJSgVlxc7E5LS3OvWLHCffHFF7sfeOAB05GC1qOPPuq+4IILTMfAcQYPHuy+4447Ki37wx/+4B4+fLihRMFNkvvDDz+seO5yudwJCQnuv/3tbxXLDh486I6IiHC/++67BhIGl9+/Hyfz3XffuSW5t2/f7p1QQe5U78kvv/zibtmypXvDhg3u1q1bu//+9797PVt1ccTJgPLycq1du1b9+vWrWBYSEqJ+/fppzZo1BpPBo7CwUJLUpEkTw0mC26hRozR48OBK3ysw4+OPP1aPHj30xz/+Uc2bN1e3bt00Z84c07GCWp8+fbRy5UpZliVJ+umnn7R69WoNHDjQcDJIUk5OjvLz8yv9/ys2Nla9evXiZ72PKCwslM1mU6NGjUxHCVoul0u33nqrHn74YaWnp5uOU6Uw0wGC0b59++R0OhUfH19peXx8vLZs2WIoFTxcLpfGjh2rvn37ym63m44TtObPn69169bp+++/Nx0FkrZt26ZZs2Zp/Pjxevzxx/X9999rzJgxCg8P12233WY6XlB67LHHVFRUpI4dOyo0NFROp1NPP/20hg8fbjoaJOXn50vSSX/Wez4Hc44cOaJHH31UN910k2JiYkzHCVrPPvuswsLCNGbMGNNRqoXiBPzOqFGjtGHDBq1evdp0lKC1Y8cOPfDAA1qxYoUiIyNNx4F++4NCjx49NHXqVElSt27dtGHDBs2ePZviZMh7772nd955R/PmzVN6errWr1+vsWPHKjExkfcEOI2jR4/qhhtukNvt1qxZs0zHCVpr167Viy++qHXr1slms5mOUy2cqmdA06ZNFRoaqoKCgkrLCwoKlJCQYCgVJGn06NFavHixVq1apVatWpmOE7TWrl2rPXv26Nxzz1VYWJjCwsL0xRdf6KWXXlJYWJicTqfpiEGnRYsW6ty5c6VlnTp1Ul5enqFEePjhh/XYY4/pxhtvVEZGhm699VaNGzdO06ZNMx0NUsXPc37W+xZPadq+fbtWrFjB0SaD/vWvf2nPnj1KTk6u+Fm/fft2Pfjgg0pJSTEd76QoTgaEh4ere/fuWrlyZcUyl8ullStXqnfv3gaTBS+3263Ro0frww8/1P/+7/+qTZs2piMFtcsvv1yZmZlav359xaNHjx4aPny41q9fr9DQUNMRg07fvn1PGNFvWZZat25tKBEOHTqkkJDKP8ZDQ0PlcrkMJcLx2rRpo4SEhEo/64uKivTtt9/ys94QT2lyOBz67LPPFBcXZzpSULv11lv1888/V/pZn5iYqIcffljLly83He+kOFXPkPHjx+u2225Tjx491LNnT02fPl2lpaUaOXKk6WhBadSoUZo3b54++ugjRUdHV5x/Hhsbq6ioKMPpgk90dPQJ15c1aNBAcXFxXHdmyLhx49SnTx9NnTpVN9xwg7777ju9+uqrevXVV01HC1pDhw7V008/reTkZKWnp+vHH3/UCy+8oDvuuMN0tKBRUlKirKysiuc5OTlav369mjRpouTkZI0dO1ZPPfWU0tLS1KZNG02cOFGJiYm65pprzIUOYKd7P1q0aKHrr79e69at0+LFi+V0Oit+1jdp0kTh4eGmYge0qr5Hfl9e69Wrp4SEBHXo0MHbUavH9Fi/YPbyyy+7k5OT3eHh4e6ePXu6v/nmG9ORgpakkz7eeOMN09Hw/xhHbt4nn3zittvt7oiICHfHjh3dr776qulIQa2oqMj9wAMPuJOTk92RkZHutm3buv/0pz+5y8rKTEcLGqtWrTrpz47bbrvN7Xb/NpJ84sSJ7vj4eHdERIT78ssvd2/dutVs6AB2uvcjJyfnlD/rV61aZTp6wKrqe+T3fH0cuc3t5hbjAAAAAHA6XOMEAAAAAFWgOAEAAABAFShOAAAAAFAFihMAAAAAVIHiBAAAAABVoDgBAAAAQBUoTgAAAABQBYoTAAAAAFSB4gQA8BmXXHKJxo4dazpGJTabTYsWLTIdAwBgmM3tdrtNhwAAQJIOHDigevXqKTo6WikpKRo7dqzXitSf//xnLVq0SOvXr6+0PD8/X40bN1ZERIRXcgAAfFOY6QAAAHg0adKk1l+zvLxc4eHhNd4+ISGhFtMAAPwVp+oBAHyG51S9Sy65RNu3b9e4ceNks9lks9kq1lm9erUuvPBCRUVFKSkpSWPGjFFpaWnF51NSUvTkk09qxIgRiomJ0T333CNJevTRR9W+fXvVr19fbdu21cSJE3X06FFJ0ty5czVlyhT99NNPFfubO3eupBNP1cvMzNRll12mqKgoxcXF6Z577lFJSUnF52+//XZdc801eu6559SiRQvFxcVp1KhRFfsCAPgnihMAwOd88MEHatWqlf7yl79o9+7d2r17tyQpOztbAwYM0HXXXaeff/5ZCxYs0OrVqzV69OhK2z/33HPq0qWLfvzxR02cOFGSFB0drblz52rTpk168cUXNWfOHP3973+XJA0bNkwPPvig0tPTK/Y3bNiwE3KVlpaqf//+aty4sb7//nu9//77+uyzz07Y/6pVq5Sdna1Vq1bpzTff1Ny5cyuKGADAP3GqHgDA5zRp0kShoaGKjo6udKrctGnTNHz48IrrntLS0vTSSy/p4osv1qxZsxQZGSlJuuyyy/Tggw9Wes0nnnii4uOUlBQ99NBDmj9/vh555BFFRUWpYcOGCgsLO+2pefPmzdORI0f01ltvqUGDBpKkGTNmaOjQoXr22WcVHx8vSWrcuLFmzJih0NBQdezYUYMHD9bKlSt1991318q/HwCA91GcAAB+46efftLPP/+sd955p2KZ2+2Wy+VSTk6OOnXqJEnq0aPHCdsuWLBAL730krKzs1VSUqJjx44pJibmjPa/efNmdenSpaI0SVLfvn3lcrm0devWiuKUnp6u0NDQinVatGihzMzMM9oXAMC3UJwAAH6jpKRE//Ef/6ExY8ac8Lnk5OSKj48vNpK0Zs0aDR8+XFOmTFH//v0VGxur+fPn6/nnn6+TnPXq1av03GazyeVy1cm+AADeQXECAPik8PBwOZ3OSsvOPfdcbdq0SampqWf0Wl9//bVat26tP/3pTxXLtm/fXuX+fq9Tp06aO3euSktLK8rZV199pZCQEHXo0OGMMgEA/AvDIQAAPiklJUVffvmldu7cqX379kn6bTLe119/rdGjR2v9+vVyOBz66KOPThjO8HtpaWnKy8vT/PnzlZ2drZdeekkffvjhCfvLycnR+vXrtW/fPpWVlZ3wOsOHD1dkZKRuu+02bdiwQatWrdL999+vW2+9teI0PQBAYKI4AQB80l/+8hfl5uaqXbt2atasmSTpnHPO0RdffCHLsnThhReqW7dumjRpkhITE0/7WldddZXGjRun0aNHq2vXrvr6668rpu15XHfddRowYIAuvfRSNWvWTO++++4Jr1O/fn0tX75cBw4c0Hnnnafrr79el19+uWbMmFF7XzgAwCfZ3G6323QIAAAAAPBlHHECAAAAgCpQnAAAAACgChQnAAAAAKgCxQkAAAAAqkBxAgAAAIAqUJwAAAAAoAoUJwAAAACoAsUJAAAAAKpAcQIAAACAKlCcAAAAAKAKFCcAAAAAqML/AUuVACUpQQexAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.neural_network import MLPRegressor\n",
    "\n",
    "y_train_norm = norm(X_train)\n",
    "y_test_norm = norm(X_test)\n",
    "\n",
    "clf = MLPRegressor(random_state=1, \n",
    "                    max_iter=1000,\n",
    "                    verbose = False)\n",
    "\n",
    "clf.fit(X_train[list(set(X_train.columns) - {'value', 'task_id'})], y_train_norm)\n",
    "preds_proba = clf.predict(X_test[list(set(X_test.columns) - {'value', 'task_id'})])\n",
    "\n",
    "test_data = X_test.copy()\n",
    "test_data['prob'] = preds_proba\n",
    "test_data['value'] = y_test_norm\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(np.array)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(np.array)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "plt.plot(clf.loss_curve_, color = 'black', linewidth=1)\n",
    "plt.title('MLP')\n",
    "plt.xlabel(\"iteration\")\n",
    "plt.ylabel(\"loss\")\n",
    "\n",
    "ndcg_score_skl = []\n",
    "for idx in range(len(y_true)):\n",
    "    ndcg_score_skl.append(sklearn.metrics.ndcg_score([y_true[idx]], [y_pred[idx]]))\n",
    "\n",
    "print(f'NDCG_sklearn: {np.mean(ndcg_score_skl)}')\n",
    "print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CatBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_920854/3633819575.py:22: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
      "/tmp/ipykernel_920854/3633819575.py:23: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1-score: 0.7091670544439274\n",
      "NDCG_sklearn: 0.9887497583625292\n",
      "NDCG_my_implementation: 0.8974712719807446\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.32222222222222224\n",
      "HITS@3: 0.35555555555555557\n",
      "HITS@7: 0.6333333333333333\n",
      "MRR: 0.4257618012967043\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from catboost import CatBoostClassifier, Pool\n",
    "\n",
    "pool_train = Pool(X_train[list(set(X_train.columns) - {'value', 'task_id'})], y_train, cat_features = list(dict_category.keys()))\n",
    "pool_test = Pool(X_test[list(set(X_test.columns) - {'value', 'task_id'})], cat_features = list(dict_category.keys()))\n",
    "\n",
    "model = CatBoostClassifier(random_state=1, iterations=1000,\n",
    "                           learning_rate=0.03,\n",
    "                            l2_leaf_reg=3,\n",
    "                            loss_function='CrossEntropy',\n",
    "                           depth=6, verbose=False)\n",
    "model.fit(pool_train)\n",
    "preds_class = model.predict(pool_test)\n",
    "preds_proba = model.predict_proba(pool_test)\n",
    "\n",
    "test_data = X_test.copy()\n",
    "test_data['prob'] = preds_proba[:,1]\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(np.array)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(np.array)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "plt.plot(model.evals_result_['learn']['CrossEntropy'], color = 'black', linewidth=1)\n",
    "plt.title('CatBoost')\n",
    "plt.xlabel(\"iteration\")\n",
    "plt.ylabel(\"loss\")\n",
    "\n",
    "print(f'F1-score: {sklearn.metrics.f1_score(y_test, preds_class)}')\n",
    "ndcg_score_skl = []\n",
    "for idx in range(len(y_true)):\n",
    "    ndcg_score_skl.append(sklearn.metrics.ndcg_score([y_true[idx]], [y_pred[idx]])) \n",
    "\n",
    "print(f'NDCG_sklearn: {np.mean(ndcg_score_skl)}')\n",
    "print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')\n",
    "\n",
    "plt.savefig(fname = \"./catboost.png\", dpi=300, facecolor='w', edgecolor='w',\n",
    "            orientation='portrait', format=None, \n",
    "            transparent=False, bbox_inches=None, pad_inches=0.1,\n",
    "            metadata=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cols = X_train[list(set(X_train.columns) - {'value', 'task_id'})].columns\n",
    "values = model.get_feature_importance()\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "sns.set(font_scale=0.8)\n",
    "palette = sns.color_palette(\"crest\", as_cmap=True)\n",
    "plt.title('Distribution of feature importance')\n",
    "sns.barplot(y=cols, x=values, palette=['slateblue']*len(cols))\n",
    "\n",
    "plt.savefig(fname = \"./fig/get_feature_importance.png\", dpi=300, facecolor='w', edgecolor='w',\n",
    "            orientation='portrait',bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MLPClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/home/eegorova/.local/lib/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:1091: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/tmp/ipykernel_920854/1841509076.py:18: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
      "/tmp/ipykernel_920854/1841509076.py:19: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1-score: 0.7182009838369642\n",
      "NDCG_sklearn: 0.9730655236333511\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.13186813186813187\n",
      "HITS@3: 0.2967032967032967\n",
      "HITS@7: 0.5274725274725275\n",
      "MRR: 0.327783267367679\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "clf = MLPClassifier(random_state=1, \n",
    "                    max_iter=1000,\n",
    "                    verbose = False)\n",
    "\n",
    "clf.fit(X_train[list(set(X_train.columns) - {'value', 'task_id'})], y_train)\n",
    "preds_class = clf.predict(X_test[list(set(X_test.columns) - {'value', 'task_id'})])\n",
    "preds_proba = clf.predict_proba(X_test[list(set(X_test.columns) - {'value', 'task_id'})])\n",
    "\n",
    "test_data = X_test.copy()\n",
    "test_data['prob'] = preds_proba[:,1]\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(np.array)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(np.array)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "plt.plot(clf.loss_curve_, color = 'black', linewidth=1)\n",
    "plt.title('MLP')\n",
    "plt.xlabel(\"iteration\")\n",
    "plt.ylabel(\"loss\")\n",
    "\n",
    "print(f'F1-score: {sklearn.metrics.f1_score(y_test, preds_class)}')\n",
    "ndcg_score_skl = []\n",
    "for idx in range(len(y_true)):\n",
    "    ndcg_score_skl.append(sklearn.metrics.ndcg_score([y_true[idx]], [y_pred[idx]])) \n",
    "\n",
    "print(f'NDCG_sklearn: {np.mean(ndcg_score_skl)}')\n",
    "# print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/home/eegorova/.local/lib/python3.9/site-packages/sklearn/utils/validation.py:1141: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1-score: 0.0\n",
      "NDCG_sklearn: 0.9581526043663249\n",
      "NDCG_my_implementation: 0.8407176032787944\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.2\n",
      "HITS@3: 0.24\n",
      "HITS@7: 0.8\n",
      "MRR: 0.42987830687830686\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/home/eegorova/.local/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "clf = LogisticRegression(random_state=1)\n",
    "\n",
    "clf.fit(X_train[list(set(X_train.columns) - {'value', 'task_id'})], y_train)\n",
    "preds_class = clf.predict(X_test[list(set(X_test.columns) - {'value', 'task_id'})])\n",
    "preds_proba = clf.predict_proba(X_test[list(set(X_test.columns) - {'value', 'task_id'})])\n",
    "\n",
    "test_data = X_test.copy()\n",
    "test_data['prob'] = preds_proba[:,1]\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(list)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(list)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "print(f'F1-score: {sklearn.metrics.f1_score(y_test, preds_class)}')\n",
    "print(f'NDCG_sklearn: {sklearn.metrics.ndcg_score(y_true, y_pred)}')\n",
    "print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/home/eegorova/.local/lib/python3.9/site-packages/sklearn/utils/validation.py:1141: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1-score: 0.0\n",
      "NDCG_sklearn: 0.8748003416211196\n",
      "NDCG_my_implementation: 0.6965330683778072\n",
      "\n",
      "HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K\n",
      "HITS@1: 0.0\n",
      "HITS@3: 0.04\n",
      "HITS@7: 0.24\n",
      "MRR: 0.16526455026455025\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "\n",
    "clf = SVC(random_state=1, probability=True)\n",
    "\n",
    "clf.fit(X_train[list(set(X_train.columns) - {'value', 'task_id'})], y_train)\n",
    "preds_class = clf.predict(X_test[list(set(X_test.columns) - {'value', 'task_id'})])\n",
    "preds_proba = clf.predict_proba(X_test[list(set(X_test.columns) - {'value', 'task_id'})])\n",
    "\n",
    "test_data = X_test.copy()\n",
    "test_data['prob'] = preds_proba[:,1]\n",
    "test_data = pd.concat([test_data, y_test], axis = 1)\n",
    "y_neg = np.array(test_data[test_data['label'] == 0].groupby('task_id')['prob'].apply(list))\n",
    "y_pos = np.array(test_data[test_data['label'] == 1].groupby('task_id')['prob'].apply(list))\n",
    "y_true = test_data.groupby('task_id')['value'].apply(list)\n",
    "y_pred = test_data.groupby('task_id')['prob'].apply(list)\n",
    "y_true = np.array([y_true.values[i] for i in range(len(y_true))])\n",
    "y_pred = np.array([y_pred.values[i] for i in range(len(y_pred))])\n",
    "\n",
    "print(f'F1-score: {sklearn.metrics.f1_score(y_test, preds_class)}')\n",
    "print(f'NDCG_sklearn: {sklearn.metrics.ndcg_score(y_true, y_pred)}')\n",
    "print(f'NDCG_my_implementation: {ndcg(y_true, y_pred)}')\n",
    "mrr, hits1, hits3, hits7 = eval(y_pos, y_neg)\n",
    "print()\n",
    "print ('HITS@K все POS_ElEMENTS содержатся в предсказанных TOP-K')\n",
    "print(f'HITS@1: {hits1}')\n",
    "print(f'HITS@3: {hits3}')\n",
    "print(f'HITS@7: {hits7}')\n",
    "print(f'MRR: {mrr}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MLP with RANKNET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.optim import Optimizer\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "BATCH_SIZE = 32\n",
    "EPOCH = 100\n",
    "NUM_WORKERS = 8\n",
    "LEARNING_RATE = 0.0001\n",
    "device = torch.device(\"cpu\") #mps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "class pair_dataset(Dataset):\n",
    "    def __init__(self,data):\n",
    "    \n",
    "        self.data = data\n",
    "        self.x1 = torch.tensor(np.array(self.data[list(set(self.data.columns) - {'value', 'task_id'})]), dtype=torch.float32) #dtype=torch.float16\n",
    "        self.y1 = np.array(self.data['value'])\n",
    "\n",
    "        self.x2 = pd.DataFrame()\n",
    "        self.y2 = np.array([])\n",
    "        for i in self.data.index:\n",
    "            new_row = self.data[self.data['task_id'] == self.data['task_id'][i]].drop(index=i,columns =['value','task_id']).sample(n=1)\n",
    "            self.x2 = self.x2.append(new_row)\n",
    "            self.y2 = np.append(self.y2, self.data['value'][new_row.index])\n",
    "\n",
    "        self.x2 = torch.tensor(np.array(self.x2), dtype=torch.float32) #dtype=torch.float16\n",
    "        self.y2 = np.array(self.y2)\n",
    "\n",
    "        self.compare = torch.tensor([1.0 if t1 > t2 else 0.0 if t1 < t2 else 0.5 for t1,t2 in zip(self.y1,self.y2)], dtype=torch.float32) #dtype=torch.float16\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.x1[idx], self.x2[idx], self.compare[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLP_RankNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MLP_RankNet, self).__init__()\n",
    "        self.fc1 = nn.Linear(18, 10)\n",
    "        self.bn = torch.nn.BatchNorm1d(num_features=10)\n",
    "        self.fc2 = nn.Linear(10, 1)\n",
    "\n",
    "    def forward(self, x1, x2, t):\n",
    "        s1 = self.fc1(x1)\n",
    "        s1 = self.bn(s1)\n",
    "        s1 = F.relu(s1)\n",
    "        s1 = self.fc2(s1)\n",
    "        s1 = F.relu6(s1)\n",
    "\n",
    "        s2 = self.fc1(x2)\n",
    "        s2 = self.bn(s2)\n",
    "        s2 = F.relu(s2)\n",
    "        s2 = self.fc2(s2)\n",
    "        s2 = F.relu6(s2)     \n",
    "        \n",
    "        return self.ranknet_loss(s1, s2, t)\n",
    "    \n",
    "    def ranknet_loss(self, s1, s2, t):\n",
    "        o = torch.sigmoid(s1 - s2)\n",
    "        loss = (-t * o + F.softplus(o)).mean()\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:57<00:00,  1.73it/s]\n"
     ]
    }
   ],
   "source": [
    "ranknet_model = MLP_RankNet().to(device)\n",
    "optimizer = torch.optim.Adam( filter(lambda p: p.requires_grad, ranknet_model.parameters()), lr=LEARNING_RATE)\n",
    "\n",
    "log = []\n",
    "for num_epoch in tqdm(range(EPOCH)):\n",
    "        train_loader=DataLoader(pair_dataset(X_train),batch_size=BATCH_SIZE)\n",
    "        \n",
    "        for train_values in train_loader:\n",
    "\n",
    "            ranknet_model.train()\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            x1,x2,t = train_values\n",
    "            x1,x2,t = x1.to(device), x2.to(device), t.to(device)\n",
    "\n",
    "            loss = ranknet_model(x1,x2,t)\n",
    "            loss.backward()\n",
    "            log.append(loss)\n",
    "            optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'loss')"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,5))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "plt.plot([float(i) for i in log], color = 'black', linewidth=1)\n",
    "plt.title('MLP RankNet')\n",
    "plt.xlabel(\"iteration\")\n",
    "plt.ylabel(\"loss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Raw data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "libr_distr = df_openml['flow_name'].apply(lambda x: x.split('.')[0]).value_counts()\n",
    "\n",
    "TOP = 10   \n",
    "libr_distr_top = df_openml.groupby(['task_id']).apply(lambda x: x.nlargest(TOP,['value']))\n",
    "libr_distr_top = libr_distr_top['flow_name'].apply(lambda x: x.split('.')[0]).value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Distribution of used libraries on a logarithmic scale'}>"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x1080 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,15))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "sns.set(font_scale=0.8)\n",
    "palette = sns.color_palette(\"crest\", as_cmap=True)\n",
    "plt.title('Distribution of used libraries on a logarithmic scale')\n",
    "sns.barplot(y=libr_distr.index[:-30], x=np.log(libr_distr.values)[:-30], palette=palette.colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/ft/5vplhl0d36b0qq16wf5p_mbh0000gn/T/ipykernel_13193/3786237575.py:8: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"papertype\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig(fname = \"./libr_distr_top.png\", dpi=300, facecolor='w', edgecolor='w',\n",
      "/var/folders/ft/5vplhl0d36b0qq16wf5p_mbh0000gn/T/ipykernel_13193/3786237575.py:8: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"frameon\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig(fname = \"./libr_distr_top.png\", dpi=300, facecolor='w', edgecolor='w',\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj0AAAHiCAYAAAADEX1mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABelUlEQVR4nO3de3zP9f//8dt7J8upOYyiUGQqEcKY4yghZiPnicLHOZXDREjIKXJMSkqphDFyCtOBmEMYhRLGxMxmzGb23t6v3x9+3l9rNtvM3r33vl8vF5eP9+vwfD2ez/f67O71fL5fb5NhGAYiIiIi+ZyTrQsQERERyQsKPSIiIuIQFHpERETEISj0iIiIiENQ6BERERGHoNAjIiIiDkGhR+Q/JDIykieffBI/Pz/8/Pxo06YNnTt3ZsOGDdZjZs+ezZo1azJtZ968eWzduvWO+24/38vLi9jY2GzVGB4eztixYwE4fPgwQ4YMydb5OZGamkr//v1p0aIFX331VZp9QUFBLF68GAA/Pz+uXr1KcHAw//vf/3K1hqioKDp37pwrbd2P+vKznPyc5sQ333zDokWLAFixYgXLli0DYO7cuUyYMOGe2u7Tpw8nTpy45xqzKywsjJdeeinPr/tf5WLrAkQkLXd3d0JCQqyvz507R8+ePXF2dqZFixa8/vrrd20jLCyMSpUq3XFfVs7PzIkTJ4iKigLgmWeeYc6cOffUXlZERUWxY8cODh48iLOzc4bH3T5uua106dJ8++239619sb0uXbpY/75//36eeOKJXGv7k08+ybW2JOcUekT+48qWLcuQIUNYvHgxLVq0ICgoiCeeeILXXnuNOXPmsGXLFlxdXSlWrBjvv/8+W7Zs4ciRI0ybNg1nZ2e2bdtGXFwcZ8+epUmTJsTExFjPB/jwww85fPgwFouFoUOH0rRpU4KDg9m8eTMff/wxgPX1+PHjmTNnDvHx8YwaNYp27drx3nvv8f333xMfH8+7777LsWPHMJlMNGzYkDfffBMXFxeeeeYZ+vbty86dO7l48SK9e/ema9eu6fq6b98+pk2bxvXr13F1dWXo0KHUrFmT3r17k5KSQkBAAHPnzqVcuXJ3HCsvLy927doFQHR0NK+99hoXL16kbNmyvPfee3h6ehIYGMiDDz7IyZMn6dKlC8888wzTp08nOTmZ6Oho6tevz+TJk4mMjKRbt25UrFiRc+fOMWXKFF599VUOHDgAwEcffcQPP/yAxWKhbNmyjBs3jtKlS/PDDz/w0UcfYTKZcHZ2ZsSIEdSuXTtdrXeqz2w289JLL/HTTz9RpEgRDMPgxRdfZPbs2VSpUiXNuSNHjuTy5csANG7cmKFDhwLw8ccfs3r1alxcXChfvjxTpkyhSJEizJ8/n/Xr1+Ps7Mxjjz3GO++8c8fxaNeuHZMmTeLPP//EbDZTr149RowYgYtL2l8XufF+r1y5kuXLl2M2m7ly5Qp9+vS543G3y6gfERERvP3221y5cgVPT08Mw6Bt27YEBASwcOFCtm3bRlJSEtevX2fkyJE8//zzzJ07l4MHD3Lx4kW8vLwoX748ly9fpl69eoSGhrJz507c3d0BOHnyJIGBgURHR1OyZElmzpxJqVKl8PX15aWXXmL37t1cuXKF3r1789tvv/H777/j4uLCRx99ROnSpfH19WX27Nk888wzrFy5kiVLluDk5ESxYsWYOnUqDz/8cJp+fv3113z77be4urpSoEABJkyYQKVKlTh16hRjx44lNjYWJycn+vfvT6tWrdi+fTsff/wxycnJxMbG0q5dO+vPxC3JycnMmDGDvXv3kpqaylNPPcWYMWMoXLhwpmOerxgi8p9x9uxZ49lnn023/c8//zSqV69uGIZhjBw50vj000+Nf/75x6hZs6Zx48YNwzAMY/HixcaWLVsMwzCM7t27Gxs3brQe/8orr1jbunW+YRhG5cqVjY8//tgwDMM4fvy4UadOHSMmJsZYtWqV0bdvX+s5t7++/e+7d+82WrdubRiGYYwYMcJ47733DIvFYty4ccN49dVXrW1XrlzZ+PLLLw3DMIzDhw8bVatWNZKSktL0MTY21qhXr55x8OBBa5/r1KljnDlzJsNxuVN/btX/7LPPGqdPnzYMwzA++OAD4/XXX7eOzahRo6znv/HGG8bu3bsNwzCMa9euGXXr1jUOHz5snD171qhcubKxd+/edO/N6tWrjaFDhxpms9kwDMP49ttvjd69exuGYRjNmjUzDhw4YBiGYfzyyy/G3Llz09WcWX39+/c3vvrqK8MwDOPXX381OnbsmO78efPmGe+8845hGIaRkJBgDB061Lh69aqxdetW44UXXjDi4uIMwzCMyZMnGwsWLDBWrlxpdOrUyUhISDAMwzDmzJljvPrqq3ccj6CgIGPp0qWGYRhGSkqKMWzYMGPRokXparjX9/vatWtGx44djdjYWMMwDOPAgQMZvse33tfM+tGxY0dj2bJlhmEYxokTJ4zq1asbq1atMiIjI43AwEDj+vXrhmEYxvfff2+89NJL1vNbtGhhfR/nzJljvPvuu4ZhpP25mjNnjuHr62vExMRY36N58+YZhmEYTZs2NSZPnmwYhmGsX7/eqFKlinH06FHDMAxjwIABxkcffWQ9Ljw83Dh69KhRt25d459//jEMwzCWLFlifS9vSUlJMZ5++mkjKirKMIybP2/ffvutYRiG0a5dO+vPxz///GM0a9bMuHr1qtG9e3fj1KlThmEYxoULF4wnn3zSiImJSfPf6Ny5c40pU6YYFovFMIybP3fjxo2745jnV7rTI2IHTCaT9V+ct5QuXZoqVarg7+9Po0aNaNSoEfXq1bvj+bVq1cqw7Vu39CtXrkzFihWtdzKy6+eff+abb77BZDLh5uZG586d+eKLL+jbty8AzZo1A+Dpp58mOTmZxMREChQoYD0/PDyccuXKUb16dQCeeOIJatasyZ49e6hbt26266lfvz7ly5cHoEOHDnTo0MG677nnnrP+fcqUKfz8888sXLiQkydPcuPGDRITE/Hw8MDFxYVnn302Xdvbt2/n8OHDtG/fHgCLxcL169cBaN26NYMGDaJx48b4+PjQp0+fbNXXrVs3pk+fTrdu3Vi+fHmaKZdbGjZsSN++fTl//jz169fnrbfeokiRIuzatYsXX3yRBx98EIBRo0YBN6c0AwICKFiwIAA9evRg4cKFJCcnpxuPH3/8kcOHD7Ny5UoAkpKS7lj/vb7fhQoVYuHChfz000+cPn2aY8eOkZiYeMdr3X7NO/Xj0qVLhIeHW9d7VaxYEW9vb+DmndJp06axbt06IiIiOHToEAkJCdY2n3322XR3se7Ex8eH4sWLA1ClSpU0a4xeeOEFAB599FFKlixpvStXrlw5rly5kqadXbt20aBBA+udnZ49e6a7lrOzMy+++CKdO3emSZMmNGjQgMaNGxMXF8exY8d4+eWXAXj44Yeta/cWLlzIjz/+yPfff8/ff/+NYRjWn8lbfvzxR+Lj4/n1118BMJvNlChR4q59z08UekTswOHDh6lcuXKabU5OTnz11VccPnyYXbt2MXnyZBo2bMiIESPSnX/rl8SdODn93+cZLBYLLi4umEwmjNu+ls9sNt+1RovFgslkSvM6JSXF+vrWL7xbxxj/+tq/1NTUNOffOub2NrLj9rU/t/p1y+3j0b17d7y8vGjYsCEtW7bk0KFD1trc3Nzu+AvRYrGkmbJJTk62/nJ74403aN++PTt37iQ4OJjPPvvMGiCyUl/9+vW5fv06u3btYt++fUydOjXdudWqVWPbtm3s2rWL3bt38/LLL/PJJ5/g7OycZgyvXr3K1atX7/re3D4eFouF2bNnU7FiRWsb/35fbh13L+/3hQsX6NSpEx07dqRWrVq8+OKLbN++Pd11snLNW9e6/Rq3xvf3339nwIAB9OzZEx8fH2rXrs277757x75n5vafg3//9+Hm5mb9u6ura6bt/Ps9SkpK4ty5c9bxvmXGjBn8+eef/PrrryxatIiQkBAmTZpkvf4tJ0+e5KGHHsLf35/mzZvz3HPP0b59e7Zu3ZpuzC0WC2+//TaNGzcGICEhgRs3bmSp//mFPr0l8h936tQpFixYwKuvvppm+7Fjx3jppZeoWLEi//vf/+jZsyeHDx8Gbv4fa1bDwurVq4GbvxzOnDlD9erVKV68OH/99Rc3btzAbDazefNm6/EZtd2gQQO++uorDMMgOTmZ7777jvr162e5n88++ywnT54kPDwcgL/++ou9e/dSp06dLLdxu7CwMP755x8Avv32Wxo1apTumKtXr3L48GGGDRvGCy+8wIULFzhz5gwWiyXTths0aMDKlSu5du0acPMTcSNGjCAlJQVfX1+uX79Oly5dGDduHMePH7feUclKfSaTia5duzJ69GheeumlNHdHbpkxYwYLFiygefPmjB49mkqVKvHXX39Rv359tmzZYq1r7ty5fP755zRs2JBVq1ZZ76R8+eWX1K5dO80v69v79vnnn1vfx/79+6f7xNyt4+7l/T5y5AjFixdnwIABNGjQwBp4UlNTMzwno34UKVKEmjVrEhwcDMDZs2fZtWsXJpOJvXv3UrVqVXr16kWdOnXYtm1bpte4JTv/DWVH3bp12bVrFxcvXgRuvvfTp09Pc0xsbCyNGzfGw8ODnj17MnToUA4fPkzhwoV5+umnrZ++PH/+PF26dOHPP//k2rVrDB06FF9fX8LCwkhOTk73c9ygQQOWLVtm3ffOO+8wc+bMXO/jf5nu9Ij8xyQlJeHn5wfcvAtToEAB3nzzTZo0aZLmuCpVqtCyZUvat29PwYIFcXd3Z8yYMQD4+voyc+bMLN2hOXv2LO3atcNkMjFz5kw8PDys/yJu2bIlnp6e1K1bl+PHjwM3w8n8+fMZNGgQgYGB1nbGjBnDxIkTadOmDWazmYYNG9KvX78s97t48eLMnj2b9957j6SkJEwmE++//z6PPfYYkZGRWW7nlsqVK/P2229z6dIlHn/88Tt+5Lho0aL07dsXf39/ChYsSOnSpalZsyYRERE8+uijGbb98ssvExUVRceOHTGZTDz88MNMmTIFFxcX3n77bYYNG2a9YzZ58uQ7hovM6vP392fq1Kl06tTpjtd/5ZVXCAoK4qWXXsLNzQ0vLy9at26Nm5sbJ06csE6JVapUiffee4+CBQty/vx5Xn75ZSwWC+XLl2fGjBl3bHv06NFMmjTJ+j7Wr1+f3r17pzvuXt9vHx8fVq5cyYsvvojJZKJOnToUL16ciIgIHn/88Tue06FDhwz7MXXqVEaPHs3XX39N6dKleeSRR3B3d6dhw4b88MMPtGzZEovFQtOmTbly5Yo1GGakUaNGTJkyJcv9ySovLy+GDx9uHVNPT08mT56c5pjixYvTv39/evbsibu7O87OzkycOBGADz74gHfffZcvv/wSk8nEpEmTqFatGk2aNKFly5a4ublRuXJlKlWqRERERJqfvQEDBjB16lT8/f1JTU3lySefJCgoKNf7+F9mMv59/0tERGxq/fr1rF69mk8//dTWpdiNjz76iBdeeIGKFSsSHx9P27Zt+eSTTzJ8dIM4Jt3pERH5DwkMDCQ2NpYFCxbYuhS7UqFCBd544w2cnJxITU2lT58+CjySju70iIiIiEPQQmYRERFxCAo9IiIi4hAUekRERMQhaCGz2L3LlxOwWLQ0LTtKlChMTEzmH9mVO9PY5YzGLWc0btnj5GSiWLFCGe5X6BG7Z7EYCj05oDHLOY1dzmjcckbjlnv06S0RERGxuVSzmdi4O3/XW1Y5OZkoUSLjb43XnR6xe5FbFpNy/aqtyxARkXtQoe0bwL2FnrvRQmYRERFxCAo9IiIi4hAUekRERMQhKPRInoiMjMTX19fWZYiIiANT6BERERGHoNAj2damTRv+/vtvAN566y3GjRsHwIEDB+jbty+LFi3C39+ftm3bMm3aNP79VITNmzfTtm1bYmNj+fPPPwkMDKR9+/Y0bdqUb775Js/7IyIijkGhR7KtcePG7Nq1C4A///yT3377DYBffvmFJk2acOTIEVauXMmaNWuIiopi7dq11nN37NjB/Pnz+eyzzyhevDgrVqxgwIABrFq1iqVLlzJt2jSb9ElERPI/hR7Jtluh58SJE1SqVAknJydiYmL4+eefOXz4MOHh4QQEBODv78+RI0c4ceIEAJcvX2bw4MG0a9eOkiVLAhAUFMSNGzf4+OOP+fDDD0lMTLRl10REJB/Twwkl22rUqEFQUBC//vorderUoUSJEmzatImUlBSKFCnCK6+8Qq9evQC4evUqzs7OXL58GZPJxPz58xk2bBitW7emdOnSDB06lKJFi9K0aVNatWrF999/b+PeiYhIfqU7PZJtLi4uVKtWjS+//JI6derg7e3NwoULady4Md7e3oSEhJCQkEBKSgoDBw5k8+bNAHh4eFCvXj26dOnCxIkTAdi5cydDhgyhefPm/PzzzwCkpqbarG8iIpJ/6U6P5Ejjxo3Zu3cvFStWxNPTk5iYGJo0aUKNGjU4duwYHTt2JDU1lYYNG+Lv78+5c+es5/bt25e2bduydetWBg8eTNeuXSlQoABVqlShbNmyREZGUr58eRv2TkRE8iN94ajYPX33loiI/avQ9g2io+PvqY27feGoprdERETEISj0iIiIiENQ6BERERGHoDU9IiIiYnOpZjOxcUn31Mbd1vTo01ti92JirmGxKLtnh6dnkXteMOioNHY5o3HLGY1b7tL0loiIiDgEhR4RERFxCFrTIyIiYgNZWcOi6a3s0Zoeyff0cEIRsUcV2r4B3NvCXckeTW+JiIiIQ1DoEREREYeg0CMiIiIOQaFHREREHIJCj4iIiDgEhR4RERFxCPrIuuSKsLAwFi5ciKurK5GRkfj6+lKwYEG2bt0KwKJFizh8+DAffvghFouFRx99lAkTJlCyZEk2btzIkiVLSEpKIjk5mcmTJ1OzZk0b90hERPIb3emRXHPo0CHeffddVq1axbJlyyhevDjBwcF4eXnx7bffMnbsWObPn8+6deuoWbMmEyZMwGKx8O2337Jw4ULWrl1L7969WbRoka27IiIi+ZDu9EiuqVy5Mg8//DAAxYoVo169egCUKVOG0NBQqlWrxiOPPAJAp06dWLRoEU5OTsyfP5/Q0FBOnTrFnj17cHJSFhcRkdyn3y6Sa1xdXdO8dnZ2tv793992YhgGKSkpJCQk0KFDByIjI6lduzaBgYF5UquIiDgehR7JE9WqVePQoUNERkYCsHz5curWrcvp06cxmUz069ePunXrsmXLFlJTU21crYiI5Eea3pI8UbJkSSZMmMCgQYMwm82UKVOGSZMmUaJECZ588klatmyJyWSiQYMG7N+/39bliohIPqRvWRe7py8cFRF7VKHtG3f9BnV9y3r23O1b1jW9JSIiIg5BoUdEREQcgkKPiIiIOAQtZBa798jzr9m6BBGRbEs1m21dgsNR6BG7FxNzDYtF6/GzQ4sjc05jlzMaN/kv0PSWiIiIOASFHhEREXEIek6PiIgIN9fYxMYl2bqMNDQtmD13e06P1vSI3Yv84VM9nFBE7lkFvzeB/1bokdyl6S0RERFxCAo9IiIi4hAUekRERMQhKPSIiIiIQ1DokUz5+voSGRmZZltwcDBBQUE2qkhERCRnFHpERETEISj0iNWFCxfo3r07AQEBdOjQgYMHD1r3nTp1ihdeeCHNNoDw8HC6dOmCv78/r776KmfPngVgz5491u3NmjVj69atAAQFBdGvXz9atmxJaGgovr6+fPjhh3To0IHWrVtz5MiRvOquiIg4GIUesVq5ciVNmjQhODiYIUOGsH//fuBmGBo0aBCTJ0/m2WeftR6fnJzMmDFj+OCDD1i9ejW9evXinXfeAeCrr75i4sSJrF69mokTJzJ79mzreR4eHmzcuBFfX1/r65UrV9K5c2c+/vjjvOuwiIg4FD2cUKzq1avH4MGDOXr0KI0bN6Z79+4sW7aM119/nWeeeYbnnnsuzfGnT5/m7Nmz9O/f37rt2rVrAEyfPp3t27ezadMmDh06REJCgvWYatWqpWmnYcOGADzxxBP88MMP96t7IiLi4BR6xKpWrVqsX7+eH3/8kQ0bNrB69WoARo8ezfz58/nxxx9p0qSJ9XiLxcIjjzxCSEgIAKmpqVy6dAmArl27UrduXerWrUu9evUYNmyY9Tx3d/c01y1QoAAAJpPpfnZPREQcnKa3xGratGmsXbsWf39/xo4dyx9//AHcvDMzfvx4JkyYQGJiovX4xx9/nCtXrrBv3z4AVq1axbBhw4iLi+P06dO8/vrrNGrUiG3btpGammqTPomIiNyiOz1iFRgYyFtvvUVwcDDOzs5MnTqVCRMmAFC7dm3q1q3Lhx9+SJUqVQBwc3Nj9uzZTJo0iRs3blC4cGGmTp2Kh4eHdWGyi4sL3t7eJCUlpQlMIiIieU3fsi52T184KiK5oYLfm/+5bzTXt6xnz92+ZV3TWyIiIuIQFHpERETEIWhNj9i9R17obesSRCQfSDWbbV2C3GcKPWL3YmKuYbFoaVp2aJ1AzmnsckbjJv8Fmt4SERERh6DQIyIiIg5BoUdEREQcgtb0iN3L7JkMkjFPzyK2LsFuOfLYpZrNxMYl2boMkRxR6BG7F/nDJ6Qk6uGEInmhQru3AIUesU+a3hIRERGHoNAjIiIiDkGhR0RERByCQo9kW2BgIGFhYbnS1rZt25g9ezYAP/30Ew0bNuStt97KlbZFRERup4XMYlPNmjWjWbNmAGzatIlBgwbRqVMnG1clIiL5kUKPZMowDGbMmMHWrVtxdnZOE0hSUlIYP348f/31F5cuXcLLy4uZM2eSkpLCm2++yaVLlwAYOHAgzZo1Y8mSJaxevRonJyeqVavGhAkTCA4OZs+ePdSqVYtt27axa9cunJycePnll23VZRERyacUeiRTmzZt4rfffmPdunWYzWa6du3KjRs3ADhw4ACurq4sX74ci8XCK6+8wk8//URiYiJly5Zl0aJFHD16lLVr19KkSRM+/vhjfvnlF5ydnRk9ejRRUVHW67z88svs37+fOnXqEBAQYKvuiohIPqbQI5nau3cvLVu2xM3NDTc3N0JCQggMDASgdu3aeHh4sGzZMk6ePMnp06dJTEykRo0azJw5k6ioKJo0acLAgQNxdnamRo0adOjQgWbNmtGrVy9Kly5t496JiIgj0UJmyZSLiwsmk8n6OjIyksTERODmIuRhw4bh7u5OQEAAtWvXxjAMKlSowMaNG2nTpg379u2jQ4cOWCwWFixYwPjx4zEMg969e7Nnzx5bdUtERByQQo9kqnbt2vzwww+YzWauX79O7969rdNSu3btomXLlrRv356iRYsSFhZGamoqX331FXPnzqVly5aMGzeO2NhY4uLiaNWqFZUrV+b111/Hx8eH48eP27h3IiLiSDS9JZl6/vnnOXLkCAEBAVgsFnr06MHGjRuBm+twhg0bxvr163F1daVmzZpERkbSp08f3nzzTdq0aYOzszPDhw+nePHidOrUiQ4dOvDAAw/w2GOP0b59ezZt2mTjHoqIiKMwGYZh2LoIkXuh794SyTsV2r1FdHR8ts/z9CySo/McncYte5ycTJl+CbWmt0RERMQhKPSIiIiIQ1DoEREREYeghcxi9x55oY+tSxBxGKlms61LEMkxhR6xezEx17BYtB4/O7Q4Muc0diL2S9NbIiIi4hAUekRERMQhKPSIiIiIQ9CaHrF7mT2ISjLm6VnE1iXYrfw6dqlmM7FxSbYuQ+S+UegRuxe5WU9kFskNFfzfAhR6JP/S9JaIiIg4BIUeERERcQgKPSIiIuIQFHrE5ry8vGxdgoiIOACFHhEREXEI+vSW3FdhYWEsXLgQV1dXIiMj8fX1pWDBgmzduhWARYsWWY+dO3cuBw8e5Pz583Tv3p2uXbvaqmwREcmHFHrkvjt06BDr16/Hw8OD+vXrM3LkSIKDgxk1ahTr169Pc2xycjIbNmywUaUiIpKfKfTIfVe5cmUefvhhAIoVK0a9evUAKFOmDFevpn2+TrVq1fK8PhERcQxa0yP3naura5rXzs7OGR7r7u5+v8sREREHpdAjIiIiDkGhR0RERByCyTAMw9ZFiNwLffeWSO6o4P8W0dHx96VtT88i963t/Ezjlj1OTqZMv4Rad3pERETEISj0iIiIiENQ6BERERGHoOf0iN17pEUfW5cgki+kms22LkHkvlLoEbsXE3MNi0Xr8bNDiyNzTmMnYr80vSUiIiIOQaFHREREHIKmt8TuZfZMBsmYp2eR+9p+qtlMbFzSfb2GiEh2KPSI3YvctEgPJ/wPqhAwDFDoEZH/Dk1viYiIiENQ6BERERGHoNAjIiIiDkGhR0RERByCFjKLzURGRvLiiy9SsWJFACwWCwkJCbRr144hQ4bYuDoREclvFHrEpkqVKkVISIj1dVRUFC1atKB169bWMCQiIpIbNL0l/ynR0dEYhkGhQoVsXYqIiOQzutMjNnXx4kX8/Py4ceMGly9f5plnnmHevHk89NBDti5NRETyGd3pEZu6Nb21YcMG/Pz8MAwDHx8fW5clIiL5kEKP/Cc4OTkxYsQIoqKiWLx4sa3LERGRfEihR/4zXFxcGDFiBAsWLCA6OtrW5YiISD6j0CP/KY0aNaJGjRrMnj3b1qWIiEg+o4XMYjOPPPIIoaGh6bZ/9tlnNqhGRETyO93pEREREYeg0CMiIiIOQaFHREREHILW9Ijde+TFvrYuQe4g1Wy2dQkiImko9Ijdi4m5hsVi2LoMu+LpWYTo6HhblyEikqc0vSUiIiIOQaFHREREHIKmt8TulShR2NYl2I1Us5nYuCRblyEiYhMKPWL3IjctIiXxqq3LsAsVAoYBCj0i4pg0vSUiIiIOQaFHREREHIJCj4iIiDgEhR4RERFxCAo9ki1hYWEEBgbaugwREZFsU+gRERERh6CPrEuOffHFF2zdupXRo0czdepU4uLicHd355133uGpp54iKCiIuLg4IiIiGD58ODdu3GDJkiUkJSWRnJzM5MmTqVmzJkuWLGH16tU4OTlRrVo1JkyYYOuuiYhIPqTQIzkSHBzMDz/8wKJFi3jttdcYO3YsTz31FCdOnGDgwIFs3rwZAA8PDxYuXIjFYqFXr14sXLiQ4sWLs3LlShYtWsT8+fP5+OOP+eWXX3B2dmb06NFERUVRunRpG/dQRETyG4UeybY///yTd955h5kzZwJw5MgRRo0aZd2fmJjI5cuXAahWrRoATk5OzJ8/n9DQUE6dOsWePXtwcnLC2dmZGjVq0KFDB5o1a0avXr0UeERE5L7Qmh7JtkKFCjF37lymTZuGxWLBzc2NkJAQ658VK1bg4eEBgLu7OwAJCQl06NCByMhIateunWYx9IIFCxg/fjyGYdC7d2/27Nlji26JiEg+p9Aj2Va2bFl8fX2pU6cO8+fPp0KFCoSEhACwc+dOunXrlu6c06dPYzKZ6NevH3Xr1mXLli2kpqYSGxtLq1atqFy5Mq+//jo+Pj4cP348r7skIiIOQNNbkmMjRozgpZdeYu7cucyaNYtPP/0UV1dXZs2ahclkSnNslSpVePLJJ2nZsiUmk4kGDRqwf/9+ihcvTqdOnejQoQMPPPAAjz32GO3bt7dRj0REJD8zGYZh2LoIkXuhLxzNugoBw4iOjsfTswjR0fG2LscuaexyRuOWMxq37HFyMlGiROGM9+dhLSIiIiI2o9AjIiIiDkFresTuPfJiX1uXYDdSzWZblyAiYjMKPWL3YmKuYbFoaZqIiGRO01siIiLiEBR6RERExCEo9IiIiIhD0JoesXuZPZMhP0sxm7kcl2TrMkRE7IZCj9i9sxs/dsiHEz7Wfjig0CMiklWa3hIRERGHoNAjIiIiDkGhR0RERByCQo8DiYyMxNfXN912Ly8vwsLCqFGjBn5+fmn+pKamEhQURLdu3bj9u2mDg4MJCgoCuOt+gG3btrF06VLra7PZzCuvvEJYWBgAFouFgQMHkpCQkOv9FhERAYUeuU3VqlUJCQlJ88fZ2RmAQ4cOpQkt/5bZ/uTkZD755BO6dOkCwMmTJwkMDOTAgQPWY5ycnOjYsSPz58/PxR6JiIj8H4UeyZLXXnuNjz76iIiIiGzvX7t2Lc899xyurq4ArFy5kt69e1O9evU0xzVo0IAtW7Zw7dq13O+AiIg4PIUeB3Px4sV0U1i3HDlyJM32tWvXWveVL1+efv368fbbb6eZxsrK/tDQUGrXrm19PWLECJo3b56uDWdnZ7y8vNi9e3dudFVERCQNPafHwZQqVYqQkJA027y8vICb01tffvllhuf26NGDH374gaVLl1KkSJEs74+IiKB06dJZqq9MmTIZ3k0SERG5F7rTI1nm5OTE5MmTM5zGymi/yWSyTm3djbOzM05O+rEUEZHcp98uki0VKlSgX79+LF68OMv7y5UrR2RkZJbaP3fuHOXKlcuVWkVERG6n0CPZ1qNHD6pVq5bl/U2bNrV+ND0zqamp/PHHH9SvXz9X6hQREbmdybjTqlSRXHTjxg26dOnC8uXLM53m2rp1K/v372fkyJHZat+Rv3srOjo+R+d6ehbJ8bmOTmOXMxq3nNG4ZY+TkynTL6HWnR657woUKED//v35+uuvMzzGYrGwcuVKBg4cmIeViYiII9GntyRPPP/885nud3JyYuHChXlUjYiIOCLd6RERERGHoDs9Yvcebfk/W5dgEylms61LEBGxKwo9YvdiYq5hsWg9voiIZE7TWyIiIuIQFHpERETEISj0iIiIiEPQmh6xe5k9iCo/SzGbuRyXZOsyRETshkKP2L2zGxz0icwdhgMKPSIiWaXpLREREXEICj0iIiLiEBR6RERExCEo9OQjkZGR+Pr6ptvu5eV113ODg4MJCgqyvo6KiqJFixYsXbrU2saKFSvSnBMYGEhYWFiW9gOMGDGCqKgo6+vjx4/TunVr6+vDhw8zbdq0u9YqIiKSEwo9kk50dDQ9e/akR48e9OjRw7r9gw8+4Pz58xmel9n+7du3U7p0aUqXLg3AmjVr6N27N9evX7ce88wzz3DhwgWOHz+eSz0RERH5Pwo9DqJevXpcu3YNgM6dO7No0SIAvv/+e959913rcTExMfTq1YtevXrRrVu3NG288sorjBkzJsNrZLb/008/pV27dgDEx8ezbds2Zs6cme64Nm3a8Nlnn2WrbyIiIlmh0JPPXLx4ET8/vzR/ALy9vdm7dy8JCQn8888/7N27F4BffvmFJk2aABAbG0vPnj0xm83WgHK7Pn36cPny5XTTWHfbHxcXx+nTp6lYsSIARYoUYe7cuTz88MPp2qhduzbbt2/HMPRdWiIikrsUevKZUqVKERISkuYPQOPGjdm1axf79u2jTZs2nDhxArPZzL59+/D29gZuBqBXX32VcuXK8cEHH6Rr28XFhSlTpmQ4jZXR/jNnzlCqVKks1V+4cGEMw+Dy5cs56b6IiEiG9HBCB9GoUSOWLFmCs7Mz9erV4+TJk6xcuZLKlStToEABAFq1aoW/vz8NGjSgbdu21K9fn8aNG6dpp3LlyplOY91pv8lkwsUl6z9qzs7OODkpj4uISO7SbxYHUbx4cdzd3dm+fTu1atXC29ubBQsW0LRpU+sxrq6uAHh6ejJ+/HhGjRrFpUuX0rV1axrrwIEDd7zWv/c/+uijmS6Avt2tdUceHh7Z6Z6IiMhdKfQ4kEaNGlG0aFEKFSqEt7c3Fy9eTHcn55YWLVrQsGFDRo4cmW59za1prIz8e7+HhwflypXjxIkTd61x7969aYKYiIhIbjEZWjEqeWDbtm3s27ePkSNHZnrcoEGDGDx4cJaeLXSLI3/3VnR0fI7O9fQskuNzHZ3GLmc0bjmjccseJydTpl9CrTs9kieaNWvGxYsX0zyc8N/Cw8MpW7ZstgKPiIhIVmkhs+SZO30i7HbVqlWjWrVqeVSNiIg4Gt3pEREREYegOz1i9x5t9T9bl2ATKWazrUsQEbErCj1i92JirmGxaD2+iIhkTtNbIiIi4hAUekRERMQhaHpL7F5mz2SwVylmM5fjkmxdhohIvqLQI3bv7PqF+e7hhI+9PAJQ6BERyU2a3hIRERGHoNAjIiIiDkGhR0RERByCQo+IiIg4BIWeXBYZGUnVqlXx8/PDz8+PNm3a4Ovry5w5c+657eDgYIKCgnKlnTp16lhrfOmll3jhhRfYunXrfbv+tWvXGDx4MIbxfw8RXLFiRZr2Pv/8c7Zv356j9kVERO5Gn966D0qVKkVISIj1dVRUFC1atKB169ZUrFjRhpX9H19fX6ZMmWJ9vXXrVsaOHUvz5s3vy/Xmz59Px44dMZlM3Lhxg7lz57Js2TJatGhhPaZr1650794dHx8f3Nzc7ksdIiLiuBR68kB0dDSGYVCoUCHGjBnDX3/9xaVLl/Dy8mLmzJlcunSJQYMG8cQTT3D06FFKlCjB7Nmz8fDwYM2aNXz00UcULlyYsmXLUrBgQQAOHjzIpEmTuHHjBsWKFWPChAmUL1+ewMBAnnrqKfbv38+NGzcYNmwYS5cu5e+//6Znz5707NnzjjWeO3eOBx98EIC5c+cCMHjwYOBmQFq6dGma48PDw3n//fdJSkqiWLFivPvuuzz66KMsWbKE1atX4+TkRLVq1ZgwYQLXrl0jNDSU4cOHA7B3714sFgvDhw8nPDzc2qabmxu1atVi3bp1tG/fPlffAxEREU1v3QcXL17Ez8+PF198kbp16/Lhhx8yb948zp49i6urK8uXL2fLli3Ex8fz008/AXDs2DF69erF999/T9GiRVm3bh1RUVHMmDGDZcuWsXz5chISEgBITk7mzTff5J133mHt2rV07tyZN99803p9wzBYuXIlLVq0YOLEicybN49ly5Yxf/586zGhoaH4+fnRrFkzfHx8+P3331mwYEGW+pecnMyYMWP44IMPWL16Nb169eKdd94hNTWVjz/+mFWrVhEcHIzZbCYqKordu3dTpUoVnJxu/rg1aNCAESNG4O7unq7t5557jtDQ0ByPvYiISEZ0p+c+uDW9ZbFYmDJlCn///Tc+Pj44OTnh4eHBsmXLOHnyJKdPnyYxMRGAEiVK8NRTTwHwxBNPcOXKFQ4cOECNGjUoWbIkAG3atGH37t2cPn2aokWLUq1aNQBatmzJ2LFjiY+PB6BRo0YAlClThurVq/PAAw9QtmxZrl79vwf43ZreunbtGn379qVChQo89thjWerf6dOnOXv2LP3797duu3btGs7OztSoUYMOHTrQrFkzevXqRenSpVm3bh0PPfRQltouW7YsERERWTpWREQkOxR67iMnJydGjBhBu3btWLx4MY8//jhz5syhR48eBAQEcPnyZevC3gIFCljPM5lMGIZh/d9bXFxuvl0WiyXdtQzDIDU1FQBXV9d052SkcOHCTJ06lTZt2lCvXj1q1KiByWRKcw2z2ZzmHIvFwiOPPGJdt5SamsqlS5cAWLBgAQcPHuTnn3+md+/ezJgxA5PJdNc6bnF2dsZkMmXpWBERkezQ9NZ95uLiwogRI1iwYAE//vgjLVu2pH379hQtWpSwsDBrULmTWrVqcfDgQaKiorBYLGzYsAGAxx9/nLi4OOt6mA0bNlCmTBk8PDxyVOOjjz5K9+7dmTRpEoZhUKxYMU6cOAHcXLsTHR2d5vjHH3+cK1eusG/fPgBWrVrFsGHDiI2NpVWrVlSuXJnXX38dHx8fjh8/Tvny5Tl37lyWajl37hzly5fPUT9EREQyozs9eaBRo0bUqFGD06dPc/DgQdavX4+rqys1a9YkMjIyw/NKlizJmDFj6NmzJw888ACVKlUCbi74nTVrFu+99x7Xr1/nwQcfZNasWfdU4//+9z9WrlzJunXraNWqFZs3b6ZVq1Y8/fTT1mm3W9zc3Jg9e7Z1IfWtu0XFixenU6dOdOjQgQceeIDHHnuM9u3bYxgG77//PhaLxbquJyNhYWE0a9bsnvoiIiJyJybj9vkTkfvk/fffx9vbm6ZNm2Z4THJyMp07d+bbb7/N1kfW8+sXjkZHx9+39j09i9zX9vMzjV3OaNxyRuOWPU5OJkqUKJzx/jysRRzYoEGDWLlyJZll7C+//JIBAwboGT0iInJfaHpL8kSRIkXSfGT+Tl577bU8qkZERByR7vSIiIiIQ9CdHrF7j7buZ+sScl3Kvx4TICIi906hR+xeTMw1LBatxxcRkcxpektEREQcgkKPiIiIOARNb4ndy+yZDPYqxWzmclySrcsQEclXFHrE7p39Ph8+nLDjCEChR0QkN2l6S0RERByCQo+IiIg4BIUeERERcQgKPSIiIuIQFHokU2FhYQQGBt5TG3PnzmXu3LkA+Pn5ARAeHs706dPvuT4REZGsUuiRPBUSEgLAiRMniImJsXE1IiLiSPSRdbmry5cv89prr3Hx4kWqVavGuHHjGD16NH/99RcAXbt2pWPHjgQFBVGgQAEOHz5MQkIC/fv3p127dmna8vLyYu/evcyZM4fExEQ++ugjEhIS+OWXXwCIj4/n8uXLHDhwIK+7KSIi+ZxCj9xVZGQk8+bNo3z58rzxxhssWrSIK1eusGbNGqKiovjggw/o2LEjAGfPnmX58uXExMQQEBCAj49PuvaKFi3KkCFD2LNnD/379wdg2LBhJCcnExgYyLBhw/K0fyIi4hg0vSV39dxzz1GhQgVMJhNt2rQhLCyMU6dO8dprr7Fp0yZGjBhhPTYgIABXV1ceeughatasyf79+7N8nTFjxlC7dm1atWp1P7ohIiIOTqFH7srF5f9uCBqGQfHixVm/fj3du3fn1KlT+Pv7c/XqzSciOzs7W4+1WCxpzs3M4sWLiYmJ4c0338zd4kVERP4/hR65q/379/PPP/9gsVhYs2YNtWrVYvjw4TRp0oQxY8ZQsGBBzp8/D8DGjRsxDINz584RHh5OrVq17tims7MzKSkpAPz888+sWLGCmTNn4uSkH0kREbk/tKZH7qpSpUq8/fbbREdH4+3tTefOnfn9999p3bo1BQoUoG3btnh5eQGQlJRE+/btSU5OZsKECRQrVuyObVarVo158+YxY8YMtmzZQkpKCj179sRisQA3P+Zerly5POujiIjkfybDMAxbFyH5Q1BQEHXq1CEgICBPr5tfv3A0Ojr+vrXv6Vnkvrafn2nsckbjljMat+xxcjJRokThjPfnYS0iIiIiNqPpLck1U6ZMsXUJIiIiGVLoEbv36Ev9bF1Crksxm21dgohIvqPQI3YvJuYaFouWpomISOa0pkdEREQcgkKPiIiIOASFHhEREXEIWtMjdi+zZzL8l6SYzVyOS7J1GSIiDkuhR+ze2e8/souHEz7WcSSg0CMiYiua3hIRERGHoNAjIiIiDkGhR0RERByCQk8+FxkZia+vb7rtXl5eafYFBwcTFBRk3R8VFUWLFi1YunSp9fgVK1akaSMwMJCwsLAs7QcYMWIEUVFR1tfHjx+ndevW1teHDx9m2rRpOe2qiIhIphR6JJ3o6Gh69uxJjx496NGjh3X7Bx98wPnz5zM8L7P927dvp3Tp0pQuXRqANWvW0Lt3b65fv2495plnnuHChQscP348l3oiIiLyfxR6JI2YmBh69epFr1696NatW5p9r7zyCmPGjMnw3Mz2f/rpp7Rr1w6A+Ph4tm3bxsyZM9Md16ZNGz777LOcd0BERCQDCj0O4OLFi/j5+aX5cyexsbH07NkTs9lsDSi369OnD5cvX043jXW3/XFxcZw+fZqKFSsCUKRIEebOncvDDz+cro3atWuzfft2DEPfpSUiIrlLoccBlCpVipCQkDR/7uSXX37h1VdfpVy5cnzwwQfp9ru4uDBlypQMp7Ey2n/mzBlKlSqVpVoLFy6MYRhcvnw5i70TERHJGj2cUKxatWqFv78/DRo0oG3bttSvX5/GjRunOaZy5cqZTmPdab/JZMLFJes/as7Ozjg5KY+LiEju0m8WsXJ1dQXA09OT8ePHM2rUKC5dupTuuFvTWAcOHLhjO//e/+ijj2a6APp2165dA8DDwyMHPRAREcmYQo/cUYsWLWjYsCEjR45Mt77m1jRWRv6938PDg3LlynHixIm7Xnfv3r00bdo054WLiIhkwGRoxajkgW3btrFv3z5GjhyZ6XGDBg1i8ODBeHl5Zblte/rurejoeFuXAYCnZ5H/TC32RmOXMxq3nNG4ZY+TkynTL6HWnR7JE82aNePixYtpHk74b+Hh4ZQtWzZbgUdERCSrtJBZ8sydPhF2u2rVqlGtWrU8qkZERByN7vSIiIiIQ9CdHrF7j77U39YlZEmK2WzrEkREHJpCj9i9mJhrWCxajy8iIpnT9JaIiIg4BIUeERERcQgKPSIiIuIQtKZH7F5mD6L6L0kxm7kcl2TrMkREHJZCj9i9s+vs5InMnUYCCj0iIrai6S0RERFxCAo9IiIi4hAUekRERMQhKPTYgcjISKpWrYqfnx9+fn60aNGCUaNGcenSJXr16sXWrVutx06dOpUaNWqQnJxs3dagQQMiIyMJDAwkLCwsTdtBQUEEBwcD4OvrS6tWrazX8fPzY8uWLYSFhVG1alX++uuvNOfe+mLQu+0HuHbtGoMHD8Yw/u8hgitWrCAoKMj6+vPPP2f79u05HSYREZFMKfTYiVKlShESEkJISAibNm2iZMmSDBkyBG9vb/bv32897tdff+XZZ5+1bouIiKBgwYI88sgjWbrOokWLrNcJCQnh+eeft+4LCgoiNTU1w3Mz2z9//nw6duyIyWTixo0bzJgxg8mTJ6c5pmvXrnz00UdpApuIiEhuUeixQyaTicGDB/PXX39Rs2ZNDhw4AEBUVBRubm60aNGCHTt2ALBv3z58fHzu+Zo1atTgwQcf5JNPPsn2/mvXrhEaGmqtY+/evVgsFoYPH57mODc3N2rVqsW6devuuV4REZF/U+ixU25ubpQvX57o6GjOnDnDjRs32LFjBz4+Pvj4+GQYesaMGZNm+io0NDRNu3379rXuGzp0aJp9EydO5PPPP083jXW3/bt376ZKlSo4Od38cWvQoAEjRozA3d09XRvPPfdcuppERERyg57TY8dMJhPu7u5Ur16dw4cPs2PHDrp168ajjz5KUlISV65c4cCBA4wePdp6zsSJE6lbt6719e1rauDm9FZGU2FlypThjTfeICgoiO+++y7L+0+fPs1DDz2UpT6VLVuWiIiILB0rIiKSHbrTY6eSk5M5deoUlSpVwtvbm99++43w8HCeffZZAOrVq8e2bdsoVqwYhQvn3hOLO3XqlOk01532m0wmXFyylq+dnZ0xmUy5UquIiMjtFHrskMViYe7cuVSvXp1y5cpRr149QkJCqFy5sjVc+Pj4sGTJklxZz/Nvt6axsrq/fPnynDt3Lkttnzt3jvLly99jhSIiIukp9NiJixcvplmLExUVxcyZMwGoXLkycXFxNGjQwHq8t7c3J0+epH79+rleS5kyZXjzzTezvL9evXocPnwYi8Vy17bDwsJo1qxZrtQpIiJyO5Nx+4NTRO6T999/H29vb5o2bZrhMcnJyXTu3Jlvv/0WNze3LLdtT9+9FR0db+syAPD0LPKfqcXeaOxyRuOWMxq37HFyMmX6JdS60yN5YtCgQaxcuZLMMvaXX37JgAEDshV4REREskqf3pI8UaRIEebPn5/pMa+99loeVSMiIo5Id3pERETEIehOj9i9R9v0t3UJWZJiNtu6BBERh6bQI3YvJuYaFovW44uISOY0vSUiIiIOQaFHREREHIKmt8TuZfZMhtyUYjZzOS4pT64lIiK5T6FH7N6ZdR+RknDlvl/n8c5BgEKPiIi90vSWiIiIOASFHhEREXEICj0iIiLiEBR6RERExCFoIbOdioyM5MUXX6RixYoAJCUlUbNmTd566y1KliyZa9cJDAzkwoULFCxY0LqtY8eOdOvWLdeucbs5c+ZQv359nnvuufvSvoiIOC6FHjtWqlQpQkJCADAMg5kzZzJkyBC+/vrrXL3OxIkTqVu3bq62mZG9e/fm2bVERMSxKPTkEyaTicGDB+Pj48OxY8f4+eef2bhxI6mpqTRo0IDhw4djMplYs2YNX3zxBRaLhaeffppx48ZRoEAB6tWrx/PPP8+BAwcoVKgQM2bM4JFHHsn0mgsXLmTt2rU4Ozvj4+PD8OHDOX/+PL1796ZYsWK4u7vz6aefMm3aNPbs2UNqaioBAQH07NmTCxcuMGzYMBITE3FycmLMmDGcPn2aI0eOMGbMGObNm4eXl1cejZ6IiDgCrenJR9zc3ChfvjzHjh3jyJEjrFy5kjVr1hAVFcXatWv566+/+O677/j2228JCQmhRIkSLF68GIDY2Fhq1KjBunXraN26NRMnTrS2O2bMGPz8/PDz86Nr164A/PTTT4SGhrJq1SpWr15NREQE3377LQCnTp1i+vTpLFmyhO+++w6A1atXs3LlSrZt28a+fftYuXIlTZo0ITg4mCFDhrB//37atWtH1apVmThxogKPiIjkOt3pyWdMJhNLly4lNjaWgIAA4OZ6nzJlyhAfH09ERAQdO3YEwGw289RTTwFQoEAB2rVrB4C/vz8zZ860tnmn6a3du3fTunVrHnjgAQDat2/PmjVraNy4MSVKlLDeJdq1axdHjx5l9+7dACQmJnL8+HHq1avH4MGDOXr0KI0bN6Z79+73b1BERERQ6MlXkpOTOXXqFHXr1qVNmzb06tULgKtXr+Ls7MzKlStp2bIlY8aMASAhIYHU1FQAnJycMJlMAFgsFpydnTO9lsViSbctJSUFAHd3d+u21NRUhg8fzgsvvADcvKNUqFAhChQowPr16/nxxx/ZsGEDq1evZsmSJfc4AiIiIhnT9FY+YbFYmDt3LtWrV6d9+/aEhISQkJBASkoKAwcOZPPmzdStW5ctW7YQExODYRiMHz+eL774AoDr168TGhoKQHBwMI0aNcr0et7e3qxfv56kpCRSUlJYtWoV3t7edzzuu+++w2w2k5CQQNeuXTl48CDTpk1j7dq1+Pv7M3bsWP744w8AnJ2drUFMREQkN+lOjx27ePEifn5+wM3Q8+STTzJz5kwefPBBjh07RseOHUlNTaVhw4b4+/tjMpkYNGgQr7zyivX4vn37WtvbtGkTs2bNolSpUkydOjXTazdt2pSjR4/Svn17UlJSaNCgAd27d+fChQtpjuvcuTMRERH4+/uTkpJCQEAAdevWpVy5crz11lsEBwfj7OxsvV7Dhg0ZN24cU6dOpWbNmrk8YiIi4shMhmEYti5CbM/Ly4vjx4/buowcycsvHI2Ojr/v18kLnp5F8k1f8prGLmc0bjmjccseJycTJUoUznh/HtYiIiIiYjMKPQJgt3d5REREskqhR0RERByCFjKL3SvXpn+eXCfFbM6T64iIyP2h0CN2LybmGhaL1uOLiEjmNL0lIiIiDkGhR0RERByCprfE7mX2TIbclGI2czkuKU+uJSIiuU+hR+zembV59HDCLkGAQo+IiL3S9JaIiIg4BIUeERERcQgKPSIiIuIQFHpERETEISj02LnIyEi8vLzYuXNnmu2+vr706tWLrVu3WrdNnTqVGjVqkJycbN3WoEEDIiMj8fX1JTIy0rr9008/pXXr1ly6dIm5c+fSokULkpL+bxFvWFgYgYGBAHfdD/D7778zffr0NDWOGDGC4ODgNK+joqJyOhQiIiKZUujJB1xdXXnnnXe4du1amu3e3t7s37/f+vrXX3/l2WeftW6LiIigYMGCPPLII2nO+/zzzwkJCWHp0qWULFkSgHPnzjFz5swMa7jb/vfff58+ffoAEBUVRb9+/di8eXOaY/r27cvkyZOz0GMREZHsU+jJB0qVKkX9+vWZOnVqmu316tXjwIEDwM2g4ebmRosWLdixYwcA+/btw8fHJ805S5cuZc2aNXzxxReUKFHCur1Tp05s2LCBffv23bGGzPbv2rULT09PPDw8AFi3bh3NmjWjZcuWaY6rVKkS586d48yZM9kbABERkSxQ6MkngoKC2LFjR5ppLg8PD86cOcONGzfYsWMHPj4++Pj4ZBh6vv76ayZPnkxgYCDFixdP076Hhwfjx49n9OjRaaaxsrI/NDSU5557zvq6d+/evPzyy3fsR61atdi+fXv2B0BEROQuFHryicKFC/Pee++lmeZycnKievXqHD58mB07dtCgQQMeffRRkpKSuHLlCgcOHMDb29vaRlhYGB9//DHTpk3jn3/+SXeN5s2bU7Vq1QynsTLaHxERwUMPPZSlfpQpU4aIiIisdltERCTLFHrykQYNGqSb5vL29ua3334jPDycZ599Frg57bVt2zaKFStG4cL/9xUOM2bMoHHjxnTu3Jm33nqL1NTUdNcYM2YMGzZsSLNW6G77TSYTLi5Ze/i3i4sLTk76sRQRkdyn3y75zK1prosXLwI3A05ISAiVK1e2Bg8fHx+WLFmSbj2Pq6srAIMGDeLGjRvMnz8/XfvFihVj/PjxLFiw4I7Xv9P+cuXKce7cuSzVHxkZSbly5bJ0rIiISHYo9OQzt6a5zGYzAJUrVyYuLo4GDRpYj/H29ubkyZPUr1//jm24uroyffp0lixZwt69e9Ptb968OS1atMiwhn/v9/X1JSwsLEv17927l6ZNm2bpWBERkewwGYZh2LoIyf86d+7MggUL0i2Qvt2xY8dYsGABc+bMyVbbefmFo9HR8ff9OnnB07NIvulLXtPY5YzGLWc0btnj5GSiRInCGe/Pw1rEgb399tt88sknmR7zySefEBQUlEcViYiIo8na6lKRe1StWjWqVauW6TEffPBBHlUjIiKOSKFH7F65tv3z5Dop/3+dlIiI2CeFHrF7MTHXsFi0NE1ERDKnNT0iIiLiEBR6RERExCEo9IiIiIhD0JoesXuZPZMhN6WYk7kcdyNPriUiIrlPoUfs3pmQBXnzcMKuowCFHhERe6XpLREREXEICj0iIiLiEBR6RERExCEo9IiIiIhDUOiRXDF79my2bdtm6zJEREQypE9vSa54/fXXbV2CiIhIphR6xMrHx4dmzZoRHh5OyZIlad++PV9++SUXLlxgypQp1KlThz179jBr1iySkpK4evUqo0aNonnz5gQFBVGnTh3q1KnDoEGDeOKJJzh69CglSpRg9uzZeHh42Lp7IiLi4DS9JVaXLl2iUaNGrFmzhhs3brB161a+/vprBg8ezBdffAHAV199xcSJE1m9ejUTJ05k9uzZ6do5duwYvXr14vvvv6do0aKsW7cur7siIiKSju70SBqNGjUCoGzZstSqVQuAMmXKcPXqVQCmT5/O9u3b2bRpE4cOHSIhISFdGyVKlOCpp54C4IknnuDKlfv/4EAREZG70Z0eScPNzc36d2dn53T7u3btSnh4OFWrVqVfv353bKNAgQLWv5tMJgzDyP1CRUREskl3eiTL4uLiOH36NF9//TVubm7MmDGD1NRUW5clIiKSJQo9kmUeHh506NCB1q1b4+Ligre3N0lJSSQmJtq6NBERkbsyGZp7EDuXl184Gh0df9+vkxc8PYvkm77kNY1dzmjcckbjlj1OTiZKlCic4X7d6cmnzpw5w+DBg9NsS0pKwt3dnTNnzlCuXLk0+4YMGUKzZs3uWz2BgYHWxdC3u3DhAg899FC67b6+vnr2j4iI5CqFnnyqXLlyhISE2LoMqy+//NLWJYiIiINT6BG7V85vQJ5cJ8WcnCfXERGR+0OhR+xeTMw1LBYtTRMRkczpOT0iIiLiEBR6RERExCEo9IiIiIhDUOgRERERh6DQIyIiIg5BoUdEREQcgkKPiIiIOASFHhEREXEICj2SI/Hx8QwcOPCe2wkMDCQsLCwXKhIREcmcQo/kyJUrVzh69KityxAREckyhR7JkYkTJ3Lx4kUGDhzIqlWreOmll2jTpg1BQUEkJCQA4O3tTe/evfHz88NsNjN9+nRatGhBq1at+OKLL6xtrVy5En9/f5o1a0ZoaKituiQiIvmcQo/kyJgxYyhVqhRDhgxh4cKFfPnll6xbt44HHniAefPmAXD58mX69OlDSEgIW7du5bfffmPdunWsWLGC4OBgoqOjAShSpAirV69mzJgxzJ8/35bdEhGRfEyhR+7J3r17adq0KcWKFQOgU6dO7N6927q/evXq1uNatmyJm5sbhQoVIiQkBE9PTwCaN28OQKVKlbh8+XIe90BERByFQo/cE4vFkua1YRikpKRYX7u7uwPg4uKCyWSybo+MjCQxMREAZ2dngDT7RUREcptCj+SIi4sLKSkp1KlTh9DQUOLi4gD47rvvqFu3brrja9euzQ8//IDZbOb69ev07t2bqKioPK5aREQcmYutCxD7VKJECcqUKcOkSZP43//+R2BgIGazmaeffpp333033fHPP/88R44cISAgAIvFQo8ePXjsscdsULmIiDgqk2EYhq2LELkXMTHXsFj0Y5wdnp5FiI6Ot3UZdkljlzMat5zRuGWPk5OJEiUKZ7w/D2sRERERsRmFHhEREXEICj0iIiLiEBR6RERExCEo9IiIiIhDUOgRERERh6DQIyIiIg5BoUdEREQcgkKPiIiIOASFHhEREXEICj0iIiLiEBR6RERExCEo9IiIiIhDUOiR/4z4+HgGDhxo6zJERCSfUuiR/4wrV65w9OhRW5chIiL5lIutC5D/vrCwMBYuXIirqyuRkZH4+vpSsGBBtm7dCsC4ceMYMGAA69atw8nJCX9/fxYsWMDWrVuJiooiIiKCc+fO8fLLL9O/f39SU1OZNm0ae/bsITU1lYCAAHr27MnEiRO5ePEiAwcOZP78+TbutYiI5DcKPZIlhw4dYv369Xh4eFC/fn1GjhxJcHAwo0aN4uDBg3Tq1Ilp06ZhNpvp0qULTz75JFu3buX48eMsW7aM+Ph4mjdvTrdu3Vi/fj0Aq1evJjk5mddee42qVasyZswYevToocAjIiL3hUKPZEnlypV5+OGHAShWrBj16tUDoEyZMly9epX+/fvTvn173N3dmT59uvW8unXr4ubmRokSJfDw8CA+Pp5du3Zx9OhRdu/eDUBiYiLHjx/noYceyvuOiYiIw1DokSxxdXVN89rZ2TnN6/j4eBISEkhISCAuLo7ixYsDUKBAAesxJpMJwzBITU1l+PDhvPDCCwDExsZSqFAhoqOj73MvRETEkWkhs+SKd999l+7du9O1a1fefffdTI/19vbmu+++w2w2k5CQQNeuXTl48CAuLi6kpKTkUcUiIuJodKdH7tnGjRtxd3dn5syZGIZB+/bt2bBhQ4bHd+7cmYiICPz9/UlJSSEgIIC6detiNpspU6YMgYGBfPnll3nYAxERcQQmwzAMWxchci9iYq5hsejHODs8PYsQHR1v6zLsksYuZzRuOaNxyx4nJxMlShTOeH8e1iIiIiJiMwo9IiIi4hAUekRERMQhKPSIiIiIQ1DoEREREYeg0CMiIiIOQaFHREREHIJCj4iIiDgEhR4RERFxCAo9IiIi4hAUekRERMQhKPSIiIiIQ1DoEREREYeQ66Fn1KhRnDt37p7bmTt3LnPnzgXAy8vrntvLzP1uHyAwMJCwsLAsHRsZGYmvr+8d923duhU/Pz/atm3LgAEDuHLlSm6WSXh4ONOnT8+Vtm4f1wsXLjBq1Kg0+z/88EPrewwwZcoU/vjjj1y5toiIyL/leugJCwvDMIzcblaAa9euMX78eBYtWsTatWvx8vJKExpyw4kTJ4iJicnVNgEmT55M7969AYiPj+ftt99myZIlaY7p27cvkydPzvVri4iIALjc7YCUlBTGjx/PX3/9xaVLl/Dy8uKtt96iT58+hIaGAlh/8RYoUICLFy/St29fli1bRkREBJMmTeLGjRsUK1aMCRMmUL58eQIDA3nqqafYv38/N27cYNiwYSxdupS///6bnj170rNnz3R1vPPOO4SHh1OsWDEmT55MmTJliIiIYPz48cTFxeHu7s4777zDU089RVBQEIULF+b3338nKiqKgQMH0r59e+Li4hg9ejQnT57Ezc2NoKAg6tWrB8DYsWM5ePCgtT/ly5fH19eX1q1bs3PnTlxcXBgwYACfffYZERERjBw5klatWvHnn3/y3nvvkZiYSGxsLH379qVLly7MnTuXgwcPcv78ebp3727tR0xMDK+88gpDhw6lefPmGY57UlISb7zxBn/99RdFixZl/vz5AIwbN47SpUsDN++krFu3DoCDBw/ecaz37NnDrFmzSEpK4urVq4waNYrmzZsTFBREnTp1CAgIsLa1d+9e5syZQ2JiIh999BH/+9//mDx5Mrt27cJkMtG2bVv69u1LWFgYCxcuxNXV1XpXqmDBgmzduhWARYsWUbJkSWtfzpw5w8WLF6lYsSIA27Zto0KFCvTq1StNn4sXL07x4sXZvXs33t7ed/vRFBERyZa73uk5cOAArq6uLF++nC1bthAfH89PP/10x2P79u1LqVKlWLRoEYUKFeLNN9/knXfeYe3atXTu3Jk333zTeqxhGKxcuZIWLVowceJE5s2bx7Jly6y/3P+tdu3ahISE8PzzzzNp0iQARo4cyfDhw1m9ejXvvfceb7zxhvX4Cxcu8PXXX/PRRx8xbdo0AGbPnk25cuXYuHEj06ZN48MPP7QeX79+fdauXYuPjw/ffvutdXvJkiUJDg6mYsWKLFq0iM8++4zp06ezaNEiAFasWMGAAQNYtWoVS5cutV4LIDk5mQ0bNtC1a1fg5h2Ovn37MmjQoEwDD0BsbCy9evXi+++/p2TJkmzYsIFixYrx/PPPAzdD0aJFi2jevDnJyckZjvVXX33FxIkTWb16NRMnTmT27NkZXrNo0aIMGTIEX19f+vfvzzfffMP58+dZu3YtK1as4IcffuDHH38E4NChQ7z77rusWrWKZcuWUbx4cYKDg/Hy8mL9+vVp2g0NDaVmzZrW1+3ataNv3744Ozunq+G5556zhmkREZHcdNc7PbVr18bDw4Nly5Zx8uRJTp8+TWJi4l0bPn36NEWLFqVatWoAtGzZkrFjxxIfHw9Ao0aNAChTpgzVq1fngQceoGzZsly9ejVdW+7u7rRt2xYAPz8/PvzwQxISEjhy5EiadSKJiYlcvnwZAB8fH0wmE5UrVyYuLg6AvXv3MmPGDODmnY3ly5dbz70VQipVqsS+ffus22+vs1SpUri4uFCmTBlrnUFBQfzyyy98/PHH/Pnnn2nG5lbfbxk3bhwlS5bkhRdeuOv4lSpVynp+pUqVrP2Cm+Fp4MCBVKlSBX9/f/78888Mx3r69Ols376dTZs2cejQIRISEu567VvCwsLw9/fH2dmZBx54gDZt2rBr1y58fX2pXLkyDz/8MADFihWz3jG7fWxuiYiI4LHHHsvSNcuUKcPOnTuzXKOIiEhW3fVOz7Zt2xg2bBju7u4EBARQu3ZtgDTrdlJSUtKdZ7FY0m0zDIPU1FQAXF1drdtdXDLPXk5O/1emYRi4uLhgsVhwc3MjJCTE+mfFihV4eHgAN6faAEwmU5rr3P7677//ttZ5qwaTyZSmb3erc+jQoWzZsoWKFSsydOjQNPvc3d3TvO7Tpw/Fixfnm2++ybS//77W7TVdvHiRrl274uXlZb3jldlYd+3alfDwcKpWrUq/fv3u2KbZbL5jDf9uN6P3D7jjXZvbr3W39/iWf79HIiIiueWuoWfXrl20bNmS9u3bU7RoUcLCwihSpAhxcXHExsaSnJzML7/8Yj3e2dmZ1NRUHn/8ceLi4ggPDwdgw4YNlClTxhpKsiMxMZFt27YBsGrVKurXr0+RIkWoUKECISEhAOzcuZNu3bpl2s5zzz1nnXr5+++/6dOnzz3/gt25cydDhgyhefPm/PzzzwDWYPBvTz75JOPGjWPevHlERUVl+1qpqan069ePli1bMnr0aGvtGY013Lzj9vrrr9OoUSO2bdtmrc3Dw4MTJ04AWNfiwM3371aI9fb2Zs2aNaSmpnL9+nXWrVtH3bp1s113uXLlsvyJvnPnzlG+fPlsX0NERORu7vrP75dffplhw4axfv16XF1dqVmzJrGxsfTu3ZsOHTrw0EMP8cwzz1iPb9KkCX379uXTTz9l1qxZvPfee1y/fp0HH3yQWbNm5ajIokWLsnXrVmbPnk3p0qV5//33AZg+fTrjx4/n008/xdXVlVmzZmUaYoYMGcKYMWNo27YtLi4uTJs27Z5Dz+DBg+natSsFChSgSpUqlC1blsjIyAyPr1ChAt26dWPChAkZrl/KSGhoKH/88Qepqals3rwZgKpVqzJp0qQ7jrWHhwcdOnSgdevWuLi44O3tTVJSEomJiXTp0oWhQ4fSpk0bvL298fT0BG5Oyc2bN48ZM2bw+uuvc/r0afz8/DCbzbRp04bnn38+yx+9v6Vp06YMGzYsS8eGhYWlWfgtIiKSW0yGPl8ueWDQoEEMGTKEypUrZ3hMTEwMgwYNytL0X9rzrmGx6Mc4Ozw9ixAdHW/rMuySxi5nNG45o3HLHicnEyVKFM5wf9YWWkiuO3PmDIMHD77jvokTJ6a5e5YfjBo1ijlz5jB16tQMj1m4cCFvv/12HlYlIiKORHd6xO7pTk/26V+POaexyxmNW85o3LLnbnd69N1bIiIi4hAUekRERMQhKPSIiIiIQ1DoEREREYeg0CMiIiIOQaFHREREHIJCj4iIiDgEhR4RERFxCAo9IiIi4hAUekRERMQhKPRkIDIyEi8vL8aOHZtm+9GjR/Hy8iI4ODhL7YSFhREYGJjpMUFBQdb2vLy8eO2119Lsj42N5emnn2bu3LmZthMYGEhYWBjx8fEMHDgQgKioKPr06ZPpeXPnzr1r2/fqwoULjBo1Ks22Dz/8MM11p0yZwh9//HFf6xAREcel0JMJDw8PfvnlF1JTU63bNmzYQPHixe/rdU+dOkVcXJz19Q8//EDRokWzfP6VK1c4evQoAKVLl+aTTz7J7RKzbfLkyfTu3RuA+Ph43n77bZYsWZLmmL59+zJ58mRblCciIg5AoScThQoV4sknn2Tv3r3WbTt37qR+/foAbN++HT8/P9q0acOAAQO4dOkSADt27KB169YEBATw3XffWc+NiIigV69e+Pv706VLlwzvajRr1oxt27ZZX2/atInnn3/e+trX15fIyEjgzneSJk6cyMWLFxk4cCCRkZH4+voCN+8ojRs3joCAAFq0aMGaNWvSXfvnn3+mQ4cOtGvXjkGDBnH58mXOnz9PvXr1+Pvvv0lOTqZNmzb8+OOPpKam8v777+Pv70/btm35/PPPrTV16NCBgIAARo4cyZkzZ7h48SIVK1YEYNu2bVSoUIFevXqluXbx4sUpXrw4u3fvzvhNERERySGFnrto2bIlmzdvBiA8PBwvLy9cXV2JiYlh7NixzJ8/n3Xr1lGzZk0mTJhAcnIyQUFBzJkzh+DgYNzd3a1tjRw5kuHDh7N69Wree+893njjjbte81aQ8vT0zHLNY8aMoVSpUsyfPz/dvrNnz7J8+XK++OILpk2bRnR0tHVfbGwsH3zwAYsXL2bNmjU0aNCAGTNm8PDDDzNs2DDGjx/P/PnzqVGjBk2aNLEGutWrV7Ny5Uq2bdvGvn37ADh9+jRffPEFU6dOJTQ0lJo1a1qv065dO/r27Yuzs3O6+p577jlCQ0Oz3FcREZGscrF1Af91vr6+fPjhh1gsFjZu3EjLli3ZsGEDDzzwANWqVeORRx4BoFOnTixatIjjx49TqlQp610Nf39/Zs+eTUJCAkeOHEmzriUxMZHLly+nu2aNGjU4deoU8fHxbNq0iRYtWljDz70KCAjA1dWVhx56iJo1a7J//37rvkOHDnH+/Hl69OgBgMVi4cEHHwSgffv2bNy4kXXr1vH9998DsGvXLo4ePWq9M5OYmMjx48epVKkSjz32GEWKFAFu3uF67LHHslRfmTJl2LlzZ670VURE5HYKPXdRqFAhqlSpwv79+9m9ezdvvfUWGzZswGKxpDnOMAxSUlIwmUwYhmHdfutuhsViwc3NjZCQEOu+Cxcu4OHhke6aJpOJpk2bsm3bNjZv3szs2bNZtmxZuusBpKSkZKs/t99dsVgsuLj8349AamoqNWvWZOHChQDcuHGDhIQE698vXLhAamoqFy5c4PHHHyc1NZXhw4fzwgsvADfvFBUqVIiDBw+mucNlMpnSXCczLi4umEymbPVJREQkKzS9lQUtW7bkgw8+oGrVqtZf3klJSRw6dMi6tmb58uXUrVsXLy8vLl26xLFjxwBYv349AEWKFKFChQrW0LNz5066deuW6TW//vpr3Nzc0i2cLlasGCdOnABIs/bnFhcXlwzD0MaNGzEMg3PnzhEeHk6tWrWs+6pXr87Bgwc5deoUAAsWLGDatGnAzU9aeXt7M2rUKEaNGkVqaire3t589913mM1mEhIS6Nq1KwcPHkx3zXLlynHu3LkM+3q7c+fOUb58+SwdKyIikh2605MFTZs2ZfTo0bz++uvWbSVLlmTChAkMGjQIs9lMmTJlmDRpEq6ursycOZPhw4fj4uLCU089ZT1n+vTpjB8/nk8//RRXV1dmzZqV4V2NZ599lujoaF5++eV0+4YMGcJ7773HvHnzaNCgQbr9JUqUoEyZMgQGBvL++++n2ZeUlET79u1JTk5mwoQJFCtWzLrP09OTyZMnM3ToUCwWC6VLl2b69OkcPHiQzZs3s3btWgoXLszq1av57LPP6NmzJxEREfj7+5OSkkJAQAB169YlLCws3fgNGzYsS2MdFhZG9+7ds3SsiIhIdpiM2+diJF8LCgqiTp06BAQE5Pm1Bw0axJAhQ6hcuXKGx8TExDBo0CC++eabbLUdE3MNi0U/xtnh6VmE6Oh4W5dhlzR2OaNxyxmNW/Y4OZkoUaJwxvvzsBZxYKNGjWLx4sWZHrNw4ULefvvtPKpIREQcje70iN3TnZ7s078ec05jlzMat5zRuGWP7vSIiIiIoNAjIiIiDkKf3hK75+Sk5/rkhMYt5zR2OaNxyxmNW9bdbay0pkdEREQcgqa3RERExCEo9IiIiIhDUOgRERERh6DQIyIiIg5BoUdEREQcgkKPiIiIOASFHhEREXEICj0iIiLiEBR6RERExCEo9IiIiIhDUOgRu7Ru3TpatWrFCy+8wLJly2xdjt2YN28erVu3pnXr1kybNs3W5dilqVOnEhQUZOsy7EZoaCgBAQG0bNmSiRMn2rocuxISEmL973Xq1Km2LidfUOgRuxMVFcWsWbP4+uuvWbNmDcuXL+fEiRO2Lus/79dff2XHjh2sXr2aNWvW8Pvvv7NlyxZbl2VXdu3axerVq21dht04e/Ys48aNY8GCBaxdu5Y//viDn376ydZl2YXr168zadIkvvzyS0JCQti3bx+//vqrrcuyewo9Ynd+/fVXvL298fDwoGDBgrRo0YJNmzbZuqz/PE9PT4KCgnBzc8PV1ZWKFSvyzz//2LosuxEXF8esWbPo16+frUuxG1u2bKFVq1Y89NBDuLq6MmvWLKpXr27rsuxCamoqFouF69evk5KSQkpKCgUKFLB1WXZPoUfszsWLF/H09LS+LlWqFFFRUTasyD488cQTPPvsswCcPn2ajRs30rhxY9sWZUfGjh3LG2+8QdGiRW1dit2IiIggNTWVfv364efnx9dff82DDz5o67LsQuHChXn99ddp2bIljRs3pmzZstSsWdPWZdk9hR6xOxaLBZPJZH1tGEaa15K5v/76i1dffZURI0ZQoUIFW5djF1asWMHDDz9MvXr1bF2KXUlNTWXXrl1MnjyZ5cuXEx4erunBLDp27BirVq1i+/bt/PLLLzg5ObF48WJbl2X3FHrE7jz00ENER0dbX0dHR1OqVCkbVmQ/9u/fT8+ePXnrrbfw9/e3dTl2Y8OGDezcuRM/Pz/mzJlDaGgokydPtnVZ/3klS5akXr16FC9eHHd3d5o3b054eLity7ILO3bsoF69epQoUQI3NzcCAgLYs2ePrcuyewo9Ynfq16/Prl27iI2N5fr16/zwww80atTI1mX9550/f56BAwcyY8YMWrdubety7MqSJUv4/vvvCQkJYciQIfj6+vL222/buqz/vKZNm7Jjxw6uXr1Kamoqv/zyC08//bSty7ILVapU4ddffyUxMRHDMAgNDeWZZ56xdVl2z8XWBYhkV+nSpXnjjTfo0aMHZrOZDh06UK1aNVuX9Z+3ePFibty4wZQpU6zbOnfuTJcuXWxYleRn1atXp3fv3nTt2hWz2YyPjw/t27e3dVl2oUGDBvzxxx8EBATg6urKM888Q9++fW1dlt0zGYZh2LoIERERkftN01siIiLiEBR6RERExCEo9IiIiIhDUOgRERERh6DQIyIiIg5BoUdEREQcgkKPiIiIOIT/B6lynm5qzMP1AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 504x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(7,8))\n",
    "fig.patch.set_facecolor('xkcd:white')\n",
    "sns.set(font_scale=1)\n",
    "palette = sns.color_palette(\"flare\", as_cmap=True)\n",
    "plt.title('Distribution of libraries by score on a logarithmic scale')\n",
    "sns.barplot(y=libr_distr_top.index, x=np.log(libr_distr_top.values), palette=palette.colors)\n",
    "\n",
    "plt.savefig(fname = \"./libr_distr_top.png\", dpi=300, facecolor='w', edgecolor='w',\n",
    "            orientation='portrait', papertype=None, format=None, \n",
    "            transparent=False, bbox_inches=None, pad_inches=0.1,\n",
    "            frameon=None, metadata=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data amount: 8283681\n",
      "Datasets: 895\n",
      "Tasks: 1793\n",
      "Model: 4755\n"
     ]
    }
   ],
   "source": [
    "print(f'Data amount: {len(df_openml)}')\n",
    "print(f'Datasets: {df_openml.data_id.nunique()}')\n",
    "print(f'Tasks: {df_openml.task_id.nunique()}')\n",
    "print(f'Model: {df_openml.flow_name.nunique()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Processed data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data amount: 1230\n",
      "Datasets: 118\n",
      "Tasks: 123\n",
      "Model: 320\n"
     ]
    }
   ],
   "source": [
    "print(f'Data amount: {len(df_top_merge)}')\n",
    "print(f'Datasets: {df_top_merge.data_id.nunique()}')\n",
    "print(f'Tasks: {df_top_merge.task_id.nunique()}')\n",
    "print(f'Model: {df_top_merge.flow_name.nunique()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_top_merge[df_top_merge['flow_name_type'].apply(lambda x: x.endswith('RandomForest'))]['flow_name_type'].unique()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.16 ('sat')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "794105dfe45acd45667c0ec848c3c17bdbc409cda564f877ba431899b91ef0e2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}