task2/VladimirovTask2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c91d5169",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import pickle\n",
    "import gc\n",
    "import graphviz\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import animation\n",
    "import scipy.stats as sps\n",
    "import seaborn as sns\n",
    "\n",
    "from IPython.display import HTML\n",
    "\n",
    "# sys.path.append('./pyfac')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1057e7af",
   "metadata": {},
   "source": [
    "Visualize message passing for factor-graph with algorithm Sum-Product.\n",
    "\n",
    "The directions of messages should be visualized in the resulting plots.\n",
    "\n",
    "Graph and model parameters must be sampled randomly during each run of notebook.\n",
    "\n",
    "Visualization format - plots step by step via interactive plots or animation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1ccfcb07",
   "metadata": {},
   "outputs": [],
   "source": [
    "from builtins import range\n",
    "from functools import reduce\n",
    "import numpy as np\n",
    "\n",
    "\"\"\" Factor Graph classes forming structure for PGMs\n",
    "    Basic structure is port of MATLAB code by J. Pacheco\n",
    "    Central difference: nbrs stored as references, not ids\n",
    "        (makes message propagation easier)\n",
    "\n",
    "    Note to self: use %pdb and %load_ext autoreload followed by %autoreload 2\n",
    "\"\"\"\n",
    "\n",
    "class Node(object):\n",
    "    \"\"\" Superclass for graph nodes\n",
    "    \"\"\"\n",
    "    epsilon = 10**(-4)\n",
    "\n",
    "    def __init__(self, nid):\n",
    "        self.enabled = True\n",
    "        self.nid = nid\n",
    "        self.nbrs = []\n",
    "        self.incoming = []\n",
    "        self.outgoing = []\n",
    "        self.oldoutgoing = []\n",
    "\n",
    "    def reset(self):\n",
    "        self.enabled = True\n",
    "\n",
    "    def disable(self):\n",
    "        self.enabled = False\n",
    "\n",
    "    def enable(self):\n",
    "        self.enabled = True\n",
    "        for n in self.nbrs:\n",
    "            # don't call enable() as it will recursively enable entire graph\n",
    "            n.enabled = True\n",
    "\n",
    "    def nextStep(self):\n",
    "        \"\"\" Used to have this line in prepMessages\n",
    "            but it didn't work?\n",
    "        \"\"\"\n",
    "        self.oldoutgoing = self.outgoing[:]\n",
    "\n",
    "    def normalizeMessages(self):\n",
    "        \"\"\" Normalize to sum to 1\n",
    "        \"\"\"\n",
    "        self.outgoing = [x / np.sum(x) for x in self.outgoing]\n",
    "\n",
    "    def receiveMessage(self, f, m):\n",
    "        \"\"\" Places new message into correct location in new message list\n",
    "        \"\"\"\n",
    "        if self.enabled:\n",
    "            i = self.nbrs.index(f)\n",
    "            self.incoming[i] = m\n",
    "\n",
    "    def sendMessages(self):\n",
    "        \"\"\" Sends all outgoing messages\n",
    "        \"\"\"\n",
    "        for i in range(0, len(self.outgoing)):\n",
    "            self.nbrs[i].receiveMessage(self, self.outgoing[i])\n",
    "\n",
    "    def checkConvergence(self):\n",
    "        \"\"\" Check if any messages have changed\n",
    "        \"\"\"\n",
    "        if self.enabled:\n",
    "            for i in range(0, len(self.outgoing)):\n",
    "                # check messages have same shape\n",
    "                self.oldoutgoing[i].shape = self.outgoing[i].shape\n",
    "                delta = np.absolute(self.outgoing[i] - self.oldoutgoing[i])\n",
    "                if (delta > Node.epsilon).any(): # if there has been change\n",
    "                    return False\n",
    "            return True\n",
    "        else:\n",
    "            # Always return True if disabled to avoid interrupting check\n",
    "            return True\n",
    "\n",
    "class VarNode(Node):\n",
    "    \"\"\" Variable node in factor graph\n",
    "    \"\"\"\n",
    "    def __init__(self, name, dim, nid):\n",
    "        super(VarNode, self).__init__(nid)\n",
    "        self.name = name\n",
    "        self.dim = dim\n",
    "        self.observed = -1 # only >= 0 if variable is observed\n",
    "\n",
    "    def reset(self):\n",
    "        super(VarNode, self).reset()\n",
    "        size = range(0, len(self.incoming))\n",
    "        self.incoming = [np.ones((self.dim,1)) for i in size]\n",
    "        self.outgoing = [np.ones((self.dim,1)) for i in size]\n",
    "        self.oldoutgoing = [np.ones((self.dim,1)) for i in size]\n",
    "        self.observed = -1\n",
    "\n",
    "    def condition(self, observation):\n",
    "        \"\"\" Condition on observing certain value\n",
    "        \"\"\"\n",
    "        self.enable()\n",
    "        self.observed = observation\n",
    "        # set messages (won't change)\n",
    "        for i in range(0, len(self.outgoing)):\n",
    "            self.outgoing[i] = np.zeros((self.dim,1))\n",
    "            self.outgoing[i][self.observed] = 1.\n",
    "        self.nextStep() # copy into oldoutgoing\n",
    "\n",
    "    def prepMessages(self):\n",
    "        \"\"\" Multiplies together incoming messages to make new outgoing\n",
    "        \"\"\"\n",
    "\n",
    "        # compute new messages if no observation has been made\n",
    "        if self.enabled and self.observed < 0 and len(self.nbrs) > 1:\n",
    "            # switch reference for old messages\n",
    "            self.nextStep()\n",
    "            for i in range(0, len(self.incoming)):\n",
    "                # multiply together all excluding message at current index\n",
    "                curr = self.incoming[:]\n",
    "                del curr[i]\n",
    "                self.outgoing[i] = reduce(np.multiply, curr)\n",
    "\n",
    "            # normalize once finished with all messages\n",
    "            self.normalizeMessages()\n",
    "\n",
    "class FacNode(Node):\n",
    "    \"\"\" Factor node in factor graph\n",
    "    \"\"\"\n",
    "    def __init__(self, P, nid, *args):\n",
    "        super(FacNode, self).__init__(nid)\n",
    "        self.P = P\n",
    "        self.nbrs = list(args) # list storing refs to variable nodes\n",
    "\n",
    "        # num of edges\n",
    "        numNbrs = len(self.nbrs)\n",
    "        numDependencies = self.P.squeeze().ndim\n",
    "\n",
    "        # init messages\n",
    "        for i in range(0,numNbrs):\n",
    "            v = self.nbrs[i]\n",
    "            vdim = v.dim\n",
    "\n",
    "            # init for factor\n",
    "            self.incoming.append(np.ones((vdim,1)))\n",
    "            self.outgoing.append(np.ones((vdim,1)))\n",
    "            self.oldoutgoing.append(np.ones((vdim,1)))\n",
    "\n",
    "            # init for variable\n",
    "            v.nbrs.append(self)\n",
    "            v.incoming.append(np.ones((vdim,1)))\n",
    "            v.outgoing.append(np.ones((vdim,1)))\n",
    "            v.oldoutgoing.append(np.ones((vdim,1)))\n",
    "\n",
    "        # error check\n",
    "        assert (numNbrs == numDependencies), \"Factor dimensions does not match size of domain.\"\n",
    "\n",
    "    def reset(self):\n",
    "        super(FacNode, self).reset()\n",
    "        for i in range(0, len(self.incoming)):\n",
    "            self.incoming[i] = np.ones((self.nbrs[i].dim,1))\n",
    "            self.outgoing[i] = np.ones((self.nbrs[i].dim,1))\n",
    "            self.oldoutgoing[i] = np.ones((self.nbrs[i].dim,1))\n",
    "\n",
    "    def prepMessages(self):\n",
    "        \"\"\" Multiplies incoming messages w/ P to make new outgoing\n",
    "        \"\"\"\n",
    "        if self.enabled:\n",
    "            # switch references for old messages\n",
    "            self.nextStep()\n",
    "\n",
    "            mnum = len(self.incoming)\n",
    "\n",
    "            # do tiling in advance\n",
    "            # roll axes to match shape of newMessage after\n",
    "            for i in range(0,mnum):\n",
    "                # find tiling size\n",
    "                nextShape = list(self.P.shape)\n",
    "                del nextShape[i]\n",
    "                nextShape.insert(0, 1)\n",
    "                # need to expand incoming message to correct num of dims to tile properly\n",
    "                prepShape = [1 for x in nextShape]\n",
    "                prepShape[0] = self.incoming[i].shape[0]\n",
    "                self.incoming[i].shape = prepShape\n",
    "                # tile and roll\n",
    "                self.incoming[i] = np.tile(self.incoming[i], nextShape)\n",
    "                self.incoming[i] = np.rollaxis(self.incoming[i], 0, i+1)\n",
    "\n",
    "            # loop over subsets\n",
    "            for i in range(0, mnum):\n",
    "                curr = self.incoming[:]\n",
    "                del curr[i]\n",
    "                newMessage = reduce(np.multiply, curr, self.P)\n",
    "\n",
    "                # sum over all vars except i!\n",
    "                # roll axis i to front then sum over all other axes\n",
    "                newMessage = np.rollaxis(newMessage, i, 0)\n",
    "                newMessage = np.sum(newMessage, tuple(range(1,mnum)))\n",
    "                newMessage.shape = (newMessage.shape[0],1)\n",
    "\n",
    "                #store new message\n",
    "                self.outgoing[i] = newMessage\n",
    "\n",
    "            # normalize once finished with all messages\n",
    "            self.normalizeMessages()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "60f59fa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Graph class\n",
    "from __future__ import print_function\n",
    "from builtins import range\n",
    "from future.utils import iteritems\n",
    "import numpy as np\n",
    "import pdb\n",
    "\n",
    "\"\"\" Factor Graph classes forming structure for PGMs\n",
    "    Basic structure is port of MATLAB code by J. Pacheco\n",
    "    Central difference: nbrs stored as references, not ids\n",
    "        (makes message propagation easier)\n",
    "\"\"\"\n",
    "\n",
    "class Graph:\n",
    "    \"\"\"\n",
    "    Putting everything together\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.var = {}\n",
    "        self.fac = []\n",
    "        self.dims = []\n",
    "        self.converged = False\n",
    "\n",
    "    def addVarNode(self, name, dim):\n",
    "        newId = len(self.var)\n",
    "        newVar = VarNode(name, dim, newId)\n",
    "        self.var[name] = newVar\n",
    "        self.dims.append(dim)\n",
    "\n",
    "        return newVar\n",
    "\n",
    "    def addFacNode(self, P, *args):\n",
    "        newId = len(self.fac)\n",
    "        newFac = FacNode(P, newId, *args)\n",
    "        self.fac.append(newFac)\n",
    "\n",
    "        return newFac\n",
    "\n",
    "    def disableAll(self):\n",
    "        \"\"\" Disable all nodes in graph\n",
    "            Useful for switching on small subnetworks\n",
    "            of bayesian nets\n",
    "        \"\"\"\n",
    "        for k, v in iteritems(self.var):\n",
    "            v.disable()\n",
    "        for f in self.fac:\n",
    "            f.disable()\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\" Reset messages to original state\n",
    "        \"\"\"\n",
    "        for k, v in iteritems(self.var):\n",
    "            v.reset()\n",
    "        for f in self.fac:\n",
    "            f.reset()\n",
    "        self.converged = False\n",
    "    \n",
    "    def plot(self, marginals=None):\n",
    "        t = graphviz.Graph('Graph', format='png')\n",
    "        reversed_var = {v: k for k, v in self.var.items()}\n",
    "        \n",
    "        if marginals is None:\n",
    "            marginals = self.calc_prob()\n",
    "        image_names = []\n",
    "\n",
    "        t.attr('node', shape='circle', fixedsize='true', width='0.9')\n",
    "        for nm, node in self.var.items():\n",
    "            plt.pie(\n",
    "                marginals[nm].reshape(-1),\n",
    "                autopct='%.1f%%',\n",
    "                radius=2\n",
    "            )\n",
    "            \n",
    "            img_nm = f'{nm}-distribution.svg'\n",
    "            image_names.append(img_nm)\n",
    "            \n",
    "            plt.savefig(img_nm)\n",
    "            plt.close()\n",
    "            t.node(f'{nm}-{node.nid:d}', image=img_nm)\n",
    "            \n",
    "        t.attr('node', shape='box')\n",
    "        for factor in self.fac:\n",
    "            t.node(f'factor-{factor.nid:d}')\n",
    "            \n",
    "            for node in factor.nbrs:\n",
    "                node_nm = reversed_var[node]\n",
    "                t.edge(f'factor-{factor.nid:d}', f'{node_nm}-{node.nid:d}')\n",
    "            \n",
    "        t.attr(overlap='false')\n",
    "        t.attr(fontsize='12')\n",
    "\n",
    "        filepath = t.view(cleanup=False, quiet=True)\n",
    "        \n",
    "        for img in image_names:\n",
    "            os.remove(img)\n",
    "        \n",
    "        return filepath\n",
    "\n",
    "    def sumProduct(self, maxsteps=500, return_probs=False):\n",
    "        \"\"\" This is the algorithm!\n",
    "            Each timestep:\n",
    "            take incoming messages and multiply together to produce outgoing for all nodes\n",
    "            then push outgoing to neighbors' incoming\n",
    "            check outgoing v. previous outgoing to check for convergence\n",
    "        \"\"\"\n",
    "        # loop to convergence\n",
    "        timestep = 0\n",
    "        probs_history = []\n",
    "        while timestep < maxsteps and not self.converged: # run for maxsteps cycles\n",
    "            timestep = timestep + 1\n",
    "\n",
    "            for f in self.fac:\n",
    "                # start with factor-to-variable\n",
    "                # can send immediately since not sending to any other factors\n",
    "                f.prepMessages()\n",
    "                f.sendMessages()\n",
    "\n",
    "            for k, v in iteritems(self.var):\n",
    "                # variable-to-factor\n",
    "                v.prepMessages()\n",
    "                v.sendMessages()\n",
    "\n",
    "            # check for convergence\n",
    "            t = True\n",
    "            for k, v in iteritems(self.var):\n",
    "                t = t and v.checkConvergence()\n",
    "                if not t:\n",
    "                    break\n",
    "            if t:\n",
    "                for f in self.fac:\n",
    "                    t = t and f.checkConvergence()\n",
    "                    if not t:\n",
    "                        break\n",
    "\n",
    "            if t: # we have convergence!\n",
    "                self.converged = True\n",
    "            \n",
    "            probs_history.append(self.calc_prob())\n",
    "            \n",
    "        # if run for 500 steps and still no convergence:impor\n",
    "        if not self.converged:\n",
    "            print(\"No convergence!\")\n",
    "        \n",
    "        return probs_history if return_probs else None\n",
    "    \n",
    "    def calc_prob(self):\n",
    "        marginals = {}\n",
    "        # for each var\n",
    "        for k, v in iteritems(self.var):\n",
    "            if v.enabled: # only include enabled variables\n",
    "                # multiply together messages\n",
    "                vmarg = 1\n",
    "                for i in range(0, len(v.incoming)):\n",
    "                    vmarg = vmarg * v.incoming[i]\n",
    "\n",
    "                # normalize\n",
    "                n = np.sum(vmarg)\n",
    "                vmarg = vmarg / n\n",
    "\n",
    "                marginals[k] = vmarg\n",
    "        \n",
    "        return marginals\n",
    "\n",
    "    def marginals(self, maxsteps=500, return_probs=False):\n",
    "        \"\"\" Return dictionary of all marginal distributions\n",
    "            indexed by corresponding variable name\n",
    "        \"\"\"\n",
    "        # Message pass\n",
    "        result = self.sumProduct(maxsteps, return_probs)\n",
    "        \n",
    "        if return_probs:\n",
    "            return result, self.calc_prob()\n",
    "        else:\n",
    "            return self.calc_prob()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ce72512c",
   "metadata": {},
   "outputs": [],
   "source": [
    "G = Graph()\n",
    "\n",
    "# add variable nodes\n",
    "a = G.addVarNode('a', 3)\n",
    "b = G.addVarNode('b', 4)\n",
    "c = G.addVarNode('c', 5)\n",
    "\n",
    "# add factors\n",
    "# unary factor\n",
    "Pb = np.random.rand(4, 1, 1) #np.array([[0.3],[0.7]])\n",
    "Pb /= Pb.sum()\n",
    "G.addFacNode(Pb, b)\n",
    "\n",
    "# connecting factor\n",
    "Pac = np.random.rand(3, 5, 1) # np.array([[0.2, 0.8], [0.4, 0.6], [0.1, 0.9]])\n",
    "Pac /= Pac.sum(axis=-1, keepdims=True)\n",
    "G.addFacNode(Pac, a, c)\n",
    "\n",
    "Pabc = np.random.rand(3, 4, 5)\n",
    "Pabc /= Pabc.sum(axis=-1, keepdims=True)\n",
    "G.addFacNode(Pabc, a, b, c)\n",
    "\n",
    "# factors can connect an arbitrary number of variables\n",
    "\n",
    "# run sum-product and get marginals for variables\n",
    "prob_hist, marg = G.marginals(return_probs=True)\n",
    "# distA = marg['a']\n",
    "# distB = marg['b']\n",
    "# G.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "846dccc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "MovieWriter imagemagick unavailable; using Pillow instead.\n",
      "gio: file:///home/eduard/dep-tasks/bmm/Graph.gv.png: Ошибка при получении информации о файле «/home/eduard/dep-tasks/bmm/Graph.gv.png»: Нет такого файла или каталога\n",
      "gio: file:///home/eduard/dep-tasks/bmm/Graph.gv.png: Ошибка при получении информации о файле «/home/eduard/dep-tasks/bmm/Graph.gv.png»: Нет такого файла или каталога\n",
      "gio: file:///home/eduard/dep-tasks/bmm/Graph.gv.png: Ошибка при получении информации о файле «/home/eduard/dep-tasks/bmm/Graph.gv.png»: Нет такого файла или каталога\n",
      "gio: file:///home/eduard/dep-tasks/bmm/Graph.gv.png: Ошибка при получении информации о файле «/home/eduard/dep-tasks/bmm/Graph.gv.png»: Нет такого файла или каталога\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAFBCAYAAADqo6ytAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADgVUlEQVR4nOydd3xcxbX4v3e7Vr03q1qW5d47mN6SUAIhkEJJXkJ6ISGBlBdC3kshjbyEAEkgkAAh/OgQimnullxldVtW71270vZy7++P9a4lWWXVLMmaLx9hae/cmdl7z5175pwzZyRFURQEAoFAIBDMW1Qz3QGBQCAQCAQzi1AGBAKBQCCY5whlQCAQCASCeY5QBgQCgUAgmOcIZUAgEAgEgnmOUAYEAoFAIJjnCGVAIBAIBIJ5jlAGBAKBQCCY5whlQCAQCASCeY5QBgQCgUAgmOcIZUAgEAgEgnmOUAYEAoFAIJjnCGVAIBAIBIJ5jmayFYhNDwXjQZKkme6CkFnBuBAyK5grTEZWJ6UMKIqC2WzGbDZTW1s7maoE5zFxcXHExcURHx+PWq2e6e7Q0tJCT08PPT09YpAVDEtCQgK5ubmzQl4B6uvrqaurm+luCGYpERERREZGkp2dPWGFYNKWgb6+PpqbmykoKBADq2BYFi1aRG5uLjExMbNicG1ra6OmpoaamhpkWZ7p7ghmIUuXLiU7OxuVSjUrLAONjY3k5+fPdDcEsxBJkkhKSiI9PZ3s7OwJ1zNpZaC6upoDBw7wk5/8RCgDgmG59tpruf7668nOzkan0810d8jPz+ftt9/mvffew+PxzHR3BLOQW2+9le3bt6PRaFCpZj606sMPP+SBBx6Y6W4IZiGSJLF+/XouvPBCLrnkkgnXM2llAHzuAlmW+eIXv8imTZumokrBeUBvby8///nPZ4U1YCCKoqDT6Vi9ejXr169n3bp1M90lwSygs7OTlpYWnnrqqVk3sVEUBbVaza233kpmZiaZmZkz3SXBLKCmpoZ9+/ahVqsnLbNTogz4ueiii/jMZz4zlVUK5jCNjY089NBDs04ZANBoNGRkZHDppZfyiU98Yqa7I5gFVFdXU1ZWxr///e+Z7sqwaDQatmzZwvr169m4ceNMd0cwCygoKKCjo4OWlpZJ1zXz9i+BQCAQCAQzilAGBAKBQCCY5whlQCAQCASCeY5QBgQCgUAgmOcIZUAgEAgEgnmOUAYEAoFAIJjnCGVAIBAIBIJ5jlAGBAKBQCCY5whlQCAQCASCeY5QBgQCgUAgmOcIZUAgEAgEgnmOUAYEAoFAIJjnCGVAIBAIBIJ5jlAGBAKBQCCY5whlQCAQCASCeY5QBgQCgUAgmOcIZUAgEAgEgnmOUAYEAoFAIJjnCGVAIBAIBIJ5jlAGBAKBQCCY5whlQCAQCASCeY5QBgQCgUAgmOcIZUAgEAgEgnmOUAYEAoFAIJjnaGa6AxNBURS8Xi9OpxOXy4XH4wkc0+v1aLVaDAYDAJIkzVQ3BYIAiqLgcrlwu90BmZUkCUmSMBgMaLVadDqdkFfBrEBRFBRFwWaz4fF4cLvdKIqCSqVCo9EQEhKCVqsNyLBg7jMnlQGXy0VtbS1vvfUW+/bt4/jx4wAYDAauvvpqNm3axE033YRarZ7ZjgoEp3G73ezevZuCggJ27txJXV0dKpWKmJgYbr75ZlavXs0VV1wx090UCABwOp1YLBb+8pe/UFZWxpEjR3C73YSGhrJu3TpuvfVWNm7cSExMzEx3VTBFzDllwG63097ezr/+9S+8Xi95eXlkZWXR0dFBc3Mz5eXlRERE0N/fT3h4OBrN9HzF7u5uGhoayMrKwmg0BrTk2YKiKDgcDiwWC83NzTQ3N+NwOIiMjGTx4sWkpaXNdBfnDV1dXbS3t/Puu+8iSRIXXXQRy5cvp6uri9raWsrLy1GpVNOuDJjNZioqKsjNzZ11g7jH48Fut1NeXk5bWxutra14vV4AYmJiSE1NJTMzk+TkZLRa7Qz39vxFURQAqqqqOHDgAH19fSQnJ/OJT3yC+vp6TCYTlZWV1NTUsGDBAqKioqZt0tXX14fdbqe/v5/Y2Fiio6OnpZ2J4ree1NbW0tjYSGVlJW63G4Ds7GxSUlJYunQparUalWr2e+TnnDJgsVioq6vj0Ucf5TOf+QzXXXcdK1eupLCwkPfff5/XXnuNuLg4+vr6CAkJmXJlwP+wtLe3s2fPHsLDw0lKSpqVA1RfXx/Nzc3s27eP/Px8enp6yMnJ4ZOf/KRQBs4hbW1tFBUV8cYbb/CRj3yEO+64A4CSkhL+8Y9/UF1dDfhkazoUSv+g1d3dzY4dO4iMjJw1yoD/eXK73XR3d7Nz506OHj3K4cOHcTqdgG9g3bJlC5dffjnR0dFzZnCdq8iyTElJCY8//jgXXngha9as4YYbbghYYR999FEaGxtpampiyZIl09aPnp4eOjs7aWlpYdmyZbNSGXA6nZSUlLB7927eeOMNbDYbiqJwxRVXsHnzZjIzMwkNDQ0817NpwjiUOacMHDlyhIMHD+LxeMjKymLTpk3o9Xq2bt3KqlWr+NKXvoTBYCA+Pn7aNFaHw8GJEyd45pln2LJlC0lJSdPSzmRQFIXnnnuO8vJyKioqAi+cjIyMwAAsODccO3aM//znP2RmZpKTk8OCBQtQFIW4uDjWrVuHx+OZ9niBxsZGSktL2blzJ5dccsm0DuLjxeVycerUKR5++GHWrl3LnXfeyU9+8hN6enpoaWnhL3/5C++88w4vv/wyP//5z1mxYgXLly+f6W6fl3i9Xk6cOEFpaSnl5eV84xvfYPXq1RiNRi644AI2bNjAzTffTHh4OEajcVpdse+99x4nT55k69ats3LM6urq4je/+Q0nT56kp6eH3/3ud0RGRqJSqXjooYd44403OHbsGN/97nfJy8ub6e6OyZxTBnp7e+nq6kKSJPR6PaGhoQBoNBpCQ0NJSEiY1vZlWaa0tJSysjKamppwuVzT2t5kSE5ODvj5WltbMZlMM92leUlfXx9tbW1ERUUFggUBdDod4eHh09q2LMt4vV4KCwspKiqir69vUMDtbKCnpweLxUJiYiKZmZlkZWWRkZFBX18fcXFxbNq0ifz8fCorKzl58iQxMTFCGZgmFEWht7eXvr4+nE4nRqMRo9GISqUiLCyMsLAwYmNjp7UPDoeDtrY2ysvLOXXqFJs3b57W9iZCb28vjY2NHD58mJCQELKzs1myZAmRkZFIkkRubi6nTp3i2LFj1NTUEB0dTWJi4kx3e1TmhDIwUCs0m8309PSgVquRJGnCGuPAWdh46nC73fzrX//i0KFDdHR0BKJsx1vPwH6M97xgZpAqlYpbbrkFRVGQZZn6+noOHDgw7v4JJsbAe9rf3093dzcxMTGoVKpBx8Zz//33fTzy4vV6sdls/Otf/6K8vBy1Wh1wG0ym3vEymsyeOnUKl8vF7bffTnJyMmFhYYAvIDg2NpZvf/vbGAwGDhw4wNGjR4mOjuaqq66atr7ONwbed1mW6erqor+/H/BNsvwyM14mOsb29vbywQcfsHfvXlpaWrj99tvHXcdkGWuMramp4ciRI+zfv5/bb7+dm2++mczMTHQ6HbIsc9NNN7Fjxw5eeeUV8vPzUavVs15mZ70yoCgKJ06coLi4mMcee4yWlhZMJhNms5nf//73/Pvf/wbg2muv5bbbbkOWZaqrq3n33Xepqqqir68Pt9tNYmIiqampfPaznyUxMfEsn2lJSQmnTp3i/fffp62tDZfLRUREBOvXr2fJkiVcccUVHDlyhF27dvHmm2/S3t6OLMt85zvfITw8HLVazU9+8hO2bNmCXq+npaWFxsZGXn75Zdra2ujs7MRgMJCQkEBeXh7XXnstKSkphISE0NPTQ1dXF3v37qWiooL29nbuv/9+amtr+fDDD6mpqSE7O5s77riD9PT0gDUkWFQqFVqtdlbGNZyvfPjhhxQXF/Pmm29SW1tLW1sbHR0dnDx5kqeffpr4+Hi2bNnCt771LWpra6mtreW1116jvb2d/v5+1Go1qampZGRkcMcddxAdHU1ISMigNvbt20dlZSW7du0KyHlKSgrr1q1j8+bN5ObmcvToUZ544gny8/Pp7e0F4Lvf/S6JiYlkZGRwyy23cNlllwFQW1tLaWkp77//Ph0dHfT09BAdHU1CQgLbtm1j8+bNpKenI0kSbW1ttLS0sHv3brq6ujCbzXz+85+nt7eXZ599FlmWWbBgAffdd98ga8hwrFy5ElmWMRgM6PX6Qcf8Ky6ioqIIDw8nPj6eyMjIKb5bAlmW+etf/8rzzz9Pd3c3XV1deL1efvzjHxMWFobBYODTn/40K1asYO3atezZs4eSkhIOHTqE1WrF5XIRFxfH4sWL2bp1Kxs3bhxk9XK73bS3t7N3716KioooLy8HfNax9evXs2LFCi6//HKOHz9OYWEhDz/8MI2NjTidTn72s58FLBJ33303CxcuJDMzk+7ubqqqqnj33Xc5efIkfX19yLJMeno6aWlpfPKTnyQ+Pp6IiAgsFguNjY2UlZWxb98+wsPDueKKK2hpaaG1tZUPP/yQbdu2sXr1ai6//PIxx8rCwkL27t2LJElkZGSwZs2aQHyaJEksWrSIyspKQkJCOHToECqViiuvvFLEDEwWWZZxu93YbDacTicejyewbttmswG+pTBer5dTp05RXl5OUVERFosFl8uFw+Ggq6uL5uZmVq1ahVqtDigDDoeD/v5+iouLqampobOzE7PZjN1up6WlBfDN7NasWUN/fz8ulwu1Wh3wlTkcjsDfHo8Hr9dLX18flZWVlJeX09LSQm9vL/39/fT09GAymejp6SEtLQ2n08mSJUtobGykqqqK/fv3U1ZWRnt7O01NTXR0dNDd3c3Ro0exWq2YTCaSk5PHde0GBq7MZkE83/B4PLhcrsBAKcsyHo8Hp9OJ1WolLCwMh8OBx+OhvLw8YBJ1OBy43W4cDge9vb00NTVx0UUXAQSUAf+KGv85vb29WCwWnE5nQElVqVQkJSUFchuoVCpUKhUejweHw4HNZgu07/V6aW9v59SpUxQWFtLe3o7ZbKavr4++vj66u7sBiIyMRK1Wk5iYSGNjI8eOHWPfvn309PRgtVq58sorA4Nue3s7XV1duN3us17wA5EkiaioqFGvpb/vKpVqWEVeMHn846nVag3IoD9ATq1WI8syLpcLu91OQ0MDxcXFFBYW0tXVFcj30tbWhsViQaVSkZeXF4gpcLlcmM1mjh49SmVlJc3NzfT39wfGbH/ujYULF2Kz2QLy67ea+fvgz3ngf7bKysqorKyktraW3t5erFYrNpsNi8VCW1sb2dnZLF++nOzsbJqamjhx4gT5+fns3buX2NhYMjMzsdlsdHZ2cvToUWJjY4mLi0OW5TGvV2trK/X19Wi1WsLDw4mOjh40vkZERBAREYHRaKS1tZXGxsbpvH1TwpxQBpYuXcrSpUv51Kc+xSOPPMLevXvZuXMn9957L1/84hcB36Didrv5wx/+QFtbG0ajkR/+8Ifk5ORgs9n4+c9/zt69e3nooYf46le/Sm5uLkDA7/PQQw+RnJzM9773PRYtWoTFYuFPf/oTH3zwAe+99x6ZmZmsW7eO++67j9jYWHbt2sUrr7zCn//8Z9avX09oaCgqlQqr1cqRI0f429/+xv79+/n1r39NXl4emZmZ7Nu3j927d/PYY49RUVHB5s2befTRR3n55Zd5++23KSoqwuPxYDAY2Lt3L7m5uXzuc5+jrKwsULd/uZVgdnPllVdyxRVXcM899/DLX/6Sp59+mry8PK6//nruuOMOJEnC6XTS09PDH/7wB2pra/nEJz7BtddeS05ODsePH+cf//gHr732GllZWVx66aV8/OMfB3wz+EceeYTa2loiIyP57W9/S3h4OFarlbvuuoudO3fy2muvsXz5clatWsXTTz/N3XffTUlJCT09Pfz2t7/l0ksvDSiIdrudZ555hsLCQkpKSvjtb39LdnY20dHRvPzyyxw8eJA///nPVFVVsXnzZu666y5ee+01/vKXv9Db20tERARJSUlUVlaSmJjIHXfcwRNPPIHNZsPr9QY1uI6E34dtNptxOBxs376dFStWTNVtEpxGrVbzjW98g7vuuos33niDN954g3//+988+OCDrF69OmARam5u5uGHH2bv3r1YLBb+/ve/ExcXh1qt5r777qOsrIz333+fiy++mKioKIxGI52dnZSUlPDlL3+Za6+9lo985CNcddVVNDQ0UFRUxL333ktFRQVtbW3cc889rFu3jjVr1vDjH/+YEydO8L//+7+sWbOGhQsXolKpsNlsdHR08IMf/ACAa665hnvuuYe4uDhqa2v5y1/+wp49e9i7dy9f+tKXuP3223n++ecDll273U5KSgoFBQVcd9115ObmcuDAAbRaLSaTKSh3RE1NDSdPngy88IdaElQqFUajkaSkJFpaWqipqZmW+zaVzHplYKC25V9SNHC2OzCaVZIkZFkmMjKSlStXkpycTExMDJGRkeTk5NDU1ERDQwNWqzWQxbCiooJ//etfrF27lmXLlpGXl0dERAR6vZ5LLrmE6urqQDCNP2vc0D74Zy0AJpOJp59+GpfLxdatW1m7di3x8fGEhoayevVqZFmmrq6OwsJCKioq2LVrF1u3bmXp0qU899xzlJaW0t7eTnp6OllZWWRlZfHjH/8YvV7PkiVLAv5UwexmoCVmqHVmoMy63W40Gg3R0dFs3LiR1NRUoqKiWLlyJZmZmURGRtLT00N/fz+KotDa2kp5eTkffPABN998M2vWrAmsvdfr9Wzfvp0DBw5QXFyM0+nE7Xaf1ReVShXog8Viob29nbfeeouYmBhuvPFGcnNziYuLCzwD0dHR5OfnU19fj9Pp5Oabb+bKK69k0aJFPPTQQwHL15IlS8jJyUGn0xEfHw9AeHj4pNxTLpeL/fv343K5uOiii8jMzJx1S8zmOkNlY6C8+Me2gTLr8XhISkpCpVKxYMECwsPDkWWZtWvXYrVaKS8vx2QyYbFYMBqN7Nmzh8LCQvLy8ti4cSObN28mLCyM9PR0dDpdYHWNPxjb34+B/Rv43FRVVbF79268Xi85OTlcd911pKamYjAYWLhwIR/5yEeIj4/nkUceobCwkJiYGC6//HKWLl3KkiVL+Oc//4lWqyUuLo6UlBSSk5P5wQ9+EJjNjyav/hgsu92O3W4nOTn5rJVA/t/VajVGozFg2Z7tzHplYLz4tdSlS5cSFhaGJEm4XC4MBgOhoaEB8xT4zK1NTU0cOnSIu+++m+XLlwciPiVJYtmyZeTm5gads8Dj8WA2mzlw4ABLly4NJPcxGo0ApKWlYbVa2bRpE8eOHaOlpYXi4mI++tGPEh8fH3ARdHZ2kpiYSGJiIgkJCXzkIx8JuEm6u7uHjQY3Go2Ehoai1+vFGuw5hCRJJCcnEx4ezqJFizAajXg8HjQaDTqdDp1Oh8ViweFwAL78Fg0NDVRWVpKdnc3GjRuJiIgIDJirV6/GZDJhMpmCyrHhN6mWlpZy4YUXsnHjRhISEgJKZ25uLl6vl4ULF3L8+PGA2yA3N5d169bx4osvBnIEpKSkkJWVhV6vJzs7G7fbTW9vL263e1iLltFoJCYmZkQXlj/leFlZGYqisH79+oBiLZgZ1Go1kZGRZGVlERISQnh4eMC6FB4ejsFgwOv1YrfbAzJbXl5OaWkpGRkZZGdnk52dDRBIG5+bm4vT6RwzgZF/xt7a2sqBAweQJImkpCRWrVoVKGMwGAL++0cffZS6ujoOHTrEnXfeSWZmJmFhYbz88ssBBTw6OprU1FRSU1MBn8y1trYOa83yP5ORkZG43W48Hs+o7wWVSoVOpwtMPGc755UyoNVq+eMf/wj4hLa6uprjx4/z6quvkp+fT0NDAxqNJrDc6sSJE9TU1NDb20tmZibp6emBuvR6PTk5OfzqV7/C6/Wi1WpRq9Wj3tSGhgYqKiqor69n3bp15OTknCXcaWlp3HzzzbzwwgtUV1ezZ88eNm7cSGJiYmDpmUqlIi0tbdASnvr6el566SWeffZZamtrz2r7pptu4pZbbuHiiy8+K9BMMDsxGAwkJyfzyCOPoCgKWq2W48ePc/LkSV544YVANj6Xy4XX60VRFI4ePUp5eTlGo5Hk5GRSUlIG1ec3w/rdTWMphidPnmTv3r3Y7XaioqLIzc1Fp9MNKhMbG8vNN99Md3c3lZWV5Ofno9frWbZsGZGRkcTGxgaW9g48t7GxkbvvvpuKigpaW1vPavumm27iD3/4A2FhYcMOqGazOZA06/LLL+dzn/vcmPEFguklKSmJe++9N/CC6+3t5fDhwxQUFPDqq6/S2dkJ+F6q/niUsrIyKioq2L59+6B4D0mSMBqNPPHEE8CZl6fFYhm1D3V1dbz33nts27Yt8BIfSHZ2NjqdLhBkeODAARwOBzqdLpC0KiQkJKDQDKSzs5OtW7cO6y5YuHAhmzdv5ve//31AWTAYDCMqA34rwmzMkTAc55UyAD4hbGpq4siRIzQ0NGC321mwYAE5OTloNBoaGhoA343q7+/H4XAEglQG5gzwm6WGvsxHUwYsFgtmsxlZlgM/QwVBp9MRExMT2Eipt7c30O5A98PA34FAAI8/QGYo/mCwuSJ4gjPmxP7+ftra2tizZw9msxmn08nq1atxOp309fUNWvpnsViwWCyB2bbX6x0UxTzcqpHRfPZWq5Wenp7AcsPhZFar1ZKYmIjBYECWZUwmU2DWN9CsPHSG7zenWq3WEWV2OBRFwePxUFJSQmlpKZdffjlr1qwhPDxcWL1mGP+4WFZWRl1dHUVFRXi9XnQ6HWvXrg0EofqVBYfDgdPpxOl0BsaogXUBActpMNjtdmw2WyCYcDjZ9q+eio2NxWw2Y7VacTqdZ7nLhrNIDXzGhj4H/mBg/6ZiWq32rO80EL+FxG9RmO2cN8rAwJSrJSUlPPvss1gsFuLj4/nkJz+J0+lEp9MFojoVRcFutwdexBaLJbAyYaL4X9T+wczvjhiIVqtFo9Gg1+uRJAmr1RqIRRgNv9bsdwcMxa+hihUDcwf/y7exsZGioiL++te/kpKSwoIFC7j11lvp6+ujvr5+UC4Ch8MRkFv/QDuZlNv+1TQDdwIdThmIiYlBr9cjyzJWqzUoH6hKpcJgMIwqs0PxXxOr1UpZWRkHDx7k3nvvDfhm/WX8CHk/t/jvzdGjR8nPz2ffvn2sXbuW9evXs3XrVlQqFYWFhYGy/lgrt9uN2WzG5XIF7t94751/0uafuPljYobDvyS1ubkZk8mE2+0etMviSJMmSZIIDQ0dVtEwGo2BcdZgMKDT6bDZbINyzQys25/jQ6fTzQlr7XmjDHg8HiwWC9/97nfp6ekhLi6OH/zgB+Tm5hIeHo7JZKKhoWGQZhgREUFISAiyLLNr1y4URWHjxo0T7kNUVBSxsbFIkkRXVxf19fUjzspUKhUhISEsWLAgKM04IyODL3/5y9x2221jxgwI5gb9/f00NDRw//3309bWxq233soll1zCokWLCA0N5fjx42cFJoWFhQVerAcPHiQkJISrr756wi/FsLAw4uPjkSQJk8lEbW0t2dnZZ72o/YqmRqMhNTU1qMyJaWlpPP7446PGDPjjHfzIskxHRwePPPIIS5Ys4Zvf/CYLFy4UOTJmCU1NTTz44IOcOnUKWZZ55plnSEhIIDQ0lJ07dw5S+tRqdcB1ZLPZ2LFjB+vWrWPjxo0TUmD9Y3ZYWBh6vZ7m5mba2tpGLKvRaDAajURFRREWFhaUDMXHx5Ofnz9izIB/fM3KyiI3N5fS0tJAjo+B9cuyjM1mo7m5mRUrVsyq9N8jMeeUAb+/f6g502q10tbWRk1NDVqtlq1bt7JgwQISEhIC5tOBWptKpSIuLo6IiAg0Gg1VVVXExMRQWFhIWloaYWFhqNXqgJnJbDaTkJAw7Bpnf50RERHExcURGhpKb28v1dXVOJ1O9Hp9wN3gX+ftNzctWrSI8PDwszTVoVnitFotkZGRIuHKHMQ/2/X7/f309/dz8uRJmpqacLvdrF27loyMDOLi4gCGHTATEhICsSQlJSXodDoWL15MbGwsRqMRr9eL2WzGbDaj0+kGpY8dbkYUExNDWloaarWanp4eysvLufDCCweV8dfp30MhKytrkO/eL6vDWRSCTQ/uP7+xsZG2tjZSU1MDyWP8FgG3201jYyOyLKPT6UhISBjWuiCYHAPH1oHuTlmW6e/v5+jRo4SEhJCSkkJGRkZAoRtomfSfr9FoiIqKIiIigs7OToqKikhNTWXVqlWEhISg1Wrp6+vDbDbT2to6KM30cAquSqUiIiKCtLQ0LBZLYEfQ6OjoQZYjWZYxm80BZWDg+D9axli1Ws2CBQvGvEZpaWnk5ORQWFhIb29vQGb943xXVxc9PT24XC7S09PJzs6e9VasOeOA899Ef2CK2+0OCKl/LXJlZSXt7e3o9XouvPBCoqKiBgnnQCGQJIm0tDQSEhLQ6XSUlJQEcgfU1NRgNpux2WzU1tZy9OhR3njjDU6cOAEMXjY2UKDi4+MDgX9tbW0cPXo04N/1t+9yuejp6cFms6HX6wftCT7w+0zF+uyRBumRPhdMLQP98H6Z9SsEfpk9dOgQPT09GI1GLrroIhITE8+6PwN/z8rKCuw4uXv3bl566SXy8/NpbGzEZrNhNps5ceIEH374IQcPHjwr2HSoXKSmprJixQp0Oh3Nzc3s2bMnsPR2oMw2NTXhdDoJDQ0NLGeEMy8L/8x/vDI1sB23283Ro0c5fvw4V199NStXrgwsUfSvpvGbpgsLC8cMNBOMD/+98wf+Df3d7XZjMpk4cuQIYWFhrFq1atDS0aH33h9fsGDBAhYsWBDYNfPxxx+noaEBk8mE0+mkoaGBgoIC/vGPf9DZ2RkYn4f2y098fDwrV66kr6+PxsZGTp48eZbMut1uWltbiYqKYv369YGofv+Y6h9jJzoGLlu2jA0bNuD1emlubqaioiIQs6UoZ7Y1drvdgXwfs505YxnwC+LJkyepqKgIvKiLi4tZtmwZISEhgWWFbW1t7Nixg9TUVJxOJ+Xl5Rw+fDhwXmdnZyBrVXR0NHfeeSf//ve/aWxs5IknnuDll19Gp9MF8shHRkbywx/+kKysrIBPyWAwoCgKdXV1qNVqTCYTubm5aDQavva1r/Hqq69y/PhxfvnLX3LRRRcFkryUlZXxwgsvEBERwbJly7j00kvR6/X09PRw7Ngx2traAi+KuLi4SVsCXC4XfX19WK1W7HY7XV1dAQVFmF6nF6fTycmTJ6mtraW9vR3wRUJ3d3cTFRWFTqcjLi4OnU6HyWTizTffZPny5URGRrJnzx6OHj1Kb28vUVFR1NfXc/jwYWJiYli8eDGbN2+msrKSuro67r///oA5VpZlQkJCiIyM5Fe/+lVAcQgNDUWj0QRSY9fX17Nnzx5WrlzJokWLuPbaaykrK+Pw4cM888wzrF27lgsvvJCuri4qKip44oknSE9P5+KLLyYpKQlZlgNZC1tbWwNLrSaC2+3m1KlTPPHEExw4cID29nYee+yxQF58ODPb6+/v58ILL+SBBx6Y9k2e5ht+V2tBQQE1NTUoikJhYSEGg4Hs7OzAUsDw8HDq6urQ6XR0dnbi8Xjo6enh3XffpaSkBCCQKri2tpb169cTExNDcXEx1dXVgSXV/hVaDoeDnJwcrrzyyoCchoeHo9FoAjtaGo1G3G43PT09hIaGctddd1FaWkp9fT2/+MUv+PrXv86yZcsCZv7jx49jtVpZvXo1n/rUpzAYDDQ0NJCfn4/VakWj0dDd3T3hjeaWLVuG0Whk69at1NfX8+STT5KTk0NISAhOp5PHH3+cxsZGLrjgArZv386aNWum8lZNC7NeGVAUBavVSldXF0eOHKGmpoaenh68Xi/V1dWBTFjh4eHExMSwYMGCgPm1sLCQpKQkzGZzwMwuSRI9PT3U19cTGRlJSkoKmzdvprCwkPr6erq6uujo6Ai89BcsWEBERAQLFiwInJ+QkBDIeV1ZWYndbickJASPx0N0dDRr166lqqoKk8nEqVOnCAsLC0SfNjQ00NXVRV5eHosXLyYmJoZTp05x8uRJ6urqMJvNeL1eioqKcDqd2O32QabS8dDU1ERXV1cgzbLT6aS1tZWioiLCwsJYs2YNISEhIs5gGujs7KSzs5N9+/YFkvX45WHPnj3k5OTgcDhIT08nPj6e3t5eDh48GNhHw+FwBGTWarUGdutMSUkhNTWVrVu3Bszm/hUyKpWKqKgosrOzSUpKIjY2NpBrIzk5mcTERGRZpqqqKpAOWaVSER4ezqZNm5BlmZ6ensAsB3yBtS0tLWg0GnJzc1m5ciU6nY6TJ09y/PhxOjs76evrA3z52j0eD6mpqURERAQts9XV1RQVFVFQUEBlZWVgD4XhiI6Oxu12Ex0dPanAScHZ1NbWUlFRQWVlZWCGfuLECTQaDWFhYSxduhStVsuSJUuwWq20trZy6NChwCoT/w6HarWa1tZWwsLCSE5OJj09HaPRyMqVK2ltbaW3t5fy8vJAlH1KSgphYWHk5OQEAvT8+1BERUUF5NX/eUxMDBEREaxZs4a6ujpaW1s5duwYJpOJhIQEysrKAi4Hf66X5uZmTp48SXFxMXa7Ha1Wy6lTpygpKcFut5OXlzcuM35YWBhJSUls3bqV6urqwPOr1+txu910dXUFrGj+d8hsZ048TbW1tezevZtvfOMbgz5/5ZVXeP3110lLS+Ouu+7innvu4YYbbuDQoUO89957nDp1ipycHL7whS+wbdu2QOIU/4ZE3//+94mIiAiYdg4fPswrr7yCxWJBp9OxcuVKbr75ZrZu3cqiRYsCy5o2bdpEf38/+fn5PPvss2RkZPDVr351UAKLqKgoNm3axKOPPspzzz3Hn/70J2JjY8nOzubCCy/kjjvuIDMzE0mSePrpp/nPf/5DcXFxwET2s5/9jCVLlrB161buvvtukpKSxnXNFEXhxRdf5MCBA7z44ouBzwsKCigoKCA2NpaXX36ZnJycQWvVBVPDvn372LdvH3/84x8DL1aTycQLL7zASy+9xMc//nG2b9/O5z73OY4cOUJBQQGPPfYY2dnZ5Obmct999wWWQ7333nu0t7djMpkICwtj7dq1LF26lMcff5yCggJ27NiBJEmEhIRw8cUXc+WVV3L11VcTGxsbkNnLLruM8PBw9u7dyzPPPMPu3bt58MEHSU5OJiQkhC9+8YusXr2anJwcXnrpJd577z1+8YtfsGDBAhYuXMhnPvMZtm/fTlZWFi6Xi6effprf/OY3g77zt7/9bdasWcM3vvENNm/eHFS8gKIo/O1vfyM/P5+CgoJRy0qSxOLFi8nOzp4T0dlzjSeffJLf//73g2bLr7zyCq+88gr/8z//w3PPPcfq1av57ne/y9NPP83Bgwf51re+xfr169m8eTO33nor8fHxHD16lL179+J2u/nYxz5GREQELpeLX/7yl7z00kvs3buX2tpaoqKiSE5O5q677mLlypVs2rQp0G5qairbtm3D4/Hw2muv0dLSQnd3N/feey+hoaEoisL999/P0aNHeeqpp3jsscfo7+9Hr9ezYsUKli1bxu9//3vi4+PR6XQ8//zz7N27l3feeQfwxev84x//YOfOnaxatYonn3xy3MplXFwcP/7xj3n99dd57733+M53voPH40Gv13PdddcFrslcscDOCWUgPT2dq6++mhdeeOGsY/7EFVlZWajVaq6//nq2b9/Obbfdhl6vJywsjKysLGRZxuFwsHDhQqKiooiJiSE0NDTg/7/oootYsWIFV199NR6PB5VKRWRkJKmpqYFB1R+AEhoaypYtW4iLi8Nut2M0GsnOzg6sJAACaVPT09Ox2+2BpY2hoaHExcWRnJwcEL5PfepTXHzxxZjN5oAy4N/rPjY2dkKJViRJ4mMf+xhbtmzhlltuOeu4SG88vWzcuJGFCxeybdu2s2I/JEkiNTWVuLg4QkJCuO222/joRz8aeNmHhYWRnZ1NTEwMa9eu5ROf+ARRUVEsWLAgsAeGXq/nox/9KJs3b+ZTn/oU4At+io+PJzExkcjIyEEy61+18uijjwZWsmRnZwdWsqjVanJzc4mKimLLli2BZVshISGEhoaSlpZGXFxcIBj3tttuG7Tyxi+zUVFRLFy4MOiZkCRJ3HHHHVx77bWBDZFGKxsTE0NiYuKsD8aai3zmM59h48aNIybK2bRpUyAyPyUlhZ6ensA9iYmJISEhgfDwcJYsWUJERASxsbEBc79KpWLlypXExsZy4403YrVaA26HrKysgNUVzsR0XXXVVaxdu5ZPf/rTREdHB/Kz+Mv5d31NS0sLRPSr1epAWuHExMRARtYbb7yR7du381//9V8AgRTLRqMx8KyMB38f9Ho927ZtIycnh49//OMoioJKpSI5OZnY2NhA4OJcYNYrA5IkBaLoc3Jyxiy/ePHiUY8vWrRo2M/T09NJT09n9erVY/bHn097tKjTqKgooqKiyMjIGLPPy5YtY9myZWOWGw+S5NtGc6TvK5he/BailStXjll2pDLR0dFkZWUNe0yj0ZCTkxPUM+FfkhUREUFmZuaI5WJjY4mNjR1zGZRarWbFihVTsmGQJElzIrhqPrB8+fJB0fwjER4ePuLYFx0dPewYrFKpSEhICMpa5H95DkxdPFyZ8PBwwsPDB2WOHYm8vLwxy4wXf4BkWlpaIDZnLjNnVhMIBAKBQCCYHoQyIBAIBALBPEcoAwKBQCAQzHOEMiAQCAQCwTxHKAMCgUAgEMxzhDIgEAgEAsE8RygDAoFAIBDMc4QyIBAIBALBPEcoAwKBQCAQzHOEMiAQCAQCwTxHKAMCgUAgEMxzhDIgEAgEAsE8RygDAoFAIBDMc4QyIBAIBALBPEcoAwKBQCAQzHOEMiAQCAQCwTxHKAMCgUAgEMxzhDIgEAgEAsE8RygDAoFAIBDMc4QyIBAIBALBPEcoAwKBQCAQzHOEMiAQCAQCwTxHKAMCgUAgEMxzNFNZWXV1NQcPHpzKKgVzmI6ODtxuN4qizHRXzsLr9WI2mzl16pSQWQEAzc3N1NTU4PF4ZrorwyLLMnV1dYSEhMzKZ0pw7ikrK6OzsxO32z3puqZUGaipqeHIkSNTWaVgDmMymXC5XMiyPNNdOQtZljGZTNTU1BARETHT3RHMArq6umhtbZ2SgXU6kGWZhoYGAGw22wz3RjAbqKuro7OzE71eP+m6plQZePbZZ/n3v/89lVUK5jCKouByuWblTMvtdlNSUkJxcTFqtXqmuyOYBSiKgqIos1YZ8Hg8vPTSS0iShEolPLwCn4IoyzJr166ddF2TVgaysrJQq9U88MADk+7MXMdisdDW1sazzz7L5s2bWbVqFQkJCTP64DY3N/POO+/gcrmIiIjguuuuw2AwoNVqz1kfcnNzWbx4MTqd7py1ORqbNm0iNjaWzZs3nzNzq9frpbW1lbKyMo4dO8bq1atJS0tj+fLl56T9kaiurqahoYGysjJWrFjBRRddNKP9sVqttLe3869//YvU1FTS0tLYvn07Wq0WSZLOWT+WLVuGwWCYNS/dSy65ZNb0ZaYpKSnhwIEDLFiwgNTUVFavXj3TXZpxUlJSSE9Pn1Qdk1IGJEkiMzOTzMxMtm/fPqmOnA+0tbVRVFTEc889x9atW/nMZz7D8uXL0Wim1AAzLo4ePUptbS09PT0kJiby5S9/mfj4eMLDwwHO6QA7W9i4cSMbN248Z+3JsozL5eLgwYO8+uqrnDx5kgsuuIAtW7Zw4403nrN+DMf777/Pvn37aG9v59JLL+VHP/rRjPans7OTsrIy/vOf/5CVlcXatWu5++67iYiIOKcK7GzjoosumnFFbbbw3HPPUVdXx8aNG9mwYQO33377THfpvEComuc5ubm5/OY3v2HRokXU1tbyxS9+kf/85z+YTCYRhHSOaG9v59ixY3znO99h9+7drFu3js9+9rNcfvnlM921WUdMTAzLly/nwQcfxGg08uyzz/Kb3/yGnTt3znTXBILzmpmbsgrOCQaDgbS0NLZu3YrBYODQoUMcPnwYnU7HVVddRUhIyIxaLs5nvF4vJpOJo0ePcuTIEVwuF4sWLeKCCy4gOTmZ0NDQme7irEOtVhMaGsrq1atpaGjA4XBQWFiI0WgkOjqaFStWYDAYZrqbAsF5h3gLnOdotVpiYmK49dZbWbVqFQcOHGDHjh0UFhaybt064uPjAy+l+egymC78wZP19fW8/vrrvPbaa6xcuZLLL7+cz3/+8+h0OuEDHoGQkBDWrVuHWq0mIyODe+65h97eXvr7+0lPT0ev1wtZFQimGKEMzBOioqJYsWIFDz/8MP/+97/Zv38/3/ve9/joRz/KTTfdRFhYmBhgp5DW1laqqqr47//+bzweD6tWreKBBx4gIyMDnU4nrnUQ5ObmEh8fj9lsJj8/n+effx6j0cjGjRv56Ec/OtPdEwjOK4QyME/QarWEh4ezatUqKioq6Orq4tSpUxw/fpzMzEzWr1+P0WgUy+wmidfrxW63U1ZWRnFxMc3NzSxdupRVq1aRl5dHeHi4sAgEidFoRKPRsGHDBnp6eqioqKCoqAiNRsOSJUtITk4mJCRkprspEJwXCGVgHqFWq4mPj+czn/kMF154Ibfddhs7duzg0KFDPP7442RkZBAWFjbT3ZzT2O12ampqePTRRzl06BCLFy/mU5/6FDfccIPwdU8ArVbLtm3biI6OJiMjg5/85CdUVVXh9Xq58847yczMnOkuCgTnBUIZmEf4TdPh4eFkZGRw3333sXv3bnbt2sWf/vQnNm/ezC233IJOpxMWgnGiKAqdnZ2Ul5fz8MMP097ezpIlS/jud79LXl5eIMeCcA+MD//1SktLIyQkhIaGBk6ePMkLL7xAaGgo69at45JLLhHXVSCYJEIZmIfodDoiIyPZvn07PT09lJSUcPToUTQaDRs3biQ9PR2j0YgkSWKQDQKv14vH46GmpoaSkhIOHTpEXl4eS5cuZcuWLcL9MgVEREQQGhrKBRdcgKIo7Nu3j8LCQgBWrlxJeHj4lKRkFQjmK0IZmKeoVCrS0tL41Kc+xQUXXMBdd93Fe++9R2lpKQ8++CArVqwQ/tggsVqttLa2cv/991NbW8uCBQv45je/yYUXXij2PZhCVCoVl112GdnZ2aSmpvLHP/6RQ4cO4fF4uP7661m6dOlMd1EgmLMIZWCeMtBlkJaWxu23305xcTH79u3jxRdfpKamhhtvvBGNRiNmtSOgKAq9vb0UFRXx6quv0t/fz8KFC7n11ltZsmQJRqMREK6BqUKSpEDcy7Zt26iurqaqqoo333wTg8FAb28vmzdvFvIqEEwAEdY8zzEYDMTGxnLdddexZcsWFEVh165dvPfee3R1deF0OgMbuAjOIMsyHo+H5uZmCgsLefnllwNR7jfeeCMZGRnnPJ/+fCEyMpLly5dz+eWXs2rVKoqKijhw4AAFBQVYrdZZu9GQQDCbEZYBAZIkkZaWxrXXXsvSpUv58Y9/zL59+/jyl7/Mt7/97UD2QsEZ+vr6aGtr49vf/jZdXV2kpKRw//33s3z5ckJDQ4UScA64+OKLycnJQavV8tprr3Hw4EEkSWL79u2sX79+prsnEMwphDIgCJhfIyIiyMrK4tJLL6WkpITS0lL27NmDw+Hg8ssvR6vVzvs18rIsY7VaKS4u5sCBA/T29pKUlMTFF19MdnY2UVFRIvDyHCBJEnq9nri4OLZt20ZLSwtlZWXs2rULnU6HwWBg8eLF83pzI4FgPAhlQBDAYDCQmJjILbfcQmZmJrt27eKtt96ipqaGLVu2EBYWFhhc5+PLTlEUZFmmq6uL3bt38+STTxIdHc3q1av58pe/THh4uNjn4RwTGRnJxRdfjMPhIC4ujl//+teAL9gwIyMDtVo97xVYgSAYxMglOIu0tDRCQ0N57LHHeOKJJygoKOCee+7hpptu4vLLLw+smZ9v9PX10dzczPe+9z26u7uJiYnh5z//OYsWLSIiIkK8dGaQbdu2sWjRItxuN4cPH+Z3v/sdarWatWvXsmHDhpnunkAw6xHKgGAQfvNrdHQ0K1euZPXq1bjdbsrKysjMzCQ6Opq1a9fOq412ZFnG6XRSXl5OaWkpDQ0NJCcns2TJEvLy8khISBAR7DOMP83zli1bMJlMdHR0BGII4uPjSUlJmbdKrEAQDEIZEAyLwWAgOzubz3/+82zatIn/+q//4qWXXqK4uJhHHnmE6OjoeeEbVxQFj8dDV1cXzz//PP/5z38IDQ3lsssu4wtf+AJRUVFCEZglhIaGcu211xIZGUlycjK//e1vqa6uRpZlbr75ZmJiYs57eRUIJopQBgSjkpSUhE6n44EHHuCDDz7g+PHj/OpXv+Kiiy7iIx/5CBqN5rweYPv6+qirq+PBBx+ksbGRuLg47r33XrHp0CxmxYoVxMfH09LSQm1tLX/+85/RarWsXLlSuAwEghEQyoBgVEJCQgIR242NjVRXV3P48GEiIiJYsmTJebu/vCzLeL1e6uvrKS0t5ejRoyQlJZGXl8emTZuIjo4WZudZSnR0NEajkc2bN+NyuSguLubYsWNIksTChQsJDw8XqwwEgiEIZUAwJjqdjuXLl/OFL3yBCy+8kLvuuosXX3yREydO8Mtf/pK0tLTzLore7XZjMpn4v//7PwoKCpAkiU9/+tNcf/31JCQknHfKz/mGTqfjtttuIzc3l4SEBJ566ikOHjyIVqvlsssuIyUlZaa7KBDMKs6vEVwwLfhffHFxcahUKr70pS9RUlJCSUkJzz77LGvXruWqq65CpVLN+ZekoijYbDYqKyt57rnnOHXqFNHR0dx2221s3ryZyMjIeRErMdfx36OFCxdyww030NbWRmtrK08++SQAq1evZvny5eI+CgSnEcqAIGjCw8MJCQnhIx/5CB6Ph/z8fHbv3o3T6WTDhg1ERkbO6TwE/jwC7e3tVFRUBIIFc3JyuPbaa4mKihKbN80xEhISiI2NZdu2bRQUFPDCCy+wYsUKNBoN2dnZ6PX6886qJRBMBPEUCMaFWq1mxYoVREVFsX79eu69915efPFFGhoa+O53v8vSpUvnbHS9w+HAbDbzwx/+kMrKSjweD3fffTfbtm0jMTFRBAvOUVQqFbfddhvr168nIiKCt99+m/fffx+VSsXGjRvJysqa6S4KBDOOUAYE40KSJDQaDbGxseTl5XH11VdTXV1NSUlJYHOjiy66aE65DBRFweFwUFFRwe7du2lqaiIyMjKwV0NsbOyc+j6CwfhzZ6SkpHDllVfS0dFBU1MTr776Kl6vF4/HQ3Z29pxVYgWCqUAoA4IJERERQVhYGDfffDM7d+5k586dvPnmm7S1tbF582Z0Ol1gcJ3NL1G/a8BkMnHs2DGeeOIJFEVh/fr13HXXXcTGxopNms4TEhISuOqqq2hra2P//v0888wzhIeHo9PpSEtLQ5IkYf0RzFuEMiCYMJIksWrVKuLi4khNTeWRRx7h9ddfB+CTn/wk69atm9WKAIDT6cRsNvP973+fmpoa7HY7//u//8vKlSuFa+A85cYbb2TNmjW43W4KCwvJz89Hp9OxdOlScnJyZrp7AsGMIJQBwYSRJAmDwUB8fDyrVq1izZo1VFZWcvToUbKystBoNKxYsQK1Wj3rlAJFUXC73VRVVVFaWkp1dTV6vZ6LLrqIpUuXkpqaOiv7LZg84eHhpKamcvHFF2Oz2Th16hS7du3C5XJhNBpJSEgQQYWCeYeQeMGkiYiIYMWKFXzuc5/j0KFDfP/730dRFGpqavjZz342yMw+G16ufteAzWbjvffe45lnnqGnp4drrrmG733ve6SkpKDX62e6m4JpwC9/sbGx3HHHHWg0Gt5//33++te/0t7ejsFg4NJLLxWKoGDeIZQBwZSRl5dHdHQ0brebt99+mzfffJOIiAguvfRStm3bNtPdC+B0Ouno6ODnP/85lZWV2O12HnjgAZYtW0ZycrLITjePuPLKK1myZAlOp5Pm5mYeeOABFEVh8eLF5ObmznT3BIJzhlAGBFOCJEmEh4cjSRKbN2+moqKCzs5ODh8+TFxcHCkpKYFMhTM141IUBa/XS0NDA5WVlRQWFqLX61m8eDHr1q0jJSVFBAvOE/wyGB8fj8FgYNOmTezbt4/6+noOHz6M1+slPj6e8PBw4TIQzAuElAumlNDQUDZt2oRWq2X9+vV897vfpaOjgxMnTvDTn/6U6OjoGeub3zXwz3/+kx07dtDW1sbnPvc57rzzTtLT08XSsnlKeHg43/zmN1m4cCERERE8/PDDbNy4EZ1Ox9atW4mKiprpLgoE045QBgRTin/GlZWVRUhICF/5ylcoKytj586dLF68mDVr1rB169Zz2id/sGBzczNPPfUUBQUFeDwevvOd77Bx40YSEhJEHoF5iiRJKIqCJEmsWbOGyMhIuru76evr449//CMqlYq8vDwyMjKEfAjOa4QyIJgWYmJiCAkJ4fLLL8dsNlNcXMz+/ftRqVQsXryYyMjIc2J+VRQFRVHo6uqiqqqK999/H4fDQVxcHFdccQUpKSmEhYVNez8Esxf/Sz41NZXY2FjWrVvH0aNHyc/P5/jx46jVahITEwflzhAIzjeEMiCYNvyR2fHx8WzYsIH//u//5uTJkzQ0NPD1r3+d1NTUae+D1+vF5XLx0EMPcfDgQaqrq/nud7/LNddcQ15enhjcBYMwGAx873vfY//+/YSEhPDYY4+RmZkZCDCNi4ub6S4KBNOCUAYE04YkSajValJTU5Ekieuuu47m5mb27NlDbm4uy5cvZ/369dNiflUUBY/HQ11dHR988AHFxcV4PB7uvPNONm7cSEpKilg+JhiE32Wg1+tZtGgRn/zkJ7FYLFgsFp566iluueUWli9fHpBngeB8QigDgmknPj6eqKgorr/+enbs2MHu3bt5//33sVgsrFixAq1WO6UzdEVRALBYLIGtiNvb20lPT+e2224jNTVVBIUJhsW/9XFaWhopKSmUlpZy6NAhXn755UAcjD8pkchOKTifEMqA4Jyg0Wi4+OKLSUpKIj09nb/85S+UlpZiNpu55ZZbWLRo0ZS15fV6cTgc/PSnP6W0tJTKykp+9KMfsWnTJhYtWiSWignGxL8h1ze+8Q1KSkpQq9W8+OKLvPPOO/z6178mJyeHpKSkme6mQDBlCNVWcE6QJImQkBBSUlLYuHEja9euJTY2lv3793PkyBEqKioCM/qJ4s8jUF9fzwcffEBZWRkul4vLLruMFStWkJGRgVarFTM6wZj43QCRkZFkZWVx9dVXk5qaisvl4q233qKkpISuri5kWZ7hngoEU4OYIgnOKYmJicTHx9PT08PevXt56KGHiImJobe3l0WLFk3Yj+9XJNxuN8ePH+fxxx/nxIkTrFmzhrvvvptFixYREREx1V9HcB7jdxmkpqbyhS98gd7eXnbv3s2jjz6KLMtERUURGRkZKCcQzGWEMiA450iSxPbt21mwYAFGo5F3332XiooKNBoNF1xwAUuXLh13nbIsY7FYePDBBykqKqK8vJx77rmHVatWkZeXJzILCiaM32Vw++23s2XLFn7+85+zZ88eDh06xC9/+UsyMjKEy0Aw5xHKgOCcI0kSUVFRpKens2XLFsrLy6mrq2P//v1ERUURFhYW2DVwLPx5BJqbm6mtreXYsWPYbDZyc3NZs2YNOTk5hIaGnoNvJThf8c/6k5KSUKlUbNu2jYKCAhobGzlw4AAOhwOj0UhYWJhwQQnmLEIZEMwYsbGxXHXVVUiSREFBAf/zP/+DyWSitbWVL33pS0GvMPB4PLz77ru8/PLLHD16lI9+9KN87WtfY/ny5cIiIJgy1Go1SUlJ/OhHP+Lxxx/ntdde4xe/+AUf//jHCQsLY9myZULeBHMWoQwIZgz/jGvNmjXExMTQ0tLCqVOnePbZZ4mLi2PVqlUsX758xPO9Xi/d3d088cQTHDhwgJqaGr75zW+ybt06cnJy0Ol0wpcrmDL8sqTRaLjyyivJysriN7/5DadOneJnP/sZ9913H1lZWcJlIJiTCGVAMOMkJCSg0+nYvn07nZ2d1NbWUlBQgE6nIzk5maioqEFWAn+wYHd3N7W1tezZs4euri7Cw8O54IILyMnJmdENkQTnL/5gwczMTKKjo1m1ahXFxcUcO3aM4uJiAKKiotDpdMJlIJhTCGVAMCuIjIzk1ltvJSEhgX379vG73/2OiooKWlpauOOOO85KEiTLMs899xy7du3iwIED3H777XziE59g8+bN6HS6mfkSgnmDWq0mOjqan/3sZ7zyyiv8/e9/5xe/+AVbtmzhxz/+MVlZWSJWRTCnEMqAYFbgT13sj/w/efIkvb29vPbaa2RmZrJ48WIWL16Moii0t7fz7rvvsmfPHpqbm/nc5z7HJZdcEkgoJFwDgunGL2MhISGsW7cOlUrF448/TkdHBw8//DCf+9znyMnJISYmRsijYE4g7FiCWUVaWhrr1q3jiiuuIDIyksLCQvLz86moqMDhcGCxWGhsbOQ///kPJ0+exOPxcP3117N+/frAfgMCwbnAv+QwNzeXa6+9lsWLF+N2u3nttdcoLS2lubkZr9crEhMJ5gTCMiCYdYSEhPDpT3+a7OxsFi9ezJNPPkl+fj7d3d2cOHGC2tpaPvzwQ7761a9y8cUXs2XLFrRa7Ux3WzBP0Wg0hIeH87//+7/s3buX3//+9/z+978nJyeHBx98kJSUFJHwSjDrEZYBwazDn7o4OzubCy+8kFWrVqFWq3n77bcpKCigs7OTK664gvXr17No0SKxz7xgRvEHFUZFRZGXl8dNN90UyLL5//7f/6OiogKTyTTpdNsCwXQiLAOCWUt6ejopKSmUl5ezd+9eXn75ZdRqNcuXL+fee+9l7dq1JCcnz3Q3BQIkSUKr1ZKbm0t6ejrV1dUcOXKERx55JJC2ODw8HJVKJWIIBLMSYRkQzGpkWaa3txeLxYJKpUKWZRwOBx0dHTgcjpnunkAwCLVajdFo5Dvf+Q7f//73SUlJ4dlnn+UHP/gBtbW19Pf3z3QXBYJhEcqAYNbhTzHc0dFBSUkJ1dXVeL1eNm7cyJIlS4iKiuLo0aNUV1fT2toqzK+CWYPfZZCSkkJeXh7bt29Hr9fT3NzM7t27qaqqwmazCZkVzDqEMiCYVfgHSUVRKCws5K9//SvvvPMOiqLwgx/8gNtuu43c3Fwee+wxXn/9dQ4dOoQsy2JwFcwaJEnCYDCQm5vLAw88wObNm/F4PDzwwAO8/fbbdHR04PV6hcwKZhUiZkAw67BarTzzzDPs27ePgoIC/uu//os1a9awZcsWVq5cGbAUFBYWUlZWhl6vZ8mSJWRkZMx01wWCAGq1mtDQUG677TbWr1/Pgw8+yPvvv095eTn3338/iYmJREZGznQ3BQJAKAOCWYJ/ltTb20tLSwv5+fk0Njai1+vZsGEDy5YtIz4+nvj4eLRaLVu2bKGtrY3W1lYOHTqEXq8nIiKCyMhIkQZWMCvw5yHw75y5bNkyampqKCoqoqioiCVLlmAwGNBqtUJmBTOOkEDBrOL999/nD3/4Ay+++CIxMTHcf//9XHXVVeTl5QXKpKSk8NWvfpU777yTbdu28ctf/pKnnnqKXbt24XK5ZrD3AsHZGAwGMjIyeOihh7j22mvRarXcd999/P3vf6e1tRWPxzPTXRQIhGVgSlAUULzg7Adnn+8zZz/0t4EpErQ6UGtAHwkqje93wSD6+vr44IMPePvttykqKuLWW2/lggsuYMOGDRgMhkHLsfxBWps3byY2NpaGhgaam5v5+9//TnR0NFlZWcJlMAayrGBzebC6vNhcXjxehT67m6ZeGxqVhEqS0KgljDoNGrUKtYRYEjdBJElCpVIRFhbGpZdeSkxMDI899hglJSX84Q9/4Ctf+QqpqamEhYXNdFdnL4ri+3H1g9sGsgfcdnCYwdQIKpVvbNWHg1rn+10wLsQVCwZFAUX2vfBlL3jdZ35XvCDL4HWBuRH6WgEFbD3QWw9dgFbvE9CweFDrQaMHSeX7UWlO/6hBrT3z+TzCZrPR3t7Orl27qKiowGw2c9lll7Fq1SqysrJGPC8nJ4eoqCi2bNnCrl27OHz4MEeOHEGSJBISEtDr9fPS/OrzuCh4ZQWvouDxKnhkBVnxfSbLvr9NdhcdfQ5MNhcur0y31UVVhwWtWoVaJaFTq4gM0aLTqtBrVKikM0qCWpJQqyS0ahWSBCqhKIyKJEno9XqWLl1KYmIib775Js3NzezYsYPLLrsMrVZLSEjI/M1D4A+mlD2+cVV2+35XZN/4qnh9f1u7wdIBHic4+sDSDl2VZ8ZPYyxojb7x1j+WSqrTCoL69I8GkGA+XudRkBQR0jo2shccJjA3gakB2kp8s35zA/S3g8sCdhNt/W6KWt187J89fHtrKJ9ZZWB5ogaN6rTQSSrQ6HzaqzEWQqIgZiHE5kBEKiQuB2MMGOZXUNG//vUvDhw4wFNPPcVNN93ElVdeyQ033IDBYBg1s6B/CaLT6eTVV1/lnXfe4a233uLSSy/lzjvv5MILL5yXsy1FAVlRqO2y0t7noK7LSlWnhW6Li8ZeG90WJ1anF4fbi6W2EFtDGX3le4hYfilxF9zqGydP1yUBWo2KaKOOuDA9UUYtixLCSI0KITkqhGUpEYTpNYTqxbwiGBRFwev10tLSwuuvv86jjz6KRqNh8+bN/PSnPyUmJga9Xj/T3Tz3KLJvnO2qhL4WaC3yjbf2Ht/ftm6fFcDj5LkiG7/fb2Vzmo4NC7Tcvtpwph5J5ZtsafQQlgghsRAaC0krIXIBxGT7frQhpxUFoRD4EU/wUBQFvE5w2aC31ieI1i7frN9u8ikFfa0+c5W9F5wWX3m3A1xecJ/elMTrBg/gVoFqgMC51afLWsHSCdYe6KkFQwQ05ENIjO8nNhtC4yE82XfsPDR79fT0UFxcHFh/ffnll3PBBRewevXqMRUBOGO2NhgMrFy5EpVKRX19PWazmRdeeIGoqCgyMjJISUk5F19nRjHZ3PQ73NR1W+m2uOixumjqtdPncNNjddFlcWJzeTHZXNhcXlweGY+s4HDLuL0ysgIer4zd7T2rbpXbi9urYHV66OhX02N1ERmiJcKg5XBtD9GhOuLD9aRGhRBj1JIabUSn8VkXBIPx784ZGxvL2rVr+fSnP80bb7xBbW0tTz/9NNdeey0ZGRmEhIScvxYCv6XV3gvWTuip8Y2t1g7feOswn/nXbfNZANw2n1tA8YLHfdoa6waPfGbM9eO2+1yxHpfPktAX6mvHEOmbbIUl+SZiEakQleH7LDyJ+W4tOP/eMBNBUQDljHbqF8y6/dB0GLpPQedJ3/FJt+U9Ldg239/mxsHHDVEQGgc5l0PiUkhZA6oM0Bh8Ji5pwAtyjgquoih4PB7a2tp4++232bt3L263m/vvv59NmzaxaNGioOvyD5hLly4lIyOD4uJiDh48yIsvvsjq1auRZZmEhATUavV5M7j6jXnyaQuAV1Zo73PQZLKz62QHVR0WajosdFmceAfY/RTOzPgH/zE6XgWsTg9Wpy/Qrb7bFjimkiA+3EB6rJFNmTEsjA8lRK8h0qBFp1GhUUlIIt5gEJIkERoayurVq8nMzOTIkSPU1NTw97//nYULFxIREYHBYAiUPS8YOsZ6HL6xr6Mcqj6A3jrfGOu2TX6cVbzg8fpcCX46K878rg2BsARIXQeZ232WWX2ET4GQ1GcmXufLtQ8SoQz46TrlM1Gdeg/ain3WAJfFJ1Be99QoAgMZaTB29vnaPf4vnw9MY4D4PIhbBAsvg9Q1PhdDsCP5LERRFJ5//nkKCgp49tlnuemmm9i4cSPXXXcdISEhE67XnwZ2586dxMfH8+c//5klS5bwzW9+kzVr1hAdHT2F32LmUAC3V+FwbQ9VHRZ2neygxWyn1+rG7vbi9sp4vPIgRQCGSMwY4jNQPCVGFldZga5+Jyabi5Otfeg0KkL1GlanRZEdH8oVS5JIiTIQZdRN7MuexxgMBhISEvjFL37BgQMH+M1vfsPvfvc7lixZwi9+8QsiIyMDSsGcR/b4xtSWY9BeBlXv+eKq7CbfTF52+8ZZptJrPYLUuh1gbgZLF9Ts9ikHEcm+iVf8UljyMdCFg/Y8ufZBMn+VgYCZqhv6T/uoeuug9Tj01PncAFOpAAyVy5EGY0X2/fhXJfhx9vu0a1sXRKRAdBaKMRZ0ob7q5ogW29PTQ2NjIwcOHKCuro7c3FzWrl3L6tWrCQsLm3DAn//7x8TEkJeXx8UXX0xtbS29vb3s2LGD0NBQsrOziYuLmzPXaiCKoiAr0GKy02tz0dBjo7jJTGOPjcr2fnpt7jMm/nHM+kdCGlLPaNV5FQWvR8HpkZGAXpsbnVpFr80FSGTHhZIcaSA7PhSjToNBK3aYBALBggsWLGDZsmVcdtllHDt2jOrqat5//33Wr19PZmYmOp1uTsosymlTfl+zL+ivrcQ3+++t9U2+3LbBs/dh62DisqxII5yrnA5U9IDb6rMGuKy+tqw9viIRKb6fmGxf/MF56KYdyvn/DQcyMFZS9kJ3NTQegqp3oemITyCmi6Gj63joa/b9NB2CyDSUmGxY81mU1A0QZURSSSiKMqsHDL9pu66ujldffZVXX32VmJgYvv71r3PNNddMyVJA//dftmwZubm51NbWcvjwYf7v//6PmJgYPB4PcXFxs/5aDeSMS0DB7VU4Ut9LcZOJt4pb6bW5cXnPKKwB6QriqwUlicMUGO08/9PllRVOdVg41WFhT2UXeUnh5CaGcceWTFKjjSRGnFH45sp9mC4kSSI8PJxVq1axYMEC7rnnHo4dO8aDDz7I9773PeLi4gIWrTlxrQaNsR6flbN2NzQfheIXfKuuxjPJGtdXHiKdo547oKzi8U0Mmw773gMn34KU1ZC+Bdbe4XPbaue+e3Ys5pkycHrG3XjId+Or3vdFqfpNVTDyaDcpDZUzo/RkZ22WdnBZkQ/+jReNfVSEbeaTG9JIjDAQGzZ7o5A9Hg9vvvkme/bs4aWXXuKaa65hzZo13HDDDURFRU15exqNhi996UusW7cOnU7HK6+8wsGDB9HpdGRnZxMbGzvlbU4HsgKn2vspaTazp7KTk+39mGxuem0uPEP8AOMRq4mK4GjnjXSsvttGR7+DynYLixLDWJIcwQ2rU4k26gjRCSsBgF6vJz4+nrvvvpuioiJ++9vf8vTTT1NQUMD9998/KI5gVqPIPiWgZhd0VED1B2eCAcerCAxb/2gHx/kE+Osa9HJXfPEMbSU+S3HjQYhfAgsvgfStvsBDRTkvFYLzXxnwa6r+hEAdFb4b3HTY57vyDslYN9I9nsy9P8s9MJxGEKSW4HUhu6zYrX1U9Zk4qu0lOyGM7LhQMmJDSYwwoFFLs2rdd19fH11dXRQUFFBTU4Ner2fNmjWsWbOGxMTEKZ/x+OvLyMjA4XCwZcsW3nrrLZqamsjPz0etVqPVagkPD5+Vsy2/S6DX5qLH4uJofS/FTWaONZjo6HfgHhoMEGy9TF+kSaDuYRqxu73Y3V56rG5sLi9Wp5eMGCMLoo2kxRiJMPgSG81nVCoVOp2O3NxcVCoVy5Yto62tjeLiYgoLC1m0aBFpaWloNJpZKbMop1+i9l6fP77xoG+sbT7q89ErZ69SGaEiRpXSqfzqI0XTKvLp90W/T4lx9vviCnShvuWJEaln8hacR5z/yoCf9hJoOQ77/+/0elXHMIUm8ZIeF8PVF3wbLpWRxvDV1LWHUdLZR/kb5axaEMmGzBj+64Isoo06VJrZM2CUlpaye/du/vKXv7BkyRK+9a1vcfPNNxMfHz+tA5skSSxevJgf/vCHqFQqDhw4wA9/+EO+853vcM0117Bx48Yxly/OBApgc3nZU9nJBxXtfHCiA8fQ5VMDygZ7BadTIqShv4zQsYYeG409No7W97IuI5pPrFvA1oWxIsAQn7xGRUWxcuVK/vCHP/CrX/2KHTt2cO+993LHHXdwxx13EBkZOStlFkXxWQBqdsGxp07HBNgnUNFMjFujCK3L6osnay3yfbeUNbDtWxCeCLrzK4fJ+asMKIpv1t/fChX/8VkCemp8eQK87mHKM4LpZwyfQbCj8YR1irNPtCp6Drqy6PT6hNEr+xLM9Dk89Ds8rFgQyUW58cSF6dFpZm7GZbfb2bNnD++++y67du3iyiuvZMOGDVx55ZVERERMuyLgR6VSccMNN7Bo0SKsViv5+flUVVVx7733kpqaSlxc3LT1Y7x09DloNdt56Vgzpzos1HVZcXlOKwLDiN1kQlEmErgdsKyOUWa4W+vvpk/Z8VDabKbP7qa608ripDC258ajVc3v/AT+zY3i4uL45Cc/SV5eHn/961/54IMP6Ojo4Bvf+AaxsbGzIzGR3+raUw2dlVD2sm+M7a33rfEfVJZz/54fd5tjFDbV+2IgHL2QcwUkLIXUtedNxtjzUxnw+63623xCWv0htJf6/O0jMcaMZvjCwZQdqc5gJfVMGeX03w50lDvjMMlnfIi9Njcmmxu7y4vV5SE5MgSNWiLCoEWvOfcpTm02G93d3RQUFFBaWkprayuf+tSn2LBhw7jyCEyWgXkIQkNDyc/P58CBAzQ0NFBUVARAWFgYer1+Zs2vshfcVmxmMx3tFnaeaKfH5sbqHGBeHUnsRun2qLaucZwXjBIwVncGfu72KnT0O+nod6LTqLA43WTHh5IQZsCoU6NWSbPTHH4O8G99vHr1amJiYnjttddoa2ujs7OTj3zkIyiKQnJycmCPjhlBOR2Rb+vxrRBoPOjLF+Ds830eKMcArfUcM9aYO+oQPMxBv8vA0gbaUN+kMirdl1FWc3osnsMye36oNENxWX3BHx88AO/cBzU7R1cEBjLcyDktjDB1GgtdKGYpirc642h0DJ4dKPiWnr1d2sbdzxfyWmELRY2mqejsuMnPz+ef//wnv/3tb5FlmW9961t8/vOf54ILLpiR/kiSRHp6Oj//+c+5+eabycjI4Hvf+x7/+Mc/KCsrw+0exlp0LrH3QvnraI49ieb4P+k0WwcrAhNkog6poWWmczwvqOnmXwcbuPu5IvZUdtJlGWO52TwhKiqKJUuW8PDDD3P55ZfT0tLCD37wA5588kmsViuyPMW5T8aD1+VLxf7ef8OH/wv5f/alDh6oCMDMKAEjIo36Z1AHFdmXnbb4/8GuX8L+P/jiIqY6D80McH5ZBhTZlyOg64RvpUBbsS+ToCIzYTvVOE5RS2DQQGq4RKRBOrMaZQqduhZDMmZScVpUyMpgq4HfBOv2ylicCh+caKep14bbK7MkJYLY0Ok3LVqtVsrLy3n33Xc5duwYW7du5ZJLLuGSSy4hNDR0Rvyd/tmTSqXCYDBw4YUXEhUVhclkorKykqeeeoqvfOUrJCUlERMTc+465k/L2njQN7s68R8iLRbi7HrC1OuRkXDJw+vrU2V1ldRaJJ0RtTEKSRcyJZUPZ1UYrTpZAbvLS/NpRbau28q1q1KICdURbtBOvCNzHL/LIDk5mYsuugiNRsNbb73FkSNHePLJJ7nxxhtJSEhAq9WeOwuBLPvirer3n/alH/flEBiqBIyb4IXOqIWEUIlIg+/3Kahy/CheX5rkun3g9fj2UVh8zelNkuamzJ4/yoB/p6uuk74bVPjskKUs0/+wqFUSRp3EwmgVsUYJvVqaulZPC3a/LhGzlIJHUaEMcCBL0pkyiuIzwxbU9NDca8eoUxMTqidMr0F3Omp7qgcPf4phk8lEQUEB+/fvp7q6mm9+85tcdNFFbNy4cUrbmwj+vPDr168nPT2d/fv3U1ZWxvHjx7nooouQJImIiIjpT108cIc2t923J0XjIah6nzC1jjhVAnEaJ25FPaIyMFW9k7R6VIYw1BHxqAxhU1L5cFaFsfDICj02F7sqO6jqtLAkJYJFUjgh2vntMlCpVERHR7Np0yYWLFjAhx9+SFVVFR0dHaxbtw6j0Uh0dPT0587wpxP2unyJz2r3Qs2HvkDBKZkVB9/3ML3EgkiJ+FCJcP00rzwYTaHwOn0KkbPft4FdylpfmmNDhO+kOSaz58+uhT01PkvArgd9WtrQDH6jMR6H6CjIioJHhj6nQohGQq9hSveBV4C3oz/LUWkJf2/JPKMMBI6e3Y5aAoNWzcWLE1iTHsUdWzNP54ufemVg586dHD58mF//+tds376d9evX85WvfIWwsDB0utkTLe7fOa6np4cXX3yRV155hfr6ei6++GK++tWvsnjx4kmlRQ6iAz5FoK0Yjj7lS4lqaQOP0xdcp47kvYQ7+U9vOu+bkgefSvCz7mAmRorXgyJ7ULweJLUWlVZ/1rmTnWCNd8WDRi0RZdRxw+oULs1LZH1mNNp5vvRQlmXcbjclJSXs2LGDRx99lLy8PDZt2sQPf/hD9Ho9Gs00zu0U5XQMVgV8+HPfy284t8CI55/+dwqGHadHwe4Bjcr3Y5jplVOS2pelMGkF5H0M1nzGt8fMHFt6OPefMNnr2/Wv6YhvX4G+Fl8q4fEw0CEajGo0QhmVJKFTS8QZVYTqpCBfumM0GDgsgUpNjTOCSlvk2Wcpw7fjVcDi9FLZ3s/R+l4O1fbQ1ucIbP87FVgsFiorK9m9ezfHjh1j4cKFbNiwgS1bthARETGrFAE4YyGIiYlh9erVXHXVVYSHh9PU1MRrr71GXV0dZrN5ehr3B7c2HPDNrlqLfDMtj9Nn4QG0iotcbxVxSg8qTs/I/H0f8NdIwYH+AgPLjoSk1iBpDagNYQFFwH/ucL8rZ/0yTPtD2xj9lLPOd3sVeqwuipvM7DrZQX23FZPNNea55zMqlQqtVktGRgZr167lmmuuwWKxUFpayptvvklraysej2fKnulBeN2+2W/9vjObCjnMPvP4WAxUAiarUZ5Gr5GIMkiE6aTJKQJTdalkr8/C11vnW7V28q0zz/QcYm67CfzLB5uPQuUO39KWyZqsJhMuPR0N+j0BkgRqHaXWSI57IsdVjSTBqQ4L7X0OjDoNN6xJIT5cj1qSJpVMy69QdHV1sW/fPl5++WXMZjNf+MIX+OhHP8qqVasmVvE5wO+P3bhxI0uXLqWkpISKigr+9Kc/BRK/REREBMpOmoBr4PSulcUv+BSBtuIBnfL9o1Vc5DqKifcmo1UtwSkPbl8a8u9Zx0ZadTAC4/l2kl8FGeGk0eoaTzteWeFwXW8ga+GylEgiQ3y+2PnsMoiPj2fr1q1kZGTwla98hdLSUv70pz8RHR1NdHQ0oaGhU+cy8Musx+kLwC55wfeys53O338ux8oZueVB2rSk02Ut7VC7x7fLbXwexOh8yYlgTrgM5raboKPCl0Vw9699N8JhGsfJYxhYR9zkYphqGKWqKUHBpYuhPyqPr3dez0F7Gr6QyOFjEkb6ZioJwg1atmTHsC4jmts2Z6LXqicsp7Iss3v3bg4cOMDf/vY3Vq1axfLly/n6179OVFTU9Jrapwi/y6CmpoadO3fy1FNPIcsyK1eu5Pvf/z4pKSmEhoZORUM+RbXhAJz4D5S/4UuF7XaANFjeFACVlg8Nl/OB7hJe6UjCLgent493tdTox6Y2AmsifVOrJFKiDFyal8D1q1NZmhwx7zc68nq9uFwu9u/fz6FDh/jzn//Mhg0bWLVqFd///venzmWgKL5VLs1H4MDDvrHW3ktQ2QQVfHI9KSfWOJn2nC9BIKl9AYQZW30/G+7yZS5Uz/5599x0E8hen1B2nvQFXpnqx6kIjEWQisCA4iOijPhHcCi+BpwqA+2aFBzokU/b3EZqdtgxHV/UttnupqrTyvFGM3WTML9arVZaW1s5ePAgFRUVqFQqli9fzoYNG0hKSpoTigCccRlkZmayfPlytm7ditPppLa2lr1799LS0oLNZpuc+VVRfANo1yloK4XmQp8i4HGcmcpLg10BkuwmSdXLcm0LWmnwZkSDqh7Xlx3lvGGFaWpHzDFrG+bLeGWFZpOdE639HK7rocvixOaabOT63EatVmMwGMjLywso4F1dXRQVFXHs2DE6Ojrwer2Tk1nZ67O6thVD8zHoKAen2fd5MAw1UU0HQ79e0IEpUzX/HeZpVLy+57rzBN72chwdVXhcNmR56tyy08XcVAY8Tmgvh/LX4OiTI6QWhiHu1iEMIznKCL+PxEiZWYY2M9DvP1pdw3H6FLMSxjEljz4mMEsd0mxVh4WdJzt4vaiFstZxBFoOoKWlhd27d/PYY49x+PBhbrzxRu644w6uv/76OWfGlSQJrVbLpk2b+OlPf8q6deswm83cd9997N69m+bm5sk34nbA0X9A6Uu+pYRnyezZ12whzVwkHUOPa8RSE4ncH1hu2PFpUhrHJBih87IMR+t7efiDKo43mmg1j/C8zyMkSSI1NZXt27fzq1/9iqioKA4fPszPfvYz8vPzJ583w+sCWy/s/5NPbq2dvtiBYAVszLF0AmPhOKoYvR8jnDhuOR9oyhtSb18LrsZCug6/gK23HfdM5oQIktlvuxiKtcsXqLHvd77sgvIoQj/ed5L/xT1qsIt//d4wZUYKvx7VUjbABzuS+UpS0eEx8nZPCt3uqckV4HTLvFXSis3lRadWsXJBZFDmV7fbzbFjx9i5cycvv/wyK1asYMWKFXz2s58lJSVlzikCfiRJQqVSERISwpe//GWOHTvG3/72N1544QWOHj3KvffeS1xcHGFhE8hH3l4KrcVQ/X7wya8Arb2TcLeb1aEmKl0a6h1Tv2tdUBm4p+iWjmqdHXLAX9b/r1dWsLu9PFPQwObsGG7fkkm4QTOvVxlIkkRISAjZ2dncddddFBUV8Y9//IPnn3+eU6dO8dWvfnX8uT38VqymI1DxOnSWg717mHKc8ZUPd1dHGguD+mLjLB9sXYPqHcYVPJF2h/l+CqBoQ6l0J/BUQy5phj4yU1r5+JrUCTRw7pg7T5Ki+ExU5kboKIOmo76lLlNtehlTIKSxy41rejZStJcS+L9XE0K/FEq1PQybd/gHe7xXwaso1HXbONHWT0mTmX6HB7d3dO3V4XBgMpkoLCyktLSUxsZGli5dyvr161m6dOnEXpSzCJVKhVqtZuXKlaxbt45ly5bR3t5OYWEhJSUldHR04HQ6gzf3KbIvG2Z3tW9wNTX4orB9B8c8Xe11oHP2kmswkayzTfyLTTkTe+Ym4nnzW3QVfLkIylvMlDb3UdNlxe7yIk/hqpi5iEajITIykjVr1rB582aio6Npampi//791NbW0tPTgyzL45BZBSyd0FUJ9QfA2j18VLx01i/DM+4X7Lm4l6MHwY6LEero18bRpMRzqC+aQ012ipvM9NrcZ/YZmYXMHWVA9viWtxx+Anb92jeojmYVACYsWMGeNnAd16SaHG1BloQ1YhEmYyZtLg2uEZYQjl+ufW0eqe/hTztPUdRkom0M82tVVRU7duzgJz/5CRUVFdxyyy1885vf5IYbbhh367MZnU7HqlWr+OMf/8ill14KwFe+8hVefvllGhoagk8D63b4VrqUvwbHnx7iGhjNXHTmV63k5ROhRWzW10/ou4xFsN6wwWXPofVnSFN9Dg+H63r42RtlVHVaxlRg5wsLFixg27ZtPPLII+Tm5nL48GHuu+8+XnvttfG5DLwOOPIElL1yeov3oYrAOAa4CY2Fg/yq40AZ9tfBRcaI9h7xvPH1REbN7tCr2ae7gGaHloN1Zt6vaOeNohaaemeTUj+YueMmsHZC5TvQecKX7CKoOzTBQStYE9dwQTITanKkNQG+FQON6lRavYkTrXzUNr1eBZvTy5vFrXRlOfn42lS0ahWqAfZjp9NJZWUlb7/9Nnv27AkkO7nuuuuIiopCpZo7OuVY+N0carUao9HIxz72MdLS0njiiSfYv38/XV1dfP3rXw8s4xoRl9WX8+L4v3xugmDWZPt6MOhXlSITazlJvDuCWN1yTG4N3hEUQgjOKjuwTDDR/WOWHa7tiZiHRzC5Dq3G7vLQ1Gtnb2UnFoeHCxfNnl0nZwpJktDpdGRmZnLNNdcQExMT2C1UkiRuvPFGIiMjR39W+1p8Ow7W7fO5YkedpIzCmK7WsZjIiSNZWAcWmaAVYxzdcesisRsS+LAvlTJXNOBbjGuyuXm7tJUIgy8LbEp0yKAxdjYw+0dxRfGZqfrbfQkvTA2+ddowfRalCS8XnEpLhBT4aSSRNmIn1sQwATRDP3J5ZfKruyhsNNFrc+PxninhdruxWCwUFRWRn59PQUEBy5cvZ8uWLVxwwQUYjcZxdmhu4E/ysnnzZq644grS09OpqanhnXfeoaamhp6enuEjthXl9JIsk29gPfXeKAPr2EjIRNgbifG0k6x3DFpZMHz5YOqcqkKjnDLB8XyobA5Xjet0UqKj9b0UNvTi8sh45fnrKvCj0WiIj49n8+bNXHPNNXg8HioqKgJJiaxW67DJxhRFQZa9KH0t0FYEbSW+rd/PlBhfRwZOpqaDMesdT8PjsY2NfZ5dE0mnIZtj1jhO2cMDn1ucHg7X9lDe2kddtxXvLFxdMPvzDCgKnHwHGvOh4FFfRKuinFNLZfAME5Qy3vOHnOxBzfd1P6LEk84p21S+eAe3JUmQFm1kc3YsX7l4IVlxvllvSUkJxcXF3HPPPWRnZ7N8+XJ++tOfEhMTE8gsOFeDBoNBURTcbjcdHR088sgj7NixA6fTyc0338ydd95JSkoKWq124AmAAvsegupdvg1dglmXPQaNocspjbqUnzeuoMk1jEViIjPxOcPwX06jkshJCOM7V+SyckEkSZFzYznrdOP1enE4HOTn5/PKK6/w/PPPc8kll3DxxRfzpS996ay9N7xeN/2WNgwH/4Kh6N++7HnKgJnDqPkCZpAZ7dYwM0atgXdVF/KsdC2H+6KwDZMbJC5MR1ZcKA9/ei2RIdpZlTNjdlsGPE6fS6Ax37fW1esCpksRGGbaPO7TB6wKmBCDv5isDsEdEk+b20i3e6p3whrclqKAyeaitNlMVYeFmrZe6urq2LlzJ++//z7Jycls3LiRq666iujoaHQ63czup36O8GcqjI2NZdu2bXzsYx9DkiTKysp48cUXaWtrw2Yb4Ad0WaDluC8hVm9tkIrA2AITIZtY6DpJCA5UKGcbfKRga5o8Y7Vx1vFJT9SGlzGPrNBlcbKrspPGXjsO9yTX1p8n+PMQLFq0KGAlaG5u5tChQ7z11lt0d3cHggoVRcHmsbO79QBH3N2cDIvEI51+LQRettIkx8VBv0wdwfitxnN8XF0c7AfxShqaQpZQq8qgxhGGSxn+1drv8NBmdnCwtptmk308DU47szNmwP9Au+0+P1bNLt/gOul6GfyyHmrXnIymOdoSlYH1DuzDGG15taE4Q1Np7zfS45n+bTH7HB7KW/sobuzFagZNdxWvv/46paWlfOxjH+Pqq6/miiuumBdKwED8Sw4vueQSlixZwv79+6moqOD48eOsX78ejUYTSLIk2U1Qu8sXJ2BuDLKFUQKaTh8K93RjsJcQxiXoVFE4ZFXg4GRXR42Xsdo46/hElhEESa/NzdslraxcEElmrBF92PRv0z0XUKvVZGRkcMkll7BgwQK+9rWvcfDgQaxWKxkZGYSHh6PT6ZAVmT5XP6/V7yDDaycnLoO07kbUsnewi30y46LC2f56ZejxCdY/VtvjOT5S6NYYnyuAV9JyMnQ9Vf1ZNI6yBNjpkem2univvAODRk1WXKhPrZgF4+nsdBP4u1R/wBfZWr3Tl3HwnGU/GY1zZ5tqC1tCdeRW7m3cRJPr7GV7Qcjp+FEU4j0dSF019Oz/N+np6SxatIgf/vCHxMTEBJYPzgbhPdf4d46rqqri1Vdf5YUXXiA0NJQLL7yQb3zj68SHKOg6iuGt753JMDhFKEjIKg3PRn6JI+4sXu9KYtS7PJoQTEBApkvqJ1Ov/1yVBBcuimdtRjRfvXjhvM49MBS3243D4WDHjh3s37+fZ599liuuuIJNmzbxta99jeNdxynvLufPx/+MWvYSqUjc6zaQ1ddFuimYZFuz1IUwXibxNTyGWHp1SXy+/y6a3BH0evSj1ikBoXoNN61L5YbVqSxLiUSnmXmZnZ2WARToa/OZWTvKfQGDQ+MEhrvQ476hp08I9q06nIY7aUbutEkOodKTgFPRDFt00FnDRH+P1sRwXw2PC9lpo6WuCG9XHW6rk8sW57F18yZSUlLQaDTzUgnw4w8qzMzMZNWqVbS0tLBnzx5OnjzJzp27uGShgThbFTpLB1KwW7v6GVV2fZtVS7KHRaoWutShQNLo9Y12myYwGxvr0Zsoo+krox0feExWoLHHRohOTUe/k2ijFqNulg5t5xitVotarWb58uWBQOCmpibUGjWHjxymhBKqXdXYPXZkRcaFimO6MBS9njidEYPbjmrU+eIw4+eY4+k4JUgZ3zRQCla+B5YJZtAcgVZVAtXSIppdYfTJ2jFPV/AFFNZ2WjnW0MvC+DDUKgm1ambH1tn3xCiKL/9o0yHfvgMdFcNf2OGu27iv5UhvzxHqC6b+cY+UZxf2C36zK5xd/WlY/QIWzMgY5LHhvprXacXVUYfp8JtonH2kLVnDdTfezNWXbkelUs1rRcCPSqUiNDSUSy+9lFWrVlFZWcnJkyf52QMPkPjJdFbHOokbM//FMIx6af3uAIXVchlmL8BKJvVansStnNipg/s6Vs/H20ZNl5V+h4fSZjN5SeGkx/gCs4TM+mQ2Ly+PqKgoUlJSuO+++/jwww9xeV10renCkmRBPr3bqxOZF1R2LHotC8MTSDI1I3ndwYjnyH+f9Xnw98RvuB6qHA6MbwzUKoE01pjuP0kao0wQffTF6qg5quTxrnwJFlmP1x8rEMRXPN5ooq3PweVLE9FrVahVMxtMOPO2iaF43b5Nh0r+H9Tt9X02l57nKemrhCcsiXZVHEV9oTi803ub/A+U12HB1V6NJioJTdY6XCuup1UVT2OvY1Y4aGYTer2e+Ph4fvSjH/HZT9+KXuWlpa6Slvqq4KcxI5Ub5XxdfyOJrnq2x/QSrZ2lG/YoQ/4Fhk4dp+OR7ne6ebaggaJGMx6x1PAsoqOjWbduHd/85je5+ZabOVZ2jNa2VqwW66D4aZvHzhGdmsfi4mjXG/Gopz9eaSQUwOqGRrNCcbvM/kYvJ7plLG443i6T3+RlT72XTpuC2+s/YwyGsyhPYIRzq43Uxl/KcWUxB00RuEfJ/zEcVpeXNrODN4taKWwwjbv9qWb2WQacfWBq9O3w1t/m+2zEacT0+atkxSdcCqc9FP5gkSG/6zVMffIISYVdF0e/JxJTkIGDUxH7KEkqJJ0ebXwGmrAY5Kg0Wu0Sdd1W0mKMc0spm2bUajUqlYrVq1bh7GmmLEEiXLGgcrnx6dhBXKyB5sxRTZZnPla7bUTqzKwI6abOqqeXIAfq8VtmJ367x/gekxWkkTyEbq9CZXs/jT02ui0u4sP1qIXMBtDr9eh0OpavWo5VsmIpsBCqDkWraFGhCsyqvYqXTkmmVCNRZwxHLUkkWU0Awa8ynKKhWVHA6VGwuBRMDoVeu4JagiiDQr9LweYGh1vB7lYI1Urohp1cD+nM0L4F1U+FQduMS2qcqlDKWESdN45ut27M04e245UVbC4vJc1mYsJ0rE2PRqOWZiwZ0exTBtqK4eTb0Nd6JrnQNA0qw3L6pnlkaLcqODzglUGn9vkmvQqoVb5isgwZkRIhU6w4e1FTZ1hKlzv4jS2m4kpoolMIj04BxZ/YRmLXyS46+11sXRg34z6t2UhkRBhXLA7n0o+Horb0IXm94zNNj/niPLt8ssrMLYbDHFFfTEOwu1iO89bN5js9kofQKyu09Tk41tBLpFHLjWtTRezAMMRkx5BoTCTWG4siKcNe0H6PDYvHzj9TF7Gp38zna475DgQtp2PEYwWJrPgsAx5ZQSX5ltTa3AqdVoVog0S4DuxusHvA5FAI0wXhPx62P2N1UhpURDZE0qVK4Vdt6+j1jKEIjFK9R1Z4v6KDEJ2aC3LiSQjXo9PMd2VAkX17D3Sd8iVqmcJI7MmgkkCWfEqAJIFGUrC6wOHxCWW0wWfCN2iG8U9O8EHwouKoYwG17uipqC7o8yRJOm36OOOW6Oh3YOhUUd7ax4LoEOLE0q0AkiJD02FoK0Lt6EZSPJP0UQdxpxTQeizEmktIUa0kUR9Hu1M79nnjb2lCDLeK9lzhb6+qw4IkwRVLEtGqVWJ1wRAOtx3mWPsxUJ32sY8Y6KZQZe9Ar1KzN20lKzpqiHZaRio8xMI1NXderYKYEIkwnYpEL2REglbtG29BQlF8m67p1BLaEW/zCJI4CQEt1SynRLUEk0eLc5icAuOp2iPLNPbY2Xmyg4+uSCZGE4RyMQ3MHmVAln37D5gaoLtq7E2IztHaVAmfEiDju1iq04qBW1awe8Dl9VkRhu3TBDJ3KUh4JA0nnbG0ugcvJ5ysG2Dsts9WaPodHtr7HFS292PUqYkN9SkD8z4uy7/Va3sJUvcpJNcIg+S4CM61oPE60NiaSdGYSdHZTysDI3RzhFqn+vYNF5M1nYrrcPjPa+934JEVuq0uDDo1kSFCGQDwyl7cspsTPSc41XsqqAvd6e6nRh1GYVQqqX3thHqcaIcLKBzJwjVJQVNJEmG6YSoaJChBzOrH8fFoKKjwqnWckjIpYhF2WY08TEUjVT2si0uBzn4HhQ29XJQbT2SIdkassLPnKXFbofBZ30zLv2XmiDEdw5u2Rio6ERTFZ6JS8CkAepWvSVmWyIhSsThOzYoEFTFGCcOIY/EI2uho7epCcYXEsdsUw4kpTT88dhdGuqR9dg//2F9HSZN5WvozJ5E9vs2ISl6E2j3nuHEFZA8fiajhE9GnhjzEg+/uuRpSpqqd0QbR4X4fDodbptvi5D/FLRxv6J2ins19TE4TxzuPU9xZTLWpOujzmrxWnrZWsy82lZNJi8cofY4CN6VR2hpvYO44uuzSRdKWdDFv2/J4pSOJ8e6ZebZ8+xpv7LWxo6yN2i4LPVbXjGTSnB2WAY/Dt7FLSyH0DUh0MRWxAhMcpdQqiDJIvv3SkVBxJpjQqD0dPKiW0KlA7Z8mB2WLH/2wTRtDryEDF6PvTjcZxlOrgs+M1dbnoKHHRl23lfQY45nvPF+xdkB3tc+a5ZrgtqSTtG4luhpYIOnQq1bjDMxQzv19UTwuFLcTxesm8KVUalAUFLfD53ZSa1CHRiFJE5t/jNfi4JEVjjeaSIjQs8Uro1XNr6yZw9Ht6OZw22HMTjPyOF5jMgouxctBtRubBtKMURidNnRe1zClz+U1HueMf7yfD0ABUOvokmJ4zbqMRk8knhFSDo+P00GbMjjdMsVNZtSSiric2Cmoe3zMCmXA67ah2LuR2kuRHKbRzRVT4ZQM4jyNSiLKwPgbGCnUebRqBhy3amLoNGTgRTP+tqcBCZ+FpNvqoqHHRlWHhZQow4yviZ0x/Bp7f5tvvwy7yWfJGuQvHXrOCJ9P6PaeiWqOdTSQJEmEqz3ISDjlmbkniteN196P4rahKDKgQtLoQFGQbSZQqZE0etTGSBSUwEt5tMwDk/UCemSFkmYzixLDsLs8qPXaebuyQFEUFBS67d0cbj2MxT1+l5aCwhFcmNQSl4XFkCR70Z5WBiZ8WYe9ycHFzZy7wJQzz5tXbaSNOF7uX0rbWKsHJoBXVjjeYEKvUbM1JxYU5ZwqsLPCTXCsu4zXW/ZREbOALmP06IWnQgim8/qOOegPY/4ZcPyUJ57djlxcymQH9qk3MxU3mXnteDNO93iNY+cZiuzbe6DkBd/GRCP5Sxn4+TD3Y0K3aEDAl8tCnNzNF5NrWGLsD+rsaTE+yjLIHhSPG8XlRHZYUFwOkD1IOgOKy47X0o3ssoHXnxthaK6B0f6aGBanh8o2C++UttPvmEAiqPMEBYWGvgYqeysp6y7D5p6YJcvhdVAjefh5XCyHwyKw6ybpxhz2JgcXN3NWFqJp48zzlh9+BXtCLqfepscWZO6X8TxvClBQ001BTTdtZgdOz7kdZ2dUGVAUBa/spd7SzDFTJbs1MkWhYTRGJOGRxngZBoRgMsObMuyvYxWdcFMKjCS9CqCotLR5Qim3TYUJavSnZCJfp9fmor7bRrfVhdU5SxPeTDeKF8zNvp/+NpCD3Z54wAg2RQOZhIJBsbNMqiGavqB7MeWoNUi6EFQh4aiNkahDo1CHhKHSh6EOiUAdFoM6LAZJpQFJOv31p3/GoyjQaXFS3GTCPo93NFQUhWpzNY39jbhkF8oEBzMFBafipUF2Um4MozQyHq//fo5r/JyC+zAu8Zlce7JKj9sQx3FXKsWOeDyKdJYqOxLjlXK720uP1UVVhwWba/Jbn4+HGXUTKCi4vC5OmKr4sOMYTrWTCyKisUVlcHm1CbX7zMUY+aKOxy479LA0fBh0sM2Mp9kxz1ehaEKodUaQ74rCNU3xAkF3Zxh6rC6cHi91XVY0KolQ/azwMp1bvB5fLozuat++7+NihNiSYKxcI5QJUeysdRcSL6cAaYPbOUeotHpU/uVQ0umHSRkwq5GkActPzm3fWkx29pzq4o6tmSSEM+9cBYqiICsyh9sOc6LnxPjPR0EacM88ipcup4m94Sl0RehZ0d2MWvEEP376liwN+H301qdGXoKsY4TmPLowrBE5vNeeRokzfgr6MzKy4htnC2q6WRAdQrTRF51+LtwFM2oZsLgt7GvZR31fPVaPFbfXzRFPL39zt/BE9mp2pyxGHtY3PZamN8aFG2800mjtD+zKcIP8GKf78ap1dEavpk+fhEueFd6bYfF4FXae6KCiNbiZ6HmHxwGVb0Nnxdn3caITkIFmz9HKDPex14Wur5aV+lYujelBI/krOpezYMkXJCidzrwoceZv/2dBMtW9dri9dPY7KG02U905Fcs/5xYOr4NuRzeF7YVUmarGfb40wr2rdXRyyNHBGws3cDJmwXgqHP73MQsPhzLqn+MWpuGaU+uoUDL5re2jtHijp1A+R66p2+LkgxMddPY7OZdZtWf0reP0OKnsrcTkNCErMgoKfYqHRtlBsVZDqSGEqrBobFo9Xkk94PJNo5YUlEBJw/56xhUw6snDdt+LhjZ1MhYp7LQJamR3wniYElkaUIlXVqjutNLe58TjleeX6dXr9i0n7K72bVE89BZNRizHnCEN/5GEgsrjIE3dw1J9J6ogfRCj3bVxH5P8CoCE4rcMSEN+glzpMKkne5jOyQq4PDL13TZaTbMjkdm5xOq20mZto9fZO+FYgeFwyG66ZQfFei31BiNmQ7hvNctUKchBIY3653h1ibMPS/TpEmhWJVPkTDq9YdwZOZ7oMzRS5/znOD0ybWYHXRYXffZzF+sy45aBnY07abG0DPpcRuGgtYGXNV7+kL2WuvB4HPqQc9OpiQzwA8ffQZpv8EObAy2HvItokWPG1b2xmBK1aUAlHlnhSH0Ppzr6sbm851RznXEcJuhrgrbSM/tmnBOGuYtDPlqtqeNqXRFagvMzjiYXEzsmjXnutDNC44oCB2t6KGoyndPuzAaaLc3kt+Zjc9smHCswEnbFyxvWBnaF6ClJXYpbo51aBXm6GcMiJ0tqKqIvpli/jtJ+I/YhFtuJPkNjneORFcx2N+WtfZS19p0zG9+MKAOKotBl66K5v5lWSys2z/Aaa5/HyglbM09GRvBcbDLtkck4NLMwHe6Yd36M26lSYyeEnb0J1DvOzjUfjDBMVZlgCrm9Mq1mB0cbenG4z22Qy4zSWQn1B8bOjjlhJv7YG20tRPdVkG20EqM9t5HzI/Y6yK8zXYPdQIdJVWc/1Z0WTDYXbu/8WQ3TZm3jWPsxnF7ntNQvI3McJ/+WbNSHx2MOiZxched6cjHC2O3VheMITeVf3Yv4wJxMsJatyTD0q5e39FHY0HvOrsmMWQZ6HD102DqwuCx45OEj052Khy53P0d1Wg4bQ6k2htOrN+LQ6Md/fcZ1wjhWGQTFMOazAchqAw51KNX2UHpP71I4WijCCC2Mq4wywu/BVOQPcqnq6Md1jpe/zAiK4vvpb4HOk74VBWcXGvXP0ev3/zLxwUbr7iPU2Um2vp8YzQgD/yh9Gs8LfehHI/b6rAPDtyKN2oFRzh/jnIHN91hddPY76bHOD2VAUXzB2T2OHhr7G3FPmwILbXgowkmNMZwuvRFZ8jurxvEQTOVSwSmYGdlU4XRoF3DcFketY0Ba+BHOG7W6IC/D0K/ebLJR123DLcvI58AdO2PKQGl3Kcc6jgVluupy9XLIa+a+MIlXkxdSkrLk7KUdk4opHGV4myplcBSTlCUsk97Ipb5NL+RzY24dLY4nGLFr7LHxfnkHlvm0xLCjAur2+lIRn6VNjeG/HI0pGQAVjJKDz0WXsNE4nAtDGbWdc9PdyXbg7Gsc7BApK9BlcbLnVCe9tvM/54BX8VJtqqbOXEezpRnvsArs1OCRPfR5nfw5Kow3IiKw6cOQhw0cHeVuTdS/P5mg3VEOHiWPx+Tr6ZbD8QSxsmuM6phIR6s6rJQ2mWk3O7Gfg2WG51wZ8L/8G/sbqeurC9qP5VVkrLKbA4qV/6g9HEpZTFto9JkCg+7GKDP7sQICpyIAZqRzRpCYNuKok1KRCX796lQxXFeD6UG/00Njrw2T3YXNdZ4rBLIbzI1gaQd7r89KEGxU9HTbwAeglj2kWsuIc7diVHuRBhUaRcZHayOYlQ5jd23aGM/T0u/wUNrch8Vxnssrvhf0id4TtNvaz0l7MgrdLgvlWg3vJGTQp9WfHU893N0Kdko90o0e7vOByxiDrN6PV9LQEbmSKlUWhf3ROOUhSs14nofxmFyHMXrJioLN5aWyvR/zOQgkPPfKgKLgVby0WltpsjQFd87p/9yyhyLZxi61iyNx6TSHRmFXa5AZRejGG9AyFQEw4zynVYmhTk5i8Ires5noIDvaeSO3N3prdpeXzn4nvfMhAZHX7dtN09rlW00wHqZDtxvhJa1SPMTZqon1dhCt8Zz9cI9mih1NKwzyO0ylpXc6sDg9VLb3Y3V6fHuOnMcrYTyyh6reKjptneeszX6PjRqNip0xiXTrQnCrgshDMvaUegSCsNePc6xXkPCqdDSGLqOadCptobiHS/423ucnGIVnBMOi0+OlqtNyfioDVreVkz0nabY002PvCeqcga9IBYVer4OnLad4NDaex/IuoN8QhjcYwRs3kxksgnUUqSiwxPNWb8oIGxOd8b5NdJAd/N4I9jsNvObD45UVjjWYqGgNLhXunMVpgeoPB2+iNSbT+KLx5xKQhrahgMvCupBW7ko6RbhmyAAijdKzKXiDj1TF5C28U3MtLU4PFa19NJts9FqH22Tn/MEtuznafpTG/sbxnzyJy93p6uNgXw0vpy1jV9qKiVc0JiNI2yTkWNGHY9an8rO2LbzbnzHp7gQXCjR6h20uLwdruunom54A0IGcc2XA4XHQ2N+I3W2f8FIXBbApXhpkOyWKnQ8j46gIj8amMyJPJlPTWH7gsc4ZxNgOTVmlxRWSQK8cRpdLO1p41bhlfOQoiPFfn9HOaOix0Wo+z9dve53QVQUOc5AnTEZ1C4bhp+y+eGeFOKWbxfIp9Ayz7/wwPRvvUzje8iNaeIOuaHANE7aQKeD2KnT0O2nvO39l1u6xY3aZMTlN2D328VcwCdGVUXAqHsoUG8VqhabIZOyTXQE2LXr12ZW2qFMp1y6h1R1Kv1cz6edivMrxcLi8Mo29dswON+5pzusyI5aByt5KrO5xmluHodVl5pijnafjU9kbnYzJGDUkOdF4GIcfeCCjRUyPtY5VbcAenkmvFEGv25/QYnwop82dQ38Y4fNghSmogFwFqjosNPTYxlX3nEJRfFkHO8p88QJBEYR9cAL+zGE/H6ZcvKedpc4iQnAOSEI0MuOVuilTc0bKCxD0aWOUHOFwY4+dum7bOY1tOJf0u/rptHVicppweGdG6Tnm7CQfO6WJOfTrQ4eJHxiBcQUxDZ29jeeODpYiBYlKTS77tZsxebS4ZNW0PRejlxv8HVwemdouCz1WF45p3iDunCsDZpeZwo5C+lxTk87Wq8jU29t4XePkv+NjOJaYTVtkchBnjnMgCXpwDiKqXPH9zyoZOa5ZiUmKChwYr0gDKB4nstWEp6cZR91xXO3VKG47rvYqnE3lOJvKkG1m3+5yQ7pxxgkxdreHO7e6w0JdlxW7+zxNQGTvgb5Wn4tg1HiBcYZijjd2ZaTPhymncvWhtzZzTUwrGyJNYzQ0OsqQfydTR7AEPwiPUXKEw6c6LL502uejvOILzi7uLMYb9CZaIzDJ69OIi8fo4UhENG1RKcFVPqa5aKSgWIlRBtuR21R8WxN3xm9lpzOPF9tTho0TmIrnYLgKgxl5vTLUd1spbTbhncZB9pwpA4qi4JE92Nw2OmwduLxT57NzyW66FC9VKoUjOi2lIUbaw2JxjRpHMMaoGmwg4UQCDiXf/+yKjpOuBPpkfeDASCINjKKQKD6FwGFBtvehOG0oshdkL4rXjeKyI7vsyJ7BfqczbU3cdWB3e7E43PRa3XjOx/Xbth7fKgKPi0Gb75zFJOfLyoh/jBtJkVF7nSzRtpOuMY2v6aF1Dfl3Qv0Jop1gCkzUmDKUrn4n7X2+vO/nozXL5DDRYm1BHlVeg2CSIu1UZJplFxU6HSdCQvGotQPcuONZHjDScWX4jwcdHt3cq6hU2FVGjisLqfPE0uPWMdyKrmCeg3FJkjS4vrHO7ba4aDbZp3XCdU4tAza3jV5HL02Wpik3XzllFz2ufp7QOPhHRCgF6avoM4SN7w6NoUSO6/yBn41QV69Hz9vmdFrdoYOKj8hIMTOSCsXjwuvoQ3bZUbwukGVU+jBU+lCQVMiOfmTr2Wbu8Xzl4Y7LCvQ5PJyagS03zwndVb78AiiTcFYH8fmgezveJVhno5ZktqtLWKGqHbNrQb+sJ94dYIxhfowwi2CiMIL9HvU9Vmo6LXhlhfNQF6DF2sLJ7pPTmlsgGGQUnF4nb4bo+X9hYVh1oXhV2rFPnGAsybCHx/IkqPV0SrH8ybyVElfi+LswoOx4Vh0ObWMs2W7qtVHW3DetyYfO6R60dX2+BBiT1lhHwSN7qFEs/NProi0lhzyHnQubK5AUeZgwpFGsAZNaUjig7hHGdU9oEv1KCjV9BqzeMzqZNLTgGAMkAGot6oh4VCERKPFuJI0Old6IpNGhlmWUyARQqX37yY/SvbHaHqkr/U4PFa1mchJCiQ7VjdzhuYipAXqqOSu3QDD4r6Hk/wMGVTKe+gJ1SKP8O7BtmVDTSZIJY0W4hSprCHb57B1AJyLy0zIcTcDiP9LjMdb3cHlk+h0e6nusJEUYiAgJ4gU1B/Av2+6yd9FoaZzWcXY8mN39VEla/r5gEZd2NrLS3DHMeDyAoSIdjCY4Wl3D/X6aitANlKgWU98Zgs07+PkIttmJvjaG2jhGO7etz0HoaQV2ujhnyoCCQpe9i15HsEFYE2+nX/HQr3hICI3DrdaSFRJOjMtBiNeNakQhHHI7ht6dke7WsOXGFgm7LgaLHIvZo2ag1PtNVBIEN0D6d4XThaDSndnMSQFU6tEHuTOvp3G8+Qec6y/icHtp7rXjnOYAlxnB1g2WjiAKjnUNpyLsbqixcmTjpQRoXSZitL3khZhptuuGVQbGYjh1Y6I60VQz0Tplxbd+u6PfSVSI9rxRBmRk7B47FreFflc/k96YaIpunEt2Y1LB0ZAQskJCWeAMJ8behzRs/043Op5Zyqh9HV6rUCQVslpPtZROuZJJv0czyD0wtKpR1O6JcbqiQfOFUeh3eOi2uvDICrKsoFJN/RN1Tt0E9X31NFvGs1Z7cuy3NvBvbw8PLt5IYWwqdv3ATYDGORUJOmZgiICP8DzWaRdRp1t0VmXBCMZw1Q81kQar0Y4UMzDWMDLwjD67m5Jm8/mZmtjU4NuyeFxXxM8o50zUAT708zHKLdT2cGfkMeLUE1u9M5UxA8ES/Cts4kEGDrfMidY+TOdwi9jpxu11U9dXR6+jd2r2IpjC941DdlNsqeO96Hhez16PWzWCYjpm6t+RYgZG8scOr1V4teHYYlbwUl/e/2/vvYIsS847v19mHnv9LW+6utp3z0zPTI93IBwJEEsQXIokyNVKVMRqTWyEtHpQSAptSA9SKCSFXqTVPmxIG1xRhiu3TtylSIrcJQESJAgQwAAzGNPjuqd9dXX5645NPZyq6jLX31u3bnXXv+N2VZ2bJzNPni8zv/wsv7Ew3/bs7tuQNBQc15/gG7WQxXWPlYpP9YCSww1OMqA1C5UFHtQeDKpJNFCJfT6oLvAvUg4fGFP87LpL1iuR8vdmSuzXa27vhP1ObYx39Nj+LzpkPdvlWRqiQXvN6tl7Sy1MshhW/Ygo1kgBopd4D8OAKABvI3En9Lr1fGkyBq2kTG0zn83LOcEK0+tvMSKvkFa5TZWU2NVeL6edvp766xwKm0uLRdM+aNG4b34U8+lS5ZEKTRzEAbc2blEKSofdlYb4yF/DkzWuTJxhtrTEZGlpd4GOiKlLAb1Q3GOE3/Ne5XZU3BXsrRU9J27bMbFXSYyzwwBpuQjTIq6VQMdoDcrNIpSJUO1vsUnb+yf4Vp+iWHN3tYptSNJ2/7fugTADWifhhJery6zWVvtcOU3fXqAj7nmrfMfKc9t2eSYSzOoYM/Qx4rAFCfV/mUwMXBUf+3k+jvL7b9t3S1JPr4vuDgHZ7praqHRv23tvCcKY5bJPJYgIohjbOLT8V/1DFGwyAqUkzkDH6OKNtV28faGlFZYwKtcYVxsUzYByZD+8q+HppH20c2+7GrbGTGn9ZbJVH5r1LQhj7qxWH6m8GmEcslBeoBLUTwnfNg5KrwPcjcpsRDXey89gxCGjlVVUHB1Uc/uggdBwuS/G+Ff+JR7EaXY+bFv90Bod1Ii9CrFfBR0jhSaqrCYeXBqEMpEWHTEDreg40knArLGMDXW2jl4xkFVbk7gV3izd5F65Xka15vc2RZtUtOKv856/zH+SNfk/Jmb58exlwkYvarvJXgSc9e/VRoogM8vblRHeLmX237YPewT5e61jW3VD7+1Nk2dqUF+rUdBAGGvurlW5s9pFxLNhhF9KvAj8zVNWx+rXg1zexBZX+fBSQ1qIkEGVr498zL82cr3jnvXDXKmdzVo3pev+j2UtjLi6sMFa9dFhBrzI4+rKVVa91d4qOuCduUzM/xgt8TuOyY2x04QtbJt6J8Ld6/LV4k/y/fTn+M5qjtWgi/OwVGgdo6MQQi9hDGoVotIKUWUdXSsTlZeJqxsddb/Vch7GMR8ubPCgdDChiQfCDHiRx6q3ihd6hLqzydc8dU/70GhCHbOsfX4ofH7XCPjh2EluZ0b3FmyolmqNHeLXBvBUigfOPDXhboqnRFtr+t4m9v3eaZl67fU41CuVgKVHJeZ75EPpXhKKGHoTEA0CDfq3dbKeD64zF93YnPBtdkpv3t/hM3TzyKIDmu0Wevu/ROS6Xguo+CF+GD0S8QaiOGKxukg1GG6GXKMpaZ+rhuAPUinWLJegLkOw7yTTaUPsrEAri8gu8sfVk3ynMkWo92SJbYMEkhVbI4REKANhuYn3lmGh3DwqXURlRxLVgWG2333deNvZuh7HsLDusXFAqq2BqAlqYY2l6hJe5B2qu4sm8Xv9ET7vC4U7eYbnl+8yUV7B2OzXPlV3N4TY6B4NVZnhjnMOXzh1pXGD1rS3Jb5tE0slbxfXunOBPXI2BKEHG3eTn/XQXJn9EAf12B3We8L7iDuxgS1/Ej+WtGWC1J4moteu9YROurdTNRJrWK+GlP2QWhBjqqOt2tJaE+qQ+5X7VMIe1QQDQBCHvG/aLBk2bzgZbA1GlBg91pVitq1r2nFtz/VIudTcCX5v5STvBZPsQ7uEpDVCKoRhIZSx6cZto7Kjyd+mjQ4DUDuNJFtQqmj6Z9L/WHNnrcp67WCMXgcyA8pBmVulW/2xcO0DNEkyjX9cvsavpQz+7hOf4W66QHggmQ93QMBClOX3yhdYid3uF81e5U4t0O5pcG+Re2s1bq9UB3YYPlAElcSLoFEI4gPd8ZqNYLvuBLu/k9VlpuN7/JvTN5lzOjg5HgYP1/CR9n/Ra/eWSj63Djiy2yAQ6xgv8rhfud9dcqJDQDmocKu2xP8wfYrfGptFiyaur50w23XLCt4TZ/gf+Dq34xG8WDYq2BpCIlN5jNw4Rn4S6eYQloNKF5BOBgwLYacRplO/Uw1orR01wceLZZZKByN97QszoLUmDEPiuP6pf0tNcNgRsXZCA2txwE0d8LYM+X6mwNVMEc+wiUW/eaTNnAPKZE2neK+SpxLvCADURl93oQ4N161GtFGmUUVtzJO9XpQlL9wnwmpGF0ONyIfyg+RnK/Rtw2xn8DuRJW3Zm2iEjshQ5lnjJnnZ35NjB3t3e8UaPlJnA91O82UvYrUStLZNGnJ4kUc1qBLEwdAEG2qFGE2gQz7B5wPL5MPCFDXV/6BlGkHJnea2nOWHtUnKsUm9kMNtYTOui5AqURMoI/ldyOTn9u8S0Wgf6aJpTWJXU6qF1IKI8AAyGPZl14vjmFqtRhTV3+yrYZXFyiJhPHzGOg/CEt8v3+J/mZjhX0zOs54qEsp20ld28iI2dVZWlgc6x5+uFlgPjZ1ftb67VztK3SYNNiu0tw97yq5WAlYqDzdPrTW1Wo0wHL733hRbmQrXbrXpSVDv5XSlOe/x/kbtJ/UWKPET/IBRVje/748xQOO9u736D1OBtFr1WVivbRswdprdc1Bo1a91f50Vb4Uojo4UY6OB69X7/MCA356/woqd6rD3zUtrIBaKe4UXeN98gm+tjlCOOgy+1efhbFRdM+HHlsau5IWU/QgvjPv+lvvCDIRhyOrqKkFQXw1QCSrcLd8dSmZgCzeqi3xTb/Cfj4/wp+MnuVOYbTDYHRydd0GykHmC5dSp9vS1e9GJIWAX97esfFPl1aydlYrP8g4DwjiOKZVK+P4RMircTP9M4EF5MUlQ1BJtyyo7QP/vV0GZ9PK7PGku8Gy21HkLHdNghy10u7p16QUDm5HdSt4ub4ZyuUytdjipfxshDEM8r7EV+UpthQfVwcVw6TfuhCV+p3SNPxmf572Jc7tfaS+eJoaDZ4/y91Ze4Hc3ztS950DXzgOoruKHPCh5xH3WbfVNMlCtVhtKBvzYZ91bH6iaoFPuuBp53NcBb5mStxyb990UK24Ob5+V6xaPtt1Qs07s+FVwX02yLEY66le7ONDT1Q5jnGbtVPyQshdu7qfJw3ued/QkA3GQeBGEiQ9xQ3Sivm+Fgz7MaRA6wgg2mDdWOG+v9Z1meq6vBbN5EA1Xg4iSF26vF1prqtXq0DGwYRhSrVYbSgYqQaU/IYgPCTUdci8q8Z5l8aGbpma6RFs2BA09TfY8a535WFJ57plzvFsb51aQqdt22+TT16HtvjI/jCl54bady06pUS8Srb4xA+VyueGiXw2rLFYHqyboxiUxiENWvHX+Z1Xj72RM/uTUiyxk60QJ3Fl3m+rdGMGf+6d5L3yY17spwztg9KMva5WA5bJPFOlthqBarR49ZqC6BrV1iCOajkY/XUEOWla+o/6fcD7hq+l3kQyfbrmvw9AGISeSAX+XZGB5eZmNjY1+9qRnlMtlFhcXGx64Vrz+SAYOk5nQwD/Xq/wT5fHp+Fkqu8LH10MLE3wB75tP8lvuz3EryFAKe9zuOiDO1qPYPaVX/IgHJY/oKNoMBFHAur9+ZAxbwjhkMarxj4L7/FZxnG/MPkkgVfdSTGkQmS7fXS/yXvkhd9rMtXoAB8Vd6Iebd6whiDRrtQB/08DF9/2GdHFY8H2fWq3WmIv2VnsIQdwMetePw0K+fI3J0rtM2T4p1Yd306Gh4MAevxUhayh7IatVf5fNwPr6OpXKcLnnVatVVldXGxrjVsMq5aDcs61Dv+K6dIsgDrglIn4jbfKBm6Zip7uil1iarBee4EfxGX5naZJavDMh3MGjq5ZauRNsohZErJSDXWqCjY0NSqXewlD3zZvA87x9i/6W2CKIAypB5cgwAxpNWYe8Ga3zPcflzfw4D6wUFWUSi/q5tnbeve+KNAmNDNdrae56dlt9aBKqoK1vWi28BzEtNIkvbNkLCWO97WUyjMxAtdrE/covJ66Fe9FyVWolX2lD19JO1T3C9ZfIe3c4YVfIqLD3yhv5f++5sFWs7uN30gXd6Q0NIJKFda+aoFKpNNXPHwZ836dUKjXc7L3IoxYNl51DPWit0ZEmqkbbH71jU4t1zCoR3zbgE8dlyU6jqbPmNlngNBAKkzv2GT6OpnivnCXcmwDpQDjSnXrhTncJ6qrJ9Ob1nfA2U3DHO9qoVCo9M7B9YQaiKGqoJtgK9LPmrw2Va2G7+H7tHv+Xd5v/+uJL/Kvps1TtNLppAJ3935WdKe4XXqAiXIKWWbmaY//dew0a9a6/+rXptzt3wjhmterjh/HQqgkWFxe5efNmg1OWhuoq1Nb2f9VyMHfak7RxLO0E/eTe4pACZf7GxLs8m1rqc+Wb2FdlizY2v25rVHZGD+oRpVrIcinYJRlYWVnp+ZTVb7RSE5SDMiV/uPpcD7EXE6wFrP7pKivfXGH5m8vEtd3zMIhDFmtL/KPiGL82cwbfMNF73fS2XKzqkYFhs6pG+S9Xvsw3a2d33rDn/n5jp/q4uVtWI/65nuZxr99P2YtY3PDYuXzdvXuXhYWFDvu7Gz1F2dFaE0URQRAQBEFdrrUW1vAjnyg+eowAJL6wtTjkI28Fx1JsjEzyk2sr5IMqrt9ecI8VneUjfQJfG8R+jaiyRrhyF+1XiEMfaToIy8Uam0fYLnJXsIpW6Kfiej8SAtVtiw9jnei0ojgGlTCKnudRLpdxXRcpDz/S2/r6OsvLy41FqkG1ceTBlmh3/EX92T8IaLC0x9naOxSjPEpMPQyNXa+4jtFhQLhyh6i8SlRZRZp2QrOT5xL6NVrEl28Tgx4OP4qp7UkJWyqVyOfzA+5Jc3iex/r6elPJwDAHG9KRJlwPKb9XpvppFe+2h0xJjIKBjh4+k95cazSwEJYwMPn25FnOry1worS8p9b61HLXPsMnxlk+XU2xUvIIyquEK3cQpoORHUVlRhCt8iEcKOr3u5lr4U74UUTJC9jpXLi6uopSHbpM7kHPIffCMCQIgrrBZTR6mxk4LMMU3cFG1ggRMTe9JUpWluupcS6GGlGVWIGH1HHL2pd1lqvRDH4siL0y4fJtajffJiqtEHslpJ1BpQpIw0blxxNCFXIoQviKHf+3g1hrKn5EGG+yEZsqpFKphON0wuQcHDY2NpozA2GtO2ag0839sF6vACP2mKu+z2h8AVdFlMP9sTW2xyeKiGsl/IWPCR7cIFi5k9BsOo9Kj0C6iNxM+jUMNAuJlLadrgRhjBdGyelrU605jK6FnuexsbHROLBb2AMz0AHd7lxPO1lbdaQJ10JKPy6x/oN14lqMNWXhCneXmmBnfctBiUBafGv8HE7oM1VeQ+nGGQ4TkbrklnWGd41nuVOCytoq4eoCtes/RGVG0NPnk4iBzZiBw2LS20QQxpT9cNf6tba2hmH0tp33zAysrKywsrLScGEth2W86PD0b/00iFnzS5SCCv9ZzuWFdIqfz89wceFDUluJQeoRkTK5Wivwjysz3H//e9RWFwlW72JNnMEamycOatQ+fYva9Tcpv/uHuOdfxT37Iu78FTD6H42rGTqdA/XKR7FmrRLghzHYCae6JXItFos9c6/9wPr6OktLS40L+CUIGoQhbobDXEA6fnkRovKA1zJ3oHiTX78zv2lktaeYV8F/8Cmrf/S/JiFXnSzpi58hWL1LuHKHpd/5uzinrpB97quoVA46SNnaj8dohH2MQIOKg1hTC2K8IMLZTL1dKpWa25QcArYkA42YgXKYqAm6OnR1MOA719NO1lZhCKwJi9GfHiX7bJbb/+tthGx9fyn2+a31D4mzOYLMy7x6/XtYUVD3fWrDwcuf5TfXn+RfPBjj9j/9Lwg3lolrZXTkY594CqMwtekltOfendUd4DxuTt+Nvt19Pdyk2Z1b7srKCqbZm7SjZ5ltEAQNfXK3UhcfRVuBekjCZ0YsEHJVRnzT1LyfH+duZrSuoYcWEs8ZZ13meOBJwloZpMKaPIs5Ooc5egJrfB579gms6QvEfpVw+Rb+nQ/Qh6BW6XQO1CVbnRi47FyzWgVMGTSCIMDzvMaSgciHqJc8GocgBevw5QlA6JhpHvCkuIFqEArLf3ADf+FjotISRnYMa+ZiQreTZ7GmL6CDGuHKXbxb76KD3t/xgbkWNqlYa40fxURDbPS6pY5thDAO8ePhio2wCwKEKTBHTKxJC2UrhNH6bWugogM+EiHfVREP3DwV061rk1IizXf0k3wajbKuU5gTZ7AmTmOOnkBHATr0QdeP3NdoC+7ag6zBddHsyzYVBYnX1u7n8H2/KX20g54lA57nNV7odeJWOMyRB7exhylr5qJTDau8KyRXhSScOM2VapnJ0u6TpgC0UGxkz7IRjbLuaaIgwMiOkbr4xq6y5sQZwtV7VK99n2D5DlG1RPaFr6GtBsmMNvvako9sUGDn5W6kAVvPVw+x1lSDiHDH+G0xA8MS4jUIguZi4F1qgnZGaG+ZwYsItsa2+UIn9p2YT8a3cSOFySvsfI6t+mqfvol/5ypEIc78s6TOvQLKxJo8S+xXqVz9FuHqXco//n3s6XMIO9VXVUFPkoK2Rd9Q9SMCO8YUDC0z4Pt+wzkUxAF+O3k06I/qtNM2BAJhCqQpQYNKKYT58PtWa8PbUYkbosZrhWlObyzhrlU3691UR0qDJVHkH3qf5eMog7ZM8q/9MuHafYLl2wQPPu34GXoZoab39jj0UawJQr1LMtCPIFkHywyQRB/sl2SgFRH3ROR7b4shqkRUP6ni3fPwH/hIU6JcReZyBqNgYBZNfsu7ww+VzbVLn+En71xlfmMZufm8AQZvcZFbTADgnnsZUUf0LwwLaaexxuaJKqubnWnyJGJ/l3cumq3EXb1sW+1si2G0OxLWlk3JsDADnuc1jeZGFCRRCIH22KZNm18tOh/QrWrb3fX2ltv8uxLCWk3z2x+GLJQ0S1WNFDCWEpwbkXz+lGLETTjInXu1Wb1P1vP4XOEB79ZG+LCyGeglCon9Ct7tq4Qrd7DnLqMyo7vVAFJhz1zCv/cR3p2rBMt3klSumWKHg9AY7Vpd98I0bNFspMEUycI6bB4wrZiBSEf71tlG6+EgYgnsa2Nvk5syaU1iS+Av+FQ+qBCWQoQhcGYcUudTmCMmyOT5NtD8/VSGL8QpfiEokq6uoTZP+tcLr/AWF/ju/RyVSIEQSCeDCn1ivwp9Tj7XMb310Q4hjGO8aHcOin4ctvpiQNho4vRbTdCKiPtB5FprdKCJKhG16zW8BY9wLUT7mrAcEqwESFtiz9hIR/LArhGZkh9aBlOpLGEccaq6gRFHREg+DEZZjDIIoVDp4jZR7tq8hQSpQBlIK51YZjc4XTWiqWZGNQ1HpcmXu77a8UdLmtYQ6d1caxRFxHH/s2x1i6YiVw3omP1hiFuIWGjMCERxstE0ZN42b5W0YYC3VxWFJo7hk5WYT5Zj3luMqYWaIIZKoFmuCu6VNCfzkkjHTKTErkpkHGDpMk/Zi6xGFh+SMAM6CojKq8TVdXToozKjidfAjkVVCIHKjCLMW8RehaiyQlwbe8gMHJAhVif036gbevM/scmIRTtCuW7RaxzHCCGGwigyjuOm0op6oWgPO4BQK+hIJ66GDwLiICauxclaG2micoS0JTrUWFPJASrUmmsi5IRp8H46z2W/jBNFoEw+iE/wjj7BWmiwLQETBkhj0yC7v2PRcW375m33UyPWCfO6UwwYhmHPnlp9kQw0E7n6sd8XNcEgRFtbCNdCqp9WufsP75K+mMaes0ldSFH9uEr5gzILP1gg/USacXcce9ZmVVb5o41PuDU6zcWRaf6Dmx+S88p4ocnvrs5yM8jDHkvPfU+iY+JaCSM3jjlyAtHAEKuvJ/kmX4oGf7SWDGjCKN4VEGPLrmRYmIFWNEsc1jUy2oc2X0Y1TD5S7Nx8ktsNCUqAkuB2MRs14EXwGz8K+M2rIacLghdnFM9PK354L+YHdyP+5x8GSAFvzCl+4Yn9jVgi5KvOW6z78E0mAYhrG3h3PyD2K6AMVHYUYe4JmCUkRn4CmcoDmmD5NtLNYo6drDM+u5e/QRpsizotiodfbB5aHtLs1gEnjuOhMHiFhy66DSUDcXTk1tm4GhMEARtvbWCOmjinHFDg3fFY+cYK3i2P1JkUk1+fBCPp24q/xredPHfyU/xnlVVmQo12Rvm/1y7xZ/6Z7bqH3CGgp75FsU7iuGz+veWxdeiSga0YA40Q67gvboUDIdDNbq5/f53arRrpS2myV7K4J12kK5G2RKUV3i2PqBRRu1nDmrBg02NuwVuhJgz+7tgYrwRzTAcFSotZBDZ5szHXFnllfK+ErqyRmX+GwsVXsRwXZM+vZ+DIKAUx22MppSSO46GyGWguctUJI9CTNGu3KEWQTNi7JU0UJ99OpgW1CO5uJBKItCl4YlxiyIRpaFnvJsIY7pc1C2XNuqf56XMmT08qLo1KLo5JcjZ860bInY2Ym+v1aVDGESNrP2YmznM6+wQPApNKycMP1hA6REiJk3FxXYFlPxwXHcfolEVoKcqADDYw4zIpe7j07a3gWjHRNjOQjO/W5us4zlAwBFEUNVVd1FMTdINBShOkLVFZRf7lPGbRRDoSe9rGX/CJ/URiUP6ojHfPwygaGOlkPVwLK3wSR/x/U2cZ84sY5TNsMEIKsOSeAEYyxpcxS4CJJi1icjJCyaNFozuR1QFW5CN2rF++7/cswep5t9kSpzVFH/eA7QV8Z5Nys42YLXX7Q716BwOktUaHmtrNGt49j+xzWewZG3s6ORFt+cOa4yYqrSACHWqiWkRcjlklYEMqanYBM3C5GGSJywEpYZNv4nK1XtmA0go5w2UsM8544QQKM9FBHzGMaIkbg9p8TUIksQZa0sgA0VploXkYko7m1ph1sVuUsmWVXA4S8V6sYdQVBBFs+BBGibtQGIMUGtmQZvdf1zphCNIWTGUET08qzhYlE2mBawpGXIGpBGserHvJM1UCjRdCyd8agxhdWqBm3MGybmMoByUWEfEy6BBhGJipKqazguE8ZCh0HGG6G0gzMV4Seh0pljCcxTbHaThgOA5aBGhi4OHGP0w0C82N7DT6yIR734IwBMpR2DM2ZiFxizOLJtKWuKdcgsWAYDkgWAkQRqKuiWsxgQ6oiAo/SOcpeBlSS1nk+gYToY+1Z+7UymuUqyt8qmOc2GfcW2ey/AAzHK7cE50gE1uMGWnUjvfd1j7cAj0zA5ZlYVlWQyNC2Sp4Thfm7DrSRKVo+16VUcReTFyNEbZAqMRqVRidGXTFXkywGOAv+ETliPT5NGbuoe+mWTQx8yYn/uoJhCUwCybBakDlkwrLf5BExxII7urbLFQtxqIMJ85mOTF6iZOjTzRs95s//h53lj/hxad+iRO5c0xutMrWNbxIh4onPUkhTgZ+S9TqOM5Q6F4BTNPEsqwm/dnJTe68VgctXTogisGPEjWAVsnFSpioB86PCtZqiTSgEiQ/Ddmi7h2wFJwpCv72Z2w2fM2ZosQL4V5Z80/fDfizWxGVALxQE2wys9+7E/Hj+zG/+X7wMA2q8Fgw/ojb9nfJfaFAHEfEVhkt15O5NP376GkHXXg4H3Sk0aUyOr0GaLTzLjp3Az39ZvNODxm0M4q0nt5UzSWJxLZodhgiZkIiYWsWVCaK+yMZGCgkdddoI2uQfylP9aMq4XpI7dMawVKAUIL1768TB8mm97/r2+Q8yYkVg59LZbhgWVywd6uyHoQhtwKfd/wKp5dv8fW3f5vXP/kjskMg7ekWKl/AnJ4i91c+A5s2PrZtY1m9xaXpmRnYWlibMQOymSVnN0pwnWzc4UZi2OeedtGBJq7FxBsx0pKojEJlVFuBLbagQ01YCtGh3j7O7VRxCCHQUmMUDYQSCEMkxoalCO9u8vxCCwIEC6FHRQTMrH2CSE+ghNgnIakFFRZWbqCjgJxTYG7sHDl3BDXU2q7mkIBSclvUrbVGKYVt20PDDBiG0WTiiMTIsx7N1tuc2zjEOwZIIXDUwy+V3LIhEGTMJFZ5ytzBCOytuwFjIEQi2E2bCcPxW1dDbm9o7pZiEs2UwN20n9o6WG54moVyzNWlmGhTmqbRVKVHxQxJV1xQIKyt+zQ6CBPVyc5xERodRWwFlZCWQFgaxBHblESEkhK5OcBKqe3PsEBKiWmaDeeQkgpDGAT05ms+FFCg0ptxCHTi1QWAAO+ut80MoCGKBFFNsGGYBFJgGGrXGBlxiNq0/xFolI4x4ghzOJairqCIMXfsa0IITNPsOehQX5iBZp1Iplj/Rj6JW63RviZaj4jKEc6cgw41sR8TlSK0pRMRVKqzyawjTVyNE3WAhjiM2ZvyXQiBkUmGTetNpiGEuBJjxQIVA3FEAJRVjFm6jRmsoqQmMQbeFJvrmJpf4fbyJ4CgmB5nIj+LOoJ2AjshhEDK3RbYw7awbjGwDdGIGeiIjLc4P4FtCGwDsnaDChpdb6NtrRN2NYw1JV/zh9cjPlmJuVvSfPW8wjHANcSu6GJBDLUA1ryHNgyekonOPAiJwxipEhuZLRWcDvSusLFbj6gDvR1bXtoSaQ3HSbpTKKG2Dy1Syu3PsEAp1XSdVUKhZKK6rIdBGgb2CiEE0pGgEvqO/RhhbqoJqjGx/3BR9hCsCIFHTHQINkldaRF7hZQItTsl81AwA67r4rpuw++VVM0lA91AQxzEGEUDc8zc1qVJU2LMGNuLVKe2CkKKZEREInmofFjByCbxBBrBHDXJXs6Qys/zM58WOb0okTfvgdYoIZgOStjGGubIOteXMwRRsineXbnOysYCyxsLPD3/OtPFeaQYkg3z4T7WXtmdKnIBhil3SWQsy2p6qhk0bNsmlWoSHEcaiatnp9jratiyTO8IY1ipwd/5M59/+UnE+VHBLz1p8OWzBjlb8LsfhfzpzWiXUeJLM4ozRclrcwqtoaoUvzZ7lsXYZz0s45xwiIMY6SSbe+xtunwFuyeU1knymbiaLM7muJn4hR8xCCEwpbm9TlmW1XOc937DMIym0jVDGpjKZFswsHdeHhFGABLbrLgaQ5SsySqjcOdd7AkbZ97ZdUAbi1wu18Z4+UcrnFwdfATGVtP9QNqUEmGau6WPjjMcaoJGHIlAYAij78yAUAIjZyQ6JymQlkTLRBogLbl9qheqszckjKReYQhiP6Z6rYo9Y2PkDYy8sW0Mp8NEJRFtRFgFk3HT5QqjPBdETIQhYvOlCCAjJWr9Hlz/LqniZ1hHsba+wUZlhSgOOTl+kXx6FGszU2EcR0RxxErpPo6VIpca6evYtTcQvZWVaneku61TzbAwA4ZhNOaiBQkj0A0z0M7j9TQE+zmJWghv34/4aDlmsRzzbz1r8dSEYiItMWWiotg77DlHYClwDcmGk2HRTqNHJFIb2JGNyihkINGxRqUSexx/ySf29ojJNISrIVEtQloSs2iickPC0HaIbdsmndDHMEmyoLXNgBKJmmAbwzHVuoIONcFKkEgElMAatxLayitsw951yJOxScXXWB8buOUdhr/dtMtgh21nex21LSWo3eoQ0zQPP1HRlgFhwwakkYiv+gWRbNrWeHMuSNF5m8IUWCNWchryY8rvl3FmHYy8kXgPbIpM41pMsBzg3fRIP2tzSqf5K2szGCufojYqsHc8Fq8Tr94l+5NX2NAmi2u3WC0v4lgpnjr5MiC2UzyHkY8XVLmxeJXR3PThMAM70U6UoZ3+20KgjN1Go4ZhDJ0BYdMMitIAUWdqtGEs2DsaRHjS7NjVt77QlAPNn9yI+HglphbBv3bJZCwlMGWiPtB6ywr9YQczJmRMwVhKcGN0jJXcOFWWiIXG5qHnjExJjKxBuBbi3faIKtFui/YY/Ac+cSVGpVSyaBeOnmQAHkowBWKomYFmkgHjkFWMHasidthk7aSr2I/x7nkJM2AJnFkHc9TEyBjbKtothFpwK65CVuGsAJ6/VXWjJhti0KvTpvnbTnPlltCQqAmM3fS5JX3tBT1TTy6XaxhnQAhB2kxjS7vu93tx2HotYSQiqdT5FDrWVD6osPKtFdbfXMeetBNJgwR/0cc94VB8scC//dEsF1cF5tsfIrxGUe1iCDwq3/vfuFb1+X/vLmAZLoa0eOfT7yRFSKQCpdoqfljj5Qtf7lFt0KcdqmUVYt+f0pC7VO7pdJqxsbGh0cFms1mKxWJj5sRKg7VT9bXtJ9nEiLDZeHfvlrj/9511bS0nCaIYrq/GSCGZzAjefxDz4XLMSg0mQij5cGdDYyowlaBgw7uOyzeyeYLy8u5T1SbTnXsxh1E0WPv2Gt4tD2vMwhw3idYj/EWf8tUy5ojJyE+NYOSNpqnPDnt+N4JEkjEzWNJCR5pMJjM06ba3YNs22Wy24RwypYmlDi7L6a5318iYtd13KxKJblyJ8Rf8bU8BlVbJtTs+y3+4jJEzSJ1NYU1ZSU6DOgjRVGSINzdFgMD48MauzTXWsG0PrnUSabLDZz9IdGM/L00TmUrvsmvK5/PDIxlQe8QWW7CVjSnb41gOe6HY8hZwTjjEfox/zyeqJkaKcS1ONjlDICzBqHJ4VoxyZiFmYjlEVL2Gva/GMRtxyDv3PuZq1WNhbQ3XTCN3nT4To8KqVyImJmVncKzGthhtPE0HZft3tBUClHpoQCiEwLIs0un00DADqVSKXC7XmBlQVvLZRoMNehea2Qj0ka638h9svjJLwVxeUHAEN9Y037oRcXtDM5MVVILEXTFlJjEG7pViPl6Jmc9LLFPgWQ4LQnNd14j2rJBbKjF72k6kZO+V8Rd9Su+VsFdswrWQYClApRXWpIV7ykVYzUP3Hvb8rgeJTCzxZaLOjEXcF/1rv7E1h5raDLS5znYD0dYcaLMuJXBOOvgPfMKNkMoHFYLFACNvEJUi/CU/KTPr4JxwkJZs7BUmkuRo5bxNeUOQ37wcaM013+d2EPCp7xNqzVoc86HnMaIUM6bJaau9Q+rQwTAQjr3rPWQymcNlBrYWesdxsG1732IvEKSM1IFyrAeB7JUk2FCwGFC9XiVYCghXkwQaylWMf3aMlwuz/DvxE2Q/ehdjvXkAi8Uw5Krn8T/dX+B+GBIB6yzXLSsQuHaGmZEzFNPjB/B09VvdBb0ZNq/lrH8ort4qK4TAtBVyc/JKKUmlUhSLxf52uQcUi8WGzCsAZhqMOoxYNzzT7uHpvr698sTNnxlL8MXTBn92K+LthZj/4o98JtJwIif5+UsGXqQ5W5T8cCGi4mt+/+OQv/S0yYxjsJgZ55r2ea98p26UUCEE7mkXI28QroZsvLXByrdXsMasxGvH14z85Aip8ykyT2Y6HJjhgKEMbGVvqzPjKCafz5NOD1esD9d1GRkZachQO4aDa7jb3lbDDGlLRn96lI0fbbD+5+vc/2f3EabAKCTMgJE1yD6fJf9SHme2PQnNwpjBiC+3mYFyHPN/rq7ygVfjuu9TjmOueT53g5A3q1VedFP8e2Nju9aAQdsM7ERHskPLRGUyie3AJsbGxnpWbfVFySSlbBi20zZsLGUlXPcRiZAlDIE5ZjL+c+MEywFRKSL2Er2okzb5VX2eCw8iMu98gKq0zuGelpIZw+CvjoxS28yyVTr/GjVnlNXybm5eColl2ORSIxjqkPSv9TbJutS6V1ydBHxyMhbKlAihsW176CyzR0ZGyGQyTdQEKTDrMAMd2E60dV+PhpqQxCWYSAn+vZctfuUpkyhOpAWOCZNpiR9pfv6iybqXqAemM5LprKBimHxz4hQ3oxV0tN60aZVV5F/Lk7mcIfaTOB46TBLjWCMWMj0cEp9uYCublJnaPvkKIcjn86RSqUPu2W60YgZSRoqslR1wr7qETLyw8i/lSZ9P4y/6SWwXkvgC0pWJjUC+/XXjx5lV/Kzg0uZSZAvBT6TTPO04bEQRgdYIARJBVklmjP1r62HKrTpaCiwbmckidtDC+Pj44ScqgocSgn2dEZtWrpsiLD/yh55rFZsp5JSTuLOYY2YSzMiLKdgO46bLcx+mmNjYwHzQfBHdgi0EBcPgiusmvtxCsF4YpZw9wb3RGeIY4k0fbiklSppYho3sp+FlI/SNHd6UBAiB5SqkkkCEaZpDox7Yguu6zSMQGg4YnYoQuxxEDQjNrvTHHZgfSJKgQk9NKJ5qVnZHO7EULErF+7bFktfYN327DVNiT9ps5jB6pGBKE1s9fNdCCFzXxbaHS4TcSk1gKxtHDZedQyMIkYQhVo7CHDMT93A/iSdgFs0kiqzRWbbI+1aVvC3Qto3wAwytmTdNpg2DcI+HgRSCzJCtSZ1AGAbCcXYd2poebtpEX5gBpRTpdLrhCdBSFjkrx3JteaAhM/thsKRSajt40esrU3zpzgQn/+THGOX2fVrTUm5LB7b7dvNNymMbfPT6Fymtx/jeITFJ7WoC2rUNUgI3m0gGYh0PpWSguXGYALcATm7z73a4pXpl2uSyttQxdY0FG5XvouyOdgLDZsUw+MPabUrR0Y1Y14/5nTbTFOzCroW0WCwOnZpgywi3kSg4a2XJ2/m63w07jEKP64OA+5TJOhbMT8PdRYy1Eqdb2H0Mi3dTp5C2jcpmdzED/VDD9oU9klLiuu4+QhWb/2xlU7SL/XUxbAOtFop2pBRCCFxt8NNrc1z5RDP+5g2UF3Ym1tnMib6dG10IRBhglx8wc/OPSHsPtt3xdpUbBnTQDSETt0LTVpuxBsRQMgMtx9jJgb0lcm1nAOqV2XGtXT6vE36wh7LX81O8NzJHNfKJdO9pbw8L/ZjfKSNFzs7tUhPkcrmhYwYcx6FQKDS1Gdip7hhm7A3x3ujTEQSElmR5NouXMpvWu/UZZhl1UxdIx0YV8rvUBP3YM/rCDAghmqb6tKRF1sqihiXC3ibamThWLMmHJi8u5TlzOyJ3/QEy7M72YVdgvzjCqK0zsvAW6WAZS0V0tsK329rg7pUqYQYMQ26HJN7yNDlSsDKJEWE7aGeoGpLZXhP+9prstqze/NxK5fk4O4IfR5tpex9NtDO/HcMhY2Z2MQPpdHooXQubiYJtZeMq93AV323ioBiW0JAsjTl4dnvrzbAMVb0Z2MjeGDZtBrLZbQPCfh0i+8IMGIZBsVhs6I7jmi5T6an6QTGGfC16vTTNX7pziid/+33Grt7vqa69UlvhVTBuvMds7UNOG5/SX161F1Jv91S7+0snbeLsCAoipSSXyw2d/rUlnELyUTaJL2+TQWhHg9DRza1oYO/3nZaH71Pjm1SIBzH5hnx+56wcY85uq/JcLjd0BoSmaTa1GchbeYrOIXvsHPK7LpkR355cY9FtpvoaPoJs24tg86fMZDCnpqDPh6y+qQlaSQZyVq6+ZGBY2LM9cGODZ6pjXPo05NS7SxjVABn11xtCACKOse59SPrmW+RTEbY5ZMTa9P3s/tK0FZb9kBkYVjVBSwiZxBlw8kk0wkERqaaNtjoxGtj8fpOkPMPmVmGWBQnLQbmrLnaMIZ3fW3ANl6yV3SUZkLJF2vVDQKuT35bNwKGqCQ55yGoi5CNrlQ0HaCjZGUwnD0Ljt1VOOg4qv1tN0A/0jRmwbbshM2Arm7ydr5+jYMj2PgCpBdnI5JXSJJc+8ph9e2GbETiI7lp3PsS99n1GU1Vcq3sDS6319ifWMbGO0TrevJb8Hcc7r9V7mu6f0LQVlmvsmm/N6GIosWnTgTLBLSY/e6rvgMp20YeaafPJ2DwLEtaD0gE1tgdDOL93ImWmEsO74dr7O0bWylKwC4fdjUOFJyI+NJfZSAlEupFkZzAEueVs3W7ZtssJgdhkBugzMzCQI1vaTDObma0fIasPk7CvYU41vFyb5vwDkzd+92Osjdp2vnboz5pRz87cqK4x/Ud/H+a/QDj9CuWNsKucG7GOqPpl1svL+GENy3QYz8/yYO0OVb9EEPmMZCbJporY9QLrbJ0k233QHWWzIzbZ0SOmEmgEy4WRM1BdBr/eKfowQ5R01/wDqfgX6RR3K6sQDig88LDN7z0YcUaYyc4g+3MuOjSMOCNMpCawlIUXeX2P6TIMoaTb6YMGKtMFNsIU6ZVVRLx3HESdUGkHgza9g9svIwSqWETlsgjX3eVN0A8MhBmwlc2IM3JgiTT6RaR2rBiJXc7d0Zy565FarUHUf1fIur2NI8z1BdKl2xRqt6gyQYTsgmIFURRS9ct4YTWREmxKA+I4kQ7UgirKM7AMp/7YdXmatVMmTvohwzdsotaOoCxIj+0JS7wTbT7bQa04HdSpgZrpsmpaXA/LVDY9CA57cW8XB9nPlJkib+WPNq2SJFqylEXaTBPpCD/qbzrfYaCVln3Y/Ho9I1kqKFKi/jQRe34OGt36JyElKp9Hum7fVQQwYMnAYWfVaojNE3g+tnnBm+SlH9xn5mYFHfbX7arpvqA1olahsPohKSfmQfEvEAsHHTcS5devSQhBpCNqQZlaUEUIidYxhjKxTRdTW3hBBS+okE+NQh/TS6dyFun8IyIZMBwozCU/293Q95Y7ZOHBTqymR7nr2HxYuTMYw8EjAIEgb+UZd8eHYrPrBVJITGky5o4RxEHfmYGjhPs5zadBzKzokx68EVrM7x6ij9StSyqFOT2NzOValu8GA9mdU2aKifQEaSONKU2CePgCnVwKxrhwT/DT310kf7eM9vvfx2ZEsPWdWrqDVSkx/9qzLDPGYq1eiNHGNQkEWbeAPfEEWsdIqbAMm0JmYpcNAYIesyLuR7pokxkZLpesrmG6UDyVhCYWTabw3iSCOy8MQhbZJr5TnOJN2yT2bh92V4YChjAoOAWyVnZXBMKjDFOZnMieYMPfYM1bO+zuHBred1aoZEq8ZhkQh7vUvH1Fe4KKhtc6ykcAoBTW/DzGAeV5GQgzoITCUUlQDEc5Q8UMGFriaoMzS4oz92ImblfRtZCuFPab6GX9F34NFcdk16/jObBmZggC0G1ooBJRp8ZUFuYe8bYlVWI0uHkq7Egs2s4DCbBdA9sdUulPp1AWZCYeqgkajcF+xV6L7weLGEEsJdcNyQ3VfWeGQWfcTyipKNgFHOUMPBjaQUEJxYgzgmMMliHfXlOGhD7WlMeiGRGlXYy4hqi1zh/TCfrF32/V0W59QkrU6CjygNxeB2Y1I4VkKj3FWGqsq/sPKqdBMXZ4wh/lZ/+4xuvf3UBXqj1zkj0TSuiT/fY/ZeTWnzMxBqrp/tqZq9lWVMh9aBryqv7l7SAYAgxT4WYtUrmjlaGyIaw0jF1MfsLhbuo9RDCMlEHZyfKm/4C3vdZxMjR6Xz2DYAQGnbPEVjbnCufI2Qcjcj0MWMriTP4MOWuwz7S1pvTjHXZbx877aoSUzJDgzCxxsf9j8XAm9Idm255ZhoE1P48qjvSl3b0YCDOwlfxnKj3FuNtdWt5+L0ZCw2yY5fnbNl/9E5/sYgWqtb620QitSEgAQse4Dz5h4u1/jqvLGGbvz78rUtVepqCL6rduMSxFZsTGsNShn4T7BmkmOQpSo0kAor6hiwWkI1nibiy5Ob43eY4VpQji1jYwgv1WV4M48Q36VGkpi/ncPBnzaKZergdTmpzKnRo4M7CFfrzDbuvYu5aFSnB32mIj253Up71ZOliaFVJizswcmM3AwCQDAsGoMzoUvrBSC2ytOFlyOL8gefIjH7vsQ58NBhuhHgnVIz6r9IDsrbdIR2vYMmheuB4GdNhSpiSdtzfTFg9RXoVeIBWYqSTwkNPPBDBtjE3L96b3/KxfQgNrhs172VHKQvTF3WzYs462C0MaTKYnceu61x5NGNJgIjVxoDkKtmOZxJufnb/vvHbIYa4jCXeLUOpSY7LP8E9rIq0JNz9bzxjt+MQH+dxSIiwLNTJyYGqCgSp4zxXPsewtD7LJuiLOYuww7bn8lX+pyT2ooVcO39im7tT1q8jA4/TKt1nOnOWq9VwXVicHDztlMHk6h+08GrrXXSiegrELsHqTzriwHga/5a3tOUdpobhFwO9Ey6y2ylPcJoZFL7yFblUYjnK4NHLpyGb6qwdLWpzOn2bMHcMxHKphtWHZrlU/GnSYpBsmBmGLhNy3+ExJkr78kE2HairiG6P3kakyJ/pU52oUEWyuAQWpMIRgOYqQgBICRwgMwDyAw5DK5zGnpjDGx5ANAyr1hoG9MoFgKjW17cYzqBPGToIXWpDVFpcXLJ69q0gtlZCV4XXBEYDWMebdj0mPKSbOXGS1auNHw7XpmraiMJlK1ASPGjJTkJt96BnQFnpZDNpkJFq6NQluFme47dqs+CXCAaYOHyS62dBMaZIyU4y74wM3tjtoKKHIW3kmUhPc3LjZUBrULVOnQ42/5CcbvgQ8EgZBa+JanEgGDYE5biL6oNrsFhGae6pEKS2hkIe19Z6MwgE8HbMRxyyFIadtm7SQLG5KkyUwohRpKTHpvxORMTKCeeIEQqkDk7wOlH+bSE0w5oyhpCKKo8GKHDUYWjAeOFy+Y/CZ94HV8sG5nfQJAjDu38CVNhMXV6h4owSx6pWuW6MDajZtRWHcxbCOdhS3ushOJsxAZ9xAAzQa1H3+ia3RopgWguuFaW6qkI3wQftdfESx8yS8lalw1B3FEI+I9wsPPYQKdoGp1BS3Nm71vQ0dacLlEJVRSFMS17bCtGvCtTCxRDIERtFIdpdNOh20N0osNEuiQjmdIx7NIDZKiB4DyHlasx5F3AgCRg0DqWA5Col1wgwYQqCEIEP/hbJqdBRzdpZ+Rx3ciYGu3o7hUHSLnM2fJWUONitYRlvMV1L8+9/I8srbPtxZGHpGYAsaMBevM/L7f4/x6A6FwgBeW5s0p0yJm7EYPZHBtB+dhXUbE0/CzBX660zU7vXuEQK/bxu8afRHWnPkbAX2dHfnRnQmf4aLxYtDl1K9X5jNzvLU2FMHEuRNSIFKJYbCOtbJhm+AMAX2tI05ZiLsHcbJm+9hHyMwIHIqjaa4f26U2OxizdzTR1+DKSRPOQ45pVBCkJOSE5bJuc3MrE13lB6e2Zw7gfPUk4gDzPMyODXBpgV7ykhxInuCxeoi5QFkThOAgeLSssP5JYvivTLGhgd9zkB4ENg6LwqAKECV18guf4jWsG6cJY70wUsIWsDNmrhZE8OU/QxmODywMknCIicPfgkONbJbO5KFJDvhupXidlRhif4YxQ6brUBLNOnuuDvOVHoqKfYoGLvuwagzylx2rn5iuB4hlMDIGfvHV4AwBDrSCEu03lkGNOxrruZ2IWJEQMfb6J4+5qTEFQJTCFJCIoVg1DBwhcQWAgk4QjQWqnYdfEZgFIuY09N9T060EwM/yqXNNBeKF/hg5QOWawdsTKhBIkhh8tmbGV6+biDuXutZdzQoiD2/a60p3vweVukBCxfO4fsQha2e5QDTcgjIj7lkRpxEh/gows5AagRyM7B265CZgWaShYfvt+RkuJsd51N/hQfiaND6IDGbmWUuN3f0GJw2MZmexI/9A5F8CENgjvaYyXOAWHQDro5UuSQ1vURAEUIwbe5/7qx8WGum61N787VZSIkxMYE1P3+gzMDAV/C8neflqZcP3opXg4nidMnlP/rzGZ56p4S4frsuI9Dv5fIgl1+5uoi7dI1zle+Ti9rRBW9a+x7AwieA0RMZChODVfkMHGYK5l6BzGTzcr28+G7dRbe9DB++34/dLP/f6AzVRySyXj8hEJwtnOVi8eJhd+XAkLNyTKWnmMnMHFrMgWHBTWOd7zp3CXMuOP0xFu1mmje/pwkj4DjYTz2JMT2NzBxsTIyBMwO2splKT5E1s1gNM8L1iCT0PqdKDheXHE7dDkiveoiaV3fY+71NHtR5QwAiClC1DTJLH5EO13CtiJbkeUAdEkKQHXFI5x+RqIONoCwYPQdOi4V1n3NyB2106y66w+5QA4EyWVSSj0TE8AT9Hg4Y0iBn5yg4hUd6kzSkgaMcJlOTZK16uU0eH9RkyJryCfIp4lR/clB0s5w2u6dp8FfTxJqbQ2WzB+pJAIfADDjKYTYzy1R6ilFntK17OjVeEoDSgq9fn+RX3s1jvH8NsdFf+4TDFL6Kagnn7W8w7t9gulBrYmCqd//e505LKZiYzzEyk+5vxcMGKw3zr0N2qrP7BiyF1kJScnNcw+d7ldt4ejBBtHrFoIwTM2aGC4ULjLvjpM30I2kvsAVDGlweu8x0evqwuzIw1KMjTRKAqHxqAm+if9LoflJsMyqUqRTuCy9gjHcXubcTDJwZ2JqAp/OnOV8835berm3dnk7CDJ8tpfmbn5zi5HvLmNfvbNbR9LaOcZjLyJZRYfqjP2PkB79JPhNj201kHltqgnZOrm0Ohps1GZ3LJMaDj2J8gZ1QFhRPQ/4EpMdp/fY7pKh9xXXz6w0q8KXiOxNnuZ4uErYRenhYMCjdfc7K8fzk8+Ss3CPNCEASS+GZsWeYzcwedlcGhkZ0FAu4NqG530fN9KCoR6Zc3GeeQY0cTD6CXW0deAsNMJWe4kTmYWyofp0Oxnyb0xsOz9+2yS9WUGvlli/uqC4L1sod3HtXycYr2NQ691zrQWdiuQb5cRfTVijjETUe3IJU4OYhNZZkMmy4kWynbupCRaD3XqjzLrYMBXeGI06MjzQQSMXVVIYF0yJu7uQ0cAyDa2LaTHM6f/qRCkHcCFJIZrOzjDgjWPIRV+O1QCzgTiZg2R0cg9wPaheOg8xkMaemDiwE8U4c2ir+7PizvDT10rb7Sz9OB4YW/LWbZ/iFdzOkv/0Ocr2y/V23L+fwl7AmiCOM2hqn3vsnjC6/i9mpL20PD5cbdZm/PIrpPIKxBRph/BLMfwb2+m9vj+MOGu6YnDsxGhD7fo+FoiIkfxAs8VF08C677WAnA3DYlvuGMBh1R3l1+tVHKgRxIyihOJU7xen8aeZz85jy6HgA9BsRMd/K3OW91BoYg1mv+kHt9pkzuE89iSoWEdbBM3SHwgwIIcjbecZT48xkZkgZvXM9Z8sZfm5hlpl3F0l/+gCh9T7XvK762nPPDhhRhHpwm3z5JtPcQnXiV97lw0klSOUsRmczj75UYCdGzsDsC6D2LKztjGPbjFedgm3cey87xoejc6xGVby4d/fHfpzkD5sB2ImTuZPMZedIm2nUY+BlsZUwbCI1weWxywdnrH0EoIGS9KmmDeLpcbR5NA4w1tmz2JeegAElfzu0lTxtpinaRWYzs6TNdPeLjwY3UpwtpfnsvSKj11Zw7q/1t7NDDKFj5PoSmcodxv2bmCJCHLBvuWkr3KxJbsxFqeFZ8A8cuRmYuASmu186sA/7QuC1WbZOwTaGeCFd4KP8JOXIbytVccPmG0WM6xbb5g/dz+9eIRDMZeeYzcziGM4jG3mwHkbdUS6OXOyMGRhqcWgXEFAVATXXIJgsovsqHagzefoBIbDm57HPnjnQEMQ7cajHuqyV5UvzX2I2M9tw8Wm1iLix4q8uXOJLP5ZM/sHbqIrXoJ6jhs56bN54j8x3/h9mc+uM5DqLwd1JS1IJTjwxwuiJTJKL4DHiBXBySZ6C2ZcSY8J6qKcyaIktW4Du8ZbS/Esz3s6q1hH6IEJrNU+7nd/9oC8hBK/PvM7zE8/3XtkRw1x2js+e+CxZK9s+E3SE53QjehIINrIG186k8e1+bnv9kD/vqdEwUIUCzuWncJ5+ui91toNDlZfYyuZ88Tyj7iimNAni/Z7RzU4oJ/wM89UUJ6+uUrxTQvmNT0RHj74767GIQ6RXIX/j+0TZM2y4lwj8uK1gi520JJVg4mSW3Kj7yFtk74OQYNgw/TTU1mDlep0yXVfe1V2hVKymitwTmrvBxqEwvTrUxGHMdpbkLVMGnSS2EVIkqW0duY9mDlqVYEozCYGeOcF46uDds4YNlrLIWTnmsnP4kc+98r3D7tKBohk9rVshH+UqTKuYYc5VKdNp7PPnUYXCQGwFttsdWEt14BhJTvGJ1ERniYs0SA2XakU+vzzFiTdvk7u10uoWOjl9dRsQ7kDRqrE4JP/+N8jdfZuUuydyZV/MW0EakqmzefITj75Fdl0oE+ZehuLJ5uX0jrgO/SSSPXUFyuRWcZbbEu57K4ditR+HMVE5ItwICddDwlJIVI6IyhHBSkC4FhJtRNupbg8Mev/J0FEOY+4Yc7k5JlITB9f2kGIrXfPF4sVd3lvDAn0A8U8aYcXy+XFunZra62kzXHJjmcvhPvccKl9AyP0M9IG1O5BWGkAgsJXNs+PP8vm5z7edZSsXW/zyygU+9+dVLv7ue00lAg/bevh/e33rb7m+oJ3GamXyyx9y/vo/JxWtI7d0+tv3NiD8NuZDbtRl5lyewkQKN/OYWicrC+ZehalnoXCqse2A2BHXoZ9BLvbUta4Mfrs4zg278VnnoBkEIZO0tTrUxF5MVEo2fiRoT+Mv+3j3PWJvh/TgQDqy/2R4Kn+Kr539Gnk7P1QGjYOEEoovzX+Jl6deHroxEPXinxwQVkWN943FJPjQaHFXL4YGhoE5M03+Z7+KOTFYSdbhMgNCIIVkJjPDxeJFTGm2JNax0GW+kuL8dY+xhRrOWo1B5GIZLt6xPgSJQaGqruEuXSOrV0nJGi0N1Jpc3ol0IfEgMCz56CYmagmRZDLMTcP4hf2eBU1Rh4pE86+bVRUok5Jh8pGusd5klz3wDWAr3IEEFAgltk980pbJxxo8vZjSZMwd4+LIRWxlP35qrU0IBJPpSabSU4y5YweS2vgoIBKamgipFVz8XGvJ5mGs+cb4OOb0NMbExEBVBHDIzMAWLhYv8trMa7iG29jtZ3PBeaY2zucWx7j8B58yemNtYBkIO1pGeu5SbxXIyjrq5lWmucWkudSvTjEyk2H+6bHHy51wL4RIPqPn4OJXkiRGrdCuUWEnEgQBZTvDouXyo/JtlgaQDrwRdKzRoUZaEpVSqIzaVgkYIwb2hI09aSepbQdEOgJBxspwMneSl6ZeeiwCDTWCEIJxd5yTuZM8OfpkX1y5jyq0gNWZHBuTmZYr4sBZRyFwn3kG5/LTyFwOUSdL4kFiKFhEW9kU7SKvzbzGe0vv8cnaJ/vKFGKbZ7wJXvteifkbHoRRXxiBJH5bn7Gnws7b2F26uz5q0m/9K/T4Bcaf/mXW1sHvMnONVILcmMPITJqRqdRD1cPjjMJJMBzI/U8QeeBtUPct9UJgO++tE0r6rZFZfpTKEAZ3DzXCn7QkogFNCLnj+gB5SEMafHb2szw5+mRbEsfHAdPpab5y6itcX7/Our9+2N05NHw44iHWA5oF+D2QfaEVlCL9xuu4A/Qg2ImhYAaUVNvGhMu1Za6vXX8YTlVDWpuMeRYX7xvM3PEoLJT7JhHYcuraevGdEIHWOskMpzVyhwhyZ8/kZn29iChbHRj3Spq3jLmNlXs4yiXv3aUqRgmkje4iSq1UgsJkikzBxk49prYCe2FlIKsSpsArJZ96aJuY2E+M9e7VyelGC8Et0+K6ZaGDw1ViCSUaMgOHASkktrK5OHKRmfTMdpTTxx0ZM8PZwlmKdpEFtUAtqnVVj0YfWeZKA3ecGnknREgJcbzv+50xPgfFFAjbRuZyWHNzGJMtUqUfEIaCGYDEs+BrZ75G2S/z1v23qISV7dPOM94kl27Dl37nNtQ8iPprhdSLp+hiGBJrTUapZC3XGg+IN5mVnJRYQmAdkL5yb617/7ZXbzP7J79G9fK/QVS4SHWj8/jclmvw5GdmGX3UsxN2AiHBdODyL0HqG/XdDFthmwHQDwOL1OPsdrWbMAKhNHkzXOM7vnck7FkGCddwGXPH+OLcFx9Ld8JGyFpZLo5c5JnxZ4h0xNsP3u6qnqPKCGzhTececUrxtUwGXalA+HBNbLWeHhTM2VlSL76IdepUEn74EOxbhoYZkEgyVoYzhTO8Mv0Kf3rnTzGDmKkow6s/qnLyTpAwAnH9o22/pLGd9xtqWnPT98krhRKCB2GIAqQQrEQho8pgSnZ+OukLVxqFyPIa46vvYYmA6+oiWrdfa3bEoTidYnQmjfO4ehDUgxCAhJnnoLKUpDcuL0Ec0Pab25YAdGbUuWGl+WDsFPcNn0qXp7tHGWfyZ3hu4jkyVuaxNZarByEEaHhl+hUsZfHOg3eGLqHVIBChCV2T2skJzE/vILs4ILWLdlYCYZpYJ0+S+ckvIrPZQzN0HRr5mRCJm+FsZpZnxp8ho1KMhDbnNlJcuOZx4kY1kQg0UA/Ui+HW6MS01/27s6HfXavWmkBr1qOIWhzjxTEbUURFa2pasxJFVLuRzXfar30Pm1wQOkb4NbLrn1Jc/wRLRUjZ/lkyM2IzMpMmXbCxHqekRG1BQGEeimcgfxIM6+H1RtAN/2gPGkqmzdXCFKtS1g3U9bDo4yczUEIxl53jmfFnsJV9rCKogwvFC1wauYRruu1HJWy1mB4ViETNFtiK8mSWyDrYNa3lGi4EMpvFnJ3BvXwZ6RxeOKShmykXRy7y82f/Ip+1L/OVW6P8m7+5zsjtErpabXlvuyKedty/221lNY7xtOaEaWILgQRmTZNpw2DSUEwqg0wPiVHanmv7Hmb3BePG+6Svf5+zuUXyVoOx3NOYVIIzz47z5Bszx0aDjSBkkq/g9b8Fmak2yjf8o832YFHE/L/K434Ln9qjLs7tFIY0OJk7yfOTz/O5uc9hK/uwuzSUmEhNcKF4gS+f+jJT6TZoFlovphwt5rPswLvzsNHEyWQQTyMMg9zP/Azp115DFYugDi9vxtAd9UxpkjHSvOY8gUWItXYb3aGNQD3RzEEZgowqRQy4Quw2HBTJUuwKidOFimALvT7HtkGMjpHVDTIf/imZkefw02cpV/aQ+46KTUcxOpMhN+7iZh/fjGdNsSXOc/IJQzB+AaIarN1us4LO3qYGHmTGuOumueev4eku3UMeUbjK5fWZ15nPzWPJY5qtByEEgiRr7KtTr/Lp2qfcr9xvKmFqu+4jxHyWVMi76TVOGhEjQtSVOB/E0+yyD7ZtVD6P+9xzWKdOJQaNh4ihkwxIIbGkyRuZp3nSOon2PIg749HqvcSeXmwD/YMQgknTZNo0KRgGBcOguPnJK0VOKUYNg3QfX3Knz7GzvPTKpN/5BrnSTbKpCNmkMts1mD5XIDfm4qTNxzZgS1uwszB6HiYvw8jZDm7cHNMOyPtOfpKb6TwPvNXOsxP2AYeZfbAZJJKMmeHzc5/nVO4UUgwujOtRRNbK8urMq31LIT/02EN/Gyrg7dQyG1a4J277wWLXepxOY0xM4D53BXN+fmB9aIShkwwAib/lSy+DBv/adao//CFxqYHrVgt0KxHYdV+b+oee22njes+IY0au/QmptRtsnPnX8bRJuMc1zcmYjM5kuPzZmWOpQCe48m/A6Fm48wMIqhBHbVoQtVd9jOCbmSw/MiRUVluWPwgXMIHort4D3pefHn+ap0af4vLoZRxjmNPQDAcMYZC38vz0qZ9mKj3Fr//414n0QcaKPmTsoT+fiAeiTG1mnCiQyGu3Bi7XSL3yCrmv/DRGsYjoa1rl7jB0kgFITtzSdTGnZ0i99BKqWOh4sLozDtzRhy7v29l2L+102n47bW75z6rqKvbqHQrhAm68n8kam80wfjKLm7VQ5lCSyHAiPZbkK5h6FpxCcq1PK0woDapWipuxx724PQ+CgxLbDpM4eCu/ydnCWS6PJYzAsQdBawghUDIxtrw0comp9NTjISHYgkjCE5fzFuWiUzdQXLfQDX7fhlKYJ05gnz6NffYswhwOyetQr/TW/EkKv/gLWLMnkKnOCPUwh/Yw2u6kTVktY64tcKLyDsXg3i7PNiEEp6+Mcea58SQHQTNdwjEeQohEXTByGp7+OuS6zBDXYBXyTIflzCgf+svcrC3VL3QYOGSbMUMa5O08L02+xOdPfL596/hjAHC2cJbnJ57n8thlxtyxw+7OwLEyZvNgaqckadMLq4c6W8WtkbZN6sUXcZ95GvvcuaGQCsCQMwPCNFH5PLmf/SrZn/qpw+7OoaFf6+2uekIf550/ZmTlfeaKZQwZkxmxOffiBFNnCxQmH99Y7j3BHYGLPwOnPwvTV2hvWdnxZvb5yCZ/3Erl+P2pM6wrc7istg+RVxQIptJT/I2n/wZPjT2Fax7TbDfIWln+8qW/zJWJK23lcKhHf0NFkx3g/ewGP8qv7eh9a4Lu5UllLoc5P0/hL/0lnKcu91BT/zHczICUYBjY589jX7yAGhkZePKGRxVCa9TGMu76HfLr10lZEbkRm6kzedI5C9M2hkJ0deRgWJCdhMknE4NCw07cD7uERhAJybJSXDUUteNXso2iU2Q2M8vlscuMOCMY8phmu4EpTU7nT3Mmf4ZTuVMYYjhOqoPAfbPGPbsGtjUQQ0Jzehr7wgWs+XlkPn/g7XWCoX/rQgicZ55BplJU3/4xle99j/DevcPu1kDRr+WtXj3OzbexFz4i+sX/lNEnsjz5xvTjnZWwX7j01cTV8No3kwiFQaVOob2R0Dex19jJcrhJwLeqdygfggfBsOKV6Vd4buI5nhx98rC7cqQhhaRgF/jc3OeYSk/xX33nv2LD32h42q9nMzJMdiSd4KZaRzgKJkZhaQ3Ku+dpg4jg3UEpsl/6KbJf+AIqlx2oF0M7GHpmABKGwJicpPjLv4wOAqpCEN692/SeQ8k6dYhtd9umUBLlmJy9nCd9Jo005OEaXDwqMFOQm4NX/yZc/R248WewbyNvPdCRkPxo/CyfmJpqVHksw8fuRdpMM52e5nMnPrfNCBxLBLrH1thNpiYxpcnnTnyOqytX+WDlg0Pu2QAgILIMVueLZPwa1iYz0IBNbwv1Et+pYpHM5z6He+UK5okTIIfP9XW4WJMmkJkM7rPP4Fy6iHXyJBhG45juHLYBYUt70gNAd+2odBpzcoKx+Rz5CRcpxdAR6ZGEMsEtwOnPwfglSI02pdd60EAsJB9nityxXUJ9LBVQQpG381woXuDiyEVO5k4edpceGWStLFPpKa5MXOFU7hS2so/sib8TREqwOubiOQ+NT/tpQCgcB2NsjNTLL2GdPInK54dyjT0SkgEgWUgti8Iv/zLuCy9w5z/+20QrK22FKe4ZjfIENyzWyp60/+hq0ipF6rXXKPzCL+BcuoRwjw2w+gplwcRTcPkXIT8H3/xv6qsLmoh1AuBfUeI6wxFtsOvYBX0Sl406o7w89TJ/67m/RcEuII/OeeZIwJIWP3/u5yk6RTaCDX54/4dUwwGssQeNJvRXNTXfn67xwtWI7AE0nXrxBdwrV8h/7WuHGm64FY7MTBIiObHKTAZzdpb8z30N+/z5uoNb74zc0/n8AIMOdYpOn6NReWFZZD77WVIvvoB15gzCsoaSWz3SECLRCxZPwclX4dQbye/b2AplWf/2VbfAp8UT3A+rlMLhyE7Y9UmxR9JSQpE20nzp1Jd4feZ1clZu22DwmG77C1OanC2c5S+c/gvM5+bJW8Nl6NYVmpBITYS86yyx4oRg9c9AXbgu5twc6TfeIP3qq2AYhx5yuBmOjmRgE9K2McbGyH3lK4RLS/iffkq8vr4rtnTfwxFDjyeb7cT1Pfekl3DE21AKmUmT+YnP4DzzDNbsTE99OkYL5GYSlcH8G8nfa7c3Ux03f5vLbo5rhWlWontU6S063EFEIxwkHMNhxB7hC3Nf4HT+9HGUwQPCFmM1l5lj1BnlO3e/QxAHbPgbh26vclA07MuID+0V1h0D4dpovw9SOClR2SzWmTOkXn4F5+KF3us8YBw5ZgCSU6199izFX/ol3Cee4P7f+e+JSyV0HLcjze9ua94uuP+u5Eqz2sSenweAfc037k/qxRdxX3ie7M/8DCqdPrg+HeMhDAde/Gsweg6sLHz4++Cv04wm3rdMfiftUivRZbbjh4vnUWYELGXxxswb/MVzf5EnR598vCLlHRIMaZC1svy7z/27fH/h+/z9H/197lfuU4v2SKgGaC19UDSsScIT16bGqdYy2D/6ABH1xvhY8/OkXn6Zsb/+11BjY0OtHtjC8MosmkAIgTBNjOlp7CeeIPPG69hnz+wTwRzM1lzPraaz2g7CpFDva75OPy0L++IF3CtXSD3/PCqdPo7bMDAIsDNJQqOzX0jcDjOTdUvGQrDh5FiQcCPcIKqTUa29Fo8uAwBJ8iHXcHl1+lWuTFzZlgioHlKCH6M9bGU3HHVGOZs/y+fnPs9UegpH7ZHIHG0S24WNtGJ5xKyzlrYPYduokRHSb7xO6sUXUGNj2yrYYVdnHUnJwBbMiQmMYhH9K7/Cxu/9Hv7NW0mWwy4Xz0HhIEiiZZ2b9hbpn/gJMl/4PKkrVw6gF8doiK2FYPwCjJyCBx/C7e9DaZG97GEkFA+y49wSmmvVhYF3dVhgyCSZztcvfJ0z+TPMZecOu0uPFYQQuIbLucI5fvXJX+Ve+R6VsEKtMhz2K/3Gck5wKxBMCNH1KVlmMlgnTlD4pV/CnJtDOkdHnXWkmQEADAP36aeRqRTWmTMs/do/IHzwAML23bDq+YX2gkHGGWjT0YHMF7+I+/TT5P/iz6GGLPLV4wWReBm88jfh3tuJdOD6H0HpwbbuqqoMfm/iJB8HKxAsH3aHBw5Bsgl9ef7LvDH7BlcmrhyrBg4RlrIYdUb568/8da6uXOUfvP0PWKwsUgq6yyQ7rHjfXaWSr/CMAUYoQOv213IpsU6fJvMTP0H+az+LdfIk4ggxAvAIMANCCEQ6jTkzA1rjXL6Mf+0a/qefQhS1JSXotyPgIIVBrRwdRCqFOTOD+/TTuE8/jTE5OdQWrY88hEg4ttwMRD7MvwalBZAmbNwlkpKaMvhAxiyJ4ZZwHQQMaZAyUjwx+gSXxy9zaeQSWTN7rBo4REghEVJwInsCKSQvTLzAjx/8mFulW48UQ7CufO6bEXHaRcc+wvPbWstFKoXK5Ug9/zzu009jnT6NcJwjt84KrYdcpt4mtNagNbUf/5jyn32HpV//deKNjY4kBP3rDD1yBH2SLUiJdfYsI7/6q2Q+8wbG9PTQ660eG2xNO63hR/8QbnwH3vwNqpbLLdvh354Yo6TDxy7QUNEuMp+b52+/8reZTk9TsAvHNDsk0FoT65hKWOE33v0N/vj2H/PO0jvE+hGJiqmh4Cn+2z88QeruKnKhveyg9oUL2E8+ycR/+B+gcrntLIRHjW6PvGRgC0Ik9vzWqVPIVApzepq1f/bP8K5daxm6uP+dGXwFO9kHYZoI1yX/ta/hPHGJ9OuvJ0mejhhxPtIQiRgSIeDMF2DkLLgjfLj+Ce/U7lOL7xM9KotsG3CUw1R6ip85/TNcHrvMXHYORznHNDtEEEJsG3V++dSXuTRyiX/0wT/i2to1bpVuHXb3eoeAWAkW5jKMV6vkWpjriHSa9Ouvk37tNVJXnkVlswiljizNPjLMACTEqnK5xKKzUMD76COQEl2pEFcq6GA4orgdBLYZAcdB5fOYMzOkXnwR+/y5Y4nAsGLrneRPgJ0Fv0xlMcvG+ieoByvIOCDSvcUXgOGPMZA204w4I1waucRzk8/xxMgTZMzMMc0OIYQQGMJgPjdP0SlydeUqQgj82Ge5tkwUR0c2nTFALGGxIHBdQa5RISlRhQLG+Dip564kYfKfeCL57gjT7COjJtiJrUfSnkdw6xYr/8f/Sflb38L/9DrtnrrbFdQPNClRq8akxHn6adKvv07xl7+OGh1NpARHmEAfG2gNaO6V7/Hpxg3+ux/8He6W7rJcO0IGhF1MBoHgS/Nf4srEFX7x/C9iKQslEvuAY7odXmytsbGO+Xj1Y95bfo+/96O/x1J1CS/y2q8HjdDicF0Ud9CtpSUvejO88t11XvuTOnPPMJDZLMVf+RVSL75A+pVXYKc04AjT7CMlGdiCEAKtNcKyMCYmyH3lK6ixUbwPPqT87W+jKxW07zevo922eu9u+2jUmFJY8/NYZ86Q/amfwj59ClUoIIzj/O5HBkIAgpxdYF5IfvWJX+XtB2/z7tK7vPPgHfy4Ob0OBTogtayVZS47x5XxK7wy/QqzmVlsZSfGasc0O/TYekdKKCbTkxjK4C9f+stcXbnKmwtvslBZIIhbS2IFh8wIJJ3YRojmE3OV865GZLPoUmnbvsc8MYt5Yi7JPvjM05izs0mI4UeEXh9JZgA2iXVTbZB66UWwTFSxSPXtt4mCAFowA4ePDo5ZSmHOTOM+d4XsF7+AymSGLlf2MdpDykzhGi4/Nf9TuIZLEAV8sPIBQRwMtfi1oSqiDhlvuQ7O5+b54skv8tToU2SszED6eYz+I2/nyVpZrJMWOSvHrfVbLNWW2mIG+o2WKrGGSeaS+2KhuadKrNsupFNQqSReaYAxPo5z6SK5n/0qKpdD2vbBPMQh4ZFUExzjGMc4xjGOcYz2cXx8PMYxjnGMYxzjMccxM3CMYxzjGMc4xmOOY2bgGMc4xjGOcYzHHMfMwDGOcYxjHOMYjzmOmYFjHOMYxzjGMR5zHDMDxzjGMY5xjGM85jhmBo5xjGMc4xjHeMxxzAwc4xjHOMYxjvGY45gZOMYxjnGMYxzjMcf/Dy14/8xL1GgkAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def drawframe(n, prob_history=prob_hist, graph=G):\n",
    "    img_path = graph.plot(marginals=prob_history[n])\n",
    "    new_img_path = img_path[:img_path.find('.png')] + f'_{n}' + '.png'\n",
    "    os.rename(img_path, new_img_path)\n",
    "    \n",
    "    img = plt.imread(new_img_path)\n",
    "    plt.axis('off')\n",
    "    plt.imshow(img)\n",
    "    \n",
    "#     os.remove(new_img_path)\n",
    "\n",
    "\n",
    "plt.subplots_adjust(top=1, bottom=0, left=0, right=1)\n",
    "anim = animation.FuncAnimation(plt.gcf(), drawframe, frames=len(prob_hist), interval=(2000.0/len(prob_hist)))\n",
    "anim.save(\n",
    "    'output.gif',\n",
    "    writer='imagemagick'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "29b08ee5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import imageio.v2 as imageio\n",
    "\n",
    "\n",
    "\n",
    "list_of_im_paths = [f'Graph.gv_{i}.png' for i in range(3)]\n",
    "ims = [imageio.imread(f) for f in list_of_im_paths]\n",
    "imageio.mimwrite('example.gif', ims)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}