{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a827ed8c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5c9168a9e4a427b3e6ce3cd7d6474001",
     "grade": false,
     "grade_id": "cell-6a941dadcabee4ce",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Exercise Sheet No. 9\n",
    "\n",
    "---\n",
    "\n",
    "> Machine Learning for Natural Sciences, Summer 2024, TT.-Prof. Pascal Friederich, pascal.friederich@kit.edu\n",
    "> \n",
    "> Deadline: Jun 25th 2024, 8:00 am\n",
    ">\n",
    "> Tutor: jonas.teufel@kit.edu\n",
    ">\n",
    "> **Please ask questions in the forum/discussion board and only contact the Tutor when there are issues with the grading**\n",
    "---\n",
    "\n",
    "**Topic**: This exercise sheet will focus on recurrent neural networks such as GRUs and LSTMs. For practical applications, we'll be looking at the classification of ECG data and text sentiment classification."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1ed7b07",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a879c1dc172b7295c35c8e5d74a122c1",
     "grade": true,
     "grade_id": "name-entry",
     "locked": false,
     "points": 0,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "Please add here your group members' names and student IDs. \n",
    "\n",
    "Names: Nils Lennart Bruns\n",
    "\n",
    "IDs: 2460137"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d79f4d6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "825a5716d90ba2160202d4c3bc57e271",
     "grade": false,
     "grade_id": "cell-75db4b3e225be105",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# 9 Recurrent Neural Networks\n",
    "\n",
    "\n",
    "## 9.1 Working with Time-Series Data\n",
    "\n",
    "**Normal Tabular Data.** With neural network models, we are usually working with relatively strictly defined data - at least regarding its data format. More specifically, when thinking about the data from the perspective of numeric arrays and matrices, we need to impose strict assumptions about the *shape* of this data. For a dense neural network that predicts tabular data, for example, the input vector always needs to have the same number and order of elements. For convolutional neural networks predicing based on image data, we need to make sure that the input images always have the same dimensions.\n",
    "\n",
    "**Sequential Data.** For the class of data known as *sequential* data, strict assumptions about the shape are no longer possible for at least one of the data dimensions. One particularly illustrative example for sequential data is *text*. If we want to use neural networks do classification on textual data, we run into the problem that text generally has different length. One often used example in the domain text processing is the problem of [sentiment classification](https://en.wikipedia.org/wiki/Sentiment_analysis): In the most simple case, we could use a model to predict whether a given has a positive (*\"I really liked this book!\"*) or a negative (*Worst movie I've ever seen!*) meaning. In a simplified manner we can encode text snippets as sequences of characters, where each character could be represented as a [one-hot encoded](https://en.wikipedia.org/wiki/One-hot) vector, for example.\n",
    "\n",
    "In other domains, sequential data can be found whenever some measurments are recorded are recorded over periods of time. This, for example, includes measurements of seismic activities or climate data records that can later be used to perform analyses or predict forecasts of future observations. \n",
    "\n",
    "**Recurrent Neural Networks.** Due to the particular properties of sequential data, the special type of *recurrent neural networks (RNNs)* is required to handle the dynamic input shapes. These special network architectures treat the sequence dimension of the input data in a special manner to allow for different lengths. The common method of treating this dynamic sequence dimension is following: Instead of having dedicated parameters for the sequence dimension, the same existing network layers are applied for each time step independently. The network is able to maintain information about the whole sequence by accumulating in some kind of internal state representation that is passed shared between adjacent time steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2bb9f0cd",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0910d6d5c3a1e2091ced89b25a5c3aa0",
     "grade": false,
     "grade_id": "cell-717cee8c7f8ad17f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "import os\n",
    "import io\n",
    "import re\n",
    "import sys\n",
    "import time\n",
    "import random\n",
    "import hashlib\n",
    "import zipfile\n",
    "import tempfile\n",
    "import typing as typ\n",
    "from collections import defaultdict\n",
    "from copy import copy\n",
    "\n",
    "import requests\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.nn.utils.rnn as rnn\n",
    "import torch.optim as optim\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "28d23044",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5c869e94a6b1c0c8e97c01966defc791",
     "grade": false,
     "grade_id": "cell-9383204f5fb9dd9d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "hashcheck = lambda v: hashlib.sha256(v.encode()).hexdigest()[:16]\n",
    "\n",
    "def sigmoid(x: np.ndarray) -> np.ndarray:\n",
    "    if isinstance(x, np.ndarray):\n",
    "        x = x.astype(float)\n",
    "        \n",
    "    return 1.0 / (1.0 + np.exp(-x))\n",
    "\n",
    "np.sigmoid = sigmoid\n",
    "\n",
    "\n",
    "def nextcloud_download(url: str, raw: bool = False) -> str:\n",
    "    \"\"\"\n",
    "    Downloads the content of a file from a nextcloud server and returns \n",
    "    it eithers as a string or a bytes object if the ``raw`` flag is set.\n",
    "    \"\"\"\n",
    "    response = requests.get(f'{url}/download')\n",
    "    content = response.content\n",
    "    if not raw:\n",
    "        content = content.decode('utf-8')\n",
    "    \n",
    "    return content\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccc653f6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3e78d693cd467e6f028d0ae62fd02724",
     "grade": false,
     "grade_id": "cell-3b2c81f08f9d2ced",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**A Simple Example.** To get a basic understanding of how sequential tasks are structured, we will construct a simple sequential toy problem. We will consider a problem with two binary input values $u_t$, $v_t$ and one binary output value $y_t$. All of these values are signals over time and can be evaluated at different discrete time steps $t \\in \\{0, 1, 2, 3, \\dots\\}$. In this task, the current value of the output signal $y_t$ does not only depend on the current values of the input signals, but also on the input behavior that was observed in the previous time steps!\n",
    "\n",
    "Specifically, the output function $y_t$ is defined to be $1$ only if the following two conditions are met:\n",
    "\n",
    "- Across all previous time steps $\\{ 0, \\dots, t-1 \\}$ a $1$ within the $u_t$ input signal was observed an *odd* number of times. (So only if the there have been $1, 3, 5, 7, ...$ ones in the input signal previously)\n",
    "- In the previous time step, the value of the $v_t$ input signal was $1$.\n",
    "\n",
    "The previously described sequential input-output problem is illustrated in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e3b96927",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7de2aaff4ce358d4f5d7b1a0c980d343",
     "grade": false,
     "grade_id": "cell-d7bcc1a1e0c11455",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "ts = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])\n",
    "us = np.array([1, 0, 1, 0, 1, 1, 0, 1, 0, 1,  1,  0,  1,  0,  1,  1])\n",
    "vs = np.array([0, 1, 0, 0, 0, 1, 0, 1, 0, 0,  1,  0,  1,  0,  1,  1])\n",
    "ys = np.array([0, 0, 1, 0, 0, 0, 0, 0, 1, 0,  0,  1,  0,  0,  0,  1])\n",
    "\n",
    "# For an odd number of vs, it displays how many us there were in the past\n",
    "\n",
    "fig, (ax_us, ax_vs, ax_ys) = plt.subplots(\n",
    "    ncols=1,\n",
    "    nrows=3,\n",
    "    figsize=(10, 15),\n",
    ")\n",
    "\n",
    "ax_us.step(ts-0.5, us, color='cyan')\n",
    "ax_us.set_title('Input Signal u')\n",
    "ax_us.set_xticks(ts)\n",
    "ax_us.set_xlim([-1, 16])\n",
    "ax_us.xaxis.grid(ls='--', alpha=0.5)\n",
    "\n",
    "ax_vs.step(ts-0.5, vs, color='magenta')\n",
    "ax_vs.set_title('Input Signal v')\n",
    "ax_vs.set_xticks(ts)\n",
    "ax_vs.set_xlim([-1, 16])\n",
    "ax_vs.xaxis.grid(ls='--', alpha=0.5)\n",
    "\n",
    "ax_ys.step(ts-0.5, ys, color='red')\n",
    "ax_ys.set_title('Output Signal y')\n",
    "ax_ys.set_xticks(ts)\n",
    "ax_ys.set_xlim([-1, 16])\n",
    "ax_ys.xaxis.grid(ls='--', alpha=0.5)\n",
    "ax_ys.set_xlabel('time steps')\n",
    "\n",
    "pass\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8e3a0c9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9d6ee6c63da577e32293234d5b227f68",
     "grade": false,
     "grade_id": "task-9-1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 5.1 (2 points)** In this task, implement the function ``custom_step`` which receives the momentary values of the two input signals ``u`` and ``v`` for each timestep. Additionally, the function receives a dicitonary object ``data`` which is empty at the beginning, but retains it's content between every time step! You may use this dictionary object to implement some kind of \"memory\" to solve the recurrent task. In each time step, the ``custom_step`` function is supposed to return the predicted output value ``y`` according to the previously described rule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "58272687",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a2bc8fa5bb2f19d4b43b8da19a50f0b8",
     "grade": false,
     "grade_id": "ans-9-1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15]),\n",
       " array([1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1]),\n",
       " array([0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1]))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def custom_step(u: float, v: float, data: dict) -> float:\n",
    "    \"\"\"\n",
    "    This function receives the current value of the input signals ``u`` and ``v`` \n",
    "    as well as the memory storage ``data`` and is supposed to return the predicted \n",
    "    which solves the previously described sequential toy problem.\n",
    "    \n",
    "    :param u: The current value of input signal u\n",
    "    :param v: The current value of input signal v\n",
    "    :param data: A dictionary object that retains it's content between the time steps\n",
    "    \n",
    "    :returns: The predicted value for y\n",
    "    \"\"\"\n",
    "    #print(f\"{u=}, {v=}, {data=}\")    \n",
    "    if len(data.keys()) == 0:\n",
    "        data[\"u_count\"] == 0\n",
    "    \n",
    "    oldu_count = data[\"u_count\"]\n",
    "    oldv = data[\"v\"]\n",
    "    if u == 1:\n",
    "        data[\"u_count\"] += 1\n",
    "    data[\"v\"] = v\n",
    "\n",
    "    \n",
    "    return int(oldu_count % 2 == 1 and oldv == 1)\n",
    "\n",
    "ts, us, vs, ys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7e461483",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "53dcb8dd58b96971ef57bd129bb18a12",
     "grade": true,
     "grade_id": "test-9-1-custom-step",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t: 00 - true: 0 - pred: 0\n",
      "t: 01 - true: 0 - pred: 0\n",
      "t: 02 - true: 1 - pred: 1\n",
      "t: 03 - true: 0 - pred: 0\n",
      "t: 04 - true: 0 - pred: 0\n",
      "t: 05 - true: 0 - pred: 0\n",
      "t: 06 - true: 0 - pred: 0\n",
      "t: 07 - true: 0 - pred: 0\n",
      "t: 08 - true: 1 - pred: 1\n",
      "t: 09 - true: 0 - pred: 0\n",
      "t: 10 - true: 0 - pred: 0\n",
      "t: 11 - true: 1 - pred: 1\n",
      "t: 12 - true: 0 - pred: 0\n",
      "t: 13 - true: 0 - pred: 0\n",
      "t: 14 - true: 0 - pred: 0\n",
      "t: 15 - true: 1 - pred: 1\n"
     ]
    }
   ],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-1-custom-step - possible points: 2\n",
    "\n",
    "data = defaultdict(int)\n",
    "\n",
    "for t, u, v, y in zip(ts, us, vs, ys):\n",
    "    y_pred = custom_step(u, v, data)\n",
    "    print(f't: {t:02d} - true: {y} - pred: {y_pred}')\n",
    "    assert np.isclose(y, y_pred, atol=0.1), f'predicted {y_pred} != expected {y}'\n",
    "    \n",
    "# NOTE: The hidden tests will perform the same kind of test with a number of randomly \n",
    "#       generated input and corresponding output signals of different lenghts.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9f076f5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9e4a44faffb62624cd394308064ac815",
     "grade": false,
     "grade_id": "cell-a3e327c7b3a7d96d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 9.2 Gated Recurrent Unit (GRU)\n",
    "\n",
    "The first kind of RNN layer that we want to look at is the *Gated Recurrent Unit (GRU)*. Compared to the default model found in the literature or presented in the lecture, we will consider a slightly extended version which also includes a *Readout Gate*. The following illustration shows a basic overview of this GRU architecture:\n",
    "\n",
    "<img src=\"https://bwsyncandshare.kit.edu/s/89PNHisYaGMCJGW/download\">\n",
    "\n",
    "The basic idea of this layer is that a hidden state vector $\\mathbf{h}$ is maintained and updated throughout each time step of the sequence. These hidden state values are supposed to act as some kind of \"memory\" which can be used to store information about previous time steps within the same sequence. The general workflow within a single forward pass of the GRU cell is to use the information that is contained within the current input vector $\\mathbf{x}_t$ and state vector $\\mathbf{h}_{t-1}$ of the previous time step to calculate (1) the readout value of the current time step and (2) the updated state vector $\\mathbf{h}_t$ for the next time step.\n",
    "\n",
    "The variation of the GRU cell that is used in this exercise can be decomposed into 4 general sections:\n",
    "\n",
    "- The *readout* gate determines the current readout value $\\mathbf{p}_t$ based on the input and previous state values.\n",
    "- The *reset* gate selectively determines which of the hidden states should be reset by multiplying each hidden state value with a $[0, 1]$ value based on input and previous state values.\n",
    "- The *selection* gate determines for each state value whether the previous state value should be maintained or the updated state values from the update gate should be used instead. This is done by determining the factor for a weighted average between the previous and updated state values: $(1 - r_z) \\cdot \\mathrm{previous\\;state} + (r_z) \\cdot \\mathrm{updated\\;state}$ \n",
    "- The *update* gate determines new state values based on the inputs and reset previous states. An important detail to consider here is that the state values themselves are ``tanh`` activated, which means that they can only ever be values in the range $[-1, 1]$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13d8ab09",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1efb783747a2e34aaae4106bfa43a117",
     "grade": false,
     "grade_id": "task-9-2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 9.2 (1 points)** To familiarize yourself with the architecture of the GRU cell, your next task is simply to determine the appropriate shape tuples for the weight matrices $W_r, W_z, W_h, W_p$ given the fixed shapes of the input signal ``x_shape``, the hidden vector ``h_shape`` and the readout vector ``p_shape``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "59c158ff",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2e1900dad8fdd91eaf30e51e30365719",
     "grade": false,
     "grade_id": "ans-9-2-gru-shapes",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "x_shape = (5, )\n",
    "h_shape = (7, )\n",
    "p_shape = (2, )\n",
    "\n",
    "# TASK: Given the example shapes for the various input and output vectors, fill in the \n",
    "#       expected shapes of the various weight matrices that are used in the GRU architecture.\n",
    "\n",
    "W_r_shape: tuple[int, int] = None\n",
    "W_z_shape: tuple[int, int] = None\n",
    "W_h_shape: tuple[int, int] = None\n",
    "W_p_shape: tuple[int, int] = None\n",
    "\n",
    "W_r_shape: tuple[int, int] = (x_shape[0]+h_shape[0], h_shape[0])[::-1]\n",
    "W_z_shape: tuple[int, int] = (x_shape[0]+h_shape[0], h_shape[0])[::-1]\n",
    "W_h_shape: tuple[int, int] = (x_shape[0]+h_shape[0], h_shape[0])[::-1]\n",
    "W_p_shape: tuple[int, int] = (x_shape[0]+h_shape[0], p_shape[0])[::-1]\n",
    "\n",
    "assert isinstance(W_p_shape, tuple)\n",
    "assert len(W_p_shape) == 2\n",
    "assert hashcheck(f'W_p{sum(W_p_shape)}') == '6c7416d9e1335f1b', 'W_p shape likely incorrect'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "133c4f28",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "eefe461dceabd49b598d73bdd05a4ff3",
     "grade": true,
     "grade_id": "test-9-2-gru-shapes",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-2-gru-shapes - possible points: 1\n",
    "\n",
    "assert isinstance(W_r_shape, tuple)\n",
    "assert len(W_r_shape) == 2\n",
    "assert hashcheck(f'W_r{sum(W_r_shape)}') == 'f1e3f6eba02f53b1', 'W_r shape likely incorrect'\n",
    "\n",
    "assert isinstance(W_z_shape, tuple)\n",
    "assert len(W_z_shape) == 2\n",
    "assert hashcheck(f'W_z{sum(W_z_shape)}') == 'e5f3c32506daf289', 'W_z shape likely incorrect'\n",
    "\n",
    "assert isinstance(W_h_shape, tuple)\n",
    "assert len(W_h_shape) == 2\n",
    "assert hashcheck(f'W_h{sum(W_h_shape)}') == '18645d6bfc1fc4b4', 'W_h shape likely incorrect'\n",
    "\n",
    "assert isinstance(W_p_shape, tuple)\n",
    "assert len(W_h_shape) == 2\n",
    "assert hashcheck(f'W_p{sum(W_p_shape)}') == '6c7416d9e1335f1b', 'W_p shape likely incorrect'\n",
    "\n",
    "# NOTE: The hidden tests will simply check for the exact expected shape.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fac7c86",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5747eaf42e0896c0f9d6f6272d991954",
     "grade": false,
     "grade_id": "task-9-3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 9.3 (6 points)** In this task, we want to solve the same toy problem as previously solved in Task 9.1. However, instead of using an arbitrary dictionary memory, we'll try to implement a ``GRU`` cell which implements the same functionality.\n",
    "\n",
    "The following code cell implements the ``gru_step`` function, which implements the above introduced GRU cell. In each time step, the function receices the current values of the input signals $u$ and $v$ as arguments. The function additionally receives the current *state* $h_0$, $h_1$ of the cell's memory. The function also accepts the various weight and bias tensors ($W_r$, $b_r$, $W_z$, ...) of the GRU cell as additional arguments. Based on these inputs, the function implements one forward pass of the GRU cell and is supposed to return a tuple of the following three values:\n",
    "- The updated value for the first state $h_0$\n",
    "- The updated value for the second state $h_1$\n",
    "- The current readout value $p$ which is supposed to match the value of the output signal $y$\n",
    "  at the current time step.\n",
    "  \n",
    "Your task is to populate the the weight and bias matrices $W_r$, $b_r$, $W_z$, $b_z$, $W_h$, $b_h$, $W_p$, $b_p$ in a way such that the readout value $p$ returned by the function matches the expected output signal $y$.\n",
    "\n",
    "**NOTE.** This is a difficult exercise - it might make sense to initially skip this exercise and return to it later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "187bcedf",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "057713dedc617c45e5e357c93ba4bd84",
     "grade": false,
     "grade_id": "cell-92455f2c6f01dafa",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "def gru_step(u: int, \n",
    "             v: int, \n",
    "             h_0: float,\n",
    "             h_1: float,\n",
    "             # parameters for the reset\n",
    "             W_r: np.ndarray,\n",
    "             b_r: np.ndarray,\n",
    "             # parameters for the gate\n",
    "             W_z: np.ndarray,\n",
    "             b_z: np.ndarray,\n",
    "             # parameters for the update\n",
    "             W_h: np.ndarray,\n",
    "             b_h: np.ndarray,\n",
    "             # parameters for the readout\n",
    "             W_p: np.ndarray,\n",
    "             b_p: np.ndarray,\n",
    "             ) -> tuple[float, float, float]:\n",
    "    \"\"\"\n",
    "    This function implements the forward pass of a GRU cell.\n",
    "    \n",
    "    Based on the the current values of the input signals ``u`` and ``v``, the current \n",
    "    values of the memory states ``h_0`` and ``h_1`` and the weight and bias matrices \n",
    "    of the GRU cells to make the \n",
    "    \n",
    "    :param u: The current value of the u signal\n",
    "    :param v: The current value fo the v signal\n",
    "    :param h_0: The current value of the first memory cell\n",
    "    :param h_1: The current value of the second memory cell\n",
    "    :param W_r: the weight matrix of the reset gate\n",
    "    :param b_r: the bias vector of the reset gate\n",
    "    :param W_z: the weight matrix of the selection gate\n",
    "    :param b_z: the bias vector of the selection gate\n",
    "    :param W_h: the weight matrix of the update gate\n",
    "    :param b_h: the bias vector of the update gate\n",
    "    :param W_p: the weight matrix of the readout gate\n",
    "    :param b_p: the bias vector of the readout gate\n",
    "    \n",
    "    :returns: A tuple of the following three values:\n",
    "        - the updated value of h_0\n",
    "        - the updated value of h_1\n",
    "        - the readout value p\n",
    "    \"\"\"\n",
    "    \n",
    "    h_t = np.array([h_0, h_1])\n",
    "    inp = np.array([u, v, h_t[0], h_t[1]], dtype=float)\n",
    "    \n",
    "    # ~ reset vector\n",
    "    r_t = np.sigmoid((W_r @ inp) + b_r)\n",
    "    \n",
    "    # ~ selection vector\n",
    "    z_t = np.sigmoid((W_z @ inp) + b_z)\n",
    "    \n",
    "    # ~ new state vector\n",
    "    h_t_ = h_t * r_t\n",
    "    inp_tilde = np.array([u, v, h_t_[0], h_t_[1]])\n",
    "    h_tilde = np.tanh((W_h @ inp_tilde) + b_h)\n",
    "    \n",
    "    # ~ updating the state\n",
    "    h_t = (h_t * (1 - z_t)) + (h_tilde * z_t)\n",
    "    \n",
    "    # ~ readout value\n",
    "    p = np.sigmoid((W_p @ np.array([u, v, h_0, h_1])) + b_p)\n",
    "    \n",
    "    return h_t[0], h_t[1], p\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ec6e703",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6278a55a6a2297aeedc7c4212fb11098",
     "grade": false,
     "grade_id": "ans-9-3-gru-step",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# ~ \"reset\" weight matrix & bias\n",
    "W_r = np.array([\n",
    "    [0, 0, 0, 0],\n",
    "    [0, 0, 0, 0],\n",
    "], dtype=float)\n",
    "b_r = np.array([\n",
    "    0,\n",
    "    0,\n",
    "])\n",
    "\n",
    "# ~ \"gate\" weight matrix & bias\n",
    "W_z = np.array([\n",
    "    [0, 0, 0, 0],\n",
    "    [0, 0, 0, 0],\n",
    "], dtype=float)\n",
    "b_z = np.array([\n",
    "    0,\n",
    "    0\n",
    "])\n",
    "\n",
    "# ~ \"update\" weight matrix & bias\n",
    "W_h = np.array([\n",
    "    [0, 0, 0, 0],\n",
    "    [0, 0, 0, 0]\n",
    "], dtype=float)\n",
    "b_h = np.array([\n",
    "    0,\n",
    "    0,\n",
    "])\n",
    "\n",
    "# ~ \"readout\" weight matrix & bias\n",
    "W_p = np.array([\n",
    "    [0, 0, 0, 0],\n",
    "], dtype=float)\n",
    "b_p = np.array([\n",
    "    0\n",
    "])\n",
    "\n",
    "# TASK: Fill in appropriate values for the given weight matrices and bias vectors \n",
    "#       to realize the above described toy problem using the GRU cell.\n",
    "\n",
    "# HINT: With mathematical operations of matrix multiplication and addition, \n",
    "#       you won't be able to match the expected integer output *exactly*. \n",
    "#       However, the tests will check with an absolute tolerance of only 0.2, \n",
    "#       which means you'll only have to match the output value within a \n",
    "#       certain range. For an expected output value of 1, for example, a \n",
    "#       predicted value of 0.83 would still be counted as correct!\n",
    "\n",
    "# HINT: Large input numbers will saturate the sigmoid and tanh functions. Think\n",
    "#       about how to use this to your advantage to be able to work with (almost)\n",
    "#       binary numbers instead of having to deal with continuous ones. The task\n",
    "#       can entirely be solved by just storing \"binary\" flags in the two hidden \n",
    "#       states of the memory.\n",
    "\n",
    "# HINT: Think about a way of debugging your solution. You might want to think about \n",
    "#       writing some simple test cases yourself to understand how the function \n",
    "#       is behaving. Also think about how you could better track the internal \n",
    "#       workings of the layer. This could be as simple as printing the intermediate \n",
    "#       vectors or as advanced as tracking them visually in some plots.\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad8782f6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f020248f9285ae3909b966c26039b335",
     "grade": true,
     "grade_id": "test-9-3-gru-step",
     "locked": true,
     "points": 6,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-3-gru-step - possible points: 6\n",
    "\n",
    "# This is the example signal from the introduction of the sequential task\n",
    "us = np.array([1, 0, 1, 0, 1, 1, 0, 1, 0, 1,  1,  0,  1,  0,  1,  1])\n",
    "vs = np.array([0, 1, 0, 0, 0, 1, 0, 1, 0, 0,  1,  0,  1,  0,  1,  1])\n",
    "ys = np.array([0, 0, 1, 0, 0, 0, 0, 0, 1, 0,  0,  1,  0,  0,  0,  1])\n",
    "\n",
    "h_0 = 0\n",
    "h_1 = 0\n",
    "for t, u, v, y in zip(ts, us, vs, ys):\n",
    "    h_0, h_1, p = gru_step(\n",
    "        u, v, h_0, h_1, \n",
    "        W_r, b_r, \n",
    "        W_z, b_z, \n",
    "        W_h, b_h, \n",
    "        W_p, b_p\n",
    "    )\n",
    "    \n",
    "    y_pred = p[0]\n",
    "    assert np.isclose(y, y_pred, atol=0.2), f'predicted {y_pred} != expected {y}'\n",
    "    \n",
    "    \n",
    "# NOTE: The hidden tests will evaluate the weight and bias arrays on a number of randomly \n",
    "#       generated sequences of u, v input signals and corresponding output signals y.\n",
    "    \n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eca34c0d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4ebf83d12705738e7352b9a1bca7c817",
     "grade": false,
     "grade_id": "cell-5d99de620befe40c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 9.3 Long-Short Term Memory (LSTM)\n",
    "\n",
    "The *Long-Short Term Memory (LSTM)* is an alternative to the GRU cell which was introduced by [Hochreiter and Schmidhuber](https://doi.org/10.1162/neco.1997.9.8.1735). The following image illustrates the basic architecture of an LSTM cell:\n",
    "\n",
    "<img src=\"https://bwsyncandshare.kit.edu/s/NbKxq9CeMjCxZCg/download\">\n",
    "\n",
    "Much like the GRU cell, the LSTM cell also internally maintains a hidden representation $\\mathbf{h}_t$ which acts as a kind of memory that can be used to keep track of an internal *state* across different time steps. However, unlike the GRU cell, the LSTM cell naturally includes a *readout gate* which separates the internal hidden state $\\mathbf{h}_t$ and the readout signal $\\mathbf{p}_t$. Additionally, the selection mechanism that determines which parts of the previous state $\\mathbf{h}_{t-1}$ to keep and which parts of the new state $\\mathbf{\\tilde{h}}_{t}$ to update is implemented differently.\n",
    "\n",
    "Specifically, the LSTM cell can be described by the following equations. The two selection signals $f_t, i_t$ determine how to compose the current time step's hidden state vector from the previous and updated version, where \n",
    "\n",
    "$$\n",
    "f_t = \\sigma(W_f \\cdot (h_{t-1} || x_t) + b_f)\n",
    "$$\n",
    "\n",
    "is the selection signal that determines which parts of the previous time step's hidden vector to keep and \n",
    "\n",
    "$$\n",
    "i_t = \\sigma(W_i \\cdot (h_{t-1} || x_t) + b_i)\n",
    "$$\n",
    "\n",
    "is the selection signal that determines which parts of the updated state vector to use. The updated state vector \n",
    "\n",
    "$$\n",
    "\\tilde{h}_t = \\mathrm{tanh}(W_h \\cdot (h_{t-1} || x_t) + b_h)\n",
    "$$\n",
    "\n",
    "is calculated by a linear layer transformation based on the input vector and the previous state vector.\n",
    "Finally, the new hidden state vector\n",
    "\n",
    "$$\n",
    "h_t = f_t \\cdot h_{t-1} + i_t \\cdot \\tilde{h}_t\n",
    "$$\n",
    "\n",
    "is a linear combination of the previous state vector and the updated state vector.\n",
    "The readout signal \n",
    "\n",
    "$$\n",
    "p_t = \\mathrm{tanh}(h_t) \\cdot \\sigma(W_o \\cdot (h_{t-1} || x_t) + b_o)\n",
    "$$\n",
    "\n",
    "is derived from a masking of the current time steps's hidden state vector."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0d8ed41",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "728d2c12c81b42dd25b1206cbc481cb7",
     "grade": false,
     "grade_id": "task-9-4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 9.4 (3 points)** The goal of this task is to complete the implementation of the ``LSTM`` class below. To do this, you'll first have to properly initialize the weight matrices and bias vectors $W_f, b_f, W_i, b_i, W_h, b_h, W_o, b_o$ in the constructor of the class. In this task you can simply initialize all weight and bias arrays with all values set to zero. Additionally you'll have to implement the ``forward`` method which takes the current input vector $\\mathbf{x}_t$ and the previous hidden state vector $\\mathbf{h}_{t-1}$ as inputs and is expected to return a tuple consisting of the updated hidden state vector $\\mathbf{h}_t$ and the readout vector $\\mathbf{p}_t$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "c7f40b6c",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f0d5bb7222bb46df6b9a66d905ba79c4",
     "grade": false,
     "grade_id": "ans-9-4",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "class LSTM:\n",
    "    \"\"\"\n",
    "    numpy implementation of the Long-Short Term Memory (LSTM) cell.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,\n",
    "                 num_inputs: int,\n",
    "                 num_states: int,\n",
    "                 ):\n",
    "        \n",
    "        self.num_inputs = num_inputs\n",
    "        self.num_states = num_states\n",
    "        \n",
    "        # selection gate\n",
    "        self.W_f: np.ndarray = np.zeros((num_inputs+num_states,num_states)).T\n",
    "        self.b_f: np.ndarray = np.zeros((num_states,))\n",
    "            \n",
    "        # selection gate\n",
    "        self.W_i: np.ndarray = np.zeros((num_inputs+num_states,num_states)).T\n",
    "        self.b_i: np.ndarray = np.zeros((num_states,))\n",
    "            \n",
    "        # update gate\n",
    "        self.W_h: np.ndarray = np.zeros((num_inputs+num_states,num_states)).T\n",
    "        self.b_h: np.ndarray = np.zeros((num_states,))\n",
    "        \n",
    "        # readout gate\n",
    "        self.W_o: np.ndarray = np.zeros((num_inputs+num_states,num_states)).T\n",
    "        self.b_o: np.ndarray = np.zeros((num_states,))\n",
    "    \n",
    "    def forward(self,\n",
    "                x: np.ndarray,\n",
    "                h: np.ndarray,\n",
    "                ) -> tuple[np.ndarray, np.ndarray]:\n",
    "        \"\"\"\n",
    "        Given the current time step's input array ``x`` of the shape (input_dim, ) and the \n",
    "        previous time step's hidden state array ``h`` of the shape (hidden_dim, ), this \n",
    "        method returns a tuple (``h_new``, ``p``) consisting of the updated hidden state \n",
    "        vector and the readout vector of the shape (hidden_dim, ).\n",
    "        \"\"\"\n",
    "\n",
    "        sigmoid = lambda x: 1/(1+np.exp(-x))\n",
    "        \n",
    "        conc = np.concatenate((x,h))\n",
    "        ft = sigmoid(np.dot(self.W_f, conc) + self.b_f)\n",
    "        it = sigmoid(np.dot(self.W_i, conc) + self.b_i)\n",
    "        ht = np.tanh(np.dot(self.W_h, conc) + self.b_h)\n",
    "        ot = sigmoid(np.dot(self.W_o, conc) + self.b_o)\n",
    "\n",
    "        h_new = h*ft + it*ht\n",
    "        p = np.tanh(h_new)*ot\n",
    "        return h_new, p\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "3b17eb4c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "58cf095f4b37f1f89063f374c3c3163b",
     "grade": true,
     "grade_id": "test-9-4-lstm-constructor",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-4-lstm-constructor - possible points: 1\n",
    "\n",
    "# checking for one example instantiation of the LSTM class\n",
    "lstm = LSTM(2, 3)\n",
    "assert isinstance(lstm, LSTM)\n",
    "\n",
    "# all matrices and biase vectors have to be numpy arrays!\n",
    "assert isinstance(lstm.W_f, np.ndarray)\n",
    "assert isinstance(lstm.b_f, np.ndarray)\n",
    "assert isinstance(lstm.W_i, np.ndarray)\n",
    "assert isinstance(lstm.b_i, np.ndarray)\n",
    "assert isinstance(lstm.W_h, np.ndarray)\n",
    "assert isinstance(lstm.b_h, np.ndarray)\n",
    "assert isinstance(lstm.W_o, np.ndarray)\n",
    "assert isinstance(lstm.b_o, np.ndarray)\n",
    "\n",
    "# all \"W\" variables have to be matrices (2-dimensional)\n",
    "assert len(lstm.W_f.shape) == 2\n",
    "assert len(lstm.W_i.shape) == 2\n",
    "assert len(lstm.W_h.shape) == 2\n",
    "assert len(lstm.W_o.shape) == 2\n",
    "\n",
    "# all \"b\" variables have to be biases (1-dimensional)\n",
    "assert len(lstm.b_f.shape) == 1\n",
    "assert len(lstm.b_i.shape) == 1\n",
    "assert len(lstm.b_h.shape) == 1\n",
    "assert len(lstm.b_o.shape) == 1\n",
    "\n",
    "# checking the exact shape of one gate as an example\n",
    "assert hashcheck(f'W_f{lstm.W_f.shape}') == '9e7dcaf998a20515', 'W_f likely wrong shape'\n",
    "assert hashcheck(f'b_f{lstm.b_f.shape}') == 'd7ff6f69428e93c9', 'b_f likely wrong shape'\n",
    "\n",
    "# NOTE: The hidden tests will construct a number of test cases with combinations of \n",
    "#       random input and hidden dimensions. For each combination, a new LSTM instance \n",
    "#       will be created and the shapes of the weights and bias arrays will be checked \n",
    "#       against the expected shapes.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "0022f219",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9b7b462c2360511b90a0b253fe92cbfb",
     "grade": true,
     "grade_id": "test-9-4-lstm-forward",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-4-lstm-forward - possible points: 2\n",
    "\n",
    "lstm = LSTM(2, 3)\n",
    "x = np.array([1.0, 1.0])\n",
    "h = np.array([2.0, 3.0, -2.0])\n",
    "\n",
    "h_new, p = lstm.forward(x, h)\n",
    "\n",
    "assert isinstance(h_new, np.ndarray)\n",
    "assert h_new.shape == (3, )\n",
    "\n",
    "assert isinstance(p, np.ndarray)\n",
    "assert p.shape == (3, )\n",
    "\n",
    "# For the given input arrays these are the expected  outputs of the forward method\n",
    "# HINT: For these results, the assumption is that all the matrices and biases are \n",
    "#       initialized with all zero values in the constructor of the LSTM class\n",
    "assert np.isclose(h_new, np.array([1.0, 1.5, -1.0]), rtol=0.1).all(), 'h_new calculation incorrect'\n",
    "assert np.isclose(p, np.array([ 0.380,  0.452, -0.380]), rtol=0.1).all(), 'p calculation incorrect'\n",
    "\n",
    "# NOTE: The hidden tests will execute the forward pass for a few sample input and hidden \n",
    "#       vectors and compare the results of the given implementation with the ground truth \n",
    "#       implementation.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b78950fd",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "839c5113535abed9d340b8b708bc2f89",
     "grade": false,
     "grade_id": "cell-dc60f9831168a4f0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 9.4 ECG Classification\n",
    "\n",
    "**ECG Classification.** In this section, we want to apply the problem to an actual classification task on sequentially structured data. Specifically, we are going to use a dataset of [*Electrocardiogram (ECG)*](https://en.wikipedia.org/wiki/Electrocardiography) data. An ECG is a medical test that measures the electrical activity of the heart over a period of time using electrodes placed on the skin. This data is inherently sequential and is characterized by temporal patterns that are crucial for identifying heart conditions. The resulting measurement is a function over time and may, for example, look similar the following image:\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/a/a2/12_lead_ECG_of_a_26_year_old_male.jpg\" width=\"80%\">\n",
    "\n",
    "Such ECG measurements can be used to detect certain heart conditions which will create certain characteristic deviations in the course of the signal. To diagnose these heart conditions, specifically trained medical staff is able to identify the characteristic deviations in the signal. Alternatively, since the deviations caused by the various diseases follow a characteristic pattern, it is also possible to apply a machine learning model to use a patient's ECG signal as an input to classify a possible heart condition.\n",
    "\n",
    "**ECG Dataset.** In this section we'll be using a dataset of ECG data that consists of roughly 5k patient's records. Each record is a function over time representing only a single heartbeat within a larger EKG measurement. The records of different patients have different lengths."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8a67b33",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a9bad1b5eee1a894d4a58e24c31f06e7",
     "grade": false,
     "grade_id": "cell-ba366cb8fd6212a6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Data Loading.** The first step in working with the given ECG dataset is to load the dataset into memory. However, compared to previous datasets you've worked with, sequential data is a less convenient data format. Since the different elements of a sequential dataset may have different sequence lenghts, they cannot be easily encoded into a single CSV file. Because of this, sequential datasets are sometimes given in more *unusual* data formats, where the individual sequences are often encoded as individual files. This circumstance can somewhat complicate the process of loading sequential datasets into a sensible format for the subsequent training of the machine learning models.\n",
    "\n",
    "The given ECG dataset is available as a ZIP archive ``ecg.zip``. This archive contains multiple files - exactly *one* for each element in the dataset. Each of these files is a ``.npy`` numpy file, which contains the binary encoding of a numpy array. The content of these files encodes a 1-dimensional numpy array that represents the ECG signal of one patient. The *names* of the files contain the information about the patient ID from which the sample was recoreded, as well as the target label (normal/abnormal) associated with each recording in the following format:\n",
    "\n",
    "``\"patient_{patient_id}_{label}.npy\"``\n",
    "\n",
    "Some examples are: \n",
    "\n",
    "- ``patient_0001_normal.npy``\n",
    "- ``patient_0022_normal.npy``\n",
    "- ``patient_2906_abnormal.npy``"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6c16a35",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "844d8bc2ad37f311f837804c2b64cb80",
     "grade": false,
     "grade_id": "task-9-5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 9.5 (2 points)** In this task, the goal is to implement the ``load_dataset`` function. This function accepts the path to the dataset ZIP archive and is supposed to return a list of dictionaries, where ach dict represents a single element in the dataset. Each of these dicts should contain the following three key value pairs:\n",
    "\n",
    "- ``id``: The *integer* ID of the patient from whom the ECG recording was collected.\n",
    "- ``target``: The *integer* target value annotation, which is 0 for ECG data labeled as \"normal\" and is 1 for      \"abnormal\" ECG data\n",
    "- ``signal``: A *list* of *lists* containing *float* values that represents the time series recording of the ECG itself.\n",
    "\n",
    "An example for the expected final result may look like this:\n",
    "\n",
    "```python\n",
    "dataset = [\n",
    "    {\n",
    "        'id': 0,\n",
    "        'target': 0,\n",
    "        # Wrapping each element in a list may seem redundant but we do this here because \n",
    "        # the model later on expects each sequence to be a 2-dimensional tensor!\n",
    "        'signal': [[0.9], [0.8], ...],\n",
    "    },\n",
    "    {\n",
    "        'id': 1,\n",
    "        'target': 0,\n",
    "        'signal': [[0.7], [0.8], ...],\n",
    "    },\n",
    "    ...\n",
    "]\n",
    "```\n",
    "\n",
    "The path to the downloaded dataset archive is available in the ``zip_path`` variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "246ac2a8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "44b3a5786354f113ac43466034dda7d2",
     "grade": false,
     "grade_id": "cell-64a2b3d0701ef35b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# The dataset archive ZIP file will be downloaded and stored on the local system at \n",
    "# the path given in \"zip_path\"\n",
    "content = nextcloud_download('https://bwsyncandshare.kit.edu/s/xMctqCzFp3XRtKM', raw=True)\n",
    "zip_path = 'ecg_.zip'\n",
    "with open(zip_path, 'wb') as file:\n",
    "    file.write(content)\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "60121261",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "17c1866fb3a9cc6b62c5fca6d43604b1",
     "grade": false,
     "grade_id": "ans-9-5",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# TASK: Implement the following function which loads the dataset from its ZIP \n",
    "#       archive format into a list of dictionaries that contain all the relevant \n",
    "#       information about the various data points.\n",
    "\n",
    "# HINT: If not already the case, it makes sense to familiarize yourself with the \n",
    "#       \".npy\" numpy file format and how to load the data contained in these kinds \n",
    "#       of files.\n",
    "\n",
    "def load_dataset(path: str) -> list[dict]:\n",
    "    \"\"\"\n",
    "    This function loads the dataset from the ZIP archive at the given absolute string \n",
    "    ``path`` and returns a list of dict objects, where each dict contains the information \n",
    "    about one element of the dataset.\n",
    "    \n",
    "    Each dict contains the following 3 keys:\n",
    "    - id: The unique integer id of the element\n",
    "    - target: The integer target value annotation\n",
    "    - signal: A list of list float values that represents the signal\n",
    "    \"\"\"\n",
    "    dataset = []\n",
    "    with zipfile.ZipFile(path) as ecgzip:\n",
    "        files = ecgzip.namelist()\n",
    "        for file in files:\n",
    "            with ecgzip.open(file, mode='r') as single:\n",
    "                datum = {\n",
    "                    'signal': np.load(single).reshape(-1,1).tolist(),\n",
    "                    'id': int(file[8:12]),\n",
    "                    'target': 1 if \"abnormal\"in file else 0\n",
    "                }\n",
    "                dataset.append(datum)\n",
    "    return dataset\n",
    "\n",
    "ds = load_dataset(\"ecg_.zip\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "fe7e6f5f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2c5aa9b9215450e0b570341d2ee09466",
     "grade": true,
     "grade_id": "test-9-5-load-dataset",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-5-load-dataset - possible points: 2\n",
    "\n",
    "# making sure the dataset ZIP archive exists\n",
    "assert os.path.exists(zip_path)\n",
    "assert os.path.isfile(zip_path)\n",
    "assert zip_path.endswith('.zip')\n",
    "\n",
    "# loading the dataset\n",
    "dataset = load_dataset(zip_path)\n",
    "assert len(dataset) == 4766\n",
    "\n",
    "# simply checking for the correctness of the first element as a proxy for \n",
    "# the entire dataset.\n",
    "first_element = dataset[0]\n",
    "assert 'id' in first_element\n",
    "assert isinstance(first_element['id'], int)\n",
    "\n",
    "assert 'target' in first_element\n",
    "assert isinstance(first_element['target'], int)\n",
    "\n",
    "assert 'signal' in first_element\n",
    "assert isinstance(first_element['signal'], list)\n",
    "assert len(first_element['signal']) > 0\n",
    "assert len(np.array(first_element['signal']).shape) == 2, \"The signal should be 2-dim arrays!\"\n",
    "\n",
    "# NOTE: The hidden tests will perform similar type and shape checks for all the \n",
    "#       elements of the dataset.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "36981e4f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4cc8d1d8dddfbee29a8219e5b6bf6221",
     "grade": false,
     "grade_id": "cell-01833fecab335082",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'signal value')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAATYCAYAAAAszUdsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9aZBsaVXuv3IeKiurMquy5vnUGfp09+kRmqaBbqAB2wHbqxGKF8QZBRRFP9jKVfjrjXYICQxERLyXxgnxegMVFBCZmpkeD91nHmqep8ysqqyc8//huc9ZO2uuM1XVOesXUVFVOez97nfv/e53vWutZ7kqlUpFDMMwDMMwDMMwjDW4d7sBhmEYhmEYhmEYexUzmAzDMAzDMAzDMDbADCbDMAzDMAzDMIwNMIPJMAzDMAzDMAxjA8xgMgzDMAzDMAzD2AAzmAzDMAzDMAzDMDbADCbDMAzDMAzDMIwNMIPJMAzDMAzDMAxjA8xgMgzDMAzDMAzD2AAzmAzDMIw9xUMPPSQPPfTQbjfjuvHEE0+Iy+WSwcHB3W6KiIj89E//tPT09Ox2MwzDMPYMZjAZhmHsMzjBDgaDMjY2tub9hx56SG677bZdaNn1paenR1wu17o/3/d937fm888//7y8+c1vls7OTgkEAhKPx+Xhhx+Wj33sY1Iqlao+m8vl5IMf/KC84hWvkFgsJn6/X9ra2uSNb3yjfOITn1jz+fXI5/PyZ3/2Z3LXXXdJNBqV+vp6ufXWW+UXf/EX5fTp01etHwzDMIxri3e3G2AYhmFcHrlcTv7wD/9QPvjBD+52U3aNO++8U37jN35jzettbW1V///1X/+1/NIv/ZI0NzfLW97yFjl48KAsLi7KF7/4Rfm5n/s5mZiYkN/+7d8WEZGZmRl55JFH5JlnnpE3vOEN8p73vEfi8bhMTk7Kf/3Xf8lP/uRPyvnz5+V//I//sWnbfvRHf1Q++9nPypve9Cb5hV/4BSkUCnL69Gn5zGc+Iy9/+cvlyJEjIiLylre8RX7iJ35CAoHAVeoVwzAM42piBpNhGMY+5c4775SPfvSj8thjj60xEK4WlUpFstmshEKha7L9K6W9vV3e/OY3b/qZb3/72/JLv/RLcv/998t//Md/SG1t7aX3fu3Xfk2efvppefHFFy+99pa3vEWee+45+b//9//Kf/tv/61qW4899pg8/fTTcubMmU33+dRTT8lnPvMZ+Z//839eMsTIn//5n0symbz0v8fjEY/Hs9WhGoZhGLuEheQZhmHsU377t39bSqWS/OEf/uGWny0Wi/L7v//7cuDAAQkEAtLT0yO//du/LblcrupzPT098oM/+IPy+c9/Xu69914JhULykY98RL7yla+Iy+WSf/qnf5L3ve990t7eLrW1tfJjP/ZjkkqlJJfLya/92q9JU1OTRCIR+Zmf+Zk12/7Yxz4mr3nNa6SpqUkCgYAcPXpUPvzhD1/VPlmP973vfeJyueTv//7vq4wlcu+998pP//RPi4jIt771Lfn85z8vv/iLv7jGWHJ+/r//9/++6T4vXLggIiIPPPDAmvc8Ho80NDRc+n+9HKZyuSzvfe97pa2tTcLhsLz61a+WkydPSk9Pz6W2Or/7jW98Q9797ndLIpGQmpoa+ZEf+RGZmZmp2u+//uu/yg/8wA9IW1ubBAIBOXDggPz+7//+tsIL//Ef/1Huueceqa2tlWg0Krfffrv82Z/92ZbfMwzDuBEwD5NhGMY+pbe3V37qp35KPvrRj8pv/dZvbepl+vmf/3n5+Mc/Lj/2Yz8mv/EbvyHf+c535PHHH5dTp07Jpz71qarPnjlzRt70pjfJ2972NvmFX/gFOXz48KX3Hn/8cQmFQvJbv/Vbcv78efngBz8oPp9P3G63LCwsyHvf+1759re/LU888YT09vbK7/7u71767oc//GG59dZb5Y1vfKN4vV759Kc/LW9/+9ulXC7LO97xjsvqg0KhILOzs2ter6mpkVAoJJlMRr74xS/Kq171Kunq6tpye5/+9KdFRLb0Wm1Fd3e3iIj8/d//vTzwwAPi9e7scfvYY4/JH//xH8sP/dAPyRve8AY5fvy4vOENb5BsNrvu53/lV35FYrGY/N7v/Z4MDg7KBz7wAXnnO98pn/zkJy995oknnpBIJCLvfve7JRKJyJe+9CX53d/9XUmn0/Inf/InG7blC1/4grzpTW+S1772tfJHf/RHIiJy6tQp+cY3viHvete7dnRchmEY+5KKYRiGsa/42Mc+VhGRylNPPVW5cOFCxev1Vn71V3/10vsPPvhg5dZbb730//PPP18RkcrP//zPV23nN3/zNysiUvnSl7506bXu7u6KiFQ+97nPVX32y1/+ckVEKrfddlsln89fev1Nb3pTxeVyVR555JGqz99///2V7u7uqtcymcyaY3nDG95Q6evrq3rtwQcfrDz44IObd4Kjrev9PP7445VKpVI5fvx4RUQq73rXu7bcXqVSqfzIj/xIRUQqyWSy6vWVlZXKzMzMpZ+FhYVNt1MulysPPvhgRUQqzc3NlTe96U2VD33oQ5WhoaE1n+X5HBgYqFQqlcrk5GTF6/VWHn300arPvfe9762ISOWtb33rmu8+/PDDlXK5fOn1X//1X694PJ6q41iv/9/2trdVwuFwJZvNXnrtrW99a9W5e9e73lWJRqOVYrG46TEbhmHcqFhInmEYxj6mr69P3vKWt8hf/dVfycTExLqf+Y//+A8REXn3u99d9TrFEv793/+96vXe3l55wxvesO62fuqnfkp8Pt+l/++77z6pVCrysz/7s1Wfu++++2RkZESKxeKl15x5UKlUSmZnZ+XBBx+UixcvSiqV2upQ1+W+++6TL3zhC2t+3vSmN4mISDqdFhFZNxRvPfj5SCRS9fpf/uVfSiKRuPTzile8YtPtuFwu+fznPy9/8Ad/ILFYTD7xiU/IO97xDunu7pYf//Efr8phWs0Xv/hFKRaL8va3v73q9V/5lV/Z8Du/+Iu/KC6X69L/r3zlK6VUKsnQ0NCl15z9v7i4KLOzs/LKV75SMpnMpqp99fX1sry8LF/4whc2O2TDMIwbFjOYDMMw9jnvec97pFgsbpjLNDQ0JG63W/r7+6teb2lpkfr6+qpJtQgMpo1YHdZWV1cnIiKdnZ1rXi+Xy1WG0De+8Q15+OGHpaamRurr6yWRSFwSRLhcg6mxsVEefvjhNT8MiYtGoyICA2E70LBaWlqqev1Hf/RHLxljx44d29a2AoGA/M7v/I6cOnVKxsfH5ROf+IS87GUvk3/6p3+Sd77znRt+j+dj9fmKx+MSi8XW/c7q88LPLSwsXHrtxIkT8iM/8iNSV1cn0WhUEonEpdDDzfr/7W9/uxw6dEgeeeQR6ejokJ/92Z+Vz33uc5scuWEYxo2FGUyGYRj7nL6+Pnnzm9+8qZdJRKo8EJuxmSLeRmpuG71eqVREBCIIr33ta2V2dlbe//73y7//+7/LF77wBfn1X/91EYHIwbWgv79fvF6vvPDCC9v6PKW+nap5IjAIaYxtZLRsRmtrq/zET/yEPPnkk3Lw4EH5p3/6pyrv25WyVf8nk0l58MEH5fjx4/L//X//n3z605+WL3zhC5dykjbr/6amJnn++efl3/7t3+SNb3yjfPnLX5ZHHnlE3vrWt1619huGYexlzGAyDMO4AaCXiRNgJ93d3VIul+XcuXNVr09NTUkymbzkjbmWfPrTn5ZcLif/9m//Jm9729vk+7//++Xhhx++5nLl4XBYXvOa18iTTz4pIyMjW37+B3/wB0UEYg3XAp/PJ8eOHdtQrEJEBSPOnz9f9frc3FyVx2gnfOUrX5G5uTl54okn5F3vepf84A/+4I6MP7/fLz/0Qz8kf/EXfyEXLlyQt73tbfI3f/M3a9poGIZxI2IGk2EYxg3AgQMH5M1vfrN85CMfkcnJyar3vv/7v19ERD7wgQ9Uvf7+979fRER+4Ad+4Jq3jx4QejxEEAb2sY997Jrv+/d+7/ekUqnIW97yljWhdiIizzzzjHz84x8XEciAv+51r5O/+qu/kn/9139dd3vOY9iIc+fOyfDw8JrXk8mkfOtb35JYLCaJRGLd7772ta8Vr9e7RnL9z//8z7fc70as1//5fF7+4i/+Ysvvzs3NVf3vdrsvhSWulo43DMO4ETFZccMwjBuE3/md35G//du/lTNnzsitt9566fU77rhD3vrWt8pf/dVfXQrN+u53vysf//jH5dFHH5VXv/rV17xtr3/96y95Kd72trfJ0tKSfPSjH5WmpqZNwwi3YmxsTP7u7/5uzeuRSEQeffRRERF5+ctfLh/60Ifk7W9/uxw5ckTe8pa3yMGDB2VxcVG+8pWvyL/927/JH/zBH1z67t/93d/J933f98mjjz4qjzzyyCVPzOTkpPzXf/2XPPnkk/LII49s2q7jx4/LT/7kT8ojjzwir3zlKyUej8vY2Jh8/OMfl/HxcfnABz6wYRhdc3OzvOtd75I//dM/lTe+8Y3yfd/3fXL8+HH57Gc/K42NjdsOrXTy8pe/XGKxmLz1rW+VX/3VXxWXyyV/+7d/uy3j7+d//udlfn5eXvOa10hHR4cMDQ3JBz/4Qbnzzjvllltu2XFbDMMw9htmMBmGYdwg9Pf3y5vf/OZL3hInf/3Xfy19fX3yxBNPyKc+9SlpaWmRxx57TH7v937vurTt8OHD8s///M/ynve8R37zN39TWlpa5Jd/+ZclkUisUdjbCc8//7y85S1vWfN6d3f3JYNJRORtb3ubvOQlL5E//dM/lb/5m7+RmZkZiUQicvfdd8vHPvaxqrpLTU1N8s1vflM+8pGPyCc/+Ul53/veJ5lMRhobG+Xee++Vv//7v5cf//Ef37Rdr3rVq+T3f//35bOf/ay8//3vl5mZGamtrZW77rpL/uiP/kh+9Ed/dNPv/9Ef/ZGEw2H56Ec/Kv/1X/8l999/v/znf/6nvOIVr5BgMLizThKRhoYG+cxnPiO/8Ru/Ie95z3skFovJm9/8Znnta1+7oSIiYX7cX/zFX0gymZSWlhb58R//cXnve98rbrcFqhiGcePjqmxneckwDMMwjF0lmUxKLBaTP/iDP5Df+Z3f2e3mGIZh3DTY0pBhGIZh7DFWVlbWvMYctIceeuj6NsYwDOMmx0LyDMMwDGOP8clPflKeeOIJ+f7v/36JRCLy9a9/XT7xiU/I61//ennggQd2u3mGYRg3FWYwGYZhGMYe49ixY+L1euWP//iPJZ1OXxKCcIpTGIZhGNcHy2EyDMMwDMMwDMPYAMthMgzDMAzDMAzD2AAzmAzDMAzDMAzDMDbgpsphKpfLMj4+LrW1tZdV+M8wDMMwDMMwjBuDSqUii4uL0tbWtmlduZvKYBofH5fOzs7dboZhGIZhGIZhGHuEkZER6ejo2PD9m8pgqq2tFRF0SjQa3eXWGIZhGIZhGIaxW6TTaens7LxkI2zETWUwMQwvGo2awWQYhmEYhmEYxpapOib6YBiGYRiGYRiGsQFmMBmGYRiGYRiGYWyAGUyGYRiGYRiGYRgbYAaTYRiGYRiGYRjGBpjBZBiGYRiGYRiGsQFmMBmGYRiGYRiGYWyAGUyGYRiGYRiGYRgbYAaTYRiGYRiGYRjGBpjBZBiGYRiGYRiGsQFmMBmGYRiGYRiGYWyAGUyGYRiGYRiGYRgbYAaTYRiGYRiGYRjGBpjBZBiGYRiGYRiGsQFmMBmGYRiGYRiGYWyAGUyGYRiGYRiGYRgbYAaTYRiGYRiGYRjGBpjBZBiGYRiGYRiGsQH7xmD68Ic/LMeOHZNoNCrRaFTuv/9++exnP7vbzTIMwzAMwzAM4wZm3xhMHR0d8od/+IfyzDPPyNNPPy2vec1r5Id/+IflxIkTu900wzAMwzAMwzBuUFyVSqWy2424XOLxuPzJn/yJ/NzP/dy2Pp9Op6Wurk5SqZREo9Fr3DrDMAzDMAzDEFlZEcnlROrrd7slhpPt2gbe69imq0apVJL/83/+jywvL8v999+/4edyuZzkcrlL/6fT6evRPMMwDMMwDMMQEZGFBZGBAZFKReTgQRFbs99/7JuQPBGRF154QSKRiAQCAfmlX/ol+dSnPiVHjx7d8POPP/641NXVXfrp7Oy8jq01DMMwDMMwbmamp0UuXoSxJCIyM7O77TEuj30VkpfP52V4eFhSqZT88z//s/z1X/+1fPWrX93QaFrPw9TZ2WkheYZhGIZhGMY1ZXRUZGoKf8di8DS5XCK33y7i8+1u2wyw3ZC8fWUwrebhhx+WAwcOyEc+8pFtfd5ymAzDMAzDMIxrSaWCELyFBfzf3i7S0iJy5ozI0pJIW5tIa+vuttEA27UN9lVI3mrK5XKVB8kwDMMwDMMwrhfruR0uXFBvUm8vjCURkUQCv2dn1/+esXfZN6IPjz32mDzyyCPS1dUli4uL8g//8A/yla98RT7/+c/vdtMMwzAMwzCMm5AXXxQJBkW6u0X8fpFsViSVgrF08KBIba1+NhYTGRkRyefxGVPM2z/sG4NpenpafuqnfkomJiakrq5Ojh07Jp///Oflda973W43zTAMwzAMw7jJWF6G8VMqaU5SMonftbXVxpIIjKiGBuQ1zcyYwbSf2DcG0//6X/9rt5tgGIZhGIZhGCKixlE0CmNIRPOWYrH1v5NIwGBKp1GXKRC45s00rgL7OofJMAzDMAzDMHaD1cZRLieSycB42sh7FAhoHabZ2WveROMqYQaTYRiGYRiGYeyAbBYGksulBhA9TpGIiHeTGC4Tf9h/mMFkGIZhGIZhGDuA3qVoVMTjqX5to3A8UleHnKdiUb9j7G3MYDIMwzAMwzCMHUBvEkPv8nmIQDhfczI8LHLiBD7jcok0NuJ1C8vbH5jBZBiGYRiGYRjbJJ9HrpIIvEUi1eF4VMwjS0tQxctmRc6ehaQ4DabFRbxu7G3MYDIMwzAMwzCMbbKecbRZON7YGH57PCLlMgrbptNrjS1j72IGk2EYhmEYhmFsk9XheIUCvEjO10gqhffcbpGjR1GHqVIRGRpSz1I6fR0abVwR+6YOk2EYhmEYhmHsJsXiWuOIBlRNjYjfX/15epcSCbzX0wOv1OQkwvHm5vB+uQyjytib2KkxDMMwDMMwjG2QSsFDFApp0dmNwvHm50VWVhCK19Kir7e3i3R1wYBaXkZ+0+Li9Wm/cXmYh8kwDMMwDMMwtsHqcLxiUY0dZzhepSIyPo6/m5vX1mVKJOBpSqWQC+XMaTL2HuZhMgzDMAzDMIwtKJc132h1OF44rB4nEciF53IwlJqb199efb3I3XfDA2V5THsbM5gMwzAMwzAMYwvSaRhNfj8MJJH1w/HKZZGJCfzd2rp5blJtLeoyZbOQKzf2JmYwGYZhGIZhGMYW0JtE42ijcLzpaSjn+f0IvdsMjwdiESLmZdrLmMFkGIZhGIZhGJtQqazNX5qbw+vhsEgwiNeKRSjgiYi0tcF7tBXRKH6bwbR3MYPJMAzDMAzDMDZhelqkVIJQAz1Cs7P43dionxsfx+dCIZF4fHvbdhpMlcrVa7Nx9TCDyTAMwzAMwzA2IJdTxTt6jZaWkHfkdqthtLICiXARkc7O7XmXROCh8nhgaGUyV7/9xpVjBpNhGIZhGIZhbMDQEIQcamvVm0TvUiwGY0dEZGREX6ut3f72XS4Ly9vrmMFkGIZhGIZhGOswOwthB7dbpLsbr5VKqo5HAyqZxOdcLpGOjp3vxwymvY0ZTIZhGIZhGIaxikJBZHQUf7e1aZ2l+Xl4nIJBFJ0tl/VzLS1Qx9spNJiWl2GQGXsLM5gMwzAMwzAMYxUjIzBewmGRpiZ9fbXYw/Q08px8PhhMl4PfDwOsUlGpcmPvYAaTYRiGYRiGYThIJhF253KJ9PSogEMmgx+XS6ShAV4oFqnt6Ni8SO1WWFje3sUMJsMwDMMwDMP4f5RKIsPD+Lu5GRLhhN6l+noRr1dkbAwheTU125cR3wgzmPYuZjAZhmEYhmEYxv9jehqeo0BApLVVXy+Xkb8kgnC8pSUUrxWBjPiVUlsLz1Uuhx9j72AGk2EYhmEYhmEIjKLpafzd1lYdYrewAO9TIADjhjLijY1azPZKcLshIiEikkpd+faMq4cZTIZhGIZhGIYhKDxbLMIoisWq32M4XkMD/s5kUIOpvf3q7b++Hr/puTL2BmYwGYZhGIZhGDc95bLI1BT+bmlRoQcRkWwWIXgiMGrGxvB3eztyma4W8Tj2S3EJY29gBpNhGIZhGIZx0zM3h9wlvx9eJCc0pOrr8TflxiktfrXwes3LtBcxg8kwDMMwDMO4qalURCYn8Xdzc7V3qVhU4yUS0b+7uqo/d7WgsTY/j3YZu48ZTIZhGIZhGMZNzfy8SD6P4rOrvUYzMzBcwmFVyWtouDpCD+sRjaIdxSLqQRm7jxlMhmEYhmEYxk2L07vU1FStjOdUzfN6Veiho+PatYdFcUUsLG+vYAaTYRiGYRiGcdOSTELUweMRSSSq35ufh6fH41HRh7a2qyv0sB70cqVSyKsydhczmAzDMAzDMIyblokJ/G5qgmHkhGIPXi+8TaHQWqPqWhAIaE0m8zLtPmYwGYZhGIZhGDcl6bTIygrC8Jqa1r6XzeK9UgmvNTVdG6GH9WBYHus/GbuHGUyGYRiGYRjGTQlFHBob14bZ0bsUCGhYXjx+/doWi8FYy+U0HNDYHcxgMgzDMAzDMG46KhVVoYvFqt9bWYGHyUljY7UgxLXG49F2WVje7mIGk2EYhmEYhnHTkU4j1M7n03whQu9SOAzjSeT65C6thuIP8/PIoTJ2BzOYDMMwDMMwjJuOhQX8Xu1dKhQ0VI8iEHV1CM273kQi2G+5rO01rj9mMBmGYRiGYRg3FZuF401O4v1QCHWXRHbHu0SYN2V5TLuHGUyGYRiGYRjGTYUzHK+mRl/P50VmZvB3KITPBALwMO0WoRB+MzTQuP6YwWQYhmEYhmHcVDC8rb6+WiZ8YgLepdra3c1dchIM4nc2u7vtuJkxg8kwDMMwDMO4adgoHC+XUzW6aFTrM1F4YbcIBmHUlUrIrzKuP2YwGYZhGIZhGDcNi4vrq+PRuxSNau5SPK7CD7uFy6WCExaWtzuYwWQYhmEYhmHcNKwXjpfNqnepqUk9UE1N17t162NhebuLGUyGYRiGYRjGTcFG4Xjj4/hdXw8vTqUC7xMFF3YbE37YXcxgMgzDMAzDMG4KFhdFisXqcLxMRr1ObW0is7P4e7dzl5yYh2l3MYPJMAzDMAzDuClYLxyP3qV4HMZULoe8pdX1mXYTGkzmYdodzGAyDMMwDMMwbnjWC8dbXhZJpfB3a6t6l2IxKOTtFWgwmVLe7rCHLgXDMAzDMAzDuDYwHM/r1XA8Cj3E4wjTo0G1l8LxRGC8USnPwvKuP2YwGYZhGIZhGDc88/P4HYshHK9S0RC9hga8Xy5DYKGmZvfauREUfjCD6fpjBpNhGIZhGIZxQ1Muq3EUj+N3Oq0CELW1e1PswYnlMe0eZjAZhmEYhmEYNzTJJIymQEDD8Zwep5UVqOW5XGpQ7TVMKW/3MIPJMAzDMAzDuKFhrlJDA36Xy5qvFI/r+/X1yHHai1gtpt3DDCbDMAzDMAzjhiWfR/idiHqPnB6nUEgNpr0ajieiHqZiET/G9cMMJsMwDMMwDOOGhaF3kYgqzTnzmZJJyHX7/chl2qu43WijiIXlXW/2jcH0+OOPy0te8hKpra2VpqYmefTRR+XMmTO73SzDMAzDMAxjD7M6HK9Y1NpLsZiKPTQ0aDHbvYqF5e0O+8Zg+upXvyrveMc75Nvf/rZ84QtfkEKhIK9//etleXl5t5tmGIZhGIZh7EGWl+GNcbu1WG0yCUnxUAivLy7i9b0cjkdM+GF32KNpbWv53Oc+V/X/E088IU1NTfLMM8/Iq171ql1qlWEYhmEYhrFXcYo5eDz4myF68bjI2Bj+jkY13G0vY7WYdod9YzCtJvX/fKnxTbQfc7mc5HK5S/+nmfFnGIZhGIZh3NCsLkwrIlIoqEfJ7cb7LpdIe/vutHGnWC2m3WHfhOQ5KZfL8mu/9mvywAMPyG233bbh5x5//HGpq6u79NPZ2XkdW2kYhmEYhmHsFqlUdWFaEfUuhUIik5P4u7lZJBzenTbuFBpMhQKEKozrw740mN7xjnfIiy++KP/4j/+46ecee+wxSaVSl35GRkauUwsNwzAMwzCM3cQp9kAxB3qcslkYHYGASGvr7rTvcvB4TClvN9h3IXnvfOc75TOf+Yw8+eST0tHRselnA4GABKgfaRiGYRiGYdwUOJXwmL2Ry0EEIpOB0eH1ivT0IDRvPxEMorbUyopITc1ut+bmYN9cIpVKRd75znfKpz71KfnSl74kvb29u90kwzAMwzAMYw8yO4scpnBYhRLm5lCsNp2GsZRIoDbTfsOU8q4/+8bD9I53vEP+4R/+Qf71X/9VamtrZfL/BZ7W1dVJiHeCYRiGYRiGcVOTSomMj+NvSoVXKjCYZmZgQPn9+0foYTVWi+n6s288TB/+8IcllUrJQw89JK2trZd+PvnJT+520wzDMAzDMIw9wPKyyMWLMJDicXiRRKCMl0qhBlNtrUhXl8qM7zfMw3T92TcepkqlsttNMAzDMAzDMPYo2azI+fMIu4tGkZ9EZmZEJiZE6urgdaqr27VmXjE0mPJ5KOXtV8NvP7FvPEyGYRiGYRiGsR75vMi5cxB7qKkROXBAlfGKRZELFyD60NAgst+rzHi9kEoXMS/T9cIMJsMwDMMwDGPfUizCWMrn4X3p769Wvhsfh4cpGBQ5dAgGx37HwvKuL2YwGYZhGIZhGPuWoSEYDj6fyMGDaw2iF19ETlNnp0qM73co/GAG0/XBDCbDMAzDMAxjX5LJQMhBBJ4lFnUlQ0Mi8/PI8zl27Lo375rBMqNmMF0fzGAyDMMwDMMw9iWUD4/HUXPJSaEgcuIE/u7vV6/MjQANw0Jhd9txs2AGk2EYhmEYhrHvyGQgFS4i0tq69v2hIZGFBRhKhw9f37Zdayj6kM/vbjtuFsxgMgzDMAzDMPYd9C41NKgIApmfh8EkItLdDZnxGwl6mIpF5GcZ1xYzmAzDMAzDMIx9xfIyvEsu11rv0vy8yOAgcpvicZGOjt1o4bXF68WxVyowmoxrixlMhmEYhmEYxr5iYgK/43EVQBARmZ4WGRiAGILfL9LUBA/UjYbLZWF51xMzmAzDMAzDMIx9w0bepYkJkZER/O31irS1idTXq2Fxo8HjMuGHa48ZTIZhGIZhGMa+wamMR+/S6Ki+3tysOT6Njde/fdcLHqN5mK49N0CtY8MwDMMwDONmYHlZJJ2u9i6Nj4tMTeHvzk78LpUgBFFXtzvtvB6Yh+n6YR4mwzAMwzAMY1/gVMYLBCB6MDOD17q6RBIJ5DGJIH/pRsZymK4fZjAZhmEYhmEYe55sFt4lEZGWFvxOpaAS5/Mh/C6VEsnlkMN0I4o9OLHitdcPM5gMwzAMwzCMPQ89R/X1mrs0N4ffDQ0I02NoXmOjiPsGn+VaSN714wa/lAzDMAzDMIz9TqmkxhFD7YpFeJREYDBlMiJLSzCcbvRwPBETfbiemMFkGIZhGIZh7GlmZ0XKZZFQSKS2Fq/NzyOHKRyGwAO9S7HYjSsl7oTHWC7DoDSuHWYwGYZhGIZhGHuWSmV9IQdnOF6hILKwgP+bm69v+3YLtxu5WiLmZbrWmMFkGIZhGIZh7FlSKRgEXi9qL4mIrKwgBM/lwmvT0zCsIhF4nG4WLI/p+mAGk2EYhmEYhrFnoXfJKeRA71JdHV6bncX/N4t3iZi0+PXBDCbDMAzDMAxjT7KyIrK4CE9SIoHXKhXkL4kgHG9uDgIQgcCNXah2PUxa/PpgBpNhGIZhGIaxJ3FKidM4SKdhIHi9EICYmMDrTU0wrG4mLCTv+mAGk2EYhmEYhrHnKBbVk+QUe+Br8TiU8QoFGFONjde/jbuNSYtfH8xgMgzDMAzDMPYclBIPhyHmIAL57GQSf0ciIpOT+Luz88YvVLse5mG6PtyEl5ZhGIZhGIaxl6lURGZm8LfTu7SwACMqGNQ6TLW1CNm7GTEP0/XBDCbDMAzDMAxjT7GwACPA50MhWkJ1vEAAniaXC96lmxV6mIpFGI/GtcEMJsMwDMMwDGNPMTWF34mEhtplsyJLSzAMlpf1/VBod9q4F/B6VejCwvKuHWYwGYZhGIZhGHuGxUUUpXW7VUpcRGstlUrwqHi9Im1tu9PGvYSF5V17zGAyDMMwDMMw9gwUcmhshFEkAq8S6y3RMGhrE/F4dqeNewkTfrj2mMFkGIZhGIZh7AlWVlBnSaRa7CGVgrGUTCIELxy+OWXE18M8TNceM5gMwzAMwzCMPQFzl2IxCDuQ2VkYTOUycnY6Om6+IrUbYR6ma48ZTIZhGIZhGMauUyhoUdrm5urXUyl4l+rq4F2qrd2VJu5JzMN07TGDyTAMwzAMwxCR3Z10T08jVykSEamp0dfn5vB6LgevkzNUzzAP0/XAu9sNMAzDMAzDMHaXYlHkwgXIdnd3X//8oFJJC9W2tFS/NzuLdtXUQATCWZfJMA/T9cA8TIZhGIZhGDcx2azIqVMwSkRERkevv7didhZGUzCIsDuyuAjPUiolEo3CkHPb7LUK8zBde+ySMwzDMAzDuElJp0VOn4Z3IhBAflCpJDIycv3aUKkgHE+kOndJBIZULgf58NV1mQxAg6lSgafQuPqYwWQYhmEYhnETMjMjcv48DKRIROTIEYTjiYgsLKi897UmnYbB5vWKxOP6eqkEoYeFBZH6enieGH5mKC6XGk0WlndtMIPJMAzDMAzjJqJSERkexk+lItLQIHLoEAyWcFhFFYaHIeN9rWHuUkNDdbjd/Dw8Jtksai+Z2MPGWFjetcUMJsMwDMMwjJuEXA4heDRS2tpEenqqaxq1tWECnsuJTE5e2/bk88hPElkrNDE7i/dqaxEuGI1e27bsZ0z44dpiBtMukc9rcqVhGIZhGMa1Zn4e4g6ZDLxJ/f0ira1rP+fxiHR14e/JSXh4tiKbhYGz0wn73Bx+19ZC8IEsLqKdqRRC8cy7tDnmYbq2mKz4LpDPi7zwAlZz7rrLKlUbhmEYhnHtKJch4jA7i/8jEZG+Pp1krwdzhlIphOYdOlT9fqWChd9UCj80qkIhkaNHt9euSgVtYo2lkycRkudyiQwN4b1CAcZdQ8OOD/umwnKYri1mMO0Cfj8GhHIZA4RzRcUwDMMwDONqUamInDunUS2trfjZzmJtV5fIiRPw9jz7rH7H5cIcplLRz/K9lRX1Cm0FxR5mZxGOx21ks1DNm56GCEQmY1LiW8GQPPMwXRvs8tslQiH8XlnZ3XYYhmEYhnHjMjEBY8njgZeorW37kS1+v0h7O/6uVGAklctQr6tU1PPT1ydyxx0qCT4xsb3tz8wgTLBcRpu6uhAmGA5jW01N8Jy43fByGRtjHqZri3mYdolgUGR5eXtxwYZhGIZhGDtlcVGNl+5u5AntlKYmeHmoluf0Kvn91cZXUxO8QsvL8B5tJtKQz4uMjYlMTcHg6uhAjaVsVr1Xvb0wyrxeeKF8Phh8xlrMw3RtMYNpl2AYnhlMhmEYhmFcLXI5eID8fpGBAbzW2CgSi13+Nr3bnC36fNjX9DTEIjYzmEZH8RMOw4tF7xRV+UolzJUoPjE8DOPP6zUBiPWgh6lUgsFpIYxXFzOYdgkLyTMMwzAM42pSKkEyvFiElycUgkHS2Xn92tDcjFC7xUWEAkYiaz+Tz4s89xy8SB0dahTl8wjRW1mBN8zthnfL48ExjY9DvGJ1gVsDfeTx4BrI5y0//mpj9ucu4fQwOd3bhmEYhmEYl8PcHAyLhQV4ZAYHYcBcT2+D36+KduvVcCoURJ5/HkZRKFStFjw1hTlRsYj36uthBIhAqIKepcFBW3BeD5MWv3aYwbRLMO63UrEEPcMwDMMwrpyZGYTk5XLwwtTVwXCamrq+7Whpwe9UCgp3ZGkJdaAmJmAI3XmnTvKLReQplcsaAri6kG1nJ46pUtm+sMTNhAk/XDvMYNolXC7LYzIMwzAM4+qQTsPrMjEB8YQ77hA5cADGxeioyPnzKtxwrQkENGSOXqbpaZGzZ2FE5XIQoaACH98vl9W75PevL1LB7yws2PxpNSb8cO0wg2kXsTwmwzAMwzCuBjMz+AkGYbD098Ng6upCSF4qJXLx4vVLA6CXaWEBxtrICDwf6TTU71pa4BGZnYUhRY/RRt4lwlA9ETXGisXLm0tVKuizkye1qO9+xjxM1w4TfdhFzMNkGIZhGMaVks/D4Jibg0R3d7dOnhMJGBnnzsFoGh7G+9caGjbJJPZbLsPz0dKitZyOH6824GpqtMAu86DWo7kZkuQzM9h2sYjXOzu3r6CXTGIbnIMND0OgYj+LJZiH6dphBtMuYgaTYRiGYRhXytQUFORqaiCOQA8MiUTg1blwAZ4Uvx+fu9a0tsKjRNEJtxs5TT4fXheBYRWPQ/Z8bg7qftGoTv6dlEowcubm9LOlknqzRkfRBzU1G7dpeRmfo2Hm9WJfmQzEJA4f3n5h370G+yyX29123IhYSN4uYiF5hmEYhmFsRaUCme715gvlMkLK8nl4kyjRvZr6en1vfBwGx+WSycDocAo6rEc4LHLbbTCGikUsELvd+O3ziRw9ip+WFoQRsk3reZfSaRznzAyOuaUFAhDhsMgtt2AflQrCDulxWs3MDGTXl5bQjtZWtO/AAYhQLC8jl2q/woV4M5iuPvvKYHryySflh37oh6StrU1cLpf8y7/8y2436YoIBLCKUS5rXO+NEENrGIZhGMaVUyrBe/Tii8jzOXkSxWidOSrDwzAEfD6R229XGe71SCTUGzM0pF6e7bKyAi/VqVNo15kzMOQ2I5VS9b5SSUP0CoXqNiwu4rg8nmoPWamEYzx3Du8HAiIHD4rcf7/IoUPwRs3PI8wwEMBnBgfXtiOdRh6VCAyy224TaWvD/vx+1IMSgTG5Xw0OKjBzXmlcPfaVwbS8vCx33HGHfOhDH9rtplwVXC7c3CIYKM6fx+Cx1eBjGIZhGMaNSy6Hyf33vgdPDg0JERgHJ05gYl8oIA9IBCIPdXVbb7u9HSFwlYqG6G1FNgvPzcmTMHhEMH8plzU3ajVLS9j+0JCKMlDZrqkJ311exvfPnFEjp75eF5EpyDAzg/cSCXikolH8T+NvZgbH09eHuVUqVV0DKpdTwYuGBpGeHs3xIo2NUOUrl9Hm/YhzXmnpHleXfZXD9Mgjj8gjjzyy2824qgSDuKiHhzXxcXZ2fSlNwzAMwzBuXJaW4LmhUSKC8P2mJhg52SwMqaUliDxcvIhF1kAA3qXt0tMDIyadhnEwO4twvXC4+nPpNELUnAZRLAbPjN8Pb1cyCcOopwfvzc/jOwzXK5fx/cVF7DORQPvDYRhRrBk1MYFtdnWtDRcMBOBBWj03YkheJoN9trXh+0NDMCgjEfTf+fPwVNXUbByyKIJ9nDyJts7MoK37Dc4rs1k1LI0rZ18ZTDsll8tJzuFXTe/U93wdCIUwUM3OVktwdnaqtKZhGIZhGLtHuQzDYGYGk3OXCzkw/AkE8NxeT6hgKyoVPPenpqpzgqJRqME5J73hMEQJkkl4nsbG8Pqtt+5s3y4XPFLT0zBUlpcRZhePw6golzEvcYam1dfDIGH+tQg8OoODMJJOn4bHKxLBe243vDnz8zi+UgnHMjWFv0VgAEWj2MbYGLYdjaJPYjFM/sNhzI/cG8REtbTAcJyexncaG2HwzM/jdb9fc6YOHNh4OyI4j+3tMEpHR2GQXc453U1MUOzacENPyR9//HF53/vet9vN2JRgECsp2ayquiwvVxtQhmEYhmFcf3I5GElzc2uFBDjpF4GnpFDYucLa8jIm9cw3cbthtDQ3by5vXV+POcP0NCb1PT3b3ydxubCfeBzGwfy8yLPP4lhqa5HT4/HA6EkktD35PPa7sKDhbR6PyNe+hu1Eo1Dka2yEB+r8eRiCfj+O1+/HZ1pasK9kEtuqrUVuUmMjtlcoYJ+h0OZGDg2rbBbeoWBQja7xcRxnIgFjaXUY3nokEmjP0hKif/r7d963u4kZTNeGG9pgeuyxx+Td7373pf/T6bR0dnbuYovW4vXixqRaS7GIAWVmxgwmwzAMw9gNCgV4GRYW9DW/H5P5WAz/l8taT2hgAM/uycnty3Uzf6dUwkQ+kcDPdqNLlpZgLNELc7n4fDBwXC4YbyIwirxehPnRWFlawvGNj8MAyuVgUAwPawHaQgF/DwzAeJqawg+FHDwezG2am2HQZDLoZxpS9D7RCEql8NPXp/2+HgcOYH/ptIajJZNoU00NjLrNpMaduFwamsdQwv2UJmEG07XhhjaYAoGABJj9tkdJpTBo+Hy4md3u6mrYFn9qGIZhGNePuTk8h+lBqquDoVRXt7H3qKsLRsLEBJ7bW03OncZSJALPymZelPVglsF2hB5EsK9MBvvmT7mM/KiGBhgYvb0wDpaWsIA7MwPD6cUXYXxks5iz1NTASJudxXGfPauernBYlfGGh/F/PI6f9nZ4rtiPjY3wbLnd6AevF99lLaZoFJ8dHka7NjImg0F4gkolfD+Z1HDCmhrseycEgzBep6dhiN1yy86+v5vQYCoU0B+bqSYa2+eGNpj2OsUiBmafD4MG3eANDbhJZ2bMYDIMwzCM60E+j4k5BQ7CYRgAzpydjYjH8b35eRgQt9yy8UT1ahhLItrOreYJlQpEEDaquzQxIfL88xr+Rk/awADC7FZWYLS4XDCKmpvxfk0NxB4+9zkYXoUC8rhKJeyTanitrSL33IPfFFwol/GZkRHMgWprYfCMjMD4mp1FXyaT6K/OTvTVgQObH6vHo8ZZdzdeCwRgPO10/by1FX2WyeD3erWh9iIeD/q0UKhO9zCujH1lMC0tLcn58+cv/T8wMCDPP/+8xONx6dpM9mSPMj2tSZC1tbiwa2t1VSOZxAC+3xIODcMwDGM/MT8PY6lUgmHQ1gbDYCf5SF1d8MxQEny9vKKrZSwxZ4qemY2gdDiNK78fE2j+FAoQa5iYQB+0t8NASCaxqMuwtiNHRB54AIYI84tmZjBHOXAAx37oENrj86nXiu3r7q5OM3C70U/z8/i/rQ2vdXdjW7OzyH2ansaxXryIvotEcF62A40netN2YjCVSgg9DIVwTsfGEBJ4OedqNwgGzWC62uwrg+npp5+WV7/61Zf+Z37SW9/6VnniiSd2qVU7p1xGXPSZMzCWOjsxcDDeNBiE4bS4iEGjrW1322sYhmEYNyorK/CmiGi+y2aCCxvh8SCk7cwZeCTq6jDJLhQwYV9awjP9So0lEQ3Hi0Q23ka5DGMpncZnDhxY640qFDTvJxhUxT7OR7JZGFG1tTBuJic1VLFcxv8tLaiN5PHAyGA4Gzl2bH2xhYkJ7C8arTb6KNLQ2IjtnzqFn4UFka9+VeS1r92+t6emRg2mnYTlUVbc54ORmc8jv2q7+Wm7TTCIY9ivBXj3IvvKYHrooYekwmJF+5hKReTpp3EzNjbiBhwcxKBNEgk1mFpbd7bKZRiGYRjG9hgfx++6OhgVV/K8jUTwzJ6YQBjc2NjaSWskgvCznRhLNGQqFXx/q/yl1cZSf78KF1QqMCAWF5GbxLnIsWPIEcpkYCBMTuKzTBdwzlE8Hmy7qQnfpYcokcB7ExP4XDS6vrGUzWqI4EaLwi4X+nJlBQbAM89gW9/4hsjddyMXaiuc6sM7gf1bX4/+HhhAfzQ2bk9pb7cx4Yerz74ymG4kqLzjlOp0Xtj19Ri4CgW40uvrr3cLDcMwDGN3SadVpexa5PQuL2uRWKcYwXYpl+E5KhTgweAkP53GtumNCYUweY9E1oZ2UZGOrxUK8OYwPDCdhgGSz+N/5iQFg5i8O42BfB4LrRcvom3BIMLp2B4aSqUS5hzT0/Cg3H8/ol3Iygo+m07DE0avmFOI4fRptKW1FZ9dWcH+6+s11G4jTxANKsqjb0Z3N4y4u+7CPtNphOsFgzBgNoPbzmTQVuf5LRTweiaDvmhsVKOSIYx1dfiZnsYxTkxsXvj2arG6rTvFDKarjxlMu0ChgMEzl8MAtJ6iicul7uiZGTOYDMMwjN2hWNRQrECg+udaKXClUlpQVQT7p/fmahpOLPza2Lg2DI+y4auV2VZWMGlPp2Eslct4PZmE/DWLws7PY5s1Nev30/Iy9r+4qAVwi0WdB2SzOG56drxeGEgMjfN6dVJNZd2lJUy2RbC95maRF17Q/zs60B6XC59taUEI4uqKK1Slu/NObC+Xw+eXluCRGxrCnGU9OfOhIfRJJLL+3CWTUYNqOyFuHg88f6dPIzxwaEjk+HHMo+LxrQvRer3oVxYFpiz66rpaCwswDn0+NU5pQHV0INRydhZetcsJ2dwuY2MI/zt48PLlzJ0G05UaXwYwg2kXCAaRHJlO68C4nqIJDaZ02sQfDMMwjOvP/DwEDFZPLgnVzTabtHIxcDuTzFRKJ7Qi2G40iteXliCYUFODMK4rNZzovaJXiBSLmLDOzGDi39GBSXI+j9CspaW125qfx2R6dhYeCJcLz/b1jKWVFRgkNAinp/HsDwT0Oc+aQ8GgelIaG7X0SG2tGgMzM2gTVexqavCbeUQrK9h+uYzfBw6oYeXzrfWYzM3hfbcbk3aPB6+trOBnbAxtWFpSuW22s1jEcaVS8Aitvi7oHROBsbPd+lGhEM7D8DAMm1wORXbb2tYae6upqUF7BgZwDmlQulyqDFgo4Fo4f17DHGtrtf00/pJJpFBstwjuTkmlMO8TwXm9XIPJ70fby2Uc8x6vsLMvMINpl/D5NORORG/YlRU1mAKB6oRFM5gMwzCM60E+j4ktczlCIUwYczm8l8vpJHNwEJ4VUizidf4wLMjvxzbq6jARdLnwWXprUik1zJgP09ysC4qTkzBIqDRXX49wre0WehXBd1n/cHgYE8rOTk3sn5yEcUCvkQiMg9FRnXzmcvB0sGjs0BC+PzqKSe7UFIyBhQW839WltY2mprCPXE5/wmF8P5OBcdLUhGN3uRDS1tZW/fxPpTSvKBDQHKD6enwvFKr2Polg3ydPYn9PPw0DIB6Hseuc+BeLOA6R6v02NaHPZmaQ91RXh35rbsY8pb9fPTkM1VtYwE8mg8/U1+P88Ti3k4NESiVsy+1Gn4yP4+eb3xT54R/e3BgPBHCuPR60t1zG9ZpIqEFUqcBYSqfhkWtsXNu+9nYNbTxxAu9vFRK4EwoF3EsklUJbL1cYJBBQY9kMpivHDKZdoFTCgDw7ixtQBDc7lWqcBAK4OfP5699OwzAM4+ZjehpehHJ5c4ntpSXUzFlYgBEQi2FiSiPLicuF59j0NH48Hjzf6EkiHo8aSk5DyOfDBL2lBfsaG8PEfnhY25bNYjLd2altrVRgtCWT+OEiZTqNbbjdWiy1UFDvQ00N9pXNwpMxP6+hTQcOaE4PQ9MaGvT4czmR731Pw8C++lX0JUMYYzH1yLS0aBFYHj9V9RoasM/JSbzudmPu8OKLaAdzoWIx9MFG9aKY8+N2I7dpZASG0MtehuMLhTCxnp/HT7GI15qadBvLyzi2oSF8p74e35+cxHunT6NfsllcL4ODmON87nMwGEMh/GYIZCyG68frxbHlcjgujwfGV12dTvLzebR/ZUWvxWhU5DvfgeESj0M5bz3DYnERx0tZcV5To6O4Htra1Hg/cABhd0tLOG+33lq9LeaDDQ1he0ND6K/u7qtjkAwNad8Xi7ogsd3CxKsJBtVgutxtGIoZTLuAy4WbzCnduVGCHld3TBry6sLVr2JRH1YW42sYxs1MoYCwpcVF/M/6ORut3kciME6Gh7EqHwzqxD8UwkSUPy6XGi40TmgshUKY0FFe2jkW0+uTz+OnUNA8n8lJ/D8+DiOroQEekFIJE3IaSRReEMGEPBrFMzgcxt9ery5KRqMwYqgKNzGBti0u4plRU4PfHo/If/4nPtfUhDB7etD+5V9wjJykLi/jmZPPY4Lu8WDiHQyizR0d2gaG9fl86oFyQoGKhgZM8OvrNeSvUtG6ScUijoVS39x/IIA2+3w4b8kk+jse1/Ps9SKvyeVC/46NwVArFPD55mYUoo3Hsf/z59HOM2dwrDMz6NtsVs9Ta6vIt7+Nz9MwnZ2FcTIxgeuuWITRMzSE645G0/y8pi7096Ofa2vRphMn4GUKBlEnigqAzLdaXMR3/X70WbGo3jca/M4Qz+Zm7LNUQv+EQtXGUCgkcvgwjpH5ZydP4hw6pdR3yvQ0rhmXC9L0s7N4bWHhygwmERN+uFqYwbQLsLCbiF7IXBlyynaKVK+wGFtTLmOw5eob1Xyc78/OIizC2acuFwb4mhoMxHV1+9uAKhTw43Jtr0q9YRg3N8mkrnBnszAampt1ou1UcXPC/KKpKbx/7BjyXtZbcafimAgmtRQ+2izcfHBQDTgnoRBq/8zPo71uNybmk5M4FgoCVCp4Fhw5gv9ra/EMiMdh6Nx+u+b2cGI9P4/JMAUnWDNpYkJX/E+cwPi6soK+Yijb8ePYhteLSX99vXrXampgvKysYDu3316dh+X3Y+Le2or3mftFA7Fcxmv9/dg2FejyeUzgadSQ+XnNF2puRlsOHhS57z604cQJtLlSQbt6e5GT1NSEOcrEBPqT10ShgM/EYlrTKBiEAfHsswiTPH8e+7nrLmyHOWkvvqh52y95CQyBlRW0e3oar4fDuG5GR3GOmGMVDsMgvf12vVZuuUXbNTYm8t3vos+cYXaE3reBAQ0F7OzENesM8YzF8H5np/b/mTMwTJ1Kfi4Xjq2uDv27uAjjKhC4vLy6lRUNg+zo0PBXGlGXK9pgBtPVxQymXYKTWK6w8cLO56tjVs3DtDMWFlR9Z25Owx/q6zEoTU1pjLzPh/NAtRzmik1Pa6gEZWL3OjMzOG6uwDrLldXUYHCPxfbHsRiGcf0olzX3RkTVweidccLwNZ8PPx4PxtxoFJ/lAtV2copqaraWk04mVUGOeUbct3Mfg4MIz6L3aWUFz8xgEMZFTY16V2ZmVNK6tRXbdrkwYZ+exj6d42d9PfY3M4PP33knvGk+HzwUzc3Y16lTGp7W0SHy+tfjdeYVsTaRy4VnU0PDxgqDLtf6E29GRpRKMPxSKbSLEtgiaFdjI87r8eN4LRjU7dXUoB+WlvT5trKCz9OjEYuhv6JR9M/CAvp+Zga/YzG8FgrhN68dPnu9XmwvnUao3nPPwaAoFFQ44YEHdEHv2DGkJ/T0oMbSuXNoUzSqIWUXLqhqnceDY+rpQVjgt7+NfY2Poz2NjdheS4sqEZ86hWspGNTcLIZ4Tk3psU9M4Hl5xx04rpUVGE1dXWvzlQIBGHLDw/js0JAW8N0u5TIMuUoFBhjDICMRzQlbWro88QczmK4uZjDtEjSYeCF7vXpz5HL6vnmYNofhBMEgBkA+OMJh9bJMTGBAc7nwMKmpwUOuoUEN01xODaa5OZyXwUF8t6UFn92rxkYqheNbjc+nhuDAACZFLDK40YSmVNI49qUlPJC2W1HdMIy9AYuN0nhxCgCUy6p2ls1i/OBzKB7HmMr6PZUKxoRSCX9T9GD18ygaFXnDGzCp5dh54MDmbUwm0Ya6uvWV0ioVXXVvbt44uX56GuNVRwe2ecstON5kEu2kFyOXw8S9pwfvB4OYlI6O4vtOz0wohHEvHseC2vnz2o5SCZP+5WVMvF0uvM9coN5e5L6sJ6fd1qb5PXNzyK3p6MD/hYJKizsXTCMRNS5pCC4uIhfJ2eZoFH1EYY4zZ/Ds6uuDoTcyAsOA51wEhk9fH/p6fh59kcuhT8tlPFdqamAs0BiqqVExD0JlvN5etKFUgveKSnrZrIbHsWZVsQjPFAUqSiVcPw0NKnbAZ+/QEL43MIDz5/fr87qpCduZnVUjiuGMExP4flOTttfvr4668PlwDurqEFqXTOK7d9yB7w4MqPc1k6nOjyMdHTDYcjkcc0/P+tfqetDj6PNVf8/lUpGMhYUrM5iKRQ1FNC4f675dYrXBJIIbuVjEIM/36WEql+2CX83MzFpDYXBQ4689HgxwlI71evEA5EpZOo1BsrFRa4rE43igUekol8NAOTGBEIhrUTjxSuBDTQSDeyKhK7CMP5+dxfEwFn1sDMcaCuEnGMQDen5+7eoq5WtNodEw9gfFIiaeq6WvKRrgnGQTTtYoox0OI4RtdTgzJ7pcjGJNQUpgM2meeTSrjRx6SJy1hcbH1UBpaNBn3PQ0xl+fDxPn1ZRKGJtZBL61Fd4GjwfHfuYMwsA40c9kcAxTUyL33osx8NQp3R6fDw0NasDRs5FMVod5ud06SWdIG2s2tbVtXTexvR19/fzzyL9Zb3x1u9EeZ14Ma1PV1qLvmffEULCaGjV8ikWtn/S1r+F5x7E9HEYbQyGM8U1NWo8pmUQfceynelylgrZ0dmrR22IR28nnYTTMzOD4FxbUwCgUcHwtLerZKZVwjqanRV7xCq0L5fOpl2V+Hn1w5AhC8U6cUJGI7m5cN9ks9h2LoW9aW7EPXmf5PPprZESvk428mrW1MIgvXlQj+OBBXNMTE9gfPU59fdXKgm43+u7MGRjC9fXbq51ZLKp3bj21RxpMyeTlFct1u1X9MZez+eOVYt23S6xXVIw34OrcGkqq2gWvlMsaVkFDc3ERg5nHoysqzEvq7tZYfOcKK1dTnWpAHg8G96YmNZzyeYQJUGr0WhVr3Cnj41qjq6trbey2z4eHSEsLHkDT03iIMZl4dciNiE5eFhawgjcysvVqsWEYu8/KCiZ6+Xx1IVQR9RSJYFxg/RnmS1CQweXShH8nbrcuLG1ETQ2MgdFR/ESjGJvowZiY0PByjwfek3RaczjGxjTPaXwcn2tvXzuuZbMqNOByaZ2kdBr7oDeDz1KPR8PvvF4sMrW3q+HQ0FCdt8oJ/9gYJuKBAJ4hIiqn7vFgkk2paS50zs/rMedyMHpoUFYqWmeHHhiPBx6phgaVMne59HnF3J5cDu2qVHCsPT1o39mz+tm5OT1XpRKeVzTGaBDW1akH5sUX1WvC46tUcHwMhysUcG6YQxUO68Kj243nIpXuQiENe4/HNWTP4xF56UvV2GJ9Sbcb18CxY2vnNhSwGBiA1/DoUYT35fPo40OHsO98HscQjWrI4KFDaCe9eJRhz+X0vDiv41IJn8lk0A/5PK6xM2cQ0tnaiu2xBteZMzCYnUZTJKIKjkNDGlK3Gc4FivWEHSjaQdXErUJY1yMY1OO5nO8bik2/dwl6kDix9/l0YFu9AhgI4DUmjRqY+BcK6Jtbb8UD5uJFDIY0kPhwp7dFpLqORjqN7VBidfWKEKukJxJ4ME1PY7UnnYZxstsyncvLeDiJ4Hg3q9XAeh4NDVog2RmWQ0Ul5+pqNIoV2GRS49oNw9ibcHJJ+er+/uqwOgoHOKWVSbGonuqWlisTimlqQluWljBx7OmBccN8Xa8Xn2lqwmSQYcBzcxjTkkmMO8vLmKiu9upz8YoLRX19GLNGRmBkuVwYp8tlkdtu0/BsfpcKtRMTmMDTEEmn1WPklEUPBLBg1NyMMXZ0VD30DNvLZjXs+dQpTOw7OjBpTibRzmAQn5ufRztpcLW0YPzu61NPC/uEIYmtrdgfPSx33IHn3alTamTNzaGPqQpXU4Nj7OtD3lV3t47tc3PwOlHmfGYGf/f2wgBbWkK/d3RgG42N+I7Phz6am8Pzj3mzVEBcXtaQPMrGNzWpEX7gAK6znh5sd2VF62n19lYb6d3daAcL5XZ04Jo+cwb7mpyE0XL2LNo6N4fr+Nw5VbdbXESfTE+jr+NxnKfmZrSBeVtcFB0YwDVx113o+2wWfdzcjHNw5Ai2n8vhmj50qHrxtLVVjbPh4eraZKspl9W71Ny8/mdYiJiLnYGARpFsl41K1hg7xwymXcLvr/aEOA2m1fHhJvxQTbGolbAZQy6CgTESwSC10eTe7db6F3V1WohvYACD33oGKROOYzGE/HGwZL2P6+1tWl7WB3SphAfSTkIFGbK3VUx0KISHOUMauNplGMbVIZvFRI/hRz09l7coxrpEIriv+/rUKHLmMW3UhvFxrf/S2npZh3IJlwuT3VOnMMkbH9fV9pYWTKg9Hoy9DDNPJPCTzWKsOXsWY5vLBTGHSgXbbGzEuJfPqzobw6cuXFD57PZ2bK+2FvuensZEl4YT84XPnNFnMXO5KhX81NdjItvUhIl2sYi2lcsY+w8dUmW+iQkNWeOC3NISDJShIex/aUlDEWMxLLq1t8MAefppvOf0AlL8iR4CeuQ8HtR4OnVKBQ4OH4YxMj2NsZ2FYRMJtCGfx/6p5HfqFNpBAQSGNqZS6Gf238wMvrewgL4oFGBchMPoa+a2jY9jn6GQiimxL7lwOTSEzzU2qvIewzZPn17r2WTo3YUL2GckgnPS14fzPTeH4+rtxXO5rg4es0IBbejqwncWFtCXrPtUKKD/GC5ID+zKCrY3Pi5y993o08FB9QgyT+7QIbQ3k0Hb+vt1sZL38OnTKkBFNcHVLCxouOJmi5H19TjWF17AtZjP7yxHyoQfrh5mMO0SVPlhPDgHGpH1PUwiJvxA+GChbKwIBgOGZ+zEeOjsRL+mUhiEjxzZOOQkEkFYwPg4BvC5OQzAvb1Xx/OXzW4+sRHBIH36tOYleTw45uVlTA4YVnG1aG3VemGjo1d/+4axF2Ax8eVlnZjtZBV3p/tyelScnDmjIbTbFZkZHVVPM3NMtvouQ+S4uj43hwnmeqF4G8HJt8jaoqkUVDh5Ev/femv12FosijzzDMawmhr11DAsrb9f6+RwHxcvagHOWAxeFoYgnjsHo4Xj4alT2B4LptLgomFDMYhMBueD+S1NTdr/XKisVDAxPnUKfZZK4dgSCbSVoWj04LOGzuAgJuYsZUEPnteLFf+pKexjYQHHyVIYTg9gIIC+zOUwGe/owGcyGbSDeUETE1pT0ONR6W8R9TydP499TE3h/4YGyHvTG/WlL6GdFy9CwU4EhuvEhBbxpbdyeBivl8vYViaD9+JxLXxbX6+hZu3tOMZcDu83NKBdtbUaZsjntvMapMKgc1EzGsVnKOd97hzO2YUL+rxKJPD34cMaShoM4vyeOCHy1FPY/+234/XWVngCJyfx2bNnkb9UW6thlisrkE6vVHCPURp+YABGHNscDmN74+Pop41k83nP0gO3EXV16j2enUVfrxd+vxFmMF09zGDaJSjJynAoEfMwbYdCQd3Y7e36OlV/KDm6XVwuDHZnzuhD5fDhjY0WPrTq6zGAUY2ovX1jt/p2mJrCxMDlwgBLKXTnpK1SwUOCBp7Pp3K1zElqaMD3KUVKl/7lwtXi06d1Vc/5MDaM/QwVwebmdGV/fl4nOkze3ixvZycwN4b74gIP1ekWFjDRSqcxKdxqv86w3K6urQtnlkpa94ar61ztz2R0f1vVfeHqOp9VTHRnrgfrxwSDqmIaCOC45uZgSNFISSbVO7a4iM/U1+u4RaXPwUH1ivT3Y8Wd4WG5nBqLgQDakEziO+Uyxvi+Pnhhzp1DH/v96jGhvLXLpflHKys4BqqQsr6TiOYgNTbimBMJ/Ww+j+MZHNRJqseD50OxWF1CZHERr7GPKhXNK6NhNTaGa9Llwrnr6IAB09GB8/nMM2grvVFNTRirl5erc3YpdNTbi/4Lh0WefFI9K1SyK5chRhEKqQz4nXcivNHnU+U7qt95vXju8HpNpVQkg8fT1ARxh8FBDXdsaIBxRoNraAjfr1TQxlIJr1PYwuPBNcd6WjU1eAYvL+NaSCax7VtuwfUQDmP7DDGNxVQoY35eIyjuuAP3+uQknnXlMr7/pS/hO8Uizu/EBPqwUsE19/DDaHMyiT5xijK0tKAflpfRZhpuhHl7bvfG6o+kWMQ1kE5r+OTCwvbVa3lPM39rr6r97gfMYNol6GHizSmyscFkHiZlfBx9FolUGwI0mC7HOHC78QA5fRoPgIsXsbq02cBCbxNDGRj3TknTnUBjSQQDGiVbOWnjg3R2FgNnsYiBPRZDOwsFtHlsDA/xSKR6NYkrcpe7Yl4s6uobcwO40mcYexlOFBmi5PxxyiuL4D6j+MHysk4KR0cx2W1v33xMWFrCNtZbbFld6ygYxEQpHtf7kqvzw8PY1qlTMACcE6PlZWyDBTbPn9ew3K2MpclJjHGcjFNMqLUV93U4jJX1eBzjLCfCDQ3VhtvcHNpYLutzjGUIjh/HeMbioD09Kg/OsCrmEJVK8I6w6OrMjOY6RSLwSlUqmvvj86kR8M1vqsgBRXpqajAGh0J4ptKQqlRgwB0/jmNhAVaKKdTV6fZXVjDB5bOYin40qijz7XbrhJc1kaJR7GdoCO81NKDti4t6jjs78RMOYwJOA4ttjsfRn11dOK7nn0dBVi4CcoEuFsOYT9W5UAjnPxLBcbMeFMO3l5fVOzQ4iOtlYADtohHt88FQ4SJCPo/r/u67YaTQU5dKoT2U6j58GM9PholdvKhhipGIhuedPQuDlYXj3W68Vy6jTayVmEhoyDvxePB8Y1g4vZWHD+M4vv51Vb1dXFRjqVzGM/IlL8F5zeU07437GxrCfZFM4pjuvRfbm5rC8zSRwHXQ3o73L1zQcaW3F/uZmcF5a2tDe7kQe+oUrueREc3JYv4V79utFniPH8c2gkG9Z4eHt28wUZyDc00a7MbOMYNpl/B49MFKeVUOquWyJk2KbGxI3Www3l+k2rtEiVKRy/em+HzVCaWDgxgMN8PjwaA4O4sBMZ3Gymkshod3OIxzu7CAAZQTNSoKVSoqV0qlvr4+DIjJZPWkjVLB5TIeYn4/BmBud24O2+JxiGjsezqNgZ9G1mpY6NHlqq4DksuhbUwAXljA69PT2OdGOV/Xi9lZ/CQS+6fAsHF9SKUw4XHWitkIyhg7FwDyeS3curiIbVFOmIVHo1FM2vJ5TLqo+tXUhHuU43supyvpIhpGtd71Go9jkkk1rsFBnVjNzop88Ysawu3347V8HhPsxUVMAlmzx+PBa6kUPnf2LMaPUAihSHV1MGT8fngPRkbQzhdfxPaoRMqJb309+mFiAmOx36+17Kam8D3mlopgnLjnHux7YkIT1pNJ9IXLhc/X1KgXobZWjZyRERgX5bKG69GIoNETj8Pw7O5WQ5deqMZGLZnAEObTp9GfNI4ZMdDWpkn4S0vYDhfmXC4YlYWCXietrRqaxgUrn0+VWilsEQxq2BmL546PY7+JBM5FNIprh2F2jY1qlBQKeNbFYuhvCkFMTGib77sPIXRcbMvn8ezx+6uPJRBQz+LkJN5vbMQ13dmpeVsLCyKf/zw+43ZjGxznz55VKfZYDAZLPI7flQrep8fq7rtxzig+kUzi3LG239AQftOIoIJrNquy6QyNLBbR54OD2E6hAM/Q7Cyei5EIXmOeUjSKe4gqgXV16K+vfhXvd3Vhm+wPpkHMzOBc1tZiP6EQ7vVEAt9vbcW5ff55eCoPH8a2GKLIMEQR7Le3F5+bnUU/jI1pPSkRXYiIRtefuwwOok9ravR8J5PY3+23b181ORjUvjWD6fIxg2kXYcw3DSZKnm5Wi4kJjTcjTOitq8MASVhfgmEfl0sopAml8/PYFleMNqOxEe25eBHncmoKg9r8vOZa1dTgM8728SEuggHZ7cZDpL8fDwqG3jHZuLERg/GhQ9XbGh9XIQcqG7GeCcUhMhm0r6EB73N1nQ/qzXC78aA4cADbonHI8MXdGIBZSFBEw5K2U//EuDFgaC4XkWh8uFxaQJLEYvjhQhR/u1yY7K13/fr9quS2sKChRJwsMqckEMDfVCorlzHRnJnBd/1+lWRmfbitFnUoizw+jm2NjGAseeEF7KtYRJsuXsT+u7owqUsmYajV1WH/ySTud4rVME+krQ0TxRdewDhz8CC+MzamIWKZDDzo6TTacfq0hs01N+N79fUwkoaHNUfEqcSWzWLizeeYy4XVcno6aNjU1uI7lE0+fBjtS6cxuWxsxE8ohP7gfe7xYKKfSOBY5uc1jyYQQDt9PvQVw9s4Ma6tVUOURVP9fvxkMlpI1OVC/8bj8HiFQmgfa/ylUhBs+OIXcZ7r67U4uAjaSznnQgHHw7C+xkaV0+7uxsSYIVweD64VFsINhzHeMk+rs1MFEFwu5NZ4PPp+Q4OGovn9aD9DAJ99Fvs4c0a9h/X1eO4sLyO/p6YG34nHcS194QvY19NPo4+Zc0ajoFCAETE+jmu0u1ulz3mf0tBmrhENyDvvxDl89lktD8Lrvr1dz31HB87FwACuOxooMzP4/eCDWLBkUd9YTA1Yhhoyt45Gc7ms9wQXKZ99Fufk8GGc31BIPXfNzXgOvviiLsq0tKhw1+oCzNz2+DjGDrcb+6GsP4226Wnch85Fm8VFFTyhYTozo7nTU1PVC8eb4TSYjMvHDKZdZL1kPJ9vrcHEUABWWL8ZDaZMRmPeVw8SVxKOt5poFIMyi9VyFW4rgkEMeOfPY6DnxINhB07ZVQ7YuRwG+pYWPEBYZPfCBfXeJBIqE9vQgFAEp1eHoQH0+JTLGGC58hQM4jtcKZ6bUy+dExpfLL7ICWBDAwZ8XnNcrRwfx7bPncP2r+c1mcnoCl00qqvKXGlsb682qI0bBy5IcHK8ER4P7lsaLVcCE/EvXIBxkEzinuWEPhTCJOrIEfXKLi4it2RxEROd9vad3ScuF75TLmNy9uKLqmp59CgMhHgcE7TubtynzAVhIVWPB21NpTA2NjRg0j8/D0npfB6LNn4/Jrsi2Cbzq557Dr/pqeM2Wcj6X/4Fk263G/fhS16CcCZud3AQ7WNSP2swUZmto0NDGBcXMRnls66lBfsKBjHp9vuxvclJHMvdd8Mr5vejLygsQIlrEbSBhnE2i30eO4b90jPH8ZjjGhUGmVvs8+H46A176UvRXpdL5cpbW7UeE71okYh686h2R48RjZd4HK/T63/woD4r5udhoNbUwDhKpfDdhgac7+ZmzcmZntbjZI0k5swEg9jv7Cz2Qc+Vz4f+oDx4W5vWZJqexr1zyy04LnoIT57E9hsb1WvX2Ij74uJFbJs5r62t6OeLF9Vg7etDHy4uYr/M31tZwfl+1atgkEUialhykZTG7JEjeP9738M2aDRQcnxlReQb31BxkI4ODWPnNcb+r1Q0V/j227FPhnomk+j7o0dxzU5OYr8TE7q/wUE8/yg5vhGtrbi+Jib0euvvx5hRqeAYlpfRPhpMhQLCAnm93HuvljSJRtHGCxd2ZjCJmMF0pZjBtIus9jCJYFBgsTgnzmrNN2MtJq7KxWLVakyMqRa5enWRGht1RWx4GH2/Vb4OPTgUXmhrw2QtHNaVSE46SHs7fljFvlLBALy4qN6bQEDVlRKJted+ZERDKaLR6gkdcbnQnmhUZdG9XvzPn+1O5Do68GBh3kNLi4YmXA/J8UIBfcOVwf5+XdWndO+ZM2psxmLbVxMy9iaVitZMc9bHceYx8r7i5IqT0asFJ4oMa3O5MJlcWVFvxcKCqtu98ALe48JDLodFmMbG6gKpWx13qYRJI/NQjh7Ftd7VpSIPPp+GXNFYo/eExT9TKfTH88/DoEqlsNCSSqlaGZXF/H6tkRONos2HDmFcO3kSx3bihBoUiQQ+MzyM93gumGBfKOC8hcOafJ9IYJvt7bifRdTTMTWl4dDM1xDBMR04gIl3by+MipkZTBypHHb4MI5/ZEQnp7W1GirFsKbBQfW8j4xgQsm6fixy7vNhPGHOVTQKD1k4rEZWsagT9HAY32fIGAV4mppw3Ky51NCAfj95Umvh0dt5+LDII49gP9wXDZ++PhwjvVHPP69eRBYZZ90jEQ2rZt+J4Hj9fhi309O4luipZL2fujoYSzU12GY8LvKtb6HP6Glh/ldzM/adz+MauO8+zVs7cwb9QuO/uRmvj43hHFOtkOGY2ayq9h06pIt8LArMcMTeXpzPZ59FP1JGXgTXb7mMdh86hDZNTMD4r6nBZ1/6UpxzhrlTTIGFftmPlLzP5XDuMxm0Ox7HuRgeRh8mk1uLIPX04HwWCrgOamo0GqJUwj6dkR4nT6KfAwGIZVDJUAT3zvi4euy2E+FhBtPVwQymXWS9i3gz4YelpZs3j4mDyWrPQSaDgY01Kq4Uhuy0takE6sWLeJBtVMxxelpXdQMBDN719Top4kOzXMbgnErhXCYS+nATweep4rS8jN9MSPZ6164mLSxgcsA6US4XBvHl5fVDN5lInc9ffuii240H1unTeHDQWB0Y0Nypa0W5jMlVoaATCOZwMSF3YgKGHBOeR0YwoWBYh3F9oGoj8wOoyMYE9VBIFdTWo1TCvcLJPid8IpicNDdf34WjpSVcW1TR8ngwYXzpSzGJSqUwBpw8qcd2yy0qAc1cIqpbUs3T+cPwNBGMJefP62Q2EtGQQIYAsyjrhQuYXDEHhPmvDNPj4tvgIH4nk/rMobR5MIixbnERYw4LyC4vY7KYTOoE+6mnNJ/np38ak9z/+A+siHMCu7KidZ0YwhcMYpwaG1Mv+NgYxrl0WvOX2tpUmnpkBK8x9PDgQUyER0bU65HNYh/9/RqCGAqh/5JJ9ZjX1KBdExM4nx4P/qcHh0aV349xmEZjUxPaz+fB9LSeIxZJDQRgLOTzOAdcsOno0Bw554JeLAZvyQsv4Lqpq1OBiPZ2kZe/HDk6VGIVUUVU5rLS88+Q72RSjR72PYv7Mly9tVVDv5h3xkK6DGNkMfhKBUbZ0BDOd1sb9kOBjJ4ezddiKHgmA8OAnld67Hivulz4XCCgBeMLBewrEtE6TUNDaKfXi/4eGFDvCmW8uXi3tKRGeiqlwh70fGYyOJeTkzgPQ0P6e2EB2794Efey2417PJtFG7NZ3S+N/uFhPAMbGmCwDw9vbTBlMriGRkfV0CQM42OJgXIZ51gE4YpcrA2HVUWXbRscxHW0Fc7FeVPKu3zMYNpFeBGvDskTMWnx1dALtzpGmBP2aPTKB4GFBazcpdNapT2d1poZt9yi+VNckeKgK4IHbk/Pxp4Wt1tlijfC41HxiWQSvzs7MUA7t0vVLREVgRDRVcFkcn3VLJfryiWSGU9OpaxcTuO56+u1VkkgoHH0V4PBQZWZ7e9f288sVtjWpoIQVHyantbQE3r9pqexLZ5Te4hcOZS+Xy/sczW8FnkeXS78VCqq6kV8PkxKmpqunsT3dmH4C/Nj+vo0NJqepqkpGAz0FtxyCyad9HJlsyqBXSjgHlkPCiksL2MsYsHoYFBllpl76PHgeo5EVO6Y3ohiUeWHmYPIiR9D6goFHAtzMChQQ4ECEbTz29/GJHZhQXOzgkGR17wGbT1+HG07dgyfYS4HQ4VZuJShdxS8yGSqIyZY683trpbc5r3qcmE8PHcOE9y5ORx7Z6eG2lGUYnZWc9dSKeyDUugMX3O5cCzZLEKecjldhGKtoJ4enQwzwmN2VutXpVLoz1tuwQSfxV0nJ9WYaW9fOwYWizgfLFzPhYFz51SCvLZWJcF5jonPB4OZBoOI9iNDv0VUlENEvUjt7XitpQV99/TTOJannsIz4557cK4odDI6imM/dgx94fXieFkwmAIgmUx1ceCaGhw3wx/r6rQtiQSuIRoGLIBLo4LzH0YQTE/j98AA+mV6Gtuur0ebKPDA5x6N/MVFDZNk7i6N0EAA1z8L287MaEkPhr6fO4ffo6NqNIvoHIELFQx73YiFBRzvsWNop9PACoVUbTGbVVEUGqWE4f2ZDO7ngQH8bMdgYmgmcwdXz6OM7WEG0y7CQZQSpx6PTnyteK1SKulxr37wMFTvSsLxSiVMTKamdPVuelpX1M6f1+RRenLCYTzoWCy3o6PaW3QleL0wkD77WQygMzMa78xJ/eSkrh46w+/q6zc3mK4WiYR6ABhOMDSEBz09p8vLmHjEYhjgneeOyoZLS1qLYqOwQCpLUW3wwIHNJ81eL/qEeSYMPeJPqYRzx21Q4pbhiZwUGDujUoFRy5oxlMHlD8NbGIbECcJGMESLqpNXE+YQbjVxKJVw/xeL+CwnMKvzopJJLZra0aHFTinnHwzi9fZ2TPrLZRxbqaQ/VDh75hlISc/OqvHDUL6aGtwznNAuLeF+oEBDLofXh4erhQ2YgJ9Mou8DAZXI5ueGh/GTSmH7tbWYELLUAgvMtraK3H8/zvOLL+L4V1bQvmPHdEJ2+DCO9dQpeJIYNhaJqOR2OIxJazCIbWWzOnmmUAdDohcXRT73OfSxz6f1sSjc8N3v4vjyeYzddXXqjaOyHOsfRiIqqc2czLo6/DAK4K671oZi0zvHsL6mJkxYH320egGnq0uNiVOndJ+1tWjr6CjOayyGNhYK6LfJSZzD4WGVf08k1MMajeJ/hnUyxM3j0TwaKs4VCio2xON14nLhPLzsZRCtoJId5eE5J6mp0Xayv8NhHNfysnr5IxEcdyajXlYW7Z2dxWtHjqjRREOT/cRQVy7GZbMqeBCJaE6gz4ftuVw4RwytO3MGz83Dh6uL9UYi8Eo2NaGvZmfxrDp8GMZhdzc8lePj6N9QSPOWDx7Edunp4rN2bAzbi8VwvUxMbDwHqVR0UbWjQ73IzvMQDquiIT3BztxhQsO/qQmfm5vDtrdTF5Gy+8vLZjBdLjYt2EUCAQwexSIGN6fBZB4mhd4lv7/6ocRq7SKXbzAtL+uK0+QkBh6XS1diSiVMcoaHYVTV1anQANvkDDm4GpTL2F9rKwbiRAIDPOtQcKVVBIM9V18Z6iOieQxXO6+IeQlM7mWo5MKCJpzfcQceOOm0rlhzUA8E0DZWhidUPGpq0tBKxowzaZzHu5PQSxpBuRza9uKLKjVNgziVUqWzchmTiKNHtyf2cbVgjk48rtfgfmK1sbSd4sbMW2CejzMPiWF714LFRdzzTKhmzZvVVCqqfOnzwTBxuXA9JpO4D4JBXDvf+x6Op6cHn2HezsmTuK4rFc3rOHkS48bRo5iwcexioveTT2Is8ng0jJEhRvX1+E4igfGoVMK9MzKC/mLOjd+PdrW2qgz60hImfIUC3mNo7sqKPlfa2tAuTjgrFUyMmc9x8KDIQw+hHfE4QnNTKfRNIoH93nIL+mVgQBcpRLTW0PKyGmV1dZi8UU2U+WpckAqH1Uv94ovwurndSNI/dgyT39OnMZlmLlV/vxYXT6UQVjY/jz6MxzHG8P5ifbtyGeeGhhhDz2gwpVKYULNPRkbwen8/Cpiuvn5qazEhZ1mGUqm6L0RU0IJqccWi1oyamNAQb9bDolfGCQ2M1ftePSnfDK9XhUkiEVV+Y62ue+7BNR8IqDHxne/g2KjmV6ngOLq7NX+wXMaxs1jxygrGiL4+3XcgACPq4kVVu6UKIGXuSyVckwcOYHvhMN5LJjXPh/2Xz6v09/Q0rov2dpzH5mac28FBrWHEmlrHj6v3N5FQ4ysUUjGJCxfQN52d2Bevp/l5LZq7Xq5zOo1j8Pk2fnZxIWRpSaXqa2r0vnN+bmYGfdvSguvk/HmExW6F02C6loupNzJmMO0CpRIGecZR0y0vsnFI3s3sYeKkfPUEihNf1vHYjHQan3GurExOqgoPB7+aGgzgk5MqVUtJ7akpDMJHjmBiUCppbZCrdZy5nE483W48rFjMkmFKq+Xlz55VQ4bhaKzZcbUGRk4SWKCPK/89PXiQsCBhKKSruE1NavTRaHLC3IxcDvcCPxMOqwwwiUbxgNjJRMAJQ44SCfV+cKLKmHc+3EdGNFynu/vay6YzjI0y8qyxsp1VQ6pHsmgjJ8hXQqGAc8l4dyovcjLDsFLec5djLImo8tX1olJRqW4yP4/7qq+vemygscTaSp2duPZnZ3WsFkHfPPMM3mtoUEOHRqCTc+cwucnl8JlTp0S+8hVM/m+/Hff4d76D64Cr+PQCsHYbRRiammCY/Od/ou+p+JbJoL01NSpHnU5jsYXhSByvYjE1EDhBE9Hirwx/pXe7rw8TV4bWud1YuadnjaFQKyvqVcrl0I6ZGXy+UMA1zgkmi6wGgxoKJYLzVCiowADDjv1+rTNFkQZGGQSD6klIpdCfo6MqctPVhb5jWKKI5mhFo9hmLodjO3lS60hVKhr2xnPvcqG9rGe1HuEwJtuVCvqS9Yb4rHHeq857obcXk/zpaRxfPH5tBXVGRtAft92mnle3G/sdGEAbb70V56JSQS2j2VnNZ6WM+mqvhdNrX1+P5xRzhpzRGAxDHx2tzg9rasL/586pENb0NM5zV5ee44MH0b7lZZznuTkVb/D70X6GBXZ04Bo5cwbvP/OMipwwP8hZRJkKiJTiX1zEtii0QfEGjtvrGUx87m22EMa+GxhAO2lknzqF+4/v8x7NZHA/Tkzg2XHPPVuL3PC7XOw1do4ZTLuA262hKHyI0BBy1lxyeggYL1+p3Hy1mDbKX2IfOl8vFjEws+ZIba3WLGBNjcZGvMa6IoytdhaFdXpS3G5MTph78N3vIiTFOegXi7oqy7Cu9QawYhH7XlnBZzgZZwFb1mbiyqGzUC/zhDgAd3aiTZTiXVnBAyQYVAnTI0e0ZgknVKWSFnzcznXEwozOSQPDLDweTWru7ES+w8WL+J8hM6yjQk8RV0Cdk+VMBsc9P68GMiclzc1XFkLgFOWIRuEBoyyuiEr+ejzo44sXcS78fvQZw/uuldoeVaZ4rzMEKhRav7bU8rIal84FFIoL9PVd3viwtKSqT5tJdnOiUlurtU52aixdb1YXj2UewdAQ3jt9WpW8RKoLZHq9+C7x+TBhovdlYQHn7uBBTLhYh4kSyiKYlM7NacHSYBB9zaTxp5/WENZwGG2jGpvXq4n99GC98AI8J6wxQ4OKRktXFz7v9+M7t92GCeC5c7j/Ozrw2YMHVc2NIhPM8YnFcC0dPIh2T06qqh6PK5fD/d/cjO+NjaFPOKlsaUGfx+NoIwu+5nLYzvnzOO5QCJPexka0u7lZ6/UUi+iXSETk1a/G53M5bLexEWNcXZ2GNI6O6vjOUMijR7UNTmjsHDyoOU4U7xgcxPjV2Yl9su7WyorKlB84sPW153KpkedM9t8Mv3+t5+haMD2NY/N40P/pNI67XMZzjs8pLjIsLODchsPw8PX1bW9cjERwPCMjKnzg9La4XOjnmhr13rFwMNvU1qZiMMzNo7pgfz+OhaH1Xq+WBKFHkaIpLEL71a/iemZ+FZ9jtbW4dmiIcywMhzFe0OtbW4trpqFBC9JSap1QpVJk83GRxsyFCxhfOCfJ52HcMZfOmYvEEEnm/nV1bX4OnLmC1yL65GbADKZdgAmnXm91UrCITt6Yt+OsxeTzaeLpzWgwrfYwsc+cHoCFBf18Ngv5W3o+uNra06PfZU0JihQ0NKgcaiKB/2dnkRBL1aGpKUxYDh3CIDY7q4mjIip/2thYXcmcD3oyNYUH9eIiJuis6xIOa8E+GkOURGVCfTCI9rFgpM+HiRcn0iz+RynzcBgDPMM/WVuDifQbhRRyEsEJfU+PFt/jhHJqChNOPlhKJe1zhi643TqxWi8sgfVk2tt1VZlFFYtFlVauqdFCl1vB0EYanbEY9sEHRWfn2u80NKiMbDqN7zCJnGp7V1t0YGoKv5ubdVWVCdcXLqDNlLpnjglhv4bDON9LS5js9fZuLYVPrxsn6s7yBkx+5qSEP0yMZ80wegH3srHEwrPlshYJDQRwDAcOoN8WFnDPsubZ/LxOvumhaG7G9U/PAItONjaqahf7kbkgzOGgahhloQsFLTA7N6c5GbW1aFs4jJ9oVD1b7e2YmM3NYVxjqGBfn070Wlvh9eCzgt7BchntPHgQ22XhUaq6TUzg3urvx74iERjq3d34PTCgOSQsmcDcmWwW49LSkgrRUHVvdBTbbWpCXzP8i3WyurpUmWxmRpVgm5uxaj47i30WClrQN5WCoZVKwRBiSOXcHO6PdBpt6uvT4q5beTJp1Bw7hnGhthbG5cQEjiUexzbHxtTj2N9//QVIrhaVSrVHh/kyDQ3oi7Nntbhre7vme+XzOI9tbThnO6GpSceaixexCLl6HhOP45pnrpHPp8+DTEZl4YNBLHwtLuozlRLiKysYAxkaGI/DcOd9SRGg2lqMCy4X7hk+l+JxGOH03FJxkG0bGVERDIbf1tbitZERbIdzku2E44nodURxogMHNH8snUZ/tbZqGDmvcUrMDw9vbTB5vVpom55VY2eYwbRLMBTP59MkaOKsxeQ0EhirezOF5VGiVmStwbTe65zAsSo2J5e1tfqQOH0afcv48aEhrafCCRITh1lYkXWUVlYw4E9MYHBzu1XRKBTCIMSV/9FReFy42uV2VxeyzWS0+jcnry0teJCsXrmcmICRxpXdaFSFC1i8lsXx2GcMAaAHgLkh8bh6suJxPJBqajAgO70Z8/PoGz6gDhzQB0E0ionX00/jGLJZreXS1ITtVirYBmW+y2W06aUv1Torq+HEVESTn+fm1Bild41J6bW1eMCsnhA5PQrOOiAkn8d10NSkBTNFcC4OHMAxMVm/VFLlq8lJDYtySsdfLsznoueByduJhE4apqa0Hg8To6kAFo3qokt9vebcnDuH65d1gTgxXlnRAqerxxFOLhKJ9Q3SchnfCwRwPqn6ls2qpDwFBdxu9YZzzCoWca6u5yRzaQmTfXo2GVrnVBzjPU4PWz6v9WZ4XzU343xcvKiLHxcvqrwz6wlRxrqxEd9JJnGObrkFEsHd3VpThgV4x8d13GH4b0cHJvpDQ7g3WdB8cBD7Z603TqwY0tbbq9ekU0p4ZAT9sLKC7zmNXVJbi/MYiWDRiKIUx4+jHbW12DfD++66SxP8R0ZwPVBMoqdHjQuqlDE31Bma63Lp6nk8rqF6lLduaNAxgLkokYgW+Zyfx4/Pp4tH9EwkEirSsxNiMZEHHlAl0pUVHEskooYFhWz2I/k8rl2GZnGhhnBcOXAA40d7u0qox+M43+stNm2H7m6d71y8CAN49fnhokZ9Peo/8TnCosUi6Ht6jpzS34kEnpMUQ4nHcW1OTmqdMT7HWbyX84j+ftzDVEjs69MC6bwePR4VKpqbQ/8w9J15sFSuYwFi9ulWUBWSNa0iERwD61bRGAyFqnORzp7VecFWMOzUDKbLwwymXcKZ0CuyvsFkwg86CPHBSyhnLaKT+EpFBw7WZurvx2DHhOiaGq2gzdCZuTlVIxLRBwI9Oy0t2DYf3FSue+oprc9ESXF6hyjTurKi0rrBID7LHIczZ3TyUV+PdlI4YXFRJyzj49g3c0h8PjwE6I53Ko3l85iQMIG0txcPBYb70TALhzEYc+Ibj6uCVVOT5heI4CFFWXOqMjHGn4nj4bCuak9MwBih/Dp/lpZ0snrHHTCcVk+eCwVtq1MVsKZG68PwweLMiwqFNKyiVMJDq1TCeW1sVM9BQwNe/9KXNKTwwAE84PgAYTL2xYu6Ui2ildb5Q+OX3gDWcHHm/DC0NpfDtlifqFTCZ5nn0daGc+/xqJeZErsXL+KaYs7XRnlVwSCOgzVqjh/H5CEe33jSyETu2tqN8/GYGD8+Xp2/I6IGtlPeWAT9vvqzIjgeKq1d6/wlhpKysHNtLe45Ko6FQtX3DxPuZ2ZwHVHK+MgRfIdhdkzyptiK1yvyta9pKI7brWpojY0YV172srWLIDScJichGrG8jO/F4xgLcjlcA1Q6o3JaPo8VcdYho/KgsyBuNqtFPylsU6mgLZGI5sxQ8ru+XkUXmNz+wgvYViaD7xw8iPP29NO4Hk6cQJFVJqlTAezoUVwrbDvHE44VVFBjmKHzOlhddoHiMp2dujDgdmvhUIYYs9YX3+/q0sT+y4H5o/RwU7GO5/N65t5dTZJJGN0Myertrc7BqlRwPfK5RVW4qSnNW9tuGN56OBeklpbQlvb29Re8xsbQ3ww1HR1F21jEmdEXIrg+mSs1Pa25sI2NuNaoJnfunOZblUqq6kexi0QC9/nICK7jQgH7HR3FXOLOO7HPZ5/VPE9K1/P+z2Rw/be26oJtPL5133ARh2N7ba2G5odCWLRIJqtzkbgIuBODiXmbxs4xg2mXcOYmiVQbTCb8oDi9SM5JH40lGhAiGASy2eoVzK4uNYQY4sXq8R6PSvf29GjIFeV7a2qq99nejgd/PC7yX/+lSeSBAAa3b31LC/hNTWES3Nqqgz5raszMYCJHtS3KpzK0amSk2rPDBFB6Fvx+DJBzcyrnyuTaQAAD4nPPaY2o225DOw4f1lorlGLt7saEZmEBnw8G8TBgOEBPD7Y7Po62Dg1pgczlZbTn4EGtSTU0pHU5KAMeDlcnx544gX1/61t4KDU3Y3/T01o7qVLROhR33FE9iapUsB3Wv3C5dNXSmdAfDqM/+Foqhb5lfDq9IGfPos8OHMDEjKv1DI8bGtI6K8y9mJ3FdcQCuZdDOo1+FcHxnTu39jMzM7oiePjw1pPA5WWtXcMk7dlZnH/mgjmNvK3i2FmQlUYFV/K9Xv1xu9UgZHy8Mzmek3Mmz9Mz1diICdm1mHxWKqqEVy5rDSEKvzDsijkRqRQWOJ56Cm3MZDB2dHVp7ovbjetiZQXXTGsrzgfr5YioEcDrnvkVq4tOi2hBUU4is1lViWR/0ghdXka/9/aulSam0UOyWRiGVF1juB2FIqgMRqOeda9mZrDQwYkbyyvQkKKh1dmJvp2aEvnUpzTf4uBBjCfJJK5nn08FcnhOLtcju3qCToEHES3vwELJLAJ7pVAme3lZC+LuN/VKJ+PjuBZEcD04QxUZOjo5qYZnSwvGh1xOv8fx8UrgdUxvzvy8KqTSi3nxoi4ov/zl+M74OAytCxcwJlOsZW4Or1G2fn5er4dwGOeQ21ztXW5thad0aEhrNvl8uIcmJ/E+a6jRc0RD6oUXcA9wgYxKfFxY4WIZF143g6qalYqeE+c9znGfYYIiaBcjAfL57eW2m/DDlWEG0y7BiQofdKs9TCJrazHdjB6mrfKXAgFMKlj0j4pxpRI8GE6VuGJRQ6oeeABGRWsrDIpDh7YebBYWMGgHg1h9/N73MDh++9tYdW1vx8D/n/+JSc0dd2DbDOnj6jUNHar90BiiUcgE1VJJJ8AimHzlcvgehRxiMfzNfKaZGRzfPffoKmFtrVYH5wouc44mJrCf2loc3+nT+qBpbES7/X7Nn5mcVAWjri4NdUynMRjz4cSJHo1EnkfWG7l4ETLB3/mOSrU3NODzDIWrq9MkYRqFjEvnQ8Pt1tj7fF6LQUYi1eE/9fU41jNntN7GD/4g3jtzRgU75uZgpLW0aOX6pSU8kI8cQR+2teGHiefOn2JRzyHzf5zFO51FPM+dUzW0REKvW/7wIcwV1o2MJRpF09N6XzBfLJVCn9LD2dGxtaJkuazhnVy5pAIj8+o2g2ElrL/kZGlJPR/MzYnF1PDYaNs7nWyPjWnozdCQFnVtakJ/Dg3pGJxMwht34gTanUyq5+aWWzRnIJHA9ZHL4d5OJERe9zrNsZuZUZGTeHzjiSXzD6amVImO+UJut+Y+5XI67gUCGF+2I9V+7pxKcjM/SAT98R//gXa1tqr3ZGlJpcc5ZnR368LH2Bg+S098T4+GAlHNk7WUmI9HCXKnMXytjA0a7le7VpcIrvkbgclJNXqamnAtlcs4xxQT4nzD58P4xzA9Fiivrb16pRbq6nB9MM+WObGU6Wfe7YEDeg1x8TMW08XRyUnN95ycVA8m75W+Pvzf3IyFC3qZeB/X1cEQYlj87CyuJXraWHaAixfnz+M5cMcdGtZ98aKODZEI+mh2FgZVQ8P2hD6GhlTGnce7es7jLD9AkSoalXz2bbWgRuVNLjLs1xy83cIMpl2gVMIkLZXS2H+nEbRRLaab3cPkJJvFe/R2lEoIE5ubwypYJIJBKxrVicv4OD7HULa+PgxCPAcbwdoIlG/OZPC9V74Sk6yzZ3ViNjSEQW9pCW0ZGFAjghMSVkCnoUOjjiFilDln/gpDQRgqWF+vHgKGCDm9aoEAHnjM42KxQda8CQSwSnbqFAyS6Wn0F4UrqJ4XCuE1xlBzwnnggE5wqeJF7x3PUyqF/dFAooJVuYz+YN6Gs1J6Not219Vh/5xY0mBkjg0fnKxTQeGJ9natSzUxUZ3kn8+rQREM4jhOn4ah/LKX4SF64YLIl7+Mz7/uddhHXx+uq41qiAQCG09iGf5ImWcn7IuGBkzK18sZqlRwvb7wgiY9r/4c20X1N7cb22xqwnHywU9p96UlPMCdxWS9XrRncVFDuOgxcbnwea42bwducz0Y2rW0hGuA+XXMQ6mvR7/Ro8B8vJUVHE9n59ax9wsLuB4oo0254LY2FdQpFFTsgPLTpRLOOY0FGhqUyZ+aQj8Fg+iT++5DO5mzw6K2mzE1hYWC6WldKGE+0vnzGi7o7EvmtG1lcBQKGIvYRha3dCpviuC4X3xRcytFMFll6Fl/v6p+lss4ToZFx+Poy1AIxzs9rQsclJGur8c9bMWf9wYUw5iZ0fGaYg9OWAS9oUHvPz7zqDB7NWFURDaL9jDcXQTXGRcQnIRCGsr9zDMqwDEwoCH3XV0qODQ1VX1fxmIi996Lz1JOfH5eF4mKRRx/MqkLdv39GkbI3NiDB7EdevPHxzXiorlZhWTyeXx2KwYHNWRcRBV6nXBRwDk+M4x+fl5zGzeDnm9GRpjBtDNsSNsFnIMAJyHbCclzGlJXEt6wn9ioBlMyicGsoQGfYYhVVxdc+JxknT6NATMYVBnpYlENp9XiA1RlYqhKLofJNEONOCAyifzRR7Gfr34VHqt8XnNWqK52/Dg+zxUk5ox4vVoglytElEJlYjHzWQ4exMC9+gHS24uH3OQkjouFTylGweukv1+9RMkkPnfvvZhUnTyJdjIMkR4brxcPAsquUsK3sxN9GgioN4STKFIqqYeFMDyKq3nnzqE9nNSVSpgcMg8pHNY8IHqVGFLY0IBzHQzCSJ2cRCgh1fX4HYp60LvI/BCGYzJksa9PFY4GBpDj9H3fp4pFrCEyOalx/athfRmGpjlzeKLR6nCWqSm9hjZS/GN+TF0d9k3JaRF8d2pK64h5PJh0r85Dcrm0TwcGVIJ2Kyhte61yjSIRGKsMoWFhUeb9OdsfDKrHMZvF9d3RsX67sllcT4UCri+3G+PDwYM4pkJB73+n57OnB9d3qYRrhgWWqf7G7zBM9bbbtj/ZWFnR0MYzZ3C+gsHqHAtn/k0koosRzrBgJr9nszgvzrGA5RS4atzdjX2dOKH3OxXPOFmm8iqvSSqF0hPB/L7ubhhsq8eehgYVn6mvrxYgMfYGySQiISYncY4ikepxiUYzPdjO8bpUUonvlpZrV4+OkRbt7VqeYCtP1pEj6s0/ehQS+6mUihEtLmIcSKXW5sUVi3jWBgJ4FjA/SgTfGxnB/cJSFCy63t+P+QTHhe5uGG8sin7mjC7IEJcL466zKPlqrzsXfrk4xXzb9WAeL3PQmPdIg2k70OhaXt5ebpWhmMG0C3AiJKK/nZPJjULyVtdi2q+Jp9uFMqYi69daYg5JLIZBIB6HAXHwYHXtoAsXMGmi4pkI+rGvTwemfF4VqJxcuKBhaJR2LhQ05Gt6Gu8dPYpBmbHLbP/CgobRMTcqk1HpXre7ep8rK/pA83jUuFpcxOQnHlelIhIKra86x+9OTCBskF4Oqi0ePoxJ6223wXCh16FQwOA/MoJr7PbbIaHa0oJVQMqntrRg4saCgSKaO3L+PB5e996r7zkfFD4fttvcjG0zqbhSwYOzWNSwC9aeKJcxAVhYgJF39qx60nI5VQJkAm59PV7jSiNruTAunQp+2SyMraNH8f6pU7gWaDRFIjB2hofhbaPcM1ktX+6EfZ1Oo81UpKLxvpHx5SQeV4GLjg41ChiHXleHh/dmIaXhMDxZ9MiyWDYNCIZusnbZ6skRH+pOaXeKelwJNNJbWnAOWE+IamceD65BGriM60+lVN6ak7x0GhOZQgF9XS7jc7wGuT0qXDGBmjVhZmY034rnm6F5rHvS11c9bmwEjZuJCRVlYGhgc7Ne+yKqJMjVXx4Pw2aCQZxrihyI4Hd/vyrPnTun9d1cLizgnDmDbbe2wsirr8f2Ojp04SGdxn3H4qQUlWAfbFZ/jAnpxt5kdhYCR0tLGCNolFAVkgWHN2JsDNdPMLi9cepKYejxdmA0A8siUJWxpgbPtakplfP/5jdRNzEWw/jFuQPhwhpFUOJx3LcM3RVBv7W24t4/f169YU1N6NtYDOPjl7+M7xw8qEqZLpcaKCMjGirLBUXOMViHivfjejCfmAuSy8v6XN+JwSRieUyXgxlMuwQnkcx34ATGWfGbq/d8ODOBmrLXN7rBxNVfHvPICAam+XkMhNmsqreFw/ibUq8+H4yBsTGsCn3nO5gwtbTgwXHHHWqEzc9jMsJBiApVZ8+qUlZnp3p+OFjPz2u+QDyOQTmRwAA4PIz29/bqKi7PMb04zNcJBHBux8a0HYcP4zuNjZq0ns+rtHUkgm1vdg0kkxjYR0bUS5VIYKCk9PSRI5hsM/yIUt4NDbryd+yYDrLNzXh/ehphPU89hW1yQspq6CL6d3+/1rBwPgi4kpjPYxtnzujk9OhRFROYmMBxMDeG3pZiUdUCmQi/vIxJKXOS+HDK5XAMbW3YVzIJxaPTp3Ec/Nyjj+IB+PWvw/D74hdF3vAGfIeGLmuIsJYPPTciqkJGrwj3PTKCyfvkJI6Tx+5yVRsxlBZn7S6+zoKjqZQayx4PrsvtqoG53Tuf+KTTmHw4JaidhaBZ34tiEryWdwLzbkSwjaam6kUjFuRljR56EVlHpqZG36tUsLDA77zkJRrew1BcXt8MQ/X5cA4jEfTPPfdg3y0tMLwoJNDTg+tnq+NLpXAvc/yiomNzM8ano0ert+Ec80kmo55tFhalgcqcQSqMffe7WpcoHtci0IEA7l9KZDN3kiHCLHWQTuM6am/XfEILp9s/0CBn3qQIrr/nnsO9woUrlhjYDhQBEdFaWXuN+nqtrdTdrWFxMzO4117xCpFvfAP3HvOUBgdxPwaDWpi8VNJnFgVQGhp0XOY8YGICBlNjI/Y1NYVFnvZ2kYce0tDCU6cwjh07hvuor08VMVk8nuTzeP5kMlrofbWXyklNjeZY8ZxzcWunBlMmo4v0xvawYXGXcCoHUYKXXiNn8dpCoXo1k8ZDLrd5IbQbAU44gkEMdAyx48oYC9G2t2PCVChUr/yzGCFlqFlxmwZDS4tOZlgTi7ktVLIrFjGZoFIWJxIsHlxTg4Gyrg4DqM8HAyGRUPlWegUJpbsjEUxynPHHPI5iEavQ3F9np0p9p1L43KlT6xcoLZUwKXTWJ6mpgVHR0oLtU9zh3DkYlrzGlpawH+ZNrI5b5/VIDw1DmxYX0WdMDr7lFhW6oJQpc7HY71wFZN/Qy8dQkFe+UtX10mk8sFIpnTguLeEY3G60obkZn61UNJTJ5dJVvY4OPMQYOsFVvpYWLa777W/DWH3pS6HiNzSEVcPXvhZ9wRXN8+dxLGNjqujX21utbEQYIjUxgf5+4QVs5+hRVUPjg5QSt8wzIjU1OHYaTNvxKl0JyaRK3hPWZ6G0O9X7nCuVzjpjvO5qatR4XE02C6NkYgLbcYbaud3qzWtr09BNKh36fKrW6FTtm5rCa0eO6Cou5dtZhJYqcT4fJkSxGM7nQw/pPReL4XyOj2ttsc1YXoYRR8ETrpjPzaH94fD6dWfW2w4T0+ndFtGitF4vQpAuXhT5p3/CPely6b1dKmkNnXvuwbmkUmRjI9rI+/jWW7W20M0Q4n2jQQlsXiPFotaOEsE48spX7iycjgXSRTRXdS9CIR+WeGhs1P6Ym8N43d+P8eXkSRxTV5cWaOZ9zjGdIdWNjXhu0bvNkNoTJ/As6OjQZ0u5jP339Ig8+CDmEozWGB3FZ9Np7LepSY1bhvw/+aSqaba3q8eIMvnrje+sP8ZIFj67uVi41X1M0SHm2F4LsZQbFTOYdgneCDSYmBzPi9dZi8k52DG2/mYQfnCGnxSL6rHIZFS5ipOhclmLGpLpaQyeFB+gu5+iG6zJUi5ronIyqYnyVNc5dkxD1TghoXra0aM6CWGS+cgIttfWhgE8m0U7GUPOcB3WRiFU76NgwfS0qjS53RqL7SzKygKlra0q2+yUHm1txQ+TUFtacCwHD+L4Mxlsq78fbRocxPdWG0vptIoziOA4br1Va1ItL6NtwaDWpuJq3fS0ev4GBjDZ8/tVpper5lSgoxDFZz+L/5kr0taGdlLdiSFX9MpNTuIBxYl2X58aZJQ4Pn9e5ZZpdLMgJiWveV01N8MoZbHX17wG2zx9WkOZmOvT01O9Kl8s6gOYxUzLZb1+eZ4YcsgVTxpNMzMwwHp6sI/ubrTd69XrcSsuN8+RleWZG9XYWO31YX4BhSIYCraygmM8e3ZtUVR6xymgwJ9CAf3k8+F6q6/HNbo6H4aFJulZ4fUSCuEao6AKJzLM7YtGVTyFYThtbWqADgyoQuOrX73Ws8LE9I1wSpbTcKQ4SlMTvM1cCOvv3zqUb3FRvUXJJM4/6xcFAjo5npvD6nkuh/PxylfiOqSHlvlxzz6r+RktLRoKSiN+r06Gjc2pVHAt0AvE+2BsTPNzDxxAJMVOwmadxXq93r0dcsm6dxyHmCM6Po4x9PRp/M/6ayJ4bt1xR/V9HgppOHpTE56DHg+2OTqqiz/MfbpwAfs9ehTjDAWagkF4tGMxFVph0W4+l5wlAJ59FmNnNIpnC+tccWGGz9TV1NVphAVxuTS0dzu5lRz/nCF9xtaYwbRLcMLDh6kzAVnEiteKaD4PVWE4oHFCt7iolbpnZjSMSwQDHZMth4fRb62tmDQ7K4eXSlqfhoMmvRW1tajRsF4+xwsvYODKZHTwpMQp5UkJjQJnoVUSCmleEs+t34+2s7K5c0BbWsI26GVZXMTxPf+81pgJBlXQgkpyDC9YWtKQMRpNw8MIC6A3h2GLpZKq2DmvN0pWl8t4aEejmLSxLs3UFNrIHCLmHoVCOCZe0/SidXTgNSofhkKIOx8awv57e2GcNTXpfVMuY9uUe6Y3MJPB/ysrUFFiYcHubkwmFhawTea+9PZqvQyvF9ucm8P5SKdxXEz8Hx7G9ZPJ4LVAAJ4oFnJkDbBUSkPZnnsOf9fW4vPJJPbD2l2NjVrVnUIgFB7J5WAcJBJaWJRe1lgM/7MIqNuNY2AB2cVFTQheTyxkI2iMVyqqSLjRhMvvx/lmSCBXpplQXSyqAAYFVNYbt4JB3D+sjbSa2Vld8aZC49AQrhl6Cqn8RHW7e+5ReX4eC4u7rqxgUrW0pPkZrPWyXVZWtJ6UMy/SWZR3ZES9XxSd2IxUCpMxSj13deE+6+pCX87MwJg6dw77bmrCsd17r17fc3Pow0QC2xkfR7vicVU/471qoTjXjuVl3P+sE+fxaN6Q14vzsd5keDuUSrhOGILV1qYhWt3duli0UwW0pSWtoyeyvRIEuw0L1VLVrqkJYyPvBWdReEZonDmDcZ/5rlQGFdF7pb9fF85Yx+zQIfT98eN4LZPBmMUahG63yOtfr7UMmdNaKmGcvv12PSdnz2IxTkTDJekFTiRwLjYymLiAw1QOziEZrbCd887olqUllY83tmaP3w43Ls4Y/VAIF+96SnmrhR9uJmlxJppTCY8D39SUyNe+hr7w+zXPgavFmQwmFpwwUpnuZS9bu2LGGjlOtcJTpzCYUl3PSamECSVXyFmLoacHk5CWFq0rQalsGlX8YSHXurq16n8iGLAZqjcwgEki85FWTziZ/8HJj9uN3ByGI4noA5q1eihYsbKCvvz613Vwj8fhIaL8bDCoYVWUqxaBQcoQRyYUc3Dv68M5WVrCsZ47h2Pp6cGxiGCgZ/gUhTNyOfQdvVgrK9hPKKQFFJkLxYkfvR3d3ZhEsHZRLodrgKFHMzMIqVhaQlupRkiD+2tfQxvb21UUoL8f+/f7sa2RETzoDh1CGxlS8b3voQ8o3MKHLBXsqIgWCuH9UAgPdYZ1HjtW7QmKx9GW0VFVYBod1eshFkNfOie8FJdweixF0J8XLqhAwGZwIkY1uNWyvszB26y+0Nwc+t9ZMJoy+ZmMemj5u1LBPbNRePHkJI6Z9c+amtTzNjSkQg3hMF7r6MB1TkO9tlZD41pacK1973vqfTtwAOGjG3laGLKbzarBR0l44lQZ47i9uKhqdKvHEUrNOyc29O7SM9ncjP5aWcHx0+N8+rTmjyUSGo78/PPo0+ZmLb69sIB7ORrd3vk3NofXMcOmeV878/ZY02h1PgkFjDIZvE9D/eBBra+zHbJZjEUMRW5rwz65v0RCvRnbpVzWnByRam/vXsdpMHV1qfIjVS+Hh/G517wGY+jYmEadrIbeqrk5/NTVYcG0t1cXHG+5BePiV76Ce/brX0eO67Fj2IbbDRGlqSlVTPX70Q6PRwWHTpzA9XTwoKqFclGYofkbiTJQXjyfx+e40JvLYQzezvVkwg+XhxlMuwQfrMWiPjidN/FGtZhuFg9TLledT8O8pbo69YYwrOvCBXzO48EElis67e26ql9fj4GPEr5cgfd41AgolzVMrq5u/WR6JvhTVGJkRD1era14gFFpLBxG23gOg0EN8aE3YSO6ujRH5+RJfZ2rlUtLGLBHRvRYolEcy9CQFtBjrZ1oFG2ZnsZnk0n1Yong/XJZZbojEUzcKYZA9azpaUxIaRg0Nen5cUJZ9FgM20yn8drRo/hdKsGoGBjQAqMMJQkE8CDp7kb7WCNnYUFVnqhMVFeH9jGnh1KyxSJeGx9HP42NoV0tLVgVZOFOqo8570cWHp2bw4R6Zgb7pKTsM8/gQVoq4cFHL0Z9Pb7Hvqmvx+SlowP9s7KiuVTLy/gujbDDh6v7Lx5H++fmtK4Qw0hF0CfOosA8XqqhhcPY5/y89lFf3+aTZuYJcoFhYED72ymM4jSGCIsRi1TXFhOpDnVkAVlncV+GvTCnjMYE64uNj+MYuE16aXkvBQI47uVlle0WUQEJFjteXlZ5ZYa+0KO6mnIZfT41tX4CNseixsa1Yialkoa2Mu+LTExAKIXGTWsrzjHvD3rNhodxPbNOFYv8Li7qfc5wTXoyurthGPn9GoYXDG593o2NodeYE9iNrgUuhvAZTk9FU5N6fwsF3PPM6UwmMSa3tWEivpWUdjKpOZ5eL8Zo5lCyQPFOZaKXl3Gfcz7R0IDx8UrVL68XjLRgJIpz4SUSQb8yTI3S+pOTWpw9GlWhE59PxwgueFKWnFLcLGD+wAMin/sczuNTT6FWGe+x9nZERDz5JJ7zFCxKJHC+kklsq7MT4YEulxq8LCUgUi0OIYLzzPufuaRUhnUu1GwHCl5R9fda5cLeaJjBtEs4PUi8yVeH5IlsXLy2ULixazFxJS4QwOBAqU2/H5OiUAhx+5RoZ8L94CAGPKpinTqFSUqlggldubzW2JyawoONYhAsdrqa8XENsThwAINvf78Wdp2YwPejUZVg9nqxbeZKzc5quF59PSZMrDfElUuqIwYCOpln7lEup96ZdFqvA06Kpqdh8DzzDLZN8QO/Xw2dmRl8d2kJfXbHHQgXiEbx3elpFZ6grHCppB4lEXyPdZC2oqcHEwWq2lHli2ET/AzlrJ3Fdjs78f/0NF4bHVWjZGEBD8v+ftxDDQ24X55+GkZIIKDiEyI4p/feq/lV4+OaVM96HKWShpI1NuKaaGrCsXZ3Q2p8aQmTjP5+9UJRrIH1ulgA9fWvx//PPYeHW3MzzhU9fGfP4j0qEjKROJPRsL5KBeeOhgRrC4ngPb8f38vnVbra79fiyKOjKqt+553VY086jZ/ZWTVamPcjoufHOYEaHsb1x4K9xSImEvTodHbiOuVK7eoxjJ4lhpBQXY/w3NBYisXUQ8eCjuynUAjnfXhYV0ujUVz7zslToYA20mPE+keri82yrycm1LsfCqlhxh/2+XqMjuKYi0UVdGGY6PPP6zh/+jRERmprcZ+urKiQSk+PhgyKaI5bfz+uaSrt5fMYiyoVnUCPj2u7DxzYP5PfqwEXs670mLmgQ68LYZ0sZxg971e+n0hU5/yRsTFdNDt4UOWpWfC8pQX352rDqVJRRUjCMGcR9ejuNASPi2blMtra1bUzb9degAsXNEBXe6qZfySCcYT1BRkGvPoerqnBPZPLqSgRt8tFr+Fh3J/33Yc8wgsXMM4ePqz7a29HWPC5c5pfNDWFczU3h/ePHFmrcMdnIJ+5zHEVwffHxjSyYmJCx1Je79s1mFiyhIIX+8GbuBcwg2mXcBan5Q3h9DBtFJJ3s9RioogCV9oXFzGYsd5IIIABa3YWfdLYiJX7v/97fJ+hC88/j4lLNIqJaUcHBj/WXllawsPuxRexrYYGhO6tXnFZWNCCjj09ugrEWiShECZAzz9fHTfN1XiuDlEsgHKoU1N4YLGorROqvaXTyJli3gtV47g63turamHt7VrX4fhxrXHT0IBrZWEB+2MBzkOH0McMOTpwAK9T7cvlwoOAggVUBHROlicmdJVuPfx+9BHlyFkDh4InlFzv6MB7fOgtLKgnKBbD/1yx5Qohw8gOHNDioDRgfD589v77NUdIBP00NKQTV+bqVCrY1tISvrewoOGInNT+8A/jOspk0IZbbhH5qZ/CdylFztykzs5qKXyGc/EB95KXaBHEZ5/FRJehFqwRRQM/GFSPSD6P642eEXoBBwZwXTA0w+/H91hT6ORJ/Ga9D443NF5razFho5GUy6FtLCJ8993Yz8wM9sXaTRcv4rN+P4zBiQm9V0TwOdYOo9z34iKOrVLBtRCN6kM7ncY+5+exfearLS6q4cTzQsngcBjX0noy68UiwvCY6xiLYexcLcJAIQ4uqHCixf8pA78ZqRTOG88zBX2eekpDZ/v7sa0TJ6pDKZNJfJZ5GAz/CgZxzHffjfvBKcbCvMWlJYw/NE5bWrYngX4jwOKik5Ma7sjw4csptrqwgPuWz16ObSzOvbpPqXxWKuEaXs9YY/iziBomfX24Hk+fxpg1OQmvRUcHFrEYtnvxIq6NTAbXC2uU+Xy43jkW7wQaaoymYHmO/QhzZZPJrUUqurpw31ECnLXQVkNJ/ro6fSb4/RhL+Izq6cHfp09jEZfjn4h6jrk4yJqQ3CbzrURwLqmsWVurYkT0agaDmo8oovMX5sKurFSr3G4XLtKYwbR9zGDaJWjoFIuax7IdDxPfYzz9jWgwFYsa0tLTo/1SqcAIqlQwQQ6FVI2LXihOzuhZYF7BrbdqPgtzdFgpnAIRdG1fuKC1k7iazNC15ua1YQ/OUAxCL8C5cyqMQEMjGkW7z56tnljS1U4PEyXJqerGCRiP0e+HweNcWSyXMSF77jk8jEslHAeFDxgiyNA0ToqdcBLGFdSnnkKf+XzYJw0jFhBmrllPz8Y1gegFmJ9XA6qxEW2ansYk5amntPZUPI7XJyfV80OJ5rk5zQGjjO7Xv65GFZNx+/s1VIYTb2esvteLB5hzwnH4MPptbExziRYWcJzNzTBIf/mX8dBlvg6Nk+5uNYaOHEEfLizAy0nPxvnzeKhR6EJEZd5pSLNkACf26TS+39+PbQ4O4v0jR6oLt951F65jhqiOj2v+Vyik9cFGRzX0JhisruFy8qTW8mHoVzKJY19YUDGB2Vm0g5LUNARYr4TXc0OD5hkwn0AE/bW0pHl+8/MqmlBXp8pS5TL2XSqpwZlM4hw55frr6jDJZFgNtz86qtcoC9VmMjjvFy6gje3t+PzFixqe0tyM73MVf2oK//f1bTzmFotqYDLnkkbiyAja0NSEYwwEYJzSm0Zvb3s7+nhqShO4KTnPhSKKaNDgdHrN/X5Mfm/0khMiWltqakqPn57HmRn8cGK6mdIhcdZLE0Ffd3auDblcjVP5bD0ohlKpaBixiNb8oyDB889j/8y16ehQAZdKBfca5wpNTfj/coycyUkNUW5owLi1nw3rujotME3RoI3w+3GPsZ8Z1r/Ztvv6MDZwYcPlwljGYuAcZ0ZGsG+KvsTj6u0vFHAf53K4nnp6tM8pB845h4guaDEElNcPx1QRffZ4vXieT03trLZSTQ3Gcctj2j5mMO0C5bLmkbCIqUh1qBhfW128VgSDMycP+4mFBQ0r4ESHRkB7u8bVMsEyGMRDY2hIQxA4Se3sVGU1Ebz2zDPY3qFDKFr3zW9iEtfXBy/DiRMqctDSouFXlQomGQx3WllRCXGni5uTq3IZDx2qgS0uahLw7bdrDoNzgkiYT1RXp7kmPO+RyNoHl8uFiVRDg4ahUc56tbHkjEfv6kLfZTKYwDIOnwV4uVImopLl+Ty2QflUn0+rvc/P47s8BsqvUjK9UtH4+tWqO9ms5rc0N+M429t1UsfCo8xN6e7Gvtxu9PPMjHrp/H58fmxM+318XOtheDyat8WJ++Cg1tHiCnE8jn2sl0eWSOD88PzR05NOw/vo9WJyPjWFSQ5XFzs6kPBLo6exUev41NSgX+bm0C7mIFDVkF5D1vaqVPT6nJvD++Uy9pFIaKJ3c7OqPbFIYnMzjnluTiX3/X4sGjCXiPLVLPjMOkeTkzDyDx/G/XbwILY3NITvMEyWRsHAAL5/5Ag+zz7v7NTrIJ1GH83OYjLR26uTBE4qKME7NYVCrB4ProMDBzChaW1F33ACmU6rEUHRh+99T/vB79ccLxH8ZrhLR4fK8zMkcXERx1VXh31evIj2stTD7CzOxYkTGurKGmf8SaU0abyxUXMrxsZwDAcP4rpnnlJ3t4r95PNoX22tenHb29WDSsl9Z5HN1dDLvl89BVtRqeg5Zy0wSitzTGLoI4UAmIdCLzXDOwnH1Lm56n6NRLSgcaWi9eMuJ9eDkvMsNL0e0ajIq16FMfW553AfjYzgvVBIr9naWlXIvBwYniuC42lvv7zt7CUYRkwp/q36pqEBYzIFVTyezQ1q5j+z+C2VZlnAvK8P1+HkpI5FNNTpjYrFNMTugQeqDRpnOB5pa1Nv2cyMRj04UwUYihgOY4x+8UWMI7nc9q4Pp/DDjZzecTUxg2kX4Ep3Mombyin6wAuXKmzrFa9dHSqyH3Cuvq7H8jImKrW1mpvDeON8Xlfxs1kMPi0t6n6uqVHBBhGV/6RXqL0dq/yZjOZULC7qSpMIJpO33qoeHeZX8LfLBSMklcJ3WCsnmcS5icVwLpeWcA6bmnSl3PmgF9Fwrq4u5NQwN4l5JM5J2OoHdCSiRtH581rkmImjNCqYE1Qo4OH74osYXC9eRPtpFCQSOhkV0dCg8+dxfAzB4kQ7GsU5YQHhjg6slDPPiApEFBpYXta6UqwntDpOnupy9NylUphkUvRgcBCT+KYmGMCdnTi+M2dwTHffjUnl3Jwqh1GWm5NTTpxDIbR3tQKcCD6ztITPs7jhwgL6kw/VwUF8lzl2FFdgIdSmJpXBnpzEg6ytDeft8GG0k4nauZxOosbHtT2lksqUi2ifcRJHkQ8RFbXgWMAwOUqRd3drKEc4DENvaQl5XrxfqGA4NIQ+bWjAdu64Q8PLuL3lZbShvR0GJVXzuJghgmuCxlI+D8/hxIRWsn/xRRXq6OhAH62soCjkxIQ+uINBtJ+1yHgM3HY2q8IWp05pDaKFBc076O3VGmVer9YsE8Hnx8dxT3C/t90m8vnPa85kR4eq87GQL3MWWlqqowJEcB/wHvF4sO3lZRzHHXfgurpwAdfPU0/p5LWtTe8L5mB5vTguTp4SCXwvn1fhDIpkMDznRmRxEeeJEzsnfr8qA/L+oeGZy6lIDT2Mp05hrAkEdNWfUt80tIPBtaFN09M4tzScVnsZufC2erzO59Wb096+tcEVj6NINkVeIhHN0XS7q9UZN4M5kk51R/4vovfdjUJ9vRrHvL/XI5XCOMdSG3w233XX5vWIYjF8dmBARXDicTwPenpUEY814u6+uzrsv6sL35mexmcYusfSHSLVBhOv5XxeBVzoCSc08jIZfJ4hg8wL3QrWqGIUxo260HI1MYNpF+DDjd4MZ3hesaiD6mbFa0XWl8bcq1BtKhTSCRAnRpRhPXcOAwnDYGprdULCFX6uxtfUYMJ29iy+wwKR4TAGJ64gMSSGYg633KIrQU4RA3ry+OCkdCehfDhze6hKRmnxmRmtgcJVQNY6oeBDsagTy2QS7ejtxcDLRNHNmJ2FQcKH5nrG5+raOZSI7ejQorGMW47FVHad25uYwKDuduuDJx5XzwGFNaamdBVtYkKv1ZERhHVFo1qU1OVSKWzG4jsV0c6fx2usR3TyJFZZmcBNMY7hYZxX5nHcdx/e//a30Ta3G//ffTeOf2BAE++Xl3EcDOtbWFB58mRSP0OvLT1VlICvrdWCjgMD2jf19fAcUPmIXil6hkZHcV5f9jK83turkxfeA83Nut9YTMcHp/oVldK++U18ng9fVpOnp4zXmDMh/O670WYaeeUyjCIax+m0yL/+q4ar1NRgH7mcek5SKfRJfb2q6N1+uxobJ05gInn0qE7ESiUoRU1O4r49cgTtoJHAQranT8M7xDA8huUFAviux7N2clcu62Q0k0F7mAzNQrYMlaWCJK/3iQnN9aIQSzqNvv7GN6oXHaJRzZULhXSFnrl4DQ0qIEFj0utFmzh56ulBX0UiGi7J/EUR9FtTk+alcdw5fVrDSXn8N0OonRNn+JiIjstUE1vPK08CAdzvLPNAoZvVRpfPp0XFORZS1IQCMxMT+C4Xjxg6zUgEjskMWeZzYHgY70Uia5UlN4OheqRcVnEhCh00NFSHC9LTzHye1ccpgs92d28cOr1f4WIDPY+rr4tSCc8mGidc9BkZwX06PY2aem1tG4ez0Rs+OIgxgWPt7CzGNo8HBjkXou67TxdRCwXMU86fxw+9nSwyTw/oaja7fngvsP6cU4hkO3ltLhcWl43tYwbTLsEVI66Ser26OsBBm0VUN1LK2y8epkJBQ/Ha29d6GGprMcgkkzCA+ICsr68Ok+CkJhDAKhFljlMprMa53RgAXC7Ny/H7dYJ+5IgqRz39tLqz43H0/fnz+L5zwEwmYcidP68GKr1JIpoLxYGYIR9MWl8NFe88Hgy03/iGyMMPb74iVCpp/g9DktraMBGjF5KrphvVk3G7VdCBEz7WlAqFcE6Y88Rz0taGbZbLWvMmn9fJbCiEBw69MrmcFmz0ePBwKRbRJ34/JtWsH8NaSek0zp/brcIQMzM4Rj5IKAqRzWLCOjeHiVQspuGDsRgeSI2NagzFYjAQKcE9MYE28wFGGEYRDutKIguuOq8/Zw0Wp6CH262GI0MaYzG0kQbb8eP4Tmen1t1w5j4EgzgX4TAmNKtDRGpqsD0Wzc3l0G/0FDJpm+p6VL4bG8O5bm/XOlw01hIJ7J/FUll3pL1dvV8M56PIDK9zQiOMk8dMRlfbv/51NXhe8hIV4mA4W7mM+3BmRmXZX/ISLYo8NKT1qJaXtT4JQ7K4OpxMoo2RiHoy29txHbBILSe0zsLRVM7kdR2J6O+DB/U+dl4DDMdjgWoWvqytRf/RGKaEOqWDOXlOpdSrceAArvn1wrRowLvda5X8bgYY1kzDnwWBd+JFY7J9qaS5HyyozKgNFpSm4UNDicn3hDmyExP4zWumWMRvPqMZVbC6cLlTqGOnpNO4dvi8p8jFwoLW2ONrDFEUUW8Zx9BAQAu032j4fOrNOXu2OvTd5aoW8aDXP5/HNfHssxhHvvEN3JOtrRgb18tVbGioNroKBYyxNTVa+/D55zUE/f77tb4TVfpSKZxPej1dLjy7Vnt45ud1wXGjPDPKi1MQRGRnwg/GzjCDaZfgCgjD8Hw+DHaMtRepLm7rZL8ZTJOTqsy2nmwpa8QMDWFgY/JkOKw1dZivtLyMhxWNHCroDQ1hEOzv19olLO5HlS+qi1FpS0Tlei9cUNWYgwcxoJ04oYprlDDu7FRZWa7qh0KYaHq9+oDn4EYJZGfYB1egv/pVHN+Xvyzyutet/yBjXhKP2+fTEKPRUbR1J/HsHg/6iQWAOYF2hqytZ9QePKjS5/G4igDMzWktiHAYDw0KOfj9MCQqFbSfdbVo3CYS6q2g3KrLheO75x68ls9rKAnrEfl86OeVFS0eef/92Nfp0/js2BiuO06MWG+iXIbByjpfjH+vr8cxM+SLngpnDSGfTw2S8XE8/NJp7I9tZAHCUAiGEcMaqRz3wgvYV2cn+jSf1/Mbj2shYsrBFwrop3hciyzTiA2FcB4Ylimi1yTl5mm0jYxgck55bNaZolJUd7dO6jihLJX0YR8KaT0jercYrieiq5us7cV7Mp/HsX7nO/rZ1latT0IlwgMH4J3icbjdMAJranCdc4LI9jFstFhUZbKlJV25dblwDmnwFAoqQ0/PxPQ07j+qW/n9unJPMQX+cIGAPz4fjnNoCMfB64ILKJQsv/tutPn8eUzklpZwfTEvcT1jiUIQIuuHf90oVCq4Jhi+SBj2yFDozs6deWdENDxYREMzr6Qf6a1hOBYXibjY4vOpAZ9K6TXicuEcXk7OEQVtnBN0Ft3muMvQMuLz4T5taLj8PKf9CiNLmNs2P1+9aMl7kh7cYFDzN7/9bb2fXS48Z+rrca+u9uo2NanKZ309xqKLFzF+0dP03e/iNV6/U1O41pubMdaPjWFBgHX6nHl1Ijpmi2C83EjtMRpVI55j2nalxY2dYwbTLlFbqx6mQkE18Z3FyraqxcSk8M0KoO42DFcT2TzkzOXCYJZK6WTt5ElMyjghTaU0bCIWUzWYs2exDa8X32OBx6UllQ/1eDBpoWoXV26bmtDnbW0YLEdHUcXbmQjJMDcm/dIIYqJxPK4G0mZx0E5CIZGHHhL5whcwqH/1q0j6dYZnjo9rzaS5OX3wNjXpRP3MGc392g7M72CfRyLY9vIyBnPKdtPFT28ba09RlpmV6imjzOK2DDPlZJX9wvY5pdQrFUyEIhF8Nh7H53p7188FOHsW+56bwwSfE+Dbb8e5oMdlbEylUhsbIQBCDw49GUeO4DvlsoacUc6aRnp9PT4fDOKHoZ0Mj6PIhXNizRXqxkb8ptpaKKSJ6HNzMCyeeUZzo+JxGFhLS3j/zBlcw5RIptQsZeAZ1jU6iu/Tk+p8WIbDeIiPjaGdy8swDOghYZjHXXfhoU3FJOb/cOJfKOC4JydxXTBevrUV7QoGdfHn/HkcGyd5ra04TxRIaG/XMFmfD21PJNBfS0trV8CbmvDa8LAWci4U8Jurx1SfrKlBfwaD6nmbnkabaPRx4kHvWyiERZZDh9TQ2i5tbfjJZLC9+Xn1LHGx4OJFVdASwfXA871erTcRXFu5nKr13WisrGh/0SPC8dTr1VBJGrLbHVNF0PfDw+rhaWzU+maXAxffkkltK8tY+P3VdbmKxWovPdVMN8upIQw7Zr4Rc2fpGV2tiscC2Om0LiRw/LxZk/cZPcIFOo7pFODZKNwuEEDINIuQc07FRZpEotpDyAiLXE5FWrJZfJ9zsfp65GqOjoq8/OXq5YxG8dz8xjc0H261SBLr2lFBeb3C2qSmBsfkTOUwg+nasYen2jc2vNA5OK6Xl+Ss1eSEuRqcOOxlg4lFYxnTvRWxmE6gWZSNnjd6MQ4dwuDHAZETr7Y2TDQXFmBsUba1s1NXyufmMJAxIb6zE9sdGdFkfXrDurqQBM6k/av9IIrHYTR95SuYjH73uzAWZmdhLDFMhCuLkQjaXFOjg+rSEjwSvb2bxy0XCphIOPO2iNeLh0A2u1ZivK4OA3tdXXWxUoop8CHAWG7KvItoUjonFKxt4fNpHpeIGlb0fK3Xz5RQZ9HidFpV7mjwOGEeDFdk2d9nzqAvhoYwUfZ68Vl6Faan4QU6dw7XQVubJvEzbK++Hp/J57Ft58SJ9bSCwep2cWLOVeMTJzARo8HY1KQ5baxNlcupIuDUFNr/4IM6UX/hBZyzZ57BfUZVpdpafDYWwzm69VZcK1SX46RgcRGLBlyE4MM/k1FRj7Y2eMLGx/VepqEdjaJ9rDU0M4PPMC6/pQX9VS7j+CilTql756opPSoimgdEKX16ezweVZWcn8f2jx3DuaMIgvN6P39e8x5ZXmB5Gdfp0hLOY08P+udKCIdhCNILnM3iWKen8droKNre0wNDPRrdOMGaeYQimgN5I8AQ5dnZ6kVBKmwy5JPRFLW1MJZ28mwrFmGgcsJ4ucIGGxVd9npxzawXskdaWnDep6fVgMpkcO7X8xJwLFo9fpFQSMf81XCxYL8Vm73WcHyiGut24GIOxWH6+vR6nZnB+OGsvZhI4L6enYWRdvq05qCLqCjV4KAWYp+fxwJWqaQLlSyXwPnfyoou8HDM2GzeQRXdVEq9oNns3l9I369Yl+4SDAXjqvBmtZhWh+SJaNw1J1V7ET54RKqVrjYjldJ6JF1d6mEZGdFaL5SOZR2OfB4DUUsLBrFvfhOT8a4uTPb6+lTh68QJlZvt7NTwquVllUKml+N6JFg3NyPZ9OmnYdBMTFQXzqQMd2srjo+Dp9eLYxschIF48SI+E4+vfTDPz6P/WHeqqalaFU9Ek+gLBY3Jd3pfMhkN0doqjyASgZEVjW4cL08Z7eFh9S5udR07jSbmSNG7R08PjS8W/3QSCqHPzp7FvgcG1MPIH8pIc0U5l9OJNZXtcjlcU6WSGklUtaSqH3NcWPCWhX9p3DMsrbZW661MTeHBW1cHr9n3fz/29eUvq/z0qVP429nGuTlM2o8dW6ukJIJ2HTyo4WMi+F5Li3rp+JA9fx7nhIbf9DQWHzo6MDGoq8P1RflaeoMZplcswgCJx9EWikSI6Njmdmvh2XBYc5+YvOycOBMaTA0NaHNvb3XxRyfJpCphud2qTsYQTU4yWZtsM9JpjEFOMQYRbCeb1bpQ58+r0EQshuN2ufA+lf443oyO4lpMJNZOhnjdsB7ZXoGhX36/ejy3Sy6He47GByf6HCO4KOaccK42SDgmOsViVr/PPFOPR6+PnbSR3iTnCj0VUDczkpx4PLi3m5t1AWF5GfdQe3t13bTZWVwLHLOYT8V8I/5tXB8oA76ygt8c81mewSmQ0NiowlKFAhZWnYvdlQrGzNOnVXwqmUS+FCNb8nlsIxbDQkoqhWcSQ4D7+7d3/mkwlUq6kJ7N3nwCMdcDM5h2EU56uAoqUn3TbVa8NhDQEJW9yvi4VhLf7s1Lr0NdnVawduZuMKwmm0W/sRJ2by8mJs8/r0UgH3gAuTAkEtGq7W43HlgM3WDifnPz9V+Z6enR4pZ03be1oT3OxOTVMM+DE1vmybDGD5Ng2afhMPa1OradIUXMU2H8PXMJzp5VGWuXC+9z+2wXw1SYWL0dolE8aHZCIKBGE4UgGhqqPT2byaMyX+a55zDBYvgMV7pzOfT7q16lssQLC9hPb2+1OIQTGg1cNWQbWLz0/HlMjriaGIvhN+PkOzrwGdbyoaxwOIxrobYWxzc9De8X2+z1qhABpeu9XhVGoFempkaLcKbTuE6Gh9WL4XKp2mFjo1afp+ExMQHxgltvVY9xIoF9TU6iXV4vzmdvL/qYYX2pFI4nmcS5ctbgWl3/g3LIfJ1em1RKvXbLyzgmZ/4PVTRZaFgE/d7VpaIRIhri2Ny89XU6N6cFIxcXMakJBnWBQkTVLpmH2tuLEEfmc1FkYHkZSoBOUin1KIpgokPlvPb2vRFaVS6jTRT2EMG5Zj7cVmSzGD8KBZUAZ0004nLp/bsaqpKtJ6DD0GiqczIsqbsb581pWFEynMW3fT7cZxTRWW2gO4suX46Xj9ENsZiKfTAXr71d6/iJ4N7cyANlXD8ornD6tCpgtrWpEZ1KqRHOxRuW0+B456S2Vr9XW6vjejoNcZvZWdwbZ89ie856TOt5VxlqyPxWwvuQYbxcSDeD6epjBtMuwhXLdFpdx04Pk1PueXX1Zg6ue9VgYq6HyPa9S/k8Jn3M1+CKs4gm2DJngtLJ2SxWfxsbdaW/VMKK+rFj1dtfXsZPR4eGTpTLmPhdblHCq4HLhfYylKutbftGG5NKw2HNRVotLU0hBaeHinBCs1qi3OvF9cakfSoNMlxKRMMX6uqw7ev1wA8GYTSdPaueIREcN3PeenrwQGPolzMEjEIrDFtgPDqPcWFB5Gtfg9eSMuT07rS347VSSeuDLSxgUjQ3pxP9REIfmAsLKg9dLOJcccHj9GlMvm+7DQ/de+7BZG9iAsp6XJ3k9c0VT69XC+MODGhIKY1rvidSrQzHnL+ZGVWjc7nwm9dRQwOMt+PH8Xc2i23OzeH1lpbq65PhS52d+Glurq5XRnjMDKtk7THKgdfVoc28lhnORE9WpaLXane31qNaWMB5cNaoaW7GOXB6HZqa8LOde2tqSuufcEyhiiZVF3mt0Vty4IBOolh+IJlURS4RNV7n5tDm06fxvVBI1fwiEUzUd5NKBcc3MaHGRCik+WznzmkdrY3u+0wGn2MSflcXjn+7Y1u5jHuD4Wo8D842Li6irysVDflliOhOcLlwXmgoXS2hDb8fngJ6k5aXNefW5VrrdTJ2l5oajBszMxjTjx7F+ZmagpfJKePe1KS1GJ1hdU5aW3H9Li1hwYl1wDo7VTRofBxjeGMj9t3Zuf71MDqKOUtra/WcKhTSuQ+jLPZTyZn9xL4zmD70oQ/Jn/zJn8jk5KTccccd8sEPflBe+tKX7nazLgtOaJaXddXfaQA5i9duVItprxpMjMNfXVl9M5j0SsUhUiho3SoRNZjm5/FaPK6y2CsrGFBuv31tiBcL2cbj6sER2Ruxvgw3uxwotRwIYGWK4SVLS5obtJ5iUqGACQ1VBAMBVXtjaAxr4NCbQGNsYUEnQpww19drCOFqKNHNlXiu8lJEYyuY58BrIBRCIVgKFYyP42HCidKZM5hUO+8ZruJlszjel78cx0QFIxHNIVlZQfhEQwOuYXo5nnkG7aAXjoWWGa5YW4t+4ISLYgRM7uXDl8pq58+jzem0GhqhEI7p4kV8hrlETi+r36+FWlk0d2BAi8Yyty8c1lDDbBbH5qxDxgWKUgmTN7cbhk4goLLXIlrsuVzG+/QI0KPDvEO220k4rPWMkkl8/+mn0Q6qgnZ1qUeA40Uuh+uLEvHj45oIHQqtzbfz+9H3VBRkGJjfjwWJ7Rr0rLUkovVwzpxBe77zHZ3Ic7Lb16fKlSMjKpNeKKjiJA1YjjWJBLy3uRyMptZW9XZvN+/iWuEMbxPBtdDWpsqkExN6P6TTWpDY6cFJJuHtT6dxzJ2dmkTPcEMWJqc3c3FR70/el6x/deSIGpFcQFxYwLmi6A2l9Znz5lQ6pNKqM+TY68X3WNPpWuaLMfxwaAh9Yl6lvQtLEmSzuAZ5b3IRmDWsgkH12M/M6FjphEZ4Oo3vNzTg/hobw5h37JjmVR44sLH8/MqKimdNT+N54rxemX9aLKqX3rj67IGp4vb55Cc/Ke9+97vlL//yL+W+++6TD3zgA/KGN7xBzpw5I03rBbPvcWgwbZTDJIIH0H4zmFhAT2RzhZfVsCo5w1hEMJljTZhgEP3hdmtydWsrHkasvcQQLeYQENY8cLZpLxhKlwsNFa5yk8VFDLxb9Xu5rMmlgQAmlOwPFvzM53GNOkPc6NmgCh4LJaZS6tUKhzXZOp3WmkobwUmW84fn3VmpnsaWM85fBJN+ik9QFICrfk1N6CsWEmWNiqYm9YAySZiGYamElcCREQ0BY2FSVoenlDfFHNrbMQGish4lxpeXNaeK928kgnMkguKG3/qWSmyL4JxSBYvH4Mw5YygRJ4M03lgomDK0+Tw+z3uHx8vQS0p7U1FwelonBD09anxTop0S/dmsXnvlsraVOTk0aGprNY+tUlGZXxabTSa1X8fGsA3KgFMeua5OBVtyOfXGNjVpf7HoaKmk4YZUqwsG1Xu7FavDv5yiAf39EIt57jlcF0wKD4WwP9ZTYehfOKyhYM4aK1QSFMGxUe3SWXvuaoXS0ChYzxBgX3H1OxDQ+4d1vrxeHH8wiHNCQ5v3yegovu/0YIpge/T6hEK4lmIx9d6ynhpVChmCSZhLR0XGzk6s9rMotBOKtmxUp2YvQcN9I2+EsTfweHDNDQzg3mYR+tFRzTniPcXFqdlZfGa9cPDWVlW67e5WIQiquN55J76/mUAJ7ycR3Ltzc9VS+9FodR0ujkPG1WVfTRnf//73yy/8wi/Iz/zMz4iIyF/+5V/Kv//7v8v//t//W37rt35rl1u3cxiLms/rDbjaAPL7dfLqhAMuk643y9u43lAOlfkT2yWTwXFGo9UGUzaLvmJYFSXGCwU8LDnBGBvDZzs71yryOT1e+3FVr1TSxHjWM+IA6nbjuBYXdcW6uxsTzvVgwc5MRsUjnMYjV/m3Oncej076QqHqCvMXLuD7jPmmUcJwGa72OtWxtjPI87Ori/PV1KiiXbGIPqAHpq0N10ZjIz5HDwS9Qi0tqrTG4z92TAvpUmAkHsdvhu4xBK+mBhNqXodOo2GrxP1QCOF4TlEO5j11dKh6oVOYgsYGa7QsLKh3J5tFrsytt6rQCY1atxv939+P415agpeO1eLpyeX/zAkLBnFsXHBIJnE/MWeEq/PRaHVOjpPRUZyTqSm0xesV+YEf0MK5lQqu4f5+9XYGg+iHUgnCF8yDYZ4WJb1TKQ0dy2TwNz2r0aiGwVDOu65O7yentDzl0GMxnBOuJPOcDg2p4Eg4jBAbFi9l6CEn+DSAnJMohqhxbKPxvbKiAiGX411iaCjDSqen1XvH/CCnZ5ILT04jJZfT0FJK6nd2ah4q4dhLr2lLC64VrrLT4+v14r077lD5dxH1NDHckv1G76zfj/PX2Ih2UJKbCybO+nbMO92ObPdewoylvU88ruVJRkcxrk1P416jh0dERXC4iLTeur0znziTwWemp2E4HT2qCzMbhYHSk8tQb6owOg0mzncYLcD5wV5fRNhv7BuDKZ/PyzPPPCOPPfbYpdfcbrc8/PDD8q1vfWvd7+RyOck5LJC0U/N4F6Hi0PS0FqzlhU1vEm8eDq6rDSYWQmWowV4qUudcZd0JnGz7/ZjEFAroFxbSZKXymRl9jyEVTMzM51XpjnAyILK/Hq4sYEmFtNXU1Gi9H48H/TQwoApwzNdaPWgyCZmqg1fyAB8bU+U1ejroaVpZwT6OHNH6Tqtxhsg4f+gdcKpFOWX4nXVKmP9COJl+6iktGNrejmvirrvUQ0m5V+bwrG5fPI5ra3RUQz95XfEaZBLvd76DfcRieJDtJLyH3pKlJfRfW1u1EhmNL+bH0KN29Cj6mPLVnZ2Y0E9NYVuHDml76+p0op/JYHssDNvSoiIW8/Nab4khYuWy1s8SUWllGjSFAu696Wlsu7292uBOp2HETU5ifGOxxuZm/O7qwrlaWMD1zronXDX96ldxPKz9NTKidarY1zSgvV5Vq2NZAiZFJ5N63llnjDk5CwtqJLa14XtdXTjWfB7epVOnNF+PYa633IL3l5e1NhRXegMBndQsLanISDiM1zlmhcOqtjU+rip+m3nAKxU1UlIpHA/VP525XE5lR+fjLxKB54ehgjS0Wew7Gq0OyYtGNSePRtGFCzgnHg/+pzSzy4Vrdb36Rx6PeqgzGV0M8/txLDQ0Gxpw/ZpxYewWnZ1QN6Rkd1sbjJzJSc0pFcH4PTyM63ejQKfWViyWzM5iMYue5eFhLZq9HixQL4LxsqVFo0rSaR3bnOHaVA5m9Ihx9dg3BtPs7KyUSiVpXuW3bG5ultOnT6/7nccff1ze9773XY/m7ZiJCc1P4KSRBtDKit5AWynlUSlsLxlMXDXcicFUqegKtjP8iIn5hYIq0zz7LPojFtOaNWfO4LX6evzv3DcnftHo3uqnrWD9HeL3qxzzesdC7wHV8qanMdhTLEBEw+1EdMK8XbJZTFZZfNM5qWZRRe6HdXnKZRxHLofJ1OpJIPOYttsOr3fjz1Jmfnpa7wnW3GGODpPxCfMmhoY0/4iFCUW0eCZZXaOlXMbEN5PBg7S9HcfN+kbbpb8f7aCC43rHNjSk4WIeD/qB+XqFAozk+npI57MeUl2demJZ8JaLNKyRxfh6PnQpV09JZOYSMRzv8GEYntEo2nXunCrl8X8RNR4ZchiJwHhuboYHlDkp3d0qRkHPCPM8GEZZqeB6pafhzBkNs6yrw/VXU6OhfPResghxOIz+GR3VPDcmSq+soG3xONrG2kmjo7gmQiH0Ka+FhgZVjhsexgSIYTpUwhLBtUAhm8FBFf44cEANh9XXE/N8RHA8kQg+yxBQFpWenVU1rOlprW3Ful5tbZhcMZ+BxsnCgnqIuOBUV4frKh7X/E6Gv0aj1ZMuhidNT+M6n5tTKXhO2AIB7IdeQ2eivBMa1SzAzYW2SATn+moJLxjG5bBakTcex73NIt7MWYrHMVZksyrSsxrWrKPqZ0+P1ozkvbceXNyhx5bjBhfcnUqV9NCWSloSwwymq8u+MZguh8cee0ze/e53X/o/nU5Lp1OLdheZm9MVV4aHBIPqtuWK+VYGEyc0ewk++HYyGafHgFKxIpqkXyhoPRu/H5OFXA4rmHzwj45isKIEM6Hak0i1C3uvs7CgE6/OTkw8tpOHwVAkThA5QV49Cefq+U4YHsb5yGQwSRwbQ//W16/vuWtqwmdYAJCSulf7PJRKeLCwho0I+qGjQxN4XS5dvWYdGCrALSxoPbTFRRiFPp+GUlCym/k+Tvx+GBD0rkxN4btnzuA429vXhstS2Y3GIpPlnaFLTijvzvujvX39ePfGRnidDh+Gx+v8efQ7PbDLy7g2nLLe6xUynprS5PzWVpVq7+/H9VRXpwsSbjcMAPb72bOagzY+DrVB5jndcgsMju7uasOZHvVsFt959lnNzaK35fBhzecsl7FPhub5/RrCyHCz5maEnQ4NVRvI9Lhyop5Oa34Zw/DyeYzNFANZWNA2JhL4bDyOPuU90d6O/me+l8eD/aRS+L+uDpOk/v7qe5GCCs6QWj4DmAO3HsWiGiVsP3MiolEN0aTqoDO8kJLnLJLJiZzLhfZtJRfOMg8ej4aTO1fcRTTPYm4On+NChLOOktut4Z3MC2QunGHsBerrcf8mk7hHOzqwIDQzg/uWCxks3p5Mbrwo29qK+216GuNTayvGu+FhjMerFwiKRS3o7XyOMKSPnmWmGDBflFFH2ez2pP+N7bNvDKbGxkbxeDwy5VxyF5GpqSlp2SDDPRAISGAPmthUteKF7fPhAUnZ3Z3UYhLZWwZTuazhYzsxmKiQFwiowIUzBCuR0DAWykJz1YbJy/k8BiKnwcTinpyQ7geyWVUAa27e2M2/GaGQCgTwGmOxZErn7oRUSutEFIswCJwT+PXw+7FSnEhoLtDwMM7X6knz5VAqYVLLFXbus6VF85REdBLLGkONjdXGZ0uLToyTSc3nca72O6GxFY3qPo4ehVEzP4/jCwQ0XKqzU43TfF6VCVfjdq/NPVtYUO+EzweDYzPPVU0NjNlEAmFkLIrJEDEWpG1uxkSaCzb0VgwP60Q8EtFJLGP3mR9TKoncfbcKG9TVYX8M3zpyROTJJ/Xae+ghlZ6nYEUmg75i0vT8vHqOBwbQn7EYapYEAmgP8wRoRLndaNPsrBbdZW5dIqHGAz2TiQR+z85iH6USro9wGN/l/VFTgz5Lp1X1r60N36PaYTiM91mvamkJ50oE55H5Whzrl5chGuGU53e7NYeJ8F4tFqvzhwjD9yh2U1+Pe5ATJ2eh6ro6GJdOQ5yqc2NjGs4pAoNuswlWPq95SmxvQ4PmcTBXimM4759CQY2njairwyKOeZWMvURdHcY7huXR48owfz5H6+o0JHajsH8uNDHPsqNDRYUGB3H9M0RcBMYSVSKdz+tAANtKpXA/0gdQW4uxg1EkJi1+9dk3BpPf75d77rlHvvjFL8qjjz4qIiLlclm++MUvyjvf+c7dbdwOYT6E16s1TjixEKmuXbLfDCYqHnHldyffY/y816uDxsKC5l7EYsgjKBS0fk4kgokOq2MHg9UGE71LO61OvxVOgYqrKUdLyeJSCcd2OUngTC7nAO+cdOXzmsza3b1WHGM9KhX1zlAi9dQpDa3aSkQjEoF3YXoa26GcdW/v5SuCFQrwZvChwPyWeHzteebqPz0f60H1L9YmYhFYFoD1+TSsbT1PH4seLi3hOqVYQy6HiT8lr+fnNXwqHFZDhUWon3pKJ+NOeXfKJm+3VlhTk8hrXqP/s37T5CT2MzWFY21r0xzKmRkt7NzUhOMeGRH54hc1vK69HdfnqVO4lnp70VcLC5gALCxgu4uLWqC3pQXGCcPIqGBIbxGLLMZiIi97mUrEUzhmZUWNDxo9hw+rkmIggAnHiROaE5PLoc8jEf2M242xggWGedytrXqemY9FI9DtVjnwQ4dw/FQkrK1Vb5XXi2Ovr9ewYJ8PbfX5sM0LF6oNI143FEepq9Pczc3qCFFJkuqEvIeZE8GFDREVs+jtrb72KU4RjeKa4LW9GipOJpPVnjq/H9dIY+P6gkPs+44O9Ov8vIqnOH8omb9RSJJh7CYM8+W4wMXG8fFqiXEuxnIM2Wic7ujQOniJBBYpTp3Ctk+cwH3JnFXOXdary9TUhHt7dlbD4b1e9TJRBMa4uuwbg0lE5N3vfre89a1vlXvvvVde+tKXygc+8AFZXl6+pJq3n4jF8BBnjQiuBItUrww483lW34h70WC6nPwlETyMKeTAmh5MZI7HManhqk6phIHM68V+RkfVC+X1Vte0YqLzVmplW1GpaCHKZFINWErvJhJXR6mQnhh6E3Zq5HFixuTygwd1YsmwR4Y0nj2Ldnd0bG70cbLj8WDixYnp9DQmuNvB5VLv38CA5i20tuJnJ8eZz6PtnBQ7PTgbsRNHs9ut4Xg7wedDWwYHcd0dOaLhiPk8EohnZnB9HjumAi8M92JNo5kZ9Aml8WnYXInB73LhHmC8/fQ0jOrnnlNvWk0N2vb/s3fn8ZGVVf74P7WvqeydpdOd3rtpFkH4ggiKCCPOoIiIwzDIIvzGDQUVEBwFXFBcGMEVlXFAZ9rBDVxBQUFmdFgbWtm6m97T3UlnT6pSqf3+/jiePLcqVdk63VVJPu/XK68klVpuVd1bec49z3PO4sUmU5zJmD45TU3SWDcQkPdu+3YJqLQR46pV8rdXXpHXwOmUbNfgoGR/NPOmPXL05IauHQsGTeW4o46S62l/Na1IqOsZtSfT4KApYuL3y1nabFa2d2jIBKdaEl2La2gFw4YGM/VPp15qNaxkUp7f2rWS5bKvZUunTTZJH0vXP9mL1miVv0BAti0aNdOOdR2ZVgAFTEl6XYegJ9d8PpMNdLnMyQFAHqurS750apuWlt+xw0xJXbZs/D6kgZqdZm61BLidlt8vNX202H43k2OJqBLo9O3eXvms0Uqb+/fL55mOyXQdrlYlLTXe0DWDQ0PyObxqlXyuaO+/XC5/Km5NTfGTmpGIWV9lL0muJ/QKZyrR7JhTAdMFF1yAnp4e3HTTTejq6sKxxx6L3/72t+MKQcwFOljIZMygRDMB9opoWhbWPrXKfh+AWXx+KBvvTdVM1i8BZi2F9o3xeMxZYD0L2ddn+oPoWRjtr5ROj6+OZy/2cDAzM3t6zABNaSYslTJTvnSqjn2qmabfa2snP4va22umrUwnm6AGB2WAZFn5i8uB/KplixbJh3Vvr5k2tmxZ8Q/mXM7Mo9ZmeXpmOBw2/SemStey7Nkjz7WzUz7c7ds6kcJgqdIqadXXm4X1e/bIYLu1VV7DvXvleK6tza9YBshzX7nSVCDTErLF1kAdDC2eotM+OztNNTmXS3qC5HLAU0+ZY+rEE03hhS1b5J/z8LCUCR8aMvu1TlVJp82+vH+/yRBp5bq6OtMOwOWS22iBCZ2Gtny5DCR0il1PjymFbe/HY1/z2dYmr7VO7dOKfUcdJfv27t1mX9HG1TqdzG7VKnm8J56Q/VWrwNmrUnk8cjLiwAE5/l0uEyQODJigRT8zgkF5TlqNEDAtE3TqWiJhmpUXvmfBoASl9hNR2sxSs5aAPJ8lS8zzXLFCPhO0rHx7+8T7R2+vPB/7WkB7MRROmaOFpqZGjgvtLWlvvdDfb4KV6mq5bHBw4hO0bW1mGYGuCa2uNhUttdx+JjPxDJPC6nwOhwmY9D5YWnx2zShg+t///V985zvfwfbt2/HTn/4Uixcvxn/+539i+fLlOPXUU2d7G/N88IMfnHNT8IrRLtF6JjKXK55hAvIDJnsgolWeijW2LRfNME0nYMrl5IPDPsXN4ZAzvT6f6UujAZM2Lw2HzT93rRqmg36dggQc3CJiLYms66Pq6mR7tPLTwIAM9hIJ+X7ggGxXVZU8j337TFnm3l4ZzBQuCrWvDwFMCezp6OszZ7xramRwViqAdrlk4FRbK4NIDUKWLBm/XkrPtusUHK18pwvsOzvNGfCpcjrNegmdQrR5swxAJxqQaVZMy6WuWVOZA7ilSyWbpBWRNIhqazNTtrQqnfYWswfHHR2mClkwePDZUTU0ZHoe6XHU1GSyNpGI6VEUiZhpaYmEBMs6qH/hBbNmp7bWLIzevFmOiY4O03xXp9xVV5tsklZuGxkx63s0w65lrrXPlT53nRqjVeJ0Cq9Wt9NgJJOR/bStzRS62L/fNGANBiWI0OOr2DHidMrrsXixCZJ07Zn2J9L9rr5ePvM6OkyGvKFBLg8E5La1taUzLFpYQ0866IwD/dLpg0ND8qVnnPW5KZ/P7F92+lmwY4e8Jw6H7J+FdPql3qdOca2pqawef0SHm34e6UkYLaJSGDDV1MhnTTQ68QlsrWbZ3S0n0Y44wmSd9f/BVKao1tebCrT62aCZJ82ya+86mh3TDph+9rOf4eKLL8ZFF12E5557bqzP0dDQED7/+c/jgQcemPWNnI98PjkQNbOkhQyA4s1rgdLrmOJxuU25AyZ7wYdiU/LSaXNmXT8gdLqYLlJsaZGDPhaTAaPfLwMXLQ+czZpyyMGgDKB1rY6uNwBMY9uDKfYwOAj88Y+yLTU1pqCA/XXWUrxa7UkXsvf0yKAylzN9awCZr6zNFnUtiS6yB8yaj+lIpUyRiOl0vddePppt6ugwFa8Aeb27uuTn1lZ5LtoAeP16U+Bgzx4Jdqarrs5M4UokTNBUrMpQIiHXq/RgCZDtamuT92TfPlOQxOeTQHGyAagu4u3ulvvYv1+CF/3yeMxUsqkaGDBFDoaHZRvWrjWZA53W1dNjejq1tck2aAYoGJT9NBo1j71zpwSH3d35Jyg0e1RbawoDLFtmmryOjJgpKFp9rq5O9r9MRo45rUBVVyfvv1ZW0yyMBigrV44PKnM5OYHw0ksmi+l2y3G3a5dZv6THov09GRqS49LhkMIWVVWmTP/goKmsl0iYxeAtLWa6mpbdn0nm0+k0a5QAuZ+WFnn8vj4zJRgwBR8aGyc+wVJbK6/9rl2maIO9OqPuH4C8Di0t5ow10ULndJr+aoODZj11R4d8lmkpcW0MrY2kJ5om3tIix/PoaP6JoeluV2OjfG739srj6ba6XPLZpDMxaHZMO2C65ZZb8O1vfxuXXHIJ7r333rHLTznlFNxyyy2zunHzmVYV0n/+Q0Mm46TBk/7DmmrAVG6aXdI5vYVeeaV4A9bBQdOIsr1dPnj275dBlTaK7OmR6/r9Zi2Evc9Kc7OpLgWY69fXyyBRp/JNZRCTyUgQsXGj+TBsa5P7ePllOWNb7EyuZg56e4Hnn5fL7c0rdfHogQNyHXultKoqeQ4zKQN64ICparZs2fRuq9kml0vuZ/du03hSq6HpP4KXXza/a1PXl16S96Ovb/qV9wBTsUuDpi1bZABcVWV6c/X2mkDb75dgabrTFQ+3hgbTmFS7tC9fPvWz9UuWyD+/rq7iRQB0GkY4LMeANr3VBqPBoPn8OHBA3ruREfNPVqsb2oNzp1OyR7oOZtEiue6BA+ZkgD6PYFDKf2vDV4fDlP1vbJSpfbqvLFokvaL0H7nSzzpdY2SXTMpz17VLWrBDb6+BlAZnhZxOySQFAsBf/iKPU19vMlqA/KzFJNra5P5SKQkCAdluPc7b2uT2HR3ynuqJBMBkAe2VGWeTBtrNzaapsAaiU600qc9d15zpjIXC62hRCyIyampMwNTaarLvg4Py+aFT52pqTMnviQImba7e0SEn1bT5/HTV1clnwvCwWd9YX28KPxQbM9LMTTtg2rJlC17/+tePu7y6uhqDxZp60Dj2hX06bWVkRP75p9OmzO9Um9cClbHAb6L1SwMDEkzognrLMl99faYiWVeXDJ61MIAOpoaHzdoZyzJVxPQ+dbpPLicZj5dektfLniUBTNlgHVjqmWrNcul6pe5u+SCsqQFe9SrTZ0GLKhQrVqADW03TL1sm0186O80Hmk5tSibNehYt8TwTmYxZqzWdtUSF2trkde3uNmfgdQG+NhUFZH/Tils+nzzmvn3ywR8Oz+ysutcrQdO2bbIPvPKK/CPQYFhVV0twN1cGdO3tsh/mcqax6lRlMnL9hgaTWdU1QLGY7FMvv2zeA10ArBXSdI3ZgQMmANBshJZ7t2clcjl5v1tazL7a3W32z7o6eZ+Hh+Wfva5N0mlbLS2mUWouJ/cZCMjfVq0qPhhwOkvv9z6fvH4tLeYMqtNpsrWlmqEW0sxPNGqyKvo1MiKfFcmkqeKnhRVCIdOYUgUCEqzrNDm/f/qZvoPh90//hIidThXUz6lUSr5r+fHprjslWij088be/kRnltgDpupqEzBNRqfl6cmhmVTEtTfX1fWk1dVmHVMlnEifT6YdMDU3N2Pbtm1YVvDJ/ac//Qkr7GWEqCTLkkF3X5/p5ZFKyQGp/7B13Qgwd0qLl1q/ZFn5hQMKB/Y6ONQpPIODMmjXqnRPPCEDnmBQnqc2QuzokNvrNCWnUwaoe/fK9XU7enrkvnQg5PebxeaaldIFmDplSHss6HRArYIVDMog9PnnpcJYa2v+GrNdu2QQEg7LlCc906Sp+wMHJIOiQd/Bpst1MX0odPBN6pYskfvq7ZXXPBQy054AeT2WLMkf/DY1mQzHzp2m3PN0uVwyHW/XLnntdXqXTj+rr6+s4g5T4fPJcxodzV9Hpw1TLctMydVGo4GAWbBbip7dHB2V2w0Oyn7qdJpKe1qqXLOxS5eaLI+eKLDbs0e2q6HBFD3o6DDHmAYb2gj6+edl2489Vh5bGxJnsxJcj47K4xQ2ap0ur1e2XacpzmTf0pMphSIRqeKnGTR7sDlRhUqdhjsXaREhr5cBEtFUud3mxMvgoKkUqc2bo1HzOaMnYUdGJj7GtLn69u3yGaQns6ZL15AODJiZHy4XA6ZDYdoB07/8y7/g6quvxn/8x3/A4XBg//79ePzxx3HttdfixhtvPBTbOO9oF3ht9KfT75JJcxbZHhzNlYBJM0yFZ411sbjbXbwJq/ZlqauTD5CXXpLr6toHzS45HBIMaYd4nV5SXy8DvFRKbqdT+Wprzd+1F0pPj9yfVqTS+1282PTFGR42Z9W1gaVWCdP1Qb298rsGVtXVZqF/XZ0EhvaBr2XJh5pmUFaulOfa0DD9Bq6ZjLxeo6MyhS2ZlMBt3z553IOZFrR0qXx4R6OyrbrmRotEFNIpWvrc9+0bf2Z+qpxOuS89Y6bNYUsNXEdHTTfzSl2Ybi+prOWwNSOocjkzHz4SMWca/X7TPFYDK/2+eLGU+NbA5oUXzP1pw+Jk0vTqaWmR6+7aJZdpsQe3W/YnDVC1Ma7LJcFXOm1aGmgPr82bZWBQVydr2ZYsMVk/t1uCZu1ZMluVOw/VehqHw5To1ul2y5dz3j8R5aupyQ+YnE75n6hNt7UvWyRiKqVOdlJCi7joNN9iBVkmU1trpuXlcvL5raXFJzrxRtM37YDphhtuQC6XwxlnnIF4PI7Xv/718Pl8uPbaa/GhD33oUGzjvKSNXbXhmDZo1HUt9il2+s9by4/bByEaMKVS5S0hqYN4ID9gsmeXmprGD2y7uoBnnpEz3G63WdAcDssZca18pWu9dBrSX/4iA8CGBtNQMRQy08hiMRkkjozIYDAUkvvyeMz6Dp3nq9OX6uvlTLNWmmlpMa+1FlbYuVMGWHoGemBA7uOll0ygtHSpfHk8ZlCfSsnAUrNfmzfLtmmVuUWLSk/tyWblNtqobmhItmtkRB5fyznv3Ssf3KVKhE9E9514XF6Pqip5TRoaJh9Aer3ymHqmTHtNzITDIcHfRHTqpk570HU5TU1Tn66nhQx07dl0xGIms6cBUShUOjjQvjZ6G0BeI+3Xs2ePvIda2GA6a0nCYXktNAOkayP1ZEwwKJdp1lY/V/r7xy80bm01wZ1mjbSiXmenfOntqqqA004r/tppBngu8XrlJAYRUTE6qyUWkzGJ2y3/u3t75f+wrjstXO80mdZWOfHZ2yvjh+merNGZKqmU/E+0N761N7GmgzftgMnhcOATn/gErrvuOmzbtg2xWAzr169HmJ3ppkVLYwNy4OkA2OGQQYr9zIAGC8XKh+tiaD2rXK5pS7q9Pl9+xsTeO6kwuxSPA//3f/Jhoc1ge3rMtDtdNN/SIh9G2vMnGjWNHaNR0w9Je7i43TKA1nULLS3m8cNhk0nS6mW9vVJ298kn5bVctUpKfeoHl55h16IVqRRw8skmkNm92wSLq1bJ7bq6zBomu6OPlue8ebNkBdavN9PgtHGoTsvUPis6ZdO+8N/plAGs2y3Znz175IO8sdGcAWtrk9dRy7Trd91f7I1402kZqGvAevTR8kHu800tCK+pkddX10DZX7/ZYFnyOmiWTuk/igMH5LHr600J6VL0vUwmZf8sLH5QytDQ+Me3V30MhSRQXLTIlL8eGJDt0rVYujYmHJbLXnnF9LlZvdoUidApaJPp7pbnuny5TI8r9pqPjJieRLGYyVJplbVMRva7wtcgmZT77+01zWsdDjmeTjqJzUiJaOHwemXsEI/L/4L6enPiS4MVXV8JmLHCZP8HtQ3JwWaZDhwwzXX9fvOZXSk9OueDGTeu9Xq9WL9+/Wxuy4JizzDZO78DMqDTMtsdHfJdB63F+i3p2WldjFgOxdYvWZYpQ61NT9XoKPCHP0jQ0NsrB/zateasujaA06xHTY1kd3p6TGnhbFYyTamUDOJaW+V+liyR18jtLl062OUyFfe0vKeuNWlokO2oqpL70KqF2vF75075fcUKCeqWLzdT8fr65D4bGuR66bTp06DZNo9H7jeXk+tEIvLe6TqtSET2hcIso34Y6+PodEL9YLYsKZyga1w2bTLlge1FA7JZcx17cLtpk2zH8uWmct50tLWZaQA7d8oC+elmPLV0uQbF+qWZGcBU8Wtulv3dHsj09pozda2t4x8/kzGNb3Uf0l4WS5eOv75O0ezuNvu49trx+02xknTaPP4LL5h+Gnp/Wh5fMy8aLMXj8h6sXi3Xeeklky2crMloOi2vVVeX3PaFF8z+oSVm+/okoNf99/jjTUNZbXBc2KcsnZbPHS01rVwuOSGwbBmDJSJaeHQ98uCgqQqrler6++V/tK530hOSxZYhFNITwXpSeLqFjTRg0tknOuNBxwblbjkzX0w7YDr99NPhmGAU9MgjjxzUBi0UGjDZ+xH5fDKQ0ulfOggGzFmCUuuYNGAql2Lrl3p7ZXs9HhmUadEDnZK2ZYsMRgMBc2Y+HpfBqMMhWR+/Xw7+4WG5/iuvmDLjHR2SzdAUdG2tqaKmAYE2WC2Uyci26GJJvx94zWtksNjbKwNWfa21Up8u4u/oMFMItUnc2rVyP/398p7t3WvO2GtFvJdfNmfrdc1Ef798aVGKbFbus75eXrNlyyQArKoyQWAuJwUndDrAyIjJ4mkFrERCXs99+2QbdD+yGxiQIGHZMvlg1ymhqRTw4otym0WL5HmUOuTjcRmAh8Py+q9YIc8zFpPvGiTr42smo9h7EovJ+1lqP3a55DVZtCj/H4p2SrdP1dPKag0N8ny0muL+/WYq3bp1ct2ODhOkLV8ur10sJr/bt0Wn/mmpbX0vAZNt7O01mUC/XwKMJUvkvXI4zFqg3btlmzye/N5Ty5aZ6Rl1dRNPrdy7V+5Hy+prmX37P02dkmFvZtzSYvou7dljpgECZt/XqcHV1fJ89cSH/k5EtNBoc1qdneL1mhYcQ0OmDUlNjfwPGRqaWsCkU+D1f9hUZxgobeytJ/hCIRkPaFU/BkyzY9oB07HHHpv3ezqdxqZNm/DCCy/g0ksvna3tmvc0+6HpWm1YmErJAeNyySBIF2Vrw9ZiAZNWeauEgEkzTDogA0x2adcuGWD390vg4/PJWXddQwTI33p65ENHm78tXiyD8pdeMuuRtIljc7N8YB1xhAzmvF5T0a6w7wsgr193tzyGpqwTCdP/aXRUttHpNNXLtPxxW5t8sC1fbkpvJ5NyW59PgqZMRs70a4GKPXtkEDwyIn9zOuX6un0vvyyBi5Y510xFNptflaynxwQdfX1yv729cj81NXKfbre5rvaeqquT+9a1LPpe6f6ya5cEpoBpvNnXJxmiQEB+HhiQQb09SInHZRCtU/i6u2U7liyRbdm+vXjPLQ2wamtl4B4IyPuwf78EIYA8zuLFZo2Plo93OOQ1KnX2LRiU5xuNShYpnTYBQjgsr9noqOwTwaAE7YDc/9698vq+9JI8B/s0Cg3GNVDYts3s70rX7dTWmoBVp1ceOCDPTwsoKI9HsnD2f2bhsDyONj5ev774dIrhYekTlkjI/qg9hzQA14wlYLKvdosXm1Liu3aZSk96m1DIHBNdXfJ8tfgHEdFCFAiMnz7n98tnvxaiWrNG/rfremVd7zSZlhYZF+kMiZlkmbq75f91IGACJvZimj3TDphuv/32opd/6lOfQsw+uZ8mpAeDfWCmA+RkUgZaK1fKdx2cezzFg6JyV8qzN9bUDJNml7xeOcufTstgOZ2WD5q2NvnSqVQnnijXGxiQ62nDzmxWBvebNskHkscjA+dcTgKBM86Q0sButykHrlXF9uyRL10josGaDlp1HYeecU8m5bZLl8qHjz6XoSHZjtpaU9Wwvl7ue/lyOYNkrwi2cqUETS+/LAPbF1+U16G5GTjuODPdLR6X+6ytBV79atnGdFo+5DTFv22bDKJ1Mb/HI4GKliFtaZG1KzU18lxiMfnQ3rJFBtOaMdPpnh6PDIZrauQ59faawEZfa11T5/PJY+3fLwHIEUeY7J69z0QkYqoHdXfL7VIpeY5LlpggWntuDQ7K+zQwINuh008Bea5aGTEWG/9h39trzuppqfFo1AR2mvFpbzfFRnSqak2N3L9WodPjJRyW97GjQ16nzk55D9vb80tw29exuVyyn3i98lrpl752ej89PeMDR49H/qEtXVp8Cq2Wsk8mJUNYeLYxHgf++EfTwPTYY81r3NoqXzqlVd9rO93XIxF5v7q6JHhsapLXtLXVTOVMJMzraK+GR0S0EBUr0rBkifzPikbl/3ZdnVnvpNebTCQin9cjI/L/fbrVZrVp7uCgPLYuJ6iECsrzxYzXMBV617vehRNPPBG33XbbbN3lvKZnHHTAlMnIDu/zyWBKF4ZrIKID3kosLa5n2wMBEzR0d8t3zS7peoiXX5ZBl1bBe/FFGZi1t8tzW7pUnvPAgCmPuWePaRQZCMiAMpmUMzmnnCLfR0flelrQQQsZaLGAgQHzmldVSXC2d69ZI6VTopqbxzeQK5yC5HBI8HDEEcVfD7dbBrGrV0sWYN8+s4YlHpfXQLW0yAduOi2DVB2ct7bKQHVgwEyPAmRwqxX3jjxyfHEFnZ62dKkM7nVNUTwut3M6zfSxmhoJVEMh0wi1p0de85NOkm3u7pZsUSwGPP20DNBrasz0uMWLTWD1l7+Y8tSBgDy3zk55rRcvltelpkbeq85O029J+0Xo9LPC8y6BgGyjwyH/jFIpU7VNM7BKGwpGIvLcdI2P3s+aNfkBnL6fgLwHO3aYKki6Nkh7dm3daqaY2qfRldoHliyR91Sn3unXZOu6NJPzyivy+rtc8p76/fL+bN1q+iuddlrx0rWhUP7lWlFxYCD/M8TeQDoalWyoBkuWJSdrdP2TTtsjIlqoihVp8HpNE/e9e+XzsqlJZmp0d5tCQJNpbZXP/Z4eM8NoOtul/w+1+rL9ZCQdvFkLmB5//HH4OVFyygoDpngcOOooGdCMjspZ4HTarJ/RQVuxiivlDph0MbxmZNJpsy3a4HFoSLIlsZhcduqp8mETj8uHTzAogzqn01R7aW01vamcTnkttBHounUyuNPy3sGgXNbXJx9aeiZc5/Tu2ycD3PZ2eXwdeGtVGe3FNJUzQVMVCgGvf715DnoGKhqV34NBCRq1CEFnpzmrVFUlU/xiMXldNOuUSMhzW7FC/l6qAk8kAhxzjNxWy0w7nXJ/Om3LsuTDXLMiixfLNjQ2yvsVDktGbP16OaO2c6eputPQIK/d0JDJ+DU2mlLqkYgJnjSA1SmNo6PmMTs7TREFnaaq/5C0oqEGkbmc3MfQkNz30JD556DNRAuLESxeLNvS0yP/tOxBRGHg4vHIa9rTI/vLyIhM0Vu0yPQk8vkk6JpqBUCfb+qFWDQY014e9fXyPDs6JMMai5nGtsEgcMIJExdf0Iyr7ut2Lpdsl2Y+R0bMnPvt2yXjpuvjNJtGRETFs0xNTfK7/i9fvFj+j6RSxds4FFOYZSo8eTsRrXqqs3t0bXvh9HGauWkHTOedd17e75ZlobOzE8888wwb105RLicDSJ1eBJgsh71JbSplChokk3Idv398vyUtHqFB1uGeNlO4fkkzBIGADLZ0Mfru3TKoPe44OQPz+OPyHLU5KiCD6ZdeMpXcamrkfrZskUF0KCQDyWxWAqTC56pTtfSDYmREPoR0WpQ2e921ywRJekZ/Kh9oM6ED5kBAPlQtyywOdThMNkjLYtszF9rnZ3RUBr/r1sl2asnwiXg846djRSLy1dZm1jvpYLqqCnjVq+SDur9fzpQNDMiZs2OOkdeos1Our5XrNDuhpdxf9Sr5vaND9vF4XH4OBk3zYruWFtmndbu0aarSaXydnaYRa1WVBDFLlsj+HgxOfPZOO7BPVWOj7J979sh+q2urgkEp4nAojq9du0yAqQGuBrk6bVWP+8ZG06upmMFB2WZ7pk77g9TW5k8ztBsYkO0YGjJTOgHZV9jIlYhIFMsyFftfvmiR/B89cGDq44uWFjm53N1tGoxPlTbSjcdl3JHNjp+xQTM37YCpuqAjpdPpxNq1a/GZz3wGb3rTm2Ztw+YzLbetaVfAVMTTSmi6/gSQgVosJgNG7QlkH8Bo8Yhk0mQgDqfCDJMGUHr2e2REDv50Wi5bu1bOvPT0yPPVogiJhKyl0IHaEUeYNTsjI/IB0N5uKulN9AGkZZ11GlE2K/cRjQLPPy+XhUKmiENt7ay+JBPSjJiKRMyi0W3bJBCwBzq5nEwV03Vbs7Hw3u2Wfa+pSQbI8bh8uLvd8nqEQibLsm2bbG9LiwRs9u3SgiT2EtqArAEaGTGZvb4+eQ6RiAQjdXXy/mkz4UL2QMmeHdHphQcOmGxUY6NZwzVbvF4JjgYG5B+e3y9ZvemWWp+Kri4TLAHmZIlqa5P3w348NTfnb0suJ0HugQPm+NEzjrW18ppPNiWktlaet71gRyRy6E4kEBHNVfZS4JplikTkc3RgQE64rVol/8MSCfn/PpWG3tXVZv1TX59pSzIV9pNhOv0+kZh64Qma2LRfwrvvvvtQbMeC4nKZQaIOYnI5M9XG5ZKdXAdNwWB+n6ZizdB8PgmY7GtBDofRUVP9TYMAPaOhGaehIVmPo2uzcjkZ2Gm1tOZm+X3XLvmgSSYlCxUMyt+feUaCLV2fY1n5RRmmwuWSD7Ns1pSGXrZM7mOitSiHy5IlZp3R9u3yPJcskfd1zx4TCC9fPruPq4Pqwg/yRYskqNGGsPG4bFcgYPZHe7EDDT7tQUsoJNPXdEpkfb28d9ofoqND9gvtR6ZTT51O+Uek+78GdzU1Eizo1EZ7ZTefT7a5oWF2m/RpUY5DZWjIlH7XYiN6HGvxFy1WUcrAgLyWeoKlVPn1qQiFJCjevl2Oa1bFIyIaT2cuFDac1WnjOsW5sVH+fuDA1AImQP73xuNy39MJmPT/uX38qCfgGDAdPL6EZaJn5C1LBjWaAdH6+YUZJsAs/i9VWnx4+PAv8NMyxOGweT6acdJBXl+fZJOqqmQApmuUHA4JDLSwQ3+/BFMaRC1bJut7du+W59XcLAN2v98soJ+OXE6yBYDMQa6kRexerxRx0Ap4Q0OmMEN/v1xn+fLD+6Hndsu0r6YmCZq6u02D31LXt0/70uBJp9sNDZn1WLoYNZsdf3+ZjOxHwaC85/YgSIs6ABJQ6L6VTJp+Stp8+HBPI9PKfvZCCjpdUbN3domErAsDZHu1uIjbXbyQQ6FsVp6zfSqfVro7mEyY1yvZ3cKpv0REZBTLMhUWgFi71kyR1jHeZOwFkKb7OazrmHR9r1bKm84JZipuSsOv2traCZvV2vXr6I4mpM1VdUClZbd1DYc2HAPMWhftw1QsYNIsSanB7KEyPCzf9QCPx81z8vnkee3da/oV1dfL+gjt21NXJ0HR4KAMAEMh0/jNsqRyW1eXqfym2aiZHPxaYU4HlpVGCy9oyXItUQpIgHc4M4d2brc8flOTqdqXy5mvTEb2g0xGPqh7e4sHT5ohVJZlTgxo8DMwIPelt9f1ecX4fLJdzc1y2wMHzILbzk45lurrZRs0gND+RMPDsq9qxUad8jaTgFQD8Z6e0tc5cEBev6Ym2ZZsVrI42aw87nSLKkSjpn8SIP+gW1pmN8BhsEREVJo9y7R/v4xxHA75nNf1wfG4jHP6+mQMsnLl5Per67/1hOJ0xjv2GSCFY0k6OFMaHtxxxx2HeDMWHrdbduZczlQWi0ZlgGcPoADZ+bUghD3VaqcBk97mcLAsM/0uEpHv+rtml4aHZfDq9UqqemBArqOL9V0uGUwODMiHzdCQWeOyd6/0M7Isue1RR5lpidMNmJJJU156yZLZnbY12/x+mcrW3y8fwqHQ7FbvmymXq/R6Fi1LPTAgwa89eNKmrlo2P5PJ/7I3TNW+XQ6HnI3bvl0u0+l2xTInTqfJKg0Oyj+qaFT2s1jM9OIqduwkk/mLYn0+ua+pBtSJhKzN0hMVdXWm0p1+aWZN1y22tJhssNdrKj2Wel2z2fGvl5bt9/nMmjMiIjq8NMukPQZra+X/QH29fOb39cmJUP279gWciK7P1Zkm0xnveL3mhDXA5rWzaUoB06WXXnqot2PB8XjyAyZADgxtUJpO50+vCwblepMFTJnM4auUF4/LYM7lMo9fWDGvs9M00GxtlQHj4KB8GHi98oEwMCABVyAgzy8QkL8/9JBcNxCQ6msNDTL4BaYfMHV0yOBTCyzMBVoqey7QUtiRiGRLtJHtwIDsk319+YUNigmF5PnW1sp71dNjSqTu3WsKSIRC8v6HQvnFJhwOs+ZIS7n298s/DM2EOhxyOy3fmkqZaop6Jm7vXrn+ZFMg+/tlumguZ4pl6IkDu5YWeR3275f9u6NDLnc65WxjsWM1FjNNCLVfVKHGRjmRUMnBPxHRfFZVJZ/DBw6YRvG9vaYQj8Mhywuqq03V1anMKKiqMgHTdGfEBIPyvzGXk/9xh3vm0Xx1UCsiEokEUgWj90ixEQONowFTJmPOBGglOJ/PrAXSHkTauXl4uHjApH2KEgnTKPNQ06yAfb2KPcNkWaZgQVubaZiq65d0YfvwsFST0TRydbVM09u+XX5fv14G0vr8gOkFTP39pl/QkiWz9vSpBHvwtGSJaZo6OGiCC/uX328qtNktXizBRn+/WT+lVfKU0yn7WiRi+nkBpr9Qc7PJ3vr9ct3CAEOzZtmsKac+PCzl7Zcvz58KqVnV3l4zXTIclizRRMecNvzt65PAKZ2WjKp9P7Ys81wLM8XaiNDtlsdpaMif3khEROXR1CSzILTP4cCAXB6Nyv/DgQFTkbavT04eT3QyTqep53IzW8eka70BlhafTdMOmEZGRnD99dfjxz/+MfqKnDLOamUCmpCuYdI1NQ6H/Kyltx0OGTRps8zJMkyAydDE48XPdM82PWuvj6Xbr2Wzo1HJMAHyYfLSS3J23e2WQbSugQkEZPBn79/0xBNynbY2GYxqNkDXR011QX8qZbJSzc3mQ4QOD51aEA7PLFh1Ok0Jec0GxePmezYr+6Hui263WYvkcpkvp9NUotS/ud1mDZaWR3e7ZX/bu1eOpa1b5Z9bOGyCPi3GAkxv7ZA26K2rM5lZzW7F46YRrz7vujrJIukaRiIiqkwOh1nTtHSpqQTc0yPjnle/2pQLHxycuF3D7t1ynb175cThTNYxaXN4BkyzZ9oB08c+9jE8+uijuPPOO3HxxRfjm9/8Jvbt24fvfOc7+MIXvnAotnFe0kFbNisHmtstg6VEIr+0uAZMuoZJ6+rrgMsuGJRB3eFIv+qZDyC/ootuh9MpHxKxmAQ7OjUqmzVVz7q75XmtXCkp6yeflOd44ICcwQ8E5HJtaFrY72kyliVVyLSYREvLbL4CdLhpBSJ7mW+dbqfroDIZ+UdzsEIhOUGRSklGyE7XZDU0TFzu204X72qGLB6X47hwup3HY9ZrsQwsEdHc43DICdrhYRnnbN0q65Jra+Wzf2CgdMCUTJoZMQ6HjKPa2mYeMGUyplgYG5AfnGn/S/7Vr36FH/zgB3jDG96Ad7/73Xjd616HVatWob29HRs2bMBFF110KLZz3tEMk/Yw8njMuiXd2e2L9XRanr1HU2H/oMNZ+GFkxJRE16xN4fqlPXtkW0Ih+YBwuYDVq2Ww2dkpQdGyZcDRR8sHi8631UX07e1mrZMugASm/sHR1SUBm8slU6t4ln7+CQTkq6nJTGMdGZEARb/sDXbt2STldJoTGE6nyfoAcn+joybbU1c3vt9UKdms7IPaW6wYLSGuX1O9byIiqmyrVsnSgr4+YNMm4IQTZC2untwrdlJMq60Gg3KyeP9+4K9/Ld6aohSfz/Q31GCJAdPBm3bA1N/fjxUrVgCQ9UpaRvzUU0/F+9///tndunmsWMCk2aNQKD/DpAqn5RUGTBpIJBJm7dOhUlhOHMhfv6RVwWIx2ZaaGjn4tdfMjh3y/Nva5Ov3vzfrmTIZeS7t7eYAD4fN9L6pBEz6+IBpAEvzmxZ0mErFOK0+p4137VIps3BXy9y73WZd1lTuu69P/jHqFDtA9mVt/Ktf/AdGRDQ/OZ3AMccAf/yjBD59ffI/YHRUTgAX9oLM5UxxpJYWGS91d8sMnS1bJEs1lfXpuo5YKy7rmqipzoig4qY9pF6xYgV2/q3b4rp16/DjH/8YgGSeauZK+bEKoEUfdOBmzzDZm9fa1ytNto5JgzDg0Dew1YIPOoDM5cxUwFBI5uDqNCm/XwKrRYvk73v3ynWrqoBjj5Xnv3+/ZKS07PSSJfJcqqrkA8bpnPqUvGxWpuJZlinvSWSn02CLnVTwemXd0tFHy3TRqirZv3fulN5HuVzp+43FgM2bZf/PZGTfX7FCqjwefbSccWxtNT2miIho/mpulpPCqZT8/9D/OVoYwk6rynq9sq67vl5mxzidMtV869b8k+gTqaqSMWEmYwps0cGZdobp3e9+N/7yl7/gtNNOww033IC3vvWt+MY3voF0Oo2vfOUrh2Ib5yWHwwyYcjn5WdcwLVpkGo4VBkxutwQhExV+iEYluDhUnZ2zWTNlqbBhrccjz2X3blPKu6ZGpkz5fPL8Ojvl+R97rFx3504JmEZHzdoRv9+c2Q+HzXoPl2vibFEuJ4+bTMp9T7chKJFyOGTfra42zXD7+mTfX75cji+dBqgnBzTz6nLJGcJFizjFjohooXK55ARwLCZBj8sl/xOGh8evRdfpeNqLEJCgKZeTMU0iITMXli2b/HEjETNzKZlkL6bZMO2A6SMf+cjYz2eeeSY2b96MjRs3YtWqVTjmmGNmdePmO51Sp+W0tcqczyc7eixmAhPAZJgymfzL7bQ63aEs/KBT73SerP2ycFh+3rlTDuyVK+XL55MUtNcrHxqNjXJ5JiMV8TTjpOtJdMqS3qdmlwqnIQLyug0NmZ4FmgFYvrx4o1Oi6XA4JCtUVSX7dSIhWSSdelqYcWpokMpGLNpARET19XLS2F4l2O2WMYv2Whwdlcu1mqrSfkzhsOkv2NY2+f+XUEjGXbmcjCtZKe/gTftfekdHB5bY6gO3t7ejvb19VjdqofD58s8+a8WsZFICg97e/J1ce850d5sz2YUOR+GHwnLiQH7Bh717JXWsxRa0kWg6Ld+rquQDpK5O1jJpdmnNGgl4qqokmEom5TWxr1+yr09Jp2VBZWHw6PXK2X3O16XZVFUlPcF27TLBOWCyoFVVckywdD0RESnN9lRV5Z9kGxw0AZNml2pq8tcp6TgmmzVlyXt6Jq/6q5WVvV45yceA6eBNO2BatmwZTj31VLzrXe/C+eefj1p7jV+aFl1zlE7LwaDZGp1Ol8uNDwa0WWWpgEmzMocyw2RvWKvsJcWfeUamLlVXA2vXShYpGpUPgh075PLGRrnN3r3y3eeT10HLRjc1ybQ+PeDtGSzV1WXOyIRCcr/V1cWzUESzwe2WdUjajykc5v5GRESlORwyrkkm5YR3ba0EMUNDMs7TQkGAKYyltDpyNitjLg2Ympsnnu6t4yK/3/TnnG4DXMo37aIPzzzzDE488UR85jOfQUtLC84991z89Kc/RZIryqYsk5HU7N69Zj6rrmMCJAjQ9RGjo/mL/DRgikbH93AB5OBwOOTgOhRzVtNpE4xpwJRMynNyOOTnri65nvaS0e1Mp03pZk1P9/aa0s8aLC1ZYp5zOGyKYejvgNxGP2BWrZLArLmZg1c6PGpqTFNZIiKiidTVmUJfgAQwuZwETf398rMWyLLT5u+AjKe0QFixohGFqqpMhkkr5dHMTTtgOu644/DlL38Ze/bswYMPPojGxka85z3vQVNTEy6//PJDsY3zjsMhZxk04gdMpTyHQwIdl8sUfigMmByO8SXH7fetU4IOxbQ8zS5pAQrAZH+0QW1npymhrM8hHJbbBgJyEI+OysHb1ydn67UHzeLFkr4uXBMFmCIQgDxONivPdSqlnomIiIjKIRw245WdO2WclEzK+Een4xVml5QGUSMj5jrd3ZM/pk4FzGTMkgiauRl36nE4HDj99NNx11134fe//z2WL1+O73//+7O5bfOWVnpzu00DzWxWgic9Y53LTVwpL50uHRAdyml5xabj6bRBjwc4cECCGZ9PvrTPjcslHxaplARHQ0MSLO3ZI8+luVn6Lul6kGIBk/0x9cOi1AcMERERUaVYtUoKNmhD2RdekK94XMZJpVqgaIYpGpXrOBz5DdZLsfdiSqWYYTpYMw6Y9u7diy996Us49thjceKJJyIcDuOb3/zmbG7bvKaBTzZrpuRls/lTztzu8Tu5y2UKH5RKyR7Kwg8TrV9KpeRMiWWZHkqZjAROliXPWZvTDg9LsYeRETmoX/c6Ezy63SZg9PvNY9o/NBKJiT9giIiIiCqFzycFrY4/XpYsaAPbkREzZa8Y+zqmTMYUipgsy6QBUzZrZvXQzE276MN3vvMd/PCHP8Sf//xnrFu3DhdddBF+8YtfsFLeNGnAlMmYea0aVAByudbQj0ZlzY+qr5c0bne3VKErdt/A7GeYhoflgHM4TMCUSJjHGR2VNUmABDNVVWaNVigk25xIyHVqa826paVL5TlFo/KBohm1cNgc6Po7YD4k6utZNpyIiIjmjrY2Ge/ozKLR0fwxXiFdxzQ0JOOoRYtkhs7AgNyXvaqenfaz1IwUA6aDM+0M0y233IKTTjoJGzduxAsvvICPf/zjDJZmQNfjZDJywGiZSY/HrGVyOotXytNykl1dpe8bkINDszYHy7KkSAMg0+C0W7UGLy6XPJfBQXlcrc6iIhH5UNi9W75rqfFIRKbi2QtJaGYsFDLZK79fXpdUSh5Dt4OIiIhorggGZZzW2ChjoeZmOVk8ES1I3dkpY61wWMZlepK6GI9Hrqfr3lla/OBMO8O0Z88eOFiX8KDZU6z2gCmVksIOmnXK5cbv5C0tcgBEo/K3wn5D9koqWnDhYHV3ywHndksTT0AOWq1U53bLzy6XBDxNTaZiX02NPJeXX5bgr7YWOOooYMsW+fvatflT/TQQDATGlxPXxZFVVaxQRkRERHNPfb2MlfbtkzFSNDpxASudhdPXJ+1ZFi2S8dFEJcbdbhlr+nwyFmTAdHCmnWFisDQ7PB7J0ni9EthotTzNumg57mIBk89n5rDu31/8/mdzWl46bR5HFywCcmYjlzM9lLq7Zbu1dLieMWlqkuvu3Cl/P+EEM5UvFJLKeJpVCodNCfFAID+QyuXM2ZRFiw7+eREREREdbnV1ZiZRKlW6t6Zde7tZqtDbK7dPp6XQVilVVaYXUyJhTs7T9M246APNXCYDPPusacyaSuVnmDRgcrlkelux4g0637Wzs/hjzGbhh717ZftCIVNkwbLMdDyfT/6uxRgCAXP9cFi+a3aprg5Yvx7YulXuo63NrFny+00TN6dTXgN7IDUwIK+d12v6URERERHNJR6PjPW0arCeHJ6IwyFFI/Qk9ciIjJl05k0x4bC5fiLBdUwHgwFTmezbJ6lVrYQHyI6vzV0jEQkM4nHJxBSuRdJpcb29EkQU0oDpYDNMsZg5e7F0qbl8YEC2VQtTJJMS6PT3y7YHAqZBbXc3sH273G7tWvl+4IA8z+XL87NIGiAFAmbtls8nr4W9VwETnURERDRX1debgCkeLz6WK+R2S3lyl0vGRV1dMlYqNdbTKXkOh4zn2Itp5hgwlYHTKTuuFnxIpWRnzmbNzlxXJzu5plALD4a6OpNmLVZe3D4lT6f7TZdlSZ8kQIIUvU9AAh5AtnlkRAox+Hzys5b7djrlw2DbNgmaamqAI4+UwKe/3zSqtQdM+jzt0/HCYdNzwOGQcpxEREREc1VNjQQ9TqcETFPJMgEy9luxQk5Y61KFUlkmr9dUNWbAdHAYMJWBrl3yek3/JUC+p9Pyc12dXC+TkesUzm/1eqV4gmVJtqqQNo3N5Waegu3pkQDGXugBkIMuHpezInrwaaYJkG1etEgCnc5OCbpyOQm6WltlPVQqJR8WtbX5FfL052Awv2GtZrlqa2V7iIiIiOYqp1PGQaGQBEtTWcekIhFgyRK5fSIhY6Ri65O0Uh4gJ50ZMM3clIaexx133JSLPTz77LMHtUELRSAgQUcuJwdNNmum5AESJOg6ptHR4h2dW1okIOnuNvejHA4zrW10NL/E91RkMqbQQ2trfpBy4IAEM6OjspZo0SJJC8dipiR6dbXcpqdHij1UV8vc24EB2d5AQLbfnlFyu83vmq0C5GDXbdFiF0RERERzmQZMXV3TC5gAOQl97LHS8iWZlKCpcAaOxyPjSYdDxlezsa59oZpSwHTuuece4s1YeHROqcslX6lUfobJ5ZJAwe8309EKNTbKwRCLydmJwkIIGjANDJga/lPV0yPbEwjkH4DJpBzYe/fK+qP6etnOeFy2Q/slBYMyTS8Wk69gEDjiCFm3pdPxmpryp+PZpyRq8QfNXKVSphkuERER0VynhR8yGRkPJZOT92Syq66WQGjfPpmaVyxg8vvlhHQ6Pf2gjIwpBUw333zzod6OBUeLMrjdpqykPWDSLI1mWorVzw+H5WtwUIKiwoCptlYOoIEBmRZnL9owkVzOVMArrO+/d6+czQgG5cBsb5eCDtGoCWpqamR7q6rk+sGgbIvfL4GY9mlqbjZ9nMJhk13SYheA3Ic2qq2uzs+iEREREc1VLpeMmfx+My2vsXF699HQILNwRkZk7GRfb67LP7SFjY6naPo4/CwT3aGdTjlg0un8KXmACZiSyeI7eSBgmsJqs1e7SARYtkx+7umRQGcq+vpM+W57Zmp0FNi0Sf62eLFMsXM45LHjcTOFMBKR3xMJkzFqa5PbR6Nyv6GQXM8+Jc/+s71hrT73mpqpbT8RERHRXFBdLWMdnS00XW63Gatpr0qlyyTCYRljDgzMvBDYQjftgCmbzeK2227DiSeeiObmZtTV1eV90dTomiKdkpfJSLBkD5h8PjmQcrnSZwWamiToGh4uPm2vvl6yQIBkjfbunXzbtAJeU5PJLuVywOOPS1ATici8Wd1ufWxtWOvxSFDU2ytZs2BQsknxuFwWDJrgJ5eTx9BO1Pra6HPxeuVyzbgRERERzRe6jml0VE5YzySg0al4fX35bWj0pHxVldxvPM7CDzM17YDp05/+NL7yla/gggsuwNDQED760Y/ivPPOg9PpxKc+9alDsInzk07J03VMgGSS7AGT223OCsRixQ+iqipzoJUKqnTqHCDB0ERB0+CgbIfLlT8X9qWXJOXrcgEnnyyBjG7z0JBsYyYjz8fhkG2PRuX5NDbKNiaTElx5vRJA2TNKuiARkPvK5fKLQFRVmdeJiIiIaD7weExl5OHhmRVmqKqSk82aRSq8/1CIvZgO1rQDpg0bNuCuu+7CNddcA7fbjQsvvBD//u//jptuuglPPPHEodjGeUmn5KXTsiO7XHKQFAuYLEsuL9aYLBw2DV+Hhko/XkODWcN04IBZo1RIs0uNjWa9UFcX8OKLcrAdfXT+/NreXinioMGMns3QAM/tlutblmSNLEsO6rq6/IAJkN9zufxCEJyOR0RERPNZba0pLz6TaXmAOcld2JPJXlp8dHTmrWYWumkHTF1dXTj66KMBAOFwGEN/G6W/5S1vwW9+85vZ3bp5zOeTKD+dlsBAG5cVBkxer3zPZosfRMGgTJHTaXsTHQiNjbL2CBg/zxUwxSUcDikVDsjvzz4r29XaKpXulGVJyfCREQl6XC65zOs1xRzs2xeNynctVmEPmFIp+fvOnflZJZ2ax4CJiIiI5qOaGhkvjYzMvDBDfb2M3+Lx/CyV1yv3rQXGZhqQLXTTDpja2trQ2dkJAFi5ciUeeughAMDTTz8N33RqIS5g6TTw8suSuclk5KyC2y07uPZjAuQyt9uU1i62RsnhkIBEiyYUC4Ts9AzE6Gh+cAaYwhH19fKY6TTwwguSQYpEgFe/On9aXE+PpH7tQZ9lycFoWaZcps8nz3NoyPQECAbzey5t2wbs3m3WM61ZYx4nFJLbEREREc03gYBkmSxLZvoUa0I7GXvxB3uWyeORcZXHY9ad0/RNO2B6+9vfjj/84Q8AgA996EO48cYbsXr1alxyySW4/PLLZ30D5yOPx1SU02p0Wikvm5XLABMwud1yWbGACZBsTW2tBFwHDkh1ulLcbglAgPyDxl6Jr6lJDloNYnw+mYpnL7qQTsuapuFh00xWt1Gn5TU0SGCUy8k2jYzIdLyGBhNYDQ7KY2gFv+ZmYP16TscjIiKihaOpScaHw8PFW8lMhY7H7ONFHXNqTqNwjRNNzZT6MNl94QtfGPv5ggsuwNKlS/H4449j9erVeOtb3zqrGzef+XymLr7XK0GGVslLJMxUPM0waVOzYsJhU8rbsqTnkj1DUygSkYNpeFiySYBZu1RdLUHN0BCwY4cEcKtWje/htG+f/C2ZNNPrtIy4yyWBj06/y+XMdEPLkozVM89IQKY9CLJZKT2+erVcZp+CyICJiIiI5jOdlheLyRgsEpn+fWgFZvvyDC3SFQrJfff3H/SmLkjTDpgKnXzyyTj55JNnY1sWFA2YMhkJlnw+CRSSSQkUIpH8gCmVKp1h0oxRXZ0JNPr6TDBUKBIBOjtNhimTMWuOmprke1eXnIWorTVBjIrFTK8mn0+m0SUSUkiitVVuU1cnB3wgIIFSNCr3qXNotVR4TY0EVzoFUAtADA2ZAhH6AUBEREQ0H+nJ76EhOYm9ZMn078PrlbFVLidjLa/XLGnQseJEBcKotBkFTK+88goeffRRdHd3I1cw0fKmm26alQ0r9LnPfQ6/+c1vsGnTJni9XgzO8XbFXq/pPaSBgpbR1syKBkxer8kIFeNymap7waBkc/bulWyRu8g7HApJ4JLJmAazuZxsg9bq379frtvcnH+WQzNYgCn04PHIwR2LSZC2bJkEfpZlDtxXXpFgrrZWsl969qS5WYIszXBpwMTpeERERLRQOBxAS4ssUejuljFasTHcZPfh88m4Tmcr2TNMgIzV0mmuDZ+uaQdMd911F97//vejoaEBzc3NcGhnUwAOh+OQBUypVArvfOc7cfLJJ+N73/veIXmMwyWTkQV5Q0NmKp4GTImEmbuqB0owKBkdLdVte8nHhMMS/AQCZs3Qvn2m/5KdFooYHJQgTJucadnJaFQey+UyGSfV0yNBnWa+ANl+zTitWWN6Lqn+ftmW6mrg+OMlQIrF5LkHArKtliWP5/XK9usZEAZMREREtBA0NkrAo1PntGLxdGjApOMwt1vGfdqLaXRUxov2dek0uWkHTLfccgs+97nP4frrrz8U21PSpz/9aQDAPffcM+XbJJNJJG0j9+EKKQ2izclSKdl502kJijRg0ipzLpfZyS3LHADFpqhFInJGIhaTDM+WLVIxr77eBEKF19eASQMwze4MDMgBFYlIxkklEibztHixrEECZHpfMinZo8IUciol2aV0Wm6zapVcrhXy7NXy9PG1/LjXa86IEBEREc1nkYicKD5wQMZYXu/0TxzrOnQtAOZwyAluLS2ua+IZME3PtKvkDQwM4J3vfOeh2JZZd+utt6K6unrsa8lMJoQeAk6n7Lg+nwQahQFTJmOCCLdbdn6tqFeqcko4LAdFMikHhpYP37NHgq1COs0uFjNro4JBuW5vrwQ64bAJWDIZOXizWbm8oUHOfmiJylRKArWaGtl2TSV3dsqB7/VKWXK3W56vVgL0+/MDpsFB6cUEMLtEREREC4fLJWOp6moZn+3YMf0y4FoNzz7Tx+ORL79fxnFzfFVLWUw7YHrnO9851nup0n384x/H0NDQ2FeH1q4uMw1g0mnZoTMZ2YndbpNJ0qZj9nVM2WzpgMnlMsFNNCrZHF0TVdj1Gciv0qfT3/x+uf9oVO6vvt5s044dsq1eL7BypdyvVsbTKXXNzXKQaybM5ZKALRqVqX1auU8DJL9fgsfRUcko9fUB27fL8wyFZC4vERER0UJRVwccdZSMgSxLxkWlin4Vo7OQ7C1mtH2NzuRhpbzpm/aUvFWrVuHGG2/EE088gaOPPhqeglVjV1111ZTv64YbbsAXv/jFCa/z8ssvY926ddPdTACAz+eryGa6uZxMnxsclIMhmZQAQQMYe5dmrZ+vzWsnqs0ficjfh4clA9TaKgFLb2/xebCRiEy/02INLpeZjldVZabjadDjdMqUOrdbgptUymSY3G45uDXASqflAD9wQC5budKkfwun4A0MALt2ScAVDJpCEMXWahERERHNV/X18qX9MIeHZWnD2rVm3DQRHfamUmbdu73wQ28vA6aZmHbA9N3vfhfhcBiPPfYYHnvssby/ORyOaQVM11xzDS677LIJr7NixYrpbmLF08pyPp8ERsmkmXqnzV/1bIK9tHgyOfFZBg1wtMpeXZ1UW9FsUOGBFomY+wwE5MAaHJRtamiQqXfd3XJwAcCKFflV7DIZU05c4+ZXXpEDcWjIFKqoq5MDXQMge8DU1wds3SqPXoPNTgABAABJREFUHQpJQDaT3gNERERE84XDISebX3lFxlJbtwLr1pmAqBTt7amlxX0+M0bTisqckjd90w6YduoCk1nQ2NiIxsbGWbu/uSQQkB1YK9q5XBIwRaMmwLGs/AxTPD5xwBQKmbVO8bgcGDU1ksHp65PGsHYaMGmz2ZER+TmdlvvKZKQ8OSC31QyRZcn9aUn0kRHJYAWDUg2vt9f0gvL5JPiyV9vTgCmbBV5+We6vuho4+miWuSQiIiICzMyerVtlXLd/P7B8+eS307Y1iYRZggGYE+vsxTR9017DVC579uzBpk2bsGfPHmSzWWzatAmbNm1CbKI5ahXM75edOJcz6338fjNFz7JkZ9eAye02gVApDoc5GHSRYF2dfO/vH1/8QavwAXLfAwNycGnpyc5O+VthwDMyItdLp0358UhEznzoVL5czgReLS1mu/R5acU9nf63bh2DJSIiIiI7lwtYulR+Hhw0rWAmouuYtPCDBkyBgIzv7GvlaWqmnWH66Ec/WvRyh8MBv9+PVatW4W1vexvqdKQ+S2666SZ8//vfH/v9uOOOAwA8+uijeMMb3jCrj3U4BIOyA1uWKS/u90ugAchl8bjJLml/osniw6oqOaCiUVOEQSvTRaPjm9Daeynp2qlIRP6Wzco26YGqhofl+pYlQZbbLRmmpibJLrndcp1YTILCSMQUpNCqgPv2SarZ5ZL1SpomJiIiIiIjFJLxWCIh4y6thFyKTtvTwg861tPlIMmkjAk59pq6aQdMzz33HJ599llks1msXbsWALB161a4XC6sW7cO3/rWt3DNNdfgT3/6E9avXz9rG3rPPfdMqwdTpdMME2CKJ3g8EkBo5bh4XKbUaUNXQHb+VMr8XkgDIu1l5HRKf6SeHsky2QOmZNKcbRgakkAnlTJZKb2/wuIL0ahkmRwOCYw8Hpmyp9MLEwn5OR6XIKqhwdxHLCZFJDSj5vXKY/KgJSIiIiquoUGWSfT2Th4wFWaY7AGT1yvjtP7+/NlDNLFpT8l729vehjPPPBP79+/Hxo0bsXHjRuzduxd/93d/hwsvvBD79u3D61//enzkIx85FNs7L6TTEjT09EjgoFkXLfuo6dKRkfyd3OMxRSFK8fvlepZlrqcB0MCAyWABphBEMCgHTjIpAZY9QCpsepvNyv0ODpoAy+2WMuZ6JkMfV3sxaYU+y5I1S1oVcMUKed4AG9QSERERlVJXJ+MzXRYxkcIMkzavdTjMeEsLetHUTDtg+vKXv4zPfvaziNhSFdXV1fjUpz6FL33pSwgGg7jpppuwcePGWd3Q+WbXLglStNlsOi07s9MpQUY8LgGN25YDnKwXk9K3RtcxhcNmvZS9MsroqDx+fb1kjQYGJHjK5cx6p8KAKRaTv8XjciBms7KNbW3mwNQ+TNo/ShvQ7t1rnvO6dXJbnRZYKmNGREREtNB5PGZ819c38XU1w5RKmRPlOs7Scd3AwOxv43w27YBpaGgI3d3d4y7v6enB8N9G6DU1NUilUge/dfOUy2UyK7mcZGLSaRMsOZ2mGay+jBp8ZDLTD5iA/OIPShf8hULy+AMD5syD05lfilLp+qVs1kz78/slravV71Ip+VsgIPen99nfL8+rtVWCNH0ezC4RERERTUyn4vX1jS/kZed2y1gTGF/4gaXFZ2ZGU/Iuv/xy3H///di7dy/27t2L+++/H1dccQXOPfdcAMBTTz2FNWvWzPa2zhtOp0T4LpfJsmhg5POZMt+pVH6lPJ2SN5XCD4AERJmM/KwB0/CwuUwDHD3boEGaKswuARIIDQ2ZEui65iqXM/eXSJjFhPX1ZophMimPXVUlwZRO3Sv2OERERERk2At52U+KF1NqHZO2iBkamjjoonzTDpi+853v4IwzzsA//dM/ob29He3t7finf/onnHHGGfj2t78NAFi3bh3+/d//fdY3dj6JRGSn11Sprh/SAMTjMYUf7JXystnJS0F6PKbBrDax9fslk2NZkunJZk2Q5vXKbbJZ0/8JGB/IZDLy98FBU+Nfp+Tt2ycNbFMpk30KhwFtsxWNyt8CAXk8t9sETMwwEREREU1Ml1EAk69BKlzHpBmmUMgUF9NgiiY37Sp54XAYd911F26//Xbs2LEDALBixQqEbaPrY489dtY2cL6KREyGCZCdNhw2RRc8nvzCDxo0adGFyVRVycEwPCxV8gDJMo2MSMCkKVmvV85UBAJyuU6lA8YHTDqNMBo1a6+SSQmKcjkJmjS7lcvJfdsDJu3xFAiYBrkOByvkEREREU1FfT1w4IBkiLS4VjGlejFpb89USsaEej2a2Iwb14bDYRxzzDE45phj8oIlmhrNMGUyplmt0ylfgAmYtPCDrmGaSoZJ7x8wGSZAAietsKKL/QIBeQwtXT48LD+73eMPonRaDrBkUqYF6mLC+nr5WzIpWaZEwpRN1wAqFjNlzO3T8QIB85yJiIiIqDStbqwzhkop1YvJ7Zb7sCyp1kxTM6UM03nnnYd77rkHkUgE55133oTXve+++2Zlw+a7mhoJFLJZCWJ06p0u0tPCENpA1p5h0rVApc4qAJIdsmeBtIBDJCJnJbq6zNS/TEauq9mmdNpUtrNLpcz6KW2i6/VKg1y9fleX/C0QMAGaBn6xmJQYDwZZ8IGIiIhoJhoapD1Nb69p3VKoVIYplZJ1TENDk1fbI2NK5/arq6vh+Ftznurq6gm/aGqqqiQocrlMzyTNMFmWBB0ej+zY2utIp+tNJcvkcplgxJ5l0uIPnZ3517csMzVuZKR4IYZ0WgKdXE4OwOFhCcTWrpXrazn0ri75XefZRqMyXU+zVtXVLPhARERENBN6QlrXuhejGSatbKwZJssys5BYWnzqppRhuvvuu4v+TDMXDJq1SVphTgOmVMqcCRgdletqYOXzmaIKtlZYRVVVSYATjZpSlJrZikblINMALZuV4CUaldsUC2R0Kh4gaeB0Wh5jxQqZiqfT73p7gdWrTcC0ZYs81qJFwKpV8pj2kuZERERENDVut4znBgYkS1RsLbgur8hkZPym48502ozxWFp86qa9emR0dBRxWzi7e/du3HHHHXjooYdmdcPmO79fgiLtraRnAFwuM0XO75fpbFpsweGQqW6ZzNQKP2gwYj/74HSaua/DwyZbpFX4XC4J0rTwg51WutN5rw6H9FSKROQ2Xq9clsvJdjc0SCC1d6/cfv16ud94XO7D7TZnQIiIiIhoanTG0NBQ6evotLzCSnkaMGk/TZrcjPow/eAHPwAADA4O4sQTT8S//du/4W1vexvuvPPOWd/A+Uqnp2mKNJORYETXNblcJmDSIEWDqGx28l5MgDnjkEiYanz2y5NJCV4SCTmI/H5T/EF7KtlFo7Kdw8NmXdTixXKwpdMSxPl8JmsWiwHbt8ttmpokuAJYTpyIiIjoYFRVmbXq2iamkJ6ULuzFFAya9fN6Up4mNu2A6dlnn8XrXvc6AMBPf/pTNDc3Y/fu3fjBD36Ar33ta7O+gfOZvbS4TovTNUr2Igwul9nZNWCaSoZJs0ZAfgCkBSQ8Hpk+p1XtcjkJYoLB4g3RolHZjsFBOThramQerd639mWqqpLn1tEhB2NNDbB0qamGx4IPRERERDNnX6teqoltqQyTntxOJoufIKfxph0wxeNxVP1tscpDDz2E8847D06nE695zWuwe/fuWd/A+ayqSnZYzf5ohskePLlcEshoVTydwjeVgAnIL+Sg4nETrPX1yQHj9ZqAKRAofvDFYpL61emDNTWSEtZAKZOR6zQ1mU7SgFTRs6+JYsEHIiIiooOja8dLBUyFGSYNmJxO06qm1G0p37QDplWrVuHnP/85Ojo68Lvf/Q5vetObAADd3d2ITFaFgPJoLybAlAvXdOnIiCn2kEhI8DTdXkxA8XVMo6MS0Did8jgaADmdEsRonyT7NL50Wm43MCCBkZ7ZqK83ZcO1L1N1NbBmjXyvq5Nt14NaezkBbFhLRERENFP2npuWNf7vhRkmHWMCZgzGwg9TM+2A6aabbsK1116LZcuW4aSTTsLJJ58MQLJNxx133Kxv4HwWCEj073CY0uL2Ovl+vwQxWkFPp9FpxRN7QFNKYYZJizz4fKaAhAY8Xq8EOVoUwl6OXAs+JBJyH1qAorFRbptIyP1qcLR8uUzD0+tqNsnesFZ7ThERERHR9IRCplhYsal1mmHSWUD2MaYGWwyYpmbaAdP555+PPXv24JlnnsFvf/vbscvPOOMM3H777bO6cfNdICABkJYMj8Uki6TNXr1e+d2eYdIgI5ud2rxTe4EH+208HglskklTFEIzTHoQ2dO0w8NygGWzEgS5XHIg1tfLfeqXwyFBl99vAq5g0KxfYsEHIiIiooNnn8FTbGqdTr0DzPILgAHTTEypD1Oh5uZmNDc351124oknzsoGLSRaJc/tlqlqGhjZezE5nfkBk2WZoKlUvyQ7Ld2tFfF0HmsgII+hRSU0XRsOy2P19IwPmEZHJVjSJre6/XpmIx43vQH8fikpDpiDWbcZYMBEREREdLCqqiToGR6WNeOFfD4zQ0hPoluWGZsxYJqaaWeYaPbYM0yABDOavdGASUt0p9OmAZlWypuo9r6dfVqerh/y+cx9ulzmvsLh/FKVGmAND5vpeNmsbHtNjSl7nkqZqX6NjXJ7zTBpUGdZZi0VCz4QERERHRzNFMVixXsq6TomXTah65j0xPVU2tQQA6ay0ua1Ol0tnTb9lnQKne7Q9gp6kYj8ra9vao+jAVM8bgImLV+uRSQ02NEATh9Xg55oVIKjTEa+gkEJmOJx08tJU8PhsDwXDbY0ONIMlfaYIiIiIqKZ07Fk4dpzpeuYCgs/2Mdmpfo4kcGAqYzszWstywQYDofsvJmM2aG1sZjDIYGKBkzFqqIUslfK04NCez8Fg/I4zoI9wb6OSTNIuv5IM0z19SZYSiblPiIR+Zt9/ZJm0Lh+iYiIiGh22avlFSrVi8leSKzY7SgfA6Yy0oDJXuhB+y4lkyaTA+QHUzU1cp2RkamVF7ffh15fH8PvNw3M7GcY9OAbGpKvTEZu63SalG5Dgyn2kErJ5ZFIfsEH+/olBkxEREREs6tYsS5lD5gsywRMliV/Y8A0NQyYysjlksAjEJDfNeujlegSifwpeUrTr5kM0N8/tcfRlKweFFpO3OMxj5FOm/mvoZB85XLA7t1mrRIgwZXTCdTWSrAUjZpGu5ph0jmx9vVL9nVSRERERHTw9OT06KiZkaR8PlONWcd9KhCQcR4DpskxYCojbUSr/ZYAkzLVvkwaXKRSZn0TYA6O3t6pPVYoZLJEgMkwWZaUAQ8EZHvs1VJaWuT7/v0mywSYNK7HYxrRajYsEJDnpM9Dg7HhYbmO252fdSIiIiKimXO7zWyiYlkmPTEfj5sMUy5nxpgDA4d+G+c6BkxlpBkmrYYHSGbGvuYnGJQgSQtBuN2SzdH061QDJl2rpGcXdN1RNisB2+LFcj17IQltYhuLSYlwzYD5/ebA1N5M6bQckJGImT6ozw8wmbC6OhP0EREREdHBm2gdk47ZRkeL92KaatXlhYwBUxlpQzHtxQRIIGNv8mqvKGcvLa79koaHTYAykVAov9eTVsbLZiVdqwHT8HB+OnfRIrlNf79cV68ficjlIyP5vZ2qqkx2Sbc7mzWZq7q6Gb9cRERERFTEROuY7NWS9UR2Oi0nxgEJmKZSRGwhY8BUZlolz+mULw1i7D2LNJWaTst1NWjx+yU4mcrc00BAbq/lvjMZCZxGR+W+6utNata+LkqzX8mkXDeTkevX1UmwtGePpHXdbjnwdJvs2z04KNfx+1nwgYiIiGi2hcMyjkynZbxmV2pKXihkio6xtPjEGDCVmVbJ00xSMik7ezY7vqqcPcOkPY8sC+jpmfxxXK78zJVmmtxu+dIy4UD+tLx4XAIhPQBzOQna6uqArVslWHO7pVmtzyf3oweqZpjs0/GIiIiIaHY5HObEd2GWKRAws4t0LAmYWU6JhDnZTcUxYCozzeBoee9UyhRk0AyTfb2QBkyWJeXFgakFTPpYgAQ0yaQ8js9npvfV1pqskwY98bgpO2lZ5kCLxSRYyuWA5ub8Ahb2KXnptDlwGTARERERHRql1jE5HMWzTLokJJlkwDQZBkxlpoURgkGTAfL5JMhIJCQg0YBJ1xbpPFMNmAYHTQW7yR4LMBkmLfigZyRcLnOfmmXS4ErPRqTTcrAND5tgybLk7z5ffoU8v99kl8JhU9qciIiIiGaXViHW1i52pQImbV5b7DZkMGAqM7fb9GLStUler+y4utZIU6ma4dEqc6GQXHd01Ezfm4g9YNL7tgdMgJmWp0UetLCD02mCu0RCtruuTq4/Oip/i0Rk+yxLru/zmcCL2SUiIiKiQycQkPFXNjt+HZO9Up4WftDMEwOmyTFgKjOXy0zJy+XMFL1MRqqWZLMme6OlxTVgsiw5ANLpyWvoW5Y8ViYjjzM8LAdVYSGGSEQeL52WUuLaDyqdNg1zvV4JgPR22rS2piZ//ZJO7dPpfkRERER0aDgcZmxWeCLdXilPM0w6jszlWFp8MgyYykwzTDqPNJeToCWXkyBI1wx5vSZg0p1+YMBkbiZbx6SZKV30F49LAFVdbaYCAvJ3vc/9++V7PG6aztbUAEuWSACkPZgsSw7QYLD4dLzqajOlj4iIiIgODZ01VJgx0il5qZQZ92WzJsDSdelUHAOmMnO5TNbG5TLlt7X4Qn+/XK7rfzRgcrlkp9dKdH19E+/ouv7J6zX9mHw+M9/VTqflHThgqvXlciZTtHKlPHYqZe43FBpf8IHV8YiIiIgOn1IBk30sqeve02kZBzqdMuZk4YfSGDCVmWaYHA4zp1Qj/mwW2L3bTMkDJEixLDPFTQsujIyYqnrFaH19n89U4Ctcv6SCQTOlbnBQvuu0O12rpNuZSMg2hMP5JcUzGXlMzWIRERER0aGlGSNtU2OnWSYNmFIpGfN5PHL9ZPLwbedcw4CpzHQNk9MpO3kuJ2cFIhEJSLq6JCDRNUy682sQkkqZQgwTNbDVgEmzQFr5rlQj2bo6uV5vr+m/pMGZBkyJhGxPIGDWN+nZCQ3eamvzp/wRERER0aHhcpnAqNQ6Jg2YtL2Mx8MM02Q4lC0zbRwLSFrUPtXO4ZCdfWhIduZsVoIPDZK0Sp4GM729pR9HM1Na+EGzWqXWFtnntPb2ym106mAwaDJI6bSsa/L55OdcTrJSGrzp9D4iIiIiOvR0DFc4LU8DpkTCVE7WdfTsxTQxBkxlpjus0wk0NMjv0agEN1oyXNcCaXClgUpDg7ktMHnApCW/dWqdPnYxliU9lrQC3+ioHIA1NXJQ6f1pkYpAQA60wUFZT+VwAIsWFZ/yR0RERESHRql1TMUCJq/XzFTilLzSGDCVmWZ4nE6ZZhcISCCSTueXAY/HTSU9nQpXV2em8umUvFJnB1IpORC015NmmHSqXqFkUoIje1U9LSeeSMhB6HLJ4+uap/37gc5Ouf/GRqmmR0RERESHjwZM8Xh+QTAdR1qWfNkvS6en1tNzoWLAVGb2lGggkL+TZ7OyozudEqRo3fxUSgIpp1OmvGmQNTpauvFYOm0WAGohhmBQMkLF6FkGLUSRy8mBVFUlB9nwsClGodu3fbtct6UFWLr0oF8aIiIiIpomn88ERoUFwQrXMblcctI7k5GxnF5O+RgwlZnDIQGHxyPfGxtlJ08mzTohXbekwYm98klDg+nSnEgUbzxmWaaUeDQqj9XcLN91ul8hzTzFYnJwacGJbFYu10xWICBBV2enXFZdDaxaNasvERERERFNg56AL8waFVbKA0xrG65jKo0BUwXQtUnZrEx58/slyLGXeEyn85vXasAUDErWJxyW4KbYOiYNftJpEzCtWCGXjYwUn5anjzs8LNsVDsvBFItJkNXZCXR0SK+mzk7ZNr9fskt6MBIRERHR4TfZOiYNmLJZGb+xUt7EGDBVAJfLVMHTwgput+zk2udIK9s5neNTrA0NcptoVAo0aBZIaYW8VEoCJJ8PaG01B9PAwPht0oApFpMDKBKR7JdlATt3SiZrdFTuIxyWbWhqkoBOe0YRERER0eE31YAplZIT3ezFNDEGTBXA7c4vD97aKjvv8LDs0PZy4hqM2A+AujqZCmdZkv0pnK+qBR9SKfkKhSQAqquTvxcGTFpoIpORACuRkLMPK1aYSio1NcDixcC6dcDRR8taKg2W2HeJiIiIqHx0OUUmkx8E6TjNvsQjFJKxKDNMpXFoWwG0eW02K0FPe7tpMBuPmxLgiUTxZmQul0yF8/mAnp7xAZMWfBgdlYCnqkruv6bG3Jd9Wl7hdDw9+xAISNBUXS1B3aJFZiqeHmB+/yF5iYiIiIhoihyO4v2YHA4Zz+l6+XTaZJgYMJXGgKkCuN2yA2tFupoaCWpyOZn6pg1nEwmTSh0dzS8VuWSJBEzaaNZOM0yxmFxH+zdp8ATkZ5k0YBoczK+iks3K7z6fbK9uiz1g4volIiIiovKbaFqetqmxLBnXeb2mF5OWHCeDAVMF0NLiGmyk0xIAuVwStCSTJnVq75+khR8As45I1xjZpVImW+V2y1ojVVsr3+3V8jRgGhqS23o88r2qSr6Hw7KtOvXO75cATn8mIiIiovLSDFOxSnla/RgwVfJ0zbt9fEmCAVMFKAyYhoeB5cslUNHCD5phKmxea6eV7/bty/9bKiX3qWnX+nrzNw2Y4nETKOn0vOFhE2RZlgRDkYjcj9+fHzBxSh4RERFR5dAM0+hofkEwnSGkl2kVZu3/yYBpPAZMFcDtlu9+v8keLVkiv4+MSKbH7ZadOJuVoMmyxp8x0Gl5w8OylkklEkBfn9x3XV3+tDm3e/y0PPsaJj3IIhEzlU+zTl6vaaarBxcDJiIiIqLyc7uLFwvTcaAWhXC55GetysyAaTwGTBVAM0yWZYKXYFDODFgW8Mor5mxAPF583REgxRjq6iTg2bdPLsvl5DbRqBw09ul4Sqvl7d8vvZXicTlY4nEJmpxOue+aGjmQLEsuKyz4oCldIiIiIiq/Yg1snU4ZE2rhB0BOhLtccqKcAdN4DJgqgGaYMhnJ5AASqCxZIj/v3Jm/w2uA092dfz9+vwRElgXs2iXBkr3gg98vvZQK1dfL1DzLkka0L78swdPoqJmSt3y5qaZXWytZJ7eb65eIiIiIKlWpwg/2SnmZjPk9kcivnEyCAVMF0KxMNiuZHEB2bF2T1NWVv3CvpUV+7u7Or2TicEiQ5XZLEYeBAdnpYzEzja5YhsnhkMdavdpUw9u6VR7XsuQgamqSMw6ZjGSa9HG5fomIiIioMun4sbDlTGFp8WDQrJdnhmk8BkwVwJ5h8vtNE9v2dglmBgfNwryREQledKcunJZXVydZqkRCpuWlUhI8OZ1yuZ5pKCYSkcBp0SI5sEZGJMhatMj0cNLmZhowBQIMmIiIiIgqka6P176a9suLBUycklfcnAiYdu3ahSuuuALLly9HIBDAypUrcfPNNyM1T3KGmmHK5SQQ0Wl5kYjMMc3lzJokDU50at3+/fn3FQ7L35JJKfwwPCyZKKcTaG6Wg2Yi2vG5rk4eNxKRjFIqJbfV/lB6P/YpeezBRERERFQ5HA5zQlvHa4BpVptMyhgvEDAn4+fJ8HpWzYmAafPmzcjlcvjOd76DF198Ebfffju+/e1v41//9V/LvWmzwl4oQSvSAab3UTYL7N1rGtvGYmZqXVdX/n1psQi3Ww6MffskC+VymTVRE9H1TjqFLxg0pcx1Kl4qJVkwt1sCMT2wmGEiIiIiqix6QtseMPn9Mr7L5eRybWbLDFNx7nJvwFS8+c1vxpvf/Oax31esWIEtW7bgzjvvxG233VbGLZsdDodZO6SFHzSDU1MjAc+uXcAxx8hOPDwMtLYCf/kL0Nsrt7GXJg+FJGgaHpbgJxqVjFGx9UuFkkmZijcyItujle90/dOOHXIdny9//ZLbbbaBiIiIiCpDsYDJ4TDrmxIJM95LJk0/JuecSKscHnP2pRgaGkKdlosrIZlMYnh4OO+rUtkLP7hcshN7vWYKXG+vuc7IiFSq8/slWLL3XAKk6l0gINfr6pL1SMFgfsPaUkZH5XaxmFk3VVUlgVsgIAGbZp84HY+IiIioshULmACTVUok5ES4yyXjPMtilqnQnAyYtm3bhq9//et473vfO+H1br31VlRXV499LZnKnLQysRd+ACTL5PGYOaVDQ2bqWzQqUb+uY+rszL+v2lq5P69XpuQlk5KRmsqZgsFBuX4ymb9OqbXVZJM0qGPBByIiIqLKpgFTIpFfXVkLP+iJcB33pdMMmAqVNWC64YYb4HA4JvzavHlz3m327duHN7/5zXjnO9+Jf/mXf5nw/j/+8Y9jaGho7Kujo+NQPp2DYs8wARIwaXrU55OdfHBQ/jYyIjt8c7P8ruW/VTAoB4fTKQUfUilTinwi2awEZhowpdNyMGkhCQ2OFDNMRERERJVNx5OWlT+Wsxd+yOXy16az8EO+sq46ueaaa3DZZZdNeJ0V2owIwP79+3H66afjta99Lb773e9Oev8+nw8+n+9gN/OwKMwwhUJm2pvfL8FLX5+sI8pkZIdftEhuNzIiWSctFhEKyW36++Vyl0um1E1G1y/ptDxdT9XYKPfX2zv+zAQzTERERESVLRCQ5Rajo+Ykt/ZiisXMSXIWfiiurAFTY2MjGnVe2ST27duH008/HccffzzuvvtuOOfZSrTCDBMgwUowKGcGLEuyP42Ncp3RUVlbFA5L5qmvzwRMXq9cPjQkAU0kMrWAZmREgqb+fvnZ6ZRAq6FB7nN0VM44+HzyN63fDzDDRERERFSp7AGT8vnk5Lxlyd/spcUZMOWbE1HHvn378IY3vAFLly7Fbbfdhp6eHnR1daGrsKb2HFaYYQIk0KmqMgHT6Kh85XJSyMHjkep3wPjy4g0NEkQBEjxpsYaJaAZpYEDuv6pKpv1p0zOtze/1skIeERER0VxRqvBDVZV814BJM0yckpdvTgxzH374YWzbtg3btm1DW1tb3t8s+xyxOaxUhikcNsUaEgkJZDIZs8M3NQE7d0o2Savh6W17eiQA0nLi/f1m3VMxfX1yHwMDEmAtWSLX1+a5urappobrl4iIiIjmilIBUzgs30dGTNU8XcdOxpzIMF122WWwLKvo13yhGRp7wKS9j7xeUxN/dFSCmnhcrqNBVTwuQZOyLAmAMhlg5Uq5rL9/4m0YGJBMVSIh29PcbKYE6tQ77fnECnlEREREc4MGTKlU/lhTM0zRqJmSx4BpvDkRMC0EmmGyT8kDZM2Sx5Nf3SQaleul0xIshcMSSA0MmNvt2GEazzY3m+l8hWcWVDwu6dhdu+T3qir5CgTkPlghj4iIiGhucrlkPAfkjwV1/btmmBgwFceAqUIUyzABJmhxuWQdUTIpgQ0gQY7fLzu7rj1Kp4HhYZmm5/UCbW3yfXBQ/lYqyzQ8DHR0yH26XFKBz+mU+9eCD3askEdEREQ0dxSblldVJePLVErGfxow5XLjx6QLGQOmClEqw1RVJWXCLct0YNbqJX19spPX1MhBEI9LYLRjh6xfqqoCVq+WDFUoJE1stRBEod5eCZgyGSkYoWcZfD7TByqZNI3NtG4/wAwTERERUaUrFjB5PDLOAyRAcjpljGlZLPxgx4CpQhQr+gCYgCmXk98tS3bmWEwySqmUTMkLBiVg2rtX1iHF4zIVr75epvVVV0vQs2ePpF3tcjng2Wfl7y6Xqc4HyIGkU/JGR+WgCoVMsMQKeURERESVr1Thh1BIvmezclLc5ZLxJaflGQyYKoQGHbmcCY4AEwzpGiZAghX9ubtbruP1SiDU0SHZIp9PAqVIRHb6lSvl58FBYNs2c/+WBbzyimSlcjmZiudwyEGlZxw8HlOhT3s8cf0SERER0dwxlUp5Xq+MOdm8Nh9zAxVCM0yASYnq5dXVplksIDuxVs3r7TW9knp6ZGe3LDkoWlok2MpmJehZtw548kng5ZflbEJPj0zT27FDbufzSV+nbFYeNxCQ22UypuCExyPZp2hUtoXrl4iIiIgqn/bVzGZNX02geKU8Nq/Nx4Cpgng8psGsx2MuD4dNLyRtYmtZpqJdKmWq58Vi0j8JkIySVj8ZHgZWrQK2bJEs08aN8lijoxIQ1dVJRmp01GSzfD5T3EEPGodDgq3ubvmdGSYiIiKiyudwmCrHo6PjA6ZYTP7udsvYj2uYDE7JqyATdWH2++WMgGXJz7GYFHtIJiVwSibN2qZUSq4TDssaJkCCKYcDOOooCYzq6oD2dmDFCuCMM4CTTzZZLo9HgrNgUL6095PPZ6YHskIeERER0dxSqlKeXubzsbR4McwwVZBAQDJB2pRW1dRIYDI8LAGTxwO0tgKvfrVkihIJCYCCQblOOi2ZJZ9PKt4ND0sgZVlyu1RKskShELB9uwRSliUHilbjy2blMQMBCbb0IAqHJZhihTwiIiKiuUXHbfaxpt9vlmA4nQyYimGGqYIEg/K9MGCqrjYZJqdTduKREQl8li0Damvl7EBTk+zs8bipeFJdLanVXE6CJq8XWLMGWLxY1jABEmwNDJggSWvvh0JyYNkLPlRVmewSK+QRERERzR2lSot7vRIguVycklcMA6YKogGTZnpUba0JerSB7eioVLvr7pbA58ABuVyDG62c53SadUxaqAGQgGt4WG5TWyvrmnI5CYgyGVMpLxCQQCuZZIU8IiIiorlMx272ister1krb1ky5kwmTdEvYsBUUbQSnn3KGyABjzaMdTpN9TqnU3ZkXcek1e20Q7OWBbdXP1FdXfK9rk6+Dw6axYA67S8UkoMlFpPraLaK65eIiIiI5h4tG67VjwFTGRkw0/JSKRlXZjLl29ZKwoCpgmhWB8iflhcISHCiRRl0jdKrXgUsXy7T8hwOCXrq6+XngYHxAdPIiARSo6NyXUBKkieTJtvk9ZpqfKGQKfig5cQBZpiIiIiI5qpiY03txZROmzY2mQzXMSkGTBXGPi1PeTwS/Gi6NJGQAMfplAzRq14FHHOMFIfQsuP9/WaH9/nM5dGoyS7V1kogNjBg5qnq1D+djpdIyLb4/SZgYoaJiIiIaG4qto5JAybNMDkcEiwxYBIMmCpMscIPDocEK5oxymQkYLKnSdvbJQPl8cgUut5eySipSERSq7t2STAFSGNbQNZCAXKwpNOm8W0wKNuRSJj1S6yQR0RERDR3FQuYfD4ZQ+qaJaeThR/sWOOswhRLkwISMGnBB4dD/r55s2R5fD7ZwZcvl2Cmr08CphdeMJf19wOvvCLXXb5cslGBADA0ZApGNDeb8uNaUry/X37XIhK6XayQR0RERDT3FAuYvF4JmLJZGRNq4QdmmASHvBXGvugunZadF5CCC9ofyeeTwCWZzC8O4XZLY9pYTPorxePAk0+a4g2WJRmi5mbJLlkW0NEh0/SqquR6nZ3yOKGQPLZmo7Q4BNcvEREREc1dOoZLp03BMC0tnsnI7y6XjPkYMAkGTBXG6ZTsjpYHr66Wy6uqzPoivx9obARWr5aAKZXKr4xXXS2FIEIhWZ8Uicj1nU75Cgble1eXHAzJpBSLCAbN9Lu6OjmIhofl8Rsa5DvXLxERERHNXRogpdMyrtOT5F6vnHTX5rWpFKfkKQZMFUgDF3vAFAxKkJLJyN8yGTlDoD2WlDajbWgA2trkeuvXy0HgcEjfpmhUpth1dkrApMUcXC5zv1VV8vijo3IQ6XYww0REREQ0twUCEjCNjuYHTJmMKT2eSDDDpFj0oQIVq5SnAVMuZ76GhsbfNpMxJcBdLrlNb6/8zd6Pad8+uY9MxhSUyGbNNMCqKlkLpQUgNKPEDBMRERHR3FY4rvN4TNZJp+QxYDIYMFWgYpXy/H75ymbNGYDdu+V3u2TSlBHXrFBnpwRX9rLgfX35jxUImCZlGjDp+qXaWvnOCnlEREREc19hwOT1mhY0Dodclk7LuE8r5y1kDJgqkAYjyaQJiIJBU+4xEJD5pckksHdv/m2TSbPT61onANi5U3b8UMhct77ezE31+aQMuWWZgGlgwFwPkHmtgNw3K+QRERERzU2FlfKcTlMB2eWS33UmErNMDJjKIpeTYgo6Va6Q2y1BCWB2ZA2YANl56+vlfnp7TSAD5GeYEglgyRJZr5TNSr8lzSi5XEBrq5nWpyXGtUKe2z0+YIpG5btmqoiIiIho7tEMUyol40nAjD8dDpNpSqdZ+AFgwFQWuZz0RNq92+ykhQqn5Xk8JrOUTstOrFPudu+WHVvXIGnzsdFRud7KlXIAJJMS9ASD0ug2m5WDQOvtR6PyvbYW2L9fAi6n05QU14p5hYUmiIiIiGjusPfT1Gl5LpcJmAAZWzLDJBgwlYGmO4H8Pkp2hQ1sXS4JhHw+CbLicWDRIgmMEgkpEa73FQzK9bW+vtstQZN2ba6qkqBoZEQCJp/PVN/zeOR+du+W+2ppkcsyGbMtzDARERERzW2F0/LcbhnzFWaYGDAxYCqbwsV2hYoVfrBXq4vHzZQ7wBR2AGRKXbEpfcuWyc8HDkiVvIEBE1ABprykljRvapLS5ICZjhcImKmBRERERDQ3FY5F7UtCcjlWyrNjwFQmupOWyjBpwJRImOokWinP4ZCAJhaTTFF1tVxn+3a5ns9XPCCrrZWMESAZqWeekWp5OpWvv9/U46+pkal44bBcX6fjMbtERERENPeVCphyOVMEIpHgGiaAAVPZ+HzyvVSGSZuGWVZ+s1gNmEZH5SudBpYulR17cFCyTD7f+DSram0FVqyQ60SjEgh1dAAvvywHhN8PrFpltk8DJs0wcf0SERER0dxXakqetpgBmGFSDJjKZLIpecD4aXkaMGUy8nsmI1kmr1emz6VSEgCVyjCp2lop+tDcLBmjXE6CLY9HpvhVV5vCEqGQZMGSSfldAygiIiIimrvss51yObPG3uHI/xsDJgZMZaMZnFJT8gATMNkzTJoqdbkkQNKS4rW18vvIiKmoZ79toVhMDoyWFlnb5PNJEYnW1vziEU6nyS6FQqZYBRERERHNXR5PfhEyXdPudJomtvaiXwsZA6Yy0cg9kzEZo0LFMky6M/v9EhxpwOTzmaomOrUOMJXyCo2MmL+FQhJweTySQdKAqXD9EqfjEREREc0feoI9kTBjTHt5cW1BU2wsuZAwYCoTp9PMD51qaXENoHw+2akHB+Vv2azcRzgsO3ksJt/t808LjYyYYM2yzHqpQGB8wMSGtURERETzj55gHx3NzzC53RIw5XLsxQQwYCqrydYx+f2y0+ZyEsR4PLIDh0Lydw1kYjH5e1WVnBEYHDTBDzB+Wl4yaVKsDof87vWauaua8QqH5TqZjFyuj0tEREREc599LFoYMOkJ9XR64iUkCwEDpjKarLS4w2GCHl2b5PHI1DgtBZ5MmoApGDRFIeLx/LMGdiMjEoSlUqYpGSClxJNJOTj8fjlYdDpeOGw6PxMRERHR3FdsSp5Ox7M3r52oSNlCwICpjCYrLQ7kT4tzu+XL55Mvp1PKiMdiEhQ5HEB9vVx/cHD8lDql65dyOVOiPJMBGhtNrX2WEyciIiKa3+wZJodDvjye/JPkzDAxYCqrqZQW13VDWtVO55SGw3L73l7528CAXE8b0w4OmttqQKRGRkwJyUzGBE719SbbFA7L5QyYiIiIiOYnr1dOwFuWqZTncpkxp85oYoaJymayKXmAyfQkErLT2hvKejwSGEWjJgO1eLEEP3p9TbVq4GNZMl1veFgOEp2CFwzKfdsDppERub7HY7aViIiIiOaPYuuYdGmGXs6AicpG54jqeqJiXC4T9MRi5udQyBSE6OmRLFJtrezcGmTZs0y6FikelyAoGpVASB+3vt6cWfB4JHhiOXEiIiKi+c1eJMxeWryweW0uV57tqwQMmMrI4ZhaA1v7tDzdeR0OudztBvbtk0Cotlb+VlMj34eGTLCjGabBQfN4mYxkoRwOWb8Uj8sBUth/ieXEiYiIiOanYhkmXTNvWaaB7ULOMjFgKrPpFn7QXkyJBNDUJD/390umSMt+a8CkAZaWDk8kJBuVSEgWKRqVLFcgILfVMwvhcH5nZ2aYiIiIiOanUqXFPR7JKmnLmYVc+IEBU5lNpfCDBkyjoxLgAPlV7TSQ0vLhGgRZlgRNGmTt2mUW77ndEhB5vRJ4ZbPyuwZMPT1ym2DQNMAlIiIiovnFXlrc5ZKfXS75qq4Gli6VsSAzTFQ2Uyn8YC+6kEpJUJPJyE6st3O5JDhShdPyLAvYudPcXzZrziS0tsptczkJoLxe4MABua5msYiIiIho/rGvqdd1Stq81ueTpRkuFzNMVEZTmZIHmCyTFmbIZiWzFApJMDUykh8wVVfL96EhuW00Kj9rXf2REfP4LS1mvVJ1tWSXslm5X10XRURERETzj8NhTsxns+ZyHaNqaxpmmKhs7Bkmyyp9PS28kEjIbTIZoKMDaGiQoKa7W4o/6JmBUMjMPc3lpE+TFnnQ9Ul+P1BXJ9fTAKqqymSXWlryG5cRERER0fyj0/K0vUwmY5Z0aBDFgInKxuORtCcwtX5MqZRMsdOAqaZGAqZdu2TK3ZYt5jY6LW/vXvmezUqVPO3Y7HZLUJROy/onp1MuZ3aJiIiIaOHQE/iaTcpkTDExvUxPui9EDJgqwFQKP+jaIpdLMlHptOy4Or80lZIs0b59pmBDQ4N837ZNArNkUjJLuZy57ZIlcrt0Wu5by48zu0RERES0MOhYVDNM2awJmOxFxxZqlokBUwWYSuEHwPRdGh3Nn75nWbIjR6NyHx0dEhgFg3LfsZhMs9Pb6m1qamTNkj0DZVnMLhEREREtJIVT8nK5/FY2WjF5oRZ+YMBUAaZT+EGr4Wn2R1OjHo/cj8cjQc+OHRIAuVyy8w8Py891dZKFAoDFi2XH37Mn/0wCs0tEREREC4fPN35sqdXztEIzMP0M03wJsBgwVYCpTMkDJGByOGQdUjYrwU8sZgKhkRE5Q6BFHl54QTJN8bise3I4zHonAGhvl2BJp+nV1jK7RERERLTQOBzmBL4WeXC75Sudntp6+0JdXTIW3bVr4sJmcwEDpgow1Sl5er3hYVP8IZmUnby5WXbGrVtlat6ePcDzzwO7d8vUu0BA1jR1d0t5cZdLpvgNDMg0PZdL7p/ZJSIiIqKFZ6LS4jpVbzoZJl0G0tcn6+m1kvNcxICpAth3RvtOWigalWg9k5FAKZ2WoKehQYIiXaPk88l0O59Pgqj2dmDVKlmvtGmT3LauDujslIAqFpN5qqEQs0tEREREC1FhwJTJmLVNetl0Mkz2Me3wsJzUn6tV9tzl3gCS7I7HY8p96yI7u64uWXvk9crUvGBQovyGBrksHgfWrpXLVq6UjNO2bZJNikSA1lbgiSckLepwyNeWLUB/v/y9oUGCKmaXiIiIiBaeYgGTjknTaRkj5nIyy0mr5k1EM0pNTZJlGhmRsefq1VO7fSVhhqlClCr8kM1K4KOFGpYulR1Ns0mrV5vskGXJ9Ts75borVkh2acUK2TE7OmQOqtMpO20mIxmlpUuBY44x20BEREREC8tEvZji8akXKVMaeEUiclLf65Xbbt5spuvNFXMmYDrnnHOwdOlS+P1+tLS04OKLL8b+/fvLvVmzptg6ptFR4OWXJUvkcEjws3at7HiA7MgNDUBjo/xdo3UNrpxO+bvTKVXzAEmt1tbKTr9iBbBmjUzr0wOCiIiIiBYeHYvqCXh7hskeME11Wp4GTLpOft06GYem07LWfi6ZMwHT6aefjh//+MfYsmULfvazn2H79u04//zzy71Zs6awUt7AgETgyaQEQuvWmUa0TU0mGEokgPp6+b26WoKrgQHTgBaQ6XydnTLtr71dpuytWyfBF2BKkhMRERHRwqRLRFwumXaXzeYHTFOt6qw0YNIKex6PjD3r6oDly2d32w+1ObOG6SMf+cjYz+3t7bjhhhtw7rnnIp1Ow6PdtOYwe5pz3z4JcgDJ/qxYYerfAzKFLhqVnXlkRHbmxkZzNmDPHuDZZ4FTTpH7279f1io1NUkmKZmUgEkrnjC7RERERER+vwQ4yaSMKWtq5HJ7wDSTDJNyueZesATMoYDJrr+/Hxs2bMBrX/vaCYOlZDKJpO1dHR4ePhybNyO6E2rfJEACnMWLxxdicDolq9TZKRXuGhvlen6/FHV4+WXJTgUCEoglkxLV+/1SMCIQkOtv3y73Fw4ftqdJRERERBXK75eT9PF4/hqmdNoEPlPJMOVypveSPWCaq+bMlDwAuP766xEKhVBfX489e/bgF7/4xYTXv/XWW1FdXT32tWTJksO0pdNnnxLndEr03dZWumqdBjkjI/Ld4ZApescfL9PunE6gt1d29nhcquZ5vRI4aXo1Fsu/LyIiIiJauPx+MyUvk5Gxo85y0oxRKjV5I1p7SXEGTAfphhtugMPhmPBr8+bNY9e/7rrr8Nxzz+Ghhx6Cy+XCJZdcAmuCd+zjH/84hoaGxr46OjoOx9OaEYdDskaBgJnfORGN+DVlqoJBCZgWLZI1TXV1UiTC6TS3CQbN7RyO4mXMiYiIiGhh0YDJPr7UXkzJpIwnLWvyaXlaUnw+BEtAmafkXXPNNbjssssmvM6KFSvGfm5oaEBDQwPWrFmDI444AkuWLMETTzyBk08+uehtfT4ffHOomsGyZVO/rlYcSSQkU6RzTAMByRgNDMjfUym5rs9ndtpg0GSXQiH2XiIiIiIiEzCl05IlyuVkrBiNyqwmv19mLiWTZjlJMcXWL81lZQ2YGhsb0djYOKPb5v4Wuian03J4ngmHJWAaGckPmPRvuZwJjBoapPgDIAHTgQPyMws+EBERERFglm8AEjRlMmZsGY/LrKV4XMaf1dWl74cBUxk8+eSTePrpp3HqqaeitrYW27dvx4033oiVK1eWzC4tBKGQrFPSdUyAKQcZicjOqo1qtbGtZpu4fomIiIiIChVOy7OXFl+0SH6erPBDYUnxuW5OPI1gMIj77rsPZ5xxBtauXYsrrrgCxxxzDB577LE5NeVutml2aGQkf/FdICA7uv69rk6m5gGy02ezpsMyM0xEREREpAoDJvt4c6rNa5lhKoOjjz4ajzzySLk3o+JoYKQBkJ4BCATMuqZQSL7v2yd/CwZNRsrnM2lXIiIiIqLCSnkaMI2OTr157XwLmOZEholKs0f9yl7NpK5O0qHa26mw4AMRERERkbIHTNlsfsDk9crP6bSphFcMAyaqKBMFTDrtDjABUyBgrsv1S0RERERkV2wNk8MhP1uW6cs0UZaJARNVFA16NGsEmHSpnhlIJOQsgNMp0/AYMBERERFRMdqKJpeTMaTHI0GSZcl4U8eZE61jmm8B05xYw0SlFTawdbvly+ORdGkiYXboQEB+zmZNHyciIiIiIuV0mtlKIyOSXQoGgaEh+X3JEnMSvpT51riWGaY5zh74lJqWZ1+/1NMjP7NhLREREREVU7jkw15aPBiUsedE48j5lmFiwDQPFJuWVyxgSqVMwNTUdPi2j4iIiIjmjsKASceV9rHmRNiHiSrOZIUf4vH8YKm5WRrbEhEREREV0rGlnnTXk/P6+2SYYaKKU6yBrQZMw8OylmnfPlnXFA4Dra3l2U4iIiIiqnyFAZJOybNXYJ4IAyaqONrANpczO7Kua4rFgP375WePB1ixgmuXiIiIiKg0DZi0ea19DZOenJ8IAyaqSJpl6u2V71q9JJEAolEJoJYvl6CJiIiIiKgUn8/0WxoZMcXC0mn5mgwDJqpIDQ3yvacH2LNHfg4ETFOx9nauWyIiIiKiqbGXFvd6JYDKZCTrNBEtKQ4wYKIKU1srQREgQdOuXZI+TSTk+/LlZd08IiIiIppDdBreyIjMUPJ4JHM0UcNawGSXHA5WyaMK1NAggZHDAfT1ScGHpiagrc3s9EREREREk9GxYywm2SWvV36PRie+3XwrKQ4wYJp36upMYYdYTKbhhULza6clIiIiokOrsG1NYanxUubb+iWAAdO8VFMDrFplgiRml4iIiIhoOuyV8QCzpokBE80bkQiwerUET01N5d4aIiIiIppLgkFTGS+ZzF/TNJH5GDC5y70BdOiEw6aOPhERERHRVHk8Ul48m5WsEqfkERERERER/Y3bLdPwsllZF68B02S9mBgwERERERHRvGcPmLQXk8czeS8mBkxERERERDTv2QOmeFyCJbdbsksTBUzauJYBExERERERzVv23kuWJYGSZpgmal7LDBMREREREc177r+VhvP7JWBKJiWAsixgdLT07di4loiIiIiI5j2XS8qK+/0SBI2OStU8YOLS4swwERERERHRguByyTqmTEaCJK2Ux4CJiIiIiIgWvJYWYM0amZ6XSskaJmDiXkzzMWBi41oiIiIiIhpn0SL5PjAgQZLDIb+nUpJ1cheJJOZjwMQMExERERERlaRT8TRImqgXEwMmIiIiIiJaUDRgspcWLxYwWRb7MBERERER0QITDsv3VEoCoUxGgqdCGiwB8ytg4homIiIiIiIqyeeTqXg6HU+/Cul0PIfDrHeaD5hhIiIiIiKiCYVC+QFTsSl583H9EsCAiYiIiIiIJhEKSSCkgVIiMf46DJiIiIiIiGhBCodlmp1lye+jo+Ovw4CJiIiIiIgWpGBQvrtcEhgVa17LgImIiIiIiBYklwsIBKQARCJRfErefCwpDjBgIiIiIiKiKQiFAL9fgqXR0fwy4gAzTEREREREtICFwxIwpVLFS4szYCIiIiIiogUrFAK8XgmMUqnxzWs1YHLOswhjnj0dIiIiIiI6FPx+WcPkcAAjI8wwERERERER5amtBTweIJmULzsGTEREREREtKCtXAmsWyfT80ZG8v/GgImIiIiIiBY0t1vKiwPjezExYCIiIiIiogVPm9gyYCIiIiIiIiqgGabC5rVsXEtERERERAteKCTfmWEiIiIiIiIqoFPyRkfNZZbFDBMREREREdFYwJRISKAEmOwSwMa1RERERES0gAWD0rw2kwFSKblMAyanU/42nzBgIiIiIiKiKfN4pLw4YNYxzdf1SwADJiIiIiIimiatlKfNawsDJp2qNx8wYCIiIiIiomkpbF5bWPChsxP4y1+Arq7Dv22zjQETERERERFNiwZMWimvMMOUSMgap/mwnokBExERERERTYtWyiu1hkmb2vr9h3e7DoU5FzAlk0kce+yxcDgc2LRpU7k3h4iIiIhowSmckmevkmdZDJjK6mMf+xhaW1vLvRlERERERAtWYfNae4YplZKgyekEvN7ybN9smlMB04MPPoiHHnoIt912W7k3hYiIiIhowQqH5XuxgEmzSz7f/FjD5C73BkzVgQMH8C//8i/4+c9/jqCGtJNIJpNIJpNjvw8PDx+qzSMiIiIiWjB0Sl4mA6TTxQOm+TAdD5gjGSbLsnDZZZfhfe97H0444YQp3+7WW29FdXX12NeSJUsO4VYSERERES0MXq80sM1mgWSSAdMhc8MNN8DhcEz4tXnzZnz9619HNBrFxz/+8Wnd/8c//nEMDQ2NfXV0dByiZ0JEREREtHC43RIwAVL4YT4HTGWdknfNNdfgsssum/A6K1aswCOPPILHH38cPp8v728nnHACLrroInz/+98velufzzfuNkREREREdPD8fgmWYrH8xrUMmGZRY2MjGhsbJ73e1772Ndxyyy1jv+/fvx9nnXUWfvSjH+Gkk046lJtIRERERERF2JvXWpb8bFmyrglgwHRYLV26NO/38N/KcqxcuRJtbW3l2CQiIiIiogXN3rxWy4en0/Ld65Wy4vPBPHkaRERERER0ONkDJl3DlErJ9/mSXQLmSIap0LJly2Bp3o+IiIiIiA47+5Q87cukGab5FDAxw0RERERERNMWCsl3zSoBDJiIiIiIiIgAyDoll8sUeZiPFfIABkxERERERDQDHo9pXgtIkYf5uIaJARMREREREU2bBkyaYcpmpay4y2Wa2s4HDJiIiIiIiGja3G6TYZqP/ZcUAyYiIiIiIpo2DZgACZrmY8EHgAETERERERHNgMNhgqNMZv5mmOZkHyYiIiIiIio/bV47nwMmZpiIiIiIiGhGGDARERERERGV4PdLOfFkUn53OACfr7zbNNsYMBERERER0YxoafF4XAInr1eCpvmEARMREREREc2I2y1BUiIhP8+36XgAiz4QEREREdEMeTxAUxMQDgNVVQyYiIiIiIiIxmgvppoa+X0+BkyckkdERERERDOijWsVAyYiIiIiIqK/YcBERERERERUgtud/7N7Hi74YcBEREREREQz4nCYIGk+ZpcABkxERERERHQQGDARERERERGVoOuY5mvANA9nGRIRERER0eHS0ABks6a0+HzDgImIiIiIiGasrk6+5itOySMiIiIiIiqBARMREREREVEJDJiIiIiIiIhKYMBERERERERUAgMmIiIiIiKiEhgwERERERERlcCAiYiIiIiIqAQGTERERERERCUwYCIiIiIiIiqBARMREREREVEJDJiIiIiIiIhKYMBERERERERUAgMmIiIiIiKiEhgwERERERERlcCAiYiIiIiIqAQGTERERERERCUwYCIiIiIiIiqBARMREREREVEJDJiIiIiIiIhKYMBERERERERUAgMmIiIiIiKiEtzl3oDDybIsAMDw8HCZt4SIiIiIiMpJYwKNEUpZUAFTNBoFACxZsqTMW0JERERERJUgGo2iurq65N8d1mQh1TySy+Wwf/9+VFVVweFwlHVbhoeHsWTJEnR0dCASiZR1W8jg+1KZ+L5UJr4vlYnvS+Xie1OZ+L5UpsPxvliWhWg0itbWVjidpVcqLagMk9PpRFtbW7k3I08kEuHBWYH4vlQmvi+Vie9LZeL7Urn43lQmvi+V6VC/LxNllhSLPhAREREREZXAgImIiIiIiKgEBkxl4vP5cPPNN8Pn85V7U8iG70tl4vtSmfi+VCa+L5WL701l4vtSmSrpfVlQRR+IiIiIiIimgxkmIiIiIiKiEhgwERERERERlcCAiYiIiIiIqAQGTERERERERCUwYCqTb37zm1i2bBn8fj9OOukkPPXUU+XepAXj1ltvxf/7f/8PVVVVWLRoEc4991xs2bIl7zqJRAJXXnkl6uvrEQ6H8Y53vAMHDhwo0xYvTF/4whfgcDjw4Q9/eOwyvi/ls2/fPrzrXe9CfX09AoEAjj76aDzzzDNjf7csCzfddBNaWloQCARw5pln4pVXXinjFs9/2WwWN954I5YvX45AIICVK1fis5/9LOy1nPi+HHr/8z//g7e+9a1obW2Fw+HAz3/+87y/T+U96O/vx0UXXYRIJIKamhpcccUViMVih/FZzD8TvS/pdBrXX389jj76aIRCIbS2tuKSSy7B/v378+6D78vsm+x4sXvf+94Hh8OBO+64I+/ycrwvDJjK4Ec/+hE++tGP4uabb8azzz6LV73qVTjrrLPQ3d1d7k1bEB577DFceeWVeOKJJ/Dwww8jnU7jTW96E0ZGRsau85GPfAS/+tWv8JOf/ASPPfYY9u/fj/POO6+MW72wPP300/jOd76DY445Ju9yvi/lMTAwgFNOOQUejwcPPvggXnrpJfzbv/0bamtrx67zpS99CV/72tfw7W9/G08++SRCoRDOOussJBKJMm75/PbFL34Rd955J77xjW/g5Zdfxhe/+EV86Utfwte//vWx6/B9OfRGRkbwqle9Ct/85jeL/n0q78FFF12EF198EQ8//DB+/etf43/+53/wnve853A9hXlpovclHo/j2WefxY033ohnn30W9913H7Zs2YJzzjkn73p8X2bfZMeLuv/++/HEE0+gtbV13N/K8r5YdNideOKJ1pVXXjn2ezabtVpbW61bb721jFu1cHV3d1sArMcee8yyLMsaHBy0PB6P9ZOf/GTsOi+//LIFwHr88cfLtZkLRjQatVavXm09/PDD1mmnnWZdffXVlmXxfSmn66+/3jr11FNL/j2Xy1nNzc3Wl7/85bHLBgcHLZ/PZ/33f//34djEBenss8+2Lr/88rzLzjvvPOuiiy6yLIvvSzkAsO6///6x36fyHrz00ksWAOvpp58eu86DDz5oORwOa9++fYdt2+ezwvelmKeeesoCYO3evduyLL4vh0Op92Xv3r3W4sWLrRdeeMFqb2+3br/99rG/let9YYbpMEulUti4cSPOPPPMscucTifOPPNMPP7442XcsoVraGgIAFBXVwcA2LhxI9LpdN57tG7dOixdupTv0WFw5ZVX4uyzz857/QG+L+X0y1/+EieccALe+c53YtGiRTjuuONw1113jf19586d6OrqyntvqqurcdJJJ/G9OYRe+9rX4g9/+AO2bt0KAPjLX/6CP/3pT/j7v/97AHxfKsFU3oPHH38cNTU1OOGEE8auc+aZZ8LpdOLJJ5887Nu8UA0NDcHhcKCmpgYA35dyyeVyuPjii3HdddfhyCOPHPf3cr0v7kN2z1RUb28vstksmpqa8i5vamrC5s2by7RVC1cul8OHP/xhnHLKKTjqqKMAAF1dXfB6vWMfmqqpqQldXV1l2MqF495778Wzzz6Lp59+etzf+L6Uz44dO3DnnXfiox/9KP71X/8VTz/9NK666ip4vV5ceumlY69/sc81vjeHzg033IDh4WGsW7cOLpcL2WwWn/vc53DRRRcBAN+XCjCV96CrqwuLFi3K+7vb7UZdXR3fp8MkkUjg+uuvx4UXXohIJAKA70u5fPGLX4Tb7cZVV11V9O/lel8YMNGCduWVV+KFF17An/70p3JvyoLX0dGBq6++Gg8//DD8fn+5N4dscrkcTjjhBHz+858HABx33HF44YUX8O1vfxuXXnppmbdu4frxj3+MDRs24Ic//CGOPPJIbNq0CR/+8IfR2trK94VoitLpNP7xH/8RlmXhzjvvLPfmLGgbN27EV7/6VTz77LNwOBzl3pw8nJJ3mDU0NMDlco2r7HXgwAE0NzeXaasWpg9+8IP49a9/jUcffRRtbW1jlzc3NyOVSmFwcDDv+nyPDq2NGzeiu7sbr371q+F2u+F2u/HYY4/ha1/7GtxuN5qamvi+lElLSwvWr1+fd9kRRxyBPXv2AMDY68/PtcPruuuuww033IB/+qd/wtFHH42LL74YH/nIR3DrrbcC4PtSCabyHjQ3N48r+pTJZNDf38/36RDTYGn37t14+OGHx7JLAN+Xcvjf//1fdHd3Y+nSpWPjgN27d+Oaa67BsmXLAJTvfWHAdJh5vV4cf/zx+MMf/jB2WS6Xwx/+8AecfPLJZdyyhcOyLHzwgx/E/fffj0ceeQTLly/P+/vxxx8Pj8eT9x5t2bIFe/bs4Xt0CJ1xxhl4/vnnsWnTprGvE044ARdddNHYz3xfyuOUU04ZV3p/69ataG9vBwAsX74czc3Nee/N8PAwnnzySb43h1A8HofTmf9v3OVyIZfLAeD7Ugmm8h6cfPLJGBwcxMaNG8eu88gjjyCXy+Gkk0467Nu8UGiw9Morr+D3v/896uvr8/7O9+Xwu/jii/HXv/41bxzQ2tqK6667Dr/73e8AlPF9OWTlJKike++91/L5fNY999xjvfTSS9Z73vMeq6amxurq6ir3pi0I73//+63q6mrrj3/8o9XZ2Tn2FY/Hx67zvve9z1q6dKn1yCOPWM8884x18sknWyeffHIZt3phslfJsyy+L+Xy1FNPWW632/rc5z5nvfLKK9aGDRusYDBo/dd//dfYdb7whS9YNTU11i9+8Qvrr3/9q/W2t73NWr58uTU6OlrGLZ/fLr30Umvx4sXWr3/9a2vnzp3WfffdZzU0NFgf+9jHxq7D9+XQi0aj1nPPPWc999xzFgDrK1/5ivXcc8+NVVubynvw5je/2TruuOOsJ5980vrTn/5krV692rrwwgvL9ZTmhYnel1QqZZ1zzjlWW1ubtWnTpryxQDKZHLsPvi+zb7LjpVBhlTzLKs/7woCpTL7+9a9bS5cutbxer3XiiSdaTzzxRLk3acEAUPTr7rvvHrvO6Oio9YEPfMCqra21gsGg9fa3v93q7Ows30YvUIUBE9+X8vnVr35lHXXUUZbP57PWrVtnffe73837ey6Xs2688UarqanJ8vl81hlnnGFt2bKlTFu7MAwPD1tXX321tXTpUsvv91srVqywPvGJT+QN+Pi+HHqPPvpo0f8pl156qWVZU3sP+vr6rAsvvNAKh8NWJBKx3v3ud1vRaLQMz2b+mOh92blzZ8mxwKOPPjp2H3xfZt9kx0uhYgFTOd4Xh2XZWoITERERERHRGK5hIiIiIiIiKoEBExERERERUQkMmIiIiIiIiEpgwERERERERFQCAyYiIiIiIqISGDARERERERGVwICJiIiIiIioBAZMREREREREJTBgIiKieeOPf/wjHA4HBgcHy70pREQ0Tzgsy7LKvRFEREQz8YY3vAHHHnss7rjjDgBAKpVCf38/mpqa4HA4yrtxREQ0L7jLvQFERESzxev1orm5udybQURE8win5BER0Zx02WWX4bHHHsNXv/pVOBwOOBwO3HPPPXlT8u655x7U1NTg17/+NdauXYtgMIjzzz8f8Xgc3//+97Fs2TLU1tbiqquuQjabHbvvZDKJa6+9FosXL0YoFMJJJ52EP/7xj+V5okREVFbMMBER0Zz01a9+FVu3bsVRRx2Fz3zmMwCAF198cdz14vE4vva1r+Hee+9FNBrFeeedh7e//e2oqanBAw88gB07duAd73gHTjnlFFxwwQUAgA9+8IN46aWXcO+996K1tRX3338/3vzmN+P555/H6tWrD+vzJCKi8mLAREREc1J1dTW8Xi+CweDYNLzNmzePu146ncadd96JlStXAgDOP/98/Od//icOHDiAcDiM9evX4/TTT8ejjz6KCy64AHv27MHdd9+NPXv2oLW1FQBw7bXX4re//S3uvvtufP7znz98T5KIiMqOARMREc1rwWBwLFgCgKamJixbtgzhcDjvsu7ubgDA888/j2w2izVr1uTdTzKZRH19/eHZaCIiqhgMmIiIaF7zeDx5vzscjqKX5XI5AEAsFoPL5cLGjRvhcrnyrmcPsoiIaGFgwERERHOW1+vNK9YwG4477jhks1l0d3fjda973azeNxERzT2skkdERHPWsmXL8OSTT2LXrl3o7e0dyxIdjDVr1uCiiy7CJZdcgvvuuw87d+7EU089hVtvvRW/+c1vZmGriYhoLmHAREREc9a1114Ll8uF9evXo7GxEXv27JmV+7377rtxySWX4JprrsHatWtx7rnn4umnn8bSpUtn5f6JiGjucFiWZZV7I4iIiIiIiCoRM0xEREREREQlMGAiIiIiIiIqgQETERERERFRCQyYiIiIiIiISmDAREREREREVAIDJiIiIiIiohIYMBEREREREZXAgImIiIiIiKgEBkxEREREREQlMGAiIiIiIiIqgQETERERERFRCQyYiIiIiIiISmDAREREREREVAIDJiIiIiIiohIYMBEREREREZXAgImIiIiIiKgEBkxEREREREQlMGAiIiIiIiIqgQETERERERFRCQyYiIiIiIiISmDAREREREREVAIDJiIiIiIiohIYMBEREREREZXAgImIiIiIiKgEBkxEREREREQlMGAiIiIiIiIqgQETERERERFRCQyYiIiIiIiISmDAREREREREVAIDJiIiIiIiohIYMBEREREREZXAgImIiIiIiKgEBkxEREREREQlMGAiIiIiIiIqgQETERERERFRCQyYiIiIiIiISmDAREREREREVAIDJiIiIiIiohIYMBEREREREZXAgImIiIiIiKgEBkxEREREREQlMGAiIpqDdu3aBYfDgdtuu63cm1I2y5Ytw2WXXVbuzThsPvWpT8HhcJR7M8a84Q1vwBve8IZybwYR0SHHgImIqAJ961vfgsPhwEknnVTuTZnzHA5Hya/3ve99467/xz/+Eeeddx6am5vh9XqxaNEivPWtb8V999037rrDw8P43Oc+hxNOOAHV1dXw+Xxob2/HBRdcgN/85jdT2r5YLIabb74ZRx11FEKhEOrr63Hsscfi6quvxv79+w/6+RMR0cFxl3sDiIhovA0bNmDZsmV46qmnsG3bNqxatarcmzSn/d3f/R0uueSScZevWbMm7/ebb74Zn/nMZ7B69Wq8973vRXt7O/r6+vDAAw/gHe94BzZs2IB//ud/BgBs27YNZ511Fnbv3o23v/3tuOSSSxAOh9HR0YEHHngAb3nLW/CDH/wAF198ccntSqfTeP3rX4/Nmzfj0ksvxYc+9CHEYjG8+OKL+OEPf4i3v/3taG1tBQB88pOfxA033DCLrwoREU0FAyYiogqzc+dO/N///R/uu+8+vPe978WGDRtw8803l3uzJpTL5ZBKpeD3+8u9KUWtWbMG73rXuya8zk9/+lN85jOfwfnnn48f/vCH8Hg8Y3+77rrr8Lvf/Q7pdBoAkMlk8Pa3vx0HDhzAY489hlNOOSXvvm6++WY89NBDyGazEz7mz3/+czz33HN5gZhKJBJIpVJjv7vdbrjd/LdNRHS4cUoeEVGF2bBhA2pra3H22Wfj/PPPx4YNGya8/u2334729nYEAgGcdtppeOGFF/L+ftlllyEcDmPfvn0499xzEQ6H0djYiGuvvXbcgH5kZATXXHMNlixZAp/Ph7Vr1+K2226DZVl513M4HPjgBz+IDRs24Mgjj4TP58Nvf/tb3HPPPXA4HPjTn/6Eq666Co2NjaipqcF73/tepFIpDA4O4pJLLkFtbS1qa2vxsY99bNx933bbbXjta1+L+vp6BAIBHH/88fjpT396EK/o1Nx4442oq6vDf/zHf+QFS+qss87CW97yFgDAT37yE7zwwgu48cYbxwVL6k1vehP+/u//fsLH3L59OwAUvQ+/349IJDL2e7E1TKOjo7jqqqvQ0NCAqqoqnHPOOdi3bx8cDgc+9alPjbvttm3bcNlll6GmpgbV1dV497vfjXg8nnefd999N974xjdi0aJF8Pl8WL9+Pe68884Jn4f6+te/jiOPPBLBYBC1tbU44YQT8MMf/nBKtyUiqlQ8VUVEVGE2bNiA8847D16vFxdeeCHuvPNOPP300/h//+//jbvuD37wA0SjUVx55ZVIJBL46le/ije+8Y14/vnn0dTUNHa9bDaLs846CyeddBJuu+02/P73v8e//du/YeXKlXj/+98PALAsC+eccw4effRRXHHFFTj22GPxu9/9Dtdddx327duH22+/Pe+xH3nkEfz4xz/GBz/4QTQ0NGDZsmXYtGkTAOBDH/oQmpub8elPfxpPPPEEvvvd76Kmpgb/93//h6VLl+Lzn/88HnjgAXz5y1/GUUcdlTdd7qtf/SrOOeccXHTRRUilUrj33nvxzne+E7/+9a9x9tlnz+g1TSQS6O3tHXd5JBKB1+vFK6+8gs2bN+Pyyy9HVVXVpPf3q1/9CgAmzVpNpr29HYC8j5/85CenXdThsssuw49//GNcfPHFeM1rXoPHHntswtfoH//xH7F8+XLceuutePbZZ/Hv//7vWLRoEb74xS+OXefOO+/EkUceiXPOOQdutxu/+tWv8IEPfAC5XA5XXnllyfu+6667cNVVV+H888/H1VdfjUQigb/+9a948sknx2XPiIjmFIuIiCrGM888YwGwHn74YcuyLCuXy1ltbW3W1VdfnXe9nTt3WgCsQCBg7d27d+zyJ5980gJgfeQjHxm77NJLL7UAWJ/5zGfy7uO4446zjj/++LHff/7zn1sArFtuuSXveueff77lcDisbdu2jV0GwHI6ndaLL76Yd927777bAmCdddZZVi6XG7v85JNPthwOh/W+971v7LJMJmO1tbVZp512Wt59xOPxvN9TqZR11FFHWW984xvzLm9vb7cuvfRSazIASn7993//t2VZlvWLX/zCAmDdfvvtk96fZclrV1NTM+7yWCxm9fT0jH0NDQ1NeD/xeNxau3atBcBqb2+3LrvsMut73/uedeDAgXHXvfnmmy37v+2NGzdaAKwPf/jDede77LLLLADWzTffPO62l19+ed513/72t1v19fXjtqnQWWedZa1YsSLvstNOOy3vvXvb295mHXnkkRM+XyKiuYhT8oiIKsiGDRvQ1NSE008/HYBMfbvgggtw7733Fl0Pc+6552Lx4sVjv5944ok46aST8MADD4y7bmFFuNe97nXYsWPH2O8PPPAAXC4XrrrqqrzrXXPNNbAsCw8++GDe5aeddhrWr19f9HlcccUVedmSk046CZZl4Yorrhi7zOVy4YQTTsjbBgAIBAJjPw8MDGBoaAive93r8OyzzxZ9rKl429vehocffnjcl77Ow8PDADCl7JJePxwOj7v8E5/4BBobG8e+JsusBAIBPPnkk7juuusAAPfccw+uuOIKtLS04EMf+hCSyWTJ2/72t78FAHzgAx/Iu/xDH/pQydsU2wf6+vrGnr9ukxoaGkJvby9OO+007NixA0NDQyXvu6amBnv37sXTTz9d8jpERHMRAyYiogqRzWZx77334vTTT8fOnTuxbds2bNu2DSeddBIOHDiAP/zhD+Nus3r16nGXrVmzBrt27cq7zO/3o7GxMe+y2tpaDAwMjP2+e/dutLa2jgsajjjiiLG/2y1fvrzkc1m6dGne79XV1QCAJUuWjLvcvg0A8Otf/xqvec1r4Pf7UVdXh8bGRtx5550TDtYn09bWhjPPPHPcl05b1LVC0Wh0SvdXVVWFWCw27vIPfOADY8GYfUrkRKqrq/GlL30Ju3btwq5du/C9730Pa9euxTe+8Q189rOfLXm73bt3w+l0jnsfJqqoWPi+1NbWAkDee/DnP/8ZZ555JkKhEGpqatDY2Ih//dd/BYAJ34Prr78e4XAYJ554IlavXo0rr7wSf/7zn0s/cSKiOYIBExFRhXjkkUfQ2dmJe++9F6tXrx77+sd//EcAmLT4w0RcLtdsbeYYeyZiqo9X7HLLVvThf//3f3HOOefA7/fjW9/6Fh544AE8/PDD+Od//udxxSFm07p16wAAzz///JSvPzg4iH379uVdvmbNmrFgbCYVA9vb23H55Zfjz3/+M2pqag7qPS+m1Puir+327dtxxhlnoLe3F1/5ylfwm9/8Bg8//DA+8pGPAJBqiKUcccQR2LJlC+69916ceuqp+NnPfoZTTz214is8EhFNhgETEVGF2LBhAxYtWoSf/OQn474uvPBC3H///RgdHc27zSuvvDLufrZu3Yply5ZN+/Hb29uxf//+cVmWzZs3j/39UPvZz34Gv9+P3/3ud7j88svx93//9zjzzDMP+eOuWbMGa9euxS9+8YuimaNCWi1vtgMaVVtbi5UrV6Kzs7Pkddrb25HL5bBz5868y7dt2zbjx/3Vr36FZDKJX/7yl3jve9+Lf/iHf8CZZ545YXBsFwqFcMEFF+Duu+/Gnj17cPbZZ+Nzn/scEonEjLeJiKjcGDAREVWA0dFR3HfffXjLW96C888/f9zXBz/4QUSjUfzyl7/Mu93Pf/7zvCzHU089hSeffHLSctbF/MM//AOy2Sy+8Y1v5F1+++23w+FwzOg+p8vlcsHhcOSt19q1axd+/vOfH/LH/vSnP42+vj78f//f/4dMJjPu7w899BB+/etfA5Bqc+vXr8dnP/tZPPHEE0XvbyoZsb/85S9Fq/ft3r0bL730EtauXVvytmeddRYA4Fvf+lbe5V//+tcnfdxSNANl3/ahoSHcfffdk962r68v73ev14v169fDsqyx/lVERHMRy4oTEVWAX/7yl4hGozjnnHOK/v01r3kNGhsbsWHDBlxwwQVjl69atQqnnnoq3v/+9yOZTOKOO+5AfX09Pvaxj017G9761rfi9NNPxyc+8Qns2rULr3rVq/DQQw/hF7/4BT784Q9j5cqVM35+U3X22WfjK1/5Ct785jfjn//5n9Hd3Y1vfvObWLVqFf7617/O+H63bt2K//qv/xp3eVNTE/7u7/4OAHDBBRfg+eefx+c+9zk899xzuPDCC9He3o6+vj789re/xR/+8IexnkIejwf3338/zjrrLJx66qk477zz8LrXvQ6hUAj79u3DL3/5y7EMy0Qefvhh3HzzzTjnnHPwmte8BuFwGDt27MB//Md/IJlM5vVSKnT88cfjHe94B+644w709fWNlRXfunUrAEy7RDkgvaO8Xi/e+ta34r3vfS9isRjuuusuLFq0aMJsl962ubkZp5xyCpqamvDyyy/jG9/4Bs4+++wpF9MgIqpEDJiIiCrAhg0b4Pf7xwbvhZxOJ84++2xs2LAh70z+JZdcAqfTiTvuuAPd3d048cQT8Y1vfAMtLS3T3gan04lf/vKXuOmmm/CjH/0Id999N5YtW4Yvf/nLuOaaa2b83KbjjW98I773ve/hC1/4Aj784Q9j+fLl+OIXv4hdu3YdVMCkhRgKnXbaaXmv+S233II3vvGN+NrXvoY777wT/f39qK2txWte8xr84he/yAto16xZg02bNuFrX/sa7r//fjz44INIpVJoamrCSSedhJtvvnls6l4p73jHOxCNRvHQQw/hkUceGXu8E088Eddcc81YFb9SfvCDH6C5uRn//d//jfvvvx9nnnkmfvSjH2Ht2rUzWkO1du1a/PSnP8UnP/lJXHvttWhubsb73/9+NDY24vLLL5/wtu9973uxYcMGfOUrX0EsFkNbWxuuuuoqfPKTn5z2dhARVRKHdShX0RIREdFhtWnTJhx33HH4r//6L1x00UXl3hwiojmPa5iIiIjmqMIiIABwxx13wOl04vWvf30ZtoiIaP7hlDwiIqI56ktf+hI2btyI008/HW63Gw8++CAefPBBvOc97xnX84qIiGaGU/KIiIjmqIcffhif/vSn8dJLLyEWi2Hp0qW4+OKL8YlPfAJuN8+JEhHNBgZMREREREREJXANExERERERUQkMmIiIiIiIiEpYUBOcc7kc9u/fj6qqqhk19CMiIiIiovnBsixEo1G0trbC6SydR1pQAdP+/ftZNYiIiIiIiMZ0dHSgra2t5N8XVMBUVVUFQF6USCRS5q0hIiIiIqJyGR4expIlS8ZihFIWVMCk0/AikQgDJiIiIiIimnSpDos+EBERERERlcCAiYiIiIiIqAQGTERERERERCUwYCIiIiIiIiqBARMREREREVEJDJiIiIiIiIhKYMBERERERERUAgMmIiIiIiKiEhgwERERERERlcCAiYiIiIiIqAQGTERERERERCUwYCIiIiIiIiqBARMREREREVEJDJiIiIiIiIhKYMBERERERERUAgMmIiIiIiKiEhgwERERERERlcCAiYiIiIiIqAQGTERERERERCUwYCqHXA7o7gY6O8u9JURERERENIE5GzB94QtfgMPhwIc//OFyb8rMdHQA+/dL8ERERERERBVpTgZMTz/9NL7zne/gmGOOKfemzIzT9rJns+XbDiIiIiIimtCcC5hisRguuugi3HXXXaitrS335sycBk3MMBERERERVaw5FzBdeeWVOPvss3HmmWdOet1kMonh4eG8r4rhcsl3ZpiIiIiIiCqWu9wbMB333nsvnn32WTz99NNTuv6tt96KT3/604d4q2aIGSYiIiIiooo3ZzJMHR0duPrqq7Fhwwb4/f4p3ebjH/84hoaGxr46OjoO8VZOg2aYGDAREREREVWsOZNh2rhxI7q7u/HqV7967LJsNov/+Z//wTe+8Q0kk0m4NAj5G5/PB5/Pd7g3dWo0w8QpeUREREREFWvOBExnnHEGnn/++bzL3v3ud2PdunW4/vrrxwVLFY8ZJiIiIiKiijdnAqaqqiocddRReZeFQiHU19ePu3xOYIaJiIiIiKjizZk1TPMOM0xERERERBVvzmSYivnjH/9Y7k2YOWaYiIiIiIgqHjNM5cIMExERERFRxWPAVC7MMBERERERVTwGTOXCxrVERERERBWPAVO56JQ8ZpiIiIiIiCoWA6ZyYYaJiIiIiKjiMWAqFxZ9ICIiIiKqeAyYyoVFH4iIiIiIKh4DpnJhhomIiIiIqOIxYCoXZpiIiIiIiCoeA6ZyYYaJiIiIiKjiMWAqF6ftpWeWiYiIiIioIjFgKhd7wMQsExERERFRRWLAVE6clkdEREREVNEYMJUTCz8QEREREVU0BkzlxAwTEREREVFFY8BUTswwERERERFVNAZM5cQMExERERFRRWPAVE7MMBERERERVTQGTOWkARMzTEREREREFYkBUznplDxmmIiIiIiIKhIDpnJihomIiIiIqKIxYConFn0gIiIiIqpoDJjKiUUfiIiIiIgqGgOmcmKGiYiIiIioojFgKidmmIiIiIiIKhoDpnJihomIiIiIqKIxYConZpiIiIiIiCoaA6ZyYoaJiIiIiKiiMWAqJ2aYiIiIiIgqGgOmcmLjWiIiIiKiisaAqZzsU/Isq7zbQkRERERE4zBgKien7eVnlomIiIiIqOIwYConpxNwOORnBkxERERERBWHAVO5sfADEREREVHFYsBUbiwtTkRERERUsRgwlRszTEREREREFYsBU7mxtDgRERERUcViwFRuOiWPGSYiIiIioorDgKncmGEiIiIiIqpYDJjKjUUfiIiIiIgqFgOmcmPRByIiIiKiisWAqdyYYSIiIiIiqlgMmMqNGSYiIiIioorFgKncmGEiIiIiIqpYDJjKjRkmIiIiIqKKxYCp3JhhIiIiIiKqWAyYyo0ZJiIiIiKiisWAqdzYuJaIiIiIqGIxYCo3nZLHDBMRERERUcVhwFRuzDAREREREVUsBkzlxqIPREREREQViwFTudkzTJZV3m0hIiIiIqI8DJjKTTNMALNMREREREQVhgFTuTkc8gWw8AMRERERUYVhwFQJWPiBiIiIiKgiMWCqBCwtTkRERERUkRgwVQJmmIiIiIiIKhIDpkrA0uJERERERBWJAVMl0AwTp+QREREREVUUBkyVgBkmIiIiIqKK5C73BixI2Szw4osSIL3qVcwwERERERFVKAZM5eB0Aum0/JzLMcNERERERFShOCWvHLRRLSBBEjNMREREREQViQFTuWiQZFnMMBERERERVSgGTOWiWSZmmIiIiIiIKhYDpnKxN6tl41oiIiIioorEgKlcOCWPiIiIiKjiMWAql2IZJk7JIyIiIiKqKAyYysW+hokZJiIiIiKiisSAqVyYYSIiIiIiqngMmMqFa5j+f/beNEbW7ioPXTXP1VXVXT1PZx6+efbnCTsGO0C4ISgS4mKCuBGRECYJhCQgAgGEQpQbAUqCACUhIxZwM5AQMBh/NtgY+7O/+cxDn57n6prn8f54eLzeqlPdp/uc7tND7UcqVXfVW++w3/3uvZ691nqWgYGBgYGBgYGBwZGHIUyHBSMrbmBgYGBgYGBgYHDkYQjTYcEakkcPU6uFl4GBgYGBgYGBgYHBkYAhTIcFa0ie3XIbTFiegYGBgYGBgYGBwZGBIUyHBWtIns2m/5uwPAMDAwMDAwMDA4MjA0OYDgvWkDwRI/xgYGBgYGBgYGBgcARhCNNhwRqSZ/3feJgMDAwMDAwMDAwMjgwMYTosGA+TgYGBgYGBgYGBwZGHIUyHgVZLpFQSSaeVIBkPk4GBgYGBgYGBgcGRgyFMh4FqVWRmRmRtTaRex2fGw2RgYGBgYGBgYHCUsLwssrp62Gdx6HAe9gn0JDwevFotkXwenxkPk4GBgYGBgYGBwVFBPo/FfRGRgQERl+twz+cQYTxMh4VQCO+5HN6Nh8nAwMDAwMDAwOCoYGtL/y4WD+88jgAMYToshMN4Nx4mAwMDAwMDAwODo4RmUySV0v8NYTI4FJAwFYsgSZ2qeQYGBgYGBgYGBgaHgXS6fRG/UDi0UzkKMITpsODxiLjdIEi5nAnJMzAwMDAwMDAwOBpIJPBuXeDvYRjCdFiw20UCASVMJiTPwMDAwMDAwMDgsFGtao79xATeazW8ehSGMB0W7HYRvx9/Gw+TgYGBgYGBwW5Rq4ksLfV8mJTBAYFiD6GQiNcr4vPh/x72MhnCdFggYWo2UcSWRMl4mAwMDAwMDAy2Q6EgcuOGyPq6yL17KFFiYLCfIGEaGMA7F/h7mKAbwnRYsNlEnE7kMYmANIkYD5OBgYGBgYFBd2xtidy6paFR1Wq7kpmBwaMilxOpVBD5FIngMxIm42EyeOxgzpLXi3eyduNhMjAwMDAwMLCi1UII3twc/o5ERIaH8d36+mGemcFJA71L0ajaqoEA3g1hMnjsYCcMBjH4kTAZD5OBgYGBgYEB0WyKzMwoMRoZETlzRmRoCLZEsagJ+gYGjwJr7aX+fv3c50NkVK0Gr2YPwhCmw4LNhnefDx2U6iPGw2RgYGBgYNDbaDZFymWRbFbk+nWRa9dE6nWR06dFRkexjdOpRq3xMhnsB1Ip9D2PBwv6hN2uEVE96mVyHvYJ9CzoYXI40DELBZF8XnOaDAwMDAwMDHoLqZTIwgLIEfHWWyBMTz4p8uyz7dsPDYlsbopkMiBYNGoNDB4GnWIPVgQCyLcvFjW3qYdgPEyHCWtsqM2GTthqGcUbAwMDAwODXsT6upIlLqiuriICZW1N5HOfaw+J8njUeN3Oy9RomOgVgwfDWnspFrv/+x5XyjOE6TDBsLxAQOOQRczAZmBgYGBg0Guo19UYpTdpZAT2wdAQCNTqqshrr7UXEB0awvvWVrtnSgRG8NWr8FD1cNFRg12AZCkQ6B7t1ONKeYYwHSboYfL78Xe9jsHNCD8YGBgYGBj0FjIZvPv98ByJQEK81RLp6xN5+WWERG1tgTSRHAWDMHJbLZGNDd1fq4U6TfU6yNLc3GO9HINjBpJ1a+6SFRR+oK3aYzCE6TBBwmSzoYPa7eiwxsNkYGBgYGDQWyBh6uvTz+7cwfvZswi9u3QJ/ycSIl/4gpImepk2N3XRdXkZNoXDAfsimzXiEAbbg4SJEuKdsNtBmkR60stkCNNhgiF5zaZIKKSEyXiYDAwMDAwMegetFgiNiBKmXA4Ex2YTefppLKxGoyJPPQWFvPV1ka9+FdtGIgijqtdFkkmQL5Kj6WmR8XH8vbzck8auwQPQbMJ7KbI9YRLp6TymY0OYfvEXf1FeeuklCYVCMjg4KN/5nd8pt27dOuzTejTQw0TC5HBgIDMeJgMDAwMDg95BPo+53+lUg3V2VqRSAYEaHhaJx/G5zSbyyisgRrdvi6TT+GxwEN8vLuK3IvgsEsFvIxEQs9lZszBr0A6KjrlcO6s193Ae07EhTH/2Z38mP/zDPyxf/epX5U/+5E+kVqvJxz/+cSkcZ5ZLwtRqYYB0OjFgHudrMjAwMDAwMNgbOsPxGg0Nx5uYgCEbjeI9l4OniCIQ77wDO2JgAHbEvXvIZQoE1LMkIjI1hd+XyyJLS4/18gyOOB4Ujkfw+x4kTMemDtMf/dEftf3/H//jf5TBwUF588035cMf/vAhndUjwhqSZ7MhyTOfx4qSgYGBgYGBQW+gkzClUshTcrlETp1CuF4ggDpLV6/CXjh1SuTtt6GA98QT8CI5HAitqtdF3v9+tTNEQKamp0HENjdFwuGerKdj0AW7JUxW4YdKRcVJegDHhjB1IvOXg0usm1b8X6JSqUjFQj6yjA8+KrCG5IlgMBMx0p8GBgYGBga9gkoFXh+bDSRGBB6idBrh+jYbSE5nrcannxaZnwexeucdEKRKBUZtfz/U9Kh41mzC5giHIRCxvo7fihjSZLB7wmSzoX8Vi3j1EGE6NiF5VjSbTfn7f//vywc+8AF58sknt93uF3/xF6Wvr+8br4mJicd4lruANSRPBCtJIj0p12hgYGBgYNCToHcpGFQPEYvV9vVhNX9jAwRncREEZ2oKnz/9NGyHW7fgeRIROXcORCuRQLHbd98VuXlTbY2xMRjG9brIzAxC+MxCbe+iVlO780GESaRn85iOJWH64R/+Ybl69ar89m//9o7b/eRP/qRkMplvvBYXFx/TGe4SnR4mEiYzcBkYGBgYGPQGOsPxEgm8fD6QqNVVEJtKRSXCFxbw+dmzIEC5nMjrr8PwHRsTicUQdvflL4MYlUrwWInAS3D+PIQkbDaE/12/Do+UQe+B3iWfT+3SnUBS1WP59scuJO9Tn/qU/J//83/ki1/8ooxbkxm7wOPxiOcouwutOUwiqkxiCJOBgYGBgcHJR7MJsiMCwpTNirz1lsiVK/AI1WrwLNntIi+8AM/R1hZEH1iU9sIFkZUVeKHu3BF57jmE3G1tYR/lMnKftrYgHCGC/Y2N4f/5eXgL5uagvHf6NIiZQW8gn8f7dgVrO2E8TEcbrVZLPvWpT8n//J//Uz7/+c/LqVOnDvuUHh3Gw2RgYGBgYNC7yGZBajwekJqvfx3hczMzCKe7eROeolYLhm21CrGHeBxE6ItfxLY+HzxIi4uozZTPQzVvaAj50c0mPFmdIf9+v8jFiyBPNhvO56hF4xgcLHabv0RQ+KHR6CmRsmNDmH74h39Y/ut//a/y6U9/WkKhkKytrcna2pqUWGjrOKIzh8mIPhgYGBgYGPQOrOF4uRwIUiqF+kkOB4zYU6dEPvYxCDkUCnh9+7fjN+m0/iafR12mz30OtZb8fniM7txByF2zif87YbMhPO/8efy/tYX9GZx8tFrqKdotYbLZNCKqh3Lujw1h+rVf+zXJZDLykY98REZGRr7x+p3f+Z3DPrWHhwnJMzAwMDAw6F1YCdP8PIhKowECEwzi/X3vA2k6dw4LqxsbIr/3exB+GBpCfhJFHQoFlSP3+/G9CLa5dw/fbYdgUGRkBH/PzxtbpBdQKsEGdTjg4dwtetBePTY5TC16YU4STEiegYGBgYFBb6JYxHxvt2P+J+mx2UCkHA4QnmgUnzudIh/4gMjXvoZ8o0QCRCuTgXfK4QBJourZxYv4/+pV1Gu6exey4tPT2+erjIxgf8xpOnfuMTaIwWPHXsPxiB5UdT42HqYTic6QvB5k7AYGBgYGBj0JepfCYeQpra2BLJVK+C4aRWgek+xbLXignn4anzudIEwDA/i/1YKXwOGAaMRbb+F3Tz4JD1UgIPLee/A0bQebDdva7chn2tg42DYwOFw8LGHqQXvVEKbDhAnJMzAwMDAw6E1Y6y/Nz8NLlMtBAKJeF5mcRIK9ywVC5PWCTF27JvLssyKf+ITImTPwGMXjIFiNBggWZcZnZ2FrvPqqyMQEPAJf+pIeuxu8XhGqEC8t4ZgGJxOP6mHqIXvVEKbDxHYheY2Gep0MDAwMDAwMThYaDU22r9XgXapUQJQqFRAklwtkym5HqNyZMxB5yOfx22efBbHp6wOxKhYh2FAogHRtbor82Z/BK+V0ivyVv4JtUynUZ9qpjk48jm1bLYTmGZvk5KHRgNKiiAnJ2wUMYTpMbBeS12yiIxsYGBgYGBicPOTzmPvdbhCbzU0Yn8w/6u+Hp8fr1fA7pxNESETznAoF2BIM3/N48HmphP2srYE0VavY5uWXsc3t23jV69uf49QUjlks4vwMThZImD0eVWneLXowIsoQpsNEZ0iew6Ha9oYwGRgYGBgYnEywWK0IyEgyCZJTr4MkxWIgOHa7Kt2tr6Nw7egoPE8zMyLvvAMvweAgpMdffRW2xPIyfptIiKyuIgyvWhV55hnUXKpUEG63k2qey6Wqed3kyA2ONx42HE/EhOQZPGZ0huQ5HHi1Wjuv+hgYGBgYGBgcX5AwlcsgI9ks/m42QYg8Hhiy8ThW/+t1FWB4/nl8l8thcTUYFDl9Gh6hb/925DQ5nSIrK9jfygpe772H/Vy4gN/fvo3Pdwq3i0bxXij0VJHSnkA+j/ftFBN3AglTq9UzpMkQpsNEZ0iew6Gf9VBcqIGBgYGBQc+A+UuVCojI6ir+r9ch2BAMwmPU6V1qNvF9JAKCxO/PnwdBcrtFLl1CrtLoKH6XSmnIXzIJifFsFsedncX/6fT25+pyQcWP+zI4OXgUD5PN1nNepmNTh+lEotPDZLNh0KtWjYfJwMDAwMDgJILepXwexubmJkiU0wmPjscDkhKPwyhNJkX+/M9hI5w7J7K4CHJks0GYgfknTqfI9ev4/cgIPFbZLIhOKgWCFoupCp/Xi/pMIiLf9V3bexqiUewnmUQhXYPjj3IZfc5uh2DIw8Dl0pw7St+fYBjCdJjozGES6UnlEQMDAwMDg55BLgeyVC5DlCGdhh0QiYDE9PeD/AwNwSB9+228e73YbmMDHqn5eUSmxOMgQG43CJTfD2I0M4PtUin8PhTCPgoFHCub1QK1/+N/INTv8mVdzCWiUZGFBeRYlUoPb2AbHB1QxMPvV1t0r3C7tfhyD8CE5B0mOj1MIrpSZAiTgYGBgYHByUMyqflFGxsIy7fZQGZcLpCdgQH8PT8PQuXxgNBMTcHLY7PBYA0EsM2bb4LUpNP47dCQ1nCiF6pUQn7Tiy+CBFm9WKkUBCQ+8xmVmiYcDuxDxITlnQRYCxI/isewx0LyDGE6THTmMIn0XAc0MDAwMDDoGdTrIvfuIRwqn9fE+74+fBeJ4DUyAgW7ZBIEZnQUNZcGBvB3KIS6TKdOYZXf4QABqtVQYykYFHnySZEXXoDIw+goCFa5LPL+94s89RS28Xpx7KEhkKpUSsP0rKD4g1HLOxxUKvtTC6teh0dRBHlyJMIPgx6LiDKE6TBBN2irpQ9Cj3VAAwMDAwODnsG9e5psn83C6+N0Yu53ueDxmZoCoVpcxLbxOEgUa99kszB8SyWE9EWj8Bo9/zw+a7UQ9vfccyKTk/A0RaOoz7SwAO/W1JTIxYvqeWo0QMhEIAbRWXcpEsEiL4UqDB4vZmehcmiVo38YzM9reOfY2KPtq8dqMRnCdJiwxgl3EqYe6YAGBgYGBgY9gWJR5O5d/M2CtY0GjNdUCl6eU6ew6j83h5C9VgshelZPAL1OzEEKhUB+slkQpIsXRSYmtK5jNIq/PR4o8r33HrxL/f04ZiAAAra+riITn/88ZMdnZ3EujYYJyzssFAp4NRqPlj+WSCBk02ZDP+vMVdsresxeNYTpMGHtrMxj6rEOaGBgYGBgcOLRbIJ8FAqY5zc3QXo8Hsz3fj9CpC5cAHHJ5zV3yGZTae9mE0ZvOo3P7HZ4Cqi4x1wnGsRDQzhmqwWSlE5DDCKRABELBPB7r1cFHUolnOu772K7rS0Uwo3FcA4mLO/xgt6+WEzz3PeKchkeSxHc7/1QteuxiChDmA4bnUp5PebiNDAwMDAwOPFYXASpaTQQVlWtghA1myA0Q0PIOapUEDInAg+QCIhPKIS/qahXLmveUqWioVqTk9g+FgP5Gh6Gh6nRwKvVQsL/9esgY4EA9jU8DEM6FIJ0eTCI/RPJJMiUwwH7hLlXBgeLel0Jajz+cPtotUCAm03cX9b2elTQXm002sXLTigMYTpsdCrlGQ+TgYGBgYHByUGtBi9NsYiV/a0tkBy3GwTIbgdJmZoSWVqCgRuJqD0QCuniajIJDxCJjt+PUDy7XZXviEAAhWwvXMA+cjl4KPJ5hNlVKvicggKhEI779NMQhXA4sF/mWa+v43ueh8HBI5FA2wcCD1dglvugMMj09P6dG/uHSE/YrIYwHTY6lfIMYTIwMDAwMDg5SKUwx9fr8DS5XCA6GxtYLJ2YEDl7Ft/nciBHExMQaRDR3KF6HeQomwUxcrnwtwiM14mJ+4/tdou88gpU8lotJUeLixpmR69Rq4XzcbvhYXK78XmlAo/Y1pZ6unhNBgeHVkvD8R7WuySi3sChIfUK7Rd6KCzPEKbDRmdIHjtfvX4452NgYGBgYGCwf9jawvvGBoiGxwN58K0tLJo+8wz+X13Fdv39IDFUo6PXyEq8PB7YDevrIF+jo2o/dCIchrx4MKjGczYL0uRwwHORy+kCbrUKYhSP42+vFx6KZlNV/UjuDA4OmQza3+lUWfeHQamE9/3IW+pED6WRGMJ02OgMyTspna/Vghu40TjsMzEwMDAwMDgclMsgG1tbmBNFEHq3tqbFakdG8J7N4rPhYfzdauFzjwe/29rC/nw+2AypFN6j0Qd7IN73PhxHRMO85uZwvEBApcVFcOx4HN+5XDgGSVIioQTOhOUdLFhcdmDg4RXtmO8m8mgKe9vBeJgMHhs6Q/JOCmHa3ITeP1VZDAwMDAwMeg3JpAot5PMq4724CGN2agoEhGQqGgVBYqgdyQnrH+Vy+Kxcxt9uNwrYMlplO/h8Ih/7GIhPJgMbY3UVMuf9/TjHfB7vjQa2c7vxqtfhnSKp4gIvBSgM9h+lknrwHiUcr1zGPXU49j8cT+Tk2Ky7gCFMh43tVPLq9eM9EBWLeM9kTJyzgYGBgUFvYmsLRKRQwHw/Pg5jeHMTC6bT0wiVSqexPb1AnflL9ObQLmD43vT07sUAXn0VxrfDoTWcrl7F+Xk8eOciLr1MVlAAIp8HoWo0lNgZ7C+Yu2QtWPwwOMhwPJGeyrs3hOmwsZ1KHld5jivoAq7XlTwZGBgYGBj0CvJ5hCrlciBEgQA8TIuLIFB+PwhPpYLto1Gth1SrwT4IBvFdMontPB54q6pV/H3x4u7PJxAQ+cAHYGfkcjjW5ibCAykmQVskm9VQMJtNa0WVSu051iYsb//RaGje2+Dgo+2L9tdBhOOJmJA8g8eIzpA8yjSyZsJxBQmTiFmBMjAwMDDoPWxtad5PtQpC5PejJk69Dm/SyIh6l4aH8U7vUigEe6BY1BA8h0O3n5xslxHfDT74QXgtGg0VFNjYwHGWl7HvVgvHpMDE3bsid+7gemiXUG0vkznetspRxNYWiKvPp6qED4uD9jCZkDyDx4ZOD5PdjgGRA9VxRK3WPoBy8DcwMDAwMOgFUJQhm8Uc6HajHtLKCoiJy4XcI86VfX1q1HbmLzH5n7lQzSZITzcZ8QdhYgJeKacTpIiFdPv7YXPcvKm2RzaL87TbcczZWXjHZmdhiFcq+NzM8fuL/ZASJx6Xh8kQJoMDR2cOk7UQ2HF1cdK75HTivVA4vuTPwMDAwMBgr8hmQUbW1jCX9/VB+ntxER6Evj6R8+fvz11qNFT6u68PxGRrC/uoVPC/wwFjur9/7+flcIg8+yz2zXykahUGdSQC8sQwu40NnM/QEM7dZoOtksvhOkjkTFje/iGdhg3lcDzc/bWiWsX9s9kOnjC1WieeNBnCdNjo9DDZbEo0jjthCgT0ITVheQYGBgYGvYKtLRCcdBrvU1OY72/fxgLiwABIT6uFsCsKN+Ry+MzjwWtlBZ/XaiA3jQbIVSSicuN7xcWLOHa5DHujUhGZmQEpqtc1lHB1FecyNgaxiqeeghcsGsX3mQwIXDZrFkX3CxTzGBx8eClxguF4Xu+DVRR3Qjq9vQ1H6XkRQ5gMDhidOUwix794LQmT16sKP4YwGRgYGBj0AkgmFhawGBoKId9odRWfud0iTzyhhWmZu0SPlAjmznwexqrNpoqzXi/I0qN4H/r7RU6dAllyOnEemQzO1eNBSFgmA/JWKuFcpqbwndOJ44vg781NnBc9ZQYPDyoX2u2PLvYgsj/heMvLINN3726fq2YIk8FjQWdInsjx73xWwsQYbBPjbGBgYGDQC2BB2fV1kKeJCZFYTOTKFRCLWAyEpdHAfB8KYfu7d0FeGHK3vIz91WqYQ6tVeHrsdnh5uiGTaRdd6ga/H8cPhWCkBwJ4z+ehylcogLhRDp35VYODOPf1dXzWaOBaWy0TlrcfoHcpHtdIo0fBowg+tFqopUkC32ppXahO9IhSniFMh43OkDyRkxOS5/Vi8HU4jLy4gYGBgUFvIJmE8Wu3Y+4bH8d8ePMmjNjxcV1MjERgjN69C4LicIicO4d5NJ8HAWJR23AY5CYSwXadKBSwn1u3HlzH8exZkC67HTYH52iXC/+vrIDclUpqcI+O4jcMw6pU8PfmJozp47rIexSQz+NlsyFnbD/wsB6mZlPk3j3td/z9doSpR5TyDGE6bOwUknccCVOzqefNuFnKYhovk4GBgYHBSUYuh9f8PIjH2BgIx/w8SIjT2V47KRJByBMlw8+dw/aU+GaOUCSiqmnbhePRy8M8pJ0Qi2leVTqNfabT+N/vh7G9uKgLniL4m94yKv+5XPA4icDbZPBwoHdpYEBtwEdBs6n1vfbiYWo0ICHPUNAzZ1SQxHiYDA4VJy0kjw8oY6NFNI/pcRCmUgkDz507mITm5hAzvryMQf04tqmBgYGBwdFHq4X5JpnEnN5owJvU1yfyta+BhAwNgfg0myAgLBprt8PrEwjg92trmLNsNniW+vvxHUP4uh3bSljW19sXYjsRDsMYttsxL7rdqmgbieDvQgFzunXujkaRj2Wz4fyLRbxKJROW97AoFtEH9tO7xHA8lwv3iTlqO6HZhCiJ1dMZiWh/Y0HlTvSIh2kfgiQNHgndQvKOM2GyhuMRDD3gYLwfsblEq4X9ptOqRrQT0mnUwjAwMDAwMNhPrK9jFX5lRXN8mJ904wYM46ef1hCnQgHb2O0wToNBbHvtGhb++vthRMfjeG+14N3ppniWz8NmcDjwfaUCAhWLdT9Xmw15TH19mLdTKZxXqaQy4yJYbMxk2r1aU1NYkKQSYDgMD5rPh9/SgDbYHehdikYfXvmwE9ZwvEQCRH5oCAR+O6TT+J3TqZ5OEfxPr2Mud3+f2qvNyjqj++FJe4wwHqbDRreQPA42x9G92Y0wud0PjoHdKxoNTE7XriFee30dA7fdjhWRyUm8xsfhTqZEZz6vcbkGBgYGBgb7gUoFeR9zc5hr7Hao39lsIp/7HOY+txvzkscD45MLpWfPgiyJYE5bWIAxGYuBLFkNy+3C8ehdikRUYY0J+9shEhGZnoatQTW8TAbn1t+PeTyXg9fBaqN4PBpWSOOXXjXjZdobyuX7a3HtB6yCD1RjfJBaMc9jYOD+MD56mbrZcHsNyUunIYCyuLi77Y8IDGE6bOzkYTqOsuIkTJ2rJNup5dXrIktLKIC3U/gAUSphMnnvPfyuUtECb2fOiDzzDN7jcbxYcG9iArHkIvjdcfTeGRgYGBgcTVy/LjI7i/mItYoiEXhorl/H3PXMM1g8dLvhnfH7YZyGQpj/bt/G3CaCFX4unjqd+N7v757Abw3HI8my2zX/aTuweG6jgbmY76kU5shz57CfO3fun7unpnCNfX0QfXA6sXBpCNPeQFIbibQvND8qrB4mRt6UStvblc2m3uNuCow7ESb200bjwWF/ImrvdRMuOcIwhOmw0S2H6TjHg3bzMIl0r8e0tYXVtPV1rDTcvLm9kl4+j0H7+nUMzs0mBoKpKYQ4TE9jwNmp0Fs8jhjwRuPYrWwYGBgYGBxR3LuHuUkEXqXJSRiEpRIIULmMRb3JScyN6bTmloyOYj6bmcGqe6sFj1N/vybu01vAek2dyOc13D0UwvvAAL7byctkt2Mxkcp3LGSbTMIrMTaGeTWTAZnr/O2TT+IaKI++uIhzNYq4u0OhoARzP71LIu0eJmuqAr1Nnchm0d/c7u4iEcGghnp2epIcDrW9HmS3lkqqBkgRk2MCQ5gOGzvJip8kwhQManJpKoXBd24Og7zPp8mjN29iRY7tQaJ065aSrWgUq2KXL2NS2G01bJsNBMtmwzmYQnsGBgYGBo+C5WWRr38dROf0aYSBN5uY6957T0PVRkdhjHq9WPQLhzVkjyJF5TLmqCefxIJiLqceAUp6dwON7khEF2GHhvB3Lre9kSyCfZ4+DSO4UID9USrpsU+dwrXdvHn/b+llGhhA3la5jN89SKHPAMTj7l20bTT6cLWSdtp3s4n773S225L5fPff0EO5XR9zOLDgLNLda7nbsLyNDbxHIiaHyWCP2CmH6biF5FWr+pB2huRR6UcEq3G5HK59fFzk0iVUPY9G0Q5ra0iQtRIlmw2D8pNPYnDvphK0G/h8qkKzsLB95WoDAwMDA4OdkEyKvPsuDNKREZFXXsF8lU6DNKyu4u+BAURZ9PVhXrfZMN9Fo5jjEgnsa3ISC4GJBBYQMxkYqQMD23sgWi1d/LMm47vd+j9lv7uhrw8erXodhjYVbldXcQ2nTuF8qebXiaeewoIoc4jv3gX5201oVq+iXkc71esgStPT+7t/azheJ4HpFlLXau0cjkfsJixvp4X+RkPJPfPsjhEMYTpsPCgkbzd5PUcF1vylbio+JEz8+/JlXQVzuUCEzpzB3+VyO1F64gmsZu2HgszICPZTq2kldQMDAwMDg92iVsOiXiqFOerFF+GZSaVgDFMW3O8HobhwQUUVQiGEuy0swLhdXwdZGhsDWblyRXOZajUYvltb8AB1EhF6gpxOFY4guDiYSun83AmHAwuXsRjsDY8Hx2s2cX2sAVWpgAh1YmwM4YPxOK4tk0Ge8F/8Ba7LLEq2g+GX5TJsvbNndx8ls1t0C8ejN8cqNkJksxpWSS9SN+xG+GEnwpRIaDpFZ189BjCy4oeNbiF5nQl0xyUxbrtwPGJgQAf/7VYxqPm/uorBe3Bw/2Q2Cbsd5Ov2bYRGxGLH8uE1MDAwMDgkzM2BEHg8yAMqFBAZQRGj2VnMZUNDEE/o60OOT6uFRbtQCNEWGxsIzQsGMRd94QvYj9sNIuRw3J9z6/XCGPb71XhlHpIVPp+StPV1zHvdQLW8d9/F+Zw+jX2l0yJvvw1ClEohLO+559p/63BAMW9zE/O73w+7ZWsLx19dRftsp+7Xa5ib0zpHZ88eTFhaN8GHUAh9pVZDX7VG6TwoHI8IBDS1oly+Xw1ZZOeQvM1NvB9D75KI8TAdPrqF5DmdGKxY+O644EGEyWbbOQ6b4IrXxMT+kyUiFNKk2KWlgzmGgYGBgcHJQyIB449REOm0ht8xHM/vBxEZH9dcpXweBvKFCyAx+TyMW48HURfXrsH7YLdjm2efxTwVjeJ7GtflMkKbFhdF3nkHdsJ28yqFIra2trcnIhFEdxSLuLZYDBEgtRo8ZYz6WFnpLugwPAwSaLfjuuNxEEAKQpjwd2B5GeTEZkN7d1M83A908zB5vbowbM1jsobjBYMgxfPz3aOb7Pbt85ge5GHKZFTVeLvaYEcchjAdNrqF5FFx5KQRpqOG0VG0f6GgA4yBgYGBgcF2qFRAVEiKHA7MeT4fFuJSKczffX0gPaEQDFEmu09O4neZDMgJC9tubcFQFUFe78c+BqP61Cl4fM6dgyLs00/DMzE6itX8chneo+1CqYJBnJs116kTTieIXSCgqnzj4yBhjYYu4haL8Jx1wuvF9sEgjlEqgYSNjOC7ZlO9GL0IhjNSsXB6+uHzsB+ERkO9PFYPk8fTnTBZQzqLRdhDicT2SsJMregMy3uQ6AO9S3sR6jpiOJ5nfZJg9TCR0bPoHQvCHRccN8LkcmFQF9GH2cDAwMDAoBtaLYRUlcswDD2e9pp/a2ua1D4+DpIRiWA1PpHA/5cuad2kYhGGZ6OhanbDw9hmO++DywUyNjKClXqbDfbCysr2580V/Z1qJEUiMGYrFZxLKAQC1WziuhiR0U0tTwQErq8P19Bq4X1rS0PxelE5r9mEV+naNRBJm03zxQ4K9AC63SDz5TLsyM1NXaDnPRJREh0KtdtBm5vdJemteUzdxMq6eZgqFfViHTMpcSsMYTpsWJk2O5/DoXlLu62cfNhoNPRBOS6ESUQfXkq/GhgYGBgYdMPGBlbnk0kQBBHMd319EHpYWoIhOTSkpTRyOVWpu3ABxCSX0/00m1jdr1RAkliv6UFoNmEMj45i1X99fXtSwnA9q0x5J8JhrWVYrWLbeByG8PIy8k6aTVxjt7C8cBjb+/0giLkcPE0kfvl8ez2gk4J6HdfLa+a93doSuXoVpKPVahe6OkhYw/Eob7+2BmK0uIh712hgO2vBY0Y0eb1IhxDBfe/sU/Sqch/ETiF5JGJ9fQeXZvEYYEQfDhvWJM1mE4MVtfNFjg9honeJxfiOC0IhPMCVCiYvrqIZGBgYGBgQ5TIMyGpVw8z6+jBnNxooXLu8DO9BOIzPMhmQlWIRRugzz2BfmQzIV6ulYg/z85g7z5/fnVFJBbr+fsxbq6vYh9d7f3iex4PPCgUYyN1W+et1kKJIBIbw+jq8IevrMLadTlxrNovrPHfu/n2cOYOQvUQC191sYvtwGO9bW0o0jzNKJVUE3K6uEeHxoB0ZzXLQIIlhOF65rPW1Wi3YOdUqzrvZVJl71uoaHkafItGan4ddx1A8mw19NpPBPWX9KBImRkbRhm020R9EjrV3ScR4mA4fNlv3PKbdFgE7Kjhu4XhW8CE2YXkGBgYGBt2wvg5jsFxWT4zPBw/MrVuYP4pFeBBqNWzPkLlTp/DivE7BBp8PRGptDYZuPA7jejfnwhC8kRGQkEgE5zcz032Vn16m7cLyikUlW82mepGiURi/S0sajrVTWB7znhjal0yejLA81oi8ckXJMckSc9h8Pvzt8eB9dBRepcdFlkTaRR4qFZAVtxv3pb8fn6+uIrSU3iWSHGvtrrExlZqfmWkvftwtj4nlYUTa7dZkEv3B48ECwzGG8TAdBXCFyhoPyo53XEQfrA/pcUN/Pwa/YhGv/ay4bWBgYGBwvFGrwdivVnVu9vnweTKpst30zthsIB6nT2N+dzhUra5U0tAoyovfuYP9nj+vuSDbYXNTlV1HR3XBb3oaxK1UgoF7/nx7yH8sht/l87iOzuMUCqriR0WzjQ14r1IpXOfgIK6N5985V7rduKaVFXgf3G41kh0ODfU7KMGDg0KxCIJB743djmtgMeIH3bPHCdpibjfIUi4Hj9DwsKrmbW5C0p5eJ+bjsS4mMT2tIYczMyhSbLPp/cvn8Xv+xuXCM2El7BQ7OebeJRHjYToaMB6mw4XTqatvxstkYGBgYGDF5iYMw2IRRIlemEQC88fiIgxL5izZbFCz6+/HZ/39alSvr2OF3+fDKv7iIgxxSnPvhEQCEt0i92/vcCAkzukE+ZmZuX8Rlipp3RTr6FEKh9XYpkdodFTFKai2100QgNvG47AJmDOVSqnn4jC9TJkMalxRvp05OoVC99wu5mzduIF75HSCRDzzDJQKmeN1VEDyIwICRGLt8YBMLy4ilHJwENdbqShJdjrvT0mw2UD6SYQo3ODz4bNO9cNwGLYU0zKyWbSb3X4i0h2Mh+kooFvxWsZ/7lQ1+SjhOBMmETzMySRe4+P352HR03ec8rMMDAwMDB4NzSYIU7Wq438wiLkin4eHYX0dfzudMEaHh0VeeQWeIxH1Lomo8d3fD4N0bQ3z5oOKmCaTKjs+NASy1QmPB/u5fRvG6twcQgGJWEzFJqziA42G1pTq78f5lcs4Xl8fjGB6J+p1GOa3bsGY7kQwCCK3sYFtt7ZAKs6fRzumUghDfJxzaa0GsmA17mmzWOFw4Fw9HrzT0yaCtpuYUNvsKIJkiVFL9O4wn4wKzFNTuNZSST8fGuou9+1woE+sreFeMrxwcBCEc3W1PYzPCoqdDAycCNvJeJiOAroVrz1OHibGdYscXwWUUEgTeTtjvBMJkffew2snWVYDAwMDg5OFrS0Y/skkyEA4jP/X1uBpYvhZLgcjOxIR+ZZv0WiFWEznRSrZMQl/awsG+ehoO6nqRDar9Y8elOcUCMDTZLNprhQRjWo9JatiXakEW4P1mJhv5XLhuJUKjptKoQ3K5e3V8lh3ioVrFxZUCfAwajIlEvAo8ZhDQ/CyTEzgmkKh9hSIUgketI0NXLfbDRJ66tTRJksi7eF4q6sgiqFQO9HneyQCIkSP0E4hc8xBy2TUExePq2x5t/tZLmtx28HBR760owBDmI4CdgrJOw4epmoVpMluP1ru6b2CLmMqutTrcNvPz+PeNJuYPDgBGBgYGBicXLRaqhLndmOOm5hoz+FZWMBKu8sFw/LJJ2Egsr4Nw+bqdYgl5POaC1OtYn+nTm2/At9owFMksnvJ8XAYoWMiMPxXV/G306n5J9bFv2IRBq7Ph/N1ufA+PAxyt7SkctIimtPVLSzP48Hvp6exXTar1/w4xR/qdXjB5ufRhn4/6luNj6N9BgfRlufPI3zyuedEnngC5GhyEsSKog3HRazAusCeSKD96V0SUfVEEid6LAcH9d7yd1Z4vWg/quyJYHsSIfYvK+hdikSO70J6BwxhOgroFpK3UxGwoward8maMHjcwBCJYhEDQGexOU58m5uY+Lq59A0MDAwMTgYyGRCGRAKG3+go5uTlZcwL1SrqLxUKMKrPn0d+C4lENKph6svLSLRfW8PqvNMJw5zG+3ZYWsIxvd7dkSWCIWQi8IJZPV4i7V6BQgHeCa9XldR8Pnhi6EWgt6VUgvGcTGo+VSeCQbRHMAjyNDeHeZWE6XHUZKKKHUnuxYs7CzrZ7VpTi168kZHjFUrGNk2n1bvEMjVer3rIgkH06WwWZJL9L5cDibp27f6crm5kd3AQ7UaZdYIeWZGDrzv1GGEI01HAcQ/JO+75S4RV/GFlBQ+9z4dVKa42nTuH7UolxKKbED0DAwODk4n1dRCccBhG5tAQvBb1Oua7d9+FB8fnQxjc6dNYxScZ4SLb2prIO+/AiPf7MZeMjqpXajujPJvViIepqe45JjthcFDPYWEB5xqJwIguldTTVSxqfSmqv7ndSurKZfxfreK3fj/IyN273ZV86cEYHdXwsFKpvZ7PbrxMuRy8eXu1g4pFbTeKHBznxdzdolrFq1gEYRoYuN+7RI8lw+VCIdznZlM9TpSSt4IS+cWi9hvm7Im0e5k2N7E/v1/7wgmAIUxHATt5mLaryn2UcFIIk0h7HO/QEFalWKlcRKt1h0IaovegwnUGBgYGBscLhQKMwHwexuLUFAxFhmgnEjA8y2WQirNn4clgfaRYDHMHJZzX12GIDg/De0GisV3uSKPRHjL1sIbn6Kiu8i8u4jwYYsYaOaWSeph8Pg1PbzZB6DwezUMisXI4sD8SEysY9uf3Y9taTdvF6qmwLhJ3u/5790Dyrl3rfpztwLytWOxEGewPRKWCe+p0ai0o2pDMPbt5Ex4oj6dd3n15Wb2I3XLknM72fkNQLKJQAAlrtdSbeYK8SyKGMB0NdMthOk4qeXwgd1L4OS4IBrEixVjnbit6Lhe2YWgDpTsNDAwMDE4GVlbUuzQ+DuP/3j2Qi2QSBubCgub6UEGNYWBjYyAFCwvwOHm92La/H//7fJhvrAtyViwva32cbop4e8H4OIiTCEggxRpSKVxPraYKcW63krhaTfNbmk0QKYZ7USmwW1iez4ff2GwatbG2BhIUiSjx2okEUWVPRL0fd+8+2CaieqHdvrsiwCcJlYp6A5lzxDasVETefBNkcnkZ9yCXA+nP5VRRjwp63dCN7Dqd2l9WV9H+tRrsJN77EwJDmI4CjnsOEx/Io64gs1uEww8uXsu8Jq6sPE7VHwMDAwODg0OloqF3o6MgOskkjMpsFgbn7KzmHz3zDIgAE92Hh0FK6I2yylUHApgzXK7tc5dyOV2lf5hQvG4YGdEcqHIZxm25jHOuVEByvF7MbfG4hu0NDOC7RgMeg1YLBnMwiPa5cqX78ejZYXjX1pbW5GGY4OpqdwGlRkPb8tQpzLU2G/Jkrl/ffr5l3SRe70lYxN0tmk3cD5IVEdxXpxP98M/+DH22WMR9ZG2wRgPiViK41wyZ7Ia+PuyPMu2FAj5nwdt8Xtv/BIZBGsJ0FNAth4mEiYXijjJ6tUaRy6Uu5+Xlo3+fDAwMDAwejDt34EkJBEQuXMAcvbYGj8jNmyBPNhsIyKlTiDZotWBIejwgGPfu4TOnE/th8n29rkpyrGljhTWXhLLX+4V4XBX57HYYtzMzGo7HsHq3W4/rcODvahVGdl8f2obbzsyo4WwFfx8IYH/ptG4Xj6MNajUlRlZsbMCu8HpBuIaGEPXh96P97t1TFUIrKKXt8ZwYKetdo1JBm5Ggt1po77k5tFezqeT+zBmoAj75JPplKrV9KJ4V9Bi2WiJXr+JZyGTQlxnGyQLOJ6BQbScMYToMsGI4k+52khVvNLonVR4lnDQP014wNITrrlT2FmNtYGBgYHD0kMkgZ0YERnowiM9SKZEvfhFzd6ulYW5jYzDsqRIWj2Mlv9VSlbxsFuTI4cB2fr96caxgKQvmkjxqKF43xGLIt4rH1aBOJjV/iWD4VamEbatV/H3+PD7f3MRvikV4fTpBD5PTieu15jHZbHpta2vtkTRW79LoqLaRz4ecYp5Xp+BSpaK/2y6c/iSjWkU7ut2qbPjeeyDFXi9yr7/lW0CWBgZUJj+VQj/YKRTPiv5+jaqx2dQjNTys96q//0Tagz3Wo44IajWR//E/RP73/8bg0C0kz+lE52s2DWE6ynA4NDZ8ZeXo3ysDA4PjB6pfGRwsWi2RN97Q3J1z5/D5+rrIl76kMsyXLqkYQiQCY73VAklIpzFvU1WvUECIndeL92IRXpfOFfh8Hsqr2Sxsgunpg4vaCIeh6BeJwJuzuKieMYLnl8ngOlwuLAo+8YSSQLcbhvmNG/cfw+/HdbRamu/bWUQ3EEBbWRXW1tfRxj7f/TkwNpueFwUGiKUl/B8Od/fcnXRUKni5XBgrrl2Dp9LpFHnhBXiUrAS92VQvnVW98EEIBHTRgHaqCPrCyAju205FmI8xDGE6DFiJRa3WPSTP4dBEy6NshFtDBnuRMIlgAKcaTbfwAgMDA4OHRaOBFfzr149HTutxxuwsjHeHQ+TFF/GeTot89rNof48HRMPt1ppFLGpus+HzfB6/O3UKBKNQwO9mZ+HNWVu7P3x7fV3k9m1VoLt4cX9D8bqhv19zTzY2cJ5WpVuGtKVS+JtS4m43BC6s1zA7CzJohc2mXiYSppWV9t/Ry5RIgHjV6yo+wIXITgQCaN9GQ8UrcjmtmcjaU70GephqNfTVhQXYZBcuiLz00v3ezHQa7Uhxht3WxaJASDeMjMCTxZSSEwZDmA4Ddrt2ONY1EGn3MDHG2KpychRBMmez9Z4LnLCGF6yv32/UVKv3r4YZGBgYdKLRgOFsVd5MpzU027oSb7C/KJdF3n4bf1+4ACM/lRL5wz+EAWq3q3R4vQ4CEYupkEEwqGIEExOYw5NJjP3VquaUuFyYI65cQW7J3bvqHYnF7i9lcZCgXHmjAQPbauj29eFc63WcW38/2mhzE+coorlP9I51goSJtZ8ymXZixZpPrRbygOld8vu39xLZbEommdbA8DwuXvYi6GFKpUDKHQ5V/O22mF0uo98ODWFbtuWDsLUFb5TPh37Mmkw9gB61cI8ArLLh3ULyOknVUUUvh+NZEYlgcqBKTyqFCejqVUyMd+5gddGQJgOD3kOzCUNzcxPGXSYDI7NQaF8QW1mBQbm+fr8xKKIr8SJ4z2S6q4wZ7B1vvQXjLxxGMvzsLMbuN97AuP3EExpiRyGDWg0Gut2O+9FqYS7o74dh2WhgLqjVcL+Hh0HGBgexbSqFe2gVkHic4kmNBrwCHg/62dqafme3a0icNY8pmYT3hyp5Xq+qCnZGw5AwORxo12q1/RgiutiYTmuEBlX0tgPDx/iMkISxTlAvolJBP0ul0Lf6+pCXtJ2nkuMIvX+dHsLtkEiASE9N4f9usvInFD1u5R4iXC508GpVyYbVmKaijoghTMcFY2OYNJLJdiOHHsRkEpMQBxoDA4PewMpKe7gua9AwD2RoCMYlw2jCYfx9/rwaMpSjXl6Gwf322yBLfX0w0Pv7sU0nmk0YvN2+MwDW1kCQbDaE4q2tYbz+2tdg7A8Pw7u0tYU5j3kyuRza3WZTOWeO75ubIEPlskaM+Hwizz4LQlAqYZtKBXPHg0pZHASKRVzL6CjIznvvaSFSEXhsKKUei4EcpdPqmZibQ/9isdLV1XalNaoDUgAjk8FvKBwhooVyEwlst5N3iSBhKhTQvgwn66UitZ2oVtEW1aoqG3q92z/3JEwDA7hvjILZSQo8n0db2+3wXN24gc8SiROpitcJY+UeFqiCV6+rG7xzpZDbGMJ0PBAM6sqi14tBPRzG59kswi8SCQxmvVZQz8DgOKHVUnneR0WjoQqaXi8M0GQSxmoqhWPkcjD+3G6QobU1bHv7thrW0ah6mLi4ZrOBiNGw9fmUOPn9GHeWljCHxGIQEjhhtVEeGY0GiFGrhfaJxTQHJJ1Wj1M+rzlGdrsWbyVhsNlAlli8tlxG0r3bjfs5OgovDUtR+HxaF+mwrptk44knEBq4uQlCc/o0tqERvLUl8tRTIDKlEtplelolxSMRfHbvHsgf+5jdjn5YKKBd5+Y0j8naD0dH8Uw0m9vnLlnh8eBVqajHyu/vvdImRL2uC/DWscHl2p5EkmTGYirjXirtTNw5jpE8j45ifFle1oLEJxgn++qOMvhg12rdc5hElDAd5UTfXq3BtB2mpzV+3YpoFJPp/DwMHIfjwWEHBgYGjx/VKjzF9P7TOGPtHKcTzy/f6T2w2dqNwFoN+7h7F+FeqRQMUJcLK+2VCohNuQz1sEwG/1N96soVGKqZDPbFgtr1Oo5z5gzGmmIR2ySTIEulkkosM2TK71fD/tQpLVgajxvP07VrIJYeD7xLS0sw8K9dw2dTU2jD2VldCHM4QIoGB9GuTifakiFhm5v4PpdTYuV0irz88tHJ9WXuCcMIL1/G/PT226p2FovhWksl9LnBQdTeSaWw6Od2a92dUgnkJZttD42jZzQSwXZcLLD2O5cLHrxqdfdhdeEw2nltbWdi0AugiiYFGRoNvPv96MPdtqdQiccDb1Q6jXu3HWFieKmIEunBQS1IvLx84qNnDGE6LFjJULccJus2R1n0wXiY7sd25HFgAPd4cRGrbA5H7xXXMzA4ymg0QHDo1a/X8epWmFMEzzMLZRI2GwzltTWQkjt3sI++PiU/AwN4BYMwWHM5jAeFAsKiqI6ayeDzp5/GttUqPovF4BU4dw6rw+vrmvB95QpWgnkNfX04P7sdoVD5vBa4TKeRwN/LifLvvYd2+9jHcG8yGRDmWg0LXRcuwANF49Lvx/0KBNDGoRA+Z9RAtQojcmYGbZ7LIaTv8uWjJXdNaWiS/OefBwEpFlFvijlbvF62R6uFPjQxgetaXVUxi2QSc5uV9ASD6v1k3aZE4n6ivldVQBKm9XW0/UGrCh5l0LtUrao9ac1B67a9CPotaymRMG0nCU4PoM+n9465d7du4Z72959o4mqs3MNCN8LUKQhgFYY4qjCEaW8YHISxsrIC4uR0atKlgYHB4aHVQkhRqYTx+fx5fEb1KSZV1+t4hqtVhBiVSjASolEYHfPzWsSUK759fQhzYkFSu13zC7xeGHvZLF5zc/BupNPYPhZD6Et/P0LFOOa++66GdXm9MFreew9GZCAAY7e/H8dirsdbb+H/8XEYRi4XCOLFi0rYfL7eiRi4fh1jsdOpnsVCAV4ml0vkmWdwP9Jp3N9Tp/Cd3a730GbD55zHl5dxD3I5JbfRKHI+jhIKhfYQw0BA5P3vF/nqV2H8zs/DSKatkkyinwYC6POFAq57ZQV/j47imldX26+VBjSFCIpFhDs+qjciFMKzYPXi9SpImGgr2u24bw/KX+JCD8lmPg9S1M0LynC8zlylYFBz0BYWcO9PaNivsXIPC1bC9KCQPJPDdLIwMqLVzBcWMFjxXhsYGDw6Wi0YucHg7p+thQUtGnr2rHpdtpN4vnkTBvH6Op7hW7eU/PT1wYDMZjHGh0JYqWftGHqDbt7E76NR5H5Uq1rHJ5vF3OD1inz969hHLofPrl9HftM778DLFArBcM1m8Xc0qsZQOIxr2tiAMevxYDvmTDmdIAUMEXa5QO4O2wAtleClGRg4mEKYlQpIZ6UCIy+ZRPtQ/CEaxesv/kJJps0GY9Pt1hDN0VE1TItF/J6haXY7FskuX+4eGnWYKBRUFpx9fHgY3szFRRjAzBNaXUWfPnMG92NzE8/X+DiukbWoSPrLZX1+XC60V7WqAgOrqxo29rCw/rbR6G0bxBqSx9Bgt3v7Z5iEiffI69V7lM/fX8S2WMTLZuu+wDs2hv5QKmGcYZ7eCUMP97BDxoNkxUWORw6TIUwPh7Exrfq+sICJyMDAYH+wsACDz25Hbsnw8M5j1OqqrqCePq3J8AxpKRZBTpJJEIu5OZGvfAXGhdMJQ8HthuF8+rTIhz6knuRKBV6J1VXkOD7/PIy9VguEq9WCgbq6ir/dbpCrkREYPKOj7WFMrRb2vbEBb8adOzBiqlX8dmxMC402GjBgKW1tJUuVinqVHA6Ei01Nwdip17Gf7Qwfa0jPQWFxUY31gYH9n2OYIxYMIvzs1i3cr7k5tMW3fivuebOJfjAxoaS4WoX3LhRqJ3NXr2pZCYY7nT599PJVs1n1mEYi7SGZk5Macuh0gijZ7SCCk5PoW8vL6JPxuHoXMhn0PwqYWPcZDKqHyulE++Ryjx6iuF10Tq+BHiYq2AUCGj663fYi7fcoFMLzkMvdT5g4Nkaj3Z9DpxPjxfw8nqFo9EQWrzVW7mGBnWmnkLzjQJiM6MPDwWaD8XTjBlZmUqnt440NDAx2j1xOJ/hmEx6cRALG/8AAxtlsFp+l0zDIk0kYhk88AWPi7l2MvxcvwsvxxhswBvJ5Va1zuTTcLhbDogdr0nz2sxqWl8upAAC9Rk88gXPZ2sI4sLqK39lsMHaosBkKYfXf7VYCFw6DTLRa7aIQQ0M4t9VVbP/cc/AAkFiJYH82G0IPFxZAxiIR7DudxvnncrgWeunqdRhfk5MwjFZX0aYstDo6uv/EKZ1WOXXWsNpP0lEuI+yxWEQ7tVq4n1QtjEY1kZ0ex3IZ2xcKCNd0uxGSRszNibz5Js69rw/bnz4NgnHUcsRYADkQwPVavahOJ+71vXto+8uX8TxsbIAMxuNoE3o1pqa0QG8shvuWSoFQEiRMNOKzWfTb/crparUeLIl9kkFJ8UYDz+vAgBLdbugMyRPBuLK1hXvD2ljc1loYeDuQOBcKuP8n0MtkCNNhweph2i4kj6TKhOSdTPh8mjS7uKirbwYGBg+HZhPERgTPl8uF/7NZrP6vrYEcdCv2yjwf1pkpFkX+4A/UK0N1Lz6rPp/ISy9pLZtQCON5oYB9bGzAKKRYw8QEvr9+HSICPh+M6UoFv6fnp17HedTraqhQqezWLYwZ4+Mw6re2sOiSzWJ/H/4wjJblZezX58OxGw3N+aAMs9er4X8sSrq8DMPn9m2Vhy4UcEwK1Xg8OC49XamUCiDYbAgRpCFGBa2Rkd0vqrVaMMxFYFwXixrms18Kc1euqMejr0/k85/HMWs1ENgnn8T12mww/ONx3HcqDQ4OYjsuai4siPze74EsjIygbV0ubHcQ4YSPAhJ4kvNG435CF42C/CSTuIfnzyvx9njwfaWC/j0xgdy5RgMvLlicPav7Y8iiy6UiEhsbj5bHRLVIux22UqfyXi+BMvYi6kneTm2QeZki93uYRNCO9brm9d25g/saCDxYWGNqam9Kh8cMxjo7LJAMUZJTxITk9SJGRmBwlMuYsKenD/uMDAyOLxgCt7mpksjRKN6Xl1V1jjLEoRDICg3cjQ38lgQpmcR2gYAW3pyYUEGAdBp/LyzgOZ6cxHblsq6iVyownINBLI5cvao5Bo0GCMr6OvbldqsYw507Gto0PKxy48UiSE+jge9ZF6fVwnm8+ipCya5cac+hKRbRPoEArmFwECSASfOxGK7h9m1sw1yUvj78juSt2QSZ8vngfWs2tf4L863Gx7VoK5W0Xn1153mCOS0s5up0wlC/fh37Tyb3pzhmsYjcsUJBvSfr6zhfpxPX3t+PNo7FQNRqNZxXIgEyRQnxQgHt9dWvoh2jUXglEwnc7+Hh7XPgDgv0LtEjINL9HCcmcE3MRxoeRtux5s7iIv5n0WUKQaTTqqhG28bnw99OJ5659XU8a9Zcp72CpI9hYgwj7DXUamjHchlEqVjcWUyKZInCEITLhftUKqEtQyGMQRQGsRLg7eDzHb3+vo8wVu5hYTcqeVZSdRTBFUYRQ5geFgzNu3kTK3mx2P3xwwYGBg9Gsajhd1R6i0Tw98gIDCwKGoyP41lj/gY9L1tbeCYbDSUR4bCSkWAQ34+NwTgMh2GkMdyuWMRvlpbwPxXIkklsv76O88nn8fnMDAzQZlNJWamk+Vc+H1bkh4ZgqK+vY/t799QL5fUihK5SwTl6vVpwtVLBtdNLFgphFfjpp7HfSgUELpnEGD40BANpfh7HEMH+IhGcP1X0lpZgcDNJvFrF8ZxOtNvrr4OQ0YCqVtE23/RN3Q3k9XX1KlGY4sIFJXxLS1qg91HB6w0G0V65HO7v2Fh7fTyfT0PLrl9H/yDZdDoR0rexAeKQSiE08QMfQNtTQe6o5S4xNNRmA+Hb3MQ1d8s3YWgei9MODiKPqVLRvkdv6NiYLhD4/WiPQkE9EvRmkdSwj2YyD0+YGLI5PKyCE0fNm/c4wFw0RiLRk2sNibSiU/DBinAY408qhf5OgZNz54yNJ4YwHR7Y+aweJpH2VZmj7mEiWRIxOUyPgkAAk9HGBgyVy5dNexoYdEO9DsObuThEq4UcEnp0BgbUiyKCBQmGS7G46/IyDGZKQG9taQ2miQkQC5cLn6+t4fNSCeRhfR3jXyzWXkvpxg18l89ryG2ziX2QbNTrmlhvt6skMhdK5uc1DG5yEvsSwXGZLN/Xh+9tNhCp4WF4Oq5fByFwOGAQTU3hN6kU5pxz50BEHA6VLH/pJXij6nX1nNjtKGDKMLtUSsf7RAL7WljAe72Oc7fZcK3MialUQE6rVRCechnt99GPtofsJBJKluhp83gwHiaTMNhY7DsYBKmjoMJeQY9QKqW1rrxeeLKaTfSN06c1HM9u1/ydZhP9qVoFqcvnVajj/Hm8WDsrEsG+jtpqO71L/f0a0bITYeF11GqaB8eivcUi9lEqoZ/NzOB7LgxYCZMI7l0up4WU02m8HjbXhc8Fw0VZX6zX5k6WPGBOmdeLtraSYC7G22zdw/GIUEi94KOjGP/OnTuRAg4PA0OYDgutVrsMJGElTOyklOw8KhXCCXq+HI7eTbbcL1CWk8bFCa+YbWCwZzQaID7MzRkfV5JBz9LGBlb2h4aULDEEq9nEc3X5MozaZBJiDlxBL5VgyI+NqfrZZz4D46FaBdFgcVKqz5H8uFwgKzdv4jufD9tHoyByo6MaOkQVtWefhXeZeUKsixMM4pynp0FgWBPojTfUozQ8jP2/9JL+bmAABu7sLIzHvj6cYy6HawuF8DnDxZpNkJhAAG22vg7D89IlGLTlMs6THhUqq1EcoVTSgq0ME6xW8VsWyqXHIR4HMc3n8dlHP4p2S6U054zeNRb0ttnaPRCbm7hWjo0eD77zevG3x4PzdDj0naAi4Ztv4hqXl9E+gQCuNxrVEDOe58YG+le5rKFkXGmnF3J8XAvT+nxoo3wen2+3wn9YKBRUdGR4GCRe5MGkbmoKv5mf1zylchlturyMezY+rlLrzGFKJts9PpS4Zn2gzU1sw3yZvYDy/CIqnlKpaL/vJdCOrNfxdyRyv4BUOo1xbnRUF+C7CbUEgyqJH4mIvPji0RMsOUQYwnQYYDX55WUMHNTNp9IL4XLpwNxoHF3CZFy1jw67HRPTnTta/6IXwwsMDLbDwgKM2EIB4+LsLCb10VGsii4tgSjF40psREBkaEhdvAjDbmAA29Ngo9dpchIkJJGAMMPCAoyN4WGRp57SGmpbWzBK+vpwDpEItltfx7j9wQ/iN1ev4jfDwzg3Gqx9fcgJePppEJdUCobJ5qZKg/t8CPsaGIAHyOfDfPHyyxoyODPTXjT1qadw7HIZeTWZjHoDUimc4/XrOMdQCG1H5PNohzfe0NpQkQgIT38/yMP4OM63VkMb9PXhtbAAwjE7qwITHo+OZZzDVlZAKr/6VZEXXlBRhOFh7JNeubNnsT8ms4+N4fdcTWd9IAoPUJ69r08X7+p13NN6HX2GBWXffBPXVKtpbtnNm2ijVgvvLhfa3W7X1XqGHI6Pa7HbTAb3l7kf5bLW1dsvBbj9Ar1LsRjar1TC/w8yiG02zE1UZCyVcF9CIRUXYVhrtQqD2+lEnz1/Xu0D5hc5nVrwt1jEPvdKLuldYi2scFhzD3uNMDFEkrLiDKG1Ym4OfbzV0kWmbvc9kVC7MxjcXpa8R2Es3cOA3a6rX7UaJiASJqvwAz03DB04asVNDWHaX4TDWM1dXMRE5HIdvVVKA4NHRaGAMWMvUtRLSwgR42p2Pq9y/HNzmu8zPg7PTKultYdu38Y+nnoKY2qthhpKf/EXGMMuXlTD2umEJPjGBj5zOvE7irEwWb3VgsFot8NIo3fG74fBPzWF42azMKhHRmBIrqyA0L3wAr5bXYWhMzqK83/6aQ0tcrtBjih6QAlnJthnMio2QdU+FrxtNnEusZh6RBIJrfvG+eTtt0HkaCTdudMequX1YjwaGIAnxu1GvpTfj2shSZqcxNj19NNQ8qPnanMT18gwPZcL95KLhuPjaK9nn9UCsOPjOMfPfQ5tOD4u8sorMITpSSJJLJcxVtLbl81qCNnampLR2Vl8t7Kiv6MM/MoK7p/bDUNzZAREml6u5WUlV4EArof5N/RG+ny41nIZbd7Xd7TmRRITEc2rYi7LbsMGp6fhPXrjDSUlVGOz23H/Uyn8nUhgsWB6GsR7eBjzm8+nYZtuN84pnd77PMf8JYb8hUIaWttrqFQwHtRqeK743BOtlnpxKxUNc+0kTJWK1lByuXTxwJCmb+AIPdE9hGYTg/nmJiYaeo8Yekc4HHjV6+35QkcFpgbT/mNwUCf7+XldPTMwOAlgaIjbjdwbhqMlEip8EArpCnSzCfGBr30Nfw8NwdClWtzyMozhrS2ES42PYyxlbtLrr8OYOHcOx//TP4XXZnER+zh7Fsba0hLOIZXCb6n81tcHslCvw7iLxfAd6zaxUOft21rEdmgI51wsaq7IygqIFsOhLlyA4b22pl6cwUEcu1PkZ3BQxRRGR3XcXVpS0QG/H0TK4cD3+TzGjeee0+8WFkAUMxlNkrfb0f4kTY0G2rRQUAIhgvadmcGxIhEQBb8fRrHdjtfHP47753ZjW9Y0GhjQHIt8HkY2JbyLRfz2S1/S4pdvvQUiR+/U2hpI8TPPgNgEgzi/sTH8Xa/jnFiL5tYt3HMakvRosNAq1fcmJ/G7W7dwL0+dgnfR7UZb5PMa5hUKwYDM53Fd2Sx+H4vhPG7cQDux326nUPY4wDw+RqwwHFFEvUsMxxTZPWEKhdDep06hz2cy2Fd/v7ZftYrvlpfRZ/hM5PMg3IEA7gnzmNiWe005oIeJYX4kTtaFj15BLof7zesmgScSCb0PbjfGy9On71+w4rgXjeI5SaUwhpr0gG+gh3rVEYLNhoGlXtfY025KeQ4HPm+1jqZSnvEwHQzGxlRGd2YGk3svyqUanCzU6+0rnTMzGi5FWOsO0TC+dQsT+ciIyIc+1J6A7HZrsn40irATvx/G2soKDG3G+L/xBgyquTkcNxrFb69fh/Ho8+H4pRLGXLdbi8aur4OARKPYP2vJ3L6thTgbDZAbkoDlZSVNfj+eY5cLpCeRaFdco8dGBMeMRtWrVKlgH60W2oWKeNEo9pPL4ZoSCT1nn09rCFEhz+OBN42iChMTuAe1moagMQeHcuxOJ4xh1mhyOEB2GN7jcqkh9rnPaW2pxUWQRl7L5mZ7sdsnn1SyWK1iP5kM2oA1pQYGQGjv3cP1kWiLoE9cvqwhRCyey1pb2awu5PX1wViPx1WGmjWxkkl8PjyMGlZuN+4pCTMNevbZYhGvyUmthzU3pwa/16vFjHcDCh9MTOzPwmOhAM/ddmCYN8PxXK7dR664XLi+WAz3Z3UVn5FUjo6qYMbqqqq+BoNow3v3NK/Q58O+qCxJIZPdwJq/RKLkdLZLYvdKEXiS+GJRRUrC4XYyNDeH93gc27PfW/sbCw+zBEC9jr6/tQV7xNh4ImII0+GA9QjoVdquFhNX7kSOZvFaQ5gODtPTGmJy9y4Mnb2EMBkYHDXMz+tknUxibDtzRlfkPR5M/gxJy2RUhezUKYRlWceaxUV4WIJBeJBYZ+gv/gLGeSqFfdMrUC6rNz8QgIGVy8HIDARUKIAiBV4vCAeldSsVGNNeL4yIeh2/39zE75n4PzMDo50S1aOjeH6HhvC7zU28KJBQq6lRPjiIbTpX21lAslzGCvH58yAUk5MwaoaGQGgSCZwn1cJmZ/F7m009K/y+VEKb3r6NNmAdpeefx3kFAthHoaA1b+jdKhZV9GFzEx4itxvnn8uhbRIJFW7I59Vj9cQTeK2uwuPHkHMKYpBwfPzjON9r10T+5E/Qf0ol7CeVQh4USezYGNojGMT/oRCICOs5lctKDBwODRN0OEDKXnxRixVTMZGS6yRkDCWbnFTCtLqqJN/vx3VGIrvzljQaMGYZHjk29lCPVRso5EAPDvOjmZNCzwMXKfYabhUO672nZH4mg/3Xappjd/UqzuVrXxP5f/4feOBYFFoEfc3nUwKaTu+eMLGvut3tiyehUO8RJi6q0Fvo8ajoiogKc4iAzDLslvLyLGa9uIhtWHRZRItGJxImn/ovYSzdwwLjypkoyURVK2HiJCdyNKXFDWE6ONhsGOBu38agdfcuVlSNGqHBccTWlnp9rJLGwSD6uXWVu9WC4XPlCgypc+fQ951ODSWbmwNZajSwj69/HSRpcRGhJfTylMv4PVezEwkYZq+8AsM2n9caRO+8A+N/aAiGBI1JjwfEjh6gkREVeyChoyx4Oo1zp8fm//q/4E0Jh3VFd3JSw9K4Uu5yYZFku/Bbtxvk4c4d7P/WLfzv8+F8h4aw3/l5tAtD6UjGajWcs8+Hc7x2DYZnuaxGb7MJovjEEyLf9m04zswM7ls4jGttNlX4gNLfJDEOB9qSNZnOn1cvDcN8xsa04CtrH73xhpKRQEALcX7xi7jeSESLqFIOPJXC7+kto9z64CCOU62iPRcXcX5vvw0CND6utZzGxvAaH9caVfPz6FvLy9hHs4nzHR9X7xHzcmZnlSwNDWkR2N2G41GaXgT9bnj40bxMzNsTQXvtFMrNfrdXwhQK4Z47HFromAsKyaSqS7K24JtvinzLt+D/O3fQziRbhYKSVIYM7gad+Uud58bFh14AQ12LRZXI9/t1PGVYpMOBvp5IoO+yDMPlyxiH6nUVXCEGB7ENx0RjezwcYfrSl74kv/EbvyEzMzPy3/7bf5OxsTH5L//lv8ipU6fkgx/84H6f48kEVzPp+u/mYeJ2IkeTMJkcpoMFVz8ZMpRIwBjYDpy8jlqxRIPjgXpdw6z2E9UqCP/cHIzfYBAkgl7zzuPZbJr0z/FweBjntriI/bCuEZXYKhVsm06ral2tpuFWrJPU1wfjjSE8rBXDwqQU5KEIQiAA71A0iu+poMbjUS7c48F+Bgaw/1pN5Ju/eftnkbWE5ufxu8nJBy88uVxKmopFkKapKQ1RKhZx3EgExnI8rkV3KQW9sIBtBgY0DLHZxDkUCupxu35dIxxcLhi5wSDaOptVomCzwUi7dElV1MJhGGJPPAFjjPWKPB70sdVV7GNzE9+Hw9gmFtPw80oF17m6CgMwHIbB198Po9huxzkNDGjoYKWikupUMxwaEnntNVx3JIJ7W62qepvfjz6VTOLc5+dVzIFhZmfPakj05CTO5dYtDYOamEAbUSGx05Dvhnod1yGieWckTQ8LCl/s5hweljAxZ8jtRrvTeyGCfhOPo/2eekpVCa9fh6jH0JDW2ervxz1kDmC1qp7eB4GksJMQ8ppJInqhdhA9TFwgikY1j05Ew/GGh9VLPjiopQju3tV8MMrHEyzAXa3invWK124H7Jkw/ff//t/l+77v++R7v/d75e2335bKXxbBymQy8s/+2T+TP/zDP9z3kzyRYDgA5WG75TCJtBe4PWowHqaDh8uFyX9xESvcsVh3gloswljgavduJm0DAyaE0xC22SBIsJ/KSFevwlPh8aAvs2YLhRKshlK9DmP0j/8Y4yLD9P7szzSuvlrF5yx46fdjv7GYhuTQo0Ri8KUvqbiBzQZD4otfxL76+3H9fj+IHD0jIyNQfSuVYPhZJbhF1BPSbMIYj8Wwf58P7fqgFVkSu72AYXU0dO7d675dNouX04k2oBpctQqj9swZjBMUX2g0QE7u3cNnbjeIot+vhJBFL+fnVWmPEsaNBj7P5XDtLF76/vej/YpFkXffVa9gpYJ7/vTTGjpXKOB4VFmrVnEN5TL6zDPP4Jpv3sRvGFZYr4MIM8erXMa5lsu6ej44iPs3Nobv1tZwTevr8LZRJa9Wwz7SaYSB1utKEsbHcX43bmA7pxPe0VBI70MstruVeHqX/H70mdlZfDY4+PDlQxiOF43ufA5WwYe9PuckmQyjpMeRHg67He8UxEin8ZyPjoJE5XJo57U1VXVstVQe/kGEiQIHDsf9zw49lCT+vaAwS0nxYhH9NB5vJ4osCE3hBnqUz5zBs0iyRAVIK2w27G91FdsawrR3wvQLv/AL8uu//uvyt/7W35Lf/u3f/sbnH/jAB+QXfuEX9vXkTjSYw0TC1C0kj9uJHE0P04MIUy9W3T4IxOMYsCoVTKqdhhvd6yTb6bQhTAY7o1xuLxxJUIL24sW9hWBsbWFyttlU+pkhW9evY7/0jjKvhkbv4iKOVyjAuHrzTUzkrRa8FOvrMJJTKbx8PpFXX4UXY2sLHoCxMZCyzU0YdFeu4H+bTUN4GBJmt+N5odHsduOz558X+djHsP9TpzAWz82pcdnfj9+zDhFfIirFSxxk+IrDgTDDe/eUZFhfIiAcW1uquEm43fCI0Njs64Mnp16Hl2hwEPeAhObChfuPf+aM5pn5fGo4N5v4fH0dpLdWw75fegltWCigv7HmFBUPHQ6QuUpFFeo45vF18SIM7vV1GOL9/Uqe5uZwrKkpNRazWa1xeO4cxswzZzRE0OvFcW7exHkNDuIcSiWVvy6VcCyvF+TZ5cJ1Mf/mzBmtMWVVoXsQrN4lhnfy+hMJFUbYC6zn8CCiQFETinXsFaEQDHSnE/2oUsGzHIup1y0SgVcjm8XzzSLIp06hDzCU0+9XspxOt89trRaIeSaj9dOspLAbsbR6SnuBMHExolJBP+Lihkh7ON7EBD7jWMaxeGMD7dppUxDxOMYPCkv0uMT4ngnTrVu35MMf/vB9n/f19UmaCX0GD4bTqTH5VCkSuZ8w8fPj5mHa3MRgR7lRQ5weHjYbDLV792AwxOPtxtnqqqoeiWCC4QBp8HiRz6P9g8GjW0CRxIRjDet99fXBc1Esop8NDOBauEK/HQnY2MDvGKLLJPNqFeSIuSUUOKDYjdeL7zc2VA3u2jV8VqthRZ8rp7GY1sth+NPMjObSXL8ODwaVot55B8YaE5hZJNZmw/HKZRgX/f0Ym0IhFHxlzaTVVS306XKpBDVx2AIsdjuuaTuMjcEIovewVMK1Dg+3G5pU77t9W71PTidIyBtvoP26yQrT69IJ5rBEIpAwZ6HYWAzfPf00iDXJkd2u3rlyGf1kclI9D/fu4dy2tuCppPduaAh5aJcuQfzh9dfRJ86dU0VAtxska2hIvWmBAMQk3G54Lbe20AZuN55dlwvtSs9RMIhzarWU6HfOaem09ufdGJSsD+X3a58aHsZCxdqaqvntBXs5h4cNxyNCIbS13Y4xYn4eYwQJTSikgifMJ6Qc/eAg2nduTj1KDK8sldpD6RYXNS+MYXwMx2MeWrdzW1vrnXpMLNrMMOJwWNuP4XgsGWCt+enxYIxgQebt7DOXC+MkSS7r0fUo9kyYhoeH5e7duzLd0XB//ud/LqdPn96v8zr5YA4TPUxWVZPO7USOJmGigdRJmAoFVV3JZLCKd/asqhsFAodvcBw3RKMabrCyokZMqaQryFNTmKDopn9QBXeDR4e1Nks6rR4Hux3G2n6Eqzab6knY68JDowGj027XifPuXewzGIRREwpp4exYDORjbg4GNydfEhgR9L8bN9AfGfYkgj5KCepaDcddWcF+zp/HMx+Pw9hhvhHzRr72NRg5GxsqZc3V0lwObby5qeIAn/mMyJe/jH0/8wyMZBaT/drXsH08rmpmg4NqGDBXZGQE3zOn55ln0MYLC+0J/JT+Pm7gSv+Dwv58PniSbt/WvKZaDX36T/5E5Ju+CeP3bo14mw2GlcsF4prJ4BwmJ3GcpSWQj3Qa8xoL4TL/jH3cZsN3djvO4/XXcd8+9CENR5yagvchk0GfvHcPv2k0VAJ+aAj9hs8qpe0HBnAegQDuOcMdv/3bNS+E8u5cDB4eRp+ztgXzuXbjXarV0P9E2lf1+/vxrNRqIB3bEYLtQM/Lbs7hUQlTMIjrp+ohC0OLoJ3iccxBsRjaL59HPtPp0zj20BB+Vy6r+iILpabT6u1jO/GcWZfN690+dI/nxgWYk2xnUEU3k0GbBIN4VnjNtMGs4XgiuG9c1GJY804YHFRl08nJhw8ZPQHY8yzwgz/4g/L3/t7fk9/8zd8Um80mKysr8pWvfEV+/Md/XH76p3/6IM7xZIIepgeF5NGTcNRC8qxFdq1GXKOhuTShEB7SchmTmcuFv51OTJzGoN8bxscREsKwDa9XQ/EiEUyyrBvCQdTg4FCpaOgR4XCo+uXm5vZJ/5QULpVgjO50r+7d0yKg4bAawbsx4lmTRgRG1eamrpqfO4fnkbHsuZzmhZRK8LBcvIi/19dBYqhexvpJ+TyMvcFBvNxu9MelJZyzx6NG8Pnz+D6TUeEAux3tt7qqk77Xi/Ghvx+T/rvvwruQzer3y8swrlhc9Nw5jC9LS9r3L1wA2SmVcI2JBH4/PY1z/ehHtVgrPRpzc2oAT0/3RliPiLbX/Dza9PJleIZWV0X+8A9hdLH+jki7tLPHo33R6cR2LOjKenIi6A9UzxsZUQGAN97A58wtOncO+6TqG4Uomk31ODoc+P3Xv64S8SMjSnI+9jGce72uOTv1Oo7x+uv4n6IgyaT208FB9K3nnkPfpJQ5SWAspiFk1pfI7sjK+roWaLZ6oGm8Li2hDfr7d09QazX1qDwOwkTp/UIB1+By4Zp4DhQJiURwHZyPikX16E1Oot1JkmkbkJjSuxuNog9Q0VFkZzLJkgEcz04yYcrnVSzD7dYwfI8HbZvPoz0mJ/E522+vdgEXuCuVvdXLOoHYM2H6iZ/4CWk2m/Kxj31MisWifPjDHxaPxyM//uM/Lj/yIz9yEOd4MsEcJqoCPUglj96cowJ6vGy2dsI0P6/hFmfO4HpmZrCCt7mJCSkWQ2z7xYt7U+T6S4GREz0I7oRgEJNLOo1JPRjEJMTaICIYzDhB7Wb1yODhkUhokng0qvVfUikNNRsaahd0KRZhEF27hvdqFR6dM2d0YnI6sd9qFdssL+O3o6Mq0rCwgGONjGh4FIuLRiK6Mr6xgWPGYlpvh6pUFDqwwuHAc7m2hu9YVyeZBHFZX9fwG64ix2J4jm/c0HGBdW88HowB167BAG+1YDTZ7TCmSMw4GY+N4Te3buF9cVHkvfdULS0WwzEmJ7EvihLYbNq2DCObmsL3Xi++KxTQVm63yPve116Xp9lUr4fNhpCrXkty9nhAZkhMolHUtFpexhh+/brWSyJJoXgRiVMggHu5uoq/+/ux3doa2v/GDXhphoZwjCtX0AfSadyvSgURCbEY+jn7RTyOPhMKaR//6lfxnASDqP1z4QL6C4siP/UU+hGPHYth3xSGYE4oyV08jutbWMCxSA5dLvSHYhF9sdviZSTSPi+xjpPfj/14PNt7lwjmizAnaLf9j4Q0GHzw3EjJfpFHy0dhrpDDoaFyrOuTy+EZYtFi2gTpNM51fFxV2ygewXpfy8vYl9OJNorH1XvPIskPIoWhkBKmvXrqjhNyOe3H1vBOtxv9XATtzHHuUeyncBh9N5MxhGkvsNls8lM/9VPyD//hP5S7d+9KPp+Xy5cvS3C7mGaD7mBIXr1+PFXyuuUvbW5qscjTp3UyHRwEQaK8LY0fmw0x6N3CjFg9nHK5pZKSRq8XAzETcnsJ4+Mat0zPAWVtRTCYLS5qUrbJHTs4MJ6eilAE5Xa5ut7fj/+3tkBS1tbw/JA4LC3pSqD1flUqSpaoYhSPw7AoFnH/STKiURiHTGp3u2H4Ub0rl1MPQa0GQ1EE/eXsWXwXDOpzSUnZr34Vf8/NgVA4nWpcjo7iXJinksupgtbCAo516RI+z2RU9SyRwHcUMPH7YVQVCvAkhcP4vF7H9edyuPZYTHOpCgVV21tY0Bo9TifGhL4+7MPn07yXsTG0eWeNGi7qUCXwzJmeNgrEbkdfYJ2nhQU1WvN5tK/Ph+0o4UwPDmXaPR71vtjtuBf5PPaxuopnoNXS4q/RKAy+lRXc82YTz0MggO0uXMB+Z2ZwLpkM+kK5DKLl9cIrFgrBg/TeexqKms/jfF0uCFCI6AJAq4VtLlwQ+St/BfPUvXvo05OT+F0konl1IugjLOzLF41QCoVwbCAcDs1ZZs2ubu3OcDS2yW6wl5BACj44HI+28Eh7z+EAKVlfV48jy1/QY0zvEWXPmeMZi6mYET3blQrGyyeeUO+82439B4N4hh+0yBoKof1Oeh4TlTA5z8diWgaAYdJcSBV5eA+TCMbDzc3eqnHVBQ8dmO12u+Xy5cv7eS69BZIJxvsfN5W8zhpMpZI+pGNjGmNcLMIYGh3VVbVqFZ+trmIgfP55DIrFIiaahQVVb7FWnmYblcualO3zaUhQLxRWYx7IxgYmqL6+9rAhjwftxQmq11bJHxdyORDTbFZj9dn/GCJJw6dQwP1aX9ewMqdTk/aZnEvDklK9c3MwBqNRXYGtVpWEvPsufjc7K/LWW+gLlO197TUYpzR+k0l899JLmPhoMPX1wUih14AYHFT55lQKv7l5E8/o9DSuJRSC4be+rqTG68W2LpcSnkAA1zAwoEZMrabGU6EAI2t+Xlf2NzfRz4tF/P7sWXgM0mkN9/X7cf40kMbGMHYMDMAjMDWl4SqnTuE+nTrVfh8rFbQzw1fOnjUKk1aMjaG9qazn96MPs+YblQLpsczlQErPndM6V5wbhofR/pQyd7lwjy5fBklhEVomqJfL+E2zic/OnUN/+9M/Rf99//txfhSsoBqj36/ewsFBHIMkeHhYFR09HuxvfBz98733NE+G3jPWjRLR+Wi7cLlaTUVTbDbss1zWxT7OmTvVyaOXqVTCM/sgEkSVNB7vQXjUcDyCYwUFOK5d05DHVArt7nIpocznVdRhawsLqrGYeplYAJqqg1YPnM+HcYIS+bs5N5tN+9BJXFSt1TTEkd48ipdwrLfZ9o8wMc+1x/Oj90yYPvrRj4ptB8P085///COdUM/A5VLRh51C8o6qSp7Vw9RsYsJjVXSGgnECaTYxMZ09q6vuTqcWJvziF7UWCusCiOABzWY10dbr1WRx5upYiVqvhKCNjOiqonVAJJhrkskYwrTfoEzzjRuqCGXNecnl8CxUq1gNTyYxibFWEMUGNjfx7NMAmJ8H8YhEYNytrKi35Px5PG83buCebm6CgJFYcJX25k0Ytnfv4v6HwyBX4TDOOxQSefttGIhPPIF+MjcHo/bdd7W4aCiE462swPBsNDTPiWS8WMT/77yjhUnrdT3ncBjnUq1iPxRlWFlRQ3V1FedcLquRREPa6cR5eb2qrMVirMkknnkmycdiaMfbt1Ui933vU8LY33+/4UlPNxceWCTaREq0w5oDQTAMk2BYeSqFnKJ0Gs9BsYi29/vxrKytoc8xLy4U0nlvcBDheRR14D4olU0Dmvv0+dDnKxU8HzMz6EesH7W8rFLLFy6AqFFCfXYW9354GEp7AwMaQmf1kmQyeBZZC28n9bpCAefA+kysc8X2YV4g8xC3g9OJeWx1FWPCg1TvOPb09e0up3G/CJPTqXktFNfI5fBqNvU7jwf3tljUvBqSomAQ92BxEWPW00+rSIe1fAbJZr2+c9sRXCRaW0N/nJjYnWfqYcG6YyTZjwMMx2N+XTiMvsJi2CIa9shzZKHwh/Essk1zuXb10R7DngnTs88+2/Z/rVaTd955R65evSrf//3fv1/ndfJBF31n4drjSJjW1jRngeqJNBhrNTxcp0+rnCWleycmsDKezeqKX38/BkwmheZymDy9XgygjJnu79fE+eVlTDD9/TtPGiclRM3phMHLvzvR14cJJ5PZXQFNgweD3pKtLVVz8nphZFcq6KsMOWExTeYsBAIw2OJxvHPF2eNBPw+FNIztxg30eeZGTU7iuXK50P+Xl6ECNzCg55FIYMJ2OkEabDacD2vNuFxQgHvnHRAErkomEpq78+abugJZr2vhUBalpCHncmlIXLGI66PHgAIO0Si8QTQ2SyWEC773Hn4zMaG1aFIptEV/P8aIqSldhWb+SiikwhHMi2m1YGCTgFHdrdmEMf/225prFQ6rse71Yt/LyzqGkdz1qBHwyKDKGb059La2WuhHDod6PzMZkJYzZ1TUYX0doZj5PF40pFlA1u/HPf7yl2FcLy/js2eeUREIa/jerVsgzLOzSnKWltBfnE7MSwMDWEygeuPICPphsYjn7O23NbdqZEQX57jQaberhD3HBnqmWJ/J2j7WGlkPwsgInq9sFkTi0qXtjf29hOOJ7B9hEkG7s4hsf7/WUgqHleB4PLiXCwv4jiGByaTmSL7xBrYtl3FPazXN/3Q4NOeKxZN3A9Z3Y5gx7+N+RaK0Wrg/VPqs1R6vSAyJC/PFAwGtq8U8ubEx3Z6LAXb7w9XeEml/hh+mVtgJwJ4J0y//8i93/fxnf/ZnJW/1DhjsDA68rMP0oBymoxaSZyVMHIQHB/EwbW1p6A1Dj7oRleFhFKC8d0/zJoaH1XBh7sf6OgyeYhETIyeTbBbGFRPR19ZU+rgTDPnx+TBZ9vfjt4uLSsCOE3YihlSRqtc1pMng4ZHNanFMESUPoRBWs3M5kJGlJUz6AwMwGum5oPiBy6Uhpw4H+noyqSvjhQLCikolGJ7PP69S8lxxZQ5HMqmEjNXbg0Ecl2pwyaTIF76A43q9OEa5jP0sLuI879xRUse8t+Vl9fqQdNEr1NenRVH53E9MaOJ/qYT9jo+DNDEXqtHAO5PgKxUYlnfvop3Gx2EYMv+lvx/nNjiIz8fHNSzM50OS/x/+IYxjhp6wVksspmE5fX2aB7m8rF59EVzb+Hhv5yvtN6gix0iDpSW0fSaDe88Ig5kZvRf0BLpc+P7tt3E/KdhRKon8wR9ouB9rRd2+DZItgn4QDOJZLRbRj77t2/CsrKyArOfzGBPjcfTlZ59tJzasx8U+yLpLVHp9EPar5iBzgOl9vXsXXjKrnHOzieuqVpWQPgj7JfhABAIqZz44iHGtXEYfSKVwTj6fLlSQEDeb+N3QkCplMieOojdU5ozH1TPi86kXeydsbmKMIkHgGLq0hM+5SPUwYHh1JtMuxMX59nEhl8N1MjyZc7zbrXlG1ugSCj48yqIQvXu8hz0oL/7QOUyd+OQnPykvv/yy/Mt/+S/3a5cnG52Fax8kK37UPEzWGkxUbSsU9MFtNDB4PvXUzi7gUEgNsvHx9sHQZsNnTArPZrESaQUTZVkRPh6//3jFIgZzEQzEDAHIZDAIFAp4PyiX/eMGXfRM1DaE6eHQailhF8GEPTmJyYrhIVz0YIgXk2+3trA9Q0lZf4x5TeUyPEXcj8+HiWhrC9tSPIWLUIEA+u3CAnI4aPwHAlhJPH9eyUQuh32+8Qa2C4VAYihdTIOSqnYsfMiCrTzn8XEYKwsLGmY3MICVVK7AUxWNtT0aDVyjw4FzHxpSdTQWKJ2YgKG0uYnwK7sdBJGGVbWKZ/6pp0AqKUfeiW/9VrTj8jKOSU/DxYu4llgMY6tVJIVe5v1cbT4OOCgDx1oLJptFe1MamjWS1tZwfwoFzYdrNvU3fj/63JNPgqSkUiAL4+O4V6urujj2zDPo7yyIvLmJ37tc2g9E0MeYCzQ/365m6XKBcO9EGmIx9HfmGFtfLKnBV6uFbYeH968/MUSUeYNzc0oOs1mttyfSrsS5E8plrWO2H95Ua57yqVNYNKrX1XNIwpTNatQDQy3tdh3nGE7GenZnz+KeWcNl+/owrxeLO4flra6iD1Chb2hIcxm5EHT7ttZ9EsF7q6Xjdbf9N5v4/caGfuZyaYkH5vg8DrDG1NaWeuetNg+fFeu8T8L/KEIfPh/G4Wq1Z+XF940wfeUrXxGvCWnYPaiSxwGX2E704agRJp5Ps4mV4HJZH9z+fgx+2SwmrZ3yaNbWdCK6cQOTQqeBT3WvmRkMFFy1oqF59aqGRLFAHsGQIwok9PVhspmfx2CztYX9RKMnq4p1JKJqUlbXvMHuUKnA80kvSjwOA85uV/JNbw5rY01O6gQWDGISHR9HKFC9jvvAfrq0pMpdFGGIRrHqvbKC/czPo+9yBfbaNUxUzN3weLDfUAjbZjIwEMtlHKdY1MmVOUSViibp0xgZHsa+MhmcTzyOfIJwGNu88grOd24OpI2EnAnnXPBhmCAXHmjwZLOa/3TmTLuow+ioyCc+odsyhM/pRDt2eyYZirixofWTmk3s74UXYHgTbjc+j8dVLtvrPZ6FaB8GzSb6RjKJezY0tLs8ECuYrM8wK75baxARNhv6UTqtIhsjI7ivX/6yRh5QrMMatsX8JNZcmp/HPmw27QvxON5PncL+Egn0zQsXdL+UPKcanwgI1JNP6pxByfCdwEXNw4LHg+fl9m2M5YuLWlBYBH2bXtfdgGPZbq59N6BXqNFAuweDmE8pNy6i5VNYI5BKiX196lnkuLmygt9fuKALPzduYFxkPhMXNzvRaqF9rLLtLLGRy2FxJBrFMTY2ukfsFAqwZSgEwnbK5VQaXQR9MR4/vIVI5ooxjJEFvkXUm1ur4ZlnHh29To96zuEwnjmS4B7DnkeD7/qu72r7v9VqyerqqrzxxhumcO1eYCVMjUb7aocVR9XDxIKA8/Oav/Tkk3iIGg2dqKjk0i3kjXViRDQc49YtTALxePu2Ph/UlKggZgWlltfWtD4EBwaGCbjdmGgZwjA+jgHQ5dLimNZwwN2g0VAFp6MGTio0dh42brmXQCn7fB6TDfva1JQaJdZE23odZH1tDd/ToLt+Hb89c0Y9TsxHoLjD6Cj6TyCgq4HVKia/c+dATubm0C+p9kTlo7ExHG90VFdUFxYwdgwMwBChF+mDH8Q1cJGB8tulkuZcVavYr9Xr/e67MGb8fuzT7db6aSwMOzysRGx6GivD1jpRk5PYXyikieEiSMRuNuF9+Jt/E+c1MIDfLS9rrRVWqLcilYKBzDCd0VH1bJ0+3b5Y0gmGLZ4UcO7Ybvyp19HnSGoYxuzzgTiRjHSCuWM0Nh8091gXsEol3MeVFeTF2Wzo21TJs9lUXVEE4/DAAJ65QgF9PRLB4lg+r/8PDrYrrYZC8E5+7Ws41q1buCavF3NNJoP7TaGVixePZwhRMIjnYG6u3bsxNIS22Ms17Wf+kojmZuXzGOficYxHDDN2OHRhJxzWbTnuMLTZ78e1uVyakzk8rCGJw8PoI8vLeg1WNBpYWKJAyMQE+gtVSUmYHA58NzysizzW/r+5qdLZ16+jH9ntSsLcbtyLvS447DdyOV0sYsg07ynDj+nNF2kvKvyoJIch2ZkM2rLHsGfC1NfR4Ha7XS5cuCA///M/Lx//+Mf37cRONFotNYL4Pz1L24XksYbRUREtqNUwCQYCOKfpaX0Yt7ZwHUz8XVmBwdQ5uK+saAzumTMwJpnjkc9jcLL+xm7vPkFwcGQeCFcct7Y0xvrUKQzed+6gHeNxGKZc8crlUHPmm76puxFBTyDbn+fZaBzNIpdOJybbfB6DWycBNQCYH0TjzIpQCP3a7ValuPl59C+HAyu/9Tru/YULathQevWNN9A3wmF4h27exO/5TPv9+L3Doap39boSNooppFL4jsbf1JTWORsY0LA0JqKTpAwOIvn93Dkt+JpMwqhZWFBPE9XmSO5qNZUBdruxoFCv4/k+d04XN6pVnFcsBrlyLgCVSjCEOKlubIBUBgL4bTSKNnnuORj0lDdn3gG9vZ3PIfMQRXCN8TgWaW7cwP3ZS2L9cUexiLajyMbwcPu1l8sY67hAxNzPRAL3Z24O/YuhSXw1m/cTJLsdhhmFivjO+2YlbKEQ5L4/9zmMqxTlEMF5PvecFjAdGdE5g95/4uxZnH+hgH4wNXX/olsgAO/nO++gXywvo9/QgKdXYWTkeIde9vdrMWC/Xwsy7xX7TZhENPexXMZYt76OcY4qmwxxS6XQh3I5LZEwPq7h9AxvK5cx3nBsbLVwDC50dHo0SyWNPLHbcf85F/M3nbn1FMLpBIkWi+fSdhDBWDM2djTsL4aiUmnQ5VKFvrU1PMPRaLt3ieqPjxoFZpUXJxnuIeyZMP2H//AfDuI8egu1mshnPoNEVBpj9Cx1C8kj8aBxdRSwsIDBKxjEQGN19VpVWjY21JM0PKzblEo6IHEgOn0aA+7yskqQMkY4GNx+0nO5YDhSACIQwMDB+hlchSZZCgZViKKvD5Pua6/BgLh6FQp0VmJGV73dDoNxdbW9MCGTg48aaerrM4RpJ5RK2idEdDU8ENBVcPa5e/cw8SwuamiGCCb2Z59VtacrV7RfezzI9XG50P+Zfzc0pPfFbtdwvEBAc/9KJZUoZgFNrtCzoDM9Bs8+ixV0qnUFgzASX3kFRstXvqIkRwRjDo0Tnw8G2L17Sv5Yk6lYRN9m2AeFFFwuDb8JBmEoUTq9UMD/X/862mp9XUMOmQP17LN41gsFtEGloqvnkQh+3/msb25qKKQ1PFIEbb+62jtlBdJp3BfOFcwF6etTtbd791SJ8exZGEqxGMZCStGzFlYn+BzwGeB93y28Xs1dqlZV4XRoCPsZHHywypbDgbF2Y0PPoRv8fpCwQADXQ+LFnJeTgtFRPDtUqXwYkDDtZyhZMKgLTixpQLXK2VnNC2JRVavoypkz6i1hv1hcxLNss2kYbSaj4ZsiWnrA+hy43diflQz6fBoJsFvj3uPRsYlKmhMTR6c2W6WC6y4UdLwOBHD9brfm8FnrWNHzth8hdA5Hu7x4j9kVPRLIfcTA0BcWyeNL5P6QPHpVKD9+FCaBlRWVMx0f18J5IlofgHHLLpfWvejv15Wd5WW884EnhobwP2vZUMyB5Mbvvz8J127Hg8tBgyvuIjrpdyNLxPAwEsyvXMFqFXMtWCX+7l1Vc/r859VwHRnR5MujSJr6+tAOrI1xHENSDgr1Ou51oYBn7qmn2uvCWMGkc3pZqlVVJrp0Cfv4vd/Dqn21imeCdYbm5zU2n16/YlHlXb1e/O10oi8zfyOdViny4WGtiUQ53rffVrWwoSF4eG7eVLW6F16AIVMsatgdvaR8DwRwPfW6hrIxfI5yzpEI9jcwoAIRzGcJhWAIPfmkCrakUljxp7eLynjPPQdFzIsXcRwKUFjrqpEcdhqEGxswpETwm04lTBqTvRB2ur6udefCYVz7xgb6BcUtiGAQ45g1hJk5ayTtLDtgfbFPPgoYFud2378AtVvwXB9EEHw+PL8iJ3uMe5T+TcEHKtHtFzh3l0p4doNBjEuM2tjYUMEY1nBLp3FP797VQtIM1XQ4sDDi8WAMY/2q+Xl8zrBa1lkSwe9On74/VJ8hxcy128t1BwIQmzlqYEi1CMZgn09DBJtNFQuyjpHMX9qvnKNwWOXFDWG6H9FodMditVYkaUgfEH71V39V/t//9/+VtbU1eeaZZ+Rf/+t/LS+//PKBHnPfQQOJniNrGESnh6mTMB02kklNSh8ZwcC1sAAjirHoIpgwGeJDw211FYMqV9dttvaVECIYhBFmrXPAcKLt+hdFHPr7sYI6PIw2Hh5WwhMMYtWy26R64YLmXqytaZgBDTW/X+sa9fdrkT0S3L2QJhLBdBqGy0ENOlZVm6tXVT6918VZWi0Q8kwGfXJiAu+BwP19I5fTVTuuMq6voy+Fw0g8v3JFa7Q8/zz6WK2Gtt/aUmlbu10NB8pri4CUUFlKRFeCbTZ8l80ilGpjQw2OaFSL3AaDyBfxenF8KldyzC4UMFkOD2vYH2ssLSzoxPfss9jXyoquBtfr+A09P6EQ9s3fDQ4iDKbVwvmtrmKbs2fx2wsXcO0vvYR2SSY1rI41kvr6sI9u3vO1NV38GB7eXsDkpJOlzqT2eBz91mbDfRkdRVuxTlh/PzyH283bNFAPCn19uJ/VKvrfwxyrWERuktuNe79dzpXIySZK+wGr4MN+hie6XDrHNBqq1Mk8z0ZD1fEyGYwRjQbmV6dTw4+5bbWKcWNrC8+6zaYy3l4v3llfSwTzJ7frBkqKFwq7r1V1lJHNom2sYbGhENqO6nh+v14rc5jt9v173nt4IXZXhOlXfuVXDvg0doff+Z3fkR/7sR+TX//1X5dXXnlFfuVXfkU+8YlPyK1bt2TwuBXSImGil4lu6k7CxG3pTTlscMDr78fg2GxqlWvWqvH52knAxAQmPipjcYV0YGB7491u13A8VtLm6jYLtDEWmblKtZrWoCEZm5vDAOz3w4jb7uFmEVERJWVMpGf1ca5gsZCiiMbXi+Ac7t3TnKbOQZz5Mum0Eq2FBbThQYUTTUyorO7amuaSDAzg1YtYXNT6LKOjuK+FAnKSmKMjgja7dw9/czFgfh73fnkZoW5f/zq+n5gQ+ehHsbK3saHemPFxVX5j4jPFRngMqhlyFbjV0pAHGsgsXEsvGD1ZtRr6OAvXMmeActqs98acyVgMz0EsJvLnf47P6FW4c0cXcUQ0MZsy0Y2GyoJ7PHjOmFeysqIrvj4f8liefhpkMh4HcbKG1dlsuIZEAi8WtWYxUD6nTFYeGem+uHKcUangHlGUw+ttHzM4tjLPkkbv+Pj944XHg3GIXu/DDiGy21VFMpl8uPOh/Hi5jD6+soLrHhjoKSNtX3AQ4XgEBWtKJc2doVcjHNZ8FxZXrdXQHyoVtQVSKRWSYk5OLofxZWwMr74+5CuKYP4fG3swCeL1duY+HVesrGiEgseD+YT171IptO3goNpV9DhvFz3xMKC6K3NdD1sE4zFiV4Tp+7//+w/6PHaFX/qlX5If/MEflB/4gR8QEZFf//Vflz/4gz+Q3/zN35Sf+ImfOOSz2yOsSYf1unqYOkPyuC1zGg4bDO1hDRrGBzOxM5NBeIRVujQYBPFJp+Ht4YrHyMjujmmzqRu+GxgetbiI9tvawork6qoSuHPnHpz/NTqKyd3rhXE4PY1jUtrY7dYE05UVVYmx2TRJPZHACtjsLCYHlwvvrCJvPWePR2Vxm83dt8deEImohOvWFiYyrri1Wj3nUv9G/sbSEiYWejfu3cMzdusWQjFcLs3roafuy1/WxGu7HTlLW1uYtP1+ePHeeENzx3w+PBMsoGi3o+8Eg6puFAggvI7FniMR9Bdr3p7Ph+1efBFKkVtbEJHY3MR9bDTw/JHcrK3h/1AI2zKBmoUONzY0Dp3hbFQHZNX4YlEXbxgmk0igz37ta6rwNz6OZ55kiYncNpsaT4FAO1miwhdJYTa7c3HQ0dGDeTYOA5WK5hx1Kn6RuPp8aoxY5wO7HYsxO8lIMyz5KCAWQ59JpXAP96ImyvAiEQ3xYqFxeoVPgsfgceEgBB+IQAD3igun8bh6hVgnjmqHzKN89ln072BQVXYpVe1yoa+vrLQLfUQimmPJEMzdnJsIrp/hp8cV5TLGcy4a81rm5vDMJxK6mM0xYD/zl6wIh9WeMIRpdyiXy1LlA/CXCB9Q41WrVXnzzTflJ3/yJ7/xmd1ul2/+5m+Wr3zlK11/U6lUpGJJ0M5y1eOw0WjAeGDVcmsO03YeJpHDlxZnkV1K2VLtptHAOVL/v5vhQ8OK/WVoaH/luONxDNbVKkgZZcKHhmAA76aeBmvQrK9jwO7v11wmYnISK/EbG5iwrSt2VPWjYWolwiIY4GIxnBMJJRM1qRh4EKvoNF6jUdyflRVd+e0lwpROq8EVDGISYUL8hQu4r5UKCAFX9n0+bPPZz6qEPmt5URr78mUttkmP6MCA5pZksxpyRoOC+UMbG3g2GMbJ2iSXL6NIp8+nHkJ6NlnI9d49XbxwOtH3s1n1EjEMhSG9hQLOx+PB9l6v1k9hPRyfD9vw/+lp9Geu/tK7RSwsYMKmZG/n+B+Nbp+DZFVGo+qetRhos6merOMOSm1bSRIXglotkPVGQ3M2CApshEJoq6NChnaDUEjDtd57D/2X9/xBno5MBu3hdmPMHR/HfLm+jmd0fl77vcGDcdCESQTjZX8/FkyolJdIYPwsFvEsUymvVsPfzaYq/3m9OhaxfMDly7rQ6fc/nIiD04nfFIvHu4g761jZbBryXavhunI5VVXlohsVV0X2nzD19eF5ZBRFj2DPo02hUJB//I//sfzu7/6ubFllF/8SDYaW7TMSiYQ0Gg0Z6ghFGBoakps3b3b9zS/+4i/Kz/3czx3I+TwSuNpst6tcuNWw7owLPSqEiR4u1qdxOjV8rV4HQaG3ZGOjXQnJ49GVJyaq7zeCQSSKUhI0kdg7AQmHMbn39SFRvdONHQ5jUtjawqR96VL7qtXEBF71uoZR0tjslOAVwcq53Y52W13Fdgc5ALlcOGYigcGUYVcnEaw/wfj5Wk1zPAYGkCjM0AWPB6Tpxg14mbJZ9Zx+/esgBaUStimVMHlPTEDI4IUXRP7iL7DPZhP5dzTuajUYfAMDKmhCiVfmsUUi2A9DO3ncRAJEgyFbtRoWA06f1rwVtxv9r1zGOVOAJZXShQ2Gos7PqyepXFZP4+YmVoH9fvRBilNcvAij99w5tEmjobmBqRTOcWEB58v6Tdevw8Dx+5UM0Pv0oByk40QGdgt6RRjWyNwh5qBZnz2GNbFwLz2RxxmTk+hThYLWiFld1X65nQHPeYVeJAr7DAygLxYKeH5OWpjmQaBcxrNLefj9hpXI2Gxas43FpVkOhQsy5TL6wKVLGJO4OHX2LMaUclmjVayLevS2sx/tVsQhEMC+rPUZjyNIiBhCXqloaZTVVS0qvb6O+Yq2BiMk9hNcGCuXe6rO454tpX/0j/6RfOELX5Bf+7Vfk+/7vu+TX/3VX5Xl5WX5jd/4Dfnn//yfH8Q5PjR+8id/Un7sx37sG/9ns1mZOArFtlgrhcZ4J2HqDMvjpHrYIXlcWeaKj8OhK1esB3L5MrZbWsKEb50QObkxIfgg4HIhl+T6da1Gf+0aJm7Kb26HTAar9iRz5XL3CZ3eslIJA9XAQDtpYkImDd0HgXK7lGEuFGBMsSr9foMS0KwK3q2o8HHH0pLmQIhoX6hWQRi7eUNcLhizm5u4t9PTmJQSCfRvEppUCts88QQm7bfe0mP09YFwz8+rB/nsWbwnEuhT9CjEYpjwpqbaFxB8vnaxA4awzc7CCJmZub/2l9eLVzarktJeL/bPPn/+PM775k2ts+RyaQ21SkUl/i9caO97Fy+qtPqlS/hNoYDzYbFQEfU4sxo9cRJzkHZCq4VnmYsgVAW05kJ2gqRxv1eDDxP0KNVq6DuZDN5rNYx3Fy7c/5tGQ0OJOsPu2I737qm4j8ln2hn0MuxVHn63sKrRcbxlOC5J06lTID+RSHtRYZsN41EmAw9/PK73vF7HOG6NgmC4cKGwe0VaK2E6jmAY9fy8hnQvL2PMDQTQpiy0LoLxhaF7BzWesGguQ6kNYeqO3//935f//J//s3zkIx+RH/iBH5APfehDcvbsWZmampLf+q3fku/93u89iPOUgYEBcTgcsr6+3vb5+vq6DFvr+1jg8XjEcxRkuLuBcboMPbF65prNdkJx1AgTJ6hmEw+wtWr2xYtYdU6nMakxfEhEw3YeBBobrdaDZWUpXzo0pMehWlixqAnxX/oS9nf6NM6x09OTSKjIg92Oa1tfV9lTK5xOXAfl0lnvibDbcd17Wc0aHLzfCyCC82QoDok0i0xa1XD2ir4+tE86ffIIE1Xccjn1oFHatq8PE3A3kZhyGaGc0ShIwdQUhBFGRkB6PB6VUx0aAuF4910NoQqF0OfzeRhzwaAmqL/3nhoWAwMgJtEozqVz4l9eVq+MlWicPo3+nEziONPTqgJl9RzxXM6c0XGEKnyJhIbThkLwhjGXjn3/7Nn7iXo0irajkuS5czgXETyjfE5aLfVekZSxsGovgOUH1tba78Xk5PH3Fj0KXC5V6azVkO+Xz3fPgWDen8/XfcEoEkGfZUmHXgorfhhwLjnI0FaOQ7RjGPK8tYX58amn2sU/kkkVdIjHUQeRUSlraxhnKa7z1FPtgksi9+f/dQMXptiHOgvYHnVUq2i/zU2QyXIZ7UCbKxRC+zE83OfDOHz+PMZ3emkPagHG48E5WesSnnDsmTAlk0k5/Zc1O8Lh8DdkxD/4wQ/KD/3QD+3v2VngdrvlhRdekNdee02+8zu/U0REms2mvPbaa/KpT33qwI57YLCq5FEy3O1uz2ciaNwfdkhep4ep1cLDUirh4YlEdMX6+nV8d+WKqt74/XhRMKIbWi01CkVgoJ0+ff8KRquF1ScWvNzaglFiJRB+P377+usaN/366zinCxcwONPA42p4fz8G8Js3MXGPjXVfPYnFMNlzcreeV7OJc+u2eroTBgYwCHIVluecSGz/GxYM3OvKYSSi9YVOkjRoq4V7Nzt7v6Hu82Hy6ObpaLWgekfVn1dfBVkiCWFScrUKMuV2w+jb3MT+qLAYiWDlPBoFMZ+agqhDLofjh0J6Hn19GrLGHJ5KRQ3tTjU0iovY7egTJCydsEpKUwRlbU0nNp8PMt/RKPoAF6ECAex/O8N+chLe2nweYVFsF+siCMNmfL7eUWFkcU3WQuJ44HTiHp60BYlHBQuNU4a+kzB1huN1wlrkdH39fg//XkHDdGjo5IyDVjwuwiSiY4LPh34/M6Nh+KyhxLy2pSUszkxOYqykZ5ohZFS4TSZ1gcsq4tANVJ7k/Ml8yLU1zeHdS+50va5zOl+U8z4IMB+JYjgimGMqFfTzSETkf/9vXMOZM/juvffwPetURqMYw1Mp2FkHFYbINjCEaXucPn1aZmdnZXJyUi5evCi/+7u/Ky+//LL8/u//vkR2Uu/ZB/zYj/2YfP/3f7+8+OKL8vLLL8uv/MqvSKFQ+IZq3rFBq6X1BvgwWpMgj3pIHicnSr7WahjUolE8wEzUvnYNBmIwiG3SaTXQKX1ZreogxhovtRoedLsdq1bXr2PlxJogzpAMDiqM6x0ZwQDsdOK7O3ewPRX9uOI1M6MCDNUq9j81pcZ0KKSF97bLKZqeVgU9axtx9TST2Xl1p1vsr8eDthkcRDtxFbbRaC8u2WjAaN7cxH5On97bZE850moV13lSwoBmZ3Fv7XbcG4YtUNmuG1ot9LHlZbTtyy8jJ+mNN7CvkRHcA8q4plJagDYcRmjehQsg12trmPx9PvTDr35Vn4dLl5SMMH+oG2w2kJDOlXN6ooeHcd/W13EcKkgGAnjneJHLwaikB4y5g/G4hsAw72B0VENDtwOlfBcX1WDhs9ZraLV0wSSdbo8Q8HoxtgwOHlzo8XHH8LDmUVq9TByPRHb2ng8MQESDBvKj2B6sKXZQojuHiVpNDdqDzN+xEhmK00QiGHNzOYxVVvXQQgHjSH+/LhCtr2vRVaoCr61hLP5rf01VZ7nQNzKiC0q5nIasEaxN5PVif+k0zuvsWZwL866sZUkYSl8ooH/W6+iHnSRrp3zM3YA2ICXX+RzQJlxext+hEMb9c+dAkD7/eWw7PAzP25tv6jWyELrb3a6Od1DKgIYwPRg/8AM/IO+++6580zd9k/zET/yEfMd3fIf8m3/zb6RWq8kv/dIvHcQ5fgPf/d3fLZubm/IzP/Mzsra2Js8++6z80R/90X1CEEcerRYIRj6PDk0PkzXUzYqj4mGqVLS4HONXWTOmWMQ1NRp45+Anggc9lcIASa/J+joG1MFBDGZ2Owy4YhFGxqVL+I6xuHfvasL5u+9qUvvYGAbrrS2sSC0twcgdHtbwKBZ3s9u1eCYFD6wrnFZvxNAQzjWRwMC8W8PH7cZ5r69j0NuOiKyuYsLv60P7dBvUWOh0O+XJcBjXnMmghtCZM3tbPevrA+FKp08GYUqlINDQaqEtOgU5RO6Xls3l4HGcmcH/zzyDtvz859HnYjH0V6rasXjia6/hu/e9D3l7zJWLxVTR7N130c9GR0U+8AEYeZSXLxRw/wsFfM9VVbdb61zwfJeXQdy7LaQwyZqFdFnfyCo04HSiDw8M4Nxv3VISxTCO3ebKxeN4fqjAd8CLZEcOLLTJujEEE91jsYPJOzxpsCqSrqzoGEfvEhX2tgNFINbWdC55GLBemQgMz5NGmOhd8vsPlrxb1ehsNk05GBjAeHfnjsgHP6ilCbJZzNUsCs6FH6pFUkhmbQ3bj42BXOXz+K7ZxDgdj+OzmRnNFaQnLZXCIm6hoN72zU2tfcnjWcdVkjurUiWJH1/VqobcbldwuxOUyU8m0R6Vii6Wt1raXnY7rofROBR6YJ269XUteeJwKNEbGNAiwh6P1rc6yHndEKYH40d/9Ee/8fc3f/M3y82bN+XNN9+Us2fPytNPP72vJ9cNn/rUp45nCJ4VNhs6u8PRrpJn9dxYwQfyKHiYVle1SncgoIMUJbOpSsbVm5kZrPxwwBsfx0CTTmuYU6uF/bZaMEi5Ar6xoYU9mVhIUklDb3AQAwvr1iwvY1BhmBGLYTabOH4wCE8S8wyoLJPNYqWRHiMax6x9sNvCyKmUDsKlEgbIzpXSbFYnikwGbbQdadoJ0SjacGYGk8KtWyqTvRtEIphAaDAcZ2QyIEu1Gu7zCy/c355372KyOncO/SefF/niF1UgguqB/9//ByIajaogg88HQt1qify3/4ZJwm4X+chHsB/WGKpUsPJ39y72GQ6LvPKKhqcxd4j9nuIbg4P3F/esVED6O8NP6H2lgZJM4kVlNa6W22x4lkZG8FzevKmGgMOB63pQjmAnbDb01ZOY+7YduoU1iqC9YzFNcDfYG4aGtJYYvUwPCsezggtT+fzDK6DxeCLYx0lTDX0c4XgExRW4kEBP+bVrGE8/8QmVyWdUCRVD+/owR7MenVVFeHkZYWjDwxhH3W6NILl7V+uV9fXB472ygv2IYD5mNA8XWSmmEwiAIA8O4m/2o1gM+4tG8ff4eHsawtyckh/WGONY0Nl38nmtRcaFZNp3JJYUYZqY0Hbw+zXqyGbDWLu+riJNQ0MgoVtb2AePzbGc4/xB1kgyhOnBWFxcbFOam5qakimqRxnsDlTJ46pHs6nFXEWOroepWsWAYrfjYWYtqWIR/1Pq0ufDA10s6gDY36+1XQYG8IDPz+vKEOW3R0dVJjmXU3c9a1dxEJ6chDHo9aItBwY0L+TaNQyalDF1ufS8aEwy92J9HcdZWNDB9dw5jZNfWMA28fiDDctSCSFhrZbmpK2sYODlb2s1bCOCwYyhe/fuIaxur6SJ8s+sIXTzJvazm4EyFMJEwHt3HCVXWy0NL0skcE0vvXT/ql+5rMTwzh30ny9+EZ8Vi+qB+d3fxSQcCqFQ7Isv4r56vfAk/ff/jj4dDqP44q1bmn/EmPnXX0ebhsP4vdUD3pmjx/pJXC0dH8fzlUyi77HG2dQU9tcZVpjPayFUhr2K4Pw5Tt++3U6UGPL5sIYhvQMnHc0m+tTami5WORxYaKAn8TgXwjxsdHqZWKCddeN28/v+ftyj9XWMe3tFZ2mUbPZkFcR9nISJizWdhIkqeLdvYwxj2PDFiwhlZnjr6irmMC6MJpP4v17XOfrSJSzYUKEzndbQ6/5+HIvjYKOBfkQ7JJXSsb9QwHkwuof9LRDAfkZHVTKbEua8hs1N2Bnr6zi3O3ewIByJqGpjoYBzpieJxL6/X8PhXa72RfJsVuSdd9A2k5P4fnwcIg6tFkL9WWzeZlNBq+FhjEUkn0xTCAQOlvyTMNF+28+6mkcUe27N6elp+eAHPyif/OQn5W/+zb8p0d1KOxooSJJYn6fR0BwVkfsJEzv9AdW42hVYkLbZ1KTdVAoDQjKJEKb1dQw8Z8/iYQ0EMMDRG+X1tivAMW53dVWNuHodBsrUlBKXchkTKWPbOfgvL2NgzOfVoHE6deDw+/F/OIyBx+3W1RAWdQsGcU1372p4x+3bGMinpzGRV6s4zk59vdlUssTz4HUmEhjkWi0Qo3od5O3MGWxz966qCj4MafJ4MPncvYsB9M4dDPgjIzv/zmZD27DmRSdhajTg5WMe2uMEJ0ifTxXaGg1MfFTmIVERQRsHAuh73Twf1pXkXE7kv/wXXel89lkc48tfxjFdLpEPf1jku78b/ZMx42+9JfK5z2ECfeklGAMsNHvqFH63tIT7HItBgc4a4tNoYIEgl0PbT01hkl1exiTMnLxAQM83GMS+twtPYv7S+Lg+T5Sa3djQ8yFRGhoyeTVWUN6aC1Z82WyaUyCCe8v8r5MoDHBYsHqZ5ufx2V7KTgwO6gr+bouZEqx5xRX8ROJkESaG/4o8nvGbHnKSBJtNPScbG1Cq/Rt/A3YAa80xGoKLrF6v1nIsl9EPcjnMpw4H7jPrcM3N6X17//t1wZY14vx+7Hd0FOPj4qJGnDDKZH4e+x8bwxw6MoI+cfu2hv5lMuijiYQunsXjGBPSaQ3183gw9kajqnrLPORwGHPIyEh3KfxsFhESjNhh/ycZqtdxPJdLSVwqhetnOB6jDhhdc9Dh0gwHZy6WIUz344033pBPf/rT8vM///PyIz/yI/JX/+pflU9+8pPyHd/xHUdXwvuoodnUWNZG435lvM5cBXbEwwzJY1FFp1Pj9QcHcQ3z80r8QiEtkjc6CgP27l08XGfPatgD5TK5usPCtvzbbsd+gkF85vfrSlQ2q9KjJHCURPb5sF+vF+fykY+0G9DlsrrSWWyzXsegPjMDg7lQwDbXr+PYVpWd7bCyou0zMIDtme+1uopzYDijwwGyxBwltlE6DdJ16tTeSZPTCZK3uIjrZ37M9PTOq0yRiCauW417krts9uFk0h8F9TragSR9cxP3o15XcQOrQcWFh7ExTIzd2o4EpL9f5H/+Tw2J/NZvxT5v3oTHyedDvtHHPoa+MDuLc7h7V+Qzn8F+JidBqJj0G41qja+XXsI98Pnak4KZh8d8vTNn1As4OYl9zM1pErAIJlfWKnkQWBCVk+vdu+2Jvw/qB72IfB59fKdx1eOB0dLfb7xJBwGrl4kiKHshLFSczGSwD6pV7gb0LvX14ZgkTCcFbE+P5/EYs4EA7keppCI51SpEcXI5jJ1372Ju3tzEvNNZtoPeHxGENv/RH2FfTzwBW2NpCXNVKqUFczMZzNX0vNB7znA75jtdvIh9nTmDMZ+qlpkMznN+HvtnvjMXoHI5fF6vY76cnNRSH1NTmEsyGV2sLZfx21OndP7kotp2JKZY1NqLjM5xuXANrRZsEy4Os/i504lrDgQwhnGRLBBQe+qgwXvMhcsTjj3PoM8995w899xz8i/+xb+QP/3TP5VPf/rT8nf+zt+RZrMp3/Vd3yW/+Zu/eRDnebJgt+uKgEi7ZCX/t4KDHbc5jBXOalVXfDwercFkt+NBdbsRo8zVI0pr22yYmJjcGI1iRf2tt7To2fAwHvh79zBAcIWxWsXAyNo3FJlgPRuqloXDGLisCfLVKgYOxkFTqpPu9tFRLdw6OorjDAzAaM1m8c7QSXqE5udBbmo1jXem25zS39PTGmrH3CyXC9dGA3Zqqn0lNBzGID4zg/NoNjG47rTKylpM1r5gs2mBXio/3biBfXcrwMtj22yY5KwrtEtLajzQA3fhwuOpJTM3p0qJnMg4IHNwpggDi2Iyf6dbkisThdfWRP7kT2BYZbOYQNfW8P1rr2lx2g98QD1/9+5pP93chGH1vd8LIr7d/Tl7tv3/RkND91wufN95P0IhhPwtL+PY4+MPF3+eyynZpOLUbvPvjiuYg7hTuYJOWOuu+Xwgpp3ywVT6MkTpYDE8rEWmHY69J6oPDakXoFzG/w/aB4WXRDS3laHm1to9uwEFCo6a57YzIuNxIB7XRcfBQRW2euIJKLrdvKnlNkiarAuRlMVOpbCPp5/GHJZMYh5jCB3zjkZGcN8CAQ19DocxD1arOGYigd9ZI0omJhBZsLGBcZ4S9SLqlWJuVaWCbdknGg2M414vznd0FMcaGkL/u3dPhXcaDfSLsTHcj1RKf+v1KsHkAt7p0/dHSMzN4dyp4kpPHm2gcBjXyAVkRiU8jv7I2oQ9ksf00EuONptNPvrRj8pHP/pR+aEf+iH523/7b8t/+k//yRCm3YDJfiJ4+DlRE91C8ihcQO/N4wY9TPTiFIv4u1jEw8zPL1/GdvRalMt4gO/cQT2aeFyTfItFXXVxOjHA3LwJo5SDPMUe6EUS0RjhdBqDwtoaVpAmJjBxMndpdVXkj/8YYYEMrdncxKDEmgU0XMfG8PmVKxhAy2VNHl1eVnnzc+cwQHIwajTgmRgcRL4K46JZi4oKfjS6Bge7e6qoljczo0Tn9On7DWu6/1dW0GaXLt0/MPb34/rv3dO8Jqv8dDCo/Y9Eg6R0cBD7Z32r6WkNmblzp3vR3/3ExgbOI5dTxR8WYPV6cR85OFerODdiO/n3ZBKk64//WBcr3vc+fFerQbY2kcA9+Kt/Ffd7YUHz6wYGsI+xMXiQ3ve+vU1Gy8s4V4+nvZBzJxyO7ivkDL8YGtrZS5TL4TkQQVudOrU9UT4pqFQ0f8/h0KLE2/XRVku9sCJ4FlnbyuBw4HRqwdJYbO/3IhTCs7GxgWcgl0P/Hxra3jNItVanU6WXWQMvk9k9YaLYjsul4edHBY8zf4mIxXShlCH8IpjLFhfVE+jzwQaYncVza10cGhvD3J7JaGFWhrdNTsJeePdd3EOq3rFI+MQE9nfrFnJ+lpcxNoyPq5T9xoYSp6Ehrde3taVhjG++qd6c557DuOHx3B/ZsLGBPlAq6bzLUHb+nguy24G57LHY/WRpfR3ttraG83M6cY1sV4YIUxyL4YePKxqkx4QfHvrpXlpakk9/+tPy6U9/Wq5evSqvvvqq/Oqv/up+ntvJhtuNh6/RaJeXFLmfMDGmnop6hxEryrwRut2ttUeKRQw8HACnpzHQjY1pUcC7d1VaMxLRxOlgEIOpx4OBYX5e62v4/epeZqiRNS6bKzV0g6+uqvchFEIdnXodg9kzz2j9ort3VZGG8sBs+8FBrXt04QKux2bDwLu1pfUhPvABbPvOO/j95iYG6Tt30D5PPKED29wcrpOKO9uhrw+EZGZGic7kpCqsUY2NCfyNBgbUblK4fj8m8Lk53KtiES8SISoNMbl2Y0NrZHG1i8qGfX04l0oFbcdK4g8Dilx0M/5LJUy25TKujfd9dLR90mcf4KtUwjl2mySaTdRC+uxn8ffoKGp6jI7iPL74RfQ5rxdhdpS3Zzv192uIUCAAsrQXA6RQUJ8bT98AAIYcSURBVON8cnJnqeRuyGaVuFHhrxtaLc0B6RUSUCigP1JhtNHQPMSBAa0rxRj7ahX3nCE/u8nzM3g84DPeqRS5W9CTurEBo7hcxvOwuorxqjNdgOF4sZgSqnBYi55aS0xsh1ZLvZSsDci824cFFXNFHq04aqv1ePOXCIdDwxvTaR2TmbP7zjsabub1gvTMzLSHfHs8qgr3ta9pNAWLcd++jeebUQdOJ+a5mRktPryxgXmBtsDQEOZDLq40GrA3XC7MHRRmYo5UsYj/vV4Qr6eewrVx+60tJejVquZN+3w4n1OncAzmUbtcWuOJ0TrlspZj4WKaFSsrWMzb2lJxn74+zMs3bmh0DRWFfT5dMHpcMIRpZ/zGb/yGfPrTn5Yvf/nLcvHiRfne7/1e+V//638Zpby9gh2tG2HqzGGy2/Gw0sN0GKC6HL091ge+WtWwGBqIzOMJBPAwcdKiCz2TwaQUjWJA8PngoRkf1zhljwcDHXN7rCqBLPDK8D3mm6RS2MfUFLxdN2/ifGZmYLCyMO7CAq7FWqyThfK4MscY4Q9+UL0OySQGyTfewMrT+fPYR6WiNZFiMbQD5auZSPqg3CQKW0xNqadlfl7D+6zKapGIqkMxAbUTzJWqVlVsI5/HcTrjjnM5fLe+jus5dUqNBqcT13LzJs7rzh2QyTNn9raiStGDeh3Xdv68/p6iGVQ4Gh7W/K7ONqM094OMq1oNIg1f+AL65qVLIt///SDozabW3OAENzSECb1UQv964QVc97Vr6LMsULtb0KASQZ/Ya4hdKtUuJJLN4lnpJmpByWuXC/3npJMljgmU4D17FmPR6qqOQVbvoxUOR3shbIPDh8326PfD7cbYz/IA6+uqQHnhgi5WNBqqJmnNl+rrgxGdz2so1U7Y3NS6gSKa62JREX4guFhFlVjrYmkkgmd5uzGWubxUiLOiUMC+nM7HE0ZtRTyOuZBGPEHRAyrtiqDNGIFy4YJuPzKCCI1sFs93Mol8Jhb/pnJco4H7trqq3kXm9/T3Y/zmnLK6qiG2Ph/6yJe/DBuE/YGlTS5fxjbXruEYr7+utSEZfh+PY86goBVzrXezmNhqqShPOIxx+/ZtLT775puIyCkW1bsVCuEYX/86+ujly/h+eVlzuTtJ10HDEKad8Qu/8AvyPd/zPfKv/tW/kmeeeeYgzunkozNWnq+dPEzMxTlMwiSCc7tzB5PF+rrmyrCadrGIzzY3MWBtbqq859AQcpeKRRit9boa4Q4HVlRYR4jtwZWieBwP5dCQJmWmUhi8qlUca2ZG6xpQBCGfx+C9sKD7TCSwr1gMD/ypU7qy6PWq1+VrX9PJ6KWX4KWanRV57z3s9403cD70HPD+sW4UZdJFMFCvrWmdJ4Lhi/yNiOYisa6UVfp2YAArTE4nflsoYCLYKdnZWlRTBPejVFICzneG3iWT9xMDlwsTCKVN79zBRLSXuk+se8Xrvn1bSdPysnrABgdxXx5GMZDIZkX+7M/gQcrnQe7++l9HG8zMYIXujTfQhwMBnMfKCu6B0wmSPDCgoV5nz8K7tBcPkdWg2smz2A2JRLvHyOfD+S0twUCwGlEspCjSXjPkpGJzU4ko8//sds1py+fRHpmMKjkxvNPjUWEZg5MJ1hiLxTDGlMtKmqhs1mxi3LJ6pdk/KhUY3jupjNVq6okfH8fzODOD8cvv312NMpbK6JzTOden0xiPT51qXxyq1zEOcF5goVMrOTmMcDyCeUiLixiHKe3N+kHr67g+enrtdoz5JE0ez/1FodnWgQDyiapVtHWxiLb/2Me0qDSL446N4Xj1OuYXik95vbi3+Tzu8+oqtne78TlFIzjWFgq4pkwG3/f1aUF5rxdjzfIy+gRDAndCLoe2YaRIf7/2y4UFECLmUzFyIhzWRczXXlOp9WQS/ScQALneawTDo4LjaK12ePn1jxF7JkwLCwtiM0mwjwaGppVKGku7G8J0mB4mhmtRvGB1FQNDOq25TdksjMyZGfwml9MJqNFol+pMpbQQG3/PFX8Wo52Z0RwoFgCNx/Hb1VUcj7lSyaQmXXo8IGIiWseGIWc+nyZKVioar1ytajw745ldLpzfxAS+p0fqr/91DO4M9UkmMahGoxhAWdtndla9JZmMrlqGwziXTOb+lRlKss7Poy3PnlVv2MREe07K+DjCBxIJtFk34sJVS+tA6nDcP5GePo3fp9OYnFkTY2pKw01KJZWv5uvmTRisnd4eyrHWalp3g2Fu4+O4z8UiPDoDA6qaGA7jXJm39DDIZrEayYK+IyMiH/oQruPaNUxu9+7heC6XyKuvYsJZX8f9P38eE2Ozic/cbtyHvSSCV6taIHF8fG9htJyARdA2JMMMrVxcbFeXWlzEuYZCJ0cSuRtYdJKeI7ZN53wUDOJ+Md/TzFe9CZcLHoZbtzTX7fx5JRrdSE04rPL+OxGmpSU1VBkyPToKw54hvg/KI+FioteLhTSGbTE3mAqdt29j3hkbw3y3uNgetsfohosXta8fJmESQVtcvaqh/Ha7hsGzzAY9Quk0tolE9B4tLGAsazTUY5hKYT8MyRsbwzhus6F9nnkGbcPCt5wrGSkyM6Ph/qxnxFxnRl7Mz6McBPPbzp7F8VdWNMRuagrXRfuFdsrMDBZZh4exzeio5t1aS6Mwn8npxDX4/UrcZmZ04fall9AvaDNcvIjrZcgdFeoYdngYHnOHQ4WxWOvyBGPPhMmQpX0AQ+xElCjtpJLH7ZnD87jBWgL5fDu5S6XUvT08jAemUMBENDiIh93rxeDDYqCU61xbw4Dl98M4pmHKIr4kUbUartnthlu8WNTJgvLk1SoGVA4qrC3E+jQMjdrYwLHorWo04GlwuzEAezz43dtv62qJNWEzn1dP0enTWpyW4gqVCgZAj0dDvThABgIYDKnSZ7djoojH8RuKQ4jgWhiHXyx2j8EXUVW4TAaGJFWEuHKWzeoqVjSKCWs7w531eZ5+GvtbXAQRpHoewzuefRbXxronLhcmuelpDUXc2tKVL4LhMQwf9HjUkOGqPxV+pqcffuAtl9FPqFDEtq1UcF3ptLZLNAqD6tQpXAPrTXEipYT91NTec11IYpiMvBtUKpiYGXo5PNwuTT41pYpRsZje+3RavZLHEcw3aTbR9t0S/5NJGKmUAN9N/tFJ97QZPBhuN8bPW7fUq80xsdvigpUwbQeu7Iu0P3MjIxiv02mM9ZcubT/ecjFGBM95J7liDurSkkZzbG3p3OfzqUfh2jUcd31dw6gPmzDFYjjHQgHjvteLNg2FMB6ylMfGhobfb2zgGm/dwjzb348w6M1NvN++jXE1FsM+L1zQXNRqVb3O4+Na3PbNNzEO9PfDNohEYIswfI5EmjWc6Gny+zH2Tk1hbhwZwfG3tkT+/M+xH+a7rq3hN1w0XF7Gq9VCf4pE7r8P8bie+2c+g/GvVsN1PPUUFodjMeyHkuQ2G2wNj0fVcKtVbJfPH57XnB5BQ5gMDgQME2EdICY11uvqjrfisEPyOOjlcur693qxqsUQplAIg/b16xhoLl3CZ5WK1mAiSfjKV/CbZBIDA1eLkklth1IJpMGaKLm0hHNxuzHgOBwYdHM5fF4uqzrS+96H/Vy5gnOIxzUOmESIRj0LwjWbuorvcmndhnod7/E4BsxaDat/zNur1/EbyqgGg2gn5ndVKvh9Oo0Bf2VFc2YYl7ywgP0y9rxUQju5XBhwL18GWemcgMfGMOgmk5pXZgWT3UVwDmNj3eszMIxFRNuKXiURDPxcBW00VIkqGMRg/yd/ojln9GYxHpsESgT3enZWz31pSdWHhodVtehhUKuh/924obHtyaSu2tbrWgjR5cKk8/TTmJTqdfz+3Dm0d6mE82aIxl5Uh/ZKYsplTLrs/yKY9Hk/CL9fQ1pY9X5xEd/Rw3jcwiI2N7VQpQj60vIy+kk8js8XFlQimcbCw0iuG/QmPB4811ayFAp1D18KhfDccgGs0wi15iUyEsKK6Wl43Skvff58dw8nyQ/DpbvBbte+Pj+v4iYsfsr9TkxgLl5ZwXhFO8HqZXncsNsxVlFiWwTP+sgInuWVFc2JjkQwLk9NqXiDCP4Ph1XUqdXCtqzXWCy2RyVUq7jeU6cwD9++jXF4eRntODKCcX9kROemuTl8xoUtlkXhwh4V/1j0+8YNLTtCwjI4iHtAYadEAip+a2ta8Doa1TE9FlP74PXX0V9YqLevD/v8yldwbcPDIi+/jPYpFEAqWRBYRIWlDpswkXCecBjCdFig4dto3C8Zvp2H6bAIUyqlJKLZVOnMalUrUBeLGhvcaGBCYMI6B89AAIPC+Dge/EgEg4/bjcFlaUllt2kw5fMwZGs1/I7HWF1VAlKpYDuXS/OLGN+8uYlzuHBBi9xNTOAaJic1npgy3YGAyPPPY+LMZkFU1tawj0oF50WPzle/inOJRkGuRHAt5TImVYYC0Kt29y7OmyRhfBz/Ly/j3EsltBOreQ8MqHGcSGAief/7QfaYw+Lz4RzeeQf/T09j316vFgl2uXTyp3DF5GT3ED6rYtTFizi3UKhdeYcy8AwprFT0HlUqCI0YG2sP0yMxjcWwXSiE/Tz/PCa2Wg3HtHpU9gKqH16/jusOBjWEIxzGPdrY0AknHMaqI1XVtrYwMYng/hUKWvh3N4pZRKXSblD5fOg7s7PojxRN4TtzxohwGPd9O9I4OqohLDduaKjoyAj60uoqjjk+/vCKY/uFVktDWzpJXL2uIikiuO5QCM8rc7K4As8xZHi43VA0MNgtfD4s2t25g7FiuxwjhitbyyxYsb6O8YFFRbv9/uxZPJv5POaVzjGNhdBFdtefIxHMS8kkDOrOcbu/H2NdJoNnitcWCBzuszIyonXsOBbYbHiWR0a0GP3sLMYw1g5iKY/ZWcyfTFtgWPrYGNqvXNaQfLcb19vfj/GXedZcQLp2DfuNxTQ3jMXrBwdVLGRuTsO4T59Gmy8uqpqd14v76vNpgfJXXsF9TCZhM0xM4Lqmp9X7xXtCe6fVgq1y7Rr2GQ6raI1VSCSRwKIvyVerpQV7SeQ43xwmYRIxhMngAOF2t5MjEiaSEisOO4eJtSlCIS3CyvwrhjelUlitF8Ggvr6OgcnngwHIWGZWdp+cxODAukluNwaVSgV/P/EEfmezwUV/7Rq2n55WpTp6AFZXYWA6nTgOPVgs3Mk45OvX0YZXrqg3g+F5Ivit3Y4B2VpBnnK16bQKPLAYab0Ob9aHPoQJtNHQwqvLy/ibSfuXLuGdcqRvvKFk4/x5bJfL6TmTeN69q5Ll6+to51OnMPgz7K9cxvUODGi+EMPonE6c8+AgJvB8Hm3RCZsN7UJDwOtFaEMn6DFbWECfmJrC5MK8L8asi2hoIGt0dSNpFy+quuDDTPCtFvrk4qKeE+8/5WyZC0BiF42iLV0uTEaTkzhPknqqOIZCu/dmJBIaiud2aztmMhrWud2k0teH5yCdxrWwPhbDBLmiaLejvW/f1pXbwUH0EYbhFIv4PhrVENHdoFzWmPi9hrM1Glpc2vqix4wk3udDm6+u6oq5tbgui5DyGWHbTEwYoQaDR0MgoEJAO+X6hcM6blkJUzKJfiuys7iKx4N5amYGY0tnQe1kUotY70YcQkQ9FdthclIXixhlcFjheATD8qpVVfmlNHY6rYtDhQLGzTff1HpJAwMa0RIIYKxgXm2xiH2TEFL4yeuFx4Z1IYeHMa/Sy1Qq4eX1Yoy9cgX36sUX8fvr13FvaIucOqViHjdvqngMC4xXKmoTcWzLZKC8NzkJr2ahoGH5DKdcWMCx5udx7v39OvZzkYvS6kNDWtiWcyO3iUZxPpxTDGE6cBjCdFhwudSzJNLuPTpqKnmULI7H8fDm8xi0olFVourvV3lmKri5XLpazsrWIvg9J5ulJUxM58/DECT5sdbCCIWUsFA9aGsLA67HgwFsYACT2/XrWJlaXtY48PFxXEM4rCSuWMSgefWq5kyUSpqAefEiBjYO9BMT2O+776rHaGwMxncigaKoL76Ic4jHVQhicxMD4+goPn/f+7D/r35VE9ipusOaR9WqDoaUQaX0ai6H2gyUbqcHrVbDb+/eVWGLYBDHZVgEiejiosqoWtFqof2bze1V3RIJbRcWYKYcbL2O4xcKMNjPnsX9FdFwh25giOWDkMngPpIIMuG0UtGVuP5+DW9g+IXNBuWhahX3JRDAOXo8quDIOHf22VZLw192AkNI5+fVWxIKtddBstZ0Coc1Vr1WwzbMnePvRbDPdFrvExN/2VcGBnDNzSbuGb3T4+Pox5ubuvrKcJJu+RQ0YhIJJVwieA6shG07aeNKRXMPuo1NrB9HT6T1Gn0+jBfWuHebTeu0lUrY52EbfgYnBz7fg/Ms+vowNudyeD6yWRis1vDkB4mrMJR3YwOLZpcv6/NH79Lg4P6Fz1JSfX5en8PD9jAz+mFtTWugtVo4z3QaY874OMo3UARpbg6/GR3FuEg117k5JUcDA7hHzSbGD4bGzc1h3AuF8DkjMXw+jGeU8bbbsQC5toZj3LiB/WYy2Fc0CpI0MoJ9UX2vXkdEBO8b1fSodhgOY5/FoobsUTKc29nt8Cy9+aaKDlWrWh5kbEzD+7jgFw6raFW9rgRlaEjHVhFDmB4DdkWYnnvuuV2LPbz11luPdEI9A4+nnTBZvUfb1WES0aTnxwVrzHY8Dk8PPUVcyQmF4PUYG9PzZNL92bO4VhbSW1zEAME6OqOjKt2cSmFwmJ1VSeZAAOSCBj9FBZgDxlhgqg1927dhP+++i3MMh9G2lAd3u9UQSyS0QvbUlBp/TieOQ/U25lOVSlrHqb9f48tnZjDBlsvIM6L38Nw5PQarnN+7p2SjUtG6VI0GJgqvF/uZnVXlNhFM0E8+ic8pJT4/r8IZrBe0uKghBpRYDga1DsXlyyoOYe1nNhuudXFRZV+t9URaLUw2NP4HB3H/qlUloazXNDMDY+P2bWzLEIyHRbmsErXd0Gzi2kVwH5i4bbeDzH3pS7gPDI/x+0GI+/pAshgbXy7j3q2vt8vPbod8HjL5yST6ChOFrSvBxaJ6Svr7tfghydrWlop9OBxoJ3pkWRsrl8O2lJ8XaZfep1rXqVM6ecXjuhixvq7eNBqMPp/maXHlkwS4Wr2/0LHLpfmLPh/alkYGwRxBLo54veqNLZVUKYoFsIeHdzYYT3gCscERBb2gtRrGFXpymee5k6fHirExXVxkPhO9sA7H7haJ9oKBAYwP2Sye5b3kXR4EuODHQvDFogo/WNX9uOh27RrGs7ExXYTb3MT88txzaMOVFYwrp09j7BgYgEdneRnH8vmwWMVCs7mckiCG+UUimpPLUDiKAHFhJ5EQ+fznMcdzUYtlPjY3sU04jPF6fR3nRUVOzgeLi3jneL+xgdD5O3dwTOZ/+3ywgy5f1hxal0ttpUwG81U+j+PbbGhDv1+L5nLsPqz7LNJ+LicUuyJM3/md33nAp9GDcLnUUOYqLA2X7TxMIo+fMFG622aD0c6wHdYAcjphgH/iE3igKf+Zz2s4GN3u9+5p9XEKFTCka2VFjVomwpJgJJMYVJ5+GvsdGsJgNzmpNTNaLTU+IxHk+rzzDoz2eFxjn6tVDLA2m+b79PVhO4cDA9faGgYr5k5wlX9jQ2PXGaaVz2u+Sb2OYz71lLrvP/xhhN5xdZJS5RwsmZjLwfjDH8YK1N27MLCj0fZ8lkuXQEgSCZz34CCudW5OpVpp2DKUsl5HG8bj+J/FfjvBlbP5eVxrq4U2rtdxH2j4j42p9PrcHM6FhIgx/JRUF8G2DzOYNxogeTwXFiR0OvEcsA+uramEuAgmJAqJvPWW7mNqCp9fuoTJ6e238X8shm07Fyp2yqeq1aCWxCKGtRrue2eIzcKC5sBtB8aiDw+rJycQUIOHiw28n5xsOSaMjKgnjfD5MPlmMnimikUNR+wknlSJ5OReqylRo9xurabH7wT74XahixSFOewVbwOD3SIcVgVW5uBSSXS3sNth2F+/jueIIegieF4OQsWR4brB4NEQf/H7MYcwt3l+Ht6VV1/VOo0cl0IhjHmXL6sRHo8rsaT67dqaepJu38biqAjGdUp+l0oY/86eVZXeRAJjZL2O+/LUU7gnFFxi5Ek2Cw/UwICKU7hc6hGizUbhKIcD9/Xdd/H55csq6EWl29u3MS+xBiTVYGMxRKZMT2N/1jE8EMBvSiXMb5QYbzY1+oZeHbf78IgKj91q4Xk5waHTuyJM//Sf/tODPo/eAz1MdNNaJcM7CZPI4XmYKHfJAY9qefQK+Xya3B6Nwmi9ehXXFI9j4FhYwMM0MoJBodnEQFQo4LeNhtYmcjhwDL5yOezj/HnNK5qawv807umpy+X0N3fuwJjPZnGuTzyBwavZ1ATaZlMJDQnXxAQ8OSyOycJ4NhtW8Ckk0NenxexcLpz3tWvYlip4AwO4rk98AgSsUMDgd/kyjpVIqAfiyhW03927KtHOgoQ0uFmfIxhUafZWS+Rzn9NVMBa8ZfgW61y0WiBkgcDO9RqYN8bwhkZDFXAob0qvC4sTVqtoZxrMNBRWVvDdbldkraASEft7Xx/OYXZWiwxzNZAhYZQ1HRvTXK5CQcMnz5+HsMOLLyKssVJB+37wg7gWkrJmE22wnUGTzcLrmUio2h4FHK5eVdn41VWQXyYA01NsfXk8uN87FRzkanEggH2T9HBVdKeVZBZzpfKi9eVwaB+1TrYuVztRp4eIL5Ivhh2d4AnSoEfBmn7BYPtCxl7h8WC+mp3V/CeGcx0E3G7MX0cFJCF+P8QR8nmM1ffugTCFQhgfOZaJYO4+fVo9zLSH4nHcl1u3EAIfCGCOyeXQnufOoa0XFjBH3L0LT9XmphIopgxQNGF0VBcYuTh6/bqKQ3CMppLr5iY8XMPD6k3h+BgI4FoTCWwbjeJcFxc1pzgWg7fI78e1v/zy9p5Get4YsUH1QIbpiRx+OB7h8Wie+mGfywHC5DAdFjwezUtiWM1OhIkr9NYK2AeNRkML9A0Pw0jjSrfDoUmdFFxgoiXDhkgwrDHbzz6LfY6NqaGZTuO358+DAN26pYbrmTMYYM6caVcEa7WwakOvApXPKhUMyEzgp4T722/jd14vDOY7d7Dtu+/qg85ipX4/CNboqA6QFONIJEA8ZmZwTtEorpFKOHNz6vGYnMTAv7yM37IaOIUI+vq0AK/bjd8sLmJSGBjAgLq1db/3gKv9xaKGHk5OwihnSMDICM7tzBmNv757F6SOK0LbCQLQSzI3pwpuHg/2ZQ2Tstux7caG1sEiuP+HgbVwq9ereTlvvIGJNhhURT6+OIl5vSqucecOtjt1Csp9H/wg9nXlCvqZ3Y6VTk7UnES3W5ltNtF35+bU20ixj0JBCTalvllglUUV98vDspdkccJub/da7QVUDjO5RAa9Ap9PlU8fFbEYDF56o7mY0wtg3irDnZ97DvN7JoP51ppL22qpB+bmTZ0D6Z1nYVnmEft8WtcwEtEyJ9Z6hJTsFoG3ye0W+eIXVVmPi3tcFBwYwCLq9ev4LUWZwmHMHc89p7mzFHSo1zH3XriA671yBef6hS9gPuAxKAdPEYvd1OhzOED0ZmfVrrIuQDJc9LBJipUwnWDs+altNBryy7/8y/K7v/u7srCwIFXesL9E0iqRa7A96GHiKoVV0KFb+A4H2MfpYSLxYFjd2prmNNhsquwVDOpqfDqtEtlM4PT5MEjEYmpMxmK6smLNE4nHsQ/mv1y+DKPUasSy2By9XCzqxhVwesNYKZx5VyKqyBWPI6Rqfl4/v3QJf+dy6lonUaSM6dQUrm95GW1BD+GlSyBaiQSISTaroQDM92Gyay6HRNPhYQzEH/849vW1r+E4hQIGXr8f7/E49sHV/cVFXHelgoGXUqMuFwZV1lDK57GCFYupss+dO3h/+WX8rpsKnggmIpsN7RMM6spcJwYGVJCjVnu0OOpmE8ez1myanMR1vPmmJv6GwxrGmM2in5bLuO6zZ/H7O3fweSCAz15+Ge2/sACvjwjI+3biFp0ol3EvSyUVJiGpFsFxLl7E/ecCgduNY58/b8LRDAx6GRMTWpdvL2UKjjtImBiSzjC3QABtUq/r4p/NhnF1dRXbLy5qodtEQudlivKEw3ixXhsjYO7cwXy1uKiKgdPTGuIWCmndQirbWkWpRDCWVyoYy1n3KRzWOZuKdoODuIZQCITJ5YKIxWc+g/243bAZXnwRghGtFuaRXE6jOR4Emw2Ea3VVC9USR8nDJGIIUyd+7ud+Tv7dv/t38g/+wT+Qf/JP/on81E/9lMzNzcnv/d7vyc/8zM8cxDmeTNDDRDAkj56VThyGh4nGe1+fkqB8XsPaWi1V0WJhtatXVTqUFaBHR7X+TquloWNWFAqqCub16gNot2t+TiiE7e7eVbWYs2d1oNsuh6LRwAAZDOrqzPQ0kjXv3MG1vfqqhkmwphPPgapdxLlzyI25fh2DLhP1BwZEPvIRXOPiItoim8X/lEznYGvNaarXkYd06RIECpaX1Vty+TJ+c/482v2999AOrJReLmvV8VoNv2EC6Po6Elc/8AG0WyymRe5u38Y+xsa2V6+LxXTf24FkmGIcD2sMVKvwsHHinJjAPa9W4VmanUVbTk6C5DDnj2EzJIxzc5rzwzDKZ5/F/WbR5FYLExAJ8oNA2fJKBfsYHkbbWEUxRHA8xtwz/4GJzwYGBr0Lux1GOEOrewX0aDMPkuG+ySQ+m5rSMGPWLDp9GjbE5ibsCooGjYxgHn32WWxLeXiKAnEO5HjNovZ9fRiHKRueTmMOicUwLxDNJn7PIuYDAxqSV6moNDgX9LxezYG1LhSOjYn83/83ohGozkfRJMqli+xd9KObcBLtCEOYHgv2TJh+67d+S/7tv/238u3f/u3ysz/7s/I93/M9cubMGXn66aflq1/9qvzdv/t3D+I8Tx4oK05vEvMmGo3uuRNc3SepOugEv1ZLBQO4Ok7Bh2oVhjJD1SIRDCKvv66FMy9fRix1va4ha0yepGyrNVfJKkkcCOC3XPmhOpjHg4GMhO3Mmd15NMbGMEiyoC2J0fPPYz+sx0Q8KPSoWNT8Ircb7eNw4Bi3boHETU9rfZxUCgY0BS/icS3+Oj+P777yFZwHSV0uh33++Z+jLW/caJeMdbvRDq+8gv9TKa0hxElpbU1DHBn/feGCTjYLC7iGF17Yvg8wtHGnduaqYbGo/cXqdexsu60tVXjji+EGFBFhscL33sN5Li5qFXu7Hd/Pz2N7erfcblzP+jr6SiwGgvXMM2jPz39eFQ5feWX3zxBreJDwOp2Y6HdK2qa6YTx+olWDDAwMdgmG/PYSXC7NuU2l2stuJJOYm51OLedAUGKbJTEYEkd1z0RCZbVZDL5YxJyxvg67odHAXFKpIOc0ldLit8EgFsz2Ql4nJnDODN/fyU7w+7HIKYLtZmZUGlwEv98pb3U3oPgWj3GYMISpO9bW1uSpp54SEZFgMCiZv1R9+Wt/7a/JT//0T+/v2Z1kUCXPmmhufXWChImhewcdA12rqQHMnBGGmbFIHIu2VSowypNJnNsTT+DFFfjRURjUzKVhWJ8VDgeIFCU/aYwyiZIDlQi2o6zobuB2wyuwsgLDu1TCublce0uQrVZhpGezMMZZRG9xUb0OxSJWspgn5HCoohk9OZWKGuGcTLgvvx8TQKuFa7bZMNiTDFFRLRTCCtzMDFbc+vrg5QmHcY6UomaNpq0tzfPJ5zUfrdnEvk6fbq/xsLWlIQBuN1ZHu5GmVgvHWl/Xfslrt9u14CJlsO/exfk4nUrIGD43MYEY8XQax93YQL+6d0/rWVy+jMmUYYubmyoxX62ir5BUxmKoe7W5CY8gZeo/8pHdK1Tx2vhMMjx1p2K2uRzuLWVvDQwMDHoV0Wg7YQoG24nPdlEJgQDsCNobhM/X7t2fntYafY2GFmhneDRFjwIBzHMsjLtXT9/DSsGzrtTKioYI7ofoB8lXIHD4OXGGMHXH+Pi4rK6uyuTkpJw5c0Y++9nPyvPPPy9f//rXxXPYbsHjgmZTpaVJmKzfidzvRaJrmrG6B/2AVKv6cPv9WnSSeUMeDwYuVppOJjEwRKMYVKzJ5R4PQqOGhpQsUXabL+Z0dYKypOPjGHCbzd3H/lpBVZvVVVWnO326uyubrnm65+t1XCNV41gg9KmnkBh6/Tr2y+RQkfbQSYbjkTSsrYEk0BtEidlIBKtqLpcqKomoqMbgIDwbHOivXsXK2vXraF+q9lWrOMbgIIjO6CjajiGVIrhHt2+r1O3QEK6JIhnWPsm48AsX2olGo6EKPkyctRZiXVjQsL9AAGF1N2+inc6dQ1utrGC7XA7n0Wyq961QwPXxXj/5JPY1NobQxbk5LZLM0ESKdJw5A3J18yb2sbCAz8+dU+GNB6HRwDGYGxeLaYHInWAtVHvYE5mBgYHBYYJqqvm8LsANDakS69DQ9vO5daFxJ/T1Ya4ZHMT8yTpGjFygYMNOCrEHiZERzCGplC42PyooUX9Y12QF7SjaTodVE+qAsefZ/G/8jb8hr732mrzyyivyIz/yI/LJT35S/v2///eysLAgP/qjP3oQ53gyQW8NPUZWtTwRdDyrcUpJYus2BwkrYbLb8X8+j3P2eDRMi/G9+TyMZp5bIKDhXLwOv789ZngvoCLbw4ISosEgDPdiEWFuTAbN5/VVKm1fNycYBGnhIP7cczD833hDZaY9HvUC0XvI/eVyIAJPPAGSSQLDRM5aDWpur7+O75ivFAxi0I9GVUgjHBb57GdBCCIReGl4jdPTOC4L2wYCKqjAUD3WTbhyBe1jLTzHQnqsUVUqwTt07hzuRaWC/+k9GxnROhWnT0OkgTWyGMM9O4s2stuxz1YL7RgI4HooZx6LgWhUKjiu14vrmZjAd6+9hmOzALLH0y7J3teHNrhyBdusrOCzyUns984dtNfExM5hEXNzmHRJCHltO3mnEglVfjoo6WADAwOD44LOsLyhIYzXS0ta+Nxaa/Bh4PdraYmJCYy9o6Na3P1h7Y79xPQ0znM/CA6jM0SOBmHiQmu1intgCBPwz//5P//G39/93d8tk5OT8pWvfEXOnTsn3/Ed37GvJ3diwVAl5jBZDWp6mLoRJquH6aBRraqXpF7HuVYqOD7rDtHrRcPe48F1uN0IOWPe0enTGCiOAsJhxC7PzuK8WdugE7xHLJTqcMCw75aTcuYMtrl5E+TA68U760OQ6K2tabHewUGRb/omGOSzs/icpJSVva9dA7mangZ56RQPOHsWHqIbN7CPc+fQ5s8/r7WKNjfbz7dU0hyiRgP3tL8fxIeCEfQO3ryJv4NBlc1eWsI9XVnRgqSXLoHI0Iv1hS9gEuzrw/f37qnHjGSGhWYDAexvaAjXz/yr/n60Sa2G35w9i+t/912E6ZXL+A0JTyYDIlssqieTYX8XL+L8WPiYqn7ZLAjW0ND94RkLCyDB9Tr2G4+DsG7nMaLQB6XEBwZ2tzJqYGBgcNIRi7UTJtZpZFHxRyVMjBiwLvIODh6tRSuWXdkPUHzL5To6tpXHo4TpsHOqDgiPHC/y6quvyquvvrof59JbsMqKd3qXRO7PY3rchKlYVBLHaucMT7MSCXqfKIDA0D3KzTO/aXLy0TxEIqqix/OwKgtSFtTn09d2qxxuNxIyl5c1OZ8y1SQIVs9DoQADP53G36wPYQXlr1stGNuxGLYpFkEu3G6tGTUwgFUwKidFo/BmLC+jrbJZ9I2REfw2lcJKmcvVHupot4u89JImk+bzIFdU8XE4dDCl4ASLDIuAZK2tKYFi7aZiUQ1/kmKSZRHc3/5+fB4Oow35eustfH72LIhUuYxrYmHCyUmtQ8U6T5GI5jw5nWgHj0dzvCYnQZquX0cYIqVlfT6tX+Z2o53On0e/6O/Hfnn+Fy5gX5EIvqPnaGUF7WfNJ6T3jG3y1FM7r+LV6+gf9BaOjnZXNDIwMDDoRUQimBcLBQ3Li8cx/+Tzmr/7sOCcxnnqpCsRMhxvp1zaxw2PB3PqCc5jeijCdOfOHfnCF74gGxsb0uww7I20+C5BsiECg8+qGiZyf0gYQ/K4/UGjWNRcqVJJDVgq3VHG2RqC12jA+LbZMIBNTuLBzmRgHBcKIAoPoxRULsNTsV2oXKGghIQIhVSRrvOYNhs8BsPDKs7QDek0iAX7OdV93G4Y3j4fyEouhzbLZtEO9GKIoA1ZV+ncOeTg8HzoSXQ64U2JRhEytrEBI39kRBX+bt+Gt85qvPv9MOjffVfPha56epcYnkBiOTqqYQpvvgmSk0zi78lJDYkjidzYUI8iV/Aajf+/vTsPjuys7j5+bu8ttbYZaaTR7IvtYWwDDsbGmFTgxQVOUWFxcAJxwM4CMTEFGLMmBaSSEId9CzFLqgxFSEgIOIsTxzjYmPh9jW08NnidsT32aEazSBrtUu993z+Oj57bLbW2kdQt6fupUklqdbeu5vb0vb97nuc8ru13JqP7+IEH9N/KfueTT+r3PT16n0JBH2MLrzY16ZvrxIT+PBLRbc5kNHxt3Oi6AT70kF6NtHK/XcEKhfR3nzqlf49VqmIxN5a6q6v8ilcyqcFqaEiDU3Bts+Fhtyr75s1aBZxtHtLkpIalXM6tCVYPQyQAoF5Eo/p+PzbmqkzBFuOnTul752JZp718Xs9TFrNA92pST/OXzDpo/LDgwPTNb35T3vWud0l7e7t0dXWJFzgR9TyPwDRficT0LnlWLRGZucLkeStXYUqn9QQ3HNbfZythi+h/DBtSaPexMcR9ffrGt3WrW5Pm+HE92e3v1xPM+bYDD+rp0X+bVMpNprehciJ6kp3JuAn6mYy+OY+N6e/q6NCqROXvne1k+NQpHYImom9MXV0uMOVy5Y0Z7LnOPVf/HezE3xb2tbbXp07pz6wiNzLi9ufu3S7sHDyoAaSrSxe9s/WcfvlL/T22vsRFF2kAsyYLFg76+vR3HD2qt2/bpoGirU3DzPbt+riODn0tPvig267JSd1/9hro6nLB6JFHNLx1d+vvSKf1Z6WS6+K3YYOGu1zOhUurHvX36/4Ph12zi1BIt7GvT3/XyIhrsLFnjz5vX5/+jRs26N9t634995z+e9vfYXOIrFlIMukWl63U1qbPZWuEHDum97d5bfv2zf76SKd1P5VKrtEEw/AAYLq2Nj1uDQ669RA7O/X7oSE95pzJ3Jdkcn0EpmzWHWvrrcIkQmAK+su//Ev55Cc/KR/+8IeXY3vWD1u41oblBRs/iMwcmMLhlR2SVyy6RVCtlC7iutrZdthJ9okTbtFRe0MU0RNW65I2MaEnmXOdjAadPq1vtKGQnszO1NmusuuZtZgeGNA3UQtttiiuDeFLJFxbagv/lfNROjpcZcyaLwwP63ZZQ4bmZr2CZlXDgQFXWclm9d8jmXStvG34lohuT0eHC4L79+uaQbZg68mTGqZshfBYTE/07erSxRfr17t2uUB09tlakbPhYjZnyOYC9fVpgDz7bNecoqfH7c+xMf1cKOgQubExDSfHj+t9bD5VNquvA/t7bNHBkyd1W7q7XWe/sTH9d7Q1LKJRtzr61q06Z8uqU/397o23t1cD45Yt7v/MkSO6PSJ6/xe/WH/3k0+6VeBt4drZKpqhkO6TY8dc8Onunr1zkxkY0MekUvrvOt9W5QCw3rS16TFmclLf2+NxN4phfFzf86td3JoPG2FhaxOtVcF24vV0zLHzMjtPXIMWHJiGhobkyiuvXI5tWV9sHSaRmddgquUcJmsGUCi4tt+nT7vhWHZbOu0mHvb0uG5p27dPf86WFp3TcuiQmyNy9tlzjzUuFFyVZ/Pm+a9oHYu5uSS2arh1wKv2hmplfRF3n61by8OfiG7zhg2us91MbK2e555zayJ5nv4biLiKXVPT9PlQmzeLXHmlVltuv13D2S9+4SZUjo250HX77fpv0t3t/jYLe76vVY983gWmWEzfcPv69IR/9279ff/n/2j1ylrdl0pukdbhYd3+5ubyVuhbt+rnvj53xSub1efv6NAwtH+/vqnHYrovLSTbPKdEwlUGt2/X3xWPa8jq7XXznDo69MCaTrvmGtGovoauuELv39/vhtdZtWeu9uHWcENkegfE2dg6WSK6n+rpwAUA9caaBNmwPGuAsGmTC0xdXYuff2Tv22s9MNXjcDwRd26Wz6/ZeWQLDkxXXnml/OhHP5Jrr712ObZn/bBhSiLlrcTt62pzmKzRwXKyDnm+705ybZibnfzGYnpyG4m4+7a06ElyNfG4zuE5eFBP3g8f1hPb2a7k9/bq8yeT04PLfNgQsQ0b3LCyyg87ybZGEiKumnUm3XusuURfn6vSPPGEhptNm2b/u2MxDTEdHSL//d/679va6hownD6tw+MOHdJmCOef7ypFbW2uy19Xl1ZZQiHX9vPIEd2mzZv1uXbu1LBic7GSSQ2pzz6r9+/s1M57wflpDQ267ycntfITi+nnEyf033p42LUCHxjQv+kFL9A3+8FB3aZ4XP89fvlLN2TRDgLnnKP/Zk1Nbt/39OjfPDys1biLLhL5jd/Qn/u+Dne0Cud89tvp025xYAt/8zU25v5v1NOwCACoVxs2TA9Mra3u2DQ0tPjmUJWd8s6UdQee62JYOq1hr7V1+Y8FpZL++4nUX2Cyudi2buV81jpcZRYcmPbu3Ssf+9jH5Gc/+5mcf/75Eq0Yc/qe97xnyTZuTbP5NzYvydgJe7UK00qsw5TLlTeiiEbLA5OtwWQVMdumjo653zASCa0sHDqkJ89HjlRfI2F83J1sb9++uGYRQRb0KrfRgmGh4BartXbXS2HTJn1zO3JE3+yOHdMT9Z07Z39T8Txthb1zp2toUSjom7O1Q3/0UQ0QDz2kVa3ubv28d6+GGmvtfuGFGjZ++lPXxvvoUbcfg/uurU339c9/rtv63HO6nTY/6rzzdBsOHNCQFY2KvOxlbojijh16X2veUCrpczY360dnpware+5xVRpbB+qxxzQknTypB6B0WgPQY4/p/W3R21/7NZFXvtJddBge1jfpSET//rlks24IogXYhbDtbms789clAKwH1i0vOCzPhmEfO+aa/SyGHUvtGD7fIf++r8dJm3aQzbpzoHBYL3pW6+CXz2uTpnxej4m2BuPGjcsz6sDaicdi9RlI4nECU9A3vvENSaVScvfdd8vdd99d9jPP8whM82WT3UX0P4DnuZBitwWt5JA8qzBlsxocbBFa669vXeeC869CIf0PMp/Jlo2NOhTsmWf0JNuGzwX5vgYMETcca7nYPK1odPn+k8fj+sY7MKAHBls4t7t77rUZLGiYbdt0wdxsVuTee0Xuv9811BgYcK3frbV2oaDh56GH9IBk3Q0bGvTfONh9sadHg1A+7xomDA+L/N//q89nLb7Hx/W5s1ndPxZsIxHdt/ffX94UY/9+Ny+pp0erR9msBuh9+7Ta9fjjeuB66CH9+sIL9d/tRz/SqqQ1gXjjG/XvDzp5Uj93dMw9FMAW0bX5RwutXJZKbgX52YZlAgAcG5Y3OqoXnWz5hfZ2nR+bTuvxcevW6s+Ry+mFRxtJYUIhPV7YgueVQ90r2cXH4FDuSsWiTh/Yt2/6Iue+r6NkbHSETWU4elSPbxs36vHNLo5bBeZMGgPVYzvxoI0bdduW6mJznVlwYHr22WeXYzvWF/tPaJP3gi3FZwtMK9X0IZfTN4FMRl/8sZieIAeHIFklrFjU+7a3L2wSYkuLnnwfOaIn1rZoqQVJq2hFIjrUa61ob9e/vadHg0hvr1s/ab5XxEQ05Fm1LpXSg83p0xo2+vtFHn5YA08ioUHKKj0dHfp4a+Vta0cVChqOxsY0nCSTWsnZtUsrUw8+qPdpb9cwZGOUzztP97u1UG9s1CtuVj2Nx/Vr39dt6uvT+yWTGqysWvXss64jn/3bPPKI/p7jx/V19qIXifzxH08fbjc6qn+jLVY4lxMn9O+3NuALrRCNjLirfGt0gT4AWBZtbS4wWefacFjPB557To9V4fDMa9kNDurxoVjUi3RnnVUempLJ8sAU7D5sI2Js+ZPBQTf1IRrVi1/xuGtqFQ7rSJhMRi/unnNO+e86dkyPn1aFikZdh1wbpjeT5ma98LeYOT71On/J2PnFGnXGC9diEew/SnAtHhuaZ0Gpcg6TLey5UkPyxsfdejahkJ5g+r7rbGMdzGy7m5oWfvLY3u462J0+PfN9tm1bexPqo1F9wxwY0KtRIyNabdq9e34VuokJtzbS5s1usuyWLW5og1Urh4d1/+3YoS3PN2zQq2InT7qW3KOjuh/yed2WVErvd9llbs2mwUH9vTYsb3hYb8/nXaMGW7RYRB+XSul27N3rQpHv6+P27NGQ2N/vWs4PDWlg6+pynRnHx/W1df75Im95y8xzk6y61N4+d+gcH3eVr+3bp181nA8bjkd1CQAWprVVj1GZjA4p7+zU9/yNG/V4cfSonhPY0hMibvSDvfeK6Hv500/r8cXOqZJJt8D88ePuQmE1jY36ez1v5uH6Z52lx+bJyfI514OD7uJfKqXbsX27W0rF5mnZnPNiUb/O5fR4W7nd82Eddz1v7uoZlsWCA9P73//+GW/3PE8SiYTs3btX3vCGN8gGTiaq8zxXprWr+za8bbY5TCtVYcpm9T+7zT2xSoQ1ErBtFdHPnqchajErdW/erFWQdNqd5NsbTGPj2j4ptarcM8/ov/nBg7M3Hxgd1XBgkz5F9ADR3q6Bo6lJKzaPPqqhoLlZ92Njo8jLX+7C2AUXiPy//6f3P3hQ72PrMCUSuj/PP98FHpsb1d+vr8+zznLjzPv7NfiNjLjugdu362vhiSf073r0UT142c/jcd2+xx5zc7FaWvQgZwv8lkr6OyYn9QB7+eXTXwt2cB0b022ea2hdsehakc/V5bCaQsGFwrX82gSA5RCJaEWmp0ff80+c0GOIXZwrFvV4cfSoHjMSCdeAKJ93DYf6+/U48cwzrmKTTOq5Sm9v+cgUW47CpjbYVAMbAmjnW+eeWz5kLhYrn3N97Jgel2y6QDzujgfPPqtDz23Y4UyhZnxcR2CMjZVv93zYiKRUau1dRF4lFhyYHnroITlw4IAUi0U55/mOaIcOHZJwOCz79u2Tv/3bv5UbbrhB7rnnHtm/f/+Sb/CaEawyBYfhBTvmVd5/pSpMIyN6oup5erJsV/pDIf3PmsnoG1Mk4ipNyeTix622tZ1ZN7rVLJnU7nFHjmhwOXpUDyDWoCIW05A6NKT7RET3S2OjOzDs3asHnLEx3R/Dwy7AXHrp9DJ5MinyqldpwNi0SRfIHRpy467tqtrwsIafgQEdjhAO6wHruef0YDAx4Vq45vPu9TkyogcYG1Y5MOCCtQ3FKBbdgaqlRZ9vzx79/TY88PHH9Tlf9jKtkAWNjuq/ma35YJ36ZnP0qP77xGIzt76fj+Fh/VuSyTU5qRUAll1Dg84LsuNONqvv5729+p4/NKSjH555Rs8NbH7Qxo1uNEQopJWahgY9Hpx7rl5QtKAVjU7vmOr7bthcsFplF4GPH9eRHkGNjToa4vBhrSqdPu1GBdlyGqGQblNPz/THB6VSenx96ind5oWEJps3W6/D8daBBQcmqx7dfPPN0vx8+XJkZET+8A//UF7xilfIO97xDvmd3/kduf766+X2229f8g1eE+yk0042g9Wa4FjboGDTB5vztBzduaw9c7Go/7kTCX0TsTeGpibdfrsKY1eAwuEzm8y4noXD+iZr7cetY58FJBMKafjZtEkPBtae/eRJrXacPq0HEFsUubm5ehANhfRqWCKhFZwDB3QfNzbqdkxO6vNFo/p68H09wD38sL4e+vrc74lE3BpJjz+uB75CwXXGs2YabW3uQDM8rK+l4JW+REIDUDisB8HNmzXUBReFLZX038iGQ8TjejCbazhof78b9rlr1+Kv0DEcDwCWRlubW0j9xAk3wsZGtgwP6/GnpUWPB3asaWhw82Z7evQC39GjeuHM8/T+Z51VflErm9XzLltk3fP099hQbms6NDk5fbRMW5s+d2+vG15nLcfb2/W4/OST+vjBwdmPD5Whaa7lVXy/fLtt0XisuAUHps985jNyxx13TIUlEZGWlhb5sz/7M3nNa14j733ve+XjH/+4vOY1r1nSDV1TolH9D2pX5O0/X7DSVG0dJrtPsbiwJgHzlc/riaXv6xtBOKxvAum0ft3c7BYmsyF0zc3uig4Wb9Mm/Te3tqbW4tQCakdH+T7fsUMPFCMj5V0GW1s1jNjE2MoufL7vOtTZG3WppAeeeFwPDIcO6eNtuEQopEEomdTXQl+fXr1rbdXbrFlHT48bD24HvYEBPYD4vgtpNrwvGtXb7QBlFdRYTINNa6sLfbmcHmRsnY2ODh3CONfVufFxPZiK6P0X26jBujOJEJgAYCnYcOr2dvfe7vtu2N7YmB4bbZ0jOwZu3arhpqNDF3a3ERft7XrMyOVcYLL5wtasqLtbq1XB4+mGDRp2jh/Xi3SVurr0mHXypG5fJKLbZEuebN6sj+3p0WPMbCMeUin9HU8/rcdvqzRVhqZCQX82Pq4/27FjzXagWw0WfMY9MjIifX1904bb9ff3y+jzYyxbW1slZ0NlMDPrwhLs3CLiThhnqjAF/zMtV2AaGHDrLdmVjNFRvS0Wc+OHbRtsnhPVpaVh47DnM9wrmXRv0n19ehDI5TTwjIzoVan+fj0Y2WtnfFyDTyaj99+8WatbVpGyNZq6unRB2b4+vVq3YYP+PJXS/W1D50T0uU+c0AOSjfneskWrX7YQYSajjxsb0w8b4hmJuMckk67rYj6vX9uFGWvhmsloyNq5c36tVXM5PeD4vv4Ni1n82NiQiLkOhgCAhbE1HoPOPXf2x9jQPrvIJ6KhyTq17tunxyabZ5RK6bFjptDR3a3v8SMjenya6cJaR4dbwL2pqbzLaleXPnZiQo+9Z589+7Y3NWnYuuceNwc5GOKyWQ1Udj62e3f9thNfJxY1JO/3f//35XOf+5y89KUvFRGRBx54QD7wgQ/IG9/4RhERuf/+++XsuV4s650NYwu2ErdxtNWG5Iksf+OHkyf1uZua3NoCY2Puak0s5qpjVhlrauKqR610delVMeugY4sAt7XpHKFcTt/Em5r0QBJsdXr8uOtuuHOnXq3LZPQxF1+sb/y2vtKv/IoenPr73VAJWyzWhuw1NrpOQ1bB2rZNg0pXl+uEZwvcdnbq796zxx0kbL2KygB+/LhrBX7OOfN7vZVKGrIKBX3tVs6DWiiG4wFA/Wlq0mPU4KCGndFRPd4Zz9NQNdsFs3hcA8vAgD72+Tn6U9JpDWKFgh4LK+ceeZ4eR594Qs+Z+vpmX+Yik9Hj2oYNetw8dkw/rGFEX5/+ruAFRdTUggPT17/+dbn++uvlLW95ixSev8IciUTk6quvli984QsiIrJv3z75u7/7u6Xd0rXEQlHl+gCmWoXJPi9X44d8Xt8sbCK+TfIfGtLfGY26hdhs+6z5AxWm2rA36Sef1CBilSCb73TihBt3bYvztbfr90NDrrOPrYNx6JC+UW/cqN30Hn3UrYIeCukwiN5e3d+NjXpwsIV/u7q0YmVz8bJZ/T2jo67Dj62ttWGDbocNZ5iNdQcUWdiQBOvCFIksfN2LTKa8JWw+7xqhrNcGJQBQrzxPj1svfrF+b3OAGxr0GDmfwLF5sx5HLXRZRcdamBeLbv3DmebBJhJ6jOzp0fDT0DBzpWpy0oWvDRv0mGLNtmwUhohbD5HpDnVhwYEplUrJN7/5TfnCF74ghw8fFhGR3bt3SyrwonixvWAxs1JJr7bbCWVw4VoLUDOtw2STDJcrMJ0+rSeGkYielEYielXFhiLF47pt4bD7/fYmRIWpdhob9UpWX58OtzvnHL0q1dGhQcPGhScSGlBsftPkpL4Ge3p0aEFTkxvHbc9jQyJOnNA38UJBhzmMjenjXvpSPSjYmlqVHzZszyQS+pqZrX16UD6voU5E/575hpVTp8qbPCzk9dnb6wJapeAYegBAfUkmNaTY+n2RyPwbZMVielw6dUqPA83NOpLi2Wf13KdyRMRMOjr0MaOj2pipqUmDmLUZt5bixaIeO886S5/PhtTb6I1oVI/XtBCvG4s+8qdSKXnhC1+4lNuyftiQIxteZ0FJpPqQPJHyTnnLEZgGBvQEtbHRzS9Jp/XKh3UuK5X0dqsY2JsAFaba6u7WN9lcTrv97Nypc9A2bXLzmLq6yod27tqlb+iDg26e0tat7kpXsGFEc7NeYQsOSwiF9HE2B6qa4EUAC9zzOQj4vh6obEjd1q1zP2ZiQg90doVu69aFjfvOZPRgKeLmGdpHJHJmc6AAAMsrFis/T1podcaGj09OusXdReZ3rDO7dmmFaXDQVYwaG/U5TpzQY5stpRE8Flpgm8/FRKy4eQWmK664Qr71rW9Jc3OzXHHFFbPe94c//OGSbNia19DghtdVhqaZhuSJLG9gsjV8rOTs+/ofeWJCPzzPLWqaTOoV+FLJTdKkwlRbNrfn8GHdX888o2+6W7dWDxqNjeWdfRobXZe8nh69va1NDzg2udZCk8j8h9RZZXShbJHeUGjuA1U6rdtrrWY9Tw98Cw04vb362m9pmblTEgCgviWTbp3AhV7MtQtjJ064sGTHukJBj0lzrYUUiehFy+5uPY6dPu3OpUT0YuauXQsbJo6am1dgamlpEe/5k6IWFs1aGsmka+ccHI5XrUueiGstvhxD8qwZgK1vYF35xsf1TceCkrXltO1ranJX31FbsZiGpt5erZL09en+2727eqDt6tJq4fi4VnPOOcd1ApqY0Ktku3ZNf/5EYnmvgo2PawAS0XlL1Q561g7dDmwienDbvHnhnezGxvS173nzq2YBAOpPMDAtZs5pZ6db+qKrSy8iiugFw8lJPabO53ltkfTNm92it62t2gxpOdbRxLKa11nuzTffPOPXOAMNDdO75FkImmkOk8j0xWuXSqmkJ4rWHe/0aTdccHxch+nZMELrjmfr7iQSDMerJ3ay39SkwwkmJ7Uxw9atGiRmuv+uXbqORU+Pvgb27tU3+SeecIvw2YUSaw6xnIpFN29p48bqXelKJa2k2fDQtja9orfY1+OxY/q5vZ3XNACsVja32kZDLJS1JM/nXdOGiQnXSKKvb2FBLBrV0GXBC6vSgssC6XRafN+XhucXmjxy5Ijccsstsn//fharXYhk0lVxSqXyatNKV5gyGRfQolFXJraW4rbAqOdpJcnuawGKk8v609Ii8oIXaPCwtZcGB6d3mSsW9Ura+LgeBOwqWEuLHhwmJ3X/b9qkb/bVqjYTEzp/qqHhzIdn9vbqc8VieiVuJsGwFAppyLP5dItx+rT+reFw+SLAAIDV5UwDk4gex4LHMltiQ8SNvKHV97qyqHWYrrjiCrn22mtleHhYLrroIonFYjIwMCCf//zn5V3vetdybOfaE43qf8ZghSnYJW8l5zBZF7VQSOcxRaO6HZmMNgCweU22/pKtF2WNK5i/VJ9iMV08r69Ph7eNjWlDiO5uDUADA3p7oaCNEazSeOKE7tNEwrUetzbkmzbp8ILgnKTBQVcREtGfJZManuyzheu5jI664aE7d84898kWsV2qsFQquTU7Nm9meCkArGYWZLJZN43gTBSLbh2+RELPjfr7l3+0BerKgs8MDhw4MLXe0r/8y79IV1eXPPTQQ/KDH/xAPv7xjxOY5isadcHEwo+1YF7ppg92FSYc1m2IRPT5s1m3BlMk4obhWXCKxWZeZBT1w/N0PHZrq1aZxsZ06NmJE+41FI+7bnJPPKGVlnhcH2dz2gYGdKjaqVP6dWur65Z4/Li+HlIp13J+fFw/gqyleGOjPpeFoVzOrWZuwWvTpplDkO9rZWlkZGnCkoj+Tfm8/s0dHWf2XACA2opE9KNQ0GPL8yOiFm1oSM+7bGmOQ4d0VMKWLUvX9rtU0nOxdFqPwckkx6M6s+DANDk5KU3Pn6D86Ec/kiuuuEJCoZC87GUvkyNHjiz5Bq5JxaJeIbcTShviZiEpl5t5DpN1G7MFNZdKsMJk7aJFdJiVtWe2Vp02t8mqSqEQFabVIB7XatPAgAamYlEPKJs365uyTUDdvVtDUz6vt51zjh4c7KpaKKSPPX3aVaNENEC1tLhFbC1Yl0r6uGLRHQz6+7U1uS2wm83qcxw/rgEsldLnO3HCdZI0Y2NLV1kS0b/T1lzasoWuRQCwFiSTerxIp888MNmoh/Z2PebY8XBw8MxCTankjnvBqREmlWLYXx1ZcGDau3ev/Ou//qu86U1vkttvv12uv/56ERHp6+uT5oWsd7LeWZOFmapFxaIbnhfspLLcFSYLTJ6n/3lzOTfJ0fP0pDuZ1Nvjcbe+AYFp9Whv12AzOqqhpPLqWDKp84ZspfJUSoPWoUP681BIuwYNDWllxoLSpk36OioW9fVRqVjU15RVLfN5vb2pSZ+vVNJt8n1t9GCL983E83T9ijMNSyI6FM/a4y+mmxIAoP4EA9OZsLm8nqfHJhENSUeP6nD3xQamyqZFInqRsaFBj4/ptD7/jh1ntv1YMgsOTB//+Mfld37nd+T666+XV7/61XLJJZeIiFabLrjggiXfwDXJ8/Q/SaFQPl/J5gbZyaQt8mmWo+lDqeSu8HueC0w2ib9YdFfdrSSdz2vFyUITK1GvLtGoe+OfSUeHvj6Hh7US+oIXuNCUTmtQKhZ1yF5HR/k47nRaD1Lj465hiIgeCFIp/Whrcy1frVtkIqFdidradNvSaVf5FHEXDuygZet/nYnJSdeOvFpzCQDA6mOVGbsQt9g23tbsoa3NzW/duFEvtmUyepxb6MW7ynm4O3bosdGaKo2N6fF2cFBHPjCvti4seC+8+c1vlle84hVy4sQJedGLXjR1+6tf/Wp505vetKQbt2ZZtznrOGfhJxhMrPlDZWBa6gqThSULYhbisln9yOddo4fJSf1PXSjoCW8kQnVprdq5UxtEZLNaadqxozw0iUwPSyJ6kEom3RpNwYYmxvP0NZVOayVrfFxfU8mktjj3vLkXBlwK1kZ8w4alCWAAgPrQ2qrv8TYMfDHrBpZKrtlDcFmOcFhDU3+/fiwkMFlYmm0eblOTHg/TaQ1sXV0L33YsuUUN2O/q6pILLrhAQoHx/hdddJHs27dvyTZsTbN5HjakzcJP5eK1leNZlyMw2cmvVY6KRb3qYQEqlysPbo2N+kZkJ700fFibwmENTSJahbFmIGefrQGju3t+HYLsNRsOuw9730gmdY7Ujh36mtq9e+UW8xse1qt4nsfaGACw1kQi7r39+HE3cmchBgf1nCgenx5qbCje8PD8n9v3tbGRLZA+29Dyzk793N8/85x2rDhmONeKDWcLzlcy1VqLB4fkiSxNaLJhT1btyuf1RNKaO9hERM/TSfoWliwwUWFau5qaNCD7vhuWEIloFWjz5qX7Pe3teuBYqfDt+66NeGdn9bWlAACrV0eHHsOKRZ1ztFB23Jtp0fdkUkfcBI+Ps/F9XUx+aEjPn/bu1XOqamwIYC5XfT6viBv2jmVHYKqVYIXJKjnB0DRTa/HgGkh2nzNlgckqSDY8KhZzi5YWi27eSzLpfm8kQoVprbOraGvpKld/v77uIxGGOgDAWmYjIYaGyhssmMlJkUcfFfnFL1ygsa6uExN6zjVTYBKZ//HRwtLgoKsszdUkLRRyz9/XN/N9ent16Hxwvi+WDYGpVmwhWFMouEqODcmbKTCJuGFLSxGYgh3ySiUNTKWSBiSbLGkl6V273LA9G2pFhWltC17lGhmp9dacuWLRtULv7qZhCQCsZQ0Nbv5ST0/5edXp0yIHD+pc3UJBvz98WMPT00/rfWzNwZnY8TGfd8eVmRw54sLS7t3zn6NrS36Mj7uOxaa3V5fEyOenr3mIZUFgqpV43M3nKJXcGFgLQ9b4IWipA5Pvl3fIGxtzQwRt8TT7HcmkG4YViTAkb70IhdzVtWpXuVaTEydcg4lqVw0BAGtHd7deBM5mNWT4voan557Tc62WFpGzztIh2vG4G/UjMvtxwvPcKIUTJzRkVQ6RO3LEdWPdtUsD2HxFo265i+Dx99gxt37g9u0cy1YIvQprxbrkGRv6ZgGq2hwmkaULTDY/ya6yDwy47Roedq3Fw2F9U7D7BSfts9Dn2tfRoW/OY2P6mlmtwzCzWXfQ2bp15RpMAABqJxzWpSMOH9Zj2ciIq9h0d7uLwc3NemzIZFwXu7mGznV26vP39OhjnnhCg1EqpbfZ/KZduxa31t+mTVqdGhzUbTt5Upf2ENGwdCYL52JBCEy1YusXWUCyIXlmJYbk2bjXRELfPIaHNSxZy+fJSd2GeFw7mWUyWt627TjT1bOxOsRielVseFjHaq/WNYuOHtX/Y83Ncx8EAQBrR1ubvu+Pjuq5TTisIWam4XGJxMIuDLa3a3OJw4f1POnQIW2aZHOmdu7U7rKL0dioHxMTOnzQztsISyuO8kCtWCUnFHLd6WoZmGwx0lTKDc2zBhCVrcTt99vCcFj77I359Onpr8vVwK4qep5epQMArC/bt+vF6sZGXZB9Kdf7SyZ18fUNG/RczsLSjh2zLxQ/HzYHi7BUUwSmWgmH9T/uTIHJ2oov9xwma/iQTOpQJQtMdgXGnr+lxbVBb2py/2lZ7HP9aG7W10Cx6MZjrxbDw66N+LZtBH0AWI/icZHzz9dgsxzzr61qtWOHXojesWNp5he1tbnlL3bsICzVCEPyaiW4iGexOD0wzafCdKZX+i345POuS4zn6byldFpvC4X06ogtXNrc7IIWQ/LWl02bdFhbf//qecNOp3WhQBHd/tWy3QCApbcSc1fb25e2EYPn6SLvhQLnXTVEhalWgkPyRDS0lEqurfhsTR/MmVSYfN8FJpsI39SkExQ9T9ciyOX0Kkx7u3uTSaWoMK1XGze6+W1jY7XemrkVCtq1qFRyk3kBAFhtYjHCUo0RmGolFCofkmcBKbgo7VyB6UwqTNmsC01jYxqIUintxFIo6JC8bFaH46VSGu6CC+16HkOb1ptw2E1ctfbc1fi+Dt07dao2C976vsgzz7jQv2sXXfEAAMCiMCSvVqJRt56RiAYkWwPJhuTNNofJQtZiWZVoZERPKFtaNCzZwrX2ubVVK0nRqF6ln5jQxyUStBRfjzZt0iA0Niby2GPakjVYgRRxc4bsNZbJ6Ljr5VAqaXiz32XbYYv5hcMie/dWX3gQAABgDpxF1Eo4rCdxNo/JQpIFpdmG5Fkr8jMZkpdO6wml/c72dh2+lMvp7RMTum1tbRqWLDBZ55fVuhYPzkwyqQv8HT2qr6GeHp3TtHWrvi6PHXOhOhLRKpSt77Vly9JuS6mkVSR7Tc5k925eqwAA4IwQmGrFmj4EGzhYCPI8PdGsDEx23+AwvsXKZPREt6lJQ1Emo0Ep2PAhmdR5KzbfqqnJLZjGWNr1q6lJW7IODIgcP66vl6eecj8PhXQxv85OnQt35Ii29Y5E9LalEAxLoZBWuuyCglVpUynm2QEAgDNGYKoVCyEWmoJVJc9zlZ9KodDSVJhOntSQ1Nmpw+6eeEJDUjarFYJCQYNUIqHBqalJq0w22Z/5S+ub52nHubY2HRLX36+3t7frquk23629XV+nx47pRzh85t2DfF8XCLSwdNZZGo4AAACWAYGpVoIVJqscFQquoUKpNPOk+mBgWmyFqVTSk1cRXZcml9MT3kJBqwVDQ7oNGzdqMEok9OuxMTf8qbl5cb8ba0skoq8hqxzZWhFBnZ362jp5UqtNkYiG9MWwZg4jI/r/YO9ewhIAAFhWzNqvFWspbmHJ911gskA0W2A6kyF5J05oJSka1bkn6bRO1C8UdLL88LDeb9s2bQYRCml3tKNHtVrQ1sZQJ5SLxWYOS2bLFldZOnxY5z5Zo4b5sspSMCw1NS1+mwEAAOaBClOt2JC8YIXJ2opbhSmXm/44C1nVhuzNxfdFnntOv+7u1m2w+UsTE/p1JqNBaedODUY2p8oWrG1v1+oYsBDbt+trdmhIK5r9/fo66+ycX/A5dkzDvOeJ7NlDWAIAACuCwFQLvq/rHOVy5RPVrdGDVZCqVZjCYbfQ7UJNTLh2y93d+nts3tLYmE7kL5VcYBoc1BPTkyf18VYlIDBhoTxPu9aNjeliycPDWi0aGdEmIjt2VG8mMjDgFljevZshoQAAYMUwJK8WSiWdyzE4WB6OrLuXDcnL56c/1ipMVo1a6KKg1tghkdDqUT6vV/ytM97p0/o7zjlH12cS0W0rFPQxNveEdW2wWE1NWiE691xtHBEK6QWEQ4dcU5GgiQkdwieiIX+x858AAAAWgcBUC6HQ9DlMJp/X6k21LnjBOUwiCx+Wl8loZSsW0wBkc5ZGR/WjUNCgdP75+ty5nPsd7e1ujR0qTDhTiYQO0zv/fA1RxaK2Jx8acvfJ57XJg+9rUNq8uWabCwAA1icCUy14XvnCtSJueJ0Nw5ut6UMwZC10WF4mo5UkC0zj4/oxOOjmh2zcqA0f8nm9vbFRf8/x43qbLWILLIVIRFuDt7W5xg59fa4jXj6v3Rp37qz1lgIAgHWIwFQr1lbc5jBZ84dCwVWYqg3Js/uLLLzCNDqqJ6LxuH709+twvJER/RyP61X8DRs0QOXzOkzP5le1tIjs38+QPCwtzxPZtUuH6IloR8YnntCKZjisQ/ioagIAgBogMNWKDcmzk0DrjlcouIVsZwtMZiEVJms2IaJr13ieBiYLRrmcXsnv6NAhUseO6fCoZFKD1Nat2sqZsITl4Hk6RG/LFv3eujLu3u3m0wEAAKwwznxrxYbjhcPlaypZYJptDpNIeSvy+crl3PPbcLzJSbdobbGoXco2b9avjx3T77ds0SYQrL2EldDVpcM+jx/Xrxn+CQAAaojAVCs2HC8cdhUlz9NKTzAw2e2mssK0kCF5mYw+byymv3dgwA25y+X0JLWhQecvPfOMhqjmZpGXvpSqElbWxo36AQAAUGMMyasVqzAF12Gy9uLBwFRZQTqTClM26wKT5+lwu4EBHfqUyeiwp9ZWnXxvi9vu2kVYAgAAwLrFmXCtRCIaWqJRF5YsMFnbcKswBZ1phalY1MA0Pq6/69Qpvd339fbOTv3ZxIQO29u27cz/VgAAAGCVIjDVig3Fi8XKbw+2FbePoDNp+hAckjc66oKSTa6PxUQ2bdLFQycmdN0lFgkFAADAOkZgqpVoVMNPNOrmMFWuxTTTkDwbireYIXlWYYrHNTCNjLjbPU8751kgy+d1/hKBCQAAAOsYc5hqJRRyTR9sOJ59nc262yqH3C12SJ6t61QqaUVpaEiHBRYKGphCIQ1H6bSrQsViuh4TAAAAsE4RmGrFwlI0qt/7vt7meRqY7DarNgUfFzTfClMm4x7f369D7kKh8vlLNjywVNIqVFOTds0DAAAA1ikCU63YGky2cG2p5L7OZPRrqwoFLbbCZIGpVBLp69Pnb23V8OR5GpBKJfd1KKTVpWBLcwAAAGCdITDVig3Js255VmES0WFxkYjelstNf1zQfCtMVrXK5VwL8VhMw5N164tG9XZrRsH8JQAAAKxzBKZaCc5hsnWXrJ14LqdfF4vVK0wLbfpgFSYb4tfQINLbKzI5WV7tam/XhhAEJgAAAIDAVDPhsFaRbN6S75d3y7MgtFRNHyoDUyikgSmX06pSJKIVpmRSK1yxmC5gCwAAAKxjBKZasQqTfYiUz2MqFGavMJmFVpgsYOXzIoOD+ngLS4mE3p7PizQ2aptxAAAAYB0jMNVKcDieDa/L5dzcpVJJP882JG+mtuMzsXbiIu7+IyM6HM/EYlpdsqDW3KyVJwAAAGAdIzDVis0ZsuAk4tY/sqA0W5e8ysVuZ2PVpUhEn8/3RQYG9PZYTJ8jGtWq0uSkfp1K6f0BAACAdYzAVCs2FC+4/lKhoGGlVNIqT6lUfR0mazu+kMAUjWq3vMlJnaeUy+kwPBuW19joQhQNHwAAAAACU80EK0sWgiww2YK1My1ca/cPVph8f/bfZS3Fo1ENSaOjWmmKRt3vjkR0CF42S2ACAAAAnkdgqhXrkud5rtJULLphcNZevFpgsgqTyNxVJqswiejzDQ/r89twvFBIvy4W9aOxUaSpaUn+TAAAAGA1IzDVig3Js8Ak4obnWTOIbHb6HCZ7rFWYRBYWmNJp/T4UchWlSEQDUz6vgampSYfqAQAAAOvcqghMzz33nPzBH/yB7Nq1S5LJpOzZs0c+8YlPSC6Xq/WmnZloVIOPDc2zDnYWmHK56oFJxHXXm61Tnu+7IXki+nWh4Lrx5fMalqzCFApphYnABAAAAMiqaIP25JNPSqlUkq9//euyd+9eefTRR+Ud73iHTExMyGc/+9lab97iRSJuaJ6IBhYLUBZ0ZgpDlYFptgqThaVwWJ8rndbvYzFdhymf14548bg2g4jHtb14LLY0fyMAAACwiq2KwHT55ZfL5ZdfPvX97t275eDBg3LTTTet/sAUHF5n4chuq1ZhsqBkZqsw2XC8eFxkYkIDVDis1a3JSX1sMqnbksno+kstLdN/BwAAALAOrYrANJORkRHZsGHDrPfJZrOSDQxHGx0dXe7NWhibrxRch8nzNLwUChqYikUNU8EAE6oYSTlbhckCUyKhay/lcq6CZQvXNjS44XkNDRqaAAAAAKyOOUyVnn76afnKV74if/RHfzTr/W688UZpaWmZ+ti2bdsKbeE8RaPlgalQKJ/TVCrNPCzPApN9nm9gmpzUwGTtxdNp/X3JpFv7qaWF+UsAAADA82oamD7ykY+I53mzfjz55JNlj+nt7ZXLL79crrzySnnHO94x6/N/9KMflZGRkamPo0ePLuefs3DhsOuWJ+IqTMHQZJ3rgiorTLMNybMKWzyuASmf1wpWOu2aP8Tj7venUgQmAAAA4Hk1HZJ3ww03yDXXXDPrfXbv3j319fHjx+VVr3qVvPzlL5dvfOMbcz5/PB6XuIWBemSByZo+FApuTSabx2TBJvh3LKTpQ2WFyYbdjY25+UvBeVSJBIEJAAAAeF5NA1NHR4d0dHTM6769vb3yqle9Sl7ykpfIzTffLKHKKstqFI2WB6Z8Xr8vFFyFKZOZXkEKLm4rUr3CVCi4hW9tGF4+r19PTOjPGho0LFlL8USiPJwBAAAA69iqaPrQ29srr3zlK2XHjh3y2c9+Vvr7+6d+1tXVVcMtO0O23lJwDpO1/7aqz0xzmIJtyCOR6hUmG44Xi5U3kfA8rTYVCjoEzypVkYgGKNseAAAAYJ1bFYHpjjvukKefflqefvpp2bp1a9nPfKuyrEY2JC8a1e99Xz9KJVd9ymRclchUVpjmE5jyef3e913lyfc1IEWjrvKUTC793wkAAACsUqtiXNs111wjvu/P+LGqRaOujbiICz6lkoYcz9NgY+2/TeX9ZxuSZ78nl3OBKdBqXWIxDWbFon7N/CUAAABgyqoITGuWDckLNl2w1uIWpEolkfHx8sfNt8JkgSkS0cBkwSuT0ee3KpbNB4vHCUwAAABAAIGpliq75JVKLvx4nlZ8fL96YJpvhSkS0aqSBaVs1j2/bUehQIUJAAAAqEBgqiUbkmdVJqsw+b6GmFhs7gqTzXmaSTAwZTLaojx4u3XDC4XcMEACEwAAADCFwFRLkYgbEmdD8qy1uHXA831tAV75OBF3v/kEpmCFyffdnKVIxK3/lEi4qhMAAAAAAlNN2Rwm+xDRuUYWhOJxDUOTk26+krGwVSjMb0heOq0f9twWmKJR99yNjcvzdwIAAACrFIGplmxIns1lssqP57nW4iIafIKd7URcYJpPhcnztHKVy7lFakslDWSxmAtcBCYAAACgDIGpliwoBecw2aK1VvWxIXM2/8gEA1O1CpPdbkP9ikX3OwoFXYMpkXDBKpVanr8TAAAAWKUITLUUnL8UDuttwc53oZDrYJfJlD/WWoJXqzAFO+6VSi4wFQr6nL7vKkw2h4lFawEAAIAyBKZaCofLGzhYlzzrWmeVp1Jp9gqTyPTQFByOVyxq4LLgZOEsFNLQRGACAAAAZkRgqiWrMFnzBxHXKlzEVZ6qdcqzpg8i04flVS5am8tpYMpmXVDzPB2SZ9UsAhMAAABQJlLrDVjXgmHJApOFFxG3NpLva6e8oMrFa6tVmCwwpdNu/lJw+J+t9RQK0fQBAAAAqECFqdZsLlIkosHFhsdVhhvrcmeCi9eKzB6Y8nkXuCyQRaNu2J+I/h4qTAAAAEAZAlOtWWtxW1C2UCivNnmehh6bh2QqA9NcQ/LS6fL7WMtyG/IXieh8JgAAAABTCEy1Fg679uIirgJkazGJuOpTsPHDQipMuZxWmCwwWQgLh93jYjH3nAAAAABEhMBUexZcLDAVChqCSiVXYbLhczNVmIJtyIMsMFknvfFxV73yfQ1I0ahbEJfABAAAAExDYKo1qzBVVoysHbi1Fq82JM/uV63CZLdbW3HrzBeJaGDKZFy3PJsvBQAAAEBECEy1FwxLnqcNGqy1uO+71uKVFSYLPtUWr7XAZAHM5jBZQ4lwWENSOk1LcQAAAKAKAlOtRSJuTSWbt1QsaqixYXoWigoFF4TssfazakPyLDBNTOhzWwOJaFRDUi5HS3EAAACgCgJTrQXnL9lCtBZ2govZ2nC5ymF5c1WYLEhNTurzJBJaxfI87YpnP29oWPq/DQAAAFjlCEy1Zk0fLDgVChpoggoF1wY8GJhsDadCYfYKUz6vzR1KJReSIhENT7buE0PyAAAAgGkITLUWDrt5SqGQhhoLTDZMzwKOyPwqTDakT8TNfQo+pw3NIzABAAAAsyIw1ZqFnmBgstbiwUVpZxuSVyiUB6bKluKDg+657PdYZcsaQSQSy/+3AgAAAKsMganWIhGtItmHDa+z9ZLmW2EKDsmrXLR2cFC/t7lS1kbcfh8VJgAAAGBGBKZas8Bk4Sc4lC64KK0FJpuLZI+daUhesMJUKIgMDen30ahrIBGJ6NeFgn5P0wcAAABgGgJTrdkQOZuvJOLai1t4siqQDcvLZvXzXIHJjIy43yWiwckqWDYkjwoTAAAAMA2BqdaswmSByT5ns+Whxve1w52IG5Znj63skmeBqVTS58lmXWXJKko2f8nWe6LCBAAAAExDYKq1YNMHkfIheTZ/KTgET0QknXbfW/CpVmFKp3UeU3C9J1ssN5fT76NRmj4AAAAAMyAw1Zq1FbfqUrBTnojrmCcyfS0mqzAF72+PEdGfBQOT/Swa1e+t1Xg06sIYAAAAgCmcJddasEueiPscrDDNFpgsCAUXuw2Gp8lJDU3B+9mCt1Zhisdd9QkAAADAFM6Sa83Ci81dCs5bCgYm33eByeYk2eNFNAgF122yz7mcftjvKBb1MbGYmyeVTLpABQAAAGAKganWgkPygmsxBVuKW4iy+5ZKrjoUi7n7WVCyCtPYmAtcwTAWiWhoyuXcmkxUmAAAAIBpOEuutWDTB5vHFOx4Z1/bukzWnMGG5VmL8GDjB+ua19fn2oaLuLBlc5ZyOf0ci1FhAgAAAGZAYKq14Bwm+whWiuxrG6Y3U2CqXIupUHBhyfM0EAXXdrLAZGHK2pUDAAAAKENgqjXPcy2/reGDsWF2wbWWKgOTVajs58WiyMSEyPCwhqO2Ntdpz4bkWUXJFsQlMAEAAAAzIjDVWijkut2Fw67BQzjs5imJuDBULTBZhSmfFzl5UsNRa2v5ED/7nEi4EMaitQAAAEBVBKZaC3bICwamUGh657v5VJiOH9fud/G4yMaNer/gorY2RM+eMxxm0VoAAACgCgJTrXmeCz22aK01acjn3deVgalQ0I9ghSmdFjl2TH++ZYtbuNb3XWjyPA1TwQpTMrmyfzMAAACwShCYas0649mwvFKpfJFZm9eUz7smDVYhsgVpLfwcPar3a2jQuUu+rwvXBitM4bD+Lt8nMAEAAABziNR6AyBu/pJVk6xBg62TJKKhx+YgJZP6s0OHdMjd4cP6ubVV79/V5R43Oel+j63BFIm4tZqYwwQAAABURYWpHlh1KfJ8frV5TMGhdLmcC0wtLe6xFrSsZXh7uw65s/CVzbp5UPm8a0Oezbr5TFaxAgAAAFCGClM9sLBkQ/FscVkLTSIacCwwdXSIbNjgAlV/v8jgoMjZZ2sYGhjQ+/m+Dtuzr20NpljMNY2IxVy4AgAAAFCGM+V6YI0brMJkzRyCFSabw2QsZMViWlGydZVsqJ0tgJvPu0YSpZKrKNlwP3ssAAAAgGkITPXAhtVFo/p9sejCk8lm3c8q2ZC6fL48MBUK+jirIJVKrstePq+fk0kqTAAAAEAVnCnXAwtM1vEu2E7cutnZIrYzBSYLWrlceWAKfi+igSke16/td0SjVJgAAACAKpjDVA9sSF406ipDnuc63dkaTPZ1JQtBwa56vq/VJXuu4BwmW7cpHNbqFIEJAAAAmBGBqR5YW3ELMzZczoJOsegqRbMNyctmXfjxPNcoIthFz+Ys5fMuMDEkDwAAAJgRZ8r1IBJxC9h6noYba/YQDEz2dSULTNb5TkSfJ5NxlaRi0VWY7Ht7LBUmAAAAYEYEpnpgLcWt850FI2v8YGsmBddiCqoMTBaIMhnXIc8eZxUm39fbqTABAAAAVXGmXA+s2YPI9NbixaILPcG1mIKs6YOtuWSPszlMwSF5iYRrV+77VJgAAACAWRCY6oFVmDxPw4+tnxSLueF5swUma/pgrceDgcmG4tlzxGL6vQ0BpEseAAAAUBWBqR5YW3ERDTAWcKJRN3dptsAUbPrg+y4w2ZA839efW2AqFPR2mj4AAAAAs+JMuR5YW3H72tZesmqTVYeqzWEKthUvlfQ5Mhn3vXXYi0T0Oa0LXyxW/rsBAAAAlOFMuR7YkDwRtxZTPu8Ckw2hm20Okz3GKke5nH5v4cs65EUi5UP3bP4TAAAAgGkITPXAqjzWlMHCTzisAcgaQlQLTMHH2+K1mYxr+GCPSSTc89j8JRvOBwAAAGAaAlM9CLYTtzWZ8nn9OjgHKZ93w+sqBZtFBNdgikTcYywwWahKJBiOBwAAAMwiUusNgGhoseASj2uYKRZdO3D7vlSaucIkUh6YRFyFydZksrlN1hAiHKZDHgAAADAHAlM9CIWmz2EKVovCYdfZrlpgshbkwQqTreUUXHPJQpgFJipMAAAAQFUEpnrgeW7B2njchZp8Xr/2PA0/xWL1IXmxWHnIsvlOFsQsJIm4NuUsWgsAAADMivJCPbAKk1WTrHOdBZ5w2HXAs853laySFBySZ40jbF0nC2O+79ZgIjABAAAAVRGY6oHNYbLgZJ3tbC0m33ftxat1yrPgYxWobNY1jrCAFaw2eR6L1gIAAABz4Gy5HlhlKRRyjRl8363FZHOXgt3vKlnwKZX0I5t17cPt/la5suF5VJgAAACAWTGHqR7YPCWrMllgyuV0GF2h4H6ey80dmLJZfYytw2QL3wafywITFSYAAACgKs6W60EwKNlnEa0wJRKuLbjI3IHJ90XGxvT+Fpo8Tz+s9bgFpkiEChMAAAAwCwJTPbDqkVWWYjG9PZt1Q/KsUlRtDpPn6edSSWRiwnXYy+Xc3ChbxNaCkn0AAAAAmBGBqR5YhcnCkQUmqwaZUql6hcnmJxUKIuPjer9w2K3BZHOjKgMTQ/IAAACAqjhbrgeVgSkS0aBkbcFtSN1sgcmG8ZVKLjBFIq67nlWZrKW4fU+FCQAAAKiKwFQPbEieBaZo1C1eay3BPU/Dz1yByeYwZbNuMVt7TnuO4HA8KkwAAABAVZwt14NghalYdNUfa/Qgot/PFpjseTxPZHRUJJ12Q/tsmJ+FMOYwAQAAAPNCYKoXwcBkXeyKRfd9KKRD9HI5tzhtUHAonw3Ji8XcUD6b42SL2VqYIjABAAAAVRGY6kUkoqHG9/WzVZiC6yZZm/BcbvrjCwUXgsbHXYc9ERemrGIVDEwMyQMAAACq4my5XtgwOc9zlSHfLx+iZ1WmbHb64y0wWYWpUHDVI2tLLuKePx7X76kwAQAAAFVFar0BeJ7NYxJxDRpEXDXJ5hsVCrrOUlCh4NZvyuVEMhkNWsEueRa4rMW4/Y5g23IAAAAAZagw1QsLMOGwqxSJaACyYGOBKZ0uf6zNaWpo0LBkjwmy76NRtyYT1SUAAABgVgSmemHhxSpJNscoOPzOFp6tDEz5vH5OJl1gMjakzzrkhcMuMDF/CQAAAJgVZ8z1wgKTBRn7vnJIXrE485A8EZHGRg1Yk5MauIJNI2ydJhuaZ40lAAAAAFRFYKoX1tHOPluL8HzedcyzClM26xa0FXEVplRKK0yZjAamcFgDVyik39tjbA4TgQkAAACYFYGpXliHPAtM8bgGHRtSF5zDlM2WL14brDDlcjpkzwJXLqePi0b1fjZ3KRplSB4AAAAwB86Y64U1drDFay1AlUrl7cVFdMhdMDBZhcmG5OVyGozyef2whW9taF6wwQQAAACAqghM9cLmLYXDbvFaW4tJxLUJD4WmB6bKLnn5vAtewUYPnqf3sflMVJgAAACAWXHGXC9CofJW37FYeaDJ5dxtts6SsQpTIqH3s6qUiH5tlaVIpPx5qTABAAAAsyIw1QsLNcH1kmxIXrHoqkaep8Pugu3GrcJkc54sJAWbPNhnW4dJhMAEAAAAzIHAVC+swhScyxQKudCTzbrbcjmtMhkLTPm83t9Cls1dEnGBLFhhYkgeAAAAMCvOmOtFMDCJuGqS57mqkTVuCFaYLByJuHbj1o7c1mAyle3EqTABAAAAsyIw1QurKtlQOmsAIaLfWxCKRMoXr7XqkgUpqyzZML5gEKsMTFSYAAAAgFlxxlwvKofkWZMGEQ1FpZJbvNb3RUZH9WfW8CEaFRkb0/vYY9Jp133PnoumDwAAAMC8EZjqRTAwBatJNrzO9/VzIqH3t8BkFaZIRGR8vLzhg81zsudJJPT3EJgAAACAeSEw1YvgkLxQSINPcIie7+v6Sw0Nev+REf1sgSkadbdZELL247GY/jyR0M9WhWJIHgAAADArzpjrhVV+gmsx2SK29nliQiSZ1J+NjelnG5IXiYgMD2tACoc1FKXT+riGBpF4XMNSLOaaRFBhAgAAAGZFYKoXwWFykYgLT1Zd8n0NQFZhssAUHJI3MuICViajYcrz9DHWUjwWo8IEAAAAzBNnzPUiGJjCYf0+Fiu/Tzbr5jBVVphENFAVixqObP5SLOZCmC1aa2s7UWECAAAAZkVgqhe2XpIFJs/TYXTWNa9U0mqSdbubnNTPVmEqlfS2YIXJGj2IuAqTPV6EChMAAAAwB86Y60WwwmRfW2CyOUeFglaJRLTalMu5ClOh4EKUiLs9HtfPVmGy57ZFcAEAAABURWCqF5VD8kTccDobQlcsugpSqaTD8qzClM3qh1WkrDV5KKRByYbjBRtKAAAAAJgVgaleBIfkWfUnGHBENDBlMq5xw+ioC0wTE27eklWkLFzFYq7SZOGrcn4UAAAAgGkITPWissLk+65bnn1dLOqwu0RCA1N/vwtAQ0NugVurLIm4uVC2aK2FKQtQAAAAAKoiMNWLmYbk2fc2rK5Y1E54thbTiRP6uVAQGR/XnxeLGpLCYf06FNK24rYGUzarjyEwAQAAAHMiMNWL4JA8++x5GnRKJf26UNDAtHGj3qe3V2/L5XR4XrHo7hsK6e3RqEhTk4alaJTABAAAACwAgaleBIfQxWJuHpMNv7Ohd5OTIhs2aPgZHtaheNmsVpiyWdcNT0QDUyQi0tpKhQkAAABYhFUXmLLZrLz4xS8Wz/Pk4YcfrvXmLJ1gi28LPOGwCzalUnnTh5YWDT8nTmi3vIkJDVPRqEhjo34dCunjGxtdhSmX0+cjMAEAAABzWnWB6UMf+pB0d3fXejOWR3D9Jfu+oUGrS76vgckqRO3tWmF6/HFt/jA+rk0fPE+kudndb9Mmvd1CmD1v8HsAAAAAM4rUegMW4rbbbpMf/ehH8oMf/EBuu+22Oe+fzWYla8FBREZHR5dz885cKKSVJAtMNjzPPvu+qzC1tWkoGhnR2ywshUI6jM/WbLJwaWsziVBdAgAAAOZp1VSYTp06Je94xzvkO9/5jjQ0NMzrMTfeeKO0tLRMfWzbtm2Zt/IMVS4ma+3Ebf5RqaQhqblZZM8eka4uDUiDg/o5HNb753JuiF9rq6tcEZgAAACABVkVgcn3fbnmmmvk2muvlQsvvHDej/voRz8qIyMjUx9Hjx5dxq1cAi0t+tnmGVnjB+uYZ53y8nltLb51q1ufqb1dPxoatJOePc73tRolQmACAAAAFqimgekjH/mIeJ4368eTTz4pX/nKV2RsbEw++tGPLuj54/G4NDc3l33UNQs2mYyGm1DINWzIZLTCVChok4dUynW9y+X0Nqu8jYzofZuadHheQ4OGp3xef05gAgAAAOalpnOYbrjhBrnmmmtmvc/u3bvlzjvvlHvvvVfiFSf6F154oVx11VXy7W9/exm3cgWlUm6tpFxOQ05jo5uTlM9riBod1TA0MeGG4Z0+rbf5voancFgrVhbCaCkOAAAALFhNA1NHR4d0dHTMeb8vf/nL8pd/+ZdT3x8/flxe+9rXyj/90z/JxRdfvJybuPJaW7WalMlogPJ9XXdpeFhDUy6nFaTGRh16VyxqABof18/Fovu6s1PDlIgGprEx/ZrABAAAAMzLquiSt3379rLvU6mUiIjs2bNHtm7dWotNWj5tbdom3Jo75PNaKUqntbqUTmuTh3hcQ5WIVpMKBa08jY1pyGpo0KYQvu/mP5VKruMeAAAAgDmtiqYP60oqpVUhz3MhKRbT4XbJpA7DGx8XGRpyQSkScd3y7DGdnXr/YrH8+a1NOQAAAIA5rYoKU6WdO3eKbx3f1hrP02F58biGn6YmN+yusVErTiMjIseO6f1tDpOIW+C2oUGH8TU0uEBVKul9GI4HAAAAzBsVpnrU1qaVoPFx12o8k3ENHIaGRHp7NQzF4zqvKRJxLcabm/WjocFVmGgpDgAAACwYgakeWTvwUskFIREdYhcK6bC8Eyc0RNl8pGRSP+Jx/WxD+KyyRIUJAAAAWDACUz3yPF2EVkQbOXR0uGF1yaTrlDcxoQEqHNaAZUP5GhrK25GLUGECAAAAFoHAVK+s3frgoEh3t67PJKIVpUJBZGDAzVmKRNwcp+ZmV2GKRvW+0aiGLBECEwAAALAABKZ61d7uht+Fw9rEwfP0Ns/ThWqtO56IBiMLRxaabE6TddMToaU4AAAAsAAEpnrV0KChJ5/X6tCmTS4c2edoVO/neRqIJiddC/LGRm1R3tysYUtEA1Q4XJu/BwAAAFiFCEz1KpHQ0FMsapUpldLbEgld1HZyUtuO20K02awOz4vF9HENDRqONm/Wx4gwHA8AAABYIAJTvYpENCT5vlaP8nkdpmeBaXRUP4pFbTNuYclCVWOjPk+hoPcXITABAAAAC7QqF65dF6yRQzKpoadY1KF1yaSGo/FxncfU0KBD9KJRkS1bNBwlkxqYLGwRmAAAAIBFocJUr8JhDU3NzTqHKZt134dCWnHyPA1Kra3aSa+z01WaUil9nmKRwAQAAAAsEoGpXlnVKB7XYBSPa0hqbHTBp7FR248nk676ZE0dLDBRYQIAAAAWjSF59cwCTiqllaLxca0ytbfrIraRiEhPjwallhadu5RKacCywOT7rMEEAAAALBKBqZ5ZwLEudzYUz8JRJKId9JJJncu0ZYvIyZNu/lMopMHKHmuL3wIAAACYF4bk1TMLStmsrsPU2KitxO1n3d265tKmTSLbt2sVqqFBA1PlmktUlwAAAIAFIzDVMwtMmYzOVWps1ApTPu8CUCymlaWXvlRk7169j4WlSKCASGACAAAAFozAVM8s5ORyGoBiMZ3HNDHh5iZFoyJdXRqOrPqUTOpnAhMAAABwRghM9cw65JVKIk8/rbeFw1phikY1PDU2amASKR+uJ0JgAgAAAM4Qgame2VykYlFkbExbh9u8pZERva2xUddfEpkemJjDBAAAAJwRAlM9C4e1klQsauB5wQtE9u3TqtPp01p5SqU0SInoXCcRKkwAAADAEqGteD0Lh7V6FIloWAqHRbZt089DQyLNzSKbN7tgZIGpoUE/2+2ep/OfAAAAACwIFaZ6Fg5rtaitzQ2v27hRh+Tl8yKFgq7JJKJNIKpVmGIxDU0AAAAAFoTAVM8sJBWL7ra2NpHWVq082bpMo6MangoFvY91ybPPqdSKbTIAAACwljAkr55ZhciCkIhWlIpFrTJt2KDh6ZlntBlEsaiPiUb1vg0NIi98YflcJgAAAADzRoWpns1UYZqc1GYPvq9haMMG/f7YMQ1WwcAkol8zHA8AAABYFAJTPasMTPm8BqNUSqtHu3frR3OzBiirMFFRAgAAAJYEZ9b1LLiOUqEgcviwVpPOPlvbhJ9zjkgoJLJnj8gTT+j9olECEwAAALBEOLOuZ6GQDqfzfZGjR0XGxzVEnX12+TC7UEhk506Rvj6d48QQPAAAAGBJMCSv3lm1aHBQP2/f7rrfBZtBFIs6NM9aigMAAAA4YwSmehccltferk0eZmoGYeGJ4XgAAADAkuHsut5ZOEomRbZt068tFA0NiYyMaOe8dFpvC3bIAwAAAHBGCEz1rqND5yTt2KFzlURciLJheiYc1goUAAAAgCVBYKp3GzfqR+Vt6bRWkxoa3Ec8XpttBAAAANYoAtNq1Nwssn9/rbcCAAAAWPNo+gAAAAAAVRCYAAAAAKAKAhMAAAAAVEFgAgAAAIAqCEwAAAAAUAWBCQAAAACqIDABAAAAQBUEJgAAAACogsAEAAAAAFUQmAAAAACgCgITAAAAAFRBYAIAAACAKghMAAAAAFAFgQkAAAAAqiAwAQAAAEAVBCYAAAAAqILABAAAAABVEJgAAAAAoAoCEwAAAABUQWACAAAAgCoITAAAAABQRaTWG7CSfN8XEZHR0dEabwkAAACAWrJMYBmhmnUVmMbGxkREZNu2bTXeEgAAAAD1YGxsTFpaWqr+3PPnilRrSKlUkuPHj0tTU5N4nlfTbRkdHZVt27bJ0aNHpbm5uabbgnLsm/rFvqlf7Jv6xH6pX+yb+sW+qV9LvW9835exsTHp7u6WUKj6TKV1VWEKhUKydevWWm9GmebmZv4z1in2Tf1i39Qv9k19Yr/UL/ZN/WLf1K+l3DezVZYMTR8AAAAAoAoCEwAAAABUQWCqkXg8Lp/4xCckHo/XelNQgX1Tv9g39Yt9U5/YL/WLfVO/2Df1q1b7Zl01fQAAAACAhaDCBAAAAABVEJgAAAAAoAoCEwAAAABUQWACAAAAgCoITDXy1a9+VXbu3CmJREIuvvhiuf/++2u9SevKjTfeKC996UulqalJNm3aJG984xvl4MGDZffJZDJy3XXXycaNGyWVSslv/uZvyqlTp2q0xevXX//1X4vnefK+971v6jb2Te309vbK7/7u78rGjRslmUzK+eefLz//+c+nfu77vnz84x+XzZs3SzKZlMsuu0yeeuqpGm7x+lAsFuVjH/uY7Nq1S5LJpOzZs0f+4i/+QoJ9ndg3K+OnP/2p/MZv/IZ0d3eL53nyr//6r2U/n89+GBwclKuuukqam5ultbVV/uAP/kDGx8dX8K9Ym2bbN/l8Xj784Q/L+eefL42NjdLd3S1vf/vb5fjx42XPwb5ZenP9nwm69tprxfM8+eIXv1h2+3LvFwJTDfzTP/2TvP/975dPfOITcuDAAXnRi14kr33ta6Wvr6/Wm7Zu3H333XLdddfJz372M7njjjskn8/La17zGpmYmJi6z/XXXy//8R//Id///vfl7rvvluPHj8sVV1xRw61efx544AH5+te/Li984QvLbmff1MbQ0JBceumlEo1G5bbbbpPHH39cPve5z0lbW9vUfT796U/Ll7/8Zfna174m9913nzQ2NsprX/tayWQyNdzyte9Tn/qU3HTTTfI3f/M38sQTT8inPvUp+fSnPy1f+cpXpu7DvlkZExMT8qIXvUi++tWvzvjz+eyHq666Sh577DG544475NZbb5Wf/vSn8s53vnOl/oQ1a7Z9Mzk5KQcOHJCPfexjcuDAAfnhD38oBw8elNe//vVl92PfLL25/s+YW265RX72s59Jd3f3tJ8t+37xseIuuugi/7rrrpv6vlgs+t3d3f6NN95Yw61a3/r6+nwR8e+++27f931/eHjYj0aj/ve///2p+zzxxBO+iPj33ntvrTZzXRkbG/PPOuss/4477vB/7dd+zX/ve9/r+z77ppY+/OEP+694xSuq/rxUKvldXV3+Zz7zmanbhoeH/Xg87v/jP/7jSmziuvW6173O//3f//2y26644gr/qquu8n2ffVMrIuLfcsstU9/PZz88/vjjvoj4DzzwwNR9brvtNt/zPL+3t3fFtn2tq9w3M7n//vt9EfGPHDni+z77ZiVU2y/Hjh3zt2zZ4j/66KP+jh07/C984QtTP1uJ/UKFaYXlcjl58MEH5bLLLpu6LRQKyWWXXSb33ntvDbdsfRsZGRERkQ0bNoiIyIMPPij5fL5sP+3bt0+2b9/Ofloh1113nbzuda8r2wci7Jta+vd//3e58MIL5corr5RNmzbJBRdcIN/85jenfv7ss8/KyZMny/ZNS0uLXHzxxeybZfbyl79cfvzjH8uhQ4dEROQXv/iF3HPPPfLrv/7rIsK+qRfz2Q/33nuvtLa2yoUXXjh1n8suu0xCoZDcd999K77N69nIyIh4nietra0iwr6plVKpJG9729vkgx/8oJx77rnTfr4S+yWyJM+CeRsYGJBisSidnZ1lt3d2dsqTTz5Zo61a30qlkrzvfe+TSy+9VM477zwRETl58qTEYrGpN0nT2dkpJ0+erMFWri/f+9735MCBA/LAAw9M+xn7pnYOHz4sN910k7z//e+XP/mTP5EHHnhA3vOe90gsFpOrr7566t9/pvc39s3y+shHPiKjo6Oyb98+CYfDUiwW5ZOf/KRcddVVIiLsmzoxn/1w8uRJ2bRpU9nPI5GIbNiwgX21gjKZjHz4wx+Wt771rdLc3Cwi7Jta+dSnPiWRSETe8573zPjzldgvBCase9ddd508+uijcs8999R6UyAiR48elfe+971yxx13SCKRqPXmIKBUKsmFF14of/VXfyUiIhdccIE8+uij8rWvfU2uvvrqGm/d+vbP//zP8t3vflf+4R/+Qc4991x5+OGH5X3ve590d3ezb4AFyufz8lu/9Vvi+77cdNNNtd6cde3BBx+UL33pS3LgwAHxPK9m28GQvBXW3t4u4XB4WkevU6dOSVdXV422av1697vfLbfeeqvcddddsnXr1qnbu7q6JJfLyfDwcNn92U/L78EHH5S+vj75lV/5FYlEIhKJROTuu++WL3/5yxKJRKSzs5N9UyObN2+W/fv3l932ghe8QHp6ekREpv79eX9beR/84AflIx/5iLzlLW+R888/X972trfJ9ddfLzfeeKOIsG/qxXz2Q1dX17QmUIVCQQYHB9lXK8DC0pEjR+SOO+6Yqi6JsG9q4X//93+lr69Ptm/fPnVOcOTIEbnhhhtk586dIrIy+4XAtMJisZi85CUvkR//+MdTt5VKJfnxj38sl1xySQ23bH3xfV/e/e53yy233CJ33nmn7Nq1q+znL3nJSyQajZbtp4MHD0pPTw/7aZm9+tWvlkceeUQefvjhqY8LL7xQrrrqqqmv2Te1cemll05rv3/o0CHZsWOHiIjs2rVLurq6yvbN6Oio3HfffeybZTY5OSmhUPkhPRwOS6lUEhH2Tb2Yz3645JJLZHh4WB588MGp+9x5551SKpXk4osvXvFtXk8sLD311FPyP//zP7Jx48ayn7NvVt7b3vY2+eUvf1l2TtDd3S0f/OAH5fbbbxeRFdovS9I6Agvyve99z4/H4/63vvUt//HHH/ff+c53+q2trf7JkydrvWnrxrve9S6/paXF/8lPfuKfOHFi6mNycnLqPtdee62/fft2/8477/R//vOf+5dccol/ySWX1HCr169glzzfZ9/Uyv333+9HIhH/k5/8pP/UU0/53/3ud/2Ghgb/7//+76fu89d//dd+a2ur/2//9m/+L3/5S/8Nb3iDv2vXLj+dTtdwy9e+q6++2t+yZYt/6623+s8++6z/wx/+0G9vb/c/9KEPTd2HfbMyxsbG/Iceesh/6KGHfBHxP//5z/sPPfTQVKe1+eyHyy+/3L/gggv8++67z7/nnnv8s846y3/rW99aqz9pzZht3+RyOf/1r3+9v3XrVv/hhx8uOzfIZrNTz8G+WXpz/Z+pVNklz/eXf78QmGrkK1/5ir99+3Y/Fov5F110kf+zn/2s1pu0rojIjB8333zz1H3S6bT/x3/8x35bW5vf0NDgv+lNb/JPnDhRu41exyoDE/umdv7jP/7DP++88/x4PO7v27fP/8Y3vlH281Kp5H/sYx/zOzs7/Xg87r/61a/2Dx48WKOtXT9GR0f99773vf727dv9RCLh79692//TP/3TshM99s3KuOuuu2Y8vlx99dW+789vP5w+fdp/61vf6qdSKb+5udn/vd/7PX9sbKwGf83aMtu+efbZZ6ueG9x1111Tz8G+WXpz/Z+pNFNgWu794vl+YBlwAAAAAMAU5jABAAAAQBUEJgAAAACogsAEAAAAAFUQmAAAAACgCgITAAAAAFRBYAIAAACAKghMAAAAAFAFgQkAAAAAqiAwAQDWjJ/85CfieZ4MDw/XelMAAGuE5/u+X+uNAABgMV75ylfKi1/8YvniF78oIiK5XE4GBwels7NTPM+r7cYBANaESK03AACApRKLxaSrq6vWmwEAWEMYkgcAWJWuueYaufvuu+VLX/qSeJ4nnufJt771rbIhed/61rektbVVbr31VjnnnHOkoaFB3vzmN8vk5KR8+9vflp07d0pbW5u85z3vkWKxOPXc2WxWPvCBD8iWLVuksbFRLr74YvnJT35Smz8UAFBTVJgAAKvSl770JTl06JCcd9558ud//uciIvLYY49Nu9/k5KR8+ctflu9973syNjYmV1xxhbzpTW+S1tZW+a//+i85fPiw/OZv/qZceuml8tu//dsiIvLud79bHn/8cfne974n3d3dcsstt8jll18ujzzyiJx11lkr+ncCAGqLwAQAWJVaWlokFotJQ0PD1DC8J598ctr98vm83HTTTbJnzx4REXnzm98s3/nOd+TUqVOSSqVk//798qpXvUruuusu+e3f/m3p6emRm2++WXp6eqS7u1tERD7wgQ/If//3f8vNN98sf/VXf7VyfyQAoOYITACANa2hoWEqLImIdHZ2ys6dOyWVSpXd1tfXJyIijzzyiBSLRTn77LPLniebzcrGjRtXZqMBAHWDwAQAWNOi0WjZ957nzXhbqVQSEZHx8XEJh8Py4IMPSjgcLrtfMGQBANYHAhMAYNWKxWJlzRqWwgUXXCDFYlH6+vrkV3/1V5f0uQEAqw9d8gAAq9bOnTvlvvvuk+eee04GBgamqkRn4uyzz5arrrpK3v72t8sPf/hDefbZZ+X++++XG2+8Uf7zP/9zCbYaALCaEJgAAKvWBz7wAQmHw7J//37p6OiQnp6eJXnem2++Wd7+9rfLDTfcIOecc4688Y1vlAceeEC2b9++JM8PAFg9PN/3/VpvBAAAAADUIypMAAAAAFAFgQkAAAAAqiAwAQAAAEAVBCYAAAAAqILABAAAAABVEJgAAAAAoAoCEwAAAABUQWACAAAAgCoITAAAAABQBYEJAAAAAKogMAEAAABAFf8fpQMti2hK9RYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x1500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "target_data_map: dict[int, list] = defaultdict(list)\n",
    "for data in dataset:\n",
    "    target_data_map[data['target']].append(data['signal'])\n",
    "\n",
    "# Based on this distinction of normal(0) and abnormal(1) we can now plot some \n",
    "# example signals for both labels to see if there is any distinguishable visual \n",
    "# difference between them.\n",
    "\n",
    "fig, (ax_normal, ax_abnormal) = plt.subplots(\n",
    "    ncols=1,\n",
    "    nrows=2,\n",
    "    figsize=(10, 15)\n",
    ")\n",
    "\n",
    "num_samples = 20\n",
    "for i in range(num_samples):\n",
    "    ax_normal.plot(target_data_map[0][i], color='blue', alpha=0.2)\n",
    "    ax_abnormal.plot(target_data_map[1][i], color='red', alpha=0.2)\n",
    "\n",
    "ax_normal.set_title('Normal ECG Signals')\n",
    "ax_normal.set_xlabel('time')\n",
    "ax_normal.set_ylabel('signal value')\n",
    "\n",
    "ax_abnormal.set_title('Abnormal ECG Signals')\n",
    "ax_abnormal.set_xlabel('time')\n",
    "ax_abnormal.set_ylabel('signal value')\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd55b3d1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8fbb2c66983693ad5ddcc4d41c7debd9",
     "grade": false,
     "grade_id": "cell-e4d7a0799a45b49a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "As we can see in these plots, the normal and abnormal ECG signals show quite a distinctive visual difference! While the normal signals are relatively constant in the middle section, while the abnormal signals show an local minimum and maximum in the middle.\n",
    "\n",
    "This obvious visual difference already indicates that the RNN model will likely also be able to achieve good prediction performance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a7a4423",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7a3e01d4109aa997eeb9c74f9bb531f3",
     "grade": false,
     "grade_id": "cell-d86c85952da88a32",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**PyTorch Sequential Data Handling.** One can imagine that working with sequences of different lengths also introduces challenges on a technical level. Deep Learning frameworks such as PyTorch handle data in the form of *tensors*. During the training of the model, each individual element can be considered and various elements can be combined into a *batch* tensor of higher-dimension to increase the computational efficiency of the training process, as it allows the model to train with multiple samples at the same time. This batching of multiple elements is relatively easy with static data types such as tabular data or image data. In the case of image data, for example, every image can be represented as a matrix of same dimensions and multiple images can easily be combined by stacking them in a third dimension. However, for sequential data - where elements can have different dimensions - the batching process isn't as easy. Trying to stack sequences of different lengths is like trying to construct a matrix with columns vectors of different lengths - which is simply not possible according to the definition of a matrix.\n",
    " \n",
    "One possible solution to the problem of sequence batching is to simply not use batching. If the model is trained by only every seeing a single input sequence at a time, the issue of different sequence lengths never arises. While this is certainly possible, it greatly decreases the computational efficiency of the training process and might have a negative impact on model performance as well.\n",
    "\n",
    "Contrary to just using single sequences, pytorch offers the option to use batching for sequential data by using *paddding*. In any given batch of sequences, all sequences are artificially extended to the length of the longest sequence by appending arbitrary elements to the end (usually zeros). Additionally, for every element in the batch we store the information about the length of the original sequence. The combination of this information - padded sequence tensor and sequence lengths - is then given to the model to perform the predictions and subsequent model updates.\n",
    "\n",
    "<img src=\"https://juditacs.github.io/assets/padded_sequence.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fd54143",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "294e4904b245b0eceb696fb03d91cc2c",
     "grade": false,
     "grade_id": "task-9-6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 9.6 (2 points)** The goal of this task is to implement the ``batch_sequences`` function, which accepts a list ``seq_list`` of sequential dataset elements and returns a tuple ``(batch_tensor, lengths)``, where ``batch_tensor`` is a ``torch.Tensor`` instance which contains all of these sequences at the same time and which can be used later on to train the RNN models in a batched manner. ``lengths`` is supposed to be a list containing the integer length values of the input sequences.\n",
    "\n",
    "For this task we assume that there are ``num_sequences`` sequences given in the input list. Each element of that list is itself a list. These lists are the actual sequential dataset elements and may have different lengths, but we assume that there exists one list which is the longest with a lenght of ``max_length``. Each element of these lists is again a vector (list) with the number of ``num_dimensions``. The function should return a float pytorch tensor object with the shape:\n",
    "\n",
    "``(num_sequences, max_length, num_dimensions)``\n",
    "\n",
    "To do this, the function should perform *zero-padding* for the sequences of different lengths. \n",
    "\n",
    "The following example illustrates the expected behavior of the batching process:\n",
    "\n",
    "```python\n",
    "# input:\n",
    "seq_list = [\n",
    "    [[1, 1], [2, 2], [3, 3]],\n",
    "    [[4, 4]],\n",
    "]\n",
    "\n",
    "# output:\n",
    "batch_tensor = torch.Tensor([\n",
    "    [[1.0, 1.0], [2.0, 2.0], [3.0, 3.0]],\n",
    "    [[4.0, 4.0], [0.0, 0.0], [0.0, 0.0]],\n",
    "]) # shape: (2, 3, 2)\n",
    "lenghts = [\n",
    "    3,\n",
    "    1,\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "0fa7592e",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "86f4b21c05bc7089aac031791ab3e300",
     "grade": false,
     "grade_id": "ans-9-6",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.utils.rnn as rnn\n",
    "\n",
    "# TASK: Implement the batch_sequences function which turns the raw list of sequences \n",
    "#       into a single batched torch tensor.\n",
    "\n",
    "# HINT: torch may already provide a suitable utility function that solves the \n",
    "#       majority of this task for you.\n",
    "\n",
    "# HINT: Make sure that the tensor has the data type torch.float32!\n",
    "\n",
    "def batch_sequences(seq_list: list[list]) -> tuple[torch.Tensor, list[int]]:\n",
    "    \"\"\"\n",
    "    Given a list of vector sequences ``seq_list`` this function performs zero padding \n",
    "    and stacking of the sequences to return a single batched torch tensor with the \n",
    "    shape (num_sequences, max_length, num_dimensions)\n",
    "    \"\"\"\n",
    "\n",
    "    num_dimensions = len(np.array(seq_list[0]).shape)\n",
    "    ll = [len(t) for t in seq_list]\n",
    "    max_length = max(ll)\n",
    "    \n",
    "    padded = [torch.nn.functional.pad(torch.Tensor(t), (0,0)*(num_dimensions-1)+(0, max_length-len(t))) for t in seq_list]\n",
    "    return torch.stack(padded, dim=0), ll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "99e3067e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ceefaa5671bac5f067e5fdfb7a8e95b0",
     "grade": true,
     "grade_id": "test-9-6-batch-sequences",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-6-batch-sequences - possible points: 2\n",
    "\n",
    "seq_list_1 = [\n",
    "    [[1.0], [2.0], [3.0]],\n",
    "    [[1.0], [1.0]],\n",
    "    [[3.0], [9.0], [8.0], [3.5]]\n",
    "]\n",
    "batch_1, lengths_1 = batch_sequences(seq_list_1)\n",
    "assert isinstance(batch_1, torch.Tensor)\n",
    "assert batch_1.shape == (3, 4, 1)\n",
    "assert tuple(lengths_1) == (3, 2, 4)\n",
    "\n",
    "seq_list_2 = [\n",
    "    [[1.0, 1.0], [2.0, 2.0]],\n",
    "    [[1.0, 0.0]],\n",
    "    [[1.0, 1.0], [2.0, 1.0], [2.0, 0.0]],\n",
    "    [[2.0, 2.0]],\n",
    "]\n",
    "batch_2, lengths_2 = batch_sequences(seq_list_2)\n",
    "assert isinstance(batch_2, torch.Tensor)\n",
    "assert batch_2.shape == (4, 3, 2)\n",
    "assert tuple(lengths_2) == (2, 1, 3, 1)\n",
    "\n",
    "# NOTE: The hidden tests will construct some randomly generated test cases, where \n",
    "#       the different input sequences are randomly generated and the derived batch \n",
    "#       tensors are checked for their shape.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1428d23",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f4ff6dd8a6b44e6b96fedcbc045e32c0",
     "grade": false,
     "grade_id": "cell-cc478e50b1997ad0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**PyTorch Recurrent Neural Networks.** In the previous sections, we've worked with custom implementations of the ``GRU`` and ``LSTM`` recurrent neural network cells. However, deep learning frameworks usually provide default implementations for well-known architectures like this. In Pytorch, these default implementations can easily be accessed via the ``torch.nn.GRU`` and ``torch.nn.LSTM`` classes.\n",
    "\n",
    "From a technical perspective, the only peculiarity when working with recurrent cells like these is how to properly handle the padded input batches. As previously discussed, the input to the model's forward pass is the padded batch of sequences ``x`` and the list of original sequence ``lengths``. However, the actual recurrent layers expect the data in the *\"packed\"* format. The pytorch utility function ``pack_padded_sequence`` can be used to convert the padded format into the packed format."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0ad4412",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0016c2c9637b9a83c48115bbbed43bf3",
     "grade": false,
     "grade_id": "task-9-7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 9.7 (5 points)** In this section, your task is to complete the implementations of the ``GruModel`` and ``LstmModel`` classes. Specifically, you'll have to implement the models constructor in the ``__init__`` method and the model forward pass in the ``forward`` method.\n",
    "\n",
    "Each model should perform a binary classification for *each sequence* in the given batch of input data. This means for each sequence in the input batch the model should return one float value in the range $[0, 1]$ where 0 represents the \"normal\" class and 1 represents the \"abnormal\" class, such that a [binary cross entropy loss](https://towardsdatascience.com/understanding-binary-cross-entropy-log-loss-a-visual-explanation-a3ac6025181a) can be used to train the model.\n",
    "\n",
    "To achieve this you'll have to extend the given model classes with additional transformation layers to achieve the desired output state such that the forward method outputs a tensor of the shape ``(batch_size, 1)`` where all values are in the range $[0, 1]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "528707cf",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9d13f04f6eaf53f08da7b86563b2f2bd",
     "grade": false,
     "grade_id": "ans-9-7",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "class GruModel(nn.Module):\n",
    "    \"\"\"\n",
    "    Implementation for a model that performs time-series classification based \n",
    "    on the *gated recurrent unit (GRU)* cell architecture.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,\n",
    "                 input_dim: int,\n",
    "                 hidden_dim: int,\n",
    "                 ):\n",
    "        nn.Module.__init__(self)\n",
    "        self.input_dim = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        \n",
    "        self.lay_gru = nn.GRU(input_dim, hidden_dim, batch_first=True)\n",
    "        \n",
    "        self.lay_output = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x: torch.Tensor, lengths: list[int]) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Receives the padded input tensor ``x`` of shape (batch_size, max_length, input_dim) and the \n",
    "        list ``lengths`` of the batch sequence lengths as input and returns a prediction output \n",
    "        tensor of the shape (batch_size, 1) which consits of the sigmoid activated classification \n",
    "        predictions for each sequence in the batch.\n",
    "        \"\"\"\n",
    "        packed_input = rnn.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False)\n",
    "        packed_output, hidden = self.lay_gru(packed_input)\n",
    "        \n",
    "        res = torch.sigmoid(self.lay_output(hidden[0])).reshape((-1,1))\n",
    "        \n",
    "        return res\n",
    "    \n",
    "    \n",
    "class LstmModel(nn.Module):\n",
    "    \"\"\"\n",
    "    Implementation of a model that performs time-series classification based \n",
    "    on the *long-short term memory* cell architecture.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self,\n",
    "                 input_dim: int,\n",
    "                 hidden_dim: int,\n",
    "                 ):\n",
    "        nn.Module.__init__(self)\n",
    "        self.input_dim = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        \n",
    "        self.lay_gru = nn.LSTM(input_dim, hidden_dim, batch_first=True)\n",
    "        self.lay_output = nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    \n",
    "    def forward(self, x: torch.Tensor, lengths: list[int]) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Receives the padded input tensor ``x`` of shape (batch_size, max_length, input_dim) and the \n",
    "        list ``lengths`` of the batch sequence lengths as input and returns a prediction output \n",
    "        tensor of the shape (batch_size, 1) which consits of the sigmoid activated classification \n",
    "        predictions for each sequence in the batch.\n",
    "        \"\"\"\n",
    "        packed_input = rnn.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False)\n",
    "        packed_output, hidden = self.lay_gru(packed_input)\n",
    "        \n",
    "        res = torch.sigmoid(self.lay_output(hidden[0])).reshape((-1,1))\n",
    "        \n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "0c7e1a55",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c75e7c22e19e5b371083f643863f0032",
     "grade": true,
     "grade_id": "test-9-7-gru-model",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-7-gru-model - possible points: 1\n",
    "\n",
    "input_dim = 3\n",
    "hidden_dim = 64\n",
    "model_gru = GruModel(input_dim, hidden_dim)\n",
    "\n",
    "# At first we check if there even are any GRU modules used in the model\n",
    "assert any([isinstance(child, nn.GRU) for child in model_gru.children()]), (\n",
    "    'The GruModel class likely does not implement torch GRU layer'\n",
    ")\n",
    "# Then we make sure that the hidden size for those GRU modules has been \n",
    "# set correctely.\n",
    "for child in model_gru.children():\n",
    "    if isinstance(child, nn.GRU):\n",
    "        assert child.hidden_size == hidden_dim, 'GRU layer hidden size incorrect'\n",
    "\n",
    "# The general idea of the functional tests here is that we create random input \n",
    "# vectors, perform a model forward pass and see if the model output has the correct \n",
    "# shape, is sigmoid activated and whether or not it is possible to compute a \n",
    "# proper backward pass / gradient calculation for the given model implementation.\n",
    "for _ in range(3):\n",
    "    \n",
    "    batch_size = np.random.randint(2, 10)\n",
    "    max_length = np.random.randint(10, 20)\n",
    "    \n",
    "    x = torch.tensor(\n",
    "        np.random.rand(batch_size, max_length, input_dim),\n",
    "        dtype=torch.float32,\n",
    "        requires_grad=True,\n",
    "    )\n",
    "    lengths = [random.randint(2, max_length) for _ in range(batch_size)]\n",
    "    \n",
    "    # Forward pass\n",
    "    out_pred = model_gru(x, lengths)\n",
    "    assert isinstance(out_pred, torch.Tensor), 'model output is not a torch Tensor'\n",
    "    assert out_pred.shape == (batch_size, 1), 'model output shape incorrect'\n",
    "    \n",
    "    # Output activation\n",
    "    array_pred = out_pred.detach().numpy()\n",
    "    for value in array_pred:\n",
    "        assert 0 <= value <= 1, 'model output likely not sigmoid activated'\n",
    "    \n",
    "    # Backward pass\n",
    "    torch.mean(out_pred).backward()\n",
    "    assert x.grad is not None, 'model backward gradient calculation not working'\n",
    "    \n",
    "# NOTE: The hidden tests perform the same kind of tests but for a larger number of \n",
    "#       randomly generated input tensors.\n",
    "    \n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "ab67225e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "69452715eda2013116c76eafebbc31fe",
     "grade": true,
     "grade_id": "test-9-7-lstm-model",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-7-lstm-model - possible points: 2\n",
    "\n",
    "input_dim = 3\n",
    "hidden_dim = 64\n",
    "model_lstm = LstmModel(input_dim, hidden_dim)\n",
    "\n",
    "# At first we check if there even are any LSTM modules used in the model\n",
    "assert any([isinstance(child, nn.LSTM) for child in model_lstm.children()]), (\n",
    "    'The LstmModel class likely does not implement torch LSTM layer'\n",
    ")\n",
    "# Then we make sure that the hidden size for those LSTM modules has been \n",
    "# set correctely.\n",
    "for child in model_lstm.children():\n",
    "    if isinstance(child, nn.LSTM):\n",
    "        assert child.hidden_size == hidden_dim, 'LSTM layer hidden size incorrect'\n",
    "\n",
    "# The general idea of the functional tests here is that we create random input \n",
    "# vectors, perform a model forward pass and see if the model output has the correct \n",
    "# shape, is sigmoid activated and whether or not it is possible to compute a \n",
    "# proper backward pass / gradient calculation for the given model implementation.\n",
    "for _ in range(3):\n",
    "    \n",
    "    batch_size = np.random.randint(2, 10)\n",
    "    max_length = np.random.randint(10, 20)\n",
    "    \n",
    "    x = torch.tensor(\n",
    "        np.random.rand(batch_size, max_length, input_dim),\n",
    "        dtype=torch.float32,\n",
    "        requires_grad=True,\n",
    "    )\n",
    "    lengths = [random.randint(2, max_length) for _ in range(batch_size)]\n",
    "    \n",
    "    # Forward pass\n",
    "    out_pred = model_lstm(x, lengths)\n",
    "    assert isinstance(out_pred, torch.Tensor), 'model output is not a torch Tensor'\n",
    "    assert out_pred.shape == (batch_size, 1), 'model output shape incorrect'\n",
    "    \n",
    "    # Output activation\n",
    "    array_pred = out_pred.detach().numpy()\n",
    "    for value in array_pred:\n",
    "        assert 0 <= value <= 1, 'model output likely not sigmoid activated'\n",
    "    \n",
    "    # Backward pass\n",
    "    torch.mean(out_pred).backward()\n",
    "    assert x.grad is not None, 'model backward gradient calculation not working'\n",
    "    \n",
    "# NOTE: The hidden tests perform the same kind of tests but for a larger number of \n",
    "#       randomly generated input tensors.\n",
    "    \n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "9568a5dc",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9c07de66bb17f41fea0aee7a200164f7",
     "grade": false,
     "grade_id": "cell-3e2d2365bcbe693b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "def train_model(model: nn.Module,\n",
    "                dataset: list[dict],\n",
    "                epochs: int = 5,\n",
    "                batch_size: int = 64,\n",
    "                learning_rate: float = 1e-3,\n",
    "                ) -> list[float]:\n",
    "    \"\"\"\n",
    "    Trains the given ``model`` using the given ``dataset`` of sequential data. The model \n",
    "    will be trained for the given number of ``epochs`` using the given ``batch_size`` \n",
    "    and ``learning_rate``.\n",
    "    \n",
    "    The dataset should be a list containing dictionary objects where each dict represents \n",
    "    one element of the dataset. Each dict should have the following keys:\n",
    "    - signal: A list representation of the ECG signal\n",
    "    - target: The integer target value annotation\n",
    "    \n",
    "    The function a list of float values which represents the history of losses over the \n",
    "    various training epochs.\n",
    "    \"\"\"\n",
    "    indices = list(range(len(dataset)))\n",
    "    \n",
    "    criterion = nn.BCELoss()\n",
    "    optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "    losses_epochs = []\n",
    "    \n",
    "    print('starting model training...')\n",
    "    for epoch in range(epochs):\n",
    "        \n",
    "        indices_epoch = copy(indices)\n",
    "        random.shuffle(indices_epoch)\n",
    "        \n",
    "        losses: int = []\n",
    "        index_epoch = 0\n",
    "        while index_epoch < len(indices) - batch_size:\n",
    "            \n",
    "            indices_batch = indices_epoch[index_epoch:index_epoch+batch_size]\n",
    "            data_batch = [dataset[index] for index in indices_batch]\n",
    "            sequences_batch = [data['signal'] for data in data_batch]\n",
    "            target_batch = [data['target'] for data in data_batch]\n",
    "            \n",
    "            x_batch, lengths_batch = batch_sequences(sequences_batch)\n",
    "            out_pred = model(x_batch, lengths_batch)\n",
    "            out_true = torch.Tensor(target_batch).unsqueeze(-1)\n",
    "            \n",
    "            model.zero_grad()\n",
    "            loss = criterion(out_pred, out_true)\n",
    "            losses.append(loss.item())\n",
    "            \n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "    \n",
    "            index_epoch += batch_size\n",
    "        \n",
    "        print(f' * epoch ({epoch+1}/{epochs}) - loss: {np.mean(losses):.3f}')\n",
    "        losses_epochs.append(np.mean(losses))\n",
    "        \n",
    "    return losses_epochs\n",
    "\n",
    "\n",
    "def evaluate_model(model: nn.Module,\n",
    "                   sequences: list[list],\n",
    "                   ) -> list[float]:\n",
    "    \"\"\"\n",
    "    evaluates the given ``model`` predictions on the given set of ``sequences``\n",
    "    \n",
    "    The function returns a list of the model predictions for each sequence in the \n",
    "    given ``sequences`` list, which will be float values in the range [0, 1]\n",
    "    \"\"\"\n",
    "    out_pred = []\n",
    "    for seq in sequences:\n",
    "        x, lengths = batch_sequences([seq])\n",
    "        out = model(x, lengths)\n",
    "        out_pred.append(out.detach().numpy()[0])\n",
    "        \n",
    "    return out_pred\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "6bf393c7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7870afb56f389651bb9e4cf276122b26",
     "grade": false,
     "grade_id": "cell-983b78421a004758",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ~ Setting Up Dataset \n",
    "\n",
    "dataset = load_dataset(zip_path)\n",
    "random.shuffle(dataset)\n",
    "\n",
    "dataset_test = dataset[:500]\n",
    "dataset_train = dataset[500:]\n",
    "\n",
    "out_true = [data['target'] for data in dataset_test]\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "31b93688",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9be0b0a41742cf318cba9cbcd8ef8c24",
     "grade": false,
     "grade_id": "cell-5ddf4de1ae1ddc31",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting model training...\n",
      " * epoch (1/5) - loss: 0.640\n",
      " * epoch (2/5) - loss: 0.355\n",
      " * epoch (3/5) - loss: 0.255\n",
      " * epoch (4/5) - loss: 0.210\n",
      " * epoch (5/5) - loss: 0.182\n",
      "GRU Model - test accuracy: 94.00%\n"
     ]
    }
   ],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ~ Training GRU Model\n",
    "\n",
    "model_gru = GruModel(1, 64)\n",
    "\n",
    "train_model(\n",
    "    model=model_gru,\n",
    "    dataset=dataset_train,\n",
    "    epochs=5,\n",
    ")\n",
    "out_gru = evaluate_model(\n",
    "    model=model_gru,\n",
    "    sequences=[data['signal'] for data in dataset_test]\n",
    ")\n",
    "acc_gru = accuracy_score(out_true, np.round(out_gru))\n",
    "print(f'GRU Model - test accuracy: {acc_gru*100:.2f}%')\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "dcb1e5db",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "50372bcbabd783042bade3f94ee3844b",
     "grade": true,
     "grade_id": "test-9-7-gru-accuracy",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-7-gru-accuracy - possible points: 1\n",
    "\n",
    "assert len(dataset) == 4766\n",
    "assert model_gru is not None\n",
    "assert isinstance(model_gru, GruModel)\n",
    "\n",
    "assert acc_gru > 0.9\n",
    "\n",
    "# NOTE: The hidden tests will evaluate the model on an unseen test set and check \n",
    "#       for a minimum performance, which the model will definitely achieve if it \n",
    "#       fullfulls the accuracy requirement above as well.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "373246d8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e4d9ba07e886190740b5bd5a42d0454d",
     "grade": false,
     "grade_id": "cell-e4f754138a662aa4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting model training...\n",
      " * epoch (1/5) - loss: 0.611\n",
      " * epoch (2/5) - loss: 0.404\n",
      " * epoch (3/5) - loss: 0.314\n",
      " * epoch (4/5) - loss: 0.232\n",
      " * epoch (5/5) - loss: 0.195\n",
      "LSTM Model - test accuracy: 96.80%\n"
     ]
    }
   ],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ~ Training LSTM Model\n",
    "\n",
    "model_lstm = LstmModel(1, 64)\n",
    "train_model(\n",
    "    model=model_lstm,\n",
    "    dataset=dataset_train,\n",
    "    epochs=5,\n",
    ")\n",
    "out_lstm = evaluate_model(\n",
    "    model=model_lstm,\n",
    "    sequences=[data['signal'] for data in dataset_test],\n",
    ")\n",
    "acc_lstm = accuracy_score(out_true, np.round(out_lstm))\n",
    "print(f'LSTM Model - test accuracy: {acc_lstm*100:.2f}%')\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "50b9d3c0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b5455797f2baec4fded8b3bf4b12c8be",
     "grade": true,
     "grade_id": "test-9-7-lstm-accuracy",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-7-lstm-accuracy - possible points: 1\n",
    "\n",
    "assert len(dataset) == 4766\n",
    "assert model_lstm is not None\n",
    "assert isinstance(model_lstm, LstmModel)\n",
    "\n",
    "assert acc_lstm > 0.9\n",
    "\n",
    "# NOTE: The hidden tests will evaluate the model on an unseen test set and check \n",
    "#       for a minimum performance, which the model will definitely achieve if it \n",
    "#       fullfulls the accuracy requirement above as well.\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b32505db",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "affd895e1f087d5be7b42ec141bfb186",
     "grade": false,
     "grade_id": "cell-b234e581cb5a5c1c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 9.5 Sentiment Analysis\n",
    "\n",
    "**Free-Form Task.** In this final section, you'll have the chance to freely apply everything you've learned so far. The only goal of this section is to create a model that solves the sentiment classification problem described below. While it is recommended to apply your knowledge of recurrent neural networks to solve this task, in principle you are free to use any method you want, so long as it solves the given problem.\n",
    "\n",
    "**Sentiment Classification.** In this section, we will apply the concept of recurrent neural networks to the task of sentiment classification. For a given piece of text, the goal is to classify the underlying sentiment as either *negative* or *positive*. To illustrate this, conisder the following simple examples: \n",
    "\n",
    "- I really liked this cake. (Positive)\n",
    "- I've had a terrible day! (Negative)\n",
    "\n",
    "Based on these, one might think that such a task mainly comes down to detecting the presence of certain negative and positive indicators (good, bad, ...). While this may be true for the majority of samples in practice, one also has to consider edge cases such as negations and sarcasm:\n",
    "\n",
    "- This restaurant really isn't bad! (Positive)\n",
    "- That meeting was sooo necessary... I am very glad it happend (Negative)\n",
    "\n",
    "**Tweet Sentiment Dataset.** The specific dataset we'll be using consists of 10k short [tweets](https://en.wikipedia.org/wiki/Twitter) in which users give their opinion concerning a variety of different video games. Each tweet is annotated with either the *Positive* or the *Negative* label, indicating the general sentiment of its content. The following are some examples from the dataset:\n",
    "\n",
    "- RhandlerR RhandlerR RhandlerR RhandlerR . This doesn’t look right. At all. Why am I just noticing this now? Shouldn’t the payouts be better in M4? Or are these typos. (Negative)\n",
    "- Finally made it into the base 10, just to try to hold on to it. Feels like enough really good meta right now in pirate pirates with all of the odd dh to even mage in high legend... (Positive)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ec5e9bf",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "941783f90188016b343107d64f50fd08",
     "grade": false,
     "grade_id": "task-9-8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**🛠️ Task 9.8 (10 points)** In this task, the overall goal is to solve the previously described sentiment classification problem for the Twitter dataset. While it is recommended to do so using an RNN model, your are open to use any method you want, so long as you as your model class implements the ``SentimentInterface`` that is introduced below. To solve the exercise simply assign a new instance of your custom model implementation to the ``model`` variable in the cells below.\n",
    "\n",
    "The points for this exercise will be distributed incrementally based on the performance of your model.\n",
    "\n",
    "- ``+1 points``: If your model class confirms to the given interface and is able to produce proper predictions \n",
    "  (only considers general functionality, not yet the correctness of the predictions!)\n",
    "- ``+3 points``: If your model achieves a performance which is better than random guessing (>55% accuracy)\n",
    "- ``+3 points``: If your model achieves *decent* performance (>70% accuracy)\n",
    "- ``+3 points``: If your model achieves *good* performance (>85% accuracy)\n",
    "\n",
    "The performance will be evaluated on an unseen test dataset. This test dataset consists of 100 elements and is balanaced regarding the output labels (same number of negative and positive samples).\n",
    "\n",
    "**HINT.** Having your final model be trained in-time during grading will likely cause unstable results. Even if the training showed good results on your local machine, there is always the possibility of an unfavorable initialization leading to worse performance. Additionally, during grading there will be a cell execution timeout of *1 minute*, which might not be enough time for a model to achieve sufficient performance. Consequently, you might want to consider to extensively train your model locally and then only load the pre-trained model weights in your graded submission. During grading, you'll be able to access [publically shared](https://docs.nextcloud.com/server/latest/user_manual/en/files/sharing.html) files from BwSync&Share, by using the ``nextcloud_download`` function. You can use this, for example, to download a file containing pre-trained model weights. You can find more information about how to export and import such model weights [online](https://pytorch.org/tutorials/beginner/saving_loading_models.html):\n",
    "\n",
    "**NOTE.** During grading, internet access to everything except BwSync&Share will be blocked. This means it won't be possible to simply redirect the task to a publicly available service such as GPT or HuggingFace!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "130115e8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a898c3604492eec90d5057c8087a3c6b",
     "grade": false,
     "grade_id": "cell-1b6799c21078ef5a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "\n",
    "class SentimentInterface:\n",
    "    \"\"\"\n",
    "    This interface has to be implemented for a sentiment classification model which \n",
    "    solves the given task. To implement this interface for a custom model class, simply \n",
    "    inherit from it and overwrite the ``predict_sentiment`` method with your custom \n",
    "    solution.\n",
    "    \"\"\"\n",
    "    \n",
    "    def predict_sentiment(text: str) -> typ.Literal['Negative', 'Positive']:\n",
    "        \"\"\"\n",
    "        This function receives a single string ``text`` and is supposed to implement \n",
    "        some sort of sentiment classification method to finally return either of the \n",
    "        string labels \"Negative\" or \"Positive\" to determine the given text's overall \n",
    "        sentiment.\n",
    "        \n",
    "        :param: String literal\n",
    "        \n",
    "        :returns: String literal which is either \"Negative\" in case of a negative \n",
    "            sentiment and \"Positive\" in case of a positive sentiment.\n",
    "        \"\"\"\n",
    "        raise NotImplemented()\n",
    "        \n",
    "        \n",
    "# ~ Mock Implementation of a naive sentiment classification approach\n",
    "\n",
    "class MockModel(SentimentInterface):\n",
    "    \n",
    "    def predict_sentiment(self, text: str) -> str:\n",
    "        if 'good' in text:\n",
    "            return 'Positive'\n",
    "        else:\n",
    "            return 'Negative'\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86721d7b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b5d02fb903405f4624ae7933b049ea68",
     "grade": false,
     "grade_id": "cell-e75de694c578d425",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# The dataset is downloaded from the file share server and stored as a Dataframe\n",
    "content = nextcloud_download('https://bwsyncandshare.kit.edu/s/nAy6oMPdP7cKAz7')\n",
    "df: pd.DataFrame = pd.read_csv(io.StringIO(content))\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19c092da",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d40f5050882a62877490d80d2cbcb73e",
     "grade": false,
     "grade_id": "ans-9-8-explore",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# == DATA EXPLORATION ==\n",
    "# You may use this cell to perform some exploratory data analysis in order to get \n",
    "# a better overview of what type of dataset you'll be working with.\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0e788a6",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d3b64c36b024a430fa16f9c8d1916b47",
     "grade": false,
     "grade_id": "ans-9-8-model",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# == MODEL IMPLEMENTATION ==\n",
    "# You may use this cell to define your model implementation.\n",
    "# In case you are planning to implement a RNN solution, here are several pointers of \n",
    "# what aspects to consider:\n",
    "# - The first challange is how to convert the text itself into a sequence which a \n",
    "#   neural network model can understand. You'll have to find some way to  meaningfully \n",
    "#   convert the string into a series of numeric vectors.\n",
    "#   For this task, several solutions of varying complexity exist. A simple solution might \n",
    "#   be a one-hot encoding for characters and more complex solutions can use third-party \n",
    "#   \"tokenizers\".\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "850697ae",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "42f28b315c3d14fefd321967b723a43e",
     "grade": false,
     "grade_id": "ans-9-8-training",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# === MODEL TRAINING ===\n",
    "# You may use this cell to train your previously model.\n",
    "# For your training, keep in mind the cell execution timout during grading! If a \n",
    "# cell runs longer than 5 minutes it will automatically be terminated, so make \n",
    "# sure to set up your training accordingly!\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67b8b3d7",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1679a5053e3dbeb8fb710cecd1c9f7c5",
     "grade": false,
     "grade_id": "ans-9-8-evaluation",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# === MODEL EVALUATION ===\n",
    "# You may this cell to evaluate the performance of your model. \n",
    "# To do this, you might want to think about splitting the dataset that is available to you \n",
    "# into a appropriate train and validation sets. Your model's performance on an unseen \n",
    "# validation split should give you a better indication of the final performance on the \n",
    "# the unseen test set.\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b2f5b29",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "162430540d5902589a2e4d997f23ca0a",
     "grade": false,
     "grade_id": "ans-9-8-loading",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# TASK: Create a new instance of your custom model implementation which inherits \n",
    "#       from the \"TextClassifierInterface\" and assign this instance to the model \n",
    "#       variable below.\n",
    "\n",
    "# HINT: During the grading of the notebook, general access to the internet is blocked.\n",
    "#       This means that it won't be possible to simply send the text snippets to \n",
    "#       a ChatGPT and or HuggingFace API to solve the task for you!\n",
    "\n",
    "# HINT: However, access to the university's BwSync&Share cloud is enabled. This means \n",
    "#       that you'll be able to circumvent the cell execution timeout for model training \n",
    "#       by loading pre-trained model weights from your cloud storage.\n",
    "\n",
    "model: SentimentInterface = None\n",
    "\n",
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cf21f2b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "82e018f7dc5a78b332209b423400c747",
     "grade": true,
     "grade_id": "test-9-8-functionality",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-8-functionality - possible points: 1\n",
    "\n",
    "assert model is not None\n",
    "assert isinstance(model, SentimentInterface), 'make sure the model implements the interface!'\n",
    "\n",
    "reviews_ = [\n",
    "    'This is the worst game I have ever played in my life!',\n",
    "    'The GREATEST experience of all time - I am so happy',\n",
    "]\n",
    "for review in reviews_:\n",
    "    prediction = model.predict_sentiment(review)\n",
    "    print(f'input: \"{review}\" - prediction: {prediction}')\n",
    "    assert isinstance(prediction, str)\n",
    "    assert prediction in ['Negative', 'Positive']\n",
    "\n",
    "# NOTE: There are no additional hidden test cases in this cell\n",
    "    \n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1c30951",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dc403af1ede47a8979543800a6e15e36",
     "grade": true,
     "grade_id": "test-9-8-basic-acc",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-8-basic-acc - possible points: 3\n",
    "\n",
    "# NOTE: The hidden tests will evaluate the model on the unseen test set and check \n",
    "#       if the accuracy is >= 0.55\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da79bae9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "67ff03c748a0899560f8f55b6163127a",
     "grade": true,
     "grade_id": "test-9-8-decent-acc",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-8-decent-acc - possible points: 3\n",
    "\n",
    "# NOTE: The hidden tests will evaluate the model on the unseen test set and check \n",
    "#       if the accuracy is >= 0.70\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddd32fb0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cbb7bac737513ee5bccaea81d0af6598",
     "grade": true,
     "grade_id": "test-9-8-good-acc",
     "locked": true,
     "points": 3,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "##### DO NOT CHANGE #####\n",
    "# ID: test-9-8-good-acc - possible points: 3\n",
    "\n",
    "# NOTE: The hidden tests will evaluate the model on the unseen test set and check \n",
    "#       if the accuracy is >= 0.85\n",
    "\n",
    "\n",
    "##### DO NOT CHANGE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6871c1d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "63fb029dd19d102de57b5f452bb71ab8",
     "grade": false,
     "grade_id": "parting-message",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "👋 I hope you've found this exercise sheet helpful for your understanding on recurrent neural networks! The final free-form task was a bit of an experiment that deviated slightly from the usually more guided style of the exercises. It would helpful if you could fill out the [Exercise Evaluation](https://ilias.studium.kit.edu/ilias.php?baseClass=ilObjSurveyGUI&ref_id=2359493&cmd=infoScreen) and let us know your opinion about more open-ended tasks like this!"
   ]
  }
 ],
 "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}