docs/ODYM Example and Tutorial No. 3. Dynamic Stock modelling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ODYM Example no. 3.  Dynamic stock modelling.\n",
    "\n",
    "ODYM includes the Python class dynamic_stock_modelling for handling the inflow-driven and stock driven model of in-use stocks (http://www.teaching.industrialecology.uni-freiburg.de/  Methods section 3). Here it is shown how the dynamic stock model is used in the ODYM framework. Other methods of the dynamic_stock_modelling class can be used in a similar way.\n",
    "\n",
    "The research question is:\n",
    "+ \"How large are in-use stocks of steel in selected countries?\"\n",
    "+ \"What is the ration between steel in EoL (end-of-life) products to final steel consumption in selected countries?\"\n",
    "\n",
    "To answer that question the system definition is chosen as in the figure below. \n",
    "\n",
    "<img src=\"Images/SimpleProcess.png\" width=\"354\" height=\"290\" alt=\"Simple MFA system\">\n",
    "\n",
    "Stocks S and outflow O are calculated from apparent final consumption i(t), which is obtained from statistics, cf. DOI 10.1016/j.resconrec.2012.11.008 \n",
    "\n",
    "The model equations are as follows:\n",
    "\n",
    "First, we compute the outflow o_c(t,c) of each historic inflow/age-cohort i(c) in year t as\n",
    "\n",
    "$$o\\_c(t,c) = i(c) \\cdot sf(t,c) $$\n",
    "\n",
    "where sf is the survival function of the age cohort, which is 1-cdf (https://en.wikipedia.org/wiki/Survival_function).\n",
    "\n",
    "The total outflow o(t) in a given year is then\n",
    "\n",
    "$$ o(t) = \\sum_{c\\leq t} o\\_c(t,c)$$\n",
    "\n",
    "The mass balance leads to the stock change $dS$:\n",
    "\n",
    "$$ dS(t) = i(t) - o(t)$$\n",
    "\n",
    "And the stock finally is computed as\n",
    "\n",
    "$$ S(t) = \\sum_{t'\\leq t} ds(t') $$ \n",
    "\n",
    "\n",
    "### 1) Load ODYM\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load a local copy of the current ODYM branch:\n",
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import openpyxl\n",
    "import pylab\n",
    "\n",
    "# For Ipython Notebook only\n",
    "%matplotlib inline\n",
    "\n",
    "# Specify path to dynamic stock model and to datafile, relative\n",
    "MainPath = os.path.join('..', 'odym', 'modules')\n",
    "DataPath = os.path.join('..', 'docs', 'files')\n",
    "sys.path.insert(0, MainPath) # add ODYM module directory to system path\n",
    "\n",
    "# add ODYM module directory to system path, absolute\n",
    "sys.path.insert(0, os.path.join(os.getcwd(),'..', 'odym', 'modules')) \n",
    "sys.path.insert(0, os.path.join(os.getcwd(),'..', 'docs', 'files')) \n",
    "\n",
    "import ODYM_Classes as msc # import the ODYM class file\n",
    "import ODYM_Functions as msf # import the ODYM function file\n",
    "import dynamic_stock_model as dsm # import the dynamic stock model library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Define MFA system \n",
    "With the model imported, we cannow set up the system definition. The 'classical' elements of the system definition in MFA include: The processes, flows, and stocks, the material, the region, and the time frame studied. Next to these elements, ODYM features/requires the following elements to be specified:\n",
    "+ The list of chemical elements considered (Fe in this case)\n",
    "+ The classification(s) of the system variables (stocks and flows): Which materials, products, regions, or waste groups are considered? (Only the region dimension is used here.)\n",
    "+ An index letter to quickly/directly access a model aspect.\n",
    "+ A dictionary of model parameters.\n",
    "\n",
    "For all these items ODYM has a specific structure, which is used below.\n",
    "\n",
    "First, we define a classification of all objects flowing and accumulating in stocks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelClassification  = {} # Create dictionary of model classifications\n",
    "\n",
    "MyYears = list(np.arange(1900,2009)) # Data are present for years 1900-2008\n",
    "ModelClassification['Time'] = msc.Classification(Name = 'Time', Dimension = 'Time', ID = 1,\n",
    "                                                 Items = MyYears)\n",
    "ModelClassification['Cohort'] = msc.Classification(Name = 'Age-cohort', Dimension = 'Time', ID = 2,\n",
    "                                                   Items = MyYears)\n",
    "# Classification for time labelled 'Time' must always be present, with Items containing a list of odered integers representing years, months, or other discrete time intervals\n",
    "# Classification for cohort is used to track age-cohorts in the stock.\n",
    "\n",
    "ModelClassification['Element'] = msc.Classification(Name = 'Elements', Dimension = 'Element', \n",
    "                                                    ID = 3, Items = ['Fe'])\n",
    "# Classification for elements labelled 'Element' must always be present, with Items containing a list of the symbols of the elements covered.\n",
    "\n",
    "MyRegions = ['Argentina', 'Brazil', 'Canada',\n",
    "             'Denmark', 'Ethiopia', 'France',\n",
    "             'Greece', 'Hungary', 'Indonesia']\n",
    "ModelClassification['Region'] = msc.Classification(Name = 'Regions', Dimension = 'Region', ID = 4,\n",
    "                                                   Items = MyRegions)\n",
    "# Classification for regions is chosen to include the regions that are in the scope of this analysis.\n",
    "\n",
    "# Get model time start, end, and duration:\n",
    "Model_Time_Start = int(min(ModelClassification['Time'].Items))\n",
    "Model_Time_End   = int(max(ModelClassification['Time'].Items))\n",
    "Model_Duration   = Model_Time_End - Model_Time_Start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That dictionary of classifications enteres the index table defined for the system. The indext table lists all aspects needed and assigns a classification and index letter to each aspect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Description</th>\n",
       "      <th>Dimension</th>\n",
       "      <th>Classification</th>\n",
       "      <th>IndexLetter</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aspect</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Time</th>\n",
       "      <td>Model aspect \"time\"</td>\n",
       "      <td>Time</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>t</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Age-cohort</th>\n",
       "      <td>Model aspect \"age-cohort\"</td>\n",
       "      <td>Time</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>c</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Element</th>\n",
       "      <td>Model aspect \"Element\"</td>\n",
       "      <td>Element</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Region</th>\n",
       "      <td>Model aspect \"Region where flow occurs\"</td>\n",
       "      <td>Region</td>\n",
       "      <td>&lt;ODYM_Classes.Classification object at 0x00000...</td>\n",
       "      <td>r</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                        Description Dimension  \\\n",
       "Aspect                                                          \n",
       "Time                            Model aspect \"time\"      Time   \n",
       "Age-cohort                Model aspect \"age-cohort\"      Time   \n",
       "Element                      Model aspect \"Element\"   Element   \n",
       "Region      Model aspect \"Region where flow occurs\"    Region   \n",
       "\n",
       "                                               Classification IndexLetter  \n",
       "Aspect                                                                     \n",
       "Time        <ODYM_Classes.Classification object at 0x00000...           t  \n",
       "Age-cohort  <ODYM_Classes.Classification object at 0x00000...           c  \n",
       "Element     <ODYM_Classes.Classification object at 0x00000...           e  \n",
       "Region      <ODYM_Classes.Classification object at 0x00000...           r  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IndexTable = pd.DataFrame({'Aspect'        : ['Time','Age-cohort','Element','Region'], # 'Time' and 'Element' must be present!\n",
    "                           'Description'   : ['Model aspect \"time\"','Model aspect \"age-cohort\"', 'Model aspect \"Element\"','Model aspect \"Region where flow occurs\"'],\n",
    "                           'Dimension'     : ['Time','Time','Element','Region'], # 'Time' and 'Element' are also dimensions\n",
    "                           'Classification': [ModelClassification[Aspect] for Aspect in ['Time','Cohort','Element','Region']],\n",
    "                           'IndexLetter'   : ['t','c','e','r']}) # Unique one letter (upper or lower case) indices to be used later for calculations.\n",
    "\n",
    "IndexTable.set_index('Aspect', inplace = True) # Default indexing of IndexTable, other indices are produced on the fly\n",
    "\n",
    "IndexTable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now define our MFA system: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "Dyn_MFA_System = msc.MFAsystem(Name = 'StockAccumulationSystem', \n",
    "                      Geogr_Scope = '9SelectedRegions', \n",
    "                      Unit = 'kt', \n",
    "                      ProcessList = [], \n",
    "                      FlowDict = {}, \n",
    "                      StockDict = {},\n",
    "                      ParameterDict = {}, \n",
    "                      Time_Start = Model_Time_Start, \n",
    "                      Time_End = Model_Time_End, \n",
    "                      IndexTable = IndexTable, \n",
    "                      Elements = IndexTable.loc['Element'].Classification.Items) # Initialize MFA system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This system has a name, a geographical scope, a system-wide unit, a time frame, an index table with all aspects defined, and a list of chemical elements considered.\n",
    "\n",
    "### 3) Reading data from Excel and formatting data\n",
    "In this example the required inflow is obtained from the steel cycle database available at http://www.database.industrialecology.uni-freiburg.de/\n",
    "\n",
    "The steel cycle dataset is selected in the table of contents and then in the download frame for flows the following countries are selected and data are exported to .csv.\n",
    "\n",
    "<img src=\"Images/Steel_Consumption_Final_9Countries.png\" width=\"554\" height=\"290\" alt=\"Database screenshot\">\n",
    "\n",
    "The .csv file provided by the database is then read by Excel and stored as .xlsx for better readability. The average lifetime for steel is obtained directly from the SI of the orginal publication and stored in a separate .xlsx file. A copy of both files is provided on the GitHub repo and parsed as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[45, 25, 35, 55, 70, 45, 70, 30, 30]\n"
     ]
    }
   ],
   "source": [
    "LifetimeFile  = openpyxl.load_workbook(os.path.join(DataPath, 'Steel_Lifetime_9Countries.xlsx'), data_only=True)\n",
    "Datasheet = LifetimeFile['Average_Lifetime']\n",
    "\n",
    "Lifetimes = []\n",
    "\n",
    "for m in range(1,10):\n",
    "    Lifetimes.append(Datasheet.cell(m+1,2).value) # Add lifetime values to list\n",
    "print(Lifetimes)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the inflow array, we also need to assign the flow values to the right countries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9, 109)\n"
     ]
    }
   ],
   "source": [
    "InflowFile  = openpyxl.load_workbook(os.path.join(DataPath, 'Steel_Consumption_Final_9Countries.xlsx'), data_only=True)\n",
    "Datasheet   = InflowFile['FinalSteelConsumption']\n",
    "\n",
    "InflowArray = np.zeros((len(MyRegions),len(MyYears))) # OriginRegion x Year\n",
    "print(InflowArray.shape)\n",
    "\n",
    "for m in range(1,982):\n",
    "    OriginCountryPosition      = MyRegions.index(Datasheet.cell(m+1,8).value)\n",
    "    YearPosition               = MyYears.index(int(Datasheet.cell(m+1,11).value))\n",
    "    InflowArray[OriginCountryPosition,YearPosition] = Datasheet.cell(m+1,14).value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 4) Inserting data into the MFA system\n",
    "\n",
    "It is lacking a list of processes, stocks, flows, and parameters, and these are now defined and inserted into the system:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<ODYM_Classes.Process at 0x20f39551610>,\n",
       " <ODYM_Classes.Process at 0x20f395515b0>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Dyn_MFA_System.ProcessList = [] # Start with empty process list, only process numbers (IDs) and names are needed.\n",
    "Dyn_MFA_System.ProcessList.append(msc.Process(Name = 'Other_industries' , ID   = 0))\n",
    "Dyn_MFA_System.ProcessList.append(msc.Process(Name = 'Use phase'        , ID   = 1))\n",
    "\n",
    "# Print list of processes:\n",
    "Dyn_MFA_System.ProcessList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we define the parameter values for the inflow and yield parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "ParameterDict = {}\n",
    "\n",
    "#\n",
    "ParameterDict['Inflow']= msc.Parameter(Name = 'Final steel consumption', ID = 1, P_Res = 1,\n",
    "                                       MetaData = None, Indices = 'r,t', \n",
    "                                       Values = InflowArray, Unit = 'kt/yr')\n",
    "\n",
    "#\n",
    "ParameterDict['tau']   = msc.Parameter(Name = 'mean product lifetime', ID = 2, P_Res = 1, \n",
    "                                       MetaData = None, Indices = 'r', \n",
    "                                       Values = Lifetimes, Unit = 'yr')\n",
    "ParameterDict['sigma'] = msc.Parameter(Name = 'stddev of mean product lifetime', ID = 3, P_Res = 1,\n",
    "                                       MetaData = None, Indices = 'r', \n",
    "                                       Values = [0.3 * i for i in Lifetimes], Unit = 'yr')\n",
    "\n",
    "# Assign parameter dictionary to MFA system:\n",
    "Dyn_MFA_System.ParameterDict = ParameterDict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The flows, stocks changes, and stocks are as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the flows of the system, and initialise their values:\n",
    "Dyn_MFA_System.FlowDict['F_0_1'] = msc.Flow(Name = 'final consumption', P_Start = 0, P_End = 1,\n",
    "                                            Indices = 't,r,e', Values=None)\n",
    "Dyn_MFA_System.FlowDict['F_1_0'] = msc.Flow(Name = 'Eol products', P_Start = 1, P_End = 0,\n",
    "                                            Indices = 't,c,r,e', Values=None)\n",
    "Dyn_MFA_System.StockDict['S_1']   = msc.Stock(Name = 'steel stock', P_Res = 1, Type = 0,\n",
    "                                              Indices = 't,c,r,e', Values=None)\n",
    "Dyn_MFA_System.StockDict['dS_1']  = msc.Stock(Name = 'steel stock change', P_Res = 1, Type = 1,\n",
    "                                              Indices = 't,r,e', Values=None)\n",
    "\n",
    "Dyn_MFA_System.Initialize_FlowValues() # Assign empty arrays to flows according to dimensions.\n",
    "Dyn_MFA_System.Initialize_StockValues() # Assign empty arrays to flows according to dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True, True)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check whether flow value arrays match their indices, etc. See method documentation.\n",
    "Dyn_MFA_System.Consistency_Check() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5) Programming a solution of the MFA system\n",
    "Now the system definition is complete, and we can program the model solution, making use of the dynamic_stock_model methods (see also https://github.com/stefanpauliuk/dynamic_stock_model)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit model parameter 'Inflow' to right shape in FlowDict:\n",
    "Dyn_MFA_System.FlowDict['F_0_1'].Values[:,:,0] = Dyn_MFA_System.ParameterDict['Inflow'].Values.transpose()\n",
    "\n",
    "# Loop over all regions to determine inflow-driven stock:\n",
    "for region in np.arange(0,len(MyRegions)): # from the first region (index 0) to the last region (Python does not use the last index on the right side of an interval)\n",
    "    # Create helper DSM for computing the dynamic stock model:\n",
    "    DSM_Inflow = dsm.DynamicStockModel(t = np.array(MyYears),\n",
    "                                       i = Dyn_MFA_System.ParameterDict['Inflow'].Values[region,:], \n",
    "                                       lt = {'Type': 'Normal', 'Mean': [Dyn_MFA_System.ParameterDict['tau'].Values[region]],\n",
    "                                             'StdDev': [Dyn_MFA_System.ParameterDict['sigma'].Values[region]]})\n",
    "    Stock_by_cohort = DSM_Inflow.compute_s_c_inflow_driven()\n",
    "    O_C = DSM_Inflow.compute_o_c_from_s_c()\n",
    "    S = DSM_Inflow.compute_stock_total()\n",
    "    DS = DSM_Inflow.compute_stock_change()\n",
    "    Dyn_MFA_System.FlowDict['F_1_0'].Values[:,:,region,0] = O_C\n",
    "    Dyn_MFA_System.StockDict['dS_1'].Values[:,region,0] = DS\n",
    "    Dyn_MFA_System.StockDict[ 'S_1'].Values[:,:,region,0] = Stock_by_cohort"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6) Mass-balance-check\n",
    "One major advantage of the ODYM system structure is that mass balance checks can be performed automatically using unit-tested routines without further programming need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(109, 2, 1)\n",
      "[[3.57113095e-09]\n",
      " [3.57113095e-09]]\n"
     ]
    }
   ],
   "source": [
    "Bal = Dyn_MFA_System.MassBalance()\n",
    "print(Bal.shape) # dimensions of balance are: time step x process x chemical element\n",
    "print(np.abs(Bal).sum(axis = 0)) # reports the sum of all absolute balancing errors by process."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ODYM mass balance array reports the balance for each chemical element, each year, and each process, including the system balance (process 0).\n",
    "\n",
    "It shows that both the system and the use phase are balanced."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7) Research questions\n",
    "We now address the research questions. First, we plot the steel stock in the different countries over time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20f399f7490>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.set_loglevel(\"info\") \n",
    "MyColorCycle = pylab.cm.Paired(np.arange(0,1,0.1)) # select 10 colors from the 'Paired' color map.\n",
    "fig, ax = plt.subplots()\n",
    "for m in range(0,len(MyRegions)):\n",
    "    ax.plot(Dyn_MFA_System.IndexTable['Classification']['Time'].Items, \n",
    "            Dyn_MFA_System.StockDict['S_1'].Values[:,:,m,0].sum(axis =1)/1000, \n",
    "            color = MyColorCycle[m,:])\n",
    "ax.set_ylabel('In-use stocks of steel, Mt.',fontsize =16)\n",
    "ax.legend(MyRegions, loc='upper left',prop={'size':10})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then plot the ratio of outflow over inflow, which is a measure of the stationarity of a stock, and can be interpreted as one indicator for a 'circular economy'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-14-25ec9b7ca822>:3: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  FlowRatio = Dyn_MFA_System.FlowDict['F_1_0'].Values[:,:,:,0].sum(axis =1) \\\n",
      "<ipython-input-14-25ec9b7ca822>:3: RuntimeWarning: invalid value encountered in true_divide\n",
      "  FlowRatio = Dyn_MFA_System.FlowDict['F_1_0'].Values[:,:,:,0].sum(axis =1) \\\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20f3a19e100>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAD+CAYAAAAkukJzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACADUlEQVR4nOydd5xcZdmwr/tM3957sum9J0BCSaWE0ER4EQQiqGBDxRcbigiIvXzgq6KISi8KKhCBICV0EhII6T2bZHvf2d3pc57vjzM72zeTZLbmXL/fZGdOfZ7JnHOfu4tSChMTExMTk97QBnsAJiYmJiZDG1NQmJiYmJj0iSkoTExMTEz6xBQUJiYmJiZ9YgoKExMTE5M+MQWFiYmJiUmfmILCxMTExKRPTEFhYmJiYtInJywoRGSUiIyOx2BMTExMTIYecqKZ2SISjBzHGp8hmZiYmJgMJeJxc/8RIHE4jomJiYnJEOSENYqhRlZWlhozZsxgD8PExMRkWLFp06ZapVR2T+tGnLlozJgxbNy4cbCHYWJiYjKsEJFDva2LhzN7tIisPtHjmJiYmJgMTeIRHnsK8Lc4HMfExMTEZAgy4kxPXQkGg5SWluLz+QZ7KEOC/Px80tLSBnsYJiYmw4heBYWIvBbjMXp0fgwVSktLSU5OZsyYMYic3MFZXq+XsrIyU1CYmJgcE32ZnpYA4wDbUV6Wfh7jCeHz+cjMzDzphQSA0+kkGAwO9jBMTEyGGX2ZnvYB7ymlruvrACJyOfBUPAcVb0whYWB+DyYmJsdDXxrFRmBBDMdQmAl3USZMmMCTTz4Z12Nu3ryZDz/8MPr+L3/5S1yPb2JiYtIXfQmKJ4D3YzjGB8D18RnO8Objjz/mrLPO4vnnn++0XNf1EzpuR0ExZ84cPve5z53Q8UY69eVuQoHQYA/DxGTE0KugUEqtUUp9/mgHUEodVko9FN9hDU/++c9/8uUvfxmPx4Pf72fp0qV8+9vfZvXq1ezfv5/TTjuNSy65hBUrVlBSUoLX6+Wqq65i+fLlfOpTnyIYDPLggw9y1VVXsWrVKlatWoVSivvvv59f/vKXXH311axbt47bbrsNgNmzZ7N69Wpmz57N5s2bAbjiiitYsmQJ5557Lm63exC/jcEhFAizf1MZdWUn39xNTPqLER8e25FNpY00egMndIw0l535RWk9rvvwww+58847WblyJa+88goAl156KYsWLeJLX/oS9957L6eccgpz5swB4IEHHuDiiy/mqquu4r777uPpp58GICcnhyeeeIIbbriBLVu2cOONNxIKhfj85z/PunXrouerrKxk/fr1bNq0iYceeog5c+bw4IMPkpCQwAMPPMBTTz3FDTfccELzHW4o3ShJo4dHVmkaE5PB5KQSFP3J/v372bZtGytXrsTv9zNp0iQA5s+fD8DBgweZNWsWFouFGTNmALBz5042bdrEn/70J3w+H1dddRWpqanR9YWFhTQ2NvZ6zgkTJuB0OqPbhcNhvvWtb7F161bcbjeXXnpp/056CNJWu2yk1TAzMRlMTipB0ZsmEA+eeeYZHnjgAVasWAHAxRdfTDgcRtMM697YsWPZunUrCxYsYPv27QBMnjyZFStWcNlllwFGcuBjjz3WKTpJKYXNZsPv93c7Z9ftNm/eTGtrK2+++SZ//vOfKSsr67f5DlWigkI3BYWJSbwY0A53IuIUkQ0i8rGIbBeROyPLM0TkvyKyN/I3vcM+t4rIPhHZLSLnDeR4j4X//Oc/nH766dHP06ZN4+23345+/uY3v8nXv/51Lr30UtLT07HZbNx4443861//YsWKFSxfvjzqsO7KwoULefTRR/nqV7/a5xgmT57Mvn37WLlyJRs2bIjPxIYZKhI3YGoUJibxY0DLjIvxCJyolGoRERvwNvB14JNAvVLqZyLyXSBdKfUdEZmGEX11KlAAvAJMUkqFezvHggULVMfqsTt37mTq1Kn9N6kYCYVCWK1WwuEwZ5xxBm+//TZW68ArdEPl++gvvM1+tq07QN74TEZNyxns4ZiYDBtEZJNSqseUiAHVKJRBS+RjW2a3Ai4B2iKnHgI+EXl/CfCkUsqvlDqIkQR46sCNOH4cOHCAxYsXc+qpp7J69epBERInA6aPwsQk/gz43UpELMAmYALwe6XUehHJVUpVACilKkSk7VGwkM65HKWRZcOOSZMm8eabbw72MEY8bb4J00dhYhI/YtYoROSvInJ/D8v/LCIxpworpcJKqTlAEXCqiMzo67Q9HaKHMdwoIhtFZGNNTU2sQzEZgbQpEqagMDGJH8dierou8urK9b0s7xOlVCOwDlgJVIlIPkDkb3Vks1JgVIfdioDyHo51v1JqgVJqQXb2kC5ma9LPmKYnE5P4E7OgUEppSil7D8utSqmYKsiKSLaIpEXeu4CzgV3Ac8BnIpt9Bng28v454EoRcYjIWGAicHKG85jEhGl6MjGJPwPqzAbygddFZAtGjaj/KqXWAD8DzhGRvcA5kc8opbYDfwd2AC8BX+kr4mmwWbduHcXFxSxdupQzzjiDnTt3HvMxKisr+fGPfwzAmWeeGe8hjnzaTE+mnDAxiRsxCQoReU1EpvSyblKsTY6UUluUUnOVUrOUUjOUUndFltcppVYopSZG/tZ32OfHSqnxSqnJSqkXYznPYHLttdeybt06fvnLX/LHP/4xujzWwoB5eXl8//vf76/hjXjMhDsTk/gTq0axFEjpZV0yRpMjkw643W5SUlI6FQbcvHkzS5YsYeHChfzkJz8B4K677mLp0qWceuqp0WKB11xzzSCPfvjSJih0U6UwMYkbxxIe29uVNx5o6WXdkOLO57ezo+LEqopOy0/hhxdN73X9I488wptvvsnevXt5+eWXeeutt6KFAb1eL+vWrUNEWLZsGd/4xje4/fbbuf3221m9erVZPjwORDOzTY3CxCRu9NUz+3ra+0wo4H4Rae6ymQuYAbzaP8Mbflx77bXcfffdVFVV8fnPG1XaOxYGvOWWW/B4POzevZvq6mqKi4v5zW9+w9y5c1myZAklJSWDOPrhjxn1ZGISf/rSKHSgzXEsXT63UQfcB/w8/kOLP31pAvEmOTkZt9uNiEQLA95333185zvfYenSpZx55pkopXjjjTfYvHkzDz/88ICNbSRj+ihMTOJPr4Ii0ozoIQAReR34klJq10ANbLjyyCOP8Pbbb+Pz+bjtttv41a9+FV13wQUXcNNNNzFt2jTsdiPS+K677qK5uZmlS5cyZ84cbr755kEa+cigvSjg4I7DxGQkMaBFAQeCoVoUcKgw0r+PmsONlHxcQUKqk+mLxw72cExMhg19FQXsy0exGviPUqou8r5PlFKm7cRk0DFNTyYm8acvH8WDwEIMP8SDRzmOAkxBYTL4mM5sE5O405egGAtUdHhvYjLkMcNjTUziT1/O7EM9vTcxGcqY4bEmJvFnoGs9mZj0K+0+ikEeiInJCCLWWk92EfmhiOwSEY+IhLu8Qv090OHAq6++ypIlS1i8eDGXXnopdXV1cTnu0qVL43KckwHT9GRiEn9iLeHxS+ArwIvAPwF/v41omFJbW8tdd93FmjVrSE5OZs+ePQQCgcEe1kmHaXoyMYk/sZqeLgd+qJS6SCn1PaXUnV1f/TnI4cB//vMfrr32WpKTkwGj9elLL73E0qVLWbBgAS+//DIA1113HV//+tc588wzufNO42v729/+1m27Dz74gHnz5vHpT38at9uoT/XSSy+xZMkSFixYYGZy94IZHmtiEn9i1SiSgPf6cyADwba613AHqo++YR+k2HOYkbm82/KKigpmzpzZadmnPvUprr/+epqamvif//kfzj33XMAwJd17772cdtpp/PCHP+xxu7vuuot///vfZGRkUFxcDMDixYtZuXIloVCIpUuXsnr1UdNbTjqirVBNjcLEJG7EKiieBxYDMfWdOBnJz8+nvLxzl9a1a9dy7733opSiurpdQM2YYbQJd7lcvW7X2NjI6NGjAUM7Adi0aRN33nknwWCQ7du39/uchiPRDnfKEBYiPbVdNzExORZiFRT/BzwsIjrwAlDfdQOl1IF4Dqw/6EkTiBerVq3i8ssv58orryQ5OZl9+/bx7W9/my1btuD3+znjjDOi23a9ef30pz/ljTfe6LRdamoqpaWlpKens3fvXgB+8Ytf8MADD1BYWMjEiRP7bS7DmY6ahFJgygkTkxMnVkHRZna6A/hhL9vE1Dd7pJKdnc0PfvADLrzwQpRSZGRkcM0117B48WJOPfVU0tLSet33wgsv7LbdD37wAy6++GImTZoU1SwuvfRSLrnkEubMmUN6evoAzGoY0sHipHQFmikpTExOlJiKAorIdfTeuAiIVpsddMyigH0z0r+Pko8rqDncCMDclZOw2k7q5xcTk5g5rqKAHVFKPRjXEZmY9BOdTE9m5JOJSVwwM7NNRhQdFWQz8snEJD7EpFGIyF+PsolSSpkNn00Gnc4axSAOxMRkBBGrM3s53X0UGUAy0Bh5mZgMOh3NTabpycQkPsRkelJKjVFKje3ySgWWApXAZbEcR0RGicjrIrJTRLaLyNcjy+8QkTIR2Rx5reqwz60isk9EdovIecc+RZOTic7hsaagMDGJByfko1BKvQn8P4w8i1gIAbcopaZiNEX6iohMi6z7f0qpOZHXCwCRdVcC04GVwB9EZMiGsaxbt47i4mJWrFjB0qVLeeKJJwb0/EuXLiUUOrnrM6qu4bEmJiYnTDyc2QeAubFsqJSqUEp9GHnfDOwECvvY5RLgSaWUXyl1ENgHnHqC4+1Xrr32Wl599VVefPFFHnvsMT788MMBOa+umwZ5AHRTozAxiTex+ih6RESswHVA6XHsOwZDwKwHzgBuivTm3oihdTRgCJH3O+xWSt+CZcjgcrm45ZZbeP7551mzZg2vvfYamqbx178acQGf/exnycjI4ODBgzz77LOEQiE++9nPkpWVxd69e/nBD37AH//4RzweD2vXrsVut7Ny5UqCwSDZ2dn8/e9/58iRI1x//fVkZmayalXUWsfjjz/O+vXruffeewdr+oOGGR5rYhJ/Yo166qnGkx2YBGQCXzyWk4pIEvAMcLNSyi0i9wE/wnCY/wj4NfBZoKe02m5Xv4jcCNwIRLOYe+LXG37O7vpdxzLUbkzOmMItp34npm0LCgpYt24dkyZNYt26dezcuZOf/vSn3HrrrTQ0NPDKK6/wxBNP8Mwzz3DJJZdElz355JM89NBDvPzyy/zkJz9h7dq1XHrppaxZswaXy8Vtt93Ga6+9xsSJE6muruaVV17BYrHw8MMP8+STT7JhwwZ++9vfntA8hysdlQjdFBQmJnEhVo1Co/sNuhmjN8WTSql1sZ5QRGwYQuIxpdQ/AZRSVR3W/xlYE/lYCozqsHsR0LnynrH//cD9YGRmxzqW/qasrIxly5bx2GOPRZsP5efnAzBt2jQ0TaOwsJB9+/Z1WlZQUBAtHFhQUEBDQwOtra3ceOONlJWVUVVVxcSJE5k4cSKzZ8/GYml32/z0pz/l7bffHtiJDiGUrhBNULrCtDyZmMSHWDOzl8bjZGJUw/sLsFMp9ZsOy/OVUhWRj5cC2yLvnwMeF5HfAAXARGDD8Z4/Vk0gHvh8Pu655x5uueUWampq+L//M/z9wWCQsrKyToUB28wlHZd1Xb927VomTZrE448/zve///3oPprW2c300EMPcc011/D0009Hq9OeTCil0DQhrCvT9GRiEicGOjP7DOBaYHmXUNhfiMhWEdkCLAO+AaCU2g78HdgBvAR8RSkVHuAxHxOPPPIIK1asYOXKlVx55ZUsWbKEvLw8li5dyrJly/jb3/52XMc97bTTeO6557jwwgspKSnpdbs5c+bwrW99i9WrV5+UEVBKgWbRIu9NQWFiEg9iKgo4nDCLAvbNSP8+tr1xAD2k4/cEGT+/kIyClMEekonJsKCvooBmrSeTEYXSlalRmJjEGVNQmIwoDNOT4d8xfRQmJvHBFBQmIwvVUaMY5LGYmIwQTEFhMqLQdSPqCUyNwsQkXpywoBCR0SJiegxNhgZKIaaPwsQkrsRDoygBKkXk/0SkKA7HG7a0FQVcunQpS5cu5be//S2vvWYktZeUlHDNNdd02r6yspIf//jHx3SOm2++mXB4SEcIDyqmj8LEJP7EQ1DcBfwOmIdR5O+k5tprr2XdunWsW7eOWbNmRQVFT+Tl5fH973//mI5/zz33dMrENumMUgqLqVGYmMSVExYUSqk7lFLfVkqdAeTEYUwjhvvvvz+agAdQXl7O5Zdfzvz58yktLe2kZTz66KMsXLiQM844g48//hiAhQsXcuONN7JgwQLWrDGqmrSVEn/ppZdYsmQJCxYs4OGHHx6cCQ5BlK4QU6MwMYkrJ1Q9titKKW88jxdvwu+9i6qrO6FjSGYmlkWn97r+kUceidZaWrVqFePGjePuu++mpKSkx0KAAOFwmN/+9re88847lJWVcdNNN7FmzRpqamq47bbbyMzM5Nxzz+XCCy+Mnmfx4sWsXLmSUCjE0qVLWb169QnNa6SgVHtZE7MVqolJfIhJoxCR90XkJyJyroicfAWEjoGOpqdTT+3cOqNjIcDGxsbo8pqaGoqLi7HZbIwZM4ampiYAMjMzGT16NImJid3MTZs2beLss89mxYoVbN++vd/nNVxQSiEaiIBump5MTOJCrBrFfuAzwHeBgIh8ALwOvAa8p5Ty99P44kpfmkB/YLPZOjmeeyoECJCdnU1JSUm0YGBqaioA9fX1lJaWkpGR0c2B/Ytf/IIHHniAwsJCJk6c2M8zGR4opUAZ33NbBVkTE5MTJ9bqsVcDiMgUYDlGr+wvAt8H/CLynlJqRX8NcjjR0fR0/fXX88477/CpT32Kn//8573uY7FYuOmmmzjrrLPQNI3f//73AGRlZXHHHXewefNmbr/99k77XHrppVxyySXMmTOH9PT0/pvQMKJN9kYFhalRmJjEheMqChhpPLQU+DqwAlBKqSERijOSigKeeeaZce8tMZy/j6Ohh3U2vbCboqnZVO6vJz0/mTGz8gd7WCYmw4K+igLG2uHOCZyJUQJ8OTAfaAXeBr6JYYIyMRlU2kxNpkZhYhJfYvVRNGB0uHsLeBa4GfhAKTOupD85mTvVHQ9RuSCCiJhRTyYmcSLWPIoWwAHkYuRK5ACJ/TUoE5Pjob3rH4hmJtyZmMSLWJ3Z2SIyi3bT0/VAkoh8SCT6SSn1cv8N08Tk6ESjnKIahSkoTEziQcyZ2UqpLUqpe5VSlwCZGE5sN/Bt4MV+Gp+JScx0i3oyBYWJSVyIOTNbRGzAQgyNYhlwGoY5qhpY1x+DG26sW7eOz3zmM4wdOxaAZ599NpoTYdL/tJmaRAxhYZqeTEziQ6xRT/8FFgEJQD3wBvAt4HWllJkW3IFrr72Wu+++u9MyXdejZSVM+o+ooNDaNIpBHpCJyQgh1ruXD/gBRoXYbKXUZUqp35lConcefPBBPvWpT3HBBRewZcsWrrjiCpYsWcK5556L2+0GYPbs2axevZrZs2ezefNmAO677z4WLlzIsmXL2L17NzU1NVx88cUsW7aML3/5y4M4o6FPx/BYzdQoTEziRqzO7Iv6eyADgb73n9BSdmIHSSpEm/jJXle3ZWa/8cYb3HjjjTz11FOAITgSEhJ44IEHeOqpp7jhhhuorKxk/fr1bNq0iYceeoiCggL+8Y9/8M4772CxWNB1nW9961vceuutLFq0iO985zu89957LFq06MTmMFJp92UjGuhhU1CYmMSDY6oeKyIXAkuADKAOWKeUeqE/BjZcaTM9PfjggwQCAcCoDvutb32LrVu34na7ufTSSwGYMGECTqczWiTw4MGDzJs3L1oAUNM0du7cyXe/+11EhJaWlm6FBk3a6WZ6Cpm2JxOTeBCrjyIZWAOcBYQwhEQmcIuIvAVcqJRqieE4o4CHgTxAB+5XSt0rIhnAU8AYjI55VyilGiL73Ap8DggDX1NKrT2WCXakL02gP2jzS2zevJnW1lbefPNN/vznP1NWZmg1XYsEjhs3jo8++ijq09B1ncmTJ3PNNdcwf/58AEKh0IDOYTjRKTNbBN2MejIxiQux+ih+guGfuBZwKaXyARewOrL8JzEeJwTcopSaihFB9RURmYZRlfZVpdRE4NXIZyLrrgSmAyuBP4jIkKgpdSxMnjyZffv2sXLlSjZs2NDrdtnZ2Vx22WWcfvrpLFu2jL179/K9732Pu+++m+XLl3P22Wdz5MiRARz58KJTZrYZHmtiEjdiKgooIuXAz5VS9/aw7uvAt5VShcd8cpFnMdqo/g5YqpSqEJF8DJPW5Ig2gVLqp5Ht1wJ3KKXe6+2YI6koYH8wkr8Pd20ru987zORFo6k51Ehrk49Zy8cP9rBMTIYFfRUFjFWjyAR29LJuR2T9sQ5qDDAXWA/kKqUqACJ/21qqFgIdH6FLI8u6HutGEdkoIhtramqOdSgmI4So6UkzNQoTk3gSq6A4CFzYy7pVkfUxEylT/gxws1LK3demPSzrdvUrpe5XSi1QSi3Izs4+lqGYjCA6ZWaLWevJxCRexBr19Cfg15Eb/GNABYZD+krg88D/xnrCSIb3M8BjSql/RhZXiUh+B9NTdWR5KTCqw+5FQHms5zI5ueiUmW1qFCYmcSPWPIr/JyLZwDeA6yKLBfADP+vJd9ETYoT5/AXYqZT6TYdVz2G0Wv1Z5O+zHZY/LiK/AQqAiUDv3mCTk5pupidToxhxNFY1Y3PaSEx1DvZQTipizqNQSn1PRH6JEa2UgVHK4/22MNYYOQMjcmqriGyOLPsehoD4u4h8DjgM/E/knNtF5O8YfpAQ8BWlVLjbUU1M6Gp6MjWKkcihrVUkpbsYP/+YY2dMToBjSriLCIXjrhSrlHqbnv0OYFSj7WmfHwM/Pt5zDiRvvPEGd955J7quY7FY+NGPfsTpp58+2MM6eehqejLlxIhDD+mEAmYu0UDTq6AQkcXHciCl1JsnPpzhS21tLT/84Q957rnnSElJobm5mX379kXXm4UB+59OmdmCqVGMQMJhnVDANCoMNH1pFOtojzASeog26rJu2CXCxZMXXniBa665hpSUFACSk5OZO3cus2fPZubMmcyYMYNly5bxne98h2AwyOc//3muv/561q9f323ZO++8w7e//W3sdjtf/OIXueKKK/jyl7/M7t27cblcPProo6Snpw/yjIcenRoXaYbiqpTqlAFvMnxRSqF0RShoCoqBpi9BsWzARjFQvHgzVG4+sWPkzYHz7+m2uLy8nJkzZwLw+OOP84c//IGFCxdSWlrKu+++S2JiIueddx7PPfccycnJnHPOOVx99dXcfvvt3ZZ997vf5dlnnyUrKwtd11mzZg2jR4/mvvvu48UXX+SPf/wjt95664nNYwTS7qMALSIclK4QiykoRgJ62KjdFQqYNbwGmr4ExSXA/1NKHYmYoT6MpZ7TyUp+fj7l5Ubk7qc//WlOP/107rjjDiZPnkxiotFe/OOPP+biiy8GDFNVTU1Nj8sAsrKygPbCgE8++SRr164lFAqZ1WN7oT08toNGoauTXNcdOegh4/9XD+voukLTzAeAgaIvQfF14AmMzOjXMRoXDe/Q1B40gXixatUqLr/8cq644gpSU1Ojxfs6+iXmzp3L008/TWJiIsFgEJvN1uMyEaGuro7MzMxoYcDVq1dzyy23ABAMBvttHsOZTuGx0m56MhkZhMPtmkQ4EEZzHlMsjskJ0Jd3tRaYFHnfl4/CBKOg3w9/+EMuueQSli9fzpe//GVWr17daZs777wz2oToyiuv7HXZT3/6Uy666CKWLVvGP/7xDy6++GJKSkpYvnw5y5cv58UXzRblPdG1ZzZgdrkbQegdBIXppxhYei0KKCKPAJ/CyIQejZGN7e/lOEopNSSqr5lFAftmJH8f5XtrKdtVw/xVk6krbaJkSyWzzp6Aw2Ub7KGZxIGWeg873zkEwJTTi0nOTBjkEY0s+ioK2Jfu9gVgCzANo5z4Fgwtw8RkSNK1cRGYIbIjiXCHjoWmRjGw9CoolFIe4JcAIvIZ4IdKqeHtozAZ2XQwM5mCYuTRyfRk5lIMKLHWejIzxUyGPEbORHsJj7ZlJiMDPWT6KAaLY+2ZnYfhr+hWketkz8w2GXw6JteZGsXIQ+8S9WQycMTaM7sQeBToqayHmZltMiRQOhAREO0axSAOyCSutPkoRBNToxhgYjUp3QfMAL4NnA8s7/BaFvl70rNu3Tpuu+226OfrrruuU70nk/6lzfQEIJFftqlRjBzaTE92p9X0UQwwsZqezgK+ppR6pD8HY3JsmIUGO9PJ9GT6KEYcelgHAZvDamoUA0ysdxkv7V3nTI6BO+64g1deeQUwNIySkhIefPBBrrrqKlatWsWqVatQSlFXV8eyZctYtWoVl1xyCevWraO8vJxly5Zx5pln8uUvfxkwtJaLL76Yiy66iB/96Ed861vfAozyH5/85CcHbZ5DAaVU1Ddh+ihGHuGwjsWiYbVbTI1igIlVo/gzRsOhtf04ln7n8LZKPO7ecgZjIyHFwegZeb2uf+SRR3j77bcB2LVrF2effXaP2+Xk5PDEE09www03sGXLFl566SW+8IUvcOWVV3L++ecDRr2n//73v1itVq655hr27t0LQCAQ4KWXXgJg+fLlKKV45plnuPzyy09obsMdpdPB9GRqFCMNPayjRQSFp8k32MM5qYhVUJQB14rIa8ALGN3tOqGU+ms8BzZcufbaa7n77rsBQ4MYO3ZsdF3Hm9aMGTMAKCwspLGxkYMHD3LRRRcBMGfOHADq6ur40pe+RGNjIyUlJdGig/PmzYse56yzzuKdd97h+eef56mnnurXuR0NXVdse30/RVNzyChIGfDzdzQ9daweazIy0EMKzSpYbJajmp5qDjWgFOSMMcvxx4NYBcUfI3/HAEt7WK+AIS8o+tIE+ovExEQqKipQSrF9+/bo8o49EpRSjB07lq1btzJt2jS2bNnCeeedx+OPP84nPvEJrrvuOq6++uqooOnol7j66qu59dZbSU1NjVapHSzCwTB+T5Cm6pZBFxTtGsWAD8Okn+ioUehhFf3clZpDDZRsqUQE0nKTsJslXE6YWAXF2KNvYtITp556Kt/4xjd47rnn+mw29PnPf57LLruMv/3tb2iahs1mY/ny5axevZp///vfve43adIkDh8+3CnaarAIR6JSTtS8d9zo7QKiTQ6bGsXIIeqjsBmR+KFgGHsXQdFY1UzJ1kqSMly0NHip3F/P6Bm5gzHcEUWsmdmH+nsgI4GlS5eydOnS6OcHH3wQgE2bNnXa7rrrrou+v+OOOwAjgum1115D0zQuuOACxowZQ2FhIVu3bu3xPB3JzMyM+jUGk7bwRW+z32gYNMD9AjqHxxpvdFNQjBj0kI7FasFqjwiKQBi7s11b8HuC7N9URkKKk0mnjebQ1kpqDjeQPzETm8MsSX4imLGVQ4SWlhaWLFnCaaedxpw5cygsLIxpvwsuuIAVK1Zgt9v7eYRHp02jULrC1xoY8PMrpaKqhBkeO/LQw4aPok2jCAc715BvbfKihxXFM/OwWDXyJ2SihxXVJQ2DMdwRRa9iVkSOpSSHUkoticN4TlpSUlJ46623jnm///znP/0wmuMj3KEWj8ftx5XsGNDzq46mJzM8dsTR5pOwdNAoOhLyG83C7C7jtuZKdpCWl0TVwXryxmdgsZrFI46XvjQKHQjH+IqpPYyI/FVEqkVkW4dld4hImYhsjrxWdVh3q4jsE5HdInLesU7OZGDpKCi87oEPX+xkejJLeIw4evJRdCTgMwRFRzNT3vhMwkGdxkqzi/OJ0FeZ8aX9cL4Hgd8BD3dZ/v+UUr/quEBEpgFXAtOBAuAVEZmklDIzbYYobUXbLDYNz6AJClOjGKkY4bFaJx9FR4L+MFaHpVNEYVKaC80itDR6ySxKHdDxjiR61SgiT/NT4nmySIXZbjkYvXAJ8KRSyq+UOgjsA06N53hM4kubRpGU7hqUyCfDRdEl6slUKUYESrWFwwqaRRDprlEEfSHsXZzWogkJqU5aG80EvROhL9PTZ4DtEbPPz0VkUT+O4yYR2RIxTbXFkBYCRzpsUxpZNmTpWhSwJ0pKSjpFPcWLm2++mXB4cJUtPWScPykjgaAvNOBlFoxIK+O9qVGMLNr+Hy0WDRHBard0KzUe9Id6jG5KTHPhafKZv4UToFdBoZSagmH2eRBYArwtIhUi8icRWSki8cpiuQ8YD8zB6Mv968jynmIre/yfFpEbRWSjiGysqamJ07CGF/fccw8Wy+A668IhHdGExFSjXcmAm5+6FgUUU1CMFNq0Vc1q3LJ6ys4O+kPYnD0IilQnSld4mwcpv2cE0Gd4rFJql1Lqp0qphRhP83cBxcC/gVoReUpErhSR407DVUpVKaXCSikdo6ZUm3mpFBjVYdMioLyXY9yvlFqglFqQnZ19vEOJG7Nnz2b16tXMnj2bzZs3A3D77bdz1lln8Zvf/Ca63aOPPsrChQs544wz+PjjjwFYtGgRN910E3PmzInWc1qzZg2LFy/m9NNP56WXXiIQCHDhhReybNkyrrjiCsDIrQiFQrz00kssWbKEBQsW8PDDXV1B/Us4pGOxaiREBcXAXpgdTU9gvDdNTyMDPdKLoi0Tu2thQKVUnxoFQGujFzBMVB+t3UN9ubu/hz1iiDkLRSlVifH0f5+IJAMXYvgR/gg4RWSdUmrlsQ5ARPKVUhWRj5cCbRFRzwGPi8hvMJzZE4ET6tn99G/fo3Rf3YkcgqIJmVz+tb6tcJWVlaxfv55Nmzbx0EMPkZuby4YNG3jrrbd4/PHHefnllwmHw/z2t7/lnXfeoaysjJtuuok1a9ZQV1fH7bffTjAY5KabbuLcc8/lV7/6Fa+99hq6rnP++eczYcIEsrKyWLNmTbcb4eLFi1m5ciWhUIilS5eyevXqE5rvsdAmKGwOK1a7ZcAjn5SuOj36iCZGMyOTYU9boERUUNgs+L3B6PpQIAyKHjUKR6INi02jtdFHdjHUlTURCoQp3VlNWl4y2gAnhg5HjitdUSnVDDwBPBExQZ0NXHy0/UTkCYxaUVkiUgr8EFgqInMwzEolwBci59guIn8HdgAh4CvDJeJpwoQJOJ3OaMG/Q4cOMWvWLADmz5/Pyy+/TE1NDcXFxdhsNsaMGUNTUxMA2dnZ5OTkANDY2EhtbS07d+6MVqGtrq5m/PjxzJw5k6uvvpr58+fzv//7v9Fzb9q0iTvvvJNgMNipttRAoIf0qGkgIcU5CBqFMjWKEUq4LaLOavz/Wu0WWjtUkA36u4fGtiEiJKa6ohpFXWkTFpuG3xOkrrSJ7NFp/Tz64U+srVC/CLymlNrTdZ1SKgi8GHn1iVLqqh4W/6WP7X8M/DiWMcbC0TSBeNG14F9xcXG0FMdHH30EGAKhpKSEYDBIWVkZqampPe6blZXFzJkzWbt2LRaLhWAwSCAQ4Bvf+AaapnHuuedy9dVXR/f5xS9+wQMPPEBhYSETJ04ciOlGaYtzB3ClOKguaeh28+5PugkKzfRRjBTaysN0ND11dGYHe8ih6EhimpPK/XW0NHrxuP2Mnp5LbWkTFXtrySxKNbWKoxCrRnEvYBWRSuD1tpdS6kC/jWwEkZ+fz/z58znrrLOYPXs2ABaLhZtuuomzzjoLTdP4/e9/3+O+mqbxv//7v6xYsQIRYdq0aXz961/nc5/7HKFQiHHjxkU1EIBLL72USy65hDlz5vRZhLA/0EM6lkgylCPBhtIVoUB4wOrsKNXeAhWMUuOmRjEy6Gp6stgs6Hp7BdmoRtGD6QkMQaEUlG6vRgQyClNwJNrYu6HU1CpiQGK5kETEBSzGMBstB+ZhWIOPYAiN14ZKm9QFCxaojRs3Rj/v3LmTqVOnDuKIhhb9+X1sfX0/rmQHExYU0VDRzL6NpUw7a0zUmdjffLR2D+n5yYyZlQ/Allf3kZjuYvy8IR1VbRID9eVu9m8qY8bScbiSDW310NZKZp89AbvLRsXeWkp31TDv/MlYrN1jdPzeIFteMfrXp+UmMfHUUSil2Pl2Ca1NPmwOK3anlVHTcknOTBjo6Q0JRGSTUmpBT+tiKgqolPIqpdYqpW5VSp0GZACfAPZi5Fs8GKexmgxj2pzZALZIvZ22sgoDgemjGLlEw2Mtxv+vzWForm2aRMAfQrNqPQoJALvTijWyT1uGtogwfn4heeMzSc1OJOALcXBzeVR7MWnnmGwCIjIRQ6NYhqFdZGNEKb0W95GZDDs6OrPtERNAcEAFRZfwWDPqacTQ1fTkSmkPwU5Mc/UaGtuGiJCU5qK5zkNablJ0uSPBzqiphunWXdPK7vcPU7m/joJJgx9mP5SI1Zn9MIZwKMDQIl4Hvorhp6jtv+HFh4F0qA5l+vPpWinVWaNwWBGBQIcQxn6nQ2Y2GGU8TI1iZNBVUDgSbFisGq2NXrJHp/VYvqMro2fkEgqEe+yKB5CSnUh6fjIVe+vILErDkWB2xmsj1n4U1wDpwG+AK5RSX1JK/WM4CAmn00ldXZ15wwB8Ph82W//8+NsSotoEhYhgc1gH1/SkiRn1NELQQ20Jd+2Z9wmpTjyRENmgP9yrI7sNR4L9qP6yUdOMbnhHdlT1uk04FD7pzFOxmp4uxjA5nQ18Q0QagHUYJqfXlVK7+md4J05RURGlpaWcrKU9upKfn98vx41Wju1gI7a5bAR9A6NRKKV6MT2ZgmIkEI4UBOz4/5uQ6jRCsHVF0BfClnPiJWwcCTbyJmRSvqcWj9tHQsTEBcZvrOZwI0e2V5FdnM7o6SdPi9VYW6GuAdYAiEgG7dFPXwF+JyKVSqkhGVpis9kYO9Zs+d3ftDsb2y9Wu9OKd6CryHYyPZnO7JFCWxhsR9pqOLU2etHD+lE1iljJHZtB5f46qg7UM3ZOAWBkfh/cXE5jVQsItNR74nKu4cLxtEJNBlIirzSM4n2m5+ckp01QtGXOAtidNgK+4IDcrNs0B1OjGJnoHfxfbbTVFGusNpoSxStfx2q3kDUqjboyN0FfCKUUBzaX01TTyqjpueSMSTf6wp9EDyExCQoR+bSIPCAi+4EDwAPANIwyHhdghMuanMREM2c7tJu0uazoYdWp811/0XbNdg+P7fdTmwwA4bDqplE4k+xoFo2mqvgKCoDcsekoXVF9qIGaw400VbVQNDWHvHEZJKQ40cMKv2cAAzUGmVi/2UcwwmCfx4h4WqeUauq3UZkMO9o1ivaLuWOIbFv7yv6i7emuY3CbWcJj5NDWtKgjhkPbQUu9UcMpXqYnAGeSg7TcJKoONqB0nZSsRHLHGpUO2nrBe90+nIn2uJ1zKBPrN5s7HCKcTAaPngWFEWEV8AajF1d/ETU9aabpaSTSMUenI4mpznZBEedSMbnjMmisOozFpjF2Tn5UW237LXua/aT3T2zIkCNWZ3YtgBjf1DQMU1MdsFOdTIY6k15p627X8WK2D2B2drtGYWZmj0T0sI7d3j20u81PIUK0l3a8SM5MIH9iJimZidhd7ee2WDUcibaBD9QYRGJ2ZovI5zE60G3BCI3dCpSLyOf6Z2gmw4meNIq2J7yBCJFt91G0L9NMjWLE0JOPAtqbElkd1rgn1YoIRVNySMlO7LbOlew8qQRFrJnZVwP3A68CjwKVQB5wNXC/iHiUUk/02yhNhjzRfgEdLmbNomG1Wwh4ByDpTvVgejI1ihGDHtbRrN0FgTPRjqbJgFUobiMhxUFjZXOPYbsjkVi/3W8Djymlru2y/CEReQT4DkYElMkQwNPkM0obFA9cmXE90i9butT1tzsHJju79/DYfj+1yQCgh3q+IYsmpGQnRgv+DRRRh3azf8CqIw8msYrCyRiaRE88GllvMkRorG6hZEvlgJYZCPcQ5w5GdnZgAE1PdPJRgG5qFCMCvUNTrK5MOKUoWlp+oHCltAuKk4FYBUUzUNTLuqLIepMhQtsNeyDyF9roTVDYndYBqSDbc3ishtKVaX4a5ui6UZ6lNxOPiAx40U9noh3RZMDb/Q4WsQqKF4GfiMhZHReKyCLgbmJog2oycFgiSW/h4MAJit7CF+1OG6FA/xdR6yk81mq3oHQVLVhoMjxpT+YcOr4AEcGV7DhpHNqxfvPfBpqAdSJyWETWi8gh4G3AHVlvMkSw2No0ivBRtowfvWoUAxQi2zEzW5W/g/K7o+GSocDAVbA1iT/RgpOWgdUajoYr2YG32ddpWcAXZM+GIyMuazvWDneVwBzg68B7GMLhfYyeFHOVUr3X5DUZcKKmpwHUKHr1UUSS7vrb/BQ1L4VaUXv+AdWbOnRBGziBaRJ/wl16UQwVElIcBP3hqJ9C1xX7NpbRXNs64sqQxxxTppTyAL+LvEyGMG3lMkIDqFEY4YvdE6Laynj0dwOjqOlJNy5aFfJiTTLObWoUw5uhaHoCSMszmhzteu8QkxeOprqkgdYGL+PnF/Z7JYKBZmh98yZxIWp6GmiNoocnvgE3PUUEBUGPqVGMENp8TENNo3Am2plyRjEiws63Sqg51Eje+EwyClIGe2hxp1eNQkQOArF6AZVSavzRNhKRvwIXAtVKqRmRZRnAU8AYoASjg15DZN2twOeAMPA1pdTaGMdzUhN1Zg9g1FNPZaDbxmKxafg9gf4dQFvUUzhiMw55sdojGoXf1CiGM0PVRwGGn2LqGWPYs/4wjgQbRVNGZseFvkxPbxC7oIiVBzFMVw93WPZd4FWl1M9E5LuRz98RkWnAlcB0jF7dr4jIJKWU+Xh4FNp9FAPzVbX1y+7NNOBMtONr7V9BEQ2P1dsFhcWqoVmEYMD8yQxnwkPU9NSGI8HGjKXjAAY8THeg6EtQ/AbYq5TyxutkSqk3RWRMl8WXYHTMA3gIo47UdyLLn1RK+YGDIrIPOBXDmW7SB6IJmkUGTKNo75fdc3asM8mBu7a1X8cQ9VGEI53HQsbP1mq3mhrFMEcfos7sjoxUAdFGX4LiI2Ah8IGIHAAuVUp93A9jyFVKVQAopSpEJCeyvBAjsqqN0siyfmXp0qXdll1xxRV8+ctfxuPxsGrVqm7rr7vuOq677jpqa2u5/PLLu63/0pe+xKc+9SmOHDnCtdd2rYICt9xyCxdddBG7d+/mC1/4Qrf1t912G2effTabN2/m5ptv7rb+Jz/5Caeffjrvvvsu3/ve9wBoafBitVlwJtm55557mDNnDq+88gp33313t/3/9Kc/MXnyZJ5//nl+/etfd1v/yCOPMGrUKJ566inuu+++buufePRJAP7x7yf555p/dFv/l98+TNAX4nf/9zuefubpbuvXrVsHwK9+9SvWrFnTaZ3L5eLFF400nR/96Ee8+uqrndZnZmbyzDPPoBT8/qHfsP/QeizBerDYIflfJNvT+NVdvwXg5ptvZvPmzZ32nzRpEvfffz8AN954I3v27Om0fs6cOdxzzz0AXHPNNZSWlnZav2jRIn76058CcNlll1FXV9dp/YoVK/jBD34AwPnnn4/X2/m568ILL+Sb3/wmMHJ+ex2Jx2/PFkzkv2+9yDd/9Wy3G/LTTz9NVlYWDz74IA8++GC3/V944QUSEhL4wx/+wN///vdu6+Px2wO49dZbee+9zs+wRUVFPPqoUdBioH57bfOJN32JaC+QEHk/BhhoN35PIrpHU5iI3CgiG0VkY01NTT8Pa3ggwoBlJLeFL3at89SGI9LcJdiPT/ZR0xMRLUq1jUkzNYphjt8TQNMGPvvapB3p7WYiIu8DFuA/wO0Y7U9Le9zYcGb/KKYTGqanNR2c2buBpRFtIh+je97kiCMbpdRPI9utBe5QSvVpelqwYIHauHFjLEMZ0ex46yAWq4XJi0b3+7lam3zsePMgE04pIj0vudt6b7OfbesOMG5uAZlFqf0yhtojjRzcXMGMog9xNH0Amh1t8S84GOl1POecif1yXpP+Z8/6wwR9IaYvGTfYQxnRiMgmpdSCntb1ZXq6GfgrcBvGk/zn+9hWATEJih54DvgM8LPI32c7LH9cRH6D4cyeCGw4znOcdFhslgFzZrfFufdWtM2RYORX+Fr6z6Edfd4JR0w7egClhw0fRSCMUsp8Ih2m+FuD0SJ8JoNDr6YnpdT7SqlpgB3DDHQGYOvlFVPjWBF5AsMZPVlESiNNj34GnCMie4FzIp9RSm0H/g7sAF4CvmJGPMWOxaoNWB5FuIfudh3RLBqOBBve1v6rixM1PYU6OM1DXmwOo97TQIYKm8QPpRR+bxBHwsnRm3qoctTMbKWULiLXA3tO9EatlLqql1Uretn+x8CPT+ScJysWm2XAaj311N2uK84kR79qFHQUFGIBFY7kUhg3mFAgHM1YNxk+BLwhlK5wJHbP+jcZOGKNN/shvZQZF5EZkagokyHEQGoUekyCwo6vJdBvDnY9MlUJtYIz0/gQ0Sigfx3pJv1HW6Km09QoBpVYBcUYeo96cgLFcRmNSdyw2DR0XaEPQM/oWBKinEl2lK76r+ZTm0ahAuBqFxTRCrJmGY9hiT+SqGlqFIPLsWSw9HbHWQA0nvhQTOJJW/KbPgDmp2i/7D4EhSvJeM7oL/NTp/BYV5axMOTF6jALAw5nfJ4gImB3mYJiMOmr1tM3gG9EPirgeRHpepW7gAzgyf4ZnsnxYo0UBgwFdaz9rLUb/Yz7jnN3JhmD8LUESM3pdbPjpq03tqAQZ6bxVBPyYrObhQGHM/7WAPYE+7CJWFNBD+rgC0jxOYijf0LBB4O+nNkHgLZUxM8AG4Gu2Wx+jKikB+I/NJMTYSDboQZ9oaijuCVYT4I1FU06O46tdgsWq4a3pX8in9p9H501Cs2iYbFqpkYxTPF7gjgTho82oQ6/AuXvQMEiOBkEhVLqWSI5DRFpfpdS6uAAjcvkBLHY2tqh9v+TtMftx5XqJKQHeKPsQXISxrIg+xOdngJFxHBo91NxQENQKKNntiMNEFTIi2AIKbMw4PBDKYW/NUBS+tC64So9DCKIdDa1Kl8DlL4JuQuQpH6vNjSgxNrh7npTSAwvBkqj0MM63hY/CSkO/GEPOmEqPfvY2/R+t237M0RW6UbZEgBsSWB1tRcGdJiFAYcj4WCYcEiPJmwOBqpiPcrT3sBT6WHUxp8bXRS7bnvwBQBkbPeaXMOdmDrcicjtR9kk5hIeJgPDQGkU3mY/KEhIcRLQWwBItKaxu/FtUu255Ca0l11wJtmpK20ychrs8c1pMDKvI+YnWwJYE6KCwma34O/nDnsm8cfXavyftdUK64oKtiK2xH47v6r+CLX7CUgqhPm3GBpE1UbwVIOnBlV4FpJUYGzbXGqsG7UMcab325gGi1hbod7Rx7o247ApKIYQA6VReJqM/g8JqU6awoYLa1bmeWxveJ3NtS9w7qivRE1QyRlGjcnmulbS8+PbBUwphaBArKDZumkUrY1xq5ZvMkBEcyh6EBSqZgtq+4Mw/xtI8qju6/2NoIeQNn/VMaICzag9T4MtEVrKoPojVM5cwweRkAcBN+rAc8isL6LCAdTeZ8DqQkaffVznG+rEanrSur6ATOA6YBswoR/HaHIctDcv6mdB4fZjsRolOvyRXhAuawrFSbMI6F784faSGonpLjSrRlNN/HtTKD2iUdgSDcHUQVDY7JZovSeT4YM/olH0FBqrKt4FdFTpmz3uq7Y+gPrg56jqzcd8XqUUavdTEPYjc74KiQWGWalqI3hrkLHnGwKhfheqdhtqy5/AXYJMvByxJRz9BMOQ4+4EopRqUEo9jNG17vdxG5FJXNAsGqJJv5fx8DT5SEhxIiIEdENQOCwJuKyGxuANudvHpAkpmQk0VbfG/6atAHTD7ATdNAqlBraHuMmJ4/cEsDms3fJzlL8J6neDxQnVH6ICzZ3XN5dCSylY7KgdD6IOvxbT703VbkPf+0/Ux/dB3TZk3AVIYh4y7kLw1aF2/x0SciFrJhSeBY501La/QNNBZOo1SO68uM5/KBGPllEfA4vjcByTONPfZTyUUnjcPlypRjJdIOxFw4JFbFFB4Qm7O+2TmpNIwBuMPi3Gi4A3iE3zG74J6KZRgFnGY7jhaw30nJFdtRFQyNRrjZpe5Z07D6jK9SBWZMG3IXsO6sBzcGhtn+dS7hLUtgeg4n0IeaBoifECyJgKqeNBhYz8CNEQiw0ZfzFY7Mj0zyC58+M066FJrD6KvriQ7vkVJkMAozBg/wkKf2sAPaxITHUCENC92C0JiEiPGgVASnYSUEVTTQvOpIy4jcXj9pNiaTBsytBNowCjMKDJ8KAtNNb4vXRerio/gJSxSNZ0VPpkVPk7MHoFollQ4SBUbYLsmUbC27TVqF02VMlLYE+F/IVQtx11+FVkzEokY7Jx3JKXwZqILLwdsXauViQiMOl/UJUbIHtu+/KcuZA9u1uY7Egk1qinv/aw2A7MAGZiFA00GWIYGkX/3Rxbm4zkuYQUQ1D4wx7sFhcANs2BVRzdBIUz0Y4jwYa7ppXcsfERFEF/iKA/hCuhNmp6EqsLpQdQesjUKIYhHrefoD9MUoar84rmI+CpRCZdAYAULUZt/TPUfgw586BuG4Q8SN5pxnrRYPKVqGALas/fDW2kaT8gqJ2PwCnfAX8j1O9Axl7QTUhES8Mk5hkaRBdOBiEBsWsUy+le68kHHALuAR6K45hM4oTVphHqR43C4/YhAs7kdtOTQ2t35iVYU7oJCoCU7ETqSt3oukLrpX3qsY4DwEUFWCcZC62RG0zIh9VhjM/UKIYP9eVuELp1TFRVHxiRbdlzjAUZU8GVbfgPAs2ouh1GwmX6pOg+ollg+nWozX+AllJk/CWQNhH14T2o3U8CkeCHwrOi+3hDzRxwb+Rw8xYmpJ7GxLSF/T/pIUxMgkIpNaafx2HSD1isFgK+/msW5Gny4Up2RG/2Ad1Doi0tut7Vi6BIzU6i5lAjrQ1ekjNPPErE06bZaDWILWIaiAoKL1anYY4K+MxciuGAUoqGcjcpWYnYHO23KNV00PAhZM+ORheJaDDrC6g9/0Dt+5exYfG53Z70xeKAuV8FPYi0/TbGXxTdR8asRKyGZny4eStb6l4GFA5LIvvdHzA2ZR5WrXOYricQYnu5mwXF6cOmFtXxcnLoTScpFpvWrz4Kj9tHQsQ/AW2mp/Ybv8uagqcHQZGclQACjdUtcRuHzaFhlS7ObDDqPWlCQqqT5jpPXM5ncvyomi3o79+NKnun121am3z4PUEyCtpzbZSnBrX1AXCkIhMu7bS9uLKQWV9Epl0HmdORgtN7PK5o1nYhAYYGkTHF+M0UGvE4LcEGttW/SoajkOWFNzA/+2KCuo8jLds6HWtbeRMX/u5t/udP77F2R1WndWF95D2QHFVQiEi6iHxLRF4UkW2R14si8k0RGXkpiCMIizV2QVG6s5rKA/UxHzvgCxLyh6P+ibAeIqyCnUxPLmsKIeUnqHfWaqw2C6k5SdQeboyLIPO6/SQkRZ7oOjqzIerQTslOpLXBa7ZEHSRUyIu+8zHU9r9CsBm192lU9Uc9bttQ7kY6mJ1UoMXIVRCQmV9A7End9hERJGcO2swbEEdaTGMS0ZAZNyCnfg+xJaCUzubaF9BEY272BSTYUslwFpLuKOCAeyMqUqL4kfcPcekf3sHjDzM6I4Gfv7iLQOR3Ve09yKtlf6bJX9XXqYcdfQoKEVkO7AZ+DswBmoGWyPtfAHtEZGSmIo4ALDYLekg/agx50B+iYn8dlfvrYs5v8LqNm39b0/u2HIo2ZzYYPgroHvkEkD8+k1AgTO2RxpjO1xvRWlMJEQFg665RAKRkJaIUplYxCKjabagNPzOikYrPQxbdCaljUTsfRTXs6bytUtSXu0nJSYqWeVElL4G/wbipJ2THdWyiWaKCZ797Iw3+cmZknI3L2u4bGZeyAE+oiQrPXvZVt3Dn81s5fXwmL37tLO64aBoH61p5fMMhSlt2sKHqn6A7cVj6r7TIYNCroBCRScBzwF7gNKVUvlJqkVJqoVIqH1gYWfdvEZkyMMM1ORZiLeNRX+4GZZQLj7VoX5sDuT3iybgh2ztqFJbeBUVShovEdBdVB+pRkS58niZftGxDrLTVmnI5IvtZe9YokjNciCa4a+OfFW7SGRUOohr2oMreQt/2FyM/wZaAzLsZbez5iNWJzPg8JOSgtv0V5a2N7tva4CXgDZERKfGifA1Q8R7knYakjum3MfvDHnY3vE1ewkQKE6d2WpefMJEEayq7Gt7k7Yon+OVnd3Ht2VtpUXtZMimTC2Y72FH/Bh/V/ofqxhS+9tcstpb2Y3/4QaAvZ/ZtwC5gmVKq26yVUhtEZBnwLvA9YHX/DNHkeGkvDKhH+0X0RF1pE3anlYAvRFNNK67k3rretuNx+7G7rNGnvvas7HaNordcCjBMBfnjM9m3sZT6CjcBb4jSndU4Em3MWDIOzRKb+8wT0WwSHBEB0ItGoVk0kjNcpqAYANT2v0H9DuODxYmMWQWjlyNa++1GbAkw8wbUxl+itj8E876OaFYqD9SjWYT0POMpXx1+xdi++Jx+HXNpyzZ0wkxJO7ObY1pEY2LqQj6uW0trwImleSzp2W42177AFnmZlQuNsOsP9qaw5v0ivrJkAlO6RGsNd/oSFMuB7/YkJNpQSvlF5B7gZ/EemMmJ065RhIGeSzV7W/y0NvoYNS2H6kONuGtayRt39PwGr9uPK6XdkR0It5me2jUKhyURDUuPDm2AtLwknIl2Dm6uQOmKpAwXLfVeKvfXUzAptmJuHrcPzSI4tIhjvM2ZbbEDWrQnBUByViJlu2oI+kOdomlM4odqPmIIiVHLkaIlYE/pNSJInBkw5dOobX9B7X+WlozzaahopmBSFhabJaJNvA/5p/VrRValFIeat5LuKCDZ3v6703XFewfqcNoszCycwfdebWFHRStvfmsZiXYLlZ59VHsPkOEo5JVtFrI0K69/cwypI7Bta19XSzZQEsMxDmIUCDQZYlhsRy8MWFfaBEBGYQp+T5DaI41HzW9o8wuk5bU7FXsyPYkITmsy3nDPgkJEyJ+UxcGPyimamkPe+Az2byyjYm8tmUWpMfUhiAqskAc0O2KxRY+tOmRng+HQLttVg7u2lczCodUMZ6SgDr9qaBHF53SOMOoFyZqJKlqCOvIGh0vGYXMkkjc+ExX2ow7+x9hm9LFrEyE9gEJh07prx0op1m6vZOG4TNIS7NT7y2gN1TMx9XwAwrrilZ1V3PPqXnZWGL9dh1XDH9K5/cJpJEUeMvITJ5KfOBGA6xcd8xCHFX0JihpgDPD2UY4xFqg9yjZHRURKMJzlYSCklFogIhnAU5FxlABXKKUaTvRcJwsWa8T01EthQKUUdaVuUrITsTttpGQnUl3SQEu9h5Ss3p1xHXtQtBHQPQhatwuzt6S7NrKKUknPS45qP6Om59JU3cLhbZXkjc8k6A9hd9lITHN2ezJVSuFp8pFRmAIBd3vEUxtdBEViqhOLTTMFRT+hPDVQ87GhTcQgJNqQcRdRV2vDU+NkjOt1ZNt/Ue4S0INQtKSTNtESrMcqdpzW7pFPbVR7DrK59gUsmo3F+auxWZyd1r+7v44vPvYhiydm89D1p3C4eQtWsbP2Yzvrdq9n85FGWvwhxmYm8qvLZ5PksLD+YD1N3iBXnzb6mL+XkUBfguJV4H9F5O+9mZ9ExAF8g/be2ifKMqVUR6HzXeBVpdTPROS7kc/fidO5RjxHKzXeUu8l4A1SONmIJEnJNPIb3DWtRxcUQEJKu1AIhL3YLa5uN3OXNYUab0lM4wRwJNjIn5hF2e4aGqva8yyciXYyClNQusLvDeL3BPG3BgiHdENg1VZCYm7nA3cRFCJCSmYi7prWSKOjkZ0kNdCo0tdBNKTo2GqE+jxhytyTSEiGjJwkaDkC+YuQrJmQNj66XVnLTjbXvggiTEg5lfGpp3RKgvOHPextfJ+DzZtItGbgCTWyue4lFmRf0un/+okPDuOyh3lnfzWPvL+XzILdVNTkc/d/9jI1P4VPzClg0fgszpuWizXiK1s5I/8Ev53hTV+C4sfAh8CrIvJ1pdSHHVeKyHzgXmAScFU/je8SYGnk/UPAOkxBETNR01MvUU+NVc1GvHp+UmR7C0lpLppqWima2uMugJEJrWnSqfOYP+zBrnV/inRZUvCFW9BVGE1i62qXPyHTyPi2atjsFlqbfNQeaaR8Ty0iRn8Cu8tGWl6yIUAKkuBwNaRN7HygLoICIC0/mYbKZqoONsTki4knuq6oPtLEoV01WK0a81eMP/pOwwTVUgEVGyDvFKMYX4w013nY+8ERRISx80ZjSZnUbRulFPvdH7Cz4Q0yHIU4LUnsaXqXkubNpDsKSLFn0Ryso8qzH4XO2OR5TE1fTEnzR+xoeIOS5o8Ym2KUAK9r8dMY3MXPrytHKXB796KrEA+9YeVLS8bznZVmAGdP9CoolFJ7ROQTwBPAByJSSbvPYgyQBzQCn1RK7Y7DWBTwshj9LP+klLofyFVKVUTGUyEiOT3tKCI3AjcCjB59cqqGPRE1PfVSGLCxqoXkzMTodgApOYmU764lFAhhtff88/C4fbhSHJ2e0gK6B4elezmO9sin5k7lPfpCNCE9vz1qJCHVSfboNELBMBar1t0E5alB6UEkMa/zgWwuaO1s9sosTKGh3E3pjiqSM1wkpsVuIjlWWhp9HNxRRcn2akp21nBoVw3eSPixCMw8sxj7CHCqq6qNRq2lY+zwVlfm5uDmchwuG5MWjsKR0LlEhj/sobRlB6Ut23AHayhImMycrFVYNCtjfKWUuD/CHaym2rsfm+ZibMo8RifNjDqkx6WcQq3vCDvq1+EPt1KYOI2X97/HpxaXkaAVkubI57WyPWw/rLFswmS+fd7kuH4vI4k+f6VKqVdEZDJwA0YU1ChAgO3Ab4EHlFJ1cRrLGUqp8ogw+K+I7Ip1x4hQuR9gwYIFZhuzCJpFEKHHwoC+1gC+lgDZxZ2jSVJzkijfXUtDZQvZo9O67Wf0oPCTkd85/C8Q9pJqz+22fccQ2VgFRW/0GuLrqTT+dhUUPWgUIsLYOflse+Mg+z8sY/risZ0E5fGilKLqUCP7t1axf2slB7dVUV1qCCnNIhSMy2D+8nEUT82httzN2kc209row57bu619OKAffAEOvQyp45Bpn4lZm6g6UM/h7VUkZbiYeMqobj3UdRXmzfKH8YWbSbPnMTPzHIqTZkcfEjKdRWQ6iwAIqxCChtahvlNNs5+QrjM3axUf1b7A3qb17G16n6RU2Fuazc1nfApNLCjvbDYeauDG88aZpsg+OOrjjFKqHiMz++f9ORClVHnkb7WI/As4FagSkfyINpEPVPfnGEYaIoIzydFjNnJTpM5SWpcbVWKqE0einbrSph4FRdAXIhwMRzOy2wjonk5Z2W1Es7N7iXyKC60RQZHQVVAkQLAFFfJFC74BWO1Wxs8rZNe7hyjdVUPxjC77xYAe1indV8++jyvYu7mC/Vsro2XXk1KdjJ2Ry6ILJjN2ei7FU7KxO9svtY/fKgGgpclH+jAWFMp9GA79F3JPQSZfaVRpPQp6WKdsdy2V++tIy0ti/LzCHnNmqr0H8YWbmZd1IYVJfdhBAYt0vo0dafBw2X3v0uoP8bur5rFsymX4Qi28f+Qj/vjGIT45Y3HUDLpgTAYLxnQ2QSqlCOkKW4y5PCcDQ0LvFZFEQFNKNUfenwvchZEZ/hmMPI3PAM8O3iiHJ5mjUindUY232d8pka6xqgVnor1b43oRIasohbLdtfg9wW4hqtEEtw4RT7oKE9T9PZqenJFSCC3B2OtIHSuqtRIcaZ2EAYBkz0EdeQ0ijW06kpyZQNaoVGoPNVIwMeuoeRVKKSoONrB7Uzm7Pyxn38cVUTNSVkEyMxaNZsKsPMbPyiNnVGqfT6dJacY4Wxp9xzPdIYFSOmrvP8CejEy87KhCQg/rhp9pbx1BX4js0WkUz8xDegnDLmvZiU1zkZ/Y3Wexv6aF+988wLv7a/nkvCI+d+ZYUpzG77S2xc+1f1mPLxhmdGYin3v4A245dzItvhBPf+jHF8jmr58u6HOsu6pb2FndzMXT87BqprCAISIogFzgX5GLywo8rpR6SUQ+AP4uIp8DDgP/M4hjHJZkFaZSurOa2iNNjJpmuHjCIZ3mOg85Y3pOYsosSqVsdy11ZU0UTGxPQFJK0dpomHJcXSKegB6d2RaxkuMaR4n7I8alzO+fGjieyu5mJ0BSRqPSJ6GOrIPCxdEcizbyxmdSe6SJ6pKGaORXRxprW9n1QRm7Npaxa1MZzfXGPLMKU5i7dCwT5xQwcU4e6TnHphUkRSruNg9jQUHF+9B8BJl6bTcB3ZXmeg8lmyvwtQZIynAxbk4ByVkJvQrTkB6g0ruPUUkzOgVAuH1Bfvjsdv79cRl2i8bsojTufXUvD75bwoopOSQ5rGwoqafS7eOxz53GlLwUvv7UZn65djcWTVg6KZsvLB5PQi++tzZKm7z4QzrVLQEKUvqe28nCkBAUSqkDwOweltcBK7rvYRIrNqeVtJwk6kobKZqSHa13pHTVzezUhiPBTlKGi7rSJvInZOJ1+ynZUoHX7UfXFY5EWyd/QXtBwJ57S0zPWMa6sr+xq+EtZmet7HWstd5DaGIlw1kY8/yU0sFTDWndnzzBSNZSH/8eKtdD4Zmd1rmSHaTlJhkRUOONnNH9WyvZ8f4Rtq8vpTxSTTc53cXk+QVMWVDIpHkFZJ5geYY2jaK1aegKChXygjfiftSs4MpCNCtKD0HDHtSBNUYf6Zx5Pe+vFL6WANUlDVSXNGB32Zh46ihScxKP6guo8OxBVyGKOtRc2lbexFce+5DSRi9fWDyez50xluxkB9vKmrj3tb2sP1hPiz+EVRPuu3o+84sNc9KfrpnP+oN1TMhJIif56Df9QEinrtXQFCvcPlNQRBgSgsKkf8kalUZjVQtNNS2k5SbTVNWCZtVIyui9aVBWUSolWyqp3F9P+d5aLFaN7DHpOBPt3ZoNRbOyexEUSbYMxqXMZ7/7A4qT55Dm6P70H9aDfFD9b8IqxNysVUe1S0fx1hnNaHrQKABImwApxYYJKn9RNxNJUnYiG1/dz7sv7+Pgzmp8rUEsVo3xM3P5xBdPZeqpRRSMy4hLJ742XEkONIvQ0ug9+sYDgKrfDYl5UUe0CvmMaq+BpvaNREO5coy2oWEfWBOQSZf3mARZc6iBqgMN+CI33Jwx6RRNzemUL9MXZS07cVlTSXcUUlLbysPvH+LR9YfISLDz1A0LO/kUZhSm8udrF/R6LIsmnD4+tnIwAFUtfhTgtGpUuIeuIB9oTEFxEpCaa5RsrtxfT12Zm/oyNxkFKX3e/NILUji0rYrSndW4kh1MOm0U9l5q2AR044bn6MH01MbEtEWUtmxna90rLMq7olu3sErPPkIqQKI1nQ9r1xDUfYxJmdvL0TrQWmH87ZpshxEN4w+14Bx1Nmz/i9EvOf80qo80seXtQ3z8dgkHt1WhFCQk25m7dBwzTx/N5PkFOLuEasYTTRMSU5xDwvSkfPWoLX+ElDEw96uIaIZQDTQhkz5lZLuHAyhPpRE0kDIGyZ4JaZO6mfLCoTAHN1fQUNFMUrqL4nF5pOUlYXfGXvvIF2qhxneIiamn8Z1/buEfm0qxiHDRrAJ+cOE0MhL77/8FoLLZh1UTpuQks7m8iWZ/iOQREMJ8ohzTNyDG48M0IAOoA3aqWBsYmAwamiZkFqVSFanMmTc+g/wJfZfnstos5IxJx98aYOzcgj6rz/ZUELArNs3B9IzlfFi7hjfLH2Zu9irSHe1OxdLW7TgtySwuWM2HNWvYWv8KKfacTmYopYegbjuq8gOwJSGTPwWeSIOYrhFPwPb61znUvJkELY3Rjdns+tMbfHzgEBUlxpPyqImZnP+ZeYyZkk1rbQujp+dGTVD9TVKac0iYnlTFekCB+yCUv4fKmglH1kH2XKSgvYBRX/qUUgp3TSuHt1Xhaw1E63YdT7hpSfNHgMLjGcXfN27nigVFfPOcyeQMkAmo0u0jJ8lBUaqTzeVNVLh9JGcP38i0eBGzoBCRzwN3YxQLbKNaRG5TSv0l7iMziSsFE7NwJtnJyE/pFrPeG6Ond39K74mooND6vpgLk6bisCSyufZF3ql4nBkZZzMmZQ6+UAvV3hImpJ6GVbMzL/tCXj7yBw63bIkKCtVaZfgaAu72/IiUUZGIp/RuDlVvsJltW7fT+GEOh98P0VyZg4hi3IQmLv/qImadVRz1NSil2LvhCGV7askoTOn1CTikBznU/BHFyXO6aUTHSlLq4GsUSumG7yZ9MqBQB56Dxj2gQsjYVTEdo7neQ+nOalrqvdhdNiYvGt1n+Ze+qPIcYG/T+xQlTuPZ91qxWzS+d/5U0vpRu+tIiz9ESyDM5Jxkkp02kuwWKtw+JpmCIjZBISJXYyS0vQo8ClRiZGZfDdwvIh6l1BP9NkqTE8Zqt5BT3HOU04niCblxaAndGtr3RJZrNEsKr4tqDUm2dJoC1YCiKHGaMVbNTmHiVMpadzI9YzlWsaH2PAV6CJl5I6RPRm39E2rfs0b/iQ7+iYqSBja9up/3/ruNxvJENC3IpHkFTL4yg6yc/zInVEdg8nScHRzSIsLo6Xlse+MApTtrGDe35/DJkuYP2dnwJoLGuNTe7eKxkJTmpOJgA6pxP7gPocJ+xOKAwrOiJh0V8kH9LkjIMXwIMXy/x0T9TvA3Gj2okwpRH/zcKOpXcPpRO8mFAmGO7Kyi9nATNqeV4pl5ZI1OO25fTmuwgY9q15Biz2Fy6gr+vflNzpmWO2BCAgyzE0BeJIw8P8XJgXoPYV1hiaOPajgSq0bxbeAxpdS1XZY/JCKPYNRfMgXFSUqdv5T0Y4hUsmkO5mdfxFsVj7Kx5nnsmoM0ez7J9nazz+jkmRxu2UJ56y5Gt3ih6YCR1JVpCBMmX2Xc2PyN1Guz+PCxzWx8ZT9l++sRTciYEuKMizK4+IKLo1FGjb7RNH14D669T/OxfoSkpLHkJkwgyZaBM8lO3rgMKvbVkV2cRnIHR7+q2oRq3IujZSdTJUy5bGRsyvwTyuRNSnPS0tCK2vw7jOo1kX9rt8KMzxqJgtv+Ct4aYweLA+VIA9EAgXDAcCqnTUSmXt2pKVB03N46ox+EpWcNSZW/B7YkyJxu7D/+YtThV5Hi8/oce2NVMwc3VxAKhskbn2n0j4jRUd3or2Jr3cuAkGRLx6a58IWbafCXA8Ip2ZewblcDjd4gVywYFdMx40WF20+CzRL1SeSnONlb20p1i5/8kzz6KVZBMRlDWPTEo8C/4zIak2GHJ9iEN9TE+JRje8K2anZOybmUt8ofoTXUyIyM+Z3Wp9nzSbZlUd7wIaMO74XUcZB3anS9N5jAR0eWsuGlXewrqQPqGDs9h//5+iJS59VTKutZXPBJkuztF3ias4Dmaddh2fIXig9/xDu5JeyoX8ecVgv5jTXk5J5JnXMS+z4oZdJpo0hMc6FK30Ltewbd4iCTIHZdkefZS2PqVtLTZnUas98TQLNoMTVFSkxx0NocQLcmYznlm2BPgpotqF2PoTb9GoIesDiQ6Z81nMnuEgg2g9JBqUhjJoHqTYYJadrqaESXCvlQ+/4JlRvA6kLlzEPyToHk4qhwU/4mqNsBo5ZGhYwUngUFZ/Squei6omxXNZX760lIcTB50eho4mVYD7HfvYGg7kNXOkm2DIqTZ3fKgyhv3c1HtS9g11wk2dKp9R0hqPtwWZNJsmUyKe10Emxp/H3jHvJTnZw5IfZopVjYtbGMioMNLL18ejchH9YVVS0+RqW2V0DOTXZgEWFXdTO5yQ60k7jER6yCohko6mVdUWS9yUlIre8wAFnOYy/GmGRLZ37ORRxo2titT7GIMCppJpa9/0SFfWiTrkAPw84PDrP+pb1seecQoUCYnMJsLvzsFE45dyJZBSm4AzW8V7mOHMc4Uu3da0gmp01DTbuelG1/4VxPJp5QE8mNR2iy20gpe4Vx1k3s817Eznf2kzvqEIX1/4XMGbyTrqFEODPxLKxb/oBt6yOoKdcSsmZSWhLGXesj4AujWYRJM20kOlsRPWg8+TtSIGNap5tTkpSjlODNvZBkh1HmhJw54MpEbfsLJBd1qp0keT0LYpU8CrX/36jdT0LWDPA3oUrXga8BipZAoAUqN6DK3wFXNip7DgRboGEPoCP5nTvu9CQklFK4aw1fhKfJR3ZxGqOn53YqvXG4ZQu7G9/BIjY0sRDUfRx0f8iU9LMI6QFqvAcp9+wm3VHAKTmf6DXxsrLJx5t7a/jSkvFxN/esfXQzez4sR9d1Vnyqs5A/UNdKMKwYnd6uSVo1jXlFqXxwpJHNZU3MK0qL6TxhXaEJI6p2VKyC4kXgJyKyRyn1VttCEVmE4eB+sT8GZzL0qfUdxq4lkGQ7vmihHNdYclxje1xXlDgZPF52thSx668H2fjKKzQ3eElKdXLGRVM47dyJjJ6SZXSzU4rDzVvZWv8KNrEzNf2sXs8pWTNg7AVYDq4hGYFxFxLIHMOBpm0kV2xmEs9w0HM+lYeKaXacQzgpAXdgEzOSzscbLqB8/BIKD7yJbHuMvZ4L8OoZpFoPkeOooCYwg72bnUxKWEOCpUNrlZSxMPGT4MyE1goSvVuAPFqsE+iYvifJo+C0Hxh9HWK40ciopUZy3KG1qKoPjIXOLGTuV5HUcUAkea7mY1TVJjj8ClgcRhG/sau6+SKC/hDNdR5aGryEg2FEBF9LgOZ6D3anlfHzC8koSOm0j1I6B9wbSXcUcGb+1YDhmN5e/zqbap4DwKElRMp/L8HSg5ms2Rfknx+W8dD7JegKLp8fX7OTUooje2qx2i386w/rychNZu5S43cX1hXbq5rJSrRH/RNtTMhKoskXYndNCwl2C0WpLjRNcHWpYtzgCVDa5KO6xU9dq5/zJueOqJaox+KjWAisE5EyoALDmV0E7KN3s5TJCEYpRZ3vMFnOUXF/empp9PHB8x/y/pqxlFa40CzbmH76KE4/fyrTF46K2sQ9wUYqPHup8OylwV9GlnM0c7Mu6LMDGgCjVxhjTsxHMqeRC+QmToCCT6DCQSbV7uHwvkbqG4uRbRZyWUUtQi2HsDqn8EFqkDT/BMLKzvjxbtJSUkBSSfD72bPbxg7fhQSz95OTMRu8hxjvft0wKUVISjA0hZZIIcGOxFJcr9P2Y1ZC1kyjdrk9BWyJnTQDsbogfyGSvxAV9IDV2U1z8DT5OjWLEk2w2i0opbBYNEZPzyW7OK3HAn6Vnn14Qk1MTV8SXZabMI5sVzHV3oMkWFNJtmX1+hvZXdnMpx94n7rWALMKU7nv6nmMPc7Iqd6oq2jG2xLg8q8uYtNr+3no7tfJzE9m9OQs9te14g2GWVic3uMY5xam0uwL8lFZEx+VGaHVSXYLU3KTyU1ysK3SzaEGI5co3WWjOMUV1wTNoUBMgkIpVSkic4DPAmdh5FGUAG8ADyqlupcnNRnxtIYa8YVbyHTFpwdIOKSzY/0R3nthD9veO0w4pDOqAFZ8Ph+Zu4fEtAOkpRUiFkVID7Cr4W0ONm8CIMWWzbT0pYxLmR9TdJCIdCsUGF1nsWHPnc6EXAgGQpQc3I8WspGakoFoGjWHGghVTScoYTJnCZac+SiHlUC4lY2Vj6NPsJJ95HSkahqNVUHCWiF61udJc1WQkhTAkZ5Bck4yPPjfuORSiAgkd7cM67oi4Aniaw3gbfbT2ujF0+RDNMHutGGxaShl9CtprvNgsWkUTMwiNSeRhLTYb3b73R+QYE0lP6Fz4yhNLOQlTOhz3wM1LVz9l/VYLcI/v3Q680b3T2Te4T2GdjduZi6nnDOBu697mmd+9x433XMBO6rcZCfayU3q3l8bQBPhzHFZVLi9BMNGZdmD9a1sPNIIgEVgWm4yEzMSef+5nfzz0c2M+f1FJI9K65e5DAYx51FEhMHvIi8TE2p9h4Dj8090pPxAPe+/uIcN/91Hc72X5HQXSz45ndPGrKcgP4w2/0Ka/FV8XLeWj+teYm/Teyil8IbdjEmew7iUU06410Vv2OxWJk42GtqEdUWF28fEhaNpaqhnZ+Mb7ND3Ezw0Fps1hFjK0UTj9NFXkjYxj1f2vIRqacDSOAtrYwB3wBijzWlFsxk9QrrmUgT9IXwtAZRSWO0WLFbjqV7pxkvXVXSd3WFFNCEc0gmHdAKRFrFet4+WBkModEyHdSTYSEh1goKAP0TAF0REEE3In5hJ3vjMPhMre6LBV06Dv5wZGSuMrG6leOi9Eqrcfr64ZHyf5pd91c1c+9cNKKV47HOLmHCMxRWPhSN76qJ9QWx2CytXz+Uf97zLv9bsJDw6lUXFKd20idZgKz9653aWFZ/NeWPPZ1Rau/9iYlYi1S1+qpv9JPtCVG2t5lePbKbqcCPTTitCG2FVZ83cdJPjps57BKcliUTrsT8FtjT62PjqPta/tJfDu2vRLMLM04tZeP4kpi8chaZ8qHeegoxzAEh15HJW/rVUew+wt+k9dKWYl33hMRUQPBH8oTBvHaijpjVAdpKds8ZmMd62kqryV7A5d4PuxO8bT6plKv5AGlUBHzWeiaRk/Idw2qu0ShhLwEGip5C0wDh8VcYN+fCOKg6NS8fr9uNt9hPqpRvhsaBpQmKai9xxmbiS7TgS7DiT7DFFY4FhUjzcsoVEazpZvWiL3lAzlZ69lDRvxqY5GJU0A28gzLef2cLzW8oB+PvGI3zjnEmMSk/A7Qui64r0BDtWi/D4hsO8sLWCZKeNJ25Y2K9CAuDI7pqokPAGwzRNSMeR6WLjk1u58hfnkZvsJBQMU36gnsO7a6kpb+KVIy9xxFPPpuL/Y9pnpzMqpf27UAq2rtnDS4981F5uvjCFL/7sXGYsGj2iHNnQh6AQkQPApUqpj0XkIG3B3j2jlFIjpwGwyVFRSlHrO0y2a0zMF0UoGGb7+0dY/9Ietr13xDAtTczk8q8uYsE540nu0JZU1ewFFJLe3sNYRMhNGE9uQv//1EK6ToMniB5pYvNhaSOeYJjJ2UnsrW3hlT3V+EI6TuupLC5YhsuSwL46DzurmnltXy2aQKItgVmZ57C9bhP+QArT8gqo9OzhsP8lXDlp2J1Wmmo91JU2GZVs85NxJdlxJTsQTQgFwoRDOiKGz0DTBNE0o2thIEzAH0LpCotVw2LVsLtsOBJs2J22Xvs8HI2g7mdz7QtUevYBMC5lAVPSz4o2BwqEvexqfItDzR8DkGzLYnbmSsobQ3zx0fXsrHTznZVTOGtiFnc+v53b/r2tx/MkOazc2KEKbH9iOLLrmHVmMUopPjjcgF/XOXv1XP7z/96l5o1DPFW9gw0v78XnCRo7aQr0QkZRCJvgxx8/wde+/GnSshIJhxT//N177PmoghmLRjF78VhGTcqiYGw6FqtGMBzEqllHlLDo6xHjDcDd4b1Z08kkSrX3IAHdQ7aruM/tlFIc2FbFhpf38dHrB2h1+0nOMExLC8+fSGGH2kpKD0ejfVT9LrA4IaXv458ogbBOTYufRm8QXRnjrfcEqGrxo3c021g1VkzMJivRQVGai7cOGDbvxeMySbYb5pUpOclMzEriQH0rB+tamVWQSl5yPoHAaDYcbiDTnsv41AXUeg/zftU/cKSm40p1MnflpEG/qegqTI23hB0N62gNNjAtfSmeUCMH3Bup8uwj1ZGHXXNR3rqLoO5jbPI8ipPnkGzPZO32Sr759FsI8NfPnMKyyUZY8t9vXMSHhxtQClJdNkSEBk8AtzfIgjEZAxYV1FjdSkuTj1GTsihp8FDm9jG3MJVJswrZ/Nwunrv/A6x2C/OWjWXawiJe8v6DZ2uf4Itzv8qnx32GP//1n2xf4+X3t7wUPaayhVn+lUlcdsUyAA65D/KPvS+xvvw9NlZu4OELnmRs2rgBmd9A0KugUEpd3+H9dQMyGpNhga7C7Gh4nURrerf8BzButuUHGtj02n42/ncfdZUt2BwWZp81hlPOmcDUU4q6ZfKqYCvqo/8zEsrGX2KUrkifdMwRQEfDHwpT0xqgutlPTYufBm+w2xNQssPKxKwkcpMdWCNP5mkuG45Ib+2cJAfnT81D1xVJXcw5Fk2YmJXExKx2U0pbyGVVs480l40s12gmpJ7Gu0lbaWhoGFQh4Qk2sbfpfSo8u40uhVoCC3OviJqcclzj2O/+gCZ/Jb5wK6n2XGZmriDFnoNSil+/vJv/e30fMwtT+cOn5zGqQ0a7iET7QsSbkB5iX8MeJmdMjX5/Td4gO6qaSXZayU1ykJloRxOJOrKzx6WzqbSRrEQ7k7KT0ES47gfL2Lu5gvnLx2NP1rj9rVt5pe5lPjPzs3xu1g2ICF/72pXcMvEbbNm0H7tyMTllKrsTP+BnviO89t+FHGo6SFWkOOWo5NFcOP4SbNrICY2F2Gs93Q480NbXusu6fOAGpdRd8R6cydDkUPPHtATrOSXn0k6ZtxUlDXz4+gE+fO0AlYca0SzClAWFXPC5Bcw+q7jX0t1KD6G2/80oV+FMR237MwAy+uzjGp8/FCakK0SEQEinttVPbWuA2tYAzf4QAJpAVqKdaXlGiGNmgh2LJjHftBOOwembaLeS5LBS2exnco6RNTExdSGulJ3U1tUR0gPHXWSwrQ2tL9xCjfcgVZ79tATr0VUYhSLVnkO2aywp9iwCYR9B3YsmVmyag8ZAFYfcmwEoSJxCQeIUsl3Fnf5P+zL1/fq/e/jd6/u4YkERP7pkRlSQxoOQrrOjqhm3L0RIV1g1YVpuMhmR39CvN/ycf+x+kq/N/19Wz7ieymYfbx+sQ1cQblBsxfg/TnHaOLjhCKIJH/kDWO0WclMbuOude0myJzMhfRLJ85N58tBbvF36Fttqt3Dzgm9yzfTPRMciItx19o94f9p7LCxYRJI9mZZAC3/b+mdeKXmZmdmz+VzBQk7NX0hR8sCWHRkoYnVm/xB4CegmKICCyHpTUAxjdBUmEPYSVkF84VZqvCVUew9i0+xMTF0UfcIMhL3sbnyHLGcxOc5xHN5dw8dvHWLzGwepPNSICIyflcenLjuDuUvGkpxu+B2UUqiWcmg6gPI1GA1w7MlI6lhU7TZo3IdMuQZy5kL5O6iajyF7Vh8j7oxSipqWALtrmintEHKqlI6Iht2ikZVoZ1xGAlkdBMNAkZfkoKTBg67raK1VWJQiP7uQnYeO8Frpn0l15JHmyCPDUUS6I7+b4NBVmFrfYSo9e6n1Hiao+wmrIGEV7LRdij2H/IRJaJoVlKLeX8buxrd7GZUwKmkGk9NOx2VN6WWbzoTCOq2BMA++W8LvXt/HVaeM4sefmBnXvIF6T4D3Supx+0OkOKxYLUJ9IMyRRi/jMxPZXPsK/9j9JEm2TH676f/R6s0i3TqXFKeVJeOzsGpCVbOfek+ARl+I6gP1JOcnMz7Pzhvlj/HrtY/htDrQlY431N48qjCpiDvP/AkXjL+o25iS7MmcPebcDp+T+Or8b/DV+d+I27yHMrEKir5+BelA96whkyFFc6CWIy3bmZS2KHoT8oVa2NP0Lo3+StyBGhR6hz2EdEc+LcF63qt6igxHERbNRmNzHWXbwlTvSWfN+idprGlFswgTZuWx+NJpzF48hrQOyVKqtRJV8b5R7M4Xaa0pFiMxLNBslJsAKD6vvUxF0WKkaHGP89CVotkXoskXpNkfir7cviCBsMJu0RiTAR/Vvsqrh5/F7W/gJ4vvYUH+rJi0hTePrGNP/S40sRDSQxxyH+Rg4wFSHWmsKD6HZcUryHQdpQaRrkNrNdTthtpdULeH6dX7mFC7H9YcMkpo2BLJTP0PoRYrWc4imoJVVHsPRL55jWR7Fmn2PFzWZBr85dT5SgmrIBaxkeUcjdOShFWzY9Xs2DQnds1FhrMIl7V7m1Z/uBVvyI1dc2GzuKJaiEWs0e3DumLzkUZ2VLixWwSbReNwvYctpU3sqW6m1R/CEwjjD7X/Ri6bVxRXIaErxa6qZrZWunFYNZaNzyIvUksqENbZVuHmncNbeWzfzxmbPIv/XfBLfvHB13hk14+4eNwXScfP7z9qYHzaBGbnzGFm/ngsmoW15c24JgW5/b2rqPPVcfGES/nq/JtJdaRR3lxGc9DNmJSxuGy991M52ZHe+g6JyFJgeeTjbcDfgLIum7mAC4BWpdQp/TPEY2PBggVq48aNgz2MIYUv1MJbFY/iCzeT6xrPgpxPENL9vFv5JK2hRjIchaTac0mwpmDR7Ng0BxmOQuwWF8FQgE3b3mfz+j1Ub4GaXQo9CA6XjSkLCpl1ZjEzTh9NUqoTFWhG7fu30SvC6gJ/AzQdMARD+mSjdEbGFHCkGTH3egiaS42Wm1mdb+RKKVoCYZq8QZp8QdwRYdDkDRLu8JN1WTWSnTZSHFYyE+149BK++soNNAeamZIxlSZ/E43+Bn665FcsLDidg4372VG3gz31u9jfuI+Z2bP57MzP47S6+MNH/8fftv6503eXn1jA2LSxlLeUU9J0EItY+OSky/nihMtJrd0DZRug8iPwNRnz9taj3GVGnac2rE70tLFUanmo9PEU5OQib/2Y/ybcz7/XwK9fug5ngo2g7qfBV06dv5RGfwUN/krCyo9d0shPHIODQl7eovHarjoK011MzU8hO8mBLxjGFwzTGgjT6g/hsGqMzUqiODOB+tYAh+s9eAJhCtKcFKUnMLMwNepb2VHh5oG3DvDarmoavZ21ExGYmJPElLwUUpxWEuxWEh2GGS03xcH5M/LjopUppdhSvZt3Dh2kztOKy+FFs1RR1nKY0SnFrBx3AYVJhTy9+yke2/QkVouFRy5/jCxXFtWtVdz415to9DbRmlmN02kn2KJILRtNQn0WSd5MUvaOpWThGxQut3LTvJuZlTPnhMc8EhGRTUqpHouK9SUofohhUgIj4qmnX0QA2AF8RSn1XhzGesKcDILC1xqg9kgjGQUp0eqdvRHWg7xb+RTNwVqKk2dxwL2J0UmzaA7W0uSv4rTcyzvFyodDOuUH6tm3pZJ9H1eyb3MFLRFTTl5xGtNOK2LaqaOYMCcfW4cGSMpThdpyv9FYKCHPuGlqVqNqad6piL37k25HgmGdI41ealr9EeFg2KbbcNkspDispLlspLtspLpsJDus2DqUlCh1H+GzL16D3eLgF0v/H9OyplPrreXrr3yZfQ17sFns+CKmBpfVxajk0exp2E1eYj4T0yfzVuk6PjHxMr512q1I5Odut9ghHERVbqZ297PU7vk3abV7yA8ZN9UwwiFHIh57ApotEbcm7Ao1U22xcshqR7KnMnnM2RSmjCYYSGFnTT0uu5uvvH8XW+vO49G3F3HXU1eSmW98Py3+EBsO1vHkB0d4ZWcldquOL2ghI9GO2xskpCvmjEqjtsVPaUP3ntsum4VAWCes9x6kaLMIC4ozsFk03txbQ6LdwsoZ+SydnM38SGa0P6STk+wgMY5tQD2BcMQcFMSmCZXePaw7vJa3y16nwV+JhDUsAQeIQhLCFCQVUtpcSjgcJr1qNFk7ppNxaDyapjFuRi4FYzPY9v5h6iuNsiMWm0ZWfjJVR5qMO5amsKTqSFqAC26ewTlzlg16dNlQ5rgERZcD6MBCpdSGeA8u3ow0QaGUornOg781QMBnFGxrrjMqphTPzCVnTO9RJWEV4qOa/1Dh2cOC7E+QnziRnfVvsM9t/DfOy7oIh7uAw7trOby7lpKd1RzaVUPAazh8M/OSmDA7n8nzC5g0t4D03O5JUUoPGQXn9j5jhLbOvAE5Skhrm527JRCixR+izhOgtNFHWCkcVo1Up400l400p41Ul5VUp62TQOj2/QTclLeU8d03vklzoJm/nP8QY1LbQxNbg6388SOjoMC0rOlMzZzO6JRiNNH4qGoTP3vvR1TV7+FrE6/g0txTkcYSqN9nvOp2Q8MB0I3vhNRiGrKn8aK3gfVamKrkcVhtuTT5G2gKVBHWNTTfDFrc4xF7KVrCFrAfAtE7jfvzDdWcsS+PP265ibRrZtKUbOdwnYftFW7CuiI9wcZVp45m1Yx8dla6ef9APZmJdq46dXS0DlKTN4jbF8RpteC0aSTYrVg0IRjWOVzv4XC9h8xEO8WZiThtGpVNPkrqPLy7v5Z1u2to8ARYvaiYaxeOOe5Q1WA4iAhYO0T5eIMemvyteP0JVDT7cXsDlLdWUu05gifUiDtYxa7GN3DX1ZJ5aCJ51dNxVWQQ7lAIKLswhXEzc2mob2b/1krCXnAkWTnzwmlYbRrb3z9C+YF6piwoZMGK8TgT7RzYVkVlSQOjp2Qz/bRRjJ6c1WNtKpOeOWFBMdiIyErgXsCCEX31s962HSmCQilFY2ULZbtr8Da3u4CciXYyR6WSVZSK3WUzcg+CLUYP6Q6hpN5QMxurn6UxUMHU1CVkBqZRVdpExcEGdu/dRcPhMLUlXnytxpOxxapROCGDsdNzGTsthwmz8roJBqUUhDzgrQNPNarlCFRtMs6fmI/M+DxhezrekI43GMYbDOMJhPEEw3gCho27NWjYuZVSBHQP3lATfr0BXaugJVxKhjOJ2TlzmZwxBW/IS4O/gUZfPfW+euq9ddR566jz1VHrqaXWW0OdtwZ/2Ph+7JqT01N+wI5D6WQm2plZkMi8xHrypZqscBWOpr1Y63cj7lL8gQD+YIgE1UJSqAFLF6ewXxxUaIUcliIOUsR+GccuxyxqyKakvpWul40mkJ3sIDfZSV6qk5xI/4JgWMcTCNDgr6c5VEOyPRGbJNPs/RE/33GYX226la2zstHGpJKf6mJBcTqnjctkQXE6zmMspzEQ+EI+9jbsZmvNFt4tfYcPqzdiESvzcs5iYtpcttZ8wJa6twjqflyWFDKchbiba7EdSsXekkzI6UW3hBlTNh/bvhzQISMviUnzCsiKJBwGA2EObK3iwLYqklKdjJ+Vx6R5Bcw6sxh7Bw1H19XAF99TCrz1hjnVmWrY59qW+93QWmP4p3JngWN4tVCNq6AQkRygm71DKXX4+IZ31PNZgD3AOUAp8AFwlVJqR0/bD1dBoYd1QsEwAW+IxspmGiqa8bUGcNgD5Gtvk5wUwJo9CUtasfF0G/KiGvag6nbi8wRobrFS73FR3+qivtlBbYOiuU7D3WCjrs5GMNR+QbkSIL/ASmGxi8KxyYweaye/0ILNEjY0hHAA/I0of6NRbVQPgh5EQh5EtZeY0NFocE3ksGsO5ZYxtPhDVDf7qWryUN7YRGuwheQEndREHdF8eIMttIZqqA/tpC64k6Bq7fQdpCoruh6iWVPtF2AHRCmcuhN7IAFb0IE95MQVsuMIOXCGrdgDySQrK9PTdcZ7NzMj8CHJ0v6Y6ldWDqpCjqhcwlhw2Cy4VSIVwSRqSaVCZVOhsmhNKMKaUkBOipMEuxVHpKS0PxRG1xWT81KYOyqNMVmJ2CyCVdNIT7BhjfHpVVeKv29dT9Hfr+CJN3/A6u8tYc7ZE/AFw7jsFuw9HCesK4JhHV0p9MjXo4nhdLYe582yNdjK3vrd7G3YA8pGgjWbsG7hQNMO9jdupzXYCspKWIE31ERLsIFaXwV65DeQbi9kTPJ8ArqXfU3v4g+3khjMYoYsJbM1n5ayFrylCq08GfTOY0xMdXD6qsmcfuEUckalxj7ocNC4SbfVUmq7QQdajOsiHAQVBj0MgWbjxu2pNUyh4QAEvRBsNRpDJWRD6mhIzDa2j1xXBFoh5AOUsdxdamiWdXuhscTYH8DqBFem8dnfbJy3jc+9B6MWHtf/y2ARD9OThtF34gtAWk/bKKX65fEn0vPiDqXUeZHPt0bO99Oeth9IQaGUQilQuo4ejhRsCyt0XUfXFcFgmEAgRDAYwusN4PcE8XsDBLxBgr4QIZ9OOBBGDypUSBEO6YRCOsFgiEDITbIqwxWqoklLI+QJE2oO4PVptHoteLwWmj1WWlqthEPdbxROZ5i0dJ3UTCEjPUh+mpuCtGaycgK4EhRWgthVEFDGxaZU9H1QVzSFhfqQTmtYEVZhwipMazhMSzhIYzhIddBPXdCLrgcQFUAjiEUFsEkQKyGsKKxKYVMKK5G/kc+2sANLMAmbbsOqC8kqxES9hgIxoqJacFAjiViVwkEIJyGcBLETiv0/J20M4bFnU5s+nxprARUqG6+rAKvNTpLDyrSCFLIi1ULrWwNUun1kJtrJSLT3auaKJ2Fd8e+//Q+vPXQe9lO3cXjOIYJBH4lkkqJlYrM4QQujCBHwhAh5dHQ9jK4FCWthwpYAQWsARLDhxKEchPQgQRUgqAfQdT9KD6BhQcNoJoTooOkQCqJCIQgGsYQtWENWLGEr1qAVLWSDoAN7KB1LKBH8VvA7EH8C+JxomgVXgkZSggMtpBHyKYL+MKGgjj+gCATabwN2m6IgL8zkMV6mjW2gILWOliY/3pYABUkV2FSzcYP3u42XWIwe6FZHRBhYIjdvn/HyN0PYD4jRDMqeCJ66yLJjQDTjJh+Msei1ZoOMCZA5EdLHQWqxIRSaKwztwp4I9mRwZUBijiF4ihaCq38q4fYXfQmKWD1VNwNfAX6OITB+DOjA1ZG/vZqC4kAhcKTD51LgtHif5NWH/8hr/3RGO00qlHHfRKKu/Oi9NLJP9P5KxCyjjKdFIqUgjEqfoPpwLPaNYLT9AJsWwGUN4bJ6SbC1kmr1UOBqITm1hWRbMymORlLsTaQ7GkhzNOC0drl4WiOvrnFrPeAAciKveKKwgFhBfKC1gtjBagXNiXJMJewYDaLhCtYxOtQIYkU0O4gNxI6u2VGa09hPc0RedmN/cUY+u0BzgiURAkJmFWTiZwqlGD+dCB8TFTspkVcbxyCOToiLXOfxphYksGEGeRtmdFrX8Rdjj7wGGqfFS6KtlQSrhyR7BYmuFpTSaPUm4m124bT6cFk9OBx+rK4Qdi1AhquOHFc1uQmVZLpq0STSD7zcAZVOXG3/PwEnujhASwJLDiS6jFnrAeOldECPCAwbOGzgcqI0p6HVhltA90PqPJQlFSwuQDNeEvmrOSLrkiO/IWv0t4QIhL0QqjOOhSWyX9t6G8b1J8ZvCQ0CCqoFqtu+oayuNwFQQaAcy4VBpL102bAnVkFxPUZC3T0YguJfSqkPReRu4GUgPg0JeqYnvbrTnVdEbgRuBBg9+viGYklMIDvNaxRgkzbLh2r/i4r+FRQieuRnpEfeh9HQ0SSMoKOJsdwiQTRCWAhgxYdVAlg03XiJjsUSxmrRsWphrJYwtshni4DFqmOzBBEJ4LJrkdLFxlmN6A1joIKAZAAZIOPxouEVwbDaCSKa8V6M925fGF1pkeUaxkViQdMsWDQrVs2K3WbDYbOjaRYUFsJKQCzGPpoF0WzGMTVLdH80q/FXrJFX5CIXS+QCPXYTSawidjjGslhI4zPnfUxVdQuCjkVT2Cw6VouRVR6OPLS47DoJzhAWDYIhIRjWjL8h41dptSisWuQppu1JRjQUWqffslJCWNewaILFKlg0wWYVrBbBZtew2zTsdsFlC+O0hzvY/62gUhGVhBIt8n9qAy3b6N1tSQBrClgTIz29Q6B0FEJYxBDmEgeDg1EdEdXtP1t6+Cid10i3DSJ/JrWva4vtFM34qyILo9dah2Vt42lbTtuNI7LcNYKkBLGbnlqBVUqpN0QkACxTSr0TWXcJ8H9KqX4RFkPZ9GRiYmIyUujL9BSrMbaJdgd2OTC5wzorRse7/uIDYKKIjBURO3Al8Fw/ns/ExMTEpAOxmp4+AqYBayOvO0XEi2HO/THwYf8MD5RSIRG5KXJeC/BXpdT2/jqfiYmJiUlnYhUU9wBtGUw/BOYBj0U+HwJuiu+wOqOUegF4oT/PYWJiYmLSMzEJCqXUfzu8rxSRU4HxQAKwU6ku2UomJiYmJiOG4woYVwb7lFJbAE1Evh7ncZmYmJiYDBFiEhQikiVdqmmJiEtEbgFKgN/0w9hMTExMTIYAvQoKEXGIyL0i0gJUAXUi8qXIumuAA8AvgcPAyoEYrImJiYnJwNOXj+J24KvAKxhRTWOBe0VkGkaW9h7gRqXU8/0+ShMTExOTQaOvfhT7gJeUUjd1WPZZ4AHgv8BFSqnAgIzyGBCRGoxIrOMlC6iN03AGk5EyDzDnMhQZKfMAcy5tFCulsnta0Zeg8GNkY7/aYVkaUA+cr5Rae5yDGdKIyMbeshOHEyNlHmDOZSgyUuYB5lxioS9ntg1o7rKs7XNNvAdiYmJiYjI0OVoeRaGIjOvw2dJheWPHDZVSB+I5MBMTExOTocHRBMXTvSz/dw/Lhl47ruPj/sEeQJwYKfMAcy5DkZEyDzDnclT68lF85lgOpJR6KC4jMjExMTEZUgyLntkmJiYmJoNH//d8HGRE5K8iUi0i2zosmy0i74nIVhF5XkRSOqy7VUT2ichuETmvw/L5ke33ichvu2aqD7W5iMg5IrIpsnyTiCwfKnM51v+TyPrRItIiIt8cKvOIjOFYf1+zIuu2R9Y7h+NcRMQmIg9Flu9s6xMzFOYiIqNE5PXIuLa3lRgSkQwR+a+I7I38Te+wz5C87o91Lv123Rt9n0fuC1iMUe12W4dlHwBLIu8/C/wo8n4a8DFGN9CxwH7AElm3AViE0cPqRYwQ4aE8l7lAQeT9DKCswz6DOpdjmUeH9c8A/wC+OVTmcRz/J1ZgCzA78jlzGP++Pg08GXmfgFHKZ8xQmAuQD8yLvE/GSA6eBvwC+G5k+XeBn0feD9nr/jjm0i/X/YD+EAfrBYzp8uN30252GwXsiLy/Fbi1w3ZrI19sPrCrw/KrgD8N5bl02UeAusiFMCTmcizzAD6BUS7mDiKCYqjM4xh/X6uAR3vYfzjO5SrgeQzhlxm5gWUMpbl0GMOzwDnAbiC/w3e+O/J+yF/3sc6ly7Zxu+5HvOmpF7YBF0fe/w/GBQBQCBzpsF1pZFlh5H3X5UOB3ubSkcuAj5RSfobuXHqch4gkAt8B7uyy/VCdB/T+fzIJUCKyVkQ+FJFvR5YPx7k8DbQCFRj13n6llKpniM1FRMZgPGWvB3KVUhUAkb85kc2GxXUf41w6Erfr/mQVFJ8FviIimzDUubZSJD3Z7FQfy4cCvc0FABGZDvwc+ELboh6OMRTm0ts87gT+n1Kqpcv2Q3Ue0PtcrMCZwNWRv5eKyAqG51xOBcJAAYa55hYxcq6GzFxEJAnDZHmzUsrd16Y9LBtS1/0xzKVt+7he97F2uBtRKKV2AecCiMgk4ILIqlI6P5EXYfQIL42877p80OljLohIEfAvYLVSan9k8ZCcSx/zOA24XER+AaQBuoj4MC6aITcPOOrv6w2lVG1k3QsYPoFHGX5z+TRGLbggUC0i7wALgLcYAnMRERvGb+QxpdQ/I4urRCRfKVUhIvlAdWT5kL7uj3Eu/XLdn5QahYjkRP5qwG3AHyOrngOuFKPE+lhgIrAhoto1i8jCSKTAagxb4aDT21zEqMv1Hwzb6ztt2w/VufQ2D6XUWUqpMUqpMRgteX+ilPrdUJ0H9Pn7WgvMEpEEEbECSzBs/sNxLoeB5WKQCCzEsIEP+lwi5/0LRvfNjr1yngPa8sM+02FcQ/a6P9a59Nt1P5iOmQFy/jyBYUcNYkjVzwFfx3C+7QF+RsRZF9n++xhRD7vpEBWA8bS0LbLudx33GYpzwbioW4HNHV45Q2Eux/p/0mG/O+gc9TSs/k8i218DbI+M+xfDdS5AEkYU2nZgB/CtoTIXDLOewogwa/vtr8Jwur8K7I38zeiwz5C87o91Lv113ZsJdyYmJiYmfXJSmp5MTExMTGLHFBQmJiYmJn1iCgoTExMTkz4xBYWJiYmJSZ+YgsLExMTEpE9MQWFiYmJi0iemoDAxMTEx6RNTUJiY/P+NglEwCvACAJII52iCXwkAAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.set_loglevel(\"info\") \n",
    "\n",
    "FlowRatio = Dyn_MFA_System.FlowDict['F_1_0'].Values[:,:,:,0].sum(axis =1) \\\n",
    "    / Dyn_MFA_System.FlowDict['F_0_1'].Values[:,:,0]\n",
    "    \n",
    "FlowRatio[np.isnan(FlowRatio)] = 0  # Set all ratios where reference flow F_0_1 was zero to zero, not nan.  \n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for m in range(0,len(MyRegions)):\n",
    "    ax.plot(Dyn_MFA_System.IndexTable['Classification']['Time'].Items, \n",
    "            FlowRatio[:,m] * 100, color = MyColorCycle[m,:])\n",
    "ax.plot([1900,2020],[100,100], color = 'k',linestyle = '--')\n",
    "ax.set_ylabel('Ratio Outflow/Inflow, unit: 1.',fontsize =16)\n",
    "ax.legend(MyRegions, loc='upper left',prop={'size':8})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that for the rich countries France and Canada the share has been steadily growing since WW2. Upheavals such as wars and major economic crises can also be seen, in particular, for Hungary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8) Save data and results\n",
    "Save entire system: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump( {'MFATestSystem': Dyn_MFA_System}, open( \"Tutorial3_MFATestSystem.p\", \"wb\" ) )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}