recommendations/deep-recommender-graph-node2vec.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "80722859-56ac-441e-b1a7-e773fe314356",
   "metadata": {},
   "source": [
    "# Deep Recommender: Item Representation Learning Using Node2Vec\n",
    "\n",
    "In this notebook, we build a non-personalized graph recommendation engine that uses Node2Vec model to learn item embeddings. \n",
    "\n",
    "### Use Case\n",
    "We have a fixed number of users and items (products). For some user-item pairs we know the interaction score (e.g. user rating). No additional user or item features or score metadata (e.g. time stamps) are available. Our goal is to estimate the scores for the remaining user-item pairs. \n",
    "\n",
    "### Prototype: Approach and Data\n",
    "We interpret the interaction matrix as a graph where nodes are items and edges are attributed with weights computed based on user-item interactions. We then use Node2Vec to compute node (item) embeddings. These embeddings can be used to compute item-to-item similarity scores enabling non-personalized content-based recommendations using nearest neighbors search. \n",
    "\n",
    "This notebook is based on Khalid Salama's implementation [1]. We use `MovieLens 100K` (Latest Small version) dataset. See `datasets.md` for details.\n",
    "\n",
    "### Usage and Productization\n",
    "This prototype can be used to evaluate the feasibility of the graph-based approach on a small scale. Production-grade implementations of graph recommenders should be used for more advanced evaluation and productization.\n",
    "\n",
    "### References\n",
    "1. Khalid Salama -- Graph representation learning with node2vec, 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9fae09e9-7774-4c7d-a9f7-16eb6e607841",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keras version 2.6.0\n",
      "Tensorflow version 2.6.0\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Imports and settings\n",
    "#\n",
    "import warnings\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "from collections import defaultdict\n",
    "import math\n",
    "import networkx as nx\n",
    "import random\n",
    "from tqdm import tqdm\n",
    "\n",
    "from tabulate import tabulate\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams.update({'pdf.fonttype': 'truetype'})\n",
    "warnings.simplefilter(\"ignore\")\n",
    "\n",
    "print(\"Keras version \" + tf.keras.__version__)\n",
    "print(\"Tensorflow version \" + tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0272d5c0-0a81-4124-9813-493e91fec573",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Helper functions\n",
    "#\n",
    "def print_df(df, col_width = 10, rows = 10, max_cols = 10):\n",
    "    def short_srt(x):\n",
    "        return x if len(x) < col_width else x[:col_width-3] + \"...\"\n",
    "    df_short = df.head(rows).applymap(lambda x: short_srt(str(x)))\n",
    "    \n",
    "    if len(df_short.columns) > max_cols:\n",
    "        df_short = df_short.iloc[:, 0:max_cols-1]\n",
    "        df_short['...'] = '...'\n",
    "    \n",
    "    print(tabulate(df_short, headers='keys', tablefmt='psql'))\n",
    "    print(f'{len(df)} rows x {len(df.columns)} columns')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "270f63ea-1c56-46bc-9408-5d409145e7ae",
   "metadata": {},
   "source": [
    "# Step 1: Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "id": "3e6e8b0a-acc3-4d68-b1c2-35d702d54ef4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+----------+--------------------------------+\n",
      "|    | itemId   | name                           |\n",
      "|----+----------+--------------------------------|\n",
      "|  0 | item_2   | Jumanji (1995)                 |\n",
      "|  1 | item_3   | Grumpier Old Men (1995)        |\n",
      "|  2 | item_4   | Waiting to Exhale (1995)       |\n",
      "|  3 | item_5   | Father of the Bride Part II... |\n",
      "|  4 | item_6   | Heat (1995)                    |\n",
      "|  5 | item_7   | Sabrina (1995)                 |\n",
      "|  6 | item_8   | Tom and Huck (1995)            |\n",
      "|  7 | item_9   | Sudden Death (1995)            |\n",
      "|  8 | item_10  | GoldenEye (1995)               |\n",
      "|  9 | item_11  | American President, The (19... |\n",
      "+----+----------+--------------------------------+\n",
      "9741 rows x 2 columns\n",
      "+----+----------+----------+----------+\n",
      "|    |   userId | itemId   |   rating |\n",
      "|----+----------+----------+----------|\n",
      "|  0 |        1 | item_3   |        4 |\n",
      "|  1 |        1 | item_6   |        4 |\n",
      "|  2 |        1 | item_47  |        5 |\n",
      "|  3 |        1 | item_50  |        5 |\n",
      "|  4 |        1 | item_70  |        3 |\n",
      "|  5 |        1 | item_101 |        5 |\n",
      "|  6 |        1 | item_110 |        4 |\n",
      "|  7 |        1 | item_151 |        5 |\n",
      "|  8 |        1 | item_157 |        5 |\n",
      "|  9 |        1 | item_163 |        5 |\n",
      "+----+----------+----------+----------+\n",
      "100835 rows x 3 columns\n"
     ]
    }
   ],
   "source": [
    "def load_movielens_100k_latest():\n",
    "    base_data_path = '~/ALGO/tensor-house-data/recommendations/movie-lens-latest-small/'\n",
    "\n",
    "    items = pd.read_csv(base_data_path + 'movies.csv.zip', \n",
    "                         compression='zip', \n",
    "                         sep=',',\n",
    "                         usecols=[0,1],\n",
    "                         names=['itemId', 'name'], \n",
    "                         header=1)\n",
    "    items['itemId'] = items['itemId'].apply(lambda x: f'item_{x}')\n",
    "\n",
    "    ratings = pd.read_csv(base_data_path + 'ratings.csv.zip', \n",
    "                          compression='zip', \n",
    "                          sep=',',\n",
    "                          usecols=[0, 1, 2],\n",
    "                          names=['userId', 'itemId', 'rating'], \n",
    "                          header=1)\n",
    "    ratings['rating'] = ratings['rating'].apply(lambda x: float(x))\n",
    "    ratings['itemId'] = ratings['itemId'].apply(lambda x: f'item_{x}')\n",
    "\n",
    "    return items, ratings\n",
    "\n",
    "def load_movielens_100k():\n",
    "    base_data_path = '~/ALGO/tensor-house-data/recommendations/movie-lens-100k/'\n",
    "\n",
    "    items = pd.read_csv(base_data_path + 'u.item.zip', \n",
    "                         compression='zip', \n",
    "                         sep='|',\n",
    "                         usecols=[0,1],\n",
    "                         names=['itemId', 'name'], \n",
    "                         header=None)\n",
    "    items['itemId'] = items['itemId'].apply(lambda x: f'item_{x}')\n",
    "\n",
    "    ratings = pd.read_csv(base_data_path + 'u.data.zip', \n",
    "                          compression='zip', \n",
    "                          sep='\\t',\n",
    "                          usecols=[0,1,2],\n",
    "                          names=['userId', 'itemId', 'rating'], \n",
    "                          header=None)\n",
    "    ratings['rating'] = ratings['rating'].apply(lambda x: float(x))\n",
    "    ratings['itemId'] = ratings['itemId'].apply(lambda x: f'item_{x}')\n",
    "\n",
    "    return items, ratings\n",
    "    \n",
    "items, ratings = load_movielens_100k_latest()\n",
    "print_df(items, col_width=30)\n",
    "print_df(ratings, col_width=30)\n",
    "\n",
    "def get_item_name_by_id(itemId):\n",
    "    return list(items[items.itemId == itemId].name)[0]\n",
    "\n",
    "def get_item_id_by_name(name):\n",
    "    return list(items[items.name == name].itemId)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d6ae6e8-4230-48fa-9023-d21ded33adc3",
   "metadata": {},
   "source": [
    "# Step 2: Create the Item Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "id": "2d3c4a66-6653-4306-8c9d-1df8edbc2d6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Compute item frequencies: 100%|██████████| 573/573 [00:00<00:00, 767.55it/s]\n",
      "Creating the item graph: 100%|██████████| 298586/298586 [00:00<00:00, 642655.01it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of graph nodes: 1405\n",
      "Total number of graph edges: 40043\n",
      "Average node degree: 57.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Create the weighted edges between items\n",
    "#\n",
    "min_rating = 5\n",
    "pair_frequency = defaultdict(int)\n",
    "item_frequency = defaultdict(int)\n",
    "\n",
    "#\n",
    "# Filter instances where rating is greater than or equal to min_rating\n",
    "#\n",
    "rated_items = ratings[ratings.rating >= min_rating]\n",
    "\n",
    "#\n",
    "# Group items by user\n",
    "#\n",
    "items_grouped_by_users = list(rated_items.groupby(\"userId\"))\n",
    "\n",
    "for group in tqdm(\n",
    "    items_grouped_by_users,\n",
    "    position=0,\n",
    "    leave=True,\n",
    "    desc=\"Compute item frequencies\",\n",
    "):\n",
    "    u_items = list(group[1][\"itemId\"])\n",
    "\n",
    "    for i in range(len(u_items)):\n",
    "        item_frequency[u_items[i]] += 1\n",
    "        for j in range(i + 1, len(u_items)):\n",
    "            x = min(u_items[i], u_items[j])\n",
    "            y = max(u_items[i], u_items[j])\n",
    "            pair_frequency[(x, y)] += 1\n",
    "\n",
    "#\n",
    "# Create the graph\n",
    "#\n",
    "min_weight = 10\n",
    "D = math.log(sum(item_frequency.values()))\n",
    "\n",
    "items_graph = nx.Graph()\n",
    "for pair in tqdm(\n",
    "    pair_frequency, position=0, leave=True, desc=\"Creating the item graph\"\n",
    "):\n",
    "    x, y = pair\n",
    "    xy_frequency = pair_frequency[pair]\n",
    "    x_frequency = item_frequency[x]\n",
    "    y_frequency = item_frequency[y]\n",
    "    pmi = math.log(xy_frequency) - math.log(x_frequency) - math.log(y_frequency) + D\n",
    "    weight = pmi * xy_frequency\n",
    "\n",
    "    if weight >= min_weight:\n",
    "        items_graph.add_edge(x, y, weight=weight, frequency=xy_frequency)\n",
    "\n",
    "                \n",
    "print(\"Total number of graph nodes:\", items_graph.number_of_nodes())\n",
    "print(\"Total number of graph edges:\", items_graph.number_of_edges())\n",
    "\n",
    "degrees = []\n",
    "for node in items_graph.nodes:\n",
    "    degrees.append(items_graph.degree[node])\n",
    "print(\"Average node degree:\", round(sum(degrees) / len(degrees), 2))\n",
    "\n",
    "#\n",
    "# Create a mapping between nodes and item Ids\n",
    "#\n",
    "vocabulary = [\"NA\"] + list(items_graph.nodes)\n",
    "vocabulary_lookup = {token: idx for idx, token in enumerate(vocabulary)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf3277b5-e8fb-4622-b09d-6e7ba6b22a27",
   "metadata": {},
   "source": [
    "# Step 3: Visualize the Item Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "id": "05daa0b7-25b0-48ed-950f-a6ced7c67b36",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAKaCAYAAAAZPRD5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAADHGElEQVR4nOzdd3hVVdbH8e9KCBCKNGkigh2wICKgCIo4AiqgoqKOOnbn1bG3mXHGMuOMOtaxj44FexkbIAiKDQs2QFHsWAAVBKTXkKz3j31u7k1IQoAk597c3+d5eCC3nLNuwO3K3muvbe6OiIiIiEg6yok7ABERERGR8ihZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRERERNKWklURERERSVtKVkVEREQkbSlZFREREZG0pWRVRESqlJnVMbMmZpYbdywikvmUrIqIyCYzs3pmdlwzs09yYE09+CUHCpqafWJmx5lZvbhjFJHMpGRVRGo1M+trZl/GcN9jzeylmr5vGXG8bmanVuH1rjGz80o91jMffuoDdz4AO68GWwV1V4ONgJ33hjvz4Scz61GFcTxrZoPW85p6ZvaZmbWpqvtWpZr4t2lmu5rZO9V5D5HqpmRVRGoFM/vezH5T+nF3f9Pdd6yG+3U0MzezOtHXZma3mdkXZtbO3R919wFVfd9SMfQ1s2XRr+VRPMtSfm1VxfdrCfwOuDv6uq6ZvWLw7kpofhU0PhSoE71+GfAc8BU0rgvN68DbqQmrmfU2s/fNbKmZTTOzPuXc94Hos22X8vC1wD/XE/LpwER3n1PqenWjv6fZpR7vaGavmdmK6Pl1/j1titKfobr+baZy92nAIjMbUp33EalOSlZFRDaRmRkhgesH7OvuP9bEfaNkp5G7NwJ2ih5umnjM3WdW8S1PBMa6+8ro67p1YM+rocypy/OBFcD3wEfA5pCXB69FM57NgVHA9UBT4DpgtJk1S71GlMBuW/ra7v4+sJmZ7VFBvL8HHi7j8YuBX8p4/HFgKtAC+AvwdJSgr1fih5Y09SjheyGSkZSsikitZmb9UmfQzKxztDS+yMymm9nQlOdGmNkdZjYmmu17z8zWSZRKyQVGAHsA/dx9bnStE83srZRru5n9n5l9bWYLo/tY9Fyumd1oZvPN7DszOyt11rYKdDCzt6PP9JKZbZ4S155m9k70/fjYzPpVcJ0DgTdSvj60FxT+KfomlDYauARoAHQEzgbqQ33gCKA3MNfd/+fuhe7+CDAPGJYSWx3gNuCscuJ5HTi4rCeiWeVtgfdKPb41cBxwTanHdwB2B65w95Xu/gzwCXB4Ode/0syeNrNHzGwJcKKZ9TSzSdH38mczu93M6kavnxi99eNo1vuoMv5tfm9mF0WzzIvN7Ekzq5/y/CXRdX8ys1NTZ2rN7CALJQ9LzexHM7uo1Pdpf1PdsGQoJasikjXMLI+QQ70EtCLkT4+aWepS7DHA34BmwDesf6n5UaAT0N/dF6zntYOBHkBXYDgwMHr8NEIiuBshYTq0Uh+o8n4LnET4zHWBiwDMrB0wBvgH0Dx6/JkKZhN3AYprLJvCHy+CxhXd2Ev9uQhym8CfAIt+pTJg55Svzycs408r5/KfE76X5cX6rbuvLfX4bcClwMpSj+8UvX5pymMfk5yxLsshwNOEmeFHgcIo5s2BvYD9gTMB3H2f6D1do1nvJ8u55nBgELA1sCthNhsL9bkXAL8BtgP2LfW++4Dfu3tjwvfw1cQT0Ux/AVCtJQci1UXJqohkkz2BRsC17r7G3V8FXiAkqAnPuvv7UZLzKCGBrMgA4Cl3X1SJ+1/r7oui5fnXUq49HLjF3We7+0JCPWZVesDdv4qW759Kue9xhGX9se5e5O4vAx8CB5VznabAUgizwUtgp8EV3HQQ4YMsJWT99xMypqUhAXwX2MLMjjGzPDM7gTAT2iC6fnvC0vXlFdxiaRRThbEmmNlhQB13f66M1zcCFpd6bDEVJ+OT3P356Hu30t0nu/u77r7W3b8nlIaUTirX51Z3/8ndfyX8YLVb9Phwwt/jdHdfQfiBKlUB0MXMNnP3he4+pdTzFX2vRNKaklURySZbALPcvSjlsR+Adilfp27GWUFIYioyGLjCzE6uxP3Lu/YWwKyU51L/XBXKu28H4Mho2XqRmS0C+gBty7nOQpLJW6M8KKioTuFWIB/YnjAFeQywJZAHa4E10cMXAHMJue0EILEs/m/g7+5eOoFM1RhYVIlYMbOGhLrYs8t5/TJgs1KPbUaphLeUEn9PZraDmb1gZnOi0oCrCbOsG2Jj/40cTvgh4wcze8PM9ir1fEXfK5G0pmRVRLLJT0B7M0sd+7YCNmVD1DvAEOAWM/vtRl7jZ0Iel9B+E+LZELOAh929acqvhu5e3szuNGCH6M8N10Be6TX2VM0JU9NzgOlAEaEGoiA0DFjm7m+4ew93bw4cT1imfj96+/7A9VHil0jgJpX6HncmLNWXF+s2KXW/2xNKZ9+Mrvcs0Da6fscoxG3MLHUmtWv0eHm81Nd3AV8A27v7ZoRyg9KlDhurwn8j7v6Bux9CKPV4njCDDoCZbUEo/6jxFm4iVUHJqojUJnlmVj/lV+mJv/eA5cAl0dJzP0Ki+cSm3NTd3yBsDLrHzI7YiEs8BZxrZu3MrCnwx9Qno808r29KjOV4BBhiZgOjTV71o00/W5Z+YbQZbCpwnpm9B0xvDEueA1ZFr1kT/TmRwc0AFhAKOV8E7iEUcjaG6e5eaGbdor+HzYAbgNnuPj56+w6EZHE3kkvhQwjdsBL2jS69DnefDXwN9Iwe+pSQ4CWudyphRnc3wmz7V4SmBVdE34fDCDWjz5T73VtXY2AJsMzMOgFnlHp+LrDNBlwv1VPASRY2CDYgpTzCQiuuY82sibsXRDEUpry3H/Cqu6/eyHuLxErJqojUJmMJG2cSv65MfdLd1wBDCZuZ5gN3Ar9z9y829cZRvedRwAjb8J6W/yVs+ppGSAjHEpbKEwlHe+DtTY2xNHefRViKv5SwE38Woa1TDhQ31R9oZrcTOlAdSdhMdiXQegmcdTx4PmFqeiBh2f+H6PqTCbucGgN/JsyyPgVLFydrci8h/D3MIpQeHJYS2y/uPifxK3p4fqJtloV+rcujFlbluZswY0tUR5p6vV+BoujrxPf5aEJXh0Td8BHuPq+S304IG9R+Sygd+C9QehPVlcCDUcnF8A24Lu7+IqGy4jVCCfCk6KlEAno88H1UfvB/hHrkhGOB/2zI/UTSibmXXsUQEZE4mdmBwH/cvUP09UfA/pXoNlAV925JaAc1hLAUP52w0Wc08BmhO8Iv7v5vM6uXDz89Ac2HlnvFpFHA0fDrSthiU2f5zOwZ4D53H1vBa+oRkv/93f3nTblfujGzzoTZ4npldDxIfd0uwD3uXrqGVSRjKFkVEYmZmeUD+xFmV1sTlp7fdffzauDeRtidPyT61YWw0Wk0oVNAhTOLZtajAbz2ODSsKGGNEtVVK2Efd/+gisLPKlFpwhigIfAgYWb40FiDEqkBSlZFRGIW1SC+QVhiX0lISM519yXVdL+6hHrPIYRuBjkkZ0/f2NBZTzPrkQ/jdoe8C6HxEMIOqrXRBW+ApVOBleGz7Zo4OEE2jJmNI5T9FhL+vZxZ22aMRcqiZFVEJAuYWQtCa6OhwAGEhvqJBPVT38T/GURL7kc0gT8thZ3ywArAG8Oni+FfhOb5lxKS5N9UtHQtIpJKyaqISC0ULe93Irm8vyvhVKPRwJjqnN00s1zCxGqdlM1LicdfAD5z9wur6/4iUrsoWRURqSWi42T7kkxQ65GcPX3N3VdV8PaqjsXdfZ0eo2bWnHBK1p8rOHJURKSYklURkQwWJX8HEpLTAYS2RokE9eNNXd7fhLjKTFaj57oRNpP1c/eKmu6LiChZFRHJNGa2I8nZ026E3puJ5f202HBTUbIaPf874C9Az/UcqSoiWU7JqohImotO4tqbZILaiFD7ORp4JdEoP52sL1mNXnMn4TCAw929qGYiE5FMo2RVRCQNRceuDiIkp4MIJ0gllvenxLW8X1mVTFbrElowjXL3a2omMhHJNEpWRUTShJltR3L2dA9gIiE5fcHdf4wztg1VmWQ1et2WwPvACdGRtSIiJShZFRGJSbS8vxfJBLUpJZf3l8cX3aapbLIavbYf8ATQy91/qM64RCTzKFkVEalBZtYEGEhITg8EZpFc3p9cW2o3NyRZjV5/IXAM0KcmW2yJSPpTsioiUs3MbGuSs6e9gLdJLu/PjDO26rIRyaoRZleXuvup1ReZiGQaJasiIlUsOqmpF8kEtSUwhpCgvuzuy2IMr0ZsaLIavacRoX71Jne/t3oiE5FMo2RVRKQKmFljQlP+IcBBwBySy/vv15bl/cramGQ1et+OwJvAwe7+QdVHJiKZRsmqiMhGMrMOJGdP9wImkVze/z7G0GK3sclq9N7DgH8De7j7vCoNTEQyjpJVEZFKMrMcoAfJBHULksv7L7n70hjDSyubkqxG77+G8L0e5O5rqy4yEck0SlZFRCpgZg2BAwjJ6cHAApLL+++6e2GM4aWtKkhWc4FxwIfu/ueqi0xEMo2SVRGRUsysPTCYkKD2IWz6GQ2Mdvdv44wtU2xqshpdoyXwIXCeuz9XNZGJSKZRsioiWS9a3u9Ocnm/PfAiIUEd7+6LYwwvI1VFshpdpweh1GIfd/9i0yMTkUyjZFVEspKZNQD2B4YSlveXAKMICeok1UlumqpKVqNrnQpcQDjhSnXBIllGyaqIZA0z24Lk8v6+wGSSy/tfxxlbbVOVyWp0vf8CTYCjXP/jEskqSlZFpNaKTkXqRnJ5fxvCpp3RwDh3XxhjeLVaNSSr9Qn9V59w9xur6roikv6UrIpIrWJm+UB/QnI6GFhBcvf+2+5eEGN4WaOqk9Xomh2A94Cj3f31qry2iKQvJasikvHMrA3J5f39gKkkl/e/jDO2bFUdyWp03d8ADwE93X12VV9fRNKPklURyTjR8v6uhOR0KLA98BIhQX3R3RfEGJ5QfclqdO0/AYcC+7r76uq4h4ikDyWrIpIRoprFfiTrTwtILu+/6e5r4otOSqvmZNWAZ4Gf3f3M6riHiKQPJasisiEaAL8hJItdCb1IrweWVcfNzKwVoa3UEEKbqU9IJqifa1d4+qrOZDW6/mbAB8DV7v5gdd1HROKnZFVE1qcdoR70t0AvYDXQGDDC5qXVQE/gm029UTRjtjPJ2dPOwMuE5HSsu8/f1HtIzajuZDW6RxfgDWCAu0+tznuJSHyUrIpIaQbsTqgJPBrYEigEGpbz+rXA48DvNupmZvUIPU8Tu/eNZHP+iapJzEw1kaxG9xkOXAvs4e6/Vvf9RKTmKVkVEYB8wjL7kYQNS3WAekBeJd+/HGhKSFzXKzrz/SBCgvob4HOSy/ufank/89VUshrd60agCzDY3Qtr4p4iUnOUrIpkr7aEetDfAr0pubxfrhUrVtCgQYPSDy8hJLlvlPWeaHm/M8nl/V2AVwjJ6Rh3/2WjP4WkpRpOVusAEwgz8ZfXxD1FpOYoWRXJHkbYFHUIcAzQkTATWt7yfrFvvvmGkSNH8sorr7B69WqeffZZmjRpkvqSQuBO4Jzim5nlAfuQTFDzSM6evu7uq6riQ0l6qslkNbpfa+BD4Ex3H11T9xWR6qdkVaR2q09okn8EIUmtB9SNflXarrvuSn5+Pv/5z3/o2rUrOTk5uDthwrTYz2a2C3AgITkdAHxFMkGdpuX97FHTyWp0z72AkUBvd9/kDX8ikh5y4g5ARKpca+Bkwi76hcATwIlAC6ARFSSqr7/+Ovvttx9nnnkm8+bNK358+PDhdOvWjW7dupGTk0NhYWHpRJVVq1a17tSp0w+EuteXgS7u3svd/+HuHytRlerm7pOAK4FnzWy9KwYikhnqxB2AiGwyI9SAJpb3t6Hk8n79ylxkyZIlfP7552y++eYsXbqUH374gZYtWwLw29/+lu222w4z47PPPmPIkCGcfPLJNG/evPj9eXl5aydPnvzPBg0aXFOFn01kQ91FaLF2j5kdpx+SRDKfZlZFMlM9wjL7PcAvwDvAXwibmOpRiTrUhKKiIgAaNmzIMcccw8MPP0zdunX5/vvvSfx/fptttuGoo45il1124bHHHuOVV17h1ltvZeHChcXXyc3NrdugQYPhVfT5RDZKlJz+H6E7wNkxhyMiVUAzqyKZI9Hu6RhCX9I1hGX9Cn/oXL58OW+88QZdu3alXbt2uDtFRUWYGTk5OeTkhLfn5ubStGlTALbccku++uorFi1aRLNmzQB47LHHipf+//jHP3LHHXdQUFBQ+nZdgOaA+l1KbNx9pZkdDkwysynu/lbcMYnIxtPMqkj6MmAn4M+EY0ZnA7cDAwlL+5uxnv+GFy1aRL9+/Xj22WcBijdF5ebmkpOTw5o1a3jmmWe47bbb+Omnn4rf17NnT3744Qdmz56dDCalRrVBgwYsXry4OLlNsZqwwUokVu7+LaFW+0kzaxtzOCKyCTSzKpJe6hLaPR0ODCMs5yca9Ceer7QVK1bQuXNnDjroIFavXo2ZMXPmTEaPHs348eP56aef6NSpE6eccgpt2yb/f96tWzeeeOIJlixZUvzY3Llzefjhh5kwYQI//PAD11xzDXXrrhNOY8LJV49u2McWqXru/qKZ3Q08ZWb93X2dpQARSX9qXSUSvxaE2cijgf5AASFJza3oTUVFRcVL+OW5+eabueyyy2jRogX//e9/6dChA+eccw7du3fniCOOYPfddy9OXtu2bcuwYcOK33vRRRexfPlyli1bxsUXX8yOO+7InXfeSZcuXRg4cGBFt/2cUA4gWSyO1lXlxJFDaGf1rbufG3c8IrLhNLMqUvMM2JFw4tNvCZuiEqdHQTj6tExr1qzhqaee4q677mL33Xfn2GOPZc899yw3cT3wwANZsWIFa9asYcCAAQCMHz+eDz74gP/973/84Q9/oH79+uy5554MGTIEgFWrVnHbbbdx880306NHD/r06UPLli2pV68e559/fvG1y7nnKuDFjfu2iFQ9dy8ys+OBD83sPXd/LO6YRGTDaGZVpGbkAX0Iy/uHk6w3XW9bqYULFxZvcpo0aRJ/+9vf+Nvf/sa8efO47bbbuPfee2nfvn2573/xxRd59tln+fOf/8w222zD9ddfz9tvv82BBx7IIYccQps2bUq8vqioiGnTptG2bVtat269zvXKOAwgYS2wEtgKWLS+zyW1W7rMrCaY2a6EI377u/sncccjIpWnDVYi1acZYef+KELy9jyhpU4boAEVJKrvvfcexx57LN27d+fMM89k3LhxAHz22Wd06NCBXr16MXjwYLbYYgseeeQRVq9eDUBZP3y2a9eO/Px8pk2bBsAFF1zA888/z+9//3vatGmDu1NYWFj83pycHHbbbTdat25NUVFRcWurhFKJaiGwBFgBPAnsgRJVSUPuPg04j3BgQNN4oxGRDaFkVaRqbQ9cCEwG5gB3E44ebUCYTa2wDhVg9erVvPzyy/Tq1YsXXniBY445hiuuuILFixfToEED3J2ZM2cC8OuvvzJt2jS+//57YJ1EEoD27dvTpk0b3nvvPSC0qCoqKqKwsLD4Pbm5uWW+N7W1VYpVhOT0J+AOQjlDE+A4wvGqImnJ3R8llKk8FNWyikgGUM2qyKapA/Qm7Nw/gjCbmrq8X+7u/Y8++og5c+YwaNCgEo/Xq1ePI444gk6dOgHQt29ftt56az7//HMOPfRQpk6dyllnncWiRYto164drVu3ZsGCBQB89913rFmzhh133LH4es2aNWPbbbfll19+oaCggLy8vPVuzCrD0uizfA48Rpgt/nJDLyKSBi4CXgUuBf4RcywiUgmqWRXZcE2AQcBRhFOkCqnE7v2ExMaknXfemSZNmvDwww+zzTbblFsL+vbbb3Pdddfx5JNPUr9+fQoKCnjzzTdp06YNXbp0oU+fPjz77LO0atWKc845h912240TTjiB3NxKhVOeQmA5odb2FeAJwoyUmv1LpaRbzWoqM9sC+AA4xd3HxR2PiFRMyyAilbMtod7tA8Lxpv8FDiMkqeUu7//888+MGDGC3r178/LLLwNhaf31119nl112oU+fPsXL8+WZPHky7du3p379MFmbl5dH//796dKlC7Nnz6Zly5bFS/oNGjRg4cKFxUv9qSrxg+lqwvL+XEL5wmGExHwIoW+qElWpFdz9J0KruAfNbOu44xGRiilZFSlbLrA3cAMwk3CC1NWEDUR1SbaZKtPUqVM55JBDGDx4MBMmTMDdmTFjRvHzq1atokWLFmy77bZ8/PHHQNn1pkuWLOG+++7jiiuuKPH4888/z5577skBBxzAYYcdVtzQf/DgwXTs2BFgnaX+cnbwLyMc2zoNuCL6fG2BPxCWStVEXWold3+T8N/0M2ZWbrs4EYmfalZFStoduAQ4GCgibIyq9H8niaX8du3a8c9//pOdd94ZgFNOOaX4zwD33HMPd955J9OnT+fzzz9n0aJFxUeXpvYvfeCBB9h///1ZsmQJN954I1tvvTW///3v6dixI5dccglDhgwhLy+v+Lp9+vRZX4hFhAS1LvAa8DhheX9+ZT+jSC1yK9ALuNPMTnbVxYmkJc2siiQdBLwFHAk0IizvVypRTbR/SmjVqlWJ5PSVV16hceMwGbtw4UI6derEmjVr+PLLLxk9ejRDhgwpLgdIJKqLFy/mgQceYMSIEZx22mnUrVuXfv36AbDbbrsxbNgw8vLy1lnuL8NqQv3pPEL5whGE5f2DgIdRoipZKkpOTyOsKPw+5nBEpByaWRUJcgltmNa7HJiYPXV3ioqKits+JTY0rVixgry8PPLy8nB31qxZQ8+ePfnuu+/o2rUrU6dOZezYsTzyyCNstdVWbLfddnTr1o1evXqxYsUK7r77bnbZZRd+85vfcOmll7LvvvuW2Zw/oZyd/csIm6O+IcyejgSmA5o5Eknh7svNbBjwtpl95O7vxh2TiJSkZFUk2BFoVdYTRUVFmFlxzWfq74kE9YsvvmDkyJGMGjWKzp0787e//Y127dphZnz//fcUFRWx7bbbAtCzZ09uu+029thjD/Lz83nqqacYN24cy5cvp2HDhgwcOLC49dTw4cOBkCC7e0Utp1KX9ycSEtSxhM1gIlIBd//azE4B/mdm3d1d/92IpBG1rhIJGhJOXqoDZR8pmuhRescdd7D55ptzxBFHcMEFF/Duu+/SqFEjDjzwQIYOHcoOO+zAkiVL2GyzzYDQ5H/77bfno48+onnz5utce8aMGdSpU4cOHTqUqFethDWEDVCrgOeAp4HXCcv+IrFK59ZV5TGzqwjHIh/g7mvjjkdEAtWsigTLSWlyn0gmCwoK+PXXXznllFP429/+BsDMmTNp1KgRq1atol+/fowbN44XX3yR3XbbjX//+9907dqVZ555priGdenSpbRv355vv/22xLUTtt12Wzp06ACUu6RfOs7VwBeEhua9gZaEurvxKFEV2RRXEv4buibmOEQkhcoARJIeBy4D6hUUFHDdddexxRZb8Nvf/pYpU6bQokULFi5cyM8//8zmm29Ow4YNadKkCaeccgrff/89Xbp0YejQoVx77bXFs6oQTpU64YQTiltKbSAneXrUO4TTo8YQjnIVkSrk7oVmdizwoZm97+7/izsmEVGyKpJqJPBnoF5eXh79+vXjmmuuYfjw4XTv3p2FCxcybdo0vvnmG77//nt69eoFwPnnn0/fvn1LXChRXmNm9OjRgx49emxIHGtILvGPBP5H6Hm6ahM/n4ish7svMLPDgfFm9qm7fx53TCLZTsmqSNJ0d19hZg0B9t57b5o0acLtt9/OXnvtxZIlS5g7dy7z5s1j1qxZAPTv37/4zYWFhZgZOTk56yz1l3eUaorlhP8efyAcbfo88BHavS9S49x9ipldDDxnZj3dfUncMYlkM9WsStYzs5ZmdqKZPX3fffc1KSwsLE4QzzzzTN544w1efvllBgwYwM4778yMGTNK9FRNzKLm5uaWW3NaRqLqwBJCfdzrwPnANoSuBFcAU1GiKhIbdx9B+G/zAVvPT5oiUr2UrErWsWAnM/uTmb1N6EU6BBjdvXv343Jzc5cmXtu7d28OPvhgnnrqKfLy8ujSpQt33HEHRx99dOr1KnvrAkJ7qUXAI8CxQHNgP0Kz/p+q4OOJSNU5F2hHONVORGKi1lWSFcysLrAPISkdQlhyHwWMBl5398Qu+rrAYqB+4r1Llizh6aef5sgjj6Rhw4Yb0loKYAXhwIHZJJf3pxD6oorUWpnYuqosZrYl8AFwnLu/Enc8ItlIyarUWmbWgnCk6BBgAKE11ejo17QKzgEfCxxY0bUrqEFN7N6vB7xP2L3/AiFZFckatSVZBTCz/Qj/Lfdy95lxxyOSbZSsSq0R1ZV1Ijl72pWwi340MMbdK9vu6XeEo1cbVfL1icb8TkhMnwImEDZNiWSl2pSsAkQbro4E9nF3deYQqUFKViWjmVke4cSZoYQEtT7J2dPX3H3lRly2OWEmNL+C16wg1Hz/THJ5/0O0vC8C1Mpk1Qg/iC5099PjjkckmyhZlYxjZs0Iy/RDgIHADJIJ6kcVLO9viH8DpxKOYYXk8n59YDLwKGEW9YcquJdIrVPbklUAM2sMvAfc6O73xR2PSLZQsioZwcx2ILm8vzvwBmGD1Bh3r45d9AYMAm4kzLC+S2jO/zIhaRWRCtTGZBXAzDoBE4GD3P3DuOMRyQZKViUtmVkdYG+SCWpjwkzmaOAVd18RY3gish61NVkFiE64uhHYw93nxx2PSG2nZFXShpk1JcxmDol+/4Hk8v4Ud1c9qEiGqM3JKoCZ/YuwyjPI3QvX93oR2XhKViVWZrYtydnTnoTltdHAC+6udk8iGSoLktU6wHjgXXf/S9zxiNRmSlalRplZLrAXyQS1Ocnl/QnurnZPIrVAbU9WAcysFaELyNnuPjLueERqKyWrUu3MbDPCrv0hhCb9PxKS01HAh1reF6l9siFZBTCznoQfuPu4+1dxxyNSGylZlWphZluTnD3dE3ib5PK+2j2J1HLZkqwCmNnpwLmEE66WxR2PSG2jZFWqRLS834tkgtoKGENIUF92d7V7EskiWZasGnAvoS/zMVXU61lEIkpWZaOZWSNgACE5PRiYS3L3/vvaISuSvbIpWQUws3zgLeARd7857nhEahMlq7JBzGwrkrOnexOa5Y8iLO9/F2dsIpI+si1ZBTCzjoQx8Sh3fyPmcERqDSWrUiEzywF6kExQ2wFjCbOn4919SYzhiUiaysZkFcDMBgAjgB7u/mPM4YjUCkpWZR1m1hA4gOTy/q8kl/cnaXlfRNYnW5NVADO7FBgM9HP3NXHHI5LplKwKAGa2JcnZ077A+0QJqrvPiDM2Eck8WZ6s5gDPAbPc/ay44xHJdEpWs1Q0mO5OMkHtALxIcnl/UXzRiUimy+ZkFcDMmgAfAFe5+8NxxyOSyZSsZhEzawDsT0hOBwNLSS7vv+3ua2MMT0RqkWxPVgHMbGfgNeAAd/8o5nBEMpaS1VrOzLYgJKZDgH2BKSSX93XaiohUCyWrgZkdDfwT2MPdF8Ydj0gmUrJay0TNqbuRXN7fFhhHSFDHufuvMYYnIllCyWqSmd0M7AAM0fHSIhtOyWotYGb1gf7AUMIs6ipC79PRwFvuXhBjeCKShZSsJplZHjABeM3dr4w5HJGMo2Q1Q5lZG0JbqSGERPVjkvWnX+i4PxGJk5LVkqIx+0Pg9+4+Ju54RDKJktUMES3v70pyeX9H4CVCcjrW3RfEGJ6ISAlKVtdlZr2B54G91BJQpPKUrKYxM6sH7Edy934hydnTiWo2LSLpSslq2czsLOBUoLe7r4g7HpFMoGQ1zZhZK5LL+/sDn5JMUD/T8r6IZAIlq2WLVskeir78ncZ0kfVTshqzaODaiZCcDgW6EArxRxGW9+fFGJ6IyEZRslq+qOf1O8C97n573PGIpDslqzEws7qEnqeJ+tMckrOnr7v76hjDExHZZEpWK2Zm2xIS1sPc/Z244xFJZ0pWa4iZbQ4cREhODwC+IJmgfqKlIBGpTZSsrp+ZHQzcTTgwYE7c8Yikq6xPVs2sDtAQWObuhVV4XQM6k5w93RV4hZCcjnH3uVV1LxGRdKNktXLM7EpC+8H91RNbpGxZmaxGu+yPbAp/XAI75UFBAeQ1humL4V/A/zZmKT5q/LwPyQS1LsnZ09fcfVXVfQoRkfSlZLVyzCxRBvaVu58fdzwi6ShnfS8wsyvN7JEKnv/ezH4T/flSM7t3Y4MxswFm9vzGvr+S9+iZDz/1gTsfgJ1Xg62CuqvBRsDOe8OddeBXMxtRiWs9bmbHmdmxZvYE8AtwLfArcDiwlbuf6e4vxpGomtkyM9umGq9fz8y+iDoYiIjIBoqOXz0OGGpmR8cdj0g6Wm+yuiHc/Wp3P3UTLnE1IdkDwMyuMrNPzGxttFRCynNmZn8xs5lmtsTMnjCzzVKeb2dmI83sVzObbWb/Z2Y9GsCrN0Lz5tD4NKAVMBCYARwKvAWNH4cGBr8zswFlBWlmO5rZjYTd+3cCRwGzgTnA9sC5wBXAFinvGWFma6IEMvErdxO+V6Vjet3MSnzv3b2Ru39bVfcoLZp9vh/4Y3XdQ0SktnP3hYQJjtvMbOdyXrYD8CwwFrgR2LqGwhOJXZUmq5vCzHoATdz93ZSHvwEuAco6mu53wPHA3oSkMB+4LeX5R4DvgNaEvqVX14UJj0PD7oQs80tgLtATOCTljUcAvwGrA89Fs4d1zKyfmd1oZl8BrxJy3GeA1u4+FLieUHPUNIrna+CuUjFfFyWQiV+VqpGN6mrT1WPACVFphYiIbAR3/wi4AHjWzJqUevo0YCrhf10HAucRjm7dtgZDFIlNhcmqmb0MbF7qsePN7AczW2Bmfyn1XHHJgJl1NDM3sxOi2c/5pV9fyoHAG6kPuPuD7v4isLSM1w8B7nP3We6+jFBrepSZNTCzRkA/4J/uXuDuHwMfbQb5QwnJ6SlAcyAPOJ+QuKaeV3oC0ADqExLTXwg/yS4FjgG2DE9zj7uvjGKd6+4/pVyiENiugs9brigxnm1mfzSzOcADZtbMzF4ws3lmtjD685bR6/8J9AVuj2Zsb48edzPbLvrzCDO7w8zGmNlSM3svap2SuOcAM/vSzBab2Z1m9kZiptbMtou+Xhz9PT6ZeJ+7zwYWAntuzGcVEZHA3R8mHKP9UFTLWh94GPg34f85idW4HKBp9NqGNR6oSA1b38zqVYS8DQAz60KYLTyeMHvYgpC4VaQP4Rz7/YHLzaxzOa/bhZAzVpZFv1K/rkdYhreUxwDIg90ah9x0HROBNoQPk9AZKIKczaAjsIu7d3f3K919MmHQ2Lp0vGa2lZktAlYCFwHXlbrVmVFZwmQzO3w9n68NIZ/uAJxO+Lt6IPp6q+getwO4+1+AN4Gzohnbs8q55jHA34BmhFnrf0Zxbw48Dfw5+jZ8CfROed9VhEGxGeHvO3UGG+BzoOt6Po+IiKzfBUDLXr16XQNMIZQHNCjjdTmE/w8/TMn/F4rUOhUmq+4+kbBLMeEI4AV3nxjVK14GFK3nHn9z95XR7ObHlJ/UNKXsGdTyvAicGs3gNiFZN9nA3ZcCbwOXmVl9M9ujAJqVlanOBv4A3FTq8cbACmAZtCXUopaOldLxuvvMqAxgc+CvhF6qCbcSEulWhO/bCDPbu4LPVwRc4e6ro+/fAnd/xt1XRJ/vn4SDBTbEs+7+vruvBR4FdosePwiY7u7PRs/dSsnPXEBIkrdw91Xu/lap6y4l+T0REZGN5O5r3n777Vtefvnli4uKinYglLiVpz4wgLBPQqTWqkzN6g8pf94CmJX4wt2XU3L1vCypSc8KoFE5r1tIyBEr637gceB1YDrwWvT47Oj3Ywmzn7OA/+RAUekp4HmE/8rPJEw5ploKNAHyYG0ZMS+Kfi8zXnf/FXgQGJmoN3X3KVHCudbdxxKSxWEVfL55qR0EovKGu6MSjCWECeGmG7hJq7y/i9J/r07y+wihbtiA981supmdXOq6jUl+T0REZOMY8NfevXs/0LhxY8vJySlzfC/VcrIhYXNynxqITyQWlUlWt0r5889A+8QXFs43brHOOzbONMJux0px9yJ3v8LdO7r7loSE9cfoF+7+g7sPdveWQK8iyNkj5f0LCYnqUKCsQtrPCV38C6AOpWaPoyR9xnrirUOYRd2snOedipduSjfAvZBQTtHL3Tcj9HMl5Rqb0jD3Z1LKOczMUr929znufpq7bwH8HrgzUQsb6UyYNRcRkY2zGWGn/58oYzZ1xYoVvPjiiwCEIbqEfGAUYSVQpNZZ3warPoSNTAlPA4PNrI+F8+3/vr5rbICxlFrWNrM8M6sf3aNOtKSfGz3X3My2jVpYdSGs5P896lmHmXU2s8ZRnMcYFHaJrruEsJV/b1L6ZJXyBiFLbxhmIH8ys7FmdoaZJZL1EvGa2bCopVWOmbWM4pkazbJiZkeYWaPo+QGEvnqjNuD705hQp7rIzJoTWmOlmgtsbE/VMcAuZnZoNBP8B0LNbOKzHZnYzEXI852wgQwza0eorX0XERHZGC2Bjwgbg8vcMPXqq68yduxYFiwodzGzEWEsL3NvhkgmW1+ieQXwUOILd59OSGQeI8zGLaTkcvFGc/cpwGIz65Xy8H8JCdoxhAnQlYTNXRDqQscCywn1q/e7+z0p7x0IfBvF+H8Of/tvVGP6HPABYbdSo5RfM6M3roou/DksWxpmEtsTlvX3Bj4ys6mEAeGUaMcmQDtgHOEenxBmYw9LiedcwqzvIkKbq9Pc/fUN+Bb9m/DT83xCYjiu1PO3AEdEnQJu3YDr4u7zgSMJG8IWAF0IbVESp3j1AN4zs2WEBPtcd/8ueu63wIMbc+KXiIgA4f+zWxJqUNcxbtw4/vrXv3L00UfTqFEj5s2bB0BRUYlFvzzC6lvpDbAiGS+tjluNZhzPdPdDq+Ha9fLhpyeg+dD1vPY2QgHsOPh1ZdhUVJyIRTOPvQkzzqcTZhifIWxEm+DuK6o69poWJeCzgWPd/bUKXlePsPy/j7v/UlPxiUj6Mx23uiF+JOUQmVTvvvsul156KRdffDE77rgj5513HqtXr+a5556jQYOymgSwgtCX9bFqjFekRqXNoQAA7v5SdSSq0bVXr4RBx8Dy9a29dwDGw/KVMKj0jGG0QWqiu1/s7k2AXoQS1/OBuVH/09PNrMyBJ12Z2UAzaxoloJcSamErXNqPOhV0UqIqIrJJmpX14LJly7jjjjtwd7777jtOPPFEpk+fTteuXcnPT5a1lpp0agDcQ2gHKVIrpNXMak0wsx75MG53yLsQGg8h7IRaS5gavQGWToWCKFH9YAOv3YxwuMEQkmUIo6NfUz2Nv9kWjrM9G6gLfAac4+7vxRqUiGQszaxukLuAEylVBrBgwQJ23HFHzj77bPbcc0++/vprtt12W/r168dXX33F/Pnz2X///cu6nhNK9XZCnVqkFsi6ZBWKl6+PaAJ/Wgo75YEVgDeGTxeHk7Ce3tQaTDPLI7QSGRL9ygdeICSuryZOvhIRqY2UrG6QzQgdbdoRdXgpKioiJyeH5cuX07BhQ2bNmsVTTz3FwoULmTFjBm3atGHVqlVcd911NGzYkJycdRZKVxP6jR/A+vuhi6S1rExWU0XdBdYCddy9sJruYYTC90TiuhuhLHY04ZCF0ocOiIhkNCWrG6wLYe9viULUtWvXMm/ePHr27MmKFSvYaqutuPLKK+nZsydt2yY7VSWS21KWE44KL909RiSjZH2yCjU/qJpZC5LlAgOAr0mWC3yczuUCIiKVoWR1oxwJjKCM41VvvPFGWrRoweGHH07jxuE8mrFjxzJy5EjuvvtuINSultGDdSXhAJrSHWREMoaSVeIdVKM+sH0J5xMkSmgTievrqadYiYhkCiWrG+1W4BSihLWsBHTu3Ln8+9//5pprruHwww+nb9++nHfeeeUlqxBaKnYFvivrSZF0l1bdALKRu69x91fc/VxgW8KM6yzgMkJ3gWfN7CQzaxVroCIiUhMuIGxyLYB1T6tyd1q3bs3SpUu55JJLePDBB3n88cd54403MDMKC8usZmsAjKeMk7FEMoFmVknfGYDoJKyDCDOuBxAGsMSs66cqFxCRdJWu42qGaE3YcLXOceaptakDBw7kpJNOonPnzpx66qmMHTuWli1bVlQOMIpwyI7+3yEZRckqmTGoRh0M9iW5SctJdhd4QydIiUg6yYRxNc3tBbxCGbOhhYWF5Obm8vPPPzN06FAefPBBJk2axHvvvcc999yz7pWSlgOXAHdWT8gi1UPJKpk3qEbdBXYmmbh2BiYQEtex7j4vxvBERDJuXE1TZwHXAg1LP5FIWF988UUuv/xyJk6cyOeff06nTp3KO9kqYSXQn/Uc+iKSTpSskvmDqpm1Bg4mJK77A9NIlgt8rnIBEalpmT6upgkDniDZq7uExHL/qFGj2G233dhqq61YsGABixYt4vvvvycnJ4c5c+bQtWtXunTpkvrWBYQDA+bWyKcQ2URKVqldg6qZ1Qf2IznruoZk4vqmu6+JMTwRyRK1aVyNWT7wMbANkJv6RGpt6q+//srBBx9Mjx49mD17NkOGDGHUqFGMHTuWgw46iGeffTa1jrUAmArsTegzLpLW1A2glnH3Ve7+orufCWwFHE74KfoaQneBJ83suKjXq4iIpLeVwCBgReknUjdRNW3alJ9//pk99tiDZ599li5durB48WJuvPFG7rjjjtIbrvIIpWQ3VnPsIlVCM6tkzwyAmbUlWS6wH/ARYcZ1lLt/GWNoIlLLZMu4WoMOBJ6hjHKAtWvXUqdOHX744Qf2339/DjroIL788kuGDx/OEUccQZMmTViwYAFffPEFe++9d+pbVwAnAv+rkU8gspGUrJKdg6qZ5ROK7BPlAstJlgu87e4FMYYnIhkuG8fVGnAVcD5lbLhKGDRoEK+88gqjR49m0KBBxY+vWLGC/v37c/HFF3P44YenvmUF0IPQGlEkLakMIEu5+0p3H+Pu/wdsSei9t5SwLDTXzB4zs2PMrFmsgYqISMIVwHvAOq0K16xZw7Bhw+jUqROnnnoqK1euLH6uoKCABg0acMMNN3DTTTfx7bffpr41n3AU62bVHLvIRtPMKpoBKM3M2gGDCTOu+wCTiWZd3f3rOGMTkcygcbXaNCXMgrYhdAso9vXXX9OiRQuaN2/OypUryc/PL3GIAMAFF1zAhAkTmDZtWupbVwGvEw6hUVIgaUfJKhpUK2JmDYDfEBLXwcBikuUC77i7dpKKyDo0rlarXYFJhGNUK1RYWMj333/PXXfdRUFBAaNGjaJ///786U9/Yvvtt0996XLCRtx/Vk/IIhtPySoaVCvLzHKA7iTrXLcCXiQc4Tfe3RfHGJ6IpBGNq9XuOOBuyklYZ8yYwf3338+qVat46qmnGDZsGL169aJXr15su+225V1zJWFsf6V6QhbZOEpW0aC6scysPclygb6EWqpEucC3Fb1XRGo3jas14m5C0loiYS0sLKRv375svfXWDB06lE6dOtG1a9fi5xOlAYlTsEpZAuwCzKzm2EUqTckqGlSrgpk1Ag4gJK4HA/NJlgu86+6FMYYnIjVM42qNqEuYJNiJ0Du1+KCAxYsX06RJk+IXph4gUFqi9VXiS+ArwiraquoLXaTy1A1AqoS7L3P359z9ZKAtcApQCNwFzDGzB83sCDNrHGugIiK1xxrC5MCyxAOJhLRx4zDUrl27tsTjpU2bNo2LL7449aE6wNbAPVUfrsjGUbIqVc7di9z9XXf/i7vvSujh9wFwGvCTmb1kZmebWcdYAxURyXw/AYcQ6k2LJToA1KlTpzhhLcuuu+7KggULuOiii1IfziecfnhqVQcrsjFUBoCWq2pSNLM6gGS5wBzCBq3RwPvuXhRjeCJSRTSu1rjzCYcGrHNgwD333MPWW2/NAQccUOLxNWvWULduXQD22WcfzjjjDI455pjUl6wktC/8sLqCFqkMJatoUI2LmeUCvQiJ61Bgc2AMIXF92d2XVfB2EUljGldrnAHPAgMpdSTrsmXL+OKLL+jevTtFRUUlNlUVFhYyduxYRo8ezb333suPP/5I27ZtU98+D+hC2IcgEgslq2hQTRdmtg3Jtli9gLdIdheYFWdsIrJhNK7GoiHwCdCB9ZT5PfTQQyxYsID777+fdu3accABB9C+fXuGDx9e+qVrCDOr+xD2IYjUOCWraFBNR2bWhDBDMAQ4EJhNsrvAhyoXEElvGldjsz0wBWhU+olZs2Zxzz338Prrr5OTk8PgwYNp06YNxx9//DonXZWyArgTuLi8F4hUJyWraFBNd2ZWB9iL5KxrU5LlAhPcfXl80YlIWTSuxmoo8ASlygEAnnjiCZYuXcppp51Wos/q7Nmz+fzzz7njjjvo2bMnm2++OaeffnrqW1cAxwLPV3/4IiUpWUWDaqYxs+1IJq57ABMJiesL7v5jnLGJSKBxNXb/Av5AGRuuEgoLC8nJyWH69Ok89dRTfPzxxwwbNoyOHTty3nnn8de//pXDDz889S3LCGPul9UbukhJal0lGcfdv3H3m929P+HI10eAfYFPzGyymV1pZt2tvMaCIiK136WEcoA1ZT2Z2Gi1ZMkS/vGPf3D//fdjZnTv3p19992Xq6++mgcffJDVq1envq0BMI4ySgxEqpNmVtEMQG1hZnnA3iRnXRsCLxBmXV9x95UVvF1EqpDG1bTQAvgMaEnoFrCO3/3ud9StW5cbbriBmTNncvrpp/PCCy+w+eabM2/ePFq2bFn6LauAlwm9XZVASI3QzKrUGu5e4O6vu/uF7r4D0B/4mrApYK6ZjTKz08ysbcVXEhGpFRYQNqiW+YP68uXLqVOnDvfeey9NmzalWbNmbL755ixbFroGlpGoAtQnjK0XlfWkSHXQzCqaAcgGZtacMGgPIXQZ+IZkd4GPXP8hiFQpjatp5WTgNsIyfgkDBgygb9++DBgwgMmTJ/PVV19x/fXXk5eXt75rrgQOAl6v8mhFSlGyigbVbBOVC/QlWS5Ql2S5wGvuvirG8ERqBY2raecBYDhRwurumBlLly7lxBNPpG7durRs2ZKDDjqIQYMGVfaai4BdCK0FRaqNklU0qGazaBNWZ5KJ6y7Aq4TEdYy7z40xPJGMpXE17dQjNPfvBNQBinurLly4kGbNmpV48Xr6riasBT4ndAgocyOXSFVQsooGVUkys80JS1tDgAOAL0iWC3yicgGRytG4mpa2BD4FmpT15GOPPcbUqVO55JJLyqtXLcsK4HHg1KoJUWRd2mAlksLd57v7Q+5+JNAKuAxoDYwEvjOz281soJnVizVQEZENNxsYRhkbrv71r3/x2GOPscsuu5RuVwXAqlWrWLhwIStWrOCjjz5KfaoBcAxwQvWELKKZVUAzALJ+UbnATiTLBboAEwgzrmPdfV6M4YmkHY2rae1PwF9JOTCgrFKAVGPGjOGyyy6jR48ejB8/nr///e/87ne/S33JCqAPMLWaYpYspplVkUrw4FN3v8bdewM7EI58PQT4xszeNrM/mdlOOoxARNLcvwi7+Is3kzZt2hQItaqpvwN88cUX/PjjjyxdupSffvqJSZMm8csvv1BQUJB6zXzgRaB5NccuWUgzq2gGQDaNmdUH+pGcdV1Lss51ortr44FkHY2raa8xoX51S8qZuCosLGTSpEmMGzeOpUuXMnDgQB555BEefvhhli9fzmabbVb6LauBdwl9WIvWuaDIRlKyigZVqTrRrOquJBPXHYGXSJYLLIgxPJEao3E1I3QidAhoWPqJ1atX89xzz/Hee+9Rr149TjjhBDp37lziNYn2V6UsB24B/lJNMUsWUhmASBWKygU+dvd/uHsvwv8MxgOHEzZovWlml5hZJ5ULiEjMviBsjFpR+ol69eqxePFimjdvzuWXX07nzp0pKipi5MiRnHbaaQCYGWVMeDUEzgcGV3PskkU0s4pmAKRmmFk+sB/JWdeVJMsF3nL3ggreLpJRNK5mlJuB0yl1wlXqzOkvv/zCDTfcwHXXXcfw4cPZc889ueCCC8qbXQVYBnQjnBYoskk0sypSQ9x9pbuPdfczgPbAUcBi4Hpgrpk9bma/NbPyt+SKiFS9i4FplGrsn0hCi4qKaNWqFatXr+bCCy9kxIgRPPXUU7z66quYGYWFhWVdswEwjjKOeBXZUJpZRTMAEj8z24KwbDYE2BeYQjTr6u5fxRmbyMbQuJpxWgHTgc1LP5F6mtWBBx7IcccdR9euXTnxxBN54YUXaNOmTXknXq0ExgJHAko2ZKMpWUWDqqQXM2sA7E9IXAcDS0mWC7zt7mtjDE+kUjSuZqSehJZW+aWfKCwsJDc3l7lz5zJkyBDuv/9+PvjgAyZNmsQ999wDQEFBAfPnz6dt27apb11O2Gx1S/WHL7WVklU0qEr6MrMcYHeSda4dCL0MRwPj3H1xjOGJlEvjasb6PXATZSzfJxLWl19+mT//+c+8/fbbTJ8+nS5dulCnTh1+/PFHbr75ZnbccUfOOOOM1LeuBAYAb9XMR5DaRskqGlQlc5jZloTZ1qFAX+B9kuUCM+KMTSSVxtWMZcCjwKGUMcOa2FA1duxYOnTowE477VTi+csvv5xrrrmGb775hg4dOqQ+tZBwCuDP1Ra51FpKVtGgKpnJzBoCBxBmXA8GfiVZLjDJ3cvc9SBSEzSuZrR8Qt389kBu6hMV7P7n3nvvZcqUKXTs2JHjjjuOLbbYIvXpAuATYM/ozyKVpmQVDaqS+aJygR4kywW2IFkuMN7dl8QYnmQhjasZryPwMbDOMVVQctPV/Pnzue222/jxxx8ZOHAg++yzD61bty7rbSuAh4AzynpSpDxKVtGgKrWPmXUg2V1gb8IRiIlyge/ijE2yg8bVWmEA8DxllAN8+umnjBo1ipNPPpm///3v1K9fnyFDhtCrVy8aNAjlrkVFRXz11Vd06tQp9a0rgFOBx6s/fKktlKyiQVVqNzNrTMlygbkkywXeV7mAVAeNq7XGFYQ+rOscybrddtuRk5PDBRdcQK9evejatWuJ9lVLly5l4MCBnH/++Rx55JGpb11BWAn6rJpjl1pChwKI1HLuvtTdn3X3k4C2hJNqDPgv8LOZPWBmw8ysUayBikg6ugp4B1iVeKCoqAiACRMmsGzZMvLz8+nWrds6fVYbN27Mddddx5VXXsnXX3+d+lR94N5qj1xqDSWrIlnE3QvdfZK7/9nddwZ6AVMJNWQ/m9k4M/uDmW0Vb6QikiaKCE39FxA19s/JyaGoqIiOHTty44038v777wOwZk04AMvdefLJJ5kxYwZ9+vTh0EMP5a23SnStygF2q8HPIBlOyapIFnP379z9Vnc/AGgH3EdIYKeY2cdm9g8z6xVt4BKR7LQYGETolwpQPIt6zDHHcMcddzB37lyWLl0KhGNaZ8+ezd57782tt97Kf/7zHzp27Fj6mr/USORSK6hmFdVWiZRmZrnAXiS7CzQDxhDqXCe4+/IYw5MMoHG1Vjqa8APtOgcG3HzzzcycOZObb765+LEjjjiCPffck+23355DDjkk9eUrgAeAs6o5XqkllKyiQVVkfcxsO5KJ6x7Am4TE9QV3nx1nbJKeNK7WWncAJ1IqYV21ahX9+/fnoosuYsiQIfzzn//k66+/5tFHHy39/uXAKOB4QJs7pVKUrKJBVWRDmFlTwpLgkOj3H0h2F5ji7kXxRSfpQuNqrZUHTAJ2jf5c3HN1ypQpXHzxxSxatIhu3bpxxhln0L1799SDBFYAlwB3EtW/ilSGklU0qIpsLDOrQ+jjmph1bQy8QEhcX3H3FTGGJzHSuFqrtQGmA80TDyQS1rlz57Js2TLatWtH3bp1ycnJobCwsDA3N3cRYYyYFFPMksG0aUJENpq7r3X3N9z9InffEegHfAlcCMwxs9FmdrqZbVHhhTZeC+BWQludOcATwDBAbbhEqs8cQuK5zoar1q1bs+2221K/fv1E14CV06ZN8wMPPPA0lKjKRtLMKpoBEKkOZtackuUC35AsF/jIN33wqU8oQdgs+jOEpcWl0deTgUej+83cxHvJBtK4mhXOAa6mjAMDIiuA+5s3b/7CwoULRwA9VOMuG0PJKhpURaqbmeUBfUmWC9QjWS7wqruvquDt5TmJMKta0SzqCsIK0s/Ak4SjIz8g9I6UaqRxNSsY8BThZLzUI1mdMOt6MuG/O8zsz8BQoJ+7r67hOCXDKVlFg6pITbKw06ITycS1K/AqIXEd4+5zKnmpiYQEuLIKgNWEHchjCP+TnUDYnSxVTONq1sgHxhOa/Fv0ax4wmFDXChT/d/8s8LO7n1nzYUomU7KKBlWROJnZ5sCBhMR1AKHmdTShvc0n5ZQLNCScqFMv8UDKjuPKSJQL1APeBx4jzPRqibKKaFzNKnWBPkAHwqrFY4QfDksws80IKxtXu/uDNRqhZDQlq2hQFUkXZlYX2IfkrGsuyTrX11OWDw8BHiLUq64jsTN5AywH6hCS1ScI5QJTULnARtO4KmUxs52A14EB7j415nAkQyhZRYOqSDqKlg27EJLWocBOhGX70UuXLh3cqFGjYYQlRz799FPy8/PZdttt17nOBs64QrJcYC0hSf4f8Aqh/lUqSeOqlMfMhgPXAnu4+69xxyPpT62rRCQteTDd3a91997A9sDonJycIYWFhYcTJaoA7733Hvfffz8ATz/9NGPGjCHxg/gGJqoQGp03ApoCxwGPAL8CrwGnAW035XOJZDt3fwp4Dng0OtpZpEJKVkUkI7j7L+4+orCw8F+bbbbZstTn8vPzWblyJYsWLeLSSy/lhhtuwMx49913efrpp4tfV1hYSFHRBq3sG6HUoB6hh+zNwHeEutq/Ad1ISZpFpNL+SNicdXncgUj6U7IqIpnmUDOrl/rAxIkT6dChA2+88QYFBQWccMIJzJw5kyeeeIJZs2YVvy43N7e4lrV04jpp0iTeeuut9d27ISFx3QH4E6EjwXzgAeAgkv1eRaQC7r4WOAo42cwGxx2PpDclqyKSaY4iOpM8oU6dOvz4449MmTKF448/nq233pq///3vdOjQgTPOOIMxY8bQu3dvLrroouKENDVxXbt2LfPmzePyyy9n99135/zzz6/MDGxdQrlAc+AE4HFgIaG+9RTCkZQiUg53nwsMB+43s+3ijkfSlzZYoY0AIhlkK8ISfPEM5tq1a7nkkkt4+umnGTFiBE2aNOGhhx5i5MiRvPvuu7Rp0wZ3Z968eYwZM4aRI0fy448/0rFjR8455xz69i3ZqvW7777jhhtu4Nhjj6V379589913PPLIIxxzzDFst12l/3+6jJBQf0dIYp8HPiG0zMoKGlelsszsTOD/gL3cXX2PZR2aWRWRTLIvpfo31qlThzZt2rD33nvTv39/vv76a2677TaOPfZY2rRpw/z58zn44IM5++yzyc/PZ8SIEbz99tuceuqpzJ8/n5Urw/Hmn3/+OT///DP5+fnMmDGD6dNDP/ObbrqJa665hjPPPJNevXrx7LPPVibORoRygU7AX4B3CI3S/wsMJKU/rIhwFzAVuMc2Ykek1H6aWUUzACIZ5M+EjU155b3g6aef5oUXXuCPf/wjnTt3Ln785ZdfZtSoUXzwwQfUq1ePo446ihNOOIGGDRvi7owePZpLL72UFStWcOmllzJs2DCaN29Op06dGD9+PB06dODTTz+lfv36bLfddhvTyxVC39ZlhBKCiYRZ1zGERLZW0bgqG8LM8gk/1N3v7rfFHY+kFyWraFAVySBbA59RaiNTRYljWc998sknTJ48mT59+pRY2i8sLOSSSy7h6KOPpkePHvzyyy+0adOG5557jkGDBlGvXsUTooWFhfzyyy+0bVvp7laJcoFvCInrSMIRlRk/MGtclQ1lZtsAk4DD3X29ux0le6gMQEQyyXfA3YQTp4oTutRktPTGqMRzRUVFFBYWArDLLrtw4oknst122zFvXnJSMzc3l5UrVzJ27FggHChw1VVX8dRTT3HUUUfx888/VxjctddeS7t27Uq0y1qPRLnATsBlwLvAHOA/wG8IM7AiWcHdvwVOBJ40M/UzlmKaWUUzACIZxgi1q38ABhGW1hsQjkutlNRTrS666CIKCws58sgjycvLY/jw4Tz66KP07t27xOuOO+44dt99dy644IJ1rvfdd98xduxYxo4dS25uLtdeey1dunQBoFWrVgwaNIhDDjmEQYMG0bBhw8qEmCgXyCMcTfk4MBZYUNnPGDeNq7KxzOxy4ACgv7sXrO/1UvtpZlVEMo0TErgjCadMHQzcBswCVka/KpS6h+Pss8+mVatW/P3vf+cf//gHN910E71792b+/PklXteiRQsaNGhQ/HViBvf777/n1ltvpW7dugwdOpS2bdvSunVrAEaNGkWDBg0YNmwYjz76KGeffXZlP2MO4TCCfOBA4E7gJ+BjQjP1zugwAqm9/gEsBq6POxBJD5pZRTMAIrXItsAQ4FhgV2A10Liyb169ejX16tWjoKCA++67j0ceeYThw4fTtm1brrjiCh566CH22GMPIDk726NHD2666Sb69u3L2WefTefOnTnxxBNp0KABRx55JD179uTiiy8ucZ/UGduNsIow87oUeCb69SaluiTETeOqbAozawZ8AFzm7o/HHY/ES8kqGlRFaqmmhDZRRwEDgELCCVTrnEVeVFSEma2TQL700ks899xzFBUVMXz4cPbff3+WLVtGo0aNAPj222/p3bs3HTp0oHv37rz77ruMGDGCXXfdFYDOnTtTv359jjzySE499VRatWq13qAXLFhAgwYNyM/Pr8xnLCTU79YBXgWeAF4Efq3Mm6uTxlXZVGa2K+GQjf7u/knc8Uh8lKyiQVUkC9QBegPDgCMIp04ZG3E86siRI/n666854YQTaNmyJQAzZszgr3/9K88//zz77bcfjz76KM2aNWPRokX88MMP/Pe//6Vz58784Q9/qPDaibZZjz/+OBdddBHnnHPOejsQlLKUsGFrOvAYMAr4akM/Y1XQuCpVwcyOBa4Eerj7onijkbgoWUWDqkgW2h4YCvwW2JlyygXcHXdfp/XVqlWrqFu3Ljk5Oaxdu5Y6depwzjnn0KFDB04++WQaNmxI3bp1i9tmjRw5khtvvJGJEyeWWwLw+eefc+mll1JQUMCIESMwMxo3bkzduhvdECBRLrAIeBp4FngbWLuxF9wQGlelqpjZrUBH4FB3X+85yFL7aIOViGSjr4Ebge5AG8JRj6OBFcASwvI6ZlZm/9b69esXP16nTh3cnY4dO7LHHnvQrFkz5syZw5tvvln8mo8//pg+ffowd+7ccmtV8/PzWbx4MZ988gknnXQSLVq0KE5UU9tubYD6hC4JWxA6J4wiJK53Aq039GIiMboIaAFcGncgEg/NrKIZABEplgf0AQ6Pfm1G+KF+g8oFvvjiC04//XSWL1/O9ttvz+zZs7nuuuvo3bs3U6dOZeutt6Zp06Yl3vPVV1/x4IMP0q9fPw444AC++uorZsyYwYABA8jNTZbZps7Mvvnmm9x9991069aNM844o0S3ggoUEDau7L0hn2lDaVyVqmRmWxD+3Z7i7uPijkdqlmZWRUSSCoDXgLMIM5LdgSsILaPWEGpCy5T6g3+nTp2YOHEiL774IkcddRQjRoygd+/ezJs3j+uuu46JEyeu8/4vvviCuXPnsu222wKwcuVKHn/8cfbYYw+GDRvGvffey5w5c4oT1dWrV9O+fXtatWrFLbfcwocffljZz5gHdCUcOiCSEdz9J+Bo4EEz2zrueKRmKVkVESmbA18A1wG7EZLXMwnN+VcRygWK6+dSl/cTta6tWrXisMMOKz7S9fnnn6devXrsu+++xa+DkJjOnDmTFi1asM022wCh08C1117LlClTuOSSS/j6668ZOHAgV199NcuWLaNevXp07NiRvfbai2OPPZZ27doV33/mzJn861//4vDDD+eVV14p67PVBXavku+SSA1x9zeBq4FnzKxS7TKkdqj0iS8iIlluAfBI9KsusA+hVGAYoSVWHcJO/HLrUnfffXf22WcfmjRpUmI5/8cff+STTz6hW7duACxbtoxPP/2UG2+8EYD+/ftzzDHH8K9//YslS5YUt84CmDRpEltttVVxW6zly5dz7rnnssMOOzBo0CBuueUWttxyS3bcccfUUFYCn1XNt0WkRt0K7AncaWYnu2oZs4JqVlFtlYhsEgO6kOwusAOhZKBRRW9KVVBQwHvvvccWW2xRPLOaMGvWLEaOHMnIkSOpX78+1157LTvttBMA8+fP5/zzz+eYY47hoIMOAuC+++5j8uTJXH311TRt2pR+/fpxySWXFD8fWQ1sTjjStVpoXJXqYmYNgXeBO9z9P3HHI9VPM6siIpvGCX1NpwPXAC2Bg4BjgH1JJq7lll3l5eXRp0+f5AXdi9tetW/fnrPOOouzzjqLgoICCgqSB1VNmjSJ+vXrs+WWWwIwe/ZsvvnmG3bbbTeaNm3KsmXL6NatW4n3RD6kGhNVkerk7svNbBjwtplNdff34o5JqpdqVkVEqtY84EFgEOEUrSOB+4D5hNOmVpf1ptRVLjMjNzcXM8PdKSwspKioiLy8PBo0aMCyZSHP/Pbbb+natWtxTeyPP/7I6tWr2X777QH47rvvyjqZawXhwACRjOXuXwOnAv8zs/UfDScZTcmqiEj1WQ28BJwOtAL2Av4JfB49Vzy7WV6dayJxTe33Om3aNFq3bs2f//xn3n77bRYsWABAu3bt+Oabb+jQoUPx6+rUqVOcvAIUFhbmvf/++y9X6acUiYG7jwIeAp40M60U12JKVkVEaoYDnwBXEWpcOwDnAhMoo7tARXr37s0PP/zAk08+yerVq7n44osBqFu3Lj/88ENx3evDDz/MLrvsUjzzCjBnzpzCXr16TTazkWZ2qpm1qbqPKFLjriD84HdN3IFI9dEGK7QRQERiVx/YDzgCOJTQVSCP0HVgHYl61tJWrVrFDTfcwF133UXPnj3Jz8/nscdKrPgXADeY2Y3AgcAQYADhRK9RhFO8plXFDmuNq1JTzKwFoQ77Ynd/Ou54pOopWUWDqoikFSM07T+EsEmrI7CW0B6rhEQ/19KJ67fffsvs2bPp1q0bjRs3Tm2TtQzYH3i/+GZmdYG+hMR1CCFJHh39es3dy6yxXe+H0LgqNcjMdgfGA/u4++dxxyNVS8kqGlRFJK21BQ4mtMXqTVjybExIaktIjOfl1b8Ci4HmlFNuYOGNnUkmrrsArxAS1zHu/ktlg9a4KjXNzE4C/gj0dPclcccjVUfJKhpURSRj5BNmRo8k9HWtQygVKLNcoBQHHgWOr+zNzCzRhmsI4XjWz0nOun5aUbmAxlWJg5n9h9A+7ggdGFB7KFlFg6qIZCQjHJl6KHAUsBXllAtElgODgdc36mZm9Qh9YxOzrg68QEhc3yhdLqBxVeIQ/TudCDzj7tfFHY9UDSWraFAVkVqhHSEZ/S3Qi2S5AITjVccRNnBVxeYpA3Ymmbh2Bl4mJK5j3X2+xlWJi5m1J9RlH+fur8Qdj2w6JasoWRWRWqchoVygP9AeuAl4u7puZmatSZYL7E9o0bU3sBPwuZZjpaaZWX9C2Usvd58ZdzyyaZSsomRVRKSqmFl9oB/wIjCL0C4rUec60d3XOftVpDqY2cWE+u593H1V3PHIxlOyipJVEZGqZmZOOHimK8lyge0JJ3olygV+jS9Cqe2icpX/AQvc/fdxxyMbT8kqSlZFRKpaWeOqmSXacA0hHILwESFxHeXuX9Z4kFLrmVljQv3q9e5+f9zxyMZRsoqSVRGRqra+cdXM8gk1tYlZ1+UkywXeVrmAVBUz60ToEHCQu38Ydzyy4ZSsomRVRKSqbci4Gi3XdiOZuG5D6F4wGhjn7gurLVDJCmZ2OHAjsIe7z487HtkwSlZRsioiUtU2ZVw1s0QbriHAPsBkollXd/+66qKUbGJm/yL8UHSguxfGHY9UnpJVlKyKiFS1qhpXzawB4fSsIYQEdjFRnSswyd3Xbuo9JDuYWR3CBr9J7v6XuOORylOyipJVEZGqVh3jqpnlAN1Jlgu0J7TIGg2Md/fFVXk/qX3MrBXwIXC2u4+MOx6pHCWrKFkVEalqNTGuRicVJcoF+hB2fSfKBb6tzntL5jKznoSjgvu4+1dxxyPrp2QVJasiIlWtpsdVM2tEyXKB+SS7C7yrGkVJZWanA+cAe7r7srjjkYopWUXJqohIVYtzXI3KBXqSLBdoC4wlWS6wNI64JH1EHSjuAxoAx+hI4PSmZBUlqyIiVS2dxlUz60Ayce0NTCJs0Brt7j/EGZvEJ+r1+xbwiLvfHHc8Uj4lq6TXoCoiUhuk67ganWg0gJC4Hgz8TLJc4H13L4oxPKlhZtYReBc4yt3fiDkcKYeSVdJ3UBURyVSZMK6aWS7Qi+Ssa0tgDCFxfVm1jNnBzAYAI4Ae7v5jzOFIGZSskhmDqohIJsnEcdXMtiFszhpKSGLfItldYFacsUn1MrO/EGba+7n7mrjjkZKUrJKZg6qISDrL9HHVzJoAAwkzrgcCs4nqXIHJKheoXaJNec8Bs9z9rLjjkZKUrJL5g6qISLqpTeNqdPLRXiTLBZoS+nSOBia4+4r4opOqEv2A8gFwlbs/HHc8kqRkldo1qIqIpIPaPK6a2XYkE9c9gImExPUF1TxmNjPbGXgNOMDdP4o5HIkoWaV2D6oiInHIlnHVzJoCgwiJ6yDge5LdBaaof2fmMbOjgX8Ce7j7wrjjESWrQPYMqiIiNSUbx9WoXGBvwgatIUBDkuUCr7j7yhjDkw1gZjcDOwBDVJ8cPyWrZOegKiJSnTSugpntSLJcoBtheXk0MMbdf44zNqmYmeUBE4DX3P3KmMPJekpW0aAqIlLVNK6WZGbNCV0FhhC6DHxNslzgY5ULpB8zawN8CPze3cfEHU82U7KKBlURkaqmcbV80axdX5KzrnVJlgu85u6rYgxPUphZb0JLq97uPiPueLKVklU0qIqIVDWNq5VjZgZ0Jpm47gK8SrJcYG6M4QlgZmcBpxISVrUpi4GSVTSoiohUNY2rG8fMNgcOIiSuBwBfkCwX+ETlAjUv+oHioejL3+nvoOZlU7J6CHAe0A4oMYB+/fXX222//fbflHr9auAT4AJAhfAiIusaApwPbEnlx9VPCePqTzUSYQYzs7rAviRnXY1k4vqGu6+OMbysYmYNgEnAPe5+R9zxZJtsSVaPAh4A8jfwfWsJiWovlLCKiKQ6EniQjRtX5wI9UcJaadHs3k4kE9cuhN3qo4Gx7j4vxvCygpltC7wDHObu78QdTzbJhmQ1H1hEKGDfGGuBZ4CjqyogEZEMVw9YwqaNqyOBI6osoixjZq1Ilgv8hjBjnZh1/UxL1dXDzA4G7iYcGDAn7niyRTYkq12Ad4HGm3CNzwg/0YqICOxIaOnTaBOu8VV0HdlEZlYf6Edy1nUtycR1oruviS+62sfMrgT2A37j7gUxh5MVcuIOoAbUBzb19In6VRGIiEgtUY9NH1frVUUgAu6+yt3HufsfgA7AYcA8wpGhc83sSTM7zsxaxBpo7fF3YBnwr7gDyRbZkKxWytq1a3nvvfe4/vrr4w5FRKRW0Lha8zz42N3/4e69CG2xXiKUXHxrZhPN7GIz6xTVwcoGio5fPR44xMxUIlgD6sQdQJxeffVV3nzzTSZOnMgPP/xA9+7d6du3b9xhiYhkLI2r6SWqq7wPuM/M8gnL10MIm7NWmlmiXOAtLWlXnrv/amaHAy+b2afu/mncMdVm2VCzujuhwXKT0k/Uq1ePNm3acNFFF3HSSSfRqFG55VffAttWY4wiIplkV+BNYLPST2zAuPoD0LH6QpSKRLOquxES16HANsB4QuL6orsvjC+6zGFmxwOXAT3cfXHc8dRWWZ2srly5kkmTJjFx4kTefvttVq9eTffu3bn55ptLv1TJqohIUrnJ6gaMq0pW04iZbQEMJiSv+wJTgFHAaHf/Os7Y0p2Z3U7oNTwsKhGQKpbVNav5+fnsvPPO7Lrrruy8886sWbOGadOmxR2WiEjG0riamdz9J3e/x92HAG2AG4FOwBtm9oWZXW9m+5hZVpcPluMCoBXwp7gDqa2yema1U6dOrFy5kv/7v/9jv/32o0ePHuTm5pZ1Dc2siogklTuzugHjqmZWM4CZ5RD+P5poi9UBeJFQLjBOS9+BmbUDPgBOdPeX4o6ntsnqZPWWW25h4sSJfPTRR2yzzTb07duXPn360L9//9IvVbIqIpJUbrK6AeOqktUMZGZbkiwX6EtI0EYTygVmxBlb3MxsX+BJYE93/z7mcGqVrE5WU33xxRfFO1gffvjh0k8rWRURSSo3WU21nnFVyWqGM7OGhNOzhgIHA7+SPIxgkrsXxhheLMzsfOBYoI+7r4o7ntpCyWrlKFkVEUmqVLK6HkpWa5GoXKAHyXKBLYCxhMT1JXdfEmN4NSbqsvA4sBw4VcfeVo2s3mCVcPTRR5f4XURENo3G1ezi7kXu/p67/9XduwJ7AO8DpwKzzewlMzvbzDrGGmg1i5LTU4FewGkxh1NrKFkFvvzySwC++uqrmCMREakdNK5mN3f/wd3vcPdBQDvgP4SVzvfN7BMzu9rM9jKzMnffZTJ3XwYMA/5hZj3jjqc2ULIqIiIi1cbdl7r7s+5+EtAWOD166h7gJzN7wMyGmVm5J0hkGnf/ijCz+j8zaxl3PJlOyaqIiIjUCHcvdPdJ7n6pu+8C7AlMBc4AfjazcWb2BzPbKt5IN527jwQeBZ5Qf9pNo2RVREREYuHu37n7re5+AKFc4D5CvecUM/vIzK4ys57RBq5MdBlQCPwz7kAyWab+5VepsHlPRESqisZV2VDuvsTd/+fuvwNaA2cBdYERwI9mdq+ZHRK1zMoIUfuu3wJHmdnhcceTqZSsAhdccEGJ30VEZNNoXJVNEZULvOXuf3T3LkAf4FPgHEK5wBgz+7/okIK05u7zgSOAu8ysU9zxZCL1Wa0c9VkVEUlSn1WJjZk1BQYS+rkeSPi3lDiMYIq7F8UXXfnM7BTgIqCnuy+NO55MktUzqx9++GGZj8+cOZM333yzhqMREcl8Glelurn7Ind/0t2PI5QLnA80JGxmmmVm95jZEDNrEGugpbj7fYQf8h4w1clskKxOVg877LAyH1+yZAnnnXdezQYjIlILaFyVmuTua939DXe/yN13BPYDvgQuBOaY2SgzO83M2sYbabGzga0I8UklZXUrhUWLFnHSSSet87i7M23atBgiEhHJbBpXJU5Rf9MbgRvNrDkwiFAu8C8zm0GyXOCjOI5CdffVZnYE8J6ZTXb312o6hkyU1clq/fr1GTx4cJm7VocOHRpDRCIimU3jqqQLd/8VeAx4zMzyCJu0hgBPAfXN7AVC4vqqu6+qwbhmmtlxUVw93X1WTd07U2X1BqtddtmFTz75pDLX0AYrEZGkcjdYbcC4qg1WEouoXnRHQuI6lPDv+TVC4vqCu8+toTj+SDiWdR93X10T98xUWZ2sbgAlqyIiSeoGILWGmbUADiIkrwOAL0iWC3xSXeUCUdL8DDDX3c+ojnvUFlm9wWrSpEksWrQo7jBERGqNCRMm8OOPP67z+Nq1a5k5c2YMEYlUzN0XuPvD7j4caAX8Nfr9eeB7M7vdzAaaWb0qvq8DJwL7mdmJVXnt2iark9Xf//73NGgQOlvMmTOHunXr0rhxYzbbbDNyc3Njjk5EJPNceOGFtGjRovjr2bNnA2GD1bBhw+IKS6RS3H2Nu09w93MJK6oHAbOBy4G5ZvaMmZ1oZi2r6H5LCKUA15vZ7lVxzdooq5PV3Nxc6tatC0CbNm3YbbfdWLp0KUuWLKFr164xRyciknlycnKoX79+8dcHH3wwAHl5eRQVpWWvdpEyeTDd3a91972B7YFRwGDgazN7x8z+bGY7b0rfVHf/DDgTeCYqSZBSsjpZLSoqYv78+QB899131KmTbI6QBbW8IiJVzt1ZuHAhEFasZsyYwYIFC1ixYgUFBQUxRyey8dx9nrs/6O5HEA4juBJoB4wBZpjZrWb2GzOruxHX/h/wNPComZVY2jWzOmbWpPTj2SSrk9Xzzz+fvffem5NOOon+/fvzxz/+sfi5Dh06xBiZiEhmOvvss9lzzz05+eSTOeSQQ7j++uvp3r07O+20E2eddVbc4YlUCXdf7e4vuftZhI2ChwJzgX8QygWeMrPjN3Cm9M9APeBKM6tnZsc1M/skB9bUg19yoKCp2SdmdlxV18+mu6zvBvDFF1/w2Wef0a1bN7beeuvyrqFuACIiSRV2A5g+fTpffvklffv2pWXLlsyZMwcI5VYp1A1AymRmxwInuPuAar7P98Cp7j6hiq73OPAkMAk4mNBdoD8wjWR3gS8q6i5gZq2AafnQoDtwITQeTGiKvxZ4AbgBlk6BgpUwyN0/KOMa7wMnufv0Cu7TEngL6FqTPWY3VlbPrAJ06tSJYcOGVZSoiojIBthpp50YNmwYLVuGPSht2rQpnahKhjGz781sjZltXurxj8zMzaxjJa7RMXpthQcSufujm5qomtmxZrYs+rXSzIpSvl62Kdcu5367Al2BkVGf1heBXGA54TCCXYCXCLWuN5vZ8Ogo2F/NbLaZ/V90qQ4NoMkF0HghND4O2Af4jJCwHgq8Ao1/A80Jp2AtMbM7o0MPEm4A/r6ekP8EPJBIVKN43jGzFWb2ehmfbzczmxw9P9nMdkt5rl70mX4ys4VlxLPJsjpZveKKK+IOQUSkVtG4Wqt9BxyT+MLMdgHyq/IG60tkKytKeBu5eyPgQOCnxNfRY1Xt98CjKbOmRcA44PDo68uArYAjgF+Bewk9XV8G7gCuMbMB+TDuRqh/K/AfYBHJkwvWRhe6FlgIPAJWPzzcndBuK2EUoR1W27ICjUoITgiXKPYr8O/o8qVfXxcYGb2+GfAgMDKlNvdPwB7AzsAOhBXtv5a+TjmxVOrvO6uT1R49esQdgohIraJxtVZ7GPhdytcnAA+lvsDMDjazqdGM3ywzuzLl6YnR74uiGc69ojZQb0czc78S6jVPNLO3ouv1NrP5ZtY++rqrmS0ys05V9Jl2M7NpZrbYzJ40s+JWFmY2OJo5XhTNOu5awXUOBN5IfOHuc939TuCDlMfc3T8CbgYaE5LMCcBeQEPgf92g4VqgL2E6tg7wR+DHlIuPBs4BjgV2hzzgQ+DklPusAiYTkuGy9AIWufvslPdMcPengJ/KeH2/KJR/R7W6twJGKHGAkE/f6u6/uvs84NbUeEqLZtf/YGZfA19Hj91iZuUeO5vVyergwYPjDkFEpFbRuFqrvQtsZmado53pR1Fydg7CsvfvgKaEus0zzOzQ6Ll9ot+bRjOck6KvexH2hrQC/pl6MXd/B7gbeNDM8gkJ81/d/Ysq+kzDgUHA1oRa7BMBop6n9xNmTFtEMYwqa2OTmTWM3v9lJe+ZaHM1z93/6+5DgUdyoP7FUM+B1KLWxNeflvoa4CJoVD8ki1uaWerenM8JZQll2WUDYgXYCZhWqtZ2WvR44vOktu6yMuIp7VDC33uX6OsPgN3Ke3FWJ6vnnXce33zzzTqPL1u2jLvvvjuGiEREMtsBBxzA1KlT13n8jTfe4Oabb44hIqliidnVAwjHkpY4rszdX3f3T9y9yN2nAY8D+67nmj+5+23uvtbdV5bx/JWETdLvE2b+7tjEz5DqVnf/yd1/JUxa7hY9fhpwt7u/5+6F7v4gsBrYs4xrNI1+X1qZG7r7UuBt4DIzqx8lxocWQd3BhG/sG8DrwBrg6uj3FdH7DwRuAeYBPYBV0D56qkHKbZamxFVWvJWKNdIIWFzqscWE2WEI9bnnmllLM2tDmPgtHU9p10QzsSsB3P0Rd19Q3ouzOlmdMGEC2223XfHXd955JwCNGjXijjuq8r8FEZHs8Omnn3LkkUcyYULJDda9evXi3nvvjSkqqUIPA78lzEA+VPpJM+tlZq+Z2TwzWwz8H7B56deVUu7yL4C7FwAjCDWRN1a0m34jzEn58wpCYgbQAbgwKgFYZGaLCEnhFmVcY1H0e+MynivPsYTZ2FnAXcD/DLwO0IlQFHoW0BaYT5h+3DJ641+AboSseh8gFwqBAuCXlOs3TomrtIUbGOsy1u38sRnJhPefwFTgI+AdwjG1peMprcTfuZldaGafl/firE5WE6dXJdx0003Ff9ZxqyIiG65t27aMHz+ec889l0ceSa4Q169fn7y8Kt0gLDFw9x8IG60OAp4t4yWPETb4tHf3JoR9Qokl4vKSzAqTTzNrB1wBPADcWEM9RmcB/3T3pim/Grj746Vf6O7LgRmEzUWV4u4/uPtgwsakh4GhDpbYRHUEYdl/AfA3Qp+3RDV4PnA7YUr7K6Ao5HKT3b0w5RadgY/Luf20DYkVmA7salbilK5do8dx95Xufpa7t3P3baKwS8dTWvHfuZn1JZTmDi/vxVmdrDZr1ozRo0fj7jzxxBMUFBTw+OOPM3r0aBo33pAfOkREBMIJVttuuy0TJ07kzjvv5Oyzz+ajjz7iP//5T3ErK8l4pwD9oySttMbAr+6+ysx6EmZhE+YRdslvU9kbRQnSCOC+6L4/A1elPD/CzEZs6AeohP8C/xfNFJuZNYw2j5WXHIylVLlDtFkrkVjXi5b8c6Jr3mVmnxA2Rw0HGjaGL1+IXjyZMF06j1A0O4Qw4wohSf2JkO3dEB5aS0jmE/etR9i89XI5sb4PNI1+CEi8JzeKtw6QE8Wa+Ony9Sicc6I2VYnTPV6N3tvOzLaIvk97EjofbEhbkMbRZ5hX3guyOlm9/fbbueqqq2jWrBnjxo3j1Vdf5ZFHHuHOO+/knnvuiTs8EZGMkzj9r0WLFrzxxhu0bduWs88+m9dff537778/5uikKrj7DHf/sJynzwT+bmZLgcuBp1Let4KwZPx2tLReVv1naecQjja9LFr+Pwk4KZqNg7A0//ZGfpRyRZ/vNMIk5kLgG6LNV+W4Bzi21OzjSsISOoT63pWEPPN+YHvCyn4DQi7Wfyn844Zoaf1cQmHpjtHv/0256AygN6F9wN+gyOG/7v5SykuGAq+7e1k7+3H3NYQfAI5Lefj4KL67CM0IViZuG73+UEKt8iLCTv9Do8chHJr0DmFz3YPAn0rFsz7jCXWvX5X3gqw/waqSdIKViEhShSdYVZJOsJJNEvX5/BjYNaprjTuex4Cn3P35qNXWYMKkaB/CbOZoYLS7f1vO++vlw09PQPOhlbjfKOBo+HUlbOHuq1Ou8x5wirt/Wt57LZxg9SbQrZxNbWklq2dWJ0yYwI8//rjO4wUFBcycOTOGiEREaofjjjuOO+64gyyYEJGYuPsad++cJolqDqF/6u5mNpWw4ag3YQazvbv/xt1vKS9RBXD31SthzNFQOGo99xsFHAPLoyNXV6c+5+69KkpUo9fMc/dOmZCoQpYnqxdeeCEtWrQo/nr27OL+uAwbNiyOkEREaoW33nqLlStX0r9/fyZPnhx3OCJVzswamNkQM/svMJvQHaE+oXShjbsf7+5PuXvptk/lXe8IoO9KGHQ0/NoHlj5H8uSqtcBzwN6w9Gj4dQXs5+4flHvBWqRKjjXLVDk5OdSvX3xYBQcffDAff/wxeXl5FBUVxRiZiEhmy8nJ4aKLLuKYY47h4osvplWrVlx11VXavCoZzcy2ILm8vy9hL9Qo4F/uvm7j9spftzOhXnSgu08xsy3ehiM+hT8thZ3yYG0B1GkMny6GfwFPl55Rrc2yOll1dxYuXEizZs2YM2cOM2bMYMGCBeTn51NQEPuqgohIxnnwwQcBWLp0afGfBw0axEsvvUTnzp1LrGCJpLtow1Q3QnI6hNDJYByhRdfv3H1hFdxjM8Kk6SXuPgVCSQDwKPComeWuDv1fly2quB1UrZXVyerZZ5/Nnnvuyd5778306dO5/vrr6d69O2bGn/70p7jDExHJOIkl/4KCAj788EMSm6ObN2+u8irJCNGxrv0JyelgwmEBo4GLgLerskY2SobvB95w9wfKek3Ur7RSpQS1VdZ3A5g+fTpffvklffv2pWXLlsyZEw6zaNOmTerL1A1ARCRpvd0ALr30Uq6++uqKrqFuAJI2omNCE8v7/QinMSV2739Zjfe9BDgc2CeblvU3VNYnq5WkZFVEJEmtqySjRTOauxKS06GEvqcvERLUFys6p74KY9gfeATo6e4VHjmb7bK2DODAAw+kTp067LLLLuv76V9ERCpB46qks+iEpn4k608LCMnpn4E3U5rc10Qs7QmJ6rFKVNcva5PVF198kffee6942V9ERDaNxlVJN2bWCjiYkJzuD3xCSFAHAZ97DMvL0XGoTwM3u/urNX3/TKQygMpRGYCISJLKACQtRcv7O5OcPe0MvExIUMe6+/wYwwPAzO4GWgBHxpEsZ6KsnVkVERGRzBfNVO5Lcvc+hOT0csIu+xpb3l8fMzsZ2IdQp6pEtZKUrIqIiEhGMbPNgYMICeoBwOeEBHUo8Gk6JoJm1p3Q0H8fd18adzyZJKuPWy3Lxx9/HHcIIiK1isZV2VQWdDGzP5rZW8AM4FBgLLCDu+/l7le7+ydpmqi2INSpnuHun8cdT6bJ6pnVxOkqqS6//HL+9a9/8Zvf/IbNN988hqhERDKXxlWpKmaWR1gyT9Sf5hFmT/8BvO7uq2IMr9LMLBd4HPifuz8ddzyZKKuT1cRJK6lWrVrF+PHj+fe//827774bQ1QiIplL46psCjNrTnJ5fwDwFSFBHQZMS8dZ00r4OyHfujTuQDKVugGUfvHuuzNlyhS6d++eOuiqG4CISNIGdQMoZ1xVNwABwMx2JNSaDgF2A14jJKhj3P3nGEPbZGZ2CHAbsIe7/xJ3PJkqq2dWyzJp0iQAbr311pgjERGpHTSuSqpoeX9vksv7DYAXCJuPXnX3lTGGV2XMbAfgv8AQJaqbRhusgKOPPrr493r16gGw9957xxmSiEhG07gqqcysmZkdY2aPAXOBG4AlwNFAe3f/P3cfU4sS1UbAs8Bl7v5e3PFkOs2sAl9++SUAX331VcyRiIjUDhpXxcy2Jzl72h14g7C8f5G7/xRnbNUpOpjgXuB94J6Yw6kVlKyKiIjIJjOzOsBeJOtPmxCS05uAV9x9RYzh1aRzge2BPhm6ISztKFkVERGRjWJmTYCBhOT0QGAWIUE9Hpjs7kUxhlfjzGwf4E/AnrWlpCEdKFkVERGRSjOzbUgu7/cE3iIkqJe6+6w4Y4uTmW1B6Kf6O3f/PuZwahUlq0AoLxERkaqicbX2iJra70kyQW0BjAFuBya4+7IYw0sLZlYX+B9wp7u/FHc8tY2SVeCCCy4o8buIiGwajauZzcwak1zePwj4iTB7ejLwQbYt71fCjcB84Jq4A6mNdChA5ehQABGRpA06FKAcOhQgzZhZB0JyOpSwUeodYBTwgrv/EGds6czMjgOuAHq4+6KYw6mVsrrP6qWXXsqcOXMAWLhwIQ8++GCJXyIismHOO+88vvnmm3UeX7ZsGXfffXcMEUl5zCzHzPY0s3+a2TTgA2AP4G5gC3cf6O53KFEtn5l1BW4GDlOiWn2yOlkdNWoUbdq0AaBRo0ZceumlfPjhh0yePJmLL7445uhERDLPhAkT2G677Yq/vvPOO4Ewxt5xxx1xhSURM2tkZoeZ2f3Az4R+oDnA/wFt3f1Ed3/G3ZfGGmgGMLNmhMb/Z7v7p3HHU5tldc1qXl5eiT+3bNmS2267DYC33norrrBERDJW3bp1S3x90003ceaZZwKQm5sbR0hZz8zak9wctTfwHqH+9B/u/m2csWUqM8sBHgFGufsTccdT22X1zGrz5s157rnnKCoq4u6772aHHXaIOyQRkYzWrFkzRo8ejbvzxBNPUFBQwOOPP87o0aNp3Lhx3OFlhWh5v6eZXWVmHwFTCbv57yccbXqAu9+qRHWTXAY0Bi6JO5BskA0zq0VAmT1U7rrrLk488UROOukkunfvXqJO9ayzzip9DRERCcodE2+//XZOOOEEjj/+eA499FBeffVVzjnnHIqKirjnnhInTxZWf5jZw8waAL8hzJ4OBhYRZk/PAia5u77fVcTMDgJOA/Zw94K448kG2dANoDmhLqfu+l5YgQnAAVUTjohIxmsCzAPy1vfCCrwO7Fcl0WQpM2tHSEyHAPsAHxIS1NHuvu4uN9lk0YEIkwgbqt6JO55skQ3JKsADwJFAw4147wrCEXITqzQiEZHM9l/gGDZ+XD2YkLBKJVk4aWF3kvWnHYFxhAR1nHajV69o9vod4F53vz3ueLJJtiSrOcB/gBMJy1clPvTKlSvr5+fnryr1nlxgGXAEoU+riIgk5QB3AKewYePqcsLkwYSaCDLTmVk+sD/J5f1lRLOnwNvuvjbG8LJG9IPCg4R/98d7liRP6SJbktWEHKAZpWpYN99883nz589vWeq1qwG17hARqZjG1SpmZm1JLu/3I2yQSizvfxljaFnLzP4AnA7s5e4r4o4n22RbslomM3N310HWIiJVRONq5UWzdl1JLu9vD4wnJKgvuvuvMYaX9cysN/Ac0NvdZ8QdTzZSsooGVRGRqqZxtWJmVp+wwSyxvL+G5PL+m9plnh7MrA3hZK//c/cxcceTrbKhdZWIiEjszKw1YWPZEKA/MI2QnA4EvlAdZHoxszzgSeB+Jarx0swqmgEQEalqGleLl/d3Ibm83wl4ieTy/vwYw5P1MLObCH9ng91d/dZjpJlVERGRKmJm9YB9SSaoTkhOLwPecPc1MYYnlWRmRwGHAD2UqMZPyaqIiMgmMLOWwEGE5PQ3wGeEBHUwMF3L+5nFzHYCbgcO0Oa29KBkVUREZANEy/tdSM6e7kzoGzsaONPdf4kxPNkEZtaEsPP/Qnf/KOZwJKKaVVRbJSJS1WrbuGpmdQlHmiYS1FySu/dfd/fVMYYnVcDMcoBngR/d/Q9xxyNJmlkVEREpg5m1ILm8fwDwFTAKOBT4RMv7tc4fgdbA8LgDkZI0s0rtmwEQEYlbJo6r0fL+jiRnT7sCrxFmT8e4+5wYw5NqZGYHEI5T7eHuP8Ydj5SkZJXMHFRFRNJZpoyrUS/NPiQT1HySy/uvufvKGMOTGmBmHYD3gKPc/Y2445F1qQxARESyipk1Aw4kJKcDgRmE5HQ48JGW97NHdJLYM8B1SlTTl2ZWyZwZABGRTJFu46qZbU9ITocCuwOvk1ze/ynG0CRGZnYv0Bg4Wj+kpC/NrIqISK1jZnWA3iSX9zcDXgBuAF519xUxhidpwMxOA/YCeilRTW+aWSX9ZgBERDJdHONq1CNzECE5PRD4gWT96RSdRCQJZtaT8MNLX3f/Mu54pGJKVlGyKiJS1WpqXDWzbUnOnvYA3iQkpy+4++zqvr9knujEsQ+Bc939+ZjDkUpQsoqSVRGRqlZd46qZ5RKWbhMJanPCDNloYIK7L6/qe0rtEZWHjAfec/dL445HKkc1qyIiktbMbDNgACE5PQj4kZCcngh8qOV92QD/AIqAy+IORCpPyaqIiKQdM+tIcvZ0T+AdQoJ6ubv/EGNokqHMbBhwNLCHuxfGHY9UnsoAUBmAiEhV29BxNVre70kyQW0NjCEkqC+7+9JqCVSygpl1AiYCB7n7h3HHIxtGM6siIhILM2tEyeX9XwjJ6enA+5r9kqpgZo2BZ4E/K1HNTJpZRTOrIiJVrbxx1cy2Ijl72ht4l+Tu/e9qNkqp7czMgKeARe5+WtzxyMbRzKqIiFQbM8sB9iCZoG4JjAXuA4a7+5IYw5Pa70KgI9A35jhkE2hmFc2sikitlwt0AdoBrwGrq/NmZtYQWEZISA8GFpJszj9Jy/tSE8xsP+AxwglVM+OORzaeZlZFRGqnzYCBwFHR74mZiZXA2YSl0SpjZlsCgwmzp4lZrE+Ba9x9RlXeS2R9on+PjwHHKVHNfJpZRTOrIlJrbE1IFo8FdgNWEZLW0lZGz3+1sTeKlvd3J7m83wF4kTB7Oh5YqHFV4mBm9YA3gOfd/dq445FNp2QVJasikrFygV7AYcBwoBWh4XmD9bxvLXAncO6G3MzMGgD7E5LTg4GlJJf333H3tSmv1bgqsTCzuwitzw53JTm1gpJVNKiKSEZJtHsaTmj3BJBPJcq63J2wORqAn4Et1vceM2tLcnm/HzCFKEF193JnZjWuShzM7ETgT0BPbd6rPZSsokFVRNJeot3Tb4HuhA1SjYEKx621a9dy1113MXbsWF588UWKiorIyclJPL2CsIz/Zep7olY/u5Fc3t+WsKw/Ghjn7r9WJmCNq1LTzGx3wr/Vfd39s7jjkaqjDVYiIuknB+gBHErYINWWksv79cp6U6mZU3JycnjttdcYP348c+fOpXXr1qXvMRS43szqA/0JyelgQq3raOAS4C13L6i6jyZS9cysBfAMcKYS1dpHM6toBkBE0kJD4ADgSELCaEB9IK+iN33zzTeMHDmSMWPG0L9/f0477bTipPS9997jiy++4OGHH2bgwIFcfPHFJRLaX375ZWbr1q2nAvsB04BRhCT1y02t9dO4KjUlOqp3DPCpu18UdzxS9ZSsokFVRGKTaPf0W6AnlVzeT1i9ejVnnHEGeXl5nHDCCfznP/9hs8024/bbbwfglltuoU6dOrRv356rrrqKDz74gIKCAvLyQv5bUFBQ1K1btz9Mnz79f+6+oCo/mMZVqSlmdhXQBzggdZOf1B4qAxARqTmJdk+HEpb32xN25jeMni9zeb+0xOxovXr1uP/++4sfnzVrFmPGjAFg5cqVLFiwgHPPPZcWLVpw3HHHMWHCBPr161f8+ry8vOWffvrpUqBKE1WRmmJmQ4ATgT2UqNZeSlZFRKpXot3TkYSa0DqEpDSxvF9mgvr999+Tm5tL+/btKSoqwsyKN0il1qUCLFiwgLPOOosXX3yRv/zlL6xatYr8/HxeffVVNttsMz777DOKioo4+uijmTx5Mh06dEi8tTFwNPBo1X9skeplZtsRTkkb6u5z445Hqk/O+l8iIiIbaAvgdOB14FfgEeA4oCmh9VS5dai//vorp59+OieffDJff/01QHGCmpubi5kxa9YsHn74YVauXAlAgwYNOPLII5k2bRoff/wxt99+O5999hlbb70148ePZ9CgQZxzzjn07duXDh06sHZtiQmo/SuKRyQdRUf6Pgdc4e7vxh2PVC/VrKLaKhHZZIl2T4cSZio7UHJ5f4NsueWWfPnll6xatYoWLVoAYbPUyJEjefPNNykqKmLgwIGcf/75NG7cuMR7X331Ve666y5uvvlmttxyy+LHZ86cycEHH8wnn3xS+nZLCIcKvLoxsZZH46pUl6i92qPAGuAkNf6v/TSzKiKyceoTmvI/AMwHJhKake9AWNrfqET1tddeY8GCBWy33XaMHDmSjz/+mGOPPZa//OUvdOzYkaeeeoq33nqLAQMG8PrrrwNQVFRU/P4mTZqwaNEiWrVqBUBhYSFr165lq622KitRTXyOPTYmVpGYnA10Bs5QopodVLMqIlJ5bQjHjB4D7E2Y2Vnv7v0PP/yQZ555hilTpnDhhRfSt29f8vPzS7wmUY/aokULjjzySFatWsXJJ5/MmjVrGDFiBKtWrWLChAlccsklfPrpp3Ts2JETTzwRgO+++47nnnuOCRMmMGvWLK666irq1q0LQG5ubon7lO7FChSiiQvJEGbWB/gLsKe7r4w7HqkZKgNAy1UiUi4DdiEs7x8DbA0UEOpOy7Vq1Sp++OEHttlmG+bPn8+ZZ55Jt27d6NixIy+99BKDBw/m6KOPXidxTCSss2fPpnv37sydO5eioiJGjRrFNddcw6677sphhx3GwIEDSyShs2bN4plnnqFLly4MGDBgQz/jUkILrSo9mlLjqlS16OjfD4FT3H1c3PFIzdHMqohISfWAfsARhFrORGP+uinPr2POnDk8+eSTvPXWW7zwwgvsu+++jBs3jjFjxrBq1Souv/xyAKZMmUL79u0B1tnVnzgKdcsttyQ3N5cpU6aw++67s99++3HooYeWeG1RURHuXtwx4LzzzivxXMqxqmVxYFn0+6lUcaIqUtXMrC7wP+A/SlSzj5Z+RESgJaFX43hgEfAUcDLQglB7Wre8NwIsXbqU++67j8mTJ3PBBRfwwAMPsHz5cgD2228/Fi1axPnnn0+/fv0YP348zZs3L1FnmiqxU3/AgAE8+OCDAMWbqAoLC4vfl5OTU+YSf+K5si5NmEVdGn2+EwllDf+r6LOJpInrgYXAP+MORGqeygDQcpVIFjJgJ+AQwvL+dlRieX/16tXMnz+fdu3alVX7Wezxxx/nrbfe4sYbb6R+/fp88803nHfeeRx//PHUqVOHESNGcNxxx3HUUUexbNky5s2bx9Zbb10iER07diz/+Mc/eOeddzblc64gTErMJSSozwHvE+pUq5XGVakqZvZb4O+Exv+LYg5HYqAyABHJFnWBfUgu7zck2aAfKjg9atGiRZx00kl8/vnn7Ljjjlx22WXssce6G+gTR5lOnjyZNm3aUL9+fQDGjx/PrrvuylFHHQUkT5o66qijeO6553j55Zd56KGHSsyIHnTQQRx00EEb8zmXEEoXphLa+7wAfLcxFxKJm5ntCtwC7K9ENXupDEBEarMWwPHAWMLy/jPAaUArQrJaZoI6derU4ob8EHqcbrHFFnz++ecMGzaMW265halTpwIl20YlluWbNWvGp59+Wvz41ltvzciRI4u/XrRoEXvttRcQWk1ts802rFmzpswPUInVr8Ty/vLo851KKGvYE7gNJaqSocysKfAscK67T4s5HImRZlZFpDYxoBMwFPht9OfVhPZSAPnlvI/Vq1fz17/+lVdffZU6derQpk0bTj31VIYMGcKoUaNo3bo1Zsbw4cP56quveOSRR+jWrdv/t3fn8VFV9//HX59AAmHflEWpyOICWjdQFhcERRDRAoKIirVKXX61tajVWlv35avW2ipqW7W4symyuSKIouIugoK4ISCKLCKBsITk8/vj3MkMIQkJJJlJ8n4+HnkIM3fuPTORm3fO+ZxztguTaWlpuDuNGjWibdu2+Y+ffPLJ3HTTTYwYMYJvvvkGd+exxx4D4Pvvv+eYY47JX2pqhzdUeKlBbMme1cBEwg/0t6mA4X2RimBmacDjwHR3fyrZ7ZHkUlgVkcouHTgGGBx91SeMGtWOni80BX733XesXLmSgw46iIyMDGrWrEnPnj258MILad++PXfccQf33HMPAwYMoHPnzjz1VPh5mZmZyUknncSVV14JhN7UxNn3Zsb777/PMcccA4RJUTVq1GDatGnMnDmTdu3acfjhh+e3Y+TIkTubuR8TG97/hDC8PxX4qhSfk0hl8hegMXBlshsiyacyABGpjBoTek6nEIb3JwEXAs2BOsSD6g42btzIjTfeSOvWrbn66qtZunQpEEJm//79ad++PT/99BOrVq3KXy6qZ8+efP/99+Tk5ABw0EEHkZmZyTffhBH2WNiM9bKuW7eOJUuWbPdcbLH/WFDdycx9CL2k6wnD+5OA30bvrwtwDwqqUkWZWT/gImCIuxdeHyPVinpWRaSyaEUIqMOBjsR3jyqVtLQ0Tj75ZI455hgmTJjA8uXLad++fX5o/OGHHxg8eDDbtm2jdevWdO3alS5dulC/fn2mTp3KoEGDWLduHW3btiUrKwuAF198keXLl3PBBRcAcO+999KyZcti1zstYnh/M2Ht07XEh/ffItSlilR5ZrYvMAYY7O7fJ7k5kiIUVkWkMvgjcGv051ivaZGz9xO5e35oNDMyMzM59NBDqVmzJuPGjeOLL76gW7du1KoVTteiRQvefPNNAO6777782tTzzjuPxx9/nAMPPJCZM2cC8Mtf/pLc3Fxat25Nhw4d8q+59957l+a9ZUXv5VPgKUJv8eLSnECkKjCzTMIvaLe4+5xkt0dSh8KqiKS6FsDNFDO0HxNb+zQWUGvUqIGZ5c/Sz87OpmbNmvmTmQ4++GC+/PLL/LVTC56nZ8+ePPzww+Tl5XHWWWexxx57MHz4cJo3b86oUaOAULPaqVOn0ryfXMLQfk3gVWAs8CKhN1WkWrIw1PAA8BlhFQuRfAqrIpLqLqaIe1VeXh5mlj+knvjfWEBdtGgRkydPZsqUKRx44IHccMMN+cH0qKOO4p133uHbb79lr732Ijc3l61bt5KZmcm8efN46qmn6NOnD+np6WRkZDBw4EAGDBhAzZqlvnVuBvIINajPRF9zCBsRiEioUT0c6ObarUgKUFgVkVT3M6GOE2C7naNi9aCxxfhHjx5Ns2bNOP300xk1ahRz586lXr169OvXj//973/st99+rF+/Pv/EnTt3plGjRmzYsIHNmzeTkZHBkiVLuOyyy8jKyuLoo4/mD3/4w3b1pTVr1txup6lixIb3FxIf3v888b2ICJhZV+AGoLu7b0x2eyT1KKyKSKp7mzCZqhbEe09zcnLIysriyiuvpGXLltx8880sXbqUNm3asHnzZnr27Mn1119P3bp1ef3117nnnnt48803ueyyyxgxYgQ1atRg69atfPTRRzzzzDOsX7+eSZMmccIJJ/Dkk0/SrFmzIhtUREjNAzYQlsqaCTwNvACsKcsPQ6QqMbPmwATgfHf/MtntkdSksCoiqe7dxL/k5ORwxx130KpVK4YPH86HH35I06ZN+emnn/j+++9p1qwZdevWpWHDhpx//vksWbKEjh07cuqpp3L77bfToEEDADZv3syNN95IvXr1GD16NH369KFOnToANGvWDHfH3XfWe7qFMFN/I2FiyDPA64RwLSLFMLOahJrtMe4+NdntkdSlsCoiqS6XsF3qUMDS09Pp2bMnt912G0OHDuWII47gp59+4pNPPuHLL79kyZIlHHXUUQD88Y9/zF+cPya2MkDt2rW59dZbC30O2K4WtoBY7+li4sP7n6HhfZHSup3wC9/1SW6HpDiFVRGpDMYD/YAGAD169KBhw4bcd999dOvWjfXr17Ny5UpWrVrFsmXLAOjVq1f+i3NzczEz0tLSdugpTZykVYLh/dmE4f3ngVVl/i5FqgkzGwIMAjq7u7YJlmIprIpIyoqWszlszz33PGLZsmX1Y0tOAVxyySXccsstNGjQgL/+9a+YGV999RW5ufGfe7HJWLGVAQpTRECNDe9vIuweNZEQVLeUxfsSqc7MrCNwP9DH3bVkm+yUtlsVkZRiZplm1t/MHgSWAWN//PHH2hs2bPgs8bju3bvTv39/xo8fT3p6Oh07dmT06NEMGzYs8VylufQGQhhdCNwCdAP2JGxz+jIKqiK7zcwaEOq7r3T3j5LdHqkcTMuZgZm5u5fqp5qIlB0zawH0B04Fjgc+BqYCU9z98+iw/wfcAdSJvW79+vVMnDiRIUOGULdu3Z1NhioocXh/DmF4fzqwcvfejYDuq7KjaKTkGWClu1+c7PZI5aGwim6qIhUt+qH1S2BA9LUfofdyKvCCuxe23NM+wCJ2spNV4jqshdhKWIh/C/AcYXh/FmHRfilDuq9KQWZ2FTAQOM7dNVIhJaawim6qIhXBzGoRek0HAKcQakKnRl9vuHtJlnv6Gti3lJeObW26hNB7OhmYh2bvlyvdVyWRmfUGHgeOdPflyW6PVC6aYCUi5cbM9iQM7w8AegPzCeG0H7BwF7ZVfBq4nGiDgCI48d2j3iIsLzUd+L6U1xKR4u0B/AY4ADDCElRLCh5kZr8AngCGK6jKrlDPKuoBECkr0fB+J0I4PRU4EHiFEFCfd/fVu3mJvYAvCKUAif9mY0P72wjrnk4AXiXM5pck0H21ymsOvAe0ANIJ//a2AhcRelABMLPawBvAOHe/KwntlCpAYRXdVEV2h5llAMcRrz814sP7s8uhNq0b8AChzrUm8C1hF5zngA/R8H5K0H21SksnbIP8y+jPibKBJ4HfAVvN7D9AI+CMXRhJEQFUBiAiu8DMmgEnE8LpiYTlnqYSelMXlPMPpbeBwwhhdQVhyF9EKs4/CKMmBYMqhNU6zgKO7N69+2PA0cBRCqqyO9SzinoARHYmGt4/kHjv6cGEYfbY8L6We5Lt6L5aZQ0DHiZhCTnYcRWOvLy8bevXr68xY8aMEaeffvoTFdxGqWIUVtFNVaQwZpYOHEs8oKYTH95/zd213JMUSffVKukg4B0SguqSJUto06ZNca/ZBPwN+Dsq0ZFdpB2sRCSfmTUxs7PMbCzwI3AbsAYYDOzj7v/P3V9UUBWpdhoCLwKZsQeWLl3KOeecw9y5c4t7XSZhlYDngHrl2D6pwlSzKlLNmdn+xHtPDyMskj8V+KO7a7knEUkjrLDRjIRVOM444wyGDBlC165dcXdycnLIyMgo7PV1gT7AR0BXwi/AIiWmsCpSzZhZTcKkh1hArUsIp3cAM91dyz2JSKJrge4krG+8evVq9t57b0aNGgXA5Zdfzrfffkvz5s25/PLLadeuXcE61tqEXejGE9ZcFikxlQGIVANm1sjMzjSzpwjD+3cB6wmTJfZ294vcfbqCqogU0Ae4mvBLbb4mTZpgZkyYMIHrrruOn376idtuu42tW7cycuRINm3aVNi2x+nAIRXUbqlCFFZFqigz62Bmo8xsFrAUGA68Bhzs7p3d/QZ3/1BLyohIEdoQhv8zCz6RlpbGmWeeyezZs1m1ahWXXnop++23Hw899BCNGzdm0aJFRZ2zMdtv6CGyUyoDEKkiouH9bsSH9xsB0whrIs5w9+zktU5EKpnawAsU6FGF+DJVp5xyCp9++inPPPMMjRs3pk6dOjRr1oyPP/6YzMwd8i2EneamoVUBpJS0dBVaYkUqLzNrCJxECKf9gGXEl5f6wN3zktg8qcZ0X63UDHgCGEiBXtXc3Fxq1KhBdnY2X331FQcffDDjx49nzpw5rF+/nhUrVjBw4EAuvvjiHdZeBdYStmP+ocLeiVQJCqvopiqVi5m1Jd57eiQwhxBOp7n7smS2TSRG99VK7ULCuqjb9aomhs9TTz2Vs846i9NOO43atWuzdu1aatSowcqVK9lvv/0KO+cmwm53b5Zz26UKUs2qSIozsxpm1t3MbjezT4G3CHty3we0cveT3f0BBVURKQNHAndTTFC97rrraNasGYMHD2bEiBEsWrSIJk2a0LBhw6KC6kbgzyioyi5SzapICjKz+oRZuAOAkwnDZlOA3wDvaXhfRMrBHsB0CmylCvGw+uyzzzJ79mxeffVVLrzwQtq2bcsBBxxQ3Dk3ETYT+Ff5NFmqA5UBoOEqSQ1mtg/x4f1uwNtE9afu/m0y2yZSWrqvVjo1gTeAw4EMgLy8PCZPnkzv3r1p0KABixcv5owzzuC5555j2rRpvPbaa0yYMAGgsPpUgDzgG8JIkCZ4yi5Tz6pIkphZGmHILRZQWwDPA/8BTnf3rCQ2T0SqlzsJoTJ/C6phw4bRuXNnBg4cCMDDDz/MzTffzPLly3n88ceZOXMmEJ90VYhsoC8KqrKbFFZFKpCZ1SNMMhgA9AdWEXpPLwLecffcJDZPRKqnwcBvSRj+z8nJoWXLlvz8888ceeSRTJw4kZtuuomtW7fSr18/7rvvPurUqbOzoHom8GXFvAWpylQGgIarpHyZWWvgFOBUwjan7xDqT6e5+9fJbJtIedF9tdI4AHifQtZT/eCDDxg0aBDNmzdn8uTJtGzZEoAFCxZw0EEHkZeXR1paofO0NwL/BP5Sju2WakRhFd1UpWxFw/tHEB/eb01YXHsq8JK7/5zE5olUCN1XK4X6wAJgbwpZHejbb7/llltuoW3btixbtoyTTjqJU089FaC4oLoFmAv0ItSsiuw2hVV0U5XdZ2Z1gBMI4fQUYB3xxfnfdvdtyWudSMXTfTXlGWE3qV6E3aqKtGzZMiZNmsRnn33GoYceysiRI4sa+nfgR6AjYQMAkTKhsIpuqrJrzGwvQjAdABxLGEqLzd5XnZZUa7qvpryrgWspZPi/MKtWrWLWrFlMmTKFc845h5NOOqmww7IJpU4flV0zRRRWAd1UpWQsrMtyOPHh/TaE9QOnAi+6+7qkNU4kxei+mtJ6EXpVM3d2YKLNmzfz6aefcsQRRxT2dDZwCfDo7jdPZHsKq+imKkUzs0zCjT0WUDcSwukU4E0N74sUTvfVlNUamA80LM2LCq6jWuDv2cDTwAVl1EaR7SisopuqbM/MWhKWlRoAHE8Y0ooN73+ezLaJVBa6r6akWoRypQOIlq7ctm0bS5YsoUWLFtSrVy//wFgY3bZtGzVrFrvK5TbgM6ALsLXcWi7VmtZZlWovGt4/hHjvaQfgJWA8cJ67a6KAiFQFDwJtSfjZP2zYMHJzc/n4448ZP348Xbp0AcDMWLVqFa+99honnHACjRs3LuqcGwhbQiuoSrlRWJVqycxqE3pNY7P3txJ6T68G3nD3nCQ2T0SkrP0GGErCwv/XXHMN7s6kSZO47bbbmDFjBg0bNmSfffYhPT2dxYsXM27cOOrUqUP//v0LO+cm4FfAdxXyDqTaUliVasPMmhMf3u9FqNuaStgOcKGrJkZEqqbDgXtJCKorV65k0aJFPPjgg0BYU3XevHlMmzaNo446ivPOO48ePXqwdu1a7rvvPo477rjtygQI9fs3ALMr8H1INaWaVVRbVVVFw/sHER/ePxB4hRBQn3f31UlsnkiVpvtqymhKqCndg7C2av4WqVlZWdSvX5/ly5czcuRInn76aTIzMxk1ahTr1q3jySefBGDDhg0Fg+pmwr30NMLaqiLlqtDtJ0QqKzOrZWZ9zOxe4BvCrP0WwN+APd19iLs/pqAqItVADWAS0IgoqAL84Q9/4JtvvqF+/foA7L333kycOJFGjRpRq1Ytrr32WnJzc1m/fj3uXjCo5gE/AMNRUJUKojIAqfTMbA9Cgf8Awi5SnxF6T08BPtXwvohUU7cQSgAyYg+cccYZNGzYkH333Xe7A+vWje8N8Lvf/Y6OHTvSoEGDws65iVA6taE8GixSGIVVqXSi4f2OxIf3DwJmEALqJe7+YxKbJyKSCk4FLiWhTnXRokWsWbOGcePGATBr1iw+//xzjjnmGNq3b8+WLVv4xz/+wbZt27jpppsKO2c2cA6gJfykQqlmFdVWVQZmlgEcQzygphOtfQq85u6bk9g8ESlA99Wk6gB8CGw3fv/dd98xcOBApk6dyoQJE3jmmWfo0KEDCxcuZOTIkYwYMYK3336bI444goyMjIIL/28kLH11RcW+FRGFVUA31VRlZk2BfoRw2gdYTDygfqLhfZHUpftq0tQlrHSyD4XMS7nzzjupV68eH3zwATfccAN77bUXs2bN4tJLL2XmzJnsueeewA47VG0lbCZwLJBbIe9CJIEmWEnKsOAAM7vSzF4HvgZOB14GDnT3o9z9Znefp6AqIrIDA54AWlLEz/cjjjiCl156iQULFjBnzhwAjj/+eJo1a8b69evjJ7Ltfs/4mTDzX0FVkkI9q6gHIJnMLB04mvjwfibx3tNZ7r4pic0TkV2k+2pS/BG4idC7WqQFCxZw55130qRJE2rVqsWXX35Jw4YNefjhhws7fBNwHPBe2TdXpGQUVtFNtaKZWWPCbNJTgZMIPahTCAH1Y/WailR+uq9WuGMI20Rnxh7YunUrGRlhIYDYsH7sv1lZWcydO5eff/6Zn376iZEjR253XCQbuAz4bwW+D5EdKKyim2pFMLMOxHtPjyDsejIVmObuK5LZNhEpe7qvVqiWwKdA49gD8+fP57///S/nnXcehx12GAB5eXmkpaWRk5NDenr6DicpEFQ3Ac8QZv+LJJWWrpJyYWY1ge7EA2oDYBpwN/Cqu2cnsXkiIlVFBvA8BWb+jx8/nhdeeIHc3FyOPvpozjzzTNLSQhlreno669atY/78+XTv3p20tDTMLDGobiNsqjKyAt+HSJEUVqXMmFlDwvD+AMIs/m8JvadnAx+6e14SmyciUhXdC+xHWM4v37Bhw/j888856qijmD17Nps2baJly5a0aNGCww47jClTptC8eXNq1KhR2DmzCRutaElASQkqA0DDVbvDzNoR7z3tArxBfHh/eTLbJiLJo/tqhTgb+DcJC//H5OXlceWVV9KvXz9q1arFvffey6xZs5g4cSLHHXdccefcRJhPMKN8mixSeupZlVIxsxpAV0I4PRVoAkwH/gXMcPeNSWyeiEh18UuKCKoAaWlpNG/enGXLljFs2DA+/vhjevTowdixY0lPT6d79+6FvWwjcDsKqpJitM6q7JSZNTCz083sUeAH4H5CTdN5QCt3P9/dJyuoiohUiEbAiyTM/P/+++8ZP348999/P8uWLQPg/PPP56uvvqJ3796cfPLJPPjggxxwwAG0b9++sHNuJoyM3VL+zRcpHZUBoOGqwphZG+LD+12Bt4gP73+bxKaJSCWg+2q5SQNeAXoAtWIPnnjiibRu3Zq6deuycOFC7r33Xn7xi1/wpz/9iXXr1vHkk08CkJ2dTZ06dQrO/HfgO6ATsB6RFKOwim6qkD+8fyTxgNqcMLw/FXjF3bOS2DwRqWR0Xy03NwKjSFj4/7LLLiM7O5v//Oc/ZGdnc80119C3b1/69u3Lxo0bqVGjBrVr1yY3N7e4CVVdgM8q5i2IlI5qVqsxM6sH9CGE05OBHwnh9LfAu+6urfVERFJHP+AKEob/s7KyaNWqFYMHDwagTp067LvvvjzyyCP07duXunXrkpsbbuXFBNXzUFCVFKaa1WrGzH5hZpeY2QvA98DFwEdAV3c/2N2vcfe3FVRFRFJKW2AcCUEVoH79+lx44YU0bdo0/7Fjjz2WH3/8EQjrrY4aNYoiRlGzgUeA8eXVaJGyoJ7VKs7M0oDOxIf39yYsIP0IcIa7qz5JRCS11SFMqNph5n9ubi4NGzbc7rH27dvTunVrvvzyS+68805Gjx6dWJ8ak0PY9eqP5dRmkTKjntUqyMzqmtlpZvYQoWh+DGGXk98Bzd19hLtPUFAVEUl5BvyP0NGw3Th+rAZ18+bNvPXWW/mPZ2RksHjxYrp27cpFF13EkUceSV7eDnuyrCd0YGwr3+aL7D71rFYRZrY3cArh5nMM8B6h/vQ2d/8qmW0TEZFddgnQnwLD/+6eX4N6+umnc/7555OVlcW2bdto3Lgxhx12GD169OD8888HyN9qNbKJ8LNiZUW8AZHdpdUAqJyzVi2M6RxOfHi/DWGYaCrworuvS1rjRKTaq4z31RTUDXiVAkE10bXXXsuPP/7I6NGjOeuss7jpppvYf//9Wbt2LU2aNAEouEzVRuBq4L5ybrtImVHPaiViZplAb0I4PQXYQAino4A33V3DOSIiVUNzwv19h6Cal5dHWloa48eP56233mLGjBmcf/757Lfffuy///7k5uYWFVQ3EZYkHF1B70GkTKhnldTuATCzlsSH93sCHxJuYFPdfXESmyYiUqRUvq9WAjWBt4FDgPTEJ2JBdeHChQwfPpwpU6bw7LPP8tZbbzFu3Dhgh4Aakwt8BRxKCK0ilYZ6VlNMNLx/KPHh/XbAS8BY4NfuvjZ5rRMRkQpwN9CRhKAaC6AbN26kfv36PP7449x666188803jB07llmzZgHxMFuIbMI6rQqqUumoZ5Xk9wCYWW2gF/Hh/S3AFEIP6hx3z0lW20REdkWy76uV2FDC7P8dlqnKy8vj97//PQMHDqRXr15kZ2fTt29f/vWvf3HYYYcVt0PVJmAw8EL5Nl2kfKhnNUnMrDlhhucAQlD9hBBO+wCLXL9FiIhUNwdQIKgmDumnpaVx8MEH884779CtWzfq1q3Lgw8+SKdOncjLyysqqG4k9NQqqEqlpZ5VKqYHIBreP5j48P4BwMuEgPq8u68pz+uLiFQk9azukreAoyhkDfSnnnqK1q1bc9BBBzFy5Eg6derEDTfcABRZowphlO5N4ERgh4VWRSqLah9WzawmYSePmmW9xaiZ1SJMiooF1FyiyVHA6+6+tSyvJyKSKhRWS82ArRQy4rl69WoGDx7MkiVLuOeee9iwYQPXXnstV155JZdccklRNaoO/ECofV1Xng0XKW/VcgcrM6tlZmc3NpufBltrAWmQ08hsvpmdHYXMXT33Hmb2azN7hrDg8t+A5cDJQDt3/4O7z1BQFRGRBA6szv9L1JG0ZcsWmjZtys0330zjxo2ZPn06DRs2pFmzZtx5550sWrSoqPNtAvqioCpVQEqGVTPraWbLy/B8e5jZ52ZW28yOzIQVR8P9/4ODtoBtBraAjYGDesD9mbDCzLqU8NxmZp3M7GozexP4ktCLOgXo4O493P12d/8UONjM3ir2hOGcF5rZPbv+jsuXmb1gZueW8zWeNbO+5XkNEZEU8zLRbP3YsP7999/PFVdcQcOGDRk/fjwtW7bkkEMOYfz48Zxzzjl07NixsPNkA78lzIUQqfSSElajsLMh+soxs60Jf3+wHC55NaFo/eA6MPN30CQX6g8HTogOqAn8CpgD9UdBE4O5ZpZtZm+ZWf7dwMwejNq5ycy2EuqA5hP2bb4NeBboTNgd5GUz6xd7rbt/AqwzswFFNdTMMoBrgTsTHutlZh+a2Xoz+9rMfpvwnJnZzWb2nZn9bGavmVmn3fu4tmvP9Wb2ROJj7t7P3R8tq2sU4XbglnK+hohIKhkJzCZMigKgV69eHHHEEQwdOpS7776bL774gilTptCuXTtuvvlmIKwSkCAbeAJ4sgLbLVKuyiWsRnWgRYrCTj13r0f4B3VH7O/uflEZt6UWcC4wPhNefBrq9gEuIyTYgr4A/gXcCmm1w2+4zwNTzGxPMzsHaEKocZ0H3EDoQR3j7r8DZgHfAscBDYG/AuPNrE3CJZ4ELiymyacRVgP4Lmp/OjAJ+Hd0zjOAu83skOj4IcBvgGOitr0NPF7CzyZlV4Nw93eBBmbWOdltERGpIFsJq8TcSdTDesghhzB8+HDmzp3L3nvvzYYNG/jDH/7A8uXL80NqQs1qDuHH2KUV33SR8lNsWDWz8xL+XMvM7jKzpWa2MuphzIye62lmy83sKjP7gdCLudvM7HIz+9HMvi9pWwpxFKFmp/vhkH4qoTd1KNCqkINfIqS+q4HDoBbQCdgX+BoYBLwIHODuXYF7CMtOPQrg7hvd/Xp3X+Luee4+DfgGOCLhEq8BvYupi+1H+M06pgnQAHjcg/eAhYSieaK2zXH3r6MJYk8kPLcDM3Mz+39m9gXhpoaZ/dPMlkU9tx+Y2THR432Ba4Azot7kedHjr5nZBdGff21mc6Lvx09m9k1ib7KZ7Wtmr5tZlpnNMLPRsZ7aqCzjCTNbY2brzOw9C0t6JX5W/Yt6LyIiVVAeoSNkIJCVm5ubB9CoUSOuvfZaHn30URYtWsTee+9d2AoAGwjzIzQnQqqUnfWsjjazxtGf/w/Yj7C7UntgL8LkoZgWhGC1D6FWZne1IPQk7gWcX8q2JDoY+LwRXHUF1N/ZRT36ArgS6tYL657mAte5+0B3f8TdV0aHDAZWAa8Xdq4oeO0HfJp//tBjmgPsX1x7E45fCTwNnGdmNcysG+EznhMdMhZob2b7Rb2w5xICdXF+RQjxsVD7HuGzbAI8BUwws9ru/iJwKzAu6vU+pJBzEZ3rc6AZcAfwsMXvok8B7wJNgeuBcxJedy7he9w6ev4itt9dZSFhu0ERkermpXPPPfeCr7/+2vPy8jbHHmzatCn77bcfQMGwuokwMreiQlspUgF2FlY3APtHwWMk8Ed3X+vuWYQQMyzh2DxCoNvi7mWxnVsOcKO757j786VsS6JGwIb10OmUElz0REK35mvAScBGaEwoac0o5PBzgccKW8A/Co5PAo+6e8HpmllRu4pqb1aBx54mhPEtwBvAX9x9WfTc99FjnxNuVkOAPxb1/iK3RZ/dJgB3f8Ld17j7Nnf/O6FHuagwXZhv3f2/Uc/uo0BLoLmZ/QLoAvzN3be6+xxC2URMDiGktnf3XHf/wN3XJzxf3OckIlJlmVmrxx577B+9e/f+VVpa2iQS6lgLsRH4C+FngUiVs7Owmg3UA/Yg7KjxQTRcu47Qe7dHwrGr3H3zjqfYZWvcfdsutiXRT0CjdMgpSYHmAYS09TtCd5+FjtZFhOWn8plZa0Jt6mMFz2FmaYS60a3RqQqqT9HLifxEQg+wmR0AjANGEAJzJ+BPZhYbHr+OEAhbA7UJw0czzWyHrfoSLEv8S1RusTCaoLWO0NvZrJjXF/RD7A/unh39sR6h0mJtwmMFr/04ofJirJmtMLM7opAfU9znJCJSJUUTbScA9y9dunQacBZwOduPPMVsBmYQytJEqqSSTrBaTfhH0sndG0VfDaMJUjEVtbtASdqS6BOgbQ6kbyvigIJOBxYQFknNCws1tyYMlScaAbzl7l8nPhj1/D4MNAcGu3tOgedbEULn5xTuE0LpQMxBwOfu/lJUB/s5MJ1Q2wphmHycuy+PekbHEHqDi6xbJeF7FdWnXkUo423s7o2Anwnve7tjd8H3QJMCwbl1fiNCr/kN7t4R6A6cQvhcYw4kTGQTEalO/g6sIawwA+E+/G/CJjM/EjpvNhFGHOcRwmz13uFHqrQShVV3zwP+C/zDzPYEMLO9zOyk4l4XTebpubuN3M22vAs0qgufT4seyCX8KrqNULuwmTAeHfNBdMwT5G8lkguMMLNuZhbbfHkEMKaQ6z1ACFkDiiiH6AnMdPctRbT3eUKPbcxHQAcLy1eZmbUjhLpYiHsPGGJmzc0sLVqxIJ2w3mtJ1Cd8FKuAmmb2N8KErpiVQJuot7hU3P1b4H3gejPLiOpt85ftMrPjzezg6DNdT/g2JO4idhzaz1pEqhEzO5uwmP+I6OddoncJk2qvAv4EnEn4mVJciYBIpVeaAHIVIQDNNbP1hGGHIusazWxvwm9983erhbvZlminqDFZMO+uqBb0cSATuJhQ4JNJKIKN+QOhUPICYFsoXx0YPfUf4Hszm0aY5PR84rXMbB/CslSHAj9YfO3YsxIOOwsobi3ZqcABUQ8s7v4VYWmqfxEC3WzgGULvLYTJZvOAjwlD5n8k9OiuK+YaiV4iBMLFhGW3NrP9UP2E6L9rzOzDEp4z0VlAN0Ivwc2EkoZYUG8BTCS8r4WE9xZbKaALsDFawkpEpMqzsCThP4BBxdzDswnreN8HTCPcs0WqNCtkblDZnDj8dtjJ3f9cLhcoXVv2AObUhmbjoMmpJXjNFGAYrN0ErRJ7Qc1sX0LP5gCgK/AWIWBOdfelO2nHwcB/3L3bTo77LdDR3S8rQVMrFTMbR1hH9rqdHPcM8HA0uU5EKhkzc3ffYW0lKVy02s17wF/d/elkt0cklZRbWE1FZtalDsx6GuoWF1inAGfCxmw4PlrXtKjzNSAsbTWAsLbdCqLgCrxXyBBOtRP1kK4lrDfbB3gO6ObuHyWzXSJSvhRWSy4qs5oKfFEVOylEdle1CqsQwlMmvHg4pF8O9QcQ6lK3Ee4Ud0HWR5CzCfoWF1QLOW8NwnD3gOirMWEi1FRghrtXy5oiC1vL3k9Yomo5YdmsMtk0QkRSl8JqyZnZdUBvoHfBSbkiUg3DKuRvwXp6Q7g6Czqlw7YcqFkfFvwcakAnFjMBqqTXaEc8uHYhlMdOBaa5+/LiXisiUtkprJaMmZ1MmA/R2d1/2NnxItVRtQyriaIe0XrAhmhR+/K4RiPCHgMDCEtOfUu8XOBDlQuISFWjsLpzZtYWeJswoerNZLdHJFVV+7Ba0cysJmFN0VivawPCjM6pwKsFFtAXEamUFFaLF60//RZhIum9yW6PSCpTWE0yM+tAPLgeQVgqK1Yu8H0SmyYisssUVosWbR7zKGH5yHMK27JbROIUVlNItHRJP0JwPQn4ini5wMe6oYlIZaGwWjQzu4SwJnc3jaaJ7JzCaooys3TgaOK9rrWJlwvMdHctBC0iKUthtXDRTn6Tge7uXtKdBkWqNYXVSiAaMtqfeHA9BJhFCK7TNYNURFKNwuqOzKwFYeH/i9192s6OF5FAYbUSMrOmxMsF+hC2Sp1K2M9gvsoFRCTZFFa3F42WzQBe29kOfiKyPYXVSs7MMoBjgFMJ4bUG8TrX13Z3vVgRkV2hsLo9M/s7cCBwipYrFCkdhdUqJCoX6Ei8XOAgwm/ysXKBVUlsnohUIwqrcWZ2BnAbYeH/tcluj0hlo7BahZnZHsDJhOB6AvAZ8V7XT1UuICLlRWE1MLNOhCUJ+7j7R0lujkilpLBaTURbzB5HvNc1j/jqArPdfWsSmyciVYzCKphZQ8KEqpvd/bFkt0ekslJYrYaicoGDiAfXA4FXCBO0nnf3NUlsnohUAdU9rJpZGvAs8J27/79kt0ekMlNYFcysOdCfEFx7AZ8QLxdYpHIBESkthVX7M2Hi63EauRLZPQqrsh0zqw0cT7zXdQvx4PqGu+cksXkiUklU57BqZicStlPt4u7fJbs9IpWdwqoUKSoXOIR4cG0PvEwIri9oVquIFKW6hlUz2wd4BzjD3Wcnuz0iVYHCqpSYmbUkXi5wPPARUa+ru3+ezLaJSGqpjmE1GpmaAzzl7ncnuz0iVYXCquwSM8sEehOC6ynABuLlAm+6+7YkNk9EkqyahtWHgPrAMNX6i5QdhVXZbVG5wOHEywXaAC8SguuL7r4uaY0TkaSobmHVzEYClwFHufuGJDdHpEpRWJUyZ2Z7EXpbBwDHAu8TLxf4MpltE5GKUZ3CqpkdSVi3+hiVRImUPYVVKVdmVpftywXWES8XeFvlAiJVU3UJq9FOge8Dl7n7pGS3R6QqUliVChMtkn0E8XKB1sALhOD6krv/nMTmiUgZqg5h1cxqEkqe3nP3Pye7PSJVlcKqJI2Z/YJ4uUAPwnIvsXKBb5LZNhHZPdUkrN5O+AW8r7vnJrs9IlWVwqqkBDOrB5xICK79gVXEywXe0Q8CkcqlqodVMxsE3A10dvfVyW6PSFWmsCopJyoXOJJ4uUAL4HlCcH3Z3bOS2DwRKYGqHFbN7ADgDaCfu7+f7PaIVHUKq5LyzKwN8XKB7sBbxMsFvk1i00SkCFU1rJpZfULJ0t3u/lCy2yNSHSisSqViZg2APoTgejKwgni5wHvunldOl24FXA80IfSoTAe0DJdIEapiWI3WlB4PrHP3kcluj0h1obAqlZaZ1QC6Ei8XaEoIkVOBV9x9Yxld6kzgYaAGkAFsih5fA0wEngXeBrQMl0ikiobVK4AzCOupbk52e0SqC4VVqTLMrC3x4HokYY/uWLnA8l08bU3gB0IQLkwukA2kAS8B46L/ahkuqdaqWlg1s+OBp4Ej3X1pstsjUp0orEqVZGYNgZMIwbUfsIwQXKcAH5aiXOB44DmgQQmPzwJqAfOAJ6JrahkuqXaqUlg1s72Bd4ER7j4j2e0RqW4UVqXKixbu7kYIrqcSguc0QpB81d2zi3n5fcBFhBIAANydULq2U7FygVWEOrdJhIkZWoZLqryqElbNrBYwG3jO3W9PdntEqiOFVal2zKwD8XKBIwg/iKYC09x9ReKhhAlcLYo6V15eHmlpaSW57Dbi4fVFQrnAy4SeWJEqpwqF1QeA5sBg1w9MkaRQWJVqzcwaA30JwbUv8DVRneuWLVuyMzIyPgDqxI5fsGABmZmZtGvXbodzlaLHFWA9UBv4EHgyuqaW4ZIqoyqEVTP7NfBnoIu7r09yc0SqrRJ1CYlUVe7+k7s/7e7DCb0nVxDKBMbefPPNc7du3Vor8fh33nmHRx55BICJEycyffp0Yr/wlSKoEl0jg7Cawf8Biwi1rbdHj+nfpkgSmdlhwJ3AQAVVkeSqmewGiKQKd88BXou+Lt+0adPCjIyMAxKPyczMZNOmTaxbt45rrrmGvfbai/79+zN37lyWL1/O6aefDkBubi5mVtISgVjPbRtgFHAJ4IRdu8YBrwBltQyXiOyEmTUlLEl3ibt/luz2iFR36r0RKVzTzMzMtgUffP3119lnn32YPXs2OTk5nHvuuSxdupSxY8eybNmy/ONq1KiRH1Rzc3PJy4svPrB8+XLef7/IHRrTgfqEntczgEcJ67m+AVwMtC6TdycihYrWb34SeMbdJyS7PSKisCpSlH7AloIP1qxZk++++44PP/yQc845h3333Zcbb7yRffbZh4svvpjp06fTvXt3rrjiCubMmQNsH1xzcnJYvHgx559/Pk2bNi0utEKY4NWAsBTW0cBdwGLCzlm3AF3Qv2GRsnYd4d/c1cluiIgE+kEnUrhhhB7OfNu2bSMjI4OxY8dy3HHHcdppp/Hss88yY8YMzjzzTGrXrs3JJ5/Mc889R6dOnbjrrrvo0qULQ4YM4Y033sg/T69evbjttts47bTTSE9Pz398yZIl3HTTTXz5ZZG7uNYhTMpqB1wJzATWAo8TluSqU9QLRWTnzGwAcB4wzN21I51IilBYFdmRAb0KPlizZk1atGhBjx496NWrF1988QX33nsvZ511Fi1atGD16tX079+fSy+9lMzMTMaMGcObb77JBRdcwOrVq9myZUt+OP34449p06YNrVq1yj//Pffcw2233cYll1zCUUcdxbPPPltcG9OBekBD4CxCYF1LWIbrQmCvMvosRKoFM2tP2FZ5iLuvTHZ7RCROS1eJ7KglYQmr2sUdNHHiRKZNm8ZVV13FgQcemP/4K6+8wpQpU3jvvfeoVasWZ5xxBueeey5169YFQg3ryJEjOeGEExg2bFh+iUDHjh154YUX2GeffViwYAG1a9emffv2pVnLNWYjYfLkUsIErecIS2TpH7tUmMq0dJWZ1QXeBh5w9weS3R4R2Z7CqsiOMghBr3nBJ4oLjoU9N3/+fD744AN69OhBhw4dAHj//fe59957ufjii+natSsAq1atonnz5kyaNIm+fftSq1atHc4fW8d1zZo1vPHGG3Tq1Cn/nMXYGn1tAyYDEwjlA5uKe5HI7qosYdXCmnNPADnAeVr4XyT1KKyKFG448F+KqQMtKrjm5eXh7tSoUaOQV8GTTz7JJ598wsUXX0ybNm0AWL16Nf/+97/57LPP2LhxIw888AAtW7bc4bXffvstI0eOpHnz5nzyySe0b9+eBx54gD333LMk78kJO2bVAt4EniZsO/tDSV4sUhqVKKz+nlCn2t3d9UucSApSWBUpnAFnA38lLBeVxy5MYErc1WrevHk88sgjfPbZZwwdOpSRI0fucAzA2WefzeGHH86oUaO2e37BggX897//Zf/99+eSSy4B4L333qNLly4A7LHHHvTr14/TTjuNvn375pcdFCNWLrCEEFwnA/NQuYCUgcoQVs3saOAZoKu7f5Ps9ohI4TTBSqRwTpi0tF/0dQUwh7Cc1XpKGOgSQ2jr1q2pU6cOGzZs4E9/+hMXXXQRAGvWrNnuNU2bNqVOnXgujq3ROnPmTLKysti0aRPPPfccW7duzQ+qU6dOpW7dugwaNIgnn3ySSy+9tCTNq0voZd0fuCZ6f6sIk0z6sZOaXZHKzMxaEmq6z1VQFUlt6lkVKZ16wInAUKB/9FgmpdwNbvXq1XzxxRd069aN0aNH8/TTTzN06FBatmzJddddx2OPPUbnzp2BeM/qeeedx5dffsmQIUOYMWMGvXv35uKLLyYjI4OhQ4fSpUsXrrzyyu2uU7DXtoTygA2E2t05hF7X6YBmSEuJpXLPqpmlE2q3X3b3m5LdHhEpnsKqyK5LA44EBhLCawt2Ui4Q6yUtWOv68ssvM2nSJPLy8hg6dCi9e/dmw4YN1KtXDwjh9tprr6VXr14MHTqU9evX88tf/pIFCxZQr149DjzwQGrXrs2QIUO44IILSlTDumbNGurUqUNmZubODt1AWCrrK+LlAgtQuYAUI8XD6j+BtsBp7p63s+NFJLlUBiCy6/KAucBVwL7AgdGf5xJm4K8v+IK0tLRCJ2X16dOHBx54gH//+9/07t0bgFdffZW77rqLVatW0bRpU/bcc8/813700Ucccsgh5ObmAvD2228zZswYVqxYwYQJO98hMjs7m5tuuok2bdpw5513smXLDpt1JapHKBfoCFxLWOLnR+DfQLedXkwkhZjZcMKoyDkKqiKVg3pWRcpHfaAPcAah/tMpplzA3XH3HYLs5s2bSU9Pp0aNGjz00EOMGzeOQYMGMW3aNLp06cL1118PxFcmmDx5Mn//+995/fXXiywBWLhwIddccw05OTmMGTMGM6N+/fpkZGSU9j3mEZbAmg2cgnpaJUEq9qya2S+BV4He7v5JstsjIiWjnlWR8pFFmGU8FGhECKz/BJYRAt52S+SYWaE9rrVr185fAuuCCy7gyiuvZP78+fzmN7/h6quvZsWKFbzxxhv5r503bx5HH300K1euLLJWNTMzk59//pn58+dz3nnn0bRp0/ygmpeXl99bWwJphElaxwEnlfRFIslgZo0I/yYvU1AVqVzUsypS8doCAwjbpB5CWGGg/q6caNGiRfz2t79l48aNdOjQgeXLl3PHHXfQvXt3PvroI/bdd18aNWq03WsWL17Mo48+Ss+ePTnxxBNZvHgxX331FX369NlubdjCembXrVvHxo0b2WuvHXZznQMcsyvvQaqmVOpZNbM0Qq31N+7++2S3R0RKRz2rIhXva0Iv65HAnsAFwLOEdU+zgCK7NmPlAjEHHHAAr7/+Oi+88AJDhw5lzJgxdO/enVWrVnHHHXfw+uuv73CORYsWsXLlStq1awfApk2beOqpp+jcuTODBg3ioYce4ocfftghqC5btozhw4fTrl07VqxYUfC0awo+IJJC/gI0JixBJyKVTKmW2xGRMvczMD76qkmYsDQIGAI0iY7Jn65fMEDGguuee+7JoEGD8h9/7rnnqFWrFscdd1z+cWbGpk2bWLp0KU2bNqVt27YAfP311/zf//0fLVu25J133uHZZ5/lpJNOYujQoVx66aU0aNCACRMmsGzZMtasWcMVV1xB/frbdQRnAy+V3UciUnbMrC9wEdDZ3bcmuz0iUnoKqyKpYxvwRvT1R6ADcCph69eDKKRcoKi61MMPP5xjjz2Whg0bbjec/9133zF//nwOO+wwADZs2MCCBQv4+9//DkCvXr0YPnw4d9xxB+vXr6dBgwa8/fbbPPLII9x33328++67dOjQYbtNC4AahG1bRVKKme0LPAoMdvfvk90eEdk1qlkVqRwaA32BYcAJhGBblxAUSywnJ4d33nmHVq1a5fesxixbtozJkyczefJkMjIyuP/++1m6dCmXX345b775Junp6fTu3Zu7776bQw45JPGlXwHtd+fNSdWT7JpVM8sE3gLGuPs/k9UOEdl9CqsilU860INQLnA60JBQf17q7VHdPX/Zq8Re2pycHNyd6dOnM2LECLp06UKDBg3YsGEDU6ZMye9ZdfccM7uTUBMoki+ZYdXC/8z/I/xbOdv1g06kUtMEK5HKJwd4Dfg90Ao4HLgOmEfYjCCruBcn/tw2M2rUqIGZ4e7k5uaSl5dHeno6GRkZDBw4kKysLEaPHs3y5cuZO3cu9913X/7yVhs3bqx5yimnHGxmA82sXrm8W5HSu5Dw7+K3CqoilZ96VkWqlqaENV2HAb0IwbbU5QIx27Zto2bNUNrerVs37r//fvbff//8ntXc3Nys2rVr/3Xbtm2nAEcBbwJTganuvmx334xUXsnqWTWzrsAUoLu7f1nR1xeRsqeeVZGqZQ3wBGFHqUaEUoH/ACsJs/aL3Ve1oFhQXb16NYMHD6ZFixaJk6u8Ro0ak3Nycv7p7icCrYFHgK7AR2b2sZndaGZdonUuRcqVmTUHJgDnK6iKVB3qWRWpHgw4kPjqAvsTSgZ2Z+h+PXA2oSd1+4uZ1SAsw3UqYQOERoQVA6YCM9w9ezeuK5VARfesmllN4BVgjrv/taKuKyLlT2FVpHpqBpwMnAn0JB5cC+0BLWw3K0IvbRNCj22xzKw9IbQOADoDrxOC6zR3/26X3oGktCSE1TuBg4H+7l7iPYNFJPUprIpILeA4YDChbCCTsAZzrWJe48AsoHdpLxbt0d6XEFz7AkuI6lyBDzUhpmqoyLBqZkOAOwgL/2s3NZEqRmFVRBIZYQOC0wi9ru0Ik7QKlgtkE+piZ+3WxcLQbQ/iva71iAfXme6+aXfOL8lTUWHVzDoCs4GT3P3D8r6eiFQ8hVURKU5z4uUCxxLC7DLgd8CLZX0xM9ufeHA9lLBE11RgunYgqlwqIqyaWQPgXeB2dx9TntcSkeRRWBWRkjJCeP0RyCv3i5k1ISzDNQA4CfiCeK/rPJULpLbyDqvRwv/PACvd/eLyuo6IJJ/CqoikPDNLB44h3uuaQXx1gVnuvjmJzZNCVEBYvQoYCBzn7qVakk1EKheFVRGpVKIetQOIB9dfAjOJlwusTGLzJFKeYdXMehPWE+7i7svL4xoikjoUVkWkUjOzZsTLBfoAC4mXCyxQuUBylFdYNbNfAO8Aw919tyb4iUjloLAqIlWGmWUQluGK9boa8eA6W8PFFac8wqqZ1QbeAMa5+11leW4RSV0KqyJSJUXlAp2IB9eOwAxCcH3e3VclsXlVXjmF1f8AjYGh6jEXqT4UVkWkWjCzPQnLcA0ATgAWEO91/Uzhp2yVdVg1s/OBy4Gj3D2rrM4rIqlPYVVEqh0zq0XYZjbW67qNeHB9w923Jq91VUNZhlUz6ww8Dxzr7ovK4pwiUnkorIpItRaVCxxMCK2nAvsBLxOC6wvavnPXlFVYjSbQvQ+Mcvdnd79lIlLZKKyKiCQwsxZAf0J4PR6YR7zX9XOVC5RMWYRVM6tB2CntQ3e/qmxaJiKVjcKqiEgRzCyTEFhj5QKbiAfXOe6ek8TmpbQyCqu3AkcBJ7n7trJpmYhUNgqrIiIlEJULHEo8uLYDXgKmAC+6+0/Ja13q2d2wama/Av4JdNbKDSLVm8KqiMguMLNWxMsFegIfEPW6uvsXSWxaStidsGpm+wFzgFPc/d2ybZmIVDYKqyIiu8nM6gC9CBO0TgHWEy8XeKs6DmHvalg1s3qEHar+6e7/KfuWiUhlo7AqIlKGzCwNOJx4ucA+wAuE4Pqiu/+cxOZVmF0Jq1GpxVhgA3CBJrOJCCisioiUKzPbm9DbOgA4BniPeLnAV8lsW3naxbA6ChgOHO3um8unZSJS2SisiohUEDOrS9g9awAhwK4lTNCaCsx199wkNq9MlTasmtlxwDjCDlXfll/LRKSyUVgVEUmCqFygM6HOdQDQirBL01TgZXdfn8Tm7bbShFUz24vQ4/xrd3+5fFsmIpWNwqqISAows32Ilwt0B+YSLxdYksSm7ZKShlUzywBmE97nreXfMhGpbBRWRURSjJnVB04kBNf+wEriqwu8WxnKBUoRVkcDewGD3D2v/FsmIpWNwqqISAqLthw9kvjqAnuyfbnAhiQ2r0glCatmNgK4FuhSXVZJEJHSU1gVEalEzGxf4uUCXYE3CcF1mrsvTWbbEu0srJrZocArwPHuvqDCGiYilY7CqohIJWVmDYCTCMH1ZGA58XKB95M5rF5cWDWzJoQJVde4+7iKbZmIVDYKqyIiVUBULtCNeLlAY2A6IbjOcPeNFdyeQsNqtArCNGCRu4+qyDaJSOWksCoiUgWZWTviwbUL8AbxcoHlFXD9osLq9cDxwAnunlPe7RCRyk9hVUSkijOzRsTLBfoBS4iXC3xY1tuamllNIAeombhygZn1B/4NdHb3H8rymiJSdSmsiohUI1GQ7EG817UeYVh+KvCqu2/axfPWAoY0gqvWQ6d0sBzw+vDpz/B/wAfAa8BAd3+rDN6KiFQTaclugIiIlIyZXWNmD0V/bmNmHoVPzOw1M7tgZ+dw923uPtvdr3D3/QlD8ouBJ4FVZjbFzEaaWctStOvITFhxNNz/PzhoC9hmYAvYGDioBzyQCfOBMcUFVTOrZWaLzGzPnVyvo5m9X9L2VbTE71M5XuP3ZnZ7eV5DJFUorIpItWJmS8xsk5ltMLMfzGyMmdUr4Wt/bWZzSnGt7QLl7nL3W919p4G0lOdcTAirbwO/AMYC5wPLzCzXzH6OPqP892BmTcxskpltNLPvM+D1sdDkDaj/K8J2VAcADYB/Ak9CvbFQow78PzN7K/rsY19bzWx+1JYtwCPAVTtp9k3AXQnt+Z2ZvW9mW8xsTOKBZtbVzF4xs7VmtsrMJpQmiO+MmfU0s+1qgMvj+1SI/wBn7yzYi1QFCqsiUh0NcPd6wKHAYcCfk9ucpLsIeNzd17r7U8CjwAlAX2AcMAxYbWYPmNnJwAPAVqB1BtSpCbXaRSdaDQwipMm1QGfgDOBU4Gmomwn7A03dvV70PXgLmJDQlqeAc6Oygh1EQfN44LmEh1cANxOCbkGNCcGuDbAPkAX8ryQfigUp+XPS3TcDLwAjkt0WkfKWkv8IRUQqQjTJ5yVCaAXAzK42s6/MLMvMPjOzgdHjBwIPAt2iHsF10eP9zewjM1tvZsui2e4xr0f/XRe9ppuZpZnZtWb2rZn9aGaPmVnD6Fw79NJFPcEnRH++3syeKMl7M7PfmNlCM/vJzF4ys32KOC4D6EXoEI19Lg+4+2vu/oq7/xa4BvgI+Br4CzAUaALc3gXSBgGPR699FugEDAFqA9cD84BFhMB6GGQAp0fXbgMck/ByopUKfiJseFCYEwmTwjYnvOZZd38OWFPwYHd/wd0nuPt6d88G7iPU7BYqKqe4xczeBLKBtmZ2XvRZZpnZ12Z2YXRsXUJgbJXQU9wq8fuU0Lt+rpktNbPVZvaXhOtlmtmj0fdpoZn9KfH/ATO7ysy+i679uZn1Tmjua4TteEWqNIVVEam2zGxvwuz4LxMe/ooQoBoCNwBPmFlLd19I6IF8O+oVbBQdv5HQu9WIEBwuNrNfRc8dG/23UfSat4FfR1/HA20JE5zuK+P39StCwBwE7EFYturpIg7vAOTtZDmrY4F33P1O4HfAZuCxBjD0Cqh3CPBpdOCnwCEJL6wLtEt4/gqo1xCujv46AnjD3b8pcL2FBU6T6GDg82LaujPHJjSnKOcAvwXqA98CPxJ2DWsAnAf8w8wOj9au7QesiPUUu/uKIs55NKFXuTfwt+iXH4DrCL2+bQlB/OzYC8xsf8Ln3cXd6xNWdFiScM7iPieRKkNhVUSqo+fMLAtYRggi18WeiHrhVrh7XrS70hfAkUWdKOqBnB8d/wkhFB5XzLXPAu5296/dfQOhBGFYWdW1Ri4EbnP3he6+DbgVOLSI3tVGhKHxQpnZeYTR/FiNaD3gZ+CpDdDgFEKqj51gQ/T3RInPDwh/7mRhE4MRwJhCLpsVtaswxba3OGb2S+BvwJU7OXSMu38aTUbLcffp7v6VB7OBlwm/0JTGDe6+yd3nETqbYyFzKHCru/8U/cLwr4TX5AK1gI5mlu7uS9z9q4Tns9jx4xapchRWRaQ6+lXUU9WTMBeoWewJMxthZh+b2bpoqP+gxOcLMrOjzGxWNHnnZ0Lva5HHA60IvXUx3wI1gea7+mYKsQ/wz4T3sBYwYK9Cjv2J0IO4g6iH9nagn7uvjh7eQOhhrJcOOTWB9QknqBf9PVHi8zWBdNhGqIltAUws5NL1gXVFvLci21scM2tPGLL/g7u/sZPDlxV4bT8zmxtN0lpH2Nq2uO9xYRLXlc0mfFQQ/n9IvF7+n939S+AyQjXFj2Y21sxaJRxbn/CLg0iVprAqItVW1Es2hqjXMOp5/C9h6LVpNNS/gBD0AApbmPopYArQ2t0bEupaizt+BSFMxvyCEN5WEkoK6sSeiHof9yj9O2MZcKG7N0r4yixi2agvwqVsuyBrZn0Jn8UAd5+f8NRiQuZskQPp2wjdhJ2iJztFf4/ZSKiriD2/DcgJrx8CPBv1Lhd0YIHTJPoE2K+I5woVfV9nADe5++M7O56E71s00esZwv8jzaP/J56n+O9xaXwP7J3w99bbNcT9KXc/mvD/jBPWrI0p7nMSqTIUVkWkursHONHMDiWUWDqwCvKHwA9KOHYlsHc0KSmmPrDW3Teb2ZHA8ITnVgF5hHrEmKeBP5rZvhaWzLoVGBcN1y8GakeTttKBawnDwKX1IPBnM+sUvY+GZjaksAOjLU9nkFC6YGa9COuuDnb3dwscv5Ewj+r6+vDZncBkQpEnwEBCun+GUNh6I/BLQvc1hJ0H6sFnhElWYwq2JwrNTYC5Rby3V4DDzax2wmtqRn+vAdQws9oWX392L2AmMNrdHyzinMXJIHwPVgHbzKwf0Cfh+ZVA09gkuV0wnvC9ahy19XexJ8xsfzPrFQXmzcAmQmlAzHGE3mKRKk1hVUSqNXdfBTwG/NXdPwP+TlhzdCVhMs+bCYfPJEzO+cHMYsPilwA3RjWwfyOEj9i5s4FbgDejIfmuhOWVHiesFPANIYRcGh3/c3S+h4DvCB2TxU18Kuo9TSL0wI01s/WE/NivmJf8m3jeBPgroRby+YRZ7omh6BIg82dofz34A8R7TvcgBNW/ENaMeoewcGvMXZC1Psxi/xmYVUhbhgOPRmuuFvbeVhK+D6clPHwtIchdTZigtCl6DOACwi8L1yW8l8J6cwvl7lnA7wnf15+i9k1JeH4R4ReQr6PvcatCT1S0Gwnf428IvzRMBGLvvRahDGM1oYxgT8LEOaJwfjJhmTGRKk3brYqICBY2O7jU3T8qxWtqZcKKsdDk1BIcPwUYBms3QavCwmjUgzgPONbdfyzmuh0JIe1Ir2I/xMzsYmCYuxc3SQ8zu5RQevKnimmZSPIorIqIyC4zsy51YNbTULe4wDoFOBM2ZsPx7v5eRbUv1VnY5KAtoTe/AzAduM/d70lmu0RSicoARERkl7n7e9lw/DBYezRkTSJMoiL67ySgB2QNg7UKqoXKIJRhZBHKGyYD9ye1RSIpRj2rIiKy26Ih/NMbwtVZ0CkdtuVAzfqw4OdQPzuxqDpUEZHiKKyKiEiZipbcqgdscPfcnR0vIlIchVURERERSVmqWRURERGRlKWwKiIiIiIpS2FVRERERFKWwqqIiIiIpCyFVRERERFJWQqrIiIiIpKyFFZFREREJGUprIqIiIhIylJYFREREZGUpbAqIiIiIilLYVVEREREUpbCqoiIiIikLIVVEREREUlZCqsiIiIikrIUVkVEREQkZSmsioiIiEjKUlgVERERkZSlsCoiIiIiKUthVURERERSlsKqiIiIiKQshVURERERSVkKqyIiIiKSshRWRURERCRlKayKiIiISMpSWBURERGRlKWwKiIiIiIpS2FVRERERFKWwqqIiIiIpCyFVRERERFJWQqrIiIiIpKyFFZFREREJGUprIqIiIhIylJYFREREZGUpbAqIiIiIilLYVVEREREUpbCqoiIiIikLIVVEREREUlZCqsiIiIikrIUVkVEREQkZSmsioiIiEjKUlgVERERkZSlsCoiIiIiKUthVURERERSlsKqiIiIiKQshVURERERSVkKqyIiIiKSshRWRURERCRlKayKiIiISMpSWBURERGRlKWwKiIiIiIpS2FVRERERFKWwqqIiIiIpCyFVRERERFJWQqrIiIiIpKy/j+0b3ibUP1UigAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "selected_items = [\n",
    "    \"Matrix, The (1999)\",\n",
    "    \"Godfather, The (1972)\",\n",
    "    \"Lion King, The (1994)\",\n",
    "    \"Aladdin (1992)\",\n",
    "    \"Ratatouille (2007)\"\n",
    "]\n",
    "\n",
    "selected_nodes = {\n",
    "    item_name: get_item_id_by_name(item_name) \n",
    "    for item_name in selected_items\n",
    "}\n",
    "ivd = {v: f'{k} ({item_frequency[v]} ratings)' for k, v in selected_nodes.items()}\n",
    "    \n",
    "G = items_graph.subgraph(selected_nodes.values())\n",
    "G = nx.relabel_nodes(G, ivd)\n",
    "\n",
    "edge_labels = {}\n",
    "for e in G.edges:\n",
    "    weight = nx.get_edge_attributes(G, 'weight')[e]\n",
    "    frequency = nx.get_edge_attributes(G, 'frequency')[e]\n",
    "    edge_labels[e] = f'w={weight:.2f}, f={frequency}'\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=(12,12))\n",
    "pos = nx.circular_layout(G)\n",
    "nx.draw_networkx_nodes(G, pos, ax=ax, node_color='red', edgecolors='black', node_size = 200)\n",
    "nx.draw_networkx_edges(G, pos, ax=ax, arrows=False)\n",
    "nx.draw_networkx_labels(G, pos, ax=ax)\n",
    "nx.draw_networkx_edge_labels(G, pos, ax=ax, edge_labels=edge_labels)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3a9e191-9592-4f32-b00f-0356800b1b06",
   "metadata": {},
   "source": [
    "# Sampling Random Walks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "id": "6823ac71-aa89-41be-9c65-56bc9edee233",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Random walks iteration 1 of 5: 100%|██████████| 1405/1405 [00:05<00:00, 276.32it/s]\n",
      "Random walks iteration 2 of 5: 100%|██████████| 1405/1405 [00:05<00:00, 278.28it/s]\n",
      "Random walks iteration 3 of 5: 100%|██████████| 1405/1405 [00:04<00:00, 284.82it/s]\n",
      "Random walks iteration 4 of 5: 100%|██████████| 1405/1405 [00:05<00:00, 259.39it/s]\n",
      "Random walks iteration 5 of 5: 100%|██████████| 1405/1405 [00:05<00:00, 274.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of walks generated: 7025\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "def next_step(graph, previous, current, p, q):\n",
    "    neighbors = list(graph.neighbors(current))\n",
    "\n",
    "    weights = []\n",
    "    \n",
    "    for neighbor in neighbors:\n",
    "        if neighbor == previous:\n",
    "            # Control the probability to return to the previous node.\n",
    "            weights.append(graph[current][neighbor][\"weight\"] / p)\n",
    "        elif graph.has_edge(neighbor, previous):\n",
    "            # The probability of visiting a local node.\n",
    "            weights.append(graph[current][neighbor][\"weight\"])\n",
    "        else:\n",
    "            # Control the probability to move forward.\n",
    "            weights.append(graph[current][neighbor][\"weight\"] / q)\n",
    "\n",
    "    # Normalize the probabilities of visiting each neighbor\n",
    "    weight_sum = sum(weights)\n",
    "    probabilities = [weight / weight_sum for weight in weights]\n",
    "    \n",
    "    # Probabilistically select a neighbor to visit\n",
    "    next = np.random.choice(neighbors, size=1, p=probabilities)[0]\n",
    "    return next\n",
    "\n",
    "\n",
    "def random_walk(graph, num_walks, num_steps, p, q):\n",
    "    walks = []\n",
    "    nodes = list(graph.nodes())\n",
    "\n",
    "    for walk_iteration in range(num_walks):\n",
    "        random.shuffle(nodes)\n",
    "\n",
    "        for node in tqdm(\n",
    "            nodes,\n",
    "            position=0,\n",
    "            leave=True,\n",
    "            desc=f\"Random walks iteration {walk_iteration + 1} of {num_walks}\",\n",
    "        ):\n",
    "            \n",
    "            walk = [node]\n",
    "            \n",
    "            while len(walk) < num_steps:\n",
    "                current = walk[-1]\n",
    "                previous = walk[-2] if len(walk) > 1 else None\n",
    "                next = next_step(graph, previous, current, p, q)\n",
    "                walk.append(next)\n",
    "                \n",
    "            # Replace node ids (item ids) in the walk with token ids.\n",
    "            walk = [vocabulary_lookup[token] for token in walk]\n",
    "\n",
    "            walks.append(walk)\n",
    "    return walks\n",
    "\n",
    "\n",
    "\n",
    "# Random walk return parameter.\n",
    "p = 1\n",
    "# Random walk in-out parameter.\n",
    "q = 1\n",
    "# Number of iterations of random walks.\n",
    "num_walks = 5\n",
    "# Number of steps of each random walk.\n",
    "num_steps = 10\n",
    "walks = random_walk(items_graph, num_walks, num_steps, p, q)\n",
    "\n",
    "print(\"Number of walks generated:\", len(walks))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19a6d487-1097-4651-97ba-0b6c7701ede1",
   "metadata": {},
   "source": [
    "# Create Training Dataset Using Negative Sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "id": "d3460fbc-b05c-4a60-9378-bcae39d4872c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generating postive and negative examples: 100%|██████████| 7025/7025 [00:09<00:00, 737.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Targets shape: (882834,)\n",
      "Contexts shape: (882834,)\n",
      "Labels shape: (882834,)\n",
      "Weights shape: (882834,)\n"
     ]
    }
   ],
   "source": [
    "def generate_examples(sequences, window_size, num_negative_samples, vocabulary_size):\n",
    "    example_weights = defaultdict(int)\n",
    "\n",
    "    for sequence in tqdm(\n",
    "        sequences,\n",
    "        position=0,\n",
    "        leave=True,\n",
    "        desc=f\"Generating postive and negative examples\",\n",
    "    ):\n",
    "        # Generate positive and negative skip-gram pairs for a sequence (walk)\n",
    "        pairs, labels = keras.preprocessing.sequence.skipgrams(\n",
    "            sequence,\n",
    "            vocabulary_size=vocabulary_size,\n",
    "            window_size=window_size,\n",
    "            negative_samples=num_negative_samples,\n",
    "        )\n",
    "        for idx in range(len(pairs)):\n",
    "            pair = pairs[idx]\n",
    "            label = labels[idx]\n",
    "            target, context = min(pair[0], pair[1]), max(pair[0], pair[1])\n",
    "            if target == context:\n",
    "                continue\n",
    "            entry = (target, context, label)\n",
    "            example_weights[entry] += 1\n",
    "\n",
    "    targets, contexts, labels, weights = [], [], [], []\n",
    "    for entry in example_weights:\n",
    "        weight = example_weights[entry]\n",
    "        target, context, label = entry\n",
    "        targets.append(target)\n",
    "        contexts.append(context)\n",
    "        labels.append(label)\n",
    "        weights.append(weight)\n",
    "\n",
    "    return np.array(targets), np.array(contexts), np.array(labels), np.array(weights)\n",
    "\n",
    "\n",
    "num_negative_samples = 4\n",
    "targets, contexts, labels, weights = generate_examples(\n",
    "    sequences=walks,\n",
    "    window_size=num_steps,\n",
    "    num_negative_samples=num_negative_samples,\n",
    "    vocabulary_size=len(vocabulary),\n",
    ")\n",
    "\n",
    "print(f\"Targets shape: {targets.shape}\")\n",
    "print(f\"Contexts shape: {contexts.shape}\")\n",
    "print(f\"Labels shape: {labels.shape}\")\n",
    "print(f\"Weights shape: {weights.shape}\")\n",
    "\n",
    "\n",
    "batch_size = 1024\n",
    "def create_dataset(targets, contexts, labels, weights, batch_size):\n",
    "    inputs = {\n",
    "        \"target\": targets,\n",
    "        \"context\": contexts,\n",
    "    }\n",
    "    dataset = tf.data.Dataset.from_tensor_slices((inputs, labels, weights))\n",
    "    dataset = dataset.shuffle(buffer_size=batch_size * 2)\n",
    "    dataset = dataset.batch(batch_size, drop_remainder=True)\n",
    "    dataset = dataset.prefetch(tf.data.AUTOTUNE)\n",
    "    return dataset\n",
    "\n",
    "#\n",
    "# Each record in the dataset has the following format:\n",
    "# (target_node_id, context_node_id), interaction_label_0_1, sample_weight\n",
    "#\n",
    "dataset = create_dataset(\n",
    "    targets=targets,\n",
    "    contexts=contexts,\n",
    "    labels=labels,\n",
    "    weights=weights,\n",
    "    batch_size=batch_size,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "523b8d0c-a37c-4e8a-a4cb-4234d7a9ea6b",
   "metadata": {},
   "source": [
    "# Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "id": "e79e02b7-d032-4e85-b08f-03004445286e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "862/862 [==============================] - 4s 4ms/step - loss: 2.4469\n",
      "Epoch 2/10\n",
      "862/862 [==============================] - 4s 4ms/step - loss: 2.3399\n",
      "Epoch 3/10\n",
      "862/862 [==============================] - 3s 4ms/step - loss: 2.3324\n",
      "Epoch 4/10\n",
      "862/862 [==============================] - 4s 4ms/step - loss: 2.3279\n",
      "Epoch 5/10\n",
      "862/862 [==============================] - 4s 5ms/step - loss: 2.3234\n",
      "Epoch 6/10\n",
      "862/862 [==============================] - 4s 5ms/step - loss: 2.3195\n",
      "Epoch 7/10\n",
      "862/862 [==============================] - 4s 5ms/step - loss: 2.3163\n",
      "Epoch 8/10\n",
      "862/862 [==============================] - 4s 4ms/step - loss: 2.3136\n",
      "Epoch 9/10\n",
      "862/862 [==============================] - 4s 4ms/step - loss: 2.3110\n",
      "Epoch 10/10\n",
      "862/862 [==============================] - 3s 4ms/step - loss: 2.3085\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rate = 0.001\n",
    "embedding_dim = 50\n",
    "num_epochs = 10\n",
    "\n",
    "def create_model(vocabulary_size, embedding_dim):\n",
    "    inputs = {\n",
    "        \"target\": layers.Input(name=\"target\", shape=(), dtype=\"int32\"),\n",
    "        \"context\": layers.Input(name=\"context\", shape=(), dtype=\"int32\"),\n",
    "    }\n",
    "    \n",
    "    embed_item = layers.Embedding(\n",
    "        input_dim=vocabulary_size,\n",
    "        output_dim=embedding_dim,\n",
    "        embeddings_initializer=\"he_normal\",\n",
    "        embeddings_regularizer=keras.regularizers.l2(1e-6),\n",
    "        name=\"item_embeddings\",\n",
    "    )\n",
    "    \n",
    "    target_embeddings = embed_item(inputs[\"target\"])\n",
    "    \n",
    "    context_embeddings = embed_item(inputs[\"context\"])\n",
    "    \n",
    "    # Compute dot similarity between target and context embeddings.\n",
    "    logits = layers.Dot(axes=1, normalize=False, name=\"dot_similarity\")(\n",
    "        [target_embeddings, context_embeddings]\n",
    "    )\n",
    "    \n",
    "\n",
    "    model = keras.Model(inputs=inputs, outputs=logits)\n",
    "    return model\n",
    "\n",
    "model = create_model(len(vocabulary), embedding_dim)\n",
    "model.compile(\n",
    "    optimizer=keras.optimizers.Adam(learning_rate),\n",
    "    loss=keras.losses.BinaryCrossentropy(from_logits=True),\n",
    ")\n",
    "\n",
    "history = model.fit(dataset, epochs=num_epochs)\n",
    "\n",
    "plt.plot(history.history[\"loss\"])\n",
    "plt.ylabel(\"loss\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07117112-a8a9-4b18-8c9c-b806fa160a21",
   "metadata": {},
   "source": [
    "# Model Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "id": "3dff4096-dc98-47d0-8dd1-1c7b8fc6458d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Embeddings shape: (1406, 50)\n",
      "Matrix, The (1999)\n",
      "------------------\n",
      "- Matrix, The (1999)\n",
      "- Lord of the Rings: The Fellowship of the Ring, The (2001)\n",
      "- Lord of the Rings: The Return of the King, The (2003)\n",
      "- Star Wars: Episode V - The Empire Strikes Back (1980)\n",
      "- Star Wars: Episode VI - Return of the Jedi (1983)\n",
      "\n",
      "Godfather, The (1972)\n",
      "---------------------\n",
      "- Godfather, The (1972)\n",
      "- Godfather: Part II, The (1974)\n",
      "- Star Wars: Episode V - The Empire Strikes Back (1980)\n",
      "- Apocalypse Now (1979)\n",
      "- Fargo (1996)\n",
      "\n",
      "Lion King, The (1994)\n",
      "---------------------\n",
      "- Lion King, The (1994)\n",
      "- Jurassic Park (1993)\n",
      "- Aladdin (1992)\n",
      "- Apollo 13 (1995)\n",
      "- Braveheart (1995)\n",
      "\n",
      "Aladdin (1992)\n",
      "--------------\n",
      "- Aladdin (1992)\n",
      "- Lion King, The (1994)\n",
      "- Apollo 13 (1995)\n",
      "- Beauty and the Beast (1991)\n",
      "- Jurassic Park (1993)\n",
      "\n",
      "Ratatouille (2007)\n",
      "------------------\n",
      "- Ratatouille (2007)\n",
      "- Up (2009)\n",
      "- Monsters, Inc. (2001)\n",
      "- Guardians of the Galaxy (2014)\n",
      "- Casino Royale (2006)\n"
     ]
    }
   ],
   "source": [
    "item_embeddings = model.get_layer(\"item_embeddings\").get_weights()[0]\n",
    "print(\"Embeddings shape:\", item_embeddings.shape)\n",
    "\n",
    "query_items = [\n",
    "    \"Matrix, The (1999)\",\n",
    "    \"Godfather, The (1972)\",\n",
    "    \"Lion King, The (1994)\",\n",
    "    \"Aladdin (1992)\",\n",
    "    \"Ratatouille (2007)\"\n",
    "]\n",
    "\n",
    "query_embeddings = []\n",
    "\n",
    "for item_name in query_items:\n",
    "    itemId = get_item_id_by_name(item_name)\n",
    "    token_id = vocabulary_lookup[itemId]\n",
    "    item_embedding = item_embeddings[token_id]\n",
    "    query_embeddings.append(item_embedding)\n",
    "\n",
    "query_embeddings = np.array(query_embeddings)\n",
    "\n",
    "similarities = tf.linalg.matmul(\n",
    "    tf.math.l2_normalize(query_embeddings),\n",
    "    tf.math.l2_normalize(item_embeddings),\n",
    "    transpose_b=True,\n",
    ")\n",
    "\n",
    "_, indices = tf.math.top_k(similarities, k=5)\n",
    "indices = indices.numpy().tolist()\n",
    "\n",
    "for idx, name in enumerate(query_items):\n",
    "    print(name)\n",
    "    print(\"\".rjust(len(name), \"-\"))\n",
    "    similar_tokens = indices[idx]\n",
    "    for token in similar_tokens:\n",
    "        similar_itemId = vocabulary[token]\n",
    "        similar_name = get_item_name_by_id(similar_itemId)\n",
    "        print(f\"- {similar_name}\")\n",
    "    print()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py310",
   "language": "python",
   "name": "py310"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}