decodingCallTypesNaiveBayesPart3Julie-PerRegion.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### decodingCallTypes 3 uses the information from part2\n",
    "## Copy of decodingCallTypesNaiveBayespart3Julie-PerBird and modified to do the per region"
   ]
  },
  {
   "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",
    "import itertools\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",
    "# rootPath = '/Users/frederictheunissen/Google 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": [],
   "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 argList10 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": [
    "# Read the histology files for these 4 birds\n",
    "for i, bird in enumerate(birdUnique):\n",
    "    histListBird = pd.read_csv(rootPath+'histology/List_h5files_' + bird + '_Histo.txt', \n",
    "                           sep='\\t', header=None, index_col = False,\n",
    "                           names = ['h5file', 'Region', 'dlat', 'dL2A', 'Hemisphere', 'headstage'])\n",
    "    \n",
    "    if (i == 0 ):\n",
    "        histList = histListBird\n",
    "    else:\n",
    "        histList = pd.concat([histList, histListBird], ignore_index = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "regionName = []\n",
    "zoneName = []\n",
    "for i, unit in enumerate(unitList10):\n",
    "    region = histList.loc[histList['h5file'] == unit[0:-4]+'.h5']['Region']\n",
    "    if len(region):\n",
    "        reg = region.array[0]\n",
    "    else:\n",
    "        reg = 'NA'\n",
    "    regionName.append(reg)\n",
    "    if (('CMM' in reg) | ('NCM' in reg) & ~('L' in reg)):\n",
    "        zoneName.append('NCM-CMM')\n",
    "    elif ( reg == 'NA'):\n",
    "        zoneName.append('NA')\n",
    "    else:\n",
    "        zoneName.append('L')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "zoneUnique = np.unique(zoneName)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['L', 'NCM-CMM'], dtype='<U7')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zoneUnique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L : 166 units\n",
      "NCM-CMM : 209 units\n"
     ]
    }
   ],
   "source": [
    "for izone, zone in enumerate(zoneUnique):\n",
    "    nGoodZone = len([x for x in zoneName if x == zone])\n",
    "    print(zone, ':', nGoodZone, 'units')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We are doing 1,2,3,4,5,10,20\n",
    "numUnits = 2\n",
    "\n",
    "#nGood = len(unitList)\n",
    "nGood = len(unitList10)\n",
    "\n",
    "maxTest = 2000  # This is 2000 for subgroups and 800 for 20\n",
    "nZones = len(zoneUnique)\n",
    "argListZones = [[] for i in range(nZones)]\n",
    "ntests = np.zeros((nZones,), dtype=int)\n",
    "\n",
    "siteUnit = (dfDataBaseNW['site']+'_'+dfDataBaseNW['unit'])\n",
    "#nGoodPairs = len(argList2)\n",
    "nGoodPairs = len(argList10)\n",
    "\n",
    "# For more than 3 units look for previous combinations that worked\n",
    "if numUnits > 3 :\n",
    "    foundFile = False\n",
    "    testUnits = numUnits - 1\n",
    "    while not foundFile: \n",
    "        pathIn = rootPath + pklPath + 'JulieDataBase%dGoodUnitPCPerZone.pkl' % testUnits\n",
    "        if os.path.exists(pathIn) :\n",
    "            foundFile = True\n",
    "            fileIn = open(pathIn, 'rb')\n",
    "            argListZonesPrev = pk.load(fileIn)\n",
    "            fileIn.close()\n",
    "            print('Found file from previous run')\n",
    "        else:\n",
    "            testUnits -= 1\n",
    "            \n",
    "\n",
    "for izone, zone in enumerate(zoneUnique):\n",
    "    nGoodZone = len([x for x in zoneName if x == zone])\n",
    "    print(zone, ':', nGoodZone, 'units')\n",
    "    if nGoodZone < numUnits:\n",
    "        continue\n",
    "        \n",
    "    xtests = comb(nGoodZone,numUnits)\n",
    "    if xtests > maxTest:\n",
    "        ntests[izone] = maxTest + 1\n",
    "    else:\n",
    "        ntests[izone] = int(xtests)\n",
    "\n",
    "    # Generate the good index for this bird\n",
    "    indGoodZone = [ind for ind, zonelist in enumerate(zoneName) if zonelist == zone]\n",
    "    unitListZone = [unitList10[i] for i  in indGoodZone]\n",
    "\n",
    "    # Generate the list of arguments to run naiveBayes in parallel\n",
    "    argList = argListZones[izone]\n",
    "    if (numUnits == 1):\n",
    "        for i, unit in enumerate(unitListZone):\n",
    "            if i == ntests[izone]:\n",
    "                break\n",
    "            unitChoice = [unit]\n",
    "            argList.append(unitChoice)\n",
    "    elif (numUnits == 2):\n",
    "        i = 0\n",
    "        for i1, unit1 in enumerate(unitListZone):\n",
    "            for i2, unit2 in enumerate(unitListZone):\n",
    "                if i2 <= i1:\n",
    "                    continue\n",
    "                unitChoice = [unit1, unit2]\n",
    "                stimSet = commonStim(siteUnit, unitChoice)\n",
    "                if len(stimSet) > 100 :\n",
    "                    argList.append(unitChoice)\n",
    "                    i += 1\n",
    "                    if (i%100 == 0 ):\n",
    "                        print(i, '...')\n",
    "                if (i == ntests[izone]):\n",
    "                    break\n",
    "            if (i == ntests[izone]):\n",
    "                break\n",
    "          \n",
    "    elif (numUnits == 3 and ntests[izone] <= maxTest):      \n",
    "        # Generate all possible combinations\n",
    "        for unitChoice in itertools.combinations(unitListZone, numUnits):\n",
    "            stimSet = commonStim(siteUnit, unitChoice)\n",
    "            if len(stimSet) > 100 :\n",
    "                argList.append(list(unitChoice))\n",
    "    else:\n",
    "        i = 0\n",
    "        while i < ntests[izone]:\n",
    "            \n",
    "            if (numUnits == 3 or not foundFile ):\n",
    "                # Choose 1rst one randomly to get going\n",
    "                unitChoice = [unitListZone[np.random.randint(nGoodZone)]]\n",
    "            else:\n",
    "                # Choose the first few from previous run            \n",
    "                unitChoice = argListZonesPrev[izone][np.random.randint(len(argListZonesPrev[izone]))]\n",
    "                if (i==0):\n",
    "                    print('Starting choice:', unitChoice)\n",
    "    \n",
    "            # choose additional ones, one by one:\n",
    "            unitListTest = unitListZone.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",
    "\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",
    "                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%100 == 0 ):\n",
    "                    print(i, '...')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One can start here insttead of running the previous cell and read a previously ran set\n",
    "# We are doing 1,2,3,4,5,10,20\n",
    "numUnits = 20\n",
    "\n",
    "# read the PC and Confusion matrices data base\n",
    "inPath = rootPath + pklPath + 'JulieDataBase%dGoodUnitPCPerZone.pkl' % numUnits\n",
    "fileIn = open(inPath,\"rb\")\n",
    "argListZones = pk.load(fileIn)\n",
    "fileIn.close()\n",
    "\n",
    "nZones = len(zoneUnique)\n",
    "ntests = np.zeros((nZones,), dtype=int)\n",
    "\n",
    "for izone, zone in enumerate(zoneUnique):\n",
    "    ntests[izone] =  len(argListZones[izone])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For ensemble size of 20\n",
      "L : 801 combinations to be tested\n",
      "NCM-CMM : 801 combinations to be tested\n"
     ]
    }
   ],
   "source": [
    "print('For ensemble size of', numUnits)\n",
    "for izone, zone in enumerate(zoneUnique):\n",
    "    print(zone, ':', len(argListZones[izone]), 'combinations to be tested')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done with chunk 1/9 for zone 1/2\n",
      "Done with chunk 2/9 for zone 1/2\n",
      "Done with chunk 3/9 for zone 1/2\n",
      "Done with chunk 4/9 for zone 1/2\n",
      "Done with chunk 5/9 for zone 1/2\n",
      "Done with chunk 6/9 for zone 1/2\n",
      "Done with chunk 7/9 for zone 1/2\n",
      "Done with chunk 8/9 for zone 1/2\n",
      "Done with chunk 9/9 for zone 1/2\n",
      "Done with chunk 1/9 for zone 2/2\n",
      "Done with chunk 2/9 for zone 2/2\n",
      "Done with chunk 3/9 for zone 2/2\n",
      "Done with chunk 4/9 for zone 2/2\n",
      "Done with chunk 5/9 for zone 2/2\n",
      "Done with chunk 6/9 for zone 2/2\n",
      "Done with chunk 7/9 for zone 2/2\n",
      "Done with chunk 8/9 for zone 2/2\n",
      "Done with chunk 9/9 for zone 2/2\n"
     ]
    }
   ],
   "source": [
    "# Run the decoders using multiprocessors if possible\n",
    "mpflag = True\n",
    "\n",
    "# Run Naive Bayes in chunks of 90 with a pool of 30 workers\n",
    "chunckSize = 100    # A chunk size of 100 is used for memory since it has to keep the results of all or 90 and 1800 tests.\n",
    "poolSize = 30       # 10 for laptop, 30 for desktop\n",
    "\n",
    "# Allocate memory for results\n",
    "pccZones = []\n",
    "selHZones = []\n",
    "confMatTotZones = []\n",
    "\n",
    "\n",
    "\n",
    "for izone, zone in enumerate(zoneUnique):\n",
    "    \n",
    "    # Allocate bird specific storage for the results\n",
    "    pcc = np.zeros((ntests[izone],))\n",
    "    selH = np.zeros((ntests[izone],))\n",
    "    confMatTot = np.zeros((ncalls, ncalls))\n",
    "    confMatCount = 0\n",
    "    \n",
    "    # Calculate the number of chunks\n",
    "    nchunks = ntests[izone]//chunckSize\n",
    "    if ntests[izone] % chunckSize:\n",
    "        nchunks += 1\n",
    "        \n",
    "    # Arglist for this zone\n",
    "    argList = argListZones[izone]\n",
    "    \n",
    "    \n",
    "    if mpflag == True:\n",
    "        if __name__ == '__main__':\n",
    "            for ichunk in range(nchunks):\n",
    "                istart = ichunk*chunckSize\n",
    "                iend = (ichunk+1)*chunckSize\n",
    "                if iend > ntests[izone]:\n",
    "                    iend = ntests[izone]         \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",
    "                    confMat = res[1]\n",
    "                    if (confMat.shape == (ncalls,ncalls) ):\n",
    "                        pcc[istart + i] = res[0]\n",
    "                        pccDiag = np.diag(confMat)\n",
    "                        pccDiag = pccDiag/np.sum(pccDiag)\n",
    "                        pccDiag[pccDiag == 0] = 1. # Because 0log0 = 0\n",
    "                        selH[istart + i] = 1 - np.sum(-pccDiag*np.log2(pccDiag))/(np.log2(ncalls))\n",
    "                        testsPerClass = res[2]\n",
    "                        confMatTot = np.add(confMatTot, confMat)\n",
    "                        confMatCount += testsPerClass\n",
    "                \n",
    "                print('Done with chunk %d/%d for zone %d/%d' % (ichunk+1, nchunks, izone+1, nZones))\n",
    "    else:\n",
    "        for i in range(ntests[izone]):\n",
    "            pccval, confMat, testsPerClass = naiveBayes(argList[i], code = code)\n",
    "            pcc[i] = pccval\n",
    "            pccDiag = np.diag(confMat)\n",
    "            pccDiag = pccDiag/np.sum(pccDiag)\n",
    "            pccDiag[pccDiag == 0] = 1. # Because 0log0 = 0\n",
    "            selH[i] = 1 - np.sum(-pccDiag*np.log2(pccDiag))/(np.log2(ncalls))\n",
    "            confMatTot = np.add(confMatTot, confMat)\n",
    "            confMatCount += testsPerClass\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",
    "    # Store the results in the bird lists\n",
    "    pccZones.append(pcc)\n",
    "    selHZones.append(selH)\n",
    "    confMatTotZones.append(confMatTot)\n",
    "    \n",
    "        \n",
    "# save the PC and Confusion matrices data base\n",
    "outPath = rootPath + pklPath + 'JulieDataBase%dGoodUnitPCPerZone.pkl' % numUnits\n",
    "fileOut = open(outPath,\"wb\")\n",
    "pk.dump(argListZones, fileOut)\n",
    "pk.dump(confMatTotZones, fileOut)\n",
    "pk.dump(pccZones, fileOut)\n",
    "pk.dump(selHZones, fileOut)\n",
    "pk.dump(zoneUnique, fileOut)\n",
    "fileOut.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'nZones' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/zn/qkxxn59x2712k0l7j64f7ry40000gn/T/ipykernel_22906/1126422020.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mizone\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnZones\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      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpccZones\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mizone\u001b[0m\u001b[0;34m]\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[0;31mNameError\u001b[0m: name 'nZones' is not defined"
     ]
    }
   ],
   "source": [
    "for izone in range(nZones):\n",
    "    print(np.mean(pccZones[izone]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "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",
    "for izone, zone in enumerate(zoneUnique):\n",
    "    ax.plot(pccZones[izone], selHZones[izone], '+', label = zone)\n",
    "\n",
    "ax.set_xlabel('PCC')\n",
    "ax.set_ylabel('Selelectivy (Ent Z)')\n",
    "ax.set_title('%d Unit Good PC' % numUnits)\n",
    "ax.legend()\n",
    "\n",
    "plt.savefig('/Users/frederictheunissen/Desktop/scatterPCCSelJ%dUnitGoodPCPerZone.eps' % numUnits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "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": "iVBORw0KGgoAAAANSUhEUgAABGoAAASGCAYAAABxMUj/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAC4jAAAuIwF4pT92AACQK0lEQVR4nOzdd5idVYE/8O+BJJTQEVRABAEVcRVUbLiCirqKK3bs3S2Wtaz+1LWAgmUtu67u6roKKrKiYkPFtaBgV1QsCIJ0BaSX0BPI+f1xb8Kdd+5M7p25M/ed5PN5nnky59z3lFwmIfOdU0qtNQAAAACM33rjngAAAAAAHYIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQBAj1LKJ0sptefjvHHPCVZpfG3WUsoh454TAKO1aNwTAIC5Ukq5U5I9kuyQZIskS5Jc1f04PckptdZb52EeuybZM8mdkixNcmOSi5L8rtZ66lyPD2tSStk8nT8rOya5fZKN0vmB3rIkV3c/Tk9ydq21jmeWMLVSSkly1yS7pvN37aZJNkhybTp/51+Z5Pe11vPGNUeAQQlqAFhrlFLunuTRSR6e5KHphDPTub6UcmKS/07yjVrryhHOZaMk/5jkH5LsNs1zFyQ5PMkHaq1Xj2r8QZVS9ktyQqP6+7XW/UbQ9/OTfKJR/ala6/Nn2zezV0p5cJKnJHlMkrslKQM0u7aU8rsk303yhVrrKXM4RVpiir8npnNDkmvSCfj+kORXSb5Xa/3ZiOe1NJ2v4Scl2TfJ5gO0uTzJz5N8MckXa63LRjkngFGw9QmABa2UslEp5S2llFPS+YbgA0kenzWHNElndcsBSb6W5HellPuNaE77dOfy/kwT0nTtkOTgJH8spTx+FOMzHqWUExtbUk4c95z6KaU8qZTy6yQ/TvLqJHfPYCFN0lmlsE+St6bzZ+aMUsprusEkrLJxkjsm2T2dEOUdSX5aSjm1lPLC2XZeStmklHJokj8n+WQ6f+evMaTpul06f+8fkeTiUsqRpZS7zHZOAKMkqAFgobt9krcnuecs+9kjnW8kXj6bTkopT0rnJ893HrLpNkm+Ukp56WzGh6mUUu5USvleOisJ9hxRt3dNJ5A8t5TyihH1ydrrHkkOL6V8u5Sy7Uw6KKU8MskZSd6cZMtZzmejJM9Jcnop5YOllA1n2R/ASNj6BMDa7Kwk309yZpJLk1yfZKt0vkl9bDrnGPRalORDpZTltdb/GXaw7laSzyZZ3HhpZZKvJ/lROj8B3ibJvZM8I52fPK/uIsl/llL+Umv98rDjw1RKKfsm+XKm/sZ2ZZLfpPM1enGSK9I502NJOqvTdkpyryQPTP+VC7dPZ2XYh0Y3a1ruqiR/muK1TZJsm84KrH4emeRbpZR9h9l6VEp5Q5J3ZuoVYFclOT6dFY2XdT9KOl/DOye5X5IHpRPQ9Fqc5BVJ/i3JeYPOB2CuCGoAWNucls5S+M/UWi+c6qFSyqIkL0jnH+abNF7+UCnlxFrrHwcdtHtWwtGZHNKckeSJtdY/9Gnz/9I5w6V3y1NJ8olSyk9rrRcPOj6j0z1D5/ljnsbIlFL+JslX0jlYtencdLalfHGQM5K6f272TfKsdIJGKxDWXV+d7ryp7uG+90jy3CQvzeS/Z/dM8j9Jnj7IYKWUw5K8aYqXv5nu9qo1HRBfStk4yd+mE8zsM8jYAPPN1icA1hYnJNm31rpHrfW904U0SVJrvaXW+rF0/qF+dePlJels5xjGv6RzY06vs5I8uF9I053Dlemc3/DFxkubJ3n3kOPDJKWUPZMck8khzYok/5TkrrXWwwc9yLr75+a7tdYXpvP1/oEky0c2YdYatePUWuvrk9w3nb8Pm55WSrn/mvoqpbw4/UOavyR5eK31MbXWHw1yi1+t9YZa6+dqrQ9J8ogkv19TG4D5JqgBYKG7Jsl+tdaH11p/MGzjWuvvkry4z0uPKaXcbpA+SilbJGmebbMyyQu6Ycx049+a5O+TXNJ46dkOuGQ2uisHPpvJKxmuTvI3tdYP1VpvmWn/tdbLaq2vTmdlxE9n2g9rv+7qxAOS3NR4qST5u+nallJ2T/8tdWekE4QPcxtVc17fSydEet9M+wCYC4IaABa0WutVtdbvz7KPLyb5XaN6/XSuLR7Es5Js1qg7rtb6owHHvyLJe/uM/5IBx4d+3pTOtdu9apKndL9BHYnuirGHZvLXMKzWDWv6nf316DU0/Wgmb7G7Mp2VNOeNYF7La62vS/LMWB0GtIQzagCg4//SOSy116ArWvqdsfDfQ47/qXTOWOjdovKMJG8csp91RvdK6Aemc730lkluTOfw0N8n+W2ttY5xemNVSrlDklf1een9tdbvjnq87sqcf51tP6WUJUnun8619dsmWZrOwcaXJjm11nrmbMeYZuxt0zlsdtvux63dcS9J8rNhDr0dctxd0jlcfPt0At9lSc5O8vNuiLs2+WI6W+567VBK2abWelnz4VLKY5P8dZ9+/rHWetEoJ1ZrPXqU/QHMhqAGADr63V5yhzU1KqVsns4tIr2uTfKtYQavtV5eSjkxE3+6fOdSyu5TnXGztiqlHJLODUKr1VpLz+u7pHM179My8dasXpeUUj6cTjBx/ZDjfzLJ83qqzq+17jTFs9OFQfuu4fVVdh7FyoCGv8vk9+aKJG8Z8TgjUUrZP53DXR+eyVu1ep87J52Dkd87isO2u2Hfy5MclOQ+mfo2oVtKKT9N56DyTw1yFsoaxi1JXpjOIbv3meKxW0spxyd5R631h7MZr0VOm6J+m3RC1qZX96n7Xq3186ObEkD72PoEAB39vuG/cYB2D0pnm1Kvn83wG7l+34z1+2nyOquU8rJ0Vsw8P1OHNEnnuui3Jfl9KWW3eZha2zy/T90naq3NM0LGqpRyl1LKt5J8J53bz6YMabrukuQ1Sc4qpbyllDLjf8uWUg5KcmaS96RzTslUIU3S+eHmXyc5PMlvSykPncW4Oyf5QZKPZ+qQJun8vfLoJD8opXywlNL8e2YhumaK+i2aFaWUO6Vz2G/Tf41yQgBtJKgBgI5d+9T9ZYB29+1TN9ODVX8yYP/rpFLKO5P8Z4a7EnqnJD8qpWw/J5NqoVLKPZPs3OelfueDjE0p5b7pfM0/agbNlyZ5e5LPlVL6XTu+prHfks5ByzP5utgjyXdKKc+Ywbh3SSekeciQTV+R5NPdlTgL2eZT1F/dp+5vMzk8uzjJV0c5IYA2svUJgHVeKWVRkgP7vPSLAZrfvU9dv2toB3F2n7rmYbDrpFLK32fieT2XpXOu0C+6n2+YTtj2xHS+ke61bToHkj5uDqb2257Pd00nQFjl+gz2tTDqA0z361N30Vye7zKs7k0+J6b/Cpozk3w5nfduWTpbEO+f/itunpLOf/u/HWLst6QT8jTdkuSEJMcnuTCdfyffKclj0zkLqTc0WJLkf0sptw66DaeUsmW3/x36vHxWki9l4u/5wenclLTqa+oZSX41yFgt1vyzuUq/bU8P61P3g9ncVAawUAhqAKDzDWDzPJorkwxya9NOferOn+E8LkznANPeLQ6u6O74QPfXFUnemuQD/bbxlFLems7qg3/PxJXDB5RSHlhr/dkoJ1Vr3bNn7BOT7Nvz8i9rrfuNcrwB9VuFddK8z2IK3RUwR2dy6HJlklfWWo+aot2WSf4tk7d1Pa6U8spa638MMPY+aZx/1PWjJC/q3kzUdFgp5UFJjsjEYLYk+Wgp5We11n5nXDX9e5IdG3XXJHlNrfWIPs//Rynldkk+mE5IkySHDjBOmz2pT92F/Q4STv9tYa35OgaYS7Y+AbBOK6VsmORdfV76xIA/ue134PCfZzKX7rk2ze1Wt59JX2uhDZPcnOQxtdZ3T3XWSu34YPofmvviuZxgi9y1T12bVmL8czq3HPW6MsnDpgppkqTWelWt9QVJ3tnn5X9d0/a27rahwzP5TKnjkjxiipBm1dg/TbJPOucj9doiA5yZ0j3T5nmN6uuS/M0UIc2qcS+vtT4znbAmSTZa01htVUrZNclL+rw06eD17u1f/bbv/XLU8wJoI0ENAOu6d2XyN7ZXZfCrhrfqU3fdLObTbLuklLKmA1bXFa8b4mrp96azQqnXo/s9uBbqt7Xm0nmfRR+llMXp3LLU9Pxa6+8G6aPW+qYk32xUb5DkZWtoekAmbyX8U5KDaq1r3H5Wa70yndV3zUPGDyilrGmL4iv71Q2xwutV6X+G1YLQDWmOS/+g6eN96rZP/8OdZ33TF8BCIKgBYJ1VSnlyOt8ANb12iqX4/SztUzfIbVFT6dd2utuN1hXnZIjbXmqtK5J8rlG9Qyll25HOqp227FM31W078+3JSe7YqPtGrfVrQ/bz8nS2Cfb6u24QNF2bptcOc317rfXcTA5xS6YJiUopd0wn4Ol1cpJPDDFuTWdL34JROu7RPQT85PRf6fXF7mqlpn5fw0n/Q4cB1jrOqAFgndS9cebIPi99cbqtCH30+8ZwNlcg9wtqlsyiv7XFEbXWlUO26Xeexd3SktUlc6jfqoWrh+2ku5Lr2iGbnV9r3Wma1x/Zp+7DQ46RWuvZ3Wu9H9tTvXU655r8vPl8dyvNvo3qi9M5tHhY/5PO1rreLVT9fl+9rzX/zf3xbvgysFrryaWUXya53zDt5tDjSym/meK1pekc4r3ZNO1PydTbEafa4tWWwBFgTglqAFjndK/I/Xomr1Q5PckLRjDEUN+ADdB2oV/JOwrfn0GbfrdoTXU98NqkzV8v+zTK12fyNqZBfT4Tg5pV/U8KatIJcJrXun9lJjcI1Vr/Ukr5YSbernW3UsrWtdYr+jR5YJ+6Lw07bk+7tgQ1W2bqlS9rckKSZ9Zar57i9am+hmfzdyvAgmHrEwDrlO6Bo8dn8iHAf07nYM9hVxCs6FM3mwM/+7Ud9fXNC9FMrpbu99P3dSGo6bcqa+y/71LK0kze/vLr7iHaM/GLPnX9bgqaqn42B9M2xy5J9pri2eYtXBfWWi+Z4bhtOhR6Jv6QzoHCj6i1TnfezFTbR7cY+YwAWsiKGgDWGd3zSY7P5NtELk6yf611Jtdq35DOQaa9NsrMDxTuF9QMfIbGWuzKGbTpF6JNd4bJ2uKqTL76eosZ9HNrkt+u4Znm7U3T2TqTV0r8YagZTXR6kpWZ+IPH203xbL/62Yx92oBjJJ0tQL3OmMW4p8+i7Xy6McmydL4W/5BOwPS9Kc6j6WeqP+9bJJlpyAWwYAhqAFgnlFK2TvLdJHdvvHR5OiHNlFfzrsEVmbz8f5Mkgx5G3NT8Bnt5rXU2t0itFbqHAzOYPye5U6Num2E7qbXemGTP6Z4ppQyzFaXfNpmrh2g/Qa11ZSllWSaGUP1uYRv52OkEEE1Tjb1Fozybc1badEbLp2qtz5+jvi9MZ5tTM9i7fWYXdAEsCLY+AbDWK6VsmeQ7Se7ZeOnKdEKaU2fRfb+f7va7HnmNSinrZ/KNOHP90+N+Z3Q0z/KYqX6rg4Y+E4Sh9dsm1tx+Mw6b9qmb7WqxZvt+Y8zF2P3aDjr2qMdd63SvSz+vz0ttOZ8HYE4JagBYq5VSNk8npGmeH3F1kkfVWte0tWNNzu1Td+cZ9rVdJq927df/KF3dp665qmem+vXTbyUCo9XvHJMHzPssJut3/lO/6+2H0Ww/1RlTox67X9tBxx71uGurfl/H95/3WQCMgaAGgLVWKWWzJN/O5NUEy5I8utY6ioM5+y3D33WGfe3Sp26uz6ToF5xsMaK++/UjqJl7/W7I2q6UMtOvy1EZ6ddaKWW9TL7+eaqzTUb9dd6v7VRjX90oz+Zg57EfCj2PTuxT99DuykOAtZqgBoC1Uill0yTfyuSfwF6bTkhz0oiG6hf2PGiGfT24T93JM+xrUFdm8pW323Xfv9navU/d5SPol2nUWn+X/ttG/m6ep9J0eSZ/rfX7GhnU3TL537JTfX31OzNqNmPfo0/dVGNf2ijfbRbjNs/YWpt9LZO/Xu6Y5PFjmAvAvBLUALDWKaVskuSbSR7YeOm6JI+ptf5shMP9NJ3bcXo9aIY/9X1In7ofzKCfgXUPjG3eflOS/NUIum+eCZQs/OuFF4pP9ql7YSllVOcPDa3WekMmr0DbcxYrJPbuUzfV11e/wHM25500x65TjJFMntP2pZTbz3DcNpw1NC9qrX9K5wD4ppfO91wA5pugBoC1SillaZJvZPLqlOuTPLbW+uNRjldrvTpJM/jZNMmjhumnlLJVkoc1qv9Ua53NFcKD6veeHDCbDkspd02yW6P6+qz5uueFrHlQ8ji3aPxPOlck99o6ydvHMJdeP2mUN0nyNzPs66kD9L/KyUluatQ9YSYhUTdk+etG9Rm11qm2PvULhp847LhdT5phu4XqA33q9i+lPHm+JwIwnwQ1AKw1SikbJ/l6Jn8TdUOSA2qtP5yjoT/bp+7vh+zjeZl829LRM5vO0L7Xp+4ZszwL4jl96n5Qa12bb31qHho7qkOZh1Zr/Uv6f5P7z6WUh8/zdHp9q0/dPwzbSSll50wOeC7PFKtaute7n9CovkOSJww7djpbyJqHfn97mue/k8kh3otLKc2rp6dVStkz69itR7XW45L8qM9LHy2lNG/Im5VSyjNKKduNsk+AmRLUALBW6G7pODbJfo2XbkzyuFprvwNWR+WoTP4m/W9LKf3OnJmku5rmdY3qW5N8bARzG8SXklzUqNs5yT/NpLNSyo5JXt3npQ/NpL8FpHlg7c7DfjM+Yu/I5Ku610vyxTGGNV9O8pdG3eNKKY8Zsp8PZXJY8tFuIDOV/+pT975uwDuQUsqdk7yhUV2T/OdUbbqh2Vcb1fdNJ5wddNyStf/Pz1T+PpNXQ22d5LullDvNtvNSypJSyvuSfCbJktn2BzAKghoAFrxSypJ0wob9Gy/dmORva63Nn6SPVHf7U/ObwPWSfKKUsuV0bbs31/x3Oodk9vpMrfXskU1yGrXW5Uk+2Oeld5RSHj1MX6WUrZN8IZOvET611vp/M5ziQnFKo7x5+h8QPS9qrdcneUY6K8p6bZHkm6WUV5RSmmHHwIYJOHrmtCL9A4cjSyn9DujtN+7bM3lr3k1JPryGpt/I5FvUdkrymUHeh+6f5WOTNH/fX6u1NgOxpn5/vj5YSul3zk4/70v/M6zWerXW09I/NN49yU9LKfvOtO9SyiPSWYX1zzPtA2AuCGoAWNC632B9PknzJ/I3JXlCrbXfYZRz4R1JLmjU3TXJT0opfW9q6X7j96VMPmtjWSb/1H6u/UeSXzfqNkrytVLKYQMETqV7bsTPM/mg1RVJXjyymbZXv/NRjiilPKwbyM277hX0T0uyvPHS4nTCgzNKKS8qpWwxaJ+llJ1KKW9Kcv4Mp/X+JL9p1N0uyYmllIOmGXeLUsrHk7ylz8uvr7U2V4VNUGutSV6UyYd/H5jk29NdX15KeUA6W3Du3Xjp6iSvmG7c7tjfT/KpRvWm3XGnXFlTStm6lHJUktd0q5rnDq0Taq0fS/LOPi9tn87XzXGllAcP8ueslLJRKeVppZQfJjk+yR4jni7ArJXO/7MAYGEqpTwrna1HTVdn5t9IrvLLWuvAAUMp5a/TOe+l+dP5lelcNfvDJBem803pvdNZ7dBceZIkT621fmFGM56FUspd0rmhZos+L9+Qzvx/nOTidLb5bJxkq3R+Lw9PsuMUXf9TrXXgbRullEOSHNxbV2sdegtRKWWnJOc2ql9Qa/3kGtp9MhO3pZxfa91pwDFPTf+rm29MJ8hrrm5JOodcTxsyzFZ35cAX01nl08/KdIK6H6ezNemKdP4bL07nrJ1t07kaeq9M/43tD2utDx1gPrsnOSn9z/E5PclXkpyVzpbC2yd5QDrXMve7Nv64dFbODfSP2lLKW9L/UOUV6dwy9L10/pyun+ROSR6bzsqo5tdgTfL0WuvnBxx3y3QCqn5/Ts5MJ7Q9M53b6W6f5EFJHpeJ79Fr01ld0+tttdZDBpnDTJVS9svkM34+VWt9/lyO22ce/5LksEz+b7HKlemEL6elc2bRqivTt0hyl3S2nD0ok1dFrbJzrfW8EU0XYMZmvNwVAFpi8RT1W6R/4DCMq4d5uNb6w1LKM9M566D3/7HrpfNT+wPX1EWSV40jpEmSWus5pZSHpHOOSPPGpo2TPLr7MajlSV5Za/3vEU1xIXhFOgfLNg9i3iiT39NV5vxcjFrrd0sp905yZJJ+Qcp66XwTO9Prny9NJ1wb6FylWusfSikPSydk2bbx8t0z+IqyLyV51qAhTXfsQ7tnvryt8dLidA4oHuQWqhXphH4DhTTdca/qng10YpIdGi/vluT1a+jis0n+LZODmnVGrfWdpZRfJTkiSb+Df7dKZwXZsG5MZ1Vh8/wkgLGw9QkARqjWekySRyT585BNr0jy5Fprv7Ms5k2t9dR0ti59PJO3ywzjpCT7rmMhTWqt30vn6uVLxj2Xplrr+bXWfZMclMnn6czU79JZ5bFrrfW/a63NbUXTzeeX6axuOH4G416fTjD01Fpr86DZQcZ+ezor2maykum0JI+stf7vDMY9O8m+6axcGsaHkzx7mEBqbVVr/VaSu6Wz3fTqWXZ3XTpX2d+11vrGWuvNs+wPYCQENQAwYrXWH6SzKuB16WzfmM6FSQ5Nslut9ctzPbdB1FqvqbW+JJ2tAu9O8tt0tsasycVJPpfk4bXWB9RafzaH02ytWuvX0jmk9mlJDk8ntLo4nXBh7N9o11o/X2u9VzrX2H8wyR8z+LyuTfL9dL4u9qq13rvW+v5aa/PWs0Hnck6t9ZFJHpXO9sDr19DknCT/nk4w9PZa6yBfl1ON/dkkuyb5f+ls+5ruPbglnTNqXpzkXrO5Ra7Wek467/1LMvlcqF4r09mK9fBa68uGCcHWdrXW62qtb05nZdIL0lmZtWzA5pemcwvXc5Lcvtb697XW5vliAGPljBoAmGOllLsm2TOd8y42Tueg44uS/K7WOqqVDXOqlLJ5kvulc3bGlulsK7sxnXNMrkhyWq11TaEULdU9TPieSe6cZJt0vk5LOisWVn2cneSMuVzV0b3B7QHp/FnZJp0znK5IclmS39da/ziHY98+ndVk23bHvrU77sVJflZrvWaOxt01nb8ftkvnDJ5r0wmkflZrvXyapvToHiR8t3TCtzulc7bPBum8n6v+njql1jrbs8sA5pygBgAAAKAlbH0CAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpi0bgnAGtSStk8yb49VX9OsnxM0wEAAGDttyTJnXrK36+1XjMfAwtqWAj2TXLsuCcBAADAOuvAJF+dj4FsfQIAAABoCUENAAAAQEvY+sRC8Ofewle+8pXsuuuu45oLAAAAa7mzzjorT3jCE3qr/jzFoyMnqGEhmHBw8K677po99thjXHMBAABg3TNvF9rY+gQAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoiUXjngC0Ua01K1euTK113FMBWKuVUrLeeuullDLuqQAAtIKgBtIJZm666aZce+21ufbaa7N8+fJxTwlgnbJkyZJsuumm2XTTTbPhhhsKbgCAdZaghnXeDTfckIsuuigrVqwY91QA1lnLly/PFVdckSuuuCKLFy/Odtttl4033njc0wIAmHfOqGGddsMNN+RPf/qTkAagRVasWJE//elPueGGG8Y9FQCAeSeoYZ21KqRxDg1A+9RahTUAwDrJ1ifWSbXWXHTRRZNCmsWLF2ezzTbLJptsksWLFzsjAWCO1VqzYsWKXHfddVm2bNmEFY6r/q7eZZdd/H0MAKwzBDWsk2666aZJ25023XTTbL/99r4ZAJhnixcvzsYbb5xtttkmF154Ya699trVr61YsSI333xzNtxwwzHOEABg/tj6xDqp95uApPNNgpAGYLxKKdl+++2zePHiCfXLli0b04wAAOafoIZ1UjOo2WyzzYQ0AC1QSslmm202oa75dzYAwNpMUMM6p9aa5cuXT6jbZJNNxjQbAJqafycvX77cwe8AwDpDUMM6Z+XKlZPqmsvsARifRYsmH6HX7+9uAIC1kaCGdU6/n8ra9gTQHuutN/mfJ1bUAADrCkENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIagGnstNNOKaWs/jjxxBPHPSUAAGAttmjcE4CFbKc3HDfuKaxVznv3AeOeAgAAwFgJagAAAKBFxvEDYT80bQ9bnwAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpi0bgnAAAAAIzZIZvP83jXzO94C4gVNQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJRaNewIAAADAbc7b8JnjngJjZEUNAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtIRbnwCG8Ktf/Sq33HLLjNruv//+I54NAACwthHUAAzhta997Yzb1lpHOBMAAGBtZOsTAAAAQEtYUQOzcN67Dxj3FAAAAFiLCGoApnHeeeeNewoAAMA6xNYnAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWmLRuCcAAAAAbbbTG46b1/HO23Beh6NlrKgBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJZYNO4JADAzF110UX73u9/l/PPPzzXXXJMVK1Zkiy22yJZbbpldd901e+65Z5YsWTLuabbWFVdckV//+tc577zzctVVV+Xmm2/O5ptvni233DJ3vvOdc9/73jcbb7zxuKcJAMA6RlADMI2ddtop559//oS6u9zlLjn99NOzePHiWfV11VVXZYstthiqj3PPPTcf/ehH88UvfjFnnXXWtM8uWbIke++9d571rGfloIMOylZbbTXt889//vPzqU99alL905/+9Bx99NFDzbN3vrvssktqrX1f22mnnWbU70xdcskl+Z//+Z8cc8wxOeWUU6Z9dv3118+9733vPP3pT8+znvWsbLfddtM+f8ghh+Rtb3vbpPoHPvCB+elPfzqj+V533XW5wx3ukOuvv37SayeccEL222+/BTMfAAAGI6iB2Thk83HPYO1yyDXjnsFAzjnnnBxxxBH5+7//+3kb84orrsgb3/jGHHHEEbn11lsHarN8+fL8+Mc/zo9//OO8+tWvzite8Yq8+c1vzuabD/d1e+yxx2bZsmXZbLPNhp73kUce2TekmW833HBDDj300HzgAx/ITTfdNFCbW2+9NSeffHJOPvnkvPGNb8zznve8HHbYYbnjHe841Ng/+9nPcuaZZ2a33XYbet5f/OIX+4Yis9G2+QAAMJEzagBm4NBDDx34G/7Z+tnPfpZ73/ve+djHPtY3pNl0002zyy675P73v3922223bLLJJpOeufnmm/O+970vu+6669Dj33jjjTnmmGOGbldrzZFHHjl0u1H74x//mL333jvvfve7+/4323jjjbPTTjtl7733zt3vfve+Qdatt96aI444IrvttlsuueSSoecw0/eh3wqnUWjbfAAAuI2gBmAGLrzwwnzkIx+Z83G+973v5RGPeEQuvPDCCfW77bZb3v/+9+e0007LsmXLctZZZ+XnP/95/vjHP+baa6/N+eefnw996EOTtqJcfvnlA4+93nq3/S9iJt/Y/+hHP8o555zTt7/5csopp+QhD3lITjvttAn12223XQ499ND86le/ynXXXZdzzz03J510Uv7whz/k6quvziWXXJLDDz88j3vc41JKWd3u+uuvz4033jjQ2L2/36OOOmrolUXnn39+TjzxxL79zUTb5gMAQH/+lQUwQ+9617ty3XXXzVn/559/fp7ylKfkhhtuWF23ZMmSfOADH8ipp56a17zmNdl99937tt1xxx3z8pe/PCeccEJOOOGE7L333kOP/7CHPWz15z/84Q9z3nnnDdW+d/XFHe5wh9zjHvcYeg6zcc011+TAAw/MZZddtrqulJI3velN+eMf/5g3v/nNuc997jMhiFll2223zQtf+MJ87Wtfy8knn5xHPepRQ4/f+/6dd955+cEPfjBU+09/+tOrw5QlS5Zkn332GXoObZ4PAAD9CWoAhvDgBz949eeXXXZZPvCBD8zJOLfcckue8Yxn5Kqrrlpdt3Tp0hx33HF55StfOdRBxvvtt19+/vOf5y1veUvfUGIqz3jGM1aPM+w2puZ2qWc+85lZf/31B24/Ci9+8Ytz7rnnri4vWrQon/rUp3LYYYdl6dKlA/ez55575lvf+lY+8pGPDPW+/83f/E223Xbb1eVhtw31vt+Pe9zj1ngY9EKbDwAA/QlqAIZw2GGHTQg73ve+900IU0blwx/+8KSbeQ4//PDsv//+M+qvlJK3v/3t+eIXvzhwm6233joHHHDA6vKnP/3pgdt++ctfzrJly1aXn/e85w3cdhS++tWv5gtf+MKEusMOOyzPec5zZtznP/zDP+R73/vewCHPokWL8sxnPnN1+Qtf+MLA26Z+8pOf5Mwzz1xdHsX717b5AADQn6AGYAh77bVXnvzkJ68uX3PNNXnve9870jFuvfXW/Nu//duEuic96Uk56KCDZt33E5/4xKGe7/2G/KyzzspPfvKTgdr1rtbYc889c6973WuocWfrPe95z4Ty3nvvnde+9rWz7vchD3lIttlmm4Gf733/rr322nz5y18eqF3v+7fNNtvkMY95zOCTXEDzAQBgMkENwJDe/va3T9jG88EPfnBGNwFN5Qtf+ELOP//8CXWHHHLIyPofxgEHHJCtt956dXmQ7U8XXnhhjj/++NXl5z73uXMyt6n8/Oc/z49//OMJdW95y1vmfetV0gmp/uqv/mp1eZD376abbsrnP//51eXeLWhr23wAAJhMUAMwpN133z3PfvazV5evv/76vPOd7xxZ/1/60pcmlB/wgAdM+OZ6Pi1evDjPeMYzVpc/97nP5eabb562zVFHHZWVK1cm6Wy3edaznjWnc2xqvn/bb799HvvYx87rHHr1rmI5/vjj85e//GXa54899thcffXVfduvjfMBAGAiQQ3ADBx88METVhV89KMfzZ///OeR9P3DH/5wQvnAAw8cSb8z1bsi5uqrr85Xv/rVaZ/v3Sbz6Ec/esIBtvOh+f4dcMABY1lNs8qznvWs1ePfeuutOeqoo6Z9vvf922OPPXKf+9xnrZ4PAAATCWoAZmDnnXfOS17yktXlm2++OW9/+9tn3e/ZZ589aYXD/e53v1n3Oxt77733hGvAp9su84tf/CJ/+MMfVpfne/XFjTfemF/96lcT6sb9/t3hDneYcL33dIcyX3zxxfn2t7+9ujwX71/b5gMAwESCGoAZevOb35yNNtpodfmTn/zkhJtxZuL000+fVLfXXnvNqs9R6P0G/Zvf/GYuvfTSvs/1rr7Ycsst8/jHP37O59brnHPOyfLlyyfUte39O+WUU/LrX/+673NHHXVUbr311iTJ+uuvP2GL3do8HwAAbiOoAZihO97xjnnZy162unzLLbfk4IMPnlWfV1555YTy+uuvP+Ew33F59rOfnfXW6/wv45ZbbslnPvOZSc8sX748Rx999Ory0572tGywwQbzNsdk8vuXZN63XvVz4IEHZvPNN19d7g20evXW77///rnjHe+4TswHAIDbCGoAZuENb3hDNt1009Xlz33ucznllFNm3F8zaNhss81SSplxf6Oy/fbb5xGPeMTqcr/tT1//+tcnzH8c22T6BTVbbLHFvM+jacMNN8zTnva01eWjjz46t9xyy4RnTj755Pz+979fXZ7L969t8wEA4DaLxj0BgIVs6623zmte85q87W1vS5KsXLkyb3nLW/KVr3xlRv1de+21E8pLly6d7RRH5nnPe16+853vJEl+/etf59RTT80ee+yx+vXe1Rd3vetd86AHPWje59h8/5L2vIfPe97z8rGPfSxJcumll+ab3/xmHve4x61+vff922yzzfKEJzxhnZoPALTZeRs+c9xTYB1iRQ3ALL3mNa+ZsD3p2GOPzUknnTSjvnpX5ySdq7/b4olPfOKE+fV+I3/ZZZfl//7v/1aXn/Oc58zr3FZpvn9Je97DffbZJ7vsssvqcu+qpBUrVkzYTvbUpz51wvlH68J8AADoENQAzNJmm22W17/+9RPq3vSmN82or6222mpCedmyZTOe16htvPHGecpTnrK6/L//+7+rD5r9zGc+kxUrViRJSimzCmp+9atf5fjjjx/o46qrrprQtvn+Jck111wz47mMWu9V51/96ldz9dVXJ0m+8Y1v5PLLL1/92nxtM2rbfAAAENQAjMTLX/7yCQetHn/88TnxxBOH7qcZNNx666254oorZju9ken9xv6iiy7K8ccfn2Ti6pp99903d77znWc8xj//8z/nkY985EAfv/3tbye07RfUTHVD1Tg85znPWX3m0M0335zPfe5zSSa+fzvvvHMe8pCHrJPzAQBAUAMwEhtttFHe/OY3T6ibyaqau9/97pPqpro6eRyaIcyRRx456Xrnca6+uMtd7pLFixdPqGvT+7fzzjvnr//6r1eXjzzyyFxxxRU57rjjVtc997nPnbcDpNs2HwAABDUAI/PiF784O+200+ryT37ykwnf8A5il112mXQF8i9/+ctRTG8kSikTVtV85StfyYc+9KHV5aVLl07YHjXfNtpoo9zvfvebUNem9y+ZGGT95Cc/yaGHHprly5cnmfz+rovzAQBY1wlqAEZkyZIlOeSQQybUvfnNb06tdah+elc4JJ2zQ9qk9xv3G264YfXNQUnnwOFNNtlkVv2feOKJqbUO9LHffvtNat98/4477rjVZ+m0QfNg3v/4j/9Y/fk+++yTu9zlLuv0fAAA1nWCGoARevaznz1h+9JvfvObfOELXxiqjyc+8YkTyj/96U9z6qmnjmR+o7DrrrvmwQ9+cN/X2nDobPP9u+CCC/LNb35zTLOZbNNNN500x1XG8f61bT4AAOs6QQ3ACK2//vp5+9vfPqHurW9961ArOp7ylKdMOoz3bW9720jmNyr9tsPssMMOefjDHz6G2Uz0wAc+cFKQdNhhh2XlypVjmtFk/d6/DTfcME996lPHMJv2zQcAYF0mqAEYsac85SnZa6+9VpdPP/30fPrTnx64/aJFi/KqV71qQt0xxxwz9Mqcfr7xjW/Muo8kOeigg7LBBhtMqHv2s5+d9dZrx/9WXve6100o/+xnP8u//du/zbrfX/ziF7nssstm3c/++++f7bbbbkLdE57whGy++eaz7nttmA8AwLqsHf+iBliLlFJy2GGHTah729velhUrVgzcx8te9rLc//73n1D3ghe8ICeccMKM5lRrzfvf//4ceOCBM2rftMUWW+TKK6/Mtddeu/rj0EMPHUnfo/CEJzxh0naeN77xjTn66KNn3OdRRx2Vhz3sYbn++utnO72sv/76Ofvssye8f0ceeeSs+11b5gMAsC4T1ADMgcc+9rHZZ599VpfPO++8XHTRRQO3X7x4cT772c9OWNFw3XXX5TGPeUz+8z//M7fccsvAff32t7/Nwx72sLz2ta8dqt2abLzxxtlkk01WfyxatGhkfY/CEUccMWEL2S233JJnP/vZOeSQQ3LDDTcM3M8555yTJz3pSXnOc54zkpBmlQ033HDC+9e8Vny+tW0+AADrKkENwBx5xzveMav2O++8c4455pgJN/LcfPPNecUrXpF73vOe+cAHPpAzzjijb9sLLrgg//3f/51HP/rR2WuvvfL9739/VnNZiLbYYosce+yx2XrrrVfXrVy5Mm9729ty17veNe985zvzm9/8pm/byy+/PEceeWSe9KQn5W53u1u+/OUvz9OsAQBY17Xrx58Aa5F99903j3zkI/Od73xnxn2sav/Upz41f/nLX1bXn3HGGXn1q1+dV7/61dl8882z7bbbZsstt8zVV1+dv/zlL7n22mv79neHO9xhxnNZiO5973vnhz/8YZ74xCdOCLUuvPDCvOlNb8qb3vSmbLLJJtl2222z9dZb57rrrsvFF1+cq666qm9/m2++eTbeeOP5mj4AAOsgK2oA5tBsV9UkyT777JPf/e53ecELXtD3sN5rrrkmZ555Zk466aT88Y9/7BvSLF26NG9961tz1llnzXo+C83uu++eX/3qV3nta1+bJUuWTHr9uuuuyznnnJNf/OIX+cMf/tA3pFm8eHFe/vKX56yzzsq22247H9MGAGAdJagBmEN77713nvCEJ8y6n9vd7nY54ogj8sc//jGve93rsvPOO6+xzQYbbJB99903H/vYx/KXv/wlb3vb27J06dJZz2UhWrp0ad773vfmvPPOyyGHHJJ73OMea2yzaNGi7L333vn3f//3XHTRRfnQhz6U293udvMwWwAA1mWl1jruOcC0Sil7JPn9qvLvf//77LHHHjPu75ZbbsmZZ545oW633XZr3UGosCYXXHBBfve73+X888/PNddck1tvvTWbb755ttpqq+y22265973v3XcFCR2XXXZZfv3rX+e8887LVVddlRUrVmSzzTbLlltumbvc5S65z33uM+F8IOaPv6cBaJ1DNl/zMwznkGvGPYNpnXrqqbnnPe/ZW3XPWuup8zG2f/EALFA77LBDdthhh3FPY8HaZptt8qhHPWrc0wAAgAlsfQIAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJZYNO4JcJtSygZJ9kqye5Itk2yUZFmSS5OcnOSsWmsdwTiLkjwgyT2TbJ3k1iR/SfKrWuups+0fAAAAmBlBTQuUUu6b5NVJnpJkg2kevbCUcniS/6i1XjmDcTZJ8oYk/5hkqymeOSPJvyb55ChCIQAAAGBwtj6NUSllvVLKu5OclORZmT6kSZLtk7w1yWmllL8Zcqy/SvK7JG/KFCFN192SHJHk/0opmw8zxkJRSplUJ5MCaI+VK1dOquv3dzcAwNpIUDNeH03y+kz+73BDklPSCXDOTtJMEW6f5NhSymMGGaSUcrck30uyc+Ol69IJb85MsqLx2qPTCWs2HGSMhWS99SZ/2a9Y0fztAzAut9xyy6S6fn93AwCsjfyrZ0xKKU9J8uJG9WlJDkiyea31XrXWB9Rad00nmDk4yfKeZ5ck+VQpZcs1jLMoyTFJbtdTfWWS5yXZqtZ671rrXZPcIck7kvT+GPNBSd4z9G+u5UopWbJkyYS66667bkyzAaCp+XfykiVLrKgBANYZgprxObhR/mWS+9dav1FrnfCjxFrrZbXWtyd5TJLe17ZJ8g9rGOeFSf6qp3xVkr+utR5Za129jKTWemWt9c1JntNo/4+llN3W/NtZWDbddNMJ5WXLltn+BNACtdYsW7ZsQl3z72wAgLWZoGYMSil3SefGpV4vrbVeP127Wuv3khzeqP7bacZZkuTNjerX1lpPm2aMzyQ5qqdqUZJDppvXQtT8R/+KFSty4YUXCmsAxqjWmgsvvHDSdtTNNttsTDMCAJh/bn0aj7s1yhfUWn8xYNsvJvn7nvKu0zz76CR36imfl+QTA4xxSDqHG69aZ/7UUspLa63XDDjH1ttwww2zePHiCd8MXHvttTn77LOz2WabZZNNNsmiRYuciQAwx1auXJlbbrkl1113XZYtWzYppFm8eHE22GBNZ+0DAKw9BDXj0bx16c9DtP1To7zFNM8e2Ch/YpArt2utZ5dSvp9kv27V4iSPTXL0gHNsvVJKtttuu/zpT3+asIpmxYoVueKKK3LFFVeMcXYAJLf9Xe18GgBgXWK5wHg0V6ZsNETb5rOXT/PsAY3yt4cY5zuN8uOGaLsgbLzxxtlxxx19AwDQQqWU7Ljjjtl4443HPRUAgHklqBmP3zTKu5dSlg7Y9v6N8kn9Hiql3D6dm5xWuTnJyQOOkSQ/bpT3HKLtgrEqrFm8ePG4pwJA1+LFi4U0AMA6y9anMai1XlBK+UmSB3erNkjyT0neNV27UsoGSV7VqG4eLrzK7o3yWbXW5X2f7K954PCupZRFzRup1gYbb7xxdtlll9x8881ZtmxZrr322ixfPsxbBcBsLVmyJJtuumk222yzbLDBBlY7AgDrLEHN+Lw+yfdz26qmt5dSLqq1fqrfw6WULZJ8OhMDmK/VWr82Rf/NA4uHOQcntdbLSik3JdmwW7Ukyc5Jzhymn4WilJINN9wwG264YbbddtvUWrNy5Uq3QAHMsVJK1ltvPcEMAECXoGZMaq0/KqW8PMl/pXO70qIknyylvCzJl5KckeTGJLdL8oAkz8zEQ4i/k+QZ0wyxbaN8wQymeVGSuzT6nFVQU0rZNsk2QzbbZTZjzkQpJeuvv/58DwsAAMA6TlAzRrXWj5RSzkjywSR7dKv37n5M5Zwk70nysVrrymme26RRvn4GU2y2afY5Ey9NcvAI+gEAAIC1jsOEx6zW+r10gpn3Jbl1DY//qfvcZ9YQ0iSTQ5WbZjC9G9fQJwAAADBCgpoxK6X8Q5Kzk7w2yZr22uyY5MNJziulvHANz27YKM/kdNybG+VhrhEHAAAAhmTr05iUUhYnOTrJk3uqr0zyn0m+ns5ZMNenc0bN/ZK8IMkT0jnPZqskh5dSdq+1vm6KIZoraJbMYJobrKHPmfhwkmOGbLNLkmNHMDYAAAC0mqBmfD6SiSHNSUkOrLVe3HjuL0m+luRrpZTHJ/lcblst89pSymm11k/06f+6Rrm5wmYQzRU0zT6HVmu9NMmlw7RxEwgAAADrClufxqCUsl+SF/VUXZrkcX1CmglqrV9N8rJG9XtLKf22JDVDlaVDTrNfm1kHNQAAAMDUBDXj8U+N8gdqrZcN2PaTSf7YU946yZP6PNdctbLDgP332m4NfQIAAAAjJKiZZ6Wzj+fhjeqvDdq+e9vTcY3qh/Z59IxGecdBx0iSUsq2mbhdank6V4MDAAAAc0RQM/+2TLJ5o+7cIftoPr99n2dOb5R3KaUMc6Dw7o3y2bXWW4ZoDwAAAAxJUDP/mjcpJcmwAciKRnnStd7d8256z7zZIMl9hxhjn0b5N0O0BQAAAGZAUDP/ruhT1zwLZk2aK2imOt+muUXqkUOM0Xx24O1ZAAAAwMwIauZZrXV5Oldu92qeWbMmj2iUz57iua82yi8oA9x1XUrZJcm+PVUrknxj8OkBAAAAMyGoGY/vNsqvKqUsGqRhKWXfJA9aQ3+rfCvJBT3lnZK8YIBhDknSG+h8sdZ6zSDzAwAAAGZOUDMeRzXK90zy4VLKtP89Sim7JvlMo/rMJD/t93yt9eYk72hUv6+Uco9pxnhmkmf3VN2a5ODp5gUAAACMhqBmDGqt30pyQqP6JUm+X0p5RHN1TSll61LKPyf5ZSafZ/MvtdZbpxnu8CSn9pS3TPLDUspze8cppWxVSjk0yacb7T9aa/3jmn9XAAAAwGwNtN2GOfHMJD9JsnNP3UOSHJ/kulLKuUluTLJ1krtk4lakVd5fa/3CdIPUWleUUp6a5EdJtupWb5XkU0n+q5RydpKNuvNY3Gh+UpLXDvObAgAAAGbOipox6V6fvW+SE/u8vEmSv0py/yS7ZHJIsyLJG5K8bsCx/pDOgcXn9xnn3knumskhzfFJHl1rvXGQMQAAAIDZE9SMUa31z+nc4PS0dAKblWtock2SjyT5q1rrv9Za6xBj/Tad8OddSa6a5tEz09mG9aha69WD9g8AAADMnq1PY1ZrXZnkmCTHlFI2TXK/dLY6bZFkwyTLklyR5HdJTus+P9Oxrk3yL6WUg5M8IJ1DjLdO58DgvyQ5udZ6ysx/NwAAAMBsCGpapBuknJDJBw2PepwV6ZxZ86O5HAcAAAAYjq1PAAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0xKJxTwAAAACGsdMbjpvX8c7bcF6HYx1nRQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC2xaNwToL9Syt2S3DvJDkk2TnJjkkuS/DHJb2utN8+i7w2TPDjJ3ZNsmWR5kguS/LzWes4spw4AAADMkKCmRUopmyZ5RZIXJ9l5mkeXl1JOSvKFWut/DNH/NkkOTvL8JEuneOZXSQ6ttR47aL8AAADAaNj61BKllMclOTPJOzJ9SJMkS5I8JMkbh+h/vySnJXlZpghpuu6b5CullE+VUpYM2j8AAAAwe1bUtEAp5dVJ3p+kNF66KclFSS5PslGSOya53Qz6f0iSb3T76HV1knPT2f50pyTr97z23CSblFKeUmutw44JAAAADM+KmjErpbwoyb9lYkjzf0kek2SLWusutdYH1FrvVWvdJsn2SZ6T5IvpnC2zpv63TPK5TAxpzk/yhCRb1VrvU2vdOclOST7aaP6kJK+eye8LAAAAGJ4VNWNUStk1yX/2VK1I8rxa69FTtam1XpTkqCRHdUOYNXldku16yucmeUi3n95+L0jyD6WUP6Wz/WqVt5ZSPlFrvWqAsQAAAIBZsKJmvP4nyYY95WdNF9I0rSk86R4e/IpG9UuaIU3Du5L8oKe8eZLXDjonAAAAYOYENWNSSjkwycN6qo6ptR4z4mGenmSTnvIPaq3fna5B9zyatzWqX1hKaZ6fAwAAAIyYoGZ8/q5RboYjo3Bgo3z4gO1OSGeL1Cp3SPLAkcwIAAAAmJKgZgxKKdsneXRP1W9qraeOeIxNkjy0Uf3tQdp2V9Uc36h+3CjmBQAAAExNUDMef5OJV2GfMAdj7JFkcU/53FrrxUO0/3GjvOesZwQAAABMy61P47F3o/zbVZ+UUvZK8oIk+ybZMckGSS5NcmaSbyU5utZ64QBj7N4onzbkHJvPN/sDAAAARsyKmvFoBjXnlFI2KaUcnuTkdG5quleSLZJslOTOSfZP8t4kZ5ZS3llKWZzp3a1R/vOQc2w+f+dSyoZ9nwQAAABGwoqa8di1UV6ZzpXYew3QdqMkb0yydynlSbXWa6d4bttG+YLhpphLktyS275G1kuydZJBVvNMqZSybZJthmy2y2zGBAAAgIVCUDPPSinrJdm0Uf3B3BbS1CRfT/KNdMKVpd3XnpNku542+yf5ZJInTzHUJo3y9cPMs9ZaSyk3Nuba7HMmXprk4BH0AwAAAGsdQc382zxJadTdp/vrFUmeWGv9YeP1z5VSDkvy0STP7Kl/UinlubXWI/uM0wxVbprBXOciqAEAAACm4Iya+TdV2HFrkgP6hDRJklrrdemsqmlesf0vpZRm8JMkzfNklg81y46bG+WNZtAHAAAAMCAraubfVCtbPl5r/fl0DWutK0sp/5jODVCrQra7pXND1IlrGGfJkPNMOjdOTdfnTHw4yTFDttklybEjGBsAAABaTVAz/66bov5jgzSutZ5TSjk+yaN6qvsFNc1xZnJjU3MFzVRzH1it9dJ0rhsfWP8FQwAAALD2sfVpntVab0xnm1Ova5P8eohuvt8o36/PM81QZekQ/ae7nWrkQQ0AAAAwNUHNeDRXlJxVa105RPszGuXmVdz9xthhiP6T5PaZuOJqZZLLh+wDAAAAGIKgZjz+0CgvG7J98/kt+zzTDHN2HHKM5vPn11pHcUYNAAAAMAVBzXic1ig3D+1dk+Z5Mzf0eeb0RvkeQ46x+xr6AwAAAEZMUDMeJzfKtx+yfXOr0xV9njk1yYqe8k6llDsOMcY+jfJvhmgLAAAAzICgZjyOS+fMl1V2LqVsNUT7+zbKzW1OqbVem+QHjepHDtJ59yDh/RvVXxt4dgAAAMCMuJ57DGqtl5ZSfpzkr3uqn5Tk42tqW0pZlOSJjeoTp3j8q0ke0VN+UZIjB5jiw5Ls3FO+JMnPB2gHAAAw587b8JnjngLMGStqxuejjfLrSimDnFXzkiR36CkvS/KtKZ79bJLre8oPLaU8fLrOu6tpDm5Uf2LIW6kAAACAGRDUjM/RSU7pKd81yUdLKVP+NymlPCDJexrVH661XtPv+VrrpUn+s1H98VLKdtPM641JHtpTvibJe6d5HgAAABgRQc2YdFeovDpJ7al+XpJvlVImnEFTStm8lPKaJMcn2aTnpT8meecahnpPkot7yjsn+Ukp5fHd1TOrxtihlPLfSd7RaP+OWuuVg/yeAAAAgNlxRs0Y1Vq/W0p5Y5J391Tvn+SXpZSLk1yQZGmSXZIsaTS/IslTuocGTzfGlaWUg9LZHrXqWu87Jzk2ydWllHOTbJFkxyTrN5ofm+R9w/6+AAAAgJmxombMaq3/muSfMvEq7aRzDs39kuyeySHNGUkeVGs9JQOotf4gyQFJmitjtkiyVzqrbJohzWeSHFRrrQEAAADmhaCmBWqtH0pyrySfy+TApte5SV6Z5F611jOHHON7Se6R5CNJbpjm0V8neXKt9Vm11puHGQMAAACYHVufWqLWenqSp5dSNkvy4CS7Jdk8yXXpXI99cq31jFmOcUmSl5ZS/rk7xu7prKpZnuTCJD+vtZ41mzEAAACAmRPUtEytdVmSb3Y/5mqMG5N8t/sBAAAAtIStTwAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASi8Y9gUGUUo7oKb6n1nr6LPraPcnrusVaa33RrCYHAAAAMCILIqhJ8vwktfv5UUlmHNQk2a7Rn6AGAAAAaIWFtPWptLw/AAAAgFlZSEFNXfMjAAAAAAvXQgpqRmX9ns9vHdssAAAAABrWxaBmq57PrxvbLAAAAAAa1sWg5sHdX2uSS8Y5EQAAAIBeC+XWp1krpSxN8uQkL85t5938bnwzAgAAAJioNUFNKeWcAR89qpRy0zBdJ9k4ydbdz1fd9lSTHDdEPwAAAABzqjVBTZKd0glPpro2e1X9HWY5zqoxzk7y+Vn2BQAAADAybQpqVul3DXdZw+uDKD2/npHkybXWYVbmAAAAAMypNgU1f8rUIcyde167NMkwAcvKJNcnuTLJqUm+neTrtVZXcwMAAACt0pqgpta601SvlVJW9hSfVWv93tzPCAAAAGB+LaTruac6uwYAAABgrdCaFTVr8Kmezy8a2ywAAAAA5tCCCGpqrS8Y9xwAAAAA5tpC2voEAAAAsFYT1AAAAAC0hKAGAAAAoCUWxBk1TaWUrZM8Isl9ktwpyeZJNsrwN0PVWusjRjw9AAAAgBlZUEFNKeVOSd6T5IlJFs+2uyR11pMCAAAAGJEFE9SUUh6V5Jgkm+S2lTOCFgAAAGCtsSCCmlLKHkm+lGTjblVNJ6wZdqsTAAAAQGstiKAmyfvSCWlWraCpST6f5HNJfpPk0lrrDeOZGgAAAMBotD6oKaXcPsmjctsqmmuS/G2t9UdjnRgAAADAiLU+qEny0Ew8k+ZVQhoAAABgbbTeuCcwgDv2fH59ks+MayIAAAAAc2khrKhZ2v21Jjm71rpinJMBAACg4ZDNxz0DWGsshBU1V/R8fsvYZgEAAAAwxxZCUPPb7q8lyQ7jnAgAAADAXFoIQc1JSS7ofr5tKWWPcU4GAAAAYK60PqiptdYk/9pT9f/GNRcAAACAudT6oKbrw0m+l872p2eXUl4w5vkAAAAAjNyCCGq6q2qemORH6YQ1HyulvL+UsuV4ZwYAAAAwOgvheu6UUp7b/fTIJNsluUuSVyX5+1LK8Ul+meTSJDcN23et9cgRTRMAAABgVhZEUJPkk0lqT7mms7Jm4yR/2/2YKUENAAAA0AoLJahZpeS2wKb2eW1Qq4KeZh8AAAAAY7OQgprS+HUUfQEAAAC0xkIJatzyBAAAAKz1FkRQU2v91LjnAAAAADDXFsT13AAAAADrAkENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWWBC3PpVSdpyrvmutf5qrvgEAAACGsSCCmiTnJalz0G/NwnkPAAAAgLXcQgspyrgnAAAAADBXFlpQMxPNlTjCHgAAAKCVFkpQ86kZtNk4yTZJ7pNks25dTXJOkh+OaF4AAAAAI7Mggppa6wtm2raUUpI8NskhSe6bZOckn6u1vmk0swMAAAAYjbX+eu7acVySB6WzMqckeUMp5d3jnRkAAADARGt9ULNKrfWWJC9O8vN0wprXlVIeNd5ZAQAAANxmnQlqkqTWemuSt/ZUvWtccwEAAABoWqeCmq7vJbk2nVU1e5ZS7j7m+QAAAAAkWQeDmu6qmvN6qu4/pqkAAAAATLDOBTVdN/d8fsexzQIAAACgx7oa1OzY8/ktY5sFAAAAQI91LqgppeybZNueqkvHNRcAAACAXutUUFNK2TrJh5PUnuqTxjQdAAAAgAnWiaCmlLJFKeUlSX6TZNUtTzXJqbXWM8Y2MQAAAIAei8Y9gUGUUr43w6YbJbl9OmfSlO5H7fn1DSOZIAAAAMAILIigJsl+mbhdaRil5/PaUz641vqN2UwKAAAAYJQWSlAzG6sCnlUrai5M8spa65fGNyUAAACAyRZSUFPW/MgkNyVZluT8JCcn+UaSb9Rabx3lxAAAAABGYUEENbXWdeLQYwAAAGDdJgABAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASC+Iw4TUppSxKcvskWybZNMm1Sa5Kckmt9ZZxzg0AAABgUAs2qCml7JLkxUkemmSvJBv0eezmUsrJSb6f5OO11nPncYoAAAAAQ1lwQU0p5Q5JPpzk8UnKquopHt8wyYO6H68vpXwlyctrrRfP9TwBAAAAhrWgzqgppTwyySlJDkxn7qsCmtr96NVbV7rPPzHJKaWU/ed+tgAAAADDWTArakop+yT5SpKNulU1nQCmJLklyelJLk9yfZKlSW6X5G5JFjee3zrJV0opj6y1/nS+5g8AAACwJgsiqCmlLE1yTDohzarAJUk+m+SIJD+otS7v025Jkr9O8qIkB+W2FTYbJzmmlHLXWusNczx9AAAAgIEslK1P/y/JHXJbSHNhkn1qrc+stR7fL6RJklrr8lrrd2utz0znnJoLel6+Y5LXzfG8AQAAAAa2UIKaF+a2kOaKdEKanw3TQa31pHRW11zR09eLRzxPAAAAgBlrfVBTSrlXku27xZrk9bXWP82kr267N+a2rVPbdfsHAAAAGLvWBzVJ9uj+WpLclM65NLNxdJIb+/QPAAAAMFYLIajZtvtrTXLubA//7bY/t0//AAAAAGO1EIKaDXs+v3HKp4ZzU8/nG4yoTwAAAIBZWQhBzWXdX0uSHUfU5516Pr98RH0CAAAAzMpCCGr+3PP57UopD5hNZ9322/RUzehgYgAAAIBRWwhBzY/S2apUu+V3z7K/d/V8fnO3fwAAAICxa31QU2u9Mcm309n6VJI8tJRyeCllqLmXjo8m2S+d0Kcm+Vat9aZpGwIAAADMk9YHNV0HJ1mZTrhSkjw/yS9KKQ8bpHEpZb8kJyV5cU8fK5O8dfRTBQAAAJiZReOewCBqrb8tpbw/yetyW9CyV5LjSyl/SnJCkt+lczDw9UmWJtk6yb3TWUFz525XJbetpnl/rfWUefxtAAAAAExrQQQ1SVJrfX0p5Q5JnpPbzqsp6YQwz5umaVnVRW4LeY6stb5hruYKAAAAMBMLZetTkqTW+rwkr0zncOHe1THJbWfY9H4kEwOam5K8otb6/PmbNQAAAMBgFlRQkyS11g8luWs6tz9dlomhTNOq1y5N8s4kd621/td8zBMAAABgWAtm61OvWuuFSf4lyb+UUu6e5AHpbIHaMskmSa5LclWS85P8rNZ6xrjmCgAAADCoBRnU9Kq1np7k9HHPAwAAAGC2FtzWJwAAAIC1laAGAAAAoCVaE9SUUjYopfy8lHJOz8cTRtT3Y0opZ/f0+6NSyvqj6BsAAABgVFoT1CR5dZK9k+yUzsHA3621fmUUHdda/y/Jl7t975TkQUleOoq+AQAAAEalFUFNKWXjJG9IUrtVZyT5xxEP84Ykp3THKEneUkpZPOIxAAAAAGasFUFNkicn2SydAKUmeWOt9ZZRDtDt75+6YyTJ1kkOHOUYAAAAALPRlqDm2d1fa5Jf1VqPnYtBaq3fT/LTnqrnz8U4AAAAADMx9qCmlLJekn1y27anz8/xkF9YNXSSh5ZSynQPAwAAAMyXsQc1Se6ZZOPctiVpTlbT9Phaz+dLk+wxx+MBAAAADKQNQc3uPZ/fUGs9cy4Hq7WeleSGnqp7zOV4AAAAAINqQ1CzZffXmuSSeRrzLz2fbzVPYwIAAABMq01BTZJcPk9jXtHz+RbzNCYAAADAtNoQ1Kzs+XzzeRqzd5w65VMAAAAA86gNQc2y7q8lyTbzNGbvONfO05gAAAAA02pDUPPnns+3LKXcaS4H6/a/VW5bSfPnaR4HAAAAmDdtCGp+3/11VXDy2Dke7zHdX1ddB/77qR4EAAAAmE9jD2pqreclubCn6kVzPGRv/xfXWs+d4/EAAAAABjL2oKbrK+mscClJ7ltKecZcDFJKeXqSvdNZvVOTfGkuxgEAAACYibYENR/t/lrTCWv+q5TyV6McoJRyzyT/1TNGknxslGMAAAAAzEYrgppa6++TfDmdAKUm2SLJt0sp9x9F/6WUvZN8K8mWPWMcW2v93Sj6BwAAABiFVgQ1Xa9Kck3385rk9kl+XEp5Tyllq5l0WErZspTy7iQ/TnLH3HZg8bLueAAAAACt0Zqgptb65yTPSbJyVVWS9ZP8c5ILSymfKaUcVErZZbp+Sil3KaU8rZRyVDqHFL8uyaLctuXp1iTPq7X+aY5+KwAAAAAzsmjcE+hVa/16KeX5SQ5Psji3hSsbJDmo+5FSynVJLktydZLrkyxNsnmSbZJs2tPlqrNoVvWzIslLaq1fnePfCgAAAMDQWhXUJEmt9X9LKWck+VySnXPbdqXS89imuS2QqY3XJnTX0/a8JAfVWn8x0gkDAAAAjEhrtj71qrX+MsmeST6QzoqZ3pUxzY/p6ku3/X8k2UtIAwAAALRZK4OaJKm1XltrfU2SOyV5Y5KT0jlfpgzwcWv3+Tcm2bHW+upa6zWTBgEAAABokdZtfWrqBiz/muRfSykbJ3lgkrsn2ar7sWmSa5Nc2f04PcnPaq03jGfGAAAAADPT+qCmVzd8+V73AwAAAGCt0tqtTwAAAADrGkENAAAAQEssqK1PzF4pZcMkD07nnJ8tkyxPckGSn9dazxnn3AAAAGBdJ6hpsVLK0Ume3qg+v9a60wz62ibJwUmen2TpFM/8KsmhtdZjh+0fAAAAmD1bn1qqlPK3mRzSzLSv/ZKcluRlmSKk6bpvkq+UUj5VSlkyirEBAACAwVlR00KllM2TfGREfT0kyTeSbNR46eok56az/elOSdbvee25STYppTyl1lpHMQ8AAABgzayoaaf3Jtm++/n1M+2klLJlks9lYkhzfpInJNmq1nqfWuvOSXZK8tFG8yclefVMxwYAAACGJ6hpme42pRd3iyuTvG0W3b0uyXY95XOTPLjWemzvSpla6wW11n9I8qZG+7d2wx4AAABgHghqWqSUslGSjycp3aoPJfnFDPvaJskrGtUvqbVeNE2zdyX5QU958ySvncn4AAAAwPAENe1yaJJdup//KcmbZ9HX05Ns0lP+Qa31u9M16K6yaa7geWEppfR7HgAAABgtQU1LlFL2TvKqnqqX1Vqvm0WXBzbKhw/Y7oR0tkitcockD5zFPAAAAIABCWpaoJSyOJ0gZdXNS8fUWr8+i/42SfLQRvW3B2nbXVVzfKP6cTOdCwAAADA4QU07vDHJX3U/vzrJP82yvz2SLO4pn1trvXiI9j9ulPec5XwAAACAAQhqxqyUco9MvG3p9UOGKv3s3iifNmT75vPN/gAAAIA5IKgZo1LKeulseVrSrfphko+NoOu7Ncp/HrJ98/k7l1I2nMV8AAAAgAEsGvcE1nH/lNsO6l2e5O+6Z8TM1raN8gVDtr8kyS257etjvSRbJ7lwlvNKKWXbJNsM2WyXNT8CAAAAC5+gZkxKKTsnOayn6l211tNH1P0mjfL1wzSutdZSyo1JNp2mz5l6aZKDR9QXAAAArFVsfRqf/0mytPv56UneOcK+m6HKTTPo48Y19AkAAACMmKBmDEopL0qyf7dY09nytHyEQzTPk5lJ3zc3yhvNcC4AAADAgGx9mmellDsmeV9P1cdrrT8c8TDNFTRL+j41vQ3W0OdMfTjJMUO22SXJsSMaHwAAAFpLUDP//ivJFt3PL07y/+ZgjOsa5Znc2NRcQdPsc0ZqrZcmuXSYNqWUUQwNAAAArWfr0zwqpTw1yRN7ql5Za716DoZqhipL+z41hdJJRuYkqAEAAACmJqiZX+/t+fy4Wuvn52ic5oqVHYZsf/tMXG21Msnls5oRAAAAsEa2Ps2vLXo+P6CUUmfQx537tNur1vqbnvIZjdd3HHKM5vPn11pHdUYNAAAAMAUratZOpzfK9xiy/e5r6A8AAACYA4KatdOpSVb0lHfq3jY1qH0a5d/MekYAAADAGtn6NL8OTLJ4yDb3zsTrvC9J8uzGM2f1Fmqt15ZSfpDkET3Vj0xy5JoG6x4kvH+j+msDzxYAAACYMUHNPKq1fn/YNqWUWxpVN9Vajx+g6VczMah5UQYIapI8LMnOPeVLkvx8gHYAAADALNn6tPb6bJLre8oPLaU8fLoG3dU0BzeqP1FrXTnqyQEAAACTCWrWUrXWS5P8Z6P646WU7aZp9sYkD+0pX5OJV4oDAAAAc0hQs3Z7T5KLe8o7J/lJKeXx3dUzSZJSyg6llP9O8o5G+3fUWq+ch3kCAAAAcUbNWq3WemUp5aAk30qyYbf6zkmOTXJ1KeXcJFsk2THJ+o3mx2biIcYAAADAHLOiZi1Xa/1BkgOSNFfGbJFkr3RW2TRDms8kOajWWud8ggAAAMBqgpp1QK31e0nukeQjSW6Y5tFfJ3lyrfVZtdab52VyAAAAwGq2PrVcrfXEJGVNzw3QzyVJXlpK+eckD06yezqrapYnuTDJz2utZ812HAAAAGDmBDXrmFrrjUm+2/0AAAAAWsTWJwAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaIlF454AAAAAI3bI5uOeATBDVtQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALTEonFPYF1XSilJdkryV0l2SLJFkpuTXJXkzCS/qLXeNOIxN02yT5K7JtksyY1Jzk/yk1rrRaMcCwAAABicoGYMSilbJnlCkr9J8vAkt5vm8RWllOOSfKDW+v1ZjrtzkrcneVqSJX0eqaWU7yc5uNb6g9mMBQAAAAzP1qd5Vkr5ryQXJzkincBkupAmSRanE+qcWEr5VCllsxmO+7Qkv0/y7PQPaZKkJNmvO9a7u6t9AAAAgHliRc38e0D6ByW3JvlLkkvSCWfunGTzxjPPTXL3Usojaq3XDTpgKeWpSY7O5GDusiR/TrJtku3TCWrS/fX1STZI8upBxwEAAABmx4qa8bo6yYeTHJBky1rrnWqt96u13jvJ1kkeluSHjTb3T/LJQQcopeyS5BOZ+N/6t0keXmvdttZ631rrnZLsnuRLjeavKqU8aYjfDwAAADALgprxOC/Ji5NsV2t9Wa31G7XWa3sfqLXeWms9MZ2w5n8a7Z9cSnnYgGMdmmRpT/kXSR5aaz2hMd4ZSZ7SZ6z3lFKsvAIAAIB5IKiZfwcnuVut9fBa641rerjWemuSlyb5ZeOlF6+pbSlljyQH9VQtT/K8WuuyKcaqSV6Zzm1Tq+yS5AVrGgsAAACYPUHNPKu1HldrXT5km1uTvKdR/egBmr4wE/8bf7bW+oc1jHVTknc3qtcYCgEAAACzJ6hZOJpn1WxdStl4DW0e3ygfPuBYn0tyfU9571LKdgO2BQAAAGZIULNwXNWnrnkr1GqllLsl2bWn6vokPxlkoFpr89mSzoHHAAAAwBwS1Cwc2/epu2Ka5/dslE+qtd4yxHg/XkN/AAAAwIgJahaOv26Uz1/DWTe7N8qnDTle8/lmfwAAAMCICWoWjhc2yt9Yw/N3a5T/POR4zeeb/QEAAAAjJqhZAEopj03y0Eb1J9fQbNtG+YIhh72wUd5myPYAAADAkBaNewJMr5SyVZKPNqq/Ums9aQ1NN2mUr+/71NSazy8upWxQa715yH4mKKVsm+FDn11mMyYAAAAsFIKaFiulrJfkqCQ79FRfk+SfBmjeDGpuGnL4G6foc1ZBTZKXJjl4ln0AAADAWsnWp3Z7b5LHNOr+vtY6yHkzGzbK0x083E+/QGajIfsAAAAAhiCoaalSyj8leU2j+j211s8N2EVzBc2SIaewwQB9AgAAACNk61MLlVKemeQDjepPJnnDEN1c1yg3V9isSb/VM80+Z+LDSY4Zss0uSY4dwdgAAADQaoKalimlPC7Jp5KUnuovJXlxrbUO0VUzVFk65FSaz99Sa531ippa66VJLh2mTSllzQ8BAADAWsDWpxYppTwsndUmvQHad5I8o9Z665DdNcOQHfo+NbXtG+XLhmwPAAAADElQ0xKllAck+WomblH6SZIn1lqHPQg4Sc5olHccsn3z+dNnMAcAAABgCIKaFiil3CvJ/2Xildq/TvLYWuv1M+y2GazcY8j2u6+hPwAAAGDEBDVjVkq5Wzrbm7bsqf5DkkfXWq+ZRde/aZT3LqUMcybRPmvoDwAAABgxQc0YlVLunOT4JNv2VJ+b5JG11lmdCVNrPT3J2T1VS5M8eMB5LU3yoN7uknx9NvMBAAAA1kxQMyallDsm+W4mHvJ7YZJH1FovHNEwX22UXzRgu4MycRvWL2utF41mSgAAAMBUBDVjUErZKp3tTrv0VF+Wzkqac0c41BHprIZZ5emllObZM825bZjkDY3qw0c4JwAAAGAKgpp5VkrZNMk3k+zRU311kkfVWv8wyrFqrb9P8vmeqiVJPlVK2WyKuZUkH0iyW0/1OekEPgAAAMAcG+ZwWUbjq0n2btT9W5LblVL2H7KvX9Var1rDM29O8rdJNu6W907yg1LKq2qtJ656qJRy1yTvSvKkRvs31FpXDDkvAAAAYAYENfNvvz51b59hXw9LcuJ0D9RazyqlvCjJZ5KUbvW9k5xQSrksyZ/SOcx4h57XV/lQrfWYGc4NAAAAGJKgZh1Qa/1sd1vT4Uk26nlpm+5HP+9L8v/mem4AAADAbZxRs46otR6d5J7prKyZbivTD5LsV2t9Xa21TvMcAAAAMGJW1MyzWmtze9F8jn1OkmeVUv4xyUPSOTR40yQ3pbMF6scjvBocAAAAGJKgZh1Ua12W5BvjngcAAAAwka1PAAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaYtG4JwAAALBWO2Tzcc8AWECsqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAAAAQEsIagAAAABaQlADAAAA0BKCGgAAAICWENQAAAAAtISgBgAAAKAlBDUAAAAALSGoAQAAAGgJQQ0AAABASwhqAAAAAFpCUAMAAADQEoIaAAAAgJYQ1AAAAAC0hKAGAAAAoCUENQAAAAAtIagBAAAAaAlBDQAAAEBLCGoAAAAAWkJQAwAAANASghoAAACAlhDUAAAAALSEoAYAAACgJQQ1AAAAAC0hqAEAAABoCUENAADA/2/vzsMlqcrDj39fGJZhcVgExUEYFkFQEVQkQtQBURNxAQSCMW5gMJqoaATRYIAYISrmJzEiJvgDEgMiRkIUiREFUUhcENCwqKwKo+zDOjDD8OaP6hu6z3TfXm7fe+t2fz/P0w9Tp0/VOUy/U9X9Vp1zJKkmTNRIkiRJkiTVhIkaSZIkSZKkmjBRI0mSJEmSVBMmaiRJkiRJkmrCRI0kSZIkSVJNmKiRJEmSJEmqCRM1kiRJkiRJNWGiRpIkSZIkqSZM1EiSJEmSJNWEiRpJkiRJkqSaMFEjSZIkSZJUEyZqJEmSJEmSasJEjSRJkiRJUk2YqJEkSZIkSaqJebPdAUmSJEmaUccumO0eSFJHPlEjSZIkSZJUEyZqJEmSJEmSasJEjSRJkiRJUk2YqJEkSZIkSaoJEzWSJEmSJEk1YaJGkiRJkiSpJkzUSJIkSZIk1YSJGkmSJEmSpJowUSNJkiRJklQTJmokSZIkSZJqwkSNJEmSJElSTZiokSRJkiRJqgkTNZIkSZIkSTVhokaSJEmSJKkmTNRIkiRJkiTVhIkaSZIkSZKkmjBRI0mSJEmSVBMmaiRJkiRJkmrCRI0kSZIkSVJNmKiRJEmSJEmqCRM1kiRJkiRJNWGiRpIkSZIkqSZM1EiSJEmSJNWEiRpJkiRJkqSaMFEjSZIkSZJUEyZqJEmSJEmSasJEjSRJkiRJUk2YqJEkSZIkSaoJEzWSJEmSJEk1YaJGkiRJkiSpJkzUSJIkSZIk1YSJGkmSJEmSpJowUSNJkiRJklQTJmokSZIkSZJqwkSNJEmSJElSTZiokSRJkiRJqgkTNZIkSZIkSTVhokaSJEmSJKkmTNRIkiRJkiTVhIkaSZIkSZKkmjBRI0mSJEmSVBMmaiRJkiRJkmrCRI0kSZIkSVJNmKiRJEmSJEmqCRM1kiRJkiRJNWGiRpIkSZIkqSZM1EiSJEmSJNWEiRpJkiRJkqSaMFEjSZIkSZJUEyZqJEmSJEmSasJEjSRJkiRJUk2YqJEkSZIkSaoJEzWSJEmSJEk1YaJGkiRJkiSpJkzUSJIkSZIk1YSJGkmSJEmSpJowUSNJkiRJklQTJmokSZIkSZJqYt5sd0CzIyK2AV4IbA6sCdwLXAdclpmPzGbfJEmSJEkaVyZqxkxE7At8BHhehyoPRsTpwHGZeddM9UuSJEmSJDn0aWxExFoR8UXgXDonaQDWA/4MuCYiXjIjnZMkSZIkSYCJmrEQEasBZwNvLN5aCdwEXAncV7y3CXBBRLxo2jsoSZIkSZIAEzXj4gjgdUXZKcAWmbl1Zu4CbATsD/yqqc46wJcjYsHMdFOSJEmSpPFmombERcTGwF8UxR/KzHdm5pKJgsx8PDPPBXYHbm6quznw/mnvqCRJkiRJcjLhMXAksH7T9iXAxztVzszbIuLtwIVNxe+LiL/LzLunqY+SJEkaZ8f6ALckTfCJmhHWmJvmbUXxsZmZk+2Xmd8GvtdUtD5w0JC7J0mSJEmSCiZqRtvuVJMCT7gRuLjHfb9QbO87hP5IkiRJkqRJmKgZbfsU29/q9jRNc91ie3FErDuEPkmSJEmSpA5M1Iy2nYvty3rdsTHR8M1NRWsCO069S5IkSZIkqRMTNaNth2L7mj73L+uXx5MkSZIkSUNkomZERcR8YIui+Nd9Hqasv/3gPZIkSZIkSd24PPfoejIQTdsrgDv6PMZtxfamU+oREBGb0jrBcS+e2bxx/fXXT7UbkiRJqpM7Vs52DyTNtKuvnu0eTKrN7841Z6ptEzWja71i++E+JhKe8FCXYw7iXcAxUznAvvvuO4RuSJIkSZJmzeeePds96NfTgStmoiGHPo2uMqnyyADHWNblmJIkSZIkaYhM1IyutYvt5QMc49Fie/6AfZEkSZIkST1w6NPoKp+gGWQ83VpdjjmIk4Fz+txnPeAFwP3AfVSTHA+SeJpu2wDnNW2/DrhhlvqiucGYUb+MGfXLmFG/jBn1y5hRv+ZKzKxJNdxpwndnqmETNaPrwWK7fMKmF+UTNOUx+5aZd9D/pMYAP5hq29MtIsqiGzKz3jNkaVYZM+qXMaN+GTPqlzGjfhkz6tcci5kZmZOm5NCn0VUmVdaJNv8iuli3yzElSZIkSdIQmagZXXcBzas8rUH/y2svLLYHeRJGkiRJkiT1yETNiMrMZcCviuIt+jxMWf+6wXskSZIkSZK6MVEz2srEyo597r9Dl+NJkiRJkqQhMlEz2q4stnfvdceI2AxY1FS0Arhm6l2SJEmSJEmdmKgZbV8vtvfuY0LhVxTbF2WmkwlLkiRJkjSNTNSMtsuoJhWesDWwuMd9Dy22z2tbS5IkSZIkDY2JmhGWmY8DpxfFx3R7qiYiXga8uKnoAeDLw+2dJEmSJEkqmagZfR8HmocsvRT4YKfKEbEQOLUoPikz72pXX5IkSZIkDY+JmhHXSLAcXxSfEBEnR8TTJgoiYrWI2JdquNSiprpLgE9Ndz8lSZIkSZKJmnHxcVadWPidwK8i4oaI+AlwN3AusEVTnWXAQZm5dEZ6KUmSJEnSmJs32x3Q9MvMxyPiQOA04OCmt1anmmC4nbuBAzLz0unu3wi5Eziu2JYmY8yoX8aM+mXMqF/GjPplzKhfxkwXkZmz3QfNoIh4PXA0sHOHKg8BZwDHZeYdM9UvSZIkSZJkomZsRcS2wG7AQmBNYClwLXBpZj4yi12TJEmSJGlsmaiRJEmSJEmqCScTliRJkiRJqgkTNZIkSZIkSTVhokaSJEmSJKkmTNRIkiRJkiTVhIkaSZIkSZKkmjBRI0mSJEmSVBMmaiRJkiRJkmrCRI0kSZIkSVJNmKiRJEmSJEmqCRM1kiRJkiRJNWGiRpIkSZIkqSZM1EiSJEmSJNXEvNnugDQqImIb4IXA5sCawL3AdcBlmfnIbPZNc19ErA3sDjwT2BBYDtwK/CAzb5zNvqk3ERHAIuA5VOeJDYBHqc4VvwR+NOxzRUSsD+wBbAc8CVgG3EJ1XloyzLY0fBGxJtW/+UXAQmB9YA3gfuBu4KfAtZm5ckjtzQN2A54NbAysBH4DXJ6ZVw+jDY0Or0sahHEzmiJie+C5VN9v1qH6vnE78Avgqsx8dArHHsuYicyc7T5Ic1pE7At8BHhehyoPAqcDx2XmXTPULU2ziFhIlZjbrfHfF1D9iJpwS2YuGkI7mwDHAG8F1u1Q7XLgo5l53lTb03BFxIbAvsDvAXsBT56k+grgfODTmfndKba7FfBXwEFUieNSAt8FjsnMS6bSloYrIg4A9qZKsD2T7jfV7gPOAk7KzOsGbHM94CjgncBGHar9HPg4cHr65XHOiYizgIOL4oGuU16X5r6IOJbqMxzUGZn51j7bNG5GTONm0LuBtwNbTVJ1OfBD4CuZeVIfxx/rmDFRIw0oItYCvgC8scdd7gQO8EfR3BURewB/TpWceVqX6lNO1ETEYuAcJv9x3+yfgD/OzOVTaVfDERGfpfry0i5R0s0/Ae/OzPsHaPcg4DSqO1rdJPAJ4EP++K6HiLiV6umZfq0Ajqe6KdDzZxkRzwHOY/Iv2c2+CfxBZt7Xfxc1GyLiNcC/t3mr7+uU16XRMNOJGuNm9ETEq4FTgaf0sdvtmfnUHo+/mDGPGYc+SQOIiNWAs4HXFW+tBH5FdYdzK2BB03ubABdExN6Z+V8z0lEN267AfjPRUET8LvANYH7x1lLgJqpHP58OrN703puB9SLiAH9018JutE/STAwnuZ1qGMuWtJ4roPosnxkRL8vMB3ttMCIOpHq6opyD7k7g18CmVEmAmNgF+CCwFvC+XtvRjHuEJ64tq1F9cd2CJz5HqGLpGKrzwqG9HLTxqPp3WPWL8IPAjVTnn0WNY094JdW1bC+H9dZfRCwAPjekY3ldUt+Mm9ETEe8DPkXrNQiqa9US4C6qz3szek+0NB/fmMHJhKVBHcGqSZpTgC0yc+vM3IXq8fH9qb5cT1gH+HLji5NGS88/prtpDJc5m9YL1C1UQ2g2ysznZeZWVD+gPl/svj/+4K6jpcDJwD7Ahpn59Mx8QWY+l2oukD2B7xX7vJBq2GRPGvNknUbrtf0qYK/M3DQzn5+ZTwd2AL5a7H54ROzfx/+PptcS4B+BNwHbAutm5vaZ+cJG3CyiipvDqMbpNzskIt7WrYHGfDTl3cp7gLdQnWeem5nbAU8FPgY83lTvRVRPYqn+PskTT2g9NOhBvC6NvA8AL+/j1dO/f+Nm9ETEocDf0pqkuQD4fWCDzNwmM3fLzJ0ycxOq88+bgH+lGgLV7fjGzITM9OXLVx8vqi/H91MNGZh4HTVJ/YVU2d/m+sfN9v+Hr4E++8Mbn9/9wEVUX1QOoHoiYnHxGd88hXaOL451I/C0Sep/uKi/lCoZMOt/Z+P8An7c+Ld/KDC/h/qrU33pyOK1Z4/tnVns90PgSR3qRpu2rgfmzfbf27i/gJ1oDE3vsf6GVGP0mz/LJcBqXfY7rNjnHmDHSer/YVF/BfCM2f778jXpZ7yYKsGWVE/yHTHodcrr0mi9gGOLz2fxNLVj3IzQi+rGwbKmz2c58IY+9u/6WRozT7x8okbq35G0Thp7CdUEi21l5m1U81Q0e19EbDwNfdP0+hrwLKo7Bntm5pGZ+ZXMvGVYDTQmTnt3UfzHOfkKPSdQxeGEBVR3xzS7jgG2z8wvZOaybpWzWrnnXVQJnmbl+WMVEfEs4A+aipYDb8kOc9xk9e3mvVSrTU3YBuj6JIamV2b+tPH59Fr/XuCPqL6gTtiMajLithqrSR1dFH8gM6+ZpJ0zgS82Fc2j+rGnGoqI+VTzR0zc9f4M8KMBj+V1SX0zbkbSPwBrN22/MTPP6nXnxvWqI2OmlYkaqQ+NuWnKHzLHdvtSnZnfpnVYw/pUq7FoDsnMGzLzmsx8vHvtgR0MrNe0fUkjfibrVwLHFcWHNJaD1izJzPOzz0ntGsma8pHyV/aw6yG0XtO/lJnXdmnrEeBviuKuSSHVT+Ozvrwo3mGSXV5JNb5/ws1Uw+a6OZbWhNCBDuWtrY9SJV+hGoJdJub64XVJgzBuRkhEvI5qmPaEczLznCE3Y8w0MVEj9Wd3qkmBJ9wIXNzjvl8otvcdQn80esq5j8q46eQiqmE2E54K/M5QeqSZVs5Vs3FEdFvB6bXFdq9xczat81bsGhHdVjRTPd1QbE82gWN5njmtl6d4MvMGqmXdJ6wBvKq37mmmRMSuVEN1J/xp9jEpeRtelzQI42a0HFZsl8mRYTBmmpiokfqzT7H9rT4eUf9Wsb04ItYdQp80IiJiPeAlRfF/9rJvIw4vLIpfPYx+aca1ezS441MLjZV7tm0qegi4rJeGMrOsG6x6ntPcsHaxvXSSuuVn3NN5pqG8lnmeqZGIWIPqx83EaijnZObXp3A8r0vqm3EzWiJiIa1P916ZmVcPuQ1jpmCiRurPzsV2Tz+GABrjK29uKloT2HHqXdIIeRaty+DelJm/7WP/S4vtnafcI82GhW3K7p6k/s7F9g8z87E+2jNu5rjGI967FsXlUKiJuk+huts44VHgJ300Z7zU24eA5zT+vBR4zxSP53VJgzBuRsvv0boU9kXT0IYxU5g32x2Q5phyzH/HiRc7uIZqObnm4w00uZ9G0jDia7LjaW54cbF9S5e5bowbHQI0D1m7jmrVr3bKz/f6PudSKuNl24iY12dyUNMgInYE/qKp6IN9/tBpx/PLmIiItYCtqVY3XUF1g2BJZj48wOGMm9FS3gi4auIPEbEL1fydLwW2ANYC7qBarOCbwFmNhVW6MWYKJmqkHjVWUNiiKP51n4cp628/eI80gsp4mGp8bRkRazcmjdXccUix/Y0u9YcdN56X5pCIeAtwclPR48CfTTIsd0rxkpl3RsQjPDHUak1gK1pXENMMayx28AWqzwOqua7+cQiH9ro0Hj5LlaQph1A+FhGXAxcAJ2fmnT0ez7gZLWWi5sbGUKWTWPU7C8CWjdfewF9FxKeBYzJzxSRtGDMFEzVS757ME8tcQnW34Y4+j1FmlDedUo80asp4uLXP/W8HHuOJc/tqVHfGermToRqIiFex6hjt07vsNtW4KeNjk7a1NCsiYjtabxKsAWwIPJtq4sXmIbTLgcO6rJIx1XgBWEL1o675mCZqZtd7eGLyzIk46HmZ90l4XRoPnYbizwN2a7w+GBEnAsc1ViicjHEzWrYtth+nWhJ7lx72nU81JHPXiNg/Mx/oUM+YKZiokXq3XrH98ABfgh4qtstjaryV8VDGy6QyMyNiGdXy752OqZqKiI2AzxfF/5aZnYawTJhS3LSpv0ZErJWZj/Z5HE2PdwHv7VIngf8APpSZV3WpO9V4abeP55lZFBFbAX/dVHRCZl43pMN7XdKE+cBHgBdHxGu6rCRm3IyIxtN66xfFf8cTSZoEvk719O+twLqN995E65DcvaluPL2+Q1PGTMHJhKXelf/YB3mUblmXY2q8GWNjqvFF6IvA5k3F99HbRKBTjZsyZtodU/V2DvCxHpI04HlmFP0D1Y8jqOYnOn6IxzZeRldSLYrxF8DLqa4/61ANf1oIvIbq5kH5mS8GvhQRq9OZcTM6FtA6ogDgeY3/3g28NDNfm5mnZObXM/PszDyKaijTmcV++0fEmzu0Y8wUTNRIvSvH7fYz+eKE8g71/AH7otFkjI2vTwK/X5S9IzN7GaM91bhp9+SMcTO3HAR8PyIuiYjyEfWS55kREhGHUt2phuqH92F9Tg7djfEymv4TeGZm7pGZx2fmhZl5W2Yuy8xHM3NJ40f3nwDPYNUVdfahetqvE+NmdHRKdqwE9snM77V7s/HE1ZtYdYntDzdWKiwZMwUTNVLvyszumm1rTW6tLsfUeDPGxlBEvAd4f1H8icw8u8dDTDVuyphpd0zNksw8PDNj4kV1x/vpwKupJo9tvoP4YuBHEfGCSQ7peWZERMRmwIlNRad2+tE0BcbLCMrMyzLzFz3WvZUqGfhfxVtHR8Q6HXYzbkZHp7/3UzPzB5PtmJmPA++kmtNmwvZUK0R1a2fsY8ZEjdS7cixumfntRZnZnWx8r8aPMTZmIuIPgU8XxacDR/VxmKnGTbs7TsZNTTXueN+amedn5tuBnYArm6psAPxbRGzQ4RCeZ0bHZ6k+b4DfAkdOQxvGi2isnPNmqslaJ2wKvKLDLsbN6Oj0997TqnKZeSNwYVHcLlFjzBRM1Ei9K/+xr9Ph0b3JrFtsz+kTiIaujIcyXibViMeRukiNsoh4NXAGrWO/vwq8vc+JyqcUN23qPzaXl7McN5l5PdX8Es3D5BYCR3TYZarx0m4fzzMzLCIOBPZrKnpvZi6dhqa8Lgn4v3PNvxfFvSZqjJs5KjOXUQ1zavYAcEUfh/lusd3uqU9jpmCiRurdXVTjvyesQf/Lay8stvtd3lujrYyHzdvW6uwptK7m9zhV3KpmImJPqglgmz+vbwFv6GHZ09JU46Y8L93Z5/6aZZl5F3BMUfzWDtWnGi/QupJHu2Nq+n2y6c/nZ+aXp6kdr0tq9u1ie/sO9Yyb0VJ+ntc3hjX16ufFdrvfT8ZMwUSN1KNGRvlXRfEWfR6mrD+s5TM1GsoL2VTj6xafjKifiNiN6q5k82O9lwH7DTgJ6LDjxvPS3HQurTcTnhYRW7apN6V4iYhNaY3d5cCN/RxDQ7FB05/3iYjs9gIuKo6xZZt6Oxd1vC6pWTnB/SYd6hk3o+XaYvv+Pvcv62/Ypo4xUzBRI/Wn/AGzY5/779DleBpvxteIi4idgAtoXUXhCuBVmfnQgIc1bkRj2Ms9RfFT21QtP99tIqKfSRvLeLkhMx9rW1OjwPOLmq0ottfoUM+4GS3XFNvtFiGYTDnfzMNt6hgzBRM1Un+uLLZ373XHxuoMi5qKVrDqiU/j7WpavwQtasRNr/Yotq+cco80NBGxPdXwpuY7SdcCr8zM+6Zw6CuL7V0jYl67ih0YN6Or/FFFZv6WauLZCWsBz+/jmMbLePG6pGZl8rfTUFnjZrT8pNh+Sp/7l0Od7m5Tx5gpmKiR+vP1YnvvPiYULidcuygz5/QkVxquzHwAuKQofnkv+zbicO+i+GvD6JemrjEE5UJav6zcBLw8M6c0J0xmXgfc0FS0Lj0mkSNiXeBFzYdj1fOc5oCIWB/YqCi+vUP184vtns4zHep6npkdr6P6LPp5faA4xu1t6lzfXMHrkgq/W2yXQ6EA42YEnU/rEttbRUR5vZlMeTOgHOZkzLRhokbqz2W0Tky1NbC4x30PLbbPG0aHNHLKFRXKuOlkT2Crpu3bgR8MpUeaksYdoW/TOjHebcDLMvO2ITUzaNz8Aa3DsH6cmUuG0yXNsH1oXUHsTuA3HeqW8fK2Xm46RMQ2tC6rugL4Rj+d1HBk5ncz88J+XsDlxWEeaVOv3Q0kr0siIjYAXl8Ul5MLNzNuRkRm3gFcWhTv38u+jSd89yuKL+5Q3ZhpYqJG6kNjhvPTi+Jjun3BjYiXAS9uKnoAmK4VGjS3fQlonqvkJRGx12Q7NOKvXPHltD5n5Nc0aNxx+hawTVPxnVRP0tw0xKb+P60TyR4cEeV47bJvawNHFcVfGGKfNEMiYj5wXFH89UnOAd8Ebm3aXgS8rYemjqU1GfSvUxy2p7nB65IATqR1EuvlVHOudWLcjJbPF9tHREQvc9X8Ma1D5u6nuga1Y8w0MVEj9e/jQPMdp5cCH+xUOSIWAqcWxSc1llOVWjTuWvx9UXxqRJTL4Tb7EPCSpu37aF26VbOgMRTlP4BnNRUvBV6RmeUKClOSmf9Da/J3TeCMiHhSh74F8GngGU3FN1IlfDRLIuITEbFrn/tsRHUXcrum4pXA/+u0T2Y+CnysKD4xIjpO3hgRfwj8UdFG+eVYI8jr0miJiKMioud5qSJiXkR8ilWfbjglMzs9tWfcjJ6zgJ81bW8HfD4iOuYTGqtcfqIoPrlTgt+YaRWZ2b2WpBYR8SHg+KL4c8BfTwwbaJy4XgucROuScUuAZzVW6NAcExF7APPbvPVcqrtNE26n9UdNsyWZ2XEi6cYPr6tpvQNxC/Ae4GvZOHFHxObA0cA7ikMcmZkjcZGayyLiIlYdGvmXwH8NcLjLM/PeLu1tC1wFrNNUfBVweGZe3FRvO+AEVn1s+aDMPGeAvmlIIuJKqnPJD4Gzge8AV2fmiqJeANsDB1KdF55cHOrEzDyiS1trUK041pxIvAd4H3DmxEpOjfPR+4AP03qD7+TM/NN+/v80uyJiMa1LdN+SmYt63Nfr0oiIiIupbjJeRpXg/zZwXbl6W0QsAF4FHAnsXBzmBmC3zGw3KWzzMYybEdIYIfAtWp+svBA4KjMvb6q3gCqxdxytw6t/AbygMR9NpzaMmQYTNdIAGkmY84BXF2+tpDqZ3Ec1VnKD4v1lVEMeynGemiMi4mZgyyke5ozMfGuXdl5C9WhouaThUqpJaDegSgCuXrx/HrBfenKfdRExzM9gz+ZkyyRtHgycSeuXKKiGW/2KajLjzdu8/5nMfM8Q+qkpaErUNFtONafR0saf1wee3vhvO2cAh/Ty2HdjeNz3WXUS4gepfojNp7qWlUvw/hBYnJnLurWh+phKoqaxv9elEdCUqGn2KNVwyPuovstuTDUkst3TEr8FXpKZv+yxPeNmhETEB4G/afPWb6liaF2q4d5rFu/fTfVd5mfljm3aMGYwUSMNrDG/w2nAwT3ucjdwQC8/tlRfM5WoabS1F3AOq/6I6uRMqh9oj06hbxqS2UjUNNp9A9VcM+2e/GrnRKo7UH4hmGUdEjW9up9qzqFT+vksI+K5VF9uez2vXQgc6FOhc89UEzWNY3hdmuM6JGp69Q3gbY0hKv20adyMkIh4N/ApVk3id/Jz4DW9JvcabYx9zDhHjTSgzHwkM98AHABcOUnVh4CTgR1N0qgfmfkdYEeqYXUPT1L1CuD1mfnGUbpAaTCZeRbwbKovLSsmqXoJ1VMRR5ikqY03UM15diFV4qWbBH4KHAFsm5mf6/ezzMyrgOdQDYebbHjdL6kmhXyFSZrx5XVpJHwMOIVqeMnKHuo/SPWD+aWZuU+/SRowbkZNZn4G2IlqiO5k3zNuAt4L7NRPkqbRxtjHjE/USEPSmB9iN2Ah1eN+S4FrgUsz85FZ7JpGQGNVl92BHage+ZwYDvGDzLx+FrumGmtMJvy7VJMGrw88QjUE6tIc3tLgmgaNIbbPALalesT7SVR3Lx+gGp5wM/CTzOwlodNrm2tQXceeTTX0YSXVEt8/6eVxdY0Xr0tzX0SsQ/VjeBGwGdV8IqtRfYe9F7gG+Flm9pLQ6bVN42aENL5n7E51vVpAldi7neq68fMhtTGWMWOiRpIkSZIkqSYc+iRJkiRJklQTJmokSZIkSZJqwkSNJEmSJElSTZiokSRJkiRJqgkTNZIkSZIkSTVhokaSJEmSJKkmTNRIkiRJkiTVhIkaSZIkSZKkmjBRI0mSJEmSVBMmaiRJkiRJkmrCRI0kSZIkSVJNmKiRJEmSJEmqCRM1kiRJkiRJNWGiRpIkSZIkqSZM1EiSJEmSJNWEiRpJkiRJkqSaMFEjSZIkSZJUEyZqJEmSJEmSasJEjSRJkiRJUk2YqJEkSZIkSaoJEzWSJEmSJEk1YaJGkiRJkiSpJkzUSJIkSZIk1YSJGkmSJEmSpJqYN9sdkCRJ0vBExNOAnYAtgQXAGsBS4F7geuDKzFw+5DY3BnYBFgEbAmsB9zXavAW4PDMfHmabkiSNqsjM2e6DJEnSSIiIm6kSJJN5nCeSGNcCPwLOycxrptDuVsA7gNcD23apvrzR5r8AZ2fmPQO2+RTgMOBA4Dldqq8ErgK+BPxLZi4ZpE1JksaBiRpJkqQh6TFR08m3gXdm5i/7aG9j4ATgEGD1Adp8FPgM8NeZeV+Pba4DfAQ4HFh7gDZXAmcAR2fmbwbYX5KkkWaiRpIkaUimmKgBeBg4IDMv6KGt3wG+AizsUOUB4A7gbqrhSJsB63Woe1dmbtJDm9sB5wI7dqjycKPNO4H1G20u6FD3IWCbzLy9W7uSJI0T56iRJEmaPh+gGvLTbHVgY+B5wMG0JlrWAc6JiN0z86edDhoRewFfa9Rv9kvgFOCCzLy2zX5bAK+lGiK1uOmtJ3f7H4mI51A99VMmdJYAnwO+AVyRxV3AiNgUeDWwH7APEI231gXmd2tXkqRx4xM1kiRJQ9LmiZo9M/PiSeqvCXwCeG/x1oWZ+fIO+2wJXEH1lMyE5cCRwMmZuaLHvi5utL0rQGbGJHUXNNrcqqk4geOBEzLzoR7b3Bn4OPCKRtFWmXlzL/tKkjQuXJ5bkiRplmTm8sw8nGpi32Z7R8Szy/oRMQ84i9YkzUPAPpl5Uq9JmkbbFwO7AR+lSrpM5lRakzSPAW/JzKN7TdI02rwyM18JvBPoua+SJI0TEzWSJEmz7yiq1aCavaJNvXcBLyrKDs3MCwdpNCt/STUUqq2IeC1wQFF8dGb+8yBtNto9BdiLKskkSZKamKiRJEmaZZl5K6vOZdOy5HVErA68v6jz1cw8ewjtnzvJ20cW2z8CThxCm9/PzDunehxJkkaNiRpJkqR6uLHYLif4PYBVV5Q6dtp6A0TEbsAeRfFHM3PldLYrSdI4M1EjSZJUD+WcLeXqnPsX2z/IzJ9NY3/atXkb1epOkiRpmpiokSRJqoenFdt3F9svLrbPm8a+dGrzfJ+mkSRpepmokSRJmmURsQ6NZbKb3NT0/jbAZsX7P57mPs0Hnj+TbUqSJBM1kiRJdfBuYH5R9p2mPz+zzT5XTF93ANgaWHOG25QkaeyZqJEkSZpFEfEa4KNF8U3A95u2NyreX8mqQ6OGrWwT4I5pblOSpLFXTlInSZKkadRYZntDqmFFbwEOBqKodnRmNk8uXCZN7s/MnL5etm0TYOk0tylJ0tgzUSNJkjR9LoooczBd/W1mnlmUrV9sPzR4l3pWtjlT7UqSNNYc+iRJklQPDwHvysw/b/PeA8X2ujPQn7LNmWpXkqSx5hM1kiRJs+cRqgl6vwqcnpl3dah3T7H9pGntVfs2ARYA989A25IkjS0TNZIkSdPnA8BVRdlKqqdVlgI3Z+ZjPRynTJqsHhEbZ+Z0TijcLlGzKfDraWxTkqSxZ6JGkiRp+lyemRcP4TjXtSnbBbhwCMfu5EZgBbBG0ebl09imJEljzzlqJEmSai4zbwB+UxS/YJrbXAb8eCbblCRJJmokSZLmiu8V26+dhTb3aSwvLkmSpomJGkmSpLnh3GL7RRHxrBluc3Pg96a5TUmSxpqJGkmSpLnhK8AtRdkx09lgZv43cFlRfHRE+B1SkqRp4kVWkiRpDmisDvXpovjAiDhgqseOiFdN8vYni+3fAd4/hDZ3jYhNpnocSZJGjYkaSZKkueOzwA+LstMiYs9BDhaVPwfO61QnM/+NVYdAnRARbxikzUa7fwRcBKw76DEkSRpVJmokSZLmiMxcARwM3NdUvB5wQUT8WUTM6/VYEfFcqmTJiUC3/Q6hddjVPOCLEXFsRKzTR5tbR8RXgX/GJI0kSW2ZqJEkSZpDMvMm4EBgWVPxWsBngP+JiMMjYvt2+0bE5hHxJxHxTeAK4KU9trkUeB1wd1PxalRz5PwiIj4cETt3aPPJEfHmRoLm58B+vbQpSdK4isyc7T5IkiSNhIi4GdiyqWjPzLx4mtraAzgH2KxDlfuAO4B7gQ0a9dbvUPe3mdnpOM1t7kA1DKptIgh4sNHm3VRP+jwV2HCS/m2XmXd0a1eSpHHiEzWSJElzUGZeCuwEnAY83qbKAuAZwAuB7WifpHkI+Ctg2x7bvBZ4PtVwqeVtqqwHbA3sCuxA+yTNCuDvgW1N0kiStCqfqJEkSRqSmXyipmh3G+AdwAHAVl2qPwr8N/BF4OzMfGDANjcDDgMOAnbsUv0xqqFWZwJfzMy7BmlTkqRxYKJGkiRphETE5lRP2mxJ9VTN6lTDjO4BfglclZntnoaZSpubALsAi6ieolkDuJ9q2NWNwE8yc1nHA0iSpP9jokaSJEmSJKkmnKNGkiRJkiSpJkzUSJIkSZIk1YSJGkmSJEmSpJowUSNJkiRJklQTJmokSZIkSZJqwkSNJEmSJElSTZiokSRJkiRJqgkTNZIkSZIkSTVhokaSJEmSJKkmTNRIkiRJkiTVhIkaSZIkSZKkmjBRI0mSJEmSVBMmaiRJkiRJkmrCRI0kSZIkSVJNmKiRJEmSJEmqCRM1kiRJkiRJNWGiRpIkSZIkqSZM1EiSJEmSJNWEiRpJkiRJkqSaMFEjSZIkSZJUEyZqJEmSJEmSasJEjSRJkiRJUk2YqJEkSZIkSaoJEzWSJEmSJEk1YaJGkiRJkiSpJkzUSJIkSZIk1YSJGkmSJEmSpJowUSNJkiRJklQTJmokSZIkSZJqwkSNJEmSJElSTZiokSRJkiRJqgkTNZIkSZIkSTVhokaSJEmSJKkmTNRIkiRJkiTVhIkaSZIkSZKkmjBRI0mSJEmSVBMmaiRJkiRJkmrifwGsrsjBfBogAwAAAABJRU5ErkJggg==\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",
    "for izone, zone in enumerate(zoneUnique):\n",
    "   ax.hist(pccZones[izone], bins = 30, range = (0,60), label=zone)\n",
    "\n",
    "ax.set_xlabel('PCC')\n",
    "ax.set_ylabel('Count')\n",
    "ax.set_title('%d Unit Good PC' % numUnits)\n",
    "ax.legend()\n",
    "\n",
    "plt.savefig('/Users/frederictheunissen/Desktop/pcchistJ%dUnitGoodPCPerZone.eps' % numUnits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x3600 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,12), dpi=300)\n",
    "axZones = fig.subplots(1, nZones)\n",
    "\n",
    "for izone, zone in enumerate(zoneUnique):\n",
    "    ax = axZones[izone]\n",
    "    im_ = ax.imshow(confMatTotZones[izone]*100.0, interpolation='nearest', cmap=cmap, \n",
    "                    extent = (-0.5, ncalls-0.5, ncalls-0.5, -0.5), vmin=5, vmax = 50)\n",
    "\n",
    "    \n",
    "    if izone == 0 :\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='%s %.0f %%' % (zone, np.mean(pccZones[izone])))\n",
    "    else:\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='%s %.0f %%' % (zone, np.mean(pccZones[izone])))\n",
    "        \n",
    "\n",
    "plt.savefig('/Users/frederictheunissen/Desktop/confMatJ%dUnitGoodPCPerZone.eps' % numUnits)\n",
    "\n"
   ]
  },
  {
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}