DependencyParsing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cosmetic-atlantic",
   "metadata": {},
   "source": [
    "# 📑 Summary 📑"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "stopped-investigator",
   "metadata": {},
   "source": [
    "## 📌 Task 📌"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "judicial-anxiety",
   "metadata": {},
   "source": [
    "To combine pre-trained word embeddings (custom or BERT) with dependency parse trees to train edge conditioned convolution graph networks for sentiment classification."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indie-clearance",
   "metadata": {},
   "source": [
    "1. Explore how dependency parsing works\n",
    "2. Tokenize sentences and give them to the dependency parser\n",
    "3. Obtain the relationships and check them\n",
    "4. Convert the dependency graphs from the parser into the graphs that can be used for GCN\n",
    "5. Explore GCN and try to build graphs from the parsed dependency graphs\n",
    "6. Perform graph level classification\n",
    "7. Check performance\n",
    "8. Refine the various layers and hyperparameters in the process\n",
    "9. Check final performance\n",
    "10. Do interpreation manually on some selected examples\n",
    "11. Implement edge masking to get the minimum subgraph\n",
    "12. Performe automatic interpretation of the graphs to determine the most important terms/relationships for each sentence"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "basic-internship",
   "metadata": {},
   "source": [
    "## 📐 Method 📐"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hydraulic-gross",
   "metadata": {},
   "source": [
    "* For dependency parsing, we will try to use the tools from the stanford nlp group.\n",
    "* The *[CoreNLP](https://github.com/stanfordnlp/CoreNLP)* library is important as it contains many of the tools needed to performe dependency parsing\n",
    "* The *[stanza](https://github.com/stanfordnlp/stanza)* library offers a wrapped version of CoreNLP that works directly with Python\n",
    "* Visualization of the graphs can be done using *[networkx](https://github.com/networkx/networkx)*\n",
    "* For GCN and word-level graphs we will primarily look at the ideas in this *[tutorial](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial7/GNN_overview.html)*\n",
    "* We will try to use the *[spektral](https://github.com/danielegrattarola/spektral/)* library to implement the graphs convolution and attention \n",
    "* *[Link](https://universaldependencies.org/u/dep/)* to explaination of dependency relations.\n",
    "* *[Link](https://nlp.stanford.edu/software/nndep.html)* to explaination of dependency parsing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "constant-beijing",
   "metadata": {},
   "source": [
    "## 📀 Dataset 📀"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coordinate-graphics",
   "metadata": {},
   "source": [
    "The dataset is still IMDB review but we may expand later on"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "actual-kernel",
   "metadata": {},
   "source": [
    "## 🧮 Results 🧮"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fitted-supervisor",
   "metadata": {},
   "source": [
    "Read the notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "material-motel",
   "metadata": {},
   "source": [
    "## 🎬 Conclusion 🎬"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "earlier-morocco",
   "metadata": {},
   "source": [
    "Read the manuscript"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "circular-colonial",
   "metadata": {},
   "source": [
    "# 👾 Code 👾"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "clear-thong",
   "metadata": {},
   "source": [
    "## 𖢞 Part 1: Dependency Parsing 𖢞"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "addressed-excitement",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 📦 Basic Imports 📦"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "complete-disease",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "37c1f01c021b48aeb52deed5c4c6f6ad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading https://raw.githubusercontent.com/stanfordnlp/stanza-resources/main/resources_1.4.0.json:   0%|   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-08 14:38:14 INFO: Downloading default packages for language: en (English)...\n",
      "2022-06-08 14:38:15 INFO: File exists: /Users/zeyuyang/stanza_resources/en/default.zip\n",
      "2022-06-08 14:38:18 INFO: Finished downloading models and saved to /Users/zeyuyang/stanza_resources.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import stanza\n",
    "import networkx as nx\n",
    "import spacy\n",
    "import stanzaTools\n",
    "stanza.download('en')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "certain-consideration",
   "metadata": {},
   "source": [
    "### 🔎 Testing Stanza 🔎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "thrown-cardiff",
   "metadata": {},
   "outputs": [],
   "source": [
    "sampleSentence = \"There is nothing wrong with Apple's new M1 Max Chip, everything works so well! Ok this might be kind of difficult.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "unsigned-rover",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b0ab08f6b70144c881ced1dc5abb9f6e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading https://raw.githubusercontent.com/stanfordnlp/stanza-resources/main/resources_1.4.0.json:   0%|   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-07 15:34:06 WARNING: Can not find mwt: default from official model list. Ignoring it.\n",
      "WARNING:stanza:Can not find mwt: default from official model list. Ignoring it.\n",
      "2022-06-07 15:34:07 INFO: Loading these models for language: en (English):\n",
      "========================\n",
      "| Processor | Package  |\n",
      "------------------------\n",
      "| tokenize  | combined |\n",
      "| pos       | combined |\n",
      "| lemma     | combined |\n",
      "| depparse  | combined |\n",
      "| sentiment | sstplus  |\n",
      "========================\n",
      "\n",
      "INFO:stanza:Loading these models for language: en (English):\n",
      "========================\n",
      "| Processor | Package  |\n",
      "------------------------\n",
      "| tokenize  | combined |\n",
      "| pos       | combined |\n",
      "| lemma     | combined |\n",
      "| depparse  | combined |\n",
      "| sentiment | sstplus  |\n",
      "========================\n",
      "\n",
      "2022-06-07 15:34:07 INFO: Use device: cpu\n",
      "INFO:stanza:Use device: cpu\n",
      "2022-06-07 15:34:07 INFO: Loading: tokenize\n",
      "INFO:stanza:Loading: tokenize\n",
      "2022-06-07 15:34:07 INFO: Loading: pos\n",
      "INFO:stanza:Loading: pos\n",
      "2022-06-07 15:34:07 INFO: Loading: lemma\n",
      "INFO:stanza:Loading: lemma\n",
      "2022-06-07 15:34:07 INFO: Loading: depparse\n",
      "INFO:stanza:Loading: depparse\n",
      "2022-06-07 15:34:07 INFO: Loading: sentiment\n",
      "INFO:stanza:Loading: sentiment\n",
      "2022-06-07 15:34:07 INFO: Done loading processors!\n",
      "INFO:stanza:Done loading processors!\n"
     ]
    }
   ],
   "source": [
    "nlp = stanza.Pipeline(\n",
    "    'en',\n",
    "    processors = 'tokenize,mwt,pos,lemma,depparse, sentiment')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "annoying-appliance",
   "metadata": {},
   "outputs": [],
   "source": [
    "doc = nlp(sampleSentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "ultimate-recorder",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{\n",
       "   \"id\": 1,\n",
       "   \"text\": \"There\",\n",
       "   \"lemma\": \"there\",\n",
       "   \"upos\": \"PRON\",\n",
       "   \"xpos\": \"EX\",\n",
       "   \"head\": 2,\n",
       "   \"deprel\": \"expl\",\n",
       "   \"start_char\": 0,\n",
       "   \"end_char\": 5\n",
       " },\n",
       " {\n",
       "   \"id\": 2,\n",
       "   \"text\": \"is\",\n",
       "   \"lemma\": \"be\",\n",
       "   \"upos\": \"VERB\",\n",
       "   \"xpos\": \"VBZ\",\n",
       "   \"feats\": \"Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin\",\n",
       "   \"head\": 0,\n",
       "   \"deprel\": \"root\",\n",
       "   \"start_char\": 6,\n",
       "   \"end_char\": 8\n",
       " },\n",
       " {\n",
       "   \"id\": 3,\n",
       "   \"text\": \"nothing\",\n",
       "   \"lemma\": \"nothing\",\n",
       "   \"upos\": \"PRON\",\n",
       "   \"xpos\": \"NN\",\n",
       "   \"feats\": \"Number=Sing\",\n",
       "   \"head\": 2,\n",
       "   \"deprel\": \"nsubj\",\n",
       "   \"start_char\": 9,\n",
       "   \"end_char\": 16\n",
       " }]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.sentences[0].words[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "ranging-grocery",
   "metadata": {},
   "outputs": [],
   "source": [
    "sent_dict = doc.sentences[0].to_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "invisible-token",
   "metadata": {},
   "source": [
    "#### 📊 tokenRelationHead 📊"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "monthly-statement",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Token           | Relation   | Head            \n",
      "--------------------------------------------------\n",
      "There           | expl       | is              \n",
      "is              | root       | ROOT            \n",
      "nothing         | nsubj      | is              \n",
      "wrong           | amod       | nothing         \n",
      "with            | case       | Max             \n",
      "Apple           | nmod:poss  | Max             \n",
      "'s              | case       | Apple           \n",
      "new             | amod       | Max             \n",
      "M1              | compound   | Max             \n",
      "Max             | nmod       | nothing         \n",
      "Chip            | flat       | Max             \n",
      ",               | punct      | works           \n",
      "everything      | nsubj      | works           \n",
      "works           | parataxis  | is              \n",
      "so              | advmod     | well            \n",
      "well            | advmod     | works           \n",
      "!               | punct      | is              \n"
     ]
    }
   ],
   "source": [
    "stanzaTools.tokenRelationHead(sent_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "attempted-sight",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 🐝 getNodeEdgeLists 🐝 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "frozen-palestinian",
   "metadata": {},
   "outputs": [],
   "source": [
    "nodeList, edgeList = stanzaTools.getNodeEdgeLists(doc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "cheap-transcript",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'id': 1,\n",
       "  'text': 'There',\n",
       "  'lemma': 'there',\n",
       "  'upos': 'PRON',\n",
       "  'xpos': 'EX',\n",
       "  'head': 2,\n",
       "  'deprel': 'expl',\n",
       "  'start_char': 0,\n",
       "  'end_char': 5},\n",
       " {'id': 2,\n",
       "  'text': 'is',\n",
       "  'lemma': 'be',\n",
       "  'upos': 'VERB',\n",
       "  'xpos': 'VBZ',\n",
       "  'feats': 'Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin',\n",
       "  'head': 0,\n",
       "  'deprel': 'root',\n",
       "  'start_char': 6,\n",
       "  'end_char': 8},\n",
       " {'id': 3,\n",
       "  'text': 'nothing',\n",
       "  'lemma': 'nothing',\n",
       "  'upos': 'PRON',\n",
       "  'xpos': 'NN',\n",
       "  'feats': 'Number=Sing',\n",
       "  'head': 2,\n",
       "  'deprel': 'nsubj',\n",
       "  'start_char': 9,\n",
       "  'end_char': 16}]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nodeList[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "conceptual-joint",
   "metadata": {},
   "source": [
    "#### 📊 drawDepGraph 📊"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "computational-ridge",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA24AAANuCAYAAABuUVpnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdZ0BTdxsF8HOTsDcCTlBwKy5UtE7ciru2VlCLs1r3qFbrqKNWa7Uu3Hvitu5ZtyA4cNa9wImKKCuEJPf9QOGtVRQ05Cbh/L5USXJz6iVwn/v8hyCKoggiIiIiIiIyWDKpAxAREREREdGHsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycCzciIiIiIiIDBwLNyIiIiIiIgPHwo2IiIiIiMjAsXAjIiIiIiIycAqpAxARERkCURSRpElFokYFDbTQiiJkggA5ZLCRm8NabgZBEKSOSdnAc0pEpoSFG1EuwosYov8TRREvUpMQo0rAq9QkJKhVEAAIggBRFAEBgPj/v4sAbBXmcDKzhpu5LVzMrPl5MTA8p0RkygRRFEWpQxBRzuBFDNG7UrUaRCvjcC85FmqtFhpk/9egHAIUMhk8rZzhbukIM5k8B5JSVvGcElFuwMKNyATxIoboXRpRi2sJMXiofA0A0H7C5+K/ZEi7sVHI0gGlbd0gFzh1XJ94TokoN2HhRmRCeBFD9H6xqiRExj9Gqlajk8/Ff8kgwEwmRyX7AnA2s9b58eldPKdElNuwcCMyEbyIIXrXv29m5MTn4r9kEHiTI4fxnBJRbsXCjcjI8SKG6P3UohYRcVF4o07Ry2cjnQwC7BUW8HX0gIKfEZ3iOSWi3IyFG5ER40UM0fupRS3CXj1Aokal189GOhkE2MjN8YVTYX5GdITnlIhyO/7kITJS6Rcx+i7agLS5c2/UKQh79QBqUavX9yb6GM0/NzSkusAH0j4jiRoVIuKioOFn5LPxnBIRsXAjMkq8iCHK3LWEGEluaPxX+g2OawkxkuYwBTynREQs3IiMEi9iiN4vVpWkt/meWaGFiIfK14hNTZI6itHiOSUiSsPCjcjI8CKG6P00ohaR8Y8N5rORTgsRkW8eszP9CXhOiYj+j4UbkRHhRQxR5q4lxCBVq5E6xnulajW4zs50tvGcEhH9Hws3IiPCixii90vVagyqE/1fWoiIVr422M+vIeI5JSJ6Gws3IiPBixiizEUr46SOkCXGktMQGMu/lbHkJCLjx8KNyEgYy8WBseQk0yGKIu4lxxrsTY10WqTl5PapH8dzSkT0LhZuREaAFzFEmXuRmgS11jjmV6q1WrzkQj4fxXNKRPQuFm5ERoAXMUSZi1ElQGPgNzXSaSAiRpUgdQyDx3NKRPQuFm5ERoAXMUSZe/WeGwVdKzdAn7qt0K9eWwxs9JXO33OofwAA4FnUIxzdsivj6wfXb8P8ERM/+FpunfFx7zunMweOQmCZmuhTp+VbX79z+RqGNPsm41zfOH8pW++V+CYe0/v+iB6+TdC9amNM7/sjEt/EAwAunYrAuI69P3oMnlMi0gcWbkRG4H0XMemeP3qCEW2D0LtWC3xfuwW2L1qV8djqKbPQt25r9KvXFqO/7o6XT3Wz6uOJHfvQq2ZzjGgb9N7HeRFD+iKKIhLUqvc+NnnrSgQf2YZZBzfr/H2n7wkBADyLfoSjW3d95NlvS1CrOJz4AzI7pw07tMGE9Yve+fryCdMQ+ENfBB/Zhk4/9sfyCdOy9X6zBo1GvsLuWBKxH0vPHEBej0KYNXhMto7Bc0pE+sDCjcjAfejCFADkCjl6jB+OBSd3YfreDdi1bB2ibtwGALTr2x1zj21H8JFt8G3sh5Bp83SS6cDaLRgwfQKmbFv53sd5EUP6kqRJhaDjY877cQJO7zsMAPglqB9mDhwFADiwbgtW/joTANCuSGUAwIpfpuPq6XPoV68tti1YAQB4+TQGY77piZ7VmmDZ+N/fOb4AIEmbquPUpiOzc+r9RVXYOTq+83VBEJAUn9blT3yTAOd8bll+r8d3H+D2pavoMPT7jK8F/NAHty9ewZN7UW8992bkZfSv/+U7Xwd4TolIP1i4ERm4j12YOud1Q7HyZQEA1rY2cC9RFC+fPEv7u51txvOUSckQsnmFe3TrbvSp2wp96rTEsn/uYq+bNhd/h5/HrMGjsXTcuxelAC9iSH8SNSoI7/nGFgQBY9p3x4CG7bB31cb3vvb0vsNYPWX2O18vW70yrp4+ByCtCIu6mXYj5Orpc/CuXuWt53YZPRRlq1dG8JFtaNu7CwDg7pXrGLH4D8w9tgPHt+/F80dP3smW+IGbMbldZuc0Mz1/GYll46chqGI9LBs3FV1GDX7nOS+fxuDngO/e+XrUzTvwKlsKcrk842tyuRxeZUvhwT83wADg74hIBA8bhzGrgpHf0+Od4/CcEpE+sHAjMnDZuYh5FvUIdy9fQ8nKFTK+tvLXmQiqWA9Ht+xEpx8HvPOazC5oXj6NwYqJ0zF5ywrMObwNty5cQdieQwj8oS+KVyyLYfN/R/dxw96bgxcxpC8aaN/b3Z26cy1m/7UVE0IWYfeydbgSduad51RvWh+dR7z7mShbvQquhp9F1I3bcC9RFI6uLoh9FoPrZy+gtG+lj2aqWKc6bOztYG5pAY8SxRAT/fitx0UxLTe9X2bnNDN7VqxHzwkjsPLCEfScOAIzB41+5zl58rlhfMi7wyyzIvrmXQT/MBY/r5kPt0IF3vscnlMi0gcWbkQGLqsXMckJiZjUbQB6ThzxVqct6KdBWHnhCPzatcTOpWvfeV1mFzQ3Iy+jXI2qcHBxhlyhgF+7FrgSdjZLmXkRQ/qiFUW8ryXtkj8vAMDRNQ++8G+IG+cvZ/mYLvnzIvF1PM4dPgnvL6qgbLXKOLF9HyxtrGFta/PR15uZm2f8WSaXQaP5z6b0wj+56b0yO6eZ+WvDn6jRohEAoFarprgZmfVz7VGiKO5evQ7tv1bt1Wq1uHv1OjxKFAUAOOd1hZmFBe5c/jvzA/GcEpEesHAjMnBZuYhRp6bi124DUa9dS9Rs0fi9z/Fr1wKhuw/kQML34EUM6YlMEPDfBVeViUlISkjM+PP5o6dQuHTxbB23ZOUK2L5oFbyrV0HZ6pWxdd5ylK1e+Z3nWdnaIPmf98oy8Z/c9F7vO6cf4pzPDZdD0zqqF0+cRgGvwll+bQGvwvDyLo31f8zP+Nr6P+ajaLkyGcexcbDDuLULsPKXGbh0KuL9B+I5JSI9YOFGZOA+dhEjiiJmDRoN9xJeaPt9l7cee3T3fsafT+87jELFvLL8viV9yuFy2Bm8fvkKGo0Gx7buhneNqll7MS9iSE/kkL0zlPjV85cY3qIj+vm1weCm7VG1UV1UqV/7nddmNscNSJvnplGrUcCrMIqVL4P4uNcoW+3dws2zTAnI5HL082uTsTjJxwhCWm56v/edUwD4rddQDPXvgIe37+PbCn7YvzZttdAB0ydgyc+/oZ9fG6z8dSb6T5/wzmszGxIOAANn/oJHdx6ge9XG6F61MR7deYCBM3956zlObi74ee18zB8xAdfPXXznGDynRKQPgsil34gMWkxKAi7EP4ZafP/Qw6unz2F4q04oUroEBFnahUPQqEGo2rAuJnUdgEd37kEQZHBzL4C+v4/LGEKW7uXTGMwePPq9wyWPbt2NjbMWAqKIKg3rotvYHwAAI9p8i+7jhqN4Re/3ZlIIMlS0KwA3C9v3Pk6kK4lqFU6+umc0+xwCgBwCajl7wkZu/vEn50I8p0RE78fCjcjA8SKGKHOiKGL/i5vQGtHnQwYBTVxKZGvlxNyE55SI6P3Y1ycycNZyMyO6fEkjArCWmUkdg3IBQRBgqzCuGwS2CnNe4H8AzykR0fuxcCMycLyIIfowJzNrqSNki7OR5ZUCzykR0btYuBEZAV7EEGXOzdwW8uysHy8hOQS4mXPu58fwnBIRvYuFG5ER4EUMUeZczKyhkBnHrzOFTI48vLHxUTynRETvMo6fikS5HC9iiDInCAI8rZwhM/CbGzII8LRy4jDiLOA5JSJ6l3FcCRLlcryIIfowd0tHqSNkibHkNATG8m9lLDmJyPixcCMyEsZycWAsOcm0mMnkKGTpYLA3N2QQ4G7pADOZXOooRoPnlIjobSzciIwEL2KIPqy0rZvBfv+ZyeQoZesmdQyjw3NKRPR/LNyIjAgvYogyJxdkqGRfwOBubsggoJJ9AcgF/srNLp5TIqL/408cIiPCixiiD3M2szaozrQMAgpZOnCLjM/Ac0pElIZXWURGhhcxRB9W2tYN9goLyT8jMgiwV1igNDvRn43nlIiIhRuRUeJFDFHm5IIMvo4esJGbS/YZkUGAjdwcvo4e7ETrAM8pEREgiKIoSh2CiLJPLWoR9uoBEjUqaKH/j3H6RcwXToWh4EUMGSC1qEVEXBTeqFP0+hlJv6Hh6+jBz4aO8ZxSZkRRRJImFYkaFTTQQiuKkAkC5JDBRm4Oa7kZt6oho8fCjciI8SKG6MM0ohbXEmLwUPlaL5+R9KHDpW3d2JXJITynBKQVai9SkxCjSsCr1CQkqFUQkLbvqSiKgABA/P/fRQC2CnM4mVnDzdwWLmbWLOTI6LBwIzJyvIgh+rjY1CREvnmMVK0mRz4nMggwk8lRyb4A53vqCc9p7pSq1SBaGYd7ybFQa7XQfMK5l0OAQiaDp5Uz3C0dDXa1ZqL/YuFGZCJ4EUP0YRpRi+sJMYhWvgYAnXxO0udbuVs6oBRvZugdz2nu8e+blIBuzzVvRpKxYOFGZEJy6iJGpUrBmT1H8EOHrnCws//sYxJJiXfsTQ/PqWmLVSUhMp43JolYuBGZIF1fxAzr0htbN21GoUKFsHfvXnh7e+dAaiL9Sp8j81yVgNj/zJHRarUQZAIgChAEvDVHxvmfOTJ5OEfG4KSf0xXbNsCjbAk45HX917wn/GveE8+pMeBUAKK3KaQOQES6ZyaTw8s6DzytnDO9MM3ORYyVuQUA4OHDh6hWrRrmzp2LLl26SPc/SKQDgiDA1dwGruY2AP5ZlU6bimdxsQjq0QXde/ZAk8aN01alU5jDWsZV6QydIAg4vG0XhnfojjJlyuDKlStI0qYiUf2elQZ5Tg2aFItvaSHiofI13qiVXHyLDBI7bkS5SPqFaXYvYgIDAxESEgIAsLS0RPXq1XHkyBF9xyfSi4EDB2L27NkoXrw4bty4wQt7I3Lx4kXUqFEDSUlJsLS0REJCAuRyDnk0Ntzuhuj9+N1IlIsIQtovIzcLW+S3sEdBSwfkt7CHm4UtbOTmH7xAlclksLe3R9euXXH48GE9pibSn6ioKCxevBhAWof51KlTEieirHr58iUaNWqEpKQkAICZmRkuXrwocSrKLs0/nTapijYgrfOWqFEhIi4KGlErSQai92HhRkQf1b9/f+zfvx+HDx9GSkoK2KgnUzVs2DCoVCoAQHJyMsaOHStxIsqquLg4eHh4QKFQQKFQIDk5mSMDjNC1hBi97036PlqIeKNOwbWEGElzEP0bh0oSUbYkJyfDyspK6hhEOSIwMBAXL17E33//jQIFCsDR0RFXr16VOhZlQ/fu3eHi4gIPDw9UrVoVvr6+UkeiLIpVJSHidbTkRdu/ySDA19Gdq02SQWDhRkRE9C+iKEIul0OtVkMm48AUY+Pt7Y2VK1eicuXKUkehbNCIWhyNvYsUrVrqKO+wkCng5+zFlSZJcvwOJKLPolKpcOHCBcTExGDv3r1SxyH6bCkpKTAzM2PRZoTi4uJw//59lC9fXuoolE3XEmKQqtVIHeO9UrUaXOeQSTIA3A6AiD7Lvn37MHLkSFSsWBHnzp1Dvnz5UKlSJaljEX0ypVIJS0tLqWPQJwgPD0flypVhZmYmdRTKhlStRm97tX0KLUREK1+jhI0rN2YnSfF2IhFlW0pKCs6cOYNffvkFO3fuxOPHj1G9enVs3boVUVFRUscj+iycx2m8wsLCUKNGDaljUDZFK+OkjpAlxpKTTBc7bkSUbfv27cPixYtRtmxZNGnSBIULF4ZGo0GpUqXg5eUldTyiz8KOm/EKCwtD3759pY5B2SCKIu4lxxpsty2dFmk5Pa2cubcjSYaFGxFlW+3atRETEwO5XI6XL1+ievXqKFGiBO7evYtixYpBq9VyfhAZLXbcjJNWq0V4eDhWr14tdRTKhhepSVBrjWOvNLVWi5epSXAxt5E6CuVSvLIiomxzdnZGyZIl4eDggO7du6Nhw4bYs2cPZs+eDQAs2sioseNmnK5duwYXFxe4ublJHYWyIUaVAI2Bd9vSaSAiRpUgdQzKxXh1RUSfpFKlSkhOTsbcuXMRERGBY8eOoV+/fnjz5g2AtLvfRMaIHTfjFBYWhi+++ELqGJRNr1KTpI6QLbFGlpdMC4dKEtEnsbOzQ548eZCSkoJx48YhJSUF48ePh6urK2bOnMmuGxktpVLJws0IsXAzPqIoIkGtytJznz96gun9RiDu+UsIAtC0c3u0/u5bAMDaqcHYv2YT7PM4AwCCRg1C1YZ1cyRzgloFURQ5z40kwcKNiD5Zs2bNEBYWhmPHjmHVqlUAgIcPH2Y8zl9uZIySk5M5VNIIhYaGon///lLHoGxI0qQiq78h5Ao5eowfjmLlyyIpIREDG7ZDpbo14FGyGACgda8gtOvbLefC/kMAkKRNhY3cPMffi+i/WLgR0We5ceMGunTpgsePH2PKlCmQy+UoWrQo+vXrx6KNjBI7bsYnNjYWjx49gre3t9RRKBsSNaq03xPix+e4Oed1g3PetPmL1rY2cC9RFC+fPMso3PRFEAQkqlUs3EgSHMtERJ8lICAAxYsXxw8//IC//voLnTp1wu3bt7FgwQIAnOtGxocdN+MTHh6OKlWqQKHg/WhjooEWYhaKtv96FvUIdy9fQ8nKFTK+tmvZWvSt2xozB45CfNzr976uX722n5w1nSim5SaSAgs3IvosFhYWOHv2LPz9/TFjxgxs27YNDRs2zBgyybluZGzYcTM+nN9mnLSiiCyPlfxHckIiJnUbgJ4TR8DazhYA4N+lA5ZEHMCcI9vglNcVS3+e+t7XBh/Z9rmRAeGf3EQS4BUVEX22UqVKISQkBA0aNMChQ4ewadMmBAUFSR2L6JOw42Z8WLgZJ5kgIDs7AahTU/Frt4Go164larZonPF1JzcXyOVyyGQyNO30NW5GXsqBtP8Q/8lNJAGOKSCiz1a6dGm4ubnh7Nmz2L9/Py5duoSIiAikpqaiTJkyUscjyhZ23IyLRqNBREQEqlevLnUUyiY5ZFme4yaKImYNGg33El5o+32Xtx6LfRaTMf8tdM9BFC5VPCfiAgAEIS03kRT4nUdEOjF79mxUq1YNwcHBGD16NG7duoWRI0ciJCQEAHDnzh2JExJlDTtuxuXq1avImzcvXFxcpI5C2WQjN8/yHLe/w8/j8KYduHgiHP3qtUW/em1x5tAxAMCy8dPQp24r9K3bGpdORaDnxBHvPUZmc9xWT5mN0/sOZymHKIqwUXBhEpIGO25EpBN2dnZ49OgRnj59igMHDsDCwgJ3797F0KFDceDAAURFRWH79u2wtbWVOirRByUnJ8PBwUHqGJRFYWFhqFGjhtQx6BNYy82yPFKybPXK2B1z7b2P/TDv/XPa/iuzOW6dRwzIYoq0kZ3WMrMsP59Il9hxIyKdefPmDS5evAgLCwuEhoaia9euePr0KVq1aoW//vqLRRsZBaVSyY6bEeH8NuMlCAJsjax7Zasw51Y3JBl23IhIZ0qXLo2aNWuiYMGCKFiwIPr27fvWIiVarZarTJLBS05O5hw3IxIWFoYhQ4ZIHYM+kZOZNd6oU6SOkWXOZtZSR6BcjIUbEenU999/Dx8fH3z99dcZX0sv2Fi0kTFgx814vHz5Ek+fPkXZsmWljkKfyM3cFg+T46DJzvKSEpFDgJs5R46QdFi4EZFOeXh4wMPDA0BawSYIAgs2MirsuBmP06dPo2rVqpDL5VJHoU/kYmYNhUwGjVYjdZSPUsjkyMOOG0mIV1NElCNEUcSNGzdw5MgRqaMQZQs7bsYjNDSU89uMnCAI8LRyhiy7O3HrmQwCPK2cOL+NJMXCjYhyhCAIePDgAfr37w+tVit1HKIsY8fNeHBFSdPgbukodYQsMZacZLpYuBFRjmnSpAlsbW2xefNmqaMQZRk7bsZBrVbj7Nmz3HjbBJjJ5Chk6WCwXTcZBLhbOsBMxiG5JC0WbkSUYwRBwM8//4wJEyaw60ZGgx0343DlyhUULFgQTk5OUkchHSht62awhZGZTI5Stm5SxyBi4UZEOatZs2awsrLC1q1bM32OKIpIVKsQk5KAJylv8Ej5Gk9S3iAmJQGJahVE0fBXGyPTwY6bceD+baZFLshQyb6AwXXdZBBQyb4A5AIvmUl6XFWSiHJUetftp59+wpdffgmZTAZRFPEiNQkxqgS8Sk1CgloF4Z/niqIICADE//9dRNqmp05m1nAzt4WLmTUniFOOYcfNOISFhaF27dpSxyAdcjazRiFLBzxUvobWALYHkEFAIUsH7t1GBoO3D4goxzVv3hzm5uY4fPwo7ia9xOHY2zj/+iEeJL/CG3UKtBChgQi1qIUGIjTi23/XQsQbdQoeJL/C+dcPcTj2Nu4mvUSqESwfTcaHHTfjwBUlTVNpWzfYKywk77zJIMBeYYHSHCJJBkQQOQaJiHKYRtTi/IsHeIkUAIJO7qSm/1IvZOmA0rZuHMZCOuPs7Ixbt24hT548UkehTMTExKBEiRKIjY3lPpEmSC1qEfbqARI1Kkk6bzIIsJGb4wunwlDwdwsZEH43ElGOilUl4WjsXbyEClpAZ7+Etf904h4qX+No7F3Epibp5LhE7LgZvtOnT6NatWos2kyUQpDhC6fCknTe0jttLNrIEPE7kohyhEbU4kr8U0S8jkaKVp1jd021EJGiVSMiLhpX4p9CI3L1Svp0oihCqVRyjpuB48Ikpk8hyFDN0QOFLOz1Vrylz2mr5ujBoo0MEr8riUjn1KIW4XFRep1gnt59C4+LgprFG30ilUoFMzMzdnIMHAs30xcXF4e+3/dBRWd3+Njkh4VMkWMFnAwCLGQK+Dq6w9suH4fek8HiHDci0inOTSBjFhcXh8KFC+P169dSR6FMpKamwtnZGdHR0XB0dJQ6DulYYmIiZsyYgSlTpiApKQnm5uZQKpXQiFpcT4hBtDLts6nLudLulg4oxbnSZAS4HQAR6YxG1CIiLkqyog1I+2WeqFEhIi4K1Rw9+IuYsoXDJA3fpUuX4OHhwaLNRDVp0gSnT5+GRpO2anDp0qUBpO3zVtYuH0rYuCJaGYd7ybFQa9NWHs4uOQQoZDJ4WjnD3dLRYDf+JvovFm5EpDPXEmIylveXUvr2AdcSYuBtl0/SLGRckpOTuTCJgQsLC0ONGjWkjkE5ZOnSpWjUqBGio6MBAD4+Pm89biaTw8s6DzytnPEiNQnPVQmIfWc/UPxrP1C8tR+o8z/7gebhfqBkhFi4EZFOxKqSDGbTVOD/c94KWNpz81TKMnbcDF9YWBgaNGggdQzKIW5uafumNW/eHLt370alSpXe+zxBEOBqbgNXcxsAacVZkjYViWoVNNBCK4qQCQLkkMFGYQ5rmRkLNTJ6HENERJ9NI2oRGf/YYIq2dFqIiHzzmCtNUpax42b4uDCJ6RJFET179kTbtm2xa9cuhIWFITAwMEuvFYS0+c1uFrbIb2GPgpYOyG9hDzcLW9jIzVm0kUlgx42IPtu1hBikajVSx3ivVK0G1xNiUJZDJikL2HEzbM+ePUNcXBxKliwpdRTKAUuWLMHt27exZs0aAED16tUlTkRkWFi4EdFnSdVqDGqI5H9pISJa+RolbFw5AZ0+ih03wxYWFsaNt03UtWvX8NNPP+H48eP8DBJlgj/5iOizRCvjpI6QJcaSk6SVnJzMjpsBCw0N5TBJE6RUKhEQEIBff/01YxVJInoXCzci+mSiKOJecqzBdtvSaZGWk9tW0scolUre7TdgnN9mmkaMGIFixYqhR48eUkchMmgcKklEn+xFahLUWuNY+EOt1eJlahJc/lmBjOh92HEzXCqVCpGRkahWrZrUUUiH9uzZg23btuHChQtcQIToI9hxI6JPFqNK+KTNT6WggYgYVYLUMcjAseNmuC5evAgvLy/Y29tLHYV05MmTJ+jevTvWrFkDJycnqeMQGTwWbkT0ya7fu40RbYPQu1YLfF+7BbYvWpXx2NJxv6NXDX/0rdsavwT1Q8LrN9k6dtfKDfD65at3vj7UPyBbx7l0KgLjOvYGAMSmJmXrtZT7sONmuDhM0rRotVoEBQXhu+++Q+3ataWOQ2QUWLgR0ScRRREpghY9xg/HgpO7MH3vBuxatg5RN24DACrVrYF5x3dg7rHtKFC0CDbOWqST952+J+STX5ugVnGeG30QO26Gi4Wbafnjjz+QlJSEMWPGSB2FyGiwcCOiT5KkSUWevG4oVr4sAMDa1gbuJYri5ZNnAACfejUhV6RNoy1VuQJePn72Se+TkqzE2A7fYd/qjQCAdkUqA0jrpI1o8y1+7TYQvWr44/fewzKKsrOHT6BXDX8MaPAlQncfzDiWACBJm/pJOSh3YMfNcLFwMx3nzp3D1KlTsXbtWigUXG6BKKtYuBHRJ0nUqN6aSP4s6hHuXr6GkpUrvPPcgyFbUbnB+4fC9KvXNtP3UCYmYXyn71G3rT+adm7/zuN3Ll/Dd7+MxPyTu/D0QTT+Dj8PlTIFc4aMxdg18zDr0Ba8inmR8XxBEJCoVmXnf5NyGXbcDNPjx48RHx+PEiVKSB2FPlNCQgICAgIQHByMwoULSx2HyKiwcCOiT6KBNqPDlZyQiEndBqDnxBGwtrN963nrZyyAXC5Hva9avvc4wUe2ZfoeE7/ti0YBX6LBN23e+3iJSuXgUiAfZDIZvLxL4Vn0I0Tfuou8HgVR0KsIBEF4631FMS03UWbYcTNM6d02rjpo/Pr374/atWujfft3b8YR0YexcCOiT6IVRUAA1Kmp+LXbQNRr1xI1WzR+6zkH12/DmQNH8cP83z/pgqu0byWcO3wi03lpZhbmGX+WyeXQaDQfPqDwT26iTLDjZpg4TNI0rF+/HqGhoZg9e7bUUYiMEgs3IvokMkGAqBUxa9BouJfwQtvvu7z1+NnDJ7AleCnGrp4HS+tP62B0+nEAbB0dMO/HCVl+jXtxL8REP8aTe1EAgGPbdv//QTEtN1Fm2HEzTCzcjN+9e/cwYMAAhISEwMaG+2kSfQoWbkT0SeSQ4e+I8zi8aQcunghHv3pt0a9eW5w5dAwAsGDEL0hOSMSor7ujX722CP5h3HuP86E5bgDQa9JPUClTsGz871nKZW5pgX7Tx2Ncx94Y0OBLOLrkyXhMENJyE2WGHTfDo1KpcOHCBfj6+kodhT5RamoqAgMDMWLECPj4+Egdh8hoCSLXxiaiT5CoVuHkq3tGswE3AMghoJazJ2zk5h9/MuVKrVq1Qvfu3dG6dWupo9A/wsPD0atXL1y4cEHqKPSJRo8ejbNnz2LPnj2QyXjzjOhTcQ1WIvok1nIzIyrZ0ogArGVmUscgA6ZUKjlU0sCEhoZymKQRO3r0KJYtW4bIyEgWbUSfiZ8gIvokgiDAVmFcnStbhTlXpaMPSk5O5lBJAxMWFoYaNWpIHYM+wcuXL9G5c2csW7YMefPmlToOkdFj4UZEn8zJzFrqCNnibGR5Sf/YcTM8XJjEOImiiB49euDrr79G06ZNpY5DZBI4VJKIPpmbuS0eJscZxTw3OQS4mdt+/ImUq7HjZlgePnwIpVKJokWLSh2FsmnhwoV48OAB1q9fL3UUIpPBwo2IPpmLmTUUMhk02o/sn2YAFDI58rDjRh/Bjpth4cbbxunq1asYM2YMTp48CQsLC6njEJkMDpUkok8mCAI8rZwhg2FfVMkgwNPKiRd/9FHsuBkWDpM0PkqlEgEBAZgyZQpKliwpdRwik8LCjYg+i7ulo9QRssRYcpK02HEzLFxR0vgMGzYMpUqVQrdu3aSOQmRyOFSSiD6LmUyOQpYOeKh8Da0BznWTQYC7pQPMZHKpo5ARYMfNcCiVSly+fBlVq1aVOgpl0c6dO7Fz505cuHCBIxyIcgA7bkT02UrbuhlsYWQmk6OUrZvUMcgIiKIIpVLJws1AnD9/HqVKlYKNjY3UUSgLHj9+jJ49e2Lt2rVwdHSUOg6RSWLhRkSfTS7IUMm+gMHNdZNBQCX7ApAL/FFHH6dSqaBQKCCXG+ZNiNyG89uMh1arxbfffos+ffqgZs2aUschMlm8miEinXA2s0YhSweDKd5kEFDI0oF7t1GWJScnc36bAWHhZjx+//13qFQqjBo1SuooRCaNhRsR6UxpWzfYKywkL95kEGCvsEBpDpGkbOAwScMhiiILNyMRERGBP/74A2vWrGG3miiHsXAjIp2RCzL4OnrARm4uWfGmVWsAZSp8HT04RJKyhR03wxEVFQW1Wg1PT0+po9AHxMfHIzAwEPPmzYOHh4fUcYhMHq9qiEinFIIMXzgVlqTzJoOA+3/fRNvS1VC2VGnMnTsXcXFxes1AxosdN8MRFhaGGjVqcGVCA9e3b1/Ur18f7dq1kzoKUa7Awo2IdE4hyFDN0UOvc97S57RZ3H8JdYoKN2/exPDhw+Hm5oZTp07pJQMZN3bcDAeHSRq+tWvX4syZM5gxY4bUUYhyDRZuRJQj5IIM3nb54OvoDguZIscKOBkEWMgU8HV0h7ddPvg3bZYxzyIlJQW1a9eGj49Pjrw3mRZ23AwHCzfDdvfuXQwePBjr16/ndg1EesTCjYhylLOZNfycveD+T/dNVwVc+rHcLR3g5+yVsXpkwYIFUaBAAZibm8PR0RHe3t68GKcsYcfNMCQnJ+Pq1auoUqWK1FHoPVJTUxEQEIBRo0ahQoUKUschylVYuBFRjpMLMpS1y4cGeYqhhI0LLGRyyD+xgJNDgIVMjhI2LmiQpxjK2uV7ZxGS/v37o2/fvrhx4waOHDmCyZMn6+J/g0wcO26G4dy5cyhTpgyLaAP1888/w8XFBQMGDJA6ClGuo5A6ABHlHmYyObys88DTyhkvUpPwXJWA2NQkJKhVEAAIggBRBCAAEAFBSFsWXARgqzCHs5k13MxtkcfM+oOLFgwePDjjz/v27UOtWrWQJ08e9OrVK6f/F8mIseNmGEJDQzlM0kAdPnwYK1euRGRkJBeOIZIACzci0jtBEOBqbgNX87S5EaIoIkmbikS1ChpooRVFyAQBcshgozCHtczsky8SChQogAMHDqBOnTrIkycPvvrqK13+r5AJYcfNMISFhaF9+/ZSx6D/ePHiBYKCgrB8+XK4uXGPTCIpsHAjIskJggAbuTls5OY5cvxixYphz549aNy4MRwdHdGwYcMceR8ybuy4SS994+2ZM2dKHYX+RRRFdO/eHR06dEDjxo2ljkOUa3GOGxHlChUrVsTmzZsREBCAM2fOSB2HDBA7btK7f/8+ZDIZN3M2MPPmzcOjR48wadIkqaMQ5WrsuJHBE0URSZpUJGreM4xObg5r+acPo6PcpU6dOli6dClatmyJo0ePolSpUlJHIgPCjpv00rcB4M90w3H58mWMGzcOoaGhMDfPmVERRJQ1LNzI4IiiiBepSYhRJeDVOwtXiP9auEJ4a+EKp38WrnD5yMIVlLu1atUKsbGxaNKkCU6ePAl3d3epI5GBUCqVLNwkxv3bDEtycjICAgLw+++/o3jx4lLHIcr1WLiRwUjVahCtjMO95FiotVpoIL79BPGfv4v/+TuAN+oUvFGn4GFyHBQyGTytnOFu6QgzmVw/4cmodOnSBS9fvkTjxo1x4sQJuLi4SB2JDEBycjLs7OykjpGrhYaGokOHDlLHoH8MHToU5cqVQ1BQkNRRiAgs3MgAaEQtriXE4KHyNQBA+9+CLTvHggiNVoObiS9wM/EFClk6oLSt2zv7fBENHToUz58/h7+/P/766y9esBOUSiVXy5NQYmIirl+/jsqVK0sdhQD8+eef2Lt3Ly5cuMBRLEQGglezJKlYVRKOxt7FQ+VraCF+VtH2b+nHeqh8jaOxdxGbmqST45JpmTx5MsqXL48vv/wSKSkpUschiSUnJ3NxEgmdPXsW5cqV4zkwAA8fPkSvXr2wbt06ODg4SB2HiP7Bwo0koRG1uBL/FBGvo5GiVeusYPsvLUSkaNWIiIvGlfin0IjaHHkfMk6CIGDBggWws7ND586dodFopI5EEuIcN2lxfpth0Gg06Ny5M/r378/zQWRgWLiR3qlFLcLjojK6bPqQ3n0Lj4uCmsUb/YtCocC6devw4sUL9O3bN20BHMqV2HGTFgs3w/Dbb79BFEWMHDlS6ihE9B8s3Eiv1KIWYa8e4I06RW9FWzotRLxRpyDs1QMWb/QWS0tL/Pnnnzhz5gzGjh0rdRySCDtu0knfeJuFm7ROnz6NWbNmYfXq1ZDLubgXkaFh4UZ6oxG1iIiLQqJGpfeiLZ0WIhI1KkTERXHYJL3F3t4ee/fuxcaNGzFr1iyp45AE2HGTzt27d2Fubs7tOST0+vVrBAYGYsGCBTwPRAaKq0qS3lxLiJGk0/Zf6Z23awkx8LbLJ2kWMixubm44cOAAatWqhTx58qBTp05SRyI94gbc0gkNDWW3TUKiKKJPnz5o0qQJ2rZtK3UcIsoECzfSi1hVkl7ntH1M+py3Apb2cDazljoOGZDChQtj3759qF+/PpycnNC8eXOpI5GeKJVKdtwkEhYWhho1akgdI9davXo1Lly4gDNnzkgdhYg+gEMlKcdpRC0i4x8bTNGWTgsRkW8ec8gkvaNs2bLYvn07unTpglOnTkkdh/SEHTfpcH6bdG7fvo2hQ4di/fr1sLbmjUwiQ8bCjXLctYQYpGoNc5n1VK0G1xNipI5BBqh69epYs2YNvvzyS1y+fFnqOKQH7LhJIyEhATdv3kSlSpWkjpLrqFQqBAQE4Oeff0a5cuWkjkNEH8HCjXJUqlZjUEMk/0sLEdHK1wZbWJK0mjRpglmzZqFZs2a4e/eu1HEoh7HjJo0zZ86gQoUKsLCwkDpKrjNmzBjkz58fffv2lToKEWUB57hRjopWxkkdIUuilXHwss4jdQwyQB06dEBsbCwaN26MkydPIl8+LmhjqthxkwaHSUrj0KFDWLt2LS5cuABBEKSOQ0RZwI4b5RhRFHEvOdZgu23ptEjLyY2XKTN9+vRB586d0bRpU8TFxUkdh3IIO27S4IqS+vf8+XMEBQVh5cqVcHFxkToOEWWRIPJqlXLIc1Uizr9+CI2BF24AIIeAyg6F4GJuI3UUMlCiKGLAgAG4ePEi9u/fzwt8EyOKIuRyOVJTU7nxsB6JoghXV1dcunQJBQoUkDpOriCKIlq2bAlvb29MmTJF6jhElA3suFGOiVElGEXRBgAaiIhRJUgdgwyYIAiYNWsWChUqhA4dOkCtVksdiXRIpVJBoVCwaNOzW7duwcbGhkWbHgUHByMmJgYTJ06UOgoRZRMLN8oxr1KTpI6QLbFGlpf0TyaTYcWKFUhJSUGPHj2g1XIrCVPB+W3S4Pw2/bp06RImTJiAkJAQmJmZSR2HiLKJhRt9ULdu3eDm5gZvb++3vj5mzBiUL18eFStWROPGjfH48eO3HhdFEQlqlT6jftCfC1dCmZSc8fd2RSq/85wEtQrz58/HqlWr9BmNjIy5uTm2bNmCGzduYPjw4ZwbaSI4v00aLNz0JykpCR06dMAff/yBokWLSh2HiD4BCzf6oC5dumDfvn3vfH3YsGG4dOkSLly4gBYtWmDChAlvPZ6kSYW+16jSaDJf0n/7olVISVZ+8PUCgG+/645vv/1Wx8nI1NjY2GD37t3Yt28fpk6dKnUc0gF23KTBwk1/hgwZAh8fH3Tu3FnqKET0iVi40QfVqVMHzs7O73zd3t4+48+JiYnvLCWcqFF9cHnh80dOYWizDhjQ4Ev82n0QkhMScfbwCfzafVDGcy6disC4jr0zfT4AdK3cAMsmTMOABl9i0+zFGNDgy4zXP7p7HwMafIkdi1cj9ulzjPwyCCPaBmU8vvLXmejn1wZDmn2DVzEvIAgCxv08DtOmTQMA+Pn54ccff4Svry9KlCiBEydOAEi7a9m+fXuUKVMGbdu2RbVq1XD27Nms/pOSiXB2dsb+/fuxYMECLFmyROo49JnYcdO/N2/e4Pbt26hYsaLUUUze1q1bcfDgQcybN0/qKET0GVi40ScbNWoU3N3dsXbt2nc6bhpo8eLJU/wc8N07r3v98hXWz5iPSZuXYfZfW1G8QllsW7AClep8gZvnL0GZmDbX7MSfe1CnjX+mz09n7+SI2X9tRYfBvWFtb4c7l68BAA6FbEPDgC/RqmdnOOdzxeStKzFl20oAgDIpCaUqV0Dw0T/hXb0K9q/ZBFHEO1sXqNVqREREYObMmRg/fjwAYN68eXBycsLff/+NiRMn4ty5czr7NyXjUrBgQezfvx9jxozB1q1bpY5Dn4EdN/2LiIhApUqVYG5uLnUUkxYdHY3vv/8e69ate+umKxEZHxZu9MkmTZqE6OhodOzYEcHBwW89phVF5MmfF+NDFr3zuhvnLiD65h380KIj+tVri782bkfMw8eQKxTwqV8L4QeOQKNW48yh46jerEGmz09Xp02zjD836fgVDq3fBo1Gg+N/7oXfl83fm11hbgbfxn4AgGIVyuJZ9CNAAMT/FG5ffpnWwatcuTLu378PADh58iQ6dOgAAPD29kb58uWz9w9HJqVEiRLYvXs3evfujSNHjkgdhz4RO276FxYWhho1akgdw6RpNBp06tQJgwYNQrVq1aSOQ0SfSSF1ADJ+HTt2hL+/f0ZHCgBkgoDMdgIQRaBi3Rr4ceH0dx6r28YfO5euhZ2jI4pVKAtrW5sPPh8ALKytM/5cs0VjrJs2F+VrVUOxCmVh7+z03tcoFGYZQzllcjk0ag0gAsJ/ZuZZWFgAAORyOZd/p0z5+Phg48aNaN++Pfbu3YvKld9d/IYMm1KpZOGmZ2FhYejZs6fUMUzar7/+CrlcjuHDh0sdhYh0gB03+iS3bt3K+PP27dtRqlSptx6XQ5bpHLdSlSvgWkQkHt99AABQJibh0Z17AADvGlVx5/Lf2LdmE+q29f/o8//L3NICPvVqYd7w8WgU0Dbj61a2Nhnz4jIjCIAsC0uq1KxZExs3bgQA/P3337h8+fJHX0Omz8/PD4sWLUKLFi1w8+ZNqeNQNiUnJ3OopB5ptVqcPn2aC5PkoNDQUMydOxerV6/m/oREJoKFG31QQEAAvvjiC9y4cQOFChXC0qVLAQAjRozIGCZ44MABzJo1663X2cjNM53j5uDijMGzf8XU3j+gb93WGOofgOhbaYWYXC6HbyM/nPvrBKo28vvo89+nXrsWEGQyVPKrmfG1pp3bY2yHnm8tTvJfoijCTPbxX259+vTB8+fPUaZMGYwePRply5aFg4PDR19Hpq9Nmzb45Zdf0LhxYzx8+FDqOJQN7Ljp182bN+Hg4IB8+fJJHcUkxcXFoWPHjli4cCEKFiwodRwi0hFB5CZElANEUcT+FzffWexDH7bMXYak+Hh0HjEwW6+TQUATlxIfXA0TSJszkJqaCktLS9y5cwcNGzbEjRs3OMGeMkydOhUrV67E8ePHkSdPHqnjUBasWbMGe/fuxdq1a6WOkissW7YMhw4dwrp166SOYnJEUURAQADy5MmDuXPnSh2HiHSIc9woRwiCAFuFOd6oU/T6vr8E9cOT+9H4deuKbL/WVmH+0aINSNsOoF69ekhNTYUoipg3bx6LNnrL8OHD8fz5czRv3hyHDh2Cra2t1JHoI9hx06+7d+9ymGQOWbFiBa5evYqIiAipoxCRjrHjRjnmasIzPEh+JXWMLCti5YQytnmljkEmQhRFdO/eHY8ePcLOnTtZ3Bu4OXPm4MaNG++skEs5IykpCRYWFpx7pWM3b95EzZo1ceTIEXh7e0sdh4h0jHPcKMe4mdtCnoXFPgyBHALczNkVId0RBAGLFi2ClZUVgoKCoNVqpY5EH8COm35ZW1uzaNOxlJQUBAQEYMKECSzaiEwUCzfKMS5m1lDIjONbTCGTI4+Z9cefSJQNCoUCISEhePz4MQYMGAAOcDBcXFWSjN2oUaPg4eGB3r17Sx2FiHKIcVxVk1ESBAGeVs5ZWmJfSjII8LRyytL8NqLssrKywo4dO3Dq1Km39jokw8INuMmY7d+/Hxs2bMCSJUv4u4zIhLFwoxzlbukodYQsMZacZJwcHBywb98+rF27lnOoDJRSqWTHLYfFx8cjJiYGCQkJ7D7rUExMDLp27YpVq1ZxFVsiE8fCjXKUmUyOQpYOBtt1k0GAu6VDlvZvI/ocefPmxYEDBzBlyhSEhIRIHYf+gx23nDdlyhR0794dfn5+UKvVOHDgADQajdSxjJpWq0WXLl3QtWtX1KtXT+o4RJTDWLhRjitt62awhZGZTI5Stm5Sx6BcwtPTE/v27cOgQYOwb98+qePQv7DjljPSO2unT5/G1atXsXXrVuTNmxdKpRK//vorFyj5TLNnz0ZsbCzGjRsndRQi0gPu40Y5Ti7IUMm+ACLioiXZkDszmtRUTB/0Ew4XLw1vb2+UKlUKpUqV4l13ylHe3t7Ytm0bWrdujR07dnAvKwPBjlvOSJ9vpdFoUKVKFWzduhW1a9fGvXv3UKhQIYnTGbfIyEj8+uuvOH36NMzMzKSOQ0R6wMKN9MLZzBqFLB3wUPnaIIo3GQQon7zC3k3bsBfbYGNjg9TUVNSvXx979+6VOh6ZuBo1amDlypVo06YNDh8+jLJly0odKddjxy3niKKImjVr4uzZs/jpp59gaWkJtVqNzp07Sx3NaCUmJiIgIAAzZ86El5eX1HGISE+4ATfpjUbUIjwuCm/UKZIWbzIIsFdYwNfBHTWqf4EzZ84AAMzNzXHy5ElUrVpVsmyUu6xduxYjRozAiRMnUKRIEanj5GqNGzfG0KFD0aRJE6mjmKRDhw6hYcOGAIBr167By8sLFhYWEqcyXj179oRKpcLKlSuljkJEesQ5bqQ3ckEGX0cP2MjNJVusRAYBNnJz+Dp6QCGTIzg4GFZWVrC0tISVlRVWrFiBpKQkSbJR7tOxY0cMGzYMjRs3RkxMjNRxcjV23HLO06dP8dtvvwEApk6dismTJ2PHjh0SpzJemzdvxtGjR7lCLVEuxMKN9EohyPCFU2HYKyz0Xryld9q+cCoMhZD2re/r64s6derA29sbd+/eRVxcHKpUqYILFy7oNRvlXgMGDECHDh3QtGlTvHnzRuo4uRbnuOle+oCeK1euwMnJCWFhYXjz5g2++uorbN26VeJ0xikqKgp9+vTBunXrYGdnJ3UcItIzFm6kdwpBhmqOHnrdJkAGAYUsHVDN0SOjaEu3detWHDt2DM7Ozli7di1GjRqFxo0b448//oBWq9VLPsrdxo8fj2rVqqF169ZQKpVSx8mV2HHTvfSFSSwtLeHk5ISdO3eie/fuePXqFVxcXCROZ3zUajU6duyIH374gUP6iXIpznEjScWmJiHyzWOkajU5Mu9NBgFmMjkq2ReAs5l1ll937949dOrUCTY2NlixYgUKFCig82xE/6bRaBAYGAiVSoVNmzZBoeDaUfpUrFgx7N27F8WLF5c6iskQRRGCIOCPP/5AUFBQxubQ+/btQ/78+VGhQgWJExqX8ePH4+TJk9i/fz9kMt53J8MjiiKSNKlI1KiggRZaUYRMECCHDDZyc1jLzTJu6NCnYeFGktOIWlxPiEG08jUA6KSAS+/kuVs6oJStG+RC9n/JqdVqTJo0CfPnz8fChQvRunXrz85F9CEqlQotWrSAh4cHFi9ezF9welSoUCGEhYXB3d1d6igmRavVombNmvj111/h6+sLGxsbqSMZpZMnT+Lrr7/G+fPnkT9/fqnjEAFIK9RepCYhRpWAV6lJSFCrICCt2y6KIiAAEP//dxGArcIcTmbWcDO3hYuZNX/PZRMLNzIYqVoNopVxuJccC7VWC80nFHByCFDIZPC0coa7paNONv4ODQ1Fp06d0LhxY0yfPp0XHpSjEhIS0KBBA9SrVw9TpkyROk6ukSdPHty4cYND+HQsLi4O06ZNw4MHD+Dl5QWFQoGSJUuiffv2UkczGq9evULFihUxd+5ctGjRQuo4RAZ7vZYbsHAjg5N+B+e5KgGx79zBwb/u4OCtOzjO/9zByZMDd3DevHmDfv36ISIiAuvWrYOPj49Oj0/0by9fvkTt2rXRrVs3/PDDD1LHyRVsbGzw7Nkz2NraSh3FpDx//hxPnz6FTCbDmzdv8PjxYzg4OGRsDUAfJooi2rdvj/z582P27NlSx6FcTiNqcS0hBg9zYIRUIUsHlP7EEVK5CQs3MniiKCJJm4pE9XvGTCvMYS3T35jpkJAQDBw4EMOGDcPQoUM5z4ByzMOHD1GrVi2MGzcOXbp0kTqOSRNFEXK5HKmpqZDLeddXF9Lnt61fvx5RUVHw8vJCnjx5YGNjg2LFisHZ2VnqiEZhyZIlmDNnDsLDw7l4DkkqVpWEyHjDW5Mgt2HhRpRNDx48QKdOnWBubo5Vq1ahYMGCUkciE3Xjxg34+flhwYIFnGOZg1QqFWxtbaFSqaSOYnKio6Nx/fp1PHjwAMePH0dSUhLmzZsHNzc3qaMZvOvXr6N27do4duwYypQpI3UcyqX+3WXLiYLtv9JXAWf37f34L0KUTYULF8bRo0dRr149+Pj4YNu2bVJHIhNVsmRJ7Ny5Ez179sSxY8ekjmOykpOT2c3IASkpKXj48CG8vb3RvXt3LFmyBBqNhkVbFqSkpCAgIAC//PILizaSjFrUIjwuSm9FG5A2/PKh8jXC46KgFrkl03+x40b0GcLDw9GxY0fUq1cPM2bM4PwYyhF//fUXAgICsH//flSqVEnqOCbn2bNnKF++PJ49eyZ1FJNy584drFq1Cnnz5oVWq8WVK1fw9OlT/Pnnn1JHM3iDBw9GVFQUNm/ezFX3SBJqUYuwVw+QqFHprWj7NxkE2MjN8YVT4Xf2383N+C9B9BmqVauGyMhIqNVq+Pj44OzZs1JHIhPUoEEDzJ8/H82bN8etW7ekjmNy2HHLGUWLFkWrVq1gYWEBBwcHdOvWDXPmzJE6lsHbu3cvtmzZwi1BSDIaUYuIuCjJijYgrfOWqFEhIi4KGnbeMnCHV6LPZGdnh+XLl2Pjxo3w9/fHkCFDMGzYMC5yQDrVrl07xMbGokmTJjh58iQ3hdchpVIJKysrqWOYjPSFSebOnYvXr1/DwsIC5ubmKFmyJBwcHDIep3c9ffoU3bp1w/r167mAC0nmWkIM3qhTJCva0mkh4o06BdcSYuBtl0/SLIaCHTciHWnfvj3Onj2LvXv3omHDhoiOjpY6EpmYnj17omfPnmjSpAlevXoldRyTwY6bbgmCALVajZCQELRs2RItW7aEQqHAwIEDoVQqWbRlQqvVIigoCD179kTdunWljkO5VKwqSa9z2j4mfc5bbGqS1FEMAgs3Ih3y8PDA4cOH0aRJE1SpUgWbNm2SOhKZmBEjRqBRo0Zo0aIFkpL4i0wX2HHTvbt378Lc3Bw2Njbw8vKCv78/Hj16xAL5A2bMmIGEhASMHTtW6iiUS2lELSLjHxtM0ZZOCxGRbx5zyCS4OAlRjjlz5gw6duyIWrVqYdasWbCzs5M6EpkIrVaLrl274vnz59i+fTvMzMykjmTUDh8+jIkTJ+LIkSNSRzEpBw4cQEREBBwcHBAZGYmCBQti4sSJUscySOfOnUOzZs0QERGBIkWKSB2Hcqkr8U8Nqtv2bzIIcLd0QNlcPmSSHTeiHFK1alWcP38eMpkMPj4+iIiIkDoSmQiZTIYlS5ZALpeja9eu0Gp5F/JzJCcns+OmI+n3gkNDQ1GmTBn4+fnB3d0d48ePx4QJEyROZ5gSEhIQGBiIOXPmsGgjyaRqNQZbtAFpXbdo5WukajVSR5EUCzeiHGRra4slS5ZgypQpaNmyJSZNmgSNJnf/0CHdMDMzw8aNGxEVFYXBgweDgyc+nVKp5BA+HUmfvzZ58mTY29ujVq1aaNOmDc6cOcOhvZkYMGAAatasiW+++UbqKJSLRSvjpI6QJcaSM6ewcCPSg3bt2uHcuXP466+/UK9ePURFRUkdiUyAlZUVduzYgWPHjmHSpElSxzFa7Ljp1pMnT/D8+XPY29sDANRqNebOnQsbGxuJkxmeDRs24NSpU5g9e7bUUSgXE0UR95JjDbbblk6LtJy5+UYlCzciPSlUqBAOHjyIFi1aoEqVKtiwYYPUkcgEODo6Yt++fVi+fDnmz58vdRyjxI6bbrm4uKBly5b4/vvvsW7dOqxduzajiKP/i46ORv/+/RESEgJbW1up41Au9iI1CWojGXKv1mrxMhevMMnCjUiP5HI5hg8fjr1792Ls2LEICgrCmzdvpI5FRi5fvnw4ePAgfvnlF2zcuFHqOEaHHTfdUigU6N+/P2rXro2IiAjExcVh4cKFUscyKKIowsnJCQsXLoSPj4/UcSiXi1ElQGPg3bZ0GoiIUSVIHUMyLNyIJFC5cmWcP38elpaWqFSpEk6fPi11JDJyXl5e2Lt3L/r374+DBw9KHceosOOmG+nDl7p37w6VSoVWrVrhm2++QUBAANzc3CROZ1gEQYCtrS3atGkjdRQivMpiB2vmwFEILFMTfeq0fOvrU3oORr96bdGvXlt0rdwA/eq1zdb7XzoVgXEde2f5+bl5TzcWbkQSsbGxwcKFCzFt2jS0adMGEyZMgFqtljoWGbHy5ctjy5Yt6NixI8LDw6WOYzTYcdMNQRCgUqlw//59uLi4YPDgwVi7di2+/fZbJCcnSx1PMumrvr5vbjM3IyepiaKIBLUqS89t2KENJqxf9M7XRyyegeAj2xB8ZBtqNm+MGs0b6jrmWxLUqlw7z42FG5HE2rZti/Pnz+P48ePw8/PD/fv3pY5ERqxWrVpYvnw5WrdujWvXrkkdxyiw46Y7jx49QkpKCoYPH44iRYpgzpw5SExMzLWF8dWrV3Ho0CGsW7eOw0XJICVpUpHV2wfeX1SFnaNjpo+LoogTO/ah7pfNdZItMwKAJG1qjr6HoWLhRmQAChQogAMHDqBt27bw9fXF2rVrpY5ERqx58+b4/fff0aRJE65gmgXsuH2+yMhIvH79Gp6entiyZQuCgoIwatQohIeH5+o5XIUKFcKuXbvQpUsXVKhQIePr3HuRDEWiRqWzzu/V02fh6JoHBb2KvPfx7A6hzIwgCEjMYpfQ1CikDkBEaWQyGYYOHYoGDRogICAAe/fuxdy5c+Hg4CB1NDJCnTt3xsuXL9G4cWOcOHECrq6uUkcyWOy4fb7jx49DFEUcO3Yso1i7ffs2XF1dMX78eKnjScbBwQGjRo1CsWLFcOLECZibm6NJkyZYunQpvvnmG34uSXIaaHU27PDY1t2o2zbzblvwkW06eR9RTMudG7HjRmRgKlasiHPnzsHe3h4VK1bEqVOnpI5ERmrQoEFo164d/P39ER8fL3Ucg8WO2+cTBAHHjh2Ds7MzGjVqBJVKhRMnTmD69OlITEyUOp7epV8Ijx49GjNmzMCAAQPQtWtX7N69G0OGDMH9+/dZtJFB0IoisjxW8gM0ajVCdx9CnTbNsv3a8jV9MW7tgqy/QPgndy7EjhuRAbK2tsa8efOwY8cOtGvXDr1798bo0aOhUPAjS9nzyy+/4MWLF2jTpg327NkDCwsLqSMZHHbcPo9Go0GTJk1w9epVLF26FIULF0b58uUhiiJatmyJggULSh1R7wRBwN27d3HmzBns3bsXAODj44OZM2ciLi4O+fPnB5A2ZFIm4z10ko5MEKCLnQAij4ehUHFPuBTI9/kH+xjxn9y5EH9aEBmwVq1aITIyEmFhYahTpw7u3r0rdSQyMoIgYN68eXB2dkbHjh2h0WikjmRw2HH7PHK5HCVLloSlpSVKlCiBefPmZSxzf+XKFWnDScjMzAzOzs4IDQ0FACQmJuLnn3+Gs7NzRrHGoo2kJocsy3Pcfus1FEP9O+Dh7fv4toIf9q/dnPHY8W17PjhMEsh8jtutC1ew4KdJWc4sCGm5cyPevicycPnz58fevXsxe/ZsVKtWDX/88Qc6derEZaQpy+RyOdasWYPmzZujT58+WLBgAb9//oUdN91ISkrCs2fPEBoaisKFC0OlUuXa4YCvX7+Gs7MzunbtisjISBw9ehQ3btyAl5cXbxKQQbGRm2d5jtuPC6dn+tiQOZM/+vrM5rgVr+iN4hW9s5QBSBuKbKMwz/LzTQkLNyIjIJPJMGjQINSvXx8BAQHYs2cP5s+fD8cPLMtL9G8WFhbYtm0b6tevj9GjR2PSpKzf3TR17LjpxldffQUXFxf89ddfGXu6+fv7Sx1Lb9KHPa5cuRIrVqxA48aNoVAoULlyZcTFxcHNzQ3fffcdgLQLT948IUNgLTfTxUhJvRIBWMvMpI4hCRZuREakfPnyOHv2LIYPH46KFSti9erVqF27ttSxyEjY2dlh7969GDVqFFJTU2Fmljt/8f2XUqlk4aYjfn5+qFmzJpKSknLdirgymQxRUVHYtGkTFi1ahKSkJJw6dQonTpxAjx49Mub6cV4bGRJBEGCrMMcbdYrUUbLMVmGea2988CcHkZGxsrLCnDlzMHfuXLRv3x5jxoxBamru3IiSss/FxQXz58//YNGW2+bBJScnc6ikjmi1WiiVylxXtKWLiorCrVu3cPbsWVSoUAHt2rVDvnz58OrVq4znsGgjQ+NkZi11hGxxNrK8usSfHkRGqnnz5rhw4QLOnTuHWrVq4fbt21JHIiPx3wtHjUaDFy9e4OjRowDS5sTlJuy46c78+fMxf/58qWNIIjw8HI6Ojti0aRMiIiIwbtw4WFhYoFevXvD2zvr8HSJ9czO3hVwXewLogRwC3MxtpY4hGRZuREYsb9682L17Nzp16oQvvvgCK1as0NlGmpQ7pKSkYO7cuZg9ezamT5+OIUOGAEhbAe/p06cSp9MPdtx05+TJk3Bzc5M6ht4lJSUhLCwMBw8exKtXrzB8+HDY29vjt99+kzoa0VuCgoLg4eGBcuXKoVatWqhatSrm/PIbFEbSCVbI5MjDjhsRGStBENC/f38cOXIE06dPxzfffPPWsByiDwkNDYVGo0G3bt2wc+dOXL9+HQcOHMCRI0fwxx9/4PHjx1JHzHHsuOlOWFgYvvjiC6lj6FVKSgoSEhLQvXt3FClSBCdOnMDx48fx9ddfY/To0QDAG2pkMLy8vPD06VNcuXIFp06dwtmzZ2FnZwdPK2fIDLzrJoMATyunXDu/DWDhRmQyvL29cebMGeTPnx8VKlTAsWPHpI5ERmD37t3Ily8fihQpgoiICDRv3hwpKSk4dOgQWrdujQIFCkgdMcex46YbT548QXx8PEqUKCF1FL06deoUJk6ciNu3b6Nt27YoXrw4tm/fjlevXsHGxgYAcvWFJhkGURRx7NgxnDt3LmNevJWVFSZNmoRhw4bB3dJR2oBZZCw5cwpXlSQyIZaWlpg1axaaNm2KgIAAdOnSBePGjYO5ee7c74Q+rnLlylixYgXu3bsHV1dXxMTEYMuWLZDL5fD19UXNmjWljpij0i9mrK1z79AbXQkLC0P16tVzRZGSvpz/ihUrcPv2bTg5OeG3335D27Zt8eDBAxQpUgTly5eXOiYREhMTsWbNGgQHB0Oj0aBfv34AgD179uCrr77CyJEjAQBmMjkKWTrgofI1tAa4QYAMAtwtHWAmy11zsP+LhRuRCWrWrBkuXLiA7t27o2bNmli7dm2uuwtOWRMQEAAzMzO8evUK8fHxiI2Nxdy5c2FnZ4fAwEA0atQIrq6uiI6Oho2NDZydnaWOrFOCIKBKlSpSxzAJoaGhuWKYZHrRdvXqVWzcuBH9+vVDfHw87t69i8jISFy/fh2rV68GwKX/STq3bt3CvHnzsGrVKtStWxezZs1CvXr1IAgCatWqBQcHByxduvStGy2lbd3wTJWAFK1awuTvZyaTo5Rt7ps/+1/8aUJkotzc3LBjxw507doVNWvWxNKlSznPgt6S/v3w1VdfoXr16tiwYQO6dOmC0qVL4/nz52jRogVcXV1x/fp1/PTTT9ixY4fEicmQ5Zb5bekXumvWrIGFhQX8/f3xzTffoF69emjevDm2bNkCOzs7aDQaFm2kV1qtFrt370azZs1Qs2ZNWFlZITIyElu3bkX9+vUzvnfLly+P1atXv7MtjFyQoZJ9AYOb6yaDgEr2BSAX+HkSRF7JEZm8q1evIjAwEMWLF8eiRYtMrmtCujFhwgTcuHEDLVq0wMmTJ1GrVi2UK1cO06dPR6NGjRAYGCh1RDJQKpUKTk5OePr0Kezs7KSOk+O0Wi0iIiIQEhICR0dHdOzYEdOmTYOXlxdGjBghdTzKZWJjY7F8+XLMmzcPzs7O6N+/P9q3b//Jc3evxD81mCGTMggoZOkAb7t8UkcxCCzciHKJlJQUjBw5Eps2bcLKlStRv359qSORgfj3cK4pU6agXLlysLKygqurK2bNmoUWLVqgXr16SE5ORr58/OVJ7woPD0evXr1w4cIFqaPo1ZMnT7B161Zs27YNTk5O2LRpE4D/D6ckykkXL15EcHAwNm/ejJYtW6Jfv37w9fX97ONqRC3C46LwRp0iafEmgwB7hQWqOXqw2/YPFm5EucyBAwfQtWtXdOzYEb/88gsXLiEAaZtw/3vj7d27d2PLli346quv4O/vjxMnTkAul6NGjRoAjH/ujlarxdOnT3H9+nUULFgQxYsXh1Kp5CIln2jmzJm4ceNGrtl8WxRFpKamwtzcHCkpKTh+/DhCQ0NhZ2eHHj16wN7eXuqIZKJSU1OxdetWBAcH4/79+/j+++/Ro0cPne+fqBa1CHv1AIkalSTFmwwCbOTm+MKpMBQs2jKwcCPKhZ4/f44ePXrg4cOHWLt2LUqVKiV1JDIwY8eORfPmzVGtWrWMr2m1Wpw+fRqVK1eGhYWFURdvR48exYYNGxAeHo7vv/8eLi4uuHz5MsaOHSt1NKP0zTffoHnz5vj222+ljqIXS5cuhZeXF/z8/CAIArRaLa5evYorV64gICBA6nhkgp48eYJFixZh4cKFKFWqFPr164dWrVpBoci5dQbVohYREnTe0jttvo4eLNr+g/8aRLmQq6sr/vzzT3z33XeoXbs2Fi1axIVLCMD/FyyZMGECbGxssHfvXgBAXFwc9uzZg9GjR6Nfv34QRREymcxov29OnTqFOnXqYMyYMTA3N4dKpYKFhYXUsYxWbllREgCuXLmCESNGoGDBghnDIWUyGcqVK4dvvvlG4nRkSkRRxKlTpxAQEICyZcvi2bNnOHjwIA4fPowvv/wyR4s2AFAIMlRz9EAhSwe9LViSPqetGou292LHjSiXu3btGgIDA1GkSBEsXrwYLi4uUkciA/Hy5UukpKTAxsYGx44dw4kTJ9CsWTMcP34cDx48wPLly6WO+MmWLVsGpVKJp0+fwtnZGWZmZlAoFOjVq5fU0YzOw4cPUalSJcTExJj8vK7k5GRUrVoVQ4cORdeuXaWOQyYqKSkJISEhCA4ORmJiIvr164egoCA4ODhIlik2NQmRbx4jVavJke6bDALMZHJUsi8AZzMOWc8MS1miXK506dI4ffo0ihUrhooVK+LgwYNSRyIDIIoi8uTJgwIFCmDfvn3466+/0KlTJ9SvXx958+ZFrVq13nq+VquVKGn2iaKIbt26wdbWFmFhYdixYwdcXFzw3XffSR3NKKVvA2DqRRsA/PDDD/D29kaXLl2kjkIm6O7duxg2bBgKFy6M7du347fffsP169cxYMAASYs2AHA2s4afsxfc/+m+6aoDl34sd0sH+Dl7sWj7CHbciCjDoUOH0KVLF3zzzTf49ddfOXSMAABRUVFQKpUoWLAgtm/fjtjYWFSpUgVxcXF4+fIlOnbsCMC4FiyJiYmBi4sLZDIZbt68CUEQULx4caljGaUhQ4bA1dUVI0eOlDpKjtq+fTsGDRqEyMhIODo6Sh2HTIRWq8XBgwcRHByM06dPo2vXrvj+++/h6ekpdbRMpWo1iFbG4V5yLNRaLTSf0IGTQ4BCJoOnlTPcLR1hJpN//EXEwo2I3vby5Uv07NkT9+7dw7p161C6dGmpI5EBUKvVWLZsGZKSklC2bFnIZDLMnDkTr1+/RqtWrfDDDz9IHTFbunXrhoCAAKSmpmLHjh24du0axo4diwYNGkgdzeh88cUXmDx5Mvz8/KSOkmMePXqEypUrY+vWrRkrqxJ9jtevX2PFihWYO3cubGxs0L9/f3To0MGoVrYVRREvUpPwXJWA2NQkJKhVEJC2Sb0oAhAAiIAgpD1XBGCrMIezmTXczG2Rx8w6V3TqdSlnZzUSGSFRFJGkSUWiRgUNtNCKImSCADlksJGbw1puZtI/aPLkyYMtW7Zg6dKlqFOnDiZMmIDevXub9P8zfZxCoUCDBg1w584dJCcnY//+/ejTpw8aNWqEunXrwt/fH6VLlzaa7xNra2ukpKTg0qVL+PHHHzFv3jwkJiZKHcvopP8bVq1aVeooOUaj0aBz587o27cvizb6bFeuXMHcuXOxYcMGNG3aFCtWrDDaocaCIMDV3Aau5jYA/rl+0qYiUf2e6yeFOaxlpn39pA8s3CjXS79jFKNKwKt37hiJ/7pjJLx1x8jpnztGLiZ4x0gQBPTo0QO1a9dGx44dsXfvXixduhSurq5SRyMJOTg4IDk5GStXrkTbtm3RrFkzPHr0CI0bN0apUqWMamXGmjVrYt68eahfvz48PT2RlJQEW1tbqWMZnfPnz6NkyZKwsbGROkqOmTp1KjQaDX766Sepo5CRUqvV2L59O4KDg3Hz5k306tULV69eRf78+aWOplOCkLb3mo2c+8PmFA6VpFyLY7SzRqVSYezYsVi9ejWWLVuGJk2aSB2JJKBSqbBx40ZcuXIF5ubmuHr1KgIDA3HmzBnky5cPbdu2xbhx4xAUFAQ/Pz+IomjwNzTUajVUKhU0Gg3UajXs7e3f2oScPm769Om4e/cu5s6dK3WUHBEeHo5WrVrh7NmzcHd3lzoOGZmYmBgsXrwYCxYsgKenJ/r164e2bdvCzMxM6mhkpFi4Ua6jEbW4lhCDh8rXAKCTZW3TV1cqZOmA0rZukJvg3iNHjhxBUFAQ2rVrh8mTJ8PS0lLqSKRnV69ehSAIKFOmDH7//XcUKlQIVlZWqFixIsaNG4fU1FSkpKRg0KBB76w6aWjOnDmDtWvXIjw8HNbW1oiJicGmTZu4GX02ffXVV2jTpg06deokdRSde/PmDSpVqoTff/8dX375pdRxyEiIooiIiAgEBwdj165daN++Pfr27Yvy5ctLHY1MAAs3ylViVUmIjOc+JJ8qNjYWvXr1ws2bN7Fu3TqULVtW6kgksXPnzmH58uXw8fFBt27dMH36dDx79gxjx46Fra0tNBqNQXaxatWqhYULF2LixIkYOXIkDhw4gICAABQqVEjqaEZDFEUUKlQIJ06cgJeXl9RxdK5Tp06wsbHBwoULpY5CRkCpVGLDhg0IDg7Gq1ev0LdvX3Tp0gVOTk5SRyMTYnptAaL30IhaXIl/iojX0UjRqnOkaAPSuncpWjUi4qJxJf4pNKLx7G2VFc7Ozti4cSMGDRoEPz8/BAcHg/d+crdjx46hWrVq6NatGy5evIhr165BLpejW7duuHfvnkEWbQDg7u6eMfTNwcEBp06dQkpKisSpjEt0dDTUarVBL1v+qVavXo3z589jxowZUkchA/fgwQOMHDkSHh4e2LBhA8aPH4+bN29i8ODBLNpI51i4kclTi1qEx0XhofJ1jhVs/6WFiIfK1wiPi4LaxIo3QRDQtWtXhIaGYtWqVWjRogWePXsmdSySyJAhQ9C5c2ecPHkSO3bsQO3atTF58mQ4OztjzZo1AGCQxb2Pjw+USiV69uyJjh07QqFQcPGdbDLVjbdv376NIUOGYP369Ua1NDvpjyiKOHToENq0aQMfHx+kpKQgNDQUe/bsgb+/v9HsZ0nGh99ZZNLUohZhrx7gjTpFb0VbOi1EvFGnIOzVA5Mr3gCgePHiOHXqFCpWrIhKlSphz549UkciiYiiiHPnzsHDwwNBQUE4deoUihQpgvbt2wNAxoW9Vms4n4NDhw7BwsICDRo0wKlTp5Camgq1Wi11LKOSXriZEpVKhcDAQIwdO5Zzkugdb968QXBwMMqUKYMhQ4bA398fUVFR+OOPP1CsWDGp41EuwMKNTJZG1CIiLgqJGpXei7Z0WohI1KgQERdlcsMmAcDMzAyTJk1CSEgIvv/+ewwYMADJyclSxyI9EwQB33//PYKCgrB3716cP38e+fPnR1xcHFauXInJkycDAGQymcEUbxqNBvHx8dBoNACA+Ph4mJtzCevsCA0NNbnCbezYscibNy/69esndRQyINeuXUO/fv1QpEgRnDhxAgsXLsTFixfx3XffmfRWGGR4WLiRybqWECNJp+2/0jtv1xJiJM2Rk+rWrYsLFy7g2bNn8PX1xeXLl6WORHpmbm6OpKQkXLt2Da6urihYsCDOnDmD6OhoPH/+HN27dwcAgxlCVLduXcyYMQNbt27F6NGjUbx4ca6Umg3Jycm4cuUKqlSpInUUnfnrr7+wZs0aLFu2zOSGf1L2qdVq/Pnnn2jYsCHq16+PPHny4PLly9iwYQPq1KnD7xGSBFeVJJMUq0pCxOtoyYu2f5NBgK+ju0muNplOFEWsWrUKP/zwA0aPHo3+/fsbzIU66Ud8fDzs7OwwadIkFCpUCEFBQXj48CGmTp2K2bNnZ+zvZgj7vEVERODq1asoUqQI6tWrJ2kWY3Py5EkMHjwYZ86ckTqKTjx//hyVKlXCihUr0LBhQ6njkIRevHiBJUuWYP78+ShUqBD69euHdu3asSNPBoFXVGRyNKIWkfGPDapoA9I6b5FvHpvkkMl0giAgKCgIp0+fRkhICPz9/fH06VOpY5Ee2dnZ4eXLlwgLC4OPjw9UKhWOHz+esYLjkydPAKR9r6hUKimjwtfXF127dmXR9glMaX6bKIro1q0bOnbsyKItFzt79iy6dOmC4sWL49atW9i2bRtOnTqFgIAAFm1kMFi4kcm5lhCDVK1G6hjvlarV4LoJD5lMV7RoUZw4cQK+vr6oVKkSdu3aJXUk0qM8efKgR48e6NGjByZPnozQ0FC4urpi/vz56N69O+bNmwe1Wo29e/fiwYMHkmYNDw/HmzdvJM1gjEypcAsODsbTp08xceJEqaOQnqWkpGDNmjWoXr06vv76a5QtWxa3b9/G0qVL4ePjI3U8ondwqCSZlFStBn+9vG1w3bZ/k0FAgzzFYCYzzP2tdO3kyZPo3Lkz/P398fvvv3N57Vzkxo0bKFy4MG7fvo1Tp07B0tISDRs2xODBg1GtWjU8e/YM7dq1Q7Vq1STLWL58eaxZs4YrCGaDKIooUKAAwsLCUKRIEanjfJZLly6hQYMGCAsL46qAucjDhw+xYMECLFmyBBUqVEC/fv3g7+9vsPtOEqVjx41MSrQyTuoIWWIsOXWhVq1aiIyMxKtXr1ClShVcvHhR6kiUw9LvB5YoUQKWlpY4efIkHj9+jKCgICgUCjg7OyMuLg6dO3eWtGgD0hbZ4KIk2XP//n0AQOHChaUN8pmSkpLQoUMHTJ8+nUVbLiCKIo4ePYqvvvoKFSpUQHx8PI4dO4b9+/ejZcuWLNrIKCikDkCkK6Io4l5yrEF324C0uW73kmPhaeUs+eIM+uLo6Ih169ZhzZo1aNiwIUaOHIlBgwZx4RITlf59nf5fjUaD+/fv4/jx47h48SIKFCiAzp07w9PTU8qYANIKNysrK6ljGBVT2Xh7yJAhqFSpEjp37ix1FMpBCQkJWLNmDYKDgyGKIvr164fly5fDzs5O6mhE2carJjIZL1KToDaQPaI+Rq3V4mVqktQx9K5Tp06IiIjA5s2b0bRpUzx+/FjqSKQHffv2ReXKlREcHIykpCR07drVIIo2AFAqley4ZVNYWBhq1KghdYzPsnXrVhw8eBDz5883+gKU3u/mzZsYNGgQChcujIMHD2LOnDm4cuUKvv/+exZtZLRYuJHJiFElQGPg3bZ0GoiIUSVIHUMSnp6eOH78OGrWrAkfHx9s375d6kiUg9I33B4wYAA6d+6Mbt26wd3dHVqtFoYwxZodt+wz9oVJoqOj8f3332Pt2rWwt7eXOg7pkEajwa5du9C0aVPUrl0bNjY2iIyMxJYtW1CvXj0W6WT0WLiRyXj1gQ7W9kWr0KdOS3xfuwX+XLgyW8d9FvUIzd1KY9XkmRlfe/3yFVoVKIf5I9JWIbsSdgYDGnyJlvm9cXLn/iwdNzYXdtzSKRQK/Pzzz9i6dSsGDx6M3r17Iykp9/57mDKZTJZRvLVs2RKurq7QarWIj4/HH3/8IWk2URTZccum9E3WK1euLHWUT6LRaNC5c2cMHDgQ1atXlzoO6UhsbCymTZuG4sWLY+LEiejYsSMePHiASZMmwcPDQ+p4RDrDwo1MgiiKSFC/f0+o+9duYv+aTfhj30YEH/kTEQeO4vHd7C1BntejEM4cPJ7x95M79sGj5P8ns7sWLIDBsyfD78vmWT5mglplEB0HKdWoUQMXLlxAUlISKleujPPnz0sdiXLAf+cyymQyiKKI5cuXY+rUqRKlAlJTUyGTyaBQcLp3Vp09exbe3t5GW+xOnjwZgiDgxx9/lDoK6UBkZCR69OiBokWL4vLly1i/fj3Cw8PRuXNno/0eJfoQFm5kEpI0qchsAET0rbso4VMeltZWkCsUKFejKkJ3H8zW8S2tLeFewgu3LlwBAJzYvhe1WzfNeDyvR0F4li0JIRuLbQgAkrSp2cphiuzt7bFq1SqMHTsWTZs2xe+//57RoSHT5ejoiP3792P+/PlYunSpJBnYbcs+Yx4mGRYWhjlz5mDNmjVcQdCIqVQqrF+/HrVq1ULr1q1RtGhR3Lx5EytXroSvr6/U8YhyFAs3MgmJGlWmY9cLlyqOq6fP4U3sKyiTknH20HE8f/z0need3ncYq6fMzvQ96rTxx7Fte/D80RPI5HI453P7rMyCICAxky5hbhQQEICIiAjs2LEDjRo1wqNHj6SORDmsYMGC2L9/P8aMGYNt27bp/f05vy37QkNDjbJwe/36NQIDA7Fo0SIULFhQ6jj0CR4/foxx48ahSJEiWLx4MYYOHYq7d+9i5MiRcHV1lToekV6wcCOToEHmCx14lCiKr/r3wOj2PTC2Q094eZeCXP7ut371pvXRecSATN+jcv1auHAsFMe37UHt1s0+O7MopuWm/ytSpAiOHDmCevXqwcfHR5KLedKvEiVKYNeuXejVqxeOHj2q1/dmxy17RFE0yo6bKIro3bs3mjVrhtatW0sdh7JBFEWcPHkSHTp0gLe3N54/f45Dhw7hr7/+Qtu2bTnMmXIdFm5kErSiiEzHSgJo0vErzD60BVN3rIGtowMKeBXJ9nuYmZujWIWy2Dp/BWq1bPzpYdMJ/+SmtygUCowePRo7duzAsGHD0LNnTyQmJkodi3KQj48PNm7ciPbt2+t1niM7btlz9+5dmJubw93dXeoo2bJy5UpcvnwZ06dPlzoKZVFSUhKWLFmCSpUqoXv37qhZsybu3buHuXPnokyZMlLHI5IMCzcyCTJBwId2Aoh7/hIAEPPwMUJ3H4Rfuxaf9D5tv++CrmOGws7J8ZNe/xbxn9z0XtWqVUNkZCRSU1Ph4+ODs2fPSh2JcpCfnx8WLVqEFi1a4ObNm3p5T6VSycItG4xx4+2bN29i2LBhWL9+Pc+1Ebhz5w5++OEHeHh4YOfOnfj9999x7do19O/fHw4ODlLHI5Ice8xkEuSQpV1MZNLB+rXbQLx5FQeFQoHvp4yBrcO7e/ec3ncYty5c+eBwycKliqNwqeLvfP1m5GX80qU/El6/QcSBI1g7dQ7mn9j1wcyCkJabMmdnZ4cVK1Zgw4YN8Pf3x5AhQzBs2DAuLGCi2rRpg5cvX6JJkyY4efJkjs9FSk5O5lDJbDC2YZIqlQqBgYEYP348vL29pY5DmdBqtThw4ACCg4MRHh6Obt264ezZsyhSpIjU0YgMjiDm9vXIySQkqlU4+eqe0WzADQByCKjl7AkbubnUUYxCVFQUOnfuDJlMhlWrVhndcC3KuqlTp2LlypU4ceIEnJ2dc+x9jhw5ggkTJuDIkSM59h6mxMfHB3PnzjWa4m3YsGG4desWtm3bZlRdwtwiLi4OK1aswNy5c2FnZ4f+/fujQ4cO7IwSfQBv95NJsJabGVHJlkYEYC0zkzqG0fDw8MDhw4fRuHFjVKlSBZs3b5Y6EuWQ4cOHw9/fH82bN8/R+Y3suGVdQkICbty4AR8fH6mjZMmBAwewfv16LFmyhEWbgbl8+TJ69+4NT09PnDlzBqtWrcK5c+fQtWtXFm1EH8HCjUyCIAiwVRhX58pWYc4LimySy+UYOXIkdu3ahZEjR6Jbt26Ij4+XOhblgKlTp6J06dJo164dVKqc2TaDc9yy7syZMyhfvjwsLCykjvJRMTEx6NKlC1atWgUXFxep4xDSNrvfvHkz/Pz80LRpUxQsWBDXrl3D2rVrjW7eJJGUWLiRyXAys5Y6QrY4G1leQ1K1alVERkZCEAT4+PggIiJC6kikY4IgYNGiRbC0tESXLl1yZFN2dtyyLiwsDDVq1JA6xkdptVp06dIFXbp0Qb169aSOk+s9ffoUEydOhKenJ+bMmYO+ffvi/v37GDNmDPLlyyd1PCKjw8KNTIabuS3kH9oTwIDIIcDN3FbqGEbN1tYWS5cuxeTJk9GyZUtMmjQJGo1G6likQwqFAiEhIXj06BEGDhyY6V6Nn4odt6wzloVJZs+ejdjYWIwfP17qKLlW+n5/HTt2ROnSpfHw4UPs2bMHx44dw9dffw0zM04RIPpULNzIZLiYWUMhM45vaYVMjjzsuOnEV199hbNnz+LQoUOoV68eoqKipI5EOmRlZYUdO3bg5MmTmDBhgk6PzY5b1oiiiNOnTxt84RYZGYlJkyZh3bp1LA4kkJycjOXLl6NKlSro3LkzqlSpgrt372LhwoUoX7681PGITIJxXOUSZYEgCPC0cobMwLtuMgjwtHLimH4dcnd3x6FDh9CiRQtUqVIFGzZsyPS5XEjX+Dg4OGDfvn1Ys2YN5s6dq7PjsuOWNbdv34aVlVWOb8/wORITExEQEICZM2fCy8tL6ji5yv379/Hjjz/Cw8MDW7ZswaRJk3Dz5k0MHjwYTk5OUscjMiks3MikuFs6Sh0hS4wlpzGRy+UYPnw49u7diz179iAlJeWtx9OHUQqCAFEUWcAZmbx58+LAgQOYPHkyQkJCdHJMdtyyJjQ01OC7bYMGDYKvry86duwodZRcQRRFHDx4EK1bt0aVKlWg0Whw+vRp7Nq1C02bNoXMSEa/EBkbbsBNJsVMJkchSwc8VL6G1gA3CJBBgLulA8xk3EA6p1SuXBkrVqx4p6N58uRJ7Ny5E0FBQShXrpxE6ehzeHp6Yt++fWjQoAGcnZ3RpEmTzzqeUqmEtTWHLH+Moc9v27x5M44cOYLIyEipo5i8N2/eYOXKlZg7dy4sLCzQv39/hISE8HNEpCe8JUImp7Stm8EWRnIIKGXrJnUMk/ffoi0qKgqbN2/Gq1ev8OOPP2LJkiUZj3FBE+Pi7e2Nbdu2oXPnzjh9+vRnHYsdt6wx5BUlo6Ki0KdPH4SEhMDOzk7qOCbr77//Rt++fVGkSBGcOnUKS5YswYULF9CjRw8WbUR6xMKNTI5ckKGSfQGDm+umSVVjYIsOsLW2QZkyZdC2bVvMmzdP6lgmLyEhAYcPH4a7uzuWLl2KDh064NKlSzhy5AgePnwIudwwi3zKXI0aNbBixQq0adMGV69e/eTjcI7bx8XHx+POnTuoWLGi1FHeoVar0bFjRwwdOhRVq1aVOo7JUavV2LZtGxo0aIAGDRrA1dUVV65cwfr161GrVi3O0yaSAAs3MknOZtYoZOlgMMWbDALcrRwRdfUmlEolrl27hh07dmDz5s1SRzN5oaGhOHv2LDp16oQbN27g0aNHuHTpEg4dOoRWrVrh5MmTGc/lvDfj4e/vj+nTp6Np06a4f//+Jx2DHbePi4iIQMWKFWFubi51lHdMmjQJFhYWGDZsmNRRTMrz588xefJkeHl5Yfr06ejZsycePHiAcePGoUCBAlLHI8rVWLiRySpt6wZ7hYXkxZsMAuwVFijnWAAzZ858a1jJ6NGjJUyWO/j6+qJbt25wdHTEoUOHUKxYMdSoUQMtW7bEwYMHERcXhxs3bkAURd5BNjIdO3bEsGHD0LhxY8TExGT79ey4fZyhzm87efIk5s+fj1WrVnEhDB05c+YMgoKCUKJECdy5cwfbt2/HyZMn0aFDB4Ms3IlyI/60I5MlF2TwdfSAjdxcsuJNBgE2cnP4OnpALsjQtWtXuLm5wczMDD169ED79u3xxx9/QKvVSpLP1ImiCEdHR/j4+OD+/ftQqVSQyWQYN24c1q1bB1tbWxQtWhSrVq3CgQMH3nktGb4BAwagQ4cOaNasGd68eZOt17Lj9nGGuKLkq1ev0KlTJyxevJgdoM+UkpKC1atXo1q1amjfvj3KlSuH27dvY8mSJahUqZLU8YjoPwSRVydk4tSiFhFxUXijTtHrSpPpnTZfRw8ohP/fIzl+/Di2bduGGTNm4M6dOwgKCoKZmRlWrFiBwoUL6y1fbnT37l107doVfn5+ePDgAb7++ms8ffoU8fHxGDRoEPbu3QsnJydUr14du3fvxtmzZzF69GjOgzNwoiiiT58+uHHjBvbs2ZPlYqxp06YYNGgQmjZtmsMJjZNWq4WLiwuuXr2K/PnzSx0HQNq5/uabb5A3b17MmTNH6jhGKzo6GgsWLMgo0Pr164dmzZrxZx2RgWPHjUyeQpChmqOHXue8ySCgkKUDqv2naAOAOnXqYMaMGQCAokWL4tixY2jatCmqVKmClStXstOTg7y8vLB//37kzZsXnTt3hqenJ65evYqOHTvi1q1buHz5Mh4+fIioqCj8+eefaNKkCeRyOVeeNHCCICA4OBiurq4IDAyEWq3O0uvYcfuwmzdvwt7e3mCKNgBYtmwZrl+/jt9//13qKAYpJSUFx44de+9joijiyJEjaNeuHSpWrIjExEScOHEC+/btQ4sWLVi0ERkBFm6UK8gFGbzt8sHX0R0WMkWOFXAyCLCQKeDr6A5vu3yQCx//iMnlcvz44484dOgQpk+fjnbt2uH58+c5ki+302g0sLS0RJ8+fdCgQQNs3boVSqUSNjY22LFjB1xdXVGnTh1MmzYNly5dwuvXrwEg44KGBZzhksvlWL16NRISEtC7d+8s3QBJTk7mHLcPMLRtAK5fv44RI0Zg/fr1LLj/I324vYWFBXbs2IG5c+dizpw5iIqKyniOUqnE8OHD0ahRIzx48AAzZ85EiRIlpIpMRJ+AhRvlKs5m1vBz9oL7P903XRVw6cdyt3SAn7MXnM2yv69NhQoVcObMGRQrVgwVKlTArl27dJKN/u+/d5S7du2K1NRUdOrUCW/evEGdOnUQGhqK27dvY9GiRZgwYULG3etXr15h2LBhUKlUUkSnLDA3N8fWrVtx+fJljBw58qPPVyqVLAA+wJAWJklJSUFAQAB++eUXlClTRuo4Bkcmk0Gr1eLly5coWLAgRo0aBXt7exQqVCjjOWZmZoiIiEDv3r1ha2srYVoi+lQKqQMQ6ZtckKGsXT6UsHFFtDIO95JjodZqofmE+W9yCFDIZPC0coa7peNnb/xtYWGBqVOnokWLFggKCsL27dvxxx9/cGPZHKDValGwYEEsXrwYhw4dgpmZGd68eYOpU6di4cKFKFeuHNq3bw8bGxsAad2ZCRMmcHU1A2dra4s9e/agdu3acHV1xdChQzN9LjtuHxYWFobvvvtO6hgAgJEjR8LLy8tg8kjp3yvgpnfaQkJCMH36dLRp0wa9evXCtWvX0LRp07dW3FQoeMlHZOzYcaNcy0wmh5d1HtR3LgYfh0IoYuWUsX2AHAIUggxyyCD/579pfxcyFh0pYuWEyg6FUN+5GLys83x20fZvderUwcWLF6HRaFCxYsW39hoj3Ui/Qw0ADRs2RI0aNbB7927Y2NigXLlyuHv3Lnbt2gVPT0+MGDECEydO5F1qI5EnTx7s378fs2fPxooVKzJ9HrcDyNzr169x7949VKhQQeoo2Lt3LzZv3ozFixdzyw4g49/g/PnzGT/H9u3bh5UrV2Ls2LHImzcvihcvjp07dwIARwkQmRDefqFcTxAEuJrbwNU8rbMiiiKStKlIVKuggRZaUYRMECCHDDYKc1jLzPRy8WBvb49ly5Zh+/bt+PrrrxEUFITx48fDwsIix987t/j33WgzMzOMGDECycnJqFmzJqpXr46hQ4fi/v37uHjxYsZFEBkHd3d37N+/H/Xq1YOzszNatWr1znO4OEnmwsPD4ePjAzMzM0lzPH36FN26dcP69evh7OwsaRZDsXPnTmzevBlXr17Ft99+i5o1a6JMmTJISEjIeE7Lli2xYMECBAYGomHDhujWrZuEiYlIV7gdAJERiImJwXfffYd79+5hzZo1KFeunNSRTI5Go8mYA3fu3DlUrlwZcXFxaNeuHSZNmoTq1atDq9Vys18jc/bsWfj7+2PTpk2oW7fuW4/Z2tri6dOn7KS+x/jx45GUlITffvtNsgxarRbNmjWDr68vJk6cKFkOKfx7OCQAJCUlITw8HJ6enpg2bRoUCgVmzpyJZcuW4fnz5/D09ERkZCTGjBmDFStWoE2bNkhJScG9e/dQv359Cf9PiEiXeAVCZATc3Nywbds2DBo0CPXr18fvv//OFQ517N/L/vv4+AAAhgwZAn9/f1SvXh2iKCI1NRUpKSlSxqRsqlKlCkJCQvD1118jMjIy4+uiKLLj9gGGsKLkjBkzEB8fj59//lnSHPqUPnw7vWi7d+8eLl68iPj4eBw/fhx37txBYGAgnj17BgAoW7YsUlJSUKFCBTg5OaFdu3aIiIiAXC6Hp6cnizYiE8OOG5GRuXfvHoKCggAAK1euhKenp8SJTM+8efMQFhYGKysrLFq0CEDahf6rV69QvXp1LF68+J3uDRm2LVu2oH///jh+/DiKFSuG1NRUWFtbIzU1VepoBker1SJPnjy4ceMG3NzcJMlw7tw5NGvWDBEREShSpIgkGaSSkJCAVatW4fr166hYsSIePHiA8ePHY9OmTXj16hVatGiBWbNmoVWrVqhUqRKmTp0KPz8/1KlTByqVijcjiEwYO25ERsbT0xNHjhxBq1at4Ovri2XLlnHTbh3r06cPRo8ejVmzZgH4/7AlZ2dnzJo1CwEBAfjpp5940W9E2rVrh/Hjx6Nx48Z4/Pgxu20fcP36dTg7O0tWtCUkJCAgIACzZ8/OdUXbhQsX0KZNGzx69AilSpXCo0eP8PDhQzx+/Bje3t64e/cunj17hipVqmDDhg2wtrZG37594efnB5lMBktLS2i12ozOHRGZFhZuREZILpfjhx9+wOHDhzF79my0bdsWMTExUscyKSVLlsxYcfDfc02aNWuGCxcu4NKlS6hRowZu3bolVUTKpp49e6Jnz55o0qQJnj59yhUlMyH1/m0DBgxAzZo10aFDB8kySMXV1RX29vZo3rw5+vTpAycnJ0RHR2PHjh2Ii4vDzZs3ce3aNTRu3BijR4/OeM2/yWQyzsUlMlH8ZBMZsXLlyiE8PBylSpVChQoVsH37dqkj5Qpubm7YuXMnunTpgho1amDp0qXsehqJESNGoFGjRggMDOSefJkIDQ2VrHDbsGEDTp48iTlz5kjy/lL498+OfPnyoW3btjh8+DCAtK0thgwZgv3792Pq1Kno3r07OnToAAcHB8k6okQkHc5xIzIRJ0+eRFBQEPz8/DBjxgzY29tLHSlXuHr1KgIDA1G8eHEsWrSIS5YbAa1Wiy+//BIHDx5EXFyc5EveG5oyZcpgzZo1GYv06Mv9+/fh6+uLvXv3onLlynp9bym8evUKy5cvx6NHjzBhwgTY2KRtSfP3339j8ODBqFChAvbv34/ly5ejWLFi/JlOROy4EZmKWrVq4cKFC5DJZKhQoQKOHz8udaRcoWzZsggPD4eHhwcqVKiQcaecDJdMJsOoUaMgl8vRtWtXzgf6l1evXiE6Ohrly5fX6/uq1WoEBgZi+PDhJl+0Xbp0Cd999x28vLxw/vx5tG/fHtbW1hmPe3l5oVmzZkhKSsKpU6fg4+OTUbTxe5Uod2PhRmRC7OzssHjxYsyePRsdOnTAsGHDuHy9HlhaWuKPP/7AkiVL0LlzZ/z4449QqVRSx6IP0Gg0KFWqFB48eIDBgwdzqOs/wsPDUaVKFSgUCr2+74QJE2BnZ4chQ4bo9X31JTU1FRs3bkSdOnXg7+8PDw8PXL9+HWvWrEG1atXemkdraWkJHx8fWFpavtMN5tw1otyNPwGITFDLli1x8eJF3LlzB1WrVsXFixeljpQrNGnSBBcuXMD169fxxRdf4MaNG1JHokwkJyfD2toaO3fuxNGjRzFp0iSpIxkEKRYmOX78OBYvXoyVK1eaXGHy9OlTTJgwAUWKFMH8+fMxcOBA3Lt3D6NHj0bevHkzfV2ZMmVQrVo1xMfH6zEtERk60/oJSUQZXF1dsWXLFgwdOhQNGzbEb7/9xk279cDV1RV//vknevbsiVq1amHRokXs5hggpVIJKysrODo6ZswjWrBggdSxJKfvwi02NhadOnXC0qVLkS9fPr29b04SRRGhoaEIDAxE6dKl8eTJE+zfvx9HjhxBu3btsjSn0sXFBV9//TVcXFz0kJiIjAUXJyHKBR48eIAuXbogNTUVq1atgpeXl9SRcoVr164hMDAQRYoUweLFi3kRZkC2bt2K1atXY9u2bQCAO3fuoE6dOpgxYwbat28vcTppaDQaODs74/bt2+8sMZ8TRFHEV199BXd3d8ycOTPH3y+nJScnIyQkBMHBwUhISEDfvn0RFBQER0dHqaMRkYlgx40oFyhcuDD++usvfPnll/D19cXixYvZBdKD0qVL4/Tp0yhatCgqVqyIQ4cOSR2J/pHecUtXtGhR7NmzB/3798fBgwclTCadv//+G25ubnop2gBg8eLFuHPnDn777Te9vF9OuXfvHoYPHw4PDw9s3boVkydPxvXr1zFw4EAWbUSkUyzciHIJmUyGIUOG4OjRo5g3bx5atWqFZ8+eSR3L5FlYWGDatGlYsWIFunTpgh9++IELxhiA5ORkWFpavvW1ChUqYPPmzQgMDER4eLhEyaSjz2GSf//9N0aNGoWQkBBYWFjo5T11SavV4sCBA2jVqhWqVq0KrVaL06dPY9euXWjSpInJzdUjIsPAnyxEuYy3tzfCw8NRvnx5VKhQIWOoGOWshg0bZiwYU716dVy7dk3qSLnafztu6WrXro3ly5ejdevWue4chYWFoUaNGjn+PkqlEh06dMCvv/6K0qVL5/j76dLr168xe/ZslC5dGsOHD0fr1q0RFRWFadOmoWjRolLHIyITx8KNKBcyNzfHpEmTsHXrVgwbNgxdunTB69evpY5l8vLkyYOtW7eiT58+qFOnDubPn88hqxJ5X8ctXYsWLfD777+jSZMmiIqK0nMy6eir4zZ8+HCULFkSPXr0yPH30pWrV6+iT58+8PT0RFhYGJYtW4bIyEh07979rT3YiIhyEgs3olysRo0auHDhAiwtLVGhQgUcPXpU6kgmTxAE9OzZEydPnsSSJUvQunVrPH/+XOpYuU5mHbd0nTt3xuDBg9G4ceNccX5iY2Px+PFjeHt75+j77Nq1C9u3b8eiRYve2rvMEKnVamzduhX169dHo0aNkDdvXly9ehUhISGoWbOmwecnItPDwo0ol7O1tcWCBQswb948dOzYEUOHDoVSqZQ6lskrWbIkwsLCUKZMGVSsWBEHDhyQOlKu8qGOW7rBgwejXbt28Pf3N/n9tE6fPo2qVatCLpfn2Hs8efIEPXr0wNq1a+Hk5JRj7/O5YmJi8Ouvv8LT0xMzZsxAr169cP/+ffz888/Inz+/1PGIKBdj4UZEAAB/f39cvHgRUVFRqFKlCiIjI6WOZPLMzc0xZcoUrFmzBt27d8fgwYNZNOvJxzpu6X755Rf4+PigTZs2Jr2oTGhoaI4Ok9Rqtfj222/Ru3dv1KpVK8fe53NERETg22+/RcmSJXHv3j3s3LkTJ06cwDfffANzc3Op4xERsXAjov9zcXHBxo0bMWLECDRp0gS//vor1Gq11LFMXr169XDx4kVER0ejWrVquHr1qtSRTF5WOm5A2tDWefPmwcnJCR07djTZTexzen7btGnTkJycjNGjR+fYe3wKpVKJVatWwdfXFx06dECFChVw584dLF68GBUrVpQ6HhHRW1i4EdFbBEFAp06dcO7cOfz111+oU6cObt++LXUsk+fs7IxNmzZh4MCB8PPzQ3BwMBcuyUFZ7bgBgFwux9q1axEXF4c+ffqY3HnRaDQ4c+YMqlevniPHP3PmDKZNm4a1a9dCoVDkyHtkV1RUFH766ScULlwYISEh+Pnnn3Hr1i0MHToUzs7OUscjInovFm5E9F7u7u44ePAgvvnmG3zxxRdYuHChyV2wGhpBENCtWzeEhoZi5cqVaNGiBWJiYqSOZZKSk5OzXLgBafvxbdu2DefPnze4rtHnunLlCgoUKIA8efLo/Njx8fEICAjA3LlzUbhwYZ0fPztEUcThw4fx5ZdfolKlSkhOTsbJkyexd+9eNG/ePEfn9xER6QILNyLKlEwmw8CBA3Hs2DEsWrQILVq0wJMnT6SOZfKKFy+O0NBQVKxYERUrVsTevXuljmRylEplloZK/pudnR327NmDLVu2YMaMGTmUTP9ycphkv3794Ofnh6+//jpHjp8V8fHxmDdvHsqWLYuBAweiSZMmePDgAWbMmIHixYtLlouIKLtYuBHRR5UpUwZhYWGoXLkyKlWqhM2bN0sdyeSZmZlh0qRJCAkJQe/evTFgwAAkJydLHctkZLfjls7V1RUHDhzAjBkzsGrVqhxIpn85VbitW7cO4eHhmDVrls6PnRXXr1/HgAEDULhwYRw5cgTz58/HpUuX0KtXL9ja2kqSiYjoc7BwI6IsMTc3x4QJE7B9+3b89NNP6Ny5M+Li4qSOZfLq1q2LCxcu4NmzZ/D19cXly5eljmQSsro4yft4eHhg//79GD58OHbt2qXjZPqXEytK3r17FwMHDkRISAhsbGx0euwP0Wg02L59Oxo1agQ/Pz84ODjg0qVL2LRpE+rWrcu914jIqLFwI6JsqVatGiIjI2Fvb48KFSrg8OHDUkcyeU5OTli/fj1++OEH1K9fH7NmzeJ8w8+UncVJ3qd06dLYsWMHunXrhhMnTugwmX49f/4cMTExKFOmjM6OmZqaisDAQPz000+oVKmSzo77IS9evMBvv/2GokWLYsqUKejSpQsePHiAiRMnolChQnrJQESU01i4EVG22djYYO7cuVi4cCG+/fZbDB48mMP4cpggCAgKCkJYWBjWrVsHf39/PH36VOpYRutzOm7pfH19sXbtWrRr1w4XL17UUTL9On36NKpVq6bThTnGjRsHJycnDBw4UGfHzMy5c+fQtWtXFC9eHNevX8fmzZsRFhaGjh07wsLCIsffn4hIn1i4EdEna9q0KS5evIjHjx+jcuXKOH/+vNSRTF6xYsVw8uRJVK1aFZUqVTKJoXpS+NyOW7pGjRohODgY/v7+uHPnjg6S6Zeu57cdOXIEy5cvx4oVKyCT5cwlRkpKCtauXYsvvvgCX375JUqVKoVbt25h+fLlqFKlSo68JxGRIWDhRkSfJU+ePNiwYQPGjBmDpk2b4pdffuGm3TnMzMwMEyZMwMaNG9GvXz/07dsXSUlJUscyKrrouKVr3749xowZg8aNGxvdqqu6LNxevnyJb7/9FsuXL0fevHl1csx/e/jwIcaMGYPChQtjxYoVGDFiBO7evYsff/wRLi4uOn8/IiJDw8KNiHQiICAA58+fx/Hjx1G7dm3cunVL6kgmr3bt2rhw4QJevXqFKlWqGO1wPSnoquOWrnfv3ujatSuaNm1qNIv2qNVqnD17FtWqVfvsY4miiO7du6N9+/Zo0qSJDtL9/7jHjh3D119/jfLlyyMuLg5HjhzBwYMH0bp1a+69RkS5Cgs3ItKZQoUKYd++fQgMDMQXX3yB+fPncxGNHObo6Ii1a9fip59+QsOGDTFjxgxotVqpYxk8XXbc0o0aNQp+fn5o2bKlUXRAL126BHd3dzg5OX32sebPn4+oqCj8+uuvOkgGJCQkYOHChShfvjx69+4NPz8/3L9/H3PmzEHp0qV18h5ERMZGEHlVRUQ54Pr16+jcuTNcXFywdOlSFChQQOpIJu/u3bvo1KkT7OzssGLFCuTPn1/qSAZLoVBAqVRCoVDo9LharRbffvstXr9+ja1bt8LMzEynx9eluXPn4vz581i6dOlnHefKlSvw8/PDqVOnULJkyc861q1btzBv3jysWrUKderUQb9+/VC/fn0u409EBHbciCiHlCpVCqGhoahevToqVaqEjRs3Sh3J5Hl5eeH48eOoUaMGKlWqhO3bt0sdySClpqYCgM6LNgCQyWRYvnw5NBoNunfvbtDdz7CwMNSoUeOzjpGcnIwOHTpg6tSpn1y0aTQa7N69G82aNUPNmjVhZWWFyMhIbNu2DQ0aNGDRRkT0D3bciCjHnTlzBp07d0blypURHBysk6FZ9GGhoaHo1KkTGjdujD/++APW1tZSRzIY8fHxKFCgAOLj43PsPZKSktCoUSNUq1YN06dPN8jio2jRoti5c+dn7eHWt29fvHjxAuvXr8/2/2NsbCyWL1+OefPmwdnZGf3790f79u11PoSViMhUsONGRDmuatWqOH/+PJydnVGhQgUcOnRI6kgmr0aNGoiMjERiYiJ8fHwQGRkpdSSDkRPz2/7L2toau3btwsGDBzFlypQcfa9PERMTg9jYWJQqVeqTj7F9+3bs2bMHCxcuzFbRdvHiRfTs2RNFixbFxYsXERISgjNnzuDbb79l0UZE9AEs3IhIL6ytrTFnzhwsXboUXbt2xYABA4xiAQdj5uDggNWrV2Ps2LFo3Lgxpk2bZtBD9/RF1ytKZsbJyQn79+/H4sWLsWjRohx/v+wICwtDtWrVPnmvtUePHqFXr15Yu3YtHB0dP/r81NRUbNiwAbVr10aLFi1QpEgR3LhxA6tWrYKvr+8nZSAiym1YuBGRXjVq1AiXLl3Cixcv4OPjgzNnzkgdyeQFBgbizJkz+PPPP9G4cWM8evRI6kiS0kfHLV2BAgVw4MABjBs3Dlu2bNHLe2bF5+zfptFo0LlzZ/Tt2/ejc+SePHmC8ePHo3DhwliwYAEGDRqEe/fuYdSoUXBzc/uk9yciyq1YuBGR3jk5OWHdunUYP348WrRo8T/27js+5vsP4Pjr7rL3ksSIvbJI7FV7FkVRtSV2qVVVtaqlNaotSluliT1apfbeq2aMEHslyCB73/j+/vDLVSRISHJ3yef5eHjg7r7f7zskd9/35/P+vD98/fXX2oYRQv4oW7Yshw8fpkmTJtSoUYPNmzfrOiSdKagZtwwVK1Zkx44dDB8+nAMHDhTYdV/n5MmTb524zZ07F7VazaRJk7J9XpIkTpw4Qc+ePfH09CQ8PJy9e/dy6NAhunbtmi9NYQRBEIoC0ZxEEASdevToEQMHDiQ6OppVq1a9cztx4c3+/fdfevfuTfPmzZk/fz6Wlpa6DqlA/fvvv4wePZrTp08X6HUzNpLeuXMntWrVKtBrv0ipVGJvb8+jR4+wtbXN1bGnT5/mgw8+4Ny5c7i5uWV6Ljk5mXXr1rFo0SKSkpIYOXIk/fv3z/U1BEEQhOyJGbciRpIkklTpRKYl8iQtnkepcTxJiycyLZEkVbrYLFkocCVLlmTXrl0MGDCARo0asXjxYvF9mM/q1atHUFAQSqWSGjVqcO7cOV2HVKAKesYtQ5MmTVi2bBkdO3bk+vXrBX79DJcuXaJcuXK5Tqji4+Pp1asXv/76a6ak7e7du3z++eeUKVOGLVu2MGfOHK5fv86oUaNE0iYIgpCHRL1CISdJEk+VyUSmJxKjTCZRlY4MkMlkz2+OZYD0398lwMrIBHtjC5xNrHAyttDLNtZC4SKTyfjkk09o2bIlffv2ZcuWLQQGBlKyZEldh1Zo2djYsHz5cjZs2MD777/PZ599xvjx41EoFLoOLd8V5Bq3l33wwQdER0fTpk0bjh8/nmXWqiC87fq2jJ/RDz/8EI1Gw759+1i0aBH//vsvfn5+nDlzhnLlyuVDxIIgCAKIxK3QUmrUhKbGci8lGpVGg5qXZjAyZjSkl/4OxKvSiFelEZYSi5FcTjlzB9zM7DCWF/4bOkG3KleuzIkTJ5g1axa+vr4sWLCAnj176jqsQq1Hjx7Ur1+fvn37snv3blauXKmTZKIg6WrGLcOAAQN4+vQpbdq04dixYzg6Ohbo9U+dOkWrVq1ydcyqVau4cOEC+/fvZ8GCBSxevBhLS0s+/fRTNmzYIPYJFARBKACiVLKQUUsaghPCOfDsNjeTnpKmUWdN2nJ6LiTSNGpuJj3lwLPbBCeEo5ZEK3EhfxkZGTF16lR27tzJN998w8cff0x0dLSuwyrUSpcuzcGDB2nVqhW1atVi48aNug4pX6WkpOg0cQMYP348H3zwAe+//z6JiYkFeu3czrjdvn2b0aNH4+npiaenJ6dPn2b58uVcuHABf39/kbQJgiAUEJG4FSLR6ckcjr5LWGocGiQ0b5mwvSzjXGGpcRyOvku0Uuy9JeS/WrVqceHCBVxdXalWrRp79uzRdUiFmkKhYNKkSWzbto0vv/wSf3//Ak8oCkpqaqpebPQ8a9YsvL29+fDDD0lLSyuQaz558oS4uDgqV678xtcqlUrWrVtHjRo1UKvVeHt7c+3aNdauXUuDBg1EGb0gCEIBE4lbIZAxy3YmLpQ0jSrPEraXaZBI06g4ExsqZt+EAmFubs78+fNZsWIFgwcPZuTIkWLT7nxWp04dgoKCkMlk+Pr6cubMGV2HlOf0YcYNnq/t/O2337CysqJfv36o1ep8v+apU6eoV6/eazfejoiIYObMmZQrV44JEyZQqVIloqKimDZtGsWLF8/3GAVBEITsicTNwKkkDadjH2pn2QpCxuzb6diHqETyJhSAFi1acPnyZeLi4vD19eXatWu6DqlQs7Ky4o8//mDWrFl07NiR7777rkCSioKiLzNu8Lw0eO3atURFRTFy5Mh37qj6ps7Bp06dynbTbEmS+Pfff+nTpw9Vq1bl4cOHTJs2DY1Gw+7duzExMXmnuARBEIR3J/ZxM2AqScOpmAckqdMLLGl7kRwZlgoT6tuXwUgmxgCEgrF582bq16+Pq6vrK1+T8bYmSrneXWhoKP369UOj0bBq1SpKly6t65De2cyZM0lNTWXmzJm6DkUrPj6eZs2a0b59e7755pscH5fbzsHpynRMNDJK2RXD2cQKS5WMP//8k0WLFhETE8OIESPw8/NDpVLh6+tLYGBgrhuZCIIgCPlDdJU0UGpJw5nYhzpL2uD5zFuSOp0zsQ+pa1cahUjehALQpUsXNJrMM71qtZo7d+7w559/0qpVK+rWrauj6AofNzc39u/fz7x586hVqxY///wzPXr00HVY70SfZtwy2NjYsGvXLho1aoSTkxOjRo167evftnOwwtgYNfAgOYY7cZEkxMZxMy6Cb76dSdtWrZHL5UiSRMeOHenVq5dI2gRBEPSImHEzUMEJ4QVaHvk6cmSUMrPFy/rVMyCCkJ/+/PNPrl69ikwm48iRI3z00UcMHz4cAI1G89r1PELOnT9/nl69elGvXj0WLVqEtbW1rkN6K5999hklSpTgs88+03UoWTx48IBGjRoxe/ZsevfuneV5taQhJDGSsNQ4gDz5DJDzfGa6lJkt7lbO/LJoMStXruTEiROiRFIQhLciSRLJaiVJ6nTUaNBIEnKZDAVyLBUmWCiMRVXMWxAzbgYoOj1Zb5I2+G/NWwkzGxyMRVtooWDFx8dz69Yt2rVrR7169QCYM2cOgYGBVKtWjZo1a+o4wsKjZs2aXLhwgTFjxuDj48OaNWu0/+aGJLsZN325yShTpgy7d++mRYsW2Nvb8/7772ufi05PJijhMUqNOk/f/zPOFZYaR1hSDOu2b2bt2rUiaRMEIcdyW7YtAVZGJtgbW+BsYoWTsYVI5HJAJG4GRi1pCEp4rDdJWwYNEkHxj2nqUF6UTAoFSpIkbty4wciRIwEIDAzk2LFjdO/enUGDBrFq1Sq8vLwAMfuWFywtLVm6dCmbNm2iU6dOjBw5kkmTJqFQKHQdWo5ldJWMSk/Sy5sMT09P/vnnHzp27Mg///xDvQb1tbNs+fner0EChYzJKxaRZmmNWtKI93NBEF7rbcu2AeJVacSr0ghLicVILqecuQNuZnYYyw3n86SgiVJJA6NPJZIvkyPDzcwWT1EyKRQQSZJITk5m7NixKJVKhg0bxogRI1i3bh2VKlVi2rRptG7dGl9fX5KSknB2dgZEApdXHj16RP/+/UlLS2PVqlWULVtW1yG9kVKjZvayxfi2a4qxmWnWm4wcUCArkJuM3bt3M2TYMFad2UeKTFOg7/tyZNgYmVLHrrRoPiUIQhYFUbYtBo6yEombAVFq1Bx4dlsvk7YMcmS0cKwoRkuEAvfrr79SrFgxLl26xIwZM7h27RqDBw9mz549fPnll4SFhTF48GBt6ZkkSaIsIw9oNBp+/PFH5s6dy/z58+nVq5euQ8rWizcZaWlpGJu+exlgft9kqCQNBx9fR20i18m7vugcLAhCdvKrbDuDHBnGcgW+NiXEEpyXiMTNgNxNfsbNpKd6n7hVtnSivIWjrkMRiogXZ88SExNp3749ZcqUISoqijFjxiCXy/n555/5/PPP+f777+nXrx8dO3bE1NRUx5EXLhcuXKBXr17Url2bRYsWYWtrq+uQtAzxJkP9/z0641VpOn3Pz5h5E52DBUF4cQCsIN6XMprfidm3/4jEzUBIksTB6NukafR/E1xTuYLmDhXFbIagMzt37sTX1xdjY2N69uzJwoULcXd355tvviE4OBiAjz/+mA8//FDHkRYuycnJjBs3jr1797J69epsN3ouSIZ8k6FPZfGic7AgCKr/b0NV0INJomw7M5G4GYio9CQuxIW91XqMgqZARk3bUjiZWOo6FKGIUavVmZpkjB07luLFizNhwgSuXLnCoEGDWLNmDXFxcSxcuJDly5dnGmAQ5ZN5Y8uWLQwdOpRhw4YxZcoUjIwKvg+WId9kRKcncyYuVC+StgxyZNSxcxNlS4JQBKkkDadiHuhs72BRtv2fov3VG5DI9ESDSNoA1EhEpifqOgyhCHq5s+GPP/7IhAkTgOdJ3KhRo6hYsSIKhYLk5GRkMhnTp0/n8uXLwAsdBYV30qlTJ4KCgjh58iSNGzfm7t27BXr9jJsMXZQZapCIV6VxKuYBKknz5gNeou+dg9Vv8TUJgmC41P8fBNNV0gbP33+S1OmciX1Y5N+DROJmIGKUycwfPZleHg35pHHHXB17/9pNRjbrwshmXehRuR7+tVoyslkXJnX14/KJM0zvPSzP441WJuf5OQUhN9RqNTKZDI1Gw82bN/Hy8tJuaDx58mTGjh3Lrl272L59O0uXLmXatGkAYsYtjxQvXpzdu3fTvXt36taty6pVqwokKTb0m4yQxEiUeloSr9SouZ4YqeswBEEoQCGJkTpfawv/DYqFFPH3IJG4GQBJkkhUpdPy4858s/73XB9f1qMyiw5tZtGhzdRt0wz/rz5n0aHNfPd34DvHplapsn08UZUuZi4EncqYfZPL5VSuXJn58+cD8Mknn+Dj40PVqlWZO3cuS5Ys4eeff+bGjRuEhIRkOodarZ830IZCLpczduxY9u3bx6xZs+jduzexsbH5ek1DvslQatSEpsTqPPZX0SARmhqnt4mlIAh5Kzo9WW/W2sLz96Cw1LgiPTkgEjcDkKxWIgO86tfG2s4uz8+fmpTMd/6jGdrgfb4f9rk24bp16SpfdOrLqJZdmfrRIKIjnt+ATOzcj9+nfMfoVt3Y8vuqbF8nA5I1yjyPVRDeVsb3dffu3Zk5cybTpk2jYcOG1KxZk5s3bxIeHk7ZsmWJiYnh6NGjQNbSS+Ht+Pj4cO7cORwcHPDx8eH48eP5ch1DvclQq9Vs376daQu/JzU1tYCie3uhqbG6DkEQhHwmyrb1k0jcDECSOj3H5Vv/7j7IqtkLc3X+O1dCGDLzS349vp3wB6FcO30BlVLJb1/OZNIfC1i4/29a9fqQld8t0B6jTFeyYN9GPhjcJ9vXyWQyklTp2tc/efKEr776itu3b+cqNkHIKxnr15o1a8aCBQu4e/cuGo2G0NBQJk+ezFdffcXGjRsZO3YsP/74Ix988AEJCQna4zWaovkhkVcsLCxYtGgRixYtonv37kydOhWlMu8GdwzxJiM6Opp58+ZRqVIlZsyYQYOu72NqbqaDKHNOg8S9lGhRUSEIhZwo29ZPBd/qS8g1NZocf0jWa9ucem2b5+r8lX29cSrxvM1zea+qRIQ+wtLWmgfXbzG5+0AANBo1Ds7FtMc07twOgLDb97J9nSQ9j/vGjRvMmDGDv//+G5VKRbVq1ahYsWKu4hOEvCKTyQgJCWHlypUcO3aMDRs2MHHiRBo3bkzVqlX56quvWLduHaVKlWLIkCGEh4djbGyMmZmZdq844d106NCBoKAg/Pz8eO+991izZg0VKlR45/Mawk2G5//b6QcFBbFo0SI2bdrEBx98wPr16ynn42kwnYNVGg3PlMmic7AgFFJKjVqvqhdellG2XdmyGMbyolUZIxI3A6CRJJBBfv38GJuaaP8sVyier+uRoEyVivywa322x5hZ/L8l9KteJ4M5c+ay4Ktv/7uOsTFLlizh0KFDmJmZ5eiXubn5a58XpWxCbrm7u7Nu3TosLS3x9/enZ8+emJubc/z4cTp06ECpUqW4evUqt2/fpnTp0vj5+dG9e3e6dOmi69ALDVdXV3bs2MGiRYuoV68e33//Pf3793/rxjCGcpNxefdRFs1fQGhoKMOHD+fGjRs4OzsDcDUxwiCSNvivc7BI3AShcDKUcujQ1FjKWzjqOowCJRI3AyCXyfItaXuVkhXLEvcshpCzQbjX9kWlVPLozn3KVK2Uo9eVr1qFDzp25PCm7Vy/fp20tDSMjIzw9vamXLlypKaman/FxsZq/5ySkpLpudf9SklJQaFQ5DjJy21S+KbXmpqaig6EeSRj/zRJkrSzyxqNBiMjI86cOYNCoaBatWoYGxvnyfWqVKmivY65uTkAtra2rF+/nqpVq/Lrr78yadIk/v77b9RqtTZp+/fff6lXr542PjEL9/bkcjmjRo2iWbNm9OzZk127dvHbb79hb2+f63MZwk1GSkoKFx7eZPz48XTs2DHL3nYxBrbYvig3BxCEwkySnpdD6+tAWIaMsu1y5g5F6l5MJG4GQIEcmUzGnCHjuHLiDPHRsfSr3pTeE0bSpne3TK/9d/dBbl0Mpu/EUe90TWMTE778Yz5LJn9LcnwiarWKTkP6ZUncXvW6Cu5V8PLw5OLFixw9epQRI0YQHBxM165dadCgwTvFlkGSJJRKZa4SvZcfi4+PJzIyMkevfflXWloapqam+ZIU5uT1RkZGhebNKuPrkMlk2j9nJEWnTp3C1NSUqlWr5lni9uI1M3h7e7NgwQL279+Pn58ftWrVokuXLixduhSAb7/9ljt37lCvXr1MG32LTbvfjbe3N2fPnmXixIn4+PiwcuVKmjRpkuPjDeUmIz46hn2bt7Mjei1TpkxhyJAhjB49Gvivc/CmXwL5Y/pc1oacxNYx9wkswL71m7l9MZjhs6eyc/l6TM3NaNGjM6G37jJnyGfIZDIm/TGfs/uPsGP5eip6e/Be53Y8vHmHj0YNzvF1MjoH+/n50aFDB7p168b8+fMZMmQIFhZik25BMFRPlcmoDGRNd1Es25ZJYoWx3ktSpXM85p7BlNEAKJDRyKEclornZZiSJHH06FEaNGiQpzffuqTRaEhPT3+rmcKcvvZ1r9doNPmWFObk19uUqf7000/s2rULY2NjGjZsiIuLCwMHDmTcuHEMGzaMoKAgwsLCePjwId7e3gwaNIhly5ZhYWHBhx9+iJlZ/jVueDkBO336NP/88w+zZs0iKCiIyZMn89dff/Hbb79x+/ZtBg0aRM2aNfMtnqJo165dDBw4kAEDBvD111/n6L0iKj3JINaGRUdEEhvxlI/fa4NpmoaaNWvyzz//4OHhQZIqnc3BJ/lp7BRCb99lwb6/8yRxe9GfC5eiUan4eNxwAIY2eJ9vNwZo1zfnVsZ7/IiBQ7SJW9myZTl37hxOTk5vdU5BEHTvamIED1JidB1GjpU1t8fDykXXYRQYMeNmACwUxnp+S5KVBFjI/7vpkslkuRpFNwRyuVybxNjlwzYNb6JSqUhLS3unpDAmJuatE0gjI6M3JneBgYGULFkSgCtXrpCQkMCGDRu4efMm//77L1u2bOHKlSs4ODhQunRpli1bRnJyMh06dGDJkiW0bNlSu5H2i0lVfsxyZZRqZpzX0dGRw4cPs2TJEpYuXcqcOXO4evUqwcHB1K1bly+//JKBAwfSo0cPbUwZ5xHeTrt27bh48SJ+fn40aNCAtWvXUqlSpdceE5meqPdJG4CDizMOLs5EpifiYe2Cu7s7jx49ep64qdNZMnU2ftPGM6P/iFyfe9+6Tfy54HesbG0o51kFY5PnA2Zr5i7CzNKC0lUqsGXJShQKOReP/UupCuUIfxDGtJ5DaNXzQ6zsbLXJXkzkUxZ/Pp3wB2EAfDL3Kxxdnfm6zzB+OboNgL8XB5CenILvjFnaGBYuXMjjx49p1qwZTk5OHDp0KA/+1QRBKGi5KdueP3oyZ/Ydxs7JQfv+APDH9O85s/cQRsbGFC/rxpiF32Fla5Mf4Ra5sm2RuBkAmUyGlZEJ8ao0XYeSY1ZGJuIGNp8ZGRlhZGSEpWXBlwjkpEw1JSUl03ql+/fvs3PnTg4fPoxSqaRixYr07t2badOmsWPHDszMzEhPT6d9+/a0bduWkydPcv/+fZKSknB0dMySuGXMDr5tWWrp0qXp0qULFhYW2pmdF69RsWJFDh48yJw5c2jdujUNGzZk5MiR+Pn50bhxY5KSkggNDdXGk3Hs+fPnxUzcO3B2dmb79u388ssvNGjQgDlz5uDn5/fK9xNDXBt2//59goKCqFu3LgA7tm3Dsbgz5b2qvvK4Z+GRLBw7ha/X/Z75fBGRrJm7iAX7NmJhY8WXXQZQwds902tqt2zC+/17YGZpQdcR/gCcP3SMWZtWYOtoz771m7WvXTL5W7wa1GbKikWo1WpSk5JJjI3PEk9G5+AMo0aN4scff+TQoUNixk0QDFRG2XZOtfy4Mx0G9uLHkRMzPe7bpAEDpoxFYWREwDfz+HPB7/hPG5/X4QL/lW0XlXtOkbgZCHtjC4NK3ByMxRqHwkwmk2FiYoKJiQk2NjkbRXNycuKDDz7gk08+wdraGoVCQd++falRowbXr1+nYsWKSJKk3TstNjYWU1NT4HlH0hcbgchkshzNFr5uBvLatWtcvnyZDh060LBhQ+21Mmg0GszNzZk+fTrwfI1bxYoVady4MUFBQWzbto2dO3eyYcMGjh07RqVKlfj444/x8/Njx44duLm5kZSUxPz587l3716eNsUp7N1UZTIZI0aMoGnTpvTq1YudO3fy+++/4+DgkOl1ubnJiHr0hB9GTiQ26hkyGbTt+xGdhvTLcUzPwiNZMulbJgUsePOLXxdHbAyjuw1m/vz52NjYkJyczMI5PzB1w2+vPc7R1TlL0gZw4/xlvBvUxtbp+b9N487teHTn/lvHd+n4aT5bNAd4vgG9pY11tokbsv93PBYEodBIVivJTfrjVb82EQ8fZXm8RrOG2j9XrVmdE9v25kF02ZMByRqldmlOYScSNwPhbGJFWEqsQZQEKZDhbGKl6zAEPVO/fn22bdvGxx9/jJmZGbdu3WLIkCH4+/vz4Ycf4uPjg1wu5+DBgxw/fpzQ0FC8vb3Zs2cPqampmUbTZDIZ5ubm2o6Q+UEul2fqHPnpp59i8v8StEmTJjFnzhwOHjzI+vXrmT17NkuXLqVjx46MGzcONzc37RpEd3d3nJ2dMyWNycnJREdHv/X6x+zKVPOrIc7LrzUxKbjZdE9PT06fPs2kSZPw8fFhxYoVNGvWTPt8bm4yFEYKBn09gYrVPElOTGJ0y674NmlA6So521fS0dX5nZM2lVLJTP9RdO/Zgw8//BCAO3fuEPrgAcObdgLg6eMIRrfsyo+7N+DgUux1pyswCiMFGs1/nz3KtDSQ/t/xWBCEQiNJnf78/T0PB2X2rdvEe53aZfvcyGZdWHRoc7bP5ZRMJiNJlS4SN0G/OBlbYCSXo9bTDWZfZCRX4Chm3IRszJgxg5SUFNLT00lKSsLFxQUTExMWLVpEyZIlSUtLo127dsjlckqXLo2VlRUdOnTA3t5eJ7NMGUmbRqPRziyeOXOGSpUqUbduXVq0aEFAQABlypTB1NQUJycnBgwYkOnYjBv0vJJRpvouDXFe3IIjt8mjUqks8G6qkyZNonHjxvTp04c+ffowY8YMTExMcnWTkbHGDMDCyhK3yhV49iQix4lbxMNH2nVeD67fYv7oySjTlUgaDZMCF1CyfNk3/r8tGDOF0pUr4P/pJ9rHvb29uRZ6j4sJj1FJGvxqtmD+3o05bk5SpWY1lkz5jvjoGCysrTi+dQ/lPKvk6Njs+LxXjx3L19F5aH9tqaRdMUfinj4jPjoGc0tLzuw7TO3mjVGQeTsMa2trEhISRKmkIBiA27dv4+rqipXVfwPtajTkZc/C9T/9hkKhoFm3jtk+/65JG2Qt2y7sROJmIGQyGeXMHbiZ9FSv217LkVHO3L7I1BoLuaNQKLQfEi+WvVWp8vxGMyIiAg8Pj0wNKWrVqlWwQWbjxTLNOnXqUKdOHSRJolSpUpQpU4arV69y+PBh/vrrLyB/twh4sUzV1tY2X67xOhqNRtsU522Tx4SEhLcqcU1OTmbu3LnMmzcPGxsbPujfk16TR+f6a4h4+Ii7V0KoUrN6ludysqXKzhUb+GBwX5p164gyPR2N+s03DddOX+DgX1sp616ZZnUaYCyT8+2331KjRg2u3rmJpsrruzu+ao2bg4szvT8fyWfv93zenOQ16+RyYsjMSfw8/iv2rv0buVzBiLnTcK/tS8/PPmFsmx44FnemVMXySJKEpVHmEe4hQ4bQtm1bSpQoIZqTCIKe69KlCzdv3uSjjz7i008/pXbt2s/Ln2Xkyd7B+9Zv5uzew3z7d2D+3hMWsbJtsR2AAVFq1Bx4dlvvE7cWjhUxlhfuNThC/rh+/Tpubm7afaBe7vSoLzJi+uabb7hx4wZ79uxh9uzZDBo0SGzMnc+USiWLFy9m5syZzFm2mFINfXJVQp6SmMQXnfvRY8xQGnZonePjXpxxO/z3djbM/43m3TvRoEOrN862vUijVHFl+yH2rtvElStXAPCuVo0J639B0q9v89eSI6ONU2W9+9kUBOHVJEkiOjqa8PBwPvroI65du4ZMJsPIyAhTU1M2HdqDpoxjrt5TX3xvzHDu4DGWTZvDnH9Watff5sbymT9S2debBu1bvfG1CuRUs3GluGn+dK3UNyJxMzDBCeGEpcbpZfImR4abmS2e1m+3L5AgGKLLly+zd+9exo9/3jErKSmJo0eP0rx58ywNT4S8ExISwre/zqfb+OGYmOdsfz+VUsnXvYdTo1kjugwfkKvrvXxz8uTeQ87uP8K2ZasZOe9rqr9XL0fnUaakEXnmKmVsnPD29sbV1RWZTMbxmHsG1YDKxsiURvbldB2GIBR5kiQRFxdHREQE4eHh2t9f/HPG75GRkVhZWeHi4sKzZ8+IiooCnjcA8/LyYs2OzYQap6GSclZ6OGfoZ1w5cYb46FjsijnSe8JI2vTuxqA6bVCmp2Ntbwc8b1Ayct70LMe/ao3b9N7D6DFmKO61fd8Yg5FMjo91CZxNi0ZvBZG4GRi1pOFw9F3SNCpdh5KFqdyIpg7lUcjEbINQ+GW3b5skSahUKnr27MmtW7dYtWoV1apV01WIhd6jxBjOxTzE2OzNCbIkSfw4ciLW9rYMmTkp19d6MXF7cj8U1zKlkMlkLPtqLk4lXOg8tH+OzvOqmwyx6a0gCC9KTEx8YyKW8WcTExNcXV1xcXHJ9PvLj7m4uGgHFCdMmMCPP/5IsWLFWLFiBa1btyZJlc7xmHs6b4Q39aNBzPhzWY5eq0BGI4dyojmJoJ8UMjm+NiU4ExuqV7NucmT42pQQSZtQZGRXIiaTyTA2Nuavv/5i5cqVtGjRgs8//5zPPvus0Lfw1wU7M0vMzMxydJPx4hqzkc26ANB/8hhqt2yS6XU5WeN2bOtuDv21BYWRMfbOTvQYMyTHMWe3NgxE52BBKApSUlJyNDMWHh6OJElZki9XV1dq1KiRJSHLWF6QG+3bt8fc3JyJEydqOzRbKIz14h0op0kbPF+OZyE3zr9g9IyYcTNQ+lQyKUdGKTNbvESJpCBkcv/+fQYMGIBGo2HFihWUKydKy/KSJEnseXpTL94Hc+pVa8MkSeJg9G3SDKBzsKnciOYOFcT6NkEA0tPTiYiIyNHMWGpqao5mxjK6PeriZ0yUbes3MeNmoNytnIlXpRKvStPpTYscGTZGprhbOessBkHQV2XLluXgwYPMnz+fOnXqMHv2bPz9/cUNbx6RyWRYGZkY1E2GlVH2++CJzsGCoD9UKhVRUVFvTMTCw8NJTEykWLFiWRKxihUr0qhRo0yP2dra6v3Pjr2xhUG9pzoUse2nxIybAVNJGk7FPCBJna6TD3o5MiwVJtS3L4ORKJEUhNcKDg6mb9++uLm5sXTpUlxcxPqgvFCY1oaJzsGCkH80Gg1Pnz7N0cxYTEwMjo6Or50Ry/jdwcGhUHUSjkpP4kJcmMGUbde0LYWTiaWuQykwYsbNgBnJ5NS3L8OZ2IcFPvOWMdNWx660SNoEIQe8vLw4ffo0X3/9NT4+Pvz666907txZ12EZPENaGwaQolYSlZ6Ek7FFlpF3Y7mCUma2elMG/7KMzsEiaRP0hSRJxMTE5Ghm7OnTp9ja2mZbolitWrVMjzk5ORXZdclOxhYYyeWoDaBs20iuwFHMuAmGRi1pCEmMLLAP+4w1be5WzqIZiSC8hZMnT9KvXz/ee+89FixYgI1N0dh/Ji9oNBru3r3LlStXnv8KDubDr8e81V5BuqJAhpFcTjlzB9zM7DIlQqJzsFDUSZJEfHx8jmbGIiIisLS0fO3MWMafnZ2dMTYuOk0s3sXd5GcGUbZd2dKJ8haOug6lQInErRCJViYTFP8YpUadLz9scmQYyxX42pQocjXFgpDXEhMT+eyzz9i7dy/Lly+nSZMmbz6oiImIiPgvQfv/r5CQEJycnu+BlvGrTN1qxFsb6fVNRnbkPJ9xe3kgLFqZrJedg+vYuYn3/kJAkiQkSUIulxMSEkKpUqWwtrbO9+smJiZmScBelZwZGRm9sXmHq6srzs7OmJnlbB9HIedE2bb+EolbIaOWNFxPjCQ0NQ4gT37oMm4u3MxsqSpm2QQhT+3YsYMhQ4bQs2dPZs6cWSRvQpKSkrh69WqWJE2lUmVK0Ly9vfHy8soyQ2kINxmvk92gmOgcLBSEKVOm4O/vT/ny5d/q+Iz29jlpca9Wq7UJ1+tmxlxcXLC0LDprlvSVPr0HvSyjbNuzCL4nicStkFJq1ISmxnIvJRqVRvNW6z9eV84jCELeefr0KcOGDePGjRusWrUKHx8fXYeUL1QqFbdv386SoD1+/JgqVapkSdJKlCiR4w5s+nyTkVMvlqEDnNbB+uXsYrIxMqWuXWkxaGegYmNjsbS0xNjYmPv377N//35CQkKYMGECvXr1IiIigo4dO/LFF19gZ2cHPG9xf/ny5TcmZCkpKa9s2vFyQmZtba33HRWF/4iybf0kErdCTpIkniqTiUpPJFqZTKIqHRnPW09LEiADJJDJ/l8+wfN21Q7GFjibWOGYzQJ6QRDyniRJrF69ms8++4yxY8cyYcIEg10cL0kSjx8/1iZmwcHBXLlyhevXr1OiRIksM2iVKlXCyOjdemXp801GbrzY+AnQaefg9LQ0TDQyWrt5iSZUeiY1NZXIyEgiIiJwcXHh8ePHeHt7c//+fa5fv07Dhg2ZNWsWd+7c4eHDh3z55Zf07NmTGTNmEB0dTaVKlRgwYABfffUV5cqVw8/PT7sJM8Djx4/p0KHDG/ccs7OzE/cIhZgo29Y/InErYiRJIlmjJEmVjhoNGklCLpOhQI6lkQkWcmPxJiwIOvTw4UMGDBhAWloaK1eupEKFCroO6bXi4+O1idmLiZpCocgyg+bp6ZmvJVD6eJPxNl7cagXQWedgktMZ3KQDq1esFGsw9UhkZCTjxo3j2bNnALRs2ZKwsDBGjhxJeHg4R48epW/fvowdOxZ/f3+qVavGypUr8fHx4fTp0/Tq1YvKlSsDsHDhQhwcHOjTp48uvyRBj+lTNYMo2xbbARQ5MtnzGwJLhYmuQxEEIRulS5dm//79LFy4kHr16vHdd98xaNAgnQ+oKJVKbty4kaXMMSoqCg8PD21y1rlzZ7y9vXWyT52DsYVet9PPKQ0SSep0zsQ+pK5daeraldZN52AnZ1YEBNKtWze2bNlCgwYN8v3aRV1Ge/uXSxTbtGmDu7s7AObm5sjlcqZMmUKDBg2YO3cu0dHRqNVq7O3tMTc3JyUlBV9fX5RKJfb29lhaWvLo0SMcHR2Ji4vTXs/S0jLT3wXhZe5WzsSrUvWmbDujlLyoEombIAiCnpHL5YwZM4bWrVvTt29ftmzZwrJly3B1zf9RRkmSCA0NzZKg3bp1izJlyuDl5YW3tzd+fn54e3tTvnx5vSrp1JebjHelQSJelUZIYiRe1q54WbtSwswmXzsHp6emYWVuQQ3bktoypObNm7Nq1So6d+7Mzp07qVWrVp5ft7CTJImEhIRXNu14cf1YZGQk5ubmWUoUk5KStOeTy+W4u7uTmJioHdB58uQJGo0GKysrwsPDUalUODk58ezZM8zNzUlPT6ds2bKkp6ezZMkStm/fTs2aNWnVqhXfffcdH3/8MV988QW+vr66+mcS9JRCJqeOXWmdlm1nVCHUEWttReImCIKgrzw8PDh16hQzZszAx8eHxYsX07Vr1zw7f0xMTJYELTg4GEtLS+0MWuvWrfnss89wd3fPtAZGX+nDTUZe0SARlhpHCTMbHIwtcDC2oKlD+XzrHHzr1AVSbz2i5eQpmZ5v27YtS5cupUOHDuzZs4fq1au/8zULg6SkpDcmYhl/NjIyynatWJ06dbIkaW/qLGtiYkJ8fDwnTpzAxMQEIyMj3n//faZMmULJkiWJjY0lPj5eO8smk8lwdXXFwcGBWrVqkZCQQFRUFK6urpQuXZrvvvsOhUKBra1tAf3LCYbGSCanvn0ZnZVtZ6z7FWttxRo3QRAEg/Dvv//St29fGjRowMKFC3N1k5WWlkZISEiWJC0uLk47g/biL0dHw9/QVCVpdHKTkR+y66CWH52Dn4Q9wtfXl3PnzlGuXLksr//rr78YNWoUBw4cwMPD452+Jn2Vmpqa473GVCpVjvYay+v29mq1mj/++INt27ZhYWFBhw4d6NixIxs2bKBUqVJUrlyZUqVKYWxs/M5NfwThRWpJo5uybbEVlZZI3ARBEAxEUlISn3/+OTt37iQwMJBmzZplel6j0XD//v0sCdq9e/coX758lgStTJkyyOWF98OwoG8y8svr9izK687B3377LWfPnuWff/7JNpbVq1czceJEDh06RKVKlfLjy81z6enp2g6MbypXTElJwdnZ+Y2JmKurq87a22s0GjZs2MCzZ88YOXJkjo+TJAmZTIZGowGef4/oeu2sYJiilcn5Wrad3d6WwnMicRMEQTAwu3fvxs/Pj4YNG1KvXj1t05CrV69ib2+fpd1+1apVMTU11XXYOpPfNxkFQY6MFo4V37if5rt2Dk5LS8PLy4uFCxfSrl27bF+zbNkyZsyYweHDh7OdmSsIKpWKp0+f5mjdWHx8PMWKFXtjIubi4oK9vb1BJDM7duzg/v37jBgxArVajUKhQKPRaGM3hK9BMGxqSZNvZdtuZrZUFbNs2RKJmyAIgh5LTk7m2rVrWWbRUlJSMDExQa1WM3ToUNq3b4+Xl5d2A10hM7Wk4VpCOLfjIjE3Mze4BE6OjMqWTpS3yP8y1p07dzJ69GiCg4NfmfAvWrSIH3/8kaNHj1KqVKk8ua5Go+HZs2c5WjcWHR2Ng4PDGxMxV1dXHB0dC/XMsiDoUn6Ubb9pgKooE4mbIAiCHlCr1dy5cydLghYaGkrlypWzlDlm3CyvW7eOMWPGMHr0aL744guxpuU1EhMTqVC5EqduB3MvJZqk1FSMTIx1HVaOmcoVNHeoWCCzKZ06daJu3bpMmjTpla/54YcfWLJkCUeOHKF48eLZvuZV7e2zK1t8+vQp1tbWr0zAXkzOnJycxPe6IOiRvC7bFrInEjdBEIQCJEkS4eHhWTatDgkJwdnZOUuCVrlyZYyNX59chIWF4efnR2JiIqtWraJixYoF9NUYlow956Kiorh95zZDxo9mbuBvRCqT3nywHlAgo6ZtKZxM8m8T8wz37t2jVq1aBAUFUbp06UzPvdjefu7cuezZs4dPPvkk2y6LERER2ba3z26WzNnZGRMTsceoIBQG71q2LWRPDFcJgiDkk8TExCwJ2pUrVwC0iVmDBg0YMmQIXl5eWFtbv9V1SpUqxZ49e1i8eDH169dnxowZDB06VHwoviQ1NVXban3njp2UtXfB3MgEDCRxUyMRmZ6Yb4lbUlJSpqSrXr16tG3blsaNG2eZJXuxvb2lpSU//vgjAwcOfKv29oIgFD4y2fO91ywVYjAmL4kZN0EQhHekUqm4efNmlgQtPDwcd3f3LLNorq6u+ZZUXb9+nT59+uDs7Mwff/zxyhK2oujmzZt06NCBRo0asXr1alxdXVl76QjxqrRMr9v0SyB/TJ/L2pCT2DraF3icEzv3Y+D0CVTy8crynI2RKY3sc94Q5HXt7V8uV3y5vb2joyObNm2iX79+NGnSRPuci4sLVlZW2mtIksT48eM5duwY+/btE/uBCYIg5BMx4yYIgpBDkiTx6NGjLAnazZs3KVmypDYx69u3L97e3lSsWBGFomAXWVetWpVTp04xc+ZMfHx8WLRoEd27dy/QGPRVxozbRx99xPr167GysiJRlZ7pNVGPnhB0+ATFSukm4VWr1a99PlGVTlpaGlFRUTlaN/Zie/sXSxOrVq1K06ZNMz2WXXv7Dz74gIkTJ/L999+/soxRJpMxb948Ro4cyfvvv8+ePXsyJXaCIAhC3hCJmyAIQjbi4uKyLXM0NTXVttlv1qwZo0aNwsPDI0832H1XxsbGfP3117Rv356+ffuyZcsWFi1aVOQ7TqakpGBubk5aWho+Pj7Exsfx8rzn0qmz8Zs2nhn9R+Tq3Me27ub62YsMnjGRLb+vZMvvqwg4t48n90P5YcQXzNuxlotHT/HH9O9Rq1VU9vFmxNyvMDY1wa9mC97r1I6LR07SdeRA7Tk1Gg3zR0/GqYQLvSd8yoIxU7gZdIUn9x9ibmpGhQoVMq0RK1euHPXq1cv02Lu2t//ggw9YsmQJCxYs4PPPP3/l62QyGT///DNDhgyhY8eO7NixAwsLsf+SIAhCXhKJmyAIRVp6ejrXr1/PkqBFR0fj6empnUXr2rUr3t7eFCtWTNch51idOnUICgriiy++oFq1agQGBtKiRQtdh6UzGTNuO3bsoHnz5mzcvOl5UvP/FQOndh3AsbgL5b2qvvIcz8IjWTh2Cl+v+z3T4551a/L3oj8AuPrveWwc7Hj6JIKr/57Hq34t0lPT+GnUJL77O4CSFcrxw4gv2LF8HZ2H9gfAxt6OhQc2AbBrxQbUKhXfD/+cMlUr8fHYYdy6dJVnTyJYenwHPtbFMU3VFEgiLpPJWLBgAfXr16dXr16ULFnyla+Vy+UsWbKE/v3706VLF7Zu3Vqk9w8UBEHIa2JjE0EQigRJkrh//z7btm3ju+++o2fPnnh5eWFra0uPHj3YsmULlpaWDB48mEOHDhEfH8/p06dZtmwZo0ePpnnz5gaVtGWwsLDg559/ZtmyZQwYMIDRo0eTkpKi67B0ImPGbefOnTRr1gx4/n0BkJqcwp8LfqfPF5++9hyOrs5ZkjYAB5dipCQlk5yYRNTjcJp82J7gU+e4evocnvVqEnb7Hi6lS1KywvP1aS16dCb41Dnt8Y07Z97setH46dqkDcC1TCnCH4Txy5czObBvPzY2Nm//D5FLlSpVYujQoa+dccugUChYvnw5NjY2dO/enfT09DceIwiCIOSMSNwEQSh0oqOjOXLkCIsWLWLo0KE0aNAAW1tbGjZsyOLFi4mJiaFdu3asWrWKmJgYQkJC+PPPP5k6dSqdO3emQoUKhW7D3tatW3Pp0iUiIyOpUaMG586de/NBhUxqaippaWmYmZlRvnz55w/+v4ow/H4oEQ/DGNmsM341W/D0cQSjW3YlOiIqx+d3r+3D/nWbKFWhLF71anH133NcP3cRjzo13nis6Utlhe61fbh8/DTpqc8bp1jb2bLo0GaqNazDyt//YNCgQTmOKy9MmjSJEydOcPjw4Te+1sjIiLVr1yKTyejduzcqlSr/AxQEQSgCRKmkIAh6Ly4uLttOdampqVy7dk1b3pixJi0xMREvLy+8vb2pVq0avXv3xsvLCwcHBx1Erz8cHBxYt24d69evp3379owYMYJJkyYVmY2MU1JSePbsGe3bt/9v3df/+yqX9ajM2msntK/1q9mC+Xs35qqrpGe9WqyZ8zM9PxtOeW93Lp84g6mZKZY21pSqWI7I0Mc8vvuAEuXLcPCvrXg3qP3Kc7Xu3Y3gU+eYNXgsUwIXkhiXgLGJMY06tKF59dqM9R/2Vv8Gb8vS0pIffviBTz/9lAsXLrxxb0FjY2P+/PNPOnXqxIABA1ixYkWBN+oRBEEobArXkLIgCAbvyZMnREZGcvToUTZs2EBKSgrdunUjKSnzXlu7d+/G3t6e/v37s2fPHhwdHRk5ciQnT54kNjaWEydO8NtvvzFixAgaN25c5JO2F3388cdcuHCBEydO0LBhQ27evKnrkApEamoq4eHhXL58mfr163Pn5i36VG/CnjUbc3yOZ+GRfNVzSLbPedWtSdSjJ3jVr4VCoaBYCVc86tYEwMTMlDELvmXWoLF80uQD5HI57/f/+LXX6jJ8ABW83Jk34guePYlgYud+fNKsE5/6DWHWrFk5/8LzSNeuXXF1dWXx4sU5er2pqSmbNm3i8ePHDB06FI1Gk88RCoIgFG5iHzdBEHTixo0bXL9+HWNjY4yMjIiLi6N79+6MHz+etm3bUqZMGb744gvKli2Lt7c3fn5+mY5PS0tDJpO9skW58GaSJPHLL78wffp0pk+fzieffFKoN+2eO3cuU6ZMISEhAVNTU5JU6RyPuYcaw/kYVCCjkUM5nW1qGxISwnvvvUdwcDCurq45OiYxMZG2bdtSvXp1Fi1aVKi/xwRBEPKTmHETBKHAPXv2jOnTp3Pq1Ck2bNjA7du3iYyMBKBMmTIkJiZSqVIl5syZw6pVq6hSpUqWc5iamoqk7R3JZDJGjBjB8ePHWblyJW3btuXRo0e6DivfXLp0idKlS2s7HVoojA0oZXtOAizkry9TzE/u7u74+/vzxRdf5PgYKysrduzYwdmzZxk/fjxivFgQBOHtiMRNEIR8pVKpuH79Ok+fPtU+Zmdnx9KlSxk6dChPnz4lJCQEtVpNcnIyjo6OhIWFAXD+/HnatWvHvn372L59u66+hEKvSpUq2rLJGjVqsGHDBl2HlC+uXLlC5cqVtX+XyWRYGRlW8m9lZKLzGaupU6dy4MABTpw48eYX/5+trS179uzh4MGDTJ06NR+jEwRBKLxE4iYIQp6QJInHjx+zZ88e5s2bR//+/alRowY2Nja0b9+ekydPate4KBQKfvzxR+bMmUOxYsUwMTHByMiIO3fuEBMTw/Xr1wkODubSpUuMGjWKhg0bEhwcTFpamo6/ysLLyMiIadOmsWPHDqZPn06vXr2Ijo7WdVh5RqVScevWLby8vDI9bm9sWJtEO+hBvNbW1nz//feMGDECtVqd4+Ps7e3Zu3cvmzdvZubMmfkYoSAIQuFUNFqJCYKQpxISErQdHF/8JZfLtRtWv/fee3zyySd4enpiZWWV6fioqCjS0tLo0KEDN2/e5MGDB6SmpuLv70+lSpXo0KED5ubmDBgwgEqVKiGXy2nZsqWOvtqipVatWly4cIGJEydSvXp1/vjjD1q3bq3rsN7ZqVOnsLa2xtnZOdPjziZWhKXEGsQ6NwUynE2s3vzCAvDxxx+zZMkSbQOgnCpWrBgHDhygSZMmmJmZMX78+HyMUhAEoXARzUkEQXglpVLJzZs3syRokZGReHh4aFvuZ/xycXHJURmXJEls3bqVZcuW0axZMxo3bkzlypWxsrIqdPunGbL9+/fj7+/PBx98wNy5c7Gw0P1sz9v68ssv2bdvH35+fpkSDUmSOBh9mzRNzmeOdMVUbkRzhwo6L5XMEBwcTLNmzbh27VquN6cPCwujcePGjBs3jpEjR+ZThIIgCIWLSNwEQUCSJEJDQ7MkaLdu3aJ06dKZkjNvb2/Kly8v9mQqImJjYxk5ciTnzp1j1apV1K796r3H9Fm1atUoU6YMnTt3ZuDAgZmeu5v8jJtJT9Ho8aybHBmVLZ0ob+Go61AyGTt2LAkJCSxbtizXx96/f58mTZowZcoUBg8enA/RCYIgFC6iVFIQipjY2NgsCVpwcDDm5ubaxKxVq1aMGzcODw8PzM3NdR2yoEN2dnasXr2av/76iw4dOjB8+HAmT578xg2Y9cnDhw958uQJnp6e2X4/u5nZcTPpaTZH6hc3Mztdh5DF9OnTcXd358yZM9SpUydXx5YtW5b9+/fTrFkzzMzM6Nu3bz5FKQiCUDiIxE0QCqm0tDSuX7+eJUmLjY3F09NTm6R99NFHeHt74+TkpOuQBT3WvXt3GjZsyMCBA2nQoAGrVq2iatWqug4rR3bu3EmbNm1ITk7GzMwsy/PGcgWlzGwJS43Ty1k3OTLczGwxluvfLLetrS2zZ89mxIgR/Pvvv7meia9UqRL79u2jefPmmJqa8tFHH+VTpIIgCIZPlEoKgoHTaDTcv38/0+zZlStXuHv3LuXLl89U4ujl5UXZsmXFOjLhrUmSxJIlS5gyZQrTpk1j5MiRev/91LFjR3r16sXKlSsZNWoU7dq1y/IataThcPRd0jQqHUT4eqZyI5o6lEch089/Z41Gw3vvvUf//v0ZMmTIW53j8uXLtG7dmiVLltCpU6c8jlAQBKFwEImbIBiQp0+fZplBu3r1KnZ2dlnWoVWtWlW70bAg5LVbt27Rr18/rKysCAwMpFSpUroOKVspKSm4uLhw//59unbtyrRp02jWrFm2r41WJnMmNlSvZt3kyKhj56YX2wC8zsWLF2nTpg3Xrl3D0fHt1uFl7Nu4YsWKbJNrQRCEok6USgqCHkpJSeHatWtZkrSUlBRtJ0dfX1/69euHl5cX9vb2ug5ZKGIqVarEsWPHmDNnDjVq1GD+/Pn07NlTbzoeZjh8+DDVq1fHwcGBlJSU167ZdDC20KuSSTkySpnZ6n3SBuDj40P37t2ZMmUKv/7661udo2bNmmzZsoUPPviADRs20Lx58zyOUhAEwbCJGTdB0CG1Ws3du3ezJGgPHz6kUqVKWWbR3Nzc9O7GWBAuXLhA37598fLy4tdff8XBwUHXIWmNHDmSUqVKMXHiRHx8fFi+fDk+Pj6vfL1a0nA69iHxqjSdJm9yZNgYmVLXrrTelki+LCYmBnd3d3bu3EmNGjXe+jxHjhyhe/fubNq0iUaNGuVhhIIgCIZNJG6CUAAkSSIiIiLLOrRr167h7OycZR1alSpVDKprnyCkpKQwefJk/vzzT5YtW0bbtm11HRKSJFG+fHm2bt2Kt7c3VapUYevWrVSpUuW1x6kkDadiHpCkTtdJ8iZHhqXChPr2ZTAykKQtwx9//MGyZcs4ceLEO6193LdvH71792b79u257lYpCIJQWInETRDyWGJiIlevXs0yi6bRaLLMoHl6emJjY6PrkAUhzxw8eBA/Pz/at2/P999/j6Wlpc5iuXbtGm3btuXBgwfIZDLKlCnD0aNHKVOmzBuPVUkazuhg5i1jpq2OXWmDS9rgeaOS+vXrM3z4cAYMGPBO59q+fTsDBw5k9+7d+Pr65k2AgiAIBkwkboLwllQqFbdu3cqSoD158oSqVatmSdKKFy8uyhyFIiE2NpZRo0bx77//snLlSurVq6eTOL7//nvu3r2rXXPl7OxMcHAwzs7OOTpeLWkISYwssDVvGWva3K2cDaY8Mjvnzp2jY8eOhISEYGdn907n2rRpE5988gn79+/Hy8srbwIUBEEwUCJxe0uSJJGsVpKkTkeNBo0kIZfJUCDHUmGChcJY3KQXEpIk8fjx4ywJ2o0bNyhZsqS2WUjGr4oVK2JkJPr+CMLff//NiBEjGDx4MNOmTSvw8t+mTZsyfvx4OnToAICNjQ1hYWG5nuWOViYTFP8YpUadLwmcHBnGcgW+NiUMohFJTgwdOhRTU1MWLlz4zudat24dn332GYcOHXpjmasgCEJhJhK3HJIkiafKZCLTE4lRJpOoSkcGyGQyJEkCGSD993cJsDIywd7YAmcTK5yMLUQiZwDi4uK0689eXI9mbGycZQbNw8NDp2VggmAIwsPDGThwIOHh4axatQoPD48CuW5sbCxlypThzqOHaIwVqNHg7z+Qpb//jomRca4H2NSShuuJkYSmxgHkSQIn5/m13cxsqWrgs2wve/r0KR4eHuzfv59q1aq98/mWL1/O1KlTOXz4MBUqVMiDCAVBEAyPSNzeQKlRE5oay72UaFQaDeq3+LBWIMNILqecuQNuZnYYyxX5EKmQG+np6dy4cSPLLNqzZ8/w8PDIkqTltLRKEISsJEli6dKlTJ48mcmTJzNq1Kh82bT7xQG2u5GPkEyNMDUx/W9ATZKQyWTvNMAmPhNy7rfffmPNmjUcPXo0TwYuf/vtN2bPns3Ro0cpXbp0HkQoCIJgWETi9govrm2AvB1dLQxrGAyFJEk8fPgwS4J2+/ZtypQpkyVBK1++fL7cUAqCAHfu3KFfv36YmZkRGBiYZzffukimMpLEqPREol+qwlCmK1GpVZiZmSOTkSlJdPh/kuhYBKow1Go1derUYdy4cfTu3TtPzjl//nwWL17MkSNHKFGiRJ6cUxAEwVCIxC0b0enJBCWI9QyGJiYmJkuCFhwcjJWVVZZ1aO7u7q/diFcQhPyhVquZO3cuP/30Ez/88AN9+vR56wRGnwbYJEkiWaMkSZXOkeNHuRAUxKhPP32+7tnIBAt50Vz3fOrUKbp160ZISEieddCdPXs2K1as4PDhw7i4uOTJOQVBEAyBSNxeIDqIGYbU1FRCQkKyJGkJCQlZEjQvLy8cHR11HbIgCC+5ePEiffr0oWrVqvz22284OTnl6nh9HmBbv349mzdvZsOGDXkelyHy8/PD0dGRefPm5dk5p0+fzqZNmzh06JB4jxcEocgQidv/iT179I9Go+HevXtZErT79+9ToUKFLGWOZcqUKZIj2oJgqFJTU5kyZQrr1q1j6dKlvP/++288xhAG2P788082btzIn3/+mc/RGYbIyEg8PT05cuRInjWnkSSJL7/8kn379nHgwIF33nZAEATBEIjEjedJ26mYBySp0ws0acsgR4alwoT69mWKbPIWFRWVJUG7evUqDg4OWRK0qlWrYmJiouuQBUHII0eOHKF///60adOGH374ASsrq2xfZygDbBs3bmT9+vVs3LixAKIzDD///DObN2/mwIEDeTbAJkkSY8aM4cyZM+zduxdra+s8Oa8gCIK+KvKJm1rScFoHNwIvy7gxqGtXulCXTSYnJ3Pt2rUsSVpqamqWBM3Ly0uMogpCEREfH8/o0aM5duwYK1eupEGDBpmeN6QBtr///ps1a9awadOmAopO/6lUKmrWrMnkyZP56KOP8uy8kiQxfPhwrl27xq5du8QWLYIgFGpFPnELTggvsJKbN8koyfGydtV1KO9MrVZz+/btLAlaWFgYVapUyZKklSxZUpQ5CoLA5s2bGT58OP7+/kyfPh0TExODG2DbvHkzK1euZPPmzQUYnf47duwYvXr1IiQk5JWzqm9Do9Hg7+9PWFgY27ZtE42nBEEotIp04hadnsyZuFC9SNoyyJFRx87NYLpNSpJEeHh4lgTt+vXruLi4ZEnQKlWqhLGxsa7DFgRBj0VERDB48GBCQ0NZtWoVlHEyqAG2LVu2EBAQwJYtWwowMsPQp08f3NzcmDVrVp6eV61W06dPH+Lj49m8ebMopxcEoVAqsombWtJwOPouaRqVrkPJwlRuRFOH8npXMpmQkMDVq1ezJGlAlgTN09NTrDcQBOGtSZJEQEAANx49oPnw3nqRtGV40wDb1q1bWbp0Kdu2bSvgyPTfkydP8Pb25sSJE1SpUiVPz61UKunRowcAGzZsEIOEgiAUOkU2cdOnEsmXyZHhZmaLp45KJpVKJTdv3tTug5aRoEVERODu7p5pDZq3tzeurq6izFEQhDxnqANs27dv57fffmP79u06iEz//fDDD+zdu5fdu3fn+WdHeno6Xbp0wcbGhtWrV6NQvH4jdUEQBENSJBM3pUbNgWe39TJpyyBHRgvHihjL8+9DR5IkwsLCssyg3bx5Ezc3tyyzaBUqVBAfgoIgFBhDHWDbuXMnixYtYufOnTqITP8plUp8fHyYOXMmXbp0yfPzp6am0rFjR0qWLElAQAByuX5VrwiCILwtI10HoAuhqbG6DiFHQlNjKW+RNxuLxsbGZpo9y5hNMzU11SZmLVq0YMyYMXh4eGBhYRhr7ARBKJyUGrXeJm0AGiRCU+OobFksywCbTCZDo9HoKDL9Z2xszM8//4y/vz9t2rTJ888bMzMz/vnnH95//32GDx/Ob7/9JqpCBEEoFIpc4iZJEvdSovX2ZiCDhudxljN30H7gqFQqZs2aRbt27ahVq1a2x6Wnp3P9+vUss2jR0dF4enpqk7Ru3brh7e1NsWLFCvLLEgRByBFDHmCTy+UUwWKWXGnevDl169Zl9uzZfPPNN3l+fktLS7Zv307r1q0ZM2YM8+fPF8mbIAgGr8glbk+VyagMZCRUpdHwTJmMk4kloaGhfPDBB1y+fJmEhARq1KjBgwcPsqxDu3PnDuXKldMmaIMHD8bb25ty5cqJchFBEAyCIQ+wwfPETcy4vdkPP/yAj48P/fv3p0KFCnl+fmtra3bt2kWLFi2YOHEis2fPFsmbIAgGrcitcbuaGMGDlBhdh5FjZc3tufDPPoYMGUJqaiqSJGm7NdrY2GRZh1a1alXMzMx0HLUgCMLbi0pP4kJcGGo9T9wAFMioaVsKJ5P/Nn7ev38/s2bN4sCBAzqMzDDMnj2bEydO5GsHzmfPntGsWTM+/PBDpk+fnm/XEQRByG9FYsYtNDSUfv36ERERQYpGReu+3eg0pB8ACTGxzB48jsjQRzi7lWTisp+wtrPN0+vfuhjMgT+3MOy7ya98TcTDR3zdZxi/HM384fUkIYa+fftmekwul3P37l0cHBzyNE5BEAR9EJmeaBBJG4Aaicj0xEyJmyiVzLmxY8cSGBjI9u3b6dChQ75cw9HRkX379tG0aVPMzMyYOHFivlxHEAQhvxWJ2jkjIyN++OEHrl69yg+71rE9YC0Pb9wG4K+FS6neuD5LT++heuP6/LVwaZ5fv5KP12uTttdRGslo0KABM2bMoGPHjlhYWBAXF4elpeWbDxYEQTBAMcpkXYeQK9EvxStKJXPO1NSUhQsXMnr0aFJTU/PtOi4uLhw4cIA//viD+fPn59t1BEEQ8lORSNyKFy9OjRo1SFYrsbSywq1yBZ49iQDg390HadmjEwAte3Ti3125K23pWrYmf0z/nuHvdWBSVz9uXLjMxM798K/Vin93HwTg8okzTO89DIC4p9FM7ubP8Pc6sGDsFAbUaE7cs+elm2q1hoXjpjL8vQ5M6T6QtJRUjm/bzaVLl1i1ahUPHz7kyZMnXLt2DVNT07z65xEEQdAbkiSRqEpn/ujJ9PJoyCeNO2Z6PiEmlsnd/Blctw2Tu/mTEBuXq/P71WzBhI59Mj02slmXLNfJjURVeqYZNtFVMnfatGlD9erV+f777/P1OiVKlODAgQMsWLCA3377LV+vJQiCkB+KROKWIUmdTkToI+5eCaFKzeoAxEY9w8HFGQB752LERj3Lctyz8Ei+6jkk23OmJidT/b26/HpsOxZWlqyatYCZf/3BlOU/s3rOz1lev3beYqq/V49fj22nYcc2RIU90T73+O4D2vv14tdj27G0teHE9r00/qAd1Wv4smbNGi5evIiNjQ3u7u558c8hCIKgd5LVSmRAy487883637M8nxdVEsmJSUQ9ev7e+/DmnXcNGRmQrFFq/y5KJXPvp59+Yv78+dy/fz9fr1O6dGn279/Pt99+S2BgYL5eSxAEIa8VqcQtPjGeGX6fMnjGRCysrbI8L5PJIJuOU46uzny9LusNBICRiTE1m78HQBn3yng1qI2RsTFlPSoTGfooy+uvnr5A487vA1Cr+XtYvbCezrV0SSp4P0/KKlbzIDL0EZKEgaz0EARBeHdJ6nRkMhle9WtjbWeX5fl3rZIAeK9TW47+swuAI5t20KTL+9rnIh4+YkLHPoxq8SGjWnzItTNBAJzcsY9JXf2QJInoiEgG12tLdEQU8PyzI0mVrj2HKJXMvTJlyjBmzBjGjRuX79eqUKEC+/fvZ/LkyaxduzbfrycIgpBXikziplQqGfRxX5p160jDDq21j9sVcyQ6IhKA6IhI7Jxy1/DDyMhY215YLpdjbGKi/bNapc7VuYxNTbR/lisUz4+XgSRSN0EQigg1mtfOVr1rlQRAww6tObljHwBn9h6mbptm2udsnRyY+dcfLDywiS+W/siSyd8C0KB9K+ydi7E9YC0Lx02j94RPcXB5vg+mJD2PO4MolXw7n3/+OZcuXWLPnj35fq0qVaqwd+9exo0bx99//53v1xMEQcgLRSJxkySJgQMHUqlqFboO88v0XN02zdm/YQsA+zdsoV7b5vkai0cdX45teT7Se+HQCRLftD5DAitraxISEvI1LkEQBH2gkaTntYc58DZVEgDW9nZY2dlwZPMO3CqXx9TcXPucWqVi4bipfNLkA2YNHEvoC6WUw2ZN5q8Fv2NsYkLTD9u/EMj/4/4/USr5dszMzFiwYAGffvopaWlp+X49Ly8vdu3axSeffML27dvz/XqCIAjvqkgkbidOnGDVqlWcOHyUT5p1ZmSzLpzdfwSA7qMGcfHISQbXbcPFIyfpPmpwluPfNHqbG73GjyDoyEk+adyR49t2Y+/shIXVqztEymTQs28fhg0bho+PDykpKXkShyAIgj6Sy2SvrQ9/1yqJDI07tePXiTNo0qV9psf/+W0FdsWcWHToHxbs+wtl+n9r1549jkAmlxMb9SzzjJr0/7gzvgZRKvnWOnToQJUqVfjpp58K5Hq+vr5s27YNf39/9u3bVyDXFARBeFtFYh+3Ro0aIUkSSap0jsfcy7Q/kI2DPd/9/foFyq8bvf37/nntn3tPGJntc9Ua1qFawzoAWNpYM2PDUhRGRoScDeJmUDDGpia4lC6ZaQ+3riP8geezhT26d8f/4965+IoFQRAMkwL585m0V8xYZVRJfDRq8DtVSdRv34roiChqNGtIdHiU9vGkhAScirsil8vZt+EfNOrnJe9qlYr5YyYz4bd5HPjzHzb/ulz7Pi2TPY87gyiVfDfz58+nbt269O7dGzc3t3y/Xp06ddi0aRMffvghf/31F02aNMn3awqCILyNIjHjlsFCYazz1WKRjx4zpvVHjGzamSWTv2PUj9+89vUSYCE3LpjgBEEQdMxSYYIkScwZ+hmfvf8xYbfv0696U/as2QjkXZWEhZUl3UcN1q5LztDerycHNvzDyKadCb11FzMLCwA2zF+CZ92aeNaryaBvJrJ3zUZtR0q1RoOF4r/3aVEq+W4qVKjAJ598wvjx4wvsmo0aNWL9+vV069aNkydPFth1BUEQckMmFbFPl+Mx94hX5X/tfF6xMTKlkX05XYchCIJQICRJYs/Tm2h0PsyWc+mpaQz0aY6Pjw++vr7Y2dmxZs0arly5gpFRkShsyXPJycl4eHjwxx9/0KJFiwK77u7du+nXrx87d+6kVq1aBXZdQRCEnChyidvVxAgepMToOowcK2tuj4eVi67DEARBKDCGOMBWMc2cixcvcvHiRQ4dOsSRI0dQKBR4eHhoEzofHx+qVauGlVXW7WiErDZv3szkyZO5dOkSxsYFV3myZcsWhg4dyp49e6hevXqBXVcQBOFNilziFpWexIW4sEzr3PSVAhk1bUvhZPLq5iWCIAiFjaEPsF2+fJk+ffpw8uRJrly5QlBQkDapu3r1KqVKlcLHxydTQufq6qrDr0A/SZJEu3btaNWqFZ999lmBXvuvv/5i1KhRHDhwAA8PjwK9tiAIwqsUuRoOJ2MLjORy1Jrc7bGmC0ZyBY7GFroOQxAEocCkp6dz90IwxlVLosnhtgC6pECGs0nmGbSM5iRWVlbUr1+f+vXra59TqVTcuHGDixcvEhQUxLx58wgKCsLY2FibxGUkdBUrVkQuL1JL0TORyWQsXLiQBg0a0KtXL4oXL15g1+7evTtpaWm0bt2aQ4cOUalSpQK7tiAIwqsUuRk3gLvJz7iZ9FSv11DIkVHZ0onyFo66DkUQBCHfXbp0icDAQNasWYOXtzcT1/2C2gByFlO5Ec0dKjzvhPl/V69e5aOPPuLq1as5OockSYSFhWln5TJm6KKiovD29s6U0Hl5eWH+wr5zRcGXX35JaGgoq1evLvBrL1u2jBkzZnD48GHKlRPrzQVB0K0iN+MG4GZmx82kp7oO443czOx0HYIgCEK+iY6OZu3atQQGBhIVFcWAAQM4ffo05cuXN5gBtnLm9pmSNsj9Pm4ymQw3Nzfc3Nzo2LGj9vHY2FguXbrExYsXOXnyJIsXL+bmzZuUL18+U5mlj48Pjo6Fd5BvypQpuLu7c/ToURo3blyg1x40aBCpqam0aNGCo0ePUqpUqQK9viAIwouKZOJmLFdQysyWsNQ4vbwpkCPDzcwWY7lC16EIgiDkKbVazf79+wkICGDPnj20a9eO2bNn07x5cxSK/97zDHmALa/2cbOzs6NJkyaZ9hVLS0sjJCREOyu3detWLl68iK2tbZZ1c2XLls2SVBoiS0tL5s2bx8iRI7lw4UKBd+ocOXIkaWlpNG/enCNHjhRoyaYgCMKLimSpJIBa0nA4+i5pGpWuQ8nCVG5EU4fyKGQGUCckCIKQA7dv32b58uWsWLECV1dX/Pz86NmzJ/b29q88JjghXO8H2DytszYVuXnzJh06dODmzZsFEotGo+H+/ftZSi0TEhK0yVxGQufu7o7JS3vXGQJJkmjZsiWdOnVi1KhROolh5syZrFu3jsOHD1OsWDGdxCAIQtFWZBM3gGhlMmdiQ/XqpkCOjDp2bjiIpiSCIBi4pKQkNm7cSEBAACEhIfTp0wc/Pz+8vb1zdLyhDrDdvn2btm3bcvv2bR1E9p+nT59qk7mMhO7evXtUqVIlU5ll9erVsbW11WmsOXHt2jWaNGlCcHAwLi662SZnypQp7NixgwMHDuDg4KCTGARBKLqKdOIG+jWiK0dGKTNbvLIZwRUEQTAEkiRx6tQpAgIC+Pvvv2nUqBH+/v60b9/+rWZ6DHGA7c6dO7Rq1Yq7d+8WcGRvlpKSQnBwcKYtCi5fvoyLi0uWUsuSJUvqXanl+PHjefbsGYGBgTq5viRJjB8/nmPHjrFv3z6DSHgFQSg8inzippY0nI59SLwqTac3BnJk2BiZUteutCiRFATB4Dx+/JhVq1Zpb6j9/f3p27dvnqwHMrQBtnv37tG8eXPu3btXgJG9PbVaze3btzOVWQYFBaHRaLKUWlauXLnA15i9KD4+Hnd3dzZu3Jhpm4WCJEkSI0eO5OLFi+zZs0dsqC4IQoEp8okbgErScCrmAUnqdJ3cGMiRYakwob59GYxE0iYIgoFIT09n27ZtBAYGcvLkSbp27Yq/vz/16tXL05majAG2WGUK6HAGKKcDbA8ePKBx48Y8ePCgAKPLe0+ePMmybu7Ro0d4enpmKrWsVq0alpaWBRbXmjVr+PHHHzlz5kymhjYFSaPRMGTIEO7cucOOHTuwsBDLGwRByH8icfs/laThjA5m3jJuBOrYlRZJmyAIBuHy5csEBASwdu1aPDw88Pf3p2vXrvl6866SNGy5eRYTa0sUxgU/45ObAbaHDx/SsGFDQkNDCyi6gpOQkMDly5czJXTXrl2jdOnSWbYoyK91aJIk0aRJE3r27Mnw4cPz5Ro5oVar6d+/P1FRUWzduhVTU1OdxSIIQtEgErcXqCUNIYmRBVaSk1Fy427lLMojBUHQazExMdo91yIjI+nfvz8DBgygQoUKBRZDq7ZtGPPLHBTW5no9wBYWFka9evUICwsrgOh0T6lUcuPGjUzr5oKCgjAzM8uybq5ChQrI5e/+eXf58mVatmzJtWvXcHJyyoOv4u2oVCp69uxJWloaGzduNMiOnYIgGA6RuGUjWplMUPxjlBp1vtwcyJFhLFfga1NCdI8UBEFvqdVqDhw4QEBAALt376Zdu3b4+fnRokWLAi9Ri42NpXTp0jx+8oT7mgS9HmB7/PgxtWrV4vHjx/kcnf6SJInQ0NBMZZYXL17k2bNnVKtWLVNC5+npiZmZWa6vMXr0aFJSUvj999/z4SvIOaVSSdeuXTE1NWXdunU6XQMoCELhJhK3V1BLGq4nRhKaGgeQJzcIcp6vzXAzs6WqmGUTBEFP3blzR7vnmrOzM/7+/m/ccy2//fnnn6xYsYIdO3YA+j3A9uTJE3x9fQkPD8/zuAxdTEwMly5dypTQ3bp1iwoVKmQqs/Tx8Xlju/3Y2Fjc3d3ZunUrtWvXLqCvIHtpaWl06tQJJycnVqxYobO1d4IgFG4icXsDpUZNaGos91KiUWk0qN/iBkGBDCO5nHLmDriZ2WEsF2/ogiDol6SkJP7++28CAgK4du0avXv3xs/Pj2rVquk6NAD69+9P3bp1+eSTT7SP5ccAmzItHYWRgnKWjm89wBYREUG1atWIiIh453iKgrS0NK5evZppz7lLly5hZ2eXZd1cmTJlMjW+Wb58Ob/++iunTp3KkxLMd5GcnEyHDh0oX748v//+u87jEQSh8BGJWw5JksRTZTJR6YlEK5NJVKUjA2QyGZIEyADpecMzSZKQACsjExyMLXA2scLR2ELv9sMRBKFokySJf//9V7vnWoMGDfD396dDhw56tVZHo9Hg6urK2bNnKVOmTJbnlRo1lx7fJdpEgyTjnQbYFFFJDOvai0sXgt662URUVBQeHh5ERUW91fHC8//ze/fuZSm1TEpKylRmWa1aNYYNG8bgwYMZOHCgrsMmMTGRtm3bUr16dRYtWiQ+9wVByFMicXtLkiSRrFGSpEpHjQaNJCGXyVAgx9LIBAu5sXjDFgRBLz158oRVq1YREBCAJEnaPddKlCih69Cydfr0aQYOHEhwcHC2z9+6dQsvLy8+6NSJX1YHvvMAW7t27ejcuTNDhw59q3ifPn1KlSpVePbs2dt+ycIrREZGZim1vHv3Lmq1mh49elC3bl1tQmdjY6OTGOPi4mjVqhXvvfce8+bNE/cCgiDkGZG4CYIgFAHp6els376dwMBAjh8/rt1zrX79+np/Yzlt2jTS0tKYM2dOlueuXbtGw4YNiY2NpXPnzmzevFn73NsOsJ06dYqePXty8+bNt5p5jI6OpmLFikRHR+f6WCH3kpOT6du3L8+ePcPd3Z2goCCCg4NxdXXNVGbp6+tL8eLFC+T7PSYmhubNm9O+fXtmzpyZ79cTBKFoEImbIAhCIXblyhUCAgJYs2YNHh4e+Pn50a1btwLdMPld1axZk59++onGjRtnevzSpUs0adKEuLjna9x8fX25cOFCnlyzdevWfPTRRwwaNCjXx8bGxlK2bFliY2PzJBbhzaKjo3F3d2f37t34+vqiVqu5detWli0KgCzr5ipXrpwvzUSioqJo2rQpPXv2ZMqUKXl+fkEQih6RuAmCIBQyMTExrFu3jsDAQMLDw7V7rlWsWFHXoeXakydP8PT0JDIyMkub9REjRrB06VJUKhWSJFGsWDEiIyPz5LonTpygb9++3LhxA2Nj41wdGxcXh5ubG/Hx8XkSi5AzS5cuZfny5Rw7dizbxiCSJPHkyZMs6+aePHmCl5dXpoTO29sbC4t3364nPDycJk2aMHjwYMaPH//O5xMEoWgTiZsgCEIhoFarOXjwIAEBAezatYu2bdvi5+dHy5YtDbo1+R9//MG+fftYv359ts8fP36cli1bYmtrS1xcHCkpKXlWCteyZUt69eqFv79/ro5LSEigRIkSJCQk5EkcQs6o1Wrq1avHp59+Sr9+/XJ8XHx8PJcvX86U0IWEhFC2bNlM2xP4+vpSrFixXMcVFhZG48aNGTduHCNHjsz18YIgCBlE4iYIgmDA7t69y/Lly1m+fDnFihXT7rn2pj2wDMWHH35Ily5d6Nu3b7bP//zzz5w9e5YVK1YQGRmJi4tLnl376NGj+Pn5cePGjVxtqpyUlISzszNJSUl5FouQM2fOnKFz586EhIRga2v71udRKpWEhIRkKrO8ePEiFhYWWUoty5cv/8bW//fv36dJkyZMnTr1rcpvBUEQQCRugiAIBic5OVm751pwcLB2z7Xq1avrOrQ8lZaWhouLC7du3XrlTEf9+vX56quvaNu2bb7E0KxZMwYMGED//v1zfExycjKOjo6kpKTkS0zC6w0ePBgrKyt++umnPD2vJEk8fPgwy7q5mJgYqlevnimh8/T0zLKdxK1bt2jWrBmzZs165UAEwIEDBzh9+jRt27bF19dX75sHCYJQcETiJgiCYAAy9lwLDAxk48aN1K9fX7vn2tvuN6bv9u/fz9SpUzl16lS2z9+5c4cGDRrw6NGjXM2I5cahQ4cYOnQo165dy/E1UlNTsbOzIzU1NV9iEl4vKioKT09PDhw4gLe3d75fLzo6mkuXLmVK6G7fvk2lSpUylVlWr16d8PBwmjdvzoIFC/joo4+yPd+4ceO4cuUKnp6eTJkyBScnJ1QqFTKZzKDLngVBeHf580knCIIg5ImMPdcCAwPRaDT4+fkRHByst3uu5aUdO3bw/vvvv/L5devW8dFHH+Vb0gbQtGlTXF1dWb9+PX369MnRMTKZDI1Gk28xCa9XrFgxpk+fzsiRIzl8+HC+z1g5ODjQrFkzmjVrpn0sNTWVq1evamfl/v77by5duoSjoyPu7u74+/tz8eJFvvnmm0zfv+PGjWPfvn1Ur14dDw8PrK2tATK9Rq1Ws3fvXurXr4+dnV2+fm2CIOgXMeMmCIKgZ9LT09mxYweBgYEcO3aMrl274ufnR4MGDYpU2VTlypVZv349NWrUyPKcJEl4eHgQEBBA/fr18zWOAwcOMGLECK5evZqjGQ+lUom5uTkqlSpf4xJeTa1WU6tWLSZMmEDPnj11HQ4AGo2GO3fucPHiRXbt2sU///xDREREpq6l27dvZ9asWchkMsaOHUu7du3o2LEjJUuWpG3btvTq1Ytr164xb948AgICdPjVCIKgC69fTSsIgiAUmODgYMaNG4ebmxvz58/nww8/JDQ0lGXLltGwYcMilbTdunWLxMREfH19s33+4sWLpKWlUa9evXyPpXnz5jg6OvLnn3/m6PVyuRwxJqpbCoWCRYsW8fnnn+tNd0+5XE6lSpXo3r07AQEBHDlyJMs6SCMjI2rVqsUXX3yBqakpFhYW/P333/Tv35/z588TFxfHTz/9xJYtWxg1ahTp6ek6+moEQdAFUSopCIKgQ7Gxsaxbt46AgACePHnCgAEDOHHihEHuuZaXEhISGDNmzCuT1bVr19KrV68CSWZlMhlfffUVY8aM4aOPPnrjrJsoldQPDRs2pEWLFsyYMYO5c+fqOpwsvL29UavV2r9LksTt27cxMTEhOjoaDw8P9u3bxx9//IFMJsPKyoqnT5/SsWNHihUrxqeffoqJiYkOvwJBEAqamHETBEEoYBqNhn379tGrVy/Kli3L4cOHmTlzJg8ePGDmzJlFPmkDqF69OmPHjs32OY1Gw7p16+jVq1eBxdOqVStsbW35+++/3/jajGRSzLrp3ty5cwkMDCQkJETXoWTrxUGAjC0IjI2NSU1N5fHjx5w6dYovvvgCX19fLCwsUCgU3Lhxg+rVq1O8eHFt4hcWFsbEiRNZv349N27cyJQQCoJQeIgZN0EQhAJy79497Z5rjo6O+Pv78/PPP+Po6Kjr0PSOQqF45czWsWPHcHJywsPDo8DikclkTJs2jc8//5xu3bq9dt8umUyGTCZDkqQiVd6qj1xcXJgyZQqjRo1i7969ev3/YWJiwrhx40hOTiYiIoI6derwxx9/EBwcjKOjIy4uLtjZ2REaGkrHjh0BtN+HkiRhZWXFX3/9xeTJk4mIiMDb2zvTfnPe3t6Ym5vr8ksUBOEdieYkgiAI+Shjz7XAwECuXLlCr1698PPzw8fHR9ehGaxp06ZhZWXFhAkTCvS6kiRRt25dJkyYQLdu3V77WoVCQVpaWr52vBRyRqVS4evry1dfffXG/zd9o1aruXXrFo8fP8bU1JSGDRvSu3dvEhISWLp06Ss3nI+Li+PSpUuZ9pu7ceMG5cqVy7KBuJOTUwF/VYIgvC2RuAmCIOQxSZI4ffo0gYGB/PXXX9SvXx8/Pz86duxYaPdcy0sajUY7a/UySZL45ptv8Pf3x83NrcBj2759O5MnTyYoKOi1s27GxsYkJydn6hgo6M6RI0fo27cvISEhWFpa6jqcdxYeHk6xYsVyta9beno6ISEhmfabu3jxItbW1tokLiOpK1eunF7PTgpCUSUSN0EQhDwSHh6u3XNNpVLh5+dHv379KFmypK5D01tPnz5lwYIFzJgxg+PHj9OoUaNMz2d8RGXcRCqVSr7++mtmzpxZ4LFmxFO7dm0mT55Mly5dXvk6U1NT4uPjRaKuR3r16kW5cuX49ttvdR2K3pAkifv372tn5TKSubi4OKpXr55pZs7T01M0QxEEHROJmyAIwjtQKpXaPdeOHj3Khx9+iJ+fX5Fr3/8uYmJiSE1NpXfv3kiSROnSpWndujWtW7emWLFimV6rVCpZvXo1fn5+OooWtm7dyldffcWFCxde+X9sZmZGTEyMWFOkRx4/fky1atU4deoUlSpV0nU4r6VWq0lKSsLKyuq1M7v55enTp9pSy4yE7u7du1SuXDlTqWX16tXFJuCCUIBE4iYIgvAWgoODCQwMZPXq1VSpUgU/Pz+6d++OlZWVrkMzaGq1mrNnz7JhwwYuXLhA3bp1mThxIg4ODgBcunSJUqVK6bShiyRJ1KhRg6+//poPPvgg29dYWFjw9OlTLCwsCjg64XW+//57Dh48yM6dO/V+YOWvv/7ixo0bjBs3Ti++j1JSUggODs60bu7KlSsUK1YsU5mlj48PpUqV0vt/X0EwRCJxEwRByKHY2FjWr19PQEAAjx8/pn///gwYMEDvR+8Nwa+//sr169e1HfMyZtT8/f0ZNGgQDRo0QKVSsXr1agYMGKDbYIHNmzczc+ZMzp07l+0NqpWVFeHh4SKR1zPp6elUr16d2bNn06lTJ12H80azZ89mxYoVHD58+JWNSHRJrVZz586dTGWWQUFBqFSqLOvmqlSpIpr1CMI7EombIAjCa2g0Gg4dOkRAQAA7duygdevW+Pn50bp161w1BhCySkxMxMrKiocPH9K/f3+2bNlCeHg4GzZswNvbm86dOxMcHEzFihUxMzMjNTWVgwcP8v777+s6dDQaDT4+PsyaNYv27dtned7a2ppHjx5hY2Ojg+iE19m/fz+DBw/m2rVrBlHKOn36dDZt2sShQ4cMZuuQ8PDwLOvmwsLC8PDwyLRurlq1amJwQxByQSRugiAI2bh//752zzV7e3v8/f3p1auXwdw4GYKVK1eyfft2jI2NMTMz448//gBg586drFq1inXr1mV6fVRUFJaWlnpRNgawceNG5s6dy+nTp7PMutna2vLw4UNsbW11FJ3wOt27d8fT05Pp06frOpQ3kiSJL7/8kn379nHgwAGDXVOWkJDAlStXMiV0V69exc3NLcsWBa6urroOV3gLkiSRrFaSpE5HjQaNJCGXyVAgx1JhgoXCWJTQviORuAmCIPxfcnIymzZtIjAwkMuXL9OzZ0/8/Pzw9fXVdWiFUkJCArdu3eLWrVvaJM3CwoLw8HBGjBhB165dUalUGBkZodFoOHLkCM2aNdNx1P/RaDRUq1aN77//nnbt2mV6zt7enrt372Jvb6+j6ITXefjwIb6+vpw9e5by5cvrOpw3kiSJMWPGcObMGfbu3Yu1tbWuQ8oTKpWK69evZyqzvHjxIiYmJlnWzVWsWFEnjVqEV5MkiafKZCLTE4lRJpOoSkfG8y7AkiSBDJD++7sEWBmZYG9sgbOJFU7GFiKRyyWRuAmCUKRJksSZM2cICAjgr7/+ol69evj5+fHBBx+IVu4FQKVScfHiRdzc3EhLS+Ps2bNcuXKFcePGZSozTExMJCQkhNq1a+sw2qw2bNjATz/9xKlTpzLdgDg4OHDr1i0xQ6vHvvvuO06fPs2WLVt0HUqOSJLE8OHDuXbtGrt27SoU+9FlR5IkwsLCsqybe/r0Kd7e3plm5ry8vAyi3LWwUWrUhKbGci8lGpVGg5rcpxIKZBjJ5ZQzd8DNzA5juVh6kBMicRMEoUiKiIjQ7rmWnp6u3XOtVKlSug6tSLl+/Trr1q3D2dkZe3t7ypcvT6lSpbL8P6SlpSGXy/VuQ2u1Wo23tzfz58+ndevW2sednJy4fv06Tk5OOoxOeJ20tDS8vLxYsGCBXqybzAmNRoO/vz9hYWFs27atSCUtsbGxXLp0KVNCd/PmTcqXL5+l1FIMmOQPtaQhJDGSsNQ4ADRvkbC9TM7zAa9SZra4WzmjkIlZ1dcRiZsgCEWGUqlk586dBAQEcPToUbp06YKfnx+NGjUS5Ro6otFouHPnDg8ePOD06dNcu3aNQYMGZSmJvHXrlt5271y7di2LFy/m+PHj2u8jZ2dngoODcXZ21nF0wuvs2rWLTz/9lODgYMzMzHQdTo6o1Wr69OlDfHw8mzdvLtKbYqelpXHt2rVMZZaXLl3C1tY2S6ll2bJlxfv8O4hOTyYo4TFKjTpPEraXyZFhLFfga1MCB2P9WMesj0TiJghCoXf16lXtnmuVKlXC399f7LmmJwIDA6lWrRpVqlTBysqKXr168dVXX1GlShUkSUImk5GcnMyTJ0+oUKGCrsPNllqtxtPTk8WLF9OiRQsAXFxcuHTpkmiyYAA6d+5M7dq1mTx5sq5DyTGlUkmPHj2A5+W6+jYTrUsajYZ79+5lWTeXmJiYZYsCd3f3Ip345sSLs2z5kbC9TI5MzL69hkjcBEEolOLi4rR7roWFhWn3XKtcubKuQxP+Ly4ujj///JOIiAiSkpKIjY3lypUrHD9+PNPrUlNTMTU11evR8tWrV/P7779z5MgRZDIZxYsX58KFCxQvXlzXoQlvcO/ePWrXrs2FCxcoXbq0rsPJsfT0dLp06YKNjQ2rV68W25O8QVRUlDaZy0jo7t+/T5UqVTKVWVavXl10g/0/laThTOxD4lVpBZK0ZZAjw8bIlDp2pTESyVsmInETBKHQyNhzLTAwkO3bt9OqVSv8/f1p1aqV2PhVj2g0GuRyOceOHcPa2hpnZ2fu37+PlZUV6enp1KpVS/sagJiYGL3vzqhSqXB3d2fp0qU0bdqUkiVLcubMGUqWLKnr0IQc+Prrr7ly5QobN27UdSi5kpqaSseOHSlZsiQBAQGi62IuJScnExwcnGnd3JUrV3Bxccmybq5kyZJ6PXiU11SShlMxD0hSpxdo0pZBjgxLhQn17cuI5O0FInETBMHgvbjnmp2dnXbPNdEYQr917dqVwMBAbt26xYIFC2jZsiX9+vXL9BqVSkVsbKxB/F+uWLGC5cuXc+jQIUqVKsWpU6dwc3PTdVhCDqSkpODp6cmSJUto1aqVrsPJlaSkJNq1a4e7uzu//fZbkUou8oNarebWrVuZyiyDgoKQJCnLurnKlSsXykFBtaThtA5m2l6WMfNW1660KJv8P5G4CYKgl16ccclOSkqKds+1ixcv0rNnT/z9/cWeawbiyZMnvP/+++zdu5fhw4fz888/M3DgQDZv3pxpG4bExESDWYuoUqmoUqUKgYGB9OnTh+PHjxtU6V1Rt3XrViZMmMDly5cNbt1TQkICrVu3pk6dOsyfP18kb3lMkiSePHmSZd3c48eP8fT0zDQzV61aNYPfqiE4IbzA1rS9ScaaNy9rsV4YROImCIKekCQJSZIyJWsRERGcOnUKX19fypQpAzwfDZ01axY//fQTderU0e65Zigd4Yq6jIYjSUlJzJ49m/j4eGrXrk3t2rUZMmQIR44cyZS0p6enG9RNdEBAAGvXruX27dscPnyYsmXL6jokIYckSaJDhw40adKECRMm6DqcXIuNjWXixIksXLjQoH5mDFlCQgKXLl3KlNCFhIRQunTpLKWWLi4uug43R6LTkzkTF6oXSVsGOTLq2LmJbpOIxE0QBD2UkpLCvn37+OKLLxg1ahQ9evTAwcEBeD6rcfnyZZydncWeawYoIynz9/fn6dOneHl5UaVKFR4/fkyNGjVo06ZNpsQtOTkZCwvD+bBWKpVUrlyZtLQ0jh8/Tvny5XUdkpALt2/fpl69ely6dMkg1ydmDIy8SK1WaxuXvKmSQXh3SqWS69evZ5qZu3jxImZmZllKLStUqKBX/x9qScPh6LukaVS6DiULU7kRTR3KF/mSSZG4CYJQ4LKbXXv27Blff/014eHhjB07lkOHDlGvXj2cnZ2xtbXF1dVVtLwuJJRKJd26dWPDhg08fPiQW7ducefOHfr164ednZ32dYaWtGVYunQpo0eP5sqVK3q7hYHwalOmTOHOnTusW7dO16G8M5VKxdatW7l9+7Z2FvHFRE4oGJIk8fDhwyzJXHR0NNWqVcuU0Hl6euqsgkSfSiRfJkeGm5ktnkW8ZFIkboIgFIjsRoKTkpK4du0atWvX1paXjR49GltbW65cucKxY8d48OABNjY2AEyePDnb8wiG5cqVKwwcOJA+ffrQvHlzKleunG1pl6HeYKanp2NpacnatWvp3r27rsMRcik5ORl3d3dWrFhB06ZNdR3OW0tPT2fv3r0sX74chUKBo6Mjv/zyi67DEl4QHR2tLbXMSOhu3bpFxYoVM5VZ+vj4aKtO8otSo+bAs9t6mbRlkCOjhWNFjOWG97mQV0TiJghCvtJoNMhksizJ1vz589mwYQPOzs4MHz6coKAg7OzsOH/+POXLl6devXo0b96cx48f88MPP1CnTh3thrOCYYuKiuLEiRPcv3+fpKQkwsPD6dy5s3bz6gwqlcpgO7a5uLhQpUoVjh49qutQhLfw999/89VXXxEUFGSQM/2pqans2LGDy5cv0759e+rUqUOzZs34/vvvqVWrFmC4AyOFXWpqKlevXs20bu7SpUs4ODhkWTdXpkyZPBvIvJv8jJtJT/U+cats6UR5C0ddh6IzInETBCFfvLyWIiwsjN27d1O3bl28vb2ZOXMmXbp0wdramnXr1uHr60uTJk2Iiorixo0bHD58mPLly7NlyxaqVavGF198YfCduoTMlEol0dHR3Lhxg0qVKlG8eHHtjKqhNSV5WZUqVYiPj2fLli3UqVNH1+EIuSRJEm3atKFdu3aMHTtW1+HkWnh4OD/88APdu3fH29ubLVu28NNPP9GmTRuePn0qZt4MjEaj4e7du5nKLIOCgkhJScmybs7d3f2Vgw3JycmsWrUKf3//TK+RJImD0bdJ06gL6kt6a6ZyBc0dKhbZyhuRuAmCkGfOnj3L+fPn6dy5M66urkiSRHx8PIsXL+bMmTPa0cGOHTuyY8cORo0aRdmyZfnuu++0o4dr1qzh77//ZvHixdSpU0dbJikULmlpacTFxVGsWLFsP4ANebYNwN3dnW7duhEUFMT27dt1HY7wFq5fv06jRo0IDg7G1dXw1tXExcVhZmbG+vXrgef7XbZt25Zly5bh4eGhTUhF+bnhioiI4NKlS5kSugcPHlC1atVMM3PVq1fHxsaGPXv20K5dO3x8fNi2bZu2AU9UehIX4sJQ6/FsWwYFMmralsLJpGgO5Bbt1iyCIOQJjUYDgJOTE8nJyYSFhREWFsa3336Lubk5jx8/pkmTJixYsABvb28iIyNRKBTs3r2ba9euce3aNaytrTEzM6NWrVpcunSJli1bapM2tVqNGGMqXP755x/8/f2z3DBqNBoSExNRq/V/5Pd15HI5Xbp04eLFi5w/f17X4QhvoWrVqgwcONAgtwYAsLW15fHjxzx79gx7e3vq1avH+vXrWbp0KZ6enty5cwdAJG0GzMXFhdatW/PFF1+wbt06QkJCiIqK4pdffqF27doEBwczfvx4ihcvTsWKFfnss8+QyWRcunQJd3d39uzZA0BkeqJBJG0AaiQi0xN1HYbOiMRNEIRckyRJe2OdURIZHx/Prl27uHLlCtevX6dUqVKMGTMGExMTqlevrt1UuWrVqoSHhzNu3DgsLS0ZNmwYnp6eVKtWjQoVKvDhhx9iZmamTQYBFAqFuLkoZHbs2EH79u2zPL5x40bGjRuXaRNuQySXyzE2NuaLL77gm2++0XU4wluaOnUqBw8e5Pjx47oO5a2UK1eO2rVrs3DhQmrXro2joyOJiYk4ODiwfPlyTp06pesQhTxmaWlJvXr1GDZsGEuWLOH06dPExcWxdetWjI2N0Wg0aDQaEhISaNu2Lb///jsxymTmj55ML4+GfNK4Y6bzHdu6m+HvdaCDiwe3LgbnOh6VUkngjB8YXLcNo1p8yGftPubcgedrf7uWrZntMTuXr+fAhn9eec5oZXKu4ygsRKmkIAh5on///jg7O6NQKFAoFAwaNIhy5coBcP78eVasWEGlSpW4fv06ZmZm/PDDDzqOWNAVtVpN8eLFOXfuHKVLl870XIMGDZg6dSrt2rXTUXR5o1q1aqxatYrKlStToUIFduzYga+vr67DEt7C+vXrmT17NufOnTPY8t2FCxdy7tw5AIYNG8ahQ4coVaoU/fv35+HDh9qfQ9GwpHArU6YMT548wc7Ojvbt29O0aVM++ugjjiQ+5PKpM5hZWvDjyIn8cnSb9piHN+8gl8tZNP4rBk6fQCUfr1xdM3DGD8RERPHpD99gbGpCTORTgk+d5b1O7ehatiZ/3899RYIcGW2cKhfJAV3DfAcSBKFAvdxoJCIigsWLF3Pu3DmGDRuGr68vHh4e9OrVCzMzMwIDA7l16xblypUjPj6emjVrsmvXLm7evImPjw99+vTJdF61Wo1cLi+Sb8JF0dmzZ3FxccmStN29e5fbt2/TsmVLHUWWd+RyOZIkYW5uzoQJE5gxYwabNm3SdVjCW+jRowdLlixhyZIljBgxQtfh5ErG+rVRo0aRmpqKsbEx3333HRUqVODjjz/m+PHjHDhwgG7dulGuXDkWLlxImzZtxCBDIbV8+XKKFy9OlSpVtJ+3Sap0ZIBX/dpEPHyU5ZjSld9+L8rU5BT2rP6LgHP7MTZ93mzK3tmJ9zr9NzC34rv5nN17GBNzU6auWIy9sxNr5i7CzNKCriP8mdi5H+U8q3Ll5Fk0ahWj53+LR43qJGuUWCoMt4HV2xKlkoIgZCFJUqZSRblcTnJyMk+ePAHgwIEDRERE8PXXXxMSEsL69esxMjLi1q1bFCtWjMePH3Pp0iXgedv/iIgIvL29qVixIn369MHc3DzTBtyiFLJoeVWZ5Pr16+nevbtBtl9/mVwu1/4MDRkyhFOnTnH58mUdRyW8DZlMxs8//8zXX39NVFSUrsPJFZlMpl0fbGZmxvnz5/nnn3/o2LEjBw4c4Pz583h5eWFvb8+yZct4/PgxVapU0XHUQn5p1qwZVatWzfR5m6ROz5PP35HNumR57Mm9hxQrWQILa6tsj0lNTqZqzeosOvwPXvVqsWf1X9m+Li0lhUWHNvPJnGksGDMZmUxGkir9nWM2RCJxEwRBK2Pdmkwm0yZVt2/f5p9//qF+/fpMnjyZqKgoUlNTadmyJbVr16Zu3booFApcXV3ZvXs3Y8aM4c6dO9jY2JCWlsbUqVNxcXHB09OT+Ph4bfInErWiK7vETZIk1qxZQ69evXQUVd6SyWTaxM3CwoLx48czY8YMHUclvC0vLy/69OnDxIkTdR1Krr34XlunTh38/f3p378/mzdvply5OZ2qVwAAf3RJREFUcjRs2JBZs2axbNkyvLy8sLCw0H4WiNU0hZ8aTZ78Py86tDnXxxiZGFOndVMAKlb3JCI064wfQJMuzz8vvOrXJjkhiYTYeNRosn1tYSdKJQVB0JbTZKxtSElJYfXq1ezcuZOIiAiaNGnC6dOnmT17NmfPniU1NZW0tDTS0tJITk5GkiR69+5NuXLluHDhAl9++SUuLi7a82s0GipWrMjUqVN19SUKeuLx48fcv3+f+vXrZ3r88uXLJCcn06BBAx1FlrcySiUzDBs2jO+//57g4GC8vHK3RkTQD1999RXu7u6cPn2aunXr6jqcXMsoTR8xYgSVKlUiKSmJ+vXrs3jxYtLS0tixYwc9e/akTJkytGnTBoDIyMhM7+VC4aORJJBBfjSVLF6uNFGPHpOckJjtrJuRkbF2YEGuUKBWvaKb8EsDvTK57HncRZCYcRMEQTs7sGXLFgYOHMiePXtYs2YNX375JbNnzyYlJYWkpCTee+89Hjx4gLe3N+bm5nTu3JnZs2fj4OAAPG8sMXLkSFxcXJAkSXvj+uL6OKFoi4mJ4eDBg1maPKxdu5aePXsWmpnYF0sl4Xmnt88++0zMuhkwW1tb5syZw4gRIwxyu4oXBxNat25NixYt+Oabbzh//jy///47bm5uvP/++1SsWBGAhIQE5s2bh1KpFDNvhZhcJsuXpA3AzMKc1r26smTydyjTn5c2xj2N5tjW3bk6z7F/dgFw9d/zWNhYYWlt/TzuIkjcTQmCQHh4OIMGDeKff/6hdOnSxMXFUb9+feLi4vDy8qJcuXJcunSJunXrcv36ddRqNQMGDODLL79k7969+Pn5ac+VkbDJZLJCcxMu5J3KlSvj4+OT6TGNRsPWrVsLTZkkZC6VzDB8+HAOHz7MtWvXdBSV8K4y1uj+8ccfug7lrbz4nmxjY0OpUqVwc3MjNTWV5cuXc/bsWcqWLcu8efO4efMms2fPxtjYWLyXF2IKnjcGmzP0Mz57/2PCbt+nX/Wm7FmzEYCTO/bRr3pTQs5dZHqvYUz9aFC258lujRtA3y9HY+toz/BGHfmkcUem9xmOhVX2a95excTMhE+bf8jiCdMZ/dNMZLLncRdFYjsAQRBITU3l66+/pnz58gwePJjff/8dmUxGbGwsn3/+OQEBAURFRTFhwgTOnj1LlSpVsLW11R7/ctdJQchORkL/MpVKhVqtNvi9217UoEED5s2bl6X0c/bs2Vy+fJm1a9fqKDLhXV26dIm2bdty69YtrHJ5A6ovXvxZHD16NEqlEjMzM6ZNm8b27dsJCAjgzz//xMnJSceRCvktSZXO8Zh7ersB98TO/bJsQ6BARiOHckWyq6RY4yYIAmZmZjRv3pyTJ0+iVCpxdnbm2bNn3L17l/v379OiRQvUajUymYw6depkOV4kbUJOvGrU3sjIyGD3x3qVl0slM4wYMYIKFSpw/fp1qlatqoPIhHdVvXp1goKCDPp7NmNGWC6Xs2DBAu3jv/32Gzt27OCff/7BxsZGDMoVARYKYz1N2V5NAizkht99+G2In0ZBKGJUKhXbtm1j0aJFJCYmah/38vJCqVRy8eJFPD09sba2ZuDAgZQsWZIyZcpQvnx5HUYtCIYlu1JJAGtra0aPHs23336rg6iEvOLi4oKZmZmuw3gnGQnZs2fPkCSJmTNnsn//fjZs2CCStiJEJpNhZaS/M1ez/1mZZdNvKyOTIlu+a7jDRYIg5Mr169cJDAxk5cqVlC9fniFDhmBpaal93snJCXd3d5KSkqhduzaVKlXSYbRCYZWWloZSqTTYErOcermr5Is+/fRTKlSowM2bN6lcuXIBRybkhZdvGpVKJcbGxqSnp2Nior83wdnZtm0bBw4cwNTUlHXr1mFsbIxGoyEtLQ2VSoW1tbWuQxTymb2xBfGqNF2HkWMOxha6DkFnROImCIVYfHw8GzZsIDAwkHv37tGvXz8OHTqUbYmWsbExvXv3zvTYq9YkCcLb+vfffwkKCqJq1apUrVqVkiVLFooNt1/2qlJJeN4U4tNPP+W7775j+fLlBRuYkOfOnDnDoUOHePr0Kenp6ZlKDw3BgAEDaNeunbbtf8ZM2549e/j66685cOCAtnOwUDg5m1gRlhKrt+vcXqRAhrNJ4R74ex2RuBVRkiSRrFaSpE5HjQaNJCGXyVAgx1JhgoVCdJEyVBqNhqNHjxIQEMDWrVtp0aIFkyZNom3btjlak/Fisia+B4S8ZmFhQYkSJdi5cyd79uzB09OTihUrUq5cOcqUKaPr8PLMq0olM4waNYqKFSty584dKlSoUICRCXkpNjaWXbt2UbduXZydnVm4cCG//vorw4cP13VouZKRtEmSpC2P7NSpE8eOHaNt27bs27cvU0MqoXBxMrbASC5HrdH/bS6M5AocxYybUNhJksRTZTKR6YnEKJNJVKUj4/nNhfTC5osZf5d4XkNsb2yBs4kVTsYW4iZezz18+JAVK1awfPlyLC0t8fPz44cffqBYsWK5Oo/4fxbyU+3atSlRogSrV6+mS5cuqFQq1qxZg5OTE5MmTSo0ZVmvK5UEsLOzY8SIEXz33XcG21pegNWrVxMdHU3btm0BmDlzJuvWrTPYaoUXY5bJZMybN4+RI0fy/vvvs2fPnkJf4lxUyWQyypk7cDPpKRo9nnWTI6Ocub1B/mzlFbHqtJBTatTcTX7GwejbXIgL40FKDPGqNDRIqJFQSRrUSKilzH/XIBGvSuNBSgwX4sI4GH2bu8nPUBrAaExRkpqayvr162ndujW+vr6Eh4ezYcMGLl26xNixY3OdtAlCfspIZA4dOqQdXBg8eDCtWrUiLi6u0CRt8PpSyQxjxoxhy5Yt3Lt3r4CiEvJKxvfye++9x+XLlwE4e/YsQ4YMISYmhh9//FGX4eUZmUzGzz//jLu7Ox07diQ5OVnXIQn5xM3MTtch5IihxJlfxD5uhZRa0hCSGElYahxAnoygyHk+wlHKzBZ3K2cUMpH364IkSVy4cIGAgADWr19PzZo18ff3p3Pnzgbf5Uwo/CRJIikpid9//51ixYpha2vLunXraNKkCcOGDdN1eHmmTZs2jB07VjsT8ypTp04lPDycpUuXFlBkQl7JmFWbO3cuKSkp7N69m88++4xu3brh7u7On3/+ibe3t67DzBNqtZr+/fsTFRXF1q1bC9Wei8J/ghPCCUuN08tZNzky3Mxs8bR21XUoOiXuvAuh6PRkDkff1f7w5dUPYMa5wlLjOBx9l2ilGHkrSFFRUcyfP5/q1avTvXt3XF1dCQoKYu/evXz88cciaRMMgkwmw8rKirJly/Lw4UOePXtGixYt6Nmzp65Dy1NvKpXMMGbMGDZt2sSDBw8KICohP3z++ec4ODjw008/0a1bNwBatGhRqN6TFQoFy5cvx8bGhu7du5Oenq7rkIR84G7ljLFcoeswsmUsV1DVylnXYeicSNwKEbWkITghnDNxoaRpVPk2YqJBIk2j4kxsKMEJ4ail15cDCW9PpVKxfft2unbtSqVKlbhw4QILFy7k9u3bTJ06ldKlS+s6REHIEbX6eZn177//zogRI3jw4AEmJibUqVOHQYMGYWNjo+MI81ZOSiUBHB0dGTp0KLNmzSqAqIS89GITJ6VSyXfffcdff/1FixYtsLKyolKlSoSGhuo4yrxjZGTE2rVrAejduzcqlUrHEQl5TSGT42tTQlthpS/kyPC1KSEqvRClkoWGStJwJvahdv1aQZEjw8bIlDp2pTESP1B5JmPPtVWrVlG2bFn8/Pzo0aNHobu5FYqe1q1bM3PmTJydnTl+/Djnz59n8uTJODk56Tq0PNWhQweGDh1Kx44d3/jap0+fUqVKFS5evIibm1sBRCfkh/Xr13P9+nU+/vhjHB0dmTJlCvfu3WPbtm2FqrQwLS2NTp064eTkxIoVK1Ao9HOGRnh7+lQyKUdGKTNbvIp4iWQGcaddCKgkDadiHhR40gZom5icinmASsy8vZP4+HiWLVtGgwYNaNasGZIkceDAAU6ePMngwYNF0iYYvCdPnmBhYUFqaiouLi58/PHHnD17FnNzc12HludyWioJ4OTkxKBBg5g9e3Y+RyXkh4zZ5I8//phJkyZx6NAhevToQfny5WnWrFmh+381NTVl06ZNPH78mKFDh+ZoZlkwLO5WztgYmep85i1jcsBdlEhqiRk3A6eWNJzWwUzbyzJ+uOralRZT2bkgSZJ2z7UtW7bQvHlz/Pz8aNu2baHclFgoutRqNQqFgvPnz7N//36sra05e/YsZmZm/Prrr7oOL8917tyZAQMG0Llz5xy9PjIykqpVq3L58mVKlSqVv8EJ+SIwMJCNGzei0WhYsGABlStXJi0tjd69exMQEFDoBt8SExNp27Yt1atXZ9GiRUW6RXthlDEpkKRO18n9pRwZlgoT6tuXERVdLxD/EgYuJDFS50kb/DfzFpIYqdM4DEVoaCgzZ86kYsWKjBw5Eh8fH27evMmmTZvo2LGjSNqEQkehUBAaGoq9vT2VKlXSlpJ9++23ug4tX7xpA+6XOTs74+/vz9y5c/MxKiG/nDhxgs2bNzN9+nTKlSuHra0tZ8+epW/fvnh7e2NpaanrEPOclZUVO3bs4OzZs4wfPz7HM8yCYTCSyalvX0YnM28ZkwEiactKzLgZsOj0ZM7Eheo8aXuRHBl17NxwKMK72r9KamoqW7ZsISAggHPnztGjRw/8/f2pWbOmGKkUCi2NRoNcLmfv3r1MmjSJRo0a4eHhgbOzMxUrVsTLy0vXIeaLrl270qtXL7p27ZrjYyIiInB3dyc4OJgSJUrkY3RCflq6dCkHDx7k6dOnjBw5kk6dOuk6pHwVHR1N8+bN6dChAzNnztR1OEIee3F7qYK438xY0ya2ncqeSNwMlFrScDj6Lmka/evqZCo3oqlDefEDx397rgUGBrJ+/Xp8fX21e64VxnU9gvAqv//+O/b29nTv3p09e/Zw8uRJPDw86NGjh65DyxfdunWjR48edO/ePVfHjR07FoCffvopP8ISCkhERAQuLi7av2fs+VZYRUVF0bRpU3r27MmUKVN0HY6QD6KVyQTFP0apUedLAidHhrFcga9NCTH4/xpGug5AeDshiZEoNWpdh5EtpUbN9cTIIr1JYlRUFGvWrCEwMJCEhAQGDBjA+fPnKVOmjK5DE4QCp1ariY6O5vLlyzg5OVG7dm3atGlTqPeCyul2AC+bMGECnp6efPHFF7i6Ft33UEOXkbRJkoRGoyn0nReLFSvGgQMHaNKkCWZmZowfP17XIQl5zMHYgqYO5bmeGEloahxAniRwGWWYbma2VBWzbG8k/nUMkFKj1ps2rdnRIBGaGqe3iWV+UalU7NixQ7vn2vnz55k/fz63b99m2rRpImkTipyMxGXbtm0cPHgQDw8PgoKC+PXXX1mzZg0mJiY6jjD/5Kar5IuKFy9O3759+f777/MhKqGgKZVKfvvttyKx/svV1ZUDBw7wyy+/sGjRIl2HI+QDhUyOp7UrLRwrUtnSCVO5AsVbrn9TIMNUrqCypRMtHCviae0qkrYcEDNu/2vvPgObKt82gF/nJOleFCirBVr2prJklr333lNeZA8RQQRkqCgoW5ygKAVF4M/eS1CggiCyoRRoWaV0z6zzfiitKAVaaPOcJNfvi5YmJxelTXPnvp/nsULhqbGiI2RLeGosAlzyi46R565cuYLVq1djzZo1KFGiBIYMGYJVq1bB09NTdDQioTJGww4cOIC+ffti8ODBiIyMxNmzZ21ys4YnNWzY8KXfrJkyZQqqVKmCd955Bz4+3AbbmkmShJUrV6JIkSLo2rWr6Dh5ztfXFwcPHszsvL3xxhuiI1Ee0MkaBLjkh7+zN6IMyXioT0S0IRmJRj0kpH/fKwoACYACSFJ691kB4KZ1gLfOBT4Obsivc7HpEeK8wDVuVkZRFByMvo40K+hmOcoaNPUubZM/lAkJCfj555+xatUqhIaGYuDAgRg8eDAqVqwoOhqRqhiNRixZsgS//fYb6tSpgzp16iAwMNDm39hISUmBVqt96R1ix4wZAxcXF+4yaQMOHTqEIUOG4OLFi3BxsY+1O9euXUOTJk3w0UcfYcCAAaLjkIUoioJkswFJRj1MMMOsKJAlCRrIcNU6wEXW2eRrQkti4WZlHuqT8GdcBEwqHZN8kgYSanj6ooCDbbyzrigKjh49mnnmWuPGjTF06FCeuUaUhYxz27Zv345Tp06hevXqePDgAW7fvg03NzdMmzZNdERVCw8PR7Vq1XDlyhUULFhQdBx6Rb1790aZMmUwd+5c0VEs5uLFi2jWrBmWLFmCnj17io5DZBNYuFmZC4kPcCslRnSMbCvpnA8V3Qq9+IYqFhERge+//x6rV6+Gk5MThg4div79+3OEieg5MnbR69evH2rVqoWiRYsiPj4eKSkpaNCgAQIDA0VHVL2RI0fCy8sLH330kego9IoiIiJQvXp1nDhxAqVLlxYdx2LOnTuHli1b4ssvv7T5YxGILIGFm5U5FhOGeGPaC28XcT0M84dPyvz4/q1w9H9nLDqPGJStx3lw+w4WjZuG+f9b89JZAcBD64gG+fxf6RoipKamYuvWrVi1ahX++OMP9OzZE0OHDkXNmjXZ5ifKpqioKHTt2hXLli1DtWrVkJSUhPPnz6NixYpwd3cXHU/1bt++jcDAQFy9ehX589v+emFb9/HHH+Po0aPYvn276CgWdfr0abRp0wZr1qxB69atRcchsmrcvsWKKIqCRGP2ts/2Le2P5Yc2Y/mhzViy/xc4OjujXtvmeZzwaYlGvdXsppVx5trYsWPh6+uLr776CgMHDkRERARWrlyJWrVqsWgjeoEnf96TkpLQpEkTLF++HB988AG2bNmCEiVK2EXRdubMGXz66ae4c+cODAYDwsPDc3yN4sWLo1u3bjzTzUZMnDgR169fx7Zt20RHsagaNWpgy5YtGDhwIA4ePCg6DpFVY+FmRZJNhpfadPWvX0+gSEk/+PgVy/Z9ZI0MN6/0zQNuXb6Gia16YkyTLhgd1Al3btzM9nUkAMlmQw4TW1ZUVBSWLFmCwMBAdOvWDQUKFMCpU6ewf/9+9O3blwdlE+XAo0ePMs9nK1GiBN577z3MnDkTtWrVws2bN3Ht2jXBCS1j0KBB8PHxwahRo6DVatG/f/+Xus67776LlStXIjo6OpcTkqU5ODhg6dKlGD9+PFJTU0XHsai6detiw4YN6NWrF44dOyY6DpHVYuFmRZJM+pfq+Pz6v50I6touy8+d2H0QP8xf+tSfFyxWBO99twwAsPP7n9Bx+AAsP7QZi/dtQIEi2T8UVpIkJGWzS2hJRqMRO3fuRPfu3VG6dGn88ccf+OyzzxAaGopZs2ahZMmSoiMSWaWZM2fi66+/zvxYkiQUKlQILVu2xIQJE1C/fn2B6SynVKlSGDBgAOLj4zPPs3uZA7lLliyJLl26YPHixbmckERo2bIlAgMD7XK30KCgIAQHB6Nr164ICQkRHYfIKnGNmxW5lxaPc/H3crSjpEGvx8CqQfj8123I51PgpR738Mbt+GnxF2jaoxPqtW+BYgEls31fDWRU9SiMIo4eL/XYue3q1auZZ675+flhyJAh6N27t81vTU5kCYqioGTJkti1a1fm0Rg9e/bE3LlzUa5cOcHpLKtHjx5wdHTE8ePHUadOHRQsWBCLFy9+qTffbty4gdq1a+P69evw8vLK/bBkUbdu3cJrr72G06dP2+WbhNu3b8ewYcOwe/dublJElEPsuFkRs6Igp7OSpw4cRakqFV+6aAOAxt3aY+aaz+Ho7IT3+4zAX0dPZP/O0uPcAiUkJGDVqlVo0KABGjVqBKPRiH379uHEiRMYMWIEizaiXHLhwgXIsowKFSoAAG7evIlDhw4hICBAcDLLGzFiBDp37oxhw4ahWrVq+Pjjj196jWxAQAA6dOiAJUuW5HJKEqFEiRKYOHEiJk6cKDqKEO3bt8fKlSvRpk0bnD9/XnQcIqvCws2KyJKEnB7f9uvmHc8ck8yuezfDUbikHzoOH4A6rZsh7OKV7N9ZeZzbwjLOXBsyZAj8/PywdetWTJkyBeHh4ViwYAEPyibKAzt27EC7du0yC5R169ahR48ednnO4YoVK3D16lXUrFkTWq0WXbp0gclkeunrvfvuu1i+fDni4uJyMSWJMnnyZPz999/YvXu36ChCdO3aFYsWLUKrVq1w5UoOXlMQ2TkWblZEAzlH79imJiXjzJHfUa9di2fe5llr3J50dOtujGrUAWOadMGty9fQrGf2z2KRpPTclhIREYEPP/wQZcuWxZtvvonKlSvjypUr+N///oeOHTva5QtIIkvZsWMH2rZtm/lxcHAw+vbtKzCROGlpaXjrrbfQsmVLvPXWW5BlOXPTlpdRpkwZtGnTBsuWLcvFlCSKk5MTlixZgnHjxiEt7cVH/NiiPn364IMPPkDz5s0RGhoqOg6RVeAaNyuSZNTjWExYjta4iaaBhAbe/nDVOOTZY6SlpWHLli1YvXo1Tp48mXnmGrfvJ7KcmJgYlChRAg8ePICzszPOnTuHDh06ICwsDLJsf+8RDh48GFqtFjVr1sTZs2cRFRWF1q1bQ1EUDBs27KW+JleuXEGDBg0QGhoKDw91rBumV9OxY0fUrVsX06ZNEx1FmC+++ALz58/Hr7/+iuLFi4uOQ6RqWtEBKPtcNDorKtnSKQBc5Lzpcp05cwarVq3CunXrUK1aNQwdOhQbN26Ei4tLnjweET3bnj170KhRo8zjMzK6bfZYtAFAq1atYDQaIcsyGjZsCJPJBK1W+0rjkuXKlUPLli2xYsUKu36hb0sWL16MWrVqoX///vDz8xMdR4g333wTqampaNasGY4cOYKiRYuKjkSkWuy4WZljMWGIN1rPWIWH1hEN8vnn2vUePXqEtWvXYvXq1YiJicHgwYMxaNAg+Pvn3mMQUc4NGDAA9erVw8iRI2E2m+Hv74/t27ejSpUqoqMJpSgKwsLCsH79erzzzjvQaDSvdL1Lly4hKCgIN27cgJubWy6lJJFmzZqFS5cu4eeffxYdRaj58+fj+++/x5EjR+Dj4yM6DpEq2edboVYsn866ukneuZDXZDJh165d6NGjB0qVKoWQkBAsXLgQN27cwPvvv8+ijUgwk8mE3bt3o1279I2QfvvtN3h4eNh10Xb16lXMnz8frVq1wrx581C9evVc6T5WqFABTZs2xeeff54LKUkNpk6dij/++AMHDhwQHUWoqVOnolevXmjevDkePXokOg6RKnFU0kooioIoQzJSTAbRUbJNAwk+Di//jvC1a9ewevVqfP/99/D19cXQoUPx9ddf8xwjIpUJCQlB4cKFM9enBAcHo1+/foJTiVW7dm306tULGzduhLu7e65ee8aMGWjWrBlGjx4NV1fXXL02WZ6zszMWLVqEsWPH4uzZs3BwyLs14Wo3a9YspKSkoGXLljhw4AB/3xP9BztuKmcwm3Aj+REORl/Hn3ERiNQnio6UbVpZg/w57LglJiZi9erVaNiwIRo0aAC9Xo+9e/fi5MmTGDFiBJ/EiVQo4xgAANDr9fjll1/Qu3dvwanE+vvvv1GpUiX06NED/fr1w08//QSz2Zwr165UqRIaNWqElStX5sr1SLxOnTqhRIkSWLr0+bs82zpJkjB//nw0aNAAbdq0QUJCguhIRKrCNW4qZVLMuJQYiYjU9DN7zFa2LYkMCWVdCyDAJf8Lb6soCo4dO4bVq1dj8+bNaNSoEYYOHYq2bdty+34iKxAYGIilS5eiYcOG2L59O+bPn49jx46JjqUaDx48wJo1azB27Fg4OTnlyjX//vtvtGzZEqGhodyQyUZcvXoV9erVw7lz5+x+gw5FUTBy5EhcvHgRu3btYmeZ6DEWbioUrU/GmYS7MJhNVlewZZAhoVn+0tDJz16If+fOHaxZswarV6+GVqvF0KFD0b9/fxQuXNiCSYnoVdy5cwdVq1bFgwcPoNVq0bdvXzRs2BAjR44UHU2odevWISUlJfNIEqPRiMGDB+fqm1HdunVDgwYNMHHixFy7Jon17rvv4tatW1i7dq3oKMKZzWYMHToUd+7cwbZt23LtTQ8ia8ZRSRUxKWacT7iPkLhwpJmNVl20+Tl5Zlm0paWlYcOGDWjbti2qVKmCmzdv4ocffsCFCxcwefJkFm1EVmbnzp1o2bIltFotEhMTsXPnTvTo0UN0LOEURYGiKNBoNLh+/Tq2bNmC1NTUXH2MGTNmYMGCBUhJScnV65I406dPx9GjR/Hrr7+KjiKcLMv49ttvUaBAAXTr1u2VDrAnshXsuKmEUTEjJPY24o1pVluwZXCUtWjsHQCN9M/7AmfPns08c61q1aoYMmQIunbtyhEfIivXuXNndO/eHf3790dwcDDWrl2LHTt2iI6lGoqiQJIkdOnSBatWrUK+fPly9fqdO3dG06ZNMW7cuFy9LomzYcMGzJ07F3/++Se0Wu4hZzAY0KtXLwDATz/9xCUUZNdYuKmAUTHjeMwtJJn0Vl+0yZBQ28sP3joXPHr0CMHBwVi9ejUePXqEwYMHY/Dgwdy+n8hGpKWlwcfHB6GhoShQoADatWuHfv36oW/fvqKjCbdw4ULExcVBp9Ph/v37uHz5MjZv3gxPT89cfZw///wTHTp0QGhoKEfJbISiKGjRogU6dOiA8ePHi46jCmlpaejatSs8PDzw448/vvJ5iETWioWbYCbFjJM20mmTIaGYowfu/P4XVq1ahb1796Jdu3YYMmQImjZtmitnGBGReuzbtw+zZs3C77//jocPH6JMmTKIiIjgwdBIP8suLS0NOp0Oly9fRmJiIkaOHJknxVWHDh3QunVrjB49OtevTWJcunQJjRo1wvnz51GoUCHRcVQhNTUVHTp0QLFixbBq1Sq+piC7xMJNsPMJ9xGRGmf1RZukAHH3IjG18yD4FCyIoUOHonfv3ty+n8iGTZgwAQULFsT06dOxcuVKHD16FMHBwaJjqYrRaIRWq0Xz5s2xdu3aPHkR/scff6Br1664fv06HB0dc/36JMbbb7+Nhw8f4rvvvhMdRTWSkpLQpk0bVKxYEStXrszc/IfIXrBwEyhan4yQuHCrL9oMej3u3biFGzuOYWD/AahcubLoSERkAWXKlMGGDRtQvXp1NGjQAFOnTkX79u1Fx1KFSZMm4eHDh3BycsKdO3fg7e2NlStX5vph3Bnatm2Ljh074s0338yT65PlJSQkoHz58tiwYQPq1asnOo5qJCQkoGXLlqhTpw4WLVrE4o3sCgs3QUyKGYejbyDNbBQd5ZUY9HpoUo1o6lsRLo5cX0FkL65evYqmTZsiPDwct27dQq1atXD37l1uHPBYeHg4DAYDAMDLywve3t55+ngnT55Ez549ce3aNTg4OOTpY5HlBAcHY+HChfjjjz+4rusJsbGxaNasGZo3b4758+ezeCO7wQFhQS4lRsJgNomO8UokBSjl4YM2AdVZtBHZmR07dqBt27aQJAnr169H9+7dWbQ9wcfHB/v27cOCBQuwZMkS3Lp1K08fr06dOqhQoQLH6mxMnz594O7ujq+++kp0FFXx8vLC3r17sWvXLsyePVt0HCKLYeEmgMFssup1bTIkOMpa1MlXHJXdC/9r238isg8ZhRsArF27ljtJ/sfQoUORkpKCiRMnol69ehg+fDju37+fp485c+ZMfPjhh5mdPrJ+kiRh+fLlmDVrFqKiokTHUZX8+fNj3759+OmnnzB//nzRcYgsgq+4BQhPjRUd4aWkJqcgLSUV+YwaNPYOgLeOZ7AR2aOEhAScPHkSzZs3x99//434+HjUr19fdCxViYmJQefOnVG2bFm0atUKWq02zw8QrlevHsqUKYM1a9bk6eOQZVWpUgV9+/bFtGnTREdRnUKFCuHAgQP45ptvsHjxYtFxiPIcT3a0MEVREJYSbVXdNg0kaCQZhTRuUB4mILCqP7tsRHZs3759qFu3Ltzc3BAcHIw+ffpwa+7/qFu3LmbMmIG6deviypUrKFasGDw8PPL8cWfOnIlBgwZh4MCBHF21Ie+//z4qVKiAkJAQ1K5dW3QcVSlatCgOHjyIoKAgODk5cYMesmncnMTCHuqT8GdcBExWUrgVcnBDCed8yK9z4eJfIgIADBs2DFWrVsXYsWPh7++Pbdu2oWrVqqJjqc7Fixdx9uxZFCtWDI0aNbLYc2jTpk0xcOBADB482CKPR5bx/fffY8WKFThx4gTfKMlCaGgoGjdujDlz5mDIkCGi4xDlCf7kW1ikPtFqijYAcNboUMDBlUUbEQEAzGYzdu7ciXbt2uH333+Hh4cHi7YspKSk4NixYzh27Bj279+P69evW+yxZ82ahXnz5sFotO5di+nfBgwYAK1Wi1WrVomOokqlSpXC/v37MX36dKxbt050HKI8wcLNwmIMyUiMi8eHQ8djRL22GFG/HS79cSbH1/nfl9+js181JMUnvFKeqZ0H4trZ88/8fLQh+ZWuT0S25cyZM/Dw8EDp0qURHBzMTUmeYdCgQUhMTMSkSZPQtGlTDB06NM93lswQFBSEYsWK8cWrjZFlGStWrMD06dMRHR0tOo4qlStXDnv37sWkSZOwadMm0XGIch0LNwtSFAWJRj2+mv4hajRtgC9/34nlhzbDr2ypHF/ryOadKFu9Cn7fsS8Pkv4j0agHp2mJKMOOHTvQrl07GAwGbNiwAX369BEdSZU0Gg06dOiA0qVLo0mTJihWrBhSU1MBwCLPqRldN5PJuo+doX8LDAxE9+7dMWPGDNFRVKty5crYuXMnRo4ciR07doiOQ5SrWLhZULLJgOT4BJw/cQot+3UHAOgcHODmmbMF6/fCbiM1KQkDpo3DkU3/PCntW78ZcwaOxtTOAzG8TisEL1gBAHhw+w5G1GuLBW++jRH12+HDoeORmpzy1HX/PPQb3mrTG+OadcWHwyYgJTEJEoBkM7eWJqJ0GYXb3r17Ua5cOZQsWVJ0JFUqVKgQhg0bhilTpqBr166Ijo7G999/jylTplhkW/cmTZrAx8cHP/30U54/FlnW3LlzsXHjRpw5k/NpHXsRGBiIrVu3YsiQIdi3L2/f4CayJBZuFpRk0uPB7TvwzO+NRePexdimXbFk4ntITXp6HPHE7oP4Yf7SLK9z5H870ahzW1R6vSYiQsMQE/nPi4Crf57Du6uWYPnhLTi2bXfmGGTE9TC0G9IHX/62Ay7ubtix+t8jNHGPYrB+0Up88MsqLD2wCWWqVcLmL76DJElIMubtFtZEZB0iIyNx5coVNGzYkGOSLzBw4EDMnTsXnTp1wuTJk/H++++jQ4cOaN++Pdzc3PL88SVJwsyZMzF37lx23WyMt7c35s2bh9GjR8NsNouOo1p16tTBpk2b0K9fPxw5ckR0HKJcwcLNgkwww2g04Pq5i2g7uDeWHdwEJxcXbFj29VO3fb11UwyYOi7L6/y6eQcadWkLWZZRv11LHNu2J/NzgUH14OGdD47OTqjbtgUunDwNAChYrAgq1nkNANCkewdcPPnnv6555fRZhF8NxeT2/TCmSRcc+HkLIiPuQlHScxMR7dq1C82aNYPBYMCOHTvQo0cP0ZFU67XXXkNQUBDq16+PevXqoV69eqhbty4aNWoEZ2dni2Ro3rw58uXLhw0bNljk8chyhg4dCqPRiB9++EF0FFVr0KAB1q9fj+7du+P48eOi4xC9Mp7jZkFmRUGBooVRoGghlK9RDQBQv0NLbFj6dOH2LDcvXsWdG7fwXo9hAACj3oBCxX3RYVg/AHhq98fMj/+zKeR/N4lUFKB6UD288+Wn/7lhem4ioowxyS1btqBevXooWLCg6EiqZTQaoSiK0LPUMrpub731Fnr27Mkt5G1IxkYlHTt2RKdOneDl5SU6kmo1bdoUP/zwAzp16oSdO3eiZs2aoiMRvTQ+i1uQLEnw9imIgkWLIOJ6GADgr19PoHjZ0tm+xpHNO9Dv7TFYffoAVp8+gB/+/hXRDyIRGX4HAHDmyO9IiIlFWkoqTuw6gIq107tsDyPuZe5eeXjTdlSsU+Nf1y1foxouhZzB3Rvpu56lJiXjTmgYoKTnJiL7ZjAYsG/fPrRt2xbBwcHo16+f6EiqFhISgo0bN4qOgVatWsHNzU0VWSh31apVCx06dMD7778vOorqtW7dGl9//TXat2+Pc+fOiY5D9NJYuFmQBjIkScKID6djwci3MTqoE26cv4yeE/7vqds+a43bkc07Ubdt83/9Wd02zXFk804AQNnAqvhg6HiMadwJ9du3RJnqlQEAvqX9sX3VOoyo3w6JsfFoO7j3v67hWcAbE5d+iE/enIzRQZ3wVts+CL8WBklKz01E9u23335DqVKloNVqcezYMXTq1El0JFW7ePEi9u/fLzoGJEnCrFmzMGfOHK6HskEffvghgoOD8ffff4uOonqdOnXC0qVL0bp1a1y6dEl0HKKXIinc691ikox6HIsJy7MDuPet34zrZ89j5Px/bxP84PYdzO7/Jj7/dVuOr6mBhAbe/nDVOORWTCKyQm+//TZcXFxQuHBh/Prrrzwj7AW+/fZb/Pbbb6o4LFlRFNSuXRvTpk1D165dRcehXLZy5UqsW7cOR44ceWq5BD3txx9/xNSpU3Ho0CGUKVNGdByiHGErxYJcNLo8KtnyjgLARRa3RoOI1CFjfRvHJLNHlmXVnIGZsdaNXTfb9H//939ITEzkmynZ1L9/f7z//vto3rw5bt68KToOUY6wcLMgSZLgps27zlWL3l2e6rYBQKHixV6q2wYAbloHvoNHZOfCwsIQFRWFggUL4tKlS2jZsqXoSKony7KqiqT27dtDlmVs2/ZyvwtIvTQaDZYvX463334b8fHxouNYhTfeeANvv/02mjVrhoiICNFxiLKNhZuF5dO5iI6QI95WlpeIct/OnTvRpk0b/PTTT+jevTscHDg6/SKSJKmqcMvous2ePVs1nUDKPfXq1UOLFi0wd+5c0VGsxpgxYzBy5Eg0bdoU9+7dEx2HKFtYuFmYj4MbNP/dm1+lNJDg45D3B8USkbpxTDLn1DQqmaFTp04wm83Yvn276CiUBz7++GN89913uHjxougoVmPy5MkYOHAgmjdvjocPH4qOQ/RCLNwsrIDOBVorOUtHK2uQnx03IruWnJyMY8eOoVixYoiNjUX9+vVFR7IKahuVBNK7bjNmzMCcOXNUV1TSqytUqBBmzJiBcePG8d83B9577z106dIFLVu2RHR0tOg4RM9lHRWEDZEkCf7O3pBV3nWTIcHfOR/XtxHZuYMHD+K1117D9u3b0adPHx7inE1qG5XM0KVLF6SmpmLXrl2io1AeGDVqFCIjI/HLL7+IjmJV5s6di6ZNm6J169aIi4sTHYfomfgbWAA/Jy/REbLFWnISUd7ZsWMH2rRpg3Xr1nFMMgfUOCoJpOdi1812abVaLF++HG+99RYSExNFx7EakiRh4cKFqFWrFtq1a8evHakWCzcBdLIGvk6equ26yZDg5+QJnawRHYWIBFAUBSdOnEBKSgp27NiBYsWKwc3NDVWqVBEdzWqocVQyQ/fu3ZGQkIC9e/eKjkJ5oFGjRmjYsCE+/PBD0VGsiiRJWLZsGcqXL48OHTogOTlZdCSip7BwE6SCm49qCyOdrEF5Nx/RMYhIkKioKNStWxdeXl6IjIzEV199hU6dOnF0OgfUOioJ/NN14w6TtmvBggX46quvcPXqVdFRrIosy/jyyy9RrFgxdOnSBWlpaaIjEf0LCzdBNJKMQI+iquu6yZAQ6FEUGonfGkT2qkCBAnB1dYVer0daWhqOHj2KBw8eiI5lVdQ6KpmhR48eiImJwYEDB0RHoTxQtGhRTJ06lRuVvASNRoPvvvsOHh4e6NGjB/R6vehIRJn46lwgb52LqkYmZUjwdfLk2W1Edk6SJJQrVw5AegHi6uqKZcuWCU5lXdTccQPSX5y+99577LrZsPHjx+P27dvYsmWL6ChWR6vVIjg4GADQr18/GI1GwYmI0rFwE6yCmw88tI7CizcZEjy0jqjAEUkiAlC9enUAgKurK2bPng1nZ2exgayM2jtuANCrVy88ePAAhw8fFh2F8oBOp8OyZcswceJEpKSkiI5jdXQ6HTZs2ICEhAQMHjwYJpNJdCQiFm6iaSQZtb2Kw1XjIKx4kyHBVeOA2l7FOSJJZAcURUGSUY/ItETcS4vHndQ43EuLR2RaIpKMeiiKgiJFisDZ2RmSJGHAgAGiI1sdNW9OkkGr1WZ23cg2NWvWDLVq1cL8+fNFR7FKjo6O2LRpE+7cuYMRI0ao/meabJ+kqP0tQTthVMwIib2NeGMazLDcP0lGp622V3FoWbQR2SRFURBlSEakPhExhmQkGvWQkD7OpygKIAFQ/vlYAeCmccD90FvY9/P/8MUni7gxSQ5t374dK1euxI4dO0RHeS6j0Yjy5cvj22+/RVBQkOg4lAfCw8NRvXp1hISEoFSpUqLjWKXExES0atUK1atXx/Lly/l8SMLwlbpKaCUZdbyKW3TNW8aatjos2ohsksFswo3kRzgYfR1/xkXgVkpM5ptDJigwKmaYoMCk/PtjMxTEm9LgUqIQOk8egYPR13Ej+REMZo4KZZc1jEoC6V236dOnY86cOaKjUB7x8/PD5MmTMXHiRNFRrJabmxt27tyJP/74A5MnT7aKn22yTXy1riIaSUZl98Ko7eUHR1mbZwWcDAmOsha1vfxQ2b0wxyOJbIxJMeN8wn0ceHQdV5OikGY2wfQynXxJgiJLSDObcDUpCgceXcf5hPswKRwXehFrGJXM0L9/f4SFheHYsWOio1AemTRpEi5fvqz6DrCaeXp6Yvfu3Thw4ABmzJghOg7ZKb5iVyFvnQsaewfA73H3LbcKuIxr+Tl5orF3AHePJLJB0fpkHI6+gYjUOJgfd89yQ8a1IlLjcDj6BqINPJz2edS+q+STdDod3n33XXbdbJijoyOWLl2K8ePHIzU1VXQcq+Xt7Y19+/Zh8+bNmDdvnug4ZIdYuKmURpJRyb0wmuUvjbKuBeAoa6B5yQJOAwmOsgZlXQugWf7SqMQuG5HNyeiyhcSFI81szLO1smYoSDMbERIbzu7bc1jLqGSGgQMH4urVqzh+/LjoKJRHWrdujSpVqmDhwoWio1i1ggUL4sCBA1izZg2/lmRxWtEB6Pl0sgYBLvnh7+yNKEMyHuoTEf3U5gJ4YnMB/LO5gNYB3joX+Di4Ib/OhYtpiWyUiM2NMrpv8cZUbm6UBWsalQQABwcHvPvuu5g9ezZ2794tOg7lkUWLFqFGjRoYMGAASpQoITqO1SpcuDAOHjyIRo0awcnJCWPGjBEdiewECzcrIUkSCjq4oqCDK4D04izZbECSUQ8TzDArCmRJggYyXLUOcJF1LNSI7IBRMeN4zC0kmfQW3ZEWSC/e4o1pOB5zC3XzlWDx9gRrGpXMMHjwYMybNw8nT55EnTp1RMehPFCyZEmMHz8ekyZNwsaNG0XHsWq+vr44ePAggoKC4OTkhDfeeEN0JLID/C1rpSQp/ew1H0c3FHH0QDEnTxRx9ICPoxtcNQ4s2ojsgOlxp01E0ZbBDAVJJj1CYm9zbPIJ1jYqCaR33aZNm8a1bjZuypQpOHv2LPbu3Ss6itUrWbIk9u/fj/fffx8//vij6DhkB1i4ERFZqUuJkRY/+zErGZ23S4mRQnOoibWNSmYYOnQozp07h1OnTomOQnnEyckJixcvxtixY6HX60XHsXplypTB3r17MWXKFGzYsEF0HLJxLNyIiKxQtD45c+dINchY88bdJtNZ46gkkL774DvvvMOum43r0KEDypQpg0WLFomOYhMqVqyIXbt2YcyYMdiyZYvoOGTDWLgREVkZk2LGmYS7qinaMpih4Ez8XY5MwjpHJTO88cYbeO2112A0GkVHoTy0ePFiLFiwABEREaKj2IRq1aphx44dGD58ODf4oTzDwo2IyMpcSoyEwWwSHSNLBrMJlzkyabWjkkD6KN27774LrZb7l9my0qVLY+TIkZg8ebLoKDajZs2a2LJlCwYOHIiDBw+KjkM2iIUbEZEVMZhNqhqR/C8zFISnxqm2sLQUax2VzODg4CA6AlnAtGnTcOLECRw6dEh0FJtRt25dbNiwAb169cKxY8dExyEbw8KNiMiKhKfGio6QLdaSM69Y86jki9jq38seubi44LPPPsOYMWNgMBhEx7EZQUFBCA4ORteuXRESEiI6DtkQFm5ERFZCURSEpUSrttuWwYz0nPb8At+aRyWflLHOLTExEXPnzgUAHjdjY7p06QJfX18sW7ZMdBSb0qJFC6xatQodOnTAmTNnRMchG8HCjYjISkQZkmG0kmLAaDbjkR3vMGnto5IAEBMTg48++gizZ89GcnIyYmNjsXTpUgCw+r8b/UOSJCxduhQffvgh7t27JzqOTWnfvj0+//xztGnTBufPnxcdh2wACzciIisRqU+ESeXdtgwmKIjUJ4qOIYwtjEr+9NNPuHXrFsqVK4ePPvoIQUFBuHTpEoD0vx/ZjnLlyuGNN97AlClTREexOd26dcOiRYvQqlUrXLlyRXQcsnJ85iUishIxVtbBsucz3WxhVLJFixaIi4tDsWLFsHXrVqxduxaNGzfO3D7e2v9+9G/vvfceDh8+jKNHj4qOYnP69OmDDz74AM2bN8eNGzdExyErxsKNiEiFUlNTUbt2bVSrVg2VKlXCzJkzkWjU5+lj/rT4y8z/f3D7DkY16pDl7X6YvxRnjvz+wuslGvVW33V6WbYwKlmqVCkEBgbixx9/xNixY1GxYkVs3boVkyZNAsCum61xc3PDwoULMWbMGJ7hlwcGDx6M6dOno1mzZrh9+7boOGSl+KxLRKRCjo6OOHjwIP766y+cPXsWu3bvxuVTZ/P0MX9e/FW2bjdg6jgEBtV74e0kAMlm+9ypzhZGJQFg/Pjx6NKlCxRFgYODA0aOHAlfX1989913ANh1szU9e/ZE/vz5sXLlStFRbNKbb76J8ePHo2nTprh7967oOGSFWLgREamQJElwc3MDABgMBqQZ9DnqcOxbvxnzBo/FjF7DMbxOK6yavSDzc4c37cCooI4Y1agDVs1ZCABYPfdT6FNTMaZJFyx4820AgMlkxtJJMzCyYXu812MY0lJSAQCfjZ2GY9v2AACG1GiGHz9ehnHNumJUUEeEX0sfA4qLisa0HkNRo0o1vPHGGyhRogSioqJe/QtjJWxhVBIAXF1dkZycjOrVq2PKlCmoVasW3NzcMrc4Z9fNtkiShGXLlmHOnDmIjIwUHccmTZgwAW+88QaaNWvGrzHlGJ9xiYhUymQyoXr16vDx8UHDZo1R7rWqT91m53frsfO79Vne/8b5y5j69WdYcWQrft2yCw/v3MOj+5H4bu6n+Gjjd1h2cDOunT2P4zv3Y8iMt+Dg5ITlhzbj7S/Si7y7N26h3ZC+WHl0O1w9PfDb9r1ZPo5H/nxYemAT2g7qjU2frwIABC9cgWoNXsehMyfRvXt3uxsNsoVRyQxdu3ZFpUqVsG3bNqxYsQIREREICAjAvn37AKR/n5LtqFSpEgYOHIipU6eKjmKzpk6dil69eqF58+Z49OiR6DhkRVi4ERGplEajwdmzZxEREYEzf5zGzctXn7pN28G90XZw7yzvX73R63D1cIeDkyOKly2NyPC7uHrmb1SpVwueBbyh0WrRuFt7nD9+Ksv7Fy5eDKWqVAAAlK5aEZHhd7K8Xb12LdJvU60SHtxOv82Fk3+icZe2MCsKWrdujXz58uX472/NbGVUMsOJEyfw119/oUqVKvj888/RuHFjzJw5E0D69ynZllmzZmHPnj04ceKE6Cg2a9asWWjTpg1atmyJ2NhY0XHISrBwIyJSOS8vL9QPaoRTB3K225vOwSHz/2WNnOPOiM7xyftrYDJmff+Mx9FoNDA/+RgKINvpYc221HEDgGbNmmHChAlo3Lgxjh49iuDgYHTs2BFms5kdNxvk4eGBjz/+GKNHj+a/bx6RJAnz589HgwYN0KZNGyQkJIiORFaAhRsRkQo9fPgw813YlJQUHD1wCH5lS73ydcu9VgV/H/8DcY9iYDKZcGTTDlSuVwsAoNFpYTTkzmYiFWsH4tetu6CBjL179yImJiZXrmstbK3j5urqilu3buHdd9/F1atX0aZNG7zxxhuQZZkdNxvVr18/uLi44OuvvxYdxWZJkoTFixejatWqaNeuHZKSkkRHIpVj4UZEpEL37t1DkyZNULVqVdSqVQvNW7RAnRaNn7rd89a4ZcW7kA8Gv/cWpnUdhLFNOqN0tUqo26YZAKD1gB4Y3bhz5uYkr6Lv5NH48/BvaFyjDjZs2IDChQvD3d39la9rLWxlc5InFSlSBK+//joCAwNx5coVrF27FtOmTcOuXbsAcK2brZEkCcuXL8fMmTO5DisPSZKElStXIiAgAJ07d0ZqaqroSKRikmJLbwkSEdkoRVGwJ+oqzLCOp2xDmh5ajQZtC1fEiRMnMHLkSJw9e1Z0LIsJCwtDkyZNcPPmTdFRct2uXbtw+fJlVKtWDQ8fPsR3332XWbyR7Rk3bhzS0tLw5ZdfvvjG9NJMJhP69++P+Ph4bN68GQ5PjLoTZWDHjYjICkiSBDet9fwij7xzFxNb9UT16tUxbtw4uxu3srVRyQxRUVH47LPP0L59ezRt2hQNGzaELMu4cuWK6GiUR+bMmYMtW7bg1KmsNzGi3KHRaLBmzRo4Ojqid+/eMOTS2DrZFnbciIisxIXEB7iVYj1rxUo650NFt0KiYwgRHh6OevXqITw8XHSUXDd8+HAULVoUNWrUwL1791CwYEF07dpVdCzKQ6tXr8aXX36J33//nWf35bG0tDR07doVHh4e+PHHH7mGlP6FP31ERFbCx8ENGljHLo0aSPBxcBMdQxhb21XySe+88w5cXFzw8OFDPHjwACkpKTh//jy7bjZs0KBBAIDvvvtObBA74OjoiI0bN+Lhw4cYNmyYzT6P0Mthx42IyEooioKD0deRZlb/JhCOshZNvUtBstPjAO7evYuaNWvi7t27oqPkmfDwcGzatAkODg44f/48wsPDsXXrVty+fRs+Pj5wcnISHZFy0enTp9GuXTtcunTJ7s5lFCEpKQlt2rRBxYoVsXLlSrt9LqV/Y8eNiMhKSJIEf2dvyCrvusmQ4O+cz65faNjirpJPMpvNmd2XHj16YMWKFfDw8MDChQvx888/4/jx42IDUq6rUaMGunTpghkzZoiOYhdcXV2xY8cO/PXXX5g4caJNrpmlnGPhRkRkRfycvERHyBZryZlXbHlUEkgvTMPCwlC4cGEoioIff/wRBoMBJpMJAQEBKFGihOiIlAfmzZuHDRs22NUOsSK5u7tj165dOHr0KKZNm8bijTgqSURkbc4n3EdEapwqjwaQIcHPyROV3AuLjiLUw4cPUbFiRTx8+FB0lDzz999/Y+rUqShcuDCqVKmCMmXKIDAwEEWLFhUdjfLQV199hTVr1uDo0aN23VW3pEePHqFJkybo1q0bZs2aJToOCcTCjYjIypgUMw5H30Ca2Sg6ylMcZS0aewdAI9n3QMejR49QtmxZmz+4+Oeff4ajoyNq1KgBX19f0XHIAkwmE+rUqYPx48djwIABouPYjQcPHqBx48YYNGgQpk6dKjoOCcLCjYjICkUbkhESG66qrpsMCbW9/OCtcxEdRbjo6GiUKlUKMTHWc3zDyzAYDNDpdADStzF3dHQUnIgs4eTJk+jSpQsuXboET09P0XHsxp07dxAUFIQxY8ZgwoQJouOQAPb9ligRkZXy1rnA18lTNRuVyJDg6+TJou0xWz2A+78yijaTyYRp06bhwYMHghORJdSpUwdt2rTB+++/LzqKXSlWrBgOHjyIJUuW4IsvvsiVayqKgiSjHpFpibiXFo87qXG4lxaPyLREJBn1dvE8Zk3YcSMislImxYyTsbcRb0wT2nmTIcFD64g6XsXtfkQyQ3x8PHx9fREfHy86isWMHTsWTk5OWLBggegoZAEPHz5EpUqVcPDgQVSuXFl0HLsSGhqKxo0bY+7cuRg8eDAiIiKg1+sREBDwwvsqioIoQzIi9YmIMSQj0aiHhPQNlRRFASQAyj8fKwDctA7Ip3OBj4MbCuhcuLZRIBZuRERWzKiYcTzmFpJMeiHFmwwJrhoH1M1XAloWbZkSEhJQpEgRJCYmio5iMREREahatSouX74MHx8f0XHIAlasWIENGzbg0KFDfDFvYVeuXEHTpk0xceJEfPDBB6hatSqOHDnyzNsbzCaEp8YiLCUaRrMZppf4faGBBK0sw9/ZG35OXtDJmlf5K9BLYOFGRGTljIoZIQI6bxmdttpexVm0/UdSUhJ8fHyQlJQkOopFjRo1Ch4eHpg/f77oKGQBRqMRNWvWxNSpU9G7d2/RcezOpk2b0L17dyiKAkdHRzx8+BDu7u7/uo1JMeNSYiQiUuMAIFd+R2SM6Ps6eaKCmw8nLSyIhRsRkQ148pezJYq3jDVt/KWdtZSUFHh7eyMlJUV0FIu6ffs2AgMDceXKFRQoUEB0HLKA3377Db169cKlS5eeKhoo79y6dQuVKlXKfHPI2dkZ33//PXr06JF5m2h9Ms4k3IXBbMqT3wsyJOhkDQI9inJ9s4Xwty0RkQ3QSDIquxdGbS8/OMraPNu0RIYER1mL2l5+qOxemEXbM9j6AdzPUrx4cXTv3h2fffaZ6ChkIfXr10fTpk0xb9480VHsipeXF4YMGQIvLy+4uLggJSUFixYtApD+Rt75hPsIiQtHmtmYZ2/mmaEgzWxESGw4zifch0mxv+c8S2PHjYjIxpgUMy4nRiI8D0Zj/Jw8UZ5dthfS6/Vwc3ODXq8XHcXibt68iRo1auDatWvw9vYWHYcs4P79+6hcuTKOHTuG8uXLi45jV0wmE44ePYqPPvoIFy5cwM3w2xydt2Es3IiIbJTBbMJXm9ej2GsV4OzmysXoFmQ0GuHk5ASjUX2HpFvC8OHDUbhwYcydO1d0FLKQRYsWYefOndi7dy83KhGEm1XZPhZuREQ2SlEUlC5dGj/9/DNKVCmPh/pERD+1/TOe2P4Z/9r+2fvx9s/5uf1zjplMJuh0OrsclwSAGzduoFatWrh+/Try5csnOg5ZgMFgQGBgIGbPno1u3bqJjmN3eDyMfWDhRkRko06ePImBAwfi8uXL/yq8FEVBstmAJKMeJphhVhTIkgQNZLhqHeAi61iovSJFUezmEO5nGTp0KIoXL85Dmu3I4cOHMWjQIFy8eBGurq6i49iV8wn3LbY51YtkbF5V2b2w6Cg2h4UbEZGNGj9+PLy9vTFr1izRUexSxgYl9loEX79+Ha+//jquX78OLy8v0XHIQvr06YNSpUpxsxILitYnIyQuXBVFWwYZEmp7+XG3yVzGwo2IyAYZjUb4+vri6NGjKFOmjOg4dkmWZRgMBmg09rsucNCgQShdujRmzJghOgpZyJ07d1CtWjUcP36czz0WYFLMOBx9A2lm9a2ndZS1aOwdwJHJXMSvJBGRDTp48CCKFy/OF04C2fuoJABMnz4dS5cuRXx8vOgoZCHFihXDlClTMH78eLv//reES4mRMJhNomNkyWA24XJipOgYNoWFGxGRDQoODkbfvn1Fx7Br9nqW25PKli2LVq1aYfny5aKjkAVNmDABN27cwLZt20RHsWkGs0k169qyYoaC8NQ41RaW1oijkkRENiYlJQVFixbFxYsXUaRIEdFx7JajoyPi4+Ph6OgoOopQly9fRqNGjRAaGgp3d3fRcchC9u3bhxEjRuDChQtwdnYWHccm3Uh+hKtJUaot3ID0tW5lXQsgwCW/6Cg2gR03IiIbs2PHDtSoUYNFm2CyLNt9xw0Aypcvj2bNmmHFihWio5AFtWjRAq+99ho++eQT0VFskqIoCEuJVnXRBqR33cJSojk2m0vYcSMisjFdunRBx44dMWTIENFR7JqLiwsePnzIbdEBXLx4EU2aNEFoaCjc3NxExyELuX37NgIDA3Hq1Cn4+/uLjmNTHuqT8GdcBEwqL9wAQAMJNTx9UcCBz4Wvih03IiIbEhMTg4MHD6Jr166io9g9bk7yj4oVK6Jx48ZYuXKl6ChkQcWLF8ekSZMwceJE0VFsTqQ+0SqKNgAwQUGkPlF0DJvAwo2IyIZs2rQJzZs3h6enp+godo+jkv/23nvv4dNPP0VycrLoKGRBkydPxoULF7Br1y7RUWxKjMG6fo6irSyvWrFwIyKyIdxNUj24q+S/ValSBQ0aNMAXX3whOgpZkKOjI5YsWYJx48YhLS1NdByboCgKEo16AMDi8dPRt2J9jGrU4V+3uXH+Mt5q0xujgjpidv+RSE7IWcfrf19+j9TklMyPu5WskeXtdn63Hgd++t8Lr5do1HMCIRewcCMishF3797FmTNn0K5dO9FRCByVzMqMGTOwYMECdt3sTNu2bVGxYkV8+umnoqPYhGSTAdLj/2/euzPmrP/qqdssnTQDg2dMwudHtqJu2+bYuOLbHD3Glq/WIC0l9YW3azu4N5r16vzC20kAks2GHGWgp7FwIyKyEevXr0fnzp3h5OQkOgqBo5JZqVatGl5//XV8/fXXoqOQhS1atAiffvopbt++LTqK1Usy6SFJ6aVb5bq14O7l9dRt7oTeROW6tQAAgUH18Nv2fdm+/tavf0D0/YeY1nUQpnYZlPnn33+4GGMad8akNr0QExkFAFj7yXJsXLEq835vNmiP0UGd8PH/TfrXNSVJQtLjLiG9PBZuREQ2gmOS6sJRyazNnDkTn3zyCVJTX/xuPtmOgIAAjB07Fm+99ZboKFbPBPMLu/nFy5XGiV0HAADHtu5B1J17Wd5uTJMuT/1Zx+ED4F24ID7a9D3mb/4eAJCanIzyNaph+eH/ofLrNbHnxw1P3W/D0q+x7MAmrDiyBaMXvP+vzylKem56NSzciIhswJUrV3Dnzh00adJEdBR6jKOSWQsMDESNGjXYdbND77zzDk6dOoX9+/eLjmLVzIqCzFnJZ5iw5APsWL0O45p3Q0piErQOuixvt/zQ5mw9ptZBh9otGwMASlerhAfhd566TcmK5bBg5Ns4uGErNBrNvz8pPc5Nr4SFGxGRDVi3bh169er19C9LEoajks82c+ZMfPzxx+y62RlnZ2csXrwYY8eOhV7PsbmXJUsSXnQSgF+ZAMzb8C2W7t+IoK5tUaRk8Vd6TK1WlzmeKWs0MBlNT93m/eAv0G5oX4Seu4gJrXrCZDT+80nlcW56JSzciIisnKIoCA4ORr9+/URHoSdwVPLZatasiWrVqmHVqlWio5CFdezYEf7+/liyZInoKFZLAzmziHqW2IePAABmsxnrP/sCbQb1ytFjOLu5IiUxKdu3N5vNiLpzH9Ua1MGQmW8hOT4BKUn/bEIkSem56dXwK0hEZOVOnToFRVFQs2ZN0VHoCRyVfL5Zs2Zh/vz53CLezkiShCVLluDjjz/GnTtPj9vRi7lqHDKfWz4e8RbeatsbEddvYmC1xtiz9hcAwJHNOzD89dYYUa8tvAv7oEWfrlleK6s1bgDQekBPzOw9/F+bkzyP2WTCwlFTMCqoI8Y164oOwwfAzdMj8/OKosBV65CTvyZlQVL4W4WIyKpNnDgRHh4emD17tugo9AQ/Pz/8/vvv8PPzEx1Ftdq0aYPOnTtjxIgRoqOQhU2fPh1hYWEIDg4WHcXqKIqCPVFXYX7RvKSKyJDQqkDZF3YK6fnYcSMismImkwnr169Hnz59REeh/+Co5IvNnDkTH330Edc72aF3330Xx44dw+HDh0VHsTqSJMHNyrpXbloHFm25gIUbEZEVO3z4MIoWLYry5cuLjkL/wVHJF6tbty7Kli2LNWvWiI5CFubq6orPPvsMY8eOxZkzZ9C5c2dERESIjmU18ulcREfIEW8ry6tWLNyIiKwYNyVRL+4qmT0zZ87Ehx9+CIPBIDoKWViLFi0QExODOnXqYNeuXbh48aLoSFbDx8ENmhedCaASGkjwcXATHcMmsHAjIrJSqamp2Lx5M3r1ytluYWQZHJXMngYNGsDf3x8//vij6ChkQQ8fPoS/vz8iIyNhMBig0+nw6NGj595HURQkGfWITEvEvbR43EmNw720eESmJSLJqLerDncBnQu0snW8jNfKGuRnxy1XaEUHICKil7Nz505Ur14dxYoVEx2FssBRyeybNWsWhg4digEDBkCr5UsTe5A/f36MGjUKn332GQwGA1JSUp4q3BRFQZQhGZH6RMQYkpFo1ENC+psiSsYh1Mo/HytIX0uVT+cCHwc3FNC52Oy6KkmS4O/sjatJUarepESGBH/nfDb772Bp1lGqExHRU4KDg9G3b1/RMegZOCqZfY0aNYKvry/Wrl0rOgpZiCzLmDdvHk6dOoVKlSrBbDbjzz//BAAYzCbcSH6Eg9HX8WdcBG6lxCDemAYzFJigwKiYYYICk/Lvj81QEG9Mw62UGPwZF4GD0ddxI/kRDOanD4u2BX5OXqIjZIu15LQGPA6AiMgKxcXFoXjx4rh58yby5csnOg5loXz58ti8eTMqVKggOopVOHToEEaMGIGLFy+y62ZnzGYzJkyYgKK+vmg/ciAiUuPS/zwXOkny43Vgvk6eqODmA41kWz2L8wn3EZEap8qumwwJfk6eqOReWHQUm2Fb371ERHZi8+bNaNq0KYs2FeOoZM40btwYhQsXxvr160VHIQuTZRnvL5yPWsO6ZhYhuVWIZFwrIjUOh6NvINqQnCvXVYsKbj7QyRrRMbKkkzUo7+YjOoZNYeFGRGSF1q5dyzFJleOoZM5IkoSZM2di3rx5MJlsc7SNnmZSzDifcB8hceFIMxvzrHNkhoI0sxEhseE4n3AfJsU2fjY1koxAj6KZnUW1kCEh0KOozXU4ReNXk4jIyty7dw+nTp1C+/btRUeh5+CukjnXrFkz5M+fHz///LPoKGQBRsWMk7G3LTrql9F9Oxl7G0YbKd68dS7wdfJUTfEmQ4KvkyfPbssDLNyIiKzMzz//jI4dO8LZ2Vl0FHoOjkrmXEbXbe7cuey62TijYsbxmFuZm45YUsYmJsdjbtlM8VbBzQceWkfhxZsMCR5aR1TgiGSeYOFGRGRleOi2dWDH7eW0bNkSHh4e2Lhxo+golEdMihkhsbeRZNIL21TDDAVJJj1CYm/bxNikRpJR26s4XDUOwoo3GRJcNQ6o7VWcI5J5hF9VIiIrcv36ddy6dQtNmzYVHYVegB23lyNJEmbNmoU5c+aw8LVRlxIjhXTa/iuj83YpMVJojtyilWTUzVdCSOcto9NWN18JaFm05Rl+ZYmIrEhwcDB69uzJ7dKtADcneXmtW7eGs7MzNm/eLDoK5bJofbKqtq/PWPNmK7tNaiUZdbyKW3TNW8aatjpexVm05TF+dYmIrISiKDx024pwVPLlsetmm0yKGWcS7qqmaMtghoIz8XdtYmQSSB+brOxeGLW9/OAoa/OsgJMhwVHWoraXHyq7F+Z4pAXwK0xEZCXOnDkDg8GAOnXqiI5C2cBRyVfTrl07aLVabNmyRXQUyiWXEiNhMKtz0xmD2YTLNjIymcFb54LG3gHwe9x9y60CLuNafk6eaOwdwN0jLYiFGxGRlcjotkmSOrZ8pufjqOSrydhhcs6cOSyAbYDBbFLViOR/maEgPDVOtYXly9JIMiq5F0az/KVR1rUAHGUNNC9ZwGkgwVHWoKxrATTLXxqV2GWzOH61iYisgMlkwrp16zgmaUU4KvnqOnbsCEVRsG3bNtFR6BWFp8aKjpAt1pIzp3SyBgEu+dHUuzRe8/RFSed8mZuYaCBBK8nQQIbm8X/TP5YyNx0p6ZwPNTx90dS7NAJc8kMna0T/lewSV7cTEVmBX3/9FT4+PqhQoYLoKJRNHJV8dRldt9mzZ6NDhw7sNlspRVEQlhKt2m5bBjPSc/o7e9vs95okSSjo4IqCDq4A0v9tks0GJBn1MMEMs6JAliRoIMNV6wAXWWezXwtrxI4bEZEV4KYk1oejkrmjc+fOMBgM2Llzp+go9JKiDMkwWsnPgtFsxiMb2WEyOyQp/ew1H0c3FHH0QDEnTxRx9ICPoxtcNQ4s2lSGhRsRkcqlpaVh06ZN6NOnj+golAMclcwdsixjxowZmD17NjuYVipSnwiTyrttGUxQEKlPFB2DKEss3IiIVG737t2oUqUKfH19RUehHOCoZO7p1q0bkpOTsWfPHtFR6CXEWFkHy1bOdCPbw8KNiEjlOCZpnTgqmXvYdbNeiqIg0ah/6s8f3rmHqV0G4c0G7TGyYXts+WpN5ueObt2NkQ3bo32hirh29nyOH3NIjWaIexTz0pkTjXp+n5EqsXAjIlKx+Ph47N69G926dRMdhXKIo5K5q3v37oiNjcW+fftER6EcSDYZstx8XqPV4I3ZU/DFse34dNdP2L4qGLevXAcAlChfBtNXL0PlujUtG/YxCUCy2SDksYmeh4UbEZGK/e9//0NQUBDy588vOgpl0+bNmzFq1ChcvnwZixYtwsiRIxEZaVsH+4qg0WjYdbNCSSZ9lhtceBfyQemqlQAALm6u8CtbCo/uPQAAFC9bCr6l/V/pcTcu/wajgjpiYqueuHvjFgAgLioaHwwZhwkte2BCyx64ePLPLO8rSRKSsugSEonGwo2ISMWCg4PRr18/0TEoB06fPo2vvvoKd+7cwa5du/DNN9+IjmQzevXqhaioKBw8eFB0FMomE8wvLLQf3L6DG39fQrka1XJ07TFNujzzcy4e7vj8yFa0H9oXX834CADw5XsfovOIQVi8dwPeXbUESybNyPK+ipKem0hteI4bEZFKmUwm1K9fHx07dhQdhXJg8uTJWLx4MZKSkqDVajF8+HD4+PiIjmUTNBoN3nvvPcyZMwfNmjUTHYeywawo6bOHz6jdUhKT8MHQcRg+dypc3N1ydO3lhzY/83NBXdql/7drO3w9cz4A4Oyvx3H7Sug/j52QiJTEJDi7uf77ztLj3EQqw44bEZFKaTQavPPOO3B2dhYdhXLAy8sLkyZNgizLkGUZ7733nuhINqVPnz64e/cuDh8+LDoKZYMsSc8s2owGAz4cOh5NunVA/fYtc/VxnxzPzPh/xWzGZ7vWY/mhzVh+aDPWnDvydNEGAMrj3EQqw8KNiEjFHBwcREeglzB58mRIkoSgoCAULVpUdBybotVqMX36dMyePVt0FMoGDeQs17gpioIlE96DX9kAdBk5ONcf99ctu9L/+79dKF+zOgAgsHF9bPvmx8zbhP59Kcv7SlJ6biK1kRSu8CUiEi4tLQ0GgwFubjkbFSJ1URQFySYDkkx67D90AJUqVYaPT0FoIMNV4wAXjS7LF7GUMwaDAeXLl8fq1avRqFEj0XHoOZKMehyLCXvqAO4LJ05jSsf+KFmhLCQ5vUgaNH0CajUPwu879uGLdz9A3KNouHl4IKByecz9+em1omOadMlyXHJIjWZo2KkNTh84Cp2jA6Z8sRBFA0og7lEMVk6dg/CrN2AymVD59ZoYs/D9p+6vgYQG3v5w1fCNM1IXFm5ERCpw+PBhnD17FhUqVEC5cuVQrFgx6HQ60bHoBRRFQZQhGZH6RMQYkpFo1ENC+miW8sTanoyPFQBuWgfk07nAx8ENBXQuLORe0rfffot169Zh//79oqPQcyiKgj1RV2F+1rykCsmQ0KpAWf5skuqwcCMiUoGQkBCEhYXht99+g1arRaVKlVCqVCkEBASgePHiouPRfxjMJoSnxiIsJRpGs/mpbkJ2aCBBK8vwd/aGn5MXdLImD5LaLoPBgLJly+LHH39E/fr1Rceh5zgWE4Z4Y5roGNnmoXVEg3yvdhwBUV5g4UZEpBLh4eEYPXo0unbtCoPBgJMnT6JgwYJ499134e7uLjoeATApZlxKjEREahwA5EoXQX58PLGvkycquPlAI3FtTXZ9/fXX+OWXX7Bnzx7RUeg5LiQ+wK2UGNExsq2kcz5UdCskOgbRU/jbgYhIsIz3zw4dOgR3d3cMHjwYw4cPR/PmzREfH8+iTSWi9ck4HH0DEalxMEPJtdGvjGtFpMbhcPQNRBuSc+W69mDQoEG4fPkyTpw4IToKPYePgxs0sI6xQw0k+DhwrTGpE89xIyISLGP9U5cuXRAVFYUffvgBnp6e2LJlCxo3biw6nt17ssuWl+t0zFCQZjYiJDac3bdscnBwwLRp0zBnzhzs3LlTdBx6hgI6F2hlGSazSXSUF9LKGuTXuYiOQZQl/kYgIlIBSZLg7u6OEiVKIDw8HI8ePUKzZs3Qp08f0dHsmlEx42Ts7Twv2p6U0X07GXsbRsVskce0ZkOGDMHff/+NkJAQ0VHoGSRJgr+zd+ZYsFrJkODvnI+bkpBqcY0bEZFAJpMJGo0GX375Jc6dO4fSpUvDaDSibdu2qFSpEhRF4YsIQYyKGcdjbiHJpBeyI54MCa4aB9TNVwJadt6ea8WKFdi9eze2bdsmOgo9g8FswoFH11W9u6QMCc3yl+ZGQaRa/E1ARCSQRpP+AuGXX37BkCFD0KVLFxQuXBjffPMNoqKiWLQJYlLMCIm9LaxoA9I7b0kmPUJib8PEzttzDRs2DGfOnMHp06dFR6Fn0Mka+Dp5qrbrJkOCn5MnizZSNRZuRESC3bt3D66urkhJSUGhQoXQq1cv/PHHH3B1dRUdzW5dSoxEvDFNeHfADAXxxjRcSowUmkPtnJycMGXKFMyZM0d0FHqOCm4+qi2MdLIG5d18RMcgei6OShIRCZQxKnnq1CkcOHAA7u7u+OOPP+Dk5ISVK1eKjmeXovXJCIkLF160PUmGhNpefvDmpgnPlJKSglKlSmHHjh0IDAwUHYeeIdqQjJBY/nwRvQwWbkREgoWHh0Ov1+Ovv/6CwWBAzZo1kS9fPnh7e4uOZndMihmHo28gzWwUHeUpjrIWjb0DuNPkcyxatAhHjx7Fpk2bREeh5zifcN+iG/48jwwJvk6eqOxeWHQUohfisz8RkQBmc/qapT179qBLly5YtmwZHj16BEdHR6SmprJoE+RSYiQMKt2y3GA24TJHJp9rxIgROH78OM6dOyc6Cj1HBTcfeGgdha93kyHBQ+uIChyRJCvBwo2ISABZTn/6vXnzJqZOnYrFixejePHiOHPmDC5cuCA4nX0ymE2q6QJkxQwF4alxqi0s1cDFxQWTJ0/G3LlzRUeh59BIMmp7FYerxkFY8Zaxa2ttr+LsYpPV4KgkEZEgRqMRCxcuREREBLp164Zq1arB29sbBoMBOp1OdDy7cyP5Ea4mRam2cAPSX2yWdS2AAJf8oqOoVlJSEkqVKoX9+/ejcuXKouPQcxgf795q6Y2AMjpttb2K86gNsir8biUisrCMMclt27bh0KFDqFixIs6cOYOVK1di7dq1LNoEUBQFYSnRqi7agPSuW1hKNPie67O5urpi0qRJmDdvnugo9AJaSUYdr+IWPSYgY01bHRZtZIW0ogMQEdmbjLPZDhw4gH79+mHgwIGIjIzEX3/9BRcX7momQpQhGUazdZyVZjSb8ciQjAIOPC7iWUaNGoWAgABcvHgRFStWFB2HnkMjyajsXhhFnTxwJv4uDGZTnryBIkOCTtYg0KMod48kq8XCjYjIwiRJgslkQkBAADZu3Ij79+/jtddeQ40aNbgpiSCR+kSYVN5ty2CCgkh9Igu353Bzc8PEiRMxb948BAcHi45D2eCtc0Fj7wBcToxEeGocAORKAZfRyfNz8kR5Nx+uZyOrxjVuREQWZDabIcsy/vzzT/z+++9ITEyEs7MznJyckJiYiLfeekt0RLt0LCYM8cY00TGyzUPriAb5/EXHULWEhAQEBATg6NGjKF++vOg4lAMGswnhqbEIS4mG0Wx+qTdVNJCglWX4O3vDz8lLtQd/E+UE33YgIrKgjDHJBQsWIDExET/99BOOHDkCg8GAzp07iw1npxRFQaJRDwBYPH46+lasj1GNOjx1u63f/IgR9dpiZMP2WDV7gUWyrf1kOTauWAUA+GzsNBzbtgcAkGjUc53bC7i7u2P8+PH44IMPREehHNLJGgS45EdT79J4zdMXJZ3zZR4foIEErSRDAxmax/9N/1jK3HSkpHM+1PD0RVPv0ghwyc+ijWwGRyWJiCxIkiREREQgLCwM69atw759+/D+++9jypQp6NKli+h4dinZZMjcFqF5785oP6wvPhsz9V+3+evYSZzYdQDLD/0POkcHxD58ZPmgT5AAJJsNcNU4CM2hdmPHjkWpUqVw7do1lClTRnQcyiFJklDQwRUFH48FK4qCZLMBSUY9TDDDrCiQJQkayHDVOsBF1mW+OUZki9hxIyKyMDc3NyxZsgTXr19HkSJFEBERAZ1Oh2LFiomOZpeSTPrMF3uV69aCu5fXU7fZ+d169Bg3HDrH9ELJq2D2t+O/euZvzBs8FgBwfNcBdCleHQa9HvrUNAyt2QIAcC/sNmb0Go5xzbthSof+CL9247nXlCQJSY+7hPRsnp6eGDt2LLtuNkKS0s9e83F0QxFHDxRz8kQRRw/4OLrBVePAoo1sHgs3IiIL8/LyQp06dVC6dGk0adIEBw8eRJ8+fUTHslsmmF84dngn9CYunDiNia174Z1OA3D1zN9Z3m5Mk6e7pqWqVMCN85cBABdOnEaJ8mVw7cx5XPnzL5SrURUAsGzyLLz50XQs3b8RQ99/G5+/M+e5eRQlPTe92Pjx47F9+3aEhoaKjkJE9Eo4KklEJNDQoUNhMpmg1fLpWBSzoqTPHj6ndjObjEiIjcNnu9bj6pm/MX/4RHz7x76n3uFffmjzU/fVaLUoUtIPt6+G4uqZc+j85mCcP3EKZpMJlerUQEpiEi79cQYfDZuYeR+D/gXdNOlxbnohLy8vjB49Gh9++CG+/fZb0XGIiF4aXykQEQlw4cIFlCtXDlqtlkWbYLIkPbdoA4D8RQqjXrsWkCQJ5V6rCkmSEf8oBp4Fsnd8Q+W6NXH6wFFodToENqqLz8ZNg9lkxrBZb0NRFLh6uGdZ9D2T8jg3Zcv48eNRpkwZvPfee/D3526cRGSdOCpJRGRhBoMBjRs3RkREhOgoBEAD+YVrY+q2aYZzx04CAO6EhsFoMMAjf75sP0al12tiy1drUL5mNXgW8EZCTCzuhIahRIUycHF3Q6Hivji6dTeA9A0YMkYrn0WS0nNT9nh7e2PkyJH46KOPREchInppfNYnIrKwffv2oWzZsihZsqToKATAVeOQucbt4xFv4a22vRFx/SYGVmuMPWt/AQC06NsV929FYFSjDvj4/97CpGUfZVnsZbXGDQDKvVYVMQ+jUPn1WgCAkhXLoUSFspnXeHvlAuxduxFjGnfGyIYdcGL3gedmVhQFrlruKJkTEydOxMaNG3Hr1i3RUYiIXgoP4CYisrD+/fujbt26GD16tOgohPQiaE/UVZhf4pBfUWRIaFWgLHfRy6Fp06YhJiYGX3zxhegoREQ5xsKNiMiCkpKSUKxYMVy7dg0FCxYUHYceOxYThnhjmugY2eahdUSDfFyrlVNRUVEoW7Ys/vrrL/j5+YmOQ0SUIxyVJCKyoK1bt6JevXos2lQmn85FdIQc8bayvGpRoEABvPHGG5g/f77oKEREOcbCjYjIgoKDg9G3b1/RMeg/fBzcoIF1jB1qIMHHwU10DKs1efJkrFu3Dnfu3BEdhYgoRzgqSURkIY8ePUKpUqUQHh4Od3d30XHoCYqi4GD0daSZTaKjvJCjrEVT71Jc3/YK3nrrLRgMBixdulR0FCKibGPHjYjIQjZs2IDWrVuzaFMhSZLg7+wNWeVdNxkS/J3zsWh7RW+//TZ+/PFH3L17V3QUIqJsY+FGRGQhwcHB6Nevn+gY9Ax+Tl6iI2SLteRUs8KFC2PQoEFYsGCB6ChERNnGUUkiIgu4ffs2XnvtNdy9excODjx/S63OJ9xHRGqcKo8GkCHBz8kTldwLi45iE+7evYvKlSvj4sWLKFyYX1MiUj923IiILGD9+vXo1q0bizaVq+DmA52sER0jSzpZg/JuPqJj2IyiRYuif//+7LoRkdVgx42IyAKqV6+OJUuWICgoSHQUeoFoQzJCYsNV1XWTIaG2lx+PAchlERERqFq1Ki5fvgwfHxbFRKRu7LgREeWxCxcu4NGjR2jYsKHoKJQN3joX+Dp5qmajEhkSfJ08WbTlAV9fX/Tp0wcLFy4UHYWI6IXYcSMiymPTp0+HwWDAJ598IjoKZZNJMeNk7G3EG9OEdt5kSPDQOqKOV3FoJL7XmhfCw8NRrVo1XLlyBQULFhQdh4jomfhbgIgoDymKwkO3rZBGklHbqzhcNQ7COm8yJLhqHFCbRVue8vPzQ8+ePfHZZ5+JjkJE9FzsuBER5aHjx49j2LBhuHDhAs/eskJGxYwQAZ23jE5bba/i0LJoy3O3bt1CYGAgrl27hvz584uOQ0SUJf42ICLKQxndNhZt1kkryajjVdyia94y1rTVYdFmMSVKlEC3bt2waNEi0VGIiJ6JHTciojxiMBjg6+uL33//HaVKlRIdh15RtCEZZ+LvwmA25Un3TYYEnaxBoEdRbkQiQFhYGGrWrIlr167B29tbdBwioqfwrTwiojxy4MABBAQEsGizEd46FzT2DoDf4+5bbnXgMq7l5+SJxt4BLNoE8ff3R+fOnbFkyRLRUYiIssSOGxFRHhk4cCBq1aqFsWPHio5CucxgNiE8NRZhKdEwms0w5bQDpyjQSDK0kgx/F2/4OXmp9uBvexIaGoo6derg+vXr8PLyEh2HiOhfWLgREeWB5ORkFCtWDJcvX0ahQoVEx6E8oigKogzJeKhPRLQhGYlGPSQAkiRBUQBIgMlgRJo+DU7OToAkITUmHveuhKFnq/bIr3Ph+keVGTx4MPz9/TFr1izRUYiI/oWFGxFRHvj555/x7bffYs+ePaKjkAUpioJkswFJRj1MMMOsKAgLvYFtW7Zi/JujkBIbj61btuL06dMYNGgQzGYzWrVqJTo2PeHatWuoW7cuQkND4enpKToOEVEmFm5ERHmgU6dO6NatGwYOHCg6Cgn26NEjjBo1Cl5eXvDz80NUVBT8/f0hSRK8vb3Rv39/0RHpPwYMGIBy5crhvffeEx2FiCgTCzciolwWHR0Nf39/hIeHw8PDQ3QcEkxRFOzZswdFixZFvnz5kJSUhL1792LQoEFwcnKCo6Oj6Ij0H1euXEGDBg1w48YNuLu7i45DRASAu0oSEeW6jRs3olWrVizaCED6erfWrVujUKFC+O2337B161ZotVp4enqyaFOpcuXKoUWLFli+fLnoKEREmdhxIyLKZU2aNMH48ePRuXNn0VFIJbZv3479+/ejSJEiqFmzJmrUqMFdC1Xu4sWLaNy4MW7cuAE3NzfRcYiI2HEjIspNEREROHfuHNq0aSM6CqnIypUrce3aNfj6+uLevXs4d+4cUlJSRMei56hYsSKaNGmCzz//XHQUIiIA7LgREeWqhQsX4sqVK/j6669FRyGVuXbtGvbt2wedToeEhAQEBQWhRo0aUBSFRwKo1Pnz59G8eXOEhobC1dVVdBwisnPsuBER5aLg4GD07dtXdAxSmbS0NHh6eqJ///5o3749ihcvjoz3TVm0qVflypXRsGFDfPHFF6KjEBGx40ZElFsuXbqE5s2b4/bt29BoNKLjkIpcuXIF69evh6urK+Lj43Hz5k0EBQVh2LBhMJvNkGW+j6pW586dQ6tWrRAaGgoXFxfRcYjIjvE3BRFRLlm3bh169+7Noo2eUrBgQdSrVw+tWrXC8OHD0b17d/z++++iY1E2VK1aFXXr1sWXX34pOgoR2TkWbkREuUBRFKxdu5ZjkpQlb29vVKpUCVqtFvfu3cPdu3cRFRUFgKOS1mDGjBlYsGABN5QhIqG0ogMQEdmCkJAQ6HQ6vPbaa6KjkAoZjUYsXboUzs7O0Gq1CA0NRZMmTQCwcLMGgYGBqFWrFr7++muMGzdOdBwislNc40ZElAvGjx+P/PnzY+bMmaKjkEqFh4fD1dUVrq6u0Gg0GDx4MFauXAl3d3fR0SgbTp8+jY4dOyI0NBROTk6i4xCRHWLHjYjoFRmNRvz00084evSo6CikYiaTCX///TciIyNx584dhIWFIS4ujoWblahRowYCAwPx7bffYvTo0aLjEJEdYseNiOgV7du3D9OnT0dISIjoKKRiixYtwr1791CuXDm4uLigfPnyqFKlCrRavodqLUJCQtCtWzdcv34djo6OouMQkZ3h5iRERK+Im5JQdkycOBETJkyAt7c3NBoNSpUqxaLNytSuXRuVK1fG6tWrRUchIjvEjhsR0StISUlB0aJFcfHiRRQpUkR0HFKx6OhobNyxFSmKES6urngUHY2yZcui/ut14Sxr4aZ15EYlVuDEiRPo1asXrl27BgcHB9FxiMiOsHAjInoFv/zyC7788kvs27dPdBRSGUVREGVIRqQ+ETGGZMSlpcBoNMLZyQmKosBgNMJkNMLZ2RmKokAB4KZ1QD6dC3wc3FBA58JCTqVatWqFbt264f/+7/9ERyEiO8LCjYjoFXTt2hUdOnTAkCFDREchlTCYTQhPjUVYSjSMZjNMyPmvWQ0kaGUZ/s7e8HPygk7moe5q8ttvv6Ffv364du0adDqd6DhEZCdYuBERvaTY2FiUKFECt2/fhqenp+g4JJhJMeNSYiQiUuMAAOaXKNj+S0Z6x83XyRMV3Hygkbg0XS2aN2+OPn36YNiwYaKjEJGdYOFGRJRDa9aswcKFC1G5cmUkJCRg27ZtoiORYNH6ZJxJuAuD2ZQrBdt/yZCgkzUI9CgKb51Lrl+fcu7XX3/F4MGDceXKFXbdiMgi+NYdEVEOpaWl4fLly/jpp5+we/duNGrUCA8fPhQdiwQwKWacT7iPkLhwpJmNeVK0AenduzSzESGx4TifcB8mxZwnj0PZ16hRI5QoUQJr164VHYWI7AQLNyKiHCpZsiScnJxgNpshSRIePHgAJycn0bHIwoyKGSdjbyMiNS7PCrb/MkNBRGocTsbehpHFm3CzZs3CvHnzYDQaRUchIjvAwo2IKIdKliyJtLQ0yLKMcuXK4cSJE3B3dxcdiyzIqJhxPOYW4o1pFivaMpihIN6YhuMxt1i8CRYUFISiRYti3bp1oqMQkR3gGjcioscURUGyyYAkkx4mmGFWFMiSBA1kuGoc4KLRQZIkpKWlwcnJCaVLl8bp06fh4eEhOjpZkOlxp01E0fYkGRI8tI6o41Wcm5YIdODAAYwaNQoXL15EQkICnJyc2IEnojzBwo2I7NZ/z9lKNOohAZAkCYqiABIA5Z+Pnzxn6+cvV2PSGyO5m6QdOp9w36Ljkc8jQ4KvkycquxcWHcVuKYqC2rVrI1++fDh8+DCWLVuGESNGiI5FRDZIKzoAEZGlvfCcrYz3s5T/fAwg3piGeGMa6g3sglPGSPgnG3nOlh2J1ierpmgD/lnzVtTJg7tNCmA0GjF+/HicO3cOer0eOp0Oer1edCwislEs3IjIbuTmOVsmKDCZTbiaFIWrSVE8Z8sOmBQzziTcVU3RlsEMBWfi76KxdwC//yzMaDTi4MGDkOV/vu5P/j8RUW7iswsR2YVofTIOR9/I7Jbk1ovvjGtFpMbhcPQNRBuSc+W6pD6XEiNhMJtEx8iSwWzC5cRI0THsjpOTE86ePYt+/frB0dERBoPhmbdVFAVJRj0i0xJxLy0ed1LjcC8tHpFpiUgy6sGVK0T0Iuy4EZFNe7LLlpedkifP2WL3zfYYzCZVjUj+lxkKwlPjUNa1IMd2LczR0RHffPMNmjVrhn79+uHatWsAXm0NrY+DGwroXCBJksi/GhGpDDcnISKbZVTMCBGw+1/Gbn+1vYpDy+LNJtxIfoSrSVGqLdyA9O+7sq4FEOCSX3QUu3Xu3Dl4+xSA3sPx2Wtos0EDCVpZhr+zN9fQElEmFm5EZJMyztlKMumFvNiWIcFV44C6+UqweLNyiqLgYPR1pKl0TPJJjrIGTb1Ls1MjQG6uoc0gI/3fkV18IgK4xo2IbJDpcadNVNEGpL9oSzLpERJ7GyYekmzVogzJMJqt49/QaDbjEddZWhzX0BKRJbBwIyKbcykxUvjhyED6i654YxoucdMIqxapT3ypcTcRTFAQqU8UHcNumBQzzifcR0hcONLMxjx7znlyDe35hPt8M4jITrFwIyKbotZztvhOufWKsbJ/O36vWYZRMeNk7G2LPt9kPJ+cjL0NI4s3IrvDwo2IbIbaz9niu+TWR1EUJBqzPlB58fjp6FuxPkY16vCvP1/7yXIMrBqEMU26YEyTLvhj/xFLRM2UyK3l81zGGloRnf2MTv7xmFss3ojsDAs3IrIZPGeLcluyyYBnbfPRvHdnzFn/VZaf6zRiEJYf2ozlhzajVvOgvAuYBQlAsvnZ54nRq+EaWiIShYUbEdkEazlnS62FJWUtyaR/5g6NlevWgruXV64/5uq5n+LNBu0xOqgTvpn1CQDgwe07mNZ1MEYHdcK73YYgMuLuM+8vSRKSntElpFfHNbREJAoLNyKyCeGpsaIjZIu15KR0Jphfauxw+6q1GB3UCYvHT0dCbFyWtxnTpMtTfxYfHYPjO/dj5dFtWHFkC3pPehMA8MW789CsZ2esOLIFjbu1x5fvfvjMx1aU9NyU+7iGlohEYuFGRFZPURSEpUSr5sXUs5iRnpPrj6yHWVHwzFnJZ2g7uDe+CdmLZYc2I1+hgvj2cdfsv5Yf2vzUn7l6uMPB0RFLJryH37bvhaOzEwDg8qmzaNytHQCgaY+OuBhy+tkBpMe5KVdxDS0RicbCjYisHs/ZorwiSxJy+jo9n08BaDQayLKM1v174OqZc9m+r0arxaI9P6N+h5b4Y98RzOz9fzlMDEB5nJtyFdfQEpFoLNyIyOrxnC3KKxrIz1zj9izRD/55Af37zn0oUb5Mtu+bkpiEpPgE1GoehOFzpyLswmUAQPlagfh1804AwKGN21GpTo1nXkOS0nNT7uEaWiJSA63oAEREr4rnbFFecdU4PHO09eMRb+Hv30IQHx2LgdUao9+UMWjVrztWzV6IGxcuQ4IEn+LFMHbh+1nef0yTLk+NS6YkJWHuwDHQp6ZBgYI3Zk8FAIz8cDoWjZ+OjStWwbOANyYs+eCZmRVFgavW4eX+wpQla1mbGp4aiwCX/KJjEFEekRQutiAiK6YoCnY+uIRxLbojfxEfvL/2C9GRXkiGhFYFyua4k0OWpygK9kRdVW2nJSv8/spdiqLgYPR1pFlBN8tR1qCpd2n+2xPZKM5SEJFVSzYZsOWrNfArG5Cnj2MyGnPtWjxny3pIkgQ3K+teuWkd+MI9F3ENLRGpBUcliciqXbsVhj/2H0HPCSOw+YvvcnTfWX1HYPD0SfCvVA5jm3ZF3bbN0HfyaPwwfykKFiuMogEl8eP8pXD18kDEtRtYcXgLVkyZjWt/nYdGo8Ubc95BtQZ1sG/9ZpzcfRBpKam4f/M26rZtjqGz3gYA7Fn7C35Z9g3cPD3gX6kcdA4OGPvxLCQZ9XDVWFdBYK/y6VwQb0wTHSPbvHUuoiPYFGtcQ1vAwVV0FCLKAyzciMiqvff2FAybORmJiUnPvM3O79YDSN+m/UmVXq+JCydOwcevKDRaDS6FnAEAXDh5GmMWvI/oBw9x/e+L+PzIVhQu4YtNn6+GJEn4/MhWhF+7gRk938BXx3cBAG6cv4xlBzdB5+CA/6vXBh3e6A9Zo8H6z1Zi6f6NcHZzxbtdh8C/Ujmes2VlfBzcEJESaxUv3jWQ4OPgJjqGTclqDe3mL77D3rW/QJIklKhQFhOXfAgHJ0cB6Z7GNbREtoujkkRktbZv3478BQuiTPXKz71d28G9nyraAKBynRo4f+IULob8iVrNg5CSlIzU5BQ8uB0B39L+AICygVVQuIQvAODiydNo0r0DAMCvTAB8fIviTuhNAED1Rq+nn8Hl5IjiZUsjMvwurv55DlXq1oJ7Pi9odTo06Ngq/YF5zpZVKaBzgVa2jl+XWlmD/Oy45RpFUZBo1P/rz6LuPcC2b37E4r2/4PNft8FsMuPI/3YKSvi0RKOeZ0US2Sjr+E1ERJSF3377Dft27MLA15ri4/97C+eOncSCkVOyff8ygZVx7ewFXDhxGpXr1kSpKhWw58cNKF21UuZtnFycs3UtncM/Y4+yRobJ9JyNDHjOllWRJAn+zt6Qc3oSt4XJkODvnI/r23JRssmQ5b+6yWiCPjUVJqMRaSkpyF/IJ9vX3Ld+M+YNHosZvYZjeJ1WWDV7Qebn/jz0G95q0xvjmnXFh8MmICUxCVfP/I15g8cCAI7vOoAuxavDoNdDn5qGoTVbPHV9rqElsl0s3IjIan300Uc4G3oFP/x5CO989SmqNqiDt1d+ku376xwcULBYYRzbugfla1ZHpddrYNPnq1G5bs0sb1/p9Zo4tHEbAOBOaBgi79zN7MxlpUxgFfx9/A8kxMbBZDTit+17AfCcLWvk5+QlOkK2WEtOa5Fk0j9VCBcoUghdRw3B4MBm6F+lEVzd3fFak/pP3Xfnd+szx7T/68b5y5j69WdYcWQrft2yCw/v3EPcoxisX7QSH/yyCksPbEKZapWw+YvvUKpKBdw4n36e34UTp1GifBlcO3MeV/78C+VqVH3q2pIkIek/XUIisg1c40ZEVu1552xleNYaNwCo9HoNnP31BBydnVDp9ZqIunsflV7P+nDjdkP6YMWU2RgV1BEajRYTl34EneOzNxgpUKQQeo4fgUmtesItnxf8SvvDxcOd52xZIZ2sga+Tp2oPYZYhwc/JEzpZIzqKTTHB/NTzS0JsHE7sPohVp/bB1dMdHw2biIMbtqJpj47/ul1WzzcZMkarAWSOVifFxyP8aigmt+8HADAaDChfsxo0Wi2KlPTD7auhuHrmHDq/ORjnT5yC2WTK8iB2rqElsl08x42IrJraz9lKSUyCs5srTEYj5g0eixZ9uqJBu5Y8Z8sKmRQzDkffQJo5946GyC2OshaNvQOgkdjJzU13UuNwPvE+TE+8VDq6dTdOHzyKCYvTD0E/8NP/cPn0Xxj9yaxsXXPf+s24fvY8Rs6fAQB4v9+b6DpqKFISk3B403a88+WnT91n3aefw8nFBX/sP4J3vvwUn42bBrPJjGGz3kbJimX/dVuNJKOyWyEUc/J82b82EakUn+GJyKqp/ZyttQtWYEyTLhjVqCMKFfdF3bbNec6WldJIMgI9iqpurZsMCYEeRVm05QFZkvDf94QKFiuCK6f/QmpyChRFwV9HT8CvbKlXfqzyNarhUsgZ3L1xCwCQmpSMO6FhANLHtLd8tQbla1aDZwFvJMTE4k5oGEpUKPP0hbiGlshmcVSSiKyems/ZemP205ul8Jwt6+Wtc1HVyKQMCb5OnvyeyiMayOlvsjzRcStfoxrqt2+F8c27QaPVIKByBbQZ0POp+z5vRDsrngW8MXHph/jkzckwpKWvURswbTyKlfJHudeqIuZhFCq/XgsAULJiOcRERmX5BhDX0BLZLo5KEpHVe6hPwp9xEVZzzlYNT18ekGvFTIoZJ2NvI96YJrR4kyHBQ+uIOl7F2W3LI0lGPY7FhFnFc0sGDSQ08PaHq0a9kwhE9HL4TE9EVo/nbJElaSQZtb2Kw1XjIGxsUoYEV40DarNoy1MuGp0VlWzpFAAusk50DCLKA3y2JyKrx3O2yNK0koy6+UrAQ+to8e+7jE5b3XwloGXRlqfUvoY2K1xDS2S7+IxPRDbBWs6vspac9GJaSUYdr+LwdfK0WPGWsaatjldxFm0Wks/KOuRc70hku/isT0Q2IeOcLbV23XjOlm3SSDIquxdGbS8/OMraPPv+kyHBUdaitpcfKrsX5nikBfk4uEGj0ueV/9JAgo+Dm+gYRJRH+MxPRDajgpuPagsjnaxBeTcf0TEoj3jrXNDYOwB+j988yK0CLuNafk6eaOwdwG6KAFxDS0RqwV0licimRBuSERIbroqt2jPIkFDby48vuu2EwWxCeGoswlKiYTSbX2pHQg0kaGUZ/s7e8HPyUu0bEvbiRvIjXE2KUtXzyn/JkFDWtQACXPKLjkJEeYTnuBGRTeE5WySaTtYgwCU//J29EWVIxkN9IqINyUg06iEhfcMLRQEgAVDSz91SFAUK0jeW8Na5wMfBDfl1LtxkQiX8nLxwNSlKdIwX4hpaItvGwo2IbE4FNx/EG1NVc85WBY5I2iVJklDQwRUFH5/ZpygKks0GJBn1MMEMs6JAliRoIMNV6wAXWcdCTaUy1tCq5Q2h/+IaWiL7wFFJIrJJRsWM4zG3kGTSC3mhlXHOFrdsJ7INJsWMw9E3kGY2io7yFEdZi8beAdy0hsjG8SeciGwSz9kiotykkWQEehRV3c61MiQEehRl0UZkB/hTTkQ2i+dsEVFuylhDq5bijWtoiewLRyWJyC5EG5JxJv4uDGZTnoxOypCgkzUI9CjKF1FENsykmHEy9rZq1tDW8SrObhuRnWDhRkR2w6SYcTkxEuGpcQCQKy+6Mt5593PyRHk3H76AIrIDXENLRCKwcCMiu8NztojoVRkVM0IEdN4yOm21OY5NZHdYuBGR3VIUhedsEdFLMylmXEqMtNgxARlr2iqwu09kl1i4ERE9xnO2iOhlcA0tEVkCCzciIiKiV8Q1tESU11i4EREREeUSrqElorzCwo2IiIgol3ENLRHlNhZuRERERHmMa2iJ6FWxcCMiIiIiIlI5rnIlIiIiIiJSORZuREREREREKsfCjYiIiIiISOVYuBEREREREakcCzciIiIiIiKVY+FGRERERESkcizciIiIiIiIVI6FGxERERERkcqxcCMiIiIiIlI5Fm5EREREREQqx8KNiIiIiIhI5Vi4ERERERERqRwLNyIiIiIiIpVj4UZERERERKRyLNyIiIiIiIhUjoUbERERERGRyrFwIyIiIiIiUjkWbkRERERERCrHwo2IiIiIiEjlWLgRERERERGpHAs3IiIiIiIilWPhRkREREREpHIs3IiIiIiIiFSOhRsREREREZHKsXAjIiIiIiJSORZuREREREREKsfCjYiIiIiISOVYuBEREREREakcCzciIiIiIiKVY+FGRERERESkcizciIiIiIiIVI6FGxERERERkcqxcCMiIiIiIlI5Fm5EREREREQqx8KNiIiIiIhI5Vi4ERERERERqRwLNyIiIiIiIpVj4UZERERERKRyLNyIiIiIiIhUjoUbERERERGRyrFwIyIiIiIiUjkWbkRERERERCrHwo2IiIiIiEjlWLgRERERERGpHAs3IiIiIiIilWPhRkREREREpHIs3IiIiIiIiFSOhRsREREREZHKsXAjIiIiIiJSORZuREREREREKsfCjYiIiIiISOVYuBEREREREakcCzciIiIiIiKVY+FGRERERESkcizciIiIiIiIVI6FGxERERERkcqxcCMiIiIiIlK5/weQ4mz0WNhzPwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "stanzaTools.drawDepGraph(nodeList, edgeList)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hydraulic-lewis",
   "metadata": {},
   "source": [
    "### 🔎 Testing Spacy (SKIP for Now) 🔎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "respected-resource",
   "metadata": {},
   "outputs": [],
   "source": [
    "import spacy\n",
    "\n",
    "# Load English tokenizer, tagger, parser and NER\n",
    "nlp = spacy.load(\"en_core_web_sm\")\n",
    "\n",
    "# Process whole documents\n",
    "text = sampleSentence\n",
    "doc = nlp(text)\n",
    "# Analyze syntax\n",
    "print(\"Noun phrases:\", [chunk.text for chunk in doc.noun_chunks])\n",
    "print(\"Verbs:\", [token.lemma_ for token in doc if token.pos_ == \"VERB\"])\n",
    "\n",
    "# Find named entities, phrases and concepts\n",
    "for entity in doc.ents:\n",
    "    print(entity.text, entity.label_)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "behind-circus",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "spacy.displacy.render(doc, style='dep', jupyter=True, options={'distance': 120})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "surgical-battle",
   "metadata": {},
   "outputs": [],
   "source": [
    "doc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "weird-capture",
   "metadata": {},
   "source": [
    "### 🔎 Testing TF Datasets 🔎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "chemical-utilization",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow_datasets as tfds\n",
    "import tensorflow as tf\n",
    "import spacy\n",
    "import tfDatasetTools\n",
    "nlp = spacy.load(\"en_core_web_sm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "threatened-toolbox",
   "metadata": {},
   "outputs": [],
   "source": [
    "trainDS = tfds.load('imdb_reviews', split='train', as_supervised=True, shuffle_files=True)\n",
    "testDS = tfds.load('imdb_reviews', split='test', as_supervised=True, shuffle_files=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "visible-yeast",
   "metadata": {},
   "outputs": [],
   "source": [
    "part = testDS.take(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "affected-style",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 🐝 decodeZeroDimTensor 🐝"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d958e3d-c23b-484a-8355-d10a339933f1",
   "metadata": {},
   "source": [
    "moved to tfDatasetTools.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "billion-cause",
   "metadata": {},
   "source": [
    "#### 🐝 convertTakeDataset 🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "contemporary-representation",
   "metadata": {},
   "outputs": [],
   "source": [
    "features, labels = tfDatasetTools.convertTakeDataset(part)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eastern-headset",
   "metadata": {},
   "outputs": [],
   "source": [
    "features[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "intellectual-mortgage",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fitting-writer",
   "metadata": {},
   "outputs": [],
   "source": [
    "nlp = stanza.Pipeline(\n",
    "    'en',\n",
    "    processors = 'tokenize,mwt,pos,lemma,depparse, sentiment')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "controversial-literacy",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "doc = nlp(features[1])\n",
    "for sentence in doc.sentences:\n",
    "    print(sentence.text)\n",
    "    print(sentence.sentiment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "engaged-triple",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "doc.sentences[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "explicit-reply",
   "metadata": {},
   "source": [
    "### 🔎 Testing spektral 🔎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "understood-basketball",
   "metadata": {},
   "outputs": [],
   "source": [
    "import spektral\n",
    "from spektral.datasets import TUDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "introductory-fundamental",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = TUDataset('PROTEINS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "elder-catch",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "living-stockholm",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_datset = dataset[:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "worse-feature",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_datset = dataset[100:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "indonesian-immune",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dense, Dropout\n",
    "from spektral.layers import GCNConv, GlobalSumPool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "advance-evidence",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyFirstGNN(Model):\n",
    "\n",
    "    def __init__(self, n_hidden, n_labels):\n",
    "        super().__init__()\n",
    "        self.graph_conv = GCNConv(n_hidden)\n",
    "        self.pool = GlobalSumPool()\n",
    "        self.dropout = Dropout(0.5)\n",
    "        self.dense = Dense(n_labels, 'softmax')\n",
    "\n",
    "    def call(self, inputs):\n",
    "        out = self.graph_conv(inputs)\n",
    "        out = self.dropout(out)\n",
    "        out = self.pool(out)\n",
    "        out = self.dense(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "empty-april",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MyFirstGNN(32, dataset.n_labels)\n",
    "model.compile('adam', 'categorical_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "promising-launch",
   "metadata": {},
   "outputs": [],
   "source": [
    "from spektral.data import BatchLoader\n",
    "\n",
    "loader = BatchLoader(train_datset, batch_size=32)\n",
    "testLoader = BatchLoader(test_datset, batch_size=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "catholic-interest",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(loader.load(),steps_per_epoch=loader.steps_per_epoch, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "polyphonic-cambodia",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(testLoader.load(),steps=testLoader.steps_per_epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "russian-trainer",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_datset[12].y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moral-cooler",
   "metadata": {},
   "source": [
    "## ፨ Part 2: Graph Networks ፨ "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "choice-explanation",
   "metadata": {},
   "source": [
    "### 📦 Basic Imports 📦 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "funky-structure",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow_datasets as tfds\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import stanza\n",
    "import networkx as nx\n",
    "import tensorflow_hub as hub\n",
    "import tensorflow_text\n",
    "import spektral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "graphic-phenomenon",
   "metadata": {},
   "outputs": [],
   "source": [
    "import stanzaTools\n",
    "import tfDatasetTools\n",
    "import relationEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "997bbbb6-e771-491c-98e4-a105cf1063a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import io, time, joblib, json\n",
    "from importlib import reload"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "original-newfoundland",
   "metadata": {},
   "source": [
    "### 📦 Set up Stanza 📦"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "applied-india",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1acf4988e2ea40ff90bbe4795bdf64e2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading https://raw.githubusercontent.com/stanfordnlp/stanza-resources/main/resources_1.4.0.json:   0%|   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-08 14:38:22 INFO: Downloading default packages for language: en (English)...\n",
      "2022-06-08 14:38:23 INFO: File exists: /Users/zeyuyang/stanza_resources/en/default.zip\n",
      "2022-06-08 14:38:26 INFO: Finished downloading models and saved to /Users/zeyuyang/stanza_resources.\n"
     ]
    }
   ],
   "source": [
    "stanza.download('en')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "maritime-enough",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 📀 Load Data 📀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "native-friendship",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metal device set to: Apple M1 Max\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-07 14:21:06.976083: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:305] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2022-06-07 14:21:06.976329: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:271] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
     ]
    }
   ],
   "source": [
    "trainDS = tfds.load('imdb_reviews', split='train', as_supervised=True, shuffle_files=True)\n",
    "testDS = tfds.load('imdb_reviews', split='test', as_supervised=True, shuffle_files=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "related-literacy",
   "metadata": {},
   "source": [
    "#### 🫥 Set a Limit 🫥"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "neutral-appointment",
   "metadata": {},
   "outputs": [],
   "source": [
    "trainLimit = 25000\n",
    "testLimit = 25000\n",
    "\n",
    "trainSubset = trainDS.take(trainLimit)\n",
    "testSubset = testDS.take(testLimit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "driven-guarantee",
   "metadata": {},
   "outputs": [],
   "source": [
    "validationSplit = 0.2\n",
    "validationIndex = int(validationSplit * trainLimit)\n",
    "\n",
    "validationSplitSubset = trainSubset.take(validationIndex)\n",
    "trainSplitSubset = trainSubset.skip(validationIndex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "complicated-panama",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-07 14:21:11.534515: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
     ]
    }
   ],
   "source": [
    "trainFeatures, trainLabels = tfDatasetTools.convertTakeDataset(trainSplitSubset)\n",
    "valFeatures, valLabels = tfDatasetTools.convertTakeDataset(validationSplitSubset)\n",
    "testFeatures, testLabels = tfDatasetTools.convertTakeDataset(testSubset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19d15ba0-9789-4540-aa32-0297f0c38359",
   "metadata": {
    "tags": []
   },
   "source": [
    "##### 📦 Load the right stanza Pipeline 📦"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "901e073e-4306-4575-afd2-5b37da9e33f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8488b67489e04b7b861a567827c098a9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading https://raw.githubusercontent.com/stanfordnlp/stanza-resources/main/resources_1.4.0.json:   0%|   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-07 17:26:06 WARNING: Can not find mwt: default from official model list. Ignoring it.\n",
      "WARNING:stanza:Can not find mwt: default from official model list. Ignoring it.\n",
      "2022-06-07 17:26:06 INFO: Loading these models for language: en (English):\n",
      "========================\n",
      "| Processor | Package  |\n",
      "------------------------\n",
      "| tokenize  | combined |\n",
      "========================\n",
      "\n",
      "INFO:stanza:Loading these models for language: en (English):\n",
      "========================\n",
      "| Processor | Package  |\n",
      "------------------------\n",
      "| tokenize  | combined |\n",
      "========================\n",
      "\n",
      "2022-06-07 17:26:06 INFO: Use device: cpu\n",
      "INFO:stanza:Use device: cpu\n",
      "2022-06-07 17:26:06 INFO: Loading: tokenize\n",
      "INFO:stanza:Loading: tokenize\n",
      "2022-06-07 17:26:06 INFO: Done loading processors!\n",
      "INFO:stanza:Done loading processors!\n"
     ]
    }
   ],
   "source": [
    "nlp = stanza.Pipeline(\n",
    "    'en',\n",
    "    processors = 'tokenize, mwt')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0312c200-058c-4dd5-8fc3-f6e840219f3d",
   "metadata": {},
   "source": [
    "#### 🤖Create Custom tokenizer🤖\n",
    "The goal is to matche our tokenizer to the one used by stanza. The ideas is to first tokenize all of the train+validation reviews into words. Then use our own tokenizer to parse all of these words to learn what the vocabulary is. Later, we will use stanza to break each feature into a list of nodes. The list of nodes will be converted using our own tokenizer into a list of ints. The list of ints will be used to train the embedding model and to create the embeddings for the graph model.\n",
    "\n",
    "Use joblib with parallel jobs to speed up the processing by about 200%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4cf27551-528d-4d46-be36-8f8b039bc546",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getStanzaProSents(features):\n",
    "    tokenizedSentences = []\n",
    "    for feature in features:\n",
    "        doc = nlp(feature)\n",
    "        for sentence in doc.sentences:\n",
    "            tokenizedSentences.append(\" \".join([item['text'] for item in sentence.to_dict()]))\n",
    "    return tokenizedSentences"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f677dbc-5ac6-4bf4-aa55-74540cdbb1e9",
   "metadata": {},
   "source": [
    "This takes about 42 seconds per 1000 reviews"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1fc64ced-4588-47f4-92d9-d4705b4ed878",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1129.3985874999998\n"
     ]
    }
   ],
   "source": [
    "startTime = time.perf_counter()\n",
    "step = 50\n",
    "totalFeatures = trainFeatures + valFeatures\n",
    "results = joblib.Parallel(n_jobs=8, prefer=\"threads\")(joblib.delayed(getStanzaProSents)(totalFeatures[i:i + step]) for i in range(0,trainLimit,step))\n",
    "print(time.perf_counter()-startTime)\n",
    "deListed = []\n",
    "for i in results:\n",
    "    deListed += i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "alien-packing",
   "metadata": {},
   "outputs": [],
   "source": [
    "customTokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=30000, oov_token='OOVTOKEN', filters='', lower = True, split = ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "c878ce1f-4829-44c0-a1dc-bd195fa2dc7c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "customTokenizer.fit_on_texts(deListed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fdbb9848-af23-4263-9741-0d88f74d54ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "file_path = './tokenizer/token' + '25000' + '.json'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3ab6d40a-20a1-4f55-9e34-5a21902c339d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# use if you want to rewrite the file\n",
    "tokenizer_json = customTokenizer.to_json()\n",
    "with io.open(file_path, 'w', encoding='utf-8') as f:\n",
    "            f.write(json.dumps(tokenizer_json, ensure_ascii=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "844e759c-4ff8-46f1-ac80-9a97796e5565",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(file_path) as f:\n",
    "            data = json.load(f)\n",
    "            customTokenizer = tf.keras.preprocessing.text.tokenizer_from_json(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7b16cdd1-f7f2-47ea-b6d3-4c6cf37235de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "82222"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(customTokenizer.index_word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e0c67646-8241-4c25-8ab4-3019e53f34a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "one = customTokenizer.texts_to_sequences([trainFeatures[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0d97f311-ca2c-49e3-bc4e-fbb132862c13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"it is amazing to me what passes for entertainment OOVTOKEN maybe i am a dinosaur from the OOVTOKEN and i am out of touch with todays movie going OOVTOKEN and apparently that is the case with regards to this OOVTOKEN since so many people loved OOVTOKEN i found it foul and OOVTOKEN i OOVTOKEN said that about many movies in my life but this one fits the OOVTOKEN the humor is sophomoric and OOVTOKEN i am not a politically correct OOVTOKEN and even i found the gay OOVTOKEN not only not funny but downright offensive ( i'm not OOVTOKEN the main character in the movie is not even a likable OOVTOKEN just OOVTOKEN when the movie was finally over i heard a number of people comment on how disappointed they were in what they had just pay good money to OOVTOKEN\"]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "customTokenizer.sequences_to_texts(one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a7eee01-a278-45ff-89f9-6024ace307c6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dependent-paper",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 💽Bert Embeddings (not used too expensive)💽"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "current-jesus",
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.keras.backend.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "id": "multiple-distributor",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-29 23:02:06.956843: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    }
   ],
   "source": [
    "# Preprocess and encode input\n",
    "text_input = tf.keras.layers.Input(shape=(), dtype=tf.string)\n",
    "\n",
    "preprocessor = hub.KerasLayer('https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3')\n",
    "encoder_inputs = preprocessor(text_input)\n",
    "\n",
    "encoder = hub.KerasLayer('https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/2',trainable=False)\n",
    "\n",
    "outputs = encoder(encoder_inputs)\n",
    "\n",
    "pooled_output = outputs['pooled_output'] # [batch_size, 128].\n",
    "# [batch_size, seq_length, 128].\n",
    "\n",
    "sequence_output = outputs['sequence_output']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "canadian-industry",
   "metadata": {
    "tags": [],
    "toc-hr-collapsed": true
   },
   "source": [
    "##### 🐛 Sample Convert to BERT Embedding 🐛"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "id": "major-condition",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-29 23:02:11.958773: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
      "2022-05-29 23:02:12.132296: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    }
   ],
   "source": [
    "text = \"hello there who are you hello there who are you hello there who are you hello there who are you hello there who are you hello there who are you\"\n",
    "words = text.split()\n",
    "converted = stanzaTools.convertToEmbedding(words, preprocessor, encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "id": "light-snake",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(30, 128)"
      ]
     },
     "execution_count": 413,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "converted.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "id": "coordinate-softball",
   "metadata": {},
   "outputs": [],
   "source": [
    "converted = stanzaTools.convertToEmbedding(['!'], preprocessor, encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "id": "international-hungary",
   "metadata": {},
   "outputs": [],
   "source": [
    "word = ['hello', 'there']\n",
    "convertedWords = stanzaTools.convertToEmbedding(word, preprocessor, encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "id": "recorded-dealer",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 128)"
      ]
     },
     "execution_count": 416,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "convertedWords.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da6de07d-5213-43a9-8165-75357ad7b281",
   "metadata": {},
   "source": [
    "#### 💽Training Custom Embeddings💽"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72d67db5-e0f4-4c70-b0b7-3e1efff2ffaf",
   "metadata": {},
   "source": [
    "Tokenize and pad the train and val features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "8a783f22-033d-4846-a666-4cfa3b01e9be",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.sequence import pad_sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1cd8d724-0db9-4061-8c66-47e4bcd31511",
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_SEQUENCE_LENGTH = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7127cd8a-7599-402d-ba66-7f06c43dac78",
   "metadata": {},
   "outputs": [],
   "source": [
    "xTrain = customTokenizer.texts_to_sequences(trainFeatures)\n",
    "xTrain = pad_sequences(xTrain, maxlen=MAX_SEQUENCE_LENGTH, padding='post', truncating='post')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d3570a95-3cc4-4e31-832d-ae1b45fa57f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20000, 256)\n",
      "(20000,)\n"
     ]
    }
   ],
   "source": [
    "yTrain = np.array(trainLabels)\n",
    "print(xTrain.shape)\n",
    "print(yTrain.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "87bd63ca-cfb3-410f-8e67-f986ecefdb53",
   "metadata": {},
   "outputs": [],
   "source": [
    "xValidation = customTokenizer.texts_to_sequences(valFeatures)\n",
    "xValidation = pad_sequences(xValidation, maxlen=MAX_SEQUENCE_LENGTH, padding='post', truncating='post')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6e1a8bf1-c716-4ad6-a6fc-394e629f81d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5000, 256)\n",
      "(5000,)\n"
     ]
    }
   ],
   "source": [
    "yValidation = np.array(valLabels)\n",
    "print(xValidation.shape)\n",
    "print(yValidation.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "cf25d1c1-01c0-414b-ae91-9ab6b2dabe93",
   "metadata": {},
   "outputs": [],
   "source": [
    "testLimit = 25000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5c7c662b-644f-45e1-b7e6-f29f253b19fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "xTest = customTokenizer.texts_to_sequences(testFeatures[0:testLimit])\n",
    "xTest = pad_sequences(xTest, maxlen=MAX_SEQUENCE_LENGTH, padding='post', truncating='post')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "89556f98-b688-4503-945b-0e7af5337d18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25000, 256)\n",
      "(25000,)\n"
     ]
    }
   ],
   "source": [
    "yTest = np.array(testLabels[0:testLimit])\n",
    "print(xTest.shape)\n",
    "print(yTest.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8b0b07df-7b0e-4f68-be9d-a64edf9beec6",
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.random.set_seed(420)\n",
    "np.random.seed(420)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ecae2e5-794f-40dc-a1b1-97432df859fa",
   "metadata": {},
   "source": [
    "Make the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "front-avenue",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sampleModel():\n",
    "    sequence_input = tf.keras.layers.Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')\n",
    "    embedding_layer = tf.keras.layers.Embedding(30000,\n",
    "                                                16)(sequence_input)\n",
    "    pool = tf.keras.layers.GlobalAveragePooling1D()(embedding_layer)\n",
    "    dense_layer = tf.keras.layers.Dense(16, activation='relu')(pool)\n",
    "    dropout_layer = tf.keras.layers.Dropout(0.3)(dense_layer)\n",
    "    outputs = tf.keras.layers.Dense(1)(dropout_layer)\n",
    "\n",
    "    return tf.keras.Model(inputs=sequence_input, outputs=outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "preliminary-amateur",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 256)]             0         \n",
      "                                                                 \n",
      " embedding (Embedding)       (None, 256, 16)           480000    \n",
      "                                                                 \n",
      " global_average_pooling1d (G  (None, 16)               0         \n",
      " lobalAveragePooling1D)                                          \n",
      "                                                                 \n",
      " dense (Dense)               (None, 16)                272       \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 16)                0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 1)                 17        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 480,289\n",
      "Trainable params: 480,289\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "tf.keras.backend.clear_session()\n",
    "embeddingModel = sampleModel()\n",
    "embeddingModel.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "beginning-tiffany",
   "metadata": {},
   "outputs": [],
   "source": [
    "embeddingModel.compile(\n",
    "    optimizer='adam',\n",
    "    loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
    "    metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "recreational-buffalo",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-07 15:25:50.698912: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "622/625 [============================>.] - ETA: 0s - loss: 0.6018 - accuracy: 0.5964"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-07 15:25:58.387285: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625/625 [==============================] - 8s 13ms/step - loss: 0.6010 - accuracy: 0.5974 - val_loss: 0.4440 - val_accuracy: 0.7610\n",
      "Epoch 2/5\n",
      "625/625 [==============================] - 8s 13ms/step - loss: 0.3553 - accuracy: 0.8384 - val_loss: 0.3397 - val_accuracy: 0.8610\n",
      "Epoch 3/5\n",
      "625/625 [==============================] - 7s 12ms/step - loss: 0.2653 - accuracy: 0.8846 - val_loss: 0.3180 - val_accuracy: 0.8600\n",
      "Epoch 4/5\n",
      "625/625 [==============================] - 9s 14ms/step - loss: 0.2123 - accuracy: 0.9099 - val_loss: 0.3200 - val_accuracy: 0.8734\n",
      "Epoch 5/5\n",
      "625/625 [==============================] - 9s 14ms/step - loss: 0.1653 - accuracy: 0.9313 - val_loss: 0.3216 - val_accuracy: 0.8722\n"
     ]
    }
   ],
   "source": [
    "history = embeddingModel.fit(\n",
    "    xTrain,\n",
    "    yTrain,\n",
    "    validation_data=(xValidation, yValidation),\n",
    "    epochs=5,\n",
    "    verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "beneficial-gates",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 3s 4ms/step - loss: 0.3558 - accuracy: 0.8477\n"
     ]
    }
   ],
   "source": [
    "results = embeddingModel.evaluate(x=xTest, y=yTest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4bd5bf24-acb5-4803-b6f2-35d579b54b03",
   "metadata": {},
   "outputs": [],
   "source": [
    "savePath = \"./embeddingModel/embed16_25k\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b77d7378-8b31-402a-a0bf-fb32f591671e",
   "metadata": {},
   "outputs": [],
   "source": [
    "embeddingModel.save(savePath)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ad798c7-f157-4258-8bab-7c21c32e39ff",
   "metadata": {},
   "source": [
    "**If you want to load a pre-existing model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2dcffbb4-a382-4c11-a427-3e9c94eedfbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<keras.engine.input_layer.InputLayer at 0x7d527ca580>,\n",
       " <keras.layers.embeddings.Embedding at 0x7d527a84c0>,\n",
       " <keras.layers.pooling.GlobalAveragePooling1D at 0x7d527a89a0>,\n",
       " <keras.layers.core.dense.Dense at 0x7d527a8b80>,\n",
       " <keras.layers.core.dropout.Dropout at 0x7d4f342100>,\n",
       " <keras.layers.core.dense.Dense at 0x7d4f3422e0>]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loadedModel = tf.keras.models.load_model(savePath)\n",
    "loadedModel.layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e476d1b7-fcdf-4eb9-baf4-4e1fbfa6460e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 256)]             0         \n",
      "                                                                 \n",
      " embedding (Embedding)       (None, 256, 16)           480000    \n",
      "                                                                 \n",
      " global_average_pooling1d (G  (None, 16)               0         \n",
      " lobalAveragePooling1D)                                          \n",
      "                                                                 \n",
      " dense (Dense)               (None, 16)                272       \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 16)                0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 1)                 17        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 480,289\n",
      "Trainable params: 480,289\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "loadedModel.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c30a116-776f-4498-b2fe-ea66a1e1b664",
   "metadata": {},
   "source": [
    "##### 🐛Sample Convert to Custom Embeddings (for debug purposes)🐛"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "2c2ec222-b641-48ac-84ff-ebd6cfcb9cf8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<keras.layers.embeddings.Embedding at 0x2d591ac10>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embeddingModel.layers[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "de036072-ea80-4f9f-bce5-0c2bad2a7d58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['why', 'did', 'I', 'do', 'this']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listOfWords = \"why did I do this\".split()\n",
    "listOfWords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "5a85901d-ad74-45c2-a780-a370fc904d69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[147], [83], [12], [50], [13]]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence = customTokenizer.texts_to_sequences(listOfWords)\n",
    "sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "8d93ba14-5113-4b8a-8c82-578f76a504fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([147,  83,  12,  50,  13])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reshapedSeq = np.array([item[0] for item in sequence])\n",
    "reshapedSeq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d7da9733-e41b-4727-9373-b1b8c883cb48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.06583753, -0.14925908, -0.07439847, -0.11051435,  0.13862614,\n",
       "         0.09201127, -0.16731969, -0.1010332 , -0.13546863,  0.13432755,\n",
       "         0.08380182, -0.04522675,  0.08616781,  0.08880984,  0.03236263,\n",
       "        -0.07402526],\n",
       "       [-0.03517925, -0.09838024, -0.09140101, -0.08225321,  0.09395648,\n",
       "         0.12466376, -0.0624707 , -0.1158405 , -0.07749478,  0.12928651,\n",
       "         0.03179754, -0.09451605,  0.12110313,  0.1594039 ,  0.0286512 ,\n",
       "        -0.06960334],\n",
       "       [ 0.03472452,  0.02322617, -0.03128216,  0.04207388, -0.04271244,\n",
       "         0.01156361,  0.05967582, -0.0290033 , -0.03640172, -0.02010541,\n",
       "        -0.02718968, -0.05278517, -0.01194761,  0.05206764, -0.153005  ,\n",
       "         0.06796191],\n",
       "       [-0.04292245, -0.16216798, -0.10949111, -0.13775189,  0.10121065,\n",
       "         0.06401047, -0.08168249, -0.14128214, -0.08900571,  0.05968   ,\n",
       "         0.0589614 , -0.07539045,  0.07043786,  0.11637982,  0.02042517,\n",
       "        -0.10202847],\n",
       "       [-0.02709097, -0.03695998, -0.02162378, -0.04302891,  0.04687724,\n",
       "         0.0432179 , -0.0351271 , -0.03887198,  0.04895001, -0.02503408,\n",
       "        -0.05711193, -0.17074299,  0.0254335 ,  0.06346203, -0.09451028,\n",
       "        -0.01556538]], dtype=float32)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embeddedSeq = embeddingModel.layers[1](reshapedSeq)\n",
    "np.array(embeddedSeq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99fe2c4a-9b57-4e3c-9c6f-44a8e10f1a0b",
   "metadata": {},
   "source": [
    "#### 🐝 convertToCustomEmbedding 🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "064c2287-09f2-4b1f-9851-5b5001d1fb4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convertToCustomEmbedding(words):\n",
    "    \"\"\"\n",
    "    Takes a list of words and converts it to a list of custom embeddings. \n",
    "\n",
    "    Args:\n",
    "        words - (list) The list of words to convert\n",
    "    Returns:\n",
    "        embeddings - (list) A list of embeddings\n",
    "    \"\"\"\n",
    "    sequence = customTokenizer.texts_to_sequences(words)\n",
    "    reshapedSeq = np.array([item[0] for item in sequence])\n",
    "    try:\n",
    "        convertedWords = embeddingModel.layers[1](reshapedSeq)\n",
    "    except:\n",
    "        print(words)\n",
    "        print(reshapedSeq)\n",
    "    return np.array(convertedWords)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "expected-coordinator",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 🐝 createGraph 🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "descending-wallpaper",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'tfDatasetTools' from '/Users/zeyuyang/Projects/CS397Project/tfDatasetTools.py'>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reload(stanzaTools)\n",
    "reload(tfDatasetTools)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "034e37c7-eb6d-46d6-a4e4-d43ebff3e657",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "relationsDict = relationEncoder.getRelationsDict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c1121f0-8d7e-4e5f-a058-0789818f2cde",
   "metadata": {},
   "source": [
    "❗️**ONLY USE createGraphAlpha THE REST ARE TOO SLOW AND MAY THROW ERRORS**❗️"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97788ca4-4b3c-4b68-a0b9-6816dd367fe2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createGraph(doc, positive):\n",
    "    startTime = time.perf_counter()\n",
    "    nodeList, edgeList = stanzaTools.getNodeEdgeLists(doc)\n",
    "    nodeTime = time.perf_counter()\n",
    "    words = [item['text'] for item in nodeList]\n",
    "    convertedFeatures = stanzaTools.convertToEmbedding(words, preprocessor, encoder)\n",
    "    adjacencyMatrix = stanzaTools.createAdjacencyMatrix(edgeList, len(nodeList))\n",
    "    convertTime = time.perf_counter()\n",
    "    sortedList = sorted(edgeList, key=lambda x: (x['edgePair'][0], x['edgePair'][1]))\n",
    "    edgeFeatures = relationEncoder.OneHotEncode(relationsDict, [edge['edgeLabel'] for edge in sortedList])\n",
    "    encodeTime = time.perf_counter()\n",
    "    label = np.array([positive])\n",
    "    print([nodeTime - startTime, convertTime  - nodeTime, encodeTime - convertTime])\n",
    "    # newGraph = spektral.data.graph.Graph(x=convertedFeatures, a=adjacencyMatrix, y=label)\n",
    "    return (convertedFeatures, adjacencyMatrix, edgeFeatures, label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c20d4ee-f465-49f5-823f-e9c168eb6fcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createCustomGraph(doc, positive):\n",
    "    startTime = time.perf_counter()\n",
    "    nodeList, edgeList = stanzaTools.getNodeEdgeLists(doc)\n",
    "    nodeTime = time.perf_counter()\n",
    "    words = [item['text'] for item in nodeList]\n",
    "    convertedFeatures = stanzaTools.convertToCustomEmbedding(words, preprocessor, model.layers[2])\n",
    "    adjacencyMatrix = stanzaTools.createAdjacencyMatrix(edgeList, len(nodeList))\n",
    "    convertTime = time.perf_counter()\n",
    "    sortedList = sorted(edgeList, key=lambda x: (x['edgePair'][0], x['edgePair'][1]))\n",
    "    edgeFeatures = relationEncoder.OneHotEncode(relationsDict, [edge['edgeLabel'] for edge in sortedList])\n",
    "    encodeTime = time.perf_counter()\n",
    "    label = np.array([positive])\n",
    "    print([nodeTime - startTime, convertTime  - nodeTime, encodeTime - convertTime])\n",
    "    # newGraph = spektral.data.graph.Graph(x=convertedFeatures, a=adjacencyMatrix, y=label)\n",
    "    return (convertedFeatures, adjacencyMatrix, edgeFeatures, label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d413e7e-3c08-4ade-8195-63eccc21c603",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createCustomGraph2(doc, positive):\n",
    "    startTime = time.perf_counter()\n",
    "    nodeList, edgeList = stanzaTools.getNodeEdgeLists(doc)\n",
    "    nodeTime = time.perf_counter()\n",
    "    words = [item['text'] for item in nodeList]\n",
    "    print(len(words))\n",
    "    convertedFeatures = convertToCustomEmbedding(words)\n",
    "    adjacencyMatrix = stanzaTools.createAdjacencyMatrix(edgeList, len(nodeList))\n",
    "    convertTime = time.perf_counter()\n",
    "    sortedList = sorted(edgeList, key=lambda x: (x['edgePair'][0], x['edgePair'][1]))\n",
    "    edgeFeatures = relationEncoder.OneHotEncode(relationsDict, [edge['edgeLabel'] for edge in sortedList])\n",
    "    encodeTime = time.perf_counter()\n",
    "    label = np.array([positive])\n",
    "    print([nodeTime - startTime, convertTime  - nodeTime, encodeTime - convertTime])\n",
    "    # newGraph = spektral.data.graph.Graph(x=convertedFeatures, a=adjacencyMatrix, y=label)\n",
    "    return (convertedFeatures, adjacencyMatrix, edgeFeatures, label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4893d85-fbd9-469c-a19a-8d6dced0947a",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 🐝 **createGraphAlpha** 🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "70a1a6c2-f837-43d0-ac9e-1f1519f5ab61",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createGraphAlpha(doc, positive):\n",
    "    # startTime = time.perf_counter()\n",
    "    nodeList, edgeList = stanzaTools.getNodeEdgeLists(doc, False, False)\n",
    "    # nodeTime = time.perf_counter()\n",
    "    words = [item['text'] for item in nodeList]\n",
    "    # print(len(words))\n",
    "    convertedFeatures = convertToCustomEmbedding(words)\n",
    "    adjacencyMat𑗊rix = stanzaTools.createAdjacencyMatrix(edgeList, len(nodeList))\n",
    "    # convertTime = time.perf_counter()\n",
    "    sortedList = sorted(edgeList, key=lambda x: (x['edgePair'][0], x['edgePair'][1]))\n",
    "    edgeFeatures = relationEncoder.OneHotEncode(relationsDict, [edge['edgeLabel'] for edge in sortedList])\n",
    "    # encodeTime = time.perf_counter()\n",
    "    label = np.array([positive])\n",
    "    # print([nodeTime - startTime, convertTime  - nodeTime, encodeTime - convertTime])\n",
    "    # newGraph = spektral.data.graph.Graph(x=convertedFeatures, a=adjacencyMatrix, y=label)\n",
    "    return (convertedFeatures, adjacencyMatrix, edgeFeatures, label)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "genuine-application",
   "metadata": {},
   "source": [
    "### 🤖 Convert Data to Graph Format 🤖"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ad52bcd-665a-4bcb-b351-76a75dc52422",
   "metadata": {},
   "source": [
    "Now we need the full pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "44add8bb-6a06-4095-87d9-65c7abf300cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc67cb49adf646efaca7225b872b63d0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading https://raw.githubusercontent.com/stanfordnlp/stanza-resources/main/resources_1.4.0.json:   0%|   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-07 17:45:34 WARNING: Can not find mwt: default from official model list. Ignoring it.\n",
      "WARNING:stanza:Can not find mwt: default from official model list. Ignoring it.\n",
      "2022-06-07 17:45:35 INFO: Loading these models for language: en (English):\n",
      "========================\n",
      "| Processor | Package  |\n",
      "------------------------\n",
      "| tokenize  | combined |\n",
      "| pos       | combined |\n",
      "| lemma     | combined |\n",
      "| depparse  | combined |\n",
      "| sentiment | sstplus  |\n",
      "========================\n",
      "\n",
      "INFO:stanza:Loading these models for language: en (English):\n",
      "========================\n",
      "| Processor | Package  |\n",
      "------------------------\n",
      "| tokenize  | combined |\n",
      "| pos       | combined |\n",
      "| lemma     | combined |\n",
      "| depparse  | combined |\n",
      "| sentiment | sstplus  |\n",
      "========================\n",
      "\n",
      "2022-06-07 17:45:35 INFO: Use device: cpu\n",
      "INFO:stanza:Use device: cpu\n",
      "2022-06-07 17:45:35 INFO: Loading: tokenize\n",
      "INFO:stanza:Loading: tokenize\n",
      "2022-06-07 17:45:35 INFO: Loading: pos\n",
      "INFO:stanza:Loading: pos\n",
      "2022-06-07 17:45:35 INFO: Loading: lemma\n",
      "INFO:stanza:Loading: lemma\n",
      "2022-06-07 17:45:35 INFO: Loading: depparse\n",
      "INFO:stanza:Loading: depparse\n",
      "2022-06-07 17:45:35 INFO: Loading: sentiment\n",
      "INFO:stanza:Loading: sentiment\n",
      "2022-06-07 17:45:35 INFO: Done loading processors!\n",
      "INFO:stanza:Done loading processors!\n"
     ]
    }
   ],
   "source": [
    "nlp = stanza.Pipeline(\n",
    "    'en',\n",
    "    processors = 'tokenize,mwt,pos,lemma,depparse, sentiment')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79b2c8a2-1097-48bc-aea6-36d46410beab",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 🐝 convertToGraph🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "8c67e0e3-9128-4d5e-bc81-67db68fd3fcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convertToGraph(sentence, label):\n",
    "    doc = nlp(sentence)\n",
    "    newGraph = createGraphAlpha(doc, label)\n",
    "    del(doc)\n",
    "    return newGraph"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa763429-7d47-4796-98b7-f2803b7c4e3a",
   "metadata": {},
   "source": [
    "##### 🤗**Train Graphs**🤗"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "e7ff2024-50d2-4d8d-9ae1-8b88db5df1e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "numTrain = len(trainFeatures)\n",
    "numVal = len(valFeatures)\n",
    "numTest = 25000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "468ed815-747b-4f82-9547-323549ef88fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2486.1492048749988\n"
     ]
    }
   ],
   "source": [
    "startTime = time.perf_counter()\n",
    "# trainGraphs = [convertToGraph(trainFeatures[i], trainLabels[i]) for i in range(10)]\n",
    "trainGraphs = joblib.Parallel(n_jobs=8, prefer=\"threads\")(joblib.delayed(convertToGraph)(trainFeatures[i], trainLabels[i]) for i in range(numTrain))\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "feb3c125-9cec-4726-b78b-e853d4f9335f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20000\n"
     ]
    }
   ],
   "source": [
    "print(len(trainGraphs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "55a55f65-29cb-4d75-8a6c-be8b86213abc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(158, 16), (158, 158), (150, 51), (1,)]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[item.shape for item in trainGraphs[0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e20c9df2-fab3-4e42-a0f3-d00912c01511",
   "metadata": {},
   "source": [
    "meaning of output:\n",
    "\n",
    "[(nodes), (adjacency), (edges), (label)]\n",
    "\n",
    "meaning of dims:\n",
    "\n",
    "[(# of nodes, # of nodes dims),( # of nodes,  # of nodes),(# of edges, # of edge types),(# of labels,)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba576c5c-8bb2-44f1-a827-22efbb0b1f82",
   "metadata": {},
   "source": [
    "##### 🥵**Validation Graphs**🥵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "0ba81c9c-39fc-40d6-8729-70a912dcdd9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numVal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "b7d99bb0-b8ad-4cde-93f1-df62f4eb5e27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "643.4632887499993\n"
     ]
    }
   ],
   "source": [
    "startTime = time.perf_counter()\n",
    "validationGraphs = joblib.Parallel(n_jobs=8, prefer=\"threads\")(joblib.delayed(convertToGraph)(valFeatures[i], valLabels[i]) for i in range(numVal))\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "9753e666-fb58-4d5a-a297-40f3eca4d44b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000\n"
     ]
    }
   ],
   "source": [
    "print(len(validationGraphs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "3bc551c9-a64b-46e5-b8e2-76481f3067e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(134, 16), (134, 134), (125, 51), (1,)]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[item.shape for item in validationGraphs[0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a3e92ed-d2b2-4d73-a945-62e5ed82d9bc",
   "metadata": {},
   "source": [
    "##### 😳 **Test Graphs** 😳"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "4fa88f76-9483-4f1a-9dee-0e62cdfbbbc9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3177.3946277080013\n"
     ]
    }
   ],
   "source": [
    "startTime = time.perf_counter()\n",
    "testGraphs = joblib.Parallel(n_jobs=8, prefer=\"threads\")(joblib.delayed(convertToGraph)(testFeatures[i], testLabels[i]) for i in range(numTest))\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "6df332df-5d2b-4556-a40c-0955bbf66f70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000\n"
     ]
    }
   ],
   "source": [
    "print(len(testGraphs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "2439caa6-d710-41cc-923e-ae09a6d5ef08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(220, 16), (220, 220), (210, 51), (1,)]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[item.shape for item in testGraphs[0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd47af7b-5070-4c98-9653-cf2df26f2bff",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 🏎 Speed test (I AM SPEED) 🏎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 802,
   "id": "42961004-89e0-41d7-b0fe-1ab98a98f387",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentences = []\n",
    "labels = []\n",
    "for i in range(10):\n",
    "    sentence = trainFeatures[i]\n",
    "    label = trainLabels[i]\n",
    "    sentences.append(sentence)\n",
    "    labels.append(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 871,
   "id": "e87e8bbf-b5d4-4051-85d7-a2c1b6ab1fcd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love this show!  Every time i watch an episode i repeat that line and remind myself how good of a \n",
      "I gave it a 10, since everyone else seemed to like it and it would have been churlish not to. The re\n",
      "Considering its pedigree, this should be a far more enjoyable film than it is. Even with a lip-smack\n",
      "Give this movie a break! Its worth at least a \"7\"! That little girl is a good actor and she's cute, \n",
      "Actually had to stop it. Don't get me wrong, love bad monster movies. But this one was way too borin\n"
     ]
    }
   ],
   "source": [
    "for sentence in sentences[0:5]:\n",
    "    print(sentence[0:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 803,
   "id": "d0a2cb05-a626-4d98-acae-c56e4fc8ec76",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 804,
   "id": "9eda0e62-b80c-47b8-929d-6fff7971b874",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5648865830007708\n"
     ]
    }
   ],
   "source": [
    "startTime = time.perf_counter()\n",
    "docs = []\n",
    "for sentence in sentences:\n",
    "    doc = nlp(sentence)\n",
    "    docs.append(doc)\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 872,
   "id": "285121b4-3200-4e7b-9502-4ff0d102990f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love this show!\n",
      "I gave it a 10, since everyone else seemed to like it and it would have been churlish not to.\n",
      "Considering its pedigree, this should be a far more enjoyable film than it is.\n",
      "Give this movie a break!\n",
      "Actually had to stop it.\n"
     ]
    }
   ],
   "source": [
    "for doc in docs[0:5]:\n",
    "    print(doc.sentences[0].text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 873,
   "id": "2fc03d38-bc35-4a13-94b5-e872e6e61f4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def runDepenParse(sentence):\n",
    "    return(nlp(sentence))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 880,
   "id": "767ee204-73e5-4ef0-8a21-8de58a8c766f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.400063583991141\n"
     ]
    }
   ],
   "source": [
    "startTime = time.perf_counter()\n",
    "parallelDocs = joblib.Parallel(n_jobs=8, prefer=\"threads\")(joblib.delayed(nlp)(sentences[i]) for i in range(len(sentences)))\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 881,
   "id": "674476bd-77a3-4190-a1c3-0a959b6448ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love this show!\n",
      "I gave it a 10, since everyone else seemed to like it and it would have been churlish not to.\n",
      "Considering its pedigree, this should be a far more enjoyable film than it is.\n",
      "Give this movie a break!\n",
      "Actually had to stop it.\n"
     ]
    }
   ],
   "source": [
    "for doc in parallelDocs[0:5]:\n",
    "    print(doc.sentences[0].text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 815,
   "id": "51561309-1bb7-460c-843c-0fbf69cbe06e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0016565000114496797, 0.8239069159899373, 4.258399712853134e-05]\n",
      "[0.0005920830008108169, 0.880328291998012, 5.966699973214418e-05]\n",
      "[0.0004295000107958913, 0.5279259999952046, 4.3624997488223016e-05]\n",
      "[0.00021374999778345227, 0.1548051249992568, 2.400000812485814e-05]\n",
      "[0.0004080420039827004, 0.41955416700511705, 3.466599446255714e-05]\n",
      "[0.0003648330020951107, 0.38100525000481866, 3.6124998587183654e-05]\n",
      "[8.412500028498471e-05, 0.050149124988820404, 1.2541000614874065e-05]\n",
      "[0.00044112501200288534, 0.6078953749965876, 4.849999095313251e-05]\n",
      "[0.0008354589954251423, 1.7352896660013357, 6.474999827332795e-05]\n",
      "[0.0004531250015133992, 0.6398550419980893, 4.225000157020986e-05]\n",
      "6.228190624999115\n"
     ]
    }
   ],
   "source": [
    "performanceTest = []\n",
    "startTime = time.perf_counter()\n",
    "for i in range(len(docs)):\n",
    "    doc = docs[i]\n",
    "    label = labels[i]\n",
    "    newGraph = createGraph(doc, label)\n",
    "    performanceTest.append(newGraph)\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 821,
   "id": "8448e940-8289-41e9-a24c-ef4e81f7d5b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(68, 128)"
      ]
     },
     "execution_count": 821,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performanceTest[0][0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 823,
   "id": "bd3d2628-c115-4d30-af0e-e6329745362f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:46.623199: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0014568749902537093, 0.650831000006292, 4.850000550504774e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:47.259807: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.000592500000493601, 1.0497337500128197, 5.037499067839235e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:48.308816: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00040020800952333957, 0.6706725839903811, 4.2750005377456546e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:48.981627: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0002625420020194724, 0.2348579579993384, 2.4708002456463873e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:49.218482: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00036829200689680874, 0.42855179199250415, 3.783300053328276e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:49.645511: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0003355830122018233, 0.39810258299985435, 3.258399374317378e-05]\n",
      "[7.166700379457325e-05, 0.10051387498970143, 1.4375007594935596e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:50.043553: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
      "2022-05-30 20:44:50.145551: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00044062500819563866, 0.6135991249902872, 4.1000006604008377e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:50.759863: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0006962500046938658, 1.3325668750039767, 6.137500167824328e-05]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-05-30 20:44:52.093539: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0004484169912757352, 0.6950325420039007, 3.9165999623946846e-05]\n",
      "6.181251499991049\n"
     ]
    }
   ],
   "source": [
    "performanceCustomTest = []\n",
    "startTime = time.perf_counter()\n",
    "for i in range(len(docs)):\n",
    "    doc = docs[i]\n",
    "    label = labels[i]\n",
    "    newGraph = createCustomGraph(doc, label)\n",
    "    performanceCustomTest.append(newGraph)\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 834,
   "id": "97b37c23-798f-4d78-bf84-a9e850562730",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(68, 10)"
      ]
     },
     "execution_count": 834,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performanceCustomTest[0][0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 883,
   "id": "1ccb156d-52a6-427c-9e79-b312e4f9899b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68\n",
      "91\n",
      "67\n",
      "29\n",
      "56\n",
      "55\n",
      "8\n",
      "69\n",
      "113\n",
      "73\n",
      "0.04741829200065695\n"
     ]
    }
   ],
   "source": [
    "performanceCustomTest2 = []\n",
    "startTime = time.perf_counter()\n",
    "for i in range(len(docs)):\n",
    "    doc = docs[i]\n",
    "    label = labels[i]\n",
    "    newGraph = createGraphAlpha(doc, label)\n",
    "    performanceCustomTest2.append(newGraph)\n",
    "timeElapsed = time.perf_counter() - startTime\n",
    "print(timeElapsed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 867,
   "id": "7b350c6e-1af5-4e56-9494-6ffcc94c4841",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(68, 10)"
      ]
     },
     "execution_count": 867,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performanceCustomTest2[0][0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 863,
   "id": "296ada08-fc49-4037-9bee-24515cc1b88c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Graph(n_nodes=68, n_node_features=10, n_edge_features=51, n_labels=1)"
      ]
     },
     "execution_count": 863,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Graph(performanceCustomTest2[0][0], performanceCustomTest2[0][1], performanceCustomTest2[0][2], performanceCustomTest2[0][3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 859,
   "id": "3786527c-bf19-4973-bab8-c3058f60c4b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "execution_count": 859,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performanceCustomTest2[0][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deluxe-globe",
   "metadata": {},
   "source": [
    "### 📀 Custom Graph Datasets 📀"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad22f7f9-7913-4a6c-a80b-c0e4f9002ead",
   "metadata": {},
   "source": [
    "Training the graph model requires custom graph datasets. We need to convert the list of graphs into dataset objects.\n",
    "\n",
    "These classes (TrainDataset, ValDataset, TestDataset) will also download the list of graphs into the directory containing the spektral package. This means you could just read those graphs from the same directory next time rather than running convertToGraph again."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c16b5eda-b00a-4d00-9a43-8fba4994b6f0",
   "metadata": {},
   "source": [
    "#### 🐝 TrainDataset 🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "stone-booking",
   "metadata": {},
   "outputs": [],
   "source": [
    "from spektral.data import Dataset \n",
    "from spektral.data.graph import Graph\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "specified-vector",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrainDataset(Dataset):\n",
    "    \"\"\"\n",
    "    A dataset of train graphs.\n",
    "    \"\"\"\n",
    "    def __init__(self, new=True, **kwargs):\n",
    "        if new:\n",
    "            self.download()\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    def download(self):\n",
    "        # Create the directory\n",
    "        try:\n",
    "            os.mkdir(self.path)\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        # Write the data to file\n",
    "        for i in range(len(trainGraphs)):\n",
    "            x = trainGraphs[i][0]\n",
    "            a = trainGraphs[i][1]\n",
    "            e = trainGraphs[i][2]\n",
    "            y = trainGraphs[i][3]\n",
    "\n",
    "            filename = os.path.join(self.path, f'graph_{i}')\n",
    "            np.savez(filename, x=x, a=a, e=e, y=y)\n",
    "            \n",
    "\n",
    "    def read(self):\n",
    "        # We must return a list of Graph objects\n",
    "        output = []\n",
    "\n",
    "        for i in range(len(trainGraphs)):\n",
    "            data = np.load(os.path.join(self.path, f'graph_{i}.npz'), allow_pickle=True)\n",
    "            # print(data['a'])\n",
    "            output.append(\n",
    "                Graph(x=data['x'], a=data['a'], e=data['e'], y=data['y'])\n",
    "            )\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bf69316-f80e-4ec1-97d3-8745fa50d831",
   "metadata": {},
   "source": [
    "#### 🐝 ValDataset 🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "reduced-tokyo",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ValDataset(Dataset):\n",
    "    \"\"\"\n",
    "    A dataset of val graphs.\n",
    "    \"\"\"\n",
    "    def __init__(self, new=True, **kwargs):\n",
    "        if new:\n",
    "            self.download()\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    def download(self):\n",
    "        # Create the directory\n",
    "        try:\n",
    "            os.mkdir(self.path)\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        # Write the data to file\n",
    "        for i in range(len(validationGraphs)):\n",
    "            x = validationGraphs[i][0]\n",
    "            a = validationGraphs[i][1]\n",
    "            e = validationGraphs[i][2]\n",
    "            y = validationGraphs[i][3]\n",
    "\n",
    "            filename = os.path.join(self.path, f'graph_val_{i}')\n",
    "            np.savez(filename, x=x, a=a, e=e, y=y)\n",
    "            \n",
    "\n",
    "    def read(self):\n",
    "        # We must return a list of Graph objects\n",
    "        output = []\n",
    "\n",
    "        for i in range(len(validationGraphs)):\n",
    "            data = np.load(os.path.join(self.path, f'graph_val_{i}.npz'), allow_pickle=True)\n",
    "            # print(data['a'])\n",
    "            output.append(\n",
    "                Graph(x=data['x'], a=data['a'], e=data['e'], y=data['y'])\n",
    "            )\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e06b57e-ef83-487c-a5d9-cc63ca6b479c",
   "metadata": {},
   "source": [
    "#### 🐝 TestDataset 🐝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c050412f-d9d1-45ee-92ba-460dcabd0747",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestDataset(Dataset):\n",
    "    \"\"\"\n",
    "    A dataset of val graphs.\n",
    "    \"\"\"\n",
    "    def __init__(self, new=True, **kwargs):\n",
    "        if new:\n",
    "            self.download()\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    def download(self):\n",
    "        # Create the directory\n",
    "        try:\n",
    "            os.mkdir(self.path)\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        # Write the data to file\n",
    "        for i in range(len(testGraphs)):\n",
    "            x = testGraphs[i][0]\n",
    "            a = testGraphs[i][1]\n",
    "            e = testGraphs[i][2]\n",
    "            y = testGraphs[i][3]\n",
    "\n",
    "            filename = os.path.join(self.path, f'graph_test_{i}')\n",
    "            np.savez(filename, x=x, a=a, e=e, y=y)\n",
    "            \n",
    "\n",
    "    def read(self):\n",
    "        # We must return a list of Graph objects\n",
    "        output = []\n",
    "\n",
    "        for i in range(len(testGraphs)):\n",
    "            data = np.load(os.path.join(self.path, f'graph_test_{i}.npz'), allow_pickle=True)\n",
    "            # print(data['a'])\n",
    "            output.append(\n",
    "                Graph(x=data['x'], a=data['a'], e=data['e'], y=data['y'])\n",
    "            )\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1228e1b5-bc31-432d-89e5-71df5990c122",
   "metadata": {},
   "source": [
    "#### 🐝 loadGraphs 🐝"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de40c10-fc12-4306-83e5-f17ddba17ab8",
   "metadata": {},
   "source": [
    "These help load existing graphs in the spektral directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0694682e-db68-4ccb-ace1-fe3dd995cda6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadValGraph(graphDir, index):\n",
    "    data = np.load(os.path.join(graphDir, f'graph_val_{index}.npz'), allow_pickle=True)\n",
    "    graph = Graph(x=data['x'], a=data['a'], e=data['e'], y=data['y'])\n",
    "    return graph\n",
    "\n",
    "def loadTrainGraph(graphDir, index):\n",
    "    data = np.load(os.path.join(graphDir, f'graph_{index}.npz'), allow_pickle=True)\n",
    "    graph = Graph(x=data['x'], a=data['a'], e=data['e'], y=data['y'])\n",
    "    return graph\n",
    "\n",
    "def loadTestGraph(graphDir, index):\n",
    "    data = np.load(os.path.join(graphDir, f'graph_test_{index}.npz'), allow_pickle=True)\n",
    "    graph = Graph(x=data['x'], a=data['a'], e=data['e'], y=data['y'])\n",
    "    return graph"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aebffbee-e37a-47e8-a2fb-e00b60a88408",
   "metadata": {},
   "source": [
    "#### 😎 Create the Data Sets 😎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1ecb711e-a662-4a23-bd35-0945506a9dfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# to load prev generated val graphs\n",
    "valGraphDir = '/Users/zeyuyang/spektral/datasets/ValDataset'\n",
    "valGraphNum = 5000\n",
    "validationGraphs = [loadValGraph(valGraphDir, i) for i in range(valGraphNum)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "sophisticated-reservation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ValDataset(n_graphs=5000)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valDataset = ValDataset(False)\n",
    "valDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2e3d4798-6934-4195-bf50-715b56f00961",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Graph(n_nodes=134, n_node_features=16, n_edge_features=51, n_labels=1)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "valDataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bdffbbdd-01ec-4876-8f1c-c6f6b59fd019",
   "metadata": {},
   "outputs": [],
   "source": [
    "# to load prev generated train graphs\n",
    "trainGraphDir = '/Users/zeyuyang/spektral/datasets/TrainDataset'\n",
    "trainGraphNum = 20000\n",
    "trainGraphs = [loadTrainGraph(trainGraphDir, i) for i in range(trainGraphNum)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "amateur-district",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TrainDataset(n_graphs=20000)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainDataset = TrainDataset(False)\n",
    "trainDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9d530ec5-521d-488b-804b-d87ef9b7cb35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Graph(n_nodes=158, n_node_features=16, n_edge_features=51, n_labels=1)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainDataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a2ed12af-6705-44b6-b6bb-78712bb3893b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# to load prev generated test graphs\n",
    "testGraphDir = '/Users/zeyuyang/spektral/datasets/TestDataset'\n",
    "testGraphNum = 25000\n",
    "testGraphs = [loadTestGraph(testGraphDir, i) for i in range(testGraphNum)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "76a64e13-9c98-4ba3-838f-a1a510295eb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TestDataset(n_graphs=25000)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testDataset = TestDataset(False)\n",
    "testDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "522b3c18-2f7c-4c7d-9a51-3e396e7f8fd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Graph(n_nodes=220, n_node_features=16, n_edge_features=51, n_labels=1)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testDataset[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "satisfied-alexander",
   "metadata": {},
   "source": [
    "### 🤖 Model and Training 🤖"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deaef641-4bd7-4915-a1d3-c88dd237d1fc",
   "metadata": {},
   "source": [
    "#### 📦 Basic Imports 📦"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "brave-rally",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dense, Dropout, Conv1D, Embedding\n",
    "from spektral.layers import GCNConv, GlobalSumPool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "20515141-7f44-4ec0-863e-fcf112f17060",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import LeakyReLU, PReLU\n",
    "import customECCN\n",
    "from importlib import reload\n",
    "import keras.backend as K"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "321f4835-ef2a-449d-b31e-978aba13c1e4",
   "metadata": {},
   "source": [
    "The custom edge conditioned convolution layer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b581a4-7cd0-4e06-be2a-62ed6ad4a9da",
   "metadata": {},
   "source": [
    "#### 🧱 Model Architecture 🧱"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "advance-explosion",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyFirstGNN(Model):\n",
    "\n",
    "    def __init__(self, n_hidden, n_labels):\n",
    "        super().__init__()\n",
    "        self.graph_conv = GCNConv(n_hidden, activation='relu')\n",
    "        self.AGNNCONV = spektral.layers.AGNNConv(trainable=True, aggregate='sum', activation=None)\n",
    "        self.GenConv = spektral.layers.GeneralConv(channels=n_hidden, batch_norm=True, dropout=0.0,\n",
    "                                                   aggregate='sum', activation='prelu', use_bias=True,\n",
    "                                                   kernel_initializer='glorot_uniform', bias_initializer='zeros',\n",
    "                                                   kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None,\n",
    "                                                   kernel_constraint=None, bias_constraint=None)\n",
    "        self.graphAtten = spektral.layers.GATConv(channels=n_hidden, attn_heads=5,\n",
    "                                                  concat_heads=True, dropout_rate=0.2, return_attn_coef=False,\n",
    "                                                  add_self_loops=True, activation=None, use_bias=True, kernel_initializer='glorot_uniform',\n",
    "                                                  bias_initializer='zeros', attn_kernel_initializer='glorot_uniform', kernel_regularizer=None,\n",
    "                                                  bias_regularizer=None, attn_kernel_regularizer=None, activity_regularizer=None,\n",
    "                                                  kernel_constraint=None, bias_constraint=None, attn_kernel_constraint=None)\n",
    "        self.graphECC = spektral.layers.ECCConv(channels=n_hidden, kernel_network=None, root=True, activation='relu', use_bias=True,\n",
    "                                                kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None,\n",
    "                                                bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, \n",
    "                                                bias_constraint=None)\n",
    "        self.customECC = customECCN.ECCConv(channels=n_hidden, kernel_network=[64], root=True, activation='relu', use_bias=True,\n",
    "                                                kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None,\n",
    "                                                bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, \n",
    "                                                bias_constraint=None)\n",
    "        self.customECC2 = customECCN.ECCConv(channels=n_hidden, kernel_network=[64], root=True, activation='relu', use_bias=True,\n",
    "                                                kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None,\n",
    "                                                bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, \n",
    "                                                bias_constraint=None)\n",
    "        self.avePool = spektral.layers.GlobalAvgPool()\n",
    "        self.maxPool = spektral.layers.GlobalMaxPool()\n",
    "        self.dense1 = Dense(16, activation='relu')\n",
    "        self.dropout1 = Dropout(0.2)\n",
    "        self.dropout2 = Dropout(0.2)\n",
    "        self.dense = Dense(1, 'sigmoid')\n",
    "\n",
    "    def call(self, inputs):\n",
    "        if len(inputs) == 3:\n",
    "            x, a, i = inputs\n",
    "        else:\n",
    "            x, a, e, i = inputs\n",
    "    \n",
    "        # x = self.graphECC([x,a,e])\n",
    "        x = self.customECC([x,a,e])\n",
    "        # x = self.graph_conv([x,a])\n",
    "        # x = self.customECC2([x,a,e])\n",
    "        out = self.avePool([x, i])\n",
    "        # out2 = self.maxPool([x, i])\n",
    "        # out = tf.keras.layers.Concatenate()([out, out2])\n",
    "        # print(tf.shape(out))\n",
    "        # out = self.dropout1(out)\n",
    "        out = self.dense1(out)\n",
    "        out = self.dropout2(out)\n",
    "        out = self.dense(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deaf1423-bdb9-4f1d-9083-72368d14e4b1",
   "metadata": {},
   "source": [
    "#### 🚂 Compile and Train 🚂"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "3b95aa20-0cba-4d62-af82-a0e80854796f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.keras.backend.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "3969d520-f3ee-4955-9659-0b8b98f45895",
   "metadata": {},
   "outputs": [],
   "source": [
    "numHidden = 16\n",
    "numLabels = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "aboriginal-white",
   "metadata": {},
   "outputs": [],
   "source": [
    "graphModel = MyFirstGNN(numHidden, numLabels)\n",
    "graphModel.compile('rmsprop', 'binary_crossentropy', metrics=['accuracy',])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 460,
   "id": "running-intake",
   "metadata": {},
   "outputs": [],
   "source": [
    "trainLoader = spektral.data.loaders.DisjointLoader(trainDataset, node_level=False, batch_size=80, epochs=None, shuffle=True)\n",
    "\n",
    "validationLoader = spektral.data.loaders.DisjointLoader(valDataset, node_level=False, batch_size=80)\n",
    "\n",
    "testLoader = spektral.data.loaders.DisjointLoader(testDataset, node_level=False, batch_size=80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "average-miami",
   "metadata": {},
   "outputs": [],
   "source": [
    "history = graphModel.fit(trainLoader.load(),\n",
    "              validation_data=validationLoader.load(),\n",
    "              steps_per_epoch=trainLoader.steps_per_epoch,\n",
    "              validation_steps=validationLoader.steps_per_epoch,\n",
    "              epochs=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "35ab3389-1af7-4d6e-a09f-09778da2f522",
   "metadata": {},
   "outputs": [],
   "source": [
    "modelName = \"loadedModel\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1af172e2-bc99-4e89-92ee-4291d5fb8b6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "graphModel.save(\"./savedModels/\" + modelName)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "7230956f-cbf6-4f28-8d5c-346725e70ec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load existing model\n",
    "graphModel = tf.keras.models.load_model('./savedModels/1ECCkernel64_25k_1drop_Avepool/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "9eabe47b-473d-4393-8ea3-1717f1b34458",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"my_first_gnn\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " gcn_conv (GCNConv)          multiple                  0         \n",
      "                                                                 \n",
      " agnn_conv (AGNNConv)        multiple                  0         \n",
      "                                                                 \n",
      " general_conv (GeneralConv)  multiple                  0         \n",
      "                                                                 \n",
      " gat_conv (GATConv)          multiple                  0         \n",
      "                                                                 \n",
      " ecc_conv (ECCConv)          multiple                  0         \n",
      "                                                                 \n",
      " ecc_conv_1 (ECCConv)        multiple                  20304     \n",
      "                                                                 \n",
      " ecc_conv_2 (ECCConv)        multiple                  0         \n",
      "                                                                 \n",
      " global_avg_pool (GlobalAvgP  multiple                 0         \n",
      " ool)                                                            \n",
      "                                                                 \n",
      " global_max_pool (GlobalMaxP  multiple                 0         \n",
      " ool)                                                            \n",
      "                                                                 \n",
      " dense (Dense)               multiple                  272       \n",
      "                                                                 \n",
      " dropout (Dropout)           multiple                  0         \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         multiple                  0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             multiple                  17        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 20,593\n",
      "Trainable params: 20,561\n",
      "Non-trainable params: 32\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "graphModel.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3845a4f3-9eae-4400-807e-30e73148a993",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 🧐 Evaluate and Analysis 🧐"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "id": "joined-channel",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/zeyuyang/miniforge3/envs/graphLearning/lib/python3.9/site-packages/spektral-1.1.0-py3.9.egg/spektral/data/utils.py:221: UserWarning: you are shuffling a 'TestDataset' object which is not a subclass of 'Sequence'; `shuffle` is not guaranteed to behave correctly. E.g., non-numpy array/tensor objects with view semantics may contain duplicates after shuffling.\n",
      "  np.random.shuffle(a)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 252s 803ms/step - loss: 0.3246 - accuracy: 0.8736\n"
     ]
    }
   ],
   "source": [
    "testResult = graphModel.evaluate(testLoader.load(), steps=testLoader.steps_per_epoch)\n",
    "# graphModel.evaluate(validationLoader.load(), steps=validationLoader.steps_per_epoch)\n",
    "# graphModel.evaluate(trainLoader.load(), steps=trainLoader.steps_per_epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "id": "21a98527-381c-4134-bd62-014df2aa2261",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.32461294531822205, 0.8735600709915161]"
      ]
     },
     "execution_count": 462,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testResult"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cbd3613-65fe-413e-a99a-1883b3f2c12c",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 🍰 Layers and Ablation 🍰"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02f45224-2a08-4770-b155-069d3901973c",
   "metadata": {},
   "outputs": [],
   "source": [
    "graphModel.customECC.weights[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c37db7e4-84b3-4511-b4a3-a7afaf709b29",
   "metadata": {},
   "outputs": [],
   "source": [
    "graphModel.customECC.weights[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99ee3b43-9fca-4cba-807d-f83759da82ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "graphModel.customECC.weights[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6d64ab5-c2b8-4fee-b189-810d278d6652",
   "metadata": {},
   "outputs": [],
   "source": [
    "graphModel.customECC.la"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d01f4379-7844-4d35-b47e-1564800b1b22",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 🤌 GNN Explainer 🤌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "be90e62b-c505-43c9-bf88-7fb946cad61b",
   "metadata": {},
   "outputs": [],
   "source": [
    "preprocess = graphModel.graph_conv.preprocess"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "054c1c2d-edb3-42ea-a604-a2e94dbe00c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from spektral import models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "0972ff52-cd9e-465c-bcd0-a9dcb6722108",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_hops was automatically inferred to be 7\n"
     ]
    }
   ],
   "source": [
    "explainer = models.gnn_explainer.GNNExplainer(graphModel, n_hops=None, preprocess=preprocess, graph_level=True, verbose=False, learning_rate=0.01, a_size_coef=0.0005, x_size_coef=0.1, a_entropy_coef=0.1, x_entropy_coef=0.1, laplacian_coef=0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "e74668db-4279-4d6a-a8b8-be1a82d0d2f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "(x, a, e, i), y = next(testLoader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bc6a879-2c25-4c92-afce-fc7383fd10d7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "28ce6311-8e68-40c5-a6d1-51f8a3f0c457",
   "metadata": {},
   "outputs": [],
   "source": [
    "cut_idx = (i == 0).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "66f7f002-14f1-4027-a8ec-d011b1a8e3ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_exp = x[:cut_idx]\n",
    "a_exp = tf.sparse.slice(a, start=[0, 0], size=[cut_idx, cut_idx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "fe85f116-63ec-41f9-bea3-fcc2ecde6102",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-06-08 17:42:42.410335: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    }
   ],
   "source": [
    "# Explain prediction for one graph for GCN\n",
    "adj_mask, feat_mask = explainer.explain_node(x=x_exp, a=a_exp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "bee395b0-4152-4707-863f-c31bb50e8103",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the result\n",
    "G = explainer.plot_subgraph(adj_mask, feat_mask)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "0ae52bb0-2927-41d7-bae5-1c61774be4fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([1, 16])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feat_mask.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "6f364902-3b24-4edb-b62b-584cd3666809",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([205])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adj_mask.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed533ea7-6bb2-4fa8-ac1a-5d16a3b1cac7",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 📊 Figures 📊"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "b68ec377-6fb0-4ec9-b5a7-696faf8751de",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_path = './results/' + modelName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 465,
   "id": "developing-oregon",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7c085694c0>"
      ]
     },
     "execution_count": 465,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# plot training and validaiton loss over epochs\n",
    "history_dict = history.history\n",
    "acc = history_dict['accuracy']\n",
    "val_acc = history_dict['val_accuracy']\n",
    "loss = history_dict['loss']\n",
    "val_loss = history_dict['val_loss']\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "# \"-r^\" is for solid red line with triangle markers.\n",
    "plt.plot(epochs, loss, '-r^', label='Training loss')\n",
    "# \"-b0\" is for solid blue line with circle markers.\n",
    "plt.plot(epochs, val_loss, '-bo', label='Validation loss')\n",
    "plt.title('Training and validation loss | Test loss: {loss}'.format(loss=np.round(testResult[0], 4)))\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend(loc='best')\n",
    "# plt.savefig(results_path + '_loss_history')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 466,
   "id": "e52266ee-e5ae-4465-8f19-febea0adc17c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7d695611c0>"
      ]
     },
     "execution_count": 466,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# plot training and validation accuracy over epochs\n",
    "plt.clf()   # clear figure\n",
    "\n",
    "plt.plot(epochs, acc, '-r^', label='Training acc')\n",
    "plt.plot(epochs, val_acc, '-bo', label='Validation acc')\n",
    "plt.title('Training and validation accuracy | Test accuracy: {accuracy}'.format(accuracy = np.round(testResult[1], 4)))\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend(loc='best')\n",
    "\n",
    "# plt.show()\n",
    "# plt.savefig(results_path + '_acc_history')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "477b5a6b-16c8-49f5-bad6-c79d48b4735b",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 😵‍💫 Confusion Matrix 😵‍💫"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "id": "4a4e036c-0e95-42da-9038-c4e834202103",
   "metadata": {},
   "outputs": [],
   "source": [
    "testLoader = spektral.data.loaders.DisjointLoader(testDataset, node_level=False, batch_size=100, epochs=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "fddd9bf0-9bde-436d-aefe-1a42ef37b47e",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = graphModel.predict(testLoader.load())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "id": "f2dd550f-fac3-42f0-8a36-d3ad67f963d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictionReshaped = predictions.reshape((25000,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "id": "47b31378-059e-442e-9b89-a60af978f935",
   "metadata": {},
   "outputs": [],
   "source": [
    "truth = np.array([i.y for i in testDataset])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "id": "cddcfcea-dd9f-4d7f-bef1-1e2c365b4f9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "truth = truth.reshape((25000,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "id": "a86bb8ea-1324-4d99-855a-e5d753e80a1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictLabel = (predictionReshaped >= 0.5).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "id": "fa8da67d-c83d-4938-a2c9-fa4111e037b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "id": "7ffa4237-6dfb-4b66-acd7-0eb96e778901",
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = confusion_matrix(predictLabel, truth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "id": "a45306fe-22fe-4bf5-9965-ac37373ee191",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x7bfbcbb1f0>"
      ]
     },
     "execution_count": 364,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n",
    "disp.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "id": "46a396cc-50cb-486c-b50e-d5f5d325ed74",
   "metadata": {},
   "outputs": [],
   "source": [
    "tn, fp, fn, tp = cm.ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "id": "628369fc-a4a3-46ae-bbb1-3ec3f42f22fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8678219771563608"
      ]
     },
     "execution_count": 304,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tp / (tp + fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "id": "14797722-2428-4d69-8caf-d80d4dee0290",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.88136"
      ]
     },
     "execution_count": 305,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tp / (tp + fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "id": "4f1453ce-b573-4de2-b2d9-15f45544c981",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.87356"
      ]
     },
     "execution_count": 306,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(tp + tn) / (sum(cm.ravel()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "id": "a2079eb7-ab04-44a6-a19e-87f43fd3f912",
   "metadata": {},
   "outputs": [],
   "source": [
    "lengths = [i.n_nodes for i in testDataset]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "id": "eef48324-7329-43fd-8543-7ce6bdb4b6c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "correct = np.array(predictLabel == truth)\n",
    "correct = correct.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "id": "bb035db1-3da4-4eb3-893b-c8526d9d2aa8",
   "metadata": {},
   "outputs": [],
   "source": [
    "correctLengths = lengths * correct\n",
    "wrongLengths = lengths * ((correct - 1) * -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "id": "ef3fe71e-f99b-4c37-8a3c-e5e5b7ea8919",
   "metadata": {},
   "outputs": [],
   "source": [
    "wrongLengths = wrongLengths[wrongLengths != 0]\n",
    "correctLengths = correctLengths[ correctLengths  != 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "id": "1853fb70-921f-470b-8193-3a78f29b7b83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "269.4954128440367"
      ]
     },
     "execution_count": 371,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(wrongLengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "id": "59cd260f-e390-4501-ae4d-970709126c82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "263.8292504235542"
      ]
     },
     "execution_count": 372,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(correctLengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "id": "1eadd0cc-2011-47cf-84db-e7ed922afd82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3161"
      ]
     },
     "execution_count": 373,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(wrongLengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "id": "4e72425b-e38c-4b38-8aae-47f007ec2a64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7bfcaf82e0>"
      ]
     },
     "execution_count": 375,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "fig, axs = plt.subplots(1, 1, sharey=True, tight_layout=True)\n",
    "axs.hist([wrongLengths, correctLengths], label=['wrong','right'], bins=30, density=True)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ccb4f8b-8f3d-4977-ad2a-1dc4c1d0e6fd",
   "metadata": {},
   "source": [
    "#### 🙉 Edge Label Masking 🙉"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 450,
   "id": "6ca07379-6dcd-409a-b45e-2a3eaccc1572",
   "metadata": {},
   "outputs": [],
   "source": [
    "allA = [item.e for item in testDataset]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "id": "c5eebad2-b834-431f-bf40-fedc3ca0a376",
   "metadata": {},
   "outputs": [],
   "source": [
    "allASum = np.array([np.sum(i, axis=0) for i in allA])\n",
    "aSum = np.sum(allASum, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "id": "e83e9e12-c8f5-4420-8859-128dfa66b7f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 48, 28, 29, 19, 47, 24, 44, 31, 20, 49, 36, 34, 12,  0, 30, 43,\n",
       "       18, 22, 42, 23, 26, 25, 15, 39,  7, 38,  9,  2, 45, 13, 27,  3, 50,\n",
       "       35,  4,  8, 14, 17, 33, 32, 11, 16, 41, 40,  6,  5, 37, 10, 21, 46])"
      ]
     },
     "execution_count": 471,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lowToHigh = np.argsort(aSum)\n",
    "lowToHigh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "id": "ad6a98c9-c607-49d4-a053-b7968e7a78e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'acl': 2,\n",
       " 'acl:relcl': 3,\n",
       " 'advcl': 4,\n",
       " 'advmod': 5,\n",
       " 'amod': 6,\n",
       " 'appos': 7,\n",
       " 'aux': 8,\n",
       " 'aux:pass': 9,\n",
       " 'case': 10,\n",
       " 'cc': 11,\n",
       " 'cc:preconj': 12,\n",
       " 'ccomp': 13,\n",
       " 'compound': 14,\n",
       " 'compound:prt': 15,\n",
       " 'conj': 16,\n",
       " 'cop': 17,\n",
       " 'csubj': 18,\n",
       " 'csubj:pass': 19,\n",
       " 'dep': 20,\n",
       " 'det': 21,\n",
       " 'det:predet': 22,\n",
       " 'discourse': 23,\n",
       " 'dislocated': 24,\n",
       " 'expl': 25,\n",
       " 'fixed': 26,\n",
       " 'flat': 27,\n",
       " 'flat:foreign': 28,\n",
       " 'goeswith': 29,\n",
       " 'iobj': 30,\n",
       " 'list': 31,\n",
       " 'mark': 32,\n",
       " 'nmod': 33,\n",
       " 'nmod:npmod': 34,\n",
       " 'nmod:poss': 35,\n",
       " 'nmod:tmod': 36,\n",
       " 'nsubj': 37,\n",
       " 'nsubj:pass': 38,\n",
       " 'nummod': 39,\n",
       " 'obj': 40,\n",
       " 'obl': 41,\n",
       " 'obl:npmod': 42,\n",
       " 'obl:tmod': 43,\n",
       " 'orphan': 44,\n",
       " 'parataxis': 45,\n",
       " 'punct': 46,\n",
       " 'reparandum': 47,\n",
       " 'root': 48,\n",
       " 'vocative': 49,\n",
       " 'xcomp': 50,\n",
       " 'none': 0,\n",
       " 'nextSentence': 1}"
      ]
     },
     "execution_count": 464,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "relationsDict = relationEncoder.getRelationsDict()\n",
    "relationsDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 482,
   "id": "c396a2f1-52d2-481d-a60f-87e2ba0a2ab5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MaskDataset(Dataset):\n",
    "    \"\"\"\n",
    "    A dataset of val graphs.\n",
    "    \"\"\"\n",
    "    def __init__(self, graphs, edgeIndex, **kwargs):\n",
    "        self.graphs = graphs\n",
    "        self.edgeIndex = edgeIndex\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    def read(self):\n",
    "        # We must return a list of Graph objects\n",
    "        output = []\n",
    "        for i in range(len(self.graphs)):\n",
    "            output.append(\n",
    "                \n",
    "                Graph(x=self.graphs[i].x, a=self.graphs[i].a, e=self.maskEdge(i, self.edgeIndex), y=self.graphs[i].y)\n",
    "            )\n",
    "        return output\n",
    "    def maskEdge(self, graphIndex, edgeIndex):\n",
    "        base = np.ones((51,))\n",
    "        base[edgeIndex] = 0\n",
    "        return (self.graphs[graphIndex].e * base)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 509,
   "id": "80ee82d0-157f-44b2-8d30-74a6ebfb763d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 48, 28, 29, 19, 47, 24, 44, 31, 20, 49, 36, 34, 12,  0, 30, 43,\n",
       "       18, 22, 42, 23, 26, 25, 15, 39,  7, 38,  9,  2, 45, 13, 27,  3, 50,\n",
       "       35,  4,  8, 14, 17, 33, 32, 11, 16, 41, 40,  6,  5, 37, 10, 21, 46])"
      ]
     },
     "execution_count": 509,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "targetEdges = lowToHigh\n",
    "targetEdges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 503,
   "id": "958a2e28-6288-4f15-91d4-e80b473d02e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "targetGraphs = testGraphs[:25000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 510,
   "id": "1ff5f4ee-bbdd-46ec-8260-f06155de2646",
   "metadata": {},
   "outputs": [],
   "source": [
    "maskDataset = MaskDataset(graphs=targetGraphs, edgeIndex=targetEdges)\n",
    "defaultDataset = MaskDataset(graphs=targetGraphs, edgeIndex=[])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 511,
   "id": "cafe7216-6866-4f87-a367-52db7afe03aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "defaultLoader = spektral.data.loaders.DisjointLoader(defaultDataset, node_level=False, batch_size=100, epochs=1, shuffle=False)\n",
    "maskLoader = spektral.data.loaders.DisjointLoader(maskDataset, node_level=False, batch_size=100, epochs=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 512,
   "id": "b60e15fe-eae6-4826-b555-65f673d52de2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 238s 951ms/step - loss: 0.3246 - accuracy: 0.8736\n"
     ]
    }
   ],
   "source": [
    "defaultResults = graphModel.evaluate(defaultLoader.load(), steps=defaultLoader.steps_per_epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 513,
   "id": "3aade5f2-1c72-4f31-8692-9b232d0be28a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250/250 [==============================] - 237s 948ms/step - loss: 0.3057 - accuracy: 0.8749\n"
     ]
    }
   ],
   "source": [
    "maskResults = graphModel.evaluate(maskLoader.load(), steps=maskLoader.steps_per_epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 533,
   "id": "8d19bf1c-ed70-4403-bdca-2a1b77e65a84",
   "metadata": {},
   "outputs": [],
   "source": [
    "maskedEdges = np.array(([i.e.sum(axis=0) for i in maskDataset]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 535,
   "id": "2bc1b4ba-7782-458b-b2a6-dc5405330207",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 535,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maskedEdges.sum(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d11810ad-c5d2-4c31-bbd2-6ebce0722ca3",
   "metadata": {},
   "source": [
    "### ⛏ Digging for Stuff ⛏"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e95bbcbf-90d7-45d9-9a10-183064db7e90",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 🔎 What is in DisjointLoader 🔎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ab62280-30d1-47c1-90bc-715751c2f257",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sampleLoader =  spektral.data.loaders.DisjointLoader(trainDataset[0:10], node_level=False, batch_size=10, epochs=1, shuffle=True)\n",
    "x,a,e,i = [],[],[],[]\n",
    "labels = []\n",
    "for batch in sampleLoader:\n",
    "    labels = batch[1]\n",
    "    x,a,e,i = batch[0]\n",
    "    print(batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0a7824f-f90d-41b4-ae99-078f75138744",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(stanzaTools.printSpareTensor(a)[0:500])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "id": "81350cb3-cf05-4b9a-b472-162a1a0ead40",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_x = GCNConv(16)([x,a])\n",
    "new_x2 = GCNConv(16)([new_x,a])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f52b529-4eac-469e-83a1-9881319f9491",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "691207cb-cd4e-4097-92ad-9e5d8cdd305f",
   "metadata": {},
   "source": [
    "#### 🔎 What is QM9 🔎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "aboriginal-relevance",
   "metadata": {},
   "outputs": [],
   "source": [
    "from spektral.datasets import QM9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "049880df-6d78-42f8-bc89-ab6890cb886c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/gdb9.tar.gz\n",
      "44859392/44852087 [==============================] - 43s 1us/step\n",
      "44867584/44852087 [==============================] - 43s 1us/step\n",
      "Loading QM9 dataset.\n",
      "Reading SDF\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████| 1000/1000 [00:00<00:00, 2878.29it/s]\n"
     ]
    }
   ],
   "source": [
    "dataset = QM9(amount=1000)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70de0185-aef9-4da0-821e-d39b12c995f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Graph(n_nodes=107, n_node_features=128, n_edge_features=None, n_labels=1)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}