TicTacToe/TicTacToe using SARSA - Part 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TicTacToe using SARSA - part 2 - Function Approximation with a NN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous part I made an agent who could be me in TicTacToe using an algorithm called SARSA, and keeping all the exact states that it ever encountered (~4.5k). Let's see if we can improve this now, using a function approximation of the total states.\n",
    "\n",
    "I will be using the (semi-gradient 1-step) SARSA with function approximation. You can learn more about it in [Sutton & Barto's book (2nd edition)](https://d3c33hcgiwev3.cloudfront.net/Ph9QFZnEEemRfw7JJ0OZYA_808e8e7d9a544e1eb31ad11069d45dc4_RLbook2018.pdf?Expires=1578700800&Signature=kknv~Fe2hgmHae7aID4u9P9BUwvcIQ2F5qaNopIiaOpjUeiqESW6W4xhnji1Yyf1dEgNg5NvaKCqAOtHPX65N4LFHM3cU-Zj3WQFRl1S~NM79uQSWijIvnCNAIvPVSLct6i5u7Ruc-IkWYDGoPFtyHUWq8iFH1WJBuOZTaw~QzQ_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A), in chapter 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the modules discussed in part 1, I will also be using a softmax function (if you don't know what it is, you can read about it here) and a \"simple\" Feed-Forward / Dense Neural Network - which is implemented in Keras. I set the default activations for the layers to be the sigmoid function (you can read about it in the same link as the softmax). I did play with a non-keras manual-numpy implementation of a NN, using ReLu's, but they didn't seem to work so great (but it could be there were some bugs in my implementation). In any case, ReLu makes more sense if you have a deep network, but the implementations here are more shallow, so a sigmoid will work just fine (oh, no - spoiler)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "C:\\Users\\david\\Anaconda3\\lib\\site-packages\\tensorboard\\compat\\tensorflow_stub\\dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "from BaseAgent import BaseAgent\n",
    "from BaseEnvironment import BaseEnvironment\n",
    "from RLGlue import RLGlue\n",
    "from Softmax import softmax\n",
    "from SimpleNN import SimpleKerasNN\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No change for the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TicTacToeEvnironment(BaseEnvironment):\n",
    "    def env_init(self, env_info={}):\n",
    "        pass\n",
    "    \n",
    "    def env_start(self):\n",
    "        self.terminal = False\n",
    "        self.board = np.zeros((3, 3))\n",
    "        self.reward_obs_term = (0, self.board, False)\n",
    "        return self.board.copy().reshape(9,), self.get_mask()\n",
    "    \n",
    "    def env_step(self, agent_num, index):\n",
    "        if self.terminal:\n",
    "            print(\"Environment in terminal state, please restart.\")\n",
    "        \n",
    "        row, col = self.transform_index(index)\n",
    "        self.board[row, col] = agent_num\n",
    "        \n",
    "        if self.check_won(agent_num):\n",
    "            reward = 10\n",
    "            self.terminal = True\n",
    "        elif self.check_tie():\n",
    "            reward = 0\n",
    "            self.terminal = True\n",
    "        else:\n",
    "            reward = -1\n",
    "            \n",
    "        self.reward_obs_term_mask = (reward, self.board.copy().reshape(9,), self.terminal, self.get_mask())\n",
    "        return self.reward_obs_term_mask\n",
    "    \n",
    "    def check_tie(self):\n",
    "        return (self.board == 0).sum() == 0\n",
    "    \n",
    "    def check_won(self, agent_num):\n",
    "        for row in self.board:\n",
    "            if np.array_equal(row, agent_num * np.ones((3,))):\n",
    "                return True\n",
    "        for col in self.board.T:\n",
    "            if np.array_equal(col, agent_num * np.ones((3,))):\n",
    "                return True\n",
    "        diag = np.diag(self.board)\n",
    "        if np.array_equal(diag, agent_num * np.ones((3,))):\n",
    "            return True\n",
    "        diag = np.diag(np.fliplr(self.board))\n",
    "        if np.array_equal(diag, agent_num * np.ones((3,))):\n",
    "            return True\n",
    "        return False\n",
    "    \n",
    "    def env_cleanup(self):\n",
    "        pass\n",
    "    \n",
    "    def env_message(self, message):\n",
    "        if message == 0:  # return available indices mask\n",
    "            return self.get_mask()\n",
    "            \n",
    "    def get_mask(self):\n",
    "        rows, cols = np.where(self.board == 0)\n",
    "        indices = rows * 3 + cols\n",
    "        mask = np.zeros((9,))\n",
    "        mask[indices] = 1\n",
    "        return mask\n",
    "    \n",
    "    def transform_index(self, index):\n",
    "        return index // 3, index % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The agent now will have to calculate the Q(s,a) using it's function approximator, aka - the neural network. It will then use the softmax function to calculate the (adjusted by available options) probabilities of the actions for the given state, and choose an action using these probabilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(The dimensions must be handled a bit differently in order to be fed to the NN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TicTacToeAgent(BaseAgent):\n",
    "    def agent_init(self, agent_init_info):\n",
    "        self.discount = agent_init_info[\"discount\"]        \n",
    "        self.network = agent_init_info[\"network\"]\n",
    "        self.tau = agent_init_info[\"tau\"]\n",
    "        self.num_actions = agent_init_info[\"num_actions\"]\n",
    "        \n",
    "        self.rand_generator = np.random.RandomState(agent_init_info[\"seed\"])\n",
    "        \n",
    "        self.last_state = None\n",
    "        self.last_action = None\n",
    "\n",
    "    def policy(self, state, mask):\n",
    "        action_values = self.network.predict(state)\n",
    "        probs = softmax(action_values, self.tau) \n",
    "        probs *= mask\n",
    "        probs /= probs.sum()\n",
    "        action = self.rand_generator.choice(self.num_actions, p=probs.squeeze())\n",
    "        return action\n",
    "\n",
    "    def agent_start(self, state, mask):\n",
    "        self.last_state = state.reshape(1, -1)\n",
    "        self.last_action = self.policy(self.last_state, mask)\n",
    "        return self.last_action        \n",
    "\n",
    "    def agent_step(self, reward, state, mask):\n",
    "        # SARSA\n",
    "        state = state.reshape(1, -1)\n",
    "        action = self.policy(state, mask)\n",
    "        target = self.network.predict(self.last_state)[0]\n",
    "        correct = reward + self.discount * self.network.predict(state)[0][action]\n",
    "        target[self.last_action] = correct\n",
    "        self.network.train(self.last_state, target.reshape(1,-1))\n",
    "        \n",
    "        self.last_state = state\n",
    "        self.last_action = action\n",
    "        return action\n",
    "    \n",
    "    def agent_end(self, reward):\n",
    "        # SARSA\n",
    "        target = self.network.predict(self.last_state)[0]\n",
    "        target[self.last_action] = reward\n",
    "        self.network.train(self.last_state, target.reshape(1, -1))\n",
    "        \n",
    "    def agent_message(self, message):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a Proof of Concept - I first use a relatively big network. It has ~2k parameters. The exact solution had to keep ~4.5k states, and for each state to keep 9 action-values. So it's a big improvement over it, in terms of space and memory.  \n",
    "\n",
    "![nn](nn36x36.svg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the function approximator - a Feed-Forward NN \n",
    "layers1 = [9, 36, 36, 9]\n",
    "layers2 = [9, 36, 36, 9]\n",
    "nn1 = SimpleKerasNN(layers1, lr=0.1)\n",
    "nn2 = SimpleKerasNN(layers2, lr=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I ran it 5 times for 10k episodes each. The improvement was slow, but noticeable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "runs = 50000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def experiment(runs, nns):\n",
    "    rlglue = RLGlue(TicTacToeEvnironment, TicTacToeAgent, TicTacToeAgent)\n",
    "    rewards = np.zeros((runs, 2))\n",
    "    starts = np.zeros((runs, 1))\n",
    "    final_states = np.zeros((runs, 9))\n",
    "    agent1_info = {\"discount\": 1, \"network\": nns[0], \"tau\": 1, \"num_actions\": 9, \"seed\": 747}\n",
    "    agent2_info = {\"discount\": 1, \"network\": nns[1], \"tau\": 1, \"num_actions\": 9, \"seed\": 101}\n",
    "    env_info = {}\n",
    "    rlglue.rl_init(agent1_info, agent2_info, env_info)\n",
    "\n",
    "    for i in tqdm(range(runs)):\n",
    "        rlglue.rl_episode(10)\n",
    "        rewards[i, :], starts[i, :], final_states[i, :] =  rlglue.rl_return()\n",
    "    return rlglue, rewards, starts, final_states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 20000/20000 [04:24<00:00, 75.70it/s]\n"
     ]
    }
   ],
   "source": [
    "rlg, rew, starts, states = experiment(runs, [nn1, nn2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-1.]), array([-1., -1., -1.,  1., -1.,  1.,  0.,  1.,  0.]))"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "starts[-1], states[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, not a lot of 0's - this is a good indication of an interesting game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3554, 3088)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rew[:,0] > 0).sum() , (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "only 6k/20k wins - the rest are ties! Good indication that both agents learn well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA28AAAEvCAYAAADSCPm5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9ebQs210e9tXUVX3vOX2upPckgZAsMcg2k0BB2MGBhIWwAYMYzJQ4c2JsY5xlYCXGjo3iRYTDaGIWmGCcYMgCGwiDbBkQIBlFKAySLQkhgdCThCYkPT3pdPe5p6u7pvyxa1dXVe+xatfQ9+5vrbfeffec7q5XVb13fb/v+30/pygKWFhYWFhYWFhYWFhYWMwb7tQHYGFhYWFhYWFhYWFhYSGHJW8WFhYWFhYWFhYWFhZnAEveLCwsLCwsLCwsLCwszgCWvFlYWFhYWFhYWFhYWJwBLHmzsLCwsLCwsLCwsLA4A1jyZmFhYWFhYWFhYWFhcQbwpz6AOh555JHi2c9+9tSHYWFhYWFhYWFhYWFhMQle97rXfagoikdZP5sVeXv2s5+N1772tVMfhoWFhYWFhYWFhYWFxSRwHOePeD+ztkkLCwsLCwsLCwsLC4szgCVvFhYWFhYWFhYWFhYWZwBL3iwsLCwsLCwsLCwsLM4AlrxZWFhYWFhYWFhYWFicASx5s7CwsLCwsLCwsLCwOANY8mZhYWFhYWFhYWFhYXEGsOTNwsLCwsLCwsLCwsLiDGDJm4WFhYWFhYWFhYWFxRnAkjcLCwsLCwsLCwsLC4szgCVvFham8K7fAuLN+J+b58BjrwCKYvzPHhDrXYJ/966PTH0YbLz914F4PfVRnOADmxi///4J7sEzxls/sMXbH7+Z+jDM412/Cdz/0NRHYaGC9AC841VTH4VxfHAb43V/NNAafvth4J2/Mcx7W5wgzwu86q2Po3jAnjPOFZa8WViYQBIDP/pFwL/75+N/9ttfCfz4lwN//IbxP3tA/MRvvQtf+3/8JtIsn/pQmnjzS4EfexHw+p+Y+khO8L0vfyv+2o+/burDOBt8YBPjq37o/8OLX/p7Ux+KWRQFWRN+4muALJ36aCxkeMtLgX/+JcBH/mjqIzGKf/qqt+Orfug1+Pemi3B5BvyLvwz82JeSP1sMjt96x4fxX/6fv403vGd+RcuHEZa8WViYQHIL5Ok0lW76mbcPVpV9Eyc4ZDn26YzI280HgX/9t8ifbz887bEw8MT9PZ64f5j6MM4CRVHgf/qZN2K9S3B9m0x9OGaRxmRNeu9rgd/4vqmPxkKG+4+Tf98+Me1xGMbNPkVeAN/8U2/A7mCQZP3mDwLveg2QJ8B+a+59LbjYxGSN/PD9/cRHYgFY8mZhYQZpuaDtJ7Cs0c+cwrI5IOIka/x7chQF8K/+FrC/AbzFNNdagk2ckgem3FpbZPjJ3343fv2tj+My9LGNHzDyRteCcAX82/8NeP/vTns8FmLQ6zXDNaUP4iTHwnfx9g/dx3f80u+bedMPvgX4tW8j9zbwwJ2zuYLuw9vYKvlzgCVvFhYmkMbk31NUAenm9YBVIKniNhvl7Q0/CfzBy4DP+/vA3afO8nzfxCmKAridC+GdKd71xC3+15e9GX/u45+CL37eR+Nm/4A9kNB783P/Z+DOk4Gf/avHApPF/PDAruEZnvXkO/ivP+vZ+NHXvBOveVtPd0iWAD/3V4HwEvi8by0/5ME6Z3MF3YcteZsHLHmzsDAB+mA0hfr1gFZt98mMyNv1u4Ff/NvAsz4L+LNfD0SrWQaWbPdEQXrglCSDyPIC3/zTr4fnOPiur3weVksfmwftgWRf3ptPejbwou8HPvh7wCu/fdJDshDgAXVP7JMcUeDib3/Bn8LHPnIX/+PPvLGy33XCq76L9HZ/yfcBT/5Y8ncP2DmbKyx5mxcsebOwMIFKebO2SVOI05nYJvMc+IWvJ43xX/aDgOsRy84MyTLdWO0Gy8c/e/Xb8Tvv/Ahe/KJPwkffW2IVBTikOfbpA6RW0rUgWgHP/QvAp/8XwGv+MUnEtZgfHtACXJxmCH0Py4WH7/7q5+GP1zt82796c7c3e+/rgFd9N/CpXwv86S8Boivy9w/YOZsr9pVt0hYG5wBL3iwsTKDqeZvCNrmd7rMHxGyUt9/5pyTG+wu+HXjyc8jfhZezO99FUeDGkjch3vqBLb77l9+KP/+JT8Nfev4zAAAXoQ8A1bl7IEDvzfCS/PsvfDtw9THEcna4P91xWbDxAK/hoU8eM5//rCfh6/+Tj8dPv+49+NU3f0DvjZId8HN/Dbh8OvCF30H+jt7bD9g5myvoPvzAWczPFJa8WViYAFXerG3SGKgSsp9SefvQ24BfeTHw8Z8PPP+/Ov59tJqd0hknOdIyqMRWR0+RZDm+6adej8vIx7d/xafAcRwAwGVEyNsDRXj3tcASgNyvX/ZPgI+8E/iVb53ssCw4qNwT87Ni98E+zREFXvXf/8PnfQI+8aNW+JaffSOeuNHowfy1bwM+9FbgS38AWN4jf0fv7QfsnM0VextYMitY8mZhYQKTpk3Squ28yERfUOUtnkp5y1KiVPgh6RsqH/YBzFJ5o/1ugK2OsvD9r3gb3vTeDV7y5Z+CRy7C6u8r5e1BOmdt5Q0Anv0fkX7N3/kR4LFXTHNcFmw8oMpbnGSV8gYAC9/F937N87DZpfh7P/8mtYHP73w1GQ3wgr8CfNznHv/eKm+jIrY9b7OCJW8WFiZQT5tU2ZBM4gHteZtcefuN7yNzsv7i9wCrj2r+bIY9b/VN1W6wTbzh3df4gVe+DV/x6c/AF3zy0xs/u4wCAOgXpDA3xC3ljeLz/j7wyJ8Efv5vADvDg5MtuuOBdU/kDfIGAH/q6St84+c/F7/4pvfjF17/PvEbxBvg5/86sat//j9o/mxxF3C8B+6czRW2521e8Kc+gAcd9/cposCD5zryXx4RaZbjnU/cF/KM5zxyF75n+b0SqPJWZKSnJLwY77NnvPHvDhl8z0HAu4/iDbF0MUA99lzlLYkBxwX8BfPH2zjBRehX9jgt/PEbyXysT/py4FO+8vTn0YoQ9vTA/XweDmmOvCgadiITaJI38xtsmuVIsgLLBee4D7eAF5B/ZoQ4yfBNP/V6PPUyxItf9EknP5+zbXJ9m+DqTofzud8AwV3Aa23xwRL48h8CfuSFJD31K37YzIG2sI2TihSP+t55ToaTj7n+UqR7UrgLIv3XTlmAyxLyz+JOt9cL1/CMuc593ed8LH71LR/At/7Cm/BnP/YpePoV55z98t8F1u8B/ttfJmStDsch6lvXcxZvyOu77A+HW+D6XfyfewFJw+zy3n3uIxmyBHjiMf7PHRd4yseRUK4WZp02mewIkdfciwHgQzd7XN8meM4jd2f3nC6CfTIfEFle4HO+85X4yd8WfMknwvf96h/ihd/7Knz+P+L/852//AdTH+b5IKv598e2ccx4RtB/9iO/ie/4Rc5w1s37gO98DvBHr2H+mKZMcpW3f/mfAy/7JuaP1rcJXvCSX8Urfv+D2scMgMSqL+8Bf/F72T+vBsTqn/MXv/RN+Cs/9tpuxyVAPXBjiPCNf/JvH8MXf///y/+FH/0i4JUvMf65ffEzr3sPHnv8Pr7jL30qrpanD/2UvM0tsOT/+o134NO/7eV4/zrWf/F+07RM1vGM5wOf/c3AG/8l8IGOyX8CPPb4DZ73D16ON73XfC/S+9cxnv9tv4LffPsT7F94/f8N/O+fSizPY+Pn/zrws/+9/uvyDDjckD9PsYa/4tvId7cLPvBm4Dv+BBmczUCcnCpvAOC5Dr7nq56HfZrjh36dQyaeeAz49z8OfNbfBJ75mezfCVfdztn9DwHf9fHA235N/7UA8DP/DfCDf4b/z/c/n3y/uuBffxPZ24bAL32L+Lh/4AXAq/8R86V0P56lvfzHvwJ4+d/r9NKfeu278cLv/XUk2QxGEmnAKm8DYhsneOL+Ae/80PzSvd7zkVs8chHif3nRJzJ//pKXvQXv/chu5KM6Y6S1B6z9BsBHcX/VKIriuHnN0Db5zg/dx9NXnAri9v1AnpIK5p/4rJMfS4d0X/8RkLMVpifu7xEnOd7R9bu3eS/wjP+ADDhmoSJva+DuU7Te+h0fuo/3DPDdqqttQ8wte8cT9/G+awGRuH6XuKo7Ed6/juE6wGd/wiPMn1MVZ052oLd9cIt/+Iu/j7wA3rfe8ZUJHgRqCADg418IvOo7ge37gKex94CueNeHb5EXwDufuI9PfsaV0fd+7/Utkqzg703X7wJunyAhFprfy9544jGibOiiTj6mcE888RjwxNu7vfYj7wCKnKhjT/3TJz/epxlCjsPg2Y/cxTPuLfHE/QP7vW9Lgv6cz+F/ftTRvr55Lym4fvgxAC/Uf/31u8n+8B9+w+nPihz4f/478jtd8OHHgBvNNE5VXL+bzH78vBezf/4L38D97KPyNp91ssKHH+usHG92KRaeyywyzBmWvA2IzY48QM2xl2ITp3j6VYgv/tSPZv78n736HbM87tkinUh5S26JVdNxZ6e8FUWBTZzy57RRwpuwH8Qq2yTv9UlM/mEgLsNOOpOYeM18GKnQo1l+s0ux2Zn/bm3LiqjrDFMd3exSxGmGoijYVtQknmXy2yZOsFoGXPvs3AJLSCrmG5CWleBO98p+y1fegOOMrAGuFz1euv+ZfW/ynjFvJh9dS+Lr8clbvO5H3qZaw+M1IUB5DriaD7D0/mGs4UVRkLRJwUPxwncF63v5nv6S//ldg6PocXe9/+M18NGfBnzyV7B//tK/Se7Bru891Doar4F7z+If9y/9Hel+fLNP+XvAVOhxzsj+0LG9YkKcF9U8M1DyM8Qm1hebXYKVoCdhFQWDPGA+sKgrb2M+wFK17eLpQLrr9vAwEG4PGbK8qIjUCeg5S3kErLRN8pS3dEf+Yb22fLjrfA/H6+MDLgtU1eigdm7iBNt9ijw3G2xDexGeehkNUh3dxAmKAkgyxnEXBbkWcyRvkrVu4ZOq61x6OX7wlY/hje9Z4xtf+FwAHQsQ+81pWEkdQ5K3eLiiJX1P6ZoyxX3Y9QFyX1vDJxk1swZQdFOw6P8vYw0/ZDmKAlzlDQCiwBOs7+V7inq/wlW3c26CvAn3h6t+7x2vhwk+kx13EEn34yQrpp+9WkcSk2PuSt4k+8NcYcnbgKgqkDNUsDaxhLwtg0GsVw8sGsrbiBswrTpefUzzv2cAet/vuVVyNeWNu1EkcfO8119bKW8dvnt5Tq6haJOrbJMdyNuOkKCbg9nvFyVsT7+KBlLeygdn1vXMU2IXmiN5i1OslmKTyWUUVMrllPjd96zx/a/4Q3zZp300vvoFzwTQsQAhs02OorwNQN52kjVlKvJWFOQzD1v9frv6Gn7YkvVnTPQhMgLyRtdtkR0tFClv9D19AXmLOva8Vf/PHdSxLCXXaUjylqfEVWMaMvLmL7nkrb4Pz6XQBaD3jMRNnOKS0Qs9d1jyNiAq5W2O5G0nfqBZRb5V3nTQ6HkbkUDRhevqGeTfM3p4rixOHZS3JMuRlcoUN7Ak3XGJ31F567DJHG4IERGSt262yTwvKpJg+vt1E6e4u/Bw704wyOZK33PPup6VXW0+9x+FSmX1MvInfyChqZiPXIT4By/65OqYO+0fMttksATcYCDlbbh9jxYUuWtKMhF5O9wn9nVAv6ATt9bww8gFOBPkjWFfp6RMpLyFIuUtUSBv4WU/xbCPUjoEecvSY3jNEPdwvAaie/yfB5GgFeG4D8+q762nikr2h/PrILPkbUDQjWbqhwIWtgrK2zZO1YZoWhAFyCm/TmNaX+iCtSo3/hmNC6ALPLc/hapmjApjfUNnbu5ZQqqTvCphn5k0qpszoH2t7x/Syg1jel3YxikuIh8X4TBERKikVnMON+PPOZRgG6eK5G3aB5Lvefkf4A8/eIPv+MpPxdWdAFHgIvCcbtdyvwFCwf3rOOUDpvn1YjvgvlfdgzK1Zux1sP55up9Nf5+u4WPuH0XNLtmJBJWvYdjXaZFHpLxFvisuzgGk0MBDuCLHoLvm0OPucq5V94cu57P+GtP3QZYCyX2J8sa3Te7THIvyWs7qmba6B/lOHBG2ZU/0ucGStwExpH2kD9Isx/1DJrxhV1GAQ5bPy9s8Z6QxsCyTCUdV3s7ANslV3srNmVHpq2/oTLKQ8F8L9AwsoYRYSXnT22Drx2NcedunuIwCYgE0vLnmeVFZMZmqB70eQ9l9eoA2pItwEfqTjgr4rbc/gR959Tvwl//Ms/AfP/dRAIDjON16j2n0vEh5A/pZuwQY1jZJ70FZYMnIylv983Q/u3JPTLCGU5cB0FF5K22HrDVcxTZpQnnLE/2HdhNq4xDKW5/7SAYV0ulHgjaGDI9ehADmE+4EoGl97dSDLi/uzRGWvA2IY+P2vBQs+mAnkorpw87ciOdske5JVO2io42jK6as2kpAH7T4/Snlhsuo2tYHczPJgiTsZN8nsIRumqLABz8EvFCfvNWOx3RP6aYcSj6EirTdHxVDtvJWe3iamXVys5MPjJ7SNnmzT/HNP/0GPPNJd/B3v6iZcNqp95g+/It63ujPBw0sGVL95RWEyvvwnMhb3FrDx9w/+pIFQc8bJdisId0UoVB5U+l5K4mItlX1ISRvlOQIA0uWXCIcJzkeuSTkbWqXQgM9z9lmJy/uzRGWvA0I+qCW5QVuD5wFagLQDVD0QNOr3+JhRBqTTSZajUugzkB5k/a89VHesj2zwT/uE1iisjkDna51g7wZLoxs4xSXkY/L0Mc+zXEwqJrXj5X54Fwn4DMib5XLQEregsmqyS952Zvx3usdvuern4e7YfMholPvMX2QFRUfgDNV3uiaIrHanRN5228BxwMun37877EwIHlTUd6iwJWnTQqVNxocpXnOTJA30feLpmBq2zmHJG8K+5ofcROc90mGRy8WAOZmm+x+zuIkwz7NrfJm0UT9wXFOJIgqIiLb5GWpyq1nOOZglkj3RI3p2kDdFVXVtpzXN6OeN+mDliBtstHzJrLpAcKq702XSH5V8tZhxlDDNml4TbjZE/sH/e6aJCP1Y2VezzoBnxF5q1wGCrbJKdboV/7+B/GTv/1ufN1nfyxe8OzTgfBEedMlb+U9OZVt8mEMLOlrmwwvB00A5cIUeWOu4WVgiS9S3jyxBdYLxbPn6D2urXbWyFtXgiVT3rpYyBvXo+OcONl7Cx0l/MCSfZrjKXep8jaj58Ie50zFhTZXWPI2IOpJd3Oa9UY3VbFt0ipvbfzjX/tD/MN/8xb2D6nyFq7Gt00uLo4JUjN6cKYPWmleVAOHG6isjwzbZG1DZwaepDLyRj6vKKAfAV9tzoJULqDTtW4qb+ZHBVyEPi7KKqJJa0v9WM9JeTuudeLK6iryuxH9HsjyAn/nZ38Xf/Jpl/jGz38u57g69LzRgo7UNjmU8pY2/m0SW9G4CuA8lbe4nMnXsY+2F4ZU3so1OArEowKEyptoxhtwvMe72iaLjCSFdnmtUqBVR1LZ5bWq7y2d88YfuP6UB0x5q/YHG1hiUcd8lTf5DVvZJm3PW4Vff+vjePXbPsT+YbovyZu+GtMLdBhvEAHeYl62SanVjqZN8i03rsNT3mqvYVp2jg93+g+/dJOTPPx2Ut6GWxNuqG2yLMqY3GDrxyq9HnMibwouAwC4iHwUBXDLUwEGwHqX4P2bGF/zgmdy+4JWS797z9tUtsnyXtklmVHrbv29uSFIkylv9dCEDrbJaNXdAtgHfcgCnYcJCNdgkfIWBR6/uJfsxJZJoPPIln5kew3AEX+/zpW8+eyeN7of3w19LAMPN/sZPRf2IW87teLeHGHJ24DY7BI8bRVWf54LVKoNVWDJnCosE2O9S7ATNVf74fg9b/HmuIGNbdmUQGq1oxU+Vsx0uVmsloFc6WFYduq2Km2SFK+B4C7gSRb0DlHrlEw89TI0uiZkeYH7hwwXZc8bYJi8NYi4YFQAMC/ypuAyAI79v2M24q/Lc3rvjriINmjPW7rrFK/NQ1wSNrrvmTyfRVEc0ybnNqQ7XpMH3y6EmNomF3fJuJkpRs1cfpT+cdeTKkVpkxLlrf67DdCCqAj0Htc9Z/Ga/D/TP+u+NlyJ7Zx9yJvjAncfnU55E7QxhL47i5mYDfS4lhtFW/0cYcnbgNjGKT7mSXcAzE15U0ibtMrbCa5vE0Hs/X4i2+T2qBCFq5kpb8cFPtZU3ijZW0WBvMeKZZtsKG+6tslreb8b0M02GSe4u/Dw5LsLo2sCjbmnowIA0z1vNdukKP0TMN+r0QMqLgPg2OM75riA69sDAAl5K4sX3L4gFlSV48pqbW69ovf0cd8zdz73aY5DqdBIQ5CmIG/RVQ/ytiKz98Z2btBjvXpmP5VIYH2XpU0CAiu2aMYbUEub1DhnVDG896zyQDv8f0vDrDq2MVBiuHzSMOTNcUmbBQ9+RKykWXNv2tcGrl9Gvn4rwpCI1yTsx/Wt8mZhBptdgo950rL883xu9k2cwHWAuws+eYsCDwvfnRXpnBKk6psIUs7iWmDJBLZJYHzVTwK58kYDS/hDuq94ylv9NQLy1z4OJahszkAnpZPEEgelomJuTdjuaYJs3TZpsudNorwlM+95k9kmw/GdBlR5uxLa1zuoqDqBJYDR60Xv6eO+N9A9yFpPimLaOW9dyVu8qRXgOg537op4TR7m7zxFv+hS///sOOeNEjv2mhJr2CY1ztl+A6AYmLz1UN663kcq7y1TDOn5bqlv9FpGvouLAeaI9kK8JmS5wzmzPW8WJ8jyAtt9imfcM7+J9QWde+S6jvD3TD9gnjN2SYZDJqiAU+UtuiLEIhvpejdskyOrfhJsdgkW5cYtVM+Yze7k9wl5k9j0OM3y9LM79bypkLeoVDo10so2cYJVFJS9TObuEbqZXoY+LgbqeaPLhXDunhfOi7wpuAyAaW2TV8sF93c6BUftNyR6Prgj/r0hyFulvC0b/23yvRe8kIvsAKAg9+DhBshG3Luqh+573W2TAPn3qLbJ6x6ks/x9LxQGloiHdNP9gaO8ycibFxC7qs6x0999GMmb7Lip0tmyUlf9i4GH1QBzRHuhxzk77g+WvFmUoPabJ99dIArmpWBt4lTJ42v6AfOcQR+0dknGHrheV96A8dS3Odsm4xRPLYd6sm0x/DlvcdXz5rM39saoAHZMNf1sbTVFR3krcq20ss2OfPcuow4R8AJQi+TlUKMCdikeuaDXUkCmL582L/Km4DIAMMg5k0FFeaPHpVWA2G/JvemIi3PHB0xzNld6nM+4V9omDRb/1rV+UaGSf/k08u+xFSwaOtIlsKTunhj7uMNVt4HtVb/c03oM6RYob+lenjYJ6Ltd6lbR+n/rvF5lBijQTc2MrrrdR6rvLQIly609Na4R8YvQH9VeLkWP794mThB4jjARda44vyM+E9Tl2LkpWJtdolRp6NQs/4Di+pach7wAkoxF3mo9b8B4G3DdNjl21VYAajOlBIr9sFVW91jkS0d5Y9om84psDKa8dbjWm5io3mT4skHbZLneXEQ+Qt/DwjNbMNrECZ58d0HSP5k21vIaXMyMvCm6DIZI6JSBrili2yRV3jSOq27DE2EQ5Y0c5zMGVN645K26B8th12P2Xnat/icxUQynCp1qHPeG9IPpvBYg55sTcuE6gC/47tGHZu4sT1/S8wboE94xyJsf6iuC9feeSnmrbJPNPZXuwRHteZsdeeuqvJFnYUdW6JohBidvjuO803Gc33Uc5/WO47x26M+bC+rzhVbLoOpJmQO2capG3paBTZsssa4RAPbcsVraJDAOicrKIaBTVW0FiJMcaV7gUaq88WwxAHl4yZvntJ02eaJ2KgzpvrPwcNll+HK8UVfe6O8rgtgmfbImxImxuWKVbbIkIZeR2eoo7dXjDtVNy4G6XWxjA2Kr6DKgPW9jVpTXuwR3Fl5l72Whsk1qKW+1go4IVdiDuTVj27JNmrRX0Xv80cuQE4BUrgkXTyX/Hjv1t8sDJFWM6LUY2z1Rf/BFARw6KFgXT+WOCgh9T/hgTJU3rpKqpLxpnrPquB8tCVZHdUyGrlZUej32G/0B4irvLULAVt7qFtjLKBjVoSBEuifH2pW8xelZ9rsB4ylvn1sUxacVRfEZI33e5DjOF/KNV9n7YhMnarbJyK+Goj7soFVygLHR5DkhIHTOGzDOBkwfutq2SZMLfkccq+RkMxAqb8Bpg3T5+5chmb91aM8BSiSjAtIMUeCRAoTOd68o9DZnQOtaE9skUePzArh/MLMusMib2Z43UvAJA06/UVI+aA00O6wraI+hDHcXPhxn3J6369sE9yQPDkflTdc2OZHyVn7XPuoqguuYtU1SAvvUywhZXiA5WROobZIqbyPdh/U1gz5055ze6DbaYx1GHzVTJ2/Q+2x67BdP47ofZHY0YdqkSmAJoO84qUfm0+ulijwvWxVUyZvmtdzXigDZgUmKO4MGe4hAlc7W9YyrmX2lbXKfIjNUeOwFen47BpZsy2LqOcLaJgdCW3mbU++Ysm3SKm8VmklnrY0mK0mIH45rm6w2/prlpsi0erCGwvFBS6Hnrf3n8vdD362lkbVerxBYEgV0Jo3Gd+9wn5xDFdtZda3VNoyiKMrNIqiKJ6YI1jGwhHyvLww3lW/Lgk/ke/xRAdWcq3movwAhD5cKm7PrOrgIOwzE7oF1qWaK0Ok+oT0gMgR3SLCJ4cCSwHOwpIWTgWyTgGBNuBiZvCU7IE+aJEi1oEOPcTLb5KZF3jSDP4K7QHghVN5E4K7vQLmmKJA3XcdJVfTsopSWSZVDKG951iRvgNl7WMVRUilvrf24XPOpbRIYtz+Yi/a17Jj+fI4Yg7wVAF7uOM7rHMf5uhE+bxbY1JrR59Y7tonTKl1NhJXhUIVzxvXuUP35ZFA3XegaPW9jKG80ErxWtR3rsyWg982jop63JAZQWmoY0cRR4CGkm3ubMNT7IThz3iLf07+HVQaZUmiqrPcPGfKCqvEdFBUBbvYJfPfYeH0ZmrW20IJPGLh823AQHYMPZqD+AurKG0BU3nEDSw7CGW8AsAw8+K7TLbBEBu+3m5EAACAASURBVMcxrpTWe0hM73ubXYqF51YPWydrSkXeqG1yJPLWVnJ0PruyTdbcE9nB6OB0LtqKIaBJ3sqkSn9JCpitfrl9mgsHdANH5Y1vm1ToeQuvutkmw5X+/a86Q5H+jjYxxDDkLUuJJVY5sOS0mAoch3QDMyFv1PJKk16TWyA9iF9Tw0axhWiOGIO8/bmiKJ4P4AsB/A3HcT6n/kPHcb7OcZzXOo7z2scff3yEwxkH1eT2KhZ8Bjc6gDTLcbNXT5s86A6IfUDR6Hk7eWioKW9Vz9sIDw5xW3kbOSxFAGqXEpK3ND5uJq3NIk4yhL7L39zTGFiWFhCOZScMXPLd07Fu6ZA3zf7G+kDQYy+TOeXtIvKr/pILg7bJvBx7QnreXEG4QGmbzBOmlXUK6FRWL6Ng9FEBorASAIQE6SpYqj1vgHnyVushMb3vUbt/FHDWBHrPXZRpk2dB3jhr+BjqdeUy6KG8RVdk3wOYa3gkUd6OaZOCNUWGLrbJcAW4Xg/yNoDy1riPOg755qFODEXgzHmLG0O6xx+rwgXru6cTILZLlJwZc8Tg5K0oiveV//4ggJ8D8Jmtn/9wURSfURTFZzz66KNDH85ooA9qF5FfVSCZEfMjg1ZLVKoNl4bVgXNGs+eNY9cZO22SVbWt//2EOOl5Y9pi9sDySeTPrUHdtGrL7YlIbss4dJeZVknI31jKmyJ5ayXQAubmP27jpj3QZM/bzSFFUZAe2Cjw+OmflLwBs+l706msXkTjKm+k540/441Cq2e6KNCY/SjDIMobuQ/NK29E1aNWO+46fPdRAM6ZkDeee2KE/aPPcdPfja5qs8EY1neJ8lalTbbXlDwjRSBV2+Rhq56UWe9pni15M7yOqiqGgmsJAFFdeZuDINHznJGCkFXeTuA4zl3HcS7pnwH8eQBvGvIz54JNnOAy9OG5pHKa5sWp3W6K46qCVFRsk3TG0Ay+pBNDWXnzQ8ANxg0sCelGNKLqJ0HV87bipE0WBSFdHPVsX9oejw9q7Sp7aanxl0yLEbVdksCSgcjb4hKAo3yt6wNBqfJtqjCyjdOq341+hqnKaKUYlsobd0h3sJwVedNxGQDmQ15kWO8SXElskwD0lLd0X/ZfTaW8HR+GTNvuN3GKyzLxFGA88NMHzsUdfctaH1Rrxj39+z9uKSJjFv/6Kj2V8sbvkxIN6AbqaZMcIq465w1QT8ocm7ypFu1HIW9dbZNH5Y0m885iXADznKmlh+7TDHGS28ASDp4G4NWO47wBwG8DeFlRFL808GfOAjRVDqglhs2ABB2DVFRsk1Z5o1jvkirSW9jz5jjjJYaxmt2Bedgmy4X9ahkg8JzTPqk8JQOu6UMDYyioUHlLy563IDqxeOR5gUNKAktWkY/tPlWP5K8/iMngulqWnSMJ8gdQ3hJc1L7TNBHMhNpfJ52hz1HekvkpbzouA4DaJsdZo+Mkwz7NpbZJQFPBaqcXyjBQzxsAfcuy0nvXbZOctEl/5NRTo7ZJ/fEjnVE/7rBD4a+tvLWtdmXirwghT3mrrqVKz5um1ZRF3roQLBl0LeQ9iIjWe4sQcNImW6MCgJk8F/b47tG13ipvDBRF8faiKJ5X/vNJRVG8ZMjPmxPIMN7SPmK4yt4H9Sq6DKYfMM8Z612Cp684sfd15Q0YLzFszrbJXVKlRTJng1HCW9kmTyt9oe/xq+w0mt5fCpqrifJWFMT6pwSdzRkor7Wi8lZLoKVrg6meIDK7sWmbzAvg9tBf7T/aPcmDMzsZjva8Ge7V6AEdlwFACO9Y5G1dC7SSQat3rG3Dk2GQnreabdJw2uSqrrydrCnlQ/Lo5K0emtCBvPlLwCvvgzFDp+prnecDiwujPW9qyhtnSDe9lirKm+45o0ErQEmw0hPbPv+1muSt/hqd955MeaPXsh0glsFzHQTe3AJL1oDrk+RczXNW70E/R9hRAQOh3ig/JxJUf4CU4Wpp9gHznHF9m+BpPAtgRd7KjWasQav7DVm4qs8dsWorQd0+FQUMq13SIm+MoaBR4B57Inhpk37Iba4mypvmd6+eRKaCcKU8KqBeOPE9F3cXnrE14WafVnYWAJUKZ4KM1Dc57pDu+pw3YB7kTcNlQH9vrCZ82kMrS5sENJU3nTQ8YGDlLcDtITudx9b5vdOy561U3nhqTVAWEcZW3sJVuW5o9Nu1+xPHdE+0H+h17oV6UiVnNtg+zaq0YB4cx8HCZyTY1lVUGXTPWVt5o3+n+lpgmDmK9esRRIAXTkDeONeyRsQvDe4tvUGvJU3OpX+ngCpUUNFWPzdY8jYQ6o3yc7If1oeHyzAn0jk1rm8PeBpV3k56LUry5pVVq7FmXdFhvGXC4KgDwiUgD1rkHmNa7Srljfa8nVpuhMpbuiMWj+C0561qrg68o+qtat+Kr0kVz5cHSQDQs022BmmbnIO1jZPG+A/655t9//evW2BDn6e87Y9z3gBzdp8e0HEZAER526c5Dqz/P8OgyptSYInOfdK24cnQIV6bB2oFPRYtzT7kHdMmOeND0prVbmzbpB+RB27XJWuyTmBJnWjT/uWxlTf6b9Xv7eGmtL1fcWeDxQrKG0BCMPjXUoW8dZit14e80aRKGTqRN6fspYbZe1iVvLku4C1Or2WaVddyGXjwXGc+gSUdr6VV3iyYIMobtY/MJ/ijnngnw5xI55TIyqh0vm2SbjR12+QYm++mufG7Hln4Z9Hz1lTeuGplZZs8Vd5C3631RDCUu2BJNveTfjmG8qZ6D9c3AxVE6irrZpfgzsJD4JH/J6Ko9F8TiqLAzf40bRIwo5o3lLfA49smg6hb78xA0HEZABjVDnR9S8iSim3yMvQRJzm717CNLrZJwMiaUfWQ1IoTgJniX5xkOKR5M22SVxDyw/HJW33N0Pns9liHKXreqqRLjeOuk4Fq3ubprE7ZkG4A7DWlCixR6Xmj50zh2PMcjWHVXQiW6v6gayGP12Q/cd3jsRklbzViKAKrFSHJq++d4zilxXwGz4X167G4CziehvKmV9ybGyx5Gwj14bBzavDc7BI4DnCxkCtvoe9i4bmzIJ1TYhsnKApUytvuIKkSaljpemHPiATXnXkzEOr2qShg9byVG30VWHLatxYFgrRJ2mMVLE+bq2kyVtnzRo9HCbrkLVxpjQpYNdQx38iasE9zJFnRCCy5NJgIRo/xIvLLtElBYEkQkX/PgbxpuAwAjDq/qFLeFNMmAcVrWaUXapI3A9eL3ieXA+x79QctfmDJrhYaNTJ5qxMwnaTLtm3SX5D/hzH2j7bLQEcxbJC3smjJSgyWjAoAUM6O5MzsUx0VAKitw4ctgKJJWIGByFsXVa9eBDCYmNomhiIwWhEIET++duxkXi7q370qLE5VedMLtJobLHkbAHlOKuG0Ajknj/AmTnEZ+nBdR/q7ZECsmQfMcwZ90Hry3QU7OZEVWDKabbK1kUTqZGJIbGvDekNWT4NEeWsP6eYrbyEzqRJoK2+qgQ8bTfKmEViya8bWm7JNth+a6382YW3Z7Eg/nec6CGWBJcC4D84C6FZWTfYJyrDWCY6qrL8K90pX5c3A9dq2ekhM2ibrqt4xXp6hvNXvwcOWzAsbGu01Q0t5254S7bF6pvsoho3+LM5ssERNeYtEypuSbVIjsIRlFa3/vcrrtcmbohWVeT0M7eU6xx1EzIHr9Wt5EZIU58nR4x6uB3GdIyx5GwDVUNvlUXkIfXcWvWO6QwlND1o9R9BwgatlgEiUnFg9OJSb79BD2VnDeMdKupSAqExkUYwCj9/TEJUN/pxKH7O/pShIn05lm2z1vFHbpO/pPfgC3WyTyj1vzb40reHLAlCCdskMLDFDDqtr6Xs4pHlzBEGWksQ2+hA3G/KWKrsMgHGLbOtdAtdpXjMetAoQ2j1vBpW3Vg+JSdtkvX8x4lqpd817EBgv+MOUbRIYr/jHOm7l0I/afDrGbLA8L3DI1HreSB8tR3lTSZtc3AUcV+2c9SVve439QXdmX9yjCCB9b43j5iQ411VUk3NEe6EPedsl8F0HS0mozlxhydsAYDVCmgwn6AOa2KWKy2Xw0KdN1i1O0cJjDBRtK28roMjU44e7Yt/qeaOfPXFgSVEU2OzSiqhEgSdIE6OhIyzLjVdt/g3CnB0AFDXbZDvspBwVUBsoqtXzpqpaAOR30x2Qyd+/ToIAc2vCthWEUv+zif6tenIuswfxpHgxE/K2S3Ch6DIAUA05H6fnjZxTlWPTIkHxuhk9L0NkrkexrXSa7Jne1JS3iKu87ZvWdWCc+7AXeduerjcafbS9wDtulaIjS3mrrcOH7BgaJQOxYvP2VIWeN8dRd0C0yZvufaKrYOlYyPvcR0rvrTC7FChnp7JH91BcRv58RgX0UN5WywCOo7Y/zA2WvA0AVq+FqSp7X9Tnz6lgzPjsueK6NpOJhG9IlLexUh9ZVduxBoQLsE9zHLK8uv+ZowLq4QJ+c9B2URRVUpnvOnCdFlmoqrJUeTu1eADkocD3XL35XV163gCla123kgK0etl/kDbdROuqHlWbTBRetrXk3OOMLQl5m436q1GoMqhWyrDeJbin6IBYRRo9bywbnghGlbdmD4nJoK56QdR1HSw81prSsu4C05E3lZ61PBfYJsew3TOUniInSZIysHreautwfQ2WgdgmOT3RKsoboH7O6oohfX9dgqVb3JsDedNpB2CGgOVV4Q4gzo7J24CyhBTI66RUw2rano16brDkbQCwUs7mo7xp2iaX1jZZDdS9Q2yTO9mQ7urBYcANuChma5tsK8/CId1+RJrmaxs/rdqGgQfHcU4398ZrGcpblTbplcfhq93D9dlFqtBQLuohLgAp7mR50XuQNiUb9TlvrmsuEYxGtANgz9hqW5xmo7ylWmvdmLbJ612ilDQJ1HreVK4lq6AjwgCBJfR47y58uI75wBIA7OAcOmsQGI+8sdYM+gCZS0ZOVOEZE4VOsY6b/r3KawFyrzFmg+0r94OqbZIzB1Sl540eRxfbJP1zl6RKFej2EbaPK9ufqGCdoGWbZClv+YnyNjl5axNx+mcN2+TlmYaVAJa8DQLWfKG59I7Vq+gqWEXWNrmuxXqzkxNjMuPtZN7agBtwsiPWzBnaJtsPWhEr5KKKgi4TCmsErNr4y6rtia2G2lGrwBLenDc6VFSxcJLckt4t3cASQHrOi6Igsx8barwZW1l7fhzFZeSbCSypKVhi5a18iNOpNg+Itk1VhguDVlMZ1rsEV3fUZglqzdvcb9X73QBgcVH2C5npeav3kLiuQ757RnremqoeN17eb/W8DX0fpjGxcZ+QoKIkZwLwwmWiq+lsk/Tvpa+tJVV6AbmHagU4uj5EKqMCmMU9jbRJQD2oqw95o2R7CPKW52wlFDBzD2vZPdltDA3lLQymn/NGg2Aa5+yehm0yPduwEsCSt0Fw9Oe3lbfpSVB9/pwKVktF1eIBxnqXYBmQgdHLgNPzVt9kdBuVu4AXTBCuCAlR6MEaCuvdsT8FUFDe/KZ6VlluyofAkyHftCoYLMvm6l2jT2PfVt6WipZl1UGmdShe69tDhiwvTtYEoL+t7IZD3rTsogLUFaxj+idDCW0rb0MH9kig6zIIfQ8L3x3FIbG+PSgrb3cWZCiu0nG1Zz/KYDBWn9VDQtKKzRQQAs+pCjJc+/rYyhuPDKh8dsxbw0dwT/AUQ0BdeaO/7zgnIRfVuBYF5Y1d3CsLcipz3gD1c9aebQeo3/9d9gfV995vcEIMdefE8ZBnHWyTjDlvLeXtkOXssTFjgffdS+6r9aDv9Gz1c4MlbwPgqLy1e96mJUF02LSu8rZPJ/6STozr26PFKQxYsffx0TIJ1Kx0Q5I3WrVljAqo/3wCnCpvjLTJpNbzFjQ99vR3KVE42dyrquzy+LBWU9+OowKobVJReetE3tSG6rJi600pb5SgXYQM5a2nipTnBbat5FAALSW0pbxFV0SNSA3YfXpA12UAkPTHMSrK1xo9b47jqPdMs2Y/ymCKvO1Oe0hMOU7ogxYlhtwQpLGVtz7kja7RPPeEzHbZByyXQVfyBpy6J6o1XE15O90fdoAbAK5iEqCq4yRek0HVXu0+nQN563MfyVAVehWLOkzbZFN5MxmI1RnCcyZ/9tLtiZ4bLHkbABtGDwrteesbTtAH9KFEb1TAfGbUTYX1LqmG6UaBh127R+lEeRshsIQ3jHcM1U+C0543F4csR5bX7v261a61WRxtj0flrVE8SGpKD31YSxnKXUn+lPtNu27OgPRaswaCao8x4OBmn+DOwoPvNZfzSwNxzvcPKfICEuWNkul2z+e01kldlwEwTi9HnhfYaPS8ARr3MGv2owyGlbc6lAsn0vdu9i+yEwp3zcRfOCOSt1ZoQv1nPFQP1awCXKEWHNIVfclCm7y11Bq6PigN6eYVRFVVN0C9T5BlH3zQyZvucQengSX75HRINzDxc6HwnMln67Xnrp4bLHkbAHSobf1hahUFSLLidMMZ87iqIBUd26S5uOdzxXXNfsUdKFpX3kaxTVL7B8NyA0yaOFnZhpdNtebQUM/2ABzSLxHcEZKvk8HQdeWtSjo7Km/7NIfnOgjK75+yasF6EJNB8VqzBoKaVN7aqhtgJhGsbQGv5u6lDOWtPWNrQvLWxWUAmCG8Mmz3hBDTgpAKlBUsXdskYFB5O61kK1uWld77eI8zEwqT2gO/647Te9nLNilZw4fcP5j2QQ2bnoS8xRrKG9uZsWvuqdI3Ue15u56GvMmK9j2JiPZ7i+AvT/rI43J0DwUdqzJpEnmP794hzbFLMqu8WTTBapTXSgwbCGtGkIoMWs3yDyg2NYtTxEo54ylvo9gmGaMC6j+fAG3lrUooTFpqjR+RfomArbxVtsm2raY+KoAxYyhOMkS1KuFqSR7I87zDBiqD4oMWb/Yj+Vm/h9ttnDLHf6wiH9uetpa2BZw5d+9kVIChXo0e6OIyAIhbYmgrECvQSgal3rE8J6EKU9kmGQEA5pS3pqrHHT9SX4fHSD0dyjZZ//kQYB63xsyzE9vksrWGq48KoEO6G66kdK824616k1Vp1d6Lf0+kvHUhWDKoWsjnprzV9tMsL5BkReNaVuFOs1XexOdsy2hjODdY8jYAWI3ycyBBrBEGMhxJ58Nrm6z3vC0XnPCNepXQ9UiK2xi2ySmqthJs4gQL360qdVWfVMNqtz/2q7UCS46Wm9I22bbVNAJLaM9bs1m+XiVcRQHyglgAheiyOQcR4C069bxdRmZsk9t9igvGd9rEqIATC6xoSPeMlLcuLgNgHNvk9S05NtWeN0BReTtwCjoyDKq8me15o4h4IUh1q90o5I2VeKdrm2SETgHDFv9YLgMvAIK7PZS308Rg1SHdeQEkWZ287dRnvAHq54xH3vLkZOQM87X091Whq8LOgbz5ETkfOfl+HdJTFbXau6Ymb44HLO4e/07xnLXdQecIS94GAGsQ9vFmn5C8MYaHyzAH0jk12j1v0rRJoGygHvDBgVu1VevBGhIkuKDZnwK0Qi7qVXJJYEnou61o+lqMNFN5a/rzlQsQ1San+fCrkHS2aSVwAkDguVgGngHbJDsS/zIKECc5kqy7VXvTUrBo4tieNedtRj1vXVwGwDjDZ6u5kZoz6KT3Ca+gI4NGvLYIvH3v/iFD2uMeJO/dVPXCgDXnrWW1G1V5q60ZoaKCtd+SiP3FRfPvx3BP8B7oo5XcpsdKqmz1LesO6Qbaa0p8uqcK30SxVSFe85VOZZvrAHMUWfeRH5HQlinIG1Ct68e5qbWet9I2OXlgSbQ6jmgClK8lywlzbrDkbQCwUs6OvWPT3ezbTsrbw93ztk8z7JKsetCKfBe7pG3xiE/9+eHlsJsvL0FKx/oyELZxMyjimFDY3pzLc+bzLDdUeRONCjjteYuTU+UNUChAxOtmH50qFJLO6Ge3h4Ka6Am64dgmLw1YW47HXdomAw4RBxhJfz17NXpgG58GxKhgNULP2/WOzI28pzjnDaDKm+Q68go6MlTx2t3vk0OaI07y030vMvOQt41PlbeG+pslZO6l31beBnYgxBuivNeJhuuRREOVUQHhZfPhE6jZJgdcw7nkTYHwHu6XM0ZbaZMpw/quOKS7/hoAR1u9KlQdJzzljf5M9tp2UqUMqhZyFjGkYzz6umi0bZM0BIzsqXuB8jZ5z1vHa8lywpwbLHkbALzULWBq22SXtEkzfTnniqpKXj5ohazABpbyFq0Gtr1siMWlHaU8C9tks3gR8ax29EErWHIsN5Ih3T47bXKf5tV1Auq9ZQrkTccSQ6FwrTcxmRW4aFWiTfQEcQNLwv6JYG2r9XFIt2TOGzAP22SHtMmbfTpoKnAX5W21DLBLsmboTxu6keAUVWJq9zWD10Nioq9zn2aEGNbTJtsOiPY9CIynvEVXpwRM5bP3G/a1GqNnurJ7MgaEd7H4tdMmqVqjOCoAaPfR7s3bJlmDsAE9gqW7P+gQw3B1up+buIfjNQBHb1QAUO2prP7Fi7mkTbavx+KCqNlS5a1bcW9OsORtADDn3cygd2yzS+A4ZJaRKqLAReApDoh9ALFu9adUFo8TC2BbeVNMv+qKPSdVjlotJg4sqStBEW9zpucsWJKZQ+VgTfaQbk6PFd3gW5adusXjmOqoYJvUVS0AReWNHUusHAEvwDZOThQ94Kjybffd359ucvR6Mol40gosCSLAC6clbx1tMRehj7wgQ9WHQtXzppU2qVDp5oUYyVA9+HZXSnk9JCsD7QL0AbGxprSHdLfvQaAsqoxE3tpQIm9b9rUayzbJchmoqJWsIkHQ7FuOdZQ35pqy0wssUTlnhxugyPlqTRfVTnpcGv2PXe8jGSpiqPi47zf31PbcVIBY/qPAnYFtsnXOFFNmuxb35gRL3gyjGmo7S+UtwcXCh+s68l8uQQbEmmk6P0e0q+RLXvjGSc/bCLZJVm+L46jPvBkIbeU5FKVNAice+0p5awzpbvVYeQtSpWQpb7yet6GUNwWivuEQLOUxBhxkeYH7h4ypvJmYxbOJE9ytzZBbeCzbJGOg7hiqhwDtEQeqqAjvgEW2za4Z6KMCJdt9155NA0opjywrq96a7x36rSHd9T5YCmo5G3LYdR/yFq/Za3hwF4Az/KiAPsdNf5fCD1vKm96Q7vprAJThM4ZtkyKraP3notdrf7c0+umGJG+6IVyAUHkDxhmrIkSPc8ZrYzgnWPJmGNVQ29ZNEZWWqakDS7p4fIk68HDaJttVcqo8NAZ1s5S3oW2TvKot/exZBZZQ5a1lNaWbROWxp5U+hvJ2onSWr2H1vDHSJgEFf35n8iYny6QP1rzyRiufQ/a81dcM33Phu85pD2J7oO7U5K3cnC800yarCOweaqUM17eJVtIkoHgP89ILZTBB3ni2SQOzDFmqXhS4SLICGR3/0Z41CJT/X8V8SdB+yyYDVD0YWnnrTd5qSZWMxODAc+ApFIqr4l67QKfV86YQ1EXvAy55kyjPQ9sm50LefE7PW0tFvQyHD3cSQnTOJN/5bZzCdYC7C/UC2txgyZthiCJIlZrOBwQrDUwFq6h/5Pi54rqlvHFj75lpkwOPCuBVAYe2bEqw4QSWNB74G2mTzcRIVtrkIcuPc9qS3SnxS5rKW9Ql1rhPz5uC8sYqnJCAjO5rAiVvLIXJhG2SFb50Mqi+PV8LGCcsQoBNnOAy9JUeHusYIwJ7vUu0+t0Axd6xrrZJI8ob+z48qt79Q3OafbStNaU9axAYp/eyF3nj9LwB4/RMi45b1PPJUrCCqBUalSupbsDRVr9vF/e6BJaIzpkR5U1zf/DpKBnZezOGh9Nj603eONeah6DphDmmTTav5xhjVYTYb5oFBAoV5a3cj512r+oZwZI3wxD1WpBBq1Mqb+wHSBlMzeo5R1Db5L0lCSyJeGl7rJ63ngluQvBsk/SzJ3pwjstQBWZgSdLqk2rbJssHsH2aw3MdBB61TZJN40DjxpPdkbRx57wdlzbfc3Fn4Q1omywtsoIHHtYMLICmTSadAzJoUYWlMJkKLGkXosL2oHqWxWly5a2jy2CERvzr3UGr3w2o90wL7uF4U0bP3+X/DgtGlbd2r7cJ5e1U1Yva40d4gSXAfMlbLFrD5eNHekF03EVGEiVFr6W/S+GXoVPlOrZPM6UxAQBHeUt3p2q+CH6Z+ClK6OSRN9Ue3S77A02MPCvlrbUft4qpFJPaJrOU9DD2sE2ec1gJYMmbcVTkjVNlnzptsssNSxLxHk7b5Pr2QEJeqsCGVvhGUQAZJ20SGG4DnqltkvmgxVQrWcobSZGMk+bGf5wTR6vstWZ25py37KTqK011ZM0uUkW4kj7wtOdU1Y8rzQvs2jOrFMEKc6Aw1fPWXjNC32WEC7DSVqdNm+ziMrig84sGVd5SfeVNpWeaFnR0q8kD9rxdLHw4Tt+et1NV72QdTjg9b8B05E3Wb8ezTQLDuydEx01/zn0tI6myZV+Pk1y5p7MaFcAr7qlC5nYRRebLHvh5SZUq6Eve0rgRyKWNruSt1YPe3lMvQn+6wBKeBRaAytxK3n58TrDkzTBEjfJT944R5U3/hr2M/IdaeVtFQRXycvLQQK0irDlvwHAkKhZYbsLLYWcECcAaRn1CvoBm2mQr3WqfNgNHTtLIkprS4y0AOCeWnajlz5fOU0t2QJ50t00C3GtdFIVAeesXpU5JBiuwJPRJUmwv8sZQsNRtk9P2vHVR3saYX7S+PeBqqT7jDVBUsPbbY++PDhTjtUXYxAk818GdVg+J6zq4DP1e+x5L1TtZE9qzBoHhyVsSk8IdV8HKiTrAQronrxUpb4PaJjnhG0rkjZFUGTSDo3SUtxMLbJ6zC6IyyM4Zq1evOgjJesVLqlSBCjEU2ViBfkReN2ilNeeNNaQbmNg2WRUQrPJmYQhH5Y1VZfexnThtspPyZiDO/Fxx3epPBcuXPAAAIABJREFUOYm9Z/VaALVBqwNswHlGLJnCqu38lLd9O6EwaKlntY2/XrVlnnP6kOY45YyhZrN8u+orVd50B5nWIbnWuyRDmhdcNR7obiujr2OlZjmOg8so6BW+QdaM5lq2aNsmE4bFaWry1tFlcAwsmVfP292FB9eRkHyRDU8ExXhtEeh4HFYPSV/b/WaXwHedKukXYKwJVHkb0zYpU3JEn131J3LWmyHdEyKXgSp5a7+2stodQy7aMy15OFHeWBZYFcjOGWsQdvVayXrVZ3+QEsMtgIKvItU/XxddFMOTOW8c5S3yB3UoCCH77h1uhC0rXZ+F5wRL3gyjPdS2jilJUJ4XuNl37wOJk7wZOPGQYL1LGv0pJz1vUyhvsmG8tNl9wEHDPLDsU4HnwnMdRshLbc4b0JgrI1bebpsbexBVry2Kgry+Td5k3z0j5I19rUUDQZXHGHBwDCxhK+p9qqOVYthaM8IT5Y1lG74i1fM+dp8e6OoyuFgMG1iSZDnuHzLtnjfHceT3MG/2owp6km1eIA/QfxA9K1yA74CYgrxxlBzRZ8vGOgxpmxS5DLqSt5Z9nczaVLVN8sJnNHreAHmfYLwmKrPHWBemJG99igAy7DfgEkMeTvZj/qiAm0N6DBIbEyrnTHAv8OaunhMseTOM9lDbOmjaZNdwgj7Y7lMUBf8hTwS6KU+aLDQRrm9bylv7oSHjkLdqvssAGzB9T5HlpsiqHrIxQR96r1oLY+S7R8JbFE2rnc+y3Bw3/pM5QEkMBHeOb06b5VGvErZsk7J5ar3IG006Y2+wooGgfZU3+p3kReJf9Ihzvn/I2GNP/NaA5JTV8zZCv5EAXSurruuU52yYIlsVgKRJ3gCFnmlRiJEMfcmbwIYktSxL3/t0zEZ4UkRj9LxVw8fnqLwprOFD2SaFx62g9DCVN9rzxra+ixDxLLC6ypssqIuX6AicAXmTjDHo8t48VNeyNXf1xM3ioyiAm8MEz4U9z5lV3ixO0B5qW8dq6eOQ5c2q9VjHJQhSkWEOA8anwqZlcVqqVHyB2tyZATZgqvCIqrb13xsRvOCCMPD45yw4bZCu++ujdhpZmyzUlDdK8E42GhXVAmBX0WWQhNOIE2j79bxty16jJafKfdnD2sKzgIeBhzhthQucpE32tPv0QB+XAdDvnMlA50bq2iaBsvdYOKRb0AcrQ2/ljV/JNqW81VHNjqRrAmvOm+v1toMKYcQ2KXBPZPtGL68x9FV6mOStNe4lPXU/8BDyLLC6PW/Rldw2ebbkreM93Im8NZU3qoi2bbC0z3oS66TwnImLNkmW4/aQdd4f5gJL3gxjGyfcqe2XPavsfbAVBKnIcIypfgiVt3bPW7kh7dr+fK5tcgjyJqvaDqj6SVDdZ+2Qi3pCYbtP0D+13MiVt9rG7ke1ii+7uZqqFlzVe0jbJGeAMVCfK9bRNhmnuAjZvUYASU803U8XMpU3Rs8bMAl5uzl0dxkAwzbiU+WtC3mTK2+C9EIZes7l28YJLkP+vtfnfLJnDbb7pDgP/AoDezuDhkIxe6gkqp/UPTFgAU601qmolUzbZKvnLcmqcQ4yBJ4Dx2GFz3QILJHZJoWtBoL5dn3Jm8hCLuzF67mXdzluzwdcv7oOcZIzB65Xc0SnJG+8/sX677RwfBa2tkmLGkReWnqzTDGoW2TdkuFhVd6KojjpeTuNrecob0PaJlWa3eu/NyI2cYKF555YZiKm8tbqeatbbmrkq2poTxmjAoAGeaM2qqg9KmDpIy+IFZAJUXqVDJIBsawEToqKvHX8bm3jVBiJv4q6xznzevWiwMOh3fPGmvMGTELe+rgMgGEjsNe7A4CO5E02J7SXbVIery2CcN9b9ksrZvUvng7p5q3DAwbn9LEfKrsnhrDdC3r1/AVZW0U2PZHyluorb47jIPI9hm1St+etDCzhjWeQKW/ZoTEv9OS1QEdnhmr/40yUN6BsRTgWRNv7KVAPd5rguTBelzMtL05/JjlnffeHucCSN8MQeWlNDCztCpF1S4Ypj3tK3OxTZHnReNByXYek7Z00V7eUNz8i1atBKqfU4ifb+Kd5cL5kpM4R22SrSt5Om6xZH+vK27HPkDGkm76eNleX1yVkKG/0+JgQVfJkkITTiJS30PcQBW5nVXu7T7lKP9BPReLaJk/SJjmjAoDuvRo9ICLLKhhy+Oyx501vVABw7JlmIt2Th8/OtsmeaZOifS8KsC3X0q7v3Vb1mHPevAVJzqxjKtukTMGq3BOSAtwgPdOSB3oR4a2SKlv3Gd3/qjVcfVQAQNbr47Xsobyh4I9nkJE3+ju81wLdvl8yIi+6HsEd8hwxOnkLWxbY02t5dI1MpLyFq9PvOyAnb4JQwXOCJW+GIUvdAqZRsETz52Q4HvfDZZusHrRaM5mWgXcaa9zeaBxnuMSwyq4jaHYHJrFNkt4XFklxGVXycsP3AsDxjkO604yvvNGwk6CtvB0tlwBLeZMUIOI14IX6TfIA6a1ZXEh73ngKmdQOJwCxq/FJykWpvHUJSeJtcidDumcWWNJ3c74Y0DbZp+dN2LdZ2fB62CYPW2G8Ng+yHhL69917L09VvaMDorYOs9IJo6vhCgjxGnADtkLk+WRN6GybHNB2L3MZiKymyQ7IU37aJF2H09NZmyJEvie3wErfRKJWCskbJVic1+43QHCXnVQpg0xFFX13HaefetyVvAXLmpslOxkTAByLY5PZJjsScVGo4DnBkjfDYCVjUVxN2Dsmmj8nw7Hn7eFS3uiD1umQYpdvAWz8oiT9qitUmt3rvzciSOrc6T0WBa6Y8NY2i71oVADrtX7UmC9EPu90zhs5Ps53T7QZqECQdLaJU0SBy9wAgX4jRGS2ycsoQJYX2CX6Yz549pLGkO48I4oPa84bcJa2yVXkYzuYbZISy2729dtDhiRj2ML2EjVehh7DgGU9JKsefZ2HNMcuyZjWXaBmm0x27MLL0LbJ6Io8YLMg+uz9hqxbPkeBHaPnjbt/CI6bRwbac944D/w8hEGtuJf0SJsE2OesKMAdhA0oKG+CpEoZZC6EeA0sLvnE0AR50y3qNPrI2crbRdivKNMLov16cQnAkStv1jZpUcd8lTfymReCKj0Py8CD7zoPXc/bprI4nT447GRDuoGygXog26Tj8XsChqzaSsC7/6PAO02GaxOwRtokZyBv0rJcAmXaZEt5a9smZfPU+pK3iK+yimLUAYUxBgLc7FPumADg+H3vUh2lRaY2OWzYJnm9Rn5EbGyTKG/dXQbAsLbJ61uilLLSiGWg9zDzWspmP8rQg2zLyDL9+3WH/WPLedCKTpQ3xqxBYBzyxkN0xbeuy/oTh3RPxGtyrnjkqAt5Cxhpkzq2yfoomc5z3gRW08N9Mj6nj22yN3nr+N59yVu4Iu4QHbQSnFlE/LJS3ibqeeOdM9cV2sB5a8q5wZI3g6iG2s6y542k0nV5aKADYh+2OW/XnGS4yBeEb9QRDpR0RlPleBXfiUcFsO7/5jljKW93aspbxlfeWDHSft3iQee8sZW3La+5urfyxk86k4aKLLuTBbny1p28beMEdxYegtaaEfoe0rxAmnGUUOBo95migNDDZQAQwhsnOVvh6onNLsFVhxlvQO0eZt0rMhueDH3Im8Sm2meWYUXEW9fS91z4rlNbUxjWXeCYoskLseiDPg/d+62YaFdK6ABr+F6gQNHP1lbejnPe0ixHmhfKQ7oBqua39gdd5U3kOFHp8wPE6thg5E2i6vUhb7JrzUOtFYHMXT19bryz8OA6GCzcSQiRigocv/cM9O2JngsseTOIaqgt56Eh9F0sPHeytMk+N+sqkiSdPYDgDdQltkmFWGNZdHFX7CXznGgP1mQ9b6f3Wdg4Zwy1JohaVVvOqIBqY7/DfC1feRvBNikILBFV+cgcrI7KWywOLBE+8EtALOAsFZWc20NWI9NjW9YE6OMyAI6Edwg7UHv0iA6E97AsvVCGXsobezwIxVH17qD+CoK2GmoNa9YgUP5/FaSfzzT6kLd4I75WlXtigO+PKDIfUCRvrdTF2rgXaqnWVd4qK3bXOW+ic6ZM3h5A5a0reaspb6z+RcdxcBEO1x8sRLwWJ38KztkmTuA6wN2FJW8WJWSJjkTBmoYEkbjl7jLxatk9VOFcwQsXEMbeN35xwJ43mT1qKOIogUh5a0T9A6ez2pId8rzAIWtuFp7rIPAcYrtkkQWFnjdpJL8J5Y1b6ZPYJjtGqcdJhkOWC0nKMc65i23yNKIdaIVFiCxOQyb9CdDHZQDUhs8OUFFujx7RgbB3TDb7UQYTyptgSHf997q9N9uKzR0fUv3SgL2XvZQ3iW3SD0mA0lA9byrHzQo5EipvDpDuO5I3iTND6U0EtskpyVuwJME250TeguaoAF7/Yt8Zjp0hPWf80SckETuA63KcS2cCS94MQqURsk+yXB+IopxV0EcdOFesd2Rm2bJFBJrkTaS8DZQ2KavaDvnZAsRJhn2acx60ZMrbEkjrVdvmOQ9pGhmLLFCLR1FU16XdYB2U11GYNjlUzxsngZOCfLcEA8Q5UBk22sc2yVszwnpYhMjiNKHy1sdlcNmDbMhwfXswoLyJbJMDqQMCyIqWwuOWvje/fzFqjB9hzBoEZkzeFApwQxX/VI47T6v03+ZrOUmVjlOtw0f3g45t0u0/562PbVLWo9tnf5AlRg5K3joGrbRmp/KIOBlFM/LzbJYSJb3jOeO5g84NlrwZhGijobhcTkOCRENUVXAZ9Ru0eo5Y7w64uhOczCxjEhGP1fNWBpZ0iGkXYr+WV9gFStBQEJGJBuGtbDG1c1bOaqOV9NMh32UaGUt5CyKgyIEsOZI3VrTxkhMMUs0uGsg2yUngPB5XgCQrjveUIqgypBZY0tE2ySHiQKm8iWYyTUXe+roMBozAXu9SXC31Z7wBkp7pKoF2SuWNfc4vQx+O0y1lWaTqhUFt3mYi6HkDpiVvTAVLYn0HhnNPqBw3/T3WawH2sfthuYaXBTiNUQFhfUh3EpNALk/zOxzcBeCwz5mMvIkIlon9oS95S3fHZw0dyCyyPDQCxDIuEe8zR7QzqmTdjuRN4oQ5F1jyZhAqjfKriUiQGeXtYSNv7P6URnJiGrOHwwKkEpinR8JhCqpV25EDS8TDqElltSiKmvJWV8+aylt7syC2mnqP1Z3ma4HW60+vB/ceTmMSd9+XvCW3QNZ8/6IolHreAH2lhxKy9gDjOi6rnreuyhvLNllX3gT9KZMqb93XuouBet6KoiAFoR4jDABez9taHD0vgyReW4TNLi17SNgPeK5LemO6KW+injcP+7oDYkzylsTkM2UPkEXOHhpNQ6dEEBSEeqEveeMlVVbuCX4BjYdmgi3nWsrguvxzxuvVq4O3Xh1uyHUcgrzluUKAjGQGnQidbZOtUQEc5e0i9McPLFGZXSfpebPkzaIBleGwfWY69UH/nrfucebniuvbBPcY52zZ7nnjbTRVA7XhDXimtknhg1ZltatbH+vKG6n0HZWzdsKhyycLVdLZHnGSwXGABaPfifvdixUqeTJwLDsktbCQ9rwB+rayG06Ufx29RgVw1oxqaHpdeWNZnCZT3vq6DCTJpB2xSzIkWdG55+3uwofrCJS3rmMCAGm8tgi0ONF2KNTRtfi3iRN4roM7DGLYsNolMf8eBMzfh6rVf9Zn0wf2KWyTKiqSjLyJrIfpvnIQ6AzpDuuzI3kz+5TeiOM4qR74OwS1qJAFGfoQw673cJ7LUxl58FtDujnXcsixKlyokrfDllgsW+i7P8wFlrwZxFbhYWo1gcyc5wVu9vzh4SpYRQF2SYZDqmftOmdc3wqUt3raJCusBDj2n5gkUUVRPqgp2CZHVt62nFhv4KikNfvWWnH/AstNtbmzyELQTDqLfI/5IMmdp2Zic+bM1pOFOQDde6yoDU1km/RcB3cXnnZ1lCiG7DEE9FrGSSbu+YyuyM/pNRsJ231P5S0cRnnjBSCpQqhgxZIADBV0HO0gG1cBdLdXbWOyb7G+zyfjR4TKm2ESpFLwqQI0Wg/dhxsAhcIaPoDypuIy6EregiVZgwXWdR5C322pqJr9bhS83uP4mrg1RFZMXsDSkORNhVRWo380ydthC6DorrwlR+Ut4lzLi2hK5U3lnJ3eC1Z5szgB3VRl0d1j2ybvH9JyhEG/tElgooGME2HNmckUBm5tSLdAeaOLi8kHhzQG8kShasufczIURMpz1SdFQy5cH/BqD3wBaXbf06rtSWBJaathKm/ln9MYcZJxK7585U3BUiMDJ+lMFuZAftYtSn2roPQD3aqjt4cMWc5WDCvlra6iilSP0RVgcUCMDFUy6UDkjaXmq2LF65neK6jxMnRUSlV6SLqmFYscIycjW1j3II9A9YVq9Z/12apjHYZwT/Q5bvp3QuUt7pY2GbiI64ElnZU3HnlTsA9Oobz1vR4i9DluPwKyPZDnxDbJVd788TMcep6zvi60ucCSN4PYxAmWgYeFYNFaLQPs0/xYMRzluORBKjJU1q6HKHGS2/PmezikOfK8kChvbDWmF1SH8YaXQHKfaRsYCpR8sIoXlIwRAsYgvMEdIImrXsIT5Y3OAap63tjKW5zwY425hROVSp4MHNukUgKtKIhCgCqwRDLP7KKD6iGLaAfaQ9NZozJor8Z41sk8L7CNE6kSJEIUeFh4rnGHBJ0b2VV5AwT3cF/bJECcAl1tkzLy1jGtmKf+AowQJNY96PnlzEvT5I2Tutg4QB5501jDjSuGBsgb7z4rZ4N1Spss99SiKIji06XnDRDbJi15U0d5/pPDLbK84CpvqyjAIc2PIzvGQI9zlmY57h8yq7xZNKHipR0yyYyHoyLYzzZZf68HHUmW42af4h4jGa7x8CrseeNL951RVW0lCzL97CGG03IgS4YDcAwdaT9olTHT+wPbchNVtkkGeWv0vLEHitLj2sTpaSS/yoOYDDzbZJVAK7JSd/tubRVskwD53utaW0TJucc5b3Xb5MgztjioXAY9N2diBzK71q13BwBgqvmq4M4JNWWb7BhYIt33Os4yFKl6VUEnz4gbgWe1G6L30oTyJhvrQC2AJtOKVVwGIrVSFK4R9FPeALqncpJDVcAL6lIlb0zVzlBPdBqfJkb26Z2UoQ95K/fXfUz2W57yNpTFXIge3z2V1qZzweDkzXGcL3Ac5w8cx3mb4zjfMvTnTQmlCmTHKnsfHFMw+9smH5bEyU1VJT/9ki+D1sOrTHkzWT2lvneVZnfTny3BZpfAd52TuXjAUXkjoSP70wetMu7/cCBkoE3Aqp4IXr8cUCWd8Sq+qyhAlhe4PbSqhEZ63qhFUF9562rT25ZKfyAZRn3ZQfUQEnGfobwJZ2xda312H2wEfZc6GCIC25zyxrJNSuYeqaAreVNW3roFlvDeu1LeRPcgUP5/Gb4HlR4gOcpzRQYUbJMo2GmVXaFy3EFE1ldt2+SyRd50et5qPdG88BmlN+KMV1Alb6weXSPKGycxcu7K2+4+AP617DNHtDPiNQCnTMjlgHPOVPbjc8Gg5M1xHA/ADwD4QgCfCOA/dRznE4f8zCkhiwQHplGwjNgmq+N+OGyT9EHr3h2+8hanHAtg9YuCoaFdoTrPaaikSwFEqXPHkIucTXhLApbEZDDsyZDuuvLmR2QuDwV9aEtiMlCUR954BQiTgSXtzUKh5y0KPIS+q582uU+lqhtA5mzd6IahCI47qqrkGXvsQ/WL4ytvKudbBRehP1hgCWtNUQW3b3M/pfKmsO8tA9zsU2I113pvvqpXkTfRPQhMqLxxFCwd2yRgdg1XXetY50yWVNlKDNZJm2yuKX1skz2VN+CU/Ilm26mCtxaqKKGLu2Tu3QTkbb8n+zHvWlbK25ihJfGafLdY45koeORNwQlzLhhaeftMAG8riuLtRVEcAPwLAF868GdOhs1Onug4Re+Yyvw5GY7H/XAob9eCKjklIruDTHkbwDapVbU1/NkSiO7/6EStbPe8kQev7EDJW2tId115a7+2pryRnjeObZJXgIjXZFZf1wcGoEbU22mTajaNLiNERP1AdXRRkcQz++pEfFcO1GUcx5TkrWdldSjljaZ/dgWz5y3PzfS8UdtYrt6/otpDsop8FAWw1bXvCpS3KuQiFfRdAsORN9dvzptswwvI4GgueZvAPVFZxFUCr1rHLUuqPAks6aC8pZzinioqe+Kh+feyWWqAQCktkyq7zlAE5ORNdC+IBoiL0Ms2WSpvsUx5m8CRpUPErfLWGc8A8O7af7+n/LsHEvNV3vpXox+2nrfK4sToT4nq/VuiKqHrkc3bqPKmWrWdwDYpuP/DRmAJI02sJG/pgVb62spb+aCW3J4+MNH3SveI05xvm1xSiwdDeYuummqeLvwIcAOmbTL0XWnzPneMgQA3cYpLSVgJQKqj2uRNUKEM61VykcVpCvJmwGUAUKup2bXuekfmRormocmwWvq4f8iQZrWRLTR63kTaJKBV8BGNB6mjUr019o8ky3F7yIRryiHNUbD6YOsYiryprBmsz1YOnRqi+NdDeZO91o/KcS3s0CkRGn20ya6HbZJxzlRm2wFigmXCkgyc2nfjNQnUYRW/2q/vSt66FHXKgmi6L3veOAXRyWyTSj3/zsl3RzWh+RwwNHljrWwN34TjOF/nOM5rHcd57eOPPz7w4QwL1chkYOyet/5NmncWHjzXGX1G3VRYC2YyhSe2SUGVsOPgWy4q26Ri1XZM26Tg/o8aDekMq2n539merbyFvkeUt4RB/Oh7lTOGIpnyxiNvfeA4zKSzzS4Vjg6pjq2D8kZSFeXvfVnOaGw88Cu8N31tG40h3aJwgWBJCO3IfZeAgZ630Pz8Il56rQ7oPdw4NtWCjgwdyLZqYZD73ROgIoYSNf9QWq359vUByZsMrM/eb0F6di7Erx3KuaHiMuhC3oJlY0i3TmBJMwSsp20SaJ6z5BbIUw3yxiBYxsgbQ9Xreh/JEG9IX5iMGLJAlbc9u5hKQZ8pRw0s2W/ENlOAWCoZc/uqoqQd0i3FewA8s/bfHwPgffVfKIrih4ui+IyiKD7j0UcfHfhwhgMdaitPmxy/d2wTJ7i78OBLgg1EcByHqAMPiW2y6nljPGwt20OKRRsNr4G6K2JFy03XwZ49ILr/G4OdWWmTZaU1P7DTraLArW3srapsbc7bXqi8CWyTfTdngJl0RtRI+UbRJUpdZTgyUNtgNcjIJk65Y08cx8HCd4/FC16VvKvdpwdMuAyAgWyTt+y5kTpg3sOqBR0ZupC36mFIVrTUn2Uos8DSEKSKvImUt/2G2EtNoRd525BrJerZAQayTfZRDCX9WTQxOEmx8F0thfk4O5I6M3oElgDNc6ajNtZ/v/76wchbj/tIhj7HXRVTZcrbBPN/e5wza5tUx+8A+ATHcZ7jOM4CwNcCeOnAnzkJRENt64gCF4HnjJ42aeJm7Tpo9RxBwwVEc66OM8sEyhuvgbor9htiG5RV06YILBHFeldDuqnyxiZgFXk7GdLtIc0L5MmOa7k8znkTWzwGUd4AJlFXUeMBcp9tuwSWqNgmO1hbyJrBf2+S/skZ+1CHaeVZAhMuA4COCmCMleiBdWmb7IMV6x5WLejI0Et5Uyxaaux7MiJO1+GkUt4EPW9Fbj61sY/ypqKSDhVY0vW4VWyTRY70cOC6H3g42ibzfnPeWI6Th5a8Kap6LFDyximmUkwXWNKRvO0SOA5wsbDKmxBFUaQAvgHALwN4C4CfKori94b8zKmgyuiJgjUuCVKJclbBZeQ/NEO617sEF6HPjGFX7nkDyodXk6MCNmoPacGSNNTPrOdtzxuvUPaxFckOgefAc53W68k5Lw63AuVtjzjhjwqoyFv7u2eMvF2d2ibjVKlw0kXVJsqb2nvT31eFbM2o5u6xlNDGL46vvPV1GQCkopzlBXaJueGz17tDf9skq3esmhU1hfKmtu9ddeh5k6l6dE2g1i5h2iRg9j7sS4JUrtVQPW86x10vXkhtk+UDf3LLTfzlfhy1TSZpvzlvrHM2B/IW3Cn347GVt45rQhUgxi6mUix8F6Hvzq/nDeAob6RP3HV79LfPBIPPeSuK4t8URfHcoig+riiKlwz9eVNhq9Eov1oGo97sWwU7pwrGJp1TQvSgFfkt5c0TpFCFl4Yrp4qR4LQHa6S0yUOaI05yaX8Kt6eh3PiLZMfcKOjmXhwYzeyOA3hhOeeNP6Q79D1EgXtagFBJIlMBwza53SVKscRE1VZXevK8UB4VcBHqW1tIRDt/Lavm7rGU0DpGJm9bhdAoFQzRiL++TXqNCQA4CpZqeqEM1cNrl8AStZ43nfNZhQtIrNgpJW+iOW+A2bVQdc3g2iYV1vDFBQBnGNukDNEVGXxOw2CAWlKlQHkDkB9irX434KjsJPtyxppoTRG+UQ/bZNWjOwB541nItYiI5n1gwDaZl9dfNPahyxzRzsizXt89Uy60OWBw8vawQKdRfuzeMVPKW9dBq+eIjSBcYFlGfccHlZ63leGHhq16Nc20ZVOArUR5XnguHEeQNkmr5sktc6OolLeUQxaCCEVpmxQlOzILEEZtk6ceezXlLcAhy6uYbRluDurzarr1vIlJZ+i7/PCZOsZW3napkbWO2oFMkbcsL5RVWBGO6nHtuFTTC2UY0DZ5wbMsK723OAQpPdBRATNW3upFGdWxDq47QPFP47jp79dfW/9ZG2VRrUhiabpuG7RglxwkKqoMFVFn2SYlIRcsgqWaVKl6bJ3J2z0guQ9kGs9fBshbIVHeALImjWabrFwGKueMEVhi6Fl4DrDkzRDoRqOa/jaqbVJSRVfFaqkfZ36uuL7lk7eqUf5Ah8NKet6msE0C5i2bAsgi2h3HQeTXhupylDckMXOjqDz3Ccem5y+RH2LkhTjl7CTVMYkJmTRC3ppkuSgKZTLBtXQmjJYFAAAgAElEQVRyQEmFTmCJbs+baC0jtslMbnGawDZpymUAmGvEp+/Tu+eNlVZM77m+tkkar61pm3Qc4K6kh8RzHVyEevuHzDZJCUK2V+h5A8zdh+mBJBiGig+QRQYc7h//Lt5oFuAmUN6qUTMt8uaFfFWseuC/1VbeKiIe07EPPZW3PYN0quyb7Qf+w31y/YYgb5QYqh4XoLef9yFvQVN5E419IOFOIz3Pal1LlvJmxoU2B1jyZgg6k9tXy3F7x2RVdFU8TMrbepfgHicZji5kh70kohogi25yX2vwrRCqze7AqMobJR0iMhEGbtmQzkqbJD1vTsq23FDCDIHyllUWD5Hy1nqANGU5A46jAsoq+z7NcchyNTVec4QIjWamlkgRqsASzbRJWWBJFS4wI9vkRnF8ggwXHdRKEa4Fo0d0cBn6cBxWz5tDZkr2AVV6tJQ39R4SXcfJJk7gOuAONafrBA054iYUsohIH2hV/xnEUWsNN51WrKH00N9vvFawTtZSf7Vtk+X6nlUqakfy5oeEYDaUN8XB5MDpeqVquVRB+70PNyRIR+s+uhb/HkWe92sHqJwwxMYqUt4uQn+8UQE616NKmT0+e5naH+YAS94MQSeCdMzeMVL9N3PDrpYBbg8ZEo15UeeKa4FtMvSJBZDG6EqVN8DcBqxdtR3nwVnl/o98D4fkQHopOKEjThYzm90pYXbT+HRId/n6yuIhIm9t5U3VUqMCWmVPCKmvrNQaoSJrRWXiOIdNbQxB/TUy0DVDdNyhX1feJIEl6Y6orSOAKJ39C1Wme96q0SM9RwW4VMGKW7ZJleh5FWiSbZ0eEt20Yrpv8SLnaZGGqgP8OW8MItIHug+Q7c+eyj2RxEC272ebFL2W9i2nXWyT5N7NDgoFURna5yxekzVKtE9Xr+WQNyPFvVV3YqirHusQQxa8AHBc4kqB2M0yxFgVLrqcs9qzl2r68znAkjdDUFEeKLoM5O2K+4cMeWFmKGGX1LpzRFEUZKAu50HLcRyEvousrEpJ57wB5hQwnY2fMTR6KByVZ5HVzkXKs5qWVXOXU7WllT+H12PoR8fmapFtsl04MVlZbV1rrYKOpvJGVTSVwJLQd+G7jvL3dpdkSPNCTMSDWs+bUHmjD85j2XdNBZaYtU1e78wobwDjHtZRcmTQJW8aPSS6zg2Z+kutdrlsHY4MK2+y4I7GZ7ceutMDeSDWWcONFf76PfiSwqHgtbSI00l5o+SNBpZ07HkDTs+Zjn2wHQyio7KqvHf7fKq+ty5567uvOQ65nol4zhtA1srRbZMdz5nKLOZzgSVvhrCJU0SBK5SXKVaRjzjJSeV66OPSqP7LwIypfgARJzkOaS580FoGnprFw+Sg1TwjFTWdqu1YtklJMhxAKuU5r7LqeoAbwMs4tsnAhYscbn5gb+zBEkWiory1VQuNBzEZaA9Mea3XOlbqSO+7dUy3lb+34zikqVyRvKkQ8ZD2LyYKPW/AKNZJFcVQFaYDS0wpbwCj+LfXUONl0Fbe1B+GdHumVdRfgCTUwvX5sy+9gFhK56C86fYnmrS+VypSR5uejASV6wApwOkpb75HCkxFYkB5a58zbfLGUsdMODN6WDLHJm8A4Idwy/1YNHD9IvS1LPm90OOcpVmOm72ZQKs5wJI3Q9B5aKAkaAwFy+RE+S6DVs8R1YPWkh/rHQXesUootE1SNcYAeeu08W+aSWcDQaVIEAYe8qRU3ph9a0t4OdtyE/oeQhzIf3CUN+rPV1Heqkh+oz0NzQGxesobTePTtU2qfa91qqMqRDyslDfZnMPxyJtJl4Fx8nZL7l0z6zCjb9OErQuYmfImnzUIgB9i1PjlK/V+IRm0HiBblk1qY5/CNtmXLCjaJt0sFkbL8xD6LvKDgptF+kYtx4kR8mZif7hHLPXpQf+9pyBvwZLbg17HqkybzPPhnzP6nDPav2xHBVg0oGPX0a2y94FKFV0VR+XtwbZNXu/I4iqqkkeBJ7frAMcqp4nqKX0PnWb3PK1860NiEyfwXAd3OOECANmcC1F/SrCEl+05tkkXS0reWMqbH1X/n8LAkmWAtD58eRDbJHlPvZ43vTXhGFiiRlQuQvU4Z5XjjnwPezoqQ2Rx0m207wGTLgPPdXB34RkLLFmbtE2e9G0qzg1Twax63iShOZQg8EKM6jAZnGNCedMKLDGsvKkcdxCR4A8d8kb7ljsob0C5bqc90yaB0p7YQ3mr9+iaDiwBjoXcuZM3P4KT7aX9ixeRj6IAbpPhnWTk/8tRT5usXqMXKngOsOTNEHQa5XWr7H2gM39OhuNxP9jKm0oyXOi7NfImUN5M2iZ1kxFNfrYE9P4X2SuiwEORCs6ZH8HP90zbYxR4iETkLVAkb+1hwUbJW/N8HwcYy797UeBh4bvqPW9xCteBkCzXcRmpJ9yqKIZh4CJPFYoXIypvJl0GgNlejuvbBMvA6/RQ28YqCpqK4JS2yVjdhrSKiL1KtUIvVd6qBNq9ovI2AXmrAqvK11R9TqruiZJM6Mz34kHXIs5SoYTKG7kGXr4XRsvzEPrucSh41zlvwOl4BVmvXh3tHl2dpErpe7fWQh1L5uKCBIiMrLx5mfxamu4PFoKOVlAJZ6rON7mWpveHqWHJmyHMVnmTDDrVgenZR3OFSpV8ufDIwGhAMbDEAIHSHcZrOulSAJX7P/LdytrI3JyDJYI8ZtoeQ99F5FDbJHvOm6OQjFUVIOh3L14DbtCvQb46SE5giYatTNWmd7NPcRGKyXIdOolgKv10oe9W51uJvI1xDxp0GQCkomyy581EvxtAe8cGDCzZb0jUuARVD4lyz1uAojgOmJdBpuoFngPXoSFGkiRB0+TN8YCFwmgGf0HScSvlTXcNL3/PZPGvC3lTSaos1wFPQa1hflzgoUgFtnpV9LVN0tfQf6smVSq/93XzM1SIIWuAuAjVte7Rq+eH8HK5imo6mVcILSLeUt4MPgvPAZa8GUKXnrcxFKyj8mZtk6pYKyhvke8BieKQbsBwz5vi4jUmeVO4/4ktRqy8BZyqbejXlTf2nDc3U1fequ8e3dgVSZAQUfN8b3YpFp6r/CBz8lAugO68mssowM1e8b0V1owo8I7kTTbnDRhHeTPoMgDIQ4mxOW+C0SO6WEUBtvsUGVWwYsM9byiU1oyqh0SjOAGoFS3TLMf9QyZ8b8dxEAVeOT5kZNukzppR/+zKNqnpnjBS/NNUY+rHrfJaSt5ytvVdhoVqQUiGqNbrTQdh9yFvJlwZzPe+JkE6nuK6oHMPmxhx4C9LIi6+lqb7g4XQuR6t+Y5Vcc+mTVrUoRNBetzExggsIZ+hMsJAhrsLD67z4NsmVZLhosA9+uJFG02wJFXaB902qXD/h74LJxNEQQdLLIo9s9IXBu6RvDGVtwhuRq6HaLOh34Pqu2dycw5PA0t0NgoS6KCujul8p3WUN5U1I/RdLETXgyK4Q5IAx7RNGqqsXmpcDxnWJslb+T43cUrWoGxv1jYJKF2v48OQatGy9d0TQNVyHPouKdqMbZvUWTMaJEhT/TJZgNN1GTDJm0DJKffBEIdO5C2kRLz2Xp0QXgIoSDJzsiNzRbXJW00dG4y89biPZIjXxGrJS2BVQVC2MUiVt5Ftk6rnzPUas/Ws8mZxgqIosNVJ3VrSSsXwN/s2TnBn4SHw+l9qx3G0m87PEde7A7xyGC4PUhWJwnFgLLK/q+VmhHEBKvc/UWsEamWwRFAcmOSrYZvkBJZ4FXkTB5YAdeVNw4Yhg+uVkeRUedOLrdf5bt1okreLkIwKKBSSRze7RDr2RKqEUjjO6XDagXB84DdE3kIfN4bW6PWtSeWt1nusq+TIoGFzPT4M6RUtVfa9o3VXvqZ4uWTWIIBqfpeJ5F3dNaOhvE24hvdRDFWUN9dF4YWIkHSzTcqKe6qoF9G6qI3ASMpbB/KmSuLj6/7H7UfwCzkRp/uQKZeCED0Ir0kX2hxgyZsBxEmOJBMPta1jGXjwXWck26TZuRY6wQfnCloll4VvOLmC8gacNlB3hXaz+5i2Sfl9FgVujbydnrPcixDhwCQNjuPg0iu/L5wxA26RwkMm7nlrW7dMbs5ASdRppS/FpcZGsYp8jSHd+rbJNC8QJ/JeJpX49yhwEaI8Vtn9b1L1EIBeUxMuA/o+8+x5C6r3NGKPqkNHedMMADgWTuTnVPW9o8AjRRuVe7DIgMN9pWMVoo9ist+QFEfVHiqT7oleiqEaCSr8sJ/ylu0BOIDHH9MjRf2cPWjkTUd567smlG0MMiI+bs9bD/IWp/j/2XvXWGm6tDps1b26+1y6z3m/YYAwDIMNBMhksAciMgRMsEKCHFsWkRNiWwoBBTkktuIERbETJ1iR5SAlwYoQiW2B7SRE4Uc0EcGEW2wnxigjjLmZiWywDQYD873ndJ9Ld9e98mPXrq6urn3f1X3e9+sljWa++U7X6VNdvfd+nrXWsxyHNOXeBpyLNwugG43soYGG5h5HNqkm3RKB5mS9zVhJdMmJ10LC8wbYC1pNH4kEM5jK/bxNs7sAMs8Z6ZKzZTGkeGP7JS685vvCkE0CQIyMu9m0sslkBNkksDfamzBvKtLGQHpNeE4K6ZgAgAzfAORYj8etmNXbY95eSvFmUWUANOGzlg4kq21mjXm7HGTeLA4sAZRkk7L73k6yLPMMyrF6ke/CrySLN8DOc5g8qMlUu8yzaqyDbdmk0sG3ed91LT2psuY04ESIfBde2eRGmniQu/dMZShI97VjFG/hrLFQdK+t8hwpFm+m7zuIGxvDC5s2qfnde9zmuIh8uK4Ff/sLwLl4swCdfKGDrJ6RoDrYQATVoNU3ETL+lDhwW4+V+OBgKWiVTpWT3dh6HqyxkJcVNlkpfM6IT4rN1hRehNhhS27a4m2IeWv9Fjl3s4kDD5Hv9pg3S6wF0GwWu9HEKhKNq4kC86Yom6SH4CcJaYvM+44CgYy1i6Mxb2r3RITLOMA2L1GUYraShyQvkeQV5lMDNqGDPc90qsjGi9A/vHKgM021+zqZawvXlMAjxZvwGZT/u4QwYt6e1A+f9HWm0HnfZUbsAZIMb+XHiJxcKyogbj9LA78bwCjeJKcumhZYPFALxbGYN2PZ5ARBzd9PAWAaeHCcXfboaKiqJhZFl3lTszG8dJyLNwvQyY84FoOlkj8nAzIR770hm+Sh9VoAEszb5S7nxwSJYp6T5xMP1siySZnR8kBTOLXF2+E9K9uu7fCydOlyBmQ0G/6VXwjH5+81TkaRTVLmTU2yfBUHyIoKiUTYKSneVGST8tIWGa/eS2XebEvEAXMvh22vxXXXtzmW502KeVP7uw6GBXGvLTewJPZdBPUpmDeFEez0+a+bKZ4qn9Wpi076Okn5YelFZsxbJZHZJ7xQR3GiKpvsjuRXnVQpg74UVfXzyJ6BUmI9ssS8RRDLJt1mPsDodpr0EUBt4Hmz29w7Nc7FmwXoJLeTLvuxZJNn5k0FMv6U2Pfg1xlqNyCDKniwJpt8Uj+kRZejF2+yh7hIELSdu83Gz+jazlzKvA3nvAGkeBPhikqWi5QE4FqXTXaZN5U1QY6ZSIsSWVkpDizpTCgUgEwOFTNvL87zZnmtu7Dk5Win11qMCgCa751q9qMISsybmofE91zMQk+JeZPxvAV1drzircyBfK1+gKwKIN+oZ/L5EfF/WWPeVArHTmB1+ig1qbISrOE8tBJYU+Yt7rCVqsHk9GfTx2ZSZTFC8fa4K+R1immZ/dwK89Y0Uz2x0ucysherwoRqIU5/tsu8vSXDSoBz8WYFL5t5s9uNfk9Mm5TwvE3C5vAqYzy3JpvUyHOy9bs5kJVPxX7nwO8d3rfciTBxMsQMz9LUpQNL2MzbpUzxRpm3dgCMQZBpH41sMslLZEWlyLzJMRNPEqP8+7hU8ryJvXr70z9fSPFmW2VgqXhbbcW5kSq46Po2VYOXRfB8ILyUZt5UPSSy+8fjNofjABehiM13EdaZxDNICxHD51B11H/3Z5MHvem21gZeGTJvEpMqi6Z4izWYtzjwEFQShbgIQ7JJJbbzWoltVAK9dr5RLwz7MQYs2GIMm89h6ouVIJdxML7nTbd4Sx+BqrJ+Fj41zsWbBWh53o7AYNV1rZQ/J4OrOMA6M/eBvFRUVY3HJBd2yakEsPYkNho6xMJ0THXyoN5hPwrzJjeiPQo8xE6Gyg0B93DpyV1S0E3c4e/F1M1RsSaRNczbpSfeaNrGyRibc8OyajV0JJk3yp4pDSyRDFIla4a4Qxl3WVRhxtacHFaKTPr96sA68xbZMeI/bMS5kSrwXAeXURPorjp6XgaSxbaOTFV233tMClxKFIax5xAfrUzOG2CheNNkcujvThUHlgDk500bcHlCvGumxZsAhRtpe94iWQmsCOEFAGcnm/RjNTbvGMWbbiECiJ/h7BmoK+P3XTefw4Urbl5dWJzMy4T2PSMs55Pls/CpcS7eLEAnCPsY3rFNVqKsasvM2xHHwp4AT0mBupaQ6/ikeKtkRhpHVyQolObC6ULV7E5/98gDS3aFitifEiFvN4U+cpB7OXGGD3cTJ0OGcLj72zCgl774YEiYt2KkzfkKyNd4XJPPWklK3Y8xYGDHvKk1iwDxwJI29kRi+Ewkk/MGqMl9DGC7s2rL82abeQN67LHK6HkZyBZvW7G8tg/Zfe9xK1eIX1CmXfQMKshBuTA9dOuqJ0zX8FRDZdBlehSKN55vmYfI9xAhY+4P0nDdXcNUh4F604s3S++7aBrTU0YztYvL+AXLJpvXnpm3Mw7wuCUTeVSCKa+aSWZZMR6DpdP9F0FlYtibiNafIpgMFwUuIidHNSD/O/xhSyP7X6psUpJ5pmxl5Q7f29Qlm8XEGWZopsiQOoz73Ugp24mUHBDPW67XRReh+XzWT+TaKt+960kvxoCBp3YSn/2oAOlCfG/4zJFYDw7GUBnYyi9abcjzPJ/YmTYJYBc1o9PQEUGJeVO73/LMm9xB64Iy7aJn0A9JxIpIciaC1gGyKZi2K4MGnOEablosSBZB1LesFdLd+Ggr0+IN2ClOrBRvFmX18fyNKd5yh6xXcsVb8IKZN6DcrvCUqjebXjLOxZsF6Mh16M+PqRPeDVKx2/HtXvttw2pLDloy0yYJ8ybjeaPMg2n3VNHsDuzljo0FleECsZOhZNyzFOT1MYa/E7GTIQXjANxs+DOJjYayFvUoskny+Wwf78nv0mDHhMxbqi6b9FwH09ATDiyRLcSp562GA3iCv1HWq2GAMVQGFwrxCjxQ/5bNSWct86YjwxMhvpb6rGTZsS5kI3IIqye+XzOPPb32ADa8lyaH7qffIHI25TXcAvN2rOINIZFNajFvLmJkKF0LLDIteFWHggDjM2/5Gli/Vr/2iYo3lhKmC5uZmEwYPMO7/fgsmzyjAx2j/JVkl90Esl10FbRDFd565k0wsCQgEo+SwSLtoTVQGxwc8oRk7ih3ba+P4nlzHWAW8rutUSObZG3OKcj/H2NYXhojQ8Iq3hrmbSahz7+KA+RljWK9bC5sWTYJIF2Tw+/1CNMmd9EMagfnSwlfgmwhTqICclKIi3IHj8C8jakyMG2wrRq5js1w2Cva6U402HgRJIucp0QtCgPoTHoVQJZ5mzUHSymp3amLt4d/TP77FOoJHZWBHxN/sULxljkhIt2oALqnyjRERaD3TIt5azy663ebf7ZcvAG7Z0FLxnqc4i1rVC4yxdtV7B9vYInq8BkA2yey15+ZtzP2oMW8SXbZTaAzSEWEYzCGp8RqI+dPocxbIdMlpJ1Wk+5pO5hAIyogewYq8SAPXdDnX5SvJrpn25rc84jBvEXI2cVb03mXkXjQZkb6PELx1nzWtHhT+e5FvovQc4UF1nPz3btQbBhdRD6eUpFsUjazj3TJC1fy0AyMKt8dQ2UQ+S5817ESFWBrWAkF8Y7lemy8CNKeN7UoDIDsH09JjlowvEmW1aPf90JWAXGS4q1Zs1e0eNNRT5xgSmY380yyCEqdCDFyxFoh3YTNl9pTRTCVTQL6xbbMtVe/uv/PMggvAMeVKN7sTKDNGuYtZtgYuriIfKRFNaoNqLWNiKKZumjuQbpWV8K8dJyLNwt41OlAtkXQeMxb26G3bJQH3l7ZpGwmU9x43gpH4t62QasGh1fdMN5u5s1IkO3AE09DhoLBViYN8xbW6fDrkbQF3gEaz8tUqktIrpGtV4DrEy+MLURksyjWZINVGSriOM7uUM6BTlQAfS9C5k02s68Z2JOzPIhdHIF5expBZeA4DjHiG3vexNEjqmi9YzqyMBHia7JeVOyDWFXVeM50mLcAVQ2sM34zSXZNmTRMeyb7HJqqENJHcoAOL+Rf40dkfXr4td37UAGVTZpMK9ZlY+Jr4PlT0pMqU4QGId20uWfD83ZlNrAEIAWW6qRKlWvT9ykL122jaLiw5NVLm71WhnmzNdyJC4PPMn+mHvSzbPKMDp50tP9HGPyxy986yyZl8SB5eG1ZJEdGNkmZN4ODQ7sga5jdTX+3ALId+DjwEDl5q6XvY9uwamE93OkL6wybmiWbpMNO5DeaYrOCTHaREprPp0geEXiOcgeaHMoFA0vSAnHgImDk4bEgJ5uUY7ACz2m65BLP/zFlk5Y7qzbyix62IxRvkwDPaYFaZ4iRCPE18WZlz8wfeUrlpvL20doFOA2Ksqqb4QLiNWXasAIZZJpolpg3nTUjvjaTTdYVkK3VXteFSfH2IM8SpQgQOCUCR13pQT1vuUxDVAQj2SQtsH5lnMYIvXYwJYN0VF8vLZs0WxfocLCIsR93cWlJYs6FzmfZfNfKjboS5qXjXLxZgNbULYlNzBT02irdfxFmoQ/HGfd9nxKrTUbkG4JpWZOAMg8qnjcT2SRl3jQkN6a/WwBZf0rcjIJm3bNNRa4RMJi3sM6wqcJhyVXjeYllmLfmwFltV/Y35+Z+19sHXMViKWkflxIhxk9J0WaQKV1bYpzzbs3gr2eO42DmSj7/4QxwvHGLN8msQVVcROYjsEcp3mKfEDHJSANLAO7ntZPkq0+bBPjNv2cFTydt1kgzb7aKN1XE18DjPyH/+xRrePKgpzKIrzsSPzGTkzRsjaMRixO3xZsl2eTmrvGJGzBvoxVvmteWKt5W5HMWDZISgH6WkczAEkuTeflvSOO75/lAeEH2etiNazk1zsWbIeq6xuO2UC6QLo/CvJEOfagx+YkFlwbEvqU5bw/bXGqkd9RIADOV4s1INqnpebMh2RSAPP/iQ1wUuIg5Be+m2SyCanjjD+oUCQJkQwHxroe89pgxA120h8LkwT5r0VzPSR+1Comr2JcYWKLeLAKAy0jMIj0mOULJ2JOJk8kdmh2n6YSPz7zZnOhIr2e61o3ieYsDOKhGigoQZ6Lt7rfmvseR3at8ljQoPmUx8l1EzTNoKj/UWTPiK6Aud/9bBTbUE7qMYXSlxORQ9QSK4QYcD7FbwnNq5FY8b9e7+629Z463P+g/R5LMm4Wik/rLI0YztQtbsSr8N7Qyvme294dT4ly8GSItKmRlpaylnYUeXGdc79hYoYRXEuzAmwpZf0oceAidQk6u4zUdT6PNlxZvGmOmgXFlk5LMGw12Zo37p8wbq2sbVCkShEgZpugE4S44mgP6XXXH8AsFE8Dx4GRPWgXWVSz+bj2nhfKwEoB0R8WeN3kfU+wU7OiGgx+2wHpwIMsYqkJGaspDXdcjySZ9TJHCQX0i5o0ynfYVJ7LSdWDHCjAHGXURXwNVQSYJ6sKEeaPQXcNNGnAmxcLQ/2b9mqr5HPKt+q9qPkvpNYWH7j3WZd50Xjv2tY9ZvNXku8qyMXRxGb1Q2SQAxNdkr4davM5Lx7l4M4TuREcynEAu80YXOlMwZSAbtPom4mGb41qiSx435mqp4g0wD1qlkhlNzfeosklJz6fjOIidHBljc163G/9w8eZXCdI6RJofFm9FWckXb8131c9GKN4alsnPn/SYt4mY6XlK5JjOPi5jv81DY4GsGXLXJsyb5N84dvHWqAx0BiXwcBkHeBZM6OThOS1QVrXVgG6APMOXaIqQMTxvgBTzpjOwpPt602tT5o05yGjvhy14L42LNwcIFYu32CLzpgrFYmPTHPihIZtsJbCyeyoPXZZQdXDHmMUbnRipe+0jFm+binrQ5Zm3FzewBADia3jZIy4iH76iT/wl4+35S04Ek3whmS67CXTy52RAJuK9vbJJmS554DmIkMvJdQAYZ/WkmsybhATKBEVZYZ2VCmxN3oZx97Gu6MY/3LX1qxRbREjyQzN8UlRI6pAZM7D3HgIPoe8iyJ/sb84AEF3Bz9darLfMmvCU5G2nUwVUssabnqjC1sccFvXwh8dn3sZQGZgyb7LRI6q4mgS4cJrviXXZpLznTfXv2k0r5hRvCqxe2BRvicw6bK1405jiR393dEmmBqrApmxSFarFW6Oe0GHe6NpN8z6N0G1oqP7dpgUWD3RipO61j1m8NQ0Rv5YfAjaabLKqyPlJ856FhZ4S5iXjXLwZ4qHNF9KQSEl02U1wZt7UQTxvEiwSgAgZEkh+7tGlec6bP1E3IY88sGQXRyF3H3hZbeuiuQaDefNK4nkbkk2meYkUgZTEAyDPcFSMV7xF5bPWWOKrCfn7hgpUiudETzZ52UhGeFlvj0khvWbEyOUOzcARmLdx1rqLiEQFiHLJWKASQBk2XwVXcYCr0Zi3pjjhMm/6QfHd1w9fW555CyvCCmzeFOZNR+Jqa2DJUZi35nPQ8LxFIK9JbDBvJrJJmm+n81oZmFw7vgayJ6DknBstFW/bykdVO0wPehcXYzNv2ROAWvueRYWeEuYl41y8GeJlM29nz5sqpDOZqgKeU7cTmYQwlU0mj3od9mBKJv2N5HlTlU+FyFotfR/bsiaSmSFPSpnDrQskdYi0YDBvCKUkHgBwE9cI60Sviy5CfIW40mXexHxBPIUAACAASURBVB1ME9mk8Npb+WEoEdLdgAIRRmfexlEZXMYBiqpGMiDVlcGDJkMlwtXExyVl3sYcqsAAXf9VmwiB52IaegLmTX5PpczbhrGm7EGiKOWiLEh8glHxpjnsBDD3vGm97+aeSU6qfC5p8abBvNUKLKoIsQHz1n3NSyzeAP5+bsvzVlRIEcCXaIhGPlGzjNbU1426aF4Tl89vVUwAcC7ejKHreaOvGXva5BihhDJZVG8i0qLENi/lJsM1mn4prwVgh3nT6do6DnndSNMmlUa0lzl8VMx7luYVyZYZ8ks0MpwE4eBBOslLJAiZMQN9vD9qvncjbM5lcIFZvdH0vPE9QTQc+VLDeC0zzlmFwQqRMwvxA8TzN5N5a++Z3jpNizfb0yYvIh8XoMWb5YElzXhtkeftMvLhueoZiaJ97zEp4DiQesaDKkNZO9gWEkcZU+aNHpiPzbzRQPBTyiYlJ1VuKr56goewmRRsh3l7y4s31jNc19aKtzQnxZtXyn2Wl5GZxJwLw+JtWq9xHb9d5c7b9decAI+KsrEuxvSOkQiDsZg3kn1UDI1sf4Oh1CVvZCFb6cOrqeftSb/DHl+NJptUCoIXFLxpUZHR80N+CfpaRMPMW14iqQP4lZxs8tPCZkMaYXPOgwtcYqM9bRJge4LWGQlH1slubD1vDNkkjT2RZlHrDFsV2WS+BspxmlWjrXW0eNOUA43lefM9F68C+gxbZt4AIVP6uJWX1/Yh2vcetzkuIh+uRGFI4kNCpDJ7kWnxlqz2r6OC9sCu8Vm5HhlyoruGFylhwky8epJ/83PJ9y3zEJQNi1pZLN68CAhi9de/qcVbtiYRCTaKt0bN4pZyDdHL2Of6qY1gWLy5qPFO+Hapxc7FmyFeKvO2zUsUVT2a5w0YebLQCdCa8KcSB1JaTMhuNNH1aWSTNn43ByoSJ1rwsjbnJC9JBhyHeUtZnreiQooQfiW30bwTjFe8pd4FLpyt9rRJgO0Jop3NMWSTSrEndY2gTuUPWu2hYyz57jgqA1Mjfsu8WZ42CQCv/OZZty2bBJribcX8149Jrh3LIGbe5Atx4oMdZuMP0MoP2X8XF4YHSABmDTjd705igTGUfO1TW7ype97chuHZ2JRN6q7v7d89hqx+vv87lF4rKN5MntH+pfISGULpwPXLWJwjqv9mzL977Z7/luBcvBlCJdS2j6tJgE1WIh+BwWrlbCN53rq/422BUpe8LUQUBpZkz0DFHkTBRfqkL48ylWxyoOT5bAow1j1LiwqFy2fekjpEOjRtMi+RIIAnWbzd+uMVb4k7wyW2uNKQNoqYN9owMRpYwihElBpRZQYXNdbKxZvmwZmDMVUGF5F4QicPq22G0HMRB/a32hs/QQVnJ6uzCSHzpi9TFUXkqLB6XpU0xZvEuupHZOiTNvNmcoBsDuxGa7hu8Wah6JQt3gr9aZOUrZPyL4rgR4AXWije3jDmzWLxlhYVUieU/iwvIn+8hr7B31U1DZN2z39LcC7eDPGUyMuM+qCSnDGo5qf2UD2G542yA28XDb3rkst73talgmwS0C+i0kfCoOkgvhrNb9ROm5SSTZLCinXgT4uSXbx1PG/D0yaJxENWn3/j0jHr9jfnjTNF4JS4DtW/1/TQyiqw6PfaRDbJLN4SBf9i8/xLNy9kjPaaSPJqNJXBpaHn7bHJjXQk/EKqWHgJEmeiPnpeBjGfrTfd9/gDeeSH5nhVhqwOBhs6g4ivT8xg6aonDAZepUcs3sqmia2R89buD6Ulljq6MijeDNgx4bUNWD3ROmriy+xfquAoYQZgGqvChcF3b+uRhsmNp9FQeMF4u4IPRsAn/98fxtNP/iXmv//YU4pJ8BEAv1v52q/cJ/xp/3vx//0PfwWe5Q04K0r85z4w97/Y6nUB4Dqs8J/5/yPuv+8v4xMajONLhZsW+I/8Ca7jrxL/sGLx9lRPcAngZ777G5G56hr83/H0KTwWEW6UXwncFRGmn/pl/Px3foPGq/n4wCbDv+1/Ombh14l/mB74GfcsySsUbiwcWDIU0p3kJdI6hCfpeZu7ZKJl4l9AwxHBxTMmze9QP8BcxQG+xfsBvO//+l584icPD8dJXuI/9V1c+h9VvnYcuPhG/4fxuX/re/CJnzk8INE1Y+F9ofhizUACWeYtCy4RAvjk9/3HePJvVd62EGVV47/0M0zxJ61eFwAuQg9/3P9+xH/1L+ETP66+XX7FU4JJ+FHo7A8iXLsJ1phCPANQHXflBNPf+iXmmvHNyy1+9foPAFB/Dj+v/of42NNfwSe+888P/vtvWG3x9z/9XwXw5cJrOXmC1Blu6AzhyZkh+/kfwS//A/W18FX2a/gQgDq+gnIp3hw6H6oYOsfqZRkh+JWfwS9qrOFXxR2+ALvvoBKCCUrHx2M1xULixx/auBeNg3KrzLBzplg7U+T1FDrCx4d6Qj6nEYq3Z2eGC5g9R7/yI9+F3/obP3jwr6/zd/H5AIrwyvhwn+QVcieSlsB+YfX38LXL78cnvvO7DX/zIT4j+SX8U4CW7PgZU8wAzN1z8faewubu1/CB1SeY//7DeMSXBb8M4E8pX/ujxd/B+/0fxbuPC5SwWwSFyPEV/gOW1TcD+Gyr1/6C8u/jn/N/CPfrazLa/S3BBAm+2n9G4vxpAAIpUrOgPZdyn9vfSj6A3169H+9//Dmt9/ab9TX+5va34d/QeO0Pb74AX1X+BPc51sUXYoN/0U/hOv+d+Iebouy5GL5naVGiDGOGbJL8f9s6RDIYFUCmTcrq86/xDAB4rGfWi7eHmhynr7BWfm3sZPhPgv8FT+kU6/TwWB4hw1f6j3gq/30An6Z0bQfAn/C/D2kW4Dk7vHaAAl/hr3BXfSOAz+FfrPk8niSbF7+Yvx9x9VlYPP8yFvhlpfctgocKX+7f49eLfwnA77R67U/Da/xR/+N42F5gu1V/Uj6MR3wUvwqMUFheYY1HTPGO9SsDP7L9fHxl+f8w14zf4dzj18prAP+m8rW/rvhxfMD96/jUariI/xKs8E9KB8A3iS9WbJE5kZxsEsD/mX4YH8v+b3wgV18La9T429Vvx2dU1/h0xdfeVRf4O+WX4GHzefh65d8M/ND2i/C7il/UXsM/WX0W0vz9+Iji62oAHy8/hmTzT+MPSvz8Y+GTU6WG563dH2wMLAHw8exLUW3fjz+s8dof234e5uWX4CP1Bey2moC/tv1czMsvxgeKG+WT2TMm+Nnyi/Ch7W/iA9tPHfz7GsAnqw+gyt6HLzJ8n2lRImcpYQbw+8sfxmc6fwOvVzotZj7qusaPV1+C3+V4yiflh3qKTwNwjXGsI6fCuXgT4Hd+3TcBX8fZRH7gjyH+5P+hde33B6T7/863/W1gZnmJ+K2/C3z3P4+Fo36AFOG6JhT2zbf8APDp/6z1658Mn/wB4H/9Q4hzCYkh3WgkD6//yPscfEv23+AXvv1rcaHhhfrK7/hr+JJgrlW8/VDwNfj+930VPv6tH9N4tQA/8eeAH/1TxM8n8nMINue0qFBOIqAYWGQbpofFvNGxxq6kbPIaz0jrAPe5j/dJvUIedxW5D1e1+mbhbO4BAJe/58/g8qPfePgDv/7TwF/4alyWGjLY5AEBcgRf++24+PJvPfz37/494Lu+FLdNYcsFZd7KAHVdC2WBd9Ulvin7r/Dxb/0YPvJZlocAZGvgz3wGPjMcyAc0RJjcAQCuv+Ev4vrz/xX1C3z830X8D/663TfV4BpP+I3qAp87wrV/JPga/E+3X4Ef/KP/wvAPfPdX4IMTPQ/JBycJsPhsvP+P/ezwD3zv1+Gza8lr5wlyR3JgCYDvqP8QvubDfxx/9us/LPlud/ihn/8N/JH/+afxgwmUi7dlUuKb82/Dv+V/UKt4+z7v9+BHP/j1+N5v/DLl1/7sP17h933XT+AvlureyG1e4j/MvgX/cvB+YfFW1zWSAigDH57GtElaJDwXdo6lfzb71/Ehb6ZVvP1d/4vxPfm34ceSCreW5wH9kve5+HP5n8D/lrnKxdtyU+AP5n8S3/F7P4w/8KWfdfDvf+of3eNf++9/En+5nBi/z9aDXkjsBwA+e5IAn/ZFeP8f+ZvGv7uP7/2Jf4hv/4FfxE9vc9zM1Pjju4p8gFe13N/xpuDseTPF9BbYLkm+hio29wAcYDLCRKNJI3LY2h8QgOaAiantntSJoXLPFJm35SZH6LmYhXoM6+1FiLtnOUlgH6+fM7y6sD/tDoDiPSMHsicG85bkJSo/Hg7pLrqeN1ZUQAinzKSGwlyUD1jiAvcb+77NTxUzAECYLtVfvBV8t2YNz7J+V/3a69f71+iD/k76HnhoPkvW9M8+lPykqgimgB/LvW9ViO6ZCJPFOGswyDN8V11Is04qWG4Eh6TpzW4fUMX2nr93TG/kP8siQeFGg2x8H3VdY7XJsFA8/FHQ16001oxl85rXzxqMFIC75wy3F5HWa+nnuNyo7x/0fcu8lq4DpRtp5bzt9lTz4i3JSzylRfv+VbFq/l7d18tce6X1eZDXsJ7h3TOqd1boIsnL5rOULMQ39+S7OwJMnuF38xB57eGyGi9n9BQ4F2+mmNyQXA2dgRDbe1K4uSP4xqgZdqtxgBSBbqyTcb6oJ4PKPWsOr4+53Ge32mSYGwwuuJ1FBht/ituZ3sYvhMo9azb0p4GCt65rpEWFypsMb/zNBpKxQrqbTBoAUgbrafmAZX2pdRAT4TeLRpKoU0y0jRHGd2v2ivy3VvH27v41+pjMAThyh/KCz4T2MVbeGQASHjy5ATYjrHWieyZCPCf5doX5YaqPMZ9hsl4JijfdYnlzz987JgqFYZEgl5RNrrMSeVljoRmYvpgaFEFr8hqdBlxd103xpld00oB4raJzTQsN8WvpOlB6kVbOG4otMgRIC41GeA/3a1p86X3v6Ovo328TbUG81m8CsJ7h9hm18L7ToiLFm+zwme14xRtdi3SK0tU2xwoXmBTjxNScCufizRS0g7i5U3/t5m489iqYkIDKEUZzY3NHRi6HY1jlTwjKIsncs6ZL+CQp8bhfZ8p0fxevLkLcaSzIVVXjfq2/8QuhdM/ohMLgIB4jL2tCXgfx8MbfFG+VP2Ezb23xJi5yo2yFZX3RbvI28WtpI1nRXRMA9roQTEhgL2WEVNAWIgwWyfVIASfzvukAmXqYCe3jQSUPUAfTW737LYLonolAVRW21+GqQpQ17PEIz/D9OsMNr8gxud8bEfN2Sw6CMmqWfIvCi6TYX3qgXcjkeA5gMQv2rqMCWgzcrdUbcE9pgays8EqzAXcR+Qg8B/cGTI/Ma+k6UHqxnuctT5BLsqgi0CL5KSm0opjuFRhHVbSFoUETgMW8XU8COA6sKErSvGoKccnibcTz7E3znb3XKHjv1xmW9QWibITm3glxLt5MQTsNOgyXqANpAqeRY47BvG2Wo3VYToqJOvO2qXypzWG1ydsOqA5uL0LcrzNUlVpX8jHJUVS1tuRGCKV7Rjb0dGDcP92wa5/BvNENxI+ZId2l02xoEjIPP13iHpdW5CV9/ObWI4N8dGRlMqz27JUh88YpRCaSjEqXeZOUTV7GPjzX/sh8AMB0MZJs8l0iywxneq9vZcWW1+H0AQ6qhnmz+wwXZYXHpOAzb5MbIgfVya0UdeinN0BVyI3GLxKUrhzz1krONIs3GrSuI6Wjr9Fh3uhrdBtwjuNgPg01ZXrkfa82GWpBMU0VEZXHGDolQrFF7kRSTL4IrztFsg7jOKZs0qh4EzzDnuvgehLYkU0W1MYgUbxVJVkPRjrP0rOTzj1bbXI8uldwk3PxdkYXRsyboANpirH8Fpu7t7N4C6Yk2FPB85YikDo43G/MmLebWYSyqpWz9Shbd2vwu7lQ8ryRDT2tD+9Zu2H7MVCmh4fCZgOp/cng/U7yknQJAalOobu9x7N7pdXJE2G5ybHxr/WKN5FsEiDF20aDeROxevTfyaxlHc+bzPP/sDVrXggxFvO2uQOmmpJJoNPcsLwON8/Jsr7QYlR4WDUsKd/zdgugVv+7ipQMN+IWbwp7apGg8iKpgSX3AtZChNB3cRn5WkznsiPjKxUbcPdNIWK0f0xDo/edl7UwgJkyb7UKW9NFTvyLMky+CPedIlnnwN/KLseQTTZ7js7es1xncBy+/Fz3s+4jzStUVAIrYsG3KwD1eMzbTF8Oer/OsPGux9kfTohz8WYKenjV7bKPWQTFIzFv2xEZw1PCceTvWefwupU4vAo9JALQgSOvFTu3pl1bIZR8guQQkiA8LN6aDdsJGslhf/MvtoDjwQ+HmZ4kr4hcBxB3fasK2C6RBPNRmLflJkMSzPU9b9EV4HEKndk7+rLJeM6/tuwgilyNeVttsnH8bhQqPikVrN/V97sBQDwS89b8rfe4tM4O0O8Et9huFSeK93wjwSzTfyfjYcwTVF4s1UBYCfxCMpjP9FgNWkBUtbpvh675rwzUE/NpoMkY7t6riMGi60Dt6zJvCUpXfnIoD115quqBPy+rNmx6TNmkLhN6PQm4Cob5NLDig02LCrUXA3UFlILrbSWajgaYhh5Cz9V+hrfBfJz94YQYrXhzHOe/cBzn1x3H+ZnmPxIpvm8gjD1vIxZBk8V4nre3kXkD5O9ZU4hkCIQyj7qusdzkRocGOnDkTnFoCf350QaWhDPADZQ8b4St6ckm6T/T4q0v1ci3QDBB7HuMqIBG4gGI/RbJCqgr5OHcOmtBN/48lPSO9bG52zWEWDCRTYq8W7JFUKHueaOys1EwvSEFko6MjweZe8bDWJ635tla1ZfW2QHKCHDlhXT9V33GpdhfyWvXNVBsUfkxMokGwr2h542+VsdP1GVZVL3LNhpwi2mo59XrvEbE5tACuvY1PW+FPebtzoB56xY+tpUZSV5ik5XNtTVYpE0mfH4X1pi3knjQATGTSr+rIzX1ifQ30Pab5uFc3kf7hmBs5u2/rev6I81//urIv+s0iK8Bx1PvQGYb8oUYk8GazMeLCnjbYgIoZH2CRYLK8VHCE3Z9H5MCZVUbHRroxq268b9e067tSAdnFW9lnqCGgwz+wQZN/9mlQ3D6Q0ua4i0K3EFDe1pUgB8Nv7aP5r2Wk5sRWAtyvTLWZIJEY9SBHfNWKXao16/FhYjsFMGWeTssxIew2ubjMm9Uxqcz9ZcHmXvGw1iet+YzSsO5dXaAXo8r02vZMcVnXKZDLxtZ0RQItTTzlsF1zIbmLDS9Y6tNhsAjbInq1GDagDORTS5moZFXj/xv/t/dMvA+Y+iUCPkWpTfsaVbF6+fd/Vb9u1d7bKNlSXLnveh68URN4MVM7xntIy0q4kEHJIq3cZk3gDz/ekNecrIfy/po3xCcZZOmcJxGajRCB9IUY3jeqpIcRN5G2SQgf8+KlOjBAeHh1XTKGdAp3jQ3fl2fhxSk71nS3DPn4J7RDdsNqfSxL5tMAH+CyHcHmbckL4nEY+i1fXS6hLZZi3ZzmS7GY+Nn7zTxJIrfbRkJ4PSG5OyJZE8tiyrHvD1uc1yP6XmbaDJBPNS1BdnkNflv65438nfWYzzDaxnZpKbiRGbfa60Igmu3Q4wiJDLMWyPdNRmas5gG2ozJ57wiQ29Uh5bcrTNcxj4iXz9SaDENpIaO9LFsIm7o/+ZhJ32XHHLRR7GTwKq+zz7u1ik+eEvut+rndd95/m0rM0yvfb/OJZg38/ddVTWysoLjS1oR2u/1eOdCIv3VlCyPsT+cGGMXb/+e4zg/5zjO9ziOM6gFchzn33Ec56ccx/mpd9/VkAK9BOj4LUbWCAMg/pbsSaxXVkHygDGNqSdHLMlWFgkxZgPC0cZSnWwB6KhcHc/bfBog8Eb8qiv4BOk9S3udcto59yjz1g/qzrdAECMOvOGogKLcSS5FXd/mu+rObu2zFs3m7M5ekeJKlR2TYbV1g7plJIDtoVzEerAlsH2QcORjMG+w62tIH4EyM2PeXA+IrsfxvDkewtncOntMrycM6QbG8bzFc8BxpZ9B+HLM23KTGzexCKuhw5jk+G3vuwCg3oB7/Zwa+d0A8lkWVY0nwdCRPpabDB9qik5RLhldB5xgopnzlqD2QlQ1UCgOdenj7jnDZy4miANXmYWiz/+HXs2sZyjS90KurV5My4TML2bEN7jN9OWntJnK9KD30Z5nxzsX3miwx1Sm6l3Q/eHtmThpdKJzHOfHHMf5hYH//D4A3w3gcwF8BMBvAPivh65R1/Wfr+v6o3Vdf/Sddww2yVNC1uTfxcgaYXJtmsFlUUp0hA7LSSHteSMbDQDhIkkLBJNpe77nYjENlHOC7tbpeJMmKVTumT9c8NLNwgsZm0W+BfwYke8Oh3TnFen4AmK/RfMMB5evtHOAWKCfdXB5S4zequyYTHyITlB3WZBry3jeAHGHMt+SkeBwhMzbJitRVDXmoxZvkmyNCuhQGJPiDSCyYtuet2bY1XwWjSKbDH0Xk4DD9IQXxOuqzLxJNC1dl6wpEs8gQA6YsjlvJuoHgKgnntNCymNHUVU1VpsMH7ydwXX0PG+ma/hcM7x5uc7x2bczOI4K8zbRznmrGpmeqXTy7jnF7SxqJi+qHfjp3/k5ry6w2qjH8/Bw37m2zATPg9evJWSTBmHyFHssKiDneXMDsi6MhLmGb5MW3/5Fs2eemTeCuq5/d13XXzzwn/+9ruvfquu6rOu6AvAXAHyZnbf8AkFDRVWwGb9ToZTBJYsjaJtPism86bgLFtUi3RUigq4v7ViaMG8AcHsRKUtuXj9n42W8UUj7BFNiZgcOpI/0n/2oydPqyzSKLRBMEfnDzFtalHDbYScizxt5huMrsqDb7K7SzmB89T7yf6g0dYqMMOVjMG/bewC1hGxS1m+UEG8LDj/LPujo+aMwbzaz3tpcPAPZJDBO3mYTiLvQlBLxsFxnuJmGcByOvNBxmngGDcVJeLHzp7Igs6fSA2UwQVnVwiYMGRplzrwBal6oxyRHVZP1+2YWqqsn1qnxtOAbGjCuuNYtN6RwnE/EzxldB7yQkdUpQmdNkWFSWajrGq/XGV5dhFr5dvTv/NA7M1Q1lON5+NfO22sDanvPNiuRFpWYebNSvFEbA2OAWB9UMcJbMwxxMw2x2uZKxTS9B9F1s2eOkQV6Iow5bfLTO//4+wH8wli/6+SQ6RL2cYwiSCWDSxbHYAxPCVm2srvRCLqEO+bNsHibhep+ied0vGElFJMFsJVgdxv2DBhi3sg/+zEdWNJn3hIgiMnAEibzJmuuvgNcHxdX5Bm2aUqnn/V0rrFZtNIT0bRJWrwpxAXIBHQDnUl/gvfdyFgB8UHroTmgjJrzNoanQfaeiTCG93hDfMeLaYiV5Yl4XZ8TF7qKE5m9Q8aK0DRp6AFT3EQTsxYi0NereIqoz+lmFuB2Fmn4ls0bcDrMG5WcLWYhmVYpKDTo/XdDTdlkvt019wyYN8qM3l6EuJmFyv6v5TpD5Lv4jDl5LzYmN3avDaCVoqpcm/4dMp438rv014XWxiBrRdguR2/oz6cByqpuYxxkQPfjGd2P36K4gDE9b9/hOM7PO47zcwC+GsB/MOLvOi1oB1JFv0wPaqKx4CZQyeCSxRG0zSeF7D0rUjiyzNsmg+c6uIp9o7f26iJSlk3er7PxYgIo4jmQPojHtBdpp7PKYt6o522AefMnDfM2PLBEmnlrpImL5r7Y3pzjwEV0STcLhWJClo2f3ABwNIs3SeZNOCxi91mKDlqrLbm/JlP+hIguGxnfC2TexsjbbAbbLKYhnhRlfCIsN7mcSkBXcSJzyJNh9RppnhcMryldkLiWzFj9cNMWQfIH42XbvAhxe6E2xr2syPt+Zet9KxQyu1y8kEyrFLzvPel7manHdhRpK9Pre6JVQO/v7SzSyjyjz/+OwbLJvGW4iHy87ypu/1n6tZKDz9pAawvMmxfJMm93o58Jdf4u+j29nL9qfLRn2aQQdV3/4bqu/5m6rj9c1/Xvrev6N8b6XSfH9AaociB7ln/N5p4Y2XmBuaZoWaQRmLe3VjYpec+KpN1oRMUbmRAV8GVIEri9CJX8EkVZYbnJxwvoplBgK13GPaNMXBgzijfKvPnu8MCSvIJLNxoZz9v0FgtNKREPy01ODkqyDFYXbUNH8N3yfHJ9FdmkrH9LdrR9sd0dtASFw2Mjmxw1541O/bUqm2zu2dRUNjlC3mbjeaNyOFog28BSIksKQKM40ZBNShVvCwnZZMO8NQ0fnvdymxPJman6gb5eha2nP3szDYn0XWENX22yVnJpAp1CZJeLFzTyXLmQbqZvWYSmQQeIJzjz8LqTi6czXn61yTCf7oo3m8qM1SbHvLmf9J9VXguIQ+Z1ntE+dhJYhhKmj839uEQE9OSg7bC4i7hRQJyZtzO60BmbfIyg67E8b144qjH1pJC9Z0UmXbytZA9DAtw0k85kB2xQmcX4A0tk71nCPPDTzSKMG8/bUM6bPyHTJodCuosSYRiSzEVJiYcNb0AfyzXZ+LVCjFXiQ6aKQd2yxZsXkKaScFhEAieYwHcdiee/8byNKZsE9DxYPKxfk1H/vuH3h3rebAXE1nUrP5xrMEEiLNdZ29jgYnqrFxUg9Xw31+bds4YN2Mkm2eviboKm2TNIu/86ssnFNMTtLFTKebtrJZdmz+Bl7MNzHSXZJD38t7JJiZBu33U6B34FlUhZAFUBJ6T7gz7zRmWpry4izKchHrY5SgWf1P06w80s2H3WFpUZ5Nqh1rXpMyd6Fqjk2SRgPGltDApWhJGZt4UW89YZFjfRiPR6wTgXbzagE1gq24E0QSsBtNj13TbT8EY0pp4Usj7BPRZJ7HmzUbzR7qvsBnzXdiDHHliics+G/Slpy7w1TYGDnLcmpNt3kZXVgWk5zSvEgUfiAqTM1SMVb1SaFV0Brq/W6VPxwdKgblms3yWFLV0TeJhKMCrd3D0B8/bQMm8j7ttsiAAAIABJREFUF286kS08yEQryGCyIAGx2dr8WgCQPpHrTW+tSKS6KKsaD1vJwR7TG1KUqsRhbCQzQic3RHrHu2dNk4ZKrXlNhN0hzpR5M2BMZgFeXYR4Sgrp4oQWeqbqCdd1pIaOdNH1WC0aBos32j4tKkS+23phhfL1LiiLGphPm6QF7+1FiJtpgLrerUEyIOxYqPVZi69NmntXcQDX0WNwRc9w4Lm4jH0z2SS1MYQMJUwXVXUUz5uOl2+5yTELPZKRaLu5d2Kcizcb0MkYOkKnAp5PDpG2mbe31e8GKMjGUrh+jMATMw/LdS7XyRaA+h5kp5W1xdsxogIAOZ9gECP0DoeOJHkF1wGCmGGQzhNSvAVkyco67GPZBIpGvkt8WMKcN8JaTEIPceBaDTleNrIYOI56p09lGNBMlXlrwqZdiSVfhlEpEsCPmLl7Xay2OQLPwTTUDxmWwtRyZ9VW8Wbbe9yRrrcBypae4cctmYwoV7zdkrD4VDKKpszJz8oybwD/82yYnSCiB35O8WYhaxMA4sDDNPSUGRPfdXAR+W0jTfb1dA03zXkD0BZgslh2is7FNERaVNhy9rq0KEkDzZccL98F9S9KDp/hgTJvN7OwZWtUP6+baYiLyEfgOVaDusm1A1JMT9WGqXQDvkXQkYt2Qb9LQSQhm0wfyDrwEpm3plgGoDdg6QXjXLzZgE5gqWwH0hSx5YwhWcP5m4r4mvy3hOcNfozY947OvMkOLaE/NzrzRg+nontGs9oCd5B5i3wPjk+yw/Y6fXXd+CHI/Qb2N3e60bTMG0+uU9cN6002mhuJKWoq2BuKoNrp2y6BYLbrXPMwe0ddNilbiEwkvGO0mGbk7nXxsCUB3aaeTyHG8LyZDisB7HuPO0OjdsybnWd42UrlJJpNqooTWrxKed4k9tRmjQgadoAXWbGU9AvJgExeVGNM5k30Am2kyU4NpoWIjQbcYhqosRa0WJiEO9aD85wleaeBBqgxb73JoSbM2+vnDJexj8j3lP1fO+aZrFc6UQM8rNZ5+57mEj7CvdduclzGPgJPfGyfG+5ryYGNgVO80e//yOfZy8iH7zrKxdtuP7a8P5wY5+LNBrQ9b0dgsGxnDB3Dq3dKeAEQXkqxSPAjRIHH7UbSKWeibBYZUOmM7Mb/uu3avhzmjQRtH06MTIuKsGqOQzb/7sZfZiTwuokKoD/fvrbZaGJ6cOAdGtLHRnJGnmGd4E8W6Mav3elTWRNm75BioJB875R5k4EU80YL8eHpn108bPJxM94odKb+8mBNNmmbedsdlmxLf5cdqZwQqooTlWFXUswbOVAGzZCjfvxIF7KT+mSwmAVKawb1UAG7NVzW93a3zuA65nJPQL3oXG4yXEY+Qt/dsR6cv5us4U0DDVDzvDWfJfXLmcomabFLp2zKMm8P2xx1vWN5SMi3ne9WVlR4Sou2mLhR3HuoX04GN1O1Z7SPnY1BYtrkMTKLgbaYVvHyEQ96s/dQJYyt/eHEOBdvNhBfA3DkN7E8AfK1OM/JBmwXb9Tz9jZjMpfyb8GPEQcud6zxOiuRl7WVju+rZrS99Mb/nMJ3HVzFY3uNJL2VnHuW5GXLqhH2rLNZ0GKsCekG9rvsSZd582O5LmGz0Sxm9kKO242fftaqnb7NvfyaQAsx2YaRSiEyvSHKAB46zJtorDdl3kbH5IbId0RTT2VQleTe2vK8AfaLt+kt4sDDJPCsNSAoMyPteQPkn3GVDn3L6nHuWbMuhBPqeeMxb+T+2HgOZTLP9n/3rqFDY1tUGnA3sxCea85aKxdv6wzzpuiUaRIkebnPvKlkveXUv2hHNknVJqq+tX7zQpUd44FOhKX7gyo7ticBFED1s+6DFs9R6ANexP8stwpebUMspoESE7oXezK9Ffto3yCcizcbcD21oO5jZqXZDIit67dfNgnIFbwN8xYHnlTH10bn9GpCZAOyo6bvmo3ftbDxc+EFZPqoxLRJ1j1rmTfgcOgILcaawg/Y77LTQ1sUNGZ5HvPWO0CqHsR42IXxhrvfocrGyzZG2qBuSemkqmwye+Kzes1nGQWeMKR+tZU/dBhBZ8InC5t7ALVlz5tt2SR9hgNrvhzZIODu75e+30rTVCWuXaQAHEQSPqnlOsNV7MOXkJyJMNcogigD1KonZKXvz6m1nM75jMgmeUNHumhjT7Cb0sljoVrmrZVNqnvegsgC8/bcYd4Up4O2DG3n9dYbI7PdPVW5NrFfyDUfTBUl9LsU+83nyWXeqFd7fDJiociELtcdy4rN/eEF4Fy82YJKl/1IGmEAdgNik+MYU08OGZ9gwyJNAr7nrTXKWzi8Oo5Dst6kJTfp+H43CtFzVtfkngUTxMGhTyqlfgngcOhIy7xNhpm3/kbDk+v0GiemHcouDqaBqcr4Ol48IVSKt3xLijHZa8swKt1pkxJRAUeTTQJ21jt6X22sddaZtzsSONv4cxdNhIgNrEb1vCl06OM5AEfwDDY+2NAHwD/wSwePS0BVkrbc7AZWXTQyRGnP2zqzltN5Mw2RlRU2mRyrteowPTvvGPs5SynzFmgwb8U+82YS0k3uGdn3pqGH0HOl1/i+N9LUO7Z/7f3GCN17pIvpdS59jriZBVhnpXbkQsu80YaogpplTCxm8qHreUlkqovufgy8Nb63c/FmCyqZNyodSFPQgFgbOl+VaXhvMiYL/kGrLEgR2zBBvI5vm/FjYdokQGQ30pPK1tn4fjcKURBx2bxnP2o8b4ch3XHQkU122bMO80YLvO7r6UazG1jCY972fTeLmXoOEAst89bt9KnI+FT8pLR4k1lzZDPeKGQ6lPkWCOJm2qTcwJLRMbHYWaXFmw3mLZyR2AhbA0s296S4ccn3RbUbzcP9Om8nIwoRX5P4CdV9T2b/8Hxyfe4zmBAfbLMmcJk3BcmZCPNpiMekQCGRt1nX9V7Op+M4eDULpdUT951CxBT0Pcg+K/cdpofGfPBemxRNXIuv4XlrmB06IEOXeauqGvfrtN33HMdR8ij2vZFUpidbYMlce94pDEUTPPder/AMyxTbPNDmaOTLWBHumhiaa63fpYKFwoTOg+FLNveHF4Bz8WYLEwmfCMURNcKYzMnBOd+YX6udFvaWM28i2WRbTBAJIG/xbTN+LB0cbi9CpaiA0WMCKET3jBZjbcHLYd76xRt9doNJW+AlA8xbFLiAH0maq3eSM9UcIBboZ90apFU6fWVBijxp5q3xvMkwb6qFiGgQRZk3zQs6bZL9/JdVjaekOBLzppG3yYLN4s1xxA0hFfQG2xDmzR57vJiFcpNBHUddceJPAJodJYJoWmuxBfzhNaGPvalzhqDXWUmsGU9pgaKq99b/24tIWj3x+jm1toZTuZ7sgX61ztvX+J6Lq9jnPmcHzJtGzpsfTeA4+szbqom66N4zFWn87sC/k00WVY2ntNB6P/vXpkHx+1JUmfeW5CU2WSkdMm+a/5gUJQLPIV7L/n7cB80sPkL2L13rZIrpg7NXu69ZnAFxQpyLN1t4ycwbYMdvoTIt7E0G9QmyFgjaUWwmJ/IODfe9Tp4pbmehkl/ixpJfQgjRkJfOPSPxCsNRAfRn9geWNP+7GZBBf56iLd78pusrYt4cF4hIl7D1RFhgLmhHcM/zBshtFvRgL8tqx9eAG0gWb4rM20Qgm+w0LyLfRcbpkj9uewXtmLDpaVC9ZyLEEkOQZLHd9x0vpoFF5k3eVwNAcd9TzAgVFYZ04q8M87bOrT2DKtl6fQ8VQBpwMsxbWpR4Sgp7xVvzvmWYCzoZsbtvkZw4dqGRFb2oAJWct2aNd2hDSJN5a6MVOmzlQsH/db/JEHgOZk0mJWWwbPjeDoehyF971xiUZd7ETCkPpJlK9+NILJs8khprMQ2QlzWeJYrpg7PX2fN2xiCmC7LRyNDrG8WDmglsBsRujsgYnhLxHChTdrdpj3nje35WGzLq+coS80C6tuIFeZuVWGelNb+EECLP297QkcPiLcmrdhjJoWySsnaTwagAWjzHrT5f4Hmb3LRh1ao5QDwsNxlCz92FUatEiKiy8Y4jH9S9oYWIQlQAwH7fnWJaJJuk7MRRmLeokfHZ8DRsXpMi35YJ3yrztl8ELRRkfCKsNrlao0lVcaIyYVlUGOZbIJjAdR2EvivwvGVWfMcAlLL1hvLlbmdyazg9fFqTTc7k17p2MuIBg8WfNrkX0q3EvNE1pZFiazJvVJXS3fdUJgqv1uT5p8yzCjsmwnKdYRJ4LVOswo6phszfKLKsfZDAdepBn4iLtyOpsRYKctAD/66Mj/YNwrl4s4XpLXnAZeSJmzuSJeYf4WBtMyD2veR5A9j3rFOITAYKkS7uNxmuJ4GVUc8A2ZQ2WYlNxu88UXbuxXjeumzNkGyyz7ztySY7G7sopNsXSDx6vjJ6oLOxOROZUSeMWmWUug6rPXu1Y4h4UJZNCuSHxU4CK5JNPhyTeXObYsuWbHL6qi3yjSH6fqig1+mmhYEN6e99x58lhanCRFXVbFNRYdgMjQJIxiPrOaSSMxtZm4Cad2yIeXt1EeL1cyqUft0NFCImUHvfh0XnYsovglLKvBnkvLVDkHSZt3bf6zFvkut7//m3ybx1PYTkfcmzY32/nAiq/sY+ki7zFgimTfaUAGNC6RnuyyZbH+25eDujC5XJW6odSBPYDIjd3h/NmHpSiO5ZKwEUe97IpDF7BdQryZygduM/pmyySMRsZTMxcjCku+t5G5o2yWDe2pDuwFOWeKhIoEQ4OPiqyDR0JnbN3pH3vPkTMjhDBn5Eoh9Ya1nO/yy7oN3PozBvgJqMjweVaAUZ2MrbrOuDBsTC0N/SBfW8SUPV86bS+BMVhk3WIIAmLH54HbbtO1ZhsIZCz28vyKCKtWDqI83ztNWAu54EcBxZxvBwSvJiFrZF3RDIGu6R6BjH08p5IwNo+A1RHnb73j5juNpkqCSGUpHnf7dW7Zp7Nr5b+QGTSf9/Efp+ORF2+Xaassmi7Ex/lrAiHKt4U1jrBi0rtvaHF4Bz8WYLSl32IwZd2/a8HcmYelKI7lkvd4xrlF8rdrIF2OUECYq3NdX+H5F5Azj3rFvwDoV0NxlBwEDO21BUQMfzVlDPm7sL+GZ1tXsSD1NjdxerfvEWXRPpnWxDB1BbF6SLt6YQUfneTjiH8r5smDOO+qGVTR7pOZze2IsKkJWZymCyALYWwsPzDZF073ne7LDHdV2TZpMKSzq5kY/DUO3QT2/Idz9jqFmarEEA3HV4d4iz00Cg11GRTXaLoJu2Acdnpmw34DzXwfVELuR4KJ9UTjbZiXtRynnb31O1mbfnFI7Te9+zEFUNPCVin9SyJxu29d0i19jfH2hDS0U2KXuWiHwPs9DTft97+zFvCBjN/j2i5w2Ql03GgYsJtTEAas2mF45z8WYLKv4WVfmICWx73t72SZOA+J71mLekKJkSmP5mYArqfxBt/FT7/+qYOW8A+57tTZscCunud/qGB5bsQroHct66fguWZKfHetMcIBshx/fr/a7tTsYnuSYAGsybpGxStRDhsR57EicPeVkzoxYejul5Aywyb+/aZd7iOZA+AJV+fhWAQem6qUSK4jEpUFa12lTG6S1Q5UD6xP+5qiSNHaWBJYJprU3WIEAyHtnM26F00QSTwEPky2WHLdfE83wZ76IXaENNNDV4jAbcjWSsxBDTczMjkv0hVqwoKxRVvS+1U8p5S8gAJtcTsvk8vG4C0bs2BZVBLcv1PvN8GfvwXMfOwJLetX3PxfVELsZAVTYJUKbUAvMWTNj7afpEvv9HOheqDBi7Xw+cvc7M2xkHUJZNHol5iy6JhMGK5+2IjOEpoeB5iwMPdQ1kjGEBS9XpbQJQOYi0bPLYzBvzntGCd4J44MCfFlUriSQa+6GBJTFCr5FN5gMDS/b8FgMHh1ZytttoaA7QiiMHksXgsIfprTwb78fyY9QBUpDlGyBb839OpxCZ3nBkkx2JU3A4/bOLh82Rizdrnjfbskn6/TBk3wbktbRhYDp05yBkXgayipPtCkCttn+I9tQmaxBAMwSJwbwpshYiOI4jPcGQsi1up5h4pcC8hb4rl7kniflULuR4uTksFuYc1oPuf9HekAvFnDcqgRX4aHm4fz4MNZeV2lVVjdV2n3l2XQfzifzAEx6GWG3iI5RjcGehtyuOJSBiSnnYszH4nEL8mLFXAK7iAK4jOXRnyL+rMmDpheNcvNmCKBupi2MyWI5jz29xzKLzlFD0vAHsjCGb+UKAvGzyfp1iEniYhvY2fi6E92x/YAmwO/BXVY2sqNphJPAnpJtXNjKXDvPmey581+mFdJfwXQe+57YyqkGZR7YmmYe9A6RK8CcLVVUfyGIA7GRlIuisCbS4ELFv69cazBunQ9lh3mL/sJjuYrXNCbvpH2mroe/bJFQ3T4D0EZhZXKNteY8HBtvsmDezBkQbMi+ZJUXeh6TiRIdZFl27w7zxDvzt4AKVv0sAMjZfrnjrsyV0DRexB3frDK9kM/ckcTOTZN7WGabhbjIisJN+Dr1+r4EGHDbgRCi2u+Ezggm2PNyt0wOZaSt9FPzdTw3z3F/DZT9rHoqywsP2sLmn8hypMseLWYh77ZDucvfZ920MXRwz9gpNMS25X9/3/IsA1AYsvXCcizdbaD0/goNamZODwTEZLJpbZorNe6R4i66akeNynjdgOGNom5VIi0qtky3ANPQxDT2pru3RWDdAzSfY5jKRDfqga9tnz/JNK6kBDrvsSTfg2+cwb4yNhnSjzTbnp6RAVQ/IWkRBwxRbDVZbpniraz3ZJM/z1kpgo9YX0ZfBUjxsc8yPxboBZH2qciB71r/GxnLGG2DPe0yLv84zTItjc+ZNLUsKgHyWYduhV4kKELB6+bbjeWMPuWglZxZ9l9KMyTo/aN7Rfxb6lp9TazEBFPOpXKD70NRRXqwKbabtfFK9rE4R8t3kUDJtUn9gSX/fk50ozPKVLaYBd1CLDKh8/JB5UyjeFM8RC4N9bZ95i9jM2zFjrxrMJb97w0oYgY/2DcK5eLOFdgypqAN5gqw0UQaXDAYkZ28tHId8ljLM28DoeopdaLPdw6tMyOvrdWZ94+dC6BPcz/EBdveMsjY7v0RTgNFuX5EAwU5O2N/ck70uYbz/2i4YEg/ZbjQPBwHdFFMFz5vqmkALMt7QkvSRsI3KsslbIvErB0z+9PnvhqazmLdNbi3jUAoq3mMWVKMVZGDLe0z3j85hicj4zIO6W+ZNSTZ5DOaN5XlL27WCN7BkuclwGflW2V9ZPxFh3vbvZxx4uIz8dpokC3dr+w24m5kca0EmI+5/b1u/0VDx1q7h3YElip43CQmsCK+f0wOf95xmtYnUKow13ER+SNEWhkPXligM+345GSwk/Y1DIDaGrhKmGN4Ljsy8AWR9kvnu3Q8Ni5tIyrzfAJyLN5uQkUgdWSMMwE7GUPZMOtrvBc8bwL9nPc8bMCybHJrYZQM3s0i88T+ne+OSR0d0RSYrCj1vh8Vb0ua0dTZ+oMO87bwt5Of2ZTUk4Luz0QDDXV/GOH7SjTbrrDKngVHPm0jGp8NqTyWKt7Umi9SyHgPFRrE/fAYAU+b0uM2Pk/FGoeI9ZkH3nvFgK2+zHViyz2CpZFmxoDrRDoC8522g6BSC/o1Dn2Vd70nteFEBy3XWHuBtQZR51v5uRjj47UUo5Vu2KbkHCGuR5BW2gpiCoYMvb8pm0s3aBPhDLoZQmDNvWVHhMSkO9r3LyIfvOsLPa+f51GPHeDjIHGuvLfscKU6BbX7XU1IgZ/jxeUjycl8CCwzvqSc4z84l1rqirPCYDMQ0qdibXjjOxZtNyEyyOUGnwornTSdE+E0G7551CpFJyJZNah2GJPBqJrfxH7V4c10+W9mV2lG2pjnwSzFv/q546/tb0qLsGOWj3Wv6YBwgb5rNWSYHiIWhMN72d5WZWMa3udOQTaoUb6qySXpwHljP9nLe2M8/AKy22fGGlQDigHEZ6N4zHmx53rb35Hvm7XtZbbED/cmIQsQ0DmOEfc8LSFNo6NplDtRVe7AkawKLebM78RdossO2OXPKKtBEL6zzwcLx9iJqp0myXjvEIpliN/peXMj0m468wOpB5k01563N7HOZTD4PlGXqK04cx2kO/CKf+HCBNZ8R2aQoVF3mvQ153lgTPLvQiRzaDTJSb+rsDRDjNkTvADhHzf4lMlb+Z/mwzVHXA/EgKtmrLxzn4s0mZDIkdDqQprDhedMJEX6TwbtnLfMWtrLJoaDu3bjlMWST/I3/bm3fLyEE9551pk32ZZPdnDZgV6jlm91/04IOQOi7B8zbYeE3cHDYspi3QDoHiIVdZ3XA8wbwi4mqJIyM6ncrnAHBjO9505UA8sa0F91CnM+8Ec/bEZsIovHyMhhVNmmBeRt4Tm4sDFWgRU53MqIQrkf+NhnFiRfKB8VTsPbUDvsLUDaeHRUwRvFW14RZZmGTlcjKavB33woacOvGL227ASdbvN2vM9z01jI6+XLotfT7367DvGywIewxb3oh3VSNMiQ1lfGtsSIlbqYhsrLCRsBWyl37kNUj/5793vKywlNaaHje5MPk+0jzcv+zBIb31M092fdd+SmYpqBrHa+YZoaa29gfXgjOxZtNyAwnOAnztiD+lUpPRw7gNEXnKTFZSDFvUcD2vI0lm7y9iHD3zF68HpMCeVnj1TEHlgCCe5aQITCe33b0aKe8nVQW9AowWiR3xkjTn+sWC2lRDkguOV1CyoI04Hk5ZMFk3mQ6fckDYRF0WO3ZKwHzplu8cRisvUKcHxWw2pxKNmnoefNjILyw854AwA9JoW3D8zawBs8lutEiLNeHkxGlIKs4md6qBcUDbCtCZw0GSM4bLyrAZlwLsDuE89YMnofw9iLk5rzdtYWIbeaN+r/YxQKRnBWD+xYramCXtdnNBlP0vLUSWL2QbuoDHyp4FxJev/t1Bs91cBUfstr03+uCxeq1GXScay8ZhZ8IJu87Kar9zxJgyyaPrMaaT0OkRTXYMKfYRV0wPG9n2eQZe3ipnrd4DqAmIbG6YLAWby3iOd/z5riA63emTQ543ugCYlk2djsLUVQ1HrfDTNEdpwM5KkT3rNMlB3Y+iQPmrc+edUaC05/rFstEn88o/LrY3JPCrdcllO1G87DcZPBdB5f9TCaZTp8Jqz17R042OdWICgAYssktYVFct+3ODj3/SU7Yg6MOLJnMATjmssnZO+qFhgg2vMcc5u1hm5tJf3VjTaQUJ0u9xh+rMGyzBncDS5gNhPWA98UQMqzGbnrngGxyFuF+nTI/r9cj5XTSz5e31q22DNYC7OFOh8xbrJHztmPe0qJSlinyCl6ZyYvUV9aPZqDPjokverUhmX3TsLf3zOSfI13ZpKoXtigrlN3AdVFD9MhnwhuJv2vJapzYkNW/EJyLN5uY3gD5mi8X2NyTyXkdJmF0tGOqDbq+7znPWyMBHGIraSHiOJi0AxuGmber2Cf5YxZBfRCvGdLJXQfyFLJJDvPW8acAO58E3fjjgLFZ9AaWRAfMW6dLyMt5Y/jKZDZQEZabHPPpQCaTzCj1dgiFDvP2jlg2GV8T5kcFvKlcnWKax7zR8dhHZd5cjxRwpsybTb8bhQ3v8XY5uAbPpyGqGnhM9A+Yy3WupxKQVZzo7B1M2eRuaBRADvx5WR940LJCT3Imgky2HnMCLUhRVtW7QqkPWoi8sryGzyUaVazBHfT1/KiATgNOOeetv6aosW87zxur6BREBawPfX5Ahx0z2B/IAJiBwnAqVn2w/HIi6DYld4V4v5k6tKdqNmUMwPNeUjAbJ9RHe5ZNnrEHmclbDNnLqJhY8Fts7gnbdERj6kkxoWzl4+G/K9K9fCGANbDkMOPHBkQhr3cjdW2FmMzZz1h+yLzRDZ/eu8PNovG89Zi32HeR9pi3yO9Pm2R43ga6hDvpisnBlyHNkhmlbsLGz17tcsmGsH5XnXUDgHBK7iWL9Wiefx7zRou3ow4sAXYTPnWhe89EsOI9ZjFvYvmVCKzJiELIKk60ijdGYZj3PW/Dg3NWW4ac2RBSDBZLuoUdO3TPaMDxChETzCVkk0y/EICbaTBYaOxCujs+KdWctw7zBqgXb6+fM4See6h+wK7o5Pukhp9/W829oeJLhh1j+eVE0C3edhLYnueNlZ16dOZN/HfxGidvS1D3uXizCZnhBCfQCFtj3uJDydlbC949G5AADo1eHsr4sQHKqLGCuukwE9uTyoSgsjAmWzlc8Ladvr7Gnnb68g2XeSNRAb2xxizmbeC7Z2dzZuTwUBmflGxSl3l7lx1FsH5Xf/DG9GaYMSzS3UGLw7y13c9jDiwB5IoJHqhs0jZ401hlkG/Jd2FyGHS9Y1T0GhB1XRN/os5wJcqO8WRum+HGiRCTGzKptS/Ba7MGe1LsXvG2XDMGCRmCFkG8NaOVbg2sC6+a/4/le7vjvNYEgefiMh4eOkLBY3rm0xCrgcLvgHnzJ2TNl5U+FuleVED3mrIgoeYD6gcQ+VxR1XhO2UOpWP7chQTTIwJraA5dG1dcz5uebHISeogDV1nuecC8+Qzmra6b8+zhejQmeJEVFMsNKeT7MlUA5vvDC8G5eLMJGbO8rnzEBHTSmYnfgsFavLXg3bM95q3p+A50CbU9JALQQSTMjf95nIgCIeI5GbyRPR3+u67Uzt/3CdJNOmaxZ72BJdEA8yaX8zYs8aA5QKasxeABUUbGZzLEaPYOCVBlfbfXr/UlgKwOZVfiRLvkL415092c63pE2aSh543jjTQ9YK6byYhazNv0hnzfKFPeR1WR/UPL88bwqLTTJvlSO1qkaP1dHFxEPgLPEcgmczjO8PNPmTfWxMnXzykuI3+3rlmEaDIpa+oife1TWiDr3eeDqIA2G0zS99bJ7GuVGYpxAbxQcxnG8Z6xX19PAjgO+Tx1wbp26BMTnSUnAAAgAElEQVSmcAzZJECee9V97bCZyvC85Rvy/x35XCiz1tHhS0OFvNSApTcA5+LNJmSHExy7CLLFvL1X/G4A/56Vuy5h7POmTY4zaY9uqqyN/+45xfUkQOgf+estZCsbqd2BbJKxWbQ5b9t92WTg7hXLxPPWHHK8gMh7mebqw2eY5AAFRiHH3CwpUadvew+4gd50Q8oQsXxvJszbhOE36kqc2ubFEPPG9s6MCpkBGiykT+T7PQbzZup548hrbzQlUhRLgwOiUHGS0mmqGvsey4rQZg3uS+0OmbdxJv7S7DD+oAmScegNRC/QIoMV+XL3zC5ETCEKOb7nsJX0/6NyVIqDkG6efL2PqiRZmDTnzYR5Y3gERVI7wjwPK2U818H1RDzwhAfe1N35bHiC5+61GeLAxWSIRRJA9IwOoZVNHjRTe3vqiSaQ02YIb63jWlZM9ocXhHPxZhMyY8F1wnhNYSMgdrN8bzFvPJ9gh3lzXQchIyBW20MiQOC5mE8D5sb/mtOBHBXCe0YL3h7z1nreeMxbN6TbO/S80cLPccjv6Zvlsw25HqMBsZiG2qwFCeNlyCYBscZed4w6wA/qrkpybW3ZJKND2SmmQ29/+EwXlHk76rRJwMzTMEbGG8Vk0TBUCoMcuuAMtpnPxAcaHpYctkUIkeLERBbM8owymLf+Oszzb5lCxGrcc4KVF9MQjsOTTY6X03kjiJVYbTJEvtsO4+qCPh99Bot+/+l6wJWv93EwfIY9wZmH15yClxZlLIbrOSXxOqxMVh0Gi6KqSGHIegbFz1GufY5gTQfl4YB5Y+W8nSL2CoDvubie8J9hbuyJiTLjBeFcvNmEaLJcWZBMp2MXQX5EJlwaDSw5QdF5Skh63gBSjPQ7vkleYpOV1o3yFDeckFfSgTxF8Sa4Z82G7nsufNc58Ly1vjXKnuVbImPrMW9RJ6S7rmukRSekG2jGVPcODYKoi8VUP+T4OS1QVDXbVyMaoLEx8MHyirfNPYDa0PPGyNjqNS+Ghgs8bHO4DgYHCIyKSSPjyxgyPh4ogzmK581wcBRHNkmlv7rsMTNkXgYixYlJFAYrl6nNedtn8/sM8HJE9peVeUaxakbPD8FzHdxMQ7Zv+XkcyT0gXuto0TkkOWMNwUiLCqHn7gLe24nBEo2KfL946w+0kkFd17hbp0yf943A17ybTsiWXepGBTwmOaqad20xg6vLHOu874NmKit+5xSxVw0WAqUM17LC8tG+YTgXbzbhh0B4ye5AJisA9WnkhzFnEqAMTjFo5ZSQ9LwBZLM5mHKmaTKWxatZhNecjf/oMQFA53A6ULzlvYI32IXqJv2ureOQZkOe7DaMXkh3UdUoyuqw8KM/qyjxWMwCA8mZ4LMWySZNpNStbHKoeKOFiK7n7ZZ8llXvEJVvDzyIQ7Lh1SbH1STYHeiOBZkJnyyY3jMeTOXrnMMSlfHpssfMkHkZiLKTTKIwWJ9lP+eN4b1crjNMQ28075jIq8Rb/28v2A24189Z6222jcWM/5wsN+xcPJbfaE/9AOzWehXmjRElI4NNViLJK2bTUjRRmBeoDugxWAfXZrF6oufIwDsvuvYQkv6eysp5M2nKGGIh8G3S6J5BvCVZb+fizTZ4etoTPuxGZvmMGlPfQ8VbEBO2R4Z5GyjeWhnSSH6f24uwnUjWB8+4PSro4XSw4E16Be8uVDctSvius5+H58eka9s7pAFdT0TVbvBxn3nrHxoEEo+FwAfCw+6z5skmBZ63gQmCUqB/z5DnzVQCOLkBUBO1QBe955+G6vbxsM2tB9RLQSayhYVRZZOGg6MEDYgbkwaE6BnmQeR5M+nQsz7Los/WDHsv7xlT/mxAhjHhFcM3s3BQ+l5VNe7XbP+WKRbTAOusZDJbzOFLYI+2P1A/sNiaIbSfZeN5C9SjAmgRzCpyruIArsNm3nayYYYvTcM7tru2BKvHGaTC88uJMJ+GeNjmB/mHPBzaGBiF+Ik8bwCfPW5lqqLi7Q33vZ2LN9vg+S3aDuRxR6uS32lgljfpnL7JYOWW9Zi3SYdFohjLKE9BuraHG39RVlhustH8ElzwvJVF2pM+ep1pk9VhZzyY7DNve8XCrng7MMrTn1WUeNBuNC8HiIV7kV9oekMKUZaMz2QYkBeQ9WSIeTMtRFge3t70z24h3sVqmx9/0iQgN/WXhfaevUDmbXNPlB2MwHXCvGk2INYZczKiEJRxF+17Os+4HwHB7LAw7DV12mywAQXEWANzqHSLtWbcc4oggEycHGLeVlsisxtzYAkAppyOGXsCnmyy3Fc/sNiaIbSfJT+zj4fXgngc1yXMNIs9EzUvdBis9toiVm86PMGTQsTg8rCYBqjrnf9YBgdRAZ4PuP6hBPaE59n5NGCudTuZKuO7Z7I/vCCcizfb4EmkTqgRNgqIFfiF3lpMFpLMmzvgtRjPKA+QrLflJkdRHhr06xqjSW64CCbkvgwWvNu9gjfq3DMSst1bijjMWzfT6SDgGyCHgANztcjzFghzgFhYiVhWnieors0n0NKstz7WprJJlt9on0Ul0Q3DzNv1seMqALm8TRbWr4Hoau/vswZjzxu/yL8x8G0uNzlzMqIQnt9k2HEUJ65P7qsOhgYMUL+K14ts6T2H9+vxvGM3sxBlVeMxOVwzto2Mj8e8vZqFg9J32pQbbWCJYPLics0uOuPAwyTwDmSTaV7tr8EtWyPheTsYWKLOvN0/i0PNFxz/l0j6Pp8GSPJqMM9VBFFhOKd+vO3h51GUFR4TtoxVBJlA6z4OQroB0njtM2/be/K9947saQZ/rROevUz2hxeEc/FmG7wMiRNN5wHQeN4Mmbf3kmwSIPesLxkDDpi3KPAOFvX7kWWTtDjry1doZ/EknjeA/Zx1pk0CROaYdgaWHBRvwaQJJaZT5boh3R3mjcom+xtN34zcSjyGu4Q7L4c6c0F9FFyDNDC8LiQPQF2asdqzd4D1wLXX75LBL7qd0QlHstZjUYeYt4dmVPrRYeJpGCvjDbDjeeOswSa+TWN5oWjfm9zoTVMFSAjwwTO4JYWbS9YC1pALk2EPIswZ/i9AToZ6exHhMTlkXKgc/tVIRee89X8dvu+yqvGw5cSeYHhYRFqUPdmkAvPGmDapMrCEyk95Be9CwLw5DnsyLotxlEE7NIchyWxDpwf2noctacbqniN4zygLB8wbQD7PIc/bidRYi1nY+BwPnxFhLp7MVPg3AOfizTamN+zN+YQaYUzm5l6LM/NGMOR5623Aq9Flk03Ia88zsevanoDxANjeys60SaBhK4WyyW3HzD5t/9WuM1t2uoT9jabX8d3eA9E1kRkOwGRzXm0yuA7xVQyC1+mzwWrPXrFlk9NbEhSuA96wiN5n+aI8b22RpFu8jeB3AxrmyTFYh++4zwn1bepIf1cCiZ8QIsWJSeNvqDDM++sJZeMHmLeRGmg3nHgGueJteM25a1mkcZm3IRbqsZFscou3gWERZA3vMm8Knrd8fygV67PkgUYu8KYs84ZcLDcZ5hzm2ax4y+G7DnPqLi+j0VTBs7u2jmyy3xAd8JGf6Ey44Eh/eSHzANhNyTcM5+LNNqa3QPoIFANf8s0d6RaGs+O/r8kcyDd641FPWXSeEiyf4AGL5B54Le43GS4if7SgbLpJ9T0Tr2nX9mTF24BPkIawHgy52MkmD+4T9a31/BDAvkRqN21SYmDJlM1A0YVex9dwvybdfeZURV6nzyQDi4InmzQpRIYYrKoEqnzAv7j//FdNB/8kzJsXkEJdy/NmeM94cF1D7zG/072YsmV8Ityv+WyLEFzmzVAWPFQYDsSHAPs+KSI5K8Zn3oYO3ZygawqqjuhLJ3cs0nhRAcAw8yYa3EFf3/+bifR9gHmTmja5r67QYt6eyX7LmypKGEOWVFTMNtKfU8Wy2R+GohcAOQbXJCqAdW0WWitCvyHal8CecAL5gsMe75g3xjMcxMM+2jcM5+LNNnjSGPqw68pHTNC+L42u75YvOXtrwfIJ9jw/k3A4KoC3AZqCdmUPNn7KvJ1KNjl0z3qZTMAh8xaJmLdesQCQ4QSDnjd/gHkTHCDpQq8zUUw4FKH1vA2sCTZY7dk75Dta9g7tphLA8ALwwv1DeStj3fcv9pm356zgm8bHhmjCJwtjyiYBs8gW0TMsyLLiQTQZUQiR4sRk7xjyvOX96bWHbA0d0jCa540jtZYJPacNtoMG3DOR8I03JZO91skwhkNRA2QNHxpYop7zphMVQELN+feLx0zzhrQAet6x7rVZMQH71x54jgTDTkTQed+Dskk/GpZNnop546x1bUwT73v/FgR1n4s32+ANJ9gsTyc95GVwibC5O5kx9aSI50C+3mdRywKoigP/1rbPvBlMiJIBa+O/e87guc5pGA9g2PM2UIB14xXSvEQ8xLzlW8IWA3vM2960ySFzdRAPeN74IfPtJqfTWeWNJQZ2B1eebNLkcEuLjT7zYSoBdBxyz7prGb2v3QEyvndw0HpoNlCWh2R08CJbWKhKcg/HYt4AthRbhCIDsie+54122TUiL+45QyqkwDsMbQ0PedMbIH0Ays7fVexPPPVcB4Hn7LE1YwZ0A3wp3UpKNsmWvt9MQ73hMRKIfA+z0GMUC+J80kHPW14dxrUAWjlvvufCd52DIWA8kGxTQfE2C5EV1cFeDTTZdpznhMeyirBcczLH0GHHOIWI7jM8DT2EnqukKEkLooTZYwoHZZMn9Lxx5KDLTcaVqQIY9tG+YTgXb7bBlUjdnY694mVwiXDCDstJMZTLVPJZJIrViPlCAPFXea5zuPGvUyx4Er6xMeR5a4u3XrA5lU0OMm/TRjZ56HnbmzY5FNLtTxgSD/YzTHOAdDZnKptkgifjszHEaNoUb33ppA0JYP9QXgwPkOkftCjrcRLPG8CX8bGwXQJ1NXLxpuk9lphUvJix5VfcS2cl0oI/GVGIyYI0uvqH9bo2i8IAhpnrnu8YIE2E7jo89sTfy9iH5zqDawYdYsQ7dN9yGnBjvWcKVlA3PeTzfv+iyQ7rTjpOil5It0HOG8CeYMvC6+dU6BHkSe2Wgmbr3EQ2KWjuxYGHaXg4wROQ+zx4cBwHixk/R64PUoj3B4j1rAh5Qr7vp5JNNkzmUFG63PBlqgD09ocXhnPxZhui4QSnKoJMJp0JWIu3FkP3rJUA8kO6RRk/pnBdh4S8DkhuTuZ3A8g9y54Pu+TAQdA23ZzToagAqrEfKhb2Qrp7gaIAR+LBfobdhq3UG1jC79oCYHf6NveA4xFmWxe02OgWb0VKvLemEsC+/DDnf5YUu47xqbyXN0TpoALTaAUZ6DJvEr5j3aEKRgHdFCzFSfpElApGnrcB5jrf7j2DwGETQTh1zhCu62A+OWShAHJPL2Mfgcc+Yl1GPkLPbYdtUMhIAE3BCjleSbCVdK3rZocdRAV4IQBHK+cNIBOclUK61+J9jzXkoq5roWwy8Fxcxr72wBKRhYJKOg9fmyH0XExDzaFTYH/WLKRFedhM9Sf7EthTxl4BmE+az3KwEJfYj3kDlt4QnIs32+CNBTftQJpgYpAxdMqi85QYumcMFiktqj0t/Wqtn80ii9tZeLjxP4+/8XMxeM+G2MpdwZsNTZukMo3BYmGXA0SZt4Oub74lXX/6+7Nn4XePdKPVOqt1XeN+I9EpZ3X66Jpg4oNti7fXu/+vLURMmbeb/fddHHreyPM/zLydTL6r01k1DTWXgW7epsRUUtrdZ41DZ8FKkcNSnLRBvhaYt73ncN/zBhwOzhFOnbMAFoO1lFBeOA5twPVlk9lokyYpFrMQ9wPFwv06R+A5uOBIzhYDPioS0t1Zwx1nJ30XoRcVAJAhYLIh3VVVS+X5tUOpep/XNm+YZ8HndcOZVslCXddSKhxWzMdynWExC/gskgDKxVu/EAfId63LvJ0y9gpA6Lu4jPxB5u1exr979rydcQC6ifU7kFVFOq5vJPN2uqlCJ8Ug8zaw0QT7oaJZUeEpLUaVTQLAq4toQDaZnW5YCTB8zxhZbbTwGgzpDnqeN39o2mTZMm8H0yZR79g/yWmpqpscQDb+rKjEDBOr07e14BuYDcgm6f+eGrJILM9bT+J0IBvejus3EmLKkPHxYOue8RA3sslKnlUAIJW1eRn7cJ3h8dk8tAZ/U88bcPiM24jCGNpTe1mDwGFkxb3ExEdTsCYYErZFvP7fXoRtrhvF6+d0tIw3ChJYPcy8iSRnQ36jZOjAP5QNNoQiIeqDToyLCvP2mOQoq1q477GY6aXk8z9nsGM8PKUFiqoWF2+MvYd48cyeBVIYyr/vpF+IA6Qh2v0sX8AE8vlsOHRdKvZkyEf7huFcvNlGMCH+nP4mlqyIn+JUD3t0De2Mofeq5y0e8LwxJicCaIO66cF1dObt4jB09P45Oy3zxr1n+0NesqJCVdXDId3+hIRXp08Hr91j3mjxtjemmvotmqJRUuLBC3Flgf48b5pY+7uHijcb3614Drg+sBmDeWs6lJTFHJI4NbEPXeb5RTBvgJop3dY942GyIPtA9qT2OonDkus6mE9D5bgLU1/N3vs6YN4syKuGmLdezhvQMMA95i3yXUw44+NNsZgOs/VLyQEwtxfRXvGWFSTeYHTmjbHWCYcvYfec0NfXdX0Y0g0MD7kYQp4cSmB9VzoqoM14E8omh8fm038W7dc300DZTyp7bfIcqXvxZMC6NgvDzFuvED8x8wYQpcFwVIBEwcubAP2G4Fy8jYEhSpY+JKd62F2X+GpUH1ZqTH2vxQQAyswb9VvIZPzYwO0s2vO8JXmJp7TAq5E3fi4k7xmVOWYlKcAGO330On5Mnt/ea9OCyF1cBwi87mSs5u///9s782hJrvq+f293V6/vzXT3mxkhpBktMIAQSIDHmM3Gi3ywMVjIgWNnJT7xwU5w7NghCSY+cfwHTnzCieM4GMOxic0h8RJWWYDxEhs7doIZGSELy0ILQhKjZeZt817vy80ft25VdfWtqnura+t5v885c2be1u9O1e1763e/v9/3J1UXzY1GnEbHUy0ilbfmVnDN26qqdqkk1CKV8pZEzRufAcN98bHSObSEOQemc0/w1p+gVimF9l1KFSeYMAneLgJg6WYZNGK6/moob0CwohKGW+eUQs1bEq0wVPdSobz5FWDp+LtKylkUwYpJdBAEACd8aZPytbKoeTsYTjGZLapbwhkxSoFabDUwnXPMuc80Clg2uQhiOlgyn6lZZe0m3fL6Re17xxsWGFt2KNSt+YyTmaGr6qkcPOXYVm051GlWsTeYYD5fbpGgYqQqY7Aai/cy55o3QKxX/rXOSVONOogKc4BeE1YK3hhjb2GMfZkxNmeMnfN97acYYw8xxh5gjL1utWGuGY1OcO5/numHqgbKUSSR9rKuSBOJyPott2k04G4GcXuz6LK1UcXhaOqoT/IUKsoyOVV06wQrrmOkUnmTp+oyePPgNuSdO81hl2yNAVd500zx6LaEaqHqAxSEq7xppE2OD9UtDJJYE1onfTVvCdVv+VUPVZ83z72U5NagW6JSa6LoXRQ/V0ox4Izbb3OwKzI6fAqFn1XU45VSXIMehpyatxUO/6pN8Z729xv01bz5jaN0UxdXoWPXQfnXDNmYOYqtjUXTqUsZ9emUmQL+w6pdjfpdf1+yoco0ClhWa4KYLDuHmihvUrmMCngr5RKO1ZfTXHWzJ4LqG8PQVt5ayw6eQFJpk1XM5hwHw2n0NyOgjKFSWzQsKUDapNyvvbhpqlGZMDH2h4KxqvJ2H4DvA/Cn3k8yxl4I4AcA3AzguwD8MmMspyPYHFCdsieRPrIqcZzOijDuvCiVl9VKuRmVPU26rcWH191eAifZGji93uzft+2kjxRUebMW+7wBQG88w3TO1Sk3gHgf+R5YGWOo2pv7cDJXn/gCbqCkqby1m8F9gIJwT2010iaBxYdbzpOpeQOEwuZX3so1oLa52uvKscn7qejz5iqh7oNHZOPytAmqPQ5j1b54OsTtt9nf1jpA67SqsdTjKGfESCpVoHZMXfPGSu7/Oy7+JuDT0dK6UPfVSe2m7PgLiPf9ZMbRG7trxmg6Q288i06lhlirB5MZ+mPxYC3X8LQdg+Xe5FcupM16GA2rjGql5OxzI5VpFGBmWGKpgjcz5U0n4BWmI4vvD93siU7TQm880w4qATNVD1h08JzP9cxOonD7P+oFnoFlDLOxW6vb3wGqm+J9nxPt5nILhD2NPoUA4u0PBWOl4I1zfj/n/AHFl24H8Fuc8xHn/KsAHgLw8lV+11rhd2gDknHdWpV6jB5DRRh3nvivmaJ+q+YP3mSqxIrpDlHIzUpuXpds85J8a95stVKzTlA2cw4MwPrLyhvg2tMrUy5l4Dcxq3mTD1smyoVzsqq7WXjXhfGh2BATU968wZvd423VlDF/0Klo3VCvLBr2AAVQ3sJcf4PoXUq3TQAQv99mf0dLveo0rVjKWyLmSkEZJ43OQtpzvNf21YwqUu1Ev83FJt1pm0Y5Jhiea27SJkNmScigbdtZw9OveQMW1zphmR9ts84YWzBqke/7uv8AzmosZxqoUJrP6KdNXjocgzG9MoW2om7NUZ4j1is34NU/HHGdXPVSUb0B1uXhBHO+uumTc6+1gzdVGYM8ELUPYgc7whQqRzrNKg5GU4y9JkW6bU9IeQvkGgCPez5+wv7c0UBZ81aA9MM4ylsRxp0n/msWkgI4cIK3dPsLSfxNXp1T2zzdJktlYY4T5TZpXzN50ricNmk35ZbpYj6kPb06P9+30fR3gOrGUpqVnzibswzUIwMVVU1QEvVAElXaZBKBiD/oVLVu8Lh/SvYGExxv5HiI4IzbYL3LQnlbpebNQHkzSf2N6nGlTVDGSRLz23sgOpuK3nFLJhflhT5v0mY9TVS2+U7avMY1lXVaMl1yW9N8Y1XkdfGqUJeHU8zmXGvcIj3XlzapUt6mGsrbZBCgvOmmTY7QaVZR0VCOu4q6tb3+GMfqlcif7yrudRR7/QlKDDhWD5+H/lRU779Xbdgu56huLazSOdQpRfDUkef8TOj8vwbL773omrcYNdEFI3K2M8b+kDF2n+LP7WE/pviccjdhjL2NMXaeMXb+4sWLqm9ZPxpdcbI68+QY97eFI9yqaUwrjStGzVsRavXyxH/NlE267bQxWfPWG6NhlVM3a1je+AugvAFA47j2NXOCtyX1zFPzZoUrb0pnLMANGvt6qYl+FzUddvtjHG9Y0Q8OKiUoSVW7dUIoeWO7tUJSgUjDl16i6PPmNE33nJRfzlt5q9REwG6svKUdvMWtedMztuk0qxjP5gtpfFEkll4YlHGSxPxudkPnICCVNzEHZ3OO/cHq9UJRyOvmXTNMagj9B3CXDkVT5s2QPmtJoLLNNzGu6XjMIuT7XrkOaxmWqGreygvrSRjbh2PtOu+2wnlxR7M2sq2411Hs2GmopVJ4BoRKCU2qybw7R/UOJdXOodIEzGxPTRPXPdQT8Goqnco62jUjMnjjnN/GOX+R4s8nQ37sCQCnPR9fC+BCwOt/gHN+jnN+7uTJlDfOrJAnEt7UGHkCmaLzVSRSRTI4lXVOro9q2qSO8qZIm1z1tEwH+TucmreesMZuVnMuLw28ZssOnZcHQWmTMvWxt5RSI39+OJ1hOJ0HB37emjetB1+z2gDxvdFpRgDUfbCSVLWlyibbBSQViNSPix5McpNT9Xlz+hwu2rTnWvMGLD7wRzEdib4/aQdvVkPUIqakvHUVaXxR7PYmyZgrBbksJ6K8bYXOQUA+8Is5eHkgUs5SD95ay2r9noFiItMjZbrk9uEI3Va6DpmAOnjTbnuCRbMIqXYurcOWgfKmSIHVVt4M2uN0FT3PdOvKuop7HYVWzzGo1bGkmsybKm8imyVgPy6Q8tZVzGEjtdJfR7tmpJU2eSeAH2CM1RhjNwA4C+AvU/pdxUNV35LUCeQq1NuLvbN06G/nXpiaKxo1bw1/q4CMHlyb1TLqVsmteTsc4cRGLfWNP5Kla6YK3sTSI1MelE5lkgjlrb6Ucqno86YRvLVjPfjqucopC6STNAOSQUfvojicSSptkrHFHnWTgcggKLvKgNf9EwAmtvKTq/IGBDdGVyHX6rRr3gDz9PXZVLRq0Ng/VLUzUeiYVGihut797WRqYxpdoVbOZ8peg4A80Fl0/E09bXJFxUQqRpcO3QO4LDInGvbeEbdWr+1pqxKsvOnWvI0UaZMGyltvpO3O2W5WMZjMFlK8dzR78qnudRS69aQqdUy3Xi6KzVoFlRLTHvdwMgs5EJU1b7u5Z2Op9uvd3lgrTRWA2f5QQFZtFXAHY+wJAK8E8CnG2GcBgHP+ZQC/A+BvAPwegLdzzvXzONYdlW1yASZ7rGJ5zQffKxa/WhmivA3G7oNDFsobY2yh15vJCWSqqJS3cnWxV1tFKm9T++OAAAwINiyZztU1b07apNkpoSxYV/XbCUL7XjtpfCnWvAFCcRsfArNRcoHIguqh6q+1qLzJVNj8lbct/bSYpPri6dAwNI4y6BGqqp0JYzSdoa/pjBhJsyuaj0/thynOk0uvam4B4CKAU/QaBMSB0Hg6x3zOM6s7lr3DVIqJzvyvW2W0qmXPGj7KzC1Y1H8tBws6Kmy3JdIm53PuvO+XDuAsXbfJgfJeDg1aBegrb6p0UbO0SZM+irqv3bDKqFVKvnkkjc9Wm8OMMZEuqrEmiIbrqtY9MhNmKN7fo8v5K2/KOkG9NFUA6jTvNWJVt8mPc86v5ZzXOOdXcc5f5/nauznnz+GcP59z/pnVh7pGBJkT5B0ExSmWT6oP1brSaIvi+HFPfByiInlbBaTdJkByYqPqpE3u9PRz/1NFVSeoSIsB3Af9wCbdQKBhyXAywyis5s3p87ar9QAp+gBVjDdn7SDFf9I32AHAXIfOVZBBR+9Scj3eJA1Peomyv9ZiqwB5Tz1WNroAACAASURBVHNX3kzSJpO+ZmE0OmY1bwYNcYMs4IMwUVsicdRlOVf64hAhKcMSQFwLRa9BwHuIMHfqYNIO3solhuMNa8loolUtLwczAWxt1LAj0yZ7Y5zIaA33Nzk2CXjbzSrmXDgiSsV9KdXOqM/b8r2czDhmEY2lJ7M59voTbeVNWSelmTZZq4hA2/RwT0c5Ew6eVfiNbyollkj9Y6dpaa0JkxkH54r9WN6f6cB9f6/SuzEBVFkGRvuxyf5QQNJKmzzaFDVtMk6xfFJuYeuKv2/ZdASAAWV3gagvpU1O0M1IddjaqC3US+Ta403iVysVD/zywWYvyG3SexIblDY5DWgVYHmUt9lE1DJpzmFRy2FmBa1dL+Q/6XNs1BOoUfSmTUrXyaQCEe+4Ff21/E26ZUCQf/CmqMEKIulrFkbd0DjKIL3W1HRHu8m8Dn5TniTNrrx7qqLXILB4iGbi+Lgq3eZis2Dhcqn/e7c8B3BZZk90W4sN3Xf7Y5RLDJv16GDB21YlUHmTfd6iauyng+U1xb6X44hebzJlTvea+Wv9hhOpPGv+vEGjbs45dnv6jeI7repC2qRUkZIog+j47nUQTv1i0H48GWr3TU2bulVGs1peuB9m+7FBZkYBoeAtDfzmBLIZb95BUJwGsUUIOvNEXjOZ5iRVJM+C6q35mc7m2B9MMlPetlpVbB+OwTnHpYzqJSKpt4H5RJy8A/Y1W+7jA3hbBQQEYIDSsKRWKQc36fbaGjspZ3pz2H8aHcZwMsNgMtN/UPOf9CWpxldbQqHsXUw+BdBb8xbQXwtwlbfLRVHeGl2R3jPTCMYzTZs0rHkzcCWVaXy66sCuQYpfJP6MkyTTgr3W3opeg4C7poym82T/XxG0faqGaX+5rVYNlw7H6I+nGExmmR3AeevWADFn2g1LK+XMqTfqT9wm3UupdnUAPPr9p8rMqCxmswRxybCpub+1g6s8680TvzoWRn88w3g2154LfnVst6dphqX92tFrQmD9orf9jkEmQNp0fOmgRvW73jraNYSCtzSwmsJRTG66o8si9S7vyR6r5i0ht7B1RaW8+VQkxphwx5rMnGAkixNfwFbeDsdOs8pce7xJlq7ZclrMctqkmfImbcGVDUWdFI+hsSmI/zQ6DOO6Gv9JX9KOXa0T6aRNynFzLk5eFeYCgBu8SROarA4wAvE3GA+jd1HUZdaOpTsmIEbNm34Q5KTx6c7hXoLrlT/jJMlWGN6muopeg4BfeZvAKjNspGy5D8g1w1M7ZpK6BTv1/XDk9njLaO/wOkYCZoqh19VUOnwur8M+4ygVnIt1ekl5W1xTgjBtau6k2nlKDQC9Oj/AVrA0D0bivbZHRUqq/yKW73UQoyDnUO+BaEGUN0AYEvlTTbXrd711tGsIBW9pwNhiw9IkTyBXwbTmzSlMzf+EJTecayaVt+WeNIDYuAaedJ2szBpObIi+Tl+7JFSuQihv/nkW0McHcFWaJeWtXAFK9jVU1Lx5lbelU0LG3JQdwwdI/2l0GG5djUnNm+e9N0i4V07r5KLy1kxIRWp0hZI6PlQqbzWnz2HR0iYVDp9ByNYKWTi1Njq2qYxmeq5h+qGJOpCosYc/48TAaCX6tT33MqDPm5O+O505dcdZOO/61fo9Q8OqrQ1xYPTMgQhETmSmvFWxP5g4dWUm/f686YeO8rZ0ACd7g4XUvSlqyAFP78gI0xLTgLfjUQwBs9524uf1asfEa5uqeot7j26bAR3kHOURKazDQOdQT583+f4uQEaWd63jnNutewwyYYC1rXuj4C0tvKlGRZnsVlOcLuueNBimnF2RaChvAFCvlJ0TXyBL5U38ngeePrA/LpLy5gl4fWqNVWYoMW+TbsVSJE9jVW6TtvI2VClv8mdipHh0mzGUN5O0ydG++9CedD2pE7xdEgqSQrGMhfehfLIciNd9ypu8p8c0amdSxavWRJFUawUd6r4DoSj6OyKTQ3GIoaLdtPSDN4OG0pGkWfNW3RB7l5yDgNKhEBAPoLt9g9qXFfGr9br28JKtVg3TOcdXLwlTrMxq3poWOHffryJNT1clks6LYWmTGsrbJDwFdhjRLuDSoZnyZtkN0OX9kmqUds2bwf5g+trdpuvgCYi2AUk9R3SbVUxmHIejaej3BTuHeksRCpY2ad+P/niG8XSun/Gh8qZYIyh4Swtv8JZkM95VYMwultdU3pJMe1lXlmregpQ3EUyY9PhJAumy9RUZvBXBbdJfW6l44BeppmU3bVLlzCZ/xlI36T4cTdXOWPJnYqR4dFrLfYCCiJU2CbjXpb+TTA8siTdtMslAZMEsYjnFySozMLZoWLJZq6BSznl7aRimTWZhVgIsHwhFIYN8TRWp26wuuOmFYeqMGIpVB6zW4vwGc9eDVWDMVq63XbXG3+dNHiJMZtjtmaUurkK7aWE0nWMwnmEym+NgODUL3uxg7SsZH8D5679MavU2ZO+w/hjDyQyMAVX/+93fskWFYz4TU3nrjWGVmdFBUaflKqXysNVEcTwYTjGZRfegM1X1vA6enHPsJdV/Ed42B+HrggzElc6hgFuKYDWV+3LWdJqu06trUmSQCQOsba83Ct7SQm40QLInkKvS6OjXWxTohCU3qi2RvhelvNnW9SY9fpJAnsw98JTc+AsQvPlrKxU1b4C4ZjJlR6282RtGQJ8352f9J77yZyZDY9Xb70YWhjzx024E7PR/3AbGfXEineTBSPOECEIOn0k2EGl4U9bUgbh0/wREKuzxvHu8AWYnqzJtMgsavgOhKAx7bbYN0yYTrU1s+va9+vGFhu4rv/ZgN7DPW81x/Z0bm4asgtO8uT/29ObSn//yAM5ZwzNsFQCIdUyknOnXWDHGnCBI9gVbSlH1qjVBOCmwQb0jw4OknUORomqSHttpWk7dmqs86/aJ0wuCAHMnV69T7MFoiumcJ2hYoudCKw/gApU3uacW5EBfpv5OZ257EH3lzSAzo4BQ8JYWypq3Akx4E6ezAhWm5gZji32ZImredpI0ANBA1kc8aJ/aZvV7Q1GmmqoDMMnSqS3gbuiKEz7vzwanTdo1b5UGUNVLOVP1AQpCnvi1G6abxU46anzrpKhN2/lqcvVugC9tctnWGxD3wKl5G2SneoTS0Kxp4FwEvVmtc8bKm1mvzW7LIG3SsD4rEn/GSZLXVBrnyFS7ALVGtgpIyuwhio4nCNozVePhHrg9+PQBWtWyej1LAcd0pD9BbzzDZGYWLHSalmgVMJmplVuvWhPEJEBFtfTcJrd7I+0eb5JF5W2MjVoFVdUBoAKTPoq7/QkY06/9dfuWTbCXcJ9Cv8oaRGD9YqkCsJK7pxbhWRbu887+YGLeHoRq3ggl8pRwPheTnZWAWgLNeFfF30A5jKLU6uVNo62hvJUwmsyx1x+jWimhkdUGbC9UF/aH2KxXkkl/WpVqSyz2TsC7bHIBuEFXtVJS21NbwcGb9wFHqbxZtvI22DXaaHQ3OUCcYm4abPwLSlAaarxUji4/kVLa5E6gilqrlJz6lP3BJH+zEkAE7JVGdFrMuCf+X1kpb3Fq3gzW4HaziuFEpPFFIYw9ErxX/oyTJOd3o+POQSCkTmpmGxdkMwedA5/+OFbavAzeLuwPM61Z9jov7sYYd9u2aVe2awE8aZMhNW8BbR8c5S2y5s28PY63bs10/usqWPK1j9UtlDVaL3hfe7c3durlEgveFA2tVTjOof7nCMbEWjoZGmcCpIm3UbdbxqB5P506WlLeCC/NLYDPRWqMdJUrFeBye1WkKChtUuBVK0OUt+F05hTKZ+FyBojAR+b7Z+VSFomjVuopb8rgC/AYlsRR3jw1bybBm0Ha5F5/jLZBetRCH6w0HGi9AVuSgUj9uDh8kvVGIX33APu66KqRaaPTqDvp1gpRxFLe9OdJ1+AAYrefnCkCgOWMkzSUt+lQpLL7mtvLAOLiwQizOc8sC8G93hO3hspgXfAaq2SZ9u6dJ8bmS5C1laJJt/LQ0NJQ3mTNW5CDrUarANN9r9OsOmmPpvNf3ledPoqmqvaq90PrtSMySgKVN0DcT2dPLUY21sJ7z/QAwqmjJeWN8OIthiyQzIy6QY+hAhWm5or3mgUobw275m0nw0J5idy8CmFWIlm4Zstuk4AbdAWqhY5hiSrwc39GbVhSd4urDVSLjuc0OoodE1tiYNGNLw0zIG/wkWQgUirbRkc7yj5vgK08O26TUxwrgvIGCEOYqLSY3iXxd2bKm52BobMOz2fi+4wOIMS111UHEq0NW6h5S7g2RmazhKTuAsBT+yJYyKrPoLd2LE7rhUq55Nwz0xTAVWhWy6iWS9jpj42NOwDZY2vi1LwtUdGoeXNSYH3OoRVXRQ1j+3BsvO91mhYO7b6opjWfRjXRfTNVb0FF6hmqSBEcq1soMR3lLcA5FPAciBan5s2rhO7EaVGjc7hXUCh4Swv/KXtBTirQ6IjebbNwy1gAxRp3nugqb3baZNZ1Z/K0thBmJRLvNVO4TQLuBqFMuQHClTfLq7yFGZaYnRK2PXUgUeyZmiJ40/iS7IElWQjeEra9b26JIGc2ClTehpMZOOfYHyScircK/sboKhzlLaNWAeWKaOWgo7wN90UGh8E86Th1OeFzeDKb42Bk5owYSXNLjHk2TT69qrkF8Blw+HToevLkZREsaLvOrYg6dcvsmsp0yRMZruHCdMTCXs+jWpioULa1/WAS0K7F0nGbDOjzpqG89cdT9Mcz41RT+X/cs+9XN0bapJ6h1cSoXcVGrQKrzBYU3KSeJUolpmVkNJwGNFwHxP0cH9qHScV4LvTey73+GMcblpnLcbNLNW+ED2kBLh/UCnJS4Tqd7Ud/b3/bTfE5yjTawMC+XgEpgHWrJAxLMnQ5k8jT2kL0eJN4aytD3CYBjbRJpWFJWflvB2lYYvgAWa2UsFGraJ+sGp+MSvXAqSdN8P3l3VCTVpGaXeDyBfHvgJq30XSOwUQYHxSi5g3QS4vJOm0SsJVMDeUtRt2xbt1mHGfESOQ4D54EJv2Ea97s19r/emgN7ZN7Qs3JSnmzyiVs1ivY60+w15+gbpXQqJrVHkv1KOsDONnkOE7Q2WlWMZ1zbB+Ogx1/gVh93nRaBTgNumPUvAGuMYjJPGlUy6hbJS23SVOrf8aY00x7rz9GiQnFLCnaHlv9IMKVtzpw+Unx74JkknU8Ji+x6lyblDZJ+PHakBYpbdKk3iJpt7B1pdERzZXnsxDDBtkqYJLsw5AGcvM6UaS0Sam8zabitFyh1kjFLDhtUgZv6ibd/tdZwGoIO/6B+Slhp2VppU3u9ibmNQkyrSxpG3UAqFRdM4zEg7ctN3gLcpuczp2HmnZRgrciKm/AoglSGDFcSXXVgbgqUShyn9t+yP444Zo3QMxDxZpglUsol5iTNplVk27AbdS904vXHNxNfc/2AM4J3npjI2dEwD0keHJ/qK6R0urzFuQ2Gd2ke9teo03VSrk/P3MwxMFoaqxudTUbde/0x8bqr3ztnZ4I/JRGXjGRNYphBDbpBuzgzd4DCvJc2LDKqFVKjumO8X7sNVhaMyh4S4uF+pbiuPMsNZ0Oo0hBZ57UPWploPLm9nnLXHnbKKDyJmveHDexYOUtOG1S9nlTBAtRNW+VukivAjdWvTu2i1oY4+kch3FSzqQSNEipbkAGbUkHb42uUFOAwJS14WTmNF0vjPLW7LppfEH0LgHVzWxrexuatceOK6m+QtvWbHcRx2EwEn/wlnTNGyDmoWIOAkC9UsLTB8IEI8t1WKakxW2snFfqu6xb2+0Lh1hdZ0TAVT22e6Nld0JAs8+bumefbB0TrryJ+2zcKsC+P1+91LM/NlurpDoWxmA8w3AyN54LUh3b6ydfO9/W2NeGkzlKDLDKAe7Pcg8oSEYWY2xBPTZ+zze3XFf4NYOCt7SobQpHrP0nRJ1IQU4qjJQ3qnkTeK9ZgPLWsMqYzDjmPNuHBsA9eSxczdtwX6hfgDrgraxgWOJV3oIeHLi98Zsqbxq1AU4/J2Plbcujxqfw3mqdBMCSP3Rpdt3rqUpjtQ1LpPJWiCbdgH2NeXig1LuYreoG6PfbjOFKKtP4tJW3JDMF5DgvPbj4cSKvbc9pPgsMtOtWGbM5R7nEsFlPUNWOoNu0nFYBceqUZACStWNwx1ZjdvrmiqFc+zgPcCdcoc9bqcRQLZdCa96k8ma678n788hFO3gzVd5a0cqbcc8xz2vvrqDghr92dEaJdA5VumVX6rH31DTptKrYses2zYM3e18baZQRFQwK3tKC2Q9Q2/YmVrSat6h6i9lUPPAUZdx5Iq9Zf1s0QQ6oeZNknTYpN4hCNOiWyGvWe0b8HRKAKTd+QLtVgPrBwfMQZKBaAOIkNvrB19ydTYyl6zExSkN52xKvWzKruYnEO1aVimq3Ciic8uZ1/Q3i8oXsgzftmrd4rqQ6BxDuHE5w3ZDjlPteGjVvgHIOAu660G5YiaacRSGCoPiKSXcjnzW806xibzDBzqG5yZB33igP4BgDyrVYfd4Asa6HuU1eiqm8yf/nwxcPAZjP/3bTiqx5M+455rx21VZC4ym4Ycg1gXMe+D2j6Tx4P17YU4vzXNhpWrb5TIyaN539oaBkdzR1FGluAZdSyP1fBV3lTZ5UF2XceSKv2cFT4u+QFEAge+XtVc85ge8/dxovOd3O9PeGsnTNgg0GlMoZANz0RlFnGHG9lT/vDfiMa96qkSln8uTV+HS0uSUe2q0mcOoms5/V4WVvBU6/IvnX9V7DAPfP4WSO/YG4LlmZRUTibYyu4iu/Dzz2F8C3/KvsxgS4yhvn4iE3iMGOyOCobRq9fEdDHYjTUDoSR3lLYd+rHwdYObCGFnDXhaT6Y+nSaYkH42qlFCsA+/YXnMLfftMZPOfkRgqjC6bTqmI253hsp4+brjabY961LzT1PVJ5Y6JZsg/ROzJYefu/D2/juq2msTlMrVJGq1p2lTfD+d9tVZ0m2kHI/cP8tS3HrOSWa48b/WwUnVbVMZVqVtWP/sPJLHg/tuLvqWnSaVVxz2N7GExm8TJhABG8bT0n+cGlCClvadLoAvuPi38X5aRCt8eQU2tRkHHniax5O3xa/B2lvGX84NptVfHzb74lcEHOBXnNnDoplVoTobxdfStw288oH24jlTev0hdDtZB9gIKQaZPGQUqjC4ALtScNVfvsdwKv+tHkX9c71oC+e6Oi1rwBajvo/g5w5z8HTr0wh+CtLVT8ST/8+2TdcViAp6CjoQ7s9cexnBFDqTbF+ij3vSRrY5gnHVgxBwGgJoO3jNN2O00L/fHMVt7M1/9r2g28+44XoxrkvJsS8jpd2B8Yj3uzXoEUN0NNp6Jq3qxG4Bo/CjAsuXQ4wl88vI033HK10Zgl7WYVF/aF6meaKdNuVrE/mGA2D1aw4jbZlg6eFw9HiT9HeJ0ZgwhX3uz3XLkmDh8LQqdpufcyTtoksJbtAih4S5NmB4D9Bi9K+mHZEsX5UcqbU2tRkHHniaMiyUBkeYHwKkGFSl/MiyXlTaXWRLQKCGGxVUBIvQUQS3kDEFqUvhOzpsEdC1+v95aG8iZr3iolhlaSAcEqeF1//Xz6HUD/EnDHrwSm4aWGbgZEzLpjHUe8HcM+VNrIA4raMbHfJIm8FoHKm1gLsj5A8z6kZx04roK3bs10LSuVmHOdg9u91KPdJoPMZ6yS03fMz2fuewqzOccbb3220ZglnZYFmT1orI41xc/KgyoVcZ1c5fdznrx67LjQhqwLo0lAw3XAVd6aW8aHSWnSbVade2nc2zEqM6PAUPCWJt5Nt0Ay80IPriBi1lpckcj6rYMw5c19WC1Mg+I8aUQrb26TbvMHfbfNQCm4uBoQ6TjVltFr65xQOpb4xjVvHiVirYK38HojmeK0NxCudcp7kgdBNQ33fQy476PAa98pFN7MxyWDt6h1OJ4rqY4jXlxnxEjkXpfG/JbXIqLmLfPgzfP71unwzjvuOPuW/Jla0Bou+20GMQkO3oSar1be7vrSBTz31Aaef5VZqqdE/r8bVtl4/9HpoyjTJo3rCD3BR9KHADrjHk4DGq4D7nuuYPtWe2EOx8mEwVrWvFHwlibOpsvch9kioNNjaEDKm0PZAqob4SmA9oJXKTFs1AqUvpgXBjVvqyhvgRuNPCVsmKecSTUiTLnY6Y3RrJpv/AsP4ut0MLKQNhlsIPPM5VFxnCYBEbiXq4snqwdPAZ/6SeCabwBe8xP5jEumFeusw4aGO4B48OuNZ6FW6zv9cTrmSnK8acxvJ20yvOatnbFplPchvTD1nhp4A4Q4AW+k8laJUt4GISmwJeX8fWp/iL98dAdvvOXZsQ+J5LjjBEhtDQVrtz/GZq0Cq2y2t60UiEQg/69h+1qo8ibV7oK0CZAsBryG10zW0ZLyRiwgTyAb7eTd31ahrhG8OTVvBVIM86TeDq95kye+rWpxVIc8cWre7OBNsUG7wZv5e8MqMzAWUigv71GM+Ss3zTDlIlZPGf941um95d2wQwLxiwfD4tS7AXad1JZ7GMW5qHObDIA73p9sk3QTtNMm47WUcFN/w9XjVBQqR3lLYX7L4C2wz5uYh1k26AYW1basf/cqLKZ7xgjeWlFpk1E1b6PgFNgA5e1Tf/0kOAfecGu8ejfAvV9xUhPl/Q3LzNjtx2gYjcW5k7SC22lGrwmyVYASK/6emibeeWt8GCXraKnmjVhAbjRFO2FvdDQMS3YKV5iaK42OlvK2TvUOqVKpAlYrQnkrLfxtAmMM9UqI8uVsNObvPbkBhDmK7fbMrbWXxrNOqna54podhShvT18eoV2k4A1wG6MDwF99CHjw94HbfhY4cTbHMdmHG2HrMOciuIuxf3Q01eNUgjc53jTTJgOVt/zTJtcpbX6zVkHFdh2Js3fJnwlOtYtymzRX3u669wJeePWxlZw55T2KM0/kz4Ypb+K9Fed6plc7KQ/VwtaE4WQeciAqa96KtW8tvPcaMQ9USXkjFkjzBHIVdNMmC1aYmiuNtvsGVwQi0rEt64eGQtPwqpXqOinv36bUrFJ4ug4QL3jTOKHc7U/inYxWN1xb7KKtC1E4ZhHB9YsXD0fFUt4AMQf6O8Duo8Bn3wVc/83Ay9+W75h0lLfRZWA+jam8ybpN9YPadDbH5eEkHUv9VJW34DkIuGtJ1q0CvAHbOtW8McacTIM4445U3iLTJsNq3pabdD++08cXH9uLbVQiWUl506gd2+vHe29t1isoO8F0svOoUi7heMMKzSgJVd6cmrdi7VvyfmzWKvHcWhtdoB/xPFxAKHhLkzRPIFeh0RGF8iHNGlNrIryueGsWlWmTFLwt0eiInkyAMjWmHtWkO4JapRRy4uupeTOkbpXRsMqhJ5Sxm6gy5o6paIp8FI5ZhOpeivswm/Pi1fw0u8JV8hNvB8CAN/0yUMp566tuiFqLMMOSFdq1uM5y6gOI/cFEONqloRKlmXHSDJ6DgFd5y/YAQfYOq5ZLaBbFaVUTea3ivG+dmrewDIhQw5JBiNtkealJ9133iuyXuC0CJO0Vat6a9n0Oy8yIq2qXSszJXEjjEKzTtLAT1Sogym2yYPuWPDiJXee6pmmT5KyQJnKjKdhJBRodYDYSC2c1IC2SgrdFFmp+VGmTbs0bYRN5zSKadEdQt8ohDUVXy8/v2k13g9jtjdGN+4DY3ALGPWXLiULT3AJYSWn/7t3wi6e8bQHbD4k/t/8y0D6T94jsIL4TrrzJ0+A4rQIi1AFZr5OKSpSm26R87YBUu7yadMvfOZnN167mWV6rOOmeskarHmZyMR0Fv8B0FJgCq1Le7rr3Al5yuo3T3dXKObpO8GY+Txhj6LQs7AUcjACiXjruQW6nJXq9VQzNTnRfO0x5G07m4c6hQOGeZzdqFVhlFr/WtNkFnvhCsoPKAAre0sQ5gSyWO49jJjHcCwnetoGrbs5uTEWnHq685dUcttDIGikgVK1cRXmLbCga8wGy3bTwV1/bxX/4zP3LX+TA5eE0vsLU7ALjg3g/myfNrngYUzXU9Wz4hQve5Enx818PvOTv5TsWL412eM3bCu1a5IP4737pAh7fXW4EfvHyyP6+Na15C1De3HU4h+CtKYK3daPTtLBZN3dGBDRaBVh1MY//4N+pv37568Cpm5Rfku1HJI9cPMSXL1zGT3+P+vtNcGve4q1VnWYVX3h0J3B/6I1nK7y2hWlK86jTrOK+r++rxw3g8nCi0eetWIf6MvU3/n68JcQKzteqTIiCtzSpHQfOvAo488q8R7KIt97imCJ3/JHPAdsPAi9+c7bjKjIRKtJGrYKXnWnj3PUFC9TzJOKane428LyrNnDT1cdivfwrbtzCiY2A5sqbVwNXvQi49uWxXvvlN3TxPz//GH79zx9Vfr1VLePW08eVX4vkhteKh5Z147pXA8N95Ze8J++FM2y49huBUzcDb/zFYm3OYcob58D5DwrTqO4Nxi9dq5Tx0jNt3PP4Hu55XB0gntio4uyp+KYPgVx1M3Dieen0zztxFjj5AuBZL1J++dZrj+PcdZ1cDhBec/YEJtP1C95eeeMWqjGzH26+5jhuPNnCc4Pm0dUvAe75TeDz7w9+kWe/VPnpulVaSJu8694nwRjwhltWq3cDgOtPtPCCZ23ipWfi7dcvv6GL3/7C44H7w0atgltOx2sP9ernnsD2YXiPxricu76DP3/oUuC4y4zhRdcE7GunbgK2zhbyUP+1zzsZfy1rdMXzybgH1FJYD1OC8bC6p4w5d+4cP3/+fN7DuPJ55E+AD90O/ONPA9e/evFrw33gfa8Wk/mH/yxYmTtqnP8gcJfdE+odDwIbp/Idzzrw+z8N/MUvCRXsp5/OezREitzz+B7e9N4/BwD82lvP4TtuuirnEa0BH34z0LsI/PDnlr/2xQ8Dn3w78LqfA1759uzHRhA5857PPoD3fe5hrpRA6AAACjJJREFUPPxzrwfnHN/5C3+KbquK3/nhgh2GE+tNgRU3xtjdnPNzqq+RYclRJMzp7PfeJVSBN/0KBW5eIlQkQoG8ZgEF6cSVQ63IyltRCVLe9h4DPvNO4LrXAN/0T7MfF0EUgLpVwmzOMZ3N8cDTB3jomUO8cUWjEoJYoqCBWxQUvB1F6gE9hv7208A9HwZe85PA6W/MflxFJqLmjVAgrxldryueepFr3oqKquZtPgc+8c/Ev4vgikkQOSEt64fTOe760pMoMeC7X0zBG0EAVPN2NFEpb71LwO/+GPCsFwOv/Tf5jKvIeJW38pq5BOaFo7yRUnmls+g2Se8PLRodkaY+nwElO/j9y/cDj/4Z8L2/BHSuy3d8BJEj0oxqOJnhd++9gFc/90RwjTNBHDHoWO8oUttc7DHEuajnGu4Dd7x//SzMs6DhUZHWVGbPHHnNAqygiSsHUt5i4GRA2CYwF78C/OG/B86+DnjpP8xtWARRBKQb8flHd/G17f7Kvd0I4kqCgrejCGPiwVoqb3/9v4D77wS+7V2FdBIqBKQimUPX7MgglbdmtYxqkNU0sYg3A2I2BT7xI4DVFKobHRARRxypvH3k7idglRled/Ozch4RQRQHSps8qtTteov9rwOffgdw+puAV/1Y3qMqLtVN0aCY6rf0oZq3I4MM3kh1M6DhqT3+Px8Dvn438JZfBzbJqZMg5JryJw88g2953sl0ehISxJpCR6RHlUZHNCa880eB2QR40/vcugtimVJJBCOkIulDbpNHhkq5hEqJUfBmgnx/PPI54HP/EXjRm4Gb78h3TARREGTj7+mc4423UsokQXgh5e2o0miLfm/zKfD69wBbz8l7RMWn0QZK9JbRpnYMAKPg7YhQq5QoeDNBKtN//G6geQJ4/X/KdzwEUSCk8larlHAb9Y0kiAXoSfSo0uiIwO3GbwO+8YfyHs160OgAs3Heo1gfSiUR8JJaeSSoWWXq8WaCVN7mU+D29wLNbr7jIYgCIVsFfNvzT2GzTusKQXih4O2o0j4jTn5vfy8Vx+vSvREYHeQ9ivWieyNw/Nq8R0FkwNXH67huq5X3MNaHRgeobgC3fD9w9ra8R0MQheLUZg2MAX/nG2j/IAg/jHOe9xgczp07x8+fP5/3MI4G0zEwPqTTXhPGfQAcqNIDqjbDy6IvnkWpk1c6B8MJqpWSc2JOaHD4jEiZpGbcBLHExYMRTm5S5gZxNGGM3c05P6f6GilvR5VKFahQ4GZEtZn3CNaP+rG8R0BkBKU2xWDjVN4jIIjCQoEbQaih4z6CIAiCIAiCIIg1gII3giAIgiAIgiCINYCCN4IgCIIgCIIgiDWAgjeCIAiCIAiCIIg1gII3giAIgiAIgiCINWCl4I0x9hbG2JcZY3PG2DnP569njA0YY/fYf35l9aESBEEQBEEQBEEcXVZtFXAfgO8D8H7F1x7mnL9kxdcnCIIgCIIgCIIgsGLwxjm/HwAYY8mMhiAIgiAIgiAIglCSZs3bDYyxLzLGPscY++YUfw9BEARBEARBEMQVT6Tyxhj7QwDPUnzp33LOPxnwY08COMM532aMfQOATzDGbuacX1a8/tsAvA0Azpw5oz9ygiAIgiAIgiCII0Rk8MY5v830RTnnIwAj+993M8YeBvA8AOcV3/sBAB8AAMbYRcbY10x/XwacAHAp70EQVzw0z4gsoHlGZAHNMyJtaI4RWZDXPLsu6AurGpYoYYydBLDDOZ8xxm4EcBbAI1E/xzk/mcZ4VoUxdp5zfi76OwkiPjTPiCygeUZkAc0zIm1ojhFZUMR5tmqrgDsYY08AeCWATzHGPmt/6VsA3MsY+xKAjwD4Ec75zmpDJQiCIAiCIAiCOLqs6jb5cQAfV3z+owA+usprEwRBEARBEARBEC5puk1eSXwg7wEQRwKaZ0QW0DwjsoDmGZE2NMeILCjcPGOc87zHQBAEQRAEQRAEQURAyhtBEARBEARBEMQaQMFbBIyx72KMPcAYe4gx9s68x0NcGTDGTjPG/pgxdj9j7MuMsR+3P99ljP0BY+xB++9O3mMl1hvGWJkx9kXG2F32xzcwxj5vz7HfZoxV8x4jsd4wxtqMsY8wxv7WXtNeSWsZkTSMsZ+w98v7GGO/yRir03pGrApj7IOMsWcYY/d5Pqdcv5jgv9oxwb2MsZflMWYK3kJgjJUBvBfAdwN4IYC/yxh7Yb6jIq4QpgD+Jef8JgCvAPB2e269E8Afcc7PAvgj+2OCWIUfB3C/5+OfB/AL9hzbBfBPchkVcSXxiwB+j3P+AgC3Qsw3WsuIxGCMXQPgxwCc45y/CEAZwA+A1jNidX4dwHf5Phe0fn03RPuzswDeBuB9GY1xAQrewnk5gIc4549wzscAfgvA7TmPibgC4Jw/yTn/K/vfBxAPO9dAzK/fsL/tNwC8KZ8RElcCjLFrAXwPgF+1P2YAvh2ihQtAc4xYEcbYMYj2QL8GAJzzMed8D7SWEclTAdBgjFUANAE8CVrPiBXhnP8pAH87s6D163YAH+KC/wegzRi7OpuRulDwFs41AB73fPyE/TmCSAzG2PUAXgrg8wCu4pw/CYgAD8Cp/EZGXAH8FwD/GsDc/ngLwB7nfGp/TGsasSo3ArgI4L/b6bm/yhhrgdYyIkE4518H8B4Aj0EEbfsA7gatZ0Q6BK1fhYgLKHgLhyk+R/acRGIwxjYgeiL+C8755bzHQ1w5MMbeAOAZzvnd3k8rvpXWNGIVKgBeBuB9nPOXAuiBUiSJhLFrjm4HcAOAZwNoQaSw+aH1jEiTQuyhFLyF8wSA056PrwVwIaexEFcYjDELInD7H5zzj9mfflpK8Pbfz+Q1PmLteTWA72WMPQqR8v3tEEpc2047AmhNI1bnCQBPcM4/b3/8EYhgjtYyIkluA/BVzvlFzvkEwMcAvAq0nhHpELR+FSIuoOAtnC8AOGu7GVUhimPvzHlMxBWAXXv0awDu55z/Z8+X7gTwVvvfbwXwyazHRlwZcM5/inN+Lef8eoi1639zzv8+gD8G8Gb722iOESvBOX8KwOOMsefbn/oOAH8DWsuIZHkMwCsYY017/5TzjNYzIg2C1q87Afwj23XyFQD2ZXplllCT7ggYY6+HOK0uA/gg5/zdOQ+JuAJgjL0GwJ8B+Gu49Ujvgqh7+x0AZyA2q7dwzv2FtARhBGPsWwG8g3P+BsbYjRBKXBfAFwH8A875KM/xEesNY+wlEKY4VQCPAPhBiMNhWsuIxGCM/SyA74dwa/4igB+CqDei9YyIDWPsNwF8K4ATAJ4G8DMAPgHF+mUfHPw3CHfKPoAf5Jyfz3zMFLwRBEEQBEEQBEEUH0qbJAiCIAiCIAiCWAMoeCMIgiAIgiAIglgDKHgjCIIgCIIgCIJYAyh4IwiCIAiCIAiCWAMoeCMIgiAIgiAIglgDKHgjCIIgCIIgCIJYAyh4IwiCIAiCIAiCWAMoeCMIgiAIgiAIglgD/j/MT21PdZ8zMgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,5))\n",
    "plt.plot(rew[-100:,])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's play a game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = TicTacToeEvnironment()\n",
    "env.env_init()\n",
    "ret = env.env_start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "ai = rlg.agents[-1][\"agent\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_start(ret[0], ret[1])\n",
    "action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = env.env_step(-1, action)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Human (aka - me) will play 4, middle square\n",
    "ret = env.env_step(1, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_step(-1, ret[1], ret[3])\n",
    "action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = env.env_step(-1, action)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I choose 0\n",
    "ret = env.env_step(1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_step(-1, ret[1], ret[3])\n",
    "action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AI chooses 8 to block me - good move!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret = env.env_step(-1, action)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I'll try to block him at 5\n",
    "ret = env.env_step(1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action = ai.agent_step(-1, ret[1], ret[3])\n",
    "action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,\n",
       " array([[ 1.,  0., -1.,  0.,  1.,  1., -1., -1., -1.]]),\n",
       " True,\n",
       " array([0., 1., 0., 1., 0., 0., 0., 0., 0.]))"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.env_step(-1, action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AI wins :-) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets save this agent\n",
    "ai.network.model.save_weights(\"agent-3-keras-9-36-36-9.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Face Off - Exact Agent vs. NN Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TicTacToeExactAgent(BaseAgent):\n",
    "    def agent_init(self, agent_init_info):    \n",
    "        self.learning_step = agent_init_info[\"learning_step\"]\n",
    "        self.num_actions = agent_init_info[\"num_actions\"]\n",
    "        self.rand_generator = np.random.RandomState(agent_init_info[\"seed\"])\n",
    "        self.states = {}\n",
    "        self.last_state = None\n",
    "        self.last_action = None\n",
    "\n",
    "    def policy(self, q, mask):\n",
    "        # greedy policy, breaks ties randomly\n",
    "        pos = np.exp(q - np.max(q)) * mask\n",
    "        return self.argmax(pos)\n",
    "\n",
    "    def argmax(self, array):\n",
    "        m = np.max(array)\n",
    "        ind = np.where(array == m)[0]\n",
    "        return self.rand_generator.choice(ind)\n",
    "    \n",
    "    def get_q(self, state, mask):\n",
    "        if str(state) in self.states:\n",
    "            q = self.states[str(state)]\n",
    "        else:\n",
    "            q = np.zeros_like(state)\n",
    "            q[mask == 1] = 1\n",
    "        return q\n",
    "    \n",
    "    def agent_start(self, state, mask):\n",
    "        self.last_state = state\n",
    "        q = self.get_q(state, mask)\n",
    "        self.states[str(self.last_state)] = q\n",
    "        self.last_action = self.policy(q, mask)\n",
    "        return self.last_action        \n",
    "\n",
    "    def agent_step(self, reward, state, mask):\n",
    "        # SARSA\n",
    "        q = self.get_q(state, mask)\n",
    "        action = self.policy(q, mask)\n",
    "        q_s_ = q[action]\n",
    "        q_s = self.states[str(self.last_state)][self.last_action]\n",
    "        self.states[str(self.last_state)][self.last_action] += self.learning_step * (reward + q_s_ - q_s)\n",
    "\n",
    "        self.last_state = state\n",
    "        self.states[str(self.last_state)] = q\n",
    "        self.last_action = action\n",
    "        return action\n",
    "    \n",
    "    def agent_end(self, reward):\n",
    "        # SARSA\n",
    "        q_s = self.states[str(self.last_state)][self.last_action]\n",
    "        self.states[str(self.last_state)][self.last_action] += self.learning_step * (reward - q_s)\n",
    "        \n",
    "    def agent_message(self, message):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "rlglue = RLGlue(TicTacToeEvnironment, TicTacToeExactAgent, TicTacToeAgent)\n",
    "agent1_info = {\"learning_step\": 1, \"num_actions\": 9, \"seed\": 12}\n",
    "agent2_info = {\"discount\": 1, \"network\": nn2, \"tau\": 1, \"num_actions\": 9, \"seed\": 176}\n",
    "env_info = {}\n",
    "rlglue.rl_init(agent1_info, agent2_info, env_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reload states into our exact agent\n",
    "fr = open('agent-exact-states','rb')\n",
    "rlglue.agents[-1][\"agent\"].states = pickle.load(fr)\n",
    "fr.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "runs = 10000  # "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "def experiment(rlglue, runs):\n",
    "    rewards = np.zeros((runs, 2))\n",
    "    starts = np.zeros((runs, 1))\n",
    "    final_states = np.zeros((runs, 9))\n",
    "    for i in tqdm(range(runs)):\n",
    "        rlglue.rl_episode(10)\n",
    "        rewards[i, :], starts[i, :], final_states[i, :] =  rlglue.rl_return()\n",
    "    return rlglue, rewards, starts, final_states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 10000/10000 [01:59<00:00, 83.93it/s]\n"
     ]
    }
   ],
   "source": [
    "rlg, rew, starts, states = experiment(rlglue, runs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1721, 0)"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rew[:,0] > 0).sum() , (rew[:,1] > 0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the exact agent won 1721 games out of 10k, the rest were tied. The NN never won a game. Still, tie-ing with the exact agent for 83% of the games is impressive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It took 50k games to reach a less optimal level than the exact model. This model used ~ 2k weights, while the exact solution had to keep ~ 4.5k states x9 action values per state. But it did take much more time to train. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When facing the NN agent with an exact agent, it became clear that the Exact agent is much better. Though after some practice, the NN agent improve, and didn't lose as much."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: I thought perhaps that the slow learning also came because I used a small learning rate. But using a larger learning rate didn't help (and in some cases made the networks explode). Obviously the learning rate parameter is one of the most important parameters, and a lot depends on it. IMO, it is better to go slow and in the right direction, then fast and all over the place. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "rlg.agents[1][\"agent\"].network.model.save_weights(\"agent-5-nn-9x36x36x9.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}