ADA boosting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random as rand\n",
    "import math\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "Npoints = 300\n",
    "class1 = np.zeros((Npoints, 3))\n",
    "for row in class1:\n",
    "    radius = rand.random() - 0.5\n",
    "    theta = rand.random()*2*math.pi\n",
    "    x = radius*math.cos(theta)\n",
    "    y = radius*math.sin(theta)\n",
    "    row[0] =x\n",
    "    row[1] = y\n",
    "\n",
    "class1[:,2] = np.ones(Npoints)*-1\n",
    "\n",
    "class2 = np.zeros((Npoints, 3))\n",
    "\n",
    "for row in class2:\n",
    "    theta = rand.random()*2*math.pi\n",
    "    radius = rand.uniform(0.6, 1)\n",
    "    x = radius*math.cos(theta)\n",
    "    y = radius*math.sin(theta)\n",
    "    row[0] = x\n",
    "    row[1] = y\n",
    "    \n",
    "class2[:, 2] = np.ones(Npoints)    \n",
    "\n",
    "dataset = np.append(class1, class2).reshape(Npoints*2,3)\n",
    "np.random.shuffle(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2df5Ac1XXvv2dHs2Ikx9qV0bNhkUBO9MD8EFLYwuRRFQdjCzC2JMtYgEMCMX4KwY4Lk6eSKFIgFKcQUT3LdoXEUTCxHdsgIUAIMCVsCb9UOZbNKvqBZSMjg0FaY6NYP8pIg3a1e94f3b3b03Pv7Xu7b/+YmfupUmmnp7vnTk/3Ofeen8TMcDgcDkfn0lX0ABwOh8NRLE4ROBwOR4fjFIHD4XB0OE4ROBwOR4fjFIHD4XB0OBOKHkASTj31VD7rrLOKHobD4XC0FNu3b/9vZp4W3W5FERDRgwA+DOANZj5f8D4B+BKADwE4DuAmZv4v/70bAfytv+vnmfnrcZ931llnYWBgwMbQHQ6Ho2MgoldF222Zhr4G4ErF+1cBmOX/WwLgn/1BTQVwN4D3ArgYwN1E1GtpTA6Hw+HQwIoiYOb/AHBIscsCAN9gj20AeojoNABXAPguMx9i5sMAvgu1QnE4HA6HZfJyFvcB2B96fcDfJtveBBEtIaIBIho4ePBgZgN1OByOTqNlooaYeS0z9zNz/7RpTb4Oh8PhcCQkL0UwCGB66PUZ/jbZdofD4XDkRF6KYBOAPyePSwAcZebXAWwGMI+Ien0n8Tx/m8OhZvd6YM35wIoe7//d64sekcPRstgKH30IwJ8AOJWIDsCLBKoCADN/BcB34IWO7oMXPvoX/nuHiOjvADzvn2olM6uczg6HJ/Sf/CwwXPdeH93vvQaA2YuLG5fD0aJQK5ah7u/vZ5dH0MGsOd8T/lGmTAc+9xO9c+xeD2xZCRw9AEw5A7j8LqdEHG0PEW1n5v7o9pbMLHaUDJlQzUrYHj1gtl00XreicDjGcIrAkQ6RUH3i08CTtwHDx8b3sylsp5whWRGcoXf8lpXj4w0YrnvbnSJwdCAtEz7qKCkioToy1KgEAgJhm5bL7wKqtcZt1Zq3XYe0KwqHo81wisCRDlPhaUPYzl4MfOTLnk8A5P3/kS/rz+ZlKwfdFYXD0WY405AjHTIzjYyapVJSsxcnN+NcflejOQuIX1E457KjjXErAkc6RGaasmO6ogj8IEf3A+Bxf4dJ7kI75z2083frENyKwJGOQHgGs+VaL3Did8DosHj/+uH8xqbCZEWR1rnczlFK7fzdOginCBzpiQrV3euBx28BeKR5Xx07/JgZZj9AFe88U6YXZ45J61xu5yildv5uHYRTBA77BALA1A4PNM8wA2USnmkCcnt9Frb8tOGq7Ryl1M7frYNwisCRDVGTka5QFs0wA4brwDPLgJN1sSkCyMZMkcS5HCatIikz7fzdOginCBzJ0Jl5J4nsiZtJ1gWlqML5CVmYKZIqtYC0iiRPTFdUpt/NRV+VEqcIHOZk6SA0DUcNUCkQW7kLSb9bWkWSF0l+V5Pv5hzLpcUVnXOYY6Pom4yosAhTrQETauJVwRS/rUVW4+oEsvxd8zi/IxZZ0TmXR9AO5B3HnaWDsCHGH17UEDAe63/VffLyEmlLT+RFWePus3b8OsdyaXGmoVaniOV21g5CHTOMyhRRZhNMmc0jWf+uzrFcWpxpqNUpYrktMt9Ua2b1fjqJsIOUuiT5FSUwj2T9u7r7pnBcP4J2pYjldqs4P8uALC8iShnMI1n/ru6+KS22WlVeCeBLACoAHmDmVZH31wC4zH85CcD/YOYe/70RAC/4773GzPNtjKljKGq5nSSKphNDB1V5EWGiv1dR1ypNdFQZzu9IRGpFQEQVAPcD+CCAAwCeJ6JNzPzTYB9m/lxo/78GMDd0ijozz0k7jo6lVWLUdW3j7aYsdGb60d+rzH4ER1tiI2roYgD7mPllZh4C8DCABYr9rwfwkIXPdQDpa/PnhaomTYCNKp8yiorUiV2ZEXDhJ5qd3XHXyuFR1gisFsOGaagPQNg2cQDAe0U7EtGZAGYC2BrafAoRDQA4CWAVM2+UHLsEwBIAmDFjhoVhtxGtsNzW8WVkVcCsyBm2aMXWAAMvPdu4qcgwy1ZakbmVkzXyziO4DsAG5gaP2Zm+F/sTAL5IRL8vOpCZ1zJzPzP3T5s2LY+xOmyi0xUsKwFY5Aw7mhchIvr9bHVQM50tZ7kiywLT39WtHqTYUASDAMJ3+Rn+NhHXIWIWYuZB//+XAXwfjf4DR7ugk+yVVQvJOAWTtYCYvdgLDZUpg+j3mzVPvJ9su4gkQj1OsJZNkJpMHFpNyeWMDUXwPIBZRDSTiLrhCftN0Z2I6BwAvQB+GNrWS0QT/b9PBXApgJ9Gj3W0ATq+jKwyg1UKJk8Bofv9oqaiuO0ikqyCVIK1jILUZOLg/C5KUisCZj4J4DMANgP4GYD1zLyHiFYSUTgU9DoAD3NjBtt7AAwQ0S4Az8HzEXS2IijbrMsmwcx4xRHvf1G10iwc3yoBnKeA0P1+NkxkSc6hEqy61ynP+9dk4uDKWyixkkfAzN8B8J3Itrsir1cIjvtPABfYGENb4Jxf9hzfUafnhZ/wZtRRJ+hjS8THZyUgdL6fLDeEurzvpXN9kuSXqEKRda5T3vevSYKaK2+hxBWdKxNJZ6ftvIpIgsiMsevbnpCIrkay8kukQTTTBbysZF1zTBIzm2rFonOdijC/xK0yA1qlIGFBOEVQJpIsX8touy0aE4FURgERCOSg8moYXcGa1MwmE6w6Duwym19aJd+mIJwiKBNJZqfOCdaMiUDKWkAkXa3NXgzwqPg9XcEaCPVFa73Xjy1JvmLUcWCXcXUVRnf10IG4onNlIkm5iCJmYWVPOjK1B6vs9mm+a1qbuep76I7Llt1e5z7Lo9xJ2e+9FsWtCMpAMGt8bInXgas2FdqzU5NZmA1fgsgU9dgS4Knbzc+VBtV3EdrYySwOP/iMNGa3tKs1mdlq1jxg462N49p4q3hctlaMOvdZHqurvM2gHeJ/c4qgaKI3d/0QcLLuLed1lq+6Nm5bD5GwmiYDAw/af0hkD2Hcd5m92IsSAjWOcde3zcaYVoimXa3JBOuex4HR4cZ9R4eBZ5bZH0OA7n1man4xEbR5m0E7yP/mFEHRpL25dWdhST5H9JBKBQjbfSBVD6HOd3npWe841T5xpBWiaW3mMjOIqGczIOnlbMlun8Vs31TQ5m0G7SD/m/MRFI2Nm1snNt30c2S25VqvXBDZfCBVD6HOd9EpKxFna04be57GZq6y7Ztg026fNscjes2HjpkVGTT5PWz4EsocBWUZtyLIE9EMW2fGZsNOaTozlAliAI0mF41zJUH6EO73EqviPt9GWYm0oaVpZtEqRVibKj5GtD3pGGzbxkXX3HRCkbcZtOxRUBZxiiAvZDfnrHnqm9vWTW0q1GQPY/0w0P9JNCkD29EhqodN1O4x+vk2ykrYMIckDVlUzUavug+odDdur3R72wPCgnzLSnEynYy4ey6JktDt1Aaoo7uyMoOKKGOOSUY401BeyG7Ol571bmbZMtZWjX7TfrGqZfiHvwDMuCTbML7YOv7wEq54VPz5qu9rUlaiqF4Pqusf91umDRmNE6RJzq1tTomJ7hL9HlEzkOi6GY0h9FlAR4SrUmMNuNagv7+fBwYGih6GGSt60OS8BACQN1OzfVxaosIE8GZDeWZjjj3gkgcbAFYcNT/vmvMlQna6N2MuA2muf9rvp7rnpAoq5tyyMVUnA8PHGz/P5D4TXSeQePxl+n0Lgoi2+/1fGnCmobxIam8syk5ZhpT82YvVy3BRCQYdWmHJn+b6ZxntlPTcsms+YSJSRXfJwpmzNl22GU4R5EVS4VOk0ArbtwPbet6JNSqBIPIV6FAGJadDUv9CmsnD7vVeNE+U4J5Lem7ZNZc6jCWrwKh/Qrpa5PL/viXC+QjyQseu+8yy8QejNhU476OeD2G47tvDR7ybOis7pSzkrsjy2Mr6+Yr2j3G0Qp/npCQNGRWaWeDdi1fdN369ZOeOC9kUXfPHbxErdNFqT3QfOjOQFZwiyBOZ8Nm93isREM4WrR8CBr46/ppHxh+4rJSATNjbcFgnjeuWOv/ILfVlJHVyyiJ7uiePHys7N5BssiBb1Ym2K81AER+DuzeMcIqgDGxZ2VwyQESSaCGTMaRJ4FKRZkUhjB4iL4S1XWf0Nkiy4tH9nUXnXnN+ssnClOly57Pu+AIzUJtH9mSJFR8BEV1JRHuJaB8RLRe8fxMRHSSinf6/T4Xeu5GIXvL/3WhjPC2HjRaEWY3h6H4vm1iErsM6TVy3yLa8aK0Xwuqwi+z3DDqjqbDtRBbN6KX+iemuvHRKUq8IiKgC4H4AHwRwAMDzRLRJ0Ht4HTN/JnLsVAB3A+iHt7bb7h97OO24WgZb2Y5pUcVfnxCFaBpU87RRfK3gh3vjjkGs3rwXvzpSx+k9NSy94mwsnNsn3d6SyHI3gs5oQLK8ExW6Zqw4J7YjFTZWBBcD2MfMLzPzEICHASzQPPYKAN9l5kO+8P8ugCstjKk1CHwDwphtAVne9LL2iAAwKrLjGlTzbPFU/Y07BnHHYy9g8EgdDGDwSB13PPYC/nbjC8LtG3cMFj3kZKTpjJYmui0uOi0wLUYjjGpTiymX0YbYUAR9AMJTgQP+tigfI6LdRLSBiAIDoO6xIKIlRDRARAMHDx60MOwSEOsb6DLrTZCGQAiYoGveaYW4fQWrN+9FfbhRGdaHR/DQj/YLt6/evDfP4dklaWc0GyG5stIWzyyLd2KbnjOqDDpcWeTlLH4SwEPMfIKI/hLA1wG83+QEzLwWwFrAyyy2P8QCiDWNjHo3+7JXchkOZi+Oz+SNomPeafFU/V8dEZe5GJFk5Yv2bykTUhozT5rfVCTwh+vyMiM6955OxFuR4dElwcaKYBBA2MV/hr9tDGb+LTOf8F8+AOAi3WPbGh3TiElkjo0ZjcpEJKLWq/e5JewXu3HHIC5dtRUzlz+NS1dtlZp0Tu8RX48KiauwRveXmZZKa0IqYgW3e708uUxGmucnvF03mKGNVw02FMHzAGYR0Uwi6gZwHYBN4R2I6LTQy/kAfub/vRnAPCLqJaJeAPP8ba2J6Y1y+V1AV1W9j242qK1OSg1LfMhLPgNexcsTv2vJDk4mwnnpFWejVm20m9eqFVz/3unC7UuvOLthm8y0JDIh6SqnTCki81plYqxNTa6YdPxTOsqizbuVpTYNMfNJIvoMPAFeAfAgM+8hopUABph5E4DPEtF8ACcBHAJwk3/sISL6O3jKBABWMrPhtMAySROfkiwvg+3hjOIwuje7bEbzzLLmbOVwhqgMWQYp4CkGHvWEw9Cx5nFnmetgEZVwjppsgtdR0w4APP5f44KaAHzsor6m42Wmpej2QDkF4xo8UsfSR3bhnif34Mjx4XxNSrab0MQ9R6qVb1BeO8lzqZNlrWMKs1UFuKRY8REw83cAfCey7a7Q33cAuENy7IMAHrQxjtSksRUmvVHCD1xSJSTtHXCo+fXGW8c/V4Usy/SUnnGfxYoes/GUCF3hHLBwbqOA37hjEEs37MLwyLifgAGs+/F+9J85tWHf03tqGBScN2pCEimn4VHG4eNeQEGwagnGU1qSPEcyYdw9ufGZWLTWfvl1HWXR5t3KXNG5MGkSn2y1nLRZZEzE6LDm95E4jOuHxpfDLRwWKrP7y7ZHWb15b4MSCBgeZdy2bmeDWUdmWoqakGRKKExLRCUleY5EfolKN3ByKL05RvZcBabcx5YAE2rqCL0Wvtd1cIogjCq7Ns7mX+SNYurgjVNOu9dD2o4SGH+gWzgsVFc4y4gT2mGfw8K5fbh30QXo66mBAPT11HDvoguaZvW6SkhHYRRKkkmRyC/R/bbm8GpbzeOjNv/6IeBk3VtxiCZhLXyv6+BqDYVRdjeKWd7abBJuimj5K7LfB8Qppy0roUxyCx7oFg0LDUI568MjqBBhhBl9hvZ3mbknTNjnEDUtiVh6xdkNPgLVZ5calc1dZf6M+iWkpkd/Ynb0wHj5k/phs/vP1JRr415PavrNAacIwsS1R8z6RklD9CHavR544tPAyFDzvkPHvPdlY4tbMYQVSQnKP5gQdciOMI+tBEzs7kuvOLvJRyDCZPYedUpPqVVxbOhkw2eYrFoCcs9hkE2KZs0z8x3ETcyAxsmOiU8v6aol6b1e8lwFpwjCBD+IrEY6kN2NYhtVRFL9UPIHsMWXwybRQiqCfe95cs+YM1eE6exd5JQ2EeLR/S87Zxoe3T7YEImUucNZNCmaNQ/Y/rXm50o1ubr8LvlkRoZOgMbu9X70m+AZz8qUW/KoI9ezWIS0Zytas+GFaQ9b3QYlOWB7Njtz+dOybrx4ZdXVVs8JAF+8dk5uET7R1Y6Kvp4afrDcKLk/ObL7aQxF/+37ZponmqnOpxpLlj25i+o9Hv00Sc9ityIQUcZmKGnsi6bL4KLNXD6iuPq0s1ndUE4b5wQwFuFjMt6kyk+02pGRq8NZFoocoJqF1xMUIladTzYWqmSbNJe0bEdOuKghEcIonAKboaTNakwS0VSCkhAmGbm6pI0W0j1ngGk5iSA/IZzxvHTDrqbjRRnIJsI9V4ezypwaZ2o0FZRx55ONhUezvcdLHnXkFIGIsjVDSZPfAJT+JpRhmvSlg24oZ4BOyYfwOUWYKK97ntzT5IAeHmHc8+SehjFFy2MsfWQXJKWPmkir+IyRNrzRmIWL7t2uqpdo1nxC4MJPxHREKyjMu4iyHQY405CMIh2/UTOQNHLCoLELULipx5QszDhAs0NWholpKjinzF+gq7xkjufwdlkGsooKEUaZY01NYbNUz6QqmIGj9ZTlLWRRRDqCUHbvblkpaFTDwEvPJhtLXmHeJX3mnCIoG6Iws2hz7gCTWUyJb0IZorh62Ww2ixBJnQij6OdOqVVxpN4szG2aYkxXRLVqRbnqCYgqvrDySeWfSTsREd27jy0R7xs3ObI5KSpxXoApThGUDaEzi9GsDAxaRbYo4bj6wSN1VIgazCxBq8hoCKetEEmZwB08UsfM5U+jZ1IVb751cmw2LnMYm5hieiSKpKc2XqVWpmxEmCTKxTmbk4TZjmF7IiJbKQdl0VXC2cZYSp4XYIrzEZQN6YwmUAah17qtIluYhXP7xpyxQSOYaKtIkTnFRk0e1Sye4c2Y40wyvZOqWrPxgBXzz0O1q9HYX+0irJh/3pi/wkQJ/GD5+7U/W2elUZryFrLaRHmVRU/rtysZThGUDaW5JyJ0glLTbY5Jq8gwaYWWKhpIF+bmVYnKAb1wbh9Wf/zChhXA206ZgIFXD405iHVI4hDWMV+VprxFVrWJdHuKtFk1UqcI0mK7a5FpAblwNdA2xbRVZIANp3I4wigJ0dm7bkOcEyfH+wYfPj6Mb217LTZHoEKkFQklI07x5R5tFEc0xFmWc2DS5U83TLvNqpF2po/AlpMnjZ1QNoYGZ5Zm7+ASpKlnWc9GFj0UFIwTUatWcNk503Dpqq2JxxT9TkeOD+HYkF7ClgwdB7Ron7j8f12HsIporSNrUUN5kTZpy6QMRJHRRxlgRREQ0ZUAvgSvQ9kDzLwq8v7tAD4Fr0PZQQCfZOZX/fdGALzg7/oaM8+3MSYpNp08SeuHxI0h+KcqdRFGNuPJKaohiwzgMLLooT+cMQX/+YtDTVeop1bFhy88LVWNHdF3EtFFwNtP0Xfe6uRGmJq0TCunqtANrS0laYWzibmnRUOyZaQ2DRFRBcD9AK4CcC6A64no3MhuOwD0M/NsABsA/EPovTozz/H/ZasEALtOnqR2Qt0x6M5kRPvl2GM1iwzgMKIksI9d1If/eu1oNI4KN1wyAzvvnofnXjwoHFM4MUuFbrmGUfYcvGGbfpjodp2GOFMk54pSq1bwxWvnGDmE86Cwvstpk7ZMzT0lyL63hY0VwcUA9jHzywBARA8DWADgp8EOzPxcaP9tAG6w8LnJsOnkSboU1R1DXFlsQD7jybDaYdRkIpstBzNbG2aj6Ez10lVbheaT51482PDZUQ4fHx5rFqPCZFa+evNerJh/HpY+sqshiiiI9gmjkxuhyhDunVTNv3+xAVmvDmNJExpapLmn4JwEG87iPgBhaXjA3ybjZgDPhF6fQkQDRLSNiBZaGI8am06epKUbdMfQMMMBmruGKVLqM4pqEDk7ZXLr9J6atnPUlDgTi8pRrLNSMXE0/+pIHQvn9uHai6c3XIvhUcbAq42VM3VKXBxRlLV+a3gUa/xVAIBiZt4Ksl4dZkpRZSByXL3LyNVZTEQ3AOgH8L7Q5jOZeZCI3g1gKxG9wMy/EBy7BMASAJgxY0byQdjU+knthLpjCM8SqCKon65Iqc+o2qHMkRlNdwtmubbq/0eJKz+x9Iqzcdu6ncJjdWb7ut3Cgs/cuGMQD/14f5O/4pvbXgMA9J85VXtVpFpl1YdH8Dfrd2Hg1UP59xnQIIv6UFaJm3nLVhRZzthL0KvAxopgEMD00Osz/G0NENEHANwJYD4znwi2M/Og///LAL4PYK7oQ5h5LTP3M3P/tGnTko82jdYXhYomsRPqjCE6SzBtlJNRoTnZA82AcJablWCIqyK6cG6f1G6vM9uPKyQX/czVm/diRJJc9s1tr+G2dTu1V0VxYZwjzMJw0jLMvHV8IIWRdOad9Yy9BDkJNhTB8wBmEdFMIuoGcB2ATeEdiGgugH+BpwTeCG3vJaKJ/t+nArgUId9CZkSFNxCfC2D7ZohTIHE13ANUjqwMlrmyBzrIYn1l1dUNzsusBIOOiWXF/PNSlZxeOLcPP1j+fqkyqBDFKjwZwcxeVc20onAWyGLJip55Z1Hm2xpJA0WyziIuQU5CatMQM58kos8A2AwvfPRBZt5DRCsBDDDzJgCrAbwNwCPk3dxBmOh7APwLEY3CU0qrmDl7RRBGN5w07+WbzmwgboafQaE5k0JwSfY3IS7UMRoXLzPJxFXclH2HsOLRaWYfZYRZWc0UgLZ5KqDombfuNS+EpDPvrGfsJchJcK0qdds4pmk1F7Yv1nq9bfXDalujbFxU8ZpoFBi3rBsFFOwXFIwbYbYa826DuPaOgcAH1MJt445B/M0ju6TmIRWqtpEbdwzib9bvEibOifwyaZPK2pq4Z13mBzBp9ZrUl5BT1JCsVaVTBHH9iZPcDGHi+rXK6rKLjsuyp2qEtCGfIgFbRkF16aqtsTN53f6+G3cM4s7HXzDOPo7rlyy7lh+7qA/PvXgw0W8U/n2n1KogQqnDUqWYCFDVMwUke0/k1yvomdXB9SyWoWz8EjITJV2+xdn6ZealAjMXZbHgA68e0hY8aaOFsixZEcak4qbOmHomdeP4kCdcj9aHdfLCY805ac0t0XFfds60hoijcFZ0WaKPpERX1yd+N15oLq5KgOqZWnO+3PQbTPTinkWZ+fjxW7z+CSXOPnYrgrgZOxC/dFShWyYivPooGNks2cQUIevUFTf7BfJdTeiuCOL8BHEmJhU3XDIDn194gfFxOojGJWlz1IDuKkj0eZkpcJ1nFYhfpYtIY/qNPUeIglcIshVB51QflVUJbUraEhA4hZKEiup6/gtIIpGhChENowpXTBMtlGdSUlyoJgG47JxpsWPSLUkh4pvbXhtLCLNdniFJATsgWfRRVsmDY+hG0iWtEmCyPem+Je1Z0BmKIC70MxDwMmWQJozLpKx0SW4S06xaEWnCCNPmHpgI02gY6uTuxjEzgEe3D8aW0Ugbthk0oF+6YZdVQZp0XDr3QPQ6r9i0J1sFrivg86wSEHcOESXsWdAZikA3DjiLJKxoPH9tqvdPRgluEpEQV5WREKET5y8jzWoiyaw0yBd4ZdXVqFaaH4n68Ig0pj8oEGcjbHN4lDE80jhfTytIk4wrTmFv3DGIOfc825QkJ6vAai23QUfAp6kSkDbvZvZir+QLxTQzKmHPgs5wFuvGAWfloBXF80ujkGJukhzCzETOyaiDEYgXGElLGsvs8Tr9BdI4qTfuGJQKsxFmVLuoqTXlsaGT2Lhj0KgkhSlpBKnOuHoMooaS+EJ0q6nGIgrYqHR7ncnC4djAeN9i3XBtIH3eze71XvtYWRUAoLQ9CzpDEZjU3ckgCUtIkiikHBtmR5XBcy8eTBWumOazRYpIFt2iMivFOTJXbJKXqO7rqeH40Mmm/sjDI4zVm/di6RVnY+KErgYBObm7gmqlS7tXgYw0q43g+8lyEWROYdm1SuILUVVTNUJnohZ9Ruqhon9ZN5iX+TBKkPsTR2dEDT11OzDwVcGJbgY+/AV7AzPFdHafNJchAUXnAUQFkUgIA82CTBYF1DupireGR5uE2KRqF+rDo7GZwV+8dg4+t26n1NFaq1aEAlK0ipBR7SKA0GAesnXNRb9ntUKY3D2hqQOZ6rdXXQMVBOSToyB7RsJk8LwAsBN5lDGdnUcgq9Ap254XpquPHItTZVU1VAfd7mBA8wpAZlZihlBQHx8ejf0MAGOzYVnLTNksWVcJBCGqgDxfIG5FI8oXCK/gwiu6nklVvPnWybHVSjhX5KEf7W9aPQS/vUphqsJSw/4aIMMcBZ1nISs/XEYVf/OgMxRBCar7WSGnG23jjvgomTTnjis7YWJ+CEpAhwWgyIT1OUlJah0md1fGVhoiYSfrm6xL4GsJvr+sXIes4QvgmbWiiWFBCezg9aPbB8dWF5eu2tq0wqoPj+Bb215TFrRbc+0coY+gd1IVV88+rcmPFCXzyYQqQTS8jw2iK/pZ8zwfQQv2Me4MRdDCmrqBHIpTBQJHRhp7dVSYBQI0OlPUVTaBAzkqIMMCL0A2m4+ji4Chk6Njx2ZhSNURjrIV2j1P7hGavOI+RzdXJMzpPbXYLOdw34VCKqTOmgcMPAjpN7H1vIj8dbu+7UUNvfRsy/Ux7gxFUILqflbIoeyEajaetmqo6txhISUzP/TUqpg8cUKDANI1Yaka1agYZWA0Bz/a4JG6MiJK1XrThHAHNxPFGO31IFNa4fdk/prMKqQGUTtRJdA9GRg6bvd5kYWkv/RsNv6HjOmMPOMcpwoAACAASURBVIKiWtBlQcYNs1WztbROy7iZYPC+LBltxfzzmnoe6CafLZzbh1q13Le7KvfBlvAMd3DTzRUJ910wIffeBLKoneG3gEVr9XuP6NAu5mafzlgRAPmFhbY4spliX8gsYPvc4fcBsyJrcS0rw7zlO4ZbgaBxzefW7ZTmcejUDAoTndUDerkiSScAufcmkAlhHgE23go8dRswdCy0f4pw0izNzQU0su+M8FGgkIvbisSFjSYpKhZ2EMuEV1KBYxLmqiow1zupikndExL5EWQEznAbiMpOq8YaOG9N8z7yqvqaCTqhoyKShJNmVXI641LWnd2PoAXqhJcJmTBIklugqn4ZjhqKhjqmKbOsapQj8xMQII2IKQsmORM77pqX59DKgW510iYSxvlnMbnMOFco0zwCIroSwJfgtap8gJlXRd6fCOAbAC4C8FsA1zLzL/337gBwM4ARAJ9l5s02xtRA3m0mWxyRM1DWKSsu4kVW/TIs1FShkTrKQLeUxcK5fbjnyT1CB2s4IiaJUzkPdHMm7v7IeU3HtvRMX5fgWX78FnWZhyhJzTlZmJsL8j2k9p4RUQXA/QCuAnAugOuJ6NzIbjcDOMzMfwBgDYD7/GPPhdfs/jwAVwL4J/98dmkzx07eBIJaZuZQOYF1nLk2yk7rVhy9+yPqhvZ5C0fRA9gl8dr2TGqs2aNb2G/jjsGmqqZLN+yyVx66TMxeDHz0K/oVf8sWPVhQI3sbK4KLAexj5pcBgIgeBrAAQLgJ/QIAK/y/NwD4R/K62C8A8DAznwDwChHt88/3QwvjGqdd8ggKIi7BSxXRouPMNS07Hddxa/BIHbet24nb1u1ET62KFfPPa0rWUs2Obdr246hUCG+PlHkAgKUbdjVVIn3zLa/AXXisOquhe57c03Su4RHGPU/usa74SrHyiIZZ13qBoTeBkaHG/WpTgavuK5dVoKBQdxuKoA9AWMoeAPBe2T7MfJKIjgJ4h799W+RY4V1DREsALAGAGTNmmI2wXfIICkI1448LB5SZL8LHmET+iMxIqmzYI/VhLH1kFwA0KAOVcLr+vdMbsnKzZHiEMXniBOy827PpB4I0KrgBr1xFkqxcWa6BaQ5CHGlNfFaJmm3KHiwSbcE5oaZXMdUSLRM+ysxrAawFPGex0cEF9v9tB2SCWie+XGcGrqMsApJ03BoeZdy2budYldA4ofT5hRfg0e0HUM8p3DSojCrzX0T3LStF1qeKpczh46KKqdWal/uQ05htKIJBAOHWXmf420T7HCCiCQCmwHMa6xxrhzLfCCUnrl9vHHEzcJWyiJoa0oR3msxQ7100Ozen8ZRaVTtayTSxbOOOQWnIbo+tPgE+aTvLFU5Rq4YSBLPYSLV8HsAsIppJRN3wnL+bIvtsAnCj//c1ALayF7e6CcB1RDSRiGYCmAXgxxbG5LBImm5jOsSFq4adnLLsV92S97pO6IVz+zAph0zkWrUCInFlVNG+Jlm5wfUTKYFqF2HF/OboojTodpaz3ZfZCnHtbLOkBMEsqVcEvs3/MwA2wwsffZCZ9xDRSgADzLwJwFcB/LvvDD4ET1nA3289PMfySQCfZjaJ+yoBZbc9WiJpt7E4VHZlmRkoOsMNkq2e3v26lt1bZ4a6ccegdglpXb547RwAzSsf3cqoUeUb55iVOfkrRLj24ulYvXnvWOayrlN3447BhkqnvZOquPsjnjNex8RXKj9CmCJn5SUIZumMhLKskCWwlDEaQZO8oz5kSVF9PTVlBcvgfVHN/jhbu6wrl864JndXMCrpbaCiQoRf3Puhhm3hjOs4omPWSe6bufxp7RIUOqa+jTsGsfSRXU0KslohrL7mwtjMc1kuiuj75U6RTWV0El4tTTg7uzFNVsiKXNUPZdsSLyOKmK2p7MqqKqQyoRFeuciEZXSGKhJcsnEdHxrBmmvnGJe1vv6905tm07qITEJxuRerN+81qkMU1DYC5L/16s17haukoF1ncO1V/RSS5KKkRkeIFjkrF4W7AsBjS7xt0T4HGbTcdIogDSobXgtmLucV9REWvl2SmP0uIqmgDRrGx40pLmLpbze+0BB6GlZ8qpDWQNidtfxpre97wyUz0H/mVOFsWkQXARMndOEtv4WmaFUmE5zBd0hSJmOEWan4kyQOBqTJRUmFqs830Ch8u6rAaEhJ5xliHgSziMYr6q9gWb44RZCGuG5ILZa5nEfUh6w5TRRVQld4BhqcUybsVTNUUf5BoPhMQlpVVIjw+YUX4NJVW7V9Dt5uhDXXzpEqO1VIb5paSSrFr4raihPkaXJRUiGz/T+zDDhZbwzZrHR7Zl1b8ftJzDlCK4PkvrEoX8pdoL3sXH6XOpW9xTKXdaM+0qByYJL/vw6BYBFFFkVr+cvGoeqgpRMppdPf4Pr3Tm8Yry5x0U2yWv8yBRp8Bx1kY116xdmoCupfVCsUK8hl91DSXgfayIRl/VCzwB0Z8prY2Oj1kTQKyUS4W5QvThGkIWh4U5va/F6l22xZuXu9nYYZKcijkYhMyIwy45VVV2t3AwsEi6qFY5JxAMAkv0dxEM2z5to5Y41wwty7aLbyM2rVLnx+4QUN4zVB5YOQKSqZsA9WStHfV7av7DNXf/zChvyD3knVMUexjI07BnHsxMmm7bVqBf93sfpYKbrPi6mwtDXLVkUhqZCON6KALZutnGlIhc7SLni98dZG+6JJNJbKjqk7K7EQVZBHI5G4chI6SWNh5aRq4ajyI6g+59jQCI4Nee+pHOYL5/Ypk87uXTTbKDIoSnh1JDN/Rcc08OohYXmMy86Z1vT7TqlVcWzoZEM5izjFbxpGLHLYA41hp8aYPC+y8jITat6qIIqJ4lA9c0lzA2TjzbgXslMEMkxuti0rG5UA4L3WdeakjWG2oUh8og96kPyjqxjiwk/jbO+i9wEvbPP40EjTOVUCXWTrTiKYVXbzPsnn9/qVQuMctzdcMkNa1ygw86ic2tExPbXrdeG5nnvxoPC3AbJV/DJT4KTuCck/J+55iQpokRAF0tUfi3vmkkYhFVQOxykCGSbCOW1mYNrjM0qGMQ0n1dk/+D8c6z9xwriFcuHcPgy8eqjJkTvKaHCe6gj06GpBNjvVQWU3l/UEiIuUATwBLVMmfT01bNwxKFQUYR+CTkhqNJooeH3vogti4/fT5JZkEoCgel5EAnrXt+VNqJIKXNkz9/gt3t9pCl0WUA7H+QhkmAjntDXE0x6fUYq6aZ8Ak/3D/YOP1IcbHLzPvXhQGs0DNDqIVURt3TqCWfdcASqnso6w+9WRutB2X60Qjp04qTQ9DR6pY+kju7TyEkTRRDrlNnSc8aqSEZkEIKieFxPb/OzFnlM4iXNY1R85WBl85MteZzGQ93+JOyI6RSDDRDiLoodk2l/k5DI5Pu1YDVDFqptsj54nTmHEzSJ1BLrI1p10FqpjN//B8vfjlVVXNziVdYRdkJcQVia9k6oAI1bAV4i0Q1KTJHIFmcCq3ypOUWQSgKB6XvKq26N6tsKr8aSKJmecIpBhIpyD6KE47S8LKQPSzR7SKhIJMkFGQFN4ZlDlUuc8cYI+bhapEl4EL/P4lGoXPrduZ8MMVUcwE4BLf3+qlQJ7l50zTfl+OOwyrEwmdU/QEvC6zXN6J1WV0UQidDOB45R6JgULVc9bXh2+4kLHj+4vPArQBOcjkGHqtNGx66mWrWlmDKKxzprnvX5sSWKHU1AQLSoKGM2OWFlcPvnnCSNz8DK8Gj/RjmNA4yxSdnyfb7+W+SlE9vxqhTC5ewKO1IfHOpP98rf11E7TjTsG8dCP5MmGqqgZmwl84R7GJglyupnAOj6ATAoWyp43Hdu8jbo9sf2RadxZnEFJCNs4RaDCttNGumz1Zw9hIW4aKhYeq6UoIlV4ZFQAyAQCo9mxLIsMAjzB/ej2QXzsoj489+JBoYNSFXmkmqEGTlFR5IzNGktxs2kCsOOuedLj0/ZdCOgTOHZ1nb66mcAm3eVyIW4CZzHCbmz/psKTgg4QJS854xRBnkhLUkRmDwNfHX8ryY1qMYpIFtESfdBVs/Qo4Xh20TH14RE89KP90mQjVb6DrKRzINhEs9NLV221WmMpbV0dkaKTNZeJolpp6MzMgwgh2WdFM4FtleKwimoCZ+PZiAtPlZWdKXHJGacI8kS0bNV5xE1vVIsOM90H3VQgBEJJVio5rgCaTKglmaGaOsXjMKmrEw6DDUxTfT21phXRZedMw0M/2p9pCee48FpRqeo8khCtkvbZ0AlPXXN+4f0FTHHO4jwRObl0iwXbqEGS4EbUdfYldQqqBLRuN7EwSaJUTJziQHyHLd26OtEw2EDIB+axpVecjVdWXY2lV5yNR7cPCpWAzdm3aiWj+j1lUVOlJO2zoROemlHwRpa4xjRFI5s9RJky3XMo66DT6KIkxM1CCRir/28ru1m0v8gpDiRrCKO7j6xJS/SzZU1yKkTJa/UIkK3OCMArq6628hmFI2wm5a/Kp0yP98fpNrApaefCTBrTENFUAOsAnAXglwAWM/PhyD5zAPwzgLcDGAHw98y8zn/vawDeB+Cov/tNzJxPx/CyIDQXRTCdTRSUpp6EQIjJhGLPpKrUkQuITRJRc0U4lDEgqixUlUjD6DSECer4nFLtwpHjw8JOXSpncvSzVYX68qwD1RY0PBv70WCa1fHH6ZaOKCA7OA1pfQTLAWxh5lVEtNx/vSyyz3EAf87MLxHR6QC2E9FmZg7U51Jm3pByHK2LLPQzbYGpFroRA2EmmkW/NTyCeigLGfAE7x2P7cZbw6PC+jvRc0WjgESlMGSeGt0ciMEj9YZVxZH6MGrVirCngG6Gc1whPtsCupSO3ywIng3RajzOH5emdESJSasIFgD4E//vrwP4PiKKgJl/Hvr7V0T0BoBpADJuBKpJGZZwLSS0s0LkdLzsnGnSgmxR5eBtG5+Zq6KARIJYNjePJoWpQjtlZTF0u4uFiSvEl4WAbjnHb1qSOI5lq22gMQS8pCtwGWkVwTuZOSh3+GsA71TtTEQXA+gG8IvQ5r8norsAbAGwnJlPSI5dAmAJAMyYMSPlsH1sxhSXkTIoOQOikUCXrtpqfA6ddoomCVtP7359rKcAoM6B0B1PXJ5ANP5fJaDTFIQTkUnyV1lJUyE0/By1gRyJVQRE9D0A7xK8dWf4BTMzEUmNnkR0GoB/B3AjMwfTuTvgKZBuAGvhrSaEnRuYea2/D/r7++14uE1iiltMqLbDzZkkwzYwl6TteRAQ7WsQlwMh+8wwS684u6l/cbWLsPrjcsdvWEAHwv+2dTsbTFppEuFsK5SWYNa85n7AScw8qkqkKTL78yQ2fJSZP8DM5wv+PQHgN76ADwT9G6JzENHbATwN4E5m3hY69+vscQLAvwG42MaX0kZ3aZi07VyRJO2QVCKSdvU6PnSyqaVi1NQSDTFVNciMhrAG4ZI6rR+PnTgpbpsZ+cDhUcZtkdpIIqIhp6oqrbokbffZ0uxe78X/N1xB8pLDTAW2qhJpi8iLtHkEmwDc6P99I4AnojsQUTeAxwF8I+oUDikRArAQgGZ8pCV0Y4pbUajmVYUxQ3RbK0Y5fHwYIK/4nCinQZTz8KeXyM2Nql4EceOLltgGPMUS7goWZvBIHUs37MKce54V5inoOJpNV1Km5cbbAlmT+JeeNT+XTg5CyeVFWh/BKgDriehmAK8CWAwARNQP4BZm/pS/7Y8BvIOIbvKPC8JEv0VE0+DNj3YCuCXleMzQjQCwKVTzMjEltX+WiKht3MQeODzCIJLHv4ts4U/tel1Y+lnViyA8vtN7ajh24mTTOaJO4zhBPTzCY+eImnt0hLzpSiqT5jFlx+YzrRMCbnLuAszQqVYEzPxbZr6cmWf5JqRD/vYBXwmAmb/JzFVmnhP6t9N/7/3MfIFvarqBmd9M/5UM0C0fbStTN6mJKUlj+xbMbhQRzlrVMcWECez7uqyYf55xVnI0q/aopIdAWKiaCurw7Fzn2CPHh6RZzyJ6JlWF29sqfyCKzXLVUTlCklWizrkLMkO7EhM6zSNsCdUkJqakN4aukmshZOUjeiWCDGi276uwUTtfpyNXEpNXoEh0jj02NBJr6w/KZJy1/OmxlqFhwr0S2hLbE6WwHPnoV5KfuyAztCs6p4NOpq7Oci7JcjRNtcQ2y0+QhVEC0C6XHRcdE5iMgv0+t24nVm/eqx1FoxPzH4080qksGiiS6DXo8gvVyRDlMuj0bp6cprl82VA9m1mYYNKcuyDfnlMEuqiEqm6oZhK7fR43RguFxops+yrzR3gmLsooFoVb6u4nGx8Qn5QlCgf91ZE6JnVXcGyoUUCLFElw7FnLn1aOB9ArkxFFZuJqOeKezazu86TnLsi350xDNtBdziVZjmbdeq8VQ2MjyMw/0e5outExaaNoTKtxBvuvuXYOoh0qCcDHLpIneVVIFfjqoVsmQ3VMKUjiK1PF+JfxHi/It+cUgQ10Z+2zF3txyoEziSrxcctZ3xgF2STjSjmboNsdTTc6pqgoGlnpi+dePCg9Jq5wXbCaCF/vrhjlUcr6QkknLKoY/423lk8ZFOTbc6YhG+gu54IklqDHKY94r2dcou6FDGRnuinAJpnG9BIcHza9TKlVhWGf0Sgj3eJtRVXhTKKAZB3kgPFuZUBjET6R8gj8FKL2lqUgqa9M1TFsdBh4Zln5zKAF+PacItAlakcPVwit9QJdVe/GChDN2pPezFneGAXYJFWmF51WilElUq0Qql3UULIhTRc1WT2h40MnG8pN2CaJApK1tfzTS2aM1UgSteIEPLPSKHNrlJRIOmGJi/GvH0o3rjbBKQIdRA6ncF/h+iGg0g3UpgL1w3ajhrKmgLK6aUwvIiUyPMLonVTFpO4JsQ7a4Bw6+63YtKdhpXH4uJclPPDqoYY2kraEaJIqozrfSdXPINOGMzaDENIUiAOAx/53ss/tEJwi0EGYjh5hZAjongwse0W+TxmzfQsoq5vG9CITakeOD2PHXfNij9etrhmUqxZlCX9r22tWCr2JPhMwLwMd950KMXXZLnqYZsIye7FnAhLN/mtTzcciooUi70Q4Z7EOujN2nWVqGbN9o0l1QKaRREn6CgfoJGzZQuWEDqMbUWTTQW5CmuudGNtBCGmdqFfd563aw1S6ve1paYPIO6cIdNCdsessU1sh2zfjSKI0Gbx5CjUT5RJn1tKp8JlVFVAbGdPGZGEGVVUBiAstnb0YWHB/47O34H47z14rFqWM4JrX6yBseB2hpM3hE6HboLsgbNfOl51PlIErywKONrmPnl/Wkzl8nKxJvercqvEXwpiJRBKpM2X6+KrT5meKzEZ5PY8lf17CZNK8vmPIqq9wGdm9HqCu8RDXMCWpXGqzi5YqlBUAJk7oGnuvd1IVV88+DY9uH9R26MY1qg+vJJI40dOG4lolbsIUZwZNamePm5Fnbbsvo+/PEKcIdGmzuj1CggdZpATK4MvIAFko6z1P7sFbw6MN7701PIr+M6ei/8ypWjNw1UogIGx+SuLUTROKmxiZwFYFVUyZrhbCaZzLUjPU/ny69LVBQ3unCBzjyB5kqpgvs1skikI22xZV5AwErE7ZiLiVAOC1pwyvJJKEj+aeBa0S2FL7P8Wbg9IUV5TNyKmS/JwmZJ30mQPOWewYR5WOb6oEWiSKwlYTlyg6hd2i7SqTOHXzjKICoBbYUlMIx9cGSuNclkXjiVa2uuc0RaecfYlxisAxjvRBJuCp2/ULfrVQFIUsCqmnlq5Zi05j++ERlvZD1i1Yl3toqMwJfPSAWCCHj3vys/L7KE1xRVk03pTpyc/ZYaQyDRHRVADrAJwF4JcAFjPzYcF+IwACD9xrzDzf3z4TwMMA3gFgO4A/Y+ahNGNypODyu4DHlqA5AoKBgQfHt8fZWsuYQS1B1ePA1EwTphLTJyAgrQknaRJaInavhzRuasoZEROJQGEM1+X3UVo7u8yH1+K2+7xIFT5KRP8A4BAzryKi5QB6mXmZYL83mfltgu3rATzGzA8T0VcA7GLmf4773NzDRzuJFVP095WFAq45XxJFkUHoYIakCcvU6RMAxIeGlgrZ7woCFq1tFMTSkEoBwX2RhV+pRXxVeSELH02rCPYC+BNmfp2ITgPwfWZumjKJFAEREYCDAN7FzCeJ6I8ArGDmK+I+1ymCDJE+7CIkcdJFx3WXAFlOQJhatZJ9YpcOusJSKdyp8Vgb95HDOjJFkNZH8E5mft3/+9cA3inZ7xQiGiCibUS00N/2DgBHmPmk//oAAOkTQURL/HMMHDwor8/uSInQziupXy+ztbZKBnWGiGz31Qqhp1bNL7tXB5ljX2TLV9rWI0EBKn9BlKJs9kka3bQpsSsCIvoegHcJ3roTwNeZuSe072Fm7hWco4+ZB4no3QC2ArgcwFEA25j5D/x9pgN4hpnPjxt0R68I8ljqikpu7/p2R8/wk1CqjF8ZKnNPePZfrXlNlKL3gYgmU49iZRDcR0C+JpwOXbUWahqKHPM1AE8BeBTONGRGkTevs7W2J6a2/MvvGr8PVGaisKlH9RmL/tX7P+/7uk38WKZkZRraBOBG/+8bATwh+OBeIpro/30qgEsB/JQ9DfQcgGtUxztCyMIyn1mW/RK3xeOkHRJMzDJHDzTeB3HhmYHpRaYEpkyXZyRnHW7cQpFteZBWEawC8EEiegnAB/zXIKJ+InrA3+c9AAaIaBc8wb+KmX/qv7cMwO1EtA+ez+CrcMiR3aT1Qy2RvOUoIWl8Qqqy6g2+BwHhMM4ihHKavIU2JFUeATP/Fp69P7p9AMCn/L//E8AFkuNfBnBxmjF0FKr+q2GySKN3tCfR8gi1XuDkCWD4WON+ovh7VWmFNefLfQlU8fwNwfGy+7rWm1lzpHaoD2QTl1ncSphEYrTrEjdppEcrR4ikGbvOsYG5Z9Fa4GS9WQnUpsrt9TKToer+4xHP6RyMRXRfV7qBE7/LbqXrItsacEXnWgnRDGzomLgFXzsucZNWqLTdNjFP0ozd9FhZ0cHuyebXKW71Gl616t7Xw3Xg8Vvk4wfMgho6oaKwJq4xTavTSWFwSSM9ZMdRBeDRYqOg4gRXmugW02NtNlh56nZgIM7lpzivKtJIdn930rOQkKyihhxFo7PEbWWzSJikTkVVVdUsHexx112nSmsaR6rpsbWmFCD1dhUvPRu/j+q8qhWtLKKohYodlg2nCPIga0Ec18u1RUpCx5I00kPHTGZbYOhcdx3BlSa6RbZP4ITNcmKgo6hO/E7+2XH+MNH5XUhoYpwiyBoTQZyFwminWZIqXNH0OBFJBYbod9O57jqCK+l3lh2rcsLWmwoHe8i2q9BRVKPD8vswWOnKQllFqwkXEpoYpwiyRiUQwgLkvpnAE5+2P3PPepaUp9kpaaRH9DiqiPejLvPxyxS9qm5/gI7gShPdIjq2+22eAA4T11gmiWnIhvKdvdjss+OUZruYSDPAOYuzJs7ppVu3JSlZptK3qnNO1WTddPxKR7SgQ1b4uhdx/UxKSgR0VYGF/zQ+Jt3InPB+1BV/PYzGq6h8Kxpbq96rlnHO4qKQzbJE/VRFBDOmpLOZNKaFOFrV7BTMlEUrA9PxqxzRcdc9zWxf534Q7ZPETBI24Tx1u9e8SGflGvZdffQrYjPV0DH1dzA198j8Za16r+aEUwRZY9pPNcqUM9I5fLNMnGll59zsxV7oqIij+/WVrlRQTZdf97CA3rLSq+465QzvugUmQxU694Nsn1nz9JMSwxw94J0z3GEsQEegRu/D2lSA2c8V8Mf3xKc9E2n4utuayLTyvZoDzjSUB6Llalx5XmB86Srbt+hKia1ewfG+meJkvCgqE4KpyUFlltI5XjXu8HVX/TZaFUQjUAU4ZYriehnmGug0rrFZorrV71VLyExDLrM4D3T7qXZVgYm/50VphG/4x5aIz1v0bKZT6rWoajep6u2IkGXv6n7e7vVyYRy+H1Qz4PD9qNtJjEfUStPU5KRz7wbXwUa12065VxPiFEFRmAgQWbp+0WFxooJlgKe4tqwsf88Ck7BImeAy7dOgq7wDU0ywGgycz7KIJ8BzyK7o8cZR69UrPSISkJVuYGQY+k5lMheougUUbU12TBV2h+EUQZHo1jop82wm+A6tWM9HVxgF+0ZJ8p11P7PW23juwKek8i0F7x3d760uK93AyND4+yYVRGWr0CYI6P+k+W8suqdFpJnsiJR0B5mBTHDO4lagFSoltmJUhsgRGQjQMDKlm+Q768TXB+/rRJXJGB32cgZ07hlRpI00p2Bq4zkXrQU+/AXz8Ymcx13Vxn3STHbaKaM+B9yKoFUoe6XEVozKkM2GRdtE1z7JdxZ95qx5Xm2eRDNyBfVDXuXQRWvtzNirNeCq++zdh9F72mY7VJWSLvNzVBCpFAERTQWwDsBZAH4JYDEzH47scxmANaFN5wC4jpk3+v2L3wfgqP/eTcy8M82YHAVRVj9GHDIFqyMskn5nHaUeF1UWrpwqK0UOJDfRFWFTtznZacWJSYGkXREsB7CFmVcR0XL/9bLwDsz8HIA5wJji2AcgXJpwKTNvSDkOR9GU2Y+RBbvXewI4iq3vfPldwMZbm8tBAOJM3yc+3egPCJN0Jmx7FWpzxh93bl1nuQNAeh/BAgBf9//+OoCFMftfA+AZZj6e8nMdZUPXj9EO9V6C7NqooFF18jJl9mIvlFjExN9r/oy4fCDbM2HT3zFLm73o3ENv2vU5tDmpEsqI6Agz9/h/E4DDwWvJ/lsBfIGZn/Jffw3AHwE4AWALgOXMfEJy7BIASwBgxowZF7366quJx+0QkOVsLfwZtuq95DFe2ec+tgTC0MraVM8mb2tMunV2dHIBbCZOJfkdkyZ06fzOsnPb/j3agMQJZUT0PQDvErx1Z/gFMzMRSbUKEZ0Gr4n95tDmOwD8GkA3gLXwpMgnwwAAC2FJREFUzErCkAtmXuvvg/7+/tZLhy4zeYV+2nLgFRmqumUlpPH19UPjq4Sj+z2F8dq2ZFE1gL4PIm62b3smHPc7ioR3Epu97u8sO0f9MLDsFb3v1OHEmoaY+QPMfL7g3xMAfuML+EDQv6E41WIAjzPzmNGTmV9njxMA/g3Axem+jiMReYV+2nLgFRmqajRW9mrzJDV/6NbZUdm9swg1Vv2OMhOQrJy0auy6v7PrQ5CatD6CTQBu9P++EcATin2vB/BQeENIiRA8/4LL9iiCvCIsbD2wOuPNyhdhLFy4ufeE7nh0/S4yhbHoX+2UZ4ii+h1lwjsYU3SMqpWKtKdDZHuWFXY7hLSKYBWADxLRSwA+4L8GEfUT0QPBTkR0FoDpAP5f5PhvEdELAF4AcCqAz6ccjyMJec2obD2wcePN0jEpTAgjoDpZfkxDs5oE1WNlbUjD++SZcKj6HVVmGtMxShsIRba3QsJlyXHVRx35Nu2w4eSNG2/WlSZF3wGQO5F1mtS0GrLf0ea1XzFF8d5R+XsOKa76qENOnslDNmLT48abtalL9h1e29Zcr1/Vha6Vk5tk18BmPsmU6XKl4rCKUwQOj1ZKHgLU4y0qy/nDXwBmXKLfeyJJL+Cyk3ZSEb5var1eLkA4qc7Z/jPBmYYcapIIdJnp5sJPNNfUMe2DqzvmMvWn3b1enCVc6QYW3O9s2QGi363S7RXPi/bocCRCZhpyisAhJ6lAlSY4EZrMJkEHKtuCO6sVSdLz6nQVs/VZrYrrIpY5zkfgMCdpApjU9q3odWu7UmQW1VrTJLLJmuCoGt60Wn+HtLhCcYXh+hE45CR9ME1s8UcPtI4ASJPIZhqiW8b+DlnXiXKJYYXhFIFDTtIHUxZrLztX2QVAIAClCU4aCss0h6JsyjGPRi8uMawwnCJwyEn6YIoSfPo/KT9XmQVAgwCUoKOwTJOeyqYc81ihuMSwwnA+AoecNKGAIhu9KLQyvE8ZHaPPLFO3jDRRWCZ+i7L1d8hrhVL2TnxtilMEDjU2H0zVucooAHavl3f+ArwZa5aJd0B5lGOrdqBzaOEUgcMhQ2X2yCOksSzKMetubI7CcT4CR3thM7JFZfboFAEY+Eiy7MbmKBy3InC0D7LY+9e2yTOaVcjMIbWpnSMARU5iwOv81SnXoANwKwJH+yCLbBl4MFnYoyya6ar7rA259JQtjNWRCU4RONqHJBnNKlw4Y/nCWB2Z4ExDjvZBZsoRoTujLYvDtijKFsbqyAS3InC0D8KMZgluRquHWxV1BKlWBET0cQArALwHwMXMLCwJSkRXAvgSgAqAB5g5aGk5E8DDAN4BYDuAP2PmoTRjcnQw0dh76hJ3BgO5Ga0Jnb4q6gDSrgh+AmARgP+Q7UBEFQD3A7gKwLkArieic/237wOwhpn/AMBhADenHI+j0wn3+OVRyU7sBJvDESKVImDmnzHz3pjdLgawj5lf9mf7DwNYQEQE4P0ANvj7fR3AwjTjcTgakDo6XatDhyNMHj6CPgBhD94Bf9s7ABxh5pOR7UKIaAkRDRDRwMGDBzMbrKONKHMxO4ejRMQqAiL6HhH9RPBvQR4DDGDmtczcz8z906ZNy/OjHa2Kc3Q6HFrEOouZ+QMpP2MQQHgtfoa/7bcAeohogr8qCLY7HPZwjk6HI5Y8TEPPA5hFRDOJqBvAdQA2sdcs+TkA1/j73QjgiRzG43A4HI4QqRQBEX2UiA4A+CMATxPRZn/76UT0HQDwZ/ufAbAZwM8ArGfmPf4plgG4nYj2wfMZfDXNeBwOh8NhDnkT89aiv7+fBwaEKQsOh8PhkEBE25m5P7rdZRY7HA5Hh+MUgcPhcHQ4LWkaIqKDAF6VvH0qgP/OcTgmlHlsQLnHV+axAeUeX5nHBpR7fGUeG2A+vjOZuSn+viUVgQoiGhDZwMpAmccGlHt8ZR4bUO7xlXlsQLnHV+axAfbG50xDDofD0eE4ReBwOBwdTjsqgrVFD0BBmccGlHt8ZR4bUO7xlXlsQLnHV+axAZbG13Y+AofD4XCY0Y4rAofD4XAY4BSBw+FwdDgtqQiI6ONEtIeIRolIGjpFRFcS0V4i2kdEy0PbZxLRj/zt6/xieLbGNpWIvktEL/n/9wr2uYyIdob+vUVEC/33vkZEr4Tem2NrbLrj8/cbCY1hU2h70dduDhH90P/9dxPRtaH3Mrl2svso9P5E/1rs86/NWaH37vC37yWiK2yMx3BstxPRT/1rtYWIzgy9J/yNcxzbTUR0MDSGT4Xeu9G/D14iohttj01zfGtCY/s5ER0JvZf1tXuQiN4gop9I3ici+rI/9t1E9Ieh98yvHTO33D94PZLPBvB9AP2SfSoAfgHg3QC6AewCcK7/3noA1/l/fwXAX1kc2z8AWO7/vRzAfTH7TwVwCMAk//XXAFyT4bXTGh+ANyXbC712AP4ngFn+36cDeB1AT1bXTnUfhfa5FcBX/L+vA7DO//tcf/+JAGb656nkPLbLQvfWXwVjU/3GOY7tJgD/KDh2KoCX/f97/b978x5fZP+/BvBgHtfOP/8fA/hDAD+RvP8hAM8AIACXAPhRmmvXkisCLneLzAX+OXXPfQ2AZ5j5uMUxqDAd3xhluHbM/HNmfsn/+1cA3gCQZaci4X0U2Sc87g0ALvev1QIADzPzCWZ+BcA+/3y5jY2ZnwvdW9vg9f3IA53rJuMKAN9l5kPMfBjAdwFcWfD4rgfwkOUxSGHm/4A3QZSxAMA32GMbvN4upyHhtWtJRaCJlRaZCXgnM7/u//1rAO+M2f86NN9gf+8v99YQ0USLYzMZ3ynktQbdFpitULJrR0QXw5vN/SK02fa1k91Hwn38a3MU3rXSOTbrsYW5Gd4sMkD0G+c9to/5v9cGIgoaWGV93Yw+wzenzQSwNbQ5y2ung2z8ia5dbIeyoiCi7wF4l+CtO5m50AY2qrGFXzAzE5E0PtfX4BfA69UQcAc8IdgNL0Z4GYCVBYzvTGYeJKJ3A9hKRC/AE3CpsHzt/h3Ajcw86m9Ofe3aFSK6AUA/gPeFNjf9xsz8C/EZMuFJAA8x8wki+kt4q6r35/j5ulwHYAMzj4S2FX3trFJaRcAlbpGpGhsR/YaITmPm131h9YbiVIsBPM7Mw6FzBzPiE0T0bwD+j8nYbI2PmQf9/18mou8DmAvgUZTg2hHR2wE8DW9SsC107tTXToDsPhLtc4CIJgCYAu8+0zk267GBiD4AT9G+j5lPBNslv7EtYRY7Nmb+bejlA/B8RMGxfxI59vuWxqU9vhDXAfh0eEPG104H2fgTXbt2Ng0V1SJzk39OnXM32R19ARjY4xcCEEYNZDk+IuoNzCpEdCqASwH8tAzXzv8tH4dnH90QeS+Laye8jxTjvgbAVv9abQJwHXlRRTMBzALwYwtj0h4bEc0F8C8A5jPzG6Htwt8457GdFno5H14HQ8BbIc/zx9gLYB4aV825jM8f4znwnK4/DG3L+trpsAnAn/vRQ5cAOOpPhJJduyw931n9A/BReLavEwB+A2Czv/10AN8J7fchAD+Hp6nvDG1/N7wHch+ARwBMtDi2dwDYAuAlAN8DMNXf3g/ggdB+Z8HT3l2R47cCeAGeEPsmgLdZvnax4wPwv/wx7PL/v7ks1w7ADQCGAewM/ZuT5bUT3UfwTE7z/b9P8a/FPv/avDt07J3+cXsBXJXBsxA3tu/5z0hwrTbF/cY5ju1eAHv8MTwH4JzQsZ/0r+c+AH9he2w64/NfrwCwKnJcHtfuIXgRccPwZN3NAG4BcIv/PgG43x/7CwhFTya5dq7EhMPhcHQ47WwacjgcDocGThE4HA5Hh+MUgcPhcHQ4ThE4HA5Hh+MUgcPhcHQ4ThE4HA5Hh+MUgcPhcHQ4/x/SWCBiFy21zAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(class1[:, 0], class1[:,1], 'o')\n",
    "plt.plot(class2[:, 0], class2[:,1], 'o')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0\n",
      "Parameters [-0.6397935   0.59734723 -2.06981536]\n",
      "0.3866666666666659\n",
      "Epoch 1\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.09119178 -1.40839408  0.21642038]\n",
      "0.4993909295352294\n",
      "Epoch 2\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.1484551  -0.94306209  0.80704923]\n",
      "0.49774071645347884\n",
      "Epoch 3\n",
      "Parameters [-0.64629078 -1.49313992  2.0904544 ]\n",
      "0.32786116332220716\n",
      "Epoch 4\n",
      "Error rate is limitating the loop\n",
      "Parameters [-0.00029498 -0.00494471  0.0242242 ]\n",
      "0.4890364519331919\n",
      "Epoch 5\n",
      "Error rate is limitating the loop\n",
      "Parameters [0.02078447 0.28618496 0.01728072]\n",
      "0.4991112631254946\n",
      "Epoch 6\n",
      "Parameters [-0.00085526  0.00187931 -0.00174   ]\n",
      "0.42650202065627313\n",
      "Epoch 7\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.02451423 -0.04105211  0.00603074]\n",
      "0.4814410852884909\n",
      "Epoch 8\n",
      "Error rate is limitating the loop\n",
      "Parameters [0.00116916 0.01358458 0.04254637]\n",
      "0.48391215481478894\n",
      "Epoch 9\n",
      "Parameters [-0.20444612  1.00850483  0.38434419]\n",
      "0.4159286559018336\n",
      "Epoch 10\n",
      "Parameters [-0.49786053 -0.67687087  1.1074613 ]\n",
      "0.4903819751798002\n",
      "Epoch 11\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.10564669  0.19525574 -0.05715513]\n",
      "0.49434923596293634\n",
      "Epoch 12\n",
      "Parameters [ 1.65859552 -2.10345509 -0.75465017]\n",
      "0.39136783546940695\n",
      "Epoch 13\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.00215682  0.01067693 -0.02090031]\n",
      "0.49507633217047764\n",
      "Epoch 14\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.00259478 -0.08147998 -0.01590938]\n",
      "0.4959785928053681\n",
      "Epoch 15\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.00080878 -0.03482747 -0.00704011]\n",
      "0.49934141777219015\n",
      "Epoch 16\n",
      "Parameters [-0.2698884   1.10301638  0.04386267]\n",
      "0.4253478971145082\n",
      "Epoch 17\n",
      "Error rate is limitating the loop\n",
      "Parameters [0.00427636 0.00572435 0.00072175]\n",
      "0.458317584019318\n",
      "Epoch 18\n",
      "Error rate is limitating the loop\n",
      "Parameters [0.011716   0.00107609 0.01725499]\n",
      "0.4691582684005975\n",
      "Epoch 19\n",
      "Error rate is limitating the loop\n",
      "Parameters [-0.00122026 -0.07562914  0.16328786]\n",
      "0.4978738172901423\n",
      "Epoch 20\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.03251533 -0.43693824  0.46304908]\n",
      "0.49972174076916026\n",
      "Epoch 21\n",
      "Parameters [-0.10682668 -0.41752096  1.4497825 ]\n",
      "0.4694362473856973\n",
      "Epoch 22\n",
      "Parameters [-0.59062857 -1.09560679 -0.18297378]\n",
      "0.3780298979347003\n",
      "Epoch 23\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.05127122 -0.09004395  0.07458008]\n",
      "0.49945732085026584\n",
      "Epoch 24\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.02422876 -0.0399772   0.01527738]\n",
      "0.4827435657443836\n",
      "Epoch 25\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.01449701 -0.01875639  0.00312359]\n",
      "0.41399717958736665\n",
      "Epoch 26\n",
      "Parameters [-0.42811036 -0.67659165  1.90750105]\n",
      "0.4676758248284882\n",
      "Epoch 27\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.00178722  0.11700843 -0.01027955]\n",
      "0.4957583642609878\n",
      "Epoch 28\n",
      "Parameters [-1.03753334 -1.71424012 -2.02316692]\n",
      "0.385726469117051\n",
      "Epoch 29\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.01389899 -0.00758993  0.02158374]\n",
      "0.46845643141166105\n",
      "Epoch 30\n",
      "Parameters [-0.60700503  1.90227186  1.58123584]\n",
      "0.3858405045195567\n",
      "Epoch 31\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.14227166 -0.46542711 -0.20338974]\n",
      "0.4979863128789228\n",
      "Epoch 32\n",
      "Parameters [ 0.05829624  0.51842052 -0.75270456]\n",
      "0.4497223936814122\n",
      "Epoch 33\n",
      "Parameters [-0.03026283  0.15916762  0.40500709]\n",
      "0.49903713532830124\n",
      "Epoch 34\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.01236562  0.01508692 -0.0125368 ]\n",
      "0.46404472441545674\n",
      "Epoch 35\n",
      "Parameters [-0.43799296 -0.11633295  1.28715867]\n",
      "0.4458047249817458\n",
      "Epoch 36\n",
      "Parameters [1.42984204 1.90873448 0.71376003]\n",
      "0.42739986979491507\n",
      "Epoch 37\n",
      "Parameters [-0.44525415  0.27068071 -1.39201543]\n",
      "0.4321702648339403\n",
      "Epoch 38\n",
      "Parameters [-0.64747416 -1.69071405  0.52076723]\n",
      "0.3921133216843756\n",
      "Epoch 39\n",
      "Error rate is limitating the loop\n",
      "Parameters [ 0.13560535 -0.22381648  0.04513516]\n",
      "0.4954626674549579\n",
      "Epoch 40\n",
      "Error rate is limitating the loop\n",
      "Parameters [0.15087348 0.02765736 0.30416255]\n",
      "0.49815218869247274\n",
      "Fine\n"
     ]
    }
   ],
   "source": [
    "def normalizeWeights(weights):\n",
    "    weights = weights / np.sum(weights)\n",
    "    return weights\n",
    "\n",
    "def learn(dataset, weights):\n",
    "    inputs= dataset[:, :2]\n",
    "    phi = np.ones((inputs.shape[0], inputs.shape[1]+1))\n",
    "    phi[:, 1:3] = inputs\n",
    "    phiT = phi.transpose()\n",
    "    t = dataset[:, 2]\n",
    "    #w = np.linalg.inv(phiT.dot(phi)).dot(phiT).dot(dataset[:,2])\n",
    "    w = np.linalg.inv(phiT@phi)@phiT@(t)\n",
    "    return w\n",
    "\n",
    "\n",
    "def learnPerc(dataset, weights, iters):\n",
    "    w = np.random.rand(3)*5 -2.5#w0 and w1 adn w2\n",
    "\n",
    "    k = 0\n",
    "    while(calculateError(dataset, w, weights) >0.5 or k < iters):\n",
    "        n = k % dataset.shape[0]\n",
    "        row = dataset[n]\n",
    "        x = np.array([1, row[0], row[1]])\n",
    "        c = dataset[n][2]\n",
    "        if (calculateFunction(w, x))*(c) <0:\n",
    "            w = w + x *c * weights[n]\n",
    "        if(k == iters):\n",
    "            print(\"Error rate is limitating the loop\")\n",
    "        k = k+1\n",
    "    return w    \n",
    "\n",
    "\n",
    "def calculateError(dataset, w, weights):\n",
    "    error = 0\n",
    "    for i in range(dataset.shape[0]):\n",
    "        row = dataset[i]\n",
    "        x = np.array([1, row[0], row[1]])\n",
    "        y = calculateFunction(w, x)\n",
    "        if y > 0:\n",
    "            c = 1\n",
    "        else:\n",
    "            c = -1\n",
    "        #se c'è il segno negativo, significa che sto missclassificando, quindi aggiungo il peso\n",
    "        #del sample\n",
    "        if c*dataset[i][2] < 0:\n",
    "            error = error + weights[i]\n",
    "    \n",
    "    return error\n",
    "\n",
    "def updateWeights(weights, w, beta, dataset):\n",
    "    for j in range(weights.shape[0]):\n",
    "        row = dataset[j]\n",
    "        x = np.array([1, row[0], row[1]])\n",
    "        y = calculateFunction(w, x)\n",
    "        if y > 0:\n",
    "            c = 1\n",
    "        else:\n",
    "            c = -1\n",
    "            \n",
    "        #se lo ho classificato giusto, il peso diminuisce (beta tra 0 e 1)    \n",
    "        if c*dataset[j][2] > 0:\n",
    "            weights[j] = weights[j]*beta\n",
    "    return weights        \n",
    "        \n",
    "def calculateFunction(w, x):\n",
    "    return w.transpose()@x\n",
    "    \n",
    "T = 41\n",
    "i = 0\n",
    "learners = []\n",
    "betas = []\n",
    "weights = np.ones(dataset.shape[0])/dataset.shape[0]\n",
    "while(i < T):\n",
    "    print(\"Epoch {}\".format(i))\n",
    "    weights =normalizeWeights( weights)\n",
    "    w = learnPerc(dataset, weights, dataset.shape[0]*3)\n",
    "    print(\"Parameters {}\".format(w))\n",
    "    error = calculateError(dataset, w, weights)\n",
    "    print(error)\n",
    "    if error >0.5:\n",
    "        print(\"Exiting at epoch {}\".format(i))\n",
    "        break\n",
    "    beta = error/(1 - error)\n",
    "    weights = updateWeights(weights, w, beta, dataset)\n",
    "    \n",
    "    learners.append(w)\n",
    "    betas.append(beta)\n",
    "    i += 1 \n",
    "\n",
    "print(\"Fine\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAroAAAILCAYAAAAHaz/JAAAgAElEQVR4nOydd1QbZ7r/c3/33D9uOUm23GX37t3LLtldSIIT21knTpyebKqdHmfTk00hTpw4juPIuL3uca/CvYBtbONecJdEBwMGUUWvEr1XoTLz/f0x8IIMAgkVsPx8zpnjY6R555E0M+93nvcpt4EgCIIgCIIgPJDbRtoAgiAIgiAIgnAFJHQJgiAIgiAIj4SELkEQBEEQBOGRkNAlCIIgCIIgPBISugRBEARBEIRHQkKXIAiCIAiC8EhI6BIEQRAEQRAeCQldgiAIgiAIwiMhoUsQBEEQBEF4JCR0CYIgCIIgCI+EhC5BEARBEAThkZDQJQiCIAiCIDwSEroEQRAEQRCER0JClyAIgiAIgvBISOgSBEEQBEEQHgkJXYIgCIIgCMIjIaFLEARBEARBeCQkdAmCIAiCIAiPhIQuQRAEQRAE4ZGQ0CUIgiAIgiA8EhK6BEEQBEEQhEdCQpcgCIIgCILwSEjoEgRBEARBEB4JCV2CIAiCIAjCIyGhSxAEQRAEQXgkJHQJgiAIgiAIj4SELkEQBEEQBOGRkNAlCIIgCIIgPBISugRBEARBEIRHQkKXIAiCIAiC8EhI6BIEQRAEQRAeCQldgiAIgiAIwiMhoUsQBEEQBEF4JCR0CYIgCIIgCI+EhC5BEARBEAThkZDQJQiCIAiCIDwSEroEQRAEQRCER0JClyAIgiAIgvBISOgSBEEQBEEQHgkJXYIgCIIgCMIjIaFLEARBEARBeCQkdAmCIAiCIAiPhIQuQRAEQRAE4ZGQ0CUIgiAIgiA8EhK6BEEQBEEQhEdCQpcgCIIgCILwSEjoEgRBEARBEB4JCV2CIAiCIAjCIyGhSxAEQRAEQXgkJHQJgiAIgiAIj4SELkEQBEEQBOGRkNAlCIIgCIIgPBISugRBEARBEIRHQkKXIAiCIAiC8EhI6BIEQRAEQRAeCQldgiAIgiAIwiMhoUsQBEEQBEF4JCR0CYIgCIIgCI+EhC5BEARBEAThkZDQJQiCIAiCIDwSErouwmAwIDk5GWVlZdDpdLTRRhtttNFGG20u2crKypCcnAyDwTDS8mfUQULXRSQnJ+O2226jjTbaaKONNtpoc8uWnJw80vJn1EFC10WUlZXxk26kn/RGYruUU4Bfh13Gr8MuQ11UMuL26HQ6XDqUiGUfHMGGb07Zve++2H24Z+M98N3gi4lbJ0KZqRzxz3PLbZnx0M26E7qZ/wXd6SX9Xo+KisLRBx9ChM9diH74EeScSEDS1yeQNO0IIu76CxKmvDLkMc6cOYOZM2diyZL+47tqKyguhe/Mg/j918FYdDjaJcdgCan4ddhlTAqPHPYY2jItsnZGS9/p1yeQ9vNllBf0XtuxsQtw5Mj/4fyFyUOPVV6OqPvuR4TPXcjesdOl3+++JZex7IMjCJp9Dlqt1m2/K206+J9W4tdhl/FzUtrwx1l6n3TNH/nRLTZrtVrMnTsXM2fOxLlz55wyZoEig183RXHZLrG7x7lWVlY20vJn1EFC10XodDrcdttt0Ol0I23KiNBuNsNLpYaXSo3IhtaRNgcAUFXUDHmAEvIAJVob9Hbvn1CZgImhE+Ef7I8JBycgWhvtAiuJQTk7A2C3A6v+BHRZnlcGgwEbZs1Clt/d0Pj6oXrVemhl0dDKopE78UU0nTg55PDp6elgjOHnn3921Sfox6HEMnjLwvHnuedR02r/eWkLP+aWw0ulxkcZRcPaXzCYUbcvi3+f9aEaiCbB4j2lpduhUPrgWuJLQ47XVVQMja8fNL5+0OflDcsmW6ks7L3ui9NqXXosopc6g4nPAfFNbcMbpKlcut7Z7UBJrHMNtEJ9fT0YY2CMobKy0uHxREFE1brr0MqiUbs7wwkWDnAMUcTlI0m3tOYYDBK6LuJWF7oA8GB8NrxUamwvrxlpUwAAZqOArd+oIA9QIj+5elhj5Dbk4umwp+Ef7I/7Q+7HyfyhxRPhRJp1wJL/lia+yFX9Xg4ODsapV16BxtcPOWPuQ/mMI9DKolH01hwInZ1DDl9QUMAnObPZ7IpPYIEoinh+QxS8ZeGYfijVZcf5R1ohvFRqBOZp7d7X3GpA9ZZULnKbwosgCmK/92l1oVAofRAb9/iQYzafOSP9RuPGQ3TD93xqfSrkAUocXZEEUexvO+F8lPUt8FKp8VuVGm2mYf7G14Ola335/wAm98SeqtVqMMawfPlyp9wD2lNr+LVjKHe+00cwC4g6nIdlHxy55TWHNUjouggSusBHGUXwUqnxfc7oWUo5vuo65AFKRB8Zvhepqr0Kr51+Df7B/vAP9sdW9VaaPN3JxUBp8lvxv0BHg8VLMTExWDp3LlLHjoPG1w+5D78ArSwausAzNg1dWVnJhW5rq+tXIpJKGuAtC4e3LBxJJQ1D7zBMHr2mgZdKjaAy+x46jbUdqFyVJE3Uc6LRGmP9flZVdQYKpQ8io8YPOW7V0mXQ+Pqh9P0P7LJnuOhyG7lXtzSr3i3HvNXZUFIFL5Uaj17TDH+QsI+ka/3QP5xn2BCcPXsWjDEEBwc7PJZoFvj1UxeS7QTrLDHoTTi3JQ3yACUJ3UEgoesiSOgCK4oq4aVS44Vk1y5N2kPc8QLu2XGEFkMLPr30KRe7C2IXwCgYnWQlMShttcCy30kT4NVFFi/1CNW9H3/Ml8ZLPg6CNjAagmFo70xzczMXutXVw/P628P0Q6nwloXjhY3RLntYEkURf4xMh5dKjTM1TTbv11XagorF8ZLInReDjoy6Qd9fV6eEQukDpeqvQ36WkqnvdIeXrLbZHkcQRREn1kgPucdXXacHUzfwSUYxvFRqfJ1dOrwBBDPw8/9J13niTucaNwhBQUFgjEGpVDo8Vtu1Sv6QaKxqd4J1fcZu1OPw0kRsCVBA9lMQJm9885bXHNYgoesiSOgCJ6sb4aVS409R6RBGycRSpK6FPECJoGkqGLscW5YymA2YHTmbi92AqwHoMHY4yVJiUBSLpQlw2W+Btl4vpSAIWL16NdjChUh9+BFpeXz84yj/UQl9XuOQw5pMJi50i4qGF89qKzUtetwVeB7esnAcSnTdqkd9n1jJlGbbJtvOrHpo58VK3vBF8egqaR5yn8bGRCiUPlAofWA2W481Fg0G5Iy5DxpfP7RcuGDz53CUsux67tXV5rjOe05IjI/Lcix0TZvcG59bX+hc46yg1+v59Z+fn+/QWKJRQOXya1JM++EcJ1koUVvWit0/ReDb+T/jiaDn4B/sD98Nvre85rAGCV0XQUIX0LR18gm2tLNrpM0BAHS0GPhkp7NB+AyFIApYl7yOi923z76Nus7BPV+EE+hsBFb8QZoEL8gsXjpx4gQYY9j//vvcq1v42hw0nbdNuC5fvhyMMWRmZrrCcs7Gq/nwloXDn11Ch8HksuOkt3bw67Cma+hVh7b4CmjnSDGFlT8nwlhj28Nba2sWF7pdBuvXQGdWFv9dDFr33R9FUcTRn5MhD1Di1LoUtx33VsQpiWiRq6Tre4M/4CZHSd8Y/U4bYvoHozVaJ3lzA6NhqnNsrL5kpBTh8+WBeHDnI3ze8Q/2x+shr9/ymsMaJHRdRI/Q1WgujrQpI4ZBEPD7COlmd7luaI+Qu9g/Px7yACWuXyxx2pgHNQcxJngM/IP98fzx51HcXOy0sQkrRK2WJsIlvwaae5Os0tLSwBjDknnzkO0/RhJV94xBxdLLNg27ceNGMMZw7do1V1kOo1nAg8uvwlsWjiXnnB+715fztU3wUqnxh4i0QVdWREFE84VinjhTvSkF5hbbE4A6Okq50O3oKLH6vsbDh6Hx9UPew4+4PYSgJL2OP+hWFNgexkHYh1MS0fY8L13fZ2c417hBUKlUYIxBLpc7NI7QZUbFkgRoZdFoPO6YZ7iH8pZy/HA8EGP3jOfi9r7g+zAzYibUNWokXL5IQtcKJHRdRI/QvXTpzZE2ZUR57FoOvFRqbCp1fbyjrVzdmw15gBLn5GlOHVdRqsADBx6Af7A/Jh2ehNQa12XREwC62oBVPtJkeOZb/ufWlhbulUkKDETugxOh8fVD/lPvwdw2tHDbuXMnGGNQqVQuMz08vZInoRXXOTd270Z2lNfAS6XGxATrglo0Cag/nMNFbu2eTAhd9nmZDYZ6LnRbWq17wysC50Lj64eyL7+0a3xnIIoijixLhDxAiTOb1G4//q2Cw4lo+hZg0S+kazvbtkRSZxASEgLGGM6cceyYLcoy6VqaGwNTk2MlA9U1asxQzeCOFP9gf4zb+wAWRy1FeWs5dLkaHFkkw4LJz5DQtQIJXRfRI3SPHPk/NDYmjrQ5I8YXWSXwUqkxbbgJCS4gM0oHeYASu36IGrBMkiOoa9SYdHgS/IP9MX7/eFwtverU8YkbiJdLk+GiX/A4vvb4eGz47jswxnD+0CE0HjnKl8rr9w8dExoaGgrGGM6dO+cys6duj4e3LBwf7nH9vWFhvg5eKjXeUhcM+LqgN6F2RzoXuQ1H8yCahQHfOxiC0MWFbmNjgtX3FU2eAo2vH2q3OOY1Gy6FqTXcq1td3DIiNng6Dieiac71Xted7vG8C4LAw5ZSU4fvpBA6jNCxOKkU39nhxRabBBMulVzCe+ffswhPeHDnJMzasQR1LQ2oKSnCyZWLsHbqy1g79WUSuoNAQtdF9BW611PevWWzfNd1P9k/lejcYHxHqNe18Ymu0cmZsABQ3FyM548/D/9gf4wJHoODmoNOPwbRjVEPrPWTJsUTXwAAtN9/j8NTp4IxhqCgIIiCgPwnJkvL5Y8+C3GIXvCnTp0CYwxhYWEuMTm3qpV7cxUa1690/DNTEh0zNP0T3kzNXajecJ2L3OYrpQ7dq5QqPyiUPqitHfgBT2hvh+bue6Dx9UNbZOSwj+MIoiDi0OJrkAcoEe7kVR1CwuFEtHMzpWt699+da9ggVFVV8ZWgurrh51k0XyyRkjjnx8Lcal/t33ZjOw5kH+DzR8/2RNBz+Hbez1AezkK9VovwTau5wF079WWE/PgNYi+cI6FrBRK6LqKv0FUofdDQEDfSJo0IfeMDjU72ng4XQRCxc0Yk5AFKZMdWuOQYdZ11mHpuKr9RrU1eC0G030tG2EDS7u7s7Dtgyo2Hxn8MIh5/3KIebt3eq9D4Sh3T6nbvHnS4K1euSCXK9u51iblzT2bAWxaOSSuVMLvhmvh7ci68VGqsKa6y+Luxqp1nhWsDo9GeVGVlBNuJiv4bFEofVFadGvD1jqQk7l03NYxc5YP8pGr+sFtbNjo6N3oKTklE23i/dE1HuK9DYVJSEhhjWLly5bAf9sytBujmS9VKmu3IAalqr8K66+vwcOjDFgJ3ivwdzJm9FfKvFLh2Jh2Xd2zGun9M4QJ393efIyc2EqIgUAL8IJDQdRE9J134+RegUPog+frbt6RXt6iji9/08tpd0950OJzZpIY8QAnlfgeKmQ9Bh7EDX139it+0foz8EQaze7r73FKYDMCGMQC7HfXTn4HG1w/ZD/wNS5cuBWMMarUaXWUtKHj+C6nc2NjxMFZb9zTFxsY6JSFlIFr0Rty94CK8ZeHYFumekkn3xGTCS6XG4creRgn6wiboFsZxz1Onk8ptxcU9CYXSB1rtgQFfr9+9BxpfPxQ8/YxTjjdcBEHEwYUJkAcocWG7a9qy3qo4nIjWUNRbVqzcfWF/PdVaQkNDhz1G09lC6ZpicRA6hq5wktOQgznRczA2ZGxv/O3+cZh57ies+Okw5AFKbPvmPE6v24wN77/GBe72rz5CuuIizKbeOHoSutYhoesiek66zMzjPG6tvj5qpM1yO2ZRhHdkmt3F6l1N4rliyAOUCGXWYwmdgUkwYWHcQn4T++TiJ2juGj0VKDwG9SGIC29HwQN/hsbXD5ULGQ4cOADGGI4fPw7RLKJ8ziVo/MdD4+sH3Y+zrQ/V3QJ01ar+LYYdZV9sMbxl4fjrvAtobHf9Q0+HWeAPmjGNkueyQ10D7dwYaGXRqFiaAIPWeR7Na4kvQ6H0QUnJtgFf137/PTS+ftB+/73TjjlcchIquVe3XjdMzyPRD4cT0ZJ2dXc+/ANgdl3ZvRvpqbYSHR09rP1NTV38umpRWK+LLYgCorRR+OzSZxbe20cPP4otqVsQo8hA0FdKbPnyAuRfrMDGD9/kAjfos3dxPfwUTAOEX5HQtQ4JXRfRc9JptVokX38bCqUPkpJfvyW9un9PkpZOVxVXjrQpnHJNA5/k9G2u7WgmiiK2pm3lN7TXTr+GyrbR8114BIIZ7bJxfFm8MysL8fHxXLAKgoC6kGwUTV3C39ORNHB3vLy8PDDGsGjRIgiC88JNRFHEU2sj4C0Lx6yj7okNLejQc6Fb0qFHa2Q5j8etWpMMU73z6nsCwPXr70Ch9EFh4ZqB7Xla8rjX797j1OMOB8EsYP+8OMgDlLi8y7U1k28lHE5EO/yeJHSPuKc9NAC0tbXxUKeSkpJhjdF4Il96eFySMGDFki5zF47nHccrp16xELiTT05GWG4Y2g0diAnLx5YvL2Hjx6uw7t23uMDd/PFbiD92CF0d1mtak9C1DgldF9H3pGtoiONe3bo615UsGq1M15TCS6XGPzNHT21ZQ6cJQV9JQrdkiNamzuJk/kncH3I//IP98XTY08htyHXLcW8VdP+cCo2vH4on+gCl8aitreWTV0VFBdriK1D+UyRyJz4Hja8fiqa8AtHUf0LS6XR8v/Z25yUrxuTX8SS0DK17vPoRDdIy8u+Uqag7lc9Fbk2QGuZ25z/gqdM+g0Lpg9w81u81U0PDkA8Z7iY7pkJ64P3KNYmptyIOJaKZjcCK/5WEbrJrYuQHQqPRgDGGxYsXwzBEsupAGOs6oQ2Urq3WaEuh2aBvwFb1Vjx+5HELgfvxxY+hKlNBEAUY9Cac25KKjZ9swNp3pnKBu/H91xF5YA86W4euDkJC1zokdF1E35NOFEVcT3kXCqUPEpOm3HJe3S2l1fBSqfFIguviYYfD4aVSPc2EU+6JlQSAWF0sJhycAP9gfzwU+hDiK+LddmxPxtTQgJzu5hCN7/8W2PsiREHAunXr+HKksbYDWlk0Sj/fxwVXw/7+saSNjY1c6NbW1jrNxs9DkuEtC8er8linjTkUByrq8X9XUxG2IYGL3Lr92RCNjrW/tkZm1gwolD7Iyp7V77W2yEjpe7/7HghOfIBwBLNJQHBgLOQBSlzd59rGHbcCDieilcb3xuc2uq8k5eXLl8EYw44dO4a1f08N6srl1yAapVWg4uZiLIpfxGur+wf74/6Q+zE7cjay6rL4vm0Nndj74x6s+8d7XOCuf/cVXN0lR2uD7U4YErrWIaHrIm486fr2ga+tta1Dk6dwtTs54XcqNfTDqM/pKiJDc0ekHWh2fTaeOPIE/IP9MTZkLM4WnnXr8T2R+j17pUSz+++Dee4d0kRZqMTp06fBGMO+ffsgiiIqV0hVBko//hYaXz/k/m0CTPX1FmMZDAaHlzFvRNfUiT/Nkby5J1K0Q+/gJDZkaxH+cywXuY2nC5xeO7ovOTnzoFD6ID09oN9rtZu3SJ70yVNcdvzhkBGhhTxAiaBpKjTXOjeU41bD4UQ05TLp2t083vnGDcLu3bvBGMOFC0PX2b4RY1U7b5ndllCBpKokfKP4xsJ7+1DoQ1idtNoiZE0URaRcjMCGDz7pUypsMsI3r0Fjlf3VgEjoWoeErosY6KRLTf0QCqUPriW+BPEWKjWl1Rv4U35mq/UYI3eTe60K8gAltk+PgNnNAlzXpsPkk5P5jXBXxq5bztPvLERRROHzL0hJaPMXALuelSbLHU8iMzOTL0l2dXWh4Wie1N52YzRyH/gbNL5+qAic22/MnooN2dnO8fKtupgDb1k4xi+5Ar2LvKk3YqrvRNryeC5yWyO1Lj/H8gt+hkLpg5TU9/u9Vvbll9L3Pbf/9z2SmIxm7P0pBvIAJVQurMJyK+BwItrOp6Vr9/yPzjVsEEwmE5YsWQLGGDIz7Y/VrgvJhlYWjcJlkXjn9DsWAvfvx/6O4KxgtBksvdtlmenYO/M7i1q4ofPmo7asZNifg4SudUjouoiBTrrm5hTu1a2uOT+C1rkXURRxV1Q6vFRqHKsaudqZN9JS18kT0mpK3d8hqbmrGR9e+JDfFJfEL4FJcF+WsafQnpjYm4SWkQkUR/Hlz46009w7m5ubK1UckEVDOy8G9Xt7Qxg61ZbtYNevXy+1EHZCLKneaMa4JVfgLQvHqovuaZxi0LaiYqkUrlA8JxoHLrknHry4eEt3iNarFn8XRRF5Ex+WQksOH3aLLfaQpiiHPECJrV+r0Nowesog3mw4lIjW0QAsulO6dnPt96wOl/Lycn6PaG62L3a+sbiaP0h+u+mf/F7+zrl3cKH4Qr/7eWVBLo4unWchcDd+OA1ZUdcd/hwkdK1DQtdFWDvp1GmfQqH0QcK15yGK7vHsjAZevp4HL5UaSwtd06BhOIiiiL2zJU9OmrJ8RGzoMndhZsRMfoOcrpiODuPo8XrfDOhm/Sgtib/ep6pJ8BRpwgx6GDt37JDaAZ8/D3OrgU9MnTm1vB1t8RtvQjT3Xo/bt28HYwyRTujedSJFC29ZOP40Jxy6JtcvjXfmNPCi9bnzYvDSsWTs0Tov1ngwysr3QqH0QXyCZZ1cg1ZnURFjtGE0mLHnx2jIA5SIPERJosPFoUS0rJPSNbv4l0CX+5p4xMXFgTGGdevW2bxPRVsFViWtQvjS3dDKohG74Aju33cfpiunI7kqud/KSV15KU6vWWYhcNe9+xn2/XTYaQ9WJHStQ0LXRVg76Vpa0rlXt6rqzAhZ535m5ZTDS6XG++lFI22KBRe2Z0AeoMSlESwvZBbMWJm4kovdd8PfRX1n/dA7EjA1NvYmofX1FGqTuVdXeVgOxhg2b94MALzlbfOFYgtvcOPhI3z3nhq85887vvLyqjwW3rJwfBGS7PBYQ9GeWMWzvytWXMPjZ6/DS6XG5Tr3VHmoqDgGhdIH0TETLf7ecuGCFEM95j6IRteW8xsuKZdKJa/uNyq0NXaNtDk3HQ4nop2ZLl2ze19yvnGDcOTIETDGcPTo0SHfm1GbgVmRs3B/yP14N+h1/tAccnwrSppL+r2/uaYKF7asxdp3JvcK3H98hE2f7sCZTakwdDpvBY+ErnVI6LqIwU66tPQvuNdDuEWWqndpa+GlUuOB+NHlzUm9UgZ5gBLBc9yXCW+NkKwQLnZfPPEiylqsFx0nJOr37evudjYO5rYbJtfQdwB2O0rXPsOXJhsbG9F0rkiK092cCgDQ/TALGl8/5D34EEyNjQCAkydP2jz5DUa6tomXFIvJd10ZO1EU0XyllE+81RuuQ1fdyoVHdpt7kqxqai5CofRBRKS/xd+rV62GxtcPJVPfcYsdw8GgN2H3D5JXNzosb6TNuelwKBFNFIH190pCN2rgGsyuQBRFrFmzBowxJCQM3DzILJihKFPgowsf9cbf7vOHYskB6YFyY1I/D25bYwOu7t6K9e++ygXuhg/ex6ZPtmDLl1cREZoLwcl5ISR0rUNC10UMdtK1tmZxr25l5YkRsM79xDT2Trqtw8nGdRFVRc08Tnc0xOZdLLmIcfvHwT/YH48dfgzptekjbdKoRRRFFL74kpTgNG9e/zdUpgPsdpjZnVi+dBEYY0hOTkZnToMkCOdEw9xuhLG6GjnjpI5plYwBAC5dugTGGIKDgx2ycdbRNHjLwvHU2giXJYKJZoEn2Wll0ajdkQ5Bb0JiUxu/5pqN7nmgrm+I4fe2vqFZpe9/AI2vH6qWLnOLHcMl+XyJ1HZ1egQ6Wqhdtz04lIhWm9dbVkznvio4fUsJVlRYhtV1mjpxOOcwXjrxkkWC2aunXoVSeY5fb/rc3ryTzrZWRB3ci40fvNHbzezzD7Dt683Y8uUVyL9SQn21zCX3AhK61iGh6yKGOunSM6ZBofRBXPyTEITRuZTnTGoNRj7pXm8eHTU0AcBsFLDtmwjIA5TIT64eaXMAAMlVyXj40MPwD/bH3w78DaqyW6/JiC10JCf3xn2mW3kgOPoxwG7H4aWfgzGGI0eOQOgyQxsotersyJBiV+t37ZLG8rsbnZlZiImJAWMMQUFBw7avsd2Av8y7AG9ZOPbFuqZZitBlQu2eTD7pNhzOgWiSPEUnqhvhpVLjz1Hue1hqblZzoWs0SgmeotnMHySaz4zucK2uThN2zYyCPECJuOMFI23OTYVDiWgJ2ySRu/KPgBO7EQ5Feno6GGNYtmwZzN0x+nWdddiUsgmTDk+yELifX/4cMboYCGYB1ZtSpMYr29IgiiIM+k4kHD+MzR+/zQWu/NN3cHlHCLZ/d5VX9ylKdV2sPAld65DQdRFDnXRtbblQKO+CQumDioowN1s3MtwTkwkvlRoHK0ZX/OmJ1del5cojo2e5srCpEH8/9nf4B/vjvpD7EJZ7a5wj9qCbPVtKQnv1Nesekto8YNGdSGKPgjGGFStWwGw2o2ZbmlRX9mQ+AEA0GFD4wot8eT0lORmMMaxZM/xl1G2RhfCWhePuBRfRonf+w6y5xcAnXK0sGs0Xiy1q5G7ubtTyZKJ7Kj0AQHt7ARe6er3kIdPn5fEHkq7i0dMd0RrXzhZJwuS7SHS2kVfXVhxKRDv4tiR0j33qfMMGITw8nNfZzm/Mx/zY+XxFzT/YH2P3j8XcmLkWXSw7Mmr5NdeRV4eU86cR9Hlvs4dNH76J2LADSL1SgKBpKsgDlNg7OwbVJa6t7ENC1zokdF2ELSddRua3UCh9EBv3GATB82+ob6QWwEulxvx89xXMt4W44wWQByhxdMXoaEvaQ01HDd488ya/6W5M2Ui1drsxNzUhZ8x9Unez0NDB33xqGhrYH/gSZXl5OVquSvGslat7f/O2mFguyHKCgnj93eF852ZBxKSVSnjLwjH3ZIbd+w+FsaYDlT8n8hCMtvj+1Uxm5zVXXJsAACAASURBVLo/AVTfVcWFblubJA6ajh/nzTlEN3rrhou+3Ygd30VKXRNPu69r4s2MQ4lopi5g2W8loZvav1OhK9m2bRsYY5i1a5aF9/bhQw9jw/UNqG63XOUTBRFV65Klsn2rI7BjWm+zhw3vvQpV8E60NzYitntOkQcocWjxNbTUuz5G/kzKGRK6VvBYoVtQUIAvv/wSY8aMwf/7f/8PTzzxhE37GQwG/Pjjj/Dy8sJ//Md/4Nlnn0Vurv3lZmwRupL3Q/LqanVDTNYewNw8LbxUarylHl1LgkXqWt4Zydg1euKHAaDN0IYvLn/Bb8BzoufAaPb8UJehaAgJ6e6ENhbm1iFKETWWAot/hY1sBhhjUKlU6Cpt4V4ZU5/YbO10qWNazkMTsSwwEIwxdHbaP0kpNNU8CS23yrmlkrpKmqFbJDWC0M2PRWfWwCsk76UVwUulhizPfQ+WJlMrF7pNzVJt0ErGoPH1Q9mn7vXWOUL8yULIA5TYOSMSXR10vQ2FQ4lofepeo9k9Is1gNuC45jgWsoVgjOHZrc/CP9gfLxx/AQc1B62WeGxPruL3jT0ffNZdRWEKLm/fhJa6GhgNZlzYlsFF7plNanQ5sbLCQOhNeqxMXAnfDb4kdK3gsUL39OnT+MMf/oC3334bf/3rX20WugEBAbjjjjuwZ88eXLp0CY899hh+//vf211I2tZlhKysmVAofRAT+wjMZs8uabO/og5eKjX8Y0eulNdAdLQY+I1Jl9s40ub0w2g2Ym7MXC52P7v8GVoN7qszOdoQRRGFL79stavZgJybiXD2Khhj2LVzO0SzAN3COGhl0WhPrOJvM+p0yLl/LDS+fjg9ZQoYY6irs79awoe7E+AtC8fUJbuB7Y8DB98C0o9K3isH6Miog3aeFF9csTgeXWXWl0MfT8yBl0qNzaXuiz0XRYEL3fr6KABA8etvQOPrh5p1691mh6N0thqw/Vspdj8pfPSHW4w0DiWiXWWSyJU/5Gyz+tHc1Yyd6TvxVNhTeGrbU3yV58PTH+JK6RWYhYFFuiiKKEpORP5PF6CVRSNh+i6snfoyzm1YiYYK6UGyvbkLR1ck8blEdTDH5R03s+qz8MqpV+Af7E9CdxA8VugKfZbIXn31VZuErlarxb/+679i586d/G8NDQ34z//8T6xatcqu49sqdDs6iqFU/QUKpQ/KtSF2HeNmI6m5nS9v1RlGV1m1A/PjIQ9QIvlCyUibMiCiKGJz6mYudt8480a/ZbVbhY6UFKsdzazSUomcxQ+CMYZF3V7auuAsaGXRqA+1nJzrtm6FxtcPWX53Y/2MGSgrs6/MW3FRPvfmhi94TprEezo+bRoHNA2vbFxrjA7aOZI3qXJVEoy11huLiKIIn+5uhKeq3fvwFhF5H+/+KHR1QXOvPzS+fmi9etWtdjhKzLF8yAOU2DUzyqn1Tj0RhxLRtj8mXRsXA51vWDdlLWVYlrAMEw5O4PfQtze+LcXhbxg8Dl+rycThhbNx6rN50MqiUf5TFC4sW42akt6QoHpdG4IDYyWR+5USqZddU1mhB5Ngwo70HRgbMpbncSy5tISErhU8Vuj2xVahu2fPHvzLv/wLmpqaLP7++uuv2+wR7sGewPDs7Nm8yLrZPPIlrlxFi8nMhW5s4+jySF7dlw15gBLn5GkjbcqghOWG4b6Q++Af7I9njj6DgsbRFQbiDip+kklJaFNesWsy0YfPxWI2H4wxZKcmojVWJ3lGl8RbJHEJXV0oePbv0Pj6IfLRx6DJzrbdOFMXliwJhLcsHA/K9sO48Be9y7I9gnfzeLs8u6Ig8tq/Wlk0qrekwtw6eEx/k7E3ZjLZzVVOYmIf4Um2nWo1fygxVt9cD2btzV28Isv1iyUjbc6oZtiJaG21vddGvnMfhERRRGpNKmaoZmBM8BgucCccnICfE3/Grn27wBjD6dOnB9y/uqgAx1cslOJv33kVebPOS9fgjmsW7yvPbsDOGZG8skJh6jCS8eygrKUM751/j3+el068hLTaNEpGGwQSun2YPXs2fv/73/f7+9y5c+Hl5WXXMe056To7y6BU/RUKpQ/KyvbYdZybjZ4b4m43tSS1lcwoneS9+SHKQvSMRiLLI7ln4uHQh5FUNbqS6FyJubkZOffdLyWhHTho387t9diz6EswxnB260IYq9u5eDRUWCbQtKpUXKCpN222+RAdKUfhLwuDtywcG+d9bCly+24Zx2waTzQKqA/VcDvr9mVBMAwdA5nZ2sGFbmWXexNd4xOe4/eyhv0HoPH1Q/5jj7vVBmcRdTgP8gAlds+KHnXx+6MFhxLR0o9K18OS/wYMzml9bhJMuFRyCe+Fv2eRYPZ02NPYnbEbzV3NEAQBK1asAGMMKSmWdXvrdeU4u/5ni3a9ET9tka7BwBiY+iSWZUXreGWFPT9Go7rYdZUVRFFEWG6YhVd6acJSHk9MQtc6JHT78Pnnn+Pee+/t9/c1a9bg3/7t3wbdt6WlBTqdjm/Jycl2nXSanEAolD6Iip4As9k5F/xo5N20Qnip1JidWz7SplhQr2vjsVUNlaOnzq81Mmoz8PiRx+Ef7I9x+8fhQvGFkTbJLfQIp5z77oe5xf5JJXLvYjDGsJ79AKG5AhXLrkEri0ZrVP+ErZjucmOZDz4Ec5tt58ShzZI398+y06hZ+IeBRe6iO6VySkMgdBhRsz2Ni9zGE/kQzbY9hF2sbYaXSo3/jUiD4OZKHUnJb0Ch9EFR8SZeAq7862/caoOzaG3QY+vXkpBRX6VOhQPhUCLaya+kayLkFYftaDe240D2ATx//HkLgfvmmTdxtvCsRRJvTU0Nj8+trZWcLi21Nbi0bSPWvTOFC9w93wcgL1qKh++5BgFplSXuRG9lhdBF19BS57rKCrUdtZh2dRr/TE+GPYlobbTFe0joWoeEbh8cEbqMMdx22239NltPus5OHZQqXyiUPigt3WHTPjcjiwsq4KVSY0pK/kibYoEoiHz5KTu2f6mm0Uh5S7lF1559mfs8uvyYKIoomjxFSkKTzbF/AFMXdFd38Amubs1DaNh2Weomtqd/guSRjRuRefc90Pj6oXr1apvse37BXnjLwjE9cK51by67HdjxxOCmNul5GSOtLBotCvti/npabj8Yb0fYhZNITf0ICqUP8vOX89rEddu2u90OZ6E6mMNroZps8Kbfagw7EU0UgTV/la6H2I3DPn5VexXWJa/Dw6EPWwjcaVenIaEyYcDr5vr162CM4eeff0ZbYwOU+7Zjw3u97Xp3fP0JMlVXIJjNaFGUSdfhvBiYmrtgMphxcXufygobU11aWeFK6RU8evhR/rlmRsxEo75/3D0JXeuQ0O2DI6ELjnp0ASAnd0G3V/cBmEx2LgHdJBypbICXSo2/RKePOlF2dpMa8gAllCHDyBweIRr0DRZLdCuurbCaOXyz05GaysMJOlJS7du5qQzYNA4CuwMr2U9gjOEaexzt81+TynTNi4aYelSqjtBdJeH47vU41l0xQHOvP7oKB6+pmlTSwJPQkhZMsC5yh/DoGirauKdZGxiD9r4d+0xd0nJvHzsHqubACnTwUqnxeqr7Y7h7uj5mp8/iv1d7XJzb7XAWLXWdfHk6XTW6aoCPBoadiFad1XtNVNlfa1pTr4EsWsYTsvyD/TF+/3iwOIbCpsGv1VOnToExhs2rV2HTh29ygbv1i/eRcuEMTEbJ+yt0GHl1lqazhehoMeDoz8m9lRX2a1xWWaHV0IrA6ED+2SaGTsTZwrNW500SutYhoduHnmS0G0uJvfHGGy5NRutBr6+EKsIPCqUPSkqG33p0NJPWJ3awQj+6mmQkhRdLy1AsYaRNsYtOUyemK6fzG+L3qu+hN3leUmPFnEApCW3yZPsekkxdUrWD7soHR9k/wBhDKPsQ5oV/6u1ZP39Sb3WERXfiApuCJfPmQT1hAq8DO9hxpx9KhbcsHC/MkUNcOIg3d5AYXX1+I59YdQvioM/r47npFusWVRysVHP4PLMEXio1vtUMIwveQXqSa9UR73KhO5wwk9GEIlhKVg2eEwuzcfQ3vXAnw05Ei9ssnbur/yx5d21AEAVEaaPwz0v/tPDePnb4McjVctR1Dl0K0KjXY/WK5WCMYfm0z7F26svY8slUXDsZBoPeMvyg+WJx97UYi/qCJoQExnGRm3Kp1GXOmsTKRN4Z0z/YH/+89E9UtlUOug8JXeuQ0O1DT3mx3bt38781Njbiv/7rv1xWXuxGcvMWQ6H0QWTUOJhMo6sygTPoMAv4bbfQVdWPrsmvXNPAb2L6tpurSLxZMGNpwlJ+Y/zg/Ado0jcNveNNgrmlhde3bQjZb9/OPQkv3VsKe1jqb88CYWJ3omrOQamF7tyvLd4XxZ4FYwzHPv8HF2wtly4PeIiaFj3uCjwPb1k4Dq34vFeADuTNtVJ1of16NbSB3TVylyVYJsjdINaHGveF5Dx4qdRYWTT45OgKeu5hiWefhcbXD4XPv+B2G5xNU3UHgr6S7g1Z0SQkenAoEW3/a9K5e+LLId+qN+lxLO8YppyaYiFwJ5+cjLDcMJse7M0mI1IvnUNQwEc8fGnN5x8iOnQfOtv6z7XmVgN082OlkmIHNdj5fRTkAUpsmx6BguuuqazQZe7CqqRVFh7qkKwQCOLQD1ckdK3jsUK3o6MDx44dw7FjxzBhwgTcc889/P89wedPP/00nn76aYv9AgICcOedd2Lv3r24fPkynnjiCZc2jLiRrq4aqCLu5skcnsjEhGx4qdTYWubaMiz2YtCb+GRWkm5/k4CRRhRF7M7YbTEJaFs9Y6m14eDB3iS0JjsF/MG3LARiM/sfPtEVs3vQNPdHqWzXnF0W4jGZTQJjDOsWzkTZ21KDivwnn4LQ0T9ZdONVqXauP7uEjpoSSXQO5HndPL5fHV1RFNGiKuOe5ap1yTA13jBx3yDWh/IU+8dmwkulRmjFwF3TXElh0TqptXnYA9D4+kH342y32+AKLu/OgjxAiZC5cS5vBHCzMOxENGMnsPQ30jmbdsTq2+o76xGkDuKJtz3bJxc/QUR5hE0CUBDMyIpUYOc3/8TaqS9j5T/f49d/Q3WV1f2azhRKInd+LHb2qaxQVWyfFrAVTb0Gr51+rbfO79m37SofSULXOh4rdEtKSgZMDrvtttsQEREBAHjiiSf6eXq7urowa9Ys/OY3v8G///u/49lnn0VOTo7dx3fkpMvPXw6F0gcRkffBaHTNRTWS9MR0facZfVnMR5YlQh6gRPypm7fH/dnCsxi7X4pbe+LIE8iqzxppkxxCFEUUTXlFSkL76Sf7B9j+eD9BKGfTwRjDVfYiOuc/2y0yIyAs/B1/j4aNA2MMS9g86De+Ao3/GKnD14YNFsMbzQIeXH4V3rJwLDnXnfxl6pJE58G3pcSzg29L/7/BkyuaRTSezOcit2ZbGoSBWs7eINYHi/3VmwXuZYtqcP+qUGnpDinX4JDv8Dzwo5SGinbIux+ENXHu95SPRoadiFag6D1v2/o7PIqai8DiGMbvH8+F3/0h92N21Gyb72eiKCL/Whz2zvyKx+Cue2cKdqySyopt3249QdLUpId2rrS6cvm7CB7S5orKCmbBjF0Zu/g9+76Q+7ApZZPdrd5J6FrHY4XuSOPISWcw1EEVcS8USh8UFq1zgXUjy8qiSnip1HguOXekTelH5KFcyAOUOLk2Zeg3j2ISKhMwMXQiL5B+Yymam4nOtLTeJLTr1+0fYACReJFNliY79hWEhV7QyiKglUWjc/7z/D2lzI97frq2PY2aNWskr7L/GBhKe2Nfw9MreRJacV2fMmRDJI4JBjPq9mVxkVt/UAPRWvznAGLdWjWHoo4uLnQLO1wcqz3AZ9RemyU9qB/1kX6zVDsTB0cxF3dI2fYHFsRDGOX1tt3BsBPRLnVXJdk2if9JFEUkVibia8XXFt7biaETsSZpzZAxqn3HKUlPxYE531vUwj2zdjnqtWXYu3cvGGM4f/681THqw3KhlUWjYHYUtgUocWp9KroGegB1kPKWcnxw/gP+WV888SLUNTZ2e7wBErrWIaHrIhw96QoKVnV7dcfAYGhwsnUjy6nqRnip1PhjpPtrfA5F7rUq3uHmZl+ezG3IxdNHn+bekBP5J0bapGFRMXeuFOv58svDS/4YYNk/n43hIraNeaFmznapTubcn/h76ph37xLnvvdgbmtH/mOPS4lpX37JbZm6PR7esnB8uCex95hDJI6ZdcWolqu5yG06VzR4oxI7PLpRDa1c6OpdeQ5b+YxV8l9DofSB8qwPNPf6Q9B7TmJknbaVx/HnJVpf9r5VGHYiWtBE6Xy5sgBGwYhzRefw9tm3LQTu34/9HcFZwWgz2B77W5GnQdiiORYC99iy+agqyAMAmM1mLF26FIwxZGQMXOmhtbgZ5d3X5YVvI6AM0cBscu51JIoijuUds2j+sCh+EW/+MBxI6FqHhK6LcPSkMxobERE5BgqlDwoK7EuEG+3ktHfyibik0/ZWqO6gpa6TT2Q1paMrWW44VLVXWcR9BamDRl1ZN6uYumBO2I8c/7ulJfBvnxywlJYt49yYyGVgv8QSNg+MMaSzCWie+5UUHzvnEH9PB/tvLnS1kSEAgObwcO5dblWqkFvVyr25Ck211eP13UwL70bl3BOSyJ0TjdaBkptu9JRunWRzjG5oZT28VGr4x/avDew0BvmMdZt+BYXSB4orPih6/TXX2TBChAel8yYBo72LoisZdiJaS2XvyopiDp45+oyFwP3HuX/gYvFFmATba9PWlhbj5KrFFgI3dP4slGelW7xPp9Pxa7ppgFj/hsp2XJ8jhSzkz47C9fBip98v6zrr8I3iG/55nzjyBCLLIx0el4SudUjoughnnHQ9SR2qiHthMNx8yVHWMAgC/jciDV4qNS7Wjq4YZFEUsXd2DOQBSqQpRlf3tuHSYmjBp5c+5TfW+bHzYRRGeVWJbm9h43u/lcIF7vaFOfAX0gS57LeAfKLVGrJWx7shQSyEfQLGGE6yt9C14GHuXTUtvAtgt0Ngt2MRWwDGGHI1kmgURRGlH3wIja8fCp55FoHH1PCWhWPSSiXMPaJnkMSxrgV/Q4XsXHeN3Ch0pA/QCnswb/Bg3tzuqguriqXQoOeT8yzHvVE8H3gDCJ8F7H9j0Jq8AzLIZ2xc/0tJ6Cp9oPvuvaHHusmoKW3hD8Ouyr6/GRhuIlpjghxgt0O/6A6M23cv/IP9MSZ4DL5Vfovr1dftEpaNVRUI37Qaa9+ZzAVuyI/foPB64oDjJCQkgDGGtWvX9ntdm9OAwzOj+H2gKMz5oXWKUgUeO/wYvxfPUM1Ag945K7YkdK1DQtdFOOOkMxqbERl1P+8y5Ek8kZgDL5UaG0pG3/JfT9ebSztd6BFzMwazAbOjZvMbbMCVALQbXdTqWN8iCahVPsAyL+nf8FnS322h21sosjtR9NBdUub+c/83gKi6g4cC3FjJwOq4fRLEYpe8IJUYYrMgLPwldDKpS1r7vDf4MdawH8EYQ2qfOFN9bh4099yL5HvHwm/OWXjLwrEtsk/yopUwg875z0InuyLV5ZRdQNeOGVY/+5DCtuezD1DN4TtNGbxUanyWWdw7bl/x3LOvI9/nIKEULat+wYVu7dwnh/5dbkLObpaayxxeOrCguhWwNxEtozYDsyJnIXyNlPAZvfI3+NuBv2FpwlKUNJfYdezWhjpc2bEF6/7R265393efQxMbCVGwHmYQFhYGxhjCwsIs/p4dW4Gt01RI+iFSErrLr0F0YthPm6EN82Lm8fvvQ6EP4XTBaaeeOyR0rUNC10U466QrKt7c7dW9G11dnuM9CMiSCtoHZJWMtCn9UF8t48XhPQlBFLDu+jqL8jW2FFi3i7IEYPGvBhZSi38lvT4U3d7Czum/6k1Cm/Zrm7yZ9lC1+QW+jFnN/oS6wHVSUljgEj52EPsajDHExMRY7rt8OX5+8TN4y8Lx17nn0djep/nJAIljbfPe4QlvlbLjMC64d+A2wLaWEdv2qNVqDm+kFsBLpcbCgu57j83i2Y7vc5DkuOZ5v+JCt3Htg3b9JjcLlYXN3KtbnDaAV/4WwJZENLNghqJUgY8ufCR5bvfdi4bF0nkYd/z9AVvZDkZHSzMi9u/Ghvdf4wJ3+1cfIV1xEWbT4KEOoihi7dq1YIwhPj5e+psgIuFUoRSK8rWKe3M7Up031yZVJeG5Y89ZlEbTtTlfjJLQtQ4JXRfhrJPOZGpFZNQ4KJQ+yM1b7CTrRp4eb8ATifaXbnM1VUW9k1hrg+ck0vQQqgnFmOAx8A/2x/PHn0dRc5FzBta3WBe5fcXuUJ7dbm9hxYt/kJLQJtw1dKex7vhUexAPvMU9trHsKbTO+1Bq1iA7w48XzD4FYwyXLl2y2NfU0oJJ34bAWxaOaT/cUKaoj7dTXHg7mudO5xNo9Zx9MC/8o2Tv1kn9xaQdSWfWeDBeqlO9S9stwGwVz/Z8n4PYWfelFxe6zYdfsucnuak4tT4V8gAlwpYn3ZJe3cES0TqMHTiUcwgvnXjJIv72h0PP9J4rtbaHBnR1dCDu6EFs/vgtLnDln72L5HMnYTTY9oDb1NTUG3Ov1cJkMOPSrkx+r89eIDWHqFp/3Smx1wazAWuT1/J77bj94xCcFWxT7d/hQELXOiR0XYQzT7qSkiApi1nlB73eM+o3XqxthpdKjd9HqGEYZKlpJDAbBWz7RqqdmJ9UPdLmuARFqQIPHHgA/sH+eOTQI0ipdkI5tfBZtgmo8z8OPs72x2Geewdy7vkrNL5+qP/H74Ye80bxN0RpLwBA+lGcZG+DMYYQ9gmMC8ZwQWpcMAZgve2CT548aWFiTH4dT0I78+AzaIuOsRhXErm/REPgIj5mbeBGCAu9LO2+MUzAjjJiAyGIYv/4d1vEs73f5yDJcRWv/S8Xug3XVw7+W9/E6PIauUgqzXR/Y46RxFoiWm1HLTalbMKkw5MsBO4Xl79ArC4WYvQ66TxZd7dNbX+Nhi4knz0B+WfvcoG7+eO3EHc0FF0DNG4ZjIyMDDDGsHTpUrQ1deL4qmT++8UFpfHrtDPL8VWu3IZcvH7mdf753zzzJvIa84be0QFI6FqHhK6LcOZJZzK1ISr6b1AofZCTu8AJ1o08JZ29tT5z2p1fhNtRTqy5DnmAElFHXHtzcjt9BIt6x8N4NPh+qdVkyP24sv85+5OS+rLKxzYRtequwcc5+BYa3/8dT0IzzbEWU2pF/A1R2osLS1MX0ldP5k0hDAt/iQrZGWhl0Wid9yHA7sD5n6V2oQcOHLAw8fOQZHjLwvHC9/t4m1vBYODjChseRm3gZj55NgQuhLjwF0OHCTjo0a3qMvLrKqO1WwjYKp7t+T6txvnejpJHfKC41B2jW2W9Vqkn0HOfOL4q+Zby6t6YiJbXmId5MfMwbv84Lu7G7h+LuTFzkdvQx3O772XpPDn99aDjm00mpF+9iO1ffcQF7sb3X0fkgT3oaBleAvP58+fBGMOO7buwf14cF7nJ54tREySV+qvekurQ72gWzNidsZs3fxgTPAbrr6+HwWwYemcHIaFrHRK6LsLZJ11PtyGlyhednTf/iSyIIv4YKXmeTlU3jrQ5/Yg7UcCXJT2GAQRLybJf4/ldfjx+7sC63w8sCm1hmZdtAmqZ16DDiGlhQyShWRF/+98E1KFSVYbB3tdHWLZV5PLlzAJ2H+oDl0Ari0Zd4DpgzV8QcfG0NDnu2MHt0zV14k9zJG/ukbPXoPGTyp/V7dwJADA3d6F6bQIXuc1zpw0detETJmBnq98bSW5u50K30dgds+iIR9fW+F4eqnEncu7xheq0JHQrK0/afv7chJRnN3DBVJ7jWfXOB2NDSRW8lKl4SHkYX1750sJ7+8ihR7AxZSNqOm4Iaehq6w1tyjw+4LiiIEATE4Hd337OBe76d1/BlZ1b0NrgmKd1+/btUsWFOXsgD1Bi2zcRyE+uRmdOA79W9XnDn4u0rVoei9wTFuaUlTIbIaFrHRK6LsLZJ53Z3IGo6AlQKH2g0cxxypgjzXPJufBSqbGyaPSFYxSpayEPUCJomgrGLjt6uI9WBqt7uvhOTN3xF36DXrPp/yAM5G0cCid5dDvVKTwJrX2wJLQbtzV/sf29fYTitm1bwRjDxQ3T0b72++6qCJchbhiH5GvxYIxh/fr1vR/zYg68ZeEYv+QK9EYzKhctkrzP48ajM6sUlSuu8Rq5bau/t11UDvE7DSTUb6SnGYtPVHqvZ8qRGF07k+P0ayZD4+uHiCOS0NVqDwxop6cgiiKOrUz2iG6KtmIwGzA5Yif8Ql+wELgvHH8BoZpQ600P8i51ny93AB2WDwWiKKLw+jUE//hNby3cdybj/OY1aKyqcNxmgwGLFi0CYwzrvjuK3bOiUVnYDFEQUb0xRWq/vT1tWN5cURRxMv8kHjz4IP8uFsYtdF1VGyuQ0LUOCV0X4YqTrqx8b7dX9y/o6LCz5eIopKcM0icZxUO/2c10tBi4p0aXO/yn/BHDzoYDHYvuwLStd/Eb9Sz5n9C1aHDvYT+cFKNbOX+BFA7w0N2SJ9SWUluLf2VfVYE+S/9Xr14FYwxyuVzqcd/t3ela8DAqzi4HYwzLli0DAOiNZoxbcgXesnCsuiglUpqbmpD30ETkTXoF2p8UklCeH4tOTf3wYm4HqPk7UBmxgdhSWg0vlRqPXeuT5NkjngcJN+j3ffaIaTtDKRoPH4HG1w9RB/4KhdIHJSXbbDt3bmJKMur4vaIiv38TAk+hSd+EHek78GTYkxYC94PzH+Bq6VWYhSEcAhe6uw7usCw5V5aZjtB5P1g0ezi1eglqS50zL4iiiPMH4/jKTfDCKDTXSmK8I72293ovsT8kor6zHtOV0/l38fiRx6EqUznFbnshoWsdErouwhUnndmsR3TMRCiUPsjOnu20Ud2uRwAAIABJREFUcUeKoLIaeKnUmJiQPdKmDMiB+fHdMVwlI22KfQwYUzn0ZmK3g235I79pf7ztz2he8otBM/wtcELVBXNbO3LGjZeS0Hbt7K17G/Rwn5CEG2rI2uPJHUBYFhcX80mwubkZVWuSu0MOvoJp1V+wtLuDmsFgwIkULbxl4fjTnHDomnpjy2u3nUH5j0pJ5C6IhqG8VXphuDG3N9T8HaiM2EDMydPCS6XGu2mFli9Y1NEdYusbsmKnUO9p1xx3eLzU1bFwzaD29vvMQyUQOgMnH0cURYQtT4I8QIkzG1Oda+sooKylDEsTllq0q703eAz+EvYpDhbZUC6wh80PSOeKYgkAoKogD8eWzbcQuGGLA1GR57xKPCajGZd3Z2HVD/vAGMOKxauhb5ea5YhmEVVrpWu9bq/9NdNVZSo8fuRx/p18q/wW9Z0jl5RYWlxGQtcKJHRdhKuersq1Id0ZzX9GR8fo84TaQ9+Ehg4nFud2Fop92ZAHKHFuS9pIm2I79tZMvWET2e3YtuF/+c371Z1/ReWOR20/voN1dBsPHZTCAO65G6YNj1qKEGvi78Ab9n3eG4SlyWTCsmXLeGOIxlMF0lJm4A6A3Y4L7BWpZWjCQby6aB+8ZeH4YnkQkH4UolGP1igt9wqVfXMMRa9/ANHY3XnOwZhbe/kgvQheKjVm5w7Q1c/UBSRssx7DvOy30ut9BZ+dQr1oyivQ+Poh8fQzUknEXGab4bYmEDqKi45TlFrLvbpVxaOr2+NwEEURKdUp+E75HS+P5R/sjwkHJ+DryMX43ZXL9nVEayrj50tz8kmcXrPMQuAeDPwepelqpyb0dbYZcGK1lCy4XLYJjDGcOHGSv96eXM2vW4PO9hbG7cZ2LIhdwL+TBw8+iJP5J0csGdFkNCNNUY51X50koWsFErouwlVCVxC6EBP7CBRKH2RlzXTq2O6mQm/giTNprfaVinEHWdE6yAOU2DUz6ubpaT/ceMwbtlNrfoex3e05nwoei5wGO7ws+hYpPGHVXd2d0e6S/j9U/dymMhQ/KiV26f7ubbsIGU5VgRuE5cGDB8EYw7Fjx9CZWdc9AUZCWOiFNvZbLGNzcXXB07ykWMyCSRAX3ommJUv5ZFm1Og45Y/4meaP37ZMGdjDm1l6e7O44uKl0kLJ49niL7RDqQkcHNHffA42vH9TKd6V7VPYPQxvtru/IhccRBRGHFl+THozlN9GD8Q2YBBMullzEu+HvWoQnPH30aezJ3IMWQ4vdHdEAANeDAXY7TIt+jfXvvMQF7r4fpiE/Kd7pIrGxqh37u1fktgQosGzJCjDGkJycDAAQTQIqVyZKDWIO2L6imFKdguePP8+/l48ufARtq9apttuK2SggI0KLfT9JLeuXfXCEhK4VSOi6CFfGy2h1od1e3bvQ3l7g9PHdhSiK+Et0OrxUaoRVjb6M5XpdG/fSNFS6N7Fg2Awnw97KFrvyN3hw7z28ZWVcRZzr7DZ1oXPe/b1JaF/92nYRYs9ntjJOQkICGGNYuXIlTG1d0M7p7pC04HmA3Y6r7EV8MXcxvGXheGrOTggLfo36wJ+5yK0LzoBgMKNi3jxofP2QO/4BmGq7GzY4EHNrLz3X0wlnVTKxQxx2JCfz3y877UcolD5IS/9y6GO4y+vt4uPkJ1fz+0VtWatjtrqZdmM79mfvt+jg5R/sj7fOvoWzhWdhNBv5e23piNaXtsYGVK+UcgQKfvgj1k59Gbum/xPZUUoIQ8X1DgNdXiN2zYyCPECJrd+okKTU9HZArJYeANviK3jCqLF66Hu7wWzA+uvruXd77P6x2JO5Z+i4ZBdgNgrIjNQieE4sP9+CpqlwZEMECV0rkNB1Ea4UuoJgQGzc41AofZCROd3p47uTKSn58FKpsbjA8cxaZyMKInbOiJS65sSOPvsGZLg1U62IGI18LJ488oR0cw8ZizOFZ1xjd/pRVL4kdUIreODP1stxDSRC7PFiWxGWdXV1fDLUlZWgerWUVNa0IBBgt6Ni4R/xZ9lpeMvCsWfeB6iZs52L3Ma5Mohpkl2mhgbkTngQGl8/VPwk6z3AMGNu7aHFZOYrJNeabF+KHRIbhXr9nr3S7/fU0ygoWAmF0gcpKe8NPb4TusHZhIuPIwgiDi5MgDxAiQvbMhyz1U1UtVdhbfJaTAydaCFwp12dhmuV1wb0tA7WEa0vnW2tiArdh00fvA79/F8C7HZEfz8J6kvhMJuMg+47XHITKrH1axXkAUrs/iEaFQVNSElJkeJzV6yAIAjSA+kyqTJKQ9jQ3dnyGvPwxpk3+Hfz+pnXLWsDuwmzSUBWtA7BgX0E7ldKKIKz0VzbQclog0BC10W4+qSrqDjKuw+1tbn/onMWs3PLB06eGSWc3aSGPEAJRYgdy3SO4kiyjL0eXYv33jGgiNG16TDl1BR+o9+ZvtPpS43C3teRe293J7SpVjqhWRMhtsQlL/stoD5k9TsURRHr168HYwxRK6eiee43UjjCnIMwsl9g27z34C0Lx92yEyiQhXKR2zLvU4jM0q6GAwe5Z7MjxX0lpzRtnVzo6vROLlBvg1DXzZwJja8ftDO+R3HxFiiUPkhMenXosR3sBmczbjhObkIlFyH1dsR9upvs+mz8FPUTxoaM5df1+P3jweIYCpus34utdUTri0HfiYQTR7Dlk6lS/O1Hj/Hv1ljpmvuoKIq4draIf/cHFsSjqUYKhzt9WqqFvX//fgBAa2R3TH1gDEz11psVmQUz9mXu400wxgSPwbrkdW5p/mBhh1lAdmwFQubGWQjcq3uz0VTdG/JHQtc6JHRdhKtPOkEwIi7+SSiUPkjPmOaSY7iD3dpaeKnUGB+XNdKmDEhSeDHkAUocXGhHdrEjOJosY2fdUxx8WxKA6kODipjmrmaLYuiL4xfDJJic9rEbv5kgicO7fWGSDSJYdzwx8ABOCA84c/oUGGPYyz6Dfv4kLmbTFjyLSXP2wlsWju9lZ7v/rkTH/FcGtEs0mVD0yqvQ+Pqh6LXXIZrds7x5uU5qq/0/EWqYRiCmvOCZZ6UHld27UV6+DwqlD+ITnhl6R1s9rdsedaxSghs8x0KXHvtnX4E8QIlLsk2uqxwxHNtEAZHlkfj00qcW3tvHDj8GuVqOus6hGzLc2BGtLyaDASnnTyPo8/d4DO6mD99E6ZZ3pe92wxib2v7ai9ko4MqeLC4CT65Ngb6t12O8ZcsWMMYQEREBQW9CxeJ4aSXmZL7VMXVtOnx88WP+HT137DkkVyU73fbBEMwCNHGVFl3c5F8pcXl3Fhqr+odbkNC1DgldF+GOk66y8gT36ra2jk6hOBSxja3cQ9BiawavGynP6e181Nnm4id5ZyTLuDDhpsvchZkRM/nN/xvFN9aLw9tJ8VPjJG/gs97DFyEOhgdkXdgFxhgWs/nQL/SCTnYFWlk0Ns5dy5PQomQR0MkuQj//sUHt6rh+nXt1G0JDh/292MOe7ofGB+Ldfy8wNTb2xlcnJqKi8hgUSh9Exzw09M72hJ44UinB1bHA3Q+p2bNf775nXEXj/Hvtt9PJ6E16HM07arEq4x/sj8knJ+No3lHoTXqbxxooEU0wm5Ghuowd0z7hAnfDe69CFbwTHc1NwO7npO/g7Aynf7bONgNvwywPUOLK3iyYjb0VfDo6OnhIUmFhIVqulkoPqvNiYW7uf18QRRGnCk7hodCH+Pc0P3Y+2gzu884LgojchEpe3rJH4F7alYmGCuvxxCR0rUNC10W446QTBBPiE57tTvr4wmXHcSV9l8KSmkdfwpdBb0LQV9LNpiTdsRaUQ+KsidiFyU+CKGBl4ko+Cbwb/q7DtSP12dm9IilgiE5oTirDNRCdIVOxiC0AYww5bCxqAzdAK4vGG92xua/KLqJSdhKGBffZZJdu9mwpMW3CgzA1uD7ZcklhBbxUaryaYt1T5SraoqK6PfL3QGhvR03NJSiUPlBF3Dv0zo6UxLPnwc2V1R36jG1e+EsETzsMeYASV2fMt29sJ9b4re+sR5A6yKLWq3+wPz699CkiyyMhiPaXdOybiCYKAnLjo7Fnxpdc4K57ZwoubduElrru+F19M7DoF9J3oDlr9/EGo6m6w0IMJp4r7hdSlZeXB8YYFi1ahI6GNugWxkmx9+eK+o3XoG/ADNUMC0+3okzhVJsHQxBE5CVW8Tjvnu3ijgybwmBI6FqHhK6LcNdJV1V1hnt1W1rSXXosV+EfmwkvlRr7K1wsJIfJkWWJkAcoEX/KxXHEzlxadXHyU0hWCM9AfvHEiyhtGX6nvp4WugUT7pbiXZ0tQmxl++PYxb4AYwzh7FW0zP0Y8bII7s09IAuDaeEAbY6X/XZAu4w1Ncgd/wA0vn6onD/f5Q0RvswqgZdKjW9szIZ3JrVb5FKoxuTJAICG/8/ee0dFde3t4+/f7/ot0+69JHlvYkKSCyZYU67GGGNy0/tNMUZTjFE0auwOInIQu6KgUgQLRbFhBRSUmaH3MtSh16H3oU0/z++PM+xhYMoZmBkgX561ZmVFTtnnnH3OfvZnP5/n05FEvksqNhIXQ5Mzc0ZhLTUJHDZJLdjxHaOldHyI7t3/YtdOM3n8VnZVgkqmMC9kHiFts4NnY2f8ThS2jy3aP5iIdiAlCyE7/9Tywg33PIyOhmFWW8II9XU8BgyYr2pcQ1knzm7VOCuUpDXp3I7L5YKiKPj6+qLrfpW6oEsylMNW5+Lq4rD46mKt1So2Ug5zgFbRKMtsRiilTXDv++WjTcTevWOK6OrHFNG1EKzV6WhaidS0D8Hl2UIg+NWi57IUvhWUw4YvgHPp+PgRGkPc5RLr1LI3R7KMtapLAYiujiaD6aIri5Dbarp/qKq/n5DBtpNHR0dCzHXNl74Fn/oQFEXhlOsmtO06gp0cptzvXE4E4vd8pvt5+CzQe8j2C4FMpNN+BgacZ499+d0APskqhQ1fgEOVjWM+lqmoW+PIOE3scgYAdItzCdGVy1kWUNA1OfNbCKOli03V1VpiEjhskqpwfQKB667D25EH3mYn4+0cY7SZpmmkNaZhXcw6rejt/ND58Mj0QFOfbiJoCoauvm3atJ4Q3JsHXdFcpScIELGZaf+598d8/kGUpDURZ4WzW+PRUNapd9vAwEBQFIXwW3dR75LEVDx8UE3+3i/vB5VMaRXEuFF6wyrFH2gVjfKsFuK/PPiL9MkblT3dFNHVjymiayFYs9M1t9wng0pXd5bFz2duuJQxZUv/mzMxPYFL05vg7ciD34ZYKC1ZwW2sEV1rVZcagqzmLCy4vAAOQQ547eJrJtd577pxgyGCrzhA0dZmOgkx5zXnXUctZYd9ru5I2XULZZx4vKKO5q52uoKj1DYdz+QRgySLlstR8fEnENrZo2qBrW7bNDNFq2cnMdG2iw3WLUNK0zRKF7wJoZ09Oi9fBgD09VWQb9LAwBi+gdZyZBgrdLQzd/uPTMTR8QHELi8w/37EVnfhlFHKluQqOcIrwvFd+HdaBPeDsA8QXBhsNm1pc1UF3H28GaLLy8bB5V/jiusOiIRGSud6zWLaHXtozG2gaRrpEVUaZwWXFC3XgeFQKpWk4mHKhQdMNNctBSoJs8IgaBHgoxsfkXu24t4K1Il1VBQ0M2iaRmVOK664p2sR3AjvXLTUGCmqYwBTRFc/poiuhWDNTkfTKqSlfwIuzxY5OT9Z/HzmxqWGdtjwBXg50fR649aAuG2AfIyaq0f/ITKKsWh0rVyBaygquirwftj7cAhywKzgWbhafJX1vlXff88kof05ikQVc1+zQgrZ8cXIdYqAiJMAHw4X0zmReIETiUinm6AoCkpd0UUjy+Z9oYeJBrlzhZ7yu6Ysv+uATKXCk+poG7/dgn1UB+T19eT6BgqYpXGJtMk89ofW8tgdK3S0U+76N5xfdxPejjzEbd6u+ZuuUtgmXqdYJsb5gvN49/q7WgT3h4gfEFUVZTZHlI4GEcJPHILH95/im8NHYcMXYGZ4LKpyMo1HPTsqNW2vyxhTO5RyFR5e0Dgr3DyWpeWsoAsNDQ0kEa3ImSG64tg6yJVyeGV7YVbwLFL84Wz+WYsXf6BpGlW5rUQKN/gLPyUwS9noKaKrH1NE10KwdqdrbX1ABpbOznSrnNNcyOruI0tirTLLGImPBTRN44K6zGIu14Iz/rEQN2tVl9KDlv4WfBv+LRlwPbM8jSa7SIqLCUHqTUoy/aSsrdQWspI0yFv70XiQSVap5cThLU4YpnMi8RsnGpUcPtxc3SCmhhFVNkT60rcQ/Wc6hHb2KJ35EpROupbiDUeGjaFmQEreobI+9ln05oA4KgpCO3sUO8wELWO0jwpFr3lWmca5X4+1ndnbf1ZHdaPR6/KcNtkdGtllGbkW+b+Fw+mH8calN8i7NjNoJjbyNiKrOctsS+7ithZE+3nh+NLPiURhSegt2PAFWFdYze4gGWeZdh96BlCOnnhLeuW45ZGtcVY4r+2soA9paWmgKApH9h1CHSceDftSUd5cqvWd+urOV6aVNx8FaJpGdX4brh/M0CK4d71y0FQ5doI7iCmiqx9TRNdCsHano2ka6Rmfg8uzRVb2D1bRGJkLPUMqOiV2TszSmVFn8hlvzAALR51HmywzASJfvbJerH6wmgwinASOVunQ4Wja684kob33H9CqUUhCRlscQ4ekQVrdTfw163YlwM35LElCi+TwmQjvnhNopF6Alma07KHxdvq9Bfn2R1H8MlMQo+mzZ3S378wi0++BGolDbPr6rOTbO4jmo0cZacb335N/o2kVuLwXwOXZor09bvQHH8eVCnO0U7bnHzi39ja8HXlI2LJZu+33tmv2N9KX8w7+DVt9bDFrSPT2tYuvYV/qvjElgg5Hf3cX+IH+8PzxS0Jw/df9inz+A8xlWRGN4LLaP/fqilG3p6ulHxf3DHFWCK9kPbaFhYUxvtgu3hBxEsALu01yCmYGzcTRjKOQKi3Xb2iaRk1hO64fytQiuLdP5KCh3HyJeYOYIrr6MUV0LYTx6HRtbXwSRenoSLbaec2BV1OYj+hZUet4N0UnBDG18HbkIZCTZPlJxGiSZSaIllGuksM50ZkMxqserEKPbOTkRTUwgJJXX2OS0M74j+5koy13PIwcDRS0QbSbSVRp2JuCtvx6vLMrGNM5kXjvKBcNh5lyoXd2B6Hi5FfAxW+AYy8xxwpdarydvgsBahravntanZhmB8mfj+uIPL81uvsA4EojI/+ZkTjG0rOjSOyrWfETQ+Dd92n9e2zcLHB5tmhujhxbmyxol2dWDG3nkF/mtt8Yjb/jffS5PKv525EXNPvqiAgrqWngHrHBT2de1JInLL66GP55/uiSmI8sSfp6kXglBCd/+oYQXJ/ff0T2/btQyOWsKqJpQSkHDvwfcy1ZgaNqU0N5F85tTWAi4n/wUZxqWpLlYKXDe84XUeB6H3MvMFXg3g97HxlNY5NSGAJN06gr6sCNI9oE95ZHNupLOi123imiqx9TRNdCGI9OR9M0MjL/Cy7PFplZ306qqO7yvErY8AXYVmz5ZIDRoKmqm3ywejqsuzTMChMgojsImqZxOue0Vm344VnfXTdvaZLQWkc5uTE1oqtjubs3qR4iJ6YCWuORDMhb+9EiluB5TgSmcyLhGvwAnbfKIOIkIMPpLvLy1BZ++WGa4xjTH6qJrsplGipeexFCO3tUL9SRmDYGoutRxRj5v59pgh52OKkN/BQ4+qJuQqknsY9WKlEydx6EdvbovnNH62+JSW+Cy7NFfQN7zbbBtlrQLs9sUEgB9ye0nqt0z5M4u/YuvB15SNqyUfO3/Tba+6kjwv1ujyDU42l8fNZOi+B+dX4mbpVcN2sJWrlUgvQ7YfBeuZQQ3NO/fo/Um1chk2jK4xqqiKYTNSma6+w0PeJcmtEE3/VqZ4Ut8agvNY0gdnd3E31ullM4tnqtgUOQA5wTnXVOvM0FUUmnVgELb0cebh7Ngqi4w+Lj8RTR1Y8pomshjFena29PIFHd9vZ4q557LNinNrv/NKt0vJuiE0qFCn7rY+HtyENZRvP4NMJQtG0CahnDSsMwO3g2HIIc8N7191DWqSlkUL30ByYJbcPG0Z/AlIpaw3409Ri6jnmRMr/Np3Kg7GEIhFdMGaZzIvEi5w68z5xFf34r0e2mJqhXSlQqwGc+c7ygzw2384ymilrvmr8TXXL3zzZmky5sLq6FDV+AlflV7HbQ5VZhQhR8ENKyMnI90krtcw/aHtbWnhv1dU1KHBnptZy2dQ28HXk4szYSA3v+b2REF0CrKB1evvZ48/wMLYK72u8FJPnMAT0KwqgPSoUcOdER8FuzghBcrxX/RXxoIAZ6RxJBXRXRDIK3TxNxNwE0TZOy696OPIS4pOgsd2sM6YJ0psqhqxuS9lzD25ffxsMaFjKjUaK+tFNLR+ztyEPY4UzUFVme4JI2TBFdvZgiuhbCeHU6mqaRmfUduDxbZGR+PWmiutebOmDDF+CF+LwJ2+bBmXr81XEg48ZstNrKJ6SWMV4Uj9cvvQ6HIAcsCF2A9MZ0SEpKNUloCYnaO5iydD7Kilq06+No37WPkNy2CwVQSZkolVypwhsHYjCdE4mPnc/Bzc0NvW1i1HHiIeIkIPUKT3P+QTN8ahpQztXf7mGR57p31Ylps1+CctcjZom2D3pR7ylj8b0ZSyWyYROlrhs3mepvr742QmedkfkNuDxbVFZ6jfq6JiUiR9rQSfY8Df+1EfB25CF16zrm39Ua3ZKOEjjzNmFOoIbczgl8BbtPP4eS/U8wUfY281gvqlRKFMZxEbD+N0JwTyz7Etzzvujt1F+9b2hFNFYIWKJ1jWygVKgQE1ikFQkdTdn1BFECtnpsAkVR8NlzAqcvHkZrv2UkcQ3lXbh9IkeL4F4/mIGawnarj2NTRFc/poiuhTCena6jI5lEddvaeMZ3mADI7+knGjCRxHxLc+ZE8s1yeDvycO2A5fRdOsE2IaetfEJqGQvaCkgZ0rkhcxF6fDWThLbkXW1yNBpPXF36TQM/letTaHHyISS3I6wUtFIzIEXmNZIktK3UYVAUhcLCQgjduBBxEpDlNSQqRNOA/zvMsff9Q3+7U3212iDb9hiKX7aD0M4ezV/80yzR9gWpQtjwBfBnkyg02ki4DjI+WNWu5teRxWpycn4Gl2eLsrIDo76uSQmJmHFVGHb/Uraug7cjD/5rIzBAPYukqodayZsOQQ548/wMnPR6Bq3uj2rf9zFOUmmaRll6MgK3rtNUM1v6Ge57H0d3i/FiEvNMSUTr7wBJ2CyJYtU+SZ8ct49rIqIPzhVCITctqbJf3g/3FHc4BDngKMX4517ZdxYqC3ifN1V2466XNsG9diAD1flt4xaoqaurmiK6ejBFdC2E8Z5dZWUvA5dni/T0zydshHQoBpQqPKUmujFW9gFli6rcVqas5zo+ZBLz+FSygimyhAmqZawT1+HTW5+SAf3wzzPQ6uer2YBNlHH/k0BO6MhrGX7Nfm/p3F/haosmp4uE5IpD72u/Gwopvj9+F9M5kfjJ7RQuHN4OiqJw5/YtZJ56CBEnASXUsIljSZRxcnhyLnByjta1tX6jSUyTbvmbfiLDIsKtomk8G5cLG74Aka0sEpTGom32X6x1qKr/fgOhnT1aPI6POE1e/h/g8mwhFDoZb9NfDbWpI8juwJ5/4szae/B25GHLkb1aBPfjs3a47PE0+t0MVIEbxUSIpmnU5AlwaddmrXK9dz0OoK2OXXTW5ES0gptMe/c+AUiNb9/d2o9Lrpryt2l32TsrDCK3NRef3PwEDkEO+Mn7W7i5uoGiKOQ+MK/VZnOVGOGnBFoE9+r+dFTlto7rOCuVtuLe/c+miK4eTBFdC2G8iW5nZzqJ6ra2PhiXNpiKN9VRqdM146SBNYKBHhn5uIlKOq134gmUaDYWdEo6sfTix2Rw38d30Zi0mxJlNFbxTAdplu2ZhQbObTXJjUXfobXaxLKrFiUeH5JoLtdlMRKo/4CiKBzfuwPJIXcJQR7U8gIAcq+xa3Oqn1bkWbV7GsrnMYlpNe++rFt/yTLC3SqTEyKS26O/UhTBWNwqhvQxlVQKocNMCO3sIX44Uv9YJNwJLs8W+QUbjLfprwiJmFm6P/ICug4+iTPedti41xXejjwc/yMCc8+9ip/u/wRuyIdQWuD9bigtxrW9u7QIbth+FzSVmya9MjkR7c56ps0XPjG6aWN5F85tG+KskGKas4JcJcepnFOa4g9Bc8A/FEYS0Xp6zJN41lIjRoR3rhbBveKehsqcVtCq8Q0kdXdnIyFxPq5efXaK6OrBFNG1EMab6AJATs5P4PJskZb2MWgj5v0TAb8VMDqwDULzJV2YG4OejpnnI0yyYBoTJoh1mDlQvPwH/Or8MiG7m/ibIFFITIsyslnKHSJpkOx5G/WcaKYEKOcBJEd/1CbKamLs7LwZ0zmRWOh0AUrXR9BAvUgGzJiDK1DNiYWIk4B+wZDl20vfArqqpekiKcMizz17PiRaZfG9e9rtN8E/NlusKbjSJmOx0jCWiO6QqOJAbi5pv7xp5PJ3aak7uDxbCAQjZQ3/r6BGXIN9qfvw2sXX4BDkgNcDFsBrXRS8HXmIDFNXRzPz+91aW43bR921CG7o7q2oLcgb1TWYlIhG08Dxl5n2JngY3LQso5kk+J7dEm+y9VZlV6VW6eMvbn+B0jQBIp1DQFEUPI+dMOl4utBa24NInzwtgnt5bxrKs1rGneDSNA1RfSh4fDtweba4HmY37pxjomKK6FoIE4Hodndnk6huc8s94zuMM45UNTIWSRljKBlqYXD9meo2EX8eYa8jHSv+IhHdwQz9Qnt7uN78gwxQy+8tR+cZ3XIDtqRLJxRS9N2NgMiJIagNu6Mgi7vNRNqGygF8F0LsaoMZnBuYzomE3+4fAWoaVNQ0HKF2gKIo3KS+Q9quO4yuO2O8AAAgAElEQVSu9/qQiNgYSApN06hdzeiVy95eDFXfkOxyE+Qqd1u6YMMX4Lm43BFSDJ2yB0Ho6Eiu1yytyUXHxUtM299apHPZtqLyBLE6/H8JNE0jqzkLG3kbMTNoJunnb1x6A4fTD+NeCKNFPbctAXKp0mzvd2dTAyJPHoXH0s8IwQ3avh4VWWljWlY3KRGttVTT5oYcnZvQNI3Me9UaZ4XdySY5K6hoFS4WXcSrF1/VSKHSD2NANoBmz2ycdznNvLM3b7I+5nC0iXpx3y9fi+CGUqkoy2wed4ILAEqlFEKhExnfk1PeRWlpwrhzjomKKaJrIUwEogsAgtyV4PJskZr2IWjauhWTTMXggD09LhfKiagrVkhR6LaWiUCsvQva9ZGRg5ElnA3GyzpsFMUDDKHpwAGGGC1ZApVCgfMF58lA9VnQPNTtH5nAM9qBn6ZpiPl1RG7Q5JEJRYdEr61W4O5vMZ0TiX9xbqHT9Wny72HUUlAUBX/KETd3X2AI88EhxGGMJEVWXY1i9fK/ls7VhOP61rZoR9wUUkYqsf/JkdtT0wCvOYDnTNOjup4ztZ59w86dENrZo27dHzqvraY2QP3t+ci0jjJJoVApEFUVhR8iftDS3757/V2cLzgPsYzJPejtlBCP2JyHtWN+v3s62vAw4DROLPuCENxzG3+HMCludBUHh8GkRLTBxMvDzzEWfMOgVKjADdI4K9w4komBHvbJx019TVj1YBW5t+9dfw+pjUxkvD+3FXWceBxyZRLRMjJMTxpur+9FlL82wb3kmorS9CaoJgDBBQCJpAEZGV8Rkpub+zvkcvGE4RwTEVNE10KYKJ1OLM4jL0RT091xbYsxlPZJyBJsZf8EM4IHgLzraHd+hXwAO3a/bD3CaW3rsNE4IBiASiJByRv/htDOHq0+PuTfIysjMSeEqVj09vkZKDzwN/bEy3+xznPRKhqdt8sJyW3xzYWyT673PtKu07DEKQDTOZHY5rxD62851HxQFIV91G6c3HOMHFPeqtbCmmES0nL8BCMBcJip8aI1IVLsXCqCDV+ApYIK5rl4zTFOkD1nmuajq+M6Kj7+hKls5+en87rq6y+Dy7NFUtLoC2FMBvTKehFcGIwPwj7QIrjfhn+L8IpwnWWwYy8Vw9uRh/M7EqHo7x/V+90v7kZsyDl4Lf+aENwza39GXkwUlArzJMuanIh26VumzWErR/xJ0ifH7RMaZ4XoswWsnRVomkZEZQQWhC4g99cpwYlMHmgljaZjmSh0iiZyoyYdchp96GjsQ/TZAniv1RDciy4pKElttIhrw2jR2ZmG+ITXyJheWelFZIkThXNMREwRXQthInW63Lw14PJskZL6HlQqK7oFmAi5isYzsUz2+D022ePWxqVvQVOPIWBtOLwdeSja8V+TI42jhjXLoFqAWHffvcuQuRkvQ96snWyY1piG+aH/ZjSMF15G/OF/GCdceu6zSqZEW1AhIaTtF4tAyw0nvCW6vEmS0PL3zNb6m5h6igyclCuFcg4PIk4CelMazHavVP39KFv8DoR29qj9bRUTLTYhovtzvrqqoLBaTV6NaIYHf4LLGs3wwX8a337IPVf29Gi8kJOSdF5XU3M4uDxbxMXPZd1PJhOa+prgkemB+aHztQjuH9w/kN6YblAuIG4bgO86Jqqbx68z6f2W9vcj+XooTv3yLSG43quWITP8JuQy8wYITEpEU0g1qwg5l7T+1N06gFBK46yQeruCtQSgW9qNbXHbyP1deGUhoqujtbbpy2iCiJMA3q5roCgKBw4cgIpFNLuzqQ8PzhVqEdyQ3ckQJk8sgkvTNGrrLoDHfwlcni1i42aNsA6dSJxjomGK6FoIE6nT9fQUkhlgY+PodUvWwJL0YtjwBThezX42bjWoo2zhG4/B25EH7mZnkyKNY4a1rMMsIJWoXr7c4DJ3aWcp3r26GA5BDpgd+ApuHHvK5PMre2Vo8RYQktt1d9hgqoc8/r7LDdM5kfjSyVPneXyo9YTsxu8KY4pMHAjUyDiGkpThP5aTEHFUFCGOPTExjI0ay2fwXkYJbPgCeKbGsI/MDp8omKg17ktJIe1VdnfrvKa2Nj64PFvw+C9NCotDtihsL8TO+J2YEzyHkK95IfNAJVOo7KpkfRxusBDejjwEcpKglKuMvt9ymRSZEbfgvWoZIbinfvkWyddDIe1n4bYxCpiUiFYZp+kn4gbyz02V3Ti/Xe2ssI4PYXKDgYNoI6k+CUuuLSH32fGhI1r6tSUUtEKFxkPpEHEScP14MCiKQnBwsMHjdjX3I+ZCEXyGENxg52QUJTVAOYEILgAolQMoKNxMxvDUtA/R3z+yAmJdbe2E4RwTDVNE10KYSEQXAPLy1zGi9eR3oFKNXEqbKFhXVAMbvgCrC6vHuynaUEgB34UANQ0Z21Yx2q0/gllHGicVzJz8Jq2o0JC42Fi92zU1ZuOr85rImLfnM6BZRkkV7QNoOppBSG5PgmgkudJB5updn8fznHBM50TipssnOq81mvoMFEXBjdqDK7sD1O4N90G7PqqRcQySlAtDjnFzNetJCE3TqPnlV6aQxuLFUHnMNn7/1ffALiEfNnwBrt90M02G4L941M+8zT8AQjt7VHzwod5r6uzKIIOzUjlgds23NaGiVYiti8WvUb9qRW8XXVkEH4EP2gfaTT5mV0s/IVoF8frHCaVCgbyYKJxZ+zMhuJ7Lv0JsyDn0i3VPMswFkxLRHroy/cT73+SfyjI1zgoBm+MhKtZffW0o+uX92Je6j9zn1y6+hqvFV3VOmHqTG5j33ikB3ieZRDQ+n6/zuN2tA+AGFcFHHU33duQhyCkJhQn1UComFsEFgIGBWqSlf0reo/z89VAoRkpI5BIJApy2TCjOMZEwRXQthIlGdHt7S8DlvQAuzxYNDdfGuzl6cbKmGTZ8ARalFY93UzQYqlelpqHOaSH5SJK69aOMdE5ImNnuqPngISYJ7Z0loJV6lj/VEgCx+2P4ze9FMsDtPv0c5EaipLK6HjS4pzKDnXMi+nP1lPvUQeaOOK/GdE4k5nFCIXF9YiSxo6ah3G0Oiege3XOIkGnpntd0SxPubmD2P2LLyjB/ENLycghfcWB0zN8YkRKoCXavQqnRUAavHH1E18QovmjDBgjt7FG/TX+J154eIRmgpa0Cs2q+rQWJQoJrJdfw2a3PtAjuZ7c+w/XS65BIusdE3h+eLyTRxOGRRFqlgjApDuf+/J0Q3OM/fI6HAafR095micsdAZMS0QYLtUQ7M84TUdVa0dKORnbOCnmteVrFZZZFLkN1d7XObVUyJRr2M+9+4+V88p6Wl2uXTBa3DYAXItQiuIGcJBTEiZho+gREe3sC4uLnqt+hF1Fdc0Yn0e/v7sJFp83Y89l7E4pzTCRMEV0LYaIRXQDIL9jIJIckL4JKNTHL7D5o64YNX4D/ixVAaoaM4TFDZ/GBf8DH8SG8HXmo4rxrMNKo95gTObJlxoiuSipF6WASmre3/g2HEC0ZNQ07vZ/XLFf6voC+wYpR97Zr3acBYTvqXZKYKCuVAmmlAW33MDIncX0CczmXMZ0TiSPOqzV/83tLs3QcuQ1y6jHso3YTnW6VUzhTWW3377onN111gLs6qS7+mPH7PQTN236D0M4exTPsINv2mP77L7gMACjuGyBEt/bKqlEnlpmqNR7UFHcYWCIeGKgjRLffb5Z1kynHiPaBdngLvLHoyiItgvtb9G+Iq4uDilaZJWGzo7GP6EMHl/RpmkZFVhqCt6/XKtcbefIoOpvYL/uPFSYlovW2kuepLH0InlqW4e3IQ9jhTPSLjY83cpUcPgIfzA6ezUiYgmfDL9cPCgN5JT1xdWSCW5JTRIjuwMAA8/cOCfiXioke2tuRhws7E5HHF5lcYthaoGka1dW+JDAVFz8P7R2JOrftbKzH2Y2r4PH9p9jz+RTR1YcpomshTESi29dXDi7vRXB5thDVh453c3SiZkBKPq7C3oHxbo7eSNfV9QHwduQhZesfeiONOmFmNwOLwIwa3e7wCE0SmqEs6GHkWkVNg6fXM4RgfOf/L7Tue1yLXPemNULkxERXGw+mQ95sJGI0jMzddPkE0zmReJ4TjnrX55lzu/8duPhfzcRD3a4Q6hcyiOY6+0DESUDrLm/9pP/+TuZvh54BBtgnVirPf43S2S8xeuYlzxmdZMSok4We4gsgz2VbXe4R3cSSZUKUvKWFSFH6s3P0Xotc3kmIrvjY42bpT5ZGZVclqGQK80Lmkb43J3gOOAkcFLUXaTY0Y8JmlH8ByfKvyc9FqMs2rWIPt4+6o7VmpCbT0jApES2PqRBIu/8dESdSCKmM8i+AQmacUFZ2V2JpxFKtiHlhW6HBfVQSBerdUiDiJKDzdjn4fD4oioKPjw96OyWICy2B7x8agnt+RyJyuXWs2jNeUCh6icyQy7NFWvpnGBio07ltY1kJfNR6bc/lX+F+0LkJxzkmCqaIroUwEYkuABQWbgWXZ4vEpDehVE6cCMogVDSN5+PzYMMX4FZz53g3R290M37LNng78nBrwylNFJBNJNfaNmGjgUQMHH3RcDSXZTtrVvzEkLa16wxvqEcucdnjacwMfAUOQQ744Kw9KgMWgqZpdEdXEwlBs2c2lGKW92wImfvSyQvTOZFYvYsaeX2DEw/v+QA1DcnUO5oqaS4u6nPzoHL9O7Ot/2Lt8/S2aDLQue7s2qa+D92/2Gg0zav/rvsZqM8XVN8GG74A85ILjfevwZ+hCRWLhMceHo9p38uvQCWR6L0UlUpGBuwOTyO2ceOobadpGqmNqVgbs1Yrejs/dD6OZx5HU5+OCZoZJ4Ntol5Cxk6s0JDca25OaCg1kARm4ZUhkxLRbjkC1DQ0UovJtaSwcFZQ0SqECkO1ij8cTDuIAYXxIEf3wxrmPdydBKVYiuDgYOx1OYCgg9HEp9jbkYfz2xMgiKmFfAITXADo66tESuoH5J0pLNzKaNt1oCIrDV4r/guP7z+F14r/4vwmxynpggFMEV0LYaIS3f7+KmJRUicynJk6XvgosxQ2fAEOVppW99ysGBxE9Ngule78FN6OPPg53ofS9TF2etXxKvxgCobpkXX+WDoJSCurNIRNT3IIgQG5BPeIDV69wJQNXhQ4F2VBKYTktp7Nh0piomWeQoq82BvEUizR5U395Gv/kwD1CJqp5wnRPee6kZxf4vKOfpIWQzHH2f8Us7TLBpe+BU09iuqFzzOJaa++CJWLflK4v6IBNnwBPs8uY/bXcoAYZjO2/0mmkMQYiVCLpyeEdvao/Ppro9vyY2eAy7NF6ykW/sj+i8fULlMhV8oRXhGOb8O/1SK4H4R9gJCiEPTJ9awQDElMHSt5bxfV4q7HAZxc6Q9vRx5O/X4dF502oyZPYNipwgorQ6wT0WgaysMvANQ0JG3ZCN91fBQlGZdYNPc1Y/WD1VqFNZIbklm1TdknR/2eZMZd5V4lejsHcHz7JZx2jCEE99y2BGQ/qGGqz01wtLbGIDZuFnEpqasL1Pv8BQ8itarfDf6miK5+TBFdC2GiEl0AKCraAS7PFgmJ86FU6o/IjBc2F9fChi/Az/nsrXrMChZkT7z7BfJBbXZ+jV00aqKX8mUTETz2LybiywLNh48wSWiL3wE93MB+eDTKCHEQHPwb3g+Yi7vu/oRkdlwtAT3KTOlt13MxnROJJU4BoF2NTz5oahoOUk5MQhq1Hc1Ogcwg67xJ/+Skv0MzUYraxa5h6smQ5M/HIbS3YwoyfPv0yDapzzfoUrJuKBmxsA1d7UpGR9y4x9XotoPm9o2+RryRrdjvxTIxzuWfw7vX39UiuMsilyGqOsqgJpTVRJAFee9uacJ97+M4vvRzJsls2UryPSnLbNa5D4GVVobYJqLV8uPJuW9sDUKd0Lizwv2q+3jz8pvk3u+I34FuKXsHia57lRBxElCxOwkJl0vgNySCG7A5DllR1ZCZOgEeB9C0CpWVniSKG5/wOjo703Ru21pbjdDdW0cQXK8V/8W90x5Ii3kwYTnHeGOK6FoIE5noDgzUgsf/F7g8W9TWnh/v5oyAn7qk6RspRcY3NjdYLv/SrtMQuO46vB15yN3+I7sorJndDMwOthFnv4VGl0hVMhlK/z2fSUI7dVr7j4aiUXp+SsoWdS6XCck9dtQZIYUho7rMzj4ZXtp9H9M5kQh0+c44Adv/JOD2KM5Tv4OiKOylXNDlvImRTTgFGSYVsYeZ47j/XctbVC+G9L+mz/7JJKa9/C/Itz+mk8R8nl0GG74A+yusk6RE0zRKXn8DQjt7dIUZ7/PJKe8wq0dnWBQBsfBKhqhHhEPph/D6pdcJwZoZNBN/8v5EdnO2ca9fttIQA+S9t7MD3PO+OLHsS0JUAtb/hsI4LsJPCeDtyMMV93TDS/5WWBlik4hG0zSyo2uQtGUjQE1Dv+t0dNQbTlrrlnZjR9wOcv8XXF6A+1X3TWqbUixFxa5ERP8ZC78hGtxTa6NxwikE0v6Ja585FHK5GILcVYTkZmR+DYlEexVzoLcHguhIXHTaNILghu7einzeA+KhPJE5x3hjiuhaCBO90wmLd5EZpFJpGbPx0SK2Q0w+sn367KgsBbaDCDUNUX/uYxIudpxgFz2Z6BFdNu0b+jOwRNodGalJQmsYQsJYk4VHyP2Q73kFjc53iVemV4A7GSiPZBxhMuBNgF9cBaZzIjHD6RbErjbGr9NnAXBqHh5Qn6jlC67ocnmPkG5lw7BEoaHRat+FwF61bdndjfobNXQfn/nA/ieh3PUISmcxiWmi/6gT04bJRuaqo25B9daxm5JVVxM5iqSkxOj26emfg8uzRXXoDPNFIE3Upua25mJL7BbMCp6l5cu6L3UfasQs/GEHYcK3YTjZHOjtQUJoINFVenz/KfzWrIAgOhJKSS+Qdx1NvusJaau8c1v//bDCd8RYIppSqQI/hHFWqHVaBFDToLj2u8FjJjcka0XRVz9YjeY+I9HrYZD0ysE/nAk/R96QCG48go5Gwm2POy5fvmzS8cYLvb0lSE5ZQkiuUOgElYp53iqlEpU5GQg/cQieP345guAGbf8DbaKR392JzjnGE1NE10KY6J1uYKAePL4duDxb1NScGe/maKFJKidEN0dsZRJuAtkTbF/O+DHuiGNX+Wmia3TZRpxZEJSan35mktDWOGr/gXXUmLH4kvpvQv2eOMY+zCUJA0Xt6Jf34w/uH2TA3Ba3DVKWiZVKFY2Fh3mYzomE8xEP9oRBIUVFTCDR6eb5rIFoVzxEnARt315d0eqhWtkaHeVyDUS4u359lhDLvkuHte61XEXjKfV7wm1nJycZKwZdNIrnzB0pR9GBrOxl4PJsUV7oMvYS1gopkOqrSfIbPikaMvFSqpSIqYnBinsrtOQJ71x7BwF5AeiSjKLEuCkTQfW7IevtQurNqzj96/eacr0rlyL9ThjkUsmIZ39n4wl4O/Jwbb0/aC89E0krrAwZSkSTDihwxzNHk6NAqfXXebr92QcUAziYdlBrkhEqDDVpgirpkyP1TgX8N8YSguu/PhZp4ZWQ9svh6ekJiqKQmKjbhmsiobk5ErFxDmo9rh3q6xly3i6qRdzF8/Bbs0Kb3A7R4yaE6tfuTnTOMZ6YIroWwmTodMUle9RR3Vd1VlsZL9A0Tao9XW40veIQgNFnJLMdRA7+E00Pb5GPbk8HC63zRHddMDWiq4eYS6uGJKHxeKafQ00u+/NaIXJOhIiTgAb3FEhrNWROoVKASqbI4Pnz/Z9Zafy4wmaShFYSH2bS9XV1dRGie/PmTbT65zHWRjfUiWBsotUH/0/7+RrZh6YeRdXbLzNVyD7+BLRM40daO8SKr7jPOlZ8TQcOQGhnj+ofl7PaPjdvNbg8WxSXuI5NO9xVC5ycY7Tf9J+ai9DCYHx882MtgvvVna9wu/w2ZMox+IebMBFUeM1D9s0g+K5eTkjKyZ++QeKVEEj61N9aHc++ftcC8k2pcVqi+3tghYiuvkQ0cdsAQt3SSBuLgoZUh+wdqeUtbCvUKrbxQ8QPqOpmb5Um7ZcjLbwSAZviyDn9HHmI2RGP/k7mm9vT00Pey5oaEyL0VoZKpUBZ+SESxU1MXIDmhiQIoiNxadfmEZHbEM6f8P7tB0bDvfRzCKIjDR5/MnCO8cIU0bUQJkOnk0gawY+1Z5YWq33Guzla+FKtPXQtH8X9G0tGsgmDiFKhgt8GJsJQmmHAI3Z428Ya2bIURrM0q2NAbT5ylElCW/T2yKgfS7LQc8SJSAMaj2ZA0TaMyCmkoHOv4UzIO2QQ/eLqO2joqjZ4iT+dT8d0TiS+P5Ni8sRDJpORAfXEiRMQ82qZ9h1KZ6IsbO9f0kmT7vnAxicgtJ8BoZ092s9pNPXJnb0aiY8xn1MzofqHZRDa2aP50GFW2xcWbiFWSaPG4HMa7iIx5Nfi/hi8vJ7Bm+dnaBHcNQ/XILk+md2KizGw+DaoXKch33UJ/Nf9oinX++OX4Af6o6+rU/t4ep79zQ2nmEILG3yZRMnhKzxWWBnSlYjWXCXG+e0J8HbkwWcdH4UJ9UC0M3Muv4Va+ytUCvjm+mJO8BxS/MFH4AM5y/Lz0gEFMiKrELA5nhDcMxtj8WBTLCp2xKM3WSOHKipiCkXs3bsXcvnE1OfKZB3IzlkBLs8WMTG2eHDtG9zxcBshTfBf9yuSroagOCmOkFyv5V+jPCPV6DkmA+cYL0wRXQthsnS6ktK96uorc6FQ9Ix3cwh2ltTBhi/AD7kVpu041qipiYPIzWNZ8HbkIf5KqWlttGBW/KhharLN4M9/MTmESiZD6fwFTBLayZMjz2GELNCuj6LLebvGI9dbAGXvsCjcsInM7WNPYY7aa3fJBQcU1+i2Mqtq6yPR3Mi8Rs2xTJh4uLu7E7LbWlRP2qloH2AfET/2kmbF4Ygtq8lE47I3IbSzR8nceZA3M+TjelMHbPgC2Cfk63+eZvRZpeVyFM+aDaGdPbojDUeXBjG4apSbt2ZU5wRg8J0s2f8EnE8/R56/Q5AD5gQ5YHfibpR2mvBOjrEdtOs0lGyxxfkVSzTlepd+jmg/L4hb9bgW6OkvdU6LCLmr2/X2yMishVeGdCWiVWS3kEl9wKY41BWpnRV8GJ9pPNQ4cFR3V2NZ5DKt4g/5rXr66DDIJApk3qvG2S1DCO6GWCTfKEf9hQLNxHKI20p0dDQoikJAQMCortfSEPcUICl5ESJv2CPkwHyc/u0rna4JNfkC0CoVytKT4bX8a0bmsmqZYS/lIZgsnGM8MEV0LYTJ0umk0hbidVlZpYOYjBMuqI3w5yQbro4zAmONdpg4iKTcKmc0dQcyxnjFEwRaPqwsfsMiuuJ79xjZgv0MyHX1fYNk4Qm07zpEyGNbUCFUw03e9Tyf5MP/wBtqr903Ah2QXBc34tTuEUWYzonEGwdiIFeqtI/JcuJx/PhxQnSzMrNQTzFenr1pjaZpnI+/bNJkQuG1iJRSrt+2HQBwQq2jfC9DR1KYBXxWJUIhkaTI6nRXaxqO8vLD4PJskZ39o8nnIxhGCGlqGhIP/wO/+72gFb198/wMnPR6Bq3+i0Z/LkPQ0fdo12mo2jYdIT8t1iIv4ScOob3eyD3S019o12kI2+CrKUjjv3jkvhZcGRqaiNYjVyD7QQ0pUxy8Kxntg84K4gZNuyuZPIWrxVfx2sXXyDPZn7qfVfEHmUSBrKhqnNuaoJEobIhFYlgZ+sUyyOp7yXehL1N79ezs2bOgKApRUVGjvmZLoabiMq6dfgO+G94dIU244rpDyzUBAHKiwokm9+yG39DRIGJ9LpFINCk4x3hgiuhaCJOF6AJAWdkBcHm2iI2bBbmcvZehJZHSpVmW7ZKb4IdoDv2aCYNIVW4rWcobF99GS1RHGiR+fm+ZPGmo+eVXCO3sUbt6tf5j6yCqKten0eLkRwazzpsloJU6lpsNEOXiA0/gnXMz1FG9WbhTfofs1i9TwIGKxnROJLxiykZ9a/z9/QnRvXbtGtqCiyDiJKD9knD0GmeWk4nOK1c0pXczMrCtmFn1+GW437SFIn6dV69BaGeP0n/PZy0FqKr2Bpdni/SML8asm5dR03Dr2FP4KuBfWgT3k7N2uOLxNPrdHrG8a8mQb4No5zO48stbWuTlpvtONFeWszuWgf5S7fQOIXwNPn/q3t9CK0ODiWgLU4XgXyom7bh+MAN93UOOnXOJae/+J9EiroNjjCN5JkuuLUFSvY7Ey2GQS5XIflCDc9uGENz1sUi4Vqp1rjZ1NLfJI1PruyCXy8kqS2GhiUERC0GlVKIiOxWh7itw/IePtfrHmXW/IPFKCDobtXkBrVIhPjSQbHfRadNIqYsODAzUo6EhDIWFW3Dz1rxJwzmsjSmiayFMJqIrk7WBH/sKuDxbVFR4jHdzAAAdcs3yWZoeH0edMFdGMstBZKBHRj7QomLjRulmhaWrI5mqYR1iPdUTE2O43UMmEoo9L6LJKZSQXPH9fP1EygiZbNj3GL4IsCMD7pncM6BpGpfTazGdE4kXne+hpUdP4iALInbx4kVCdA8dOgRxsohxhHBLAS0YhcaZ7S8/DLRSicqvv2aqkn3+BX7IYioIOpcOi/pYSMPZsHs3M4n5Xc8kRgfq6oLA5dkiOentUffVzotf4YznM1h8Tlt/+/OZF8E9YgPlGK/LVDSXC3Fz1xrt6Ny2lRAV5Jh2ICNSiGvrmWppd/ZFW+ZC9GAwEe2LmwLybbvvlz+yhG7YbwA1Da1nF2PhlYVaLijGXC3kMiUEMbVE8+vtyIPvej7ir5Sit1P7GyutEZNvg5bDCYDa2lryPorF1nEe0Yd2US3iL12A75rlWn3jxI+fIsLrAGryBFCpdFi1KeS4d+oY2f7GQVfIJLqj4DJZO5qbIyAsdiYe1YO/q1efnTScw9qYIroWwmQiugBQXn5EHc+X1TcAACAASURBVNWdCZnMyoRND2YlFZjuEToOXrWXXFPh7chD5j322cRjhrUcHEyIbrccO8Ykob21CLSxpBD1REJ2dh0anO+pPXLj0Zdh5H1hMZHp3vsofr4whwy8VLIbPvSMw3ROJDZc1kNGWE4abt26RQZWiqJQnV9OBmFZTbvxZ7KPhW+vgefYn5NDJhN73I/Bhi+Ab+0wDaiF3oHKL75Ua69Psd6nsfEGU4Ux+gWT+2p1dzXcU9zxWrDmWc4KfAXbvJ9H/gFdJYUfsahrSUeDCOGeh7VITPDOjajKyRxdspuRd7jS6QNCApsqrbfSNieR+e6uOJ4Eb0cekm6UjyxgoVJBdZjxdj508lmm+EPoAkRWRhq8Fwq5ErncOlzYkaghuH/wERtaotO5hqZp4m7S7JU9oh1JSUkkOXQ8IOntheDBPVxy3jJCmuD35xJwL2/GQK/+Zyft78N1d2eyT5SvJ5RDEngVih60tfFQWrYfaemfaBHbwV9snAMEuSuRln50UnEOa2KK6FoIk43oyuWdiI2byXhelh8Z7+YAAL4XVMCGL4DT8IiVIYyDVy03qAjejjyEn8o12zGNwprXySK6TctkKF3AJEy1eHqyOqyktJPUq693TYakrNP4TixJnPTiN9gauxUOQQ6w9/2UJKFlVOuYxJkwaRhMfNm3bx8oikJsbCwaD6YzkejYOuMTg8HkHbY/HXrLBqddENrZI3P2XNjfiUV4y7DomTlXNdQRbtXpRRDaD0brHxp/Tmq0NEWCy7MF/+HzrPoqTdPIbMrEBt4GzAyaSQjuG4EOOHxyOur3PaZ/f3OsYuiAuK0F0X4ncfyHzwkhOb9pDUpSEkCrRleCmsBAf6FPvoorFEMII05b59sirOgkK2k79ySgIF73+JWfF0Lu++cBdlj1YBWa+vQ7zyjlKuTHihC4cwjBdXwIPnUK4qQbeicnkrJOMpEcKBppNXnlyhVQFIUwFlX6zAWVUomqnEyEex6G53LtxLKTKz/AxUP/RtSdOWhuNpyw2dPRhuDt68m+SdcuQaGQoKMzBRUVHsjM/AY8/ksjiC2Pb4es7B9QWXUKXV2ZUKmYZN3JxjmsiSmiayFMxk5XUXmcGZRiX4FUZp1KS4bgWlYPG74AX+WYoKkcB6/awoR6eDvycHZLvOHSnebEBKuyJo6KIkloMpHxiUlfZjNEu5gBrOFAGmQNLOUpJhB8Fa3CkYwjeOHAfqYSmnsI2vp19GsTjpmYmEhkCxRF4fz58+i4XgoRJwGtZ9WZ5YYmBpe+hSGbLPI78oJevaWirQ3Fr74GoZ09jv/qiGxxn/YG5tKpD4lw9//xNxJJVhyaw45QdtWi49xMMkCrDLRH4fYo7od8gKURS7XkCe9dfw8XCi5A3Fo0khAO/vY/CaT6mT2S29/dBX6gv5YFlP+6X5HPfwCVOSs2GugvZZnNhBi21Fh2ab4ypxXb9iUyiWi8HAjzW0dsI1FIcDj9MDy9ngGoaWja9zguFoboLf6gVKhQEF+PIKckch0+jg/B27wL4t0vGpSv0DSNZm8BRJwEtPgIRkSKaZrG0aNHQVEU0tLSzHcj9KBdVIf40ECccfxJi9x6Lv8al/ctx+1gB8TE2CI5ZQl6ew1XDWyrq4H/ul/hsfQT+G54D6nczcjOWUESw7V/LyA940uUlx9Ge3sClErdsobJyDmshSmiayFMxk4nl3cjLn42uDxblJUdGO/mILSxHTZ8AWYkGtBs6oKVvWrbG3rJR7yjoc/4DuaAFaojmYLalSsZ/eYqw2VAaZqGmFtLojRNx7Og6GJRbGMQJk5kWsQSPO8UgemcSPzLcyU+uvHRyLKvJhDD7OxsLaLr5uaGzow65np2J4KWGyFAZorE5/ufJcSzISPTvOfQcY/blz7FyFLmvshusqg+htjjCTJgy/eNJPi9bo8g6Pj/4f1z9loE97vw7xBRGaHtu2olWz5pfx+Srobg5E/fEDLj8/uPyL53BwrZGApOjAIqFY1QipFG3fPNM21nlsl/NE0j52EtvNfysNQrGTZ8ARYkjUzsKmovwhe3v4BDkAPSD/0doKZBfP1nnadWKlUoTKhH0K6hBDcG3M270b37X6wCEAOF7eQ7ISkfqfnt6OggEqKGoWXGzQhJby9yH95DqPPWEdKEyy7bkRV1FSlJX5E+Lsj9DXK5/gkJTdOoyL2HS4cX4+b5WXgQ9aJOOUJK6gcoKaXQ0hrNOkF8MnIOa2GK6FoIk7XTVVadUkd1Z0Aq1eP/aCVki/vIMlqL1EQjcCt61dIqmvg+FiZY6XlPoIiurLaWkC7xgwd6t6OVNDpvlJHBq+VMHlT9ozB4N2Ei4xVThumcSNjvicTcoH/DIcgBb115C7mtQ5aCTZg0lJSUEILr5ubGZHtn52sGZGPyC2PFD1iuOEQ2tiFyyftMYtrX/wU9NMJoAS/p+veZUsSi/0xnR8bVx+g7/BgZvAcOatrT6P4Yjp18FvPVlnCDvz+4fyC9Md08BR5MhFwqQfqdMHivXErIzKlfvkPqzat6k4OsgZK0JkIW20QsVz5Yas5VShViQ0vI8d+/kT2iIppCpYB/nj8p/vDvQAco3dQSkoKbWqdVKlUoSmpAsHOyhuCu5SHm+H107bZjPfmiVTSaPbOYlZIA3QQ/NzcXFEVh//79UJoxwq5SKVElyEKEDmkC45oQjI6GenR2piM+4XXSvysrPUHriGwPDNShoeEaCgo3gc+bq5PYJiW9hSLhTjQ23YZU2jyqdk9WzmENTBFdC2GydjqFogdx8czLWFLqNq5t6VMoCdGN7xhlMQtL2G/pQPipXHg78sANKjLrcfViHLTI+tDicZyxnVr4lt4kNJVUSSyCRJwEtIcKtUzfTQaLiYxcqcIb+2MwnRMJ96NHkOW/AG8GzYJDkANevfgqeLXq8sQmTBrq6upIFCkgIAAURSEiIoIMyt33WSQk6vQqfsSkFYczdS344EwomWB0Xrmq/xymrmrouB/l815kKrN9/zS7SZT6GNIDj5LBvPfIYyg88AR2eD+P2UMKPLx64WW4nZqOygw/4/duOMzwfisVcgiiI+G3ZoWWiX98aCAGese/iI5KqUKISwq8HXmIDigwvgPLiY6spw/hpzTOCvd88zA3SbsiWq24Fj/e+1Fj5XbzE1Rm+Gr6bH8HaaMwuREhuzUE13stDw/OFaKzqc/kiXm/oIV8K4aW/h6KiIgIUBSFwMBAs9xnfdIEr+VfI/LkUVTn5UClUoKmadTVBYLH/xex5Wxt1bjMSGVtaGoOh1DohKTkxTqJ7YP7dsjK/B319ZfR319tlondZOUc1sAU0bUQJnOnq672UYve7SGRNI5rW15PKYINXwD/ulFEly1tvzUEmfeq4O3IwyVX46UazYJx0CLrAi2TofTNhUwS2vETOrdR9sjQfDqHDFxd9yqtomWOTM0nSWhVrkw0qfLA3/DBWWaZfFbQLFwpvmLSpGHocum9e/dAURS8vLzQFVHJZIafymHXuEGiPlgZbf9TQO5V1s9rj1q/fnXlGmaS8ca/oegcFk0e7arGsAi3wukRQqj71g5xO/BfbPQYir3TyOC+I1C7wMPb52fA1/Of6HB/fHR9dbTvt5ocqy5+gyLqXZz99TONFdSyLxBzzhe9nRPDeWYQRUkNhDx2NBqRR7Hozz0uz+OK8wNCSpPCytAqkZPAQnJnD66VXMPrl14nz8s9xR398n7g3g7mOAFLoFLRKEltxEU1ER9sY/TZAm0ZlwmrJrSSRtOxTKZoTKB+b1xfX19QFAUulzvq+2pMmpDHjYK0X3MdSuUACgu3akkMurvz0doag9JSd6SmfaST2HJj7HHzwiwE75uPqwdWoq/L/P1rMnMOS2OK6FoIk7nTKRS9iE94DVyeLYpL9oxrW37Kq4QNX4AtxSaSUisTQVFxB/nQDwwvWWspWFmLrAvi6AcGq2XJW/vReCRDbR+WgJ4kK70PCim+33Ma0zmR+GnXAa1n3+r+KL7z1xQdOJFxDKqTc1j1FYlEQohuZmamRiOYUUmuUdlnghyjQaA5T84l1rutVHudOidlo2TuPAjt7NHoSpl+n3RhWPStd83f1c/YDkrnR1hHdAf2PoZrHk8jhssM9t9dZXxwPw+wQ5jHU5C4mRbF1sJo3++uWtBec1G29XkE/vTOEGLzCe6vX4KusmzT75cVoFSqELyLiZY+vGCkMIKR6GmL8xxcWBdGZAUFcUzy6GBFtKdiYrHm4Vryfrxz7R3Ei+I1xz/1KkBNQ/tFDrFWHPxF+edrKqeZ0Kahfaovo0lj2acnSVUikRDpUGmpaaWe2UoThmNgoA5p6Z8R8pqc8h7SM74ElzdSZ8vj2yM7+0dUVJzEPf8t8PjhE3h8/yluHXaDXGJCToIJmMycw9KYIroWwmTvdDU1/sTKZGBg/K7hQEUDbPgCfJxlYt16Ky/tyyQK+KjLZFblWdGxwopaZF2o/W0Vk4S28rcRf5PWiNGwN4UkavXnW+++lMSHkWgu12XxiOfe5/YIHH01Ecad3A2QndITHRxCxGia1qrENJiUlpacBtGuRMbUXke2ukFcXcGcx9MBULCbJL2fUQIbvgAeVU1oP3eOOF4MFJihOtSwd6f1m6chtLNHxesvsHp32gbacDp6Hd46zxDbiBhm8He7+ALiD/9D233h3vbR9dXRvN8KKWr2/huXfn5bi9zcWfVvtDk9yTzvk3OBnFCLS51Gg4L4ekJOu1r69W9oIHpayfkPzqy9B29HHvzX3UdNgcayy7O6Cc9EBmDmxQXkvdgSuwWdEs1KAd1RQ451c8NprYISbSIDMg+Wz4sWhBG7vvZQod7DVVRUkElmf7+BezEE7fXspAnDoVIpUFsXCH7sy7qjtTxbcHkvIiPza5RXHEVHRxKUSgkkvb246sYh53ngf8q8bh3DMNk5hyUxRXQthMne6ZTKfiK0Fwqdxq0dN5o6YMMXwDY+DypTdEzjkKx1dX86vB15SLnFsgToJIdMJNIkoflTWuRgIPIuRLsTSdUwabV1S0s7H/HAdE4kFjpdgNJVd+KX3O1R7A7WVHT6LepX9AguGp00eHh4gKIoZGVl4dq1a6AoCpcvX0aLXy5TvviWiSWGW4pBNLoZZ1ntMiMxn5EuNHaAlslQ8dHHENrZo/r7pWP3dh0WLa1b8hzj7vDRswajpRVdFXBNdsW8kHnkns4JfAUR0c+Dy7NFvd/fzbeiwrbcsu9CQCFFQ2kxru9cpUVwwla+iaadT+v/Ngz9r4U8ek2BUq5CIIdxMeAF6yeBuu4N7ToNudt/hLdjDLwdeQhadw1t/o5klx5ZDxaHbyTPbX7ofIRXhBPtKK2iUZ7VgnQ3V4CaBtkeG/g6PkCkTx5aa1nomFlG4HsSasjKiLxVP4GNjY0FRVE4ffq0wdNK+nqR+/A+QnezkyYAAE2r0Ntbgtq6CxDkrgKPb6+T3KamfYiS0r1obX04wmlB3NaKwK3ryLlSbly2eILlZOcclsQU0bUQ/gqdrrbugjqq+xL6+2uM72ABFPYOEN1Y7YAJg+I42G/FXymFtyMPN49lme2Y4wYWST4tJzwZfegce9AuGlLQ6/IjRJw4iDgJaDyQDLmh6JMFIJbIMcPpFqZzIuG3+0fDEST/t+Et8CYD/Nd3vzZofA8Afn5+oCgK8fHxyMrKAkVROHDgADofVDHXfDTD9EbfXMO0ycMOkBvO8O9TapI0EzsZktGblEQmHV03bhrcnxXUshjadRpKZ70EoZ09OpY/pTPCndqYirUxa7X0twtCF+B4EoWm03ORGv4suDxb1ATYmE9aw/L9buU8idtr39UiOKG/LELt9mfYfR/MRczNhFxeHVNsYR0X4nMrdb+bw6KnKtdHEbdlO4m+XlsfgD6X6STandGUgffD3ifP7sM7K9DYy+Rm0DSNypxWXHFnJvHlnA8BahqaDnxiuq+vEamVqqUaDftSIeIkoOO64RW8kJAQUBSFO3fujPibSqVEtSALEV5HRkoT1v6MhMtB6GjQeH3TNI2BgVrU119BfsFGItvTVaghv2ADmpruQirVv2rTWluNM2t/hsf3n+L4D5+jgM++wMpY8FfgHJbCFNG1EP4KnU6plCAhcT64PFsUFW0flzZIlCo8HcsM6g/aTIgKjkNEtzSDsQHy2xAL5VgcBcYbLJJ8aLkcpQvfYpLQvvqnOmr0CLqdNxJ9XbPTBSg9F1udHAQmVTG+uZxb6HTVE7Eb9vxvlN7A7ODZcAhywLvX30Vpp/6BNjg4GBRFISoqCl1dXWQJtSytiFy7Qkc5U4PoqAL2Ps60K9lwid2yPgkhujVDJn+ijX8yE48Fb0IpNkNxAYUUcp7Gr3fg6Kckwi1XynG34i6+ufuNFsH98MaHuFh0EX3yPnKMjPh3GPulsDnmk9YYeb+7dv0D935/HR7ff0JITtDKj1Cx9TnQriYQ3OE/K7iYGIKitRrn/7gNb0ceYrfs1B11HhI9le35B8I3HiUkN/LPQ5C72gCn5kEqFeNoxlFSge6VoLl47s5BJHWKQdM0qnJbySrVYKEHmZv6fUoPGOUF6JdaiWPVftTOiQbfH5VKhYMHD4KiKGRnazTV7fV1SDAkTcjNJtIEqbQFTU13USTkICl5kR45gqYqmSB3td5CDUNRW5CLU798x1RJ++kbVAusF/T4K3AOS2GK6FoIf5VOVycKJhqk/n4W1kkWwFtpQtjwBThVY4K/4DjYb4nbB8ig0Fxl2SpGFgPLJUZx1H1NEtrWx0C7Po72Xe6E6LXu8oTK1cbq5ICmaSzxiMV0TiS2Oe8w6fnHi+JJlvn80PlIa9RdbenGjRugKAo3btwAAJw+fZrJ/o6JQb0rU9K4L91wVFgnwjcxbTryPCDVvxzMVycNPckXQDZEpiCvr0fx7DkQ2tmjab95Cr6Io6IhtLNHscNM0DIZuqXdOJt/Fu9ee1eL4P4Y+SOiq6OhUClGHCNH8Au4PFuUlu03S5sA6H2/e5z/hodr5uHE9x8TonNu+bsQbn4BtO9CdnIHK02MTYb63czZ/rO6hG40el2e0x117qpF7/EluLL+HPkmJW7dDJUrs42wmo+v7nylmaDc+hpPR0fgSV4OigUtuH4wQyvJ7K5XDtrT+JpztVeY9dJUAwrUuzF6/s47hqVfzc3NZHJZX1ujV5oQ6rINeTFRkPT1Qi4Xo7X1AUpK3ZCa9qFOYhsbNwu5eashLN4FfuwrZDWztu4CK9mBMCkOJ5YxVfR8Vy9Hc6V1JWx/Fc5hCUwRXQvhr9LpVCopEpPeBJdni8LCLePShlUFVSNMzI1iHOy3aJomtdxzuSMdCCYFWE4Qapd+DqGdPWrefh4q16fQuus0IbkdzntAuz42LuQgsayNJKHlH/vU5Odf2FaIt6++zehLQ+YgsnJkvfr79++DoiiEhIRo/b+/vz/aggqNJtLoRXc94K7WscYd0btZSEMbbPgCzNZRvarN15eZgMx4GZISw2VI2aDl2DEI7eyR8vNXOJh2UMtuambQTGzib0JOS45BIpCfv978Wv9h73f/7scRt3Y2vJZ+pFmm/vE/yPvzX4xG2+1RRq87WpI7+PNfbL5rMBXqd1O25x84t5aJ6iZs2aJz8tZa20O+RT6OMcjfvw249B2UeddwVuCHOSFM8YdZwbNwMvskPCpq8WZoOvbuTtAiuLdP5KBhsCpZ7GHm+F6zzH5p3Q+qGT2/SxKUPYYTMjMyMkBRFNzdKJzQI01oE5WjvSMR5eVHkJHxlU5nBH6sPbJzlqO62gfd3QIolTJUVnqRv8cnvIbOTuN2kTRNI+PuDdKG85vWoLtlFBPd0YKmgaZ81F/d9pfgHJbAFNG1EP4qRBcARPWhpOZ2b5+JiTZmwLGqJtjwBXgvw8SBexzst6L884nNzqQEC8mHbPsTGj3oqhlocgohJLfbee3IpWH/xVZr/u/BmZjOicSX3kmjfv51PXX49NanhNCdLzivReTi4+NBURT8/JgCB6WlpSTC1MyvgIiTgAb3lNF5BUc5Me07+E9ixj8chyobYcMX4FMdTiQqqRTl73/AJKYtXz7mBJio9f/FKqeXMStwJrkfr196HftT96NWzO79KRJywOXZIr9gw5jaMgJdtZCdeBXJfzjg1A8fEqLhvewDZG6YAfmeYf34zCLDk1+jv0cYsjxejgxD3s3MbSsZmZTjffS5PKs1gas6uR1nNsYyzgp/xqFa7XZS11mBFWEfkef4UdBc5CQdR11+Mw5TSVoE95ZHNupLOrXPf+4D5hwRm816WcpeGer3MCshXQYKrgxKEw7v3MoQ3a2bhkgTDqE48zIqK08iK3uZzgQyHv8lZGR+g4qKY+joSIZSqXluCkUPcnN/J9tmZHwFicR4WWGVSgnehTNaUeR+sZUSb1tLAP5B4PRrADUN9Vv+v78M5zA3poiuhTBIdM+77EAeNwo97Va0nDIzVCoZkpLftsxgxQIRLV2w4QvwbFwuFKaSByvbb+VymWSRwJ2J41LGdMxgkeTT8vX/QWhnj7JF76OBc0tNcmPRt/ubcV3ure8awPNOTDT3ZrY62WSUz79T0onl95YTUrA/dT+Uan3fYALa8ePHAQAymQx79+4FRVHITcoy6gFqEL2tTPEIahoQo7sy4fqiGtjwBVhTWK3z7z2xsWQi0h0eYXITlColHtY8xPLIH7XkCe9cewcBeQHolpo2kJeW7QOXZ4scwS8mt0Uf5DIpMiNuwWfVMkIyTv7wIZL/cIDU5TH9/dDQ5McUCcPQ/1rLkWHIuynbY4Oza+8yxR62bCT/nrt9Gbwducw3iJOE1roe0DSNMIE/Xg/UPEvq1HOo2PWWlkWYtyMP3vtSICruGPntknQDg2V/heFju45hia5dx7yYaK5r8ggPal2uCW67OKAoV/gfXovUmO3Izv4FsXEzdcoR0tI+RmmpO1rbuFAodMuBentLkZzyLtlHKHTSIsH6IJdJcdfjgMam7tg+yGUWnvS0VwDxRwGfBSP6Zb3rS1NEVw/+0kS3uLgY//nPf/C///u/sLGxwY4dOyCTGfep/J//+Z8RPzs7O5POPUh093z2HnkRgrevR0JoIETCAov66VkCDQ3XNaU8e8e+JGoKyvs1yTfl/ZYx2zYXmqvEZNAQtxtPXphwMBLRpfdMQ9mcl1C68EuIdnKZAYrzAAMuS/QTAytpdI9EFWM6JxLz3B9CIh/7+yVRSPAn709CDv7k/QmJQgKhUMhElNzdCSEIDAwERVG4ffs2GvanQcRJQE+8yMgZ9IC7l7lv+58EekdWBPwyuww2fAHcK/RHnOoc1zKTkbcWQdnLjnD3y/txSXgJH934SIvgfnL0FYSlBECmHF0hlMpKT3B5tsjM/GZU+w+FUqFAHjeKZLV7fP8pPJd9jti1s9G/+3HDBHWwH+qa/AguA14GioYYI77WcGQY9m6mb10Nb0cezqyNRJ/LM4jfspV8e67uT0dvpxRtA21YH7OOPMvF52bgHrUYtzac1CK4Ts5xmH85A8kBS3WTdmG4+lofY0jvaDEs0VXp+jxEHOY7It6/C+iqZVwTcrMRefIovJZ/TQp6nPr9fVw6+gGuXF2CqKgZOoltcvI7EBbvQlNz+P/P3ndGt1GtXfOue/+8a71fuMC9mHoN4UI6pEBoIQW4AZJAIEB6D8GppEfu47jG3XHcu+M4bnHsuBdJ7r3IvZe4994lzezvx9gjy5JsuSawvNeaBZFHM2dmjs7Z85zn2RvDI1MHl5pbwhATu5pRVair95QrQDHY14sHGjeYPhjtZCNVg3dO0PkESDCnVyQm9j3j94AwFlCbhvra2kWiKwN/WaLb2dmJV199FZs3b0ZERAScnZ3x/PPP4/z581N+97nnnsPly5eRkpLCbDk5OdM6//iI7p0jP0skyt89vhdB5reRHxON/q7OqQ/4lEGSfCQl09XTuXlnFvTcApLCv2NzoMDlIbila0HPPV0IBSRsL9DLhqXpC5inNVeYIke399TLKPvqKGpvcOklepVQjGh++HQJAIAhvhDrtKOgyAqBYXjxnB1XSAqhm6LLEIVDoYeQV57HpCoMjbocJSQkgCAImJiYoN2rmC7Ic86f2UkHOwH9UfmrMJbEnzckF0CBy4NLveyJfKSmBsVr3kfRsuVoNjSa9HTN/c0wzzTHpw8+FSO4Jz1+hPc3K1C8YcOstHmf1DgyuqMzBUWSKEqMhdMfvzFjqOn+7xFlfxe9zQ1zk48/22jvfL/QTfhtDmm8CvszwbBS4uDeufsiZQWDcIwMCcB+wsYXXl8wz5NltB1+F83FCK7vBTs81v0dCpxsvMLJQp/Oq9LvVfBl+rxO22fefil1E52qyvQ4wgpGO+stxJ9bB7ujo2oJx7fDWW0TfG03ICr8fanENj5hI/ILLqOhwReDg/K/WFKUEOXlhuOO8wm6u+VzxetuaYbLZSWmH6YF+s396l1PA5BsDTh8KdnPDJcCwVeA6gRgHLn+K6VLzjX+skRXX18f//d//4eODlGem729Pf72t7+hoWHy3JvnnnsO5ubmszr/+E4n4PPxJI+HGHdHsR/I+M1D+RISfTzQUFo8f2+Gs0Rjoz8zMPT0znASnw7GLXF9FRYMBS4Pxinsp65lORX8jTNhpcRBnNc03dyeBUxSxEdpLkHNwfPM0nyTcQYE1RVP3YYYAPyz6qDICsHbyiGo75rbSDpFUXDJdxHlNvp9i2s610AQBDO+NDY2MuT3SUwRU1hDzVRmLs6Ivofa/wS6RRO4gKTklttrvXOHTmFYtRrDFZJV8iUdJVCJV2EKk1a7rca6e+ugnqiOss4yNN26RRccHjs+s2sYRX29F9icpUhM3DTt71IUhYrMNLhfPy8aL/ftQsgdI3Q2jRvH5yofX1q011YOtYaFSNGR8tuMu3xVjLjGq2ihp78NaglqzDPdefd7OF62ENvPZAOqPwAAIABJREFU57wDqlnbQGkugbnzOShwedgUHCidtFMUYL6G/jzm9szbP4GoCzTeRR2LfmGOO6sC8yPfwpH1BbzubEDIQ+kmDdHsVfD22Qwvr9Po6yudEcHk8zuRnX2UOWZG5q8YHpZcOZGG5qoK2P5+GCZ7d8LswA8ojOdO+/wy0ddCy7Y5fwvGQGZsu60IPL4AVHABoaSyCbBIdCfDX5bofvHFF/jpp5/EPuvq6sL//M//wNXVddLvzjXRnYiu5iZkRwTD34AYtzQj2qxOHUCopTGKEmIw2PvsyFSRpADJKV+DzVmKnNzT83uyCUtc570MocDl4ZSP+TPhUjQZkh+VM8uHf0pIIQ0U8SLab7AYktugxxXl0z1lG2IA2G2VCEVWCE67Z8zbOUIqQxhSuMF5Ay7qXURtLa2uQZIkjIyMQBAEErnxzH0aqpjhCsRwHy0zRiwBHl9kPq4fGmHSeIr6Jif05OAgyrZtG7VoPgGKokBRFOLr4nEq8pRY9PZzr89xJ+sO2gZFUeKqn3+hdZJNTGZ2DaNoag4Cm7MUsXFrp/W92oJceKpfExsbHxneQusTGQVL89UPn4L5jEyM+222qq2Dyxk/hrwGXbVGRnkotvttp/Wg7+6ArsY9MYLrfd4RVayvxApGj/ta0qo2XobSSXt7hegaa2dghjKG0dQLUnMJqq/9GznXDFFiZI00h9MI8l6FaLYkseVGL0V21iFUV9uipycXzs6OIAgCoaGhM2pCb28BU2/C5ixFSSkBkpQvJac6Nxt3jv4Ck707YXnsFzzJ5c2oDWLobwcyXAC3XZIvU/pvAI/OAGVRgJA/5aEWia5s/GWJ7r/+9S+oqalJfP7aa6+BxZJcDhyP5557Di+99BL+9re/4YUXXsChQ4fQ1DS9ZWh5Ox1/ZBhV2RnguNjB8eIpCdJruu97eKpfQ8pDLzRXls/e3nOWaGp6zAwS3T3TS+eQG1IiF5ZOSuJRB+N3gaGn8BIgh2NYVW4b40k/MiT97fuZxzjSQNp+jTY9N4a8VZ+0hrD/2cmVzq3rYiTFEsrmt+gzrTENn3h+gtVuq/GBywfwTPFk/jamr3vv3j00mdJFad0R1TM/WdJdUV7kqG5palcfQ3R7BFOv/PRERjKFaVGut7A7YLd4/q3/DngVe2GAL+5eR46MoGj1GtreOTJy5tcAoK2Ny2hxyxOBa6oog5+uutg46KOljIbSGUi2zQWegvnMpBAMozooEHZnIxgjhztnInHU6BLWuK3BVqtvcVNZvMjM67wLKln/BSXFDnt9WAQUuDzYOZySTtrTHOjPDN4UWyqfLtrMNiNWfSV8jDcg2HMt2NHvShBbDvttZDx6ExUur6DT7CWQWqLoskAggLa2NgiCQJ7tyWkrXzQ2BYAbs4KRFmtsfCh32wti2TA78ANM9u6ErdIRtFRXzvg+YLALyPYA7v0kKvAb23RfBfxOAsUhAH96Y+wi0ZWNvyzR/fvf/w5jY2OJz1etWoXTpyePRh47dgx+fn6Ii4uDpaUl/vWvf+G9997DwIBsK9Oenh7U19czW0ZGxrQ7HUVR6GioR2ZIIPx01WF+cLcE8bU5fQjh1uYoSU7AUP8MqrpnCYoSMoLbPN7sljRlQkqeaNSd7VDg8vAaJwNDWv+kPzf6z8JGduVwDAOAwb4RZoKpK5YuEfVngbCfjxZrHkNyK3/VQpOBbI3Xp4FrvjlQZIVgm0nMgihdlHaWYqPzRlqH1O19+JXSE3FOTg4IgoCOjg7aAkppdzirWUR9+IO0JTCxBPCnx6yHTR1Q4PLwbnyuXIfoGOxA4q+03Fj8R8uxwWEVVrutxtGwo2DXsBkliYkYzM1lCDK/sXHm1wCgqyuDITJCoewxtL2uRqyKnU7puozq3Ml1eucdT8F8ZtLmcOtgfYbDqLvEZqRji812bLH+BteUxVMUHtxKRfmjQKkEF8QStOm+ybw4JZttkk7aHxygP/c5Mq12UhSJ9tYMpERfQ6jvp4iMeEdqOkJyoCJK3V9F252XINCe0M5xbakrymDSg7qIN2WOvxNBknyUlN5izpeYuAk9PfLJP1IUhdRHPkx/dLlyBj2t8qU5iGG4F8j1ATz30elI469RR4G+twUBwMjM7dIXia5sLBJdOZCcnIznnnsOTk5OMvchCEKqWsNsOt3I0CDKM1IR5XAX9mePS0Z7938Pb4KFtEA/tNZUL9hk0NwSxgwaXd3zYHEoJYJSq/8uMyAXGK0T/W2h/OenaUBxXzMFVkocZIQ+HTe5uYCgfRBNxhkMyS3fSVvMDofbPD0t0Qno7B/Bu2phUGSFwDVx4e61oY0hPnP4jImM3s2+i56eHmYiLuRk0/dNOR7kwNTLjjKR7jTax54HWopw50kzFLg8bEubvOCuursa2sna+NDjQ/zXdBXyVtCk9cHlXchrnXqS77h/n7YT3rRp1uNKb18xM15Iy4XsbmlGuLUZTPd9L0YoylKTng2JvqdgPiMNJEkh3ruUIbGeOimwTbPHl7bf4aqKmRjB9SRSUJbRTGs5T9J+jsXXtMseJwt92gqSpF3IB/Repz/LdJ20fRRFob+/ErW195CScADRkdKVETiPlyHD7SQKzUzQdWuXfCkhgmEkG/5MF3wSV0HJ+QyGR9qQmbWfOXdW9iGMjLTLeb+FiHa0Yvqkl+ZNDPbJdiyUwEg/kO8PeB8CdF4Wb6/2P+kXiDw/Ok1pDrBIdGXjL0t0Z5O6IA2vvfYazp49K/PvcxHRnQwURaGtphppgX7w0VJmllHEXGHOHkOkvSXK0pMxMjjzN8Op20IiNW3H6MBxeO5PICUnjiKWYGlUEhS4PDy03rPwkZRpRnXYboV03pzlHORxPQWM1PaiQSeF8Z6vvWBAFyZtWzllRHshYRtbAUVWCFZohKNnaBaEUk4MC4QI5NXjpoElVLVU8YXjDobsHnl8GSxdOk/3urEbapXpF4TB/FmkUwhGRIVA3odwo6QWClweDudKLp1SFIX0pnRc4FzAGjeRwcPG+xsRdPUXxsp3pLp6ytM23GShaNly1J6RPebJi8HBOoZo9PeL2t3f1Qm2sw1jm2qydycczp9AQSz72SvIfQrmM+MxMiRAiHUuQ2TdraPwu9dFXFExEdfBVeIg0qkA5ES98fHtH7dJFKJNJIxPkkT7S7nGoaFGNDY+REHhNcTFfSyV2IYHv4eIh98gN/k2Bqw/QKuKOV3MquwJSnMqVYvn6Yhuri98iAMgCAK+xH65ourd3TzG1ZPNWYqycn2QUiyqpYE/PIQAI22mXwaZ6kMghzQp+EO0FJvvcVoecHzbbr1IBwZ4D2Yn0SYDi0RXNv6yRPeLL77Anj17xD7r7u6WqxhNGl577TWcO3dO7v3HOp2OdzxGZlp5PQmGB/pRmpqICFsLpgp0/GZ2YDd8tVWREfwI7fW1cx4ZaW2NZAaQzs7UOT22rJy4HYH3ocDlQdftmtSlrXnFNPP0ChMaYKXEgcPluJk5ZD1FDBZ3oF49kVYOIJLQn1aBohUraQOC46/IvvaFiq6PQkhS+Pw2B4qsEKg+mn8nurrOAWw1joEiKwRH1e+AIAgcVDfHsjuHRaTS+juoaqniosZthI5WlNd5z1LujPeAuc/707KhwOVBuVSkxMAn+QitDMW+4H1i+bdf+X4F13xX9I70guzvR9kXm+nCtNOnpxwPKnbsRNGy5WizsZld2wHw+V0itZaeXAz19SHe0xUWh/eIpWRlRwRDwJ//l5UZYzbFbnLk9stCf9cwvHXTYKXEwV0lNgwdnHBNzQx3laJFxFc9EQFm2bBS4sD5RgIEI1JeFMba77aLsZoWFaIZSSftHJ3RzzcAoBULmlvCUFyijuSUr6QS24iw/+Ch0wd4ZPMjMqOcMdgrioIO55UyK0QD6jvkCx6k2ILy+AUmBK10kkJsmXL8rW/wZtzRuDGr0Nwsv3HKQE+3mEEF19V+8toYwQhQGkGnF41Fv8e3yf0HINNNptPhXGGR6MrGX5bo6uvr4//9v/+Hri5R1bOjo6Nc8mITkZiYSGviOjvL/Z2xTvf6OTd8ZRqL1Er5lktmAook0VxVgRR/bzxQvy62BDi2OV44CbazDSqz08Efnn0hEUVRSEv/HmzOUmRm7Z9bIi0jenrVU4eOZvlZSy5tzTemWXnd0dDPTELtM3HIekroS2tEnQo9ETXqp4Lf1I/Wu1b0Mvaad0GqyxfRXgiwi5qZIrSSpmksKc4AwwIhthrHMM5re9WsQRAETqmbQZEVhHdNLogUDOw/x03tm9BihaKOFY901TgMy1E4JhOkkLH5/CIyCgpcHqxqWtA70gu3Ajf81++/YgT316BfEVIZAj4pThq7Q0KYvNtejmxZJGFvL4qWr0DRsuXoS0icebvHmk/yRfmRj/Vx9/hekZ74ib1IDfAFf+jZKW6cc8iZ2y8NbXW9cFOm7XlNzj/GLU1nMYJrz+KgKKkRpJBET/sgbM5yYaXEQQ6ndvI2jZLe9VGxdCFagJFU0k7Z0+Ne14NtSEv7HmyOZJ5tVMQ7eOS2Bvf0PoGL8k+I9XRGe53k+SmKQotdDp27fpsD6t7PwK1/Tj2m3lmHLquvmbSgeuJdmfuS9ptRVKwqMpBI3jotg6Ou5iY4XzrN9M+MIH/pc5tQAJSzgcBzgMG/J7TjecBlB5DuSDsdLhAWia5s/GWJ7phhxJYtWxAZGQkXFxf84x//kDCM+PLLL/Hll18y/7a3t8epU6fg7e0NLpcLc3NzvPTSS1i+fDkGB+XX5xzrdG+cd2Mm4+u+Oejsn5m70HQw2NeL4sRYhN01EbPIHNssDv0Ef31NZIcHoatp5oUmomrqpejomP2EyGAsp2zCIGbvcBIKXB4+DA17NiO6xPPAPdr9iSIpOF6Jg5USBwXxz/7AQ1EUuiOrmWhLs3kmBN3DoIRClG3ZShsP/PCm3BHthcAR5zSadNolz/u5Ann1zO9YkRWCH1TtQRAEzmsYMp/957YaVrnSKQMbnTZiL2HO3M+z1slYqRmOt5VDsFQlFJ8ZcOCVViM/AS54BIpYgrej6fSdk0nu+NjzYzGCezb6HMwSQnHMJRW7LBNw3CUNgbx65hwUReHJ4SMoWrYc5V99DVIGuexPSWEIsbBr9gYtAj4fbPYysDlL4XhzMz0GHdmDBK97T6WgdkExi/ze6rw22P8RCyslDgz/8IflOIJrdjUIadxSCIXikUaOexFj/yvkT76S2DYiEBWiddHPgSRH0NmZhspKc2Qn72ZyYXm+b4i0bKPfQeD9VbhvtBG2l7bB4sgPCDa/jSpe5qSOn0OlnczvYXCsSDfFRq4AQp7ZHrrQk1CFkJB+L4f0X0B6uMgKmJdzAny+/CkCTRVlsDl9iHbbO7gbxYmx4juQQqAqDgi6JJL+G785/RdIsQV6Zle8OVMsEl3Z+MsSXQAoKirCV199hf/93//Fyy+/jOvXr0tYAG/ZsgVbtmxh/s1ms/HZZ5/hxRdfxN///ne89tprOH36NFpbp/dmNtbpItMLseNOPDMZrtOOgl9m3YIVWZCkEI3lJUjyvY/7KpelmlU4X/odXDcHVOdmT2vpkKIopGfsGRXd/mVur6mrhpYQGzeQxJlvYwZmqYUT8wl5c3SN32UiNEGWObBS4oDtVjj/7ZsFKCGJDl/RkmKrQy7IUVm03pgYhvQMX5nCYnWhousAqtr6md9USO7sJpaxvNvjLmlSCSIAHHdJY6K5iqwQbFd1AUEQuKapJ0aA39ExxPsuH9DyY87rEaDlTBNdVqTYfmPbJ/ps1HXKkU9Pkkh2EPX/ZQ9ombANHhuglayF5JpCJq1irJ1j/91qHMOcY6i0FEUrV6Fo2XK0WllJPVWbgwNNhrfPwgULACkUIp8bBftzxxEeTEtJuWpuBsfV7k/hBjknmKFiQ15MHayUOLijFCkWwTX8wx8eD4MhkGFx3dUywCgy5MdNTng47T14hZOJTzgPUVpli2zeMXBjVjFEMc+bXoYntZYgyv8DPDD7EPbXtsDs4Hcw2bsTnqpXkRMViiE5LKYpikLzXbpAs8WaJ5or5EwJCzU8CYIg4EKckrpPp+mLiA9/i2l7RaUpKEr+VZSq7AzGwfTu8b2oLRhVNSFJ4EkyEHpdYj6ix7utQJIl0DVFBH0BsEh0ZeMvTXSfJsSc0YQkHOMrsUIjnJng9tkno7xl4aMZ/V2dKIhlI9j8Nu6e2CtBeu8c+RkBRtrIiQpDT9vUMirt7fHM4NLeHje3jR3qoSXERgeVFt23mIk+y+Tjhc0LZaLM0mV6pEVoMkKrYKXEgYfG/EccZwpyWIBWpzyG5HZ4FYu5edWePUcXof13/TOlJaodXAhFVgg26kWDL5x5Dvz4vNvJCOIuywQxgrpZ5R4IgoCq5i0J8vqltg7WO68f1dpdiwe6FnBmcaQSXUVWCLYYcWVGdkmKBLeGi2Phx7DMcyfT/z/z+gY2PBt0DHVIpFVM3N5ihWC5ejh23InHcZc0JF1WpQvT3v8AfU9qJEh+2pHfULRsOeqvXpvRPaVIEiXJCXAe5wIZ+ojOlywrkk6u/7KYZm4/SVJMVPauEpshuLcv+uO6tR6edE5d9BblUkDn7aokSUR8aWWEctTW3YN/ynEEcqRb68bFbkKd+XsAsQS1N99gnqOt0hHEebpKTU2YDIMFbdJNVORMCbPTuQKCIBBNiOf1UsQS1Nq/DE7022BzliImdg1aW6en+5zHjYTpfjrdz+7MUdqQpC4TCFcBTFdItsfmcyDeBOiYhZbuPGCR6MrGItGdJ0jrdA1dgzjtnsFMQO+qhsE0qhRDMt7O5xukUIj64kIkeLnD/eZFqdFe16tnEevhjNqCXAgFkhWrFEUhI/NXsDlLkZ7+49xHqsdVC1Na/8CKyBgocHnwtN2/oBazTFukvdXLiNDUlXQyE9Vg7/ynrEwXwp4RNFtkMRNQd3iVWOEcv7lZVIRmpTajyNR8YGBEgNVEBBRZIbCILpvxcaYiiG8rh2CbcQyGBUKJiO5G5QdMzuBS1mOx772v7IerOlfxsSOdWrDGdQ1uG2rKJLqKrBAE8sQnp0HBIHxKfLDr0S4mNeFdn2NQ4PLwOjsdA/ZbaWtWSKZVTLa9rRyCFVf9kLJ2Iy03tn2fBMmPXfsJipYtR6WN47TuJ0VRqOJl4h7rD7ExJMjMAEmJ34LNWYrqausZP68/JaaR29/Z2A83lSQxgmt44REOGp6HE89FpubxRHQ29cNqNKpbmNiAoaEGNDT4oaDgKhISPpVKbBMSP0N2xlnEBlyF49X9MNm7A72qdP5s4oW1cqUmyAJFUmgyow1UWh0nFI3K8SIwTPwTWoQGCIJAifbHo58/D+GtJSh48LpIjzdxK/r7Ja2uZbaLopDk68n0U7dLJ9EboCxSORm/WW2k7Y/bZj7ezDcWia5sLBLdecJknS6yoAmf6rOZyWercQwSy+fX0Uke9Ha0IY8TiccmerA89osE6bU89isem+ohjxuJvg5RcV1HRxIz2LS1cea+YeOqnX8M8YMClweN5Jino93qsUe+qO79XzEyJID1aHFIVc7CFSXIA37LABoN0hit175kyQLNVmtrFC1bjpKNH4Ps73kmtEQB4EFaDZ0TqxqKlt6ZFzHJSxADefUS+76v7McQ3ZUs/wnfCcZ1TV2wbrGw0e4rhqh+ZHoGiqwgqec44Upbq7YNtsEy2xKbvDaJ5d+eijgFVn4KFLg8fBwaTN/z4hAAkmkV8mwnD2gxKSl7jpswn6+99ID5/NQ1J7lziOuLC+GleVNsvHior4nmynIAQGbWAbA5S1Fe/myZjcw75CByfRpLEa1hIyYRZnQhAAcMzuPnR7+gpEP+YioAGBlpR6SnLfwcjiMiWDqxjY1bD7OYwzgaqQN7fxs80Lgu9uxcDm8TEc3ypFndgoHsFuZleqR2QtGoHKkdVcRK5rfWT9CqL4PGryIt9D3menJzfodAIH9BKikUItLujsh577evMaQ+waXszjpadaL52Uo9I0kSg4OD6OzsRENDAyorK1FQUICwsLBFoisDi0R3njDV21X/sAA6wYViE9Rlbx7a+p6O8P5ECAV81OTnItbDGa5Xz0qN9t67+QcSvO6hvrgQmZn0RJaW9v285h8rl9ZBgcvDr7zyeTvHpJim+oKPXjqslDhIfvSU2isFw1XdqNdKpuXD1BMxWCCpCEIJhSjbto0uQtPXpz98ylqiAB2F+cY8DoqsEFx4kD2rYx13ScNbUxDEt5VpEjox+vseK4CZfNcr+0h874DaXVqVQcMAR+7uZwjrMssDUFQOkNh/u5UPNBI1sO7eOmbfte5roRyvjKJ22vpWs7weClwe9oT50/fc+lOAJCXSKuTZ3roZBL9Pv6Wtgddvwn+uB0KRFYK9Rw1RtGw58pevxHvXHklEmieipboS/gaE2LjwQOMG6grzxfbLyf0dbM5SFJdozOqZ/ekwCZHrV1dE3JWrsFGKZAiu8flAHNS/gHXO62GaYYoR4dQrQQJBH9rauCgt00Vq2k6pxJYbswo83nE8qXFAd3cecjLTcVJNFQYHfxR7drZKRxB33wX94Xp0Ow3fpvNUZwhKSKLRKB11rHi0uRVIafwUxXrEEsQRtOKCJXERIJagw/wlxEWM5eO+g+pqa1CU/G3k1+fD/7pIkjP4t48g0BgNXpivBqI0gcYcZsVkPjBGVjs6OtDQ0ICKigoUFBQgIyMDCQkJiIqKQlBQEHx8fODu7g47OztYWFjAwMAAWlpazNgzfrty5coi0ZWBRaI7T5B3GSG/vhs/3BVNVO9rRcIrrUZS8Pspo6e1BTlRoXhkeAsWR/ZIkF5n1g5mUK198mje2uFW3wYFLg9rEvOn3nk+MM2cuzgv2snI33geHORmgIG8VtSpJaCOFY8G7WQM1/RI3a8vLk5UhFY+jqTPRkt0DpBe3cH8VtKrZ6dLuXNckehk28478QDofN5to/m8S5WDoalJTzCfqdzHf1RCxVIAtqrSObzqmlqwZ4XjhvkZhsAut9kFRRVfKLKCsfSWOZZb7RGL3n7q+SlMM03R1N8k1t6T+VVQ4PLwR0aWWKrITCK6iqwQfKlkj/xltIzY9Z+uQpEVAvXvL6Bo2XIEb/ySIfnS0NFQj2Dz22JjgPvNi6jMTpf6oltQcBVszlIUFFyd1TP700EKketX/zfir1yGrVI4Q3BNz4XgkN4fWOu8Htv9tiO9Sfp9BwCSHEZnZwoqKk2RkfEzONx3Jd3HuMsQFbwLXncuwdfUDQLBMDob65HgdU/CZdPs4G4Emd9GVXaGKDXB42e6vX4nZ3X5fWmNzKrRSGO/9J2kvUCPWzW7TxwBQRAIIH7BE0cFsNl0Pm5sxFtoz9SVryEdVUC8KQYsNsHj6Gbm2mPPfADKeDmdj1uXMS1yS5IkBgYG0NHRgfr6elRUVCA/Px8ZGRmIj49HVFQUHj9+DB8fH7i5ucHOzg7m5uYwMDCQSlRns+nq6kJTU3OR6MrAItGdJ0wnX0ZIUnBPrsYqzQhmEvrZJgmlzfOrDTpTCEZGUJ2TBa6rvZjmYIA7Le0S7LsC91UvI8nXE03lpZOLbU8TqV19TEFOB18+l5s5xTSrqEvTm2ClxIHthRgI58E4ZDroTahH3ahbV6NhOvhtsuXyas+fR9Gy5ag+eGgBWzg1LjzIhiIrBN9axM965eA7C/mI7nejRBcQKTSccE2HqpYuCIKA82Mueof4zOe7LBNwyikRmqOT0CUVL9Sy4qBnpMKQ2ZWOn2KF/TYxgvvNw2/gUeiBfr50QvBNRikUuDwYVTUCnnuZSPrjrCfTJrljm+G3J1G0bDmyV67Bhj/uw+OLH1C0bDlMtx+DIisEuywTxNrQ09aKSLs7TPHOmGpLSXL8pL/z4hINsDlLkZP7+6ye2Z8So0RuQP1NJFy9BDulMIbg3jkTgWM617B2tHhRLUENfSOjRcqjJhPU/Z/R4/oJqgM2ITt+O7gx0qx130Fa+g8oKzdAe3schMIBtDzpwd3fw2Bx3AIuVy5JBCeuXlDCYXsnSVtbwTCgM6pqk31/xpdN8Uk06qeijhWP9gdTmKZMfIE2XAoQz4MklsCAYIEgCDy2/ZK53tTH/8bg7RcnL37trqMVEey3AsQSdKq8DMdDX45e/w5kGZ8EWZWEgb4+tLe3o76+HuXl5cjPz0d6ejri4+MRGRmJx48fw9vbG25ubrC1tYW5uTn09fXnnKzq6enB1NQUNjY2cHFxgZeXFwICAhAREYHY2FikpaUhNzcXZWVlqK2tRVtbG/r6+iAYrZ1ZzNGVjUWiO0+YSadr7hnCuftZzCT0jkoobocXY1Cay80zhM7GemSFPUaA5VlmIHJU/oIZUK1/O4gwK1MUJ8WJpGhm6BTUxZfUflxQTFMXs7djiJnUmqrm3vZxyrbm+oLy+AVdegYijVzLLAj7ZC+J8ptbGAmq7sDABWzw5GjpGcI7o5HTB2mzT5P4ziJu2kR3PO7epdMTkpKk5zDa2tFau8fUbJh7/5X5b1jlulqM4K513IWQynAIprAnXZWQTxdiNrYDjblMn+NnuE1aVDfZtuqKL1LWrEfRsuWw/XIf0lavQ9Gy5fh9n4ZYRLezvR2OxmYw2ieyHrf47TCyo8PlKlAqLzccNZc5MOW+fzUM9o4gya8EdudFRWY2ZyJxSdUQ65w2YLXbamx6sAnsJ2wAdHpOX2Msaj1WIsfndcRGviU1HSE55b8oKSHQ0hIBPl+kZECRJJ7k8hBqaQzT/dJTE5Q4tB7zucInkg2ujBWNZ7PQhO1NqKf7vUr8pC/VUjGaItZKvMUQwcdB68DmLEW+12sQ3hKliAmFQvT396O9vR11pTkoD7JAnuV+pBObEEd8hUhiJ7zU9kP/2gVoX78CbdYNGBkYzBtZNTMzg42NDVxdXeHl5YXAwEBEREQgLi4OaWlpyMvLQ1lZGepn+8yzAAAgAElEQVTq6tDW1ob+/n4IZ1DkNxGLRFc2FonuPGE2nY5b3MJYmyqyQrDJkIOYkqmlvp4FZGUfo0XFwz+Ew/njElEE033f44HKH0i9/gVaWK+CIibkek7hFAQAa5MKoMDlwaX+KRXwTSNXlaIouLJoZyNe9AIrRNxZB0rzJbSr6jFEq03FBKT5x5O7Mdna0kVoH22UaSrwNGARXQZFVghWExEYGJl9NF9uomshXTbPxYXW0o2KipL6dw6HA4IgcFlTF8mqwahjxeO2MQur3VaLyK7LOgSWTF3AOSgkmRe8+I7RCJzvMbrPma1CXWsnk1YxXcKrtE+dSVMZ27aecYAiKwT+KeUIc3PB7XGESXv/z9h9Vh9LbwSKSbBNhupqazqHP/37Kff9q2Coj4/kRxWwuxjDEFyHs6Ewv+mAz2y3iow+Is+hoTMXDQ2+yC+4jPiEjdKVEUIVUej5GhqtX8aQzVqJoEBnU8NoasKxCePuDzA7dAVJvhHMS8n60THUrlbKvBKlOZoD/smMr50cFqJBO4WWLPQrnXL/MbLa1taGuro6lNkfRx6xEZ56+0AQBLS01GFjcxAuBkfgSpyEDXEWZsQV6N1Sn3Oyqq+vDzMzM9ja2sLV1RXe3t4IDAxEZGQk4uLikJ6ejry8PJSXl6Ourg7t7e1zRlZng0WiKxuLRHeeMNtONzgihEFYMRPBUmSF4LxnFlp6nh3iIQ09PbnMwNzYFIj2ulpkBPnDV1sFZgd2SxBfu4NfI+L0BpRdeRvD6i/IVb2/P6cCClwebpY8RZHuaeSqhtvnw0qJg3D7PIm/zVvb7qwDSbyBFmVRNLFTVQWU5j8mvccUSaJ825coWrYcTbp6C9NeOcAXktioFw1FVgi0g+emCnomqQvj4e3tDYIgECgj6h3Ni2Ymz7v62qhjxSOCcMMy89/xkdkdfHJ/M1N0FlAeMGlbKwaGGKJbOTD63FpLRS9YqfZiaRU778RjuXo43pJVjDa6YvS2cgjevhmEwI+/Zkhu9orVWHbdH6euGuLuiX3Mb1Vv30/4+fdb+M+NR8xxxkuwTYbaOvdRS9ZtUz+YPzmG+vlICaxgXM2slDiwPxMM7tVLOGFwGKvdVuOTe6twwnsVQhN+QmLSFulathFvIc/7ddTZvYwBg38wLmXj06OGBwaQx4mEl+YNibH1/tHN4P2xDP7nDWGlxIHPJXdQnU+kOqKJwfZz+vgRqtO6bqFQiL6+PrS1taE4MAPJKo8Qo+aHlNhExMbGIiIiAgEBAfDy8oKLiwtsbGxgamoKPT29uSertzRgbqQPM6Pb0L5+BTpXLsLw5lU8fvgQ8fHxSE9PR35+PsrLy1FfX4/29nYMDAw8dbI6U1BCISrj4xeJrgwsEt15wly9XRU39WCPTRIzsazWjMC95GoIn7FitfEYq7BOTvkK5Ljl2JHBAZT5miDy9/WwO/i1xMBstvc7+Bz/HOkXVqCN4yAzB5MYrT7fnfXsahqORw67lrblvJmwMI54ub4QaL6DJuX7DMntUfsNlKb0POLx6ItPYAjPUOnUkZiFQkhuI/MbqGqTUdQyTcw2dSE4OBgEQcDT05P5TEgKEVkdiYOhB7HGdQ1UtVRBEASUza4wy7hjrnONfY34IeAHJrJnm2PL9I+Jbm27HqQz5GRovAnAozP0szR+FxgRj6yOL56baIaxzTgGGdUdzN+/+d2Gee5hH38G3UMiMxmDfbtx4LQa3rv+UOY9mkqdobHRnyZv8R/N5FH9KTA8wEdqUCUcLo0juGdDkXLtLKK1P8IJjw+hEfge7oW/I5XYxsSuAS/nJGoCvkCv8UuSxHZ0ozSX4Ml1RYRe/QEWh8ULg20PfYvYsx+gTfkVZv8GlU+Y9lTrHQSnpR0KXB5e4fLQN+EFRdDVwHyvNdkLpaWlyM3NRWpqKmJjYxEeHo6AgAA8ePAALi4usLa2hqmpKXR1deeYrGpCR0cZWlq0fq45cQk+xAE8JvYgitiBeOIrZBCfI5/4EBXEatRrr0bH/d8wwHsEcngAFEUh0fueqFDyxgUxScw/MyiKAr+xET0RkWgxNsaTI0dRsm49Ypa+s0h0ZWCR6M4T5nIZgSQpeKbWYA0hKlb7wSoRBQ0LnPMpJ3p7C0RR3caH4n8cVS2gNJeglfUKUs+vhNexTTDdu0OC+NqfO45oRytUZKaCP24J3auRHqiXxectmJXybNBc1cNMND3TzVWbAUYcz6CBFTBKcrnoV/9Rei6xlEKOugt01X31/mcrl3KvXTIUWSE44pw2Z8fcIafqwg4ZRJfL5YIgCDg6OmKAP4D7RffxzcNvxPJvL5tdBkEQeHDfkykEHCwUTbjdw904Fn6M2Z9IIvCkvUfCre3Nu1wocHl4LTJLPFWgsxq49RL9TBMtJNo4Psq7yzIBJ1zTxeyNmb+7pCJhw0coWrYcuStWwPKnb2B24AeoXCew6rqkfNr4bTJ1hjG0tkaOylytmP6DesYxPChAekgVHC7HMb9zu4sx4Nh4IN/hPwgIeheRbEliy4l+G5n+b6IqRQld3ZkgyVH7dRkShp0qLyPx7BrYH/xKbJw0P7gbQWYGqPQ3A6m5BALiBfQSr6CVeAs1xDKUEh/A+aoxjK/cg/UNI+i72GO/jRPOWdvD2dkZ1tbWMDExga6uLh4SdJGjgHgBOoTa7MiqJgEDAwNYWFjAzs4O7u7u8PHxQVBQEKKiopCQkICMjAwUFBSgoqICDQ0NqKvPQlz8dkSz30F4xHLmWJXEKin35HnaOTP0BjAgUmARCgQItzZj7o+vjhqGB+Sw2X5GIezpQX9SEtps7VB79hxKN22SSDUqWrZ8kehOgkWiO0+Yj3yZ1t5h/OGVzUwwS1VCoRtSiP7h2ecrzjVy8+jCtKSkraIBHJA5iA+pv4iSK0sRfvpD2Bz4rwTpNT+4G3666sgKDURSWQUT3Woa5stuxDMCoZCE3QU6T680rWnqL8wCQ6WdqFeOpjVyWREYUt8i9X6P1/odA79FVITW9WjypfSFRElTL9Pn2UXNc3bc4y5pMpf2xy/xyyJxqampuKl9EwftDuLTB5+KEVylKCUkNSQhLS0NBEFP+E13aRe6rsfi7k3DwmFci73GfHed/V68rSJuQvGaYxwUuDy8GpAmmSoQfIV+nrcVadvsaYCiKJSlJ8P16llY7vkWuStpJ7z0H3ahq7lJbo3eieoMEzHeVEZsPPgTY2RIgIzQajheERFcm/PReGRjjqjwDyWIbRR7KTiB/0G56ytoN3+JLqiS9sJ5/xfwiZfQS7yKevV3wL36KRzP7IbBb0egr3QCeud+g+7FMzC5cQG2FuZwdHCAlZUVTLRVoUOozoqc5hC081gFsRoEQUBLSwu3b9+GhYUF7O3t4e7uDl9fXwQFBSE6OhoJCQnIzMxEQUEBKisrUVdRgyKNaFSwOOgKm55FbktLOGJi14Ab9TbyfP6NXOuf6DYQGhgmXpI+hk2o7RgZHICfrjozb4TdNYFQ8Ofpb+TICAbz8tDhcR8NN2+i4tvvpJLaomXLUbR6Dap++RVNt7TRFRCAyqSkRaIrA4tEd54wn4nh8WWt2GLEZSaZzww4iC6cOwIwF+jrKwGbQy/RNTT4iP4ghw4tRfwDTVZ7kPzwATzVrsJk3y4J4qv22xEc0NZBYHw8+CPPhsnGZHhkkgUrJQ7iHkzP5Wg66M9sRp3KqEYuKwAjGh/Ivs9SJtg2Wzu6CO3Dj0AOzn/kWV6oPsqDIisEn9/mzGnKznSc0SaiuKMYZ4POYo3rGhFBvbcO6onqKOsUpdR0dHQwJKLIj3aiazLNkDgeSZEwSjdijrXC9lu8perFtOFVj0Sa6D5IkmxTTyOg8zL9XGMM5L7+J3k83Fe9Iva7ivj0I2YiHcjMlEujV56I7vjc/fEKAX9GjAwJkBleDccroiIz63Ph8DRlISL0A+Y6I6PehWvQamh6fQhNy31I0doMHvExUogt4BLbEUb8AH/iV3jqn4eTkxOsrKxgbGwMnVvSDQFmumkRGriteRN66trQUTGBpoYFDlk5wNDLF9HR0UhMTERmZiYKCwogMHgbIJZgIPo2hoaGQE5TGrIrqIJ+ydZMAjkgH8GkKCHKS/WR4/s6mqz+BYE2PT9EE9+BIAjYEmcnnS/GxrM+kw9x7+YFpi/HP3B7plf8KJLEcGUVugMD0aStg6pf96J49RqZxLbim29Rf+MGOjzuYzA3F+SIuHLOYjGabCwS3XnCfHe6Ib4QJpEl+I+qqFjt93sZaOx+dghKXv5FsDlLkZj0BUhy9Ec5TR1aABjo6UZRPBchd4xgdXK/BOm1OLwHj25rgRcRgu6WZ4vwjyH5UQWslDjw1p27pfcxUBSFHk4Nk4/bpMeFQPOdad1jiiRR/uVXdBGats6ct3Gm6BniY4VGOBRZIbCNld/HXh5MdDuTRuDGR09JikRcXRxORZwSi96ud14Pi0wLtA1KVwGxsLAAQRCI9g9nnpGwW/rL2Xcuulg1Sp5XOmzGWxquNNF9mEqnLjjHSyeWEar0M9V7XWwZVxoaSovhq60i7mZ24Tckr/0AJR9tROXu3ShathyVu39EYFbNjF8GxqO/v5IhgIODdZPu+6yAoiiMjIygp6cHzc3NKCxIhZ+TO8yvu8PoijsMrznj9g1bmOiow9xMCaamZ2FodA23dJWhoTXHagCaGtDXZOGO5h9wIJRwT/cs/Hy8ERwcDDabjcTERGRZ/4ZCYgOqiJVoJN5BF/E6hoh/Mrm+1cpbGWL+kXe6ZCFaU75obGiW4mI2BQTdw4wZTQ9bDoUZIR+Cokdod1oNvrakrboLcRIEQSCE2D3lWNaurACHQ18xyj68iJBpt3++IWhtRS+HgxZzc9ScOImSjzbKJLWln29C7dlzaLO1RV9iIoTdU6cpLhJd2VgkuvOEhep05S29+HU0f1GRFYKVGuFwTqh6JorV+vvLweb8B2zOUtTVjxbsTFOHdiJIUoiG0iLctLTE9fOnJUivyd6dcLlyBjH3nFCTn/PMLFtV5bbRkZ8zHIwMzV2qCSWk0OlfxhCoFtsckD39077HfQmJoiK0kmenCM01sQqKrBC8pxaGzv6p7VCni6kKtuo6BzAsHMbD0odihWOr3VbjG99vcNjkMNS01NA9yUQ0VrTm6OiIevVE1LHi0Z8p/YVsl2UC3tE1wCqXtTTZddqIt7Ws8UpIBhS4PLxuHSM9VaC/DdB7jX6+UdJtdltrqhFgpCP2W/FUvYqa/Bw0qtMSYzWnfsNAZibTF1rueUzrZUAWhodbGKLb2zeFecAcgqIoDA8Po7u7G01NTaiurkZRURGys7ORlJQEDoeDkJAQPHz4EB4eHnB0dISlpSWMjIygrX1rTsnqLUIdhsQNWBIX4UD8Dg/iKHw09sPd9BYsNVWhf+YkDE4fhcGpQ7h9fD+clXYj6dI6dGm8SpPViRKGE7XIbT6ffKVMcwmcLt2HlRIH1zTjJArRkGgBprBxBpHQsXGoQTsZpKx0OqEAqOACjy+AMnhDso3O24FHZyAk/sGkYeQSGye9rvobb8DqwHY66LF/J8rTU2bQU+YWZH8/+tPS0O7oiLqLf6Bs6zaZpLZ43Xo8OXwEzUZG6AmPAL+hYUaR6EWiKxuLRHeesJCdjqIo+GbUYu2tSGYC2mkZj9y6p79EOGb9mZD4GYTCUWI1DR1aWTCobIQCl4fvYzKQHxONIDMD3D2+V4L03jn6CwKNdZDLDkdv+wLq7k6YhAZdDzPRlNri2VnXjoEcEaLNtYAhue33i0DxR5cap3mP6y7+QReh7d03J22bC1AUhW0mNLG75pszb+eRVbDV3NcGmxwbbPbeLEZwj4YdBaeGg+6ebobENDbKFtYvLi6ml5C1tFDnSOfpdnhLT2EZSxVYqmWFVc4f0Zq7LmvxZrAjFLg8vGHClp0qwNGhn6+OAtArygXvampEqKWxWAqQ27VzKM9IZSbUyt0/omjZcrTeuQMAaLh5k9FSrqmsn/JlYOK9HFOLOO6ShkBePQaGexmi29UlmboxGcbIaldXF5qamlBVVYWioiJkZWUhKSkJbDYbISEh8PPzg4eHBxwcHGBpaQlDQ0PcujW3ZJXQ1IKO1i2YmOjCzs4SHh4eeODzACr2Kthrvhc/3fkJP1rswU3V24jySUKTyRZ0E29gmBCpKFCaS1Bz/U2Enf4IFvu/E1dN+P0wYj2c0Vb7ZHIJw1GdbLHfNSEZFZ34gmtheUdkYFM54eXM/Qd6v0dK03o+ACBoG2TSpnrjJ0TsSRKoTqBzyY0kV5q6TV5Cd8RpoHt0rrz/C+qJ95h73klIEuKxrezK27DY9y1M9u6E1YHtaDBaePk6is/HUGEhOr280aCqispd36NoxUrpxHblKlT++BMaNTTR5eeHodJSUHMkabZIdGVjkejOE55Gp+voH8E13xyxaAvxuAC9Q08vqjkwUMV4sdfWuon+MA0dWml41NwJBS4Pb8XmghydrIUCAeoK8xHn6Qq36+elRnvdr59HvKcr6ory5XJ0mhGkTUJa/8D9c+6wUuIg/SFv1qcQ9o2g+W42Q3K7gitBTYziy3mPBa2tKFq1mi5Ce+g/67bNFRLK2pi+nFe3cAojVd1VuJV8Cxs8NjDk9gP3D3A99jry2/KZ/YRCITMZl5eXyzze0NAQQ7gy/ejn1aCbKjVqMz5v+G0NF6x02ESTXbc1UHxshDd1I2WnCgx2AQZv0v0t9AZ6O9oQ7WgFswMiNzOni7+hKCEGJCnq++TgIFOE2MvhAqALE0vWb0DRsuVoVFefUr0BoKPjE9Uixv671YiDiMjlCAldg6KiIFRVVaGwsBBZWVlITEwEm81GcHAw/Pz8cO/ePTg4OODOnTvzQla1tbVhbGyMu3ctYWdnBgcHbTg4XIS9/T44O/8IN7fv4WB2ARbXXWB2wR8W54NgeT4UoY6x6GoRt8uNr4vHVh+R+cMO870wuRKIiqxRI4ZxL5xdqq8g8dwa2B+aoJpw4HsEXfoelbrbQN77eWqHyKlWxcav3Ex4wT2emQ+Nm7T8WZDluJfHkQFA+1/0fsFXp+1Y2eFVTPdrvVRQfCEdEa5NA8JYgMkyibb1GL+AMrdXkB79EXp6csUPZrcZKcRmEAQBY+K6TJm17IvLYDKq1uN46Et0qLw6uSXwHICiKIzU1qI7JATN+gaoPnAQxR+slRmtLf/qa9RfuYJ2V1cMZGXNa+3DItGVjUWiO094mp0uuaKdiYQpskKwUS8a4fmNTy0xv7DwBticpYhP+BhC4dwYXhT1DTLKC08GpQ/CPW2tyI0OR4CRDu4c+VmC9N49vhdB5reRHxON/q7OOWnXZJMQ+7IqPcFcs5ab0EsDv20QjYbpNMlVjkdv/Oz6WJu9Ax292/AhyAWW4ZEVARwWCPGbewYUWSHYbZU47+2gKArpTem4wL4gFr392PNjGKYboqGvQer3DAwM6OXV3Fypfx+Ds7MzCIJAgJc/83LCb5bUA56YN/yW2gOscBRJlr1nfgFbjTmyUwXiTQBiCUjiBTgfE0UL7ZSOICcqDEKB5JLyQFYWMzELWluZz9tdXOnPl6/AYG4uKIrC0NAQOjs70djYiMrKShQWFiIzMxOx8fE4oeuM/epWOKp+B7+pm+KchhGuaOiDpakDDc05jKoSBHR0dGBsbAwrKys4OTnB09MT/v7+CAsLA5fLRUpKCng8HkpKSvDkyRO0tLSgu7sD7e3pqKq6i8ysA+Bwl4upIkRHvQs/+5NwuBooKjI7ywHHvUhCFnCAPwDtZG2RjbPzepzT0IbT9Tgxq++RwQHkRYfC69pJifHH4/oZZCt/jkG1FyVJ6WQOkfLWOdhuknjBXZ9UgK3uacz1tTwZVekoj56cJE/SHn5TPyOd1xeeCkSqAWaScmCk1Ueo9/oQSSGKYHOWIivrIEZGpGjb3v8FvsR+EAQBb+KgxHEozSWIO/u+6D4e3Yx+tVFVBina4LOBoLMTfXFxaL1rhZrTp1H68Sey82o//gQ1p0+j1fIu+mJjIeiYm5U7ebFIdGVjkejOE552pxsWCHGHXYZ31cIYwnvSNV0uu865xuBgDTjc98DmLEVNjfOcHHOEJPF6DE10I9qmjvYJ+Hw8yeMhxt0RLpeVpEZ7PZQvIdHHAw2lxWIRr2lhkkmo8MYe2gb0TBCo3JkNyMM1PWjQTqbJkloCBnJbp/7SJKBIEuVf/5cuQrt1a1bHmi4miwBuus1h/t8/a/6Kl/gkH6GVodgbvFeM4H7t9zXcCtzQO9I76fctLS1BEASSk5Mn3S82NhYEQcDMzAz1t5LoJd5E6WPDxLzhN8xD8Z73AaZtF6KvYUQoma88MjiAVB9XDKj/EyCWIO/Su7A6uR/pQf6MMglJkhgcHERnZycaGhpQWVmJVCsrBH+3AwFHjiA6OhpBQUHw9fWFu5sbLK9fh/HVq9BXU4OW1tyqAejo6MDExARWVlZwdnaGp6cnHj16hLCwMMTExCAlJQU5OTkoKSlBTU0NWlpa0NvbCz5f3mp+Er29RaipcQYv5xRiYt+XatSQnLwDHD97uNxkiwjuGQ7YboXobpUcL3Nac7DDfwfzPL66uwu6l7zgqZWKnrZBUCSJmvwchN01gcURcUMHm9OH6NSEqrKZ1yrIoVwjVVVlzBGNkw0njSRYKXEQajP6ghZ2Y+rjSWsPRaHNgbb6bVR9BErzRfHvWW4AuProrQpEQuJnzD0vK9MTMxMSQ64vTIkrIAgCScRWseMJNZ9H6G8fMffz4YlPMaIxudujvCCHhjCQlYV2V1fUX7nKjItS82rf/wDV+w+gWV8f3cEhGKmtfeoKD0+bczzLWCS684SxTnfQPBQOcZXIrunEiGB6Ui1zgaq2fhx0TGHI7nL1cNjFVoAvXNi2FBWrMM5IQuHckO0vUouhwOXBonr6SgtdzU3IjgiGvwEBi0M/SZBeq1MHEGppjKKEGAz2TkObdJJJqENtJTORttv/Pu02Dxa0M8VM9VrJGK6a/XJ+f1KSqAiteOGKhKZSPBjb1mlHYYg/9ykmvSO9cM13xdd+X4sR3L3BexFaGQq+nFqvTk5OIAgCbDZ70v3q6uoYglfuSsuMtbnJrmwfnyqw4UEqFDgZWPPwPN1O19U4FXIKNc01aGhoQGlJCYLuucLkjzPQO3sKTtcOIoj4CT7EAbjaW8POzg4WFhYwMDCYc7Kqq6sLExMTqOga44yGMU6om+OQuiV+UbPBD6r2+EbVGdtU3PC5yn3Ye+5AUPBaFBXbQSCQQXJmAYqiMDBQjbp6T+TlX0BcvKSWLa0CswVFRcpoqH+M3NhSuKsmiRHcaJdCdDVLjlF8kg/LbEu87/4+VrutxvuuH+CENguWSlEINM9GS3UNEn08YH/uuKShg6k+KrPSRelSM1CfYSBDi1xis98i9jVOew/jiJab3MBcc1tdH2C6fHrtaS0BuPoYMf2RWaFgjGks3geitYCmPICi0NDgw0TPuTEr0dT0WPKaxtU0dFt/zfSvWuI95tzD6i/A9/hnzH0NP70BQuIFjKVlyFPbwfQVoRBDpaXoevgQjZoEKn/6iUnfkdiWr0Dlrl1oUFFFp5c3hgoLQcn5srWQWCS6srFIdOcJY53u9XNuzKS9TD0M++yTYRJZgtjS1gXLnaUoCgHZ9digE8W05RvzOGTVzNFyvRwYHKwHh7sMbM5SPHliNyfHPF1QDQUuD2cKqmd1HP7IMKqyM8BxsYPjxVMSpNd03/fwVL+GlIdeaK4sBzWZtuQkkxCl+Twcz9DLogV6V6bVxr6UBmZ5sNEgDfyWuXlZqLt0GUXLlqPq171zcjx5Ia+G7Sm3yfVZp4uGvgYYphviY8+PxQjuBfYFpDelTzsq4+XlBYIg8PixlMl7HEiSxO3bt0EQBOJ9olHDikOpGhen7TjYaxaKM9YhcA2JQ0pqGuLj4xEVFYXHjx/Dx8cH6jb2OGdsBhVDY2jpakGT0JzbyKq6Om7fuAFLHR24uLjgwYMHCAgIQHh4OGJjYxFx8ybCtn8D7s5deFJYiNbWVvT19YmRVXmMJez8vwSbsxRhSdpTqjTIi+HhZjQ2BaCw6CYSEzdJJbbxCRuRX3AJDQ0+GBysBSkkUZzciHtqIoJrdYaDSKcCdDZJt5eu7KrEr0G/Mv1lq9N2EFfdcPf3cPjqusFL84aUFaLLyI4Ilv6iPMOo7Gy+a17dBAUuD5tSi0AKSXioJ8NKiQOuDVc+kks8TxNK60+Zz1pVzGlJQ1UfUBFqQH0Wo9hAksMoLlZjnkNS0lbpihsTahryiQ9BEAS0CTUIiBcA4nn0qv4T7ke2Mvc2UXUnKLstctV2yLLMlRWtLduyFXUX/0C7oyP6U9Mg7Jsby/H5xiLRlY1FojtPGOt0J6wi8Ik+W6Y0z3cW8dAMzEdQTgOauucmf1UWugZGoOyfK3J9Ug6B6qM8dA8uDOEuLtEcjepugEDQN/UXpoDp6MC9NW3uIpEURaGjoR6ZIYHw01WH+cHdEhOYzelDCLc2R0lyAob6J1zHFJNQ8B+GsFLigK1hI197SArd4VVM1KTZIgvCnrmR2RK0tYmK0PzmNrdtKshjRKDICsEBB1oqaLJcXnmQ35aP67HX8YH7BwxZ2eCxAbeSb6Gqu2pG10CSJPz9/UEQBFxcXFBeXo78/Hykp6cjPj4ekZGRePz4Mby9veHm5sbk82ppzbESAEGA0FCHnvYtWFlawsXFBV42txFA/IwIYhdiQ32RlpaG3NxclJWVoba2Fm1tbejr68NIezszwfenpEq9Tn5jI4rXrps0vUWe52nuswNszlLcdDmJrRPUGuQFn9+NltYIlJQQSE7ZLpXYxsS+j5zc31Fb64q+vlLm5YUkKZSkNsFDI1mM4EY45qOjQTqZISkS94vuixUmHjX7A6a/OcDs8HWYHfxJYmyIueeEtprqyS9khmfT9eQAACAASURBVFFZADOOBh/Pq4ICl4dzhU8AAEVJdFSXfVlVTqIrvg3r72TGpYHcFrFzDQ83Iz3jZ+aZ8HjHpRuFSKlpCCO+B0EQcCJ+A4jn0ab+FuyPfDcadNiF3MjgSW+tvJa5Y+Y4NSdOoMXMHL1sNvjNLZMe+1nGItGVjUWiO0+Y2OnquwYRyKuHWkAevjGPw1syJoXPb3Nw2ZuH+6lPUNrcC3Ie9HAzqjuw3SyOOecGnWg8zpmZdt90MDTUCG4MvYRVVW016+OFtnbRkksxOeDPk27wyNAgyjNSEeVwF/Znj0tGe/d/D2+ChbRAP7TWVIPK8Zl0csi4dhJWShx43Iya8tyUgGSqmetY8Wh1ypOtTzkDtDs60oP9+g0g+xc2ajEda9lJq/knIUwkRYJTw8HRsKNi0dvN3pthk2ODjqEOCIVC9Pf3o729HXV1dSgvL0deXh7S09MRFxeHyMhIBAYGwtvbG66urrC1tYWZmRn09fXnnKyqaN7CNU09XLtlBGcXF3h5eSEwMBAn3R7gO1dvGIZHI/pxAGxZl3Ht0m58bvsp1juvx4cu6xGdP0EgX8gHLEad8bwOynwOffEJzPKssE/2y+dYwWLRipUYKiyU+Ls8EXoDzz1gc5aCcD8ot/6uUDiI9vZ4lJffRlr6D4zb4viNG7MCWdmHUV1tg+6eHAzxh8VfipxT8cC3CB6a4wiuEgfh9nlor5d9zU39TTgVKTIH2XJ/C1hXL8Jk/wGxMcDswG48NtVDRWaa1GI/qZhNRHeGWuTrkwqgwOXBrrZl9N6ScFdNQunNHdMguM8DZitBReugxZpWfWm2zBabO7q6MhCfsJF5PhUVJqAoGc9ZCmm3J5RAEAQiiZ2ou/EG7u4f1cg9sgcVmeKGO+TICAZzc2dkmTtcWTX56tyfDItEVzYWie48YapO1z3AB7e4BYbhxfjVNlmsaGz89r5WJE66psMmpgIZ1R1ztuTHF5KwianAMnXReQ87peJJ+/wSnpLSW2BzliI2bi0EgskLfaZC5cAwo7xQ2j+/0XCAjva21T5B+uOH8NFSFpNtYqrbzxxF5MWtKLu6FCPqL0gM4nUqm5iJdrBXdmSWHBKg1TGPIbkdvqWg5jCvmiJJlG/fTstHEcScHVdeyBMBfIsVgmPOaVMaFnxpxEFndw/a2tpQV1eHgpIC2EfY47jDcfxs8TMOmB7AUeOjuGR2CUbWRrC2sYaZmRn09PTmnKzq6+vDzMwMtra2cHV1hbe3Nx4FBMDawx+XTd2Y/QxVXZGlHAw/5RC8xwrAW6xgsesaLx/2n7hcKHB5uH73rrhqiMkf2OT5OV31f28tQionkN0cb1Hfq8+U+hxara1pe9EdOyd9XuTICCq2f0NrLe8/IPFSLE/Otab7QbA5S3Hbc4/U6wQAkuSjqysDlVWWyMzaz6Q7jd843HeRkfEzKipM0NGZLNLnxoQCR1YItl8Jx62z0WIEN8w2D211ssceiqIQUhmCTz0/ZUjuL2ZfQ+/gdxNSEy4hOzxoejn8Y5hNji4wbZ1sphCNyxNzRMuPrcWgxusAsQQjGv+Sm+wOqW9lxqbBkg7mvtXW3WMKj2Ni30dLa8Tk92EC4R8hXsQtgnaVY9/YAvN99D23PrwTDaXF07bMbfj/7H33W1PZ+v1/4Mz9zNzr3Jl7R8UCKvY26qijzoxj79h7QQELoCSEkEPvvfeOgkov0hIEQRQpKhIVBESaIL2XkPX94cBJQhJIEGbm+vV9nvP4SE5O2Wdn73Xevd61dHSkWuZ+bvEF6EqPL0B3kkLeTtc7wEPeuya4P3iLcwG5WGiQLHGymK2XiAPu2bC4/wqcV/VoldFPXFq8b+rCSd8n1PHn6CXChVM6aYVzvb0N4KTPQxpbAWXljp90LB6fj2kPnmEqpxAx9X++OUZvVyfePM5CkrsD3C8eFwO9dipbcefMWjzVmItG3X+Dz5qCfodVcL1MTrhlhRIUEwZ6MZBzDx+ISGoiaQ1OBL9/YoF8Z06OoAhNQoZuMqN3gAdmVNEIUBsLRVoUZtGiMY0Wj5m0GGygB0LfKwo7GV7Yr+eGo3rOOM20h6q+Da7oW0CbZQoGa+JpAGZmZrC3t4e7uzsCAgIQFhaGmJgYJCcnIzMzE7m5uSgqKkJpaSnS09Op7/Ak6DKPzEZf1SfpC9f0vFBFy0QFLQNKEsD7sCFESWkJBVCuX70MG5XtCDOgofo1FwDwvv09dkTuoACZzwsfAQgd5AEuQ65SQXskPov3ly6Dq6iEGhp9zOfWkZlJ9ZmP9yLEqCR+WeX4xZojFejq+J5FGlsBDuHbhO7zMdrbX+JdpTcKn51B+gNliXSEx0+24U2JCT5+ZEt9QabANi0ev2kmghgBcK9rpGCPCWfUZEFrbyu007UE9BbvhVC/+otQ9lYFyZ4eaBiLmjBWfKJDJHUMGbXIhQvRKEe0zkYMJhvIkc0lNz5rCj7QfUknRv0A8Pt7wOP1oLj4hkDJIudXdHbKYNk9gsJRQcylfodWQ4kEz4O/onjLUrxevmJCLXM/t/gCdKXHF6A7SfGpnW5wkI+SD+0IfVwJzbBC/GzJlpz1opOFZXpRLxBdWI3qFvkFqfl8PuKe12C5SSp13F9tH+BJ+eToAJaUmFJv/BJ5W3LEb7mvMZVTCMty6c5Uf0bwBwfxofwtciLCcIt5A7aHdooBX+8TW5B2cycCrnvC+WISsiNKRQ/SUol+m22opQ1rraajg6lCTgKj6WqOI6o1NckitP0HRt1PHm7swMAAOjo60NDQgPfv3+PNmzd4/vw5Hj9+jAcPHuD+/fsICbsLdSMnCqzeYJlQYJXGMsIMWiym0eKhouc6bqDKIljQNdQFy5wFBxcHBAQEIDw8HDExMUhJSUFmZiaePn2KoqIivH37FtXV1WhqakJXVxcG5VzKLC0tpc7L4/HQO8DD3bz32OqQifms+5g+4vd6QM8NBEHgqr4lKmkZqKJl4hAtSex3rWIRhRhbU+hcPkcBXWdCFxXP8sWyqS09LTiecJwCZ8Y5xuANy+MVxwiARIWoHjGfz8ebtSR/sSkkRKb7fa+uDq6iEnIWr8RcrbtiVJINVhz4ZZVDmSV+T1e81JDGVoBv1DqccqbBInQf4pIlS35FJa3G/axrqKqJQV+fbI6GUQVV+FUzEawRAFdTPQUrtRPEssgj+/ZBd0es8hMUKf5uvRxGJ7bARmUn7I5dR4j+bXS1TaDg/wQ4RMoaw4Vof2Q+BmKuApYzxABsv/4/0W88XUBRkAJ0u5lbqJfwXv3V6C70wpPcndSze/5cVfbVuqGM7iDjK3Re/hZJl7eCIAgY6NLIMXPHZhTOF1VDmCjL3M8tvgBd6fEF6E5STEanq2vtQdzzGhAxL7HVIVPqMuFqszRcuVWAoEcV4Na2gScjf7Wtpx/60UUi/GGdu8/R3DmxSz59fR+pzM3btzafdCwN7jtM5RTibNH4CoomK7o72vEqJQKJ6hvhOuTDLrrtguu5K8hPjEVLXS0w0Iseq4OopiWS8mG0FHQzN8mX4ZExBpqawB1a8msODxf5rL+/H+3t7aivr8fTl2+wz/wuNuoGYKueL3YxPHFQzw3HmE5QN3KCm6c3XFxcYGNjA2Nj40/OpO7Tc6eyuXSWEczMzEE3tIC6viUuMG1xkumAw3ou2Kfnju0ML2wxsMCvtqexyX0Tfvb8Gau8V2Gx909Y7HgVh32TxlW0Jm/U1tZS1/+mqh4/W0h+IR3e1uiGUvsn0pJRRcuENU3wgqmsdQvnzmrBWoW06710UwtTOYX4nlOAgVFAeM9AD65xrlEg7Qr7CroHuskKeI91ZB/y3UJVxANkkdkweOh+8UKm++2oeIdn88i+Y7LtokQqyUbrdJz0FVBTFrFCcNiBBe/IDRJBLQlsl8A4WAXHnJhYSgTJxMEeDj6fj/JnDbDUTBcBuFrqKfhJCOAKZ8uHM+2zbkZiyxULbDXZLHDB812A8zfWw/H0OTicsoHzhXiwA7ngTcYqlzwOkSNsxWV1LUNPGzzjnZHsuAUDBuJ0KhBTUKP7EzxUE5Ee9JI8v/vPUrK5X6OOHkLWDOg6oMn+G2Skzh56jjNRXu4MPn/0dhKxzL10FGUrZ4KrpIgiJSVYXVEHQRAwvqaOoC2/4MVcJZStmola9eNouXdvQi1zP7f4AnSlxxegO0nxZ3S6tp5+PHjTAJvk1zjk+UiEbyu8KRNJOOX3BC6cUjwuaxxTl7TwfQv+cMikvr/EKAX38qom9K259K3VUFZ3Afr6xp85dqmsx1ROIdbkcCfs2iYkhJYmB1lTUKvzPbLVlBFycr1Es4qEK/qo1OGQNpq0WPTpL5OPsycU/f39aGtrQ319Pd69e4fXr1+jsLAQOTk54HA4iLS2ht/JU/BUVYWPlxdcXFxgbW09IWBVeDMwMICFhQUcHBzg6ekJGxcvCqzu1XPHdoY3fmX4Y71uEFbRb1HZ3N9sOOjpJ4t6xLm80ZhpZoi5HqL6t/O81mOWhS6m0SMofq+sRWufEq2trdT9brOIHbMgS4EWAyaL1LI10Q1FFS0T6bR0zNW+gxPnabBUEawEeKmfgUl6FqZyCrH8kWR6iXBWcrtTBjb5C8Du0YSjaO5pBkpSBP2nNJX6bltSMlWkIyt/MbqwGrq7r4KrqIQipXlYf9lb7B7n6YXDIc4TegEnERz7k0RgG5M0H1a39iA22wEHnEMxgx4nsb1GFq2JZGEdM3HNNhuezGwRgHtDPQWrtSWPhdNo8ZjPTMQ2uh/On9WE9sUtWOOyWFCo6LAcRzWuwlI1jDpe3v2Kvz5jKMVWXOpqT18nUBRBFiIajc29LadtgosqG27qHHQ095AgWsJ+nczdVDb3nfMapKXNoGouPjami122rJa5z+fNg++2TTDQY4AgCPhePICOy99ikDlxL/ife3wButLjC9CdpPgrOl3fwCAKKpvhlVGGC4FPscQoReJAP4uRgL2uWTBL4CKl+IPEjO0AbxDemWWYq3+f+t4RrxyUNXy6LBgA9Pc3I/3BAqSxFVBaajHu46QNcc/+zSlE959sgjFqjFJs8oE+G46nnWF3TAtOx/ci7oIhNXlwtaLhfewwIs6tQc61RShjKOIdMReviMUoJFbjkbMqOBwOEhISEBERgZCQEPj4+MDZ2RnW1tYwMjKaULCqzyJAYxnjur4Z1PStcJ5pi5NMRxzSc8FePQ943klAXl4eiouLUVZWhtraWjQ3N6Onp0eEBtA7wMNWh4wxgeA0WjwOeghcxqhqft07mG2ljXneq0UA7ly3bZhpYo5ptNFBpqxV/vLGwMAA1VardG/JdH8XmLYgCAJXmc7Uc7c/KqjkNzl6ELkJMRjo74dhaQ2mcgqxp6BE7NyS1SjiMMtSh2qf7ZHb8b6tEvD5nex/nhuorG69jQ1JXzkgWtk/Gl3ltN8TKN6MAnvJGnAVlXB77XbM0b2H7VZWuOF7Hr5R65GSJq6MkJCiCP9oUuc2PnkuFOix2Gidjnt572Vqs+jCasH96sRjo3YiGGqiFAWTG+n4+YZ0gLtA6xZULrLAOnoYVoe24ZjeWizwU6ZMOFaYncY6zWjYqA45pKlxUPJUfjOaCQ9Z+bw9rQA3FrhzGjD5TpSWYPAPpDr+jhILcWtekrbwLXwuRcJFlY2MsDcS5c/4rH+glh6OKlomysxsBfzppPno6iIlyyjLXCdnmS1zK0z04Xv0d1gd30f9luqIWZgMCsfnHF+ArvT4AnQnKf4OnY7P5+NtQwfCciuhfecZNlhJLxTZbPsA9IjnuJdXhcrGLiqDUd3SjXMBT6n9ZjMSYZfyZkLcqt6W2Q7JA81Hr4w8vJFR3dNHcRhftP/59sbSgh98AH3Et2glvscHYgYqhsBqAfETslkbYHfDGeY3POHPsoEP0wmu+nawYZqQGQ19/QkFq4aGhrC0tISTkxM87OzhfuEifE+fRnRQENLS0pCdnY38/HxwuVyUl5ejrq4O57weYDY9BtNokjNtwsvAY4UwIJNl2+H0kPru2+YKLHdXw3y/JRR4m++/AIpOhzHDwFXmYwoDpomOYfWGDbqBMl3DNoY3CIKAHpNAhQ4bVbRM3D1zEyaH9+K8lgUq6gQrHMOmKOpD2qfDMZbKwSxTUyj7L6bk1IqeBwtACzcWAPDu5CkxbdyxpNx+t8uAAj0ammrXKcCSaTFHDNgmp81G9uP9IEKu4TcLe8zWjcJ2a3IVJyVtJjZac1DV3CWT+sYM+pD6hhUHv2gnQlctRQTg0tRSsE47ESuMU8Xb4WYUtqjZ4PrJC9SLhP6Z37HBYamgP3luwAzCHduv34fjEMi1upQGDaecCe8r4wpZFRqM/yUOgAN3g5vhCcXkDHzHzkeH0VSp38+7cQYuqmy4a6Sj0+8ERvJ0O/RUUEXLxHvaA2RGr0PafQW8sPwRH03UUH3mIEp/kq6AIM0yt6GyAh6XTsJGZTvML54CQRAwNdDDYPDYRhBfQjT+Dpjj7xpfgO4kxd+109W39yDxRS0MY4ux0/khFHQTJE4uK0xSoRaSD7+schRVtyLxRS1WmQqMLzZapyP77fjA6XD0d9fjAYdUYCi5t1B2zplQ8Pl8Sn7pTt3EFs/x+Xz09vaitbUVdXV1qKioAJfLRUFBAbKzs8FmsxEfH4979+4hODgY3t7ecHJygpWVFQyJiQWrBEsfBnoMGOrqwMrIAG6O9gi7FYr4+Hiw2WxkZ2ejoKAAXC4XFRUVqKurQ2trK3p7e0WWXau1tMks3t59o967PDq3o4WsVr/D23QaCZ4L6wtxnXMdCwIWCACJ31LMsbuI6UzZAKUkwLTVMXPcphPSwsHBAQRBYAvDd+xr0ImBioZA1ox93RtVtEwk3LyDiEdvxK5la94bTOUUwqJMtNhSFt1aBUNHLA8ii6tWhKzAg4BfSdDisgr8gX68XrqMNAuJjBr1WU2nxWK9iRtU3TXhdGc7ElKUkJamgIJ9c0gKwypFsBMU4Be1Djd9z2OnjSUuBGRQxxy2Mr7g7UsB4a7eNrn62S8374M+AuDS1VKwTisR03QE+y03ScUMWhzWXPXEubNaMDskMHyxVtmGEzqbscBXYBoyx+4iptEicexqEnVcw8upWHgjYcy+/aeFLJq71PYV4LcNyPUGOkhVF8oRLS561O/26U+Ft1o8XFTZyHKLF/lskPkNqmhRqKJlouSaFZ79OgdcJUUpwFYRZStnomb3fDT7uUm1zK0seganUwdho7Idjif2I8TPFwRBIDAw8M9u4c8i/q6Y4+8QX4DuJMX/Sqfr7B1AVulH2Ke+wTHvxyJUBeFtPisJh70eYa9rlkixmmZ4IRo7xvHWPcQ5K/OdSmZ1U2ag12yoUEJOhYEdeaQEk9HbGrHPhsFqS0sL6urqUF5eDi6Xi/z8fGRnZyMtLQ3x8fG4e/cugoOD4eXlBScnJ1haWsLQcGKlq4wIPVgRN+DEugYXpgV8mE4IYroj0vkW2Ldc8IjYgALiJ7wiFqOCmIsalgK4NxXBvrQEfkL2l8JbkM5VPLwdhOpXxRgco0hjoLmZ0p1svh0m9rnwkrWkqnlJwHGsjK6sVr/kFgcFYzNsvXNAhJ6wMXwjPJ554fbTV9jqmCnH8aRf98hMpTz83ZFL+3RTexAEgd16ntIBvE4stqjZgHX0MKxVtlNcRNsbtqiiZeKlXqZEHujCrCJM5RQipKZR5O+yZkIP+Udi8x2y0GphwALcsfk3uVSd4kQBk963b0c8qzisMvTFaRcdWN7ai5gkyZJfd32Xo2jeXHAVlWC265zIufWji8ReKJpai6nv9vZ+kInOslY7ETojAC5DLRXrRwDcabR4LNK+BS2aBYyOixo6WKrsxJmLF7DE6Q8Bp9t7DRSM7KGgEw91jWTq2DfVUzDnpuyrFX9KyOqiZjsXaBNXn6Ec0W5bjf59g6/xxNQCLhfT4H/uDj6em4363T+g4ucZKN2pTmZzb6bj1dJ1opa5S2ajavM0NKp8j85L34LH+EqQUZbCr+VmPYDdkd2Um9yHslK4uLiAIAhwOJw/o1U/u/hfwRx/RXwBupMU/6udboA3iBdVrfB9WI7LIXlYJmE5cOQ2T/8+vDPLZHdxE+KcDRh9hQdJ05HGVsDroH9LHCD5fD56enrQ0tKC2tpalJeXo7i4GPn5+cjKyoJueCQOeAZAy9sfQUFB8PLygqOj4+SAVSMjWFtbw9nZGT4+PggJCUFERAQSEhLA4XDw6NEjFBYW4tV9H7wj5uIDMQNtxL/RR/wf+MQUDOjPRh39FsXNTLqajtaGLpl4eG1WK/DsfgwiLQ3hcGKfGOh1OXMIcQ6WKM5go6tNXEey0c+fkucZ6YIlaclalm0sKoBsVr8kPWKWBU0E4O6L2YeYtzHo5wmyQfJmiGUFvrLydyW101kmCXQP6bmIH18nDps0HME4dox6TlYqO3DjBgl0rzFtqb7Q3yAKtnsHBylaTnqTqCmBPBn3D50fsC9mH9WuTvb/xYDpLHCVFPF66TLwBwfR01MDo3ArGAer4G7CEsnANmEJjIIP4YijPhazgjGNFg/WTlJu7LnSfKxR88M0WjxmDq0SjXyh2O14lzpWWe3LUeksa7QTcVNdFODqqaViwwiAK4maMLzRT5zGzkvmUDIiMN93BXX/io7HME33DpRuxovQIFSvJGOG0LEng+YiVwwOAu8eAXaSebViNAVJLmoQckTzOifxuzzdKehU/RYfD3yPdyrb8GzBCL3a+YtQeT2B5OYeNUH5LzNQrzIH7c6a6NeRIdMsVEDL5/ORG3OPeka+1y6itb4O3d3d1BhbWlr6Z7XwZxX/q5jjz4gvQHeS4nPpdHw+H+8aO3Hn6Xvo3H2OjTbSJydFvURcDHqK8KfvUf6xUyRDNQxWm5ubUZsRiDJiPoqJpcgj1uCBz1KksRWQmjoTd033IYg4BU9CFY5WprCwsICBgcGEglVjY2NYW1vDxcUFPj4+CA0NRUREBBITE8HhcJCTk4PCwkK8fv0a7969Q319Pdra2tAvYflNakgArn36S1BDixkCNmzEXiEn2Td2umTWxn87YD1bMHEJ/zuiKGOgrw8Vz/LB8feE7zXxSd7m0A6EMDSRfScUdaVvMMjjUfaYtUymyKWOBzzKCg5HA2TT9UKhYGw+9P9ozPP5CcoBylBNVcWjmkdSK92rmruwcQgkjdSp/ZRtLGAjrZ2O6DmDIAicYjqIANx1V9xw87iobbTq6StYrBmMjbqBIAgCTJYBntNInm7HI9EViXIh57/SLlHDEFkzusNZyfa+dhE7W5rrDBRd/xG5bmuQ/WijFGUEZVje2ovTLjSsNPSFJL72HO0IPFhMFhwFr9uFaTrSOd3zmXeoYx9x9ZN4/au1E3FjBMBlqqViozDA1ZFMTbBR2Q6L4ypID/RG0QsulFgRUHQ8JqC++C7HTFNTTKPFY/GNBJgI6e2qXEsSAdA/W7DRO8CTS0d6QoLPB6qeAvd1yQytTHQFcUA5HCKOaN6HMKj/Nbo1vkGfFrl61qn6rVRe7Uul+Xi+WQncq5pD3Fw2eo3nA7HXgeB9gNl/5ALgg4M8sP08qGcVytSmXshLSkqo8bmnZ/JdLj/H+Fwwx2TEF6A7SfE5drrBwUF0d3ejrOoD7j18AaNbHBy1uovfGP7YzvDGXj13HNZzwUmmA84zbXGNsIaesSUMjU1BjAJWjYwYuH9/LtLYCggO/kM2sEowYENow4VQh73xdZxycsdhNx/ERIYjPT0dOTk5ePbsGV6/fo3KykrU19ejvb1dPrD6qSEkCN+tvwnVQ7qp1bT76LHYj8jrnnBRZeOB5g1RUGs1CwjYMbauplA011YjPzEG98xYsD+2Rzzbe+ogbv+6HmmrlqH5iahfvDz0gmFwslHG5X5JgGwGywuKjicwz28hZrBIeaqZJmZgPGSitFm2bE5ZQ4eIwcmnbp9Cw9in5w6CIKCqb4NptHj8dM0bmifPi7T/lVOXsPy6v+ClkBZF9WUP3buoomXiY6BAQqx3gAeL3HIKpJzwFwVYsj6zYfA+MNCB2voUqCcIXNT2356L+FQBsE1KnQuH8G246K6JdSbumD6GksXwduy4KQWOjpwwH6WNY6hz/WFpK/LZKu0EaI0AuPpqqdgkBHAXaN3CwYsE9I8eFqMmXDqtgQ1XXBCVV4neAR7WOLhjnvca6l6VXPZiul4oCWK1EmF9iSw6c1BNwxZNcbrWz5ZslDV0jFqYN2FydXw+UFMIpOgD9sriYNF5BWAxDVJNHKRQBPiDg3iQ/wLHzZ1gqnoVb/fuxqu5SuAqKYKnSx6rdvt/BZa5G1ajZsuP+HB4OkKOucP1QhLu2N/AO737qKJlopmhLXpOWQG45wb09/UixsaUembR1sbo7xUAWjabDYIg4OrqOjFt+v9hfI6YY6LiC9CdpPi7drphsNrU1ISamhq8ffsWL1++xNOnT/Hw4UOkpKQgNjYW4eHhCAwMhIeHBxwcHGBubj7xmVUWAzaEFlwJddz1/o3K6t4324J04jc8tj2KZ8+e4c2bN6isrERDXTXa7X/CAPGNyEDaYPIjBQieeh/8e1XqDvSiMzIOVbQHqKJlolYvEX3pdwHHxXikpQYXVTbC1L1lmrhkjf7eHpTl5yLVxw1e6mfEQK/toZ24pX8TjyPDUV9RhtO+j2XK5iqzknDGP1eujJYAkMVCwcgGSq67BeDDbTt1bONE2fmQ8mSg5clSDxcfScviCZsgCG/bGD4gCAJaTBOon1ITaWutE+ew+qqXxPNp6FuCIAjQ9TzJFyAiG3wen6JH/ODIIfv1/TwxgDWm6gI9Cifd3PGm1BZP8w6AzSGVEVLTFHA9QpF6BttCFiCXa4rmllxEF1SM70VBJw6hP+8EV1EJ6YtXY452pNR9E1IUkcZWwD5bMrO6UjsBmiMALnE5Fb9qkgB3NGqCzvFT1Vg8pAAAIABJREFU2HnJDIo37lIrDK09HTgfzxAqYFxM6isPgfZtmqLKCmtG0dtdbpIqtX0nRK7uQzHANhbo4wpvjkvIzz4MvfzI4KI20NCAdjYb9fb2qDxzRqplbsUaBeo8TWo/oSPYHLzGBiDkAPgGX+Ot/3e4ZacDF1U2OJoplIENj/WjfBnmoWvs9juAW/o3qeeW6uOGwUHRdgsICABBEIiNjR1/e/5/HIN9PJTnvflbYo6/Q3wBupMUkwl0BwcH0dXVhaamJlRXV+Pt27coKirC06dPkZmZiZSUFMTExCA8PBwBAQHw8PCAvb09zM3NJxSoEgQBExMT2NrawtXVFd4+vjB08MIxpjMO6LlhJ8MLKsZB2GUYgjW6IVhOD8NC+l0o0qIwgxaLGbRYbKc7g2BoIJ61GQ/uk+Lj3JDvJXPORpHZmZdEgoJg96MymSp8csjgUsTn89Ga8o7iYNbZ5WGgtZe6j4ohkXZX1RT06f9L/L4m4D74fD7qi4uQsGEt/LduhJ0Ea2LT44dw5qw2Nmk4YdZN6SBlPFXobb1d+MnZBPM8N4kaPHj+gunMAEyjkZJ1wwYRsoSs2cyfLdg445+LrQ4ZY1IcRjpmScrizWZIBkU7dEhbXwM9BtWmtOMnsf6K66hL+cOZYG19C6qPdJS3UAD2B68MTOUU4ruoJxIBVlVzF+XENp0Wiw2mrrjkfg2O4VspQCm6zcST3J3gPtKCm8UMLPSfD+UAZfx251e8bXmLsoYOil8r77busg9eKM0DV1EJeruuSN0vInER0tgKOG9hiWsSAO5vmomYdjMOq6964awEaoLR4f04dl4Xy64HiDybjdbpYJfnYWfUToHGsvsfmKHvNwTG43FUSFnB6HIqFt2Qfq+yUmLk5vF+LAHSLQCXleK/d3tlIIUF1D4TcbCjQshFbdB5HTpNtqLR+CqqNDRQ8stGqRSE/IWLkLrvIGWZy4tlkOdzWChy+H6vn1Fw9z9kdj9+MXzU7qNCh7SpbmWoyw9yiSlo1f0n/C4fpZ7f46g7YpQkHo8HExMTEASBwsJC+drz/6Pg8/gY+NiN7ldNaM+sRnNkCRq8nqPW9DGqaJnIVYv4AnSlxBegO0kxFtAdBquNjY2orq5GaWkpioqKkJubi8zMTCQnJyMmJgZhYWEICAiAu7s77O3tYWZmNuFg1dTUFLa2tnBzc4Ofnx9u376NqKgoJCUl4cGDB3jy5AmeP3+OkpISvK8ow8esYHQEHMKA+waJAI9b24Y9rlnUZKBMJMEprQT38t9DN/IFfjOTvCR6zlWb1NlMnYlwky0oddwJ/jOhY48is7MvwhdTOYXQC2ZKLcqYsJDBpYjPG0TTnTcUgGnwfI7B7gGR++jW/4GaeN/T14pndSfoPpoCAsgitMVL0N1Qj5LcR0j2dKL0K0cuA187eQF7VI2xRDOIAmryVqE39TTBrdAN68PWjzB42AkFYyuRZXFXjnzFJ/LyU2UFxvfy3svFVZ6vHYYzZ2/A7MxR8rfEYoF57Ci2XXPCNJ24MY+zSvcW9Rt8wkxFFS0Tj0OKqM+/DyJd0f59+5E4wCqoQnPra9zw14PVrT2ISZovkWcblrAGxVwm6uvvo7+/mXw2oaEoWTILbPOpWO43D8oBylh9azXWOoi7nMmzGW9XBVdRCc/mKuMnjQCJ+wSG7EaAkbUIwDW8nIrfNe9jgaZ0asLl0xr4RcMZM3RiqGMNv8hEFFTCucAViwOHHM78F2K29TVMo5H7KujEQ01IWUFHLQWKN8d/n5L62Og/hnIg0wZwWys+dtkokXzcqjzJ4BYjLHPpdJT9uh5cJcmgljtvPsr27EWtPgst9+5hV3gi/p2WD4/39YID+vxGnjvuOvWn9nYuspOVqH7zKvjfeHnDD1W0TJTrPEAPc4bcIPcD7Qe4H/sDNirbYXdkF4oz2BLvT9hGu7GxcfxWx59B8Pl88Nr70FvWis4ndWhJKMfHgJeos3mKKsZDaj6RtH0ButLjC9CdpBgGur6+vggLC4O/vz/c3d1hZ2c3aWDVzs4Obm5u8Pf3x+3btxEdHY2kpCRkZGTgyZMnePHiBUpKSlBVVYWPHz+is7MTPHl8w+WwoRwc5CPk8TsoEwKZqj2uWeDWtgEDvWixX4M0/V9gzriI/XRbzKZFYZZuJFXxbRh0GNNo8VhMu43zhDU8k/KQ73AIfSzJXu2MICamcgqxP8KH5LZOVsigjjDo8BMafJ5TA1DjrVfgDwi5tgnJBYWoBcJFlY1cbQkV0RNwH3w+H2+3bQdXUQk1enpinzW8K4e/mw80T5yHlcoOMeDLOnIIp87dxIYrLoh8UjbquXoHePDOycEv/upY4C8weFgUuAha6Tfgms3BGf9c7HB6SGVNlYkkdPXJns0F5Nf4HWuZfzhLKqtLl+KNuzh2XhcWh3aRQOzkQep3qKgTgXt57yntWCUpttzTaPGYQYsFg0WqgrgbhKGKlokMg4fUdf77bg6mcgrxvR95v0uJIBxz1INpyEHEpSyVCGzvJCyFYdBhHHZgUcoII7OONTQ6uIpKaL+5HM/MvsU633lDy/yLMNPEbNzAb67WPTxctBJcRSX4bdgn8tmyGwm4oiGawTW6nIrt1+Ow5fLY1ARJz6t3gIeK1gocjT8q4gR3wO821YZKN+NF9HcvaYgqK3zqJnWVo+U9kOVI/oZH/q6tZgEJN0hFhUFRN0dZLXOHt9Jls1D9249oPLsAXQ8SMdjdTR1LpBCtZUhlpbsFMBgaQ7lxAIC6uhhw0kk9c3bqDNS4/RMDrJmoGiqSTLmajvwbJ2UHuQZfo0L7Rzge2Qoble1wOnUA755Lz9Q+efIEBEHA0tIS/OZ38lkd/4/GYC8PfdUd6HrWgLbUd2i6/QofnAtQzcoeFcxW0TJRRc9ErVUuPvoVoSX2LTpyatBT2oJ33LIvQFdKfAG6kxTDQFdTU1NmsGpmZgY7Ozu4u7vD398fYWFhiI6ORnJyMjIyMpCbm4sXL16gtLQUVVVVaGxslB+sjjdktaEc8dZd396DK7cKqIlBQTcBZglcdNVXCDhnxFfoYX2DXP0VCHXbTLknrTT0E5tY5tAioUK3gjXjHNKZP6ONRTr9BHkcw1ROIeYnsSc3ozuGSxGP9SM+0P2oQaklsRz8kbJrQpnptOsMuKiyEXvFelIyul15edSk2P38ucR9hoGg0s0IbFZ3wLmzWjA6fEAMeNgd3Y27JkzkJ0SjuVYwmPL5fCSUZGKJ52GR7O1832WYY3sJ62wjRAp3+nmDWGlKFpIZxRVLuqRRQ96MLiCq1DCSkjBcWDfWcWffjIDKRRbMDgmK/YwP78d+NRPqN7zdMl6EtznWMc8y7UAQBIxN3cnsGS0TikOffR//hLT/jbBFaNxKicA26v4CWITuw0lnOlYY+mGkMoKkrOPwi0+jkzlgPBXvjP8P632XU89tliVN5oym8L+/WHGgdcGc6m8HTllhyY0EqGskw3nYVleVDU/t27C1InDurLZEasLxC7rYxgrDL9Ycqc/rfVMnwl6FYXmw4LqNc4zR1d9FZfAX30iAsZCywuERygpjbbLSXahorwNy3AUZU+HNcgYQew0ozwCE+KlyWeYuUkLlLzPQsO8HdFz4JwboX486/rKH7NG/4xSiY7hPFscM7f8PDHY14U2JCdWXHj5cgzavBYDB12hm6KGKlokKnVS4q7LhezkC/axvxwa5Zv/BS7M9sDtEPk/341tR77pv1IzsvXv3QBAEboWGjGuO+buGRKqBp4BqMNZWY5yDevdnaLr7Bu0PqtD9shH99V2iSROh+LvWBf0d4gvQnaQY7nRubm6IiYlBcnIyMjMzkZubi6KiIpSWlqK6uhqNjY3o6urC4KDkzvu3CVltKKXwSjPeNGCdpcCCeI05G2lFVeT+Qkt6gwZT8DBxGtLYCsi+NRtBevtwVVcXa2j+UiajWPxBd8EFSxMqe/ExP3zy2mEU+kS//jzU0u8MDVQZ6MgWN7AY2ZbFN/fCRZUNr0ux4LO+kqkt5YkaHR1wFZVQtnuPVLkuQAIQ1InDSk0/HLhoAL0z52FzSDzb633lHHzt6TjnsQ+LfAUOZvO812KWpQ6m6d4Ty8ABQPzzWur5lX/slPue5FUcGA5hl64dTg/FCuukZYpn3ozCHlVjGB8WaBebHtqLg6oGmHUzErPoMRTQzX3xSq5r/YNBukEZm5ihgpGEV9ZOsPc7B9/odfiBnYupnEKYsw9TYCQ+WQn2YTvADNHFFktvmZQRhLOOvI4OcJVIk4eUgCgk2J4HiCl4bzAVyu6/CzmGqWKalGMPO8xJasf3TZ2I3bADTxevR9ABOxGAa6WWirvuN5CaOgthTkvFqAkbr5DUhI1CBXeSnldVWy1UU1VFDEUeVj8Uec4HjDgiygp/CCkrTKeRWr+jZfhXyKjokfj4OelC5rcNYqoI5v8FotWA0jSA14/B7m505eej0d8f1ZpaKP31N9ksc+Pj0ZfiAT5LvvGXckR7zBV0yNhr5DjrvRF5+UeofpWXfwR9fR+Blkr02/2OKlo6SbnSvQw3VZL28ezG0VHPzWdNwWNHLeq5+h3fiDbGP8fMyNrbkzrUD++6fdIc81eEONWgTGaqQRUtE9XMLHxwyEdjKBetyRXoLKhH3/t2Ac1NjvgCdKXHF6A7SfHZdTpZbCjHyEL29PNgnfQasxiCIhDVoDzU+Z8UOXaVx7/IAThtBjos/0Edu9rnJKLNT4LJuIYtdFeRSf5HvQQK6C6xjsS1oCwE57zD67p22Y0shEMaT8xjncR779VfhRpa/NAAlopuu0ujH3soc9GkN48CAo0M5QnNXPBaWvBqwUJwFZXQFBo65v6jAcGutlZwMzmId7SC89lDYqDX4vBWXL28Dbs0NaCsFTIq8FTxIDmnJ3yfjHFF0q9TFiqCvBXxI7OvM3RisP2yBQyOHBTc56FdoOmYIiL7tUg7GRoZgyAIvHz5UuZrnakbhf1W5vDz34XIqJVIS5tFAY977KVUf2ZGnoaGpzo2mztBgR4jEwCTlnXszHlMgSllzXAsod9G+9CqiDPzEJScBa50ik6HMY0eJdNLxHC01Hch0S4bLhcFmVR7tSS4XLWDjcpO3HFfTFIsPBaLUROUmPfhl1U+6nNLqkjC2ttrqWvUStdCS0+LyD6vc2rhqsahlBV+vpEolhF+WtE0aoZ/WFpM0nNbSAsDjaGNp0brwB85Jpr+AERcAL84AT3cl2i5dw+1LAJle/eCO2++ZGCrNBdlO3aghsFA8+0wyZa54xh/KUe04nfkH/h8Sr7sXZCgr70pMcHgoABYNYYWkwoxzATw3TeDzXKBiyob/uqRGCD+KfHcg8TXSL0qcG+8fepndDP/b8yMbFtbG/WS+M775CfPMZMVAqpBPdpS36FRHqqBbibqRKgGtegpbQGvtXfU5IO88dlhjgmML0B3kuKz63Sy2lB6bhjzUCUf2nHQXVBgM58eAT+9g+ANZTQHDaYgK4HM6r64/YPosYV4wq2s78BhroMV4zwO0q3xXcJTTOUU4gdXUVOLBQQpi+WaXorciib09I8BgEbjIpt8JzYYdzH/QBUtjVxuosWjV/+nsQfjIbkgPusreF+KhosqGy91DpLHHGEOMd5oCgwis0OLFoPX3v7Jx6vuqIbFEwusCl6JjfZLcYKxFvTzv0q0JmYcO46j5xlYe9UDM3RiKMD1uq6dei5p3A/jvpbRTCNWmKSirKFj7IOMiOHs63SdWPyubgf9o0dEso4nz+lgnna4RJBnZ0dSEHJzxYuThq91Bj0Gm8xccNnjKpzu/IFEScoIaTPBjtqEU8F6FND9cRSer7yZ7Q+eXuAqKiFt6Vrqc3u90wAxBT2sb7CcFog59gJjCSW3HZime0ckGyrpJaK1oRtpAcVwvcyhAK73qbtI3ngeLnv+EJgEOJMUDKfQP+R6QWnrawMtU+Cctzp0NeLK4sRMaZ7EllHnD2I+wt30cqkZ/LEy/MJ9bCH9DjR1dZDOXIf+EXUCfOPv0O99BG2+pqi3sMC74yfwaslSqdnakl82ourKVTR6e6Pz8RPwOmRY1RjH+Es5og0XojW+pfbLjfovOOnzUFcXI3Ka/rpOVNGHFEAe1w492y7quRYZqIuNi/36XyPq0mbqGceeW4kBfSmavyMyssXFxSAIAoaGhuh3/2XC5pjxBJ/HR78EqkGNnFSD5nslMlENJjo+O8wxgfEF6E5SfHadbgIyusIxOMhHeO57LDJMFiyx0p3wQn8RQExBjds/qcm/3eofoscuCJV4/kN3PTCVU4jtQf44p2uARfqSpZ1mMxKx3y0b5omvkMb9gJauPsGFjcVFHrE82a53TKCRS7+Dfv25si+vDckFxdH94KLKRqq+m0zmELIEn89H2Y4dZBGaLuOTjvWi4QW0H2hjYeBCCmgsC14Go0dGqGitwD6b+9iiZgPVM1dhenivGOg1O7QHl09r4ALDGTdv5WIaLR5rLdjgjSfTLhSSTCOGQe94BP17+gdwiOEN3WMnqGu3VtmO82c1sUDr1qhAzNPTEwRBID09nfobn89HR8drlL3zxf2ME0hIkayMkJK6GkFBW3ErUJsS51/rRSouTE3Nx49C2UZ5s7kjr/fJiQvgKirBbdNhaj9l2h20sEj77UC9/ZhGi8NsK22BUobnRkxnBpHtasURade2j91gB3HhJgRwXVTj4HiMjnxlcjWBs2o5oq2NERIeDy3vC0hjK8Dl7u8yAXMAeFz7GJvvbKau51zSOdR11onsw+sfRIrvS+oaIqzz0NPxieYwvR3oLwxHrfse9Atpd/N0v0LH5e/x8fImvD+2B2/WrpUKal8vX4HKM2dQb2eP9rQ09NfXj31eSSHn+DuyEG1wsA91sbsAYgr6jb9CVtZ6tLdzxU7zMXAom2uVCz5PANBS/YrhospGAD0LvEJS4gyeG9DlewChmgL3P86lJaNTLEbMEUlJSSAIAt7e3hM+x0gKYapBx5NaUaqBrgxUA/0sfHAUUA26hqkGPfJTDSY6PjvMMYHxBehOUnx2ne4TObrSorGjF1oe0YLJmRYLA4Y62oh/ITuezOo+D/9B9NhSBkTDQB1M5RRiZ1QgqX7g9jNKfc7hlpUGNM0dsM5YOp/xd7sMMCJfICo6AlUshTH5cHzW12hhXKcGwA90X1JQXRbawQhaxFMzM7ioshHMzP6EByQaXfkFgiK0cWhT8gZ5SKtMw8nEkyIFZuvD1sP9mTuae5qpfYWX/GfoxGD1VS8cucAEXQgwDvNaZ90kl8J17MNQxS3C4DgLKSeavvDuRSFCGJoi16t2WgNLNANlcoMLDg4GQRBISAxEdU0Yil5eQ+ZDyQVk4fHLYBB0BBo+5qior8DLly/J5VsDA5TQOaiiZUIlhOTnKiQVYIfTQ5zyfSJVx1fatsIkFYc9H4mYXuSsIEHZtf06IvuaMy4CxBT0sf6BtXSSDz/T1Ajz/cmXm/k+q2Gelkq1Z3tTDzghr0QyuM4XYmB/Qg82KqQaRcKhfVQf7MjKwmm/J1DzuIo0tgJ8o9aPSbXoGeiBxRMLkZer4OJgDPJFM2Q9Hf2IsM6jriPF7yV4/ePMovV1AS+jgPATgPFUDDKnoFvjGzQd+Q41W6bj7ZpFUkEtV3kByg8cRJ2RMVqjo9FbVg7+RNVeyDn+CheiNXbV4mneATQ4kcVkzZ5K6O9vETtF3/t2ajzrLBAF5M11nXC5RLZvcRZZe9DyoU7EfvwpY7NsPGLPDdRxvb29QRAEkpKSPm2OGTGmDgYeQV96JLryaz6NahBXRlIN3k481WCi47PDHBMYX4DuJMVn1+kGegE7CfaUwpv9gvFlIwd6kW21DxvpAh3PVbRAJDkLgEKb10LBsaUs44W7HcRUTiFmp2SCL5wBEPr3g916xOe8ABHzEtscM6UCpZ9ogdDQZSBQbz+K9ZUpWgUJcv8Pjbom1MD4UdcWg8R35Odj0Q4k0CKqdddSk3RX1egSXrLGsIRU2c5dcg3O3QPduP3qNrZFbBMBuLujdiOiJAK9PPHnO1rB1XztMGy7bIXLpzVw8qIeptHioXAzmirscj6tglh7CxSlp6KzpVnCFUmO8RakjYzakte4Y8QQAbjhRgyEJTyUuqQtHL19H1FXF4PE+4cRF79QqjKCWeh+nHDSxQoDfwwrIwyDce77j2AN8RQDdclixh3+j0igG0WaWMhj0zyPdZ/KdAvzTxddu02Bsm3nnUW+o0S7hwbWf8nfkd5OKLOSsMPpIfb5+2NZ0EooByhjZchKcLgPkR76Cq6X2UIANxb2J5iwUdkN13NHwAnwQn1FGfiDgyhXUQFXUQmFG3/HIr14nHbRQRpbAaFxK6Ve/w6nhyhuLMauqF1U/zsYexBvW96KtX/Lhy4E6z+iruVJXLn8YGSgF3gVD374GfTe/AGtJ6eibsd/UL5aAdy5ilKB7ds/tqJGRwdNwSHofv4cg319Y59rvCGn6s1wIdrq7AJkPlwFduoMDBiRYxg/z0/iKRp8XpDGNrZ54koxAJK8i0hKiF42akpew+3CMdiobIf90d14lfVA7oxsf38/DA1Jeb3i4mK575HPGySpBk9fod1UE80MXTTouqCGFiU71cBDiGpQ/OdSDSY6PjvMMYHxBehOUnx2nW6glwSyow1iDgvHv+zeUolexxVw0DuF2bSoock5BpGxZPHKs6fHBPtKGVCfWy+jlutqTGfKNFi29/Qjo+AlbI21cVjXEoq0CImTrzLtDk7qmsCDcQ5v6f7UYNls4Qa+x0Zy8B6LdiBlIO/X/ydcVUmtzzKTE59ehNbailcLycxTU3CITN/52P0RjvmOIoU+ygHKOJd8DplVmaOCh+Hs6vRRltcV6PGUi9cxszvwu64qkdsbTL+GrPBg1Lx5JWYTKhzjkRgTud/KCkRZGYucO5ShhcqiZ6O2U2dPC+KehMElSg1hCeskAtv0BwtQ+OwcEnLssNbYc0xlhOUmqVDTtwJBEGDpkTJjO8PIjO4PgVnYaJ2Okz6PZQa6Ssz7Etvm4CkrcBWVUKQ0D3O0xfs5i3EFIKaAx/oKul4R1D2/bnqNbUG7oEoQcLyULARw42B/Qh92R/Yh2toY3JxsROW9E7FODg9JwktFUuVBa582DjuwkMZWQETiIonXPp0Wgy3++pT5w8LAhXAqcEI/T5yGUFPSAm+tDLiosuGmxsHrx3Vi+0gNXj8GntxDu8kB1B9QQOX6GXitPEe6tNfan/H+sho+urujIysLvNZW2c81USGDDfBwnHpRhqmcQuzjOCGNrYCC6NmCMUfCi3jP2xZqTOsu+ijx9I3VHXBRZcPxrA/sjwleVN+/HJItlDMjW1lZSRWitbW1SbxHPmsKeMR09OqvQYe5GloinslHNaAl4wMzFI0hL9Ga8o6kGlT9PagGEx2fHeaYwPgCdCcpPrtON0nUBZEY4qyW+Z7DEcKVnJztDSkA0dRcMOq1dBt+i+/Y+ZjKKQTb4VfZrnME+Oxn/QOF+kvgrXcYF3VZWEoLpSbhlbQEZAzJ7lTRMuFBC4OpfxSSX9ahqVOGbM4obRiu7gkXVTaytdQ/WT6nKTiEkijiDU8gUqKkuQR6D/WwJEhg8LA4cDF0M3XxqunVqN8VDnnsY19UkSCh5UMdCpLiEGFOwOGYOLfX5dwRJDhZg/swHd3tovchr2nEcNRXV8HT0AjWQudxUr+AV4+zJYJ5Hq8HTU1ZKH1rjayc3UhJmykGbO+nzkZw5Cb4+O6Fr68eBgdJUCYLGB/mFO/WIzm+NH1zVNEysS46jwS6Hg8wjRYvolQy3o25SwNcRSXErdgk8fPZtChUsRQAYgqqvA4BAFrr2xBlmwYXVYHpgrV6DG5q6sD/xlXkJ0Sjq61VonXy8L1ZbzkNrqIS8uYvwglDJtLYCkhMURRvC2YA5roJVhK2RWxDYb1k2s3rx3VwUydpE95aGagpGX01YLCzE52PHqHRgo6qA+tRslQ6qH21eDHeHT9BWuYmJaO/tvbvs2QtZAMMzw0SX7B5vF4seEByvLXZV/EoZzP67l8fAsTLxA7J5/NR7/aMpGA5F4x6r6EsP9gMGct4XDqJhsoK0WuTIyOblZUFgiBgb2+Pwd4BUtWgsB5tyWVodE/GB4O7qKanyJCdTUcdPQwfdW3QwtBCh94h9DDXgseaIaBS/I0kySYrPjvMMYHxBehOUnx2ne5PKBQQDj6fj4j8KiwzSkJgzFqksRXgHb0bBZXNow6oq+NjMZVTCFfvC7Jd5xgAns+agjL9OYhjnMUrWjIpok7LwGVasthEvckmHbR7z3E3rwrvGjvFJ4xR2jBDU5MsotFw+eRii7Kdu8giNBpd6j7Z1dm4mHJRJHu7+tZq2OfZ40On/GoIsi6tr7fiSPx+f18vyguegu3nAe8r58SzvYd2IJSpjYd3biEsMRtLDMXbf7SMbkdTI6JcHGB1aCd1TP2jR7BF3Q7TdWKp4rXBwQG0tuajvMIF+flHwUlXEgO2KWkz4RW5EZreqvjD0hazdCPxG8MfBEHAytqauidZwfg0WjyW028LtHjpSZiVXICpnEL8x4H9yQB3eAtatxtcRSXY/n5K6j40hjb4rCko1Z6HYHoAnC8mUQDX6WI8LjNvYrHvUigHKOMX/8uIKKhEe0//qHxpZc1wPFYmVQiCt+6g2lGBPszNj8Msc33M9xO8bBk9MkJXvzgfms/nIze+nLqmYOYjtHwQ3U/EMldXF2VbNku1zC1WUkL2quVw23IEFw6zcEQ3BO8/frpCyV8VPT01SHlymFrZCs4jMDDQDngOKRok6oh9p/tVEwUae+5HS7Te5fP5yL4TSv12bA+fxHOOeDHbaFlnvuNy9Je9RTe3Ee2ZVQiyJfm5wYYeslENTISoBhlDVAPf8+ATYxhZ/EWSZH92fHaYYwLjC9CdpPjsOt0EyovKv76FAAAgAElEQVTJEy1dfbCNcacmx83mTmBGPkNbpgcp9TViQDsT7oipnEJcuWUm23XKAOB7mOtQTUsaWgpLwgfmNtxnboYRQw27WN5QkJLJXG6SisshefB9WI4XVa0YcN8g9RwlOlvhosqGu+p98Nw3jbu9ugsLqUm8K79A5LM+Xh+iSqOwN2avCMDdcm8LQrghEoGFrCFL9nIaLR5/OGSMeSw+n4+mmmrkxUfjrgkT9kd3iwFfwyMHcPasFjZrOGL2Dcl0k2m0eERkv8aDYF/YC2WMDY4cxPbLlpihE4PptFisNfbEBTdtuEfuRfqDBRLpCMkPNoPudwa7bcygpHdH7DxrdUOogrLhFxxZ24TMfsZBl2UEgiBgqx9KAZX/mqdMDNDViaPApuohJmbriWrLzqDHQ1nrNtSumcPtrJkIwHW+mABfHR8cpXtjBi0CSk4Cy10ll/1YZjr2+S+rMKh+melBZsXnMcMxXe8WlFz2C8xGfFZjr7+PxH7B6x+kqv+HlRW62nuFLHPNUHH4CEXbkWiZu3QWXv0+H+EHt+PkBWPM0Y4Uu1Yl5n3czXsvtw7zXx1NzY+Qkbkctux9Q4VoBWjv7wc6G0GpxbxJEvkOf5CPD475qKJlol7fj8yAjgCogw5LkOxkRv1+XC9owPlCAm4ZPhbj8vL5fPCa29GbGo0OJwO0mJnho0kA6kw4IlSD97QMmLNIR8FkRqi4qsGtV7JRDf6ieenvGJ8d5pjA+AJ0Jyk+u073J2d0hYPPHwTn4RZSf/MOqb+5nBaMWOYW0Spfk+9gEWaMqZxC/BZzW7brHGOg7GTuRhWNM6SRG40+/SVCn38FhBxEV98Asks/wiG1BMd9HmOe/n2Jk/083Ugc1zWDg94pZDN/QhdLIL7ezpxBTeB1burjbqsaXRJQlO3YQQGu1t5WeD33wsbwjSIA91jCMaS8SwFvFC6srCFr9nKbY6bcx+7r6carx9m4os4AcUTcrMJKZQc0T57HXlVjLNUMxDSdOMzRicQFTTM4nRKYPRgf3oc9qkZYxfLGCSddmIXuR+R9yQVkWdnrweXSUVcXg97ehjFB63J6GJWR7e7uBiB7lnt4if8U0wEEQeCSuTcFdKcRkvuSvNtPGgEU2Nuo6ok/7DNwL+89znpn4RzTHYaXtOBw0hzOF+8LZMIuJiDa9DY+VNePyNjGYo6tmkB+zH0LpjNuj3r+GTqxiFm5GVxFJTzfOAdpKQpYbMXAPJ+VIgYV0xnhYnQTAOjp7EekTT48z8Tg9gFH5JzRx7tzY1jmLpiNyl+mk5a5N5djIN4IqQ+zZG6z8UjU/RXB5/NRWekDNmc20tgKuJrOFHVEK7pHjjOG3wC9ovrSXS8aKJDZq79GbPzr1/8aEWdXU7+hOAdLVJd8pPoIN7KUVDW49QofnGRXNXht+YD6vbxNfkGqGrSNQ9VAlnmJmAIE7Jig1v77xmeHOSYwvgDdSYrPrtP9GRzdUaKhIYUCIdstrKnJ6KSuCSr1Z1EANsrnJKZyCjE9NQc8YpQBcAypMj5rCtr0zlGDcx09FAPD5xHeCm+JXesAbxBF1a3wyyqHWki+mNbr8KZAi8EuuiOMGGq4z9wM38t34KLKRmFQ3LjaiNfejleLFpNFaIFBqGyrhEmOCVaErKDAxMLAhdBM15TKfRxvyJq9lFYcNlZQoFEnDks0g7BH1RjXT16ApcpOMeBrengvLA/tEmSgVHfDzvE8jAMPITx+mURgG5G4CGahB2ByxwLd3e/Fzj8WkFem36Mm7o8fyWIeWSTQVhgL+sZvDD8QBIETDqQe9PdpBfiN/mlmEdTv5JgxuIpKKJi3AAo3orH6mheuqtHgcOIoHE6aigBct8sp4NCY6NX/DgjcJRWwz7LQxXx/0vp5ntd6TNeXbNM9vG254EKBUGdNJapPzvddhpmmRphGixOhmwxb5lY5eyHrt1PIX/SzdF7tPCVUrFXAh13/Qevpf6FP+x/gOy0DOGZAw2u5++nw8xmPw96fGTxeF4qKrlL9OOfxHzhR+FLUES1ajRyr/LeLfJc/yCeLumiZaNC1E3/JZ/wLQScFRhBJN5mo9yhEjcljhA/xo4PV2HivkzE61SBCiGrQQKoaPHv2DARBwMTEBLxxSgwCkH1esp49Ifrkf+f47DDHBMYXoDtJ8dl1OjkLDSY6+Hw+njwgq9yzIxRwQteEmpDm0CLhonccfax/4JXlQiobVm4+d+zrlDBQ8llfo5lBpwbsero7BlnfS75vCUBX0rVXZt/FXeZ20Bha2ET3lDixamiQFe2WzEyE575HWUOHXBmOptBQkne4YAF04i5jQcACCkysCFkBs8dmeN8uDuImIiZK7ktaSAMos29GYJOGI86e1YLpIfGCNtvD2+Ch+Qtu2S9H/D0lpKaRgCA2aR5sbu/COdcbWGPshWHJL0nZxNHOT4E+WgwFdCsrBVXtZQ0dImB2Gk2QwR22mt1gxcF0GukQSBAEDnj4YyqnEIsS8qFHmxjqgsm2i8hXVob3lq1gHj0Cm0P74HDSBM4XEymA667BxqPIEvR09gPcOKqPm7t5Sb33mSbmmO+3eEhrdyVmGLiOeh3OW0n+eN5CJax1nQ8l112YrheCGTqxWH/ZGxcOs/BI/cbYlrkbf0LNHmU0H/sOPVf/D3z9od+jw0Ig1QCoe0Fa3o4IeXjTn9pnJzu6ut7h8eOtFMh9UaSBgYFOUUc0Ph+wHRoHM21Fvt+Z94Ea4zr0VNChdxAtjOv4qGuDN9oecD96lPodsS/ZiYDYZ9oPqH5TaPpEQDUolE3VIC4uDgRBICAg4NMaYaCXBLF/YRLm7xKfHeaYwPgCdCcpPstOJ4e8zWTEx7u/UYN6o903iGX+juW0YEFGjO6ObNZq/IdNWgEnOm0b+zpHAPhB1j/xUdeaGtAbdc3BZ30jeeCUh6oxInPcyPoBycyNMGVcwh66PWbRorH3OplVs7iUhmk65D0tNUrBxaCn8M4sQ+H7FvTzJGs89vP68eyPTeAqKsF9/1wK4G4K3wSfFz5o7Z1cOaSxspfDwG682TGpAEUnDn9ctYLNzW0IsV6BO+6LEWK1Au5XNsLm0DYx4Gt+cjc01C7jl6vOmDlkXiGcwZOWcR4byMeByTIAQRDgcsklY2ElgpE2xcuHbIrLGjqwxEgAZq/rm2FLQDimcgqxJeIpomicTwK4M29G4Xc1WzjvGm6LvbA/aQznCwkUUHFV5+BR5Ft0dwgph/D5VAFTsfEq6kVA0qZg4IL5QxSE+X6LMdPEQnw/ehTm2F7CGhdlPF1IAtaoTStguF0VYWu2IX/eQqnZ2oKFq5GzYS+qrh1Gp+4y8Bgj7GXt5gPJekB1vkRwKxzyZHTH6hN/ZTQ2PsCDjMVD4+EsvKv0Ap/PF3NEQ/0rAQ2hMBtdhfVoTXmHjyFcVDEky3M9uxYG58MHYKOyHXaHduGRhgfq6LeHVA000WGmjp5nbxBh+RQuqmzctXgq+wv5kLGDmykNBEGA7ahGFbzJ832RgjnnFWOD3P8PCtI+S8wxQfEF6E5SfLadTgZ5m8kKvsc65Eb9F2lsBTyN/C/4xBS0sr6DHuOaiFbpfId4TE3Kh93jNNmucwjA81j/wQe6NzXgtzC0wWeNwf/y3CDbxY/BBe5mfYs0+l4KfKzWS5I48SoyE3HYMwe2ya+R8aYBde0tCCoOwgX7XyhgsN94PvbH7Efs21iJ+qOTFVXNXdg4QmJqeFtlmvZJfMfTfk8osKhAj8FmM0cwXY7jTshipKSIS36xObORnbkPDyJuIMqWBrtTKmKg1+LQLlw5dQk7L5ljgVboqNk7WWgIdANTEASBvLw8mfZfa5EmJsmmoueKtWFxmMopxOmQXLylZWC2vABXJw6rr3nhzFltmB3aM3S/e2B/0lAE4NqrpuHU1SRc8HosudFL06j+eVrXeHRAqO+HeV7rSLDrvwCzLBjUZ8p0JxzSXQv9C/MQuGMu8hdIcRZTVAJ32XK8O30Gz9QJxBw0wCO1C2hkLRX/zdgoAok04P0TQA73MXmMN4Y3aVn+vyL4/EGUV7ggjU32+YzMZWhqyiI/4w0iuayBckSriniDdls9gJgCHuu/lFW5VFUDWjTyrrBgf4iUD3M+vA0V2kvAZ/1D4qrY+5cfqL70vrhp7IsfMsvpIb4FQbBAEARKCNLyHY5Lxk6USDDbkYmfK+9Y/T8any3mmID4AnQnKb50ukmIkANodPhWkNV1EGRaC/SXYAtdsGz6o34idsQWypxpGPjQSlYGDw367QaXQVUqT0SWQIaiCR7xDTwuk9Xu3JxaFNe0IfBRBTRuFWCVaZrI5DtdLxRzbNUw33c5lAOU4XKQFOV/uH4pcmoe/WW6n70DPEQXVuOMfy4WD0mArTBJRU//+AXa+fxBxD5NxwU3LdiF7UBCsrjkVxpbAcFRP0HH7yzinoSTkkpC0d3Xhz3ELahcJHDz+BmJZhUGJ48j1c8DFc8LMNAv/oIgCcgL2wM7ubiCIAhkZGSMC1BNo5HqDQuj0jCVU4gb3o9QRcvEfppsBWnKWrdx4KIBSU2g7msP7E4YwvV83P9j77ujmsrW9n933e/7497vfjq3zHDnTsHBAgrWsY117L2PihVRFAFRqYeaI1UElSIgSBMboEiRXhKqgEhHAUVUiiAIKNIhyfP748BJQhJIUJz5lHetvVgrJOfs7Lxn72e/+3mfVwjgTjYYAshxuYDPWoAcg2LzaUMXvrC9iymXV/OSHQ2WIXbuLPGgVl4BBYrTcENZC0xnP7x/Wo7eNy/xxMkMdcazhZ+Rc3JApC7wIl0qcMtvkpw8/FEjur2971FQqE77e0bSWryOvI83fo9Q50AVUDjjmQUZVj7m3cuhij+YLQPIMWg329SnanAfdc65qDZNp2hZ7gXoTgoBhyGDgpOTcGEXFfn33LsCjUYyg85X3MI7CO6L6t51yBmi87yTs3JSiZe4SX4tGfVtKOrcaER3FHMMYqNAd4Rs1OlGwApvg0uOwcMQKqqbHfoDr9QvSRV78DTdg/EmvIVqr1cmKhpaB71sV2ULXllSoKLaJA3tBQ0fP/lOwuuFWFBAN/lWmcDHuVwuqpvb4XY/GWtuqkPJbxqPf3t5GvIUp6BEXgGndhhi0TkmdALzcetBJcrr3/8uoLe5rZuWsPJLfy7VZ7lcLtrbn6O65iaKirSQkio6gSwqRB6+lxdB7ZwOlMwDhgQm/EB1iv5trNG8AHXVU7BWFub2Oh/YgVB7SxTER6PlTT0ACiTdyanCOqdUKDFiocSIxTqnVAT3SVFdu3YNJEkiOjpa6iPy/jaeCIdcDFX+96QrJWl3lhCdzChL8KgJpw4eG/AdtsD6kB0uqvNkwtyOxuKQdiymGEgO5Lor0mjfPG5sLrjZMryHBZq+UN1jAfdt6ijf/htyZihhv/kU2jfVDaagcAoFah+tWoZXhobItVqAjDMTaLDb7OcJZHmCc2W1MJiykwXCTwDPWAB76M1S/0aLvzrbwPLN/H4gSfs9OLqczl50V7+nqQY1QfFIi+ZV4su+fgCVxolCUdndAVRFPdU7uXjjkwuuxTcAOQbdcV60qsH7lOo+9YM09DZ2gNvTiXTdJbTv+B9YilYTybRpXxY30v5V86RZ/Bfim/9Y5GqQJAlX8oTk86mk8/HHmKv/j9oo5hBvo0B3hGzU6UbA+nb1TY68qO4b538KTr4us3DjaQ2+P8+LgE40jYZTwlOR/NCOx42oMaOiGzVkBroq3gnc64OS7wT4ZIv7dH/FRIn7rpdx9wlc1ZkItH5AX4bD5SClOgWHYw8LyIMtvLUQegl2uGZiQ0XHJitBSSdIaKGeYRGHI1cfwiP5GXJeNguNgyTgQFq7nPwMskQkJpvHoKVzaPpEZ1cdamtD8PixPtLSF4oEtjH3JuK2xwz4mi+E+XFlLNK+DFlDYe7oIjumwHe5k1OF4JwqHPJ9gPXOqVjnlIJ1zqnY4JwKVb9shOZW4sWjYqQF+MPfUFtktPfK6ePQOHkGC056YjwRLhDN7ZehCg6mlBeCg4OHlfQkS0TiR6NIyDCpYhFqF26hmkhFAjEAlBlGYP4prwHUhH4Jtd3QP+oOB75KZpeOxSNsgzn8l+2RGsiF5dcg2WwRQI7BE30F7Dl4FoxNWrixaBOyFWeIjNIWTVaAugEP7K72XYBXdeX0NR/m/IaU2HF4tveXPhmwSeg14j0XXeb/RoPzPnDL4gApqDeiqrMN/I36rauXjeCcKiiYiY+Wj7TqApfNQU9DOzoeN+J9SjWa7z5FvUchXllnCYDXkvOOYMVNoZ6DhIkocmWgikjBK+ss1HsUCqgazEwr5iWiVSTx5peWWgAUgH5lQW3qm0Oegt3bixi3i7T/3FZdgC6zv0sGHD2Xgsvl4rZtNlzVmQi9mCf+y/KdaPmTh0CSJMLJ7ZJHXSWVERvuXP0Z2CjmEG+jQHeEbNTpRsj6+LQ5d79HIlMOD8J+BHdAotmLji7IMPPwbUAGZvFJey07n4SMZ430pVqzalFtRC0mtbYP0PO6TeS96MmS/+9QyXdD8snGirzei0JKo9LtOBMtrW248+QONoVuEgC4G0M2IqgsCB29HVQltC1bUSKvgEpdPWS/aIJbUjlU/bIxlRTN851kGo2dHhmwjy3F7YdVWHyOJRE4kNTYHC4W2lEVvUxCikS+p6fnLerrY1FaxkBG5kqRwDYpaRriw1bA33IBLh1bifO71sNk3z4sP+EsEuAOBCmyRCTG8UVVxxGSfb/3TW9QxIxD+HkbuKj8Jixftnsbjh/SxlpNB0zRC6IBUWRUNEiShL+//7Ajuj+ciaGTiTTsnFFFpKCSSMFUIgqKegHYccxiADWB0hHWOqQNXZ0gXNFLoQGus3oi1LTjELqQqohmtumExECO3dqGtqwHcFdnIGjZejydOUEs/SB3yjTErtyKF7YWuOiwE0tdFKHkpygga7c1bCvqGkuBvOtocZsADjkGPYZfoUyRKsVbs/4nPDHciOhTdihNeym1z0nCiRb1XYeio3yoji6XywW7pQudz96iNasWbyMq+KgGg+vNVhHJyPc9TT8PyYk/oy47TqyqgVAiWrw5Nbe4zaff05Lwkrq+aRo6Xr/FHWsz2o+inM+BnR9IUUSkoAJU5DfQPlf7TEzSa1+OAoccCxvSCCRJIo+cLxI8D/Z5iYGtNHP1Z2KjmEO8jQLdEbIvxulEZcFKk0U7zHs259jTC0D9nZUCiWYcLhfjkgsgw8pHQNUbnLn3SGAB1A3MR929Z/SC8topF+yWQbhh0ibfDcknG0tFdz0WC12vs7WHXjR+c1cRALgqMSpgVbLA4fL4iR1FRbxKaNmCR9AcDhdlde9xPfMlTgXkYcFZ6crJDjeilVjymr5GWR3FlWWz29HYmIyn5WfxIHsTnUzD31hJk5GXdwBPSi8i8QaJi3t5WriW+/dgreZ5jDMcnCcqTRtHDP392L09uBXGxJ6jpjDet19ktNdwvwp2HzWHlukFkAwGjK0vwCy0eFh9+t4ungYrJhaWyCeiUU2kwu2YNRwG3Nf6iCo0DC/CyIoJdx0ewHXVYOKodhymGkRhkl4IihUoWsuug+cE7jXHOgHVze2CJXNNTFCxcSNKFCaLkfaSR8Tc5XBYcwhHlRlYouGFnwzvYZn7JSwOWEz76knmSTR1NuHu4xuY3idzt9x7MsqseScwHMt/4JXaMkoST34yAlT9UV02yPH3IPYh8nb8vPKNLmlQ9ctGWH4N3nf2SHzSMZBqQBdQMJekgEIa6hwe4o3fI7yNqEBrVi1an1Qi76EKj6rwcAc6u+oGHQNmYwudiNbaywYuL6TGOtaE6mN7D13QoSH4Ma4ZnqR9KfWmH4/iJCVti8vlIsDyAVzVmbjnIkafuy8iW0fK8fSmSdmPHNEdC1xe9LskSv8R7IvBHMOwUaA7QvZFON1gUUtJsmg/0PLyDiKRKYesrHXgcgWTU1Y/LIMMKx92FdSRXVH1O2x0ScN4IhJeBI/b1uBVNKTmo9Q2TH5vxbsKkPdJWJ++BVd1JlSs9DDdfzoMUgzw6M0jkbeqNTNDibwCnq1dJxEX99XbDoQXvIJ5WDEWnE2UCBy4J5WDw5Gc53vA5wFkiUhsd41DxXNn5OTsBpMlL1IZ4WHOb3hWcQHNzZlob2lCWoA/nA5spxdg96P7cNXrOn4yDP9oAFcS8MNv/NFZJd0AbNA4B81Dmji7W7g0sYPyZlgdOYjVmhegaBgsEFGWCOg6MyHDysePsVkgSRK3DdxQTaQiScMZ53dtgOuRPWD6eaC2vBxFydW4apTO4+BqsMD0L4GaeyZ9vbVqvCINM07dgqxhBOad8MfBfVbwUdYesmTu/XmLcXmFMmx+O4pWjX+BYzoWxiY6vD4bB0Peibchm3dzHkJLA8EtugME7AUsv0aq3TeY40tRGeb7TgHLaxqKA75Dasx+uB2Nw8OZS6nyvFt/A3eYSWaSRNClSSwTRYOYQERiERENHeskVMdU9FENCvDKOnNoMEukClMNSvoKKAyQDGxtLcP9jF/p56S01BQcztBgzfFFHa8iWms9b54pTwQAvIt+TvXFLA1XT2hSOtO7NyE/NlLwQsOgbZXn1NN++PpFi3Dn+ubEbHIRSJKEHWkokF8hbk4c+Hlp59Qvyb4IzDFMGwW6I2SfvdP9zgUkAODdu1x6MXhdHyXwv5MllZREUxEvEaqnvQcFDg/ohecKkQjly/dRXv9+4KU/zKQol8zlcvGg9gE0E3klVbXMbKijZ8sQ1LbWir0Nu7UVpTOprPZGXz+pu8kv2TVUm0rG4pDvA7iyyvHgeRM6ewSjWlwuBy3vi5Fe4E1/5uzN7ULgNuvBBjx9aoM3b1jo7aWSBHs6O5EVEoRLqjwJsEuqu5AVEoSezs5h0wAkbSo+D0QND23i+LZyBmFYpH0Z+9WMYMonrk+D3l0bYHBAFTuPkZhz2ndIuoWiXgDmOAdAhpUPpZAEkCQJR+IMqolUlBExePrgPrq7uvAotQZXjfkA7nEmEv0e410Ddcy+yI4XuSe2nEKJvAIeKk6H/5KtyJwqXgXhybz5qDx6FA0ul9CakoLe5maBSGmoGaXAUMsYh0lECOTOuGDKlUW8E4e7G1ETuKePi87n6xb/wKPrG7H0xjwoXVXCDP9psLs3EWE3N8JVnYmYk750H94G35Xajwf7jQa2oaTCuFwu2ps6oGGThFNEHByIBAQSTGQQSXhBiK4Axt9qzO/jtUseGm+VoiWBr4BCl2Sb6brX98BKUuzbCCqg5lWgxGNwqOg5ryJaQSA19lbfAD0dYL/vpnMREk9QnFynfdvwNDtD9MWkpG1xOVzcJDPhqs5EpFuh8PX61ou75C6QJImb5AHp1os/wHrzR7fPHnN8gI0C3RGyz97p/iA77PwCVUpqJ3M1uFwe+HKvrIcMKx/zMx8DANgtXXjtmEsvSAEOGfTiN8EkCg7Rj9CZ+5EoGBLwyXrIMYjwmo+d93YK0BNW3VkFr6A7cFVn4sqpZHAHiaQ2BwRS5U+VpqK3Wfoj3+EmTMkSkZhoEoUjXsHwjnVA4v3DSEqZiUSmHNTc9SBLRGI64wZiEybgfsYylJaa4vXrSHR3Nwrcv7enB3kx9+B+dB8NDp0ObEdagD86W1s/Sj8laYvsmIOOk6RAe5meJ6y1j8NOdQ/s+EoQ0/QL5R04clgHK7WcMEn/LmQJSjVhldZFnDyoDoddG7DSzQsyrHws8L8DkiTBYJB4SSSj0jAFgX6FuGpyXwDgxvs+wtvXFMDtL5lrvMcY7suVwZy5UCyozZ+shDu/rMV9HVO8i4xEd1WVyBOBioZWWut3iZE3ehlfoZscgx0X19Llf6f7KcHXWQ5sAeDxd8B/C5DrD7RTGqvV76ux4e5G2tf1bsxHjFcRervZqNY+SYHtXxaA/U764ibSRnRFUg2cc1Fjnj4kmH1BpOA+kYRi5xy8jaSoBl0Vb8Fu6R62wgmH04unT23oDWFa+gK8eyddmW6Bimh3j1G/w7WtAIC34RRVq8IgHs7K2+F6WBk1ZSWDX1BK2lZZVh3tm2+qRQQP3lbCyUIfJEkilVwpPY/2dy5Y9Ee3zx5zfICNAt0Rss/e6aSIWo6ktbQU0otDXV04/TqLj6/W8qoVtbZ9kVyjVLRmUVHSxJLXArzVJUbeSDVf9OEUjEHGpsViLHwvfocV3goCAHd3xG5EP49GL6cXTbVt9ILRWCNeGu35tu1UIo+u3rDGThJwMI6IxC6PDAQ8qITJnUSc8LaC5fXduB01U1juK04BCqZ3IEtEYvNFHyi7h4rkNXI4bBQnJeCKFk/P9uKeLWD6eqDtrTBgH+mI7izL+EHHSVL+51SjYJp/ON0wEEu13XDwiCEYe5VFRnstlH+D3a5NAq/PvhYMGVY+JnnHUtdikAjVjYSvBpPHwT3ORJxXMeoyH+FtcDBqGSQqtg5SMldeAenTZsNx1UEc32WK5eqekDOgqCCDHeX3J3jxR/2dLNZg25VJtN9u95yEJzTvdizgux7I9gba3ghd711DB7wsErDGi8fltcywBJvDRs+rVyidTqk41FlZS+HF4n+j8QRFNdhLxMKIiIcbkYiS89kSUw3yiWSEEyy4EokwJOKxh4jFIiIacsTH1dft7m5Ebt4++jnKyVVGV7fw+A1mAolozS2A/QTqN7nvgt7mTlQZUdHoqKNW8DpxGE2vqj9K3/mNw+bgulkGFaX3FE5CbW1tpZ+PF1dUhsej/R0LFv3R7bPHHB9go0B3hOyzdzpJs2A9l454VwoKj/VFdVeAw6GOCGu7uiHDyse64IeoJKkEjBqzdHQ8Fowqtre3w8bSCHIEjwOqbWyMesYPwz8SExHtrrH6O+ycf8RcX57s0tSrSjjBPIGHdYIlNLkcLrx0qeSi4hTR/tNR/IgGMW1Zgx+9i7OhAFVAVF8AACAASURBVJyiWSC2X7TC+dtHEJ+0RKQyQmS8EuxvbcUhV0NMNb8l9lq/nE3EizeteJKVDl+d4zSwu7B7E2LcHPGu/vWw+zlSEd3+JKWD3lmYaBI95HUmEmH0Qj7bKJD3P8MIzNC5jl1HzWG+d49QUll/lbZTB49hsZs/fojNxPduSTA18IKTJq/Qg+uxRFw44Ic7q1RQOmOmWFCbOXsBrizbCePN2vRrmw87iuzzYEf5/eP+E3EPu43PQvv8UszwU6R8108RF51+QDc5Bo3OS4HMy0BLrVipuqqnzfDRT4WrOhN+58yxN4i30TvBPIGO3g68uXyZ6u/kKegsKxPbL37jcrlgv+vC+ydNsLRMxvmPQDXQOJ8KBQn85mNUTGtpKUJ6+iL6eXryxBIcjvTVDPkT0dprCuh5h1tbhMd2kagmUlGuH4MbhI7IzeTHspL7tfRmrOmVoIpNSUkJSJLEmTNn0N3dLeYKozZc++wxxwfYKNAdIfvsne4PEtEFgPfvH9MLRW1tMABqATwWmIOKPvmwV5aZ6K4ScZzWB0ofmythixEPDEwlgnDDdCs4jLHSUzD4+GSFtv+CnutPmNYHEJSuKmG27xRYXZmGF01PxF4iwrUArupMJPg9Fvn/WnMGlYS2es2wj0sHSjJNMrmLDQ72MPBRg2/oYsQniiitm6SIvHwVvHzpgZaWInC5bLR29SKxpG7IqOsEg1As1nbH7mPmOH3wKILPn0VjddWg/ZMEaP5kFIlfHVhYas8aVuT3gLdwCVxRyUhDtwiYM86AJEksNL5BRRUHUBMEVBN2b4fNbuFiFfa7N8F+nzqcVOzgohaES8cSEbTNAdmzlgmB2rxpsxC2Yhu8Dxkgwes22mrraIC6TfUCVahBfjIm694R6u+4wSK6HA5s3H1w1ew3FFjK4qDHBNp/13gpIMf2a3Qw/onVRu70NcTp2K7SiYbzcQqsXzmdgsd5gYhPlIPWXd6Jxt7IvWh8V4vyVatRIq+AF/v2Cfg1TTXI66Ma3CyRimqQbZKCaq9CimrwYHCqwcdObBNnr2rvgJWk0Kc4MgW1daHDvpZAIlq6EwVyHSYi4bwLKg2p0r9pjCvo7vgwubShjM3mwL+PXhPnLZhAGxcXB5Ik4enpOaJ9+FLts8ccH2CjQHeE7LN3Okk5upF6n+RYqbBIE4lMOdy//yvY7G68T62mF7pHNhnofdMh+oN8gJ3NGItrptuhRPCKLmwzuohShpJUgJ3NYSPxcQAOeE8VoCcs9ZkMD8fv0XxpaDrEw+gXcFVn4rqZcLIIu7UNZf1JaN4+EvdroHE4XXhSmQzyxilcDl6J2IQJQsA2NmEC3INX4uQVTay2c8LK8/Ei5ZUuxJeJBAST9IMxST9Y5P/GG0dhi2s6rCMfI/ZRHRpbeX4iCdDsP1Lv1zsVpYkqSTMPKxb4LtKWieVvBgxrkAwGdug4QPWwvoiCDttxQM0Is0/7QdYwAhP0QrHtiB1Mdx6Gwy5lOOzaKAR8L21bj9vLFyFp7hxE/rIadmuPQP2AJRZo+kKurywvvzZwRUMrZlsngNh6GiXyCoj9eYnY/gooTnC5QPVDIMYYuDAZXHIMQhy+FTiF2OK8HJtM7NHBoCpnuZgexEaXNNFjZhiJnad4ldnOaTFRV9WCxsZkJDLlkJA4Hn7FfvS1199dj6eBN2kQ/8rsCqVqYCWhqoFNFl57FCDvSj68LmTA6Fwq9DyzEJZbLZVE3odIlUliHE43SssY9DOWfn8J3r8XvaGV1AQS0fw3A+QYvDgzF+laHqgmUvHcJBG9HZ8mivootYbmkPfzxwHA29ubrhz4yez3kL/8neyzxxwfYKNAd4Tss3c6aWqPfwKpsdbWMlqbtTz6Er34xdim40iW+MipKApGPeMHnDA2oRc0OSIctrbmaO/u5X13EZNne+db3Cq9hfV31wsA3C1XZyHEax66ru+QmE9WU9ZMA4T2FsEFqjkoiAIDSlPR29Qk8RhxuWy0tBTixUsP5OWrgJU0RQjYxieOh0/oEuj7qGGDgz0mmdyVaIGfw1eYQ5aIxM+nr0JLRZPmo5rt3YsdxyywiAwbtPzqJNNozLNJgBIZK5EixGzrBIESz/yaqIoM8VWv+NtaxxSBo/bhauAq6gXAVFMT9vu2C0Zod22EloomVmg5YZGGN1T3WMBu7WGEzluFAgUlJC/aA79916gqZkej4KzqDtddR+G4Q5ji4LBrM7RVjmPzcVtM070hMtK4zCEJpbUt8P11B0rkFeCycp/ITcIyhyR09fQCr/Kp4gKOSvQz0GjxFbTd5Hg0G+85GG/F0+F1N90HkGPQxvgaJ73jhMDhT4aROKYdR/uwiWYCJhtEIiyvGk01mbS/NUY8QpCvJ2b6zaCq/XnPR96yTVSS5bS5qNKNE6QaMPqoBgF9VIOCenTXtEqsaiCJDbf4hETX7qrHw5yd9PfPy1dBT8+HUwn6E9G8n78E15LahLCOr6DHrfWBePWWj23sHg4te5d4lQLwvb29sLS0BEmSKC4uHuIKH8l+Z/nLT22fPeb4ABsFuiNkX4TT8WfBDkVh+ATSL0WFJ6gKQpFzUGXEQu7lPPyYkIeZ9wdo0PIDVdvvxfY72WwRFhv50AvcgrNMsHKKhSbPBqt/wNnpByz0VRIAuGpxakirSRsWtaCnmw03DRZc1ZmoyG8Q+N/zHb9RSWg6OoNeg8vloq2tHFXV/igsVEdyygyRPNuMzBUoLTMHI9AFSubCJYQHLvIDj2zrWzrp/yvo3cYx1VMC4IzYfxBLtd0gaxhB8xrftHYhprgOhsGFmGQ6NP91sP6IAx3SqDUMrIolaRuMmmCxczeMd6jDasMxoZK5j+UVkLJwN67u8+dxcNWZOHkmFTODsjBZ5w5kDSNwQp+EjeZROBzcJwR6z+/aALO9e3BAzQiLtd0hZxDG24zkVaPkF0p14cROIwGAK0tEQtXuKloizXm+zNfu2E/GHO8ZtB/LX9qJcSaBAt97GhGIFoYMQI5B+TVtgeP+SQaRMNWKxw1NFsJOsBCow4S/IRNMIgnPjFLxzOoW7XsvGOFUkpSFN+b7UJXU1l2Yjkd9iXWV6iY8qsH74asaSGsjUTHt7bscpKbNp797+TN7AaWY4Rp/Ilrepa3075hz0hnVRCrq7LOFtHpH2gpZ1bS2c8ubDlRVVdH89XfDUNWQ2r5AObIvAnMM00aB7gjZF+N0vV0UPUESGsMISo2x23pQ6R2JxD5e6ZNIR6T3JWjIsPLx7uY+KvrqtwFwmCi4ux+kdTL+CXsTNYw34mmgahib4zXjRzyx/idML43DTD7+7Qw/JZikEChrkiyZZjDrryF/P7icfq3jEV8SWmam0Gc6Omrw6tUdPHqkI7Co8re09AV49FgPtbV30dnJi/QMV4vUKeFpH+gLgw3fUb3p3r1YqeVE68cOBMkfQhEY2IJzhLm+I6bWYBiBeae8ceiIPs2xddyxDr7rlyN42WIkLFyArOmi9WofyysgYdEeXD54SwDg6mrFY45DEpVQFJFN32u9CXXca8awRrl+DFha7lBXPQ0r5e1CoPfs7i3QUtHEJg076JwLou8ZeycRqn7ZUHcMQIijNlrOC4Pb3guK8Lbej3lOv9G+rOgzC+NtScgSovV/nUwOU1xQi3/B2zoEbkQiYgxZeGIweBLYczKU9sUq3yg0hzzF+9RqFOfmYGXgCihdVYLVYaqaW4miErrKy4V+209h4iqmSRvJ5XK5qK65SRdNSUpWQn19zEfrJ7OyHDKsfMy+fhd52vJURN7oR3q829OHkBEbAevtZsPXIA2u6kywbpTi/v37IEkSFy5c+DQd+IPIX35K+2IwxzBsFOiOkH1RTvc7J6b1NnWi7vxDVBOpyL6+jwZz9a+f0ED3wcVFkk18Ynb+T2oa8dt5njKDnFEwJl08RmuJ/uIzBY5OP6De8u8fbfJMDXwCV3Um7trn0K/VkiRVRWr1anA5HHR3N+L160iUlJoIVFMSkP2Kn4bLIbtgc9sa4TmZ6OwRfcw7nCScd83NmG5KjcuW4zY4v2sDyD27sE7TXmQ1M37aw8dUU5AzjsL1zBeof985IteXJSKhqBeIHeoWMNuzB1c2rkTQikWImz8HWdOn4bEYBYRihSm4N3cFHNYcgu5+J1iqRwkAXH2tePyiR0W0/+OXBhlWPr69zatsNt3oNh0JKzCKQjWRiq1EDMYZ3sO8U97YdYwBg/2HREZ7PTavQuiahXhx3Qhs14XCvn1hMhBrgraKLMy0u4wpV5bQIFfBfSPGmflDlojEbCIK24gYnCTicJ5IQFCfqkElEQM2gzoRaTXdLRLUlhEpiCeS4EMwcYaIxwXnTLRVvqJ9811LgYAPvm57je3h2zHLSxHJc6kxfKly6KNHcsWpQwyHjjCYsdldeFxC0N/3fsZytLY9/Xg36O2C4y1zLPa6jnPKm/DGiCrW0WKyiYrmGl0D1/nn3yVymZ9QCVd1Jtw1Wbhx7RZV6e/27U9z8z9QsvSnsi8Kc0hpo0B3hOyLcrrfUWqsu6aVp4tpnIY32Q/BZE2kokXXp0Apliqp6u+xT3qAS46hhci72d0I9l+JxecPQNb4Ng1E5BnusLebh/YzYz/65Pn04Wu4qjNxWSsJ7B4OOG1tKPllFvJ2TELh3d3IerBeJLBlJSkiM/sAjPwJLLa+DDkj4YQlUUev0iThdLW3IT3oBrSO6dGvGx5UxRYNG4EjdH6APJBiMFIR16X2LOjdLsD1zJdYcJYpcfU3UW28fgiUVc/AZf02RC6ch/SZM1CsMFmstFfarHmIWbUaV3YdxDq1S5ikG4KlutEw0UwQALgGWvFYoCdI2fg2IAMyrHz851o63+sR0GdYgyRJXDfxRzWRChsiQaifk/VuY43meairnoSt8lYh0OusvAZhh+ehwOBnPLqsBht3H2xyTsEuzxQoOWnTG7apftOxx94IPkQCmEQSngwh0fXW5DQV1SX/jgK9QLBOJSFUm4VjerGYSUSJ9B0Op5f21aamdCE/bO1uhVqcGlSNp9Dj2hwVKfS+4ZqoRMd+H5loEg1lz4yPAno7O18hO3sr/V0LCo+it/cjV2EsvA09G1047NoIj70r6fmrwdgV1UQqOsxW/26Ry54uNrz1UnFJPRE2lmdBkiQyRZxCjYj9geQvP5V9UZhDShsFuiNkX5TT/U67586yJlpeqIZxH51PqaSOxyWGSGTKITV6HHbfdYcMKx/G180lB7m239NC5G/bXsOz0BO/Bv1KR7umeM/DHCuSB+KIe7Aw0UQr4xve5PkRsn3fN3XCTSMWvmZuKMixRWbsr0iMFwa2TJY8cnKVUfHcGW/fPkRHd8ewkmkkScJZcS4eGaG34XqYKoKw4KQnZIlIbLIJw/PaRql4jSNd8Yy/3/xgZjDgO+10IH5TsYftelVEzF+M/EGKMGROnQX/JVthslkbOw45YOrpIKw28QVJktAzt8ES3WgYa8YLAFxCMx6LdEVzkv8d9gAyrHx855ki8Ppe00sgSRKWZhdRTaQijhBO5ptDXAdpcgIPzWeDzRiLaoPvkaIxDVcP/Coy2mu3XwVnj+tjp90aTO3jlm/0WI0Uxi2xoDaPSEZYXwGFKxcy0FHahJ5Xb9BjLQeQY1BquBk2GgmYpS8McAf6XH+Z2/r6WJG+38PugXGKEW6tpTYVWfOno+Vtg8j3SmPS0GXEbQglsebmTKSkzqaf0YrnzuByPy5PlsvhIMloC/2bxp6cS206GP9ENcHEayNvcBljAHIscH3HR723pJYT8wLOmlH0qcQnWw9HI7qjxmefNdAtLS3FypUr8de//hUyMjIwMDCQSKi6u7sb+vr6kJGRwV//+lesXLkSZRIKmPfbF+V0vwMfqu1hHaqNebJC3a94mfcdHZVgJlILjMfdHZBh5WNbiK/kQNdzKSpbKmGVaYU5N+bQAHfaVSXouMmhwJbKar5vNh+/GnnRC+N8wh+x5isAv43Dzvblctl411KAFy/ckZd3AAnx8sJR20Q5PMjejKflZ9HYmAI2W3Ax/hB5JHFJOD8ZhkPFwBFuR/fzEqFUDtPXSiyhCj5Iw2v82BHdcUQktrqlw5VVDhXfB1BixIoFvpPNYzBJLwTr1C7h1A5DuC9XBmvmL2JBbZHCFETM+xU269Wgefgs5p3wp7nH/G2J8TVYG13EhRMhAgDXSDMei3WjIWsovv8ysTmQYeXje2emwOu/GvuDJEmYM87gBZGEl0QKlIhIzCJuwtTkFDLN5/H0nvtar8k/0KIxA69tz+K5axISTrvh1qHTcNotHO213bsOZ4/vBkvLBQV6UTTVgCTicZiIxUoiWqiAwkaXNLDZHLCulyJZh+Loc8ivcNTGX6KNTmraPCQy5fCqVvycwOVy4RVxBkWTqd/AXWMR6tvrxb5fEpOGzjIcdQUul4vKSh/6VCk5ZTrevBm8xPRwrLenBxGOdvRveNxAFw1WVJGbDjNKbaHTjC+qafn176Iy0N3ZC2eDIJAkCYszlmCzPy41RKx9QRxdNoeNZ2+fwTvN+8vBHFLaZwt0m5ub8e2332LJkiWIjY2Fj48Pxo4dCy0trSE/q66ujrFjx8LHxwexsbFYvHgxvvvuO6myRb8ooDucDNdhRjy5XC5aEl7SUaa6Cznofdsp9L6SkKlIZMohLm4SfmRmYnJcErhDTHpccgxyz36Dk/7zMfUqTwN3zo05OPvgLKqyPYU+08n4Jy6aqGIiEUovkGrmZ/GKISfRWHC5XLS2PkFVlR8KCo8hOWW6SDpCfOQiZJhPQO7uSXiXHjfoGEla2lfFV3RFNQGw6pyC09becDqmwleudzMSvNxgEEAlTS20Y4LNkZ5DORIVz/gT5dgcLkpqW3At4wVO3sjBDoNrOLrbHOfXHELE3OUoVpgiEtQ+llfAg+nTcG/hItw4pAETS39sdkyCql82gnOqoGAmOiK7UC8aZloxAgDXRDMBS4YAuLJEJH40iaL55N/bxQv8bxIRCgaDiohlGl9Dk4kpHpstBHsguGXIoMVsC94YX0A1wRQZlc02DsZR6y04RCyGmepqkdFeg/2HsOsYA3NPeWOc4T2RAPCI1wOEO+VRHEz1WHRYTgLIMWAHHpBoo5ORuYKiF1VdHdJPko3VUCKvgMIpCthzeSnKm4efnKbsmSG1T0mql8tmd6D40Wn6mc3MWoP29ufD7qs462xtReAZgv69DpAkvovPBKfPD96a6KPeyK0vmsvXfieVAV83ip9rY3IRHe8/UUW0z1h14XXbayS+TMTFnIs4HHsY827Oo9RRHOW/HMwhpX22QNfW1hZ/+9vf0MSnM+rp6Yk///nPePXqldjPVVdX489//jOuXLlCv9bU1IT/+Z//wblz5yS+/xcFdAFBqbGBUcw+nqvAe4cR8eSyOWi684RetOs9CsFpF10us/PWZjATfkIiUw5HmCRkWPlosJYVOen1kmMQY/9v7PGYKCAPtjxoObyLvPGuq2+DM8jk+cxcHsrGPJ3RyUQwvEyV0csQfm+H7Vd49cAAxY9OITVtrhhlhIV4/NgAWUxveJwOhrdGDB7LK6B85SpwOYMfgUpKCZhoEi32aJbL5aI8OxNX9TR5IGj3RkRdOo+3dbVo6ezBZHNKp/Zy8rOhvEOkfUzVhX4ApuqXDS6Xi55Xr9ASE4vX9vZ4uf8ASmeKVkEokVdArpISmHN/RsivC+CxYQ3UVHQx57QvFM1j4JP2HB7Jz6Dik4WNLmlY55QqdN8FetEw0BKkKDieCMUa3XCMGwLg9rcfLGNpoPvDGWpcxxORWEJEQ40IwV3zfXhKTgNngD9xGF+j3WwD3hjboZpIFAC1L0+GI9yQiUtEIvSJOKyxtYKSz8882TAnFUzV98NGDTucUNGA3e7NQqDXSnkH1FRPY5XWRcj3Ff6YahAFD6M0+rum3nmK3FAXuk8Mj5tDclwfZG9BIlMOz1+4DuknnLY2FC+cjxJ5BdxYNxm/3JyP7Drpq5J19bIlKuUsyqeGso6OSgHOfFGRFnp724b8nLTW8qYBfroavBLajtaQYebhSOBFevzrjG6iy3zeHyaC6e7mDpIkYafnjYyQ4c0VwzJp1qQ/qLV2tyKrNgteRV44xTqF5UHLBdYo/jbz0swvC3NIYZ8t0F28eDG2bdsm8Nrbt2/xpz/9CX5+fmI/5+Pjgz/96U94+/atwOvbtm3D0qVLJb7/Fwd0AQoIFt2heE+eS2meq1Akdxg7bU4XG298i+lFvPFmCbi9gwC+wtsovf4tEplyCGVOhywzA6mOvwrcq+3MWFy78B1WeykITBg7wrfj3rN76GGLANGDTJ5c51kIdtLBTOIWvVCuM3JFtsVM1Ln+CyU3/oP0SFmRwDYl9WcUFZ9Adc1NtLe/oLPM61+20IAid/pCvPG8ItynASYNJUDU0WxlcQFumugKAJ4wByu8qXxBv8cv/TkVbTSNRnPb8KM0/FSJ4SaNTdG5g62qF0FsPY3svap4smiRWFD7ePoMZCyYj3uL5+Paml9xadsauqDD8hPOIpUixLVf9KKhPwDgMjTjYUM4g2SQmGcahDWOKVjjmDIowJpNRGGZA5U0KcPMQ4AREw+IGDQYW6LDbDW4jH8Injww/oV2s7VoNLZBGRGHOCIJ3kQiSCIeqkQsPLcZoGTKdAQs3ECNq0kQ5F12C3DMx1vbCfVDziAMS7TdcEDNCOZ794goVrEBxvsP4/whG7gcuQXX40ykxT7Hrw5JkCPC8cyckrZimi2FLDE4xzU3j1JHKS+3G9JHunrZSHS7Tv+GKqZTMN1/Ju6VR0nla8M9QRgopzfQGhtTkJwys+9ZnoCXLz1GRO+3ofIFPI4fpACu8iYUs+JxqJCSFgu/tLkvqj8eb4wviJ9bPzEntaurC2fOUGWxL5y8Dc+TyehsEx2cGBGTZE36g1gPpwePGh8hsDQQpmmm2BK6ReBkkb/N8J+BXRG7YJVphbDyMFS8rUBVddWXhzkktM8W6H799dcwNTUVev0///kPCIIQ+zkDAwN89913Qq+bmJhARkZG4vt/kUBXEhsGd4r9vhuvXfJ4md5RFeAOdVTe24VOt+lg9UV1jzFNceWKKhXxsPw7zjv9iPl8pU2VripBw2sqsp7eG3qRGmzy9FiCBovvoG1hSC+U44h7UHU1xL1YXiWypITxyC84jMpKb7x/XyI2UYXN5uCyRiKlR/nrIfQ2DJ2QI+2C3n80W/u0DLctTQTAzW1LY9Q+FeSnc7lcLDtPgVO92wWiuiCxdfWycSenCuucUiEvhhLA3yboh2HVMXec2GkEl5X7EP/zYrGgtkRpKnLXbcbtzXvgtWUH3Devwvmd6+nv5qergYywOwhOe0wftav4PIBjwhOcjysTC07n6UVBdwDANddMwHLdaIwzjIB5H81ggTGvcpkiEYm1RDSOEnGwIhJwlWCCRSThaZ+qgdOlTMiw8jEtOhPtZuvAYXw9IHL7d5SRMxBM7sITgiqysIoQ3b+Q+atQIq8Aiw3HIWd1HlO85/Nkwy79hnEmAUP7hWEEpuvewObjNjh5UB3ndm0SLk2sugenNA2x8oQzJurfhZaxKd3fbUYXB+W4FhQeQyJTDqVlZoP6B62QYBiBwIUbUCKvgKS5ipjpRWlXOz/0khhUHvJ9IPVmarCILpfLxYsX7nRFxuSUWWhsGhwUD9cqiwvgorKTUtA4sAPP8ynJwf6KaI2WVFW7VtPf0G0urJNMN8+lI9I/cVZRUUEnormfop6ZrHsVn7QPf0TjcrmoaqlCZEUk7B7YYV/UPsy6NktstHb93fUwTDHEjZIbKGgoQBdbGKiPYg7x9tkC3f/6r/+Cg4OD0OuKioo4evSo2M+pqalBUVFR6HUHBwf893//t9jPtbS0oKamhm4PHz4cdTpRJmU2bE9DO2rPZVMg1ygV79OlGM+3lXhyWwGJTDmEM6dCPZABQ1c5zOAr8DDLTwmk/yI8e+A+7F0+m92JpqZ0lD9zQHaMEhITKXDtHrwS8y296UVzhtkN+DptQPP5f4Fz4zeJr3/r8HW4qjMRqeEt0fv7KQGSLOTjiEgcd4lEmIOVAIi5YaKDl0X59PX4NUc3X+JRI4qqh1/lSJTMk0DfDO9hgaYvDu85Q5fMLVQQr4KQu3QlXhkaoun6dRQE3cEpDUO6oEN/s1bejhMnTFGYXyQWIFU0tEKJFE5km6sXBZ0BAJfUSMBKHR4HV5GIxD5TV+gxbHDB+CYiCRYKieRBJLqYeGNsDwtfJ8iw8rEx9Br9HLAZXyHTbBEMTPQxnQiACcMCJEki2iQA1UQqNIg4oT6ONwhD4WRF5CkpYIn1Fl7xB99ZmHCWAXHFHwbzjwW2TBCWTDirXoHjfmNc3CMc7bXftRE6B9UQobkADcS/kW46X2gjxW+PHusikSmH4kenh/Tjft9YouFF86oZKjzwfiTCFCq+mUPq4Q5X5UNU/3t7W1FYdJyPj7sB4TnZI6LLW5KejIt7KHUF96P78LqC4ij3V0STj00Hl/F3gByD9yYHJZpXP5UlJyeDJEm4uLjgfnA5XNWZuHI6BV0dH69k8/8Fa+psQkp1Ctzy3aCeoI6FAQvFgtrFAYuhmagJ9wJ3pNWk4W3n26FvgFGgO5iNAt0BNlygS5Ik/t//+39CbdTpBpgU+oZdL1vwyiKDAgSmaWgvekNdQ4pEto62KsQyKeUCrbhjfJPJIrjmu+JNxxupvwKH04t37/Lw/IUrcvP2gZWkIEIZ4Sdkh/6AEt/vYG+lgklECL1wqhhboyojWKJ7dZaVIWKtAVzVmbhpxJK4j9XN7ZhgIizzxN+m6t6CmqqOQOlaP10NlGdn0iBwMDA6yVQ0x1cSMX5R/NwZp25h90E7MDZpCZXMHdjSp82Bz9IdILaexhbVi1DUuYOj7onICgmC96mjQiCMn5owWKSxoqEV440FPRKV5QAAIABJREFUx22OXhRODQC4NhoJ2KcTi58No8RGCWcQ93CEiIUzkYikPrWEUiIF8UQCYo3tkW+2Ce19ZXQ1A85BhpWPYwHnkW72C4xMdDCDjwIjS0RC1cyROgI2ozRSfQim0D1XHruM0OUKWOHI28xNdt9AF3+QNIopS1BjVPmmDUk3SunvfcMyC2tsmZipcw1b1a1w+uBRkdFej70rQRw5guXal3DESzjKWVZGUtqyBWpifVjUyYTN+qMokVdA/mQlLLHhAXkFF2XIGoUOqhUtrcqHOD9pa6tARuZq+lnPzjuJledjBcZuKM1qSYzL5SI7PJgeU59Tx/Cuvo7+P7Ov8qOnu1MfpeUr9JgrSHxS9ins+vXrIEkSoaGhaG/phseJJLiqM/Ew6sUn7centI7eDuTV58H/kT8Mkg2wJniNWFA7+/psHIw+CPtse8Q8j0H1++ph015Gga54+2yB7qemLoxGdCU0CSO6HW4Eqk0pjdxXFhnoetEXOZQwka2ztxO3n9zGptBNICKpimH3EhWxPXQdgsqC0NkrrNQgzihlhDJUVvmioEANScnTRPJsM7PWoKzUHA2+Suix+rvAd3ppPgH7jW3pRVTeLBruSc/QM0QN+jpLK6T+soOqG3+ciW4pIiFrLiaLXMCn6AXh4BFDAYDideIwHqeywOEMDkYHRvsGAgFRwFjUoh+e8RQbDztBb7serizbiZQZ88RHaqdMQ8DCDbDYeBx799viZ+0btLSXnEEYVmo5QlvluABgP79rA4z37cfW49aYrBckUaSuq5eN2VYJdGR2p34MbE4IFnrw02AiSycZVYa8QgqlRAqCCRYYRDy2EjEYTwgrFcgR4dhnfBa3TLegmfGfAbSEsVgWchsyrHxM8I4X2VdZIhJrTHxAkiQYDCtUEikoJAb+vmFYZ7YNU30pkKvoNw0T7fUgK6I/otrKC8kCSgnv33fhnnM+/d0j3Aux4hxLyB8mGtzF8hPOUD2sB4s9O4Wjvbs34balCR5GhKCxpopKdHzmgESmHHJylcX6ryhgOln3DtKnzUGJvAK8f92BSY5H+Kq5bYCsSZBYkCoppad/4yJK+7mhIYF+/pmsSXj+0he/OgiPyVBgeSjjcNhg+nrQY3jTTA/tLYKnJxdf1OHHhDw0Mvb2JdVO/kOpDHA4HNja2oIkSeTkUFSL1CCq2qOXbgq6O//vR3XZHDbKm8sR8jQEFhkW2HlvJ6b7TxcJaqdenYqtYVvBuM/A7Se3UdpUih7Ox+MrjwJd8fbZAt3Fixdj+/btAq+9e/dO4mS0gVJi27dvH01G+xgmAUe31XQvqvu4i7V2D9BT37fYSJDI1nhpJlxznbE4YDFv13xrNSKZFD82t2zo5Bcul4uOjkrU1ASgqFhbQPidv6XfX4zHJQTq6sLR1cWn7ykmYY3LGINwu4P42ZJ3LL76YgpyXjaJ7AenowNls+egUPFnGmxUlYh+rygbqBAgrx+MPUdNBbLrz+zZCTUjZ7B7hSdcafV4xQFjOYNwLFf3hMZuU/hsUkX5ho14LC+6uhh/ydyjygws0fDCTwMlrgwjMO+UNw4dMYCNsiA1wVV1N4z1SczV8RWpc8sPQNR8HqDndRs6Hr3B++Qq5HvkI5JgIVM/CSEnWEIAN3MAwM0lkhFKsOBCJEKfiMduIhYLiCgcNHWCprk9lhn7YZeRA66ZbsebvlK5/C3XfBYsTLQwl7gGmaiHVLEIV/GUEyWjYJrvmGsUgWoiFcv6eLo/mftgssdq2ueXOs7CTwxPqaKX/FzU902duGWRRX//9OByhOZVD30twwgc0TVFppYibqksEtp89G+qQhw1EeI3FffTN4j1X3FUg8N7ztD+sv2QAyba6/Oi157LMM7smsjNjCQqHxNNo6HiI3wCweVy8KziIl/y6Bw0Nz/4IM1qcdbT3YXw8zYCiaA9XcIb80NFz6Hv84CO4nJC9P5QKgP19fW0v9bXU/Nja3MX3LWoZys39uUn7c+HGpfLRV1bHRJeJuBCzgWoxqpi7o25YqO1K++shE6SDnyKfZBdl422no+vwsFvo5hDvH22QNfW1hb/+7//K6Ce4OXlJbG8mLc3jw/Z3NyMv/3tb6PyYh9i/XSDa9sp8XIRQJXLGIu3pqdoIPHaJQ9sft3FQUByhfU/QF4ah1m+vCPb6f7TYZBigLyGYpxi6iGRKYeEJCV0dwuDxa6uetTVheNxCYH0+4vFKCPMRlGxNmpqAtDRUTn4EdMgCWvvOnpgElIksBAa3S3CuwFSaW9DQqkFXVEJN0zT4arOxIMIyXU5NzhTQHeCQQh+O3ZGgK9qpbwdW9WtMN4gFBucU0V+XpKjXn6AFJZfA1nDCMw/cRUH91nBZv1R3PllLfInK4mN1jJnLoT7cmWc2mGItWqumKQXIvZeU/QCsV3dEqb79gpRE06oaODGrXD0dncLAKRxRCTmEFHYTsTgNBGHC0QCbhNMZBHJqBzAly3RT0HoAIDro8HEHR0WrhgmgtGnarBCRAEF3v3uwdzUAJnkErwdELkFOQZF5tNga6KOhUZ+9Gd+NIqETGIepaHrIFzel9cioGtuA5IkEWRyFdVEKvSJWEw4R0DRdwbt94TmFBhu05IY5Pa3fnWB+pct8DWg5MPcNFgoTqmR2B/6+5lhNh8gxyDfZDqu37iL6Evn4XZEmNt7Yc96BNsykBt9D2/raiXyv3GG93Dnl7UokVdA/KxFmKAfhvE2VlD0m96nKjEfP5EeIhPJxBVEkSVER3ABoKfnHfILDvOoCg+3o7OzdljPyFDW0foet8wN6PFJ8HYXOGXht4XJxSgz45sTX2b8oVQGcnJyQJIkzp49Cw6fJGLyzTLq2dJPRU/3JyogMQx73/0embWZ8CrygjZTG8uClokFtfNvzodanBqcc53BrGSiof3Dq/hJa6OYQ7x9tkC3v2DE0qVLERcXB19fX3z11VdCBSOWL1+O5cuXC7ymrq6Or776Cr6+voiLi8PSpUtHC0Z8iImiGwwEueS/0GhsSYOOBp9icLoGHG0NoD1wyTHIOvs1NNzHC046V6fBIdsBta28hXNlZhYimIq0pFFPTwsaGuJQ9uQMMrPWiAS2ScnTUFCghsoqX7S2ln10yaCcl81Y48gr9/qzVTxC82ro+7xQ3oMSeQVUn9AG81oJXNWZCHfOl/j6ql73sUXDBpbKO3hVsHZvwa5jDEw0uDvkIixJ8s6004HQ13VHg8slRKzbhcyp4vVq+0vmXjlsBAvTK5iuI5pSwN/kDMKw6gRFTbDftVGYmqBuhSl6QVhvx0JMXDkcHTNwzoQJ/wGqBoO1EiIV4fopAgDXXiMRO0/HSqiDG4GNRi7wMN2DGsZPQr5dYq4IexM1LDHyFvn5H8kYnoaulehqbv1N2dQVJEnC1vwCck3DsNFtGy/h7MoCBK2a3BfpPC8VyO33g4r8BppH6XkqGZWPGqXyh/623YgncdVTSPFCORw2asvLcP/2DfjqHxJZrMLn1DGwrl7Bi8I8hD58Ifb6y9Q9Udx3KqC/TZfyFQsnKPbpBCv6zoKc5QWR0mDSVO9rbS3D/Yxf6TmhpNQYHA4PNEo6JkNJlAHAu/rX8D2tTo9FVuhtsXPOm+5emF/JQrOJCTUX2nwHiJJD/B0tNDQUJEni+vXrAq+3NHbAXYPaUBYkVv1OvRO0HnYPHr15hIDSAJikmWBT6CaxoHbGtRlQjlCGdaY1wp+Fo+JdBTgfubzzcGwUc4i3zxboAkBJSQlWrFiBv/zlL/jmm2+gr68vVAJ46dKlQpSErq4u6Onp4ZtvvsFf/vIXrFy5EqWlpVLde9Tp+mwougE5BhwLWTRY3qSBR9PtJ+CK4q72JbL1kGNwz/7f2Ok5SWACWuWtAP8L36HVc7HQR48WleAMU6VvwRpPSwLxN1aSAnJz9+B55nG8C1oHjsdiiSu2Ddd62Bx4JD+DglkMvSju88pCaXYxDRBbU9PwOP0VlbF8KhmcIaTVOGw2ChNj4XSEV67Xbvdm7FMzhoL+baFFWNyx6sBoVX+VrPlaV3F5uTKYMxeIBbX5k5Vw55e1sF5/DAf3WQmUzJ1oEg3fPh1ekc0wAnNPeUPliAHO7tkuWK5WeTuII0YwP30N7oYJiCJYKBpU1YDXcgZQDWKDHiPuciHcjvMlmR1PwMbTMfhpSIAbgbVGbnA13Y+X5hOEfLqBHIdYxjosNxqaPvDD2Xga6P44RALhYuNrYJAMHLJXxVyf2XzFHw5g3dFz9PhPPT30JkJwzCNx/WoRXPvG4qpROhprWgf1h6FaluWyvmPznwG24Ka1oSEeMRETcfvybHiQJM7t3SEEep0ObIf+sZPYqHkOinrCkmjn1h5GibwC8qZMxc8nKSm3nxhXMMVrAc1R3uh3YdjP5uvXkWAlKfbxcRVQUxMw5DMy2CZi0Hs9f4bLx/bTlQcfpwxeNjipugmlJqloN1tLjXHA3mF/z5EyFxcXkCSJ5ORkof/1b9x9DdPQ2/Npo7pcLheVLZWIqIjA2QdnsTdq76DSXhtCNoBIJXCj5AYKGwpFSnv9EWwUc4i3zxro/p426nR9NgQnt5chhzqjazQYeRf/UmwUo+X6Nvhc/B7LvQULPCh7TkSM/b/Ryyehw+H04O27HDx/7oKc3D2I71NeEGwTkP1wO549c0BTUzrYTU+HVbHtY1hVUztU/bLpxXEicQ9mm0/g8XKqElpzXRsNxgYCkH7jcjgovZ8CHz7VAftdG6F6RB+KeoEiF2BxiTJcNhvR99LokrmuK/bQn7u5aJNgEQaFySjfuAl+W47g+C5TLFf3hJzB4IUXfnVgYam9YBJPPzWBsW+f4PH2ro3wPaSN9BOeeGnAGiI6m4I4IglehCDVQJ7v3jMMoqCvz4SbBg/gXjVKx42bj4YEuCuMPOBkeogujjAw4fCS6QGomtiCJBkwZlhIBAi/d+orFhGXO+R7J5rcwmpXXhb3L97zsNyaqsi3+8BZZEydDebMhVKBXDkiEjoGvLEIsslG2zvhxfxOTpVE11vnnIqw/Bp0V+XyxifvhsC1mpoz6OdwvFEo5Ih7mH/KC8rHzEHsVxEZ7TXetx97jppi4SlP/GQYDkWd2/QJwuXlu+n7jzO9gckeK+gxcs93l+o0hsPpxdNyW74qhQvw7l2eyPd+DI7ui8I8OB/8Ded3bYCLym94WTj0qU3CrWJUE0lgM76lxjfbS+Lv9ymsra2N5udWVPDp5vZR2N55HYabOpXoWXQzfESpFY0djUipTsGlvEtQj1fHglsLxILaJYFLoJWohcsFl3G/5j6vKub/ARvFHOJtFOiOkI06XZ8NorLQbT4NtURIH0hJRlt2nchLVL+vht0DO8zl23VP9VOEtpsccmy/BrePxvDe/u+ovPIN8tPWIyl5qkg6wl3mzL4IjTza2vjKUQ6nYpsUMmeSGJfLRXRRLeZa83iaS81CkVnRCC6HCy9d6ni9nzPJ/7mKvGz4G2oLAIMIRzuUlJYPyUmUpGSumjIJWSISCzV9kTRjPq4s2wn97Xo4quuJZy9fS6zb29+UiEgER5TC1CIBtlqucFbRxPkB1IQr+w4iQd0BT/WiBMDscyIFqUQSbhJM2BEJ0CTisImIwXRi8GjodIMoHNOOgwt/khmRjuLkarB7OHSy0kC5sKVGXnAwOYJSc0Uhv6hmyMHDdA82GrmgX6N2nvEtepH/SQLFg+88kiHDyse/wx4MDkgtL2CK9y+8SJPbBhSaRsCCEOT1zjx5a8h79vvBRMNImOnwxiPKvRA9XcIbn+rmdiy1Zw15PaGNU+B+aqwclYBe3mlaY3MB/UwqmglvwhT1AnHQ0AUhDtY0CBTY/OzfAV310zDYrYE8RUpbefNhR15fTO5g5pWt9FiZp5tLlOHe3d2E3Lz9dN9ycnajq1u8BOFQCW5DqS48Sk7ExT1Ucuhl9QOofzF0MQV2SzcqTNJQb+TJ88WmP1YRhrKyMpAkiTNnzqCr/T01L/pt4MvPGIuEU2bUJlMjEGyn2R8lkNDR24Hc17m4+ugq9JL1BpX2mnNjDg5GH4RDtgNiXsTg1dsX4BYEfbT5/FPbKOYQb6NAd4Rs1On6TIxubqfZItQQMagmUlFDxKHDbrfQBFNYlwPdJF1M85/GU1DwU4KVyzg8t/oH2s9+hWqPb1AU+B1SYsaJUUZYipISI+RX3sVEZhLGMe+DlTwDiUw5lD05w+untBXbJJQ5G47VBIdB+zeCpgrIElQFsgDnXLiqM5Hg+5h+b3VJMQIYBgIgIMTujMCCOZCTePxyEuL9w1Hn6oYqDU08WSi+ZG7Jz7NxbZUyfuqL0Cro3hEAyhUNrWIX+glEJH4lonGAiIUJEQ8PIhFRBAuFhknIPxWA0COmcFYWpCY4K29H2BEzFJwOwiubTDRcKUTw2XQY9qka/EJEQU4KQC1LRELJIAqap+NxiY+i4GuYhkJWtdCxaX+y0kIjP5w1UUex+TQhH6hjyMLHdBe2GV2EqAIM041u00B3MiE+ua6//cc/HTKsfHwbmCH6PUYhAjJaU31n4MD5AzhjbotqIhXRBAVAh4qiD2zbzqfA0ziNHpPkoCcIza0W0j9+39kzpFqBLEFF6YWSuepLAXKsUNQxPCeTfkZ/PnNV7DXD8mvA7u1B1aNCJF/3gZ+uhsho75WNK3F11SosOumJcYb3KN988xYGyQb0uKknqKO9R7ymbcv7YoFE1LInFuBIAI6Hk+DG5XKRFRJE999X5zhaGupFXF3YmsPKUU2kot5cnRpXp+kSfe6DTYqNfUJCAkiSxGVXF948OaA1m06Ga19U97HhDtHyZ4Pck81h40nzE9x9ehdnMs5gR/gOsdJe0/ynYVv4NpD3Sdx5cgdlTWXo5fDRaUZwPv9UNoo5xNso0B0hG3W6PhMR0W0324xqgklp5BLhvJKVZ74CmxyDBPt/44DHBIGJamngUnjlOaC8zAWPgxWQFiUrEtimpvyM4ken8OpVEDo6eIkOPRwufkgqgAwrHzGPLtC8u/7saakqtg0n+iuFvdi7j8oo1zbGBheeRJiSaQyOa8fB3/Q+XleUI9iWIbDYB5IEakofC1yL092NjsJCNF2/gRoDAzxbs1YsqC1VmornO3ehztIK78LC0FXxHFwOB5dYTykgZRSFdU6pAsk7YXnVmEtEYQcRAx0iDheJBNwhWHhAJOPlgESwJ3pRiFe3h+e+A0LUhABtPeR5hqAl9xW6X7WCw5eNPdyKVooGkTiiHQdn9UQazDmeYOG6fzHa2rsHDjvwrgbIcAXnyjKh37SR/AHXzHZgp5EDxg0RpVUgQmmgO9NoaK7st7ep8r//8RP+nj+R7pji+Stf8Yf1mGXuTl//sVEsXhApmH86EHlTpiJw4QbMOXFtyHtONIzELp1Y6GvFw/F4IlKjK8TqH8+2HkwJgteCc8QkFt09Ro3jeXmgpwMAoOYbRz+zi6w9xF7zgHeW0OVaGupREB+FkHMWcDqwXQj0Xjy4E+GOdnicwkTru2ZceHiBHr+d93aKLBJTW3sXrKTJfVz9yaitDZHiiZUuwY3DYSPBy5XubwDDEB2t7yW6T29TJ6pN0lBNpOKlDaVsgQgdqfo6LJMSCPr6+oIkSUTaHhx0Xo07dQau6kxc07wJDuMrwYIWfPfknvkKdZZ/R5z9t7jg9CMOeU/FnOuzxUZrV91ZBZ0kHfgV++Fh3cNBNzgjPZ9/KhvFHOJtFOiOkI06XZ/xRUq5jDFoMf3/7L33W1TX/j3+D3wfc3OTzzUdxQKCPbFFY4kmMZaoSey9YlcsDP1IERCQOipIFcECSHPoDL13C70z9N7LMHPW94cDZ2aYGZhB0Zv75vU858kTOXPKPvvsvc5rr9daJ2jgU6/phSG9ORT4vfUJvCy/wu9OSvRgtdxDFdeezkNI6kEkpWySrIwQMQu5wUtQnXoV3R1vxuTibUgrwPToHFiVltHauAWFutQf5XBskzv7K0cMlJQIitDi4jDE48M5oRwqeoJitTXXQ6B96CQ9UXowLqMiJxN8Hg8DZWVo9/dHvYEhyv/ejfz5C6QC29LNvw9b5nqi79Ur8AfFwR+PT2K1GeXAxfDIRE9mAzrCKtDimY8G6yyUaY5dAFZxk424Cw5wOnpBjJpgcvwo0gJ80N3aIqElBCFvEZTKTRZOXAqHjRDAvXM2Cn9dCcMcOvs4nGnragBSHQGX38Sfn5kCEHgJiRE+UGTIni2dwQiigegqLa9x9/8iKJ3S0H0gbAARiDkWl6HqtkDI/EEdCoxAzGC8hKa+IQiCQKg2VcRJnHGidIiV5mHu9RdyfRDM1KT0YyfyMSF8DKkFV61lgMG/qTZNsgMALDN+Sb/Dm0xtpR53iWH4mH1jaHAQFblZeHnmGO7v+EU827t3Gzy11eFwn4H1Nt9jvtt8/Ob7G8o7KJk+Pp+LwiKCvpaImB9xzfPZe7fxHQnuQD/8zQ3p6wu6a4IhCe+dtGj1LgKHEY/XeqHgEcPALP/le7s+iSEnEOTxeDAyMgJBEHhFLBtzjGzRnk+/owUaO2iL4s7eZiQzF8HR+ltcvKeI9c7zpILaVV6rcDr8NGyzbBFTHSO/2+UkjucfMqYwh/SYArqTFFOdbjiGB0mS+DfatDVoANSo6QCe/tdoMvwXbGy+xY8u87D0kSr+fjYPWv5z4R1M2eiKKyPMQ3b2YVRU3EdHZy74/KHxr2E4zuVVYnp0Dk69qUBl1UOaq9vXx5EvoyvPvnJGg4kJ8pWUUbxhA0ieYIItKuPgj1sCLuNMjSAcvWKO10wmGq2sUHX8OAp/WCYV1BatWYPq8xfQ/MABPUlJ4HV2ip2bHOJTBgpvmtEZU41W7yL4WqbQ54xjxMikamCrEQmtKx7QOMmAyShDB+N9u3DkpAaWX3WBfzZHpjaRteBH5SYLx0YBXPOzUfj7ShhmCxWZLWY8gba2OrINV4Mc/RxNvgX8zgLFEbRck7xAW4HBooHoz9pjW+9+x2BhekQWpaFrRX1QzNRzxbwHAm7hPMcNmEmIZj2P6tqAIAjY6NpR9IXTLshXUgZr2Qbp59NgYcvVEJy9GI7tV0Ox5ObYnGZ5tzEltIIuU+17ZyYw0IXZ2iyERc5GFFsR2y3uSD3mbO1gmfrIUGsrCpctR8aCBYg+exK+JvqwPrhTDPgaH9qMs+rrsMdiPRKKgpGRuYceWx76b4OK7vP3auMrHL2dHfDSuUZfC9vNQapGrqTgNvaCM/xh6cy0HB5nPgX6xd9lqTGRugI5gWBNTQ39oddOfDvu71iXjcFUY+P+RU9oOX+PbX7bpILaJW6q2O8wB7dtFRBk8QUq0h3eXdprEsfzDxlTmEN6TAHdSYqpTicIflMFmol7NCBq1jJDofHX0LGfgZ1PlHHdTwmOwbMRFiWesWVHzURG6AKUllqitS0ZvHeQdrGtbMD06BysSc0Hj9eH+ITllDZmvqZ8g7k82V952mlgAIXLKSvcpnv3AAA97W1guznAbu92uG75GddPP8F8IYCy6oKbmApC4ZKlqDx8BI0WFugMCwe3ro7OdJN8EkPt/egvbkN3ci3aA0vR5PIGdXfS6UlUeNvNoDLJO0b41EQSGpg5aH1WiM6oKljaJGPTsKqByvVn2KVmBO1Rqgkjhg4bL9hA8WaA3Lao4xX8zLvJwtHLYbAWArgWZ6OwWwjgLmA8ww3tG4jVXYMh/VGT2u2vAN+TQEEwMDRAL0OPcFXn64+tbStpu6pnCoIgcOi2hwhoGvnvHG0qg/qdbohAQ9ckDLPNtETMH+ZaqUFB01/s+Ju03SgwoW+IKkYsCi9R5iJWvx6ReD0zNKgs90j76J2PxIvESrT1DGKbXbzc9ydXRhegaCEjhUixdzBbOxiBYfMRxVbEbmvp6hSyAl0AaPX0pN+B3sxMcAf6UZaVjkjn+3h44bi4NfGeLbC88DO8LJbB6P4pqVn7idr4Ckd7Q72IGkpG0Au5dblbvPLBYcTjjUESHj84SLWly29yXMQEeahyAsGUlBQQBAFLA02Qo/YjiWmoMPo3gsy/gImtAg44zMEm5m90v9xheVgE2G57qAQt+5nwsvwKr29/jsHJAJ+TNJ5/6JjCHNJjCuhOUvzjOt17VhAYCV4PF433cmjg9NbCHHd9VGHPmo3gSHFgG8VWRGrgdyh69CWabT/DkOEn722ACW/uoLiQMTkY4PNRVe06nNWdg96uYtmX5yYpA9ARFERN1Mrz0BoRgfRrVxC5eiXSFi1A3vAEHrBVB1ZqUThw9hldIKbAYOGM1iOUPvVFf1ERSB4P/F4uBqo6xagGNbqJ42vOaieg/m4msh7m0sf3jyoFr3tQbHL2y6jApgs2Eg0dtA8exK5hQwdhkCetQGeskFTwo6LBwpHLYbARKjKzPBuFvVfCMEeDBVWGN65oaSJSdx0G9T8VeT59+p+DpfsLmExLmjc6cp7RXNWJgL6rBndBEATCIyJEuJtHXdOgF/AGSwzCocBg4VvjcBroznU8RE/wKk6roWhgLfUcKowXdNYsQzMQHEY8ChatxNm9uuJgUYMF9QsRdBupX4zApjvRNHCbKAd69DauzW2o5nDW/Busu+WLZyyKPnTEXkvqMZcYRsjcR8ihIZTt2Il8JWWU7dgJckiw2kOSJFo41UgPegEnzcMw37tFDPje2r8Hx09cx88X7TD7pngRoTw2vsJRX1qM+6cPDmvk7kBBoriu7HgxWNtNv58aXpmoNplLfzTIFO/CQ5UTCHp7U8WYzy2uotnw34gxmw47629x5v4srHJRkZipvaFpC6YaG3eve8Mh1xFJD1ehw+CTDwM+pzK6//MxBXQnKf5RnW6SKk65zb2ovZNED9BpzhcRJSFrm8BSQL7nl2iw/xyDxp9M2gBT2TdAg4q87j7weP1ISFiFKLYi8vJuUPcpi1f8e+R0kSSJwaoqdLxkofintbTSmz/IAAAgAElEQVQurTQKQsKOS9Qy39kopIUmY/tdgazXfO0QONxJBMcgaXwwy4hHnUkampxeo82/BF0JNegrbMVQSx/IYUMKw5d5UGCwsPx2JLhCBh4kSaKuuBCRTkzYH9sjlZqgoPESMxgszNMNxVZb0SK2icRIpvXUwzRc04mBrZAO7sOrsfBwysU5x1iYWdxGpP4mDOh/JvI8BvT/jXDdDbiopY15DF8oMESX28fLHI+3jciSbbCIgauHJwiCQGBgIH18YRA9su83dyOpPslOh6o7xcdVsj0EBS1xYw9pWWNfbVdwGPEo3nQMP6uJGlSo3mRB/1wk3U7HLodjuWEk9jkm0zzU323ixCTVJrL9Zh0HvYA3CMytRV1Hn/gD7G4CjCnd19h7F+AWsAZRbEWceaAu9Zh6AW/k6iO9WVn0u9LqKardy+MNID9fE1FsRfiyZuPI3ZU4fX0tDI78JgZ67+zZjitHTmOnmhGWqHtgJuOlzDa+wlGenQHbw5QZhv2xPah680ruYwBAs9tbakXFPB2rXwYJ+jUnQ7YDvMuYJSMQ7H38FzIbMmFoRtF2jjL3S5f2clXB0QezYWnzHcLvTMdbveV0Hy3Nbvyw4PN/hKNbzeH8czDHB44poDtJ8Y8Buu+54rS/vw51dS9QEGeESr0QcBjxqNJkI81zPw1sg6KUEJm2D5zUm+gzGWcwe48DDJ8kMTPuFaZH5+BFQxsAoJrjQZtH9PaWy+YV/w5tNtTaiu7YWDTZ2aPq9GkUrVgpFdTmqqoid+tW1N62QOuTYHSE56P2WSE9Iby6QSkb2DKioCIEDrYxQmk+bQ2RjEYhqkHvqyYxVQNJ0Ts4hPkEtWRvE1kMAOhubUFagI+ITanlnq24u3cbNE5fwKYLNpitEfDO2Vtp0d/DRUpAKRwvx9Jt4HglFqn+RRjIDgS8jwLGX4g8C67+p2DrroW6lgbmM0TB4+jldlm5wJK2OdohOCpUvBQYGAiCIPD0KeWmJRFEa3ljhpcltcoQHgpVl2WYZWwi8zl369yjloh17oDDiEfJAQso3gzEfCIMexyTsd8sDpYXqHayV2ND3TieVlAYTaWYjG21GRtXn+XAPakcD2JLcNQlFc/NTgHENAwZ/gfOLyhr3SsPz0n8/WytYHT1y29rW6uhQVF4li3HUGsr1Xf6a5GesYseg3JyT6Kjtx5qkWqY7zYfP9ktwZ6bf0H9yEmxlQnLPVuhv38v1C/rojQzFdz+fqnnFqa9nNJmwmLvtmGN3CNoqqqQ+14AYKCyk/44TU+ohNZjPYCYBtL0O0BWju+7AEcJQHCImIZC48/ga/ElCLsZ+NNxLha6L8Ay52X0SsNPDj9R0l5uqvjLcS4IuxnwtfgShcafYWj0ue2WItAyGUw1Np4Zp4HM/YDg8x+kusAnSXD6BxHf2oVHNc0gSmpw9HUZfkotwFc+4f8MzPERYgroTlL8Y4DuO37NcrltaGgMQUGhHpJTNiKKrYiUZ7tQpRVJSeDohCH6+RZYs+bANnonMqtZguXvjzDAbM4owvToHNwurQUA8PkDSEhcjSi2It68vSr7gWTI/vL7+tCblYUWNzfUqKujZOMmqaA2T5n675t5qkjYeQb5Gu6otUgFR0ecauAyvFQfcyWGphq8MU/DqduC7O4srWCYBL5F74DsxXrC8SStigIb2sFIYsfA10Qfd/duF5n8Xa+qIS3AB12tzXLJK8kbA71cpAaV4eEVIYB7ORYpLhHof3YBuP31qH7zKRqZm3FT+zoWMsTNCKQtR8tbdDYWmI+KigJBEHB2dgYgDqIVDa2g4vQjZgSYUIoLL/0wQ2d8hQYRIKnlOczTJVDCYKPsajB9XQduRcPhUgyYamw4XI5FcU7jO2WrZd2UdEJo/rGkbQHjGTr1qY+RYB/KvEXT9bhEkJtR0Spb/xjFqb5gF443iynDk1odHbS1pdIqK1FsRZSV2YAcLmDi8rlY73aOzjQq39uOuRqe2HjBBidOXIPBfnGzCusDO+BjrIus4AC01Qn6D52x13iJPWoEvb/mwcPYfDtowh98TY6vwGHEo8E6C1bldQizG7b9fX5E9oO8Aw+V5Paj1m4xwsy/hKXNdzj6YDaWuUqmIGxmbgZBENA30Ifbazdklgaj127UauGIrrLh/wPct9GJhNqSdvr9rsiu+7Bzg6yreR8gxgKz38Xm0quSo7fPn08BXWkxBXQnKf4xQFfOL/2hoR40t8SguPg20tK2I4o9S4SGkPHoOKoZseAw4pGnF4Bz7ltglmoCTpeUCvsPPMBcLajC9OgcHHktMFSoqXkyfP2z0N1TLPvBhLK/5IO16L+7He3WmqjT1UHZzl3IV1GVDGyV56F4w2YU7TqJt7sZKD7pgPz51MRcuuPmuFSDICIFTDU2XlpkilANACCmsBFr7rBFsmrRhbIJ0Y8En8/HxjsRUGCw8NsVe5FJ3v7YHkQ6MVFXXCh3MY28MdA3hHRWOR5ejaMnQIeLUUg2u4c+43mj+uknlPNSujPQ04yufi5maY2tKjA6YygrV3W+fti4YD45ORkEQcDOjpLTokG0ph/mWp2mgcG3L52ojK5HotygchYjELr6t0AQBGK1fMBhxGMdIwS7robCbrgwz5WRAO/IUvxuEyc3gJ8IKJ6pycJ682iklDWDGV2CeUKyeCObhfZJgJiG3KffIIqtCBufI5ivHwYlnWAsNYyAXsAbmTO5kjjVMzVZuPKXBv2+xbvOoaQIYxeiqTlK7Bj+2RzMsbgqULlw2IgZOp7U9Wq8xA9X3fD3mVuwv3oRlnvFs73Ol04hwvk+duu6Ys5NPxw/cYP+29UjpzHnxosJF7T1l7TR739fXgtO5hah23A61ecz3WU/kBzjfMdAB5JqkuCQzcRFvz+xzl2yCcN89/lY5aKCM84LYJdsjNjqWLwIorjjLi4ugnPLsko28izuUqY43qYZINsqPyz4lOM63zUkgdkjMoBZ4W1R4lvsyCqGekEV7Cob4J6b98/AHB8hpoDuJMU/BuiO86XPvzUNbVb/RpnPYmRk7gE7eq4YxzaSPRue4QvxwlYA0pJuecMzzR2dgzJI33zAAcahuhHTo3OwPFlgrMDnDyIxaS2i2Ip4/ebiuMeQxTJXRAXhh9Uo+fUQyv7UQcVJJ1RfixC1tD1oObzvPFTfYAmoBmzJVINX0dVgqrHhcjNBItjsG+TBLLRABOid98xCQ6f0JVdAQE24dU1QHHTt8Enc3bsdvib6KEiKk0vzc6Ix2D+EjOAKOKkLAdxz4UjSuIE+vW9E+6jzr0CqA9Alah8tKw1B3ozuuOoCw/Hq1SsQBAFTU1MAFIieSTwQNX94sBlfBCRRGd2HsgNR4e2MrgUIgoCnlj04jHg4qAuUJ0yvRGOz6di2vaPv7fdhLvUIkP/RlD2h6wrIqZH6DFQYPmjR/xr5nl8hiq0Isye76L/9ahUHbb/X8M+uoe2ppcVYnGplhg9SVy+iKEC/zEVy0i8UNWmM48wxvQVVt4XDxYA/Yqb+Q7pdRkBqb2cH8uOjwbI1B/PEPglKDgIgfP7oeczUCBRrF1mDJEk0MqlC3gZmDkiSxMmXjwV9v12KQYfEDil55W6QmIbXtz+Hl+VX0GTOxLan68aU9jrgMAcm9rMQ5PADKh/vADmqYNnR0REEQSAiQvYiQuHgFLTS/bcqr+WDzg3vOyYDzL5sbEdedx96eOIfTP8YzPERYgroTlL8YzrdqC99kpiGTotPUek0Hdk+3yA6QlzLNoqtiOTU3+GfchBnA1ZjufsCuJrcoYFbvi0bAz0SilH+CyK2tYseRIQHi9pab/reuroLRH7D6+hAd2Iimh88GN8yd/4SFK3ZhdLt11BxxA5VV4LEMrOVGtF4q+6HlItOSNN7hKItfyJfSRlVp87IlCVtrOykJ4OOJuntXFjfhb/uJ4lkIh8lV4AnlAEeGhxEYXI8XghREzZdoKr9l9/0Qqo/RU34EDHYP4TM0Ao4XxMA3AdnQ5Ggfhm9ukJ6nI7rKeOBDuk6vBMBrRMBx9KipKSE5ir2c/vxi5s2DaJU3RZijsVVKDACMT00kwK6trIDUuHt8DVK3eGOzi1UM+KQfo2id6hfiMBsDfmzslts40VoAKr64hlZWQDzcbf0MZ+BofY5FLt/gSi2Ipx9Nkndb6VJFC4+ycaj5Ark1XaK9F1pz+v7W4/g6v8T4u/Pot/LlqceYz6vEVUPRcO7UHVdSj0nl++haGAjlWfO5/NQW5SPxGceMDp5QqI1sfbBQzh4ShurLztgFiNQroK2vrwWeszoL2lD8+AQrF3OA8Q09Noslfk4AIChAfBtF6Pc+HMEWXyB27YK2Oc4B4vdVKUC2+0PlaBtPwNPLL/Cm9ufgzsObWBwcBC3blErDAUFBVIuZOwgSRK+dzLBVGPjhUXmpK8avWt8aDA7VvxjMMdHiCmgO0nxT+l0ZO5z9Jh9imqH/+DV868RGzZDIrBNil2OgkJdFFY9gXWaEVZ6raTcy1x+QKChIz0gt9wPB9n/3wlyAaBhgEsPMNmdgsmLzx9CUjJVHJOdsB+tHo9Rc/0mSjb9Kh3UzpuPwpWbUbL5HMr330HVeW9Ua8QKqAamFNWg1iMLibec4Xn0Ih4cOIC7e7bhie4NVOe9xkBZOX28Lna0TPfA4/Fp/mVhav2Y+/L5JJ6kVWEBIdCC3W6fgNjUV4h0ugf746KqCaYnjkKR8RIKDBa8Uivfqa1lDe4AD1lhlXBWjxYAXLVQxKtfRY+uAjW5PlgNxN8FWiVn5UaHrDQEeVQX5Fl+rqurA0EQuGZ8DbsDd48yf3gABQYL32mx6L74zTBVRN7t3BE9GlC/1gxBuUYcTl4KxwwN+Y+lwGBBWTeUvteJ/F64Xcd6BnMZfnjlMjzWBKiiq5+LuKIm3A0vxD7HFCjpSub5ztcPwxGXNNizi7GDmSCmFrHF3AIBoZQ+b0TULARsX08ZpqxYCV57+5jPbITru8fNBwtdf6QKqdwX4UVRwJi/a6urgdERSj7MYs9WMA4dwe1RRimWe7bCZO9OMM5exauoUHS1jP3xSPJJNFhngcOIR5MjpdTAbulEjiXlNDZovXBcGcjmvmZEV0XDNssWp8NPY5XXCqmgdp3rfFwMO4mHrx4iOcEMnbJIe42q2ygvL6f7Ynd395j3N1ZUvm2hx4GawrYJH+d9hTCYdf/IYHas+Kdgjo8RU0B3kuK/udP199eits4Hb99eQ0LCSonANiFEAW+ffIW6+/9B//3FeNuQg5txN7HokYCvtenhauToPqaBXYfOZZD608aWJJskvV5ZgyRJKMe/xvToHDypaUJ/SSlaPb3BUddB7rW19P3nbporTkH4fh2KNx1D2W4DVJ7xQPUNtkDV4LkQ1aCuB/xBHtrqasCyNReZ7B7dvIiyrHQ6U9FgdodyQlu7TkT3c7wY4bLFehXKtH9z9wAuPEqlAcEMjSDsOGsMk707RKgJd8PyKUBBhKF3cGKFbLIGd2AIOb7JcLkcSk9s99XCEKd+Dd26MwDmCkontLlE7mNPlIaQUdEqlds7S44CqY6ODhy0PIhFroL35YcH5zFTS6DP+q1BGD0Rfmcgf+ZUgcGC5XZ1GOhSck4h2p7gMOKxlTGxY72vTZaMrgKDhQcPtlOrQ0HfAY35on2Dx0dOdTuc4stwxiMDSw3H+xB4iV13jfEiZCGi2IoIDJuPLeYW+P6yJ3JVFyJfSRn1BgYy95+a7hoRhy6n104Ss4t1xYW4d3I/LPdshdneP/DzRcrOeKZGIFZdfoj9p3WhefCwxGzvoxsXEO/lBk7+G/BHAZ7e3EZ6XB2opOhf93NTwR8p5Br57/BqXK/tYqSXsOD6xhXqMer4xecX6dJeHktwzH057jr/gAiP31Cf6QySK0RrmqBCQ1xcHAiCgK357Xca30mShLdJOphqbPhbZcv8u3eJ9wVmd2ZPLpgdK/6bMcfHjimgO0nx39TpBgdb0NDAQkGBDpKSN0gEtrHhs/Dq2dfgOE5Hj9mnIG/9C3xiGmLuL8axl6J6iD89XYNHdr+gRtN3eDCOQbfOvvErYidJr1eW4PVw0ZNVhiYHX9hf1oLHjr+Rs0iUV5unrIRYL6o9Eu2UULxuL0p3aqLipCNqTePQ7JGHjpBy9GTUY6CiQ6KBAgB0tTQj3NEOd/cJVAqcL59CQWIsSL5Aj5Y/OEjLizXZ2sl1Pyn+pWCqsfHUMG3M/UZTEy4fOYOF1zxpgLBULwgBqUUAKHCx/DYlP2X4Mm/M475LDHHeIveBE1wv+IsA3JirN9FluR5gGwEN73b+idAQRjK60jRlZzBEM7qjq/2PDcuLVXfW4nS4oOBs7ZO1SKpJEjO9+MY8kp4k11pEY40ZWy492w3XQnDvVChMNCiZMaauLTiMeBCMiWWH3+c2Fkd3ZDtip0l/VOPZwTGfJ0mSKGvqxvP0atzwzqUL0CRt3xOPMFfbl35mD87oDa/AqKA/T/Z+1d7fjsMhAqeuDW4XsdUuln7OBWnJsDn0J2UEcWQ3Vl15KPWaVK8/w5Zz5nigq0Pr6o4u8gyyNsObmEh0t7Si3iKDcpF0e0tdzNAA7rteAIhpGCL+hSLjf8PH8kvo28/ArodzsVAKBWHRo0X4O+hv3Eq+hRfFL1DcVgzeeJJkE1Ro8HR3BkEQ8CN2v/P4Xp7bRI8NdaUdMv9urOCTJKr/4WB2rPhvwhz/bTEFdCcpPmanGxrqRnNzNIqKjZGatlUisI2OUUVOzjFUVjqis+sNSG4vTfrvd1yL5x6bxAoTtvltg3eRN7rCfVDDoDRyaxgR6NP9ZfylrQ8gJUZy+eDW96D3dTPaQwpRb+aDyhMGKN50EAWLV0mnIKguQtHqP1D21zXk3b1Kt1HT63gMtfaLqBqMFb2dHYh55ATrgzvpCczh3FG8igoDT0K2toPFolUYuLW1ct1rxetmaiI4y8Zgn+ixSZJEfUmRRGqC/bE9CHZgwuBpEmZrCzKXpx9l4HFKJf3/5c09cl3PuNFcDF7UHbw2uAy3c95CADcc0RpG6PS/DdTlAu+JkzcRGoKs4Ng3s1pqtf8s49tY4LpcRG4pOTuZBsVHXNKwxoyNpYYRWOCSSDmixbzCwBAPnLZemjow3rZTSFnB5oLzsMyYASoYMXjJmBjf931swu063jP428qIUkMIn0GNAbXjZ++EPy5WmURhoZ4X9tnoYd3te5ipKdnCd4kuC0mrNlAfs7t2g8uVfaWitLkVS4Uc65Ttd2Omlh+2nLsDi+HCM8fzx1BXWSFzfxviclH5Ogcxj5zENKlHNpdDJxFy5jYqE7NQ3VmN0FgCPswdADENKeZKUrO1vz1ZgxuxN+D+1h1ZDVnoG5oAjWwCGV0+tx9mt7Qopz5i9TuP7yRJ4qlRGphqbATZ5ch86f/rYHasmAK60mMK6E5SfMhOx+cPoK0tBaVld5GR+bdEZQR2tBIyM/eirMwGbe3p4PPFq+db+lrAzGHip6c/iQyex8OOI7Y6FnySj95XTeBoUvqttYyXGNBbJtvSlqx6vQ9Wj7nkRfJJDLX2o7+oDd1JtWgLKEGjYzaqbzxH2V4jFP9yAoU//Ix8JSnuYsoqSF23GWanLuCSkTXaWakY4HTSqgYkyUNK6m+UqHzOMZnaf6C3F4nPPWF7RKC5ee/kfmSy/MdUKag8cpQqQjtzRqbzCEd/D5cGi9V51HJ6d1sr0gN94XbtnOjEuXcbfG/roSAxFtxBQXuWNHZjj0OyyGSswGDhkHOq3NcjMVrLgXhL8Jhr8ebmbrife05f8z21CLBNHqPzdfp7A7ejQ5Jt8Fjat7Lq6CrrhmC1GVvM/EHJ9iD9zixwXYaL9y6BIAiERcdLBMVfOcVhenQONqYKCne22MaPee4ZGiwcuxROt6P7wUdIXraW5kamagWgghEH5Y8AcCW161jP4ISDHTU+RSmCJKbhlelG+GRWwzezWixLPvIhINyOf1iaIihMBVFsRYRHzsZRewYUhvnlo7ddx+7SY8C5w4Y45JwKm8hiJJU0S6XoCIB6EOZaqQkoKPY/wejQZlju2Qq9o8fQ0tQ4of42Eu0N9cgOe4kXpoTIRzLtNnhwM86qb0STAVWQacGkiuV+dJkHtfuzwLT+FnFm/0GL4b8/mlNYU+Jjug82EDNl5vWOFSWZjXQ/bygXqPf8XwazY8UU0JUeU0B3kmIyOx1J8tDZ+QoVFQ+QnX0Y0THzJGRtZyEtfTuKS0zR0hILHk+6WHlpeymIJAJLPZaKLHlpxGkgrzGX5tR23dEEhxFHFVppPgNXT3n8pa0RTu4dRdkGz+GNR3yLAb3l6DFVQ0dALlo88lBvlYlq7XhUXfRF+UFLlGy5gMJVW5E/b4HUbG3Rj+tRefQ8Gq0c0J2UDl5vL5Lbu+kBr01CdqehMYRux/aOTKntxh0cQHrQCxGZIbujfyPZ5wkG+8YWhx8oFypCixLX9pQlvIb1dEPux+KFKSFm6OByVQ2p/t5jFr6QJAmfTI5IsdpPd9jIrR67cEdqtFcDibaA4zrw9D/F25t/wf3cUyGAG4UoZiw6Gt5zxlhKyGNkIWsB2+hN0cAaKk4/CrJ+zF2YoeOFOzYUpeCYsatEAP3lY0pabI5vGn09Y4Ht2RosXL0QQbel2fFneK2yCPGLVuCSnhllB6zjAg4jHnsZYRO6l4lsa8zYY7arpGfgmliOA/ec6PdsyJDinP6peZcC9KMA9DpzitoxU5OFGYwgXH54nv6tX+hC/GJmLQa615tHIzK/AS4J5TjnmQmPTXuQr6SMxIXLMO+aj+D5aQXjD/sEGL7MQ+ibOjR1UR+DozP8c8xuCvRj7y3GKbUjmH3TT4z+Imt/G+ANILcpF575nmDEM7DVbyu0Lc8j/ZIbAk7pwfDo7wJzlkPr6bHxyZkVCL24APUaX1E1EWPQCSYUE1h9y7p3CgRBwITQFOIRj8/rlRZ8kkRV7wAImzQcN0/EYR9K+3xNar7sYDYmAzuzimgwy2r654PZsWIK6EqPKaA7SfE+Ox1JkujuLkJ1tTtyX51BbNwiyZJfKZtQUKiPxsZQcLljV6uSJImUuhScjTwrkr1d6bUSlhmWqO+ppzm1pP4naNe+ThdHNGg6g6f/7dhg9da/KNebEU6uhI3U/xxcvQXo1d2MTp2TaNXSR6OmI2oZLPpcVVeDUXH0Hkr/uIGin/5C/vzvx9CrXYHKY6fQZGeP7rg4DLVJboNW7hA9GKa0i1cHkySfpnxkZR8S+ztvaAi5ESFwUBMUmdgc3IXYxy7o65JBNxhAg7k5VYS25ie5itBGnl19SREe67wAU40N2xMuItSEiIf2qC0qkEua57p3rmjmUJMFfVmF+zvrgJT7gNMm6iNF/1Pk3dyFR+efCADuWTYiXN6gveH92AHLG9L4tMIARF5nNMr84Qz97qi6LsZsMy0oMIIwU5OFm2YU0N2rw5T4+y98UymzCJd4GixJ1Z69yYLu+Ui6PU9cCgdz40HkKynDaf3f+EvnASUzpmcODiMeFoxIucCqPNzg0ZlceSSzRp7FeosYrDYSAN1XRqrUsrzeColZ2ZHrU9bxxt1n2+nfPfTbgMX6j2UC3QMcDvIXUNq6vsev4WdL6Tzf9RYxWHE7ij7v7Jt+uHT0LC5cWY+FLsPP23k5Zt26L9P980k+yjrKEFgaCKMUI+x9uReLPRaLjL3fuy7FK+2X4DDi4W15H9rxWvBIcATL+wGib6wCiGno1fkMlnu20O/7/f2/IPT09yhUV0S/3mfvJ6MLyG3kE2B2GgRBwIM4Ova8YL2ALlTje/6N6mw/xDe1imRm5QKziW+xM/0N1H1tYeesBpb9duSZL0aP4RcT4gb/k2MK6EqPKaA7SfGuna6vj4PaWm+8eXsV8QkrJCsjJP6IvLwbqKvzQ39/nUzH5fK4CCoNwt9Bf4sMsr/6/IpHbx+he3AY+A1/1ZPE/0OL1m0aeDZrWYKv//9ky8yazwZJ/BtDerPRr7sO3ToH0KZ9E01aNqhj+IDDEEhxcRjxqL4eiYpTrij7Sw/FPx9CwRLperUFCxehYv8BNJiYooPFwmB1tVzAbmHiG0yPzoFbjeRsZ1NTBN3ObW3UUj6fz0N+fDScLp2kJxqr/X8g0okpl9Ysf3AQRSspznCjjY3MvxtNTbA+pAGmGhv2Z0LgbaSL/FHUBFmjs59LO1hpvXgtAgCW345E8Os68bbtbgLSnQDXLRipAOfr/wsFGjvgcUGQwWWeZSPc+S3a6j9MBldSSOPTjgCakSVlWTm6CgwWZhIOmOe4Qcj84TfM1HMV2eeCCSWef0zXRjLQZWVQ0mL3YmiwNDDEwxozUZOGH24Ew+QsBXLt1aKw62ooFDRYiFhKvR83d6ljpZYXvXRcxIhELEMcxKnohUJZL1RyO5hHQ0lHunXvWJuwRJssMdLOSwgP+h27bHSdHjcOaplKPM8qQyd4BQnGQv1HBzFLy18u0N3EZFJjiIoq+ouK0NI9gPC39bgdnI+d9xIlKm7Mu+4NjUNH6Xd++/WzUHX5YfjjZgl+vs8UP09vE9hVbNhm2eJk+ElajlHStuH5BlxmX0bU0xe0pfdQq5AKwtAAXg3LimUZL0XEmaVwPLBRjOJwd88WPLtxAmkBPmiqqhh7PJRF/UYOswb72wwQBIEY4leROYBPfIJqkzmIt14Pd4dDIB4xcMSbiTUv/fFdVJpMYHZOaDaWP0vHbv9c8czsR7CR/2+NKaArPaaA7iSFvJ1ucLAZ9Q1ByC/QQlLSeonANi7+e7x+fQGcGi/09pbLBew6Bjrg/NoZP3v/LDLI7mftR2hFKIb4o7KKr7zB1/8KjZoPaCDapq0FUl/ygMLT/5qiGujsQof2JbRomaJe0wMcRpREO9tqjVhUnn2Csr0mKPntJIqWr0O+shRerZISytYsQq22NtqePkN/fj5IrmwWofVnmVwAACAASURBVNJiT04ppkfngFEk2XSAJEmkpf+BKLYiMjP3ojg9Be7Xz4vwXoPtLNBWL18RGQB0hoTQRWiDnLH7B6WakCCRmuB06ToNKJs5E9etdEsshwKDhbk6IWjrGcTAEA92UcWYIwR8jrmmobq2lrIdffSHyMTC1/8XCrV347F6gADgqrER9vANWms/HsAF5CtKG9l3bGAXiDkW6qPMH65AgREodtyrdz1AEATU9CzFjvMdg4XpUdkU0LWMosHiwBAPq4WA7vprIbAaLjqzUovCz9eoZ6Kq7k2/HztOWEOREQQdfQMQBIForefgMOKxhCEK2rbZJYy5tP6rlfzubBPJ6I5kzpV1BCYt603skaVHZRBz9BaLZXX/sjICK1wZUWxFhEXOwWE7LYnXMx7o5vf3o2TjJuQrKaPy8BGxMbRvkIeUshbYs4uxxDAci9QfQ+/APtr1bNs5M+q+9Vyg4rSaGkfdFsA42Qwub1ygHqOOjd4bpYLa5Z7LcTzsOKwyrRBZGYn6nnqQJAl+/xBqbiVT46z/KDm9bC/0G3wOENMQbb1xeDVsGpo1v0D6xXl4fmw1rPb8LgZ8Hc4dRbijHYrTk0WpVO9Z/aa7pwfXTMxw0toeFg6Xof9IE0e87YfBbKpsmdnwaOzMKsI1CTSD/KQ6ekxpqR01zk2AT/y/GlNAV3pMAd1JivE63dBQF5qao1BUZIjU1N8lAtuY2PnIyT2OyiondHXlgST5Eo81VnC6ODBNM8Uyz2WCQhn3BbjMvoyshiypYHnI9TjqNT1pYNqpcwp8PUlUg4ciVAPJoDYOVZf8UHmIQMW2vShZvRoFKipSs7XFS2aDs0kBLXu+RM+5z8HT/uT9cM+EQr+4BtOjc7Ajq1jqPs3N0fSzcFBfT08g/nduoSnSccJakZXHjg07oZ2W+HdaNcH5PpjH94pMXnZHdyPC0R61Rfng8/lwGnYRexM3scGNJElsGM7gXvfOFflbRXMPDjom0iBCifECD3QOgKv/KQVwjb5Ekb0BPDUjRQBuqMNrtNRMHHi/z5BXZozT1os52pIzmzP03DDvwe/0e6TiuB4ziftSj+noHQKCIHBFTzxD+Z1+CD3JKxiH0WDRN7Oa3meHkLKC2dkoLL8uAK47j1vR78sI3/SkrhUIgoC77n1wGPE4JcTTlQWQHnNNm1BGVx5bW0DAhZ7BCKLfr9/vWGKf1h0amJzSujV83YG47nya3s8neAl+NrF/J9DdxWbTbdfBYknd7+nLWBjt+5PWyN1w0V4EgM/QeYJ5DgK92rk2RzHbTBNKdvuh4rQKix4twu6g3TBINoBfsR9K2kqkSnt1RFRSKja6ieB1ihawdjhtptslw3KFRCA3oPspiky3IuyBDR6cOSQGeq3274C3oTYyAr3RYroMJCFfBnR0AZi+EM3gWxmA7PToHCwKjcBOP1dc8zIaphlspWgGBv8ZE4zyeHw80k4CU41aHRKJCWr+/i/GFNCVHlNAd5JidKfj8QbQ2pqE0lILpGf8CXb0HAnKCMrIzNqPsnI7tLdngM+feNYytykX6jHqWPhooaBa+PEPMEoxQmWndMcrkk+iL78FNVphw0A1FvWaHhKpBpK2GkYw6q/Zoe7EGXD+/BUV65eiaJEUWS8lZRTOn4uqtTPQuOtrdJ36f+BqSBi0JmGg8qprwfToHCjHv5YsBF9SCG8jbQQ+oaq6A7xU8dxAE7VZse+UDRmsrKTvvXOUH/xYqgk+xpKpCSxmLphqbES6Tkx3NqG4mZ64X3OG9SoHuqlJ58k+kAafI0B3M75neNH7/abviXD3l/DUTxIBuEaasfCOLJXJOexDxUSMI36zjh21z0vMNtWFqusSAaixOgUFTT+px9tgEYOMrCwQBAGGvpHYPt+aRgjMInSCEZBTQ8uLzdBg4ejlMLpdiXORmH9TNDvL2HkV+UrKCP/+J/rfftemZMaM9I1RzYiDAyNKLkAqD3VD+D7lfd7Cz2QkS/vnXWMoMFhI1KW4qPl6qlDVfQpbb0ES4L7vJizQezLmNflmVo97fpIkUXXmDPVR/dNa8HvEVx2K05JgfZByNzPevwM/3ToO5ftboeKyBCpOa6BkewizTXUxk7gHZeZOul8o2RyGAiMACgwW1phFQf15Dp6kVaGksUtqUoHXPYgavSRwGPFoDxZ3/qu0Xg4Q05BnvhjdhtOlAzrHdfT9NZSXIuXFMzzRuym2EmS5ZyucDv6MKLUlKLuuAK7ev0RoBnHWG+CeFi4CZmXlzC4OZ48Cs9tFwewEwejb+Bqa6y/C85dV89d4+gc3J/rQMQV0pccU0J2kGOl0KSm3kZV9ENExylKUEXagpOQOWlriweO9m3Uuj89DZGUkDgUfElkuW/dsHRxfOaK9X1BJz+vhYqCyEz0Z9egILadVDThaYwNZaotCvaYHWrRM0c64gNazm9G4bzE4v85C6Q+zpfNq5ymhfJUi6rd9g44j0zGg/ilI468/ytJTVmcPPTg3DAg+KJqrKhBgYURPCI7X1tHPq6Ux8p35YI2WlpQaxJo1ILlcDHG5KEpJgJ/ZLRGDCcs9W+Fy5QxS/Z6PqZqQGVoBphobHrrJE2qHU48yqOyhfTzw1h94fhgwGjWZGnyGjkeHofXQH7+oh4A4J5rBvXoxAsuuB0vkvX7smIgVsLDE1wydJ1Bm/inI4jqtgqIhpQwwe5jPKU1Kqri4GARBQJ8goKgpuhT/jTWb6n/hWdhgEYOufi7WW8RgtgYLV4SUFa5diMAcCXa+zuv+Qr6SMuw2HaT/baGmD83TzdEMRiYjVi5AOjDEwzpz2TV4x5LMGiuEAbVv8GJEsRVxwFaPylRrWtP9LumRQCZRy+0YFDUDxi2aW2ceLdM1DVZUoGA+pdbSaGkJgDKISKhJgK2zBiyG30Hi6K/4kblYjIKg4rwcSx33wDTZBoFFUTgUeEnwt3s7oaDlK3Ztiw3CcdI9Aw6xpcisbMPgELVC184qo5IE+kng9YgnNxrN5gLENDy5v3dCQLGvuwsFibEIsbcE89A26J04iIvql3Ho1i1stbbHGlcvLPILwTeRsnFmFydR0lwjNIPrz/xw0fwufF+yJPN6rRfINsY7rpP6vHhcPtw1E8FUYyPKTeijXpaMrnAbTZCe8U+IKaArPaaA7iTFSKd79uy7UcoIv6KwiEBjUxi43Pfj+NLL7YVXvhd+f/G7yGC8038nfDKeoT23Bp3RVWh9XojGezmoNUiWAczGoZbhjyYtG7Rp30S3zgH06axF75XZaD/8Beq3fYvyVYrIn6ckFdiW/jALtb99h9YDX6Dv4mfg60oYfHKefJRigp4hHj1wx7Z2ob2hHiH2lrDcu40Gmm7XzqEoLQkZmXsQxVZEetxakO8AysnBQRT9uBp5SsrINzRAlIsEasL+LYi4+Qdqg5mitpxSoqaojQZFvZ3SNXsl/ra5gwZnL4hdo8Dtv4HHfwLZniB721CW04SnhmkiAFf9QoTIcvq7ZvomI2TJ6M5giGZ0j7mmYQaDhVnGJlB1Fpg/KNnth4L2c/o3R4eVG6RJSdXU1NDA81fzcBEw/I1DLJXNDc4Ep60XATk1YsoKJy+FY4YEkKvAYCFh0XLkKynj0t+aIpnnG/rGIAgCLG0PcBjxWMMIkQuQctp6seYOW2pbzdYOxv6HKVIls2QJYd704yDKgvzEvZv0OTKNFwHENPSYfYrQ8LnYb6uHmZqUosJ4QFxmUM8bwGtjTeQrKeONyjwccdiI+W7zcVRzDf0uap7ahGWOC7HUYyl+996NjW7qWH/fCvvdWPDP5oicgyRJ2GbZCoxCfHbgTmQqjruli0j3CW9zdUJwkpmEiuHkQmNImfiFdjXQ76Sds5pM484IzSBOAs3gu6h0mcDsvOAYbI7PxtW8Cpozmy9BmovH48HYmOpzubm54tcPvDd6wesYDpXVPReNjqbhpJCsHN0PMKd87JgCutJjCuhOUox0On//ZcjL10B9fQAGBhre6zkaexthnWGNH71+FAG4x1z3I+iuC6qHNW/H2moNktHAzEaDTRb9b3V30sGtawfXZDG6Tk1H466vUbV2Jgrnz5WuV7toDqp/VkDz31+hR+1z8LSkaClKGmzklLJ5X7EsOQ/To3NwzdsPVvv/ECzrXTyBvDg2+MN8uta2ZPpDpdluHMWJMQbs+hcvwFqzAg7bfxm1lLgFPsd/RL76bGoZUY7MA3eQh/vnosFUY6Msu2n8mx4aBIrCAT813NG/AAUGC0sZXujX/0wgCZfpBvS2giRJlOc24ZmxKMB1Mk7BSgkAd/QmL3dzMkLW5XjXRMGS8dPMQijZClZFVF1+wKzbRhhdIDXe/bW3t9NAt6auXgQULwvMxPToHOzPLQUAnGMmiygr/HmFUlaQdK1LL3vR792vp++J/G2/jv2wHbA1OIx4PHXIkBuQDgzx4JtZjd9t4zFfPwzz9cPwu208fDOr39vHy4i5wkM/qvD2gsMlzNYKhKbrMaQGfke/T2aGJ0Syx8IcZln7Hp/ko6y9DP4l/jBKMcKel3uw+NFifP9QFfHLqHZ89ts8nLuyln4nTW/sw9NXnshryQNXDgrZ88LnNF1so/dGlLSVgM8nUVjfhccplbjyNBs/mgo+JOyGi3XfMmKhwmDhN+s46Pq/QUBODWrb+4DcpwAxDX0Gn8Pp4TG6XXjEvwQ0A8fD0Pc2w5HcEvloBqHh+OOFO467WuD8XT1c0FQH4+wJmBwQmFbYHP4T/uaGyI0IRmdzo9j91tbW0n28tbVVcqO8p4KxIS4PrhoJYKqxEf142GRlPNWFdzjfPy2mgK70mAK6kxQjnY7DkVzVL0+QJElRDSo60JNRj8wgNq65n8dit0X0ZLzYbRHUbU4hXv+pOKDVSUC9VSZaPPLQEVqBnowGDFR2gtfDBckj0faiWMCxJcLAuXgNxevWS+fVqs5F5c8qaFQ/iM4T/wH3xr/EhcvHWz4aDWDlkLJ5H9HX3YUtIVRWbdM9Z1ju2YoHaoeREx4M3pD4xJaZtR9RbEWkBXw3flbXcZ3gtoSpCaNtPi+fQuqNn9CpI4W/JmPmwdskHUw1NhJ9SyTvwBsCSqOBwIuAKQUi+vU/wxIGxXe8c+cWkPYQ6KYmMpIkUfG6mT7uyBZok436so4J8V4/Vsi6HL/eIhoDQzyk1qWKVM0r39uBGTqeE8oaDg4O0iCgoqJC5G8Hcsto1Y+qty2wOUe1sbVaFDaqjy3zdeUCVYj2WlkFs2/4i/xtndajYTvgWyhnRCPcKHESW/fdYmCIh7C4vxHFVsRd79N4EryF/qCstJ0FENPQbDgbQZnlMhlqjGyKuk+w080B1pnWOBk2trSXGmM5Pa49/m0dLPdsReh9a4mW3bJGbHUsXfy7ymsV0uvF34Pa9j6EJlaiSpMad7UYEWL38R2DhWCj7QAxDTEWG7DvuTMOy6lmIEwzsK9sACs9GPlSOLN8/WmoufkNEs4twKNLh8V4vSOrXLGPXVD99hV4Q0NITU0FQRAwNzeXrgL0HiXAciKrKOvw89HoGpFgk5QokWUe+h8rUJsCutJjCuhOUkyk0/EHeRis60Hv6yZ0sgVUg5pbyahmxMHf8AEOM0X1b1e6LIeR5XW80nmJOtM0NDm/RltACboTa9Bf1Iah1n6QfNEBiORy0ff2LVo9n4HD8KVBbvkhK+TPmy8KbFVUUbZ5A+r2/4j2S8sxYLUdZM5zalAaGcBk/YI2+WbSAex4MdjfhxTfp7A7uht/WNpgenQOlngHIy3AB9wB6VSBtvZ0ehJutPt8zAGUfPw36kuLJVITbP7aDJauBmoK80HmPn8vmYf450VgqrHhe0fIxY3PAyoSgJfqEl3pXty9SIO2mnZqGZAkSVS+bYG3aYYIwPW3ykZtiYDfPRHe68cMl2H5tDE3TX+cYenR79USj6VYwSQwYv4gTDuQhwowsqz79q1otfjatAJMj86BTkwx7g1n5EcrK0ja5umGovT2HeQrKSNgxSbx5XBGAPT1KXCdpOWHIs14kLzJsVh+H/HqlRqi2IqIjlGl36/iElPwG/MEoCXVkd5frO9p+ULRwBZzzG9AyW6viEPd6G2F1wqcDDsJw0RzrLK1wQwdL8y//hTsZRTYzZo/H0dO6+JXq1iJhiLyxOum11j7bO1wX1qCkPIQsX1anxeikhGPDIsUhHBaoJ1Vji2Rb6ASlIkvX6bji4hMNBrPAIhpIB5pSgez8bmiYFYKzQCAXKCzq7UZr9nhCLS8Dbujf4uBXruju3Ff/TyMrlyAp6vL2A3ynlbtuIM8uNyIB1ONjbgnhaL3NZIoMR6jYE9KQuJ/IaaArvSYArqTFNI6HcknMdTaj/7CVnQl1qAtoARNTq9RZ5omkVpQpsmGs4kZtgrJ2Mx3n4/fHm2Ca+A9tORUg1vfA5IreUAmSRKDVVXoeMlCg4kJKvbtR8HCRShYuAyVZzwE5/lLF/lK81Cy6RfUqF9Dq7s7erOywe8bp0CuvQowlNFAwuGn8UXKJymGBgeRFRyAe6cO0AP1GUIf06NzoBibC74MmsTZ8b8hiq2I1EDJWd0enc+QfnEe3C4cFFNN8Dp1GJErfkDecBEagPfGXSvOaKCyHBeiMVSWAoRoABZzJbT/WiDRBmivwg4mJRt2+lEGSJJEdV4rfO+IAlw/yyzUFLYBEHUWm68vm73sSpMotPXIxxuejBgvCziTcISKo0BfenfQbpS2l8pl5yotrKwoya/0dEFWjyRJKMa9wvToHJw1ppZiHbQSxJQVJG2+mdW0PJ3F5uMS9zmvZw6CIOCt4wQOIx4DVbK59X2MSM/4kwa40TGqaGh4Kfij31mq31rMAQZ7weVzsdvVG3PMdKFkcxTzHH+GqtsCiaB2gRsl7WWUYgT/En+UtpeCx+eJ8IOXqHuA2L8XD/74BW+HP+x1/xB8AFKZ/okXVlZ1VmHLiy1QdV+AeY/XQTvLB26cJuiX1OBgRjFWBmXi28hsqQD25yDBkv86X2986ZuKrzwS8fWDWHxzNwrfGoVhtnYA/tK7B1PWG0TlN6C9V4b3bQKgkzfERfXbV4h97CKuCjO8eWhcRsJTD9QU5IEvDWS/h1W7rLBKMNXYeHAhBj0dEn77f1RybAroSo8poDtJMdLpioOz0RFSjuYRVQOdhPELwXQSUGgdA6tHhljrsUZkAD8cchhRlVFS9RiHWlvRHRuLJjt7VJ06jaLlK8TVD5auRdXFF7TGbZ3JszEtc8eNx38C0vzN6e0TwPgLyYPrJFbB8nk8vGaHw/HcMXpAtj6wA9HuD5FZ10hPKlV94w+2Ha1p9KTcYE9ldYf0PkGRuiL8TqzEXSFrTko14TRS/Z6js74ORavXDFd43xUcUFZpHMd10i+KJNGdL6AY1GktE/3tvVVAnAXQUkr/5BWnnQZFftHleGGRKQJwX5hnglPQSi9FSnIWk3VbYhgBn0yOXOYm7zukZ6ADMcf8Gm3+MN9tAWyzbMHlvZsZiXA4OlLuaDExMfS/NfUO0v2OoR0Hf+tsPE+ugLJu6JhUkA0WMegf5KLwh2XIV1LGqX36EvfdqeNALSfr3aE0sNn/fRXmfP4A8gu0hECuCrq7BRk6kiRRy0kG34DSbH7ivBLfP/5earZW5eE6KNkexGwzTcy8dQ8+WRIKuyDgbK+6/BDG+yj5MNO9O2D7637kKykjd958rLzoLjdNhSehAOzwqzKsSnmDL9gZMtMMdmWX0JnZ/DBTgJiG+tszcc7LDCV6yniiswPqWhr4SdNFal/5Rf8xtJz84ZdRgerWXsnv3juCzs6mRqQEvoDZiQOwkCBfxjy+Fy9t7iAvjo3ezvdTdD0Sg/1DtH54grcEHfT/oyYSU0BXekwB3UmKkU6Xfv6FZDCrGY86MyGqQVIt+ovaUFpdCINkA/zw+Ad6EF/4aCGuxVzDq6ZXIufg9/WhNzMTLa5uqFFXpx1/xrLMrTO0R41OLA2oe1/JUMA0Xshc+SoFDMvC0ZLFslIoSD4fhcnxcLlyRmCRuW87wh1s6aKKAT4fX8VQk0x4s2yDcU4GxdVNCJyBqLOLwdz/q+hy3pG/EO5oR1EThieYzvBw+jkM2m0XXP/91RPLPJAkUP8aiLwF2CwEiGlwP0fZ7mbfOAzY/wBEmwBNhRLuALjunQsFBgvLtENhP2xIwFRjw8csA9V5rSIT43jOYtK22VrBIr/Z7ZCM0qaPYyIhKaM7Q9cd8+5vEQFKu92evPdzP378GARBIDg4GADQ0zEAKxtB5ftj99fYMMwhniGhjUfktNabR8MlsRzXLAIEjmg3PCQ+l2WaT2lucD4jHE2Or8SuSzhDv80u4Z2X6uWJ/v46kUxuFFsRKek7Ec+Jx72cezgbeRZrnlIf+E8tvwKIaWg3+BdWuKpQ2VrXlVBm/oU5FlcpqbdhJQxZgOkx1zRsumiLO3socGa07y8sv+oC5Wu+tJKF29pdYm0akFMjAmbdhMDsmtR8fBsjWwHYlxFsLIgMximPFBg/SMWL5Arkd/ehlyfBDMid4uc+u78HDg9Pio0NDfrfgaX7Cwjti9iqaY+ZjCCJ7+KK21G44JUF96QKvK3tAI//fj463759C4IgYHjrFkqy0hHt5igy3gqvaHlqqyPJ2wv1JUUg+fIbH42OdFY5tRJyMUZcbeb/qC1wTWnBFNCVElNAd5JiBOhmXg9E470ctHoXoTO6Gn1vmsWoBiRJIqM+AxfZF7HAXbAUt9xzOczSzMDp4oDk8dBfWIR2Hx/U6emjbOcu5KuoSga2yvNQtm07ZZn77Dltmdv3tgUcnUSq6OxWMgbK39OX9riVr+Nle8f5wpbDspIkSZRlp+ORxiWRwfaltRlaa8ULA9ek5mN6dA7sKsdXxOhpb0MKy4aenJ21BVJEPozTyI+NlMjzrTp6kHJCWztD/PrlaZfGAiD6NmD3vdg+4TctwFRjI8Q6kQLCUiL/TRNmDU+AJy6Fg6nGhrdJOirftkjM/MhjIiCscSoJtM3WDsbdiCL0S6HZTFaI3sNLzDbVg6rrUoH5g/VJKGi+mBSVCD8/P4pG4O2NlppuuGsl4pJBPKZH5+Brdg7WmUeP+RGhrBeKh3GldEHdiQMGFJ9UZSFmagRhlgQt3xmMIOgQhiAIApHaT8HRTkB/7yANbH+1jqOzxyPP7ENpILe1pSEufhn9Dj1nr0AUWxHuobMkZmo3uy3C4PC7Uux3AtVd1ahu7cGGUSsMsvKnzzKsaI1c3QP7sfCawAjl6AFDvFGeh+hVa7BJ0xlfM2PwlWs8vnqWjFlh2TKD2dGZWVZTO9509kA/+TZ9X3vu/4GiuzHS+dODvSANqVUjtWcWSLZaM+440a3/H8Tr/oi72sexX8sMygxxLV8FBguq+mE47JIGu6hiJJe2oG9wYu9jaGgoCIKAk5OT6DOur0VWSBB8TfRhfXCnGPC9d+oAQuwtUZAYi77urgmde6CXi4dXYsFUYyPZT0IR7kdS8vmgwe0DymKAKAPAaSNqrn0yBXSlxBTQnaSQZRlhiD+EkPIQ7H25V2Rw//n5BnhG26DhpR8azM1ReegwCpYslW6Zu34DOJevoMXZGT1paeB1izv9dCfXgjNc4VtnmgZu43uezMYaWIy/mDhnSo6vc07+GzzVvykyqL4wJdBYIXkZEwBOvanA9OgcnM+T7BY3xOWiKDVRxNDhhctCRLEVERqoihS/J+hslp4VH6woEzihnRjHHUjSvVnPp7Kz91aK/91KFQjXBWqz8YpdDaYaGy43EyQC1vqyDgTaZOPwZYpfO1uDBXfjVFS8bh6TViBLlbsCgwVVvVDK1UsGQLzeIgaJJdJNMN53jGSlFXWeQpn5l5Do/0ooGllOqu5vWFgYCIKAwz0nemI+ZpWE6dE5UI19JdMHxA/GkfQzMP39FCWH9eMWGqguM47E0eHM7AiP2NPLa9gO+B44jHgc0hav6pe0jW6Ld8388vg8lLSVwK/oBR7G70N4FAVwWZGK2PdMGWo+SohiK+JZ+CwscF+AnQE7oZuoi+eFz5Hfkk9Je4VpU/399tdAb6vIdcnKnyb5fMQ8coLlnq0w37sN59QuY5bpSxrMfvksGV8EpeOriInRDIKHC8AkZmZHroEk4RBnT/e/LU83g9MlRZWnOIJ+z1VD2WM7oknZuPqfIldvMZye+0HNIxPfG0nuA7O0grGDmQhjVh7C3tajpVu2TOfDhw9BEATCwsKk7sMd6EdZVjoine/j4YXjYqD37t7teKJ3E6l+z9FYUSYXxSk1sAxMNTYcL8eiv1sC3egDK/lMevC4QFUKEHsHcNsKGIoWRdeo/39TQFdKTAHdSYqxgG73YDfc37rjFx+qwGzFA1XsJ1Rgf3kdMo78iaIfV0uX9vphGaqOn0CjtTW62GxwG8W1DYWD5JPoCCmnKRMNtlliXurvLaQNLA4/yTY4O64TP6YMtIgGjS/hqyW6ZPZUXwOcgrfixxsVluX1VOFHegH9byRJoqGsBFEuD8A8sW9UpfHfCHfVpTNSdXW+Yx6/UYuyGi1aOAekJMOM0cBWOAMuqcjPUgkIYQDV6SKZ28bKTpqC0NEk+IhpKO9EkF0OmGps2KlFYeENKgN4ySldpklFVoWFNWbSTQZEsr5CoPnqsxw0yzipvms8e8vCAtcVQuYPezFT57lMWcB3iYSEBGp5V8ec/hDRyCofFuXPksnMQvj//Vb+inwlZRhuVRNbWheOtLS0YTtgI1QxYnGHESlzZn7keJK42eNlfht6GhBZGQmrTCucCDuBFV4rsOSRKkyDBJbnXmGz8LOnCjZ6b4QF+y/K/jx2EXq44h/oAICeZuA2RWFAhJ5M7c4jSVT1DSCutQsuVQ049MwfP7o+gYpvOL6MzJQJzM78/9n76u+ozvX7/4Be+XxvKkAgSAIEbaGl1KhBoYa7Q4M7TPwkQAIJcXcjgRDiukDSXgAAIABJREFUbjNxIcIkxIi7u8vMnP394SQnMxmPcHvXyl5rVrvCzNH3PGe/z7uf/YSm0gVg3wTkyERmJYEkSbQ65MPT4CltDfmt77co7BARp6LUAWIB8p5+hq/CguUmuaISCCRJoqp9AC+z63DvVR6dFRf1+d4kAQz/fLzKqUdNx4BQrBgbG4O+vj4IgkBRkWztx0mSREd9HbJDA+D3QANmR/4QIr72aicQbW+Jssw0jAxKfiaH+8fgeJ2aPGaGiE9m/M+CxwUa2UCqJfBsH/DoI9H32OZzIOIeGhI85omuGMwT3TmCKKLb1N8E07QnOGr0Ge5eXQ2HvasQv1U0oS1WVkGJ6lpUHTiI5gcP0RMSgpGqKrn0TSSHh84XJTTJbXN5C97I9P0hp42ZVMFK+G2HugJCz20RqvytYufInBkIa+2GAouNRQl56OnqRHZoADzuXBbSmPk91EJxMouWJuS/vYx4phLS0r4DT4yhPDk2hrJPKbu21j8ltTr+ALDZAlhvnizY4/8YLwPCbwPVqYCY+8/j8uBwLQE2aky8y2hCa00vwmzyBIrMdHUnW9u+a5ZtyVBWz9xND2Jl+t5++zT8bj1JntfpxeDF61rwZkk3OBV9o33QTNGkCe6nXlvwm7s5dlslT8tFQR6QPBJ+TtTyrr62AZ7rZ6K3Y4heRVgdkCUX+Vx2Lxh54/Z/x44bCFzXqZ7Fza1ttE43Vz0MTIZ4UiPqPp1yfS1Rm71UPRzfmkQipT4dzm+dcZ15Hd+//F5IevDNs9XwiFpGk9yA5J8QXx2O1kFqgt7WFkcRXZaK5IvJfEg9Cw8VqG5hECSz09XMKkTmCLkZ3DlxH29U1+HN6rXYfM1L5ERiOhgu66JjcWJGDO3vu9l7M5LrkwW/bLMFIBbA0uUSLgfYTa8hgqQEwjja+kYQVdCMh2FF+N06BUoaop0/PnsUh0veOXBNqcLb+h5UVlXT46uvb3ryg9GhQZRlpSPG0QoOF08KkV6zI7/jpb4GskL80V5XIzKmpwWUw0aNCaebSRgZ+i+822YTJEnJ0zIdgRdHac9zoY/FeiDkGpVE6p9MdM0Xo4nHPNGdI0wMusq0NBR62SBAbSdCv1uFt6vEE9uKnb+g8T4Dnd7eGHr7FrzR6WdeecMctDnl04G1068U5DQzETPGTKpgRTgT9Gr+P0Rf+FTA5cD19C8ozUiRu9DhXU8//dLTVBNcWnO5fh4ZAb4iOwL1979DPJN6gTc0+orcdl9c3GQR2u1/yvdyeqJIBbPKBKrhgwwIMsuFjRoTnpppAgT3uX4mynNaccIlE4qMcBx0SJf5+siq0ZU1o/urVQq4PBIeadVYw2dTts8uDaUtkl+Y8i6jZzVn0asmqh6qOBN9Bo39jTKf+0wwNspFlMNbmF73GycEehgepCZEO7NLocBi48vAHLmK/H5Qc6DH0+arXgL/pqobLXAtgtkNuKVjCIIgEKLpgXpGMtYzpNuXib+fwVhKOGD5Y+nWXhs8N+BQ2CFYpV5EXILqOMldhupqOyGy0tWVQZNgHk84u0+T2eYmuLv+BV1PdZyIC5OLzC4LTcRnzwJwPJIF65oWeFW1YKt1EhZrRIiU2qy+9Qrpaz9FsbIKnLYfmBVZC0mSaLF+Q7X6tWWDJEm863yH7/2oycF6z/UIKAugvtxTT8eBPYFucCgtFS8LkyOjKwsGRzlIK2+HRVwZjrtkYrWOaCeQPTou1ATO0Bip5e0YmGEChSRJtNVUITPIDy9079MyMf6P4+XTiHO2QUVOJsaGqYTDYO8oHK5SE/zsiCope/kboqsayPEAXp0FjJeLvocmykDABeCNt0Rt8TzRFY95ojtHmBh0CUrLREsQtm1D3eUraLd3wEBaGri9s+d1yekZQYt5Dk1ye2JFz4bfG2ZSBcuX0R3Q+jeYahtgfuiXyeB39AcU3FwJntd+mQ+HX5pgde4IPo6lquAvqN+npAkOlmgoKZJ6zQoKriOeqYTU1K/A4wlPSmovXECxsgpqvlkq20vJcBEQdAkoi6P0WHKgvb4f3rrpAgTXh8hAWXYLSB61ZDnxkgrPb5J5u9JcFyY0nSdd5e+W1tI7jMveuZMZS40IGEWViCyOkWcZfYQ7AuMsY7qwc5PXJngUeoBHvp+J3mDvKN10w/xqEJ35Ghxfil2bWgAFFht3M8tlIp0TZOzSQU0UK6sgfe2nULwfJvK7E9fitNtrHNa2odoB65ihnpGMMwzZ/I+Xqodho6EPlhs+wkozNayy24U1bhvEWnvtCtiF+0n34V3sjby2PAxzhlFT44B45nLEM5WQmLQRHR1JIq9Vb18BYpnL8YL5OeJbG6admVVOyMcfuWW4U1IH65oWvCgqhT7jFh4f/ROmh39DAStWYL/8Gt+fzZKgMk7oJsbUhSO6dKyujmbOeEwMFXbQ8XiYr/lK80Az/gz+k76WtmxbkLmeVLzTV8Ci+NdI7+4XLQsLvzP9BIKM4HB5KGjogVtqFS5752LzI0oCc0bbHARB4Li2JRQZ4VDSiMBv1inQDy1C5NsmtPaJb74jC4b7+/EuPRlRtuawu3BMiPSaH/0Drx5pIzciGHEu1MTe+XYSRof/5lnd3iYg/yUQfJmqvxCZ5FgCvDwBZDkD7WUSi4v5MU90xWOe6M4R+Ilu7loVhP2yEcka59ERGYaxpqY5I55jzQNoMsykgqpGMvpfy05q5hTTrYLN98Ow9j+RcmktLA/tpAOd3ZGfkHtNBRydD2QO5gPdXcgOC4TH3SsCQXOtXyQUWGzcT0iX2B1NaHsDFfTLvL7BR+DfxhoaUKyyarwITYaGGtFa0yqS6GjoR5TjWwGCa6PGRFFKo4Ac4EFYERQZ4dhiEIcxOTP79V2DUqvcZc38iloCZpW0YhtfBvErIyYS3k1m0WUl2yMcLko6SwSIw76QfSjrEuG1OUfobByAp8ZkRj05pIAmuu3t7Rjm8mhyFtfWLfW8Nj+c1NZa/HRCrP3V1Gux2zIZX2s8G28HTKCCwYQtI140kdb0hdIDE6x4egMqNnuxxmWLeL9al8+hYr1/3NrLDKp6AQLZ9cGRXrwtuEpnaTNf78LQUK1ImcGxvAqsT8zFJ8wsmcjsxtQC/Bn8DHe8H+C8oxEWmVFNE5ZoRgiQ/NqCPFidOgCTg7theWIfqtg5Uu+bUHGbWyZyd/9Jr7SRM1hdI3kk5aHOSEab81uhf+8d7cWZ6DP0NX5rR7mqxFruwIcsNvrFZZP/CzZaJEmipn0ADwwegyAIHHvsI3YsfmvMwh2/PPhm1aKirX/a7zySx0NLZTnS/Z/DR+s2TA79KlzUdvgYzE9oIdYlAmOjf6Nis8FOoCiEkp5Zfyb6Phl8TE1c0m0o28hp2q/NE13xmCe6c4SJQXfR7Hck1SS8l2zScEU3Gog0yj5MOxVDJZ1zvk+5IGcV7NjwMDIDnsP6yGQG1/rwDmReWYNRnX/IFMy5nDGUZaYh0EhfaDlsQppw4c07KLDYOFsg/9JXYeFtylc39UtwuZPH0G5hhIafF6P/8sciu6gJ6HOn8TLqbBpAtHMBbC5Oklt+yUJtUQf93cFRDlQJKptnETc90ietyl0eMioKQ6NcPI4soe2yFBnhuOKTi9beYRlJdChuRZtig9cG2nvaItdiVps/SENlQTtsx3XSlheZuPU0DQFZVTTRrampQeXgCE3cKgaHpU4iKtv66esa+dm3KFZWgcYf16Vejy8fM7GcEQKd8XbAyRr+yGIkQpERCCU9Gyw3YkDZ8ihWO30jltSucdsIFbtfsdL0IpY9MsASbS8oMkRnkpeqh+MzfTfYRPwOC+afUGdewuUMbxzPK5NPMxuRjaUhWbiYXyXkZjDC4cLa4BZALABH9x/4Vt1Z6BiOqdvRRU52F46hpVKE9ZSMGCoopCerHS4u097OILuVzuaK61I3yh3FvcR7WOe+Bt36VGzT9GTgq8xiyRv/L9hodXR00GO6qakJnQOjiC1qgWFEMfbYpmK5pmiJzKYHsbjgmQ2npEq8qe2Se8I9gcHeHhQnsxBuaSxULGxycDcsju9B4BM9sKPD0dPaPMtnLwUjfUBpDOUUYv8VRFprPvwP5ZGc9JQqKp6lGDVPdMVjnujOEd73oBtkt6Jek+q61vgwA6P10ysQ+DuAyxnDm+gw2P91fDJ4Hf4FyZfWYljn31KD+YQ0genmAJtzR4RdE6ZIE6xqWqDAYmObtJeKCAwOVoHJoirK66qdgAJ/kM+PgKc9NcB9IPjfab6MupoHEONSKEBwvbTSUJzWBB6XBx+9TNioMfE6dLIK+fnrWigyKB/bmS4pSoIsmV9pKGnuxR7bVPrlqKobjZ9MEyXali3R9sQqu92T3qv+O/Gm9c2cnacopMZUw2r8fhhdjMcXdyYaZoRBh9CjmjcUFyO5s48mdUPjL3ppk4j6rkHsNIhCoTJFuvadfipT9lyREYqLugYgCAIvtJxQz0jGj47CBWOqHqpY474Wqxx+xGf2F2CX8wxX/cOgyAgR2uZiRjgWEVFYaBQ3bs2Vgo9806EYkSJzZnZDaiGWhmThY69ULHJg4jHzMNyZ3+IHYyuJk6JgdgNWMgLRqLsEIBYgWHvn5LHdD8Ofag8nJ7E3LuBVQt6MG2I06RKU1GzjJoy1SPfangqSy0OzcRbqGclo95DsAsMjefCOv03HjJ3u3+N8Hlv6Tt6zjRabzQZBEDAwMABXRKvf4TEuMis7YMMqxykJLcOVtSNx2DEDpjHvkFTahr5hOQkfZwQ8ti8arfaAeWc3zI4I25eZHNwNt1sXkeDpjJq3bHA5szzxHRsGqpKA+AeA84+AnohaDP1/AS4/UQWVVcnUb+YA80RXPOaJ7hzhfQ06kiTRl1hHZwyan2aD0zE0p/ucK/B4XBQmxsPpylm+yts/EO9qj4H2ZqnBXJw0weTQr/B7oIkiPtcEfsS291Bdi1hsDMubZRgbQlH6YcQzlZActRRc/ckAR+osANdpF5D3Auhvm9HLqLt1EHFuRbDlz+BqpKEotRFcvmNmeRXDRo2JEAuK6JEkiR3mSVBkhOPq87knf/L6m4oCj0fCJ7MWawlpmtIwLH+sK9D8gUgjxNtUzQFIHokU/zL6nuhdisPau4IZrbu6j0AQBDJeZ8GnqYPy0E0pkGs/3ekZtGZ07c2XIq/FEi0fLHv0GCtMrkDF9nescd2E/eb7qXbAuoaoYyThvvklSoLgvA3KVoexyuQ+vrVywUn3JASzG1DZ1o9vnyaIJLMfhmZBIf6NTGRWJSEfe96U05pZ/szs1AYe0XGU/Oe3p08EzmmqzGXCAURdk8rq8nQ/wM/qdlhyPxQnzqvTz7veBTX8ZCjcSINf3iArOF1ddBv1htt35LpnADDwupmOzaONMnQGTDIGiAVofPBPqLqvwVbfH1HZ8/eyzgoNDaU8mj08ZPo+l0eiuKkXXunVuPb8Db4wFC2hWaoejl2WySBCChGW34jmHgmEUEQTIdZNdVhfCIX9uScIeawN69MHhUiv5cn9CH76EPnxUejrmIaXN3cMqHtN3SePX0VbQBIfUJaaMVqUH/LI+0k6zRNd8ZgnunOE9zHoSB6JruByOpC22rLBHXh/S7WzBZIkUZaZBrdbFwWMxKNszdDTKjmLIlGacO08MvxfoLdNstdw3fAo/YIu6JPhJcgZBd5FUZWwBp9g6PE/wIxbinimEmqdP8Sw+ko0/rIIdaePyHMZRKKnbQjxHkWwvcSiyZSHeioKkxvA5QiT8uK0RspE/UYieDwSWdWd9Iskq/pvJmWRgra+EVx/8UaMrvQFVKwPTGYkXb7AHncnufcxk4YInFEuohwL6Pty70osVt4TPtarOkZU0wjfMBhXNUGBxcaO7FK5jrPDxZUqRNvyNUXaNPyhpG+BFcZ3oGx9EKudt4rM1H7t+DW9zFyoHo1nmkFYovUcS9TD8akJE7t8snArsxyapXU4lleBRRE5MpPZDyOz8Fl0IA4zjXGTeQu3wq5hjZEflmhGCNmd8WOqZV1wFOXMcNBcT4D0TN3GhKfzMkYwqnVWAMQCRGp+j4unr9LP/KXTV7FKPWTaEhpR6HrhS08yBl6/lvl3JIeHJsPXqGcko8NHxtUit18AYgGeW/+ENZ4boeqhii+ff4ncllyZ9zvXsLW1BUEQYDKnX6TX0D2EYHYDtILeYod5kshOiooMSq9/y5cNn8xalLX0UXUHYrTJPVorYKsWCxs1Jt4SV8EdHkB9UQGSfNyFkx/jH8+7V5Ds44764gLwRGSnweMBTXlAmhVVGD3h5zz1Y7MFiLgLFIfSTU3eN+aJrnjME905wlwPOnKMi3avIprktnsWgTfNVo7/LZAkier8N3imflMg+ISYGqCjXvxyviRpguXJ/Yi2t0R9SaHMxQ8kSUIpKR8KLDZeNYsJUtwxoDwOCLoMPF4kNIMvDt6EeKYSkhI2onA9tcTcEx4+ncsCAOhtHwLTqxh2fATXnZGKgsR6cMfEZ527mgfo77fX9+Pqc4oo7rRI/u86b8wAT6JKBF+A6oFYaXF8svmD9UEs0fSV2+t0Og0RJjDYO4pXT7Lpa612LQZL74t+WZ/XNgVBELhl4o7rxbVy68HHuGMoungGxcoq8D/wHVY5bhevq3Vfj1X2O7HS7AKUDPWhaOCNE+Z22O/gjpPu8fjTN0uuzKxCRDblM+s56TO76GE0tjxyhXfo53TRGeF5FMs0guhz/tUqRez5TG1C8iL8M8QzlXDSWl3g71O3wU+Qb2ioY0j7X3h+arIN98lz97H0fqhMsg55xgrJ5aJqz14UK6ug8tffQHJkq+zvS22gi4LH2mSYQA/3UsvcxAKce2mOhVEv8eXzbbRzSGxNrPRtzDGGhoboiVNZ2ewVefYMjoFZ0oInUSXYb5+GFZqRIu/bev0YnLMKhr3WUeTofIoR3X8JxOK4G9pUMuCSL7hswQLl3vY25MdHIfjpQ1ie2CdEeq1PH0So2WMUhD7DAMsK8D1O2TyKIrbma4HgK5R1Zt971gGLwTzRFY95ojtHmMtBxx0YQ6stmya5XUHlIOfIcH+u0FhajJd66gKB5tUjbTRXiA+egz3d0qUJw9PTP+3KobxNH1bw+azyuEBlIhB6nbJ8mRrsXH4GMh2AvmYMDzeCyaLamb6+ugKln38xLR/kvs5hsLxLBAiu2/0U5LPqwBmTPpEhSRIut5Nho8ZEUnQVXdz1/PX/bm/3EQ4X3xizoKgeDEXGJJFRemgMpUcGWKoeRmfpZM3QzqR4rrNxQKDw75pOIhTFkFxFRjiOa1uCIAhcNbDH3jflUGCxoVveIHQ8wewGnHLLxA6bAPzmZokL4Vo4HHYEG702InELlVFUv7RagNiuctyO5XZXsMTOAgsdAvCxW5LcMoMJMrvoWRoWOkyS2cVimgfsNXuI8BgVxDOVEB23YpyghglcO3kyuu7BXyGeqQQ1+5sSt8EveVh32wcOx3+iY8BetQe05Zq0NtTSjk8UBt+8obO6nZ6eUr/PG+Wi8WEG5WH+SsbsfUkEJcnQ+weUY5LwVWYxqnqqsMN/B1Q9VLHWYy28i73lOu7ZRnl5OU10h4bmTiI3PMZFdnUn7BIqcNY9C+v0YkTeyxWMQBxQfwojzQtgaX+DWs2NsFGLg40aE4VPdcVunzM2hpq3bCR4OsPt+lmR2d5nJ79B6uW1aLz/CXjGKwD/80CuF+V9+zfEPNEVj3miO0eYq0HH6RhC89NsmuT2Jdb9T2Xq2mqqEGikLxBQfLTvoK4wX+T3uZwxlL1OQ5DxA5gd+X1a0gSJ4IwA+X64HeYGBRYbxyN8AaYBEHZTtIG343fUMlaPcI/6kmKqNTArRAmNxg/lOoz+rmEkPn8Hu8uTBNf1Xgry4uvAkTNTH26bTxEwY6qoS5WIxuDo39xfUgoiy1OxzvUbrHLcDiV9K4GX3aYHsajpGJArQztdO7S6kk443UyCjRoT9lcSUJ7TKrV73H4tOxAEgfuPrfF5RhEUWGw417cBADqGOuBfHIPNtncpay/XzUJZ2i/sVMHa+hW8/jiAgy+MsCs5HEuDmfgw9LXMZFYpMg2bAuLwl+dr/GafIpXMipSLMEJx2+UvOovrH7EB3xtayXTd+DH12tv5/4h4phJuOF2SuI2JycnmWx7QP0LZh5kd/AVFN5fjgPpTmUiuLBlncWjUoHyM3336GTjtkvWdvazxugnNFHC6ZJx8j/viVlhugwKLjctFNQCA9qF2HAw7SI+Hp1lP35sn9FSwWCzKm9nG5r3ul8cjUdrSB+/MGtx8YIRt6m5ix6jG1SDq+bwagroOEXr9vhaqPiLkKmCxDiAWoFvjP3hzTRkBZ7bCgs/GcuJjc+4wIqyeojglAUN9s+d5P5uYJ7riMU905whzMehG6/voLEG9ZgoG2TMgeO8ZXU0NCLc0FvBA9Lx7BRU5r4WIOkmSaKmqANN9dqQJYsFX0BBk8yfsnc6h5ZGIzK39NiDZFOiUvNzcwQxAfDRFAspzZSO6A90jSPIthd0VPoJ7NxnsuFqMTVOKkhNVDUu1eKiOd8J6ECZbL/qZYCZaV0kY5Y7CNNuUbv6w3nMjdrjp48vH8QI2Rrssk7HVMF7mDK2srY35M39FqY10pt31bjKaK3sASCfNv2o6gSAIGJpa4JMEipgeTDCnM3WqHqpY47EWq559h5W+h7HM/wYUg55gYcgLfBTJwodxObJnZl8JywxUNALpLFyWegiCGCyZye3EZ7X2S1i83EWTXHv/H7FOR9hDVRYN7NRsupnvr4hnKkHd7YzUbWSnZuDJ4T9hcnA3DA/9iYTbmwFiATJ1tkCc9dlsZHQBgNPejnefbUaxsgoa1TXEfo83xEEDkU6ttgXLYW82HoscPW9CgcWGQ91kfB8cG8SluEv0eLmTeAcj3PfvF+vp6Ul12wsJee/7pjHeRKhJdwlCtX+GruY1/KJugyXjqz2f3o2gY+muW1H42SAIzo6WKHH9CyMWkrxs9wNpVhiryUZVbhaYbg5wvnZOONt76Ff4aN1Guv9ztFSWy92Nc64wT3TFY57ozhFme9ANlXSiQSeV8sjVTRPorvN3Rl9HO2IdrQUKxVyun0dxaqJQgBjs6UZOeBA8RRQO+D3QQFESc9rSBCGMDQOmqyU3cXiyBGiRnSTWXbyEDK2JblAbwOH00RljeO+n2hl77wfy/TDQ2YeUl2Wwv5pAB2WXO8nIjanB2MjMyGFjWReuXY2lX+xV7XPrQjATraskvOt8hz0he+iX+96QvXjX+Q4ARZa8M2vwuUGczGSNP0s4VScqKfNH8kikB1UIdJzraZtcthUtgwjFUl0XLDck8IvRNRAEgStPCJqULgnSx5JgQyyKcMPHMRFQiM+WsQAsG0uDs3CzuAY2ta2IaOvGvmdZWKIp+Txu6FAG/4FabqhgJGGFHNfsq0cOtI42nqkEDfdTUFIPFiKPigzZbeT4regMffYjnqkEfa8jErdRmBhPr+qYnzmKL+964ZTGI/p5PaFhIPc4kBednl60hGHwjWgXk56YatrLnNsno3ypq5o+j1+DvKDAYlMd0fjA4XFApBH083Aq6hR6RnqmdR7TAY/Hg4EBZVf3Rsy5vxeIaSnfq6uARO2vYKl5Cs9uEci9cxKNmhvB0xX2sh0j/o168+9RH6SHkao0sV62JEmis7EBOeHBePVIG+ZH/xB6N9ldOIYoW3O8S0/B8IAMzhpzhHmiKx7zRHeOMJuDbuB1M+o1KKlCk0Emxprfn33SdDHY24MET2eYH/uTDggOF08iPz4KXL5iDknSBOdr55Du/3xm0gR+kCTQUkh5HoqQJZQ/WQNT16soMtow+XcZ22eONTejeNVqFGxWBiue0upWFukLWeAM6ixG6q1rcLgYRRMn59tJyImqnrX2lWOjXHx1hyrm2G8u/xKtPJiu1lVSBpjL48K1wBUbvTbS2kTTHFOMcinSIIpYy5vJkzWje9b1NaKdJp0VgszeYHiKswlJkshtqMSXlmZYYXoFK51PYMXz41jmfwNLgg2xIsQHymHJ+Cg+d1qZ2Xt/MRCx/UcY/3JGJFGTRYYxIZ+w1jFBPSMZ+xhRQt9ZwgiHinaUwHU5aE4gIpYaz1GxK3HUUkfgN6q60dO2kZsYA/bBFxDPVIJb2GGR2yBJEpmBLwV8UV8l5o8fQxiydKgsXZ7OBqlZ3em4LggcC4eDyt9+pwrT9uwBOaVSn9s/SickeiLlaECT7Uo1wjD4BJ/EZ4vtiEaSJOzz7Gmy+0fQH2jqfz/dL5ubmwW6/P3XIK0jnIgPl/gH8ojPYKV1Eoc1jLCSEUiPiRWakdhrlwbDyGLEFbWga0D85GR0eAjl2ZmIdbKG46XTIjq0/QZfgoHXwa/QVlP1XmWF80RXPOaJ7hxhNgYdSZLoia2Z9Mg1ywGn52/U3lAERgYHkebnDcuT+/n0TUeQHRYo0JpRsjTBAvXFBbMXJNpKgYTHgPVmsYGQJBZgVRQLCiw2fOwPT5JT7wOy7cLGBsXKKijd8jlKSx4inqmEhFgljD2iDMSHdBYi7fZVOFycXFZzvhSG7LByjA7Non6WM4J3Sa/oIG6l60BlQObIPF5Wrat/Th39G0kZ4K9NX+Fw6KSjwg7/HchpmWzhKo1Yy5KhlfW4Ve6Fw0l3suhMTzsJv1kk45hbAnSSInAz0wdfhptDKdh0PDMbDgVZ29mmFWLvm3Ko+mcJyAwWa0w5jvthyFj7KYqVVXDxoJYQYZf1mvxIvKDbAZcx4vGYIToT7pZahe+esqCkHgKG2xk6i/sy/FN8Y2AnduIgL/gnOkYvL1OFbUkHhQgoj8dFnLMNHR9e6N7HUH+fwETloPpT+jn+S4MQS3DlyThLwmBWFp3V7XrxQuDfusMq6VU33qAcVo++x6jJtuteKLDYUjuiBZYFYr3neqh6qGL7y+0o6SyZzqnIhaysLBAdYpfDAAAgAElEQVQEgSdPnvx360K4HKA4DDASITPjtxt7+CnYd48jQc8K5FAvSJJEeWs/Xryuxe2XeVSBq7jnxTQR6gFvEZBbj7rOQZHnS5Ik2utqkBXij5d66kKJmonkToyjFcqy0jE6NLNxJw3zRFc85onuHGGmg47k8tDpV0qT3DbHfPBmkxDNMsZGR5AVGiBAXK1O7Ueanw9GBqkH/L1KEzqrgGQTwG6bcBA0XQUYLxP6+55AqiBNx0uDr/jsW6m7IrlclH23HcXKKmgxfIzR0Q4kMKmq9Hdui5F++zIcLobThMnpYiiy7pzHiM6HMmeMZcK45lhTk6peX3c3An5XbanzsNw4J+1AZcmMKo5nCuu7BiWQsjAsM9TDGtfJ5g86qTroHxVcCpSVWEvL6Eojh5vuRUDjXgJu6ybh9NNUfOYWhU+C/fFRdLTMZHZtSh72vinDFXYZ/nB+hq99gqkOfBnFMl+/LVc9aVL1vZqDEGGfgLSudKWNXXSHtkQNP8QxEsRmOgOy8mD76iea5Fr77cQa7Rcij48/syyrTnvqROeq4xXEM5XgFLhdQOoyNjKMIOMHdIwINTUEZ9zJZKr0JFn7S4BYgHc6q7GUz5ljJhlnSWi4c5ee2HK6ugAAnJ4R1GtR3Sl742pk3xiXAxhSloUewUYChWiSkNqQii3eW6DqoYrPfT5HWmPadE9HJgQEBIAgCPj4+MzpfoTA4wHNb4F0G8DnIGDwiWhy++gjwPMPKqYOdKClupeOuRW5olcFW3uHEfG2CXqhhfjVKkXss7jFIA6XfXLhnlqFgoYecEW4HI0MDqA0MxXR9hYCXT35mx/5PdBEdlggOhpmv4h8nuiKxzzRnSPMZNDxRjhocy2gSW7H8xKQIpoD/B3A5XCQFxsJB7UTk+16j+1B4jNXDPb2UNKErHSJ0oSe1haxWla5MpHddUCqJUVOpwbBpyuAiHtAbQYVOMcLGvi/o/FMBwosNg4EOMuV0e1PTKTJyEhFBQCgJJCyTIqNXgX7a8FUE4eLYci8/RdFcOXMGEvF+HJeL/ERVjH8ocgIx4nr0bBTiwZH99/Uvqw2zXpmV1at6wTh8s+pE/r7Ek1fKFtPVpWvdvkcjxNFTwBkJdbiPvzErKZzANssk7DQOA4LbRPwsVsyPvZLxKKwNHwcJ2PThOhkfBwcg0+8o/GJAwsLTeOh+Cga35pMLo9PeI9+/ywACiw2DudV0McgjbgfP/4IxcoqyFulCqV7IRIzqdK60jm6uIEgCHhrOaCWkYS1jAihTGdPbx5CYib1uPdcz2OpunArYEVGOFR0ogTaFIvL0n9rzIJrahVOu73GbstkqGhHCbgjnLO9g3imErxCttKEu7urCz5at+lYwXR3AI83SVKnjoPf1S3o5/i6hvqMM87SMNbSincbN6FYWQVNOpSNVVdgGdWCXT8dPHlkSLWZ9LH/FhcjVIgmCUUdRfju5XdQ9VDFBs8NCK0IFf/lGcZYCwsLEASBlJS5lUOBJIH2ciDLBXh5QrS1I7EAMFtD+Zrn+QK9ouUboZZs2Kgx4ftIuOhZFPpHOEgpa4dZbCmOOmdARVtY4qPICMca3Wgcd8mEZXwZ0iraMTQqLLdpqapARoAvnuvcg+mh34SIr/PVs4h3tUPlmyyRHTvlxTzRFY95ojtHmO6g4/aOosUylya5PZFVf0uPXJLHQ3FKAlyuneebsf6OWCdr9HW2o7W6Eix3R9jKIk0Q0c6R/q+kTCRnBMh0oiQJjz4UDoRGSymbsKpkyhOXHyIKGjwcjlOZuKh4uTS6dZcuolhZBdU/bcKIzU/INDCCy42XiIlejXimEl7ZXkDG7YsY1hHRVcfx2xndh6nn4661H4qMcKxkBOLpxXjYqDHRpLFZrvORB/ISz18skgS+r/TQGKtdvuBr/nAAS7V8xRIUeYi1IiMcixnhVDtbY6qd7fZINg6/KcdXmcVYmCCDXpbFxkex8fgkwheL/N2w2NMFi22eYdGjYGGZgRhSTZIk9PX1seVVFBRYbNx7NynjkJZZfrhbDcXKKgj4YodYwi4rUlJSQBAEjMbbAesYJQuQ4YZGXzBZ1EpERKwKDpjrSzy/n82SZDoH/qyxqL8fs9RCPFMJfhEbocgIx9rbz2GpdoaOGdmhAUIkRdQEIVZ7O0AsQJXOCixjBE/7OsmKiW51xSqr0J+Sg3oNKpvblyRsPSgRLENKR2qxnh5zUwvRJKGhvwG/Bf1GP0NO+U7CpG66MXYcfX19tD63pkaObLWs6K4D3ngDAX8BJiqiia3xcuDVWSDHg1qxk4G4NpV301ndqnz5dcVjXB7y67vhklKFi89y8OlD0ZKfZRoR+N0mFQ/DihBV0IyOfsHJw1B/H0pSExFpbSL0TpxIDvkb6iI3MhTdzdPTXM8TXfGYJ7pzhOkMurHWQTQ9plpG1qsnoz+9UfqP3jNIkkR5dqZg04ZDvyLC6ikay0qQEx4Mz3tXhR5ksdIEaYUFojKR/W1AojHw8D+if2PwCZD3gloSnLqviYyG/Vfj5HiyIjfTdBv9oul4tFimDOhYaS6KVVTwdvUGJJ+9BKeLoXRg9bO+RPnqxi7FyCPhyt9Zzeh67wep+wG2qztBkRGOO5r34HHpBWzUmMi9e3J8nx/M3v7GIY+UYKk6tZSsyAiHokYAVpqfmbTXct2E5YYEJoqJxPmciiLWixnhWKQ3SWY/dkuRu2nCR7FxWB0YjV+cM3DULA1/GUfjR9enWPbYCEu0vCGrdRX/uZ5yfU0v5WvqGWB1aCIUWGyYVgm+yETJDiY+L7/chWJlFRj+cp7+9+kWU/EXE+WrR6IrkGrOwuONoLhEk87iBkV/ga8eOUo8vyWMyWzpTOQkigyqAUU8UwlhMauw+aYbHhzZTy/1lqQmijwXUeR6h7odXWHP0Lwzo6IzWUCOjqLiF+r+lP/wO+ruJ6LRIBOkDI1dBOD8I0AsQL3/VWqVQEwhmiT0jPTgZORJ+nnST9cHhzce/6YTY6eguLgYBEFAX18fY2NyaI/FZZF76oECf6oZj8V60cf1eBHw4ijVlKe1RCZiKwpBZrlUPDbMmrFcgCRJVLcPwC+7Dvdf5WO7SYLYcb3dJAH3X+XDL7sO1e0D9L5JHg9N5e+Q5ucNb42bApabEx/XG3+B5eGE6vw34Mh4veeJrnjME905gryDbqS6Bw16lPdivVYqhgr/i1WtYlBbkC+wnGhycDcCn+ghJzwIQcYPhaUJV88i/dW4NEEcxFjFCH1y3KmZvOfv0qttRQVuURkNPpILvX+g++HHNPFJczksXdPKGUHTiU8R+dMNOJydJLgOapFIu30VffoLkRizBPFMJZR6fiT6WGcrw2r/FVK0v6SD7Fud9Yi5QcBGjYmI6waT+3P4enb2N44JwiErqVHVjcYyfRusdvqGfimr2O3GEm1PAZI4NaPLJUnUDI3AMKtq2mT2w+gUfOSfTrsZLLbxgrLnYewNPAqTxy/o+xdokoPhgTG5s8dTPxNtTJeqh+OazhMsiqW0vRtdU4UKovhlBz+bJ2GVdhSW3g9F7up1KFZWwdmjVHZ1JsVUPB4PxsbGIAgCEZrP0GScheGRZmRl76NJLjvvDIJzS2Q6v4ls6UzlJLuMnyKeqYRA97UwPETZNz05she1BaKbyExA1AQhVHsHQCxAi54S6tu6pnWd5MFAWhotW6o6bIj+DDmTE0NddDwKTnomUyGaOIxwR3Ar4Rb9XF2Jv4LBsUHZY6yEWBQTEwOCIODk5CT7AfHHXELERF9IY/sh8GwvkGoBNL4RXoWbJurfddHPdm1hx6xskx/t/SOILmzGo/Ai/GGTSnejnPr59GEcLj7LgUtKFfLru8HhUnLEwZ5uFCUxEWZhBOszB4WzvSf2Isj4AfJiI9DbLl7SMk90xWOe6M4R5Bl0g2/b6SKGRv10jNT8vTqvNJeXwu+hlmB7RPWbCDV/IixNOLEPUXbmqC8qkM1IW4RWVvRHhkApLnBLtaP5gAqyDl9jQ1wSFFhsuNZKXj4aHeYgxy0EjmdD6CBqrxaJlFvXMai9iN52lavCZFbXgG//s62ZtduG8xp6UGSE4w91c4BYgPy7h6jmBpcCQOqO79f+q9nZHx/quwbFatkEs5zB2OpwG2vcqeYPa9zXY4XxXUy09eXPzN7MKIduWQOO51diW2YxFibkyZaZjUnAwsjnUAwxhVLAfax4eQoqPjuwxpOyKtvucwBbnk6S6pVakbiolwhLNUrmEe9eBO64Hn6mBI7/c5owp49x8ZNYmZoqRIam0CTqtmnIrBRTTRQUOWlbop6RjPSYnTTJragwAUly5baMm+mEYLuhNV7aboTJoV0wObgbekcO4qJVmEznM1WXrOEUAJIYf84y7Gd0rWRF5R9nUKysgpL1m8HpkJNcFwWPx4N/4mLuW5kL0cSBR/Lw5PUTmuweCT+Cjmd/ypYckLDa4+LiAoIgEBUVJduBDHYCJsrSY7TrTiDRiKqd4MjfMl0WkCSJAOMc2KgxEWCcM+eOEUOjXKRVtMMyvgzHXTKxWkd0bFylE4Wjzhkwiy1FSlk7BkY44HG5aCgpQsoLT3jevyayNbH77UtIfOaKusJ8AavOeaIrHvNEd44g66DrS2lAvfq4R65RFsba5taCRB501Nci+OkjgYfM8dIpOF8V7hbzUl8DhYnxGB2Ws/+5wzeyE9eH/6FseOy/kk58+QO3HBmNw3kVQjpKfoyNcJEbUwOXO8k0wbW7EI2Ey7cxoK0otE3Ogw+QGE1ldd95fTT5wrHaNKsuCA1Wv9DV5gHauwBiAdo0N9DH2KO1cs6ILgCRRWYC5EjXBascfhrvALYdy70uYqFD0LQysypJOVgcFo1F/m5Y+kpHiMxOfL58/iXUYtVg/cYaiXWJaB+iVklIkkRYfiM+1Z9sqrHpbgQ8nwt225vpkjz/Z89j50miS0QJZETFodvfn2o5u3nLrHVfysvLA0EQeKCrj2pGArI9TyMhcR3a2mIEvifNxYE/qzyjCcH9MJy9eoeOI1onjmL1Hd+ZaWuDLlNj3XgZMDq3nuOj9X2ovRaE4tVrUaysguaHj+TbQOj1ccK3A5vSCuUqRJMEz0JP+jn4xW0dah7+S3r8c/xW5LY4HA4ePHgAgiBQWFgoeoecEaA6ldIbu+4E9P454yzybKK2sIOOhfXv5j7Tzw8Ol4eChh64p1bhsk8uNj8SrfNV0ojAr1Yp0AstRMTbJrT2DqOvsx1vmTEIMTGA1an9Qu9dq1MHEGJqgLesGJQWFMwTXTGYJ7pzBGlEl+SRtOdiPSMZLdZvZO+iM8foaW1GpI2pgHbI8uR+ge5mMksTpMF7v2zZWrttwEgf9RtZybHjt5P7kDGjQZQ3QIHFxu+5ZQKHOTbKBTuuFq53+QjuXzEI3q2Dkm83Stx2tTdluM+MV8Lw83H7m1l2PzAypDxWNzF8MKz7b4BYAJ7uP2jf3nf3f6OOZ5alCxPgzwIKamZZWPj8BRaGu1MdwJiydQDblFaIPbmlOMvOw7nsKBxJtMYPwWeFyCyt8XVbj1X2v+Azu8vwfBuAmt4aiZmbhtIuWN9KxJ83o6B4f/Jlc/9VProHR4XOaaZE9wez55R8Ij4Xi9VlcwRo0iVQrKyC2jNnZu0+9fR00DrdDI0glFrZYWCgQuR3pbk4TGC6E4Il90Nx5uzdSc/Rm9/hWz3bmWtru2oAfeoZQLLp9LcjAybccaqOaVPZ91WrMVwio6ctSQJmqgCxAAPMx9MqRJOEqOoouunK166rkG/4f9PK6NbV1dFjpqdnvBMblwPU51DX1/MP4KGC7AkLGbPIswmSJOFnmDXe9CX3vexT0rHUdQ4iILce6gFv8aNpothn5BtjFm6/zMOL17UobexGbUE+Ep+5wv32JSHSq/PrD/NEVwzmie4cYYLo7nTbiVNRp3CNeQ1aKVowyjKCfa4dnLzM4GlggsAH9khyC0RlWwU6hjowxpND6D/L6O/qRJyLHcyOTLY5NJ0ilJdbmiAOnBGgJJwuxJBr5i8HcQUgFzF+0dQBBRYbK5PfgiRJcMa4yIuvg9u9lEmCe5kFpjMbb9Z/gWJlFXSflBDk9f4Bjs9eJCVTlk0l77RndI9EYXiMi42alKWYkeYFgf0HXbOAjRoTCTfvz+qLZUIzm9jZB7eGduiUNWB/ThkWRebInplNyMfqyFyo+mfhm4Bs3Ep9DevCCOilG+Jw2GFs8NogktSqeqhiteN2KFucxPInWlhKOEBxvMpelmKtkowm2F1mUW2XbycjLq0OOy2S6ZfLxgex8M+pB0mSEjOby8e1eFP/PqHN5f9ssQuCAouNpRHp9N/EFdxNoGrPXhQrq6DVzHxW7tnQUANeZ/0GY2OqJfErLVc06KfN2NVlOhOCZfeCcPXU5MvaReMrxMYuwzFblxk3dAAAhN+hnoHHi4HhuWmTO1LVQycqBnIbUP7zz5T7ytFjsi2Pt5fTz2lWYeK0C9HEorsW2TbrsdV1NVQ9VPGZ22qwjCTEKjHZ1dTUVOgRuvB8ygAy7IDnh2nfX6GP1SYg5BpgpCRfMuI9oCq/nY7hTeXd722/sqBrYBRxRS0wjCzGXrs0LNcUrfPd+CAW5z2z4ZhUgbS8MuREhSPQSB8WJ/bOE10JmCe6c4QJoqtsriz2ZS3us9l7M37w+wF7QvYIkGTjLGM45DngeclzhFeGI7k+GXlteajqqZoRSR7q70OSjzvMj+0RqQmakTSBH5xRoDQGCFQDDBfKPuufqmWVt7hCDmLM7h2EAouNj+PeICWuGu73+QjuJRZYz0rQ2zGEdnt7allZdSV4WtKPo6bWicrqspQxNCSn/ZAUBOTWU0SLEYoG3aUC+868rQYbNSZeXHGV+DITBVFkVm7NbGwcFkZ64+sEf5hV1SGyrRslA0OoH2gDq5YFy1xLnI85j60+W8U+D9+9/A7XmNfglO8Ek+RQKGq8kkqkRC19kySJzNBK+n5662agu5UiVRwuD87JlQJa4yNOGahs6xeb2ewbHhP595Ouwkv5qm7RlHVdIJMmxZIyuryRERSvUUWxsgr64uLkHxRT0NmZiqTkTxHPVIKzyz4QBAELHWPUM5Ix2jDzDKKoCcESMfdG5a4f7h2fbJ969IIG4uIpnXBzW9KMjwUA0Nc8mWVkGczONvlAkiRa7fOo1TjLXJA8UsBPuydUgp/tBDIdqeN7ogjzyoYZFaIJga8uoeLRv/CTiwpUPVSxzn0NfE0+Fh1jh3v5XGm+Btx2AUFXUGuyHQOEGIJsuhoIukS53PQ0TClAm+OMrpy+wCRJwvfRa9ioMRFqyZ7+ft8Dhse4eF3VCRtWOU67vYYqES3yWVqpFYmDDul4Gl4ANw/feaIrBvNEd44wQXRN4k1gnmMO/XR93I69iZNOh7DHfhd+ctqOL722Yp3nOrmJsDSS/OOrH7E3ZC9OR53GdeZ1aKdqiyTJOfWvEfjSGo/P/A7j8UKQWZcmcDlABRMIvkJlVwSC3QeTxQgW6yaDH/9/RWlZZel1/uD/AV57qcD3xkdmYtw7MoZdThkwuJlAEyLbSywwPYvR206RfJLHQ/n27ylN3p6VMpF0LncIySlbEM9UQnGx+gxGljD+sEmFIiMcFwhjoWtSo/7d+HnEYcT8S6GXwGyQ2U1phdj3phx339XBpLIa+1mmtGb26xdfI6IyAlnNWXArcMOthFv46dVPEsfv6ajTMM0xRWxNLJoHmgWyY7LoQUW6NozxEONSyOeskIvhAeGJYUP3EM55ZNPbWqEZCfO4UrmW0kUt5S9/nkB1RXs+2bVLkg51iM2mSdNYy/Q1myRJoqbGEfHM5YhnKiExaQPY7EB6KfodIxZ9ibMz8RI1IfjCQFCPuO62N3SOUgWsTw/uxu8XDaHICEdkLOU53doqY7GTLIjRpp4Dg4+Bgdmtth8u7aKzuUMlnfTf6y5eojqmffUVuP1SJhA+B6nj8zuF02+rZlyIJoApyYDWB//EPseV9HNmbrEIPP4sbG0GYL5Weow0UgL8TgPZbkBHhaDllyxxWcYsslRM0xe4IreVjgEtVX+vom9J4PFIlDT3wiujBtdfvMFWw3ihGPPJZY95oisG80R3jjBVozva2I/GR5lUcNRIwUA2RR55JA+9o72o76tHUUcRMpoyEFMdg1elr+Ba4EqT5DuJd3Ah5gIOhh3ETv+d+PL5l1jrsXZWSfIGl7X43GEDfnL9BkcCDuA68xpNkh3zHfGi5AUiKiOQ0pCC/LZ8VPdUo3O4UziTzOMC1SlA2C3RS1jOPwDptkAvnxUPZ4QKet4HqOUs7wOStazdtVSA5g9woogmsQCw3EBp4SR8j2v5GQoTa+ChkUoHQpuLVBV+z5QCwf7kyWr44RsSijymkPTaOrfxrO4KDA7Ozgstv76bDnQp7CKhazKs+wmsLjLx8HYCXqYVzgqZta1tpTOzQ9xJ+UpSfRK+9f2WHk8/+v2I34J+EzuZW++5HvtD90MvXQ+BZYEo6yoDV4qlkKwV/vyygKH+UQQ8zaHva7RrIYJy6iS2qo0ubMbnBpMvk+1PE5BW0S5Tm1tRS/mLA9OgwGLjF3dfrFAPkSqv6PT0QrGyCsq+/mY6wwIAwOEM4G3BVdpVITPzFwwO1oDD4eDRo0cgCAJMTV+0ubyd9j6k4bTbazqzu+WGKx4e3kfZhx36Hd9ftaQnJqExVLa5sXEWi5MGOibbxcZozdpmSZJEi/Ub1DOS0WqXJzARG62qQIkqlYlvObpRfJaRM0q1rCUWALmes1qIBkDkKla/3ge4YL+Mfv4YNksxZqZKFe9NaJqnfHjEApQQGxBJ/I7WvFjJXrayrrRNSQLIjRn4ApM8Es/1M2GjxkS4rWT7ur87GrqHEMxugFbQW+wwT8LCK/NEVxzmie4cgZ/oDpd1oUE3DfWMZDTopGG4tGtW9iGJJLu8dYFZjhn00vVwO+E2zsecx/6gffjG9Qtscl4HVffZI8iqHqrY4r0FP774Bnu9t+KM02rcsFWCjvUSPLVcDEezhXjhvAURUdeQ8i6AJsldw12TpubTwQQ5fraPyuBKCqoW60RmALi6/0SRvho81ZNoImR9kYm/DFNwJ61c5G7rr1yhtHjbJOjQjJdTvr98y2rcPB+kpHyBeKYSioruTv+8+XDHL48iYiYJqB4cRkJbB9xex0An1BHHQ59hW0w8PpZRMysLmeUHSZJo6G9AcEUw9gTvkTpGdvjvwN3Eu/Ao9MCb1jcY4sgvg5E3o9vdMohn2un0vY1/VYrvjFkitbXfTXET6B/hQD+0SLCTm7qgdm6CxKloR+Fn8ySa+Fa29Qss5X8USRXhHXBww06jSKk61IZ791CsrIK6K1fkvkYAMDhYjYzMSeuwgoLr4HIn9+nt7Q2CIOClbYcG7VSQY3PTYnwiu/3tNRs8HvfIfXR4D7becBK4jrEJ3yGeqYTaOrfZPQDWuIf0w/+IbRMrL4YK2uls7nAFn9ZzPMvYtveT8Y5pyhi59W/RWcbqFDpWdLZVz3ohmri6hDFiATStl9DP5Dn75ejTE18MnEdsBkEQeERogpvnJ3mfMltFCicB5MIMfYFLs5rpeNBW2ze9Y/gbori8ep7oisE80Z0jTBDdsig23Rqy8VHGrOjh5AGXw0HZ6zQ807gpIEt4enAXjM/ugZ/HU2SWJSG9MR3R1dHwK/UTSZIPhB7ADv8d2Pp866xnkj/3+Rw/vfoJ+0L24Uz0Gdxg3YBOqg6eZj2FY74jfEt8EVkVidSGVLxte4ua3hpBkixr4GM/p7PGPIfvUGKqBa97sQIZ3BiXQhhlUS+en7PfCV3PsdZWFK9eTRWhnZCh0njKslrds9Xj5GM5BgYq5buX4zKDhM5euDW0497bGiwZL4ha5JE6LTIb1dYjkczyo2ekB6kNqbDPs8fl+Mv4xvcbsfd024ttUItTgw3bBkn1Segc7pS6fVkga4V/MLsBjWVdcL5NTWDsrrBQmN4olz/sBOKLW0QWmInbxgRprmzrRzC7Aafcs6DApCYbZy1sUVUr2rqOHxU7dqJYWQXt9g5yX6P2dhYSk9bTqweV1U4IflMvkIV28o8GQRB4rPsIdYwkQcI2ixjhcHHyngWMD1JFrbpHDmHDLS+ha56Z9QfimUqoqrKa3QMY7pmUTIXfnvHmSB6JZrMc1DOSBTPhfFlGntYHKN+4HMXKKqj5ZinlYT01yxivTx2T9WdgdvTOfiGaBDcbklgAK/NF9LO6x3kVmh+IXpkKI/4EQRBwJ85K19PKWvRrvnZmrjPyFiNPAY9Hwls3AzZqTEQ6zN1qxvvGvI+ueMwT3TnCxKDLuhyAekYymk2ywekclv7DWUJbTRVYHk6wPn1ASHvrdOUsipKY03NNIEnwGtnoidFAndVaFBr8G+mP/x+ijRTgZ/IRnB03wDTgAAjmTdxKuIVzMefmniR7bMA+p5U4Y78cN22VoGu9BCYWi+FkthC+Jh8j0vhDpD5RwNtnv6KquxpZqe/gqTNZZGajxkS0UwE6GynPzaCWLiiw2FiSmA/elKW6dgdHviI0+ZtY8PT/gZSoZVSWrfCm0OWdSmYlyQw+dqWcAhZrRkAhJlcsmXVKroLuvUTY3EwET1qF/XiBx8izvchz/BLeXt+DEXIEuwN2Sb0XxyOOI6QiBLW9tXNmyi5rM4OCtEbaWcH5dhIay7rlIslT9yfL78SR5pqhEfreXDd6itLSUonnyO3tpaUxA2lpMl8bkuShqsoK8UxqfCUlf4bS2gT6+Pkz2OvUX9E6XbZ6OHqiq6d7SyQcD4lUXy867jCOn8Sauy8FjmXCkzf3zXHEM5VQVm4468eBFDPq+dP/N2U9NgMMvGmls7mjdXzZwCmT7d5z/6HvYe8ZvlblE1nGCVIYyYBZdfPsFKJxRoGadCDhCWD9mdRY5GfyEdaNx+MfXFRQ9khYvkm5K6wAACAASURBVGBHXAJBEIgndkp3SJghAZUZ8tpLikBJehMd+zvec/JprjBPdMVjnujOEfiJbqt9HniDc28bNtjbg9zIEHjdvy7SOcHj7hXUlxRNb+OtJdQyoNWnwgHFYj2VoWgukNqPnMvjomekB3V9dShsL0RaYxqiqqPw8t1LOL91hmmOKYg0QpgkS6jKn+5nk8tn+Nr9O/zpvwdno8/iJusmdNN0oZH2BEuD9KEY8hSe70KQ1pCGgvYC1HRXI/eX71GoooLmX8XY68jwqbVXwHPmFzBj7oV9ZdG0NLMbUwuw4kEMFBnh+MPrtcTMbHfLIB3U2+uFl+p4JA+VPZUIznfFQ8d1OOS4Ahvc14i8Zms91mKn/05se76N/tvvQb+jqGOa42oakNjMwJiFOL939Pk+005Hdwu1ZD+dQraZNo0IZjcgpauPvm+a+g/AZkuu+OZvK6tmxxKrBeYHh9OHvPy/aKnC66zf0dNfJ2FSEIa7ugYgCAJhml5osZndKnQuh4MoWzM69vjqayAws1ysJ2/+24tUoWaJ5qweBwCqaYTxcur5C7o87c2QXB6ajLJQz0hGu+eU8T6F5JG6C1D77RJKZ71hBTUpniB5A+2T2dbSmOkXovG4QEMukGIOeO2hujvKGofGM8yJ1XHYPE52t7quRtbjSQnYMPF/0CN0QBAESon1lERMEmah1bBMmAVCzeXy4KWVBhs1JmKcC2Z2PH8TzBNd8ZgnunOEiUFXYMmaM/0bQL1QyrMzEfz0kYD/7dR2vfUlYjraSEJHBZBoDNh+IRxIzNZQVc2Nb6SS29kCTZJ7p5Bkrx/gbL4IphaLQVgvwS1bJZyzX44Djivxs7MKtrjObhZZ1UMVn7uuxs/OKtjvuBJnxzPJhPUSmFoshrPZQrww+QRe5iqws9kGQ6d9uOV5HYf8TPFlWCAWxmfJJTO4J0JmEF/cQpOWd82SdWYkScLlNtXooiCxHm2DbWDWMmGRa4FzMefwhc8XYs9zu4sKrtsqwdl8EdJt18OZbY9NXpvofzfKMsIId3abX8gCURX+QTl1iHYpoEluwNMcDPdPTjCnU8g2k65fE6TZt6mT8tCNzQJBEEhNTZV4bhVm1ihWVkHsp18LEXkV7Sj8bJYkQHwHBsqRnvEDTXKLiu6Byx2WStKPaFmDIAjY65ijXj151ibjo0ODePVIm44/EdYm4HIkb7uo6O74KseNWTkGIWQ6TBKg9jLp3xeB/swmKpurnoyx5ikd10RkGUdu/RPFq5QpL+Q9n0xmGd++ov7/wf8BowOyF6KRJNBaTJ3Li6PAYzGTbcsNVMe1TEeZ3GwKgs7jG9dVUPVQxUb3NYgwpghzBaFKZ/0Hif8AEVLqCmZQJCYXZolQFyY30JK1rqn3838Q80RXPOaJ7hxhYtDV182uZ+oE2mqqkODpBNvzR8V633reu4Yqtpy9vbuqqaU++6+EA4eJMhClDtRlvTdyKxNEBD5S9wNUMH7G8ytusFFjwkotDiZXQuFpF4vkgkykNaQhqoovk5zNl0mOPof1L37DqmffYeOzLbNOkld7bsaqZ99B2Wc31rzYg88Dz2Bn5B0cZz7AvXRrWOY/Q0hFBNIa0lDYXoi63jr0jPQIOBKccH0NRUY4DjqkS7w0A2MDyGrOgt3jMNioMXGfsBB7XFvcVuOs/XKYWSxCnJECmh9MtvFsevBPnLNfTn/3x1c/IrMpc67vrMwY7h8TcFaIdS0Ed8oEczoZXVnJsSTSbFJFLU1vjEoDQRCIjY0Vex4jHC6e/3wIxcoqsP7hqNjtThTBqTmbgJmgOq7HXYn6em/6eZd2vt9oeIEgCOjp6qGSwcJQQfuM78NAd5fAilKyj7tM8eddqR7imUpg552b8TGIBGeE8nwlFlD2WHKCHOOhyZByzel4LqLzmZgsY+ufVGFaySpljN75N5VlDLpE/bvHr2gf5YgvRCNJoLMSyHEHXp2hWhqLInQmKpQ3OdsH6J6i/5bFzcZrL+oe/gu7nSc9393MPgGL+BEEQcCauErtx0tKRhcQ7YYz223PZ4lQczk8eKhTLjtx7u9vRWquME90xWOe6M4R5mLQSZMmTHxcb6rhXXqK7BrcngYgzRpw2i4cNIyXUUUc1anATDqhzSX4Ah+puwCVjB/x4oqLgAY37I41Witkf5H/VUgVpKkVVKFyYAAhpUXQuHEBJx7cxq5gR2wONIRSsBGWBOlDKeA+lr26ghUvT2PliwNQ9tmNVc++w2rPzbNOkrf6bMX3L3/CKoefoWL7Bw4HXwSRRsA0xxSO+Y6wzLWEbpou1GLVsNN/J/27YwY3YKPGhOH1l1D1oKy9DoQewIP0BwgsC0T5s9/AFfHiIIkFCDX+EF+4raa3pZ6sjt7Rv48HZXfrIJ7pTDorvA6tFEmupqPRnUlGdwmDIs03S2qhwGLjp6hkEASBoKAgsecSzG5A8votKFZWwbX9DAnbDsUtZzU6i5uU8jm6u7MFtiWNpK9gBENHl8rYpWoEoCtItMuIrOhsrIfTlbNUHDr0K9jR4TL/tqLCBPFMJeTkHJrRMUhEjsfk2G6WrwipL6Vh3BoyGWPtItxCxGQZeZofoGzDCqqV83dLQIbeAkzGvbdTzIQL0XobgTxfSmJhtkY0kTNaCrw8CWS5UN3VZpp0GM9Gd+r/A0cdVtDP+UnL7dAldBFM7JvMRssCea0ip4NZItRvE+ppr/Sethk0Q/obYJ7oisc80Z0jzNagkyRNsDp1QKBFr+Pl0yhgxYLHlaFyt6+FWtpy3SEcSJ8oUm0cKxOohg//AyC7alBlcAy+V5wECG7otadofvKHxMDHXwDmWt8GnbIGfJlRLJO8QIHFxofMXGyKjMK+AFfc89aDrfMFRFn9ghKjdejT/z906/8DtQ//hQKD/0Pqk/8g0vhD+DLvwzT1Bq4FKOP8KxVciT2Ls9FnsT90P35+9TM+9/l8dkmyuyo2uWzGVodvsfvVbpyJPoNbCbdokuzsvBkvTT5GlPGHSHv8HxQa/B+KDP6Nq7ZK9Da2ua5CjPMX7/GuSkdjeTcty7C7zMK7DPEWUrIWsvHrYGeq0bVNKMcBdjkUWGwci6GIro+Pj9hjvGoZRetzd1ywFbnN1VovYf5yF01y7f1/QEhuntC2ZCHpl3WMQRAEXmo5o/lptogjkg0NJUWwOXsYJgd3w+LYHpRlSV5pmIqaGgfK6/f17mkfg1Rwx6hlfWIB4CMjoeaMgJfzCo2a0ahnJKPriZ0YX1zxWcbeM5OFaQMX+Qq+mvJgV1KEcy/NEeh6WnT9A7GA6iLpc4jyHm8umP2EA182ekjvA1zje+Z/tv0ZGXpfzGr78FnDLBBqzhgXbuPdL1les9SV7r+EeaIrHvNEd44w00EnTppgcXwvPO5egfmxP+m/2V04htzIEHDGpGjsBjqAbFfAfbdwQDZcRC2plcVRL4T/EZAkieq37fAzzBIguCF3ndBsd5UOfKLI7DE5CsA+ZOZi3atY/BYQO6mZbWnHuzfBGPI+Mhlo2c+pl6kMy2okyUV6xo+IZyohL++80LlxeBx0/X/23jsqqmtvH/eue9e973rXb5mbm5uQvIkxwQLG3pLYE1M00cQYa9QYExOxRaNRh34UEEHpUhWkCoKFIkibGXovQ0c6SO+9TTnP748DZxiYYQoDGr88a52la2bOPoV99nn2Z38+z9PfhsrOSiTUJMAp2wm/M89j/nUtzLv+J9TtpSshKGtb6roQXzirY4/bKhwNPypKknNuw6/ID2EVYUisTUReSx6edVHpFgJy8lYBilLqYX9qpLJCm9R9xi1kG6WjCwBd/VysMoxUmOiqaoXgg9txUInIwAU2lbpw69YtiefH+MMGBWrqyFH/AHMv+I9pb52hE3wer6ZJro7bYczVChBrJywLSd+h4wSCIGCuZ4JqRix47fIrwxSnJMBqyD7c9pf9qHkqP2GorvYCk6WK+IRNcu8rF0ZGXqulEPshXdxOnV+HlBZY4OkPFbWJc98aGWUUSaOaicoN76NATR1Nu4ftd18B7NaIHyMM3wDcvwVizahznOxgw6hoNJ+YCW0bYRrDXscFaLvy74kXkb2g4ERW0RPlrilURlI2pomuZEwT3UmCIp2OSk0IggdjbGqCj/5FBFkY4+aRvfRnN4/sRfIjXwz2j7Pk0tcGZHgAHt8Bl18VHVCv/h/w4Cjw9Ilyl5WmACRJojKvBfdN0mhya3OchVu2mXiQW6cYmR1RAKaRJxRxD4hLRtbCxZQTWsGol7g4v/UkB8n2lKOW1eobgmjS0tGZBfAG0M+5C47nNnje/hCX3NfiK+8N9EtnvuXPQyQlAB84f4yVnitxKOQQTFJMEFIWgmedz0CSpAhJzmnKQXxNPPQtb+K4/mVo3zXGjdQb0IvXw1n2Wfwc9jN2+X6GL5zV8eGIFAVlbIvdFmON9xpsebAFe4L24NfwX3E+6jwuJ16GRboFnHOcxZLkzsFOiSSZJEmkBpeLVVaQBeIK2cQpGlS39UqVFhvOlR1Nmj+6Gok114TOau8Sofj9YRwIgoCVlZXEc3M5QhlFBH742Zhj7bW8jJAINTBZqgiNmI8D1rr0dyML6EZep7QI9g6TALrgqEAzHD1p9TLfRwDIDHsMs6FVpVunfkFrrWI1CfX1AUOSaCsV2l9mCATC4lr3byX/bihCKyDeRg3jCaoZsWjXviA9D5Q3AAT/OYa8DvzxHxSoq6H72FhjG+7lV1Fnv5lStamIm/qxWEw0OpVYi/0W++nneLvLIjxrK53a85oicAf5cLlArQpFe4/VTv+rYJroSsZLTXSdnZ0xb948/Otf/8KSJUvw+PFjqfu4urpixowZY7Zr167JdWxZOx2fx0NpejICza6OSU24depnxN3zQILfXTgcOyQS1Y2964q+bgnV9v2dVJ6X156x1o6GKlR+V34AwP3r5STxBAIkZjfC0CEdP92Ix7cOSVjvlYIlTzLxtixpBqPUDOyH1Aye9vSjf4Q0F58kMTuaIsd3rluiQE0d5btHLd2N57dutYzKe3ZYTy09Gr8DOKwDMu+KvMj4Ah5iEj4Fk6WKB6w12Ou8WKK01yLXxVC74o7ZjGB86xiA/Jb8sfbL4yDOtxi2Giw8MBUTyeININt2qUhByi6n+Qg3VUGcyRsIufEWfByWwoljR5PkM6wzOBJ6BN8Hfo/P73+OD72UW7i32G0x1nqvxdYHW7H38V78Gv4rzrHP4zfXszh09SyOXtGClo0ZHheGIKkuCfkt+ajuqh6XJMsKaSRxNiMYq40i0dI9IJE093P5uBKSj3dHtLFRywPahqYSj5u2+wAK1NRxY8vP9D6qmoG4dOcXekLkG7wSm67aiRBWcRFdQHoEu6qlG8bGxlSRnLY3WnzEFFqJASkQIOauKz0meTDOoKddekRdEpqamUMFdWoKtyEzCh4Lx8PyWPG/GYpydmifohwtGRHg6787NvrqsE44wc32Awa6gdufQ5xZQ8OOtyHQof7PY7yCXquV2PfACe9HJijPEU1RjMp5fUTsBkEQ0Lq+DcuGXDQ33tuIvGYF1Hv+AsgIq4StBgsOp6LQ0/7XCvoMY5roSsZLS3R9fHzwt7/9Dbq6umCz2dDQ0MA//vEPJCUljbvfMNGNjIxEUlISvdXW1sp1fGmdrqmqAlHut2H/20HR1IQfv8cTW3NU5nKQGxUpLO7Yuw0WP+wA08Ue3W1iXKYGe4DcB5TszGg7XIPXqc9z7lMD8QsOSWkGH8bmymRnKyuZlYYvUp9Chc3BhUsE5YR2f8TSndTK31eEk4wRJLjR4FUw7ZbCMuEKjoYdxUd3P8IBX3WaxHzjvYAmepud1XHWThW3Ld5BiokKYm7soMlNaoX8TmMl6Y20SxiPK4xecgVc3My8iaXuS7DIbRGWuS6Eo+Us8BQo8OAKuGjtb0VFRwWym7IRVxOH4LJgeBd6wzHLEddTr0M3XnfSSfIS9yVjSPKf0X/iSuIVWKZbwiXXBfeL7iO8IlwsSVakcE0cMjp78GZQKmaZRND7zGUEwjm2FPxR5h2kQICnq1ajQE0dx/brYzYjGIv0fGB7/0u6f9je/xKL9HzkOg9pEWwfHx/K/UrXFrWGSVJVEvg8LkJsbtDj0oOrehjskz2iLg5tbcn0NQoEk0w0SJJKNSJmAs5fiC/m8toNPjEbNYxwVDNi0aH9u/jnnN5eGfXv2I2vLfx/zZZZYHlqCAvR+nvHrgyJywWeTIzIebU2uAiCIBDjZ4fk6jhagnC112rEVMdM3TlNEQb7ebSLYpyvYvJzzxvTRFcyXlqiO3/+fBw4cEDkszVr1uCrr74ad79hotvePjFLTHGdbrzUhHsEA7nsCAz09qA4JQGu508Iv9+3HU9szdHROGpZkdsH5AcCfj+NFQu/8h8qopvlQ0V4XzDwBOLJ7NokWXNmM7E0Oge7J0hmx8PpgkqosDnYbe6EpytWQtAzQmtRBi3H7suvIOXa67ht8Q7O2qlis7O6hMjlQniGzgWTpYqAwPfANFVBg8GrY9o7raWN2YxgbLWKVch5rKd9gF7uryuh+ndZexn2Pt5Ln8s3j7YjL9l6ciumJYAr4KKlrwXlHeXIaspCbHUsTZKtEm/iZ6tz2HX9KLZb/IDvvfZhZ8BOfOb3GVZ7KVfdYon7Eix1/Qgf3NqEBQ5boW67E2o2BzDf8ijmmZ3GPNOLmHtNH3OvXsMuV3cUtBSgprsGXYNdY/4uQY3tUGFzMDuKg1vMXMxnBNDk9Jubccit6aB/O1BeThctHdDywqardvALWUETwIsuR/G+ZqDUAjp5kZpK6fte1TdEFSN6rEbsCAz09sDPQJsem0LtLcHnTTyHtKsrj77OwcGWCbcnFSWRwmerKHzs944b0a59fiia+wQC/f+T+rzLuvWf+Q8K1NThYXKeckRLyJa8MiQuF3iS0dPTQ6ezlJeXAwCK2oqw2W8zla/vvhQPih5M6TlNBdJCqHQox9NR6O0cfN6nIzemia5kvJREt6ysDDNmzEBgYKDI59bW1vjnP/+JgQHJL21lE92qyspxUxPifb3QXl9HFVVlZ8JT8w+R3wSaXUXzsxGOObwBKqf2wa9Ujq1IFPFVwH0HkOEO9Mof8VM2Jkxm2RwsCMvEx96p+OpWEg5aJEDXIQ3srHr0KcsTfhzYVjZAhc3BSp8nqCMI0S9H6WZyiZnIv/oafM3+D7o338OOW/OxWEIKwjLXhdjjNB+GwUfgX+KP0vZSNNwXCv63WYz1nW/UfxdzhkiSd4riLz53LcoNKD2sAl4FXljpuZI+r2sp19DPe/GKMepK2uH8p1BZoVCMsgKXL54k3y24C4csB5immkInTge/s37HT6E/YWfg5JHkdT7r8NXDr7Dv8T5sDfwJc/2OYkXAOVxPvI7d5gexxuQ85hhdg+oVK8whnHDRn436rja0BwRQmqvLV6CyyhuRLCrSHxqpjkM2BmJzgsUV0MmLtrY2mtikawahK1b8i7KrtRnuF07RY1O8r6fSrJ57eyvp/t/bOzGbXplAkoDL1qH0g/VjlAx4d46gmsFCNSMWXTo/KI3kgpiJjp8oFYb4jRvxTngqTj60n3yTBTlQWFhI6StfvozBQSHhq++px3cB39F93ZZjO2lW388DA3083PqDiuomPJyY1N7zwDTRlYyXkuiGhIRgxowZKCkR7awRERGYMWMGCgsl56ENE9033ngDf//73zF37lxYWlrK/UAPdzrjAzvFpiZU5WbTOre1RQXwvawp8rv7RrqoLymiGuNzqQiE/wlKHWH0kpnrNkpTsWfigu/yQhlkdkVCHnZzhJFZ79xaODhkwuqEUEXB92oqKnKap3RgDY6nHMzeZGagPU+Ym0aSJJ45rUPI9TdhYv0uDjnOw8pxiri+uq2Gi7bvw9P8bXCM/4v+y6+MkeshHTcgJWAWpSX6cBbIUS88K52fqKVsrQfoHVQ8ghbunAdbDRaMLrvR5/eZ32dIrJVPDmqqUJRaD4dTUZSywrkY1DxVPA9UErh8Lpr7mlHWUQZOIwcx1TH45o415ploY96Nc5hvfhxqVj9B7eZeqNtvxwLHz/DB7bVYeGe5cnOSXRfjY4eF2HxnMb72XoBd9xbgyIMV0Is5B/M0C/wZbontrmb41N4au1zd4ZAYg4r2Z+ge7J7wc2FtbQ2CIBCg44bmO2MtUZufVcLpxBGY7d0G833fIDsydELHG43BwRaa6HZ1TVEeaGWC8BnLDxB+3lWPbitd9OjsAk9PgkmDtDQGozclktfBP/+DAnUqcn/uEgHHW0eltzmFigcREREgCAKOjo5jvusc7MQvYb/QfVY3XleuOoEXHcmBZVRU90y0iKviXwHTRFcyXkqi6+XlhRkzZqC5WZT4paWlYcaMGUhISJC4b1hYGAwMDBAeHo6wsDAcO3aMzvUdD52dnaipqaG34WPpbf9MJDVhZC5bU2U5HpleESG4d3XOoyo3m/IxL4umrBxN3hs78Dl/SVlBdslXJa0IRpNZ3eLqCZNZcWkGDeWdCLLhiMiE3TNKQXlW03OJHKRr6dLX4FoSBzuOHY5HHsd6n/USycoGlwU4YT8H9pbvIM7kDbRfGceT3WmT8GBeu9Fs/Tr9sm+1FBYRcvVfxYcMD8xmBMPguuRCJlngcz8Mthos3DgVgEWui3Ap5hI6Bjqk7zjFIEkSaSEVdD/w0EmYUptOWXN0H2RUjCHJj8sew6vAC/ZZ9tj8RAtz7x/HpwG/4vCTw1h3ex1WO6/GSo+VSiXJS92XYr3Penz98Gvsf7wfxyKO4UL0BRgkGsA6wxquua54WPwQkZWRSKlLQWFrIWq7a2mSHBwcDIIgYKdnjhq9eJA84XNZnZ+Lmz/vpSfqpekpSr/ffP6AcEWjbQod9zx2Us+ZmTpljHNztXIit3ZrxhoaDG/Wy1CuRalrZCxeiiTDddKJs6nqlOXuuri4gCAIhISEiP1+kD+ISzGX6L6nEaGBHu5f30IXAPp7uHA6Ew1bDRaSA8ue9+nIhWmiKxl/GaLb0dGBwsJCqRufz58Q0RWHY8eO4X/+53/Q0yP5YSYIQqxag7+DDdrrRZda2+prEWx9nZblMdu7DW4XTqE0LRFkRTwlT3N97tgB79anVCV/h/JthSeDzIY1y5Yz21jZice2WSIE18cgGWWZTSAFU0tw+3n94DRy4J3ogJyFH0A1JAEqbA7m3tcYQy5W3vkAPzrOhan1u3hy/U1UG746JhIrcRstwJ7tB5KYiVR/Kqqb9kgY1Q3W/YImVuXxiuXGdQx04EL0BWyy2yI008hQblROWeDzBGC65dPn+cA0HX1dU5szp4i5hDh8NlTQaFFBTUhtbGxAEAQSExMxyB9Ec18zostzsc3BEaqGZphz1RDq1y/iB5/fYJxsDO04bZxmncbhJ4fxXcB32Oy7Gas8VymdJK/xWoOPbn+EDY4b8KPtbpwPOQvDJEPoB13AL1qbcOz8Rvx56Ws8SXuAwtZC1HXXoYfbo7QJKEmSYLEp6bSmZqZsO4mT9pOFBA50UXm5YdpidW9BzASp/18MXN4I0mSOkGzK+2yPNDQwmU19Z78W4A2AXf4MiSupwsOKL1Tla5uYOWm5uzweD4aGhiAIAjk5kt3jBKQAFukWdB/aE7QHTb1NSj+f54HERyWw1WDh1tloDPT+daK600RXMv4yRFeS7Nforb6+fkKpC+IwvF9KiuRIhqSI7shO19XajAinmzDf/w1NcJ1/P4ryYEeQTxhUVGH0wOawDog1B1rL5bthYjBMZtktU09mxaGpqgvBdtkiBNf7SjJK0hunhODyBXyUtJXgUfEjGCQaYE/QHixzX4ZFbougeeIDFKip4xPne1Bhc/B+gBG+C/gOevF68H3qi4LGLHDHM4aQZcsZq+LQYvVfOrLVYkVFdfdqXsdsRjB+1LdUKJITXxOPzb6bh5bHl8D6JBXVFZfr+rzR38OFv0UG3R/CbueKKERMJeQ1lxAH9dgcqLA58KuncuadnZ1BEASYTIrMkSSJZ9UeYDLnwcBzHxbq3qPJ9FarWGRWiU/VGCbJZe3CSHJQaRAVSebYwyTFhCLJzMklycvcl2GDzwZse7QNPwT/AI0IDVyMvgjDJEM6kvyo+BGYlUyk1qfiaetTiSQ5JnYlmCxV1NcHiL1mEYwn7TeaBHL7gfIYgGVIqSxcGZsDD2ImYPA6+AG6aNKyRTWDie7kurHuWw7r5X+2BQLKSp2YSQUqAFhU1ONnA/MRjmn/lW/smKTc3erqajpfW5Y6Fe9Cbyx2W4xFbovw5f0vUdY+Igqq6ETkOaO3cxCOp6l0qdTgib93pwrTRFcy/jJEVx4MF6MFBQWJfG5jY4N//vOfIgn2smCY6KamiteqFIeRna63swNRHs4j3My+xoPT36Lx1iGQ4vzMbT8Cok0pH3M58aKRWXForu7GE4ccEYJ7l0hCcVrDpBLc+p56RFZGwiLdAr+E/SLZZtd1IaLWLqKq313uQIXNwV5O0dgGx/Nbl7YUKe4l1V4F0mY50h5RUd1U/1ko1F9EEx9m2tjcyfHQx+uDUZIRfV2rPFfBu9CbJpJRXvJN+CYbHU19uEsk0X0iKaB0yiP6oyGruYQ49PD49HOV0EbJ+g1LeQUGBoLP70d+/gV6YhN9VxVJOzbg0oNsoSGFZjB0/XPR2a+8yNIAfwDNfc0obS9FZmMmop9FI6g0CKfvnMYeyz04YnkQhy2+wVemq7HZYiU+cfoIn9zbJFK4OBkkeZ/fchz2U4cm8zCsM6zhlucmniT3tYIcd5L5CmC+AIi6BrhtHyu3OPwbxw1AuA6Q4kx/3mxNmUPUmaaCFDfeSZUVFENA67KF3zfkAwCO5JTjTWYGorZuRYGaOkpXzwGpN8HJshKQmJgIgiBgZmYmc7SeWcWk+8Za77XIaMiQbyLyAiLOr5h2XBzsn2RnSQVxjgAAIABJREFUOiVhmuhKxktJdAFKXuzQoUMin61bt06qvJg4/Pbbb1JTF0ZjuNMFONrA5qfdMNv7Ndx+/ARp51ag31hMWoLNCoBlBDRKt8/8K5BZcWip6UaokyjB9dJPQlFKPQRKJjTdg91IrkvG7ZzbOMM6Q0c0xW0f3/0YR8OPwirDCqwqFmpiw+lIi31qNlSG7pdYjI74eOwCbswbf6nzymuSJzG8AbSmm9Dk57yZMWX9eo05Rnd1POQ252L7o+30Ne5/vB/lHVR0YrjgwsdgCnMhpaCutEOorHCCjYIE+XSrX0QU9vTRz1xVH0V8goKCQBAEfH3tkZL6Lf13Tr63AXlL1VB17BgAILWiFZ+bR9OEd5VRJIKyaic1Vz0mJgaEnh5uHP2JXnF6ZHIZ3H6hEscAfwBNvU1jSLJXgRfsOHa4lnINWrFaOMU8hR+f/Igd/jvwqe+nyifJrgux0WUBtt9SwwHHedCwn4OLtu/D0GY2rK1mwc38bTy68RaYpipIvfY6nhq9hnrbleh9fBZkXsBYVZoHRzGot3LI6jcWPRkNkm/UeBPcYb3pkdFMMzXqu2vvUtFlACsS8qDC5sArnEWPNS373pI/quu1R/J5SsI4kVZfX9+h/ukrV5OcRg5du7DCYwXC7Za+UEoS8qKnY4Augs0ImwIVECVgmuhKxktLdL29vfG3v/0N+vr6iIqKwvHjx/GPf/wDiYnC6vLKykr8/e9/h7u7O/3Zzp07YWxsjJCQEISEhODo0aOYMWMG9PX15Tr+cKcz/34tEk4uQquWmEHMchEQSVAz/lEvsL8qmRWH1roehN3Ohe1xIcH10E3E06Q6CJRwLlw+F3ktebhXeA/acdr41v9bejltzAvSYxn2Pd4HwyRDBJQEoKy9bIyLVs2fFygntJ3fI66ti76nnbJImsmgrytLJCYj4wCCwj7AfG1/zGYEwyFaNvtNroALO44dlrovpfMv7Tn2IpXRlbkt1N/hOOuFyEErTmsQUVaoLnz+0njKALOlEypsDt5ic8AdmqQwmUxYWB5DeMTCIZI7B+XlN1G6fTsK1NTRZHOT3n+QJ4AtuwTzdZ7QhPewSwqqWiYmJyYJ5cVFMDmyjya5T0yuQ8BXXtrISJKc0ZCBqGdRCCwNhGe+J+w4djj3eCOO+KnjSOBWmiR/4vsJVnisUHokeeO9jdj+aDsOBB+ARqQGLkWchI7lXlw1u4ibVtp4VPQIzCphJLm+px693F7hRGP0BHek3rS4aObwZvQmmh0+p8eUxJY21F38AwVq6ni6cD64DAlpFZI2p03y/RHGibSSVsthdt2UziGXFxUdFdjyYMtQitRCeJi/PaXRaGUjxvspbDVYcLkQC+7A80mfkgfTRFcyXlqiC1D5cHPnzsU///lPLF68eIwFcEVFBWbMmAFXV1f6M21tbaipqeF///d/8a9//QtLly6Fg4OD3MemO925/0/04TZfQBVBVKeDxxdMmMyuTHwxyKw4tNX3UHJWIwmuTgIKEhQnuCRJoqqzCsFlwTBJMcGBkAPjvgi/fvg1GLEMeBV4IaspCwP88aMIvLY2FC5ajAI1dbT53EPzII++36kdMkT0R+nrKhqJaWtPhZbrEcxmBGO+TjDaeqSn25R3lGP/4xH+9I+2I7d5bLrDQC+X/ntU5U2BOL8EkCSJ9FBRZYXWupejehsA3GqaocLmYPnQagBJkoiN1UUkcw6VqhCzDM3NbAh6elCwgMoJ746OHtNOZUsPfnRJocnufJ0nsIsqAVeJz3hnc5OISY37cU20BUytlign6yiYLFU8Lbo85rv+lmI0ptijxO8gMkzeRJSJCgJvvAVP87dhZzkLxtazoWn7Pk7az8Ehx3n49pYaPnFdrHyS7DGCJIccwPHI47gUcwlGSUawybSBW44zHtkvBfP6m0i79jqKjF5DvcGr6L38Cl1cyrL6fMj0JgPdN9eAV56Np6upwrSa3R9T5NVUdfxVIUUiulLSLtqJWXR+bnW1YgXPzX3N2OcmzAO/bv0uBMqMRk8hulr7YX+SDVsNFjiRL3aqBTBNdMfDS010nyeGO13luVdQab0O7FALuOSkQrfo5SKz4tDe2IvIO/mwG0Fw3bUSkB9fC76c59za34qY6hjYcmyhEamBdT7rJL6ENt7biJPMk3DIckB8TbxCslktrq60aD+/m8qrXBiXCxU2B561MpBCx41KicSQJIm1Rt5UFM/uBkhS8n0jSRLehd4ihUZXk6+ij9cncR/vK8mUhE7Q85HQ4fMEYLkXCJUVLtxF782tf5mCFVlgVFoLFTYH32QUg8/vRW7uGTpVIejxSvT2VgAAelNT6eVrXqv4aDZJkgjKqsUqo0ia8H5hEY00BaygR6OpqgKOxw/TLoyGZ0/BWdcG9eZpE25bHuTmnQWTpYr8/AtAVwMV8Qs8DVgtkT93dQSR6uf1o7G3ESVtJUhvSAe7io2AkgB45HvAlmML42Rj/OGsgV9u7sc+hy/x7S01bPJcheUeytVJHk63WOe6Gmre32HZ3e9xyVYVV28twXX333D90ALY716AJywnpCXcEEuSJxQVlbLalEOsBkEQMLxyGbwJuN31Om7ASfs59HX/afs+Bi4rIRr9HMD2LIStBgt3LsaBN/hiR3Wnia5kTBPdScJwp3vLN0xhMlv0ApNZceho6gPTLR92J9g0gXHTjEdebA34POnX0cfrQ2ZjJtzy3HAh+gK9DCZuW+W5CoefHMb11OsILQ9FTXcNtaw4gUpfkiRR+tXXKFBTR92wbjJvALtiKYkxnYdW0ttTUkQ3rriZJjTO/pvQ0BAs9ncNPQ04FnGMvi+bfTcjoUa6fN7wAB5gmSn1t8rGQC8X/haZQmWFs1fAI94QXU79CxSsSMOJfMpC+rfsfCQnf0WTXB+fT3Hlijb4Q2kBLS53UKCmjpLNn0lts6OPCx3/HLw3QvaM8SAb7b2Kya9V5WbB5qc9MNu7DdY/7kLkAypH01D/CioZ0eB3KDDhUOQZ7GvDs8j9eOb0BvrNR5viDC/7vwV47gLuy2CwIAcJ7HvaSufm9ntep/a9Ngtkbxv6eH1o6GlAcVuxRJLMiGXgROQJHAw5iG/cVmCTywIsl+CKOFGS/M0tNRx0nIcT9nPAuLUEVxMNcDPzJtzz3OFf4g9WFQtp9WkobitGQ08D+nh9wnQLKWNTCPEtCIKAy7UL8v/NR8JrN3iX/w3C5j36/H9ymIuOK6/INQa+COho6qPfZ9ls5ct6KhPTRFcyponuJGG40/3XN/ylIrPi0NncB5ZHAexHEFxXRjxyo6vB54q/Nr6Aj+K2YjwqfoTLiZexO2g3nVc6elvivgQ7A3dCP0EffkV+KGwtBE8wKuLAGwCS7ClHIpEB/BWZiVNvWhodWevLyaHz2XQ8dKDC5mDXQ2fpRExJObq/uqdRUbvrHmCyVJGY9CVIUjSiEFoeirXea+n7dCH6gsxR7IKEOthqsOB0JlrphYDjobNZVFkh8fxJkPpilmj/AgUr0vBNRjFU2BwcizIaIrlzkZNrBoLQB0EQ6OrqAgBU/0HlaFaf/UPmtjOq2rDFMoYmuysMIvAos1quYrWC+Gjaltz+t4NoKCtBZ2cnvXydohWAnvRxirLEQdZq+4FuoDgSCNcdWgUR0wcMXqdcH6OvA1XJlEMkoJjygQSQJIkGm0xUM2LR6JAFsrMeMFSh2mEayHftAL2iQxIz0Xf5FTQYvIpio9eQbvw6WKYq8L/xFpY+0Mb7j3Txg8tnYNi+jxP2c3DQbTW2+3yBdbYLsdRFuSR5ucdybLq3Cd/cWSIkybbv46r1bNy0nAUP87cRcOMtMEz34JTxKbhb7BtLkuXB0BhIEjPhaPkOfR7f3lJDreGrikWjnyOYrvl00EbS++xFwDTRlYxpojtJGO50XjkFLwWZFYeu1n6wvQpFCO6dS3HIZj8T0T4lSRL1PfWIqIyAebo5joQewWqv1RIH5s/vf45zUedwJ/cOUutT0cuVUnzTXgVYL5MeRZXy8qu5SLkVlX23EyS3n36ZejgehAqbg4VhLOntKeElXNPeR+u1esUn0pHAYX3RjoEOXIy5SN+vNd5rEFIm3sVI4i1r6KX/Zk3PuuTaV1HUl3XA5cKwsgIT+Rd3Ki0q96KBJAVYEpMEFTYHmqzjiIldidbWeBEiWV9PmUiUfPY5VXXv7CLXMbh8AZxiSqGuG0oT3gO3k1DW1C3l3EikBj6g83Fdzh5DR6PQYdHW1hYEQeChzh203nsq+wlJ6/vEK5Rxwu3PxWrZkpf/jQ6z/6DWcwnlCsmVnHojk/KBDOjNaaajuQNlQ5PECH1hBFleW3UpUdNmo1nCQjSLEZq8TpsAALWXGMhXU0fWmtWoqcxGUaIl0pw+AsviPfhbqsL91ircDNXA1UQDXIq5hOORx3Eg5AC2P9qOjfc2YpnHsskhyf7f4FDIIZxknoRmrCaMk41hy7GFR74HAkoCwK5iI70hnYokdz5D/wj5N/8bb2HZUIT7U2d1FBq//peaxLY39NJpeHmxLy6JnCa6kjFNdCcJL3On627rR7T3UzpR31aDBZeLcchiPgNvkI+uwS4k1ibiVvYt/M76HZ/6fipxIF1zdw1+Df8V1hnWYFex5XfXGX65yupcJIE48dvbUbh4CVWE5u0tEplNNV9Dv5yajN6V3t4EX8KmoYV0lK6fy0dW9jEwWapISNyMhJo4bPYTSqX9Gv4r6nvkt4EmSZKW88qJmvwluZL0RjicppQVbv0Rg2c3z04sxeMFFqPn8bqQnnUcb7LSocLmwC7xPPr6aoa+49FEt6ysDLzWVqFpwDiGNOOhuq0Xv7im0mR3ns4TWEUWi9X6FQj4YN1xFFqO6/6J3k7RVYCwsDAQBAEbPTPUGiXLHtWTdTVj5OawjirOLQrDs1L7odWLL2Q73njKBzKAFJCoN09DNSMWTc4jXMB6WwHjIcUAy8Xy9S8p90CkEM1AZUw/5zU14emKlShQU0ftdwulR8ZHXxNJopfbi/qeehS1FSGtPg2sKhYeFT+CW+Q52FjOgpHNbFyyfR/H7efggOM8bL+lhnUuC7HYVbxSjaLbCtdF+MR5Ab69pYYdt+ZjyRDZXea6CAzmaXjkeyCwNBBRz6KQ0ZCBkrYSNPY2op/XL/banifCnfOoWhPtBLnrTKYKLzPnmCimie4k4WXsdD3tA4i5VwT7U0KC6/xnLEL9U3A3xxvacdr4xv8byXlmHsuw//F+GCUZIbA0EOUd5WOkveSGvC9XU1WxL6xWd3eqCG3ZcvC7ukQiM50Gb9FEN85yk+xETIGXcD+Xj+UGEZjNCIZpKGXo0NWVT0d1f/ZTxyK3RVjpuRJeBV4Tun/DrnQRLhI0gpUAkiSREVYpLErUTkBrbc/EivZeYDH6np4SJCZ9Dh/WR3SfyR9FJI2NjWmL1e6YGIroLvgAAjl0ukeDJEmE5tbho6tMmvB+ahaFxFJhASV3cACBZldpkhtwwxDcgbGkoqSkhCbjRYxIcBtkOC+BAHDZItuE02IhkOcP9IgWd9bW3geTpYq4uDWK3QQ5Jz89GQ10NHewskW4r+3HlNb16EmXLP1LSlTbwuUUVNgcrH8cIHHC3OJyW5hCdfq1se0omtYzzrnFEJ9Dn9CHmcFZ1HdU4mnrU6TWp4JZxaRIcp4bbDJtYJRkhEsxl6ARqYEDwSMiye7KjSSv8FiBT3w/wbf+3+JQyCGcYp6CVqwWrqVcgx3HDp75nlNKkltqu+kxrCDhxXOUBF5OzqEsTBPdScLL1Ol6OgYQ51tMR+RsNViwOROGC1bXsNpVgruYGyVvpRmrCa8CL2Q3ZWOQr1jBzLiQpfhL3DbihUWSJEq3baOiKNraVLujiNiKJ1RR4W2nI9KJ2ATwMKOatpqtaaeWbvOa8+AQtgxMliruhc/Bvse7Ra02FcQwAfXQkV68pgj4fAHYHkJlhfsmaejtHOoDshbtee4SJS8e31OGHC+gGH1jUxiioheDyVKFLXsHTXS7R0VWraysQBAEkpOT0XTTlkqX2f6NUs6he4CHy0F5dOrLbEYwzvtmobaxFd56F2mSG+lsD4FAfBU5l8uFgYEBCIJAlJYfuuLFjGEkSZmepDoDvocB0/dlf/acNok9bmNjKJgsVURFL5b/wuWc/JA8AepMU1HNiEWzS5pwX1kkvaT1r5HnMmo74mcDFTYHJ31MJbZHZvig7MM5lJb3x6qSHdMUSeuRsNrkRfwIgiDw6J6n/G1CNJIsjiRbZ1jDMMkQp1mnRdLWVnutVjpJXum5Ep/6food/jvw45MfJZLk6GfRyGzMRGl7KZp6m6RKT4Y6UmZHnnqJU1rXICteJs6hbEwT3UnCy9Dpahrr4XOHjZunImmyYnYqCIeu/oFlLqL6lBvvbcRp5mk4ZjkioSZBIWkvhSBrZHCcF1ZvRoYwgpKVRbU7ioj9cN8BKmwOLnhdkS2iqyB22MZjNiMYv7mngSfgwSHLAcvcl+Hzux8ggklFdauq7yrlWLXF7fTftUeR6vpxMNDLRYClUFkh1ClHVJ5H1kj89bmiL+UJpqhMBkiSj9LSG3TUPTbuQ7iWpUGFzYFabM6Y39++5QSCIMCyPoGqrVS6TK3GD+LzvRVMz8ip7sA2m1ia7KpfeoRffjmPG3u3IdnfT2o6gru7OwiCgKeuA5rdhiL+HdUA5y7w8Bhgpq74cyfhmWlpjaPv4ejCy3GhQF58d1IdFc3VjAXX7Cv5J8vS+ldV0ohJ9Qq6SHZ4wux4+1fqO3GpTF670XPiDXpMajs0usB2gmPPqNUmgeceXDOiJjZpaZMvKdcx0IHDTw7T7w4igUDHQAfquuuEJLlyLEm+GHMRGpEa+CH4B2x7tA0bfDZILGBWNkk2STHBjRhLaBD6OKNjgrtMf7lI8lTgZeAck4VpojtJ+Kt1uj5eH9Ib0uGW54aL4Zr445oxLE88oYmK+cnHOGx0DsudV2K112ocfnIYZmlmCKsIQ2335FqTjgtFI7ojXli1lxhUVO3bHcLrGEXErrhfggqbg+3+HpNGqLKr22licp+TiwPBB+gB+OuHXyM2/TCYLFXEx6+HQDDx6DhvkE/nWZdmNCrhCih0Nvfh7uVkobLCoxKQoyMgspCTK6/JTmyVRQLkBJfbDg7nCE3QUtN2oX+gHpYV9VBhc/BZ6qhirvYq3DXSAEEQCCJ2omjJPIrMHHwTMPgvpTKQ7UdFSyeYnsHjC2AdmIZ5l/zpfrXN9AlKGqUXHyYkJOA6cREB+ofQrb8PpKRiz2uzAJ8DQLIjEGc5IZLY0ZFJ30ceT44CSTmVTkguH7VXk1HNiEWrQ/jk9K/oIZkyi0VU9Js3gOash8JCNL/zklOZhibvNV/MRoGaOooWzwNfU8xz4LRJ9ns0DpqamuhUlYYGOVU2FMQAfwDno87T49tJ5knpRcdiQJIkerg9Ykmya66rkCRHX4RGxOST5M2+m/FdwHc4/OQwTjNPQztOGyYpJrDn2MOrwAtBpUF0JLmsvQzNfc1KW+n8q3GOqcQ00Z0kvMidji/go6itCA+LH4JIILArcBeWui/Fytsf4hcDzVEENxjnzYxxOcoA94vu42nr07HSXs8LvAEg+E/FSe7lf4N/+3sULlmKAjV1tHp5ibY9goj52u+BCpuDuRFxlHj7JCyR/+mXhdmMYKy6GoRVnsLlPcMkQ/Rye9HTUwomay6YLFVUV3tJb1AG3DdJg60GC3H3i5XSXkN5J62sYHeCjfy4Wsk/Hq9o78Y8xf+uipIAOSOoXd2FSEj4hCZnhU91IRBQv/2z8BlU2BwczikTbd96OQKI3SAIAt46B4UrCb+PysW88hpwWQLJl7HvVWRnwvrwblz+YS8+P2tLk9252iG4EfYU/dxRUdO+dqAwGHhyCVzrVeKPbfQm4Pk9EG8F1GYCI9MfJqg40t1TTN/L/v5x+s1oyKld3RVbTUVztWLBczmq2ETZadP45+Sylfpd4O/0R6whS+g3xaSziLse7sV/o3DhfErXe9ssidczUWRkZIAgCBgbG0MgmLpCKwEpgGmqKT3O7Xu8Dy19U+fUOEySa7trUdhaiJS6FERWRuJh8UOxJHn/4/3Y4rsVq25/hMWuS5RKkld5rpJMkrOEJDmmOgacRo5Ykvwic47njWmiO0kY7nRp+SVo7x3EAI//XKKeJEmirrsO4RXhME8zx0+hP42R9lp5+0P8bHAJFidDaIJrezoS/t5xaOvonPJzlgnj5MHJs7Uep6w3C5cuA7+zc+wxhohYttlqOhpTYzxHLgkjWdDWM4h52iGUxasFZQDxie8niK2OFfldXv55qmAnfi34Slgui/MrpvNnJ4rSjBHKCmej8SxfBtcuSUV7Ht8rHqlXhATImeNZ3xAEdtRCMFmqYLHVUVvrK/L9Pk4pVNgcaBeNULQYijxGEF+DIAjcYvxG9b0FaiB1FbjOcVYT8qKZsPjhW5jt3QYHjR/RWFGGyPwGrL3Gognvl6ZPkBPzkJLTcvpE7P3mEa+iRW8l+l00gcpEgCcl+jQBxZH+/jqa6HZ3F41/nJGQo7BRMMBDrUEiqhmxaHtYrFjqk7T+1d8plE/L86c/thiK8q9PLhj/ekZEqJv3/t/QZEht7GRISatJAQEBIAgCHh4eSmlPXrjnuWOxG6X4sPXBVlR2Vj6X85AVQdYc3NRgws0oGjVdNWJJslWGFQwSDXAh+gKORRzD/sf78fXDr7HeZz2WuE8OSd7ismWa6ErANNGdJAwT3bdPutEvljlaIVhMhOFjYyY+NYvCdps47HVMxM+uqTh5NwMX72eBCMyDaWghbNkluBNfDt/UZwjKqgWrsAFJZS3Iqe5ASWM36jr60NHHHeN33znYiYTaBDhlO+E06zQ23dsk8QHZ6PEp9KyscfP3CJrgOp2JRlJAKfp7uM/pzskAqXqdsm0k8W+UraeiubWaWpKPlXMffV4/4E1WBlTYHDDTQ5Re7HTu0ROqn2g+xEKXlTgXdQ7t/e1jftfbWw4Wex6YLFU8e+YmuUEZo5Ml6Y2Uru1Jtoj2sTwgSRIZ4SOUFbQS0FI7vparVCiae60ICZAjEikQ8FBcfJUmZHHxa9HRmTWmyfXJBVBhc2BfNSIlZChSl0B8AoIgYMU4QxUcrVVVGtkiSRLJj3zporM7546js2noHHiD6CuOQazTOaTofYhB/VfFt3vrUyDyMuLcDWFEaMNJ1xqNDmOvcdz7qYDiCI/XRd/Xjo5M2Y8nR0S3k1lFRXN14sDrGFA89Wm8/lUYLDxmXxv98ZGccqoQLV8KkRvRHwW6M1G6ai4K1NRRsVYVpP5Mpa8m3bx5kyo8jIpSSnuKIKwiDCs8qLqP9T7rkdUkR3+bYtSVCGsbyrPklMME9Yx2D3ajtrsWBS0FSK5LRkRlBB4UPcCd3DtiSfJXD7/COp9145JkNUu1aaIrAdNEd5IgjuhO1qaq9RjzdP0xV88H7+u54H3CAapXrKFqeB1zrhph7jV9zDfVxjpbE+xxv40LD4JgZ5cAu9+FKgr2p6PwxKsAVXVd6Orngv8CVpXSUESvU8zWe+o1eum4N1P6i3VNEkVebKuUmM862IlLMZp4T9cDsxnBWGB6BUGlQeNG//MLLg0VPX0EPn+EqP4wuXXdRrlKETNB57hKiE72tA/QfaCuZCyxlgY+XwC2VyHdhp9xqnIK2xQlIIqQABn702CWKzIyDtBkLD3jBwwOjjUUIEkS70VnQYXNQWDjiHs6RN45xEfUUrEWlRtev/0dxfqw0yaR4woEfETetqVJ7j39P9FfHAvEWQAe3wkdv0ZtBXqL4EHsR1SgGwS9wvPNzs4GQRAw0L+CCq1oCAYUmwjJCpIU0Pe2pSVW+g7DkPHvJ0h7gBr9BFQzYtEeVCrXviKbtP4VfJ763W1RS+cVCXlUIdozGcaPEZHxbg1hYVr7YRWlrib19vbS+bmlpaVKaVNRpDek006PKz1XglXFeq7nMx6GLcz9jFOndKVWQArQNdiFmu6aMSTZnGk+TXQlYJroThKGiW5cVhGyq9uRWNoCVmEDgrJqcS+1Ci5x5bBll8A0tBBEYB4u+GXh5N0MHLmTgj2OidhuE4dPzaLw0VUmFhFhUNUKmTAhnnspGPvOhuHGcSZNTCw1mDh8JgzqF8f+fr7OEyw3iMA6Exa+sIjGDtt4HLidhKNuaTjjkwnNhzkwfJwP8/CncIguhUdiBR6kV+NJTh2ii5qQVtGKvNoOVDT3oLGrHz0DPOXIsky0AG2IENXuWEhLO8kyWP08FJE5XaCcpbXkumR8fv9zqN/cTd/z+PJyqfv19T0Diz2fUmCocqY+lDWVQwwRdNdKgK0GCxlh8l3XQB8PgVZCZYUnjjngDiqJDMlMQEYReUVIgAz9qdPsNcRFqNFErKjYEAKB+FWP5kEeneaS0dkz5jjFxBKKXOjrI099AToOiyegUv+OIyK63IF++JtegeuPn4ClsQx1hitAGksg0NbLgcd/gJ/7CL4xmVhEhNH9b6ddPArrqRSenp4emgQlavmjr1CGVBRJkHGFISp6CZgsVTQ0PpGvbRki8h0hJahmxKJGLx787kHZ9h3dz4iZQH7g+OczXLjHvkp/NLJPJLbLuNoxIjJevY1aeSr6cCX4bXK6tY2DoqIiEASBy5cvo7//+Rs1lLWX4cv7X2KRG2X97lPo87xPSSxqnrbR415l3tTlFY+H6RxdyZgmupOEiXa65r5mRD2Lgk2mDX4L/w0f312DhXeWYqHzh/jg9noscNqMBQ5boW63A6udfsFOr6s4/tATOsEs3AjPxbUnhdALyMWfflk45Z4GhmEcLE+y6IfT6jgTv56LwMJLkxttFrep64ZipWEENpiyscUyBjvt4nHIORm/uafhj3scaD/KwdWQAlhEFMEpphSeSZV4lFmN0Nx6xBY3Id1qPwr0FqKWJkuyAAAgAElEQVRKby6a9d9Bn/5/qSU9WQkCMRP8G8uFRWgesmlHmpTVQYXNwRejK+nlRD+vHyYpJvSS01xDS8xmBGOvY6LMbRQUaoPJUkVM7CrwB9rkT+UYsfQ67PoTYp8t8/E7W/rgfUWorJDwQIyywkQgi53sjXmUzq7TJrldsUQgJU2i1v51sCPfB5OlCnbUB7QVsyRkdfUKnfQGR5DhIfJeQ8yjCWTmkqUYOCcmhUCWLdsPaCnFQJwdKvWWoVdHjLkAMRMwXwA8Og5wvCmJsFFo7OzHqbsZIilWxk8K0DvIg6OjIwiCwH0dZ2EUVF7Ikf8cF78WTJYqamv95D/GOLnB/Opy1OjGo5oRi46wCun7DhNbozcBuzWA527A4gPqM9dtks+jtVx436uS6I9lLkSTgMHqGnq8ajA2lnt/SWAymSAIAvb29kprc6Jo6m3CnqA99PhokW4xcWMhJYMkSTy8kQ5bDRYemKY/P9WhEZgmupIxTXQnCfJ0ul5uL9Lq0+Ca64rzUefxxf0vJObhrPZajSOhR2CeZo7winDUdddJfMi4A3xkhFfSVq+2Giw4nIpCrG8RvbxMkiT6uXy0dA/gWWsvntZ3IaOqDXHFzQjPq4d/Zg28kitxK6YMVpHFMA4pgI5/Ds75cqDhkY5Dzsn43j4BW61isfE6GysNI7FAL3TKyfN7jCB8wLiPVQxPbNJ0xlZNW+zSNMePWlehoaWPcwbXoHvVEMY3rsHqrj+sLe7B7MufYL/lR4SmliG+pBmZVW14Wt+FZ629aO0ZRD9XtIAwoLENKmwOZkdnga/gwFbQUoAd/jvov+c3vr/Q1xCcLbvjTn9/LVhsdTBZqqhIOjmhaGBOVDVl43whVqYBu6GiEy4X42hlhUnzf5+glbLMkBDRFVyeiULPt+gobny4Orq68qU2F9zUDhU2B+9GZ0Ew8n4Okfd2YhZNdFPWrJJ9kjaS5Bu/TRFYMd+TpqqA3xEg7Q7QUkrJW8mA6KImrDcVFqutvcaCuQ9lB2ypdx31Funy31s5lRgSk76gViqe3VHsWBJyg9sDS6loLpEAQa+YSLwsecWFIcLzLosWfw6pztT3xu8AfKE6jcyFaOOgyZYyFyn4YCH6n8pRrDcOXF1dQRAEgoODldKestDD7cGxiGP0OHkp5tLkGA5NAFX5LfR7tXoiqx1KwjTRlYxpojtJkNTpeAIenrY+xf2i+yASCHwf+L3EBPMl7kuwK3AXiAQCD4sfoqitSCZpL+4gH5zIKlrmyVaDBftTbMT4FKG7bWqErQUCEr2DPDR1DaCqpRcFdZ1Ir2xFTFETQnPr8TCjGh5JlXCMLoVFRBGMgvOh9SgHf9zj4Df3NBy8nYzv7OKxxTIG601ZWGEQATXdJ1NOoN/XDMYi/TB8eDUS60zZmGUUjlkmEdhzOwknvNLxp18W9ANyYRJaCBtmMZzjyuGTUoXArFpE5jcgobQZWc/aUVjXhhvJtrR24xL3JbDOsMbloFzMZgTjw6uRYwoLpeHpUwJMliqiI+eBZyhnKofTJrqdpqouup+0N46vZVmW2QTH01Rut9PZaFTlT/KynYKFTXJBTJrEwNVXkPZoFk1yM++/A26Wu0zNOT1rhAqbgzVJYkhNexUGrVfTRDf5248lk1nahnZ8LeEB3VdR+qcq6r3PAw15MhNbcegb5MM0tBBzRqRKbdTywEV9IxQyIsDvkpNsyKlxm5q2E0yWKsrKbeQ/eQnpEbzmTlRrx6GaEYtO9gQmRyRJFeoRM6n8W3H32ecA9b3PAZGPZS5EGweCgQGUfP4FCtTUUXnox4lFEXkD4HN8YXRZDwRBINv+qMxmJFMFroALnTgd+n34S9gv6BqUQ195kkGSJPyuUfKM/uYZz/t0ponuOJgmupOE4U6XXpSOsIow3Ei9gcNPDo+R9hq5bXmwBX9G/wm3PDdkNGTILaDN4/KRxXyGO0PRtuFq+qi7T9HV+vzzr5QBvoBEd08PGi02oEJfDXl6i5GqtxpRuuvxRPcz3NfdBnedXbDXOQhz7V9gYKANTe8EnPHJxFG3NPxwKwnfXA/HxhPOWP27B5bqhWCezuQS6Pd03bDA/mv67/zBrU2Yd8UOi/RD8d7Qb1YbRYpV4LgeJlmBg1NeDOZQVLfA+R1wxVXRyxDRFfAFcDwTDVsNFgoTxUeVSZJEZkQVbI9T/cpNKx4tNRNUVnhRMCrq2G7+H8Q+mU2T3BK3t0DaLJeZBOgV10CFzcFuTonE4xnq6lK5r0c2jCKzQ/9emwXYrBT/9zNUQa/tZsSfXgHPwxthe2Q3qnJlTzuRBUUNXdjtkCDM72cEQkvzIbrS5TQUkFPjNjPzRzBZqiguviql4VEYJz2i9YopqhmxqDVMmnhBXSlLeN5PQ0W/4/OoSC4xk4rsjoBchWjjoIvFpgvTOhSNwg7dq1piLj3haiPehbhUkucNkiRhy7Glx86dgTtR31P/vE+LRkV2M/2urVWgmFeZmCa6kjFNdCcJw51OzVJNLKld670WGhEauJl5E9HPoicklM3nCpATVQ3XSyMI7gk22J6F6Gzpk97AXxHj5dUZvA64bZcY+avV1kaBmjpKt22joyI8vgCd/VzUd/SjrKkbuTUdSC5rAbuwEcHZdfBNewbX+HIs80jE204x2OGVikv3s3HaOxO/uKZin1MivrkZh8/Mo7HGmIkll8MxTzsEc6/pYeEdoV3yfMujmK35UGkkmnHnZzBZqggMWwh1HT/MY/hjKcMHaxmu+EzTEd9qWmO/limOal3BaS1tMLTP44r2SZh5+sMuqgRuCRXwS3sGZ8Mk2Gqw4GufhdyaDpQ1daOhsx9d/VxwuXxE3X2qfGWFqcZ4BVHtVSBtlqPa8Q2whvJxo8LfR+PN/1J5mrYfy2zBO1y0+EeheMIgGBiA6YULIAgC8S5OQOQVwGopbRM7ZrvyGmVAwDYGKuKRywyG+f5vYLZ3GxyPH0ZTVcUk3CxqVeZeahXUtYPo/vbVlUjk1shh7y2Hxi0AZOecoCZuhdqi7Yz3txsnPYKrp45qRhSqGbHoilFCESlJAne+ptq3XweMNFgYafvbVkF/rFAhmoRrJrN8UfXrryhQU0fxho3gd/dIb2d0m0P3KpnYCIIgcIO4QJngiEkleVFwv+g+vRq22W8zitqUk7oxUZAkiXtGKbDVYCHQmvNcz2Wa6ErGNNGdJIwkuss9luNA8AFcS7mGx2WPUdlZqZTkdT5PgNyYGrhpxtMkxO4EGyz3AnQ2v6QEdyQUWNbmd3WhcNlyqgjNXbal6JE4nlcBFTYHx/Iqxv1dc18zTjJP0gR3g89G+OSG0Qockfn1WHONidmMYHxtHTuuAsc2m1iJChyL9bwRMqQG8PutkwoT5gNnwmCrwQJxIlLs93MuBUP9YjBW6ITic3OhAsev7qMUOCKKJCpw5Nd2Kl+BQ1ZIKYjit5YgP+9POoqbEDoP3eZviU6gZLTg/SLtKVTYHJiVi4k88QYxwPRA0sUNqCA+gODyf8RHOJ0+oYwcSpjAIEVmSJJEgt9dWj7M9fwJdDbLoOMpp+PbaITHJGKzllAm8X3NYBg8zkfPgAwOiXJGdPPzL4LJUkVu7hlhG9KK2ZLsJbbdomWAakYs6hgPQXIUMFgQd+/YV4XHyH0o/O3w59bLRJpQqBBtnGseNFiKwkWLUaCmjsYbN+S7nhGpJH7EfhAEgXvEAYmpJC8SYqpj6BXRj+9+jJS6lOd9SgCA0sxG+v3bUP78DJamia5kTBPdScJwp2PlsMDlK9d8gc8XIC+2Bm5aIwjucRaYrvnoaJLfL/z/JbTevUu5US1eAn67/EtNVhUNUGFzsDGlUOJvIisjsd5nPU1y/2D/gdZ+0WKF1IpWmjikVshXyECSJAZ4fLT1DKK6rRcpHH2KoIXPQcTlDQjQ3QJvnR24rbMPNjqHcU37GPS0z+C81kWcIExw2Ckaux0S8JVVLD65EYXVRpHYygiHrQYLNzWYmC9Gam6yNkkKHMc8RBU4LCMlKHBUtqGwvhNVLb1o7h5A36AYB0IpBVH91/6DlOB5NMnN4hwF7+Yyha1sF8TlQIXNgU9dC2WRW5tJWeZ6fg8YvSW+TbuPgSeXKLOBvrH9UsDnI9zRmia5vpc10d8jQ3RQTsc3cWhubgZBEDima4aPGY/pv93HxkyE5UlZRpYzR/dp0RUwWargZP1C7S9LMZvRmxKiuYtRzYhGNSMW3br7lOuWNxx9t1kpLDq7/Rn1WfB5kWbkLkST4ZobDyyiUhgWLcZAWZn0NocxYuJhTpwDQRBIID6ROPF40ZDXnIeN9zZikdsiLPNYhuCy519ERwpIWoEm2Pb5GV1ME13JmCa6k4TJ6HR8vgD58bVw104QIbgRd/LQ3jBNcKWBJEmUfbsDBWrqqLl4UaE2Qps6oMLm4O0oDgZH+cJ3DXZBO06bJrgf3f0IgaWBYonXafsAzGYEY6ueC0hP+SJsozE42IKoqA/AZKmi1PVNuVM5AGCgl0v3qdz0emTmNMLkYjS0T0bi4ulI3PLNk6zAcU9UgWOLGRMbtd2xkuGFBYwHU0aa6ZxozWB8oBeKVUaR2HSdja3XgmgFjuNaejindQm62mdgrH0MJgY/Q/PWL9BzPwQjr73wYDsjLuw+MvWWo0hvAZ7pqaJV/2306782Vh1BTNSrh8fDxsePoO2pixaHzUIr2FFbp/ZbSCPWIfH2BaB7/LxNbn8/Hl4jaJL72MoUPK4Mk2c5FQ8kRX5Jbj8sLS1BEAQearnD5E465mkL89p/dU9DbbuEFSQ5z6G0zBxMlirS0vdS+0/AHKZZi8rNrdO8B1L/1TEGGxO6dyMLBDl3KQe04d8WipIvuQvRZLhmgc4rKF77EQrU1FH18y+yrxAOpZJ0EP9H5+c+I9TGHkOeezXFeNb1DNsebaPHWZdcl+cu71Wc2kCPn01Vz6dgbproSsY00Z0kKLPTCfgCFCbWwUNHSHBtj7MQ7pyHtno5c7T+H0ZfdrbQCS0tTaE2KvoG6Hy7gm7hyz21PlVEFu5I6BHUdteObaC9Co0WGzCHQRFdb50dckfYxKGk9AaVV8pSx+DdnQopFAxHJUJv5cLxd6GyglyC6GIIgkD/FfTqv44m/XdQqT8fBeZfIT0rBzGmuxGq+xke6m6Dh873cNQ5CAvtn2FkoAktn0Sc9ckUUeD40uI5K3AwgrCI4YcPGR74VPM2vibcscc+ARecAuBlZ4AMi+/Rafie+Kix/mto1JuFKuNViP9+O+x/+Bma+ga4fcd13NvZ29EOT80/aJIb7ekCUiCjOoc80VQpkd+g+94gCAIOepZods9HaVM39jkl0vdmgV4obseWgSdOOUQOmbjKSkcwWapITvma+kBBc5gBvVWU1S8jFr2638ofpZSHYFsuou4hMZOa2PSLLl/LXYgmY7pHp86X9HjWGR4uV9u5xCrK9Y7QAY94dUzbL2pEdxht/W04GHKQHm+NkozAF0yuc994EAhIeOkn0cY5zwPTRFcyponuJEEZnU4gIPE0uR6eeolCgqvBQtitXLTWThNceVGro0MVoX31tcIRAMEIe1f/hjYM8AdwI/UGFrstxiK3RVjusRxueW7iBc6HSKCVzhHMZgRjEcMXvfqvi75gFCwE4XLbaFepkhITha6N7Vko0s/cNOPRXC2nsoKsBOH6XIVTA4bBF5DoHuChsbMf5c09yKvtQGpFK6KeNiIkpw7306vhnlgBe5MLlAKH9kloap/HaW0t7L1qhC2m5vjkqi3WXbmFNZquWKblJ5MCx4cMD5zV0oSvzjeo1lcVew0tRrPwWPcLaGv/gU80b2P2iCX/0dtczUAs1n2Mj69GYrNZFLbbxGGvYyI0bENx7cghmO3dhht7t+O6+S0RBY7H2UIFjpzqDpQ2daOuow8dfVxKqk7W/FiPXVKjrvk3tlEOWvqXUU7EgOSTIEkSD9Krsdwggr6Wr6xiwXkmJiVIxnz66pq7lGZxwkbqA1mL2UZtTVrWqGbEol7TE6T+v4WEXlbIRLBHRHWdv6T+ddkq0oxChWgyXjPpuBFVP/9MFaZ9+ikEfTLUZQw9n0+Ib0AQBJyJ3yRPfl5w9PH6cIZ1hia7Z1hn0M97fupChUl19Nj5PBRppomuZEwT3UnCRDqdQECiKLWeniEOb6GOOS+PpNMUg9/dTRehtbi6TqitL4eKjS5mx+G7gO/ogXZX4C4UtxVL3jHbD1z9V/EhwwOzGcEw0JZg9KDgS6a0zGLIvWshBgblswkV8AXwt8ig+9o9oxTFlBXkJQjjbcp62Y44p95r/0Zy4Lt0Pm7OvbfBuyIaxeJ57kEn8Rbq9WejVE8NBXoLUaSnjhq999Gt/4bYc+2/8iZyrm+Bnc1ZfBL0ALNCEvGZpiPWMNywhHEPc4ci+LJuH551geH+XTDbuw0m+77F5tPWckeg5zECaAWOz0cpcPyupSVU4DA4Dzudg3DT2Q0/ne0I0f0cbN0NSNFbjVy9xSjXm49K/XnQ1r8CPX0C8VoPMVAljFq29Qzi4v0skdQRvYBcdPbLX5tQXx9IaUPHrBjzt5N169ddR0dz+3S3KDaBlJVgm8wemgwMRUWjr4s0o1AhmhwFfAOlpShYSOXrNllbS297aLLtRGiAIAiEE9sUmmS+KOAL+DBKMqLH4IMhB9HW3/ZczkXAF9CrrmG3c6f8+NNEVzKmie4kQZFORwpIFKc14C4hSnBD7LPRXP3iCGX/FdHm40MVoS1aDF7bxAbC3/PL8Z6/ARa7L6PNHyzTLaU793jtRrDelzQhKNebL/EFpgi43E5ExywFk6WKomIjmfcb7OchyCZLpM/VlcohITUSCkbglHkfxmAoitVi9Rqiw96jSC7zfVTeVhHKKo0k1unusp2j3cdArBlQnUYXJF0LvAkVNgdfB3iN+f2g/qso2zcXMcs+gvfOnTilZwoN3euI0N2EIN0vcU93B1yMT8LK+QFu/PAdzPZuw/WDu3De+qFMChxTtc1hPMYy3VCsM2HhS4sYWoFjl30CFumH0b/7QC8UZ30y4Z5Qjgfp1QjNFVXgqGwZq8DR3MzC/8/ed0dFce/tv+/5vX+95z3m5ib3cpPcXBOSCIlYYqJJjJrE9JhmiokxPRqMJjFFs4jIIFhAEVEBKwrYsaIgxd0Fll6XuvS69L607fP8/hj4LgtbZhsYs885ezyyOzPfmf3ufJ/5lOfh8hzB4zsxWRcTa3Rpz2lo33wEYo4AbW6hTF21OS56bMnmiWUakktNA5q03ePMckQzsYGvzW83abCVNxg/T3lHDbZRjFGEiHpKcy6UmddqikHTNEKLQwnZXXZlGRr7G6dkLKUpzaS0cLLLCu1EVz/sRNdGMGXS0Woa1XntpEZy9BUdXDhlhe13EmiaRs37y5kmtN83WrSvxv5GvHL1U3JTfePSG8hvz2e38eElWOG2G9M50fhi8w79C9iRF8weX23tgZGo7uOQyYyL+/d3S3HOO0tjEf0jU5tblCg2bwBm1lSafR1YSGfRCinqzj4OLpfRx02Kewjd++4Zc6y7gL3OjJzXsZe1iYvO111Mql9H1Gv9taOM/Nx5f53bil+eDpGTM/I/mEeagYYoTflKwc8zsPeTt+G/YhmOrPsaXWIDpEMpA10QCVnECvQEvwbxia9QkXwRwrp2pFV1IiHmspYCx/4tX2kpcKzdvBVfbt6OjzwO4k23ILzodgzzOacwkxOJhzjXJ51AO3vE4sltMXjaKwzP+xzB+8Ep+PxoOr6nduPXzRy4u/+CHe5rsW/L1ziyZSVObVmOKx5vIs5jKQQeC5G79SlUbl9Lorl9IZtAF5rpomcK2Tz+qmZejFPMMMsRzcQGPtXAICoXLYbIyRmNrmuN7r6uro7Mvf6wT23nODjJiK6JxtwIJviw5PwSFHdOflRVpVQTNaRbJ4zbhVsTdqKrH3aiayOwmXQ0TaNG2KFFNIJcebhxsABtdVOnx3enYbiomDRtDGaZp71I0zQuVVzCgtMLCMl99OKPaJey/57Kj68mizrX4wWbRDKVyn4kJc8Dl+eI8grK4Gc7GvpxYsRkJHgtQ26jgwsR5Mo0OpoF1hE4I+ULbK4DC+kspbIfhUVrSalC1rX/YHjn3ePGwLKUYvRlIOr1Xuw1OPCF8A7bpHPbyrmPQeTkjNovZhCy0UlNB+05Dak/zCJNZ+GbfsRAt4EmQDayYWwJ06kPJnyG9mQa6Lo8H0Dj1kdQ5umC2IO/YI3HXnztsQ9BbrE4lVqLo8k12HerQkuB4/uIHHwYkoZZVJwWkX3U3bbR54c40eCNmENc5/BJGcVYBY43AwX4MCQNX4RmYe2pXPx2oQAeV4ux86YI+7mVOCaowZnMBlzLrUeC30qkbn1etwIHNYZshr2ruXbjShfMdkQzoYEPAPqu3yD3uH4+3+CuBQIBKIpCYGCgaWP6EyCrJQvPnnkWLmEumH96PpLFyZM+hqJEMdG0n0y5TzvR1Q870bURDE06mqZRW9hJHFVGX9f3C9Faa2bK2A69aPHYyjShvfGmWU1oncOd+JH7IyG4i84twYPRoXDgCyGUsL+RuR+7iumcaDzvdgIqTwPkysLa1Lq6QyPpX2dIpTqUHwDUFnZqlBV+TkJdEVPTmxdXjyBXHsLd08w7OBtytecx9tEyC44zeHgO0tNfAZf7MDKj/oPWSy+DDnlOf8T24PwRC1cD382exyZ01Y/FU0nZcOALEXrkywnbKv74GyEjPT/+ixDdWk9nxK55mpDcSNfXIRsyMK9MifixIUwsH05UBZHYtXMXU9vpfhbSih6DU4GmaVwTNuEpH40JyasBSUit6kBHvwz1XYMobZYgt74byRUdiC1uwbmMAmwJ+xIbj6+Gb0wWtkeXYvOVImwIuYLVm72wavMuvO+2D6+5hWCR2wnM45yBE4dxGvyaE0eiue9wYm1Kqh05UXDxvImF229imGLqtkPcP8NXW3yxLjwDv0cWYNOVIjxwOAn3HxPAI6EM57IaEFXQDK6oDWnVnSho7EVVez+aeofROySHXDmugdUEQxyaplG/6nOInJxR9cqrUMv0R2bPnDnDSMVdvqz3M39mVPRU4OXIl+ES5oI54XNwsWJyG+uUChUJIPAiTChZsRB2oqsfdqJrI+iadDRNo66oE5E7s7UI7rV9+ebXRNphEKqBQZQ9OY9pQjMi5aQL3AYuESgf7eztGu7CDMEYUwAWkEgVeHwrs/ge2rLKOEGxAErlIJIFT4PLc0RZuceE9wt4jQhay8y9k5xUrfrv5qpeMi8He80chzFy1Vllmr6rLhghZ90B96Ai7F9oP3gvFD56iGvgbCDqR4Y89LeZXBs5Hiqaxv0jHfbxB96YsF3/d/9kiK6zE1RbpsGb2gLKwwNh37xMSG7MmvlQRXxk+PqaOk5jhMkE4nz+/HlQFIUTHgfRG8POqKBvWAH3K0VaRNHtchH6hiY2q8nlXST6Lukfk3o2Mkal5z1odr8IMUeAhkOMjbVOBY7EavjHl8P7RincLhfip7P5+C4sByuPZuDdoFS8sjcJC3fxMHdbPCsFjk827yZjeJYTbjGBftQ9BrOoODy7k4ul/ol45yCjwPHNyWysP5OHTRcLQEWVYHdc2QQFDkFsOkofnwmRkzMq9gQSBY6xkm80TcPX1xcURSE7O5vV9/dnROtgK5ZHLSf37YP5BydVa7eA24ggVx5CfuBD0jU5LqV2oqsfdqJrI4yddDRNo6GkCxd9c7QI7tWAfDRXme7OZQd79Jy/YFYT2oB8AB6pHlrmD1cqr5Cb5bt5lXDgC0FVsbupnEytxXRONGZsiUHPvudZpyTNRX3DUdLUMzzM1NuqVWokn6vQUlYY6NEmk0q5CiHr+Ahy5aE6z8R0q9aOjJArE1OzE6CnFpimpkHprS8aOwO4vAbIPwX06KiZNNGudjyapHIiJVV65N0J59a+/AGInJxR8ywjSea/5Wf4ffExIbmCH2YzzVPGIvoWjlMnDH0fex4DTi4DDi9BbvAaUBSF7Z7eaN5nmhZ1bn0PXt+XTEjdUz4JuCZs0iIgarWMEN2engzWYxzc5UqiuXIrNu4qVWpIpAq09klR3TGA4qY+ZNZ0gV/WjhuFzRCd+o15sPKbg92HjsHLfT3+8OBgfXg6XgxJwb99E/DoLkY27rmdXMz2iscjNmwg3PnmaqYG/IlZmP9TBPn7Y1tuYs62eLyy4wbJJHwVFI/vwrLx09l8cC4VYtv1UvjHlyMksRphaXWIzGlETFELEsvbkVXbjeKmPtR2DqJNIkW/VAHVZFp4m4F+eT++jfuW3MPdU9yhUFvXpVQfFHIVQjcKEOTKQ9KZ8kk5pp3o6oed6NoIo5MuO7EYl/y0Ce4V/zw0lbMnXXaYj9oPPmSa0H77nfU2Oa05eP3S6+QG+eXNLyHu127O2lTeCAe+EJ8WVBvdH03TeMk/EdM50fg9ssCklKS5UKmGIUhZAC7PESKRG+RSJW4c1CgrRAcXQi5V6tx29IEs5aIBqTRrwJLrEPyc0Yim0vsuqHz/DWQdBToqAGMRHbaKEUde0Ll5Zu8AIboS6RBzLhEfAvtmAX6OaHj5cYicnNHy1oPodnPA3lXvjpDctyD8acSdavu/GKctQ9fAwnHqxfjv4+TbmjKTEULZSz1IiFKOWxRUA0aURsZBoVLjcFI1nD00pQWrjmWirlPToc7jO4PLc0RHxy3jYzz9MWjhRbTsyoSYI0DXqcltACLfxU0O446280Hyf0ONaHKlGn1DCjT3DqOqvR+F4l6kV3eBK2pDVEEzzmc3IDSlFgd5lfCNLQMVVYKNkQVYdzpPW4Fjj7YCxxO/XkTa7KchcnLG0Rc/nkCEX3YPA0VRcPfchocMaDuzfTl53MST3glEgeP9YEaBY3V4Djacy4fb5SL43CjF3oQKHE6qRkR6HVHgSDaiwGENKE+k2/gAACAASURBVFQKcAQcci//PuF7DComRw1htAwsZD1/QkDBFrATXf2wE10bYXTSbf/8PCEXl3fnQlzWPeV2hX8VDBeXaJrQMo03oclVcuzN3atl/nCi+IROx51QcQcc+ELMTTPetJVS2UkWhiLx5JWoNDSeGImOPYYLu6+TeSi4UGFwMUmJrESQKw8Xfc1zj7MJhrqB0igg+nemllYHsVNtm4bO/fegIvw+1IT+E2qvu0yLaloYKb3c1gMHvhCPCQqZP4xpGKOpv6HcZQZETs4o/+wRBK18jTGC+ORtnP/tbe39U9MMu+TZIqI7HgZKBQ54/gyKonB1y0kM5emuATeGxu4hfHMyWyviuJ9bCZlSRcpuWluvsdrXQHozE811E0DRNomSToOdIPXclQnM35JGShm878WbPJ55jWhmgqZpSBUqNJ2NJPe9gitxjAJHaRuuCZsQcJypz/XZdwg7b4qw9VoxfrtQgLWncvFlaBY+OpSGNwMFeGE3H/O338JMzzg85Ga7Wmd9r8e3xuIpnwQs9uPj9X3JWB6cis+PZ+L7iBz8el4I9ytF2BEjwr5bFTiaXINTGfW4ki9GXEkrBJUdyK3vQVmrBI3dQ2jvH8aerABCdj+6/hE6hjps/n3IpUoc+y2Z3HNtDTvR1Q870bURxhLdi745aCy1E9zJRosnxTShvfa60Wtf3l2OD6I+IDfD5VHLUd6tP+WU1qOJ3vUqdEdGR7E6PAfTOdF4LyjVrPMwFyqVDElJz4DLc8Tl0FUIXstDId+4vmR1XjsTiVjHh1I+RbaasgGGPMRvAQ4vhqEGsQG/u5F76d/g3XoYvFsPo+nQGLc5Uxr7LKzR3V/fBge+EC9mlU0givLf7obIyRn8+U9h34o34b9iGQJWLsO2Tb/jErVCN1HVV6ds4TgtvRYx1LugKApBW/ei+yhL61kdoGkaN4tasGCHplltqX8ijkd9Di7PEWLxaaP7UMtVaN7ORHO7z09Oiphg1PbX+15APkKwZf2A38MANQ3hh1eZ5ohmJdBqNepWfKJpwJVrou5BQUGgKAp8I8oMWvujaQzLVegakKGxewhlrRLkNfQgpbITcSWtuJIvxunMeqLAsWOcAsfnxzPxQUgaXt+XjMV+fDzlc4v0K0zm61HfLZh5kglizA5djFcOXGCnwCFsQkJpG1KrOpHf0IOKtn6Ie4bQPSiHVKEyuLbkxNQS2cYhiWnZD1NhJ7r6YSe6NsLopMvkFdsJ7hRAPTiI8tEmtOOhej+nUqtwovgEnox4Ei5hLpgVNgt7c/YaNX/oGmPtmWlgIWvqHcbDIxGRy3lmatOaibrCTpwN8ASX54hb3EdQkZ9rfCMAg70yEv2dtBpyhRSoTQZ4Powu6ba/6yB/dzPv8XyAKi7UgbNRGX4fqelMuTkdff5/N04U9cFE/dLxGC1n+bywZgJR7PvKATcXLoD/x2/Bf8UyHF31Mq65vQ2KohBOfW0aWe2sArbdo38br7ssb2o0EDUup+Yw5QueFGo9rll8f+uXKkBFlWhFDj/b7wFh2VHj2yaLmWju5hQoJ6nph+DqD8w1CXtb++9pBwFqGhRed+OZmGj2jmiGwEIveiyGi0sgcmZKZbqOHWP+NjxMyk6qqqosH5OFUKtpDMqUehU4LuWKEZFRj8NJ1dibUKFR4DiXj9XhOVh1LBPvB6fitYBkPO/LwzzvBDh5GG4gfMTHDzNPMPf6maHz4eh10GIC7bg5Bi5UHBbsuIWX9iRi2QEBPj6Ujq9OZME1PAfvbIzD+7/E4qd96TjIq0RoSq1eBY5mfQocLGAnuvphJ7o2gn3STS16IkfSdy6zoOzu1vmZpoEmfHnzSxLFff3S68hpZZ+un5VaDAe+EGFN+u12/WLLMJ0TjXneCZAqJi86WshvRPBaHoJ/iENcNJMKLi75hfX24e6MlWVenAlC96ZApQQas4HkPUDYO4CPLmvdu4BDi4A4d6AinomWjUAu70Ze9oeE5OZeeRCy7XdZ3thnQZPcyoJqOPCFcKsQaxFF2nMabi6fT5rOIr5cgsEt9yCZehkUReEQ9QP78oNRMm5IAm3bPQwZtgQG6oBl1D3Y5sk4ayVvvghlp3UIZqG4F8sOCAiBmOV5DZE5jXqJtFqqRPO2dIg5AvRcsXE9+XjQNOA/UledEqD9nmIYA36PAtQ0xB1ZYfmxDGkmB84FMkJ0EuAWislolT05D4q2NlRWVhKiOzw8yQ8FkwiVmsaATIl2iRS1nYMTFDgCkhMw/9RCJrIb9iTWXDo+RoEj22wFDqtHoN1jMNsrXq8Cxx8XC7UUOAKupts5hx7Yia6NYCe6U4vajz5mmtB+/XXCezRN40rlFTxz5hlCcj1SPTAgNy3F+LGwCg58ITZX6I7UShUqPOmdgOmcaPjFlpl1HqZCraYhOK+trFBTGT5CCB/BwAC7WrH44yXEftpKAwNaCplo1+mPgR0P6CZSB+czdbilUUxdrg5IJEVITV1ESG5F+hdQn/7Ieo19pjbJjUTbFscnwIEvxMFr/kwDGjUNKs+7ELNaQ3LPfLgYcg9GxzeXWgiKouBP/aaftB55QftYk1G2ABitAz7p+S0oisKZLYcxkNFi3jF0RCmVwkh4n9+BGe6XyIK/4nA6qton/jYlt+qZaO6WFKj6JtnRq61Ucz1aJv5Gwq/6AtQ0qKm7gHYLtFSNZRnGPhSN/Xf/k1DWF6NiwTOkGZfH44GiKAQHB1tw4ncG6iX1eOPSGySLF14SbnSb8QocRWJtBY4L2Y04mVqLIH4VdseVwet6Cf64WIgfwnPx8sZYLPrtJl7yZkjrszZQ4HhgXZidc+iBnejaCHaiO3WQlpZqmtAytCWKuoa78BPvJ0Jwl5xfAl4Dz6zjbK1sggNfiOX5uqNnl/PEmM6JxsNu0WjqtX0ERS5VIjpIo6xwI6gAcqkSarUCqWkvgMtzRFHxj6z2NeruE7pRYF5qmqaBzkog+xhw4QvA9yHdC3SAC3BtHUN4+luN7ral5RL4ic7E5ril9arpY7MmRqJtNDUNjglpcOALcTV4ORP59LgbkV8vJCT33CuL0fu1Azl3EfUkKIqCN7UFNNuIrjmNaCamvQEYJdSCkWj0bs+d6Iwww0XPQJSy+LITImPm4dOgk1rRrb3x5SQrohpUoMkzDWKOAL032On5WhUj5QnY/QjzEDcOC1Ly0bBrBvOZXQ+yu+a6wNppUHeZTc+Z0+ReeNnbGxRF4fr161a6CH9udA134dMbGjt33yxfqGnTSwbYIP1KNYJceTi6IQmycfrR4xU4Chq1FTjOZelX4PhqjALHQo9IO+fQAzvRtRHsRHfq0OLlxTgEvfYa6DGLUGJjopb5w4/cH9E5rL/swBhON3fBgS/E4ylFOsnge0GpmM6Jxppw26sXDPTItJz2ks9XQD1GKL65+SKJgPYPGI8udzT2k331trF0f+ttYDRqL6/RpHXHv/Y8Blz6DsgLB3rqWJ+fWi1HeTlFziE1bQn6+820KbYWxkTbenweIDXbOXufQ7/7vQj/4gVCcq8teQ6lTs6Q/65xZWugnEkqWUrdyy4ya6q0GBurYCPnpmv/zdRjZOzFVAJoUyShjOy77PT94PIcUViwBgmlbXhuJ5cQ3hd285FS2Ynem7UQcwRo2ppmssSZVRDBPMzg0uoJb3V21MGBL8RPZ3eNOa+7jF9zXWDzYGPgRQsvoHb5BxA5OSPjmWfhtXUrhEKhFS/EnxtDiiGs564na8Jvib9BprJ+dmC4X06cKLOja62+f8DOOQzBTnRtBPukmxqoh4ZQPu8prSaMQcUgqDSK3MwWnF6ASxWXLG6iye0bJOSmQ679lF4o7iWLc0ql+WSaDTrF/TjJSWX81dfyUMCbqKygViuRlv4SQyAKXY3uU61S48jPSQhy5aEsXU9qeqCdIWJRPzIuY7oW213/Ac59BmQeATrKjWvZ6oBM1oGc3I8Jyc3P/wIKRY/J+7E6xkTbivY8pTGLoJ7Akc8Yt7O9K95C+koXxq1q1mOMIcQI8en0eoSQxW7qQZ0RuQkRQFMiuhY21xmqV1bvnwe/XTtBURRi3U+bZtJgJEpZGfYvcHmOyBO8BgAYlCmxPboUjmPSvGvc4lHESUJffJ15350lUAxrasoLzmm/p5SBF/oFHPhC3M/NZkoXTLnm48H2wcbAPBgWCklU9/SnK9HVxc7N8a8CpVoJr3QvLd30Ppn1ZSBTLjKyjcd+TYZ82LBSjzmwcw79sBNdG8E+6aYGvZcuaZrQurqQ356vZf7wxc0v0NhvXGKLDfqVKkJuBN3aC/3vkQWYzonGS/6JNlXdqCvqJIT08E+JqC3UT6pbWq9q7FUlRUb3fW1fPoJceeCfHokAD/cAohtAzCYg6Bndi+v2+4BTHwKp+4FmISAfMj1tPgZ9fXkQpDxLxl1V5QeaniLJs/EYQzpjD7wJB74QD3CzceDT1+G/YhkCP3kD1b89hOY3H4TIyRkNLz6k1dg2XCkgRLeRctYmlPoa30yp0bVGPa+BeuVLly6Boigc8zgASaIJvykjZL021AFcniOyY120Nitp7sO7I1mS6ZxouHBicDql1qoGA6xQzdOMd3y5TWEkAkLXw4EvxKIb18y75mNhYUR3NLJfuHoNRE7OKHSZBUWH7TVk/2ygaRpHCo+QdeLdq++iecA8jWh9GOyT4dB6JqqbG1tn1X0Dds5hCHaiayPYJ93UoHbFCoicnFH7y8/Yl7sPs8NnwyXMBXMj5uJY0TGd5g+W4Kn0EjjwhTjaqFk8egblpEv3ZKpt0lQAU0cbvJYpLzj5Rwo6GgxH1WhahfSMV8DlOaKgYGLKdTyyr5Qg6id/lFKrRyJLOjr9ve9l7GGT/ICGTEA1JrJtbtoczMIjbjoDHt8JXJ4jEpNc0NZ+k/W1mRSMibYdO/oNHPhCOF3lwn/FMgSvfA0tf9wPUNNQ8xwTTev46iktokjTNLZt2waKolB++Bv2jW9so7Q2NpYQCoVMjbHnNrQcNSEdbiRK2Xjkn+DyHJEeO2PCprKuYex34+KJMU04H4SkobzVera/RhG/hRlryMKJ753+CF9HHmAc0c75WX7Nza3RHXecq2FhKHCZBZGTM5o5bla8GHcWrlVdw9zwuXAJc8GLF16EqMuCRkIdGLVgP/67AAqZddciO+fQDzvRtRHsk27yIS0rg8jJGXHPO2P52TfI0/n7195HWbdtVA9WFdbAgS/Eb2Ua0nYoqZq4+0ik1vdWV6tppFyoJDW053yyMNAjZbVta9t1Eh3t6xtHTpQyoC4F4O8AQl8H7aVDq9XrbuDYywB3G1CTyKRxdcGCtLlKJUOpiEPGmZa+lLVaxKRiDJFce2Q7HPhCzD91GcdXLUXPZia1rfa4GyJnhuj2JyZO2MWePXtAURTy8vLYH5etBJqtrIJH0N/fTyLSmR7XQLOVzzNCwJtD/gEuzxGCBKcJm3ZHVkDMEaBgWxrWncrV6KNujoFvbBmGJ8PgZNR+On7LxPcOL8G8m3GMI9rR7yy/5mxVF4xEjvft24fTK1eSEoahvHyrXY47DWnNaUSRZ8HpBUhrSrPavvu7pQhZx0eQKw/CW2bIHxqAnXPoh53o2gj2STf5aN62Dbs/fxxzQ12IbMye7D02aS4YhU91Mxz4QryVyxAxlZrG8748TOdEw/2K8fIAU6GQqRAdXKhRVjjIKCuwBU2rkZH5+kit65eAOBcQ7AXC3wV8HHQulp3usyE5/QtQHgtIJewOZGbaXCptRnb2+4TkFhSshkLB8piTjcJI0J7TkLh2DhYfOwUHvhBvHzmMoS2aB4ShH+4l5EKpozYyJCQEFEVBIBCYdmw2EmiTYBUcHBQMiqJwaUsopJU97DYyMjfaD9zLRPF5zlqbKTqGIHYTQMwRoD+Vua8mlrdjkR+PEN5Ffjzwy21oudvfqhlr9UR3sc6zX5JypvSARXrO0URral0PNoZ0lMc9SEokElAUBa+tW1H2xhsQOTmjZvly0KrbpAToNkRZdxleuvASkw0Mn4urVdZTd+GfLkOQKw8nNqVY1XnSzjn0w050bQT7pJtciDtr8Mn22SSK++rFV5Hdmm3z415s7YYDXwjH5ELQNA2uqI0sutZOpw72ynBhRzYhuUlny7WUFYxCrQZai9GesoEQyd69OhzIDjwF3PgVKLmKS17xCHLlITPKRAknM0hWT08GkgVPk7HV1ASCtpHcjzWgHB7AjXVL4b9iGeacvwEHvhC7Qn/ROr+ub5l0cdVLS3XuIywsDBRFIS4uzvoDnATN3fj4eFAUhf1b96DvJssyHSNRyq7Ae8kcGFuP3XVGBDFHgJadWaDHOEcNy1XwjS3T0iRddzoPbRJ2WQ6TIDzLjNPnn4yb3zjwcqLhwBfiX7w8DHjrfnA065rrerDJOKS/NGhMZL+0tBQURWHbtm2QpKeTB6+es2ctvx53MJoHmvHu1XfJmnKo4JBV+i0kncMI/oGJ6hbyreeWaecc+mEnujaCfdJNDmiaRlR1FJ4Je4rckDbf+h398smp2SvuHyIRnEapHF+EZhGRe2uiUzyAMDdGWSFoLQ8FXP2OUQQ0DXRVAzmhwIUvAb+HAWoaaGoaMqP+w3S2X/o3EDATuLoOKDgPSLQbMEajD9f2mZjqNCFtTtM0GhpPgMd/bKQedzY6O83TNp4sSAcGcN6LQ+TDZsQkwYEvxJlDn2qRjab1rhA5OUP88wad+7l48SIoisLly5etP0hLVRdYoLq6mpQv1AaaMOcNlF/0HZtNiO5oNF/ePMCYQ3AEGMzSrbdc3tqPD0LSNM1qnnEIT6+DyprNapdWM2ONWK7z7YAaRlt7UbSBRjTve/WX/JgKFpH9uLg4UBSFo0cZS+WmjZsgcnJG+YJnoOxhGYX/i6JP1oevYr8iawuVRkGptlwxgRtWiiBXHsLcUqFSWOdh3s459MNOdG0E+6SzPXqkPfiF/wu5CT0XMhPnt346qWOQqtS4b4TonqpsJYtsdKGZblE6UF/SpaWsUCM00DXdVQNc38Do2G7TUWNLTQN2P4KOa+8QMtHTrZ+glKW3MMf9Ocm06DHLiK7q9IcoLvmFjCUj83UMDdmugc8akHR24ORvPxCSmxR5mjzsJEes0SIbVa+8ykjdHT+uc18xMTGgKAqnTp2yzWAtsDTWgh7TCYV0ED4jRgR89wtQDZpQk66HpA1KSsl8kEqZB6/OsBKIOQK07s4GbWAeqtU0zmY1YBYVR36L7x5MQUmzFeSi1GrAz5G5dulBOj/ydVEt04h2JUT3NbdCFN1UHDt2jJGBi40FACja2lH+5DyInJzRstVz0sbxZ4VMJcPvSb+TdeaHWz9gSMFSW1wPetuGSCNxcbJ1OIKdc+iHnejaCPZJZ1ski5PxwvkXNLJhHk8gfZ4zBlJSJ30sz2eK4MAX4oMzOZjOicaCHbegMIUUGkBxkpikuU5sSkF7/bh61YEOoPgScP1nYJ+LflK5/T4gcSdjR0rToGkaWdnvgstzRG7ep3qjw73tQ6RUwpiqgxZYpM2Hd/0NmUnPE1JTVLQeSqVpNsyTjY6GOhxe+yWjkfvpOyjmJ6B6SEqIbs2QJpKm7OnROPRlZuncX1JSEiiKwuHDh203aFMtjcfDiHpGxPEjoCgKER6HMFRkuXSVVNZK5sTAQAVkDRISzR0Ssqu/7eiXYcO5fEJ2HTfHwOdGKQZl46JxprjGtRRo5q8eW995aYwKy+H6Zt3X/NSHmocMlfW1VMdDoVAQZY+SEo3BStfxUGZuOj+O4aJim4/jzw41rcbu7N1kvfnkxicWmQ0BGpv1cPc0qKywXtg5h37Yia6NYJ90tsGQYkhL3Hv+6fk4HvA1Sp2cUbX0ZS0ntMnCt8W1cEjIwyMejKRY4K1Ki/epVtNEYDzIlYdz3pno75YCw71AWQxwk6Pp/mbz0pGm7uzkE0LR3a37AYGmaYRuFCDIlYeiRBPqyYzWYf4DSfGPjBz/UdTVH7a8/s0cq1sT0FBcgANffQz/Fcuw/4sPUSvMBQAkd/cToisds2ANCASETKgGBnXuMzs7GxRFISAgwCpjtDpYlD+k+30EiqKwy3M7ui9bro6hVA6MUQbJQ8fRQog5ArTtyzXNgQ1ASmUnXtjNJ4T3uZ1cxJeMlD6YKn+XEsC85++k0/ikU67UNKL16nlgaynUXLu8CJPOxRw0NDSQ0hKJRPOQTCsUqH5rGSPF+PGKKblv/hkRURqBWWGz4BLmgjcuvYG6vjqz99XdPIigkaiuKM1yzV4759APO9G1EeyTzvoQtgvx5uU3CcldFbMKde0VKJ+/ACInZ3QesmFUzAB217bg/nBGyP5R9xi091vWBKOQqRATwigrHHa9iQz/o1Dd9ACOvKibcGy7Bzj4tMmNRzRNIzvnQ3B5jsjJ+VAv0RwdS/xxEy13daTNaa+/oe64A7hchsgkJc9DV3eKJZdLcywzNXvZQJSahICV78F/xTKErFmFtpoq8t6ZEStol1TtyFhHUBDT4f7223r3O9oo5OPjY9H4bAYWkfl26mFCpop23bL4kDStBpfHPAS15yWTaO5wiXmOXlKFCnsTKvCo+xhntbAsNAe8YFr98sllzHtXf9B5HF6XhGlE4wsxoBzXTT/2IWzXf5j9+D7EXsXETKSmpup9kBpMSyMZh95Ll2w6jjsJ8XXxmBcxDy5hLlh0bhGE7eZbKsceKUKQKw+nPNJNKw3TATvn0A870bUR7JPOelCoFNift19j/hA+F0cLj0KpVqL36lXmZv3ETCjabSgrZABRbT140IepCVx/xgQ9VB0Y7O4HzycUWb99j6bNz0JN6VBF8PobcPQl4BbFuDTJh8yWkurqTiHRs66uJJ1jyourJyk2kzEmba48uhiF0fPI8TKz3sbwsBVc6mzYdEXTNLKjLpF63NAN36OvXbsZyremBQ58Id7I0Y5mNn7PNKI1u23Wu/+6ujpCEuVyucnjszlYzCua+hv8t20FRVGIdo+AsttytYPEpNngch3RFJjIRHODhBZH/KvaB7DicDohu09wLuL4lhVQeho4v9EHQ/mgpuZdT31tQF0r04iWOa6sQddD2OjLz9HihzBDOHfuHCiKwsWLuscs/nkDY0/97HNQ9Vnf9vZORV5bHhaeXQiXMBc8deopcBu4Zu2nU9xPsnblmbqbLNnCzjn0w050bQT7pLMOqnur8fH1j0kU972r76G0q5S8X7fyM6ar/ccfp2yMV0SaJrQrZSberNQqoCkPSAmA/Og7UHj+Q/eCG7IQiHUDym8CUh0LkpnmADRNIyd3Bbg8R2Rlv6eTTDRX9ZKb8WCveWUAg4M1SM94jZDckpLfoFJZqfPcRjJaarUKvBOHCck94/E7hiQTr/1Pono48IVYXVxH/kbTNCoWPm9Uxqmjo4MQ3Z7bsQOe5by66uvK1Bp7BGIgy/JGzJTUhcg4v5xEc1lr9BoBTdOIzGnEXPdL5Df7lttBFGyda/jBsCJ+5O93AYO6I8ukEa20XvNHNoYP++darbxm/Lnu3r2bMfTIzNT5GUVzM8rmPgmRkzNavW/TrMJtipreGrx28TWi2X62zDy5tlFd9DNUhsmlOWNh5xz6YSe6NoJ90lkGNa1GRGkESRG5hLnAN8sXUqUmWiSrrCSptwFTBfetiPVn8jCdE40Ht8fjepuRBZmmgbZSRgPz7Epg54M6Fz/57tmMekLxZWCQRdODBeYAPT0ZhIB2dE6MTCgVKuLmU5VretS8o+MWE6HjOYLHfwyNjSetokdJYANjBIVchij/HYTkXtvjA4VMd6RyeX4VHPhCUFWa37qiqYnMTUPNPoODg4To3pb3CpbXtvjQd4xWq6cXWk9ZbpSSnv4aqrafhpgjQMeRQuvOFwDdwa9jo/tGQnYf4lyHp/tP6Pccp3175AVmg5sc5v+Hl+jdJ2lEaxzzG5kELWO959jdTeZWc7P+GtDOQ4eZufr4E5CW2cZB8k5Fx1CHViAmIDcAahO1v9vrJSSQYM79dRR2zqEfdqJrI9gnnfloGWjBd3HfkZvHKxdfQWbLxIhE644dRIx/qlx+2iVSIlR/f3gq9tSOi+gSLdsTQOTXwO5HdC50Ax4PQ/THe0h280JHiRmLjYULal7eZ6ScQBepuOibgyBXHlIi2Tfa0bQaNTX7CIlOFsxHT4/uyJJFsLLV7fBAP85u3URI7q3jIVCr9c+vBemlcOALcUysURyQxNyAyMkZZU88Djp4sd7GOLVaDS8vL1AUhYqK29DmmOW8Gso5R0hVhleURZEpACi64kaiubLxSiPWwAiBz9i6AEvdjhDCu4ATgRiPV0B7jns4Gq2B527TuTu9jWhsHhSoaUC4bl1eS1BQUACKorB9+3aoDNwf1XI5ql57DSInZ9R9tsrqDxV3OgYVg3BNcCXr1R/Jf0CuMq0M6foB4UjTcZbZvx0759APO9G1EeyTznTQNI3r1dfx3JnnyE3DTeAGiXziQqeWSlG+4BmmCS0kZApGyyDwViWmc6LxiMdNOCTk4bviWqCvCSg4xzStBMzUvbD5PQz6wleoOuKLU+tOIciVi7PbMiHpMjOdb2Gdam9vDiGk7e0TXbpGFSAu+uawGo5CIYGw4Fuyz+yc5ZBKractrAUrRnT72ttw4hdXQnIzr0YaXPjVNI1/JxbAgS9EbMdIWUNvA9o+mcl0tD/nqD2OwLkTajL9/PxAURSEQvObWmwGE+bV4eBDoCgKkVuOQd5kvkwcraJRt/06xBwB6g9es+LJjMEYAi/z/DsObPkSj3GuEML79WYfNG51ZB4Mexs151unu3FSbyMa24cw/xlWP8UbN26AoiicPHnS6GcHkpJIBqIvKsrqY7nToVAr4JHqQdatb+O+1blu6UNLdR+J6hrUSTcAO+fQDzvRtRHsk8409Ep78Vvib+RG8fy55xFXp98WtS8qStOE1tY2ZoQCKAAAIABJREFUiSPVQKFSY8GOW5jOica3IZEIO/w5Gnbr0bLd+W/g7KdARgjQVgKFTIGbh4vIzS1qvxCyYQt1NS00B8gXfjVi2vDGBOvd6rx2BLnyELKOb9SffWCgHGnpLxGSKxK5Qa22fg0igZXSw+11NTj0/efwX7EMASvfRWmycXe2FpmcRPKK+4cYYhjggvrFDzN1j2//e+I49s3SeuAICgoCRVFITZ18DWhWYDmvuFwu0+G/1Q/9SeZbmw7mtJJobnnqLmudhTZ0EPi6rY9h1eZdhOw6uV3BIX45lDlhzGe23wcodUfq9DaisY3obrsbGOq26imGhISAoihwuewapRp/WMc0pi1aBNXA7a1nfTuCpmkEC4PJGvb+tffROsi+Z+NqQD6CXHm4sCPbrKi6nXPoh53o2gj2ScceKU0peOnCS+QG4XrLFe1DhmuV6latgsjJGY3r1k/SKMdAKgHKYxEd7k8WxdqtM7QXLh8HIPw9QLAXEOdqicMP9skQuTObkNzE02VWEQwHYJE5QF9fPiGnbW3RWu8N9snIeJsre/Xuo60tGolJLiP1uE5oajKvQcMkWEF1oa4wH/u//Aj+K5bhwFcfoa4wn9Whc/oGCdHtVSiB/DOgt05D+cwZjGzTlw66xyTUXJcTJ06AoigkJCRYfClsBhbzaqyCRM1h80pUaKUaLbuyIOYIIArYi6Lin6wzfl3QJX9H/Q3XPN7AU5vPk9928vY3mc+cWaF3Vzob0QD2D2HUNCDBei5lUqmUfBdsS2LkjY0omzUbIidntPn6WW0sfzVcrryMOeFz4BLmgqWRS1HRw+76N5X3kHtsfbHpUnp2zqEfdqJrI9gnnXEMKYbgk+GjZf5wofyC0adZWXW1pgktSbckllUhHwKq+cAtL+DoUsDrboCahhVuuzGdE40vNu8Ave0epAcswp4TP6NOxNNLqrqaBhC2OZW5oa3lIT++4baqiRstN0jPeA00rR25jdiShiBXHvLi6idsp1YrUVm1ixDllJTn0NfHjixaBRZEs0uSuAhY+S78VyzDIdcv0F5Xw/qwV9t64MAXwjF5pGEq5HnIfvk7mZ+yX3XIw1HTgEOLyD4uXLgAiqJw9epViy7BVEOlUmG793Ymirj1PGiF6Q9vA+nNEHMEaHRLhiDqeQgLvrHBSMdAD4Hv6x+A2+UiPMy5jl7P+wBqGqKOUugb0m1xrLMRbXT/xh7CfKdrHo77rZOdqq6uJkR3aIi9XW3H/gPM3J3pAllVlfEN7NCJZHEy5p+eD5cwFzx75lmdPSbjQdM0Lu/JRZArD5f8ckxeF+ycQz/sRNdGsE86wyjsKMSyK8sIyV0ZvZK1y0zbzl0QOTmj8sWXbNOEppQDDRlAkh8jEu9974QFqtzThUR8uLw4qGUDeDi5EA58IS7rUV5oLO3G0Q1JjBHEj4mozp8a3V9DkEiKCFltbdWuj0wIZSwro4MLtf4ul3cjL/9zsl1u7ieQySy3gjUZJkazaZpG5pULpB73xK9rIekw7Ts5WN8GB74QS7JGGgh3/hu9XzhA5OSMcpcZTFOTvlKWEYzWUp45c8bME799cCbiNCiKQphHMKTV4yL/Rpzr1HIVmrdnMLW5oVcYI5Nc9koZtoAoh0e+sxfdjuEpnwRcEzZpkRCjjmjGHsJai4FdI+orMZusMu7ExERQFIWDBw+atJ1aKkXV0pchcnJG/Vdf31YP4X82lHSWYMn5JYz2e8RcRNdEG92mobSLRHUby0wrZbFzDv2wE10bwT7pdEOhVuBg/kGS2pkbPheHCg5BqWZXn6qWyVAx0oTWERRknUGpVUBzPpAaCJz6gKnF00VOgp8Fbv4BlEXDPTIH0znReN6XB9VIl+wbORVw4Auxo3qilE+JoAnBPzASXaEbBWirta0jkiUoKPweXJ4j0tKXQj3meylKFCPIlYfjvwvIAijpL0Zq2mJCcssrvKBW64563U5Qq1W4dSyYkNxznpswPNBv8n44FWI48IVYWVDN/GHnv9Gy7EGGKCx+WH+aegzR5fP5oCgKR48etdbpTRmysrJAURR2ePqgJ3ZMZJyFc11/UiNTm+uegvqiE4wKSOabU3cyAJC0G6CmQbLTCU4eGme1z49nor6LsXU26Ig2CmMPYcl7mGvhfS/T/GYhIiIiQFEUrl0zvZmv/9YtkpGQxMZaPJa/Mhr7G/H2lbdJQOd40XGDDw80TROFmyv+ppkP2TmHftiJro1gn3QTUdNbgxU3VpAf/TtX30FJp2m2sn3XbxDNR0WrmU4yNA20lwGZh4Fzn2miKeNfgXOAqJ+A4kvAgCbSJ5Eq8PjWWEznRONQUjX5+y9lDXDgC/FFoWaBp9U00i5Xkaf0M16ZkHRaySjBRujvFxHi2tyiaeDqaNS4+PS2DaGl5TL4iY+Dy3MEP/FxtLRcnsJRs4dCJsXV3d6E5Ebt3QGlma5kqwpr4MAXYlP5CDkJeR61zzlC5OSM9vcf0E90x5QuZGZmgqIoBAYGWuP0phRdXV0kZV6wb6SZj0X6Xh24EM1eaRBzBOi5WgVx0xlweY5ITdOvWzspCH2dGeP1n9HYPYSvT2QRsjtjy00c5FViT3Wz7kY0UyAb0EgPXrOs70CtVmPnzp2gKAp5eaY7NdI0jYbvVjNZsxdehHpw0KLx/NXRI+3BqphVZN3zyfCByoBcYV1RJ6t+iPGwcw79sBNdG8E+6TRQ02qcFp3GU6eeIj/2XVm7tMwf2KL+8y+YJrS1uv3mdYKmge5aIDcMuPgtsPtR3QuuvxNw+Xsg/7TBms6TqbVkoesZ1BCkw43tcOALMT+dcW5TylWIHausEJhvubLCJKGoaP0I0XiBRGjVKjWO/MyUXvCvhBAynJq2GJJ+/aYIkwIjafFRDEn6cGbLb4Tk8k4eNqiRawwvZpXBgS/EgXqmtlKdHQ7R405MNOzbf+onumOa0YqLi5ko6I4dZo+D7flPBvbt3guKohC1JQzqIQWrhqw+97VMNHdLKlQSGVpbo8DlOSIped6kj59AKiH1+ChlIqM0TSOmqAXzt98ihPfxHQn416XMiY1opiI9eIT4381ob5uJtrY28rDR0WFeCZGsthYil1nMA9veALPHYgcDqVKKDfwNZP37ifcThpW6Ax40TePCjmyyZrCFnXPoh53o2gj2ScegdbAVq+NXkx/40silSG9ON2tfsppaklLr5/MNf1jSAhReAK6uAwL0SH75PgRc+ALIPg50VjGE2AhomsZL/omYzonG75EFWu8ldfeTWr2OHilJQQW58sCPEFlPWWESMDBQDi7vEXB5jmhqPk/+fmVvFoJceTjlR4HLc0Re/ueQy60ri2QyWKTFAaC3rRWhG9YQkptz/bLFNYiPjqvLHs7PIXNUsUlPBDNwthYBrampIcREqTTjQYjl+U8Wrl+LAkVRCN4agOHiTqMSWyrPf6OJEwcxR4DeGCYb0tnJH1HumDF1daJl0ZprOaxddy+RKuB5rRgPuUUTwvtOWKbWg6/JUEgBf2fmmJe+M3s3OTk5oCgKvr6+Fl27dv+9zFx2mQVZba3Z+7GDgUqtwo7MHWQt/CzmM/RIdfdz1OR3kLWjtVaH5bsO2DmHftiJro1gn3RATE0MnjurMX/YlLwJfTJ2P1pdaPP1I+k0ejwhGOpmoi7Rv2lcjMa/djzASASlBwGtRYDadOKZUtlJFrYisfa5tMkUhOj6+GaQG1VeXP2fsqmjuPhnJmKbughqtQx9ffm4GLQFQa48HN0UgcqqXVo1vFMCltJirRUlCFmzakQj9z2IUi1X6+hTaJqQskaakLpPnWa0SJ901t2IpoN4jo3A9fWZ+PuwgrSatSESiUBRFLw8vdB6sdSoaUKv+waIOQI0uSVANchkD3p6s0nGQKUyPfNjFdz4lRnjsZf1fiSxphMPbo8n94QnvRNwMVds/u89J3TkutzFWIWbgStXrliluVE9OIjKF16EyMkZDavX/CnvYbcbaJrGyeKTZE1cdmUZGiUTa7JpNY2z2zIR5MrDjaACHXuaCDvn0A870bUR/sqTrk/Wh41JG8mPeeHZhYittaypQS2ToeKZZ5kmtAMHAVk/UBEPxLkDh55nFobxi6jPP4GwdwCBPyDO0dKyNRerw5kmtPeCJor70zSNGYlMhG+1bwoO/ZhokXf5VGNwsBpc3qPg8hxRXLwBPL4Trp15hxB4mR6ppUkFi7R47e/TsX/Ve/BfsQwHv16BhuLCifsxI/VfOjBMiG6zlInkNf/BGSmtWctaAWJgYIAQ3ZYWE93j2Oq07ps1aeUMUqkUXhRja5y267rBiK7K8yGIObcg5gjQt9ef7GNsnbhM3mnT8epF4BxmnPydej/C65LAgZuPB06kwHmkbn86JxqfHElHdYcZpgsqBRPxp6Yx/QPmDDswEBRFQSAQmLX9WEhu3tRk0VgaT9hhHDE1MZgbMRcuYS5Ycn4Jijsnln5V5rSRe21Hg/FG2b8y5zAGO9G1Ef6qky6tKQ1LLywlJPf7hO/RNmi5NmRf1BXUL34YnR8/AHXIEk3t3NjXtr8Dx18DeNuBWgGTCrQimnqH8fBIqvJy3kTnp9LUZiy4kA0HvhAfhGaxTjndzigu+YUQDi7PEYKkNxC01nxRc6vDSFq8aMNj2LviLfivWIbDa79ER0PdxH2YmfqP7+yDA1+IBxKFUI1Eu6rffMtkW2qVSkWIbpWp2qVsnbcmuZzhWPARUBSFc1uOQpl+Se+Yetz/YKK5nBiocy+R7YeHG8icGxqagrR5d41mnA36NVDHOqI19Q6TB+HpnGg85n4TexMqIFWYWANecE5z7KZckzYd+9BUV1dn2nF1gKZp1H/5FUROzqha+jLU0imKrt+ByGrJInb380/PR1KjdpZJraZx2pPJDN48VGR0f39VzsEGdqJrI/zVJt2wchjbM7YTgvv0qadxtuys+ekulQJozGLkfU4uA71V12J+FxN9i/cAKm8xncs2hF9sGaZzojHPO0Fr8aLVNNKvVCPIlYdlRzIYopvNzg3ndoZU2oLMrLcI4UjPeA0KhQTnvJmUWmYUe2MFm0FPWpz2nIa0dS6kHvfkN29A0qmjMceC1H+ouAMOfCGeHmk+VPX3Q+T8OGNkkmKana+vry+jVFDALk1p7PyNEl4blzMk8hNBURT2bN2FgYxGnddYufVRiDk8iDkCSHZs0hqPXN5N5p1EYnyRtzqyjzPj3PmgwUyQLke0+JJWPLuTSwjvi3sSkVplQlRarQKCFjDHj3jfpGGTshEvL8jNVBIZD1llJURPzGSyaQetJOloBwCgsqcSL0e+DJcwF8wOn43Iikit98szWkhUt6vJ8Pr2V+McpsBOdG2Ev9KkK+4s1tIK/PTGp6jtMzEKo1YDLQVA2gEmSrXjft2pTr+ZQMxGQHTd6t7whiBVqPCkdwKmc6LhF1tG/q6UqxB7pJjcjH6NyIcDX4jZqVOsQmAhenoykSyYrx3NTXkGKtUwEk+XIciVh6sB+VM9TJ0RTbXnNMR/P4+Q3AtfL4L05Ee6t2eb+i+6OGHTbVWMrNR7eZUAgMGMDJLmVfWylwUCgAMHDoCiKKSnm9ioaUpEl8U5WQtisZhEFqvDs3WaJnS7e0LMEaB58w2o2+u0tlerZWTe9fRk2GycenHuM2as51cZ/Jg+R7QBmRLeN0pJBmg6Jxq/nBeic4Dlw0XpNc33VMf+oSk+Ph4UReHIkSOst2GDUZOestlzIBdPzGbZYT7aBtuwPGo5WT8P5B8gASK1So0Ij3QEufIQd8zwmvJX4hymwk50bYS/wqRTqBUIFgYT84c54XMQIgyBgo1hAE0DHeVA1lFmMRm1wRz/CpyNIe8laHr1P6h5ZeHEJrRJwuU8MaZzovGwWzSaehlZmCGJXEtZgRchQtoY5YVuxZ9DSmwsaJpGQ+MJ8PiPgctzRGLSbDQ1nQOPPwNcniMaGo6jbCTKcPjnJKinWkliHFFVbP0bLn/zHCG5N1YvgHLrXfpJHRui6PU3psZ2HNaU1MGBL8T6kWhe55GjTIr3tddMPo3Q0FBQFIVbt26ZtiFbos7ynKwFtVqNXT6MlmvCtvPMwj3GNEFx8COIOUkQcwQYSNFdRsFPdAaX54iODhOviaVQKRhDD2oa0xymB0Yd0QAUN/Xh3YMphOzO9orHuawGqNVGMl00zWgtU9OA0DdYKcIAwPHjx0FRFG7evMnq82yhGhhAxfOLmPrzdZbp/NoxEf3yfnwX9x0hu+4p7mQdLU1tJpbx3S36NY3/CpzDXNiJro1wp0+62r5afHrjU/LDfPvK2yjqMJJi7KkH8iKAS6uBPTN0L8B7ZjDv50UAPfVQy+WoePY5Jm22/8DknJwOvBeUiumcaKwJzwEAdLcMImJLGiG5ubF1oGkaPQrji9/tCpVqGCUlv2qVKgwOMuUJojJ3cHmOSBY8ja6WTpOaJGyKMaUHQ1vuwakvlxCSm7h2DmjKSJqeber/yAsTNn0rl3HC861hGsjEP/4EkZMzmn7faPJpnDt3jtGejYoybUNjpRfGzsmG+rvnw8+CoiiEehyEolV7ge46LYKYI0DLrizQSt0PS8mCp8HlOaKl9arFYzEJDRmaa9RTp/djrBzRAKjUNMLS6jDTM44Q3g9D0lDRZuS3UxGvGUeVcbKvVCrh7e0NiqJQXGz9jFLftWskYzGQnGz1/f/VoVApwBFwyJq6Jn4NBuQDUCnVCNuciiBXHhJO6DdYutM5hyWwE10b4U6ddDRN42zZWTx96mnyg9yesV23+HV/K7NoXlvPdH3rWmx9pwPnP2ciux0VEyIXkpgY5ubq/DgUzROtdScDheJeskClVHZCXNaNo78kI8iVh0PrE1GZo91sNyeVSWeeaJqibnEzMDzciMystwnJLSz6AUqlhqhLpc3g8ZkIW13dIYRuFCDIlYdC/m2QxuxtQI/ffBxbtXSE5L6FvJ8eZ+bXgXmGG68siOjOTi2GA1+IU81MU96oFFN3WJjJp3D9+nVQFIWzZ89OfNMYGdVRFmD8dRdw4i2b6u/m5uaCoihs9/RGb5KmhlXeNMCYQ3AEGMzW726Ylv4iuDxHiMWnLBqHyeBtH7kGcw1+bGwjGhu0SaRYdzqP3Ese2RwDv9gyDMv1kGSaBo6/qnkoMRLVbWxsNF+mjgVomkbdys9I1kJtpRpgOzSgaRqBeYFkbf3o+kdoH2pHcRJjvx68lofe9iGd296pnMMasBNdG+FOnHRtg234PuF78iN86cJLSG0aUz821M3UzsZs1DRTjH/tuJ9ZqNMOMDW5RrRs67/6mtFx/P57G5+dfvweWYDpnGi85J+I0tQmhPzAR5ArD6EbBWitmbigfCKshgNfiD/KLfesnwx0dQmQlDxvhOQ+grq6QzqbCMvLKeJWFXOY6QaOP26ahbMt0FJZjuDvVsJ/xTLs+3QZKryXGpTz0oKZNboytZpE7hO7JVC0t5No11BevsnnwOVyQVEUjh8/rv0GW0WIMWUBeh8qJxD4uwEvHbJ8o8ewsGGtr69PYwccojF46TxZAjFHgNY9OaBV+slbVtY75MFqUnF0KXMNon83+DFdjWhswC9rx/O+PEJ4F/nxkFiuR4awVqD5TkTXDe43LS0NFEVh7969Jo3HFEhFIogef4JRFjls3TpgOzQ4X3Yes8NnwyXMBa9efBXlnRU4+UcKUyIXrvvB6k7kHNaCnejaCHfapIutjcXCswsJyd2YtBF9/c1AZQIQvwU4vBg6tWy9/wGEvQ0k72ZUFFTstVfldXVTruHYMyjHY1tuYjonGtShbJKyP0NloK9Dt4WjZ1WTVpPS7QqaplFXf5ho5SYlP4muLv0pSamsldRNpib4IMiVh/DNaZM44omozs1E4OcfMBq536yAWGRiytZM1YW6YRkhulVDUvTzeMxcfWIm1MO654UhZGRkgKIo7N+/3+KxWVTOYITgm4oDexhN16tbw0Ar1ZDVS0g0d6jAsD1tbt5KcHmOqKreY9EYTMJQt+a6lcUY/Ki+RjQ2GJarsOtmGR7ZHEMI7/ozeWiX6JDvCn+XGU/QM4wigx6cP38eFEUhMjJS72esgdZt3kxj2twnoTBV99kO1uA18Ejm9Lmzz+F8TAyCXHkI+YEPSefEe8ydxjmsiTuW6J4/fx7Lly/Hv/71L/zXf/0XTp48yXrbsrIyvPLKK/jf//1fODg4YNOmTSZLtdwpk65P1oc/kv+AS5gL5p2YiXXHZ6Py8teMXu22v+uOEh17BeB6AzVJgML0RX8U7Xv2ME5oixZPWRPaoaRqTOdEY4ZbDPa6ckfUBvIgHdRP2M+0dMGBL4SzoOi2dRNSKgdQVLSelCpkZi3D8LDxVHVFpQ+4PEfw+XMQ8uMNBLnyMNAzea5bY1GQcBN7P3kH/iuW4ci6r9ElNjPVriv1P/qvntKHlB5N0+GQSo32wECInJxR8/5ys4ZQWFgIiqKwa9euMX80XxECvQ3AnscsI7lWaFiLuXoDFEXh4FZ/SKt70XGkEGKOAG2BeaCNNGQVFKwGl+eI8nLKojGYhJKrzLlv+zsglej9GJtGNDYoa5VgeXAqIbsunnGIyKjXblYT52q+k0LdJJamaezZswcURSEjw7YqFaq+PtI3Id7wi02P9VdHQUcBFp9bDJcwFzwZ8SQ43oEIcuUh8Uz5hM/eKZzDFrhjie5HH32EefPm4dtvvzWJ6Pb09OC+++7DkiVLEBcXh9DQUNx1111Yv960TtM7YdKli1OwPmwBAgMfRMauf0C+TY+W7aFFjENZRTzjWGYF0HI5Kp5bCJGTM9oDA62yT1OhUtNYOKKH+e4vsQhy5YEbVgqVnuaZUeRJBski2Ca7DdzDxmFoqBYZma8Tkltc8gtUKnYPJDJZB/iJT4DLc8SFgxsQ5MqbdPc3mqaRej6CNJ2Fb1yPgW4LzSvGpv6PvGC09OHcyMPMEylMBLnh2+8gcnJGy1ZPsw5fXV1N0vwq1UjUzoL6YQBAxAe6syymvI68YNb5jKKyspI5L08KzacKSTR3uNT49zVqVlJSariEwKqI+pE57xNvGvwY20Y0NlCraZzJbMAsStOs9l5QKkqbxxDts5+OlKvM1ZkV6+npIfNnMtac3osXSbZt0FRJPDtMQr2kHm9eflPTpOblgZD1/AkBhjuBc9gKdyzRVY/Ufvb29ppEdHfu3In/+7//Q3e3RqP1yJEj+H//7/+h2YRmqD/lpFOrgdYiKFL3oSroSQzoq987+DQQ/RtQGmUzLVtJbCxpQpOLp+YaXkurJwsP9cMt5NysYxWhHVSqCNFN6p5iVYJx6OzkITFpNrg8R/D4j6Gh8YTJUefKqp3g8hxxK34mQn66jpQLk1eioVIqERscQEhupLc7ZEO6mzNsiT21TCPSqznloGka5QuegcjJGT1mpo1bWloIUenvH5kzFihCmLS9DSO6crkc3l7bQHlSqN7Ch5gjQHuQkNWcKyv3YBojC10tGgNr0DQQMJM59+TdBj9qaiMaG3T0y/DzuXxyz3HcHIPt0aUYlCmB1iLN95I7sdlxNCPg4+OjeVCyIWi1GrUffQyRkzOq31oGWnH7PdDfSega7tJSOVq5cz2SzpVpfeZPyTkmCXcs0R2FqUR38eLFWL5cO/3Y29uL//7v/zap/OFPMeloGuisBLKPARe+AHwf0rngKfydgGvrgMILgGRyarIavvmGaUJbvWZSjjceTeU9eGkT412/aOPNCcoKxjA/vdTs+j1bgKbVqKkJJFHcZMHTZgvxy+VdSExyAZfniPMHf0Tkrhwrj1bPcYeHcHG7ByG5MQf9oVJOzQK7QdQAB74Q3xbXQl5fT6Jb0vKJKUU2kEgkhOi2to4oEVga0bXETMJKNboAcCL4GEI9DpJorrSqh9V2VVW+4PIckZdv2LTBauis1Jy3EetdcxvR2EBQ2YElu/mE8C7cxcOt0jYg8mtmbHufmJBpiI6OBkVROHHihNXHow/DRUXECbArdPKO+1fFkGII67nrCdl9L+BzdHdrov5/Cs4xRbAT3XH4xz/+gS1btkz4+/333w8Oh8P6uLftpOttBPJPA5fXAP5OOhe3Tu+/IWb3feBd/RKKrqpJH6K8oYEQB0lCwqQfvyy9BdvXayw8TyVUm7yPLwpr4MAX4pcyyySarAGFQkLqHbk8R2Rnvw+p1DKptqrqPeDyHJEQ9zgOb4iCUp9EkpUw2NuDiD9+JiRXcObklNY/fySsggNfCM/KJvRdv8E058yZa3YtuVKpJES3pmbEWtmSGl1TttdHoK1kEyzgJ6PALYZRWggwTCDHorYuCFyeI7Ky37N4DKyQcYg5d9/pBpu+AMsa0dhAqlDBP74cj7prmtW+P56EFsqRGWOGthLFoUOHzDMcsRAtHlshcnJG+ZPzoGi/PR7q72Qo1Up4CihCdt+P+Bh9Mkb557blHLcB7ER3HP7nf/4He/ZM7PKdOXMm1qzRH12USCRoamoir5ycnNtj0g20Mwth1E9A4Bydi5pq5wPI3jcDOw5Mx7tHnfDWpTdR0FEwZUNu998LkZMzKhYtmtSUGE3TyIyqQZArDx9sYKK5T/skQGGG+9eOasYe9o2cChuMlD0GBiqQlr6UkFyRyA0qleXkRaHoQWLiLKZWN/gHNFeaZnlrCrqbxTi6/luG5H7yNvLjbtjsWGzxbAYTsT/S2I62nTshcnJG3WeWRR537mScxIqKRoxXzFVdGIVR9YW7gG33aPY19l9j+sMmoCmxgkRzq0MzWW/X2Bg2YlzyslXGYRSnP2bOPfJrgx+zViMaG1S19+Pjw+mE7D6x+RpCt6yAyu9RQM6YcMhkMnh5eYGiKJSbmVEwF8qeHlK207Rp06Qe+68Kmqax9YKvxqzp8ttoGmiyE10D+NMQ3b6+PpSVlRl9ja9PmiyiS1EU/uu//mvCa9In3XAvUBYN3PyDkaPRtcCaisEKAAAgAElEQVRtvw849QHolEDEp/nhmTHmDz4ZPhhSTH7N4yhouRwVC59nmtAC9k3acZUKFeKPlyDIlYcAVy6c3JhISuAt8+pPL7f1wIEvxMPJhVBPUeSxrf0mKTHg8Z0gbjpj1ShoTc0+Jqob74ycuHyr7XcsmspKEfTtp/BfsQyBq5ajMnvqG1/UNI0HEwvgwBcipqMXdZ+uhMjJGW07dxnf2AACAxkprszMMWTQDEUILRjbvrPKpCY8U0GraLTszoaYI0Da5suI23mB9bYtLZfA5TlCkPKMVcZiEEoZsP1fzHXJizD4UWs2orEBTdO4kNOIOdviCeFd5nYQRTeCAQA1NTUkGzA4qN8i1lboPnNGoyGdMzllTH91SAcV+MXLD7NPMFq7L154EYnFiXaiqwd/GqJ78uRJnURy/IvUt41gskoXpiyiKx9k7CETtjILla7ojfe9wMllQJIfY2+plKNjqANrb60lBPfFCy9CIBbYdqwsIImLJzdNuXhyXLeGB+S4vDuXaORu3ZeB6ZxoPOoeg/Z+HbqWLFA6MEyiPvXDkyu/RdMqVFX5kSiuIOVZ9PXlWf04CoUEt24xUd24ixusvv/KrDQErloO/xXLEPTtp2gqt17jjyVolynId1vQI0HZnLkQOTmjLzraov0eO3YMFEX9//buPL6pKu8feHhgdHScn86odAZ/DjMdpVUW0Rl1FIFHxXEcFwR3QRlEKIKOgmDZbyk7BcrSikALlLWl7HSlTUp3ulFKabqv6V7apnuaJvfz/HHpDaVJs94mTb/v1yt/kOYmJ9yln557zvdALBb3/IGRFSF6MXd7M7QmV/G9ubtWe2D/ql1QyQ373JqaMK6UXdRogVuJngszyPu+ZgsxEc0Qt1oUWBxwnQ+7f3G9COZsGkIjosAwDHbvts4S6axKhcL3p3Hl9d6barVSkINNwtkCuP7kjWd9uY6q8bvHU9DVYcAEXVOZMhlt+vTpPZ6Ty+W2MxmtSwEUxwGSDYDvm5pbj3ff0tz/GhC5FiiM6lXLNrw4HBNOTuBD7qKoRWjoMGyCiNC6yzSVfjWnXz6vsboNR1Yl8CE3OagQb3pGY6RrEL49YXovpUKtxogoLgyF11l+OU5dlMoGXLv2BR9yU1I/gkIh3Ni5RMl6rlf3shM6OnQv52qsa2GXsO2Td7Dt47exf+FXqK+wgaWGb0uTa8rHVdzM0vxhVmrerf7jx4+DYRhcumT9oRmWwHapUbkpiRuy4JUAhmHgvmYtGpMMuybW18fxxzHLCtxzGsFw106vF/S+VMiJaIZIuJGLV5cd0NTeXXkR/1m1E2fPnrNKewCgLS2NPw/qjx6zWjsGk/bmTvzyXRTcFvlhgt8kOHk6UdDVgYLuXTZu3Ijf/va3aGzUjDk8cOCA9cqLqbq4guEx2wG/qcA6B+3DEX6eAIQuB3JCgQ7twaqpswnLYpbxAfcfx/+BiwUXbWZRg06ZTDMJLSxc8M8rz23AgUXR3GozCyXITa5CcnE9/wskudi80mmvXJXCQZKOXSXGVWwwVXPzTcTFT+LDQU4OA7Va2PXoq0sqER7C9epmpPe+E2IsVq1G9PFD/KSzI67/RWujbfwR1u1CTSMcJOn485UM1AcEcOPJX3jR7PPo/PnzYBgG/v7+FmqpdbXElXO9uctiIC+u42+vX/OJMmh7edN1/lhWKnUv3mARv0zkrqOhy/S+VOiJaIZQhK7CzpWz8KTrOf56NX1nBGQN1ht2VvGTKzcx7fkX0HXLzLrWxCCxgXnwchFj+0/n8MaBNyjo6mC3QTcrKwuBgYHw8/ODSCTCwoULERgYiJCQEP41JSUlGDp0KPz8/PjnuheMmDx5MsLDw3Hw4EE89NBD/bdghFoNVGUCCd7A8U+Ajf9fe7Dd/RxwaRG3kk+r/ovK1cqrmBI4hQ+5X4V9hcoW21q+sWaHJxcaJgg/CS0nsRI/L5DAy0UMn8UxqMjn/rD59gRXx/JfO2PMDi5fZxbDQZKOb/qh56ey6hwkUU/dvtXrjMrK04J/JsAVuw/Ys/R2IHEyq5qDqkuJ4N0efMg9vWE1Otut94tbF+/SGv7WdeWqVRYrg3f58uV+LxElFHWnChXrEiFzjUH9KW5CppfHbjAMgzNrDxtWj7q1gA+65lYJ6fuD6jTX1by+q7z050S0PrXeAjY8hpTVz+Mfy4/zYdd5VSh+uVJg0gRac3XV1iLnb3+H1MkZFStW9PvnD0atcgX2fhsFLxcxTvtFUtDVwW6Drq7JYSNHjuRfU1xcrLW3VyqV4vXXX8d9992H4cOHY8mSJcItAcyywK0CIMUXODUL2OKoPdhufxo49w1w/aTeMWR3UqgU2JK8hQ+4zx15Dn43/aBm+/9C2BdWqUTuK69wk9C2bRfuc1gWVy8W8kMVjq5OQGMNF6Zqmjr4tedPJJk/43zb7UUFXk3K1v9iE6nVSuTkruUDQVzcK2hquiHY52lzflc8woKfQaTYEdnZpvXqKtpaccp9BR9yQ709obLRsX7Lc2VwkKTj0+sFKHxvKqROzqjdtcvs942Pj+eWy92zxwKttK6mqDKuN3dFLLrquXHuoWe5Wq87V2+Fslr/pCmFopo/rltaBKwm0F2Gzf0RvpKBLv09Ea1Pkg1IZV7GmjUMZrt54zn3y3zgfdMzGmml/X8npP7wYf6uXPt161XuGUyi/XPh5SKGx7wzFHR1sNuga219Bl25DEg/Dpx1AbY/pT3Ybv0rEDgbSD0E1BdygdhI0ltSTD03lQ+5H138CPkN/V8X1xBNly9bbKyjLiqlGpd9b/Ih9+y2NHS0aHqOd0bkcWPemDC0dZofsoJquVvcj0ddh1Jt+eEhis46pKZ9yoeBtGsz0NnZ/7cMr14sxIntrrerO4xCe7tx42mb6+vgt2QhH3LjAo7azHAabb68wdVI/vFmEaRPj4bUyRnNEonZ75ueng6GYbBlyxYLtNJ61O1dKHdLgMw1Bg3nNdebwgJNdYDKSP1l97q6Wvlju1FueP1do52dz11zD7+r96XWmoimVYcc59w/A8MwOLpjJRrbOrHsTAYfdv+8LAgrz92AvL0fSzQqlSh85x1InZxRNP0DsP2wSttg19LQgZ8XSrB+pj8FXR0o6AqkR9BtqQUyzwAXv+fqWmoLthsfB058xhUCr84yKdh261J3YX/Gfoz3G48xh8dgnN847ErbBaWWNdJtRenXc7lbwLNnC/L+HS1KnPHQVFa4fPAmVEpNr7ZSpcYLGyIw0jUI7peyLPKZBW0d/G3O3FbTqjfoIpenIzbuZT4I5OVvhFptnR7Q0qxb8F4QgrCg8XytXkPVlZVg3zf/wbaP38b2T95FRkSogC21jNeSs+EgScfWeM0EnK66OrPfNy8vjw+C3UuYD0Ty8GLIXGNQvioOqibNnbCuri6sc3MHwzCI2aO/QgXLsogU/xWRYkfcunVFmMayLOAxirsGx+ovZ2jtiWh3271lLRiGwRW3N4EGrk0pxfV4Y8cVPvD+fX0ELlyv6Lc/HluvJvHnRYO/4eXkiOmijmVT0O0DBV2B8EF3w3M6atn+ATgyjbu4lqfpXYnHUGVNZZgRPIPvxX3rzFtIr0m3yHsLpVNWzi8l2RRq+aDTWN2Goz0qKxT1uugHZVTyvxiK6ixTi1LFsvjTFa7e6oUayy2oUF5+EmKJM196qbraurP0Fe1d8JovxvFty2/36j6JtrZivdvJsjKxZ/bHXI3cmdNRkJokfGMtwCnmBhwk6Th06jykTs7Ie/VVi7xvRUUFH3RbWqw4/tMMqpZOlK+Oh8w1Bo3BRb1+7uflC4ZhcGTNXrAGjCONujIOkWJHVFebV7pNp+oszTW5MkPvy21hIlq31tZWzWp6zGjg3AL+Z51danhH5cNpVQh/XZvpcxUlt/qnzm75osX8JM2uBtuaTGqPmurasfGLAAq6OlDQFQgfdBc9wF1E1z4MHHwLiNoElMQDXZadDc+yLE7lnsLzx57nQ65bgptVF38wVM3OndxF8aWXwRo5FlqfirxGHFisqayQc1V7CayPb68+9IWvZcPWlOQcOEjSsaXI/Il/arUC0uzlfC9ufML/Cjt20Qgn3a/C+5swiCOeR6TYETezfuzz9TkJsfD8fCq2ffw2vOd8hsp82/ge+rR0qfhe+ovrNkPq5AzZd/+1yHs3NjbywaVmgC6n2hhUyPXmromHqrX3HaR4cQwYhsGmNevRUay/7F73XYuKCoF6BuN33x4q9gQ3EbgPNjMR7bacnBwwDAM3hoGCeZgrK1nXc4Gb0ltt+NI3iQ+7o1aGwEuSj84uYe8YKKuqkP3sc5A6OaPSzU3QzyIcf09aMEIXCroC4YPuyUVAgRjoFC5w1rXXYUHkAj7gTvafjCtlAt3qszC2qwt5r0zkJqFpWZHOHDlXq/DzQq6ywoHF0ajI096zkFPVzP8iiJRathTYwqwSOEjS8VVm794tY3QoqpCcMp0PuenXZ0Op7L/6vPpEHcuGl4sYQX4bb7fxCbS2Fmp9bWrQeb5Grs93X6OhSsAZ9RYmvWMhkNgPPobUyRm3DhywyHsrlUo+6BYVmXe8WINKroBsZSxkrjFoitB+a7+2tpb/jnnn9I+7Tbz6JiLFjigt9bV0czlH3ueC7hn9VTNsaiIagIiICDAMg717f+YmK+tYvphlWVzKqMDf10fw17kp268gqci88on61O3fzw1hcH4K7TdvCvpZBMi6nk9BVwcKugLpr3WnI0oi8MrJV/iQ+73ke9R3CHsBs6TmyEjNJLTiYou8J8uySLpUpKmssCoBjdW6/9BYcfYGRroGYcJmMVQWnjS2p6QaDpJ0vJxo+uSVhsZkxMS+wIfcgsLtwhfQN1JOYiW8XMT45fvLiI2bgEixIzJv9lwtjVWrEeV3gJ90dmz5D2iTW25IR3+IuB12/ihJR+ZTT0Pq5IzWxKv6NzTQ+vXrwTAMbg7AYNBwNg8y1xhUrE2AukP7eHGWZeGxfgsYhkGIh/5e2uSUDxApdkRhkflVLXpRtgPrhnMB8fpJvS+3qYloAA4ePAiGYRAUFASkHtYMwajSXnWlqUOJVecy8edlQXzg/SkwA41twtTaZjs7UfDmvyB1ckbxJ5+CHcDjzgeC/socAxEFXYEIfdA1dzZjRewKPuC+ePxFnM8/b9Oz1bUpnTcPUidnlMzq3RNhCpVSjcsHNZUVznik9qiscLemDiWeWh2Kka5B2HulwCJtuNPlOjkfjDqMrG3JsizKyg5BLBmFSLEjoq6MQ22t8AtpmEJe28b/n2ffOHQ7lP8VLS3c7PoupRKXPDfzIffsZjcoOyw7Qa8/HCqvg4MkHeMlaXxvlcqC42k9PT3BMAySkgbGeOVuXbfaIVvO9eY2X+m76sbpQwFcT+RqT6gVfU+gvJY+i5tsmbfBks3l5EdqwmGz/js5tjQRTaVSYd26dWAYBhkZGYBKCewaz32XE5/2ue210gb8a2cMH3afdb+M06kyQX53tMTG8R0ZjVZcuW0woKCrGwVdgQh50CVXJeONwDf4kPuf0P+gvGXgHdzKigrNJLTgYLPfr6NVibPb0jSVFXx7VlbQ5lBcET92raHV8j0bZR2d/K3uzGbDh6+oVB24mbWY78VNSHwDra2WD+KWwrIsfJfEwMtFjOviYsTFT0ak2BE3Mr9FR0sL/N1c+ZAbvm831AO07NC6ggo4SNLxVlA0pE7OKHj7bYu+/759+8AwDKKioiz6vkKrD8jhenPXJ0Ld2fe+zUzLAMMwWLvGDY03+l42+saNhUZX8jBY2ArNqpIGsKWJaOXl5fwQkIbuyV4ZAZrgLkvpc/sulRoHYgrhvCqUD7yf7U9EYa3lxx7Lvv2Wm4Px8gSomgRe4W4Qo6CrGwVdgQhx0ClUCngke2Ds4bEYc3gMnj3yLA7fPGxziz8YqnbXbu4C+I+XoDZzElpjTRuOrUnkQ27SxUK9PRQsy+LVbVEY6RqEH08JU9ycZVk4RmfAQZKOwCrDhpS0t8uQlPQuH3IzbsxHV1ezIO2zpOCfM+DlIka4z01UVATy7T/GzOBDbsLpEwPursOd5t/kVrubdfAUtwKUq2UD2LFjxzS3owcIZXUrZMtiIHONQUuC/vHWbW1tcLsd0tKORPX52iypK/8Hk8V5v8SFwvBVel9qaxPREhMTwTAMPDw8NOeTWgV4vch9J7/3DHqf8sZ2zDmczIfdJ1eEwDMiFwoLjkFWlpcje9wzkDo5o2qDAD3zBAAF3b5Q0BWIpQ+67PpsvH/+fb4X94MLHyC3QX/RdVvFdnUhb9JkSJ2cUb1lq1nvVZHfCJ/FXG/izwskyE40rMJBbF4df4G/IRNuYte/U3PhIEnHugL9IaC+Pg7RMX/jb/0XF3uDHSB/yKSFl8DLRYzDy+OgVnchJmYiIsWOOO0zDts/fReZkr6XVx0I3knN4xaLYLZA6uSM+uPHLfr+Z8+eBcMwOHXqlEXfV0i3jmZB5hqDys1JYA2czb/XYw8YhkHghkN9vi43152bfJlumaFNvOYqTe9ngf7FPmxtItqpU6fAMAz8/f17/kB6UfO9imIMei+WZRGaWYUXN0Ty18NXPaIQX2B+behutd7e3BCGp0ejI2fg/t6yZRR0daOgKxBLHXQqtQo+N3ww/gi3+MPYw2OxI3UHOlXCTCDoL81iCT92S2HGDPPc5DsqKyyKRnmu4TUbv/ZLwUjXIEz1ijP58w2xOLsUDpJ0zMjQXoUA4H7ZlJT8gkjxE4gUO+JK9HjhiuQLpLJAzveo5yQkw8/tNb5XNztl4AS3vjx7+/b15jkLuWVOb1h2ueXw8HAwDNNrWXJb1Vnewi316xqD1hTDK5aEnw4GwzDYvnozVM26r2UFhTsQKXZESupHlmiuRvpxLgyucwCU+seK29pEtO3bt4NhGMTHx/f8AcsC+yZz383nDaMWHmpRdGHtxSz85Y7JaosC0nGrRWF2e9UKBfKnvMHNx5j5xYC+q2OrKOjqRkFXIJY46Mqay/BlyJd8L+6bp99EWnWaBVtpPWUu87mL3hdfmrQ9y7JICdZUVjiyKgENVYYXQy9vbOcv6GfSjFuy1lj7y2rhIEnH3xK0z6Tv6mrFjcxv+VB49epbaGuz/oQXY3UpVfh5oQS7Zntj+6fvYdsn/0bw2dG3y6HNsXbzzKZUs/jj7dvXh6Z/guwxY80ecnO32NhYMAwDb29vi76vUOoOZkLmGoOqbSlgVYaHl5LCYn6MaUWs7mXJS0r38+eERZ2ew4XBo9MNerktTUSTy+X8/11ZWVnvF+RHaHp1c42fvJpZLsc7u2P5sPvM2nD4J5dCbWZFmjs7N+SXBs7QnIGCgq5uFHQFYs5Bx7IszuSdwQvHXuBD7pr4NWhV9s+qNkJTVlZCers0kykXPFWXGpGHsjSVFbamor3FuMCxJTQbI12D8Jz7ZXQohb0VGVPfzI/va77rtmdbWxFfK7S7JJdKZfuLfGjDsix8F+3kx+P6fj8XhblH+e8ml9v2Cn36lLQr+P0YMvl1FH1o4V5GANeuXQPDMNi61bzhPP1BUSzne3PbMmqN2lalUmGDG1c14Movuq8B5eUnECl2RFz8RHObq6FWA1scuSCY4GXQJrY0ES0zMxMMw8Dd3R1dXVqqVrAs4Psv7vvtfcWk5eRVahaH4oowek0YH3g/2puAvGrz5gqUzXPhVhOcOAmqFvv4fWYrKOjqRkFXIKYedHXtdfg28ls+4E7ynwRJqf4xZANJ7R4vbhLai/+AWmHcbbGOViXObddUVgj3uYkuI4Nqh1KFZ90vY6RrELaEZhu1rSlqO5V8QEqVay7udXViXIl+hl82t7TUd8De0lOrVRAf/IUPubtnu6CtSQ6WVfNB/lr6LGs30yzxDS38fkwb9wyq1rpb/DP41a7c3KC24bqjLMui5pfrkLnGoHpnGlgTevuO7uHqwB5e+7PO476q+uLtoTzPmttkjYp0TY9njf6hCLY2ES0kJAQMw8DHx0f3i4rjNN8x67zJn1Ul78D8o6l82H1iRTC2hmWb3DnQWVKC7DFjBVkgaLCjoKsbBV2BmHLQiUvFmOQ/iQ+534m/w632WwK2sv+xKhXyJv8vNwlt02ajtpXX9qyscPWC/soK2pxJk2GkaxD+siwI5Y3tRm9vLJZl8VTsDThI0nGs4hZYVo3Cot18T2d0zN9R35AgeDuEouxU4MK2DXzI3THjv/CeHw7l7TJTNTWh/HdtbOy77JEtC6iqh4MkHU9eihWsLqhMJuNvS7e12W7PfkduA9+b255t2gI1iZe5YRob1qyDolp7gKyrk/B/CFrsj8CY7VwA3OZsUG+nrU1E6y5BFx6uZ1hC96pve57nKjKYIVJajZc3ifnAO3GLBNG5xvXid6vx9OSGMIweA0Wh7nkLxDgUdHWjoCsQYw66ls4WrI5bzQfcF469gLN5Zwds715fmqOiNJPQjLjIVRbI4fPjHZUVEgyrrKDNVK84jHQNwly//gtd067lw0GSjhU5RbieMY8PfknJU9HRMXCWwL1be0szTqxeyofcEO/d2DMvAl4uYn7JZZZV42rSO4gUOyLt2gwrt9h027snJB0+yx2/BZava1xfX88H3bo6y816tySWZVG95xpkrjGo8U43+TpVf0vzXXOCtc89aGxM4c8VlcpCf5QeepsLgOcWGPRyW5qI1tnZCTc3NzAMA6lUT3vKUzW9ugas/KZPW2cXNgZL4bg8mA+83564hppm4xZ+Ube3I+/VVyF1ckbp7Nl2+XvOGijo6kZBVyCGHnSp1al48/SbfMj9MuRLyJqFnRxlTWXfLOAmoc2YafA2ecnV2LswSlNZIcfwygp3y5A18hfp2Lz+CxLLc2VwkKTjjSsB/C/uLOlPUKnMn9FsLfKaahz8wYUPuVfPnQLLsjiyMh5eLmKkhhbzr62tjeC/d0NDovUabYbu6hkf7NiPnOf+JsiSpgqFgg9/JSXWn/ikTfvNOr43t6PAvCWcd6z34OoGe2pfDri5WcofNwqFaT2IPXS2Amsf5sLfjUCDNrGliWjFxZpJfC2GrMh38nPuu+4cx62eZgHSyia87x3HX0fHMGE4mlhi1GS1prBwvsOjSV/PNDEIBV3dKOgKRN9B16nqxPbU7fziD+OPjIdvpi9UZt5ismXK6mrNJLSLF/W+nqusUKyprLAy3qjKCtr8eOo6VydyW1S/9iR4ZV+BgyQdo8QSiCVOkMmODeiejJriQuydN5MbqvDZe8iKFvM/616COcg7g3+OZVkkJU9FpNgRqamfDMjv/nF6ARwk6fhm1UaUfDlLkM9gWRbu7u6G9dhZAatmUbUjFTLXGNQeML+02jlfbjlgb2aH1qoN7e1lfNBtazO9DCEvN+x2L+eDQKthw8JsaSJaTEwMGIbBzp07DdugOov7rsz/A1J8LdYOtZrF0cQSjGE0k9Xe946DtNKwlc9YlkXp7NncxLRXX4W6XfghZPaOgq5uFHQF0tdBl1Ofg+kXpvO9uNMuTENOfY4VWtm/uouG57zwot5JaKouNSIPayornN6SgvY+6m0aoqG1E0+uDMFI1yAcirPAL00DsKwK+QVb4S1+i5/QUliX2i+fLZTijGvY9eWH3KSzWR+iOONaj59nXpHBy0UMn8UxPQJt3a0oPrTU1wtbu1gIE65K4SBJh9uCxajZtk2wz+mukZqSYnvjmdvSa/jeXEWp+cu5ZiVzywG7rWHQmNc7SCqVDfwx09RkgZrFIT9xoW/fZINebmsT0Y4fPw6GYXDmzBnDN+oupbbN2aCawcaoae7Adyeu8WHXcXkwNgZL0dappRrEXRSFhZCOHsNNTDM0uBOdKOjqRkFXINoOOpVahYOZB/HskWf5xR+2p2wf8Is/GIJVqfhxWdUbN/b52o5WJc7t0FRWCDuQaXRlBW32XinASNcgPLU6FE0dlrmN1xelsgHX0mchUuyIC+Ix/C/MuAbbX85Xl5tXIrHjs/ew7eO3sdflC9QU9x5nXSdr5vfdnT3wLMsiOeUDbgGAlA8GVK8uy7IYeeU6HCTp2Pvpl2gKE+526969e8EwDKKjowX7DFOwKjUqtyZD5hqDusPaa0Ibq6OjA2sZbsxpin/vBVLU6k7NH0eWmLC55+9c6Itca9DLbWkiGsuy2Lx5MxiGQXJysuEb3ioA3H53u5yaMPWZo3NrMXGLhA+8L28SI1KqfwGR6q1bIXVyRvaYsei00aE6AwUFXd0o6Ark7oOuvKW8x+IP/wz8J1KqbK/HRigt0dGaSWj5ugvEy2vbcZzRVFZIPFdgUumiu6nULCZs5mYNrzhr2dWstGluzkJc/CTNymA5azA+PhMOknT4yCww1rCfsSyLq2cD+PG4B39wQVOt9lu5ajWLfd9fgZeLGNL4nhPtbtXH8v8ndbei+qHllnFnibiz//w3lJWmT4bU58iRI2AYBiEhIYJ9hilakiq53txlMeistFwN1P1bvcEwDAK2HNL6c0nUU4gUO6K21swlpBvLNJOzimMN2sSWJqLV1dXx43OrqqqM2/j8Qu57b3EEFML0THcoVfAIy8ETKzST1eYfTUWVXHcvsqqlFXkTJ0Hq5IyyeS6CtGuwoKCrGwVdgXQfdDKZDOfyz+HF4y/yIXdV3Cq0dFr/Nlh/KlvILZla/LnuWfdVhXL4LrldWeEbSa+QZI5IaTV/8c2pErZHtarqPCRRTyNS7AhJlDMqKrhJL59e58Z4Ls3RspqRDVOrVYg44M2H3JNrlqK9pe//wws7r8HLRQzJkZ4BgWVZpKZ+wlecGCi9uulNbXzQvfrPfwna7tOnT4NhGJw+fVqwzzAWq1SjcuNVyFxjcOuEZWtPRwZwdWE91myCStH7lnd0zPOIFDuisvKseR+UepgLextGAF2G3UWzpYlo3YuJbNiwwfgay41lgPsj3PePFrZ+bV51Mz7am8Bfb0evCRJIzYYAAAq+SURBVMPBuCKodHRYyC8F8Z0gzRL7qhnfnyjo6kZBVyDdB91X/l/xAXfiyYmILI20dtP6nbK6BtKnR3OT0M5rL16el6KprLD/h2jITKzNqcsXvkkY6RqEj38Rrl6tWq1Ebq4732MZGzcBTU2aCVlu+eVwkKTj3bQ8wdpgaUpFB85tdedD7oXtG9BlwLK3SRcL4eUixnG3q71+1tCQyP8f1dYNjPPhUk0jHCTpeDwsCaXzvxH0s0JDQ8EwDPz8/AT9HGM0x5ZzvbnLY6CstWx937L8Er6nsjyl91CY+IRXESl2RJnsiHkfFPAlF/SOf2LwJrY0Ee3ChQvmHRfBS7nvv+lxoN28ahn6qNUsApLL8MzacD7wvrsnFpnl8l6vZVkWJTNmQurkjPwpbxi9iBDhUNDVjYKuQEpLSyESieDIOMLJ0wmz/GfhRv4NlJeXD7rHjU2bEOX4V0Q/Mx5lBQU9fiaTyRByNBHrZ/pj/Ux/eH53HplpeRb9/IQbeXhswWE8tuAwDl9OE+Q7FhXdQEjoVPj7/wn+/n9CSOhUFBVl9njNz2mZeCQgHH85cxkymczq+0XfIz9bij3fzcXqd17H6ndeh/+OTSgrKzVo2yRJJr9PC/KKe/08NPR9+Pv/CRcvvQ6ZrMzq31XfY1PydTwSEI5x3n7I2LBB0M86c+YMFi1ahE2bNln9e5eXl6OsqBSpSy8gecEZZP4SY/n3LyvDssU/YdGiRQjYdrjXzy8FTYG//5+QmLjR9M8pK0X5shEoX/QAyi9uNmibG0UleCQgHI8EhONCVq7V98P69eu5/6OAANPeIycd5Usf4f4P/Jf0S5szcwsxd284f/19fOFhLD4kRm5hSY/XFUTHIOrJUYhy/Kvg55e9PlJSUiASiVBaWmrt+GNzKOgKpPugowc96EEPetCDHvToj4ctVmuxNgq6Auns7ERKSgpKSw3rAbPmX4ApKSlWbws9aH/Sg/alPT5oX9rXw1b3Z2lpKVJSUtBpwNCywYaC7iBWXk5jeuwJ7U/7QfvSftC+tC+0PwceCrqDGJ2w9oX2p/2gfWk/aF/aF9qfAw8F3UGMTlj7QvvTftC+tB+0L+0L7c+Bh4LuINbU1ASGYdDUZP5SnsT6aH/aD9qX9oP2pX2h/TnwUNAlhBBCCCF2iYIuIYQQQgixSxR0CSGEEEKIXaKgSwghhBBC7BIFXUIIIYQQYpco6A4i/v7+mDZtGv7whz9AJBLh0KFDBm+bnZ2NKVOm4P7774eDgwOWLl1KK7DYAB8fHzz55JO49957MW7cOFy6dEnvNocOHdK6dOSmTZv6ocXE1HOps7MTS5YsgYODA+6//35MmTIFOTk5/dBiooup+1Lb+efk5NQPLSZ9yc/Px7x58zB27Fj8z//8DyZPnmzQdnRu2jYKuoPIhx9+iOeeew5fffWVUUG3oaEBf/zjHzFp0iSEhYXB19cXDz74IBYuXChsg0mfTp48iSFDhmDVqlWQSCRwcXHBsGHDkJiY2Od23UE3IiICiYmJ/KOioqKfWj54mXMuubi44MEHH4Svry/CwsIwceJEPPbYY5DL5f3QcnI3c/alSCTCDz/80OP8u379ej+0mvTl/PnzePzxx/HRRx9h1KhRBgddOjdtGwXdQUStVgMAGhsbjQq6GzduxAMPPID6+nr+uX379mHo0KEUjqxo1KhR+Pzzz3s899JLL+Gtt97qc7vuoNvY2Chk84gWpp5LMpkMQ4cOxf79+/nn6uvr8Zvf/AZbtmwRtM1EO3OuiyKRCJ6enkI3kRip+3ckAEydOtWgoEvnpu2joDsIGRt0J06ciGnTpvV6jyFDhhg1/IFYTmFhIUQiES5cuNDj+V27duGee+6BQqHQuS0FXesx9Vzy9fXFkCFDeu2zadOmGdzrRCzLnOsiBV3bZ2jQpXPT9lHQHYSMDbqPPvooVq5c2ev5ESNGwNXV1cKtI4YIDg6GSCRCfn5+j+cvX74MkUiE7Oxsndt2B93hw4dj6NCheOKJJ+Dp6QmWZYVu9qBn6rm0dOlSPPbYY72eX7FiBRwcHCzaRmIYc66LIpEIDz/8MIYOHYrf/e53mDFjBqqqqoRqKjGBoUGXzk3bR0F3EDI26A4bNgweHh69nh89ejTmzp1r4dYRQxw7dgwikQh1dXU9nk9JSYFIJEJ8fLzObcPCwuDu7o7w8HCEhYVh3rx5/FhfIixTz6Wvv/4ao0eP7vW8h4cHfvWrX1m0jcQw5lwXZ82ahcDAQERHR2P37t149NFHMWrUKLS1tQnVXGIkQ4MunZu2j4LuACaXy5Gdna33oVKpemxHQdc2GbM/zQm62sybNw+//vWv0draasmvRO5CQdd+WPK6mJCQAJFIBB8fH0s1j5iJgq79oKA7gOkqE3X34+5bYjR0wTYZsz/NGbqgTfd2SUlJlvxK5C40dMF+WPq6OGLECHzzzTeWaBqxABq6YD8o6A5CpkxGmz59eo/n5HI5TUazou7JaBcvXuzx/O7du3HPPfcYXeO4O+gmJydbspnkLqaeS90TXu4uVzR9+nSa8GIllr4ujhgxAgsWLLBQ64i5jJ2MRuem7aKgOwiZUl7st7/9bY9ZpQcOHKDyYlY2atQozJw5s8dzEyZM0FteTJu5c+fS0IV+YOq51F3C6M5b2w0NDXjggQeohJGVWPK6GBcXB5FIBF9fX0s3k5jI2PJidG7aLgq6g0hWVhYCAwPh5+cHkUiEhQsXIjAwECEhIfxrSkpKMHToUPj5+fHPdRdGnzx5MsLDw3Hw4EE89NBDtGCElZ04cQJDhgzBmjVrEBUVhfnz52PYsGFISEjgX6Ntf06bNg0bN25EcHAwgoODMWfOHIhEIqxZs8YaX2NQMfRceu211/Daa6/1eM7FxQUPPfQQDh48iPDwcEyePJmK0luRqfty3759mDNnDvz9/SGRSODp6YmHH34Yzs7OaG9v7++vQe7Q1taGwMBABAYG4vnnn8fTTz/N/7u2thYAnZsDEQXdQYRhGK1jPkeOHMm/pri4WGtvr1Qqxeuvv4777rsPw4cPx5IlS2gJYBvg4+ODJ554Avfccw/Gjh3bawlgbftzxYoVcHJywv333497770XzzzzDPbu3dvPLR+8DDmXJk+e3Ks3SaFQ4Mcff8Tw4cNx3333YcqUKUaPxSaWZcq+jIyMxMsvv4zf//73GDZsGEaMGIG5c+fyQYpYT/f1UtsjKioKAJ2bAxEFXUIIIYQQYpco6BJCCCGEELtEQZcQQgghhNglCrqEEEIIIcQuUdAlhBBCCCF2iYIuIYQQQgixSxR0CSGEEEKIXaKgSwghhBBC7BIFXUIIIYQQYpco6BJCCCGEELtEQZcQQgghhNglCrqEEEIIIcQuUdAlhBBCCCF2iYIuIYQQQgixSxR0CSGEEEKIXaKgSwghhBBC7BIFXUIIIYQQYpco6BJCCCGEELtEQZcQQgghhNglCrqEEEIIIcQuUdAlhBBCCCF2iYIuIYQQQgixSxR0CSGEEEKIXaKgSwghhBBC7BIFXUIIIYQQYpco6BJCCCGEELtEQZcQQgghhNglCrqEEEIIIcQuUdAlhBBCCCF2iYIuIYQQQgixSxR0CSGEEEKIXaKgSwghhBBC7BIFXUIIIYQQYpco6BJCCCGEELtEQZcQQgghhNil/wPE7FrsIxX5+QAAAABJRU5ErkJggg==\" width=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.ion()\n",
    "\n",
    "\n",
    "fig.show()\n",
    "fig.canvas.draw()\n",
    "\n",
    "def drawLine(w,ax):\n",
    "    x1 = 2\n",
    "    y1 = (-w[1]*x1-w[0])/w[2]\n",
    "    x2 = -2\n",
    "    y2 = (-w[1]*x2-w[0])/w[2]\n",
    "    ax.plot([x1, x2], [y1, y2])\n",
    "    fig.canvas.draw()\n",
    "    plt.pause(0.2)\n",
    "    \n",
    "\n",
    "ax.plot(class1[:, 0], class1[:,1], 'o')\n",
    "ax.plot(class2[:, 0], class2[:,1], 'o')\n",
    "plt.xlim(np.min(dataset[:,0]-0.2), np.max(dataset[:,0])+0.2)\n",
    "plt.ylim(np.min(dataset[:,1])-0.2, np.max(dataset[:,1])+0.2)\n",
    "for learner in learners:\n",
    "    drawLine(learner,ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predictClass(learners, dataset):\n",
    "    prediction = np.zeros(dataset.shape[0])\n",
    "    i=0\n",
    "    for row in dataset:\n",
    "        c1 = 0 # 1\n",
    "        c2 = 0 # -1\n",
    "        x = np.array([1, row[0], row[1]])\n",
    "        for learner in learners:\n",
    "            w = learner\n",
    "            y = calculateFunction(w, x)\n",
    "            if(y>0):\n",
    "                c1 +=1\n",
    "            else:\n",
    "                c2 += 1\n",
    "        if c1 > c2:\n",
    "            prediction[i] =1\n",
    "        else:\n",
    "            prediction[i] = -1\n",
    "        i +=1\n",
    "    return prediction    \n",
    "\n",
    "prediction = predictClass(learners, dataset)\n",
    "predDat = np.ones((dataset.shape[0], dataset.shape[1]+1))\n",
    "predDat[:,:3] = dataset\n",
    "predDat[:,3] = prediction\n",
    "\n",
    "class1 = predDat[predDat[:,2] == -1][:,:3]\n",
    "missClass1 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "missClass1 = missClass1[missClass1[:,2]==-1]\n",
    "\n",
    "class2 = predDat[predDat[:,2] == 1][:,:3]\n",
    "missClass2 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "missClass2 = missClass2[missClass2[:,2]==1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.xlim(np.min(dataset[:,0]-0.2), np.max(dataset[:,0])+0.2)\n",
    "plt.ylim(np.min(dataset[:,1])-0.2, np.max(dataset[:,1])+0.2)\n",
    "plt.plot(class1[:,0], class1[:,1], \"o\")\n",
    "plt.plot(class2[:,0], class2[:,1], \"o\")\n",
    "plt.plot(missClass1[:,0], missClass1[:,1], \"o\", color = \"green\")\n",
    "plt.plot(missClass2[:,0], missClass2[:,1], \"o\", color = \"red\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total points: 600. Misclassified points: 344.\n",
      "Missclassification rate: 0.5733333333333334\n"
     ]
    }
   ],
   "source": [
    "datSize = dataset.shape[0]\n",
    "miss = missClass1.shape[0]+missClass2.shape[0]\n",
    "print(\"Total points: {}. Misclassified points: {}.\\nMissclassification rate: {}\".format(datSize, miss, miss/datSize))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "learnersNumber = len(learners)\n",
    "x = np.arange(1, learnersNumber+1)\n",
    "error = np.zeros(learnersNumber)\n",
    "for i in x:\n",
    "    prediction = predictClass(learners[:i], dataset)\n",
    "    \n",
    "    predDat = np.ones((dataset.shape[0], dataset.shape[1]+1))\n",
    "    predDat[:,:3] = dataset\n",
    "    predDat[:,3] = prediction\n",
    "\n",
    "    class1 = predDat[predDat[:,2] == -1][:,:3]\n",
    "    missClass1 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "    missClass1 = missClass1[missClass1[:,2]==-1]\n",
    "\n",
    "    class2 = predDat[predDat[:,2] == 1][:,:3]\n",
    "    missClass2 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "    missClass2 = missClass2[missClass2[:,2]==1]\n",
    "    datSize = dataset.shape[0]\n",
    "    miss = missClass1.shape[0]+missClass2.shape[0]\n",
    "    error[i-1] = miss/datSize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.plot(x, error)\n",
    "plt.xlabel('Number of weak learners', fontsize=16)\n",
    "plt.ylabel('Missclassification rate', fontsize=12)\n",
    "plt.grid(alpha=0.4, linestyle='--')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "test set. to have some idea about performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "Npoints = 500\n",
    "class1 = np.zeros((Npoints, 3))\n",
    "for row in class1:\n",
    "    radius = rand.random() - 0.5\n",
    "    theta = rand.random()*2*math.pi\n",
    "    x = radius*math.cos(theta)\n",
    "    y = radius*math.sin(theta)\n",
    "    row[0] =x\n",
    "    row[1] = y\n",
    "\n",
    "class1[:,2] = np.ones(Npoints)*-1\n",
    "\n",
    "class2 = np.zeros((Npoints, 3))\n",
    "\n",
    "for row in class2:\n",
    "    theta = rand.random()*2*math.pi\n",
    "    radius = rand.uniform(0.6, 1)\n",
    "    x = radius*math.cos(theta)\n",
    "    y = radius*math.sin(theta)\n",
    "    row[0] = x\n",
    "    row[1] = y\n",
    "    \n",
    "class2[:, 2] = np.ones(Npoints) \n",
    "testSet= np.append(class1, class2).reshape(Npoints*2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "prediction = predictClass(learners, testSet)\n",
    "predDat = np.ones((testSet.shape[0], testSet.shape[1]+1))\n",
    "predDat[:,:3] = testSet\n",
    "predDat[:,3] = prediction\n",
    "\n",
    "class1 = predDat[predDat[:,2] == -1][:,:3]\n",
    "missClass1 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "missClass1 = missClass1[missClass1[:,2]==-1]\n",
    "\n",
    "class2 = predDat[predDat[:,2] == 1][:,:3]\n",
    "missClass2 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "missClass2 = missClass2[missClass2[:,2]==1]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "plt.xlim(np.min(testSet[:,0]-0.2), np.max(testSet[:,0])+0.2)\n",
    "plt.ylim(np.min(testSet[:,1])-0.2, np.max(dataset[:,1])+0.2)\n",
    "plt.plot(class1[:,0], class1[:,1], \"o\")\n",
    "plt.plot(class2[:,0], class2[:,1], \"o\")\n",
    "plt.plot(missClass1[:,0], missClass1[:,1], \"o\", color = \"green\")\n",
    "plt.plot(missClass2[:,0], missClass2[:,1], \"o\", color = \"red\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TEST SET\n",
      "Total points: 1000. Misclassified points: 608.\n",
      "Missclassification rate: 0.608\n"
     ]
    }
   ],
   "source": [
    "datSize = testSet.shape[0]\n",
    "miss = missClass1.shape[0]+missClass2.shape[0]\n",
    "print(\"TEST SET\\nTotal points: {}. Misclassified points: {}.\\nMissclassification rate: {}\".format(datSize, miss, miss/datSize))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learnersNumber = len(learners)\n",
    "x = np.arange(1, learnersNumber+1)\n",
    "error = np.zeros(learnersNumber)\n",
    "for i in x:\n",
    "    prediction = predictClass(learners[:i], testSet)\n",
    "    \n",
    "    predDat = np.ones((testSet.shape[0], testSet.shape[1]+1))\n",
    "    predDat[:,:3] = testSet\n",
    "    predDat[:,3] = prediction\n",
    "\n",
    "    class1 = predDat[predDat[:,2] == -1][:,:3]\n",
    "    missClass1 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "    missClass1 = missClass1[missClass1[:,2]==-1]\n",
    "\n",
    "    class2 = predDat[predDat[:,2] == 1][:,:3]\n",
    "    missClass2 = predDat[predDat[:,2] != predDat[:,3]]\n",
    "    missClass2 = missClass2[missClass2[:,2]==1]\n",
    "    datSize = testSet.shape[0]\n",
    "    miss = missClass1.shape[0]+missClass2.shape[0]\n",
    "    error[i-1] = miss/datSize\n",
    "fig, ax = plt.subplots()\n",
    "plt.plot(x, error)\n",
    "plt.xlabel('Number of weak learners', fontsize=16)\n",
    "plt.ylabel('Missclassification rate', fontsize=12)\n",
    "plt.grid(alpha=0.4, linestyle='--')\n",
    "plt.show()    "
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}