decodingCallTypesNaiveBayesPart3Julie.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "### decodingCallTypes 3 uses the information from part2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dependencies \n",
    "import os\n",
    "import glob\n",
    "import re\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import pickle as pk\n",
    "import multiprocessing as mp\n",
    "from scipy.stats import t\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from scipy.special import comb\n",
    "from scipy.stats import norm\n",
    "\n",
    "from decoders import naiveBayes\n",
    "\n",
    "import config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some paths\n",
    "rootPath = '/Users/frederictheunissen/Google Drive/My Drive/julie/'\n",
    "pklPath = 'pkl/'\n",
    "\n",
    "\n",
    "# The 6 birds from Julie data set\n",
    "birds = ['BlaBro09xxF', 'GreBlu9508M', 'WhiBlu5396M', 'LblBlu2028M', 'WhiWhi4522M', 'YelBlu6903F']\n",
    "\n",
    "# Color code for call type\n",
    "callColor = {'Be': (0/255.0, 230/255.0, 255/255.0), 'LT': (0/255.0, 95/255.0, 255/255.0), 'Tu': (255/255.0, 200/255.0, 65/255.0), 'Th': (255/255.0, 150/255.0, 40/255.0), \n",
    "             'Di': (255/255.0, 105/255.0, 15/255.0), 'Ag': (255/255.0, 0/255.0, 0/255.0), 'Wh': (255/255.0, 180/255.0, 255/255.0), 'Ne': (255/255.0, 100/255.0, 255/255.0),\n",
    "             'Te': (140/255.0, 100/255.0, 185/255.0), 'DC': (100/255.0, 50/255.0, 200/255.0), 'So': (255/255.0, 255/255.0, 255/255.0)}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/frederictheunissen/opt/anaconda3/lib/python3.8/site-packages/sklearn/base.py:324: UserWarning: Trying to unpickle estimator PCA from version 0.24.2 when using version 1.0.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
      "https://scikit-learn.org/stable/modules/model_persistence.html#security-maintainability-limitations\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# Load the data base\n",
    "outPath = rootPath+'JulieDataBase.pkl'\n",
    "fileIn = open(outPath,\"rb\")\n",
    "dfDataBase = pk.load(fileIn)\n",
    "pcKDE = pk.load(fileIn)\n",
    "fileIn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfDataBaseNW = dfDataBase[dfDataBase['call'] != 'Wh']\n",
    "# Number of Calls\n",
    "callNames = np.unique(dfDataBaseNW['call'])\n",
    "ncalls = callNames.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read unitList and argList2 and Confusion matrices data base\n",
    "inPath = rootPath+ pklPath + 'JulieDataBaseGoodUnitList.pkl' \n",
    "fileIn = open(inPath,\"rb\")\n",
    "argList2 = pk.load(fileIn)\n",
    "unitList = list(pk.load(fileIn))\n",
    "\n",
    "fileIn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read unitList and argList2 and Confusion matrices data base\n",
    "inPath = rootPath+ pklPath + 'JulieDataBaseGoodUnitList10.pkl' \n",
    "fileIn = open(inPath,\"rb\")\n",
    "argList10 = pk.load(fileIn)\n",
    "unitList10 = list(pk.load(fileIn))\n",
    "\n",
    "fileIn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "408\n",
      "375\n"
     ]
    }
   ],
   "source": [
    "print(len(unitList))\n",
    "print(len(unitList10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "siteList = pd.read_csv(rootPath+'h5_listFiles_CallProtocol.txt', sep='\\s+', header=None, names = ['CellNumber', 'Path'])\n",
    "\n",
    "birdL = []\n",
    "siteL = []\n",
    "\n",
    "for path in siteList['Path']:\n",
    "    pathSplit = path.split(\"/\")\n",
    "    bird = pathSplit[5]\n",
    "    site = (pathSplit[6].split('.')[0])[0:-3]\n",
    "    birdL.append(bird)\n",
    "    siteL.append(site)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BlaBro09xxF : 21\n",
      "GreBlu9508M : 171\n",
      "WhiWhi4522M : 83\n",
      "YelBlu6903F : 100\n"
     ]
    }
   ],
   "source": [
    "# Printing the name of the most discriminating units\n",
    "birdName = []\n",
    "for unit in unitList10:\n",
    "    ind = siteL.index(unit[0:-7])\n",
    "    birdName.append(birdL[ind])\n",
    "    \n",
    "birdUnique = np.unique(birdName)\n",
    "for bird in birdUnique:\n",
    "    print(bird, \":\", len([x for x in birdName if x == bird]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generates the common stimulus set\n",
    "def commonStim(siteUnit, unitList):\n",
    "      \n",
    "    for i, unit in enumerate(unitList):\n",
    "        tempStims = np.unique(dfDataBaseNW['stim'][siteUnit==unit].values)\n",
    "        if i == 0 :\n",
    "            stimSet = set(tempStims)\n",
    "        stimSet = stimSet.intersection(tempStims)\n",
    "                               \n",
    "    return stimSet\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 ...\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/zn/qkxxn59x2712k0l7j64f7ry40000gn/T/ipykernel_39140/3826931506.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     55\u001b[0m             \u001b[0munitListTest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnewUnit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 57\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0munitChoice\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mnumUnits\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0munitChoice\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0margList\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     58\u001b[0m         \u001b[0margList\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0munitChoice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m         \u001b[0mi\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# For 1 and 2 - see part 2\n",
    "numUnits = 15\n",
    "\n",
    "#nGood = len(unitList)\n",
    "nGood = len(unitList10)\n",
    "\n",
    "maxTest = 4000  # This is 10000 in version 1 and 1800 for version 2 (with more permutations)\n",
    "siteUnit = (dfDataBaseNW['site']+'_'+dfDataBaseNW['unit'])\n",
    "\n",
    "\n",
    "ntests = int(comb(nGood,numUnits))\n",
    "if ntests > maxTest:\n",
    "    ntests = maxTest\n",
    "    \n",
    "#nGoodPairs = len(argList2)\n",
    "nGoodPairs = len(argList10)\n",
    "\n",
    "# Generate the list of arguments to run naiveBayes in parallel\n",
    "i = 0\n",
    "argList = []\n",
    "while i <ntests:\n",
    "    # Choose two at first\n",
    "    #unitChoice = argList2[np.random.randint(nGoodPairs)]\n",
    "    \n",
    "    # Choose 10 at first\n",
    "    unitChoice = argList10[np.random.randint(nGoodPairs)]\n",
    "    \n",
    "    # choose additional ones, one by one:\n",
    "    unitListTest = unitList10.copy()\n",
    "    while (len(unitChoice) < numUnits) & (len(unitListTest) > 0) :\n",
    "        newUnit = np.random.choice(unitListTest, 1, replace=False)\n",
    "        if newUnit in unitChoice:\n",
    "            unitListTest.remove(newUnit)\n",
    "            continue\n",
    "        testCombo = True\n",
    "        for testUnit in unitChoice:\n",
    "            testList = [testUnit, newUnit]\n",
    "            testList2 = [newUnit, testUnit]\n",
    "            if (testList in argList2) | (testList2 in argList2) :\n",
    "                continue\n",
    "            else:\n",
    "                testCombo = False\n",
    "                break\n",
    "        if testCombo == False:\n",
    "            unitListTest.remove(newUnit)\n",
    "            break\n",
    "        unitChoiceTemp = unitChoice.copy()\n",
    "        unitChoiceTemp.append(newUnit[0])\n",
    "        \n",
    "        stimSet = commonStim(siteUnit, unitChoiceTemp)\n",
    "        if len(stimSet) > 100 :\n",
    "            unitChoice.append(newUnit[0])\n",
    "\n",
    "        else:\n",
    "            unitListTest.remove(newUnit)\n",
    "    \n",
    "    if (len(unitChoice) == numUnits) & (unitChoice not in argList):\n",
    "        argList.append(unitChoice)\n",
    "        i += 1\n",
    "        if (i%1000 == 0 ):\n",
    "            print(i, '...')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1358"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unitList20 = np.unique([unit for sublist in argList for unit in sublist])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save unitList and argList and Confusion matrices data base\n",
    "outPath = rootPath+ pklPath + 'JulieDataBaseGoodUnitList20V2.pkl' \n",
    "fileOut = open(outPath,\"wb\")\n",
    "pk.dump(argList, fileOut)\n",
    "pk.dump(unitList20, fileOut)\n",
    "\n",
    "fileOut.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read unitList from previous run\n",
    "inPath = rootPath+ pklPath + 'JulieDataBaseGoodUnitList20.pkl' \n",
    "fileIn = open(inPath,\"rb\")\n",
    "argList = pk.load(fileIn)\n",
    "unitList20 = pk.load(fileIn)\n",
    "numUnits = 20\n",
    "\n",
    "fileIn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unit List has 364 units\n",
      "arglist has 1358 combinations\n"
     ]
    }
   ],
   "source": [
    "print('Unit List has', len(unitList20), 'units')\n",
    "print('arglist has', len(argList), 'combinations')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "callNames = np.unique(dfDataBaseNW['call'])\n",
    "ncalls = callNames.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "numUnits = 15\n",
    "newArgList = []\n",
    "for sublist in argList:\n",
    "    newArgList.append(sublist[0:numUnits])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "argList = newArgList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done with chunk 0/16\n",
      "Done with chunk 1/16\n",
      "Done with chunk 2/16\n",
      "Done with chunk 3/16\n",
      "Done with chunk 4/16\n",
      "Done with chunk 5/16\n",
      "Done with chunk 6/16\n",
      "Done with chunk 7/16\n",
      "Done with chunk 8/16\n",
      "Done with chunk 9/16\n",
      "Done with chunk 10/16\n",
      "Done with chunk 11/16\n",
      "Done with chunk 12/16\n",
      "Done with chunk 13/16\n",
      "Done with chunk 14/16\n",
      "Done with chunk 15/16\n"
     ]
    }
   ],
   "source": [
    "code = 'PC'\n",
    "\n",
    "# Run Naive Bayes in chunks of 100 with a pool of 10 workers\n",
    "chunckSize = 90    # A chunk size of 100 or 90 is used for memory since it has to keep the results of all\n",
    "poolSize = 30\n",
    "\n",
    "ntests = len(argList)\n",
    "\n",
    "# Allocate memory for results\n",
    "pcc = np.zeros((ntests,))\n",
    "confMatTot = np.zeros((ncalls, ncalls))\n",
    "confMatCount = 0\n",
    "confMatFits = 0\n",
    "\n",
    "# Calculate the number of chunks\n",
    "nchunks = ntests//chunckSize\n",
    "if nchunks % chunckSize:\n",
    "    nchunks += 1\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    for ichunk in range(nchunks):\n",
    "        istart = ichunk*chunckSize\n",
    "        iend = (ichunk+1)*chunckSize\n",
    "        if iend > ntests:\n",
    "            iend = ntests         \n",
    "        \n",
    "        with mp.Pool(poolSize) as p:\n",
    "            results = p.map(naiveBayes, argList[istart:iend])\n",
    "        \n",
    "        # I don't think I need these??\n",
    "        # p.close()\n",
    "        # p.join()\n",
    "        \n",
    "        for i, res in enumerate(results):\n",
    "            pcc[istart + i] = res[0]\n",
    "            confMat = res[1]\n",
    "            testsPerClass = res[2]\n",
    "            # fitsPerClass = res[3]\n",
    "            if (confMat.shape == (ncalls,ncalls) ) :\n",
    "                confMatTot = np.add(confMatTot, confMat)\n",
    "                confMatCount += testsPerClass\n",
    "                # confMatFits += fitsPerClass\n",
    "                \n",
    "        print('Done with chunk %d/%d' % (ichunk, nchunks))\n",
    "\n",
    "# Calculate the average confusion matrix. \n",
    "for i in range(ncalls):\n",
    "    if confMatCount[i] > 0:\n",
    "        confMatTot[i,:] = confMatTot[i,:]/confMatCount[i]\n",
    "        \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save the PC and Confusion matrices data base\n",
    "outPath = rootPath+ pklPath + 'JulieDataBase%dGoodUnitPC.pkl' % numUnits\n",
    "fileOut = open(outPath,\"wb\")\n",
    "pk.dump(argList, fileOut)\n",
    "pk.dump(confMatTot, fileOut)\n",
    "pk.dump(pcc, fileOut)\n",
    "pk.dump(confMatCount, fileOut)\n",
    "# pk.dump(confMatFits, fileOut)\n",
    "fileOut.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14199., 16110., 21975.,  9852., 10662., 19020., 36852., 24444.,\n",
       "        9700.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confMatCount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([52.64084828, 59.26990611, 57.68208184, ..., 58.65682972,\n",
       "       47.60428432, 45.47543342])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pcc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x1200 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(4,4), dpi=300)\n",
    "ax = fig.subplots()\n",
    "\n",
    "ax.hist(pcc, bins = 30, range = (0,70))\n",
    "ax.set_xlabel('PCC')\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_title('%d Unit Good PC' % numUnits)\n",
    "\n",
    "plt.savefig('/Users/frederictheunissen/Desktop/pcchist%dUnitGoodPCJulieV2.eps' % numUnits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABGUAAAQCCAYAAAAFG0W8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAC4jAAAuIwF4pT92AADcRUlEQVR4nOzdd5hsVZWw8XeRMxcUJAcBkYzKKIIJxaygqChGUBFFZ3QMn1mMY3bGhFlBHVFBVMyKCg4iBgSRoJIREMk5317fH/u0t/p0dXdVdVWf093vj6ce6uw6Z+/V3dV1u1btvXZkJpIkSZIkSZpbyzUdgCRJkiRJ0mJkUkaSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpASZlJEmSJEmSGmBSRpIkSZIkqQEmZSRJkiRJkhpgUkaSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpASZlJEmSJEmSGmBSRpIkSZIkqQEmZSRJkiRJkhpgUkaSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpASZlJEmSJEmSGmBSRpIkSZIkqQEmZSRJkiRJkhpgUkaSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpASZlJEmSJEmSGmBSRpIkSZIkqQEmZSRJkiRJkhpgUkaSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpASZlJEmSJEmSGrBC0wFIkiRJkiQNIiJWBPYENgM2BG4GLgdOy8yLGgytJ5GZTccgSZIkSZLmqYh4O3DYLLo4MjMP7HPM9YB3AM8E1p3itJOBj2Tmt2YR20i5fEmSJEmSJM0bEfF44EzgZUydkAHYAzgmIr4aEavPSXB9cvmSJEmSJEmaFyLiEcB3gJU6mhP4I3ABsAS4H3DPjsefA6wVEU/JzLG5iLNXJmUkSZIkSdIwHQCc0sf5N/dyUkRsAhzLxITMr4GDM/OcjvNWBg4BPgSsWDU/GXg38KY+4ho5kzKSJEmSJGmYrhhRkd13AOt0HJ8M7J2Zt3eelJl3AB+LiEuAb3c89OqI+ExmXjyC2AZiTRlJkiRJktRqEbEN8IKOpjuBA+sJmU6Z+R3gyI6mlZldQeKhMykjSZIkSZLa7tnA8h3Hx2bmuT1c9/7a8f4RscrwwpodkzKSJEmSJKntnlo7/lIvF1W1Zn7b0bQ68JhhBTVbJmUkSZIkSVJrRcQGwC4dTXdTCvz26oTa8eNnG9OwmJSRJEmSJElttmPt+IzMvKWP60+uHe8wy3iGxqSMJEmSJEkapkMi4viIuCwibo+ImyLioog4MSLeExEP7bO/7WvH5/V5/fkz9NcYt8SWJEmSJEnD9Kza8crAGsDmwMOAN0XEH4A3ZubxPfS3de34kj7jqW+BfY+IWCczr+uzn6EzKSNJkiRJWtSq3Xi2ajqOAa0LrAP8nbJNdD+uyswrhx9ST3YDfhoR7wXekpk5zblLasd9xZyZN0fE7UDnrktrAyZlJEmSJElq2FbAmU0H0YB3AG8fYn+XAT8EfgecA1wLjAH3AO4PPAl4bMf5AbyJUlrljdP0u0bt+LYBYruNiUmZNQfoY+hMykiSJEmSpNn4HSXZ8rNpZrycDHwiInYDvgZs0/HYGyLilMz87hTX1pMytw8Q422UGUVT9dkIC/1KkiRJkqSBZeYPM/OnMyxBGj/3D8DuwN9qD70vIpbvdch+YxzwmpFzpowkSZIkSR2O/dKGbL3lik2HMa3zLryL/Q76R2fTvkzeZWgmVw0vot5l5rURcQDwB8oSJoD7AnsB3Qr/3lw7XnWAYevX1PtshEkZSZIkSZI6bL3liuyw7cpNh9Gv8zPzrKaD6FVm/jEifsrEGjOPw6SMJEmSJEmL1xjJGGNNhzGtsXauxunXj5mYlNl5ivNuqB2v188gEbEGk5My1/fTx6hYU0aSJEmSJDXhotrxVMmWc2vHm/c5Tv38azOz8e2wwaSMJEmSJElqRn1r66mWJZ1TO966z3HuXTs+u8/rR8blS5IkSZIkdRjLMZZmy5cvtTy+Ht2zdnz1FOedWTveOSJWy8xbexxnzxn6a4wzZSRJkiRJUhMeVDu+vNtJmfkP4IyOphWAh/QxziNqxz/q49qRMikjSZIkSZLmVESsAuxXaz5hmku+XTs+qMdx7svE5M8twE97uXYumJSRJEmSJElz7fXAxh3HS4EfTHP+/1bnjNsvIrbpcZxO38zM23sLcfRMykiSJEmS1KFsid3+WxtExPMi4l59XnMwcFit+YjMvHiqazLzXODIjqaVgCOqGTdTjbMvcGBH053AO/qJddRMykiSJEmSpEG9CLgwIo6MiCdGxOpTnRgRu0XEscBngeh46DLgLT2MdRjQuZX1HsDx1RKlznFWjoh/B46uXf/h6RI/TXD3JUmSJEmSNBurAs+vbmMRcS5wEXADZcnRPYBdgG4zaq4FHpeZV8w0SGZeGhH7AT+hzJSBsrPS2RFxKnABsDZwf2C92uXfB97a35c1eiZlJEmSJEnqMFb912Ytjm85YNvqNpOfAwdm5qW9dp6ZJ0TEU4EjWJZ4CWC36tbNUcDBmbl0iscb4/IlSZIkSZI0qI8CXwN6XRZ0C2Unpb0zc+9+EjLjMvOHwI7Ap5m4nKnuFODpmfnszLyl33HmgjNlJEmSJEnSQDLz21TbVUfEEmAHYFPKUqXVKJNBrqckT84BzhjGjJXMvBJ4WUS8krKEaXNgA0rS5zLgtMy8cLbjjJpJGUmSJEmSNGuZeT3w6zke807gl3M55jCZlJEkSZIkqcNYwtJsx5bTUxlrd3jqkTVlJGkeiogDIyJrty2ajksCiIgTas/NE5qOSZIkqY2cKSNJmhciYiXKGuUtgI2A1SlbId5E2W7xBuBC4OxqGqvUOhGxMXBfyrr3dShbiN7GsrX25wFntXF3iLaIiC2B+wCbUbY9XYVSP+C66vYX4G+Zo/2IOyKiimNrSu2ENYGVKa9J11G2eD0zMy8aZRzzXUSsB+wK3BtYQnl/cgvwT+B8yu9Do8U5I2IV4KHAVsC6lN/Xi4AThxVbROwL3K+j6ZuZefYw+pbUbiZlpAZFxLos27ptN+ABlD8yJ8jMGNJ4JwAPH0ZfwGcy86VD6mtGETHpj+thfF+q2SX1AmAXZ+YWs+1bsxcRWwHPBJ5E+f1YqYfL7oqIsynrmb9F+aPZN7iLQLfXiWncycRk3h+A3wA/zsy7hhjTcsBjgadX/9+4h8tujYg/Aj8A/jcz/z6seKYzxevhdG5n2ffwb8CpwP8Bv8zMoe3TGhErAvtSvoePZNn2p9O5ISL+AHwX+HpmXjWkWFav4tiP8u/p2j1cczXwW8rr0bcy88ZhxNKLiLiIkgAchjdm5vuG0VFVCPSFwPOAXShb2U5laUScSdk29zuZ+X/DiKEX1d9pbwUOoSRQ6+6MiC8Dh2Xm5bMYZ3PKzjWrVU1/Af5r0P40HGMkY7R7fVDb41NvTMpIcygidgSeSHlzuRuwZbMRabGJiLcDh3W2DSvpN0wRsSvwLsrvS7/xrUj5I38X4FDgqoj4GvCB2fzRrAVnJcqb+/UoMx0eXbVfGRGfA/4rM28dtPNqFsULgDdX/fdjNeAh1e2/IuKXwDsz88RB4xmRVarbvSgzRp5UtV8UEZ8APpqZdw/aeZWMeQXwWsrsuH6sDTyqun0kIn4AvD0zTx8wltWB11fxrNPn5fekvJY9EfhkRBwDvCMzzx8klvms+r34d+Dt9P59XJ5lr+n70v/v00AiYlvgx5TZmVNZCXgxsG9EPDkzfzvgcJ9gWUIG4FBnfEqLhzVlpLn1YuB9wDMwISNNEhGrVm/mTqW8wRtGwmg94JXA+RHxsYhYYwh9auFan5JIOSMi/m2QDqoZXicDX2L2byCDMjvkhIj4wTypHbUF8CHglIjYZpAOIuIBwJ+Bj9B/QqZuBcqb+T9GxFci4h59xvJoykygt9J/QqZuVcrskHOq16NVZtnfvBERawM/AT7K7L+PI1XNkDmeiQmZmyizWd4HHElZnjZuPeAn1dK6fsd6CssSmgBfzcx5u4uMpP45U0Za3G6h1C8YxJxMp9fiERGbAD8EdprmtAuBE6r/XwtcAySllsOmwHbAg4FNuly7CuUT2s8CZw4rbrXaXcBUNRlWpsxguOcUj28F/DQiHp6ZZ/Q6YPUG/hhgrSlOuYOytO53wFXV7XbKc3hzYEfgYVPE9QTgEcARvcYzBNP9O7EaJc6p3mA/ADg+IvbMzEt7HTAingd8nqmXK94MnAiczrLv4VLK93xLyoyKhzD5ZxDAc4EvUF5HeonlDZRlJFMliK+jLKs5uyOWoNRG2ZIyK/bBTF76siLl9egjlNokc+U64JIBr/3noINWSY4T6P76fgslAfI74EpKvZa1gA2AnSnfv0lLu0fso0z8d+R3wL6ZecV4Q7UE6xvAY6qmtSm/mz0vE69mYH2so+l64DWDBCxp/jIpI7XDnZQ3iX8A9qf8MTcX/pCZj5ijsTREmXkEc/vGbKQiYjNKLYpuf3jfSPmj9XOZ2dObiYjYmVKL5sWUmQ9anC7PzF2nO6FKBj6V8kaoXntjCXBcRGybmXfMNFhEPBE4lu7JhHMoSza+P9OyqKoOzcOBgykzK5v8e23GfyeqmUHPAl7F5GTSZsDRlDfWM4qIlwCfpnsS5BTgHcAvZlraUS19eizwMuDxU/Q3Uyzvpsya6uYnwLuB38xUsyoiVgOeTEnC7NlvHEN2XGYeOJcDVkXav8fkhMyNwDuBT2bm7TP0sRPwbErCcqSq+i4HdDTdAOyTmROSUpl5fUQ8jZKQ27RqflhE7JGZJ/c43Ns7roVSt+fKwSLXsI2RLG15zRZryiwMLl+S5t7dwBnAFyn1Lh4IrJmZD8jMQyj/+EuLRkSsBfyI7gmZzwNbZOZbe03IAGTmGZn5Zsofu/9B+fRVmiQzL83Mj1M+kf9+l1M2pzyHplXVQfoGkxMydwEvB3bKzG/2UqcmM8cy85eZ+WzK7K/vzXRNkzLz/Mx8D+VN9++6nLJ7RDxjpn4i4nHA4UxOoNwE7J+ZD87MH/dSayMz78rM72fmEymzVU6a8QuZGMuL6Z6Q+QfwyMx8XGae1EsR8cy8NTO/kZkPodS4WWwz9d4L7FFrOw/YMTM/PFNCBiAz/5yZb6TMgBq1/Sh1bMZ9up6Q6YjrZuCDteYZn+vwr0TTqzqafkuZySlpkTEpI82t9wNrZeYumfmizPxUZv7eYm5a5D4JbF9rGwNel5kHZ+Z1g3acmXdWb7jvS6nvIXVV7YizP93fMB8y3bVVXZCjKNu0d7oZeGJmHj7oDmCZeV5m7kMpGnzzIH3MlWppx5OAK7o8PNP3cH3gy0x8M0zV18Mz8+hZxPVHygyL11GSZNOKiO2Aj3d56K/AHrOp95GZv6As6/rQoH3MJxFxfyYmHgAupfxM+14GPeptziv12UzdkrWdjqsdz5g4qgoef4pls+CWAi8d5q5lkuYPkzLSHMrMf2TmbU3HIbVFVX/juV0eeldmDu1NS2Zel5kvpEx/H3hHHS1s1evz27o8tFW1RGcqb6Ik/ur2z8yfDSm2L1PeLPZcm6UJ1dbTH+jy0EOqZTxT+RCTt7q+E3hcZp42hLiyek15HDPPSP00pQZVp2spM2QuGkIsd2bm6yivRwv9Q5kPMfn9xqEt3wmvPmvznOlOzsyLKXVxprq+mxcyMfnz8UF3BtPojG+J3fab5j9rykjSCFW1Ie5Pmda/PqUo7dXABcDJzpLifV3aTqHUahi6zDxqtn1Un3DuBGxDeRO5LuVN3pWUAsR/HNWnndWb2gdRdqNZj/LG8apq7NP6Kaba57j3AHYHNq7GvY1SLPTUzLxwFGM26IeUr69emPX+wKQtjKsZHq/u0s+nMvNHwwysn4LDDTuWUsC208rADsDv6ydHxI7Ac7r089bM/NMwA6tmqkwpIp5A97olQ08kDOP1qM0iYjdgr1rzjzOz1cvxmFzXr5dl5dezbKbctDtLRcQ9KTOnx11G92SwpEXCpIwkDSAiHgHUp7DvlZknVI+vRSkceghwrym6uSUijgbe1u807og4kMnLcbbs9iluRJzANLtBREQvH7McVBUXHpqIeBjljW7df2Tm3cMcaxgi4j7A/6PsgLPhNKdeExE/AT40jE/4q7GfQSn6+jDKm9upzjuLsvPPR6rlOLMd9+HAG4C9meJvhoj4M/Bh4MtztLRgpDLzjoi4gJJA6FSfxTHuYCYvW7qB8lxZlDLz4oi4hcnfl6m+h69k8myKc2lmic9/dmn7RWZ+Y84jmf9e3KXt03MeRf/qRb1XotQDnE7n6/JMNXI+AHRuy/6qzLypx9gkLUAuX5KkIauSDWdTPvmaKiED5Q3LgcBfI2KfOQitbQ7s0vaHzJz0SXqTImK1iDgcOAt4EdMnZKD8sf1s4NSI+EpETPup6Qxj3z8ifgd8E3g00yRkKjsAhwHnR8S0NTxmGHfViPg8JfH4OKb/EGcnyk5gv6w+AV4Iun0yvmSKcw/q0vblqgDoYtbT97Cqx/OsLud+eq7ra0TEppRCvHWfnMs4FoJqlujTas1XAT9oIJx+XV073mi6k6vncOfrfP36znMfwsR/+36Umcf0G6CkhcWkjCQNUUQ8CTiessyjV6sC36p2HlkUqj/Yn9TloVbtPFElGX5B2Va339mlQamXc1K15Xe/Yz8e+BXwb/1eS9mW+NMR8dHqe93PuKtSdvt5Ef1tI/xw4FezSUK1yNpd2q6vN0TE9kC3WjOfGXZA81BP30PgkcAatbY7KYm+ufZkJj/nr2ByIVfNbFcmb4/+f22cBdlFfcncA2c4fzcmFqg+vdtJ1Tbtndu93w68YoD4NEfGMlna8tvY/J+gKly+JC1260fE2yk7BWxN+QNqeUpBw2soMwP+Dzg+M//WVJDzyK6UrT9XrI5vA35OeWN9BWX686bAY5j8aewKwOcjYofMHPa26Oex7BPqDZg8e6eXmg3XDjMgyoyObksZThjyOAOrkhO/BHbs8vDVwLcp29tfSZkdsx3lk+H6p6rbUxIzu2ZmT9/HiNiL8kaw27/Tf6oeu4jyHNuQkhB5LJNn0vwH5Xe6nz/8v0732QLXUL7mP7Hsa96Bsn3s+Oyh7Sg76Mxb1afe3RItV3Vpq9fLAPhnZp413Kjml4jYnMlLl6D37+Hpvf6uDFm3WH41TxIJvdoqIt5H2aJ6C8rr8Bjl9/sayu/3r4CfDbI7Uof6FtgAJ4/fqWpzPRZ4OqVe1eaU169rKa+vf6Z8wPGDalevufQLypK6cQcCX5vm/Ppsual25/pPJi6LfE9mXtB3dJIWHJMy0uK2HWWpQ91G1W0nqmnlEfEj4H2Z+au5C2/eeS/Lduz4CvD6zPxHl/M+UNXqOJZSJHbcxpQZGd2K3w4sM/+1rr9Kwh1We3zXYY7Xo261ZK6jJJDa4r+ZnJBZSinQ+K7MnFQ3ICL+k1L09V1MTJBsCnyeksCYVkSsS3n+1P+NvgQ4JDN/3OWyj0TEJpRPYZ9Ye+zlEfGzzPxuD2MfCNSX0iWlZszbuu0eFxGvotSdeRslIfkkSrJovno8k3feAehWH6jb87hVy+8a0u15fidlWWddt+/h74YbTs/aFMuoPITuWzavRnmd2pWy/frSqubZ+wfcFWinLm2nAUTEzsCR1Vh196puO1D+/rg9Ij5DSWB0S+qNwg8or7fjMxwfHRHPzsxJiZmIeCQTlyPdTHn9rp+3GROL+f6V7ruUSVqEXL4kqVePB06MiI9HxEpNB9NS42/k3pqZz58iIQNAZp5IefNbn3f6olEF1zL36dL2x7YUio2IPSlFmjuNUQoev7lbQgYgM5dm5gcpb0rvqj381Iio11jo5n1MXv52IbDnFAmZ8bEvpSy/+GqXhz9XzfyZUkSszeQdc6AUXn5dt4RMNe7dmfluSh2dpVXztGO1VTVL5h1dHrogM7slDLft0vaH4UY1v1RL/roVOT4pM2/p0t6K72H179qWbYilJZanJEX+EBFvrma29OPeXdoui4iXUhKXu/bYzyqUWSunV7s5jVxmLgVeX2s+IiLeExFbRcRKEbFZRLyBstSz8/3UuzLz+i7dfpyJs8cOdfdFSeNMykiCMqX8POAc4J8se2PVzSsoyZluU9MFx1ZvUGeUmb8Gjq41bx0R3ZZOLDSbdGm7cs6jmFq3HVj+JzMnfQLaTWb+EHhrl4deM9111Rva59WalwJP62W76yqpdRBl6n+n9br0W/d8Jm/l+pXM/MRM41ZjH8M8/uQ3ItagLN3q9gn/56a4bNMubXO91KI1qu3Bj6Msk6yb9D2MiOWnOLeJ7+HGdK+htBB/nmOUr+tvwF8ofwNMVVR5eeDdwLHVz6tX3Qqi7wkcTtnNqNNtwAWUHbemKpC9EaVmVbdZPkOXmV8HOl/7VgTeRPlb6Q7gYsrs2NU6zvkW8MF6X1Uh/84ZiF+daWt2tcPYPLlp/jMpIy1Op1Cm0e4JrJ2Z62fmNpm5fWZuQCnQ+Gjgi5Qp53W7A1/v8w+0xWCM/rfB7Tar4QFDiKXtuhWDHXYtnYFExMbAU2rNVzJx6nkvPkJ5k9HpwRHRbYnEuBczeenMZ/rZWruqf/HvXR6aqa7MS2vHtwOv63XcyruZZ29iI2KjiDiUUh9o3y6n/B346BSXd3seXz+k0OaNiLh3NWvgz8CDu5zye6DbltJrM7FA6rjrhxddz6YqUH39XAYxIkspdVJeRykcvmZmbpiZ22bmdpm5PqVG1JOAY+j+Pu8plNkevap/P5OSkOlMfP2IUsdnrczcKjPvA6xF+Rvja0yeSboq8M2I6JbIG7rM/HdKImamLa7vpmzf/sz6bM+IWI2J37frgdcOMUxJC4A1ZaTF5UhKTYq/TndSNcX8eOD4iHgncBST/9B+EvAqSq0JFb/IzPP7vOa3Xdq6TedfaLotb7l+kI4i4g/0n8jaMjMvmuKxRzL5jeKXp1h6MaXMvCsiPsfk2SOPBv44xWWP7tL2qX7GrcY+MSLOYmJRyZ0iYoNuRTOregfb15qPy8x/9jnurRHxVdrzpmOjiDh9isdWptR0Wn+a628E9p1q6Rbdn8etSC4O0W7TfA9XpRSIX3eKxwEuA54xxdLEqZa5NfE9bFMsw/RByu/ytEV7qyU3PwB+UNV8+QZw39ppL4uIn2fmt3oYt150PDraxoBXZOak17bqefJb4DkR8S1Kcqazrw0pCe9n9xDDrGXmeyPiK8DBlMLE96YUzr+RUmz9eODzUyxvBHg7y2rTALyx2+tqlbw5iLIEdbwQ/i2UpPDPgC9lZreaTJIWAJMy0iKSmV8a4JqLq6K036fsGtTpTRHx+RHsFjRfndjvBZl5ZUTcwsS15t22kl1o+q1PMJf27NJ2zIB9fZPJSZlu/Y8v5ahvvfqXzDxzwLGPZmJSBsqOKMd2OXf3Lm3dzuvFsbQnKbMisMuA114IPHuGWUrdnsetqIs0RKsz+PfwdOBZmXnxFI9P9TrQxPewTbEMTWZ+coBrzoiIB1J2X6z/7N8TEd+p6q5MZ7rX+Hd0S8h0iePYiHg5pUh6p/0j4m3TJEKGqlo6ehjdN0aYUkTsQPnwatzvgM92Oe+xwBeYXEtsPHG8C/CqiPgo8P8y0xUrc2QpydKWvwS0PT71xuVLkmaUmXdRtq2s17RYl8lbQS5m9aUqvaontRZDUqbbzIO2fN315UV309u24ZNUb0brtXKmWr60LbBGrW02RUa77QI01djdZhqdOuC4pzN9Xaq2u5JSK2KnzDxlhnO7PY+XDD2i+ecSSqHUB84wM3OqGUhLhh7RzNoUS+My8ybKrI36DMFtq/aZ1AudjzsP+K8+4vgCcFKteXlaXhS/Koz8aUpiGMpr4kvrCZWq+Pv3mJyQqVuBUpPsqAGKLktqOZMyknpS/YHWbVeSx891LC127YDX1f94XbHrWQvLdV3algzY118pSZOpbn0tO6Isx+h04VS7LfXonBn6n669fm0/uk11n2rs+hKeu4F+l+IBUC31uWSQa+fYXcA1lAKjx1N2vdoH2CQz39TjcrVuv/NLhhZh+91BKRJ7LmXpyzuBvSnLAz9QJfSncwPd65csGWaQPZrq9XvJXAbRJtWSp//p8lAv/+5P9fvzqaruVT+6FRvfq88+5tpBTNx6/OP1WXcRsSXwJSb+m38MsBtlOd3GwKuZ+L3cn7IblaQFxOVLkvrxTUp9i87XjodFxAoD/JG1EM30BkTLdKtvsN4gHWXmc6Z7PCJOAB7eR5f1ApXX9xlSXT0BtXJErJaZt84w7mzH7pb4mqr2x5La8U2z3J68LUsaL87MLUbY/6VMrBcBcK8RjteEEzPzEaPoODPvjogrKDvrdGrie3gZZalSfRbCvSiJ38Xqa8Cba22P6uG6a+i+LfZPB4jhZ0z+2TwgIlaZZcJ8JCLiHsD7O5ouo3uh+PcCa3Ycfy4zX9JxfDnw3xFxKvBzlv3t9e6IOGKKrbclzUPOlJHUs8y8EajXV1iF6QtlDsuk5RARUd+lZhDdijuaYBq9bku9ptuVaC6tWTvud6ZNXbfr62NM1TabsXsdt1v7KL7mhajbm/Xd5jyK+a0V38PMvJNSuLVuUf88q+KyV9Wau20FX/ePLm130n0G30wxXMvk2XcrMDd/ewziA0yclfiqarbxv1Q7SO3X0XQVZVbMJJn5K0rNmXGr49LxOTGWsLTltzFLyiwIJmUk9avbH1oDzXDo0/Vd2ur1NwbRrY9uMww0XN3qlawbEdvMeSST3VQ7Xr3rWb3rdn19jKnaZjN2r+N2ax/F17wQdXse14s1a3pt+h62KZY2qf+7v1JEzFQD7IIubdfNokjtNV3a7jFgXyMTEXsyMWHy48zsVij+UUxctvT1zLx5mq4/Vzt+3IAhSmohkzKS+tXtE/CpthIdpmHWIJmpD5Myo3cWcHWX9n6WGY1K/ee/ZJb91a+/o8vSpW7jznbsbtdOVTfj+trxmrMsJtmWos2jdkKXtntFRH17cU3thC5t94uIbsv5Ru2ELm0Pq3ZGW8wG+Xe/Wz2sO2YRQ7dlSsOYLTs0EbECZYn3+Gvn7cDLpzi9nuz71Qzd/5GJP4cH9R2gpNYyKSOpX91mxXR7cz1s3ca47xD63a7HsTRE1aelP+jy0Eu6tM21+lT9LSNi5Vn0V3+DPtXzqz4udH9+DjrudGPXd4haAdhqkEEjYlUm11lZkDLzLLoXRD5krmOZx37O5Df9KwEHzn0ofI/JW2BvSCkAvZh1+3e/28yVTt12jptNsnbJADHMtf8Eduo4fk9mdpsxBJPrKE27vXdV46uzr7Wr11qN0Ng8uWn+MykjqV/d3iR2ezM5bH/s0rbzEPrdsUvboFsBqz9f6tL2bxHRdA2H+nNtBWDXQTqKiM2YXPdgqufX34D69PXZfC/+rUvbVGN3a++2TXYvdqVsWbtYdHsevyAiFssSrlmpCrUe1eWhl0bEnP6dmpmXUJJEdYfOZRxtUj2P60nW63vYWetPTJ79t3ZETFVsfLoYlqN7HZu5+NujJxGxKXBYR9NfKbVlprKkdjzV0tJON9aOm5hNJmkETMpI6llE7EzZorHTxZk5Fzut/LpL2xNn02G1PKPb1p7dxlooJhUxbmpqfmaeCJze5aGPNbxc4OQubU8fsK9n9Ng/mbkU+F2t+b4RscOoxwZO6dL21AHH3W/mUxaUzzF5psfaTNx9RdP7GJNnqNyHKQqfjtj/dGnbOyKeNteBtMSjKDOXOv1ppouq17OfdHnowQPEsBOTi5FfnJltWmr8cSbW0jq0Kh49lfpSrhW7njVR/efQup2nJA3GpIykfryhS9uP5mjsE5k8S/PBETHQEovKI4FNam030H1WzkLR7dO4YRRMHtTru7Q9GHjrXAfS4edM3u3ref3OfKjqCxzc5aHptoTt9ibmpf2MW439UCbPAjsjM//Z7fxqhkB9V5R9I6Kv3U2q6fTP7eea+S4zrwT+u8tDh0bEY4Y5VkTsHBF7D7PPNsjMPwP/2+Whd0fETl3aBxYRj4yI+00Tyw+A/+vy0GciYsMhx3JARNSXsbRNt9foXv/d7/Yzfd4AMTy/S1u3GU2NiIgnAft2NH01M38xw2X1+l69vNZ2LiNLyt8rkhYAkzKSehIRTwae1eWhbrsKDF1mXgZ8u9YcwEcG6a+aifHBLg99ZoZPt+a7bp8s3nvOo6hk5k+Br3V56K0R8Zq5jgcgMy9n8nPtXkycmt6LVwHb1tp+nZn1beU7fZHJn36+tJql1pMqGfTxLg91a+v06drxKkw//b6bNwMb9HnNQvBfTN7aOYCjI+KRwxggIp5PmcVXTyQvFK9h8nKUlYEf9/P8n0oUrwN+zMy1TQ5h8u/hPYCfV8tUZhvLShHxIcprX332Q2tExMuBPWrNY0x+fZzKj5hcc+lpEbFLHzFsCry4y0Nz8rfHTCJiNSa+tl4PvLaHS+uFkHedYZwlwOYdTX+tZiNphMYIlrb8NsZsavKrLUzKSItAROwWEc8cdH1+RDyesua//sr/y8ycy0+rPtSlbZ+I6GtWRZWQ+RRQ/7T0Lso0+oXsz13anjDnUUx0KJPf0C4HfCgiPjebXViqJWqDFEPsNvPhNRHRLTHZbdzHAu/p8tCHp7suM68GvlxrXgH4Vi+f0ldf7+eB+pueK4GvznD5l5m8C9MLIqKnmToR8VS6f6q+4GXmbcABTF7GtBbwo4g4ZBavv1tHxPeAI2l2VttIVTOOXsDkWWobAb+KiIGXxUXEA4CTKEnGGZeJZOY5wH90eWg74DcRMfAucRHxKMpszJEmnSPiMREx8LbJEXEQ8NEuDx2ZmX/rpY8qafDOWvMKwNci4p49xLAaZbbNWrWHfp+ZczVLdyZvA7boOH7jVDMSa+rLpJ8yw/n7MvFvsIW8zFpadEzKSIvDJsDXgb9ExBsiYpteLoqIzSPicMouOfWlG7czx+v9M/MUJn+aD/DOiPhmRNxnpj6qP85/SvdlJW+oZuQsZGcyuVjgGyPiwKZ2cqhqEj0OuLTLwy8GLoyId1ZFc3sSEetExIGUr7e+9WgvMZ1MSdx1Wg74SkS8PSK6frodEctHxKuB7zD5E/BvZ2YvnzC/kcnfi62BX0+3dCUiNga+S3ljW/eSqqDqlKqfw392eejwiHhfRHTdfjYiVoiIN1BeY1aomm+bbqyFqJoB9UygPtNuJcrr1hkR8fRefs8iYrmIeERE/C/wF+BJQw+4hao32ocyub7M2pTE5K8j4rERMWNiJSJWjIgnRsT3gd8zecbHTLF8ju6J1Y2BEyLiBxGxRy/JtohYNSL2j4j/A44HBq0T1Y/tKQnBP0bEf1SvDzOKiO0j4huUWXv12l7X0P/S0q9Qlh/XY/u/iJhyW+co28r/Anho7aGl9DYTZeSqGDv/Dvod8NkeLz8JuLDjeK+pkn1Rdv97Y635yF7jlNR+UXZYkzRXIuKHTN4KsdP2TP4kb6aiek+ollxMNeZTmDzd+HzgNMrMiSspb9TvAtalTJF9CKW2xwpMthR4WmZ+d4a4hq764+Qkuu9Ks5SyDeeJwMWUNdtBmXa+FbAXk2cQjDs2M3su5BgRjwB+WWveKzNP6LWPjr4uYuK05CMz88AZrjmQybu+bJmZF/Uw3ifpvpvIUuDvlLoz9fo9b8vM42bqezaqpMuP6L6V87gLgBMof8xeS3mTkJQZBOtQioPuADyI7s9dqmu2y8xpd+6o3jz/ju47dF1J+Z06g7LN9DpV3PvRfXnJ34FdM7NeR2CqsfeiJA+7fQ1/pGzdexElOboh8DBKYqtb4uSTmfmKXsatxv4u3bcAvho4lvJ6NP417wA8jYmvaT+g/Dw632CcmJmP6DWGQUVE/Y+aizNzi1GPW4vhMZSlFfXCpONup7yG/Y6yXOfqqm1NyuvAjpSfZ7dtiAEOyswjhhjyv0TEFkx8owhz9LOrxfF8SgHlqZb23Ex5/T2d8v27ilLEfC1gS8pSkIcw9TKlnl+rI+KNlOTMVGsErqUkWs6uYhnfdn4JZWnoAyj/lq42xfU9vW73KyJexcQZf0lZMvMn4Kwqzhuq9nUpid+HUv5t7fa13go8MjN/O0AsG1N2eLtX7aEEfkWppfV3yr9BG1OKC+9N99e/V2dmt5mMcy4iTqT8rkKJ/d9mWJ5av/5Q4JMdTVcAj8vMP3WcsxolAdNZbP7XmfmQgQPXlKIU1j9z/Ph7P7sn22zbSw3m5pz717t48qOv7mzaMTPPaioeDWaqP1gljc72THwD3ouZ1l8PsiZ9q+rW764y1wMvbiIhA5CZd0TEoylTmuvLbpanvBmf8tO3KXwe6PlN6wLwLkryoF77Y3kmTsPu1Pc2pv3KzEsi4t8oS3wOofsbg3szeA2cOylr/9+dmdf3EM9tVT2Q7zN5ts36VYy9OIfyh3ZPCZlq7F9GxD7A0UyepXb/6taLj1Nq2/TjWZSvuV4L5Z7AS2a49i+UQp691pxYcDLzpxFxf8pysW6vRatQ3nAOUrD3aOBnswhvXsjML0fE2ZTvYb0uE5Sk35OrWz+WAl+g+65vU8Xy3oj4I2XmSLcPVNYF9u8zDiizyT4K/GOAawcRlL8/pkt6T+VS4DmDJGSg1ISrZvkdz8TETFCSt70sB0vgnS1KyBzIsoQMwCf6SchUPkX5t/hR1fEGwO8j4seUxNk6lAR559LVm+g+G1LSPObyJUm9SsobtZ0y81uNBlLeUD+JUr/imll09XfKp84HZ2Z9e8oFKzOvoLzhPrXpWOoy89bMfBnwb5RZM8OYzvkPSqLnvpn52l4SMh3xXEWZYfVpumwnPtPllEKee1a7G/V3cVnK8TDK7K9+XQO8LDP/IzPrs55mGvc2ypvdL/Y55knAw1q2TW0jMvM8yuyIFzK50Gm/lgI/BB6UmfsvgiWWAGTmH4CdKUtVZpu4uIOyvG7HzDykn9eAKpafUJJD72Fy3aV+3UxZ4nKfzHxjy//tuZtSa2rnzPzVbDrKzDMps4YGqUP3D8rs3LfPJoZhiYh1mVgE/XIG2DEwy3KF/Zi4vGtFyuvvGyiJ/86EzHXAYzNztq8pklrGpIy0OPwYeAxlh5AT6f2PygT+BvwP5Q3tkzOzW92POZfFB4DNKAUZf8Xk3TK6uZnySfOBwFajWgbQdlUhy3+jfEL5P5SlAJdSlrE1vqNDZp6amU+gvBF6G2Wpx109Xn4nZYnPp4HHA5tWyZj6soxeYxlPFO1ISVRcMcMl11IKYz8gM58zmyRFZv6RMkvnmZRPmWd6A3c2pbDmVpnZrf5Sr+PempkvAh5BWVowXULqbErtn4fPtCRsMaleo75EWVL3BOAIypu3XtxMea1+LbBJZj4xM383kkBbLDPvzMwPU2bw7Q98k2XLg2ZyHWUJ4MuADTPzgMz8yyxiuTkz30JZnngQZQlhvT7XVK4EjqPMIrtXlRga9b+lX6DMsvgI8BsmF6GeyhhlWfO7gS0y8wXDSrRm5mWZuTcl6fAzpn9dScpSq/+kvJ61afbd+5m4vPBVmXnTIB1l5o3Ao+m++9i4uykJ/l0y8zeDjCOp3awpIy1SVf2OLYBNKcsSVqMkam+k/DH7T+AP8+lT76r46v0pX9O6lKm/SXmTfC2lBsfp6TaS81JVT2hHyvN2Q8qynhUp07mvr26XAX8e5afP1Q5HOwPbUJYxLaH83lxFqcfxh35np/Qx9urA7pSvf33K0sWrKW/6TsvMv49o3HtQCqVuRHm9uJ0y0+xUP7XtT0RsQtnFZ3PKc2cVyvfzuur2N+DsUT2HFoKI2IqS7NqMUkdmFUrS4TrKa/3ZwHk54j9yqyK/96G8FmxKWVa1MuU16TrKjLU/Z+bFo4yjF1WsW1Ked5tS/n0cr3NzAyXeyymvXzfPUUxrUz4c2KaKZynle/ZP4JQ2JnmrWmOvY9kH29dlZrddqgbpeznK6/sOlNfZWyivs7/sd3aXBlOvKfPdn63H1i2vKXPeX+9i30dP+FWxpsw8ZFJGkiRJkrSomZRRU1y+JEmSJEmS1AB3X5IkSZIkqcNSgqVdN4Jsj7bHp944U0aSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpAdaUkSRJkiSpwxjBWLa7ZsuYNWUWBGfKSJIkSZIkNcCkjCRJkiRJUgNcviRJkiRJUoexebAltsuXFgZnykiSJEmSJDXApIwkSZIkSVIDTMpIkiRJkiQ1wJoykiRJkiR1WEqwtOVzGNpe80a9afezTJIkSZIkaYEyKSNJkiRJktQAly9JkiRJktQhMxjLdi8PypbHp944U0aSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpAdaUkSRJkiSpQ9kSu901W9oen3pjUkbzVkSsDTy8o+nvwJ0NhSNJkiQtdisBm3Ycn5iZNzQVjDQfmJTRfPZw4LtNByFJkiSpq32B45oOQmoza8pIkiRJkiQ1wJkykiRJkiR1GMvlWJrtnsMw1vL41BuTMprP/t55cOyXNmDrLVdsKpYF4aUHP6HpEBaEsXMvaDoESZKkOXcrN3MGv+ls+vtU50oqTMpoPptQ1HfrLVdkh21XbiqWBWGNVdZrOoQFYSyuaToESZKkuZeTWtyEQ5qBSRlJkiRJkjqMEYy1vATrmFtiLwjtfpZJkiRJkiQtUCZlJEmSJEmSGmBSRpIkSZIkqQHWlJEkSZIkqcMYwdKW12yxpszC4EwZSZIkSZKkBpiUkSRJkiRJaoDLlyRJkiRJ6rA0l2NptnsOQ9vjU2/8KUqSJEmSJDXApIwkSZIkSVIDTMpIkiRJkiQ1wJoykiRJkiR1GCNav+V02+NTb5wpI0mSJEmS1ACTMpIkSZIkSQ1w+ZIkSZIkSR3GCJa2fA6Dy5cWhnY/yyRJkiRJ0oIQEV+PiKzdLurj+vq1/d62GN1XNxiTMpIkSZIkaaQiYh/gmU3H0TYmZSRJkiRJ0shExBLgU03H0UbWlJEkSZIkqcNYLsfSbPcchrGWx1fzYWCj6v5NwJpD6PO3wLP6vObSIYw7VCZlJEmSJEnSSETE3sALq8O7gbcB/z2Erm/PzIuG0E+j5lVqTZIkSZIkzQ8RsTrwuY6mjwCnNxNNOzlTRpIkSZKkDmMsx1jL5zC0Pb7Ke4EtqvsXAG8HHtRUMG00L36KkiRJkiRp/oiIPYCXdzQdkpm3NRVPW5mUabmIeEyXvdVPajouSZIkSZK6iYiVgS+yLOdwZGYe32BIrWVSpv1e2KVtz4i475xHIkmSJEnSzN4ObFvdvwp4TXOhtJs1ZVosItYFnjLFwy8E/t/cRSNJkiRJi8PShKUZTYcxraXZdATdRcT9gdd2NL0qM68ZwVCbRcSXgAdSttteHbgOuBo4DfgVcExmXjuCsYfGpEy7PRdYeYrHnh8Rb8rMu+cyIEmSJElSK20V0Xci6arMvHJYAUTECpRlS+O5hh9n5teG1X/NltWt0/rVbXvgOcBHIuJzwFsz8+YRxTErJmXa7UUd98eAnwCPr47vBTwJ+M4cxyRJkiRJap/vDnDNOyhLjYblDcAu1f1bgJcNse9BrA68CnhCROyXmWc1HM8kJmVaKiJ2A3buaPo58B6WJWWgLGH6zhyGJUmSJEkL3hjLsbTlJVjbtiV2RGwPvKWj6a2ZedEIhrobOAk4HjgDuBS4CVgD2Ax4KPB8yoyZcfcBjo+I3TPz4hHENDCTMu31otrxEZn564g4F9imantCRGyYmf+Y49gkSZIkSQIgIpYDvsCy8hunAh8bwVBvAT43zZKr04HjIuKtwGHA64HxNV0bAMdGxG6Z2ZqKPCZlWigiVgUO6Gi6Efh2df8IyowZgOWBFwDvm+V4mwMPBjas+rwM+FtmnjqbfiVJkiRJc2Zf4Pw+r7lqSGO/Eti9un838OLMXDqkvv8lM98z81mQmbcDb4yIS4FPdDx0f8p77VHVuembSZl2ejqwdsfxNzLztur+l4F3sWw78xcyYFImIvaqrn3gFI//DfifzPxUdXwEJQk0bssRTUeTJEmSJPXn/CZqpkTEvYF3dzR9JDNPn+s4usnMT0bEY4B9OpoPpUVJmXYtQtO4SUuXxu9k5qWU+jLjtomIh/XTeRT/DfyCKRIylfsAh0fEdyNi9X7GkCRJkqT5aozlGMuW31rwdj7Kdk+fA1armi5guIWDh+G9tePdI2JJE4F00/xPURNExNZAZ5Ll3Mw8uXbaEbXjF/Y5zMcoFag7JWUv92OBb1X3x9fZ7QN8ts8xJEmSJEkL28HAIzuOD+lY5dEWvwOu6zhenrJldiu4fKl9XsiyQkQAR3Y559vADSxb4vSMiPiPzLxxps4jYh/gFbXmY4DX1qtQV7VmPgLsBzwbuLqnr0CSJEmStBi8o+P+D4HzImKLGa7ZoHa8QpdrLs/MO2cZGwCZORYRlwDrdDSvN4y+h8GkTItExHjh3nFjlBoyE2TmbRHxTUpWEspUsWcxw2yWiFgB+GSt+WOZ+cpu51dJmqdFxCcp6+7u2cvXIUmSJEnz2RgxD7bEjplPGr1VO+4/AbhwgD427nLd/Sg7KQ1LffbOql3PaoBJmXZ5PLBRx/EvMvPvU5z7JZYlZaDUoZlpidFTgU06js8AXtNDXK8CHg7s0MO5A4mI9ek/W7nVKGKRJEmSJC0o9QkGrVkFYlKmXaYs8FuXmb+JiL8C21ZND4yIHTPzzGn6P6B2/P7MvHumoDLzroh4H/CVmc6dhUMp+8hLkiRJkjQUEXFP4N615subiKWbds/HWkSqmSJP7Gi6kVJ0dzr1ejMzFfx9cMf9uyi1aXp1LGW/eUmSJEmSyMwlmRn93IC9at1c3OW804cY5rOYmPv4J3DOEPufFZMy7fF8YMWO42/2ULX6y5S6M+OeFxErdTsxIu7FxIJKZ/dTFTszbwXO7vV8SZIkSZqvlmbMi5umV70Pfkut+XuZmd3Ob4LLl9qjPsvliJkuyMzLIuJ44DFV0z0p21cf0+X0+hq6i7ucM5NLgJ0HuK4XhwNH93nNVsB3RxCLJEmSJKklImJb4D6Z+b0+rtkA+B5wr47mO4H3Djm8WTEp0wIRsQewXUfTeZn56x4v/xLLkjJQ6tJ0S8osqR3f1HOAy8y45fagMvNK4Mp+rokwMyxJkiRJi8CGwHER8Wfgq8C3M/PcbidGxJqUXY3fwsSEDMC7M/OCkUbaJ5My7VAv8Lt1RAw6neoxEbFJZl5aa7+jdtx1mdMMBrlGkiRJkqRh2Al4P/D+iLgBOJOyk9JNwBrApsAudM91fDYz3zVXgfbKpEzDImINYP8hdrkccCDw7lr7dbXjdQboe91BApIkSZKk+SRZjrGWl2DNlsc3B9YG9uzhvFuA/8zMz404noEs+p9iCzyTktEbphfG5LU9lzNx96SdBuh3x8FDkiRJkiRpIOcA/wX8Guh1w5q/AW8CtmhrQgacKdMG9aVLz6U80fp1JPCw6v6WlG3GfjH+YGbeFhF/Ah5QNd0rIrbLzJ62AouIHYD1B4hLkiRJkiQAMvMEoK8CoZn5T+DNABGxHLANZeOXjSn1U1ehJGuuA/4B/D4zrxpa0CNkUqZBEbEd8OCOpquBb2Tm3VNcMl1fX2VZUgZKsucXtdOOZ1lSBuBg4NU9DvGSfmOSJEmSpPloaS7H0mz3wpK2xzcqmTkG/LW6zXuL86fYHvVZMkcPkpCpHEPZ3mvcfhGxpHbOZ4GxjuOXR8SMS5IiYhfgZQPGJUmSJEmSujAp05CIWBF4Xq35a4P2l5nXAT/uaFoFeHbtnAtqY6wE/CQidp4mzl2qflccNDZJkiRJkjSZSZnmPJmJNVouYbBaMp3qSZ36TByAV1LW2I3bCDg1Ij4fEU+KiB2q25Mi4vPAH4ANKEurfj7L+CRJkiRJUsWaMs2pJ0yOysycZZ/HATezbDen+0fErpl5+vgJmXltRDyOUl9mvap5hSqebkkcgLuA51CbeQPMNl5JkiRJap0xYKy/WrRzbmzmUzQPOFOmARGxMfDYWvPAS5fGZeZtwHdqzZMSLZl5BmU/91/10O3FwEMz86fAqrXHbhogTEmSJEmShEmZphwILN9xfHaVKBmGenLnORGxSv2kzDw3Mx8OPJGynfbfKEmWW4Bzge9TZsdsl5m/rS5bUuvmhiHFLEmSJEnSouPypQZk5nuA94yo7x/Rx57vmflD4Ic9nr59x/2rM3NpP7FJkiRJ0nwwNg+2xB5reXzqjT9F9SQitgQ26Wg6talYJEmSJElaCEzKqFcvqx3/ppEoJEmSJElaIEzKaEYRsStlK+1xCXy1mWgkSZIkSVoYrCmzCEXEy4HVgU9l5rQ7KEXEo4CvAyt1NH8vM88fYYiSJEmS1JilLMfSls9haHt86o1JmcVpPeAw4LCIOI6yNfafgaurx+8B3B94KrBX7dprgUPnKE5JkiRJkhYskzKL22rAs6pbL64FnpKZl40uJEmSJEmSFgeTMovTtZS6MD1vnU3ZNvuVmXneaEKSJEmSpHbIDMayn7dLcy9bHp96Y1JmEcrMj0XEt4DHAXsA2wObAUuAVYCbKYmb8yhLm76bmWc0E60kSZIkSQuTSZlFqlqC9IXqJkmSJEmS5pjlmiVJkiRJkhrgTBlJkiRJkjosJVq/5fTSvkqEqq3a/SyTJEmSJElaoEzKSJIkSZIkNcDlS5IkSZIkdchcjrFs9xyGbHl86o0/RUmSJEmSpAaYlJEkSZIkSWqASRlJkiRJkqQGWFNGkiRJkqQOZUvsdm853fb41BtnykiSJEmSJDXApIwkSZIkSVIDXL4kSZIkSVKHMaL1W2KPuXxpQWj3s0ySJEmSJGmBMikjSZIkSZLUAJMykiRJkiRJDbCmjCRJkiRJHcbmwZbY1pRZGEzKaME4ZO+dWGO5JU2HMa9948IvNR3CgrD/Jg9uOgRJ0iISK/gn/bDk3Xc3HYKkRcblS5IkSZIkSQ0wKSNJkiRJktQA5zpKkiRJktRhLJdjLNs9h6Ht8ak3/hQlSZIkSZIaYFJGkiRJkiSpAS5fkiRJkiSpw1gux9KWLw9y+dLC4E9RkiRJkiSpASZlJEmSJEmSGmBSRpIkSZIkqQHWlJEkSZIkqcMYMEY0Hca0xpoOQEPhTBlJkiRJkqQGmJSRJEmSJElqgMuXJEmSJEnq4JbYmiv+FCVJkiRJkhpgUkaSJEmSJKkBJmUkSZIkSZIaYE0ZSZIkSZI6jGUwli3fErvl8ak3zpSRJEmSJElqgEkZSZIkSZKkBrh8SZIkSZKkDktZjqUtn8PQ9vjUG3+KkiRJkiRJDTApI0mSJEmS1ACTMpIkSZIkSQ2wpowkSZIkSR0y27/ldGbTEWgYnCkjSZIkSZLUAJMykiRJkiRJDXD5kiRJkiRJHcZYjrGWz2Foe3zqjUmZloiIi4DNezg1gZuBG4C/AX8EvpWZp4wuOkmSJEmSNGym1uafANYENgEeCbwW+E1EnBoRD2w0MkmSJEmS1DOTMgvH/YGTI+KApgORJEmSJEkzc/lSex0AdFuStDywNrAt8CRgf5b9HJcHvhIRf83MP85JlJIkSZK0wIwRLG35lthjtDs+9cakTHtdkZkXTfP4H4GjIuJDwE+A9ar25YEPAo8abXiSJEmSJGk2XL40z2XmacAhteZHRMT6TcQjSZIkSZJ640yZheG7wHXAOtXxcsDOwPGNRSRJkiRJ89RYBmNtX77U8vjUG5MyC0BmjkXEecC/dTSvN9X5U4mIFYAHAveurl8ZuAq4CPh1Zt4++2glSZIkSRKYlFlI6mnSO3q+MGI74C2UwsFrTXHabRFxHPC2zPzbYCFKkiRJkqRx1pRZACJiOWCrWvMFPVy3fET8N3Am8GymTsgArAo8EzgrIl45aKySJEmSJKlwpszC8GSW1ZMBuJKSaJlSRKwKfAd4TO2hu4DTgUsps202oCxpWq16fAXgfyJincx8+yzjliRJkqTWKTVl2j2HwZoyC4NJmXkuInYGPlNr/mhm3j3DpZ9kYkLmBuDtwBcy86baGKsChwLvBlapmt8WEb/NzB8NGnttjPXpvw5OfXaQJEmSJEnzhkmZ9togIrbo0r48ZZnRtsATgGcBK3Y8/hPgg9N1HBHPAA7qaLoYeERmXtTt/My8DfhwRPwG+DklMRPAxyJi28wc6+ULmsGhwGFD6EeSJEmSpHnBpEx7HdXn+f8E/gf40HSzZCIigLd1NN0N7DNVQqZTZp4cEW8DPlA1bQ08BTi2z1glSZIkqbXGCJZO2kulXcZaHp960+5FcurVuZSlR4f3sGxpL2DHjuP/zcwz+hjrk0Dn1tj79HGtJEmSJEmqOFNmYdgG+BTw/oh4O6WmzFRLih5dO/5GPwNl5q0R8TvgYVXTQ/u5fhqHA0f3ec1WwHeHNL4kSZIkSXPKpEx77ZWZJ3R7ICJWA+4B7Aw8DXgupa7MWsBHgAdExAsyc2mXyx9SO752ito107mx4/4WEbHcbOvKZOaVlF2jelZWYkmSJEmSND+ZlJmHMvNW4Fbg78APIuJjwM+Ae1anPAf4C2W3pLpNa8enzDKc5YAlwLWz7EeSJEmSWqFsid3uD4HbHp96Y02ZBSAzTwdeVGt+U0R022L6HiMIYc0R9ClJkiRJ0oLmTJkFIjOPi4jLgY2qplWBZ1BqtXRaaQTDm6KVJEmSJM25iFgR2BPYDNgQuBm4HDitl12Gm2ZSZmH5I8uSMgAPYnJS5uqOc24HVsvMnIPYJEmSJEmLWER8HXhmrfnizNxigL7WA95R9bfuFOecDHwkM7/Vb/9zxaTMwnJj7fheXc75J8uSMqtQsokXjzIoSZIkSZpPxnI5xrLd1T7aHl9dROzD5ITMoH09HjgCWH+GU/cA9oiI/wUOycxbhjH+MM2vn6JmUs8O3tblnJNrx48ZUSySJEmSJBERS4BPDamvRwDfYWJCJoFTgaMpm+BcXbvsOcBREdG6HEjrAtJgImJ54IG15ku7nPqT2vGLRxORJEmSJEkAfJhlKzZuGrSTiNgEOJaJtVJ/DeyQmbtl5v6Z+RhgE+CVwF0d5z2Z7jsUN8qkzMLxQibPlDm+y3k/As7vOH5gRLxwZFFJkiRJ0jyTwBjR6tt8KQwaEXtT3q8C3A28bRbdvQNYp+P4ZGDvzDyn86TMvCMzPwbsX7v+1RGx+SzGHzqTMgtAtTbvo7XmS5g8K4bM7PZL8KmI2G+AcfeOiHv3e50kSZIkaeGLiNWBz3U0fQQ4fcC+tgFe0NF0J3BgZt4+1TWZ+R3gyI6mlYHDBhl/VEzKtNcGEbHFFLf7RsRDIuLlEfEL4LuULbDHjQGHTvXkzMyvAV/saFoJ+FZE/G9EPGCqgCJi+Yi4X0QcFhFnU9bqbTbrr1SSJEmStBC9F9iiun8B8PZZ9PVsYPmO42Mz89wernt/7Xj/iFhlFnEMlbsvtddRA153N/CizPzBDOe9lDLt66kdbc8Gnh0RVwF/Aq6hJHjWoqz/246yY5MkSZIkSVOKiD2Al3c0HZKZt0XEoF0+tXb8pV4uysxzIuK3wIOqptUpG94cN2ggw2RSZmH5JfDKzPzzTCdm5l0R8TTgdZR1eZ3JlvWAvXsY7y6gdVuKSZIkSdJsLM1gaQ6cPJgTbY4vIlamrM4YX51zZGZ2q3naa38bALt0NN1NKfDbqxNYlpQBeDwmZTQLdwE3UmaynAX8ATi6x6lb/5KZCXwgIr5MqUx9ADBT0aObgP8DfgB8IzOv6TN2SZIkSdLC9nZg2+r+VcBrZtnfjrXjMzKznwkCJ9eOd5hlPENjUqYlMnOLBse+Angj8MaI2BK4P2W2zDqU5Us3AZcDfwHOzcylTcUqSZIkSWqviLg/8NqOplcN4cP87WvH5/V5/fm143p/jTEpowky80LgwqbjkCRJkqSmJMsxlu3eFydbuG9PRKxAWbY0nmv4cbXRzGxtXTu+pM/rL64d3yMi1snM62YR01C076coSZIkSZLmozewrPbLLcDLhtTvktrxlf1cnJk3A/XdideeTUDD4kwZSZIkSZLmv60G2NnoqszsK8ExlYjYHnhLR9NbM/OiYfQNrFE7vm2APm5j4gY3aw4ezvCYlJEkSZIkaf777gDXvINSlHdWImI54AvAylXTqcDHZttvh3pSpj7rpRe3UeqmTtVnI0zKSJIkSZLUYSyDsRZvOQ20Lb5XArtX9+8GXjziDWJyjq4ZOWvKSJIkSZKkgUTEvYF3dzR9JDNPH/IwN9eOVx2gj/o19T4b4UwZSZIkSZLmv32ZvPXzTK6azYBRith8DlitarqAISyH6sKkjCRJkiRJi8EYwRitWh40SZf4zs/Ms+Y4jIOBR3YcH5KZgxThnckNteP1+rk4ItZgclLm+tkENCwmZSRJkiRJ0iDe0XH/h8B5EbHFDNdsUDteocs1l2fmnR3H59Ye37znCLuff21mXtdnHyNhUkaSJEmSJA2ic/bJE4ALB+hj4y7X3Q84veP4nNrjW/c5xr1rx2f3ef3IWOhXkiRJkiS12Zm1450jYrWuZ3a35wz9NcaZMpIkSZIkdchs3ZbTk2QrN3gejcz8R0ScAexcNa0APAT4aY9dPKJ2/KMhhTZrzpSRJEmSJEl9y8wlmRn93IC9at1c3OW807sM9+3a8UG9xBgR9wUe1NF0C70nc0bOpIwkSZIkSWq7/wWWdhzvFxHb9HDd62vH38zM24cX1uy4fEmSJEmSpA5juRxj2e45DG2Pb9gy89yIOBJ4YdW0EnBERDxqqiRLROwLHNjRdCcTd4xq3OL6KUqSJEmSpPnqMKBzK+s9gOOrJUr/EhErR8S/A0fXrv9wZl484hj74kwZSZIkSZLUepl5aUTsB/yEMlMGys5KZ0fEqcAFwNrA/YH1apd/H3jrXMXaK5MykiRJkiRpXsjMEyLiqcARLEu8BLBbdevmKODgzFw6xeONMSkjSZIkSVKHsYzWb4nd9vhGKTN/GBE7UurDPBNYZ4pTTwE+lJnfmrPg+mRSRpIkSZIkzYnMPIEys2W2/VwJvCwiXklZwrQ5sAFly+vLgNMy88LZjjNqJmUkSZIkSdK8lJl3Ar9sOo5BmZSRJEmSJKlDEozNfjLHSGXL41Nv3BJbkiRJkiSpAc6U0YKRd99Fxp1NhzGv7b/Jg5sOYUH4yeWnNx3CgvHYjXZtOgRJar28++6mQ5AkDciZMpIkSZIkSQ1wpowkSZIkSR3cEltzxZkykiRJkiRJDTApI0mSJEmS1ACXL0mSJEmS1GGM9i8PGms6AA2FM2UkSZIkSZIaYFJGkiRJkiSpASZlJEmSJEmSGmBNGUmSJEmSOuQ82BI7Wx6feuNMGUmSJEmSpAaYlJEkSZIkSWqASRlJkiRJkqQGWFNGkiRJkqQOY/Ogpkzb41NvnCkjSZIkSZLUAJMykiRJkiRJDXD5kiRJkiRJHcYIxmj38qC2x6feOFNGkiRJkiSpASZlJEmSJEmSGmBSRpIkSZIkqQHWlJEkSZIkqUPOgy2xs+XxqTfOlJEkSZIkSWqASRlJkiRJkqQGuHxJkiRJkqQOY/Ng+VLb41NvnCkjSZIkSZLUAJMykiRJkiRJDXD5kv4lIjYBdgY2A9amPD9uBK4DLgBOy8zbmotQkiRJkqSFw6TMHIqIi4DNZzjtjup2DfBP4HzgLOA3wCmZefuQY9oeeAnwVEoyZjpLI+J04BvAUZl56TBjkSRJkqQ2GMv212wZy6Yj0DCYlGmflavbWsCWwO4dj90cEd8DDs/Mk2YzSERsCnwIeAbQ66vN8sADqtv7IuIrwGGZefFsYpEkSZIkaTEyKTO/rAEcABwQET8HXpGZf+m3k4h4MvBlYEmXh2+nzMy5CrgWWAfYANgaWLPjvOWAFwDPAlbpNwZJkiRJkhY7kzLNOgA4pda2IiVZsoSy1OlBwJ7AdrXzHgWcGhEHZeY3ex0wIp4LHEGZ9dLp+8DhwAnd6sZExIrAw4CnAC8CVq0eWrnXsSVJkiRpPkjavyV29rzgQW1mUqZZV2TmRTOc83mAiNgDeDXwtI7HVgOOiojlMvPrMw0WEbtV/XUmZP4BHJCZJ053bWbeBfwc+HlEvBd4K6UWjTt4SZIkSZI0AN9QzxOZeXJmPh14DnBzx0PLAV+MiB2nuz4i1gGOZuLMlvOBPWdKyHSJ5fLMfBnwZOD6fq6VJEmSJEmFSZl5JjO/RtkpaayjeVXgkzNc+iZgi47ju4BnZOaFs4jlh8Bug14vSZIkSdJiZlJmHsrM44F31ZofFhF7dTs/IpYAh9Sa35uZpw0hlvNn24ckSZIktUlmzIub5j+TMvPXh4Ebam0vmeLcg5m4c9IdwCdGEZQkSZIkSeqNSZl5KjNvAr5Ua358RHQr3vy42vG3M/Oq0UQmSZIkSZJ6YVJmfvtZ7XhtYELB34hYCXhw7bxfjDIoSZIkSZrPxoh5cdP8Z1JmfjsFyFrbLrXj+1EKAXf6/cgikiRJkiRJPTEpM49l5rVAfRnSZrXjjbtces5oIpIkSZIkSb3qVn9E88t1wPodx+vVHl+3dnx7Zt4x2pD6FxHrMzn2mWw1ilgkSZIkSZoLJmXmv+tqx/WlSveoHV8/ulBm5VDgsKaDkCRJkqTMYKzlW067JfbC4PKl+a/+M6zXmJEkSZIkSS1kUmb+W1I7vq12fG3teO3RhSJJkiRJknrl8qX5b53acb3w7zW141UjYuUW1pU5HDi6z2u2Ar47glgkSZIkLWKZ0frlQW2PT70xKTOPRcQ9mVwc9+La8eVdLr0v8KeRBDWgzLwSuLKfayJ8EZIkSZIkzV/zKikTEbsC+wAPpcySWBdYE8jMnPS1RMQSYK3q8I7M/OfcRDpndu/SVk+2/JGypKmzAPADu5wnSZIkSZLm0LyoKRMRO0XE8cCplB16HglsQUm4RHXrZi/gwup2bkSsNvpo59Sja8fXAWd1NmTmncAptfP2GmVQkiRJkiRpZq1PykTEgZSkwl5MTr7MtNPQd4FLqutWB5427PiaEhFrAQfWmn+YmUu7nP7j2vF+EVHfKluSJEmSBIwljFXbYrf31vR3ScPQ6qRMRDwN+AITl94E8HfgdKaeIQNAZo4B3+ho2mfIITbpNSxbmjXus1Oc+zngpo7jlYF/H0VQkiRJkiSpN61NykTEhsCR1eF4DvBwYKvM3ALYr8euxnfnCeDhQwuwQRGxN/CWWvMJmfmrbudn5nVMTti8MSJ2HkIsW822D0mSJEmSFqPWJmWAtwGrUZIpY8D+mfmKzLywerzXyVq/B+6q7t8jIrYcbphzKyIOAL7NxJ/drcChM1z6XsoMo3ErAcdExGaziOXxwB8GvV6SJEmS2mh8S+y23zT/tTIpExHLAwdQEi8JvD8zvzVIX5l5N/CXjqb7zj7CuRcRD46Io4GvAWt0PLQUOCgzz5nu+sy8BngGcGdH8zbAyRHxkD5j2TAiDge+Dyzp51pJkiRJklS0dUvs3VlWL+VO4AOz7O9SYKfq/qaz7GuYNoiILWptKwBrU5IdmwMPAh4CbN/l+luAAzPzmF4Gy8zfRsRLgC+yLCG3MfB/EXEcZXnYrzLztvq1EbEiZSvypwIvYmKdH0mSJEmS1Ke2JmW2rv6fwO8z88ZZ9td5fb04bpOOmsW1xwOvyMy/9nNRZh4ZETcAR1CSP+P2qW63R8SZwFWULbaXABtQZtWs2aXLSQkcSZIkSZI0s7YmZdbruP/3Kc/q3VjH/bZ+zb24GfgecHhmnjRoJ5n5nYjYBfgwk7cJXwXYrYdu7qbMuHnHoHFIkiRJUhslZdvpNsvpNyPWPNHWBEVnEd/lh9Dfuh33rx9Cf6N0F3A7cC1wBXA+cBbwG+A3mXn7MAbJzIuBp0fEjsDBlGVJMy3tuhv4I/B14KjMvGIYsUiSJEmStBi1NSlzVcf9jYbQ344d968ZQn8DqbbybpXMPBN4JfDKaiemnSi1bNaiPD9uoCxjOh84bVhJIUmSJEmSFru2JmUuqf4fwP0iYsXMvGu6C6YSEfehFLMdd8Zsg1uoMvMSln3vJUmSJEnSCLVyS2zKUp3bKMuYVqVsjz2o/+i4/89+C+NKkiRJkhaXzPlx0/zXyqRMZt4B/JwyUyaA90TEkn77iYg9gUMoyZ0Ejh1imJIkSZIkSQNrZVKm8p7q/0lZfvTTiFi/14sjYi/gOMrXGMBS4EPDDlKSJEmSJGkQrU3KZOZvKbv8BCUxsxvwl4h4a0RsS5fYI2L5iHhURHwdOB5Yp+P6j2bmRXMVvyRJkiRpfhoj5sVN819bC/2OexGwLXA/SmJlCfD26nZn54kRcQ6wJbDieFN1TQAnA2+Yg3glSZIkSZJ60tqZMgCZeRvwWOAXLEuyUN1fuXa8LbBSdR+WJWR+CjwxM5fOUdiSJEmSJEkzanVSBiAzrwYeDbweuJqJSZfx/3feqM65AXgzJSFz45wFLEmSJEmS1IO2L18CIDMT+GBEfJyyPfajgYcAGzExsXQdZanST4CvZOYNcx2rJEmSJGl+ywwy212zpe3xqTfzIikzLjNvB75U3YiIoBTzXQm4JjPvajA8SZIkSZKkns2rpExdNYPm2qbjkCRJkiRJ6te8TspIkiRJkjRsmcFYy5cHuXxpYWh9oV9JkiRJkqSFaN7OlImILYH1gXUpuy5dB1yZmRc2GpgkSZIkSVIP5k1SJiKWA/YBDgT2pCRjup13LfBr4AjguMwcm6MQJUmSJEmSejYvkjIR8Sjgs8AW403TnH4P4MnV7cKIOCQzfz7aCCVJkiRJC0VmubVZ2+NTb1pfUyYi3g38FNiSZcmYrG51ne0B3Bv4aUS8a9RxSpIkSZIk9aPVM2Ui4p3Am6rDzmRLAhcA5wI3VO1rA9tQEjFRO/9NETGWmYfNRdySJEmSJEkzaW1SJiIeDLyZicmVy4D3A0dl5jVTXHcP4NnA64BNqusDeHNE/DAzfzvq2CVJkiRJ81fS/i2nXb20MLR5+dIHmFg75mjgvpn5iakSMgCZeU1mfhzYrrpmfNbMcsAHRxivJEmSJElSz1o5UyYiNgH2YFny73jgWZm9lzLKzFsi4lnAOsDeVfMeEbFJZl461IAlSZIkSRIRsSpwX2BzYCNgTWBF4EbgGuBM4KzMvLuxIFuklUkZSkKms6jvK/pJyIzLzIyIVwB/Ydkypj2Abw4rUEmSJEmSFrOIOAh4JPAgYCtmXpVzc0R8E/h4Zp7exzizXbW1ZWZeNMs+hqqtSZmNqv8ncEZmnjtoR5n5t4j4E7BL1d9GM1wiSZIkSVrEMqP9NWXaFd+7gI37OH8N4IXACyLi48DrFuvMmbYmZTqzaucNob/zKEmZet+SJEmSJGm4bgXOBy6hLFtaDlgX2AnYoOO85YFXAVtExNMzc+kcx9m4tiZlLhtyf51TnC4fct+SJEmSJC1mtwDHAT8CTgbOzMyxbidGxO7Au4FHdTQ/BXg1/W3O81vgWX3G2br6sm1Nyvy14/7WQ+ivs4+/TnmW5rVYaSViuZWbDmNeyzvuaDqEBeGxG+3adAgLxu5/uqvpEBaMU3ZZsekQpAnuePy/NR3CgrHyj37fdAjSgjOWwVi7lgdN0rL4dszMnv5wy8xTIuIxwJHAczseenNEfCwze31Tcnvb6sMMopVLeapCP3+lFObdOSIGTsxExDbArpTZMudl5mnDiFGSJEmSJEGvCZmO88eAl1Nm2IxbG9hrmHHNB61MylQ+2XH/E4N0EBEBfLyj6fBZRSRJkiRJkmYtM28ETqo1D2OlzLzS5qTM4cDPKbNlHh0RX4uI1Xq9uDr3a8BjqqYTmJigkSRJkiRJzbm2drxmI1E0qLVJmWo601OA71MSM88EzomIl0XEulNdFxHrRsShwDnA/pRlSz8A9pmq0JAkSZIkSf+SkC2/TdjOZv7avHa86DbmaWuhXyLii9Xdq4HrgHWATSlLmT4eEecDf6Nsr5WU9Wf3AbaiJHHGqx5dW/Xx8bKaaUaZmS8a0pchSZIkSZJqIuI+wIM6mhI4saFwGtPapAxwIBNzf+P3xxMu2zB5vVl0OX8d4Pk9jhnVdSZlJEmSJEkagYjYEDgaWL6j+Zg+d1PaLCK+BDwQ2AhYnTKh42rgNOBXVZ/1JVKt0uakzFSmm6S1MCZwSZIkSZIakxlku7acnqTt8XWKiBUoEya2A54EHAKs1XHKBcAr+ux2y+rWaf3qtj3wHOAjEfE54K2ZefMAoY9c25My8+dZJkmSJEmSiIj/AV7Z4+m/BJ6XmVeOIJTVgVcBT4iI/TLzrBGMMSttTsrUM16SJEmSJKm7rXqso9rpqhElQ3pxHPDJzPxpn9fdTdlK+3jgDOBS4CZgDWAz4KGUEibrd1xzH+D4iNg9My+ebeDD1NqkTNu+UZIkSZIktdh3B7jmHcDbhxxHrx4PLB8Rt2fmr3q85i3A56ZJJJ0OHBcRbwUOA17PshU4GwDHRsRumdma0iet3RJbkiRJkqQmjNeUafutxd7JspovW1JqvDwU+HfgF9U5KwJPBE6MiE9ExPLdOuqUme/pZWZPZt6emW+sxut0f+CAnr+KOWBSRpIkSZIkDU1mXpuZF3XczsnMkzLzE5n5KEqCpnN1zMuBz44gjk9Slkl1OnTY48xGa5cvSZIkSZKknu0LnN/nNVeNIpCZZOZJEbEX8HvgHlXzCyPiuMwcZBnWdN4L7NNxvHtELMnM64c8zkBam5SJiG8Ah2fmiU3HIkmSJElaPLK6tVmX+M5v4+5CU8nMCyPincBHO5r/H4PVxpnO74DrKFtyAyxPWU518pDHGUibly89A/hFRJwTEf8REUuaDkiSJEmSJA3N12vHuw/7vX9mjgGX1JrXG+YYs9HmpMy4bYH/Bi6LiC9ExAObDkiSJEmSJM1OVbT3uo6m5SiFgYftttrxqiMYYyDzISmTlC2sVgUOBH4TEadGxIsjYrVGI5MkSZIkSbNxV+145RGMcc/a8dUjGGMgbU7K7AP8iGVL5cb/H8D9gM8Al0fExyNixwbikyRJkiQtQEnz213PeKPVW2L3JCJWYXLC5J9DHuOewL1rzZcPc4zZaG1SJjO/n5lPokxd+i/gCvjXs2589sxalO2s/hQR/xcRB0TEio0ELEmSJEmS+vEoJuYlbgUuG/IYz6qN8U/gnCGPMbDWJmXGZebfM/MtwGbA/sDPOx+u/h/AHsBXKbVn3hcR9UyYJEmSJElqgYhYDnhrrfnHmXnnEMe4F/CWWvP3MrM1m2u1PikzLjOXZuYxmflo4D7AR4BrYcKcraBMfXod8LeI+HFE7Fv9sCVJkiRJ0hBFxL9HxIZ9XrMi8AXgQbWHPjnF+dtGxJP7HGMD4PvAvTqa7wTe208/ozYvkxWZeX5mvhbYGHg+8GsmLm2C8rU9GjgWuDgi3hYRG815sJIkSZKk+SXnya0dXgScHxFfjYgnR8SaU50YEatGxAHAaZSNfDp9JTN/McWlGwLHRcQZEfH/ImKbacZYMyJeAZwO7FZ7+N2ZecEMX8+cWqHpAGajmtb0VeCrEbE9pb7Mc4C1q1PGEzUbA4cBb4mI7wGfyszj5zpeSZIkSZIWoFUp78WfA2REnAdcBFxPmZ2yJrA5sD3QrQ7s94GDexhnJ+D9wPsj4gbgTMpOSjcBawCbArvQPdfx2cx8V89f0RyZ10mZTpl5NvCKiHgd5YlwCPAAJtadWQF4CvCUiDgf+ATwpcy8ae4jliRJkiRpwQlgm+o2k9uAdwMfzMz61tgzWRvYs4fzbgH+MzM/12f/c2JeLl+aTmbeBhwJ/DdwMROXNXUmaLauzrkoIl7vrk2SJEmSJIBMmt/yesZb09+lfzmYklj5DXBHj9f8hVLk9z6Z+V89JGTOoezK/GtKIqcXfwPeBGzR1oQMLKCZMgARsRXwEsratPG9zjsTMZ3Gt9Veh/LDfXZE7JuZF40+0vkpIjp/7U/MzEc0FYskSZIkqXmZ+Xvg98Bbq8kO2wH3ppQRWYOyXOlm4EbKkqbTMvO6Psf4J/Bm+NeuTdsAW1VjLAFWoSRrrgP+Afw+M6+a5Zc2J+Z9UiYilgf2BV4KPJKSaOmcHTN+/wRKJecbKImbfSlPjvFzdgJ+GRE7t3k5U0RcRFmLN507qts1lD3YzwfOomQuT8nM20cZoyRJkiRp8almvJxR3UY1xhjw1+o2783bpExEbEpJrrwQ2GC8mWXLlIKSjfsK8MnMPKfj8uOr/cpfDbyCklULYDPglZSpV/PZytVtLWBLYPeOx26uih0fnpknNRGcJEmSJEmaZzVlonhSlVS4gLI+bEMmLk0K4Gzg5cDGmfmKWkIGKNOfMvP1wP0ps0nGEzlPGe1X0bg1gAOA/4uI4yPivk0HJEmSJEmtkuN1Zdp7a9GW2JqFxmbKRMRmHYeXVlOQpjp3A+DF1W3T8WYmzopZCnybMgPkxF7jyMy/RsS7KTsxAdyn5y+iHQ4ATqm1rUhZV7eEstTpQZSq1NvVznsUcGpEHJSZ3xxtmJIkSZIkqVOTy5cuYllS5d7AJfUTIuLRlFoxT6LE2lkrhur4H8BnKXuO/2PAWH7TcX/1AftoyhU9FCf+PEBE7EFZsvW0jsdWA46KiOUy8+vTdZKZ9WLJkiRJkiRpQE3XlJnyTX5EnEtJ1oyf1zkrJoATgcOBb2fm3bOM49rq/wt6AlhmngycHBHPBj5DWcoEZRnbFyPizMw8s7EAJUmSJKkFxredbrO2x6feNF1TZrokyFa18wK4BfgUsGNm7pWZRw8hIdNpUTyrM/NrwFOBziVjq1J2p5IkSZIkSXOgDTNlZpqdMl6491PAkZl58wjiuALYawT9tlZmHh8R7wIO62h+WETslZm/bCouSZIkSZIWi6ZnykznbuBY4JGZuWNmfnJECRky847MPHH8NooxWurDwA21tpdMdXJEZMfthJFGJkmSJEnSAtf0TJnpbJGZlzcdxEKWmTdFxJeAV3U0Pz4iVhjysjBJkiRJmj8yyq3N2h6fetLamTImZObMz2rHawM7NhGIJEmSJEmLSWuTMpozpzC5rs8uTQQiSZIkSdJi0ublS5oDmXltRFwFrN/RvFlT8UiSJElS0xLImbakaVjLw1OPTMoI4DomJmXWm+sAImL9AcbdauZTJEmSJElqp6aTMuPJvd0jYos5GTDzV3MxzjxzXe141QZiOJSJ23NLkiRJkrSgNZ2UAQjgqDkaK2nH19w29dpCzoSTJEmSJGnE2pKgcC+vZi2pHd/WRBCSJEmS1ApJ+z+qbnt86klbkjJz8XQy8TO1dWrHVzUQw+HA0X1esxXw3RHEIkmSJEnSyLUhKZPA5cDdTQeyGEXEPZlcYPfiuY4jM68EruznmgjzbJIkSZKk+avppExQkjJ7ZuYlDceyWO3epe1Pcx6FJEmSJLVEZpDZ7g+B2x6felMv8KrF59G14+uAs5oIRJIkSZKkxcSkzCIWEWsBB9aaf5iZSxsIR5IkSZKkRcWkzOL2GmCtWttnmwhEkiRJkqTFpumaMmpIROwNvKXWfEJm/qqJeCRJkiSpNdwSW3PEmTKLUEQcAHybiT//W4FDm4lIkiRJkqTFx6TMIhIRD46Io4GvAWt0PLQUOCgzz2kmMkmSJEmSFh+XL81/G0TEFrW2FYC1gSXA5sCDgIcA23e5/hbgwMw8ZoQxSpIkSdK84ZbYmitNJ2VcBTd7R83i2uOBV2TmX4cVjCRJkiRJ6k3TSZnAxMxcuxn4HnB4Zp7UdDCSJEmSJC1WTSZljuy4f3NjUSxMdwG3A9cCVwDnA2cBvwF+k5m3NxibJEmSJEmiwaRMZh7U1NjzWWZu0eDYLlqUJEmStPC5JbbmiLsvSZIkSZIkNcCkjCRJkiRJUgOaLvQrSZIkSVLLRHVrs7bHp144U0aSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpAdaUkSRJkiSpzi2nNQecKSNJkiRJktQAkzKSJEmSJEkNMCkjSZIkSZLUAGvKSJIkSZLUKWl/TZm2x6eeOFNGkiRJkiSpASZlJEmSJEmSGuDyJUmSJEmSOiWQ0XQU03P50oLgTBlJkiRJkqQGNDJTJiKe38S4AJn55abGliRJkiRJGtfU8qUjaG6ylUkZSZIkSZLUuKZryszVIr2sxnLVnSRJkiRpWpnl1mZtj0+9abKmzFxWTWp5hSZJkiRJkrTYNDVT5qCGxpUkSZIkSWqFRpIymXlkE+NKkiRJkjSjpP3FL9oen3riltiSJEmSJEkNMCkjSZIkSZLUAJMykiRJkiRJDWh6S2xJkiRJktolo9zarO3xqScmZbRg5J13knFH02FIGqJTdlmx6RAWjJ9cfnrTISwYj91o16ZDWBBW/tHvmw5hwVh+h22bDmHBWHrWX5sOQdIi4/IlSZIkSZKkBjQyUyYiLmhiXCAzc6uGxpYkSZIkzQMBRMu3nHbx0sLQ1PKlLSi7qs/186jlv1aSJEmSJGmxaLqmzFwmSUwkSpIkSZKk1mgqKXMJzlqRJEmSJEmLWCNJmczcoolxJUmSJEmaUdL+aQRtj089cfclSZIkSZKkBpiUkSRJkiRJakDThX4lSZIkSWqXjHJrs7bHp544U0aSJEmSJKkBJmUkSZIkSZIaYFJGkiRJkiSpAfOqpkxELA/sCmwHrAOsTZ+Jpcx85/AjkyRJkiQtGG6JrTkyL5IyEbED8Bpgf2DVWXZnUkaSJEmSJDWu9UmZiHg18F5KrFOVl+7MEXY7J6t2c4mSJEmSJKkVWp2UiYjXAh+oDusJlekSMfXH3CtMkiRJktQbly9pjrQ2KRMRO1FmyIw/1QL4PvAt4C7gq1V7AnsBawEbAXsATwHWrB67Eng1cNkchS5JkiRJkjSj1iZlgNcDy1f3x4AXZuaRABGxeeeJmXlix+FnImIt4B3AfwDrUWbb7J2Zfxl51JIkSZIkST1o5ZbYEbEisB/LJo19Zjwh04vMvDEz/xN4CWWGzUbA9yNijVHEK0mSJEmS1K9WJmWABwCrsKw47wcH6SQzvwB8oTrcEvh/Q4lOkiRJkrRw5Ty5ad5ra1Jm2+r/CZyfmRdNd3JETPd1vJ1lT9fnzzoySZIkSZKkIWhrUmadjvvd6sCM1Y5XmaqjzLwM+BNl1s2mEfGA2YcnSZIkSZI0O21NyqzWcf+GLo/fXDteMkN/F3Tc33qQgCRJkiRJi0VAtvxGNP1N0hC0NSnTmXTpNgvmptrxxjP0d3vH/Q0GikiSJEmSJGmI2pqUubLj/tr1BzPzbuAfHU27ztDfph33p1zqJEmSJEmSNFdWaDqAKfy14/62U5xzJrBhdf+xwOe6nRQR6wIPZFmx32uGEaAkSZIkSZooIlYF7gtsDmwErAmsCNxIeT9+JnBWNdliGOOtCOwJbEbJEdwMXA6cNtOmQW3Q1qTM2cCdwEqU4rxLMvP62jm/AB5NWUj35IjYJTP/1KWv9wErV/cTOH0kEc+hiLiI8gQft1dmnjDN+UcALxhtVABsOR+e9JIkSZI0nchya7M2xRcRBwGPBB4EbMXMq3JujohvAh/PzNMHHHM94B3AM4F1pzjnZOAjmfmtQcaYC61cvpSZdwC/7Wh6TJfTvkHZhSkpWbefRsTzI+IeEbFCROwYEV8FXsSyWTKXA38cYeiSJEmSJC027wKeC2xDb3mGNYAXAn+IiP+OiL4mjETE4ykzbl7GFAmZyh7AMRHx1YhYvZ8x5kpbZ8oA/BB4aHX/qcA3Ox/MzIsi4kjgIErSZT3gS136GS9JncAHMrO+nbYkSZIkSRqeW4HzgUsoy5aWoyRPdmLi5jvLA68CtoiIp2fm0pk6johHAN+hrKwZl5QJGBdQdme+H3DPjsefA6wVEU9pW06gzUmZbwLvpSRVnhoRG2TmFbVzXgc8mLJeLZm8J1h2tP8gMz8+2pBb67XA23s89yQm7mZ1AHBKj9de2kdMkiRJkqSF4RbgOOBHwMnAmVMlPyJid+DdwKM6mp8CvBr44HSDRMQmwLFMTMj8Gjg4M8/pOG9l4BDgQ5SVNQBPrsZ9U69f1FxobVImMy+MiHuwbOrTjV3OuTYiHgl8AXh8l24CWAp8lpJ9W5Qy82rg6l7OjYh6saUrrBMjSZIkaVEZ/3i/zdoV346ZeVcvJ2bmKRHxGOBIypKncW+OiI9V5Uym8g5gnY7jk4G9M/P22hh3AB+LiEuAb3c89OqI+ExmXtxLrHOhtUkZgMy8rodzrgCeGBH/BuxLWcO2BLgO+BNwTGaeO8o4JUmSJElarHpNyHScPxYRL6eUKhmv9bI2sBfw427XRMQ2TNzA5k7gwHpCpjbOd6qyJ+PXrQwcRqln0wqtTsr0IzN/D/y+6TgkSZIkSdL0MvPGiDgJeGxH89bTXPJsSg2accf2OAHj/UxM5uwfEYdOl8yZS63cfUmSJEmSJC1419aO15zm3KfWjrtt9DNJVWumc3fn1em+w3MjTMpIkiRJkqQmbF47vrzbSRGxAbBLR9PdlAK/vTqhdtytJm0jTMpIkiRJkqQ5FRH3AR7U0ZTAiVOcvmPt+IzMvKWP4U6uHe/Qx7Uj1WhNmYgIyrbWq3Q0f3m2u/1ExJbA8zqabs3MD82mT0mSJEmSNHsRsSFwNBNrxBwzTS5g+9rxeX0Oef4M/TWm6UK/zwbex7LNvI4dxvbL1XbaOwH7jbdFxAWZeexs+5YkSZIkLWyR5dZmbY+vU0SsQNnKejvgScAhwFodp1wAvGKaLuoFgC/pM4T6Ftj3iIh1etnxedQaS8pExHLAO8cPgb8xsSLybB1IWXM2/sN7D2BSpqUiYn1gvT4v22oUsUiSJEnSPLRVWYzSl6sy88phBxIR/wO8ssfTfwk8b4Y4ltSO+4o5M2+OiNuZuEpnbWDxJmWAvYEtWTZL5o2ZeeuwOs/MWyLiDcAxVdN9IuKRmfmLYY2hoTqUsl+8JEmSJKl/3x3gmncAbx9yHL06DvhkZv60h3PXqB3fNsB4tzExKTPdTk9zpsmkzHM77p+amd8e9gCZeWxEnAo8oGp6DmBSRpIkSZI0tYxya7O2xzezxwPLR8TtmfmrGc6tJ2VuH2C82yhLqKbqsxFN7r70uI77XxjhOON9B/CEEY4jSZIkSZJKqZItO27bAw8F/p1lEyVWBJ4InBgRn4iI5bt1NIVBKuq0sgpPIzNlImJz4J4dTd8f4XDfBw6v7q8fEZtm5t9HOJ4Gczil+nY/tmKwKXqSJEmStNDsy+RdhmZy1SgCycxrgWu7PHQS8ImIeAjwVWDzqv3lwKrAi6bo8uba8aoDhFW/pt5nI5pavrRL9f8Ezs/My0Y1UGZeGhHnsazg766ASZmWqYo69VWsaYAiVpIkSZK0UJ2fmWc1HUQvMvOkiNgL+D1wj6r5hRFxXGZ2++B9wSZlmlq+1LnLzuVzMF7nGOvPwXiSJEmSpPkq58ltHsvMC1m2I/O4/zfF6TfUjvvauTci1mByUub6fvoYlaaSMp3Fda6Yg/E6x1gyB+NJkiRJkqTpfb12vHtELOly3rm14827nDOd+vnXZmbj22FDc0mZleY4hs4xVp6D8SRJkiRJ0jSqMhadyZHlKIWB686pHW/d5Zzp3Lt2fHaf149MUzVlbu2439e0owF1jnHrlGdJkiRJkgTzfnnQPHJX7bjbRIoza8c7R8Rqmdnr+/s9Z+ivMU3NlOlcTtTvtKNBdI7xzzkYT5IkSZIkTSMiVmHizszQ5T17Zv4DOKOjaQXgIX0M9Yja8Y/6uHakmkrKjG/TFcDmEdHv1KOeRcRWwBZdxpYkSZIkSc15FBPzErcCU+3O/O3a8UG9DBAR9wUe1NF0C/DTXgMctaaSMn8C7mTZhLB9RjjWUzru3wWcPsKxJEmSJEnSDCJiOeCtteYfZ+adU1zyv8DSjuP9ImKbHoZ6fe34m5l5e49hjlwjSZnqm3wiZaZMAP8vIlYf9jhVn69j2YZhv5rmByxJkiRJEpHz49YGEfHvEbFhn9esCHyBiTNYAD451TWZeS5wZEfTSsAR1RKoqcbZFziwo+lO4B39xDpqTc2UATiq+n9SCvF+YARjvA9Yn5L4AfjaCMZogw0iYotBbk0HLkmSJEma114EnB8RX42IJ0fEmlOdGBGrRsQBwGlMTJYAfCUzfzHDWIcxcbemPYDjqyVKneOsHBH/Dhxdu/7DmXnxDGPMqaZ2X4KSIHkPsAElafLSiLgsM/9rGJ1HxBuAl1OSPkEpLrxQkzJHzXzKlGLmUyRJkiRJmtKqwHOqW0bEecBFwPWU2SlrUjbg2R5Yscv13wcOnmmQzLw0IvYDfkKZKQNlZ6WzI+JU4AJgbeD+TN7p+ftMXi7VuMaSMpl5Z0S8ETiCZYmTd0XEzsDLMvO66a6fSkQsAQ4HntnRbwJvcumSJEmSJGlG4wUw2qy98QWwTXWbyW3Au4EPZmZ9a+yuMvOEiHgqJZcwnngJYLfq1s1RwMGZuXSKxxvT5PIlMvPLwHdZljgJ4BnAuRHxgR6L9gAQEVtHxAeAcykJmfEZIAl8LzOPnPJiSZIkSZI0iIMpiZXfAHf0eM1fKLNW7pOZ/9VrQmZcZv4Q2BH4NBOXM9WdAjw9M5+dmbf0M8ZcaXL50rjnAb+gZLTGEzPrAq8BXhMR/wB+B5xDmfp0fXXd2sASYDvggcBGVXtnMiaAU4HnjvZLmFuZucV87FuSJEmStLBk5u+B3wNvrQr4bgfcG9gYWIOyXOlm4EbKkqbTBl0ZUxv3SuBlEfFKyhKmzSnlUW6hbKt9WmZeONtxRq3xpExm3hwRj6JMPXoqyyZhjSdXNgL2rW5T6ayL0nn9d4EXZObNQwtYkiRJkiRNUs14OaO6zdWYdwK/nKvxhq3R5UvjMvOmzHwaZXbMbSxbztS5ki+muFE7N4Dbgf+XmU/NzBvn6uuQJEmSJC0AOU9umvdakZQZl5n/TZly9B7KMqXO5MtUT8POc66vrt08Mz80t9FLkiRJkiT1rvHlS3WZeQ1lLdo7gQcBD6esD9uYUmvmHtWp1wLXAJcDvwZOBH7rDkuSJEmSJGk+aF1SZly1Fu2k6iZJkiRJ0pyILLc2a3t86k2rli9JkiRJkiQtFiZlJEmSJEmSGmBSRpIkSZIkqQGtrSkjSZIkSVIjMsqtzdoen3riTBlJkiRJkqQGmJSRJEmSJElqgMuXJEmSJEmqc8tpzQFnykiSJEmSJDXApIwkSZIkSVIDTMpIkiRJkiQ1wJoykiRJkiR1Soi215Rpe3zqiTNlJEmSJEmSGmBSRpIkSZIkqQEmZSRJkiRJkhpgTRlJkiRJkjol7a/Z0vb41BNnykiSJEmSJDXApIwkSZIkSVIDXL4kSZIkSVKHmAdbYrc9PvWmkaRMRLytiXEBMvOdTY0tSZIkSZI0rqmZMm+nubJEJmUkSYvOYzfatekQFowVT9iw6RAWhLse8Y+mQ1gwrtt5naZDWDDWXLJr0yHMa3nLP+G0nzUdhjSvLKaaMtF0AJIkSZIkSeOarCljkkSSJEmS1D5uia050lRSZq+GxpUkSZIkSWqFRpIymXliE+NKkiRJkiS1hVtiS5IkSZLUyeVLmiOLqdCvJEmSJElSa5iUkSRJkiRJaoBJGUmSJEmSpAZYU0aSJEmSpA4BRMtrtkTTAWgo5m1SJiLWBNamz9k+mXnJaCKSJEmSJEnq3bxJykTEw4DnAHsA92WwpVfJPPqaJUmSJEnSwtX6BEVEbAn8L/Cg8aYGw5EkSZIkSRqKVidlIuJ+wM8py5SCiTuxd96PKdrrj0mSJEmSJLVCa5MyEbEW8C1gCcsSLXcDJwPXAU+p2hI4ElgL2Ai4H7BSxzVXAj+ai5glSZIkSZJ61dqkDHAosAXLkis/AQ7KzCsiYnOWJWXIzIPG70fEypTaM2+prl8PWL66dulcBC5JkiRJkjSTQYrlzpVDWZaQOQ3YJzOvmOmizLwjM78I7EpJ5AQlSfPFEcUpSZIkSVpIcp7cNO+1MikTEfcGNmFZPZg3ZOZd/fSRmTcC+wFnVP08NyKeOtRAJUmSJEmSBtTKpAzwgI7712bm8YN0kpm3Aa/taHrVbIKSJEmSJEkalrbWlLln9f8E/tTl8QkTtSJi5cy8o1tHmXl8RPwD2BDYMyI2yszLhxqtJEmSJGnBiCy3Nmt7fOpNW2fKLOm4f1WXx2+vHa82Q3+nV/8PYLfBQpIkSZIkSRqetiZl7uy4323HpJtqxxvN0N+1Hfc3GCgiSZIkSZKkIWprUub6jvtr1x+sasXc2tG09Qz9dfax7uBhSZIkSZIkDUdbkzLnd9zfZIpzzu64/9CpOoqI+pKlm2cRlyRJkiRpoWt6q2u3xF402pqUGU+4BHDfiOgW5+87znlORKw6RV8HMHHJ0gXDCVGSJEmSJGlwrUzKZOaVwLnV4UrA7l1OO2b8dGB94GsRsUbnCRGxN3A4y3KIdwEnDT1gSZIkSZKkPrV1S2yA44FtqvtPBE6uPX4C8Gdgx+p4H+CyiPgVcANwX+B+lJk0UBIzR2XmjSOMWZIkSZI0382H5UFtj089aeVMmcr4TJgADoyI5TsfzMwEXgHc3dG8JvAEypKl+1fXjj9VrwTeMMqAJUmSJEmSetXmmTInAq9hWeJoPeCKzhMy8/8i4jnAEcBqTMwVjt8P4HLgSZn5z1EG3K+IuAjYvNZ8IXDfzLxz8hV99bVeZl49qwAlSZIkSdLItDYpk5ljwH/3cN4xEfE7yiyYfYCNOh4+F/gG8OHMvGEkgQ7flsBLgY81HYgkSZIkSRqd1iZl+pGZlwCHAodWuzAtAa7LzNsbDWxwb4mIL2XmTU0HIkmSJEmLTWS5tVnb41Nv2lxTZiCZeVtm/mMeJ2SgLNV6bdNBSJIkSZKk0VlwSZkF5NURca+mg5AkSZIkSaNhUqZdvtNxfw3gbQ3FIUmSJEmLW7b8pgXBpEy7HAbc1nF8cERs3VQwkiRJkiRpdBZEod8F5HLgo5SdpABWBN4NPGsuBo+IewP3p9S0WQe4gbIN+W8y8/K5iEGSJEmSpMWitUmZiPjiCLrNzHzRCPodpvcBLwHWrY73j4gPZuapoxgsIlYH/gN4ITDlrJyIOB34L+CYzHSynCRJkiRJs9TapAxwIMNdKRdVf61OymTmDRHxXuCDVVMA7wf2HvZYEfFY4MvA+j2cvivwTeD4iHh6Zt4w7HgkSZIkqQ3cEltzZaHWlInabb75OHBJx/GjIuLRwxwgIg4GfsDkhMxFVfvXgO8Df689vjdwUkSsOcx4JEmSJElabNqelKknV3q9wcSa1PMqMZOZd1CK/nZ6X0QM5euIiEcCnwKW72j+X2CHzNwyM5+Umc/JzCdn5mbAXsCZHefuCHx2GLFIkiRJkrRYtXn50pZ9nr88pTjtDsATgf2qtmv5/+3dd5hsVZWw8XeRLihIRpB0ieYEiAio8KkIiigmgglFMYyjYpZRgRkVw+gYRhx1lKCCARFQGQMqKsEIiCIqQVBAkmTwku76/tinvadPV3dXdVf1qep+f89znu6964TV1dXVVav2XhteDpzb1+gG71jgTZQECJQCvPsCx8/mpBGxKmUUzFhCJoGXZ+akNXwy8/SIeBzwPeBxVfe+EfGpzPzJbOKpxbUepcBwL7box7UlSZIkSWrD0CZlMvPyGR76a+DYiHgo8DXgQcDRwB6ZeXafwhu4zFwaEYcAp9S63xMRJ2Tm3bM49auA+9faH5oqIVOL57aI2Ae4CFhUdb8Z6EtSBngNE0cHSZIkSdLcq8+7GFbDHp+6MuzTl2YsMy+gTLv5C3A/4BvVaIyRkZnfBH5a69oceOUsT/uvte9vA/6jh3j+Sin2O2a3iFg02f6SJEmSJGly8zYpA5CZ1wBvqZrrMpojMd7WaL+rmoLUs4h4ILBJrevUzLytx9P8qPb9ImD7mcQiSZIkSdJCN7TTl/ro68CNlHoz+0fEG6tCuiMhM8+OiJOBZ1Zd61GmDR02g9Pt3Gj/JSIW93iOpY32FowfzTNTR1Kmm/ViC+DkPlxbkiRJkpZx+pLmyLxPylS1WX4J7EaZxvQE4PvtRtWzdwB7sqw475si4sjMvLbH82zcaL+52mZjrVkeD0D1s/T08/RpMSpJkiRJkloxr6cv1Vxf+36TSfcaUpl5IaVY8ZhVgXfN4FRr9yWg8VYbwDklSZIkSZr3FkpS5r6173tddnlYHAr8o9Z+ZUT0uiT0Sn2MZ4zDVSRJkiRJmoGFkpTZrvb9La1FMQuZeSXwiVrXisB7ejzN9Y32/pkZs9wOm83PJUmSJElDJyGGfLOmzPww75MyEbEvsGGt67KWQumHIyhFi8fsExHb9HD8NY321rMPSZIkSZIkzcS8TspExF7AZ1mWQ7wH+El7Ec1OZt5EScyMCeD9PZzirEZ7t9nGJEmSJEmSZmZoV1+KiCfM4LAVgDWAhwDPoExbGqt5ksCXMvO2vgTYnk8ArwM2qtpPiYgnd3nsOZQpTOtU7cdFxMMy83d9jlGSJEmSRtcoTA8a9vjUlaFNygCnM7uHWT0ZE8DVwL/NMqbWZeaSiDgU+Fyt+/10UXC3Wh78SODdVVcAH4+I3TLznv5HK0mSJEmSJjMK05diBhssy20G8Gdg98z825xGPjjHABfU2tvS/VLfH2Z8wd9dgaMiYuVeAoiITSJij16OkSRJkiRJywx7Umamyy2PJWeuoCwl/YjM/G3fompZZt4LHDLDY28B9qHU1xnzQuCciHjBVMmZiNggIl4aEacAl1bnkSRJkiRJMzDM05cOn8Ex91CWvL4WOCczL+pvSMMjM0+JiDOBnWZw7A8j4gDKFKhFVfeDgS8Cn4+I84CrgNuAVYG1gAcB680+ckmSJEkaAdZs0RwY2qRMZs4kKbPQvA04YyYHZuaXIuKPwPHAlrWbVgK27/I0N06/iyRJkiRJ6mRokzKaXmaeWU0l2muGx/8qIh4E7Av8C/AYpn5MLAV+A3wf+HJmnjuT60qSJEmS5qeIWJ7ywf9DgAcAqwN3Uj7UvwT4VWbe3l6Ew8WkTIsyc3EfzvHMWR5/L/Al4EsRsRqwA2W57bWAlSlTmP4OXARcWNWkkSRJkqR5K7Jsw2yY4ouITYBnA08GHg/cb4rd742I7wP/nZnfnsG1ZvuTb5aZl83yHH1jUkb/lJm3UkbBSJIkSZI0rYg4Dtivh0OWB3YHdo+IbwEvz8xrBhLcCBjapExE3Ft9m8DmmfmXGZ5nU8pKQQCZmUP7M0uSJEmSNGK2nqT/SsqMi2souYfNgUcyfhXoPYGfRMQTM/PqgUY5pIY5QTHT5bAHfS5JkiRJkjTRucDngf/LzEuaN0bEhsC7gYNq3VsDX4uIJ2Rmr1OTfk6pkdqLK3rcf6CGOSkDLkImSZIkSZpryfC/Gx2e+BL4NnBYZv5qyh0zrwReGRG/AT5Zu2lnYB/gyz1ee8kw1YeZieWm36VVjnCRJEmSJGl4PS8z95wuIVOXmUcCX290v6i/YY2GYU/K9MNKte/vai0KSZIkSZLmmVmMVPlko73rLEMZScM+fakfNqp9f2trUUiSJEmSRoJLYs+JcxvtVSJijcy8qY1g2rIQRsrsXX1N4LIW45AkSZIkScU9HfpW6tA3r7U6UiYintDlrjtExOIeTr0I2ADYjfGVmH/dwzkkSZIkSdJgbNlo3wNc30YgbWp7+tLpTF8zOoDjZ3GNerHgr87iPJIkSZIkqT+e22j/KjOX9niOTSLiKGB74AHAfYEbKcmdc4GfACdk5g2zDXZQ2k7KjJlulaWZrsI0tpBZAKdk5o9meB5JkiRJ0kLhktgDFRGrAgc2ur8xg1NtVm1161XbQ4AXAB+JiM8C78rM22ZwjYEahqTMIJe9DuA24NPAvw3wOpIkSZIktWmLiJ7fXl+XmdcOIphpHAGsX2vfBPzvgK51X+ANwNMi4tmZecGArjMjbSdlDp/itkOrrwl8nPJL6kYCd1b7X0gZAnXHDOOTJEmSJGkUnDyDYw4HDutzHFOKiL2B1za6/63HKUb3AGcApwHnA1dQVlteFdgEeDzwYsqImTFbA6dFxA6ZefkMw++7VpMymTlpUiYiDmXZgKz/ysy/zE1UkiRJkqQFzelLAxERjwSObXR/D/hUD6d5J/DZKUb4nAecEhHvogz2eBvLZuisD5wYEdtl5lDcg8O+JPYgpzZJkiRJkqQ5EBGbAN+mjGYZcznwwl4SJJn53m6mXGXmksx8B/CvjZu2Afbr9nqD1vb0pansWvv+6taikCRJkiRp+D0TuKTHY64bRCBNEbEe8H1gw1r31cBTMnOgMWTmJyNiN2CvWvdrgOMGed1uDW1SJjN/3HYMkiRJkiSNiEuGrYgtQESsRan9snWt+3rgyZl50RyFcQTjkzI7RMQamXnTHF1/UsM+fUmSJEmSpDkVI7INu4hYnVIz5uG17hspI2TmMoH0i+q6Y5anLJndOpMykiRJkiSpryJiNeA7wLa17luA3TPzvLmMJTOXAs3Fg9adyxgmM7RJmYjYPSLurbbbqzlovZ7j/hHxj+oc90TErtMfJUmSJEmSZioi7gucCuxQ674N2CMzf9FOVPyj0V6llSgahjYpA7yUZSOyju+munJTZl4DHF+dZzngZf0LT5IkSZI0b+WQb0MqIlYBvgXsXOu+A3h6Zp7VTlQArNNoX99KFA1DmZSJiOWA3Wpdx8/idF+qviaw+yzOI0mSJEmSJhERKwOnALvUupcAe2XmT1oJCoiIdYDNG91XtRFL01AmZShFgFavvl8C/GgW5zq9OkcAa0XEQ2cXmiRJkiRJqouIlYATgSfXuu8EnpWZP2gnqn/al/H5j2uAC1uKZZxhTco8uPqawG+rojwzkpn3Aud3OLckSZIkSZqliFgB+CqwR637buC5mfnddqIqIuL+wDsb3d/MzKGYBLZC2wFMYv3a91f24Xz1czygD+eTJM2BWLSo7RDmjbzzzrZDmDfu3uVvbYcwL3z3qvPaDmHeeKqvbjUkIm9uO4S+iSzbMBuW+CJieUrZkGfWuu8B9snMb/XxOg8Ets7Mb/ZwzPrAN4H717rvAo7oV1yzNaxJmfvUvr+jD+ern+O+fTifJEmSJEmCzwPPb/QdApwbEYt7PNfVmblkkts2AE6JiN8CXwS+kZkXddqxWo77JZQRMvdv3PyezLy0x7gGZliTMrfUvl+rD+ern6O5DJYkSZIkSZqZF3fo+2C19WpXSl3YqTwc+ADwgYi4GfgdZSWlW4FVgY2BR9I53/GZzPyPGcQ1MMOalKkvTfWgPpyvfo6hWPZKkiRJkiTNyurATl3sdztwcGZ+dsDx9GxYC/3+sfoawOJq7tiMRMTWwGa1rktmE5gkSZIkaZ7LEdkWlguB9wFn0v0MmD9RplItHsaEDAzvSJnzgBuBNar2O4ADZniud9S+vw34xUyDkiRJkiRJy2RmzNF1rgH+DSAilgO2ArYANqTkDlamJGtuBP4G/DIzr5uL2GZjKJMymZkR8S3gRVXXiyLiO5n55V7OExH7UOa3jeUQv10tkS1JkiRJkkZQZi6lzLD543T7Drthnb4EZVjSUkpCJYCjI+LN3R4cEW8EjhlrVud5b7+DlCRJkiTNM21PS3L60oIxtEmZzPwj8CmWJVRWolRXvigi3hoR20fEP5e3joj7RsRjIuItEfEn4EPVMVTHfzozL5jjH0OSJEmSJKmjoZy+VHMw8ChKNeWxETNbAEeM7RAR91Tf1n+WsTltY8f8GHjdgGOVJEmSJEnq2tCOlAHIzHuAPYCTWTZiZizRMratWG31vvp+JwB7WktGkiRJkiQNk6FOygBk5m2ZuTfwKuBylo2Cgcln1QVwKfCyzHx+Zt4+hyFLkiRJkkZY5GhsGn3DPn3pnzLzMxHxOeBpwJOAHYENgLUpyZi/U5a9OhM4DfhOVZFZkiRJkiRp6IxMUgagmoL0zWqTJEmSJEkaWSOVlJmtiFgpM+9qOw5JkiRJ0hAbhSWnhz0+dWXoa8r0Q0Q8IiI+BlzZdiySJEmSJEkwj0fKRMT9gP2BA4FtWg5HkiRJkiRpnHmXlImIXSiJmGcDKzNxtSZJkiRJkqTWzYukTEQ8ADgAeBmw2Vh39TUbbUmSJEmSpuSS05oLI5uUiYgVgL0oo2J2o9THqSdismoHcBtwEnDcnAcqSZIkSZLUwcglZSLiIZQRMS8C1hnrrr7WEzF3Ad+hJGJOycwlcxyqJEmSJEnSpEYiKRMRqwL7UkbFbD/WXX2tj4oB+AnwReCEzLxpDsOUJEmSJM0HLomtOTLUSZmI2JkyKuZ5wH3Gupk4Pan+cHxxZv5lLuOUJEmSJEnq1dAlZSLi/sBLKMmYrca6q6/1ZMxS4PvAUcDxcxymJEmSJEnSrAxFUiYilgP2pCRingYsz+RFe/8IHAMcm5lXVceblJEkSZIkSSOl1aRMRGxNScS8GLj/WHf1tZ6IuRn4KnBUZv5sruOUJEmSJC0ckcO/JPawx6futJaUiYifADuNNauv9VExCZwGHA18Y6GvnhQR9wW2AbYE1gDuCywBbgWuAC4D/pSZd7cUoiRJkiRJ6kGbI2V2rn1fHxVzESURc2xmXtlCXEOjmta1D/AK4InActMccmdEnE9Zgeq7wE8y887BRilJkiRJkmai7Zoy9aWsTwXem5lntxjP0IiIB1OSU9tPs2vdIuAx1fYmYG/gpH7HJkmSJEnzmktia460nZSBZYmZpwIrRMRRwEkLeYRHRDwK+AGwVuOmpZSRRBcBtwArVfs8CHjAHIYoSZIkSZJmqe2kzFjtmKSsuPSUarslIr4MHLPQCvtWtWO+yfiEzC3AB4DPZ+bVkxy3PrAbZXTMHpRRM5IkSZIkaUhNV6NkkJ5KWVHpLpYlZ6i+Xx04CDgzIv4QEW+PiA3bCXPOvRXYqNa+FtghM983WUIGIDOvzsxjM3NvYGPgncD1gw1VkiRJkiTNVGtJmcz8fmbuS5l28wbgt4xfhYmqvTXwXuCyiPhuROwbEfN5FMj+jfYbM/PCXk6Qmddl5nsz84w+xiVJkiRJC0OOyKaR1+ZIGQAy88bM/HhmPopSoPbTlOk69QRNUKY3PRn4EnB1RHw6InZoIeSBiYgNKEtej7kbOKGlcCRJkiRJ0gC1XVNmnMz8NfDriDgYeB7wMuAJYzdXX8emN70ceHlEXDzngQ5Os1jv9XNZ8DgiAtiGUjh4PUpdmuuAK4EzMvO2uYpFkiRJkqT5bqiSMmMycwnwBeALEbEFcCDwYpYlLeoJmq0Yv7T2jhFxRWYuncOQ+6X5+1g9IpbPzHsHedGIWAc4BHghsO4ku90VET8EDsvMnw8yHkmSJElqU2TZhtmwx6futD59aTqZeUlmHgJsAjwDOBm4h/ErN8GyxMyXgL9FxCciYscWQp6Naxvt+1CmbA1MRDwLuBQ4mMkTMlCW394d+Fk1dWwoE3qSJEmSJI2KoU/KjMnMpZn57Wp1oY0oqxT9gZKIadafWRd4DfDTiPhzRLw3Ih7WRty9yMw/A80Vlj4dEQ8exPUi4mXA14HVGjddQlmW+yvA2UBzpM5BwDdNzEiSJEmSNHMjk5Spq1YX+s/MfCiwE3AUcDudV2/aFHg78JuIOH/Og+3dFxvtTYHzIuKLEbFnRKzaj4tExKOATzH+MXAesFNmbpmZe2Xmvpm5I7ABpQBz3e7Av/cjFkmSJEmSFqKRTMrUZebZmXkgJXHwCsrIjrHRM/XpTQE8tJUge/MBSmHdupWAF1BGr9wUEb+JiM9GxEER8YiImMnv8XPVececQUnInNXcsUqCvQp4S+Omt0XEw2dwbUmSJEkabm0vd+1y2AvCvJl+kpm3UxINn4uIB1FWZ3ohZRWhkZGZ10fE04FvAxt22GV54BHV9vKq78aI+AFllM2pmXn3VNeIiF0pqyyNuQXYJzPvmCa2/4yIJwJ7Vl3LUWrRvGzqn2p6EbEeU9e06WSL2V5XkiRJkqS2jPxImU4y8w+Z+WZK7ZnnAqcysS7K0MrM3wCPBv6XUtR4OmtSfs6TgN9HxN7T7P+SRvuTmXlVl+G9vdHeLyIWdXnsVF4D/K7H7eQ+XFeSJEmSpFbMy6TMmMy8JzNPzMw9gcXAu1oOqWvVlKFXUEaDHAKcA3SzzPeWwIkR8fEppjXt3Gg369hMFdcFVSxjVga27fZ4SZIkSZJUzJvpS9PJzCuB97UdR68y8y/AEcAREbE68DhKEuTRwGMpo4E6+VfKtKR31jsjYk3GT/u5Cbiwx7DOYvz0p8dUfZIkSZI08iKTyOEu3DLs8ak7CyYpMx9k5s3Ad6oNgIjYEtiHkoS5f+OQd0TEcZn5+1pfs27LRZk9/zX/odHuR92eI4Gv9XjMFjiFSZIkSZI0okzKjLjMvBh4b0R8jFLo+Pm1m8cK8b6i1rdm4xQ3z+CyzWPWmsE5xsnMa4FrezkmIqbfSZIkSZKkIWVSZp7IzNsi4gWU0SP1Gi+7NXZtZjL6MebNcXOSJEmS5o9RWHZ62ONTV+Z1od+FJjPvAT7W6N4kIlaptW9o3L76DC7VPObGGZxDkiRJkqQFzaTM/HNeh776lKXrGrdtPYNrPLDR7mnakSRJkiRJMikzH93boe+fNWAy80bgktpta0TEg3u8xo6N9i97PF6SJEmSpAXPpMz885BG++bMvL3Rd0aj/YJuT14lcOo1a5YAv+4+PEmSJEkabpGjsWn0mZQZIhGxWrXE9Wwc1Gj/sMM+xzbar42I9bs8/xGN9pcz884uj5UkSZIkSRWTMsNlbeAPEXFsRDy014Mj4jDgKY3u45r7ZeYPGV97ZnXg+EZB4E7nPxh4Zv1UwH/1GqckSZIkSTIpM4yWB14E/C4ifhkRr4uIh0ZEcylrACJi+Yh4UkT8ADi0cfOPM/OESa5zIHBXrb0L8NOIeGyHa6wTEZ8EPtK46YOZeX4XP5MkSZIkjY4ckU0jb4W2A9CUtqs2gJsj4kLgeuAmYBVgfeDhwP06HPt7YN/JTpyZ50TEa4H/YVlyblvgZxFxMXABpV7MxsD2THysfB94V+8/kiRJkiRJApMyw+YO4C/AJh1uWx3YocvzfAl4Q2ZeP9VOmfnZiLgROApYtXbTltU2mc8Dr8rMu7uMR5IkSZIkNTh9aYhk5rWZuSmwDfBuymiUW7o8/HrKqJftM/OF0yVkatc8AdgC+Fh1jsncDXwP2CkzDzQhI0mSJEnS7DhSZghl5rnAuQARsRywGNiKMoLmfsB9KKNqbgGuBs7PzMtncb1rgTdExBspU5geBKwLLKIkaq4AzsjMW2d6DUmSJEkaFaOw5PSwx6fumJQZcpm5FLi02ubiWr+sNkmSJEmSNEBOX5IkSZIkSWqBI2UkSZIkSWpyepDmgCNlJEmSJEmSWmBSRpIkSZIkqQUmZSRJkiRJklpgTRlJkiRJkupGYElsa97MD46UkSRJkiRJaoFJGUmSJEmSpBY4fUmSJEmSpLpk+KcHDXt86oojZSRJkiRJklpgUkaSJEmSJKkFJmUkSZIkSZJaYE0ZSZIkSZJqYgSWxB72+NQdR8pIkiRJkiS1wKSMJEmSJElSC5y+JEmSJElSXWbZhtmwx6euOFJGkiRJkiSpBSZlJEmSJEmSWmBSRpIkSZIkqQXWlJEkSZIkqSYY/iWno+0A1BeOlJEkSZIkSWqBSRlJkiRJkqQWOH1JkiRJkqS6rLZhNuzxqSuOlJEkSZIkSWqBI2UkSUMr77yz7RCkCWLbh7Ydwrzw1Ae0HcH88d2rzms7hHnjaY/ere0QRtryd68Af287Cmm0OFJGkiRJkiSpBY6UkSRJkiSpJpaWbZgNe3zqjiNlJEmSJEmSWuBIGUmSJEmS1BcRsTywJfAQ4AHA6sCdwI3AJcCvMvP2Pl9zRWAnYBNgA+A24Crg3My8rJ/X6jeTMpIkSZIkacYiYhPg2cCTgccD95ti93sj4vvAf2fmt2d53XWBw4F9gLUm2ecs4COZ+fXZXGtQTMpIkiRJklSX1TbMhiS+iDgO2K+HQ5YHdgd2j4hvAS/PzGtmcN09gKOB9abZdUdgx4j4EvDKfo/SmS2TMpIkSZIkaaa2nqT/SuAi4BpK7mFz4JGMr227J/CTiHhiZl7d7QUjYhfgJGClWncC5wCXAmsAjwbWqd3+AuB+EfGszByaMskW+pUkSZIkSf1wLvCvwJaZuVFm7pqZ+2bmczNzG0rNl880jtka+FpERDcXiIiNgBMZn5A5E3hoZm6Xmc/PzN2AjYDXA3fX9nsG8J4Z/WQDYlJGkiRJkqSayNHYhkQC3wYek5nbZOZ/Z+YlHXfMvDIzXwn8S+OmnSl1YbpxOLBmrX0W8OTMvLBxrTsz8+PA8xvHvzEiNu3yWgNnUkaSJEmSJM3U8zJzz8z8VbcHZOaRQLPw7oumOy4itgJeUuu6CzggM5dMca2TgGNqXYuAQ7uNddBMykiSJEmSpBmZxZLTn2y0d+3imP0phYLHnJiZF3Vx3Aca7edHxMpdHDdwJmUkSZIkSdJcO7fRXiUi1pjmmL0b7aO6uVA1tennta77Art1c+ygmZSRJEmSJGmchBzybVjWxJ65ezr0rdShD4CIWJ+yelP9+DN7uN7pjfYePRw7MCZlJEmSJEnSXNuy0b4HuH6K/R/WaJ+fmbf3cL2zGu2H9nDswJiUkSRJkiRJc+25jfavMnPpFPs/pNG+uMfrNVeEap6vFSu0HYAkSZIkScNkyJac7mjY45tKRKwKHNjo/sY0hzVH1vylx8te3mivHRFrZuaNPZ6nrxwpI0mSJEmS5tIRwPq19k3A/05zzBqN9rW9XDAzbwOaS2ev3ss5BsGRMpIkSZIkjb4tIqLXY67LzJ6SG7MVEXsDr210/1tm3jDNoas22v+YweX/AdSXwl5tBufoK5MykiRJkiSNvpNncMzhwGF9jmNSEfFI4NhG9/eAT3VxeDMp0xz10o1/AGtOcc45Z1JGkiRJkqS6UVhxetjja4iITYBvMz4RcjnwwsycyU8zV8cMlDVlJEmSJEnSwETEesD3gQ1r3VcDT8nM67o8zW2N9iozCKV5TPOcc86RMpIkSZIkjb5nMnHZ5+l0mxCZsYhYCzgN2LrWfT3w5My8qIdTmZSRJEmSJGneG4ElsTtMxLkkMy9oIZJJRcTqlJoxD69130gZIdNrrDc32uv2GMuqTEzK3NRjDH3n9CVJkiRJktRXEbEa8B1g21r3LcDumXneDE7ZHFWzaY/HN/e/ITNvnEEcfWVSRpIkSZIk9U1E3Bc4Fdih1n0bsEdm/mKGp72w0d6yx+M3b7R/P8M4+sqkjCRJkiRJ6ouIWAX4FrBzrfsO4OmZedYsTv27RvsREXGfHo7faZrztcKkjCRJkiRJdZmjsQ2ZiFgZOAXYpda9BNgrM38ym3Nn5t+A82tdKzA+8TOdXRrt/5tNPP1iUmbIRcTiiMg52I5u+2eVJEmSJI2miFgJOBF4cq37TuBZmfmDPl3mG432S7uM7UHAY2tdt1MKELfOpIwkSZIkSZqxiFgB+CqwR637buC5mfndPl7qS8C9tfazI2KrLo57W6P91cxc0r+wZs6kjCRJkiRJNZGjsQ2DiFiekix5Zq37HmCfzPxWP6+VmRcBx9S6VgKOrqZNTRbfM4EDal13AYf3M67ZWKHtADStK4DNutz3ucCHau2fA/t2eextvQQlSZIkSRLweeD5jb5DgHMjYnGP57q6ixEshwJ7A2tW7R2B0yLi5Zn5h7GdImIRcBDw4cbxH87My3uMa2BMygy5zLwHuKybfSPi+kbXkszs6lhJkiRJkmbgxR36PlhtvdoVOH2qHTLzioh4NvBdykgZKCsr/T4ifg1cCqwObAOs2zj8W8C7ZhDXwJiUkSRJkiRJIyMzT4+IvYGjWZZ4CWC7auvkeOAVmXnvJLe3wpoykiRJkiQ15ZBvC1xmngo8DPgf4MYpdv0ZpeDw/pl5+5wE1wNHymiciFiLMidvfWAdypry1wHnZeYFbcYmSZIkSRoumRktXvta4NUR8XrKFKZNKe9lbweuBM7NzD+3FV83TMqIiAhgH+ANwGOYZARVRFwJfAL4eGb+Y84ClCRJkiRpEpl5F/CjtuOYCZMyC1xEbA6cADy6i903BN4PvCoi9nTkjCRJkqT5aJiWnJ7MsMen7piUWcAiYnvg25RpSnV/B84FrgcWAVtR5uqNWQycGRG7ZOZ5g49UkiRJkqT5x6TMAhUR6wMnMT4h83PK8mCnZWY29t8S+BDwrKprdeCrEbFtZt7ah3jWY+JyZdPZYrbXlSRJkiSpLSZlFq7PARs02q+cbHmwzLwY2DsiPga8rureCjgY+Pc+xPMa4NA+nEeSJEmSpJHgktgLUERsBzyt1nU2cFCX67W/ETi/1n5tRCzqZ3ySJEmS1KqlORqbRp5JmYXpdY32IZm5tJsDq8TNx2pd6wKP61dgkiRJkiQtFE5fWpieXPv+auDHPR7fXGrs8cDpswkIOBL4Wo/HbAGcPMvrSpIkSZLUCpMyC0xEbMH4WjIXA5tGRC+nWanRnnXB3cy8Fri2l2N6jFmSJEmSupPVNsyGPT51xaTMwrNxo70z8OdZnnOtWR4vSZIkSdKCY02ZhWftAZxztQGcU5IkSZKkec2kzMLTnHrUD84jkiRJkiSpR05fWniub7Q/k5mvbCUSSZIkSRpCkWUbZsMen7rjSJmF55pGe+tWopAkSZIkaYEzKbPwXADcXGs/LiKsCSNJkiRJ0hwzKbPAZOa9wA9qXYuAF7UUjiRJkiRJC5ZJmYXpE432oRGxQSuRSJIkSdIwyhzuTfOCSZkFKDNPB75f61oPODUiNurlPBGxWkTs38/YJEmSJElaKEzKLFwvAa6otR8FnB8Rb42IdSY7qErE7BURnwOuBN432DAlSZIkSZqfXBJ7gcrMv0XEnsCpwAOq7jWBDwDvj4gLgUspRYEXAWsAWwCLgaid6oY5ClmSJEmS5oRLYmuumJRZwDLzNxHxaOALwG61mwJ4SLVN58ZBxCZJkiRJ0nzn9KUFLjOvzcynAk8ATgJu7+KwPwP/C+wBbDe46CRJkiRJmr8cKTOPZObRwNEzPPanwE8jYgVKomVLYG1gNeAOyjSmS4ELM/PqfsQrSZIkSdJCZlJG42TmPcDPqk2SJEmSFp6stmE27PGpK05fkiRJkiRJaoFJGUmSJEmSpBY4fUmSJEmSpJrIJHK45wcNe3zqjiNlJEmSJEmSWmBSRpIkSZIkqQUmZSRJkiRJklpgTRlJkiRJkuqWVtswG/b41BVHykiSJEmSJLXApIwkSZIkSVILnL4kSZIkSdI4w78kNgx7fOqGI2UkSZIkSZJaYFJGkiRJkiSpBSZlJEmSJEmSWmBNGUmSJEmS6pLhL9ky7PGpK46UkSRJkiRJaoFJGUmSJEmSpBY4fUmSJEmSpLrMsg2zYY9PXXGkjCRJkiRJUgtMykiSJEmSJLXApIwkSZIkSVILrCkjSZIkSVJNZNmG2bDHp+44UkaSJEmSJKkFjpSRJEnqwdJFvnzqh2g7gHnkia88qO0Q5o3P/+IjbYcw0i764908/SltRyGNFl9VSJIkSZJU55LYmiNOX5IkSZIkSWqBSRlJkiRJkqQWmJSRJEmSJElqgTVlJEmSJEmqiYRY2nYUU3NJ7PnBkTKSJEmSJEktMCkjSZIkSZLUAqcvSZIkSZJU55LYmiOOlJEkSZIkSWqBSRlJkiRJkqQWmJSRJEmSJElqgTVlJEmSJEmqy2obZsMen7riSBlJkiRJkqQWmJSRJEmSJElqgUkZSZIkSZKkFlhTRpIkSZKkmkiIHO6iLTHc4alLjpSRJEmSJElqgUkZSZIkSZKkFjh9SZIkSZKkusyyDbNhj09dcaSMJEmSJElSC0zKSJIkSZIktcCkjCRJkiRJUgusKSNJkiRJUl0CS9sOYhqWlJkXHCkjSZIkSZLUApMykiRJkiRJLXD6kiRJkiRJNZFJDPmS08Men7rjSJkFKCJOj4gc29qOR5IkSZKkhcikTMsiYnE9QTLA7ei2f1ZJkiRJkrSMSRlJkiRJkqQWWFNGkiRJkqS6zLINs2GPT10xKdO+K4DNutz3ucCHau2fA/t2eextvQQlSZIkSZIGy6RMyzLzHuCybvaNiOsbXUsys6tjJUmSJEnScDEpI0mSJElSndOXNEcs9CtJkiRJktQCR8pogohYDXg8sDGwFnAjcAlwRmb+o83YJEmSJEmaL0zK6J8iYkPgfZSCwvfpsMuSiPg0cHhm3jinwUmSJEmSNM+YlBEAEfE04Fhg7Sl2Wxl4PfDUiNgtM/86J8FJkiRJ0lxaWm3DbIjji4jNgccA21VftwFWq+1yeWYunuG5Z1tMZ7NhWjDHpIyIiJ2AE4FFVdc1wDmUaUtrAI9lfLLmQcBXImLnzBzipwJJkiRJ0lyIiF2Ad1ASMWu1GswIsdCvAE6iJGTOB56Smetn5tMy8wWZ+XRgfeBg4N7aMY8DXjDnkUqSJEmShtGjgN0wIdMTR8oIYB3gR8AzMvP25o2ZeQ/w0YgA+K/aTQcBX+hHABGxHrBuj4dt0Y9rS5IkSVJdkMSQLzkdDHd8NXcCVzCY928/B/bt8ZgrBhDHjJmUEcBNwL6dEjIN/w28jTJyBmCHiFilTysyvQY4tA/nkSRJkiS1427gAuBXwC+rr78FdqIMBOi3JcNUH2YmTMoI4NOZee10O2XmPRHxHeCAqmsF4OHALwYYmyRJkiRp+B0D/E9mLmneUM26UAcmZQTw7R72vbDRXq+fgUiSJEmSRk9m3th2DKPIpIwAft/Dvs0/tNX7FMORwNd6PGYL4OQ+XV+SJEmSigSGvKbM6JSU0VRMyggmJlqmcnejvWI/AqimT007harOIXCSJEmSpFHmktgiM5e2HYMkSZIkSQuNI2UkSZIkSarLHIHpS0Me39zYJCKOArYHHgDclzIT5HrgXOAnwAmZeUN7IU7NpIwkSZIkSRpFm1Vb3XrV9hDgBcBHIuKzwLsy87Y5jm9aJmUkSZIkSRp9W8yg7uZ1VX3P+ey+wBuAp0XEszPzgpbjGcekjCRJkiRJo28mK9MeDhzW5zjmwj3AGcBpwPnAFcCtwKrAJsDjgRdTRsyM2Ro4LSJ2yMzL5zbcyZmUkSRJkiSpzpoyw+ydwGenGOFzHnBKRLwLOBR4GzA2hGh94MSI2C5zOO5AV1+SJEmSJEkjITPf282Uq8xckpnvAP61cdM2wH4DCW4GHCkjSZIkSdLoeyZwSY/HXDeIQIZJZn4yInYD9qp1vwY4rqWQxjEpI0mSJElS3dJqG2YT47tk2IrYDpEjGJ+U2SEi1sjMm1qK55+cviRJkiRJkuazXwA31trLU5bMbp1JGUmSJEmSNG9l5lLgL43udduIpcmkjCRJkiRJmu/+0Wiv0koUDdaUGSGZeTRwdB/Os0vbMUiSJEnS8EpiOFZMnsKwxzd01mm0r28ligZHykiSJEmSpHkrItYBNm90X9VGLE0mZSRJkiRJ0ny2L+PzH9cAF7YUyzgmZSRJkiRJ0rwUEfcH3tno/mbmcMxPs6aMJEmSJEl1mWUbZsMeX59FxAOBrTPzmz0csz7wTeD+te67gCP6HN6MmZSRJEmSJEmzFhEb0TnPsH6jvUJELJ7kNLdlZqcivBsAp0TEb4EvAt/IzIsmiWM14CWUETL3b9z8nsy8dJJrzzmTMpIkSZIkqR/OADbtYr8NgT9PctsxwAFTHPtw4APAByLiZuB3lJWUbgVWBTYGHknnfMdnMvM/uohvzpiUkSRJkiSpbmmWbZgNe3xzY3Vgpy72ux04ODM/O+B4emahX0mSJEmSNOwuBN4HnAn8o8tj/gQcAiwexoQMOFJGkiRJkiT1QWYuHuC5rwH+DSAilgO2AragTIVaA1iZkqy5Efgb8MvMvG5Q8fSLSRlJkiRJkjQyMnMp8MdqG2kmZSRJkiRJqkuGf8npIQ9P3bGmjCRJkiRJUgtMykiSJEmSJLXA6UuSJEmSJNVljsD0pSGPT11xpIwkSZIkSVILTMpIkiRJkiS1wKSMJEmSJElSC6wpI0mSJEnSOCNQU8Y1secFR8pIkiRJkiS1wKSMJEmSJElSC5y+JEmSJElS3dIs2zAb9vjUFUfKSJIkSZIktcCRMhplK9Ubd3Cbta4kSQOXd1zTdgjzQuTNbYcwb9x5y9VthzBvXPTHu9sOYaRdftk9za6VOu0naRmTMhplG9cb53N2W3FIkhaSc7/fdgTSeKf7mOyXp5/edgTzzsbAuW0HIQ0zkzKSJEmSJNXl0rINs2GPT12xpowkSZIkSVILHCmjUfZj4Jm19l+Bu1qKZTJbACfX2s8ELmkpllHnfdk/3pf94f3YP96X/eN92R/ej/3jfdk/o3BfrsT4EgM/bisQaVSYlNHIysybgVPajmMqEdHsuiQzL2gjllHnfdk/3pf94f3YP96X/eN92R/ej/3jfdk/I3Rfzo8aMgnkkK8iMuThqTtOX5IkSZIkSWqBSRlJkiRJkqQWmJSRJEmSJElqgTVlJEmSJEmqy4SlQ160Zdhr3qgrjpSRJEmSJElqgUkZSZIkSZKkFjh9SZIkSZKkuszhnx407PGpK46UkSRJkiRJaoFJGUmSJEmSpBaYlJEkSZIkSWqBNWUkSZIkSaqzpozmiEkZabCuAw5vtDUz3pf9433ZH96P/eN92T/el/3h/dg/3pf9430pzUORZtckSZIkSQtYRDwU+N1Ye6f19me1FdduMaLp3Xr33znz2uPqXQ/LzAvaikcz40gZSZIkSZLqnL6kOWKhX0mSJEmSpBaYlJEkSZIkSWqBSRlJkiRJkqQWWFNGkiRJkqS6pQlLl7YdxdSWWlNmPnCkjCRJkiRJUgtMykiSJEmSJLXApIwkSZIkSVILrCkjSZIkSdI4CTnsNVuGPT51w5EykiRJkiRJLTApI0mSJEmS1AKnL0mSJEmSVJcjMH1p2ONTV0zKSJK6FhEbAY8ANgFWp/wfuQW4EbgUODcz/9FehJK0TETcF9gG2BJYA7gvsAS4FbgCuAz4U2be3VKIkqQFzqSMJA2RiLgM2HSa3e6str8D1wCXABcAZwM/y8wlfY7pIcBBwN6UZMxU7o2I84CvAMdn5hX9jGU+iYj6x1s/zsxd2opFmk8iYjlgH+AVwBOZfrr+nRFxPvAT4LvATzLzzsFGKfVHRJxOeZwDkJnRXjSSZsKaMlIXImK3iMjGdkbbcQ2riLisw/3VaVsaEbdExF8j4gcR8aGI2KHt+EfAIuB+wGbADsALgPcBPwKui4jjImLn2V4kIjaOiK8AvwNez/QJGYDlgW2BDwKXR8TRETFdkqk1XT5Wl0TEzRFxaUScHRFfjIh3RMQuEbFy2z/DsOhwX+4yzf5Hd/k8Mdtt8ZzcAT2a5LF3aUSs1IdzrTOImEdBRDyYkqA+DtiV7l7rLgIeA7wJ+B6wx8ACHAERsXiO/jaPbvtn7TfvO0kz4UgZqTsv69C3U0Q8KDP/MOfRzB8BrFZtGwH/D3hzRJwDvDozf9FmcCNqVWA/YL+I+AHw2pk8RiPiGcCxlOH+TUsoI3OuA24A1gTWp0wPWK2233LAS4B9gVFOXixiYiJszG0R8U3gyMw0UavZ2gx4FfDxtgMZRRHxKOAHwFqNm5YCF1XbLcBK1T4PAh4whyFKGiVLs2zDbNjjU1dMykjTiIi1gGdNcvPLgLfOXTQLxjbAWRHxosw8vu1gWrYf8LNG34qUZMkalKlOjwV2Ah7c2O9JwK8j4qWZ+dVuLxgRLwSOpox6qfsWcCRweqe6MRGxIvAEyt/LgcAq1U2Lur32COpLEkyqeWdEHJWZt7YdyCiJUjvmm4xPyNwCfAD4fGZePclx6wO7UaZn7sH8fr6SJA0hkzLS9F7I5C/SXhwRh2TmPXMZ0AjqlFiA8qZ/deCBwJ7A81n2vLQ88IWI+GNmnjMnUQ6nqzPzsmn2+V+AiNgReCPwnNpt9wGOj4jlMvPL010sIrarzldPyPwN2C8zfzzVsVWhzB8AP4iII4B3UWrRjNJU2TlPgi1gbwYO63LfM4ANa+3JnlM6GbW6RutS7ptD2w5kxLyVMuJyzLXALpl54VQHVcmaY4FjI2JdynPW9QOLcjRcQRm11Y3nAh+qtX9OGR3Zjdt6CWpEeN9J6plJGWl6B9a+X0opAjg23/z+lGTCSXMc06iZLrFwDiVx8J+U+3fdqn95yguWJw02vPkhM8+ijDDaH/g0ZRQHlKTI5yPid5n5u8mOj4g1ga8xPgl5CfCUzPxzj7FcBby6mtrzpV6ObdmcJcEWejHGzLyeLt/8RkQz8d3N72mUvTEijszMa9oOZITs32i/cbqETFNmXge8t38hjabqg6bLutk3Ipp/w0vm+d/mlLzv5plcSubStqOY2rDHp66M0qeX0pyrRg08otb1Aya+YOtUb0YzkJnnAq9sdO8SEeu1Ec+oyszjKEPx6/+pVwE+Oc2hhwCLa+27gef1mpBpxHIqsN1Mjx9mmXlWZj6XUmi5/qnlWBLsYe1EphF1Uu37VYF3txTHyImIDSg1rcbcDZzQUjiSJPXEpIw0tQMb7aMz80xKscAxT6teEKo/TgZurLWXY3xiTF3IzNOA/2h0PyEidu20f0SswcSE2BFVomy2sVwy23MMs1kkwaS6Q4F6raZXRMSWk+2scZrFeq+fyyWto9g2Il4QEQdHxNsj4sCI2D0iVp3+DJKkhczpS9IkImIVSt2CMbcA36i+P5plI2aWp6ww8/5ZXm9T4HHABtU5rwT+lJm/ns15R01mLo2IiynLk45Zd7L9JxMRKwDbA5tXxy+irBZ0GXBmZi6ZfbRD78PAGyh1e8YcRFk6u+kVjF856U7gvwcW2TyTmadFxH8wvg7IEyJi18zsdH9LTVcBHwPeXrVXBN5D9zUmZiUiNqcUWV+XsqLazcDVwNnVdMRh1nw9u3pELJ+Z9w7yotXS44dQas9N9n/qroj4IXBYZv58kPGMqmpBhR0pq/itQ1nh7zrgvMy8oM3Y5oOIWA14PLAxpRD2jZSpyWd0Ktovae6ZlJEm91zGv5n9Su2f17GUUQhjo81exgyTMtXIhfdTEgidbv8T8NHM/FTVPpqSBBqz2Tycg9ystdH1J54R8WDgnZRaP/ebZLd/RMQpwLsz808zC3H4ZeatEXEUJTEzZo+IWKFDcerdG+1vVPUV1L1ekmBERH0dyx9n5i4Di0yj4v2Ux8zYCkLPj4gPDSo5X61Y9DrK/7BJR+VExHnA+4ATMnMY11+9ttG+D/BkSo2ygYiIZ1FeC6w2za4rUZ5fd4+IzwD/4uIAZXQRsA/lOfMxTDJ6PyKuBD4BfNwEQm8iYkPK3+1zKX8TTUsi4tPA4Zl5Y4fblQz/ktNDHp664/QlaXITpi6NfZOZV1Dqy4zZKiKe0MvJq+HO/wX8kEkSMpWtgSMj4uTqBfS8FhHLAVs0ui/t4rjlq/vzd5SCj5MlZKBMLdkHuCAiXj/TWEfE9xvt1YFxtU4iYiXKKK26Hw4yqPmoWsL4qEb3HtWoLWlamXkzcEStKyhLOvddRDyV8tz6PqZIyFQeBXwV+F5ErD7NvnOuqnvVXPL601WSvu8i4mXA15mYkLmEsiz3V4CzgeZInYOAby7054RqVNavgeMpq9lN9X5kQ0qy8vcR8dA5CG9eiIinAb8BXkznhAzAysDrKQsEbDxXsUmayKSM1EE1j7+eZLmoWtmm7uhGu9eCvx9n/AgGKPnuc4ETKS/4zmVZDnwv4DM9XmMUPYMydH7MtZREy6SqqWanUu7P+vPa3cAvKdPOvgycDtxRu30F4KMRcdgsYx5mP2Pi5yiPbLQfTUlU1f1yYBHNb9MmwaRpfAL4S639pIh4Sj8vEBGvAL4NNIuoX1b1Hwd8C/hr4/YnA2dU0yGGzRcb7U2B8yLiixGxZ79qu0TEo4BPMf5/zXnATpm5ZWbulZn7ZuaOlOnIn26cYnfg3/sRyyiKiO0pSz8/unHT34HTKP+rv8HE//uLgTOr+19TiIidKK8j1666rgH+j/J3fSrlvq57EPCV6kMxSS3wj0/q7GWMn0JzTId9vkGZcz/meREx1eiMf4qIvYDXNrpPoExF2iYzn5OZz83MbYDNKP9coYwAeXo31xhFEfEIJr6A/VgXQ70/CexWa98MHAysnZnbZ+azM3O/zNyVMl/9zZQ562PeHRF7MA9l5g2Uufl1mzTaG3Y4tKelZPVP3STBpElVBWoPbXS/v5ruMWsR8f8oSYXla91fAh6amZtl5p6Z+YLMfEZmbgLsyvg3yA9jOD8g+AClFlvdSpTV0b4J3BQRv4mIz0bEQRHxiBm+Cf1cdd4xZ1ASMs0PbsjM6zLzVcBbGje9LSIePoNrj7SIWJ+yytg6te6fU/5/r5uZT6n+Vz87Mx8ObMX4VclWB746pEnBYXISpY7e+cBTMnP9zHxa9Xf9dErtnoMZP5LrcZS/FdVljsamkWdSRmqIiLHCvWOWUuaNj1PNbf5qres+dFGQsRq23FyV5eOZ+bzMvLzDdS7PzOcAR1Zd6zT3GQHrR8TiDtsWEfHoiNg3Io4FfgXcv3bcd4EPTXXiiHge8NJa1+XAozLzo9V0knEy8x+Z+WHgSSxLzATw8Xn8KVFzrnizIOVajfaSuVy5ZD7pMgkmTedYxidCtqEPBX+r0SLHsSwhk8CBmfnCzPx9p2My83TKG7aza9379jpld9Ay83rKhxbNxMyY5Skr+b2ckvz/DXB9RHwtIp4ZEStOd42qBtw2ta5bgH0y845JDhmL7T8pI4/GLEd5U7zQfI4yeqje3ikzv9+pVlFmXpyZe1NGFo/ZioV53/ViHUotsx2rlRjHycx7MvOjlA+o6g6ag9gkdTBf34BIs7EH45fX/GFmNodwj2nWj2jWoelkb2CjWvt84E1dHPcGYFRXITge+HOH7WLgnOr2F1FWG4Ey1PYdwJ6ZefdkJ60+OX53reseYK9uCh9Xn2rWj90SeFZXP83oaSZlmlOV1m60bxpcKAvCdEkwaUqZuZSyqk/de7pJHEzjVYxPfH8oMz/fRTy3Uepw1ZO1zTd0rcvM31Cmxfwv5f/BdNakFEE9iVKzZO9p9n9Jo/3JHlamenujvV9ELOry2JEXEdsBT6t1nQ0c1OUKWW+kvFYa89qFdN/NwE3Avpl5+zT7/TfjazHtUE0HlzTHTMpIE01a4LcpM88G/ljr2j4ipqsfsV+j/YFuVmKokhOzWnZ7RFwEHAYc2cX9sivj63V8KTPPn2znDj7J+GlMe/Vw7ChpPtc71nWwpkuCSdPKzG8CP611bQ68cpan/dfa97dRVhHsNp6/Mn506G7D+Ma4mjL0CkrB+EMoif+lXRy6JXBiREw1anLnRrtZx2aquC6oYhmzMrBtt8fPA69rtA+pko/TqhI3H6t1rcvE4vRa5tOZ2VyRbILqNdZ3al0rAAtuWp00DEzKSDURsR7ja7bcwrJ6LpNp1puZruBv/YXE3ZTaNN06ke4+/RtlW1HqHfw1Ig6eZkpRs/jlV3q5UDXk/Be1rsf3cvwIWaPRbi4rekOjPXSrq4wYk2Dql7c12u+aacHaiHgg46fSnVqNgOlFfXn3RUy9cmCrMvMvmXlEZm5LmaK5B/BOShH9K6Y49F/pUIg3ItZk/MqAN9F77a1m3ZnH9Hj8KHty7furgR/3ePyPGu35+v+6H77dw77Nx3Cz+PfCtnTpaGwaeQt6ST6pgxezbAoNwFer2jFTORZ4D8veiL0oIt6emXc1d4yI+1MKrI35fRfn/6fMvCMifk+ZFz9Kdq3qEkwQEfehTJ95BPAc4IWU38H9gI8A20bESyYZ4tz81PKGiFjcY2y31L5fHBHLdfvp3QhZs9Fu1jxprsSwSkQssq7MjK3RaHf9Ny7VZebZEXEy8Myqaz3KtKHDZnC65vPlX2bwfNl8btyC8aN5hlK11Ph3qI0KqFZZ3IeShLl/45B3RMRxjTo7zWmIF3WqgzKNPzTaC+INcERswfhaMhcDm/ZYu3qlRnuLjnsJoGN9qEk0R3b6oYzUApMy0njNUS5HT3dAZl4ZEaexbPWfdSjTYE7osHuzSO+Ewr5d+Aujl5SZVDVa5Q7K0qvfjoiPU5YVHruvXkB5IfueDodv3Gj/bJbhLEd5Q90cOTKyImIdJr6ZaD7uOtVEeBClEKZ6N10STOrFO4A9WVac900RcWQ30xMams+Xb2b2dWGaRcJHRmZeDLw3Ij5GKTj7/NrNY4V4X1Hra/5d30zvmseM7P3Xo+Zjb2dKXbnZWCj33Uw0Ey1Tadbtm23dKkkz4PQlqRIROwIPrnVdnJlndnl4twV/12i0J6wO1IVbpt9ldGXmeUy8/w6JiE7FUpsFavthvi21uUOHvmay5RwmjuYY2mkJw6zLJJjUtcy8kPEfEKwKvGsGp/L5soNqCtcLgF83btqt0W4O6+jHtMSFMrXRx94cmoejfdvT9lLXLom9YJiUkZZpJgK2jIjsZqOsHlS3W0RsxETN6SDN4bjdmMkxIyUzT2H86I1VgOd12HUQ90VP46lHQLPuzo00VvGqpto1RxntOsig5rFukmBSrw5lfOL0ldWUkF74fDmJquDpxxrdmzRWoulH7a3mMb2MaBhlPvYkaQomZSSgKpz4/Gl37N5ywAEd+psvwJrDobuxUIbsntNoP7bDPtfXvl8CLJeZMcvtsoH9RHMsIu7HxMfhqZPU5/lOo/3siBjEp5vz3bRJMKlXmXkl8Ila14p0ntI5lesb7f378Hx52Gx+riFzXoe++v/o5jTErWdwjQc22r1OQRtVzcfeZ/rw2NuljR9EkgbBpIxU7EMZEt5PL4uJVeyuYvzqSTNZenC6Jbfni+Y0rWYhRoBrat+vzPiVRQRvohRMrvvMJPt+lvHT6RYxfvlcTaPHJJjUqyMYn9jfJyK26eH4axrtmSQV5rNOf6f/rAGTmTcCl9RuWyMiHjzxkCnt2Gj/ssfjR5WPPUmagkkZqWhOXXohsNkMtp/UzrEZjSkg1UpL9akM9+/lRV1EPJQFsloDE0cEdVrBprm8aLMGwIIVEU+mLP9ad3pm/qTT/tUbjmbC5h0RMeui0jOYZjGqekmCST3JzJsoiZkxAby/h1P4fDm1hzTaN2fm7Y2+MxrtF3R78up//ba1riVMrGMzX13A+CLHj4sIa8Jo6GUmuXTpcG/WlJkXTMpowateKD2u1nU98JXMvKzXDfhi4/SdCv6e1mi/osM+kzmoh31HVkQsz8RCs1d02PW7jfbLBxPRaImI/YBvMP45/g7gNdMcegRlFawxKwEnRMSMRyBFxB7Ar2Z6/KjoNQkmzdAnGP9c+JTqsdeNcxg/jeRxETEvRl5GxGrVEtez0fz/+sMO+xzbaL82Itbv8vxHNNpfzsxmnbl5qRot+INa1yLgRS2FI0lDx6SMNDFx8rWq6N9MnADcVWs/OyLWaOzzGaBeGf9funlhHBGPBF49w7hGzcuYOFKmmcwC+D/GDyffPiKay5ovGBHxuIj4GnAc46fj3Qu8tFrFZVKZ+XdKQeX6Y3gr4KyI2LnHWDaIiCOBbzFx1bF5ZRZJMKknmbmEUvS37v10UfS0WpHlyFpXAB+PiBX6F2Fr1gb+EBHHViNKexIRhzGxHtRxzf0y84eMrz2zOnB8oyBwp/MfDDyzfirgv3qNc8R9otE+NCI2aCUSSRoyJmW0oEXEikz8tGbCC7FuVVNA6gVTVwb2b+xzaeMaKwHfnWqaSJWQ+Q6luOO8FhF7MXEVjL8wcVTM2IoZ7250fyoinj2D6z45Ijbv9bg5sH5ELG5sW0bEthHxpIh4WUR8OiIuoExPeG7j+NuBfTPzq91cLDN/TvnEuJ443BD4aUScHBFPnewNSESsGBH/LyI+QUmWvZp5/H9mtkkwaYaOYXzx6G3pvp7Whxk/WmZX4KiIWLmXACJik2oU3DBZnvL//HcR8cuIeF1EPLRDbTegjMisnkN/wMRE148z84RJrnMg4xPXu1CeHycUo4+IdSLik8BHGjd9MDPP7+Jnmjcy83Tg+7Wu9YBTJ1mpclLVqKj9p99T6oO2l7p2SewFYz58OiLNxjMYX6PlL8CZszznccBetfaBjP90EuD1wJOAsU+JHgD8OiKOAU4C/lz1bwY8C3gJ5e/1ekpNmifNMsa5tn5ELJ7ktpWBdYBHAs9h4lLMS4HXVJ8QT5CZx0XEkyija6Akub4eEccBH8nMjnP2qylSj6D8rvYBHlxd+9Juf6g50lxuvRenAa/NzD/2clBmHhMRNwNHM34J172qbUlE/I6yGsmNlJEw61NG1XSqE9CpHtCw6vRYXYFyP6wBbEpZCWxnJtaggJIEO2CKN3QLyVR/91OaT6ug9Vtm3hsRhwAnz+DYWyJiH0qSe+w14AuBbSPivcDXJ3uurUY17A7sDTyNMl33/2bwI8yF7aoN4OaIuJDy//MmYBXK89XDmVgDCuD3wL6TnTgzz4mI1wL/w7Kk87bAzyLiYkrCbAmwMWUabvO19veBd/X+I80LLwF+AYwlYh4FnB8R7wc+n5nNVZqAkoih/H9+JmU05w3M4gM0SRo2JmW00DWnLh2fs6+YdQpwG8s+Od8mIh6VmeeN7ZCZN0TE7pQ3zetW3StU8XSqQwNwN6WoYPMTolFIkc80sXAPcGBmfnua/V5FWbp071rf/sD+EXEdJZH1d0qC536UJNiDKQmh+eY24JvAkZnZLErZtcw8qRqh9WFKsqxuZZa94ZnKPcDngcNnGkcL5jwJNo/N5r6cdjrOQpaZp0TEmcBOMzj2hxFxAPA5Sm0PKM+HXwQ+HxHnUVYKHPs/thbwIIa7yPwdlA9VOo0YWh3YocvzfAl4w2TJgTGZ+dmIuBE4ivGj5Lastsl8HnhVZt7dZTzzSmb+LSL2BE6l/B+G8r/7A8D7q+TZpZSiwIsoifAtgMWMf064YY5ClqQ5YVJGC1ZEbAg8tdE9609eMvMfEXES5dPHMQfSWF44M8+PiJ2A/wWeMM1pLwf2ycyfR0QzaXNrpwPmgR8Br8/M3063Y2beHRHPAd5CSQDUky3rAt0UwrybMsphFNxN+ST2BuBqylShC4CzgbMn+6S7V5l5OfDcqubRKyhJr42nOeweSkHRL1OSnFf3I5Yh1pckmDQDb2PiakBdycwvRcQfKYmzehJhJSYWWZ/MjdPvMjcy81pg04h4NLAn8HjKiLZOI2GarqfUg/t8Zna9RHVmnhARPwEOoXxgss4ku95N+X92eGY2V8BacDLzN9Xv6QuMXwEsKKMPO41AbBqax54k9YNJGS1kB1DmoI/5fR/neB/H+KTMCyLiLc03y5l5EfDEiHga8HzKKlAbUIZEXwWMvWj+RrWcNkwsmnozo+1u4BbKSJYLKCv1fK26b7pWjXD6YEQcS5keth9lqslUbgV+CnybsuLW33uMve8yc3HbMTRl5u8o9+nrq5WYHk65b+9H+T9yM+VF8iXAuf1KCg2ROUmCSb3IzDMj4hTGT5ft5fhfRcSDKFN1/gV4DFO/LlxKGXX4fcrKQefO5LqDVMV0LkBELEcZYbEVZQTN/YD7UEbV3EL5Wz6/Sj7P9HrXAm+IiDdSpjA9iPJBwCJKsucK4IzMnK8fnsxIdb89NSIeD7yRUmT5vtMc9mfKCk5fZ3xtGmlwliZDPyB96ZDHp66Ea5tLoyUi/sqy+djXZ+a6U+2/kEXEZsA2lBfJa1LeVNxKSXj9AbioWqpTkha0qm7HDpT/L2tRRhzeRkmYXwRcmJm3tBeh5qtqBbDtKKO21qbUJruDkvC/lPLYm++jLjUEqtXbfjfW3nGlPVl1uTXaC6gLty29ibPu+la962GZecFk+2s4OVJGGiFVkqG+UkHHIrYqMvPPLCuaLEmaRDWawxEImnPVSoo/qzZJWnBMykij5dWN9tmtRCFJkiTNZ7m0bMNs2ONTV5abfhdJwyAiHkWp6zEmKatlSJIkSZJGkEkZqSUR8S8R8dZqHv90+z6JMqx8pVr3NzPzkoEFKEmSJEkaKKcvSe1ZFzgUOLRaQeMnwG8pKzZAKXa3DWUZ4l0bx94AvGaO4pQkSZKkoRURKwI7UVbc24BSrP4qysqgl7UY2rRMykjtuw9lSdJ9u9z/BuBZmXnl4EKSJEmSFq5MyCFfcnqYF1KOiM2Bx1BWV3sM5cPm+gyByzNzcR+usy5wOLAPZfXATvucBXwkM78+2+sNgkkZqT03UOrCRA/HnAq8PjMvHkxIkiRJktS7iNgFeAclEdMxQdLn6+0BHA2sN82uOwI7RsSXgFdm5u2Djq0XJmWklmTmxyPi68DulCeKh1CG260BrEwZcncDcDFlatPJmXl+O9FKkiRJ0pQeBew2FxeqEkAnMb7mZgLnAJdS3lM9GlindvsLgPtFxLMyh2fpKpMyUouqKUifqzZJkiRJmm/uBK4AtujHySJiI+BExidkzgRekZkX1vZbBLwS+E9gxar7GcB7gEP6EUs/mJSRJEmSJKkulwJDM5iis+EZ7FF3N3AB8Cvgl9XX31KK8P6oT9c4HFiz1j4LeHJmLqnvlJl3Ah+PiL8A36jd9MaI+HRmXt6neGbFpIwkSZIkSZqtY4D/aSZHACJ6KaM5uYjYCnhJresu4IBO1xyTmSdFxDG14xZRVsF9WV+CmqXl2g5AkiRJkiSNtsy8carkSJ/sDyxfa5+YmRd1cdwHGu3nR8TK/Qtr5hwpI0mSJElSTS5NMoZ4zWkgh3lN7MHZu9E+qpuDMvPCiPg58Niq676UosSn9DG2GXGkjCRJkiRJGmoRsT7wyFrXPZQCv906vdHeY7Yx9YNJGUmSJEmSNOwe1mifn5m393D8WY32Q2cZT1+YlJEkSZIkScPuIY32xT0ef8k052uFNWUkSZIkSapzSexhtGWj/Zcej28ugb12RKyZmTfOIqZZMykjSZIkSVLNHdwOQ15H9w4mzNzZYgZLT1+Xmdf2J6KBW6PR7inuzLwtIpYA9VWXVgdMykiSJEmSNCzOn1B+ZCScPINjDgcO63Mcg7Jqo/2PGZzjH4xPyqw283D6w5oykiRJkiRp2DWTMktmcI5mIqd5zjlnUkaSJEmSJI2amUwwG7pJaU5fkiRJkiQtdJcwccnlUbEWsCbwV+CuHo+9rv/hDMxtjfYqMzhH85jmOeecSRlJkiRJ0oKWmUuAC9qOQ1Oal0kZpy9JkiRJkqRhd3OjvW4vB0fEqkxMytw0m4D6waSMJGleiIjLIiKr7bJp9j2stm9GxC5zEuQCFBGLG/f10S3FsSgito+I/SLi4Ij4t4h4S0S8PCKeGRGL24hrOj0+rg9o3NcHzE2UkiTNiYsa7U17PL65/w2Z2epy2OD0JUkaCtWbren+sSylfEJwE3Ah8Evg65n524EGJ42oiFgE7AfsDzwRWGma/a8HvgN8ETgtM+8deJBDrkqivWQOLrVZZl42B9eRJI2uCxvtLXs8fvNG+/eziKVvHCkjSaNjOUoRt82ApwGHAudHxI8j4sGtRqYZGZZRJPNRRLwY+DNwFPAUpknIVNYBXkhJzFwUES+MCF8rSZI0HH7XaD8iIu7Tw/E7TXO+VvhCQ5JG3xOAcyLiWW0HIrUtIlaLiG8AxwAbdNjlcuAnwNeBrwE/pay40bQZ8AXgrQMKVZIk9SAz/wacX+taAdi5h1Ps0mj/32xj6genL0nScNoP+Fmjb3lgbWAbynSCHWq3rQwcHxGPz8xfzU2I0nCJiPsBpwGPadx0HfAh4OTM/NMkx24M7AkcCGxbu2nlAYQ6St4MHNblvmcAG9banZ7HJnNFDzFJkhaubwCPqLVfCnxvuoMi4kHAY2tdt3dz3FwwKSNJw+nqSeorXAL8AvifiHgt8HEgqttWBv4LePycRDjCMvMwun+jqdFxFBMTMp8G3pKZt051YGb+FfgU8KmIeA5wBLDVQKIcIZl5PXB9N/tGxD2NrsmexyRJmqkvAe+kfFgJ8OyI2Cozm0WAm97WaH+1Wga9dU5fkqQRlZn/DXyk0b1zRDy6jXikNkXEwcCzG93vzsxXTZeQacrMr1NGpJ3Yr/gkSdLsVcmXY2pdKwFHR8SkI1sj4pnAAbWuu4DDBxLgDDhSRpJG2/uA1wEr1vp2A85tJxxp7kXEOsB7Gt0nZOZ/zPScmXkb8JyIaK7UIEmSJhERG9E5z7B+o71CRCye5DS3VSM1J3MosDdlAQyAHYHTIuLlmfmHWiyLgIOADzeO/3BmXj7F+eeUSRlJGmGZeUNE/Ap4XK37Ib2eJyLWo8yz3YCyAs1twHcmq79RO27l6tqbAOtSplJdB1wM/Cwzm9MZehYRjwAeWcX2D+BK4NzM/PNszz1bEfEAYHvKz742Zdnym4A/Aedl5k0txrYW5UXK+pTf6RLK7+a8zLygD+dfnlJcbyvKz/93yu/mzBZ+7tcD9dUXbgRe1Y8TZ+al3exX/S08BHggsB6wKnBHFcsfgV9n5l39iEn9U40sfCClFs5S4CrgrGo6Wz/OP/DnSEkaMmcAm3ax34aUVRI7OYbxI1vGycwrIuLZwHdZtrriTsDvI+LXwKXA6pRRr+s2Dv8W8K4u4pszJmUkafT9lfFJmXWaO0TEZSz7B3l5Zi6u+h8PvBvYlWVzc8ccTEkuTBARjwX+DXgysMokcd0SEccD/56ZV3XzgzSusR+l7svWHW7OiPgpcERmfmcG5z6M8inLmF0z8/Quj70v8BpKQdgHTrHr0iphdhxwdGbeXDvHZXR+wfKSiHjJFOd8aWYePUVsAewDvIFSW6XjNOWIuBL4BPDxzPzHFNfrdOwi4O3Aa+nwWAPujIiTgEMz84+9nHsmImIl4F8a3Udl5t/n4NqbA8+nLFH/WKZedntJRJwIfCAzz59iv3ktIjYELmPZa9BLgS0zM3s8z57AN2tdJ2Tm8xr7LGb8C/5jMvOAKqH4aspjuNPfcEbEWcBbM/OsXuKqXXvgz5GStJBl5ukRsTdwNMsSLwFsV22dHA+8IjPvHXyE3bOmjCSNvph+lw4HRfw7cDrlTUMzITPZMfeJiOMoK6o8g8nfbADcD3glcFFEPLeHuFaq3rweR+eEDJSf+QnA/0XE+7s992xFxNMpbyg/yNQJGSj/Y7cHPkoZYjtQVYLg15QXHI9l6v/xGwLvp3yi9NAerrExcB4lWdYpIQOwiJIYOrd6sTRoj2XZ8OUxnxn0RauRSJdQCgI/nqkTMlAKce9PWb7+LQMOb2hl5pXAybWuzSlTLnvVHAn1qW4OiohVge9QkpKT/Q0H5RPXMyKipylwc/EcKUkqMvNU4GHA/1BGpk7mZ8BzM3P/zLx9ToLrgSNlJGn0bdRoT7tSSkS8gfFDNy8HfgfcAtwfmFAsOCLWpbyZ2aZx0z8oNWyuAu4FNqaM0hirc3Mf4KvVPN/PTxPXcpTiqk9v3HQ38HPK9JhVKUshblzd9raI6Gp1mNmIiDdSllVuJjtuA84BrgGSMo3pYZT7cU5ExPbAt5mYKPk75XdzPSVZslUV25jFwJkRsUtmnjfNNTagJPGaNVZuoqwI9vfq+ttThgyvAnyZslTlID2x0f7bXIzQoXPS66+UqUo3U6aLrQ48CNiCZcnT5YEPRkRm5n/OQZzD6JPAc2rtV1GGoHclIjYB9qh1/Qn4UZeHH09JRI85nzKVCGBLxi+zGsA7I2L5zDyki7gG/hwpScNubDT2HF7vWuDVEfF6SkJ9U8rU7dsZoinvUzEpI0kjLCLWBLZtdF84zWHrUZILAGcDB2fmzxvnXURJLoy1l6O8mam/2biKsiThcZl5Z+P4NYC3UpYfXI7y5uaTEfHrzPzNFLG9ifEJmQQ+Rhne/89PQKppOrsBR1KSBO+lJG4Gohrx8Z+MH5X0e8rP/63MnHDtiNgaeC7lk/CmnSn/gzcCflrr/zrw5ilCmZB8ioj1gZMYn5D5OSXpdlpzWkhEbEn5/T+r6lqd8oZw22lWKfos4xMyt1B+x0fVa6VUj52XU0birAr89xTn7IedGu1fDPh6dXdT7vsTge9l5g2ddqpGMb2F8lgYewwdERHfzczfzkWgwyQzfxQRv2dZ/as9I+IBPUzhOYjxSbH/6XL6014sG1V1GvDaZgIvIh5IeczWEzfviIgfZeb3JzvxHD5HSpI6qF6LdJugHypOX5Kk0fZ2Jk6bmPSNQ2UVSkLgW8AuzYQMQGbe2XiD9CbgSbX2OcAjMvOo5puN6vibqk+W96EkVqBM3/ivyYKqak38e6P7NZl5cD0hU50/M/O7lFo6f6LcB/ed7NyzUa3sczTjEzInAttl5jc6JWSqGP+Ume+jjJL4VuO2KzLzMuCKxmG3ZeZlU2y3dbjU5yhFkOvtnTLz+53eqGbmxZm5N/DxWvdWlBpCHVXF9OrJstuAJ2fmp5vFa6vHzieB3SmFbptTi/ptw0Z7uqRkv9wCLM7M52fmlydLyEApFpyZrwZeVutegfJ3tVDVpxutQEnkTSsiVmD8/biE8UujTmXssfhV4KmdRlRVfbsDX2vc9Jnq2pMZ+HOkJGl+MikjSSMqIl5F+fS97qzM/HUXh18HvKSb1WAiYpXGdW4G9uymkGpmnsD4N1+7RkRzaP+YV1LelIz5emb+zzTnvxZ4IWXVlEE5mFL7YcxvgP27LZCbmffk1Ms6zlhEbEcpMjvmbOCgLgvYvZEydWPMa6tRLp28odF+R2b+cqqTZ+aZlCLSg7ZWo33THFyTzLyr1+KsVZHmeoLu+RGx4iS7z3fHUJJ7Y15eFeCdzrMYn4T8ylQJsQ6uAA7MzEmfM6q/n5dRhr2PWUwZaTPBHD5HSpLmIZMykjSc1o+IxY1ti4jYLiIOiogzKC/k66M37qS80e7GZ3p4I7Mf45cT/Ghm/q3LYwE+3Gh3fGMDvLjRPrTjXg1VcuCUHuLpWjUloTn96A2dPvluyesa7UOmerNZV73x/Fita13Gr+IF/HMFm8fXuq6my6KqlNE413W570yt3WjfNODrzdbXa9+vAjyqpThaVU2V+0Kta2Mm1pLqpFngd8rEbQcfmGTE2TjVPh9odB8wye5z9RwpSZqHTMpI0nA6nrKUa327GPgl8Gkm1tG4E3hBp6lIkziph1ie0mh/pYdjycxLgb/Uuh7f3CciNmL8EtHnZ+YFPVzmS73E1INHMv5N/x+zy6Wz50i97sXVwI97PL4593rC74ZS/6buq90uJVlN7fpqjzGNvIhYMSLWiohNmslVJtY+enALIQ6LTzbaneov/VNVD+n/1brOy8yf9XC9pBSf7tbxLJtaBLBTVc+qaeDPkZKk+ctCv5I0+s4CXpmZv+ty/3sZP21lOvU35XcBd1ZvLntxA7BJ9f0WHW7frtHuNrk00/27tWOjffqArtOziNiC8dM4LgY27fyecVLNekSD+t38S4/H9OIG4AG19uoDvFZHEbEZpTbI/6OsbrXB1EeMM+iaO0MrMy+IiB+zbAWt3SNi08y8fJJDXsX40YG9jpK5pJephJl5fURcyrK/i7Uoxa4vaew6F8+RkqR5yqSMJI2OpcCtlOkZf6CsMnPidEsZd3BzN7Vk4J/Td+pveFdi4huSXjVrgMDE5aMv6uWEmfnXiFjC+Jo0/dB8c93L6J1B27jR3pkyomo2+v67oRRiHqS/M/4xusaAr/dPEbE28EHKtJaZjj6e8yTSkDmSZUmZ5SgrK/1bc6eq3tEBta5b6X2E3EweixcxPkmyHrXnwDl8jpQkzVMmZSRpOO06wGkyUy173LQm/Z/qutok16m7ZQbnvZn+J2Wa9Upu7LhXO5qx9cMgfjc3zzCWbl0FPLzWnpPpQBGxAfCDPlxvoU8l/wbwN5YlQF8WEYd1WNXseYx/zH+xm9owDTN9XqlrJkzm6jlSkjRPLfQXApKkqTWnt8yVCUs5D4lhimsQv5tu5j4N030AcGajvf0cXfd/GZ+QuYeSYHgVsANlJNNqwIqZGWMbsOscxTcSquTLZ2pd6wPP7LDrbAv8Qn8eu81ztPUcKUmaJxwpI0maSnNJ1z9l5gMHcJ3mCJSZTOkYxDSQZv2JYZpW0IztM5k5ZaHUGZrt72bQ03OaxY0fEBFbZ+bApk1FxPaMX4r8euCpmXlOF4ffb/pdFpzPUKYsjb0ufRVwwtiNEfFQxhc3Pysze6mLNaYfzyvNv4e5eo6UJM1TjpSRJE2qqj1TfxOyWUSsOIBLXdNob9XLwRGxMf2fugRlWkXdQwZwjZlq3mdbz9F1evrdMLi4xvyciW+UDxrwNZsjOd7aZUIGxtcfEZCZV1FGGY35fxFRf5y9unFIt0uyN83ksdh8vF9bb8zhc6QkaZ4yKSNJms5Zte9XBHYZwDV+1Wjv0OPxj+1XIA3NqTFP7LjXzM1mOsUFjK938biIGEQtimH93QCQmXdSisXWvTQiBjmqqflG/Vs9HNtc0UtF/XcYVIm1iLgP8MLabX8HvjbDa2wREet0u3O17+a1rhuASzvsOhfPkZKkecqkjCRpOt9ttF/R7wtk5hVAfRnch1dTFrr1gj6HNOZ84Lpa+8ER8YQ+nv/ORntRtwdm5r2UQrP1Y1/Uj6Aazmi0nxcRy3dzYDVi4Pn9D2mCjwH/qLXXYmKiZkYiYvMO3Ws02l0VM46I1YFnzTKkeakqbF5f3eyAasWl/Rk/heioKhE3EwHs28P++zG+ztKZmdkpkTrw50hJ0vxlUkaSNJ0vUJbhHvO8iHjSAK5zbKN9eDcHRcRjgL36Hw5Ub8Cab+4/GhH9Ku55U6PdXIJ7Op9otA+tVgXqm8y8DPhprWt9Jk4nmczrgHX7GU8nmXkdcGije5+IeMdMzxkRq0bECcCLO9zcnC71oC5PexiurDOV+t/aOsBzGV/gN4FPz/Iab4uIVafbqdrnrY3uYybZfa6eIyVJ85BJGUnSlDLzJuBDje4TImLnXs4TEctHxLOnmFbyaWBJrf2ciJiycG1ErAd8kcH+P/s4499wPRr4YvUp/rQiYoXJpkxk5hLgslrXYyJijW4Dq0YXfL/WtR5wakRs1O05qhhXi4j9p9jlY432+yJiu2nOuSPw773EMRuZ+SHg5Eb3+yLiv7t5E14XEc8GzgGeM8kuv2m0397FOQ8EXt9LHAvQF4Bba+33AtvW2qdl5sWzvMZGwOciYtLnjOq2z1X7jrmMiY8vYE6fIyVJ85BJGUlSNz4IfK/WXgM4PSI+GRGTrjQSEStGxI4R8QHgEuDrTLL6TGZeCby70X1kRHw4ItbscO7dKLUctgbuAm7v4efpWmbeQBktUZ+28DzglxGxV0R0XMkwIraqRmpcDOw5xSV+VPv+PsB3ImKfiHhYRGwWEYtrW6fkwkuAK2rtRwHnR8Rbp6qfUSVi9oqIzwFXAu+bbN/M/Dpwaq1rNeC0iDioOWooIlaKiNcA36l+nuaokkF6CSWZUvcvwCUR8eaI2HKyAyNi44h4VUT8ivI4naqg8QnAvbX2fhHx2YhYu8N5N4qIz1KW0A7GT4dTTWbeSknMjNm0sctMlsGuG3ssPh/4v4iYUPi36vsOE6fdvTIz75ni3AN/jpQkzU/ReWqsJGkuRcRljH8Dsms1CmIQ5788MxfP4ByrU96YdypUeiXwO0ohzOUobyo2okzraK5Eslk1JabTNZanfBr99MZNdwM/q65zX+CRwCa1298GvIYuf8aIOIzx012mvb8j4g3Ah5n4gcatwK8pq7IksDbwcOD+tX1emplHT3LeRwG/ZNlywFPpeJ6IeCTld9Nc2SeBCynFSW+m1J1ZA9gCWMz4ehnT3WcbUAofb9a46SbKCkg3UH72x7KsBsjdwMsY/0b7mMw8YLLrzFZE3I8yeuoZk+xyGaV+0XXAUsp0rAcAkyVs3paZH+xwnSOZOI3rTuAXwF8pq4FtTnmsjt3PVwNvYfz9cXhmHjbFz3MZ3T+uDwCOqnVN+rgbhH48j0XEQxhfW2bMVcCm0yRGmudaDPy51nUsZVpUfTnz8yiJ06A8Bh7Z4VRHZOYhXVxv4M+RkqT5p5sXgJIkkZk3R8QuwPsp0zDqxV43rLbp3MHE4rb1a9wbEc8Bvsz4gqgrAo+f5LAPZ+YHq9EZA5OZH42ISylveuvTC1ZjFqutZOZ5EXEQpZ7GjJb1zszfRMSjKW/2d6vdFJRlvLtZynvKES2Z+bfq9/89oP7J/xrAUzsccidl1Zzm6k0DlZm3AHtFxEspo3/Wb+yyuNqm8yfgnZk52Uo/b6AkBusJxEVM/ji9jDJiauA1dkZZZv4+Ik5n4t/U//aSkJns9JRCvycDu1Z9j6q2yfZ/X2a+s6uTz8FzpCRp/nH6kiSpa5l5d2a+iTJl6FPANV0c9nfgROAA4P6Z+bdprnFnZu5NWVHpT1PsehbwjMx8czex90NmnkJ5Q/8uxn8C38k9lJElr6ZMSZjqvEdRPjF/N3AaZTrS7fSwZHZmXpuZTwWeAJxEd9O5/kyZVrMHMGWNmOoaf6GMJDgcuH6S3e6i/LzbZuYJXcQwENV9uhlwIGWVqru7OOxa4GjgKcCDp0jIkJl3UQpMv4EyimMyf6Ukhx6ZmZ1GgGiiTzba9wKf7ceJqylSuwFvpIyQ6bgb5fll524TMrXzD/w5UpI0vzh9SZI0KxHxYOARlKkra1CSEbdQ3oz+Abh0kmVkuz3/IymfZK9PWfb4KuCczLx0VoH3QURsQSlEui7lZ7+LMj3hIuC8atRGW7GtQEm0bEn53axG+RT+Zsp0pgsz8+pZnn9nSu2VdSgjba4EzsjMuawj05WIWJnyONqCMrXsPpQRCTdRkjHnZeblkx0/zblXALapzr82pWD11ZQ3/b+azeN/IYqIpzC+PsvJmfmsGZxnMeOTpxOmzkXEtpSRXw+gTGe7CjirSkD2xaCfIyVJo82kjCRJkoZGRHyVUkx7zO6Z+d0ZnGcx0yRlJElqm9OXJEmSNBQiYn3G15O6hPGjZiRJmldMykiSJGlYHMz41Yg+6dQeSdJ8ZlJGkiRJrYuIBwL/Wuu6Cfh8O9FIkjQ3XBJbkiRJc6oqvDy2XPlawA6UVc1Wqe32ocy8ea5jkyRpLpmUkSRJ0lzbAfjRFLdfAHx4jmKRJKk1Tl+SJEnSMPkr8MzMvLPtQCRJGjRHykiSJKlttwN/Ak4GPuq0JUnSQhEWtJckSZIkSZp7Tl+SJEmSJElqgUkZSZIkSZKkFpiUkSRJkiRJaoFJGUmSJEmSpBaYlJEkSZIkSWqBSRlJkiRJkqQWmJSRJEmSJElqgUkZSZIkSZKkFpiUkSRJkiRJaoFJGUmSJEmSpBaYlJEkSZIkSWqBSRlJkiRJkqQWmJSRJEmSJElqgUkZSZIkSZKkFpiUkSRJkiRJaoFJGUmSJEmSpBaYlJEkSZIkSWqBSRlJkiRJkqQWmJSRJEmSJElqgUkZSZIkSZKkFpiUkSRJkiRJaoFJGUmSJEmSpBaYlJEkSZIkSWqBSRlJkiRJkqQWmJSRJEmSJElqgUkZSZIkSZKkFpiUkSRJkiRJaoFJGUmSJEmSpBaYlJEkSZIkSWrB/wcesXNUJWLefgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1200x1200 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the overall confusion matrix\n",
    "\n",
    "cmap='viridis'\n",
    "fig = plt.figure(figsize=(4,4), dpi=300)\n",
    "ax = fig.subplots()\n",
    "im_ = ax.imshow(confMatTot*100.0, interpolation='nearest', cmap=cmap, extent = (-0.5, ncalls-0.5, ncalls-0.5, -0.5), vmin=10, vmax = 50)\n",
    "\n",
    "fig.colorbar(im_, ax=ax)\n",
    "ax.set(xticks=np.arange(ncalls),\n",
    "               yticks=np.arange(ncalls),\n",
    "               ylim = (ncalls-0.5, -0.5),\n",
    "               xticklabels=callNames,\n",
    "               yticklabels=callNames,\n",
    "               ylabel=\"Actual Call Type\",\n",
    "               xlabel=\"Predicted Call Type\",\n",
    "               title='%d Unit Good PC PCC %.0f %%' % (numUnits, np.mean(pcc)))\n",
    "\n",
    "plt.savefig('/Users/frederictheunissen/Desktop/confMat%dUnitGoodPCJulieV2.eps' % numUnits)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n",
      "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x1200 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(4,4), dpi=300)\n",
    "ax = fig.subplots()\n",
    "\n",
    "x = np.arange(len(callNames))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "rects1 = ax.bar(x - width/2, confMatFits, width, label='Fits')\n",
    "rects2 = ax.bar(x + width/2, confMatCount, width, label='Tests')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Number')\n",
    "ax.set_title('Fitting and Testing Data Size')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(callNames)\n",
    "ax.legend()\n",
    "\n",
    "plt.savefig('/Users/frederictheunissen/Desktop/dataSize%dUnitGoodPCJulieV2.eps' % numUnits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}