KCIF.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "imperial-deputy",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import dot, zeros, eye, isscalar, shape\n",
    "import scipy.stats as ss\n",
    "import numpy.linalg as linalg\n",
    "from copy import deepcopy\n",
    "import itertools\n",
    "import random\n",
    "from matplotlib import pyplot as plt\n",
    "# from scipy.stats import multivariate_normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "cultural-proposal",
   "metadata": {},
   "outputs": [],
   "source": [
    "class KCF_main:\n",
    "    \n",
    "    def __init__(self,dim_x,numnodes,eps, A, x, P, Q, graphs, actions):\n",
    "        \n",
    "        self.dim_x = dim_x\n",
    "        \n",
    "        self.ownpriors = []\n",
    "        self.ownposts = []\n",
    "        # could use below as TPM across graphs but for now they are randomly obtained\n",
    "      # self.G_tpm = G_tpm\n",
    "        \n",
    "        # the possible graphs\n",
    "        self.graphs = graphs # the graphs are the states\n",
    "        \n",
    "        # system A and Q\n",
    "        \n",
    "        self.A = A\n",
    "        self.Q = Q\n",
    "        \n",
    "        # fixing initial x0 and P0 for the real system\n",
    "        \n",
    "        self.x = x\n",
    "        self.P = P\n",
    "        \n",
    "        self.numnodes = numnodes\n",
    "        \n",
    "        \n",
    "        # adjacency matrix of the graph\n",
    "        self.G = zeros((dim_x,dim_x))\n",
    "        \n",
    "        \n",
    "        self.allnodes = []\n",
    "        self.time = 0\n",
    "        self.nextid = 0\n",
    "        \n",
    "        \n",
    "        # update parameter for all the nodes\n",
    "        self.eps = eps\n",
    "        \n",
    "        self.actions = actions # various errors that can be injected into each node at an instant\n",
    "        \n",
    "        self.priors = []\n",
    "        self.posts = []\n",
    "    \n",
    "    def reset(self,dim_x,numnodes,eps, A, x, P, Q, graphs, actions):\n",
    "        self.dim_x = dim_x\n",
    "        self.graphs = graphs\n",
    "        self.A = A\n",
    "        self.Q = Q\n",
    "        self.G = zeros((dim_x,dim_x))\n",
    "        self.x = x\n",
    "        self.P = P\n",
    "        self.numnodes = numnodes\n",
    "        self.allnodes = []\n",
    "        self.priors = []\n",
    "        self.posts = []\n",
    "        self.time = 0\n",
    "        self.nextid = 0\n",
    "        \n",
    "    # required, provide listQ and listR to save as Q and R matrices of the nodes\n",
    "    # also required is the initial adjacency matrix G\n",
    "    def create_nodes(self, G, listQ, listR, listH):\n",
    "        \n",
    "        for i in range(self.numnodes):\n",
    "            node = KCF_node(self.dim_x, self.nextid, self.eps, self.A, self.P, listQ[i], listR[i], listH[i])\n",
    "            self.nextid = self.nextid + 1\n",
    "            self.allnodes.append(node)\n",
    "            \n",
    "        self.G = np.array(G)\n",
    "    \n",
    "    # does it ensure infinitely many occurrences of each (graph) state?\n",
    "    def update_graph(self):\n",
    "        # print(self.graphs)\n",
    "        idx = random.randint(0,len(self.graphs)-1)\n",
    "        self.G = self.graphs[idx]\n",
    "    \n",
    "    # require the observation z for this\n",
    "    # and the injection e\n",
    "    def single_step(self,e):\n",
    "        for i in range(len(self.allnodes)):\n",
    "            \n",
    "            self.allnodes[i].set_nbrs(self.G)\n",
    "            \n",
    "            # note the observation\n",
    "            z_curr = dot(self.allnodes[i].H,self.x) + ss.multivariate_normal.rvs(cov=self.allnodes[i].R)\n",
    "            \n",
    "            \n",
    "            \n",
    "            self.allnodes[i].prior(z_curr + e[i])\n",
    "            self.allnodes[i].update(self.allnodes)\n",
    "            \n",
    "            self.priors.append(self.allnodes[i].x_prior)\n",
    "            self.posts.append(self.allnodes[i].x_post)\n",
    "        \n",
    "        \n",
    "        \n",
    "        self.update_graph()\n",
    "        self.time = self.time + 1\n",
    "        \n",
    "        self.ownpriors.append(self.x)\n",
    "        # updates the true state as well by x = Ax + w (w ~ N(0,Q))\n",
    "        self.x = dot(A,self.x) + ss.multivariate_normal.rvs(cov=self.Q)\n",
    "        self.ownposts.append(self.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "upset-calgary",
   "metadata": {},
   "outputs": [],
   "source": [
    "class KCF_node:\n",
    "    \n",
    "    # dim_x is the dimension of the state, ID is the unique id assigned to it, eps is related to how x updates\n",
    "    \n",
    "    def __init__(self, dim_x, ID, eps,A, P, Q, R, H):\n",
    "        \n",
    "        self.nbrs = []\n",
    "        \n",
    "        self.id = ID # id is the zero indexed identifying value for every node in a particular KCF. it corresponds to their\n",
    "                     # occurrence in the adjacency matrix of G\n",
    "        \n",
    "        self.x = zeros((dim_x, 1)) # state\n",
    "        self.P = P # cov x\n",
    "        self.Q = Q # measurement error noise = cov(w)\n",
    "        \n",
    "        self.A = A # update matrix of system\n",
    "        \n",
    "        self.H = H # observation matrix\n",
    "        self.z = zeros((dim_x, 1)) # observation = Hx + v\n",
    "        self.R = R # measurement observation noise = cov(v)\n",
    "        \n",
    "        self.u = zeros((dim_x,1)) # info vector\n",
    "        self.U = eye(dim_x) # info noise\n",
    "        \n",
    "        self.y = zeros((dim_x, 1)) # fused info vector\n",
    "        self.S = eye(dim_x)\n",
    "        \n",
    "        self.x_prior = self.x.copy()\n",
    "        self.P_prior = self.P.copy()\n",
    "        \n",
    "        self.x_post = self.x.copy()\n",
    "        self.P_post = self.P.copy()\n",
    "        \n",
    "        self.eps = eps\n",
    "        \n",
    "        self.inv = np.linalg.inv\n",
    "        \n",
    "    \n",
    "    def info(self):\n",
    "        return self.u, self.U, self.x\n",
    "    \n",
    "    \n",
    "    # G is the adjacency matrix at time t\n",
    "    def set_nbrs(self,G):\n",
    "        self.nbrs = np.where(G[self.id] == 1)[0]\n",
    "        # print(self.nbrs)\n",
    "        # print(self.nbrs[0])\n",
    "        \n",
    "        \n",
    "    # all nodes contains all the (instances) nodes in this particular KCIF\n",
    "    # z is the observation that this node receives (z_{k} for node k, that too could have error involved)\n",
    "    def prior(self, z):\n",
    "        \n",
    "        # saving prior estimate at time t\n",
    "        self.x_prior = self.x.copy()\n",
    "        self.P_prior = self.P.copy()\n",
    "        \n",
    "    \n",
    "        # information vector and matrix for node i\n",
    "        self.u = dot(self.H.T, dot(self.inv(self.R),z))\n",
    "        \n",
    "        # print(self.u.shape)\n",
    "        \n",
    "        #u = self.u.reshape(2,1)\n",
    "        \n",
    "        self.u = self.u.reshape((self.u.shape[0], 1))\n",
    "        \n",
    "        #print(self.u.shape)\n",
    "        \n",
    "        \n",
    "        self.U = dot(self.H.T, dot(self.inv(self.R), self.H))\n",
    "        \n",
    "    def update(self, allnodes):\n",
    "        # to fuse info vector and matrix we first include the self u and U, then we add the values from the neighboring nodes\n",
    "        self.y = self.u \n",
    "        self.S = self.U \n",
    "        \n",
    "        \n",
    "        \n",
    "        nbr_info = []\n",
    "        \n",
    "        # print(self.y.shape)\n",
    "        \n",
    "        for j in range(len(self.nbrs)):\n",
    "            idx = self.nbrs[j]\n",
    "            info = allnodes[idx].info()\n",
    "            \n",
    "            self.S = np.add(self.S, info[1])\n",
    "            nbr_info.append(info[2])\n",
    "            \n",
    "            # print(info)\n",
    "            \n",
    "            self.y = np.add(self.y, info[0])\n",
    "        \n",
    "        \n",
    "        # setup for update\n",
    "        Mi = self.inv(self.inv(self.P) + self.S)\n",
    "        P_norm = np.linalg.norm(self.P,ord='nuc')\n",
    "        gamma = self.eps/(P_norm + 1)\n",
    "        \n",
    "        \n",
    "        # x hat update. this is the final estimate at this time step\n",
    "        # print(nbr_info)\n",
    "        # print(np.stack(nbr_info,axis = 0))\n",
    "        \n",
    "        \n",
    "        # print((self.x).shape)\n",
    "        \n",
    "        # print(nbr_info)\n",
    "        \n",
    "        diff = np.zeros((2,1))\n",
    "        \n",
    "        # print(diff.shape)\n",
    "        \n",
    "        for k in range(len(nbr_info)):\n",
    "            diff = np.add(nbr_info[k], (-1)*self.x)\n",
    "            \n",
    "       \n",
    "        # print(type(self.y))\n",
    "        \n",
    "        \n",
    "        \n",
    "        self.x = np.add(self.x, dot(Mi,(np.add(self.y, (-1)*dot(self.S,self.x)))) + gamma*dot(self.P,diff))\n",
    "        \n",
    "        \n",
    "        # print(self.x.shape)\n",
    "        \n",
    "        # now update P \n",
    "        # this is the P estimate as this time step\n",
    "        self.P = self.A@self.P@self.A.T\n",
    "        self.P = np.add(self.P, self.Q)\n",
    "        \n",
    "        \n",
    "        # saving post estimate at time t\n",
    "        self.x_post = self.x.copy()\n",
    "        self.P_post = self.P.copy()\n",
    "        # print(self.x.shape)\n",
    "        # transform into prior for next state\n",
    "        self.x = dot(self.A, self.x)\n",
    "        \n",
    "        # print(self.x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "fundamental-watch",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "x0 = np.array([5,5],np.int32)\n",
    "n = 3\n",
    "dim_x = 2\n",
    "P0 = np.array([[10,0],[0,10]],np.int32)\n",
    "A0 = np.array([[0,-2],[2,0]],np.int32)\n",
    "A = np.eye(2) + (0.01)*A0 + (0.0001)*dot(A0,A0) + (0.000001)*dot(A0,dot(A0,A0))\n",
    "# A = np.eye(2)\n",
    "eps = 0.0001\n",
    "Q = np.array([[25*0.01,0],[0,25*0.01]],np.int32)\n",
    "\n",
    "\n",
    "graphs = np.array([[[0,1,1],[1,0,1],[1,1,0]],[[0,1,0],[1,0,0],[0,0,0]],[[0,0,1],[0,0,0],[1,0,0]],[[0,0,0],[0,0,1],[0,1,0]]])\n",
    "\n",
    "actions = np.array([list(itertools.permutations([1,0,-1]))])\n",
    "# actions.append(np.array(list(itertools.permutations([-1,1,0]))))\n",
    "actions= np.append(actions, np.array([list(itertools.permutations([-1,0,0]))]))\n",
    "actions= np.append(actions, np.array([list(itertools.permutations([1,0,0]))]))\n",
    "actions= np.append(actions, np.array([list(itertools.permutations([1,1,0]))]))\n",
    "actions= np.append(actions, np.array([list(itertools.permutations([-1,-1,0]))]))\n",
    "actions= np.append(actions, np.array([list(itertools.permutations([-1,1,1]))]))\n",
    "actions= np.append(actions, np.array([list(itertools.permutations([-1,-1,1]))]))\n",
    "actions= np.append(actions, np.array([[1,1,1]]))\n",
    "actions= np.append(actions, np.array([[-1,-1,-1]]))\n",
    "actions= np.append(actions, np.array([[0,0,0]]))\n",
    "\n",
    "\n",
    "actions = actions.reshape(45, 3)\n",
    "actions = np.unique(actions,axis=0)\n",
    "# print(actions.shape)\n",
    "print(type(graphs))\n",
    "# print(graphs[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "tutorial-moore",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "kcf = KCF_main(dim_x,n,eps,A,x0,P0,Q,graphs,actions)\n",
    "print(kcf.nextid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "polished-reporter",
   "metadata": {},
   "outputs": [],
   "source": [
    "listQ = np.array([[[3,0],[0,3]],[[5,0],[0,5]],[[1,0],[0,1]]])\n",
    "listR = np.array([[[1,0],[0,1]],[[3,0],[0,3]],[[2,0],[0,2]]])\n",
    "listH = np.array([[[1,0],[0,1]],[[1,0],[0,0]],[[0,0],[0,1]]])\n",
    "init_G = graphs[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "id": "southern-apparel",
   "metadata": {},
   "outputs": [],
   "source": [
    "kcf.create_nodes(init_G, listQ, listR, listH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "handled-wayne",
   "metadata": {},
   "outputs": [],
   "source": [
    "iters = 0\n",
    "e = np.array([0,0,0])\n",
    "\n",
    "\n",
    "\n",
    "max_iters = 2000\n",
    "\n",
    "while(iters < max_iters):\n",
    "    kcf.single_step(e)\n",
    "    iters = iters + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "id": "positive-paradise",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6000, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "print(np.array(kcf.priors).shape)\n",
    "prior_values = np.array(kcf.priors).reshape((max_iters,3,2,1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "posted-departure",
   "metadata": {},
   "outputs": [],
   "source": [
    "node_1_priors = np.array([row[0] for row in prior_values])\n",
    "node_2_priors = np.array([row[1] for row in prior_values])\n",
    "node_3_priors = np.array([row[2] for row in prior_values])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "id": "extended-planning",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEGCAYAAAB8Ys7jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABr/UlEQVR4nO2dd5hdVbn/P+v0NmfO9J6ZTHqAEEioAREEBVRQrNjwWlC8Ktafer1ivYpee0WuIqgIKiog0gUpAiEhCenJTJLJ9H5m5vS6fn+sfdqU1JkkB9bneeaZmX3O2Xudtff+7u9617vWElJKNBqNRlN8mI53ATQajUZzZGgB12g0miJFC7hGo9EUKVrANRqNpkjRAq7RaDRFiuVYHqyyslK2tLQcy0NqNBpN0fPCCy8MSymrJm8/pgLe0tLC+vXrj+UhNRqNpugRQuyfbrsOoWg0Gk2RogVco9FoipSDCrgQ4hYhxKAQYus0r31GCCGFEJVzUzyNRqPRzMShOPBbgUsnbxRCNAGXAJ2zXCaNRqPRHAIHFXAp5ZPA6DQv/QD4f4CeTEWj0WiOA0cUAxdCXAH0SClfPIT3XiuEWC+EWD80NHQkh9NoNBrNNBy2gAshXMAXgRsO5f1SypullKullKurqqakMWo0Go3mCDkSB74AmA+8KIToABqBDUKI2tksWD737b6PG5++ca52r9FoNEXJYQu4lHKLlLJaStkipWwBuoHTpZT9s146gwfbH+S7z3x3rnav0Wg0RcmhpBHeATwLLBFCdAsh3j/3xSrEYrKQTCeP9WE1Go3mhOagQ+mllFcf5PWWWSvNDGgB12g0mqkUxUhMIbWAazQazWSKQsAfe9RCLKEFXKPRaPIpCgG3mCxgSqEXYNZoNJocxSPgQEqmjnNJNBqN5sShqARcx8E1Go0mhxZwjUajKVKKSsATKS3gGo1Gk6EoBNxqVgIeT2oB12g0mgxFIeAZBx6JaQHXaDSaDMUh4IYD17ngGo1Gk6MoBNymBVyj0WimUBQCnomBR+NawDUajSZDUQh4JoQS1Q5co9FoshSFgGdCKHEt4BqNRpOlKATcqmPgGo1GM4WiEHCbRQu4RqPRTKYoBFwP5NFoNJqpFIWAZxy4zkLRaDSaHEUl4LFk4jiXRKPRaE4cikrAdQhFo9FochzKqvS3CCEGhRBb87b9rxBipxBisxDib0II31wWUgu4RqPRTOVQHPitwKWTtj0CnCylXAHsBr4wy+UqICvgOgtFo9FoshxUwKWUTwKjk7Y9LKXMqOlzQOMclC2Lw2oFtAPXaDSafGYjBv4+4IGZXhRCXCuEWC+EWD80NHREB7BZDQeuF3TQaDSaLEcl4EKILwJJ4PaZ3iOlvFlKuVpKubqqquqIjmM3QigJ7cA1Go0mi+VIPyiEuAZ4HfAqKaWcvSJNJevAtYBrNBpNliMScCHEpcDngAuklOHZLdJU7Fa9JqZGo9FM5lDSCO8AngWWCCG6hRDvB34KlACPCCE2CSFumstCOnQMXKPRaKZwUAcupbx6ms2/noOyzIh24BqNRjOVohiJqQVco9FoplIcAm7TAq7RaDSTKQoBdxgCntQCrtFoNFmKSsATaS3gGo1Gk6E4BNyIgSe1gGs0Gk2WohBwm1UVU8fANRqNJkdxCLhNQMqiHbhGo9HkURQCbrEAaS3gGo1Gk09RCLjJBKQtpLSAazQaTZaiEHAA0hadhaLRaDR5FI+AS+3ANRqNJp+iEXCRtpCUWsA1Go0mQ/EIuLSQ0gKu0Wg0WYpGwHUIRaPRaAopGgEX0kJSJo53MTQajeaEoagEXIdQNBqNJkfRCLhJWkijBVyj0WgyFI2AC2nVDlyj0WjyKBoBN6FDKBqNRpNP0Qi40CEUjUajKeBQVqW/RQgxKITYmretXAjxiBCizfhdNrfFVA5cC7hGo9HkOBQHfitw6aRtnwf+KaVcBPzT+H9O0SEUjUajKeSgAi6lfBIYnbT5SuA24+/bgDfMbrGmoh24RqPRFHKkMfAaKWUfgPG7eqY3CiGuFUKsF0KsHxoaOsLDaQHXaDSaycx5J6aU8mYp5Wop5eqqqqoj3o9JWJBCC7hGo9FkOFIBHxBC1AEYvwdnr0jTY9YOXKPRaAo4UgG/F7jG+Psa4J7ZKc7M6BCKRqPRFHIoaYR3AM8CS4QQ3UKI9wM3ApcIIdqAS4z/5xSzDqFoNBpNAZaDvUFKefUML71qlstyQLSAazQaTSFFMxJTC7hGo9EUogVco9FoihQt4BqNRlOkFI2AW0xawDUajSafohFws7CASQu4RqPRZCgaAdcOXKPRaAopGgHXDlyj0WgKKRoBt5i1gGs0Gk0+xSPgwgJCkpbp410UjUajOSEoHgE3q0GjsUTiOJdEo9FoTgyKRsCtJiXg0bgOo2g0Gg0UkYBbMgKe0AKu0Wg0UEQCbs2EULQD12g0GqCoBNwKaAeu0Wg0GYpHwDMhlJgWcI1Go4EiEvBcFooWcI1Go4EiEnCbRQu4RqPR5FM0Am7VDlyj0WgKKDoB152YGo1GoygaAbcZAh7XAq7RaDTAUQq4EOKTQohtQoitQog7hBCO2SrYZLIx8KQWcI1Go4GjEHAhRAPwcWC1lPJkwAy8fbYKNhmrRTtwjUajyedoQygWwCmEsAAuoPfoizQ9OgtFo9FoCjliAZdS9gDfBTqBPmBcSvnw5PcJIa4VQqwXQqwfGho64oJmY+A6hKLRaDTA0YVQyoArgflAPeAWQrxr8vuklDdLKVdLKVdXVVUdcUHtVi3gGo1Gk8/RhFAuBvZJKYeklAngr8C5s1OsqWRCKFrANRqNRnE0At4JnC2EcAkhBPAqYMfsFGsqtowDT2kB12g0Gji6GPha4C5gA7DF2NfNs1SuKdh0FopGo9EUYDmaD0spvwx8eZbKckAc2oFrNBpNAcUzEtMQ8IQWcI1GowGKSMAzWSgJ3Ymp0Wg0QDEJuEWHUDQajSaf4hFwHULRaDSaAopGwB32jIAnjnNJNBqN5sSgaARcO3CNRqMp5KjSCI8Z99yDY+0msGsB12g0mgzF4cAfewzn/90EQDypQygajUYDxSLgpaWU+gcAiGoB12g0GqBYBNznw56WAMTiWsA1Go0GikjATRJIm4lpB67RaDRAsQh4aan6nbYSS8aPb1k0Go3mBKE4BNznA8CUtmoHrtFoNAZFJeAibdVZKBqNRmNQHAJuhFBM0kI8pUMoGo1GA8Ui4NkQioVEWjtwjUajgWIRcMOBm9MWPReKRqPRGBSHgFut4HJhSZtISh1C0Wg0GigWAQfw+TCnTSSlduAajUYDRSbglrSJlBZwjUajAY5SwIUQPiHEXUKInUKIHUKIc2arYFMoLcWaEiTRIRSNRqOBo3fgPwIelFIuBU4Fdhx9kWbA58OSkkgSpFJzdhSNRqMpGo5YwIUQXuAVwK8BpJRxKeXYLJVrKj4ftiRgThCJzNlRNBqNpmg4GgfeCgwBvxFCbBRC/EoI4Z78JiHEtUKI9UKI9UNDQ0d+tNJSbMkUmOOEw0e+G41Go3mpcDQCbgFOB34hpTwNCAGfn/wmKeXNUsrVUsrVVVVVR340nw9bIgWmhBZwjUaj4egEvBvollKuNf6/CyXoc4PPhy2ZBrMWcI1Go4GjEHApZT/QJYRYYmx6FbB9Vko1HaWl2FNpHULRaDQag6Nd1PhjwO1CCBuwF/iPoy/SDPh82NNpHULRaDQag6MScCnlJmD17BTlIPh8OFMpHULRaDQag+IZiVlaiiOls1A0Go0mQ/EIuM+HI62zUDSauWbTJli0CPz+410SzcEoKgF3pZI6hKLRzDFbtkB7O3R1He+SaA7G0XZiHjs8HpypJJjTWsA1mjkkFlO/o9HjWw7NwSkeB26340onwJwgFJLHuzQvSZ55BkpKYHj4eJdEczzJCHjmt+bEpXgE3GrFkUoDEIro2azmgh07IBiE3t7jXRLN8UQLePFQPAIuBDbMAATCekrZuSAUUr/1jfvyRodQiofiEXDAalIh+2BEL+owFwSD6re+cV/eaAdePBSVgNuEcuAhLeBzQkbA9Y378kYLePFQVAJuNVkBCEV1CGUu0CEUDegQSjFRXAIuVAglHNUOfC7QDlwD2oEXE0Ul4DazcuDhmBbwuUDHwDWgBbyYKCoBz4RQwjEdQpkLdAhFAzqEUkwUl4CbbQBEtAOfE3QIRQPagRcTRSXgNsOBR+JawOcCLeAaODoBT6fh/e+H9etnt0ya6SkqAbdaDAce1yGUuUCHUDRwdCGUQABuuQUefXR2y6SZnuIScCOEEk1oBz4X6E5MDRydAw9HUvCeV7Ez9tjsFkozLUUl4DaLHYCYFvA5QTtwDRydgA8F/dD6GPtTaw/+Zs1RU1QCngmhpEWcZPI4F+YliI6BawAmTPvhTVcTikcO+7NjhguIp/RFdCwoLgG3OtQfpoQWmVkmHodMw0bX7cub0fL74ZQ7GZa7D/uz4xEl4DEt4MeEoxZwIYRZCLFRCHHfbBToQGRCKJi1gM82mfAJ6Bj4y52Io0P9Th7+yinjEdWMS6T1DXosmA0Hfj2wYxb2c1CyDtwc1yIzy2TCJ6Ad+ExsHtjMpx76FFK+tBcUiTk7AIimQgd+4zRMRNVnEmmdKXYsOCoBF0I0Aq8FfjU7xTkwNqvhwHUIZdbRAn5w7tt9Hz947gdMxCaOd1HmlIS7A4Bo6vAdeCCWEXB9ER0LjtaB/xD4f0B6pjcIIa4VQqwXQqwfGho6qoNZbU71hw6hzDr5IRRdt9MTTapmXyR5+J17xUTKsx+AaPrwHXggaoRQpL6IjgVHLOBCiNcBg1LKFw70PinlzVLK1VLK1VVVVUd6OACsGQeuQyizTr4DPx51e+UX7+SNX/rjsT/wYRBJKOEOJ166q2pHEhGkewCAuDz87xmMK9FPSh1CyRAOw/bthSZptjgaB74GuEII0QHcCVwkhPj9rJRqBmw2l/pDh1BmnYyAOxzHx4E/Fv4R/wz85Ngf+DDIOPCXsoB3jO3P/h07AgcejGUEXN+gGe56ehMn/aqJn9z3+Kzv+4gFXEr5BSllo5SyBXg78JiU8l2zVrJpsNp0J+ZckXEHFRXHR8CTIkRSnNihiWwIJXFil/No2DPSkf07weE/qEIJ5QSSaAHPMBQYg9JuHPbZ33dx5YHbDQf+MoiB794N112Xy82eazIO/HgJeMocIiVObGebiX2/lB343pGcA0+Iw3fgoYT6TAodQsmQyY0v87hnfd+zIuBSyn9JKV83G/s6EFkH/jIIoTz0ENx0E2zYcGyOl3Hg5eXHJwaeNoVJmU5sZ/tyCKHsHe2AlBUSTpJH4MAjyYyAv8Rv0MNgPHyCC/ixwuRwYk7zsgihhI17Z926Y3O8jAOvrDw+DjxtCZE2n9jC+HLIQukY74DxeRAvIWk6fAceTqoLKSW0gGcIGLnx5S93Acdmw5ISL4sQSkbAj9W8ysEgWCxQUnLsBVxKibSEkJYTW8BfDiGUzvEOGGvGnHKRMh2BAzcG/6TF1BBKx1jHlBz6l3JdZsjkxleWvtwF3G7HlgJMCe3AZ5lQCDwesNuPvYDHUjEwpcESOaFHOb4cQigD4T4INGBOu5GWEKnU4X0+M3pzOgf+it+8gm899a3s/0/uf5Kyb5fRH+w/qjLPBVsHt5JIzU4HVCYzp9L7chdwmw2rEUJ5uTjwHTvUJPlzTTCoBNzhOPYx8KwgmtIn9HqnmeyTw81C+a9//hfX3XfdXBRp1okkQxArwYobrOHDvs+iaRVCkabCD0op6Qv2MRgazG7b599HPBWna7zrqMs9mwyHh1l500r+uG12xiWEEiGQgvIS56zsL5/iEnC7HWuKl1UIRcpj05EZDILbfXwceCZGCDASODHcbSKVYPXNq3mg7YHstukc+GteA9/4xsz7iSaj/PT5n/J4x+znAM8FkVQYEi5suMAWOuxrISaNEMokAY+n4iTTyYL+g0w9BuLHwKEcBqORUVIyRc9Ez6zsL5wIQcKNySRmZX/5FJeA22zYUvJlE0KpqFB/H4s4eH4IJR5XD465YPNm6Jl0X4yFcwI+FjwxOgjHY+O80PcCL/TlBhpPJ+DPPgtbt868n4faHyIQDxTF/ClpmVbznyRc2E1H5sDjhoBLU2FLKhhXzjxfwDN/B2InloCHjNGk47HxWdlfJBVCJGc/fALFJuB2O7aXUQiluRkaGmDLlrk7zsaNcOWV0N2dc+CgRHwueNOb4MtfLtzmD4by/j4xHHhGpDM3M+QEJ/s7osJb4QMU+U/b/wTMnhjMJZkHFAkXDrMLrKHDNkoxOX0IJSvgiRPfgWfKNR6dLQEPYtYCjoqBp8BkeWmlEUoJZ58Nd96Z2xYOg8sFVVUwOjq7x0ulU4xG1E7/8NhG7q05gxfXnMRYy604jFT7uXpA9vr+wp5I4fQ545GcAo4fSA2PIRmhyQxMgakOPDM3W2SGRkM0GeXvu/6OSZgIJ8Ik0yf2MlLZlkXCjdNyZA48O/jHPIOA5ztwo44zr50oZM75bD10Y+kQ5rQW8GwWislS5A78Rz+C88/P/hsKwdq16idDRsDLymBs7PB2PxGboPmHzTy+b/q4620v3saCHy8gloyxPfQkNKwHXwcjlX/POvC5eEBKCeELPsbOsu8XbB/PC6GMh06MEMp0DnxyHvig0R83k4Bv6NtAIB7gFc2vAE68UMFkcgLuwm07shh4AqO+LHHS6Vwc7oAO/ASrl6wDny0BlyEsUgt4Ngul6AX8xRdV8NQINGcctt+fe0tGwH2+wu2Hwp7RPXSOd7Kxf+O0r3eMdTAWHWMiNpGdPc4VXIHFO5QV8Lmo32gUcI5mm9kZMkON1d8niANPFjpwKeUUB34wAR+LjgGwuHwxwAkfB88XcI9NOfDDeZCn0ik1mjZlBSASz6XhZQR8YHSaGPhLPISSIIRVCzjZLBRR7CGUUAhSKX6/9mYGggMHFfDDdeB9wT4gJyBTDm+IdjAeVDdWysLlaxpxVs6tgA/6I2CJkaBQwCfyBHziBBHwrANPTF3jMfPagJp1lRH7ek696VQGggMF+8g4y0ZvI3DiCnhappFSFgq43QXWCJHojFP9TyH7+Ug5AIFIrs4yAu4PvPw6MRMihE1oATeyUMA0qRPzuuvgnnuOX7EOm2AQvwPe/dCHuXXTrQcU8CMJofQFlID7I9Nb98zNFIwHCSeDmJIeqtxVDIWG5jQG3jOiypMwFQp4MJYT7cDRCPjAwMx2+DDJxsCNmznbwZf3WsaBjzb8gc0Dm6fkDY+GlWBXOZSAn6gdmStvWsn/PvO/BQJe6lSCM3GQ+rzhaxEueksbyXQy118QVulToUiuJ3zcWOghnj7BOzFvvJHwTWpa49ly4ElTCLsWcJQDT4PImwslFFKTPt1///EtWjIJf/7zIabfhUL4jZz+0cgoIyPq73yhznfgweDhzUqYdeCxsWlfb+80HEY0SDgVxJTyUOWqYjQyisWmht5N18J5rvs57m878oruM55QqUkCnhlqDBCMqRs8HodPfjLncg+Js86Cb37ziMuXz2QHPl3sNiPg4bpHAPjz9j8X7GPrbiXgg20nrgOPJWNsGdzCzuGduXh/wkWpS838md8/MR0/3/NpHj95Md5veblvt7GuebQMgGA05wJGJoxpZsXUTsy5EPBH9z7K/B/NP3x3//TThHr2AQd/4D7f83zWLB2ItDmEw6wFPJuFginnwNva1O+J43xvPPggvPWth5izHQoxYYQq/FH/QUMoAOOTrqUnOp7gqf1PTbv7gznwniF1M/UOB4ilg1jSyoFLJHGzKsx0Dvxzj36ON/7xjewa3sX1D1zP1X+5+uDfNY/+cUPALZMdeL6AK3HcuhV++EO4++5D3HkyCfv3w549h1WmmcjGwKdx4AUC7ukjVbGVOk8dT3c+XTD4w284cIL1wIkp4L2BXkCJaNaBx934jImXAtGZW0ThMIzQBqOtJFIJ7t11r3rBCKEUCLgxW1r+jJNz2Yn5QNsDdIx1sNe/N7vtkT2PsLZ77QE+BQwNETZWE5qITRxwaofLbr+M7/z7OwctS9ocwqkFnGwWisgbibl7t/p9vAU8MzjlkDocQyHGDyDgyaRyoJkQCkwNo3zxsS/yX4/917S7zzhwf3T6wmQmHBoaDxJLh7DiptJVqV4TKjcuX8ClhHvvhe1D24mn4rzytlfy4+d/zJP7nzyEL5tjMKDKIy3BgpZKMD5VwDPft739EHeeqcTh4cMq00xMduAZATcJU2EWSuujAHz/NSqz5i87/pLdx3g0ALESomM+4MQU8O6JbkCVLT+EUuZRDjx/lOxkNm4EPH0wcCr1zgWs6zUm7smEUKK5EIo/ZDy0LVHicXXyM/V4KGmEHR0HHjA1mRcHXgRy9wLAh+77EF994qsH/uDgICFjLvO0TM9YtkgiwmhklH39B77hpZRIa0ilZc4BxSXgeXOhZJr4u3ap35Md6rHkxqdv5IH+W4FDfJCEQowbsWZ/JCfgoZAKlWTCjvkOfLKAj8fGGQmPTLv7jKuaqRMzM1/F8ESQuAhiR4VQAMLTCPhzz8GVVw8xHB7m9LrT6Q/2YzFZDjt/dzhoXOyT0tPCiTDEPMbf6stnzuchC3gmDnWUC2cXlImcA8+ITZmjrNCBL3gEQlW8cfFbWVyxuGDI/ERsAmIlBIe9uf+PEal06pAmY+oJKOcRiAUKBLziEBz4unWApx+CtVSJpblJqYwQSijPgY+FctdKV3/hykYHC6HcdRecfDJcfvlBvw6gRDMj4Jl7IRQPsW9sX3b8w4wMDRG25P6d6R4aCKnY3os7DhxiiibiYErhtnoOrfCHSXEJuMmEVQpkXgjlRHDgt2y8hQ0xNQrnkCaeCgandeCgXHhmLEu+gE929sF4kJHI9AKedeAzhFAy81WMrHueJAHsQoVQAEJSCWB+DLyvD6jaAcA3LvwGj73nMa4/63pC8dBhzR44GjbKY4kxNpETl3AiBFEfpM1ZETlsB54R8Fly4JMH8mQceLmzvDALZd7T0PFKYlET1e7qApEOJiYg5mV82INAzFqn2KHwhX9+gVfe9sqDvi8T8sl34DaTC69TOfD81tFknn0+Dq4RCNThCi/LvWCEUMJ5T+lMJybA/l51nOlCKDt2qJ8MXV0qNCml+vtQjFpfsI/hsLoOMuHEncM7gZlbpapAYQiFCNlym2aKg3eO9htln8bEvP/98KUvATA4rl732LQDB8AmTUhTnPZT3sPDbQ+ya4fqdDueAh6IBwgm1YmeScD/8Q/4wQ+Mf/Ji4GPRsQIBHxvLCbjTOXMIJRgPMhoZnSKgUsqsE5rJPWTS+PxPPU3SFMBpzjnwQHqqAx8eBirVXXVS9UlcOP9CKpwVpGSqIL3uYOTfPINjOWEIJ9VkPyRcRJJGDq5x3+zZA+lDyWTLF/BZmMglIy7hRFjNEZIn4JFEhHQaBodTUNoJI4uIRMBj8xS0SjICPjwg8dq9x9SBbx/azuaBzQd9X9aB58XA7SYXPrcSnFA8PKNort2mXKjXXAvDOQG3pYwQSt5FFMgT8O7+wikJ8h34f/4nfPSjuWN0danT+Z73qP8zLe4D8WL/i9m/M2Zm+9B2YOZ7Asi23sLW3KaZHrp7+tV3DyemecD961/wz38CMDKhXvfYtYADYMVMxNPHWPPv+OZd17PrBSOj4jiGUCZiE0SlKsBMD5Jf/1o9lNOJFMRi04ZQYGYHPlnAA7EAyXRyShhjNDJKPBWnylVFJBkhlpwqsJnhzuMWSFvDuCyebAw8kFTOZYqAV+3AhpsmbxOgxAoObxj0eF5WzPBE7nPRVAgSLki4iBo3deb7RiJGC+AA7N4N37i1EQmq6TALw/EnD/nOOPJyZzmRZIRRf5qUYwBMKZhoJBwGt9VdUB+RVEAJ+Lp9eP1h2jrHj3hq4Ot+cTuf/eNNhzyV7WhklGA8WDCSdArxOD3DqpNvIjZBKBFCSBN2iy2bhbJhS4jy8lxLN7v/Udg/ok5MfUkd4f05AXeiXEckb0KdQF699AwULoyR78B3+X7MLt+Ps/9nroOzzzZePwQBzzy46kvqsyGUjID7I/6ZW41GWlHIqvo6YGYH3jGsBDzTmi1gZAR6ehgfzwm416EFHACrMGf/fiK+m4nSMUpLUkxMzN0MegcilU4RToSJC6XcM92gw8Mqxt2x3XCYeQ58eCRNba36PyvgIkUvG9gTWQeWSEEIJZFKZJ3v5JhexnEsq1I31HRNxkwan99mBVsIt9WD1Wyl1F7KeHIGB161nUqWIoSaEjMj4JMF4sn9T/LJBz85bR0EErmyjATyhS4EcTcknETThQ4cDh5G+d3v4Et3r2KQarVhFuLg+TMOhhKhAgcO0NUXBa/qAGSiMevACya/khMQL2Fo3IY9aOKBxwIsXaoylg6Xm/f+P7678zqW/WzZITn5THgtE6udwrXXQkUF3U/8HVAiGoqrId8Ou6DMcOBbdoVIp6cm93R0oOLfQHNFLUM7lmRfc5uMEEo8dxFlVqsH6BsunFc9koxk54kZbvwNw3V/yL43I+CrVqkVo3buPOhX58WBF5lXOo9llctyDnxYCXginZh5QY48B15tUw+hmRx4t1/Va9ocKjSPySSMj/NCTy3l5ZIN205QARdCNAkhHhdC7BBCbBNCXD+bBZsJG0rALYOr1YaT72D1/FHS6VkxXlk2D2zmlo23TNmeTkNvb+7/jONKWQ4cQsmEZrdsULHfjAOXSEaCEyxYoP7PCviK2/nkjlVccPuZiMs/UeDA813eFAE3Yn7LK5cDuSbj2rXwla+onvW0sXTZqM0KtmBWjKvcVYwlpsbAMyGUstTy7Da3EdOb7MD/vO3P/HDtD6ftQAumcgI+Gsx9LpYOq/mS0y5iqVwM3GIBRJpdbZMmgRoYKIirdHaq3z005BX46Jg8b3Xm/4yAdw9E8gS8adoQSgwjhJIsxRxzg2OcRELygQ8cXlnSaUjb/dijTewf30/bSNtBP9M9rK6LaVe7iUbh//4P5s+nx63qMSVTdI+OYE67sNtRIzGBuFTnY2RSd8vYGCoDBVhUV0vPXi8NJar+SyyqjiJ5Ah5J5uqlf0StvBRJRiixlQC56yjh6Cdlzt1Emeu+qgoWLJhewFPpFN948hvZ0Mmm/k2cWnMq9SX12fsh48BhqqkZCg2pbJyMA7dBvVWFgWZy4L0TxoPRGqK7O+8Fw2m1peaTTgs2GQJe6jrBBBxIAp+WUi4Dzgb+Uwix/CCfOWqsQnURW9d9hgV9DXDq71hVoZqBBwqjvOdv7+H997z/kI6xvnc9r/jNK/jAvR8oyP8F+OMfobU116mYdUP2IIjUjCGUrIBvVjfMeEmup8Qf8WcFPBsDr9iFWZg5q+EszE3PzyjgkzsypzhwoyPz5z+Hr361cKi635UGU4oSIz5X5arCH5vqwPv8E1DaTUkk10yeKYSScXzTOf+w9ENaPYCzAr5jB7HB/RB3Y0m7iMtcFsqiRSCu+DA3dJ2Za/YGg+oEfO1r2f12GQu6dKMGzMyGgBc48PhUB949EAavceA8B55fH3FDwAN4kaIO7BP8x8Xd9PQcoM/m61+HFwpnaxwYiYE1gmVMudyDOfBQWxdhqQR88vB+IFs/6es+TG8JEFVZMvf8c0DNBW7PPaCxKgGaPCOmEnD1cDippYZUClo8yyBpx22If34IJZIOQkS52sHRSLY+q92q1RSIBUilU0jnICnLROFxgNJSWLp0qoDH4/Chv3yWLz3+JT78jw+zoW8DO4Z3cEHzBdR56ujy9/H1b0XY69/LSVUnAVM799/0mw9z0S/fXODA68ylwMwOfDBs1KstlL3+8itqDB8AHT2q/nwnmoBLKfuklBuMvwPADshYoLmjLmHHEfOQ2vFaFm46Faq3UeNU+cgz3hSxGGt71s44uVM+0WSUS39/KaFECImkY6yj4PVtu8PE6h/LjhAM5N9M9omcA897mqTTOQezZbsSsAmfI/t63OyntVX9nXXgpV1UOxq4oPkCUuXbGfHnHG1+p8+MDrwqz4Hv3MnGDerB0TucN++IR4mU15lz4CPRSQL+gx/Q0/sMAM7QVAEPTerEyTi+0cgow8Pw+c/DKafAbbdBFD8E1KAWf9gQun//m5g5Bgk3FpzK8d15J2PbunHXdyJPvYUB00a2DhpJwHv2qAr63vdUpb74InsHu2Dlb+i2GpU4CyGU/FhzfgilzKFEaOPWMJR2YxV2CFdkY+CxVIxEKoGUkqRZ5YEDhKwLMdnHOCv5byA3AK2AaBRuuKFwXmFgX6+6lpKj84BJAv7ud8MHP5j7f/9+/rDi02qNUWD/6DQO3BDw4UonCTMwvBSAhK2fWFAJuNNiDBW2hsHTP70DL+mj3F7JolbV69dqPQcx3kKJU8UHo4mcC4jJIOao6igfHo9kWzQZAQ/Gg/SOD4MpjbQFsg0sv18t8+dwwJIlqt6SeQ2yiz56F7/e/gOWVy7nue7nuObuayixlfCB0z9AXUkdaVOcO//9LGmZ5tymc9U+J5mLdd0b2eNvK4iBV+HGLMwzOvDRWEbAg4UO3KiojIB39av7o2wOVqSHWYqBCyFagNOAKcOchBDXCiHWCyHWD83CjXX9/jo+eu8PiAc9lO5bCUC3RY1InCzgzzwDW+/cCl4vvf7ObGrRgdg1vIuRyAjXrVZrGOaP5AJ4Jng7XPMq9gyoG2OiKy9A6zA6qXbuhPJyY6SDutgzF+SW3eriHvdY1KhSAMcY9fXqIs0KuLeLek8TK2pWIM1xemK5XqQDhVCe3dqHHU92AiW/v5fIirPYbrQgewbzOg896uL0uTywfTtVwsNIZBgh8gT85psZlkptzGN5cU7r9CGUrAOP+LnlFvj2t1XH00MPQczkxzaubtjxwJj6wL59xG0JzCkHFukiQRh+9jPG948xsuhHCAFIkRsgs9c4H8EgXHAB6ZWn0V37C3jD+2irbVGvTXLgyXSSVPrwVucNJ8IIVLw/FA8VdGIC3HV3hIZl3dQ4GwGRdeCgBD+SjCBFCmLK3Y75KzHZx1jSpQb+TO4UBHIPnklNyY4BVVexgWYgT8CDQfjTn1TWQ4a2Nm51vjb7b+Y6LcCon263USeGgOMZQMaVgJtNZkg64KQ/wWfqaBvfVrCLTAilzllFCx0AnC+/BDe/QIlTtS4j/3wk+/44QSxxJeCjE5FsCyfrwOMB9g4aZbUFCIVk9jiZTKylS9U4iX1qpDt//zv8238XjDdyzxXPUuGsYOvgVj606kOUOkqpdSuz0CZUnP/8eWoK5/xMlEgiQtTRQdo+SmS4D0wmwlZwp02UOkqnOvBbb4W2NsZThoCbE3R05YULDQfuNzpy+0eVgJeXnKACLoTwAH8BPiGlnOKBpZQ3SylXSylXV1VVHe3hsNgc+GIqjBIdWoUp7GO3S7mzyQJ+7bXwxf/1MSHiBNNRhoODk3c3hV0jqpv7tYvUTbDPv6/g9aGIusj2G73QgV255XJqWwwBb29Xim3cpRn30tICuzsdxLAx7hDMy1wbDj/l5epCzQl4Nw27B1hRpm6uAXIpYfm99pMFfN2OPhL+Ospsqgno79/HlsQSUml1qjseeCb73pRHCUaZ3QGvfz2Va7cwFBrCWreL4XiP6hXu6GDc1wNpE4y2Zj+bDaFExgqOn2myj0ZGGRpSqZDnnKNW/Ema/Xgm1IU9sc948O3bR9KawJJyYcVFkgix7v10LXmYruqbWRx/O+bu86cK+KWXwrZtDNmbSJWpHrY95R621pp4h/9XBTH41/7htXzkHx8pKOfBsmfCiXBWrAs6Mf/z06peg2F887qod6usnHwBP/O8EG2d6mJ0pZSYhUZLkY4gC7bcjRBy+myKGQS8e2jM2K4ceNYVPvqoiiHs309m+fi+HWM841ya/WznyDQhFOM4PXajjjIpgO6hbAgFwJRyQbV68ndFcjFkUinG/BJK+qnrHaPqQ1cBMDpkRcbceN1qB7G9bdmbMiGC2FOGgAdyWT35IZSOYSPdyJRmaMzoC/FLfHIUxsZYanytXbvU1/7IR4DGtdB9DqFRL58651O4rC6uP1t1x3moU8c++Tc0ultyDjwvhLJ+XxsI9bDo9PdAQ4MS8KRJdernO/BYDP7jP+C73yXEAEj1gM+ESdSXKwyhpEyGgJ+IDlwIYUWJ9+1Syr/OTpEOgs2Gw8hU6JHz8PWvYnO1ymWdHAMfHIRhv0nF+YBIOjZtD7Q/4qfue3U81P4Qu4bVnXXevPNwWpxTHPh4TJ383rERnnsO3v69luxrDa0T6nrNBMgN5c4YwgsvhFTaxA6WMW5J0TxmfNBZKOChkARvN/O2d7K0I4hJWhm15gT8QA58PN1HerwOS8sqAMZGetjIadnX9/2fMWNerASshqs0m6Gri6qhEIl0gvj7T+ERk5pJKh5NES/fD2MthDLJ6+S5zY9cq1wgKvyUueD9UT+j23opTw/T1JCmqzdG2hKhbFx9LtC1l4/d/zG+IZ4iYU1gSTqwCidJEeb6U7oZuurTeFJ1XFX+ZVJb38TWwa3sHtmtBLysjK1f/Qs//sx+uta8HSrUg7LTLvn7Shd3mLcXhL7+tXsdf8+LK+8a3oXvRh9PdDzBTESSERyG4GRi4BZpoqRbiV9DS5igqZv6EtXSyRfwto4gL2xVwlWdiQPHvKSsESyREVrq49M78MzsWJNyRntHjf8NAd/SNqGW2fvHPwCQiQTP/X2IdBp2bE2BM/f53omZHXiP2ciQGDX6DkQa4u6cgOctAzYUzwv0vv/9+H97L8LbR/1IjJK+3ZjN0G8cyusyQihmWPqrlfxi3S9Im6I406o+Y6kIIxOTBDweoMufK2v/mKq/sa4Avv6dhD//aepaR7DZ4JGH0jz4twjd/kHwdUD3WfT1wefP+zz7P7E/2/q0x5WA4xhnletNlDmVefBH/UxMqGfLv7blRg3tDE6QamkmagVXAuXA8wXc+ILRF9YSN41jjaiHd2d/noAb97zfbJhVm7pXK0tPMAEXKp/s18AOKeX3D/b+WcNux25MSdlNI/Xhs+kqj0NJjxLPb38b7rsPKdXDcDRgzQo4MG0YZV3vOvqD/dy76152juykubQZt83N/LL57B0rFPBMJsXAUCcb18YZzVsmq7zWrxx4psfH+J0R8Fe+Uv3exkmMizgtY8YH8xz42JhRRmuU+RNJrOteoCy5nKB7egGf3IkZsfRBsI5+fxlOLPjH+tnA6dnXu4z0KIK12W0VkTAkEtT0G/s1J5TD2LePESqgog1GFxEcjqiFKMjLQpExNR0khR1m/oif0fZRymO9NHon6Damkq2cULH/oL+fu3f8jZ839IKQWJMO7MJFyhTm340S2i/hupF/c+bCRbDjKgSCP2z5gxLw1lZ+cZuL6787j7X2Nap8QL8tRGeVisdmzvN4dJy42c9QvDNbtj3+PaRkiltfvJWZCEbD9LSp3PhMSMSRNmFKKEd97gVBegI9NJXmBDzb8WcL0jeiWkl1oTG1LaZaRAEbLPYOHJYD7x8xLqBgLVZh48/3TPCFL0j4xz+481wvHzjpEs55Yy3//Cd0dqTV6EiA8SaGIjN0YgpBV3IEpJlWWZl7Lc+BO8wuTNKGKW1nLG0EesNh+NOf8PeGkK5+avuDiHAIn09m+4VKjQ76cVeSXYF9/PyfapIrjzBEzRJh225lpGrcNapeYgG6x3MCPjim6s8/nMLHGJ/r+g2vuX01r79C8odfh7ntff+iZKkRse05k74+lbudGc8AYA7XZf+uGn4TpXajVRrx85a3wFVXwQv7c72iu+MRIi2qG88dB5/DVxhCMQYkDO7barxHtUh7dnXnYqSjo2AyMeZS4RtsIZCCCq9z6nmYBY7Gga8B3g1cJITYZPwc4mwFR0GeAx+gloVmY2my5qeUgN94I/zmNwQCqlU5GrLTW+PKfnw6Ac+kHz3X8xy7hnexpFLFelvLWtnr38tAcIA/bVMuM5xWQjT8yH2M/PyPYMuFM8y2kUIBn+TATz1V/e4VNQTSERoCYJKmKQ58IKrcTst4GtaupVasIF72IhOxCRKpRLYTs9pdXeDAIxFIu/ogUEcHLZQlbYwFh9nIaZxihGB6rOoitoXLs5+r8qsCXrF2jF+9/v9wdF1GVIxBRwdDVEDFbsxjiwh0jcOHPwzkYuAhGyoG291dkLI2GhnFP26mDD+NtkGSFlVvZSErJG0ELUn6gn30GWls1qQVu8lF2hyivRwYPAWfDNDSAkw0cor7Ym7ddCvpvXugtTXbCXhrT6u6SYBRq5/OUlFwnvf5OwBI2oeyra89varOfrvur3zz29OPJA3GIhAudODOlGAguRAAp2UtyXSSZp8S8HA458CxBekbVQ6yITaOEDIbC59oqmJxege7d08zbsEQ8D2DJfz0p3mb+4yZ0qI+nKZSxiITDOwLQ18fX73Ixa3nqXrfsQP291rBqa47MbycscQ0DnxoCMrL6Qx0Yw42srCuNPdanoC/Y80r+fS5n8CTbCFoMhz4Qw9BJMKQVYI5Qd2IamGUlSSzAu7zqB0MlagQTVtICW2JyRBXa4Rn10114PnXz5ARehkbBx9jtFea2B3o4LKr9zJs9fPXesHic5/ELMzQt6pgsNdrXqM8RXjcrTJsJurxbzkLs8mM1+5lOOTniSfUZbu1fycEVRn2iDihGmVwXHE5NYRiHGTAocJVvrRKHesLJpAvGgZrZATKyvCbK4zvqgapeT7+QQrTVWaHo8lCeVpKKaSUK6SUK42fuZ+V227HnsqFQZZUnYknBjQ9w/hwXFnY/lyvuT/morsql/ExHJrakbppYBOghHzH8A6WVqhgW6uvlX3+fXz5X1/mbXe9jbHIOHGTEqKRdJCR3cNgzwXeTZZhgkFIZ5q8kwS8tRUsphT9Ng8SSWkUnMkScIwVCPhQTLmdpglg7Vrm2VeAt4eyb5dx3T+uyzrw5tLmAgHf1RFQYhaop4MWfDHBSNjPZlZwEY8B0G+IjCeUa5ZUDiiB8AbivH/eG7DGa4gJP+zbR5vHC/YAVckWggkbQ70JWlrgKzdYsQsrQRtKie64o2DQiD/qZzRko5xRGtOd4DQEPGFFJD2Mlk2QIpfLbU/YsJtdpG0TRK3A6EJKkyPMn69ePyX5PvaP7+cxqRx4ZnDP+vHc90+4B9hrPBAyAr6jvyP7+s5edQNt26vKkrZO8NOHph9VE06EIaQEfCSgBNwRT7N/yZsAiLWpUNT8iqkxcGyhbAigPJak3JvMCfgZp7Jk+BmCwVzIIcvgIDFsXNX1Qz72sVzfyeiYUa9RHyLuRdrGGexJIAW0mcZJ+7pxWBK0t8P+YRclTvWd3ZGlBBlA5qdtgLogq6rYN7qf1Og8lp6aSx6zCRfGIEx++bqb+M6rv00pTUTthvj8VUVKOxYp55rpx/G5ElkB93oEpCyMlChxjxkP71KpHhQ1jRHWvWg4cE/OgQ+FcxUyElQmZSxkpcwaYrhFiWyC27C/7j/gXZext/xXnFJzCqUuF/3/3Aa7dhEOw8MPwxN3+xm94Yew6wpq93+CLZuV1JVZvey992Fia/6b1Gs+yr7ADuhbBdFSutyScIUqozuaptRRWjj03jhhA8ZprrYoAY/YYPxZo49gdBQqKhiTpbgIqfsx7sZ0229yva+zSNGNxMRmKxDwmvk+lo2aMFVtY6LP2N7XlzXBibSFzrI8AR/rZTKb+jdRYishJdWoynwHHogHVNMd2DswiHSoi3HMnmCECjz23mxnhjQp0QgOGuXIE3C7JYnnY/9BuTNCv101p0rNLqwxDya3v2D9y9GkulmaJoD9+znb/CrYfTk1rnp2DO/IdmI2lTYVCPjmvYYNCdaxv/ZsykIpuiIJYjg4l2fwEGDYpu7O8kBuwoeqzrwLq7sbW7qMuGkM9u1ja4VqDjel6wikXOwcrWb/frVuQjzs4RbbW9g07wq4/fZsCMVmtqlOTHOE4dPupSa2HYx6q7C4MSc9+KsLU7lsCQsOc14zc3QRvvggpaXqwebuegNltlJ+siqFv6mJ/fuN95UrK+6OWKGkh06bqvuMgG/r6cju8vnd6kN9Y6rOrIkKhmsLU/YyJyyWiqhZ9aRg554QkUQYRyxFh2mleotZ7aultA6LZbKAB+kdVgJeEUtSVSVyAr6slUUj/4bVN/H81kmtwaEhvsYNbF7QDh9eSXefMegr5kekLIiEjUTQC/YJhgIO+s5bqebXdvpZVLGTPXugc8KH29lFaRTKZA0pU4T+W24rTHUbHobKSvaNdsJYMyed0Zjpx+P156X43IfGCopVYW0i5e4iFU3AfffRfuV5tL/2B5T3Luf1RiiozBlhoFN19HosUUjZGC8pTDEtxYbdbGdea4Ttu3NZPSZhIhAPMBLrVyNygdHQBFLCWMyJzycZ8qh77C//+gmJhY9hStjxizHOrD+TulpJ32Pb4atfVSNEgZ5dQUY27oe//Y63NX6W9nbVSiqLQmcwDit+B2f+jHTVZmrMS2GigT5vilCZOr4rmqLCWcFQaCiXwdSnslT6a9R5rne1Zs/3wFrjwKOjUF7OWMLDSWwDawhTwgmf/Sy84hVTr7WjpPgE3G7HMbA/+29llWBJrAQqdjFhzLHQEe7hC8+9FyzqgtrvsVBlUo5zeLizYHeRRIRdw7t45ynvzG5bWmk48DJ1gjIhi7bewawQBVxxRnwLcNiGKBUerCmQQgl2YNholufFwCsZQdz9NyocIQadhoDbvZgiXuylfoRQQjU+DqOpLkhZqW5YrMozmoQ//IOVZecxEBwgGA/itrqpdFYWTCm7s1sJuDVYQUfpCnzjMfqN7ITzSjZTziijNiXI1YFc+72kLVef9PRQavORNAdIduylrUldrEsiLmI46Emr2PmXvgTOtIMhq5sHFn0cNm+mf1TV7cLyhfgjfoZPu5Onr7yVD1R8DVbeqs6XqxRz2kPAp8paYlSVI27GacmFuhhdSGlEvaelBbr2OfhQzWu5dyk0jnyWdNMTKiuhog2RsnBSjxuqthM2K9c3HBqEYJDda/+Z3eUWY8jmUMAPUS+LTK8mUfPslNWOUtd+kJSIY047Ie6mbX+IaGgcRxLaJxYBsLbViiUF8wfjOJ1TBbzfr66Z8pSkstaMz6kEfLy1Hlm9DV533ZQl2KL9Y/wvn8W76A6ofZGdXcaMdzKINeqmihEiY0rAI2kHWy44I/vZGu/zyoFHa7C7+ymPQFVEhTI++1sXZ56pGkrBeJCdsW6SleX0h7thvJlFi02UpFVm17L7f8Xyn1xXUK4aZyOU9DF4xz9gbIwvXSiQ0szFf7xGTe8MlNlCDAeUUbKPD0LKTrikMJZfKsFpdVLbFCGJulfdVnd2AJQ/0Q8jqn7HwgG1dKw046uwMJxQ+3q0Yoy0SfKvzUu5st/HO1e8k7rKBH3UwQMPsLdNXe+9fgcjVGAixZpz0qTTKnulLJiix5cCX6cyXkJycu1SmGhkqCROuMqnyhVJsqJmBZFkhLZRI17X1wfV1Wxd2gApC/NKDAG3hhjcklkgdQRZXoE/6uAUtoAthDnhLBh4NpsUn4DbbNhlbpBFVRUsNdeQLu1hxK9O8p2L4jwyfBtUqxS/HmeK5c55mNIw5O8u2N22oW2kZIqLWy+mLK3im0sqlsAddzD/U4WVvm9wMBsKCLqijFQvwzrPQpnbS2kUkigxnTDiglkH3henMtkH4+NUmv2MGHmypa5y0qEyLCVqn80qzZfeYDfWiRpMl14GFgsN/SqDwp6sYSA0QCAewGPzUO4sL5iRcO+QEryTTUn2R2spC0v85gStnkHqTyqjDD8pq1LMhmBOtdw78ya66O6m2utT36NnL/sbTZC0cdKQcot7URftdddBsz2KzTbCPvMCkJKBrh2UOcqo9dQyEhgiWdaFPWpn1DQBy/8Cw4tp8tRhlR5SRgbMFe1qYJM9ZsJlVQJuSZlgvAlfQJ2r+fPV3Bv/Iy/k8VtBYIUVv+d97wMqduMN1LFgPAHluQ7nYX8P3Hor+9vXwdBSSJvYPageVKORUUyxclq9S6G0k67+vAmienuJPKA63crsNqzCxf4+JeDOBOzsV5kgQWJcvRXK2ntwOpW7y666YgsyHFAOvLLEyznnCM5dqeK/fbVu+mpVtknPWC7kBLC7y0kCG6XVqqO4vb8f/H5C1iiOmIsqhpCR0mzYbkNLU/azXsc69u2TdKYbMfsmqAhDnV99rwdsW+krvZuhIfj2099m1YXt7K2zkyYF4/NYuBBKjAUH3CkzPP54QYC+0V4NQrLzl7+E1lZ22QOYus6hcdxMJt5Sljf83d62FZG0kXQVCnhZUuK0OCmvDmNyqJaS0+qkxFZCIBZgIt0PI8q0+MMT2WQuV70glAjRauRWnxr2cv5Jl3H3r4K8ovoMakvDSsDHxtj7T9Wa7Al4GaGSckZZPKjGibS3Q9lohPFq1cJ9g/d/YGgZr1p4AZZQHX5viFCdOk+ucILT61Tn/4a+DaogfX1QV8fjNRHoOYsGd+Z8hxhsGyeTORHy1pFKm1hsakfYgphNXrIdC7NM8Qm43Y6D3PD2ykpYUtICQH9KBUbXGR3AeFVst98eoclTT3kEhielVW3q3wTAytqVOIbWQMRHjateCfgjan20zACAfSO92Q6ziDPMcMiJyR3G6yilNAYJDHc+mmTCrvqKenpguCNIJUoAKxL9+B1KtLzuchLhiqyrP/NMVaZx2YV9olJZzyVLaBxQAm6K1BCMBxkMDVJiL6HcWU4inciOhuz0q/DQKaV2OsZ8VIYh7AmwpqUTli2jnFGV1pRw0GDMYywSDszjATVW2WSC7m7qy32q3oYH6S0dw+SfT1WXehhmBLyyEjxxcDpGedr3AJe/E/oG91DjqaHMUcbwxDD4OmgarKD799U03xaDn+6iorYcm8xNbv+ekUaQAu+4G5dNtUyqwpUgzZSOK8c8vy5Cx84IvZ/7KbbO82gynQ0Nz/OOd4C5uo3GZB0L8lY7N6Whp6uD4L/W0+tLwOgiCNTTNdEJ730v40N7sabKWFC2CIRk4/7cA2z/r79P0KJsZQUJSuxuRiZCdA9EsSVNdPR7MaPCT59+TsD27bhcyoFHJnIOPBCfgJSFsiof3/kO/P23rXjtXtaH29nWom7mwXDhuIRtA5WAZNRIi90/MoB8fh1RRxQXJVQzqEIxDiWM6/MWg7Y7tpBICOLYSZWGKI9A8371QB+94Jvw5rex7X1f54Wd/yRslfy9QpmLGnszpaVQUqZaVq7XvkHNNZOZver552n+2a0A7OrrhM9+lq6JblLjzfgYU7NMAWXkQmK2HS8iUnlzsk6oG7IsHsdpdZIUEVoWqvPltDjx2Dz0BnuJMo7wKwceiAUY7RwHUxLzPOWq377srZjScE3VJWp6wmQSNm6kzhOgjzoksPff6jtH03bay1ZTYR6j9ZnbAdizO4llMJXN+/7KVe/kqr7tvPd1S3BHqgh7AkyUqlaEOxRnedVyHBYHL/QaKah9fYw3VrLV3A37LqLWZJgga4ihoEPd7CMj+N2qY7viF/+Dpbwvm/8+FxSfgNts2MllDlRVwdIaNcfBkFk1ddZl+mRKegDJsGWc+tJGKsNTOzFf7H8Rj83D/LL58OiN8LtHGB0BnnsOdwJ+17mam19/MwDtvbmh+HFXgJGADewBSpw+vDGIM6b2aRuj/HNwlevDXHihZHggRbL1cf7vdKgIdjJmTINS4q0hEqolaVUX/7Jl4C5JQdk+XOMVUF0Nzc3UGZ2sqXHV4bPXvxePzUOFS/V0Z+LgA+PdiKSNRQ2lDI7b8Qw3gDXC8pVt8J73ULagwuhU8dAQVyJgjhtx57o69dPdzbxq5XR2Wcrxu0axjzfgCakH3x4WUO6JYbWCJ5bG5pigy/UEDyyCRyPbqXHXUO4sxx8dA18HdekqzN29zKtQrZKSRh82YQzdj5p5dfkZLLnlRSoGfLiN+HxpRLlc37B6ILd0PEFEOnlV5D4uFI8j+s6G6q3YfSNYq9u55NyTmHfh67PnZtkwPNmW5FMPXcyQLwhjLbgSzQzF98PDDxNiAiflLK9Rbm9Lj7pu+sa6WZT4Hr95s+qcqgr7qat0460MsbPfQjBZgZQCt7mUVy94Nae6F8D27dkQylCfDVIWXKUh5ZLjJXgbVKeYSZg4o/4Mnu9dx4vzVZ37Y5MEfKwBU0knISPLoWesj+C3foJ0TFDirMgKuLCrc7draA+MLMQmbaR8uQyHuDtCeQSWDQWhbyXsPw8scZ5c/wJbe1XG1V02JdAnz1N17XWqcrqWnqx28vTT6vfWrSwaV/fb3royIu98G8ORYZhoUgK+bBl4vZSlc6E827aNCGMAExEfDKwAoDIaxWlxEklGWLRcPXz8Qy7OaTqHB9tVZ7I70QJpM4H4BF967kNw9euRDeqBesaKS9l26b18/OO3qwWsAdato87uJ4KLQO1i9u7KtSy3RBZR7opSMtBOTQ20rx8jbKQWeqJmVvi8/OUv6rL3hbxIk+R3DygH/5229zLYb2FFzQo29Occ+JPzJGmRhn0XUZc2Yvy2kJoJc906CAQYcxgPQ1+cpG8H5fFTmSuKT8DnzcNekZdBUQkLW04HKRhz7GXAa6IrkxXl7QHXCClTiobK+UrAo4UDX7b372GeazGRsIm+tlroXc3ghm5ln2treddvN1E5XInb5KWrTS2XZYuXknROMDZhRlonKHF4KU2Y1fShwNrKYVIm2FifpK1NsHu0ivYL/srnL4aKRB8Bm8oKSDnmkw42EhUj7BjaQUJGcb3n7WoelH0nZQXc1rWHmhqIDisB3+PfQ4mtJDtS8G13vY2P3f8x/Ik+HAEf85erpl378OsAKD91L7zylZRfeCrYgoiEixpj2lNLwhDw6mpobITublrrfAC0OaoI20ZwR32UoJrIe2ml2phDxR1OYXIGCZqMVV1M8awDH0uNq8FIJc0gJY1mI+bdUoHDZHQC1S+Bn/+cVLgBezqC20iWcERVKKt0qB0iEeY/9VsAdocbiacs7HjkTDCl+cZTXyeainLpGW+j/u1qPhCRtrE0XUXENs66ZB0xRwzneA3l5nkERCf09RF1hCiRblY2Kbe3a1iNqtn83N0kzPDcMvX9a0Z78VicnHxaiJQpxqakGsl30yvv5tYrb4Xly5WApwJE/v4IvS8OQ9xDRX1QpZfGvHiaK7LX2lkNZ7F5YDMv+Ix5sNN5Ah6Nsi2+kPp5T2Y39XduY+iJbeAYw+eqoIoh5cDtE4CkJ9IOo4uotdUT8uUENGQNUBEVtCSG4ZcbKfv7jQA81Zymy6qO/VxahZPOWaYEPDMroKtpgeqMyQh4by9LjDmtOy9dQ08il2PuY0xNEVhZiS9v4JR9rB9T0nDgkQoYUvPyVAYncFqdRBIRmhdGQAoeecDG91/9fZqsKnThiVYg4iUEEwF2BDZDw/OkDENW6apk6Tmvx2yzQ02NGubb1UWdRZmyvsvex95QNZXl6gE4EC2lwh2Dvj4WLoT27QkmIipOeepAGpG3yGaFMb/zU9vVtXDX0BX834df4PT1PWzo20A6mYCBAR4vn8CKHbrPpiGutMTh9DNINTue/CtnfQAedRoLqti2IUWKT78zN5Butik+Af/4x3E8ouY2cDrB7QZH62JK/JWEfJ2sPysXF3RUdkGJCivUVy9UAp4ojMutb+tiz8amgoEVg08Z/3zve5BM8oP3byU0VENPhRKxinA90qmad0lzAK/dS6m0ERHq9V116neoIhOukYzUdzHqAqezm5Rd3RAB0xJY/2HcJh/X3nctl91+GUNVd8FD32PJxvPVRdrcDH4/jfUpAv1KwMOJMB6bJzsI4rnu57jphZuYcLbhDbppWaVE489DNwAQrFdCUVaG0SvuojqubmRr0ojN1dRkBXzRPB8A+5w+YvYhqlIePMYqPt00Um3EYD2hBNIRMVo6igpbDelwOUmRBFOa1nnK0TUOK+fnmV+FMyPg5c1QVUUsbcVBFI+R+2sKLcNqTuEc74ObbmL+xCZADYS67DKgR8WafrbuZ1S7q3lV66to8Kq73BxswuldDK5hdpcpESnzl1DvbCTh6iIhIOkM4otZmF/vhUAt+ybUTbtzy78A2CJUi6g+PoJ7LATWEM2+LhbSzxVXwFvOXkNdSZ0S8N27cfp7CcfM9N67HhJuSiuDSmRjXjytuebzmQ1nkkwnGRUqBBgz5wn40BDbOImy+eq7ipSNkbF9DK24WKWZesoNB16KNCfBEmXC0g6jC2mpXsxATRorcRApAukA5WYPdaiH5iUjHYiEgw0rjEErRqYH4QrOOl397bWrTlaX3QNr1hQIeLNTQNRLrz1C13hmBsYmfM64em9lJWW9ublSbMQRaVX35nApJVveAGs/Ru3EeNaBe3wRRNLF/fcLypxl/MH9HjxDjZSPL8KU9BJKTTCcGgDXKKMV6p7NrBqlKkhAfT309ma/Z++iC9hLK+e15jLNKnwp6OtjwQJo73EwHFMZZisGJWw2crelpG5YufwhoUT9JNnFE8/ZWbWuh4nYBHv3rId0mj/GR7EPnAtJB9Uj7TgT4HRPMFiykIe33s3zjfAZ99fh1N/SJ1WL/TWnrmSuKD4BFwK7EaeqzAy6ammhfKSSaOU+1i32YEqDx78Qq68Hi1c1FevLm6mMWxhOF86BERBdxAabuPfe3LbBF7qQLjeJq94G73oXzz+TgFAV4VIVx6428oNx+ImLCUpsJZQKB2Gh4np768bU6+VtLKryQ9k+osa0nMmy/WCfwCzMDMv5EKrm+vov8HTn0zzd+TTXN/0Onv0ULsJZBw7QWBZipLMmW8YSewlnN57NX976F+7uOEdN2FT3ApVBO4vPq8bhgLMYwBc2s9NYqLi8HLAFsaRc1Bq55LakkWKZceBdXSxp8gGwobYSTCkWO2xZB57GTLVlFNJpPMEYSVsESno5Lamaybue9vGT75Rly7lksWo+zt+rJnEqXzkPl7HAa32Jio1GU1bsxKgx1kpMDZ9JqTOuppL67/9m6bkV3PAlyS23wCc/CYSrKJOtJNNJ3n7S27GYLNm5qJMj80h7Tgann3C5eoDWjLmYL7xgTvJsSQvS6adiIq7qY3QRvcZEYTt6NgHQGVHutMEWx71pO+EtG0ing6zx7uOee4x5ykEJeCKBc6iLCE56numAuAenL6ji1LESPAtzowHPbDgz+3f1QBUp52B20rBo9zB7WICpaTfVQXAF5zHhDDB0+mvAMUZVeVUuBg5YqneTtgZgdCELq5rprLTQyl5KHJ1IJBV2H/PZh9OW5Cp5L76BJvyNRjbFtreq32PNnHZa7noCVEfyeeeplI2hIejtxdfgholGBiJd/PWfhoCPN+F76I9KwCsqKMsbsWwnhtmIgdsiJSwI1sEDP6Z0oifrwCPJMHazk0cfVeGn84ZdnPGz2ygPe7CkSgin/Yybx9Q1JdVw9/xRloCKffT2UpdSZdoUX04EF2vkv7NvqagAxsdZ2JygJ1TG/thKAFYEXDkBHxhgQb8ZIj5kg+pAviC5kWeHF7K8T4WC7nr8OR62rKHXsQfH0Hl83PQTKvY8jzsODk+AoabT2WMN4onB/PRJcNEX2RvdQImtJJvNNhcUn4CjZu2DPAGvqqJ2pJx0ZTsPlo2wbNyKbbSVtLsHZ5V6Ci6pWEIlLoZFJJu1sWfjPqR9HCaa+PWvcoNKBncM8+P6G2ldZCb2k5tZbz4LQtXZzo/6CXUT4RomJg0HbnIRMMfAEqG/yujQqdjNt1puhroN2X1HynvBOYLHUkpPXAnyR2peyZd31vJgzaf57GvepXZNRH3BjIC7RhnYW53dj8fqQQjBVfNew2vvfIHSiDqVtSknVbVmenrgqVfewMlDKXaElSCVlQG2EFZKqLzqjaouU5MEPBSiSqp9bS5Tna2nVTqzDhygWgzC6CjuOIyZJ8ASY6m4gj/9CWzPvpnYWG6U58mnnA4WC+8tvZtHfj9ATZ0JlzGKs86jBDyWNGMnxuKdAfhRO5H9r8bnNc5HNIrpZz/hq18TzJ8PF1+s1hY9v1XFQN+5QqV/VrgqVOfi+DwGQ8vUuWp5HNJmmoecnBJT8Zm/1p8K5gTVg6OYTRJ7cDHDacOBR1XWS0qqJvi8b/8X7pVnEEpHicgETmfenAygBBxwESJSUk3PkA1r2o2whVSrJFBPydLcIJm6krrsknSndtaDY5z9PUrBd22KkMZMsKqDkwfBEykh7AnQ46wFa5Sa8nLO8u6k3hgD4FmoOta8yYW0ljUzSBDrmm+SuuYyAMpdFZQ7Igx0xnkrf6a533ioxjz4tl8IgD3aTL3R4e+1qWvabXXD6cbUC9u2QW8vpoY6rIFFtE9s46e/zc2BnpklkMrKwk5M4pilEj5n2EVzlXowl4x1ZR14JBnB63QSDsNnPgP09TGBF2/KjzXtZcK8GynUNbB5dD0mYcrOZZLFcOC1kQ4Antiozs/yvfdRkUkaqFFP24XlKtwRGlHn7KyKFXDPPSrVt72dmrQf2i/LTsN7UfRpotLBnwa/Bmkz3/pHH58rvxaE5LufX8aPGr+L2LYVdwKs7hCDVLF3YQULR2FN/Foo7ebvHbdzau2p2eXZ5oKiFPBMRk52ckMhWDDRBNYIay39vCJQTnqsnrizD3PVZuzxGipcFVSaPSSFzE7H+cjXf60+P9FId4+JefUJzCLFYFec523n0d0Nt/7RyVjKiyudi2W2ZCIj7iEi6aBy4LYSJsxJzPUbSJsknkArlO3lit3f5E1NN2AxqQtpvHwIajcxz3ky3eFyLCSo3fc8X7mzn1c90UVDA7x23mbOKdkKZjMYnUyN5n7Ghu347D4gL+f4kUewROOc1KaEYYlDVU55OZhWrmBZ3MvO0d3ZbdiC2MxevD9RHbO1mUTe6moywx7d9z0MaTPRMuWqzm71Zh04QHWqD4aG8MQhbTzU4qmTeMt+N/tfLMtO3E/axNLGZvj2t3HefQcXv1M9sDyGA9/4VB1//nNOwJ27XwT/Ana3m1i8wCjXxz8OK1dmjy0EfOITcP35H+DDqz7MGfUqF9okTFzX+n1Ydx17dxgtlYUPwdAy6s1RLjXi3P+Ypx6C9WN+2LOH0uRiIuZBxvduZ0cmKd2geWkN7qUrCFWVErWAw11a8HpmejynJUGkah69ogF70kbCNKEmWRqbj7ulMAPhvHnnMd83n2Uu9WDe3qFaR9u2pMHTR69lDycNQdmEjbjbzwsBJazN1T5W1vbzi9jnAbC0qAypGusiWnwtAGy95Hcsdg/zkdUf4bKLr4NPfYqSGheiqZFT+o2lCIeW89+9D6nPOudhrJBX6MAXqj4I2tvV8lP19ZRMnEW6rA1qX4RwJSSd2fVaJwu4nRjmtLoO3a5Gml+hylcyuj/rwMOJMGWxCJ/mu/z853DH+kUEKKEkNoIt5SbsyE2Yvn1oGxXOiqlCWF8PfX34JjpZ7NjPPfeoL9PqX089KoxS0aAMygJpDN3tPoc/nbOf0774UzVA4+Mfh/Z2lSW2W/UZObFyQepfAPwo9TnMoy1MuNrZVK7q6KS6Rcr979yJOw4WV4TBQcGe+aW0eptpsr4bYiUE4hOsrFnJXFKUAj7FgQNXhZfBj9r5+uAf+OHY2cTHmklYA8QaN+IKnMyzz8J4Qj19h8PD0N3NM5s7ADjHyDdeFt5AFUMMLjmffW6V2fI//6P2f8EZuabwgj3GxVqq0ty8di9eu5e0CWwL1Ax3YsfVYE7SaZogsLifk6tPpjHlob9qDOo2Ms98Bt3jJTTQg+kpY1a8bSqOeN+qr3DNPNVhSl0dWK00plRZfTYlQCUps7oA//53KC2lZOAKAFbW5FL0+PKXWfa+zzEcHmY4PJyNgdtNnmzO9bJSIyWzuhouvxyqqxGf/CT2qBMqVcy0tWleoQOPdmUFPENwsJnkpz9He6AGIsqBmwIN2K1W+NSncjN5AV6HKuM/7qjnRz+CWNyEgyglRnz1zDPh1rs8ara9b32L6bho/kX84nW/yK7RCfDJNR+FnrPYt824MMr2Qd8qqpdVsOKuv0LKwp5KFa9vioTgqaeoMhkDc574A4MeOLVkUXZ/FSUu3FY3IyJKyC5wnJYLgQCqA+bkk3G21BCOW+lwLscdTdMdaQNLHMtYE1abKPjIjy/7MY++51FaFymR3L1FhQc27ALedhXCJLh2l4eq0STSM8C/2tTnK91lUFVF5nTFqtdC0k5zSSuLK1Q2zXtPvYb13+7nZ6/9GZXvujZ38S5YwBpjxryq8EI+WLcD26M/5nV112bLle3EtLqUabDZVBilvx/q66mOn63O6ZL7YVylyWUFvKJCdWga2IhjRjlwb2kTZ17spcodoizSgwubcuBjwzj7R/gWX+DkeRP8rO3VSsDDA9hjNqQ5N397Wqapck+TildfD8EgomMf/17zOd76VljgHWQ++2jICHizutYWdj2e/dirz5qn0h//+7/h9tvhG9+g0jQK7ZeCNOMSVioZ4SRUPHx50E5N5ZPUV6h9LCo3BDyRwJ0A4YowPJJmX6iHBZe8lWDAi7XtzYBKT55LilLApzhw4I1n9XO+v4fv/fbNDLmXERlXcadIVSdm/0m8973w/V1qIqah8BC8+CKbvcopXl6uxGnx2Fqq68wMLn0FeztVDK+rSx3v4nPVwWxxKy2ZnGOfSjkqsZdQajTv0vMfwRbyEtj2agDaKuCFsgir6lax0FLNU4sCYIlRnTyD7lEnDfTAk0bmwY4dKrd1YEB1KoLKzW5qojGkHGSJUNvdv72T38z7Mqff+nF2nvs+Bns/Qe3GS7ms8fxcpdhsLJunmsM7hnZkHbjT5MZsMuOyunJOvrpa9Qp//OMwPo4rYgeHaqnUnnERrtOWqkmZgOpwBwwN4c4T8KG99ex/86dJYFND0AFbMNehnE9GwAnUZxeasBPjDNbxh0t+w2OPQVW1UA+UzNP6EGhqUtUlQ3lP9r7TqX7T+ViTktKxcmTD8wDMt6ThqadotKsH9Y/2qFzh81quzH7UaXVS7a4mlorRWr6AK856z9SDPvUUzovOwe+H3ZFGKsKh7JzxzsDUBaoqXZW0lrWyeI16GOzdvIVwZIJb6r8ETc9x6xt+w8nJcuoCabAHaRtS+/I5fFBVhddoJATdL8LwUupqzayuX82Gazfw6ytvwWy2TDkmixdz2fgIhCo5a/6leNteYPfvP8Z3/19uBUSfwwcYLTuzWU3c88wzaka4+nq+ft1qTJhIW0Iw0YTZrJ5f6ktVUkouOcB+zdWYjZkZfbYK3vEO6PvRn7GRwJmQyoFvfxFnSmAlyYXz2tkYXsw4pZREBnBGcg89S7QmW29TyMR/2tqorLfxxz9C+9fvxE6cetcYABWtqtVUvuFRfPhpbYxRmmlIffGL8J//CXv2UFVrgUg5jak1eIS65i7jAarL4lzy5tcyWj3Gq1/3PFWuKkodpUrAUbMW4ohCSa+6TspaGRuD8r0fxufwcUHLBVPLPYsUpYBbLHDJJXBBXt2Y5jfzKz5ANGHmY+uvQQYas69NtJ/M7t0QGjgNkTLz5l98kQ9+s4a2UjtIwZUXqJNxsr2d6sVldHQoDc2MjFy5EupLlfOtjiSYZ6wrKSoMAbeVUOpWrjM271/E916WHRJ87xIYMUU5ve50FnrmMeFQIlgSOIPuPjONpl6yswDF42oAxeCgEtQMzc00+JUbcKTUBf1ox9m8L/IzNqZP5cbQR9nSNZ/3rn0bjRdfVVBXmWkBvvvsd9kdewLsAVwWJaDXn3U9b3Qbi0NnjveRj4DbjVeq9EIbLjxNCzBtWI/brW6s6oAqY74D79xWx64u5eqrDfPkkTk3m8/VZ11MXc+H+OAVK7Kj7ezEMJPm6ivDOWE4TKxWJeKE8272XuXA+chHaBmxglvFRpuXLYSnnqK1dDHWPVdyv7UDgPCW12U/mlkcYP0H17Pro7s4p+mcqQf1+XCVWAiFIC1N1Mdzk5t5ky0zlnXRmWoATGdXOxd/Yzn+BU/w6s4v8JaT3go+H/OCRuVWqIyoyQIuRQqGllNXB0IITqs7beZY65e+xLwH/sg/Lurjt59WfSzNzep5neFtJ7+NX1/x62w2D4sWqbxmgPp63vz6Ek6qVg87xpvw+ciGX6isxEyaUovRMf7D72AxrrEKVyVCgLlWGSBnPE0kESYyPoKroRnKylhl2kQYN2HceJnA5VdfUqRsVMTV9VmQgZIhI+DpdK45fpIqY0OZanFUzPcqwVi7lvN5ile/Ou/zFgv89Kfw4IO0fPejmM3w2ZN/zM+r/wOA/+GL7HxigBUNJ5EgxcO2LhZVLCo4ticOaVsUjEVFFpQtwO+HmuSZ+D/nZ2H5wunPySxRlAIOasaxN74xb8Pb3sbiL7yZa64R/G2HmpwmQ7xbpbJdXpFA3nsLPbbHuKXil4S9frymWk55xxk8zRqu+aCN6nqLmiwf9XAGOOOM3LSXZXETdfFxSNqwVnYAKoSy3LcIWxLqN/4H3PNrfnZjDZ6E4BdngNfi5g1L38DCKtXUFeEK0iPz6e4WNDqNvPRyo+Nv7Vpl+xtzDyCam7PD6c0RJeDPJy7iDa+N8+6LurntyVaSScE5v3wvnHxyQT01lzbz2XM/yyN7HuHqh18JthAlVnWsb77qm7z6NR+BN71JjfoE1dP5t79R3ajcc7W7NhumKDH68KrTfdDWlhVwr6ma4QHlgADe+M5mCNRRlVg17bm7cHU9vTffxGsuzg0vdlgM1c8su3KEtLQAYdVfIRAwcKpqzHzlK5w+P7fvylXnQns7Vc4gifu/gyUFlrSVf/zy3GwKXGaU4Kr6VQfsiMoXwnlpQ8CloNS+eMbP1JSo87jdu5FnbT3w4A/59Nu+qV4sLaUlZIyyNMJYkwUcgKHl1NZycBobYc0aLr/UQlmZmPYt5c5y3nfa+3IbFi4kO0mMIVZnN6owijvVlAufgJHqAWVOFd+x2cAijDl33EbfkWEQnNEkkWSUsBWcdfNg4UJWdd2d3VUJATxhZXLkRAPzSlS/zAEdOEwR8MV1QSwWqGswQW0tRKPcW/E+fvHraYa0v+Y1NF19Hl1d8LG3nsrl1WvU9zCnKVtWlzVBvYFeFT6BnAPHStIUhHIl4BkHnu3gnWOKVsCn0NIC3/wmH7zWuEDzm69Dyykvhz+9/2F+8OIGrm75Dywrb6G2/ilaqxph1SrW/P4j2L/+31RX5+ZmP/98uOsu+H//L0/AcVLGOISrSFWq3OYSewmn1Kwg+g34/RYTD5R8kI/8p4mFEXVnf+/i/6W+pJ4FTSqlzjF0Gv9+Wq2juCAzAONKo+l+441q6aYrrsiVv7kZ18A+yssl6VElvsFYHZdfaeNDX8sJ/dlnT60WIQTfueQ79Hyqh39cfT/eh+/kipqP5t6wYoX6ksYkVwBccgktrWq/88pzCuExIh9VDMH27bit6vs1lzdgMsEf/qDiohe+UsCP9nBq/D9nPF2gTF4Gu8voZDtKAZ8/H0g6cZjczHMtxWHyqD650lJWX/mm7PvK1rxKfZexNhhZTOUTHyG5+Wpk0kq9W3UcO62HNgl/RsBraqC6Rp0fa7Aab4lnxs94bB5Eyk73MpXKZt71Zs4913ixtJTFQfUgEIseQiDU9TeNgNfVMTfkn5wGdS9lBPz8FU2F15ohnmUeJfh2O2qxZ6C2dJKAhxNIJGMlVpxl1bBwIUv33Y8TI1OFAJ6YcQ9PNLC8Tgn4tA48/8tnBLymBubP5+pL/WzbZoRZM+9bsOCAX1m1ZsjFhpqawGLJCjgwVcDNDuKEoGwvJsw0eefR0VHYgJ5LXjoCbrBqFSq3Ne7BHTVTFi6DWCkXXgju+lI+wY/46OJLiZvT9Ne20VrRpM7aO98JPl9Bxbe2KnPa1JQn4NYSXIQRT/0XKbtyz167F84+G1FayoV7f82ldUrY3xRt5Z3d5bz/TBV7X7hU3aFlsbPYuFE1+d/caqQYnnGGOuCOHeqAa9bkCtLSAlLSUh1hdJsRE46XcM45cO65KpttwYIDXzRlzjIuX3wZnfe/jc989OD2IBMTzQwWAuXALea06rB67DE8lerGbi5vYM0aFb5fssQwQUknFeUHvrzy7ye726KeEPmu6gjIzB/e5Gnl1UvPY3ycrEtdYnT2mbDgWb0GnE6qjKHl/U/+jG+f/RsGBmBpbQsOi+OQ078yAr5qFZS0qBu8Ll3D5QdY3kQIgTNdTcoSxh5YwpnL6rMPSHw+lgVVbEmWt/Hele9V0yY0NGBPgd1kPGyPhYALke2PuXThpZxRfwa/+K81/P73ee+dNw/KyiirtmIyqRC61aQEvL7MEHCjw8rZrwxLhyehOl8XLMBCilMxzJAlijcTmptoZPWiFmAGB15SkhPbjIALAZs2Yb7hiyzONIAOUcCzZPZpxFBLHaXUedQ+siGUjIBb3UTTISjbQ5lpHvv2WOnsVMsnHgtecgIOaqY8IaDZ1cR8pxpgctFFZJt6Zwd9NBgt3UxeboaMCLpchZ2kFc4KBGrUmADKd1/Lqs7fcmrNqcz3zVcu5S9/UXE14zj//bV/8fuvbc2GIE6qOokPrfoQC8PXACoEVN1gDDlevjzb/OPqq1VvXIbXvQ68Xq6M/5n2DuXi3aYyli9X3/Ouu7LLUh6U0tK8gSgHICPgtZ5CB15VnsKEhJYW3F9VGSL1nnre8Ab1nsWL1U9paS4qMxNud06vHaU2Na+GmL6Jf6hcdhm86lXw6Hse5fuv+X5BwyJz81W6yxF2O6xZQ9VTaoGCWoefj33chBBqOtzM8luHQr6Ae05VaY0XnL6QL33pwJ8rs6uLLbbzovwkHSgtpS6UhrQJCw6+dqExK+Yb3gCPPILXUYrVZOV7X1xQ8JyfVTICXl2tnAZq4NXzH3w+m7aYxeuF0VF8CyqzCQZW4yHTZNwLuFzg9VL+oMq4um7em/jyBV/OpiyejjIy3honPsO9WyINnLdsUfbYU8iMxoTClDSvN1tmICfgrYc4oGaSgAMsq1oG5Dlw47hum5twIgTle/AmF/DAA+rlyy47tEMdLS9JAf/AB2DnTvjrdQ/ygzf8jpNOgte/nuwJMd1xJ28xRv7OJOCtrYVaYjaZuaDlAs4qVSJ71WujXHvWu9n04U2qVxqUctx/fy59q6KioJlnNVu56XU3Mc+jLoIPfYjchbd8eS5+/Y53FH6hykr4r//iXXu/CnteA3/6E+fOX53V+GXLcmMvZovpBLymBpoXWOCOO2DtWjxLTgGgwduQjQAtX66iMdu3w8c+dvDjZHTC/qH3wi9/edTlPuMMtVj7vIrqXIaNQaO3EYfFQZnDaIHcdBPNS1SL5gtvassK8Q0X3MDdb7/7kI+ZWcFm1SrwNCqRmN9w8gE+oVjRqi62j77uQjWYJYPPh1nCJXVn882Lv5ZdpBerFS6+GK/dy6KKRXzqE9ZDehgfEY2N6kQeRouorCwXiatLnw3tr6GuMm+O9zvu4G1X/w9r67/Mz9/7Z6xma1bAVwk14K7kwtX4FiuxrPM0sLLuFO5/x/1cufRKpmU6AZ/MUTpwILtKV7ZTsqoKzGbcjhIS6QQ0rMPjP5cHH1RRwIOZl9lirk7/cUUIjObTEpZUQnbOmsaTYPVquPVWrq6HH55DNoc2Q0bAM03xfB6/5nG1ZFvjG7j5nTPENy+55KDlu+ACNUr5wguB+GvV8thVVSoDZNEiFZeezPXX0/rLX3Lu6E6e2f4Wzn3LQQ9zVGRELl/Af/xjiMcFzHs7ANURcFgcnFJ9CgsWwGOP5R4kh3rfL1wITzwB9mULYO7m/AHUYJ9F5Ytyiw8vWMCCdXey448bWfLW1dn31ZfUT+/4ZmDVKpW7fv758Eiv2vehDJ/OhOVuePcrKc/PvFm8GMrLefiaRwt7SA1OqzuNes/RhZoOitmsnMFhKNF73kM2bLE0fRWP/P4qyr6a94bLL8d++eUUZNMbAv7G2mfZ/FY441sf5Km/PgHt32VRtXpwXbboAHb2cAT8UB14ba1y8ZkZD4GPnfUxTq09NTvgCZMJ3vc+3EvjMLAJb2IxW37xeXYAH/3o9LudE6SUx+xn1apV8rhz221SgpRCyC2d62UqnSp4ee9e9fL11x+f4h2Q4WH5ix9EJEj58MNze6g/bP6D5CvIe3bec8D3jYRHZDqdPuLj3Hijqu/HHz/iXRwW9+68V96367452/8jex6RfAX5785/H9J7b3jshqkvpFJShkJzULrDpL1dyu7uI/ropz+tzuvo6EHemE5L6XZLecYZ2U33PRSSvPY6+c3vH+zDUsrPfEZKk0nKRGLm97S3S/n610sZCBxa4aVU5+AQ+PO2P0vr16zyX+3PyrPPVt/5wQcP/TCHCrBeTqOpRyXIwKXALqAd+PzB3n9CCHgkImVlpZQtLTO+XF0t5R13HONyHSLxuJR/+tMhX19HzHNdz0nxFSF3DO2Y0+Pcc4+6Cl94YU4Pc8xIpVPygbYHjuqh9lLgy1+W0mo9xOv0/POlfM97sv92dqpbdPPmQ/hsZ6eUf/3rkRbzqEmn09If8UsppRwakvI3v5mbe3MmARcyb+mkw0EIYQZ2A5cA3cA64Gop5faZPrN69Wq5fv36IzrerPK3v0EwCO9+97QvZ6rkKPvTip6B4EB21fC5IpVSI+Zf/3pd3y8lBgdVP0hB5+xMTExQOLRTMxkhxAtSytWTtx9NDPxMoF1Kudc4wJ3AlcCMAn7CUDACaCpaSBRzLd6g7tv8lHfNS4Pq6sPIhfZ657QsL2WOJgulAejK+7/b2FaAEOJaIcR6IcT6oaGhyS9rNBqN5gg5GgGfzqdOicdIKW+WUq6WUq6uyk+s1mg0Gs1RcTQC3g3kJ1E3Ar0zvFej0Wg0s8zRCPg6YJEQYr4Qwga8Hbj3IJ/RaDQazSxxxJ2YUsqkEOKjwEOAGbhFSrntIB/TaDQazSxxVCMxpZT3A/fPUlk0Go1Gcxi8JOdC0Wg0mpcDWsA1Go2mSDnikZhHdDAhhoD9R/jxSmB4FoszW5yo5YITt2y6XIfHiVouOHHL9lIrV7OUckoe9jEV8KNBCLF+uqGkx5sTtVxw4pZNl+vwOFHLBSdu2V4u5dIhFI1GoylStIBrNBpNkVJMAn7z8S7ADJyo5YITt2y6XIfHiVouOHHL9rIoV9HEwDUajUZTSDE5cI1Go9HkoQVco9FoipSiEHAhxKVCiF1CiHYhxOePYzmahBCPCyF2CCG2CSGuN7Z/RQjRI4TYZPxcfhzK1iGE2GIcf72xrVwI8YgQos34XXaMy7Qkr042CSEmhBCfOF71JYS4RQgxKITYmrdtxjoSQnzBuOZ2CSFec4zL9b9CiJ1CiM1CiL8JIXzG9hYhRCSv7m46xuWa8dwd5/r6Y16ZOoQQm4ztx7K+ZtKHubvGpltn7UT6QU2UtQdoBWzAi8Dy41SWOuB04+8S1JJyy4GvAJ85zvXUAVRO2vYdjLVKgc8D3z7O57EfaD5e9QW8Ajgd2HqwOjLO64uAHZhvXIPmY1iuVwMW4+9v55WrJf99x6G+pj13x7u+Jr3+PeCG41BfM+nDnF1jxeDAs0u3SSnjQGbptmOOlLJPSrnB+DsA7GCaVYhOIK4EbjP+vg14w/ErCq8C9kgpj3Qk7lEjpXwSGJ20eaY6uhK4U0oZk1LuQy3cfeaxKpeU8mEpZdL49znUfPvHlBnqayaOa31lEEII4K3AHXNx7ANxAH2Ys2usGAT8kJZuO9YIIVqA04C1xqaPGs3dW451qMJAAg8LIV4QQlxrbKuRUvaBuriAQ12lcC54O4U31fGurwwz1dGJdN29D3gg7//5QoiNQognhBDnH4fyTHfuTpT6Oh8YkFK25W075vU1SR/m7BorBgE/pKXbjiVCCA/wF+ATUsoJ4BfAAmAl0Idqwh1r1kgpTwcuA/5TCPGK41CGaRFqwY8rgD8bm06E+joYJ8R1J4T4IpAEbjc29QHzpJSnAZ8C/iCEOJarAs907k6I+gKuptAoHPP6mkYfZnzrNNsOq86KQcBPqKXbhBBW1Mm5XUr5VwAp5YCUMiWlTAP/xxw1HQ+ElLLX+D0I/M0ow4AQos4odx0weKzLZXAZsEFKOWCU8bjXVx4z1dFxv+6EENcArwPeKY2gqdHcHjH+fgEVN118rMp0gHN3ItSXBbgK+GNm27Gur+n0gTm8xopBwE+YpduM+NqvgR1Syu/nba/Le9sbga2TPzvH5XILIUoyf6M6wLai6uka423XAPccy3LlUeCKjnd9TWKmOroXeLsQwi6EmA8sAp4/VoUSQlwKfA64QkoZztteJYQwG3+3GuXaewzLNdO5O671ZXAxsFNK2Z3ZcCzrayZ9YC6vsWPROzsLvbuXo3p09wBfPI7lOA/VxNkMbDJ+Lgd+B2wxtt8L1B3jcrWierNfBLZl6gioAP4JtBm/y49DnbmAEaA0b9txqS/UQ6QPSKDcz/sPVEfAF41rbhdw2TEuVzsqPpq5zm4y3vsm4xy/CGwAXn+MyzXjuTue9WVsvxX48KT3Hsv6mkkf5uwa00PpNRqNpkgphhCKRqPRaKZBC7hGo9EUKVrANRqNpkjRAq7RaDRFihZwjUajKVIsx7sAGs1cIYRIoVLeMtwppbzxeJVHo5ltdBqh5iWLECIopfQc5D1mKWVqpv8P9XMazfFAh1A0LzuM+aJvEEI8Dbxlmv+vFmpu9a1CiG/nfS4ohPiaEGItcM5x+wIajYEWcM1LGacoXFDibXmvRaWU50kp78z/H3gSNf/2RagJm84QQrzBeI8bNbf0WVLKp4/Rd9BoZkTHwDUvZSJSypUzvPbHGf4/A/iXlHIIQAhxO2oBgbuBFGqiIo3mhEA7cM3LldAM/083xWeGqI57a04ktIBrNIWsBS4QQlQas9hdDTxxnMuk0UyLDqFoXso4M4vbGjwopTzgothSyj4hxBeAx1Fu/H4p5fGahlejOSA6jVCj0WiKFB1C0Wg0miJFC7hGo9EUKVrANRqNpkjRAq7RaDRFihZwjUajKVK0gGs0Gk2RogVco9FoipT/D64VPlVSQyEsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "actual_x = np.array(kcf.ownpriors)\n",
    "# print(actual_x)\n",
    "\n",
    "prior_diff_1 = []\n",
    "prior_diff_2 = []\n",
    "prior_diff_3 = []\n",
    "\n",
    "for i in range(len(node_1_priors)//10):\n",
    "    x_real = actual_x[i][0]\n",
    "    y_real = actual_x[i][1]\n",
    "    x_i_1 = node_1_priors[i][0]\n",
    "    y_i_1 = node_1_priors[i][1]\n",
    "    \n",
    "    prior_diff_1.append(np.sqrt((x_real - x_i_1)**2 + (y_real - y_i_1)**2))\n",
    "    prior_diff_2.append(np.sqrt((x_real - x_i_2)**2 + (y_real - y_i_2)**2))\n",
    "    prior_diff_3.append(np.sqrt((x_real - x_i_3)**2 + (y_real - y_i_3)**2))\n",
    "    \n",
    "    x_i_2 = node_2_priors[i][0]\n",
    "    y_i_2 = node_2_priors[i][1]\n",
    "    x_i_3 = node_3_priors[i][0]\n",
    "    y_i_3 = node_3_priors[i][1]\n",
    "    \n",
    "    # if(i < 1000):\n",
    "    # plt.scatter(x_i_1,y_i_1,color ='blue')\n",
    "    # else:\n",
    "    plt.scatter(x_i_1,y_i_1,color='red')\n",
    "    plt.scatter(x_i_2,y_i_2,color = 'blue')\n",
    "    plt.scatter(x_i_3,y_i_3,color = 'green')\n",
    "    plt.scatter(x_real,y_real,color = 'black')\n",
    "\n",
    "\n",
    "plt.show()\n",
    "plt.plot(prior_diff_1, 'red')    \n",
    "plt.plot(prior_diff_2, 'blue')\n",
    "plt.plot(prior_diff_3, 'green')\n",
    "plt.xlabel('Error')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "suffering-november",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "understood-saturday",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}