--- a
+++ b/DataAnalysis/data_processing.ipynb
@@ -0,0 +1,2191 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Analysis of CHIA dataset\n",
+    "\n",
+    "*Chia* ([[dataset](https://figshare.com/articles/dataset/Chia_Annotated_Datasets/11855817)][[paper](https://www.nature.com/articles/s41597-020-00620-0)]): A large annotated corpus for clinical trial elegibility criteria extracted from 1,000 interventional, Phase IV clinical trials registered in [ClinicalTrials.gov](http://ClinicalTrials.gov).\n",
+    "\n",
+    "Description of the dataset:\n",
+    "\n",
+    "- For each clinical trial (Example: NCT00050349) there are two **.txt** documents and two **.ann** documents, one for the inclusion criteria and one for the exclusion criteria.\n",
+    "- The two **.txt** documents (NCT00050349_exc.txt and NCT00050349_inc.txt) contain the correspondent free text for each inclusion or exclusion criteria respectively.\n",
+    "- The two **.ann** documents (NCT00050349_exc.ann and NCT00050349_inc.ann) contain the annotations for the entities and relationships in the correspondent **.txt** files. Each file has the following format:\n",
+    "    - Each line corresponds to a single entity or relationship. \n",
+    "    - For entity lines we have: 'EntityID (Example: T1) EntityType (Example: Condition) StringStartIndes (Example: 28) StringEndIndex (Example: 35) Text (Example: metastatic carcinoid tumors)'\n",
+    "    - For relationship lines we have: 'RelationshipID (Example: R1) RelationshipType (Example: *has_value*) RootArgument (Example: T1) TargetArgument (Example: T2)'\n",
+    "    - In the case of *or* relationship we have the list of entities connected by the or.\n",
+    "    - List of available entities:\n",
+    "        1. Scope (deppending on the approach used)\n",
+    "\t    2. Person\n",
+    "\t    3. Condition\n",
+    "\t    4. Drug\n",
+    "\t    5. Observation\n",
+    "\t    6. Measurement\n",
+    "\t    7. Procedure\n",
+    "\t    8. Device\n",
+    "\t    9. Visit\n",
+    "\n",
+    "We are going to analyze the corpus with scope entities."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import numpy as np\n",
+    "import json\n",
+    "from sklearn.model_selection import train_test_split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_path = '../data/11855817/chia_with_scope'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# list of all files in the data path\n",
+    "files = os.listdir(data_path)\n",
+    "\n",
+    "# filter out all files that are not .ann files\n",
+    "files = [f for f in files if f.endswith('.ann')]\n",
+    "print(len(files)) # 2000 (1000 for inclusion and 1000 for exclusion)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# analyze the inclusion criteria files\n",
+    "inclusion_files = [f for f in files if f.endswith('inc.ann')]\n",
+    "print(len(inclusion_files)) # 1000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dict_inc_crit = {'entity': {}, 'relation': {}, 'or': 0}\n",
+    "for f in inclusion_files:\n",
+    "    with open(os.path.join(data_path, f), 'r') as f:\n",
+    "        lines = f.readlines()\n",
+    "        for line in lines:\n",
+    "            if line.startswith('T'):\n",
+    "                term = line.strip().split('\\t')[1].split()\n",
+    "                entity = term[0]\n",
+    "                if entity not in dict_inc_crit['entity']:\n",
+    "                    dict_inc_crit['entity'][entity] = 1\n",
+    "                else:\n",
+    "                    dict_inc_crit['entity'][entity] += 1\n",
+    "            elif line.startswith('R'):\n",
+    "                term = line.strip().split('\\t')[1].split()\n",
+    "                relation = term[0]\n",
+    "                if relation not in dict_inc_crit['relation']:\n",
+    "                    dict_inc_crit['relation'][relation] = 1\n",
+    "                else:\n",
+    "                    dict_inc_crit['relation'][relation] += 1\n",
+    "            elif line.startswith('*'):\n",
+    "                dict_inc_crit['or'] += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inclusion criteria:\n",
+      "Entities:\n",
+      "Procedure 1594\n",
+      "Value 2450\n",
+      "Condition 2707\n",
+      "Negation 352\n",
+      "Qualifier 1446\n",
+      "Undefined_semantics 48\n",
+      "Temporal 973\n",
+      "Pregnancy_considerations 59\n",
+      "Post-eligibility 286\n",
+      "Person 1232\n",
+      "Measurement 1850\n",
+      "Multiplier 375\n",
+      "Scope 1295\n",
+      "Mood 235\n",
+      "Device 82\n",
+      "Parsing_Error 217\n",
+      "Not_a_criteria 34\n",
+      "Non-query-able 326\n",
+      "Reference_point 375\n",
+      "Visit 118\n",
+      "Observation 578\n",
+      "Informed_consent 189\n",
+      "Drug 759\n",
+      "Competing_trial 7\n",
+      "Non-representable 130\n",
+      "Grammar_Error 29\n",
+      "Subjective_judgement 57\n",
+      "Context_Error 39\n",
+      "Line 46\n",
+      "Relations:\n",
+      "Has_value 2220\n",
+      "AND 1010\n",
+      "Subsumes 624\n",
+      "Has_negation 354\n",
+      "Has_qualifier 999\n",
+      "Has_temporal 931\n",
+      "Has_multiplier 334\n",
+      "multi 191\n",
+      "Has_mood 220\n",
+      "Has_scope 546\n",
+      "Has_index 328\n",
+      "Has_context 80\n",
+      "causal 14\n",
+      "OR 6\n",
+      "Or: 1202\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print the results for inclusion criteria\n",
+    "print('Inclusion criteria:')\n",
+    "print('Entities:')\n",
+    "for entity, count in dict_inc_crit['entity'].items():\n",
+    "    print(entity, count)\n",
+    "print('Relations:')\n",
+    "for relation, count in dict_inc_crit['relation'].items():\n",
+    "    print(relation, count)\n",
+    "print('Or:', dict_inc_crit['or'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# analyze the exclusion criteria files\n",
+    "exclusion_files = [f for f in files if f.endswith('exc.ann')]\n",
+    "print(len(exclusion_files)) # 1000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dict_exc_crit = {'entity': {}, 'relation': {}, 'or': 0}\n",
+    "for f in exclusion_files:\n",
+    "    with open(os.path.join(data_path, f), 'r') as f:\n",
+    "        lines = f.readlines()\n",
+    "        for line in lines:\n",
+    "            if line.startswith('T'):\n",
+    "                term = line.strip().split('\\t')[1].split()\n",
+    "                entity = term[0]\n",
+    "                if entity not in dict_exc_crit['entity']:\n",
+    "                    dict_exc_crit['entity'][entity] = 1\n",
+    "                else:\n",
+    "                    dict_exc_crit['entity'][entity] += 1\n",
+    "            elif line.startswith('R'):\n",
+    "                term = line.strip().split('\\t')[1].split()\n",
+    "                relation = term[0]\n",
+    "                if relation not in dict_exc_crit['relation']:\n",
+    "                    dict_exc_crit['relation'][relation] = 1\n",
+    "                else:\n",
+    "                    dict_exc_crit['relation'][relation] += 1\n",
+    "            elif line.startswith('*'):\n",
+    "                dict_exc_crit['or'] += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Exclusion criteria:\n",
+      "Entities:\n",
+      "Condition 9332\n",
+      "Mood 338\n",
+      "Multiplier 296\n",
+      "Measurement 1455\n",
+      "Temporal 2071\n",
+      "Procedure 2001\n",
+      "Drug 3042\n",
+      "Qualifier 2711\n",
+      "Person 434\n",
+      "Scope 2959\n",
+      "Observation 1217\n",
+      "Device 304\n",
+      "Negation 491\n",
+      "Parsing_Error 391\n",
+      "Undefined_semantics 217\n",
+      "Post-eligibility 199\n",
+      "Non-query-able 460\n",
+      "Value 1552\n",
+      "Reference_point 559\n",
+      "Pregnancy_considerations 131\n",
+      "Visit 47\n",
+      "Context_Error 104\n",
+      "Subjective_judgement 184\n",
+      "Not_a_criteria 42\n",
+      "Grammar_Error 53\n",
+      "Informed_consent 69\n",
+      "Non-representable 174\n",
+      "Competing_trial 89\n",
+      "Intoxication_considerations 5\n",
+      "Line 54\n",
+      "c-Requires_causality 1\n",
+      "Relations:\n",
+      "Has_mood 270\n",
+      "Has_multiplier 268\n",
+      "Has_temporal 2161\n",
+      "AND 1656\n",
+      "Has_qualifier 2041\n",
+      "Has_scope 967\n",
+      "Has_negation 475\n",
+      "multi 311\n",
+      "Has_context 100\n",
+      "Has_value 1423\n",
+      "Subsumes 1251\n",
+      "Has_index 501\n",
+      "causal 22\n",
+      "OR 1\n",
+      "Or: 1202\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print in a nice way\n",
+    "print('Exclusion criteria:')\n",
+    "print('Entities:')\n",
+    "for entity, count in dict_exc_crit['entity'].items():\n",
+    "    print(entity, count)\n",
+    "print('Relations:')\n",
+    "for relation, count in dict_exc_crit['relation'].items():\n",
+    "    print(relation, count)\n",
+    "print('Or:', dict_inc_crit['or'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# combine the dictionaries\n",
+    "all_ent = set(list(dict_inc_crit['entity'].keys()) + list(dict_exc_crit['entity'].keys()))\n",
+    "all_rel = set(list(dict_inc_crit['relation'].keys()) + list(dict_exc_crit['relation'].keys()))\n",
+    "dict_all_crit = {'entity': {ent :  {'inc': 0 , 'exc': 0} for ent in all_ent}, 'relation': {rel : {'inc': 0 , 'exc': 0} for rel in all_rel}, 'or': 0}\n",
+    "for ent in all_ent:\n",
+    "    if ent in dict_inc_crit['entity']:\n",
+    "        dict_all_crit['entity'][ent]['inc'] = dict_inc_crit['entity'][ent]\n",
+    "    if ent in dict_exc_crit['entity']:\n",
+    "        dict_all_crit['entity'][ent]['exc'] = dict_exc_crit['entity'][ent]\n",
+    "for rel in all_rel:\n",
+    "    if rel in dict_inc_crit['relation']:\n",
+    "        dict_all_crit['relation'][rel]['inc'] = dict_inc_crit['relation'][rel]\n",
+    "    if rel in dict_exc_crit['relation']:\n",
+    "        dict_all_crit['relation'][rel]['exc'] = dict_exc_crit['relation'][rel]\n",
+    "dict_all_crit['or'] = {'inc': dict_inc_crit['or'], 'exc': dict_exc_crit['or']}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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>inc</th>\n",
+       "      <th>exc</th>\n",
+       "      <th>total</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Condition</th>\n",
+       "      <td>2707</td>\n",
+       "      <td>9332</td>\n",
+       "      <td>12039</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Scope</th>\n",
+       "      <td>1295</td>\n",
+       "      <td>2959</td>\n",
+       "      <td>4254</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Qualifier</th>\n",
+       "      <td>1446</td>\n",
+       "      <td>2711</td>\n",
+       "      <td>4157</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Value</th>\n",
+       "      <td>2450</td>\n",
+       "      <td>1552</td>\n",
+       "      <td>4002</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Drug</th>\n",
+       "      <td>759</td>\n",
+       "      <td>3042</td>\n",
+       "      <td>3801</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Procedure</th>\n",
+       "      <td>1594</td>\n",
+       "      <td>2001</td>\n",
+       "      <td>3595</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Measurement</th>\n",
+       "      <td>1850</td>\n",
+       "      <td>1455</td>\n",
+       "      <td>3305</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Temporal</th>\n",
+       "      <td>973</td>\n",
+       "      <td>2071</td>\n",
+       "      <td>3044</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Observation</th>\n",
+       "      <td>578</td>\n",
+       "      <td>1217</td>\n",
+       "      <td>1795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Person</th>\n",
+       "      <td>1232</td>\n",
+       "      <td>434</td>\n",
+       "      <td>1666</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Reference_point</th>\n",
+       "      <td>375</td>\n",
+       "      <td>559</td>\n",
+       "      <td>934</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Negation</th>\n",
+       "      <td>352</td>\n",
+       "      <td>491</td>\n",
+       "      <td>843</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Non-query-able</th>\n",
+       "      <td>326</td>\n",
+       "      <td>460</td>\n",
+       "      <td>786</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Multiplier</th>\n",
+       "      <td>375</td>\n",
+       "      <td>296</td>\n",
+       "      <td>671</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Parsing_Error</th>\n",
+       "      <td>217</td>\n",
+       "      <td>391</td>\n",
+       "      <td>608</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                  inc   exc  total\n",
+       "Condition        2707  9332  12039\n",
+       "Scope            1295  2959   4254\n",
+       "Qualifier        1446  2711   4157\n",
+       "Value            2450  1552   4002\n",
+       "Drug              759  3042   3801\n",
+       "Procedure        1594  2001   3595\n",
+       "Measurement      1850  1455   3305\n",
+       "Temporal          973  2071   3044\n",
+       "Observation       578  1217   1795\n",
+       "Person           1232   434   1666\n",
+       "Reference_point   375   559    934\n",
+       "Negation          352   491    843\n",
+       "Non-query-able    326   460    786\n",
+       "Multiplier        375   296    671\n",
+       "Parsing_Error     217   391    608"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "entities_df = pd.DataFrame.from_dict(dict_all_crit['entity'], orient='index')\n",
+    "entities_df['total'] = entities_df['inc'] + entities_df['exc']\n",
+    "entities_df.sort_values(by=['total'], ascending=False, inplace=True)\n",
+    "entities_df.head(15)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAosAAAHrCAYAAACn9tfQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACJbklEQVR4nOzdZ1RU198F4D30Ir2KQYqdiIqixo6KimLsLahY0Nh7jxrRGCyJ3VgSC5bYaxIjoqAm2AvYK6KighVBRaSd94N/5nUYBiv3DnE/a7GWc+cwd88wwm/OPUUhhBAgIiIiIsqDjtwBiIiIiEh7sVgkIiIiIo1YLBIRERGRRiwWiYiIiEgjFotEREREpBGLRSIiIiLSiMUiEREREWnEYpGIiIiINGKxSEREREQasVikAhMaGgqFQgEjIyPcunVL7X4fHx+UL19ehmTAgQMHoFAosGXLFlnO/75u3rwJf39/WFtbQ6FQYOjQoZKd+969ewgODkZMTIzafcHBwVAoFCrHFi1ahNDQULW2N2/ehEKhyPO+/zIpnrePjw98fHwK7eO/KSsrC/b29pgzZ44k58uLQqFAcHBwoX38gpLzO/3mzZvKY+vWrcPcuXML7Jyurq7o3r17gT0+vRs9uQPQf9+rV68wYcIErFmzRu4ohdawYcNw7NgxrFixAo6OjihatKhk57537x4mT54MV1dXVKpUSeW+Xr16wc/PT+XYokWLYGtrq/YLvmjRojhy5AhKlChRwIm1y3/heS9atEiyc/3zzz94+PAh2rRpI9k5pXbkyBF88cUXcsd4b/7+/jhy5IjK759169bh/PnzBfYBdvv27TA3Ny+Qx6Z3x2KRCpyfnx/WrVuHkSNHomLFinLHkdTLly9hZGSk1vv2vs6fP49q1aqhVatWnybYJ/LFF1+88x89Q0NDfPXVVwWcSB75/Zz/C8/bw8NDsnNt2bIF3t7ecHFxkeycUits74ec97ednR3s7OwkO6exsTG8vLwkOR/lj5ehqcCNHj0aNjY2GDNmTL7t8rtcl/uyTc7lz7Nnz6J9+/awsLCAtbU1hg8fjszMTFy5cgV+fn4wMzODq6srZs6cmec509LSMHz4cDg6OsLY2Bj16tVDdHS0WruTJ0+iRYsWsLa2hpGREby8vLBp0yaVNjmXaMLDw9GzZ0/Y2dnBxMQEr1690vicb9++jS5dusDe3h6GhoYoV64cZs2ahezsbAD/f7n8+vXr2L17NxQKhdploNyEEFi0aBEqVaoEY2NjWFlZoV27drhx44ZKu5xhACdOnECdOnVgYmICd3d3TJ8+XeX8VatWBQD06NFDef6cn0Xuy9Curq64cOECDh48qGzr6uoKQPPP99q1awgICFB5DX755ReVNtnZ2Zg6dSrKlCkDY2NjWFpaokKFCpg3b57G1+HN12/t2rWy/Zzzet45r9uFCxfwzTffwMLCAg4ODujZsyeSk5PVnvuCBQuUP09LS0t89dVX+OOPP976vA8cOPDWLDdu3ECnTp3g5OQEQ0NDODg4oGHDhirDDvK6DP3kyRP0798fxYoVg4GBAdzd3TF+/Hi110GhUGDgwIFYs2YNypUrBxMTE1SsWBF//fWXWm4hBLZv3462bduqHN+4cSNq1KgBU1NTFClSBE2aNFH5+UVFRUFfXx8jR45U+b6cn9Xy5cuVx54+fYoRI0bA3d0dhoaGsLe3R7NmzXD58mWNr2dewy3efPw3/z9GRkbCx8cHNjY2MDY2RvHixdG2bVukpqaqvCa5L0OfP38eLVu2hJWVFYyMjFCpUiWsWrVKpU3Oz3X9+vUYP348nJycYG5uDl9fX1y5ckVj/jddvnwZ33zzDRwcHGBoaIjixYsjMDBQ+XPL7/2d+/n6+Phg165duHXrlvL/+5uvU3p6OqZOnYqyZcvC0NAQdnZ26NGjBx4+fKiSydXVFc2bN8e2bdvg5eUFIyMjTJ48WXnfm1cp0tLSMGLECFSqVEn5e79GjRrYuXPnOz1/+jDsWaQCZ2ZmhgkTJmDIkCGIjIxEgwYNPtljd+jQAV26dEGfPn2wd+9ezJw5ExkZGdi3bx/69++PkSNHYt26dRgzZgxKliypdmnru+++Q+XKlbFs2TIkJycjODgYPj4+iI6Ohru7OwBg//798PPzQ/Xq1bFkyRJYWFhgw4YN6NixI1JTU9Uut/bs2RP+/v5Ys2YNXrx4AX19/TyzP3z4EDVr1kR6ejp++OEHuLq64q+//sLIkSMRGxuLRYsWoXLlyjhy5Ahat26NEiVK4OeffwaAfC9D9+nTB6GhoRg8eDBmzJiBJ0+eYMqUKahZsybOnDkDBwcHZdvExER07twZI0aMwKRJk7B9+3aMGzcOTk5OCAwMROXKlbFy5Ur06NEDEyZMgL+/PwBo7E3cvn072rVrBwsLC+WlS0NDQ41ZL168iJo1a6J48eKYNWsWHB0dsWfPHgwePBiPHj3CpEmTAAAzZ85EcHAwJkyYgLp16yIjIwOXL1/G06dPNT72m+T8Oeenbdu26NixI4KCgnDu3DmMGzcOALBixQplm+7du2Pt2rUICgrClClTYGBggNOnT+f7geF9NGvWDFlZWZg5cyaKFy+OR48e4fDhw/m+tmlpaahfvz5iY2MxefJkVKhQAf/++y+mTZuGmJgY7Nq1S6X9rl27cOLECUyZMgVFihTBzJkz0bp1a1y5ckX5+gPA4cOHkZCQoFIshoSEYMKECcr3YHp6On766SfUqVMHx48fh4eHB2rXro2pU6di7NixqFu3Llq0aIELFy5gwIAB6NKlC4KCggAAz549Q+3atXHz5k2MGTMG1atXx/Pnz/HPP/8gISEBZcuW/ajXMmdscZ06dbBixQpYWlri7t27CAsLQ3p6OkxMTPL8vitXrqBmzZqwt7fH/PnzYWNjg7Vr16J79+64f/8+Ro8erdL+u+++Q61atbBs2TKkpKRgzJgx+Prrr3Hp0iXo6upqzHfmzBnUrl0btra2mDJlCkqVKoWEhAT88ccfSE9PV/m/+i7v70WLFuHbb79FbGwstm/frnJfdnY2WrZsiX///RejR49GzZo1cevWLUyaNAk+Pj44efIkjI2Nle1Pnz6NS5cuYcKECXBzc4OpqWmez+HVq1d48uQJRo4ciWLFiiE9PR379u1DmzZtsHLlSgQGBmp8/vQRBFEBWblypQAgTpw4IV69eiXc3d2Ft7e3yM7OFkIIUa9ePfHll18q28fFxQkAYuXKlWqPBUBMmjRJeXvSpEkCgJg1a5ZKu0qVKgkAYtu2bcpjGRkZws7OTrRp00Z5bP/+/QKAqFy5sjKPEELcvHlT6Ovri169eimPlS1bVnh5eYmMjAyVczVv3lwULVpUZGVlqTzfwMDAd3p9xo4dKwCIY8eOqRzv16+fUCgU4sqVK8pjLi4uwt/f/62PeeTIkTxfl/j4eGFsbCxGjx6tPFavXr08z+/h4SGaNGmivH3ixAmNP5ecn8ObvvzyS1GvXj21tnn9fJs0aSK++OILkZycrNJ24MCBwsjISDx58kQI8fq1rlSpUr7PPS/a8HPO63nnvG4zZ85Uadu/f39hZGSkzPrPP/8IAGL8+PH5nqNevXoqr3nO896/f3++WR49eiQAiLlz577X4y9ZskQAEJs2bVJpN2PGDAFAhIeHK48BEA4ODiIlJUV5LDExUejo6Ihp06apfP/QoUOFp6en8vbt27eFnp6eGDRokEq7Z8+eCUdHR9GhQwflsezsbNGsWTNhaWkpzp8/Lzw8PETZsmXF8+fPlW2mTJkiAIi9e/fm+3w1/b7JLee9EBcXJ4QQYsuWLQKAiImJea/H79SpkzA0NBS3b99Wade0aVNhYmIinj59KoT4/59rs2bNVNpt2rRJABBHjhzJ97wNGjQQlpaW4sGDBxrb5Pf+zv18hRDC399fuLi4qLVdv369ACC2bt2qcjzn98miRYuUx1xcXISurq7K77w37+vWrZvGvJmZmSIjI0MEBQUJLy8vje3o4/AyNEnCwMAAU6dOxcmTJ9Uu632M5s2bq9wuV64cFAoFmjZtqjymp6eHkiVL5jkjOyAgQOWyiYuLC2rWrIn9+/cDAK5fv47Lly+jc+fOAIDMzEzlV7NmzZCQkKB2+Sf3JTRNIiMj4eHhgWrVqqkc7969O4QQiIyMfKfHedNff/0FhUKBLl26qGR1dHRExYoV1S5LOjo6qp2/QoUKeb5Wn1paWhoiIiLQunVrmJiYqL22aWlpOHr0KACgWrVqOHPmDPr37489e/YgJSXlvc4l5885Py1atFC5XaFCBaSlpeHBgwcAgN27dwMABgwY8NHnyou1tTVKlCiBn376CbNnz0Z0dLRyCEJ+IiMjYWpqinbt2qkcz+l9jYiIUDlev359mJmZKW87ODjA3t5e7X22bds2ldd1z549yMzMRGBgoMrPxMjICPXq1VN5PysUCqxevRpmZmbw9vZGXFwcNm3apNJDtXv3bpQuXRq+vr5vfY4folKlSjAwMMC3336LVatWqQ390CQyMhINGzaEs7OzyvHu3bsjNTUVR44cUTme1/sGQL7/b1NTU3Hw4EF06NDhncYdfuz7+6+//oKlpSW+/vprlZ9dpUqV4OjoqPa7qEKFCihduvQ7PfbmzZtRq1YtFClSBHp6etDX18fy5ctx6dKlj8pMmrFYJMl06tQJlStXxvjx45GRkfFJHtPa2lrltoGBAUxMTGBkZKR2PC0tTe37HR0d8zz2+PFjAMD9+/cBACNHjoS+vr7KV//+/QEAjx49Uvn+d52p/Pjx4zzbOjk5Ke9/X/fv34cQAg4ODmp5jx49qpbVxsZG7TEMDQ3x8uXL9z73+3r8+DEyMzOxYMECtazNmjUD8P+v7bhx4/Dzzz/j6NGjaNq0KWxsbNCwYUOcPHnync4l5885P7lf/5zLgDmv/8OHD6Grq5tn/k9BoVAgIiICTZo0wcyZM1G5cmXY2dlh8ODBePbsmcbve/z4MRwdHdXG8dnb20NPT0/tvfsu77Pjx4/j9u3bKkVKzs+latWqaj+XjRs35vl+btGiBdLS0uDn5wdPT0+V+x8+fFigs5BLlCiBffv2wd7eHgMGDECJEiVQokSJt46tfd/fBW973+QlKSkJWVlZ7/z8P/b9ff/+fTx9+hQGBgZqP7vExMQP/v+0bds2dOjQAcWKFcPatWtx5MgRnDhxAj179szzdzx9GhyzSJJRKBSYMWMGGjVqhF9//VXt/pwCL/cA+Q8pmt5VYmJinsdyfhnb2toCeF2saFrKo0yZMiq333Xms42NDRISEtSO37t3T+Xc78PW1hYKhQL//vtvnmMF8xs/KDUrKyvo6uqia9euGnvO3NzcALzuHR4+fDiGDx+Op0+fYt++ffjuu+/QpEkTxMfHaxwLlkPOn/PHsLOzQ1ZWFhITE9/rj7em/0u5/0ADr3tZcyaAXL16FZs2bUJwcDDS09OxZMmSPB/fxsYGx44dgxBC5XV48OABMjMzP+i9u3XrVpQuXVpl7dWcx9myZcs7zY7eu3cvFi9ejGrVqmH79u3YunWrSvFpZ2eHO3fuvHe2N1/PN/8P5fV61qlTB3Xq1EFWVhZOnjyJBQsWYOjQoXBwcECnTp3yfPyC+F2Qm7W1NXR1dd/5+X/s+9vW1hY2NjYICwvL8/43e5rf53xr166Fm5sbNm7cqPI9+U0kpI/HnkWSlK+vLxo1aoQpU6bg+fPnKvc5ODjAyMgIZ8+eVTlekLPc1q9fDyGE8vatW7dw+PBh5czPMmXKoFSpUjhz5gy8vb3z/Mr9S+9dNWzYEBcvXsTp06dVjq9evRoKhQL169d/78ds3rw5hBC4e/dunllz97S8i3fptcjd/l3ampiYoH79+oiOjkaFChXyzJtXj5SlpSXatWuHAQMG4MmTJ+800UPOn/PHyBlOsXjx4vf6vpwZ6Ln/L+U3gxoASpcujQkTJsDT01Ptffmmhg0b4vnz59ixY4fK8dWrVyvvf1+5CzsAaNKkCfT09BAbG6vx55IjISEBXbp0Qb169XD48GG0aNECQUFBiIuLU7Zp2rQprl69+t5DPDS9nn/++afG79HV1UX16tWVM/vf9npGRkYqi8Mcq1evhomJySdZaidnFYDNmzfnWeR+KE3/35s3b47Hjx8jKysrz59b7g9f70qhUMDAwEClUExMTORs6ALGnkWS3IwZM1ClShU8ePAAX375pfJ4zli7FStWoESJEqhYsSKOHz+OdevWFViWBw8eoHXr1ujduzeSk5MxadIkGBkZKWelAsDSpUvRtGlTNGnSBN27d0exYsXw5MkTXLp0CadPn8bmzZs/6NzDhg3D6tWr4e/vjylTpsDFxQW7du3CokWL0K9fv3cev/OmWrVq4dtvv0WPHj1w8uRJ1K1bF6ampkhISEBUVBQ8PT3Rr1+/93rMEiVKwNjYGL///jvKlSuHIkWKwMnJSXmJLDdPT09s2LABGzduhLu7O4yMjDQWqfPmzUPt2rVRp04d9OvXD66urnj27BmuX7+OP//8U/lH/euvv0b58uXh7e0NOzs73Lp1C3PnzoWLiwtKlSr11ucg58/5Y9SpUwddu3bF1KlTcf/+fTRv3hyGhoaIjo6GiYkJBg0alOf3OTo6wtfXF9OmTYOVlRVcXFwQERGBbdu2qbQ7e/YsBg4ciPbt26NUqVIwMDBAZGQkzp49i7Fjx2rMFRgYiF9++QXdunXDzZs34enpiaioKISEhKBZs2bvPSYwJiYGsbGxasWiq6srpkyZgvHjx+PGjRvw8/ODlZUV7t+/j+PHj8PU1BSTJ09GVlYWvvnmGygUCqxbtw66uroIDQ1FpUqV0LFjR0RFRcHAwABDhw7Fxo0b0bJlS4wdOxbVqlXDy5cvcfDgQTRv3lzjB7RmzZrB2tpaOSNdT08PoaGhiI+PV2m3ZMkSREZGwt/fH8WLF0daWppyZnt+r8mkSZPw119/oX79+vj+++9hbW2N33//Hbt27cLMmTNhYWHxXq+nJrNnz0bt2rVRvXp1jB07FiVLlsT9+/fxxx9/YOnSpR/0gcjT0xPbtm3D4sWLUaVKFejo6MDb2xudOnXC77//jmbNmmHIkCGoVq0a9PX1cefOHezfvx8tW7ZE69at3/t8OUvs9O/fH+3atUN8fDx++OEHFC1aFNeuXXvvx6N3JOfsGvpve3M2dG4BAQECgMpsaCGESE5OFr169RIODg7C1NRUfP311+LmzZsaZyc+fPhQ5fu7desmTE1N1c6Xe+Z1zqzCNWvWiMGDBws7OzthaGgo6tSpI06ePKn2/WfOnBEdOnQQ9vb2Ql9fXzg6OooGDRqIJUuWvNPz1eTWrVsiICBA2NjYCH19fVGmTBnx008/KWfe5njX2dA5VqxYIapXry5MTU2FsbGxKFGihAgMDFR5brlfkxzdunVTm924fv16UbZsWaGvr6/ys8hrlujNmzdF48aNhZmZmQCgfCxNs93j4uJEz549RbFixYS+vr6ws7MTNWvWFFOnTlW2mTVrlqhZs6awtbUVBgYGonjx4iIoKEjcvHkz39dBG37O+c2Gzv3+zWu2aVZWlpgzZ44oX768MDAwEBYWFqJGjRrizz//VLbJPVtZCCESEhJEu3bthLW1tbCwsBBdunQRJ0+eVMly//590b17d1G2bFlhamoqihQpIipUqCDmzJkjMjMz8338x48fi759+4qiRYsKPT094eLiIsaNGyfS0tJU2gEQAwYMUHtd3pzlOmHChDxn1ObYsWOHqF+/vjA3NxeGhobCxcVFtGvXTuzbt08IIcT48eOFjo6OiIiIUPm+w4cPCz09PTFkyBDlsaSkJDFkyBBRvHhxoa+vL+zt7YW/v7+4fPmySuY3f98IIcTx48dFzZo1hampqShWrJiYNGmSWLZsmcrP68iRI6J169bCxcVFGBoaChsbG1GvXj3xxx9/qL0muR//3Llz4uuvvxYWFhbCwMBAVKxYUe3/Ss77efPmzSrH81tJIreLFy+K9u3bCxsbG+X/pe7duyt/bvm9v/N6fz558kS0a9dOWFpaCoVCofL7ICMjQ/z888+iYsWKwsjISBQpUkSULVtW9OnTR1y7dk3ZLr/fb3nNhp4+fbpwdXUVhoaGoly5cuK3337TOGOdPg2FEG9cmyEi+g85cOAA6tevj82bN6vN3CXt4eHhgaZNm2LWrFlyRyGiPPAyNBERyerixYtyRyCifHCCCxERERFpxMvQRERERKQRexaJiIiISCMWi0RERESkEYtFIiIiItKIs6HfUXZ2Nu7duwczMzNJtvkiIiIiKkhCCDx79gxOTk7Q0dHcf8hi8R3du3cPzs7OcscgIiIi+qTi4+PxxRdfaLyfxeI7ytkGKT4+Hubm5jKnISIiIvo4KSkpcHZ2futWjywW31HOpWdzc3MWi0RERPSf8bbhdZzgQkREREQasVgkIiIiIo1YLBIRERGRRhyzSEREVMCEEMjMzERWVpbcUegzoqurCz09vY9e8o/FIhERUQFKT09HQkICUlNT5Y5CnyETExMULVoUBgYGH/wYLBaJiIgKSHZ2NuLi4qCrqwsnJycYGBhwYweShBAC6enpePjwIeLi4lCqVKl8F97OD4tFIiKiApKeno7s7Gw4OzvDxMRE7jj0mTE2Noa+vj5u3bqF9PR0GBkZfdDjcIILERFRAfvQHh2ij/Up3nt89xIRERGRRiwWiYiIiEgjjlkkIiKSmOvYXZKe7+Z0//f+Hh8fH1SqVAlz58799IEKUrCFxOdLlvZ8MmCxSERERGq2bdsGfX19uWOQFmCxWFi97ZPTZ/BJh4iICo61tbXcEUhLcMwiERERqfHx8cHQoUMBAK6urggJCUHPnj1hZmaG4sWL49dff1Vpf+fOHXTq1AnW1tYwNTWFt7c3jh07JkNy7SeEwMyZM+Hu7g5jY2NUrFgRW7ZsgRACvr6+8PPzgxACAPD06VMUL14c48ePV37/H3/8AW9vbxgZGcHW1hZt2rQp0LwsFomIiOitZs2aBW9vb0RHR6N///7o168fLl++DAB4/vw56tWrh3v37uGPP/7AmTNnMHr0aGRnZ8ucWjtNmDABK1euxOLFi3HhwgUMGzYMXbp0wT///INVq1bh+PHjmD9/PgCgb9++cHBwQHBwMABg165daNOmDfz9/REdHY2IiAh4e3sXaF5ehiYiIqK3atasGfr37w8AGDNmDObMmYMDBw6gbNmyWLduHR4+fIgTJ04oL1+XLFlSzrha68WLF5g9ezYiIyNRo0YNAIC7uzuioqKwdOlSrFu3DkuXLkXXrl1x//59/Pnnn4iOjlaOH/3xxx/RqVMnTJ48WfmYFStWLNDMLBaJiIjorSpUqKD8t0KhgKOjIx48eAAAiImJgZeXF8c5voOLFy8iLS0NjRo1Ujmenp4OLy8vAED79u2xfft2TJs2DYsXL0bp0qWV7WJiYtC7d29JM7NYJCIiorfKPTNaoVAoLzMbGxvLEalQynnNdu3ahWLFiqncZ2hoCABITU3FqVOnoKuri2vXrqm0keO15phFIiIi+igVKlRATEwMnjx5IncUrefh4QFDQ0Pcvn0bJUuWVPlydnYGAIwYMQI6OjrYvXs35s+fj8jISOX3V6hQAREREZJmZs8iERERfZRvvvkGISEhaNWqFaZNm4aiRYsiOjoaTk5OynF59JqZmRlGjhyJYcOGITs7G7Vr10ZKSgoOHz6MIkWKwNbWFitWrMCRI0dQuXJljB07Ft26dcPZs2dhZWWFSZMmoWHDhihRogQ6deqEzMxM7N69G6NHjy6wzCwWiYiIJPYhO6poMwMDA4SHh2PEiBFo1qwZMjMz4eHhgV9++UX6MIVgneEffvgB9vb2mDZtGm7cuAFLS0tUrlwZ48aNQ8eOHREcHIzKlSsDACZNmoTw8HD07dsXGzduhI+PDzZv3owffvgB06dPh7m5OerWrVugeRUiZyEfyldKSgosLCyQnJwMc3NzueNwUW4iokIgLS0NcXFxcHNzg5GRkdxx6DOU33vwXWsbjlkkIiIiIo1YLBIRERGRRiwWiYiIiEgjFotEREREpBGLRSIiogLGuaQkl0/x3mOxSEREVEBydj1JTU2VOQl9rnLee7l34HkfXGeRiIiogOjq6sLS0lK5h7KJiQkUCoXMqehzIIRAamoqHjx4AEtLS+jq6n7wY7FYJCIiKkCOjo4AoCwYiaRkaWmpfA9+KBaLREREBUihUKBo0aKwt7dHRkaG3HHoM6Kvr/9RPYo5WCwSERFJQFdX95P84SaSGie4EBEREZFGLBaJiIiISCMWi0RERESkEYtFIiIiItKIxSIRERERacRikYiIiIg0YrFIRERERBqxWCQiIiIijVgsEhEREZFGLBaJiIiISCMWi0RERESkEYtFIiIiItKIxSIRERERacRikYiIiIg0YrFIRERERBqxWCQiIiIijVgsEhEREZFGLBaJiIiISCMWi0RERESkEYtFIiIiItKIxSIRERERaSRrsZiZmYkJEybAzc0NxsbGcHd3x5QpU5Cdna1sI4RAcHAwnJycYGxsDB8fH1y4cEHlcV69eoVBgwbB1tYWpqamaNGiBe7cuaPSJikpCV27doWFhQUsLCzQtWtXPH36VIqnSURERFRoyVoszpgxA0uWLMHChQtx6dIlzJw5Ez/99BMWLFigbDNz5kzMnj0bCxcuxIkTJ+Do6IhGjRrh2bNnyjZDhw7F9u3bsWHDBkRFReH58+do3rw5srKylG0CAgIQExODsLAwhIWFISYmBl27dpX0+RIREREVNgohhJDr5M2bN4eDgwOWL1+uPNa2bVuYmJhgzZo1EELAyckJQ4cOxZgxYwC87kV0cHDAjBkz0KdPHyQnJ8POzg5r1qxBx44dAQD37t2Ds7Mz/v77bzRp0gSXLl2Ch4cHjh49iurVqwMAjh49iho1auDy5csoU6bMW7OmpKTAwsICycnJMDc3L4BX4z0FW7zl/mRpchAREVGh9K61jaw9i7Vr10ZERASuXr0KADhz5gyioqLQrFkzAEBcXBwSExPRuHFj5fcYGhqiXr16OHz4MADg1KlTyMjIUGnj5OSE8uXLK9scOXIEFhYWykIRAL766itYWFgo2+T26tUrpKSkqHwRERERfW705Dz5mDFjkJycjLJly0JXVxdZWVn48ccf8c033wAAEhMTAQAODg4q3+fg4IBbt24p2xgYGMDKykqtTc73JyYmwt7eXu389vb2yja5TZs2DZMnT/64J0hERERUyMnas7hx40asXbsW69atw+nTp7Fq1Sr8/PPPWLVqlUo7hUKhclsIoXYst9xt8mqf3+OMGzcOycnJyq/4+Ph3fVpERERE/xmy9iyOGjUKY8eORadOnQAAnp6euHXrFqZNm4Zu3brB0dERwOuewaJFiyq/78GDB8reRkdHR6SnpyMpKUmld/HBgweoWbOmss39+/fVzv/w4UO1XsschoaGMDQ0/DRPlIiIiKiQkrVnMTU1FTo6qhF0dXWVS+e4ubnB0dERe/fuVd6fnp6OgwcPKgvBKlWqQF9fX6VNQkICzp8/r2xTo0YNJCcn4/jx48o2x44dQ3JysrINEREREamTtWfx66+/xo8//ojixYvjyy+/RHR0NGbPno2ePXsCeH3peOjQoQgJCUGpUqVQqlQphISEwMTEBAEBAQAACwsLBAUFYcSIEbCxsYG1tTVGjhwJT09P+Pr6AgDKlSsHPz8/9O7dG0uXLgUAfPvtt2jevPk7zYQmIiIi+lzJWiwuWLAAEydORP/+/fHgwQM4OTmhT58++P7775VtRo8ejZcvX6J///5ISkpC9erVER4eDjMzM2WbOXPmQE9PDx06dMDLly/RsGFDhIaGQldXV9nm999/x+DBg5Wzplu0aIGFCxdK92SJiIiICiFZ11ksTLjOIhEREf2XFIp1FomIiIhIu7FYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDSSvVi8e/cuunTpAhsbG5iYmKBSpUo4deqU8n4hBIKDg+Hk5ARjY2P4+PjgwoULKo/x6tUrDBo0CLa2tjA1NUWLFi1w584dlTZJSUno2rUrLCwsYGFhga5du+Lp06dSPEUiIiKiQkvWYjEpKQm1atWCvr4+du/ejYsXL2LWrFmwtLRUtpk5cyZmz56NhQsX4sSJE3B0dESjRo3w7NkzZZuhQ4di+/bt2LBhA6KiovD8+XM0b94cWVlZyjYBAQGIiYlBWFgYwsLCEBMTg65du0r5dImIiIgKHYUQQsh18rFjx+LQoUP4999/87xfCAEnJycMHToUY8aMAfC6F9HBwQEzZsxAnz59kJycDDs7O6xZswYdO3YEANy7dw/Ozs74+++/0aRJE1y6dAkeHh44evQoqlevDgA4evQoatSogcuXL6NMmTJvzZqSkgILCwskJyfD3Nz8E70CHyHY4i33J0uTg4iIiAqld61tZO1Z/OOPP+Dt7Y327dvD3t4eXl5e+O2335T3x8XFITExEY0bN1YeMzQ0RL169XD48GEAwKlTp5CRkaHSxsnJCeXLl1e2OXLkCCwsLJSFIgB89dVXsLCwULbJ7dWrV0hJSVH5IiIiIvrcyFos3rhxA4sXL0apUqWwZ88e9O3bF4MHD8bq1asBAImJiQAABwcHle9zcHBQ3peYmAgDAwNYWVnl28be3l7t/Pb29so2uU2bNk05vtHCwgLOzs4f92SJiIiICiFZi8Xs7GxUrlwZISEh8PLyQp8+fdC7d28sXrxYpZ1CoVC5LYRQO5Zb7jZ5tc/vccaNG4fk5GTlV3x8/Ls+LSIiIqL/DFmLxaJFi8LDw0PlWLly5XD79m0AgKOjIwCo9f49ePBA2dvo6OiI9PR0JCUl5dvm/v37aud/+PChWq9lDkNDQ5ibm6t8EREREX1uZC0Wa9WqhStXrqgcu3r1KlxcXAAAbm5ucHR0xN69e5X3p6en4+DBg6hZsyYAoEqVKtDX11dpk5CQgPPnzyvb1KhRA8nJyTh+/LiyzbFjx5CcnKxsQ0RERETq9OQ8+bBhw1CzZk2EhISgQ4cOOH78OH799Vf8+uuvAF5fOh46dChCQkJQqlQplCpVCiEhITAxMUFAQAAAwMLCAkFBQRgxYgRsbGxgbW2NkSNHwtPTE76+vgBe91b6+fmhd+/eWLp0KQDg22+/RfPmzd9pJjQRERHR50rWYrFq1arYvn07xo0bhylTpsDNzQ1z585F586dlW1Gjx6Nly9fon///khKSkL16tURHh4OMzMzZZs5c+ZAT08PHTp0wMuXL9GwYUOEhoZCV1dX2eb333/H4MGDlbOmW7RogYULF0r3ZImIiIgKoU+2zmJKSgoiIyNRpkwZlCtX7lM8pFbhOotERET0X1Lg6yx26NBB2TP38uVLeHt7o0OHDqhQoQK2bt36oQ9LRERERFrkg4vFf/75B3Xq1AEAbN++HUIIPH36FPPnz8fUqVM/WUAiIiIiks8HF4vJycmwtrYGAISFhaFt27YwMTGBv78/rl279skCEhEREZF8PrhYdHZ2xpEjR/DixQuEhYUpJ44kJSXByMjokwUkIiIiIvl88GzooUOHonPnzihSpAiKFy8OHx8fAK8vT3t6en6qfEREREQkow8uFvv3749q1aohPj4ejRo1go7O605Kd3d3jlkkIiIi+o/4qHUWvb29UaFCBcTFxaFEiRLQ09ODv7//p8pGRERERDL74DGLqampCAoKgomJCb788kvlfs6DBw/G9OnTP1lAIiIiIpLPBxeL48aNw5kzZ3DgwAGVCS2+vr7YuHHjJwlHRERERPL64MvQO3bswMaNG/HVV19BoVAoj3t4eCA2NvaThCMiIiIieX1wz+LDhw9hb2+vdvzFixcqxSMRERERFV4fXCxWrVoVu3btUt7OKRB/++031KhR4+OTEREREZHsPvgy9LRp0+Dn54eLFy8iMzMT8+bNw4ULF3DkyBEcPHjwU2YkIiIiIpl8cM9izZo1cejQIaSmpqJEiRIIDw+Hg4MDjhw5gipVqnzKjEREREQkk49aZ9HT0xOrVq36VFmIiIiISMu8V7GYkpICc3Nz5b/zk9OOiIiIiAqv9yoWrayskJCQAHt7e1haWuY561kIAYVCgaysrE8WkoiIiIjk8V7FYmRkJKytrQEA+/fvL5BARERERKQ93qtYrFevnvLfbm5ucHZ2VutdFEIgPj7+06QjIiIiIll98GxoNzc3PHz4UO34kydP4Obm9lGhiIiIiEg7fHCxmDM2Mbfnz5+r7BVNRERERIXXey+dM3z4cACvd2yZOHEiTExMlPdlZWXh2LFjqFSp0icLSERERETyee9iMTo6GsDrnsVz587BwMBAeZ+BgQEqVqyIkSNHfrqERERERCSb9y4Wc2ZB9+jRA/PmzeN6ikRERET/YR+8g8vKlSs/ZQ4iIiIi0kLvVSy2adMGoaGhMDc3R5s2bfJtu23bto8KRkRERETye69i0cLCQjkD2tzcPM/Z0ERERET03/FexeKbl55DQ0M/dRYiIiIi0jIfvM5igwYN8PTpU7XjKSkpaNCgwcdkIiIiIiIt8cHF4oEDB5Cenq52PC0tDf/+++9HhSIiIiIi7fDes6HPnj2r/PfFixeRmJiovJ2VlYWwsDAUK1bs06QjIiIiIlm9d7FYqVIlKBQKKBSKPC83GxsbY8GCBZ8kHBERERHJ672Lxbi4OAgh4O7ujuPHj8POzk55n4GBAezt7aGrq/tJQxIRERGRPN67WHRxcQEAZGdnf/IwRERERKRdPngHFwC4evUqDhw4gAcPHqgVj99///1HBSMiIiIi+X1wsfjbb7+hX79+sLW1haOjo8oC3QqFgsUiERER0X/ABxeLU6dOxY8//ogxY8Z8yjxEREREpEU+eJ3FpKQktG/f/lNmISIiIiIt88HFYvv27REeHv4psxARERGRlvngy9AlS5bExIkTcfToUXh6ekJfX1/l/sGDB390OCIiIiKSl0IIIT7kG93c3DQ/qEKBGzdufHAobZSSkgILCwskJyfD3Nxc7jhAsMVb7k+WJgcREREVSu9a23xwz2JcXNyHfisRERERFRIfPGYxR3p6Oq5cuYLMzMxPkYeIiIiItMgHF4upqakICgqCiYkJvvzyS9y+fRvA67GK06dP/2QBiYiIiEg+H1wsjhs3DmfOnMGBAwdgZGSkPO7r64uNGzd+knBEREREJK8PHrO4Y8cObNy4EV999ZXK7i0eHh6IjY39JOGIiIiISF4f3LP48OFD2Nvbqx1/8eKFSvFIRERERIXXBxeLVatWxa5du5S3cwrE3377DTVq1Pj4ZEREREQkuw++DD1t2jT4+fnh4sWLyMzMxLx583DhwgUcOXIEBw8e/JQZiYiIiEgmH9yzWLNmTRw6dAipqakoUaIEwsPD4eDggCNHjqBKlSqfMiMRERERyeSDexYBwNPTE6tWrcq3zfTp09G3b19YWlp+zKmIiIiISAYfvSj324SEhODJkycFfRoiIiIiKgAFXix+4NbTRERERKQFCrxYJCIiIqLCi8UiEREREWnEYpGIiIiINGKxSEREREQaFXixWKdOHRgbG7+13bRp06BQKDB06FDlMSEEgoOD4eTkBGNjY/j4+ODChQsq3/fq1SsMGjQItra2MDU1RYsWLXDnzh2VNklJSejatSssLCxgYWGBrl274unTp5/i6RERERH9p713saijowNdXd18v/T0/n/5xr///htFixbN9zFPnDiBX3/9FRUqVFA5PnPmTMyePRsLFy7EiRMn4OjoiEaNGuHZs2fKNkOHDsX27duxYcMGREVF4fnz52jevDmysrKUbQICAhATE4OwsDCEhYUhJiYGXbt2fd+nTkRERPTZee9Fubdv367xvsOHD2PBggXvtVzO8+fP0blzZ/z222+YOnWq8rgQAnPnzsX48ePRpk0bAMCqVavg4OCAdevWoU+fPkhOTsby5cuxZs0a+Pr6AgDWrl0LZ2dn7Nu3D02aNMGlS5cQFhaGo0ePonr16gD+f//qK1euoEyZMnnmevXqFV69eqW8nZKS8s7PiYiIiOi/4r17Flu2bKn2VaZMGYSGhmLWrFlo3749rly58s6PN2DAAPj7+yuLvRxxcXFITExE48aNlccMDQ1Rr149HD58GABw6tQpZGRkqLRxcnJC+fLllW2OHDkCCwsLZaEIAF999RUsLCyUbfIybdo05WVrCwsLODs7v/NzIiIiIvqv+Kgxi/fu3UPv3r1RoUIFZGZmIiYmBqtWrULx4sXf6fs3bNiA06dPY9q0aWr3JSYmAgAcHBxUjjs4OCjvS0xMhIGBAaysrPJtY29vr/b49vb2yjZ5GTduHJKTk5Vf8fHx7/SciIiIiP5LPmhv6OTkZISEhGDBggWoVKkSIiIiUKdOnfd6jPj4eAwZMgTh4eEwMjLS2E6hUKjcFkKoHcstd5u82r/tcQwNDWFoaJjveYiIiIj+6967Z3HmzJlwd3fHX3/9hfXr1+Pw4cPvXSgCry8hP3jwAFWqVIGenh709PRw8OBBzJ8/H3p6esoexdy9fw8ePFDe5+joiPT0dCQlJeXb5v79+2rnf/jwoVqvJRERERGpeu+exbFjx8LY2BglS5bEqlWrsGrVqjzbbdu2Ld/HadiwIc6dO6dyrEePHihbtizGjBkDd3d3ODo6Yu/evfDy8gIApKen4+DBg5gxYwYAoEqVKtDX18fevXvRoUMHAEBCQgLOnz+PmTNnAgBq1KiB5ORkHD9+HNWqVQMAHDt2DMnJyahZs+b7Pn0iIiKiz8p7F4uBgYFvvQz8LszMzFC+fHmVY6amprCxsVEeHzp0KEJCQlCqVCmUKlUKISEhMDExQUBAAADAwsICQUFBGDFiBGxsbGBtbY2RI0fC09NTOWGmXLly8PPzQ+/evbF06VIAwLfffovmzZtrnAlNRERERK+9d7EYGhpaADHyNnr0aLx8+RL9+/dHUlISqlevjvDwcJiZmSnbzJkzB3p6eujQoQNevnyJhg0bIjQ0FLq6uso2v//+OwYPHqycNd2iRQssXLhQsudBREREVFgpxPssivgZS0lJgYWFBZKTk2Fubi53HCDY4i33J0uTg4iIiAqld61tuDc0EREREWnEYpGIiIiINGKxSEREREQasVgkIiIiIo1YLBIRERGRRiwWiYiIiEgjFotEREREpBGLRSIiIiLSiMUiEREREWnEYpGIiIiINGKxSEREREQasVgkIiIiIo1YLBIRERGRRiwWiYiIiEgjFotEREREpBGLRSIiIiLSiMUiEREREWnEYpGIiIiINGKxSEREREQasVgkIiIiIo1YLBIRERGRRiwWiYiIiEgjFotEREREpBGLRSIiIiLSiMUiEREREWmkJ3cAIpJQsMU7tEku+BxERFRosGeRiIiIiDRizyJ9PPZWERER/WexZ5GIiIiINGKxSEREREQasVgkIiIiIo1YLBIRERGRRiwWiYiIiEgjFotEREREpBGLRSIiIiLSiMUiEREREWnERbm1kOvYXW9tc9NIgiCFFRcJJyIi+mTYs0hEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpxHUWiT7QO62HOd1fgiREREQFhz2LRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNWCwSERERkUYsFomIiIhIIxaLRERERKQRi0UiIiIi0ojFIhERERFpJGuxOG3aNFStWhVmZmawt7dHq1atcOXKFZU2QggEBwfDyckJxsbG8PHxwYULF1TavHr1CoMGDYKtrS1MTU3RokUL3LlzR6VNUlISunbtCgsLC1hYWKBr1654+vRpQT9FIiIiokJN1mLx4MGDGDBgAI4ePYq9e/ciMzMTjRs3xosXL5RtZs6cidmzZ2PhwoU4ceIEHB0d0ahRIzx79kzZZujQodi+fTs2bNiAqKgoPH/+HM2bN0dWVpayTUBAAGJiYhAWFoawsDDExMSga9eukj5fIqJ3Emzx9i8iIonoyXnysLAwldsrV66Evb09Tp06hbp160IIgblz52L8+PFo06YNAGDVqlVwcHDAunXr0KdPHyQnJ2P58uVYs2YNfH19AQBr166Fs7Mz9u3bhyZNmuDSpUsICwvD0aNHUb16dQDAb7/9hho1auDKlSsoU6aMtE+ciIiIqJDQqjGLycnJAABra2sAQFxcHBITE9G4cWNlG0NDQ9SrVw+HDx8GAJw6dQoZGRkqbZycnFC+fHllmyNHjsDCwkJZKALAV199BQsLC2Wb3F69eoWUlBSVLyIiIqLPjaw9i28SQmD48OGoXbs2ypcvDwBITEwEADg4OKi0dXBwwK1bt5RtDAwMYGVlpdYm5/sTExNhb2+vdk57e3tlm9ymTZuGyZMnf9yTIiLN3uVSanBywecgIqJ8aU3P4sCBA3H27FmsX79e7T6FQqFyWwihdiy33G3yap/f44wbNw7JycnKr/j4+Hd5GkRERET/KVpRLA4aNAh//PEH9u/fjy+++EJ53NHREQDUev8ePHig7G10dHREeno6kpKS8m1z//59tfM+fPhQrdcyh6GhIczNzVW+iIiIiD43shaLQggMHDgQ27ZtQ2RkJNzc3FTud3Nzg6OjI/bu3as8lp6ejoMHD6JmzZoAgCpVqkBfX1+lTUJCAs6fP69sU6NGDSQnJ+P48ePKNseOHUNycrKyDRERERGpk3XM4oABA7Bu3Trs3LkTZmZmyh5ECwsLGBsbQ6FQYOjQoQgJCUGpUqVQqlQphISEwMTEBAEBAcq2QUFBGDFiBGxsbGBtbY2RI0fC09NTOTu6XLly8PPzQ+/evbF06VIAwLfffovmzZtzJjQRERFRPmQtFhcvXgwA8PHxUTm+cuVKdO/eHQAwevRovHz5Ev3790dSUhKqV6+O8PBwmJmZKdvPmTMHenp66NChA16+fImGDRsiNDQUurq6yja///47Bg8erJw13aJFCyxcuLBgnyARaQXXsbve2ubmdH8JkhARFT6yFotCiLe2USgUCA4ORnBwsMY2RkZGWLBgARYsWKCxjbW1NdauXfshMYmIiIg+W1oxwYWIiIiItBOLRSIiIiLSiMUiEREREWnEYpGIiIiINGKxSEREREQasVgkIiIiIo1kXTqHiP6b3mldQyMJghAR0UdjzyIRERERacSeRaKCFGzxDm2SCz4HERHRB2LPIhERERFpxGKRiIiIiDTiZWgqVDhxggoMhwwQEeWJPYtEREREpBGLRSIiIiLSiMUiEREREWnEYpGIiIiINOIEF8oXJ5QQERF93tizSEREREQasWeRiIi0wjtdyZjuL0ESInoTi0UiIsof16Ak+qzxMjQRERERacRikYiIiIg0YrFIRERERBqxWCQiIiIijVgsEhEREZFGLBaJiIiISCMWi0RERESkEddZJCKSELfQJKLChj2LRERERKQRi0UiIiIi0ojFIhERERFpxGKRiIiIiDRisUhEREREGrFYJCIiIiKNuHQO0X8El2QhIqKCwJ5FIiIiItKIxSIRERERacRikYiIiIg0YrFIRERERBqxWCQiIiIijTgbmojoM8ZZ9ET0NiwWiYiIPlSwxTu0SS74HEQFiJehiYiIiEgj9iwSERH9F7CXkwoIi0UiIiL69Fi8/mewWCQiosKDBQiR5DhmkYiIiIg0Ys8iERFRHrisUOHxtp/Vzen+EiV5R4Wsh5zFIhERUSHw1oKIhSsVEBaLRERE9F7Y6/p5YbFIRERE/22F7LKvtuEEFyIiIiLSiD2LRERERJ/If/ESPXsWiYiIiEgjFotEREREpBGLRSIiIiLS6LMqFhctWgQ3NzcYGRmhSpUq+Pfff+WORERERKTVPpticePGjRg6dCjGjx+P6Oho1KlTB02bNsXt27fljkZERESktT6bYnH27NkICgpCr169UK5cOcydOxfOzs5YvHix3NGIiIiItNZnsXROeno6Tp06hbFjx6ocb9y4MQ4fPpzn97x69QqvXr1S3k5Ofr1YZ0pKSsEF/Z/sV6lvbZOiEG9p8GlyfpIswH8yjzZlAbQrjzZlAbQrjzZlAbQrjzZlAQpfHm3KAmhXHm3KAkibJ/9TvD6HEG/JIz4Dd+/eFQDEoUOHVI7/+OOPonTp0nl+z6RJkwQAfvGLX/ziF7/4xa//9Fd8fHy+ddRn0bOYQ6FQqNwWQqgdyzFu3DgMHz5ceTs7OxtPnjyBjY2Nxu+RS0pKCpydnREfHw9zc3O542hVHm3Kom15tCmLtuXRpizalkebsmhbHm3Kom15tCmLtuWRM4sQAs+ePYOTk1O+7T6LYtHW1ha6urpITExUOf7gwQM4ODjk+T2GhoYwNDRUOWZpaVlQET8Jc3Nz2d/0b9KmPNqUBdCuPNqUBdCuPNqUBdCuPNqUBdCuPNqUBdCuPNqUBdCuPHJlsbCweGubz2KCi4GBAapUqYK9e/eqHN+7dy9q1qwpUyoiIiIi7fdZ9CwCwPDhw9G1a1d4e3ujRo0a+PXXX3H79m307dtX7mhEREREWuuzKRY7duyIx48fY8qUKUhISED58uXx999/w8XFRe5oH83Q0BCTJk1Su2wuF23Ko01ZAO3Ko01ZAO3Ko01ZAO3Ko01ZAO3Ko01ZAO3Ko01ZAO3Ko01ZNFEI8bb50kRERET0ufosxiwSERER0YdhsUhEREREGrFYJCIiIiKNWCwSERERkUYsFuk/RQiBW7du4eXLl3JHISIi+k/gbGj6JJ4+fYotW7YgNjYWo0aNgrW1NU6fPg0HBwcUK1ZMshzZ2dkwMjLChQsXUKpUKcnOm5/MzEwcOHAAsbGxCAgIgJmZGe7duwdzc3MUKVJE7nikJd7cXvRtZs+eXYBJiIhUfTbrLP4XZWdn4/r163jw4AGys7NV7qtbt65kOc6ePQtfX19YWFjg5s2b6N27N6ytrbF9+3bcunULq1evliyLjo4OSpUqhcePH2tFsXjr1i34+fnh9u3bePXqFRo1agQzMzPMnDkTaWlpWLJkidwRtcL169cRGxuLunXrwtjYON992wuSu7s7Tpw4ARsbG5XjT58+ReXKlXHjxo0CO3d0dPQ7tZNrb/qrV6/iwIEDef6++f7772XJpC1u374NZ2dntZ+NEALx8fEoXry4TMm0gzZ8YM7IyECZMmXw119/wcPDQ5JzFqY8b8NisZA6evQoAgICcOvWLeTuHFYoFMjKypIsy/Dhw9G9e3fMnDkTZmZmyuNNmzZFQECAZDlyzJw5E6NGjcLixYtRvnx5yc//piFDhsDb2xtnzpxRKUBat26NXr16yZLJy8srz4JDoVDAyMgIJUuWRPfu3VG/fv0Cz/L48WN07NgRkZGRUCgUuHbtGtzd3dGrVy9YWlpi1qxZBZ7hTTdv3szz/86rV69w9+7dAj33/v37C/TxP8Zvv/2Gfv36wdbWFo6OjirvH4VCIUuxqE3Fq5ubGxISEmBvb69y/MmTJ3Bzc5P09/GLFy8wffp0RERE5PnaFOQHnrxoywdmfX19vHr1SrYPW7lpW563YbFYSPXt2xfe3t7YtWsXihYtKusb7sSJE1i6dKna8WLFiiExMVHyPF26dEFqaioqVqwIAwMDGBsbq9z/5MkTybJERUXh0KFDMDAwUDnu4uJS4MWHJn5+fli8eDE8PT1RrVo1CCFw8uRJnD17Ft27d8fFixfh6+uLbdu2oWXLlgWaZdiwYdDT08Pt27dRrlw55fGOHTti2LBhkhWLf/zxh/Lfe/bsgYWFhfJ2VlYWIiIi4OrqKkkWbTR16lT8+OOPGDNmjNxRAGhf8aqpJ/z58+cwMjKSNEuvXr1w8OBBdO3aVfa/DYB2fWAeNGgQZsyYgWXLlkFPT/7yR9vy5Ee705FG165dw5YtW1CyZEm5o8DIyAgpKSlqx69cuQI7OzvJ88ydO1fyc2qSnZ2dZ6/CnTt3VHphpfTo0SOMGDECEydOVDk+depU3Lp1C+Hh4Zg0aRJ++OGHAi8Ww8PDsWfPHnzxxRcqx0uVKoVbt24V6Lnf1KpVKwCvC41u3bqp3Kevrw9XV1fJezlPnDiBzZs34/bt20hPT1e5b9u2bZJmSUpKQvv27SU9Z360pXjNGWeqUCgwceJEmJiYKO/LysrCsWPHUKlSJUkz7d69G7t27UKtWrUkPa8m2vSB+dixY4iIiEB4eDg8PT1hamqqcr/U/6+0LU9+WCwWUtWrV8f169e1olhs2bIlpkyZgk2bNgF4/Yvz9u3bGDt2LNq2bSt5ntx/7OXUqFEjzJ07F7/++iuA16/N8+fPMWnSJDRr1kyWTJs2bcKpU6fUjnfq1AlVqlTBb7/9hm+++UaSSRQvXrxQ+QOb49GjR5Luk5pzqc7NzQ0nTpyAra2tZOfOy4YNGxAYGIjGjRtj7969aNy4Ma5du4bExES0bt1a8jzt27dHeHg4+vbtK/m586ItxWvOOFMhBM6dO6dSEBkYGKBixYoYOXKkpJmsrKxgbW0t6Tnzo00fmC0tLWX5m6SJtuXJl6BCadu2bcLDw0OsXLlSnDx5Upw5c0blS0rJycmiVq1awtLSUujq6gpnZ2ehr68v6tatK54/fy5plhzXr18X48ePF506dRL3798XQgixe/ducf78eUlz3L17V5QuXVqUK1dO6Onpia+++krY2NiIMmXKKHNJzd7eXqxatUrt+KpVq4S9vb0QQogLFy4IGxubAs/SrFkzMWHCBCGEEEWKFBE3btwQWVlZon379qJt27YFfn5t5enpKRYuXCiEeP26xMbGiuzsbNG7d2/x/fffS54nJCRE2Nraim7duomff/5ZzJs3T+VLaj179hSLFy+W/LyadO/eXSQnJ8sdQwghxJo1a0S7du3Eixcv5I4ihBCiQ4cOonfv3kKI//8//uzZM9GgQQPRvXt3mdPRu+LSOYWUjo76EpkKhUI5dkbKAdU5IiMjcfr0aWRnZ6Ny5crw9fWVPAMAHDx4EE2bNkWtWrXwzz//4NKlS3B3d8fMmTNx/PhxbNmyRdI8L1++xPr161Vem86dO6uNpZTK1KlTERISgt69e6Nq1apQKBQ4fvw4li1bhu+++w7jx4/HnDlz8Pfff2Pv3r0FmuXixYvw8fFBlSpVEBkZiRYtWuDChQt48uQJDh06hBIlShTo+fMSERGhcXLAihUrJMlgamqKCxcuwNXVFba2tti/fz88PT1x6dIlNGjQAAkJCZLkyOHm5qbxPoVCIfmkiWnTpmH27Nnw9/eHp6cn9PX1Ve4fPHiwpHm0iZeXF2JjYyGEgKurq9prc/r0aUnz3Lt3D/Xr14euri6uXbsGb29vXLt2Dba2tvjnn3/UJgUVNG2YmZ3bw4cPceXKFSgUCpQuXVqW4Vtvw2KxkHrbeC4XFxeJkmifGjVqoH379hg+fDjMzMxw5swZ5ZIorVq1km1iiTb5/fffsXDhQly5cgUAUKZMGQwaNEg5e/3ly5fK2dEFLTExEYsXL8apU6eUxfSAAQNQtGjRAj93bpMnT8aUKVPg7e2d5+SA7du3S5LD2dkZf//9Nzw9PVGxYkWMHTsW33zzDY4cOQI/Pz8kJydLkkNbaVvxqk0zkCdPnpzv/ZMmTZIoyf/Tlg/MuWdmX716Fe7u7hg6dKgsS5m9ePECgwYNwurVq5XvGV1dXQQGBmLBggV5DtGRC4tF+iQiIiIwZ84cXLp0CQqFAmXLlsXQoUNl6V0sUqQIzp07Bzc3N5Vi8ebNmyhbtizS0tIky/K2NSYDAwMlSqJ9MjIy0LhxYyxduhSlS5eWOw4AoGjRopg5cya6du0qa46AgAB4e3tj+PDh+PHHHzFv3jy0bNkSe/fuReXKlWUd+J7zJ0PuWbba5Jtvvsl3BvKQIUNkSkZvatWqFczMzLB8+XLY2Ngo/zYcPHgQvXr1wrVr1yTN06dPH+zbtw8LFy5UTkiKiorC4MGD0ahRIyxevFjSPPnhBJdCLDY2FnPnzlUWaOXKlcOQIUMkv3S3cOFCDBs2DO3atVP+Ujx69CiaNWuG2bNnY+DAgZLmsbS0REJCglrvQ3R0tKS7yQDqfyQyMjKQmpoKAwMDmJiYfNbFor6+Ps6fP69VRUd6ejpq1qwpdwwsXLhQ+aFm3Lhx0NfXR1RUFNq0aaM2i10qq1evxk8//aT8g1q6dGmMGjVK9sJaG4pXbZuBDACnTp1S/m3w8PCAl5eXZOd+cymqt2nRokUBJlGlTTOzAWDr1q3YsmULfHx8lMeaNWsGY2NjdOjQQauKRU5wKaTCwsKEgYGBqFatmhg2bJgYOnSoqFatmjA0NBTh4eGSZnFychILFixQO75w4UJRtGhRSbMIIcSoUaNE7dq1RUJCgjAzMxPXrl0TUVFRwt3dXQQHB0ueJ7erV6+Khg0birCwMFnOr1AohI6OjsYvKQ0fPlyMGTNG0nPmZ/To0WLKlCmyZsjIyBChoaEiISFB1hxvmjVrljAxMRGjR48WO3fuFDt27BCjRo0SJiYmYvbs2bJkWrVqlShfvrwwNDQUhoaGwtPTU6xevVqWLK6uruLixYuynDu3+/fvi/r16wuFQiGsrKyEpaWlUCgUokGDBuLBgweSZFAoFO/0JfXvGysrK3HhwgUhxP9PHBNCiH///Vc5uU9KxsbGeb5vzp8/L0xMTCTPkx9ehi6kvLy80KRJE0yfPl3l+NixYxEeHi7pIGYzMzNER0erLeNz7do1eHl54fnz55JlAV733nXv3h0bNmyAEAJ6enrIyspCQEAAQkNDoaurK2mevJw8eRJdunTB5cuXJT/3zp07VW5nZGQgOjoaq1atwuTJkxEUFCRZlpzxOiVLloS3t7faOmNS74E8ZMgQrF69GhUqVECFChXUJgdIlcfExASXLl3SmrHHbm5umDx5slpP+KpVqxAcHIy4uDhJ88yePRsTJ07EwIEDUatWLQghcOjQIfzyyy+YOnUqhg0bJmmetWvXYufOnVi1apXs48w6duyI2NhYrFmzRrnQ/cWLF9GtWzeULFkS69evlzWfnDp27AgLCwv8+uuvMDMzw9mzZ2FnZ4eWLVuiePHiWLlypaR5GjZsCBsbG6xevVo5Pvzly5fo1q0bnjx5gn379kmaJz8sFgspIyMjnDt3Tm3/46tXr6JChQqSjsvr3LkzKlWqhFGjRqkc//nnn3Hq1CnZfjnFxsYiOjoa2dnZ8PLy0oq9onNER0ejXr16eS5mLpd169Zh48aNasVkQcpvS0GFQoHIyEjJsgDak6d+/foYMmSIcrFwuRkZGeH8+fN5fiD09PSU9PcNoH3FqzbNQLawsMC+fftQtWpVlePHjx9H48aN8fTpU8myaBttm5l97tw5NG3aFGlpaahYsSIUCgViYmJgZGSEPXv24Msvv5Q0T344ZrGQsrOzQ0xMjFoBFBMTI/kbvly5cvjxxx9x4MAB1KhRA8DrMYuHDh3CiBEjMH/+fGVbKZe0KFGihCxLr7wp99gdIQQSEhJUBjRri+rVq6N3796SnlPb9kPWljz9+/fHiBEjcOfOHVSpUkWtx7VChQqS5ilZsiQ2bdqE7777TuX4xo0bZfkQlpCQkOfY0po1a0q+rBAArSnqgdeLYOcuVoHXY4Rzz9KWirZMgHRyckJMTIzKzOygoCDZljLz9PTEtWvXsHbtWly+fBlCCHTq1EnWpdU0Yc9iITVlyhTMmTMHY8eORc2aNaFQKBAVFYUZM2ZgxIgRmDBhgmRZ8lvG4k0FuaTF8OHD8cMPP8DU1FS5BZcmUl7azL0epkKhgJ2dHRo0aIBZs2bJsjxMXl6+fIlx48Zh9+7dyuV0PmfXr19HbGws6tatC2NjY417/xYUbVtHdevWrejYsSN8fX1Rq1Yt5e+biIgIbNq0SfJdZcqXL4+AgAC14nXq1KnYuHEjzp07J2kebdKyZUs8ffoU69evh5OTEwDg7t276Ny5M6ysrCRb/inHmxMg3+xM2LJliywTILVFRkYGypQpg7/++gseHh5yx3krFouFlBACc+fOxaxZs3Dv3j0Arz81jRo1CoMHD9aqGaZSqF+/PrZv3w5LS0v4+PhofP5yXNrUNlZWViqvjxACz549g4mJCdauXSvp7MT69evn+16V+mf1+PFjdOjQAfv374dCocC1a9fg7u6OoKAgWFpaSrY/tDauo3rq1Cll75AQAh4eHhgxYoSks2xzaFvxqk3i4+PRsmVLnD9/Hs7OzsrtVz09PbFz5061fdgLWrFixTBu3Di1ovCXX37Bjz/+qPz7VVD++OMPNG3aFPr6+m+dpS3l7z7g9Wuzb98+5dhSbcZi8T/g2bNnACD5Ppt5ETItY3H27FmUL18+zx4ZUrVq1SqV2zo6OrCzs0P16tVhZWUlaZbcExEyMjIQExOD8+fPo1u3bpg3b56keQIDA/HgwQMsW7YM5cqVU67DFh4ejmHDhuHChQuS5iHN5C5era2tcfXqVdja2qp9AMvtyZMnkmR60969e5WXNj08PGTbUUvuCZA6OjpITEyEvb19vn8f5Oixnz59Oi5fvoxly5ZBT0+7RwVqdzp6J9pQJMq9BpuXlxcSEhJgb2+v3K3FxsZGknPn9rbL4G+SerZvZmYmbt68iZ49e8LZ2VnSc+dlzpw5eR4PDg6WfBY9AISHh2PPnj1qvS+lSpV6a2/fpyb3OqopKSkwNzdX/js/Oe2kVKVKFaxdu1by8+aYM2eO8nfv3LlzZcuhSaNGjdCoUSO5Y6BFixbYvn272gTInTt34uuvvy7w8785TlOuMZuaHDt2DBEREQgPD4enp6fa2GQ5F9/PjcViIVK5cmVERETAysoKXl5e+X6SlXL2naZlLPr27YtHjx5JsoyFpaUl4uLiYG9vj5s3b8r6SyE6Ovqd2skxVEBPTw8///wzunXrJvm530eXLl1QrVo1/Pzzz5Ke98WLF3kuffLo0SMYGhpKlmPPnj1o0aIFKlWqpPw/dfjwYXz55Zf4888/JSkCrKyslB/ALC0t83y/yjWG8vTp09DX14enpyeA14XHypUr4eHhgeDgYLVFlwvCm/+H5P7/NH/+fHz77bcwMjJSmVCYFykmGb6Z4W0TID9nlpaWaNu2rdwx3gkvQxcikydPxqhRo2BiYoLg4OB8iw0p9//UhmUsvv32W6xevRpFixbF7du38cUXX2hcT1HqfWO1TatWrdCqVSt0795d7igarVmzBmPGjCnw8Uy5+fv7o3Llyvjhhx+U67C5uLigU6dOyM7OxpYtWyTJoQ3rqB48eBC1atWCnp4eDh48mG/bevXqFXieN1WtWhVjx45F27ZtcePGDXh4eKBNmzY4ceIE/P39Zenpy8rKwo4dO1R2TWnRooUk67q6ubnh5MmTsLGx0Yp9s7Vh0mOOtxXPb5JytY7MzEz8/vvvaNKkCRwdHSU774disUgfTVvWYAsLC8P169cxePBgTJkyRePl+c99n9alS5ciODgYnTt3znNZFikHebdp00blds7SQidPnsTEiRMl/dADvF682MfHB1WqVEFkZCRatGiBCxcu4MmTJzh06JBkl4C1aR1VALh9+7ZyssSbhBCIj49H8eLFJc1jYWGB06dPo0SJEpgxYwYiIyOxZ88eHDp0CJ06dUJ8fLykea5fv45mzZrh7t27KFOmDIQQuHr1KpydnbFr1y7Zl/D6nGlT4Zqbti2+nx9ehi6kNI3Le/r0KSpXrizpm15b1mDz8/MD8Hrg+5AhQ7RiLCcAnDhxAps3b8bt27eRnp6ucp8cY1L69esHIO/xklJfUrSwsFC5raOjgzJlymDKlClo3LixZDlyeHh44OzZs1i8eDF0dXXx4sULtGnTBgMGDJB0mSNtWkcVeP0HN+eS9JuePHkCNzc3yS9DCyGUQ0327duH5s2bAwCcnZ3x6NEjSbMAr3ukSpQogaNHj8La2hrA65n1Xbp0weDBg7Fr1y7JskyZMgUjR45UG07x8uVL/PTTT/j+++8ly6INpF6g/X1Ur14d0dHRhaJYZM9iIfXmDK833b9/H87OzmpFSUHiMhaabdiwAYGBgWjcuDH27t2Lxo0b49q1a0hMTETr1q0l316KCgdtWkcVeP375v79+7Czs1M5fuvWLXh4eODFixeS5mnQoAGcnZ3h6+uLoKAgXLx4ESVLlsTBgwfRrVs33Lx5U9I8pqamOHr0qHIMZY4zZ86gVq1akk7W0tXVzbOwf/z4Mezt7SUv7AHgzp07+OOPP/L8wCz1JL8ccq3c8abNmzdj7NixGDZsmFYsvp8f9iwWMm+uE7Vnzx6VnpmsrCxERES8c7f7p9K2bVscO3YMc+bMwY4dO5RLNRw/flyyZSzatGmD0NBQmJubq13azE3K3ryQkBDMmTMHAwYMgJmZGebNmwc3Nzf06dNHlgW5s7OzERoaim3btuHmzZtQKBRwd3dH27Zt0bVr189ufc68pKWl4ezZs3jw4IHaRCmpLtFPnDgRZmZmmDVrFsaNGwfg9TqqwcHBko6rypnZr1AoMHHiRJXeqqysLBw7dgyVKlWSLE+OuXPnonPnztixYwfGjx+vHAKzZcuWPHd2KWiGhobKJcze9Pz5c0km27xJ0wLyZ86cUfZ6SikiIgItWrSAm5sbrly5gvLly+PmzZsQQqBy5cqS51m+fDnmzJmjXLmjVKlSGDp0KHr16iV5lo4dOwJQHSsp5+L7+WHPYiGTs05UzhvqTfr6+nB1dcWsWbOUl2U+Fz169MD8+fNhZmaGHj165NtWyt48U1NTXLhwAa6urrC1tcX+/fvh6emJS5cuoUGDBpJuTSaEwNdff42///4bFStWRNmyZSGEwKVLl3Du3Dm0aNECO3bsKPAcb1uT7k1Sr08XFhaGwMDAPC9lyvXLW851VHP2yj548CBq1KihUvgYGBjA1dUVI0eOlHS4SVZWFqKiouDp6alW/KSlpUFXVzfP7e4KUmBgIE6fPo3ly5ejWrVqAF4vi9K7d29UqVIFoaGhBZ4h5/9VcnIyzM3NVf6PZWVl4fnz5+jbty9++eWXAs/ypmrVqsHPz085jvzMmTOwt7dH586d4efnpxwWI4WJEydizpw5GDRokHJm9pEjR7Bw4UIMGTIEU6dOlSwLoJ2L72skqFBydXUVDx8+lDuGEEKIXbt2ibCwMLXjYWFh4u+//5Yhkfb44osvxNmzZ4UQQlSoUEGsW7dOCCHE4cOHhbm5uaRZVqxYIczMzERkZKTafREREcLMzEysWrWqwHOEhoYqv2bNmiWsrKxEp06dxLx588S8efNEp06dhJWVlZg9e3aBZ8mtRIkSon///iIxMVHyc+fl/v374p9//hH//vuvePDggWw5unfvLpKTk2U7f26Ghobixo0bcsdQSkpKEi1atBAKhUIYGBgIAwMDoaOjI1q1aiWePn0qSYbQ0FCxcuVKoVAoxLx581T+n61bt04cPnxYkhy5FSlSRFy/fl0IIYSlpaU4f/68EEKImJgY4eLiImkWGxsb5e/gN61bt07Y2NhImqWwYbFIH83T01Ps2rVL7fju3btFhQoVZEgkv+joaCGEEN98842YNWuWEEKIqVOnCjs7O9GrVy/h4uIiWrduLWmmRo0aiWnTpmm8/8cffxSNGzeWMJEQbdq0EQsWLFA7vmDBAtGyZUtJswghhJmZmfIPm5ySk5NFly5dhK6urlAoFEKhUAg9PT3RuXNnyYoPbebt7S327dsndww1V69eFTt37hQ7d+4U165dkyXDgQMHRHp6uiznzouDg4O4cOGCEEIIDw8PsXPnTiHE62LR1NRU0iyWlpbi6tWrasevXLkiLCwsJMvRr18/8ezZM+Xt1atXq9xOSkoSTZs2lSzPu+Bl6EJE2xZezWFsbIxLly7B1dVV5fjNmzfx5ZdfSjL4/W2LlL9JijXqdHR04OXlhVatWqFXr14oWrQosrOz8fPPPyMqKgolS5bExIkTJd1ez9HREWFhYRrHmEVHR6Np06ZITEyULFORIkUQExMj21ZgufXs2RO1atVCUFCQpOfNrUOHDoiJicGCBQtQo0YNKBQKHD58GEOGDEGFChWwadMmyTNp06z+8PBwjBkzBj/88EOeEwPk2FEmh9CCiRM5Xr58iYyMDJVjUr82rVq1gr+/P3r37o3Ro0dj+/bt6N69O7Zt2wYrKyvs27dPsiyDBg2Cvr6+2qSakSNH4uXLl5Jdos89Ccnc3BwxMTFwd3cH8HqiqpOTE8cs0ofRtoVXczg6OmLdunVo0KCByvF9+/YhICAADx48KPAMkydPfue2Uqzdd+TIEaxYsQKbNm1CRkYG2rRpg6CgIOUYMDkYGBjg1q1bGifW3Lt3D25ubnj16pVkmVxcXDBw4EC1rcB++uknLFy4UPIt9lJTU9G+fXvY2dnB09NTbeybVB/CTE1NsWfPHtSuXVvl+L///gs/Pz/JZx9r26z+N/f4fbMoEzJODNCWiROpqakYPXo0Nm3ahMePH6vdL/Vrc+PGDTx//hwVKlRAamoqRo4cqfzAPGfOHEnH5Q0aNAirV6+Gs7MzvvrqKwCvd5OJj49HYGCgyv/3gpylnXs1k5yxnNpcLHI2dCHy5npR2rR2VIsWLTB06FBs375dufjs9evXMWLECMlmj0q9ePPb1KhRAzVq1MD8+fOxadMmrFy5Er6+vnB1dUXPnj3RrVs3tf2HC1pWVla+m9Xr6uoiMzNTwkSvi/ygoCC1rcDCwsKwbNkySbMAwLp167Bnzx4YGxvjwIEDKoWIQqGQrFi0sbFRW4MSeL0upZS90Tm0bVb//v37JT9nfjRNnBg2bBhu3rwp6cSJUaNGYf/+/Vi0aBECAwPxyy+/4O7du1i6dKnajkBSyCmAgNeLUC9atEjyDDnOnz+vnIEdGxsL4PWapnZ2djh//ryynTb0CmsdOa+B03/D06dPxVdffSX09PSEq6urcHV1Fbq6uqJ+/foiKSlJ7nha4/r162L8+PHC2dlZ6OnpST4mRaFQiGbNmonWrVvn+dWsWTOho6MjaSYhhDh69KgICAgQXl5eolKlSiIgIEAcPXpU8hxCvB5f9eOPP4qsrCxZzp9j6dKlwtfXV9y7d095LCEhQTRu3FgsWbJE8jwmJiYiLi5OCPF6kkDOpK2LFy8KR0dHyfNoG22aOOHs7Cz2798vhHg9Bjdn7OTq1atlHwfXr18/rZmYKSeFQiHu37+vvF2kSBERGxurvJ2YmCjL7+L8sGexEMlZ8+xdSLnQqYWFBQ4fPoy9e/fizJkzMDY2RsWKFVGnTh3JMrwpKysLc+bMwaZNm/IcXyX1ciw5SpQogbFjx8LZ2Rnfffcd9uzZI+n5u3Xr9tY2uff3lkL16tXx+++/S37evKSnp6Njx44qlznlsHjxYly/fh0uLi7KrfRu374NQ0NDPHz4EEuXLlW2lWIMrrW1tXIJn2LFiuH8+fPw9PTE06dPkZqaWuDnz8u///6LpUuX4saNG9i8eTOKFSuGNWvWwM3NTe3yfUHLysqCt7e32vEqVapI3lufs6sO8HosXM7vu9q1a0u6TE1e1q5di5EjR8LW1lbWHNrg+++/V65bmp6ejh9//FF5NUGu/1P5YbFYiERHR6vcPnXqFLKyslCmTBkAr/eN1dXVRZUqVSTJc+zYMTx58gRNmzaFQqFA48aNkZCQgEmTJiE1NRWtWrXCggULYGhoKEmeHJMnT8ayZcswfPhwTJw4EePHj8fNmzexY8cO2ba6OnjwIFasWIGtW7dCV1cXHTp0kHwShbbuFhMbG4uVK1fixo0bmDt3Luzt7REWFgZnZ2d8+eWXkmbp1q0bNm7cqLZ1pdRatWol6/lzq1OnDvbu3QtPT0906NABQ4YMQWRkJPbu3YuGDRtKnmfr1q3o2rUrOnfujNOnTyvH2T579gwhISH4+++/Jc3TpUsXLF68WO1D+q+//orOnTtLmsXd3R03b96Ei4sLPDw8sGnTJlSrVg1//vknLC0tJc2Sm5BhioQ2bthQt25dXLlyRXm7Zs2aavMM6tatK0mWd8UJLoXU7NmzceDAAaxatUo5hikpKQk9evRAnTp1MGLEiALP0LRpU/j4+GDMmDEAgHPnzqFKlSro1q0bypUrh59++gl9+vRBcHBwgWd5U4kSJTB//nz4+/vDzMwMMTExymNHjx7FunXrJMkRHx+P0NBQhIaGIi4uDjVr1kRQUBA6dOigNnvzc3Xw4EE0bdoUtWrVwj///INLly7B3d0dM2fOxPHjx7FlyxZJ8wwePBirV69GxYoVUaFCBbUJLnJtTSa3J0+eIC0tDU5OTrLP6gder34wbNgwBAYGqkwOiImJgZ+fn6Qz+gHtmTgBAHPmzIGuri4GDx6M/fv3w9/fH1lZWcjMzMTs2bMxZMiQAj1/fnJP5JDCmxs2dO/ePd/xiNr6gVobsFgspIoVK4bw8HC1npfz58+jcePGuHfvXoFnKFq0KP7880/l5Zfx48fj4MGDiIqKAvB638tJkybh4sWLBZ7lTaamprh06RKKFy+OokWLYteuXahcuTJu3LgBLy8vJCcnF3iGRo0aYf/+/bCzs0NgYCB69uyp7AGm/1ejRg20b98ew4cPV/lDcuLECbRq1Qp3796VNE9+s9UVCgUiIyMlTPPa8+fP1bYdlHNpGG1gYmKCixcvwtXVVeV9c+PGDXh4eCAtLU3SPO+6yoEc76Hbt2/j5MmTKFGiBCpWrCjpuQHgxYsX/HD8kXIvrSMHXoYupFJSUnD//n21YvHBgwd57lFaEJKSkuDg4KC8ffDgQfj5+SlvV61aFfHx8ZJkedMXX3yBhIQEFC9eHCVLlkR4eDgqV66MEydOSHZJ3NjYGFu3bkXz5s2hq6sryTkLo3PnzuXZ02tnZ5fnsh8FTVtm2cbFxWHgwIE4cOCASuEjZFoapn79+ujSpQvatWuX5yxtqRUtWhTXr19XW9s1KipKlj+o7/q+uXPnDrKzsyUdE1u8eHHluFc5ODg4oEOHDujZs6fkY0lza9CgAbZt26Z2OT4lJQWtWrWS5cPgu9CGPj0Wi4VU69at0aNHD8yaNUvlsseoUaPeOi7jU3FwcEBcXBycnZ2Rnp6O06dPq6x3+OzZM8n3aAVevzYRERGoXr06hgwZgm+++QbLly/H7du3MWzYMEky/PHHH5Kcp7CztLREQkKC2rqh0dHRKFasmEypXi/9FBsbi7p168LY2FhZpEklZ5zbihUr4ODgIPtSHp6enpgwYQIGDhyIZs2aoWvXrmjWrJnKXtFS6tOnD4YMGYIVK1ZAoVDg3r17OHLkCEaOHCnbuOR34eHhUeA9RJo2bFAoFDAyMkLJkiVRt25dyT7Erl+/HqGhoWjYsCFcXFzQs2dPBAYGwsnJSZLzv+nAgQNqEx6B13uK//vvv5LnKVTkm4hNH+PFixeiX79+wtDQUOjo6AgdHR1hYGAg+vXrJ54/fy5Jhm+//VbUqFFD/PPPP2L48OHCxsZGvHr1Snn/2rVrhbe3tyRZ8nPkyBExa9Ys5TZTpD1GjRolateuLRISEpTLfERFRQl3d3cRHBwseZ5Hjx6JBg0aCIVCIXR0dJTLWfTs2VMMHz5cshympqbi8uXLkp3vXWRlZYk9e/aIbt26CXNzc2FlZSV69+4tDhw4IEue8ePHC2NjY+V2iEZGRmLChAmyZHlXuZdIKQiurq7C1NRUKBQKYW1tLaysrIRCoRCmpqbCwcFBKBQKUaJECXH79u0CzZHbo0ePxOzZs0WFChWEnp6e8Pf3F1u3bhUZGRkFfu4zZ86IM2fOCIVCIfbv36+8febMGXH69GkREhIi+T7V70OK983bsFgs5J4/fy7OnDkjYmJiJCsSczx48EDUrl1bKBQKYWZmJrZt26Zyf4MGDcR3330naSYqXNLT00VAQIDQ0dERCoVC6OvrCx0dHdGlSxeRmZkpeZ6uXbuKJk2aiPj4eJVf0Hv27BEeHh6S5fDx8RF79+6V7Hzv6+XLl2LTpk2iYsWKkq4H9+LFC9G/f3/h5OQk7OzsRIcOHcSxY8fEsWPHVPbW1VZS/NFft26d8PHxUdnj/Nq1a6JBgwZiw4YNIj4+XtSqVUu0bdu2QHPkZ/78+cLQ0FAoFAphZ2cnJk6cKF68eFFg58v58Jfzeyb3l4mJiVi+fHmBnf9jaUOxyAku9NGSk5NRpEgRtcsaT548QZEiRSS/VLV69ep875djLUHK340bN3D69GlkZ2fDy8sLpUqVkiWHo6Mj9uzZg4oVK6pMnIiLi4Onp6dke1XHxsaib9++6NKlC8qXL682nKNChQqS5MhLYmIiNmzYgLVr1+L06dOoWrUqjh07Jsm5R40ahUWLFqFz584wNjbGunXr4OPjg82bN0ty/o8lxWzgEiVKYOvWrWp7wEdHR6Nt27a4ceMGDh8+jLZt2yIhIaHAcuSWmJiI1atXY+XKlbh9+zZat26NoKAg3Lt3D9OnT0fRokURHh5eIOe+desWhBBwd3fH8ePHYWdnp7zPwMAA9vb2Wj22nBNc6IO9ePEC06dPR0REBB48eKA2W1LKvaE1DXi3traWLMObci8NkZGRgdTUVBgYGMDExITFohZyd3eX9RdhjhcvXigXyn3To0ePJF0v9OHDh4iNjUWPHj2UxxQKhWwTXFJSUrB161asW7cOBw4cgLu7OwICArBhwwaULFlSshzbtm3D8uXL0alTJwCvx3bWqlULWVlZWv3HXkoJCQl5LgSemZmpXFLIyclJsomQ27Ztw8qVK7Fnzx54eHhgwIAB6NKli8okk0qVKsHLy6vAMuTsP53772RhoQ19eiwWC6levXrh4MGD6Nq1K4oWLSr7AHhtkpSUpHbs2rVr6NevH0aNGiVDItKkXbt28Pb2xtixY1WO//TTTzh+/LjkPUZ169bF6tWr8cMPPwB4XaBlZ2fjp59+euflUT6Fnj17wsvLC+vXr9eKCS4ODg6wsrJChw4dEBISgqpVq8qSIz4+XmVnqGrVqkFPTw/37t2Ds7OzLJnehxQ/x/r166NPnz5YtmyZsgCLjo5Gv3790KBBAwCvVyHIPamsoPTo0QPffPMNDh06pPF94+7ujvHjxxfI+d9nsmGLFi0KJMPH2r17t6wT/gCus1hoWVpaYteuXahVq5bcUQqNkydPokuXLrh8+bLcUeh/7OzsEBkZCU9PT5Xj586dg6+vL+7fvy9pnosXL8LHxwdVqlRBZGQkWrRogQsXLuDJkyc4dOgQSpQoIUkOU1NTnDlzRtJeO02EEPjtt9/QpUuXPHtdpaSrq4vExESVy4hmZmY4e/asZMXPx5DiMnRiYiK6du2KiIgI5fCFzMxMNGzYEGvWrIGDgwP279+PjIwMNG7cuMBy5Jz3119/RZs2beDo6Fig59LkXZcpkqPHXtMWvm/OXG/ZsqVsV+lUMrFYLJzc3Nzw999/o1y5cnJHKTSio6NRr149pKSkyB2F/sfY2BgxMTFqC5ZfvnwZXl5eePnypeSZEhMTsXjxYpw6dQrZ2dmoXLkyBgwYgKJFi0qW4euvv0b37t3Rtm1byc6pSXZ2NoyMjHDhwgXZxpLm0NHRQdOmTVWGBPz5559o0KCBysLPUm3bltvbllyKj4+Hk5OTJJfML1++jKtXr0IIgbJly8q2KYCJiQkuXbqkvBRM/69+/fo4ffq0ctteIQSuXbsGXV1dlC1bFleuXIFCoUBUVBQ8PDxkzcrL0IXUDz/8gO+//x6rVq2S/dO+tsl92UEIgYSEBCxcuJA9sVqmfPny2Lhxo9raeBs2bJD8l2NOT8vSpUtV1guVw9dff41hw4bh3Llz8PT0VJvgIuXlMh0dHZQqVQqPHz+WvVjs1q2b2rEuXbrIkETV48eP0bFjR0RGRkKhUODatWtwd3dHr169YGlpiVmzZgGApJfK3d3doVAoUKJECejpyfenvnr16oiOjmaxmIecXsOVK1cqd2VKSUlBUFAQateujd69eyMgIADDhg3Dnj17ZM3KnsVCysvLC7GxsRBCwNXVVe2PyenTp2VKJr/clx0UCgXs7OzQoEEDzJo1S9IeIsrfH3/8gbZt2yIgIEA5nioiIgLr16/H5s2b0apVK0nz2NnZ4fDhw7IXRfldOpPjctmuXbswffp0LF68GOXLl5f03IVBYGAgHjx4gGXLlqFcuXLKS83h4eEYNmwYLly4IFmW1NRUDBo0CKtWrQIAXL16Fe7u7hg8eDCcnJzUxgcXtM2bN2Ps2LEYNmwYqlSporb1n5Qz+6dMmZLv/VIv6F6sWDHs3btX7YPxhQsX0LhxY9y9exenT59G48aN8ejRI0mz5caexUJK6j+ihUnOjLeHDx/CwMBAK7Yno7y1aNECO3bsQEhICLZs2QJjY2NUqFAB+/btQ7169STPExgYiOXLl2P69OmSn/tN2jZrs0uXLkhNTUXFihVhYGAAY2NjlfufPHkiUzLtEB4ejj179uCLL75QOV6qVCncunVL0izjxo3DmTNncODAAZXtV319fTFp0iTJi8WOHTsCAAYPHqw8JtfM/u3bt6vczsjIQFxcHPT09FCiRAnJi8Xk5GQ8ePBArVh8+PChcriUpaVlnrvOSI3FYiE1adIkuSNopadPn2L8+PHYuHGjcla0nZ0devTogYkTJ/KSvRby9/eHv7+/3DEAAOnp6Vi2bBn27t0Lb29vtV6Q2bNnS54pLS0NRkZGkp/3TXPnzpX1/NpOW5ZcAoAdO3Zg48aN+Oqrr1TGS3p4eCA2NlbSLMDrfc61RXR0tNqxlJQUdO/eHa1bt5Y8T8uWLdGzZ0/MmjULVatWhUKhwPHjxzFy5Ehlh9Dx48dRunRpybPlxsvQhdypU6dw6dIlKBQKeHh4FOhaVdruyZMnqFGjBu7evYvOnTujXLlyEELg0qVLWLduHcqWLYuoqCicOXMGx44dU/mkS/LSlvdxfsvjKBQKREZGSpIjKysLISEhWLJkCe7fv6+8lDhx4kS4uroiKChIkhz0bvz9/VG5cmX88MMPytnZLi4u6NSpE7Kzs7FlyxbJspiYmOD8+fNwd3dXmX195swZ1K1bF8nJyZJlKSzOnz+P5s2b4+bNm5Ke9/nz5xg2bBhWr16tXBtTT08P3bp1w5w5c2BqaoqYmBgAUFtkXXKS7hdDn8z9+/dF/fr1hUKhEFZWVsLS0lIoFArRoEED8eDBA7njyWLIkCGifPnyIjExUe2+hIQE4enpKdq1ayfMzc1FaGioDAkpN76P8zZ58mTh7u4u1q5dK4yNjZVbfW3cuFF89dVXsmS6fv26GD9+vOjUqZO4f/++EEKI3bt3i/Pnz8uSR5tcuHBB2NnZCT8/P2FgYCDatWsnypUrJxwcHFS23ZNC3bp1xfz584UQr7eJu3HjhhBCiAEDBogmTZpImiXH6tWrRc2aNUXRokXFzZs3hRBCzJkzR+zYsUOWPLn9+++/wtLSUrbzP3v2TLltr7ZuW8lisZDq0KGDqFKlirh48aLy2IULF4S3t7fo1KmTjMnk4+LiIsLCwjTev3v3bqFQKERwcLCEqSg/fB/nrUSJEmLfvn1CCNV9YS9duiTLH7UDBw4IY2Nj4evrKwwMDJR5ZsyYIesew9okISFBfP/998Lf3180bdpUjB8/Xty7d0/yHIcOHRJmZmaib9++wsjISAwZMkT4+voKU1NTcfLkScnzLFq0SNja2oqpU6eqfPBZuXKl8PHxkTTLvHnzVL7mzp0rxowZI5ycnD7r3zfvgpehCykLCwvs27dPbUX848ePo3Hjxnj69Kk8wWRkaGiI2NhYtUHmOe7cuQNXV9c8t8IieWjb+7h+/fr57rIh1WVoY2NjXL58GS4uLiqXEi9evIhq1apJtkd1jho1aqB9+/YYPny4Sp4TJ06gVatWuHv3rqR5KH/nzp3Dzz//rLJW6JgxY9QWv5eCh4cHQkJC0KpVK5X3zvnz5+Hj4yPpLN/cC7fr6OgoV8oYN24czMzMJMsCaNe2vW/DCS6FVHZ2ttpyOQCgr6+vdTMppWJra4ubN29qLBbj4uJgb28vcSrKj7a9j3OPC8rIyEBMTAzOnz+f5xp/BeXLL7/Ev//+q7Y23ebNm2UZz3nu3DmsW7dO7bidnR0eP34seR5ts3LlShQpUgTt27dXOb5582akpqZK+t4BAE9PT+XSOXKLi4vL8z1raGiIFy9eSJ5FmxSmbXtZLBZSDRo0wJAhQ7B+/Xo4OTkBAO7evYthw4ahYcOGMqeTh5+fH8aPH4+9e/fCwMBA5b5Xr15h4sSJKktJkPy07X08Z86cPI8HBwdL0pvXs2dPzJs3D5MmTULXrl1x9+5dZGdnY9u2bbhy5QpWr16Nv/76q8Bz5GZpaYmEhAS1npno6GjZ96zVBtOnT8eSJUvUjtvb2+Pbb7+VpFjU0dF5a7GhUCgkv7Li5uaGmJgYtQ8+u3fvlmzh/Z49e75TuxUrVhRwElW7d+8uNNv28jJ0IRUfH4+WLVvi/PnzcHZ2hkKhwO3bt+Hp6YmdO3dq7F37L7tz5w68vb1haGiIAQMGoGzZsgBe7/e7aNEivHr1CidOnEDx4sVlTko5Csv7+Pr166hWrVqBryeoq6uLhIQE2NvbY8+ePQgJCVG5lPj9998X+H6+eRk9ejSOHDmCzZs3o3Tp0jh9+jTu37+PwMBABAYGfvZLeRkZGeHy5ctwdXVVOX7z5k2UK1dOkm0rd+7cqfG+w4cPY8GCBRBCSL6F5sqVKzFx4kTMmjULQUFBWLZsGWJjYzFt2jQsW7YMnTp1KvAMOjo6cHFxgZeXF/IreXKvw1jQCtW2vXIOmKSPFx4eLubPny/mzZsn9u7dK3cc2d24cUP4+fkJHR0doVAohEKhEDo6OqJJkybi2rVrcscjDbT9fbx69WpRtGjRAj+PQqFQzjTWJunp6SIgIED5/0pfX1/o6OiILl26iMzMTLnjyc7Z2Vns3LlT7fiOHTtEsWLFZEj02qVLl0SrVq2Erq6uCAwMFLdu3ZIlx6+//iqKFy+u/J38xRdfiGXLlkl2/n79+gkrKytRsWJFMW/ePPH48WPJzp2fNWvWiHbt2okXL17IHeWt2LNYyERGRmLgwIE4evSoci/JHMnJyahZsyaWLFmCOnXqyJRQOyQlJeHatWsAgJIlS8La2lrmRJRbZmYmjIyMEBMTozVbyLVp00bltvjfvuInT57ExIkTC7wHTUdHB/fv34ednV2BnudD3bhxA6dPn0Z2dja8vLxk3xZRW4wePRqbNm3CypUrUbduXQDAwYMH0bNnT7Rr1w4///yzpHnu3buHSZMmYdWqVWjSpAmmTZumFf/HHj16hOzsbFnGjr969Qrbtm3DihUrcPjwYfj7+yMoKAiNGzeWbaxgYdq2l8ViIdOiRQvUr18fw4YNy/P++fPnY//+/ZJ3pxN9iBIlSmDbtm2oWLGi3FEAAD169FC5/eZsSSku/+ro6MDCwuKtf7zk3l4vKysL586dg4uLC6ysrGTNog3S09PRtWtXbN68GXp6r6cCZGdnIzAwEEuWLFEbQ11QkpOTERISggULFqBSpUqYMWPGZ99xkJdbt24hNDQUq1evRkZGBi5evIgiRYpInmPy5Mn53q9NwztYLBYyLi4uCAsL0zjG4fLly2jcuDFu374tcTKi97dy5Ups3rwZa9euZe8vXheLc+fOfet+5lLPrh06dCg8PT0RFBSErKws1KtXD4cPH4aJiQn++usv+Pj4SJpHW129ehVnzpyBsbExPD091SZ1FKSZM2dixowZcHR0REhICFq2bCnZufPj5uaW74cfOZaHuX37NkJDQxEaGor09HRcvnxZlmKxMGGxWMgYGRnh/PnzKFmyZJ73X79+HZ6enpIPYib6EF5eXrh+/ToyMjLg4uKithez1Jdh4uPjoVAolBNrjh8/jnXr1sHDwwPffvttgZ9fR0cHiYmJWrfE0xdffIEdO3bA29sbO3bsQP/+/XHgwAGsXr0a+/fvx6FDh+SO+NnT0dGBsbExfH19oaurq7Hdtm3bJEwFzJs3T+V2RkYGoqOjERYWhlGjRmHs2LGS5HjzMnRUVBSaN2+OHj16wM/PDzo6OpJkKMy4dE4hU6xYMZw7d05jsXj27FkULVpU4lREH6ZVq1ZQKBT5zlCUUkBAAL799lt07doViYmJ8PX1Rfny5bF27VokJibi+++/L9Dza+s6a48ePYKjoyMA4O+//0aHDh1QunRpBAUFYf78+TKnk19WVhZCQ0M1Lq4sxWLugYGBWvn+GTJkSJ7Hf/nlF5w8eVKSDP3798eGDRtQvHhx9OjRAxs2bICNjY0k587N2toaV69eha2tLaysrPL9mck93ORN7FksZAYNGoQDBw7gxIkTMDIyUrnv5cuXqFatGurXr89f4KTVUlNTMWrUKOzYsQMZGRlo2LAhFixYAFtbW1lzWVlZ4ejRoyhTpgzmz5+PjRs34tChQwgPD0ffvn0L/JKZtvYsuri44LfffkPDhg3h5uaGRYsWoXnz5rhw4QJq166NpKQkuSPKauDAgQgNDYW/v3+eiytrWr/zc3bjxg1UqlQJKSkpBX4uHR0dFC9eHF5eXvkWZ1L0uq5atQqdOnWCoaEhQkND880j9XCT/LBnsZCZMGECtm3bhtKlS2PgwIEoU6YMFAoFLl26hF9++QVZWVkYP3683DGJ8jVp0iSEhoaic+fOMDY2xrp169CvXz9s3rxZ1lwZGRkwNDQEAOzbtw8tWrQAAJQtWxYJCQkFfn5t3X2pR48e6NChg7IQatSoEQDg2LFjyvVMP2cbNmzApk2b0KxZM7mjFBpbtmyRbJyyNvW6vlkAdu/eXb4g74nFYiHj4OCAw4cPo1+/fhg3bpzy8p1CoUCTJk2waNEiODg4yJySKH/btm3D8uXLlQvydu7cGbVq1UJWVla+460K2pdffoklS5bA398fe/fuxQ8//ADg9VIkcl220gbBwcEoX7484uPj0b59e2VBraurK9mYM21mYGCgcWjQ5y53b54QAomJiXj48CEWLVokSYbQ0FBJzvO+Tp8+DX19feWe3Tt37sTKlSvh4eGB4OBgyWbRvwtehi7EkpKScP36dQghUKpUKS5hQYWGgYEB4uLiVLaKMzY2xtWrV+Hs7CxbrgMHDqB169ZISUlBt27dlNt/fffdd7h8+bLkkwOocJg1axZu3LiBhQsXak0PlrbIvTxMznJUPj4+n32vdNWqVTF27Fi0bdsWN27cgIeHB9q0aYMTJ07A398fc+fOlTuiEotFIpKcrq4uEhMTVRafNjMzw9mzZ9X2H5ZaVlYWUlJSVD583bx5EyYmJlo3llBKERERmDNnDi5dugSFQoGyZcti6NCh8PX1lTua7Fq3bo39+/fD2toaX375pdriyvyQQXmxsLDA6dOnUaJECcyYMQORkZHYs2cPDh06hE6dOiE+Pl7uiEq8DE1EkhNCoHv37srLmQCQlpaGvn37qiyfI8cfWV1dXbVe+tx7/n5uFi5ciGHDhqFdu3bK2a1Hjx5Fs2bNMHv2bAwcOFDmhPKytLRE69at5Y6hld5nAkvuXcn+64QQynHK+/btQ/PmzQEAzs7OePTokZzR1LBnkYgkl3unFE1WrlxZwEnUbdmyBZs2bcLt27eRnp6ucp82bb8lpWLFimHcuHFqReEvv/yCH3/8Effu3ZMpGWk7HR2dt16aF0JAoVAgKytLolTaoUGDBnB2doavry+CgoJw8eJFlCxZEgcPHkS3bt1w8+ZNuSMqsWeRiCQnRxH4LubPn4/x48ejW7du2LlzJ3r06IHY2FicOHECAwYMkDuebFJSUuDn56d2vHHjxhgzZowMibRPZmYmDhw4gNjYWAQEBMDMzAz37t2Dubn5Z707yMqVKzF27Fh0794dNWrUAAAcOXIEq1atwrRp0z7rXvu5c+eic+fO2LFjB8aPH6+cJLVlyxbUrFlT5nSq2LNIRPQ/ZcuWxaRJk/DNN9/AzMwMZ86cgbu7O77//ns8efIECxculDuiLDp37oxKlSph1KhRKsd//vlnnDp1CuvXr5cpmXa4desW/Pz8cPv2bbx69QpXr16Fu7s7hg4dirS0NCxZskTuiLJp2LAhevXqhW+++Ubl+Lp16/Drr7/iwIED8gSTWVZWFqKiouDp6am2hFBaWhp0dXXVxr7KicUiEdH/mJiY4NKlS3BxcYG9vT327t2LihUr4tq1a/jqq6/w+PFjuSNK5s2F/VNSUvDzzz+jVq1ayt6ho0eP4tChQxgxYgQmTJggV0yt0KpVK5iZmWH58uWwsbFRfsg4ePAgevXqhWvXrskdUTYmJiY4c+YMSpUqpXL86tWrqFSpElJTU2VKJj8jIyNcunRJ9kl974KXoYmI/sfR0RGPHz+Gi4sLXFxccPToUVSsWBFxcXFasyWhVHLvOmJlZYWLFy/i4sWLymOWlpZYsWLFZ18sRkVF4dChQ2rr4rm4uODu3bsypdIOzs7OWLJkCWbNmqVyfOnSpbIuk6UNPD09cePGDRaLRESFSYMGDfDnn3+icuXKCAoKwrBhw7BlyxacPHkSbdq0kTuepOLi4tSOPXr0CAqF4rNeoDwv2dnZeU7OuHPnDszMzGRIpD3mzJmDtm3bYs+ePfjqq68AvO6Vjo2NxdatW2VOJ68ff/wRI0eOxA8//IAqVaqorAQBaNfscF6GJiL6n+zsbGRnZ0NP7/Xn6E2bNiEqKgolS5ZE3759tWpHBak8ffoU48ePx8aNG5V7QFtZWaFTp06YOnUqLC0t5Q2oBTp27AgLCwv8+uuvyvVC7ezs0LJlSxQvXlxrJ3RJ5c6dO1i8eDEuXboEIQQ8PDzQt2/fz75nUUdHR/nv3LvcaNvscBaLRESUpydPnqBGjRq4e/cuOnfujHLlykEIgUuXLmHdunVwdnbG4cOHP/vdo+7evYsGDRpAV1cX165dg7e3N65duwZbW1v8888/n/Vi7qTZwYMH872/Xr16EiV5OxaLRERv+Pfff7F06VLExsZiy5YtKFasGNasWQM3NzfUrl1b7niSGjp0KCIiIrBv3z61PecTExPRuHFjNGzYUG184+fo5cuX2LBhA06dOoXs7GxUrlwZnTt3hrGxsdzRtIanpyf+/vvvz75HsTBisUhE9D9bt25F165d0blzZ6xZswYXL16Eu7s7Fi1ahL/++gt///233BEl5erqiqVLl6JJkyZ53h8WFoa+fftq1eLBUsvIyECZMmXw119/wcPDQ+44Wu3N5ajo/6Wmpua5CUCFChVkSqSOE1yIiP5n6tSpWLJkCQIDA7Fhwwbl8Zo1a2LKlCkyJpNHQkICvvzyS433ly9fHomJiRIm0j76+vp49erVW3cpIcrt4cOH6NGjB3bv3p3n/do0ZlHn7U2IiD4PV65cQd26ddWOm5ub4+nTp9IHkpmtrW2+vYZxcXGcGQ1g0KBBmDFjBjIzM+WOotXq1KnDy/JvGDp0KJKSknD06FEYGxsjLCwMq1atQqlSpfDHH3/IHU8FexaJiP6naNGiuH79utoWZFFRUZ/lpTM/Pz+MHz8ee/fuVZsJ/urVK0ycODHPbQA/N8eOHUNERATCw8Ph6emptgTKtm3bZEqmXT63YRxvExkZiZ07d6Jq1arQ0dGBi4sLGjVqBHNzc0ybNg3+/v5yR1RisUhE9D99+vTBkCFDsGLFCigUCty7dw9HjhzByJEj8f3338sdT3KTJ0+Gt7c3SpUqhQEDBqBs2bIAgIsXL2LRokV49eoV1qxZI3NK+VlaWqJt27Zyx9BaV69exYEDB/DgwQNkZ2er3Pc5/r/K8eLFC+VMeWtrazx8+BClS5eGp6cnTp8+LXM6VZzgQkT0hvHjx2POnDlIS0sDABgaGioXzv0cxcXFoX///ggPD1fuYqNQKNCoUSMsXLgQJUuWlDkhabPffvsN/fr1g62tLRwdHVXGdioUCq0riqRUtWpVTJ06FU2aNEGrVq2UPYrz58/Hli1bEBsbK3dEJRaLRES5pKam4uLFi8jOzoaHhweKFCkidyTZJSUlKfc4LlmyJKytrWVOpF0yMzNx4MABxMbGIiAgAGZmZrh37x7Mzc0/6/ePi4sL+vfvjzFjxsgdRev8/vvvyMjIQPfu3REdHY0mTZrg8ePHMDAwQGhoKDp27Ch3RCUWi0T02evZs+c7tVuxYkUBJ6HC6NatW/Dz88Pt27fx6tUrXL16Fe7u7hg6dCjS0tKwZMkSuSPKxtzcHDExMZ/lmF9NUlNTMWrUKOzYsQMZGRnw9fXF/PnzYWJigsuXL6N48eKwtbWVO6YKzoYmos9eaGgo9u/fj6dPnyIpKUnjF1FehgwZAm9vbyQlJanM9m3dujUiIiJkTCa/9u3bIzw8XO4YWmXSpEkIDQ2Fv78/vvnmG+zduxf9+vWDiYkJKleurHWFIsAJLkRE6Nu3LzZs2IAbN26gZ8+e6NKlCy+z0juLiorCoUOH1GaMu7i44O7duzKl0g4lS5bExIkTcfToUXh6ekJfX1/l/sGDB8uUTD7btm3D8uXL0alTJwBA586dUatWLWRlZUFXV1fmdHnjZWgiIrxeCmbbtm1YsWIFDh8+DH9/fwQFBaFx48ZccJnyZW1tjaioKHh4eKjsUhIVFYW2bdvi/v37ckeUjZubm8b7FAoFbty4IWEa7WBgYIC4uDgUK1ZMeczY2BhXr17V2q0QWSwSEeVy69YthIaGYvXq1cjIyMDFixc/60kKlL+OHTvCwsICv/76K8zMzHD27FnY2dmhZcuWKF68OFauXCl3RNIiurq6SExMhJ2dnfJYzvsmv+JaTrwMTUSUi0KhgEKhgBBCbV04otzmzJmD+vXrw8PDA2lpaQgICMC1a9dga2uL9evXyx1Pa7y59NLnTAiB7t27w9DQUHksLS0Nffv2VVnQXZsWc2fPIhERVC9DR0VFoXnz5ujRowf8/Pygo8O5gJS/ly9fYsOGDTh16hSys7NRuXJldO7cmdvbAVi9ejV++ukn5dJLpUuXxqhRo9C1a1eZk8mjR48e79ROm3qkWSwS0Wevf//+2LBhA4oXL44ePXqgS5cu3POY8lW5cmVERETAysoKU6ZMwciRI2FiYiJ3LK0ze/ZsTJw4EQMHDkStWrUghMChQ4fwyy+/YOrUqRg2bJjcEekdsFgkos+ejo4OihcvDi8vr3wvkWnTZSGSl7GxMa5du4YvvvgCurq6SEhIUG7dRv/Pzc0NkydPRmBgoMrxVatWITg4GHFxcTIlo/fBMYtE9NkLDAz87MdR0fupVKkSevTogdq1a0MIgZ9//lnjJKjPef/jhIQE1KxZU+14zZo1kZCQIEMi+hDsWSQiInpPV65cwaRJkxAbG4vTp0/Dw8MDenrq/S+f+/7H5cuXR0BAAL777juV41OnTsXGjRtx7tw5mZLR+2CxSERE9BF0dHSQmJjIy9B52Lp1Kzp27AhfX1/UqlULCoUCUVFRiIiIwKZNm9C6dWu5I9I7YLFIREREBebUqVOYPXs2Ll++DCEEPDw8MGLECHh5eckdjd4Ri0UiIqKPtGbNGixZsgRxcXE4cuQIXFxcMGfOHLi7u6Nly5ZyxyP6KFw8jIiI6CMsXrwYw4cPR7NmzfD06VNkZWUBAKysrDB37lx5w8lER0cHurq6+X7lNcaTtBN7FomIiD6Ch4cHQkJC0KpVK5W9oc+fPw8fHx88evRI7oiS27lzp8b7Dh8+jAULFkAIgZcvX0qYij4Uy3oiIqKPEBcXl+f4O0NDQ7x48UKGRPLL69L75cuXMW7cOPz555/o3LkzfvjhBxmS0YfgZWgiIqKP4ObmhpiYGLXju3fvRrly5aQPpGXu3buH3r17o0KFCsjMzERMTAxWrVqF4sWLyx2N3hF7FomIiD7CqFGjMGDAAKSlpUEIgePHj2P9+vUICQnB8uXL5Y4nm+TkZISEhGDBggWoVKkSIiIiUKdOHblj0QdgsUhERPQRevTogczMTIwePRqpqakICAhAsWLFsGDBgs+2OJo5cyZmzJgBR0dHrF+/njPCCzlOcCEiIvpEHj16hOzsbGRlZSEkJATLli37LCdx6OjowNjYGL6+vtDV1dXYjvutFw4cs0hERPQBnj59is6dO8POzg5OTk6YP38+rK2t8csvv6BkyZI4evQoVqxYIXdMWQQGBqJDhw6wtraGhYWFxi8qHNizSERE9AH69++PP//8Ex07dkRYWBguXbqEJk2aIC0tDZMmTUK9evXkjkj0SbBYJCIi+gAuLi5Yvnw5fH19cePGDZQsWRKDBw/+bBfipv8uFotEREQfQF9fH7du3YKTkxMAwMTEBMePH0f58uVlTkb0aXHMIhER0QfIzs6Gvr6+8rauri5MTU1lTERUMLh0DhER0QcQQqB79+4wNDQEAKSlpaFv375qBSNn/FJhx2KRiIjoA3Tr1k3ldpcu/9euHRMBAIAwEDOKfx0o+JFjSRR0/KHztARu+SwCAJB8FgEASGIRAIAkFgEASGIRAIAkFgEASGIRAIAkFgEASAvEhnEJCi8EPAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the entities\n",
+    "x = np.arange(15)  # the label locations\n",
+    "width = 0.25  # the width of the bars\n",
+    "multiplier = 0\n",
+    "\n",
+    "fig, ax = plt.subplots(layout='constrained')\n",
+    "\n",
+    "for l in ['inc', 'exc']:\n",
+    "    offset = width * multiplier\n",
+    "    v = entities_df[l][:15]\n",
+    "    rects = ax.bar(x + offset, v, width, label=l)\n",
+    "    multiplier += 1\n",
+    "\n",
+    "ax.set_ylabel('N_entities')\n",
+    "ax.set_title('Number of entities per inclusion/exclusion criteria')\n",
+    "ax.set_xticks(x + width, entities_df.index[:15])\n",
+    "ax.legend(loc='upper right', ncols=2)\n",
+    "\n",
+    "plt.xticks(rotation=90)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "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>inc</th>\n",
+       "      <th>exc</th>\n",
+       "      <th>total</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Has_value</th>\n",
+       "      <td>2220</td>\n",
+       "      <td>1423</td>\n",
+       "      <td>3643</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_temporal</th>\n",
+       "      <td>931</td>\n",
+       "      <td>2161</td>\n",
+       "      <td>3092</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_qualifier</th>\n",
+       "      <td>999</td>\n",
+       "      <td>2041</td>\n",
+       "      <td>3040</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>AND</th>\n",
+       "      <td>1010</td>\n",
+       "      <td>1656</td>\n",
+       "      <td>2666</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Subsumes</th>\n",
+       "      <td>624</td>\n",
+       "      <td>1251</td>\n",
+       "      <td>1875</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_scope</th>\n",
+       "      <td>546</td>\n",
+       "      <td>967</td>\n",
+       "      <td>1513</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_negation</th>\n",
+       "      <td>354</td>\n",
+       "      <td>475</td>\n",
+       "      <td>829</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_index</th>\n",
+       "      <td>328</td>\n",
+       "      <td>501</td>\n",
+       "      <td>829</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_multiplier</th>\n",
+       "      <td>334</td>\n",
+       "      <td>268</td>\n",
+       "      <td>602</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>multi</th>\n",
+       "      <td>191</td>\n",
+       "      <td>311</td>\n",
+       "      <td>502</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_mood</th>\n",
+       "      <td>220</td>\n",
+       "      <td>270</td>\n",
+       "      <td>490</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Has_context</th>\n",
+       "      <td>80</td>\n",
+       "      <td>100</td>\n",
+       "      <td>180</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>causal</th>\n",
+       "      <td>14</td>\n",
+       "      <td>22</td>\n",
+       "      <td>36</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>OR</th>\n",
+       "      <td>6</td>\n",
+       "      <td>1</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 inc   exc  total\n",
+       "Has_value       2220  1423   3643\n",
+       "Has_temporal     931  2161   3092\n",
+       "Has_qualifier    999  2041   3040\n",
+       "AND             1010  1656   2666\n",
+       "Subsumes         624  1251   1875\n",
+       "Has_scope        546   967   1513\n",
+       "Has_negation     354   475    829\n",
+       "Has_index        328   501    829\n",
+       "Has_multiplier   334   268    602\n",
+       "multi            191   311    502\n",
+       "Has_mood         220   270    490\n",
+       "Has_context       80   100    180\n",
+       "causal            14    22     36\n",
+       "OR                 6     1      7"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# now analyze the relations\n",
+    "relations_df = pd.DataFrame.from_dict(dict_all_crit['relation'], orient='index')\n",
+    "relations_df['total'] = relations_df['inc'] + relations_df['exc']\n",
+    "relations_df.sort_values(by=['total'], ascending=False, inplace=True)\n",
+    "relations_df.head(15)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the relations\n",
+    "x = np.arange(len(relations_df.index))\n",
+    "width = 0.25  # the width of the bars\n",
+    "multiplier = 0\n",
+    "\n",
+    "fig, ax = plt.subplots(layout='constrained')\n",
+    "\n",
+    "for l in ['inc', 'exc']:\n",
+    "    offset = width * multiplier\n",
+    "    v = relations_df[l]\n",
+    "    rects = ax.bar(x + offset, v, width, label=l)\n",
+    "    multiplier += 1\n",
+    "\n",
+    "ax.set_ylabel('N_relations')\n",
+    "ax.set_title('Number of relations per inclusion/exclusion criteria')\n",
+    "ax.set_xticks(x + width, relations_df.index)\n",
+    "ax.legend(loc='upper right', ncols=2)\n",
+    "\n",
+    "plt.xticks(rotation=90)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dataset Analysis without considering overlapping erntities\n",
+    "\n",
+    "Until now we have considered all annotated entities, considering all overlapping cases. Now, taking into account that in the paper we are using as baseline, they do not consider overlapping entities, we are going to remover all those cases. Furthermore, we are going to focus on the more represented entities, as they do in the paper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "selected_entities = ['Condition', 'Value', 'Drug', 'Procedure', 'Measurement', 'Temporal', \\\n",
+    "    'Observation', 'Person', 'Mood', 'Device', 'Pregnancy_considerations']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# read individual trials to be able to split the data into train, dev and test\n",
+    "files = os.listdir(data_path)\n",
+    "individual_trials = set([f.split('.')[0].split('_')[0] for f in files if f.endswith('.ann')])\n",
+    "print(len(individual_trials)) # 1000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# paths to BART chia data splited into train, val and test\n",
+    "train_path = '../data/chia_bart/train/'\n",
+    "val_path = '../data/chia_bart/val/'\n",
+    "test_path = '../data/chia_bart/test/'\n",
+    "\n",
+    "# paths to BIO chia data splited into train, val and test\n",
+    "train_path_bio = '../data/chia_bio/train/'\n",
+    "val_path_bio = '../data/chia_bio/val/'\n",
+    "test_path_bio = '../data/chia_bio/test/'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "800 100 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "# split the data into train, val and test\n",
+    "train_trials, val_trials = train_test_split(list(individual_trials), test_size=0.2, random_state=13, shuffle=True)\n",
+    "val_trials, test_trials = train_test_split(val_trials, test_size=0.5, random_state=13, shuffle=True)\n",
+    "print(len(train_trials), len(val_trials), len(test_trials)) # 800, 100, 100\n",
+    "chia_datasets = {\"train\":train_trials, \"val\":val_trials, \"test\":test_trials}\n",
+    "json.dump(chia_datasets, open(\"../data/chia_datasets.json\", \"w+\", encoding=\"utf-8\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def filter_valid_entities(entities, selected_entities):\n",
+    "    \"\"\"\n",
+    "    This function recive a list of tuples of entities in the format (entity, startIndex, endIndex)\n",
+    "    and returns a list with valid entities\n",
+    "    - valid entities are entities that are not overlapping with other entities and \n",
+    "    are among the selected entities\n",
+    "    :params \n",
+    "        entities: list of tuples of entities in the format (entity, startIndex, endIndex)\n",
+    "        selected_entities: list of entities that are selected for the task\n",
+    "    :return: list of selected entities\n",
+    "    \"\"\"\n",
+    "\n",
+    "    entities_conflict = {key: {key_: 0 for key_ in selected_entities} for key in selected_entities}\n",
+    "    current_entities = []\n",
+    "    entities.sort(key = lambda x: (x[1], x[2])) # sort the entities by the start index\n",
+    "    last_index_valid = 0\n",
+    "    last_valid = None\n",
+    "    for i in range(len(entities)):\n",
+    "        if last_valid is None and entities[i][0] in selected_entities:\n",
+    "            last_valid = entities[i]\n",
+    "            current_entities.append(entities[i])\n",
+    "            last_index_valid = i\n",
+    "            continue\n",
+    "        if entities[i][0] not in selected_entities:\n",
+    "            continue\n",
+    "        if entities[i][1] < last_valid[2]:\n",
+    "            entities_conflict[entities[i][0]][last_valid[0]] += 1\n",
+    "            entities_conflict[last_valid[0]][entities[i][0]] += 1\n",
+    "            if entities[i][2] - entities[i][1] > last_valid[2] - last_valid[1]:\n",
+    "                last_valid = entities[i]\n",
+    "                current_entities[-1] = entities[i]\n",
+    "                last_index_valid = i\n",
+    "        elif entities[i][1] == last_valid[2]:\n",
+    "            entities_conflict[entities[i][0]][last_valid[0]] += 1\n",
+    "            entities_conflict[last_valid[0]][entities[i][0]] += 1\n",
+    "            new_entity = (last_valid[0], last_valid[1], entities[i][2])\n",
+    "            current_entities[-1] = new_entity\n",
+    "            last_valid = new_entity\n",
+    "            last_index_valid = i\n",
+    "        else:\n",
+    "            last_valid = entities[i]\n",
+    "            current_entities.append(entities[i])\n",
+    "            last_index_valid = i\n",
+    "\n",
+    "            \n",
+    "           \n",
+    "    return current_entities, entities_conflict\n",
+    "\n",
+    "def save_selected_entities(trials_names, selected_entities, data_path, save_path):\n",
+    "    \"\"\"\n",
+    "    This function receives a list of trials names, a list of selected entities and the path to the data\n",
+    "    and saves the data with only the selected entities in the save path\n",
+    "    :params\n",
+    "        trials_names: list of trials names\n",
+    "        selected_entities: list of selected entities\n",
+    "        data_path: path to the data\n",
+    "        save_path: path to save the data\n",
+    "    \"\"\"\n",
+    "    dict_selected_entities = {ent: 0 for ent in selected_entities}\n",
+    "    entities_conflicts = {key: {key_ : 0 for key_ in selected_entities} for key in selected_entities}\n",
+    "    for trial in trials_names:\n",
+    "        for crit in {'inc', 'exc'}:\n",
+    "            with open(os.path.join(data_path, trial + '_' + crit + '.ann'), 'r', encoding='utf-8') as f:\n",
+    "                lines = f.readlines()\n",
+    "            with open(os.path.join(data_path, trial + '_' + crit + '.txt'), 'r', encoding='utf-8') as f:\n",
+    "                text = f.readlines()\n",
+    "                if trial in ['NCT02348918_exc', 'NCT02348918_inc', 'NCT01735955_exc']:\n",
+    "                    text = ' '.join([i.strip() for i in text])\n",
+    "                else:\n",
+    "                    text = '  '.join([i.strip() for i in text])\n",
+    "            entities = []\n",
+    "            complete_entities = []\n",
+    "            # print(trial + '_' + crit)\n",
+    "\n",
+    "            for line in lines:\n",
+    "                if line.startswith('T'):\n",
+    "                    term = line.strip().split('\\t')[1].split()\n",
+    "                    entity = term[0]\n",
+    "                    start = int(term[1])\n",
+    "                    if not term[2].isdigit():\n",
+    "                        continue\n",
+    "                    end = int(term[2])\n",
+    "                    if end <= start:\n",
+    "                        continue\n",
+    "                    entities.append((entity, start, end))\n",
+    "            current_entities, conflicts = filter_valid_entities(entities, selected_entities)\n",
+    "            for key, value in conflicts.items():\n",
+    "                for key_, value_ in value.items():\n",
+    "                    entities_conflicts[key][key_] += value_\n",
+    "            for ent in current_entities:\n",
+    "                dict_selected_entities[ent[0]] += 1\n",
+    "                complete_entities.append(ent[0] + ' ' + str(ent[1]) + ' ' + str(ent[2]) + '\\t' + text[ent[1]:ent[2]])\n",
+    "            with open(os.path.join(save_path, trial + '_' + crit + '.ann'), 'w+', encoding='utf-8') as f:\n",
+    "                for i in range(len(complete_entities)):\n",
+    "                    f.write('T' + str(i) + '\\t' + complete_entities[i] + '\\n')\n",
+    "            with open(os.path.join(save_path, trial + '_' + crit + '.txt'), 'w+', encoding='utf-8') as f:\n",
+    "                f.write(text)\n",
+    "    return dict_selected_entities, entities_conflicts\n",
+    "\n",
+    "# save the selected entities for train, val and test\n",
+    "dict_entites_train, conflicts_train = save_selected_entities(train_trials, selected_entities, data_path, train_path)\n",
+    "dict_entities_val , conflicts_val = save_selected_entities(val_trials, selected_entities, data_path, val_path)\n",
+    "dict_entities_test, conflicts_test = save_selected_entities(test_trials, selected_entities, data_path, test_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "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>Condition</th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Drug</th>\n",
+       "      <th>Procedure</th>\n",
+       "      <th>Measurement</th>\n",
+       "      <th>Temporal</th>\n",
+       "      <th>Observation</th>\n",
+       "      <th>Person</th>\n",
+       "      <th>Mood</th>\n",
+       "      <th>Device</th>\n",
+       "      <th>Pregnancy_considerations</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Condition</th>\n",
+       "      <td>56</td>\n",
+       "      <td>33</td>\n",
+       "      <td>35</td>\n",
+       "      <td>67</td>\n",
+       "      <td>45</td>\n",
+       "      <td>21</td>\n",
+       "      <td>6</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>17</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Value</th>\n",
+       "      <td>33</td>\n",
+       "      <td>8</td>\n",
+       "      <td>7</td>\n",
+       "      <td>1</td>\n",
+       "      <td>147</td>\n",
+       "      <td>4</td>\n",
+       "      <td>7</td>\n",
+       "      <td>77</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Drug</th>\n",
+       "      <td>35</td>\n",
+       "      <td>7</td>\n",
+       "      <td>20</td>\n",
+       "      <td>39</td>\n",
+       "      <td>1</td>\n",
+       "      <td>44</td>\n",
+       "      <td>9</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Procedure</th>\n",
+       "      <td>67</td>\n",
+       "      <td>1</td>\n",
+       "      <td>39</td>\n",
+       "      <td>14</td>\n",
+       "      <td>3</td>\n",
+       "      <td>132</td>\n",
+       "      <td>14</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>8</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Measurement</th>\n",
+       "      <td>45</td>\n",
+       "      <td>147</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "      <td>12</td>\n",
+       "      <td>3</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Temporal</th>\n",
+       "      <td>21</td>\n",
+       "      <td>4</td>\n",
+       "      <td>44</td>\n",
+       "      <td>132</td>\n",
+       "      <td>3</td>\n",
+       "      <td>26</td>\n",
+       "      <td>3</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>3</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Observation</th>\n",
+       "      <td>6</td>\n",
+       "      <td>7</td>\n",
+       "      <td>9</td>\n",
+       "      <td>14</td>\n",
+       "      <td>3</td>\n",
+       "      <td>3</td>\n",
+       "      <td>8</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Person</th>\n",
+       "      <td>1</td>\n",
+       "      <td>77</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Mood</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Device</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Pregnancy_considerations</th>\n",
+       "      <td>17</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "      <td>10</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                          Condition  Value  Drug  Procedure  Measurement  \\\n",
+       "Condition                        56     33    35         67           45   \n",
+       "Value                            33      8     7          1          147   \n",
+       "Drug                             35      7    20         39            1   \n",
+       "Procedure                        67      1    39         14            3   \n",
+       "Measurement                      45    147     1          3           12   \n",
+       "Temporal                         21      4    44        132            3   \n",
+       "Observation                       6      7     9         14            3   \n",
+       "Person                            1     77     0          0            0   \n",
+       "Mood                              1      0     0          3            0   \n",
+       "Device                            1      0     0          8            0   \n",
+       "Pregnancy_considerations         17      3     0          6            2   \n",
+       "\n",
+       "                          Temporal  Observation  Person  Mood  Device  \\\n",
+       "Condition                       21            6       1     1       1   \n",
+       "Value                            4            7      77     0       0   \n",
+       "Drug                            44            9       0     0       0   \n",
+       "Procedure                      132           14       0     3       8   \n",
+       "Measurement                      3            3       0     0       0   \n",
+       "Temporal                        26            3       1     2       3   \n",
+       "Observation                      3            8       2     2       2   \n",
+       "Person                           1            2       4     0       0   \n",
+       "Mood                             2            2       0     4       0   \n",
+       "Device                           3            2       0     0       0   \n",
+       "Pregnancy_considerations         2            1      10     1       0   \n",
+       "\n",
+       "                          Pregnancy_considerations  \n",
+       "Condition                                       17  \n",
+       "Value                                            3  \n",
+       "Drug                                             0  \n",
+       "Procedure                                        6  \n",
+       "Measurement                                      2  \n",
+       "Temporal                                         2  \n",
+       "Observation                                      1  \n",
+       "Person                                          10  \n",
+       "Mood                                             1  \n",
+       "Device                                           0  \n",
+       "Pregnancy_considerations                         0  "
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# plot a heatmap with the conflicts\n",
+    "conflicts_dict = {key: {key_: 0 for key_ in selected_entities} for key in selected_entities}\n",
+    "for conf_dic in [conflicts_train, conflicts_val, conflicts_test]:\n",
+    "    for key, value in conf_dic.items():\n",
+    "        for key_, value_ in value.items():\n",
+    "            conflicts_dict[key][key_] += value_\n",
+    "conflicts_df = pd.DataFrame.from_dict(conflicts_dict)\n",
+    "conflicts_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "conf_m = conflicts_df.to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# import confusion matrix plot\n",
+    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
+    "disp = ConfusionMatrixDisplay(confusion_matrix=conf_m, display_labels=selected_entities)\n",
+    "disp.plot(cmap=\"Blues\")\n",
+    "plt.xticks(rotation=35)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "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>train</th>\n",
+       "      <th>val</th>\n",
+       "      <th>test</th>\n",
+       "      <th>total</th>\n",
+       "      <th>conflicts_train</th>\n",
+       "      <th>conflicts_val</th>\n",
+       "      <th>conflicts_test</th>\n",
+       "      <th>rate_conflicts</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Condition</th>\n",
+       "      <td>8765</td>\n",
+       "      <td>1159</td>\n",
+       "      <td>1119</td>\n",
+       "      <td>11043</td>\n",
+       "      <td>233</td>\n",
+       "      <td>17</td>\n",
+       "      <td>33</td>\n",
+       "      <td>0.025627</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Drug</th>\n",
+       "      <td>2915</td>\n",
+       "      <td>357</td>\n",
+       "      <td>304</td>\n",
+       "      <td>3576</td>\n",
+       "      <td>136</td>\n",
+       "      <td>13</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.043345</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Value</th>\n",
+       "      <td>2910</td>\n",
+       "      <td>404</td>\n",
+       "      <td>337</td>\n",
+       "      <td>3651</td>\n",
+       "      <td>239</td>\n",
+       "      <td>20</td>\n",
+       "      <td>28</td>\n",
+       "      <td>0.078609</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Procedure</th>\n",
+       "      <td>2524</td>\n",
+       "      <td>380</td>\n",
+       "      <td>305</td>\n",
+       "      <td>3209</td>\n",
+       "      <td>249</td>\n",
+       "      <td>20</td>\n",
+       "      <td>18</td>\n",
+       "      <td>0.089436</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Measurement</th>\n",
+       "      <td>2501</td>\n",
+       "      <td>363</td>\n",
+       "      <td>273</td>\n",
+       "      <td>3137</td>\n",
+       "      <td>176</td>\n",
+       "      <td>18</td>\n",
+       "      <td>22</td>\n",
+       "      <td>0.068856</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Temporal</th>\n",
+       "      <td>2343</td>\n",
+       "      <td>344</td>\n",
+       "      <td>281</td>\n",
+       "      <td>2968</td>\n",
+       "      <td>206</td>\n",
+       "      <td>17</td>\n",
+       "      <td>18</td>\n",
+       "      <td>0.081199</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Observation</th>\n",
+       "      <td>1389</td>\n",
+       "      <td>138</td>\n",
+       "      <td>139</td>\n",
+       "      <td>1666</td>\n",
+       "      <td>41</td>\n",
+       "      <td>6</td>\n",
+       "      <td>10</td>\n",
+       "      <td>0.034214</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Person</th>\n",
+       "      <td>1262</td>\n",
+       "      <td>165</td>\n",
+       "      <td>165</td>\n",
+       "      <td>1592</td>\n",
+       "      <td>80</td>\n",
+       "      <td>8</td>\n",
+       "      <td>7</td>\n",
+       "      <td>0.059673</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Mood</th>\n",
+       "      <td>424</td>\n",
+       "      <td>70</td>\n",
+       "      <td>68</td>\n",
+       "      <td>562</td>\n",
+       "      <td>6</td>\n",
+       "      <td>5</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.023132</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Device</th>\n",
+       "      <td>278</td>\n",
+       "      <td>26</td>\n",
+       "      <td>41</td>\n",
+       "      <td>345</td>\n",
+       "      <td>11</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.040580</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Pregnancy_considerations</th>\n",
+       "      <td>151</td>\n",
+       "      <td>19</td>\n",
+       "      <td>20</td>\n",
+       "      <td>190</td>\n",
+       "      <td>29</td>\n",
+       "      <td>7</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.221053</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                          train   val  test  total  conflicts_train  \\\n",
+       "Condition                  8765  1159  1119  11043              233   \n",
+       "Drug                       2915   357   304   3576              136   \n",
+       "Value                      2910   404   337   3651              239   \n",
+       "Procedure                  2524   380   305   3209              249   \n",
+       "Measurement                2501   363   273   3137              176   \n",
+       "Temporal                   2343   344   281   2968              206   \n",
+       "Observation                1389   138   139   1666               41   \n",
+       "Person                     1262   165   165   1592               80   \n",
+       "Mood                        424    70    68    562                6   \n",
+       "Device                      278    26    41    345               11   \n",
+       "Pregnancy_considerations    151    19    20    190               29   \n",
+       "\n",
+       "                          conflicts_val  conflicts_test  rate_conflicts  \n",
+       "Condition                            17              33        0.025627  \n",
+       "Drug                                 13               6        0.043345  \n",
+       "Value                                20              28        0.078609  \n",
+       "Procedure                            20              18        0.089436  \n",
+       "Measurement                          18              22        0.068856  \n",
+       "Temporal                             17              18        0.081199  \n",
+       "Observation                           6              10        0.034214  \n",
+       "Person                                8               7        0.059673  \n",
+       "Mood                                  5               2        0.023132  \n",
+       "Device                                1               2        0.040580  \n",
+       "Pregnancy_considerations              7               6        0.221053  "
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "entities_df = pd.DataFrame(columns=['train', 'val', 'test'])\n",
+    "entities_df['train'] = dict_entites_train.values()\n",
+    "entities_df['val'] = dict_entities_val.values()\n",
+    "entities_df['test'] = dict_entities_test.values()\n",
+    "entities_df['total'] = entities_df['train'] + entities_df['val'] + entities_df['test']\n",
+    "entities_df['conflicts_train'] = [sum(conf.values()) for conf in conflicts_train.values()]\n",
+    "entities_df['conflicts_val'] = [sum(conf.values()) for conf in conflicts_val.values()]\n",
+    "entities_df['conflicts_test'] = [sum(conf.values()) for conf in conflicts_test.values()]\n",
+    "entities_df['rate_conflicts'] = (entities_df['conflicts_train'] + entities_df['conflicts_val'] + entities_df['conflicts_test']) / entities_df['total']\n",
+    "entities_df.index = dict_entites_train.keys()\n",
+    "entities_df.sort_values(by=['train'], ascending=False, inplace=True)\n",
+    "entities_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 198,
+   "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>train</th>\n",
+       "      <th>val</th>\n",
+       "      <th>test</th>\n",
+       "      <th>total</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Condition</th>\n",
+       "      <td>8927</td>\n",
+       "      <td>1057</td>\n",
+       "      <td>1098</td>\n",
+       "      <td>11082</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Value</th>\n",
+       "      <td>2990</td>\n",
+       "      <td>373</td>\n",
+       "      <td>327</td>\n",
+       "      <td>3690</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Drug</th>\n",
+       "      <td>2892</td>\n",
+       "      <td>345</td>\n",
+       "      <td>311</td>\n",
+       "      <td>3548</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Procedure</th>\n",
+       "      <td>2602</td>\n",
+       "      <td>282</td>\n",
+       "      <td>320</td>\n",
+       "      <td>3204</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Measurement</th>\n",
+       "      <td>2532</td>\n",
+       "      <td>316</td>\n",
+       "      <td>280</td>\n",
+       "      <td>3128</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Temporal</th>\n",
+       "      <td>2456</td>\n",
+       "      <td>247</td>\n",
+       "      <td>266</td>\n",
+       "      <td>2969</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Observation</th>\n",
+       "      <td>1381</td>\n",
+       "      <td>127</td>\n",
+       "      <td>180</td>\n",
+       "      <td>1688</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Person</th>\n",
+       "      <td>1239</td>\n",
+       "      <td>152</td>\n",
+       "      <td>140</td>\n",
+       "      <td>1531</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Mood</th>\n",
+       "      <td>467</td>\n",
+       "      <td>47</td>\n",
+       "      <td>49</td>\n",
+       "      <td>563</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Device</th>\n",
+       "      <td>275</td>\n",
+       "      <td>35</td>\n",
+       "      <td>41</td>\n",
+       "      <td>351</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Pregnancy_considerations</th>\n",
+       "      <td>160</td>\n",
+       "      <td>12</td>\n",
+       "      <td>18</td>\n",
+       "      <td>190</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                          train   val  test  total\n",
+       "Condition                  8927  1057  1098  11082\n",
+       "Value                      2990   373   327   3690\n",
+       "Drug                       2892   345   311   3548\n",
+       "Procedure                  2602   282   320   3204\n",
+       "Measurement                2532   316   280   3128\n",
+       "Temporal                   2456   247   266   2969\n",
+       "Observation                1381   127   180   1688\n",
+       "Person                     1239   152   140   1531\n",
+       "Mood                        467    47    49    563\n",
+       "Device                      275    35    41    351\n",
+       "Pregnancy_considerations    160    12    18    190"
+      ]
+     },
+     "execution_count": 198,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "entities_paper_df = pd.DataFrame(columns=['train', 'val', 'test'])\n",
+    "entities_paper_df['train'] = [8927, 2990,2892,2602,2532,2456,1381,1239,467,275,160]\n",
+    "entities_paper_df['val'] = [1057,373,345,282,316,247,127,152,47,35,12]\n",
+    "entities_paper_df['test'] = [1098, 327, 311, 320, 280, 266, 180, 140, 49,41, 18]\n",
+    "entities_paper_df['total'] = entities_paper_df['train'] + entities_paper_df['val'] + entities_paper_df['test']\n",
+    "entities_paper_df.index = ['Condition', 'Value', 'Drug', 'Procedure', 'Measurement', 'Temporal', \\\n",
+    "    'Observation', 'Person', 'Mood', 'Device', 'Pregnancy_considerations']\n",
+    "entities_paper_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 210,
+   "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>train</th>\n",
+       "      <th>val</th>\n",
+       "      <th>test</th>\n",
+       "      <th>total</th>\n",
+       "      <th>paper_train</th>\n",
+       "      <th>paper_val</th>\n",
+       "      <th>paper_test</th>\n",
+       "      <th>paper_total</th>\n",
+       "      <th>diff_total</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Condition</th>\n",
+       "      <td>9171</td>\n",
+       "      <td>915</td>\n",
+       "      <td>957</td>\n",
+       "      <td>11043</td>\n",
+       "      <td>8927</td>\n",
+       "      <td>1057</td>\n",
+       "      <td>1098</td>\n",
+       "      <td>11082</td>\n",
+       "      <td>-39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Value</th>\n",
+       "      <td>2975</td>\n",
+       "      <td>359</td>\n",
+       "      <td>317</td>\n",
+       "      <td>3651</td>\n",
+       "      <td>2990</td>\n",
+       "      <td>373</td>\n",
+       "      <td>327</td>\n",
+       "      <td>3690</td>\n",
+       "      <td>-39</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Drug</th>\n",
+       "      <td>2889</td>\n",
+       "      <td>332</td>\n",
+       "      <td>355</td>\n",
+       "      <td>3576</td>\n",
+       "      <td>2892</td>\n",
+       "      <td>345</td>\n",
+       "      <td>311</td>\n",
+       "      <td>3548</td>\n",
+       "      <td>28</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Procedure</th>\n",
+       "      <td>2620</td>\n",
+       "      <td>314</td>\n",
+       "      <td>275</td>\n",
+       "      <td>3209</td>\n",
+       "      <td>2602</td>\n",
+       "      <td>282</td>\n",
+       "      <td>320</td>\n",
+       "      <td>3204</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Measurement</th>\n",
+       "      <td>2545</td>\n",
+       "      <td>296</td>\n",
+       "      <td>296</td>\n",
+       "      <td>3137</td>\n",
+       "      <td>2532</td>\n",
+       "      <td>316</td>\n",
+       "      <td>280</td>\n",
+       "      <td>3128</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Temporal</th>\n",
+       "      <td>2466</td>\n",
+       "      <td>269</td>\n",
+       "      <td>233</td>\n",
+       "      <td>2968</td>\n",
+       "      <td>2456</td>\n",
+       "      <td>247</td>\n",
+       "      <td>266</td>\n",
+       "      <td>2969</td>\n",
+       "      <td>-1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Observation</th>\n",
+       "      <td>1393</td>\n",
+       "      <td>142</td>\n",
+       "      <td>131</td>\n",
+       "      <td>1666</td>\n",
+       "      <td>1381</td>\n",
+       "      <td>127</td>\n",
+       "      <td>180</td>\n",
+       "      <td>1688</td>\n",
+       "      <td>-22</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Person</th>\n",
+       "      <td>1294</td>\n",
+       "      <td>154</td>\n",
+       "      <td>144</td>\n",
+       "      <td>1592</td>\n",
+       "      <td>1239</td>\n",
+       "      <td>152</td>\n",
+       "      <td>140</td>\n",
+       "      <td>1531</td>\n",
+       "      <td>61</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Mood</th>\n",
+       "      <td>480</td>\n",
+       "      <td>45</td>\n",
+       "      <td>37</td>\n",
+       "      <td>562</td>\n",
+       "      <td>467</td>\n",
+       "      <td>47</td>\n",
+       "      <td>49</td>\n",
+       "      <td>563</td>\n",
+       "      <td>-1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Device</th>\n",
+       "      <td>280</td>\n",
+       "      <td>36</td>\n",
+       "      <td>29</td>\n",
+       "      <td>345</td>\n",
+       "      <td>275</td>\n",
+       "      <td>35</td>\n",
+       "      <td>41</td>\n",
+       "      <td>351</td>\n",
+       "      <td>-6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Pregnancy_considerations</th>\n",
+       "      <td>156</td>\n",
+       "      <td>12</td>\n",
+       "      <td>22</td>\n",
+       "      <td>190</td>\n",
+       "      <td>160</td>\n",
+       "      <td>12</td>\n",
+       "      <td>18</td>\n",
+       "      <td>190</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                          train  val  test  total  paper_train  paper_val  \\\n",
+       "Condition                  9171  915   957  11043         8927       1057   \n",
+       "Value                      2975  359   317   3651         2990        373   \n",
+       "Drug                       2889  332   355   3576         2892        345   \n",
+       "Procedure                  2620  314   275   3209         2602        282   \n",
+       "Measurement                2545  296   296   3137         2532        316   \n",
+       "Temporal                   2466  269   233   2968         2456        247   \n",
+       "Observation                1393  142   131   1666         1381        127   \n",
+       "Person                     1294  154   144   1592         1239        152   \n",
+       "Mood                        480   45    37    562          467         47   \n",
+       "Device                      280   36    29    345          275         35   \n",
+       "Pregnancy_considerations    156   12    22    190          160         12   \n",
+       "\n",
+       "                          paper_test  paper_total  diff_total  \n",
+       "Condition                       1098        11082         -39  \n",
+       "Value                            327         3690         -39  \n",
+       "Drug                             311         3548          28  \n",
+       "Procedure                        320         3204           5  \n",
+       "Measurement                      280         3128           9  \n",
+       "Temporal                         266         2969          -1  \n",
+       "Observation                      180         1688         -22  \n",
+       "Person                           140         1531          61  \n",
+       "Mood                              49          563          -1  \n",
+       "Device                            41          351          -6  \n",
+       "Pregnancy_considerations          18          190           0  "
+      ]
+     },
+     "execution_count": 210,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "entities_df['paper_train'] = entities_paper_df['train']\n",
+    "entities_df['paper_val'] = entities_paper_df['val']\n",
+    "entities_df['paper_test'] = entities_paper_df['test']\n",
+    "entities_df['paper_total'] = entities_paper_df['total']\n",
+    "entities_df['diff_total'] = entities_df['total'] - entities_df['paper_total']\n",
+    "entities_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 211,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(31939, 31944, -5)"
+      ]
+     },
+     "execution_count": 211,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# compare total amount of entities\n",
+    "sum(entities_df['total']), sum(entities_df['paper_total']), sum(entities_df['diff_total'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's check now the distribution of the number of tokens per criteria using BERT tokenizer (using data in BIO format)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/javierlopetegui/miniforge3/envs/TER/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "None of PyTorch, TensorFlow >= 2.0, or Flax have been found. Models won't be available and only tokenizers, configuration and file/data utilities can be used.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# import bert tokenizer\n",
+    "from transformers import AutoTokenizer\n",
+    "\n",
+    "bert_tokenizer = AutoTokenizer.from_pretrained(\"bert-base-uncased\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# read the data in data/chia/chia_bio\n",
+    "data_bio_path = '../data/chia/chia_bio'\n",
+    "\n",
+    "files = os.listdir(data_bio_path)\n",
+    "\n",
+    "criteria_list = []\n",
+    "\n",
+    "for f in files:\n",
+    "    if f.endswith('.txt'):\n",
+    "        with open(os.path.join(data_bio_path, f), 'r', encoding='utf-8') as file:\n",
+    "            text = file.read()\n",
+    "            text = text.split('\\n\\n')\n",
+    "            text = [t for t in text if t != '']\n",
+    "            text = [t.split('\\n') for t in text]\n",
+    "            \n",
+    "            crit_list = [' '.join([words.split()[0] for words in t if words != '']) for t in text]\n",
+    "            # for crit in crit_list:\n",
+    "            #     if len(crit.split()) == 1:\n",
+    "            #         print(f)\n",
+    "            #         break\n",
+    "            criteria_list.extend(crit_list)\n",
+    "            # tokens = tokenizer.tokenize(text)\n",
+    "            # tokens_list.append(tokens)\n",
+    "criteria_list = [c for c in criteria_list if c != '']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using a simple space split tokenizer:\n",
+      " total number of tokens: 179778\n",
+      " Mean: 14.487710532677895\n",
+      " Max: 419\n",
+      " Min: 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "space_tokenizer_count = [len(c.split()) for c in criteria_list]\n",
+    "print(f\"Using a simple space split tokenizer:\\n total number of tokens: {sum(space_tokenizer_count)}\\n Mean: {sum(space_tokenizer_count)/len(space_tokenizer_count)}\\n Max: {max(space_tokenizer_count)}\\n Min: {min(space_tokenizer_count)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGxCAYAAABMeZ2uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6DElEQVR4nO3deXhU5f3+8XuAZCaQZCCBLEAMYUfZRZZYIYGCBIgspWwFwa1sahEpKihERKJUKbYI1o1FVq2CFghbWcSyGBQFQSlakKgEMEACIQmEPL8//GW+TCZBBhJyCO/Xdc11ZZ55zjmfM+fMyT1nG5sxxggAAMCCypV2AQAAAEUhqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMu67kFl3rx5stlscjgc+v777z1ej4mJUePGja93WZKkzZs3y2az6Z///GepTN9bhw8fVvfu3RUUFCSbzaYxY8YU2XfatGlasWLFVU/rRntvrCD/Pdu8eXOJTaNWrVoaNmzYDTv+S508eVI+Pj5avnz5dZleQYcPH5bNZtO8efNuyPGXpISEBNlsNre22bNnl+i82Gw2JSQkFOs4L1y4oIYNG+qFF14o1vHeDGJiYhQTE+PWVnAZ7d+/XwkJCTp8+LDH8EOGDFGvXr2uatoVrmqoYpCTk6Onn35a77zzTmmVcMN77LHHtHPnTr399tsKCwtTeHh4kX2nTZumvn37XvWKAu+1bNlS27dv16233lrapVy15cuXKzAw8LpM68MPP5Svr6+6du16XaZ3vYWHh2v79u2qU6dOaZfitQcffNBjucyePVtVq1YtsSC7fft21axZs1jHOXv2bJ06dUqPPPJIsY73ZlVwGe3fv1/PPvusYmJiVKtWLbe+CQkJatiwoTZu3KiOHTt6NZ1SCypdu3bV4sWLNW7cODVr1qy0yigVWVlZcjgcHt9QvPXVV1+pdevWhI9SdO7cOVWsWLHQ1wIDA9W2bdvrXFHxatGixXWb1j//+U9169ZNfn5+122a15Pdbr/h1of89btmzZrFHhoKY4xRdna2/Pz8iv29ys3N1V/+8hfdf//9qlSpUrGO+2blzTKqU6eOunbtqhdeeMHroFJq56iMHz9ewcHBeuKJJy7b73K7SwvudsrfPblnzx79/ve/l9PpVFBQkMaOHavc3FwdOHBAXbt2VUBAgGrVqqXp06cXOs3s7GyNHTtWYWFh8vPzU4cOHbR7926Pfrt27dI999yjoKAgORwOtWjRQu+++65bn/xDXevWrdP999+vatWqqWLFisrJySlyno8cOaLBgwcrJCREdrtdjRo10ssvv6y8vDxJ/3dI4dtvv1VSUpJsNptsNluhu9vy36fMzEzNnz/f1ffSXXhfffWVevbsqSpVqsjhcKh58+aaP39+kfXly8jI0N13363Q0FB9+umnkqTz589r6tSpatiwoex2u6pVq6b77rtPJ06ccBu2Vq1a6tGjh9asWaOWLVvKz89PDRs21Ntvv+3W79y5cxo3bpyioqLkcDgUFBSkVq1aacmSJZetLf99X79+ve677z4FBQWpUqVKio+P1//+9z+P/hs2bFCnTp0UGBioihUr6s4779S///1vtz7569fnn3+uvn37qkqVKpf9dlzYoZ9hw4bJ399f3377rbp16yZ/f39FRETo8ccf91gncnJyNGXKFDVq1EgOh0PBwcGKjY3Vtm3bfnW+C64LhdWye/du9ejRw7WeVa9eXd27d9cPP/zg6lPYoZ9fWz+l//vcvvTSS5oxY4aioqLk7++vdu3aaceOHR51Z2RkaMOGDfrd737najPGaPbs2WrevLn8/PxUpUoV9e3b1235LV26VDabTbNmzXIb3+TJk1W+fHmtX7/e1fbjjz/qj3/8oyIiIuTr66vq1aurb9++OnbsWJHv57Bhwzy+GUqFHwp577331KZNGzmdTlWsWFG1a9fW/fff7/GeFNyWffLJJ+rUqZMCAgJUsWJFRUdHa9WqVW598pfrpk2bNHLkSFWtWlXBwcHq06ePfvrppyLrv9TOnTsVHx+v4OBgORwO1alTx+1w8eXW74LzW6tWLe3bt09btmxxbVMufZ8yMjJcn1tfX1/VqFFDY8aMUWZmpltNNptNDz/8sF577TU1atRIdrvdte0puH0/ceKERo0apVtvvVX+/v4KCQlRx44dtXXr1iua/48++kg//vijhgwZ4tZ+4sQJ13qRv8268847tWHDBlef/FMStm7dqrZt28rPz081atTQM888o4sXL7qN79lnn1WbNm0UFBSkwMBAtWzZUm+99ZYK+/3fxYsXq127dvL395e/v7+aN2+ut956y63PlWybCpOXl6epU6eqQYMG8vPzU+XKldW0aVO98sorrj75y3X37t3q06ePAgMD5XQ6NXjwYI9tdmEuXUbz5s3T73//e0lSbGysa724dH0fMmSINmzYoO++++5Xx32pUtujEhAQoKefflp/+tOfrmpX0OX069dPgwcP1vDhw7V+/XpNnz5dFy5c0IYNGzRq1CiNGzdOixcv1hNPPKG6deuqT58+bsNPmDBBLVu21Jtvvqn09HQlJCQoJiZGu3fvVu3atSVJmzZtUteuXdWmTRu99tprcjqdWrp0qfr3769z5855bNzvv/9+de/eXe+8844yMzPl4+NTaO0nTpxQdHS0zp8/r+eee061atXSypUrNW7cOH333XeaPXu265BC7969VadOHb300kuSVOShn+3bt6tjx46KjY3VM888I0mu3fkHDhxQdHS0QkJC9Le//U3BwcFauHChhg0bpmPHjmn8+PGFjvOHH35Qt27ddP78eW3fvl21a9dWXl6eevbsqa1bt2r8+PGKjo7W999/r8mTJysmJka7du1y+7b85Zdf6vHHH9eTTz6p0NBQvfnmm3rggQdUt25dtW/fXpI0duxYvfPOO5o6dapatGihzMxMffXVV0pLS7vcKuDywAMPqHPnzlq8eLFSUlL09NNPKyYmRnv27FHlypUlSQsXLtS9996rnj17av78+fLx8dE//vEP3X333Vq7dq06derkNs4+ffpowIABGjFihMeG90pcuHBB99xzjx544AE9/vjj+vjjj/Xcc8/J6XRq0qRJkn759hcXF6etW7dqzJgx6tixo3Jzc7Vjxw4dOXJE0dHRXk/3UpmZmercubOioqL06quvKjQ0VKmpqdq0aZPOnDlT5HBXsn5e6tVXX1XDhg01c+ZMSdIzzzyjbt266dChQ3I6na5+//rXv2Sz2dS9e3dX2/DhwzVv3jw9+uijevHFF3Xy5ElNmTJF0dHR+vLLLxUaGqoBAwZoy5Ytevzxx9W2bVu1atVKGzdu1NSpUzVhwgR17txZ0i8h5Y477tCFCxc0YcIENW3aVGlpaVq7dq1OnTql0NDQa3o/t2/frv79+6t///5KSEhwnYO3cePGyw63ZcsWde7cWU2bNtVbb70lu92u2bNnKz4+XkuWLFH//v3d+j/44IPq3r27a33+85//rMGDB//qdNauXav4+Hg1atRIM2bM0C233KLDhw9r3bp1Hn2vZP1evny5+vbtK6fT6Vrmdrtd0i9fLjp06KAffvjB9V7v27dPkyZN0t69e7Vhwwa30LNixQpt3bpVkyZNUlhYmEJCQgqd5smTJyX9EkLDwsJ09uxZLV++XDExMfr3v//tcf5EQatWrVJISIjHodghQ4bo888/1/PPP6/69evr9OnT+vzzzz22MampqRowYICefPJJTZkyRatWrdLUqVN16tQpt6B8+PBhDR8+XLfccoskaceOHXrkkUf0448/uj7fkjRp0iQ999xz6tOnjx5//HE5nU599dVXbuduerttutT06dOVkJCgp59+Wu3bt9eFCxf0zTff6PTp0x59e/furX79+mnEiBHat2+fnnnmGe3fv187d+4s8n9VQd27d9e0adM0YcIEvfrqq2rZsqUkuX2Zi4mJkTFGq1ev9u7wm7nO5s6daySZ5ORkk5OTY2rXrm1atWpl8vLyjDHGdOjQwdx2222u/ocOHTKSzNy5cz3GJclMnjzZ9Xzy5MlGknn55Zfd+jVv3txIMh988IGr7cKFC6ZatWqmT58+rrZNmzYZSaZly5aueowx5vDhw8bHx8c8+OCDrraGDRuaFi1amAsXLrhNq0ePHiY8PNxcvHjRbX7vvffeK3p/nnzySSPJ7Ny506195MiRxmazmQMHDrjaIiMjTffu3a9ovJUqVTJDhw71aB8wYICx2+3myJEjbu1xcXGmYsWK5vTp08aY/3tv3nvvPbN7925TvXp1c9ddd5m0tDTXMEuWLDGSzPvvv+82ruTkZCPJzJ492612h8Nhvv/+e1dbVlaWCQoKMsOHD3e1NW7c2PTq1euK5vFS+e9779693dr/85//GElm6tSpxhhjMjMzTVBQkImPj3frd/HiRdOsWTPTunVrV1v++jVp0qQrqiH/Pdu0aZOrbejQoUaSeffdd936duvWzTRo0MD1fMGCBUaSeeONNy47jcjISLflmj/fhw4dumwtu3btMpLMihUrvBr/la6f+Z/bJk2amNzcXFe/Tz/91EgyS5YscRu+V69ebstg+/bthX6WU1JSjJ+fnxk/fryrLTs727Ro0cJERUWZ/fv3m9DQUNOhQwe36d5///3Gx8fH7N+/v8h5LWxbM3ToUBMZGenRN39dyPfSSy8ZSa7Py5WOv23btiYkJMScOXPG1Zabm2saN25satas6doO5S/XUaNGuY1z+vTpRpI5evRokdM1xpg6deqYOnXqmKysrCL7XG79Lji/xhhz2223mQ4dOnj0TUxMNOXKlTPJyclu7f/85z+NJLN69WpXmyTjdDrNyZMnPcZTcPteUG5urrlw4YLp1KmTx+e8MI0aNTJdu3b1aPf39zdjxoy57LAdOnQwksyHH37o1v7QQw+ZcuXKuW3HLnXx4kVz4cIFM2XKFBMcHOxanv/73/9M+fLlzR/+8Icip+nNtqkwPXr0MM2bN79sn/zl+thjj7m1L1q0yEgyCxcudLV16NDBY3kXXEbvvfeexzavoBo1apj+/ftftq6CSvXyZF9fX02dOlW7du3yOGRyLXr06OH2vFGjRrLZbIqLi3O1VahQQXXr1i30yqNBgwa5Jf7IyEhFR0dr06ZNkqRvv/1W33zzjf7whz9I+uXbb/6jW7duOnr0qA4cOOA2zkt3aV/Oxo0bdeutt6p169Zu7cOGDZMx5le/OXlr48aN6tSpkyIiIjymd+7cOW3fvt2tfe3atbrrrrvUvn17rV+/XkFBQa7XVq5cqcqVKys+Pt7tPWnevLnCwsI8rn5p3ry561uHJDkcDtWvX99tmbRu3VpJSUl68skntXnzZmVlZXk1f/nLKF90dLQiIyNdy3Lbtm06efKkhg4d6lZzXl6eunbtquTkZI9vlVe6LItis9kUHx/v1ta0aVO3+U5KSpLD4XA7dFCc6tatqypVquiJJ57Qa6+9pv3791/RcN6un927d1f58uVdz5s2bSpJbvOamZmptWvXur2vK1eulM1m0+DBg92WS1hYmJo1a+a2Ltntdr377rtKS0tTy5YtZYzRkiVL3KablJSk2NhYNWrU6Irm01t33HGHpF/25r777rv68ccff3WYzMxM7dy5U3379pW/v7+rvXz58hoyZIh++OEHj+3IPffc4/a8sPezoP/+97/67rvv9MADD8jhcPxqXde6fq9cuVKNGzdW8+bN3Zbd3XffXehVcB07dlSVKlWuaNyvvfaaWrZsKYfDoQoVKsjHx0f//ve/9fXXX//qsD/99FOhe2tat26tefPmaerUqdqxY4cuXLhQ6PABAQEe7/+gQYOUl5enjz/+2NW2ceNG/fa3v5XT6VT58uXl4+OjSZMmKS0tTcePH5ckrV+/XhcvXtTo0aOLrPdqtk0F5+vLL7/UqFGjtHbtWmVkZBTZt+B2sl+/fqpQoYJrO1mcQkJCrujzcalSv4/KgAED1LJlS02cOLHIFcRbl/7zlH4JRBUrVvT4kPr6+io7O9tj+LCwsELb8ncF5h/THjdunHx8fNweo0aNkiT9/PPPbsNf7oqcS6WlpRXat3r16q7Xi5O301uxYoWysrI0cuRI167efMeOHdPp06fl6+vr8b6kpqZ6vCfBwcEe07Xb7W5h5G9/+5ueeOIJrVixQrGxsQoKClKvXr108ODBK5q/K12Wffv29aj5xRdflDHGtcs535Uuy6IUti7a7Xa3dfHEiROqXr26ypUrmY+o0+nUli1b1Lx5c02YMEG33XabqlevrsmTJ1/2c+jt+lJwGeevM5cu41WrVrkOh+U7duyYjDEKDQ31WC47duzwWJfq1q2ru+66S9nZ2frDH/7gUeOJEydK9GTQ9u3ba8WKFcrNzdW9996rmjVrqnHjxpc9l+rUqVMyxhT7+1lQ/rkGVzr/17p+Hzt2THv27PFYbgEBATLGXPW2ccaMGRo5cqTatGmj999/Xzt27FBycrK6du16RV9g8i9iKGjZsmUaOnSo3nzzTbVr105BQUG69957lZqa6tavsMOD+duX/OX06aefqkuXLpKkN954Q//5z3+UnJysiRMnumqQrmyZXM226VJPPfWUXnrpJe3YsUNxcXEKDg5Wp06dtGvXriLnI1+FChUUHBxc7P9vpF++kHr7hbPUzlHJZ7PZ9OKLL6pz5856/fXXPV7PX7EKnmhYEm9gvoIraH5b/kaiatWqkn5ZEQqe35KvQYMGbs+v9Aqf4OBgHT161KM9/4S5/GkXF2+n99e//lXLli1TXFycli9f7vpQ5vcNDg7WmjVrCp1WQECA1/VVqlRJzz77rJ599lkdO3bMtXclPj5e33zzza8OX9SyrFu3rqtmSfr73/9e5BnsBTdQ13q11pWoVq2aPvnkE+Xl5XkVVor6vBT85yBJTZo00dKlS2WM0Z49ezRv3jxNmTJFfn5+evLJJwsdf0msn++//77Ht+qqVavKZrNp69atHoFYkkfbm2++qVWrVql169aaNWuW+vfvrzZt2rher1atmttJwlfK4XAUeuJ7Ye9nz5491bNnT+Xk5GjHjh1KTEzUoEGDVKtWLbVr186jf5UqVVSuXLkS/7xXq1ZNkq54/q91/a5atar8/Pw8Toy/9PWrmd7ChQsVExOjOXPmuLVf7pyqgtMt7B971apVNXPmTM2cOVNHjhzRRx99pCeffFLHjx9325YVdtJ1/vYl/3/D0qVL5ePjo5UrV7qFooL3sLp0mRTcm31pXZJ326ZLVahQQWPHjtXYsWN1+vRpbdiwQRMmTNDdd9+tlJQUt6sVU1NTVaNGDdfz3NxcpaWlFfpl8lqdPHmy0BPUL6fU96hI0m9/+1t17txZU6ZM0dmzZ91eCw0NlcPh0J49e9zaP/zwwxKrZ8mSJW5naH///ffatm2b62StBg0aqF69evryyy/VqlWrQh9X809Zkjp16qT9+/fr888/d2tfsGCBbDabYmNjr2q8BfdUXDq9jRs3elw5sGDBAlWsWNHjA+JwOPTBBx+oR48euueee9yWQ48ePZSWlqaLFy8W+p4UDG/eCg0N1bBhwzRw4EAdOHBA586d+9VhFi1a5PZ827Zt+v77713L8s4771TlypW1f//+Ipelr6/vNdV9NeLi4pSdne31DbXyNwAFPy8fffRRkcPYbDY1a9ZMf/3rX1W5cmWPde9Sxb1+Zmdna/Xq1R6HG3r06CFjjH788cdCl0mTJk1cfffu3atHH31U9957r7Zu3aqmTZuqf//+OnXqlKtPXFycNm3a5HEo5dfUqlVLx48fd/sndf78ea1du7bIYex2uzp06KAXX3xRkgq9YlD6JYS3adNGH3zwgdtnMy8vTwsXLlTNmjVVv359r+otTP369VWnTh29/fbbl73a0FtFbVN69Oih7777TsHBwYUuO2//SeWz2WweAXXPnj0eh6eL0rBhw1+92uSWW27Rww8/rM6dO3us42fOnPH4HC1evFjlypVznfxvs9lUoUIFt8OOWVlZHvcL69Kli8qXL+8Rui5VnNumypUrq2/fvho9erROnjzpcVVgwe3ku+++q9zc3F89QbmgX9vDl5ubq5SUFK/vLVXqe1Tyvfjii7r99tt1/Phx3Xbbba72/OPUb7/9turUqaNmzZrp008/1eLFi0usluPHj6t379566KGHlJ6ersmTJ8vhcOipp55y9fnHP/6huLg43X333Ro2bJhq1KihkydP6uuvv9bnn3+u995776qm/dhjj2nBggXq3r27pkyZosjISK1atUqzZ8/WyJEjr3rD1aRJE23evFn/+te/FB4eroCAADVo0ECTJ0/WypUrFRsbq0mTJikoKEiLFi3SqlWrNH36dLcrM/L5+PhoyZIlevDBB9W3b18tWLBAAwcO1IABA7Ro0SJ169ZNf/rTn9S6dWv5+Pjohx9+0KZNm9SzZ0/17t3bq7rbtGmjHj16qGnTpqpSpYq+/vprvfPOO2rXrl2R9y+51K5du/Tggw/q97//vVJSUjRx4kTVqFHDdYjO399ff//73zV06FCdPHlSffv2VUhIiE6cOKEvv/xSJ06cuOzGpKQMHDhQc+fO1YgRI3TgwAHFxsYqLy9PO3fuVKNGjTRgwIBCh7vjjjvUoEEDjRs3Trm5uapSpYqWL1+uTz75xK3fypUrNXv2bPXq1Uu1a9eWMUYffPCBTp8+7bpSpjDFvX6uWbNG586d87gX0J133qk//vGPuu+++7Rr1y61b99elSpV0tGjR/XJJ5+oSZMmGjlypDIzM9WvXz9FRUVp9uzZ8vX11bvvvquWLVvqvvvuc32TnTJlipKSktS+fXtNmDBBTZo00enTp7VmzRqNHTtWDRs2LLS+/v37a9KkSRowYID+/Oc/Kzs7W3/72988LkmdNGmSfvjhB3Xq1Ek1a9bU6dOn9corr8jHx0cdOnQocv4TExPVuXNnxcbGaty4cfL19dXs2bP11VdfacmSJcW29+7VV19VfHy82rZtq8cee0y33HKLjhw5orVr13r8k7pS+Xvkli1bptq1a8vhcKhJkyYaM2aM3n//fbVv316PPfaYmjZtqry8PB05ckTr1q3T448/7ra360r16NFDzz33nCZPnqwOHTrowIEDmjJliqKiopSbm/urw8fExGjKlClu9z5KT09XbGysBg0apIYNGyogIEDJyclas2aNx97y4OBgjRw5UkeOHFH9+vW1evVqvfHGGxo5cqTrXLvu3btrxowZGjRokP74xz8qLS1NL730kkfAqlWrliZMmKDnnntOWVlZGjhwoJxOp/bv36+ff/5Zzz777DVvm+Lj49W4cWO1atVK1apV0/fff6+ZM2cqMjJS9erVc+v7wQcfqEKFCurcubPrqp9mzZqpX79+V7Rs8uXfVf71119XQECAHA6HoqKiXHtm9uzZo3Pnznn/hdurU2+LwaVX/RQ0aNAgI8ntqh9jjElPTzcPPvigCQ0NNZUqVTLx8fHm8OHDRV71c+LECbfhhw4daipVquQxvYJXGOVfGfHOO++YRx991FSrVs3Y7XZz1113mV27dnkM/+WXX5p+/fqZkJAQ4+PjY8LCwkzHjh3Na6+9dkXzW5Tvv//eDBo0yAQHBxsfHx/ToEED85e//MV1JVE+b676+eKLL8ydd95pKlasaCS5nb29d+9eEx8fb5xOp/H19TXNmjXzuMrq0qt+8uXl5ZlHH33UlCtXznV1yoULF8xLL71kmjVrZhwOh/H39zcNGzY0w4cPNwcPHvzV2gueWf7kk0+aVq1amSpVqhi73W5q165tHnvsMfPzzz9fdn7z3/d169aZIUOGmMqVKxs/Pz/TrVs3tzrybdmyxXTv3t0EBQUZHx8fU6NGDdO9e3e3+S1q/SpKUVf9FLYuFnZVRVZWlpk0aZKpV6+e8fX1NcHBwaZjx45m27Ztrj4Fr8oxxpj//ve/pkuXLiYwMNBUq1bNPPLII2bVqlVutXzzzTdm4MCBpk6dOsbPz884nU7TunVrM2/ePLdxFTb+K1k/869w+ctf/uIxr5d+bgcPHlzolSP53n77bdOmTRtTqVIl4+fnZ+rUqWPuvfde1+dx8ODBpmLFimbfvn1uw+VfffDXv/7V1ZaSkmLuv/9+ExYWZnx8fEz16tVNv379zLFjx9xqLrjur1692jRv3tz4+fmZ2rVrm1mzZnksr5UrV5q4uDhTo0YN4+vra0JCQky3bt3M1q1bPd6TguPfunWr6dixo2se27Zta/71r3+59SlqO1LYOlaU7du3m7i4OON0Oo3dbjd16tRxu9rjcut3Yevn4cOHTZcuXUxAQICR5HZ11NmzZ83TTz9tGjRoYHx9fY3T6TRNmjQxjz32mElNTXX1k2RGjx5daL0Ft+85OTlm3LhxpkaNGsbhcJiWLVuaFStWFHllVkHffvutsdlsblfcZWdnmxEjRpimTZuawMBA4+fnZxo0aGAmT55sMjMzXf3y/1ds3rzZtGrVytjtdhMeHm4mTJjgceXn22+/bRo0aODaXiUmJpq33nqr0KvxFixYYO644w7XtrJFixYe68eVbJsK8/LLL5vo6GhTtWpV4+vra2655RbzwAMPmMOHD7v65C/Xzz77zMTHxxt/f38TEBBgBg4c6PpcXPoe/NpVP8YYM3PmTBMVFWXKly/vsb4/88wzpmrVqiY7O/uytRdk+/8TA8qUefPm6b777lNycrJatWpV2uWgEOfPn1dISIiee+45bmmO6yL/isSkpCSvhouJidHPP/+sr776qoQqKx0JCQl69tlndeLEiWI//7Ggixcvqm7duho0aJCef/55r4a1zKEfADcXX1/fQm8+BZSUxMREtWjRQsnJya5LynF9LFy4UGfPntWf//xnr4e1xMm0AACUtMaNG2vu3LmFXg2IkpWXl6dFixa57gjuDQ79AAAAy2KPCgAAsCyCCgAAsCyCCgAAsCzLXfWTl5enn376SQEBAdflVuUAAODaGWN05syZYv+dMssFlZ9++qnI3z4AAADWlpKSUqw/Amq5oJL/GzkpKSkKDAws5WoAAMCVyMjIUERExFX/1l1RLBdU8g/3BAYGElQAALjBFPdpG5xMCwAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALMtyv/UDFCdjjLKzs0u7DOiXZZGTkyNJstvtxf57ILh6DoeD5QHLIqigTMvOzlZcXFxplwFYWlJSkvz8/Eq7DKBQHPoBAACWxR4VlGkOh0NJSUmlXQb0y96t3r17S5KWL18uh8NRyhUhH8sCVkZQQZlms9nYpW1BDoeD5QLginDoBwAAWBZBBQAAWBZBBQAAWJZXQWXOnDlq2rSpAgMDFRgYqHbt2rmdqDhs2DDZbDa3R9u2bYu9aAAAcHPw6mTamjVr6oUXXlDdunUlSfPnz1fPnj21e/du3XbbbZKkrl27au7cua5hfH19i7FcAABwM/EqqMTHx7s9f/755zVnzhzt2LHDFVTsdrvCwsKKr0IAAHDTuupzVC5evKilS5cqMzNT7dq1c7Vv3rxZISEhql+/vh566CEdP378suPJyclRRkaG2wMAAEC6iqCyd+9e+fv7y263a8SIEVq+fLluvfVWSVJcXJwWLVqkjRs36uWXX1ZycrI6duzo+n2PwiQmJsrpdLoeERERVz83AACgTLEZY4w3A5w/f15HjhzR6dOn9f777+vNN9/Uli1bXGHlUkePHlVkZKSWLl2qPn36FDq+nJwctyCTkZGhiIgIpaenKzAw0MvZAWBVWVlZrt9d4rdlgLInIyNDTqez2P9/e31nWl9fX9fJtK1atVJycrJeeeUV/eMf//DoGx4ersjISB08eLDI8dntdtntdm/LAAAAN4Frvo/KpT/dXlBaWppSUlIUHh5+rZMBAAA3Ia/2qEyYMEFxcXGKiIjQmTNntHTpUm3evFlr1qzR2bNnlZCQoN/97ncKDw/X4cOHNWHCBFWtWtX1Q2QAAADe8CqoHDt2TEOGDNHRo0fldDrVtGlTrVmzRp07d1ZWVpb27t2rBQsW6PTp0woPD1dsbKyWLVumgICAkqofAACUYV4FlbfeeqvI1/z8/LR27dprLggAACAfv/UDAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsi6ACAAAsy6ugMmfOHDVt2lSBgYEKDAxUu3btlJSU5HrdGKOEhARVr15dfn5+iomJ0b59+4q9aAAAcHPwKqjUrFlTL7zwgnbt2qVdu3apY8eO6tmzpyuMTJ8+XTNmzNCsWbOUnJyssLAwde7cWWfOnCmR4gEAQNnmVVCJj49Xt27dVL9+fdWvX1/PP/+8/P39tWPHDhljNHPmTE2cOFF9+vRR48aNNX/+fJ07d06LFy8uqfoBAEAZdtXnqFy8eFFLly5VZmam2rVrp0OHDik1NVVdunRx9bHb7erQoYO2bdtW5HhycnKUkZHh9gAAAJCuIqjs3btX/v7+stvtGjFihJYvX65bb71VqampkqTQ0FC3/qGhoa7XCpOYmCin0+l6REREeFsSAAAoo7wOKg0aNNAXX3yhHTt2aOTIkRo6dKj279/vet1ms7n1N8Z4tF3qqaeeUnp6uuuRkpLibUkAAKCMquDtAL6+vqpbt64kqVWrVkpOTtYrr7yiJ554QpKUmpqq8PBwV//jx4977GW5lN1ul91u97YMAABwE7jm+6gYY5STk6OoqCiFhYVp/fr1rtfOnz+vLVu2KDo6+lonAwAAbkJe7VGZMGGC4uLiFBERoTNnzmjp0qXavHmz1qxZI5vNpjFjxmjatGmqV6+e6tWrp2nTpqlixYoaNGhQSdUPAADKMK+CyrFjxzRkyBAdPXpUTqdTTZs21Zo1a9S5c2dJ0vjx45WVlaVRo0bp1KlTatOmjdatW6eAgIASKR4AAJRtNmOMKe0iLpWRkSGn06n09HQFBgaWdjkAiklWVpbi4uIkSUlJSfLz8yvligAUp5L6/81v/QAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMsiqAAAAMvyKqgkJibqjjvuUEBAgEJCQtSrVy8dOHDArc+wYcNks9ncHm3bti3WogEAwM3Bq6CyZcsWjR49Wjt27ND69euVm5urLl26KDMz061f165ddfToUddj9erVxVo0AAC4OVTwpvOaNWvcns+dO1chISH67LPP1L59e1e73W5XWFhY8VQIAABuWtd0jkp6erokKSgoyK198+bNCgkJUf369fXQQw/p+PHjRY4jJydHGRkZbg8AAADpGoKKMUZjx47Vb37zGzVu3NjVHhcXp0WLFmnjxo16+eWXlZycrI4dOyonJ6fQ8SQmJsrpdLoeERERV1sSAAAoY2zGGHM1A44ePVqrVq3SJ598opo1axbZ7+jRo4qMjNTSpUvVp08fj9dzcnLcQkxGRoYiIiKUnp6uwMDAqykNgAVlZWUpLi5OkpSUlCQ/P79SrghAccrIyJDT6Sz2/99enaOS75FHHtFHH32kjz/++LIhRZLCw8MVGRmpgwcPFvq63W6X3W6/mjIAAEAZ51VQMcbokUce0fLly7V582ZFRUX96jBpaWlKSUlReHj4VRcJAABuTl6dozJ69GgtXLhQixcvVkBAgFJTU5WamqqsrCxJ0tmzZzVu3Dht375dhw8f1ubNmxUfH6+qVauqd+/eJTIDAACg7PJqj8qcOXMkSTExMW7tc+fO1bBhw1S+fHnt3btXCxYs0OnTpxUeHq7Y2FgtW7ZMAQEBxVY0AAC4OXh96Ody/Pz8tHbt2msqCAAAIB+/9QMAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACyLoAIAACzLq6CSmJioO+64QwEBAQoJCVGvXr104MABtz7GGCUkJKh69ery8/NTTEyM9u3bV6xFAwCAm4NXQWXLli0aPXq0duzYofXr1ys3N1ddunRRZmamq8/06dM1Y8YMzZo1S8nJyQoLC1Pnzp115syZYi8eAACUbRW86bxmzRq353PnzlVISIg+++wztW/fXsYYzZw5UxMnTlSfPn0kSfPnz1doaKgWL16s4cOHF1/lAACgzLumc1TS09MlSUFBQZKkQ4cOKTU1VV26dHH1sdvt6tChg7Zt21boOHJycpSRkeH2AAAAkK4hqBhjNHbsWP3mN79R48aNJUmpqamSpNDQULe+oaGhrtcKSkxMlNPpdD0iIiKutiQAAFDGXHVQefjhh7Vnzx4tWbLE4zWbzeb23Bjj0ZbvqaeeUnp6uuuRkpJytSUBAIAyxqtzVPI98sgj+uijj/Txxx+rZs2arvawsDBJv+xZCQ8Pd7UfP37cYy9LPrvdLrvdfjVlAACAMs6rPSrGGD388MP64IMPtHHjRkVFRbm9HhUVpbCwMK1fv97Vdv78eW3ZskXR0dHFUzEAALhpeLVHZfTo0Vq8eLE+/PBDBQQEuM47cTqd8vPzk81m05gxYzRt2jTVq1dP9erV07Rp01SxYkUNGjSoRGYAAACUXV4FlTlz5kiSYmJi3Nrnzp2rYcOGSZLGjx+vrKwsjRo1SqdOnVKbNm20bt06BQQEFEvBAADg5uFVUDHG/Gofm82mhIQEJSQkXG1NAAAAkvitHwAAYGEEFQAAYFkEFQAAYFkEFQAAYFkEFQAAYFkEFQAAYFkEFQAAYFkEFQAAYFkEFQAAYFkEFQAAYFle3UIfV8YYo+zs7NIuA7CUSz8TfD6AwjkcDtlsttIuw1IIKiUgOztbcXFxpV0GYFm9e/cu7RIAS0pKSpKfn19pl2EpHPoBAACWxR6VEna2+UCZcrzNgIyR8nJ/+btcBYnd24AkyZaXK/8vlpR2GZbFf9ASZspVkMr7lHYZgEX4lnYBgOWY0i7A4jj0AwAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALMvroPLxxx8rPj5e1atXl81m04oVK9xeHzZsmGw2m9ujbdu2xVUvAAC4iXgdVDIzM9WsWTPNmjWryD5du3bV0aNHXY/Vq1dfU5EAAODmVMHbAeLi4hQXF3fZPna7XWFhYVddFAAAgFRC56hs3rxZISEhql+/vh566CEdP368yL45OTnKyMhwewAAAEglEFTi4uK0aNEibdy4US+//LKSk5PVsWNH5eTkFNo/MTFRTqfT9YiIiCjukgAAwA3K60M/v6Z///6uvxs3bqxWrVopMjJSq1atUp8+fTz6P/XUUxo7dqzreUZGBmEFAABIKoGgUlB4eLgiIyN18ODBQl+32+2y2+0lXQYAALgBlfh9VNLS0pSSkqLw8PCSnhQAAChjvN6jcvbsWX377beu54cOHdIXX3yhoKAgBQUFKSEhQb/73e8UHh6uw4cPa8KECapatap69+5drIUDAICyz+ugsmvXLsXGxrqe559fMnToUM2ZM0d79+7VggULdPr0aYWHhys2NlbLli1TQEBA8VUNAABuCl4HlZiYGBljinx97dq111QQAABAPn7rBwAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWBZBBQAAWJbXQeXjjz9WfHy8qlevLpvNphUrVri9boxRQkKCqlevLj8/P8XExGjfvn3FVS8AALiJeB1UMjMz1axZM82aNavQ16dPn64ZM2Zo1qxZSk5OVlhYmDp37qwzZ85cc7EAAODmUsHbAeLi4hQXF1foa8YYzZw5UxMnTlSfPn0kSfPnz1doaKgWL16s4cOHX1u1N6KLF0q7AgCAlfF/4rK8DiqXc+jQIaWmpqpLly6uNrvdrg4dOmjbtm2FBpWcnBzl5OS4nmdkZBRnSaUu4MulpV0CAAA3rGI9mTY1NVWSFBoa6tYeGhrqeq2gxMREOZ1O1yMiIqI4SwIAADewYt2jks9ms7k9N8Z4tOV76qmnNHbsWNfzjIyMMhVWzjQbIJX3Ke0yAABWdfECe98vo1iDSlhYmKRf9qyEh4e72o8fP+6xlyWf3W6X3W4vzjKspbwPQQUAgKtUrId+oqKiFBYWpvXr17vazp8/ry1btig6Oro4JwUAAG4CXu9ROXv2rL799lvX80OHDumLL75QUFCQbrnlFo0ZM0bTpk1TvXr1VK9ePU2bNk0VK1bUoEGDirVwAABQ9nkdVHbt2qXY2FjX8/zzS4YOHap58+Zp/PjxysrK0qhRo3Tq1Cm1adNG69atU0BAQPFVDQAAbgpeB5WYmBgZY4p83WazKSEhQQkJCddSFwAAAL/1AwAArIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALKtCaRdQ1tnycmVKuwjACoyR8nJ/+btcBclmK916AIuw5X8uUCiCSgnz/2JJaZcAAMANi0M/AADAstijUgIcDoeSkpJKuwzAUrKzs9W7d29J0vLly+VwOEq5IsB6+Fx4IqiUAJvNJj8/v9IuA7Ash8PBZwTAFeHQDwAAsCyCCgAAsCyCCgAAsKxiDyoJCQmy2Wxuj7CwsOKeDAAAuAmUyMm0t912mzZs2OB6Xr58+ZKYDAAAKONKJKhUqFCBvSgAAOCalcg5KgcPHlT16tUVFRWlAQMG6H//+1+RfXNycpSRkeH2AAAAkEogqLRp00YLFizQ2rVr9cYbbyg1NVXR0dFKS0srtH9iYqKcTqfrERERUdwlAQCAG5TNGFOiv5mXmZmpOnXqaPz48Ro7dqzH6zk5OcrJyXE9z8jIUEREhNLT0xUYGFiSpQG4jrKyshQXFydJSkpK4oZvQBmTkZEhp9NZ7P+/S/zOtJUqVVKTJk108ODBQl+32+2y2+0lXQYAALgBlfh9VHJycvT1118rPDy8pCcFAADKmGIPKuPGjdOWLVt06NAh7dy5U3379lVGRoaGDh1a3JMCAABlXLEf+vnhhx80cOBA/fzzz6pWrZratm2rHTt2KDIysrgnBQAAyrhiDypLly4t7lECAICbFL/1AwAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALIugAgAALKtCaRcAlCRjjLKzs0u7DEhuy4FlYi0Oh0M2m620ywAKRVBBmZadna24uLjSLgMF9O7du7RLwCWSkpLk5+dX2mUAheLQDwAAsCz2qKBMczgcSkpKKu0yoF8Ow+Xk5EiS7HY7hxosxOFwlHYJQJEIKijTbDYbu7QtpGLFiqVdAoAbDId+AACAZRFUAACAZRFUAACAZZVYUJk9e7aioqLkcDh0++23a+vWrSU1KQAAUEaVSFBZtmyZxowZo4kTJ2r37t266667FBcXpyNHjpTE5AAAQBllM8aY4h5pmzZt1LJlS82ZM8fV1qhRI/Xq1UuJiYmXHTYjI0NOp1Pp6ekKDAws7tIAAEAJKKn/38W+R+X8+fP67LPP1KVLF7f2Ll26aNu2bR79c3JylJGR4fYAAACQSiCo/Pzzz7p48aJCQ0Pd2kNDQ5WamurRPzExUU6n0/WIiIgo7pIAAMANqsROpi1410ljTKF3onzqqaeUnp7ueqSkpJRUSQAA4AZT7HemrVq1qsqXL++x9+T48eMee1mkX26lbbfbi7sMAABQBhT7HhVfX1/dfvvtWr9+vVv7+vXrFR0dXdyTAwAAZViJ/NbP2LFjNWTIELVq1Urt2rXT66+/riNHjmjEiBElMTkAAFBGlUhQ6d+/v9LS0jRlyhQdPXpUjRs31urVqxUZGVkSkwMAAGVUidxH5Vqkp6ercuXKSklJ4T4qAADcIDIyMhQREaHTp0/L6XQW23hLZI/KtThz5owkcZkyAAA3oDNnzhRrULHcHpW8vDz99NNPCggIKPRyZgA3rvxvXOwxBcoeY4zOnDmj6tWrq1y54rtWx3JBBUDZxU9kAPBWid3wDQAA4FoRVAAAgGURVABcN3a7XZMnT+Zu1ACuGOeoAAAAy2KPCgAAsCyCCgAAsCyCCgAAsCyCCgAAsCyCCgAAsCyCCoDrZvbs2YqKipLD4dDtt9+urVu3lnZJACyOoALguli2bJnGjBmjiRMnavfu3brrrrsUFxenI0eOlHZpACyM+6gAuC7atGmjli1bas6cOa62Ro0aqVevXkpMTCzFygBYGXtUAJS48+fP67PPPlOXLl3c2rt06aJt27aVUlUAbgQEFQAl7ueff9bFixcVGhrq1h4aGqrU1NRSqgrAjYCgAuC6sdlsbs+NMR5tAHApggqAEle1alWVL1/eY+/J8ePHPfayAMClCCoASpyvr69uv/12rV+/3q19/fr1io6OLqWqANwIKpR2AQBuDmPHjtWQIUPUqlUrtWvXTq+//rqOHDmiESNGlHZpACyMoALguujfv7/S0tI0ZcoUHT16VI0bN9bq1asVGRlZ2qUBsDDuowIAACyLc1QAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBlEVQAAIBl/T8V3zInvtL4IAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# boxplot of the number of tokens\n",
+    "sns.boxplot(space_tokenizer_count, showfliers=False)\n",
+    "plt.title('Number of tokens per inclusion/exclusion criteria (space split)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using BERT tokenizer:\n",
+      " total number of tokens: 231298\n",
+      " Mean: 18.639535820775244\n",
+      " Max: 505\n",
+      " Min: 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "bert_tokenizer_count = [len(bert_tokenizer.tokenize(c)) for c in criteria_list]\n",
+    "print(f\"Using BERT tokenizer:\\n total number of tokens: {sum(bert_tokenizer_count)}\\n Mean: {sum(bert_tokenizer_count)/len(bert_tokenizer_count)}\\n Max: {max(bert_tokenizer_count)}\\n Min: {min(bert_tokenizer_count)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.boxplot(bert_tokenizer_count, showfliers=False)\n",
+    "plt.title('Number of tokens per inclusion/exclusion criteria (BERT tokenizer)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(space_tokenizer_count, bins=50, label='Space tokenizer')\n",
+    "plt.hist(bert_tokenizer_count, bins=50, label='Bert tokenizer')\n",
+    "plt.xlabel('Number of tokens')\n",
+    "plt.ylabel('Number of criteria')\n",
+    "plt.title('Number of tokens per criteria histogram')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(space_tokenizer_count, bins=50, label = 'Space_Tokenizer')\n",
+    "plt.hist(bert_tokenizer_count, bins=50 , label = 'BERT_Tokenizer')\n",
+    "plt.xlabel('Number of tokens')\n",
+    "plt.ylabel('Number of criteria')\n",
+    "plt.title('Number of tokens per criteria histogram')\n",
+    "plt.xlim(0, 100)\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analysis the distribution of number of tokens per type of entity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[4, 4, 2, 2, 6, 5, 8, 8, 4, 4, 3, 3, 6, 3, 3, 8, 2, 3, 2, 3, 2, 6, 8, 4, 4, 3, 2, 4, 1, 3, 2, 11, 5, 7, 6, 3, 5, 3, 2, 2, 3, 3, 4, 5, 7, 6, 6, 4, 10, 5, 2, 5, 4, 7, 5, 1, 2, 3, 5, 2, 4, 2, 1, 1, 1, 2, 5, 3, 2, 2, 5, 8, 2, 4, 4, 5, 2, 3, 3, 2, 4, 3, 3, 8, 4, 5, 5, 5, 2, 4, 3, 3, 3, 4, 10, 2, 5, 3, 4, 5, 2, 1, 10, 4, 7, 4, 4, 4, 8, 11, 4, 4, 4, 5, 10, 7, 2, 8, 8, 6, 3, 2, 5, 5, 5, 8, 6, 3, 1, 5, 3, 4, 31, 3, 8, 12, 4, 2, 2, 5, 1, 2, 2, 7, 3, 3, 3, 2, 5, 3, 1, 3, 3, 2, 4, 2, 1, 2, 1, 7, 6, 4, 1, 3, 2, 4, 3, 2, 2, 1, 4, 4, 2, 3, 4, 10, 4, 3, 2, 4, 6, 3, 4, 5, 2, 3, 3, 1, 5, 6, 3, 4, 4, 2, 4, 7, 3, 2, 4, 4, 5, 5, 4, 2, 2, 5, 2, 2, 2, 2, 2, 3, 8, 4, 3, 4, 5, 16, 12, 2, 3, 17, 2, 7, 2, 6, 3, 20, 3, 9, 6, 5, 6, 11, 4, 4, 5, 5, 1, 2, 2, 3, 3, 4, 2, 9, 2, 1, 4, 6, 3, 7, 3, 2, 2, 2, 2, 1, 3, 3, 12, 4, 3, 4, 3, 7, 3, 2, 2, 3, 2, 1, 3, 3, 12, 4, 3, 4, 4, 3, 2, 3, 2, 3, 2, 3, 1, 2, 4, 2, 4, 3, 1, 2, 1, 3, 2, 2, 3, 2, 4, 2, 4, 3, 1, 2, 2, 1, 3, 1, 2, 3, 1, 1, 2, 4, 4, 3, 3, 3, 4, 2, 4, 2, 1, 4, 3, 1, 1, 4, 3, 3, 4, 4, 1, 1, 1, 2, 3, 3, 6, 2, 4, 4, 14, 15, 4, 5, 2, 3, 3, 4, 3, 4, 2, 7, 3, 8, 5, 3, 3, 5, 8, 2, 4, 5, 3, 7, 2, 2, 4, 2, 2, 2, 6, 3, 3, 1, 5, 3, 2, 1, 2, 3, 3, 9, 4, 4, 3, 5, 2, 6, 3, 3, 3, 5, 2, 3, 5, 2, 3, 2, 2, 1, 1, 2, 1, 2, 1, 5, 3, 4, 3, 3, 4, 2, 4, 7, 4, 4, 4, 4, 5, 2, 1, 1, 2, 5, 3, 3, 2, 2, 2, 4, 3, 5, 4, 6, 3, 3, 1, 2, 2, 2, 3, 4, 3, 2, 4, 1, 4, 1, 2, 2, 4, 5, 2, 3, 3, 2, 1, 4, 4, 5, 7, 1, 4, 3, 1, 6, 4, 2, 7, 4, 4, 3, 16, 6, 3, 3, 3, 4, 8, 4, 2, 3, 1, 4, 4, 8, 2, 2, 9, 2, 2, 2, 2, 2, 5, 2, 3, 3, 3, 9, 6, 8, 5, 4, 9, 4, 6, 2, 2, 3, 4, 3, 5, 2, 10, 8, 6, 7, 5, 8, 5, 5, 3, 5, 4, 1, 4, 10, 7, 4, 4, 1, 3, 8, 3, 2, 1, 4, 3, 2, 2, 2, 2, 5, 5, 5, 8, 3, 2, 8, 11, 2, 2, 4, 1, 7, 10, 5, 1, 9, 3, 1, 2, 4, 4, 1, 2, 7, 6, 5, 2, 3, 2, 3, 8, 2, 5, 7, 2, 3, 4, 6, 5, 4, 6, 2, 10, 7, 10, 4, 1, 5, 4, 10, 7, 7, 6, 4, 11, 4, 2, 5, 5, 6, 3, 3, 7, 4, 3, 3, 1, 1, 2, 5, 3, 2, 15, 6, 4, 7, 9, 4, 2, 3, 3, 1, 3, 3, 5, 2, 8, 2, 1, 6, 8, 2, 2, 3, 4, 1, 1, 1, 7, 3, 3, 3, 2, 3, 2, 1, 1, 4, 3, 2, 2, 4, 3, 4, 2, 4, 4, 2, 4, 3, 4, 2, 4, 1, 4, 8, 4, 3, 3, 2, 2, 10, 2, 1, 4, 1, 2, 5, 10, 8, 6, 5, 5, 3, 3, 3, 1, 3, 2, 2, 3, 1, 2, 1, 5, 5, 3, 3, 3, 6, 2, 5, 2, 3, 4, 3, 3, 4, 2, 1, 1, 2, 2, 2, 2, 5, 4, 3, 5, 3, 4, 2, 6, 5, 8, 2, 3, 3, 4, 3, 2, 20, 2, 7, 4, 2, 2, 2, 7, 4, 2, 2, 5, 6, 5, 5, 3, 4, 4, 9, 11, 9, 3, 5, 4, 2, 1, 3, 3, 5, 3, 2, 2, 2, 3, 1, 3, 2, 4, 3, 2, 2, 3, 2, 2, 2, 4, 2, 9, 10, 4, 2, 4, 5, 10, 4, 2, 1, 1, 5, 4, 3, 1, 3, 3, 4, 4, 3, 8, 5, 6, 3, 1, 2, 2, 3, 1, 2, 3, 2, 2, 4, 6, 4, 5, 2, 2, 7, 5, 5, 3, 4, 8, 11, 2, 3, 6, 12, 6, 5, 3, 4, 5, 18, 6, 2, 4, 1, 5, 3, 2, 4, 5, 4, 2, 3, 6, 1, 2, 9, 5, 4, 12, 6, 4, 26, 3, 3, 3, 6, 4, 4, 2, 5, 3, 3, 8, 4, 5, 6, 2, 7, 3, 5, 4, 5, 12, 5, 3, 6, 2, 4, 1, 5, 2, 2, 2, 1, 1, 5, 1, 9, 2, 9, 3, 3, 3, 7, 6, 2, 1, 4, 3, 3, 2, 3, 3, 2, 9, 3, 11, 4, 2, 3, 3, 2, 3, 5, 4, 5, 2, 3, 5, 11, 5, 6, 4, 5, 3, 3, 7, 7, 3, 7, 3, 9, 5, 3, 6, 5, 3, 2, 7, 6, 6, 2, 2, 3, 5, 6, 3, 7, 4, 1, 10, 7, 8, 2, 2, 3, 4, 2, 2, 13, 2, 2, 3, 2, 4, 5, 2, 6, 2, 5, 5, 4, 7, 4, 2, 1, 2, 4, 2, 5, 6, 3, 3, 3, 4, 4, 1, 1, 3, 3, 8, 3, 3, 11, 9, 6, 4, 3, 5, 2, 4, 3, 4, 4, 2, 3, 3, 3, 2, 2, 3, 1, 3, 3, 12, 4, 3, 2, 2, 2, 2, 3, 5, 5, 4, 2, 2, 4, 7, 2, 2, 9, 4, 3, 4, 4, 5, 4, 2, 2, 3, 3, 8, 1, 2, 2, 2, 2, 7, 3, 5, 1, 4, 5, 1, 2, 3, 3, 3, 3, 6, 2, 5, 3, 2, 3, 4, 4, 2, 3, 5, 3, 5, 4, 2, 1, 3, 4, 3, 4, 1, 7, 11, 2, 3, 2, 7, 3, 5, 3, 1, 4, 7, 9, 4, 7, 9, 4, 3, 3, 4, 1, 5, 3, 3, 1, 3, 8, 9, 5, 4, 2, 5, 4, 4, 2, 4, 2, 3, 1, 5, 1, 6, 4, 9, 2, 3, 6, 7, 3, 3, 6, 1, 1, 4, 4, 3, 3, 1, 5, 2, 3, 3, 6, 3, 1, 2, 1, 4, 1, 3, 2, 3, 11, 4, 3, 5, 1, 3, 1, 1, 1, 2, 3, 4, 2, 2, 3, 3, 3, 4, 2, 3, 3, 3, 2, 3, 4, 4, 2, 11, 1, 2, 3, 3, 3, 2, 5, 4, 10, 3, 2, 1, 4, 4, 6, 6, 5, 3, 4, 7, 4, 3, 5, 4, 2, 6, 6, 4, 2, 4, 3, 6, 4, 3, 4, 2, 5, 3, 9, 3, 5, 2, 5, 3, 4, 3, 3, 9, 7, 38, 3, 9, 2, 5, 6, 6, 3, 4, 7, 2, 2, 5, 3, 4, 3, 2, 3, 5, 3, 1, 2, 1, 2, 2, 2, 3, 3, 5, 5, 2, 3, 5, 3, 2, 4, 4, 2, 2, 6, 5, 1, 1, 2, 1, 1, 5, 3, 4, 5, 3, 1, 5, 3, 2, 5, 5, 5, 3, 8, 4, 9, 6, 3, 4, 10, 13, 3, 3, 13, 3, 2, 3, 8, 2, 6, 2, 2, 2, 5, 3, 8, 5, 3, 1, 3, 1, 7, 5, 6, 1, 3, 2, 4, 2, 1, 3, 4, 9, 1, 4, 4, 4, 4, 6, 2, 2, 1, 4, 3, 2, 6, 12, 4, 3, 3, 3, 3, 4, 11, 4, 7, 8, 4, 8, 4, 4, 3, 6, 5, 7, 5, 4, 1, 1, 8, 5, 2, 1, 6, 5, 1, 3, 1, 1, 1, 1, 8, 10, 1, 3, 4, 2, 1, 2, 3, 2, 3, 5, 5, 1, 7, 7, 8, 9, 8, 2, 5, 3, 10, 4, 4, 4, 6, 5, 1, 1, 1, 5, 1, 2, 2, 2, 3, 3, 2, 2, 4, 1, 3, 1, 2, 5, 2, 2, 2, 4, 2, 3, 3, 13, 8, 9, 5, 2, 5, 3, 4, 3, 3, 1, 1, 2, 5, 2, 1, 4, 2, 8, 3, 4, 7, 4, 4, 3, 3, 4, 6, 3, 7, 3, 6, 3, 4, 2, 3, 7, 1, 2, 2, 3, 2, 9, 3, 3, 2, 5, 4, 4, 5, 6, 2, 2, 2, 2, 14, 3, 9, 3, 5, 5, 6, 5, 3, 3, 5, 10, 4, 3, 3, 2, 2, 3, 3, 4, 5, 3, 2, 1, 12, 35, 4, 9, 3, 3, 1, 2, 1, 1, 1, 2, 1, 2, 2, 1, 4, 2, 7, 1, 2, 4, 2, 4, 2, 3, 3, 3, 4, 6, 3, 2, 4, 4, 2, 10, 2, 5, 3, 2, 12, 6, 2, 2, 3, 2, 1, 4, 5, 2, 3, 3, 4, 2, 7, 5, 2, 2, 3, 3, 1, 10, 5, 4, 2, 2, 7, 4, 6, 6, 18, 2, 2, 2, 2, 2, 2, 3, 4, 3, 3, 7, 5, 2, 3, 3, 1, 2, 2, 8, 4, 3, 2, 3, 3, 3, 2, 5, 2, 2, 4, 2, 3, 1, 2, 5, 2, 5, 3, 2, 3, 6, 3, 2, 2, 6, 2, 3, 3, 1, 4, 3, 3, 3, 2, 3, 2, 2, 2, 4, 3, 5, 2, 3, 3, 4, 3, 2, 2, 2, 3, 4, 4, 3, 1, 3, 7, 2, 2, 3, 9, 3, 3, 4, 10, 11, 3, 3, 5, 4, 17, 3, 6, 4, 3, 2, 2, 2, 5, 7, 5, 9, 5, 10, 2, 3, 9, 4, 4, 2, 27, 4, 3, 2, 7, 7, 1, 7, 7, 4, 11, 3, 5, 3, 10, 10, 1, 4, 6, 3, 5, 7, 4, 2, 1, 1, 2, 4, 2, 5, 2, 3, 2, 5, 7, 2, 3, 2, 2, 5, 3, 2, 2, 4, 1, 2, 1, 1, 5, 9, 2, 2, 1, 1, 6, 6, 13, 2, 2, 6, 2, 3, 3, 6, 4, 4, 3, 2, 4, 7, 5, 1, 2, 2, 2, 5, 5, 9, 4, 3, 11, 5, 4, 8, 2, 3, 3, 2, 2, 2, 2, 4, 2, 4, 6, 7, 6, 1, 1, 1, 1, 2, 2, 3, 3, 5, 2, 1, 2, 5, 8, 12, 2, 3, 2, 7, 6, 2, 1, 6, 4, 4, 5, 10, 52, 4, 2, 3, 4, 4, 3, 3, 3, 2, 6, 6, 6, 6, 1, 4, 2, 2, 2, 9, 15, 18, 5, 4, 11, 3, 4, 2, 2, 2, 2, 4, 10, 7, 8, 5, 9, 7, 5, 1, 4, 2, 3, 2, 7, 4, 5, 2, 6, 1, 6, 1, 1, 4, 5, 4, 3, 2, 11, 2, 2, 6, 3, 7, 4, 2, 4, 2, 5, 5, 1, 2, 5, 2, 5, 9, 3, 1, 5, 6, 4, 7, 1, 5, 6, 5, 3, 1, 7, 2, 2, 6, 4, 3, 7, 5, 2, 5, 3, 3, 3, 6, 3, 4, 3, 3, 3, 4, 5, 2, 2, 2, 1, 2, 2, 6, 2, 2, 3, 1, 4, 2, 2, 4, 12, 5, 3, 4, 3, 1, 1, 1, 7, 14, 5, 47, 3, 3, 4, 4, 13, 3, 16, 7, 10, 6, 6, 3, 4, 3, 5, 5, 3, 4, 4, 5, 2, 2, 1, 5, 1, 4, 3, 5, 6, 5, 2, 7, 4, 2, 4, 5, 9, 3, 5, 3, 4, 3, 3, 5, 6, 3, 3, 5, 5, 6, 3, 5, 4, 3, 3, 7, 4, 3, 3, 7, 1, 2, 2, 9, 5, 2, 1, 1, 1, 2, 5, 4, 4, 3, 2, 3, 3, 4, 5, 2, 9, 8, 1, 3, 1, 10, 6, 11, 4, 6, 10, 7, 4, 2, 2, 3, 4, 5, 7, 2, 6, 4, 6, 5, 4, 3, 2, 3, 4, 7, 24, 6, 5, 14, 9, 6, 3, 6, 8, 2, 3, 3, 3, 1, 2, 1, 1, 2, 4, 1, 3, 2, 2, 4, 3, 2, 1, 4, 7, 5, 1, 3, 3, 5, 6, 2, 2, 3, 4, 2, 3, 5, 4, 3, 2, 3, 3, 1, 2, 2, 3, 1, 4, 6, 5, 9, 5, 1, 2, 3, 2, 4, 3, 5, 3, 3, 3, 4, 4, 4, 5, 3, 7, 5, 5, 3, 6, 7, 3, 2, 1, 9, 7, 4, 8, 3, 2, 3, 9, 4, 3, 4, 5, 15, 2, 2, 3, 3, 4, 5, 3, 5, 8, 3, 4, 4, 3, 3, 3, 2, 4, 3, 2, 2, 2, 9, 2, 4, 4, 5, 11, 3, 2, 6, 4, 6, 6, 6, 9, 4, 9, 14, 2, 3, 2, 4, 3, 3, 2, 2, 2, 3, 2, 2, 2, 1, 2, 1, 4, 2, 1, 3, 6, 2, 5, 1, 9, 5, 3, 5, 1, 6, 2, 1, 2, 5, 5, 2, 3, 1, 2, 3, 4, 2, 8, 4, 1, 3, 1, 1, 1, 2, 1, 5, 7, 1, 1, 1, 4, 2, 8, 5, 3, 3, 3, 3, 4, 2, 1, 4, 2, 7, 7, 2, 2, 4, 3, 4, 5, 5, 4, 5, 8, 6, 5, 5, 7, 9, 6, 6, 4, 3, 4, 5, 7, 4, 1, 3, 1, 4, 2, 6, 7, 2, 2, 3, 3, 6, 2, 3, 1, 1, 5, 5, 2, 5, 3, 5, 5, 5, 2, 7, 4, 4, 5, 15, 4, 4, 12, 3, 8, 17, 3, 5, 2, 3, 1, 1, 4, 2, 20, 3, 5, 2, 3, 2, 3, 4, 2, 3, 3, 5, 4, 3, 5, 18, 3, 6, 2, 3, 4, 1, 2, 7, 2, 3, 4, 2, 4, 2, 5, 2, 6, 6, 3, 4, 6, 10, 3, 2, 1, 3, 3, 4, 4, 2, 4, 1, 3, 2, 3, 4, 3, 5, 7, 3, 1, 2, 3, 1, 6, 1, 1, 1, 1, 1, 2, 3, 3, 4, 6, 2, 2, 1, 4, 1, 2, 1, 11, 13, 8, 2, 9, 9, 4, 2, 5, 9, 9, 4, 3, 6, 2, 5, 3, 4, 4, 1, 4, 2, 6, 2, 7, 5, 2, 5, 3, 1, 3, 3, 4, 5, 4, 4, 3, 5, 5, 3, 4, 9, 4, 1, 4, 9, 5, 5, 2, 2, 5, 1, 4, 1, 4, 5, 4, 2, 2, 3, 2, 1, 2, 3, 3, 3, 2, 7, 5, 3, 5, 6, 3, 5, 9, 2, 5, 4, 4, 3, 4, 2, 8, 3, 2, 2, 1, 4, 4, 4, 2, 5, 4, 9, 2, 3, 4, 4, 3, 5, 4, 5, 4, 2, 3, 8, 15, 15, 9, 4, 5, 13, 2, 3, 5, 3, 5, 1, 1, 1, 5, 4, 4, 5, 4, 3, 2, 4, 6, 1, 4, 3, 3, 2, 2, 6, 1, 2, 3, 4, 7, 2, 1, 1, 3, 4, 4, 3, 4, 1, 2, 3, 5, 3, 3, 3, 5, 3, 1, 5, 3, 5, 3, 2, 2, 3, 4, 3, 2, 5, 2, 2, 5, 5, 2, 1, 3, 4, 1, 1, 2, 15, 3, 10, 4, 4, 1, 4, 4, 4, 3, 5, 1, 2, 4, 3, 7, 7, 14, 20, 4, 6, 5, 1, 9, 2, 5, 20, 9, 3, 4, 9, 4, 3, 3, 3, 3, 2, 3, 3, 3, 4, 2, 2, 2, 2, 6, 3, 7, 4, 2, 3, 1, 2, 8, 2, 2, 2, 2, 3, 3, 2, 6, 2, 2, 2, 2, 3, 4, 2, 2, 4, 3, 2, 2, 2, 3, 3, 2, 2, 3, 3, 3, 2, 5, 5, 6, 3, 3, 3, 7, 4, 7, 5, 4, 4, 5, 4, 8, 1, 4, 3, 2, 3, 1, 5, 1, 8, 7, 3, 4, 5, 3, 3, 12, 3, 2, 2, 7, 5, 3, 4, 7, 4, 4, 1, 1, 2, 1, 5, 4, 4, 5, 5, 5, 3, 3, 3, 11, 3, 1, 4, 5, 5, 10, 4, 2, 2, 3, 5, 5, 10, 9, 15, 4, 4, 3, 3, 3, 4, 4, 5, 1, 5, 5, 2, 6, 3, 8, 6, 7, 4, 6, 2, 5, 2, 4, 3, 3, 3, 3, 3, 3, 5, 3, 5, 4, 5, 9, 5, 6, 3, 6, 6, 14, 7, 3, 7, 9, 7, 5, 3, 7, 2, 3, 3, 8, 3, 2, 4, 6, 3, 10, 6, 5, 3, 2, 3, 5, 9, 1, 7, 2, 7, 5, 11, 9, 12, 5, 4, 4, 4, 3, 5, 5, 4, 3, 4, 2, 3, 6, 2, 3, 4, 5, 4, 4, 3, 1, 5, 6, 25, 6, 3, 4, 5, 6, 3, 1, 3, 5, 2, 4, 3, 1, 2, 9, 3, 4, 4, 2, 2, 4, 5, 8, 2, 3, 1, 2, 2, 1, 3, 4, 2, 4, 3, 4, 2, 2, 4, 3, 3, 4, 2, 1, 9, 4, 2, 1, 7, 2, 11, 5, 3, 7, 3, 12, 1, 6, 1, 4, 4, 5, 2, 3, 2, 5, 2, 1, 1, 3, 1, 9, 16, 2, 1, 3, 2, 6, 3, 8, 3, 6, 3, 4, 3, 2, 2, 3, 3, 2, 2, 2, 2, 1, 3, 3, 3, 1, 4, 3, 2, 3, 8, 6, 3, 1, 3, 4, 1, 2, 2, 5, 4, 1, 1, 1, 1, 4, 2, 2, 12, 2, 4, 2, 5, 8, 5, 2, 3, 5, 8, 8, 3, 5, 3, 4, 5, 2, 1, 2, 23, 5, 7, 2, 9, 5, 3, 2, 3, 2, 3, 2, 6, 2, 4, 2, 10, 4, 3, 2, 7, 3, 6, 11, 6, 2, 3, 3, 1, 1, 5, 3, 4, 12, 1, 4, 4, 3, 3, 3, 1, 1, 2, 6, 3, 2, 1, 1, 1, 2, 3, 8, 4, 6, 2, 2, 4, 3, 5, 4, 4, 4, 6, 5, 1, 3, 3, 7, 4, 16, 4, 2, 10, 5, 3, 5, 33, 4, 4, 8, 1, 3, 4, 6, 4, 2, 6, 2, 6, 4, 4, 2, 1, 4, 4, 3, 3, 6, 3, 2, 3, 3, 3, 4, 5, 2, 3, 4, 3, 3, 3, 3, 2, 2, 3, 2, 11, 5, 8, 4, 4, 5, 4, 4, 5, 5, 4, 7, 1, 10, 2, 7, 4, 4, 2, 4, 5, 4, 1, 2, 5, 5, 2, 4, 5, 3, 5, 2, 8, 3, 10, 2, 7, 1, 1, 2, 4, 8, 3, 3, 3, 5, 8, 1, 5, 3, 1, 2, 3, 2, 2, 1, 2, 1, 3, 10, 3, 4, 6, 6, 2, 4, 9, 7, 1, 4, 5, 3, 7, 5, 6, 2, 2, 10, 2, 2, 2, 6, 4, 2, 2, 8, 3, 8, 3, 2, 3, 3, 3, 1, 4, 3, 1, 1, 2, 4, 3, 4, 3, 1, 4, 1, 3, 5, 4, 2, 5, 5, 6, 3, 2, 7, 2, 3, 7, 7, 3, 2, 3, 1, 4, 4, 5, 5, 3, 6, 2, 3, 9, 10, 5, 5, 5, 3, 7, 3, 2, 2, 4, 11, 12, 4, 7, 4, 2, 2, 3, 9, 3, 2, 1, 3, 3, 4, 3, 2, 4, 3, 3, 2, 2, 4, 7, 13, 4, 3, 3, 5, 8, 3, 6, 8, 7, 2, 13, 2, 3, 2, 4, 2, 4, 5, 13, 4, 2, 2, 2, 5, 3, 4, 6, 3, 3, 1, 1, 2, 1, 2, 3, 2, 2, 7, 3, 5, 12, 3, 5, 3, 2, 2, 2, 8, 3, 2, 3, 3, 2, 2, 2, 4, 2, 12, 4, 4, 7, 3, 6, 1, 7, 10, 9, 5, 4, 12, 5, 6, 3, 3, 2, 19, 6, 4, 5, 4, 6, 3, 4, 4, 7, 10, 4, 4, 4, 3, 4, 3, 4, 12, 3, 3, 3, 6, 2, 9, 7, 3, 3, 3, 2, 3, 1, 3, 1, 2, 2, 3, 2, 7, 1, 3, 5, 5, 4, 1, 3, 4, 2, 1, 4, 5, 3, 4, 3, 5, 3, 3, 5, 11, 1, 6, 1, 3, 3, 3, 8, 3, 3, 7, 2, 2, 4, 3, 1, 4, 3, 4, 2, 3, 4, 3, 2, 3, 2, 2, 2, 2, 3, 3, 3, 2, 3, 2, 3, 3, 5, 3, 4, 1, 1, 2, 4, 1, 1, 2, 3, 2, 1, 1, 2, 1, 11, 4, 2, 1, 5, 2, 6, 2, 1, 2, 8, 6, 6, 8, 2, 3, 2, 14, 9, 1, 1, 5, 3, 2, 4, 3, 4, 2, 2, 3, 4, 3, 5, 5, 4, 3, 2, 3, 2, 6, 4, 6, 1, 9, 4, 3, 4, 7, 4, 2, 3, 2, 5, 3, 3, 4, 3, 3, 4, 2, 4, 4, 7, 6, 4, 8, 3, 2, 2, 1, 3, 1, 1, 2, 3, 3, 3, 3, 3, 3, 2, 1, 2, 2, 9, 3, 3, 6, 2, 5, 8, 5, 4, 2, 14, 5, 5, 5, 3, 4, 2, 3, 2, 1, 4, 9, 4, 3, 4, 2, 3, 1, 2, 3, 3, 3, 5, 2, 3, 2, 2, 1, 1, 1, 3, 2, 2, 4, 6, 9, 5, 19, 8, 5, 2, 3, 3, 6, 2, 3, 4, 2, 3, 5, 4, 1, 4, 3, 4, 4, 5, 3, 4, 4, 8, 6, 4, 2, 8, 4, 13, 6, 2, 2, 7, 4, 5, 2, 2, 7, 4, 6, 3, 2, 4, 5, 7, 6, 8, 6, 6, 5, 3, 3, 3, 6, 12, 3, 3, 3, 9, 4, 8, 1, 2, 3, 4, 3, 7, 7, 4, 5, 4, 5, 3, 4, 4, 2, 3, 2, 3, 5, 1, 1, 3, 2, 3, 2, 3, 3, 4, 5, 4, 2, 1, 3, 2, 1, 4, 3, 4, 3, 2, 3, 3, 2, 1, 3, 2, 11, 6, 4, 2, 5, 1, 1, 3, 4, 3, 2, 8, 2, 2, 2, 2, 3, 5, 2, 2, 3, 11, 6, 5, 2, 2, 3, 3, 5, 3, 3, 3, 8, 3, 5, 3, 6, 4, 2, 5, 3, 4, 5, 6, 7, 2, 6, 1, 5, 2, 10, 2, 4, 4, 5, 3, 1, 9, 17, 10, 2, 3, 1, 1, 4, 3, 4, 5, 4, 4, 4, 2, 4, 5, 4, 4, 2, 3, 2, 2, 2, 3, 3, 3, 3, 3, 7, 2, 4, 4, 10, 3, 5, 1, 1, 2, 3, 3, 3, 2, 3, 3, 4, 4, 5, 5, 4, 6, 1, 5, 4, 7, 7, 6, 4, 11, 2, 7, 7, 10, 3, 3, 4, 2, 7, 10, 1, 5, 7, 2, 3, 10, 1, 2, 2, 2, 6, 4, 21, 5, 6, 1, 2, 3, 10, 2, 4, 3, 5, 2, 2, 5, 2, 6, 3, 2, 6, 2, 1, 1, 2, 3, 4, 3, 9, 2, 2, 3, 4, 1, 4, 8, 4, 6, 3, 3, 2, 3, 5, 16, 3, 5, 2, 4, 6, 9, 8, 4, 3, 7, 2, 3, 4, 20, 6, 6, 6, 8, 5, 5, 2, 3, 9, 10, 3, 2, 2, 3, 5, 6, 12, 4, 3, 1, 3, 2, 7, 3, 4, 3, 8, 3, 2, 1, 4, 2, 4, 2, 1, 5, 7, 4, 3, 2, 2, 8, 3, 2, 4, 3, 6, 11, 15, 11, 7, 21, 3, 4, 5, 1, 1, 5, 2, 12, 3, 6, 1, 2, 1, 3, 1, 2, 4, 1, 1, 2, 3, 4, 3, 3, 1, 17, 5, 5, 4, 2, 3, 3, 13, 3, 1, 5, 3, 4, 2, 1, 4, 6, 21, 4, 7, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 2, 4, 4, 3, 2, 2, 5, 8, 3, 2, 2, 4, 10, 5, 3, 3, 2, 2, 5, 14, 3, 13, 7, 4, 4, 3, 4, 3, 11, 12, 12, 7, 5, 4, 4, 2, 6, 8, 8, 4, 7, 8, 4, 9, 7, 4, 6, 1, 2, 2, 2, 4, 5, 2, 2, 3, 2, 2, 2, 2, 3, 1, 2, 6, 8, 2, 3, 6, 7, 6, 7, 1, 9, 2, 8, 4, 2, 5, 7, 6, 2, 10, 19, 2, 3, 2, 3, 3, 2, 7, 16, 2, 1, 2, 3, 5, 5, 2, 1, 1, 3, 3, 4, 3, 1, 6, 3, 7, 4, 7, 8, 2, 4, 5, 1, 2, 5, 2, 2, 4, 3, 3, 5, 3, 4, 4, 9, 6, 5, 5, 3, 2, 2, 7, 2, 5, 5, 3, 1, 2, 3, 6, 3, 2, 4, 4, 3, 3, 2, 5, 2, 4, 1, 5, 1, 2, 7, 4, 4, 16, 2, 6, 2, 2, 5, 5, 6, 7, 9, 7, 1, 2, 3, 5, 1, 3, 3, 4, 2, 3, 2, 2, 3, 4, 6, 3, 6, 3, 5, 4, 3, 4, 1, 1, 1, 2, 6, 2, 2, 4, 1, 2, 5, 23, 5, 3, 3, 2, 1, 1, 4, 3, 3, 1, 1, 13, 2, 1, 6, 5, 8, 2, 5, 4, 5, 2, 3, 3, 2, 2, 4, 2, 5, 3, 1, 4, 2, 2, 4, 5, 4, 3, 3, 2, 3, 3, 2, 2, 2, 2, 3, 5, 2, 2, 5, 6, 5, 3, 3, 3, 3, 6, 3, 3, 3, 2, 4, 3, 1, 4, 5, 6, 2, 4, 4, 4, 3, 3, 7, 3, 6, 3, 8, 8, 5, 3, 4, 3, 4, 3, 5, 4, 3, 2, 1, 5, 3, 4, 5, 2, 5, 2, 4, 3, 6, 5, 5, 6, 4, 3, 4, 2, 3, 3, 8, 4, 4, 3, 3, 3, 5, 6, 1, 5, 5, 3, 2, 7, 7, 4, 3, 6, 4, 5, 6, 5, 2, 3, 3, 3, 1, 7, 6, 5, 5, 3, 5, 13, 7, 2, 3, 8, 1, 2, 1, 1, 2, 4, 11, 2, 5, 5, 3, 1, 2, 1, 8, 5, 2, 2, 2, 3, 4, 1, 2, 1, 2, 3, 6, 6, 6, 3, 11, 6, 6, 3, 1, 4, 5, 6, 1, 5, 2, 2, 3, 3, 1, 1, 2, 1, 4, 3, 2, 2, 3, 3, 3, 5, 3, 3, 5, 5, 2, 1, 2, 2, 8, 3, 6, 8, 7, 2, 5, 8, 2, 3, 3, 6, 3, 2, 2, 4, 2, 2, 16, 5, 3, 3, 3, 3, 3, 3, 3, 2, 3, 2, 4, 5, 6, 3, 7, 3, 4, 1, 3, 2, 2, 2, 7, 1, 2, 4, 2, 5, 2, 3, 6, 5, 4, 2, 3, 1, 16, 5, 3, 4, 5, 2, 3, 4, 6, 3, 1, 3, 6, 4, 8, 7, 3, 22, 1, 7, 2, 7, 3, 6, 11, 13, 7, 5, 7, 5, 6, 4, 8, 4, 9, 2, 7, 7, 9, 7, 4, 4, 5, 5, 3, 3, 3, 3, 7, 2, 4, 4, 9, 2, 6, 7, 7, 2, 3, 4, 2, 3, 4, 5, 5, 2, 3, 4, 4, 3, 3, 3, 3, 2, 1, 1, 3, 3, 3, 2, 1, 3, 8, 3, 7, 3, 4, 4, 2, 3, 5, 4, 7, 7, 1, 3, 3, 3, 1, 2, 2, 6, 4, 1, 4, 1, 2, 4, 2, 3, 3, 4, 2, 3, 2, 2, 2, 4, 2, 3, 5, 3, 3, 3, 6, 7, 3, 2, 2, 7, 2, 4, 1, 3, 4, 2, 3, 3, 2, 5, 4, 2, 3, 5, 3, 6, 6, 1, 1, 2, 4, 5, 6, 1, 4, 2, 1, 2, 3, 3, 4, 1, 4, 10, 4, 2, 1, 6, 4, 4, 4, 1, 1, 2, 3, 3, 4, 1, 2, 4, 2, 2, 6, 2, 4, 4, 3, 2, 5, 1, 3, 3, 4, 2, 4, 3, 4, 2, 3, 9, 3, 2, 6, 2, 2, 2, 3, 4, 2, 2, 4, 4, 3, 5, 4, 2, 4, 2, 4, 1, 1, 5, 3, 2, 5, 4, 1, 4, 2, 2, 2, 13, 6, 9, 5, 6, 6, 3, 1, 4, 3, 4, 8, 3, 3, 2, 3, 2, 1, 7, 2, 8, 4, 8, 4, 2, 2, 6, 8, 3, 8, 2, 4, 2, 2, 5, 4, 3, 4, 8, 6, 5, 4, 9, 1, 4, 3, 8, 5, 3, 1, 2, 3, 7, 4, 1, 2, 5, 4, 5, 4, 7, 7, 17, 6, 3, 4, 3, 2, 2, 9, 4, 2, 5, 3, 3, 1, 1, 1, 16, 1, 2, 3, 2, 4, 7, 5, 6, 27, 3, 2, 3, 11, 6, 9, 7, 8, 4, 1, 2, 1, 6, 6, 3, 3, 7, 2, 11, 4, 4, 3, 2, 2, 2, 18, 3, 2, 4, 5, 4, 3, 4, 3, 1, 3, 5, 3, 3, 4, 4, 4, 3, 1, 2, 4, 5, 2, 3, 1, 5, 4, 3, 3, 8, 20, 6, 8, 2, 4, 3, 2, 2, 3, 1, 3, 1, 2, 6, 5, 3, 1, 2, 2, 1, 4, 1, 2, 3, 2, 2, 18, 5, 11, 5, 3, 3, 4, 4, 6, 4, 2, 16, 5, 1, 3, 1, 3, 3, 2, 4, 3, 3, 5, 4, 6, 3, 3, 5, 5, 2, 3, 3, 6, 7, 9, 12, 4, 3, 3, 3, 10, 2, 3, 12, 3, 6, 8, 1, 3, 1, 2, 3, 2, 3, 2, 3, 7, 2, 2, 6, 2, 2, 4, 5, 5, 3, 2, 2, 3, 2, 2, 3, 1, 3, 5, 7, 5, 3, 1, 3, 2, 3, 4, 3, 3, 3, 3, 11, 5, 3, 8, 5, 2, 3, 4, 4, 2, 2, 2, 6, 1, 2, 3, 2, 2, 2, 3, 4, 5, 1, 10, 3, 3, 1, 9, 1, 10, 9, 11, 8, 6, 2, 3, 5, 4, 2, 9, 3, 2, 3, 3, 7, 2, 2, 4, 3, 5, 2, 5, 1, 4, 4, 4, 7, 7, 3, 3, 2, 5, 5, 1, 2, 5, 5, 3, 3, 3, 3, 2, 5, 2, 2, 3, 2, 3, 3, 1, 2, 5, 4, 10, 10, 7, 3, 9, 9, 7, 3, 9, 9, 7, 2, 5, 4, 3, 7, 1, 3, 4, 5, 2, 5, 3, 1, 2, 1, 7, 5, 5, 3, 1, 3, 4, 2, 2, 2, 3, 2, 1, 2, 2, 5, 2, 4, 3, 2, 2, 3, 2, 4, 2, 2, 5, 4, 3, 3, 4, 3, 2, 8, 9, 4, 4, 7, 11, 5, 13, 19, 6, 3, 3, 3, 5, 5, 3, 1, 3, 2, 3, 3, 3, 3, 2, 4, 1, 4, 3, 8, 3, 7, 7, 13, 4, 3, 2, 3, 3, 3, 4, 4, 2, 2, 3, 3, 2, 2, 5, 5, 1, 2, 3, 1, 2, 4, 8, 4, 8, 3, 7, 4, 4, 4, 5, 4, 4, 3, 5, 8, 6, 2, 3, 7, 8, 3, 6, 10, 10, 8, 8, 4, 3, 4, 3, 3, 4, 4, 4, 3, 4, 3, 4, 4, 2, 3, 3, 4, 3, 2, 2, 7, 11, 3, 7, 8, 12, 3, 4, 5, 5, 11, 6, 3, 3, 2, 4, 1, 1, 1, 3, 4, 2, 10, 2, 2, 4, 3, 4, 3, 2, 4, 2, 2, 10, 6, 2, 1, 2, 3, 4, 6, 3, 5, 8, 3, 3, 4, 2, 2, 2, 2, 4, 2, 2, 3, 3, 3, 8, 4, 3, 4, 6, 2, 6, 2, 5, 5, 2, 3, 2, 1, 7, 6, 4, 4, 7, 2, 6, 3, 3, 2, 2, 2, 2, 1, 2, 5, 3, 5, 3, 2, 10, 8, 5, 6, 2, 2, 5, 4, 4, 15, 4, 2, 8, 2, 7, 7, 2, 4, 3, 10, 4, 8, 5, 14, 7, 3, 4, 6, 4, 4, 2, 11, 5, 4, 2, 4, 6, 24, 4, 3, 3, 3, 5, 6, 2, 6, 1, 4, 6, 2, 4, 9, 2, 2, 2, 2, 5, 4, 3, 2, 3, 4, 3, 3, 2, 3, 7, 5, 3, 3, 3, 4, 2, 3, 4, 2, 2, 1, 1, 12, 3, 5, 2, 5, 1, 3, 1, 1, 6, 5, 4, 4, 7, 16, 3, 4, 2, 4, 1, 8, 12, 2, 1, 2, 5, 4, 3, 3, 11, 2, 2, 6, 11, 2, 5, 4, 3, 3, 2, 4, 3, 3, 3, 4, 6, 3, 3, 6, 4, 3, 3, 3, 2, 2, 2, 6, 7, 6, 2, 3, 3, 3, 2, 2, 1, 4, 1, 3, 4, 2, 2, 2, 2, 6, 3, 2, 4, 3, 3, 2, 3, 2, 1, 2, 14, 4, 1, 3, 2, 2, 1, 4, 3, 2, 1, 14, 6, 3, 4, 2, 6, 6, 4, 5, 3, 1, 2, 4, 1, 6, 2, 2, 2, 3, 3, 4, 2, 2, 5, 2, 8, 3, 1, 2, 3, 4, 2, 1, 2, 6, 4, 8, 3, 2, 3, 4, 3, 4, 3, 3, 5, 4, 4, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 3, 2, 2, 2, 10, 7, 6, 4, 4, 5, 4, 3, 2, 3, 1, 3, 2, 5, 4, 3, 8, 2, 3, 4, 3, 3, 4, 1, 2, 2, 5, 8, 3, 3, 3, 1, 1, 3, 2, 2, 2, 4, 4, 2, 3, 5, 4, 2, 2, 6, 3, 3, 7, 9, 8, 5, 19, 15, 3, 3, 10, 6, 4, 2, 5, 2, 6, 3, 4, 3, 6, 3, 1, 3, 1, 1, 2, 3, 4, 2, 3, 2, 6, 2, 4, 2, 5, 2, 2, 2, 2, 7, 2, 1, 1, 2, 1, 3, 5, 1, 3, 1, 2, 1, 1, 1, 6, 2, 4, 4, 3, 4, 3, 1, 2, 14, 6, 9, 1, 3, 2, 4, 3, 2, 4, 6, 1, 3, 4, 3, 2, 5, 2, 3, 2, 3, 3, 8, 1, 1, 6, 4, 14, 10, 1, 7, 3, 2, 6, 3, 2, 6, 3, 4, 6, 5, 5, 4, 4, 3, 6, 5, 3, 2, 2, 2, 3, 2, 1, 4, 2, 1, 3, 6, 1, 11, 5, 7, 3, 4, 6, 4, 3, 1, 3, 4, 3, 3, 3, 2, 8, 3, 9, 2, 17, 3, 3, 1, 3, 5, 5, 2, 1, 6, 11, 3, 4, 3, 3, 1, 2, 4, 1, 3, 6, 3, 8, 5, 3, 1, 2, 9, 5, 5, 5, 3, 4, 7, 1, 4, 3, 7, 3, 4, 7, 1, 2, 2, 3, 3, 12, 5, 7, 2, 5, 5, 6, 3, 2, 2, 2, 3, 3, 3, 4, 1, 3, 3, 3, 3, 4, 4, 3, 3, 2, 3, 4, 4, 6, 6, 2, 2, 2, 2, 2, 2, 4, 3, 4, 2, 4, 4, 2, 6, 9, 3, 5, 10, 3, 2, 2, 2, 1, 6, 1, 2, 3, 6, 1, 7, 5, 2, 3, 1, 3, 5, 1, 3, 4, 3, 3, 2, 3, 5, 6, 3, 7, 4, 2, 1, 2, 2, 6, 3, 3, 3, 5, 5, 3, 3, 6, 1, 5, 1, 2, 4, 4, 3, 4, 2, 2, 4, 2, 2, 4, 1, 3, 2, 2, 2, 3, 8, 1, 3, 3, 2, 3, 7, 2, 3, 3, 7, 7, 2, 2, 1, 2, 2, 5, 5, 3, 2, 4, 6, 25, 6, 10, 3, 5, 6, 9, 5, 3, 6, 2, 1, 4, 2, 2, 1, 3, 2, 3, 2, 2, 2, 1, 6, 2, 5, 5, 8, 1, 6, 9, 10, 6, 17, 8, 8, 3, 5, 6, 2, 3, 2, 4, 5, 5, 6, 5, 12, 20, 5, 13, 5, 3, 7, 4, 7, 2, 3, 7, 4, 5, 3, 1, 4, 4, 3, 10, 7, 12, 11, 4, 8, 4, 5, 2, 5, 2, 6, 6, 5, 2, 3, 3, 6, 10, 5, 2, 6, 1, 4, 2, 2, 5, 4, 2, 7, 1, 2, 5, 5, 4, 3, 5, 5, 2, 3, 4, 4, 4, 3, 3, 1, 4, 6, 1, 1, 2, 6, 9, 3, 3, 3, 3, 3, 4, 7, 3, 2, 5, 7, 5, 6, 3, 5, 5, 4, 2, 1, 3, 4, 3, 2, 5, 7, 6, 5, 7, 1, 8, 6, 2, 4, 4, 2, 4, 3, 3, 6, 2, 2, 2, 4, 2, 3, 3, 1, 5, 5, 2, 4, 2, 4, 3, 2, 5, 2, 5, 4, 7, 3, 5, 2, 1, 2, 4, 3, 2, 4, 2, 2, 1, 2, 6, 2, 7, 1, 6, 1, 1, 4, 7, 4, 1, 17, 1, 1, 1, 1, 9, 2, 4, 3, 3, 5, 3, 3, 5, 4, 4, 3, 3, 3, 2, 14, 2, 4, 6, 6, 2, 12, 2, 3, 2, 6, 4, 4, 8, 2, 5, 3, 6, 12, 4, 2, 4, 4, 1, 2, 9, 8, 1, 2, 3, 2, 23, 7, 3, 5, 4, 4, 2, 5, 3, 2, 2, 4, 4, 1, 3, 2, 1, 3, 3, 3, 3, 5, 4, 3, 4, 3, 16, 2, 4, 8, 3, 2, 4, 5, 3, 2, 1, 2, 2, 2, 3, 3, 3, 4, 3, 5, 4, 1, 1, 1, 3, 4, 4, 4, 6, 5, 4, 2, 4, 7, 2, 2, 5, 3, 6, 1, 2, 4, 1, 2, 5, 3, 1, 2, 2, 1, 2, 2, 1, 1, 2, 3, 2, 2, 2, 2, 1, 1, 3, 2, 2, 1, 3, 5, 8, 8, 8, 8, 5, 7, 3, 3, 4, 3, 2, 3, 5, 3, 2, 4, 4, 2, 2, 5, 5, 3, 4, 4, 6, 2, 2, 11, 9, 4, 3, 4, 2, 4, 2, 1, 3, 1, 2, 1, 1, 16, 3, 3, 3, 2, 2, 3, 2, 1, 2, 3, 12, 3, 2, 2, 6, 7, 3, 3, 4, 8, 5, 11, 4, 4, 4, 3, 12, 5, 5, 4, 7, 2, 2, 11, 2, 4, 11, 5, 6, 4, 3, 6, 5, 3, 3, 2, 6, 5, 7, 2, 5, 7, 4, 7, 6, 3, 9, 2, 10, 6, 7, 6, 13, 9, 7, 5, 5, 3, 1, 9, 5, 4, 12, 2, 8, 2, 1, 2, 1, 2, 3, 3, 5, 2, 1, 1, 2, 6, 2, 3, 4, 3, 3, 5, 2, 2, 2, 2, 4, 6, 3, 4, 3, 2, 4, 9, 3, 4, 5, 2, 7, 3, 4, 2, 2, 3, 4, 3, 8, 2, 2, 2, 3, 1, 3, 2, 4, 9, 12, 1, 1, 5, 5, 2, 3, 2, 7, 5, 2, 4, 1, 1, 3, 1, 2, 1, 2, 4, 4, 2, 3, 2, 4, 7, 3, 2, 4, 8, 11, 5, 2, 3, 3, 3, 5, 4, 2, 3, 3, 3, 1, 8, 6, 5, 1, 3, 2, 1, 3, 3, 2, 4, 3, 1, 5, 5, 3, 1, 2, 1, 3, 10, 11, 1, 1, 2, 2, 2, 3, 3, 3, 2, 3, 4, 1, 4, 2, 4, 2, 3, 3, 3, 4, 5, 2, 5, 3, 3, 22, 19, 3, 2, 5, 4, 7, 4, 2, 3, 4, 2, 6, 3, 2, 2, 3, 2, 2, 2, 3, 2, 2, 2, 4, 3, 4, 2, 4, 2, 2, 3, 2, 2, 5, 1, 1, 1, 11, 5, 6, 3, 2, 3, 3, 4, 1, 2, 2, 5, 7, 3, 1, 3, 2, 7, 3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 4, 4, 4, 1, 2, 1, 1, 10, 3, 3, 2, 8, 5, 10, 13, 5, 2, 4, 5, 2, 2, 8, 3, 8, 4, 3, 4, 5, 3, 4, 5, 3, 2, 4, 4, 2, 4, 10, 5, 3, 4, 5, 3, 2, 5, 3, 3, 3, 5, 3, 4, 2, 3, 4, 4, 11, 4, 2, 3, 3, 4, 5, 7, 3, 4, 2, 4, 4, 1, 4, 1, 3, 3, 1, 3, 1, 1, 5, 3, 4, 3, 5, 13, 9, 7, 5, 4, 7, 3, 3, 3, 5, 6, 4, 4, 2, 3, 2, 8, 6, 3, 2, 5, 5, 4, 1, 3, 5, 3, 3, 3, 3, 3, 4, 7, 1, 2, 4, 7, 5, 4, 10, 2, 4, 2, 3, 9, 1, 1, 1, 4, 4, 4, 1, 1, 4, 3, 2, 2, 2, 5, 4, 2, 2, 3, 2, 9, 6, 4, 1, 1, 1, 1, 1, 2, 3, 3, 3, 7, 3, 4, 2, 4, 3, 5, 2, 2, 2, 2, 5, 5, 1, 2, 4, 13, 5, 3, 4, 3, 3, 4, 1, 4, 1, 6, 2, 10, 3, 3, 3, 4, 5, 2, 5, 5, 5, 11, 4, 1, 2, 5, 1, 3, 3, 5, 8, 4, 4, 5, 3, 2, 10, 3, 3, 1, 4, 5, 4, 4, 4, 1, 3, 1, 2, 4, 5, 7, 2, 2, 3, 3, 5, 7, 1, 3, 3, 6, 2, 2, 2, 2, 4, 3, 3, 3, 5, 2, 2, 4, 3, 2, 4, 5, 4, 1, 13, 2, 4, 1, 1, 1, 3, 4, 3, 4, 2, 1, 2, 4, 2, 4, 5, 2, 4, 3, 5, 5, 4, 3, 3, 3, 3, 3, 12, 4, 2, 2, 8, 3, 2, 3, 4, 2, 2, 8, 4, 1, 2, 7, 3, 1, 7, 5, 8, 3, 2, 3, 1, 5, 3, 1, 3, 3, 6, 3, 13, 3, 2, 4, 4, 3, 2, 4, 2, 2, 2, 4, 5, 3, 4, 3, 4, 4, 3, 3, 4, 6, 2, 4, 9, 10, 6, 4, 11, 8, 7, 12, 4, 3, 4, 1, 4, 1, 4, 2, 4, 6, 4, 1, 5, 12, 7, 7, 8, 5, 6, 3, 2, 4, 2, 3, 4, 5, 4, 2, 2, 5, 3, 5, 3, 3, 5, 4, 1, 3, 2, 4, 5, 3, 2, 4, 7, 4, 3, 3, 3, 6, 4, 5, 4, 1, 1, 3, 2, 14, 3, 6, 19, 4, 3, 2, 3, 8, 6, 6, 4, 5, 3, 2, 9, 5, 5, 6, 2, 4, 2, 4, 9, 2, 3, 5, 3, 2, 1, 5, 4, 4, 4, 3, 2, 3, 3, 3, 9, 5, 3, 3, 1, 4, 3, 3, 12, 4, 2, 4, 11, 4, 4, 4, 3, 9, 6, 5, 3, 3, 3, 5, 7, 10, 3, 9, 8, 9, 8, 1, 3, 2, 2, 3, 2, 5, 3, 1, 5, 4, 10, 7, 3, 1, 6, 2, 3, 8, 6, 18, 5, 4, 6, 3, 1, 4, 3, 3, 2, 8, 3, 1, 4, 5, 5, 4, 7, 9, 3, 2, 4, 4, 3, 3, 4, 3, 2, 1, 1, 4, 4, 1, 1, 2, 4, 2, 3, 2, 2, 2, 2, 3, 5, 2, 2, 1, 10, 5, 2, 5, 4, 3, 5, 8, 3, 2, 5, 5, 5, 3, 3, 1, 8, 5, 6, 2, 4, 4, 5, 3, 2, 4, 3, 3, 7, 2, 1, 2, 3, 3, 3, 1, 7, 5, 2, 2, 4, 2, 3, 1, 4, 4, 9, 2, 2, 2, 3, 2, 4, 1, 13, 3, 1, 2, 3, 7, 3, 7, 7, 1, 3, 4, 5, 1, 5, 4, 6, 2, 3, 3, 7, 3, 12, 3, 3, 5, 3, 2, 5, 2, 2, 4, 9, 10, 2, 12, 8, 9, 5, 14, 3, 1, 6, 9, 5, 3, 3, 11, 12, 7, 8, 8, 7, 5, 2, 3, 1, 3, 3, 4, 4, 1, 3, 1, 2, 2, 2, 3, 3, 2, 10, 3, 4, 3, 3, 8, 6, 2, 3, 12, 3, 6, 1, 2, 4, 5, 3, 2, 2, 2, 2, 4, 3, 8, 7, 3, 3, 3, 2, 3, 2, 1, 1, 4, 3, 2, 2, 4, 3, 2, 8, 9, 3, 2, 3, 5, 3, 2, 6, 8, 7, 6, 8, 3, 1, 8, 3, 2, 4, 7, 2, 7, 1, 2, 1, 5, 7, 3, 3, 10, 5, 5, 10, 4, 8, 5, 6, 3, 3, 5, 3, 9, 3, 8, 17, 9, 3, 6, 1, 2, 2, 2, 3, 2, 4, 2, 5, 5, 3, 5, 4, 4, 8, 9, 8, 3, 4, 3, 2, 5, 2, 4, 3, 4, 4, 2, 2, 2, 4, 3, 2, 3, 3, 3, 2, 2, 2, 4, 6, 3, 4, 4, 6, 8, 2, 1, 4, 2, 1, 1, 4, 1, 5, 9, 1, 2, 12, 8, 8, 5, 8, 2, 1, 2, 2, 2, 6, 5, 9, 7, 7, 2, 2, 1, 5, 2, 4, 3, 2, 2, 3, 3, 5, 3, 1, 2, 2, 3, 2, 2, 2, 4, 2, 2, 3, 2, 6, 9, 3, 6, 4, 4, 6, 3, 1, 4, 3, 4, 1, 2, 4, 5, 2, 7, 11, 1, 2, 1, 2, 4, 7, 2, 2, 2, 5, 6, 8, 3, 3, 3, 3, 2, 2, 3, 4, 4, 5, 6, 4, 2, 1, 4, 2, 2, 3, 4, 4, 3, 2, 2, 2, 2, 4, 3, 2, 4, 4, 3, 3, 4, 3, 3, 3, 2, 4, 4, 4, 4, 3, 3, 3, 3, 3, 5, 3, 3, 2, 2, 9, 4, 3, 4, 2, 5, 2, 3, 4, 2, 2, 5, 3, 3, 5, 24, 1, 2, 3, 3, 3, 3, 4, 2, 4, 11, 3, 2, 2, 2, 3, 3, 2, 6, 7, 5, 1, 2, 1, 3, 5, 3, 5, 2, 2, 3, 1, 4, 3, 1, 3, 6, 6, 3, 4, 8, 8, 2, 3, 1, 3, 9, 7, 2, 1, 2, 3, 3, 1, 3, 2, 1, 3, 4, 4, 3, 1, 2, 3, 2, 4, 1, 1, 3, 4, 1, 4, 1, 1, 3, 1, 8, 1, 2, 1, 3, 2, 4, 5, 5, 8, 8, 5, 6, 6, 6, 2, 7, 13, 4, 7, 2, 3, 5, 4, 3, 7, 3, 4, 14, 3, 3, 8, 3, 5, 4, 4, 4, 2, 3, 1, 2, 2, 6, 5, 1, 2, 2, 3, 3, 2, 1, 5, 5, 2, 5, 4, 1, 2, 3, 1, 1, 3, 3, 1, 4, 2, 1, 7, 7, 5, 1, 1, 2, 7, 2, 1, 3, 1, 1, 3, 12, 8, 3, 8, 2, 4, 7, 7, 2, 3, 2, 3, 2, 3, 7, 7, 7, 3, 2, 4, 2, 2, 4, 5, 3, 3, 4, 8, 3, 32, 2, 8, 2, 2, 3, 1, 1, 2, 4, 4, 4, 3, 2, 5, 1, 4, 11, 4, 3, 3, 5, 10, 3, 12, 2, 2, 3, 6, 5, 2, 2, 1, 2, 4, 3, 3, 2, 3, 6, 2, 3, 3, 3, 4, 4, 2, 6, 3, 2, 2, 2, 1, 4, 4, 1, 10, 1, 4, 6, 4, 3, 4, 1, 1, 1, 3, 5, 4, 2, 2, 4, 4, 3, 5, 14, 2, 4, 1, 3, 2, 1, 7, 1, 1, 6, 7, 5, 8, 2, 4, 2, 1, 5, 7, 4, 1, 2, 2, 8, 3, 2, 3, 2, 3, 3, 3, 4, 4, 3, 3, 5, 1, 2, 2, 4, 11, 3, 3, 3, 13, 3, 3, 5, 3, 4, 5, 5, 1, 1, 2, 2, 2, 5, 2, 2, 3, 1, 2, 3, 3, 1, 4, 2, 4, 4, 3, 4, 1, 2, 2, 6, 6, 1, 3, 6, 2, 10, 9, 8, 4, 2, 3, 7, 2, 3, 2, 4, 5, 2, 2, 4, 3, 2, 4, 2, 6, 5, 4, 1, 1, 4, 1, 8, 1, 5, 7, 4, 1, 4, 3, 6, 7, 3, 7, 6, 7, 8, 1, 4, 5, 5, 1, 1, 5, 4, 3, 13, 3, 2, 7, 7, 1, 3, 3, 8, 1, 2, 4, 1, 1, 4, 3, 2, 1, 2, 3, 4, 3, 1, 10, 3, 3, 3, 3, 1, 5, 3, 4, 4, 1, 2, 2, 4, 7, 4, 4, 10, 6, 5, 1, 1, 2, 4, 4, 2, 1, 5, 3, 2, 2, 2, 2, 5, 3, 5, 2, 2, 2, 6, 3, 3, 3, 5, 3, 8, 2, 2, 3, 3, 3, 5, 9, 4, 8, 2, 3, 2, 5, 1, 2, 2, 4, 2, 5, 4, 6, 3, 3, 2, 2, 3, 3, 2, 6, 4, 4, 4, 8, 4, 5, 17, 1, 8, 5, 5, 4, 1, 2, 3, 8, 2, 3, 2, 1, 1, 10, 8, 3, 5, 6, 10, 5, 7, 3, 3, 2, 9, 5, 4, 9, 8, 2, 4, 5, 7, 2, 4, 2, 4, 1, 1, 3, 3, 4, 3, 6, 3, 1, 2, 2, 2, 2, 2, 3, 3, 2, 3, 7, 4, 1, 5, 2, 7, 4, 4, 7, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 5, 5, 2, 2, 2, 2, 4, 9, 4, 3, 9, 2, 2, 4, 1, 1, 1, 1, 2, 3, 3, 7, 1, 3, 2, 8, 2, 3, 4, 6, 15, 5, 4, 2, 8, 4, 5, 1, 2, 16, 12, 6, 6, 6, 9, 6, 2, 8, 6, 3, 6, 2, 3, 2, 1, 5, 1, 3, 2, 5, 3, 4, 2, 3, 3, 4, 2, 2, 2, 2, 5, 1, 6, 3, 7, 4, 3, 2, 3, 2, 3, 3, 3, 11, 5, 3, 3, 2, 8, 5, 6, 2, 4, 4, 2, 1, 3, 3, 3, 3, 1, 1, 3, 3, 3, 3, 6, 8, 2, 3, 3, 4, 6, 7, 10, 4, 6, 5, 5, 2, 1, 4, 5, 5, 2, 2, 2, 3, 2, 3, 1, 3, 2, 3, 1, 7, 5, 4, 5, 3, 2, 3, 6, 7, 5, 2, 3, 10, 30, 6, 10, 2, 4, 4, 2, 4, 11, 7, 5, 12, 8, 2, 3, 9, 9, 6, 2, 3, 2, 1, 2, 1, 2, 2, 2, 2, 3, 5, 4, 4, 2, 2, 3, 2, 6, 3, 2, 17, 7, 2, 8, 5, 3, 4, 2, 5, 2, 4, 5, 1, 2, 5, 4, 2, 7, 4, 4, 4, 4, 2, 4, 2, 6, 3, 6, 2, 3, 5, 3, 8, 3, 2, 10, 3, 11, 4, 4, 7, 6, 3, 9, 4, 4, 2, 3, 3, 6, 6, 2, 6, 2, 4, 3, 4, 2, 7, 5, 15, 2, 2, 2, 5, 4, 8, 1, 2, 1, 1, 2, 2, 3, 4, 3, 9, 3, 1, 7, 3, 7, 3, 5, 6, 7, 3, 8, 6, 6, 2, 1, 1, 7, 4, 3, 5, 4, 4, 3, 5, 3, 3, 2, 2, 1, 4, 4, 3, 3, 7, 5, 5, 3, 3, 5, 4, 4, 3, 3, 3, 1, 4, 2, 5, 5, 4, 3, 2, 1, 1, 4, 2, 3, 3, 2, 3, 4, 1, 6, 9, 5, 7, 4, 11, 2, 3, 2, 7, 8, 4, 3, 4, 3, 5, 7, 5, 3, 4, 3, 4, 5, 1, 4, 4, 2, 1, 5, 9, 2, 8, 2, 2, 2, 2, 7, 11, 3, 2, 6, 16, 10, 8, 5, 4, 9, 3, 2, 3, 3, 2, 1, 1, 1, 3, 2, 2, 2, 4, 6, 2, 7, 1, 3, 3, 1, 5, 4, 2, 1, 2, 2, 2, 3, 3, 1, 2, 2, 3, 2, 2, 2, 3, 3, 3, 4, 2, 1, 2, 4, 3, 1, 1, 1, 1, 2, 5, 2, 3, 2, 2, 4, 2, 2, 3, 7, 2, 7, 3, 2, 3, 3, 3, 3, 3, 3, 3, 6, 7, 4, 2, 2, 1, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 1, 2, 3, 9, 3, 3, 4, 3, 7, 3, 3, 4, 4, 3, 5, 5, 2, 4, 3, 3, 2, 4, 5, 18, 3, 3, 19, 7, 3, 5, 3, 7, 8, 3, 4, 5, 5, 8, 12, 2, 3, 10, 1, 1, 4, 7, 1, 3, 1, 1, 5, 4, 2, 6, 7, 7, 4, 2, 1, 5, 1, 1, 1, 1, 4, 4, 2, 3, 5, 3, 6, 1, 2, 2, 3, 1, 2, 1, 6, 9, 3, 1, 1, 1, 8, 3, 3, 6, 3, 1, 5, 3, 6, 2, 6, 4, 3, 1, 2, 3, 8, 1, 5, 1, 4, 2, 1, 2, 3, 2, 7, 4, 8, 4, 5, 3, 1, 2, 2, 3, 1, 2, 2, 2, 3, 4, 3, 2, 3, 7, 4, 6, 1, 3, 1, 3, 4, 4, 2, 2, 2, 2, 5, 2, 3, 2, 1, 2, 5, 4, 6, 6, 3, 4, 2, 6, 3, 2, 2, 1, 5, 3, 3, 3, 7, 5, 9, 2, 4, 11, 1, 2, 2, 3, 5, 5, 3, 5, 3, 4, 1, 2, 2, 7, 5, 6, 3, 9, 11, 4, 4, 2, 4, 3, 7, 5, 7, 5, 8, 5, 2, 6, 3, 4, 7, 3, 15, 6, 3, 1, 14, 9, 14, 6, 3, 2, 2, 1, 3, 4, 6, 4, 6, 4, 5, 3, 1, 9, 6, 8, 3, 3, 4, 6, 3, 6, 2, 20, 2, 2, 2, 1, 3, 4, 6, 4, 6, 4, 5, 3, 1, 9, 6, 8, 3, 3, 4, 6, 3, 6, 2, 20, 2, 2, 8, 2, 1, 9, 1, 3, 5, 4, 2, 5, 4, 2, 4, 5, 3, 14, 5, 2, 4, 3, 3, 2, 2, 7, 2, 2, 3, 6, 5, 1, 6, 2, 2, 7, 3, 3, 2, 1, 4, 2, 2, 2, 7, 4, 1, 4, 2, 2, 4, 5, 6, 5, 4, 1, 2, 6, 5, 11, 10, 2, 8, 6, 2, 3, 5, 3, 2, 3, 7, 3, 3, 3, 4, 3, 4, 6, 6, 7, 10, 1, 7, 3, 14, 3, 3, 2, 4, 3, 4, 5, 3, 11, 2, 4, 15, 3, 4, 4, 6, 3, 1, 1, 3, 1, 4, 2, 2, 2, 1, 3, 2, 2, 1, 1, 11, 2, 2, 4, 5, 2, 5, 1, 1, 15, 5, 4, 7, 7, 7, 2, 2, 5, 6, 4, 5, 2, 4, 2, 6, 2, 5, 4, 4, 3, 4, 9, 7, 3, 5, 5, 3, 2, 12, 3, 7, 5, 5, 7, 1, 19, 6, 1, 4, 6, 3, 5, 6, 1, 2, 7, 1, 5, 4, 2, 4, 5, 6, 1, 5, 5, 4, 3, 5, 9, 1, 5, 3, 5, 2, 4, 7, 16, 2, 3, 3, 6, 5, 2, 4, 7, 9, 8, 1, 4, 2, 5, 6, 5, 4, 4, 2, 3, 9, 3, 2, 9, 7, 2, 2, 2, 1, 6, 4, 12, 3, 3, 1, 1, 7, 4, 6, 3, 3, 4, 3, 1, 7, 3, 2, 3, 3, 3, 2, 2, 9]\n"
+     ]
+    }
+   ],
+   "source": [
+    "token_len_distr = {key : [] for key in selected_entities}\n",
+    "\n",
+    "for f in files:\n",
+    "    with open(os.path.join(data_bio_path, f), 'r', encoding='utf-8') as file:\n",
+    "        text = file.read()\n",
+    "        criteria_list = text.split('\\n\\n')\n",
+    "        # now let us consider each complete entity (B + I)\n",
+    "        \n",
+    "        for crit in criteria_list:\n",
+    "            current_entity = ''\n",
+    "            count = 0\n",
+    "            crit = crit.split('\\n')\n",
+    "            for c in crit:\n",
+    "                if c == '':\n",
+    "                    continue\n",
+    "                if c.split()[-1] == 0:\n",
+    "                    token_len_distr[current_entity].append(count)\n",
+    "                    count = 0\n",
+    "                    current_entity = ''\n",
+    "                elif current_entity == '' or current_entity == c.split()[-1][2:]:\n",
+    "                    count += 1\n",
+    "                    current_entity = c.split()[-1][2:]\n",
+    "                elif current_entity != '' and current_entity != c.split()[-1][2:]:\n",
+    "                    token_len_distr[current_entity].append(count)\n",
+    "                    count = 1\n",
+    "                    current_entity = c.split()[-1][2:]\n",
+    "print(token_len_distr['Condition'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 98,
+   "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>entity</th>\n",
+       "      <th>n_token</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Condition</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Condition</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Condition</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Condition</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Condition</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      entity  n_token\n",
+       "0  Condition        4\n",
+       "1  Condition        4\n",
+       "2  Condition        2\n",
+       "3  Condition        2\n",
+       "4  Condition        6"
+      ]
+     },
+     "execution_count": 98,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "entity_token_df = pd.DataFrame(columns=[\"entity\",\"n_token\"])\n",
+    "entities_list = []\n",
+    "n_tokens_list = []\n",
+    "for entity in token_len_distr:\n",
+    "    entities_list.extend([entity for _ in range(len(token_len_distr[entity]))])\n",
+    "    n_tokens_list.extend(token_len_distr[entity])\n",
+    "entity_token_df[\"entity\"] = entities_list\n",
+    "entity_token_df[\"n_token\"] = n_tokens_list\n",
+    "entity_token_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# boxplot token len distribution per entity\n",
+    "sns.boxplot(x = 'entity', y = 'n_token', data=entity_token_df, showfliers = False)\n",
+    "plt.xticks(rotation=90)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "TER",
+   "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.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}