diff --git a/MAIN.ipynb b/MAIN.ipynb
new file mode 100644
index 0000000..8f970b9
--- /dev/null
+++ b/MAIN.ipynb
@@ -0,0 +1,1349 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# <span style=\"color: red;\">1.</span> Wall structural behaviour\n",
+    "\n",
+    "This script reproduces the results of the shear-compression tests, focusing on the structural behaviour of the walls. Part of the results that are reproduced by the script are contained in the journal article: \n",
+    "\n",
+    "Godio M., Vanin F., Zhang S. & Beyer K. (2019) \"Quasi-static shear-compression tests on stone masonry walls with plaster: Influence of load history and axial load ratio\". Engineering Structures. https://doi.org/10.1016/j.engstruct.2019.04.041"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`Created by: M. Godio (EESD @ EPFL) on: August 3 2019 - \n",
+    "Last modification by: M.Godio on: August 9 2019`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Import libraries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section imports the Python libraries needed to run this script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#! pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Libraries have been imported\n"
+     ]
+    }
+   ],
+   "source": [
+    "# not used libraries\n",
+    "# import pandas as pd\n",
+    "\n",
+    "# libraries to import\n",
+    "# import math as m\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.io as sio\n",
+    "from matplotlib import rc\n",
+    "from scipy.signal import find_peaks\n",
+    "from tabulate import tabulate\n",
+    "from scipy.interpolate import interp1d\n",
+    "\n",
+    "# to install a library from the anaconda prompt, run a command of the kind:\n",
+    "# pip install mat4py\n",
+    "\n",
+    "print(\" Libraries have been imported\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Define classes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section defines the classes used in this script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Classes have been defined\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\" \n",
+    "These classe contain the test data from shear-compression tests:\n",
+    "F = horizontal force (kN)\n",
+    "u = horizontal displacement (mm)\n",
+    "N = vertical force (kN)\n",
+    "v = vertical displacement (mm)\n",
+    "ss = sampling step \n",
+    "\"\"\"\n",
+    "class Dataset_sc():\n",
+    "    \"\"\"Import the dataset contained in the -mat file.\"\"\"\n",
+    "    \n",
+    "    def __init__(self):\n",
+    "        \"\"\"Initialize variables.\"\"\"        \n",
+    "        self.dataset = {}\n",
+    "        \n",
+    "    def get_mat_sc(self, pwd, nameset, test_num):\n",
+    "        \"\"\"import mat file and create dictionary out of it.\"\"\"\n",
+    "        dataset={}\n",
+    "        sio.loadmat(pwd + '\\\\' + nameset + '.mat',mdict=dataset);\n",
+    "        for test in range(test_num):\n",
+    "            self.dataset['Test' + str(test)] = {}\n",
+    "            F = []\n",
+    "            u = []\n",
+    "            N = []\n",
+    "            v = []\n",
+    "            ss = []\n",
+    "            for dataId in range(len(dataset['TESTS'][0][test][0])):\n",
+    "                F.append(dataset['TESTS'][0][test][0][dataId][0])\n",
+    "                u.append(dataset['TESTS'][0][test][2][dataId][0])\n",
+    "                N.append(dataset['TESTS'][0][test][1][dataId][0])\n",
+    "                v.append(dataset['TESTS'][0][test][3][dataId][0])\n",
+    "                ss.append(dataId+1)\n",
+    "            self.dataset['Test' + str(test)]['F'] = F\n",
+    "            self.dataset['Test' + str(test)]['u'] = u\n",
+    "            self.dataset['Test' + str(test)]['N'] = N\n",
+    "            self.dataset['Test' + str(test)]['v'] = v\n",
+    "            self.dataset['Test' + str(test)]['ss'] = ss\n",
+    "        print(\"The dataset \" + nameset + \" has been imported.\")\n",
+    "        \n",
+    "print(\" Classes have been defined\")\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Define functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section defines the functions used in this script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Functions have been defined\n"
+     ]
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "This function gives an xy line plot on a defined domain\n",
+    "\"\"\"\n",
+    "def plot_one(setname,x,y,col,lab_x,lab_y,leg_lab,leg_pos,x_lim_lw,x_lim_up,y_lim_lw,y_lim_up,if_grid,f_size,x_size,y_size,if_show):\n",
+    "  \n",
+    "    rc('text', usetex=True) \n",
+    "    # change font gloabally\n",
+    "    plt.rcParams[\"font.family\"] = \"Times New Roman\"\n",
+    "    \n",
+    "    # plot function\n",
+    "    plt.figure(figsize=(x_size,y_size))\n",
+    "    plt.plot(x, y, color = col)\n",
+    "\n",
+    "    # config the graph\n",
+    "    plt.xlabel(lab_x, fontsize=f_size-1)\n",
+    "    plt.ylabel(lab_y, fontsize=f_size-1)\n",
+    "    plt.tick_params(axis='both', labelsize=f_size)\n",
+    "    plt.ylim([y_lim_lw, y_lim_up])\n",
+    "    plt.xlim([x_lim_lw, x_lim_up])\n",
+    "    plt.grid(if_grid)\n",
+    "    plt.legend([leg_lab], loc=leg_pos, fontsize = f_size-1, frameon = False)\n",
+    "    \n",
+    "    # save\n",
+    "    plt.savefig(setname + '.png',bbox_inches='tight')\n",
+    "    \n",
+    "    # show the graph\n",
+    "    if if_show == True:\n",
+    "        plt.show()\n",
+    "    else:\n",
+    "        plt.close()\n",
+    "        \n",
+    "\"\"\"\n",
+    "This function gives multiple xy line plots on the defined domain\n",
+    "\"\"\"\n",
+    "def plot_multi(setname,x,y,col,lab_x,lab_y,leg_lab,leg_pos,x_lim_lw,x_lim_up,y_lim_lw,y_lim_up,if_grid,f_size,x_size,y_size,if_show):\n",
+    "  \n",
+    "    rc('text', usetex=True) \n",
+    "    # change font gloabally\n",
+    "    plt.rcParams[\"font.family\"] = \"Times New Roman\"\n",
+    "    \n",
+    "    # plot function\n",
+    "    plt.figure(figsize=(x_size,y_size))\n",
+    "    for plot_index in range(len(x)):\n",
+    "            plt.plot(x[plot_index], y[plot_index], color = col[plot_index])\n",
+    "\n",
+    "    # config the graph\n",
+    "    plt.xlabel(lab_x, fontsize=f_size-1)\n",
+    "    plt.ylabel(lab_y, fontsize=f_size-1)\n",
+    "    plt.tick_params(axis='both', labelsize=f_size)\n",
+    "    plt.ylim([y_lim_lw, y_lim_up])\n",
+    "    plt.xlim([x_lim_lw, x_lim_up])\n",
+    "    plt.grid(if_grid)\n",
+    "    plt.legend([leg_lab], loc=leg_pos, fontsize = f_size-1, frameon = False)\n",
+    "    \n",
+    "    # save\n",
+    "    plt.savefig(setname + '.png',bbox_inches='tight')\n",
+    "    \n",
+    "    # show the graph\n",
+    "    if if_show == True:\n",
+    "        plt.show()\n",
+    "    else:\n",
+    "        plt.close()\n",
+    "    \n",
+    "\"\"\"\n",
+    "This function gives the test label\n",
+    "\"\"\"\n",
+    "def test_unit(i):\n",
+    "    switcher={\n",
+    "            0:'SC1',\n",
+    "            1:'SC2',\n",
+    "            2:'SC4',\n",
+    "            3:'SC5',\n",
+    "            4:'SC6',\n",
+    "            5:'SC7'\n",
+    "            }\n",
+    "    return switcher.get(i)\n",
+    "\n",
+    "\"\"\"\n",
+    "This function calcultes the envelope force-displacement curve starting from a cyclic one\n",
+    "input: u = displacement array\n",
+    "       V = force array \n",
+    "       oddindex = 1 for positive envelope\n",
+    "                = 2 for negative envelope\n",
+    "Note: the first peak in the negative envelope will be skipped \n",
+    "not to obtain me too high values of initial stiffness\n",
+    "\n",
+    "Created by B. Wilding (EESD @ EPFL) in Matlab format\n",
+    "Modified, and implemented in Python, by M. Godio (EESD @ EPFL)\n",
+    "\"\"\"\n",
+    "def fEnvelope(u,V,oddindex):\n",
+    "    \n",
+    "    # find peak position and value\n",
+    "    nPE, _ = find_peaks(u) #,height=0.05,distance=2)\n",
+    "    uPE = u[nPE]\n",
+    "    nPE = np.append(nPE,len(u))\n",
+    "    uPE = np.append(uPE,u[len(u)-1])\n",
+    "        \n",
+    "    # decide from where to start in calculating the envelope\n",
+    "    if oddindex == 1:\n",
+    "        startfrom = 2 - 1\n",
+    "    else:\n",
+    "        startfrom = 3 - 1\n",
+    "\n",
+    "    # calculate envelope only if input is cyclic response\n",
+    "    if len(nPE) == 0 or len(nPE) == 1:\n",
+    "        uE = u\n",
+    "        VE = V\n",
+    "    else:\n",
+    "        uE = 0\n",
+    "        VE = 0\n",
+    "        # take the origin plus the first valid point - only for positive envelope\n",
+    "        if oddindex == 1:\n",
+    "            uE = np.append(uE,u[0:nPE[0]])\n",
+    "            VE = np.append(VE,V[0:nPE[0]])\n",
+    "        for C in range(startfrom,len(nPE)):\n",
+    "            # if current peak > previous peak\n",
+    "            if uPE[C] > uPE[C-1]:\n",
+    "                init_pos_tmp = nPE[C-1]+1\n",
+    "                end_pos_tmp = len(u)-1\n",
+    "                ulap = u[init_pos_tmp:end_pos_tmp]\n",
+    "                if C == 1:\n",
+    "                    max_prev = uPE[0]\n",
+    "                else:\n",
+    "                    end_pos_tmp = C # this was C-1 and has changed to meet matlab\n",
+    "                    max_prev = max(uPE[0:end_pos_tmp])\n",
+    "                # look for first time value greater than peak ever seen\n",
+    "                for ulap_index in range(len(ulap)):\n",
+    "                    if ulap[ulap_index] > max_prev:\n",
+    "                        n_first = ulap_index\n",
+    "                        break\n",
+    "                    else:\n",
+    "                        ulap_index += 1\n",
+    "                        n_first = 1000\n",
+    "                init_pos_tmp = n_first + nPE[C-1] + 1 # nPE[C-1] in matlab\n",
+    "                end_pos_tmp = nPE[C]\n",
+    "                addu = u[init_pos_tmp:end_pos_tmp]\n",
+    "                addV = V[init_pos_tmp:end_pos_tmp]\n",
+    "                if init_pos_tmp == end_pos_tmp: # new part in Python\n",
+    "                    addu = u[init_pos_tmp:end_pos_tmp+1]\n",
+    "                    addV = V[init_pos_tmp:end_pos_tmp+1]\n",
+    "                uE = np.append(uE, addu)\n",
+    "                VE = np.append(VE, addV)\n",
+    "    \n",
+    "    return uE, VE\n",
+    "\n",
+    "print(\" Functions have been defined\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Define working directories"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section defines the working directories used in the script:\n",
+    "\n",
+    "<ul>\n",
+    "    <li><b>cwd</b> = current working directory </li>\n",
+    "    <li><b>where_to_import</b> = directory from where importing the dataset  </li>\n",
+    "    <li><b>where_to_save_pic</b> = directory where plots are saved  </li>\n",
+    "    <li><b>where_to_save_tab</b> = directory where tables are saved </li>\n",
+    "</ul>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Working directories have been defined\n"
+     ]
+    }
+   ],
+   "source": [
+    "# get current working directory\n",
+    "cwd = os.getcwd()\n",
+    "cwd\n",
+    "\n",
+    "# define other working directories\n",
+    "where_to_import = cwd + \"\\\\INPUT_DATASET\"\n",
+    "where_to_save_pic = cwd + \"\\\\OUTPUT_PLOTS\"\n",
+    "where_to_save_tab = cwd + \"\\\\OUTPUT_TABLES\"\n",
+    "\n",
+    "print(\" Working directories have been defined\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.1</span> Define wall properties"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section defines the geometry and material properties of the test wall units tested in shear-compression: SC1, SC2, SC4, SC5, SC6, SC7. The variable <b>test_number</b> gives the number of tests performed. The dictionary <b>wall</b> containing the following variables is created:\n",
+    "\n",
+    "<ul>\n",
+    "    <li><b>height</b> = wall height [mm]</li>\n",
+    "    <li><b>length</b> = wall length [mm]</li>\n",
+    "    <li><b>tickness</b> = wall thickness [mm]</li>\n",
+    "    <li><b>b</b> = wall aspect ratio</li>\n",
+    "    <li><b>H0</b> = wall shear span [mm] </li>\n",
+    "    <li><b>N</b> = axial load [kN] </li>\n",
+    "    <li><b>alr</b> = axial load ratio </li>\n",
+    "    <li><b>LH</b> = load history - for labels </li>\n",
+    "    <li><b>LHn</b> = load history - for plots </li>\n",
+    "    <li><b>density</b> = stone density [kg/m3] </li>\n",
+    "    <li><b>porosity</b> = stone porosity [%] </li>\n",
+    "    <li><b>W</b> = wall body weight [kN] </li>\n",
+    "    <li><b>fcm</b> = masonry compressive strength [Mpa]</li>\n",
+    "    <li><b>fb</b> = stone compressive strength [Mpa]</li>\n",
+    "    <li><b>fbt</b> = stone tensile strength [MPa]</li>\n",
+    "    \n",
+    "</ul>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Wall properties have been imported for all test units\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_number = 6\n",
+    "\n",
+    "wall = {\n",
+    "    'height': [900, 900, 900, 900, 900, 900],\n",
+    "    'length': [900, 900, 900, 900, 900, 900],\n",
+    "    'thickness': [200, 200, 200, 200, 200, 200],\n",
+    "    'b': {},\n",
+    "    'H0': [450, 450, 450, 450, 450, 450],\n",
+    "    'N': {},\n",
+    "    'alr': [7.5, 10., 15., 11.5, 11.5, 11.5],\n",
+    "    'LH': ['LH1', 'LH1', 'LH1', 'LH1', 'LH2', 'monotonic'],\n",
+    "    'LHn':[1, 1, 1, 1, 2, 0],\n",
+    "    'density': 2688,\n",
+    "    'porosity': 7,\n",
+    "    'W': {},\n",
+    "    'fcm': 10, \n",
+    "    'fb': 65.60,  \n",
+    "    'fbt': 8\n",
+    "}\n",
+    "\n",
+    "for test in range(test_number):\n",
+    "    wall['N'][test] = wall['alr'][test]/100*wall['fcm']*wall['thickness'][test]*wall['length'][test]/1000\n",
+    "    wall['b'][test] = wall['height'][test]/wall['length'][test]\n",
+    "    wall['W'][test] = wall['height'][test]/1000*wall['length'][test]/1000*wall['thickness'][test]/1000*wall['density']*9.81/1000\n",
+    "\n",
+    "print(\" Wall properties have been imported for all test units\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.2</span> Import test data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section imports the dataset related to the structural behaviour of the walls. Tha data is contained in the corresponding <b>TESTS</b> MAT-file and is imported in the dictionary <b>test</b> which includes the following variables:\n",
+    "<ul>\n",
+    "    <li><b>F</b> = horizontal - shear - force </li>\n",
+    "    <li><b>u</b> = horizontal displacement </li>\n",
+    "    <li><b>N</b> = vertical - axial - force </li>\n",
+    "    <li><b>v</b> = vertical displacement </li>\n",
+    "</ul>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The dataset TESTS has been imported.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sc_tests = Dataset_sc()\n",
+    "sc_tests.get_mat_sc(where_to_import,'TESTS',6)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.3</span> Plot horizontal force-displacement diagrams"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section plots the <b>F-u</b> diagrams for each test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwAAAAJ0CAYAAAClRUTtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xt0VNW9B/Dv5hHlYTgJF1BECjMQ0NUqThJfFUWd0bYXW6sZaH3d620zo17rsi3NEBVLfRQnah/Wq05iL5VaMWSsVXr7MINg0VqbzIC1aAHnREUD1pIcMApCyL5/zJyQx7znJGcy8/2slZUwc/bZv0nO0t/vnP0QUkoQEREREVFhGGV2AERERERENHxYABARERERFRAWAEREREREBYQFABERERFRAWEBQERERERUQFgAEBEREREVEBYAREREREQFhAUAEREREVEBYQFARERERFRAxpgdQL5TFEXOmTPH7DAoj3z88ceYMGGC2WFQHuE1RUbjNUVG4vWUumAw+C8p5ZRkx7EAGGLTpk1Da2ur2WFQHtm0aRMWLVpkdhiUR3hNkdF4TZGReD2lTgjxTirHcQgQEREREVEBYQFARERERFRAWAAQERERERUQFgBERERERAWEBQARERERUQFhAUBEREREVEBYABARERERFRAWAEREREREBYQFABERERFRAWEBQERERERUQFgAEBEREREVEBYAREREREQFhAUAEREREVEBYQFARERERFRAWAAQERERERUQFgBERERERAWEBQARERERUQFhAUBEREREVEBYABARERERFRAWAEREREREBYQFABERERFRAWEBQERERERUQFgAEBEREREVEBYAREREREQFhAUAEREREVEBGXEFgBDCIoQIZnmOpO2FEFVCCJ8Qwhv98gkhLNn0SyOHx+OBw+GAw+FAeXk5nE4nQqEQAEDTNNTV1aV0Hr/fD4fDAavVCqvV2nvOQCAwqL++ysvLoWmaMR+GiIiIqI8xZgeQCiGEAqACgANADYCMMyMhRA0AW5JjfABKpZTOATEEhRBuKWUgfmsayVRVhcPhgNfrhdfr7X1d0zRUV1ejsrISe/fuTXqeQCAAt9sNi8UCj8cDu93e71zr1q2D2+2Gz+eD3+/vVxBomoZQKISSkhLYbDaUlpZCUZTe9z/88ENMmTIFAFBaWgqfz2fERyciIqICkfMFgBDCDsADIASgEZHkvSLDc1kA1CY5pgrAEillSd/XpZSaEMINoEkIMVtKyduzeUhP/quqqvq9rigKmpqa4PF4UFdXh5qamrjnqKurg8fjgdfrjXmcoihwuVxQVRVutxuBQKBfgq+qau/P+lOHeBLFQURERBRLzg8BklIGpJQOKaVHSpk4G0rODSDZ3XsvgPp4sUR/TFhE0Mjk9/vR0dExKPnvy+v1wmKJPxKsvr4+YfLfl8VigcPh6JfwA5ECwOv1orOzE1LKQV8bN26ElBJVVVX9nlIQERERpSLnCwCjRO/sNwLoSHCMDYAFQEuCU7UCcBkbHeWClpYWVFQkf7jkdrtjvq7f0bfZbCnfma+qquo3PEiPw+Vy9XsqMFBdXR1qa1mHEhERUfoKogCIjt+vTOEJgp6JqQmOUQEonBCcf1RVHXQ3PpaBCbtOn8ib7l35gQWF1WpNmPy3t7cDAGy2hFNZiIiIiGIqiAIAkSE7q1I4rjL6PVEWGI5+Z/aVZyorK6GqKvx+f8LjbDYbrFZrv9c0TettF69AiGfg8S5X4gdM9fX1HPtPREREGcv7AiA6rKclxUm7ChCZ8JvgGP290mxjo9yiD7txOp1Ji4CBSbq+ik+6yT8QmRS8dOnSlI71eDxJCwQiIiKiRPK+AADgllImzuaOSiepjz9Gg0YkRVF6h+84nU6UlJT0rtKTbE3+lpbItJFEE4QTSeWOvj48afr06Rn1QURERATkeQEghHAhsqpPqtJJ6ienGQ6NAC6XC83NzbDZbNA0DfX19XA4HCgpKYHD4Yj7ZEBPzhON3c+Wx+PhxF8iIiLKWs7vA5Cp6MRfRUqZfFan8X27EF0paMqUKdi0adNwh0BZGDNmDB544AF0dXVh48aNCAaDCAaDCAQCCAQCOP/887Fy5cp+bT788EMAwLvvvjskf+8dO3agra0NW7duRVdXF68pMhSvKTIarykyEq8n4+VtAQCgVkrpGcLzx90OVkpZj+heAvPmzZOLFi0awjBoKC1evLj3Z3133xdffBF//etf+w3bOfPMM/Hiiy+iuLgYQ/H3/p//+R8sWbIEixYtwqZNm4akDypcvKbIaLymyEi8noyXl0OAomv+N2fQVIu2T2UcB3cCLjB2ux3BYBCKomDVqv6LSlVWRhaQSmUZ0VgStdNXGOKyn0RERGSEvCwAEFnzP9mOv7HoWViiycB6cRB3QzEamZKt/AMcnSisaVq/pF1f/UdfDShdPp8v7nv6OVPZpIyIiIgombwrAKLj76uEEMFYXwCWRI/r+5pOz+gSPQHQF4BPtqkYjTCNjY0pHacn+30LAEVRUFVVBSD9IkDTNEyeHH9OeXNzc28fRERERNnKuwJASlkvpbRKKctjfQFojR7X9zWdngEmWsvRAkAzY3IxDb10hvAMvCOvLyGq7wicqkAgkHD/gEAgwOSfiIiIDJN3BUA2pJQhRMb2OxIcZkd0gi/ln1SS91AoBEVRBiXlFosFPp8PoVAIdXV1KfWnaRpaWloSju/PdF4BERERUSwjtQAYytuh1QCWxJoIHJ1crAFYNagV5QW/34/6+sT1ncfjQUNDQ8z3XC4XvF4vPB5P0vPo50q0tr++AVlpKTeeJiIiImOMxALAAqS8Uk8spdH2MYf5RHcNXgegX4YX7c8LwCml5ApAecrn80HTNDgcDoRC/ad5aJqG8vJyVFVV9Y73j6WmpgbNzc3wer1wOBwx5wQEAgE4HA54PJ6Ew3t495+IiIiMlvP7AAghbDiajFtw9O5/mxBCz45WRRP3eOeoAlALoO84i3C0fUBK6e57vJTSLYSoEkL4cHS5TwWAg2P/81dlZSVcLhcAoKqqCl6vd9BEX6/Xm3C8vs5utyMcDsPv98Pr9cLtdkNRlN47+U6ns3dybyIWiwWKoqTUJxEREVEqcr4AiI7LL096YOJz+AEkX+MxyzY0svXd2Esfz5+tZE8LklEUBZ2dnVnHQURERKQbiUOAiIiIiIgoQywAiIiIiIgKCAsAIiIiIqICwgKAiIiIiKiAsAAgIiIiIiogLACIiIiIiAoICwCiHBYKhQZtSEZERESUDRYARDmsuroara2tZodBREREeSTnNwIjKlSapiEUCvXuTpwOv98Pn88Hi8UCAPB4PL0/ExERUWHjEwCiHFVfX5/RLsJ+vx/V1dVoamqC2+3GunXr4PF4hiDC3OX3++F2u4e8TV+BQADl5eWor6+HqqoAjhZxHo8nq3MTEREZiQUAUY7y+XwZJY3V1dVYsmQJFEVBY2MjNE0riLv/qqrC7/fD6XTC6XQOWZt49GTf7XbDarVCCIGSkhKUl5dD0zT4fL6szk9ERGQUDgEiykGhUAgdHR2w2+1ptfP7/dA0DeXl5QCA2tpaLF26FDabbSjCzBl+vx+NjY2orKxEQ0MD/H7/kLRJpqamBpqmQVVVKIoCi8UCt9tdEAUYERGNHCwAiHJQY2MjlixZklE7AL2Fg6IoeZ/8A0BVVVXaw6UyaZOMw+FIu2gjIiIabiwAiHJQfX09NmzYkHa7QCDQe+eZiIiIKBbOASDKMYFAAKWlpWnfudc0DZqmoaKiYogiIyIionzAAoAoDlVV+03ojPdltVoN7dfn86U1NMXhcMBqtWL27NkAgNbWVlitVlitVtTV1RkaGxEREY18HAJEFEN9fT3cbjcURYHdbofNZkMgEICmabDZbP3GeVdWVhrat9/vRzgcTvn45uZmAJG1/uvq6tDU1MRx6CYKBAL9dm8Oh8Pch4GIiHIKCwCiAerq6uDxeFBTUwOv19v7uqZpmD17NlRV7fe6kfx+P2w2W0bJop50cgiQeXw+H7xeb78CTFVVlJeXszAjIqKcwSFARH2oqgqPxwOXyzUoyVcUBbW1tb3rvQ+FTNf+ByJDfxRFgaIoBkdlnLq6uoTDqVL90jTN7I8yiM1mQ0NDw6DizWKxwOVyZb3PABERkVFYABD1oQ/7ibdpk57c6Tu9GknTNAQCgYyW/xwpE4Bramogpcz6KxeLHIvFEjeupUuXQtM0zskgIqKcwAKAKCoQCCRNwIci8dfV19fDbrdnlNy2trYCQEGs+T8S6YWjPl+DiIjITCwAiKL05CzREJyWlhYAGJIJnY2NjRkP/9GHJBk9IZlSl2hYkl7U6YUaERGRmTgJOA/ccsst2Lp1q9lhDIsFCxbgJz/5yZCcW0+iE91F1zfaMvpOu6qqCIVCGe9MqxcmfAJgDqfT2bt6E1f7ISKiXMcCgChKVdWEyZvf74emaXFXAFJVFYFAAM3Nzaitre1Nxv1+PzweT8KlPX0+H1wuV8ax68VLsuRT0zSsWrWqd+8CTdNQU1PTG2dHRweCwSB8Ph8CgQBUVYWmaWhubkZTUxOAyFAlIFJ0OByOtOLWV1jKVmdnZ07NA9A0LaV4cn2OBhERFQYWAHlgqO6IFxqLxYKOjo647/t8PiiK0pswx3rf6/UiHA5j1apVvQmzxWKBqqoJCwy/3x934nEqVFVNevc/FArB6XSiubm5Nw63241AIAC73Y6Ojg64XC6UlJT0vqcvWxkOh1FdXQ2Hw9H7+VVVhdVqxZIlS1JOxmtqauL+/kYym82GpqamuL+HQCAAIPHwMiIiouHCOQBEUQ6HI+7ynvX19QgEAtiwYUPM9wOBAJYuXQogksz3HYuvbxwWL/kPhULo6OjIeI34VNb/1zQNF110EXw+X28coVAI69atQ0VFRW8RoB9bXl4+qKAIBAJZPaUYbomKuWzaxLpGamtrsWrVqrhtPB4P7HZ7xkO8iIiIjMQCgCiqpqYGNptt0FKN9fX18Hq9CAaDce+y67sF63f6ByZ6Docjbr/ZDv/RJ5aWl5fHPcbj8aC0tLRfkWGz2XqH0ugFin6nemA8ra2tqK2t7fdaIBBIuPSlWfTJuOnsFZBqm7q6OpSXlw+6k68oCiorK+F2uwedQz9WfyJERERkNg4BIuojGAzC4/H0Jm0dHR2orKxMOH6/r3g7+SZKktetW4dgMJhVzAASPkFYt27doAQ+lubm5pjnCYVCaGhoGHRsrkw6DgQC8Hq9vQWY/lpJSQksFgtKS0sHLcGZSRubzQZFUWIWW1VVVbDZbPB4POjo6OgtBJxOZ1bDu4iIiIzGAoBogHiTfFMRK4EOBAJxh+f4/X6UlpZmtXKMvjJRvHPoE3lTSdb7DmXq+xoweIUhv9+fM+va2+32tIdQZdqms7Mz7vsWi4XJPhER5TwOASIykKqqg9biD4VCcZPvbNb+ByJDVlRVTbh5WWlpab/vsdr3jXVgUhyrqPH7/b1DhzRNg9/vz/gzEBER0fBiAUBkIH3FH53f74878VNPnNMZ/6+qKq666io4nU4AR8f/Jyoi9ER94CZUqqqivr6+98lBvDv9gUBg0BwGVVV7iwJ9B2MiIiIaGTgEiMhAPp8PHo+nd638ioqKuENz1q1bB7vdntYkWr/fj/b29t7x5frd+WTDe5qamvrFBUSKlb5LcsaavAxECpWBr7tcLrS0tMDv96f9GYiIiMhcLACIDGSxWFJe7cXn86U9/MdisaC8vLx37H19fX1KE4gVRUk6Nt3lcsV8GhFrArSiKFzVhoiIaITiECAiE6iqilAolPbyn1VVVZg7dy7cbjccDgeampqymkBMREREhYdPAIhMkEnyr3O73Vi0aJGxAREREVHBYAFAZIKqqiruCktERESm4BAgIiIiIqICwgKAiIiIiKiAsAAgIiIiIiogLACIiIiIiAoICwAiIiIiogLCAoCIiIiIqICwACDqw+FwwGq1oqSkBH6/3+xwBqmrq4PL5YLVakV5eXnMYzRNQygUGubIqFDxeiMiGnlYABD14fP54Ha7oWma2aHE5HK5sGzZMnR0dMQ95qKLLkJ5eTkCgcAwRkbDQdM0qKpqdhj98HojIhp5WAAQ9WGxWDLeoXc4KIqCsrIyVFRUxD3GbrdDURRYLJZhjIyGQ2tra87dbef1RkQ08rAAIBqBFEWJ+57X60VnZycTsjyUa3f/AV5vREQjEQsAIqIRoqmpyewQiIgoD7AAICIaAVRV5Th7IiIyBAsAIqIcp2kaHA6H2WEQEVGeGGN2AEQjkcfjAQBMnjwZ4XAYiqKgtrY27th8VVV7lxXdu3cvNE2D1+tNOJYfAOrr6xEOhzF58mQoigJN03DGGWfEPd7pdEJVVaiqioaGBlRVVfW+53A4oKoqOjo6et+rr6+HpmnYu3cvVFXF0qVL+7WJJRAIIBQKQVEU2O12WCyW3rvTmqbBYrH0niMQCMDpdMLr9WY9uTpZ/KFQCG63u7fvUCjUe8c8HA4DiKzylEiqf1ejfpep9FdfX4+mpqbe1zweT7/P4fV6YbPZsvosb7zxBj755JO0P0ui662vuro6tLS09M4TmDx5MmpqahL+boiIaAhJKfk1hF9lZWWSRpbOzk4JQDY1NQ16LxwOS5vNJpubm/u9HgwGpc1mk8FgMGabmpqafq81NzdLRVEGnadvDHa7XXq93kGvL168WNrtdmmz2WK28/l8MePv7OyUXq+3972amhrZ2dnZL04ACWOy2WzS5/P1i7Gqqqr3tebm5n5x6f25XK6Y50xHOvE3NzcP+vxVVVUxf2d623T+rtn+LjO5joLBYNzrMtvP4nK5Mvosia43nd1uH/T3D4fDhlwTlLs2btxodgiUR3g9pQ5Aq0whPzU9Qc73LxYAI0+iAsBisfQmuwPpSX3f5ElKGTfRcblcUlGUmO/piXUs69evlwDiJrPJChgA0m63y3A4POh9m80m7XZ73JgGvpeoL128JDgTqcY/sHDS4wAQs10mf9dsfpeZ9JdqAZDJuX/1q19l/FkSXQOJiq5YRRrlDyZsZCReT6lLtQAYcXMAhBAWIUQwjeO9QoigECIc/WoSQgx+Xj64XZUQwhdt743+zHXuClhdXR1UVY07lMVut6O0tLR36IWuvr4+5q69Docj5sZOfr8fgUAAtbW1MfuZOHFizCEfqSgtLQWAuOu268N5BtKH+Didzn6vK4oCm82GVatWxe3TbrdnFGssqcQfCARiDkXRjx+4jn6mf9dMf5eZ9peKTM9dXFwMIP3PkkgoFILf7495HYdCITgcDjQ3N6d1TiIiMsaIKACEEIoQwi6E8AIIA0iaiEcLhSYAjVLKcimlFYCehQWj54rX1gdgqZTSLaX0SCk9ADwAmoUQxmUzNKL4fL6kyazdbkd9fX2/12w2W2+y2JeeaA3cdVhPphMl+bHOl454a7aXlpbG3GVYT5pjtSstLR32zakSxZ/o/Vgy/bumEkus32W2/SUy3J8lEf06jleMKYoCq9Wa1jmJiMgYOV8ARBPuJgAOAI0AUl0HzwugWkrZm5lIKTUppROAH0CNEGLQbTIhRBWAJdHj0LctADeAJiFE4pmblJdUVU06aVd/v+/d0mAw2O9Op343vbGxEQAGJVahUGjIN1VKN/HSP9fAYkU33JtAJYo/2d9ooEz/rqnEMhT9DeW5jUzI9Yni8WLo7OzkRGAiIpPkfAEgpQxIKR3RO/Ep3WaMFg3N0aQ9luro91hLgngBxLw9JqXUi4/YYzMob+l3uFO98z4wuQoEAnC73XA6nQgEArBYLFi6dGnc9ukmsUNNv6vc0tIy6L3W1lZDh/kMp2z/rrnU33B/llTOz92BiYhyU84XABlyJnozWhiEgN5iAdGfbYgMLxqc5RzVCiC79QxpxNETmVSHQfRNfDweD5xOJ5xOJ5qamuByuRImRvpyn7nG5/P1Lg+p04eSeL1xR9TltGz+rrnSn7687HB/lmRy9TomIqL83QfAAsAlhLBGx+/HogLQE36dvc978agA7EIIi5RyaG+hUc5QFAWKoiS9a6q/rydXfr8fdXV1KY3N1jQNiqKgoqICra2txgRuIE3T0NTUBI/H0ztUJBwOo62tLeeeWKQq079rLvXX0tKCqqqqYf8syVRUVHDnYiKiHJWvTwCaAWhIfCdfz1j6/t+yMsZrA4Wj3zNbhoVGLJfLhVAolPCupt/v7zfpUZ8IuWTJkkHH6omYfr5AIABVVeF0OmOuDhSr7XBqaWmB3W6Hz+dDTU0Nampq4PP5Rmzyr8vk72pGf6n8nof7sySi71ycaII4CwQiInPkZQEgpayTUpZIKf0JDquIfu97q1WJtk/03Fp/L7tlWGjE0XfujbeCij4Uo6GhYdB7sZI3PYnXh2x0dHSgtLQULpcLNpst7rCa9vb2ISsAEg0f6buzbjqGc4WgdFeqAbL7u2YSS6b96XfsE/3th/uzJFJTUwOLxZJwOVMuA0pEZI68LACSiY77VwD4ByT76ST1I/u2J8XVNyEfKBgMwufz9SZSulAoBI/Hg+bm5n7Jvr4G+sDjA4EAbDYbLBYLgsHIthb6ECAAaGpqQmtr66B2qqpi/fr1sNlsUFU1ZjKYKH79tXh3iBPdOfb5fHA4HBBC9PuyWq1wu90xi4O6ujqUl5fD7XbHPW86solff8+Iv2u2sWTSHxC5w+/zHV27IBAIDJpMnsm59+/fn/FnSXS9NTc3Q1XVmEWAx+OJu9cFERENLRHZNGzkEEI0A6iQUpZkeQ47AGvfcfxCiDAAi5RSJGjrQmT1oLp48wuix7gAYMqUKeXr1q3LNFQaZi6XC7t370ZXVxcAYPr06fj+97+PsrKyfsf5fD4UFxf3Jk4AcNVVV2HixImDzhkMBrF27VqccMIJmD59OgCgrKwM5eXlaG9vx8qVKzF9+nRceeWVMfsBIhs16ee+4IILsHLlSmzfvh3FxcWw2Wz47ne/Gzd+n8+HiRMnxnzvO9/5DsrLy7F27Vr89re/RXt7O4DIZmPl5eVYuXIlAKCrqwv3338/5s2b1y/Grq4utLe3IxgMIhgMYvHixb2x6J995cqVcLlcuPTSS9P5UwySafxdXV34zne+Y+jfNZvfZSb99fXAAw9g9+7dKC8vx8SJE+P+XtP5LO3t7fj444/T/iyJrreBsXR1dWHixIm9m459/etfj/sZaeTT/95ERuD1lLoLLrggKKWsSHZcwRUA0XX+mwA4Bw4RMqoA6GvevHly+/btmYRKFNOmTZuwaNGiYe3TarUmncgcCATgcDgQDAYz3qmYzGHGNUX5jdcUGYnXU+qEECkVAAU1BCi6gVcDAE+S+QGp2GtASEQ5Tx9KksoOs3a7nRM7iYiIclxBFQAANgBYJaWsi/O+BvQWCslwgWuiGEb6qkBERET5rmAKgOjQocYEyT9wdPnPRJOB9ewm/WUxiEagqqoqqKqadDUfVVXR2toac8lTIiIiyh0FUQAIIXwAmpMk/8DRAiDRLUxr9PvwrW1IZLJgMAin0xl3eE8oFILD4UBTUxOfABAREeW4fN0JuJcQogaAFiv5jw71qZBS6llNI4AaRHYHjpfgW6Ln4y7AVDBsNhvC4TDq6+vhdruhKAomT56MvXv3QtM0WK1WBINBJv9EREQjQF4XANEVfyYnWK3Hjj5j+aWUISGEBsABIN4kYTuAZE8SiPKSy+UyOwQiIiLK0kgdApT0NqMQwgagMslSnZXovxMwAFQDWBJrInC0oNAArEojViIiIiKinDESnwBYgMjwnQG7+PYSQlgQWfGnNTr5N955LAMLBCmlXwjhQGS5UGefcyoAvIjsH8AVgIiIiIhoRMr5AiB6J78h+k8Ljt79bxNC6OPwVw1Y198XPS7xwuVxxvlLKd1CiKro5GE92VcAODj2n4iIiIhGspwvAKSUIQDlabZxGNCvH/HnARARERERjUgjdQ4AERERERFlgAUAEREREVEBYQFARERERFRAWAAQERERERUQFgBERERERAWEBQARERERUQFhAUBEREREVEBYABARERERFRAWAEREREREBYQFABERERFRAWEBQERERERUQFgAEBEREREVEBYAREREREQFhAUAEREREVEBYQFARERERFRAWAAQERERERUQFgBERERERAWEBQARERERUQFhAUBEREREVEBYABARERERFRAWAEREREREBYQFABERERFRAWEBQERERERUQFgAEBEREREVEBYAREREREQFhAUAEREREVEBYQFARERERFRAWAAQERERERWQMUacRAgxC4AFgAKgFIAVwF4AKgANQIeUcqsRfRERERERUeYyLgCEEJcDcAOoAFCCaKIf/a7TCwJFCCEBhAAEAPiklG9n2jcREREREWUmrQJACFEMoA6AE0ArIsn8cgCqlHJfkrazAdgAOAAEhBCdADxSyhcyCZyIiIiIiNKXcgEghPgeABcALyKJe8KEfyApZRuANgBPR89nA7BcCOEBUCWl/Cid8xERERERUfpSKgCEEOsAhKWUc43qWEoZArBECGEHsFEIUcOnAUREREREQytpASCEeBSRO/5tQxGAlDIAoEIIca8QgpOFiYiIiIiGUMJlQIUQp2MIk/++pJTLAUwe6n6IiIiIiApZwicAUsotwxVItL8Nw9kfEREREVGh4UZgREREREQFJKUCQAhx4VAHQkREREREQy/VJwBNQxoFERERERENi1T3ASgRQvwQwL3Zdiil3J/tOYiIiIiIKDPp7ATsBCAAdKTRRiKysk+N/oIQwi+lXJrGOYiIiIiIyCCpFgAagPJ0794LIa4AcCsihYMGoFpK+XR6IRIRERERkVFSnQMQSCf5F0LMEkL8EcA6AAoAr5SylMk/EREREZG5UnoCIKVckuoJhRCrEBnyIwAEALiHYyMxIiIiIiJKLp05AAkJIS4H0ACgBBzuQ0RERESUk7LeCKzPcJ8mRJL/Og73ISIiIiLKTVk9AeBwHyIiIiKikSWjAoDDfYiIiIiIRqa0hgBFh/u0gMN9yCRHjhzBvn37cOTIEUgpzQ6HiIiIaMRJ+QmAUcN9hBDLpJT3p9uOCtM777zq0UzvAAAgAElEQVSDjRs3YsuWLdixYwdef/11tLe349hjj8WcOXNQVlaGBQsW4LLLLoOUEhMmTMCsWbMwalTW01uIiIiI8lJKBYAQYicAC4A2AC4p5QtZ9FkLgAUAxbV161asXbsWf//73/GHP/wBPT09GDduHE455RScffbZmDt3Lvbv34/f/e53ePXVV/H0009jxYoVve2nTp2KSy65BN/97ndx2mmnmfhJiIiIiHJPqk8ArADCAJYDUKJzADJxPSIbg2VMCGEB0CSlLE/x+CoADkTmKgBHNyZTh6IdZebQoUN48cUX4fV6sWHDBowdOxYzZ85ETU0NrrrqKlitVowbNy5m27a2Nrz88ss49thj0dnZiU2bNmH9+vV48sknsXXrVnz2s58d5k9DRERElLtSLQA0AE5Ehv9kqhTAvkwaCiEUABWIJOQ1OJqUJ2vnA1AqpXQOOFdQCOGWUgaMbEfpa21txfr167F69Wrs2rUL48ePx49+9CP8x3/8B0pLS1M6x+zZszF79uzef1dXV2Pnzp0oKyvDn//8ZxYARERERH2kWgCoUsqtBvS3QQjRkU4DIYQdgAdACEAjABsixUCydlUAlkgpS/q+LqXUhBBuAE1CiNlSSs2IdpSe1157DTfeeCNeeeUVSCnx+c9/Hg899BAWLlyIkpKS5CdIwmq14thjj8WOHTsMiJaIiIgof6RaAPgM7NOTzsHRu+29d9yFSPkhhBdAfbxzRs9TGyOeTNtRCv7yl79g9erVWLduHcaNG4eVK1fi5ptvhqJkNTJskFGjRmHOnDksAIiIiIgGSGmpFCllg1EdGnmueIQQNkQmLbckOKwVgMuIdpTYnj17cMstt2Dy5Mk4++yzsXbtWlx44YX405/+hDvuuMPw5F9XVlbGAoCIiIhogGFfK1EIsWwYurFHvyeasKsiMqHZYkA7iqGtrQ3f/e53YbFY8NBDD+Hiiy/G/fffj/b2djz99NOYM2fOkPZfVlaGcDiM7u7uIe2HiIiIaCTJaCfgvoQQVwCYncba/sOxDGhl9HuiRD4c/W7rc1ym7aiP3bt345ZbbsG6deswatQoXH311VixYsWQJ/wDlZWVobu7G2+//faw901ERESUq4x6AuBI5SAhxPPIchnQFClAZOJugmP09/ouNZNpOwLQ09ODRx55BPPnz8ezzz6L22+/HW+99RYef/xxUxLwsrIyAMDOnTuHvW8iIiKiXGVUAWAXQnw13ptCiAuFEHtxdIjNUEsnOe9bkGTaruCpqopzzjkHN954IyorK/H666/jrrvu6rc853CbO3cuAHAeABEREVEfRhUAAkCdEKJ40BtCPILIKj5tiOwlkNFeAGlKJzmfbEC7giWlRENDAxYuXIgdO3bgl7/8JZqbm3uTbzNNmTIFkyZNYgFARERE1EfWcwAQWZ+/XEq5RQjxqBCiRkq5XwixAEATIrsIu/XVf4QQeb+JlhDChehKQVOmTMGmTZvMDWiIHDlyBA8++CCee+45zJs3D3feeSdmzJiBF1980ezQep1wwgl49dVX8+pv0NXVlVefh8zHa4qMxmuKjMTryXhZFwBSyrY+P18fLQI6cXTzLuuAY4bjCUA69hrdTkpZj+heAvPmzZOLFi3KsIvcdeDAAVx55ZV47rnnUFtbi3vuuSedPRqGTXl5OTZv3ox8+hts2rQprz4PmY/XFBmN1xQZideT8YZiGdDliAz1qZFSVvRN/gFACDFrCPocSIv2lcqQHm3gzxm0KyidnZ24+OKL8eyzz+LBBx/ED3/4w5xM/oHIROBdu3bhwIEDZodCRERElBMMLwCiK+hUIDL0J5Ymo/uMQV+eM9GkXj3J7zCgXUHo6enBT37yE8yZMwd//etf8dRTT+Fb3/qW2WElVFZWBiklwuFw8oOJiIiICkBKQ4CEEBdmcG5VCNEIwNfnNQWRnXaHmp7IJ7qTrxcoIQPaFYQf//jHWLZsGS655BLcfffdqKioMDukpPquBPTZz37W5GiIiIiIzJfqHAA/gEmIrPaTLueAf8sMzpGuRgA1iBQb8RJ1CwBNStl3M69M2+W9hx56CLW1tfjKV76CZ555JmeH/AzEpUCJiIiI+ku1AOhAZFJrI7Ib+14CoDmL9imRUoaEEBoiG5T54xxmB1BnRLt8d8899+D222/H4sWLsXr16hGT/ANAcXExjj/+eBYARERERFGpFgAqgB9KKfdn2V+bEKIt+WFJpTJJtxpAgxDCM3BnXyFEFSKFzCoD2+Wlu+66C3fccQeuueYarF69GqNHjzY7pLSVlZVxN2AiIiKiqFQnATsNSP51F2XZ3gIkX6lHSukHsA5AQ9/Xo+28iHymQU8zMm2Xb3p6evD9738fd9xxB6699toRm/wDkQKATwCIiIiIIlJ6AmDk2v3pnksIYcPRZNyCo3f/24QQ+jj8VdHEfWBfbiFElRDCh6NDlxQAjkRj+DNtly/2798Pp9OJ559/Hv/5n/+Jxx57bMQm/0CkAPjnP/8JTdOgKOls9kxERESUfxIWAEKI0wF0SinfHo5ghBCXSyl/3fc1KWUIQHmm54wWBvHG8xvebqTr7u7GFVdcgU2bNuGRRx6B2+0eUWP+Y9EnAu/cuROVlZUmR0NERERkroRDgKSUWwBcL4RYMNSBCCEeQQEurZlrbrvtNgQCAdTX1+P6668f8ck/EHkCAHAlICIiIiIghTkAUsrliBQBjwghjjM6ACHEFUKIFgC+4XrSQINJKXHDDTegrq4Obrcb1113ndkhGcZqtUIIwQKAiIiICClOApZSXg9gA4AtQohVQojibDuOJv6tiCyraZdSbs32nJS5hoYGPProo/j2t7+Nhx56yOxwDHXMMcdg1qxZXAmIiIiICKkvA9o7Jl4IUQPgbSFEGEAAkXX91UR376MFgwVABYCLEVkJKACgOjrMiEz00ksv4aabbsLFF1+M+++/H6NGpbo41MjBlYCIiIiIIlIuAHRSyjoAdUKIixDZ5bcegEUIIXF0xZyO6PdSHF21Zx+AVgBNiCT+hq0sRJlrb2/H5ZdfjlmzZuGpp57Ky+QfiBQAf/7znyGlzIt5DURERESZSrsA0EkpNyAyLAgAIISYjUiyb0Ek8e9ApCDoAKBJKY3YAIwMtHPnTlx55ZXo6urCiy++iJKSErNDGjJz587FRx99hA8++ADHH3+82eEQERERmSbjAmCgPgk+h/SMAPpyn+FwGA0NDTj55JPNDmlI9V0JiAUAERERFbL8HO9BSa1YsQKvv/46fvnLX+Kqq64yO5whpxcAnAhMREREhY4FQAFqbGzEvffeC5fLhcsvv9zscIbFzJkzUVRUxInAREREVPBYABSY999/H9XV1TjnnHPws5/9zOxwhs3o0aMxZ84cFgBERERU8FgAFJhvfetbOHz4MNasWYOioiKzwxlWXAqUiIiIiAVAQXnmmWfwzDPPYOXKlbBarWaHM+zmzp2Lt956C0eOHDE7FCIiIiLTsAAoEPv378dNN92E0047Dd/5znfMDscUZWVlOHToEN59912zQyEiIiIyDQuAAnHrrbdi9+7daGhowNixY80OxxRcCYiIiIiIBUBBeOWVV/Dwww/j5ptvRmVlpdnhmKbvXgBEREREhYoFQJ47dOgQqqurMWPGDNx1111mh2OqadOm4bjjjmMBQERERAXNsJ2AKTfdd9992LZtG9avX4/jjjvO7HBMJYTgSkBERERU8PgEII+98847uOuuu7BkyRIsXrzY7HBywty5c1kAEBERUUEzrAAQQlwohPijEGKvEKJ7wHvVQohlRvVFqbn77rshpcQDDzxgdig5o6ysDO+88w4+/fRTs0MhIiIiMoUhBYAQ4lEAAQCTAWwA8ELf96WUDQAahBCrjOiPktu+fTtWr14Nt9uNGTNmmB1OzigrK0NPTw9UVTU7FCIiIiJTZF0ACCGqAVgAWKWUFVLKJQCaBh4npdwH4F4+CRget912G8aNG4fbb7/d7FByClcCIiIiokJnxBOAcinlxVLKtj6vyVgHRouAfzOgT0qgtbUVTz/9NJYtW4apU6eaHU5OmTt3LgAWAERERFS4jCgAwmkeH7M4IOPU1dVh0qRJ+Pa3v212KDlHURRMnTqVBQAREREVLCMKgNI0j7cY0CfFEQ6H8fTTT+P6669HcXGx2eHkJC4FSkRERIXMiAKgRAjxmQGviVgHCiEuB9AW6z0yxr333osxY8bg5ptvNjuUnDV37lzs3LnT7DCIiIiITGFEAbAcwAYhxDf6vDZomI8Q4l4AXinlcgP6pBhaWlrw2GOP4b//+78xffp0s8PJWWVlZdi9ezc++ugjs0MhIiIiGnZZ7wQspdSEEEsABIQQ9QBUABBClCMyPMgCwBZ9/eJs+6P4HnzwQRQXF+MHP/iB2aHkNH0loJ07d8Jms6Xd/vDhw9ixYweeeeYZTJw4Ea+88gpmzpyJDz74AEVFRZg3bx7+9a9/4fjjj8fMmTNx4MABfPzxx1i0aBH++c9/YvTo0TjllFOwc+dOHDhwAJ9++ina29tRVFSE7u5utLe3o7OzEzNmzMAbb7yBgwcPYsKECRg7diw++ugjzJkzB5MmTcLpp59u9K+GiIiICkDWBQAASClDAEqFEF4A1QAUANbo2yqA+3jnf2hpmga/34/rrrsOxx13nNnh5LRZs2YBAN59910cPHgQoVAIH3zwAXbs2IGdO3eis7MT8+fPx6mnngpVVREOh9HZ2QmHw4F//etfWL9+Pbq7j+51pygK9u3bhxkzZuDjjz9GR0cHxo4di8OHD2cc45gxY9Dd3Q1FUTBhwgR8/PHH+PTTTzF69Gh0dXVh+fLlWLBgAU4++WR85StfwZe//GWMGzcu218NERERFQBDCgCdlNIDwCOEmATAIqXcYuT5Kb61a9fi4MGD+MY3vpH84ALX09MDAHj66afx5JNPoqenB6NGjcLs2bMxd+5czJs3D2+88QY2bNiAKVOm4PTTT8fMmTOxZs0ajB8/HjfddBMWLFiACy64AF1dXZg1axaKioowZswYSCnR1dWF8ePHY9euXfjoo49wzDHH4PDhw3jppZfwmc98Bt3d3fj73/+OWbNmYcqUKRBCYPr06eju7sbYsWMxbdo0TJgwAe+++y4sFguEODqlRtM0+Hw+9PT0YNOmTXjhhRewdu1ajB07FkVFRfjmN7+JL33pS7BarbBarfF+BURERFTAhJRclXMozZs3T27fvn3I+ykvL8eRI0ewZcuWfgkjDfbyyy/j3HPPBQCcccYZ8Pv9mDZtGoqKivodd/jwYYwePRqjRhmyYbZhNm3ahEWLFgFAbyHwxz/+Ebt27UJTUxO6u7sxZswYuFwuXHPNNTjzzDN5TVBCfa8pIiPwmiIj8XpKnRAiKKWsSHacYZmNEOIKIcQjQojvxnjvIiHEKiEE16UcAlu3bkUoFMI3v/lNJnopOHjwYO/P11xzDU466aRByT8AjB07NueS/4FGjRqFCy+8EF6vF08++STee+89bNy4EVdffTV+/vOf4+yzz4bT6cSTTz6JV199td9nJyIiosJkSHYjhHgEgAbADeDWge9LKTdIKWtjvUfZu/XWWzFhwgRceeWVZocyInz66ae9P5911lkmRmK8adOmYdGiRVi9ejU++OAD3HnnnXj22Wdx1VVX4ayzzsLs2bNRX1+P999/3+xQiYiIyCRZFwBCiGUA6qSUGwCUI8FGX1LK5dHjySCvvPIKfv/732PlypUoLU13T7bC1LcAOPXUU02MZGhNmjQJK1asgKZp2LZtG/x+PyZOnAi3242TTz4Zy5Ytw+7du80Ok4iIiIaZEU8A/k1K2QYAUsotUsp9SY7nGBUD3XfffSgpKcH1119vdigjhl4ATJw4MebQn3wzYcIEnHLKKbjiiivwxhtvYOvWrbDb7XjwwQdx1lln4Q9/+AOOHDlidphEREQ0TIwoANKdRczb1AbZsWMHfvOb3+DGG2/ExIkTzQ5nxNALAH0/gEIyduxYnHbaafj1r3+Nv/zlLxg1ahS++MUvYvbs2XjggQfw1FNP4c033zQ7TCIiIhpCRiwDGnfITxyKAX0SgB/96EcYO3YsbrrpJrNDGVH0ibCFvkymzWbDm2++id/85jd48MEHsWzZ0dF5U6dOxezZs3HiiSfik08+wUknnYTi4mKceOKJOOmkk3D++eejs7MTU6dORXFxMT755BMWoURERCOEEQVAqxDiESnlDckOFEKsQmSyMGWpvb0djz/+OK699locf/zxZoczonz44YcAWAAAwLHHHouvfe1r+NrXvoZ3330XmqbhhRdewLZt29DW1oY33ngDY8eOxaZNm9DT04NDhw4NOsf48eNx4MABXHvttfjFL34x/B+CiIiI0pJ1ASClvE8I0SyEaAHwQynlMwOPEUIsAOBFZHOwudn2ScCKFStw5MgRLF/ODZbTpaoqAMBiSffhVX6bOXMmZs6cGXNidE9PD4QQ6OzsRCgUwt///ndMnjwZu3fvxq5du/DPf/4Tjz/+OG699daCHFpFREQ0khiyE7CU0iGEaALwtBBCInKXX0VkuI+eZbUBcBjRX6H729/+htWrV+Pb3/4272JnIBwOA+ATgHTo+yGUlpbCbrfDbrf3e/+9997DunXr0NTUhNtuu82MEImIiChFhu1yJKV0AqgA8GsAnYgsCToZwAYAy6WUc/TVgig7Dz30ECZMmIDbb7/d7FBGJL0AmDVrlrmB5JEZM2bg85//PNatW2d2KERERJSEoducSilDUkpnNNkfJaUslVJeLKW8z8h+CllPTw/Wr1+PL33pSygpKTE7nBFJ3wRr2rRpJkeSX5xOJ/72t79hx44dZodCRERECRixEVixEGKZEKLYiIAosZaWFuzZswdf/vKXzQ5lxBs/frzZIeSVL3zhCwCAl19+2eRIiIiIKBEjngD4EZng6zLgXJTEc889h9GjR+OLX/yi2aGMeEJwTzojzZ07F8cddxxaW1u5sRgREVEOM2IScAiAV0q5wYBzURLr16/HwoULUVrK/dQot4waNQqnnHIKHn74Ybz00ktoaWmJu9PyoUOHIKXE2LFjcejQIRQVFeH3v/89AODNN9+E1WrFV77yld7Jx0RERGQco1YBSjn5F0KsklLWGtFvodm7dy9ef/113H333WaHQhTT5ZdfjmAwiL/97W845phjcOaZZ6K9vR1TpkzBCSecgI6ODowePRrbtm3Dvn37IKWElBKKokDT+m8R8sMf/hC1tfxPBRERkdGMKABWCSEeAeCRUu5P4fgqAPy/egb0sdULFy40ORKi2L73ve/he9/7Hq6++mps374dY8eOxXnnnYfOzk689957KCkpgRACl1xyCebMmQMhBEaPHo1du3ahsrISTz31FL7whS8gGAzi+9//Pq699lqceOKJZn8sIiKivGJEATAbkXkADdEx1S2I7AEQa8dfCwCOXcnQ5s2bUVRUhDPOOMPsUIhi0udV/OpXv8qovdvtBgBs3boVTU1N2LhxI66++mrD4iMiIiJjCoAXAEwCoM+odCY5XhrQZ0HavHkzKisrceyxx5odCtGQ+tznPofi4mJs3ryZBQAREZHBjCgAOgDUA2hE7Lv+fZUAaDagz4Lz8ccfIxgMYtmyZWaHQjTkRo8ejXPPPRebN282OxQiIqK8Y0QBoAJ4VEr5dgrHtgkhuBtwBl599VV0d3dz/D8VjIULF+J3v/sdPvzwQ0yZMsXscIiIiPKGEWvsOVNM/nUXGdBnwdm8eTOEEDjnnHPMDoVoWOjF7ksvvWRyJERERPkl6wJASrlv4GtCiFlCiAuFELNSOZ6S27x5M0499VQoimJ2KETDoqKiAscccwwLACIiIoMZsg8AAAghihFjR+DoqiBNAKqllB8Z1V+6hBAuAI7oP/Us2iulDCRpVxVtp89vUKLt1CEJNIbDhw/jlVdewTe+8Y3h6pLIdMcccwwWLFiAYDBodihERER5xZACQAhxOoANiEwIbkD/ycBWAEsAOIUQdinlRiP6TDO+ZgA+KaWzz2sKIkuXOqWU7jjtfABKY7QLCiHcyYoHo4RCIXzyyScc/08F5/TTT8fatWuxb98+TJo0yexwiIiI8kLWBYAQYhIiSb8z0Y7A0Tvp9UKI8hQ3DDNENIn3SClDfV+XUmqIFCXNQgiXlLI+RrxLpJQlA9sJIdwAmoQQs6PnGVL6SigsAKjQVFRU4NFHH8WUKVOwbds2zJ071+yQiIiIRjwjJgEvR2R4T9zkHwCklH4ASzH8uwDbByb/A3gRe+8CLyLLmw7S587/sHyWzZs3Y86cOTj++OOHozuinHHllVfif//3f9Hd3Z3x5mJERETUnxEFQImUcksqB0YTcZH0QIMIIWxIvvOwisgOxQPbWRDZ1TieVgyY7zAUpJR4+eWXefffYEuXLjU7BErBuHHjcN1112HRokVYs2YNNm/ejMOHD5sdFhER0YhmRAEQNuAcQ0UFoEQnAMdjAzDwCYG9T/tk57YkOCZrb7/9Nvbu3YszzzxzKLspKPv27cMTTzxhdhiUhptvvhnvvPMOzjvvPFRUVOCJJ57A+++/b3ZYREREI5IRBUCyO+wD/cuAPlMSHZ8fAuATQngHvh+d0OsF4BnwVmX0e6ICQC98bNnGmciWLZGHK6effvpQdlNQiouLMWaMYQtg0TC47LLL8OGHH2LNmjVoa2vDNddcgxkzZuCcc87BqlWrEA7n8n0IIiKi3GJEASCEEBemeODlAP7NgD7ToY/vrxFChKPDe3pXAQLgjrGkpwL0FhDx6O+lWwCl5a9//SvGjh2Lz33uc0PZDVHOKy0txTXXXIM9e/bgtddew913342DBw/i1ltvxcknn4yKigr86le/wrZt29DR0WF2uERERDkr69ugUsrlQohWIcQjUsqfxzomukeAC5Fke1iX8ZBSqkIIKyJ7EdgQWcJTn9xbHSfJTyepH9KduV588UVUVlZi3LhxQ9kN0Ygxfvx4nHrqqTj11FNx2223YdeuXbjnnnvwwgsv4OqrrwYAFBUVYf78+bj44ouxdOlSTJ06FTNnzjQ5ciIiotwgpJTZnyQyDv55ALMBBBC5O96BSCJtQSTx1gBUSCnbsu4wsxgVAEEcnfAbQmTp0kHDfIQQYQAWKWXcCcvReQU+AHVSSk+M91wAMGXKlPJ169ZlFPOBAwewePFifP3rX8c3v/nNjM5B+aerqwsTJ040O4yc093djddeew379u3Dm2++CVVVsXXrVvT09EAIgYsuuggulwtTpkwxO9Scw2uKjMZriozE6yl1F1xwQVBKWZHsuIyfAAghZgGAlPLtaBI9RwhRg0ji23dirAbgPinl8kz7ypYQwg7AjciOvgqOPg0IRzf0irncZ6ai56sHgHnz5slFixZldJ7nn38ePT09uPbaa5HpOSj/bNq0iddDHHa7vd+/29vbsXnzZmzZsgU//elPMW7cODz33HMmRZe7eE2R0XhNkZF4PRkvpQJACPEIIkm9BZGEvhWRu+mtfY+TUtYBqIu2OR2AKqXcZ2TA6YrejXf03c0XgDU6KbgGkQnCSjT2TOzNOsg4Nm3ahNGjR+Occ84Zqi6I8tr06dOxdOlSLF26FAcPHoTP58Mnn3yC8ePHmx0aERGRaVKdBLwUQAWA66WUlVLKG6SUj0kpt8ZrIKXckgPJvw2RXYAHbfQVHbZTjkhB4x2wnKcWbZ/K+P4h2wn4T3/6EyoqKvjYi8gAl156KQ4ePIhAIJD8YCIiojyWzipAnmS7/eYgb/QrpujGZOXRf1b1eUufF5BoMrBeHAzJciOHDx9GMBjk3X8igyxcuBDFxcVYv3692aEQERGZKtUCQALIbCarueyITEqOKzp/oR5H1/4HjhYAiZ4AWKPfB24iZoht27bh4MGDqKysTH4wESVVVFSEL3zhC2hsbMRTTz3FHYWJiKhgpVoACCnl/kEvCnGREOJRIUTjgK9HhBCrDI51KIXRf9Ovxuj3RLv8WgBosVYRMkJzczMAcAdgIgNdeuml+Oijj/D1r38dP/95zFWLiYiI8l6qBUDMJFdKuUFKeT0iK/+UIjKMpiU6R6DWoBizEULkKUAyDgDN+j+iQ4O06Ovx2BFd6cdoUkr4fD6ce+65sFgS1SBElI7LLrsMN9xwAwDghhtuwKJFi/DYY4+ZHBUREdHwSrUASLjSTXSyrxvAPinl/VlHZZxqRCb4xh3KE10iVJNSDhwqVA1gSay2QogqRAqEIXnK8dprryEcDuO6664bitMTFayJEyfi4Ycfxj333AMA2L59O6qrq3HLLbfg7rvvRnd3t8kREhERDb10JgEnFB0Kk3Q4jBDicqP6TCZ6J78akd1/qwa+H923wBM9ZmBbPyLzHhoGtFEQmVjsjLOLcNb+8Ic/AAC++MUvDsXpiQresmXL8Pvf/x5vvfUWFixYgJ/+9KdYsWIFzjvvPDzwwAPo6uoyO0QiIqIhk/FGYHGksiJOLYBfG9xvXFJKvxAiAKBWCOGOvqwn7o1SyrjDfKSUbiFElRDC16eNgsi+AkMy9h8ANm7ciM997nM44YQThqoLooKmTwgGgFdffRWhUAgbN27EL37xCyxbtgzLli3DxRdfjAsvvBBnnnkmzj//fAgRe2NwfTf1eO8TERHlmlQLgFQHoksDz2WY6J16T4Zt/QD8xkaUsD9s2bIFl1566XB1SVTQioqKcNZZZ+Gss85CbW0tNmzYgI0bN+Lxxx/H888/DyCS3C9cuBB33XUXzjvvvN62hw8fxle/+lW0tLSgrKwMZ5xxBs466yxcccUVGDXKsAesREREhkq1AJgshPgjkm96VSGEaEzwvoLES2sWvD179uDDDz/EaaedZnYoRAXpoosuwkUXXYS7774b+/fvh9/vxz/+8Q888cQTOP/883HyySejsrISN954I5qamkG9C+kAACAASURBVPB///d/mDNnDnp6evDTn/4UP/rRj1BVVYXGxkYWAURElJPSGQKUaEWcvgbtujtAKk8JCtbWrZHNlRcsWGByJERUXFyM//qv/wIArFy5Evfeey9+9rOfYc2aNVizZg0AYMmSJWhsjNz3OHDgAH784x/jtttuwxNPPIFrr73WtNiJiIjiSacAcCLyBCCbnW+tAHxZtM9727dvBwCccsopJkdCRH2NHz8ed955J+68807cdddd2L9/P4455pjeZUUBYNy4cVi+fDmeffZZ3HnnnSwAiIgoJ6VaAHRIKZ82oL8tQojlBpwnb6mqiuLiYkyePNnsUIgojhUrVsR9b9SoUbjssstw66234qOPPsJxxx03jJEREREll+oAVa+BffIJQALhcBgWi4UrihCNYPPnzwcA7Nixw+RIiIiIBkupAJBSNiQ/KjVGnisfqaoKq9VqdhhElAW9APjHP/5hciRERESDcYmKHNLT04O2tjZYLMO+UioRGchqtWL06NEsAIiIKCexAMgh7e3t+PTTT/kEgGiEKyoqgtVqZQFAREQ5iQVADgmHwwDAJwBEeWD+/Pl48803zQ6DiIhoEBYAOURVVQDgEwCiPDB//nzs3LkT3d3dZodCRETUDwuAHKKqKkaPHo2ZM2eaHQoRZWn+/Pk4dOgQ3n77bbNDISIi6ocFQA7ZvXs3pk6dijFj0tmfjYhy0cknnwyAKwEREVHuYQGQQ/bs2YPjjz/e7DCIyADz5s0DwAKAiIhyDwuAHMICgCh/lJSUYNq0aSwAiIgo57AAyCEffPABCwCiPDJ//nwWAERElHOGvQAQQiwY7j5Hgp6eHhYARHlGLwD0Fb6IiIhygRlPAJpM6DPndXZ24vDhwywAiPLI/PnzsXfvXlitVqxZs8bscIiIiAAAKS03I4S43KD+SgFwl6sY9uzZAwAsAIjyyGc+85nen7/1rW9h5syZWLRokXkBERERIcUCAMBjACYBEAb0KQ04R95hAUCUv6ZOnQpFUXDBBRfguuuuw6OPPoqioiKzwyIiogKV6hCgDgDLAZRk+TUHgGZc+PmDBQBR/jnjjDMwffp0/Pa3v0UwGITH48Hq1atx7rnn4qWXXjI7PCIiKlCpPgFQATRJKfdl2d8+IURblufISywAiPLPiSeeiPfff7/33/feey8qKytx4403YuHChfj3f/93XHLJJfjqV7+KGTNmmBgpEREVkpSeAEgpL5ZSvp1pJ0KIWUKI4ui5KjI9Tz7bs2cPxo0bh+OOO87sUIhoCF1xxRVoa2vDD37wA7z88su4+eabcdJJJ+GKK67AX/7yFxw5csTsEImIKM8N+SpAQohJAMoBLBVCLOMyoLHpm4AJYcQ0CyLKZePHj8cdd9yBzs5O7NixAytWrMBvf/tbnH322Vi8eDEee+wxvPfee2aHSUREeWrICwAp5T4p5dNSygYp5f0Aaoe6z5GIuwATFaa5c+fizjvvxFtvvYV7770XL7zwAqqrq3HSSSfBZrPh4Ycfxqeffmp2mERElEcMLQCiQ30WCCEuHPB1uRDim0KI/2/vzqOkqO7+j38uzLAvDSjuKMOiAQFZVYwGdUBj8NEo4BKjz0mAMVGS8ARZNJ6YxARBo+bERBk1xuRJlMXk0bjEzChEEH8uYFCDojIYTWSHGZiRTfj+/qjqoWl6nanp6pl5v87p007Vrarb1Vf6futu94tpQBMiAACatxNOOEEzZsxQTU2N/vnPf+qOO+5Qy5YtdcMNN6h37976n//5H/3lL38JO5sAgCYgkADAr+RvlbRW0gpJZZLKY16LJJVKKpY0IYhrNjUEAAAkqaCgQP369dOMGTP02muvqby8XJFIRPfcc48uv/xyzZw5U++8807Y2QQANGL1DgD8Pv6L5K3wO0HSMEl3yuv3H32NlzRD0vVmxixAcfbt26ctW7YQAAA4hHNO559/vlatWqWPP/5Y/fv319y5c/XFL35Rv/71r7Vp0yaZsbQKACA7QbQA3CFpvJld7/f1f1NeC8B2M3vTfz1hZndKXmtBANdsUjZt2iSJKUABJNaiRQudcMIJevPNN/XRRx9p4MCBuuGGG3TUUUepR48euvnmm7V06VIdOHAg7KwCABqBIAKAKjN7IW5bhbzuPofw0w0J4JpNCmsAAMhUjx499Pe//13Lly/XPffco4EDB2rOnDk655xzVFRUpIsuukhvvvlm2NkEAOSxIAKALfEb/G4+owM4d7MQDQCOOuqokHMCoDFwzunMM8/U9773PT3zzDPavHmzfvvb32rIkCFasWKFzjrrLN1yyy1atWpV2FkFAOShIAKAZBPXb3fOnZtge68Artmk0AIAoD66du2q6667Tn/605/09ttv67TTTtPPfvYznXbaabrqqqv00EMP6bHHHtOyZcv02WefhZ1dAEDICgI4xyLn3Gwzm+Wce13SVjO7UN7A4EXOuemSFprZDufcZWIa0MPQAgAgKN27d9fy5ctVWVmpu+66S3fffbcef/zx2v2RSERHHHGE7r33XrVo0UKPPfaYBg4cqA4dOqhv377q2LEjCxICQBNX7wDAzNY550qdcw/Im/Fnhb+93Dn3kKQHJZXG/KDQNSjOhg0bFIlE1KZNm7CzAqCJiEQiuv322/Xtb39b//73v1VVVaUtW7bo6aef1v/7f/9PY8eOTXjc0KFDdcMNN+jyyy9Xp06dcpxrAEAuBNECEO3zf73/it0+w28VmCXJJM02sxeDuGZTwhoAABrKscceq2OPPbb276uuukrbtm3TCy+8oE6dOqlHjx66++67dcYZZ+jjjz/Wfffdp2984xuaNm2aysvL1adPH3Xo0CHETwAACFogAUAqZrZIXncgJEEAACCXunbtqvHjx9f+/bWvfU2jRo2SJN166616/fXXdf7552vIkCHq1auXli9fru7du4eUWwBA0AJZCRj1QwAAIF8UFBTozDPP1COPPKKrr75an376qU4//XS9/fbbYWcNABCQIFYCPi3Fvsudc3f4r9mp0jZnBAAA8s0VV1yhP/zhD3rxxRdVU1Ojm266KewsAQACEkQLwJxkO/wVgGf6r1mSujnnJgZwzSajurpa1dXVBAAA8tIZZ5yhKVOm6Pnnn9crr7wSdnYAAAFoyHUADuOvBBwJ4JpNxsaNGyWxBgCA/FVSUqLjjz9eo0aN0pIlS8LODgCgnoIIACzL9EwDGoNFwADku+7du+sf//iHevbsqSuuuEKffvpp2FkCANRDxrMAOed6ShqcYFeRc+6rSt8SUCSpRFJ55tlr+ggAADQG3bp105/+9CeNGDFCX/3qV/Xss8+qW7duYWcLAFAH2UwDuk1SlbyK/HhJxfKe/jtJT2R4jlIz+1ZWOWziCAAANBb9+vXT//7v/+rKK6/Ul770Jb366qtq37592NkCAGQp4wDAzKokveC/HnTOFUkqkxcYTE5zeKW/WBjibNiwQS1atNARRxwRdlYAIK1LL71UTz31lC688EJNmTJFv/nNb8LOEgAgS3VeCMzMKpxzQyUtMLM3A8xTs7JhwwZ1795dLVu2DDsrAJCRMWPG6Oabb9ZPf/pTjRw5UhMnMrkbADQm9RoEbGaVkhYGlJdmiTUAADRGt912m84991xNmjRJN998s/bv3x92lgAAGar3LEBm9mAQGWmuNm7cSAAAoNEpKCjQX//6V02aNEmzZ89Wjx49VFZWFna2AAAZCGIa0Kw45+bn+pr5jBYAAI1Vq1atNG/ePD3xxBPq0qWLxowZo7Fjx+pf//pX2FkDAKSQ8wBA3uxBkGRm2rBhg4466qiwswIAdeKc02WXXaZXX31Vt99+u5YsWaKTTz5ZN954o5555hl9/vnnYWcRABAnkADAOXeec+5559wHzrmtqV5iJeBaNTU12rdvH3NpA2j02rdvr1tuuUWrV6/WNddcowceeEBjx45Vnz599Itf/EI7d+4MO4sAAF+9AwDn3OXyFvfqJulNeYOCE71ekLSyvtdrSrZv3y5JikSIiQA0DT169NBDDz2kqqoq/fnPf9bxxx+v733ve+rRo4duvfVWrVzJzwAAhK3O04DGmCCpV6bz/DvnPgzgmk1CNADo0qVLyDkBgGC1b99el156qS699FK9+uqruuOOO3T77bfr9ttv15e//GUNGjRIX//619WvX7+wswoAzU4QXYDWZbnI17wArpk151yRc26ec26Fc67Mf01Pc8w4/5g5/muevwBaIAgAADQHp59+uv785z9r48aNuvnmm7Vu3TrNnTtXgwcP1te+9jUtW7Ys7CwiA5988onmzJmjxx9/XGYWdnYA1EMQAcCWbBKb2Z0BXDMrzrnJ8lYtnmdmQ81stJmNlrTSOTcnyTHzJF1hZiVmNsPMZkiaIanMORfIQObKykpJBAAAmofu3bvrpz/9qd599139+9//1sSJE/XMM8/o7LPPVt++ffWjH/2I9QRC9Pnnn2vZsmX66KOPDtm+ceNGTZ48Wb169dLMmTN11VVXadWqVeFkEkAggggAqpxznTJN7Jw7L4BrZsyv/M+RNNTMVsZsj8gLCiYnOGacpAlmNj52u7/wWYmkhf7x9cIYAADN1THHHKNf/epXWr9+vWbPnq327dvrtttuU/fu3VVaWqqtW7eGncUm77PPPtO6detUWlqqb3/72zrttNN09tln6wtf+IJeffVVSdLvfvc7DRs2TI8++qgmTZqk5557TpLyJgCorKxUTU2NVq9erZdfflnV1dVhZwloFOo9BsDMHnTO3eGce8DMPsrgkHmS+tT3upnwu+vMkzTer7zXMrNK51yFpIoEh86RVJronGZW7pyTpFnyWgTqjC5AAJq7tm3baubMmZoxY4YWLVqku+++WyUlJfr+97+ve++9V1dddZXatWsXdjabhI0bN2r58uVavXq13n33Xf3lL3/Rjh07JEnt2rVT7969dfvtt+vBBx/UJZdcopkzZ2rq1KkaPHiwnnzySQ0ZMkSff/65WrdurbfffjuUz/Cf//xHCxYsUEVFhd588029/PLLh+zv1q2bnnrqKY0cOTLh8Tt27NDOnTu1fft29e3bV4WFhSovL9eGDRv0+eef68gjj5QkvfHGG9q+fbsGDBigv/71r/rPf/6jwsJCtW7dWlu2bNHXv/51nXbaadq7d68qKirUoUMHtWzZUjU1NSosLNSgQYPUr18/tWnTRpI37fe+ffskeetnAGGrdwDgnLtM0muS5jnnKuVVqNcmSR6RFFgf+gzMk1RpZosS7TSzXvHbnHND5OXx9RTnfUNey0G9AoDKyko559S5c+f6nAYAGj3nnMaPH69LL71Uzz//vH74wx9q4sSJ+p//+R9dc801uuWWW3TssceGnc1GY8uWLWrXrp1eeeUVLV68WKtWrdJf//rX2nUZevTooTFjxmjYsGE6//zz1b9/f7Vt21aSdOmll+rUU0/V1KlTdfrpp2vp0qUqLCyU5K0A3a9fP73zzjtp8xAdJ+A/NMvI3r179ac//Um///3vtW7dOm3atElt27bVJZdcopdfflmrV6/W3r171alTJxUVFenWW29V27ZtddJJJ6ldu3aaOnWqrrnmGr311ltq37691q5dq+XLl+uVV17R8uXL9fbbb9fmq3///tq2bZvWr19/WD5atGihtm3bqqamRpFIRMccc4yccyooKFDr1q31/e9/P+1nadmypU4++WQdc8wxWrp0qfbu3avCwkJFIhHt27dP3/ve93TrrbeqRYswlmRCcxfELEAPSeosKdP/w3MycsjvolOsJE/yU4j270/UMqCYfcXOuSIzS5Uupe3bt6tTp078zw8AvsLCQo0dO1Zf+cpX9NJLL+mhhx7SQw89pN/97ne6+eabVVJSoq5duwZ+3X379tVW0o499ljt2rVLw4cPP+zf5z179mjNmjUqKCjQSSedpLZt22ZVwc2Fd999V4MGDVKLFi20Z88etWjRQieddJK+853vaMKECerXr586duyY9Pj+/fvX/vcf/vCH2sp/1IABA1ReXp7w2H/9619avny5Hn/8cV111VVq0aKFTj/9dP3zn//UpEmTNG3atKTXfeWVV/SNb3xD7733nk466SQNGzZM5557rj788EM98sgj6t+/v77zne+opKREvXv3TniObt266ZxzztGFF16oDz74QJs2bZIkderUSWeeeaYuu+wydenSRTt27NDtt9+uMWPG6Ktf/aoGDRqkjh07atu2bbX3q0uXLnr33XfVt29ftW7d+pDrLF++XP/617/UuXNnnXjiiWrRooWqqqrUtm1btW3bVqtWrdKqVav01ltvae3atZo4caKOO+44bd++XdXV1Vq/fr1uu+02bd68Wffdd1/SewI0GDOr10vSh5JuktRTXiCQ6lUkaWt9r5lhvibLCzYmZ3ncQv+4SIo00/0049Kdr2/fvpbMNddcYyeddFLS/UAiixcvDjsLaGLyvUx9+OGH9pWvfMUkWVFRkT355JO2b9++QM5dWVlpjzzyiA0fPtz8f9drXz169LAzzjjDLrjgAjvvvPPsC1/4wmFpOnbsaEVFRXbSSSfZJZdcYlOnTrW7777bXnvttUDyl6lPP/3UysvL7ZprrqnN27HHHmsPP/ywrV+/PuvzLVu2zJYtW5Zw35133mmSbOvWrbXbPv74Y5syZYq1bt3aJFnr1q3t8ssvtxEjRtjxxx9v/fr1s5YtW9ovf/lL++Y3v2nDhg2zKVOm2P3332/vv/++ff/73zfnnJ1wwgn25JNP2v79++t8L6ZNm2aSbNSoUVZaWmpvv/12wvMFVYbq4sCBAzZ16lSTZE8++WRo+Wgs8v3fqHwi6Q3LoL4bRAtAhbzZdXZkkLbKOZfNlKH1Mdp/r/BbA2IH+3aTVGZmiR5hRKTaAb/JRPfV6zFUZWUl/f8BII1evXrp6aefVnl5ucaOHatLLrlEQ4cO1fz589Wr12E9OTP2ySef6KKLLqrtznL33Xdr2LBh+vTTT7Vz5049//zzqqys1LZt29SqVSv17t1bV1xxhY477jjt3btXVVVV+vjjj7Vlyxa1aNFC77zzjsrKyvTZZ59J8p46jx07Vhs3blSfPn00aNAgnXXWWSooKFDv3r0Pe7KeyPr16/WrX/1Kn3zyiS655BJ99atfrW1x2L17t0pLS3X//ffrvffekyR17NhR/fv317hx43TbbbfV+d6cddZZSfcNGDBAkvT222+rsLBQt956q5YuXSpJuvrqq3X99ddr+/bt+vKXv1x7zLp161RUVKQpU6aobdu2GjBggB555JFDBu1ef/31mjNnjjp1ynhekYR+9rOf6YILLtC5556rli1bJk1XUBBEFahunHO64447tHjxYn3jG9/QE088obPPPpseAciZIAYBj8ky/bD6XjND0bEG2yTNMm8az1r+OgCj47cru0p9vabv2b59OwEAAGSouLhYH374of72t7/ppptu0qmnnqovfelL+v3vf187eDNTH330kc455xxVVVXpwQcfVIcOHXTllVcekmbixIlZ59HMtGXLFv3xj3/U4sWLVVZWVrs6crT/veQtlNa1a1d17txZxx13XG0//EGDBum4447TSy+9pH//+9/68Y9/rPfff19HHHFEbTeovn376o9//KNeeukl7d69W2eddZbuuusu9e/fXyNHjqx3BTqdU089VZK0cuVK3XbbberYsaOmTp2qb3/72zrxxBMlSUuWLDnkmJ49e+q5556Tmam4uFiFhYUyM61Zs0ZlZWW1MxAFobCwUMXFgczW3aBatWqlhQsX6swzz9SoUaM0YMAATZ06Vddee23KwAUIRCbNBNm+JJ0k6TxJJzXE+TPMw1p5zaDzlKA7j7zK+2HdeKLHpTl3tHvRnHT5SNUFqF+/fnbZZZcl3Q8kQlMogtYYy9QHH3xgU6ZMsTZt2linTp3sscceq9134MABu+++++yUU06xo48+2jp27GhnnHGG/fjHP7aXXnrJNmzYYH369LFIJGJvvvlmTvK7Y8cOW716tf3hD3+wRx991L7zne/YtddeaxdccIH17du3tttO69atbcyYMYd0M3rqqads3759dvHFF9dua9++vU2ZMsVeeOGFnOQ/1oEDB6xLly42ePBgk2QLFiw4LE1jLFNh2bp1q/32t7+1fv36mSQ766yzbNOmTWFnK69QnjKnDLsAOS9t/flrAcxRgnn15fWrn2RmOwO5WGb5WSuvFaDUzEqSpFkhLzjoFX+cmSUd1eWvLTBP0lw7vAUhun+yJB155JFDFyxYkPA848aN0+mnn66bbrop8w+GZq+6ulodOnQIOxtoQhpzmfrggw/085//XGvWrFEkEtHIkSO1YsUKbdy4UQMGDFCPHj1UUFCgNWvW1HaTkbwZWu65557a7ixhMjN9+umn2rBhg5599lm9+OKLkqSrrrpKF154oXr06CHJ60YzdepU/fd//7cuuOCC2ll7wvDd735Xb731liRpwYIFh7XANOYyFRYzU3l5ue666y51795dP/zhD3XccceF+j3nC8pT5s4999wVlkFvm0ACAOfcYEkvyOtuU66DfeQlqZeky+U9tSg2s8X1vmBmeVohaYi8NQASTgPqr/Y7WTGLhGUZAMwws7mp8nHyySfbmjVrDttuZmrTpo2mTp2qO+64I9OPBWjJkiUaNWpU2NlAE9LYy9Q777yjESNG6JhjjtG6det0wQUX6Nprr9WVV155yAw9W7du1dKlS/XSSy9p5MiRGjduXIi5Tu6hhx7Sj3/8Y7311luHLRR54MCBvOgnfuONN+pXv/qVTjzxxMNWDpYaf5kK08svv6yLL764dq2gsWPHqm/fvurbt6+uu+66Q9YWmD9/vhYvXqxRo0Zp8+bN6tq1q3r06KHjjz9eRUW5nHW9YVGeMuecyygACGIdgM6SHpRX0X4hRbpxkkqdc0MtswHD9bXNf081TWc0UCmStDJ2m3MuYqkHAscen7WdO3dq7969OuKII+p6CgCAvD7pW7duVZs2bbRv376kCy1169ZNl156qS699NIc5zA7EydOTDr+IB8q/9LBgcDJFtxC3Z111ll699139fTTT+u9997T/PnzVV5ert27d+u73/2uOnXqpD179qhbt25at26dCgsLVVp66Iznbdq00ebNm3lqjqSCGAI/U173njdTJTKzRf7Ku7P8V0PLZn7+4ZKirQQV8loOuip5BT/6SGZbkv1pbdmyRZIIAAAgANFuEqyymhsDBw6UJJ155pkh56RpOuqoo/TNb35TknTnnXfKzLR48WI999xztYuIbtu2TbfeequuvPJKffDBB+rSpYs2b96sxYsXa9q0aVq5cqXOOeeckD8J8lUQAUCXdJX/KDNb6ZybEMA1M7HCf499up9M7MrF0cAh1Qw/0TED6c6bVDQAyHbmCgAAwnb66afrl7/8pa677rqws9IsOOd03nnn6bzzzku4PxqQnXDCCTrhhBM0bdo0vfbaawQASCqItsS16ZOEIjrH//AUaaKV/Ddits3331N1niuSVGn1WAWYFgAAQGPVokUL3XjjjSlXFEY4jjzySPXs2VOvvvpq2FlBHgsiAMh2MawtAVwzLb9yvlJed55kiiVVRAcA+8etlNf1Z3TSo7zjSlPsT4sAAAAANIQRI0botddeCzsbyGNBBADOOZe4TerwhJdJymWNd4akYufcYU/znXPF8p7kj09w3CRJE/wVhOOPGycvQJhdn4xt3bpVktS1a70WEwYAADjEiBEj9PHHH2vDhg1hZwV5qt4BgJnNlDTXOffNZGmcc52cc9PkLZw1s77XzCJv5fKCgLLYyrwfECyUVBL79D/muEWSFsib3Ugxx0XkrXUwPoMZglKqqqqSpAZfsREAADQvI0aMkCS9/vrrIecE+SqIQcCSNEHS35xzpTq4DsA2ed2DiuR1w6mUlHZe0qCZ2Vzn3EpJD/oV+GjF/fxElf+Y40qcc+P8tQKix0Qkja5P3/+oHTt2qEOHDiz3DQAAAjV48GC1bNlSr732mi6++OKws4M8FEgA4FeIezvnpstbWCu2y02lpDtz+eQ/nt8SUJ424eHHLdLB6UEDVVVVpc6dOzfEqQEAQDPWvn17nXrqqYwDQFKBrihiZnPNrLeZtZA0VN4UoV3DrPznqx07dtD9BwAANIjoQGAzCzsryEMNtqSgmb1pZlUNdf7GjhYAAADQUEaMGKHKykp9+OGHYWcFeajeXYCccxPN7KEk+wZLukKSyVsvYJu8+fNfrO91G7sdO3YoEkm11hgAAEDdRAcCv/baa+rTp0/IuUG+CaIFoNQ595pz7sT4HX4rwExJd0hykuZK+lsA12z0qqqq6AIEAAAaRL9+/dSuXTvGASChIAKAckm9JVU4576fKIGZVZnZg5LGBHTNRm/Hjh10AQIAAA2ioKBAQ4cO1aOPPqpnn3027Oxo06ZN+t3vfqchQ4YoEononnvuCTtLzVoQswCVmdkYf7rMO51zV8ibJ/9f8QnNrMI5l/VsPE0RLQAAAKAhnXbaaVq6dKm+8pWv6Ec/+pH279+vv//972rRooU++eQTSd6CpCNGjNDOnTv1+eefq1OnTurWrZuWLVumTz/9VB06dNAtt9yiyy67LOvr/+Mf/9CyZcvknNPUqVO1b98+DRgwQK1atdLPfvYzfetb31KbNm2C/tjIQBABgEm18+YvlLfAVoVzbrKZPZwgfb3n0G/s9u/fr5qaGloAAABAg/nmN7+pN998U8uWLdMPf/hDSd4aAa1atdLgwYNVUFCg9evX6+GHH1anTp3Uvn17bd68WTt37tSIESN02mmn6Z133tHll1+ue+65RxdffLG6d++uDh06aOvWrVq6dKl27dqlnTt3as2aNRo4cKAuuOACHXPMMZKkH/zgB3rmmWckSWeeeaZmz56ts88+Wy+++KJGjx6tBQsWvjyIIgAAIABJREFU6Nprrw3t/jQ12az8HNRCYJK8+fadcydJekjewlvj5bUG7IxJVq8VdJuCHTt2SGIVYAAA0HAGDRqkpUuX6p133tHHH3+sUaNGqV27doelMzM55yRJn332mTZu3KiePXtKkvbt26dzzz1XU6dO1dSpUyVJbdq0kZlpz549tecoKCjQ559/rjZt2ujee+9VSUmJ3n33XQ0cOFB33XWXzjnnHLVu3VqSdP755+uUU07RfffdRwBQD+vWrdOjjz6q5557Tnv27NGqVasyPjaIAKBX7B/+1J/jnXPjJJVKqkzRGtAsRQMAWgAAAEBDO/XUU3Xqqacm3R+t/EtSu3btaiv/klRYWKinn35azz77rPbt26fNmzdr06ZN2rt3ryZMmKAjjjhCbdq00bHHHqvVq1drxowZuv7667V27VpVVFTotttu0+jRow+73o033qgbb7xRr732Wu2MRUhv//79Wr58uZ544gndd9992r9/v44++mgdffTRGjlypJYvX57ReYIIAIoSbTSzRc65Mh3aGjBBfpeh5qyqylsegRYAAACQ7yKRiK6++uq06QYOHKgnn3xS1113ne68805JXpejRK699lrNmjVLpaWlTTYAiG1ZWb9+vTZu3Kj33ntPffr00dChQ7M6V1VVlZ588knNnDlT69evV2Fhoa688kr94Ac/0CmnnCJJ2rhxo44++uiMzhdEADDaOXeumS2O35GgNWCdvDEAswK4bqO1c6fXI6pjx44h5wQAACA4rVq10mOPPaYf/OAH2rZtm0aOHJkwXceOHTVgwACtW7cuxzlsWGamiooK/frXv9b999+vdu3aqXfv3nr99dd14MCB2nSrVq3SwIEDDzm2srJSCxcu1HPPPafWrVvra1/7mvr166ennnpKP/nJT7Rt2zYNGjRI9957ry688MLDHiQfddRRGecziABgnbwn/GvlVe7LzOxPsQliWgMWSTovgGs2atXV1ZIIAAAAQNPUv3//tGk6d+6szZs365VXXtHvf/97/fGPf9Qpp5yiL37xi5o2bVrGT7PzwY4dO1RWVqYHHnhA5eXlatGihSZMmCDnnDZs2KBp06Zp8ODB6ty5sy666CK9+uqrtQHAe++9p9tuu03/93//pz179qhnz57avXu3Hn/88drzFxcX69Zbb9XIkSNVUFD/6nu9z2BmvdKnqm0NGO2cO7++12zsogFA+/btQ84JAABAODp16qTnnntOZ599tvbv368xY8Zo9erV+vnPf66HH35Ys2fP1nXXXSfpYHeazz77TJ9++qm2bt2qU045Rf/5z3/0+eef11amP/vsM7Vt21b79u3Trl271K5dO61atap2YTTJG9j86KOP6q233tIZZ5yhCy64QPv379cvfvELbdq0STfccIP69esnyRtoe/zxx9d2wdmyZYvef/99rV+/XsOHD1d1dbWef/55ffTRR9q3b5+6dOmi2bNn67LLLlPfvn0P+8xmps6dO2vlypV6+umntXTpUv36179WQUGBJk6cqOuuu07Dhg3Trl27NGHCBPXo0UOTJ0/WoEGDDhmrUV+BzgKUoddDuGZeqampkSR16NAh5JwAAACEI9qFZdCgQVq8eHHt32vWrNHEiRP1rW99S7fccouKior09ttvq0ePHtq5c2fC6S4vvPBCVVRU6P3339dRRx1VGyy0b99e69evV1FRkfr166eKigqtXr1aktS6dWv98pe/VGFhoQoKCrR3714VFhbqoYceUufOndWyZUtt27btsGsdeeSR6tmzp+bOnSsz09ixY3XZZZfpoosuSvuE3jmnwYMH6ze/+Y0eeOABSd7T/d/+9rc67rjjatO1a9dOTz/9dN1vbhphBAArJPUJ4bp5I9oCQAAAAACaq3fffVeSdOONNx7Sn/3kk0/WSy+9pCVLlqi0tFSvv/66rr76am3dulU1NTWaOXOmjj/+eP3zn/9Uly5dVFFRob/97W/q06ePrr76aq1du1ZVVVXavHmzWrdurVmzZmnhwoX6z3/+o2OPPVYXXnihvvjFL+q//uu/tGLFCi1YsEBVVVX67ne/q86dO+vvf/+7XnjhBUneDEq7d+9W+/bt9aUvfUkDBgyoreBv3bpVzjl17do1q899zjnnaNmyZfrJT36im266qXZ61FxyZplNyuOcO09ShZl9FLc9m6XhukqaZ2YtszimUTv55JNtzZo1h2ybO3euZsyYoZqamoTz8QKpLFmyRKNGjQo7G2hCKFMIGmUKmbjzzjs1ffp0VVVVpZwZsamVp71796qqqkpHHnlk4Od2zq0ws2Hp0mXUAuCcGyypXNI2SUfE7X5IUmdJmXZMavbTgFZXV8s5p7Zt24adFQAAgFBMmzZNU6ZMUZs2bcLOSk61atWqQSr/2ci0C1CFpDcllSXZN0/SggzO002MAVB1dbU6dOgQ6GAOAACAxsQ51+wq//kiowDAn8En2YoFFZLmm9mODE5V5ZxrWhO+1kE0AAAAAAByLYhpQCdkmT5tv6Smrrq6milAAQAAEIoW9T2Bc66Tc26acy756A0coqamhhYAAAAAhCKIaUAXSYou7nVXAOdr8ugCBAAAgLDUuwVA0kpJY8yMyn+GCAAAAAAQliACAJnZC5mmdc7NDuKajRkBAAAAAMISRAAw2zl3fxZjAMYFcM1GjQAAAAAAYQliDEBPeeMAHvTntX9d3tSglQnSFslbDbhZYxYgAAAAhCWIAOBFHboS8Pg06VkJmBYAAAAAhCSIAGCbpFJJ85X4qX+sLkq8mnCzsW/fPu3du5cAAAAAAKEIIgCokPSAmX2UQdp1zX0l4JqaGkkiAAAAAEAogggAxptZVRbpz0+fpOmqrq6WRAAAAACAcNQ7AEhU+XfOnSRvwG9FfMtAlsFCk0MAAAAAgDAFsg6AJDnnOvnTge6XtFZeX/+1zrn9zrnHnXMdg7pWYxYNAJgFCAAAAGEIoguQnHODJb0gb0Dwgzp0MHAvSRMkjXfOFZvZ4iCu2VjRAgAAAIAw1TsAcM51llfpH59qRWDn3DhJpc65oWa2o77XbawIAAAAABCmILoAzZQ0KVXlX5LMbJGkKyTNCuCajRazAAEAACBMQQQAXczszUwSmtlKHVwwrFmiBQAAAABhCiIAWBvAOZoNAgAAAACEKYgAoGuW6bcEcM1Gi1mAAAAAEKYgAgDnnDsvw4SXSToigGs2WtXV1SosLFSrVq3CzgoAAACaoSAWApvpnHvDOXe/mT2cKI1zrpOkyZJKzKxPfa/ZmFVXV9P9BwAAAKEJZB0AefP8/805VyqpXN46ANvkdQ8qkjTE3zYsoOs1WgQAAAAACFMgAYCZVUjq7ZybLu9Jf1HM7kpJd5rZzCCu1djV1NQQAAAAACA0QbUASJLMbK6kuVLt6sAVZlYV5DUaO1oAAAAAEKZAA4BYma4N0NwQAAAAACBMGc0ClOksP7k+V2NUXV3NFKAAAAAITabTgM4J8JpBnqvRoQUAAAAAYcq0C1Av59yJkrbX83rddOgA4WaHAAAAAABhyjQAiEiqaMiMNBcEAAAAAAhTNoOAq+TN7V+ZZP8QSStTHB+Rty5A5yyu2aSYGdOAAgAAIFSZBgAVZtY7VQLn3N/MbEy6EznnPszwmk3O7t27deDAAQIAAAAAhCbTQcDJnvrHsgDP1SRVV1dLEgEAAAAAQpNpAHB+gNcM8lyNSjQAYBpQAAAAhCWjLkBBruabTysDO+dWmNnQNGnGSRqtgy0XEUlzzCzrQdG0AAAAACBsDbYScL5zzk2XN3A5VZp5krqa2fiYbRFJK5xzJWZWns01CQAAAAAQtmYZADjniiTNSpNmnKQJZtYldruZVTrnSiQtdM71NLOMxzTU1NRIIgAAAABAeDIaA+Ccez6TZAGeq6GVSEr39H6OpNJEO2Ke/KcMIuLRAgAAAICwZToIOJPVezOdBSjUlYD9J/vz5a1pkCzNEHn5fD3Fqd6QNDmbaxMAAAAAIGyZdgHq5Zz7q7zFwJIZ5pybn+Y8EYUYAPj994eb2SLnUjZYFPvvqQb6Vkgqds4VZTogmFmAAAAAELZsxgCkXeRL0vj0STJuKWgIsyTNziDdcP89VcV+rf8+JE26WrQAAAAAIGyZBgCVkib570m7zqTRVVIXSfPqeHy9+N16Xs9w0G5E8gb8pkgT3dc10zxEA4B27dpleggAAAAQqEwDgG1m9kQQF3TOzQziPHVQYmYlGabNuFIvP1jIRHV1tdq1a6eWLVtmcXoAAAAgOJkGAHMCvGbOWwCcc5OV3WfIuFIvqVuS602WpCOPPFJLliyRJH3wwQdq3bp17d9AXVRXV1OGECjKFIJGmUKQKE/By3Ql4AeDumCQ58qEP/A3UpeVe+vKzErlTyF68skn26hRoyRJDz/8sLp06aLo30BdLFmyhDKEQFGmEDTKFIJEeQpeptOANmazzGxuA55/a6YJq6urmQEIAAAAoWrSAYA/539ZHQ6t9I/PpCtQxisBV1dXMwMQAAAAQtWkAwB5c/6nW/E3kWh3oVSDgaPBQcazIhEAAAAAIGzZrAPQqPgDccc554qTJCny062IbjCzof5/RgOAVC0Avfz3lZnmqbq6Wsccc0ymyQEAAIDANdkAIHYgbiLOuTJJxTGV/ljzJU2XFyQkq+AXSarMZnAxLQAAAAAIW1PvAlQnZrZSXt/+0SmSFStFgJFITU0NAQAAAABCRQCQ3CRJExINBPYHF1dKmp3NCWkBAAAAQNiacwDQVZKcc0WJdprZIkkLJB2yboEfEMyRNN7MMp4BaP/+/dq1axfTgAIAACBUTXYMQCL+k/tZkobEbF7rnKuQVG5mJbHpzazEOTfOOTdPB6f7jEgane3CYjU1NZJECwAAAABC1awCAP+p/qKGPiaR6upqSQQAAAAACFdz7gKUUwQAAAAAyAcEADkSDQAYAwAAAIAwEQDkyK5duyRJ7dq1CzknAAAAaM4IAHIkGgC0adMm5JwAAACgOSMAyJHdu3dLktq2bRtyTgAAANCcEQDkSLQFgAAAAAAAYSIAyJFoCwBdgAAAABAmAoAcoQUAAAAA+YAAIEcIAAAAAJAPCAByhC5AAAAAyAcEADnCNKAAAADIBwQAObJ79261atVKLVpwywEAABAeaqM5smvXLvr/AwAAIHQEADlCAAAAAIB8QACQI7t376b/PwAAAEJHAJAjtAAAAAAgHxAA5MiuXbtoAQAAAEDoCAByZPfu3bQAAAAAIHQEADlCFyAAAADkAwKAHGEQMAAAAPIBAUCO0AIAAACAfEAAkCMEAAAAAMgHBAA5QhcgAAAA5AMCgByhBQAAAAD5gAAgR2gBAAAAQD4gAMiBAwcOaM+ePbQAAAAAIHQEADmwe/duSSIAAAAAQOgIAHIgGgDQBQgAAABhIwDIgV27dkmiBQAAAADhIwDIAVoAAAAAkC8IAHKAFgAAAADkCwKAHCAAAAAAQL4gAMgBugABAAAgXxAA5AAtAAAAAMgXBAA5QAAAAACAfEEAkAN0AQIAAEC+IADIAVoAAAAAkC8IAHKAFgAAAADkCwKAHKAFAAAAAPmCACAHaAEAAABAviAAyIFoANCqVauQcwIAAIDmjgAgB/bs2aNWrVqpRQtuNwAAAMJFjTQH9uzZo9atW4edDQAAAIAAIBcIAAAAAJAvCABygAAAAAAA+YIAIAcIAAAAAJAvCABygAAAAAAA+YIAIAd2795NAAAAAIC8QACQA3v27GERMAAAAOQFAoAcoAsQAAAA8gUBQA4QAAAAACBfFISdgVxwzs2RVCwp4m9aKWm2ma1Mc9w4SaMlVfqbIpLmmFlFNtcnAAAAAEC+aNIBgHOuSNIceZX9Gf62iKQHJa1wzs2Nbk9w7DxJXc1sfMy2iH9ciZmVZ5oPAgAAAADkiyYdAMir/E8ys+gTfPn/Pd45t1DSdOfcWjMrjT3If/I/wcy6xG43s0rnXImkhc65nrHnTYVZgAAAAJAvmuwYAOdcsaSyFJX0Sf77vAT75kgqTbBdMU/+Z2WaF2YBAgAAQL5osgGApPGpdvqBwUqpNliQ/99DJBVJej3F4W9ImpxpRugCBAAAgHzRlAOAIknz/AHAyVTEpI0qjtuX7LiIP8YgLQIAAAAA5IumHACUyZu9J9WT/OisQLGV/eEJtsVb678PySQjBAAAAADIF002ADCzuWbWxcwWpUg2zH9/I2ZbxD8+1QDf6L6umeRl3759BAAAAADIC002AEjH7/cfkbQorrKfUaXeF0mXwMwkiQAAAAAAeaGpTwOayoy496i0lfoY3RJtdM5Nlj9I+IgjjpAkffLJJ1qyZEl2OQQSqK6upiwhUJQpBI0yhSBRnoLXLAMAf57/Yknjs13VNxP+ugKlktS7d2/bsmWLTj31VI0aNSroS6EZWrJkCWUJgaJMIWiUKQSJ8hS8ZtcFKGYl4BlpxgdkYmu6BHQBAgAAQD5pdgGApBckzTazuUn2V0q1gUI6aVcCJgAAAABAPmlWAYBzrkzS/BSVf+ng9J+pBgNHg4Nt6a554MABSQQAAAAAyA/NJgBwzs2TVJam8i8dDABStQD08t9XprsuLQAAAADIJ80iAHDOTZdUmajy75yL+FOCRs3331Ot8lvkny/tAGICAAAAAOSTJh8A+DP+dDOz+Ok+o2Ir/zKzlfL69o9Ocdpi+bP8pBMNANq0aZNJcgAAAKBBNekAwDk3RNLwFJV/SRquQ1cClqRJkiYkGgjsBxSVkmZnkgdaAAAAAJBPmuw6AM65Inkz/rzhD/5NpEhSUXyAYGaLnHOj5U0XOj7mnBFJc+StH5B2BiD/XJIIAAAAAJAfmmwAIGmevIG8xWnSJRzIa2Ylzrlx/uDhaGU/Iml0NouHEQAAAAAgnzTZAMDMUvXhz/QciyTVa7EwAgAAAADkkyY9BiAfEAAAAAAgnxAANDACAAAAAOQTAoAGxjSgAAAAyCcEAA2MFgAAAADkEwKABnbgwAFJUmFhYcg5AQAAAAgAGpyZqXXr1nLOhZ0VAAAAgACgoUUDAAAAACAfEAA0MAIAAAAA5BMCgAZGAAAAAIB8QgDQwAgAAAAAkE8IABqYmalVq1ZhZwMAAACQRADQ4AgAAAAAkE8IAHKAAAAAAAD5ggCggdECAAAAgHxCANDAzIxVgAEAAJA3CAAaGC0AAAAAyCcEAA2MAAAAAAD5hACggREAAAAAIJ8QADQwAgAAAADkEwKABkYAAAAAgHxCAJADBAAAAADIFwQADYwWAAAAAOQTAoAGRgAAAACAfEIA0MAIAAAAAJBPCAAaGAEAAAAA8gkBQA4QAAAAACBfEADkQGFhYdhZAAAAACQRAOQELQAAAADIFwQAOUAAAAAAgHxBAJADBAAAAADIFwQAOcAYAAAAAOQLAoAcIAAAAABAviAAyAECAAAAAOQLAoAcIAAAAABAviAAyIGCgoKwswAAAABIIgDICVoAAAAAkC8IAHKAAAAAAAD5ggAgB+gCBAAAgHxBAJADtAAAAAAgXxAA5AABAAAAAPIFAUAOEAAAAAAgXxAA5ABjAAAAAJAvCABygBYAAAAA5AsCgBwgAAAAAEC+IADIAboAAQAAIF8QAOQALQAAAADIFwQAOUAAAAAAgHxBAJADdAECAABAviAAyAFaAAAAAJAvCABygAAAAAAA+YIAIAcIAAAAAJAvCAByoEULbjMAAADyA6NTk3DOjZM0WlKlvykiaY6ZVWR5nqCzBgAAANQZAUACzrl5krqa2fiYbRFJK5xzJWZWHl7uAAAAgLojAIjjP/mfYGZdYrebWaVzrkTSQudcTzOrTHyGw87XENkEAAAA6oTO6YebI6k00Y6YJ/+zcpcdAAAAIDgEADGcc0MkFUl6PUWyNyRNzk2OAAAAgGARAByq2H9PNdC3QlLEOVeUg/wAAAAAgSIAONRw/z1VALDWfx+SyQkZAwAAAIB8QgBwqIjkDfhNkSa6r2vDZwcAAAAIFgHAobKp1EcaLBcAAABAA2Ea0ENlU6nvlmyHc26yDg4U3uOce6deuQIOdYSkLWFnAk0KZQpBo0whSJSnzJ2YSSICgAZgZqXypxJ1zr1hZsNCzhKaEMoUgkaZQtAoUwgS5Sl4dAGqu61hZwAAAADIFgHAoSolyTmXSVegjFYCBgAAAPIJAcChotN/phoMHA0OtmV4zoSrCgP1QJlC0ChTCBplCkGiPAXMmVnYecgbzrk5kqZLGmpmK5OkmSdvgG8vM0u1XgAAAACQd2gBONR8/z3VKr9Fkiqp/AMAAKAxIgCI4T/1r5Q0OkWyYtEUBQAAgEaKLkBxnHPjJD0oqWf8isCp9sWlGa2Dg4QjkubQYoB0nHNFkhaa2dAM01PWkJTfpbFYB8ctrZQ0O1n3xpjjKFdIyjk3XdJw/89o2ZpjZuVpjqNcIWPOuRXpfgspU/VDAJCA38+/q5mNj9kWkbRCUkmyf+jqehyaL798DJP3j9h0ed3LumRwHGUNCfmB5BzFVPb9svGgpHGS5prZjCTHUq6QUEwZOiSIdM4VSyqTtCi23MQdS7lCxvwgc46ZuRRpKFP1RACQRLaRZbR1IFHlzf8HcqFStByg+fHLxQx5T2bny6u0DUsXAFDWkIpzbqGkSYm+f3/fOHk/kKVx+yhXSMo5tzBFBT86gcYMM5sbt49yhYz5DzBWSIokCwAoU8EgAAiIc26tvCcgyZ6sbZdUmmw/4JwrU2YBAGUNCfk/fkXxlfuY/RFJ2yUp/seVcoVkYspNuZkdNkYuphVgZXy3DcoVsuEHk0WSxqUIAChTAWAQcACcc0PkFdjXUyR7Q970oUCdUdaQRsIntFH+E7Fot6Di6HbKFdKIro0zLMn+6Lo4hyyiSblCNvwn+/OVYp0lylRwCACCEf0hTTXwpEJSxG/eAuqKsoZUiiTN85+iJVMRkzaKcoWk/K6vQ/1XItEyEd/vmnKFjPitTMPTTVIgylRgCACCEZ0RIVWBXOu/D2ngvKBpo6whlTJ545ZSPR2LPqWNLUOUK6RkZitTzK5yhf8+L2475QqZmiVpdgbpKFMBIQAIRkSqbV5PJrqva4o0QDqUNSRlZnPNrIuZLUqRLNqN442YbZQr1InfJWOcvAHA8U9vKVdIyy9Dr2c4aJcyFZCCsDPQRGRTyCLpkwBJUdZQZ36//4i8AXSxP6CUK2TF77JRLO/J7fgkQSflCpkoMbOSDNNSpgJCABCMbApZtwbLBZoDyhrqY0bcexTlChnxn9ZeIa/MFMkbtJms3zblCik55ybLmwI7U5SpgBAAAEAz4M+wUSzvaS0rZaJO/G4+sQuBDZG0wjk3O34NACAVvxUpwr9H4SAAyL2tYWcAzQZlDZIOWcV1RprxAZmgXKGWma10zk2StNA5160ec69TrpqfWQ08Vz9lKgUGAQejUqr9kc0oLVBHlDXUxQuSUj2hpVyhzvygslLS9LipFylXSMhvkSyrw6GUqYAQAAQj2nyVanBKtLAmXeACyABlDVnxV5ien6Z7BuUK9RWdVWpczDbKFZIZbmbx60ZkgjIVELoABSNaIFNFpL3893SLXACpUNaQMefcPEllGfTNplwhKefcQnnjR4am6K8dfdo6PGYb5QqH8Qf+jotdjTxOkZ9uRXSDmUUXoaNMBYQWgGDM999TrTpXJKmSwS6oJ8oaMuKcmy6vHBxW+XfOReJ+fClXSGWcvApXsgqbdLBCFrsIHeUKhzGzUjPrZWZDE73ktybFbYuiTAWEACAA/qwIlZJGp0hWLKk0NzlCU0VZQyb8/rWpBmQeUpGjXCGNcnlztaf6/qMLzNU+daVcIWiUqeAQAARnkqQJiQam+D/GlcpsmWs0b5kMbKKsISl/WsbhaWbXGK5DVwKWKFdIbo4Odqs4jF8+ogvMxffrplwhaJSpADgzCzsPTYbf37armY2P2RaRtELe05O6DHhBM+GcWyuv6bJLuiXRKWtIxJ+BZYUOr9zHKpJUZGYuwfGUKyTk99seLW8q2YqY7cWSFkp6w8wSPpWlXCEbft//IZJ6JevGQ5mqPwKAgPnR52gdHBAVkTSHvmiI5z+pfdD/s0gHn/5X6uBAp9nJ5m2nrCGeP+NPqn7aUSvj+tXGnoNyhYT8CtYcHZyBJfpv1rx060tQrpCKXz5myav4x6qQVG5mJUmOoUzVEQEAAAAA0IwwBgAAAABoRggAAAAAgGaEAAAAAABoRggAAAAAgGaEAAAAAABoRggAAAAAgGaEAAAAAABoRggAAAAAgGaEAAAAAABoRggAAABAzjnnhoSdh7pqzHkHJAIAAACQY865OZIqw85HPVQ45+aFnQmgrggAgCbEOTfZObfWObfdOWf+a61zriwuXcQ5t8LfF0233d9WnMP8RniSdijnXFnMdziuDsdPjvtea8tAzGttzLa01wjze6rv/UD+8SvO882sIuy81JWZVUqa45xbGHZegLogAACaEDMrNbNekib5m8rNrJeZjY5LV2lmQ/200adwQ/1t5TnM8guSchp0BMmvGBcFfNoSSfMkRepycEwZGO9vWhQtAzGvXn6aOfIqMSucc6muF+b3VK/7gbpriPIdDeLMbGWQ5w2DH8BUOOemh50XIFsEAEDTVBn3nsq2uPdcKpeXx8b6JHCYpECfjPuVitIAThW9p0m/VzMr9wOBbZLWpajshfY9BXg/kL3Ay7e8oHNGwOcMjZnNkFSSJoAG8g4BANA0ZVOZD60frpnNMLMujbgrQNBP/0PhtxBtk1SWZH9j/55QN0E//Z8ur0WqMff9T2SO/wIaDQIAAKi78emTNBozJBXRnQExgi7fsyTNDvic+WCBpAlhZwLIBgEAANSB312mUY5dSMTMFslrDZoVdl4QvqDLtz9+pKIJPv2PDgh+g0HqaEwIAAAgS35/34TdZRq5ckkRKjLNWwOV7/HyyldTVSZvwDrQKBSEnQF2YsWvAAAJW0lEQVQAjYM/b7ckbZUUnT1oduwTPb/isFBe3+Guks6XN3A0+lR5iKTxZlbpT59X5L8m+U+go+dZ628v949fG5OV0fKeTJaY2WGDQzPJp5+uLCafk8xskXNusrzZZrr5++bH5ss/brK8ykz0fHOcc7E//DPiZzjxn6ZGK9Xd/GvMyMOnoWXy8jla0iJJSvU9+fsnx50jIu97KzGzkgRlYry873ScDt6LrkpwrzNV1/vrd3caroODm7ea2dwkaSPy+nlX6mDZWhFfBjMoV0MkzYt+Vn961eiT9l6SZGZJK5IB5iOw8p2hYqWoIDfUfWvo7yNGuWg9Q2NiZrx48WpiL3k/aiZpYQZpV/hpI0n2F/lpihNcY4WkIQnSz/HPWSzvx1X+f5uk6f7fEUmT/W3j4s6xNv56Mfu2y6vw1DefEUnTo9f38xyJO5+lyMeQRHlPkq85cduK/c+R7NyRTM6dYRmYl8Ux4/xjVsTlJdn3NC/+vsZsXxt3jmiZmBMtA3H3aHuyvKa6H3W5v36asvjr+ec6LA/+vVwrqSiDc2RcrvxX/D1dmKh8N2Q+6lO+syhbFp/vXNy3hvw+kpTRpJ+RF698eoWeAV68eAX/ivnx3u5XDlK9TKkDgLWSJifZF61oRZJcf2Hcj+30uL8TVuwklSW53rxkP7J1zGf0x78syTlXpMhLpgFAskrtPEnbk+wLKwCIBmlr0+XHv3dJK0YJzhHNT7r7edh3mOp+1PH+pqpkJ6oEbk+Sr4SV6EzLleICobjvINFxDZKP+pTvDMtVkSTLNF0D3LcGOW+S7ydp0MmLVz69GAMANG3ldugCUIe9JCVtzve7SBRZgq42kjePvLzpI+OnwKuMSRP733Mts24vh0036Q8inCyvC0JF3L665jM6XWpl/Dlj8lHfqRAnO+dWJNheJq+/fT5NJRq9H10zSFuk1HPEx/f3jn7vCVdONa9byUp5XU6ymVM9q/vrd/EYpwSz0fj7yuR1gYpuiz4xPqxs+WVmpQ6f1z6TclUsv5tVgn1S3L1twHzkovxFlN2aJIHdtwY+b6LrsB4AGgUCAACplCj9wL1yeRXzRF6v43UPGYAY0498pSXuo13ffCab336bMqsMp7JSiddliF4znyoM0c+ayXz/b0iSv4pwotliks2LnmqNivny7kc2s89ke39nSbWzHiU6plKHjjmZrNT3o0LeglnJ9iWyzc9DNusqNFQ+6lu+M5FtkBHkfcvFeaMqlZv7CdQbg4ABpFKkFC0EvkrJG4iZ4Ae0Tj+oCSpnD8qryCWbl7y++VybIH0gzGxo7N/+E+kiHXzKnE8VhmhFLe33Zt5A7tHyu5I55yQvyCqTVFrHylT0OxyuxE9jE+Uj2/s7REmeRvutU11izhWRV+62JRjsHBVNk0iqcpXxAPAGzkcudFV2ixMGct9yeN5YvQI6D9CgCAAAJOR3h5Ay/+Eu0uEVx3r/qPpTUo6TN6tMoq5BQeSzQflPyMfLqwiVyasoz5c3JiKfRCsvGU0BaWblzrku8p5OR2dnKpY0yzk33u96lY3od5jVE+Ms728mwWJsWsnrSpewe5mkZNuDlC/5qKtsKv+N3dawMwBkgi5AAJKJVpIzfUIdeKXaf/L5oBJUfGIq/qHnM1b8HPp+3+2F8mZkGm9mdX06ngvRvC9Il9A5F3HORcys0h/bMdrMnLxAoEJeq0C23Zui32HGFcY63N9KZdjtyg5OdxlqK02+5EM6vHxnqLl0jYkoxw8XgLoiAACQkN8dolLpn8YW+ekb4ocvVdefK/zr5kM+Yw2P/odfWZoub+ByyqfhdagsB8p/il4kr/tOJi03wyRNiN9oZuV+t5xKJR9zkUw0qMuoBaKO9/cNZdfCkKuBsunkSz6Gp09ymOYyOLargutKBDQoAgAAqZRKGpKmcjpOGfbXzkZc15/4Rbzi8xNGPjP5oY8uDJToiXq0MhfNc3HIMwJFF5eKn0kmldEp9qVtRUjgCnkztWT6PdXl/pZJh7QgHSZuUPMipZkBJkW//CDlOh9BVmSj42+aehAQUfPq7oRGjAAAaJqyaW5P+qNsZjOU4kluTHeASVlcL61UXX98ExQzoK8B85n0Psa0JKSttCd5oh49rmvMeyiVB+fcPD8/52f49D9qXIpKXVcl7mt/RZI8FMur4GZdlrK5v/4sUhVKPkuRFBPY+GWrImaF6fh8pxp8m0zW3WFynY9sync6/rkyaaVLp6G6EdX7vNHg3eq2SjKQcwQAQNMUiXtPpWvce7yhkkoS9G0fIq8SNTpBBSx63XQ/+MmuHZ0r/rCuP/4P7QwdXlmuSz6j1012n9Ldv1J5U5BGr1Usb/Bp1Gx/e3yeiuVVjiv8fEveHO/R/KX7TjKR9hzOuWJ/Dv1hkoamqLwkO1elElSk/XseSdItpyLB/SiS953PSPL0P9n163p/R0sqSlSZ9rfFrxEwWl6wE3+diKRZCaamrU+5iu5L9L3lMh9S+vKdjTeUfJrSqIa6bw113lhDlPngciB0zszCzgOAgPhdAErkVbyjP1wVkir8Rb+i6SKSXvDTRCvplX7ahP2p/YrRVkndYjbPjq1Ux5w3ev1KeRX1Rf4TzNjzrUiQz6HyKgll8n5MY/MRzWu0e8bouuYzxfVL/JltpuvgfYzem3IzSxSQRJ+el8nrvhI/WLlYXsBSoYOtFiv960QrvhV+Hlcmydf4TJ8s+mVghg4NvuLnyu+qgwMW56XqcpPme4rI+46iXXFqZ0CJr4z6n3WtvKBupbz7G/2eIn4+DvuM6e5Htvc37txzdLCcbk2U7wTpY2eR2prgc9apXCX4f+ewz5qLfCT4zCnLd6b8cjk60TXqk9909y0X34ef/3ny7k82XeiA0BAAAAAaXGwAkEUffzQRfoV6nZl1SZu4EXLOrZUX4DALEBoFugABAIAG5bfAlddxGtG85nd5q6Tyj8aEAAAAAOTCbB3sLtaUzFJ2s2cBoSMAAAAADc7vO/9GU2oF8MegJBvwDuQtAgAAQC7ET8uJ5mmGmlYrwBwlXqgQyGsMAgYANBh/8Gd0JpaorGY2QtPi95kvMbOStInzmD8bUxlP/9EYEQAAAICc8meFGtJYZ4Tyu/5sI4hFY0UAAAAAADQjjAEAAAAAmhECAAAAAKAZIQAAAAAAmhECAAAAAKAZIQAAAAAAmhECAAAAAKAZ+f9dUAYJxJceVwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 864x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Figures have been saved in C:\\Users\\godio\\Dropbox\\02_POSTPROCESSING_DATA\\OUTPUT_PLOTS\n"
+     ]
+    }
+   ],
+   "source": [
+    "for test in range(test_number):\n",
+    "    legend_tmp = str(test_unit(test)) + \"\\n $\\sigma_v/f_{cm}=$\" + str(wall['alr'][test]) + \"\\n loading: \" + wall['LH'][test]\n",
+    "    if test == test_number - 1:\n",
+    "        adjust_axis = 0\n",
+    "    else:\n",
+    "        adjust_axis = 1    \n",
+    "    plot_one(where_to_save_pic + '\\\\' + 'Test_' + test_unit(test) + \"_F_vs_u\",\n",
+    "                     sc_tests.dataset['Test' + str(test)]['u'],\n",
+    "                     sc_tests.dataset['Test' + str(test)]['F'],\n",
+    "                     'k','Horizontal Displacement (mm)','Horizontal Force (kN)',\n",
+    "                     legend_tmp,'upper left',adjust_axis*-45,45,adjust_axis*-150,150,None,30,12,10,True)\n",
+    "    \n",
+    "print(\" Figures have been saved in \" + where_to_save_pic)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.4</span> Plot horizontal force-vertical force diagram"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section plots the <b>F-N</b> diagrams for each test. This can be used for checking the loss in vertical load bearing wall capacity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Figures have been saved in C:\\Users\\godio\\Dropbox\\02_POSTPROCESSING_DATA\\OUTPUT_PLOTS\n"
+     ]
+    }
+   ],
+   "source": [
+    "for test in range(test_number):\n",
+    "    legend_tmp = str(test_unit(test)) + \"\\n $\\sigma_v/f_{cm}=$\" + str(wall['alr'][test]) + \"\\n loading: \" + wall['LH'][test]\n",
+    "    plot_one(where_to_save_pic + '\\\\' + 'Test_' + test_unit(test) + \"_F_vs_N\",\n",
+    "                     sc_tests.dataset['Test' + str(test)]['N'],\n",
+    "                     sc_tests.dataset['Test' + str(test)]['F'],\n",
+    "                     'k','Vertical Force (kN)','Horizontal Force (kN)',\n",
+    "                     legend_tmp,'upper right',-300,0,-150,150,None,30,12,10,False)\n",
+    "    \n",
+    "print(\" Figures have been saved in \" + where_to_save_pic)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.5</span> Plot vertical-horizontal displacement diagram"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section plots the <b>v-u</b> diagrams for each test. This can also be used for checking the loss in vertical load bearing wall capacity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Figures have been saved in C:\\Users\\godio\\Dropbox\\02_POSTPROCESSING_DATA\\OUTPUT_PLOTS\n"
+     ]
+    }
+   ],
+   "source": [
+    "for test in range(test_number):\n",
+    "    legend_tmp = str(test_unit(test)) + \"\\n $\\sigma_v/f_{cm}=$\" + str(wall['alr'][test]) + \"\\n loading: \" + wall['LH'][test]\n",
+    "    if test == test_number - 1:\n",
+    "        lim_x_low = 0\n",
+    "        lim_x_upp = 90\n",
+    "        lim_y_low = -25\n",
+    "        lim_y_upp = 5\n",
+    "    else:\n",
+    "        lim_x_low = -45 \n",
+    "        lim_x_upp = 45\n",
+    "        lim_y_low = -25\n",
+    "        lim_y_upp = 5\n",
+    "    plot_one(where_to_save_pic + '\\\\' + 'Test_' + test_unit(test) + \"_v_vs_u\",\n",
+    "                     sc_tests.dataset['Test' + str(test)]['u'],\n",
+    "                     sc_tests.dataset['Test' + str(test)]['v'],\n",
+    "                     'k','Horizontal Displacement (mm)','Vertical Displacement (mm)',\n",
+    "                     legend_tmp,'upper right',lim_x_low,lim_x_upp,lim_y_low,lim_y_upp,None,30,12,10,False)\n",
+    "    \n",
+    "print(\" Figures have been saved in \" + where_to_save_pic)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.6</span> Plot vertical force-displacement diagram"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section plots the <b>N-v</b> diagrams for each test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Figures have been saved in C:\\Users\\godio\\Dropbox\\02_POSTPROCESSING_DATA\\OUTPUT_PLOTS\n"
+     ]
+    }
+   ],
+   "source": [
+    "for test in range(test_number):\n",
+    "    legend_tmp = str(test_unit(test)) + \"\\n $\\sigma_v/f_{cm}=$\" + str(wall['alr'][test]) + \"\\n loading: \" + wall['LH'][test]\n",
+    "    lim_x_low = -30 \n",
+    "    lim_x_upp = 5\n",
+    "    lim_y_low = -300\n",
+    "    lim_y_upp = 0\n",
+    "    plot_one(where_to_save_pic + '\\\\' + 'Test_' + test_unit(test) + \"_N_vs_v\",\n",
+    "                     sc_tests.dataset['Test' + str(test)]['v'],\n",
+    "                     sc_tests.dataset['Test' + str(test)]['N'],\n",
+    "                     'k','Vertical Displacement (mm)','Vertical Force (kN)',\n",
+    "                     legend_tmp,'upper right',lim_x_low,lim_x_upp,lim_y_low,lim_y_upp,None,30,12,10,False)\n",
+    "    \n",
+    "print(\" Figures have been saved in \" + where_to_save_pic)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.7</span> Plot loading history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section plots the <b>u-sampling step</b> diagrams for each test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Figures have been saved in C:\\Users\\godio\\Dropbox\\02_POSTPROCESSING_DATA\\OUTPUT_PLOTS\n"
+     ]
+    }
+   ],
+   "source": [
+    "for test in range(test_number):\n",
+    "    legend_tmp = str(test_unit(test)) + \"\\n $\\sigma_v/f_{cm}=$\" + str(wall['alr'][test]) + \"\\n loading: \" + wall['LH'][test]\n",
+    "    if test == test_number - 1:\n",
+    "        lim_x_low = 0 \n",
+    "        lim_x_upp = 3000\n",
+    "        lim_y_low = -0\n",
+    "        lim_y_upp = 90\n",
+    "    else:\n",
+    "        lim_x_low = 0 \n",
+    "        lim_x_upp = 3000\n",
+    "        lim_y_low = -45\n",
+    "        lim_y_upp = 45\n",
+    "    plot_one(where_to_save_pic + '\\\\' + 'Test_' + test_unit(test) + \"_LH\",\n",
+    "                     sc_tests.dataset['Test' + str(test)]['ss'],\n",
+    "                     sc_tests.dataset['Test' + str(test)]['u'],\n",
+    "                     'k','Sampling Steps','Horizontal Displacement (mm)',\n",
+    "                     legend_tmp,'upper right',lim_x_low,lim_x_upp,lim_y_low,lim_y_upp,None,30,12,5,False)\n",
+    "    \n",
+    "print(\" Figures have been saved in \" + where_to_save_pic)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.8</span> Calculate envelope curves"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section computes the <b>F-u envelope curves</b> starting from the experimental curves. The envelopes are save in the dictionary <b>envelope</b> having the following structure:\n",
+    "<ul>\n",
+    "    <li><b>envelope.positive</b> = including the positive envelope </li>\n",
+    "    <li><b>envelope.negative</b> = including the negative envelope </li>\n",
+    "</ul>\n",
+    "Inside the dictionaries <b>positive</b> and <b>negative</b> the following variables are contained:\n",
+    "<ul>\n",
+    "    <li><b>F</b> = horizontal force </li>\n",
+    "    <li><b>u</b> = horizontal displacement </li>\n",
+    "</ul>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Envelope curves have been calculated for all test units\n"
+     ]
+    }
+   ],
+   "source": [
+    "# loop over the test units\n",
+    "envelope = {}\n",
+    "for test in range(test_number):\n",
+    "    \n",
+    "    # initialize\n",
+    "    envelope['Test' + str(test)] = {\n",
+    "        'positive': {},\n",
+    "        'negative': {} \n",
+    "    }\n",
+    "    u = []; V = []\n",
+    "    uPos = []; VPos = []; indPos = []\n",
+    "    uNeg = []; VNeg = []; indNeg = []\n",
+    "    uEPos = []; VEPos = []    \n",
+    "    uENeg = []; VENeg = []\n",
+    "    \n",
+    "    # tmp arrays used for brevity in the notation\n",
+    "    u = np.array(sc_tests.dataset['Test' + str(test)]['u'])\n",
+    "    V = np.array(sc_tests.dataset['Test' + str(test)]['F'])\n",
+    "\n",
+    "    # define type of loading\n",
+    "    if test == 5:\n",
+    "        # monotonic\n",
+    "        type = 1 \n",
+    "    else:\n",
+    "        # cyclic\n",
+    "        type = 0 \n",
+    "    \n",
+    "    # calculate envelope response\n",
+    "    if type == 1:\n",
+    "        uEPos, VEPos = fEnvelope(u,V,1)\n",
+    "        uENeg = uEPos \n",
+    "        VENeg = VEPos\n",
+    "    else:\n",
+    "        #positive response\n",
+    "        uPos = np.array([val for val in u if val >= 0])\n",
+    "        indPos = [ind for ind in range(len(u)) if u[ind] >= 0]\n",
+    "        VPos = np.array([V[ind] for ind in indPos])\n",
+    "        # negative response\n",
+    "        uNeg = np.array([val for val in u if val <= 0])\n",
+    "        indNeg = [ind for ind in range(len(u)) if u[ind] <= 0]\n",
+    "        VNeg = np.array([V[ind] for ind in indNeg])\n",
+    "        # envelopes\n",
+    "        uEPos, VEPos = fEnvelope(uPos,VPos,1)\n",
+    "        uENeg, VENeg = fEnvelope(-uNeg,-VNeg,2)\n",
+    "        \n",
+    "        # apply corrections\n",
+    "        if test == 0:\n",
+    "            uEPosTmp = []\n",
+    "            VEPosTmp = []\n",
+    "            oo = 0;\n",
+    "            jobdone = 0;\n",
+    "            for kk in range(len(uEPos)):\n",
+    "                if kk > 40 and kk < 49:\n",
+    "                    if jobdone == 0:\n",
+    "                        oo += 1\n",
+    "                        uEPosTmp = np.append(uEPosTmp,1.05)\n",
+    "                        VEPosTmp = np.append(VEPosTmp,66.03)\n",
+    "                        jobdone = 1\n",
+    "                else:\n",
+    "                    oo += 1\n",
+    "                    uEPosTmp = np.append(uEPosTmp,uEPos[kk]);\n",
+    "                    VEPosTmp = np.append(VEPosTmp,VEPos[kk]);\n",
+    "            uEPos = []\n",
+    "            VEPos = []\n",
+    "            uEPos = uEPosTmp\n",
+    "            VEPos = VEPosTmp\n",
+    "\n",
+    "    # save in dictionary\n",
+    "    envelope['Test' + str(test)]['positive']['F'] = VEPos\n",
+    "    envelope['Test' + str(test)]['positive']['u'] = uEPos\n",
+    "    envelope['Test' + str(test)]['negative']['F'] = VENeg\n",
+    "    envelope['Test' + str(test)]['negative']['u'] = uENeg\n",
+    "    \n",
+    "print(\" Envelope curves have been calculated for all test units\")\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.9</span> Plot envelope curves"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section plots the <b>F-u envelope curves</b> for each test and for the two sets of tests investigated in the campaign. The plot of <b>Fig.5</b> and <b>Fig.8</b> in Godio et al. (2019) are reproduced"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Figures have been saved in C:\\Users\\godio\\Dropbox\\02_POSTPROCESSING_DATA\\OUTPUT_PLOTS\n"
+     ]
+    }
+   ],
+   "source": [
+    "# plot for each test unit\n",
+    "for test in range(test_number):\n",
+    "    legend_tmp = str(test_unit(test)) + \"\\n $\\sigma_v/f_{cm}=$\" + str(wall['alr'][test]) + \"\\n loading: \" + wall['LH'][test]\n",
+    "    if test == test_number - 1:\n",
+    "        adjust_axis = 0\n",
+    "    else:\n",
+    "        adjust_axis = 1  \n",
+    "    lim_x_low = -45*adjust_axis\n",
+    "    lim_x_upp = 45\n",
+    "    lim_y_low = -150*adjust_axis\n",
+    "    lim_y_upp = 150\n",
+    "    plot_multi(where_to_save_pic + '\\\\' + 'Test_' + test_unit(test) + \"_Envelopes\",\n",
+    "                    [sc_tests.dataset['Test' + str(test)]['u'],envelope['Test' + str(test)]['positive']['u'],-envelope['Test' + str(test)]['negative']['u']],\n",
+    "                    [sc_tests.dataset['Test' + str(test)]['F'],envelope['Test' + str(test)]['positive']['F'],-envelope['Test' + str(test)]['negative']['F']],\n",
+    "                    ['k','b','r'],'Horizontal Displacement (mm)','Horizontal Force (kN)',\n",
+    "                    legend_tmp,'upper left',lim_x_low,lim_x_upp,lim_y_low,lim_y_upp,None,30,12,10,False)\n",
+    "\n",
+    "# effect of axial load ratio\n",
+    "legend_tmp = None\n",
+    "lim_x_low = -45\n",
+    "lim_x_upp = 45\n",
+    "lim_y_low = -150\n",
+    "lim_y_upp = 150\n",
+    "plot_multi(where_to_save_pic + '\\\\' + \"Envelopes_01_axial_load_ratio\",\n",
+    "                [   envelope['Test0']['positive']['u'],-envelope['Test0']['negative']['u'], \n",
+    "                    envelope['Test1']['positive']['u'],-envelope['Test1']['negative']['u'], \n",
+    "                    envelope['Test2']['positive']['u'],-envelope['Test2']['negative']['u'], \n",
+    "                    envelope['Test3']['positive']['u'],-envelope['Test3']['negative']['u'] \n",
+    "                ],\n",
+    "                [   envelope['Test0']['positive']['F'],-envelope['Test0']['negative']['F'], \n",
+    "                    envelope['Test1']['positive']['F'],-envelope['Test1']['negative']['F'], \n",
+    "                    envelope['Test2']['positive']['F'],-envelope['Test2']['negative']['F'], \n",
+    "                    envelope['Test3']['positive']['F'],-envelope['Test3']['negative']['F'] \n",
+    "                ],\n",
+    "                ['k','k','darkred','darkred','r','r','firebrick','firebrick'],'Horizontal Displacement (mm)','Horizontal Force (kN)',\n",
+    "                legend_tmp,'upper left',lim_x_low,lim_x_upp,lim_y_low,lim_y_upp,None,30,12,10,False)\n",
+    "\n",
+    "# effect of load history\n",
+    "legend_tmp = None\n",
+    "lim_x_low = -45\n",
+    "lim_x_upp = 45\n",
+    "lim_y_low = -150\n",
+    "lim_y_upp = 150\n",
+    "plot_multi(where_to_save_pic + '\\\\' + \"Envelopes_02_load_history\",\n",
+    "                [    \n",
+    "                    envelope['Test4']['positive']['u'],-envelope['Test4']['negative']['u'], \n",
+    "                    envelope['Test5']['positive']['u'],-envelope['Test5']['negative']['u'], \n",
+    "                    envelope['Test3']['positive']['u'],-envelope['Test3']['negative']['u'] \n",
+    "                ],\n",
+    "                [    \n",
+    "                    envelope['Test4']['positive']['F'],-envelope['Test4']['negative']['F'], \n",
+    "                    envelope['Test5']['positive']['F'],-envelope['Test5']['negative']['F'], \n",
+    "                    envelope['Test3']['positive']['F'],-envelope['Test3']['negative']['F'] \n",
+    "                ],\n",
+    "                ['r','r','k','k','firebrick','firebrick'],'Horizontal Displacement (mm)','Horizontal Force (kN)',\n",
+    "                legend_tmp,'upper left',lim_x_low,lim_x_upp,lim_y_low,lim_y_upp,None,30,12,10,False)\n",
+    "    \n",
+    "print(\" Figures have been saved in \" + where_to_save_pic)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## <span style=\"color: red;\">1.10</span> Calculate key parameters"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This section computes the key parameters of the wall structural behaviour. The results contained in <b>Table 3</b> and <b>Table 4</b> of Godio et al. (2019) are reproduced. The parameters are appended to the <b>key</b>  dictionary. Inside the dictionary the following variables are added:\n",
+    "<ul>\n",
+    "    <li> <b>peak_force</b> = peak shear force, <b>$V_\\text{max}$</b> </li>\n",
+    "    <li> <b>initial_stiffness</b> = initial stiffness calculated as secant stiffness at 15% the peak force, <b>$K_\\text{init}$</b> </li>\n",
+    "    <li> <b>delta_cracking</b> = drift corresponding at the onset of cracking in the masonry, <b>$\\delta_\\text{cr}$</b> </li>\n",
+    "    <li> <b>delta_yielding</b> = drift at the yielding point of the bi-linear curve, <b>$\\delta_\\text{y}$</b> </li>\n",
+    "    <li> <b>delta_max</b> = drift measured when the peak force is reached, <b>$\\delta_\\text{max}$</b> </li>\n",
+    "    <li> <b>delta_SD</b> = drift at the Severe Damage (SD) limit state, <b>$\\delta_\\text{SD}$</b> </li>\n",
+    "    <li> <b>delta_ultimate</b> = ultimate drift, <b>$\\delta_\\text{u}$</b> </li>\n",
+    "    <li> <b>delta_collapse</b> = drift at collapse, <b>$\\delta_\\text{c}$</b> </li>\n",
+    "</ul>\n",
+    "Each variable contains values for both the positive and the negative envelopes, e.g. <b>peak_force.positive</b> and <b>peak_force.pegative</b>, plus the average value <b>peak_force.average</b>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize the key dictionary\n",
+    "key = {}\n",
+    "for test in range(test_number):\n",
+    "    \n",
+    "    key['Test' + str(test)] = {\n",
+    "        'peak_force':{},\n",
+    "        'initial_stiffness':{},\n",
+    "        'delta_cracking':{},\n",
+    "        'delta_yielding':{},\n",
+    "        'delta_max':{},\n",
+    "        'delta_SD':{},\n",
+    "        'delta_ultimate':{},\n",
+    "        'delta_collapse':{},\n",
+    "    }\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Peak force"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Peak force (kN)\n",
+      "\n",
+      "Test unit      Positive    Negative    Average\n",
+      "-----------  ----------  ----------  ---------\n",
+      "SC1                  74         -77         76\n",
+      "SC2                  90         -89         90\n",
+      "SC4                 142        -133        138\n",
+      "SC5                 112        -107        110\n",
+      "SC6                 109        -106        108\n",
+      "SC7                 103        -103        103\n"
+     ]
+    }
+   ],
+   "source": [
+    "# initialize\n",
+    "tmp_table = []\n",
+    "\n",
+    "# loop over the test units\n",
+    "for test in range(test_number):\n",
+    "    \n",
+    "    # save in dictionary\n",
+    "    key['Test' + str(test)]['peak_force']['positive'] = max(envelope['Test' + str(test)]['positive']['F'])\n",
+    "    key['Test' + str(test)]['peak_force']['negative'] = max(envelope['Test' + str(test)]['negative']['F'])\n",
+    "    key['Test' + str(test)]['peak_force']['average'] = (key['Test' + str(test)]['peak_force']['positive'] + key['Test' + str(test)]['peak_force']['negative'])/2\n",
+    "    \n",
+    "    # save in tmp table to plot\n",
+    "    tmp_table.append([test_unit(test), format(key['Test' + str(test)]['peak_force']['positive'],'.0f'), format(-key['Test' + str(test)]['peak_force']['negative'],'.0f'), format(key['Test' + str(test)]['peak_force']['average'], '.0f')])\n",
+    "    \n",
+    "# print\n",
+    "print('Peak force (kN)\\n')\n",
+    "print(tabulate(tmp_table, headers=['Test unit', 'Positive', 'Negative', 'Average']))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Initial stiffness"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial stiffness (kN/mm)\n",
+      "\n",
+      "Test unit      Positive    Negative    Average\n",
+      "-----------  ----------  ----------  ---------\n",
+      "SC1                 184        -177        180\n",
+      "SC2                 207        -235        221\n",
+      "SC4                 267        -295        281\n",
+      "SC5                 247        -216        231\n",
+      "SC6                 226        -225        225\n",
+      "SC7                 216        -216        216\n"
+     ]
+    }
+   ],
+   "source": [
+    "# initialize\n",
+    "tmp_table = []\n",
+    "beta = 0.15\n",
+    "\n",
+    "# loop over the test units\n",
+    "for test in range(test_number):\n",
+    "    \n",
+    "    # positive value\n",
+    "    u = []; F = []; f = []; u_pre = []; F_pre = []; ind_15_pos = []\n",
+    "    u = envelope['Test' + str(test)]['positive']['u']\n",
+    "    F = envelope['Test' + str(test)]['positive']['F']\n",
+    "    F_15_pos = beta*key['Test' + str(test)]['peak_force']['positive']\n",
+    "    ind_15_pos = [ind for ind in range(len(F)) if F[ind] >= F_15_pos]\n",
+    "    F_pre = F[0:ind_15_pos[0]+1]\n",
+    "    u_pre = u[0:ind_15_pos[0]+1]\n",
+    "    f = interp1d(F_pre, u_pre)\n",
+    "    u_15_pos = f(F_15_pos)\n",
+    "    key['Test' + str(test)]['initial_stiffness']['positive'] = F_15_pos/u_15_pos\n",
+    "\n",
+    "    # negative value\n",
+    "    u = []; F = []; f = []; u_pre = []; F_pre = []; ind_15_neg = []\n",
+    "    u = envelope['Test' + str(test)]['negative']['u']\n",
+    "    F = envelope['Test' + str(test)]['negative']['F']\n",
+    "    F_15_neg = beta*key['Test' + str(test)]['peak_force']['negative']\n",
+    "    ind_15_neg = [ind for ind in range(len(F)) if F[ind] >= F_15_neg]\n",
+    "    F_pre = F[0:ind_15_neg[0]+1]\n",
+    "    u_pre = u[0:ind_15_neg[0]+1]\n",
+    "    f = interp1d(F_pre, u_pre)\n",
+    "    u_15_neg = f(F_15_neg)\n",
+    "    key['Test' + str(test)]['initial_stiffness']['negative'] = F_15_neg/u_15_neg\n",
+    "    \n",
+    "    # average value\n",
+    "    key['Test' + str(test)]['initial_stiffness']['average'] = (key['Test' + str(test)]['initial_stiffness']['positive'] + key['Test' + str(test)]['initial_stiffness']['negative'])/2\n",
+    "    \n",
+    "    # save in tmp table to plot\n",
+    "    tmp_table.append([test_unit(test), format(key['Test' + str(test)]['initial_stiffness']['positive'],'.0f'), format(-key['Test' + str(test)]['initial_stiffness']['negative'],'.0f'), format(key['Test' + str(test)]['initial_stiffness']['average'], '.0f')])\n",
+    "\n",
+    "# print\n",
+    "print('Initial stiffness (kN/mm)\\n')\n",
+    "print(tabulate(tmp_table, headers=['Test unit', 'Positive', 'Negative', 'Average']))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Drift at masonry craking"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Drift at cracking (%)\n",
+      "\n",
+      "Test unit      Positive    Negative    Average\n",
+      "-----------  ----------  ----------  ---------\n",
+      "SC1                0.11       -0.1        0.11\n",
+      "SC2                0.09       -0.08       0.08\n",
+      "SC4                0.07       -0.06       0.07\n",
+      "SC5                0.11       -0.14       0.13\n",
+      "SC6                0.1        -0.12       0.11\n",
+      "SC7                0.16       -0.16       0.16\n"
+     ]
+    }
+   ],
+   "source": [
+    "# initialize\n",
+    "tmp_table = []\n",
+    "\n",
+    "# displacement values measured after visual inspection + DIC check\n",
+    "def disp_cracking_positive(i):\n",
+    "    switcher={\n",
+    "            0:1.0145,\n",
+    "            1:0.8284,\n",
+    "            2:0.6674,\n",
+    "            3:1.0204,\n",
+    "            4:0.9239,\n",
+    "            5:1.48\n",
+    "            }\n",
+    "    return switcher.get(i)\n",
+    "def disp_cracking_negative(i):\n",
+    "    switcher={\n",
+    "            0:0.8821,\n",
+    "            1:0.6767,\n",
+    "            2:0.514,\n",
+    "            3:1.29,\n",
+    "            4:1.0567,\n",
+    "            5:1.48\n",
+    "            }\n",
+    "    return switcher.get(i)\n",
+    "\n",
+    "# loop over the test units\n",
+    "for test in range(test_number):\n",
+    "    \n",
+    "    # positive negative and average values\n",
+    "    key['Test' + str(test)]['delta_cracking']['positive'] = disp_cracking_positive(test)/wall['height'][test]*100\n",
+    "    key['Test' + str(test)]['delta_cracking']['negative'] = disp_cracking_negative(test)/wall['height'][test]*100\n",
+    "    key['Test' + str(test)]['delta_cracking']['average'] = (key['Test' + str(test)]['delta_cracking']['positive'] + key['Test' + str(test)]['delta_cracking']['negative'])/2\n",
+    "    \n",
+    "    # save in tmp table to plot\n",
+    "    tmp_table.append([test_unit(test), format(key['Test' + str(test)]['delta_cracking']['positive'],'.2f'), format(-key['Test' + str(test)]['delta_cracking']['negative'],'.2f'), format(key['Test' + str(test)]['delta_cracking']['average'], '.2f')])\n",
+    "\n",
+    "# print\n",
+    "print('Drift at cracking (%)\\n')\n",
+    "print(tabulate(tmp_table, headers=['Test unit', 'Positive', 'Negative', 'Average']))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Drift at yielding"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# tbd delta_yielding"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Drift at peak"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Drift at peak (%)\n",
+      "\n",
+      "Test unit      Positive    Negative    Average\n",
+      "-----------  ----------  ----------  ---------\n",
+      "SC1                0.17       -0.54       0.36\n",
+      "SC2                0.2        -0.12       0.16\n",
+      "SC4                0.41       -0.39       0.4\n",
+      "SC5                0.29       -0.45       0.37\n",
+      "SC6                0.21       -0.37       0.29\n",
+      "SC7                0.64       -0.64       0.64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# initialize\n",
+    "tmp_table = []\n",
+    "\n",
+    "# loop over the test units\n",
+    "for test in range(test_number):\n",
+    "    \n",
+    "    # positive value\n",
+    "    u = []; F = []\n",
+    "    u = envelope['Test' + str(test)]['positive']['u']\n",
+    "    F = envelope['Test' + str(test)]['positive']['F']\n",
+    "    ind_peak = [ind for ind in range(len(F)) if F[ind] >= key['Test' + str(test)]['peak_force']['positive']]\n",
+    "    key['Test' + str(test)]['delta_max']['positive'] = u[ind_peak[0]]/wall['height'][test]*100\n",
+    "    \n",
+    "    # negative value\n",
+    "    u = []; F = []\n",
+    "    u = envelope['Test' + str(test)]['negative']['u']\n",
+    "    F = envelope['Test' + str(test)]['negative']['F']\n",
+    "    ind_peak = [ind for ind in range(len(F)) if F[ind] >= key['Test' + str(test)]['peak_force']['negative']]\n",
+    "    key['Test' + str(test)]['delta_max']['negative'] = u[ind_peak[0]]/wall['height'][test]*100\n",
+    "\n",
+    "    # average value\n",
+    "    key['Test' + str(test)]['delta_max']['average'] = (key['Test' + str(test)]['delta_max']['positive'] + key['Test' + str(test)]['delta_max']['negative'])/2\n",
+    "    \n",
+    "    # save in tmp table to plot\n",
+    "    tmp_table.append([test_unit(test), format(key['Test' + str(test)]['delta_max']['positive'],'.2f'), format(-key['Test' + str(test)]['delta_max']['negative'],'.2f'), format(key['Test' + str(test)]['delta_max']['average'], '.2f')])\n",
+    "    \n",
+    "# print\n",
+    "print('Drift at peak (%)\\n')\n",
+    "print(tabulate(tmp_table, headers=['Test unit', 'Positive', 'Negative', 'Average']))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Drift at SD limit state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}