NeuralMF.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up Colab environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "username = 'SkoltechAI'\n",
    "repo = 'Recommender-Systems-Intro-Sber-2022'\n",
    "\n",
    "# remove local directory if it already exists\n",
    "if os.path.isdir(repo):\n",
    "    !rm -rf {repo}\n",
    "\n",
    "!git clone https://github.com/{username}/{repo}.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git clone https://github.com/evfro/cofida.git\n",
    "!pip install --no-cache-dir --upgrade git+https://github.com/evfro/polara.git@develop#egg=polara"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.sparse import csr_matrix\n",
    "from tqdm import tqdm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import Dataset, DataLoader, RandomSampler, BatchSampler, SequentialSampler\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from polara import get_movielens_data\n",
    "from polara.lib.sampler import sample_element_wise\n",
    "from polara.tools.random import random_seeds, seed_generator\n",
    "from polara.preprocessing.dataframes import leave_one_out, reindex\n",
    "\n",
    "from cofida.datasets import observations_loader, ObservationsDataset, BPRDataset\n",
    "\n",
    "# navigating to cloned repo directory in Colab\n",
    "%cd {repo} \n",
    "from dataprep import transform_indices, matrix_from_data\n",
    "from evaluation import topn_recommendations, model_evaluate, downvote_seen_items\n",
    "# restoring original location\n",
    "%cd -\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fix_torch_seed(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepraring data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = get_movielens_data(include_time=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## data splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "rst = np.random.RandomState(111)\n",
    "sampling_args = dict(target='timestamp', sample_top=True, random_state=rst)\n",
    "# final test data\n",
    "training_validation_, holdout_ = leave_one_out(data, **sampling_args)\n",
    "# validation data\n",
    "training_, validation_ = leave_one_out(training_validation_, **sampling_args)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## reindexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtered 3 invalid observations.\n"
     ]
    }
   ],
   "source": [
    "training, data_index = transform_indices(training_, 'userid', 'movieid')\n",
    "# split validation data\n",
    "validation = reindex(validation_, data_index.values(), filter_invalid=True)\n",
    "validation = validation.sort_values('userid')\n",
    "# split final test data\n",
    "holdout = reindex(holdout_, data_index.values(), filter_invalid=True)\n",
    "holdout = holdout.sort_values('userid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'users': 'userid',\n",
       " 'items': 'movieid',\n",
       " 'feedback': None,\n",
       " 'n_users': 6040,\n",
       " 'n_items': 3703,\n",
       " 'test_users': array([   0,    1,    2, ..., 6037, 6038, 6039], dtype=int64)}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_description = dict(\n",
    "    users = data_index['users'].name,\n",
    "    items = data_index['items'].name,\n",
    "    feedback = None,\n",
    "    n_users = len(data_index['users']),\n",
    "    n_items = len(data_index['items']),\n",
    "    test_users = validation[data_index['users'].name].drop_duplicates().values\n",
    ")\n",
    "data_description"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Torch DataLoader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple (mostly unuseful) example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's play with the standard API to see the mechanics of torch dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NaiveDataset(Dataset):\n",
    "    '''A simple wrapper to iterate over a 2D array of user-item indices'''\n",
    "    def __init__(self, observations, device=None):\n",
    "        super().__init__()\n",
    "        self.data = torch.LongTensor(observations).to(device)\n",
    "        self.size = len(observations)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.data.shape[0]\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        user, item = self.data[idx]\n",
    "        label = torch.ones_like(user, dtype=torch.float32)\n",
    "        output = {\n",
    "            \"users\": user,\n",
    "            \"items\": item,\n",
    "            \"labels\": label,\n",
    "        }\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observed_data = training[\n",
    "    [data_description['users'], data_description['items']]\n",
    "]\n",
    "\n",
    "batch_size = 1024\n",
    "\n",
    "naive_dl = DataLoader(\n",
    "    NaiveDataset(observed_data.values, device='cuda'),\n",
    "    batch_size = batch_size, # will use the default collation_fn for gathering batches\n",
    "    drop_last = False,\n",
    "    sampler = None,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 12.8 s\n",
      "Wall time: 1min 10s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for batch in naive_dl:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pytorch adds a significant overhead on iterations due to its internal index collation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 31.2 ms\n",
      "Wall time: 109 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for _, batch in observed_data.groupby(np.arange(len(observed_data))//batch_size):\n",
    "    labels = np.ones(batch.shape[0])\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll deal with this issue later. The major parts that are still missing are:\n",
    "1. data shuffling\n",
    "2. negative sampling\n",
    "\n",
    "Let's fix that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More useful dataset construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CFDataset(Dataset):\n",
    "    def __init__(self, observations, n_users, n_items, n_samples=None, seed=None):\n",
    "        super().__init__()\n",
    "        self.observations = observations\n",
    "        self.n_users = n_users\n",
    "        self.n_items = n_items\n",
    "        self.data = None # will be extended with negative samples and iterated over\n",
    "        self.seed = seed\n",
    "        # data sampling initialization\n",
    "        self.observations_mat = self.matrix_from_observations()\n",
    "        self.n_samples = n_samples\n",
    "        self._sampler_state = seed_generator(self.seed)\n",
    "        self._shuffle_state = seed_generator(self.seed)\n",
    "        self.shuffle = True\n",
    "        self.reset_dataset()\n",
    "\n",
    "    def reset_random_state(self):\n",
    "        fix_torch_seed(self.seed)\n",
    "        self._sampler_state.send(self.seed)\n",
    "        self._shuffle_state.send(self.seed)\n",
    "\n",
    "    def reset_dataset(self):\n",
    "        '''\n",
    "        This method will be used by pytorch Sampler object.\n",
    "        It initializes dataset with new negative samples and new shuffling of data.\n",
    "        '''\n",
    "        if self.n_samples: # perform negative sampling\n",
    "            negative_examples = self.sample_negatives(next(self._sampler_state))\n",
    "            data = np.concatenate((self.observations, negative_examples), axis=0)\n",
    "            labels = [1] * len(self.observations) + [0] * len(negative_examples)\n",
    "        else: # use original data as is\n",
    "            data = self.observations\n",
    "            labels = [0] * len(self.observations)\n",
    "        \n",
    "        self.data = np.concatenate([data, np.array(labels)[:, np.newaxis]], axis=1)\n",
    "        \n",
    "        if self.shuffle:\n",
    "            random_state = np.random.RandomState(next(self._shuffle_state))\n",
    "            random_state.shuffle(self.data)\n",
    "    \n",
    "    def matrix_from_observations(self):\n",
    "        vals = np.broadcast_to(1, len(self.observations)) # save some space on not storing all 1s\n",
    "        rows = self.observations[:, 0]\n",
    "        cols = self.observations[:, 1]\n",
    "        shape = (self.n_users, self.n_items)\n",
    "        return csr_matrix((vals, (rows, cols)), shape=shape)\n",
    "\n",
    "    def sample_negatives(self, entropy):\n",
    "        '''Perform negative sampling using sparse matrix format.'''\n",
    "        # important note: negative samples must include holdout items as well,\n",
    "        # otherwise the model will be provided with hints about ground truth\n",
    "        samples = sample_element_wise(\n",
    "            # performs uniform sampling of \"unseen\" examples for each known example\n",
    "            indptr = self.observations_mat.indptr,\n",
    "            indices = self.observations_mat.indices,\n",
    "            n_cols = self.n_items,\n",
    "            n_samples = self.n_samples,\n",
    "            seed_seq = random_seeds(self.n_users, entropy=entropy)\n",
    "        )\n",
    "        user_index = np.broadcast_to( # construct user index of comforming shape\n",
    "            np.repeat(\n",
    "                np.arange(self.n_users),\n",
    "                np.diff(self.observations_mat.indptr)\n",
    "            )[:, np.newaxis],\n",
    "            samples.shape\n",
    "        )\n",
    "        negative_samples_array = np.concatenate(\n",
    "            [user_index.flat, samples.flat] # long vector of user and item indices\n",
    "        ).reshape(-1, 2, order='F') # reshape into a table with two columns: users and items\n",
    "        return negative_samples_array\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        user, item, label = self.data[idx]\n",
    "        output = (\n",
    "            np.int64(user),\n",
    "            np.int64(item),\n",
    "            np.float32(label),\n",
    "        )\n",
    "        return output\n",
    "\n",
    "\n",
    "class SamplerWithReset(RandomSampler):\n",
    "    def __iter__(self):\n",
    "        self.data_source.reset_dataset()\n",
    "        return super().__iter__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = CFDataset(\n",
    "    observed_data.values,\n",
    "    data_description['n_users'],\n",
    "    data_description['n_items'],\n",
    "    n_samples = 1,\n",
    "    seed = 42\n",
    ")\n",
    "\n",
    "train_dl = DataLoader(\n",
    "    train_dataset,\n",
    "    batch_size = batch_size, # will use the default collation_fn for gathering batches\n",
    "    drop_last = False,\n",
    "    sampler = SamplerWithReset(train_dataset),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remark: The default `collate_fn` function gathers batches entry-by-entry, it is an IO-bound procedure. Hence, it is more appropriate for ANN's with heavy computations, e.g. a CNN trained on an image dataset. In that case the overhead to gather a batch is small comparing to the compute time.\n",
    "\n",
    "However, in the recsys case with simple MF-like models, computations are lightweight and the time spent inside `collate_fn` dominates, see [this issue](https://github.com/pytorch/pytorch/issues/21645) for more details. A viable workaround for not too large datasets is to create a custom dataloader which doesn't rely on `collate_fn` and performs sampling more efficiently in a vectorized form. For example, see [cofida](https://github.com/evfro/cofida) library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "for batch in train_dl:\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'users': tensor([1805, 1496,    9,  ..., 2354, 1386, 4639]),\n",
       " 'items': tensor([2489, 3530,  537,  ..., 2328,  580,  569]),\n",
       " 'labels': tensor([1., 0., 1.,  ..., 0., 1., 0.])}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset with fast batch iterations based on `cofida`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\evfro\\github\\cofida\\datasets.py:250: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at  ..\\torch\\csrc\\utils\\tensor_numpy.cpp:189.)\n",
      "  neg_users = torch.cuda.LongTensor(users.ravel())\n"
     ]
    }
   ],
   "source": [
    "fast_data_loader = observations_loader(\n",
    "    matrix_from_data(observed_data, data_description),\n",
    "    batch_size = batch_size,\n",
    "    n_neg_samples = 1,\n",
    "    data_factory = ObservationsDataset\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 28.1 s\n",
      "Wall time: 5.62 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for batch in fast_data_loader:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([  64, 1052, 1715,  ..., 1551, 1397, 4509], device='cuda:0'),\n",
       " tensor([ 568, 2515, 2658,  ..., 3562, 3683, 1827], device='cuda:0'),\n",
       " tensor([0., 1., 0.,  ..., 1., 1., 0.], device='cuda:0')]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training boilerplate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_mf_epoch(\n",
    "    loader, model, criterion, optimizer, scheduler=None,\n",
    "    device=None, batch_to_tensor=True\n",
    "):\n",
    "    model.train()\n",
    "    losses = []\n",
    "    for (users, items, labels) in loader:\n",
    "        if batch_to_tensor:\n",
    "            users = torch.LongTensor(users).to(device)\n",
    "            items = torch.LongTensor(items).to(device)\n",
    "            labels = torch.FloatTensor(labels).to(device)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        loss = criterion(model(users, items), labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        losses.append(loss.detach().cpu().item())\n",
    "    \n",
    "    if scheduler is not None:\n",
    "        scheduler.step()\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix Factorization models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MFBase(nn.Module):\n",
    "    def __init__(self, user_num, item_num, embedding_dim):\n",
    "        super().__init__()\n",
    "        self.user_embeddings = nn.Embedding(user_num, embedding_dim)\n",
    "        self.item_embeddings = nn.Embedding(item_num, embedding_dim)\n",
    "        self.initialize()\n",
    "\n",
    "    def initialize(self):\n",
    "        for name, param in self.named_parameters():\n",
    "            if \"weight\" in name:\n",
    "                nn.init.xavier_uniform_(param.data)\n",
    "            elif \"bias\" in name:\n",
    "                param.data.normal_(std=0.001)\n",
    "\n",
    "\n",
    "class SimpleMF(MFBase):\n",
    "    def forward(self, user, item):\n",
    "        user_embedding = self.user_embeddings(user)\n",
    "        item_embedding = self.item_embeddings(item)\n",
    "        matmul = torch.sum(user_embedding * item_embedding, -1)\n",
    "        return matmul.view(-1)\n",
    "\n",
    "\n",
    "class CosineDistanceMF(MFBase):\n",
    "    def forward(self, user, item):\n",
    "        user_embedding = self.user_embeddings(user)\n",
    "        item_embedding = self.item_embeddings(item)\n",
    "\n",
    "        user_embedding = F.normalize(user_embedding)\n",
    "        item_embedding = F.normalize(item_embedding)\n",
    "        sim = (user_embedding * item_embedding).sum(1)\n",
    "        return sim.view(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_mf_model(config, data_description):\n",
    "    model = SimpleMF(\n",
    "        data_description['n_users'],\n",
    "        data_description['n_items'],\n",
    "        config['dim']\n",
    "    )\n",
    "    # transfer model to GPU if available\n",
    "    device = None\n",
    "    if torch.cuda.is_available():\n",
    "        if not next(model.parameters()).is_cuda:\n",
    "            model = model.cuda()\n",
    "        device = next(model.parameters()).device\n",
    "    # define loss function    \n",
    "    criterion = torch.nn.BCEWithLogitsLoss()\n",
    "    if device is not None:\n",
    "        criterion = criterion.cuda()\n",
    "    # define optimizer\n",
    "    optimizer = torch.optim.Adam(\n",
    "        model.parameters(),\n",
    "        lr = config['learning_rate'],\n",
    "        weight_decay = config['l2_reg']\n",
    "    )    \n",
    "    return model, criterion, optimizer, device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = dict(\n",
    "    dim = 64,\n",
    "    learning_rate = 1e-2,\n",
    "    epochs = 20,\n",
    "    l2_reg = 0 # L2 regularization\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_mf_model(config, data, data_description):\n",
    "    '''Simple MF training routine without early stopping'''\n",
    "    model, criterion, optimizer, device = prepare_mf_model(config, data_description)\n",
    "    data_loader = observations_loader(\n",
    "        matrix_from_data(data, data_description),\n",
    "        batch_size = batch_size,\n",
    "        n_neg_samples = 1,\n",
    "        data_factory = ObservationsDataset\n",
    "    )\n",
    "    losses = {}\n",
    "    for epoch in tqdm(range(config['epochs'])):\n",
    "        losses[epoch] = train_mf_epoch(\n",
    "            data_loader, model, criterion, optimizer,\n",
    "            device=device, batch_to_tensor=False\n",
    "    )\n",
    "    return model, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [04:36<00:00, 13.81s/it]\n"
     ]
    }
   ],
   "source": [
    "mf_model, mf_losses = build_mf_model(config, observed_data, data_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.Series(mf_losses).apply(np.mean).plot(title='Evolution of MF loss', xlabel='Epoch', ylabel='Loss');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABjcElEQVR4nO2dd3wUZfrAv8/OljRqQBBCFRGpUZAiigUrAupPBAR74VBR7+zl7Hee9c7GidgLVjwFAbFgAxSkGJBO6KETQwmk7e77+2N2w5bZzWaTTeP9fj75ZHdm3plnZnfnmfepopRCo9FoNJp4sFW3ABqNRqOpvWglotFoNJq40UpEo9FoNHGjlYhGo9Fo4kYrEY1Go9HEjVYiGo1Go4kbrUQ0dQYR2SgiZ8W47dUiMifRMtVWROR0Ecmpbjk0NR+tRDQJxXdjLxCRfBHJE5HpItIqxrFtRUSJiD3RclYnIvK2iPyjuuWoCCLiEpE3RWS/iOwQkdurWyZN1aCViKYqGKKUSgOOBnYCL1WzPJrK5xHgWKANcAZwt4icV60SaaoErUQ0VYZSqhCYDHT2LxORC0Tkd98T7BYReSRgyM++/3t9M5l+vjE3iMhKETkgIitE5MSAMZkislRE9onIxyKSFItsInKyiCzwjVsgIicHrLtaRNb7jrdBREb7lncQkZ98Y/aIyMdR9v+p7wl9n4j8LCJdfMvHAKMxb7r5IvJlhPGdRORbEflTRFaLyPCAdW+LyATf+gM+mdrEeG6NReQtEdnmmyl+EXLcO0Rkl4hsF5FrolzCK4HHlVJ5SqmVwGvA1VG219QVlFL6T/8l7A/YCJzle50CvAO8G7D+dKAb5gNNd8yZykW+dW0BBdgDtr8U2AqcBAjQAWgTcKzfgBZAY2AlMDaCXFcDc3yvGwN5wBWAHbjM9z4dSAX2A8f5tj0a6OJ7/SHwgE/2JOCUKNfhWqAe4AKeB7IC1r0N/CPK2FRgC3CNT74TgT0BcrwNHAAG+Pb/Qizn5ls/HfgYaAQ4gNMCPhc38Jhv+SDgENDIQr5Gvs+pWcCyYcAf1f3903+J/9MzEU1V8IWI7MW8GZ8NPONfoZT6USn1h1LKq5RainljPi3Kvq4HnlZKLVAm2UqpTQHrX1RKbVNK/Ql8CWTGIN8FwFql1HtKKbdS6kNgFTDEt94LdBWRZKXUdqXUct/yEkzzTQulVKFSKqKjXin1plLqgFKqCNP000NEGsQgG8BgYKNS6i2ffIuBzzBv1H6mK6V+9u3/AaCfz/cU8dxE5GjgfExFm6eUKlFK/RSwzxLgMd/yGUA+cJyFfGm+//sClu3DVJqaOo5WIpqq4CKlVEPMp+RxwE8i0hxARPqIyA8isltE9gFjgSZR9tUKWBdl/Y6A14c4fIOLRgtgU8iyTUBLpdRBYIRPru2+wIBOvm3uxpwN/SYiy0XkWqudi4ghIk+KyDoR2Y85Y4Lo5xlIG6CPiOz1/2GawJoHbLPF/0IplQ/86TuviOeGeS3/VErlRThurlLKHfA+0vXM9/2vH7CsPubsSFPH0UpEU2UopTxKqf8BHuAU3+IPgKlAK6VUA2AC5o0ZTBNJKFuAYypZtG2YN+pAWmOazVBKfa2UOhvTlLUK096PUmqHUuoGpVQL4C/Af0Wkg8X+RwEXAmcBDTDNdBD9PAPZAvyklGoY8JemlLoxYJvSiDcRScM0Y20r49y2AI1FpGEZx4+KTwltB3oELO4BLLceoalLaCWiqTLE5EJMG/pK3+J6mE/DhSLSG/OG62c3pimpfcCy14E7RaSnb38dAp3IcTID6Cgio0TELiIjMJ3/00SkmYgMFZFUoAjzqdvjO59LRSTDt488TGXgsdh/Pd/YXEy/0BMh63eGnGMo03zyXSEiDt/fSSJyfMA2g0TkFBFxAo8D85VSW6Kdm1JqO/AVpvJr5NvvgJiuWDjvAn/37acTcAOmr0ZTx9FKRFMVfCki+Zg+kX8CVwX4FW4CHhORA8BDwCf+QUqpQ77t5/rMOH2VUp/6ln2AaS75AvOpO26UUrmYfoc7MG/0dwODlVJ7MH8jd2A+0f+J6a+5yTf0JGC+79ymArcppTZYHOJdTBPSVmAFMC9k/RtAZ985fmEh3wHgHGCkT44dwFOY5kE/HwAP+2TsiWnuKuvcwHS4l2DOsHYBf414oaLzMKaZcRPwE/CMUmpmnPvS1CJEKd2USqOpzYjI20COUurv1S2L5shDz0Q0Go1GEzdaiWg0Go0mbrQ5S6PRaDRxo2ciGo1Go4mbOlUdtUmTJqpt27bVLYZGo9HUGhYtWrRHKdU03vF1Som0bduWhQsXVrcYGo1GU2sQkdCKBuVCm7M0Go1GEzdaiWg0Go0mbhKqRETkPF/vg2wRuddi/V0ikuX7WyYiHhFpHMtYjUaj0VQ/CfOJiIgBjMcs/Z0DLBCRqUqpFf5tlFLP4CsLLiJDgL8ppf6MZaxGo6n9lJSUkJOTQ2FhYXWLUudJSkoiIyMDh8NRqftNpGO9N5CtlFoPICIfYVYyjaQILsPsJRHPWI1GUwvJycmhXr16tG3bFhEpe4AmLpRS5ObmkpOTQ7t27Sp134lUIi0J6HGAOaPoY7WhiKQA52H2mijv2DHAGIDWrVvHLWxufhHLt+1nf0ExAAcK3azduZ/dB4ppnZ7CxSdk0KGZ7rGj0VQmhYWFWoFUASJCeno6u3fvrvR9J1KJWH0rIqXHDwHm+rrRlWusUmoiMBGgV69ecaXfP/j5Ut6bvyXqNuN/XE/rRkncfd7x9DsmnfQ0V9TtNRpNbGgFUjUk6jonUonkENAoB8jALGNtxUgOm7LKO7ZC9P7HN+zKL4m43u5xk1JSyP6kNDbnFTLuw98BuP/8Tow5rbJ7I2k0Gk3tIpHRWQuAY0Wkna9RzkjMngtB+PpMnwZMKe/YivLF4i1RFQhAl53rWPrCSLJeGMnUd/7K0zOe59zVv/Dk9OXcPXlJZYuk0WiqGMMwyMzMpGvXrgwZMoS9e/dG3f7qq69m8uTJAJx++umlCc6DBg0qc2wsbNy4ka5du1Z4P1VFwpSIrzfzOOBrzC52nyillovIWBEZG7DpxcA3vl7WUcdWtozT/thR5jY709L5xxnX8uXxA9ibVI9z1s7j1S+e4KMP7+PHH5aQvVO3kdZoajPJyclkZWWxbNkyGjduzPjx4+Paz4wZM2jYsGHlClcLSGieiFJqhlKqo1LqGKXUP33LJiilJgRs87ZSamQsYyubwd2al7nNjvpNeL33//HgOTdx5YjHOfGWSdwx6G902bmeTz+4h4kf/JgI0TQaTTXQr18/tm7dCkBWVhZ9+/ale/fuXHzxxeTl5UUd27ZtW/bs2cPGjRs5/vjjueGGG+jSpQvnnHMOBQUFACxYsIDu3bvTr18/7rrrrjJnHIWFhVxzzTV069aNE044gR9++AGA5cuX07t3bzIzM+nevTtr167l4MGDXHDBBfTo0YOuXbvy8ccfV8IVKZs6VTurvFx0YiuemrmK7fuLYx7jtRl81m0g69IzeO/jvzPs3/eSe91ZpNdPTqCkGs0RwF//CllZlbvPzEx4/vmYNvV4PMyaNYvrrrsOgCuvvJKXXnqJ0047jYceeohHH32U52Pc19q1a/nwww957bXXGD58OJ999hmXX34511xzDRMnTuTkk0/m3nvLzqH2z4r++OMPVq1axTnnnMOaNWuYMGECt912G6NHj6a4uBiPx8OMGTNo0aIF06dPB2Dfvn0xyVpRjviyJ7/efzbPD+9O5+ZpNE9z0iTFQbN6TlrWd9E0NXJSTlaL43hs4A30zlnBhtffr0KJNRpNZVJQUEBmZibp6en8+eefnH322ezbt4+9e/dy2mmnAXDVVVfx888/x7zPdu3akZmZCUDPnj3ZuHEje/fu5cCBA5x88skAjBo1qsz9zJkzhyuuuAKATp060aZNG9asWUO/fv144okneOqpp9i0aRPJycl069aN7777jnvuuYfZs2fToEGDcl6J+DiiZyJ+LjqxFRed2MpyXW5+Ea/PXs8rP60PW/dZ14HcOG8yLcf/B/52PehQRY0mfmJ8yq9s/D6Rffv2MXjwYMaPH89VV11VoX26XIdTAAzDoKCggHgaAEYaM2rUKPr06cP06dM599xzef311znzzDNZtGgRM2bM4L777uOcc87hoYceivscYuWIn4mURXqai3vOP57v/jYgbJ3XZvBK30s5ev1K5r38XjVIp9FoKosGDRrw4osv8uyzz5KSkkKjRo2YPXs2AO+9917prCReGjVqRL169Zg3bx4AH330UZljBgwYwKRJkwBYs2YNmzdv5rjjjmP9+vW0b9+eW2+9laFDh7J06VK2bdtGSkoKl19+OXfeeSeLFy+ukLyxopVIjHRoVo/7z+8UtvzzLmewK7UR+1+eQG5+UTVIptFoKosTTjiBHj168NFHH/HOO+9w11130b17d7Kysirlqf6NN95gzJgx9OvXD6VUmSanm266CY/HQ7du3RgxYgRvv/02LpeLjz/+mK5du5KZmcmqVau48sor+eOPP0qd7f/85z/5+9//XmF5Y6FO9Vjv1auXSmRTqtz8Inr+47uw5Q9/9yqjsmayZslaunVpk7DjazR1jZUrV3L88cdXtxhVRn5+PmlpaQA8+eSTbN++nRdeeKHKjm91vUVkkVKqV7z71DORcpCTV4DDwu0xrdOpuDwlbP7w86oXSqPR1BqmT59emtg4e/bsKpstJBLtWC8HGY2SsRkC7uDZ25KjO5LvTCbvq+/IvfdGXVdLo9FYMmLECEaMGFHdYlQqeiZSDtLTXDwzrEfYcrdhZ1HL4+mz+Q9y8gqqQTKNpvZSl0zqNZlEXWetRMrJ0MyWvHzZCWHL57XuxrF7NtPKrcugaDSxkpSURG5urlYkCcbfTyQpKanS963NWXHQqXl4X5F5rboB0HjRfGhnnXOi0WiCycjIICcnJyF9LjTB+DsbVjZaicTBwWIPhoAn4OHpj+YdKLC74MefSR42rPqE02hqEQ6Ho9I77WmqFm3OioNUpxGkQMD0i6xu2prCxVnVIpNGo9FUB1qJxMHBYg8OI3z56iZtSV2t28BrNJojB61E4iCjUbJl/97VTdvi/DMXdu6scpk0Go2mOtBKJA7S01xcd0r7sOUrj2oLwP7fFlWxRBqNRlM9aCUSJ11ahNe8Wd20LQAHFvxexdJoNBpN9aCVSJzUTw7vNfJnSgN2pzbEtaLSO/lqNBpNjUQrkTjp0qK+pV9kVZO2sOyPqhZHo9FoqoWEKhEROU9EVotItohY9oIUkdNFJEtElovITwHLN4rIH751iSvNGyfpaS6u6hdesXddegYNcjaCzsDVaDRHAAlTIiJiAOOB84HOwGUi0jlkm4bAf4GhSqkuwKUhuzlDKZVZkTLFieSWgceGzUbWN26J42A+7NhRLTJpNBpNVZLImUhvIFsptV4pVQx8BFwYss0o4H9Kqc0ASqldCZQnIdhswWpkQ+OW5ovVq6tBGo1Go6laEqlEWgJbAt7n+JYF0hFoJCI/isgiEbkyYJ0CvvEtHxPpICIyRkQWisjCqq6/s3zbPjzeYLPV+sZmbZr8pdq5rtFo6j6JrJ1l5XcOdRTYgZ7AQCAZ+FVE5iml1gD9lVLbROQo4FsRWaWU+jlsh0pNBCaC2dmwUs+gTMJPcVv9JhTanRxatpK0qhVGo9FoqpxEzkRygMBythnANottZiqlDiql9gA/Az0AlFLbfP93AZ9jmsdqFF1a1McI0SNKbGxs1IKGWzZUj1AajUZThSRSiSwAjhWRdiLiBEYCU0O2mQKcKiJ2EUkB+gArRSRVROoBiEgqcA6wLIGyxkV6mot7zusUtnxd45awRvtENBpN3Sdh5iyllFtExgFfAwbwplJquYiM9a2foJRaKSIzgaWAF3hdKbVMRNoDn4uIX8YPlFIzEyVrRWic6gxbtqFxS+y/zYPiYnCGr9doNJq6QkL7iSilZgAzQpZNCHn/DPBMyLL1+MxaNZ226Slhy9Y3bonN44H166FT+ExFo9Fo6go6Y72COOxGmHt9c8OjzRcbtF9Eo9HUbbQSqSCpTiMs5Cyn/lHmi02bqlwejUajqUq0EqkgB4s92EOuYm69RngdDti4sVpk0mg0mqpCK5EKkuo0cHuDl5WIQX7T5nomotFo6jxaiVSQbfsKLJcvdzSiZP3GqhVGo9FoqhitRCqMVWI+bG/QTM9ENBpNnUcrkQpilbUOkNPgKOy7dkBRUdULpdFoNFWEViIVJD3NxX9GZIbNRzIyOyFKwZYtluM0Go2mLqCVSCXQv0MTnCEhWlPyfHmc2qSl0WjqMFqJVAI5eQVhnQxz6jU1X2zeXA0SaTQaTdWglUglkOo0KPIEK5HNqekoET0T0Wg0dRqtRCoBqzDfEsNBcdNmeiai0WjqNFqJVAL7C0oslx9q3kIrEY1GU6fRSqQSqJ9sXe69JKO1NmdpNJo6jVYilUCLBkmWy7fXb2qG+Hq9lus1Go2mtqOVSCVwsNiDyx6ecTjlT7uZbLh7dzVIpdFoNIlHK5FKIKNRcmiELwBbG/jCfLVJS6PR1FG0EqkE0tNc3HnOcWHLN6c18b3QznWNRlM30UqkkujTPh1nyNXc6mtOdXB1djVIpNFoNIknoUpERM4TkdUiki0i90bY5nQRyRKR5SLyU3nG1iQyGiUTkm/I/qQ09iWlUbBGKxGNRlM3SZgSEREDGA+cD3QGLhORziHbNAT+CwxVSnUBLo11bE0kVIkAbG7QjOQt2iei0WjqJomcifQGspVS65VSxcBHwIUh24wC/qeU2gyglNpVjrE1im+W77BcvqVhc4zNWoloNJq6SSKVSEsgsA56jm9ZIB2BRiLyo4gsEpEryzEWABEZIyILRWTh7moMpV2/56Dl8i2NmuPasknnimg0mjpJIpWIVcu/UIOPHegJXACcCzwoIh1jHGsuVGqiUqqXUqpX06ZNKyJvhTi3czPL5fU6HYsUF8O2bVUskUaj0SSeRCqRHKBVwPsMIPROmgPMVEodVErtAX4GesQ4tkbRq106fdo1Clv+fVGK+ULnimg0mjpIIpXIAuBYEWknIk5gJDA1ZJspwKkiYheRFKAPsDLGsTWO+wd1JsVhBC3b1eho88XGjVUvkEaj0SQYe6J2rJRyi8g44GvAAN5USi0XkbG+9ROUUitFZCawFPACryullgFYjU2UrJVFRqNkij2eoGXrU3yzE61ENBpNHSRhSgRAKTUDmBGybELI+2eAZ2IZWxsQEQLdN0XOZLxNj8KmlYhGo6mD6Iz1SiQnr4Ake7A5K8luUNCylZ6JaDSaOolWIpVIRqNkSkJCeUu8Xuzt22nHukajqZNoJVKJpKe5GN4zI2jZ8F4ZuDq0N5WIzhXRaDR1DK1EKpHc/CI+WZQTtOyThTnkH50BxcWwwzqrXaPRaGorWolUIjl5BThswZfUYbOxq3Fz8432i2g0mjqGViKVSCSfSOPOHc03WoloNJo6hlYilYiVT+SUDul4WvmS77US0Wg0dYyE5okcaVj5RL5buZveq3ezvFE6SVqJaDSaOoaeiVQiOXkFeD3hEVgeL6xKasz2JauqQSqNRqNJHFqJVCKpToPiCFG8OfWbUZi9jtz8oqoVSqPRaBKIViKVyMFiD07Del1Og6NouW8XObnWfUc0Go2mNqKVSCWS0SjZuukJkNOgGU6Pm1bF+6pUJo1Go0kkWolUIulpLq4/pb3luu0NzaZVjXdvr0qRNBqNJqFoJVLJXHJihuXybT4lomtoaTSauoRWIpWM6RcJ7+67o3EzlAisXVsNUmk0Gk1i0EqkkslolIxYdIjPw8nB5i1h5cqqF0qj0WgShFYilUx6mouHBnexXLcopTnuZTW+QaNGo9HEjFYiCaBrywYkO8IvbXZ6K2xr10BIC12NRqOprWglkgAyGiXjsegdsrxpW2xFRbAqOHM9N7+IJVv26kREjUZT60ho7SwROQ94ATCA15VST4asPx2YAmzwLfqfUuox37qNwAHAA7iVUr0SKWtlkp7mYlSfNrz9S3Ak1pKjzWq+q6d+h9GkNQeLPSzbuo/Hp6/AYbNR4vXy9CXdGZrZsjrE1mg0mnKTMCUiIgYwHjgbyAEWiMhUpdSKkE1nK6UGR9jNGUqpPYmSMVFMydoapkAANjRqQYHdxez//cA/9nXAZReK3GZ6YiHmzOXuz5bSv0MT0tNcVSqzRqPRxEMizVm9gWyl1HqlVDHwEXBhAo9XI8jNL+KOT7Is13ltBmubtKLjns0ApQokEIfNxvJt+7V5S6PR1AoSac5qCWwJeJ8D9LHYrp+ILAG2AXcqpfzhSwr4RkQU8KpSaqLVQURkDDAGoHXr1pUle9ws37YPd5RW6qubtOW0DYsiri8ocXPDuwtxGtq8pdFoaj6JnIlYZEuElZZaDLRRSvUAXgK+CFjXXyl1InA+cLOIDLA6iFJqolKql1KqV9OmTStB7IpiddqHWd20NUcdzKPRoeAaWqkuA5ddEBGK3F4OFLkpLPFy92dL9YxEo9HUWBKpRHKAVgHvMzBnG6UopfYrpfJ9r2cADhFp4nu/zfd/F/A5pnmsxtOlRf2oF3V5s2MA6LYju3TZDae244Pr+/Lalb1IsgeXAXbYbOTkFSRCVI1Go6kwiVQiC4BjRaSdiDiBkcDUwA1EpLmImd8tIr198uSKSKqI1PMtTwXOAZYlUNZKIz3NxeMXdY24/o/mx+JFOGHb6tJlr83ewGeLt9ClRQPLHu0ZjZITJq9Go9FUhIQpEaWUGxgHfA2sBD5RSi0XkbEiMta32TBgmc8n8iIwUimlgGbAHN/y34DpSqmZiZK1shndtw03nm5dzTfflcLaJq2ClAjAu79uJu9gMU9f0p0kh416LjtJDhtPX9JdR2ppNJoaS0LzRHwmqhkhyyYEvH4ZeNli3HqgRyJlSzTXn9KeN2ZvoNgTHoE1v1U3hi37Dpe7mCK7s3R51pa9DOvVis5H1ydry17apqfgsBvk5hdpRaLRaGokCVUiRzLpaS6evbQHt36UFbbuh2N6ceXv0+mz+Q9+bt+zdHmSw+DVn9bx3LdrEKUo8iiSfOVTdJSWRqOpiWglkkD6d2iC3UZYyO+vrbtRaHcyaPXcUiVi2IS/ffw7JSHbFpYcTkLsfHR9DhZ7yGiUrGcmGo2mRqBrZyWQSfM3W+aMFDqSmNeqGyOXfkNa0SHsNsHjVWEKJBCvVzHopTlc/vp8+j/1PVOztiZOcI1Go4kRrUQSRG5+EeN/iNyA6osupwPQc+tK3N5IndkPU+xRFJcjf0QXddRoNFVBTErEF3Jr873uKCJDRcSRWNFqNzl5BdhtkS/vtx36kO9M5vzVc+Pav/KqiPkjU7K20v+p7/WsRaPRJJxYZyI/A0ki0hKYBVwDvJ0ooeoCGY2SKfFEtk8ddKUwt00PTl+/ELvHXe79F3kUJW4PS7bsJXvngdJZR25+Efd8tpTCEp31rtFoEk+sjnVRSh0SkeuAl5RST4vI74kUrLaTnubi4SFdeOCLyDmSU48/jXPXzmNg9m98fdzJ5dq/TWDUG7+FRXHdfHoH7Lbg0iv+rHftjNdoNJVNrDMREZF+wGhgum+Zjuwqg9F92zC8V0bE9TOPO5k/k+szKA6TlldBsdtLkS8PpbDES2GJl/98u4b8ouDOiTrrXaPRJIpYlchfgfuAz31Z5+2BHxImVR0hN7+IKVH8ER6bwVfHncyFK3+i064NEbcrD1YGtAcHd9azEI1GkxBiUiJKqZ+UUkOVUk/5HOx7lFK3Jli2Wk9OXgGGRL/En3Q7G4CZb92CqCgxvnGS6jTo2qJBpe9Xo9FoIPborA9EpL6vGOIKYLWI3JVY0Wo/GY2ScXs9UbdZ0uI4Xuo3AoBPJ91Dy327ytyvIaZPJBaK3B72FRRrx7pGo0kIsZqzOiul9gMXYdbCag1ckSih6grpaS5uObNjmdv9+9TR/Nz2BHptXcms18dSvzA/6vYeZfpEYsHthZsmLa5wqK/OO9FoNFbEqkQcvryQi4ApSqkSwhtMaSwY1ac1TiP6tEGJjStHPM6L/UaQ5C5m6QsjabG/7BlJrOQXeSoU6qvzTjQaTSRiVSKvAhuBVOBnEWkD7E+UUHUJfyFGewxX+t8DrmBxi+MA+OWVa3HEkT8SDUOk3A2udN6JRqOJRqyO9ReVUi2VUoOUySbgjATLVmcYmtmSu87tRBkTEgAuufwZ9qSYjvDzV8+Jum2Ks3xVaw4We1i2bV/ZGwaQk1eAIyTzXndb1Gg0fmJ1rDcQkX+LyELf33OYsxJNDEyat4l/fbUKi9YiYSixcdK49yiwu3jxy2fJ3LaalOLgG7bLbuOfF3Xl7nM7keyI/BFarXrsy+XlmkVkNErW3RY1Gk1EYn2UfRM4AAz3/e0H3kqUUHWJ3PwiHv1yebnGKLHxSfezAPjivTtY8Z9LOXvtPABSHAbPXdqD3IPFPDFjJQVRSv+KCKnO4J7tRW7FB/M3xyxLeppLd1vUaDQREbMbbRkbiWQppTLLWlbd9OrVSy1cuLC6xQhiyZa9jHptHgeLo4f6huLwlHD/D2/Sd/MfHL97I3uT0jjn2vHk1k/HJliWjTfEVBwuhw2PV/HgBZ15bNpyitzBn7HLbuOXe88slyLIzS8iJ69A9zLRaOoYIrJIKdUr3vGxzkQKROSUgIP2B7RRPAYyGiVTHKUQYyRKDAePnvUXzr/2ZUZe9gQNC/N55LtXEbfbUoE4bIJhs+Gy2yhxe3nwgs6c17U5w05sFbat09A+DY1GUznEqkTGAuNFZKOIbMTsi/6XsgaJyHkislpEskXkXov1p4vIPhHJ8v09FOvY2kQss71ozGvdnQ+7n8OgNb+Q/exFtM7bHrZNiVdR7PFysNhDsUfx0JRlnPzk93y6MNx05fdpxJL7kZtfxIuz1nLykzrEV6PRhBNrdNYSpVQPoDvQXSl1AnBmtDEiYgDjgfOBzsBlItLZYtPZSqlM399j5Rxb48nJKyDZUfFalU+fdlXp6+enPRu2PrRyr0dBkdtLscWs5cHBnZmTvafM3I8pWVs5+clZ/PvbNRSVoyGWRqM5cihXjKhSar8vcx3g9jI27w1kK6XWK6WKgY+AC2M8VEXG1iisopviIS+lAW3vmca6xhmcuG01x+zZErQ+lu6IYNbSapDk4K7Jwbkfd366hOydB0q38+eHhPpTQIf4ajSaw1SkPW5ZWQ8tgcA7XY5vWSj9RGSJiHwlIl3KORYRGeMPPd69e3eMolcd/ugmlz3GYldlMPKyJygy7Mx640Y+mXQ3ycWF5Rpf5Pbwt0+yKA5p/l7sUZz/4uzSGYlVfogfHeKr0Wj8VESJlPXoa3XXDB2zGGjjM5W9BHxRjrHmQqUmKqV6KaV6NW3atAyRqoehmS355d6B3Hha+wrva3daY/7XxbQk9s5Zwcr/DMPlLo5prD96qyRCwkqJR3H7J1nk5hdFnEE5DAkK8dU1tTSaI5uoSkREDojIfou/A0CLMvadAwSGBmUA2wI38JnH8n2vZ2DW6GoSy9jaRnqai3vOP55/XtwVp91GqsuIe3by8Nk3cv41L7I7pSEA9/74Fo998wqX/z6jzLGRFIgftxeWb9tPepqL288OLx5pE+jfoQmga2ppNJoyuhMqpepVYN8LgGNFpB2wFRgJjArcQESaAzuVUkpEemMqtVxgb1ljayuj+7ThvC7NyckrYF9BMWPfW8yhkvLlkBTbHaw8qj0njXuPSR8/wDWLvixdN7dND9KKDnFSzgre6TkYj+1wsmEsGfMmiilZW3n269Vha5yGUeoP8dfUKvS1wrr7s6X079BE55FoNEcQCWtxq5Ryi8g44GvAAN70dUUc61s/ARgG3Cgibsy8k5HKjIe1HJsoWaua9DQX6WkusnceqJjTXYRrhz3Cp5PuxuFxc/zujfzw2uHI64e+f43dqQ35qmN/3jthEGubtilzlw5DaNEgmTHvLaLYQusUezykOg1+WLVL93LXaDSxZazXFmpixnokpmRt5Z7PluL1hIfh2nxNp9zl1C8PfTeRaxdNjbh++Kgn+a1V16j7uLpfG3q1bczdny3lkEWWvU3AsAlOwxaWhZ/ksDFt3CkcLPbozHaNppZQ0Yx1rUSqgdz8Ivo/9T2FUepexUvLfbvYndqIYrsDp7uE81fP4fFvXqF+8SEAbrrwXmZ0OiXieEPKY/YySXUZeLyKoT1a8EXWNpyG4PYqnr6kO0MzLYPqKg1djkWjqRhVVfZEU4lEC5+tKFsbHEWx3QGYvpMpXc7gxFs/YEbHkwH475Qn6bRrQ8Tx5VYgToNHh3Th9rM68snCHIrd3jKbYOXmF/Hzmt38vGZXuaK6QiPBtGNfo6l+EuYT0USmshIQY8Vt2Lnp4vs5MWclb372KI9/8wqXjn4KJLboMLtNIiYzepQis1VDBr04O2ydYZMwH8mUrK3c8UlWqanOYQjPXdqD/h2aRJ1R+M1/DpuNEq9ZG+zx6Ssq1bGvZzUaTfnRM5FqwKq8+v3nd8IeS9eqCrA443j+c8poTtq6gvt/eDPmcdFMng8O7szBYg8OI/yrVOJRQUmJuflF3D15SZCvp8Sj+NvHWUG1uSbN2xQ047Dqrvjol8sjOvbjQc9qNJr40DORamJoZsuwp+9Ul50HvliW0ONO63Qqj373KmMWfM43HfuyMKNLmWMimbhSnDa6tmhAqtOgxGKmct0pbUtf5+YX8eWSbZYpox4FHreXIp92eeCLZaS5jFK/Spv0VFTI/pVXhUWPxZtJH6ikdLiyRlM+9EykGklPc9GjVcPSG1Vakj3hH0huakMGXf0iABM+fwKbt3w5KoGUeBTLtu5j8MtzEN9sxWUXDDHNVO//upn+T33PQ1/8QZ8nvuORL1dQFKPTJdCvUuL2hI0rUXB+l2ZhzbKA0llMrNn0Vj6qePrRH8noygVHLnomUk2E2t/9T8NV4SlZ0aw9b/S6kOsWTuHO2e/x9GlXx7Ufr1fx8NTlQf4St0dhs5mlVUo8bgDenRd7J8VQHDYbG3MP4bJLWDHIr5bvZMYth0OK/ZWJHTYbBSVuRIQku0GJ1xs1UszKR+XvR9+jVcO4Za9rRPIZhfqrqiIqrzrRvrNgtBKpBqx+dG3SU3HYbKXmlETz+MAb6Ll1JTfNm8ysY3qzKKP8lfY9Cgjxl3gUeMob4uUjxWnjUHF4P/fMVg1DDwOYs52DxR56tGpoaZKCw4rMyjwVeDN48ILOYabEx6et4LwuzYPqhFXmzaM23YwiKYojzRR4pCnMWNDmrCrGykl892dLfX6FqovYAvjHmdcB8OTMl6r0uFbceFp7PryhH/+8uGuYiapDs3o8PCTcd+PxHnbclxU2Hep0D3Wk/3mwmDSXEXFMZTvea5MjP9J31q8EQ697XW0VEO06HMloJVLFRPrRHSz2lEZsOS0+FbuAvZI/rYUZXZjQ5xKOzd3CpI/ux+kuqdwDxIjLLlx/ant6tGrI6D5tmHvPmbx/fR/m3nNm6VPe6L5tSotXpjhtOA3hwQs6lz7tlhU2XezxlCocq5vByz+sDStOWeL1kuo0+HnNbu6eXHk3j9p2M4qmKKyue11tFXAkKczyoJVIFRPtRzc0syVz7zmTT2/sz/3ndyqt9mu3gdikzAYu8TAp83wA+m9ayprnLqb79jWM++UjWu3dkYCjheOy23hmWI9Sv9CSLXsBSgMOAh22o/u04eHBnXF7wWm38fj0FaVP8KFh03abWaLFj1fB3Ow9gPXNwGkYjDujQ9AsaHjPDAa/PIex7y0qjRzzU5GbR227GUX7zgZe91SnEabc6xJHksIsD7rsSTUwNWsrd8dgV83NL2L5tv3c8O7CsJuYFVbO51josiOb6e/8NWz5zI79eKnfCPpsWc6bvYbGnJwYK4aYeSZDerRgTvaeMFuzgqBlt5/VkWe/WUOx5/C1SHLYmHvPmWF+i1SnwQUvzQm6bv5tgbCyM4Hr/OMHvzwnYmma0OOWB6uyN7Hsrzp9KGV9ZyfN28Sj01ZUacmb6iDW325tQtfOCqC2KBGI/YawZMteLn99PgeK3JbrXXYbIvDgBZ1p1TiFq978rcxuYVbUL8yn3+alDNiwmHWNW/HQ968Frf/3KaN5tc8lFNmdcew9Mk6b4EWFNcsye61ImcqznsvO+9f3CYuisrpugduWdTOIdN1TnAZeFfkmGajEohWiLO/NqDoculYRhFbf2XiVYm2lPMq8NgRPVFSJ6OisasJfDr4sMholU1BirUAAhp2Ywe3ndCzd1z8u6hpXwuL+pDS+7ngyX/tqbE3uNpAZb91Co4IDpJYUcvucSdw+ZxJTjx/ArUPuir1kioASyMxoyKLNe8PWF5eGBwerPkNsZTdgBgrdh30d2TsPkLVlL5mtGpLRKDloxgLBpofQZE8wFYf/x25lunDZhQmXn0iXFg2ilmZRXkWRR5HkME1WVjd8q2TTSFhFQN01eQkNUxwRZakokZSW1bH85rnAyMK63BYg1t/ukRLJpZVILUBEiNSNePLiHG4/53AHwtF924DAo1NXYNigsMQb18xkf1Iap9z4FgDXLphSOjMZuvJnFrfoxDs9B6OQMpWJW5miWymQaHiU19Q+ZeD2zV4e+uKPoHyUPu0a4Q5QIqFtfeHwzSDSj/3pS7qHzRYGdDwKiJznE/g07n8dKeQ12s0ocP9WN+kit+Iv7y1GEZvpqLxPz+UJ29W+gnCOpNBnrURqODl5BWbCnMd6NuI0Djtk/TcJf/fE8vhTovFmr6GsatqGRRmdWf3c//HIrIk8MmsiO9Mac9+54/ilTXcKHUkVOoafZIeBQvHgBZ3582AxL/+QjSFwKIJvQgHfLN8RltA4f0Ne0PvAtr6BRPuxB84W/Oap3PwiS/9NtDyf8j6VWxWbtIo8K/B1xAy8OVkpi/I+EVspLRvC8m37GdCxadj2fud6qMKN9Xxrg8mnvBxJszOtRGo4ZYWulni9LNu6jxETfw36Affv0IRd+wtxGEIEd0rsiPBL20wA7jt3HP/6+mUAmuX/yZufPVa6Wf+xb7K1wVEVOlSR28MZxzXlsWkrcBo23B4vHhGcBlj0yALMnvBlYTdsAdupUjOQVUSUUqr0x56e5gpSGsUeD15llnwJVDrTxp0S8XPyhwoHmssiYaXUHp++ggcHd+axL5dbBk74qyWHyjnujGM5v2vzcj8RW33nDpV4uOHdhTwzzFoBlcc8F0g0BVeblcuRNDvTjvVaQKATNrScR2BJdD92Gxg2G3abhHUfrAwMrwePzSD94F4WvXx56XIvwrb6TTC8Xq659BH6bFnG513OYH9SWqXLEEhkY1/wNraAhlsOQ3hkSBdsAvd9Hu5Duv/8Tow57ZiYGoj5Hfabcg9yd4hPRCnFwE7NmLVqF06j7JlAtICAfQXF/OW9RRSEyOK025hxyymW0WQOQzBsErQ8UjBCIFOztnLX5CVhSsvKYR7vzT6aQ95qthdt9lQTFU5tieTSjvUjACsncDR7udsLbq+XwNS1eMN/rfDYzMzu3NSGXHDV8zTL/5PrFn5B/01Lydi/G4CZb90CwKPfvcqZ109gfXpGpRzbiljOShFcjbjEo6IGIDz7zRou6ZlheX1D8T9h9mjVsPRzKnF7+N/vW5m8KIcZy8ycG79ZMV7/QkajZEo84XI8PMRXjt9CTrOGWfmrHQ/NbEnDFAdj318c1CY51CRTEedxJJPP8m37yzV7KkuG6lIw8c7OahsJTTYUkfNEZLWIZIvIvVG2O0lEPCIyLGDZRhH5Q0SyRKTuTS/KSWDF38DXsTS4SnUaXNG3bULkWt68A9936M3okU/w1GlX8Uvr7uxObQjAz21PAOD718dWqFpwdWDYDivqaNc31GGfnuZiY+5BRr8xnw9+2xJWrh6iJxZa9Zp58ILOLN+2n1/X7fEFWRzGBrRqlEyq06DYY32NnYbgtAeXkonlhtalRQO8yloB+btTViSTP5LCBBUxGTO0WnBZ2f/VXV4mtFJ3XSRhMxERMYDxwNlADrBARKYqpVZYbPcU8LXFbs5QSu1JlIx1Af9N5/aAboGheJRi5EmteGvuBsveIIbAmAHteXPuRlAq5nLtobzS91Je6Xtp0LKPJ91Dn5zlfPzBfXzdsS+/tMmk/Vkn8+1K07yTX+SOK3os0XgVQRnZd01egigoDLk2gqJhioPc/KKgKK1os77AsORA/E/M/Ts0Ye49Z5KTV8Cyrft4eOqyiJ+tF7j+nUXYbDDw+KOY8cdOy21eHXUCeYdKyGzVkA7N6sV0DUId5sUeDzef3oGZy3bw+PQV2CzyeKycx5FmApEc8l1aNLBULla+P6uAhkAlfaRESFUniTRn9QaylVLrAUTkI+BCYEXIdrcAnwEnJVCWOk3/Dk0wbDbcIT+8VJeBx5c93KFZPf56Vkee+3ZN2HiPghSnnV/uPZMvl2zjkS9DP6L4uWr4o/zx/AhO2rqCk7aa+928eRCPvf4qy0pcXPfOgjBzS3Vj2OChwZ1LlcLG3EO4PcpSARd7YOz7i0sTENukp1JWg0qvV5F3sLjMcuqdj67PI18uj6hADsvgBQ98tyJcgYDZwOu6dxdFzVuJhN8kM2n+Zsb/kM2En9ZF9bMVezzsKyguVapWkWZdWzYoVSiRTD6hyiVSO2SrgAb/bOlIipCqThLmWPeZps5TSl3ve38F0EcpNS5gm5bAB8CZwBvANKXUZN+6DUAepjn7VaXUxAjHGQOMAWjdunXPTZs2JeR8ajJWzthUp8GjQ7twRqejgkqC9PvXLGsTiyHMu28gAH2e+C7qjcuG+aHE+s1xeEqYN/4q0guCo6i8djub6jXls64D+f6Y3qw4ql2ll1YpL3YbOAwbXqUY0asVHy/cErMvKclh4/azOvLEV6vK3NZpt/HwYPOGalVixW4jLIu/LFIcBsUeb1B/l0hyliebPJbgghSnQbHbExb08di0FWGzlcCulbE6y3PyCiIGHGzKPchdk5diE3B7FY8M6cLovm0qnElfmb6Umuj491OTHetWd4PQb/fzwD1KKU+orRfor5TaJiJHAd+KyCql1M9hOzSVy0Qwo7MqLnbtw8q27FEqTIHk5BXw8NAuPPj5sjA3cYlH8eWSrQzp0ZJ+x6Qze21uxOOVN+ukxHDQ89YPADh1w2IemvUax+ZuweZ20y5vO3fOfp87Z78PwIm3TOLPlAblPELlYN6EKJ3RlbeZltfj5VmLmZ4VxW4vD3yxjFSnjSK3N6xfinnfLd/X2e31lDlrAXNmYvU0HulGV1ZwgcsuPH1JN+74dClFbm9pTlOkwIX8osP5LZ2Prh9WHiZQjsAIstDvuH/Wc6DQbYaC+y7XQ1PN447u28bSXAaHqxP4zy+RjbZidfyXVSqnppLImUg/4BGl1Lm+9/cBKKX+FbDNBg4rmybAIWCMUuqLkH09AuQrpZ6Ndsy6GuIbC9HCCUO/xCN7teLtX8NnbE5D8HitzTaJYHi9g9z07F9pu3d70PIJfS5hUub5bGnYPGyMXXxZ8JWM0wbF5dWOFqQ4DA6VVG0Qgd9MdfPpHXj5+7Ux+bS++9uAIN9IWfkakWYiDkN47tIetElPjVrjzQqXISgRXAGhz6FFNwPlsAp1dxq2iOa1f17cldF92gQppcDQ4cB9lHi8PFxJM5hAytpXeUrlJIoaW4BRROzAGmAgsBVYAIxSSi2PsP3b+MxZIpIK2JRSB3yvvwUeU0rNjHbMI1mJgPWTpNWXuDLDfSuM7/vX9OBeFoy/ImjVcXf8r9ILPlYXSYbgVpRpaoqEIWbCZKBpKMVh8PSw7rRqnFL6VF2W2QnMop2vXdmLBsmOiOOchvDK6BPJO1RC2/QUZq3axeuz1xO6a7sNnh9xAp2a14ta9TgWrIpuWlVpjrUSg9Nu49d7z4z6WwjlxtPb0699OjdP+j1i8c7yECnvZ/zoEwEinkdVFrCsseYspZRbRMZhRl0ZwJtKqeUiMta3fkKU4c2Az30mLjvwQVkKRGNdi8nKFGG32XCLp8pmHFHxmTF3pzWi7T3TaLlvF7NeH0uSu5jP37uDi674N8V2R9RdHLd7I71yVvDl8QMSntgYL4UehQ3TZBaPHvEo8ITcbLwo+h2THvSZB5pvitzmE3qoD8zt8XLDuwtLkx9vPr1D2Hek2GM648vC7YVxH/6O3Qaj+rTmk4U52JCIszGnYcNlN2VTEOTzUQrsIVEJoY7w9DQXDZIdOEMUqiUq2GwXS87PKz+u543ZG8IMiYG5NeXxb1iZmgtK3Nzw7kIMiVyl2hDhh1W7OKPTUaWy11Qzl85Yr+NYPX05DcFug0MlNfOzTyopZNFLl5NaUgjAd8ecxNiLH8Bjs/HS1GcYvGo2APtcqTQoOhg09sPu53Df+bdWuczVgd9cE0qgjT1SFns8ZffLwga8eFkmALd+mBV2q7bbhDevPokGyQ5K3B6GvTovbB+mggn+rs649dQg01ssMwo/gWa78owLrPoQaOqKx1cSaIYLLJtTFmkug8KS4GAFq+NV1Glf0ZmI7mxYx7FKXnt4SJeIDljD14Y3qaw41QRS6Eii698+YXtaOgBnrVtA9rMXseHpoaUKBAhTIACXLf2G5OLCwwvq0ENSIClOG11bWAcg+BPcOjSrx4ODO5e2FHbY4JITWoT/6BWMO6MDzgp+5l7gjk+XcvsnSyzDagyb0KVFfXq0ahhxpnJt/7YkOWy4fLLYbMLgl+cEJQmGdlN02GBwt+Y4QuR3GsK2fYWW4+q5ohthkh12ru3flhKvKu2iOfGnddwVR3Jl/w5NmHhFL8aPPoHXruxFkt0I28bnCgn6DPKLzECJEo8qPd7tH2cx/vu1ZO88AFR/MiXomcgRQ+jTyqR5m8KiZ5yGcMc5x/Hvb9dg2ISCYk/QtL57y3os23qg3NFZ8XLyxizOW/MrJ2xbRbed60qXn3Tze7Teu5204gIuWDWbH9v3YkanU7j5l4+5a/Z7bGrYnEFXv8h9P77F5VlfAfD4GdfxRu+LAbB5PQiHy7f4qV+Yz35XarWHGceCIfDbA2dFffL0PzUbIhSWeLDZBIdNLCsiv3FlT9btPhhTeLIhxGUKvePsjtwy8FgAfl6zmyvf/C1sm3ev7U2LBkkMemkOxVF8IwCv/rSOp2auimoeNNsvh0dDLd+2n2ve+i3ieVS0KZofqzyZ0Fp3hphmTsMmlHgVdlsMpjpgeK+WTF2yvcIBADXWJ6KpWYT6S0r7jny5AocvKsv/BY/0BV669UDMx7PbJG4nsp9f2mbyS9tMDK+H09cv5Ky18/nXGdeyPymN3WmNAPipfc/S7cf3G85ds9+jzd4dLH9+eNC+HvzhDTrv3sB3x/TmlSlPUmIz6HnLpFIfSmCL4A96nMdDZ4/FbVT85xHNB2Kj/OHSpWN9DeSjdRu8e/LSoM/SY1FHy8917y4K6kkfCX/hymhZ9Fa47MKoPq1L5W3RIAm7jaB92G3QpUV9cvIKcBm2ICUS6huZNG8T/4pB4RW5vWFZ6v7/kRWIjXFndGDiz+vLvJkXuT2kOsNnFhC5IvPtZ3Xk2W/X4DAEt8dr1jfzQonvi+Ipo4yRn08Wbg07dnUkU2olcgQzuk8b+rRtXNoNMFIRv0ikOAzO7NSUaX/sCFtXUQUSiMdmMKtDH2Z16BN9QxEuvvxZPn//ztJFfW56m9TiQr5/fSyXLPueS5Z9D4DD62HpCyNZm96KSy5/hlt/+ah0zKglMxm1ZCbnXfMSq45qVyHZo12GKL3GysRp2Hhixkq+XLINp90Wlrw3af7mcvs4yvrIzjq+Kfeedzwzlu2IyUrod6L7bfmhlXlH9WnNxwu2YIgNj/LyzLAe5B0s5vfNeVG7UubmF/Hol5ZBnkC4z8f6xmp9Ai5DeO3KXnRpUZ/xP2aXeY4iMOjF2Tw8pAvndW0elO+xr6A47PekvMpUIDahxO1lVO/WluH2sRLtOlUV2px1hJKbX1RaysIfpWM11Y5GksPG+9f2ZuRr8ytVaVSULjvXMXzpNzw6cAxen8nq2Lwcvp04FjD7ntz90ztcuPKnoHE/tz2Bx8+8nn99/TK9tq4EaleYsd+UAXDyk7MqPYzbENPVEctuDYEXRmZSP9ls4QvhYcRJDhvTxp3CwWLzaf65b9fw1bLwBxKAK/u15rELuwFm2Oyo137lYIyJPVYmnuydBzjrP2G5yzgM4SufI9/vEDcktpYKDkOwAUUehcsueL0Kyqg64DCgImlFF/Y4mq9X7KxQUmSNzROpDrQSiY0pWVu5O0KviAcHd+bxaStw2GwcLHJbzklSnAZepRjeM4NPFuXg9XgrJVGvopRlq290aB9HHcxjddO2uNzFtM7bzkOzXuPUTVkA9Bz3Prm+CsS3zv2Q2+dM4q2eQ3jytKspcliUbd+7gwaF+aSUFJLkLmZumx6lSqs6SHLYmHiFmf9RnptsZeIwzJunzRYcUWSVjOj3J5RVZBJMc5g5Q2jAzGU7opbxD/0eBCogML//d326xLL8j8tuQ+Rwsp/ff/LSrDUs2LS3XNfCj8Mwr0WR24NXqaDzdNpMpRztGcwmZnyI1SaBiri6orO0EjnCiBbm6P9R+2sVZTRK5qmZq/hkYU7pNsN7tWR0n7YRw0erE7vN/DFWxqSoQcEBlrx4Wen7kZc9wbzW3Q+/z5rJk74Oj35e7jecZwdcGXW/vXKWs6ZJm4Tls7jsNi7scTSfLKr6KB0w/TxGiDnJf6O74KU5QSY2l10YO+AYXvi+bLMRHI5cCs0vKQuXXfjl3oGlBTX7/mtWmeMDm2NZPXCVB4chvHFVL1IchmVYc7yBChB/EmQg2rGuKRfREq789tRAJ/zTw3owvGcGP6/dw4Bjm9CrnRl2u2TL3jL9J/5Y+2g90iuTCqY5BLEvuR7j+17KzfM+BeCjD+/nvnPHsb1eOiBhCgRg3K+fsDcpjdd7/5/lPi/5YxbPzfgPs9tkcsXIf0QXQCkaFh5gb3J9M5rMbseGCssYD6XI7a02BQJmoIA35I7osNmYsWxHmMO4yK1iViAQnjR5eP8gNhsoZblNkVvxwfzN3DLwWJZv2xeTArIJfLlkG//6alWFzYJOu40GyaZJNMlhC8/ZMmxBjb/KQ01ouatnIkcYkWYiVqGQELmmktV+/EojsA3snOw9QTOZ2kjnXeuZ8VZ4AuNzp4zmpf7mbMXlLub1yY+VmsZ+ad0dp6eEvOT63DbkTh6a9Rojl35TOnbsRfcx87j+lserX5jP0hdGAvBncn0a+6ofr2ucweUjHmd7/aaVeXoJx6pkS2VzXtejmLlsV8T1LruN6becwpzsPTG3OnAZEndvnUACfVVWJYjiSfS028y2x5F63pcHbc4KQCuR2AjNoB13xrGM6tPasqqr1Zfeb5uem70nrOhjYG+IvIPFls7L2khgCDDA1OMHcOuQu4JySnrmrOCzSXdH3c/DZ/2FR797FYAXTh7JWdm/8VavoUzudlbpNg/Oeo3rFk6JuI9HBo7hvh/f5MWTL2P8ySPiPKOaTbzlYSJhCBiGDeX1ljmbKy/RioI6DOHWMw//vib+tI5nvlld2m5geM8MPvhtc+ks2mEIJ7ZuyPwNeVGP6TQEEXhmWA+tRCoTrURiJ5ZSCVbF4wCS7DYU8Myw7lF7SE9euIU7Jy9N1ClUOaK82JQiregQ+5KtuwMmlRRy9IFc/jPtWbY0aM6QgAz7k25+l91pjbl42ff8Z/q/g8YVGQ6GXPUfjsrP491PHmJmx36klBSxLj2DT7udxYil3zAq6ytcnuDP4plTrwhTJB2PSmXNrvBs/lCO2bOFrQ2aUuhICj5Pyh95XL8wHyXCAVdqOUdWP36fhMsuEZuPRcKvJF6atcYyuMQQwWkXvApOatuIOdmHWyyc2+UoflqzJ8S8BYrY+8hURqFGrUQC0Eqkcimr1pC/kVWkL3CkMMpQypt057/JOQ2JaCevKbhKikgrLiiN+gIwvB6e+upFig0H7f/MofeW5dgCbtu5yfU584ZXLRXViVtX8r/372Jxi+M4cdtqAO46/zY+7X724f1HcdT6o87Wprfi2NwtgFl6/41eF5UmcMZClx3ZjPv1Ex45awx7Uhux7pkLAci89QP2JtePeT81gbvO6Uin5vVYkrOP+kl2/jGj7CRGPy67cMfZx8WU6W9FaFKu3Vf+JFbrVqrL4IPr+1arY10rEU1U/KYvFBRafLPfvfYkBnQ8KuL4h6b8wbu/Hm7uNKhbM/p3aFoaRuw3g+3YX8gTMf54X77MLD1eHvt2Tec/Xz7LxSt+ZHtaOn8/96boiZXKzD84dcNi3vvkIQC+7dCbGy55KOoxLv99Bv/45r8R1//9nJt4/4RBZcraNP9Pfv3v1diV9Z3uLxfdz9fHnVzmfmoKoTOv8pjSUhw2SryRKwEkmtBy9/GglUgAWokkhtz8ooi919+9tjcDOjYN295v4gL4dV0ue/ILOaVD06CKqoFmsCVb9jL69XmlXe8iMahbMx73xfxXdj/42shZa+fz+v8eB2BvUhpn3vCqZWfIjrs38s2b41hxVDt+bnciZ6xbwJj/+zsjln7DTfMml24XGsocyFEHcvntv1dFlGVzg2a03mf2eV+b3oqLr3iONnnbKLS7WJeeUStqkvlxGja8yhvTjKCy/Tfl4baBHfjb2cdVaB9aiQSglUjiyM0vCuu9brfB/PuDiwAGRnP5O8dFK2MduP9YynQnOWy4/aUeVGK6HJaFYBbLM0RRhs6LGUPMe2w8AUyNDu3j95dGAzCt06mMu/CewyuVYtDqufx3ypMAXHDV8yxv3iFsH2Pmf8b9P75V+v6ykU/waxtTmQxd8SOdd67ngtVzaeVTEgtadubS0U+RUlLI0zNe4NU+l/DH0cdy+eLp/OPbV8L2vza9FedcNx4lNpzuEs5c9xtz22YG+VBSiw5x0JlcI5TN9ae0o1GKnWe+WVvdooQROnMa3qslTw/LjH9/WokcRiuRxDI1ayt3TV4SVOsotDpqNEVQlhMwtP0pVG7uR2VTkSSxQDIzGvDG1ScB8MH8zbz0/dq4fD1zXrmGjP27uWXIXXzZ+TREeflt/JU0PbgXgCLDznF3fhFxfKgCuHrYI/z9+9fp8OfhEO3AasgRUYq7f34naIYDMLnrQFY2bcuDP7xRumzMxQ/Qb/NSCu0ubpw/mUMOF13+9ilK4u9SYROwud20KchlXepRcSklpyEoVIVKklQlt53Zgb+dE9+MRCuRALQSSTzRoroiRXP5iSW71r//WEph1BUMG3x92wAapTrJyStg3vpcnp65qtwKqk3eNn6aOMZy3Yv9RvD8KaPKLMvidJcwfOk3YbOJuW2682dyA24ZenfMN+W0okM0LDzAjrR0sp+9KKYxACubtuWKEY/Teed6dqc1YuVR7WMe62f1SyNwHTrI0wOu5L/9hpc9oA4QqUlZWWglEoBWItVLRWcise6nPJzV6Sh6tGrIyz9kg1KWyWOGDVyGrUqy6iNhiFne3WnYYir2F4nQfBaAvje+zY76Tcq1ny/fvo1uO9fx9bF9ueOC28l3pcQtE0C/TUv48KMHALhz0F+Z3O0sbpn7IXfMmVS6zdnXjufbN28OGzv4qudZZmGCC+WeH9/mxvnBs58daY0544aJFDiTIow6zEXLf2DJ0R3Z0LjsvAub1/yMqrNWWiix9JixQiuRALQSqX5CTVKx+kQCKWtGY4XDhmUS2eS/9MVhN0h1GmzbV2jZiOj+QZ3497dralQdsIrgchfz+Df/5fcWndg3aDCzdnnLnRHdbftaHv/2v9w56G9kN2ldKXLZPW6OPrCHLQ2bmwuU4qrF05jd9gTWp2cApq9p+JKv+deMF4PGnnDLJPIsAgbAvKE//dWLDFs2q3TZjnrpbLztHvr+426WNTuGOwf9NWpZ/0uXfsMzX5nHLKsFQJODeSx8+QrgcO5PIhHljdm8ZxXoUub+a7ISEZHzgBcAA3hdKfVkhO1OAuYBI5RSk8szNhCtRGoGodFZ5e3/HGkm4jSEs45vxtfLd5QqArsNbhvYkXZNUhj3YVbYvgJ7Wjx4QWce+XJ5UDimPzjAn33v8VR+RnN1UxvyaUIxvB467d7I2HmTSxM2h496kuN3baDn1pUMXWmdf/RTuxN57tTLWdr8WFwOg08/f5TuK+YD0Gvce+xJDc+FabF/Fz9M/AsuTwkAS5t34MIr/009n6M/tAOmvwaan3Z3Ty29yRteD6nFBaUFNhsW7Of4XRu4+ddPOHnTUo6/fbJlRWgAlOKEbauxe90saNUVgGsXTOGh71/j6mGP8OMx5n0+pbiADrlbWHp0x7BdlBVyb0WNVSIiYgBrgLOBHGABcJlSaoXFdt8ChcCbSqnJsY4NRSuRuoNVaZbzuzYPqxzsMOCrWwewbV8BV765IOo+7TZw2Y0gc1GgnyZ75wHe/mUj78/fbDneZbehlJeerRvz64Y/4z43w1fau6p01Y2ntWfCT+vj7X9VrdQrOsjCly4vvcFH45U+w3jq9KuDlh2/bytfTfgLAJsaNue0v7wetL779jVMffd2wJyBnLrhdx748U3uGPQ3npnxPBsat2DQNS9RZDhMX5BSzJlwLRn7dwft56IrnqPlvl2Mn/oUcLgszicf3EPvnMO3rXFD72ba8QMYseRrhq78iTVN2vDowDHULzrIy1OeYsDG3wG4ZchdLMjowrxXDp9P23umgVJsfHoIALtTGzLkyueDTJXx+EVqshLpBzyilDrX9/4+AKXUv0K2+ytQApwETPMpkZjGhqKVSN3CKpfEyszltNu4KM7y54Elv++JMhO59uQ2NEx1Mf6H7KhVicsqGeKwCSKCUlU343n32pOYvz6X8T+uj3sfTpugRHF883rlapNcWQxYv4h3P30YgFuH3InLXcKVi6cxt20m/+k/KuLTfbLdhs1dwq/Pj6J+0UHWN2pB+7xtfNDjPO4/bxzPzHieS//4DjBv0o0P7WOxL1w6kJkd+zH24gcYtGoO/53yJK+ddBH/POM6PvjoAU7eXHZpny87ncp5a37B4fWQdXRHMrevKV037bhTGLx6TkzX4bMuZ3DJ8h+ClgU2TquOHuvxx9GVTUtgS8D7HN+yUkSkJXAxMKG8YwP2MUZEForIwt27d1ttoqmlpKe56NGqYekPIqNRMiUW/aeLI5Q/dxiRo4hSXQYuu3Dz6R3IO1hc2gs70o392Gb1+O+P2RS5vZYKxCZwx9kdeemyzKjnVOJVFMdpMjNiaYJuIdeWPwt4pQIKBKDYa4a7VocCAfi5fU/a3jONtvdMY2rn0/m0+9kMufoFnjz9msjmIaDA7eUgBuf7ZhPt87YBZgvkLjuyOXHrKtxi47QxEwH4M6UBjww8HOH2vy5nAHDeml/Z+NRg/jvlSfa5UvnX6deACFcNf5T7zz0cDHD1sEc459rgNgHt75rCLRfeU7qdX4EsatEJIEiBnDZmIg+f9ZfS9xP6DqP3Te+UvvcrkO63fUTW0ccCsPq5/+NfX70ISmHYhJy8gpiuaWWRyJnIpcC5Sqnrfe+vAHorpW4J2OZT4Dml1DwReZvDM5Eyx1qhZyK1j1gKQQYyNWsrd0boShdIqtNg7GnHWOZcpDoNLsxswWeLt+I0bBS5PdhsEtGxLsA7157EzZN+D5oFJRnCsF6t6Ns+nX7HpJc2PTrpH99ZmqrshmBI+ct+g2m2c9mNMjP6rbDbana+TWUimA8PVt+PY3K30G/zH1y+eDqd9hzua/7owBt4q9eFQdsedSCXvcn1KbY7qFd0kPc+/juZ283EQ6vyMDavB6enpLSY5V0/vYOhvDx52tVBIdEnbl3J6N9n8OTp17A7rTH//fwJBq35hVuH3MnUzqeXbpdadIiDARFxrpIibv3lI9rkbeel/iNZ3bQtAD9MvIF2edvZkdaYM294leKkFObfH7meneU1q83mLBHZgPm5AzQBDgFjgJ1ljbVCK5HaRaReJWWRvfMAg16aQ3GUO6N/Wp93sDhs21h7OJid9BTPXppJ/w5NYurDMiVrK7d/nGWZ41FWz4sbT29PRqMUHp+2AuU1w5GTHDaUUlzbvx1vzt2Y0J4cYLZrzWzdiN82Ri9FXlOp57Jzxzkdefrr1WGNnvwRfHYb/P7cpdQrNp/YB4x5jc2Nji5z3zavhwaF+RGjxOLB6S7B6SmJO4S6ycE8Ou3ayC9tuuO1GXGF+dZkJWLHdI4PBLZiOsdHKaWWR9j+bQ7PRMo11o9WIjWPSDMNqwis8thzAx3vJV4vQ3u04IusbTgMweNVQQopdNubT+/AxJ/XB80qXIagRHAZhyO5urZsQKrTKO1fPTd7D3dF6E0fqelQWfhbvj48pAuj+7YJumYlbg//+31r6Ywpv8hdJc5xhyHcdNox7DlYzKQIQQaVla1f2TgN4YPr+zD6jd+CFK5ZVkZwGubDg/J4OClnBbtTG5WGF9cF4mmXW2Pb4yql3CIyDvgaM0z3TaXUchEZ61sf6gcpc2yiZNUkhmgzDas2vQ6bjZy8gpiUyNDMlqW9TJZt3cfj01fgsAklbi8PD+kSNKPp36EJE6/oBSi6tDCfIsf/GNyWVWzC9HGnlCqM9DQXr/60jme/WY3TsOFRpmJ67cpejH1/cdBTrl9u/+toLYNDOalNY14cdULQOaenucJ6e1fmDMSwmX0uIpkESzxm29pkh7XL9JITWnLhCS1IcRjM3/Anz89aW21VbEPxKsWIifPClK1HAUodLrtuM5jfultVi5dwij1V3y43kY51lFIzlFIdlVLHKKX+6Vs2wUqBKKWu9ueIRBqrqT3k5heVOqsPFLkpLPFy92dLyc0vAqyd5OXtF52e5iKjUTKPT19BYYmXg8Ueij2Kx6evKD3OlKyt9H/qe26etJgx7y1ibvYe0tNcPH1Jd5IcNuq57CQ5bDx9SXc6NKtX6si/+9Ms/vXVKko8ioPFnlL5WzRIxhsye/fLHcnxH42563PJO1gcdu3unry0wr29rTjr+KZ8fduAmLYtiDCjmrl8B2PeW8S2fYXcfOaxPHdpj9I+GNWN22sqjOqqqpsoDBGcMVzjcWd0qFBZ+HioIR+9pq7hn2kEEvjEHulGXt4fQLTjRFNkQzNbMveeM3n/+j7MvefMoJlL9s4DltFeNhEOFnuiyn3z6R1w2W2kOMLLYUSKrfp6+Y6g95Pmb67QzOPE1pFt9t+tNCMYHx7SJe79BypV/7WceduAiOenqRg3nNqOr/96Kt4yapY5DGFUn8qpLlAeEmbO0hzZxDLTCDRJlSejPdbjlGUy8/+FkrVlr+WxSjyHZxyB5rH0NFeQ6Q4UV53cNswRbovgR3h+1lpaNU5haGZLcvOLGP9D/OXHbzq9PX3bp3PdOwsjmpjmZO+hUaqzwn4NfzhpepqLDs3q8cLITG7/JKvckWDV2Y+jNvDa7A3YDdNf5/ZEjs57ZGiXKp+FgFYimgThn2ncHeITCf2SR7qRV9Zx4jGZZUZwSt51znGlSYmBx+rfoUnpjMevsN76ZSMPDekc1MHxmpPb8spP4fkaJR7FXZOX0DDFAYDTMChyx143LJB3f93EG3M2EC1gxmW3mYmVFbxxl3hU0LU8UBhdZocNHrjgeLq2aMCO/UXsyS+ka4sGjH5jfkJMd3WJ12dvwFYD+qxYoZWIJmFUxkyjIseJVZGF0qFZPa7s1zqore/wXi25pGdGafSVX1nc/dlSJl7R03LG07VFA+bec2ZQHbHX52ywnCEUuRVj31+Mx+ut0FO5P4/EbrPuXW8TaNkoudwBAFY8PKRz6bWcNG8TD3yxLOr2tw7syNX9w8u6PzOsB3+LEBatMXHabYwdcAzjf8ymxO21vFaPfrmC87o0r/LZiFYimoRS0ZlGRY8TryJ77MJuXNm3LVlb9pLZqiEdmtVjyZa9lsoCJOKMJ1Su5y7tETFZ0h/xZdb4suH0hRsP75XBJwtzcNhsHCp2h91ArEqtOA2Dp0d0Z/m2fbw2ez2GCAp49tIedGnRoFwBAFf3a0N6mouXf8jGbhNKPGYEnL9GU25+EY9+GT140mUPttcHhn4PzWxJ56PrM+jFORR74ldsDkNqRJRYWaVv4sHjVZzftTmHit28Pnu9pRJxGBJzdGNlopWIps4TryLr0KxeaU94iOx/6dKifswzHr9S+2D+Zl7+IRtDhEMh7fOSHXbGjz6RBsmOUkV028COpTfdmct38OiXK3AYgtvjxeNVYX6IQyUe7vh0Cc8M6878+88KU6JPX9I9psx/uw1uGXgs6WkuRvVpbamMc/IKcBhmoUwrnL6ETP+YSKHfz17anTs+ybIsCWM1qwqSUyIHLsRCtEz3WDEELu2ZwedZ26LWVysvLruN4T0zuOCl2VHNfh6vqvLwXtD9RDSachGauBiY+1LeEi65+UUs37afG95dGOSAjyXp0n+sfQXF3Pj+4oiNrKLtK5bM/zvO7sgtA4+Nem65+UX0/dcsy1mA0xBm3HpqqTIuK8l02pJtjPvw97D93HVOR/q0a8zG3EP8ebCYp0I6Pxo2sNtscUW1OQ3h2Ut7sGNfIU98tarc4xPJJSe04LLerRn1xm8RP6dkh4FCxVzxIZQam2yo0dRFopnHyjvjSU9zMaBjU54ZVn6/jf9YuflFlEQxAUVL4OzQrB7PDos8I/GHjMZSnsbqYdRfEiZwNldWxFy/Y9ItzVIvfp/NM8O6M6xXK6ZkbcWwCZ6AbTxe8JQzRwfMjpbPDe9Bv2PS6fevWWUPwAwQUJgZ8JVlPjOA0McAQ+DENo0Z9fr8qDOkq/u34fpT2ldLZBboPBGNptyEVheuKNFyVgLJzS9iyZa9pYmUflmi5XyUlcE8NLMlM249FadFtuAjQ839RksaBVi+bR9Oe3BeTIrD4LUre4WdS1mh3+lpLp67tEdpORg/RW7zuNk7D3DPZ0srrclWkcfL7Z9k8e9v1kSt+hyIiDDztgGWcpaFXWDYiS1xhVxvD3Bh5tE4DMFpmDOrcWd04LFpK8o817fmbiyXDJWNViIaTQ2gLMXkz7y//PX59H/qe6ZmHU6GHN23DTeeHh71BLFlMPtnJEkOG6lOA6ch3H9+J7q2aMDybfuiJo1OydrKDe8uDCt26EXRpUX90vd+BQiUmWQ6NLMl/x6eSZI9/LhZvuCGyqTYo5j022YOFofPZG48vT1prmAF6W9sNjSzJR9c3ydm5QPgVjB58VZL09TXy3dyftfmFHvMmdUL32fHZJ4L/DyqA23O0mhqOIGZ94Ghxf07NCm9+V5/SnvenBOc3BgaERUN61pkprM8NOTYP3PwyxXq7HXZgxWDlTksMPQ5VMlNydoaVDcs8LiZrRqWu7RMvBgCl5yQEfak7z9//3n5VVqSw4bH66Ukhmr9VnMLj9vL1CXbyy1nscdTLQ51P3omotHUcMoqIQPmTOaZYcFP+M8M61FuH01gLbIDRW6K3AqlFC578MwB4IdVu7CHNMoKNWNFKj0DhM28cvOL+HnNbsu6YX7F1KFZvaCZjMsu3HF2R/55cVdfif/KI8VpDypz45+lPXhBZwDunmyeV5HP3OT1Kh4b2jXu45XEaKFzGULg5MfjVXwwf3OQibEq0TMRjaYaiSWiK9ZilZWR3Gnl+A4NOZ6TvYf+T32P4aslFogXRYsGSSzZsjem0jN+Dj/Vh/d5SXEYTLiiJwM6No16nud1aR4QOh09xHZ4rwymZG2NGjJ7qMRNqtNgaGZLDhS6eXTaCpx2G49PX8Hc7N1hcjoMGy0bpYQ1AbNh9qUqy43jNCBCkF0wAnbDhsd3ELcXnvt2DS//kB3U26aq0DMRjaaaiObnCKQ8xSor6vSPlgvj71Hhn1kEKpBUl0GSw8xnGPzynNJzWrZ1X5kKMHC2EpozA8GKyf+0bXWe6Wkubhl4LL/ceyZ3n9fJ8vzsNuGfF3Xl6WE9+OXegdxxdkdcdnOWEYrHCxe8NIdJ8zbx+PQVFLu95BeZxSdnLNsZtv3BYg9b8g7x7+GZuOxCisNswfz4RV2xqlgS6kux2WwM71V2b5M+7RrjNMJv3f7gg6qekeiZiEZTDcTi5wikqkrIlFUqxmpmkeo0eHRIFzJbNWTwy3OCzunx6St4cHBwDbFQBWi1T4AUp4FXqVLFFGsHzPQ0F+2bplque35EDwb3aFm63S0Dj2VUn9Z8uWQbj3y5Imz7IreXR79cbhm9ZsXj01Yw954z+eXegaWfVU5eAckOe1ATNH/75vE/ZofVYZuStS2qQ31udi6Gzdp0F1gUs6rQSkSjqQbiacpVVSVkoiksq5mKRynO6HRUxHMKrSEWeg6pToOikFwXl12YcPmJtGiQHKaYoilbP11aNAjLN3EYQr9jmgDhZsRISgfAXo5Mdv9nGDpLsrpmo/q0DqsCsGTLXpxG9KRJj4K+bRozd31u2LrQophVgTZnaTTVQGU05Uokkcxi0Uxr0c4p0v6mZG1l8MtzEF+yYpLDVhoUMKDjURws9pQZVBBJ/ucu7WH2dnEauOw2nru0R2nZ/lAzYpcWDbCwEAGmz+HhIZ2DzvmUDumW21p9htGuWeh1ibWx2YJNf4blmkBwUcyqQpc90WiqiWglVGo6kQICynNOViVQylsmpSyydx4IKqIZbX8zl+2wrET8z4u7MrpPm9JzTnUapbOjQPwZ+tHONxZzpP8aWgUu+KnnsjNmQHvG/2jWXystitm3TZnXJBRd9kSjqaVUlZ8jEVRG1WQr85c/kS/wOPGU8wfr/JQ26akRzYij+7YBMUuq223g9qigasX+c7aq5hwaQVaeaxZKUM7Otn089uVyy5wZK3NYdZBQJSIi5wEvYJaGeV0p9WTI+guBxzELdLqBvyql5vjWbQQOYFYEcFdEU2o0NZWq8nNUJbGeUyJDlyMFLkwbdwoFJcHNswpK3KXHHN2nDed1aR71WFZyh2boV5RAU1dg6LK/PUCgIq3u70/ClIiIGMB44GwgB1ggIlOVUoEhELOAqUopJSLdgU+AwNi8M5RSexIlo0ajqT7KM8sor7KN5OTftq8QkeCOHxISf1vWsSoyO4qHwCiy6p51WJHImUhvIFsptR5ARD4CLgRKlYhSKj9g+1Qqv5eLRqOpwSTKpBdplgOKJLtBiefwbCTJbpQ7LLY6TJE1ddaayOislsCWgPc5vmVBiMjFIrIKmA5cG7BKAd+IyCIRGRPpICIyRkQWisjC3bt3V5LoGo2mqqjsqsj+fVpFRFl1daxJUXG1kUTORKyyYcJmGkqpz4HPRWQApn/kLN+q/kqpbSJyFPCtiKxSSv1sMX4iMBHM6KxKk16j0dRqIs0WKsMUFUuPlaqivM3QKptEKpEcoFXA+wxgW6SNlVI/i8gxItJEKbVHKbXNt3yXiHyOaR4LUyIajUYT6UZqZQKqqCmqvNUGEklNUGaJVCILgGNFpB2wFRgJjArcQEQ6AOt8jvUTASeQKyKpgE0pdcD3+hzgsQTKqtFoainx3Egr4l+Ip9pAIqgpyixhSkQp5RaRccDXmCG+byqllovIWN/6CcAlwJUiUgIUACN8CqUZponLL+MHSqmZiZJVo9HUTqrjRlpTqg3UFGWW0DwRpdQMYEbIsgkBr58CnrIYtx7okUjZNBpN7ac6bqRVHeIbiZqizHTGukajqbVU1420JlQbqCnKTCsRjUZTa6nOG2lNyNuoCcpMKxGNRlOrqQk30uqkupWZViIajabWU9030iMZ3U9Eo9FoNHGjlYhGo9Fo4kYrEY1Go9HEjVYiGo1Go4kbrUQ0Go1GEzd1qse6iOwGNsU5vAlQUxtg1WTZoGbLV5Nlg5otn5YtfmqyfKGytVFKRe7rWwZ1SolUBBFZWFNb8NZk2aBmy1eTZYOaLZ+WLX5qsnyVLZs2Z2k0Go0mbrQS0Wg0Gk3caCVymInVLUAUarJsULPlq8myQc2WT8sWPzVZvkqVTftENBqNRhM3eiai0Wg0mrjRSkSj0Wg0cXPEKxEROU9EVotItojcWw3HbyUiP4jIShFZLiK3+ZY/IiJbRSTL9zcoYMx9PnlXi8i5VSDjRhH5wyfHQt+yxiLyrYis9f1vVNXyichxAdcnS0T2i8hfq/PaicibIrJLRJYFLCv3tRKRnr5rni0iL4qvV3QCZHtGRFaJyFIR+VxEGvqWtxWRgoBrOCFgTKXLFkW+cn+WVXjtPg6Qa6OIZPmWV+m1i3IPqZrvnVLqiP3D7P2+DmgPOIElQOcqluFo4ETf63rAGqAz8Ahwp8X2nX1yuoB2PvmNBMu4EWgSsuxp4F7f63uBp6pLvoDPcgfQpjqvHTAAOBFYVpFrBfwG9AME+Ao4P0GynQPYfa+fCpCtbeB2IfupdNmiyFfuz7Kqrl3I+ueAh6rj2hH5HlIl37sjfSbSG8hWSq1XShUDHwEXVqUASqntSqnFvtcHgJVAyyhDLgQ+UkoVKaU2ANmY51HVXAi843v9DnBRwPLqkG8gsE4pFa1iQcJlU0r9DPxpcdyYr5WIHA3UV0r9qsxf9rsBYypVNqXUN0opt+/tPCAj2j4SJVsk+aJQ7dfOj+9pfTjwYbR9JFC2SPeQKvneHelKpCWwJeB9DtFv4AlFRNoCJwDzfYvG+cwMbwZMRatDZgV8IyKLRGSMb1kzpdR2ML/EwFHVKB/ASIJ/xDXl2kH5r1VL3+uqlvNazKdPP+1E5HcR+UlETvUtqw7ZyvNZVod8pwI7lVJrA5ZVy7ULuYdUyffuSFciVva+aol5FpE04DPgr0qp/cArwDFAJrAdc7oM1SNzf6XUicD5wM0iMiDKtlUun4g4gaHAp75FNenaRSOSPNVxDR8A3MAk36LtQGul1AnA7cAHIlK/GmQr72dZHZ/xZQQ/wFTLtbO4h0TcNIIcccl3pCuRHKBVwPsMYFtVCyEiDswPf5JS6n8ASqmdSimPUsoLvMZhs0uVy6yU2ub7vwv43CfLTt/01z9N31Vd8mEqt8VKqZ0+OWvMtfNR3muVQ7BZKaFyishVwGBgtM+Mgc/Uket7vQjTbt6xqmWL47Os6mtnB/4P+DhA5iq/dlb3EKroe3ekK5EFwLEi0s73NDsSmFqVAvjsqW8AK5VS/w5YfnTAZhcD/qiQqcBIEXGJSDvgWExnWKLkSxWRev7XmI7YZT45rvJtdhUwpTrk8xH0JFhTrl0A5bpWPtPDARHp6/t+XBkwplIRkfOAe4ChSqlDAcubiojhe93eJ9v6qpTNd+xyfZZVLR9wFrBKKVVqBqrqaxfpHkJVfe8qGhlQ2/+AQZjRDOuAB6rh+KdgThmXAlm+v0HAe8AfvuVTgaMDxjzgk3c1lRQZE0W+9piRHEuA5f5rBKQDs4C1vv+Nq0m+FCAXaBCwrNquHaYy2w6UYD7ZXRfPtQJ6Yd4w1wEv46sukQDZsjHt4/7v3gTftpf4Pu8lwGJgSCJliyJfuT/Lqrp2vuVvA2NDtq3Sa0fke0iVfO902RONRqPRxM2Rbs7SaDQaTQXQSkSj0Wg0caOViEaj0WjiRisRjUaj0cSNViIajUajiRutRDSacuKr0rqs7C1Lt79aRFrEsM3LFZdOo6latBLRaBLP1UBUJaLR1Fa0EtFo4sMuIu/4CgNOFpEUEXlIRBaIyDIRmSgmwzATuCaJ2VsiWUROEpFfRGSJiPzmrwgAtBCRmWL2f3i6Gs9No4kZrUQ0mvg4DpiolOoO7AduAl5WSp2klOoKJAODlVKTgYWYdakyAQ9mnaXblFI9MMtmFPj2mQmMALoBI0QksL6RRlMj0UpEo4mPLUqpub7X72OWnjhDROaLyB/AmUAXi3HHAduVUgsAlFL71eF+HrOUUvuUUoXACswGWxpNjcZe3QJoNLWU0HpBCvgv0EsptUVEHgGSLMaJxVg/RQGvPejfp6YWoGciGk18tBaRfr7XlwFzfK/3+Po6DAvY9gBm21KAVZi+j5MARKSer5y4RlMr0V9ejSY+VgJXicirmFVSXwEaYVac3YjZZsDP28AEESnA7F89AnhJRJIx/SFnVZ3YGk3loqv4ajQajSZutDlLo9FoNHGjlYhGo9Fo4kYrEY1Go9HEjVYiGo1Go4kbrUQ0Go1GEzdaiWg0Go0mbrQS0Wg0Gk3c/D9Y8lJGV4X+RwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "epoch = 0\n",
    "epoch_loss_series = pd.Series(mf_losses[epoch], name='Loss').rename_axis('batch')\n",
    "ax = epoch_loss_series.reset_index().plot.scatter(\n",
    "    x='batch', y='Loss', title=f'Batch loss at epoch {epoch} '\n",
    ")\n",
    "epoch_loss_series.rolling(50).mean().reset_index().plot(\n",
    "    ax=ax, x='batch', y='Loss', color='r', label='Rolling loss'\n",
    ");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scoring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mf_model_scoring(params, data, data_description):\n",
    "    model = params\n",
    "    model.eval()\n",
    "    # prepare user and item index for scoring\n",
    "    device = next(model.parameters()).device\n",
    "    test_users = data_description['test_users']\n",
    "    n_items = data_description['n_items']\n",
    "    all_items = torch.arange(n_items, dtype=torch.int64, device=device)\n",
    "    # perform scoring on a per-user basis\n",
    "    scores = np.empty((len(test_users), n_items), dtype='f4')\n",
    "    for user in test_users:\n",
    "        test_user = torch.broadcast_to(torch.LongTensor([user]), (n_items,)).to(device)\n",
    "        with torch.no_grad():\n",
    "            predictions = model(test_user, all_items)\n",
    "            scores[user, :] = predictions.detach().cpu().numpy()\n",
    "    return scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "mf_scores = mf_model_scoring(mf_model, None, data_description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "seen_data = training.loc[lambda x: x[data_index[\"users\"].name].isin(data_description[\"test_users\"])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "downvote_seen_items(mf_scores, seen_data, data_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.05562913907284768, 0.017044307789340903, 0.8865784499054821)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mf_recs = topn_recommendations(mf_scores, topn=10)\n",
    "model_evaluate(mf_recs, validation, data_description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bayesian Personalized Ranking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BPRMF(MFBase):\n",
    "    def forward(self, user, pos_item, neg_item=None):\n",
    "        user = self.user_embeddings(user)\n",
    "        pos_item = self.item_embeddings(pos_item)\n",
    "        prediction_i = (user * pos_item).sum(dim=-1)\n",
    "        if not self.training:  # support validation phase\n",
    "            return prediction_i\n",
    "\n",
    "        neg_item = self.item_embeddings(neg_item)\n",
    "        prediction_j = (user * neg_item).sum(dim=-1)\n",
    "        return prediction_i, prediction_j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "bpr_data_loader = observations_loader(\n",
    "    matrix_from_data(observed_data, data_description),\n",
    "    batch_size=batch_size,\n",
    "    n_neg_samples=1,\n",
    "    data_factory=BPRDataset\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([4999, 1363, 2532,  ..., 5642,  720, 2084], device='cuda:0'),\n",
       " tensor([3348, 2460,   99,  ..., 3128, 2699, 1363], device='cuda:0'),\n",
       " tensor([3562, 1371, 3630,  ..., 1339, 1032,  273], device='cuda:0')]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch = next(iter(bpr_data_loader))\n",
    "batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_bprmf_epoch(loader, model, criterion, optimizer, scheduler=None):\n",
    "    model.train()\n",
    "    losses = []\n",
    "    \n",
    "    for (users, pos_items, neg_items) in loader:\n",
    "        optimizer.zero_grad()\n",
    "        loss = criterion(*model(users, pos_items, neg_items))\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        losses.append(loss.detach().cpu().item())\n",
    "    \n",
    "    if scheduler is not None:\n",
    "        scheduler.step()\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_bprmf_model(config, data_description):\n",
    "    model = BPRMF(\n",
    "        data_description['n_users'],\n",
    "        data_description['n_items'],\n",
    "        config['dim']\n",
    "    )\n",
    "    # transfer model to GPU if available\n",
    "    device = None\n",
    "    if torch.cuda.is_available():\n",
    "        if not next(model.parameters()).is_cuda:\n",
    "            model = model.cuda()\n",
    "        device = next(model.parameters()).device\n",
    "    # define loss function\n",
    "    logsigmoid = nn.LogSigmoid().to(device)\n",
    "    def criterion(pred_i, pred_j):\n",
    "        return -logsigmoid(pred_i - pred_j).sum()\n",
    "    # define optimizer\n",
    "    optimizer = torch.optim.Adam(\n",
    "        model.parameters(),\n",
    "        lr = config['learning_rate'],\n",
    "        weight_decay=config['l2_reg']\n",
    "    )\n",
    "    return model, criterion, optimizer, device\n",
    "\n",
    "\n",
    "def build_bprmf_model(config, data, data_description):\n",
    "    '''Simple BPRMF training routine without early stopping'''\n",
    "    model, criterion, optimizer, device = prepare_bprmf_model(config, data_description)\n",
    "    data_loader = observations_loader(\n",
    "        matrix_from_data(data, data_description),\n",
    "        batch_size = batch_size,\n",
    "        n_neg_samples = 1,\n",
    "        data_factory = BPRDataset\n",
    "    )\n",
    "    \n",
    "    losses = {}\n",
    "    for epoch in tqdm(range(config['epochs'])):\n",
    "        losses[epoch] = train_bprmf_epoch(data_loader, model, criterion, optimizer)\n",
    "    return model, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [03:34<00:00, 10.70s/it]\n"
     ]
    }
   ],
   "source": [
    "bpr_model, bpr_losses = build_bprmf_model(config, observed_data, data_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.Series(bpr_losses).apply(np.mean).plot(title='Evolution of BPRMF loss', xlabel='Epoch', ylabel='BPR Loss');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "epoch = 0\n",
    "epoch_loss_series = pd.Series(bpr_losses[epoch], name='BPR Loss').rename_axis('batch')\n",
    "ax = epoch_loss_series.reset_index().plot.scatter(\n",
    "    x='batch', y='BPR Loss', title=f'Batch loss at epoch {epoch} '\n",
    ")\n",
    "epoch_loss_series.rolling(10).mean().reset_index().plot(\n",
    "    ax=ax, x='batch', y='BPR Loss', color='r', label='Rolling loss'\n",
    ");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scoring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "bprmf_scores = mf_model_scoring(bpr_model, None, data_description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "seen_data = training.loc[lambda x: x[data_index[\"users\"].name].isin(data_description[\"test_users\"])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "downvote_seen_items(bprmf_scores, seen_data, data_description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.062086092715231786, 0.02018901766004415, 0.8066432622198217)"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bprmf_recs = topn_recommendations(bprmf_scores, topn=10)\n",
    "model_evaluate(bprmf_recs, validation, data_description)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NeuralCF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NCF(nn.Module):\n",
    "    '''\n",
    "    The source for NCF code is taken form https://github.com/guoyang9/NCF.\n",
    "    '''\n",
    "    def __init__(\n",
    "        self,\n",
    "        user_num,\n",
    "        item_num,\n",
    "        factor_num,\n",
    "        num_layers,\n",
    "        dropout,\n",
    "        model,\n",
    "        GMF_model=None,\n",
    "        MLP_model=None,\n",
    "    ):\n",
    "        super(NCF, self).__init__()\n",
    "        \"\"\"\n",
    "        user_num: number of users;\n",
    "        item_num: number of items;\n",
    "        factor_num: number of predictive factors;\n",
    "        num_layers: the number of layers in MLP model;\n",
    "        dropout: dropout rate between fully connected layers;\n",
    "        model: 'MLP', 'GMF', 'NeuMF-end', and 'NeuMF-pre';\n",
    "        GMF_model: pre-trained GMF weights;\n",
    "        MLP_model: pre-trained MLP weights.\n",
    "        \"\"\"\n",
    "        self.dropout = dropout\n",
    "        self.model = model\n",
    "        self.GMF_model = GMF_model\n",
    "        self.MLP_model = MLP_model\n",
    "\n",
    "        self.embed_user_GMF = nn.Embedding(user_num, factor_num)\n",
    "        self.embed_item_GMF = nn.Embedding(item_num, factor_num)\n",
    "        self.embed_user_MLP = nn.Embedding(\n",
    "            user_num, factor_num * (2 ** (num_layers - 1))\n",
    "        )\n",
    "        self.embed_item_MLP = nn.Embedding(\n",
    "            item_num, factor_num * (2 ** (num_layers - 1))\n",
    "        )\n",
    "\n",
    "        MLP_modules = []\n",
    "        for i in range(num_layers):\n",
    "            input_size = factor_num * (2 ** (num_layers - i))\n",
    "            MLP_modules.append(nn.Dropout(p=self.dropout))\n",
    "            MLP_modules.append(nn.Linear(input_size, input_size // 2))\n",
    "            MLP_modules.append(nn.ReLU())\n",
    "        self.MLP_layers = nn.Sequential(*MLP_modules)\n",
    "\n",
    "        if self.model in [\"MLP\", \"GMF\"]:\n",
    "            predict_size = factor_num\n",
    "        else:\n",
    "            predict_size = factor_num * 2\n",
    "        self.predict_layer = nn.Linear(predict_size, 1)\n",
    "\n",
    "        self._init_weight_()\n",
    "\n",
    "    def _init_weight_(self):\n",
    "        \"\"\" We leave the weights initialization here. \"\"\"\n",
    "        if not self.model == \"NeuMF-pre\":\n",
    "            nn.init.normal_(self.embed_user_GMF.weight, std=0.01)\n",
    "            nn.init.normal_(self.embed_user_MLP.weight, std=0.01)\n",
    "            nn.init.normal_(self.embed_item_GMF.weight, std=0.01)\n",
    "            nn.init.normal_(self.embed_item_MLP.weight, std=0.01)\n",
    "\n",
    "            for m in self.MLP_layers:\n",
    "                if isinstance(m, nn.Linear):\n",
    "                    nn.init.xavier_uniform_(m.weight)\n",
    "            nn.init.kaiming_uniform_(\n",
    "                self.predict_layer.weight, a=1, nonlinearity=\"sigmoid\"\n",
    "            )\n",
    "\n",
    "            for m in self.modules():\n",
    "                if isinstance(m, nn.Linear) and m.bias is not None:\n",
    "                    m.bias.data.zero_()\n",
    "        else:\n",
    "            # embedding layers\n",
    "            self.embed_user_GMF.weight.data.copy_(self.GMF_model.embed_user_GMF.weight)\n",
    "            self.embed_item_GMF.weight.data.copy_(self.GMF_model.embed_item_GMF.weight)\n",
    "            self.embed_user_MLP.weight.data.copy_(self.MLP_model.embed_user_MLP.weight)\n",
    "            self.embed_item_MLP.weight.data.copy_(self.MLP_model.embed_item_MLP.weight)\n",
    "\n",
    "            # mlp layers\n",
    "            for (m1, m2) in zip(self.MLP_layers, self.MLP_model.MLP_layers):\n",
    "                if isinstance(m1, nn.Linear) and isinstance(m2, nn.Linear):\n",
    "                    m1.weight.data.copy_(m2.weight)\n",
    "                    m1.bias.data.copy_(m2.bias)\n",
    "\n",
    "            # predict layers\n",
    "            predict_weight = torch.cat(\n",
    "                [\n",
    "                    self.GMF_model.predict_layer.weight,\n",
    "                    self.MLP_model.predict_layer.weight,\n",
    "                ],\n",
    "                dim=1,\n",
    "            )\n",
    "            precit_bias = (\n",
    "                self.GMF_model.predict_layer.bias + self.MLP_model.predict_layer.bias\n",
    "            )\n",
    "\n",
    "            self.predict_layer.weight.data.copy_(0.5 * predict_weight)\n",
    "            self.predict_layer.bias.data.copy_(0.5 * precit_bias)\n",
    "\n",
    "    def forward(self, user, item):\n",
    "        if not self.model == \"MLP\":\n",
    "            embed_user_GMF = self.embed_user_GMF(user)\n",
    "            embed_item_GMF = self.embed_item_GMF(item)\n",
    "            output_GMF = embed_user_GMF * embed_item_GMF\n",
    "        if not self.model == \"GMF\":\n",
    "            embed_user_MLP = self.embed_user_MLP(user)\n",
    "            embed_item_MLP = self.embed_item_MLP(item)\n",
    "            interaction = torch.cat((embed_user_MLP, embed_item_MLP), -1)\n",
    "            output_MLP = self.MLP_layers(interaction)\n",
    "\n",
    "        if self.model == \"GMF\":\n",
    "            concat = output_GMF\n",
    "        elif self.model == \"MLP\":\n",
    "            concat = output_MLP\n",
    "        else:\n",
    "            concat = torch.cat((output_GMF, output_MLP), -1)\n",
    "\n",
    "        prediction = self.predict_layer(concat)\n",
    "        return prediction.view(-1)\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "e587e8b75394de48c2e2a47def3a5e72a23054844b7abdff48af37dc7e76636d"
  },
  "kernelspec": {
   "display_name": "Python 3.9.10 ('torch')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}