{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4dff7aff-6f3f-4a06-b86e-846ee7a8659e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit Forward, 4 day gap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3f56af5d-5469-45bc-a6af-8db92e9953aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime as datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from numpy.polynomial.polynomial import polyfit\n",
    "import pandas as pd\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "61614cfb-23e9-484b-85ff-55bf5f69b716",
   "metadata": {},
   "outputs": [],
   "source": [
    "maindir = '/results/forcing/rivers/observations/'\n",
    "origdir = '/data/dlatorne/SOG-projects/SOG-forcing/ECget/'\n",
    "def getdir(river_name):\n",
    "    if river_name in ['Fraser', 'Englishman']:\n",
    "        thedir = origdir\n",
    "    else:\n",
    "        thedir = maindir\n",
    "    return (thedir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d59a50ef-3e7c-4d11-98ae-9c73ed144bae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_river(river_name, ps):\n",
    "    thedir = getdir(river_name)\n",
    "    river_flow = pd.read_csv(f'{thedir}/{river_name}_flow', header=None, sep='\\s+', index_col=False,\n",
    "                      names=['year', 'month', 'day', 'flow'])\n",
    "    river_flow['date'] = pd.to_datetime(river_flow.drop(columns='flow'))\n",
    "    river_flow.set_index('date', inplace=True)\n",
    "    river_flow = river_flow.drop(columns=['year', 'month', 'day'])\n",
    "    if ps == 'primary':\n",
    "        river_flow = river_flow.rename(columns={'flow': 'Primary River Flow'})\n",
    "    elif ps == 'secondary':\n",
    "        river_flow = river_flow.rename(columns={'flow': 'Secondary River Flow'})\n",
    "    return river_flow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2e5bdf57-fa04-400d-b28a-a7a6492a61e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_river_Theodosia(set_primary=False):\n",
    "    if set_primary:\n",
    "        nameit = 'Primary River Flow'\n",
    "    else:\n",
    "        nameit = 'Secondary River Flow'\n",
    "    part1 = pd.read_csv(f'{maindir}/Theodosia_Scotty_flow', header=None, sep='\\s+', index_col=False,\n",
    "                      names=['year', 'month', 'day', 'flow'])\n",
    "    part2 = pd.read_csv(f'{maindir}/Theodosia_Bypass_flow', header=None, sep='\\s+', index_col=False,\n",
    "                      names=['year', 'month', 'day', 'flow'])\n",
    "    part3 = pd.read_csv(f'{maindir}/Theodosia_Diversion_flow', header=None, sep='\\s+', index_col=False,\n",
    "                      names=['year', 'month', 'day', 'flow'])\n",
    "    for part in [part1, part2, part3]:\n",
    "        part['date'] = pd.to_datetime(part.drop(columns='flow'))\n",
    "        part.set_index('date', inplace=True)\n",
    "        part.drop(columns=['year', 'month', 'day'], inplace=True)\n",
    "    part1 = part1.rename(columns={'flow': 'Scotty'})\n",
    "    part2 = part2.rename(columns={'flow': 'Bypass'})\n",
    "    part3 = part3.rename(columns={'flow': 'Diversion'})\n",
    "    theodosia = (part3.merge(part2, how='inner', on='date')).merge(part1, how='inner', on='date')\n",
    "    theodosia[nameit] = theodosia['Scotty'] + theodosia['Diversion'] - theodosia['Bypass']\n",
    "    part3['FlowFromDiversion'] = part3.Diversion * theodosia_from_diversion_only\n",
    "    theodosia = theodosia.merge(part3, how='outer', on='date', sort=True)\n",
    "    theodosia[nameit] = theodosia[nameit].fillna(\n",
    "        theodosia['FlowFromDiversion'])\n",
    "    return theodosia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d949555f-dc1d-44fe-82c3-336b715bba5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "matching_dictionary = {'Englishman': 'Salmon_Sayward',\n",
    "                      'Theodosia': 'Clowhom_ClowhomLake',\n",
    "                      'RobertsCreek': 'Englishman',\n",
    "                      'Salmon_Sayward': 'Englishman',\n",
    "                      'Squamish_Brackendale': 'Homathko_Mouth',\n",
    "                      'SanJuan_PortRenfrew': 'Englishman',\n",
    "                      'Nisqually_McKenna': 'Snohomish_Monroe',\n",
    "                      'Snohomish_Monroe': 'Skagit_MountVernon',\n",
    "                      'Skagit_MountVernon': 'Snohomish_Monroe',\n",
    "                      'Homathko_Mouth': 'Squamish_Brackendale',\n",
    "                      'Nicomekl_Langley': 'RobertsCreek',\n",
    "                      'Greenwater_Greenwater': 'Snohomish_Monroe',\n",
    "                      'Clowhom_ClowhomLake': 'Theodosia_Diversion'}\n",
    "backup_dictionary = {'SanJuan_PortRenfrew': 'RobertsCreek',\n",
    "                    'Theodosia': 'Englishman'}\n",
    "\n",
    "theodosia_from_diversion_only = 1.429 # see TheodosiaWOScotty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6a792d25-2220-4c02-aba0-eb1188fb391b",
   "metadata": {},
   "outputs": [],
   "source": [
    "gap_length = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "48fb9eec-47b7-40a4-b9bb-62fa7d6b54fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimate(primary_river, spoint, point, gap_length, ax, fittedbad, fittype, doplots=True):\n",
    "    goback = 7\n",
    "    bad = False\n",
    "    fitlength = np.array([7, 14, 21, 28])\n",
    "    ratio = np.zeros(len(fitlength))\n",
    "    fitted = np.zeros(len(fitlength))\n",
    "    persist = np.zeros((goback))\n",
    "    linear = np.zeros((goback-1))\n",
    "    cubic = np.zeros((goback-2))\n",
    "    for ii in range(1, 8):\n",
    "        jj = ii + gap_length - 1\n",
    "        if len(primary_river.iloc[spoint-8:spoint]) != 8:\n",
    "            print (len(primary_river.iloc[spoint-8:spoint]), primary_river.iloc[spoint])\n",
    "        persist[ii-1] = primary_river.iloc[spoint-ii:spoint].mean()\n",
    "        if ii > 1:\n",
    "            b, m = polyfit(range(ii), primary_river.iloc[spoint-ii:spoint].values, 1)\n",
    "            linear[ii-2] = b + m * jj\n",
    "        if ii > 2:\n",
    "            b, m, c = polyfit(range(ii), primary_river.iloc[spoint-ii:spoint].values, 2)\n",
    "            cubic[ii-3] = b + m * jj + c * jj**2\n",
    "    if fittype == 'fit':\n",
    "        useriver = matching_dictionary[river]\n",
    "    elif fittype == 'backup':\n",
    "        useriver = backup_dictionary[river]\n",
    "    firstchoice = read_river(useriver, 'primary')\n",
    "    for jj, length in enumerate(fitlength):\n",
    "        for ii in range(length):\n",
    "            denom = firstchoice[firstchoice.index == primary_river.index[spoint-ii]].values\n",
    "            if len(denom) == 1:\n",
    "                ratio[jj] = ratio[jj] + (primary_river.iloc[spoint-ii].values /\n",
    "                            firstchoice[firstchoice.index == primary_river.index[spoint-ii]].values)\n",
    "            else:\n",
    "                bad = True\n",
    "        if not bad:\n",
    "            fitted[jj] = ratio[jj]/length * firstchoice[firstchoice.index == primary_river.index[point]].values\n",
    "    if bad:\n",
    "        fittedbad = fittedbad + 1\n",
    "    if doplots:\n",
    "        ax.plot(persist)\n",
    "        ax.plot(range(1, 7), linear)\n",
    "        ax.plot(range(2, 7), cubic)\n",
    "        if not bad:\n",
    "            ax.plot(fitted)\n",
    "        ax.plot(primary_river.iloc[spoint-7:spoint].values, 'o')\n",
    "        ax.plot(7, primary_river.iloc[spoint].values, 'x')\n",
    "        ax.plot(7+gap_length, primary_river.iloc[point].values, 's')\n",
    "        ax.grid()\n",
    "    return (persist, linear, cubic, fitted, bad, fittedbad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dde6b3e4-bf9b-43b4-b2bb-2031967e09df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pmhalf(test, value):\n",
    "    bads = np.zeros(len(test), dtype='bool')\n",
    "    for ii, tt in enumerate(test):\n",
    "        if tt/value < 0.5 or tt/value > 2:\n",
    "            bads[ii] = True\n",
    "    return bads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6345fd32-a97b-457c-9894-ba6dbdcbd7ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def inbounds(test, maximum, minimum):\n",
    "    bads = np.zeros(len(test), dtype='bool')\n",
    "    for ii, tt in enumerate(test):\n",
    "        if tt < minimum or tt > maximum:\n",
    "            bads[ii] = True\n",
    "    return bads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cf51c048-2760-4cdc-9492-d25f705dcf7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def docheck(primary_river, point, persist, linear, cubic, fitted, badfit, ax, doplots=True):\n",
    "    maximum = primary_river['Primary River Flow'].max()\n",
    "    minimum = primary_river['Primary River Flow'].min()\n",
    "    value = primary_river.iloc[point].values\n",
    "    goodness_persist = np.abs(persist - value)\n",
    "    goodness_linear = np.abs(linear - value)\n",
    "    goodness_cubic = np.abs(cubic - value)\n",
    "    if not badfit:\n",
    "        goodness_fit = np.abs(fitted - value)\n",
    "        pmfitted = pmhalf(fitted, value)\n",
    "        ibfitted = inbounds(fitted, maximum, minimum)\n",
    "    else:\n",
    "        goodness_fit = np.zeros((4))\n",
    "        pmfitted = np.zeros((4))\n",
    "        ibfitted = np.zeros((4))\n",
    "    if doplots:\n",
    "        ax.plot(goodness_persist, 'o')\n",
    "        ax.plot(goodness_linear, 'o')\n",
    "        ax.plot(goodness_cubic, 'o')\n",
    "        if not badfit:\n",
    "            ax.plot(goodness_fit, 'o')\n",
    "        ax.grid()\n",
    "    return (np.concatenate((goodness_persist, goodness_linear, goodness_cubic, goodness_fit)), \n",
    "            np.concatenate((pmhalf(persist, value), pmhalf(linear, value), pmhalf(cubic, value), pmfitted)),\n",
    "            np.concatenate((inbounds(persist, maximum, minimum), inbounds(linear, maximum, minimum), \n",
    "                            inbounds(cubic, maximum, minimum), ibfitted)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "61d5826a-2f81-432d-bc17-43c6704371ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "def doone(primary_river, gap_length, accumulateG, accumulateC, accumulateB, fittedbad, fittype, doplots=True):\n",
    "\n",
    "    point = random.randrange(len(primary_river.index))\n",
    "    spoint = point - gap_length + 1\n",
    "    \n",
    "    if doplots:\n",
    "        fig, axs = plt.subplots(1, 3, figsize=(15, 4))\n",
    "\n",
    "        primary_river.iloc[point-10:point+1].plot(ax=axs[0], marker='s')\n",
    "    else:\n",
    "        axs = [0, 1, 2]\n",
    "\n",
    "    (persist, linear, cubic, fitted, badfit, fittedbad) = estimate(\n",
    "        primary_river, spoint, point, gap_length, axs[1], fittedbad, fittype, doplots)\n",
    "\n",
    "    GG, CC, BB = docheck(primary_river, point, persist, linear, cubic, fitted, badfit, axs[2], doplots)\n",
    "    accumulateG += GG\n",
    "    accumulateC += CC\n",
    "    accumulateB += BB\n",
    "    \n",
    "    \n",
    "    return accumulateG, accumulateC, accumulateB, fittedbad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "580d9f95-58cc-40bd-9873-2dde8e9475e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print (gap_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d127b144-4516-458a-aa53-bb7df808db0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000.  957.  957.  957.  957.] [ 77.38075562  79.28309966  80.32877961  81.31457474  81.77803916\n",
      "  82.1041747   82.66501478 158.03755418 142.56863081 134.66654472\n",
      " 131.47178594 128.67173906 124.73522751 450.85001084 371.13535188\n",
      " 305.65583099 265.56261688 251.8151398   53.83722556  57.25385277\n",
      "  61.59124673  65.63988265] [0.064      0.061      0.064      0.073      0.077      0.077\n",
      " 0.074      0.245      0.236      0.219      0.213      0.205\n",
      " 0.197      0.449      0.439      0.428      0.393      0.39\n",
      " 0.03343783 0.03552769 0.03970742 0.04702194] [0.         0.         0.         0.         0.         0.\n",
      " 0.         0.058      0.056      0.052      0.045      0.042\n",
      " 0.042      0.188      0.192      0.169      0.168      0.173\n",
      " 0.00208986 0.0031348  0.0031348  0.0031348 ]\n"
     ]
    }
   ],
   "source": [
    "river = 'Homathko_Mouth'\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2409941c-5fed-46c2-88e8-d7e141edb560",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9b803ef3-d01f-4f4e-99f6-a511203a8aaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000.  652.  652.  652.  652.] [ 40.76377032  41.96644856  41.93081656  42.19037453  42.68346658\n",
      "  42.67169678  42.33088112 107.6575276   87.63995111  79.1184143\n",
      "  76.81584872  74.30651039  70.15357114 393.80080638 267.08465883\n",
      " 210.7244214  173.8863029  155.70836324  33.96695212  38.3534114\n",
      "  37.67879376  37.87325859] [0.214      0.219      0.24       0.245      0.256      0.273\n",
      " 0.273      0.471      0.464      0.468      0.46       0.48\n",
      " 0.479      0.644      0.605      0.597      0.603      0.584\n",
      " 0.10582822 0.12576687 0.1303681  0.13190184] [0.         0.         0.         0.         0.         0.\n",
      " 0.         0.171      0.145      0.135      0.13       0.137\n",
      " 0.131      0.285      0.266      0.255      0.232      0.237\n",
      " 0.00153374 0.00153374 0.00153374 0.00153374]\n"
     ]
    }
   ],
   "source": [
    "river = 'Salmon_Sayward'\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ed04f403-16b8-471f-aa75-26e631ff86d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2841bde2-9e6d-465e-837d-68b408eb9b55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print (gap_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "39706881-69f3-4f65-89dc-e0a5b11d1eb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000.  873.  873.  873.  873.] [ 77.60557842  79.56810948  80.98701251  81.6978461   81.84767831\n",
      "  82.45479111  82.84044562 170.0340355  154.55269756 146.61737095\n",
      " 141.74783087 135.97773674 130.53747672 515.4938924  428.765193\n",
      " 358.27899509 311.6757879  282.31864103  46.32426701  49.37533186\n",
      "  52.82698818  57.30357152] [0.119      0.124      0.12       0.122      0.121      0.136\n",
      " 0.141      0.427      0.363      0.363      0.365      0.35\n",
      " 0.338      0.665      0.619      0.611      0.587      0.57\n",
      " 0.03436426 0.03436426 0.03436426 0.03550974] [0.    0.    0.    0.    0.    0.    0.    0.147 0.112 0.088 0.085 0.081\n",
      " 0.081 0.3   0.276 0.275 0.26  0.229 0.    0.    0.    0.   ]\n"
     ]
    }
   ],
   "source": [
    "river = 'Squamish_Brackendale'\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "dfb5be4f-3438-49ec-8a06-c58f13d58997",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAANOCAYAAABQmu4KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABGWklEQVR4nO39fbBd5X0n+H5/PieI2Ai3YskY82LRHl3SJGWTXF2isUMHrq8T7HQBqZnMkO7pVs84RXvKbidFj2/jHqrTqY5vJ+VpOm3HDkOnSTR1O81QldhWtWkTFyPHpBwliFzH5sUKKqwYWbIQL41EDIIjPfcP7UMO4gjt86Kz1jr786lSnb2fvdbZX8nLm/2t9axnVWstAAAA9N/rug4AAADAeBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCCmuw4wn/Xr17eNGzd2HePVXvyrpB3rOgWwBM8fn8mx6bO6jgGDMzXzupxd/r/DcBzLC8m01dY5vaqpTE29vusYr/LAAw882VrbcPJ4Lwvcxo0bs2vXrq5jvNqjX0resL7rFMAS/NG++7Lu7e/pOgYMzvPffDrveNvlXceAsT351B/mnEve1nUMBuCll57Om970E13HeJWq+sv5xk2hBAAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgenkbAQBgddm++2Bu3bk3B44czflr1+SmLRtz7aXndR0LYHAUOADgjNq++2Bu2fFoXpg5niTZf+RobtnxaJIocQALZAolAHBG3bpz78vlbdYLM8dz68693QQCGDAFDgA4ow4cObqgcQBOTYEDAM6o89euWdA4AKemwAEAZ9RNWzbm7OlXfuU4e/p1uWnLxm4CAQyYRUwAgDNqdqESq1ACLN2CC1xV7U1yJMmxJDOttc1V9QNJ/s8kG5PsTfLftdaeGW3/sSQfGG3/kdbaPcuSHAAYjGsvPU9hA1gGi51CeXVr7fLW2ubR85uT3Nta25Tk3tHzVNVlSW5I8kNJrknymaqaWmJmAACAibRc18Bdl2Tb6PG2JNfPGb+ztXa0tfatJHuSXLFM7wkAADBRFlPgWpI/qKoHqurG0dh5rbUDSTL6+ebR+AVJHp+z777RGAAAAAu0mEVM3t1a219Vb07ypar65mtsW/OMtXk3PFEGb0ySiy++eBGxAAAAVrcFn4Frre0f/XwiyWdzYkrkwao6P0lGP58Ybb4vyUVzdr8wyf5T/N7bW2ubW2ubN2zYsNBYAAAAq96CClxVvaGq1s4+TvKTSR5Msj3J1tFmW5N8fvR4e5IbqmpNVV2SZFOSP12O4AAAAJNmoVMoz0vy2aqa3fd3W2tfrKr7k9xVVR9I8u0kP5skrbWHququJA8nmUnyodbasWVLDwAAMEEWVOBaa48leec8408lec8p9vl4ko8vKh0AAAAvW67bCAAAAHCGKXAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBATHcdAABgpWzffTC37tybA0eO5vy1a3LTlo259tLzuo4FMDYFDgCYCNt3H8wtOx7NCzPHkyT7jxzNLTseTRIlDhgMUygBgIlw6869L5e3WS/MHM+tO/d2EwhgERQ4AGAiHDhydEHjAH2kwAEAE+H8tWsWNA7QRwocADARbtqyMWdPv/Krz9nTr8tNWzZ2EwhgESxiAgBMhNmFSqxCCQyZAgcATIxrLz1PYQMGzRRKAACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFYVIGrqqmq+v9V1X8aPf+BqvpSVT06+rluzrYfq6o9VbW7qn5quYIDAABMmsWegfuFJI/MeX5zkntba5uS3Dt6nqq6LMkNSX4oyTVJPlNVU4uPCwAAMLkWXOCq6sIkP53kt+YMX5dk2+jxtiTXzxm/s7V2tLX2rSR7klyx6LQAAAATbDFn4H49yf87yfE5Y+e11g4kyejnm0fjFyR5fM52+0Zjr1JVN1bVrqradejQoUXEAgAAWN0WVOCq6u8keaK19sC4u8wz1ubbsLV2e2ttc2tt84YNGxYSCwAAYCJML3D7dye5tqren+TsJOdW1f83ycGqOr+1dqCqzk/yxGj7fUkumrP/hUn2LzU0AADAJFrQGbjW2sdaaxe21jbmxOIk/1dr7X9Isj3J1tFmW5N8fvR4e5IbqmpNVV2SZFOSP12W5AAAABNmoWfgTuVXk9xVVR9I8u0kP5skrbWHququJA8nmUnyodbasWV6TwAAgImy6ALXWvtyki+PHj+V5D2n2O7jST6+2PcBAADghMXeBw4AAIAVpsABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAzEdNcBAAAm0fbdB3Przr05cORozl+7Jjdt2ZhrLz2v61hAzylwAAArbPvug7llx6N5YeZ4kmT/kaO5ZcejSaLEAa/JFEoAgBV26869L5e3WS/MHM+tO/d2EwgYDAUOAGCFHThydEHjALMUOACAFXb+2jULGgeYpcABAKywm7ZszNnTr/wadvb063LTlo3dBAIGwyImAAArbHahEqtQAgulwAEAdODaS89T2IAFM4USAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgZjuOgAAAN3Zvvtgbt25NweOHM35a9fkpi0bc+2l53UdCzgFBQ4AYEJt330wt+x4NC/MHE+S7D9yNLfseDRJlDjoKVMoAQAm1K07975c3ma9MHM8t+7c200g4LQUOACACXXgyNEFjQPdU+AAACbU+WvXLGgc6N6CClxVnV1Vf1pVf15VD1XVL4/Gf6CqvlRVj45+rpuzz8eqak9V7a6qn1ruvwAAAItz05aNOXv6lV8Hz55+XW7asrGbQMBpLfQM3NEk/8/W2juTXJ7kmqrakuTmJPe21jYluXf0PFV1WZIbkvxQkmuSfKaqppYpOwAAS3DtpeflV67elLeuXZNK8ta1a/IrV2+ygAn02IJWoWyttSTPjZ5+3+hPS3JdkqtG49uSfDnJPx2N39laO5rkW1W1J8kVSf54qcEBAFi6ay89T2GDAVnwNXBVNVVVX0vyRJIvtdb+JMl5rbUDSTL6+ebR5hckeXzO7vtGY/P93huraldV7Tp06NBCYwEAAKx6Cy5wrbVjrbXLk1yY5Iqq+uHX2Lzm+xWn+L23t9Y2t9Y2b9iwYaGxAAAAVr1Fr0LZWvsvOTFV8pokB6vq/CQZ/XxitNm+JBfN2e3CJPsX+54AAACTbKGrUG6oqr8xevz9Sf5fSb6ZZHuSraPNtib5/Ojx9iQ3VNWaqrokyaYkf7oMuQEAACbOghYxSXJ+km2jlSRfl+Su1tp/qqo/TnJXVX0gybeT/GyStNYeqqq7kjycZCbJh1prx5YvPgAAwORY6CqUX0/yI/OMP5XkPafY5+NJPr6odAAAALxsoWfgAADgjNi++2Bu3bk3B44czflr1+SmLRvd4gBOosABANC57bsP5pYdj+aFmeNJkv1HjuaWHY8miRIHcyx6FUoAAFgut+7c+3J5m/XCzPHcunNvN4GgpxQ4AAA6d+DI0QWNw6RS4AAA6Nz5a9csaBwmlQIHAEDnbtqyMWdPv/Kr6dnTr8tNWzZ2Ewh6yiImAAB0bnahEqtQwmtT4AAA6IVrLz1PYYPTMIUSAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFYUIGrqouqakdVPVJVD1XVL4zGf6CqvlRVj45+rpuzz8eqak9V7a6qn1ruvwAAAMCkWOgZuJkk/6S19reSbEnyoaq6LMnNSe5trW1Kcu/oeUav3ZDkh5Jck+QzVTW1XOEBAAAmyYIKXGvtQGvtz0aPjyR5JMkFSa5Lsm202bYk148eX5fkztba0dbat5LsSXLFMuQGAACYOIu+Bq6qNib5kSR/kuS81tqB5ETJS/Lm0WYXJHl8zm77RmPz/b4bq2pXVe06dOjQYmMBAACsWosqcFV1TpLfS/KLrbXDr7XpPGNtvg1ba7e31ja31jZv2LBhMbEAAABWtQUXuKr6vpwob/+htfb7o+GDVXX+6PXzkzwxGt+X5KI5u1+YZP/i4wIAAEyuha5CWUn+fZJHWmu3znlpe5Kto8dbk3x+zvgNVbWmqi5JsinJny4tMgAAwGSaXuD2707y95N8o6q+Nhr7Z0l+NcldVfWBJN9O8rNJ0lp7qKruSvJwTqxg+aHW2rHlCA4AADBpFlTgWmt/lPmva0uS95xin48n+fgCcwEAAHCSRa9CCQAAwMpS4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBWOhtBAAm1o6Hn8u2+57Jk4ePZf25U9l65bpcfdk5XccCACaIAgcwhh0PP5dP3fNUjs60JMmhw8fyqXueShIlDgBYMaZQAoxh233PvFzeZh2dadl23zMdJQIAJpECBzCGJw8fW9A4AMCZoMABjGH9uVMLGgcAOBMUOIAxbL1yXdZM1yvG1kxXtl65rqNEAMAksogJwBhmFyqxCiUA0CUFDmBMV192Tm8Km1saAMBkUuAABsYtDQBgcrkGDmBg3NIAACaXAgcwMG5pAACTyxRKgIFZf+5UDs1T1rq4pYFr8QBgZTkDBzAwfbmlwey1eIcOH0vLX1+Lt+Ph51Y0BwBMEmfgAAamL7c0eK1r8bo4C+dsIACTQIEDGKA+3NKgT9fiWZkTgElhCiUAi3Kqa+66uBbPypwATApn4ABYlK1XrnvFWa+km2vxkv6dDTSVE4AzRYEDYFH6ci1e0p+VOU3lBOBMU+AAWLQ+XIuX9OdsoIVdADjTFDgABq8vZwP7NpXT2UCA1UeBA2BV6MPZwL5M5Uz6dzYQgOVhFUoAWCZ9ucl60q+zgQAsH2fgAGCZ9GUqZ9Kvs4EALB8FDgCWUR+mcib9WdgFgOWlwAHAKtSns4EALB8FDgBWqb6cDQRg+VjEBAAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBWHCBq6o7quqJqnpwztgPVNWXqurR0c91c177WFXtqardVfVTyxUcAABg0izmDNzvJLnmpLGbk9zbWtuU5N7R81TVZUluSPJDo30+U1VTi04LAAAwwRZc4FprX0ny9EnD1yXZNnq8Lcn1c8bvbK0dba19K8meJFcsLioAAMBkW65r4M5rrR1IktHPN4/GL0jy+Jzt9o3GXqWqbqyqXVW169ChQ8sUCwAAYPU404uY1Dxjbb4NW2u3t9Y2t9Y2b9iw4QzHAgAAGJ7lKnAHq+r8JBn9fGI0vi/JRXO2uzDJ/mV6TwAAgImyXAVue5Kto8dbk3x+zvgNVbWmqi5JsinJny7TewIAAEyU6YXuUFX/MclVSdZX1b4kv5TkV5PcVVUfSPLtJD+bJK21h6rqriQPJ5lJ8qHW2rFlyg4AADBRFlzgWms/d4qX3nOK7T+e5OMLfR+AJPnc7u/lE189kv1HjuWta6fy0XetzfWXvr7rWAAAnVhwgYPl0qcv5n3J0pccfcnyud3fy8fufTbPz5xY++g7R47lY/c+myRKHAAwkRS4CeSLeT+z9CVHn7J84qtHXs4w6/mZlk989YgCBwBMpDN9GwFGPrf7e3n3bx/MJZ/cn3f/9sF8bvf3OsvxsXufzXeOHEvLX38xX+k8r/XFfKX1JUtfcvQpy/4j818ye6pxAIDVToFbAX0pTYkv5gt5z5XO0pccr/WeK53lrWunFjQOALDaKXAroC+lKfHFfCHvudJZ+pLjtd5zpbN89F1r8/3T9Yqx75+ufPRda1c0BwBAXyhwK6AvpSnxxbzPWfqSo09Zrr/09flX73ljLlg7lUpywdqp/Kv3vNH1bwDAxLKIyQp469qpfGeestbFmZWPvmvtKxanSLr7Yp6k88VU+pSlLzn6mEVhAwA4QYFbAX0pTYkv5qfSlyx9yZH0KwsAACcocCugT6VpNo8v5gAAMDwK3ApRmgAAgKWyiAkAAMBAOAMHAAAMxhcefC6f/PKz+e7hY3nLuVP5yFVvzE//8Dldx1oxChwAADAIX3jwufzy3c/khdHigAcOH8sv3/1MkkxMiVPgAACA0+rDma9PfvnZl8vbrBdmWj755WcVOAAAgKQ/Z76+e/jV91Z+rfHVyCImAADQU1948Ln81G98J+/8/3w7P/Ub38kXHnyukxyvdeZrJb3l3KkFja9GChwAAMzRl9I0e9brwOFjafnrs15d5OnLma+PXPXGnD1drxg7e7rykaveuKI5uqTAAQDASJ9KU1/OeiX9OfP10z98Tn7p/ety/rlTqSTnnzuVX3r/uom5/i1xDRwAALysT4tk9OWsV3LizNfca+CS7s58/fQPnzNRhe1kChwAAIz0qTS95dypHJjnfbu43mu2MHW9CiUKHAAAvKxPpalPZ70SZ776wjVwAAAw0qdFMlzvxXycgQMAgJG+TRV01ouTKXAAADCH0kSfmUIJAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEBUa+30W62wqjqU5C+7znGGrE/yZNchYAEcswyNY5ahccwyNI7ZlfG21tqGkwd7WeBWs6ra1Vrb3HUOGJdjlqFxzDI0jlmGxjHbLVMoAQAABkKBAwAAGAgFbuXd3nUAWCDHLEPjmGVoHLMMjWO2Q66BAwAAGAhn4AAAAAZCgQMAABgIBW6FVNU1VbW7qvZU1c1d54HTqaq9VfWNqvpaVe3qOg/Mp6ruqKonqurBOWM/UFVfqqpHRz/XdZkRZp3ieP0XVfWd0Wft16rq/V1mhLmq6qKq2lFVj1TVQ1X1C6Nxn7MdUuBWQFVNJfl0kvcluSzJz1XVZd2mgrFc3Vq73L1e6LHfSXLNSWM3J7m3tbYpyb2j59AHv5NXH69J8m9Gn7WXt9buXuFM8FpmkvyT1trfSrIlyYdG32F9znZIgVsZVyTZ01p7rLX2YpI7k1zXcSaAwWutfSXJ0ycNX5dk2+jxtiTXr2QmOJVTHK/QW621A621Pxs9PpLkkSQXxOdspxS4lXFBksfnPN83GoM+a0n+oKoeqKobuw4DC3Bea+1AcuLLR5I3d5wHTufDVfX10RRLU9HoparamORHkvxJfM52SoFbGTXPmPs30Hfvbq39aE5M/f1QVf3trgMBrEK/meTtSS5PciDJv+40Dcyjqs5J8ntJfrG1drjrPJNOgVsZ+5JcNOf5hUn2d5QFxtJa2z/6+USSz+bEVGAYgoNVdX6SjH4+0XEeOKXW2sHW2rHW2vEk/y4+a+mZqvq+nChv/6G19vujYZ+zHVLgVsb9STZV1SVVdVaSG5Js7zgTnFJVvaGq1s4+TvKTSR587b2gN7Yn2Tp6vDXJ5zvMAq9p9kvwyM/EZy09UlWV5N8neaS1duucl3zOdqhaM5NvJYyWBf71JFNJ7mitfbzbRHBqVfU3c+KsW5JMJ/ldxyx9VFX/MclVSdYnOZjkl5J8LsldSS5O8u0kP9tas3AEnTvF8XpVTkyfbEn2JvlHs9cWQdeq6seT3JfkG0mOj4b/WU5cB+dztiMKHAAAwECYQgkAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAAzHddYD5rF+/vm3cuLHrGK/24l8l7VjXKYAleP74TI5Nn9V1DBicqZnX5ezy/x2G41heSKZb1zEYgKqpTE29vusYr/LAAw882VrbcPJ4Lwvcxo0bs2vXrq5jvNqjX0resL7rFMAS/NG++7Lu7e/pOgYMzvPffDrveNvlXceAsT351B/mnEve1nUMBuCll57Om970E13HeJWq+sv5xk2hBAAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgenkbAQBgddm++2Bu3bk3B44czflr1+SmLRtz7aXndR0LYHAUOADgjNq++2Bu2fFoXpg5niTZf+RobtnxaJIocQALZAolAHBG3bpz78vlbdYLM8dz68693QQCGDAFDgA4ow4cObqgcQBOTYEDAM6o89euWdA4AKemwAEAZ9RNWzbm7OlXfuU4e/p1uWnLxm4CAQyYRUwAgDNqdqESq1ACLJ0CBwCccddeep7CBrAMTKEEAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAbCjbwBgImxfffB3Lpzbw4cOZrz167JTVs2usE4MCgKHAAwEbbvPphbdjyaF2aOJ0n2HzmaW3Y8miRKHDAYplACABPh1p17Xy5vs16YOZ5bd+7tJhDAIjgDBwBMhANHji5o/EwznRNYDGfgAICJcP7aNQsaP5Nmp3PuP3I0LX89nXP77oMrngUYFgUOAJgIN23ZmLOnX/nV5+zp1+WmLRtXPIvpnMBiLanAVdU1VbW7qvZU1c2n2OaqqvpaVT1UVX+4lPcDAFisay89L79y9aa8de2aVJK3rl2TX7l6UyfTFvs2nRMYjkVfA1dVU0k+neS9SfYlub+qtrfWHp6zzd9I8pkk17TWvl1Vb15iXgCARbv20vN6cZ3Z+WvXZP88Za2L6ZzAsCzlDNwVSfa01h5rrb2Y5M4k1520zd9N8vuttW8nSWvtiSW8HwDAqtCn6ZzAsCylwF2Q5PE5z/eNxub6vyVZV1VfrqoHquofLOH9AABWhT5N5wSGZSm3Eah5xto8v///nuQ9Sb4/yR9X1c7W2l+86pdV3ZjkxiS5+OKLlxALAKD/+jKdExiWpRS4fUkumvP8wiT759nmydbaXyX5q6r6SpJ3JnlVgWut3Z7k9iTZvHnzyUUQAIAzwP3oYFiWMoXy/iSbquqSqjoryQ1Jtp+0zeeTXFlV01X1+iQ/luSRJbwnAADLxP3oYHgWXeBaazNJPpzknpwoZXe11h6qqg9W1QdH2zyS5ItJvp7kT5P8VmvtwaXHBgBgqdyPDoZnKVMo01q7O8ndJ43ddtLzTyT5xFLeBwCA5ed+dDA8S7qRNwAAw3Wq+865Hx30lwIHADCh3I8OhmdJUygBABiu2dUm+7IKpRUx4fQUOACACdaX+9HNrog5u6jK7IqYSXqRD/rCFEoAADpnRUwYjwIHAEDnrIgJ41HgAADonBUxYTwKHAAAnbMiJozHIiYAAHSubytiQl8pcAAA9EJfVsSEPjOFEgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABiIJRW4qrqmqnZX1Z6qunme16+qqmer6mujP/98Ke8HAAAwyaYXu2NVTSX5dJL3JtmX5P6q2t5ae/ikTe9rrf2dJWQEAAAgSzsDd0WSPa21x1prLya5M8l1yxMLAACAky2lwF2Q5PE5z/eNxk72X1fVn1fVf66qHzrVL6uqG6tqV1XtOnTo0BJiAQAArE5LKXA1z1g76fmfJXlba+2dST6V5HOn+mWttdtba5tba5s3bNiwhFgAAACr01IK3L4kF815fmGS/XM3aK0dbq09N3p8d5Lvq6r1S3hPAACAibWUAnd/kk1VdUlVnZXkhiTb525QVW+pqho9vmL0fk8t4T0BAAAm1qJXoWytzVTVh5Pck2QqyR2ttYeq6oOj129L8t8m+Z+raibJ80luaK2dPM0SAACAMSy6wCUvT4u8+6Sx2+Y8/o0kv7GU9wAAAOCEJd3IGwAAgJWjwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBATHcdAGAodjz8XLbd90yePHws68+dytYr1+Xqy87pOhYAMEEUOIAx7Hj4uXzqnqdydKYlSQ4dPpZP3fNUkihxAMCKMYUSYAzb7nvm5fI26+hMy7b7nukoEQAwiRQ4gDE8efjYgsYBAM4EBQ5gDOvPnVrQOADAmaDAAYxh65Xrsma6XjG2Zrqy9cp1HSUCACaRRUwAxjC7UIlVKAGALilwAGO6+rJzFDYAoFOmUAIAAAyEAgcAADAQSypwVXVNVe2uqj1VdfNrbPf/qKpjVfXfLuX9AAAAJtmiC1xVTSX5dJL3Jbksyc9V1WWn2O7Xktyz2PcCAABgaWfgrkiyp7X2WGvtxSR3Jrlunu3+cZLfS/LEEt4LAABg4i2lwF2Q5PE5z/eNxl5WVRck+Zkkt53ul1XVjVW1q6p2HTp0aAmxAAAAVqelFLiaZ6yd9PzXk/zT1tqx0/2y1trtrbXNrbXNGzZsWEIsAACA1Wkp94Hbl+SiOc8vTLL/pG02J7mzqpJkfZL3V9VMa+1zS3hfAACAibSUAnd/kk1VdUmS7yS5IcnfnbtBa+2S2cdV9TtJ/pPyBgAAsDiLLnCttZmq+nBOrC45leSO1tpDVfXB0eunve4NAACA8S3lDFxaa3cnufuksXmLW2vtHy7lvQAAACbdkm7kDQAAwMpR4AAAAAZCgQMAABiIJV0DB0A3djz8XLbd90yePHws68+dytYr1+Xqy86Z2Bx9ywIAZ4oCBzAwOx5+Lp+656kcnWlJkkOHj+VT9zyVJCtaWPqSo29ZAOBMMoUSYGC23ffMy0Vl1tGZlm33PTOROfqWBQDOJAUOYGCePHxsQeOrPcdrvWcXWQDgTFLgAAZm/blTCxpf7Tle6z27yAIAZ5ICBzAwW69clzXT9YqxNdOVrVeum8gcfcuy4+Hn8g//98fzdz6xN//wf388Ox5+bsUzALB6WcQEYGBmF+XoesXFvuToUxaLqQBwpilwAAN09WXn9KIQ9CVH0o8sr7WYStfZAFgdTKEEgGViMRUAzjRn4ABgmaw/dyqH5ilrXS2m4ubmAKuPM3AAsEz6tpjKp+55KocOH0vLX1+PZ1EVgGFT4ABgmVx92Tn5xz/1pmw4dyqVZMO5U/nHP/WmTs56ubk5wOpkCiUALKM+LKaSuB4PYLVyBg4AViE3NwdYnRQ4AFiF+nQ9HgDLxxRKAFiF+nJzcwCWlwIHAKtUX67HA2D5mEIJAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBBLKnBVdU1V7a6qPVV18zyvX1dVX6+qr1XVrqr68aW8HwAAwCRb9G0EqmoqyaeTvDfJviT3V9X21trDcza7N8n21lqrqnckuSvJDy4lMAAAwKRayhm4K5Lsaa091lp7McmdSa6bu0Fr7bnWWhs9fUOSFgAAABZlKQXugiSPz3m+bzT2ClX1M1X1zSRfSPI/neqXVdWNo2mWuw4dOrSEWAAAAKvTUgpczTP2qjNsrbXPttZ+MMn1Sf7lqX5Za+321trm1trmDRs2LCEWAADA6rSUArcvyUVznl+YZP+pNm6tfSXJ26tq/RLeEwAAYGItpcDdn2RTVV1SVWcluSHJ9rkbVNV/VVU1evyjSc5K8tQS3hMAAGBiLXoVytbaTFV9OMk9SaaS3NFae6iqPjh6/bYk/02Sf1BVLyV5Psl/P2dREwAAABZg0QUuSVprdye5+6Sx2+Y8/rUkv7aU9wAAAOCEJd3IGwAAgJWjwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAzEkgpcVV1TVburak9V3TzP63+vqr4++vPVqnrnUt4PAABgki26wFXVVJJPJ3lfksuS/FxVXXbSZt9K8hOttXck+ZdJbl/s+wEAAEy6pZyBuyLJntbaY621F5PcmeS6uRu01r7aWntm9HRnkguX8H4AAAATbSkF7oIkj895vm80diofSPKfT/ViVd1YVbuqatehQ4eWEAsAAGB1WkqBq3nG2rwbVl2dEwXun57ql7XWbm+tbW6tbd6wYcMSYgEAAKxO00vYd1+Si+Y8vzDJ/pM3qqp3JPmtJO9rrT21hPcDAACYaEs5A3d/kk1VdUlVnZXkhiTb525QVRcn+f0kf7+19hdLeC8AAICJt+gzcK21mar6cJJ7kkwluaO19lBVfXD0+m1J/nmSNyX5TFUlyUxrbfPSYwMAAEyepUyhTGvt7iR3nzR225zHP5/k55fyHgAAAJywpBt5AwAAsHIUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABmK66wAAr+Vzu7+XT3z1SPYfOZa3rp3KR9+1Ntdf+vquYwEAdEKBA3rrc7u/l4/d+2yen2lJku8cOZaP3ftskihxAMBEMoUSmNfndn8v7/7tg7nkk/vz7t8+mM/t/t6KZ/jEV4+8XN5mPT/T8omvHlnxLAAAfeAMHPAqfTnztf/IsQWNAwCsds7AAa/SlzNfb107taBxAIDVToEDXqUvZ74++q61+f7pesXY909XPvqutSuaAwCgL0yhnEBW9eN03rp2Kt+Zp6yt9Jmv2ePS8QoAcIICN2H6cm1T3/Sl1PYlx0fftfYVx0nS3Zmv6y99/UQfmwAAcylwK6QvX8xf69qmlc7Tl3+TvpTavuSY+359+N8HAIC/psCtgD59Me/LtU19+jfpS6ntS45ZznwBAPSPRUxWQF9W9Ev6s6pfn/5N+lJq+5IDAID+UuBWQJ++mPdlVb8+/Zv0pdT2JQcAAP2lwK2APn0xv/7S1+dfveeNuWDtVCrJBWun8q/e88YVnyrXp3+TvpTavuQAAKC/XAO3Avq0ol/Sj2ub+vRv0pcFO/qSAwCA/lpSgauqa5L82yRTSX6rtfarJ73+g0l+O8mPJvlfW2v/21Leb6h8MX+1vv2b9KHU9ikHAAD9tOgCV1VTST6d5L1J9iW5v6q2t9YenrPZ00k+kuT6pYRcDXwxfzX/JgAAsDBLuQbuiiR7WmuPtdZeTHJnkuvmbtBae6K1dn+Sl5bwPgAAAGRpBe6CJI/Peb5vNLYoVXVjVe2qql2HDh1aQiwAAIDVaSkFruYZa/OMjaW1dntrbXNrbfOGDRuWEAsAAGB1WkqB25fkojnPL0yyf2lxAAAAOJWlFLj7k2yqqkuq6qwkNyTZvjyxAAAAONmiV6Fsrc1U1YeT3JMTtxG4o7X2UFV9cPT6bVX1liS7kpyb5HhV/WKSy1prh5ceHQAAYLIs6T5wrbW7k9x90thtcx5/NyemVgIAALBES5lCCQAAwApS4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGIjprgMMxRe/+MV891uPJFPf13UUYAmePXok03/+5a5jwOAc/95MvvHgX3QdA8b20kv/JVO7/rLrGAzAm960Jtdf/xNdxxibM3AAAAAD4QzcmK655prk0ankDeu7jgIswR/tuy/r3n5V1zFgcJ7/5tN5x9su7zoGjO3Jp/4w51zytq5jMAAvvfR01xEWRIEDAIA5vvDgc/nkl5/Ndw8fy1vOncpHrnpjfvqHz5GlJ1n6kqMrChwAAIx84cHn8st3P5MXZlqS5MDhY/nlu59JkhUvCbL0N0eXXAMHAAAjn/zysy+Xg1kvzLR88svPytKDLH3J0SUFDgAARr57+NiCxs8kWfqbo0sKHAAAjLzl3KkFjZ9JsvQ3R5cUOAAAGPnIVW/M2dP1irGzpysfueqNsvQgS19ydMkiJgAAMDK7EEYfVjmUpb85uqTAAQDAHD/9w+f0phDI0t8cXTGFEgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBqNZa1xlepaoOJfnLrnOcIeuTPNl1CFgAxyxD45hlaByzDI1jdmW8rbW24eTBXha41ayqdrXWNnedA8blmGVoHLMMjWOWoXHMdssUSgAAgIFQ4AAAAAZCgVt5t3cdABbIMcvQOGYZGscsQ+OY7ZBr4AAAAAbCGTgAAICBUOAAAAAGQoFbIVV1TVXtrqo9VXVz13ngdKpqb1V9o6q+VlW7us4D86mqO6rqiap6cM7YD1TVl6rq0dHPdV1mhFmnOF7/RVV9Z/RZ+7Wqen+XGWGuqrqoqnZU1SNV9VBV/cJo3OdshxS4FVBVU0k+neR9SS5L8nNVdVm3qWAsV7fWLnevF3rsd5Jcc9LYzUnuba1tSnLv6Dn0we/k1cdrkvyb0Wft5a21u1c4E7yWmST/pLX2t5JsSfKh0XdYn7MdUuBWxhVJ9rTWHmutvZjkziTXdZwJYPBaa19J8vRJw9cl2TZ6vC3J9SuZCU7lFMcr9FZr7UBr7c9Gj48keSTJBfE52ykFbmVckOTxOc/3jcagz1qSP6iqB6rqxq7DwAKc11o7kJz48pHkzR3ngdP5cFV9fTTF0lQ0eqmqNib5kSR/Ep+znVLgVkbNM+b+DfTdu1trP5oTU38/VFV/u+tAAKvQbyZ5e5LLkxxI8q87TQPzqKpzkvxekl9srR3uOs+kU+BWxr4kF815fmGS/R1lgbG01vaPfj6R5LM5MRUYhuBgVZ2fJKOfT3ScB06ptXawtXastXY8yb+Lz1p6pqq+LyfK239orf3+aNjnbIcUuJVxf5JNVXVJVZ2V5IYk2zvOBKdUVW+oqrWzj5P8ZJIHX3sv6I3tSbaOHm9N8vkOs8Brmv0SPPIz8VlLj1RVJfn3SR5prd065yWfsx2q1szkWwmjZYF/PclUkjtaax/vNhGcWlX9zZw465Yk00l+1zFLH1XVf0xyVZL1SQ4m+aUkn0tyV5KLk3w7yc+21iwcQedOcbxelRPTJ1uSvUn+0ey1RdC1qvrxJPcl+UaS46Phf5YT18H5nO2IAgcAADAQplACAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEBMdx1gPuvXr28bN27sOsarvfhXSTvWdQpgCZ4/PpNj02d1HQMGZ2rmdTm7/H+H4TiWF5Lp1nUMBqBqKlNTr+86xqs88MADT7bWNpw83ssCt3HjxuzatavrGK/26JeSN6zvOgWwBH+0776se/t7uo4Bg/P8N5/OO952edcxYGxPPvWHOeeSt3UdgwF46aWn86Y3/UTXMV6lqv5yvnFTKAEAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYiLEKXFVdU1W7q2pPVd08z+vXVdXXq+prVbWrqn583H0BgNVv++6DuWrbn+TS3/hKrtr2J9m++2DXkQAG6bT3gauqqSSfTvLeJPuS3F9V21trD8/Z7N4k21trrarekeSuJD845r4AwCq2fffB3LLj0bwwczxJsv/I0dyy49EkybWXntdlNIDBGecM3BVJ9rTWHmutvZjkziTXzd2gtfZca232VvdvSNLG3RcAWN1u3bn35fI264WZ47l1595uAgEM2DgF7oIkj895vm809gpV9TNV9c0kX0jyPy1k39H+N46mX+46dOjQONkBgAE4cOTogsYBOLVxClzNM9ZeNdDaZ1trP5jk+iT/ciH7jva/vbW2ubW2ecOGDWPEAgCG4Py1axY0DsCpjVPg9iW5aM7zC5PsP9XGrbWvJHl7Va1f6L4AwOpz05aNOXv6lV85zp5+XW7asrGbQAADNk6Buz/Jpqq6pKrOSnJDku1zN6iq/6qqavT4R5OcleSpcfYFAFa3ay89L79y9aa8de2aVJK3rl2TX7l6kwVMABbhtKtQttZmqurDSe5JMpXkjtbaQ1X1wdHrtyX5b5L8g6p6KcnzSf770aIm8+57hv4uAEBPXXvpeQobwDI4bYFLktba3UnuPmnstjmPfy3Jr427LwAAAAs31o28AQAA6J4CBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADMdaNvAEAVoPtuw/m1p17c+DI0Zy/dk1u2rIx1156XtexAMamwAEAE2H77oO5ZcejeWHmeJJk/5GjuWXHo0nSSYlTJoHFMIUSAJgIt+7c+3J5m/XCzPHcunPvimeZLZP7jxxNy1+Xye27D654FmBYFDgAYCIcOHJ0QeNnUp/KJDAsChwAMBHOX7tmQeNnUp/KJDAsChwAMBFu2rIxZ0+/8qvP2dOvy01bNq54lj6VSWBYFDgAYCJce+l5+ZWrN+Wta9ekkrx17Zr8ytWbOlk4pE9lEhgWq1ACABPj2kvP68VKj7MZrEIJLJQCBwDQgb6USWBYTKEEAAAYCAUOAABgIBQ4AACAgXANHADABNu++6DFVGBAFDgAgAm1fffB3LLj0bwwczxJsv/I0dyy49EkUeKgp0yhBACYULfu3PtyeZv1wszx3LpzbzeBgNNS4AAAJtSBI0cXNA50T4EDAJhQ569ds6BxoHsKHADAhLppy8acPf3Kr4NnT78uN23Z2E0g4LQsYgIAMKFmFyqxCiUMx1gFrqquSfJvk0wl+a3W2q+e9PrfS/JPR0+fS/I/t9b+fPTa3iRHkhxLMtNa27w80QEAWKprLz1PYYMBOW2Bq6qpJJ9O8t4k+5LcX1XbW2sPz9nsW0l+orX2TFW9L8ntSX5szutXt9aeXMbcAAAAE2eca+CuSLKntfZYa+3FJHcmuW7uBq21r7bWnhk93ZnkwuWNCQAAwDgF7oIkj895vm80diofSPKf5zxvSf6gqh6oqhtPtVNV3VhVu6pq16FDh8aIBQAAMFnGuQau5hlr825YdXVOFLgfnzP87tba/qp6c5IvVdU3W2tfedUvbO32nJh6mc2bN8/7+wEAACbZOGfg9iW5aM7zC5PsP3mjqnpHkt9Kcl1r7anZ8dba/tHPJ5J8NiemZAIAALBA4xS4+5NsqqpLquqsJDck2T53g6q6OMnvJ/n7rbW/mDP+hqpaO/s4yU8meXC5wgMAAEyS006hbK3NVNWHk9yTE7cRuKO19lBVfXD0+m1J/nmSNyX5TFUlf327gPOSfHY0Np3kd1trXzwjfxMAAIBVbqz7wLXW7k5y90ljt815/PNJfn6e/R5L8s4lZgQAACDjTaEEAACgBxQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIEY6zYCAABwpm3ffTC37tybA0eO5vy1a3LTlo259tLzuo4FvaLAAQDQue27D+aWHY/mhZnjSZL9R47mlh2PJokSB3OYQgkAQOdu3bn35fI264WZ47l1595uAkFPKXAAAHTuwJGjCxqHSaXAAQDQufPXrlnQOEwqBQ4AgM7dtGVjzp5+5VfTs6dfl5u2bOwmEPSURUwAAOjc7EIlVqGE16bAAQDQC9deep7CBqdhCiUAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAjFXgquqaqtpdVXuq6uZ5Xv97VfX10Z+vVtU7x90XAACA8Zy2wFXVVJJPJ3lfksuS/FxVXXbSZt9K8hOttXck+ZdJbl/AvgAAAIxhnDNwVyTZ01p7rLX2YpI7k1w3d4PW2ldba8+Mnu5McuG4+wIAADCecQrcBUken/N832jsVD6Q5D8vcl8AAABOYXqMbWqesTbvhlVX50SB+/FF7HtjkhuT5OKLLx4jFgAAwGQZ5wzcviQXzXl+YZL9J29UVe9I8ltJrmutPbWQfZOktXZ7a21za23zhg0bxskOAAAwUcYpcPcn2VRVl1TVWUluSLJ97gZVdXGS30/y91trf7GQfQEAABjPaadQttZmqurDSe5JMpXkjtbaQ1X1wdHrtyX550nelOQzVZUkM6OzafPue4b+LgAAAKvaONfApbV2d5K7Txq7bc7jn0/y8+PuCwAAwMKNdSNvAAAAuqfAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwEAocAAAAAOhwAEAAAyEAgcAADAQChwAAMBAKHAAAAADocABAAAMhAIHAAAwEAocAADAQChwAAAAA6HAAQAADIQCBwAAMBAKHAAAwECMVeCq6pqq2l1Ve6rq5nle/8Gq+uOqOlpV/8tJr+2tqm9U1deqatdyBQcAAJg006fboKqmknw6yXuT7Etyf1Vtb609PGezp5N8JMn1p/g1V7fWnlxiVgAAgIl22gKX5Ioke1prjyVJVd2Z5LokLxe41toTSZ6oqp8+IykBemDHw89l233P5MnDx7L+3KlsvXJdrr7snK5jAQATZJwplBckeXzO832jsXG1JH9QVQ9U1Y2n2qiqbqyqXVW169ChQwv49QBn3o6Hn8un7nkqhw4fS0ty6PCxfOqep7Lj4ee6jgYATJBxClzNM9YW8B7vbq39aJL3JflQVf3t+TZqrd3eWtvcWtu8YcOGBfx6gDNv233P5OjMKz/6js60bLvvmY4SAQCTaJwCty/JRXOeX5hk/7hv0FrbP/r5RJLP5sSUTIBBefLwsQWNAwCcCeMUuPuTbKqqS6rqrCQ3JNk+zi+vqjdU1drZx0l+MsmDiw0L0JX1504taBwA4Ew4bYFrrc0k+XCSe5I8kuSu1tpDVfXBqvpgklTVW6pqX5KbktxSVfuq6twk5yX5o6r68yR/muQLrbUvnqm/DMCZsvXKdVkz/coZ5WumK1uvXNdRIgBgEo2zCmVaa3cnufuksdvmPP5uTkytPNnhJO9cSkCAPphdbdIqlABAl8YqcACcKHEKGwDQpXGugQMAAKAHFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgZjuOgAAC7fj4eey7b5n8uThY1l/7lS2XrkuV192TtexAIAzTIEDGJgdDz+XT93zVI7OtCTJocPH8ql7nkoSJQ4AVjlTKAEGZtt9z7xc3mYdnWnZdt8zHSUCAFaKAgcwME8ePragcQBg9VDgAAZm/blTCxoHAFYPBQ5gYLZeuS5rpusVY2umK1uvXNdRIgBgpVjEBGBgZhcqsQolAEweBQ5ggK6+7ByFDQAm0FhTKKvqmqraXVV7qurmeV7/war646o6WlX/y0L2BQAAYDynLXBVNZXk00nel+SyJD9XVZedtNnTST6S5H9bxL4AAACMYZwzcFck2dNae6y19mKSO5NcN3eD1toTrbX7k7y00H0BAAAYzzgF7oIkj895vm80No6x962qG6tqV1XtOnTo0Ji/HgAAYHKMU+BqnrE25u8fe9/W2u2ttc2ttc0bNmwY89cDAABMjnEK3L4kF815fmGS/WP+/qXsCwAAwBzjFLj7k2yqqkuq6qwkNyTZPubvX8q+AAAAzHHa+8C11maq6sNJ7kkyleSO1tpDVfXB0eu3VdVbkuxKcm6S41X1i0kua60dnm/fM/R3AQAAWNXGupF3a+3uJHefNHbbnMffzYnpkWPtCwAAwMKNVeAAYD47Hn4u2+57Jk8ePpb1505l65XrcvVl53QdCwBWLQUOgEXZ8fBz+dQ9T+XozInFhQ8dPpZP3fNUkihxAHCGKHAALMq2+555ubzNOjrTsu2+ZzopcM4GAjAJFDgAFuXJw8cWNH4mORsIwKQY5zYCAPAq68+dWtD4mfRaZwMBYDVxBg6ARdl65bpXnPVKkjXTla1XrlvxLH07G9iXqZx9ygLA8lDgAFiU2SLQh4Kw/typHJqnrK302cA+TeXsUxYAlo8CB8CiXX3ZOb0oA305G9inhV36lAWA5aPAATB4fTkb2KepnH3KAsDyUeAAWBX6cDawL1M5+5YFgOVjFUoAWCZbr1yXNdP1irGuFnbpUxYAlo8zcACwTPoylbNvWQBYPgocACyjPkzlnNWnLAAsD1MoAQAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGIixClxVXVNVu6tqT1XdPM/rVVWfHL3+9ar60Tmv7a2qb1TV16pq13KGBwAAmCTTp9ugqqaSfDrJe5PsS3J/VW1vrT08Z7P3Jdk0+vNjSX5z9HPW1a21J5ctNQAAwAQa5wzcFUn2tNYea629mOTOJNedtM11Sf6PdsLOJH+jqs5f5qwAAAATbZwCd0GSx+c83zcaG3ebluQPquqBqrpxsUEBAAAm3WmnUCapecbaArZ5d2ttf1W9OcmXquqbrbWvvOpNTpS7G5Pk4osvHiMWAADAZBnnDNy+JBfNeX5hkv3jbtNam/35RJLP5sSUzFdprd3eWtvcWtu8YcOG8dIDAABMkHEK3P1JNlXVJVV1VpIbkmw/aZvtSf7BaDXKLUmeba0dqKo3VNXaJKmqNyT5ySQPLmN+AACAiXHaKZSttZmq+nCSe5JMJbmjtfZQVX1w9PptSe5O8v4ke5J8L8n/ONr9vCSfrarZ9/rd1toXl/1vAQAAMAHGuQYurbW7c6KkzR27bc7jluRD8+z3WJJ3LjEjAAAAGfNG3gAAAHRPgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABgIBQ4AAGAgFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIBQ4AACAgVDgAAAABkKBAwAAGAgFDgAAYCCmuw4wFF/84hfz3W89kkx9X9dRgCV49uiRTP/5l7uOAYNz/Hsz+caDf9F1DBjbSy/9l0zt+suuYzAAb3rTmlx//U90HWNszsABAAAMhDNwY7rmmmuSR6eSN6zvOgqwBH+0776se/tVXceAwXn+m0/nHW+7vOsYMLYnn/rDnHPJ27qOwQC89NLTXUdYEGfgAAAABkKBAwAAGIixplBW1TVJ/m2SqSS/1Vr71ZNer9Hr70/yvST/sLX2Z+PsOyk+t/t7+cRXj2T/kWN569qpfPRda3P9pa+f6Cx9ydGnLH3J0acsfckBwOT4woPP5ZNffjbfPXwsbzl3Kh+56o356R8+R5aeZOlLjq6ctsBV1VSSTyd5b5J9Se6vqu2ttYfnbPa+JJtGf34syW8m+bEx9131Prf7e/nYvc/m+ZmWJPnOkWP52L3PJsmKfxHtS5a+5OhTlr7k6FOWvuQAYHJ84cHn8st3P5MXRv/tOXD4WH757meSZMVLgiz9zdGlcaZQXpFkT2vtsdbai0nuTHLdSdtcl+T/aCfsTPI3qur8Mfdd9T7x1SMvfwGd9fxMyye+emRis/QlR5+y9CVHn7L0JQcAk+OTX3725XIw64WZlk9++VlZepClLzm6NE6BuyDJ43Oe7xuNjbPNOPsmSarqxqraVVW7Dh06NEas4dh/5NiCxs+kvmTpS47Xek//JuOPr/YcAEyO7x6e/78xpxo/k2Tpb44ujVPgap6xNuY24+x7YrC121trm1trmzds2DBGrOF469qpBY2fSX3J0pccr/We/k3GH1/tOQCYHG85d/7/xpxq/EySpb85ujROgduX5KI5zy9Msn/MbcbZd9X76LvW5vunX9llv3+68tF3rZ3YLH3J0acsfcnRpyx9yQHA5PjIVW/M2Sf9t+fs6cpHrnqjLD3I0pccXRpnFcr7k2yqqkuSfCfJDUn+7knbbE/y4aq6MycWMXm2tXagqg6Nse+qN7vYQh9W0utLlr7k6FOWvuToU5a+5ABgcswuhNGHVQ5l6W+OLlVr885ofOVGVe9P8us5cSuAO1prH6+qDyZJa+220W0EfiPJNTlxG4H/sbW261T7nu79Nm/e3Hbt2rWov9AZ9eiXkjes7zoFsAR/tO++rHv7e7qOAYPz/DefzjvednnXMWBsTz71hznnkrd1HYMBeOmlp/OmN/1E1zFepaoeaK1tPnl8rPvAtdbuTnL3SWO3zXncknxo3H0BAABYuHGugQMAAKAHFDgAAICBUOAAAAAGQoEDAAAYCAUOAABgIMa6jcBKG90/7i+7znGGrE/yZNchYAEcswyNY5ahccwyNI7ZlfG21tqGkwd7WeBWs6raNd/9HKCvHLMMjWOWoXHMMjSO2W6ZQgkAADAQChwAAMBAKHAr7/auA8ACOWYZGscsQ+OYZWgcsx1yDRwAAMBAOAMHAAAwEAocAADAQChwK6Sqrqmq3VW1p6pu7joPnE5V7a2qb1TV16pqV9d5YD5VdUdVPVFVD84Z+4Gq+lJVPTr6ua7LjDDrFMfrv6iq74w+a79WVe/vMiPMVVUXVdWOqnqkqh6qql8Yjfuc7ZACtwKqairJp5O8L8llSX6uqi7rNhWM5erW2uXu9UKP/U6Sa04auznJva21TUnuHT2HPvidvPp4TZJ/M/qsvby1dvcKZ4LXMpPkn7TW/laSLUk+NPoO63O2QwrcyrgiyZ7W2mOttReT3Jnkuo4zAQxea+0rSZ4+afi6JNtGj7cluX4lM8GpnOJ4hd5qrR1orf3Z6PGRJI8kuSA+ZzulwK2MC5I8Puf5vtEY9FlL8gdV9UBV3dh1GFiA81prB5ITXz6SvLnjPHA6H66qr4+mWJqKRi9V1cYkP5LkT+JztlMK3Mqoecbcv4G+e3dr7UdzYurvh6rqb3cdCGAV+s0kb09yeZIDSf51p2lgHlV1TpLfS/KLrbXDXeeZdArcytiX5KI5zy9Msr+jLDCW1tr+0c8nknw2J6YCwxAcrKrzk2T084mO88AptdYOttaOtdaOJ/l38VlLz1TV9+VEefsPrbXfHw37nO2QArcy7k+yqaouqaqzktyQZHvHmeCUquoNVbV29nGSn0zy4GvvBb2xPcnW0eOtST7fYRZ4TbNfgkd+Jj5r6ZGqqiT/PskjrbVb57zkc7ZD1ZqZfCthtCzwryeZSnJHa+3j3SaCU6uqv5kTZ92SZDrJ7zpm6aOq+o9JrkqyPsnBJL+U5HNJ7kpycZJvJ/nZ1pqFI+jcKY7Xq3Ji+mRLsjfJP5q9tgi6VlU/nuS+JN9Icnw0/M9y4jo4n7MdUeAAAAAGwhRKAACAgVDgAAAABkKBAwAAGAgFDgAAYCAUOAAAgIFQ4AAAAAZCgQMAABiI/z9d88OGLE0ukQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "df7a1cb2-476c-4291-b0f3-dcac7471d59d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/ocean/sallen/miniconda3/envs/py39/lib/python3.9/site-packages/pandas/util/_decorators.py:311: ParserWarning: Length of header or names does not match length of data. This leads to a loss of data with index_col=False.\n",
      "  return func(*args, **kwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000.  999.  999.  999.  999.] [105.48546133 106.86038262 108.7171627  111.8697667  114.5023228\n",
      " 115.80221467 117.3844214  231.48898335 216.09253032 197.19601521\n",
      " 187.27905109 176.93845482 170.1561281  645.82095475 546.22020211\n",
      " 474.02344999 435.46466257 395.4966964   60.40853594  64.21994037\n",
      "  66.95350834  70.65607426] [0.115      0.123      0.133      0.137      0.146      0.139\n",
      " 0.142      0.356      0.348      0.335      0.321      0.309\n",
      " 0.284      0.516      0.514      0.497      0.495      0.506\n",
      " 0.03603604 0.03203203 0.03403403 0.03703704] [0.    0.    0.    0.    0.    0.    0.    0.085 0.085 0.075 0.077 0.058\n",
      " 0.063 0.231 0.222 0.205 0.206 0.216 0.    0.    0.    0.   ]\n"
     ]
    }
   ],
   "source": [
    "river = 'Snohomish_Monroe'\n",
    "\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b606764d-2657-4d34-aaba-c7dc5df3fedd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c493368b-1d5c-4dee-b02b-b195a8c81059",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/ocean/sallen/miniconda3/envs/py39/lib/python3.9/site-packages/pandas/util/_decorators.py:311: ParserWarning: Length of header or names does not match length of data. This leads to a loss of data with index_col=False.\n",
      "  return func(*args, **kwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000.  998.  998.  998.  998.] [120.1784735  120.2880641  121.92100163 123.86808963 125.05650484\n",
      " 125.78596512 126.22343184 271.3635633  240.74343747 213.45846492\n",
      " 192.26178098 184.65153788 178.18153739 805.8714663  631.38218802\n",
      " 560.62005326 477.32023448 415.70285195 115.18686648 126.26846013\n",
      " 132.81644725 141.28525129] [0.051      0.045      0.044      0.046      0.048      0.051\n",
      " 0.049      0.244      0.219      0.193      0.164      0.158\n",
      " 0.152      0.586      0.505      0.465      0.421      0.397\n",
      " 0.03306613 0.04108216 0.04408818 0.0501002 ] [0.         0.         0.         0.         0.         0.\n",
      " 0.         0.084      0.081      0.061      0.035      0.033\n",
      " 0.027      0.283      0.242      0.232      0.204      0.201\n",
      " 0.         0.00200401 0.         0.001002  ]\n"
     ]
    }
   ],
   "source": [
    "river = 'Skagit_MountVernon'\n",
    "\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4e696430-3bfb-45a5-ae75-9430e9ca8552",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAANOCAYAAABQmu4KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABMnElEQVR4nO39f7Cc9X0ner4/nBMk20iOjGRZFthivLpkZJdNcnWJrh0SWG5ibE8Bqb3exZk7o5l1ivEtGCerGW9wihpPdsJOpnxHkzGxw2US32hqk7DsJLZVY8bEy8oJWUcJIuPYIKxIixUjJAuBCRKxOXCOvvuH+pAjcSTOL53u5/TrVaXqfj79PN0ftR/a/db329+nWmsBAABg8F3Q7wYAAACYGQEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6IjRfjcwndWrV7cNGzb0u41XevFvkjbR7y6Aefj+yfFMjF7Y7zagc0bGL8jy8t8O3TGRF5JRq63z6qpGMjLy2n638QoPP/zw0621NWfWBzLAbdiwIXv27Ol3G6+0/8vJ61b3uwtgHv740INZ9bZr+90GdM73v/ndvPOtV/S7DZixp5/5w1x02Vv73QYd8NJL383FF/9Ev9t4har6q+nqplACAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BEDeRkBAGBp2bnvaLbvPpgjJ8aybsWybNuyIddfvrbfbQF0jgAHAJxXO/cdze279ueF8ZNJksMnxnL7rv1JIsQBzNKsp1BW1f+lqh6tqkeq6neranlVvaGqvlxV+3u3q6bs//GqOlBV+6rqvQvbPgAw6LbvPvhyeJv0wvjJbN99sD8NAXTYrAJcVa1P8tEkm1tr70gykuSmJLcleaC1tjHJA73tVNWm3uNvT3Jdks9U1cjCtQ8ADLojJ8ZmVQfg7OayiMloktdU1WiS1yY5nOSGJDt6j+9IcmPv/g1J7mmtjbXWvpXkQJIr59UxANAp61Ysm1UdgLObVYBrrT2Z5H9J8u0kR5I811r7gyRrW2tHevscSfLG3iHrkzwx5SkO9WqvUFU3V9Weqtpz7Nix2f0tAICBtW3LhiwfPf0rx/LRC7Jty4b+NATQYbOdQrkqp0bVLkvy5iSvq6r/6VyHTFNr0+3YWru7tba5tbZ5zZo1s2kLABhg11++Nr98zca8ecWyVJI3r1iWX75mowVMAOZgtqtQ/g9JvtVaO5YkVfX7Sd6d5GhVrWutHamqdUme6u1/KMmlU46/JKemXAIAQ+T6y9cKbAALYLa/gft2ki1V9dqqqiTXJnksyc4kW3v7bE3yhd79nUluqqplVXVZko1J/mz+bQMAAAyfWY3Atdb+tKr+U5I/TzKe5L8muTvJRUnuraoP51TI+2Bv/0er6t4ke3v739Jam1jA/gEAAIbGrC/k3Vr7RJJPnFEey6nRuOn2vyPJHbNvDQAAgKnmchkBAAAA+kCAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgI2YV4Krq8qr62pQ/x6vq56vqDVX15ara37tdNeWYj1fVgaraV1XvXfi/AgAAwHCYVYBrre1rrV3RWrsiyX+b5HtJPpfktiQPtNY2Jnmgt52q2pTkpiRvT3Jdks9U1cjCtQ8AADA85jOF8tok/7/W2l8luSHJjl59R5Ibe/dvSHJPa22stfatJAeSXDmP1wQAABha8wlwNyX53d79ta21I0nSu31jr74+yRNTjjnUq71CVd1cVXuqas+xY8fm0RYAAMDSNKcAV1UXJrk+yf/r1Xadptam27G1dndrbXNrbfOaNWvm0hYAAMCSNtcRuPcl+fPW2tHe9tGqWpckvdunevVDSS6dctwlSQ7P8TUBAACG2lwD3Ifyt9Mnk2Rnkq29+1uTfGFK/aaqWlZVlyXZmOTP5viaAAAAQ210tgdU1WuT/GSSfzKl/CtJ7q2qDyf5dpIPJklr7dGqujfJ3iTjSW5prU3Mu2sAAIAhNOsA11r7XpKLz6g9k1OrUk63/x1J7phTdwAAALxsPqtQAgAAsIgEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6IjRfjcAALBYdu47mu27D+bIibGsW7Es27ZsyPWXr+13WwAzJsABAENh576juX3X/rwwfjJJcvjEWG7ftT9JhDigM0yhBACGwvbdB18Ob5NeGD+Z7bsP9qchgDkQ4ACAoXDkxNis6gCDSIADAIbCuhXLZlUHGEQCHAAwFLZt2ZDlo6d/9Vk+ekG2bdnQn4YA5sAiJgDAUJhcqMQqlECXCXAAwNC4/vK1AhvQaaZQAgAAdIQABwAA0BGzDnBV9YNV9Z+q6ptV9VhV/fdV9Yaq+nJV7e/drpqy/8er6kBV7auq9y5s+wAAAMNjLiNw/z7Jl1prP5TkXUkeS3JbkgdaaxuTPNDbTlVtSnJTkrcnuS7JZ6pqZCEaBwAAGDazCnBVtTLJjyf5zSRprb3YWvvrJDck2dHbbUeSG3v3b0hyT2ttrLX2rSQHklw5/7YBAACGz2xH4P5OkmNJ/req+q9V9RtV9boka1trR5Kkd/vG3v7rkzwx5fhDvdorVNXNVbWnqvYcO3Zslm0BAAAsfbMNcKNJfiTJr7fWfjjJ36Q3XfIsappam27H1trdrbXNrbXNa9asmWVbAAAAS99sA9yhJIdaa3/a2/5PORXojlbVuiTp3T41Zf9Lpxx/SZLDc28XAABgeM0qwLXWvpPkiaq6vFe6NsneJDuTbO3Vtib5Qu/+ziQ3VdWyqrosycYkfzbvrgEAAIbQ6ByO+adJfruqLkzyeJJ/nFNB8N6q+nCSbyf5YJK01h6tqntzKuSNJ7mltTaxIJ0DAAAMmVkHuNba15Jsnuaha8+y/x1J7pjt6wAAAHC6uVwHDgAAgD4Q4AAAADpCgAMAAOgIAQ4AAKAj5rIKJQAA87Rz39Fs330wR06MZd2KZdm2ZUOuv3xtv9sCBpwABwCwyHbuO5rbd+3PC+MnkySHT4zl9l37k0SIA87JFEoAgEW2fffBl8PbpBfGT2b77oP9aQjoDAEOAGCRHTkxNqs6wCQBDgBgka1bsWxWdYBJAhwAwCLbtmVDlo+e/jVs+egF2bZlQ38aAjrDIiYAAItscqESq1ACsyXAAQD0wfWXrxXYgFkzhRIAAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpi1gGuqg5W1Teq6mtVtadXe0NVfbmq9vduV03Z/+NVdaCq9lXVexeyeQAAgGEy1xG4a1prV7TWNve2b0vyQGttY5IHetupqk1Jbkry9iTXJflMVY3Ms2cAAIChtFBTKG9IsqN3f0eSG6fU72mtjbXWvpXkQJIrF+g1AQAAhspcAlxL8gdV9XBV3dyrrW2tHUmS3u0be/X1SZ6YcuyhXu0VqurmqtpTVXuOHTs2h7YAAACWttE5HPOe1trhqnpjki9X1TfPsW9NU2vT7dhauzvJ3UmyefPmafcBAAAYZrMegWutHe7dPpXkczk1JfJoVa1Lkt7tU73dDyW5dMrhlyQ5PJ+GAQAAhtWsAlxVva6qVkzeT/JTSR5JsjPJ1t5uW5N8oXd/Z5KbqmpZVV2WZGOSP1uIxgEAAIbNbKdQrk3yuaqaPPZ3WmtfqqqHktxbVR9O8u0kH0yS1tqjVXVvkr1JxpPc0lqbWLDuAQCYl537jmb77oM5cmIs61Ysy7YtG3L95Wv73RZwFrMKcK21x5O8a5r6M0muPcsxdyS5Y07dAQBw3uzcdzS379qfF8ZPJkkOnxjL7bv2J4kQBwNqoS4jAABAx2zfffDl8DbphfGT2b77YH8aAl6VAAcAMKSOnBibVR3oPwEOAGBIrVuxbFZ1oP8EOACAIbVty4YsHz396+Dy0QuybcuG/jQEvKq5XMgbAIAlYHKhEqtQQncIcAAAQ+z6y9cKbNAhplACAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BECHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHjPa7AQAASJKd+45m++6DOXJiLOtWLMu2LRty/eVr+90WDBQBDgCAvtu572hu37U/L4yfTJIcPjGW23ftTxIhDqYwhRIAgL7bvvvgy+Ft0gvjJ7N998H+NAQDSoADAKDvjpwYm1UdhpUABwBA361bsWxWdRhWcwpwVTVSVf+1qv5zb/sNVfXlqtrfu101Zd+PV9WBqtpXVe9dqMYBAFg6tm3ZkOWjp381XT56QbZt2dCfhmBAzXUE7ueSPDZl+7YkD7TWNiZ5oLedqtqU5KYkb09yXZLPVNXI3NsFAGApuv7ytfnlazbmzSuWpZK8ecWy/PI1Gy1gAmeY9SqUVXVJkg8kuSPJtl75hiRX9+7vSPKVJL/Qq9/TWhtL8q2qOpDkyiR/Mq+uAQBYcq6/fK3ABq9iLiNwv5rk/5pk6jJBa1trR5Kkd/vGXn19kiem7HeoV3uFqrq5qvZU1Z5jx47NoS0AAIClbVYBrqr+XpKnWmsPz/SQaWptuh1ba3e31ja31javWbNmNm0BAAAMhdlOoXxPkuur6v1JlidZWVX/jyRHq2pda+1IVa1L8lRv/0NJLp1y/CVJDs+3aQAAgGE0qxG41trHW2uXtNY25NTiJP+f1tr/lGRnkq293bYm+ULv/s4kN1XVsqq6LMnGJH+2IJ0DAAAMmVkvYnIWv5Lk3qr6cJJvJ/lgkrTWHq2qe5PsTTKe5JbW2sQCvSYAAMBQmXOAa619JadWm0xr7Zkk155lvztyasVKAAAA5mGu14EDAABgkQlwAAAAHSHAAQAAdIQABwAA0BECHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BECHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0xKwCXFUtr6o/q6q/qKpHq+qXevU3VNWXq2p/73bVlGM+XlUHqmpfVb13of8CAAAAw2K2I3BjSf73rbV3JbkiyXVVtSXJbUkeaK1tTPJAbztVtSnJTUnenuS6JJ+pqpEF6h0AAGCozCrAtVOe723+QO9PS3JDkh29+o4kN/bu35DkntbaWGvtW0kOJLlyvk0DAAAMo1n/Bq6qRqrqa0meSvLl1tqfJlnbWjuSJL3bN/Z2X5/kiSmHH+rVpnvem6tqT1XtOXbs2GzbAgAAWPJmHeBaaxOttSuSXJLkyqp6xzl2r+me4izPe3drbXNrbfOaNWtm2xYAAMCSN+dVKFtrf53kKzn127ajVbUuSXq3T/V2O5Tk0imHXZLk8FxfEwAAYJjNdhXKNVX1g737r0nyPyT5ZpKdSbb2dtua5Au9+zuT3FRVy6rqsiQbk/zZAvQNAAAwdEZnuf+6JDt6K0lekOTe1tp/rqo/SXJvVX04ybeTfDBJWmuPVtW9SfYmGU9yS2ttYuHaBwAAGB6zCnCtta8n+eFp6s8kufYsx9yR5I45dQcAAMDLZjsCBzC0du19PjsefDZPH5/I6pUj2XrVqlyz6aJ+twUADBEBDmAGdu19Pnfe/0zGxk8tpHvs+ETuvP+ZJBHiAIBFM+dVKAGGyY4Hn305vE0aG2/Z8eCzfeoIABhGAhzADDx9fPr1l85WBwA4HwQ4gBlYvXJkVnUAgPNBgAOYga1Xrcqy0Tqttmy0svWqVX3qCAAYRhYxAZiByYVKrEIJAPSTAAcwQ9dsukhgAwD6yhRKAACAjhDgAAAAOsIUSoAO2rX3eb/HA4AhJMABdMyuvc/nzvufefnC4seOT+TO+59JEiEOAJY4UygBOmbHg8++HN4mjY237Hjw2T51BAAsFgEOoGOePj4xqzoAsHQIcAAds3rlyKzqAMDSIcABdMzWq1Zl2WidVls2Wtl61ao+dQQALBaLmAB0zORCJVahBIDhI8ABdNA1my4S2ABgCAlwAMyZ69EBwOIS4ACYE9ejA4DFZxETAObE9egAYPEJcADMievRAcDim1WAq6pLq2pXVT1WVY9W1c/16m+oqi9X1f7e7aopx3y8qg5U1b6qeu9C/wUA6A/XowOAxTfbEbjxJP+stfZ3k2xJcktVbUpyW5IHWmsbkzzQ207vsZuSvD3JdUk+U1X+nx1gCXA9OgBYfLMKcK21I621P+/dP5HksSTrk9yQZEdvtx1JbuzdvyHJPa21sdbat5IcSHLlAvQNQJ9ds+mi/NP3Xpw1K0dSSdasHMk/fe/FFjABgPNozqtQVtWGJD+c5E+TrG2tHUlOhbyqemNvt/VJdk857FCvBsASMEjXo3NJAwCGwZwCXFVdlOT3kvx8a+14VZ1112lqbZpaqurmJDcnyVve8pa5tAXAkHJJAwCGxawDXFX9QE6Ft99urf1+r3y0qtb1Rt/WJXmqVz+U5NIph1+S5PB0z9tauzvJ3UmyefPmaUMeAEznXJc0WOwAZyQQgPNptqtQVpLfTPJYa237lId2Jtnau781yRem1G+qqmVVdVmSjUn+bH4tA8DpBuWSBpMjgceOT6Tlb0cCd+19flH7AGDpmu0I3HuS/IMk36iqr/Vqv5jkV5LcW1UfTvLtJB9Mktbao1V1b5K9ObWC5S2tNRcIAmBBrV45kmPThLXFvqTBII0EJkYDAZaiWQW41tofZ/rftSXJtWc55o4kd8yyLwCYsa1XrTrtN3BJfy5pMCgjgYnfBQIsVbO9DhwADJxBuaTBIF3c/FyjgQB015wvIwAAg2QQLmkwKCOByWCNBgKwcAQ4AFggkwFyEH53Nii/CwRgYQlwALCABmEkMBms0UAAFo4ABwBL0CCNBgKwcAQ4AFiiBmU0EICFYxVKAACAjhDgAAAAOkKAAwAA6AgBDgAAoCMsYgIAAHTGFx95Pp/6ynP5zvGJvGnlSD569evzgXcMz4JNAhwAANAJX3zk+fzSfc/mhd41Lo8cn8gv3fdskgxNiDOFEgAA6IRPfeW5l8PbpBfGWz71lef61NHiMwIHAAC8qkGYuvid4xOzqi9FRuAAAIBzmpy6eOT4RFr+duriFx95flH7eNPKkVnVlyIjcDBAPr/ve/nkV0/k8ImJvHnFSD727hW58fLXDnUvg9IHAPTDIIx6JeeeuriY/Xz06tef9hu4JFk+Wvno1a9ftB76TYCjbwbpi/kg9PL5fd/Lxx94Lt/vfSA9eWIiH3/g1HzuYe1lUPoAgH4YpAU7BmXq4uTfexBCbb8IcItkEALCIPUySF/MB6WXT371xMs9TPr+eMsnv3pi0d+TQellUPoAgH4YlFGv5NQUxSPThLV+TF38wDsuGqrAdia/gVsEkwHhyROn5gxPBoTP7/ve0PZyri/mi21Qejl8Yvp/wTpb/XwalF4GpQ8AhssXH3k+7/21J/Ou//u3895fe3LRf+c1aVBGvZJTUxeXj9ZptWGbujgoBLhFMCgBYZB6GaQv5oPSy5tXTP8vWGern0+D0sug9AHA8BiUxTqSwVqw4wPvuCifeP+qrFs5kkqybuVIPvH+VUM9EtYvAtwiGJSAcK7XFFZmXj9fPvbuFXnNGf+y9ZrRysfevWJR+xikXgalDwCGxyBdZ2zQRr0+8I6Lcv+t6/MXv/iW3H/reuGtTwS4RTAoAeFcryms9L+XGy9/bf71ta/P+hWn/mVr/YqR/OtrX9+X33oNSi+D0gcAw2OQpi0a9WI6FjFZBB9794rTFslI+htWBqGXyS/g/V5MZRB7GZRwMii9DEofAAyHQVqsI7FgB6806wBXVZ9N8veSPNVae0ev9oYk/88kG5IcTPJ/bK0923vs40k+nGQiyUdba/cvSOcdMmgBYZB6GZQv5oPUCwDQP64zxqCbywjcbyX5tST/cUrttiQPtNZ+papu623/QlVtSnJTkrcneXOS/3dV/TettaFbQm6QAsIg9QIAMEhcZ4xBN+sA11r7o6racEb5hiRX9+7vSPKVJL/Qq9/TWhtL8q2qOpDkyiR/Msd+AQDgvDJtkUG2UIuYrG2tHUmS3u0be/X1SZ6Yst+hXu0VqurmqtpTVXuOHTu2QG0BAAAsHed7FcqaptamqaW1dndrbXNrbfOaNWvOc1sAAADds1AB7mhVrUuS3u1TvfqhJJdO2e+SJIcX6DUBAACGykIFuJ1Jtvbub03yhSn1m6pqWVVdlmRjkj9boNcEAAAYKnO5jMDv5tSCJaur6lCSTyT5lST3VtWHk3w7yQeTpLX2aFXdm2RvkvEktwzjCpQAAAALYS6rUH7oLA9de5b970hyx2xfBwAAgNNVa9OuKdJXVXUsyV/1u4/zZHWSp/vdBMyCc5aucc7SNc5ZusY5uzje2lp7xeqOAxnglrKq2tNa29zvPmCmnLN0jXOWrnHO0jXO2f4635cRAAAAYIEIcAAAAB0hwC2+u/vdAMySc5aucc7SNc5ZusY520d+AwcAANARRuAAAAA6QoADAADoCAFukVTVdVW1r6oOVNVt/e4HXk1VHayqb1TV16pqT7/7gelU1Wer6qmqemRK7Q1V9eWq2t+7XdXPHmHSWc7Xf1lVT/Y+a79WVe/vZ48wVVVdWlW7quqxqnq0qn6uV/c520cC3CKoqpEkn07yviSbknyoqjb1tyuYkWtaa1e41gsD7LeSXHdG7bYkD7TWNiZ5oLcNg+C38srzNUn+Xe+z9orW2n2L3BOcy3iSf9Za+7tJtiS5pfcd1udsHwlwi+PKJAdaa4+31l5Mck+SG/rcE0Dntdb+KMl3zyjfkGRH7/6OJDcuZk9wNmc5X2FgtdaOtNb+vHf/RJLHkqyPz9m+EuAWx/okT0zZPtSrwSBrSf6gqh6uqpv73QzMwtrW2pHk1JePJG/scz/wam6tqq/3pliaisZAqqoNSX44yZ/G52xfCXCLo6apuX4Dg+49rbUfyampv7dU1Y/3uyGAJejXk7wtyRVJjiT5t33tBqZRVRcl+b0kP99aO97vfoadALc4DiW5dMr2JUkO96kXmJHW2uHe7VNJPpdTU4GhC45W1bok6d0+1ed+4Kxaa0dbaxOttZNJ/kN81jJgquoHciq8/XZr7fd7ZZ+zfSTALY6Hkmysqsuq6sIkNyXZ2eee4Kyq6nVVtWLyfpKfSvLIuY+CgbEzydbe/a1JvtDHXuCcJr8E9/x0fNYyQKqqkvxmksdaa9unPORzto+qNTP5FkNvWeBfTTKS5LOttTv62xGcXVX9nZwadUuS0SS/45xlEFXV7ya5OsnqJEeTfCLJ55Pcm+QtSb6d5IOtNQtH0HdnOV+vzqnpky3JwST/ZPK3RdBvVfVjSR5M8o0kJ3vlX8yp38H5nO0TAQ4AAKAjTKEEAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Y7XcD01m9enXbsGFDv9t4pRf/JmkT/e4CmIfvnxzPxOiF/W4DOmdk/IIsL//t0B0TeSEZbf1ugw6oGsnIyGv73cYrPPzww0+31tacWR/IALdhw4bs2bOn32280v4vJ69b3e8ugHn440MPZtXbru13G9A53//md/POt17R7zZgxp5+5g9z0WVv7XcbdMBLL303F1/8E/1u4xWq6q+mq89rCmVVXVdV+6rqQFXddpZ9rq6qr1XVo1X1h/N5PQAAgGE25xG4qhpJ8ukkP5nkUJKHqmpna23vlH1+MMlnklzXWvt2Vb1xnv0CAAAMrfmMwF2Z5EBr7fHW2otJ7klywxn7/EyS32+tfTtJWmtPzeP1AAAAhtp8Atz6JE9M2T7Uq0313yRZVVVfqaqHq+ofzuP1AAAAhtp8FjGpaWpnLvUzmuS/TXJtktck+ZOq2t1a+8tXPFnVzUluTpK3vOUt82gLAABgaZrPCNyhJJdO2b4kyeFp9vlSa+1vWmtPJ/mjJO+a7slaa3e31ja31javWfOK1TIBAACG3nxG4B5KsrGqLkvyZJKbcuo3b1N9IcmvVdVokguT/GiSfzeP1wQAOmjnvqPZvvtgjpwYy7oVy7Jty4Zcf/nafrcF0DlzDnCttfGqujXJ/UlGkny2tfZoVX2k9/hdrbXHqupLSb6e5GSS32itPbIQjQMA3bBz39Hcvmt/Xhg/mSQ5fGIst+/anyRCHMAszetC3q21+5Lcd0btrjO2P5nkk/N5HQCgu7bvPvhyeJv0wvjJbN99UIADmKV5XcgbAODVHDkxNqs6AGcnwAEA59W6FctmVQfg7AQ4AOC82rZlQ5aPnv6VY/noBdm2ZUN/GgLosHn9Bg4A4NVM/s7NKpQA8yfAAQDn3fWXrxXYABaAKZQAAAAdIcABAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BECHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BECHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHjPa7AQCAxbJz39Fs330wR06MZd2KZdm2ZUOuv3xtv9sCmDEBDgAYCjv3Hc3tu/bnhfGTSZLDJ8Zy+679SSLEAZ0xrymUVXVdVe2rqgNVdds0j19dVc9V1dd6f/7FfF4PAGCutu8++HJ4m/TC+Mls332wPw0BzMGcR+CqaiTJp5P8ZJJDSR6qqp2ttb1n7Ppga+3vzaNHAIB5O3JibFZ1gEE0nxG4K5McaK093lp7Mck9SW5YmLYAABbWuhXLZlUHGETzCXDrkzwxZftQr3am/76q/qKq/ktVvf1sT1ZVN1fVnqrac+zYsXm0BQDwStu2bMjy0dO/+iwfvSDbtmzoT0MAczCfAFfT1NoZ23+e5K2ttXcluTPJ58/2ZK21u1trm1trm9esWTOPtgAAXun6y9fml6/ZmDevWJZK8uYVy/LL12y0gAnQKfNZhfJQkkunbF+S5PDUHVprx6fcv6+qPlNVq1trT8/jdQEA5uT6y9cKbECnzWcE7qEkG6vqsqq6MMlNSXZO3aGq3lRV1bt/Ze/1npnHawIAAAytOY/AtdbGq+rWJPcnGUny2dbao1X1kd7jdyX5H5P8z1U1nuT7SW5qrZ05zRIAAIAZmNeFvFtr9yW574zaXVPu/1qSX5vPawAAAHDKvC7kDQAAwOIR4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOmNcqlAAAzM3OfUezfffBHDkxlnUrlmXblg0uMg68KgEOAGCR7dx3NLfv2p8Xxk8mSQ6fGMvtu/YniRAHnJMplAAAi2z77oMvh7dJL4yfzPbdB/vTENAZAhwAwCI7cmJsVnWASQIcAMAiW7di2azqAJMEOACARbZty4YsHz39a9jy0QuybcuG/jQEdIZFTAAAFtnkQiVWoQRmS4ADAOiD6y9fK7ABs2YKJQAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0hAAHAADQEQIcAABAR4z2uwEAAPpn576j2b77YI6cGMu6FcuybcuGXH/52n63BZyFAAcAMKR27jua23ftzwvjJ5Mkh0+M5fZd+5NEiIMBZQolAMCQ2r774MvhbdIL4yezfffB/jQEvCoBDgBgSB05MTarOtB/AhwAwJBat2LZrOpA/wlwAABDatuWDVk+evrXweWjF2Tblg39aQh4VRYxAQAYUpMLlViFErpDgAMAGGLXX75WYIMOmdcUyqq6rqr2VdWBqrrtHPv9d1U1UVX/43xeDwAAYJjNOcBV1UiSTyd5X5JNST5UVZvOst+/SXL/XF8LAACA+U2hvDLJgdba40lSVfckuSHJ3jP2+6dJfi/JfzeP1wIAYInbue+o3+PBq5jPFMr1SZ6Ysn2oV3tZVa1P8tNJ7nq1J6uqm6tqT1XtOXbs2DzaAgCga3buO5rbd+3P4RNjaUkOnxjL7bv2Z+e+o/1uDQbKfAJcTVNrZ2z/apJfaK1NvNqTtdbubq1tbq1tXrNmzTzaAgCga7bvPpgXxk+eVnth/GS27z7Yn4ZgQM1nCuWhJJdO2b4kyeEz9tmc5J6qSpLVSd5fVeOttc/P43UBAFhijpwYm1UdhtV8AtxDSTZW1WVJnkxyU5KfmbpDa+2yyftV9VtJ/rPwBgDAmdatWJbD04S1dSuW9aEbGFxznkLZWhtPcmtOrS75WJJ7W2uPVtVHquojC9UgAABL37YtG7J89PSvpstHL8i2LRv60xAMqHldyLu1dl+S+86oTbtgSWvtH83ntQAAWLomV5u0CiWc27wCHAAALJTrL18rsMGrmM8qlAAAACwiAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgI+YV4KrquqraV1UHquq2aR6/oaq+XlVfq6o9VfVj83k9AACAYTY61wOraiTJp5P8ZJJDSR6qqp2ttb1Tdnsgyc7WWquqdya5N8kPzadhAACAYTWfEbgrkxxorT3eWnsxyT1Jbpi6Q2vt+dZa622+LkkLAAAAczKfALc+yRNTtg/1aqepqp+uqm8m+WKS//PZnqyqbu5Ns9xz7NixebQFAACwNM0nwNU0tVeMsLXWPtda+6EkNyb5V2d7stba3a21za21zWvWrJlHWwAAAEvTfALcoSSXTtm+JMnhs+3cWvujJG+rqtXzeE0AAIChNZ8A91CSjVV1WVVdmOSmJDun7lBV/7uqqt79H0lyYZJn5vGaAAAAQ2vOq1C21sar6tYk9ycZSfLZ1tqjVfWR3uN3Jfk/JPmHVfVSku8n+T9NWdQEAACAWZhzgEuS1tp9Se47o3bXlPv/Jsm/mc9rAAAAcMq8LuQNAADA4hHgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhjtdwMAXbFr7/PZ8eCzefr4RFavHMnWq1blmk0X9bstAGCICHAAM7Br7/O58/5nMjbekiTHjk/kzvufSRIhDgBYNKZQAszAjgeffTm8TRobb9nx4LN96ggAGEYCHMAMPH18YlZ1AIDzQYADmIHVK0dmVQcAOB8EOIAZ2HrVqiwbrdNqy0YrW69a1aeOAIBhZBETgBmYXKjEKpQAQD8JcAAzdM2miwQ2AKCvTKEEAADoCAEOAACgI0yhBOigXXuf93s8ABhCAhxAx+za+3zuvP+Zly8sfuz4RO68/5kkEeIAYIkzhRKgY3Y8+OzL4W3S2HjLjgef7VNHAMBiEeAAOubp4xOzqgMAS4cAB9Axq1eOzKoOACwdAhxAx2y9alWWjdZptWWjla1XrepTRwDAYrGICUDHTC5UYhVKABg+8wpwVXVdkn+fZCTJb7TWfuWMx/9+kl/obT6f5H9urf3FfF4TgFMhTmADgOEz5ymUVTWS5NNJ3pdkU5IPVdWmM3b7VpKfaK29M8m/SnL3XF8PAABg2M3nN3BXJjnQWnu8tfZiknuS3DB1h9baV1trk+ta705yyTxeDwAAYKjNZwrl+iRPTNk+lORHz7H/h5P8l7M9WFU3J7k5Sd7ylrfMoy0AFsuuvc/7LR4ALKL5jMDVNLU2TS1VdU1OBbhfmO7xJGmt3d1a29xa27xmzZp5tAXAYti19/ncef8zOXZ8Ii3JseMTufP+Z7Jr7/P9bg0Alqz5BLhDSS6dsn1JksNn7lRV70zyG0luaK09M4/XA2CA7Hjw2YyNn/7vdmPjLTsefPYsRwAA8zWfAPdQko1VdVlVXZjkpiQ7p+5QVW9J8vtJ/kFr7S/n8VoADJinj0/Mqg4AzN+cfwPXWhuvqluT3J9TlxH4bGvt0ar6SO/xu5L8iyQXJ/lMVSXJeGtt8/zbBqDfVq8cybFpwtrqlSN96AYAhsO8rgPXWrsvyX1n1O6acv9nk/zsfF4DgMG09apVufP+Z06bRrlstLL1qlV97AoAlrZ5BTgAhtfkapNWoQSAxSPAATBn12y6SGADgEU0n0VMAAAAWEQCHAAAQEcIcAAAAB3hN3AALAm79j5vQRUAljwBDoDO27X3+dMuaXDs+ETuvP+ZJBHiAFhSTKEEoPN2PPjsadejS5Kx8ZYdDz7bp44A4PwwAgdA5z19fGJW9fPJVE4AzicjcAB03uqVI7Oqny+TUzmPHZ9Iy99O5dy19/lF7QOApUuAA6Dztl61KstG67TastHK1qtWLWofgzaVc9fe5/OP/tcn8vc+eTD/6H99QpAEWAJMoQSg8yanKPZ76uKgTeW0sAvA0iPAAbAkXLPpor4Hk9UrR3JsmrC22FM5k3OPBvb7fQJg7kyhBIAFMihTOZPBGg0EYOEYgQOABTIoUzmTwRoNBGDhCHAAsIAGYSpncmo0cOpv4JL+jQYCsHAEOABYggZpNBCAhSPAAcASNSijgQAsHIuYAAAAdIQABwAA0BECHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdMS8AlxVXVdV+6rqQFXdNs3jP1RVf1JVY1X1z+fzWgAAAMNudK4HVtVIkk8n+ckkh5I8VFU7W2t7p+z23SQfTXLjfJoEAABgfiNwVyY50Fp7vLX2YpJ7ktwwdYfW2lOttYeSvDSP1wEAACDzC3DrkzwxZftQrzYnVXVzVe2pqj3Hjh2bR1sAAABL03wCXE1Ta3N9stba3a21za21zWvWrJlHWwAAAEvTfALcoSSXTtm+JMnh+bUDAADA2cwnwD2UZGNVXVZVFya5KcnOhWkLAACAM815FcrW2nhV3Zrk/iQjST7bWnu0qj7Se/yuqnpTkj1JViY5WVU/n2RTa+34/FsHAAAYLnMOcEnSWrsvyX1n1O6acv87OTW1EgAAgHma14W8AQAAWDwCHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0hAAHAADQEQIcAABAR4z2u4Fh8fl938snv3oih09M5M0rRvKxd6/IjZe/tt9twVk5ZwGAQfTFR57Pp77yXL5zfCJvWjmSj179+nzgHRf1u61FI8Atgs/v+14+/sBz+f54S5I8eWIiH3/guSTxhZjTDEpoGqRzdlDeEwCg/774yPP5pfuezQu97yhHjk/kl+57NkmGJsRVa63fPbzC5s2b2549e/rdxmm+9KUv5TvfeiwZ+YFZH/tfj7yYsYlXvs/LRio/vO7ChWhvVp7+3kSeeG4iL060XDhSufT1I1n92pFF72OQDMJ78vT3JvKtZycyMeW/yZGqXLZq8XsZlHP2fLwnz409l9HlP7hAHcLwOPm98Vy0fDi+HLE0vPTSX2fkNcv73QYL7OtPjmVsfJrvKKOVd65fNqfnvPjiZbnxxp+db2sLrqoebq1tPrNuBG4RvDjNF+Fz1c+nM78Qj020fOvZiSTpS2Dpd2ia7GMQ3pMnnjs9qCTJRGt54rmJRX9fBuWcHaT3BACG3TN/M5En/3o8L463XDhaWf+Do7n4dYv8HWWa8Hau+lJkBG429n85ed3qWR/2nv/taJ48MfGK+voVI/n//uO1C9FZ53o5c4pekrxmtPKvr339ok+PG5T35LJPHc50/zVWkm999M2L1keytN+TPz70YFa97dp59QXD6Pvf/G7e+dYr+t0GzNjTz/xhLrrsrf1uY94G5fdeZ05dTJLlo5VPvH/Vovbz3l97MkeOv/I7yrqVI7n/1vVzes6XXvpuLr74J+bb2oI72wicVSgXwcfevSKvGa3Taq8ZrXzs3SsWvZfD03wpP1f9fPnkV0+cFt6S5PvjLZ/86olF7SMZnPfkzSum/xess9XPp0E5ZwfpPQGAxTYZmo4cn0jL3/7e64uPPL/ovXzqK8+dFt6S5IXxlk995blF7eOjV78+y8/4jrJ8tPLRq1+/qH30kwC3CG68/LX519e+PutXjKRyahSjHyNNyeB8IR6U0JQMznsyKKEpGZxzdpDeEwBYbIMSmpLkO9OMep2rfr584B0X5RPvX5V1K099R1m3cmTRRwH7zW/gFsmNl792IFbO+9i7V0w7dbEfIyvTTdHr12jTILwnk+fHoKy4OAjn7KC9JwAMh0GZtjgooSlJ3rRyZNqpi29aufjf3T7wjouGKrCdSYAbMoPyhXhQQlMyOO/JZC/Cyem8JwAspkFapn6QQtNHr379tL+BG6api4NCgBtCg/CFeJBC02Q//X5PAID+O9e0xcUOcIMUmib/7oMwMjnsBDj6RmgCAAbNIE1bHLTQNOxTFweFAAcAAD2DNG0xEZp4JatQAgBAj2XqGXRG4AAAoGfQpi3CmQQ4AACYwrRFBpkplAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0RLXW+t3DK1TVsSR/1e8+zpPVSZ7udxMwC85ZusY5S9c4Z+ka5+zieGtrbc2ZxYEMcEtZVe1prW3udx8wU85ZusY5S9c4Z+ka52x/mUIJAADQEQIcAABARwhwi+/ufjcAs+ScpWucs3SNc5aucc72kd/AAQAAdIQROAAAgI4Q4AAAADpCgFskVXVdVe2rqgNVdVu/+4FXU1UHq+obVfW1qtrT735gOlX12ap6qqoemVJ7Q1V9uar2925X9bNHmHSW8/VfVtWTvc/ar1XV+/vZI0xVVZdW1a6qeqyqHq2qn+vVfc72kQC3CKpqJMmnk7wvyaYkH6qqTf3tCmbkmtbaFa71wgD7rSTXnVG7LckDrbWNSR7obcMg+K288nxNkn/X+6y9orV23yL3BOcynuSftdb+bpItSW7pfYf1OdtHAtziuDLJgdba4621F5Pck+SGPvcE0HmttT9K8t0zyjck2dG7vyPJjYvZE5zNWc5XGFittSOttT/v3T+R5LEk6+Nztq8EuMWxPskTU7YP9WowyFqSP6iqh6vq5n43A7OwtrV2JDn15SPJG/vcD7yaW6vq670plqaiMZCqakOSH07yp/E521cC3OKoaWqu38Cge09r7UdyaurvLVX14/1uCGAJ+vUkb0tyRZIjSf5tX7uBaVTVRUl+L8nPt9aO97ufYSfALY5DSS6dsn1JksN96gVmpLV2uHf7VJLP5dRUYOiCo1W1Lkl6t0/1uR84q9ba0dbaRGvtZJL/EJ+1DJiq+oGcCm+/3Vr7/V7Z52wfCXCL46EkG6vqsqq6MMlNSXb2uSc4q6p6XVWtmLyf5KeSPHLuo2Bg7EyytXd/a5Iv9LEXOKfJL8E9Px2ftQyQqqokv5nksdba9ikP+Zzto2rNTL7F0FsW+FeTjCT5bGvtjv52BGdXVX8np0bdkmQ0ye84ZxlEVfW7Sa5OsjrJ0SSfSPL5JPcmeUuSbyf5YGvNwhH03VnO16tzavpkS3IwyT+Z/G0R9FtV/ViSB5N8I8nJXvkXc+p3cD5n+0SAAwAA6AhTKAEAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgI0b73cB0Vq9e3TZs2NDvNl7pxb9J2kS/uwDm4fsnxzMxemG/24DOGRm/IMvLfzt0x0ReSEZbv9ugA6pGMjLy2n638QoPP/zw0621NWfWBzLAbdiwIXv27Ol3G6+0/8vJ61b3uwtgHv740INZ9bZr+90GdM73v/ndvPOtV/S7DZixp5/5w1x02Vv73QYd8NJL383FF/9Ev9t4har6q+nqplACAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BEDeRkBAGBp2bnvaLbvPpgjJ8aybsWybNuyIddfvrbfbQF0jgAHAJxXO/cdze279ueF8ZNJksMnxnL7rv1JIsQBzJIplADAebV998GXw9ukF8ZPZvvug/1pCKDDBDgA4Lw6cmJsVnUAzk6AAwDOq3Urls2qDsDZCXAAwHm1bcuGLB89/SvH8tELsm3Lhv40BNBhFjEBAM6ryYVKrEIJMH8CHABw3l1/+VqBDWABmEIJAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BECHAAAQEcIcAAAAB0hwAEAAHSEAAcAANARAhwAAEBHCHAAAAAdIcABAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BEzCnBVdV1V7auqA1V12zSP//2q+nrvz1er6l1THjtYVd+oqq9V1Z6FbB4AAGCYjL7aDlU1kuTTSX4yyaEkD1XVztba3im7fSvJT7TWnq2q9yW5O8mPTnn8mtba0wvYNwAAwNCZyQjclUkOtNYeb629mOSeJDdM3aG19tXW2rO9zd1JLlnYNgEAAJhJgFuf5Ikp24d6tbP5cJL/MmW7JfmDqnq4qm4+20FVdXNV7amqPceOHZtBWwAAAMPlVadQJqlpam3aHauuyakA92NTyu9prR2uqjcm+XJVfbO19keveMLW7s6pqZfZvHnztM8PAAAwzGYyAncoyaVTti9JcvjMnarqnUl+I8kNrbVnJuuttcO926eSfC6npmQCAAAwSzMZgXsoycaquizJk0luSvIzU3eoqrck+f0k/6C19pdT6q9LckFr7UTv/k8l+b8tVPMAALOxc9/RbN99MEdOjGXdimXZtmVDrr98bb/bApixVw1wrbXxqro1yf1JRpJ8trX2aFV9pPf4XUn+RZKLk3ymqpJkvLW2OcnaJJ/r1UaT/E5r7Uvn5W8CAHAOO/cdze279ueF8ZNJksMnxnL7rv1JIsQBnTGTEbi01u5Lct8Ztbum3P/ZJD87zXGPJ3nXmXUAgMW2fffBl8PbpBfGT2b77oMCHNAZM7qQNwBA1x05MTarOsAgEuAAgKGwbsWyWdUBBpEABwAMhW1bNmT56OlffZaPXpBtWzb0pyGAOZjRb+AAALpu8nduVqEEukyAAwCGxvWXrxXYgE4T4AAA+sA16YC5EOAAABaZa9IBc2UREwCARXaua9IBnIsABwCwyFyTDpgrAQ4AYJG5Jh0wVwIcAMAic006YK4sYgIAsMhckw6YKwEOAKAPXJMOmAtTKAEAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOiI0X43AABA/+zcdzTbdx/MkRNjWbdiWbZt2ZDrL1/b77aAsxDgAACG1M59R3P7rv15YfxkkuTwibHcvmt/kghxMKAEOACAIbV998GXw9ukF8ZPZvvug30JcEYD4dXN6DdwVXVdVe2rqgNVdds0j//9qvp6789Xq+pdMz0WAID+OHJibFb182lyNPDwibG0/O1o4M59Rxe9FxhkrxrgqmokyaeTvC/JpiQfqqpNZ+z2rSQ/0Vp7Z5J/leTuWRwLAEAfrFuxbFb18+lco4HA35rJCNyVSQ601h5vrb2Y5J4kN0zdobX21dbas73N3UkumemxAAD0x7YtG7J89PSvg8tHL8i2LRsWvZdBGg2EQTaTALc+yRNTtg/1amfz4ST/ZbbHVtXNVbWnqvYcO3ZsBm0BADAf11++Nr98zca8ecWyVJI3r1iWX75mY19+dzZIo4EwyGayiElNU2vT7lh1TU4FuB+b7bGttbvTm3q5efPmafcBAGBhXX/52oFYKGTblg2nrYiZ9G80EAbZTALcoSSXTtm+JMnhM3eqqncm+Y0k72utPTObYwEAGG6TIdIqlHBuMwlwDyXZWFWXJXkyyU1JfmbqDlX1liS/n+QftNb+cjbHAgBAMjijgTDIXjXAtdbGq+rWJPcnGUny2dbao1X1kd7jdyX5F0kuTvKZqkqS8dba5rMde57+LgAAAEvajC7k3Vq7L8l9Z9TumnL/Z5P87EyPBQAAYPZmdCFvAAAA+k+AAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpiRgGuqq6rqn1VdaCqbpvm8R+qqj+pqrGq+udnPHawqr5RVV+rqj0L1TgAAMCwGX21HapqJMmnk/xkkkNJHqqqna21vVN2+26Sjya58SxPc01r7el59goAADDUZjICd2WSA621x1trLya5J8kNU3dorT3VWnsoyUvnoUcAAAAyswC3PskTU7YP9Woz1ZL8QVU9XFU3n22nqrq5qvZU1Z5jx47N4ukBAACGw0wCXE1Ta7N4jfe01n4kyfuS3FJVPz7dTq21u1trm1trm9esWTOLpwcAABgOMwlwh5JcOmX7kiSHZ/oCrbXDvdunknwup6ZkAgAAMEszCXAPJdlYVZdV1YVJbkqycyZPXlWvq6oVk/eT/FSSR+baLAAAwDB71VUoW2vjVXVrkvuTjCT5bGvt0ar6SO/xu6rqTUn2JFmZ5GRV/XySTUlWJ/lcVU2+1u+01r50Xv4mAAAAS9yrBrgkaa3dl+S+M2p3Tbn/nZyaWnmm40neNZ8GAQAAOGVGF/IGAACg/wQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADpCgAMAAOgIAQ4AAKAjBDgAAICOEOAAAAA6QoADAADoCAEOAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI6YUYCrquuqal9VHaiq26Z5/Ieq6k+qaqyq/vlsjgUAAGBmXjXAVdVIkk8neV+STUk+VFWbztjtu0k+muR/mcOxAAAAzMBMRuCuTHKgtfZ4a+3FJPckuWHqDq21p1prDyV5abbHAgAAMDMzCXDrkzwxZftQrzYTMz62qm6uqj1VtefYsWMzfHoAAIDhMZMAV9PU2gyff8bHttbubq1tbq1tXrNmzQyfHgAAYHjMJMAdSnLplO1Lkhye4fPP51gAAACmmEmAeyjJxqq6rKouTHJTkp0zfP75HAsAAMAUo6+2Q2ttvKpuTXJ/kpEkn22tPVpVH+k9fldVvSnJniQrk5ysqp9Psqm1dny6Y8/T3wUAAGBJe9UAlySttfuS3HdG7a4p97+TU9MjZ3QsAAAAszejC3kDAADQfwIcAABARwhwAAAAHTGj38ABkOza+3x2PPhsnj4+kdUrR7L1qlW5ZtNF/W4LABgiAhzADOza+3zuvP+ZjI23JMmx4xO58/5nkkSIAwAWjQAHMAM7Hnz25fA2aWy8ZceDz/YlwBkNBIDhJMABzMDTxydmVT+fjAYCwPCyiAnADKxeOTKr+vl0rtFAAGBpE+AAZmDrVauybLROqy0brWy9atWi9zJIo4EAwOIyhRJgBianJg7C785WrxzJsWnCWj9GAwGAxSXAAczQNZsuGojfmG29atVpv4FL+jcaCAAsLgEOoGMGaTQQAFhcAhxABw3KaCAAsLgsYgIAANARAhwAAEBHCHAAAAAdIcABAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQLeQMwZ7v2Pp8dDz6bp49PZPXKkWy9apULjAPAeSTAATAnu/Y+nzvvfyZj4y1Jcuz4RO68/5kkEeIA4DwxhRKAOdnx4LMvh7dJY+MtOx58tk8dAcDSJ8ABMCdPH5+YVR0AmD8BDoA5Wb1yZFZ1AGD+BDgA5mTrVauybLROqy0brWy9alWfOgKApc8iJgDMyeRCJVahBIDFI8ABMGfXbLpIYAOARTSjKZRVdV1V7auqA1V12zSPV1V9qvf416vqR6Y8drCqvlFVX6uqPQvZPAAAwDB51RG4qhpJ8ukkP5nkUJKHqmpna23vlN3el2Rj78+PJvn13u2ka1prTy9Y1wAAAENoJiNwVyY50Fp7vLX2YpJ7ktxwxj43JPmP7ZTdSX6wqtYtcK8AAABDbSYBbn2SJ6ZsH+rVZrpPS/IHVfVwVd18thepqpurak9V7Tl27NgM2gIAABguMwlwNU2tzWKf97TWfiSnplneUlU/Pt2LtNbubq1tbq1tXrNmzQzaAgAAGC4zCXCHklw6ZfuSJIdnuk9rbfL2qSSfy6kpmQAAAMzSTALcQ0k2VtVlVXVhkpuS7Dxjn51J/mFvNcotSZ5rrR2pqtdV1YokqarXJfmpJI8sYP8AAABD41VXoWytjVfVrUnuTzKS5LOttUer6iO9x+9Kcl+S9yc5kOR7Sf5x7/C1ST5XVZOv9TuttS8t+N8CAABgCMzoQt6ttftyKqRNrd015X5Lcss0xz2e5F3z7BEAAIDM8ELeAAAA9J8ABwAA0BECHAAAQEfM6DdwADDodu19PjsefDZPH5/I6pUj2XrVqlyz6aJ+twUAC0qAA6Dzdu19Pnfe/0zGxluS5Njxidx5/zNJsughTpAE4HwyhRKAztvx4LMvh7dJY+MtOx58dlH7mAySx45PpOVvg+Suvc8vah8ALF0CHACd9/TxiVnVz5dBCZIALF0CHACdt3rlyKzq58ugBEkAli4BDoDO23rVqiwbrdNqy0YrW69atah9DEqQBGDpsogJAJ03uUhIvxcP2XrVqtMWU0n6EyQnWVAFYOkR4ABYEq7ZdFHfw8mgBMlksFbmBGDhCHAAsIAGIUgm515QZRD6A2Bu/AYOAJYgC6oALE0CHAAsQRZUAViaBDgAWIIGZWVOABaW38ABwBI0SAuqALBwBDgAWKIGZUEVABaOKZQAAAAdIcABAAB0hAAHAADQEQIcAABARwhwAAAAHSHAAQAAdIQABwAA0BGuAzdDX/rSl/Kdbz2WjPxAv1sB5uG5sRMZ/Yuv9LsN6JyT3xvPNx75y363ATP20kt/nZE9f9XvNuiAiy9elhtv/Il+tzFjRuAAAAA6wgjcDF133XXJ/pHkdav73QowD3986MGsetvV/W4DOuf73/xu3vnWK/rdBszY08/8YS667K39boMOeOml7/a7hVkxAgcAANARRuAAAGBAffGR5/OprzyX7xyfyJtWjuSjV78+H3jHRf1uiz4S4AAAYAB98ZHn80v3PZsXxluS5MjxifzSfc8myVCHuGEPtTMKcFV1XZJ/n2QkyW+01n7ljMer9/j7k3wvyT9qrf35TI4dFp/f97188qsncvjERN68YiQfe/eK3Hj5a4e6l0HpY5B6GZQ+BqmXQekDgOExKAHhU1957uXwNumF8ZZPfeW5vvQzCO+LUDuDAFdVI0k+neQnkxxK8lBV7Wyt7Z2y2/uSbOz9+dEkv57kR2d47JL3+X3fy8cfeC7f751oT56YyMcfeC5JFv2L6KD0Mih9DFIvg9LHIPUyKH0AMDwGKSB85/jErOrn06C8L4MWavthJouYXJnkQGvt8dbai0nuSXLDGfvckOQ/tlN2J/nBqlo3w2OXvE9+9cTLX0AnfX+85ZNfPTG0vQxKH4PUy6D0MUi9DEofAAyPcwWExfamlSOzqp9Pg/K+DFKo7ZeZBLj1SZ6Ysn2oV5vJPjM5NklSVTdX1Z6q2nPs2LEZtNUdh09Mf0KdrX4+DUovg9LHuV7TezLz+lLvA4DhMUgB4aNXvz7LR+u02vLRykevfv2i9zIo78sghdp+mUmAq2lqbYb7zOTYU8XW7m6tbW6tbV6zZs0M2uqON6+Y/oQ6W/18GpReBqWPc72m92Tm9aXeBwDDY5ACwgfecVE+8f5VWbdyJJVk3cqRfOL9q/oyVXBQ3pdBCrX9MpMAdyjJpVO2L0lyeIb7zOTYJe9j716R15xxor1mtPKxd68Y2l4GpY9B6mVQ+hikXgalDwCGx6AFhA+846Lcf+v6/MUvviX337q+b7/zGpT3ZZBCbb/MZBXKh5JsrKrLkjyZ5KYkP3PGPjuT3FpV9+TUIibPtdaOVNWxGRy75E0utjAIK+kNSi+D0scg9TIofQxSL4PSBwDDYzII9Hu1xUEzSO/LB95x0VD/71GtTTuj8fSdqt6f5Fdz6lIAn22t3VFVH0mS1tpdvcsI/FqS63LqMgL/uLW252zHvtrrbd68ue3Zs2dOf6Hzav+Xk9et7ncXwDz88aEHs+pt1/a7Deic73/zu3nnW6/odxswY08/84e56LK39rsNOuCll76biy/+iX638QpV9XBrbfOZ9RldB661dl+S+86o3TXlfktyy0yPBQAAYPZm8hs4AAAABoAABwAA0BECHAAAQEcIcAAAAB0hwAEAAHTEjC4jsNh614/7q373cZ6sTvJ0v5uAWXDO0jXOWbrGOUvXOGcXx1tba2vOLA5kgFvKqmrPdNdzgEHlnKVrnLN0jXOWrnHO9pcplAAAAB0hwAEAAHSEALf47u53AzBLzlm6xjlL1zhn6RrnbB/5DRwAAEBHGIEDAADoCAEOAACgIwS4RVJV11XVvqo6UFW39bsfeDVVdbCqvlFVX6uqPf3uB6ZTVZ+tqqeq6pEptTdU1Zeran/vdlU/e4RJZzlf/2VVPdn7rP1aVb2/nz3CVFV1aVXtqqrHqurRqvq5Xt3nbB8JcIugqkaSfDrJ+5JsSvKhqtrU365gRq5prV3hWi8MsN9Kct0ZtduSPNBa25jkgd42DILfyivP1yT5d73P2itaa/ctck9wLuNJ/llr7e8m2ZLklt53WJ+zfSTALY4rkxxorT3eWnsxyT1JbuhzTwCd11r7oyTfPaN8Q5Idvfs7kty4mD3B2ZzlfIWB1Vo70lr78979E0keS7I+Pmf7SoBbHOuTPDFl+1CvBoOsJfmDqnq4qm7udzMwC2tba0eSU18+kryxz/3Aq7m1qr7em2JpKhoDqao2JPnhJH8an7N9JcAtjpqm5voNDLr3tNZ+JKem/t5SVT/e74YAlqBfT/K2JFckOZLk3/a1G5hGVV2U5PeS/Hxr7Xi/+xl2AtziOJTk0inblyQ53KdeYEZaa4d7t08l+VxOTQWGLjhaVeuSpHf7VJ/7gbNqrR1trU201k4m+Q/xWcuAqaofyKnw9tuttd/vlX3O9pEAtzgeSrKxqi6rqguT3JRkZ597grOqqtdV1YrJ+0l+Kskj5z4KBsbOJFt797cm+UIfe4FzmvwS3PPT8VnLAKmqSvKbSR5rrW2f8pDP2T6q1szkWwy9ZYF/NclIks+21u7ob0dwdlX1d3Jq1C1JRpP8jnOWQVRVv5vk6iSrkxxN8okkn09yb5K3JPl2kg+21iwcQd+d5Xy9OqemT7YkB5P8k8nfFkG/VdWPJXkwyTeSnOyVfzGnfgfnc7ZPBDgAAICOMIUSAACgIwQ4AACAjhDgAAAAOkKAAwAA6AgBDgAAoCMEOAAAgI4Q4AAAADri/w8Yi5+6AUcsggAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "94ee2ecb-681f-401a-a85a-1809eaa94d5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/ocean/sallen/miniconda3/envs/py39/lib/python3.9/site-packages/pandas/util/_decorators.py:311: ParserWarning: Length of header or names does not match length of data. This leads to a loss of data with index_col=False.\n",
      "  return func(*args, **kwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000.  997.  997.  997.  997.] [10.90884959 11.51201162 12.07472766 12.59403188 13.05363181 13.27653032\n",
      " 13.47422211 21.70157157 20.98180083 19.96026126 19.64740224 18.92412208\n",
      " 18.38268647 68.74868102 53.49576728 48.7566156  43.85999603 39.63153813\n",
      " 14.24624194 15.26037688 15.86327084 16.43813513] [0.064      0.068      0.071      0.076      0.08       0.083\n",
      " 0.093      0.181      0.164      0.176      0.174      0.17\n",
      " 0.167      0.4        0.355      0.331      0.325      0.316\n",
      " 0.09428285 0.111334   0.12437312 0.1444333 ] [0.    0.    0.    0.    0.    0.    0.    0.05  0.051 0.047 0.047 0.039\n",
      " 0.038 0.168 0.15  0.134 0.129 0.123 0.    0.    0.    0.   ]\n"
     ]
    }
   ],
   "source": [
    "river = 'Nisqually_McKenna'\n",
    "\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4e1800ef-b1a0-4b3f-b06f-6215211e10c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "076b73e3-6b34-4dc2-ad59-48353170f060",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.] [2.07249534 2.13103322 2.12747523 2.14008328 2.15848607 2.20821392\n",
      " 2.23555232 3.319868   3.57237676 3.54462906 3.40274395 3.46971636\n",
      " 3.32873008 9.40829425 7.39520364 7.36567952 6.95959937 6.39187849\n",
      " 1.31083163 1.37861949 1.42212593 1.48225666] [0.065 0.066 0.068 0.075 0.082 0.081 0.084 0.148 0.158 0.146 0.154 0.158\n",
      " 0.157 0.314 0.304 0.284 0.267 0.258 0.044 0.048 0.055 0.056] [0.    0.    0.    0.    0.    0.    0.    0.032 0.026 0.028 0.031 0.031\n",
      " 0.028 0.13  0.109 0.102 0.109 0.1   0.004 0.004 0.003 0.003]\n"
     ]
    }
   ],
   "source": [
    "river = 'Greenwater_Greenwater'\n",
    "\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6a2ce98b-ce35-43d6-a933-e9788f1464cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ebb4afd0-e3b9-4f7f-a72b-bbf1d740ae0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.\n",
      " 1000. 1000. 1000. 1000. 1000. 1000.  750.  750.  750.  750.] [ 8.25916476  8.25690178  8.24456291  8.26424739  8.22232454  8.15059154\n",
      "  8.2218881  20.19041009 16.84403772 15.99217695 14.90738819 14.16480952\n",
      " 14.07375672 67.15366714 47.06208537 38.6312202  34.53079542 31.30520835\n",
      "  8.44125541 10.26682788 11.95777523 12.55534819] [0.224      0.234      0.24       0.241      0.246      0.258\n",
      " 0.259      0.52       0.499      0.497      0.489      0.467\n",
      " 0.474      0.654      0.644      0.639      0.623      0.627\n",
      " 0.12       0.13733333 0.14933333 0.156     ] [0.         0.         0.         0.         0.         0.\n",
      " 0.         0.195      0.171      0.147      0.157      0.138\n",
      " 0.142      0.297      0.306      0.286      0.275      0.261\n",
      " 0.00666667 0.01066667 0.01333333 0.01733333]\n"
     ]
    }
   ],
   "source": [
    "river = 'Clowhom_ClowhomLake'\n",
    "\n",
    "primary_river = read_river(river, 'primary')\n",
    "\n",
    "number_trys = 1000\n",
    "fittedbad = 0\n",
    "accumulateG, accumulateC, accumulateB = np.zeros(22), np.zeros(22),  np.zeros(22)\n",
    "\n",
    "for ii in range(number_trys):\n",
    "    accumulateG, accumulateC, accumulateB, fittedbad = doone(\n",
    "        primary_river, gap_length,accumulateG, accumulateC, accumulateB, fittedbad, 'fit', doplots=False)\n",
    "\n",
    "number_good = number_trys * np.ones(22)\n",
    "\n",
    "for ii in [18, 19, 20, 21]:\n",
    "    number_good[ii] = number_trys - fittedbad\n",
    "    \n",
    "print (number_good, accumulateG/number_good, accumulateC/number_good, accumulateB/number_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8ea043f5-17fc-4ec2-8c13-3ba85cb2c7d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(15, 15))\n",
    "axs[0].plot(np.abs(accumulateG)/number_good, 'o')\n",
    "axs[1].plot(np.abs(accumulateC)/number_good, 'o')\n",
    "axs[2].plot(np.abs(accumulateB)/number_good, 'o')\n",
    "\n",
    "for ax in axs:\n",
    "    ax.axvspan(-0.5, 6.5, color='tab:orange', alpha=0.2) \n",
    "    ax.axvspan(6.5, 12.5, color='tab:green', alpha=0.2) \n",
    "    ax.axvspan(12.5, 17.5, color='tab:pink', alpha=0.2)\n",
    "    ax.axvspan(17.5, 21.5, color='tab:olive', alpha=0.2)\n",
    "    \n",
    "axs[1].plot([-0.5, 21.5], [0.05, 0.05], c='grey')\n",
    "axs[2].plot([-0.5, 21.5], [0.01, 0.01], c='grey');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a75c10e0-c528-409f-a459-0adc86a0db3d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py39",
   "language": "python",
   "name": "py39"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}