From 2c5306e1e83436edbe1948f7a0c76faf84cc08ed Mon Sep 17 00:00:00 2001 From: swfwmd Date: Fri, 24 Sep 2021 15:34:55 -0400 Subject: [PATCH 01/14] modflowusg --- .../flopy3_mfusg_conduit_examples.ipynb | 1688 +++++++++++++++++ .../mfusg_test/03_conduit_confined/ex3.cln | 2 +- .../mfusg_test/03_conduit_confined/ex3.nam | 1 + flopy/__init__.py | 1 + flopy/modflowusg/__init__.py | 7 + flopy/modflowusg/mfusg.py | 415 ++++ flopy/modflowusg/mfusgbcf.py | 697 +++++++ flopy/modflowusg/mfusgbct.py | 176 ++ flopy/modflowusg/mfusgcln.py | 1077 +++++++++++ flopy/modflowusg/mfusggnc.py | 351 ++++ flopy/modflowusg/mfusglpf.py | 863 +++++++++ flopy/modflowusg/mfusgsms.py | 652 +++++++ flopy/modflowusg/mfusgwel.py | 721 +++++++ setup.py | 1 + 14 files changed, 6651 insertions(+), 1 deletion(-) create mode 100644 examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb create mode 100644 flopy/modflowusg/__init__.py create mode 100644 flopy/modflowusg/mfusg.py create mode 100644 flopy/modflowusg/mfusgbcf.py create mode 100644 flopy/modflowusg/mfusgbct.py create mode 100644 flopy/modflowusg/mfusgcln.py create mode 100644 flopy/modflowusg/mfusggnc.py create mode 100644 flopy/modflowusg/mfusglpf.py create mode 100644 flopy/modflowusg/mfusgsms.py create mode 100644 flopy/modflowusg/mfusgwel.py diff --git a/examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb b/examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb new file mode 100644 index 0000000000..d36e85f951 --- /dev/null +++ b/examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb @@ -0,0 +1,1688 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1c06d1db-0156-4a25-a1b0-4e0f2f08a2cf", + "metadata": {}, + "source": [ + "# FloPy\n", + "## MODFLOW-USG CLN package demo\n", + "This example problem demonstrates use of the CLN process for simulating flow to a well pumping from two aquifers seperated by an impermeable confining unit. A structured finite-difference grid with 100 rows and 100 columns was used. Each square cells is 470m by 470 m in extent. Initial heads are 10m in aquifer 1 and 30m in aquifer 2." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2a47ab0b-115d-453e-a02c-53575fb125b2", + "metadata": {}, + "outputs": [], + "source": [ + "import os, shutil\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import flopy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7b3c55ef-88bc-40a5-9854-56b1aaac0489", + "metadata": {}, + "outputs": [], + "source": [ + "cln_ws= os.path.join('../data', 'usg_test')\n", + "\n", + "if not os.path.exists(cln_ws):\n", + " os.mkdir(cln_ws)" + ] + }, + { + "cell_type": "markdown", + "id": "2f98f702-e94c-4a59-9380-971d4884da10", + "metadata": {}, + "source": [ + "## Loading Example 03_conduit_confined\n", + "The elevation of the top of layer 1 is -100 m, the bottom of layer 1 is -110 m, the top of layer 2 is -120 m and the bottom of layer 2 is -130 m. The confining unit between layers1 and 2 is impermeable and is represented using a quasi-three-dimensional approach. The only way a stress from one aquifer can be propagated to another is through the cln well that penetrates both aquifers.\n", + "\n", + "The hydraulic conductivity values of the upper and lower aquifers are 100 and 400 m/d, respectively. Both aquifers have a primaey storage coefficient of 0.0001 and a specific yield of 0.01.\n", + "\n", + "A vertical conduit well is located at the center of the domain and has a radius of 0.5 m. The well pumps 62,840 m3/d and is open fully to both aquifers from top to bottom. The CLN Process was used with a circular conduit geometry type to discretize the well bore with two conduit cells, one in each layer. The WEL Package was used to pump from the bottom CLN cell.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f2fe115d-e9bb-40cb-8cbb-3ff2b6533597", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Creating new model with name: ex3\n", + "--------------------------------------------------\n", + "\n", + "Parsing the namefile --> ../data/mfusg_test\\03_conduit_confined\\ex3.nam\n", + "could not set filehandle to ex3.lst\n", + "could not set filehandle to ex3.cbb\n", + "could not set filehandle to ex3.hds\n", + "could not set filehandle to ex3.ddn\n", + "could not set filehandle to ex3.clncbb\n", + "could not set filehandle to ex3.clnhds\n", + "\n", + "--------------------------------------------------\n", + "External unit dictionary:\n", + "{7: filename:../data/mfusg_test\\03_conduit_confined\\ex3.lst, filetype:LIST, 1: filename:../data/mfusg_test\\03_conduit_confined\\ex3.bas, filetype:BAS6, 14: filename:../data/mfusg_test\\03_conduit_confined\\ex3.wel, filetype:WEL, 12: filename:../data/mfusg_test\\03_conduit_confined\\ex3.dis, filetype:DIS, 11: filename:../data/mfusg_test\\03_conduit_confined\\ex3.bcf, filetype:BCF6, 13: filename:../data/mfusg_test\\03_conduit_confined\\ex3.cln, filetype:CLN, 22: filename:../data/mfusg_test\\03_conduit_confined\\ex3.oc, filetype:OC, 19: filename:../data/mfusg_test\\03_conduit_confined\\ex3.sms, filetype:SMS, 50: filename:../data/mfusg_test\\03_conduit_confined\\ex3.cbb, filetype:DATA(BINARY), 30: filename:../data/mfusg_test\\03_conduit_confined\\ex3.hds, filetype:DATA(BINARY), 31: filename:../data/mfusg_test\\03_conduit_confined\\ex3.ddn, filetype:DATA(BINARY), 35: filename:../data/mfusg_test\\03_conduit_confined\\ex3.clncbb, filetype:DATA(BINARY), 36: filename:../data/mfusg_test\\03_conduit_confined\\ex3.clnhds, filetype:DATA(BINARY)}\n", + "--------------------------------------------------\n", + "\n", + "ModflowBas6 free format:True\n", + "\n", + "loading dis package file...\n", + " Loading dis package with:\n", + " 2 layers, 100 rows, 100 columns, and 1 stress periods\n", + " loading laycbd...\n", + " loading delr...\n", + " loading delc...\n", + " loading top...\n", + " loading botm...\n", + " for 2 layers and 1 confining beds\n", + " loading stress period data...\n", + " for 1 stress periods\n", + "adding Package: DIS\n", + " DIS package load...success\n", + " LIST package load...skipped\n", + "loading bas6 package file...\n", + "adding Package: BAS6\n", + " BAS6 package load...success\n", + "loading wel package file...\n", + " loading well data for kper 1\n", + "Adding ex3.cbb (unit=50) to the output list.\n", + "adding Package: WEL\n", + " WEL package load...success\n", + "loading bcf package file...\n", + " loading ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET...\n", + " loading LAYCON...\n", + " loading TRPY...\n", + " loading sf1 layer 1...\n", + " loading hy layer 1...\n", + " loading vcont layer 1...\n", + " loading sf2 layer 1...\n", + " loading sf1 layer 2...\n", + " loading hy layer 2...\n", + " loading sf2 layer 2...\n", + "adding Package: BCF6\n", + " BCF6 package load...success\n", + "loading CLN package file...\n", + "\n", + " ncln 1\n", + " iclnnds -1\n", + " iclncb 35\n", + " iclnhd -36\n", + " iclndd 0\n", + " iclnib 0\n", + " nclngwc 2\n", + " TRANSIENT False\n", + " PRINTIAJA False\n", + " RECTANGULAR 0\n", + " BHEDETAIL False\n", + " SAVECLNCON 0\n", + " SAVECLNMAS 0\n", + " GRAVITY None\n", + " VISCOSITY None\n", + " nndcln \n", + " node_prop [[1.0, 1.0, 0.0, 10.0, -110.0, 1.57, 0.0, 0.0], [2.0, 1.0, 0.0, 10.0, -130.0, 1.57, 0.0, 0.0]]\n", + " cln_gwc [[1.0, 1.0, 50.0, 50.0, 0.0, 0.0, 10.0, 1.0, 0.0], [2.0, 2.0, 50.0, 50.0, 0.0, 0.0, 10.0, 1.0, 0.0]]\n", + " cln_circ [[1.0, 0.5, 32300000000.0]]\n", + " ibound \n", + " strt \n", + "Adding ex3.clncbb (unit=35) to the output list.\n", + "Adding ex3.clnhds (unit=36) to the output list.\n", + "adding Package: CLN\n", + " CLN package load...success\n", + "loading oc package file...\n", + "Adding ex3.hds (unit=30) to the output list.\n", + "Adding ex3.ddn (unit=31) to the output list.\n", + "adding Package: OC\n", + " OC package load...success\n", + "loading sms package file...\n", + " loading HCLOSE HICLOSE MXITER ITER1 IPRSMS NONLINMETH LINMETH...\n", + " HCLOSE 0.001\n", + " HICLOSE 1e-05\n", + " MXITER 220\n", + " ITER1 600\n", + " IPRSMS 1\n", + " NONLINMETH 2\n", + " LINMETH 1\n", + " loading THETA AKAPPA GAMMA AMOMENTUM NUMTRACK BTOL BREDUC RESLIM...\n", + " THETA 0.9\n", + " AKAPPA 0.07\n", + " GAMMA 0.1\n", + " AMOMENTUM 0.0\n", + " NUMTRACK 200\n", + " BTOL 1.1\n", + " BREDUC 0.2\n", + " RESLIM 1.0\n", + " loading IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN\n", + " IACL 2\n", + " NORDER 1\n", + " LEVEL 3\n", + " NORTH 14\n", + " IREDSYS 0\n", + " RRCTOL 0.0\n", + " IDROPTOL 0\n", + " EPSRN 0.001\n", + "adding Package: SMS\n", + " SMS package load...success\n", + " DATA(BINARY) package load...skipped\n", + " ex3.cbb\n", + " DATA(BINARY) package load...skipped\n", + " ex3.hds\n", + " DATA(BINARY) package load...skipped\n", + " ex3.ddn\n", + " DATA(BINARY) package load...skipped\n", + " ex3.clncbb\n", + " DATA(BINARY) package load...skipped\n", + " ex3.clnhds\n", + "\n", + "WARNING:\n", + " External file unit 0 does not exist in ext_unit_dict.\n", + "\n", + " The following 7 packages were successfully loaded.\n", + " ex3.dis\n", + " ex3.bas\n", + " ex3.wel\n", + " ex3.bcf\n", + " ex3.cln\n", + " ex3.oc\n", + " ex3.sms\n", + " The following 1 packages were not loaded.\n", + " ex3.lst\n" + ] + } + ], + "source": [ + "model_ws = os.path.join('../data/mfusg_test', '03_conduit_confined')\n", + "mf = flopy.modflowusg.ModflowUsg.load('ex3.nam', exe_name='mfusg.exe', model_ws=model_ws, \n", + " check=False,verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c3e92a46-eb24-4870-921c-bf64b3ca4ce5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "removing Package: ['OC']\n", + "adding Package: OC\n" + ] + } + ], + "source": [ + "# output control\n", + "mf.remove_package('OC')\n", + "\n", + "spd = {}\n", + "for i in range(mf.nper): \n", + " for j in range(mf.dis.nstp[i]):\n", + " spd[(i,j)] = ['save head', 'save budget']\n", + "\n", + "oc = flopy.modflow.ModflowOc(mf, stress_period_data=spd, unitnumber=[22,30,31,50])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "30aa9aac-02fa-4a45-800c-bf0a017f8e1e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "changing model workspace...\n", + " ../data\\usg_test\\ex03\n" + ] + } + ], + "source": [ + "model_ws= os.path.join(cln_ws, 'ex03')\n", + "\n", + "if os.path.exists(model_ws):\n", + " shutil.rmtree(model_ws)\n", + "os.mkdir(model_ws)\n", + "\n", + "mf.model_ws=model_ws" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2323f160-60fa-40b4-9f6a-000ec07f93de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Writing packages:\n", + " Package: DIS\n", + " Package: BAS6\n", + " Package: WEL\n", + " Package: BCF6\n", + " Package: CLN\n", + " Package: SMS\n", + " Package: OC\n", + " \n", + "FloPy is using the following executable to run the model: C:\\GWV8\\mfusg.exe\n", + "\n", + " MODFLOW-USG \n", + " U.S. GEOLOGICAL SURVEY MODULAR FINITE-DIFFERENCE GROUNDWATER FLOW MODEL\n", + " Version 1.5.00 02/27/2019 \n", + "\n", + " Using NAME file: ex3.nam \n", + " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/09/24 15:28:53\n", + "\n", + " Solving: Stress period: 1 Time step: 1 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 2 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 3 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 4 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 5 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 6 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 7 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 8 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 9 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 10 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 11 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 12 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 13 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 14 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 15 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 16 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 17 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 18 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 19 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 20 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 21 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 22 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 23 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 24 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 25 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 26 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 27 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 28 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 29 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 30 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 31 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 32 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 33 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 34 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 35 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 36 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 37 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 38 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 39 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 40 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 41 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 42 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 43 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 44 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 45 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 46 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 47 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 48 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 49 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 50 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 51 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 52 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 53 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 54 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 55 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 56 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 57 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 58 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 59 Groundwater Flow Eqn.\n", + " Solving: Stress period: 1 Time step: 60 Groundwater Flow Eqn.\n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/09/24 15:28:55\n", + " Elapsed run time: 1.691 Seconds\n", + "\n", + " Normal termination of simulation\n" + ] + }, + { + "data": { + "text/plain": [ + "(True, [])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mf.write_input()\n", + "mf.run_model()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "81563f65-41b0-4782-9c3b-30b9bd4710c0", + "metadata": {}, + "outputs": [], + "source": [ + "head_file = os.path.join(mf.model_ws, 'ex3.clnhds')\n", + "headobj = flopy.utils.HeadFile(head_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a8a32799-e7e0-43bf-9f24-72019c67369b", + "metadata": {}, + "outputs": [], + "source": [ + "simtimes = headobj.get_times()\n", + "\n", + "nper=len(simtimes)\n", + "\n", + "nnode= mf.cln.nclnnds\n", + "\n", + "simhead = np.zeros((1,1,nnode,nper))\n", + "for i in range(nper):\n", + " simhead[:,:,:,i] = headobj.get_data(kstpkper = (i,0))\n", + "simhead=np.squeeze(simhead)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6559a5f4-c369-4aa4-8865-93bdeed1aad4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 5), dpi=150)\n", + "ax = fig.add_subplot(111)\n", + "ax.plot(simtimes, simhead[0], label='CLN Layer 1')\n", + "ax.plot(simtimes, simhead[1], label='CLN Layer 2')\n", + "ax.set_xlabel('Time, in days') \n", + "ax.set_ylabel('Simulated Head in pumping well, in meters') \n", + "ax.set_title(\"MODFLOW USG Ex3 Conduit Confined\") \n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "85043c1e-1bab-4f73-9a9f-edd9d49e9d99", + "metadata": {}, + "outputs": [], + "source": [ + "cbb_file = os.path.join(mf.model_ws, 'ex3.clncbb')\n", + "cbb = flopy.utils.CellBudgetFile(cbb_file)\n", + "#cbb.list_records()\n", + "\n", + "simflow = cbb.get_data(kstpkper=(0, 0), text='GWF')[0]\n", + "for i in range(nper-1):\n", + " simflow=np.append(simflow, cbb.get_data(kstpkper = (i+1,0), text = 'GWF')[0])\n", + "simflow1=simflow[simflow['node']==1]['q']\n", + "simflow2=simflow[simflow['node']==2]['q']" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5c6c4cb5-292f-457a-8563-6b7a8689176c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 11), dpi=150)\n", + "ax1 = fig.add_subplot(211)\n", + "ax1.plot(simtimes, simflow1, label='CLN Layer 1')\n", + "ax1.set_xlabel('Time, in days') \n", + "ax1.set_ylabel('Discharge to well, in cubic meters per day') \n", + "ax1.set_title(\"MODFLOW USG Ex3 Conduit Confined\") \n", + "ax1.legend() \n", + "\n", + "ax2 = fig.add_subplot(212)\n", + "ax2.plot(simtimes, simflow2, label='CLN Layer 2')\n", + "ax2.set_xlabel('Time, in days') \n", + "ax2.set_ylabel('Discharge to well, in cubic meters per day') \n", + "ax2.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "3073a5aa-1433-4b70-9bd9-6922ce34507d", + "metadata": {}, + "source": [ + "## Create example 03A_conduit_unconfined of mfusg 1.5\n", + "An unconfined example was simulated with this problem setup. The same simulation setup of previous example is used. However, the elevation of the top of layer 1 is 10 m, the bottom of layer 1 is 0 m, the top of layer 2 is -10 m, and the bottom of layer 2 is -20 m. The CLN domain is discretized using two vertical conduit cells. It depicts the behavior of unconfined flow in the conduit when the CLN cell in layer 1 becomes dry." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4e43acef-6d51-4973-888a-de963a4feff9", + "metadata": {}, + "outputs": [], + "source": [ + "modelname='ex03a'\n", + "\n", + "model_ws = os.path.join(cln_ws, modelname)\n", + "if os.path.exists(model_ws):\n", + " shutil.rmtree(model_ws)\n", + "os.mkdir(model_ws)\n", + "\n", + "mf = flopy.modflowusg.ModflowUsg(modelname=modelname, model_ws=model_ws,\n", + " exe_name='mfusg.exe',verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6864b760-e157-4d3e-9504-0540313c908c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "adding Package: DIS\n", + "adding Package: BAS6\n", + "Adding ex03a.cbc (unit=50) to the output list.\n", + "adding Package: BCF6\n", + "adding Package: SMS\n" + ] + } + ], + "source": [ + "ipakcb=50\n", + "\n", + "nlay = 2\n", + "nrow = 100\n", + "ncol = 100\n", + "laycbd = [1, 0]\n", + "\n", + "delr = 470.000\n", + "delc = 470.000\n", + "\n", + "ztop = 10.0\n", + "botm = [0.0, -10.0, -20.0]\n", + "\n", + "perlen = 160\n", + "nstp = 160\n", + "\n", + "dis = flopy.modflow.ModflowDis(mf, nlay, nrow, ncol, delr=delr, delc=delc, \n", + " laycbd=laycbd, top=ztop, botm=botm, \n", + " perlen=perlen, nstp=nstp, steady=False, lenuni=0)\n", + "\n", + "bas = flopy.modflow.ModflowBas(mf, ibound=1, strt=[10.,30.])\n", + "\n", + "bcf = flopy.modflowusg.ModflowUsgBcf(mf, ipakcb=ipakcb, laycon=4, wetfct=1.0, iwetit=5,\n", + " hy=[100.0, 400.0], vcont=0.0, sf1=1e-4, sf2=0.01)\n", + "\n", + "sms = flopy.modflowusg.ModflowUsgSms(mf, hclose=1.0E-3, hiclose=1.0E-5, mxiter=220, \n", + " iter1=600, iprsms=1, nonlinmeth=2, linmeth=1,\n", + " theta=0.9, akappa=0.07, gamma=0.1, amomentum=0.0, \n", + " numtrack=200, btol=1.1, breduc=0.2, reslim=1.0,\n", + " iacl=2, norder=1, level=3, north=14)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d2a3a309-844b-45b5-a0ad-dea10624236d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding ex03a.hds (unit=51) to the output list.\n", + "adding Package: OC\n" + ] + } + ], + "source": [ + "# output control\n", + "spd = {}\n", + "for i in range(mf.nper): \n", + " for j in range(mf.dis.nstp[i]):\n", + " spd[(i,j)] = ['save head', 'save budget']\n", + "\n", + "oc = flopy.modflow.ModflowOc(mf, stress_period_data=spd)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "cad2ba26-ddd9-4a99-97ea-08a579e93636", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Adding ex03a.clncb (unit=35) to the output list.\n", + "Adding ex03a.clnhd (unit=36) to the output list.\n", + "adding Package: CLN\n" + ] + } + ], + "source": [ + "unitnumber = [71, 35, 36, 0, 0, 0, 0]\n", + "\n", + "node_prop = [[1,1,0,10.0,0.0,1.57,0,0],[2,1,0,10.0,-20.0,1.57,0,0]]\n", + "cln_gwc = [[1,1,50,50,0,0,10.0,1.0,0],[2,2,50,50,0,0,10.0,1.0,0]]\n", + "\n", + "nconduityp=1\n", + "cln_circ=[[1,0.5,3.23e10]]\n", + "\n", + "strt = [10.0, 30.0]\n", + "cln = flopy.modflowusg.ModflowUsgCln(mf, ncln=1, iclnnds=-1, nndcln=2, nclngwc = 2,\n", + " node_prop =node_prop, cln_gwc =cln_gwc,\n", + " cln_circ=cln_circ, strt =strt, \n", + " unitnumber=unitnumber)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "05a22b48-e03c-49df-8fc7-45d1ed3fe410", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "adding Package: WEL\n" + ] + } + ], + "source": [ + "options = []\n", + "options.append('autoflowreduce')\n", + "cln_stress_period_data = {0:[[1, -62840.]]}\n", + "\n", + "wel = flopy.modflowusg.ModflowUsgWel(mf, ipakcb=ipakcb,options=options,\n", + " cln_stress_period_data=cln_stress_period_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "42fd068e-6be9-4211-954b-cbb36173e8f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: rec.array([(1, -62840.)],\n", + " dtype=[('node', '" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 5), dpi=150)\n", + "ax = fig.add_subplot(111)\n", + "ax.plot(simtimes, head_case1[0], label='CLN Layer 1')\n", + "ax.plot(simtimes, head_case1[1], label='CLN Layer 2')\n", + "ax.set_xlabel('Time, in days') \n", + "ax.set_ylabel('Simulated Head in pumping well, in meters') \n", + "ax.set_title(\"MODFLOW USG Ex3a Conduit Unconfined\") \n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c13acff3-492d-4ad2-bc3c-7f42639b7fa6", + "metadata": {}, + "outputs": [], + "source": [ + "cbb_file = os.path.join(mf.model_ws, modelname+'.clncb')\n", + "cbb = flopy.utils.CellBudgetFile(cbb_file)\n", + "#cbb.list_records()\n", + "\n", + "simflow = cbb.get_data(kstpkper=(0, 0), text='GWF')[0]\n", + "for i in range(nper-1):\n", + " simflow=np.append(simflow, cbb.get_data(kstpkper = (i+1,0), text = 'GWF')[0])\n", + "\n", + "flow_case1=simflow" + ] + }, + { + "cell_type": "markdown", + "id": "de189309-199c-4bc4-a664-4eb2a9d23b76", + "metadata": {}, + "source": [ + "## Modify CLN amd WEL package to example create 03B_conduit_unconfined of mfusg 1.5\n", + "The problem is solved using only one CLN conduit cell to represent the well connecting both aquifer layers. This is conceptually equivalent to the MNW methodology and does not colve for flow within the well. The behavior of unconfined flow between the well and layer 1 negalects the dry-cell condition whereby head in the well is below the bottom of layer 1." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "6c95a97c-3785-4ae0-be9c-ef4ccb75cc08", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "changing model workspace...\n", + " ../data\\usg_test\\ex03b\n" + ] + } + ], + "source": [ + "modelname='ex03b'\n", + "\n", + "model_ws = os.path.join(cln_ws, modelname)\n", + "if os.path.exists(model_ws):\n", + " shutil.rmtree(model_ws)\n", + "os.mkdir(model_ws)\n", + "\n", + "mf.model_ws = model_ws\n", + "mf._set_name(modelname)\n", + "for i, fname in enumerate(mf.output_fnames):\n", + " mf.output_fnames[i] = modelname + os.path.splitext(fname)[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "3d3e7f0d-b31b-48f3-8ddb-8e6459a3b9f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "removing Package: ['CLN']\n", + "adding Package: CLN\n" + ] + } + ], + "source": [ + "mf.remove_package('CLN')\n", + "\n", + "node_prop = [[1,1,0,30.0,-20.,1.57]]\n", + "cln_gwc = [[1,1,50,50,0,0,10.0,1.0,0],[1,2,50,50,0,0,10.0,1.0,0]]\n", + "\n", + "strt = 20.0\n", + "cln = flopy.modflowusg.ModflowUsgCln(mf, ncln=1, iclnnds=-1, nndcln=1, nclngwc = 2,\n", + " node_prop =node_prop, cln_gwc =cln_gwc, \n", + " cln_circ=cln_circ, strt =strt, \n", + " unitnumber =unitnumber)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "04b6301d-4599-4859-8aa7-d83121a016ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "removing Package: ['WEL']\n", + "Adding ex03b.afr (unit=55) to the output list.\n", + "adding Package: WEL\n" + ] + } + ], + "source": [ + "mf.remove_package('WEL')\n", + "\n", + "options = []\n", + "options.append('autoflowreduce')\n", + "options.append('iunitafr 55')\n", + "cln_stress_period_data = {0:[[0, -62840.]]}\n", + "\n", + "wel = flopy.modflowusg.ModflowUsgWel(mf, ipakcb=ipakcb,options=options,\n", + " cln_stress_period_data=cln_stress_period_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "a7042045-95f7-4205-abe1-579cf7c3bb8f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Writing packages:\n", + " Package: DIS\n", + " Package: BAS6\n", + " Package: BCF6\n", + " Package: SMS\n", + " Package: OC\n", + " Package: CLN\n", + " Package: WEL\n", + " \n" + ] + }, + { + "data": { + "text/plain": [ + "(True, [])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mf.write_input()\n", + "mf.run_model(silent=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "70192070-20db-4c2d-a252-5c6d9b96df0d", + "metadata": {}, + "outputs": [], + "source": [ + "head_file = os.path.join(mf.model_ws, modelname+'.clnhd')\n", + "headobj = flopy.utils.HeadFile(head_file)\n", + "\n", + "simtimes = headobj.get_times()\n", + "nper=len(simtimes)\n", + "nnode= mf.cln.nclnnds\n", + "\n", + "simhead = np.zeros((1,1,nnode,nper))\n", + "for i in range(nper):\n", + " simhead[:,:,:,i] = headobj.get_data(kstpkper = (i,0))\n", + "\n", + "head_case2=np.squeeze(simhead)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "28751490-a504-4afb-ab12-afd692b2299d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'MODFLOW USG Ex3b Conduit Unconfined')" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 5), dpi=150)\n", + "ax = fig.add_subplot(111)\n", + "ax.plot(simtimes, head_case2)\n", + "ax.set_xlabel('Time, in days') \n", + "ax.set_ylabel('Simulated Head in pumping well, in meters') \n", + "ax.set_title(\"MODFLOW USG Ex3b Conduit Unconfined\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "486e8682-3f8d-4f80-a2ba-80f9bd793059", + "metadata": {}, + "outputs": [], + "source": [ + "cbb_file = os.path.join(mf.model_ws, modelname+'.clncb')\n", + "cbb = flopy.utils.CellBudgetFile(cbb_file)\n", + "#cbb.list_records()\n", + "\n", + "simflow = cbb.get_data(kstpkper=(0, 0), text='GWF')[0]\n", + "for i in range(nper-1):\n", + " simflow=np.append(simflow, cbb.get_data(kstpkper = (i+1,0), text = 'GWF')[0])\n", + "\n", + "flow_case2=simflow" + ] + }, + { + "cell_type": "markdown", + "id": "2d84dd82-252d-428c-8e7c-21e77e4e16f3", + "metadata": {}, + "source": [ + "## Modify CLN amd WEL package to example create 03C_conduit_unconfined of mfusg 1.5\n", + "The CLN well is discretized using two conduit geometry CLN cells but with the confined option for flow winthin the conduit and between CLN and GWF domains." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c36c1659-b857-4d91-bff1-2f13a1c31e33", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "changing model workspace...\n", + " ../data\\usg_test\\ex03c\n" + ] + } + ], + "source": [ + "modelname='ex03c'\n", + "\n", + "model_ws = os.path.join(cln_ws, modelname)\n", + "if os.path.exists(model_ws):\n", + " shutil.rmtree(model_ws)\n", + "os.mkdir(model_ws)\n", + "\n", + "mf.model_ws=model_ws\n", + "mf._set_name(modelname)\n", + "for i, fname in enumerate(mf.output_fnames):\n", + " mf.output_fnames[i] = modelname + os.path.splitext(fname)[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "436a89dd-7299-4192-9fdf-8a790e35c14c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "removing Package: ['CLN']\n", + "adding Package: CLN\n" + ] + } + ], + "source": [ + "mf.remove_package('CLN')\n", + "\n", + "node_prop = [[1,1,0,10.0,0.0,1.57,1,0],[2,1,0,10.0,-20.0,1.57,1,0]]\n", + "cln_gwc = [[1,1,50,50,0,0,10.0,1.0,0],[2,2,50,50,0,0,10.0,1.0,0]]\n", + "\n", + "strt = [10.0, 30.0]\n", + "\n", + "cln = flopy.modflowusg.ModflowUsgCln(mf, ncln=1, iclnnds=-1, nndcln=2, nclngwc = 2, \n", + " node_prop =node_prop, cln_gwc =cln_gwc, \n", + " cln_circ=cln_circ, strt =strt, \n", + " unitnumber =unitnumber)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "f579c496-5185-46ed-b5eb-c35dfcd5021a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "removing Package: ['WEL']\n", + "adding Package: WEL\n" + ] + } + ], + "source": [ + "mf.remove_package('WEL')\n", + "\n", + "cln_stress_period_data = {0:[[1, -62840.]]}\n", + "\n", + "wel = flopy.modflowusg.ModflowUsgWel(mf, ipakcb=ipakcb,options=options,\n", + " cln_stress_period_data=cln_stress_period_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f4637d24-4259-4a7c-8d6e-68a1f4f3c4d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Writing packages:\n", + " Package: DIS\n", + " Package: BAS6\n", + " Package: BCF6\n", + " Package: SMS\n", + " Package: OC\n", + " Package: CLN\n", + " Package: WEL\n", + " \n" + ] + }, + { + "data": { + "text/plain": [ + "(True, [])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mf.write_input()\n", + "mf.run_model(silent=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5822a3c8-ea72-450e-87e3-728a3126ac48", + "metadata": {}, + "outputs": [], + "source": [ + "head_file = os.path.join(mf.model_ws, modelname+'.clnhd')\n", + "headobj = flopy.utils.HeadFile(head_file)\n", + "\n", + "simtimes = headobj.get_times()\n", + "nper=len(simtimes)\n", + "nnode= mf.cln.nclnnds\n", + "\n", + "simhead = np.zeros((1,1,nnode,nper))\n", + "for i in range(nper):\n", + " simhead[:,:,:,i] = headobj.get_data(kstpkper = (i,0))\n", + "\n", + "head_case3=np.squeeze(simhead)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "a3ad338d-e362-4ead-b1ee-2ae5448f78a9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 5), dpi=150)\n", + "ax = fig.add_subplot(111)\n", + "ax.plot(simtimes, head_case3[0], label='CLN Layer 1')\n", + "ax.plot(simtimes, head_case3[1], label='CLN Layer 2')\n", + "ax.set_xlabel('Time, in days') \n", + "ax.set_ylabel('Simulated Head in pumping well, in meters') \n", + "ax.set_title(\"MODFLOW USG Ex3c Conduit Unconfined\") \n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "b32a6c2c-56c4-442d-918b-65f18b42e221", + "metadata": {}, + "outputs": [], + "source": [ + "cbb_file = os.path.join(mf.model_ws, modelname+'.clncb')\n", + "cbb = flopy.utils.CellBudgetFile(cbb_file)\n", + "#cbb.list_records()\n", + "\n", + "simflow = cbb.get_data(kstpkper=(0, 0), text='GWF')[0]\n", + "for i in range(nper-1):\n", + " simflow=np.append(simflow, cbb.get_data(kstpkper = (i+1,0), text = 'GWF')[0])\n", + "\n", + "flow_case3=simflow" + ] + }, + { + "cell_type": "markdown", + "id": "606a8770-41f7-45d4-a54e-8a6d330d7aab", + "metadata": {}, + "source": [ + "## Modify CLN amd WEL package to example create 03D_conduit_unconfined of mfusg 1.5\n", + "Only one CLN cell to discretize the well but includes the \"flow-to-dry-cell\" option to limit flow in layer 1 when the head in the CLN cell is below the bottom of the layer." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "2f5fc636-7ba6-4041-b808-71c6092009f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "changing model workspace...\n", + " ../data\\usg_test\\ex03d\n" + ] + } + ], + "source": [ + "modelname='ex03d'\n", + "\n", + "model_ws = os.path.join(cln_ws, modelname)\n", + "if os.path.exists(model_ws):\n", + " shutil.rmtree(model_ws)\n", + "os.mkdir(model_ws)\n", + "\n", + "mf.model_ws=model_ws\n", + "mf._set_name(modelname)\n", + "for i, fname in enumerate(mf.output_fnames):\n", + " mf.output_fnames[i] = modelname + os.path.splitext(fname)[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "a279aa71-4ff7-4d0d-a088-78abb7fde030", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "removing Package: ['CLN']\n", + "adding Package: CLN\n" + ] + } + ], + "source": [ + "mf.remove_package('CLN')\n", + "\n", + "node_prop = [[1,1,0,30.0,-20.,1.57]]\n", + "cln_gwc = [[1,1,50,50,0,0,10.0,1.0,1],[1,2,50,50,0,0,10.0,1.0,1]]\n", + "\n", + "strt = 20.0\n", + "\n", + "cln = flopy.modflowusg.ModflowUsgCln(mf, ncln=1, iclnnds=-1, nndcln=1, nclngwc = 2,\n", + " node_prop =node_prop, cln_gwc =cln_gwc, \n", + " cln_circ=cln_circ, strt =strt, \n", + " unitnumber =unitnumber)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "df3cf10b-1c9d-42df-aadd-b484f6ef1b35", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "removing Package: ['WEL']\n", + "adding Package: WEL\n" + ] + } + ], + "source": [ + "mf.remove_package('WEL')\n", + "\n", + "cln_stress_period_data = {0:[[0, -62840.]]}\n", + "\n", + "wel = flopy.modflowusg.ModflowUsgWel(mf, ipakcb=ipakcb,options=options,\n", + " cln_stress_period_data=cln_stress_period_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "bd4760c3-e69b-4ccc-94aa-342aedaf1dc6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Writing packages:\n", + " Package: DIS\n", + " Package: BAS6\n", + " Package: BCF6\n", + " Package: SMS\n", + " Package: OC\n", + " Package: CLN\n", + " Package: WEL\n", + " \n" + ] + }, + { + "data": { + "text/plain": [ + "(True, [])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mf.write_input()\n", + "mf.run_model(silent=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "436b6009-4fbf-420d-ac9d-fad32b70d2c0", + "metadata": {}, + "outputs": [], + "source": [ + "head_file = os.path.join(mf.model_ws, modelname+'.clnhd')\n", + "headobj = flopy.utils.HeadFile(head_file)\n", + "\n", + "simtimes = headobj.get_times()\n", + "nper=len(simtimes)\n", + "nnode= mf.cln.nclnnds\n", + "\n", + "simhead = np.zeros((1,1,nnode,nper))\n", + "for i in range(nper):\n", + " simhead[:,:,:,i] = headobj.get_data(kstpkper = (i,0))\n", + "\n", + "head_case4=np.squeeze(simhead)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "411fadcb-05aa-4952-aa20-fbd8a8ad7961", + "metadata": {}, + "outputs": [], + "source": [ + "cbb_file = os.path.join(mf.model_ws, modelname+'.clncb')\n", + "cbb = flopy.utils.CellBudgetFile(cbb_file)\n", + "#cbb.list_records()\n", + "\n", + "simflow = cbb.get_data(kstpkper=(0, 0), text='GWF')[0]\n", + "for i in range(nper-1):\n", + " simflow=np.append(simflow, cbb.get_data(kstpkper = (i+1,0), text = 'GWF')[0])\n", + "\n", + "flow_case4=simflow" + ] + }, + { + "cell_type": "markdown", + "id": "14042416-d887-40c7-a38b-2abeb2a77546", + "metadata": {}, + "source": [ + "## Comparing four cases" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "e5d84f53-0879-4328-9478-1ff70dfdde2f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 5), dpi=150)\n", + "ax = fig.add_subplot(111)\n", + "ax.plot(simtimes, head_case1[1], label='Case A')\n", + "ax.plot(simtimes, head_case2, label='Case B')\n", + "ax.plot(simtimes, head_case3[1], dashes=[6, 2],label='Case C')\n", + "ax.plot(simtimes, head_case4, dashes=[6, 2],label='Case D')\n", + "\n", + "ax.set_xlabel('Time, in days') \n", + "ax.set_ylabel('Simulated Head in pumping well, in meters') \n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "e6a18152-d705-494c-8b7e-e7c0aea87714", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABC0AAAU6CAYAAADGKIycAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAABcSAAAXEgFnn9JSAAEAAElEQVR4nOzdd3hVRf7H8ffc9E5N6L2Z0Jsg4ipdUVxB7AXLrtjWVQTbrm1XRRQsP5RV1xVXsaKIgIuISBGEUAUS6TWUdEgIJCG58/vj3oQEEgwtJyGf1/Ocvd45M+d8bx4Wkk/mzBhrLSIiIiIiIiIiFY3L6QJEREREREREREqi0EJEREREREREKiSFFiIiIiIiIiJSISm0EBEREREREZEKSaGFiIiIiIiIiFRICi1EREREREREpEJSaCEiIiIiIiIiFZJCCxERERERERGpkBRaiIiIiIiIiEiFpNBCRERERERERCokhRYiIiIiIiIiUiEptBARERERERGRCsnX6QKk/Bhj9gPBwG6naxEREREREZEqoSFw2Fpb53QGG2vtWa5HKipjTEZAQEBY8+bNnS5FREREREREqoCtW7eSk5OTaa0NP53xmmlRtexu3rx5dFxcnNN1iIiIiIiISBUQExNDfHz8ac/215oWIiIiIiIiIlIhKbQQERERERERkQpJoYWIiIiIiIiIVEgKLURERERERESkQlJoISIiIiIiIiIVkkILEREREREREamQFFqIiIiIiIiISIXk63QBUjlYa7HWOl2GVCLGGIwxTpchIiIiIiKVmEILKVV+fj6pqalkZmaSm5vrdDlSCfn7+xMWFkbNmjXx8fFxuhwREREREalkFFpIifLz89m1axfZ2dlOlyKVWG5uLqmpqWRlZdGoUSMFFyIiIiIickoUWkiJUlNTyc7OxsfHh6ioKEJCQnC5tASKlJ3b7SYrK4vExESys7NJTU0lMjLS6bJERERERKQSUWghJcrMzAQgKiqKiIgIh6uRysjlchX+2dm7dy+ZmZkKLURERERE5JToV+dyAmtt4RoWISEhDlcjlV3Bn6Hc3Fwt5ioiIiIiIqdEoYWcoOgPlnokRM5U0T9DCi1ERERERORU6CdSEREREREREamQFFqIiIiIiIiISIWk0EJEREREREREKiSFFiIiIiIiIiJSISm0EDlFWVlZTJgwgcsuu4yoqCj8/f2pXr06PXv25Omnn2bXrl1Ol3jW3HfffRhjcLlc7Ny50+lyRERERESkilFoIXIKlixZQosWLRg1ahSxsbG0bduWa6+9losuuoitW7fyj3/8g1atWjF37lynSz1jubm5fP7554Bn148pU6Y4XJGIiIiIiFQ1Ci1EymjNmjX07duX/fv389hjj5GUlMSPP/7IJ598wqxZs9i/fz9fffUVDRo0ICEhwelyz9h3331HWloadevWBeCjjz5yuCIREREREalqFFqIlIG1lltvvZXs7GyeffZZxo4dS0hISLE+LpeLoUOHsnLlSrp27epQpWdPQUjx3HPP0bx5czZs2MCKFSscrkpERERERKoSX6cLEKkMZs+ezfr162nQoAFPPfXUSftGREQQERFR+H7fvn189NFHzJo1iy1btpCcnEyNGjW46KKLeOKJJ+jWrdsJ10hOTmb8+PF8++237Nq1Cx8fH6KioujRowcPPPAA3bt3L9Y/LS2NV155henTp7N9+3b8/f3p0qULjzzyCFdeeeUpf94DBw4wa9YsAgICuO6660hISOD555/no48+Oi8CGRERkYroaO4REhJXkZD4KwlpmzjoAt9arfHxDcTX5YuP8SHUP5Te9XtTPbC60+WKiJQLhRYiZTBr1iwAhg8fjq/vqf3fZvr06Tz22GO0bt2a9u3bEx4ezubNm5k2bRozZ85k5syZDBgwoLB/ZmYmF154Idu3b6dhw4b0798fX19fdu3axWeffUazZs2KhRabNm2iX79+7N69myZNmjBw4EAyMzNZunQpV111Fa+88gqPPvroKdX8xRdfkJOTw7Bhw4iIiOCWW27h+eef57PPPmP8+PGn/DUQERERwFoOHNiBObiLiEMpkL4T0nd4jgM7+TE3hdGRNYqP2fPjCZcJ9w/niQufYHDTwRhjyqV0ERGn6CcPOWXWWjKy85wu45SFB/qe9j/sa9asAaBz586nPLZXr16sX7+emJiYYu3ff/89Q4YM4b777mPz5s2FtU2dOpXt27czZMgQpk2bhst17Cmu5ORkEhMTC9/n5+dz7bXXsnv3bsaNG8eoUaMK+2/ZsoUBAwbw+OOPM2jQINq2bVvmmgseDbnlllsAaNmyJd27dyc2NpY5c+ZwxRVXnPLXQUREpKo4fCiJXXuWsiNxNTvTN7Pz0B525h5gJ7kcdLm4L/0A9x7IOGFcQ3//Ml0/IzeDJxY9wdydc/lbj79RK6jW2f4IIiIVhkILOWUZ2Xl0eG6O02Wcsl+fGUBEkN9pjU1NTQWgdu3apzy2Xbt2JbYPHDiQ4cOHM2XKFNavX1/YLzk5GYA+ffoUCywK7l+0hhkzZrBu3TqGDRvG6NGji/Vt0aIF48ePZ+jQobz33nu88cYbZap3+/btLF68mBo1ahQLJ2655RZiY2P56KOPFFqIiEiVdzQni917l7Fz/yp2pW5gx6Hd7MxOZac7mySfEn5J4ir8HxJKmbHYIO8oLmup64YGxp8ahw9ggXxjyAPy/ENYFRhAVn42AD/u+pGViSt5qsdTDGoy6Jx8ThERpym0ECkHOTk5zJ49m9jYWJKTk8nNzQVg3bp1AGzevLkwtOjSpQsAr7zyClFRUQwePJiwsLASrztnjic8Gjp0aInne/fuDUBsbGyZa50yZQrWWq677jr8i/zG54YbbuCRRx5h+vTpZGZmllqTiIjIeSX7ICRv5MC+1by38zu2HU5kZ34We1wW9/EzOA1QUmBxnCS/AIhqC9UaQ/Um3qMxEdWbsCK8Hn4B3n9jd8fCN/dB6mbvyBT2+vrydNNoluUdAOBAzgFGLxjN7O2zub/j/bSs3vIsfXARkYpBoYVIGdSsWRM4NgviVKxbt44hQ4awY8eOUvtkZmYW/nffvn15+OGHef3117nxxhvx9fWlc+fO9O/fnzvvvJNmzZoV9i245s0338zNN99c6vVTUlLKXO/xj4YUqF27NgMHDmTWrFl89dVXjBgxoszXFBERqegOHtjB1p0LyT+wg26HD0PyBkjeCJl7AfA3hv82aejp7AOehKJ0/tbSyPrQxDeMxsF1aFytGU1qt6dRve7UqNECXCVv4ldsTmjD7jByEfz0IvwyEaybenl5vLt5LV+EhzOhZg2O4AY8sy5+3PUj/Rr1454O99CmRpsz+4KIiFQQCi3klIUH+vLrMwN+v2MFEx54+n/cO3bsyOLFi1m1atUJP8yfTMGMhR07djBy5EhGjhxJs2bNCA0NxRjDk08+yUsvvYS1tti4CRMmcM899zB9+nTmzp3L4sWLiY2NZdy4cXz66acMGzYMALfb843KoEGDiIqKKrWOWrXK9qxrbGwsmzZtAuCxxx474XxCQgLgCTYUWoiISGWUnraVrbsWsjVxNVsPbGXbkSS2uo+Q4p0h0TYnh0/3Jp4wLtha6h3NY6/fse8nXNZS321o7BtCk6BIGoc1pnHtGJrU7UZUVAdcPmfhW22/IBjwD4i+2jPrImUjLuCGjAx6Hc7i77VrsTIwoLD73F1zaVurrUILETlvKLSQU2aMOe21ISqrwYMH89Zbb/Hll18ybty4Mu+esWHDBjZs2EDXrl2ZNGnSCee3bdtW6tjWrVszZswYxowZQ3Z2NhMnTmT06NHce++9haFFgwYNALj77rsL285EwSwLgMWLF5fab/78+SQkJBTeX0REpKLJO3qEHTsXsjHhZzamxLEpaw+b8rNIPv7xjeMe6djq54fluHkU/mFQuzU3hYXiDqlF01oxNKrTiYZ1u+MXEFIOnwZo0BVG/gy/fgqLXoUDu2iYl89/9iUyJySYd6qFs8Xfn3CfIK5veW351CQiUg4UWoiUwaBBg4iJiSEuLo4XXniBZ555ptS+GRkZ7N69m5iYGNLT0wFK/OE+PT2dH374oUz3DwwM5NFHH2XChAns27ePpKQkIiMj6d+/P++//z7Tpk0749AiLy+Pzz//HKDE3U4K3HHHHUyePJkpU6aUOBtDRESk3B1OY82m6azfu5SNB7awMSeVrSaP3OPXnPid9SbC3JZmJoCMjjcSEdUOarfxHOH1wBhuP4cfoUx8/aHL7dDxJvj1M1j0Kq70HQzKOsyArMP8FBxEhstF6KRe0GUEdL4NQiMLh0/dNJV2tdrRukZr5z6DiMgpUmghUgbGGD7++GN69uzJs88+S3Z2Nn/7298ICTn22xVrLTNmzODRRx/lySefJCYmhhYtWuByuZg3bx6bN2+mZUvP4ljZ2dmMHDmStLS0E+71zTffUKdOHXr06FGsfeXKlSQmJhIaGkq1atUAGDZsGNHR0UyZMqVwZkZAwLEpotZalixZAni2Xj2Z2bNnk5ycTLt27UoNLABuvPFGJk+ezMcff6zQQkREypU7/yiutG2wfx0krof96yExDjL3MrFOJMuCAj0dXXCyNSci3JbmJoDmgbVpHtGUZpEdaN7wYmrXisaUstZEheLjB51vhQ43wNovYPHruFI20ffwEW+HLJj3D5j/ErQcAO2vJ6lBF/659J/k23yia0ZzVbOrGNR0kLZLFZEKT6GFSBl17NiRuXPnMmzYMMaOHcubb75Jz549iYqK4uDBg6xYsYLExEQCAwNp2NCzUFdkZCR33XUX7733Hh06dKBPnz4EBQWxaNEi8vPzGTFiBJMnTy52n/nz5/PGG29Qv359OnXqRHh4OHv37mXRokW43W6ee+65wl09fH19+eabbxg4cCBPP/00EydOpH379kRGRpKSksKaNWtISkritdde+93QouDRkBtvvPGk/fr27UtkZCTr169nzZo1dOzY8fS+oCIiIifhzs9jd8IS4rb/SFzyGuKyEthgs/lu915qeNd0Kqp1bu6x0MLLx1qaul20CqhBq/CmtI7qTOsmfahV64LKEU78Hh8/6HSzZ+bFjp9h+b9hw0xw53nOu/Ng43ew8Tum1YokP8zz9YlPjSc+NZ5XV7xKz3o9ubLZlVzW8DKC/YId/DAiIiVTaCFyCnr16sWWLVt45513mDFjBmvXriU9PZ3Q0FBat27NyJEjufvuu4s9DjJp0iTatGnD+++/z48//khERAT9+vXjhRde4IMPPjjhHiNGjMDX15eFCxcSGxvLwYMHqVOnDldccQUPPfQQffv2Lda/ZcuWrF69mokTJ/L111+zdOlS8vLyqFOnDp06dWLIkCFcd911J/1cGRkZfPvtt4Bna9OT8fHxYfjw4bz11lt89NFHCi1EROSMWbebhD1Lid8xl7jE1cQfSiDeHiHTVWS2hAGMi/gAfy4+kn3CNTq4/ehmA2gdUo9WNS6gdYOeNG98GQGBEeX3QZxiDDTt7Tky9sGq/8LKyYU7nwA0PZxJW3/D+iIzMvNtPj/v+Zmf9/xMoE8gF9e/mH6N+/GHBn8g1D/UgQ8iInIic/yuBXL+MsbERUdHR8fFxZ20n9vtZuPGjYBnMUjX+fCbCHGM/jyJiEhR1u1m//5VxG2bQ1ziKuIO7SLOfZgM18nXmyjwQPpB7vGtA1ExUKctRLXzvIbV9fzwLh7ufNg2H9Z+Dr/NgKOHAdji58fM0GBmhYawv5SFxf1cfvSs15N+jfpxWcPLqBZYrfzqFpHzTkxMDPHx8fHW2tKfQT8JzbQQERERkXMnO4OEbXP4bst01h7Ywrr8TNKODyhKCSyMtTRxu4gOqElM9dbENOhFm+aDIKR2ORReybl8oEVfz5FzyBNcrP2MFtsX8tf0g/wl/SArAwOYERrCDyHBHCryS4Wj7qMsTFjIwoSF+BgfutbpSv9G/enbuK/WwBCRcqfQQkRERETODrcbUjZBwvJjR9Jv7An05//qRnn6nGRGReN8iPavQUz1VkTXv4gLWlxOaGidcir+PBYQCh1v9ByHkmHDTFy/fUu3bQvolp3G31LSWBoUyNyQYH4KDuKAj0/h0Hybz7J9y1i2bxkvLHuBSxteypt93nTww4hIVaPQQkREREROy+FDSazd+DWrdy/k14NbiclM48GUpBP6tc3JxWUt7iKPbzTIh2j/6sRUa0FMvZ5c0OJywsNP3CJczrLQ2tD1Ds9xOA02/g//377lkq3zuORIGnnAisAA5oYE82NwMCm+xwIMiyU4Lxes1aM4IlJuFFqIiIiISJmkJG9gzcavWLV3GauydrHB5JFf5IfXDD/DgyWMCwkI51pXNWqGN6J9/Z60bXEl1ao3Lb/CpWTBNTy7j3S6GbIzYNP3+P42nR6b59IjNZ0nU9P5NcCfH0KCmRsSzD5fXy75dTqsXwQt+3u2U232B/APYVfGLl6MfZFL6l9C7wa9aRjW0OlPJyLnCS3EWYVoIU5xgv48iYhUTtbtZueuRazeMpNVSatZnZ3ITp+Tj/G1lqW79hBQOxoadIUG3aFBN6jZAvT3f+WRmwWbf4DNczxHVjIWiPf3p/HRo4QW/fnBxx+aXMzHNaN4OXlxYXOT8Cb0btCbnnV70iWqi7ZTFanCtBCniIiIiJwx63azfed8Vmz6huXJa1iem0aqT5FHAEoJLELdlg6uUDpVa0mHBr1xXT8cgqqXT9FybviHQMwfPYfbDfvWYDbPIWbT97B3VfG++bmwdR4Ls2pDUFBh846MHeyI38FH8R/h6/KlY+2O9Kjbg571ehJdMxpfl34MEZGy0d8WIiIiIlWRtZCyGXYsYuKmz/kqZy8pxUKKktcsiMy3dPGvSada7ejc7HJaNOuPj69/ORUt5c7lgvqdPcelj8OhJNgy1zMDY8s8yDkIwD3pGbTOOcqi4EC2+hf/85DnzmNF4gpWJK5g4pqJhPmF0a1ON3rW60mPuj1oHN4YozUyRKQUCi1EREREqgDrdkPaNsz2BbDjZ8+R5Vk0M6d6NVKqhZc4roXbRaegunSq05XOra6mXt2u+gGzKguNhI43eY78o7A7FjbPocu2+XTZ9yuj0g+Q4OvDz0FB/BIUSGxQYLHtVAEyj2Yyb/c85u2eB0DdkLp0r9OdbnW60a1ON+qF1nPik4lIBaXQQkREROQ8lZ62lWXrPmLp3sUsPbKffyQl0i0754R+3bKzmYwntGjldtEtpBHd6l9M5+jhVK/erLzLlsrCxw+a9PIcAFmpsH0BDbbN54ZtP3FD0i7ygLgAf5YGBfJLYCC/BgaQd1zotS9rH9O3Tmf61ulEBUfxw7U/KBgTkUIKLURERETOE0cOp7E67hOW7vyRpZnb+M3lPnbSB34JCjwxtIhqS5dGPXi9Wm06R1+nkEJOX0hNaDvUc1gLadvw3TafDtt+osP2hdxzIInDxrAiMMATYgQFsuW4R0m6Z2Vi5r8ETS72LOLq51knw23dzNw2k86RnakfWl+hhkgVotBCREREpJKybjcbN8/k501fsTQ1nlUc4WjBD3MlbNaxNDCQv9SuB00vgaa9oXEvCK5BCNC3XCuX854xULO55+h2F7jzYe9qgrcv5JIdP3PJrqWQdoBkHxfLAgNZERjIiqAAuh3YDTtehgUvg8sP6nWCRj3YUqsJT617HYDIoEg6RnakU2QnOkV2onWN1lrYU+Q8pv93i4iIiFQiBw/s5Je1k1mcsIjF2ftJLlgw0xT+TzG18y09AyPpUbcnF8bcCJFty7VeEQBcPt5tcLtC70c862HsXUPtHYu4csfPXLlrKaSmYYuOcR+FhFhIiGV5eCjUrAFA0pEk5uycw5ydcwAI8g2ifa32hUFG+9rtCfMPK//PKCLnhEILERERkYrM7SZu4zR+3jSNxWnx/GpycRfMpihhh49gt6WbTxg9a3eiR+uhNGvSB+MqYdqFiJN8/KBhN89RJMQwOxZ5FondtRSOZhV297eWJrlH2eHvd8KljuQdYdn+ZSzbvwwAg6Fl9ZZ0iuxEx8iOdI7sTN2QunqkRKSSUmghcoqysrJ45513mDFjBvHx8aSnpxMSEkKbNm3o378/d999N40aNXK6zNMyefJk7rjjjhPag4KCaNKkCVdeeSWPP/44NWrUcKA6EZEq5MiBIttK/sjj1f08P6y54PjZFMZa2lo/elVrw0XNB9P2gqH4+QU7UbXI6SspxNi/zhNe7PqF4buWMnzPPlJcLn4NDGB1YACrAwKID/A/YWFPi2VT+iY2pW/i842fAxAZHFn4OMkVTa+gemB1Jz6liJwGhRYip2DJkiUMGzaM/fv3ExwcTI8ePYiKiuLgwYMsX76cpUuXMm7cOGbOnEm/fv2cLve0NW/enIsvvhgAay379u1j6dKlvPLKK3zxxRcsXbqUOnXqOFyliMj5ZffuJdTbvQqfTbNh1y/gzis8d3FgtWK/Ya7htvQKiKRX/d5c1P52LZ4p5x8fP6jf2XP0vK9wYc9au5bSd9cv9N21FPZtJtsY4vz9PSFGYABrAvzJ8PE54XJJh5P4fsf3fL/jey6L6qbQQqQSUWghUkZr1qyhb9++ZGdn89hjj/H3v/+dkJCQwvNut5tvvvmGMWPGkJCQ4GClZ+7iiy9m8uTJxdqSk5O59NJLiY+P58UXX+TNN990pjgRkfNEfl4ua+O/YP7mr1lwcAtbfSwf7d1Px5zcE/r+4UguceH+9KoezcWth3JBy6tw+ejbOKlCii7s2elmT1tWCoG7ltJl91K6JKyEvatx5x1hu59v4UyMNYEB7PIrEvjl51P3ze4QGe1dY6Ob56jVkicX/520nDTa1WpXeCjcEHGe/rUTKQNrLbfeeivZ2dk8++yzPPPMMyf0cblcDB06lL59+7J7924Hqjy3ateuzahRo7jrrrtYuHCh0+WIiFRKh7OSWbL6PX7a9SOLchJJdxWsTeF5WRAcdCy0CK4JLQdCqwH0aHYpPYL0w5NIMSG14IIrPQdA/lFciXE0T1hO84QVXJuwHBK2kuJyscY7E8PXWgwWkuI8x6oPAbD+ofxcrxbpxs3iPYsLb9EwrCHtarWjfe32tK3VlgtqXIC/j39J1YjIOaLQQqQMZs+ezfr162nQoAFPPfXUSftGREQQERFR+H7fvn189NFHzJo1iy1btpCcnEyNGjW46KKLeOKJJ+jWrdsJ10hOTmb8+PF8++237Nq1Cx8fH6KioujRowcPPPAA3bt3L9Y/LS2NV155henTp7N9+3b8/f3p0qULjzzyCFdeeeXZ+SIAkZGRAOTl5f1OTxERKXDwwE4WrnqHuQkLWJx/kJyCoMJ14qKA20NrQMyd0Opyz2+BXSdOcxeRUvj4Qb2OnqP7nzxth9OotWcl/RKW0y9hOSSsLHFogvsI6cZ9QvvuzN3sztzNd9u/A8DX5UvLai2JrhlNdM1oYmrG0LJ6SwUZIueQQguRMpg1axYAw4cPx9f31P5vM336dB577DFat25N+/btCQ8PZ/PmzUybNo2ZM2cyc+ZMBgwYUNg/MzOTCy+8kO3bt9OwYUP69++Pr68vu3bt4rPPPqNZs2bFQotNmzbRr18/du/eTZMmTRg4cCCZmZksXbqUq666ildeeYVHH330rHwdVqxYAcAFF1xwVq4nInK+SkmOZ97qd/hx3y/E2sPHFgo8LqjwtZYuJohLI7vwh7a30bDhRQ5UK3IeC64BLft7DgC3G1I3Q8JySFjhOZLiqJ3v5t19iawLCGBdgD9rAwNIK2FtjDx3Hr+l/cZvab/x1eavgBODjM6RnWlRvUV5fkqR85pCCzl11kL2QaerOHWBEZ7nIU/DmjVrAOjcufMpj+3Vqxfr168nJiamWPv333/PkCFDuO+++9i8eXPhNlxTp05l+/btDBkyhGnTpuEqsk1dcnIyiYmJhe/z8/O59tpr2b17N+PGjWPUqFGF/bds2cKAAQN4/PHHGTRoEG3btj3l2sHzaExiYiIzZsxg3LhxBAQEMGrUqNO6lojI+WxPwlJ+/PV9fkxeyWpysQX/5hz3b0+o29LbvxZ9Gvbhoo53Eh7ewIFqRaoolwtqt/YcnW7xtOVmEbh/HT33rKLn3tWwdzV212b2+vqwLiCAtQH+rA/wJ97fn5wStg8+PsgY1mgAz1766ml/3ykixSm0kFOXfRBebux0FafusZ0QVO20hqampgKedR1OVbt27UpsHzhwIMOHD2fKlCmsX7++sF9ycjIAffr0KRZYFNy/aA0zZsxg3bp1DBs2jNGjRxfr26JFC8aPH8/QoUN57733eOONN8pc84cffsiHH354Qnu3bt146623SnykRUSkSkrfAXHTeHDTf5nv4310zhT+T6EabkufoPr0bX4VF7a/A7+AkOOvJCJO8Q+BRj08h5fJPkj9fWupv3cVg7xBxtF9O9jq70e8vz/x3hBjo78/ucfNoIpe9Rks/RLqtIO6HaBue6jTnnXk8nzsC7Sp0YY2NdrQunprWtdoTZh/WHl/YpFKRaGFSDnIyclh9uzZxMbGkpycTG6uZ5G1devWAbB58+bC0KJLly4AvPLKK0RFRTF48GDCwkr+x2zOnDkADB06tMTzvXv3BiA2NvaU6i265SlAeno669atY/ny5Tz22GN8/vnnpxXgiIicFw7ugbhpEPc17PE8H1+/RnWIKP53dd186BvWlH6trqVjzA34+OqZd5FKIzACmvb2HF5+h9Nos3c1bfauZuje1bB3DUf37Wabvx9xRYKMtjk5kHsUdv7sObzWVavOhuphbEjbUOxWDUIbeEKMGq0LA42o4KjCWbgiVZ1CC5EyqFmzJnBsFsSpWLduHUOGDGHHjh2l9snMzCz87759+/Lwww/z+uuvc+ONN+Lr60vnzp3p378/d955J82aNSvsW3DNm2++mZtvvrnU66ekpJxSzSVteep2u3n++ed57rnnGDZsmHYQEZEqJSV5Az+s/D967tlAk90rTjg/KCuLKRFhNMk39K/Whr7RNxLd6mpMCVPJRaSSCq4BLfp6Di+/Q0m03ruG1vt/Zei+tbB/rSewKEG8b8khRMKhBBIOJTB319zCtmoB1TwhRvVjYUbTiKb4uvTjm1Q9+lMvpy4wwvOoRWUTGPH7fUrRsWNHFi9ezKpVq7jlllvKPM5ay3XXXceOHTsYOXIkI0eOpFmzZoSGhmKM4cknn+Sll17CWlts3IQJE7jnnnuYPn06c+fOZfHixcTGxjJu3Dg+/fRThg0bBniCBIBBgwYRFRVVah21atU6jU9dnMvl4plnnmHSpEksWrSINWvW0LFjxzO+rohIRXUgfTs/LH+D7/cuZjlHcBvDnw4d5C/Hd6zVivbR1zCtcTdaNO/vRKki4pTQSGg1wHMUyD4I+9dBQYixby0kb+DOgxl0yc5ho78/G/z92Bjgz6FSgs0DOQdYtm8Zy/YtK2zzd/nTonoLWlZryQOdHqBOSJ1z/elEKgSFFnLqjDnttSEqq8GDB/PWW2/x5ZdfMm7cuDLvILJhwwY2bNhA165dmTRp0gnnt23bVurY1q1bM2bMGMaMGUN2djYTJ05k9OjR3HvvvYWhRYMGnsXb7r777sK2c8kYQ+PGjUlKSmLz5s0KLUTkvJOTfZCFKyYyY9ssFrkzPLt+FFmj4vuQYB5MP4ip3hTaDoWYoRAVg8sYtFeAiACeX5Q1udhzFDiaTbOkeJoVhBj712L3rGcPuWz09+c3f382+vuxIcCf/aV8n5nrziU+NZ741HgeyfGFel0gKgaqNfEsMAr8mvwrLlw0r9acYL/gcviwIueeQguRMhg0aBAxMTHExcXxwgsv8Mwzz5TaNyMjg927dxMTE0N6ejpwLFwoKj09nR9++KFM9w8MDOTRRx9lwoQJ7Nu3j6SkJCIjI+nfvz/vv/8+06ZNK5fQwu12Fz6SEhoaes7vJyJSHtz5eaxc+yGzNnzGnOx9ZLpK3vWjbr6lT7ULyB34IQENumtnABEpO79AqN/Zc3gZdz4NUrfQYN9a+ibFQaLnOHAowRNgeBf6/C3Aj+1+fuR7/86pmZdPjUWvFbl2CERFQ2Q0b+RsYvnhPRgMDcMa0rJ6S89RrSWtqreiYVhDfFwnbuUqUpEptBApA2MMH3/8MT179uTZZ58lOzubv/3tb4SEHFv93VrLjBkzePTRR3nyySeJiYmhRYsWuFwu5s2bx+bNm2nZsiUA2dnZjBw5krS0tBPu9c0331CnTh169OhRrH3lypUkJiYSGhpKtWrVABg2bBjR0dFMmTKlcGZGQEBAsZqWLFkCeLZePRNut5vnnnuO5ORkwsPDz/h6IiJO27r1B2as+RezDm5kv483gDhuF4CabsugkKYMir6J9tHX4dI3+yJytrh8jm2/yvDC5mpH0rkwMZ4LE+MgcT0kxpGzJ54tJo9N/n7kHh+YHs2ChOXYhOVsalQffHywWHZl7mJX5i5+3PVjYddAnwCaVWtOy2qeMKNV9Va0rN6SmoE1tfCnVFgKLUTKqGPHjsydO5dhw4YxduxY3nzzTXr27ElUVBQHDx5kxYoVJCYmEhgYSMOGDQGIjIzkrrvu4r333qNDhw706dOHoKAgFi1aRH5+PiNGjDhhwcv58+fzxhtvUL9+fTp16kR4eDh79+5l0aJFhcGBv79nBXpfX1+++eYbBg4cyNNPP83EiRNp3749kZGRpKSksGbNGpKSknjttddOKWT4+eefGTFiROH7AwcOsHbtWrZv346Pjw//+te/CA8PP+OvqYhIeUtN2cisZeOZmbSM31yedYHwKf6NepDb0tc/kitbD+PCjnfj6xtQwpVERM6RoOrQpJfn8Apwu4lJ305MYsGMDE+YQfr2wj6HjaFhXh45xpBdyloZ2fk5hY+YFFXNP4Jm1ZrT3Hu0qdGGLlFdzs3nEzlFCi1ETkGvXr3YsmUL77zzDjNmzGDt2rWkp6cTGhpK69atGTlyJHfffXexx0EmTZpEmzZteP/99/nxxx+JiIigX79+vPDCC3zwwQcn3GPEiBH4+vqycOFCYmNjOXjwIHXq1OGKK67goYceom/fvsX6t2zZktWrVzNx4kS+/vprli5dSl5eHnXq1KFTp04MGTKE66677pQ+59atW9m6dWvhe39/f+rWrcstt9zCww8/TOfOnU8yWkSkgsk/StzqD3gv/kMWuA961qk47vt5l7X0NKFc2XgAfbo9SHCItnUWkQrE5YKazT1H9JBj7TmHIHkDJK4nJDGOTxPjyE9cT0JeFpv9/byHP5v9/Njl54u7lNkUB3IPsippFauSVgHQJaQBk3v8wzMLJKD4ds6JWYlEBkdqZoaUG3P8rgVy/jLGxEVHR0fHxcWdtJ/b7Wbjxo2AZzFIl7ZrkzOgP08i4pikDbDmY/j1Mxa7MxlZJ/KELtFuH66M6sHl3f9KrVptHChSROQssxYy9nj+Dkz+zRNqJG3gSMoGttlcNhWGGX5s9vMn1ffEx96uy8jk76metdmIaAi120Dt1qTXaMwl8f9HiG8wzau1KJyZ0SyiGc2rNadOSB1cRt/rSXExMTHEx8fHW2tjTme8ZlqIiIjIecMeOYCJmwarP4Y9KwrbewBReXkk+voSmW8ZUu0Crup0L82a9nGuWBGRc8EYiGjgOVr2K2wOspaYgwnEJG+ApIIw4zfSkjaxzRxlm58fW/z82ObvR7uc3GPXO7jbc2z5ga2BAVA3iqy8w6xNWcvalLXFbh3kE+gJMao1p2lE08KjYVhD/Fx+5fUVkPOMQgsRERGp1KzbzcpfJzMt/mMSDu3hw337T+jj4+PPo8EtCW3Rn56d7sHH19+BSkVEHGQMVGvoOVr2L2yu4XZTIyOBrgUzM5I2gOs3yNkIRw8Xu0RCKduxFjiSn8361DjWpxaf2e1jXDQMbUCTas1oGu4JMrpEdaFReKOz9/nkvKXQQkRERCqlgwd2MmPJi3y5/xe2+Xgfdw30Z6O/H61zj3re12kPnW6FdtcyKLiGc8WKiFRULhdUa+Q5Wg041u52e2ZYFJmZ8ceUTfTZu5ltZLPNz4+t/n5s9b7uP0mgkW/d7MjcxY7MXcxnPgCP172Mm1vfALVaQXDNwm2kD2QfICM3g3qh9fB16cdVUWghIiIilYh1u/k17lO+XPs+3+cmkeMycNzj2DOr1aR10z9Cx5uhbntH6hQRqfRcLqje2HO0GljYHG4tHTP30zFlE6RsgpTNkLKRQ6mb2X4kmS3+fmzz82OHny/b/f1I8PUlv4RFO5uu+hyWfOh5ExgBNVtAzRbM8XPzj7Rl+BofGoc18szO8D5m0ji8MU3CmxAREFFeXwWpABRaiIiISIWXmbGHmUte4st9i9hcsFWpq/g3wT0IYlizq7is+0MQoG2ZRUTOCWMgvK7naPaHwuZQoF1OJu1St3iCjOSNkLKJoymb2H1wJ9t9YbufH9v9fNnh50ezo0ePXTP7IOxZCXtWsr1GNYgIJ8/mszVjO1sztp9QQoRfKI3Dm9AoogmNwxvTOLwxjcIb0TisMaH+oef+ayDlSqGFiIiIVFhxv03lizXv8L/sfRxxnbhVaQ235erw1lzb/REaNezlTJEiIuIREAb1OnkOLz+gWX4ezQ7s9M7M8B6+3mAj+0CxS2S4XBhrsSfZUvXg0UOsTV3P2tT1J5yrGVCNxhFNaRTemPs73k+dkDpn69OJQ6pcaGGM6QaMBi4GagNZwDrgP8Bke9wesMYYH+AvwJ1AC+AQ8BPwjLX2t5Pc5yrgUaDg/7GrgFestbNOMiYGeBa4FE9YuQV4H3jTWus+xY8qIiJSKR3NOcT3S8byyY5ZrHPleRqPm1XRzQYwvNlV9L1wFP4B+q2aiEiF5uMLNZt7jtaXH2u3Fg6nQupWSN0CqVt4IXULT6dtZWfGTnaYfLb7+xXO0Njl58ch18m3VE3NOUBq0mpWJa3mwZ0boFYb771bQI1mEFqHWTv+R/LhZBqFN6JJeBMahDXA30cLNFdUVSq0MMYMAz7H8/TrKmARnuCiN54Qox9wc5H+LuBL4BrgADALqAVcCww2xlxmrY0t4T5/BV4D8oC5QA4wAJhpjHnQWjuxhDE9gR+BICAW2AFc4r3ORcaY648PVERERM4nyUnr+WLxP/kyfT2pPifOqgh3W64Obc613R6mWZNLHalRRETOImMgpJbnaHRhYXMA0MrtplXmXm+YsRVSt2JTNpOWvoWdh/ez08ewy8+XnX5+7PT1ZbefL0eKBBpBbje1N82BTXOK39M3iGl1o1jme+x3wi4MdYNq06haMxp5181oGNaQhmENqR9WnwCfgHP9lZCTqDKhhTHGF3gbT2Bxs7X2kyLnLgB+Bm4yxvzbWvuT99SdeAKLzUBva22it/8wYCowxRhzgbU2r8i1WgOv4gkqLrPW/uJtbwUsAV4zxsy21m4pMsYPmIInsHjEWvuatz0UmAMMB74DJp/dr4qIiIjDrIXdsRD7Dq8lLmBGaDD4FJ9V0dH6cV3jy+nfYzSBQdWcqVNERMqXywURDTxHs0sBMEBNoGb+UTof2FU4O4PUrdjUzSSlb2NXdjI7/Hw5bFyU+IBJ3hF2kUvRH4XdWPYcSWLPkSR+2bf0hCGRATVoGN6YhhGNC8OMBqENaBjWkGqB1c7+Z5diqkxoAbQBIoGNRQMLAGvtb8aYj/E8BtINz+MfAI94X8cUBBbe/l8ZY74FhgBXA18VudxDeIKRiQWBhXfMJmPMC8AEb58Hi4y5BmgK/FoQWHjHHDLGPACsBEah0EJERM4XR7Nh/VcQ+w7s+xWAG/39PaEF4G8tVwTU5abOD3JB6yFOVioiIhWNj9+xx03w7GxigCggKvcw3dK3Fwk0th3778MpWKBf1mF2+Pmx08+XPaXsblJUUk4aSclprExeXay9hm8wCy6dBDWaQlD1YudSjqRQPaA6Pq7jtriSU1aVQoucMvZLBTDGNAUuAI7geSzkeFPxhBZXUTy0GFzkfEljJnjHFA0tSh1jrV1ljNkGtDXGNLHW7ijj5xAREalwUpJ/I3HFu8Ssm+55jrmIdrm59M+1RNfpyrCLn6Z69WYOVSkiIpWWfzBExXiO42VnYNK3MyZtO6Rtg/TtHE3bxt70HezMSWWXny87/HzZ7X3cZJ+vL3knCTQaHEqH9y7zvAms5lkzo0ZTqN6UoftmcMh9lPrBUTSIaELD8EbFZmk0CGtAoG/gufkanGeqUmixDdgKtDbG3FTC4yG3AOnANG9zB+/remvtUU60yvtauAG8MaYa0Mj7dvXxA6y1u40xKUBjY0y4tTbjuHutOn5MkfZm3nvtKO0DioiIVFRbt/7Af5eNY0buPhoezWPa4dTiS1Y06Q0X3sOEVpd7FmwTERE52wLDoW4Hz+HlBzQGGh/NhgM7IW07pHtCjbzUbew7uJ3dh/eT4GNI8IYZBaFGg7y8Y9fOPgB7V8HeVRwyhvQmDQHYkbWHHVl7YO/iE8qJ9K9Gg/CGNAhvQv2wBtQPrU8D72tkcCQuc/JFR6uKKvNdgbU23xhzOzATz1oUo/CsVRGJZyHOeGCEtTbNO6QgfEgo5ZIF7Y2LtBWMSbfWZp1kXC3vuHVncK9SGWPiSjnVvCzjRUREzgbrdrN89XtMXv8Bi/D+s2gM2/z9+DkokEuOGuhwPXT/c8m/ERMRESkvfoFQu7Xn8PIFGgIN3flwMKEwzCBtOzZtGznZO8AvG44W/9Fvj2/ZfsxOyj1AUsoBVqWsO+Gcn/GhXlBt+jfuz0Pdx5zBB6v8qkxoAWCtXWyM+QOe2RSdvQdALvADntkYBQr2TztcyuUK/mSGncKY0x1X0hgREZEK6ejRw8xZ/BIfbv+W31wn7thdO99yuMP1cMmzEFyj/AsUERE5FS4fqN7YcxRZFDQQPAtKZyV7Zmh4HzlpnbadZQe2k5CRwO6jBwpnaBS87v2dx04Ajtp8dh7eT/qySTDvLajexHP/ap46koOrM3LjB7xx2Rs0qH5+/266SoUWxpgbgQ+ApcCNQBxQD3gUz0KXlxljLrLWlnX9iwrJWlvir6u8MzCiy7mc805WVhbvvPMOM2bMID4+nvT0dEJCQmjTpg39+/fn7rvvplGjRr9/oQouPj6eSZMm8dNPP7F7926ys7OpVasWXbp04dprr+WGG27A31/7WYvIMZkZe/h64dN8lLSMxBK2LG3pdnF7k8FccdFT+AWEOFOkiIjI2WQMhEZ6jiLbtgYDrYBWR4/Agd2eR0/Sd0D6DvLSd7D/4HZ2Z+1jj81hj68n0Njj68seP1/SfI4t3tkgLw+yM2DfGs/hlRDgz6Z6dYh4swvEDIVr/1Nen7jcVZnQwhjTEvgQSAKutNYe8p7aDNxjjKkHXIlnm9NJQMH54FIuWfDdVmaRtt8bc7Jx1U/xXuKAJUuWMGzYMPbv309wcDA9evQgKiqKgwcPsnz5cpYuXcq4ceOYOXMm/fr1c7rc02Kt5emnn+all14iPz+fRo0acdlllxEUFMTu3buZPXs2M2bM4LnnnmPr1q1OlysiFUBy0no+Wvg3vsjcQpbLnLBl6UUEc3vbEfTsdA/GpedzRUSkCvELgtqtPIeXL9DAe3DkgDfQ2Fn4ejh9O3sydpJwOJGm2SVPxk/w9SU8P58wayEgvBw+iHOqTGgB3IBnnZXZRQKLor7AE1pcgie02OVtb1DK9QradxZpKxhT3RgTUsq6FqWNq+49t7aMY6ScrVmzhr59+5Kdnc1jjz3G3//+d0JCjv2m0O1288033zBmzBgSEkpbnqTie/LJJxk7dixRUVH85z//4Yorrih2Pj09nVdffZVXXnnFoQpFpKJISPiFyT8/x7TsBHKNAdexsMLXWq7wr8Nt3UfRusXlDlYpIiJSgQVV8xxFFgcNBloCLa2FQ4nFAg0O7ID0nXQ7uJNxySmeAdXLtPRhpVWVQouCH/wPlnK+oL1gg91fva9tjTF+JewgUrAeRmHIYK09YIzZhWdhzU7Az0UHGGMa4lmEc2eRnUMK7tXBe83vSqjthHtJ+bLWcuutt5Kdnc2zzz7LM888c0Ifl8vF0KFD6du3L7t373agyjMXGxvLyy+/TFBQED/99BMXXHDBCX2qV6/OCy+8cEKYISJVx9atc3h/6Ut8dzTZs7d9kedyw9yW4eFtuOniZ4iKaudglSIiIpWcMRBWx3MUefQEoA5QJ/8oZOwBv/P7kcuqNEdzv/e1aynnu3lfdwBYa7cDvwFBwOAS+l/rfZ1xXPus486f0RhjTCc8252ut9buKLl0Oddmz57N+vXradCgAU899dRJ+0ZERNC2bdvC9/v27WPcuHH84Q9/oH79+vj7+1OnTh2GDh3K8uXLS7xGcnIyjz/+ONHR0YSGhhIREUGrVq247bbbiI2NPaF/WloaTzzxBNHR0QQFBREREUGfPn2YOXPmKX3O8ePHY63lL3/5S4mBRVG9evU6pWuLyHkgYSWfTRnIH38exYy8FE9g4VU73/JorZ78MPxHHh42VYGFiIjIuebj51mgM7S205WcU1UptJjufb3EGHNv0RPGmB7Aw963U4ucmuB9HWeMiSzSfygwBNhS5LoF3gDygZHe6xaMaQk8BeR5+xQ1DdgOdDDGPFxkTAjwlvft+DJ8RjlHZs3y5ErDhw/Ht4xbGBWYPn06jz32GImJibRv355rrrmGevXqMW3aNHr16sWcOXOK9c/MzOTCCy/k5Zdf5tChQ/Tv358BAwZQvXp1PvvsM777rvhknE2bNtGxY0fGjh3LkSNHGDhwIF27dmXZsmVcddVVvPrqq2Wq0+12M3v2bABuuummU/qMInIesxa2L4T/Xg3/7kPP7StwWVt4ukE+PF2vP/+7eQm3D36XkNAoB4sVERGR802VeTzEWrvKGPMqnp1C3jbG3A/E49k9pCeeAOdda+3cIsP+A1wBXANsMMb8iOfxjj8AR4BbrLV5x91nozFmNJ7AY5Ex5gc8W6oOwDNr4y/W2i3HjTlqjLkFmAtMMMZcj2f9it5AXTxByodn76txduTk55CTf3Y2Wgn2DcbXdeIfx7NxjwCfAAJ8As7oGmvWrAGgc+fOJ+9Ygl69erF+/XpiYopv6vL9998zZMgQ7rvvPjZv3ozx/sZy6tSpbN++nSFDhjBt2jRcRRatS05OJjExsfB9fn4+1157Lbt372bcuHGMGjWqsP+WLVsYMGAAjz/+OIMGDSo2+6Mk27ZtIyMjg4CAgBNqFZEqyFrYMhcWvAwJx2aFNc7LY0DWYbYEh3FXs6sZdNGT+PoFOlioiIiInM+qTGgBYK0dbYxZAowEugCt8ezIsQB4z1r76XH93caY4cBDeHYVuRLIAr4CnrHWxpdyn9eMMVuA0XiCB4AVwDhrbYnz9a21S4wx3YDngEvxrHGxFXgFeMPaIr/WqiDeX/c+k36ddFau9Z+B/6FbnW4ntJ+Ne9zb4V7u63jfGV0jNTUVgNq1T33qVbt2JU+RHjhwIMOHD2fKlCmsX7++sF9ycjIAffr0KRZYFNy/aA0zZsxg3bp1DBs2jNGjRxfr26JFC8aPH8/QoUN57733eOON4yf4FFfwGatXr45PkW2WRKRqsW43v6x8m2/WTebFXZtP/Eahfleevuh+QtoMweVTpb6NEBEREQdUue82rLXT8DyOUdb++XhmTUz4vb7HjZvBiWtX/N6YOEpeC0MquZycHGbPnk1sbCzJycnk5uYCsG7dOgA2b95cGFp06dIFgFdeeYWoqCgGDx5MWFhYidcteLRk6NChJZ7v3duTmZW0DoaISFHW7eaXVf9i0rp/s8Z1FHzgotAQ/njIuxFWs0uh9yho0puwImtZiIiIiJxLVS60EDkdNWvWBI7NgjgV69atY8iQIezYsaPUPpmZmYX/3bdvXx5++GFef/11brzxRnx9fencuTP9+/fnzjvvpFmzZoV9C6558803c/PNN5d6/ZSUlN+ts+Azpqenk5+fr9kWIlWEdbtZtvodJq17j1XmaLHVrt6pFs5VUT3xuewJaFDaOtYiIiIi545CCzltd7W7i1uibzkr1wr2DT5n9zjT9SwAOnbsyOLFi1m1ahW33FL2eqy1XHfddezYsYORI0cycuRImjVrRmhoKMYYnnzySV566SWOf/pnwoQJ3HPPPUyfPp25c+eyePFiYmNjGTduHJ9++inDhg0DPItnAgwaNIioqNIXv6tVq9bv1tqsWTPCw8PJyMggLi6O9u3bl/lzikglZC2xq9/jrbXvsMrkwnGTJ3oSzH09/opP2xudqU9EREQEhRZyBs7GApcV4R5lMXjwYN566y2+/PJLxo0bV+YdRDZs2MCGDRvo2rUrkyaduDbHtm3bSh3bunVrxowZw5gxY8jOzmbixImMHj2ae++9tzC0aNCgAQB33313YdvpcrlcDBo0iC+++IJPPvlEoYXIeWz56vd5+9e3WVFCWNGDIO7r/BCd2pU+e0tERESkvFSlLU9FTtugQYOIiYkhISGBF1544aR9C2YqgOdRCzgWLhSVnp7ODz/8UKb7BwYG8uijj1K3bl2Sk5NJSkoCoH///gBMm1bmZVpO6pFHHsEYw5tvvslvv/120r5Lliw5K/cUkfITv2EaIz/szp1rX/cEFkVcSCCTO43hvdtjFViIiIhIhaHQQqQMjDF8/PHHBAYG8uyzz/LEE0+QlZVVrI+1lm+//ZauXbuyfLlne8AWLVrgcrmYN28emzdvLuybnZ3NyJEjSUtLO+Fe33zzDUuXLj2hfeXKlSQmJhIaGkq1atUAGDZsGNHR0UyZMoV//OMf5OQU3x7WWsvixYtZvHhxmT7nhRdeyJgxYzhy5Ah9+vThu+++O6HPwYMHeeaZZ7jsssvKdE0Rcd7OnQsY/fElXL/saRZzpNi57gTyQcdH+ffty+nS/laHKhQREREpmR4PESmjjh07MnfuXIYNG8bYsWN588036dmzJ1FRURw8eJAVK1aQmJhIYGAgDRs2BCAyMpK77rqL9957jw4dOtCnTx+CgoJYtGgR+fn5jBgxgsmTJxe7z/z583njjTeoX78+nTp1Ijw8nL1797Jo0SLcbjfPPfcc/v7+APj6+vLNN98wcOBAnn76aSZOnEj79u2JjIwkJSWFNWvWkJSUxGuvvUavXr3K9DlfeuklfH19eemllxg8eDCNGzemU6dOBAUFkZCQwLJly8jNzaVly5Zn9esrImdf0v61/OunR/k6Zy/5x+340dn680DH++nW8U6HqhMRERH5fQotRE5Br1692LJlC++88w4zZsxg7dq1pKenExoaSuvWrRk5ciR33313scdBJk2aRJs2bXj//ff58ccfiYiIoF+/frzwwgt88MEHJ9xjxIgR+Pr6snDhQmJjYzl48CB16tThiiuu4KGHHqJv377F+rds2ZLVq1czceJEvv76a5YuXUpeXh516tShU6dODBkyhOuuu67Mn9EYwz//+U9uvPFGJk2axLx58/jxxx/Jzs6mdu3aDBw4kOuvv/6Uriki5ctmpfJ///sT/83cRI7LQJHAopXbxUMxd9G76wMYlyZcioiISMVmjt+1QM5fxpi46Ojo6IL1FkrjdrvZuHEj4FkM0qVvauUM6M+TSDnKOQRLJ8GSN3k2zJevwkILTzXIhweaD+Xyi/+Oy0e/sxAREZHyERMTQ3x8fLy1NuZ0xuu7FhERkcouPw9WfgALXoasZABG5vkwIySEcAsj6/dh6GVj8fMveXtpERERkYpKoYWIiEglZd1u0uK/pub8lyFlU7FzdfxCebv+5bS7+HGCg2s6VKGIiIjImVFoISIiUglt3DSTV395jt1HDzE9dS8BBSd8g6DHSOj1EBcGVXeyRBEREZEzptBCRESkEklOWsfEuQ8zLXc/1hjw8+WT8DDuOHgIOt0Ml/0Nwus6XaaIiIjIWaHQQkREpBI4fDiFD+f8hQ/S13LkuB1B1taoDzf+G+q0c7BCERERkbNPoYWIiEgF5s4/yrfzn+L/dn5Hko8B17Gwomm+4dGYO+nd7S+gnXlERETkPKTQQkREpIJasfo/jFvzBr+53OBzLKyo7rbcV68Pw/q8jJ9fkIMVioiIiJxbCi1EREQqmP37VzNh7kP8Lz8dikyg8LeWW8LacHf/NwkLr+dcgSIiIiLlRKGFiIhIBZGbncF/5zzAu6mrPOtWFHG5b00euuxV6tfr6lB1IiIiIuVPoYWIiIjDrNvNwmWv8fJvk9ntQ7F1K6LdvjzR/TE6xtzgXIEiIiIiDlFoISIi4qAdOxbw8oIx/Mxh8DnWXt1teajhIK65bCwuH/1zLSIiIlWTvgsSERFxQnYGLHyFTzZO4efwkMJmH2u5Ibgp9w58m4iIhg4WKCIiIuI8hRYiIiLlyVpY+wX88Hc4lMj9Lhf/CwnkgI8P3Qnksd7/pFXzgU5XKSIiIlIhaFN3kVOUlZXFhAkTuOyyy4iKisLf35/q1avTs2dPnn76aXbt2uV0iadt8uTJGGOKHSEhIdSrV49LL72Uxx57jLi4OKfLFKm8UjbDh1fBtD/DoUQAItxunjzi4tXmN/DvW5cpsBAREREpQjMtRE7BkiVLGDZsGPv37yc4OJgePXoQFRXFwYMHWb58OUuXLmXcuHHMnDmTfv36OV3uaWvevDkXX3wxALm5uaSkpLB69WoWLFjAuHHjuPnmm3n77bcJDw93uFKRyiEn+wCfzX6Q69bPJigv99gJ30Do9Vcu7/UQ+Ac7V6CIiIhIBaXQQqSM1qxZQ9++fcnOzuaxxx7j73//OyEhx55Dd7vdfPPNN4wZM4aEhAQHKz1zF198MZMnTy7WZq1l1qxZPPjgg0yZMoWEhAR++OEH/Pz8nClSpJL4ZcXbvLB2Ejt94GBYEH9J94YWrS6Hy1+G6o2dLVBERESkAtPjISJlYK3l1ltvJTs7m2effZaxY8cWCywAXC4XQ4cOZeXKlXTt2tWhSs8dYwxXXnkly5Yto169eixYsIBJkyY5XZZIhZWSvIHHP/4Df47zBBYAH0SEs7V6fbh+Ctz4qQILERERkd+h0EKkDGbPns369etp0KABTz311En7RkRE0LZt28L3+/btY9y4cfzhD3+gfv36+Pv7U6dOHYYOHcry5ctLvEZycjKPP/440dHRhIaGEhERQatWrbjtttuIjY09oX9aWhpPPPEE0dHRBAUFERERQZ8+fZg5c+aZffASREZG8vzzzwPw5ptvnvXri1R27vyjfPH9Xxgy81pm5acVtrus5YaQ5tS56ye44EowxsEqRURERCoHhRYiZTBr1iwAhg8fjq/vqT1VNX36dB577DESExNp374911xzDfXq1WPatGn06tWLOXPmFOufmZnJhRdeyMsvv8yhQ4fo378/AwYMoHr16nz22Wd89913xfpv2rSJjh07MnbsWI4cOcLAgQPp2rUry5Yt46qrruLVV189sw9fguuuuw6Xy8XWrVsr/aMwImfTxk3fcut/u/OP/T+R6ToWSrR1+/JZzxd5bPh0QkKjHKxQREREpHLRmhZy2tw5OdicnLNyLVdwMKaEMOBs3MMEBOAKCDija6xZswaAzp07n/LYXr16sX79emJiYoq1f//99wwZMoT77ruPzZs3Y7y/dZ06dSrbt29nyJAhTJs2DZfrWLaYnJxMYmJi4fv8/HyuvfZadu/ezbhx4xg1alRh/y1btjBgwAAef/xxBg0aVGz2x5kKCwujWbNmbNmyhfj4eBo0aHDWri1SGWUfTuPt7+7iv4c2k18krAh1Wx6q14fhfcfj46v1X0REREROlUILOW2p775HyltvnZVrNfrwQ0Iu7H5O7lHr/vup/eADZ3SN1NRUAGrXrn3KY9u1a1di+8CBAxk+fDhTpkxh/fr1hf2Sk5MB6NOnT7HAouD+RWuYMWMG69atY9iwYYwePbpY3xYtWjB+/HiGDh3Ke++9xxtvvHHKtZ9MrVq12LJlC+np6Wf1uiKVzYrV/+HZ1a951q0o8sjH5b41Gd3/bWpHRjtXnIiIiEglp9BCpBzk5OQwe/ZsYmNjSU5OJjfXs3vAunXrANi8eXNhaNGlSxcAXnnlFaKiohg8eDBhYWElXrfg0ZKhQ4eWeL53794AJa6DcaastQCFM0REqppDmXt5fdadfJ6zB3yOtTfMh7+1v5eLut7nXHEiIiIi5wmFFiJlULNmTeDYLIhTsW7dOoYMGcKOHTtK7ZOZmVn433379uXhhx/m9ddf58Ybb8TX15fOnTvTv39/7rzzTpo1a1bYt+CaN998MzfffHOp109JSTnlun9PwTVr1Khx1q8tUtEtWvY6z8f9m/0+x0I7l7XcHtqKewe/T1BQdQerExERETl/KLSQ01bzz3+ixu23nZVruYKDz9k9zBmuZwHQsWNHFi9ezKpVq7jlllvKPM5ay3XXXceOHTsYOXIkI0eOpFmzZoSGhmKM4cknn+Sll14qnLVQYMKECdxzzz1Mnz6duXPnsnjxYmJjYxk3bhyffvopw4YNA8DtdgMwaNAgoqJKX9yvVq1ap/GpS5eRkcG2bdsAiI7W1HepOg6kbWPc/+5iRl4KFAksWrpdPN/jadpeMMzB6kRERETOPwot5LS5AgLgLAQCTt+jLAYPHsxbb73Fl19+ybhx48q8g8iGDRvYsGEDXbt2ZdKkSSecL/jBvyStW7dmzJgxjBkzhuzsbCZOnMjo0aO59957C0OLggUw77777sK28vDFF19graVVq1bUq1ev3O4r4hhrca+byh3Ln2WL77G1Znyt5c/VO3L35e/i519y+CoiIiIip09bnoqUwaBBg4iJiSEhIYEXXnjhpH0zMjKIi4sDKFyksqTdNdLT0/nhhx/KdP/AwEAeffRR6tatS3JyMklJSQD0798fgGnTppX5s5yppKQknn76aQAeeuihcruviGMy9sJnN+H6+m7+lJZW2NzO7cuXvV/j3qs/VmAhIiIico4otBApA2MMH3/8MYGBgTz77LM88cQTZGVlFetjreXbb7+la9euLF++HPDs4OFyuZg3bx6bN28u7Judnc3IkSNJK/IDUIFvvvmGpUuXntC+cuVKEhMTCQ0NpVq1agAMGzaM6OhopkyZwj/+8Q9yjtse1lrL4sWLWbx48Zl+CbDW8t1333HhhReyb98++vTpw5///Oczvq5IhWUtrPkE3uoBG78D4PKswww6nMOjtS/io1uX0aJ5f4eLFBERETm/6fEQkTLq2LEjc+fOZdiwYYwdO5Y333yTnj17EhUVxcGDB1mxYgWJiYkEBgbSsGFDACIjI7nrrrt477336NChA3369CEoKIhFixaRn5/PiBEjmDx5crH7zJ8/nzfeeIP69evTqVMnwsPD2bt3L4sWLcLtdvPcc8/h7+8PgK+vL9988w0DBw7k6aefZuLEibRv357IyEhSUlJYs2YNSUlJvPbaa/Tq1avMn/Xnn39mxIgRAOTm5pKamsqqVasKF9+89dZbeeutt8r8mIxIZXM0Yx9+s0bBxlnF2k3TPzDuytcxNZuVMlJEREREzib9xCFyCnr16sWWLVt45513mDFjBmvXriU9PZ3Q0FBat27NyJEjufvuu4s9DjJp0iTatGnD+++/z48//khERAT9+vXjhRde4IMPPjjhHiNGjMDX15eFCxcSGxvLwYMHqVOnDldccQUPPfQQffv2Lda/ZcuWrF69mokTJ/L111+zdOlS8vLyqFOnDp06dWLIkCFcd911p/Q5t27dytatWwEICgqiWrVqREdH06NHD2677TZiYmJO46snUjn8uHgsYzd+xKR9ibQoaAwIh4EvQKdbtc2viIiISDkyx+9aIOcvY0xcdHR0dMF6C6Vxu91s3LgR8CwG6XLpKSI5ffrzJJVFxsFdvDxzBN/mebY2js7J4eO9ifg1uxSufgsiTlybRkREREROLiYmhvj4+Hhr7Wn95lMzLUREpMr7ZcXb/H3t2yQW2cZ0q58/v132KO17PwUK20REREQcodBCRESqrMNZybw243Y+y9kNRQKL9m4//tnndZo2vsTB6kREREREoYWIiFRJa9Z+zFMrXmaXz7E2X2u5r0YX7rjiXXx9A5wrTkREREQAhRYiIlLFHM3N4u0Zt/GfzI24i8yuaOl28VKvF2ndarCD1YmIiIhIUQotRESkyti1cxGPzXuQ9a588O4C4rKWO8Iv4L7BH+AfEOpwhSIiIiJSlEILERE571m3m+k/Pc6Lu77jiOvY7IpG+fBC96fo2PZGB6sTERERkdIotBARkfNaxsFdPD/jZr7PPwBFAothAfUYM+QTgoNrOleciIiIiJyUQgs5gTHHvql3u924tNWfnAG3213430X/bImUh1W/fsjjK19hX5G1K8Ldlmdb3UL/Xo87WJmIiIiIlIVCCzmBMQZ/f39yc3PJysoiIiLC6ZKkEsvKygLA399foYWUn/yjTJt1D8+mxRZbbLObDeDFy/9NnTodnatNRERERMpMoYWUKCwsjNTUVBITEwEICQnRjAs5JW63m6ysrMI/Q2FhYQ5XJFVG2nb46m66Jq4mqH5dsozB11rur9mVOy5/Fx9ff6crFBEREZEyUmghJapZsyZZWVlkZ2ezd+9ep8uRSi4wMJCaNbVugJSDXz+HWaMgN5OGwFMpaUyqWYuXezxDu+jhTlcnIiIiIqdIoYWUyMfHh0aNGpGamkpmZia5ublOlySVkL+/P2FhYdSsWRMfHx+ny5HzWW6WJ6z49dNizVe1Gkr/fs8RGFLLocJERERE5EwotJBS+fj4EBkZSWRkJNZarLVOlySViDFGa1hIudi69QcS5jzOHxK3HGsMiICrXoe2Qwl0rDIREREROVMKLaRM9AOoiFREM+Y9wT92zsAEWj7z86Xp0Txo1BOGvgfVGjpdnoiIiIicIYUWIiJS6Rw5nMpL31zPtKOJ4DKAYXTtWnze9EZ8+vwNfPTPm4iIiMj5QN/ViYhIpbJt24+Mmv8wW3yOPbIW4bY82OFefC78q3OFiYiIiMhZp9BCREQqjZk//Y3nd3zDEZ9jj6t1sH68Muh96tbt5GBlIiIiInIuKLQQEZEKL/twGmOnX89Xufu9j4N43B7SgoeunoKfX7CD1YmIiIjIuaLQQkREKrTt239i1Py/stnlLmwLc1teaHMHl/Uc5WBlIiIiInKuKbQQEZEK64ef/8nfNn/G4SKzK9q5/Xhl4LvUr9fVwcpEREREpDwotBARkQon72g2b06/kQ+ythR7HOTWkOY8POQT/Pz1OIiIiIhIVaDQQkREKpT0tK2M/vYGlpnswrZQt+WfrW+j70VjHKxMRERERMqbQgsREakw4n6bysO/PMu+IruDtHC7eL3vWzRudLGDlYmIiIiIExRaiIhIhfDDvKd4fNd0cosEFgN9avD8tVMJDqntYGUiIiIi4hSFFiIi4qy8HPhuNM3XTcGvXh1yjcHHWh6ufRG3Xf4vjMvldIUiIiIi4hB9JygiIs45mAAfXA6rPqTZ0TxeSE6lhtvyboeHuX3wuwosRERERKo4zbQQERFnbF8IX94Bh1MKm/rWaEuPqyYRUqulg4WJiIiISEWh0EJERMqVdbvZ9/M46v00Dmz+sRNd74RBYwnxDXCuOBERERGpUBRaiIhIucnNyeSfX13D3Ox9fOJjaJIH+ATA4PHQ+VanyxMRERGRCkahhYiIlIvUlI08MvNGVpmj4OPiwajafHzIh4jrPoL6nZ0uT0REREQqIK1wJiIi59zGTd9y47fDPIGFVzW/EPJunabAQkRERERKpZkWIiJyTv24+CWe2DSFIz6msO2P/nX4+9Bp+AeEOliZiIiIiFR0VWamhTHmUmOMLcPxdAljRxhjYo0xh4wxacaY74wxF/3O/Xp5+6V5x8UaY277nTENjDEfGGP2GmOyjTGbjDHPGWMCz/Tzi4iUN+t28+70W/jrlk844vIEFi5rebT2RTx//fcKLERERETkd1WlmRb7gQ9LOecD3OL970VFTxhjXgceAo4Ac4BAoD8wwBhzrbX2m+MvZowZBnyOJxRaCKQAfYEPjTHtrbWPljCmBfALUAtY762jK/A00NcY09dam3MKn1dExDHZh9N4+us/8r/89MK2ULdlXNt76N3tQQcrExEREZHKpMqEFtbaDcCIks4ZYy7HE1rsBuYXae+HJ7BIBXpaazd723t6+31gjJlvrT1QZEwN4D94gpBh1tqvve1RwM/AKGPMTGtt4X28JuMJLN601j7kHeMLfAFcAzwBPHt6n15EpPwk7l/DQ/8bQZzr2HamDd0w8dL/o1nTyxysTEREREQqmyrzeMjvKJhlMcVaa4u0P+J9/WdBYAFgrf0F+BdQDbjruGvdDYQD0wsCC++YRGCM9+2oogOMMd2BXkBSkT5Ya/OAe4GjwF+8IYaISIW1Lu5zbvzulmKBxYUE8ek1MxVYiIiIiMgpq/KhhTEmBLja+/ajIu1BQB/v26klDC1ou+q49sEnGTMLyAb6HbdORcGYGcc/AuINOxYB1YGLS/8kIiLO+t+CZxix/B8kF1lw84agxky6aQER1Ro7WJmIiIiIVFZVPrQAhgIhwGprbXyR9tZAAJBsrU0oYdwq72v749o7HHe+kLU2F896FYFAq7KM+Z17iYg4zrrdvDf9Nsbs+Jpc4wksfK3l7/X689R1M/HzC3K4QhERERGprPS4wbFHQz46rr2R97WkwAJrbZYx5gBQ3RgTZq3NNMaEAxEnG+dt7wo0BtaW5V5F2sv0q0pjTFwpp5qXZbyISFkdzc3in1Ov5uujiYVtEW7La51G0a3jHQ5WJiIiIiLngyodWhhj6uLZ1SMf+PS40wV78R0+ySWy8KxrEQZkFhlzsnFZ3tewU7hXSWNERBxlD6fz8JcDWcCRwrZG+fB2v3/RuJGeZhMRERGRM1elQwvgRjy7fMy21u53upizxVobU1K7dwZGdDmXIyLno/SdmE+u4/LDu1kQWQuATtafN675kurVmzlcnIiIiIicL6p6aFHaoyEAh7yvwScZH+J9zTxuTMG4jDKMKcu9ShojIuKMPSvhkxsgK4nBwJ60A2yJbM4/rv2WgIBwp6sTERERkfNIlQ0tjDEXAJ3wBAbflNBll/e1QSnjQ/A8GpJurc0EsNZmGGMO4lnXogEQX8LQguvtPO5enUq7VyljRETK34ZZMPUuyDv2SMif2t+DvewJXC4fBwsTERERkfNRVd495Fbv69fW2pLWktgI5AC1jTH1Szjf2fu69rj2X487X8gY4we0xbPt6aayjPmde4mIlJvDS96Ez24+Fli4fOHqtzB9/6bAQkRERETOiSoZWhhjDHCT921Jj4ZgrT0CzPO+HV5Cl2u9rzOOa5913PmirsSz3elca212CWOuMsYEHFdrFNAbSAcWl1SriMi5lJ+Xy8tfXMXt698iy3gbA8Lhlq+g0y0nHSsiIiIiciaqZGiBJwRoDOzhWDBRkgne178ZY1oWNBpjegL3AAeA948b8288a1lcbYwZWmRMJDDO+3Z80QHW2lg8gUQk8HKRMb7A24Af8Ka19mjZPp6IyNlx5HAaj3xyKR8f2cGGAH9GR9YiL6Ih3DUHml3qdHkiIiIicp6rqqFFwa8GP7HWukvrZK2dC7wB1ATWGGO+McZ8ByzEsx7IHdbaA8eNSQPuBNzAVGPMPGPMl3geN2kBTLDWzi/hdncAqcBDxpi1xpjPvGOGAkuAl073w4qInI6DB3bw58/7Mc8eWwM4JTCUQ7d+DZEXOFiZiIiIiFQVVS608D5+UfDoxse/199a+1c8gcJvQH+gJzAXuMRa+00pY74CLgG+x7PA5hXAFmCEtXZUKWM2e/tOBmoD1+AJPv4B9LXW5pTl84mInA37963i9q+HsMZ1bILXJSaMydf9QLVarRysTERERESqkiq3e4j3h/8apzhmMp4w4VTGLAYuP8Uxu/EEJCIijtm6dQ73LHiERB9T2DYsoB5/u/ZbfH0DTjJSREREROTsqnKhhYiIlG7N2o+4f+VYMnyOTcS7J6It9w+ZgnFVucl5IiIiIuIwhRYiIgLA/F9eYfSGD8n2hhPGWp6s24cbBr7pcGUiIiIiUlUptBAREabNHcVzCd+T7/I8EuJnLWNb3sSAXk86XJmIiIiIVGUKLUREqjDrdvPvGbfz5oE1YDyBRajb8kbHR+je6U5nixMRERGRKk+hhYhIFeXOP8rLU//IJ9m7CttquS2TLn6ZNi0HO1iZiIiIiIiHQgsRkSooNzuDJ6cO5vv8A4VtjfMN/xr4Pg3qd3euMBERERGRIhRaiIhUMYcPJfLQ1CtZarIL22Lcvrz9x6nUqNHcwcpERERERIpTaCEiUpUcTuOTz69mqe+xwOIignntupkEh9R2sDARERERkROVa2hhjJl3BsOttbbvWStGRKSqyUyEj65hRNJvxEXWYm5IMJf71uKF4bPw8w92ujoRERERkROU90yLS89grD1bRYiIVDkHdsN/r4a0rfgCLyelMLXtAG645lNcPpp0JyIiIiIVU3l/p9q0nO8nIiIpWzyBRUZCYZP/xY9wU9+nC7c5FRERERGpiMo1tLDW7izP+4mIVHXJOxdR64s7MFnJxxr7PgO9H3GuKBERERGRMnI5XYCIiJwb6+O/4Jp5I/mXX86xxiteVWAhIiIiIpWGHmQWETkPLV/9Pg+umUCWy8Xb1asRYuG2Pq9AhxucLk1EREREpMzKe/eQbWcw3Fprm5+1YkREzlMLl77GI7+9T47LM5nO11rqdL9XgYWIiIiIVDrlPdOiSTnfT0SkSvl+0fM8vvUL8lyeBTYD3JbX2t5D724POlyZiIiIiMipK++FOLWGhojIOfLtvMf5+66ZuL07goS4LRM7j6Zrh9sdrkxERERE5PRoTQsRkfPAtLmjeCbhe6w3sIhwW97p8TwxFwx1uDIRERERkdOn0EJEpJKbOuevPLfvR/AGFjXdlvf+8Botm/V3uDIRERERkTNTIR7XMMZEG2NeM8YsNsZsNMaMK3LuImPMX4wxNZysUUSkIvri+794Aguv2vmW//R5S4GFiIiIiJwXHJ9pYYx5BBhbpBYL1Dqu22tADvBOOZYmIlKhffK/+3gpaVHh+0i35f2+b9Ok8SUOViUiIiIicvY4OtPCGDMYeBXYDQwFIgFTtI+1dgmQDFxd7gWKiFRQH8+6p1hgEZVv+aDfOwosREREROS84vRMi0eALKC/tXYbgDGmpH5rgNblV5aISMX14cy7eDU1tvB93Xx4f8D7NGxwoYNViYiIiIicfU6vadEFWFoQWJxEClCnHOoREanQ/jNjRLHAon4+fDDoAwUWIiIiInJecnqmhT+QWYZ+kUDeOa5FRKRC+2TGnbyWtrLwfX03/OfyydSr28XBqkREREREzh2nZ1psBzqcrIMxxh9oD2wql4pERCoaa+GnF7n41+lE5nny24ZumHz5RwosREREROS85nRo8S3QxLuDSGnGALWBr8unJBGRCsRamPdPWPAyjfLyeH9fEl3zDB8M/pQ6dTo6XZ2IiIiIyDnl9OMh44CbgVeMMRcC07ztUcaYa4BrvOe3AxOdKVFExEHzx8KiVwvfNqnegg+u+xbCohwsSkRERESkfDgaWlhr040x/YCpwHDgWu+pQd7DAPHAH621ZVn7QkTk/LFoPCwYe+x9ZDTc9i2E1nauJhERERGRcuT0TAustZuMMR2Bq4ABQBM8j60kAD8AX1lr8x0rUETEAV/87z7ar/6CNgUNtdsosBARERGRKsfx0ALAWusGpnsPEZEq7YvZD/KPpEWE14nk3f3JxIQ2hNumK7AQERERkSrH0YU4jTE1nby/iEhFM23uKP6ROB+ADB8fnqlTB/dt0yGsjrOFiYiIiIg4wOmZFonGmDhggfeYb61NdbgmERFHzPjpSZ5J+B6MASAq3/L6wP/gqtbQ4cpERERERJzhdGixBugItAPuBzDGxOMNMIAF1tpkh2oTESk33y98jr/t/BbrDSxq51ve7/cvGtTv7nBlIiIiIiLOcXr3kK7GmHDgEuBS4DKgAxAD3AtgjNmAJ8CYb6390plKRUTOnXmLx/L4ti9xewOLGm7Lvy/7Pxo3utjhykREREREnOX0TAustRnATO/BcSHGpXhmYrQB7gEUWojIeWXh0gmM2vwxed7Aoprb8t4l42nW9DKHKxMRERERcZ6jC3GWIhc47D2OAPmA8R4iIueNJcvf4uEN/ykMLMLclnd7vUSr5gMdrkxEREREpGJwfKaFMSYQuIhjMyu6Af54QoqdwCd4Hw9xoj4RkXNh+ap/89D6SeS6PIFFiNvyzoXPcEGrqxyuTERERESk4nA0tDDGLOTEkOIzjq1hsdO56kREzo24+C954NfXyfYGFkFuy7+6PUW76OEOVyYiIiIiUrE4PdPiYsACccDzwFfWWutsSSIi587WrXMYuexZDrs8T+cFui1vdX6Ujm1vdLgyEREREZGKx+k1Lb4FDgBtgc+BdGPMt8aYR4wxXYwxWsdCRM4bexKW8ucFj3DAG1j4Wstr7e6lW4cRzhYmIiIiIlJBOb3l6R+9wUQHPNudXopn9sWVeGZgZBhjFnHscZFVDpUqInJGUpLj+dOcP5Hk48lijbW81Px6Lu56v8OViYiIiIhUXE4/HoL3cZA13uO1IiHGpd5jADAYT4jheL0iIqcqN3M/98y4kd0+x9qebjCQQb3/7lxRIiIiIiKVgNOPh5SkIdC+yBGItjwVkcoq5xD+n93MsPSUwqaHa3bn2n7jHSxKRERERKRycHzmgjGmEcdmVVwKNC44BeQCPwML0JanIlLZ5OXAZzfBnhXcBIS53Wxv3ps7r3zf6cpERERERCoFp7c83UbxkCIHT0gxH09QscRam+1MdSIiZyA/D6beCdsXFDZdFX0TXPGqg0WJiIiIiFQuTs+0qAcULrQJLFVIISKVntsNM/4CG2Yea2s3HC5/BbQpkoiIiIhImTkdWkRYa3McrkFE5KyxbjffTr+NQWtnEFDQ2GoQ/HESuCriMkIiIiIiIhWXo99BK7AQkfPNv2fczt8yfuX+qEiyjIHGF8PwyeDj53RpIiIiIiKVjn7tJyJylnw55yHePLAGgGVBgbzcoDnc+Cn4BTlbmIiIiIhIJaXQQkTkLJi3eCz/3Ptj4fsmbsNDf/wMAsMdrEpEREREpHJTaCEicobWrP2IMZs+xu1dZDPSbXln0AfUrNnS4cpERERERCo3hRYiImdg27YfeGDlWHJcnsAizG2ZdMl46tXt4nBlIiIiIiKVn0ILEZHTlLT/V0bOf5iD3l1B/KzljU6P0qr5QIcrExERERE5Pyi0EBE5DZkHd3Pvd7exz8czw8JYy0stbqRbxxHOFiYiIiIich7xdbqAoowxkUB979s91tokJ+sRESlJbnYGD027hk0+7sK2x+peysCLn3KwKhERERGR80+FmGlhjLnPGLMR2Aes8B77jDEbjDH3OludiMgx7vyjPPnlFSw3OYVtd4a14eaBEx2sSkRERETk/OToTAtjjAv4ArgGMMABYCdggcZAK2CiMaYvMNxaax0qVUQE63bzytQ/8r37YGHbEL9I/vrHzx2sSkRERETk/OX0TIs/A0OBTcAQa20Na20na21na21N4CpgI55Q488O1ikiwuRZd/Fx9q7C971MCM8On4FxOf1XqYiIiIjI+cnp77TvADKAS621M48/aa2dBfQBDgF3lnNtIiKFZsx7gglpKwrfR7t9mTBsBn5+wQ5WJSIiIiJyfnM6tIgG5llrE0vrYK3dD/zo7SsiUu6WLJ/I07tmFL5vmA9vDfmc4JDaDlYlIiIiInL+czq0AM/6FWejj4jIWWf3rOajlf9HnvFsbVrDbXmn/zvUqtnK4cpERERERM5/TocWG4E+xphapXXwnuvj7SsiUn4OJmA+vYHXE/dz+aEsgtyWt3v+g4YNL3K6MhERERGRKsHp0OJDIAL40btDSDHGmMuAH4BwYHL5liYiVVp2Bky5Dg7tJ8DC2JQDfNblCWLaXON0ZSIiIiIiVYajW54CbwODgMuBOcaYZDxbnoJny9PaeLZC/c7bV0Tk3MvPg6l3QFJcYZPrygk0a3+zg0WJiIiIiFQ9js60sNbm49nWdDSQAEQC3bxHJLDbe26ItdbtVJ0iUoVYC/8bDVvmHmvr9RB0GeFYSSIiIiIiVZXTMy3whhHjgfHGmIZAPe+pvdba3c5VJiJV0ZT/jcRv40yuK2iIvhr6PutgRSIiIiIiVZejoYUxphFwyFqbBuANKU4IKowx1YEwa+2uci5RRKqQeYvH8nLSYmytGuzy8+WRoOa4rnkHXE4v/yMiIiIiUjU5/Z34duCVMvQbB2w7x7WISBUWFz+Vxzd9jPVubTonNJyDQ98FvyCHKxMRERERqbqcDi2M9yhrXxGRs27fnuU8sPRZjrg8f82Eui1vXTqB6jVbOFyZiIiIiEjV5nRoUVa1gCNn62LGmNrGmFeNMRuNMUeMMWnGmFXGmBJnfRhjrjLGLDDGZHiP+caYwb9zjxhjzJfGmGTvPdYZY/5qjCn1a26MqW6MecMYs9MYk+N9fd0YU+0MP7KIlOJQxh7u+/4uUnw8gYWPtYzv8CAtm/V3uDIRERERESn3NS2MMZcc11SnhLYCvkBrYCAQV0qfU71/F+B7oKb3mtOBcCAaeBjPbiVF+/8VeA3IA+YCOcAAYKYx5kFr7cQS7tET+BEIAmKBHcAl3utcZIy53lprjxtTC/gFaIHnUZhvgBjgIeByY0zPgrU/ROTsOJqbxahpf2SLz7H/O/694RVc1PkeB6sSEREREZECTizEOR8o+gP7QO9RGuPtP/5Mb2yMqQ3MxhMmXG2t/fa4892Pe98aeBVPUHGZtfYXb3srYAnwmjFmtrV2S5ExfsAU7z0esda+5m0PBeYAw4HvgMnHlfc6nsDia+B6a22ed9ybwIPABGDEGX0BRKSQdbt56atrWEJ2YdtdYRcwrO84B6sSEREREZGinAgt/sux0OJ2YCuwuJS+ucBeYIa1dtVZuPdzeB41uf/4wALAWht7XNNDgA8wsSCw8PbbZIx5AU+Q8BCeUKHANUBT4NeCwMI75pAx5gFgJTCKIqGFMaYucCOez3tfQWDhNRq4AbjFGDPGWpt0yp9aRE7w31l382XuvsL3A3xr8Jc/fupgRSIiIiIicrxyDy2stSMK/tsYczvws7X2znN9X2NMEHALkAV8UMZhBetWTC3h3FQ8ocVVFA8tSh1jrV1ljNkGtDXGNLHW7vCeGoRnfZFF1trE48bkGGNmAHcCV3DiDA0ROUULfxnP+NRY8O4U0sH688Kwb3G5fByuTEREREREinJipkUha215LgTaFQjDE5IcMcZcDvQHAoFNwBfW2r0Fnb2LXzbyvl19/MWstbuNMSlAY2NMuLU2w3uqg/e1tJkhq4BmQHs8a12Udcyd3jEicga2bPkfYzb8B+vy/PVTPx/evOZLAgMjHK5MRERERESO52hoUc6iva9JxphvgKuPO/+iMeYua23B/PCCwCLdWptVyjUT8Dxu0hhYd9y4hJOMwTumwOmMKZUxprRFS5uXZbzI+So9dQsPLhxDlo8nsAh2W/7v0teoUb2Zw5WJiIiIiEhJKsuWp2dDde/rEDyPY9wPRAJN8Cy2GQR8aIzp6O0X6n09fJJrFoQZYUXafm/c2RojIqfgaM4hHplxPQneJ0CMtbwcfbe2NhURERERqcCq0kyLgoDGF3jKWvt2kXOjjTGN8ezsMRq4ubyLO5ustTEltXtnYESXdE7kfGbdbl78+hpWmNzCtr/W6sGlF/7VuaJEREREROR3VaWZFoeK/HdJC3EWtP3huP7BJ7lmiPc1s4T7lDbubI0RkTL6dPb9TM3dX/j+Kr9I7rjiXQcrEhERERGRsqhKocVO7+tha21yCed3eF8jva+7vK/VjTEhJ3YHoMFx1y46rgElO1tjRKQMDm+Yxfv75he+b2/9eGbYNIyrKv31JyIiIiJSOVWl79oLdgAJMsYElHC+hvf1EIC19gDHwoROx3c2xjTEswjnziI7hwD86n3tXEodBe1rz3CMiPye5E0ETxvJx3sTaZOTS1S+5Y0rPyUgINzpykREREREpAyqTGhhrd2FJxwwHHsEpKiCtqLbm87yvl5bQv+CthnHtZc6xhjTCc92p+uttTuKnJoNuIHexpjI48YEAFcB+cB3JdQhIiU5nAafXg85GdTNz+fDlEze+8N4atVq7XRlIiIiIiJSRo6GFsaYtcaYN4wxQ40xNcvhluO8r68aY+oWqaMjMMr79l9F+r+BJywYaYzpUaR/S+ApIM/bp6hpwHaggzHm4SJjQoC3vG/HFx1grd0HfAr4A28bY4oukDoOqA18bK1NKvMnFanK8o/ClyMgbVthU/A179C0+UDnahIRERERkVPm9O4h0UBb4AEAY0w8MB9YAMy31qaczZtZaz8xxgwAbgfijTFL8Gx1ehEQALxnrf2ySP+NxpjRwARgkTHmByAXGOAd9xdr7Zbj7nHUGHMLMBeYYIy5Hs9aFL2BusBU4MMSyvsr0AMYBmwwxqwAYvB8fTYDj5ydr4JIFTD7Cdi+4Nj7Pn+DC65yrh4RERERETktTj8eUgMYArwGrAEuAO4HPgcSjTHrjTFvGWOGH//YxBm4A/gzsBW4FOgOrAJGWGv/fHxna+1r3hp/wRM89AVWAFdZa/+vpBtYa5cA3YCvgBbe8Wl4gofrrbW2hDEp3lr+D8+Mi2uACOBNoLu1Nu20P7FIFTJz7qOsXVskF2w7DHo/6lxBIiIiIiJy2kwJPz87xhgTjmdtiUu9rx3xrEEBYK21Ts8MqdSMMXHR0dHRcXFxTpcick6sXPMBd68Zj8vCcympXBnRGu74H/gFOV2aiIiIiEiVFBMTQ3x8fLy1NuZ0xjs906IYa22GtXYGnvUiHgPeBnLwBBfmZGNFpGrbv381j6waT54x5LoM42vWJGvYvxVYiIiIiIhUYhVi5oIxJhDPuhKXeo9ueB6RMHjWg5jvPURETpCbncEj/7uTNB9PtulnLa9f+HdCarZwuDIRERERETkTjoYWxpjnORZSBHibdwKf4Q0qrLU7HSlORCoF63bzwtdDWefKK2x7qsHldIi53sGqRERERETkbHB6psXfAAvE4VmMc55CChE5FV/+8Fe+PppY+H54YAOG9XvFwYpERERERORscTq0OABUw7Ot52t4thX9Cc8si9Ul7bIhIlJgzdqPeGnfPDCex0I6WD8e/+OXvzNKREREREQqC6dDi5pAB46tZdEbGIxn9kWGMWYRx9azUIghIoWS9q/l4RUvk+ddx6KW2zJh8Ef4B4Q6XJmIiIiIiJwtjoYW3hBijfd43Rhj8GxzeimeLU8LQgzwzMqoWc4likgFdDTnEI/873ZSvIGFr7VM6PokkZGntYuSiIiIiIhUUE7PtCjGG2KsNsakAqnAQWA4EIjnMRIRqeqs5aWvh/JrkYU3n6jfn07tbnKwKBERERERORcqRGhhjGnEsUdELgUaF5wCcoHFaMtTEQGm/vAIX+buK3w/NKAuw/tNcLAiERERERE5V5ze8vQ/nBhS5AA/AwvwBBVLrLXZTtQnIhXLr+s+4cW9PxQuvNnO7ceT10zFeN+LiIiIiMj5xemZFiPwhBQFC24uAH5RSCEix0tJiuOR5S9y1LuORQ23ZcIVkwkICHe4MhEREREROVecDi0uA5Zaa3McrkNEKrCjOVmMmnUrSUUX3uwyhjpR7R2uTEREREREziWndw9Z4OT9RaRymP5IP/4UewQ/79qbwcaPAL+32WQmEdyjB3WeehLf2rWdLVJERERERM46p2daFDLG9MSzxWl9b9MeYJG19hfnqhIRx635lEbu3fjmhBGUW9B4lHwOApA5ezZH1q6l0XvvEtC8uWNlioiIiIjI2ed4aGGMaQV8BHQtaPK+Wu/5FcAt1trNDpQnIk5KjMPOfJjuUUfYPSiH1Nm1CMg9sVve3r1su/5GGr01kZALu5d/nSIiIiIick44vXtIXTyLb0YBe4EvgR14AosmwHCgGzDfGNPVWruv5CuJyHknOwP357fiyjsCQLCPP4/1vI1kqhd26ZCyhTvivsOFhUOZ7LjzLuq98E+q//Fqp6oWEREREZGzyOmZFn/DE1i8BjxhrS32O1RjzGPAS8AjwJPAg+VeoYiUP2ux0+/HlbYVALc1PGLuZ3fzC4kMC6R6sD81Qvw4cLgrL4TUYsyKKQS483Dl57H/8cdJ37aTpg8/qK1QRUREREQqOadDiyuAjdbaUSWdtNYeNcaMBgYDV6LQQqRKOLr4//D77dvC9/+Xfw3V21/Ogus64nIVDyK+79KAF9+tycM/vUO13CwAct6dxLKlK+j02lgC6tcr19pFREREROTscTl8/7rAqpN1sNZab5+65VKRiDhq7ZdjWfjE2/x2JBCAhfntWNPsz7wyvMMJgQXAwJg6vP3CbUy7+zkSQo/tIBKxdjnxgwYT/6/JWLe73OoXEREREZGzx+nQIgNoWIZ+Db19ReQ8lrJlBVkvf0i9ZEP2dzWYlRzFf6Ke5K1buuHnU/pfV7VCA3j5wSs4/Nq/WF23TWF74NFszOsvs+iq6ziweVt5fAQRERERETmLnA4tfgF6GWMGl9bBGHMF0AtYUm5ViUi5y8s5wor7bqfaIc9733z4Oaw/r9/Zj2D/33+SzRjD1b2j6Tv9E368eiSZfkGF52pvjWPZbX9m5q97cLvtufoIIiIiIiJyljkdWowF3MA0Y8xHxpjLjTEXeI9BxpgPgWnePmMdrVREzqnv/jKQxruOPcaxoGcUDz0xnmrB/qd0najwIB54+SFy/v0Jq5p0LGx/M+ZqHvh0DVe/tZhFm5PxPHkmIiIiIiIVmXH6G3djzC3AO0AQnq1Oi50GjgD3WGs/Lu/azjfGmLjo6OjouLg4p0sRKWbxvx6hxuv/K3wf18KX9u8tolXdamd03eyj+Xw94b9sWLqa/7YeWOzcRc1rMmZQGzo2PLN7iIiIiIhI6WJiYoiPj4+31sacznindw/BWvuxMWY+8CfgYqBgqf+9wCLgfWvtbofKE5FzLGHlLAL+dSywSKwOgY/9+4wDC4BAPx9ueuwOtiYPJ2n2RmbH7S88t2RrKn+c+DMvJsyh7R8H0O7awdoiVURERESkgnE8tACw1iYAzzhdh4iUr9zMNDY8Mpr62Z73OX4Qd/MI7u994Vm9T/Paofzr1i6s2X2Al/+3gV+2pQJw4f54Oq38AVb+wII33yTo9jvodvu1uPz8zur9RURERETk9Di9poWIVGHf3TOA+onHngr7uU9LRt435pzdr2PDanzypwv56K7utK8Xxh3x3xWei0reTfirz7OkV18Wjn+X3KzD56wOEREREREpG4UWIuKIOS/eRutVWYXvV7UL5OYXp+LjOrePaBhj6N2yNtMf7E3Qk08T37RjsfM1M5Kp/d5r/HpRb2Y/9DeSt+w8p/WIiIiIiEjpyjW0MMbkn8GRV561isi5s2Xh59T+dHnh+91REPPCV1QPObWdQs6EMYY/XNOHod99Qubb/2V9dE/yORaYhOYcpvH3X5F45eV8N/R21s+apx1HRERERETKWXmvabGbE3cIEZEqJPtgMrueepa6Rz3vswIg48EnGNCqmSP1GGPo3qcb3ft0I25FPOtfn0SL1QsJzM8FwAdL0/hYGBXLgn/W5eigq+j2p5uoVi/KkXpFRERERKoSx7c8lfKjLU+lIvjmpm60XnWo8P2CoZ0Z+eIUBys60b49yfwycTI1fviWqEMpJ5w/anzYHd2NujdfT8er++Py8XGgShERERGRiu9Mtzwt78dDnjbGDCnPe4pIxTH3lbuLBRYrOwQx4rn/OlhRyerWr83Ql0bTc/E89oz+J5saFf/71c/m0yxuKUFPPswvF17Ch/+ewe40LdwpIiIiInK2lfdCnM8Cfyx4412r4v1yrkFEHLBt2XSqf7S48H1CJHR9eRqBfhV3lkJAgB/97hrG1XOmwpSvie8zlLSg8GJ9wrMOMD7uCL3H/cTwfy1hyrKdHDx81KGKRURERETOL+W9pkU+UHSlPeM9ROQ8lp+dxdbHnqCBZ5kIjvhDxv2jaNOksbOFnYILulzABV1e4MiRp1ny6QwOffUVzbf+yoqoNmQEhACwfEc6y3ek8+y3cVzcohbXHd1B90EXU7NRPYerFxERERGpnMo7tNgHdDPGBFlrj5TzvUXEITu/epKw1pkcSQslKBdWDozhT9ff7XRZpyUoKIC+d14Ld17Lzs27YMU2mu+FrcnHtm89mm9Zvm4nD//vefZPcLOiQSvMpX3pcNPVRDVr5FzxIiIiIiKVTLkuxGmMeRN4ADgMJAFNgEPAiSvdnchaa5ufu+rOf1qIU5yQtOIbImfeDsCew/7MS27K8Hd/qdCPhZwqay3r92Tw9eoEZvy6l5RDufTdtYJHV312Qt9d9VrCHy6j/U3XULdlk/IvVkRERESkHJ3pQpzlPdPice/r1UBjPNufhnoPETnP5KTtInDWA4Xvs4Ki6P3irPMqsADPtqntGkTQrkEET11xAct3pLPhg22kbKxOraz0Yn0b7d0Mn27mwKfvsq5OM/IvuoSWVw+kefcOGKOn5UREREREinJ0y1NjjBuYbK2907EiqhDNtJBylZ/HzgmX0ThrLQCHbQCx/ady6cWXOFxY+cnLd/Pr3F/YNW0GNVb8TOSh1FL7pobUIL19N2r360OHIX0IClOWKyIiIiKVX2WbaXG8BcAGh2sQkXPgt88e5wJvYAEwu9EohlahwALA18dFl4G96DKwF/n5btbOj2Xn1zOoFruIqMzkYn1rZqVR85fv4Zfv2fiiH3uaROPXqzcxQy+nfptmDn0CERERERFnOTrTQsqXZlpIefnpX6NxT5lBvYvSuSAom3n+l3HRo1MJ9Hc6J60Y3G43639exbavZhK0aimNkneW2jfX5cvf73yN3u0a0LtlbTo1qkaA7/n1eI2IiIiInL8q+0wLETnPJMQtJvjdmYQfNmR/V4Ppl0DHp95RYFGEy+Wi/SVdaX9JVwAStu5m3dezyf15EQ22riU4L6ew77pazVibksPan7by1k9bCfLzoVvTGlzcoia9fA7Spnt7fPz0tRURERGR85O+0xWRsyY/N5u1D/+Zpoc9711uyO96B43rRTlbWAXXoHlDGoz+E4z+E0cOZ7N61nyS5swjYm0ssVHRxfoeOZrPwk3JrFu7ld6zn2elfzCJzWMIuLAHra/oS6N2rbSgp4iIiIicNxRaiMhZM/2vV3DBLnfh+1V9GnPHHWMcrKjyCQoO5KLhg2D4IKy1NNifQbvNqSzcnEzs9jRy8jxf3w7JWwAIyz1M2G/L4bflHJ78f/wcWoP0Vu0J6daVlv170zCmpUIMEREREam0FFqIyFmx9ItXaTl/X+H731r4cP0r3zpYUeVnjKFl3Qha1o3gT5c0I/toPqt2pbNkSyq+ny4m37jwse5iY2odSqPWqvmwaj5Z77zKkuBqpDWPJqBLF5r1uZhmXdvicrmc+UAiIiIiIqdIC3FWIVqIU86VjKQdrBlyObUPeN6nhUH4+/+lXftujtZ1vktPTmfdd/NJW/gzYfFrqJe+93fHZASEkNzkAnw7dabRpb1odVEnfP39yqFaEREREamKznQhToUWVYhCCzlXpv0/e/cdZ0dV/3/89blb7vaebHpvpNCrdELvJSBKERQV8auASFERKWIJiODXgj9FQEXpECB8QSJSpIUWICSQ3ttme7tbz++Pmb252dzd7Kbs3N19Px+PeczMmXPufOZOdnPvZ8+cM2MfJs2PANAKfPKtUzn/yjuCDaofWrd0NZ/Ofpnaue+Su/hTBlVu2G6bSHIq9198K6P2nsQ+I/PZd3g+uRlKYoiIiIjIrqHZQ0QkULNvvySasAD48MBcLvjuzAAj6r+GjB3OkO9+BfgKABuWr2XhS69T+c5cMj+bz5DSNYRol6h2jtmbjZaXl0SLxg7IZN8R+RxRt4rx44YyXjOUiIiIiEhAesWnUDPbG8hxzr0WdCwissXiuc8z6NF3ovurBhkn3v28Bn5MEINGD2XQN86Hb5wPQNnGzXz64n8pfesd0hZ8zNBNK1icN5yWUNJW7ZaW1LK0pJbj59yBqylhXnKYjUPG0jJhErn77MW4ww9k8PiRus8iIiIistv1iqQF8AfgAHpPvCJ9XlOkjqU/+D4jG7z9+lRI+f4PKSooCDYw6VBBcRGHX3wmXHwmADWV1dQuWMW1kTAfrirng1UVlNU2ApDdWMuwmhIAMpobGL1qAaxaAHOepPIOWJmWTemwsTBxMoX778OEww+gcJimthURERGRXas3JQH0Jz2RBDLrypOZsnbLowbzT9yDi0+9MMCIpLuycrM5+JApHOzvO+dYWVrHB6vKWfrux6yZO5zBpWu3maEEIC9STd6SebBkHsz+B5uAT7MKqRgxjqRJe1C0956M+8I+FA4b1INXJCIiIiJ9TW9KWohIgvjvQz9j0msbo/sLJqbwpdsfDTAi2RXMjFFFmYwqyoR9h8E3T6a6vIqFr7zDprkf0LpwAfmrl1BUWxa3/YCaUgYsKIUF78CTsAn4LCOPTw4+kbqzvsTkwTlMGZLDsPx0PVoiIiIiIl3So0kLM1u2g02H7NJARGSHla1djPvN30jyO1lszoWpv/w7KRqosU/Kzs/hwLOOg7OOi5ZtXLmexa/Ppez9j7BFCxiwdhm5keq47QvqKli8sZon/r04WpaTlszkITnsn9HEPpuXMOSAvRi731RS08K7/XpEREREpHfp6W8ZowDHjj3qoblZRRLAq9+ZwaRKb7vVoOTiszl80p7BBiU9qnjkYIpHngEXngFAa2srqz9bzvL/vkflvI9IWraYovUryG2oAWBZ7tCt2ldFmnl7WRlZq97llA8egXvhs1ASGwuHUj9iLKkTJlK452TGHDBNj5eIiIiI9HM9nbTYDBQCk4HyLrYx4Dlgn90VlIh0zTO3fJlJCxqj+x8eXMCF3749wIgkEYRCIUZOHsvIyWOBLwJeImP9sjUse/MDji0YzcDyJhasr2J1WX203diKddHtlNYWhpWsgpJV8P5/4J/e4yWL07IpGzic5pGjSZ8wgYF+MiO7ILeHr1JEREREgtDTSYu5wEnAMOfcZ11tZGZNuy8kEemKyrWLyVv3FvWpaaQ3woohxmn3zA46LElQoVCIoeNGMHTcCA6PKa+sb2LBuioWrK8iufZ91lYOo7hsHclxBvsEyI1Uk9s2c8nr3r+3NcDmrEIqBw2nddRYsiZNYMiJxzFmVDGpyaHdf3EiIiIi0mOCSFqcjDd96ZwePreI7CDX0sTmv17MEYPLWHdiKh/PKyT7+7eSm5MXdGjSy+Smp3DI2EIOGVsIh90EQH1tPUvmfsz69z+mfsECUlatoKhkNdkNtR2+TlFNKUVLSr3ZS+bAVz6H0uwixgzIZPzAbMYOzGLsgEzGJUUYPbKYjJysHrpCEREREdmVejpp8QrwEdDdfr1/Bl7Y5dGISJd88o8b2bNhAQBDMhr57LLvcNjx5wYclfQV6ZnpTDv6IKYdfVC0rLW1lU0r1rHi/U8onb+QpiVLSF+zggGb15Le0rhV+/qkVDZl5ONaHYs21rBoY0302K1v/gk2LaIsq4CqAUNoHj6S9LFjKZw8gZH7TKFoWHGPXaeIiIiIdF+PJi2cc6+xA2NTOOfu2w3hiEgXrPnkVaYs+WN0+NzXM47lqBlXBBuU9HmhUIhBY4YxaMwwOPekaHlLcwurFy5j1fufULngM1qXLaUq0kxSUhLNrduO1zy8ZhMhnNczo6YUln8Cr3nHSoBl4UzKCofQOGQ4yaPHkDtpPEOnTmTYHmNITk3poasVERERkY5ojkIR6VBTfTWhpy4nybwvg6spZtLX/kgotCMTAInsvKTkJEZNG8+oaeO3Kv9icyvLN9fy+cZqlmyqYWlJDSvWl5PfUNPBK3myG2rJXrcY1i2G914GoB5YYEmU5hRRO2AIrUOHkTJxIrlnnMHookwG5aRhpp8BERERkZ6gpIWIdOjJ753APjmlkA4tzlh/zK85sLAo6LBEtpGaHGLioGwmDsreqrz5ux+weuFS1n60kMrPF9O8fDnhdaspLF1HVmNdh6+X4loYVLkRKjfCkg/57ON5fGuTN/1qekoSIwszGDMgk1GFmey96B2Kxo5k+LSJFA4rJhTSYKAiIiIiu4qSFiIS1/N3f4c9/1NObUohzx8UIXWvEzn2yFOCDkukW5JTkhm950RG7zlxq/LW1lY2r9nIyg8XULrgcxqWLSNp9UpyS9ZRUFtOiK0fNVmXOSC6Xd/UwmcbqvlsQzXpTRGenP0LwJvTe2VKGuV5A4kUDcINGUraiBHkjR1F8aSxDJ0wSo+ciIiIiHSTkhYiso21i96j4G/eBD9pTZD6eRr7zLw14KhEdp1QKMTAEYMZOGIwnDF9q2N1NXWs+mQRGxcsonrJclpWraSicAxFWWE21zRsVXdIbelW+5lNETJLVkHJKlgY85rAQgtRllVIbeFAmoqHkDxsGFmjRzFgwhiGTRlHTmHebrpaERERkd5LSQsR2UprSwvvXXMpE/zZJhuTwH33fygsGNB5Q5E+IiMrg0mH7M2kQ/aOlp0B/AiojjSxYnMdy0trWV5SS+1H9axaOIaCsvVkNdV3+rrJrpWB1SVQXQIrPoV3thxbC9w38UheO+EiRhRkMLIgg+EFGYwoyGBEfjoDs8MkJSftjssVERERSWhKWojIVmbd/GUmLW6O7n9y5FAuPPfbAUYkkjiy01KYNiyXacP8mbuPHQ/XzKC1tZWydSWs/uRzypasoG7FSlrXriG8aT055ZvIr6/c7muvS8rkw1UVfLiqYqvyyaXL+cUb91KeVUBt3gCaBhSTNHgwacOHkT96JAMnjGLwmOF69ERERET6JCUtRCTqs7eeZcSsj6P7y4Yb59z1XIARifQOoVCIomHFFA0rBo7Y5nhtVS1rFy5h0+fLqFq2gqbVawhtWEdm6QYKqjYTbm1mfWZh3NceXFtKSmsLA6tKoKoEVi3Y6ngN8JmFKM/MpyaviMaiYmzQYNKHDyN31HAGjh/N4PEjCKen7YYrFxEREdm9Ak1amNmeQKtzbn6QcYgINDc1sPzH1zOq0duvC8OAH/6M9DR90RHZWZk5mUw4aC8mHLTXNsdamlvYuGIt32kwzqiH1WV1rCyrY1VZHatK6xjUbtyMeJJcK0U1pRTVlMKaz7c6Vg8swajIyOWFoy+g6oBDGZafztC8DAbnpTEkN51B2SnkZIQ1lauIiIgknKB7WswDXgGOCTYMEXnqe6cydc2WGRMWnjyVC48+M7iARPqJpOQkhowbwRDgoDjHq8oPYt3Cr7J5yXJqVq2hcc1a2LiBtNKN5FSVkhup3u45QjgK6ipYWBbhvXnrtjl+xtLX+crCF6jMyqcur4jmwgGEigeRNnQwOcOHUThmOIPGjSArL2fnL1hERESkG4JOWpQB6wOOQaTfe+eZPzLx5TXR/YUTkjn/1n8GGJGItMnJzyHnC3vDF/aOe7y2soZ1i1ZQsmQ51StXE1mzDtuwntTSTeRUlJBbXxWdwnVjRkHc1xhQX0F6cwPpFRugYgOs2Pp4E7AaqEnNoDK7gEheIS1FA0nyExu5I4ZRNGYEg8ePIC0jfVdduoiIiEjgSYu3gWkBxyDSr9VVbqbmjrvJafH2KzJh8s/vIzkl6F8PItIVmblZjD9gKuMPmBr3eKSunnWLVlKyZAXfGTKONTUtrCmvZ21FPesrI2yojFBUX9Glc2U11pFVWgela2Bpu/MAy4EfnnQtkVHjGZQTpjgnLboMrdlIYZJj4OhhFA4t1mwoIiIi0iVBfyu5BfivmV3jnPtVwLGI9Euzv3sqU0u27K8+/xgOmXJgcAGJyC6VlpHOmL0nMWbvSXEfP2ltdZSs3ZeNi5dTvmINtWvW0rR+A2zaSLishKyqUvLqKklyrV063wqXTvn6Kha260d59QcPc/yq9ygFNlgSVRk51Gbn05hXSGthEUkDi0kfXEz2sMEUjBxK8ejhZBfk7vT1i4iISO8WdNJiD+DvwEwzuxCYDazC+4PNNpxzf+3B2ET6vH/fdxOT39kyFeNHe2Vw/rW/CzAiEelpoZBRPLyY4uHFHdZpbmpm44q1bFq2isoVa6hbs46mDRsIlWwktXwz2VWl5NZX48yoDGfFfY3CSFV0O8W1UFhbTmFtOWxYtk3dJmANUJccpiozj/rcAprzi6CoiJTiYkKnnM6AAXkMyAozIDtMWop6bYiIiPRVQSctHgAcYMBe/uLi1DO/fKeSFmb2CnBkJ1VOcs69EKfdJcAVwGSgEe+xlp86597s5FyHAj8CDgZSgQXAbztLvJjZMOA24ASgAC+B80/g5865uIkckR1VsmYR4T8+Rsjf35gPR971RKAxiUhiSk5JZuj4kQwdP7LDOg31ETasWMdjGXlsrGpgQ2WEjVXesqEqQur7YeqTU0lvbuzyeTOaG8io3AiVG73/EX2nV4+kKSklup+TlsyA7DBf/Og5BtWVQX4hSQOKCA8cSNbggeQOH0zR8MEUDB6ox1JERER6maCTFrcSP0mxuz2BN7V9e2vbF5jZ3cCVeLPG/QtIA44DjjezGc65p+O0OQd4BAgBrwGbgenAg2a2p3Pu+3HajAPeAoqA+cDrwP7ATcB0M5vunGvo9pWKdOC1q7/IZP8Pny0GNd+4kMFDRwUak4j0XuH0NEbuMYYO0xrfOITW1laqyiopWbaa0lXrqFmznsj6DbSUbCJUupnUijKyqsvIra/q8HGUytSMrRIWAFWRZqoizQz6fB7jK7f5rxzw/iPeYCGq0nOoy8ylISePlvxCrLCQ1AEDSB80kJwhg8gfNpiBo4aQkRO/x4iIiIj0rECTFs65mwM69fedcyu2V8nMjsVLWJQChzjnFvvlh+BN1Xq/mb3inKuIaVMA/AVIAs5xzj3plxcD/wWuMbPnnHOvtDvdA3gJi98456702yQDjwJnAT8Abt6hqxVp5/m7v8vkT7Z03vn44AK+fOmPAoxIRPqDUChEXlE+eUX5jD9wzw7rNTc1s3nNBkpWrKVi1Tpq162nccNG3OYSalqMicXZbKqOUF7XtFW7/IbOp39Ndq0U1FVQUFcBJSvj1qkHFiSncek5v2BAtvf4SVF2mKLMVAqzwoxdOJes9FRyBg8kd0gxhcOKyS7IJRQKxX09ERER2TlB97RIdN/z1z9tS1gAOOfeMrN7ge8CXwNiBxG9DMgBZrUlLPw2G83sOuBJ4Bq8pAcAZnYgcCiwCbgupk2zmX0LOBX4rpn91DnXvGsvUfqbmtINZD38UnR/TTGcdvfsACMSEdlackoyg0YPY9DoYXGPX+CvG5tbKa1toKS6gU1VDdQVXcaSDRtp3VyClZeRWlVORnUFOXWVhFu7/t9neVo21Q3NVDc0s2xz7VbHHnzxtwz0Z1tpANYBjaFkqtOzqcvMoTErj5bcPMjPJ6WgkPDAIjKKB5AzeCAFQ4spHFpMalq42++JiIhIf5UwSQsz2ws4EK+3wafOuWf88jAQds5VddZ+N8STDhzj7z4ep8rjeEmL09g6aXFKJ21m4w0yeqyZpcWMU9HW5tn2j4D4yY7X/VgOIybZIbIjljx0FaOP2MyidwsZsMkIffd/yM7NCzosEZFuS00OMTg3ncG56V7B5K/Hrdf2WMrmlWspX7OB6nUbiWzYRHNJCa6slOSKMsLVFWTVVpIdqaE8nB3/hM6R17Dt06Wprc1bBhbdFL8HB0CFv1SnZrB64CgeOff7FGWlUpgZpigrTGFWKkVZqQxYu4zcojwKhw8ityhfvThERKRfCzxpYWYTgfthq5nYHgSe8be/DPzZzE6JN0jmDvqamRUCrcAi4Gnn3Kp2dSYCYaDEObcmzmt84K/b92/dq93xKOdco5nNxxurYgLw8fbaxJQf45/rlQ7qiGzX568+wt5l/wcZMOTw9cxKPY2zz/l20GGJiOxWsY+lsN/UTus2RhooKK3iOVLZVB2hpLqBzTWNlNY0Ul5RzdoPJxCuqSCzrpqsSA1JOzA0V3ZjHa6ujrnLy7Y96BxPPfdDmlqa2ACsDiVRE86iLiObxswcmrNzcDm5hPILSCnIJ1xUQOaAIrKLi8gbPICCIQMJp6d1OyYREZFEFWjSwsyG4w1UOQAvSfE6cEe7ao8CvwfOAXZV0uLGdvt3mtltzrnbYspG+Ot4CQucc7VmVgHkm1m2c67azHKA3M7a+eX7AyPZkrTo9Fwx5R0P2x7DzD7t4NDYrrSXvqm2fBNF/4k+fcSilAmcct19AUYkIpJ4UtPCDB46gMHAlv/SY1y0ZZal5qZmyjeUULZ2I5XrNlKzoYSGks00lZZBWSlWWUFqdQXptVVk1VeT3rylM2VFB1PDprU0ktayZayOlNYW8usrya+v9EbY6kSFv9SlpFGblsWyEZN57bTLyM9IpTArlfyMVAoyUyjISKVo5edkFxdROHQQOUV5mlVFREQSVtA9LW7CexzkMufcXwDMbKukhZ8cmMfWPTF21GvAn4E3gfXAcGAGXhLjVjOrcs7d49dt+zRR18nr1QJ5QDZQHdOms3ZtD8fG9j3d3rnitRHpliUPXs5eVAAQcSmEzvoj4VQ9Vy0isqOSU5IZMHwwA4YP7lL92soaNq/ZQMW6jYxvCfHLwqHRXhyltQ2U1jTStGEDFWnZZO9gLw6AjKYIGU0RFpeV8fJnm7Y5ntbcwFPP/YgmYAOw1kLUhDOpS8+mITOb5qwcWnPzsLw8kvPzCRfkk1ZQQOaAArIHFpI/qIjcAQVKdIiISI8IOmlxIvBxW8KiEyuA43f2ZM65m9oVLQJ+ZmbvAS8CN5vZ/3PO1e/suYLknJsSr9zvgTG5h8ORBPDJi/exV8W/o/tvj/42R03dN8CIRET6n8zcLDJzxzFyyrjOK954Bi3NLZRv2EzpmvVUbdxM3aZSIqWlNG0uo6WiAqusIKm6ktTaKtLrqsmM1JLW0rjVy1SmZsZ9+ZyGrQcXTXKt5EaqyY1UQ3nnoTUCG4H1GLWp6bw/7gBenH4R+Rkp5GWkkpeRQl56KgUprQz99F3SC/PJHFBI7sBCcgcVkaOZVkREpJuCTloMBN7oQr0UIGN3BeGc+5efuNgfr0fHK0DbSFudnbft00DbHGuxo3NlAPEGD23fJrZdR+eK10akS1YueIvyn9zJC3vmc9zgchamTOYLX27/hJSIiCSSpOQkioYVUzSsuMttaitrKFu/icr1JVRv3Mwe4SxuGjCCstpGyuoaKa9tpLS2kbTVlVSmZZPVUEuSa92h+EI4shvrqK+NMG91xTbHB9WWcv9LP4/u1/nLagtRG86kLi2TxvQsmrKyac3KgZxcknJzSc7PI60gn/SiArIGesmOvMEDyMzOxMx2KFYREendgk5alLJlPIfOTMB7nGN3WoyXtGjr49k2MGfc+dbMLBPv0ZBy51w1gHOuyswq8R6CHQYsiNO07fVihxdfBezT0bk6aCOyXa61lXnXf4MJFcBr6Tw3Pswev/w9qakpQYcmIiK7mNeTI4vhk8Zsp+Yh8NMv09LcQuXmcsrWbqR642aqN20mUlJKY1k5LWVl4PfmSKmtJlxfQ0akloyGuq0eW6nqqDdHY23c8uTYXh0V27+mauCRUQfzx/3PIy89hfyMVHIzUshNT2FQcw37v/08oZwcknNzSc3PJS0/j4zCfLKK8skZUEjewHwNTCoi0ssFnbR4AzjTzPZ2zs2LV8HMjgSmAg/s5ljy/XXb/7Kf403BPsDMhjrn1rar39a3/uN25R8BR/jHt0pamFkK3rVE8B5NiW1zRsxrttfRuUQ6NevWi5i4uDm6Xz16FBMm7xNgRCIikiiSkpMoGFREwaCiLrdpaW6hanMFFRs3U7VpM8eEs9g7u4iKukbK65qorG+ivK6R8NIaVg8cRVp9DemRWrKadvzJ26rUDBqbW9lU3cCm6i2DmU4qW8mXX3s2bptmoMxfIkmp1IUziKRl0JieRXNGFq2ZWZCd4yc8cmCPKYSnTSM33UuI5PjrsMbtEBEJXNBJizuBs4BZZnY58K/Yg2Z2DF6yohm4e3cFYWYDgMP93Q8AnHP1ZvYycBJwbpzzz/DX7f+3nI2XtJgB/L3dsVOBNOA551ykXZubgNPMLOyci/6PbGbFfmzldO1RGhEAls17hWFPb5lFd9lw49w7ZgUYkYiI9HZJyUnkDyokf1Ah3uzwHdkHfvTF6F5TQyOVJeVUbCyhelMZtSWlRMoqaCwro7myEldZiVVXkVRTTWpdNWl1NWQ01JLR3EBNSvynZ7OaOhsrfYu0lkbS6hqhrqLDOv+cMJ2/Tm7Ypnxa1Wp+8NYDRNIyaUzPpDkji5asLMjakvBIyfN6eKQX5JFZkE9WYS45AwrIysvW+B0iIrtAoEkL59w7ZvZd4B7gObzHHR1wjpmdBeT4+1c453aql4GZfQFvDI1nnXMtMeWj8JILmcAzzrnYaUfvwkta3Ghms51zi/02hwDfxOvY2H7OyD8DPwLOMLOznXNP+m0GAjP9Or9q9z7MNbM3gEOBXwJX+W2S8aZ7TQF+45xrQqQLWlta+PSH/8M4PzVWnwpFN9xKOKwusiIi0vNSwqndHqMDoKE+wnW1DVzeEqK8romKukYq/B4drUuSWeROwGqqCdVWk1JXSzhSQ1qkjszGOpK7MV5HTUp63PK0umpvutn6yu0OUgreh9Zqf2nBqE9NJ5KaTkNaBnP3PZ7l+x9FTloK2WnJ5KSnkJOWTEGkisIVn5OWn0tGfi6ZBXlkF+WRU6RHW0REIPieFjjnfm9mHwA3AMcAhje1ZwRvRo/bnXO7oofBBOB+YIN/vgpgJLAfXu+HT4Gvt4ttjpndA1wJzDOzl4BU4Dg/zkudcxXt2pSZ2VeBR4HHzewVvLE7jsUbA+Mu59wrceK7FHgLuNLvYbIAOAAYgzdF68/jtBGJ66mffInJy6K5ORZOH8MF02d00kJERCTxhNPTKE5PI26q44gx8NUT4rZrbW2ltrKGyk2lVJeUUVNaTn1pBQ3lFTRVVNJcVYmrrobqapJqa0gdM4YxAzKpqvcSIk0t3rgdO/NYSxKOrMY6shrroKaUjes389KCjdvUO3j9fH7yzgPR/QZ/2Qw0JKV4iY9wBo3hDJozMmlJz8BlZmNZWYSys0nOySYlN5e0vGzCEyeSPWJ4NCmSmZqkAUxFpNcLPGkB4Jx7G29sCwOKgBCwObZHxC7wDvAHvNlBDsAbw6IWmAc8Bvwh3lSnzrmrzGwe8D94yYpGYA5wm3PuzQ6u5wkzOwK4ETgYL9GxAPitc+7BDtosNrN9gFvxpoI9C2+AztuAn8U+MiLSmc/f/Rejnv0kur90RIjzZuqxEBER6T9CoRDZ+Tlk5+fAxNHbrX9qzLZzjkhTK5X1TVSs35PaxYdRV1pBpC3hUVmJq67Cqr0eHsl1taTW15DWUEd6Y2SbqWfb1KbE7zXRWWIk3NJEuL4J6uNNSLet3+15Fs+NOTS6HzLITkvhkNLPmfHBszSleYkPl56Jy8zEMjMJZWWTnJ1Fak42qTnZpOXmkJ6fQ2ZeLtmFeWQX5pKaFu7S+UVEdoeESFq0cc45oGQ3vfZC4IodbPsA3RwI1O8dclI326zG63EhskNaW1pY/OPvMdZPcdWlwqAbf05KSkL9qIuIiCQsMyM9NYn01CQG5Q6HScO71b6hvoHq0gqqNpdTU1ZBfVkFkYpKThk6loOzCqiKNFNV30R1pJmqSBNDW4pYs2o44UgdaY31ZDTWbzVDS3fUtnvMpdXhPUqzqYShm1d367Xq/WUT0BBK9h5zSU3jhS/MYMXkA8lKSyY7LZnscDJZackMLF1P8YoF2yQ/svJzySpQ8kNEdlyg32TMbCnwJ+AB59yGIGMR6QueuvE8Jq/Y0kHp8xMn8uUjTg8wIhERkf4lnB4m3K3xO/bH69DraW1tpaai2kt6bK6gttzr5RGpqKKpsormqmpaqqugugarqyGprpbk+lpSI3W4/HzSUkJEmrYezyOzOcLOCLc2E45UQ6SatZureWtZ6TZ1Tlr+Ft/96Iltyuv8JTb5EUlNpymcTlNauve4S7ueH/UHHErqmNFkpiaTGU4mK5xMZjiJTNdMRkqIzNwsDXIq0o8E/efXUcDtwK1m9hzw/4AX/R4XItINiz54mVHPb5lld/HoEOfd/niAEYmIiEh3hUIhcgpyySnI9UZk64aj/XVjcyvVkSaqIs1UR5qoWTaMTZ/vR0Oll/hoqanF1VZDbS1WV0uovo6USB0pDfWEG+pJa4qQ0RQ/0VGXEr+3REYXEiNtyY/cSHWn9X66ppU3hlZuU3760v/yrU+ephUjkpxKQ0oaDalpNIXTaA6n05KWgUtPx6VnQGYmSRmZhLIyScnKIiU7i9ScLNJysknPzSZz5AiyC3LJDCeTmqwEiEgiCzppMRL4GvBV4EzgDGCNmd0H/KXdTB4i0oHWlhY+v/G7jIt5LGTYj2aSrMdCRERE+p3U5BCFWWEKs/wEw7A8OGKvbr1GS3MLNRVVVJdVUltWQV15FZHKar46bAwzUjOpaWimOtLsr5sYbKNYWjuV5Eg9qQ110eRHWlMDoW4+7lLXwfgf6c3eB50QjozmBjKaG7yZXXbAtQddyjuDpwCQmhTyenKEkzly5XscsfA1msPptKal05qeARkZhDIyCWVmktSWBMnJJpyTRXpuNum5OWTm5ZCZn01WXg5J+vwlsksFPeXpGuAWM7sVOAFv9o5TgZuBH5vZC3iPjzznXDfmrRLpZ2bddjGTYmYL+fz48Xz5sFMCjEhERER6s6TkJHKL8sktyu9agxl7EfuYS5utkh/lldSVVRKprKahsorGqmrvcZeaGlpra6I9P0ZOGoXLzKO2oZnaBi8xUtvYEk1a7Ap1yVt6jDS2tNJY10p5XRNu3VpGrF/arddqBir9BSCSlEokJcxfpn+ddSMnkZmaTEY4iYzUJDJSkxmzYj7DViwglJFBKDOD5MxMUrIySc3KIDU7i7TsbNJzs8jIySYjL4vMnCxSNB6I9GMJkQb0Hwd5AXjBzAYClwCXAacAJ+NNU/oX4D7n3Iqg4hRJRCvmv8XQWR9E95cND3Huz58MMCIRERERT7eTH0C80bicc0Tqjqa6tILa8ipqK7yeHw1V1TRU19BUXUNLTQ0ttbW01tZCbR1WX0eovo6khnqSG+pJaYgQbvKW+u305tgZaS2NpLU0sraqgQXrtp355aIFb3P0ojmdvkYTWydCGkPJNKSEaUgJ05QSpjk1jeZwGq8ffyH1w0aTEU4m00+KZIaTKFq3nNxNq0nJyiKclUU4J9N7NCYni8y8bDJys0nLTNfYINIrJETSIpZzbhMw08x+BcwErgYGAz8CfmBms4GfOOfmBRelSOKY98NvMtGfLS2SAkU/uEWzhYiIiEifYmakZ6aTnpkOIwbv9Ou92OqobWyO6c3RQm1DMw2f57J26cE0V9fQXOMlQFxdHdTVekmQSD3JkXpSGupJbfQSIGlNEVJaW7Y5R31y/N4R6S3dT4yktjaT2tBMdkPtVuV3L97Ios3bnufST2dz3uL/bFXm2DIwKkAL5iVCksM0poZpSk2jOTWNlnA6rWlpuLR0SM9g9fQzsMFDokmR9FSv10hm6UbSa6sIZ2eSnp1Jek4WGblZpGdlkpSc1O1rFOlIwn2zMbO2cS4uBYb4xW8CLwPnAacBJ5nZF51zTwUTpUhimPXzrzJxUVN0f8HRI7ngmBkBRiQiIiKS+JJCRk5aCjlpKVsfGHcYcFi3Xy9SH6GmzOsBUldRRX1lNTcPG02dpVDX2EJdo/eIS11DM/lZB7CoIBWrrycUqSfUECGpMUJKY4TUxgipTQ2kNTfETYRsc96k1LjlaV3oMZKEI6Nt0NX6juv9JmUiS/O2HTz16588w9lLX9sqGdI2r0xDUgoNyak0tvUMSQnTkppGSzhMazgNF06DtDQsPYNQejqlR59E8oABZKQmkZ6S7K1Tk0ivLCOtOUKG/8hMZk4mqenxe8lI35UQSQszS8YbhPPrwLFACKgC/gDc65yb71e9yczOBf4K3AooaSH9Vk1FCeH/vAkYACuGGjPueDrQmERERET6o7T0NNKGplE0dOD2Kx8/sUuv2VAfobayhtrKaiKV1dRX1RCprqWxuobGmlqaamq5dK8DqU5Oo7axmbqGlug6s3w4KyPjSG6MkNLYQGpThHBzA+nNjd2+tvrkDhIjLR2/VriliXBLE7TrGdKRO+oHszJn2x403/roKU5f/sZWj8o0W8hLiCSHaUwJ05zalhTxEyJ+LxFLS8PS0wmlZ5CUkU7t4ccSLswnPSXJ7y3iJUfS6mtID0FGThbp2RmEktRLJNEEmrQws/F4Y1d8BRiA9+3rA+Be4B/Oubr2bZxzj5nZecR/3E2k31j84P9w7EHr+c+AQgo+CZPzvRsIh5V5FhEREekLwulphNPTKBhU1P3GF+0Xt7iluYW66lqvR0hlDfVV1USqamiorqGx2kuENNfW0lJXR2ttHa6+jukHTaA8KS3aY6S+sYW6xhZS0tOpCmeS2tzUaQKjKzrsMRLndZNdK8lNETK300Okvcs25rA2e9uk0nfmPc7JK97eKpbG5FQaU1JpTk6l2U+MtKSGceE0XGoYl5aGhdP8xEialxhJTydy2FGE83JJS/EfpUlJIj01RLiuhrQQpOdk6vGZHRB0T4vP8R6vqgfux+tV8V4X2lUCKdutJdJHffba4+xT/gIkwXHjS3np8K9z3CkXBx2WiIiIiCSwpOQksvNzyM7P6XKbMzo68L0jo5ttyZC6qloi1TXU++vGmloaa+porKujubaO5ro6WuvqaK2rx9XXQySCReo5cNpIKqKJkRbqG5u9xEjIaLYQybtgIsmGjnqMtOt90jaQKjswJuslazPYmFm4TfnVHzzC8ave3RJLKJnG5FSaklNpSvETIylhWqPJkfCWR2jCbT1G0khKT6fuiOMI5+aQnhoiLSWJ9JQkBuakMTQvvfsB9xJBJy0W4PWq+KtzbtuhdTvgnLsMr4eGSL9TX1VOwX+ui+5/ljSBI7/68wAjEhEREZH+bEeSIbE67kJ/LM45GiMN1FXWUlddE31MpqG6loaaWppqa2mqqaO5rp6Wulpa6yO01tdDZEtSJNQQYfLYwVSEUv2kiN9rpKmF8E72EokV6SAxEm5p2nq/tZlwYzM0bvNgwXZdtCmfzel5W5Wdt/8wZs7Yq9uv1VsEmrRwzk0N8vwivdHCv17Jvs4b5qjRJWFn/o7UVHU8EhEREZG+x8yij8rkD9q2F0NXndpBeUvz8V4vkcoa6qtrqa/2kiJNtXU01tbRVFdPc20dLfX1tNTXe0mRSCSaFKGhgVBDhFBjA3uMLqbKJRNpaqHeX+oad3FiJM6jNOkpfftxk6B7WohIN8z9v/s4YPOs6P7bwy/jiGkHBhiRiIiIiEjvtbO9RGKd0kF5c/PxXkKkppb6qjoaamqJ1NZ5j87U1tFUW0dTnd9bpL6e1vp6XCSCq4/gGiJYQwPmJ0amjSmmxoW8pEhjC5GmFnLS+/YfMBMiaWFmGcDRwHggm7bpELbmnHO39WhgIgmkdP1yGm6+k2cHDuKAPTdTEx7OgRfeGnRYIiIiIiLSieRdmBjpqMdIXxZ40sLMLgF+DcTeQcMboLP9vpIW0m+9fM15TK2EosoQK9cNJPnu2xifptlCRERERESk7woFeXIzOxa4Dy8h8TPgLf/QN4E7gCV4CYvfAl8NIkaRRDDnvp8w+YOa6P7yaXnsf/hpAUYkIiIiIiKy+wWatACuwUtYHO2c+zGwGMA59yfn3A3AFOBuvITF+0EFKRKkmvKNpNz3aPSHdUMBnPCrpwKNSUREREREpCcEnbQ4AHjbOfdRvIPOuWbg+8Am4JaeDEwkUTz/vbMYWOZttwL1XzufgsJBgcYkIiIiIiLSE4JOWmQBq2L2GwDMLLutwDnXCrwDHN6zoYkE742nfs8e75RH9z/ZN4uTv/aTACMSERERERHpOUEnLTYABTH76/31hHb1CoD0HolIJEE01tdRd/dvSW719jfnwhEzHw42KBERERERkR4UdNLiM7xpTtu8iTfw5nVmZgBm9gXgGODzng9PJDhPX3cmwzZumURn03nTGTJsbIARiYiIiIiI9KygkxazgdFmdqC//2/gY2AGsNbM3gf+gxfn3YFEKBKAT157igmvrI7uf7pHKudc89sAIxIREREREel5QSct/gqcBGyE6PgVpwAvAQOBfYA64Ebn3N+DClKkJ7U0N7Py9hsJN3n71emw5233BhuUiIiIiIhIAJKDPLlzrhJ4sV3ZWuBEM8sAcoFNzrmWIOITCcLTN3+ZyStbo/vLT9mTL049JMCIREREREREghF0T4sOOefqnHPrnXMtZvZVM7sp6JhEdrcVn7zFiOc+ie4vHh1ixs0PBRiRiIiIiIhIcBI2adHO1wHN8yh93oc/vpysiLcdSYGhP/gZScmBdogSEREREREJTG9JWoj0ec/deQWTPmuM7i88agT7HXFGgBGJiIiIiIgES0kLkQRQsmYJ+Y/8J7q/arBx9i+fDDAiERERERGR4ClpIZIA/nv3t8ir9rabQxD+zndIy8gMNigREREREZGAKWkhErClH7zMGZnvknRSOZsKHZ8cXMBRZ38r6LBEREREREQCpxH+RALU1FBPynPfJWSOSbn1JE8vYO+rZwUdloiIiIiISEJQTwuRAM37508Y0boagFZn1J/0a3LziwKOSkREREREJDH0aE8LM2vpyfOJJLK1iz5kr+V/BvP23yo8k0MPOSHYoERERERERBJIT/e0sJ1YRPqM5qYGNj78LVL9PN4GCpl60V0BRyUiIiIiIpJYejRp4ZwL7cSS1JOxiuxOT/3wPOqeq+TV0hwcsPqQn5KbXxB0WCIiIiIiIglFY1qI9LCl815n9L8WUVgFA1/K4p9rxrP/8V8KOiwREREREZGEo6SFSA/7+CffJrPB265Lhalf/xlmegJKRERERESkPSUtRHrQ7LuvZNLnTdH9z48exZ4HHR9gRCIiIiIiIolLSQuRHlJesoacf/4rur9qkHH2L54IMCIREREREZHEpqSFSA956fszKKr0tptDkHzF5aSlZwQblIiIiIiISAJT0kKkB7zx1B/Y493K6P78/XOYft53A4xIREREREQk8SlpIbKbNTc1UPOb/yW51dvfnAvTZz4abFAiIiIiIiK9gJIWIrvZk9efw4j1Lrpfcu4xDBw0MsCIREREREREegclLUR2o0UfvMzYOUuj+wsnpnD2938XYEQiIiIiIiK9h5IWIrvRgpuvIqPR264Nw8Qf3xNsQCIiIiIiIr2IkhYiu8kzd17BxEVN0f1Fx45lyv5HBxiRiIiIiIhI76KkhchuULphOQWP/ie6v3KIMePnTwQYkYiIiIiISO+jpIXIbvDva8+nsMrbbg5B2v98h9TUcLBBiYiIiIiI9DJKWojsYq8/dg+T36uK7s8/MI+jzv5WgBGJiIiIiIj0TkpaiOxCrc3NVN7/R5L8GU435cFxv3gs0JhERERERER6KyUtRHahD564g6P3Xc/KaU20GpSffwJFg4YFHZaIiIiIiEivpKSFyC6yed0y9lh4N5nJrZw4pYT154/izKvuDjosERERERGRXktJC5FdZO0/vkMmEQAqXBZ7fvNPAUckIiIiIiLSuylpIbILzP/3Q+xV89/o/oJp1zJQj4WIiIiIiIjsFCUtRHZSbWUZA/774+j+pylTOfis7wYYkYiIiIiISN+QHHQAIr3d7CtOINyUxBETk8gMGeln/y+hJOUDRUREREREdpaSFiI74dV/3sGUD2oIuWQWLitmw4x9OXuPfYMOS0REREREpE/Qn4NFdlCkrpqmP/yFkPP2m1Lg6K//KtigRERERERE+hAlLUR20DPXn8PQTVv2Ky48lfzCQcEFJCIiIiIi0scoaSGyAz6b+y/Gvbo6uv/p5DBnfPuOACMSERERERHpe5S0ENkBn/30+6Q3ets1abDnrX8INiAREREREZE+SEkLkW6affeVTFzUFN1ffNx4Jkw9JMCIRERERERE+iYlLUS6oWrzerIf/ld0f+VgY8btjwUYkYiIiIiISN+lpIVIN7xw/bkMqPC2WwxSLv8mqanhQGMSERERERHpq5S0EOmi91/6B5PeLo3uz983i+lfvDLAiERERERERPo2JS1EuqCluZkNd9xOSou3X54Fh//s78EGJSIiIiIi0scpaSHSBbNuv5Qxq1qj+2tO25+hIycGGJGIiIiIiEjfp6SFyHZsWPUZg595L7q/ZFSIc350f4ARiYiIiIiI9A9KWohsx+s3XERerbfdmAQDvvdDkpKTgw1KRERERESkH1DSQqQTrz96D5M/rInuf3pwIQcff0GAEYmIiIiIiPQf/TppYWaFZrbJzJyZLdlO3UvMbK6Z1ZhZmZk9b2Zf2E6bQ/16ZX67uWZ28XbaDDOz+81snZlFzGyRmd1iZmk7co2y41qaGqn//R8JOW9/Uz6cfMcTwQYlIiIiIiLSj/TrpAXwK6Boe5XM7G7gfmAqMAeYCxwHvGZmZ3bQ5hzgVeBE4GPgBWA88KCZ3dlBm3HAh8AlQCkwC0gCbgLmmFm4y1cmO23eM/9L/uQqyrO9rEX5F48nr6A44KhERERERET6j36btDCz6cBXgD9tp96xwJV4SYS9nHNnOudOBI4AWoD7zSyvXZsC4C94CYcZzrmjnHMzgEnAEuAaMzsqzukewEui/MY5N80590VgIvAUcCjwgx26WOm2ik1rGffJXRwwsJp9TtzAp8fmc+ZV9wQdloiIiIiISL/SL5MWZpYO/BFYAMTt9RDje/76p865xW2Fzrm3gHuBPOBr7dpcBuQAs5xzT8a02Qhc5+9e0y6mA/ESE5ti6uCcawa+BTQB3zUzjQDZA5b+83vk4o1l0RJK47AbHgo4IhERERERkf6nXyYtgJ8AY4DL8ZIBcfnJjWP83cfjVGkrO61d+SmdtJkNRIBj241T0dbmWedcQ2wDP9nxOpAPHNZRvLJrfP7OC+xX/kJ0/6MJ/8OgYaMDjEhERERERKR/6ndJCzPbE6+Xw/3Oude3U30iEAZKnHNr4hz/wF/v2a58r3bHo5xzjcB8IA2Y0JU22zmX7ELNjQ2kvXhtdH9xaAwHnnddJy1ERERERERkd+lXjxqYWQj4M1BBzCMYnRjhr+MlLHDO1ZpZBZBvZtnOuWozywFyO2vnl+8PjMQbpHO754opH7m9oM3s0w4Ojd1e2/7uyZu/yPiGzYzMhlZnNJ30K1JSUoMOS0REREREpF/qV0kL4DvAAcClzrnSLtTP8td1ndSpxRvXIhuojmnTWbtaf53djXPFayO70OJ5rzLuuc9Jbczj6SnZZB44jeMOOGb7DUVERERERGS36DdJCzMbAfwUeNU590DA4exWzrkp8cr9HhiTezicXuOTW69kj0Zve+jSJPJuubbzBiIiIiIiIrJb9acxLX4HpOINvtlVNf46o5M6mf66ul2bztq1b9OVc8VrI7vInL/czB4Ltox/uvjo0YyfenCAEYmIiIiIiEi/6WkBnIo3lsW9ZhZb3jaDx1Aze8XfPt85twFY5e8Pi/eCZpaJ92hIuXOuGsA5V2VmlXjjWgzDm1a1vbbXWxlTtgrYp6NzddBGdoHG+jrs/kei+2sHwFm3PxpgRCIiIiIiIgL9K2kBXoLhyA6OpcUca0tkfA40AAPMbKhzbm27Nvv664/blX8EHOEf3yppYWYpwFS8aU8XtWtzRsxrttfRuWQnPf2j85hWsmW/4eJzSc/I6riBiIiIiIiI9Ih+83iIc87iLcBov8rSmPIVfpt64GX/+LlxXnaGv362XfnsdsdjnYqXFJnjnIvEaXOamYVjG5hZMXA4UA680emFSresWvgeY15eGt1fsEcqp3z91gAjEhERERERkTb9JmmxE+7y1zea2fi2QjM7BPgm3iMn97Vr82egCjjDzM6OaTMQmOnv/iq2gXNuLl5CYiDwy5g2ycDvgRTgN865pp2/JGkz9yffINNPHdWnwh4/uqvzBiIiIiIiItJjlLTYDufcHOAeoBCYZ2ZPm9nzwGt4j9dc6pyraNemDPgq0Ao8bmYvm9ljeI+bjAPucs69Eud0lwKlwJVm9rGZPey3ORt4E/j5brjEfuvVh3/FHh/XR/c/O3wok/efHmBEIiIiIiIiEktJiy5wzl2Fl1BYCBwHHALMAY5wzj3dQZsn8Ma1eBFvgM2TgSXAJc65azpos9iv+wAwADgLL/FxGzDdOdcQr510X0tzM/V/ui/6A7ChAE772WOBxiQiIiIiIiJb628DcW7DH7/CulDvAbxkQnde+w3gpG62WY2XIJHd6JlffoNJa110v+LcY8nOzQ8wIhEREREREWlPPS2k36mt2EzRM29F9xePDnHmVb8JMCIRERERERGJR0kL6Xee+9H5FFV62y0G+Vdchdl2O9uIiIiIiIhID1PSQvqVlQveYdx/10b3P90rg8NP+3qAEYmIiIiIiEhHlLSQfuXdW64gwx/OtC4M+974u2ADEhERERERkQ4paSH9xtvP3cekj+ui+58fNoTxUw8OMCIRERERERHpjJIW0m+sffS3JPkThpTkwSm3/TPQeERERERERKRzSlpIv/Dp609xzphlNBxbxaZCx8ZTDyK3YGDQYYmIiIiIiEgnlLSQPs+1tpL+yq0A7F1UQ8GJ+Zx9w58DjkpERERERES2R0kL6fM+nvN3xrQsi+6nnPILkpKTA4xIREREREREukJJC+nTWltayH37zuj+BxmHMmnfIwOMSERERERERLpKSQvp0z568QFGta6M7mefeFOA0YiIiIiIiEh3KGkhfVZjfR3L//Qr3q7MwgHvZR7F+D01xamIiIiIiEhvoQf7pc965vZLmbLQwcIcnh+Rxdg7rgs6JBEREREREekG9bSQPqm+toqBcz6O7kcy0pi016EBRiQiIiIiIiLdpaSF9EnP3XYJAyq87RaDIZdfE2g8IiIiIiIi0n1KWkifU1tdzuCXF0b3P5sc5pATLw4wIhEREREREdkRSlpInzP75osprPK2m0Mw8ts3BhuQiIiIiIiI7BAlLaRPqa+uZOhrS6L7n01J44BjZgQYkYiIiIiIiOwoJS2kT/m/e66koNrbbg7BuCtvDjQeERERERER2XFKWkifkvbqu9HtxRNS2OewMwKMRkRERERERHaGkhbSZ7w9+y+MXt0a3U875czgghEREREREZGdpqSF9Bmr//6H6Pa6AXDCpTcFGI2IiIiIiIjsLCUtpE/YvG45Yz6tie5vOnAcScnJAUYkIiIiIiIiO0tJC+kT/n3XlWQ0ett1qXDUVb8ONiARERERERHZaUpaSK/X0txM0TuLo/tLpmQyePi4ACMSERERERGRXUFJC+n1Xn7wpwwp2bI/9MuXBxeMiIiIiIiI7DJKWkivV/3sU9HtZcNDHHbaZQFGIyIiIiIiIruKkhbSqy37+E3GL2qM7tcdsV+A0YiIiIiIiMiupKSF9Gqfv3QfG4a0AlCRBSdd+b8BRyQiIiIiIiK7iuaElF6rpbmZfWpeZdBhJaysTWVB+FAOyckNOiwRERERERHZRdTTQnqthW88zSDnjcA5JKOFw76laU5FRERERET6EiUtpNeq/fTF6Pb8jIMoHjo6wGhERERERERkV1PSQnqtQZvfim43jJ4eYCQiIiIiIiKyOyhpIb3S5rXLGdm6Oro/bL+TA4xGREREREREdgclLaRXevPxO3mjPJuqFmOtFTN0zB5BhyQiIiIiIiK7mGYPkV6p+T//peCzbJYnZTP/sDwuMAs6JBEREREREdnF1NNCep2W5maGrGoEILUFwkPHBxyRiIiIiIiI7A5KWkiv8+Yz95Jb5223Avufd2Wg8YiIiIiIiMjuoaSF9DprX54V3V5XbIyatF+A0YiIiIiIiMjuoqSF9DqZS9ZFt0tH5QYYiYiIiIiIiOxOSlpIr1JdXsLwNa3R/awDDwswGhEREREREdmdlLSQXuW1f95BuNnbbkiBw790bbABiYiIiIiIyG6jpIX0KtVzX49urx4aIrdgYIDRiIiIiIiIyO6kpIX0KgXLK6PbNWMHBxiJiIiIiIiI7G5KWkivsfrzDxm60UX3Bx91ZnDBiIiIiIiIyG6npIX0GnMf/XX0H2xlJhx25uWBxiMiIiIiIiK7l5IW0mu4j+dHt9cNTyU5JTnAaERERERERGR3U9JCeo3iVfXR7aY9xgUYiYiIiIiIiPQEJS2kV/jg5cco2jIGJ1PO+EZwwYiIiIiIiEiPUNJCeoXFsx+Mbm8ogKkHnxBgNCIiIiIiItITlLSQXiFl6erodsnIzAAjERERERERkZ6ipIX0ChlVTdFtN3JEgJGIiIiIiIhIT1HSQnqF9IiLbqcNUtJCRERERESkP9CckZLwXGsrBx1bQktLC5sbkpnwhdOCDklERERERER6gJIWkvCqyjeRG2qCEGSmNFI5blrQIYmIiIiIiEgP0OMhkvDKNqyKbkdcCjl5RQFGIyIiIiIiIj1FSQtJeDUlW2YOKQ0VYCH9sxUREREREekP9O1PEl6kfG10uypZvSxERERERET6CyUtJOG1VK6PbteFBwQYiYiIiIiIiPQkDcQpCW/5qy9TsWowjZmt1E+qZ7+gAxIREREREZEeoaSFJLyMTXWMXGtAEh8Nawk6HBEREREREekhejxEEl56zZZERahQj4eIiIiIiIj0F0paSMLLqnXR7czBIwOMRERERERERHqSkhaS0Brr68ip3bJfNGZKcMGIiIiIiIhIj1LSQhLass/mkrSlowUjJx8SXDAiIiIiIiLSo5S0kIS27rP3otv1qTBoxPgAoxEREREREZGepKSFJLTKVYuj21VZAQYiIiIiIiIiPU5JC0lojZvWRrfrMvXPVUREREREpD/Rt0BJaK68PLodyUoOMBIRERERERHpaUpaSEJLrq6LbjdlpwUYiYiIiIiIiPS0fpW0MLPvmdmTZrbYzCrNrMHMVprZX81sWiftLjGzuWZWY2ZlZva8mX1hO+c61K9X5reba2YXb6fNMDO738zWmVnEzBaZ2S1m1m+/rYdrGqPbLjc3wEhERERERESkp/WrpAXwQ+AkoAz4NzAbiAAXAe+b2antG5jZ3cD9wFRgDjAXOA54zczOjHcSMzsHeBU4EfgYeAEYDzxoZnd20GYc8CFwCVAKzAKSgJuAOWYW3oHr7fXSa1qj28kDigOMRERERERERHpaf0tanAHkO+cOcs6d7S8TgW8DKcCfzSw6cIKZHQtciZdE2Ms5d6Zz7kTgCKAFuN/M8mJPYGYFwF/wEg4znHNHOedmAJOAJcA1ZnZUnNgeAIqA3zjnpjnnvghMBJ4CDgV+sIveg14luzZme8iY4AIRERERERGRHtevkhbOuTecc5E45b8HlgLFwOSYQ9/z1z91zi2Oqf8WcC+QB3yt3ctdBuQAs5xzT8a02Qhc5+9eE9vAzA7ES0xsiqmDc64Z+BbQBHw3NqHSH9RWVZCzZUgLBo7bK7hgREREREREpMf1q6TFdjT560YAM0sHjvHLHo9Tv63stHblp3TSpu1xlGPbjVPR1uZZ51xDbAM/2fE6kA8ctp1r6FOWfvL6Vvtjph0aUCQiIiIiIiISBCUtADO7CO9RjMX+gr8fBkqcc2viNPvAX+/ZrnyvdsejnHONwHwgDZjQlTbbOVeftmHxh9HtmjTILdSYFiIiIiIiIv1Jv3rcoI2ZXQtMATKBPfztdcCXnHMtfrUR/jpewgLnXK2ZVQD5ZpbtnKs2sxwgt7N2fvn+wEi8QTq3e66Y8pGdXVcbM/u0g0Nju9I+UVSvXbZlOyvAQERERERERCQQ/TJpAZwATI/ZXwlc7Jx7P6as7WtyzKgK26jFG9ciG6iOadNZu7ahJbO7ca54bfq81tpqKrId2TVGXaY6BYmIiIiIiPQ3/TJp4Zw7FsCf+WMa3rSir5rZjc6524OMbVdwzk2JV+73wJgc71giGj56KAefMofWVqjMOi7ocERERERERKSH9es/XzvnKpxzrwMnA+8Dt5nZAf7hGn+d0clLZPrr6nZtOmvXvk1XzhWvTZ+XVLMRgFAIQvnDAo5GREREREREelq/Tlq0cc41AY8AxpbZQFb567jfls0sE+/RkHLnXLX/OlVAZWftYspXxpR1eq4O2vR5aZFN0e1QzuAAIxEREREREZEgKGmxxWZ/PcBffw40AAPMbGic+vv664/blX/U7niUmaUAU/GmPV3UlTbbOVeflt1UEt1OzY93C0RERERERKQvU9JiiyP99VIA51w98LJfdm6c+jP89bPtyme3Ox7rVLzpTuc45yJx2pxmZuHYBmZWDBwOlANvbOca+pSC1rLodkbR8AAjERERERERkSD0m6SFmR1qZieaWahdeYqZfQe4CKjHe0ykzV3++kYzGx/T5hDgm0AFcF+7U/0ZqALOMLOzY9oMBGb6u7+KbeCcm4uXkBgI/DKmTTLweyAF+I3/GEu/UF9bRXZ00hTIK1bSQkREREREpL/pT7OHjAfuBzab2ftAKVCEN3vIYLxHNi5xzq1ua+Ccm2Nm9wBXAvPM7CUgFTgOb/yLS51zFbEncc6VmdlXgUeBx83sFf9cx+KNgXGXc+6VOPFdCrwFXGlmxwALgAOAMcCbwM93/i3oPRa8/X+0Pj2E6kxHfZbj2B8MCTokERERERER6WH9pqcF8CrwM7yxKvbEe+TjUKAM+F9gmnPu0faNnHNX4SUUFuIlKw4B5gBHOOeejnci59wTwBHAi8A+eLOTLMFLilzTQZvFft0H8MbVOAtoBW4DpjvnGrp/yb3XpqUfkxWBwaVG4eYQ4XBa0CGJiIiIiIhID+s3PS2cc8uBH+1g2wfwkgndafMGcFI326zGS5D0ezVrl2/ZzuykooiIiIiIiPRZ/amnhfQizaVbZg6py0wKMBIREREREREJipIWkpBCFVXR7Ybs1AAjERERERERkaAoaSEJKbW6PrrdkqPnQ0RERERERPojJS0kIaXVNke3Lb8gwEhEREREREQkKEpaSELKqHXR7bTioQFGIiIiIiIiIkFR0kISTktzMzk1W/Zzh08ILhgREREREREJjJIWknA2rl1MWtOW/aF7HBBcMCIiIiIiIhIYJS0k4ayY/3Z0uzkEoybtH2A0IiIiIiIiEhQlLSThlC2bH92uyoSU1HCA0YiIiIiIiEhQlLSQhFO/YVV0uybLAoxEREREREREgqSkhSSc5tLN0e36zKQAIxEREREREZEgKWkhCSepqjq63ZilR0NERERERET6KyUtJOGkVDdEt1tzswKMRERERERERIKkpIUknPTaluh2qKAowEhEREREREQkSEpaSMLJqnXR7fRBwwOMRERERERERIKUHHQAIrFcayvVha00pRqZtUbh6ClBhyQiIiIiIiIBUdJCEkpl6UZOOnDDlv3DzggwGhEREREREQmSkhaSUNKycvjg8D/TUL6WlqoNHJpXGHRIIiIiIiIiEhAlLSShpKVnsu/0c4MOQ0RERERERBKABuIUERERERERkYSkpIWIiIiIiIiIJCQlLUREREREREQkISlpISIiIiIiIiIJSUkLEREREREREUlISlqIiIiIiIiISEJS0kJEREREREREEpKSFiIiIiIiIiKSkJS0EBEREREREZGEpKSFiIiIiIiIiCQkJS1EREREREREJCEpaSEiIiIiIiIiCUlJCxERERERERFJSEpaiIiIiIiIiEhCUtJCRERERERERBKSkhYiIiIiIiIikpCUtBARERERERGRhKSkhYiIiIiIiIgkJCUtRERERERERCQhKWkhIiIiIiIiIglJSQsRERERERERSUhKWoiIiIiIiIhIQjLnXNAxSA8xs6pwOJw9duzYoEMRERERERGRfmDp0qU0NDRUO+dydqS9khb9iJltADKA1UHHEqMtg7I00CikK3Svegfdp95B96n30L3qHXSfegfdp95D96p36C33aThQ55wbtCONlbSQQJnZpwDOuSlBxyKd073qHXSfegfdp95D96p30H3qHXSfeg/dq96hv9wnjWkhIiIiIiIiIglJSQsRERERERERSUhKWoiIiIiIiIhIQlLSQkREREREREQSkpIWIiIiIiIiIpKQNHuIiIiIiIiIiCQk9bQQERERERERkYSkpIWIiIiIiIiIJCQlLUREREREREQkISlpISIiIiIiIiIJSUkLEREREREREUlISlqIiIiIiIiISEJS0kJEREREREREEpKSFhIIM0s3s1vNbJGZRcxsnZn9xcyGBh1bf2JmGWZ2ppndZ2af+/ei1sw+MrObzCyrk7aXmNlcM6sxszIze97MvtCT8fdnZlZoZpvMzJnZku3U1b3qYWY2wMzu9H+u6v33/QMzu6OD+qeZ2atmVuUvr5jZKT0dd39jZgeY2aP+/0FNZlZhZq+b2aVmZnHqJ5nZ1Wb2iX9fS/z2ewQRf19hZvuZ2Q1m9qSZrfF/r7kutOv27zYzO9SvV+a3m2tmF++6q+nbunOvzCxkZoeb2Uwze9/Mqs2swcyWmtm9ZjZ6O+fSvdpBO/oz1e415rS1M7NhndTTfdpBO/G7L8XMrvLf6yr/fV/U2XcpM5tiZo/5/2/V+/+PXWVmvSMf4JzToqVHFyANeAtwwDrgEeAdf38TMCboGPvLAlzmv+8OWAA8CrwAVPllC4GBcdrd7R+vA5722zQBzcCZQV9Xf1iAB4BW/z4s6aSe7lXP35v9gM3++z4feBh4HlgBNMepf5Vftwn4P/8+1fll/xP09fTVBTjH/zlwwPv+/0Uv+/fBAQ+1qx8CnvSPlQOPA6/4P4e1wIFBX1NvXfx/8679sp023f7dFnPPW/1797h/Lx1wZ9DvQ29YunOvgHExddYDs/yfoTV+WRVwmO5VsPepg/aX+G3aPmcM031KjPsEFADvseV71JP+8rFfts3PFHBIzOeKd/z/79b7+48CFvR7sd33KugAtPS/Bfip/0PyJpAVU/49v/yVoGPsLwvwFeCPwB7tygcDH/j34x/tjh3rl28GxseUHwI0+P9Z5QV9bX15Aab79+CPdJK00L0K5N4MAErwvsSeHuf4ge32J/of+CLAITHlE/z71gSMC/q6+toCJAMb/Z+PL7c7tgdQ6h87Oqa8Lcm7CCiOKT/HL18MJAd9bb1xAa4HbgVOAwb5Pw+uk/rd/t3mf9Cv9NudHVNe7N87BxwV9HuR6Et37hUwFvgXcEzslyIgDNzvv+crgRTdq+DuU5y2A/zfgS/iJdvjJi10n3r+PgGGl1x3wM3t/88BxgBF7cpSgGV+m6tjyrPwvos54JKg34vtvldBB6Clfy1AKlDh/4DsE+f4R/6x/YKOtb8v/oc/5/8CTY0pf94vvypOm3v8Y9cEHX9fXYB0YAnwKTCezpMWulc9f39+77+vV3Sz/t1xjl3tH/vfoK+rry3AVP+9/ayD420/H9fFlC3wy86MU3+Wf+ycoK+tLyxd+ODe7d9twHV++dNx2pzlH3s26Gvvbcv27lUn7dJjPg8eqXuVOPcJeAiox0s6raDjpIXuUw/fJ+A8/319tBuv2dZmXpxj+/rHPgn62re39I5nWKQvORTIBZY65z6Mc/xxf31az4UkHfjIX4eBQvDGIsH7iwlsuVexdP92v5/gZdIvx/srfFy6Vz3Pf88vxOtlcX8Xm7WNW6F71LMaulivFMB/9n4PvA/ys+PU073qITvxu62zn7XZeF8WjjWztJ0OUrbLOVeP12sJYEi7w7pXATGzE4EvA7c755Zup7ruU8/7ur/+32606fA+Oec+wOuFMdXMRu1caLuXkhbS0/by1x90cLytfM8eiEU6N8ZfNwFl/vZEvCRGiXNuTZw2un+7kZntCVwD3O+ce3071XWvet7+QDbwoXOu3sxOMrO7zOz3/mBXW30wN7M8YIS/u00S1zm3Gq/7+0gzy9nNsfc3y4ClwEQz+3LsAX9QzQvxHjF4yi9u+79rvnMuXrJQP089Z0d/t3X4+cM514g3/kwa3qNZspv5g/+N9Hc3tDusexUAM8sE/gB8BszsQhPdpx5kZinAYXiPlM41sz3N7DYz+6N5g+fv1UHTPvHdS0kL6WltH9DjfdCILR/ZwXHpOVf66xecc21/lez0/jnnavG6e+abWfbuDa9/8T/g/Rnv/b2uC010r3reZH+9ycyexuvCfjXwLeDXwBIz+1JM/bZ7VO7fj3j0O3E3cM614I3pUwE85M9s8LCZvYw3mNkaYLpzri1hq/+7Eke3f7f5Sb/cztqhe9jTvgQMxBsD6M22Qt2rQN0KjAIu95MOHdJ9CsQYvCRQKd5niw+BG4FvALcAH5rZr+O06xP/fylpIT2tbQrNug6Ot31w15eoAJnZycDX8HpZ/Djm0PbuH+ge7i7fAQ4ArnXOlXahvu5Vz8v316cDJwLfxvtQPgq4E+8Z7gfNbG+/nu5RgJxzbwBH4vW62Bf4InA03ij4L/nlbfR/V+LYkZ+b2Om7dQ8DZmbD8WZ/Abgp5g8joHsVCDPbF++PVQ86517tQhPdp57X9hmjEPg5cC/euCNFeJ/Z64GrzOzb7dr1if+/lLQQka2Y2STg73gjFF/rnPtoO01kNzOzEXiz7rzqnHsg4HCkY23/pybjfRD/vXOuxDm30jl3LfAY3ije1wYWoUT5vV7mAquBg/A+2E3Am074GuBlMwsHFqBIH+Q/gvAk3hetp51z9wYcUr9nZkls6cn5/WCjkU7Efsb4P+fct51zy5xzpc65v7Dls8UPgglv91LSQnpajb/O6OB4pr+u7oFYpB0zG4o3130+cJdz7p52VbZ3/0D3cHf4Hd7MO5d3o43uVc+ridmONxBnW9mR7errHvUwMxsPPIg3Zsipzrm5zrla59xi59w3gefwel981W+i/7sSx4783MT+bOoeBsR/Jv8xvPF//os34GN7ulc97ypgH7zZkjZ3sY3uU8/b3meMB/z1UDMbF6ddr75PSlpIT1vlr4d1cLytfGUPxCIxzKwAbz71kXi/DONl2zu9f/5fUPLwntFP6F9+vcypeN367jWzV9oW4GH/+NCY8kF+me5Vz2v7vVXnnCuJc3yFvx7or9vuUb5/P+LR78Td43y8Xi8vOOdq4hx/1F8f4a/1f1fi6PbvNudcFVDZWTt0D3crf1ymB4GTgHnAaf4MIlvRvQrEaXjTXn4l9jOG/zmj7TPFY37ZiaD7FJDY93FF+4POuTpgk787MOZQn/j/S0kL6Wltjxrs28HxtvKPeyAW8ZlZFvB/eAMJPgl83fkTOLfzOd5UgQP8Xhnt6f7tPnl4f6GPXQ7yj6XFlLVNLaZ71fPaZgBJ7+CxggJ/XQPgnKtgy4eJfdpX9p/7LgJW+h8QZddp+5BW2cHxtvK2Z4jb/u+a6v+1uD39PPWcHf3d1uHnD/+eTsWbonFR++OyS/wv3uCbi4AT/N9/HdG96nmGl6Rt/zmj7f+yg/39QTFtdJ96kHOuElju7+a3P+4nBvP83dhkfJ/47qWkhfS0N/A+DI6NGYwu1gx//WyPRdTP+V+uZgEHAi8CX/JH1t+G/1eRl/3dc+NU0f3bDZxzFm8BRvtVlsaUr/Db6F71MOfcKrwPB8aWR0BitZXFTm8621/PYFu6R7tP2xSL+3dw/AB/vQLAObccWIg3mOopcerrXvWQnfjd1tnP2ql4Cd85zrnITgcpWzGznwJX4CVpj3PObdpOE92rHuScO6qTzxltf30f7pc9ENNU96nnPeOvj4pz7GC8R4nr8ZK7bTq8T2a2D96sJPPbPj8mLOecFi09uuANKOjwEhiZMeXf88tfCTrG/rIASXg9KxzwGpDRhTbH+vU3A+Njyg/By6iXA3lBX1t/WPBmpXDAEt2rxFjwntF2eH+xGBxTvjfeNGUOODemfCLenOsR4OCY8vH+fWsCxgV9XX1twfvLkvOXb7U7djDeX6kccGxM+WV+2SJgYEz52X75YiA56GvrC4v/8+A6Od7t3214PZ0q/XZnx5QP9O+dA44K+tp729KFe3W1/96uj71X23lN3asevk+dtFvhv9/DdJ+Cv0/+574GoKrdZ4YivIGlHfC7dm1S8GbDcsDVMeWZeNMNO+CSoK99e4v5QYv0GDNLA17B69q+HngdbxyFg/Dm6z7YObeswxeQXcbMrmTLtGNP4f0SjOf7LmZwJjO7G29qrDq8qQFTgePw/sI8wzn39O6JWGKZ2Si8roJLnXPjOqhzN7pXPcrMHgC+gjcS+5t4f53/Al432z85577Rrv7VwF14yYuXgEbgeL/dd51z/9tTsfcnZnYHW8bu+RRYAAzB++IbAv6f8wblbKsfAh4HzsL7UvxvvA+KR+J90DzaOfdOj11AH2Jmp7D19NoH4v2Oin0/b3POzY5pczfd/N1mZufgjVdieJ9DSvESIHl4g09fs4suqc/qzr3ye9R+4B9/i44fE/izc+6/7c6je7UTduRnqoPXWYH3GX24c25NnOO6TzthB3/3fRVvtpdmvJ+rSrzPGIV4P29HunZjNZnZF4A5eJ8r3sHrQXM4MBjv/7XzXKInBYLOmmjpnwveD82twBK8jOF6vMEft8nkatmt9+Fmtvy1sbNlVJy2lwDv4c3vXI43JsYXgr6m/rSwnZ4WuleB3RcDvh7zntfgJS++0kmb0/B6O1X7y2t4s1oEfj19ecFLQLzIll4tZXiPHnypg/pJeL0C5+N1wd2MNxvC5KCvpTcv/u+o7f0/dEkH7br1uw041K9X7rd7t7OfTS07fq/wurB35TPGNvdW96rn7tN2XmcFHfS00H0K7j75P1sv+O95BC/p/hNierDHaTMFL0Gx2f//az5eT6hQ0O9DVxb1tBARERERERGRhKSBOEVEREREREQkISlpISIiIiIiIiIJSUkLEREREREREUlISlqIiIiIiIiISEJS0kJEREREREREEpKSFiIiIiIiIiKSkJS0EBEREREREZGEpKSFiIiIiIiIiCQkJS1EREREREREJCEpaSEiIiIiIiIiCUlJCxERERERERFJSEpaiIiIyDbMzHVzWeG3e8XfHxXsFewaZnazfz2XBBjDJX4MNwcVg4iISFCSgw5AREREEtKDccoOA8YCHwHz2h3bvLsDEhERkf5HSQsRERHZhnPukvZlZvYAXtLiaefczR00vRjIANburth62G+Bh4H1QQciIiLSHylpISIiIruMc25V0DHsSs65zagXiYiISGA0poWIiIjsMh2NadE27oWZJZvZj81siZnVm9lCM7s0pt4xZvYfM6sys3Iz+6uZFXZwrmQz+5aZveXXrzezeWZ2lZntkj/MdDSmRex1mtmZZva2mdWaWZmZ/dPMhu3AuQ41szlmVm1mFWb2opkd1En9cX58b5nZBjNrNLM1/ns2oV3dwWbWZGarzSypg9f7sn9ND8aUpZrZFWb2rpmVmlmdfx+fM7Pzu3uNIiIi3aWkhYiIiPSkR4FrgE+A14DRwF/M7FIzmwG8iNcT9EWgFrgIeNrMLPZFzCwd+Bfwe2AC8DbwEjAY+DXwhJn1xOecK4DHgXrgeaAGOB942Y+xS8zsVOAVYDqwAPg/YDjee3RIB80uA24CMoF3gWeAKrz37F0z27OtonNuvX98GHBiB6/3dX/9/2LKHgJ+B0zEe49nAavwxje5vKvXJyIisqP0eIiIiIj0lJFANTDeOVcCYGZHAy8DtwOpwJnOudn+sRzgTbwvyEcB/4l5rTuBo4FHgG865yr9Ntl4Y1CcDnwDuHc3X9O3gcOdc2/558/AS558AfgS8JftvYAf81/wPpd91Tl3v19uwM+B6zto+jTwR+fc8navd6n/encDx8Qcuhc4Gy85Mbtdm3F47/FC59wbftloYAawEtjPOVcaUz8N2Gd71yYiIrKz1NNCREREetJVbQkLAOfcf4AP8XpI/F9bwsI/VsWWv/of2VZuZgPxvnivBi5tS1j4baqBrwGNwLd243W0+XVbwsI/fx1wl797RBdfYwYwAHitLWHhv5YDfgysidfIOfd2+4SFX34/8AZwlJnlxhyaAywBTjGzwe2aXeav/xRTNsBffxibsPDPEYm9bhERkd1FSQsRERHpKU14j0C0t8xf/6uTY7Ffso8CUoAXnHP17Rs45zYAi4Fp3XlEYwfFi3mRv26fGOjI4f764fYHnHNNeI+fxGVmWWb2JTP7pZn9ycwe8Gd5GQwY3mwvba/l8JJAyUDsOCIpwCVAA/DXmJf/DO8RnVPM7FozG9LF6xEREdlllLQQERGRnrLBOdcSp7zGX8ebJrXtWDimbJS//ro/cOQ2CzAF70t7wa4IvBPxekFU++twnGPxtCUDVnZwfEW8QjM7Bi+p8w/gOrzeEl/xlzF+tex2ze7HS058LWackNOAYuDJ2B4Vfk+Xr/v1ZwJrzexzM7vXzA7t4rWJiIjsFI1pISIiIj2ldSePt2n7o8s84KPt1G3o4mvuqK7GvEuZWRbeoKYFwK14vTRWAvXOOWdm/8AbU2OrAUydc5vN7Angy3iDfs4h/qMhbfX/aWZzgDOA4/Ee0/km8E0zu8s5d83uuD4REZE2SlqIiIhIb9PWu+G/zrnvBBrJrrHeX4/s4Hi88sOBQuBx59xP4hwfE6eszb14SYuvm9ki4ARgsT++yDb8MUj+DPzZ751xAt4AqN8zs7845z7t5FwiIiI7RY+HiIiISG/zH6AFONUfj6G3e91fn9f+gJklA+fEaZPvr7d5PMWfCWTfjk7mnHsd+BQ4E++xkhBeUmK7nOcFtsw+MqUr7URERHaUkhYiIiLSqzjn1uJN6TkK+KeZFbevY2bjzOycdmVH+WNerOiRQLvuMaAUb7aPr7QV+r0abgFGxGnTNtjn2WY2IKZNHnAf3kClnfkj3hSz38YbIPWB9hXMbB8zO9vMUtuVFwAH+burt3MeERGRnaKkhYiIiPRGVwIv4fVCWGpm/zWzf5jZLDNbjDd7yEXt2rR97mnqwTi3K2aa1hbgATN72x+TYj5wLfHHmngP7/pHAIvM7CkzewpYjjew56ztnPavQJ2/Pcs5tylOnZHAE8AmM5tjZn83s+fwBgYdAzyraU9FRGR3U9JCREREeh1/qtOT8GbKeAfYA5gB7A+UAD/Be/Qh1l7++q8kGOfcLOBovEdfpgKn4I11cSTwZgfNzgBux7vek4D98AbkPBio2M75KoEP/N1tkiK+t4EbgfeBicC5eO/vx8BXif/YioiIyC5l3pTdIiIiIn2bmT0DHAqM8ns39FtmNhyvV8ZqYIzTB0IREUlQ6mkhIiIifZ6ZJQFHAHf294SF7wYgCfidEhYiIpLI1NNCREREpB8ws4l4Y2SMBo7Bm3lkD+dcTaCBiYiIdCI56ABEREREpEcMxhvwsx54DfiOEhYiIpLo1NNCRERERERERBKSxrQQERERERERkYSkpIWIiIiIiIiIJCQlLUREREREREQkISlpISIiIiIiIiIJSUkLEREREREREUlISlqIiIiIiIiISEJS0kJEREREREREEpKSFiIiIiIiIiKSkJS0EBEREREREZGEpKSFiIiIiIiIiCQkJS1EREREREREJCEpaSEiIiIiIiIiCUlJCxERERERERFJSEpaiIiIiIiIiEhCUtJCRERERERERBKSkhYiIiIiIiIikpCUtBARERERERGRhKSkhYiIiIiIiIgkJCUtRERERERERCQhKWkhIiIiIiIiIglJSQsRERERERERSUhKWoiIiIiIiIhIQlLSQkREREREREQSkpIWIiIiIiIiIpKQlLQQERERERERkYSkpIWIiIiIiIiIJCQlLUREREREREQkISlpISIiIiIiIiIJSUkLEREREREREUlISlqIiIiIiIiISEJS0kJEREREREREEpKSFiIiIiIiIiKSkJS0EBEREREREZGEpKSFiIiIiIiIiCQkJS1EREREREREJCEpaSEiIiIiIiIiCUlJCxERERERERFJSEpaiIiIiIiIiEhCUtJCRERERERERBKSkhYiIiIiIiIikpCUtBARERERERGRhKSkhYiIiIiIiIgkJCUtRERERERERCQhKWkhIiIiIiIiIglJSQsRERERERERSUhKWoiIiIiIiIhIQlLSQkREREREREQSkpIWIiIiIiIiIpKQkoMOQHqOmW0AMoDVQcciIiIiIiIi/cJwoM45N2hHGptzbhfHI4nKzKrC4XD22LFjgw5FRERERERE+oGlS5fS0NBQ7ZzL2ZH26mnRv6weO3bs5E8//TToOERERERERKQfmDJlCgsWLNjh3v4a00JEREREREREEpKSFiIiIiIiIiKSkJS0EBEREREREZGEpKSFiIiIiIiIiCQkJS1EREREREREJCEpaSEiIiIiIiIiCUlTnoqIiIiIiPQzzjmcc0GHIb2MmWFmPXpOJS1ERERERET6gZaWFkpLS6murqaxsTHocKSXSk1NJTs7m8LCQpKSknb7+ZS0EBERERER6eNaWlpYtWoVkUgk6FCkl2tsbKS0tJTa2lpGjBix2xMXSlqIiIiIiIj0caWlpUQiEZKSkiguLiYzM5NQSEMcSve0trZSW1vLxo0biUQilJaWMnDgwN16TiUtRERERERE+rjq6moAiouLyc3NDTga6a1CoVD038+6deuorq7e7UkLpdZERERERET6MOdcdAyLzMzMgKORvqDt31FjY+NuH9BVSQsREREREZE+LPZLpR4JkV0h9t+RkhYiIiIiIiIi0i8paSEiIiIiIiIiCUlJCxERERERERFJSEpaiIiIiIiIiEhCUtJCRERERERE+rXa2lruuusujj76aIqLi0lNTSU/P59DDjmEm266iVWrVgUd4i5zxRVXYGaEQiFWrlwZdDjb1euTFmY2wMzuNLPPzazezMrM7AMzu6OD+qeZ2atmVuUvr5jZKds5xxQze8zMSvxzfGJmV5lZh++fmeWb2T1mttLMGvz13WaW10mbJDO72n/9ev98j5rZHl1+Q0RERERERKTL3nzzTcaNG8c111zD3LlzmTp1KjNmzOALX/gCS5cu5bbbbmPChAnMmTMn6FB3WmNjI4888gjgzfrx0EMPBRzR9vXqpIWZ7QcsBK4BmoBZwNtAAXB1nPpXAc8AXwDeAF4GDgSeM7P/6eAchwDvAjOAZX77IuDXwMNmZnHaFAFzge8CzcDTQDVwJfCOmRXEaRMCHgPuAoYBs4FP/fO+Z2YHbv8dERERERERka6aN28e06dPZ8OGDVx//fVs2rSJf//73/zjH/9g9uzZbNiwgSeeeIJhw4axZs2aoMPdac8//zxlZWUMHjwYgL/97W8BR7R9vTZpYWYDgBeAdOAM59xU59z5zrmTnXOj8BITsfUnAncCDcARzrmTnHNnAnsDpcCvzWxcuzYpwEP+Ob7nnDvIOfdFYDzwFnAu8JU44d0NjAOeBCY6577onJsK/C8wAS8x0d5XgbOAxcAk59wM59xR/jkygIfMLLnr75CIiIiIiIh0xDnHRRddRCQS4eabb+YXv/gFmZmZW9UJhUKcffbZvP/+++y///4BRbrrtCUpbrnlFsaOHctnn33Ge++9F3BUneu1SQvgFrweD9c6555pf9A5N7dd0ZVAEnCvc+6tmHqLgNuBZL9OrLOA0cBHzrlfx7SpAdp6ZlwT28DMBgNfAhqBK5xzzTGHrwVKgAvNbGC7c33PX1/nnNsYc64n8Hp3jAPOaH+dfdWST95i1aJ5QYchIiIiIiJ91AsvvMD8+fMZNmwYP/rRjzqtm5uby9SpU6P769evZ+bMmRx55JEMHTqU1NRUBg0axNlnn827774b9zVKSkq44YYbmDx5MllZWeTm5jJhwgQuvvhi5s5t//UVysrK+MEPfsDkyZNJT08nNzeXY445hueee26HrreiooLZs2cTDoc577zzuOCCC4DE723RK5MWZpYOXAjUAvd3sVnbuBWPxznWVnZaV9s45z7Ae1xkqpmNijl0It77+nps8sFv0wA8i5c8Obmt3MxGA3sA9XiPhXQ1vj6nbNNa3vnNxYx+/CQ2PvodWpqbt99IRERERESkm2bP9r56nXvuuSQnd69T+6xZs7j++uvZuHEje+65J2eddRZDhgzhqaee4tBDD+Vf//rXVvWrq6s56KCD+OUvf0lNTQ3HHXccxx9/PPn5+Tz88MM8//zzW9VftGgRe++9N7/4xS+or6/nhBNOYP/99+edd97htNNO48477+z29T766KM0NDRw6qmnkpuby4UXXgjAww8/THMCf+/qrY8b7A9kA/91ztWb2UnAcUAasAh41Dm3rq2yP/jlCH/3w/Yv5pxbbWabgZFmluOcq/IP7eWvP+ggjg+AMcCewIputPmq36ZNW5v5zrmmDtrQrk2ftPrj19ivdBYvb8gj673NPBX6JjN+eF/QYYmIiIiI9GnOOaoiifvFNZ6ctGTiDDHYZfPmzQNg33337XbbQw89lPnz5zNlypStyl988UVOP/10rrjiChYvXhyN7/HHH2f58uWcfvrpPPXUU4RCW/oPlJSUsHHjlr93t7S0MGPGDFavXs3MmTO55pprovWXLFnC8ccfzw033MCJJ564Ve+P7WnrUdGWrBg/fjwHHnggc+fO5V//+hcnn3xyZ80D01uTFpP99SYze5ptH5v4mZl9zTn3T3+/LWFR7pyr7eA11+A9bjIS+KRdu45GXGkrHxlT1lNt+qQ9j/kij//550yd5+Vump55k8pvbSQ3vzjgyERERERE+q6qSDN73fKv7VdMIB/95Hhy01N2uH1paSkAAwYM6HbbadOmxS0/4YQTOPfcc3nooYeYP39+tF5JSQkAxxxzzFYJi7bzx8bw7LPP8sknn3DOOedw7bXXblV33Lhx/OpXv+Lss8/mT3/6E/fcc0+X4l2+fDlvvPEGBQUFWyUnLrzwQubOncvf/vY3JS12sXx/fTrQAnwbb+aNDLyxJr4PPGhmC51z84Asv35dJ6/ZlszIjinbXrsg23TIzD7t4NDYrrQPkoVCDPvylbR8dCdJDgZUwOwfns+X//CfoEMTERERERGJamho4IUXXmDu3LmUlJTQ2NgIwCefeH8DX7x4cTRpsd9++wFwxx13UFxczCmnnEJ2dvyvd22Plpx99tlxjx9++OEAccfB6MhDDz2Ec47zzjuP1NTUaPn555/P9773PWbNmkV1dXWHMQWpV45pwZa4k4GbnHO/d86VOOdWOueuxUtgpOANfCm9zCGnf42Fe28ZtXfSGxtY+IGSFiIiIiIisusUFhYCW3pBdMcnn3zCpEmTOPPMM/nZz37Gn/70Jx588EEefPBBPv74Y8Abx6LN9OnTufrqq1m3bh1f+tKXKCgo4KCDDuLGG29k2bJlW732ihUrALjgggsws22Wtl4Zmzdv7nK87R8NaTNgwABOOOEE6uvreeKJJ7r9PvSE3trToiZmO95AnPfjTRV6ZLv6GZ28Ztu35OqYshq8Xh0dteuoTWfn2lVtOuScmxKv3O+BMTnesURz8C1/ZsN5XyIrAumNMP/2q9njiXlBhyUiIiIi0iflpCXz0U+ODzqMbslJ27mvs3vvvTdvvPEGH3zwwTZf5jvT1mNhxYoVXH755Vx++eWMGTOGrKwszIwf/vCH/PznP8c5t1W7u+66i29+85vMmjWLOXPm8MYbbzB37lxmzpzJP//5T8455xwAWltbATjxxBMpLu74MfmioqIuxTt37lwWLVoEwPXXX7/N8TVrvNEI/va3v3HJJZd06TV7Um9NWqz013XOuXhpsRX+um1a0VX+Ot/MMjsY12JYu9dua5fvH/u4G21ij+2uNn3a8Al78+ZRo9nzheUATP60gTn/mMmxX74u4MhERERERPoeM9up8SF6o1NOOYXf/e53PPbYY8ycObPLM4h89tlnfPbZZ+y///784Q9/2OZ4+54TsSZOnMh1113HddddRyQS4be//S3XXnst3/rWt6JJi2HDvK9/l112WbRsZ8ROafrGG290WO+VV15hzZo10fMnit76eEjbDCDpZhaOc7zAX9cAOOcq2JIY2Kd9ZTMbjjcI58qYmUMAPvLXHQ0n21Yem9DYmTZTzSzeb4p4bfq8029/mA1ejy1CQPOfH9AUqCIiIiIiskuceOKJTJkyhTVr1nD77bd3WreqqopPP/WGDiwvLweI++W+vLycl156qUvnT0tL4/vf/z6DBw+mpKSETZs2AXDccccB8NRTT3X5WjrS3NzMI488AsD8+fNxzsVdLrnkElpbW3nooYd2+py7Wq9MWjjnVuF90Te2PAISq60sdnrT2f56Rpz6bWXPtivvsI2Z7YM33el859yKmEMvAK3A4WY2sF2bMHAa3uCh0Yl4nXPLgYVAOnBKN+Lr09Izc6g9f8sItiPXOZ647eIAIxIRERERkb7CzPj73/9OWloaN998Mz/4wQ+ord26U75zjmeeeYb999+fd999F/Bm8AiFQrz88sssXrw4WjcSiXD55ZdTVla2zbmefvpp3n777W3K33//fTZu3EhWVhZ5eXkAnHPOOUyePJmHHnqI2267jYaGhm1ieuONNzrtNdHmhRdeoKSkhGnTpm0zPWusL33pSwD8/e9/3+5r9rRembTwzfTXd5rZ4LZCM9sbuMbfvTem/j14yYLLzezgmPrjgR8BzX6dWE8By4G9zOzqmDaZwO/83V/FNnDOrQf+CaQCvzez2D5GM4EBwN+dc5vaneuutjqxyQ4zOxtvlpQlwCz6mVO/8ysWjU2K7g99/kOWLXw3wIhERERERKSv2HvvvZkzZw7FxcX84he/YODAgRx77LFccMEFnHrqqQwePJgzzjiD1atXM3z4cAAGDhzI1772Naqqqthrr7049dRTOffccxk1ahQvv/xy3HEhXnnlFQ455BCGDRvGaaedxgUXXMDRRx/NQQcdRGtrK7fcckt0Vo/k5GSefvppRo8ezU033cSIESM47rjjuOCCCzjhhBMYNGgQhx12WDSJ0pm2R0PakhIdmT59OgMHDmT+/PnMmzeve2/ibtZbx7TAOfcPMzse+AqwwMzexOup8AUgDPzJOfdYTP3PzexavOTA62b2EtAIHO+3+65zbkm7czSZ2YXAHOAuM/si3rgShwODgceBB+OEdxVwMHAO8JmZvQdMAaYCi4HvxWnzF+Bk4Cy/zb/xHlk5EqgHLnTO9ctnI4ZedSPNV95CcisUVMOmCy/m/bMO5Nwb4731IiIiIiIiXXfooYeyZMkS/vjHP/Lss8/y8ccfU15eTlZWFhMnTuTyyy/nsssu2+pxkD/84Q9MmjSJ++67j3//+9/k5uZy7LHHcvvtt3P//dvOFXHJJZeQnJzMa6+9xty5c6msrGTQoEGcfPLJXHnllUyfPn2r+uPHj+fDDz/kt7/9LU8++SRvv/02zc3NDBo0iH322YfTTz+d8847r9Prqqqq4plnngG8qU07k5SUxLnnnsvvfvc7/va3v7H33nt38d3b/az9iKa9iZkZcBnwTWAPwOGN+/BH51zcb7RmdhreVKhtY1t8CMx0zj3XyXmmALcAR+HN5LEUuA+4xznX2kGbAuBm4EygGNiI13PjJ/4YG/HaJAFXAl8FxgK1wH/8Ngs6iq+rzOzTyZMnT257Fqs3eeTSQ9nzra27WX02IYWpt9/L+GlfCCgqEREREZHE19rayueffw54A0GGQr25w70kgu78m5oyZQoLFixY0NEsl9vTq5MW0j29OWnR1NjAk1efwqRX15Ia09+kOh1WnL4v5/z4QZK6ONqviIiIiEh/oqSF7Go9mbTQv1bpFVJSw3zxd3NovPNHrBxq0fLsepj2yAf85+hpPP/bq4nU1QQYpYiIiIiIiOxKSlpIr3LAiRcy/f8+5OMTRtIQMzlsYQUcvv4B6mdO4q0/focNq5d0+BoiIiIiIiLSOyhpIb1OSmqYL97zAu6e21gyyptZZP3EJrJTWsmnmkPW/5WiPx/AR788jnefuZeS9SsDjlhERERERER2hJIW0mvtc8wMTnthPhW/vJrU/fakzoWjx5Ktlb3q51L05o9Ze/yJPHX6njzxs69SUbYxwIhFRERERESkOzRyofR6h5zxDTjjG1SWl/DO7N8xfOk/GOK85MSC9dmMaYJJi5pg0Vsse/goVo5KpnHPyRx04XWMmrRfwNGLiIiIiIhIR5S0kD4jN38AB114My3NN/Lp27Ope/8Rkl7/YKs66Y0waVEzLPqYmicuZPawEFWThjD+rG+w/zHnBhS5iIiIiIiIxKOkhfQ5ScnJTDnsDDjsDGou3sycP/4Q99bbjF7WRLgppp6DMatbYfUaeOkmXi66iU3j8yk4+lSOPv8aUlLDHZ9EREREREREdjslLaRPy8ov4swb/h8A5SVrefUvt9L83lyGLY2QW7d13cGbYfDmcnjrb7x3z99YOzoN9t6LQy66nqEj9wggehERERERkf5NSQvpN/IHDOXM6/8IQFNjA//5x0zK//M8A5dUMKh067p5tZA3PwLz36HsH2fz7rgkimecTfF+pzJ6j/2xkMawFRERERER2d2UtJB+KSU1zPGX/Bgu+TEA7730EEue/gu5n61nxDpHyG2pm9wKKckNHLLsHlh2DxsoYkXBoaROOp7xB59Cdk5+QFchIiIiIiLStylpIQLsf9wF7H/cBQCsWPAu7/7jTpLmf8bwFY1kRaCgOBKtO4jNDCqbBW/O4uN/Xcfqj/KpmjCYESeez8EnXUJSsn6sREREREREdgV9uxJpZ9TkAxj100cAaKiv49VHfkVa3QaWlL3NuOYlW9VdXZLmD+a5Fv79K9667VesG51O8r4HcPhFNzBgyOggLkFERERERKRPUNJCpBPh9AzvMRJf6cbVLH9rFrZ0DuOr55K0JnWr+oVVUPhRPXz0Guv++hrvDAtRNWEoo06+gIOOu0C9MERERERERLpBowmKdENh8XD2P/N/2O+ap8m8cSWhC77Exwfns3bgtnVTW2Dsylb2eWk1+Vf/gjcOm8aj5+/HE7/4OutXL9m2gYiIiIiIBKK2tpa77rqLo48+muLiYlJTU8nPz+eQQw7hpptuYtWqVUGHuMMeeOABzGybJSMjg8mTJ3PddddRVlYWdJgdMufc9mtJn2Bmn06ePHnyp59+GnQofdLn77/MR4/9ltRPFzN8ZTMZjR3XbQ7B6iFG5diBDDzyVI6Y8R1SUsM9F6yIiIiI9Butra18/vnnAEycOJGQZsLbyptvvsk555zDhg0byMjI4OCDD6a4uJjKykreffddSkpKCIfDPPfccxx77LFBh9ttDzzwAJdeeiljx47lsMMOA8A5x/r163n77beprq5m5MiRvP322wwaNKhLr9mdf1NTpkxhwYIFC5xzU3YkfvVVF9lFJu53DBP3OwaA+upKXv3HTKre+DeFyysZUrJ13eRWGL3GwZqN8Op9vHrvfeSeMZnWsccw5qDTGDB4RABXICIiIiLSv8ybN4/p06cTiUS4/vrr+fGPf0xmZmb0eGtrK08//TTXXXcda9asCTDSnXfYYYfxwAMPbFVWUlLCUUcdxYIFC/jZz37Gb37zm2CC64SSFiK7QXp2Lid+83b45u0ALHjnReY/8XtSFy5j2KpmMhu2rt9Y1MwB1XNg3hyY90OWhMawaeChZEw6htF7HkZuQZznT0REREREZIc557jooouIRCLcfPPN/OQnP9mmTigU4uyzz2b69OmsXr06gCh3rwEDBnDNNdfwta99jddeey3ocOJSvyCRHjD5oBM4b+Ysznz2E6a99S5rbvgyHx9ayKrBRqtBXsyUqgDjWpfxhQ1/I/nZK1h+5JE8c9JU/vHdE3jj+QdpaW4O6CpERERERPqOF154gfnz5zNs2DB+9KMfdVo3NzeXqVOnRvfXr1/PzJkzOfLIIxk6dCipqakMGjSIs88+m3fffTfua5SUlHDDDTcwefJksrKyyM3NZcKECVx88cXMnTt3m/plZWX84Ac/YPLkyaSnp5Obm8sxxxzDc889t3MX3s7Agd4fSJsT9HuGelqI9LBwRhbHXfJj8GclWbPsE2o++S/vrnyDEeVvUew2R+uu2pzB6CYYv7wFlq+Cf/2CN3N/wYYR6diee3LQBdcyfMwOPRomIiIiItKvzZ49G4Bzzz2X5G7O8jdr1iyuv/56Jk6cyJ577klOTg6LFy/mqaee4rnnnuO5557j+OOPj9avrq7moIMOYvny5QwfPpzjjjuO5ORkVq1axcMPP8yYMWM48MADo/UXLVrEsccey+rVqxk1ahQnnHAC1dXVvP3225x22mnccccdfP/7398l78N7770HwB577LFLXm9XU9JCJGDDxkxj2JhpwLdwra2sXvwR699/jvTVr8KGbZ+bK6qEok/q4ZN3qPzHDD4dbJSPyifnoKM54vxryM7N7/mLEBEREZHezTmIVAYdRfek5YLZDjefN28eAPvuu2+32x566KHMnz+fKVO2/gPiiy++yOmnn84VV1zB4sWLMT++xx9/nOXLl3P66afz1FNPbTVwZUlJCRs3bozut7S0MGPGDFavXs3MmTO55pprovWXLFnC8ccfzw033MCJJ564Ve+P7nDOsXHjRp599llmzpxJOBzmmmuu2aHX2t2UtBBJIBYKMXziPgyfuA/wY0Z+fQOvPXQHtXP/S9GKqm0G9ExyMHKdY+S6MnjzCRb/7gnWDE2iZtxghhx1Joed/k2SU/RjLiIiIiLbEamEX44MOoruuX4lpOftcPPS0lLAG9ehu6ZNmxa3/IQTTuDcc8/loYceYv78+dF6JSXeB/ljjjnm/7N332FSFOkDx781eXNO5AyyigQRBCNBUBQDyqmoh4qK4fRMeEZQzwRmUc7zTPfT01NPQEBREEFEEUSRHBYWWNLmvDux6/fHDMOy7MIszAIL7+d5+ump7qrqt0eE7Xerq/ZbaSMlJWWfGGbMmMHKlSsZMWIEDzzwwD51O3TowIsvvsjll1/O22+/zauvvhpyzB988AEffPDBfsd79+7NG2+8Qe/evUPu60iSpxkhjmGxielc9JcXg+X1y+ax4vM3sKzZSPNtHmKq960f4d7zKsl2mDOZX5+ZzM6WNtyd29H/lqdp2b7rEb4DIYQQJwLD58Pn8eL1+TA8PrweD4bXwOfz+j97/J99bi8+nw/D68OHwmjRCkNrfIbGa+jgZ7XyD4zqarTPi+HxYRg+tNeH4fWiDcP/2edFe33+ss9HVUoGRV2640Ph0xrD0ETYLFzRswVxkdaj/RUJIY5DLpeL2bNns2TJEvLz83G73QCsXLkSgI0bNwaTFr169QJg0qRJpKWlMWzYMGJiYurs99tvvwXg8ssvr/P8WWedBVDnPBgHUnPJU4Di4mJWrlzJ0qVLefDBB/nvf/97SAmcxiZJCyGakJrLqnrcLn787FVyF35NzKY8Wuw0sPn2rR9XCXHr3BTtXEsLxxlsMzVjR2IfrB0G0OH0ocQnyaokQgjRUFprDK8Pr8eL1+3B6/X6H9g9Xnw+AyMhEZ9P4zWM4MO4z9D4NqzHqK7G5/FieL34vF4Mry+weTC8PrTXi+Hxon2BB3SvF8PnQ/v8D+34vLgtDracfWGw3717g1Nmf4y9vATl80FgU4YPFdhjGCjDwLTnuPaX/Zu/bDIMyiJieenCv+Iz/A//NRMKz856jtTKQsyGgUkbmLTGhG7w95gbEc/oIY/Wee69b58mvaq4wX1uiG/B2ydfzKrk9sFj/126jU9vPYP4SFuD+xNCHN+SkpKAvaMgGmLlypUMHz6cLVu21FunvLw8+HngwIHcc889vPLKK1x99dVYLBZ69uzJ4MGDufHGG2nXrl2w7p4+R40axahRo+rtv6CgoN5zdalryVPDMHjyySd54oknGDFixDG5gogkLYRooqw2O+eNGgejxgFQWrCTHz9+kcqli0jYWkazXB1cHqi0uQ+loJXeSavCqVA4Fd9ixRpLe/7IthPZrTdnXHUvqelNbEigEOKYo7XG8Hhxezx4Xf7N43b79x4PXrcHn9sd2Hv8D/puDz6lqO6Uidfnf0D2GgZen8bjM4j+6XtUeVngod7jf6j3eiHwUL/nMz4vyuv1P6j7fMGyMvwP79WOKL688Ba8vr0P+Xse+m+a8QqJZYWBh3Yfpj0P5IHP5sBnszawaKPe+8+LiOfP9TyIv/vtM2RUFR32d5wfEce93k51nntn6Q80qyw87GtYnNVsLayq85zV6ybC6z7sa5gP8D0a6tAWuOtUsp1JP07hp4yTeSdzGDujU9iQW8FNH/zKhzf1IcJmPtRwhTj+OeL8r1s0JY64w2revXt3Fi1axG+//ca1114bcjutNSNHjmTLli2MHTuWsWPH0q5dO6Kjo1FK8fDDD/Pss8+i9b4J3Zdeeolbb72V6dOnM3fuXBYtWsSSJUuYOHEiH3/8MSNGjAD8iQSAoUOHkpaWVm8cycnJh3DX+zKZTIwfP54pU6awcOFCli9fTvfu3Q+733CSpIUQx4m45GYMq/EqSc76ZSz99HWMlSuIT63er75ZaXwlO+j+UwL89C25//yWZRmKklYJRPXqR/+r/kpScvMjeQtCiACPx4vH5cHldOFxuvC4XHicHjxOF16XG4/LhdftweNy49VQ3TETj8/A7TPw+DRen4HH0MQvnIOprBTt9aA9HvB4weMBrwc8HrTPh/IFHvi93uCDvmnPb+gDnyvtkbw37C94fIY/obDnOobB4zMnkVaej9nwYTZ8WLXv4DcIKPw/hOz5QaTAEcvooY/XWfedOf8My4N4oSOWhRvr/q1UbFEeaZUN+41VXQ70IO4zheeB2WyE/2G/NlMjJBQADBSGUhjKhNdsIdpuwaTAbFKYTSbMJjArRUlcCmaLGUOZ0MqENpkwTGa0aW9Z7ymbTNi8blpu3xC8Tr9dq+iTu5ZPOg7gw5OGsGxrMbd/tIx/Xn8aVnN4viMhjjtKHdb8EE3RsGHDeOONN/jss8+YOHFiyCuIrFu3jnXr1nHaaacxZcqU/c5v3ry53radO3dm3LhxjBs3DqfTyeTJk3nggQe47bbbgkmLFi1aADBmzJjgscaklKJ169bk5eWxceNGSVoIIY6Mlp170fKx94PlvG3r2bZsNqbs+bQt+5UEysgpiKRt4LzFgDY7NOwogp9nsn3KTH7JUJS0TiS299mcddW9xMUffjZXiGOBYRi43R48mHB5DdxeI7h3ew0869biLSv3JwecLnwuN4bTieF2BzftdqPdnhoJAY//N/4ej/+3/V4PLoudry+4yZ9Q8Bp4Ag/7Hp/BzTNeIaU0L/iwb/Z5sRg+LIb3gL/JB7AGtgj8D+Jj6nnYf3vOB7QIw4N4kT2GlTvqnlHe6q4myrN/YrShDvSw71XhetivP6HiC9PDfs1rWM0Ks0lhMZkwmxSVETEU+1xo5X8AN0x797rGfu9mQpv9e8yBY2YznohoruzVAkuN/k1KYTErSvQwnNWVYDajLGb/3mxGmS0oy/6fTXuOWcyYAnVNZjPK4eD/uvfCrBQmk8Ji8u/NSmG+5HXQBiazGbPFjMliwWyxYLbWKlvMmK3+z5Y9n82m4Ez6AKvq+yIfGtjg777qt9/Je/55qv/4I/jfomOHZsHz36/PZ9znK3jxylMxmQ59tQEhxPFj6NChZGZmsnr1ap5++mnGjx9fb92ysjJycnLIzMykuNj/+tqe5EJNxcXFzJkzJ6TrOxwO7r//fl566SV27dpFXl4eqampDB48mHfeeYepU6cekaSFYRjBV1Kio6Mb/XoNJUkLIU4Qqa06k9qqM3A32vCxde2vVPznObLyNtJ8h4+IWiN9bT5ou13D9kJYNJXsyVPZ3sxEWZtk4k4/j7OuuJvYeFleVTSc1hqX00V1pRNXRRXOymqcFVW4q6pwV1bjdTrxeA3KM3vg8vr2SSi4vAYZc6ZhKS4At9ufKPC4UR4Pyu1GeT2YvB5MHg8mnwez14PZ68Xi8/iTAj4vVp8Hq+GjxB7NqAvq/uHk7bnP06Ki4e+31lZii2Je24vrPBdVVkRKRRiG8Rvees95w/SbfcsBHvYbeg2fMuFVJnwmMz6TGSOwr3BE0zY5CotJYTGbsJpV8HNh2y54K9L8D/BmC9psBrMFLHv2gc1sBosFZbGAxYraU7ZaUGYLOBw8c84pWEyBh/3gQ7/C0ethijxu/4O41eJ/8LZaMFn3PJD79yarBYvVitlqxmK1YLZaA3v/8XZWC5sd9rofisef39Cvvl71/gh74Ulhu0a9WsY3/jUOQWTPHrT+5GPKv/6avBdeBKuFUU/fw8+frWL26t0ATP19B4lRNh4ddtI+yRMhxIlJKcWHH37IGWecwYQJE3A6nTz66KNERUUF62itmTFjBvfffz8PP/wwmZmZdOjQAZPJxLx589i4cSMdO3YEwOl0MnbsWIqK9n8VcNq0aaSnp9O3b999ji9btozc3Fyio6OJj48HYMSIEXTt2pWPPvooODLDbrfvE9NPP/0E+JdePRyGYfDEE0+Qn59PbGzsYffXGCRpIcQJSJnMtM7sQ+unpwLgrCrnp/9NJv+nOURtzqX5TgOHZ982di+032bAtjz44b9kvfZfdjQzUd4mlbje53DWCEliNGUer4+qiiqqyiqoLqvEVVmJu7wKd2UlnooqvFXVeKur8VY78RianH7n4/T4cHoMnB4fLq//8+kz3yOmMBeTx4XZ48bk8WDxurF43Vi9Hmw+/1bXb9X3jB4AKLVFcfuFT9QZ65TvZtKmPLfOcw1hPcDDvtsUnn8ew/mwD4EHfpMZr8mCz2TGa7ZQbY+ic1oMVov/N+42syn4QF6Y0w1veRHaYkFbrOjAw7wOPOSrGntl9T/km6zWYNlk8ZdNEQ7e6NsTs0n5kwlmE9Y9yYULJuE1DCx2Kxab1f8Qb7ditfnLFpsNq92K1Wbznz/A0Pwh9Z249YwGf1cNdnJG419DNDqlFLEXXkj0wIF4duzE4rDzylXdueG9pfy82Z8kfOfHbJKibdx+boejHK0Q4ljQvXt35s6dy4gRI3juued47bXXOOOMM0hLS6O0tJRff/2V3NxcHA4HLVu2BCA1NZWbbrqJt99+m1NPPZUBAwYQERHBwoUL8fl8jB49er8JL+fPn8+rr75K8+bN6dGjB7GxsezcuZOFCxcGEwc2m3/CYIvFwrRp0xgyZAiPP/44kydPplu3bqSmplJQUMDy5cvJy8vj5ZdfblCS4ccff2T06NHBcklJCStWrCA7Oxuz2cw//vEPYmNjD/s7DTdJWgghcETGMOC6h+C6hwCoKi9l0eevUPTzPKK3FPhXJqn1fBfhhg5bDNiyG+b/l4INb7EltiOlqb2J6ng27XucS1zc4U2OJPbl8xn+xEJJOdUlZVSXleEsq8Rd4d88lVW4PT62n34e1W4flW4f1W4vVW4fVR4f/Wa+S3z+TixuJxa3C6vHhc3rnPdvZwAA0iVJREFUwub1YPe695v93xbYaquwOLijtFWdMQ5cv4r2ZTsP+14PlFDwhCmhUPsaZpPCbjFhs5ioiI6nyOfEa7HiM1vwWawYZiuGxYLPagsmALTVBoGEgLJawWr1/1bf6i8rRwRPnJ+JNTBywGYxBT6biDzjEcq9bix2GxabHYvdhtVhxWK3Y7XbsDr8e7vDjtXhf+A31fOu7aD6bvKmPmH5rg6obWLjX0OIBjLZ7djb+V+AdFjN/PP6Xlz99mJW7SgDYNI36zmnUwqZzeTfKSGEf7RCVlYWb731FjNmzGDFihUUFxcTHR1N586dGTt2LGPGjNnndZApU6bQpUsX3nnnHb777jvi4uIYNGgQTz/9NO+9995+1xg9ejQWi4UffviBJUuWUFpaSnp6OhdeeCF33303Awfu+1pcx44d+f3335k8eTJffPEFixcvxuv1kp6eTo8ePRg+fDgjR45s0H1u2rSJTZs2Bcs2m42MjAyuvfZa7rnnHnr27NnAb+7IULVnNBXHL6XU6q5du3ZdvXr10Q5FNDEVJfks+uwVSn75gdgthTTfpbHW+AVyUYym/7Bd+7RxazNZlo4sL4jG1qwjPS67g/adTjnCkR8bXFXVlOcXU1lWQUVSGhVOLxUu/1Ye+Jz07XRsu3egqypR1VWYq6uwuJxYXNXY3dXY3S4ivc4DvvcPUG22cfnFz9R57tX5r9CpZPth34/HZGb48OfrPPfSgtc5qbjhM497TGY8Zqt/s9hw2xy8cvUEbBZTMJHg35s5fdF0YsqLUDYbWG0omw2TzYay2zHb/Z/NDhtmuwOL3Y7ZYcfisGGNcGB12LFFOLA57NgiI4holo7dYsZm8Y9OEEIcvwoqXIyY8lNwVZSBXVJ5Z3TvoxyVEEeGYRisX78e8E8EaTLJhLTi8DTkz1RmZiZr1qxZo7XOPJRryUgLIcRBRcenMOTmp+Fmf7msYBeLPn2ZsqWLiM0pxhe7/xB4m/LRybuOygXNiHbuxPneAuamQmHzKHSXrnQZdhOn9jq7SbxTbBgG1cVlFOcVUl5QTEV+MVVFRbiKy3CXluAtK0eXlaEqyjFVVmCtrsDurCLCWUWkuwpb4Df6LpOFS4c/V+c1XlrwLZ0O4WG/NrvPA1r7ZwCvxWWua9xE3dwmCy6LDbfVjsdix2O14bPaMKw2DJuNCzLTcNgsOKwmHFazf7OYIflPbKkux+xwYIlwYHY4sEVFYI1wYIuMxBYVgT3SgT06EkdkJI7oCBxREXWOIKh3Gr6re4R8H0IIsUdytJ3Hz2rGTdOyAPhuXR7LthbTq7W82iiEEMcySVoIIRosNjmDC26fGCx7XdVsWvkjRWvnE7nzF9pUryQKJxurHEQ7/XVMQPM8aJ5XCb8vhY+XsiAR8po58LRrQ8ZZl3HG+VcRYQ/9wfpQ+XwGRbvyKdy2k7KduVTkFVBVVMLq0wZRWOGiqNJDabWbkioPJdUeHp71Al2K9iYUogNbQ9kNL2bDV+eyh9UWex0t6megqLbacQUSCl6rHa/Njs9m5/zOyTgi7ETZzURYLUTazETazdhbjGJ7dQWWqEhs0ZHYoqL8yYOYKCJio4mIiSYyLhpHdGS9ryHsUffUksCgjg26DyGEOBKca9aQ9/IrtMraSK9Lx7NsVyUAL3yzno9v6XuQ1kIIIY4mSVoIIQ6bxR5B+9MG0/60wQBon4ectUvInvM+3vaLydjhDSYvakorgrQiJ6xaB18+yx8TnmV3upmyVik4TunPyUPG0Llt6wYN26+qcrFzcw4Fm3Mo2baTqp278OblYioswFFSSHRFMfGVJdgDox9iAhvAX8ta4q1jvoRya0RDv5I6+VAkm32YYqOItluIdliItluIcVhwefuzsaQDKioKS3Q0lugorDHR2GNjccRF44iPJTIuFkd8DFHxsUTERNc7oeGw+gKQSeeEECcgb3ExW666Gu32L5P1kHs1V9AGgJ83F7Ioq4D+HWRJbyGEOFZJ0kIIEXbKbKXlyf1peXJ/uAcMj4ff53xA9nfTsGRtI22Hh/iK/dvFVULcJh9s2g3f/w/3m/9jdpqiMCOK6lP6U93lSlz2JMzKv0yhSSkifv0J+/pVROzeTmLhLlLLC7BqH3FAQ6dXi3VVUhSxf6tS295lr6osdqrtkbgcUbgjovBFRqOjoyEmFnNsLNa4OGzxsdgT4nEkxBGZGE9UciLRSXFEx8bwS30rJ4zq1cBohRBChMKSkED8yJEUf/ghALFffMTZo/7OD9urAf+knP3aJzWJ1xWFEOJEJEkLIUSjM1mt9LpwDL0uHAOA4fOxbtE01n39H8jaTOIOJ2n7L2eNzQvtdmja7aggN2Iq51a/R7aRxjLdmWVGR341OnPlL99x+s6VhxSXy2ShPCKW6qgYPNFxXHJKGhEtmpMYZSM+0kZ8hJX4SCtx7lOIjbARn5KI3dH4r68IIYQIr+Sxt1LyxRfoqip8xcXcV/obP3ASAMtzSvhubR6DuqYd5SiFEELURZIWQogjzmQ20/XsEXQ9e0TwWF7Wcn6b/k8qVvxOTE4pGbn7rlDSNt4/23tbUy5tyeUK8w8AfJuaCjvreKXDHk1FTALuhCR0UgqWtDTsGWlENW9GXMtmJLdtQWxK4j4zHdf7WgWypKMQQjRlluRkEv98PYVT/gGA438fc9FNE5mZ43938YVv1zOgSyomWUVICCGOOZK0EEIcE1I7dGfofW8Gy+6KYtbMfodtC+egtu3m7LhY8Bbs1+6PVprNXsXORMXOJNiZpLDEQJfoKE5N7MAprc6lS4cLsdkPZepMIYQQx4ukG2+k5D8f4ystxaiq4vZt85mp/JNwrttdzsyVuxh+arOjHKUQQojalNb6aMcgjhCl1OquXbt2Xb169dEORYiG0xpKtkHOEshZDNt+QeetZkCLDAos+6/GUZNVa07SNrpFt+CU1B50a38hzZv1Rska5UIIcUIpfP998p573l+wWPjwluf4aKe/2DY5ijn3nI2lvrmHhGjCDMNg/fr1AHTu3HmfkaZCHIqG/JnKzMxkzZo1a7TWmYdyLRlpIYRoGpSChNb+rduV/mPVpTy/9lNW7PiRFcUbWeEto9C8/9Bej1KsUB5WVGXDlmzY8gWJhqabOZaT49qT2ex0MjsMIyGh3RG+KSGEEEdSwjXXUPzhR3i2bwevl+tWzeLjpGEYGrILKvl82XauOr3V0Q5TCCFEDZK0EEI0WSoijtN73szpPW8GQBsGu3YtY8Wmr1iRu4yVFdtZo9y465gRvsikmK/LmV+yHEqW03b5G3xZaYNmPaB5T/8+41RwNHQNEiGEEMcqk81Gyj1/Zed99wOgf/iesWPO5c0C/ypRL8/dwCXdmxNhO/AIPiGEEEeOJC2EEMcNZTLRrHlvmjXvzdDAMY+rkg2bv2bF1u9ZUbiGla4Cttbxs+jJLjeU7IKSrbBmWvC4J6kDjyfGclJCJzJb9Oek9hcQGZVyRO5HCCFE+MVeeCFF73+Ac6V/5alLFv+Pf3X+M26fJrfMxbuLsrnjvA5HOUohhBB7SNJCCHFcs9qjyDzpCjJPuoKrA8dKijazcuMMVuz8mdVlW1htVJDpdtXZfmP5VmbGZjAzvwDyf0L9NpF22kymPYXMxC50bXkmndoOJjIy6cjdlBBCiEOmlCJt3ANsve56AIxVK3i41y4mlKYDMGX+Jq7q3ZKkaPvRDFMIIUSAJC2EECec+MR2nNXnbs7ibsD/WomvZCvsXgE7f4cdv8HO5eAqZbXdtk9brRSblMEmTy5f5uZC7gJMS/9Oa23iJFsiJ8V3pEtGb05qN4S4+NZH4e6EEEIcTGTv3kQPGEDFvHkA9Jv3KYln3E2RW1Ph8vL6vCwmDD+k+eKEEEKEmSQthBAnPGUyYUlsC4ltoesl/oOGAcXZdNk4k9E537OqMoc12kWVaf/5MQylyFaabG8hXxUUQsFiWPk6zXzQxRpLl9i2dE3vRfcOw4hL6nSE704IIURdUu+/j4oFC8Dnw5ezjSf7b+BOOgLw0S9buaF/G1onRR3lKIUQR0plZSVvvfUWM2bMYM2aNRQXFxMVFUWXLl0YPHgwY8aMoVWrpj9R75o1a5gyZQrff/89OTk5OJ1OkpOT6dWrF1dccQVXXXUVNpvt4B0dQbLk6QlEljwV4vAYPg9btv7A6i1zWV2wktWVO1mPm+o6Ehl1eTk3n0EqBjK6QXo3/0Sf6adAQluQpceEEOKI2zVhAiWf/BcAU3w8d1z4KFlV/nMXdctg8jU9j2J0QoSPLHl6YD/99BMjRoxg9+7dREZG0rdvX9LS0igtLWXp0qXk5+djt9uZOXMmgwYNOtrhHhKtNY8//jjPPvssPp+PVq1a0aNHDyIiIsjJyWHJkiV4PB7atWvHpk2bDtqfLHkqhBDHIJPZSrt2A2nXbiAXB475vG62blvIum0LWFewgrWVO1hrVFFax1/cXdxu8OZB1lz/FvBWYhILYuLo5EihY0InOmecRsc2A4mLa3mE7kwIIU5MKXfeSdmXMzCqqjBKShhf8SvXmU4DYOaKXdx8Vgmntow/ukEKIRrV8uXLGThwIE6nkwcffJDHHnuMqKi9o6wMw2DatGmMGzeO7du3H8VID8/DDz/Mc889R1paGu+++y4XXnjhPueLi4t54YUXmDRp0lGKsH4y0uIEIiMthDgytGGwe9cy1m6dx7rc31lbvpXtnnK+yMmhrjEZd6Sl8ENkxH7H032azpYYOkW3pFPyyXRqeSatWvbHYpHJ4YQQIlzy33yTgtdeB0DZ7Twx8gl+Lvf/Xq9vu0Q+vrkvqo6ls4VoSmSkRd201nTr1o1Vq1YxYcIExo8fX2/d0tJScnJyOPnkk49ghOGxZMkS+vbti8PhYNmyZZx00kn11l20aBH9+/c/aJ8y0kIIIZowZTKR0bw3Gc17M6DmiYp82P0H7Frhn/Rz1x9QlM0Gm7XOfnabFbt1BQvK10L5Wsj+DLuhaY+FTo5kOsV1oGNaTzq0PpukxE4o+QFECCEaLGn0aEo+/gRvfj6RvXpxR/9W/Dx7JwCLNxcxf30+53VJPcpRCiEaw+zZs1m1ahUtWrTgkUceOWDduLg44uLiguVdu3bxf//3f8yaNYusrCzy8/NJTEykX79+PPTQQ/Tu3Xu/PvLz83nxxRf58ssv2bZtG2azmbS0NPr27cudd97J6aefvk/9oqIiJk2axPTp08nOzsZms9GrVy/uvfdeLrroopDv88UXX0RrzV133XXAhAUQUsLiSJOkhRBCHCnRKdBhkH/bw13Jy1mzWL9jMRuK17OhKpf12kl5PfNkuEyKNfhY486F/FzIXwSrXifO0GSqCP6RfBYqrSuknASpJ0Fk4hG6OSGEaJpMkZGkj38cZXcQfdaZtALOzHLzY1YBAM99vY6zO6VgDnH+IiFE0zFr1iwArrzySiyWhj0aT58+nQcffJDOnTvTrVs3YmNj2bhxI1OnTmXmzJnMnDmT888/P1i/vLycPn36kJ2dTcuWLRk8eDAWi4Vt27bxySef0K5du32SFhs2bGDQoEHk5OTQpk0bhgwZQnl5OYsXL+biiy9m0qRJ3H///QeN0zAMZs+eDcA111zToHs8VkjSQgghjiZbFCd3HcnJXUcGD2nDIDd3ORu2LmB93u9sKNvCBncJW0wGRj1DlEtNiiJXGerXd/Y9EZ0GqScxJdJMclwbOmacRvtW5xAT27wx70oIIZqUmFoT6/3tgi5c9PqPAKzPLed/v21n5Gkyz5A4Mbh8Llw+V1j6irREYjHt/8h5uNewm+3YzYf/uuzy5csB6Nmz4ZPu9u/fn1WrVpGZue8bD9988w3Dhw/n9ttvZ+PGjcHXyz7//HOys7MZPnw4U6dO3ed1ivz8fHJzc4Nln8/HFVdcQU5ODhMnTuS+++4L1s/KyuL888/nb3/7G0OHDj3o6yqbN2+mrKwMu92+X6xNhSQthBDiGKNMJtIzepKe0ZOzaxx3Vhezacs8Nuz4hQ1F69hQtZMsw0mR2f+PYQePZ//OKnKprsxjSusW6MqNsHMOLHuWNJ+mgzmKtpFptIvvQNvUbrRt0Z/EhPbymokQ4oR3cvM4Lu3ejGnL/a+JvPTtBoaf2gyH1XyUIxOi8b2z8h2m/DElLH29O+Rdeqfv/5rE4V7jtlNv4/butx9OaAAUFhYCkJKS0uC2p5xySp3HhwwZwpVXXslHH33EqlWrgvXy8/MBGDBgwH7zP6SkpOwTw4wZM1i5ciUjRozggQce2Kduhw4dePHFF7n88st5++23efXVVw8Y5557TEhIwGxumn+HSdJCCCGaCEdEApknjSDzpBH7HC8uzCJr2wKiynZBWQHkr4O8NeAsBSDbakHXGqGRa1bkUsWiqmyoyvYnM5a/SKyhaadstLUn0TamFW2TM2mb0ZvmzU+XCUCFECeU+87vzFcrd+P2Gewuc/LuomxuP7fD0Q5LCHEMcblczJ49myVLlpCfn4/b7QZg5cqVAGzcuDGYtOjVqxcAkyZNIi0tjWHDhhETE1Nnv99++y0Al19+eZ3nzzrrLMA/weaJQJIWQgjRxCUkdaB3Uq0fpLWG8t2QvxZHzk+M2LWALGcBWXioPMB72WUmxXI8LHfvhsLdULgE1r+HVWtaazNX2DMYlX4mJHeC5I6Q1BHs0Y18h0IIceS1SIhgbOcIXltTCcCU7zdxVe9WJEbZjnJkQohwSUpKAvaOgmiIlStXMnz4cLZs2VJvnfLy8uDngQMHcs899/DKK69w9dVXY7FY6NmzJ4MHD+bGG2+kXbt2wbp7+hw1ahSjRo2qt/+CgoKDxrnnHouLi/H5fE1ytIUkLYQQ4nikFMRmQGwG7doPYAKPAnvmy/idrG2L2JT/B9nl28h2FbJZuyg5wGshHqXIUgaVuathw8/7noxtwZak1vzHYaJtXBvapJxMq4zTSE89FbOl7pVRhBDiWFa1dCm5EycxbPdu/nPOAxR4TZS7vEyel8XjF3c92uEJ0ahuOuUmru16bVj6irRENso1wjGfBUD37t1ZtGgRv/32G9deG3o8WmtGjhzJli1bGDt2LGPHjqVdu3ZER0ejlOLhhx/m2WefRWu9T7uXXnqJW2+9lenTpzN37lwWLVrEkiVLmDhxIh9//DEjRvhH0xqGAcDQoUNJS0urN47k5OSDxtquXTtiY2MpKytj9erVdOvWLeT7PFZI0kIIIU4g/vkyepGe0Ysza57QmuLizWTn/Eh23h9kl2xic1Uu2b5Kdph08PWSdnXNm1G2ndW+Ij5OTQbnVshdAKvAqjUttYlW5mhaRaTQOq4NrZIyaZXRk/S07pjM8k+QEOLY4y0qYttNY9CBYd5PelZyuzoVgP9bvIUb+rehZWLdD2JCHA/CNcnl0b5GKIYNG8Ybb7zBZ599xsSJE0NeQWTdunWsW7eO0047jSlT9p+bY/PmzfW27dy5M+PGjWPcuHE4nU4mT57MAw88wG233RZMWrRo0QKAMWPGBI8dKpPJxNChQ/n000/5z3/+I0kLIYQQTZRSJCS2JyGxPbXnz3Y5S9ia8xPZu3+lewsfFOdAwQYoyAJvNQDZ1v1HVHiUYrPSbNblUFUOVZth1zxYBTataWmYaGmNoXVECq1i29I6uSutMnqRltpNEhpCiKPGkphIwnXXUvTOuwC0m/M/Ol90EuvdNjw+zQvfrufVq3oc5SiFEOEwdOhQMjMzWb16NU8//TTjx4+vt25ZWRk5OTlkZmZSXFwM7E0u1FRcXMycOXNCur7D4eD+++/npZdeYteuXeTl5ZGamsrgwYN55513mDp16mEnLQDuvfdePvvsM1577TX+/Oc/c9JJJ9Vb96effqJfv36Hfc1wkinihRBCHJDdEU+njhcy5KzHSR74BFzxLoz9ER7eCX9dCaP+R7fMqxlpb85p2k6qTx+0T7dSbDJr5htlfFC5iad2zWXMytc4/9s/88PL7eDNM+CTUfDtY7Dsfcj+gaqCDXi94VmCTQghDiT5llswx8cDoKuqGJ/3Q/Dc9OU7Wbm99ChFJoQIJ6UUH374IQ6HgwkTJvDQQw9RWVm5Tx2tNV9++SWnnXYaS5cuBfwreJhMJubNm8fGjRuDdZ1OJ2PHjqWoqGi/a02bNo3Fixfvd3zZsmXk5uYSHR1NfODvnREjRtC1a1c++ugjnnrqKVyufX/+0VqzaNEiFi1aFNJ99unTh3HjxlFdXc2AAQP46quv9qtTWlrK+PHjOe+880Lq80iSX2UJIYQ4NCYTxLeC+Fac3XHQPsuzVlUVkLPjF7blLmdb8Ua2Vexgq6uIHMNFnrn+iUABWrkqoWKNfwWUGqYkxPNhXAzphqK5OYIWtnhaRDWjeXwbWiRl0jyjJwnxbWXJViHEYTPHxZF8553k/v3vACQs+IYBI05jnjcegGe/XstHY/qg1IH/PhNCHPu6d+/O3LlzGTFiBM899xyvvfYaZ5xxBmlpaZSWlvLrr7+Sm5uLw+GgZcuWAKSmpnLTTTfx9ttvc+qppzJgwAAiIiJYuHAhPp+P0aNH8/777+9znfnz5/Pqq6/SvHlzevToQWxsLDt37mThwoUYhsETTzyBzeaf6NdisTBt2jSGDBnC448/zuTJk+nWrRupqakUFBSwfPly8vLyePnll+nfv39I9/nss89isVh49tlnGTZsGK1bt6ZHjx5ERESwfft2fvnlF9xuNx07dgzr9xsOqvbkIOL4pZRa3bVr166rV68+2qEIIU5gVZX55OxYzNbcP/YmNNzFbDNcFJtg6ZYc6pq+857UZOZGHfg98khD0xwzzc1RtIhIpkV0C1okdKB5yik0z+hFRGRi49yUEOK4oz0eNl9yKe7Au+nuU3pwSbtr/BMdA++N7s15XVKPZohChMwwDNavXw/451QwSYJ/PxUVFbz11lvMmDGDNWvWUFxcTHR0NJ07d2bo0KGMGTNmn9dBfD4fr776Ku+88w6bN28mLi6OQYMG8fTTT/Pee+/xxBNP8N577zF69GgAli9fzocffsgPP/zA1q1bKS0tJT09nW7dunH33XczcODA/WIqLS1l8uTJfPHFF2zYsAGv10t6ejqdO3dm+PDhjBw5MqTJOGtavXo1U6ZMYd68eWzfvh2n00lKSgq9evXiT3/6EyNHjsRax2u/tTXkz1RmZiZr1qxZo7XObFCwAZK0OIFI0kIIcayrqswjsmwXFG6Cok1QlO3/XJzNyFjFWvvhLTWYZGiaY2NKTDdiE9pDfEuI27O1AJtMrieE2KtiwQJybh0bLH966V94j9YAtE+JYvZfz8Zqloc/ceyTpIUItyOZtJDXQ4QQQhwzIqNSISoVMk7d79y/q4rYufs3tuevYkdxFtvLc9jhLGC7t4Id+KgwHXyYdqFJUW64iV41tc7z92Y0Y7vNToYligx7IhlR6WTEtSEjsRMZqaeQmNgRk6nprW8uhDg0UWefTVT//lQG3hu/culUPjztTjzKwqb8Sj5Zso3rzmhzdIMUQojjXJNNWiil5gPnHKDKBVrr2TXqTwDqnw4Wntda/62ea/UHHgH6AjZgDTBZa/3vA8TXAngKGAIkAtuAj4FntdbOetpEAA8BVwGtgCJgNvCY1nrHAWIXQojjniMykXbtBtGu3aD9zmnDoKxsG9t3/cr2grVsL9nEjspd7HAVs91XzU6TxhsY0t3M6613Fur1Zs02k4+1RhlUl0H1FihYDJv8521ak24oMswOMmxxZESkkhHTgoz4DmQkn0R6+qnY7bGN8wUIIY44pRSpD44j+9LLwDBQO7bzaLc1jLf7lwx8ee5GhndvTlzEwYdSCyGEODRNNmlRw/+AijqO1/eQvwjIquP4sroqK6VGAP/Fv9LKD0ABMBD4QCnVTWt9fx1tOgA/A8nAKmAhcBrwODBQKTVQa+2q1cYBzMOfGNkFTAfaADcAFyml+mqt61/wVwghTmDKZCIuvg1x8W2oa9yhz+smL28F23P/wFO+E9orKN4KZTugJAfKdmBoH7sOsj67Wym2mWEbTnA7wZ0LpSth+946CYamq7byD0dniM2AmGYQ28z/ObY5VRHxRESlygR+QjQRjk6diB95JSWf/BeAPj9OJXVAJ/KUg6JKN29+n8VDF9a/fKAQQojDczwkLe7XWm9pQP1/aa3fD6WiUioReBcwAyO01l8EjqcBPwL3KaVmaq3n12r6Pv6ExWta67sDbSzAp8Bl+EdTTKjV5lH8CYufgfO11hWBdvcCLwbiODf02xRCCLGH2WIjo9lpZDQ7re4Khg/KdvJuzg/sKtrIrrKt7KzczW53Cbu8VexSXspDfP+32KQoc1bCtq/rPD+4VXO8ykSqNpFmtpNmjSXVkUhaVDqpMa1IS+xAWvJJJCZ0wGQ+Hv6ZFqLpS7nrLspmzsKoqECXl/P3kp+5JcG/LOB7i7Ywqk9rWiXJnDhCCNEY5KehAxsDxALT9yQsALTWuUqpccAXwH3A/D3nlFKnA/2BPGBcjTZepdRtwEXAXUqpv2utvYE2NuDOQNU79iQsAu1eUkr9GThHKdVLa13niBAhhBCHwWTGFN+S7vGj6F5PlfKyHezOXcGuwnXsKt3Mzood7KouZLe3nJ2Gm3wTGIHRE6k+X519VCtFmdk/J8YWNFtwgscJnjwoXwe799a1aE2KoUg1WUk1R5FsiyMlIonkqHRSYlvQPLEzbdN6QGSSf/lZIUSjsSQmknzbbeRNmgRAyx9n0/OiHvym4nH7DJ6fvY43RvU8ylEKIcTxSZIWBzYssP+8jnOzACcwSCnlqDFPxZ42M2q/AhJIdiwEBgBnsjfZ0R+IAzZprX+v41qfA92Ai6nnNRYhhBCNKya2OTGxzenY8YI6z3s8VeTlrSSvcAN2Zwl4gbJd/ldQyndB2S7yqnNDvp5XKXaZYRceMErAWQLOrVDsP39WVTVv5uaDyeKfvDQmDaLT8UQl85ZRQEpkKskxzUmOa0NKQnuSk7pgs0cf7tcgxAkr4bprKf7vf/Fs2wY+Hw9t/YYr2/wJgFkrd3HDliJOayPLKgshRLgdD0mLm5RSSYABbACmaa23HaD+AKVUd8CB/y3krw8wemHP9PW/1T6htXYrpVbhn6uiE7DiYG1qHB+APwkxvwFtCLQRQghxDLJaI2nevA/Nm/ept05Ln5f5xZvIK1hDbvEm8sq2sbtyN3nOQnI9ZeT5XOQqg8oQVkJJ2TOaw/BC+U7/BhSazbzVqjmUrd5n5AZAnKFJwUySyU6KJZpEWwxJEUkkRqaSGJ1BUkwLEuPbkZjYXiYUFaIWk81G6v33seOuuwGIXr6UK1r243NzSwCemrWWqbf1wxTC/79CCCFCdzwkLR6tVX5BKfWU1vqpeupfV6v8lFLqf8Domq9lKKVi8Y9+gH2mWNvHdvxJi9bsTVq0CqENgTZ7HEqbeimlVtdzqn0o7YUQQjQOk9lCUnJnkpI7c6Bp+yrKd5GXv5rc4o3klmyhoHI3+c4C8l2lFPqqyTfcNPfV/WCUb65/SdZSk6IUgyyqwVsN3nyo2gyF+9eNNjRXeszca8mAqGSISgluVY44VhuVJMW1JimhPTGxLWQpWHFCiBk8mMjevalauhSA0X9M54vut2GYzPyRU8KMFTu5pHvzoxylEEIcX5py0uIH4F/AT/hX22gJXIE/ifGkUqpMa/1qjfpZwP3A18BWIAE4G5gIjMA/2eZlNerXHENbVU8MlYF9TB3tGruNEEKI41R0TAbRMRm0Y//lXYO0BlcZlOdCRWAr301k8QYuLllJvreCAp+LAuWj5BDmvKgwKVR1MRRv2e9cts3Kjc0zgmWL1iQYkKjMJJjsJJgjiLfGkGCPI96RQEJkKvFR6STENCc+rhXx8a1lJIdokpRSpP7tQbZccSVojXnbFu7PXMtE+8kAPP/1OoZkpuOwShJPCCHCpckmLbTWj9c6tAF4Rin1K/ANMEEp9U+tdXWg/oe16lcC/1FKfQ+sBC4NLCu6uLFjb2xa67pW/NszAqPrEQ5HCCFEY1AKHHH+LaVT8HB74JlaVd2ucgoL15NflEV+2VYKy3dQUJVPkauEIk85hb5qigw3hUpTXmNoe5LPqPPSRbVGc3iVIt8M+RhANfiqwVfkn/mptO7wIw1NglZcb0RxjaOFf0LRyCSITITIJEptEWwwqoiPaU58TEti41pIokMcEyIyM4m79FJKp04l9sILueCmEbz8nw14fJqdpU7e+TGbO87rcLTDFEKI40aTTVrUR2v9bSBxcRrQhxore9RTf5dS6j38ozCGAnuSFhU1qkUCZXU0jwrsy2sc29OuvnWvwtVGCCGECInNHnPgJV9rcLvKKSrOoqhkC8k+H3jcUJEHlflQWQCVeXird5Lqq6TI5E9YHIoqk6IK8JRsh+1r9zv/R4SDO9JT9znmMDSxGmKVmThlJc5sJ9YSQZw1mjhbLLH2eOIikomNTCYuKo3Y6GbExrYgJjpDlo8VYZVyz1+Jv/JKInv2AGB0PzdvL8wG4M3vs7jytBakxjiOZohCCHHcOF7/Bd+IP2mRcbCKNepTs77WukwpVYp/XosWwJo62rUI7LfWOLYN6FHjXKhtap4LpY0QQggRdjZ7DOnpPUhP71FvnfMCmzYMyspyKCreTFHpVgrLt1NSnU9JdRHFrlJKPOUUe6soMVyUaB/FSlNVa5LCBKPu0Ryl5v1faXGaFE4gDwNwgeECdxm4c/e+SFmHcUUlXOc2Q0SCf3PEQ0QC661mvjFKibPFEetIIDYiidjIZKIjkomOSiUmKo3o6AwsVnn4FPuypqZiTd2bVLtzQEc+X7ad4ioPlW4fL8/ZwLOXy/zpQggRDsdr0iIhsD/AjzAh1f8D/7wXPamVtFBKWYGT8Q9+3VCrzSWBNnXZc3xFjWN/1DoXShshhBDiqFImE3HxrYmLb03bENu4nCWUlGylpGwbxeU7aIcdvB6oKtx3c+0mzVdFsQnchziaY494nxeqy6C6eJ/ja6OjeDsl6aDtIwxNjIZoZSIaCzEmKzFmB9EWBzGWKKJt0ZwX35WO8e3AHguO2ODea4vCZI+TkR7HubgIK38d1InxX/rnQv/v0hyuP6MNJ2XIK01CCHG4jrt/QZVSKcBZgWJ9S4jWrK/YOwFn7fqz8CctrgBqz4lxEf5lU2dqrZ212jwOXKyUsmutXTWulRaIrRhYVKPNIvxv/bZXSnXXWi+vda0rAvsZB7sfIYQQ4lhmd8STlh5PWvqpB6x3cWBDa5zVxZSW5VBavoOyylxKq/IoqyqkzFlEqauUMk8Fpd5KynxOSg03pdpHmTIoVwqtFLH1zM1RFuIEpdUmRTWQhwY8/s1XBT7ABVRC8/Vz6Fi5/3za06OjmJCSRJShidYQo8zEKAtRJitRJhtRZjuRlgiiLJFEW6OJtMUQZY8lyh5HlCOeSEcC0RHJREUmExfdDKsj1j+fiTjmXNOnFR/8vIXN+ZUYGp75ai3/vvF0lPz3EkKIw9IkkxZKqX5AKjBDa+2rcbwN/uRCFPCl1np74HgKMBL4t9a6vEb9aOAF/HNf7Aa+qHWpfwGPAJcopS7XWn8RaJeKf9URgBdrNtBaL1FKLQL6A88Dfw20sQBvAlbgNa21p0Ybt1JqcuBabyilztdaVwba3Qt0AxZorZc1/NsSQgghmjClcEQm4ohMPGiiozaf101FxS4c7irwVPlHWlSXBPftSjdwaUU2Zd4qSg0XZdpLhfZRrvyrpzRETD2vuZQHEiOVJkUlkIsBuEG7wVfpT3y4Q7vGi7n5nF/tAlsM2KPBFg32aL63KaaanESZ7USZHURZIoiyRhEVSIJE2mKIsMcQYYsl0h5LhCORCEc8EREJREYkY7VFyYN1GFh8Xv5uy+ZanYyhTCzcWMD8Dfmc1zn14I2FEEddZWUlb731FjNmzGDNmjUUFxcTFRVFly5dGDx4MGPGjKFVq1ZHO8xD8v7773PDDTfscywyMpK4uDg6depEnz59uP7668nMrHM9h6OuSSYtgE7Ae8BupdRvQAnQGuiFf/TDauDmGvWjgMnAc0qppfiXSE3B/9pFUqD9FVrrfX5ForUuUkrdCHwKfK6Umo9/NftBQDzwktZ6fh3x3QD8DNytlBqA/9WS3kA7/Eu0PltHm78H+u0HbFRKLQzcUx8gH7gxlC9GCCGEEH5mi424+Nb1nj8zsNXF8HmorMilvHI35ZW5VFTmU+EspKy6mApXCRXuMsrdFZR7K6nwVtMsoxW4XeAs8y9F6ywFT1UwaREOUVqDNsBV6t8CNsXF8n1iPBj4B4I0kFlrIjREaHjWaaWPKRpsUf7NGgm2KH7W1SwySomwRBJhiSDSGkmENZoIWwyR9hgibHFEOGJx2GKx22Nw2ONx2GOxO+KxWOxh+w6OVRU//EDus8+RkJ3NHYOv5/Uo/3wWT89ay1kdkrHUMUeLEOLY8dNPPzFixAh2795NZGQkffv2JS0tjdLSUpYuXcrixYuZOHEiM2fOZNCgAyxHfoxr3749Z57p/5fP7XZTUFDA77//zoIFC5g4cSKjRo3izTffJDb22Hq1rakmLX4BpuB/oO+Nf06KSmA58BkwZc9SpwGF+Ec99MWf8OiH/3cb2cD7wMta6x11XUhr/T+l1NnAo4H2NvxJiMla6w/qabNRKdUDeBL/iiSX4Z9s8yngmZqvjNRo41RKnQc8BFwDXAoUBeJ7bM+oESGEEEI0PpPZSkxcC2Li6psjOwQ+DzdV5nJpaQ4VVXlUVOVTXl1EhbOYCncZVe4KKj2VVHqrqfRVU+lzUWm4qTK8VGoflRhUKqhUYChFVD2jOWpPbtrgMJWiQvmXMlNlO8C5348pLI+P5YOE+EPq36I1Dg0ODXYUz7kcdDcHEiIWB1gjwBrBD7qShb4yIsx27GY7DosDhyUCuyUChzUysEVjt0URYYvBbovBYY/FYY/Dbo/F4YjHao1ChTFRFKqyWbNwZ/tXD7ngl+m8f1YHyq2RZOVV8PGSbVx3RpsjHpMQIjTLly9n4MCBOJ1OHnzwQR577DGioqKC5w3DYNq0aYwbN47t25v2I9mZZ57J+++/v88xrTWzZs3iL3/5Cx999BHbt29nzpw5WK3WoxNkHZpk0kJrvRa4vQH1y4G/Hcb1FgEXNLBNDv4RFw1pU41/PozHG9JOCCGEEMcgs5XI2BZExh5G4gP/Ki1OZwlWjxO81eAqB3cFuCrAXcHZxeuJK99ClaeyRhLERaXhotLwUK19VGuDKgyqlaZaKTz1vA4Saeg6j1erQ08EeGskRQB0yRZw7f9OzPKEOD6Jjzvk6+xh05p3Cirpri1gsfs3s38/1erjK5MTuzJjUxZspj2bFbvJis1sw2a2YzfZsFns2MwObBY7dosDmyUCmyUSuzUCmzWSjnHtiHIkgNlGys2jKPt2Drq6GlVWyviin7k/bSAAL83ZwPBTmxMXeew8AAgh/LTWXHfddTidTiZMmMD48eP3q2Mymbj88ssZOHAgOTk5RyHKxqWU4qKLLuL000+nR48eLFiwgClTpnDXXXcd7dCCmmTSQgghhBDiRKFMJiIiE+s93z2wNYTXU011VSFV1YVUO0uodhZT7SqjbZ9E8Hn9c4C4KwP7Kk4t28ifqndR7XNRbbipMjxUa29gM6hCU63ApQ6+2otd150YcYVpXg23UpjdFeDePzGSnRDP4vhY0Pi3ugevhOT/du6meyD5YgWSO0STv9I/pLrzL1/T9cZvKEhSWLRm+CcKu1JY8W82ZcKKCYsyYVNmrIHNZrIE9lYsJgu94zsz5NynQJbdFaJRzJ49m1WrVtGiRQseeeSRA9aNi4sjLm5vYnXXrl383//9H7NmzSIrK4v8/HwSExPp168fDz30EL17996vj/z8fF588UW+/PJLtm3bhtlsJi0tjb59+3LnnXdy+umn71O/qKiISZMmMX36dLKzs7HZbPTq1Yt7772Xiy66KDxfQkBqaipPPvkkY8aM4bXXXpOkhRBCCCGEOHos1ogGvf4yMLCFwvB5cDlLcbpKcblKqXaW4nKX43RX4HSX0bp3GhgaPNX+kSOeavA4Oa18E7p6Jy6fG6fhxml4cBlenIYXp/bhwodTGzjRuJR/zXmnAl1HssNWT2LkcJfPral28iWxSwUlmyPxVFqwGHDdd5pn/qRgn9dV6siW7DkE/peXazh161KoqIDLpoQtbiHEXrNmzQLgyiuvxGJp2KPx9OnTefDBB+ncuTPdunUjNjaWjRs3MnXqVGbOnMnMmTM5//zzg/XLy8vp06cP2dnZtGzZksGDB2OxWNi2bRuffPIJ7dq12ydpsWHDBgYNGkROTg5t2rRhyJAhlJeXs3jxYi6++GImTZrE/fffH54vImDkyJHccsstbNq0ie3bt9OixeGNFAwXSVoIIYQQQoiwMZmtREQlExGV3KB25wW2htCGgdtdjtNZgttdjstdjttTRXNrLGgNXpd/87nA6+SC0s10qNyJy+fC43Ph8rlw+dx4fG5chgd3YHNpL27Dh1t7cWkfHm3gwsCtNW40LjQOazQY1eB1Bu4bUnuUseNH/6iY7tmanlma3zoeWqLEZmjOq6yGP/4Dp90ALU8/eCMhwsBwudCu/ee2ORSmyEhUHcmAw72Gstsx2Q9/kt/ly5cD0LNnzwa37d+/P6tWrdpvxY1vvvmG4cOHc/vtt7Nx48bg6kyff/452dnZDB8+nKlTp2KqkdDMz88nNzc3WPb5fFxxxRXk5OQwceJE7rvvvmD9rKwszj//fP72t78xdOhQTj755AbHXp+YmBjatWtHVlYWa9askaSFEEIIIYQQh0OZTNgdcdgdoc2FcWpgCyutwecGr4sYrxv7rXfgWrYCgHsWxPGoOhcsXiwmD1f0TKFlghm314XH68JjOHF73Xh8Ljw+Dx5jz95DUmG2f8UYgK8fhDHfBUdtlLpK8RpekiKSwn03QlD4z7cpeOONsPTV6oMPiOqzf8LtcK+RfMcdpPzlzsMJzR9HYSEAKSkpDW57yimn1Hl8yJAhXHnllXz00UesWrUqWC8/Px+AAQMG7JOw2HP9mjHMmDGDlStXMmLECB544IF96nbo0IEXX3yRyy+/nLfffptXX321wbEfSHJyMllZWRQXF4e138MhSQshhBBCCCEOlVLBCT8V0Gz8U2RfehkYBvb8Ys7fbeWlpP4AlK2NYvZfz8ZmCWFi060/wXuBeeB3/gYrPsF9yhV8vO5j/rnin5zb8lyePvPpxrsvIcRBuVwuZs+ezZIlS8jPz8cdmEtn5cqVAGzcuDGYtOjVqxcAkyZNIi0tjWHDhhETE1Nnv99++y0Al19+eZ3nzzrrLACWLFkSvpsJ0IFkqQrj63SHS5IWQgghhBBChImjUycSrrqK4v/8B4DBy2bywTldKLTHsrmgkn//vIUxZ7U7eEet+0HmZbB6qr88dwLfOCy88OsLAMzYNIPru15P58TOjXUrQhz3kpL8o5X2jIJoiJUrVzJ8+HC2bNlSb53y8vLg54EDB3LPPffwyiuvcPXVV2OxWOjZsyeDBw/mxhtvpF27vX8v7Olz1KhRjBo1qt7+CwoKGhz3wezpMzGx/gmgjzRJWgghhBBCCBFGKXf9hbJZs/CVlkJVFRPyfuAvLf0z/b/63UYu69GcpOgQ3scf/CSs/9o/b0ZFLhfkrObd+A5klWSh0by07CXeGvxWI9+NONEk3XIziX++Pix9mSIjG+UaKgzzWQB0796dRYsW8dtvv3HttdeG3E5rzciRI9myZQtjx45l7NixtGvXjujoaJRSPPzwwzz77LPBUQt7vPTSS9x6661Mnz6duXPnsmjRIpYsWcLEiRP5+OOPGTFiBACG4Z+sd+jQoaSlpdUbR3Jyw+YOOpiysjI2b94MQNeuXcPa9+GQpIUQQgghhBBhZI6PJ/muv5D71N8B6LBsPj0Se/J7VDPKnV5enLOBZy6r+334fcS3gn53wQ8TAbAsfpN7rniDO5Y8BcBPO3/ipx0/0a95v0a7F3HiMdntEKakwNG8RiiGDRvGG2+8wWeffcbEiRNDXkFk3bp1rFu3jtNOO40pU/Zf3WfPg39dOnfuzLhx4xg3bhxOp5PJkyfzwAMPcNtttwWTFnsmwBwzZkzw2JHw6aeforWmU6dONGvW7Ihd92BCeKFOCCGEEEII0RAJf/oT9o4dg+W/bf7aP2kn8MmSbazZWRZaR2f+FWICDw8+N2ctn0bv9N7B0y8tewlDG3W3FUIc0NChQ8nMzGT79u08/fSB54gpKytj9erVAMFJKutaXaO4uJg5c+aEdH2Hw8H9999PRkYG+fn55OXlATB48GAApk6dGvK9HK68vDwef/xxAO6+++4jdt1QSNJCCCGEEEKIMFMWC2kPPxQsx25ay5/K1gBgaHhy5ur9ho7XyRblf01kT7/rZ3Ff+rnB8vri9czcPDNscQtxIlFK8eGHH+JwOJgwYQIPPfQQlZWV+9TRWvPll19y2mmnsXTpUsC/gofJZGLevHls3LgxWNfpdDJ27FiKior2u9a0adNYvHjxfseXLVtGbm4u0dHRxMfHAzBixAi6du3KRx99xFNPPYWr1vKwWmsWLVrEokWLDvcrQGvNV199RZ8+fdi1axcDBgzglltuOex+w0mSFkIIIYQQQjSCqDPOIGbwoGD5uj9m4PD6Hz4Wby5i9qrdoXV0yhXQYu+ykZmL/sEFbYYGy6///jpOrzM8QQtxgunevTtz584lLS2N5557jtTUVAYNGsSoUaO46KKLyMjI4JJLLiEnJ4eWLVsCkJqayk033URZWRmnnnoqF110EVdeeSVt2rRh3rx5jB49er/rzJ8/nzPOOIMWLVpw8cUXM2rUKM477zz69OmDYRg88cQT2Gw2ACwWC9OmTaNt27Y8/vjjtGrVisGDBzNq1CiGDBlCeno6Z555ZjCJEqoff/yR0aNHM3r0aK655hqGDBlCamoqw4YNY8uWLVx33XVMmzYt5NdkjpRjKxohhBBCCCGOI6njxlGx4Ae02425qIAHChfzVNo5ADz91VrO65KKw2o+cCdKwQXPwdsD/OW81dx16gjmmqx4DA+7K3fzn3X/4caTb2zkuxHi+NS/f3+ysrJ46623mDFjBitWrKC4uJjo6Gg6d+7M2LFjGTNmzD6vg0yZMoUuXbrwzjvv8N133xEXF8egQYN4+umnee+99/a7xujRo7FYLPzwww8sWbKE0tJS0tPTufDCC7n77rsZOHDgPvU7duzI77//zuTJk/niiy9YvHgxXq+X9PR0evTowfDhwxk5cmSD7nPTpk1s2rQJgIiICOLj4+natSt9+/bl+uuvJzMz8xC+vcanQhqWJo4LSqnVXbt27brnXSwhhBBCCNH48l5+hcK3Aqt8JCYx4qwHqFL+3x0+MKQzd5zXIbSOpt0Oyz/yf45IZNLZN/LvDZ8CEGONYdbls0hwJIQ7fHEcMAyD9evXA/6JIE0mGXAvDk9D/kxlZmayZs2aNVrrQ8qKyJ9WIYQQQgghGlHyLTdjycgg/qo/0XHml1x91t4JOt/4PovcshBf7Rj4ONii/Z+ri7ilqIgYWwwA5Z5y3lz+ZrhDF0KIo06SFkIIIYQQQjQiU1QU7WfNJGPCBCyJidw1sCOJUf5316vcPp6fvS60jmLS4az7gsW4Xz/g1naXBcufbviUDcUbwhq7EEIcbZK0EEIIIYQQopGZIiODn+MirNx3fqdg+YvfdvD7tuLQOup7OyS08X/WPq5Zv4jWMa0BMLTBxCUTQ1uVRAghmghJWgghhBBCCHGEXdW7FV3SY4LlJ2aswTBCSDZYHXD+03uLm79nXLO9E/j9svsX5uXMC2usQghxNEnSQgghhBBCiCPMbFI8fnFXCIyKWJ5TwrTlO0Jr3GUYtD07WDxryb/pn3FGsPzC0hdw+VxhjVcIIY4WSVoIIYQQQghxhBnV1XSY+RGTtn0VPPbs1+sod3oO3lgpGPocKP+P8qpoM+NsLTAr/9Kp2yu2839r/q9R4hZCiCNNkhZCCCGEEEIcQe6cHDYNG0bhlH9w8u/fc2rJVgDyy128Pi8rtE7SMuG0G4PFdj+/zdXtLwmW/7nin+RV5YU1btF0KaWCnw3DOIqRiONFzT9HNf98NQZJWgghhBBCCHEEWZs1wxwfHyw/nDUTk/Y/ALz7YzZZeRWhdXTuw+CI8392lTE2bxfx9nhirDHc2f1OEuwJYY5cNFVKKWw2/4o1lZWVRzkacTzY8+fIZrM1etLC0qi9CyGEEEIIIfahzGbSH32UrdeMAiB2ezZXt1jGR+m98RqaJ2as5t83nn7wB4GoJDjvEfh6HABxf/yXly6fTPtOw0h0JDb2bYgmJiYmhsLCQnJzcwGIiorCZJLfYYuGMQyDysrK4J+jmJiYg7Q4fJK0EEIIIYQQ4giL7NmTuEsuoXT6dACuXvUVMxK6UmaPYuHGAr5dk8uQzPSDd3TaTfDbvyF3FQC9f34bTr6mMUMXTVRSUhKVlZU4nU527tx5tMMRxwGHw0FSUlKjX0dSa0IIIYQQQhwFqfffhykqCgBzRTkP7vw+eO6pmWtwenwH78RsgQsn7S3v+gOWvR/mSMXxwGw206pVK5KSkoKvighxKGw2G0lJSbRq1Qqz2dzo15ORFkIIIYQQQhwFlpQUku+8k7znnweg54oFdE7szvq4FmwvruatBZu5e1DHg3fUuh+cMhJWfuovz3sKMi+DSHlFROzLbDaTmppKamoqWmt0YMldIUKllGr0OSxqk5EWQgghhBBCHCWJ147C1r69v6A1j23+ChWYlPPN+VlsL64KraPBT4It2v+5uhi+ezJ4alfFLr7Z8k04wxbHAaUUJpNJNtkatB3phAVI0kIIIYQQQoijRlmtpD/6SLCctHUDl+StAMDlNXh61trQOorNgHP/tre87H2c2xbz5vI3uXjaxTy88GF2VOwIZ+hCCHFESNJCCCGEEEKIoyjqjDOIGTIkWL5p9UwiPdUAfL1qN4uyCkLrqM9YSO4cKGiMbx7i8w2f4/K5cBtuXvz1xTBHLoQQjU+SFkIIIYQQQhxlaQ+OQzkcAFjKSrhnxw/Bc+O/XI3HZxy8E7MVLpwYLEbu+I17kk8PludsncPS3UvDF7QQQhwBkrQQQgghhBDiKLM2a0byrbcEy/1XzKN1+W4AsvIq+OCnLaF11O5c6HppsDjs18/oltg1WH5+yfP4jBBWJRFCiGOEJC2EEEIIIYQ4BiTeeCPWli0BUIaP8dlfQ2B1h1fnbiS/3BVaR0OeBmskAKaqAh404oKn1hev54usL8IbuBBCNCJJWgghhBBCCHEMMNntpD38ULCcsXk15+evAqDc5eX52etC6yiuBZx9f7DYbflnXNzszGD5td9eo9RVGp6ghRCikUnSQgghhBBCiGNEzHnnEXXO2cHyHWtnEuFxAvD5su38tq04tI7OuBMS2/k/a4O/5mQRYYkAoMRVwuu/vx7WuIUQorFI0kIIIYQQQohjSPrDD6OsVgBsxYXcuX1B8NyEL1djGPrgnVjscMHeSTlTty1hbGq/YPnT9Z+ypnBN+IIWQohGIkkLIYQQQgghjiG21q1JunkMAJaUFPoO3ftqx4rtpXy2LCe0jjoOhs7DgsXr/viKtjGtAdBonv7laQwdwqokQghxFEnSQgghhBBCiGNM0i23kHznnbT7+it63TCSi09tFjz3/Oz1lFZ5Quto6DNgtgNgrcjlIcveflbkr2B61vSwxi2EEOEmSQshhBBCCCGOMSaHg5Q778AcHQ3Awxd2IcJqBqCo0s0L364PraOENnDmPcHiGcv/x+D0vsHyK7+9IpNyCiGOaZK0EEIIIYQQ4hiXERfBXQM7Bssf/rKVldtDTDac+VeIb+X/bHgZt3s7ERYHAEXOIt5Y/kaYoxVCiPCRpIUQQgghhBBNwE1ntqV9ShQAWsOj01eFNimnNQKGPhcspmf/xC01JuX87/r/sq4oxOVUhRDiCJOkhRBCCCGEEE2AzWLi6W4OWpXtBuCPnBI+/TXESTk7Xwgdzw8Wr//ja1pHtwDA0AbP/PIMWoeQABFCiCNMkhZCCCGEEEIc43wVFex+5hni/jqGJ9ZPQwVW/Xh+9jqKK90H70Ap/xKogddCbBW5PGTOCJ7+Pe93Zmye0SixCyHE4ZCkhRBCCCGEEMc454oVFP/7/8DnI31HFhftWAZAcZWHid+EOClnYls4675gsf8fUxmYelqwPHfr3LDGLIQQ4SBJCyGEEEIIIY5xUf36ETNkSLB889qviXZXAfDJ0m0szykJraP+d0Nie/9nbTBu+2aaRTXjyX5P8sp5r4Q3aCGECANJWgghhBBCCNEEpD30N1RkJADWyjLuzp4D+CflfHz6KnyhTMppscOwF4LFZjuWM6v1SC7reBkmJY8GQohjj/zNJIQQQgghRBNgTU8n5Y7bg+X+636kU/E2AFZsL+XjJdtC66j9AMi8PFi0fPckVOSHNVYhhAgXSVoIIYQQQgjRRCRefz22Dv7XO5TWPLJhBqbApJyTvllPYYUrtI6GPAO2GP9nZwnMHd8I0QohxOGTpIUQQgghhBBNhLJaSX/s8WA5dVc2l25fAkBptYeJs0OclDM2AwY8sre8/CPY+lOwqLXG4/OEJWYhhDgckrQQQgghhBCiCYnqczqxF18cLN+wdjZxrnIA/vtrDsu2FofWUe+bIf2UveVZ94HPw+bSzdwy5xZe/u3lcIYthBCHRJIWQgghhBBCNDGpD9yPKToaAEtVBfds/jZ47rFpIU7KabbAsBqJibw1/DzvUUZ8OYLFuxbzn7X/YWPxxnCHLoQQDSJJCyGEEEIIIZoYa2oqKXf9JVjus/5nMguzAVizq4yPftkaWkcte0PPPweLPZb8H2mOZAB82sfTvzyN1iEkQIQQopFI0kIIIYQQQogmKOGaa7B36RIsP7x+OmbDB/gn5SwIdVLOQRMgMgkAh6eShzwRwVPLcpfx5aYvwxazEEI0lCQthBBCCCGEaIKUxUL6+MdBKQAS87Zz9ZaFAJQ7vTz71brQOopMhMFPBovnbFjAeYknB8sv/voipa7S8AUuhBANIEkLIYQQQgghmqjIHj2IHzkyWL5q3RxSK4sA+N9v21m6pSi0jk69Blr2DRYfyl5NhNkBQLGrmFd+eyVsMQshRENI0kIIIYQQQogmLPXeezAnJgJgdrt4cMMMCMxD8ejUVXh8xsE7MZlg2IugzABkFG1lbEzn4OnPN3zOH/l/hD94IYQ4CElaCCGEEEII0YSZ4+JI+9uDwXLXrSvpt2sVAOtzy3lvUXZoHaWfDH1vCxavW/ENHaJbBstP/fwUXsMbnqCFECJEkrQQQgghhBCiiYu9+GIi++59vWMkO4OfX56zkR0l1aF1dO7fIKYZAFafm0cr9iYp1hev55N1n4QnYCGECJEkLYQQQgghhGjilFKkP/44ttatafHGZM79xwskRtkAqPb4mPDl6tA6ssfABc8Fi72yf+GSxG7B8uTlk8mrygtr7EIIcSCStBBCCCGEEOI4YG/XlnZfzSJm4EDiI208fOFJwXNz1uQyZ01uaB2dNBw6DgkW7123mFhrDACVnkomLp0Y1riFEOJAJGkhhBBCCCHEcUKZzcHPI3o2p0/bxGB5wperqXKHMCeFUnDhJLBGApBYWcA91ozg6W+2fMNPO34KX9BCCHEAkrQQQgghhBDiOKSU4unLTsZqVgDsKKnm1e82htY4oTWc+1CwePnquZwa2y5YfvqXp3H5XGGNVwgh6tJkkxZKqflKKX2AbWg97UYrpZYopSqUUkVKqa+UUv0Ocq3+gXpFgXZLlFLXH6RNC6XUe0qpnUopp1Jqg1LqCaWU4wBtIpRSTwbqOgNt31VKNQ/tWxFCCCGEEGKvDqkx3Nq/NZEeJwDvLMxm3e6y0Br3vQ3STgb8Dw2P7dqBObAk6rbybbyz8p3GCFkIIfbRZJMWNfwP+KCObUftikqpV4D3gJOBucASYDDwg1Lq0ro6V0qNABYAQ4EVwGygI/CBUuqFetp0AH4HRgOFwHTADDwOzFVK2eto4wDmAY8B0YE2OcANwO9KqXa12wghhBBCCHEg1StWcNk/H2Xc2mkAeA3No1NXYRj64I3NVrjoFcA/UqNz3kauiekcPP2vlf9ia9nW8ActhBA1HA9Ji/u11qPr2FbWrKSUGgTcjT+JcKrW+lKt9VDgbMAHvKeUiq/VJhF4F3/C4Qqt9bla6yuALkAWcJ9S6tw6YnofSAZe01qforX+E9AZmAr0Bx6qo82jQF/gZ6CT1vpPWus+wH1ASiAOIYQQQgghQlK1dClb/nQV7nXr6LP5V7rnbQDg163FfLYsJ7ROWvaG3jcFi3esWUCq3T9PhsfwyKScQohGdzwkLUJ1b2D/d6118GU+rfXPwD+AeOCmWm3GALHAdK31FzXa5ALjAsX7ajZQSp2OPzGRV6MOWmsvcBvgAe5SSllqtLEBdwaKd2itK2q0ewn/CI9zlFK9GnbLQgghhBDiRBXRsyeOU04Jlset+xKrzwPAs1+vo6jSHVpHAx+H6DQAojzVjHNZAeiT0Yf7T7s/vEELIUQtJ0TSQikVAQwIFD+vo8qeYxfXOj7sAG1mAU5gUK15Kva0maG13md2okCyYyGQAJxZ41R/IA7YpLX+vQHxCSGEEEIIUSdlNpMxYTyY/D/yJxTt5tpN8wEoqfLw7FdrQ+vIEQcXPB8snp+9lLc7XMvbg9+mbVzbcIcthBD7OB6SFjcppd5USk1WSt2llGpVR53OgB3I11pvr+P8b4F9t1rHT611Pkhr7QZWAQ6gUyhtDnCtQ2kjhBBCCCHEATm6diXxuuuC5Ss2fEfzinwAPlu2nV82F4bWUddLocNgwD/DRd+f3kY5S8IbrBBC1OF4SFo8iv+1izuAV4EspdRjtersSWTUlbBAa10JlAAJSqkYAKVULP7RD/W2q3G8dajXCmObeimlVte1Ae1DaS+EEEIIIY4fyX/5C5Y0/+sdJq+XB9dOB+2fiPPRaatwe42Dd6IUDHsBLBH+cmU+zJ3QSBELIcReTTlp8QNwHf4H8Uj8oykeAbzAk0qpu2vUjQ7sqw7QX2VgH1OrzYHa1W4TyrXC1UYIIYQQQoiDMkdHkfbIw8Fyxx3rGLh9GQAb8yp458fs0DpKaAPn/m1vedn7sG1x+AIVQog6NNmkhdb6ca31h1rrzVrraq31Bq31M8ClgSoTAnNZnHC01pl1bcCmox2bEEIIIYQ48mIGDyb63HOD5TvXziLW5f+92KvfbSCn6EC/26vhjDsgNXNvecZfwevG0Aafb/iczzfUNRWcEEIcuiabtKiP1vpb4Ff8q4H0CRzesxpH5AGaRgX25bXaHKhd7TahXCtcbYQQQgghhAiJUor0xx9DRfp/3HRUlXPn+lkAOD0G479cjQ68MnJAZitc/Ar+mS2A/LVs/+FZRs8ezRM/P8GkpZPYXbm7cW5CCHFCOuSkhVJq3mFs34XzJuqwZ0nTjMB+W2Dfop57icKf5CjWWpcDaK3LgNIDtatxfGuNYwe8VhjbCCGEEEIIETJrs2ak/nXvG9RnbV5C97wNAMxbl8fsVSEmG1qeDqfdECxGLZ5CdnEWAFXeKp755ZnwBS2EOOEdzkiLcw9za0wJgf2euSDWAy4gRSnVvI76PQP7FbWO/1HrfJBSygqcjH/Z0w2htDnAtQ6ljRBCCCGEEA2SMGoUjpNPDpYfWDMNm88DwPgvV1Pm9ITW0cDxEJXq79Ndzf3evQOGv8/5nu+2NvbvKIUQJ4rDSVq0PYyt3WFc94CUUinAWYHibwBa62pgXuDYlXU0uyKwn1Hr+Kxa52u6CP9yp3O11s462lyslLLXii0tEFsxsKjGqUX4R3W0V0p1b0B8QgghhBBChEyZzWQ89SSYzQAkluRx7Ya5AOSVu5g0e31oHUXEwwXPBYvDNy/l9Og2wfIzS56hwl2xfzshhGigQ05aaK23Hs52OEErpfoppS5VSplrHW8DTMU/B8SXWuuaS4i+FNg/qpTqWKPNGcCt+Jc8fafWpf4FlAGXKKUur9EmFZgYKL5Ys4HWegn+JEQq8HyNNhbgTcAKvKa19tRo4wYmB4pvBF5X2dPuXqAbsEBrvayer0QIIYQQQoiQOE46icTRfw6WR2ycT5vSnQB8+MtWlm0tDq2jzMuhwyDAP8PFY1vWYjVZAciryuP1318Pa9xCiBNTU52IsxP+5MR2pdQspdRHSqkfgbVAf2A1cHPNBlrrucCrQBKwXCk1TSn1Ff6lUy3ADVrrklptioAbAQP4PDAfx2f4XzfpALyktZ5fR3w3AIXA3UqpFUqpTwJtLgd+Ap6to83fgV+AfsBGpdR/lVKL8SdF8gNxCCGEEEIIcdhS7rgDawv/tGkmw8eDq6di0gZaw8NfrMTjMw7eiVIw7CWw+l8NaVOez83WjODpj9d9zKqCVY0SvxDixNFUkxa/AFOAnUBvYCT++SWWA/cBvbXWebUbaa3/ij+hsBYYDJwBzAXO1lpPq+tCWuv/AWcD3wA9gAuBLGC01vq+etpsDNR9H0gBLsOf+HgKGKi1dtXRxgmcF6hThX/p1taBPnpqrTfX/3UIIYQQQggROlNkJOnjxwfLbfKyuTD7ZwDW55bzzx9C/NEzoTWc90iweNO6H2kbkQaARvPEz0/gNbzhC1wIccJRIS1tVFdDpQ7nIVprrdsfRntxCJRSq7t27dp19erVRzsUIYQQQghxDNhx/wOUzZwJQGVcEled8wBekwW7xcS395xN66Sog/QA+Lzwr4GwazkAvya35oaYvc8Y9/W6j9Enj26E6IUQTUFmZiZr1qxZo7XOPJT2hzPSos1hbG0P47pCCCGEEEKIMEh76G+Y4uKIGTqUdp99SkKcP0nh8ho8MnUVIf2C02yB4a9DYLq50wq2cnlE6+DpN/94kx0VOxolfiHE8e9wJuI0Hc4WzpsQQgghhBBCNJwlKYl2X35Ji1deJrFVM8Zf3DV47sesAqYtDzHZkNEN+v0lWLx3/c8kWmMBqPZW8/Tip0NLgAghRC2SPBBCCCGEEOIEZk1LDX4edkoGA7rsLT81cy1Fle7QOjr3b5DgH1Ad5/PyQOXeuSwW7ljIt1u/DU/AQogTiiQthBBCCCGEEAAopXjykkwirP5XPYoq3Tzz1drQGlsj4OJXgsVhO9ZxRkTzYPm5Jc9R5i4LZ7hCiBNA2JMWSqmuSqmXlVKLlFLrlVITa5zrp5S6SymVGO7rCiGEEEIIIQ5fi4RI7ju/E0r7lz39fNl2fsoqCK1xu3Oh+ygAFPDYphXYTTYACqoLeO231xohYiHE8SysSQul1L34lx29G/9yoh2A5FrVXgauDOd1hRBCCCGEEOGhPR6Gr57DP35+E0tgudJHpq3C6fGF1sH5f4dI/yNAS1cltxrRwVOfrv+U5XnLwx2yEOI4FrakhVJqGPACkANcDqTiT7AGaa1/AvKBS8J1XSGEEEIIIUR4GE4n2VdcSeErr9AqbwtXZs0HILugkje+zwqtk8hEuOD5YHF09nI6OFIA0Gie+PkJPD5PuEMXQhynwjnS4l6gEhistZ6mta5vDNlyoHMYryuEEEIIIYQIA5PDQUT37sHyqPVzaVGeB8A/FmxiY255aB2dPAI6ng+AFRi/YysAdrOdi9tfjFLqAI2FEGKvcCYtegGLtdabD1KvAEgP43WFEEIIIYQQYZJ6371YUvwjI8w+Lw+s/B9KG3h8moe+WIlhhLB0qVIw7CWwRgHQvayAR+xt+GL4F9x48o1YTJbGvAUhxHEknEkLGxBK6jUV8B60lhBCCCGEEOKIM8fGkj7+8WC5U94mLsz+GYBftxbz8dJtoXUU3xIGPhYsXrXuB1rlbQhrrEKI4184kxbZwKkHqqCUsgHdAPnbSgghhBBCiGNUzKBBxAwZEizfsu5rkqtKAHju63XkljlD6+j0W6B5r73lGfeAqyKMkQohjnfhTFp8CbQJrCBSn3FACvBFGK8rhBBCCCGECLP0Rx/BFBcHgM3t5K+rvgCtKXd6GT99dWidmMxw8Wuw53WQ0m3w/TONFLEQ4ngUzqTFRGAHMEkp9V+l1FWB42lKqcuUUv8GnsA/ImNyGK8rhBBCCCGECDNLSgppDz4YLPfauYZzt/8OwOzVu5m9aldoHaWfDP3u2lv+ZQps/xWA3Mpc3ln5DlqHME+GEOKEFLakhda6GBgErAauBD4KnBoKfA5cC6wFhmqtQ5x2WAghhBBCCHG0xF12KVH9+gXLd675klhXJQCPT19NaXWIS5eeMw6SOvg/awM9/XY+XfsfLp1+Ka/89grfbP0m3KELIY4T4RxpgdZ6A9AduAz4B/A18C3wLnAVcKrWOsQFnoUQQgghhBBHk1KK9CefQEVEABBVXcFtq6cDkFfu4rmv14XWkTUChr++t5y/nm//eJcKj39+i2d/eZZSV2lYYxdCHB/CmrQA0FobWuvpWus7tNbDtNYXaK1v1lp/qrX2hft6QgghhBBCiMZja9GC1L/eHSyfu+03TstdC8DHS7axeHNhaB217ge9bwZAAeM3r8BhsgFQ5CzihV9fCGvcQojjQ9iSFkqppHD1JYQQQgghhDh2JFx7LY5TuwXL9678ggiPfwWRh75YidMT4u8mB42HuJYAtHS7uMNtCZ6aljWNn3f+HL6ghRDHhXCOtMhVSv2hlHpNKTVCkhhCCCGEEEIcH5TZTMZTT4HVCkBCRTE3rP0KgOyCSl6ftzG0juwxcPErweK1Oes4yb73seHJn5+k2lsdtriFEE1fOJMWy4FM4E7gUyBPKbVSKTVZKXWFUioljNcSQgghhBBCHEGOTp1IvuWWYPmi7J/pWpgNwFsLNrNud1loHXUYBKdeA4AFeGLrRszK/1iyvWI7by5/M6xxCyGatnCuHnIakAgMB17Gn8Q4Cbgd+C+wWym1Win1hlLqynBdVwghhBBCCHFkJN16C7YO7QFQWnP/is+x+jx4Dc2jU1dhGCEuXTrkaYhKBeCk6gr+bEQFT/17zb9ZXbg67LELIZqmcK8eUqa1nqm1vl9r3Yt9kxi/A52BscDH4byuEEIIIYQQovGZbDb/ayJKAZBRmsvAnGUA/Lq1mM9/2x5aR5GJMOzFYPG2rWtoaY0DwNAGE36agMcIcTlVIcRxLeyrh9TiBqoCWzXgwz9ZsGrk6wohhBBCCCEaQWSPHiRcey2mmBjSn3oSLrwkeO7Zr9ZSXOkOraOuw+Gk4QA4tGbCzpzgqXVF6/j36n+HNW4hRNMU1qSFUsqhlBqglHpSKfUDUAzMAR4FWgD/AW4A2oXzukIIIYQQQogjJ/Wvd9Nu5kwSrrySx4dnEmkzA1Bc5eH52etC7+jCF8ARD8DpFSVcruKCp6b8MYWtZVvDGbYQogkK55KntZMULYFPgBuBtlrrtlrrG7TWH2it5W8fIYQQQgghmihTVBTWNP+cFM3iI7hnUKfguU+W5rBsa1FoHcWkwdDngsV7t6wi2eKf38Llc/HC0hfCF7QQokkK50iLMwEbsBoYCbSTJIUQQgghhBDHv9H929AlPSZYfmTqKrw+I7TGp17lX1EEiDM0DxYUBE/N3z6fxbsWhzVWIUTTEs6kxZdACXAy/tVCipVSXyql7lVK9VJKyTwWQgghhBBCHIesZhN/v/RklDZQ2mDd7nLe/2lLaI2VgoteAVs0AEOK8+lh2ruayKSlk/AZvvAHLYRoEsK55OmlQDLQE7gfWAD0B14AlgBFNZIYPcN1XSGEEEIIIcTR140y3l3+Lhdl/wTAS3M2sKu0OrTG8S1h0ATAP2P/uJxNwVMbijcwLWtaeIMVQjQZ4V7yVGutl2utX9ZaX8LeJMZ9+JMYg4BJ+JMYQgghhBBCiONA+fz5bL7kUtK3ruPGNV+RVllIldvHpNnrQ+/ktJugdX8ATna7uci5d3TF67+/TqWnMtxhCyGagMZe8rQl0K3G5kCWPBVCCCGEEOK4EnHKKZgiIgBweN3cvfxz0Jqpy3ewbndZaJ2YTHDxa2BxAHB33m4cgceVBEcCuVW5jRK7EOLYFu4lT1sppa5XSr2rlNoMZAPvAaOBZsCPwNPA+eG8rhBCCCGEEOLosSQlkfboo8Fyj/yNDNm6BK1p2GiL5A5w3sMApPt8/KWwkMfajuCziz+jXVy7cIcthGgCwrnkae0kRQb+JMXf8b8WEq+1Pltr/ZjW+rtwXVcIIYQQQghx9MUOu5DoAQOC5ZtXzSC5uoTv1uWxdEuIS6AC9L0DmvcC4PqyckYu/S8Wt7waIsSJKpwjLZoBC4GngAFAgtb6HK31eK31PK21M4zXEkIIIYQQQhxDlFKkjx+PKca/9GmU18mtK6YD8PzX69Bah9aR2QKXvAlmm79cvhO+eaQxQhZCNAHhTFrEaa3P1VpP0FrPlySFEEIIIYQQJxZrWippf3swWD5z10p65a7j163FfLc2L/SOUrvAOXv74ff/g6y5YYxUCNFUhHPJU1e4+hJCCCGEEEI0TXGXXUZEz57B8u0rpmL1eZj0zXp8RoijLQD6/xUyuu8tf3k3OP2Terp97vAEK4Q45jX26iFCCCGEEEKIE4gymUgf/ziYzQA0qyzkyo3fsz63nGm/7wi9I7MFLn0TTFZ/uWw7m2ffy/0L7ufPX/859NdNhBBNmiQthBBCCCGEEGHl6NyZxGtHBcsjN8wjvbKQl+ZswOX1hd5RWiacMw6AHRYzl5Us5pst37CqcBXf53wf7rCFEMcgSVoIIYQQQgghwi75L3/BkpICgN3wMnbFNHaUVPPR4m0N6+jMeyD9FJp7fZxdVR08/MbyNzC0Ec6QhRDHIElaCCGEEEIIIcLOHB1N6oN7J9Psk7uWPrtW88b3WVS5vQ3oyOpfTUSZuaOkNHh4Q/EG5mydE86QhRDHIElaCCGEEEIIIRpF7LALiezTJ1i+bcU0Kkor+PfPWxvWUUY36PVnurg9DK6sCh5+c/mb+IwGvG4ihGhyJGkhhBBCCCGEaBRKKdIfexQsFgDSqov504bv+OcPm6l0NWC0BcC5D4MthtuLS1GBSTg3l27m6y1fhztsIcQxpNGSFkqpVKVUj8CW2ljXEUIIIYQQQhy77B06kDT6z8Hy5VkLMBXk8cHPWxrWUXQKnH0fHTwehtYYbfGPP/6B12hgAkQI0WSEPWmhlLpdKbUe2AX8Gth2KaXWKaVuC/f1hBBCCCGEEMe25Ntuw5ySDPgn5bxm3Rz++cNmKho62qLPbRDXittKSjEFRltsLdvKjE0zwh2yEOIYEbakhVLKpJT6HHgd6AiUAiuAP4ASoBMwWSn1uVJKheu6QgghhBBCiGObKSqKlDvuAGBFakdmt+lDSZWHD37a0rCOrA4YNJ62Hi8XVVQGD7+14i08Pk8YIxZCHCvCOdLiFuByYAMwXGudqLXuobXuqbVOAi4G1gOXBeoKIYQQQgghThDxI0bQ6v332PLQ82xIaAXAP3/YTLmzgcmGk0dAi96MLSnFEhhtsaNiB1OzpoY7ZCHEMSCcSYsbgDLgXK31zNontdazgAFABXBjGK8rhBBCCCGEOMYpq5Wovn255ez2RNnMAJRWe3h/0ZYGdqTg/Kdp6fVxSfne0Rb/XPFPXD5XGCMWQhwLwpm06ArM01rn1ldBa70b+C5QVwghhBBCCHGCSYiycUP/tsHy2ws3U9bQ0Rat+kDmZdxaUoo1MNoityqXzzd8Hs5QhRDHgHBPxKnDVEcIIYQQQghxnBpzVlti7P5lUMucXt77cUvDOxk0gQzMjCivCB7618p/Ue2tDlOUQohjQTiTFuuBAUqp5PoqBM4NCNQVQgghhBBCnIDiI23c0L8NaE2v3HW8szCL0uoGjrZIaAO9x3BzSRl2wwCgoLqAT9d/GvZ4hRBHTziTFh8AccB3SqmBtU8qpc4D5gCxwPthvK4QQgghhBCiibk2oohXf5zM33/+F72yfuXdH7Mb3smZ95JqcvCnGqMt3ln5DlWeqjBGKoQ4msKZtHgT+Bo4BfhWKbVbKfVLYNsNzAVODdR5M4zXFUIIIYQQQjQxnqmf0alwKwDXr/2afy/YSGlVA0dbRKdA37HcWFJGRGC0RbGrmP+s+0+4wxVCHCVhS1porX34lzV9ANgOpAK9A1sqkBM4N1xrbYTrukIIIYQQQoimJ+Xuu8Hin9civaqYfhsW8a8fNze8o35/IckawzVl5cFDv+z6Ba1lKj0hjgdhnYhTa21orV/UWrcGWgNnBLbWWus2gXOSsBBCCCGEEOIEZ2vdmvgrRgTLV2/4jo8WbKCkyt2wjiISoN9fGF1aTg+nk1cKyvjnGX9HKRXmiIUQR0PYkhZKqVZKqcQ9Za11jtb6l8CWU6NeglKqVbiuK4QQQgghhGiakseOBZsNgCRnGeesX8jbCw9htEXfscQ7Evj3rjwGlpegFr0S3kCFEEdNOEdaZAOTQqg3ETiEv4mEEEIIIYQQxxNrejqJV18dLP9pwzw+mb+eosoGjrawx8CZ9+4tL30HSneEKUohxNEUzqSFCmyh1hVCCCGEEEKc4JJuuRnlcAAQ565k8Lr5hzbaovdNEJPh/+xzwQ8TwxilEOJoCeucFiFKBqqPwnWFEEIIIYQQxxhLUhKJ118fLI/YOJ/P56+hsMLVsI6sEXD2A3vLv38IRTLAW4im7rCSFkqps/dsgUPpNY/V2gYopW4DhgBrDztyIYQQQgghxHEh6cYbUNHRAER7nQxd8z3/PJTRFj2ug/jA9HmGl9XfPcpd8+4ivyo/jNEKIY4ky2G2nw/UXEtoSGCrjwrUf/EwryuEEEIIIYQ4Tpjj40m6YTQFr08G4NLNC7n9+3O4+ax2JEfbQ+/IYoNzH4JptzEhKZH/Va2EKmgW3Yy/nf63RopeCNGYDvf1kH/X2AA21TpWc/sX8ATQW2v9yWFeVwghhBBCCHEcSfzznzHFxwMQ6XVx8Zq5/GP+poZ31O1PkNyJDh5P8NCn6z9ld+XuMEUqhDiSDitpobUerbW+QWt9Q+DQj3vKdWy3aq2f0Fr/Foa4hRBCCCGEEMcRc3Q0yTePCZYv2ryImd+vYHeps2Edmcxw3sNcWV5OqtcLgMfw8PaKt8MZrhDiCAnbRJxaa5PW+sZw9dcQSqkkpVSeUkorpbLqqTMhcL6+7bkD9N9fKfWVUqpIKVWhlFqilLq+vvqBNi2UUu8ppXYqpZxKqQ1KqSeUUo4DtIlQSj0ZqOsMtH1XKdU89G9DCCGEEEKIpinhmmswJSUBYDe8XLZmDq/P29jwjk66BHvaKdxSUhY89EXWF+yokGVQhWhqjsbqIY3hRfyrkoRiEfBBHduyuiorpUYAC4ChwApgNtAR+EAp9UI9bToAvwOjgUJgOmAGHgfmKqX2ezEvkMyYBzwGRAfa5AA3AL8rpdqFeH9CCCGEEEI0SaaICFLGjg2WL9jyC/MW/MG2wqoGdmSC8x7l8vIKmnn8oy28hpe3/ngrnOEKIY6AJp+0UEoNBP4MhDre61+B11pqb5/V0Xci8C7+hMMVWutztdZXAF2ALOA+pdS5dVzjffxJlNe01qdorf8EdAamAv2Bh+po8yjQF/gZ6KS1/pPWug9wH5ASiEMIIYQQQojjWvyfRmJJTwfAqn38ac0cXpm7oeEddRqCtUVvbi0pDR76ctOXbCvbFq5QhRBHQJNOWiilIoC3gDVAnaMeDtMYIBaYrrX+Ys9BrXUuMC5QvK9WTKfjT0zk1aiD1toL3AZ4gLuUUpYabWzAnYHiHVrrihrtXsI/wuMcpVSv8N2aEEIIIYQQxx6TzUbyHbcHy4NyfmXJwuVszC1vWEdKwYDHuLiikpaBSTl92seUP6aEM1whRCNr0kkLYDzQDhiLPxkQbsMC+8/rODcLcAKDas1TsafNDK21q2aDQLJjIZAAnFnjVH8gDtiktf69jmvtuf7FDQtfCCGEEEKIpif+0kuxtmwJwM/pmfiU4qU5hzDaot05WNuezW01RlvM2jyLzSWbwxWqEKKRNdmkhVKqG/5RDu9prRc2oOkApdQrSql/KKUePcjohVMD+/1WPNFau4FVgAPoFEqbWse7HWYbIYQQQgghjkvKaiXjqSfJeW4KT/f5M7uikvl61W5W7Sg9eOPaBjzGhRVVtHX7f8ep0bz5x5thjlgI0ViaZNJCKWUC/gWUUOMVjBBdB9wN3Ao8BfyqlPpcKRVd6xqx+Ec/AGyvp689x1vXONbqCLWpl1JqdV0b0D6U9kIIIYQQQhxtUX37Mmj4OXTNiA0ee+Hb9Q3vqOXpmDsO4fYaoy2+2fIN64sOoS8hxBHXJJMWwF+A3sADWuvCENtkAfcDmfhX52gJjAJ2ACOA/6tVv2YSo77piisD+5g62jV2GyGEEEIIIY5rJpPi/iF7BzXPX5/P0i1FDe9owKOcX1lFR7c7eOjN5TLaQoimIGxJC6XUCqXUq0qpy5VSSeHqt47rtAL+DizQWr8fajut9Yda6xe11mu01pVa6+1a6//gT34UApcqpfo2TtRHltY6s64N2HS0YxNCCCGEEKIhzuucSs9W8cHypG/Wo7VuWCcZ3TB1vZQ7iveOtpiXM4/VhavDFKUQorGEc6RFV/wjID4D8pRSK5VSryulrlBKJYfxOm8ANvyTbx42rfUu4L1AcWiNUxU1PkfW0zwqsK85lfGedo3dRgghhBBCiOOeUor7h3QGwKQN1q/bysKNBQ3v6LxHGFDt4iTX3tEWb/z+RrjCFEI0EsvBq4QsETgbOBc4D//kkpnA7QBKqbXAAmA+/lESeYd4nYvwz2XxD6VUzeN7VvBorpSaH/h8ldZ6dwh9bgzsM/Yc0FqXKaVK8c9r0QL/sqq1tQjst9Y4tg3oUeNcqG1qnguljRBCCCGEECeEM9omcpORTe/vP6fUFsUL7ZpzVsdkaj0PHFhKJ1S3q7hjwxfcmZ4KwMIdC1met5zuqd0bJ3AhxGEL20gLrXWZ1nqm1vp+rXUv/EmMS4BXgN+BLvhHR3wC7DzMy8UD59Ta+gTOOWocc9TVuA4JgX1lreN/BPY9azdQSlmBk/Eve7ohlDa1jq84zDZCCCGEEEKcEKqX/8EVX75B6/JcuhVuxvrbEr5dk9vwjs4Zx9kuL92cruChN5bLaAshjmWNNhFnIIkxA3gEeBB4E3ABKrAdar+qrg1oG6iyqcbxLQfrT/nTs5cFirWXHJ0V2F9RR9OL8CdF5mqtnXW0uVgpZa91rTTgLKAYWFTj1CKgFGivlOpex7X2XH9G/XcihBBCCCHE8SmyZw+i+p0RLN+w5ite+mYtPqOBc1sktkX1vJ47aqwksnjXYtYU1jWoWghxLAh70kIp5VBKDVBKPamU+gH/A/q3wJ1ALvABcGO4r3uQmFKUUncopWJqHY8GpuAfpbEb+KJW038BZcAlSqnLa7RLBSYGii/WbKC1XoI/CZEKPF+jjQV/4sYKvKa19tRo4wYmB4pvKKWiarS7F+iG/5WaZQ28dSGEEEIIIY4LKffcG/zcvnQn6b8tYsYfhzCA++wHOMMDPZ1Oujtd/KvZhXRN6hrGSIUQ4RS2OS2UUk/in8+iN7BnhMFW/K+DzAfma62P1pwMUfiTAs8ppZYCu4AU/K9dJOGfI+MKrfU+S45qrYuUUjcCnwKfB+bKKAQG4X9F5SWt9fw6rncD8DNwt1JqAP75MHoD7YCfgGfraPP3QL/9gI1KqYVAa/wJlXyOcKJHCCGEEEKIY0nEKScTM3Qo5bNnA/DnNbP5+zd9GNYtA6u5Ab+LjW2G6j2G1395gxhDo0r+C2c9Ao7YRopcCHE4wjnS4lGgP/5JLW8C2mqt22qtb9Baf3AUExbgTzQ8DywDOgEj8Me6G/9IiZO11ovqaqi1/h/+CUa/wT/B5oVAFjBaa31fPW02Buq+jz85chlgAE8BA7XWrjraOPFPYPoUUAVcij9p8T7QU2u9ucF3LYQQQgghxHEk5e67wGwGIKOqkJN++57Pl21veEdn3kOsOdL/znp1MSx+M6xxCiHCRzV4jeP6OlKqCP/oA/C/UrEQ+B7/KIvfdbguJA6ZUmp1165du65eLetRCyGEEEKIpmnX4+Mp+fRTAIrsMTw8YgLfPDQEh9XcsI6+ewoWvuD/bIuBu/+AqKQwRyuEyMzMZM2aNWu01pmH0j6cIy2S8L9ucS/+REU/4AVgKVCklPpSKXWvUqrn/7d313FWVP8fx1+fDZbubpBQsLAVA1TsQLH9qtiBgWIHIgYGKoqNimKLATaKCKIoGCClpCAguc0u2+f3x8xe7m/dujDb7+fjMY/hnJlz5nPvYXfvfnbmHItobSIRERERERFP8yFDIM57Gr1pZioHzZ3KW7P/ibyjQ66D2o28f2elwszHiz9fRCpEkEueOufcPOfcGOfcQKA5sC9wMzAD73GMx/CSGFuCuq6IiIiIiNQcsa1a0uzCC0PlM5d9x4Sv/iAtMyeyjuo0hkO3T+7pfhnHrCUf8/WqrwOKVESCUJZLnjrn3FzgQ7xVOT5j+5KnjcvquiIiIiIiUr01u+xSrIG3MGC9nAyOnvcVL8/8O/KODrwSGrRldUwMl7VozJU/D+fB2Q+Snp1eclsRKRdlseRpRzO70MxeNbOVwN/AeOAC/3o/Ag8FfV0REREREakZohs1osWVV4TKp6z8kQ+/+pUtW/8z333xYutA/zup4xzz42oBkJCRwITFE4IMV0R2QmBJi0KSFIOBNsAPwIP4y4Q65w5zzt0T1HVFRERERKTmaXL++US1aAlArbwcTlvwFc9MWx55R3udS8um3flfSmqo6rVFr5GQkRBUqCKyE4K802IwXpJiJv7SnkAT59wRzrnhzrlp/rKeIiIiIiIiOyWqTh1aXjckVB6w+hdmfDOH1fFpkXUUHQNH3cvFySk0zM0FIC07jXHzxwUZrojsoCCTFv3x7qTo55wb4Zz7TkkKEREREREpK41PP53Yzp0BiMZx3sIvefzrpZF31PN4GrY7kMuTUkJV7y15j3+3/htQpCKyo4JcPWSGcy7Ch8hERERERER2jMXE0HLo0FD50PULWPLdTyxclxxhRwYDRnJO6lZa5XirkGTnZfPsvGcDjFZEdkSZrB5iZgeb2a1m9pS/3WpmB5fFtUREREREpOZqcOwxxO2+e6h88eIveOTLPyPvqOOB1O55Itckbk94fLriU5Ym7sCdGyISmECTFmbWw8xm402+OQq4zt9GAT+Y2Wwz6x7kNUVEREREpOYyM1oNuwmAXIvi33rN+XnJRmYu2xx5Z0cN55S0bXTJygbA4Xj696eDDFdEIhQTVEdm1gaYAbQC/gUmAqsAB3QGzgT2B6ab2X7OufVBXVtERERERGquegcfTPPrr2dESis+T4oD4JGv/qLvLs2JirLSd9SiJzF9/scNf01kaKsWAMxYO4PfN/7OPq32KYvQRaQEQd5pcTdewuJJoKtz7kbn3FPOuaedczcBXYEn8FYYuTPA64qIiIiISA3X4pqruey8/qHywnUpfLZgB/5O2u8Ojsxy7Jmxfbq+Mb+PwTkXRJgiEqEgkxYnAEucc8Occ1kFDzrnsoFbgCXASQFeV0REREREhD4dm3D87q1D5dFTlpCVkxdZJw3bYgddzdDEpFDV3E1zmbF2RkBRikgkgkxatAF+L+4E56Unf/fPFRERERERCdTNx/Yk2n8k5J+EdN6Z80/knfQdyv7U4dD0baGqp35/ity83KDCFJFSCjJpkQJ0KMV5HfxzRUREREREArVLi/qcvb/3a0lcThYvTlnI1sycyDqp0xgOv5mhiUmY/1jI8qTlfLbys4CjFZGSBJm0+Anoa2YnFnWCmZ0A9AVmBXhdERERERGRkBv6deXEtb/y8tRHGDD3K8Z9vzLyTva/nJ61W3FCWnqo6tl5z5KZm1lMIxEJWpBJi4eBPOBjM3vDzI43s9387Tgzex342D/n4QCvKyIiIiIiEhL7+SSu/fVdmmckc9ryGXw45Xc2p0aYbIitDUfexZDEJGL8uy3Wp63nvb/eK4OIRaQogSUtnHM/ARcD2cD5wGfAQn/7HLgAyAEuds79HNR1RUREREREwjU+bSBRzZsDEJeXw1l/fM7Yacsi72jPs+nQtCdnpmwNVb2y8BXdbSFSjoK80wLn3JtAT+B+YDqw1N+mAyOBXf1zREREREREykRUvXq0vP66UPmoNb8xa8rPrNqSFmFH0XD0CK5MSqZeXh5907fxUq8riIuOCzhiESlKoEkLAOfcWufcvc65o5xzu/nbUc65Ec65NUFfT0REREREpKDGp59ObLduAEThuHjBJ4ye8lfkHXU/hmYdDuajdet5YeNmes56EfIiXEZVRHZY4EkLERERERGRimYxMbS+5eZQeZ/Ny1g/dToL1iZH2JHBgJG0zfGXO13/Byx4P8BIRaQ4SlqIiIiIiEi1VO/ww6l74IGh8qWLPmPUZ4tw/sSapdZ+P+h9+vbytyMhK73o80UkMDuctDCz3J3YIlwoWUREREREJDJmRqvbbsWZAdAlZQP1Z0xh2l+bIu/s6Hshupb375R18POzAUYqIkXZmTst1gD/7OCmuS1ERERERKTM1e7Vi0YnnxwqX/jnV4yePI/s3AjnpWjSGQ68KlTM+2EMny16m1nrZgUUqYgUJmZHGzrnOgcYh4iIiIiISJloOfQGkr/8CsvOollGCnv//CXv/rIrFxzUKbKODhsGc9/kz9xURjSvx+JfR9G5YWc+OvUjYqNiyyZ4kRpuZx4PGW5mpwQZjIiIiIiISNBi27al+eCLQuUzl33H+E9+JTUjO7KO6jSGfrcT4+CvWt6jIqtSVvHB0g8CjFZEwu3M4yEjgIH5BX+uild2NiAREREREZGgNbvicqxxYwDq5GZxwu+f8dz0FZF3tN8ldG/YidO2poWqnp/3PKlZqQFFKiLhdiZpkQvUCiubv4mIiIiIiFQq0Q0a0HLIkFD5uNVzmPLFz6xNjHAVkOhYGDCSIYlJ1Mnz5sVIzEzk1YWvBhmuiPh2JmmxHtjfzOoEFYyIiIiIiEhZaXL2WcR08uaxiHZ5XDD/Ux6bsiTyjnqeQIv2h3Bxckqo6o3Fb7B+6/qgQhUR384kLSYB3YHNZrbSrzvDzFaWYtuB+7BERERERER2nNWqRathN4XKB21YzMpvvuePNUkRdmRw7ANclJxK85xcADJzMxk7d2yA0YoI7FzS4nbgGSAe6AQ4oD7QuRRbl524roiIiIiIyA5pMGAAtffZJ1S+bNFnPPTZIpxzkXXUtg919zibaxOTQlWfrfyMxfGLA4pURGAnkhbOuXTn3PXOuU7OuWi8+Sxec85FlWYL7iWIiIiIiIiUjpnR+tZbAMiMiuH3lj34feUWpizaGHlnR93DwIxcumVlAeBwPP7r45EnQESkSEEmD2YAfwXYn4iIiIiISODq7L03rYbfw6tXPsrrvU4gOzqGh7/8k6ycvMg6atSe6IOHcFNCUqhqzoY5zFw3M9iARWqwwJIWzrn+zrlHg+pPRERERESkrDQ97zyuPedQovz1D1fFp/PW7NWRd3TojRwa1YCDtm0LVT3+6+Pk5OUEFKlIzabHNEREREREpEbq0aoB5xzQMVR+6ttlJKdnR9ZJXAOs/50MS0jC/MdCViav5OPlHwcZqkiNpaSFiIiIiIjUWDce3YN6taIBSErP5pnvlkXeSZ8L2bXRLpy8NS1U9ezcZ0nLTiumkYiUhpIWIiIiIiJSY7VoEMc1/bsB0DAzjSlf/8o/8emRdRIdA8c8wHWJycTlefNixGfE88qCV4IOV6TGUdJCRERERERqtEsObM9Fa2fxyjejuP6Xd3jkyz8j76Tb0bTudDgXpqSGql5f9Drrtq4LMFKRmkdJCxERERERqdHyFs7nnF8/on5OBr0TVpEy5St+W50YWSdmcMz9XJaUSoscbxLOrLwsnvj1iTKIWKTmUNJCRERERERqtHoHHED9/v1D5UsXfs7Dk+fh/Ik1S631HtTd+3xuSEwOVc1YM50NaRsCilSk5lHSQkREREREarxWt92Ki4nx/r0tka7ffcpn89dH3tGR93ByVhS7Z2Zy7NY0Pml8MK3rtQ44WpGaQ0kLERERERGp8Wp17kyzCy4Ilc9e+i3Pf/gz27JyI+uoQSuijriFV9dvYvTmeNr+/jZsXBxwtCI1x04lLcystpk9YGYrzGybmf1tZk+aWZGpRDMbb2Y5O3NdERERERGRoDW/+ipo3BiAOrlZHPvzx7z0/crIOzrwKuo06eL92+XCV7dDpI+aiAiwE0kLM4sBpgB3AF2AOKATcD2w0MxOKa75jl5XRERERESkLEQ3bEjroTeEysf88ytTJn3Hv0nbIusoJg6OfWh7+e8ZsOSLgKIUqVl25k6La4DDgDXAeUBv4GRgGtAU+MjMrtnpCEVERERERMpJ4zPOIKZbt1D54rmTePiLHVgCtcdxsMuR28tT7oKczAAiFKlZdiZpcR6QARzlnHvXOfenc+5z59wAvIRGDjDWzO4OIlAREREREZGyZjExtL3rzlB59/i/SfzyS35ZlRBhRwbHjgKLBiA78W/e/GoII2aNCDBakepvZ5IWvYAfnXMrCh5wzr0ADACSgfvM7PGduI6IiIiIiEi5qXfwwf9ZAvXBj+eSlxfhvBQtd4X9L2NTdDSD2rXhkfjZfLjsQ37Z8EvAEYtUXzuTtIgDNhd10Dk3Ezgc2AgMNbNxZqa5LEREREREpNIruARqz+8/54Pf1kbeUb/baV6rIQ3y8kJVj8x5hNy8CFclEamhdiZpsQ7oUdwJzrmFQF/gb+AS4G0gdieuKSIiIiIiUuZqde5Ms//9L1Q+e+m3vPjxbFIzsiPrqG5Tovrfxa0JiaGqJYlLmLR8UkCRilRvO5O0mA3sbWbtizvJOfc33oSdi4Cz/E1ERERERKRSa37N1VjYEqin/DqZZ75bHnlH+17MXo26ceLWtFDV03OfZmvW1oAiFam+diZp8anffkhJJzrn1uM9KjIbiNmJa4qIiIiIiJSL6IYNaVVgCdQZn37P31vSimlVWEcxcNwohiYkUcd/TCQhI4GX5r8UZLgi1dLOJC0+Bx7Em2yzRM65JOAo4Clgwk5cV0REREREpFw0PuMMYrt1D5UvmzeJBz9bHHlHXfvRuvvxXJycEqp64883+CflnyDCFKm2djhp4ZxLds7d45x7OII225xzNzrnLt7R64qIiIiIiJQXi4mhzZ23h8q9E1aR8e03fL+0yDUJinbMAwzemkHrnBwAcvJyePxXLbQoUpydudNCRERERESk2qt3yCHUHzCAjFp1eHH3U/ipze7c/9lisnPzSm4crmkX6hw0hBsTkkJV09ZMY/b62cEGLFKNKGkhIiIiIiJSgtZ3303sWx8wufvh5EZFs2zTVt76eXXkHR02jOOtAXtlZIaqHvnlEXLycgKMVqT6UNJCRERERESkBLGtWrL7Hl05e78OobonvllKQlpWZB3FNcCOHsHt8duXQF2WuIz3l7wfVKgi1YqSFiIiIiIiIqU07JieNIjzFkRMycjhyW+WRt7Jnuewe/PdGZi6fcnTZ+Y9Q0JGQlBhilQbSlqIiIiIiIiUUosGcVx3VLdQ+a3Zq/lrQ0oxLQoRFQXHP8INCUnU95dATc1K5enfnw4yVJFqQUkLERERERGRCAw+pAtdmtejZXoC18z9kIc+motzLrJOOhxA8z3OZkhicqjqo2UfsWDzgoCjFanaAktamNmeZrZ7UP2JiIiIiIhURrViong4cy4vfvsYJ676iY5TPuSLBRsi72jASM7JNLplefNiOBwPzX6IPBfhqiQi1ViQd1rMAyrkfiYza2Zmm8zMmdnyEs4dbGZzzGyrmSWY2RdmdkgJbfr65yX47eaY2YUltGlvZuPN7F8zyzCzpWZ2n5nVLqZNHTMb6Z+b4bd91czaFf8OiIiIiIhIeeocm0Pt3GwAzlz2HS+++z1pmRGuAFK/JTH97+TOsEk5F8YvZNLySQFGKlK1BZm0SADWB9hfJB4Hmpd0kpmNAcYDuwNTgTnAAOB7MxtYRJtBwAzgOGA+8BXQHXjdzEYX0aYbMBcYDMQDk4FoYDgw1cziCmlTG5gG3APU99usAS4G5ppZ15Jen4iIiIiIlI/m11wDzbxfQWrl5XDqrIk8812xfz8t3P6Xs3/DXThuaxoADZxhkT5qIlKNBZm0+BnYI8D+SsXMjgIuAsaVcN7RwA14SYS9nHMDnXPHAYcDucB4M2tcoE1T4FW8hMMZzrl+zrkzgF2B5cAwM+tXyOVew0uiPO2c28M5dzbQE/gY6AvcUUibu4GDgJ+AHs65s51zBwLDgBZ+HCIiIiIiUglE169H29tvDZUP2bCI3yd+wcrNW4tpVVhHMXDCaIYlJHFmSiqf/rOG01KSS24nUkMEmbS4D+hpZsMC7LNYZlYHeBFYDBR610OYm/z9A865ZfmVzrmfgBeAxsClBdpcBjQEJjvnPgprsxHI/w71/16vmR2Al5jYFHYOzrkc4GogG7jezGLC2tQCrvWLQ5xzW8PaPYF3h8cRZrZvCa9RRERERETKScOTTiKuzz6h8mV/TGLkpPmRT8rZuS+te53O8PhEmuXlwbcjIV3Ln4pAsEmL3YA3gUfNbK6ZPWBmV5jZhYVtAV3zXqArcBVeMqBQfnLjSL/4QSGn5NedXKD+xGLafA5kAEcXmKciv82nzrnM8AZ+smMm0AQ4NOxQX6ARsMI5NzeC+EREREREpIKYGW2H340z79eq9ls30/yrj5iyaGPknQ24H2rV9/69LRG+vS/ASEWqriCTFq/hzeFgwF7AncDzeHNIhG+v+fudYmZ74t3lMN45N7OE03sCccBm59zaQo7/7u/3LFC/V4HjIc65LGAhUBvoUZo2xVxrR9qIiIiIiEgFq73bbjQ55+xQ+dwlUxn73iy2ZeVG1lHDNtDv9u3l316HdUX9eiBSc8SUfEqpjQTKZcYYM4sCXgaSCHsEoxgd/X1hCQucc2lmlgQ0MbMGzrlUM2uId/dDke38+v2ATniPcJR4rbD6TqWNr4g2IiIiIiJSCbS84XqSvvgCkpOpm5PJiT99wHPTezPsmJ6RdXTgVTD3Tdj8F+Dgi1tYd/ZrNK7TlHqx9cokdpHKLrCkhXNuRFB9lcJ1wP7Axc65+FKc799nRXox56ThzWvRAEgNa1NcuzR/3yCCawXVpkhmtqiIQ7uUpr2IiIiIiJRedOPGtL7xRjaMGAFA/7VzuePDqQzapz2dm0eQbIiOhRMeg9dPJsOM8WlLeWXSKZzX+wJu2vemktuLVENBPh5SLsysI/AAMMM591oFhyMiIiIiIkLjM88gdrfdQuXL537IyMk7MClnl8Oh9+m807A+zzVpTKbL4Y1Fb7AyeWXAEYtUDWWStDCzvczscjO7w8xOCauP8x+72BnPArXwJt8srfzVOOoWc05+CjS1QJvi2hVsU5prBdWmSM653oVtwIrStBcRERERkchYdDRth98TKndNWU/9rz5h6p+bIu/smAc4Z1sebbNzAMhxOTw8++HIEyAi1UCgSQsz62lms/AmjnwB746IgWGnnAckmtlxO3GZk/Aeo3jBzKbnb8C7/vF2YfWt/bp//H37IuKuh/doSKJzLhXAOZcCJBfXLqx+dVhdsdcKsI2IiIiIiFQidfv0oeHAgaHyhX9+xZj3ZpGRHeGknI3aUefwW7klITFU9dP6n5j2z7SAIhWpOgJLWphZB+B74CDgU7wJMq3Aae8DWcCgnbxcY+CIAtuB/rHaYXX5S5EuATKBFmbWrpD+8hdXnl+g/o8Cx0PMLBbYHW/Z06WlaVPMtXakjYiIiIiIVDKtbrkZ6ntT0dXLyeDEHyfy/PQduOH5oGs4qm57Dt62LVT16C+Psi1nWzGNRKqfIO+0GA40By5zzg10zj1e8ATnXBowj+0Jhog556ywDejin7IirH6V32YbkJ+WPLOQbs/w958WqP+8wPFwJ+ElRaY65zIKaXOymcWFNzCzVsBhQCLwY9ihH/Hu6tjFzPaOID4REREREalEYpo1o/XN2yfN7L92Lj++/yX/xBe3JkBhHdXCjn+U2+MTifEfC/k37V9eXvBykOGKVHpBJi2OA+Y7514t4bxVQGF3O5S1J/z93WbWPb/SzA4GrsRbPvWVAm1eBlKAU83s9LA2LYFH/eL/S8445+bgJSFaAo+EtYkBngNigaedc9lhbbKAZ/zis/7jKvntbgL2xJt49LfIXrKIiIiIiJS3xmeeSa3eu4fKV8z9kAcnzYu8o12OpGu3E/hf8vap7cYvHM+q5FU7H6RIFRFk0qIl3mMYJYml+Akxy4RzbirwFNAMmGdmk8zsC7xHWmLwlk9NKtAmAbgEyAM+MLNpZjYR73V2A55wzk0v5HIXA/HADWY238ze9ducDswCRhXS5gFgNnAIsMzM3jOzn/GSIpv9OEREREREpJKz6GjajhyBM+/Xra2xdfl1/iqm/bUx8s6OfYir0rJpmeNNypmdl80Dsx/QpJxSYwSZtIgHOpbivB7A+gCvW2rOuaF4CYU/gQHAwcBU4HDn3KQi2nwIHA5MAfoAJwDLgcHOuWFFtFnmn/sa0AI4DS/xcT9wlHMus5A2GUB//5x0vAlMO/l97OOc0xpHIiIiIiJVRJ3evWl+1ZV8cvRFDDt8CPF1GjHik8WRT8rZuAP1Dr2J2+O3T8o5e/1svvz7y4AjFqmcLKgMnX8HwkBgf+fcPL8uD3jNOXeJXz4C+C68TsqPmS3q1atXr0WLFlV0KCIiIiIiNcJfG1I48ekfyM3zfu+68ege3HB09xJaFZCTiXuhL9dEJ/FD3ToANK/dnE9O+4QGtRoEHbJIoHr37s3ixYsXO+d670j7IO+0GI23WshkMzvezKLDD5rZkcAbQA4wJsDrioiIiIiIVEq7tm7IhQd3CpWfnb6cVVvSIuskJg478UnujE8gLi8PgC0ZWxg7d2yQoYpUSoElLZxzs4HrgbbAZ3gTWzpgkJklAt/4x651zmnpThERERERqRFuHNCDlg28hQWzcvK4Z/LCyOek6HIYHXqfxeXJKaGq9/56j0Xxuotaqrcg77TAOfcc3pKen+IlLAxoAMThzQlxhHPupSCvKSIiIiIiUpk1rB3L8JN7eQXnWPPrfD6bvwPT/B3zABdnRNE5y1uIMI887v/pfnLzIpwnQ6QKCTRpAeCc+9k5NxBoBLQC2gANnHMnOOd+DPp6IiIiIiIild2Je7RhYPNcHpw1jrHTx/DKG1NJyciOrJN6zak1YCR3xyeEqhbFL2Li0okBRytSeQSetMjnPJudcxudc0r9iYiIiIhIzeUcV019gX02LyXG5XHeT+8y+qu/Iu+nzwUc2GJvTti6fV6Mp39/ii3btgQYrEjlEVjSwsxWmNntZtY6qD5FRERERESqA4uKov0dt4XKe8T/zfr3P+SPNUmRdRQVBSc9yS2JKTTI9SblTM3eygdLPwgwWpHKI8g7LToDDwL/mNlHZnacmVmA/YuIiIiIiFRZ9Y84grpHHx0qX7rwM+5/52dy/ORDqbXqTfMDrua6xCSa5OZy/5Ykrmx9RMDRilQOQSYtOgEjgfXAQOBzYJWZDTez9gFeR0REREREpEpqe9eduNp1AGiUlcbB097jjZ9XR95Rv9s5K6oJn65dz8DUFOyLYRDpiiQiVUCQS56udc7dh3fHxQnAJKA1MAL428w+NbNTzKzM5tEQERERERGpzGLbtKHVddeGysetms0nb3/NhuSMyDqqVY/oEx6jUZ5/l8bqH+GPdwKMVKRyKIvVQ5xz7ivn3CCgA3A78DdwIvAxsMbM7jezzkFfW0REREREpLJreuEFRO/SDYAoHJf++j73fzI/8o56Hg+7nrS9/PXdkJ5Q9PkiVVCZ3vXgnNvknHsU2A14EjC8JVDvApab2WQz27ssYxAREREREalMLDaW9iNHhMq7JP9L7UkT+e6vTZF3dtzDEFvP+3d6PHwzHOccTo+KSDVRpkkLM+tkZiOBVcBQv3oW8ACwHDgZmGNmp5VlHCIiIiIiIpVJ3X33pdGgQaHy//6awlNvTWdbVm5kHTXuAP3vCBVXLnyHSz85g2n/TAsqVJEKFXjSwsxizGyQmX0FrADuBhoAzwN7OucOdc4Nd87tCpwN5OJN4CkiIiIiIlJjtLrlZmjSBIDaudkMmvE2Y79dGnlHB14NrfZgcv16DGrXhl+SljJqzijSstMCjlik/AWWtDCz7mb2CLAWeB84BpgHXAG0dc5d65xbGN7GOTcR+AzoEVQcIiIiIiIiVUF048a0vfuuUHm/TUtY8vaHLN2YGmFHMXDSk+yZmYX5VRvTN/LM3GeCC1akggR5p8US4GagPjAeOMA5t59z7mXnXHox7ZKB2ADjEBERERERqRIannACtQ89NFS+7I9JPPj2z5HPSdFhf7rs+T8uTUoJVb3151ss2LwgqFBFKkSQSYvFwA14d1Vc5pz7tTSN/HO1DKqIiIiIiNQ4Zka7ESPIi6sNQOOsNPb58g0++G1t5J0dfS+XZcXSOSsbAIdjxE8jyM7LDjJkkXIVWLLAObe7c+4Z51xKyWeLiIiIiIgIQK327Wg99IZQ+Zh/fmHSq5NJSMuKrKM6TYg7/hHujd++7OnSxKVMWDQhqFBFyp3ucBAREREREalgTS/4H1E9dw2VL579HqMmzYu8o90HsV/7wxmUsjVU9fy85/gn5Z8AohQpfzFBd2hmdYH+QHe8VUOskNOcc+7+oK8tIiIiIiJSFVlMDB0feoC/zzgLc3m03JbI0mmz+H7/Lhzeo0UEHRmc9AQ3Pncw0+vmEh8TTWZeFiN/Hsm4AeMwK+zXM5HKK9CkhZkNBp4EGoZXA66QspIWIiIiIiIivjq9e9P0ogv5/esfGbXbQNY0aMWdHy/g6xsPp26tCH51a9yRRkfezR3f38fNrbyEx+z1s/lkxSec2u3UMopepGwEueTp0cAreAmJh4Cf/ENXAo8By/ESFs8AlwR1XRERERERkeqi1U030nnCBNY3ag3A2sRtPPH10sg7OuAKjmmyG0ekbwtVPfbLoyRkJBTTSKTyCXJOi2F4CYv+zrl7gGUAzrlxzrnbgd7AGLyExW8BXldERERERKRasFq16NW+MVce0TVU9+qPfzN/bVJkHUVFY6c8w90JydTNywMgOSuFx355LMBoRcpekEmL/YGfnXN/FHbQOZcD3AxsAu4L8LoiIiIiIiLVynVHdqdL83oA5Dm47cMFZOfmRdZJq960Puh6rk9MClV9tvIzflz3Y4CRipStIJMW9YHwKWkzAcysQX6Fcy4PmA0cFuB1RUREREREqpXasdGMOn2PUHn1PxsZN3Nl5B0dfgvnxLZij4zMUNX9P40kPTs9iDBFylyQSYsNQNOw8np/36PAeU2BOgFeV0REREREpNo5qGszzt2/PQNWz2H816P46fWP+HtLWmSdxNYm+uSx3LslgRjnrY+wLu1fnv/j+TKIWCR4QSYt/sJb5jTfLLyJN281f10dMzsEOBJYEuB1RUREREREqqWrl37FTXPfp2F2OlfM/Yh735mNc67khuE696XnnuczODklVDVh0QQWxy8OOFqR4AWZtPgc6GJmB/jlb4H5wBnAOjP7DfjOv+aYAK8rIiIiIiJSLbU6+yxcTCwAzTOS2f2Lt3j/1zWRd3T0fVyZXYeO2dkA5JHHI3MeDjJUkTIRZNJiAnA8sBFC81ecCHwDtAT6AOnA3c65NwO8roiIiIiISLUU17ULLa6+KlQ++e9ZfDT+MzalZETWUZ3G1D7hMYZv8ZY8PWjbNh5otG+QoYqUicCSFs65ZOfcFOfc6rC6dc6544CGQDuguXNuVFDXFBERERERqe6aX34Z0d22P4l/+ex3eOCj3yPvqNcpHNh5ABP+3cBLGzbT4fvHIXVDgJGKBC/IOy2K5JxLd86td87lmtklZja8PK4rIiIiIiJS1VmtWnQY9RDOvF/f2qVtocUHE/h60Q4kHE4YTR9qYwAZyfDlrYHGKhK0cklaFHA5cG8FXFdERERERKRKqrPH7jS75OJQ+bTl3/PqK5+RkpEdWUcN28CA+7aXF0+Gvz4PKEqR4FVE0kJEREREREQi1OK6a6FDRwCicVw0801Gf7Yg8o72GQwdD9le/nwYbEsKJEaRoClpISIiIiIiUgVE1a5Np4cfwpkB0Dl1I+6N8fyyKiHCjqLglKchOg6AvNT1vPPJxdwx847Il1MVKWNKWoiIiIiIiFQRdffdl8bnnhcqn7V0Gk+/9AUZ2bmRddS8O/S7neQo4+I2LXkoYzmfrfyMKaumBByxyM5R0kJERERERKQKaT3sRvJatQEgxuVx1revMWbK4sg7OuR6Grbei9iwmysemv0gCRkR3rkhUoaUtBAREREREalCourVo/OoB0LlbsnrSHx1PPPWJEXWUXQMdurz3JuQQp28PAASM5N4ePbDAUYrsnOUtBAREREREali6h1yCPVPOz1UPu+vbxj90ldk5kT4mEirXnToO4wbEpNCVV+u+pJv//k2oEhFds4OJy3MLHdHNuCAAOMXERERERGpkdrecRt5zZoDUCsvh9O+fY2x3yyJvKNDb+Tcup3pk5ERqnrgp/tJzkwOKlSRHbYzd1rYTmwiIiIiIiKyE6IbNqTj/SND5V4Jq1k3fgIL1kaYbIiOJWrgC9wXn0ytPG+Ciy0Z8Tz2y2NBhiuyQ3Y4aeGci9qJLTrIFyEiIiIiIlITNTiyP3VPOCFUPnTtPG6dOJesnLzIOmq9B10OHsqQpKRQ1eQVk/lh3Q8BRSqyYzSnhYiIiIiISBXW7p67yWvWggm7Hstth17NnxvTePa75ZF3dNjNXBjXgd6ZmaGq+2aNYGvW1gCjFYmMkhYiIiIiIiJVWEyTJuz27ddED76UnKgYAJ79bjmL/o3wMZGYWsQMfI6RW5KIcd5jIhvSN/Lkb08GHbJIqSlpISIiIiIiUsVF1a7N7cfvRrvGdQDIyXPcMnE+2bkRPibStg89DhjCFUnbEx7vL32fOevnBBmuSKkpaSEiIiIiIlIN1I+L4eFBe4TKi9en8ML0FZF31O92LottQ4/MrFDVvbOGk56dHkSYIhFR0kJERERERKSaOKx7C87Zv4NXcI73PvmZvzakRNZJTByxpz7P/fGJRPuPiazduo6xc8cGHK1IyZS0EBERERERqUbuPHE3esRlc+cvb/D01NGMevlbciJ9TKT9vvTa90ouSd6e8Hjrz7eYu2luwNGKFE9JCxERERERkWqkQa1oHp/1Iof9O586uVmc+OXLvDRjB1YT6X8nV0Y1p2tWNgAOx90z79JjIlKulLQQERERERGpRiwqik43Xhcq7xG/khUvvMqyjamRdRRbh7hTn2fklgSi/MdE/tm6hg+WfhBkuCLFUtJCRERERESkmml4wgnUHnBMqHzBws95ZNzX5Oa5yDrqeCB79bmUS5JTqJXnuDk+kfPr7RJwtCJFU9JCRERERESkGuowcgS5jZoAEJeXwwmfj2PcjGWRd3TkPVwd1ZwP/l3PRSmpRE++BjK3BhusSBGUtBAREREREamGYpo0odODI0Pl3RJXs+rZlyJfTaRWXWqd9hJdcvzJPBNXwTf3BBeoSDGUtBAREREREammGhx9NHVOODFUPm/xVzz63Bdk5US6msh+cOhN28u/vgrLpwYUpUjRlLQQERERERGpxjrcew+5TZsDEJuXy8ApL/PMN39G3tERt0HrPbaXJ1+LS08gIycjoEhF/ktJCxERERERkWosulEjOj/yUKjcPXkdCS+9xLw1SZF1FFMLTnsRomsBsCF9E1d/dAr3zro3wGhF/j8lLURERERERKq5+ocdRr3TB4XKZ/81lSef+4SM7NzIOmrVG/rfyfLYWE5v14Yfc5P54u8v+Gb1NwFHLOJR0kJERERERKQGaHfn7eS1bAVAjMvj7G/H89hnCyLv6JDr6dK6D92ys0JV98+6j/ht8UGFKhKipIWIiIiIiEgNEF2/Pp0ffThU7pKygZzx45i1YktkHUVFEz3wBR5ITKdOnjehZ2JWMiN/GolzLsiQRZS0EBERERERqSnqHXQQDc89L1Q+c+l3PPfcZFIzsiPrqNkudDxyBDcmJIWqpq2ZxmcrPwsmUBGfkhYiIiIiIiI1SJtbhuHatQcgGsdFM15n1Ee/R97R/pdxdvP9OHDb9tVDRv38IBvSNgQVqoiSFiIiIiIiIjVJVN26dH7sEZwZAO23bqbJGy8ydfHGyDoyI2rgs9yfkkU9/zGR1Jw0Rsy6V4+JSGCUtBAREREREalh6u6zD00uvhiAXIyU2Hrc/uF8EtKySmhZQKP2tDnmYW6LTwxV/fjvLD5Y9kGQ4UoNVmWTFmZ2k5l9ZGbLzCzZzDLNbLWZTTCzPQo5f4SZuWK2hwu7jt+2r5l9YWYJZrbVzOaY2YUlxNfezMab2b9mlmFmS83sPjOrXUybOmY20j83w2/7qpm1i+zdERERERERKV6roTdgh/Xjzn7X8kav49iSlsXdkxZEfpfEXucwsF0/Dk/fFqp6bM6jrElZE3DEUhNV2aQFcCdwPJAAfAt8DmQAFwC/mdlJRbT7EXi9kO23wk42s0HADOA4YD7wFdAdeN3MRhfRphswFxgMxAOTgWhgODDVzOIKaVMbmAbcA9T326wBLgbmmlnXIt8JERERERGRCEXVqsWu457nlPOPC9V9sWADn/zxb2QdmWEnP8WINEfD3FwAtuVmcMfM28nJywkyZKmBqnLS4lSgiXPuQOfc6f7WExgCxAIvm1lMIe1eds4NLmSbWPBEM2sKvIqXcDjDOdfPOXcGsCuwHBhmZv0KucZrQHPgaefcHs65s4GewMdAX+COQtrcDRwE/AT0cM6d7Zw7EBgGtPDjEBERERERCdQlfbtwYJemofI9kxayITmjmBaFqN+CFieOYfiWhFDVH1vm88qCV4IKU2qoKpu0cM796Jz7z1eSc+45YAXQCui1k5e5DGgITHbOfRR2jY3ArX5xWHgDMzsALzGxKewcnHM5wNVANnB9eELFzGoB1/rFIc65rWHtnsC7w+MIM9t3J1+PiIiIiIjI/xMVZYw+cy/q1YoGICUjh1s/nB/5YyK7ncyx3QdycmpaqOr5P55jweYFQYYrNUyVTVqUIH+R4QhnkfmPE/19YbPI5D+OcnSBeSry23zqnMsMb+AnO2YCTYBDww71BRoBK5xzcwu5Vv71T44sfBERERERkZJ1aFqX4Sd7f/Otn5VOx8lv8saPKyPv6PhHuSOnHm2zvcdCcl0ed8y8jfTs9CDDlRqk2iUtzOwCvEcxlvlbQUea2Rgze8HM7i7h7oW9/P1/Fi12zmUBC4HaQI/StClQv+dOthEREREREQnMWft14OLam3h+2mjOX/INS598lmUbUyPrpHZDGpw+joe2JGD+nRqrU9fw+K+Pl0HEUhNU+aSFmd1iZq+Z2UQzWwhMANYD5zrncgtpcgFwA3AlcD/wq5l9YGb1C/TbEO/uB4C1RVw+v75TWF3HcmpTJDNbVNgG7FKa9iIiIiIiUvOYGRekLKZ5RgoAZy+ewmNPTyIzp7Bfq4rR8SD2PeA6LklOCVW9v/R9ZqyZEWS4UkNU+aQFcCxwEXAG0BtYjZewKLgayHLgZv+c+kAH4HxgHTAIeKPA+eFJjKLuZcp/WKtBIe3Kuo2IiIiIiEigOt03nJwWrQCIcXmcMWUcT322A3NSHHEbQ+ruwm6ZWX5fjo0JS4IMVWqIKp+0cM4d7ZwzvHkiDsd7JGSGmd1V4Lw3nXOPO+cWO+fSnHNrnXNvA/vjLUs60MwOKvcXUAacc70L2/AmKBURERERESlUdIMGdH38UZwZAB22boaXxjJrxZYIO4ol9vSXeTgxnd6Zmbzz7wbO+uNzyMsrg6ilOqvySYt8zrkk59xM4ATgN+B+M9u/FO3WA+P94nFhh7aG/btuEc3r+fvwB73y25V1GxERERERkcDVO+AAGl00OFQ+eeUsxj/5Dsnp2UU3KkyzXeh69AO88+9Gds3KhpXTYfbzgcYq1V+1SVrkc85lA+8BRulX28ifsLNNWD8pQLJfbF9Eu/z61WF1/5RTGxERERERkTLR5qahuF26h8qDZ77ByLdnRb4M6j4XYruetL08dQRsWBhMkFIjVLukhS//3qUWpTy/ib9PK1D/h7/fp2ADM4sFdsdb9nRpadoUqJ+/k21ERERERETKRFStWnR9cjR5MbEANM1MZde3nuWj34paO6AIZnDy01C/tVfOzYKPLofsjIAjluqquiYtjvD3Jc7hYGYGnOYXCy45+rm/P6OQpifhLXc61TkX/hWX3+ZkM4srcK1WwGFAIvBj2KEf8e7q2MXM9i7kWvnX/7ToVyIiIiIiIhKc2j160GrYTaHyoesXMH3Mq/wTX9T6AUWo1wwGPru9vGkxm7++gy9WfhFQpFKdVcmkhZn1NbPjzCyqQH2smV2Ht6zpNrzHRDCzFmY2xMwaFDi/PvA8cCCwAfiowKVeBlKAU83s9LB2LYFH/eL/W3DYOTcHLwnREngkrE0M8BwQCzztP8aS3yYLeMYvPmtm9cLa3QTsCcwoZEUUERERERGRMtPsoguJ3u+AUPniuR/xwAtfkpMb4YSa3Y6GA68C4Nu6dTh94xTunHkH8zbNCzBaqY4s4meSKgEzG4w3eeYWvEk344HmwB5481JkABc55973z+8M/I034eUvwHq8R0f2AZoBScBJzrnwux/yrzUIeB9vjozp/rWOBhoDTzjnhhXSpjvwk9/3AmAx3iolXYFZwJHOucwCbWr7/R/oxzcT6OSXNwMHOedWRvA2/YeZLerVq1evRYsW7Uw3IiIiIiJSg2Rv3MiSE08mequ3LsDyRu34e8TTXH98rwg72kbWS/0YGJfMmljvsZMO9doy8dSPqBdbr4TGUlX17t2bxYsXL/ZXtIxYlbzTApgBPAQswbsL4UygL5AAjAX2yE9Y+OLx7nr4DegBDPLP34B3p8TuhSUsAJxzH+ItpToF6IO3OslyYHBhCQu/zTL/3NfwkiOnAXnA/cBRBRMWfpsMoL9/TjowEC9p8Rqwz84mLERERERERHZEbKtWdHpkVKjcLXkdW599mt//SYywozrUGvQKD8WnEOX/8XxN2r88PPvhIMOVaqZK3mkhO0Z3WoiIiIiIyI765557SZu4/W/DTx87hMcevYr6cTGRdTTrGZ6Z8ygvNmkUqnrs8Mc4rstxQYUqlUhNvdNCREREREREylH7u+4gr1OXUPmC6a/z6DuF3rBevIOu4come7NnxvYb0O+bdS9rUyNcmURqBCUtREREREREpERRtWuzy9NjyPWXQW2SuZXurz7Jl3+si7CjKGJPe4GHU7Opl+dN6Lk1J53bZtxKdl52CY2lplHSQkREREREREqlds8etLrt1lC5z6alvPLyZ6xL2hZZRw3b0uGkZxm+JSFUNT9+Ac/Pez6oUKWaUNJCRERERERESq35/84n6tDD2Vy3MbcdejW/1mvP0HfnRr4M6q4ncELvCzg1dWuo6uUFL/PLhl8CjliqMiUtREREREREpNTMjF0ee5j4Ma+yqHlXAH5ZlcjT05ZH3tmAkdwZ3ZZO2d5jIQ7H7TNuITEjwpVJpNpS0kJEREREREQiEtOkCacdvhun9WkXqntm2jJ+WhEfWUextal75ms8mrCVGH9ly00Z8Qz/cTha6VJASQsRERERERHZQfcP3J3OzeoCkOdg6HtzSUjLiqyT5t3pNeBhhiYkhaqmr53Ou0veDTBSqaqUtBAREREREZEdUj8uhrHn7kNstAGQviWBka9+F/ldEnufzwUdjqFv+vYJPUfPeZSliUuDDFeqICUtREREREREZIft0b4Rtx23K3tsXs5z057g0HfG8NrMFZF1YkbUyWN4ILsuzXJyAchyOdw6fRjbciJcmUSqFSUtREREREREZKec3zKbR358keYZyfROWMXqJ55m4brkyDqp3ZDmp4/nofikUNWKlFU89stjwQYrVYqSFiIiIiIiIrJT6vTsSZ0TTwyVz/xrKmMff5e0zJzIOmq/L4f0vY3BSSmhqknLPmRN6pqgQpUqRkkLERERERER2Wkd7xtBbpv2AEThuPDbVxj11o+Rd3TwdVzfZB96ZWbSOSubt//dTIe0pGCDlSpDSQsRERERERHZadH167HLM2PIjY4BoGlmKruNf5xJv/0TWUdRUcSe/iJPpTre+3cDu2akwQeXQFZaGUQtlZ2SFiIiIiIiIhKIOr170+r220LlfTYv4/dRY1i1JcKEQ/2WtD71Bermr0KyZSl8eVvxbaRaUtJCREREREREAtP8f+cT0/+oUPmshV/x5Oh3ycrJi6yjbkdB3xu2l+e+AQs+CChKqSqUtBAREREREZHAmBldHx1Fdss2AETjOPOrl3hq4uzIOzvyHmi33/bypzewfs0sNqdvDihaqeyUtBAREREREZFARTdoQPdnnyY3OhqAZhkptHn+YaYtXh9hR7FwxitQuxEAM6JzOPPbK7l1xs3k5EW4MolUSUpaiIiIiIiISODq7LE7LW65JVTed9NSZtz3BOuStkXWUZPOcOpzLKhVi2tbtyTZ4NdNv/P8H88HG7BUSkpaiIiIiIiISJloedGFcFi/UPnMPz5n9GM7ML/Fbiex+z6Xc8LW7RN6jpv/ErPWzQooUqmslLQQERERERGRMmFm9Bj9MFktWgPe/Banf/4iYz6IfH4LG3Afw+M60zkrGwAH3PH9LWxK3xRkyFLJKGkhIiIiIiIiZSa6USN6PPtUaH6L5hnJtH7uEaYs+DfCjmKpd8brjE7JIi7Pu1MjISuF2zS/RbWmpIWIiIiIiIiUqTp77knzm4aFyvtvWsLMB57kn/j0yDpq3IGeJz/P7QmJoapfN83l+Xma36K6UtJCREREREREylyrSwZjhx4eKp+54CtuHzeNzJzcyDrqcSyD9rjs/89vsUDzW1RXSlqIiIiIiIhImTMzuo9+hOzmLdlcpxF39L2SWUnGg5//GXlfRw1neJ1umt+iBlDSQkRERERERMpFdOPG9HhlHDNufpzFzboAMOGn1Xw2P9L5LWKod8ZrjE7N/v/zW0zX/BbVjZIWIiIiIiIiUm5q9+zBLWcdRO+2DUN1t3+4gJWbt0bWUcO29DzlRW5PSApV/bpZ81tUN0paiIiIiIiISLmqHRvNc+fvQ4O4GAC2ZuZwzVu/k5Ed4fwW3Y5m0N5XaX6LakxJCxERERERESl3nZrV49Ez9gyVN65ax2Nvfh9xP9b/TobX2/X/z28x42Y2pG0IKlSpQEpaiIiIiIiISIU4fo82XNy3M723rGTs9DHs/tIoJs1ZGVknUdHUG/Qqo1Pzts9vkZ3KsO+Gkp2bXQZRS3lS0kJEREREREQqzLAetXjkxxdolpHCrolrWHHfKJZtTI2skwat6TnwJe6KTwpVzY9fxGO/PBpssFLulLQQERERERGRClO/Z3fiTj41VD5hxQ+8ct8LpGVGuApI136ctv9QTk/dPqHnx0sn8u/WCFcmkUpFSQsRERERERGpULvcfy9ZXXuEymfPeINHnv8C51xkHR02jDub7MdumVl0zM7mzTXraLvhz4CjlfKkpIWIiIiIiIhUqKi4OHZ76Vmy6tYHoHZuNoe+OZrXv10cYUdRxJ0+jqcz4nh33QZ6ZmfBh5dC0j9lELWUByUtREREREREpMLVat+ezo8/Fip32LqZ7FH3M2dlfGQd1WlM67PeokF0nFfelgjvXwjZGQFGK+VFSQsRERERERGpFBr170fdSy8PlQ9d9wefDH+CTSkRJhxa7wEnjdle/ncufHlrIDFK+VLSQkRERERERCqNjjfdQG6f/UPls3+bxCOPvUd2bl5kHe19Lux/2fby76+z9uexzN88P6BIpTwoaSEiIiIiIiKVhkVHs+uzY8hq2hyAGJfHaZ8+x+Pv/RR5Z8c+BO32A+D7OrU5e/ELXD/1GjalbwoyZClDSlqIiIiIiIhIpRLTtCndnx1LbnQ0AM0yUuj03Cgm/xbhhJoxcXDWBLbUb85NLZuTEh1FfFYyt3w3lOy87DKIXIKmpIWIiIiIiIhUOnX77E3LW28LlffesoLF9z3Mkg2pkXXUqB3NT3+VWxOSQ1W/b1nAmF+fDCpUKUNKWoiIiIiIiEil1OLC/xE94NhQeeDS7xh33wukZER4l0TXIzjzgJs4JXVrqGrCn28wZdWUoEKVMqKkhYiIiIiIiFRKZka3Rx4iu1PXUN3537/BqLGfkJfnIuvr0Bu5u9lB9MjMCtUNn3kXK5NXBhavBE9JCxEREREREam0ourWZdeXXyCrbn0AaudmM+CdJ3j5i7mRdWRGndNe4MmsejTwVyJJz8tk6NQhbM3aWkJjqShKWoiIiIiIiEilVqtDB7o+9SR5ZgA035bMtx9+yw/LtkTWUe1GdDzrLR5M3J6k+HvrWu6aeTt5LsIlVaVcKGkhIiIiIiIilV6Dww6l0XXXk1ynIbcdejWzW/Xi+nfnsi5pW2QdtdyN/sc8zhWJ2yfmnLZ2Bi/PHxdwxBIEJS1ERERERESkSmh39ZXUf2siK1t5c1wkpGVx5Ru/kp6VE1lHe5zBNbv+j0PTtyc8npn3DDPXzgwyXAmAkhYiIiIiIiJSJZgZu/fqyIOn7RGqW7guhZsn/hHxxJzRA0bycN2edMj2ViJxwG3Th/FPyj9Bhiw7SUkLERERERERqVLO2Lc9F/ftHCp/sWADY6YujayT6BganTGBp9JjqZPnzWeRmruNG6ZeQ3p2eoDRys5Q0kJERERERESqnLtO2I0jerQAoElGClufHsPk3yO8S6JeM7qf+SYjE7ZPzLk8dTV3fX8buXm5QYYrO0hJCxEREREREalyYqKjGHteH452mxg7fQxnLp/OgvseYe4/iZF11GYvjhswmouTUkJVU9dOZ/is4VpRpBJQ0kJERERERESqpIa1Y7k1/Q+aZXgJh0FLpjHu/nH8G+mKInueyfU9z6Nv2MScn6z4hEd/eTTIcGUHKGkhIiIiIiIiVVa3hx8kt1OXUPnyWW9y5+hJbE7NjKifmAH382TdXdlvWwYAdfPyOCovLtBYJXJKWoiIiIiIiEiVFVWvHj1eep6cuvUBqJ2bzUVfjOXKxz+P7I6L6BjqnDmBZ7Pqc2j6Nl7csIn9pz4C/84to8ilNJS0EBERERERkSqtVqdOdHlyNM4MgNbpiVz96ZNc9sRXrI5PK31HdZtS97z3eT45i70zsyBnG7xzLqSsL6PIpSRKWoiIiIiIiEiVV/+II2h1222hcvu0LdzwxRgufXIKSzemlr6j5t3hzNfBor1y6np491zI0jKoFUFJCxEREREREakWmg2+iBY33RQqd9y6iZu+HsulT33D/LVJpe9ol/5wQtgknP/OhUlXsyF1PZOXTw4uYClRTEUHICIiIiIiIhKU5ldcjsvOYsvYZwDokrKB2759livyYNy1R7FH+0al62j/y2DzEpjzEgDrln7KpRmLWOcyycrL4sweZ5bVS5AwutNCREREREREqpXm11xDs6uuDJV3Sf6XO6Y/zzUvzeCf+Age8zh2FOxyJAB3NW/GOuetSHL/T/frjotyoqSFiIiIiIiIVCtmRosbbqDpJZeE6nokreXGb57jihe/JyEtq3QdRcfAWW/ALkfywJZ4WubkAOBwDP9xOF/+/WVZhC9hlLQQERERERGRasfMaHnLzTS54IJQ3W6Jq7n086e5ctwPbMvKLV1HcfXh3Hdp3/MUXlm/iWY5Xrs88rhj5u1MXzM9+OAlREkLERERERERqZbMjFZ33kHjc88J1e0e/zenf/AEN074iZzcvNJ1FBMHg16h894X8vKGTTTJ9RIXuS6PW2fczOL4xWURvlCFkxZmdpOZfWRmy8ws2cwyzWy1mU0wsz2KaTfYzOaY2VYzSzCzL8zskBKu1dc/L8FvN8fMLiyhTXszG29m/5pZhpktNbP7zKx2MW3qmNlI/9wMv+2rZtau5HdERERERERECjIzWt9zD40GDQrV7b1lBYdOeIzhH8/HOVe6jqKi4cQn6Hbwjby0YRP187yEx7bcTK6beg0b0jaURfg1XpVNWgB3AscDCcC3wOdABnAB8JuZnVSwgZmNAcYDuwNTgTnAAOB7MxtY2EXMbBAwAzgOmA98BXQHXjez0UW06QbMBQYD8cBkIBoYDkw1s7hC2tQGpgH3APX9NmuAi4G5Zta1+LdDRERERERECmNRUbQZeR8NTjklVPdby568/es6npu+IoKODI68i12PvJ/HN20h2k94bMqI59qpV5OeHcEkn1IqVTlpcSrQxDl3oHPudH/rCQwBYoGXzSy0pKuZHQ3cgJdE2Ms5N9A5dxxwOJALjDezxuEXMLOmwKt4CYcznHP9nHNnALsCy4FhZtavkNheA5oDTzvn9nDOnQ30BD4G+gJ3FNLmbuAg4Cegh3PubOfcgcAwoIUfh4iIiIiIiOwAi46m3aiHqHf8CXza7zw+7nYEAI9NWcLXiyK8S+KgqznksLu5Mz4xVLUkaTm3Th9Gbl4p58qQUqmySQvn3I/OuYxC6p8DVgCtgF5hh27y9w8455aFnf8T8ALQGLi0QHeXAQ2Byc65j8LabARu9YvDwhuY2QF4iYlNYefgnMsBrgaygesLJFRqAdf6xSHOua1h7Z7Au8PjCDPbt7D3QkREREREREpm0dF0eGI0lz9+G52b1Q3VD31vHn9tSImss0Ou46w9LuGi5O3tZvz7A4/98khQ4QpVOGlRgmx/nwXeXBHAkX7dB4Wcn193coH6E4tpk/84ytEF5qnIb/Opc/4ivj4/2TETaAIcGnaoL9AIWOGcmxtBfCIiIiIiIhIBM6NJvVq8fNF+1I/z/pacnpXLZa//WvqlUPMNGMmN7Y/nyLTtj4W89dc7vP3n20GGXKNVu6SFmV2A9yjGMn/DL8cBm51zawtp9ru/37NA/V4Fjoc457KAhUBtoEdp2hRzrR1pIyIiIiIiIjuoW8sGjD23D2Ze+d/4rYx48mOyckq5ogiAGdGnjmVUwz70ytz+N+tH5jzMrH9nBRxxzVTlkxZmdouZvWZmE81sITABWA+c65zLf5ioo78vLGGBcy4NSAKamFkDv9+GeHc/FNkurL5TWF2x1wqwTZHMbFFhG7BLadqLiIiIiIjUBP13bcntx+1KXE4mw2e/xsXvPMjY5z+JrJPoWOqeNYFnojvQOicHgDwct0y7gdUpq8sg6pqlyictgGOBi4AzgN7AaryExW9h59T398VN5Zrm7xsUaFNcu4JtSnOtoNqIiIiIiIjITrr8sC48u/gdDtz4J7Vzszno5Yd479PZkXVSqy4tzp3I05n1qO0vhZqSm8H1Uy4nNSu1DKKuOap80sI5d7RzzvDmiTgc75GQGWZ2V8VGVnGcc70L2/AmKBURERERERFfVFQU+952PblR0QA0zUyl8cjbmDV/VWQd1W3KbudM5P6U7fNirExfz8cLtBDkzqjySYt8zrkk59xM4ATgN+B+M9vfP5y/GkfdQht76vn7/DTY1rBjRbUr2KY01wqqjYiIiIiIiASgyRGH0fDu4aFyx9SNrLrhJlZvivBXsKZdOG7g61yRlIo5x9CERC6Y8x5kbi25rRSq2iQt8jnnsoH3AGP7ahv/+Pv2hbUxs3p4S54mOudS/X5SgOTi2oXVhz+oVOy1AmwjIiIiIiIiAel43lnknn9xqNxn/Z98PuQOUjOyi2lViE6HMOSwB3hz/UYuTU7FNi6Cjy6HvAgm+JSQape08G3x9y38/RIgE2hhZu0KOX8ffz+/QP0fBY6HmFkssDvesqdLS9OmmGvtSBsREREREREJUO+7bib1gMNC5f4LvuWVO58iL89F1E/UPv9jz32v2l6x5Av49r6gwqxRqmvS4gh/vwLAObcNmObXnVnI+Wf4+08L1H9e4Hi4k/CWO53qnMsopM3JZhYX3sDMWgGHAYnAj2GHfsS7q2MXM9s7gvhEREREREQkIBYVxX4vjCGpfddQ3ZFfvsarz38UeWdHj4Aex28v/zgG5r290zHWNFUyaWFmfc3sODOLKlAfa2bXARcA2/AeE8n3hL+/28y6h7U5GLgSb8nTVwpc6mUgBTjVzE4Pa9MSeNQvPh7ewDk3By8J0RJ4JKxNDPAcEAs87T/Gkt8mC3jGLz7rP66S3+4mYE9gRoEVUURERERERCRgUXXrss/r40ir1wiAWJfL7i8+xBdTfomwo2gYNA5a9g5V5XxyPW/8cD+ZuZlBhlytVcmkBdAd+BLYaGZfmdlbZjYFb86Hp4EsYLBzbk1+A+fcVOApoBkwz8wmmdkXwPdADHCxcy4p/CLOuQTgEiAP+MDMppnZRLzHTboBTzjnphcS38VAPHCDmc03s3f9NqcDs4BRhbR5AJgNHAIsM7P3zOxnvKTIZj8OERERERERKWNx7drS+YVnyY6OAaBRVjrR99zC/CXrIuyoAZz3LtRrQXKUMaRFYx5d8T73Tb8F5yJ75KSmqqpJixnAQ3iJgD3xHvnoCyQAY4E9nHPvF2zknBuKl1D4ExgAHAxMBQ53zk0q7ELOuQ/xllKdAvTBW51kOV5SZFgRbZb5576GN6/GaXiJj/uBo5xz/0mr+Y+Y9PfPSQcGAp38PvZxzq0s5v0QERERERGRADXff1/q3T0iVO6YspHF19zAxsS0yDpq3BHOfou3GjdhVt06AHy69jte/+PFAKOtvkzZnZrDzBb16tWr16JFiyo6FBERERERkSrh9+EPUef9N0LlmX2O4aI3niAuJjqifrLnvsUVs0fwa53agLfc5TNHjuXwDv0CjLby6d27N4sXL17snOtd8tn/VVXvtBAREREREREpc31G3E7CPoeEyofN/ZrX7nkm4sc7Yvucz+NdzqRddg4ADrjtuxtZmayb6oujpIWIiIiIiIhIESwqioNeeoqE1p1CdQdPGsfE8Z9F3FfTAQ/wVN3dqJOXB8BWl8MNXwwmOTM5sHirGyUtRERERERERIoRXb8+e7/xMql1GwLeiiIdx9zHDzPnR9ZRVBQ9B01gVHb9UNWqrERum3IFOXk5QYZcbShpISIiIiIiIlKCeh3a0+GZsWRHeSuKLGnSgWFf/c3fWyKcmDOuPked/SHXbM0OVf2YuJgnf7wvyHCrDSUtREREREREREqhzSEHEH3rXUzq0Y/7DrqEjbkxXD7hV1IysktuHK5Re648+XUGpGeEqiasnMSkP98JOOKqT0kLERERERERkVLqPfgc9njgHvLM+3V6+aatDH13Hrl5kU3MGdXxQB446F56ZmaF6kbOGcW8jb8HGm9Vp6SFiIiIiIiISARO2rMt1/bvFipP+2sTo79eEnE/dfv8j6c7nkrT3FwAsnEM/foKNqRtCCzWqk5JCxEREREREZEI3TSgBwN6tQqVn5++gk9/jDxx0faYh3kyrjsx/hKq8XmZ3PD5BWTkZJTQsmZQ0kJEREREREQkQlFRxpNn702PVvXBOc5ZMpVm11zA/N/+jLQj9jnjLe7OqhOqWrxtA8O/GYJzkT1yUh0paSEiIiIiIiKyA+rHxTDuwv24bcFELvrzK5pkprL+2uvYuDEhso7i6jPorA85L337hJ5fbprDK788HnDEVY+SFiIiIiIiIiI7qFOzeux3ylGhcsfEdfxw8RC2ZUa4okjjjtx8/MscuC0zVPX04tf5afW0oEKtkpS0EBEREREREdkJ+191If8eOyhU7rVyHh8PuTvixztiOx/K6H1vpX22l/A4Oj2dvWa9BHl5gcZblShpISIiIiIiIrKT+j8+gjW77hMq9/nhEz56ZFzE/TTe/zLGtjmG6xKSGL1pC3WXfAnfPRBkqFWKkhYiIiIiIiIiOykqJobDX3ueTc3aheq6T3iaaR9Ojbivbsc/yRUtD97+C/vMx2H+xGACrWKUtBAREREREREJQO3GDek1/iVSa9cHIDYvlzoj72Dh7xEuhRoVDYNehha7bq+bPATWzAkw2qpBSQsRERERERGRgLTo0ZXGjz1BTlQ0AI0zt7JuyBA2bohwRZHaDeHcd6FOU6+cm4l79zy+/+uDGrUUqpIWIiIiIiIiIgHqMeAwtg25OVTumLiOmZcMITU9s5hWhWjaBc5+E6JiccCTtbIZMvs+Hp89qsYkLpS0EBEREREREQnYAUMGs/6Y00Pl3ivn8cGFN5CYFmHionNfOPkpJjRswPjGDQF4fck7jPvjxSDDrbSUtBAREREREREpA/2euI91YSuKHLRwBm9dehubUyNMXPQ5n9N2v5BdM7NCVWP/eJa3/3w7qFArLSUtRERERERERMpAVEwM/d58ic0de4Tqjpo3hZevGcH65G0R9dXw6Ad4oWEfOmdlh+om/vESWblZxbSq+pS0EBERERERESkjMfXrccj7r5PctnOobuAvk3hm6KOsjk8rfUdRUTQ7/VXGuRa0ycmhd2Ym45ctoNbK74MPuhJR0kJERERERESkDMU0bsy+700gvUWbUN15P73HI3c8z/JNqaXvqFZdWp87kVdSjZfXb6Jxbg58dDlkRtBHFaOkhYiIiIiIiEgZi23Rgj3ffYPMJs0BWNugBbPrtOWcl35m6cYIkg4NWtPh7HepH1MXajeCM8dDXIMyirriKWkhIiIiIiIiUg5i27Vjt7deJ2XP/bn1sCHE12nElq1ZnPvSz/y1IaX0HbXZE85+Ay6dCl37lVm8lYGSFiIiIiIiIiLlJK5rVw58fwL3/u8Qosyri0/zEheL/40gcdHtKGjRo+TzqjglLURERERERETK2en7tOfJs/cOJS4S07M57+WfWbguuWIDq2SUtBARERERERGpAKfu3Y4x5/Qh2s9c7LpiLu/feD8L1ipxkS+mogMQERERERERqalO2ast0Wa89tQ73PnLG8Tm5fLx9VnEPHM/u7VtVNHhVTjdaSEiIiIiIiJSgU7YvRV3r/uO2LxcAE5b/A2fXnd3ZMuhVlNKWoiIiIiIiIhUIIuKoveb48nq0CVUd/KiqUy++k7+iU+rwMgqnpIWIiIiIiIiIhUspnlzer/3JhlhiYsTFk3lo6tuZ33StgqMrGIpaSEiIiIiIiJSCcQ0bcoe779Felji4tgFU/ngilvZnJpRgZFVHCUtRERERERERCqJmCZN2Ov9t9jaoWuo7uj5U5l42a0kpmVWYGQVQ0kLERERERERkUokpkkT+rz/Jinttycu+v/xDe9efjsp27IqMLLyp6SFiIiIiIiISCUT06QJ+058k6R22x8V6ff7V7x59XC2ZeVWYGTlS0kLERERERERkUoopkkT9p/4FoltOoXq+v88mfHXjiAzp2YkLpS0EBEREREREamkYpo2Yb/33ySxRbtQXf/vP+CVoaPIzs2rwMjKh5IWIiIiIiIiIpVYrRbN2feDt0lq2jpU13/qW7x6y2hy81wFRlb2lLQQERERERERqeTiWrVk74lvkdS4Raiu7Y9fc/f7c8mrxokLJS1EREREREREqoA67dqy+7tvktygKUsbt+eOvleyeEs66dnVd36LmIoOQERERERERERKp0Hnjuz23ps88+kKesXV45XB+1E/rvr+al99X5mIiIiIiIhINdSoaxeev7I9MVFR1KkVXdHhlCklLURERERERESqmAa1Yys6hHKhOS1EREREREREpFJS0kJEREREREREKiUlLURERERERESkUlLSQkREREREREQqJSUtRERERERERKRSUtJCRERERERERColJS1EREREREREpFJS0kJEREREREREKiUlLURERERERESkUlLSQkREREREREQqJSUtRERERERERKRSUtJCRERERERERColJS1EREREREREpFJS0kJEREREREREKiUlLURERERERESkUlLSQkREREREREQqJSUtRERERERERKRSUtJCRERERERERColJS1EREREREREpFJS0kJEREREREREKiUlLURERERERESkUjLnXEXHIOXEzFLi4uIa7LLLLhUdioiIiIiIiNQAK1asIDMzM9U513BH2itpUYOY2QagLrCmomMJk59BWVGhUUhpaKyqBo1T1aBxqjo0VlWDxqlq0DhVHRqrqqGqjFMHIN0513pHGitpIRXKzBYBOOd6V3QsUjyNVdWgcaoaNE5Vh8aqatA4VQ0ap6pDY1U11JRx0pwWIiIiIiIiIlIpKWkhIiIiIiIiIpWSkhYiIiIiIiIiUikpaSEiIiIiIiIilZKSFiIiIiIiIiJSKWn1EBERERERERGplHSnhYiIiIiIiIhUSkpaiIiIiIiIiEilpKSFiIiIiIiIiFRKSlqIiIiIiIiISKWkpIWIiIiIiIiIVEpKWoiIiIiIiIhIpaSkhYiIiIiIiIhUSkpaSIUwszpmNtLMlppZhpn9a2avmlm7io6tJjGzumY20MxeMbMl/likmdkfZjbczOoX03awmc0xs61mlmBmX5jZIeUZf01mZs3MbJOZOTNbXsK5GqtyZmYtzGy0/3W1zX/ffzezx4o4/2Qzm2FmKf423cxOLO+4axoz29/M3vd/BmWbWZKZzTSzi83MCjk/2sxuNLMF/rhu9tvvVhHxVxdmtq+Z3W5mH5nZWv/7mitFu4i/t5lZX/+8BL/dHDO7MLhXU71FMlZmFmVmh5nZo2b2m5mlmlmmma0wsxfMrEsJ19JY7aAd/Zoq0MfU/HZm1r6Y8zROO2gnvvfFmtlQ/71O8d/3pcX9LmVmvc1sov9za5v/c2yomVWNfIBzTpu2ct2A2sBPgAP+Bd4DZvvlTUDXio6xpmzAZf777oDFwPvAV0CKX/cn0LKQdmP84+nAJL9NNpADDKzo11UTNuA1IM8fh+XFnKexKv+x2RfY4r/vC4F3gS+AVUBOIecP9c/NBr70xyndr7u2ol9Pdd2AQf7XgQN+838WTfPHwQFvFTg/CvjIP5YIfABM978O04ADKvo1VdXN/z/vCm4ltIn4e1vYmOf5Y/eBP5YOGF3R70NV2CIZK6Bb2Dnrgcn+19Bavy4FOFRjVbHjVET7wX6b/M8Z7TVOlWOcgKbAr2z/Peojf5vv1/3nawo4OOxzxWz/5916v/w+YBX9XpT4XlV0ANpq3gY84H+RzALqh9Xf5NdPr+gYa8oGXAS8COxWoL4N8Ls/Hm8XOHa0X78F6B5WfzCQ6f+walzRr606b8BR/hi8SDFJC41VhYxNC2Az3i+xpxRy/IAC5Z7+B74M4OCw+h7+uGUD3Sr6dVW3DYgBNvpfH+cVOLYbEO8f6x9Wn5/kXQq0Cqsf5NcvA2Iq+rVVxQ24DRgJnAy09r8eXDHnR/y9zf+gn+y3Oz2svpU/dg7oV9HvRWXfIhkrYBfga+DI8F+KgDhgvP+erwZiNVYVN06FtG3hfw+cgpdsLzRpoXEq/3ECDC+57oARBX/mAF2B5gXqYoGVfpsbw+rr4/0u5oDBFf1elPheVXQA2mrWBtQCkvwvkD6FHP/DP7ZvRcda0zf/w5/zv4HWCqv/wq8fWkibp/xjwyo6/uq6AXWA5cAioDvFJy00VuU/Ps/57+s1EZ4/ppBjN/rHxlb066puG7C7/97+VcTx/K+PW8PqFvt1Aws5f7J/bFBFv7bqsJXig3vE39uAW/36SYW0Oc0/9mlFv/aqtpU0VsW0qxP2efAIjVXlGSfgLWAbXtJpFUUnLTRO5TxOwFn++/p+BH3mt5lXyLF9/GMLKvq1l7RVjWdYpDrpCzQCVjjn5hZy/AN/f3L5hSRF+MPfxwHNwJuLBO8vJrB9rMJp/MrevXiZ9Kvw/gpfKI1V+fPf8//h3WUxvpTN8uet0BiVr8xSnhcP4D97vxveB/nPCzlPY1VOduJ7W3Ffa5/j/bJwtJnV3ukgpUTOuW14dy0BtC1wWGNVQczsOOA84EHn3IoSTtc4lb/L/f3YCNoUOU7Oud/x7sLY3cw671xoZUtJCylve/n734s4nl+/ZznEIsXr6u+zgQT/3z3xkhibnXNrC2mj8StDZrYnMAwY75ybWcLpGqvytx/QAJjrnNtmZseb2RNm9pw/2dX/+2BuZo2Bjn7xP0lc59wavNvfO5lZwzKOvaZZCawAeprZeeEH/Ek1/4f3iMHHfnX+z66FzrnCkoX6eio/O/q9rcjPH865LLz5Z2rjPZolZcyf/K+TX9xQ4LDGqgKYWT3geeAv4NFSNNE4lSMziwUOxXukdI6Z7Wlm95vZi+ZNnr9XEU2rxe9eSlpIecv/gF7YB43w+k5FHJfyc4O//8o5l/9XyWLHzzmXhne7ZxMza1C24dUs/ge8l/He31tL0URjVf56+ftNZjYJ7xb2G4GrgSeB5WZ2btj5+WOU6I9HYfQ9sQw453Lx5vRJAt7yVzZ418ym4U1mthY4yjmXn7DVz67KI+LvbX7Sr1Fx7dAYlrdzgZZ4cwDNyq/UWFWokUBn4Co/6VAkjVOF6IqXBIrH+2wxF7gbuAK4D5hrZk8W0q5a/PxS0kLKW/4SmulFHM//4K5foiqQmZ0AXIp3l8U9YYdKGj/QGJaV64D9gVucc/GlOF9jVf6a+PtTgOOAIXgfyjsDo/Ge4X7dzPb2z9MYVSDn3I/AEXh3XewDnA30x5sF/xu/Pp9+dlUeO/J1E758t8awgplZB7zVXwCGh/1hBDRWFcLM9sH7Y9XrzrkZpWiicSp/+Z8xmgGjgBfw5h1pjveZfRsw1MyGFGhXLX5+KWkhIv+Pme0KvIk3Q/Etzrk/SmgiZczMOuKtujPDOfdaBYcjRcv/mRqD90H8OefcZufcaufcLcBEvFm8b6mwCCXEv+tlDrAGOBDvg10PvOWEhwHTzCyuwgIUqYb8RxA+wvtFa5Jz7oUKDqnGM7Nott/JeXPFRiPFCP+M8aVzbohzbqVzLt459yrbP1vcUTHhlS0lLaS8bfX3dYs4Xs/fp5ZDLFKAmbXDW+u+CfCEc+6pAqeUNH6gMSwLz+KtvHNVBG00VuVva9i/C5uIM7/uiALna4zKmZl1B17HmzPkJOfcHOdcmnNumXPuSuAzvLsvLvGb6GdX5bEjXzfhX5sawwriP5M/EW/+nx/wJnwsSGNV/oYCffBWS9pSyjYap/JX0meM1/x9OzPrVki7Kj1OSlpIefvH37cv4nh+/epyiEXCmFlTvPXUO+F9Myws217s+Pl/QWmM94x+pf7mV8WchHdb3wtmNj1/A971j7cLq2/t12msyl/+961059zmQo6v8vct/X3+GDXxx6Mw+p5YNs7Bu+vlK+fc1kKOv+/vD/f3+tlVeUT8vc05lwIkF9cOjWGZ8udleh04HpgHnOyvIPL/aKwqxMl4y15eFP4Zw/+ckf+ZYqJfdxxonCpI+Pu4quBB51w6sMkvtgw7VC1+filpIeUt/1GDfYo4nl8/vxxiEZ+Z1Qe+xJtI8CPgcucv4FzAErylAlv4d2UUpPErO43x/kIfvh3oH6sdVpe/tJjGqvzlrwBSp4jHCpr6+60Azrkktn+Y6FPwZP+57+bAav8DogQn/0NachHH8+vznyHO/9m1u//X4oL09VR+dvR7W5GfP/wx3R1vicalBY9LIMbiTb65FDjW//5XFI1V+TO8JG3Bzxn5P8sO8sutw9ponMqRcy4Z+NsvNil43E8MNvaL4cn4avG7l5IWUt5+xPswuEvYZHThzvD3n5ZbRDWc/8vVZOAAYApwrj+z/n/4fxWZ5hfPLOQUjV8ZcM5ZYRvQxT9lRVj9Kr+NxqqcOef+wftwYGx/BCRcfl348qaf+/sz+C+NUdnJX2JxvyKO7+/vVwE45/4G/sSbTPXEQs7XWJWTnfjeVtzX2kl4Cd+pzrmMnQ5S/h8zewC4Bi9JO8A5t6mEJhqrcuSc61fM54z8v7538OteC2uqcSp/n/j7foUcOwjvUeJteMndfEWOk5n1wVuVZGH+58dKyzmnTVu5bngTCjq8BEa9sPqb/PrpFR1jTdmAaLw7KxzwPVC3FG2O9s/fAnQPqz8YL6OeCDSu6NdWEza8VSkcsFxjVTk2vGe0Hd5fLNqE1e+Nt0yZA84Mq++Jt+Z6BnBQWH13f9yygW4V/bqq24b3lyXnb1cXOHYQ3l+pHHB0WP1lft1SoGVY/el+/TIgpqJfW3XY/K8HV8zxiL+34d3plOy3Oz2svqU/dg7oV9GvvaptpRirG/33dn34WJXQp8aqnMepmHar/Pe7vcap4sfJ/9yXCaQU+MzQHG9iaQc8W6BNLN5qWA64May+Ht5yww4YXNGvvaTN/KBFyo2Z1Qam493avh6YiTePwoF463Uf5JxbWWQHEhgzu4Hty459jPdNsDA3u7DJmcxsDN7SWOl4SwPWAgbg/YX5DOfcpLKJWMKZWWe8WwVXOOe6FXHOGDRW5crMXgMuwpuJfRbeX+cPwbvNdpxz7ooC598IPIGXvPgGyAKO8dtd75wbW16x1yRm9hjb5+5ZBCwG2uL94hsFvOS8STnzz48CPgBOw/ul+Fu8D4pH4H3Q7O+cm11uL6AaMbMT+f/Lax+A9z0q/P283zn3eVibMUT4vc3MBuHNV2J4n0Pi8RIgjfEmnx4W0EuqtiIZK/+O2t/94z9R9GMCLzvnfihwHY3VTtiRr6ki+lmF9xm9g3NubSHHNU47YQe/912Ct9pLDt7XVTLeZ4xmeF9vR7gCczWZ2SHAVLzPFbPx7qA5DGiD93PtLFfZkwIVnTXRVjM3vC+akcByvIzherzJH/+TydVWpuMwgu1/bSxu61xI28HAr3jrOyfizYlxSEW/ppq0UcKdFhqrChsXAy4Pe8+34iUvLiqmzcl4dzul+tv3eKtaVPjrqc4bXgJiCtvvaknAe/Tg3CLOj8a7K3Ah3i24W/BWQ+hV0a+lKm/+96iSfg4NLqJdRN/bgL7+eYl+u1+K+9rUtuNjhXcLe2k+Y/xnbDVW5TdOJfSziiLutNA4Vdw4+V9bX/nveQZe0v1ewu5gL6RNb7wExRb/59dCvDuhoir6fSjNpjstRERERERERKRS0kScIiIiIiIiIlIpKWkhIiIiIiIiIpWSkhYiIiIiIiIiUikpaSEiIiIiIiIilZKSFiIiIiIiIiJSKSlpISIiIiIiIiKVkpIWIiIiIiIiIlIpKWkhIiIiIiIiIpWSkhYiIiIiIiIiUikpaSEiIiIiIiIilZKSFiIiIiIiIiJSKSlpISIiIiIiIiKVkpIWIiIi8h9m5iLcVvntpvvlzhX7CoJhZiP81zO4AmMY7McwoqJiEBERqSgxFR2AiIiIVEqvF1J3KLAL8Acwr8CxLWUdkIiIiNQ8SlqIiIjIfzjnBhesM7PX8JIWk5xzI4poeiFQF1hXVrGVs2eAd4H1FR2IiIhITaSkhYiIiATGOfdPRccQJOfcFnQXiYiISIXRnBYiIiISmKLmtMif98LMYszsHjNbbmbbzOxPM7s47Lwjzew7M0sxs0Qzm2BmzYq4VoyZXW1mP/nnbzOzeWY21MwC+cNMUXNahL9OMxtoZj+bWZqZJZjZO2bWfgeu1dfMpppZqpklmdkUMzuwmPO7+fH9ZGYbzCzLzNb671mPAue2MbNsM1tjZtFF9Hee/5peD6urZWbXmNkvZhZvZun+OH5mZudE+hpFREQipaSFiIiIlKf3gWHAAuB7oAvwqpldbGZnAFPw7gSdAqQBFwCTzMzCOzGzOsDXwHNAD+Bn4BugDfAk8KGZlcfnnGuAD4BtwBfAVuAcYJofY6mY2UnAdOAoYDHwJdAB7z06uIhmlwHDgXrAL8AnQAree/aLme2Zf6Jzbr1/vD1wXBH9Xe7vXwqrewt4FuiJ9x5PBv7Bm9/kqtK+PhERkR2lx0NERESkvHQCUoHuzrnNAGbWH5gGPAjUAgY65z73jzUEZuH9gtwP+C6sr9FAf+A94ErnXLLfpgHeHBSnAFcAL5TxaxoCHOac+8m/fl285MkhwLnAqyV14Mf8Kt7nskucc+P9egNGAbcV0XQS8KJz7u8C/V3s9zcGODLs0AvA6XjJic8LtOmG9x7/6Zz70a/rApwBrAb2dc7Fh51fG+hT0msTERHZWbrTQkRERMrT0PyEBYBz7jtgLt4dEl/mJyz8Yyls/6v/Efn1ZtYS7xfvNcDF+QkLv00qcCmQBVxdhq8j35P5CQv/+unAE37x8FL2cQbQAvg+P2Hh9+WAe4C1hTVyzv1cMGHh148HfgT6mVmjsENTgeXAiWbWpkCzy/z9uLC6Fv5+bnjCwr9GRvjrFhERKStKWoiIiEh5ycZ7BKKglf7+62KOhf+S3Q+IBb5yzm0r2MA5twFYBuwRySMaO6iwmJf6+4KJgaIc5u/fLXjAOZeN9/hJocysvpmda2aPmNk4M3vNX+WlDWB4q73k9+XwkkAxQPg8IrHAYCATmBDW/V94j+icaGa3mFnbUr4eERGRwChpISIiIuVlg3Mut5D6rf6+sGVS84/FhdV19veX+xNH/mcDeuP90t40iMCLUdhdEKn+Pq6QY4XJTwasLuL4qsIqzexIvKTO28CteHdLXORvXf3TGhRoNh4vOXFp2DwhJwOtgI/C76jw73S53D//UWCdmS0xsxfMrG8pX5uIiMhO0ZwWIiIiUl7ydvJ4vvw/uswD/ijh3MxS9rmjShtzoMysPt6kpk2BkXh3aawGtjnnnJm9jTenxv+bwNQ5t8XMPgTOw5v0cyqFPxqSf/47ZjYVOBU4Bu8xnSuBK83sCefcsLJ4fSIiIvmUtBAREZGqJv/uhh+cc9dVaCTBWO/vOxVxvLD6w4BmwAfOuXsLOd61kLp8L+AlLS43s6XAscAyf36R//DnIHkZeNm/O+NYvAlQbzKzV51zi4q5loiIyE7R4yEiIiJS1XwH5AIn+fMxVHUz/f1ZBQ+YWQwwqJA2Tfz9fx5P8VcC2aeoiznnZgKLgIF4j5VE4SUlSuQ8X7F99ZHepWknIiKyo5S0EBERkSrFObcOb0nPzsA7Ztaq4Dlm1s3MBhWo6+fPebGqXAItvYlAPN5qHxflV/p3NdwHdCykTf5kn6ebWYuwNo2BV/AmKi3Oi3hLzA7BmyD1tYInmFkfMzvdzGoVqG8KHOgX15RwHRERkZ2ipIWIiIhURTcA3+DdhbDCzH4ws7fNbLKZLcNbPeSCAm3yP/dkl2OcJQpbpjUXeM3MfvbnpFgI3ELhc038ivf6OwJLzexjM/sY+BtvYs/JJVx2ApDu/3uyc25TIed0Aj4ENpnZVDN708w+w5sYtCvwqZY9FRGRsqakhYiIiFQ5/lKnx+OtlDEb2A04A9gP2Azci/foQ7i9/P0EKhnn3GSgP96jL7sDJ+LNdXEEMKuIZqcCD+K93uOBffEm5DwISCrhesnA737xP0kR38/A3cBvQE/gTLz3dz5wCYU/tiIiIhIo85bsFhEREanezOwToC/Q2b+7ocYysw54d2WsAbo6fSAUEZFKSndaiIiISLVnZtHA4cDomp6w8N0ORAPPKmEhIiKVme60EBEREakBzKwn3hwZXYAj8VYe2c05t7VCAxMRESlGTEUHICIiIiLlog3ehJ/bgO+B65SwEBGRyk53WoiIiIiIiIhIpaQ5LURERERERESkUlLSQkREREREREQqJSUtRERERERERKRSUtJCRERERERERColJS1EREREREREpFJS0kJEREREREREKiUlLURERERERESkUlLSQkREREREREQqJSUtRERERERERKRSUtJCRERERERERColJS1EREREREREpFJS0kJEREREREREKiUlLURERERERESkUvo/0p5n/oZGEM0AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(8, 11), dpi=150)\n", + "ax1 = fig.add_subplot(211)\n", + "ax1.plot(simtimes, flow_case1[::2,]['q'], label='Case A')\n", + "ax1.plot(simtimes, flow_case2[::2,]['q'], label='Case B')\n", + "ax1.plot(simtimes, flow_case3[::2,]['q'], dashes=[6, 2], label='Case C')\n", + "ax1.plot(simtimes, flow_case4[::2,]['q'], dashes=[6, 2], label='Case D')\n", + "ax1.set_xlabel('Time, in days') \n", + "ax1.set_ylabel('Layer 1 flow to well') \n", + "ax1.legend() \n", + "\n", + "ax2 = fig.add_subplot(212)\n", + "ax2.plot(simtimes, flow_case1[1::2,]['q'], label='Case A')\n", + "ax2.plot(simtimes, flow_case2[1::2,]['q'], label='Case B')\n", + "ax2.plot(simtimes, flow_case3[1::2,]['q'], dashes=[6, 2], label='Case C')\n", + "ax2.plot(simtimes, flow_case4[1::2,]['q'], dashes=[6, 2], label='Case D')\n", + "ax2.set_xlabel('Time, in days') \n", + "ax2.set_ylabel('Layer 2 flow to well') \n", + "ax2.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/data/mfusg_test/03_conduit_confined/ex3.cln b/examples/data/mfusg_test/03_conduit_confined/ex3.cln index 2bbdc03048..a999cc2d30 100755 --- a/examples/data/mfusg_test/03_conduit_confined/ex3.cln +++ b/examples/data/mfusg_test/03_conduit_confined/ex3.cln @@ -1,4 +1,4 @@ -1 -1 -1 -36 0 0 2 1 NCLN ICLNNDS ICLNCB ICLNHD ICLNDD ICLNIB NCLNGWC NCONDUITYP +1 -1 35 -36 0 0 2 1 NCLN ICLNNDS ICLNCB ICLNHD ICLNDD ICLNIB NCLNGWC NCONDUITYP constant 2 NNDCLN(NCLN) CLN cells per segment 1 1 0 10.0 -110. 1.57 0 0 IFNO IFTYP IFDIR FLENG FELEV FANGLE IFLIN ICCWADI 2 1 0 10.0 -130. 1.57 0 0 IFNO IFTYP IFDIR FLENG FELEV FANGLE IFLIN ICCWADI diff --git a/examples/data/mfusg_test/03_conduit_confined/ex3.nam b/examples/data/mfusg_test/03_conduit_confined/ex3.nam index 9b68794cb3..9e7614f92f 100755 --- a/examples/data/mfusg_test/03_conduit_confined/ex3.nam +++ b/examples/data/mfusg_test/03_conduit_confined/ex3.nam @@ -9,4 +9,5 @@ SMS 19 ex3.sms DATA(BINARY) 50 ex3.cbb DATA(BINARY) 30 ex3.hds DATA(BINARY) 31 ex3.ddn +DATA(BINARY) 35 ex3.clncbb DATA(BINARY) 36 ex3.clnhds diff --git a/flopy/__init__.py b/flopy/__init__.py index f6227cbac0..b19eb44d29 100644 --- a/flopy/__init__.py +++ b/flopy/__init__.py @@ -28,6 +28,7 @@ from . import seawat from . import modpath from . import modflowlgr +from . import modflowusg from . import utils from . import plot from . import export diff --git a/flopy/modflowusg/__init__.py b/flopy/modflowusg/__init__.py new file mode 100644 index 0000000000..36b220bc07 --- /dev/null +++ b/flopy/modflowusg/__init__.py @@ -0,0 +1,7 @@ +from .mfusg import ModflowUsg +from .mfusgbcf import ModflowUsgBcf +from .mfusgwel import ModflowUsgWel +from .mfusgcln import ModflowUsgCln +from .mfusgbct import ModflowUsgBct +from .mfusgsms import ModflowUsgSms +from .mfusggnc import ModflowUsgGnc \ No newline at end of file diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py new file mode 100644 index 0000000000..7282f3b67d --- /dev/null +++ b/flopy/modflowusg/mfusg.py @@ -0,0 +1,415 @@ +""" +mfusg module. + + +""" + +import os +import flopy +from inspect import getfullargspec +from ..utils import mfreadnam + +from ..modflow import Modflow + +class ModflowUsg(Modflow): + """ + MODFLOW-USG Model Class. + + Parameters + ---------- + modelname : str, default "modflowusgtest". + Name of model. This string will be used to name the MODFLOW input + that are created with write_model. + namefile_ext : str, default "nam" + Extension for the namefile. + exe_name : str, default "mfusg.exe" + The name of the executable to use. + structured : bool, default True + Specify if model grid is structured (default) or unstructured. + listunit : int, default 2 + Unit number for the list file. + model_ws : str, default "." + Model workspace. Directory name to create model data sets. + Default is the present working directory. + external_path : str, optional + Location for external files. + verbose : bool, default False + Print additional information to the screen. + + Attributes + ---------- + + Methods + ------- + + See Also + -------- + + Notes + ----- + + Examples + -------- + >>> import flopy + >>> usg = flopy.modflowusg.ModflowUsg() + + """ + + def __init__( + self, + modelname="modflowusgtest", + namefile_ext="nam", + exe_name="mfusg.exe", + structured=True, + listunit=2, + model_ws=".", + external_path=None, + verbose=False, + **kwargs, + ): + super().__init__( + modelname, + namefile_ext, + version="mfusg", + exe_name=exe_name, + structured=structured, + listunit=listunit, + model_ws=model_ws, + external_path=external_path, + verbose=verbose, + **kwargs, + ) + # Create a dictionary to map package with package object. + # This is used for loading models. + self.mfnam_packages = { + "zone": flopy.modflow.ModflowZon, + "mult": flopy.modflow.ModflowMlt, + "pval": flopy.modflow.ModflowPval, + "bas6": flopy.modflow.ModflowBas, + "dis": flopy.modflow.ModflowDis, + "lpf": flopy.modflow.ModflowLpf, + "hfb6": flopy.modflow.ModflowHfb, + "chd": flopy.modflow.ModflowChd, + "fhb": flopy.modflow.ModflowFhb, + "drn": flopy.modflow.ModflowDrn, + "drt": flopy.modflow.ModflowDrt, + "rch": flopy.modflow.ModflowRch, + "evt": flopy.modflow.ModflowEvt, + "ghb": flopy.modflow.ModflowGhb, + "riv": flopy.modflow.ModflowRiv, + "str": flopy.modflow.ModflowStr, + "sfr": flopy.modflow.ModflowSfr2, + "lak": flopy.modflow.ModflowLak, + "gage": flopy.modflow.ModflowGage, + "oc": flopy.modflow.ModflowOc, + "sub": flopy.modflow.ModflowSub, + "swt": flopy.modflow.ModflowSwt, + "disu": flopy.modflow.ModflowDisU, + "sms": flopy.modflowusg.ModflowUsgSms, + "wel": flopy.modflowusg.ModflowUsgWel, + "bcf6": flopy.modflowusg.ModflowUsgBcf, + "cln": flopy.modflowusg.ModflowUsgCln, + "gnc": flopy.modflowusg.ModflowUsgGnc, + "bct": flopy.modflowusg.ModflowUsgBct, + } + return + @classmethod + def load( + cls, + f, + exe_name="mfusg.exe", + verbose=False, + model_ws=".", + load_only=None, + forgive=False, + check=True, + ): + """ + Load an existing MODFLOW-USG model. + + Parameters + ---------- + f : str + Path to MODFLOW name file to load. + exe_name : str, default "mfusg.exe" + MODFLOW executable name. + verbose : bool, default False + Show messages that can be useful for debugging. + model_ws : str, default "." + Model workspace path. Default is the current directory. + load_only : list, str or None + List of case insensitive packages to load, e.g. ["bas6", "lpf"]. + One package can also be specified, e.g. "rch". Default is None, + which attempts to load all files. An empty list [] will not load + any additional packages than is necessary. At a minimum, "dis" or + "disu" is always loaded. + forgive : bool, optional + Option to raise exceptions on package load failure, which can be + useful for debugging. Default False. + check : boolean, optional + Check model input for common errors. Default True. + + Returns + ------- + flopy.modflowusg.ModflowUsg + + Examples + -------- + >>> import flopy + >>> ml = flopy.modflowusg.ModflowUsg.load('model.nam') + + """ + # similar to modflow command: if file does not exist , try file.nam + namefile_path = os.path.join(model_ws, f) + if not os.path.isfile(namefile_path) and os.path.isfile( + f"{namefile_path}.nam" + ): + namefile_path += ".nam" + if not os.path.isfile(namefile_path): + raise OSError(f"cannot find name file: {namefile_path}") + + # Determine model name from 'f', without any extension or path + modelname = os.path.splitext(os.path.basename(f))[0] + + if verbose: + print(f"\nCreating new model with name: {modelname}\n{50 * '-'}\n") + + attribs = mfreadnam.attribs_from_namfile_header( + os.path.join(model_ws, f) + ) + + ml = cls( + modelname, + exe_name=exe_name, + verbose=verbose, + model_ws=model_ws, + **attribs, + ) + + files_successfully_loaded = [] + files_not_loaded = [] + + # read name file + ext_unit_dict = mfreadnam.parsenamefile( + namefile_path, ml.mfnam_packages, verbose=verbose + ) + if ml.verbose: + print( + "\n{}\nExternal unit dictionary:\n{}\n{}\n".format( + 50 * "-", ext_unit_dict, 50 * "-" + ) + ) + + # create a dict where key is the package name, value is unitnumber + ext_pkg_d = {v.filetype: k for (k, v) in ext_unit_dict.items()} + + # reset version based on packages in the name file + if "DISU" in ext_pkg_d: + ml.structured = False + + # reset unit number for list file + if "LIST" in ext_pkg_d: + unitnumber = ext_pkg_d["LIST"] + filepth = os.path.basename(ext_unit_dict[unitnumber].filename) + ml.lst.unit_number = [unitnumber] + ml.lst.file_name = [filepth] + + # look for the free format flag in bas6 + bas_key = ext_pkg_d.get("BAS6") + if bas_key is not None: + bas = ext_unit_dict[bas_key] + start = bas.filehandle.tell() + line = bas.filehandle.readline() + while line.startswith("#"): + line = bas.filehandle.readline() + if "FREE" in line.upper(): + ml.free_format_input = True + bas.filehandle.seek(start) + if verbose: + print(f"ModflowBas6 free format:{ml.free_format_input}\n") + + # load dis + dis_key = ext_pkg_d.get("DIS") or ext_pkg_d.get("DISU") + if dis_key is None: + raise KeyError("discretization entry not found in nam file") + disnamdata = ext_unit_dict[dis_key] + dis = disnamdata.package.load( + disnamdata.filehandle, ml, ext_unit_dict=ext_unit_dict, check=False + ) + files_successfully_loaded.append(disnamdata.filename) + if ml.verbose: + print(f" {dis.name[0]:4s} package load...success") + assert ml.pop_key_list.pop() == dis_key + ext_unit_dict.pop(dis_key).filehandle.close() + + dis.start_datetime = ml._start_datetime + + if load_only is None: + # load all packages/files + load_only = ext_pkg_d.keys() + else: # check items in list + if not isinstance(load_only, list): + load_only = [load_only] + not_found = [] + for i, filetype in enumerate(load_only): + load_only[i] = filetype = filetype.upper() + if filetype not in ext_pkg_d: + not_found.append(filetype) + if not_found: + raise KeyError( + "the following load_only entries were not found " + "in the ext_unit_dict: " + str(not_found) + ) + + # zone, mult, pval + if "PVAL" in ext_pkg_d: + ml.mfpar.set_pval(ml, ext_unit_dict) + assert ml.pop_key_list.pop() == ext_pkg_d.get("PVAL") + if "ZONE" in ext_pkg_d: + ml.mfpar.set_zone(ml, ext_unit_dict) + assert ml.pop_key_list.pop() == ext_pkg_d.get("ZONE") + if "MULT" in ext_pkg_d: + ml.mfpar.set_mult(ml, ext_unit_dict) + assert ml.pop_key_list.pop() == ext_pkg_d.get("MULT") + + # try loading packages in ext_unit_dict + for key, item in ext_unit_dict.items(): + if item.package is not None: + if item.filetype in load_only: + package_load_args = getfullargspec(item.package.load)[0] + if forgive: + try: + if "check" in package_load_args: + item.package.load( + item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + check=False, + ) + else: + item.package.load( + item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + ) + files_successfully_loaded.append(item.filename) + if ml.verbose: + print( + f" {item.filetype:4s} package load...success" + ) + except Exception as e: + ml.load_fail = True + if ml.verbose: + print( + f" {item.filetype:4s} package load...failed" + ) + print(f" {e!s}") + files_not_loaded.append(item.filename) + else: + if "check" in package_load_args: + item.package.load( + item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + check=False, + ) + else: + item.package.load( + item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + ) + files_successfully_loaded.append(item.filename) + if ml.verbose: + print( + f" {item.filetype:4s} package load...success" + ) + else: + if ml.verbose: + print(f" {item.filetype:4s} package load...skipped") + files_not_loaded.append(item.filename) + elif "data" not in item.filetype.lower(): + files_not_loaded.append(item.filename) + if ml.verbose: + print(f" {item.filetype:4s} package load...skipped") + elif "data" in item.filetype.lower(): + if ml.verbose: + print(f" {item.filetype} package load...skipped") + print(f" {os.path.basename(item.filename)}") + if key not in ml.pop_key_list: + # do not add unit number (key) if it already exists + if key not in ml.external_units: + ml.external_fnames.append(item.filename) + ml.external_units.append(key) + ml.external_binflag.append( + "binary" in item.filetype.lower() + ) + ml.external_output.append(False) + else: + raise KeyError(f"unhandled case: {key}, {item}") + + # pop binary output keys and any external file units that are now + # internal + for key in ml.pop_key_list: + try: + ml.remove_external(unit=key) + item = ext_unit_dict.pop(key) + if hasattr(item.filehandle, "close"): + item.filehandle.close() + except KeyError: + if ml.verbose: + print( + f"\nWARNING:\n External file unit {key} does not " + "exist in ext_unit_dict." + ) + + # write message indicating packages that were successfully loaded + if ml.verbose: + print("") + print( + f" The following {len(files_successfully_loaded)} packages " + "were successfully loaded." + ) + for fname in files_successfully_loaded: + print(f" {os.path.basename(fname)}") + if len(files_not_loaded) > 0: + print( + f" The following {len(files_not_loaded)} packages " + "were not loaded." + ) + for fname in files_not_loaded: + print(f" {os.path.basename(fname)}") + if check: + ml.check(f=f"{ml.name}.chk", verbose=ml.verbose, level=0) + + # return model object + return ml + +def fmt_string(array): + """ + Returns a C-style fmt string for numpy savetxt that corresponds to + the dtype. + + """ + fmts = [] + for field in array.dtype.descr: + vtype = field[1][1].lower() + if vtype in ("i", "b"): + fmts.append("%10d") + elif vtype == "f": + fmts.append("%10.2E") + elif vtype == "o": + fmts.append("%10s") + elif vtype == "s": + msg = ( + "mfcln.fmt_string error: 'str' type found in dtype. " + "This gives unpredictable results when " + "recarray to file - change to 'object' type" + ) + raise TypeError(msg) + else: + raise TypeError( + "mfcln.fmt_string error: unknown vtype in " + "field: {}".format(field) + ) + return "".join(fmts) diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py new file mode 100644 index 0000000000..82ddc75f60 --- /dev/null +++ b/flopy/modflowusg/mfusgbcf.py @@ -0,0 +1,697 @@ +""" +mfusgbcf module. Contains the ModflowUsgBcf class. Note that the user can +access the ModflowUsgBcf class as `flopy.modflowusg.ModflowUsgBcf`. + +""" +import numpy as np + +from ..pakbase import Package +from ..utils import Util2d, Util3d +from ..utils.flopy_io import line_parse + + +class ModflowUsgBcf(Package): + """ + Block Centered Flow (BCF) Package Class for MODFLOW-USG. + + Parameters + ---------- + model : model object + The model object (of type :class:`flopy.modflow.Modflow`) to which + this package will be added. + ipakcb : int + A flag that is used to determine if cell-by-cell budget data should be + saved. If ipakcb is non-zero cell-by-cell budget data will be saved. + (default is 53) + intercellt : int + Intercell transmissivities, harmonic mean (0), arithmetic mean (1), + logarithmic mean (2), combination (3). (default is 0) + laycon : int + Layer type, confined (0), unconfined (1), constant T, variable S (2), + variable T, variable S (default is 3) + trpy : float or array of floats (nlay) + horizontal anisotropy ratio (default is 1.0) + hdry : float + head assigned when cell is dry - used as indicator(default is -1E+30) + iwdflg : int + flag to indicate if wetting is inactive (0) or not (non zero) + (default is 0) + wetfct : float + factor used when cell is converted from dry to wet (default is 0.1) + iwetit : int + iteration interval in wetting/drying algorithm (default is 1) + ihdwet : int + flag to indicate how initial head is computed for cells that become + wet (default is 0) + ikvflag : int + flag indicating if vertical hydraulic conductivity is input + instead of leakance between two layers. + ikcflag : int + flag indicating if hydraulic conductivity or transmissivity + information is input for each of the nodes or whether this information + is directly input for the nodal connections. The easiest input format + is to provide the hydraulic conductivity or transmissivity values to + the cells using a zero value for IKCFLAG. + anglex : float or array of floats (njag) + is the angle (in radians) between the horizontal x-axis and the outward + normal to the face between a node and its connecting nodes. The angle + varies between zero and 6.283185 (two pi being 360 degrees). + tran : float or array of floats (nlay, nrow, ncol), optional + transmissivity (only read if laycon is 0 or 2) (default is 1.0) + hy : float or array of floats (nlay, nrow, ncol) + hydraulic conductivity (only read if laycon is 1 or 3) + (default is 1.0) + vcont : float or array of floats (nlay-1, nrow, ncol) + vertical leakance between layers (default is 1.0) + kv : float or array of floats (nlay-1, nrow, ncol) + is the vertical hydraulic conductivity of the cell and the leakance is + computed for each vertical connection. + sf1 : float or array of floats (nlay, nrow, ncol) + specific storage (confined) or storage coefficient (unconfined), + read when there is at least one transient stress period. + (default is 1e-5) + sf2 : float or array of floats (nrow, ncol) + specific yield, only read when laycon is 2 or 3 and there is at least + one transient stress period (default is 0.15) + wetdry : float + a combination of the wetting threshold and a flag to indicate which + neighboring cells can cause a cell to become wet (default is -0.01) + ksat : float or array of floats (nrow, ncol) + inter-block saturated hydraulic conductivity or transmissivity + (if IKCFLAG = 1) or the inter-block conductance (if IKCFLAG = - 1) + of the connection between nodes n and m. + extension : string + Filename extension (default is 'bcf') + unitnumber : int + File unit number (default is None). + filenames : str or list of str + Filenames to use for the package and the output files. If + filenames=None the package name will be created using the model name + and package extension and the cbc output name will be created using + the model name and .cbc extension (for example, modflowtest.cbc), + if ipakcbc is a number greater than zero. If a single string is passed + the package will be set to the string and cbc output name will be + created using the model name and .cbc extension, if ipakcbc is a + number greater than zero. To define the names for all package files + (input and output) the length of the list of strings should be 2. + Default is None. + + Methods + ------- + + See Also + -------- + + Notes + ----- + + Examples + -------- + + >>> import flopy + >>> ml = flopy.modflow.Modflow() + >>> bcf = flopy.modflowusg.ModflowUsgBcf(ml) + + """ + + def __init__( + self, + model, + ipakcb=None, + intercellt=0, + laycon=3, + trpy=1.0, + hdry=-1e30, + iwdflg=0, + wetfct=0.1, + iwetit=1, + ihdwet=0, + ikvflag=0, + ikcflag=0, + tran=1.0, + hy=1.0, + vcont=1.0, + kv=1.0, + anglex=0.0, + ksat=1.0, + sf1=1e-5, + sf2=0.15, + wetdry=-0.01, + extension="bcf", + unitnumber=None, + filenames=None, + ): + + if unitnumber is None: + unitnumber = ModflowUsgBcf._defaultunit() + + # set filenames + if filenames is None: + filenames = [None, None] + elif isinstance(filenames, str): + filenames = [filenames, None] + elif isinstance(filenames, list): + if len(filenames) < 2: + filenames.append(None) + + # update external file information with cbc output, if necessary + if ipakcb is not None: + fname = filenames[1] + model.add_output_file( + ipakcb, fname=fname, package=ModflowUsgBcf._ftype() + ) + else: + ipakcb = 0 + + # Fill namefile items + name = [ModflowUsgBcf._ftype()] + units = [unitnumber] + extra = [""] + + # set package name + fname = [filenames[0]] + + # Call ancestor's init to set self.parent, extension, name and unit number + Package.__init__( + self, + model, + extension=extension, + name=name, + unit_number=units, + extra=extra, + filenames=fname, + ) + + self.url = "bcf.htm" + + nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + dis = model.get_package("DIS") + if dis is None: + dis = model.get_package("DISU") + structured = self.parent.structured + # Set values of all parameters + self.intercellt = Util2d( + model, + (nlay,), + np.int32, + intercellt, + name="laycon", + locat=self.unit_number[0], + ) + self.laycon = Util2d( + model, + (nlay,), + np.int32, + laycon, + name="laycon", + locat=self.unit_number[0], + ) + self.trpy = Util2d( + model, + (nlay,), + np.float32, + trpy, + name="Anisotropy factor", + locat=self.unit_number[0], + ) + if not structured: + njag = dis.njag + self.anglex = Util2d( + model, + (njag,), + np.float32, + anglex, + "Transmissivity", + locat=self.unit_number[0], + ) + + # item 1 + self.ipakcb = ipakcb + self.hdry = hdry + self.iwdflg = iwdflg + self.wetfct = wetfct + self.iwetit = iwetit + self.ihdwet = ihdwet + self.ikvflag = ikvflag + self.ikcflag = ikcflag + self.tran = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + tran, + "Transmissivity", + locat=self.unit_number[0], + ) + self.hy = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + hy, + "Horizontal Hydraulic Conductivity", + locat=self.unit_number[0], + ) + if model.nlay > 1: + self.vcont = Util3d( + model, + (nlay - 1, nrow, ncol), + np.float32, + vcont, + "Vertical Conductance", + locat=self.unit_number[0], + ) + else: + self.vcont = None + self.kv = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + kv, + "Vertical Hydraulic Conductivity", + locat=self.unit_number[0], + ) + self.sf1 = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + sf1, + "Primary Storage Coefficient", + locat=self.unit_number[0], + ) + self.sf2 = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + sf2, + "Secondary Storage Coefficient", + locat=self.unit_number[0], + ) + self.wetdry = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + wetdry, + "WETDRY", + locat=self.unit_number[0], + ) + self.ksat = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + ksat, + "saturated conductivity or transmissivity", + locat=self.unit_number[0], + ) + self.parent.add_package(self) + return + + def write_file(self, f=None): + """ + Write the package file. + + Returns + ------- + None + + """ + # get model information + nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + dis = self.parent.get_package("DIS") + if dis is None: + dis = self.parent.get_package("DISU") + + ifrefm = self.parent.get_ifrefm() + + # Open file for writing + if f is not None: + f_bcf = f + else: + f_bcf = open(self.fn_path, "w") + # Item 1: ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET, IKVFLAG, IKCFLAG + f_bcf.write( + ( + f" {self.ipakcb:9d} {self.hdry:9.3G} {self.iwdflg:9d}" + f" {self.wetfct:9.3G} {self.iwetit:9d} {self.ihdwet:9d}" + f" {self.ikvflag:9d} {self.ikcflag:9d}\n" + ) + ) + + # LAYCON array + for k in range(nlay): + if ifrefm: + if self.intercellt[k] > 0: + f_bcf.write( + f"{self.intercellt[k]:1d} {self.laycon[k]:1d} " + ) + else: + f_bcf.write(f"0{self.laycon[k]:1d} ") + else: + if self.intercellt[k] > 0: + f_bcf.write( + f"{self.intercellt[k]:1d} {self.laycon[k]:1d} " + ) + else: + f_bcf.write(f"0{self.laycon[k]:1d} ") + f_bcf.write("\n") + f_bcf.write(self.trpy.get_file_entry()) + transient = not dis.steady.all() + structured = self.parent.structured + anis = False + for k in range(nlay): + if self.trpy[k] != 1: + anis = True + break + if (not structured) and anis: + f_bcf.write(self.anglex.get_file_entry()) + for k in range(nlay): + if transient == True: + f_bcf.write(self.sf1[k].get_file_entry()) + if self.ikcflag == 0: ## mfusg + if (self.laycon[k] == 0) or (self.laycon[k] == 2): + f_bcf.write(self.tran[k].get_file_entry()) + else: + f_bcf.write(self.hy[k].get_file_entry()) + if (self.ikvflag == 0) and k < (nlay - 1): + f_bcf.write(self.vcont[k].get_file_entry()) + elif (self.ikvflag == 1) and (nlay > 1): # mfusg + f_bcf.write(self.kv[k].get_file_entry()) + if (transient == True) and ( + (self.laycon[k] == 2) + or (self.laycon[k] == 3) + or (self.laycon[k] == 4) + ): + f_bcf.write(self.sf2[k].get_file_entry()) + if (self.iwdflg != 0) and ( + (self.laycon[k] == 1) or (self.laycon[k] == 3) + ): + f_bcf.write(self.wetdry[k].get_file_entry()) + if (self.ikcflag == 1) or (self.ikcflag == -1): + f_bcf.write(self.ksat[k].get_file_entry()) + + f_bcf.close() + + @classmethod + def load(cls, f, model, ext_unit_dict=None): + """ + Load an existing package. + + Parameters + ---------- + f : filename or file handle + File to load. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + ext_unit_dict : dictionary, optional + If the arrays in the file are specified using EXTERNAL, + or older style array control records, then `f` should be a file + handle. In this case ext_unit_dict is required, which can be + constructed using the function + :class:`flopy.utils.mfreadnam.parsenamefile`. + + Returns + ------- + bcf : ModflowUsgBcf object + ModflowUsgBcf object. + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflow.Modflow() + >>> bcf = flopy.modflowusg.ModflowUsgBcf.load('test.bcf', m) + + """ + + if model.verbose: + print("loading bcf package file...") + + openfile = not hasattr(f, "read") + if openfile: + filename = f + f = open(filename, "r") + + # dataset 0 -- header + while True: + line = f.readline() + if line[0] != "#": + break + + # determine problem dimensions + nr, nc, nlay, nper = model.get_nrow_ncol_nlay_nper() + dis = model.get_package("DIS") + if dis is None: + dis = model.get_package("DISU") + + structured = model.structured + + # Item 1: ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET - line already read above + if model.verbose: + print(" loading ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET...") + t = line_parse(line) + ipakcb, hdry, iwdflg, wetfct, iwetit, ihdwet = ( + int(t[0]), + float(t[1]), + int(t[2]), + float(t[3]), + int(t[4]), + int(t[5]), + ) + + try: + ikvflag = int(t[6]) + except IndexError: + ikvflag = 0 + except ValueError: + ikvflag = 0 + + try: + ikcflag = int(t[7]) + except IndexError: + ikcflag = 0 + except ValueError: + ikvflag = 0 + + # LAYCON array + ifrefm = model.get_ifrefm() + if model.verbose: + print(" loading LAYCON...") + line = f.readline() + if ifrefm: + t = [] + tt = line.strip().split() + for iv in tt: + t.append(iv) + # read the rest of the laycon values + if len(t) < nlay: + while True: + line = f.readline() + tt = line.strip().split() + for iv in tt: + t.append(iv) + if len(t) == nlay: + break + else: + t = [] + istart = 0 + for k in range(nlay): + lcode = line[istart : istart + 2] + if lcode.strip() == "": + # hit end of line before expected end of data + # read next line + line = f.readline() + istart = 0 + lcode = line[istart : istart + 2] + lcode = lcode.replace(" ", "0") + t.append(lcode) + istart += 2 + intercellt = np.zeros(nlay, dtype=np.int32) + laycon = np.zeros(nlay, dtype=np.int32) + for k in range(nlay): + if len(t[k]) > 1: + intercellt[k] = int(t[k][0]) + laycon[k] = int(t[k][1]) + else: + laycon[k] = int(t[k]) + + # TRPY array + if model.verbose: + print(" loading TRPY...") + trpy = Util2d.load( + f, model, (nlay,), np.float32, "trpy", ext_unit_dict + ) + + # property data for each layer based on options + transient = not dis.steady.all() + structured = model.structured + anis = False + for k in range(nlay): + if trpy[k] != 1: + anis = True + break + if (not structured) and anis: + njag = dis.njag + if model.verbose: + print("mfusg: loading ANGLEX...") + t = Util2d.load( + f, model, (njag,), np.float32, "anglex", ext_unit_dict + ) + anglex = t + else: + anglex = 0 + + sf1 = [0] * nlay + tran = [0] * nlay + hy = [0] * nlay + if nlay > 1: + vcont = [0] * (nlay - 1) + else: + vcont = [0] * nlay + sf2 = [0] * nlay + wetdry = [0] * nlay + kv = [0] * nlay # mfusg + ksat = [0] * nlay # mfusg + + for k in range(nlay): + + # allow for unstructured changing nodes per layer + if nr is None: + nrow = 1 + ncol = nc[k] + else: + nrow = nr + ncol = nc + + # sf1 + if transient: + if model.verbose: + print(f" loading sf1 layer {k + 1:3d}...") + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "sf1", ext_unit_dict + ) + sf1[k] = t + + if ikcflag == 0: + # tran or hy + if (laycon[k] == 0) or (laycon[k] == 2): + if model.verbose: + print(f" loading tran layer {k + 1:3d}...") + t = Util2d.load( + f, + model, + (nrow, ncol), + np.float32, + "tran", + ext_unit_dict, + ) + tran[k] = t + else: + if model.verbose: + print(f" loading hy layer {k + 1:3d}...") + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "hy", ext_unit_dict + ) + hy[k] = t + + # vcont + if k < (nlay - 1): + if model.verbose: + print(f" loading vcont layer {k + 1:3d}...") + t = Util2d.load( + f, + model, + (nrow, ncol), + np.float32, + "vcont", + ext_unit_dict, + ) + vcont[k] = t + elif (ikvflag == 1) and (nlay > 1): # mfusg + if model.verbose: + print(f" loading kv layer {k + 1:3d}...") + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "kv", ext_unit_dict + ) + kv[k] = t + + # sf2 + if transient and ( + (laycon[k] == 2) or (laycon[k] == 3) or (laycon[k] == 4) + ): + if model.verbose: + print(f" loading sf2 layer {k + 1:3d}...") + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "sf2", ext_unit_dict + ) + sf2[k] = t + + # wetdry + if (iwdflg != 0) and ((laycon[k] == 1) or (laycon[k] == 3)): + if model.verbose: + print(f" loading sf2 layer {k + 1:3d}...") + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "wetdry", ext_unit_dict + ) + wetdry[k] = t + + # Ksat mfusg + if (ikcflag == 1) or (ikcflag == -1): + if model.verbose: + print(f" loading ksat layer {k + 1:3d}...") + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "ksat", ext_unit_dict + ) + ksat[k] = t + + if openfile: + f.close() + + # set package unit number + unitnumber = None + filenames = [None, None] + if ext_unit_dict is not None: + unitnumber, filenames[0] = model.get_ext_dict_attr( + ext_unit_dict, filetype=ModflowUsgBcf._ftype() + ) + if ipakcb > 0: + iu, filenames[1] = model.get_ext_dict_attr( + ext_unit_dict, unit=ipakcb + ) + model.add_pop_key_list(ipakcb) + + # create instance of bcf object + bcf = cls( + model, + ipakcb=ipakcb, + intercellt=intercellt, + laycon=laycon, + trpy=trpy, + hdry=hdry, + iwdflg=iwdflg, + wetfct=wetfct, + iwetit=iwetit, + ihdwet=ihdwet, + ikvflag=ikvflag, + ikcflag=ikcflag, + tran=tran, + hy=hy, + vcont=vcont, + kv=kv, + anglex=anglex, + ksat=ksat, + sf1=sf1, + sf2=sf2, + wetdry=wetdry, + unitnumber=unitnumber, + filenames=filenames, + ) + + # return bcf object + return bcf + + @staticmethod + def _ftype(): + return "BCF6" + + @staticmethod + def _defaultunit(): + return 15 diff --git a/flopy/modflowusg/mfusgbct.py b/flopy/modflowusg/mfusgbct.py new file mode 100644 index 0000000000..491a8b3878 --- /dev/null +++ b/flopy/modflowusg/mfusgbct.py @@ -0,0 +1,176 @@ +import numpy as np +from ..pakbase import Package +from ..utils import Util2d, Util3d + + +class ModflowUsgBct(Package): + """ + Block centered transport package class for MODFLOW-USG + """ + + def __init__( + self, + model, + itrnsp=1, + ibctcb=0, + mcomp=1, + ic_ibound_flg=1, + itvd=1, + iadsorb=0, + ict=0, + cinact=-999.0, + ciclose=1.0e-6, + idisp=1, + ixdisp=0, + diffnc=0.0, + izod=0, + ifod=0, + icbund=1, + porosity=0.1, + bulkd=1.0, + arad=0.0, + dlh=0.0, + dlv=0.0, + dth=0.0, + dtv=0.0, + sconc=0.0, + extension="bct", + unitnumber=None, + ): + + # set default unit number of one is not specified + if unitnumber is None: + unitnumber = ModflowUsgBct._defaultunit() + + # Call ancestor's init to set self.parent, extension, name and unit + # number + Package.__init__( + self, model, extension, ModflowUsgBct._ftype(), unitnumber + ) + + self.url = "bct.htm" + nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + self.itrnsp = itrnsp + self.ibctcb = ibctcb + self.mcomp = mcomp + self.ic_ibound_flg = ic_ibound_flg + self.itvd = itvd + self.iadsorb = iadsorb + self.ict = ict + self.cinact = cinact + self.ciclose = ciclose + self.idisp = idisp + self.ixdisp = ixdisp + self.diffnc = diffnc + self.izod = izod + self.ifod = ifod + self.icbund = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + icbund, + "icbund", + ) + self.porosity = Util3d( + model, (nlay, nrow, ncol), np.float32, porosity, "porosity" + ) + # self.arad = Util2d(model, (1, nja), np.float32, + # arad, 'arad') + self.dlh = Util3d(model, (nlay, nrow, ncol), np.float32, dlh, "dlh") + self.dlv = Util3d(model, (nlay, nrow, ncol), np.float32, dlv, "dlv") + self.dth = Util3d(model, (nlay, nrow, ncol), np.float32, dth, "dth") + self.dtv = Util3d(model, (nlay, nrow, ncol), np.float32, dth, "dtv") + self.sconc = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + sconc, + "sconc", + ) + self.parent.add_package(self) + return + + def write_file(self): + """ + Write the package file. + + Returns + ------- + None + + """ + nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + # Open file for writing + f_bct = open(self.fn_path, "w") + # Item 1: ITRNSP, IBCTCB, MCOMP, IC_IBOUND_FLG, ITVD, IADSORB, + # ICT, CINACT, CICLOSE, IDISP, IXDISP, DIFFNC, IZOD, IFOD + s = "{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13}" + s = s.format( + self.itrnsp, + self.ibctcb, + self.mcomp, + self.ic_ibound_flg, + self.itvd, + self.iadsorb, + self.ict, + self.cinact, + self.ciclose, + self.idisp, + self.ixdisp, + self.diffnc, + self.izod, + self.ifod, + ) + f_bct.write(s + "\n") + # + # ibound + if self.ic_ibound_flg == 0: + for k in range(nlay): + f_bct.write(self.icbund[k].get_file_entry()) + # + # porosity + for k in range(nlay): + f_bct.write(self.porosity[k].get_file_entry()) + # + # bulkd + if self.iadsorb != 0: + for k in range(nlay): + f_bct.write(self.bulkd[k].get_file_entry()) + # + # arad + if self.idisp != 0: + f_bct.write("open/close arad.dat 1.0 (free) -1\n") + # + # dlh + if self.idisp == 1: + for k in range(nlay): + f_bct.write(self.dlh[k].get_file_entry()) + # + # dlv + if self.idisp == 2: + for k in range(nlay): + f_bct.write(self.dlv[k].get_file_entry()) + # + # dth + if self.idisp == 1: + for k in range(nlay): + f_bct.write(self.dth[k].get_file_entry()) + # + # dtv + if self.idisp == 2: + for k in range(nlay): + f_bct.write(self.dtv[k].get_file_entry()) + # + # sconc + for k in range(nlay): + f_bct.write(self.sconc[k].get_file_entry()) + + return + + @staticmethod + def _ftype(): + return "BCT" + + @staticmethod + def _defaultunit(): + return 35 diff --git a/flopy/modflowusg/mfusgcln.py b/flopy/modflowusg/mfusgcln.py new file mode 100644 index 0000000000..ec271cd976 --- /dev/null +++ b/flopy/modflowusg/mfusgcln.py @@ -0,0 +1,1077 @@ +""" +mfusgcln module. Contains the ModflowUsgCln class. Note that the user can +access the ModflowUsgCln class as `flopy.modflowusg.ModflowUsgCln`. + +Compatible with USG-Transport Version 1.7.0. which can be downloade from +https://www.gsi-net.com/en/software/free-software/modflow-usg.html + +Additional information for this MODFLOW package can be found at the `Online +MODFLOW Guide +Panday, S., 2021; USG-Transport Version 1.7.0: The Block-Centered Transport +Process for MODFLOW-USG, GSI Environmental, March, 2021 + +Panday, Sorab, Langevin, C.D., Niswonger, R.G., Ibaraki, Motomu, and Hughes, +J.D., 2013, MODFLOW–USG version 1: An unstructured grid version of MODFLOW +for simulating groundwater flow and tightly coupled processes using a control +volume finite-difference formulation: U.S. Geological Survey Techniques and +Methods, book 6, chap. A45, 66 p. +""" + +import numpy as np +from ..pakbase import Package +from ..utils import Util2d + +from .mfusg import fmt_string + + +class ModflowUsgCln(Package): + """ + Connected Linear Network (CLN) Package class for MODFLOW-USG. + + Parameters + ---------- + model : model object + The model object (of type :class:`flopy.modflowusg.mf.Modflow`) to which + this package will be added. + ncln : int + is a flag or the number of CLN segments. If NCLN = 0, this flag + indicates that the CLN domain connectivity is input in a general IA-JA + manner as is used for the GWF Process.If NCLN > 0, linear CLN segments + (for instance multi-aquifer wells) or simple CLN networks are simulated + and NCLN is the total number of CLN segments in the domain. + iclnnds : int + is a flag or number of CLN-nodes simulated in the model. Multiple + CLN-nodes constitute a segment.If ICLNNDS < 0, the CLN-nodes are + ordered in a sequential manner from the first CLN node to the last + CLN node. Therefore, only linear CLN segments are simulated since a + CLN segment does not share any of its nodes with another CLN segment. + If ICLNNDS > 0, CLN networks can be simulated and ICLNNDS is + the total number of CLN-nodes simulated by the model (NCLNNDS). CLN + nodes can be shared among CLN segments and therefore, the CLN-nodal + connectivity for the network is also required as input. + nndcln : list of int + is the number of CLN-nodes that are associated with each CLN segment. + Only read if NCLN > 0. If ICLNNDS < 0, sum of nndcln is the total number + of CLN-nodes (NCLNNDS) + clncon : list of list + are the CLN-node numbers associated with each CLN segment. Only read + if NCLN > 0 and ICLNNDS > 0. It is read NCLN times, once for each CLN + segment. The number of entries for each line is the number of CLN + cells (NNDCLN) associated with each CLN segment + nja_cln : int + is the total number of connections of the CLN domain. NJA_CLN is used + to dimension the sparse matrix in a compressed row storage format. + iac_cln : list of int + is a matrix indicating the number of connections plus 1 for each CLN + node to another CLN node. Note that the IAC_CLN array is only supplied + for the CLN cells; the IAC_CLN array is internally expanded to include + other domains if present in a simulation. sum(IAC)=NJAG + ja_cln : list of list + is a list of CLN cell number (n) followed by its connecting CLN cell + numbers (m) for each of the m CLN cells connected to CLN cell n. This + list is sequentially provided for the first to the last CLN cell. + Note that the cell and its connections are only supplied for the CLN + cells and their connections to the other CLN cells using the local CLN + cell numbers. + node_prop : matrix + [IFNO IFTYP IFDIR FLENG FELEV FANGLE IFLIN ICCWADI X1 Y1 Z1 X2 Y2 Z2] + is a table of the node properties. Total rows equal the total number + of CLN-nodes (NCLNNDS). The first 6 fields is required for running + model. Rest of fields have default value of 0. + nclngwc : int + is the number of CLN to porous-medium grid-block connections present + in the model. A CLN node need not be connected to any groundwater node. + Conversely, a CLN node may be connected to multiple groundwater nodes, + or multiple CLN nodes may be connected to the same porous medium mode. + cln_gwc : matrix + unstructured: [IFNOD IGWNOD IFCON FSKIN FLENGW FANISO ICGWADI] + structured: [IFNOD IGWLAY IGWROW IGWFCOL IFCON FSKIN FLENGW FANISO + ICGWADI] + is a table define connections between CLN nodes and groundwater cells. + Total rows of the table equals nclngwc. + nconduityp : int + is the number of circular conduit-geometry types. + cln_circ : + [ICONDUITYP FRAD CONDUITK TCOND TTHK TCFLUID TCONV] + is a table define the circular conduit properties. Total rows of the + table equals nconduityp. Last 4 fields only needed for heat transport + simulation. + ibound : 1-D array + is the boundary array for CLN-nodes. Length equal NCLNNDS + strt : 1-D array + is initial head at the beginning of the simulation in CLN nodes. + Length equal NCLNNDS + transient : bool + if there is transient IBOUND for each stress period + printiaja : bool + whether to print IA_CLN and JA_CLN to listing file + nrectyp : int + is the number of rectangular conduit-geometry types. + cln_rect : rectangular fracture properties + [IRECTYP FLENGTH FHEIGHT CONDUITK TCOND TTHK TCFLUID TCONV] + is read for each rectangular conduit. Total rows of the table equals + nrectyp. Last 4 fields only needed for heat transport simulation. + BHE : bool + is a flag indicating that BHE details are also included in a heat transport + model. Specifically, the thermal conductance and BHE tube thickness are + included in transfer of heat between groundwater and CLN cells along with + the heat conductivity of the BHE fluid and the convective heat transfer + coefficient. + grav : float + is the gravitational acceleration constant in model simulation units. + The value of the constant follows the keyword GRAVITY. Note that the + constant value is 9.81 m/s2 in SI units; 32.2 ft/s2 in fps units. + visk : float + is the kinematic viscosity of water in model simulation units [L2/T]. + The value of kinematic viscosity follows the keyword VISCOSITY. Note + that the constant value is 1.787 x 10-6 m2/s in SI units; + 1.924 x 10-5 ft2/s in fps units. + extension : list of strings + (default is ['cln','clncb','clnhd','clndd','clnib','clncn','clnmb']). + unitnumber : list of int + File unit number for the package and the output files. + (default is [71, 0, 0, 0, 0, 0, 0] ). + filenames : list of str + Filenames to use for the package and the output files. If filenames + = None the package name will be created using the model name and package + extensions. + + Attributes + ---------- + + Methods + ------- + + See Also + -------- + + Notes + ----- + + Examples + -------- + + >>> import flopy + >>> ml = flopy.modflow.Modflow(version='mfusg', exe_name='mfusg.exe') + >>> node_prop = [[1,1,0,10.0,-110.0,1.57,0,0],[2,1,0,10.0,-130.0,1.57,0,0]] + >>> cln_gwc = [[1,1,50,50,0,0,10.0,1.0,0],[2,2,50,50,0,0,10.0,1.0,0]] + >>> cln = flopy.modflowusg.ModflowUsgCln(ml, ncln=1, iclnnds=-1, nndcln=2, + nclngwc = 2, node_prop =node_prop, cln_gwc =cln_gwc) + + """ + + def __init__( + self, + model, + ncln=None, # number of CLNs + iclnnds=None, # number of nodes + nndcln=None, # number of nodes in each CLN segments + clncon=None, # node IDs in each CLN segments + nja_cln=None, # total number of node-node connections (NJAG) + iac_cln=None, # number of connections for each node (sum(IAC)=NJAG + ja_cln=None, # node connections + node_prop=None, # node properties + nclngwc=None, # number of CLN-GW connections + cln_gwc=None, # CLN-GW connections + nconduityp=1, # number of circular conduit types + cln_circ=None, # circular conduit properties + ibound=1, # boundary condition types + strt=1.0, # initial head in CLN cells + transient=False, # OPTIONS: transient IBOUND for each stress period + printiaja=False, # OPTIONS: print IA_CLN and JA_CLN to listing file + nrectyp=0, # OPTIONS2: number of rectangular fracture types + cln_rect=None, # rectangular fracture properties + BHE=False, # OPTIONS2: borehole heat exchanger (BHE) + grav=None, # OPTIONS2: gravitational acceleration constant + visk=None, # OPTIONS2: kinematic viscosity of water + extension=[ + "cln", + "clncb", + "clnhd", + "clndd", + "clnib", + "clncn", + "clnmb", + ], + unitnumber=None, + filenames=None, + ): + if model.version != "mfusg": + err = "Error: model version must be mfusg to use CLN package" + raise Exception(err) + + # set default unit number of one is not specified + if unitnumber is None: + unitnumber = ModflowUsgCln._defaultunit() + elif isinstance(unitnumber, list): + if len(unitnumber) < 7: + for idx in range(len(unitnumber), 7): + unitnumber.append(0) + + # set filenames + if filenames is None: + filenames = [None, None, None, None, None, None, None] + elif isinstance(filenames, str): + filenames = [filenames, None, None, None, None, None, None] + elif isinstance(filenames, list): + if len(filenames) < 7: + for idx in range(len(filenames), 7): + filenames.append(None) + + # Fill namefile items + name = [ModflowUsgCln._ftype()] + extra = [""] + exten = [extension[0]] + units = unitnumber[0] + + # set package name + fname = [filenames[0]] + # Call ancestor's init to set self.parent, extension, name and unit number + Package.__init__( + self, + model, + extension=exten, + name=name, + unit_number=units, + extra=extra, + filenames=fname, + ) + + self.url = "Connected_Linear_Network.htm" + + self._generate_heading() + + # Options + self.transient = transient + self.printiaja = printiaja + + # Options2 is for Darcy-Weisbach equation. Not used. + self.nrectyp = nrectyp + self.BHE = BHE + self.grav = grav + self.visk = visk + + # CLN output files + self.iclncb = unitnumber[1] + # >0: File unit for CLN CBB; 0 No budget output; <0 budget in List file + if self.iclncb > 0: + model.add_output_file( + self.iclncb, + fname=filenames[1], + extension=extension[1], + binflag=True, + package=ModflowUsgCln._ftype(), + ) + self.iclnhd = unitnumber[2] + # >0: File unit for CLN HDS; 0: No head output; + if self.iclnhd > 0: + model.add_output_file( + self.iclnhd, + fname=filenames[2], + extension=extension[2], + binflag=True, + package=ModflowUsgCln._ftype(), + ) + self.iclndd = unitnumber[3] + # >0: File unit for CLN Drawdown; 0: No drawdown output; + if self.iclndd > 0: + model.add_output_file( + self.iclndd, + fname=filenames[3], + extension=extension[3], + binflag=True, + package=ModflowUsgCln._ftype(), + ) + self.iclnib = unitnumber[4] + # >0: File unit for CLN IBOUND; 0: No IBOUND output; + if self.iclnib > 0: + model.add_output_file( + self.iclnib, + fname=filenames[4], + extension=extension[4], + binflag=True, + package=ModflowUsgCln._ftype(), + ) + self.iclncn = unitnumber[5] + # >0: File unit for CLN concentration; 0: No concentration output; + if self.iclncn > 0: + model.add_output_file( + self.iclncn, + fname=filenames[5], + extension=extension[5], + binflag=True, + package=ModflowUsgCln._ftype(), + ) + self.iclnmb = unitnumber[6] + # >0: File unit for CLN mass flux; 0: No mass flux output; + if self.iclnmb > 0: + model.add_output_file( + self.iclnmb, + fname=filenames[6], + extension=extension[6], + binflag=True, + package=ModflowUsgCln._ftype(), + ) + + ## Define CLN networks + if ncln is None: + raise Exception("mfcln: CLN network not defined") + + self.ncln = ncln + self.iclnnds = iclnnds + + if self.ncln > 0: # Linear CLN segments + if nndcln is None: + raise Exception( + "mfcln: nodes for each CLN segment must be provided" + ) + self.nndcln = Util2d( + model, + (self.ncln,), + np.int32, + nndcln, + name="nndcln", + locat=self.unit_number[0], + ) + + # consequtive node number. No connection between segments + if self.iclnnds < 0: + self.nclnnds = self.nndcln.array.sum() + self.nodeno = [x + 1 for x in range(self.nclnnds)] + # Node number provided for each segment to simulate CLN networks + elif self.iclnnds > 0: + self.nclnnds = self.iclnnds + self.clncon = clncon + self.nodeno = list(set(clncon)) + else: + raise Exception("mfcln: Node number = 0") + + elif self.ncln == 0: # CLN network defined by IA-JA connection matrix + if self.iclnnds <= 0: + raise Exception("mfcln: Negative or zero number of nodes") + + self.nclnnds = self.iclnnds + + self.nodeno = [x + 1 for x in range(self.nclnnds)] + + self.nja_cln = nja_cln + + if iac_cln is None: + raise Exception("mfcln: iac_cln must be provided") + self.iac_cln = Util2d( + model, + (self.nclnnds,), + np.int32, + iac_cln, + name="iac_cln", + locat=self.unit_number[0], + ) + + msg = "mfcln: The sum of iac_cln must equal nja_cln." + assert self.iac_cln.array.sum() == nja_cln, msg + + if ja_cln is None: + raise Exception("mfcln: ja_cln must be provided") + if ja_cln[0] == 0: + # convert from zero-based to one-based + ja_cln += 1 + self.ja_cln = Util2d( + model, + (self.nja_cln,), + np.int32, + ja_cln, + name="ja_cln", + locat=self.unit_number[0], + ) + + else: + raise Exception( + "mfcln: negative number of CLN segments in CLN package" + ) + + if node_prop is None: + raise Exception("mfcln: Node properties must be provided") + + if len(node_prop) != self.nclnnds: + raise Exception( + "mfcln: Length of Node properties must equal number of nodes" + ) + + self.node_prop = make_recarray( + node_prop, dtype=ModflowUsgCln.get_clnnode_dtype() + ) + + if nclngwc is None: + raise Exception("mfcln: CLN-GW connections not defined") + self.nclngwc = nclngwc # number of CLN-GW connections + + if cln_gwc is None: + raise Exception("mfcln: CLN-GW connection not provided") + + if len(cln_gwc) != self.nclngwc: + raise Exception( + "mfcln: Number of CLN-GW connections not equal nclngwc" + ) + + structured = self.parent.structured + + self.cln_gwc = make_recarray( + cln_gwc, dtype=ModflowUsgCln.get_gwconn_dtype(structured) + ) + + # Circular conduit geometry types + + self.nconduityp = nconduityp + + if self.nconduityp <= 0 or cln_circ is None: + raise Exception( + "mfcln: Circular conduit properties must be provided" + ) + + if len(cln_circ) != self.nconduityp: + raise Exception( + "mfcln: Number of circular properties not equal nconduityp" + ) + + self.cln_circ = make_recarray( + cln_circ, dtype=ModflowUsgCln.get_clncirc_dtype(self.BHE) + ) + + # Rectangular conduit geometry types + if self.nrectyp > 0: + if len(cln_rect) != self.nconduityp: + raise Exception( + "mfcln: Number of rectangular properties not equal nrectyp" + ) + self.cln_rect = make_recarray( + cln_rect, dtype=ModflowUsgCln.get_clnrect_dtype(self.BHE) + ) + + self.ibound = Util2d( + model, + (self.nclnnds,), + np.int32, + ibound, + name="ibound", + locat=self.unit_number[0], + ) + + self.strt = Util2d( + model, + (self.nclnnds,), + np.float32, + strt, + name="strt", + locat=self.unit_number[0], + ) + + self.parent.add_package(self) + + @staticmethod + def get_clnnode_dtype(): + """ + dtype of CLN node properties. + + Returns + ------- + dtype + + """ + dtype = np.dtype( + [ + ("ifno", int), ## node number + ("iftyp", int), ## type-index + ("ifdir", int), ## directional index + ("fleng", np.float32), ## length + ("felev", np.float32), ## elevation of the bottom + ("fangle", np.float32), ## angle + ("iflin", int), ## flag of flow conditions + ("iccwadi", int), ## flag of vertical flow correction + ("x1", np.float32), ## coordinates + ("y1", np.float32), ## coordinates + ("z1", np.float32), ## coordinates + ("x2", np.float32), ## coordinates + ("y2", np.float32), ## coordinates + ("z2", np.float32), ## coordinates + ] + ) + return dtype + + @staticmethod + def get_gwconn_dtype(structured=True): + """ + dtype of CLN node - GW node connection properties. + + Parameters + ---------- + structured : True = structured grid + + Returns + ------- + dtype + + """ + if structured: + dtype = np.dtype( + [ + ("ifnod", int), ##CLN node number + ("igwlay", int), ##layer number of connecting gw node + ("igwrow", int), ##row number of connecting gw node + ("igwfcol", int), ##col number of connecting gw node + ("ifcon", int), ##index of connectivity equation + ("fskin", np.float32), ##leakance across a skin + ("flengw", np.float32), ##length of connection + ( + "faniso", + np.float32, + ), ##anisotropy or thickness of sediments + ("icgwadi", int), ##flag of vertical flow correction + ] + ) + else: + dtype = np.dtype( + [ + ("ifnod", int), ##CLN node number + ("igwnod", int), ##node number of connecting gw node + ("ifcon", int), ##index of connectivity equation + ("fskin", np.float32), ##leakance across a skin + ("flengw", np.float32), ##length of connection + ( + "faniso", + np.float32, + ), ##anisotropy or thickness of sediments + ("icgwadi", int), ##flag of vertical flow correction + ] + ) + return dtype + + @staticmethod + def get_clncirc_dtype(BHE=False): + """ + dtype of CLN node circular conduit type properties. + + Parameters + ---------- + BHE : borehole heat exchanger (BHE) + + Returns + ------- + dtype + + """ + if BHE: + dtype = np.dtype( + [ + ("iconduityp", int), ## index of circular conduit type + ("frad", np.float32), ## radius + ( + "conduitk", + np.float32, + ), ## conductivity or resistance factor + ("tcond", np.float32), ## thermal conductivity of BHE tube + ("tthk", np.float32), ## thickness + ( + "tcfluid", + np.float32, + ), ## thermal conductivity of the fluid + ("tconv", np.float32), ## thermal convective coefficient + ] + ) + else: + dtype = np.dtype( + [ + ("iconduityp", int), ## index of circular conduit type + ("frad", np.float32), ## radius + ( + "conduitk", + np.float32, + ), ## conductivity or resistance factor + ] + ) + return dtype + + @staticmethod + def get_clnrect_dtype(BHE=False): + """ + Returns the dtype of CLN node rectangular conduit type properties. + + Parameters + ---------- + BHE : borehole heat exchanger (BHE) + + Returns + ------- + dtype + + """ + if BHE: + dtype = np.dtype( + [ + ("irectyp", int), ## index of rectangular conduit type + ("flength", np.float32), ## width + ("fheight", np.float32), ## height + ( + "conduitk", + np.float32, + ), ## conductivity or resistance factor + ("tcond", np.float32), ## thermal conductivity of BHE tube + ("tthk", np.float32), ## thickness of BHE tube + ("tcfluid", np.float32), ## thermal conductivity of fluid + ("tconv", np.float32), ## thermal convective + ] + ) + else: + dtype = np.dtype( + [ + ("irectyp", int), ## index of rectangular conduit type + ("flength", np.float32), ## width + ("fheight", np.float32), ## height + ( + "conduitk", + np.float32, + ), ## conductivity or resistance factor + ] + ) + return dtype + + @property + def cln_nodes(self): + """ + Returns the total number of CLN nodes. + + """ + return self.nclnnds + + def write_file(self, f=None): + """ + Write the package file. + + Returns + ------- + None + + """ + if f is not None: + if isinstance(f, str): + f_cln = open(f, "w") + else: + f_cln = f + else: + f_cln = open(self.fn_path, "w") + + f_cln.write(f"{self.heading}\n") + + if self.transient or self.printiaja: + f_cln.write("OPTIONS ") + if self.transient: + f_cln.write("TRANSIENT ") + if self.printiaja: + f_cln.write("PRINTIAJA ") + f_cln.write("\n") + + f_cln.write( + ( + f" {self.ncln:9d} {self.iclnnds:9d} {self.iclncb:9d}" + f" {self.iclnhd:9d} {self.iclndd:9d} {self.iclnib:9d}" + f" {self.nclngwc:9d} {self.nconduityp:9d}" + ) + ) + + if self.nrectyp > 0: + f_cln.write(f"RECTANGULAR {self.nrectyp:d}") + if self.BHE: + f_cln.write("BHEDETAIL ") + if self.iclncn != 0: + f_cln.write(f"SAVECLNCON {self.iclncn:d}") + if self.iclnmb != 0: + f_cln.write(f"SAVECLNMAS {self.iclnmb:d}") + if self.grav is not None: + f_cln.write(f"GRAVITY {self.grav:f}") + if self.visk is not None: + f_cln.write(f"VISCOSITY {self.visk:f}") + f_cln.write("\n") + + if self.ncln > 0: + f_cln.write(self.nndcln.get_file_entry()) + if self.iclnnds > 0: + for icln in range(self.ncln): + f_cln.write(self.clncon[icln]) + elif self.ncln == 0: + f_cln.write(f" {self.nja_cln:9d}\n") + f_cln.write(self.iac_cln.get_file_entry()) + f_cln.write(self.ja_cln.get_file_entry()) + + np.savetxt( + f_cln, self.node_prop, fmt=fmt_string(self.node_prop), delimiter="" + ) + + np.savetxt( + f_cln, self.cln_gwc, fmt=fmt_string(self.cln_gwc), delimiter="" + ) + + if self.nconduityp > 0: + np.savetxt( + f_cln, + self.cln_circ, + fmt=fmt_string(self.cln_circ), + delimiter="", + ) + + if self.nrectyp > 0: + np.savetxt( + f_cln, + self.cln_rect, + fmt=fmt_string(self.cln_rect), + delimiter="", + ) + + f_cln.write(self.ibound.get_file_entry()) + f_cln.write(self.strt.get_file_entry()) + + f_cln.close() + + @classmethod + def load(cls, f, model, ext_unit_dict=None): + """ + Load an existing package. + + Parameters + ---------- + f : filename or file handle + File to load. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + ext_unit_dict : dictionary, optional + If the arrays in the file are specified using EXTERNAL, + or older style array control records, then `f` should be a file + handle. In this case ext_unit_dict is required, which can be + constructed using the function + :class:`flopy.utils.mfreadnam.parsenamefile`. + + Returns + ------- + cln : ModflowUsgCln object + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflow.Modflow() + >>> cln = flopy.modflowusg.ModflowUsgCln.load('test.cln', m) + + """ + + if model.verbose: + print("loading CLN package file...\n") + + if model.version != "mfusg": + msg = ( + "Warning: model version was reset from " + + "'{}' to 'mfusg' in order to load a CLN file".format( + model.version + ) + ) + print(msg) + model.version = "mfusg" + + openfile = not hasattr(f, "read") + if openfile: + filename = f + f = open(filename, "r") + + line = f.readline() + + # Options + transient = False + printiaja = False + if line.startswith("OPTIONS"): + t = line.strip().split() + if "TRANSIENT" in t: + transient = True + if "PRINTIAJA" in t: + printiaja = True + line = f.readline() + + t = line.strip().split() + ncln, iclnnds, iclncb, iclnhd, iclndd, iclnib, nclngwc, nconduityp = ( + int(t[0]), + int(t[1]), + int(t[2]), + int(t[3]), + int(t[4]), + int(t[5]), + int(t[6]), + int(t[7]), + ) + # Options2 + if "RECTANGULAR" in t: + idx = t.index("RECTANGULAR") + nrectyp = int(t[idx + 1]) + else: + nrectyp = 0 + cln_rect = None + + if "BHEDETAIL" in t: + BHE = True + else: + BHE = False + + if "SAVECLNCON" in t: + idx = t.index("SAVECLNCON") + iclncn = int(t[idx + 1]) + else: + iclncn = 0 + + if "SAVECLNMAS" in t: + idx = t.index("SAVECLNMAS") + iclnmb = int(t[idx + 1]) + else: + iclnmb = 0 + + if "GRAVITY" in t: + idx = t.index("GRAVITY") + grav = float(t[idx + 1]) + else: + grav = None + + if "VISCOSITY" in t: + idx = t.index("VISCOSITY") + visk = float(t[idx + 1]) + else: + visk = None + + if model.verbose: + print(" ncln {}".format(ncln)) + print(" iclnnds {}".format(iclnnds)) + print(" iclncb {}".format(iclncb)) + print(" iclnhd {}".format(iclnhd)) + print(" iclndd {}".format(iclndd)) + print(" iclnib {}".format(iclnib)) + print(" nclngwc {}".format(nclngwc)) + print(" TRANSIENT {}".format(transient)) + print(" PRINTIAJA {}".format(printiaja)) + print(" RECTANGULAR {}".format(nrectyp)) + print(" BHEDETAIL {}".format(BHE)) + print(" SAVECLNCON {}".format(iclncn)) + print(" SAVECLNMAS {}".format(iclnmb)) + print(" GRAVITY {}".format(grav)) + print(" VISCOSITY {}".format(visk)) + + nndcln = None + clncon = None + nja_cln = None + iac_cln = None + ja_cln = None + if ncln > 0: + nndcln = Util2d.load( + f, model, (ncln,), np.int32, "nndcln", ext_unit_dict + ) + if model.verbose: + print(" nndcln {}".format(nndcln)) + nclnnds = nndcln.array.sum() + if iclnnds > 0: + nclnnds = iclnnds + clncon = [] + for icln in range(ncln): + line = f.readline() + t = line.strip().split() + + iclncon = [] + for i in range(nndcln[icln]): + iclncon.append(t[i]) + + clncon = clncon.append(iclncon) + if model.verbose: + print(" clncon {}".format(clncon)) + + elif ncln == 0: + line = f.readline() + t = line.strip().split() + nja_cln = int(t[0]) + if model.verbose: + print(" nja_cln {}".format(nja_cln)) + + nclnnds = abs(iclnnds) + iac_cln = Util2d.load( + f, model, (nclnnds,), np.int32, "iac_cln", ext_unit_dict + ) + if model.verbose: + print(" iac_cln {}".format(iac_cln)) + + ja_cln = Util2d.load( + f, model, (nja_cln,), np.int32, "ja_cln", ext_unit_dict + ) + if model.verbose: + print(" ja_cln {}".format(ja_cln)) + else: + raise Exception("mfcln: negative number of CLN segments") + + node_prop = read_prop(f, nclnnds) + if model.verbose: + print(" node_prop {}".format(node_prop)) + + cln_gwc = read_prop(f, nclngwc) + if model.verbose: + print(" cln_gwc {}".format(cln_gwc)) + cln_circ = read_prop(f, nconduityp) + if model.verbose: + print(" cln_circ {}".format(cln_circ)) + + if nrectyp > 0: + cln_rect = read_prop(f, nrectyp) + if model.verbose: + print(" cln_rect {}".format(cln_circ)) + else: + cln_rect = None + + ibound = Util2d.load( + f, model, (nclnnds,), np.int32, "ibound", ext_unit_dict + ) + if model.verbose: + print(" ibound {}".format(ibound)) + + strt = Util2d.load( + f, model, (nclnnds,), np.float32, "strt", ext_unit_dict + ) + if model.verbose: + print(" strt {}".format(strt)) + + if openfile: + f.close() + + # set package unit number + # reset unit numbers + unitnumber = ModflowUsgCln._defaultunit() + filenames = [None, None, None, None, None, None, None] + + if ext_unit_dict is not None: + unitnumber[0], filenames[0] = model.get_ext_dict_attr( + ext_unit_dict, filetype=ModflowUsgCln._ftype() + ) + if iclncb > 0: + unitnumber[1], filenames[1] = model.get_ext_dict_attr( + ext_unit_dict, unit=iclncb + ) + model.add_pop_key_list(iclncb) + if iclnhd != 0: + unitnumber[2], filenames[2] = model.get_ext_dict_attr( + ext_unit_dict, unit=abs(iclnhd) + ) + model.add_pop_key_list(abs(iclnhd)) + if iclndd != 0: + unitnumber[3], filenames[3] = model.get_ext_dict_attr( + ext_unit_dict, unit=abs(iclndd) + ) + model.add_pop_key_list(abs(iclndd)) + if iclnib != 0: + unitnumber[4], filenames[4] = model.get_ext_dict_attr( + ext_unit_dict, unit=abs(iclnib) + ) + model.add_pop_key_list(abs(iclnib)) + if iclncn > 0: + unitnumber[5], filenames[5] = model.get_ext_dict_attr( + ext_unit_dict, unit=iclncn + ) + model.add_pop_key_list(iclncn) + if iclnmb > 0: + unitnumber[6], filenames[6] = model.get_ext_dict_attr( + ext_unit_dict, unit=iclnmb + ) + model.add_pop_key_list(iclnmb) + + # create dis object instance + cln = cls( + model, + ncln=ncln, + iclnnds=iclnnds, + nndcln=nndcln, + clncon=clncon, + nja_cln=nja_cln, + iac_cln=iac_cln, + ja_cln=ja_cln, + node_prop=node_prop, + nclngwc=nclngwc, + cln_gwc=cln_gwc, + nconduityp=nconduityp, + cln_circ=cln_circ, + ibound=ibound, + strt=strt, + transient=transient, + printiaja=printiaja, + nrectyp=nrectyp, + cln_rect=cln_rect, + grav=grav, + visk=visk, + BHE=BHE, + unitnumber=unitnumber, + filenames=filenames, + ) + + # return dis object instance + return cln + + @staticmethod + def _ftype(): + return "CLN" + + @staticmethod + def _defaultunit(): + return [71, 0, 0, 0, 0, 0, 0] + + +def is_float(s): + """ + Test whether the string is a float number. + + """ + try: + float(s) + except ValueError: + return False + else: + return True + + +def make_recarray(array, dtype): + """ + + Returns a empty recarray based on dtype. + + """ + nprop = len(dtype.names) + ptemp = [] + for t in array: + if len(t) < nprop: + t = t + (nprop - len(t)) * [0.0] + else: + t = t[:nprop] + ptemp.append(tuple(t)) + + return np.array(ptemp, dtype) + + +def read_prop(f, nrec): + """ + + Read the property tables (node_prop, cln_gwc, cln_circ, cln_rect). + + Parameters + ---------- + f : package file handle + nrec : number of rows in the table + + Returns + ------- + A list of lists with length of nrec + + """ + ptemp = [] + + for _ in range(nrec): + line = f.readline() + t = line.strip().split() + ra = [float(s) for s in t if is_float(s)] + ptemp.append(ra) + + return ptemp diff --git a/flopy/modflowusg/mfusggnc.py b/flopy/modflowusg/mfusggnc.py new file mode 100644 index 0000000000..17a48c2239 --- /dev/null +++ b/flopy/modflowusg/mfusggnc.py @@ -0,0 +1,351 @@ +""" +mfusggnc module. This is for the Ghost Node Correction (GNC) Package for MODFLOW-USG. +Contains the ModflowUsgGnc class. Note that the user can access +the ModflowUsgGnc class as `flopy.modflowusg.ModflowUsgGnc`. + + +""" +import numpy as np +from ..pakbase import Package +from ..utils.recarray_utils import create_empty_recarray +from ..utils.flopy_io import ulstrd +from ..modflow.mfparbc import ModflowParBc as mfparbc + +from .mfusg import fmt_string + + +class ModflowUsgGnc(Package): + """ + MODFLOW USG Ghost Node Correction (GNC) Package Class. + + Parameters + ---------- + numgnc : integer + numgnc (integer) is the number of GNC entries. + numalphaj : integer + numalphaj (integer) is the number of contributing factors. + i2kn : integer + 0 : second-order correction not applied to unconfined transmissivity. + 1 : second-order correction applied to unconfined transmissivity. + isymgncn : integer + 0 : implicit update on left-hand side matrix for asymmetric systems. + 1 : explicit update on right-hand side vector for symmetric systems. + iflalphan : integer + 0 : AlphaJ is contributing factors from all adjacent contributing nodes. + 1 : AlphaJ represent the saturated conductances between the ghost node + location and node j, and the contributing factors are computed + internally using the equations for the unconfined conductances. + gncdata : [cellidn, cellidm, cellidsj, alphasj] + * cellidn ((integer, ...)) is the cellid of the cell in which the ghost + node is located. + * cellidm ((integer, ...)) is the cellid of the connecting cell + * cellidsj ((integer, ...)) is the array of CELLIDS for the + contributing j cells. This Item is repeated for each of the numalphaj + adjacent contributing cells of the ghost node. + * alphasj (double) is the contributing factors for each contributing + node in CELLIDSJ. This Item is repeated for each of the numalphaj + adjacent contributing cells of the ghost node. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to which + this package will be added. + extension : str, optional + File extension (default is 'gnc'. + unitnumber : int, optional + FORTRAN unit number for this package (default is None). + filenames : str or list of str + Filenames to use for the package. If filenames=None the package name + will be created using the model name and package extension. If a + single string is passed the package will be set to the string. + Default is None. + + Attributes + ---------- + + Methods + ------- + + See Also + -------- + + Notes + ----- + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflow.Modflow() + >>> gnc = flopy.modflowusg.ModflowUsgGnc(m) + + """ + + def __init__( + self, + model, + numgnc=0, + numalphaj=1, + i2kn=0, + isymgncn=0, + iflalphan=0, + gncdata=None, + extension="gnc", + options=None, + unitnumber=None, + filenames=None, + ): + # set default unit number of one is not specified + if unitnumber is None: + unitnumber = ModflowUsgGnc._defaultunit() + + # set filenames + if filenames is None: + filenames = [None] + elif isinstance(filenames, str): + filenames = [filenames] + + # Fill namefile items + name = [ModflowUsgGnc._ftype()] + units = [unitnumber] + extra = [""] + + # set package name + fname = [filenames[0]] + + # Call ancestor's init to set self.parent, extension, name and + # unit number + Package.__init__( + self, + model, + extension=extension, + name=name, + unit_number=units, + extra=extra, + filenames=fname, + ) + + self._generate_heading() + self.url = " " + + if options is None: + options = [] + + self.options = options + + if numgnc > 0: + self.numgnc = numgnc + else: + raise Exception("mfgnc: number of GNC cell must be larger than 0") + + if numalphaj > 0 and numalphaj < 6: + self.numalphaj = numalphaj + else: + raise Exception( + "mfgnc: incorrect number of adjacent contributing nodes" + ) + + self.i2kn = i2kn + self.isymgncn = isymgncn + self.iflalphan = iflalphan + + if gncdata is None: + raise Exception("mfgnc: GNC data must be provided") + + if len(gncdata) != self.numgnc: + raise Exception( + "mfgnc: Length of GNC data must equal number of GNC nodes" + ) + + self.dtype = ModflowUsgGnc.get_default_dtype( + self.numalphaj, self.iflalphan + ) + + self.gncdata = np.array(gncdata, self.dtype) + + self.parent.add_package(self) + + return + + def write_file(self, f=None): + """ + Write the package file. + + Returns + ------- + None + + """ + if f is not None: + if isinstance(f, str): + f_gnc = open(f, "w") + else: + f_gnc = f + else: + f_gnc = open(self.fn_path, "w") + + f_gnc.write(f"{self.heading}\n") + + f_gnc.write( + ( + f" {0:9d} {0:9d} {self.numgnc:9d} {self.numalphaj:9d}" + f" {self.i2kn:9d} {self.isymgncn:9d} {self.iflalphan:9d}" + f" {self.options}\n" + ) + ) + + gdata = self.gncdata.copy() + + gdata["NodeN"] += 1 + gdata["NodeM"] += 1 + for i in range(self.numalphaj): + gdata[f"Node{i:d}"] += 1 + + np.savetxt(f_gnc, gdata, fmt=fmt_string(gdata), delimiter="") + + f_gnc.write("\n") + f_gnc.close() + + @staticmethod + def get_default_dtype(numalphaj, iflalphan): + dtype = np.dtype( + [ + ("NodeN", int), + ("NodeM", int), + ] + ).descr + + for i in range(numalphaj): + dtype.append((f"Node{i:d}", ">> import flopy + >>> m = flopy.modflow.Modflow() + >>> gnc = flopy.modflow.ModflowGnc.load('test.gnc', m) + + """ + + if model.verbose: + print("loading gnc package file...") + + if model.version != "mfusg": + print( + "Warning: model version was reset from '{}' to 'mfusg' " + "in order to load a GNC file".format(model.version) + ) + model.version = "mfusg" + + openfile = not hasattr(f, "read") + if openfile: + filename = f + f = open(filename, "r") + + # Item 0 -- header + while True: + line = f.readline() + if line[0] != "#": + break + + # Item 1 --NPGNCn MXGNn NGNCNPn MXADJn I2Kn ISYMGNCn IFLALPHAn [NOPRINT] + t = line.strip().split() + imax = 7 + npgncn, mxgnn, numgnc, numalphaj, i2kn, isymgncn, iflalphan = ( + int(t[0]), + int(t[1]), + int(t[2]), + int(t[3]), + int(t[4]), + int(t[5]), + int(t[6]), + ) + + options = [] + if len(t) > imax: + if t[7].lower() == "noprint": + options.append("noprint") + + # Item 2 -- read parameter data + if npgncn > 0: + dt = ModflowUsgGnc.get_empty(npgncn, mxgnn, iflalphan).dtype + # Item 3 -- + pak_parms = mfparbc.load( + f, npgncn, dt, model, ext_unit_dict, model.verbose + ) + + # Item 4 -- read GNC data + gncdata = ModflowUsgGnc.get_empty(numgnc, numalphaj, iflalphan) + + gncdata = ulstrd(f, numgnc, gncdata, model, [], ext_unit_dict) + + gncdata["NodeN"] -= 1 + gncdata["NodeM"] -= 1 + for i in range(numalphaj): + gncdata[f"Node{i:d}"] -= 1 + + if openfile: + f.close() + + # set package unit number + unitnumber = None + filenames = [None] + if ext_unit_dict is not None: + unitnumber, filenames[0] = model.get_ext_dict_attr( + ext_unit_dict, filetype=ModflowUsgGnc._ftype() + ) + + return cls( + model, + numgnc=numgnc, + numalphaj=numalphaj, + i2kn=i2kn, + isymgncn=isymgncn, + iflalphan=iflalphan, + gncdata=gncdata, + options=options, + unitnumber=unitnumber, + filenames=filenames, + ) + + @staticmethod + def _ftype(): + return "GNC" + + @staticmethod + def _defaultunit(): + return 72 diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py new file mode 100644 index 0000000000..e1c6dbbb38 --- /dev/null +++ b/flopy/modflowusg/mfusglpf.py @@ -0,0 +1,863 @@ +""" +mfusglpf module. Contains the ModflowUsgLpf class. Note that the user can access +the ModflowUsgLpf class as `flopy.modflowusg.ModflowUsgLpf`. + +Additional information for this MODFLOW package can be found at the `Online +MODFLOW Guide +`_. + +""" +import numpy as np +from ..modflow.mfpar import ModflowPar as mfpar + +from ..pakbase import Package +from ..utils import Util2d, Util3d, read1d +from ..utils.flopy_io import line_parse + + +class ModflowUsgLpf(Package): + """ + MODFLOW Layer Property Flow Package Class. + + Parameters + ---------- + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to which + this package will be added. + ipakcb : int + A flag that is used to determine if cell-by-cell budget data should be + saved. If ipakcb is non-zero cell-by-cell budget data will be saved. + (default is 0) + hdry : float + Is the head that is assigned to cells that are converted to dry during + a simulation. Although this value plays no role in the model + calculations, it is useful as an indicator when looking at the + resulting heads that are output from the model. HDRY is thus similar + to HNOFLO in the Basic Package, which is the value assigned to cells + that are no-flow cells at the start of a model simulation. + (default is -1.e30). + laytyp : int or array of ints (nlay) + Layer type, contains a flag for each layer that specifies the layer + type. + 0 confined + >0 convertible + <0 convertible unless the THICKSTRT option is in effect. + (default is 0). + layavg : int or array of ints (nlay) + Layer average + 0 is harmonic mean + 1 is logarithmic mean + 2 is arithmetic mean of saturated thickness and logarithmic mean of + of hydraulic conductivity + (default is 0). + chani : float or array of floats (nlay) + contains a value for each layer that is a flag or the horizontal + anisotropy. If CHANI is less than or equal to 0, then variable HANI + defines horizontal anisotropy. If CHANI is greater than 0, then CHANI + is the horizontal anisotropy for the entire layer, and HANI is not + read. If any HANI parameters are used, CHANI for all layers must be + less than or equal to 0. Use as many records as needed to enter a + value of CHANI for each layer. The horizontal anisotropy is the ratio + of the hydraulic conductivity along columns (the Y direction) to the + hydraulic conductivity along rows (the X direction). + (default is 1). + layvka : int or array of ints (nlay) + a flag for each layer that indicates whether variable VKA is vertical + hydraulic conductivity or the ratio of horizontal to vertical + hydraulic conductivity. + 0: VKA is vertical hydraulic conductivity + not 0: VKA is the ratio of horizontal to vertical hydraulic conductivity + (default is 0). + laywet : int or array of ints (nlay) + contains a flag for each layer that indicates if wetting is active. + 0 wetting is inactive + not 0 wetting is active + (default is 0). + wetfct : float + is a factor that is included in the calculation of the head that is + initially established at a cell when it is converted from dry to wet. + (default is 0.1). + iwetit : int + is the iteration interval for attempting to wet cells. Wetting is + attempted every IWETIT iteration. If using the PCG solver + (Hill, 1990), this applies to outer iterations, not inner iterations. + If IWETIT less than or equal to 0, it is changed to 1. + (default is 1). + ihdwet : int + is a flag that determines which equation is used to define the + initial head at cells that become wet. + (default is 0) + ikcflag : int + flag indicating if hydraulic conductivity or transmissivity + information is input for each of the nodes or whether this information + is directly input for the nodal connections. The easiest input format + is to provide the hydraulic conductivity or transmissivity values to + the cells using a zero value for IKCFLAG. + anglex : float or array of floats (njag) + is the angle (in radians) between the horizontal x-axis and the outward + normal to the face between a node and its connecting nodes. The angle + varies between zero and 6.283185 (two pi being 360 degrees). + hk : float or array of floats (nlay, nrow, ncol) + is the hydraulic conductivity along rows. HK is multiplied by + horizontal anisotropy (see CHANI and HANI) to obtain hydraulic + conductivity along columns. + (default is 1.0). + hani : float or array of floats (nlay, nrow, ncol) + is the ratio of hydraulic conductivity along columns to hydraulic + conductivity along rows, where HK of item 10 specifies the hydraulic + conductivity along rows. Thus, the hydraulic conductivity along + columns is the product of the values in HK and HANI. + (default is 1.0). + vka : float or array of floats (nlay, nrow, ncol) + is either vertical hydraulic conductivity or the ratio of horizontal + to vertical hydraulic conductivity depending on the value of LAYVKA. + (default is 1.0). + ss : float or array of floats (nlay, nrow, ncol) + is specific storage unless the STORAGECOEFFICIENT option is used. + When STORAGECOEFFICIENT is used, Ss is confined storage coefficient. + (default is 1.e-5). + sy : float or array of floats (nlay, nrow, ncol) + is specific yield. + (default is 0.15). + vkcb : float or array of floats (nlay, nrow, ncol) + is the vertical hydraulic conductivity of a Quasi-three-dimensional + confining bed below a layer. (default is 0.0). Note that if an array + is passed for vkcb it must be of size (nlay, nrow, ncol) even though + the information for the bottom layer is not needed. + wetdry : float or array of floats (nlay, nrow, ncol) + is a combination of the wetting threshold and a flag to indicate + which neighboring cells can cause a cell to become wet. + (default is -0.01). + ksat : float or array of floats (nrow, ncol) + inter-block saturated hydraulic conductivity or transmissivity + (if IKCFLAG = 1) or the inter-block conductance (if IKCFLAG = - 1) + of the connection between nodes n and m. + storagecoefficient : boolean + indicates that variable Ss and SS parameters are read as storage + coefficient rather than specific storage. + (default is False). + constantcv : boolean + indicates that vertical conductance for an unconfined cell is + computed from the cell thickness rather than the saturated thickness. + The CONSTANTCV option automatically invokes the NOCVCORRECTION + option. (default is False). + thickstrt : boolean + indicates that layers having a negative LAYTYP are confined, and their + cell thickness for conductance calculations will be computed as + STRT-BOT rather than TOP-BOT. (default is False). + nocvcorrection : boolean + indicates that vertical conductance is not corrected when the vertical + flow correction is applied. (default is False). + novfc : boolean + turns off the vertical flow correction under dewatered conditions. + This option turns off the vertical flow calculation described on p. + 5-8 of USGS Techniques and Methods Report 6-A16 and the vertical + conductance correction described on p. 5-18 of that report. + (default is False). + extension : string + Filename extension (default is 'lpf') + unitnumber : int + File unit number (default is None). + filenames : str or list of str + Filenames to use for the package and the output files. If + filenames=None the package name will be created using the model name + and package extension and the cbc output name will be created using + the model name and .cbc extension (for example, modflowtest.cbc), + if ipakcbc is a number greater than zero. If a single string is passed + the package will be set to the string and cbc output name will be + created using the model name and .cbc extension, if ipakcbc is a + number greater than zero. To define the names for all package files + (input and output) the length of the list of strings should be 2. + Default is None. + + + Attributes + ---------- + + Methods + ------- + + See Also + -------- + + Notes + ----- + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflowusg.ModflowUsg() + >>> lpf = flopy.modflowusg.ModflowUsgLpf(m) + + """ + + "Layer-property flow package class\n" + + def __init__( + self, + model, + laytyp=0, + layavg=0, + chani=1.0, + layvka=0, + laywet=0, + ipakcb=None, + hdry=-1e30, + iwdflg=0, + wetfct=0.1, + iwetit=1, + ihdwet=0, + ikcflag=0, + anglex=0, + hk=1.0, + hani=1.0, + vka=1.0, + ss=1e-5, + sy=0.15, + vkcb=0.0, + wetdry=-0.01, + ksat=1.0, + storagecoefficient=False, + constantcv=False, + thickstrt=False, + nocvcorrection=False, + novfc=False, + extension="lpf", + unitnumber=None, + filenames=None, + ): + + # set default unit number of one is not specified + if unitnumber is None: + unitnumber = ModflowUsgLpf._defaultunit() + + # set filenames + if filenames is None: + filenames = [None, None] + elif isinstance(filenames, str): + filenames = [filenames, None] + elif isinstance(filenames, list): + if len(filenames) < 2: + filenames.append(None) + + # update external file information with cbc output, if necessary + if ipakcb is not None: + fname = filenames[1] + model.add_output_file( + ipakcb, fname=fname, package=ModflowUsgLpf._ftype() + ) + else: + ipakcb = 0 + + # Fill namefile items + name = [ModflowUsgLpf._ftype()] + units = [unitnumber] + extra = [""] + + # set package name + fname = [filenames[0]] + + # Call ancestor's init to set self.parent, extension, name and unit number + Package.__init__( + self, + model, + extension=extension, + name=name, + unit_number=units, + extra=extra, + filenames=fname, + ) + + self._generate_heading() + self.url = "lpf.htm" + nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + + dis = model.get_package("DIS") + if dis is None: + dis = model.get_package("DISU") + structured = self.parent.structured + + # item 1 + self.ipakcb = ipakcb + self.hdry = ( + hdry # Head in cells that are converted to dry during a simulation + ) + self.nplpf = 0 # number of LPF parameters + self.ikcflag = ikcflag # unstructured grid + if structured: + self.ikcflag = 0 + self.laytyp = Util2d(model, (nlay,), np.int32, laytyp, name="laytyp") + self.layavg = Util2d(model, (nlay,), np.int32, layavg, name="layavg") + self.chani = Util2d(model, (nlay,), np.float32, chani, name="chani") + self.layvka = Util2d(model, (nlay,), np.int32, layvka, name="layvka") + self.laywet = Util2d(model, (nlay,), np.int32, laywet, name="laywet") + # Factor that is included in the calculation of the head when a cell is + # converted from dry to wet + self.wetfct = wetfct + # Iteration interval for attempting to wet cells + self.iwetit = iwetit + # Flag that determines which equation is used to define the initial + # head at cells that become wet + self.ihdwet = ihdwet + self.options = " " + if storagecoefficient: + self.options = self.options + "STORAGECOEFFICIENT " + if constantcv: + self.options = self.options + "CONSTANTCV " + if thickstrt: + self.options = self.options + "THICKSTRT " + if nocvcorrection: + self.options = self.options + "NOCVCORRECTION " + if novfc: + self.options = self.options + "NOVFC " + + if not structured: + njag = dis.njag + self.anglex = Util2d( + model, + (njag,), + np.float32, + anglex, + "Transmissivity", + locat=self.unit_number[0], + ) + + self.hk = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + hk, + name="hk", + locat=self.unit_number[0], + ) + self.hani = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + hani, + name="hani", + locat=self.unit_number[0], + ) + keys = [] + for k in range(nlay): + key = "vka" + if self.layvka[k] != 0: + key = "vani" + keys.append(key) + self.vka = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + vka, + name=keys, + locat=self.unit_number[0], + ) + tag = "ss" + if storagecoefficient: + tag = "storage" + self.ss = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + ss, + name=tag, + locat=self.unit_number[0], + ) + self.sy = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + sy, + name="sy", + locat=self.unit_number[0], + ) + self.vkcb = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + vkcb, + name="vkcb", + locat=self.unit_number[0], + ) + self.wetdry = Util3d( + model, + (nlay, nrow, ncol), + np.float32, + wetdry, + name="wetdry", + locat=self.unit_number[0], + ) + + if not structured: + njag = dis.njag + self.ksat = Util2d( + model, + (njag,), + np.float32, + ksat, + "saturated conductivity or transmissivity", + locat=self.unit_number[0], + ) + + self.parent.add_package(self) + return + + def write_file(self, check=True, f=None): + """ + Write the package file. + + Parameters + ---------- + check : boolean + Check package data for common errors. (default True) + + Returns + ------- + None + + """ + # allows turning off package checks when writing files at model level + if check: + self.check( + f=f"{self.name[0]}.chk", + verbose=self.parent.verbose, + level=1, + ) + + # get model information + nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + dis = self.parent.get_package("DIS") + if dis is None: + dis = self.parent.get_package("DISU") + + # Open file for writing + if f is None: + f = open(self.fn_path, "w") + + # Item 0: text + f.write(f"{self.heading}\n") + + # Item 1: IBCFCB, HDRY, NPLPF, , OPTIONS + if self.parent.version == "mfusg" and self.parent.structured == False: + f.write( + ( + f" {self.ipakcb:9d} {self.hdry:9.5G} {self.nplpf:9d}" + f" {self.ikcflag:9d} {self.options:s}\n" + ) + ) + else: + f.write( + f" {self.ipakcb:9d} {self.hdry:9.5G} {self.nplpf:9d} {self.options}\n" + ) + # LAYTYP array + f.write(self.laytyp.string) + # LAYAVG array + f.write(self.layavg.string) + # CHANI array + f.write(self.chani.string) + # LAYVKA array + f.write(self.layvka.string) + # LAYWET array + f.write(self.laywet.string) + # Item 7: WETFCT, IWETIT, IHDWET + iwetdry = self.laywet.sum() + if iwetdry > 0: + f.write(f"{self.wetfct:10f}{self.iwetit:10d}{self.ihdwet:10d}\n") + + transient = not dis.steady.all() + structured = self.parent.structured + anis = False + for k in range(nlay): + if self.chani[k] != 1: + anis = True + break + if (not structured) and anis: + f.write(self.anglex.get_file_entry()) + + for k in range(nlay): + if self.ikcflag == 0: ## mfusg + f.write(self.hk[k].get_file_entry()) + if self.chani[k] <= 0.0: + f.write(self.hani[k].get_file_entry()) + f.write(self.vka[k].get_file_entry()) + + if transient == True: + f.write(self.ss[k].get_file_entry()) + if self.laytyp[k] != 0: + f.write(self.sy[k].get_file_entry()) + if self.ikcflag == 0 and dis.laycbd[k] > 0: + f.write(self.vkcb[k].get_file_entry()) + if self.laywet[k] != 0 and self.laytyp[k] != 0: + f.write(self.wetdry[k].get_file_entry()) + + if self.ikcflag == 1 or self.ikcflag == -1: + f_bcf.write(self.ksat[k].get_file_entry()) + + f.close() + return + + @classmethod + def load(cls, f, model, ext_unit_dict=None, check=True): + """ + Load an existing package. + + Parameters + ---------- + f : filename or file handle + File to load. + model : model object + The model object (of type :class:`flopy.modflowusg.ModflowUsg`) to + which this package will be added. + ext_unit_dict : dictionary, optional + If the arrays in the file are specified using EXTERNAL, + or older style array control records, then `f` should be a file + handle. In this case ext_unit_dict is required, which can be + constructed using the function + :class:`flopy.utils.mfreadnam.parsenamefile`. + check : boolean + Check package data for common errors. (default True) + + Returns + ------- + lpf : ModflowUsgLpf object + ModflowUsgLpf object. + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflowusg.ModflowUsg() + >>> lpf = flopy.modflowusg.ModflowUsgLpf.load('test.lpf', m) + + """ + + if model.verbose: + print("loading lpf package file...") + + openfile = not hasattr(f, "read") + if openfile: + filename = f + f = open(filename, "r") + + # dataset 0 -- header + while True: + line = f.readline() + if line[0] != "#": + break + + # determine problem dimensions + nr, nc, nlay, nper = model.get_nrow_ncol_nlay_nper() + dis = model.get_package("DIS") + if dis is None: + dis = model.get_package("DISU") + njag = dis.njag + + # Item 1: IBCFCB, HDRY, NPLPF - line already read above + if model.verbose: + print(" loading IBCFCB, HDRY, NPLPF...") + t = line_parse(line) + ipakcb, hdry, nplpf = int(t[0]), float(t[1]), int(t[2]) + item1_len = 3 + if model.structured == False: + ikcflag = int(t[3]) + item1_len = 4 + else: + ikcflag = 0 + + storagecoefficient = False + constantcv = False + thickstrt = False + nocvcorrection = False + novfc = False + if len(t) > item1_len: + for k in range(item1_len, len(t)): + if "STORAGECOEFFICIENT" in t[k].upper(): + storagecoefficient = True + if "CONSTANTCV" in t[k].upper(): + constantcv = True + if "THICKSTRT" in t[k].upper(): + thickstrt = True + if "NOCVCORRECTION" in t[k].upper(): + nocvcorrection = True + if "NOVFC" in t[k].upper(): + novfc = True + + # LAYTYP array + if model.verbose: + print(" loading LAYTYP...") + laytyp = np.empty((nlay), dtype=np.int32) + laytyp = read1d(f, laytyp) + + # LAYAVG array + if model.verbose: + print(" loading LAYAVG...") + layavg = np.empty((nlay), dtype=np.int32) + layavg = read1d(f, layavg) + + # CHANI array + if model.verbose: + print(" loading CHANI...") + chani = np.empty((nlay), dtype=np.float32) + chani = read1d(f, chani) + + # LAYVKA array + if model.verbose: + print(" loading LAYVKA...") + layvka = np.empty((nlay,), dtype=np.int32) + layvka = read1d(f, layvka) + + # LAYWET array + if model.verbose: + print(" loading LAYWET...") + laywet = np.empty((nlay), dtype=np.int32) + laywet = read1d(f, laywet) + + # Item 7: WETFCT, IWETIT, IHDWET + wetfct, iwetit, ihdwet = None, None, None + iwetdry = laywet.sum() + if iwetdry > 0: + if model.verbose: + print(" loading WETFCT, IWETIT, IHDWET...") + line = f.readline() + t = line.strip().split() + wetfct, iwetit, ihdwet = float(t[0]), int(t[1]), int(t[2]) + + # parameters data + par_types = [] + if nplpf > 0: + par_types, parm_dict = mfpar.load(f, nplpf, model.verbose) + # print parm_dict + + # ANGLEX for unstructured grid with anisotropy + anis = False + for k in range(nlay): + if chani[k] != 1: + anis = True + break + if (not model.structured) and anis: + if model.verbose: + print("mfusg: loading ANGLEX...") + t = Util2d.load( + f, model, (njag,), np.float32, "anglex", ext_unit_dict + ) + anglex = t + else: + anglex = 0 + + # non-parameter data + transient = not dis.steady.all() + hk = [0] * nlay + hani = [0] * nlay + vka = [0] * nlay + ss = [0] * nlay + sy = [0] * nlay + vkcb = [0] * nlay + wetdry = [0] * nlay + + # load by layer + for k in range(nlay): + + # allow for unstructured changing nodes per layer + if nr is None: + nrow = 1 + ncol = nc[k] + else: + nrow = nr + ncol = nc + + if ikcflag == 0: + # hk + if model.verbose: + print(f" loading hk layer {k + 1:3d}...") + if "hk" not in par_types: + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "hk", ext_unit_dict + ) + else: + line = f.readline() + t = mfpar.parameter_fill( + model, (nrow, ncol), "hk", parm_dict, findlayer=k + ) + hk[k] = t + + # hani + if chani[k] <= 0.0: + if model.verbose: + print(f" loading hani layer {k + 1:3d}...") + if "hani" not in par_types: + t = Util2d.load( + f, + model, + (nrow, ncol), + np.float32, + "hani", + ext_unit_dict, + ) + else: + line = f.readline() + t = mfpar.parameter_fill( + model, (nrow, ncol), "hani", parm_dict, findlayer=k + ) + hani[k] = t + + # vka + if model.verbose: + print(f" loading vka layer {k + 1:3d}...") + key = "vk" + if layvka[k] != 0: + key = "vani" + if "vk" not in par_types and "vani" not in par_types: + t = Util2d.load( + f, model, (nrow, ncol), np.float32, key, ext_unit_dict + ) + else: + line = f.readline() + key = "vk" + if "vani" in par_types: + key = "vani" + t = mfpar.parameter_fill( + model, (nrow, ncol), key, parm_dict, findlayer=k + ) + vka[k] = t + + # storage properties + if transient: + + # ss + if model.verbose: + print(f" loading ss layer {k + 1:3d}...") + if "ss" not in par_types: + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "ss", ext_unit_dict + ) + else: + line = f.readline() + t = mfpar.parameter_fill( + model, (nrow, ncol), "ss", parm_dict, findlayer=k + ) + ss[k] = t + + # sy + if laytyp[k] != 0: + if model.verbose: + print(f" loading sy layer {k + 1:3d}...") + if "sy" not in par_types: + t = Util2d.load( + f, + model, + (nrow, ncol), + np.float32, + "sy", + ext_unit_dict, + ) + else: + line = f.readline() + t = mfpar.parameter_fill( + model, (nrow, ncol), "sy", parm_dict, findlayer=k + ) + sy[k] = t + + # vkcb + if ikcflag == 0 and dis.laycbd[k] != 0: + if model.verbose: + print(f" loading vkcb layer {k + 1:3d}...") + if "vkcb" not in par_types: + t = Util2d.load( + f, + model, + (nrow, ncol), + np.float32, + "vkcb", + ext_unit_dict, + ) + else: + line = f.readline() + t = mfpar.parameter_fill( + model, (nrow, ncol), "vkcb", parm_dict, findlayer=k + ) + vkcb[k] = t + + # wetdry + if laywet[k] != 0 and laytyp[k] != 0 and laytyp[k] != 4: + if model.verbose: + print(f" loading wetdry layer {k + 1:3d}...") + t = Util2d.load( + f, model, (nrow, ncol), np.float32, "wetdry", ext_unit_dict + ) + wetdry[k] = t + + # Ksat mfusg + if ikcflag == 1 or ikcflag == -1: + if model.verbose: + print(f" loading ksat layer {k + 1:3d}...") + t = Util2d.load( + f, model, (njag,), np.float32, "ksat", ext_unit_dict + ) + ksat = t + else: + ksat = 1.0 + + if openfile: + f.close() + + # set package unit number + unitnumber = None + filenames = [None, None] + if ext_unit_dict is not None: + unitnumber, filenames[0] = model.get_ext_dict_attr( + ext_unit_dict, filetype=ModflowUsgLpf._ftype() + ) + if ipakcb > 0: + iu, filenames[1] = model.get_ext_dict_attr( + ext_unit_dict, unit=ipakcb + ) + model.add_pop_key_list(ipakcb) + + # create instance of lpf class + lpf = cls( + model, + ipakcb=ipakcb, + laytyp=laytyp, + layavg=layavg, + chani=chani, + layvka=layvka, + laywet=laywet, + hdry=hdry, + iwdflg=iwetdry, + wetfct=wetfct, + iwetit=iwetit, + ihdwet=ihdwet, + ikcflag=ikcflag, + anglex=anglex, + hk=hk, + hani=hani, + vka=vka, + ss=ss, + sy=sy, + vkcb=vkcb, + wetdry=wetdry, + ksat=ksat, + storagecoefficient=storagecoefficient, + constantcv=constantcv, + thickstrt=thickstrt, + novfc=novfc, + nocvcorrection=nocvcorrection, + unitnumber=unitnumber, + filenames=filenames, + ) + if check: + lpf.check( + f=f"{lpf.name[0]}.chk", + verbose=lpf.parent.verbose, + level=0, + ) + return lpf + + @staticmethod + def _ftype(): + return "LPF" + + @staticmethod + def _defaultunit(): + return 15 diff --git a/flopy/modflowusg/mfusgsms.py b/flopy/modflowusg/mfusgsms.py new file mode 100644 index 0000000000..85b844762c --- /dev/null +++ b/flopy/modflowusg/mfusgsms.py @@ -0,0 +1,652 @@ +""" +mfusgsms module. This is the solver for MODFLOW-USG. +Contains the ModflowUsgSms class. Note that the user can access +the ModflowUsgSms class as `flopy.modflowusg.ModflowUsgSms`. + + +""" +from ..pakbase import Package +from ..utils.flopy_io import line_parse + +class ModflowUsgSms(Package): + """ + MODFLOW Sms Package Class. + + Parameters + ---------- + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to which + this package will be added. + hclose : float + is the head change criterion for convergence of the outer (nonlinear) + iterations, in units of length. When the maximum absolute value of the + head change at all nodes during an iteration is less than or equal to + HCLOSE, iteration stops. Commonly, HCLOSE equals 0.01. + hiclose : float + is the head change criterion for convergence of the inner (linear) + iterations, in units of length. When the maximum absolute value of the + head change at all nodes during an iteration is less than or equal to + HICLOSE, the matrix solver assumes convergence. Commonly, HICLOSE is + set an order of magnitude less than HCLOSE. + mxiter : int + is the maximum number of outer (nonlinear) iterations -- that is, + calls to the solution routine. For a linear problem MXITER should be 1. + iter1 : int + is the maximum number of inner (linear) iterations. The number + typically depends on the characteristics of the matrix solution + scheme being used. For nonlinear problems, ITER1 usually ranges + from 60 to 600; a value of 100 will be sufficient for most linear + problems. + iprsms : int + is a flag that controls printing of convergence information from the + solver: 0 is print nothing; 1 is print only the total number of + iterations and nonlinear residual reduction summaries; 2 is print + matrix solver information in addition to above. + nonlinmeth : int + is a flag that controls the nonlinear solution method and under- + relaxation schemes. 0 is Picard iteration scheme is used without any + under-relaxation schemes involved. > 0 is Newton-Raphson iteration + scheme is used with under-relaxation. Note that the Newton-Raphson + linearization scheme is available only for the upstream weighted + solution scheme of the BCF and LPF packages. < 0 is Picard iteration + scheme is used with under-relaxation. The absolute value of NONLINMETH + determines the underrelaxation scheme used. 1 or -1, then + Delta-Bar-Delta under-relaxation is used. 2 or -2 then Cooley + under-relaxation scheme is used. + Note that the under-relaxation schemes are used in conjunction with + gradient based methods, however, experience has indicated that the + Cooley under-relaxation and damping work well also for the Picard + scheme with the wet/dry options of MODFLOW. + linmeth : int + is a flag that controls the matrix solution method. 1 is the XMD + solver of Ibaraki (2005). 2 is the unstructured pre-conditioned + conjugate gradient solver of White and Hughes (2011). + theta : float + is the reduction factor for the learning rate (under-relaxation term) + of the delta-bar-delta algorithm. The value of THETA is between zero + and one. If the change in the variable (head) is of opposite sign to + that of the previous iteration, the under-relaxation term is reduced + by a factor of THETA. The value usually ranges from 0.3 to 0.9; a + value of 0.7 works well for most problems. + akappa : float + is the increment for the learning rate (under-relaxation term) of the + delta-bar-delta algorithm. The value of AKAPPA is between zero and + one. If the change in the variable (head) is of the same sign to that + of the previous iteration, the under-relaxation term is increased by + an increment of AKAPPA. The value usually ranges from 0.03 to 0.3; a + value of 0.1 works well for most problems. + gamma : float + is the history or memory term factor of the delta-bar-delta algorithm. + Gamma is between zero and 1 but cannot be equal to one. When GAMMA is + zero, only the most recent history (previous iteration value) is + maintained. As GAMMA is increased, past history of iteration changes + has greater influence on the memory term. The memory term is + maintained as an exponential average of past changes. Retaining some + past history can overcome granular behavior in the calculated function + surface and therefore helps to overcome cyclic patterns of + non-convergence. The value usually ranges from 0.1 to 0.3; a value of + 0.2 works well for most problems. + amomentum : float + is the fraction of past history changes that is added as a momentum + term to the step change for a nonlinear iteration. The value of + AMOMENTUM is between zero and one. A large momentum term should only + be used when small learning rates are expected. Small amounts of the + momentum term help convergence. The value usually ranges from 0.0001 + to 0.1; a value of 0.001 works well for most problems. + numtrack : int + is the maximum number of backtracking iterations allowed for residual + reduction computations. If NUMTRACK = 0 then the backtracking + iterations are omitted. The value usually ranges from 2 to 20; a + value of 10 works well for most problems. + numtrack : int + is the maximum number of backtracking iterations allowed for residual + reduction computations. If NUMTRACK = 0 then the backtracking + iterations are omitted. The value usually ranges from 2 to 20; a + value of 10 works well for most problems. + btol : float + is the tolerance for residual change that is allowed for residual + reduction computations. BTOL should not be less than one to avoid + getting stuck in local minima. A large value serves to check for + extreme residual increases, while a low value serves to control + step size more severely. The value usually ranges from 1.0 to 1e6 ; a + value of 1e4 works well for most problems but lower values like 1.1 + may be required for harder problems. + breduce : float + is the reduction in step size used for residual reduction + computations. The value of BREDUC is between zero and one. The value + usually ranges from 0.1 to 0.3; a value of 0.2 works well for most + problems. + reslim : float + is the limit to which the residual is reduced with backtracking. + If the residual is smaller than RESLIM, then further backtracking is + not performed. A value of 100 is suitable for large problems and + residual reduction to smaller values may only slow down computations. + iacl : int + is the flag for choosing the acceleration method. 0 is Conjugate + Gradient; select this option if the matrix is symmetric. 1 is + ORTHOMIN. 2 is BiCGSTAB. + norder : int + is the flag for choosing the ordering scheme. + 0 is original ordering + 1 is reverse Cuthill McKee ordering + 2 is Minimum degree ordering + level : int + is the level of fill for ILU decomposition. Higher levels of fill + provide more robustness but also require more memory. For optimal + performance, it is suggested that a large level of fill be applied + (7 or 8) with use of drop tolerance. + north : int + is the number of orthogonalizations for the ORTHOMIN acceleration + scheme. A number between 4 and 10 is appropriate. Small values require + less storage but more iteration may be required. This number should + equal 2 for the other acceleration methods. + iredsys : int + is the index for creating a reduced system of equations using the + red-black ordering scheme. + 0 is do not create reduced system + 1 is create reduced system using red-black ordering + rrctol : float + is a residual tolerance criterion for convergence. The root mean + squared residual of the matrix solution is evaluated against this + number to determine convergence. The solver assumes convergence if + either HICLOSE (the absolute head tolerance value for the solver) or + RRCTOL is achieved. Note that a value of zero ignores residual + tolerance in favor of the absolute tolerance (HICLOSE) for closure of + the matrix solver. + idroptol : int + is the flag to perform drop tolerance. + 0 is do not perform drop tolerance + 1 is perform drop tolerance + epsrn : float + is the drop tolerance value. A value of 1e-3 works well for most + problems. + clin : string + an option keyword that defines the linear acceleration method used by + the PCGU solver. + CLIN is "CG", then preconditioned conjugate gradient method. + CLIN is "BCGS", then preconditioned bi-conjugate gradient stabilized + method. + ipc : int + an integer value that defines the preconditioner. + IPC = 0, No preconditioning. + IPC = 1, Jacobi preconditioning. + IPC = 2, ILU(0) preconditioning. + IPC = 3, MILU(0) preconditioning (default). + iscl : int + is the flag for choosing the matrix scaling approach used. + 0 is no matrix scaling applied + 1 is symmetric matrix scaling using the scaling method by the POLCG + preconditioner in Hill (1992). + 2 is symmetric matrix scaling using the l2 norm of each row of + A (DR) and the l2 norm of each row of DRA. + iord : int + is the flag for choosing the matrix reordering approach used. + 0 = original ordering + 1 = reverse Cuthill McKee ordering + 2 = minimum degree ordering + rclosepcgu : float + a real value that defines the flow residual tolerance for convergence + of the PCGU linear solver. This value represents the maximum allowable + residual at any single node. Value is in units of length cubed per + time, and must be consistent with MODFLOW-USG length and time units. + Usually a value of 1.0x10-1 is sufficient for the flow-residual + criteria when meters and seconds are the defined MODFLOW-USG length + and time. + relaxpcgu : float + a real value that defines the relaxation factor used by the MILU(0) + preconditioner. RELAXPCGU is unitless and should be greater than or + equal to 0.0 and less than or equal to 1.0. RELAXPCGU values of about + 1.0 are commonly used, and experience suggests that convergence can + be optimized in some cases with RELAXPCGU values of 0.97. A RELAXPCGU + value of 0.0 will result in ILU(0) preconditioning. RELAXPCGU is only + specified if IPC=3. If RELAXPCGU is not specified and IPC=3, then a + default value of 0.97 will be assigned to RELAXPCGU. + extension : str, optional + File extension (default is 'sms'. + unitnumber : int, optional + FORTRAN unit number for this package (default is None). + filenames : str or list of str + Filenames to use for the package. If filenames=None the package name + will be created using the model name and package extension. If a + single string is passed the package will be set to the string. + Default is None. + + Attributes + ---------- + + Methods + ------- + + See Also + -------- + + Notes + ----- + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflow.Modflow() + >>> sms = flopy.modflowusg.ModflowUsgSms(m) + + """ + + def __init__( + self, + model, + hclose=1e-4, + hiclose=1e-4, + mxiter=100, + iter1=20, + iprsms=2, + nonlinmeth=0, + linmeth=2, + theta=0.7, + akappa=0.1, + gamma=0.2, + amomentum=0.001, + numtrack=20, + btol=1e4, + breduc=0.2, + reslim=100.0, + iacl=2, + norder=0, + level=7, + north=2, + iredsys=0, + rrctol=0.0, + idroptol=0, + epsrn=1.0e-3, + clin="bcgs", + ipc=3, + iscl=0, + iord=0, + rclosepcgu=0.1, + relaxpcgu=1.0, + extension="sms", + options=None, + unitnumber=None, + filenames=None, + ): + # set default unit number of one is not specified + if unitnumber is None: + unitnumber = ModflowUsgSms._defaultunit() + + # set filenames + if filenames is None: + filenames = [None] + elif isinstance(filenames, str): + filenames = [filenames] + + # Fill namefile items + name = [ModflowUsgSms._ftype()] + units = [unitnumber] + extra = [""] + + # set package name + fname = [filenames[0]] + + # Call ancestor's init to set self.parent, extension, name and + # unit number + Package.__init__( + self, + model, + extension=extension, + name=name, + unit_number=units, + extra=extra, + filenames=fname, + ) + + self._generate_heading() + self.url = " " + self.hclose = hclose + self.hiclose = hiclose + self.mxiter = mxiter + self.iter1 = iter1 + self.iprsms = iprsms + self.nonlinmeth = nonlinmeth + self.linmeth = linmeth + self.theta = theta + self.akappa = akappa + self.gamma = gamma + self.amomentum = amomentum + self.numtrack = numtrack + self.btol = btol + self.breduc = breduc + self.reslim = reslim + self.iacl = iacl + self.norder = norder + self.level = level + self.north = north + self.iredsys = iredsys + self.rrctol = rrctol + self.idroptol = idroptol + self.epsrn = epsrn + self.clin = clin + self.ipc = ipc + self.iscl = iscl + self.iord = iord + self.rclosepcgu = rclosepcgu + self.relaxpcgu = relaxpcgu + if options is None: + self.options = [] + else: + if not isinstance(options, list): + options = [options] + self.options = options + self.parent.add_package(self) + return + + def write_file(self): + """ + Write the package file. + + Returns + ------- + None + + """ + f = open(self.fn_path, "w") + f.write(f"{self.heading}\n") + nopt = len(self.options) + if nopt > 0: + f.write(" ".join(self.options) + "\n") + f.write( + "{0} {1} {2} {3} {4} {5} {6}\n".format( + self.hclose, + self.hiclose, + self.mxiter, + self.iter1, + self.iprsms, + self.nonlinmeth, + self.linmeth, + ) + ) + if self.nonlinmeth != 0 and nopt == 0: + f.write( + "{0} {1} {2} {3} {4} {5} {6} {7}\n".format( + self.theta, + self.akappa, + self.gamma, + self.amomentum, + self.numtrack, + self.btol, + self.breduc, + self.reslim, + ) + ) + if self.linmeth == 1 and nopt == 0: + f.write( + "{0} {1} {2} {3} {4} {5} {6} {7}\n".format( + self.iacl, + self.norder, + self.level, + self.north, + self.iredsys, + self.rrctol, + self.idroptol, + self.epsrn, + ) + ) + if self.linmeth == 2 and nopt == 0: + f.write( + "{0} {1} {2} {3} {4} {5}\n".format( + self.clin, + self.ipc, + self.iscl, + self.iord, + self.rclosepcgu, + self.relaxpcgu, + ) + ) + f.write("\n") + f.close() + + @classmethod + def load(cls, f, model, ext_unit_dict=None): + """ + Load an existing package. + + Parameters + ---------- + f : filename or file handle + File to load. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + ext_unit_dict : dictionary, optional + If the arrays in the file are specified using EXTERNAL, + or older style array control records, then `f` should be a file + handle. In this case ext_unit_dict is required, which can be + constructed using the function + :class:`flopy.utils.mfreadnam.parsenamefile`. + + Returns + ------- + sms : ModflowUsgSms object + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflow.Modflow() + >>> sms = flopy.modflow.ModflowPcg.load('test.sms', m) + + """ + + if model.verbose: + print("loading sms package file...") + + if model.version != "mfusg": + print( + "Warning: model version was reset from '{}' to 'mfusg' " + "in order to load a SMS file".format(model.version) + ) + model.version = "mfusg" + + openfile = not hasattr(f, "read") + if openfile: + filename = f + f = open(filename, "r") + + # dataset 0 -- header + while True: + line = f.readline() + if line[0] != "#": + break + + # Record 1a + opts = ["simple", "moderate", "complex"] + options = [] + firstentry = line.strip().split()[0] + if firstentry.lower() in opts: + options.append(firstentry) + nopt = len(options) + + if nopt > 0: + line = f.readline() + + # Record 1b -- line will have already been read + if model.verbose: + print( + " loading HCLOSE HICLOSE MXITER ITER1 " + "IPRSMS NONLINMETH LINMETH..." + ) + ll = line_parse(line) + hclose = float(ll.pop(0)) + hiclose = float(ll.pop(0)) + mxiter = int(ll.pop(0)) + iter1 = int(ll.pop(0)) + iprsms = int(ll.pop(0)) + nonlinmeth = int(ll.pop(0)) + linmeth = int(ll.pop(0)) + if model.verbose: + print(f" HCLOSE {hclose}") + print(f" HICLOSE {hiclose}") + print(f" MXITER {mxiter}") + print(f" ITER1 {iter1}") + print(f" IPRSMS {iprsms}") + print(f" NONLINMETH {nonlinmeth}") + print(f" LINMETH {linmeth}") + + # Record 2 + theta = None + akappa = None + gamma = None + amomentum = None + numtrack = None + btol = None + breduc = None + reslim = None + if nonlinmeth != 0 and nopt == 0: + if model.verbose: + print( + " loading THETA AKAPPA GAMMA AMOMENTUM " + "NUMTRACK BTOL BREDUC RESLIM..." + ) + while True: + line = f.readline() + if line[0] != "#": + break + ll = line_parse(line) + theta = float(ll.pop(0)) + akappa = float(ll.pop(0)) + gamma = float(ll.pop(0)) + amomentum = float(ll.pop(0)) + numtrack = int(ll.pop(0)) + btol = float(ll.pop(0)) + breduc = float(ll.pop(0)) + reslim = float(ll.pop(0)) + if model.verbose: + print(f" THETA {theta}") + print(f" AKAPPA {akappa}") + print(f" GAMMA {gamma}") + print(f" AMOMENTUM {amomentum}") + print(f" NUMTRACK {numtrack}") + print(f" BTOL {btol}") + print(f" BREDUC {breduc}") + print(f" RESLIM {reslim}") + + iacl = None + norder = None + level = None + north = None + iredsys = None + rrctol = None + idroptol = None + epsrn = None + if linmeth == 1 and nopt == 0: + if model.verbose: + print( + " loading IACL NORDER LEVEL NORTH " + "IREDSYS RRCTOL IDROPTOL EPSRN" + ) + while True: + line = f.readline() + if line[0] != "#": + break + ll = line_parse(line) + iacl = int(ll.pop(0)) + norder = int(ll.pop(0)) + level = int(ll.pop(0)) + north = int(ll.pop(0)) + iredsys = int(ll.pop(0)) + rrctol = float(ll.pop(0)) + idroptol = int(ll.pop(0)) + epsrn = float(ll.pop(0)) + if model.verbose: + print(f" IACL {iacl}") + print(f" NORDER {norder}") + print(f" LEVEL {level}") + print(f" NORTH {north}") + print(f" IREDSYS {iredsys}") + print(f" RRCTOL {rrctol}") + print(f" IDROPTOL {idroptol}") + print(f" EPSRN {epsrn}") + + clin = None + ipc = None + iscl = None + iord = None + rclosepcgu = None + relaxpcgu = None + if linmeth == 2 and nopt == 0: + if model.verbose: + print(" loading [CLIN] IPC ISCL IORD RCLOSEPCGU [RELAXPCGU]") + while True: + line = f.readline() + if line[0] != "#": + break + ll = line_parse(line) + if "cg" in line.lower(): # this will get cg or bcgs + clin = ll.pop(0) + ipc = int(ll.pop(0)) + iscl = int(ll.pop(0)) + iord = int(ll.pop(0)) + rclosepcgu = float(ll.pop(0)) + if len(ll) > 0: + relaxpcgu = float(ll.pop(0)) + if model.verbose: + print(f" CLIN {clin}") + print(f" IPC {ipc}") + print(f" ISCL {iscl}") + print(f" IORD {iord}") + print(f" RCLOSEPCGU {rclosepcgu}") + print(f" RELAXPCGU {relaxpcgu}") + + if openfile: + f.close() + + # set package unit number + unitnumber = None + filenames = [None] + if ext_unit_dict is not None: + unitnumber, filenames[0] = model.get_ext_dict_attr( + ext_unit_dict, filetype=ModflowUsgSms._ftype() + ) + + return cls( + model, + hclose=hclose, + hiclose=hiclose, + mxiter=mxiter, + iter1=iter1, + iprsms=iprsms, + nonlinmeth=nonlinmeth, + linmeth=linmeth, + theta=theta, + akappa=akappa, + gamma=gamma, + amomentum=amomentum, + numtrack=numtrack, + btol=btol, + breduc=breduc, + reslim=reslim, + iacl=iacl, + norder=norder, + level=level, + north=north, + iredsys=iredsys, + rrctol=rrctol, + idroptol=idroptol, + epsrn=epsrn, + clin=clin, + ipc=ipc, + iscl=iscl, + iord=iord, + rclosepcgu=rclosepcgu, + options=options, + relaxpcgu=relaxpcgu, + unitnumber=unitnumber, + filenames=filenames, + ) + + @staticmethod + def _ftype(): + return "SMS" + + @staticmethod + def _defaultunit(): + return 32 diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py new file mode 100644 index 0000000000..eb7bb6ba4e --- /dev/null +++ b/flopy/modflowusg/mfusgwel.py @@ -0,0 +1,721 @@ +""" +mfusgwel module. Contains the ModflowUsgWel class. Note that the user can access +the ModflowUsgWel class as `flopy.modflowusg.ModflowUsgWel`. + +Additional information for this MODFLOW package can be found at the `Online +MODFLOW Guide +`_. + +""" +import numpy as np +from ..utils import MfList +from ..pakbase import Package +from ..utils.recarray_utils import create_empty_recarray +from ..utils.flopy_io import ulstrd +import warnings + +from ..modflow.mfparbc import ModflowParBc as mfparbc + + +class ModflowUsgWel(Package): + """ + MODFLOW Well Package Class. + + Parameters + ---------- + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to which + this package will be added. + ipakcb : int + A flag that is used to determine if cell-by-cell budget data should be + saved. If ipakcb is non-zero cell-by-cell budget data will be saved. + (default is 0). + stress_period_data : list of boundaries, or recarray of boundaries, or + dictionary of boundaries + For structured grid, each well is defined through definition of + layer (int), row (int), column (int), flux (float). + The simplest form is a dictionary with a lists of boundaries for each + stress period, where each list of boundaries itself is a list of + boundaries. Indices of the dictionary are the numbers of the stress + period. This gives the form of: + + stress_period_data = + {0: [ + [lay, row, col, flux], + [lay, row, col, flux], + [lay, row, col, flux] + ], + 1: [ + [lay, row, col, flux], + [lay, row, col, flux], + [lay, row, col, flux] + ], ... + kper: + [ + [lay, row, col, flux], + [lay, row, col, flux], + [lay, row, col, flux] + ] + } + + For unstructured grid, + stress_period_data = + {0: [ + [node, flux], + [node, flux], + [node, flux] + ], + 1: [ + [node, flux], + [node, flux], + [node, flux] + ], ... + kper: + [ + [node, flux], + [node, flux], + [node, flux] + ] + } + + Note that if the number of lists is smaller than the number of stress + periods, then the last list of wells will apply until the end of the + simulation. Full details of all options to specify stress_period_data + can be found in the flopy3 boundaries Notebook in the basic + subdirectory of the examples directory + cln_stress_period_data : list of boundaries, or recarray of boundaries, or + dictionary of boundaries + Stress period data of wells simulated as Connected Linear Network (CLN) + The simplest form is a dictionary with a lists of boundaries for each + stress period, where each list of boundaries itself is a list of + boundaries. Indices of the dictionary are the numbers of the stress + period. This gives the form of: + + cln_stress_period_data = + {0: [ + [iclnnode, flux], + [iclnnode, flux], + [iclnnode, flux] + ], + 1: [ + [iclnnode, flux], + [iclnnode, flux], + [iclnnode, flux] + ], ... + kper: + [ + [iclnnode, flux], + [iclnnode, flux], + [iclnnode, flux] + ] + } + extension : string + Filename extension (default is 'wel') + options : list of strings + Package options (default is None). + unitnumber : int + File unit number (default is None). + filenames : str or list of str + Filenames to use for the package and the output files. If + filenames=None the package name will be created using the model name + and package extension and the cbc output name will be created using + the model name and .cbc extension (for example, modflowtest.cbc), + if ipakcbc is a number greater than zero. If a single string is passed + the package will be set to the string and cbc output names will be + created using the model name and .cbc extension, if ipakcbc is a + number greater than zero. To define the names for all package files + (input and output) the length of the list of strings should be 2. + Default is None. + + Attributes + ---------- + mxactw : int + Maximum number of wells for a stress period. This is calculated + automatically by FloPy based on the information in + stress_period_data. + + Methods + ------- + + See Also + -------- + + Notes + ----- + Parameters are not supported in FloPy. + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflow.Modflow() + >>> lrcq = {0:[[2, 3, 4, -100.]], 1:[[2, 3, 4, -100.]]} + >>> wel = flopy.modflowusg.ModflowUsgWel(m, stress_period_data=lrcq) + + """ + + def __init__( + self, + model, + ipakcb=None, + stress_period_data=None, + cln_stress_period_data=None, + extension="wel", + options=None, + binary=False, + unitnumber=None, + filenames=None, + ): + """ + Package constructor. + + """ + # set default unit number of one is not specified + if unitnumber is None: + unitnumber = ModflowUsgWel._defaultunit() + + # set filenames + if filenames is None: + filenames = [None, None, None] + elif isinstance(filenames, str): + filenames = [filenames, None, None] + elif isinstance(filenames, list): + if len(filenames) < 3: + for idx in range(len(filenames), 3): + filenames.append(None) + + # update external file information with cbc output, if necessary + if ipakcb is not None: + fname = filenames[1] + model.add_output_file( + ipakcb, fname=fname, package=ModflowUsgWel._ftype() + ) + else: + ipakcb = 0 + + # Fill namefile items + name = [ModflowUsgWel._ftype()] + units = [unitnumber] + extra = [""] + + # set package name + fname = [filenames[0]] + + # Call ancestor's init to set self.parent, extension, name and + # unit number + Package.__init__( + self, + model, + extension=extension, + name=name, + unit_number=units, + extra=extra, + filenames=fname, + ) + + self._generate_heading() + self.url = "wel.htm" + + self.ipakcb = ipakcb + + if options is None: + options = [] + + self.autoflowreduce = False + self.iunitafr = 0 + + self.options = options + for idx, opt in enumerate(options): + if "autoflowreduce" in opt: + self.autoflowreduce = True + if "iunitafr" in opt: + t = opt.strip().split() + self.iunitafr = int(t[1]) + + if self.iunitafr > 0: + fname = filenames[2] + model.add_output_file( + self.iunitafr, + fname=fname, + extension="afr", + binflag=False, + package=ModflowUsgWel._ftype(), + ) + + # initialize MfList + self.dtype = ModflowUsgWel.get_default_dtype(model.structured) + self.stress_period_data = MfList( + self, stress_period_data, binary=binary + ) + + self.dtype = ModflowUsgWel.get_default_dtype(structured=False) + self.cln_stress_period_data = MfList( + self, cln_stress_period_data, binary=binary + ) + + self.parent.add_package(self) + + def _ncells(self): + """Maximum number of cells that have wells (developed for + MT3DMS SSM package). + + Returns + ------- + ncells: int + maximum number of wel cells + + """ + return self.stress_period_data.mxact + + def write_file(self, f=None): + """ + Write the package file. + + Parameters: + f: (str) optional file name + + Returns + ------- + None + + """ + if f is not None: + if isinstance(f, str): + f_wel = open(f, "w") + else: + f_wel = f + else: + f_wel = open(self.fn_path, "w") + + f_wel.write(f"{self.heading}\n") + + mxact = ( + self.stress_period_data.mxact + self.cln_stress_period_data.mxact + ) + + line = f" {mxact:9d} {self.ipakcb:9d} " + for opt in self.options: + line += " " + str(opt) + line += "\n" + f_wel.write(line) + + nrow, ncol, nlay, nper = self.parent.get_nrow_ncol_nlay_nper() + + kpers = list(self.stress_period_data.data.keys()) + if len(kpers) > 0: + kpers.sort() + first = kpers[0] + last = max(kpers) + 1 + else: + first = -1 + last = -1 + + cln_kpers = list(self.cln_stress_period_data.data.keys()) + if len(cln_kpers) > 0: + cln_kpers.sort() + cln_first = cln_kpers[0] + cln_last = max(cln_kpers) + 1 + else: + cln_first = -1 + cln_last = -1 + + maxper = max(nper, last, cln_last) + loop_over_kpers = list(range(0, maxper)) + + if first < 0: + first = maxper + if cln_first < 0: + cln_first = maxper + + fmt_string = self.stress_period_data.fmt_string + cln_fmt_string = self.cln_stress_period_data.fmt_string + + for kper in loop_over_kpers: + # Fill missing early kpers with 0 + if kper < first: + itmp = 0 + elif kper in kpers: + kper_data = self.stress_period_data.data[kper] + kper_vtype = self.stress_period_data.vtype[kper] + if kper_vtype == np.recarray: + itmp = kper_data.shape[0] + lnames = [name.lower() for name in kper_data.dtype.names] + for idx in ["k", "i", "j", "node"]: + if idx in lnames: + kper_data[idx] += 1 + elif (kper_vtype == int) or (kper_vtype is None): + itmp = kper_data + # Fill late missing kpers with -1 + else: + itmp = -1 + + # Fill missing early kpers with 0 + if kper < cln_first: + itmpcln = 0 + elif kper in cln_kpers: + cln_kper_data = self.cln_stress_period_data.data[kper] + cln_kper_vtype = self.cln_stress_period_data.vtype[kper] + if cln_kper_vtype == np.recarray: + itmpcln = cln_kper_data.shape[0] + lnames = [ + name.lower() for name in cln_kper_data.dtype.names + ] + for idx in ["k", "i", "j", "node"]: + if idx in lnames: + cln_kper_data[idx] += 1 + elif (cln_kper_vtype == int) or (cln_kper_vtype is None): + itmpcln = cln_kper_data + # Fill late missing kpers with -1 + else: + itmpcln = -1 + + f_wel.write( + f" {itmp:9d} {0:9d} {itmpcln:9d} # stress period {kper + 1}\n" + ) + + if itmp > 0: + np.savetxt(f_wel, kper_data, fmt=fmt_string, delimiter="") + if itmpcln > 0: + np.savetxt( + f_wel, cln_kper_data, fmt=cln_fmt_string, delimiter="" + ) + + f_wel.close() + + def add_record(self, kper, index, values): + try: + self.stress_period_data.add_record(kper, index, values) + except Exception as e: + raise Exception(f"mfwel error adding record to list: {e!s}") + + @staticmethod + def get_default_dtype(structured=True): + if structured: + dtype = np.dtype( + [ + ("k", int), + ("i", int), + ("j", int), + ("flux", np.float32), + ] + ) + else: + dtype = np.dtype([("node", int), ("flux", np.float32)]) + return dtype + + @staticmethod + def get_empty(ncells=0, aux_names=None, structured=True): + # get an empty recarray that corresponds to dtype + dtype = ModflowUsgWel.get_default_dtype(structured=structured) + if aux_names is not None: + dtype = Package.add_to_dtype(dtype, aux_names, np.float32) + return create_empty_recarray(ncells, dtype, default_value=-1.0e10) + + @staticmethod + def _get_sfac_columns(): + return ["flux"] + + @classmethod + def load(cls, f, model, nper=None, ext_unit_dict=None): + """ + Load an existing package. + + Parameters + ---------- + f : filename or file handle + File to load. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + nper : int + The number of stress periods. If nper is None, then nper will be + obtained from the model object. (default is None). + ext_unit_dict : dictionary, optional + If the arrays in the file are specified using EXTERNAL, + or older style array control records, then `f` should be a file + handle. In this case ext_unit_dict is required, which can be + constructed using the function + :class:`flopy.utils.mfreadnam.parsenamefile`. + + Returns + ------- + wel : ModflowUsgWel object + + Examples + -------- + + >>> import flopy + >>> m = flopy.modflow.Modflow() + >>> wel = flopy.modflowusg.ModflowUsgWel.load('test.wel', m) + + """ + + if model.verbose: + print("loading wel package file...") + + # open the file if not already open + openfile = not hasattr(f, "read") + if openfile: + filename = f + f = open(filename, "r") + elif hasattr(f, "name"): + filename = f.name + else: + filename = "?" + + # dataset 0 -- header + while True: + line = f.readline() + if line[0] != "#": + break + + # dataset 1a -- check for parameters + npwel = 0 + if "parameter" in line.lower(): + t = line.strip().split() + npwel = int(t[1]) + mxl = 0 + if npwel > 0: + mxl = int(t[2]) + if model.verbose: + print( + f" Parameters detected. Number of parameters = {npwel}" + ) + line = f.readline() + + # dataset 2 -- MXACTW IWELCB [Option] + t = line.strip().split() + imax = 2 + ipakcb = 0 + try: + ipakcb = int(t[1]) + except: + if model.verbose: + print(f" implicit ipakcb in {filename}") + + options = [] + aux_names = [] + iunitafr = 0 + if len(t) > imax: + it = imax + while it < len(t): + toption = t[it] + if toption.lower() == "noprint": + options.append(toption.lower()) + elif toption.lower() == "autoflowreduce": + options.append(toption.lower()) + elif toption.lower() == "iunitafr": + options.append(" ".join(t[it : it + 2])) + iunitafr = t[it + 1] + it += 1 + elif "aux" in toption.lower(): + options.append(" ".join(t[it : it + 2])) + aux_names.append(t[it + 1].lower()) + it += 1 + it += 1 + + # get the list columns that should be scaled with sfac + sfac_columns = ModflowUsgWel._get_sfac_columns() + + # dataset 3 -- read parameter data + if npwel > 0: + dt = ModflowUsgWel.get_empty( + 1, aux_names=aux_names, structured=model.structured + ).dtype + # dataset 4 -- + pak_parms = mfparbc.load( + f, npwel, dt, model, ext_unit_dict, model.verbose + ) + + if nper is None: + nrow, ncol, nlay, nper = model.get_nrow_ncol_nlay_nper() + + # dataset 5 -- read data for every stress period + bnd_output = None + stress_period_data = {} + current = None + + cln_bnd_output = None + cln_stress_period_data = {} + cln_current = None + + for iper in range(nper): + if model.verbose: + msg = f" loading well data for kper {iper + 1:5d}" + print(msg) + line = f.readline() + if line == "": + break + t = line.strip().split() + itmp = int(t[0]) + itmpp = 0 + try: + itmpp = int(t[1]) + except: + if model.verbose: + print(f" implicit itmpp in {filename}") + + try: + itmpcln = int(t[2]) + except: + itmpcln = 0 + + # dataset 6a -- read well data + if itmp == 0: + bnd_output = None + current = ModflowUsgWel.get_empty( + itmp, aux_names=aux_names, structured=model.structured + ) + elif itmp > 0: + current = ModflowUsgWel.get_empty( + itmp, aux_names=aux_names, structured=model.structured + ) + current = ulstrd( + f, itmp, current, model, sfac_columns, ext_unit_dict + ) + if model.structured: + current["k"] -= 1 + current["i"] -= 1 + current["j"] -= 1 + else: + current["node"] -= 1 + bnd_output = np.recarray.copy(current) + else: + if current is None: + bnd_output = None + else: + bnd_output = np.recarray.copy(current) + + # dataset 6c -- read CLN well data + if itmpcln == 0: + cln_bnd_output = None + cln_current = ModflowUsgWel.get_empty( + itmp, aux_names=aux_names, structured=False + ) + elif itmpcln > 0: + cln_current = ModflowUsgWel.get_empty( + itmpcln, aux_names=aux_names, structured=False + ) + cln_current = ulstrd( + f, itmpcln, cln_current, model, sfac_columns, ext_unit_dict + ) + cln_current["node"] -= 1 + cln_bnd_output = np.recarray.copy(cln_current) + else: + if cln_current is None: + cln_bnd_output = None + else: + cln_bnd_output = np.recarray.copy(cln_current) + + # dataset 7 -- parameter data + for iparm in range(itmpp): + line = f.readline() + t = line.strip().split() + pname = t[0].lower() + iname = "static" + try: + tn = t[1] + c = tn.lower() + instance_dict = pak_parms.bc_parms[pname][1] + if c in instance_dict: + iname = c + else: + iname = "static" + except: + if model.verbose: + print( + f" implicit static instance for parameter {pname}" + ) + + par_dict, current_dict = pak_parms.get(pname) + data_dict = current_dict[iname] + + par_current = ModflowUsgWel.get_empty( + par_dict["nlst"], + aux_names=aux_names, + structured=model.structured, + ) + + # get appropriate parval + if model.mfpar.pval is None: + parval = float(par_dict["parval"]) + else: + try: + parval = float(model.mfpar.pval.pval_dict[pname]) + except: + parval = float(par_dict["parval"]) + + # fill current parameter data (par_current) + for ibnd, t in enumerate(data_dict): + t = tuple(t) + par_current[ibnd] = tuple( + t[: len(par_current.dtype.names)] + ) + + if model.structured: + par_current["k"] -= 1 + par_current["i"] -= 1 + par_current["j"] -= 1 + else: + par_current["node"] -= 1 + + par_current["flux"] *= parval + + if bnd_output is None: + bnd_output = np.recarray.copy(par_current) + else: + bnd_output = stack_arrays( + (bnd_output, par_current), + asrecarray=True, + usemask=False, + ) + + if bnd_output is None: + stress_period_data[iper] = itmp + else: + stress_period_data[iper] = bnd_output + + if cln_bnd_output is None: + cln_stress_period_data[iper] = itmpcln + else: + cln_stress_period_data[iper] = cln_bnd_output + + if openfile: + f.close() + + # set package unit number + filenames = [None, None, None] + if ext_unit_dict is not None: + unitnumber, filenames[0] = model.get_ext_dict_attr( + ext_unit_dict, filetype=ModflowUsgWel._ftype() + ) + if ipakcb > 0: + iu, filenames[1] = model.get_ext_dict_attr( + ext_unit_dict, unit=ipakcb + ) + model.add_pop_key_list(ipakcb) + if iunitafr > 0: + iu, filenames[2] = model.get_ext_dict_attr( + ext_unit_dict, unit=iunitafr + ) + model.add_pop_key_list(iunitafr) + + wel = cls( + model, + ipakcb=ipakcb, + stress_period_data=stress_period_data, + cln_stress_period_data=cln_stress_period_data, + options=options, + unitnumber=unitnumber, + filenames=filenames, + ) + + return wel + + @staticmethod + def _ftype(): + return "WEL" + + @staticmethod + def _defaultunit(): + return 20 diff --git a/setup.py b/setup.py index 22b3ff139e..343ce08c4e 100644 --- a/setup.py +++ b/setup.py @@ -35,6 +35,7 @@ "flopy", "flopy.modflow", "flopy.modflowlgr", + "flopy.modflowusg", "flopy.modpath", "flopy.mt3d", "flopy.seawat", From 439347a0c0325fe1982c9f862782c1396edf073f Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Mon, 27 Sep 2021 22:52:32 +1000 Subject: [PATCH 02/14] refactor(modflowusg) * move modflowdisu to modflowusg * add deprecation warning to flopy.Modflow.load() for modflowusg models * removed some modflowusg bits from flopy.Modflow; now in flopy.ModflowUsg instead * utils.gridgen updated for this refactor * several bug fixes so autotests will run * autotests t005_test, t016_test, t038_test, t061_test_gridgen, t506_test updated for this refactoring ModflowUsgLpf and ModflowUsgBcf still need refactoring / superclassing (from ModflowLpf and ModflowBcf) to minimise code duplication. Possibly ModflowUsgWel too. --- autotest/t005_test.py | 29 +- autotest/t016_test.py | 64 +- autotest/t038_test.py | 4 +- autotest/t061_test_gridgen.py | 6 +- autotest/t506_test.py | 15 +- flopy/mbase.py | 6 + flopy/modflow/__init__.py | 5 - flopy/modflow/mf.py | 43 +- flopy/modflow/mfsms.py | 653 ------------------ flopy/modflowusg/__init__.py | 4 +- flopy/modflowusg/mfusg.py | 30 +- .../mfdisu.py => modflowusg/mfusgdisu.py} | 20 +- flopy/modflowusg/mfusglpf.py | 2 +- flopy/modflowusg/mfusgsms.py | 1 + flopy/modflowusg/mfusgwel.py | 10 +- flopy/utils/gridgen.py | 4 +- 16 files changed, 132 insertions(+), 764 deletions(-) delete mode 100644 flopy/modflow/mfsms.py rename flopy/{modflow/mfdisu.py => modflowusg/mfusgdisu.py} (98%) diff --git a/autotest/t005_test.py b/autotest/t005_test.py index ac01e63871..2a135deddc 100644 --- a/autotest/t005_test.py +++ b/autotest/t005_test.py @@ -9,23 +9,26 @@ def test_modflow_unstructured(): import flopy + import numpy as np - mf = flopy.modflow.Modflow( - version="mfusg", structured=False, model_ws=cpth - ) - assert isinstance(mf, flopy.modflow.Modflow) + mf = flopy.modflowusg.ModflowUsg(structured=False, model_ws=cpth) + assert isinstance(mf, flopy.modflowusg.ModflowUsg) - dis = flopy.modflow.ModflowDis(mf) - assert isinstance(dis, flopy.modflow.ModflowDis) + disu = flopy.modflowusg.ModflowUsgDisU( + mf, nodes=1, iac=[1], njag=1, ja=np.array([0]), cl12=[1.0], fahl=[1.0] + ) + assert isinstance(disu, flopy.modflowusg.ModflowUsgDisU) bas = flopy.modflow.ModflowBas(mf) assert isinstance(bas, flopy.modflow.ModflowBas) - lpf = flopy.modflow.ModflowLpf(mf) - assert isinstance(lpf, flopy.modflow.ModflowLpf) + lpf = flopy.modflowusg.ModflowUsgLpf(mf) + assert isinstance(lpf, flopy.modflowusg.ModflowUsgLpf) - wel = flopy.modflow.ModflowWel(mf, stress_period_data={0: [[0, -100]]}) - assert isinstance(wel, flopy.modflow.ModflowWel) + wel = flopy.modflowusg.ModflowUsgWel( + mf, stress_period_data={0: [[0, -100]]} + ) + assert isinstance(wel, flopy.modflowusg.ModflowUsgWel) ghb = flopy.modflow.ModflowGhb( mf, stress_period_data={0: [[1, 5.9, 1000.0]]} @@ -35,13 +38,13 @@ def test_modflow_unstructured(): oc = flopy.modflow.ModflowOc(mf) assert isinstance(oc, flopy.modflow.ModflowOc) - sms = flopy.modflow.ModflowSms(mf) - assert isinstance(sms, flopy.modflow.ModflowSms) + sms = flopy.modflowusg.ModflowUsgSms(mf) + assert isinstance(sms, flopy.modflowusg.ModflowUsgSms) # write well file wel.write_file() assert os.path.isfile(os.path.join(cpth, f"{mf.name}.wel")) is True - wel2 = flopy.modflow.ModflowWel.load( + wel2 = flopy.modflowusg.ModflowUsgWel.load( os.path.join(cpth, f"{mf.name}.wel"), mf ) assert wel2.stress_period_data[0] == wel.stress_period_data[0] diff --git a/autotest/t016_test.py b/autotest/t016_test.py index bfc4180a90..0665a1e76d 100644 --- a/autotest/t016_test.py +++ b/autotest/t016_test.py @@ -25,11 +25,11 @@ def test_usg_disu_load(): assert os.path.isfile(fname), f"disu file not found {fname}" # Create the model - m = flopy.modflow.Modflow(modelname="usgload", verbose=True) + m = flopy.modflowusg.ModflowUsg(modelname="usgload", verbose=True) # Load the disu file - disu = flopy.modflow.ModflowDisU.load(fname, m) - assert isinstance(disu, flopy.modflow.ModflowDisU) + disu = flopy.modflowusg.ModflowUsgDisU.load(fname, m) + assert isinstance(disu, flopy.modflowusg.ModflowUsgDisU) # Change where model files are written model_ws = tpth @@ -42,7 +42,7 @@ def test_usg_disu_load(): ) # Load disu file - disu2 = flopy.modflow.ModflowDisU.load(fname, m) + disu2 = flopy.modflowusg.ModflowUsgDisU.load(fname, m) for (key1, value1), (key2, value2) in zip( disu2.__dict__.items(), disu.__dict__.items() ): @@ -67,11 +67,11 @@ def test_usg_sms_load(): assert os.path.isfile(fname), f"sms file not found {fname}" # Create the model - m = flopy.modflow.Modflow(modelname="usgload", verbose=True) + m = flopy.modflowusg.ModflowUsg(modelname="usgload", verbose=True) # Load the sms file - sms = flopy.modflow.ModflowSms.load(fname, m) - assert isinstance(sms, flopy.modflow.ModflowSms) + sms = flopy.modflowusg.ModflowUsgSms.load(fname, m) + assert isinstance(sms, flopy.modflowusg.ModflowUsgSms) # Change where model files are written model_ws = tpth @@ -84,7 +84,7 @@ def test_usg_sms_load(): ) # Load sms file - sms2 = flopy.modflow.ModflowSms.load(fname, m) + sms2 = flopy.modflowusg.ModflowUsgSms.load(fname, m) for (key1, value1), (key2, value2) in zip( sms2.__dict__.items(), sms.__dict__.items() ): @@ -96,7 +96,7 @@ def test_usg_sms_load(): def test_usg_model(): - mf = flopy.modflow.Modflow( + mf = flopy.modflowusg.ModflowUsg( version="mfusg", structured=True, model_ws=tpth, @@ -105,8 +105,8 @@ def test_usg_model(): ) dis = flopy.modflow.ModflowDis(mf, nlay=1, nrow=11, ncol=11) bas = flopy.modflow.ModflowBas(mf) - lpf = flopy.modflow.ModflowLpf(mf) - wel = flopy.modflow.ModflowWel( + lpf = flopy.modflowusg.ModflowUsgLpf(mf) + wel = flopy.modflowusg.ModflowUsgWel( mf, stress_period_data={0: [[0, 5, 5, -1.0]]} ) ghb = flopy.modflow.ModflowGhb( @@ -119,7 +119,7 @@ def test_usg_model(): }, ) oc = flopy.modflow.ModflowOc(mf) - sms = flopy.modflow.ModflowSms(mf, options="complex") + sms = flopy.modflowusg.ModflowUsgSms(mf, options="complex") # run with defaults mf.write_input() @@ -130,7 +130,7 @@ def test_usg_model(): # try different complexity options; all should run successfully for complexity in ["simple", "moderate", "complex"]: print(f"testing MFUSG with sms complexity: {complexity}") - sms = flopy.modflow.ModflowSms(mf, options=complexity) + sms = flopy.modflowusg.ModflowUsgSms(mf, options=complexity) sms.write_file() if run: success, buff = mf.run_model() @@ -148,22 +148,22 @@ def test_usg_load_01B(): assert os.path.isfile(fname), f"nam file not found {fname}" # Create the model - m = flopy.modflow.Modflow(modelname="usgload_1b", verbose=True) + m = flopy.modflowusg.ModflowUsg(modelname="usgload_1b", verbose=True) # Load the model, with checking m = m.load(fname, check=True) # assert disu, lpf, bas packages have been loaded msg = "flopy failed on loading mfusg disu package" - assert isinstance(m.disu, flopy.modflow.mfdisu.ModflowDisU), msg + assert isinstance(m.disu, flopy.modflowusg.mfusgdisu.ModflowUsgDisU), msg msg = "flopy failed on loading mfusg lpf package" - assert isinstance(m.lpf, flopy.modflow.mflpf.ModflowLpf), msg + assert isinstance(m.lpf, flopy.modflowusg.mfusglpf.ModflowUsgLpf), msg msg = "flopy failed on loading mfusg bas package" assert isinstance(m.bas6, flopy.modflow.mfbas.ModflowBas), msg msg = "flopy failed on loading mfusg oc package" assert isinstance(m.oc, flopy.modflow.mfoc.ModflowOc), msg msg = "flopy failed on loading mfusg sms package" - assert isinstance(m.sms, flopy.modflow.mfsms.ModflowSms), msg + assert isinstance(m.sms, flopy.modflowusg.mfusgsms.ModflowUsgSms), msg def test_usg_load_45usg(): @@ -173,26 +173,26 @@ def test_usg_load_45usg(): assert os.path.isfile(fname), f"nam file not found {fname}" # Create the model - m = flopy.modflow.Modflow(modelname="45usg", verbose=True) + m = flopy.modflowusg.ModflowUsg(modelname="45usg", verbose=True) # Load the model, with checking. m = m.load(fname, check=True) # assert disu, lpf, bas packages have been loaded msg = "flopy failed on loading mfusg disu package" - assert isinstance(m.disu, flopy.modflow.mfdisu.ModflowDisU), msg + assert isinstance(m.disu, flopy.modflowusg.mfusgdisu.ModflowUsgDisU), msg msg = "flopy failed on loading mfusg lpf package" - assert isinstance(m.lpf, flopy.modflow.mflpf.ModflowLpf), msg + assert isinstance(m.lpf, flopy.modflowusg.mfusglpf.ModflowUsgLpf), msg msg = "flopy failed on loading mfusg bas package" assert isinstance(m.bas6, flopy.modflow.mfbas.ModflowBas), msg msg = "flopy failed on loading mfusg oc package" assert isinstance(m.oc, flopy.modflow.mfoc.ModflowOc), msg msg = "flopy failed on loading mfusg sms package" - assert isinstance(m.sms, flopy.modflow.mfsms.ModflowSms), msg + assert isinstance(m.sms, flopy.modflowusg.mfusgsms.ModflowUsgSms), msg msg = "flopy failed on loading mfusg drn package" assert isinstance(m.drn, flopy.modflow.mfdrn.ModflowDrn), msg msg = "flopy failed on loading mfusg wel package" - assert isinstance(m.wel, flopy.modflow.mfwel.ModflowWel), msg + assert isinstance(m.wel, flopy.modflowusg.mfusgwel.ModflowUsgWel), msg def test_usg_rch_evt_models01(): @@ -205,9 +205,7 @@ def test_usg_rch_evt_models01(): "..", "examples", "data", "mfusg_test", "rch_evt_tests" ) nam = "usg_rch_evt.nam" - m = flopy.modflow.Modflow.load( - nam, model_ws=model_ws, version="mfusg", exe_name=v - ) + m = flopy.modflowusg.ModflowUsg.load(nam, model_ws=model_ws, exe_name=v) m.riv.check() m.model_ws = tpth m.write_input() @@ -226,9 +224,7 @@ def test_usg_rch_evt_models02(): "..", "examples", "data", "mfusg_test", "rch_evt_tests" ) nam = "usg_rch_evt_nrchop2.nam" - m = flopy.modflow.Modflow.load( - nam, model_ws=model_ws, version="mfusg", exe_name=v - ) + m = flopy.modflowusg.ModflowUsg.load(nam, model_ws=model_ws, exe_name=v) m.model_ws = tpth m.write_input() if run: @@ -246,9 +242,7 @@ def test_usg_rch_evt_models02a(): "..", "examples", "data", "mfusg_test", "rch_evt_tests" ) nam = "usg_rch_evt_nrchop2a.nam" - m = flopy.modflow.Modflow.load( - nam, model_ws=model_ws, version="mfusg", exe_name=v - ) + m = flopy.modflowusg.ModflowUsg.load(nam, model_ws=model_ws, exe_name=v) m.model_ws = tpth m.write_input() if run: @@ -263,9 +257,7 @@ def test_usg_ss_to_tr(): "..", "examples", "data", "mfusg_test", "01A_nestedgrid_nognc" ) nam = "flow.nam" - m = flopy.modflow.Modflow.load( - nam, model_ws=model_ws, version="mfusg", exe_name=v - ) + m = flopy.modflowusg.ModflowUsg.load(nam, model_ws=model_ws, exe_name=v) m.model_ws = tpth m.disu.steady = [False] m.write_input() @@ -273,9 +265,7 @@ def test_usg_ss_to_tr(): success, buff = m.run_model() assert success - m = flopy.modflow.Modflow.load( - nam, model_ws=tpth, version="mfusg", exe_name=v - ) + m = flopy.modflowusg.ModflowUsg.load(nam, model_ws=tpth, exe_name=v) if run: success, buff = m.run_model() assert success diff --git a/autotest/t038_test.py b/autotest/t038_test.py index 0ed5587a82..c6d693253d 100644 --- a/autotest/t038_test.py +++ b/autotest/t038_test.py @@ -28,8 +28,8 @@ def test_load_usg(): # function to load a MODFLOW-USG model and then write it back out def load_model(namfile, model_ws): - m = flopy.modflow.Modflow.load( - namfile, model_ws=model_ws, version="mfusg", verbose=True, check=False + m = flopy.modflowusg.ModflowUsg.load( + namfile, model_ws=model_ws, verbose=True, check=False ) assert m, f"Could not load namefile {namfile}" assert m.load_fail is False diff --git a/autotest/t061_test_gridgen.py b/autotest/t061_test_gridgen.py index fce063f6d6..d8b3a078db 100644 --- a/autotest/t061_test_gridgen.py +++ b/autotest/t061_test_gridgen.py @@ -67,9 +67,7 @@ def test_gridgen(): botm=botm, ) - ms_u = flopy.modflow.Modflow( - modelname="mymfusgmodel", model_ws=cpth, version="mfusg" - ) + ms_u = flopy.modflowusg.ModflowUsg(modelname="mymfusgmodel", model_ws=cpth) dis_usg = flopy.modflow.ModflowDis( ms_u, nlay=nlay, @@ -228,7 +226,7 @@ def test_gridgen(): assert nlist == nlist2, msg # test getting a modflow-usg disu package - mu = flopy.modflow.Modflow(version="mfusg", structured=False) + mu = flopy.modflowusg.ModflowUsg(structured=False) disu = g.get_disu(mu) # test mfusg with vertical pass-through (True above at instantiation) diff --git a/autotest/t506_test.py b/autotest/t506_test.py index b2d1b93494..c0139b3541 100644 --- a/autotest/t506_test.py +++ b/autotest/t506_test.py @@ -376,18 +376,17 @@ def test_mfusg(): # create the mfusg modoel ws = os.path.join(tpth, "gridgen_mfusg") name = "mymodel" - m = flopy.modflow.Modflow( + m = flopy.modflowusg.ModflowUsg( modelname=name, model_ws=ws, - version="mfusg", exe_name=mfusg_exe, structured=False, ) - disu = flopy.modflow.ModflowDisU(m, **gridprops) + disu = flopy.modflowusg.ModflowUsgDisU(m, **gridprops) bas = flopy.modflow.ModflowBas(m) - lpf = flopy.modflow.ModflowLpf(m) + lpf = flopy.modflowusg.ModflowUsgLpf(m) chd = flopy.modflow.ModflowChd(m, stress_period_data=chdspd) - sms = flopy.modflow.ModflowSms(m) + sms = flopy.modflowusg.ModflowUsgSms(m) oc = flopy.modflow.ModflowOc(m, stress_period_data={(0, 0): ["save head"]}) m.write_input() @@ -457,12 +456,14 @@ def test_mfusg(): # re-run with an LPF keyword specified. This would have thrown an error # before the addition of ikcflag to mflpf.py (flopy 3.3.3 and earlier). - lpf = flopy.modflow.ModflowLpf(m, novfc=True, nocvcorrection=True) + lpf = flopy.modflowusg.ModflowUsgLpf( + m, novfc=True, nocvcorrection=True + ) m.write_input() m.run_model() # also test load of unstructured LPF with keywords - lpf2 = flopy.modflow.ModflowLpf.load( + lpf2 = flopy.modflowusg.ModflowUsgLpf.load( os.path.join(ws, f"{name}.lpf"), m, check=False ) msg = "NOCVCORRECTION and NOVFC should be in lpf options but at least one is not." diff --git a/flopy/mbase.py b/flopy/mbase.py index 7f053a865c..08b4af5c14 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -643,6 +643,12 @@ def __getattr__(self, item): else: return None + if item == "nper": + if self.dis is not None: + return self.dis.nper + else: + return 0 + if item == "start_datetime": if self.dis is not None: return self.dis.start_datetime diff --git a/flopy/modflow/__init__.py b/flopy/modflow/__init__.py index 4efae3f19c..dec5bab063 100644 --- a/flopy/modflow/__init__.py +++ b/flopy/modflow/__init__.py @@ -36,8 +36,6 @@ from .mfmlt import ModflowMlt from .mfparbc import ModflowParBc from .mfgmg import ModflowGmg -from .mfsms import ModflowSms -from .mfbct import ModflowBct from .mfhfb import ModflowHfb from .mfsfr2 import ModflowSfr2 from .mflak import ModflowLak @@ -48,6 +46,3 @@ from .mfhob import ModflowHob, HeadObservation from .mfflwob import ModflowFlwob from .mfaddoutsidefile import mfaddoutsidefile - -# unstructured -from .mfdisu import ModflowDisU diff --git a/flopy/modflow/mf.py b/flopy/modflow/mf.py index 110b4eb1e7..6e2c1f97e3 100644 --- a/flopy/modflow/mf.py +++ b/flopy/modflow/mf.py @@ -179,7 +179,6 @@ def __init__( "pval": flopy.modflow.ModflowPval, "bas6": flopy.modflow.ModflowBas, "dis": flopy.modflow.ModflowDis, - "disu": flopy.modflow.ModflowDisU, "bcf6": flopy.modflow.ModflowBcf, "lpf": flopy.modflow.ModflowLpf, "hfb6": flopy.modflow.ModflowHfb, @@ -204,7 +203,6 @@ def __init__( "pcgn": flopy.modflow.ModflowPcgn, "nwt": flopy.modflow.ModflowNwt, "pks": flopy.modflow.ModflowPks, - "sms": flopy.modflow.ModflowSms, "sfr": flopy.modflow.ModflowSfr2, "lak": flopy.modflow.ModflowLak, "gage": flopy.modflow.ModflowGage, @@ -229,24 +227,11 @@ def __init__( def __repr__(self): nrow, ncol, nlay, nper = self.get_nrow_ncol_nlay_nper() - if nrow is not None: - # structured case - s = ( - "MODFLOW {} layer(s) {} row(s) {} column(s) " - "{} stress period(s)".format(nlay, nrow, ncol, nper) - ) - else: - # unstructured case - nodes = ncol.sum() - nodelay = " ".join(str(i) for i in ncol) - print(nodelay, nlay, nper) - s = ( - "MODFLOW unstructured\n" - " nodes = {}\n" - " layers = {}\n" - " periods = {}\n" - " nodelay = {}\n".format(nodes, nlay, nper, ncol) - ) + # structured case + s = ( + "MODFLOW {} layer(s) {} row(s) {} column(s) " + "{} stress period(s)".format(nlay, nrow, ncol, nper) + ) return s # @@ -678,8 +663,8 @@ def load( f : str Path to MODFLOW name file to load. version : str, default "mf2005" - MODFLOW version. Choose one of: "mf2k", "mf2005" (default), - "mfnwt", or "mfusg". Note that this can be modified on loading + MODFLOW version. Choose one of: "mf2k", "mf2005" (default), or + "mfnwt". Note that this can be modified on loading packages unique to different MODFLOW versions. exe_name : str, default "mf2005.exe" MODFLOW executable name. @@ -691,8 +676,8 @@ def load( List of case insensitive packages to load, e.g. ["bas6", "lpf"]. One package can also be specified, e.g. "rch". Default is None, which attempts to load all files. An empty list [] will not load - any additional packages than is necessary. At a minimum, "dis" or - "disu" is always loaded. + any additional packages than is necessary. At a minimum, "dis" is + always loaded. forgive : bool, optional Option to raise exceptions on package load failure, which can be useful for debugging. Default False. @@ -771,6 +756,16 @@ def load( # update the modflow version ml.set_version(version) + # Impending deprecation warning to switch to using + # flopy.modflowusg.ModflowUsg() instead of flopy.modflow.Modflow() + if ml.version == "mfusg": + warnings.warn( + "flopy.modflow.Modflow() for mfusg models has been deprecated, " + " and will be removed in the next release. Please switch to using" + " flopy.modflowusg.ModflowUsg() instead.", + DeprecationWarning, + ) + # reset unit number for glo file if version == "mf2k": if "GLOBAL" in ext_pkg_d: diff --git a/flopy/modflow/mfsms.py b/flopy/modflow/mfsms.py deleted file mode 100644 index 090931e996..0000000000 --- a/flopy/modflow/mfsms.py +++ /dev/null @@ -1,653 +0,0 @@ -""" -mfsms module. This is the solver for MODFLOW-USG. -Contains the ModflowSms class. Note that the user can access -the ModflowSms class as `flopy.modflow.ModflowSms`. - - -""" -from ..pakbase import Package -from ..utils.flopy_io import line_parse - - -class ModflowSms(Package): - """ - MODFLOW Sms Package Class. - - Parameters - ---------- - model : model object - The model object (of type :class:`flopy.modflow.mf.Modflow`) to which - this package will be added. - hclose : float - is the head change criterion for convergence of the outer (nonlinear) - iterations, in units of length. When the maximum absolute value of the - head change at all nodes during an iteration is less than or equal to - HCLOSE, iteration stops. Commonly, HCLOSE equals 0.01. - hiclose : float - is the head change criterion for convergence of the inner (linear) - iterations, in units of length. When the maximum absolute value of the - head change at all nodes during an iteration is less than or equal to - HICLOSE, the matrix solver assumes convergence. Commonly, HICLOSE is - set an order of magnitude less than HCLOSE. - mxiter : int - is the maximum number of outer (nonlinear) iterations -- that is, - calls to the solution routine. For a linear problem MXITER should be 1. - iter1 : int - is the maximum number of inner (linear) iterations. The number - typically depends on the characteristics of the matrix solution - scheme being used. For nonlinear problems, ITER1 usually ranges - from 60 to 600; a value of 100 will be sufficient for most linear - problems. - iprsms : int - is a flag that controls printing of convergence information from the - solver: 0 is print nothing; 1 is print only the total number of - iterations and nonlinear residual reduction summaries; 2 is print - matrix solver information in addition to above. - nonlinmeth : int - is a flag that controls the nonlinear solution method and under- - relaxation schemes. 0 is Picard iteration scheme is used without any - under-relaxation schemes involved. > 0 is Newton-Raphson iteration - scheme is used with under-relaxation. Note that the Newton-Raphson - linearization scheme is available only for the upstream weighted - solution scheme of the BCF and LPF packages. < 0 is Picard iteration - scheme is used with under-relaxation. The absolute value of NONLINMETH - determines the underrelaxation scheme used. 1 or -1, then - Delta-Bar-Delta under-relaxation is used. 2 or -2 then Cooley - under-relaxation scheme is used. - Note that the under-relaxation schemes are used in conjunction with - gradient based methods, however, experience has indicated that the - Cooley under-relaxation and damping work well also for the Picard - scheme with the wet/dry options of MODFLOW. - linmeth : int - is a flag that controls the matrix solution method. 1 is the XMD - solver of Ibaraki (2005). 2 is the unstructured pre-conditioned - conjugate gradient solver of White and Hughes (2011). - theta : float - is the reduction factor for the learning rate (under-relaxation term) - of the delta-bar-delta algorithm. The value of THETA is between zero - and one. If the change in the variable (head) is of opposite sign to - that of the previous iteration, the under-relaxation term is reduced - by a factor of THETA. The value usually ranges from 0.3 to 0.9; a - value of 0.7 works well for most problems. - akappa : float - is the increment for the learning rate (under-relaxation term) of the - delta-bar-delta algorithm. The value of AKAPPA is between zero and - one. If the change in the variable (head) is of the same sign to that - of the previous iteration, the under-relaxation term is increased by - an increment of AKAPPA. The value usually ranges from 0.03 to 0.3; a - value of 0.1 works well for most problems. - gamma : float - is the history or memory term factor of the delta-bar-delta algorithm. - Gamma is between zero and 1 but cannot be equal to one. When GAMMA is - zero, only the most recent history (previous iteration value) is - maintained. As GAMMA is increased, past history of iteration changes - has greater influence on the memory term. The memory term is - maintained as an exponential average of past changes. Retaining some - past history can overcome granular behavior in the calculated function - surface and therefore helps to overcome cyclic patterns of - non-convergence. The value usually ranges from 0.1 to 0.3; a value of - 0.2 works well for most problems. - amomentum : float - is the fraction of past history changes that is added as a momentum - term to the step change for a nonlinear iteration. The value of - AMOMENTUM is between zero and one. A large momentum term should only - be used when small learning rates are expected. Small amounts of the - momentum term help convergence. The value usually ranges from 0.0001 - to 0.1; a value of 0.001 works well for most problems. - numtrack : int - is the maximum number of backtracking iterations allowed for residual - reduction computations. If NUMTRACK = 0 then the backtracking - iterations are omitted. The value usually ranges from 2 to 20; a - value of 10 works well for most problems. - numtrack : int - is the maximum number of backtracking iterations allowed for residual - reduction computations. If NUMTRACK = 0 then the backtracking - iterations are omitted. The value usually ranges from 2 to 20; a - value of 10 works well for most problems. - btol : float - is the tolerance for residual change that is allowed for residual - reduction computations. BTOL should not be less than one to avoid - getting stuck in local minima. A large value serves to check for - extreme residual increases, while a low value serves to control - step size more severely. The value usually ranges from 1.0 to 1e6 ; a - value of 1e4 works well for most problems but lower values like 1.1 - may be required for harder problems. - breduce : float - is the reduction in step size used for residual reduction - computations. The value of BREDUC is between zero and one. The value - usually ranges from 0.1 to 0.3; a value of 0.2 works well for most - problems. - reslim : float - is the limit to which the residual is reduced with backtracking. - If the residual is smaller than RESLIM, then further backtracking is - not performed. A value of 100 is suitable for large problems and - residual reduction to smaller values may only slow down computations. - iacl : int - is the flag for choosing the acceleration method. 0 is Conjugate - Gradient; select this option if the matrix is symmetric. 1 is - ORTHOMIN. 2 is BiCGSTAB. - norder : int - is the flag for choosing the ordering scheme. - 0 is original ordering - 1 is reverse Cuthill McKee ordering - 2 is Minimum degree ordering - level : int - is the level of fill for ILU decomposition. Higher levels of fill - provide more robustness but also require more memory. For optimal - performance, it is suggested that a large level of fill be applied - (7 or 8) with use of drop tolerance. - north : int - is the number of orthogonalizations for the ORTHOMIN acceleration - scheme. A number between 4 and 10 is appropriate. Small values require - less storage but more iteration may be required. This number should - equal 2 for the other acceleration methods. - iredsys : int - is the index for creating a reduced system of equations using the - red-black ordering scheme. - 0 is do not create reduced system - 1 is create reduced system using red-black ordering - rrctol : float - is a residual tolerance criterion for convergence. The root mean - squared residual of the matrix solution is evaluated against this - number to determine convergence. The solver assumes convergence if - either HICLOSE (the absolute head tolerance value for the solver) or - RRCTOL is achieved. Note that a value of zero ignores residual - tolerance in favor of the absolute tolerance (HICLOSE) for closure of - the matrix solver. - idroptol : int - is the flag to perform drop tolerance. - 0 is do not perform drop tolerance - 1 is perform drop tolerance - epsrn : float - is the drop tolerance value. A value of 1e-3 works well for most - problems. - clin : string - an option keyword that defines the linear acceleration method used by - the PCGU solver. - CLIN is "CG", then preconditioned conjugate gradient method. - CLIN is "BCGS", then preconditioned bi-conjugate gradient stabilized - method. - ipc : int - an integer value that defines the preconditioner. - IPC = 0, No preconditioning. - IPC = 1, Jacobi preconditioning. - IPC = 2, ILU(0) preconditioning. - IPC = 3, MILU(0) preconditioning (default). - iscl : int - is the flag for choosing the matrix scaling approach used. - 0 is no matrix scaling applied - 1 is symmetric matrix scaling using the scaling method by the POLCG - preconditioner in Hill (1992). - 2 is symmetric matrix scaling using the l2 norm of each row of - A (DR) and the l2 norm of each row of DRA. - iord : int - is the flag for choosing the matrix reordering approach used. - 0 = original ordering - 1 = reverse Cuthill McKee ordering - 2 = minimum degree ordering - rclosepcgu : float - a real value that defines the flow residual tolerance for convergence - of the PCGU linear solver. This value represents the maximum allowable - residual at any single node. Value is in units of length cubed per - time, and must be consistent with MODFLOW-USG length and time units. - Usually a value of 1.0x10-1 is sufficient for the flow-residual - criteria when meters and seconds are the defined MODFLOW-USG length - and time. - relaxpcgu : float - a real value that defines the relaxation factor used by the MILU(0) - preconditioner. RELAXPCGU is unitless and should be greater than or - equal to 0.0 and less than or equal to 1.0. RELAXPCGU values of about - 1.0 are commonly used, and experience suggests that convergence can - be optimized in some cases with RELAXPCGU values of 0.97. A RELAXPCGU - value of 0.0 will result in ILU(0) preconditioning. RELAXPCGU is only - specified if IPC=3. If RELAXPCGU is not specified and IPC=3, then a - default value of 0.97 will be assigned to RELAXPCGU. - extension : str, optional - File extension (default is 'sms'. - unitnumber : int, optional - FORTRAN unit number for this package (default is None). - filenames : str or list of str - Filenames to use for the package. If filenames=None the package name - will be created using the model name and package extension. If a - single string is passed the package will be set to the string. - Default is None. - - Attributes - ---------- - - Methods - ------- - - See Also - -------- - - Notes - ----- - - Examples - -------- - - >>> import flopy - >>> m = flopy.modflow.Modflow() - >>> sms = flopy.modflow.ModflowSms(m) - - """ - - def __init__( - self, - model, - hclose=1e-4, - hiclose=1e-4, - mxiter=100, - iter1=20, - iprsms=2, - nonlinmeth=0, - linmeth=2, - theta=0.7, - akappa=0.1, - gamma=0.2, - amomentum=0.001, - numtrack=20, - btol=1e4, - breduc=0.2, - reslim=100.0, - iacl=2, - norder=0, - level=7, - north=2, - iredsys=0, - rrctol=0.0, - idroptol=0, - epsrn=1.0e-3, - clin="bcgs", - ipc=3, - iscl=0, - iord=0, - rclosepcgu=0.1, - relaxpcgu=1.0, - extension="sms", - options=None, - unitnumber=None, - filenames=None, - ): - # set default unit number of one is not specified - if unitnumber is None: - unitnumber = ModflowSms._defaultunit() - - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowSms._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, - model, - extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, - ) - - self._generate_heading() - self.url = " " - self.hclose = hclose - self.hiclose = hiclose - self.mxiter = mxiter - self.iter1 = iter1 - self.iprsms = iprsms - self.nonlinmeth = nonlinmeth - self.linmeth = linmeth - self.theta = theta - self.akappa = akappa - self.gamma = gamma - self.amomentum = amomentum - self.numtrack = numtrack - self.btol = btol - self.breduc = breduc - self.reslim = reslim - self.iacl = iacl - self.norder = norder - self.level = level - self.north = north - self.iredsys = iredsys - self.rrctol = rrctol - self.idroptol = idroptol - self.epsrn = epsrn - self.clin = clin - self.ipc = ipc - self.iscl = iscl - self.iord = iord - self.rclosepcgu = rclosepcgu - self.relaxpcgu = relaxpcgu - if options is None: - self.options = [] - else: - if not isinstance(options, list): - options = [options] - self.options = options - self.parent.add_package(self) - return - - def write_file(self): - """ - Write the package file. - - Returns - ------- - None - - """ - f = open(self.fn_path, "w") - f.write(f"{self.heading}\n") - nopt = len(self.options) - if nopt > 0: - f.write(" ".join(self.options) + "\n") - f.write( - "{0} {1} {2} {3} {4} {5} {6}\n".format( - self.hclose, - self.hiclose, - self.mxiter, - self.iter1, - self.iprsms, - self.nonlinmeth, - self.linmeth, - ) - ) - if self.nonlinmeth != 0 and nopt == 0: - f.write( - "{0} {1} {2} {3} {4} {5} {6} {7}\n".format( - self.theta, - self.akappa, - self.gamma, - self.amomentum, - self.numtrack, - self.btol, - self.breduc, - self.reslim, - ) - ) - if self.linmeth == 1 and nopt == 0: - f.write( - "{0} {1} {2} {3} {4} {5} {6} {7}\n".format( - self.iacl, - self.norder, - self.level, - self.north, - self.iredsys, - self.rrctol, - self.idroptol, - self.epsrn, - ) - ) - if self.linmeth == 2 and nopt == 0: - f.write( - "{0} {1} {2} {3} {4} {5}\n".format( - self.clin, - self.ipc, - self.iscl, - self.iord, - self.rclosepcgu, - self.relaxpcgu, - ) - ) - f.write("\n") - f.close() - - @classmethod - def load(cls, f, model, ext_unit_dict=None): - """ - Load an existing package. - - Parameters - ---------- - f : filename or file handle - File to load. - model : model object - The model object (of type :class:`flopy.modflow.mf.Modflow`) to - which this package will be added. - ext_unit_dict : dictionary, optional - If the arrays in the file are specified using EXTERNAL, - or older style array control records, then `f` should be a file - handle. In this case ext_unit_dict is required, which can be - constructed using the function - :class:`flopy.utils.mfreadnam.parsenamefile`. - - Returns - ------- - sms : ModflowSms object - - Examples - -------- - - >>> import flopy - >>> m = flopy.modflow.Modflow() - >>> sms = flopy.modflow.ModflowPcg.load('test.sms', m) - - """ - - if model.verbose: - print("loading sms package file...") - - if model.version != "mfusg": - print( - "Warning: model version was reset from '{}' to 'mfusg' " - "in order to load a SMS file".format(model.version) - ) - model.version = "mfusg" - - openfile = not hasattr(f, "read") - if openfile: - filename = f - f = open(filename, "r") - - # dataset 0 -- header - while True: - line = f.readline() - if line[0] != "#": - break - - # Record 1a - opts = ["simple", "moderate", "complex"] - options = [] - firstentry = line.strip().split()[0] - if firstentry.lower() in opts: - options.append(firstentry) - nopt = len(options) - - if nopt > 0: - line = f.readline() - - # Record 1b -- line will have already been read - if model.verbose: - print( - " loading HCLOSE HICLOSE MXITER ITER1 " - "IPRSMS NONLINMETH LINMETH..." - ) - ll = line_parse(line) - hclose = float(ll.pop(0)) - hiclose = float(ll.pop(0)) - mxiter = int(ll.pop(0)) - iter1 = int(ll.pop(0)) - iprsms = int(ll.pop(0)) - nonlinmeth = int(ll.pop(0)) - linmeth = int(ll.pop(0)) - if model.verbose: - print(f" HCLOSE {hclose}") - print(f" HICLOSE {hiclose}") - print(f" MXITER {mxiter}") - print(f" ITER1 {iter1}") - print(f" IPRSMS {iprsms}") - print(f" NONLINMETH {nonlinmeth}") - print(f" LINMETH {linmeth}") - - # Record 2 - theta = None - akappa = None - gamma = None - amomentum = None - numtrack = None - btol = None - breduc = None - reslim = None - if nonlinmeth != 0 and nopt == 0: - if model.verbose: - print( - " loading THETA AKAPPA GAMMA AMOMENTUM " - "NUMTRACK BTOL BREDUC RESLIM..." - ) - while True: - line = f.readline() - if line[0] != "#": - break - ll = line_parse(line) - theta = float(ll.pop(0)) - akappa = float(ll.pop(0)) - gamma = float(ll.pop(0)) - amomentum = float(ll.pop(0)) - numtrack = int(ll.pop(0)) - btol = float(ll.pop(0)) - breduc = float(ll.pop(0)) - reslim = float(ll.pop(0)) - if model.verbose: - print(f" THETA {theta}") - print(f" AKAPPA {akappa}") - print(f" GAMMA {gamma}") - print(f" AMOMENTUM {amomentum}") - print(f" NUMTRACK {numtrack}") - print(f" BTOL {btol}") - print(f" BREDUC {breduc}") - print(f" RESLIM {reslim}") - - iacl = None - norder = None - level = None - north = None - iredsys = None - rrctol = None - idroptol = None - epsrn = None - if linmeth == 1 and nopt == 0: - if model.verbose: - print( - " loading IACL NORDER LEVEL NORTH " - "IREDSYS RRCTOL IDROPTOL EPSRN" - ) - while True: - line = f.readline() - if line[0] != "#": - break - ll = line_parse(line) - iacl = int(ll.pop(0)) - norder = int(ll.pop(0)) - level = int(ll.pop(0)) - north = int(ll.pop(0)) - iredsys = int(ll.pop(0)) - rrctol = float(ll.pop(0)) - idroptol = int(ll.pop(0)) - epsrn = float(ll.pop(0)) - if model.verbose: - print(f" IACL {iacl}") - print(f" NORDER {norder}") - print(f" LEVEL {level}") - print(f" NORTH {north}") - print(f" IREDSYS {iredsys}") - print(f" RRCTOL {rrctol}") - print(f" IDROPTOL {idroptol}") - print(f" EPSRN {epsrn}") - - clin = None - ipc = None - iscl = None - iord = None - rclosepcgu = None - relaxpcgu = None - if linmeth == 2 and nopt == 0: - if model.verbose: - print(" loading [CLIN] IPC ISCL IORD RCLOSEPCGU [RELAXPCGU]") - while True: - line = f.readline() - if line[0] != "#": - break - ll = line_parse(line) - if "cg" in line.lower(): # this will get cg or bcgs - clin = ll.pop(0) - ipc = int(ll.pop(0)) - iscl = int(ll.pop(0)) - iord = int(ll.pop(0)) - rclosepcgu = float(ll.pop(0)) - if len(ll) > 0: - relaxpcgu = float(ll.pop(0)) - if model.verbose: - print(f" CLIN {clin}") - print(f" IPC {ipc}") - print(f" ISCL {iscl}") - print(f" IORD {iord}") - print(f" RCLOSEPCGU {rclosepcgu}") - print(f" RELAXPCGU {relaxpcgu}") - - if openfile: - f.close() - - # set package unit number - unitnumber = None - filenames = [None] - if ext_unit_dict is not None: - unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowSms._ftype() - ) - - return cls( - model, - hclose=hclose, - hiclose=hiclose, - mxiter=mxiter, - iter1=iter1, - iprsms=iprsms, - nonlinmeth=nonlinmeth, - linmeth=linmeth, - theta=theta, - akappa=akappa, - gamma=gamma, - amomentum=amomentum, - numtrack=numtrack, - btol=btol, - breduc=breduc, - reslim=reslim, - iacl=iacl, - norder=norder, - level=level, - north=north, - iredsys=iredsys, - rrctol=rrctol, - idroptol=idroptol, - epsrn=epsrn, - clin=clin, - ipc=ipc, - iscl=iscl, - iord=iord, - rclosepcgu=rclosepcgu, - options=options, - relaxpcgu=relaxpcgu, - unitnumber=unitnumber, - filenames=filenames, - ) - - @staticmethod - def _ftype(): - return "SMS" - - @staticmethod - def _defaultunit(): - return 32 diff --git a/flopy/modflowusg/__init__.py b/flopy/modflowusg/__init__.py index 36b220bc07..dc855cb5ad 100644 --- a/flopy/modflowusg/__init__.py +++ b/flopy/modflowusg/__init__.py @@ -1,7 +1,9 @@ from .mfusg import ModflowUsg +from .mfusgdisu import ModflowUsgDisU from .mfusgbcf import ModflowUsgBcf +from .mfusglpf import ModflowUsgLpf from .mfusgwel import ModflowUsgWel from .mfusgcln import ModflowUsgCln from .mfusgbct import ModflowUsgBct from .mfusgsms import ModflowUsgSms -from .mfusggnc import ModflowUsgGnc \ No newline at end of file +from .mfusggnc import ModflowUsgGnc diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py index 7282f3b67d..da9481ab70 100644 --- a/flopy/modflowusg/mfusg.py +++ b/flopy/modflowusg/mfusg.py @@ -11,6 +11,7 @@ from ..modflow import Modflow + class ModflowUsg(Modflow): """ MODFLOW-USG Model Class. @@ -65,6 +66,7 @@ def __init__( model_ws=".", external_path=None, verbose=False, + version="mfusg", **kwargs, ): super().__init__( @@ -87,7 +89,6 @@ def __init__( "pval": flopy.modflow.ModflowPval, "bas6": flopy.modflow.ModflowBas, "dis": flopy.modflow.ModflowDis, - "lpf": flopy.modflow.ModflowLpf, "hfb6": flopy.modflow.ModflowHfb, "chd": flopy.modflow.ModflowChd, "fhb": flopy.modflow.ModflowFhb, @@ -104,15 +105,39 @@ def __init__( "oc": flopy.modflow.ModflowOc, "sub": flopy.modflow.ModflowSub, "swt": flopy.modflow.ModflowSwt, - "disu": flopy.modflow.ModflowDisU, + "disu": flopy.modflowusg.ModflowUsgDisU, "sms": flopy.modflowusg.ModflowUsgSms, "wel": flopy.modflowusg.ModflowUsgWel, "bcf6": flopy.modflowusg.ModflowUsgBcf, + "lpf": flopy.modflowusg.ModflowUsgLpf, "cln": flopy.modflowusg.ModflowUsgCln, "gnc": flopy.modflowusg.ModflowUsgGnc, "bct": flopy.modflowusg.ModflowUsgBct, } return + + def __repr__(self): + nrow, ncol, nlay, nper = self.get_nrow_ncol_nlay_nper() + if nrow is not None: + # structured case + s = ( + "MODFLOW {} layer(s) {} row(s) {} column(s) " + "{} stress period(s)".format(nlay, nrow, ncol, nper) + ) + else: + # unstructured case + nodes = ncol.sum() + nodelay = " ".join(str(i) for i in ncol) + print(nodelay, nlay, nper) + s = ( + "MODFLOW unstructured\n" + " nodes = {}\n" + " layers = {}\n" + " periods = {}\n" + " nodelay = {}\n".format(nodes, nlay, nper, ncol) + ) + return s + @classmethod def load( cls, @@ -385,6 +410,7 @@ def load( # return model object return ml + def fmt_string(array): """ Returns a C-style fmt string for numpy savetxt that corresponds to diff --git a/flopy/modflow/mfdisu.py b/flopy/modflowusg/mfusgdisu.py similarity index 98% rename from flopy/modflow/mfdisu.py rename to flopy/modflowusg/mfusgdisu.py index e967614d24..299367156c 100644 --- a/flopy/modflow/mfdisu.py +++ b/flopy/modflowusg/mfusgdisu.py @@ -1,6 +1,6 @@ """ -mfdisu module. Contains the ModflowDisU class. Note that the user can access -the ModflowDisU class as `flopy.modflow.ModflowDisU`. +mfdisu module. Contains the ModflowUsgDisU class. Note that the user can access +the ModflowUsgDisU class as `flopy.modflow.ModflowUsgDisU`. """ import numpy as np @@ -13,7 +13,7 @@ LENUNI = {"u": 0, "f": 1, "m": 2, "c": 3} -class ModflowDisU(Package): +class ModflowUsgDisU(Package): """ MODFLOW Unstructured Discretization Package Class. @@ -192,7 +192,7 @@ class ModflowDisU(Package): >>> import flopy >>> m = flopy.modflow.Modflow() - >>> disu = flopy.modflow.ModflowDisU(m) + >>> disu = flopy.modflow.ModflowUsgDisU(m) """ @@ -231,7 +231,7 @@ def __init__( # set default unit number of one is not specified if unitnumber is None: - unitnumber = ModflowDisU._defaultunit() + unitnumber = ModflowUsgDisU._defaultunit() # set filenames if filenames is None: @@ -240,7 +240,7 @@ def __init__( filenames = [filenames] # Fill namefile items - name = [ModflowDisU._ftype()] + name = [ModflowUsgDisU._ftype()] units = [unitnumber] extra = [""] @@ -536,15 +536,15 @@ def load(cls, f, model, ext_unit_dict=None, check=True): Returns ------- - dis : ModflowDisU object - ModflowDisU object. + dis : ModflowUsgDisU object + ModflowUsgDisU object. Examples -------- >>> import flopy >>> m = flopy.modflow.Modflow() - >>> disu = flopy.modflow.ModflowDisU.load('test.disu', m) + >>> disu = flopy.modflow.ModflowUsgDisU.load('test.disu', m) """ @@ -775,7 +775,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): filenames = [None] if ext_unit_dict is not None: unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowDisU._ftype() + ext_unit_dict, filetype=ModflowUsgDisU._ftype() ) # create dis object instance diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index e1c6dbbb38..d141a29a6e 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -396,7 +396,7 @@ def __init__( (njag,), np.float32, ksat, - "saturated conductivity or transmissivity", + "ksat", locat=self.unit_number[0], ) diff --git a/flopy/modflowusg/mfusgsms.py b/flopy/modflowusg/mfusgsms.py index 85b844762c..f7887e39db 100644 --- a/flopy/modflowusg/mfusgsms.py +++ b/flopy/modflowusg/mfusgsms.py @@ -8,6 +8,7 @@ from ..pakbase import Package from ..utils.flopy_io import line_parse + class ModflowUsgSms(Package): """ MODFLOW Sms Package Class. diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py index eb7bb6ba4e..8e699a4722 100644 --- a/flopy/modflowusg/mfusgwel.py +++ b/flopy/modflowusg/mfusgwel.py @@ -8,6 +8,7 @@ """ import numpy as np +from copy import deepcopy from ..utils import MfList from ..pakbase import Package from ..utils.recarray_utils import create_empty_recarray @@ -335,7 +336,7 @@ def write_file(self, f=None): if kper < first: itmp = 0 elif kper in kpers: - kper_data = self.stress_period_data.data[kper] + kper_data = deepcopy(self.stress_period_data.data[kper]) kper_vtype = self.stress_period_data.vtype[kper] if kper_vtype == np.recarray: itmp = kper_data.shape[0] @@ -353,7 +354,9 @@ def write_file(self, f=None): if kper < cln_first: itmpcln = 0 elif kper in cln_kpers: - cln_kper_data = self.cln_stress_period_data.data[kper] + cln_kper_data = deepcopy( + self.cln_stress_period_data.data[kper] + ) cln_kper_vtype = self.cln_stress_period_data.vtype[kper] if cln_kper_vtype == np.recarray: itmpcln = cln_kper_data.shape[0] @@ -506,7 +509,7 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): options.append(toption.lower()) elif toption.lower() == "iunitafr": options.append(" ".join(t[it : it + 2])) - iunitafr = t[it + 1] + iunitafr = int(t[it + 1]) it += 1 elif "aux" in toption.lower(): options.append(" ".join(t[it : it + 2])) @@ -685,6 +688,7 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): # set package unit number filenames = [None, None, None] + unitnumber = ModflowUsgWel._defaultunit() if ext_unit_dict is not None: unitnumber, filenames[0] = model.get_ext_dict_attr( ext_unit_dict, filetype=ModflowUsgWel._ftype() diff --git a/flopy/utils/gridgen.py b/flopy/utils/gridgen.py index d20f198ff6..5d414f7967 100644 --- a/flopy/utils/gridgen.py +++ b/flopy/utils/gridgen.py @@ -3,7 +3,7 @@ import subprocess # flopy imports -from ..modflow.mfdisu import ModflowDisU +from ..modflowusg.mfusgdisu import ModflowUsgDisU from ..mf6.modflow import ModflowGwfdis from .util_array import Util2d # read1d, from ..export.shapefile_utils import import_shapefile, shp2recarray @@ -912,7 +912,7 @@ def get_disu( f.close() # create dis object instance - disu = ModflowDisU( + disu = ModflowUsgDisU( model, nodes=nodes, nlay=nlay, From 79345a7dece1cec4fde61b05d68c8efefcefd35c Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Tue, 28 Sep 2021 14:29:55 +1000 Subject: [PATCH 03/14] refactor(modflowusg/mfusglpf) mfusglpf inherit from mflpf --- flopy/modflow/mflpf.py | 23 +---- flopy/modflowusg/mfusgdisu.py | 14 +-- flopy/modflowusg/mfusglpf.py | 177 +++++++--------------------------- 3 files changed, 46 insertions(+), 168 deletions(-) diff --git a/flopy/modflow/mflpf.py b/flopy/modflow/mflpf.py index e58df37d78..ebbb997e7e 100644 --- a/flopy/modflow/mflpf.py +++ b/flopy/modflow/mflpf.py @@ -262,7 +262,6 @@ def __init__( hdry # Head in cells that are converted to dry during a simulation ) self.nplpf = 0 # number of LPF parameters - self.ikcflag = 0 # 1 and -1 are not supported. self.laytyp = Util2d(model, (nlay,), np.int32, laytyp, name="laytyp") self.layavg = Util2d(model, (nlay,), np.int32, layavg, name="layavg") self.chani = Util2d(model, (nlay,), np.float32, chani, name="chani") @@ -390,21 +389,10 @@ def write_file(self, check=True, f=None): # Item 0: text f.write(f"{self.heading}\n") - # Item 1: IBCFCB, HDRY, NPLPF, , OPTIONS - if self.parent.version == "mfusg" and self.parent.structured == False: - f.write( - "{0:10d}{1:10.6G}{2:10d}{3:10d} {4:s}\n".format( - self.ipakcb, - self.hdry, - self.nplpf, - self.ikcflag, - self.options, - ) - ) - else: - f.write( - f"{self.ipakcb:10d}{self.hdry:10.6G}{self.nplpf:10d} {self.options}\n" - ) + # Item 1: IBCFCB, HDRY, NPLPF, OPTIONS + f.write( + f"{self.ipakcb:10d}{self.hdry:10.6G}{self.nplpf:10d} {self.options}\n" + ) # LAYTYP array f.write(self.laytyp.string) # LAYAVG array @@ -497,9 +485,6 @@ def load(cls, f, model, ext_unit_dict=None, check=True): t = line_parse(line) ipakcb, hdry, nplpf = int(t[0]), float(t[1]), int(t[2]) item1_len = 3 - if model.version == "mfusg" and model.structured == False: - ikcflag = int(t[3]) - item1_len = 4 # if ipakcb != 0: # model.add_pop_key_list(ipakcb) # ipakcb = 53 diff --git a/flopy/modflowusg/mfusgdisu.py b/flopy/modflowusg/mfusgdisu.py index 299367156c..079c0a10d4 100644 --- a/flopy/modflowusg/mfusgdisu.py +++ b/flopy/modflowusg/mfusgdisu.py @@ -1,6 +1,6 @@ """ mfdisu module. Contains the ModflowUsgDisU class. Note that the user can access -the ModflowUsgDisU class as `flopy.modflow.ModflowUsgDisU`. +the ModflowUsgDisU class as `flopy.modflowusg.ModflowUsgDisU`. """ import numpy as np @@ -20,7 +20,7 @@ class ModflowUsgDisU(Package): Parameters ---------- model : model object - The model object (of type :class:`flopy.modflow.Modflow`) to which + The model object (of type :class:`flopy.modflowusg.ModflowUsg`) to which this package will be added. nodes : int Number of nodes in the model grid (default is 2). @@ -191,8 +191,8 @@ class ModflowUsgDisU(Package): -------- >>> import flopy - >>> m = flopy.modflow.Modflow() - >>> disu = flopy.modflow.ModflowUsgDisU(m) + >>> m = flopy.modflowusg.ModflowUsg() + >>> disu = flopy.modflowusg.ModflowUsgDisU(m) """ @@ -523,7 +523,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): f : filename or file handle File to load. model : model object - The model object (of type :class:`flopy.modflow.mf.Modflow`) to + The model object (of type :class:`flopy.modflowusg.ModflowUsg`) to which this package will be added. ext_unit_dict : dictionary, optional If the arrays in the file are specified using EXTERNAL, @@ -543,8 +543,8 @@ def load(cls, f, model, ext_unit_dict=None, check=True): -------- >>> import flopy - >>> m = flopy.modflow.Modflow() - >>> disu = flopy.modflow.ModflowUsgDisU.load('test.disu', m) + >>> m = flopy.modflowusg.ModflowUsg() + >>> disu = flopy.modflowusg.ModflowUsgDisU.load('test.disu', m) """ diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index d141a29a6e..16a4b5d736 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -9,20 +9,20 @@ """ import numpy as np from ..modflow.mfpar import ModflowPar as mfpar +from ..modflow.mflpf import ModflowLpf -from ..pakbase import Package from ..utils import Util2d, Util3d, read1d from ..utils.flopy_io import line_parse -class ModflowUsgLpf(Package): +class ModflowUsgLpf(ModflowLpf): """ MODFLOW Layer Property Flow Package Class. Parameters ---------- model : model object - The model object (of type :class:`flopy.modflow.mf.Modflow`) to which + The model object (of type :class:`flopy.modflowusg.mfusg.ModflowUsg`) to which this package will be added. ipakcb : int A flag that is used to determine if cell-by-cell budget data should be @@ -188,6 +188,7 @@ class ModflowUsgLpf(Package): >>> import flopy >>> m = flopy.modflowusg.ModflowUsg() + >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> lpf = flopy.modflowusg.ModflowUsgLpf(m) """ @@ -228,78 +229,44 @@ def __init__( filenames=None, ): - # set default unit number of one is not specified - if unitnumber is None: - unitnumber = ModflowUsgLpf._defaultunit() - - # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) - - # update external file information with cbc output, if necessary - if ipakcb is not None: - fname = filenames[1] - model.add_output_file( - ipakcb, fname=fname, package=ModflowUsgLpf._ftype() - ) - else: - ipakcb = 0 - - # Fill namefile items - name = [ModflowUsgLpf._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + super().__init__( model, + laytyp=laytyp, + layavg=layavg, + chani=chani, + layvka=layvka, + laywet=laywet, + ipakcb=ipakcb, + hdry=hdry, + iwdflg=iwdflg, + wetfct=wetfct, + iwetit=iwetit, + ihdwet=ihdwet, + hk=hk, + hani=hani, + vka=vka, + ss=ss, + sy=sy, + vkcb=vkcb, + wetdry=wetdry, + storagecoefficient=storagecoefficient, + constantcv=constantcv, + thickstrt=thickstrt, + nocvcorrection=nocvcorrection, + novfc=novfc, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + unitnumber=unitnumber, + filenames=filenames, ) - self._generate_heading() - self.url = "lpf.htm" - nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper - dis = model.get_package("DIS") if dis is None: dis = model.get_package("DISU") structured = self.parent.structured - # item 1 - self.ipakcb = ipakcb - self.hdry = ( - hdry # Head in cells that are converted to dry during a simulation - ) - self.nplpf = 0 # number of LPF parameters - self.ikcflag = ikcflag # unstructured grid + self.ikcflag = ikcflag if structured: self.ikcflag = 0 - self.laytyp = Util2d(model, (nlay,), np.int32, laytyp, name="laytyp") - self.layavg = Util2d(model, (nlay,), np.int32, layavg, name="layavg") - self.chani = Util2d(model, (nlay,), np.float32, chani, name="chani") - self.layvka = Util2d(model, (nlay,), np.int32, layvka, name="layvka") - self.laywet = Util2d(model, (nlay,), np.int32, laywet, name="laywet") - # Factor that is included in the calculation of the head when a cell is - # converted from dry to wet - self.wetfct = wetfct - # Iteration interval for attempting to wet cells - self.iwetit = iwetit - # Flag that determines which equation is used to define the initial - # head at cells that become wet - self.ihdwet = ihdwet self.options = " " if storagecoefficient: self.options = self.options + "STORAGECOEFFICIENT " @@ -319,76 +286,10 @@ def __init__( (njag,), np.float32, anglex, - "Transmissivity", + "anglex", locat=self.unit_number[0], ) - self.hk = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - hk, - name="hk", - locat=self.unit_number[0], - ) - self.hani = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - hani, - name="hani", - locat=self.unit_number[0], - ) - keys = [] - for k in range(nlay): - key = "vka" - if self.layvka[k] != 0: - key = "vani" - keys.append(key) - self.vka = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - vka, - name=keys, - locat=self.unit_number[0], - ) - tag = "ss" - if storagecoefficient: - tag = "storage" - self.ss = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - ss, - name=tag, - locat=self.unit_number[0], - ) - self.sy = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - sy, - name="sy", - locat=self.unit_number[0], - ) - self.vkcb = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - vkcb, - name="vkcb", - locat=self.unit_number[0], - ) - self.wetdry = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - wetdry, - name="wetdry", - locat=self.unit_number[0], - ) - if not structured: njag = dis.njag self.ksat = Util2d( @@ -492,7 +393,7 @@ def write_file(self, check=True, f=None): f.write(self.wetdry[k].get_file_entry()) if self.ikcflag == 1 or self.ikcflag == -1: - f_bcf.write(self.ksat[k].get_file_entry()) + f.write(self.ksat[k].get_file_entry()) f.close() return @@ -788,9 +689,9 @@ def load(cls, f, model, ext_unit_dict=None, check=True): wetdry[k] = t # Ksat mfusg - if ikcflag == 1 or ikcflag == -1: + if abs(ikcflag) == 1: if model.verbose: - print(f" loading ksat layer {k + 1:3d}...") + print(f" loading ksat...") t = Util2d.load( f, model, (njag,), np.float32, "ksat", ext_unit_dict ) @@ -853,11 +754,3 @@ def load(cls, f, model, ext_unit_dict=None, check=True): level=0, ) return lpf - - @staticmethod - def _ftype(): - return "LPF" - - @staticmethod - def _defaultunit(): - return 15 From 5404b430377cdb819776d08a1d5c18c66297629a Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Wed, 29 Sep 2021 16:02:10 +1000 Subject: [PATCH 04/14] refactor(modflowusg/mfusgwel) mfusgwel inherit from mfwel --- flopy/mbase.py | 2 + flopy/modflow/mfbcf.py | 5 +- flopy/modflow/mflpf.py | 3 +- flopy/modflow/mfwel.py | 6 +- flopy/modflowusg/mfusgbcf.py | 202 +++++++++-------------------------- flopy/modflowusg/mfusglpf.py | 5 +- flopy/modflowusg/mfusgwel.py | 141 +++++------------------- 7 files changed, 91 insertions(+), 273 deletions(-) diff --git a/flopy/mbase.py b/flopy/mbase.py index 08b4af5c14..c7bcb9e2af 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -646,6 +646,8 @@ def __getattr__(self, item): if item == "nper": if self.dis is not None: return self.dis.nper + elif self.disu is not None: + return self.disu.nper else: return 0 diff --git a/flopy/modflow/mfbcf.py b/flopy/modflow/mfbcf.py index 137ca76183..30c45d773e 100644 --- a/flopy/modflow/mfbcf.py +++ b/flopy/modflow/mfbcf.py @@ -161,7 +161,7 @@ def __init__( (nlay,), np.int32, intercellt, - name="laycon", + name="intercellt", locat=self.unit_number[0], ) self.laycon = Util2d( @@ -239,7 +239,8 @@ def __init__( "WETDRY", locat=self.unit_number[0], ) - self.parent.add_package(self) + if self.parent.version != "mfusg": + self.parent.add_package(self) return def write_file(self, f=None): diff --git a/flopy/modflow/mflpf.py b/flopy/modflow/mflpf.py index ebbb997e7e..43d4d249a4 100644 --- a/flopy/modflow/mflpf.py +++ b/flopy/modflow/mflpf.py @@ -351,7 +351,8 @@ def __init__( name="wetdry", locat=self.unit_number[0], ) - self.parent.add_package(self) + if self.parent.version != "mfusg": + self.parent.add_package(self) return def write_file(self, check=True, f=None): diff --git a/flopy/modflow/mfwel.py b/flopy/modflow/mfwel.py index 8345da2202..2ee4c54169 100644 --- a/flopy/modflow/mfwel.py +++ b/flopy/modflow/mfwel.py @@ -156,6 +156,7 @@ def __init__( # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowWel._defaultunit() + self.unitnumber = unitnumber # set filenames if filenames is None: @@ -165,6 +166,7 @@ def __init__( elif isinstance(filenames, list): if len(filenames) < 2: filenames.append(None) + self.filenames = filenames # update external file information with cbc output, if necessary if ipakcb is not None: @@ -257,8 +259,8 @@ def __init__( self.stress_period_data = MfList( self, stress_period_data, binary=binary ) - - self.parent.add_package(self) + if self.parent.version != "mfusg": + self.parent.add_package(self) def _ncells(self): """Maximum number of cells that have wells (developed for diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py index 82ddc75f60..057a3b72c4 100644 --- a/flopy/modflowusg/mfusgbcf.py +++ b/flopy/modflowusg/mfusgbcf.py @@ -5,12 +5,12 @@ """ import numpy as np -from ..pakbase import Package +from ..modflow import ModflowBcf from ..utils import Util2d, Util3d from ..utils.flopy_io import line_parse -class ModflowUsgBcf(Package): +class ModflowUsgBcf(ModflowBcf): """ Block Centered Flow (BCF) Package Class for MODFLOW-USG. @@ -109,7 +109,8 @@ class ModflowUsgBcf(Package): -------- >>> import flopy - >>> ml = flopy.modflow.Modflow() + >>> ml = flopy.modflowusg.ModflowUsg() + >>> disu = flopy.modflowusg.ModflowUsgDisU(model=ml, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> bcf = flopy.modflowusg.ModflowUsgBcf(ml) """ @@ -142,78 +143,35 @@ def __init__( filenames=None, ): - if unitnumber is None: - unitnumber = ModflowUsgBcf._defaultunit() - - # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) - - # update external file information with cbc output, if necessary - if ipakcb is not None: - fname = filenames[1] - model.add_output_file( - ipakcb, fname=fname, package=ModflowUsgBcf._ftype() - ) - else: - ipakcb = 0 - - # Fill namefile items - name = [ModflowUsgBcf._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + super().__init__( model, + ipakcb=ipakcb, + intercellt=intercellt, + laycon=laycon, + trpy=trpy, + hdry=hdry, + iwdflg=iwdflg, + wetfct=wetfct, + iwetit=iwetit, + ihdwet=ihdwet, + tran=tran, + hy=hy, + vcont=vcont, + sf1=sf1, + sf2=sf2, + wetdry=wetdry, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + unitnumber=unitnumber, + filenames=filenames, ) - self.url = "bcf.htm" - - nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper dis = model.get_package("DIS") if dis is None: dis = model.get_package("DISU") structured = self.parent.structured - # Set values of all parameters - self.intercellt = Util2d( - model, - (nlay,), - np.int32, - intercellt, - name="laycon", - locat=self.unit_number[0], - ) - self.laycon = Util2d( - model, - (nlay,), - np.int32, - laycon, - name="laycon", - locat=self.unit_number[0], - ) - self.trpy = Util2d( - model, - (nlay,), - np.float32, - trpy, - name="Anisotropy factor", - locat=self.unit_number[0], - ) + + nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + if not structured: njag = dis.njag self.anglex = Util2d( @@ -221,86 +179,30 @@ def __init__( (njag,), np.float32, anglex, - "Transmissivity", + "anglex", locat=self.unit_number[0], ) # item 1 - self.ipakcb = ipakcb - self.hdry = hdry - self.iwdflg = iwdflg - self.wetfct = wetfct - self.iwetit = iwetit - self.ihdwet = ihdwet self.ikvflag = ikvflag self.ikcflag = ikcflag - self.tran = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - tran, - "Transmissivity", - locat=self.unit_number[0], - ) - self.hy = Util3d( + self.kv = Util3d( model, (nlay, nrow, ncol), np.float32, - hy, - "Horizontal Hydraulic Conductivity", + kv, + "Vertical Hydraulic Conductivity", locat=self.unit_number[0], ) - if model.nlay > 1: - self.vcont = Util3d( + if not structured: + self.ksat = Util3d( model, - (nlay - 1, nrow, ncol), + (njag,), np.float32, - vcont, - "Vertical Conductance", + ksat, + "ksat", locat=self.unit_number[0], ) - else: - self.vcont = None - self.kv = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - kv, - "Vertical Hydraulic Conductivity", - locat=self.unit_number[0], - ) - self.sf1 = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - sf1, - "Primary Storage Coefficient", - locat=self.unit_number[0], - ) - self.sf2 = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - sf2, - "Secondary Storage Coefficient", - locat=self.unit_number[0], - ) - self.wetdry = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - wetdry, - "WETDRY", - locat=self.unit_number[0], - ) - self.ksat = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - ksat, - "saturated conductivity or transmissivity", - locat=self.unit_number[0], - ) self.parent.add_package(self) return @@ -384,8 +286,8 @@ def write_file(self, f=None): (self.laycon[k] == 1) or (self.laycon[k] == 3) ): f_bcf.write(self.wetdry[k].get_file_entry()) - if (self.ikcflag == 1) or (self.ikcflag == -1): - f_bcf.write(self.ksat[k].get_file_entry()) + if abs(self.ikcflag == 1): + f_bcf.write(self.ksat.get_file_entry()) f_bcf.close() @@ -417,7 +319,8 @@ def load(cls, f, model, ext_unit_dict=None): -------- >>> import flopy - >>> m = flopy.modflow.Modflow() + >>> m = flopy.modflowusg.ModflowUsg() + >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> bcf = flopy.modflowusg.ModflowUsgBcf.load('test.bcf', m) """ @@ -441,6 +344,7 @@ def load(cls, f, model, ext_unit_dict=None): dis = model.get_package("DIS") if dis is None: dis = model.get_package("DISU") + njag = dis.njag structured = model.structured @@ -529,7 +433,6 @@ def load(cls, f, model, ext_unit_dict=None): anis = True break if (not structured) and anis: - njag = dis.njag if model.verbose: print("mfusg: loading ANGLEX...") t = Util2d.load( @@ -549,7 +452,6 @@ def load(cls, f, model, ext_unit_dict=None): sf2 = [0] * nlay wetdry = [0] * nlay kv = [0] * nlay # mfusg - ksat = [0] * nlay # mfusg for k in range(nlay): @@ -633,14 +535,16 @@ def load(cls, f, model, ext_unit_dict=None): ) wetdry[k] = t - # Ksat mfusg - if (ikcflag == 1) or (ikcflag == -1): - if model.verbose: - print(f" loading ksat layer {k + 1:3d}...") - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "ksat", ext_unit_dict - ) - ksat[k] = t + # Ksat mfusg + if (not structured) and abs(ikcflag == 1): + if model.verbose: + print(f" loading ksat layer {k + 1:3d}...") + t = Util2d.load( + f, model, (njag,), np.float32, "ksat", ext_unit_dict + ) + ksat = t + else: + ksat = 0 if openfile: f.close() @@ -687,11 +591,3 @@ def load(cls, f, model, ext_unit_dict=None): # return bcf object return bcf - - @staticmethod - def _ftype(): - return "BCF6" - - @staticmethod - def _defaultunit(): - return 15 diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index 16a4b5d736..e2c6769c61 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -392,8 +392,8 @@ def write_file(self, check=True, f=None): if self.laywet[k] != 0 and self.laytyp[k] != 0: f.write(self.wetdry[k].get_file_entry()) - if self.ikcflag == 1 or self.ikcflag == -1: - f.write(self.ksat[k].get_file_entry()) + if abs(self.ikcflag == 1): + f.write(self.ksat.get_file_entry()) f.close() return @@ -429,6 +429,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): >>> import flopy >>> m = flopy.modflowusg.ModflowUsg() + >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> lpf = flopy.modflowusg.ModflowUsgLpf.load('test.lpf', m) """ diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py index 8e699a4722..196f127b6e 100644 --- a/flopy/modflowusg/mfusgwel.py +++ b/flopy/modflowusg/mfusgwel.py @@ -11,6 +11,7 @@ from copy import deepcopy from ..utils import MfList from ..pakbase import Package +from ..modflow.mfwel import ModflowWel from ..utils.recarray_utils import create_empty_recarray from ..utils.flopy_io import ulstrd import warnings @@ -18,7 +19,7 @@ from ..modflow.mfparbc import ModflowParBc as mfparbc -class ModflowUsgWel(Package): +class ModflowUsgWel(ModflowWel): """ MODFLOW Well Package Class. @@ -110,6 +111,8 @@ class ModflowUsgWel(Package): [iclnnode, flux] ] } + dtype : custom datatype of stress_period_data. + If None the default well datatype will be applied (default is None). extension : string Filename extension (default is 'wel') options : list of strings @@ -149,7 +152,7 @@ class ModflowUsgWel(Package): -------- >>> import flopy - >>> m = flopy.modflow.Modflow() + >>> m = flopy.modflowusg.ModflowUsg() >>> lrcq = {0:[[2, 3, 4, -100.]], 1:[[2, 3, 4, -100.]]} >>> wel = flopy.modflowusg.ModflowUsgWel(m, stress_period_data=lrcq) @@ -161,6 +164,7 @@ def __init__( ipakcb=None, stress_period_data=None, cln_stress_period_data=None, + dtype=None, extension="wel", options=None, binary=False, @@ -171,70 +175,31 @@ def __init__( Package constructor. """ - # set default unit number of one is not specified - if unitnumber is None: - unitnumber = ModflowUsgWel._defaultunit() - - # set filenames - if filenames is None: - filenames = [None, None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None] - elif isinstance(filenames, list): - if len(filenames) < 3: - for idx in range(len(filenames), 3): - filenames.append(None) - - # update external file information with cbc output, if necessary - if ipakcb is not None: - fname = filenames[1] - model.add_output_file( - ipakcb, fname=fname, package=ModflowUsgWel._ftype() - ) - else: - ipakcb = 0 - - # Fill namefile items - name = [ModflowUsgWel._ftype()] - units = [unitnumber] - extra = [""] - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + super().__init__( model, + ipakcb=ipakcb, + stress_period_data=stress_period_data, + dtype=dtype, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + options=options, + binary=binary, + unitnumber=unitnumber, + filenames=filenames, ) - self._generate_heading() - self.url = "wel.htm" - - self.ipakcb = ipakcb - - if options is None: - options = [] - self.autoflowreduce = False self.iunitafr = 0 - self.options = options - for idx, opt in enumerate(options): - if "autoflowreduce" in opt: + for idx, opt in enumerate(self.options): + if "autoflowreduce" in opt.lower(): self.autoflowreduce = True - if "iunitafr" in opt: + if "iunitafr" in opt.lower(): t = opt.strip().split() self.iunitafr = int(t[1]) if self.iunitafr > 0: - fname = filenames[2] + fname = self.filenames[1] model.add_output_file( self.iunitafr, fname=fname, @@ -243,31 +208,21 @@ def __init__( package=ModflowUsgWel._ftype(), ) - # initialize MfList - self.dtype = ModflowUsgWel.get_default_dtype(model.structured) - self.stress_period_data = MfList( - self, stress_period_data, binary=binary - ) - - self.dtype = ModflowUsgWel.get_default_dtype(structured=False) + # initialize CLN MfList + # CLN WELs are always read as CLNNODE Q, so dtype must be of unstructured form + dtype_model = self.dtype + dtype_cln = ModflowUsgWel.get_default_dtype(structured=False) + self.dtype = dtype_cln self.cln_stress_period_data = MfList( self, cln_stress_period_data, binary=binary ) + # reset self.dtype for cases where the model is structured but CLN WELs are used + self.dtype = ModflowUsgWel.get_default_dtype( + structured=model.structured + ) self.parent.add_package(self) - def _ncells(self): - """Maximum number of cells that have wells (developed for - MT3DMS SSM package). - - Returns - ------- - ncells: int - maximum number of wel cells - - """ - return self.stress_period_data.mxact - def write_file(self, f=None): """ Write the package file. @@ -385,39 +340,6 @@ def write_file(self, f=None): f_wel.close() - def add_record(self, kper, index, values): - try: - self.stress_period_data.add_record(kper, index, values) - except Exception as e: - raise Exception(f"mfwel error adding record to list: {e!s}") - - @staticmethod - def get_default_dtype(structured=True): - if structured: - dtype = np.dtype( - [ - ("k", int), - ("i", int), - ("j", int), - ("flux", np.float32), - ] - ) - else: - dtype = np.dtype([("node", int), ("flux", np.float32)]) - return dtype - - @staticmethod - def get_empty(ncells=0, aux_names=None, structured=True): - # get an empty recarray that corresponds to dtype - dtype = ModflowUsgWel.get_default_dtype(structured=structured) - if aux_names is not None: - dtype = Package.add_to_dtype(dtype, aux_names, np.float32) - return create_empty_recarray(ncells, dtype, default_value=-1.0e10) - - @staticmethod - def _get_sfac_columns(): - return ["flux"] - @classmethod def load(cls, f, model, nper=None, ext_unit_dict=None): """ @@ -709,17 +631,10 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): ipakcb=ipakcb, stress_period_data=stress_period_data, cln_stress_period_data=cln_stress_period_data, + dtype=ModflowUsgWel.get_default_dtype(structured=model.structured), options=options, unitnumber=unitnumber, filenames=filenames, ) return wel - - @staticmethod - def _ftype(): - return "WEL" - - @staticmethod - def _defaultunit(): - return 20 From 6648d9f0349db3278296791ea150eab04192d934 Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Thu, 30 Sep 2021 09:52:56 +1000 Subject: [PATCH 05/14] refactor(mfbcf,mflpf,mfwel) Generalise add_package option on initialisation --- flopy/mbase.py | 2 -- flopy/modflow/mfbcf.py | 6 +++++- flopy/modflow/mflpf.py | 7 +++++-- flopy/modflow/mfwel.py | 6 +++++- flopy/modflowusg/mfusgbcf.py | 10 +++++++++- flopy/modflowusg/mfusglpf.py | 10 ++++++++-- flopy/modflowusg/mfusgwel.py | 10 +++++++++- 7 files changed, 41 insertions(+), 10 deletions(-) diff --git a/flopy/mbase.py b/flopy/mbase.py index c7bcb9e2af..08b4af5c14 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -646,8 +646,6 @@ def __getattr__(self, item): if item == "nper": if self.dis is not None: return self.dis.nper - elif self.disu is not None: - return self.disu.nper else: return 0 diff --git a/flopy/modflow/mfbcf.py b/flopy/modflow/mfbcf.py index 30c45d773e..2bb1b1d3e0 100644 --- a/flopy/modflow/mfbcf.py +++ b/flopy/modflow/mfbcf.py @@ -70,6 +70,9 @@ class ModflowBcf(Package): number greater than zero. To define the names for all package files (input and output) the length of the list of strings should be 2. Default is None. + add_package : bool + Flag to add the initialised package object to the parent model object. + Default is True. Methods ------- @@ -110,6 +113,7 @@ def __init__( extension="bcf", unitnumber=None, filenames=None, + add_package=True, ): if unitnumber is None: @@ -239,7 +243,7 @@ def __init__( "WETDRY", locat=self.unit_number[0], ) - if self.parent.version != "mfusg": + if add_package: self.parent.add_package(self) return diff --git a/flopy/modflow/mflpf.py b/flopy/modflow/mflpf.py index 43d4d249a4..d331c3a74a 100644 --- a/flopy/modflow/mflpf.py +++ b/flopy/modflow/mflpf.py @@ -155,7 +155,9 @@ class ModflowLpf(Package): number greater than zero. To define the names for all package files (input and output) the length of the list of strings should be 2. Default is None. - + add_package : bool + Flag to add the initialised package object to the parent model object. + Default is True. Attributes ---------- @@ -209,6 +211,7 @@ def __init__( extension="lpf", unitnumber=None, filenames=None, + add_package=True, ): # set default unit number of one is not specified @@ -351,7 +354,7 @@ def __init__( name="wetdry", locat=self.unit_number[0], ) - if self.parent.version != "mfusg": + if add_package: self.parent.add_package(self) return diff --git a/flopy/modflow/mfwel.py b/flopy/modflow/mfwel.py index 2ee4c54169..2aefdae2ad 100644 --- a/flopy/modflow/mfwel.py +++ b/flopy/modflow/mfwel.py @@ -80,6 +80,9 @@ class ModflowWel(Package): number greater than zero. To define the names for all package files (input and output) the length of the list of strings should be 2. Default is None. + add_package : bool + Flag to add the initialised package object to the parent model object. + Default is True. Attributes ---------- @@ -148,6 +151,7 @@ def __init__( binary=False, unitnumber=None, filenames=None, + add_package=True, ): """ Package constructor. @@ -259,7 +263,7 @@ def __init__( self.stress_period_data = MfList( self, stress_period_data, binary=binary ) - if self.parent.version != "mfusg": + if add_package: self.parent.add_package(self) def _ncells(self): diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py index 057a3b72c4..578667c9dc 100644 --- a/flopy/modflowusg/mfusgbcf.py +++ b/flopy/modflowusg/mfusgbcf.py @@ -95,6 +95,9 @@ class ModflowUsgBcf(ModflowBcf): number greater than zero. To define the names for all package files (input and output) the length of the list of strings should be 2. Default is None. + add_package : bool + Flag to add the initialised package object to the parent model object. + Default is True. Methods ------- @@ -141,6 +144,7 @@ def __init__( extension="bcf", unitnumber=None, filenames=None, + add_package=True, ): super().__init__( @@ -163,6 +167,7 @@ def __init__( extension=extension, unitnumber=unitnumber, filenames=filenames, + add_package=False, ) dis = model.get_package("DIS") @@ -203,7 +208,10 @@ def __init__( "ksat", locat=self.unit_number[0], ) - self.parent.add_package(self) + + if add_package: + self.parent.add_package(self) + return def write_file(self, f=None): diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index e2c6769c61..1188dda4ef 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -169,7 +169,9 @@ class ModflowUsgLpf(ModflowLpf): number greater than zero. To define the names for all package files (input and output) the length of the list of strings should be 2. Default is None. - + add_package : bool + Flag to add the initialised package object to the parent model object. + Default is True. Attributes ---------- @@ -227,6 +229,7 @@ def __init__( extension="lpf", unitnumber=None, filenames=None, + add_package=True, ): super().__init__( @@ -257,6 +260,7 @@ def __init__( extension=extension, unitnumber=unitnumber, filenames=filenames, + add_package=False, ) dis = model.get_package("DIS") @@ -301,7 +305,9 @@ def __init__( locat=self.unit_number[0], ) - self.parent.add_package(self) + if add_package: + self.parent.add_package(self) + return def write_file(self, check=True, f=None): diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py index 196f127b6e..60e4c98cef 100644 --- a/flopy/modflowusg/mfusgwel.py +++ b/flopy/modflowusg/mfusgwel.py @@ -130,6 +130,9 @@ class ModflowUsgWel(ModflowWel): number greater than zero. To define the names for all package files (input and output) the length of the list of strings should be 2. Default is None. + add_package : bool + Flag to add the initialised package object to the parent model object. + Default is True. Attributes ---------- @@ -170,6 +173,7 @@ def __init__( binary=False, unitnumber=None, filenames=None, + add_package=True, ): """ Package constructor. @@ -186,6 +190,7 @@ def __init__( binary=binary, unitnumber=unitnumber, filenames=filenames, + add_package=False, ) self.autoflowreduce = False @@ -221,7 +226,10 @@ def __init__( structured=model.structured ) - self.parent.add_package(self) + if add_package: + self.parent.add_package(self) + + return def write_file(self, f=None): """ From 858c96c03bb409997874ffc01b490ea823122f03 Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Thu, 30 Sep 2021 16:38:19 +1000 Subject: [PATCH 06/14] refactor(mf,mfusg per codacy) --- flopy/__init__.py | 19 ++- flopy/mbase.py | 13 +- flopy/modflow/mf.py | 1 + flopy/modflowusg/__init__.py | 14 ++ flopy/modflowusg/mfusg.py | 249 +++++++++++++++++++++-------------- 5 files changed, 195 insertions(+), 101 deletions(-) diff --git a/flopy/__init__.py b/flopy/__init__.py index b19eb44d29..b11a80be9d 100644 --- a/flopy/__init__.py +++ b/flopy/__init__.py @@ -17,7 +17,6 @@ specify these boundary conditions. FloPy is an open-source project and any assistance is welcomed. Please email the development team if you want to contribute. - """ from .version import __version__, __author__, __author_email__ @@ -37,3 +36,21 @@ from . import discretization from .mbase import run_model, which + +__all__ = [ + " __version__", + "__author__", + "__author_email__" "modflow", + "mt3d", + "seawat", + "modpath", + "modflowlgr" "modflowusg", + "utils", + "plot", + "export", + "pest", + "mf6", + "discretization", + "run_model", + "which", +] diff --git a/flopy/mbase.py b/flopy/mbase.py index 08b4af5c14..0a7c3e17a7 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -2,8 +2,8 @@ mbase module This module contains the base model class from which all of the other models inherit from. - """ + import abc import os import shutil @@ -20,6 +20,7 @@ from .version import __version__ from .discretization.grid import Grid + ## Global variables # Multiplier for individual array elements in integer and real arrays read by # MODFLOW's U2DREL, U1DREL and U2DINT. @@ -27,6 +28,16 @@ # Printout flag. If >= 0 then array values read are printed in listing file. iprn = -1 +# external exceptions for users +class PackageLoadException(Exception): + """ + FloPy package load exception + """ + + def __init__(self, error, location=""): + self.message = error + super().__init__(f"{error} ({location})") + class FileDataEntry: def __init__(self, fname, unit, binflag=False, output=False, package=None): diff --git a/flopy/modflow/mf.py b/flopy/modflow/mf.py index 6e2c1f97e3..cb39448599 100644 --- a/flopy/modflow/mf.py +++ b/flopy/modflow/mf.py @@ -6,6 +6,7 @@ import os import flopy +import warnings from inspect import getfullargspec from ..mbase import BaseModel from ..pakbase import Package diff --git a/flopy/modflowusg/__init__.py b/flopy/modflowusg/__init__.py index dc855cb5ad..ba349bd612 100644 --- a/flopy/modflowusg/__init__.py +++ b/flopy/modflowusg/__init__.py @@ -1,3 +1,5 @@ +"""Initialize modflowusg""" + from .mfusg import ModflowUsg from .mfusgdisu import ModflowUsgDisU from .mfusgbcf import ModflowUsgBcf @@ -7,3 +9,15 @@ from .mfusgbct import ModflowUsgBct from .mfusgsms import ModflowUsgSms from .mfusggnc import ModflowUsgGnc + +__all__ = [ + "ModflowUsg", + "ModflowUsgDisU", + "ModflowUsgBcf", + "ModflowUsgLpf", + "ModflowUsgWel", + "ModflowUsgCln", + "ModflowUsgBct", + "ModflowUsgSms", + "ModflowUsgGnc", +] diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py index da9481ab70..15f7ea87f4 100644 --- a/flopy/modflowusg/mfusg.py +++ b/flopy/modflowusg/mfusg.py @@ -1,8 +1,4 @@ -""" -mfusg module. - - -""" +"""mfusg module""" import os import flopy @@ -10,6 +6,7 @@ from ..utils import mfreadnam from ..modflow import Modflow +from ..mbase import PackageLoadException class ModflowUsg(Modflow): @@ -37,6 +34,7 @@ class ModflowUsg(Modflow): verbose : bool, default False Print additional information to the screen. + Attributes ---------- @@ -59,26 +57,34 @@ class ModflowUsg(Modflow): def __init__( self, modelname="modflowusgtest", - namefile_ext="nam", - exe_name="mfusg.exe", structured=True, - listunit=2, model_ws=".", - external_path=None, - verbose=False, - version="mfusg", **kwargs, ): + """Constructs the ModflowUsg object. Overrides the parent Modflow object.""" + + valid_keys_defaults = { + "namefile_ext": "nam", + "exe_name": "mfusg.exe", + "listunit": 2, + "external_path": None, + "verbose": False, + } + for key, default_value in valid_keys_defaults.items(): + setattr(self, key, kwargs.pop(key, default_value)) + + setattr(self, "version", "mfusg") + super().__init__( modelname, - namefile_ext, + self.namefile_ext, version="mfusg", - exe_name=exe_name, + exe_name=self.exe_name, structured=structured, - listunit=listunit, + listunit=self.listunit, model_ws=model_ws, - external_path=external_path, - verbose=verbose, + external_path=self.external_path, + verbose=self.verbose, **kwargs, ) # Create a dictionary to map package with package object. @@ -117,6 +123,7 @@ def __init__( return def __repr__(self): + """Returns a representation of the ModflowUsg object.""" nrow, ncol, nlay, nper = self.get_nrow_ncol_nlay_nper() if nrow is not None: # structured case @@ -182,8 +189,8 @@ def load( -------- >>> import flopy >>> ml = flopy.modflowusg.ModflowUsg.load('model.nam') - """ + # similar to modflow command: if file does not exist , try file.nam namefile_path = os.path.join(model_ws, f) if not os.path.isfile(namefile_path) and os.path.isfile( @@ -211,9 +218,6 @@ def load( **attribs, ) - files_successfully_loaded = [] - files_not_loaded = [] - # read name file ext_unit_dict = mfreadnam.parsenamefile( namefile_path, ml.mfnam_packages, verbose=verbose @@ -253,6 +257,123 @@ def load( if verbose: print(f"ModflowBas6 free format:{ml.free_format_input}\n") + # zone, mult, pval + if "PVAL" in ext_pkg_d: + ml.mfpar.set_pval(ml, ext_unit_dict) + assert ml.pop_key_list.pop() == ext_pkg_d.get("PVAL") + if "ZONE" in ext_pkg_d: + ml.mfpar.set_zone(ml, ext_unit_dict) + assert ml.pop_key_list.pop() == ext_pkg_d.get("ZONE") + if "MULT" in ext_pkg_d: + ml.mfpar.set_mult(ml, ext_unit_dict) + assert ml.pop_key_list.pop() == ext_pkg_d.get("MULT") + + files_successfully_loaded, files_not_loaded = cls._load_packages( + ml, ext_unit_dict, ext_pkg_d, load_only, forgive + ) + + # pop binary output keys and any external file units that are now + # internal + for key in ml.pop_key_list: + try: + ml.remove_external(unit=key) + item = ext_unit_dict.pop(key) + if hasattr(item.filehandle, "close"): + item.filehandle.close() + except KeyError: + if ml.verbose: + print( + f"\nWARNING:\n External file unit {key} does not " + "exist in ext_unit_dict." + ) + + # write message indicating packages that were successfully loaded + if ml.verbose: + print("") + print( + f" The following {len(files_successfully_loaded)} packages " + "were successfully loaded." + ) + for fname in files_successfully_loaded: + print(f" {os.path.basename(fname)}") + if len(files_not_loaded) > 0: + print( + f" The following {len(files_not_loaded)} packages " + "were not loaded." + ) + for fname in files_not_loaded: + print(f" {os.path.basename(fname)}") + if check: + ml.check(f=f"{ml.name}.chk", verbose=ml.verbose, level=0) + + # return model object + return ml + + @staticmethod + def _ext_unit_d_load(ml, ext_unit_dict, ext_unit_d_item): + """ + Method to load a package from an ext_unit_dict item into model + + Parameters + ---------- + ml : ModflowUsg model object for which package in ext_unit_d_item will + be loaded + ext_unit_dict : dict + For each file listed in the name file, a + :class:`flopy.utils.mfreadnam.NamData` instance. + Keyed by unit number. + ext_unit_d_item : :class:`flopy.utils.mfreadnam.NamData` instance. + Must be an item of ext_unit_dict. + """ + + package_load_args = getfullargspec(ext_unit_d_item.package.load)[0] + if "check" in package_load_args: + ext_unit_d_item.package.load( + ext_unit_d_item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + check=False, + ) + else: + ext_unit_d_item.package.load( + ext_unit_d_item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + ) + + @classmethod + def _load_packages(cls, ml, ext_unit_dict, ext_pkg_d, load_only, forgive): + """ + Method to load packages into the MODFLOW-USG Model Class. + For internal class use - should not be called by the user. + + Parameters + ---------- + ml : ModflowUsg model object + ext_unit_dict : dict + For each file listed in the name file, a + :class:`flopy.utils.mfreadnam.NamData` instance. + Keyed by unit number. + ext_pkg_d : dict + key is package name, value is unitnumber + load_only : list, str or None + List of case insensitive packages to load, e.g. ["bas6", "lpf"]. + One package can also be specified, e.g. "rch". Default is None, + which attempts to load all files. An empty list [] will not load + any additional packages than is necessary. At a minimum, "dis" or + "disu" is always loaded. + forgive : bool + Option to raise exceptions on package load failure. + + Returns + ---------- + files_successfully_loaded : + files_not_loaded : + """ + + files_successfully_loaded = [] + files_not_loaded = [] + # load dis dis_key = ext_pkg_d.get("DIS") or ext_pkg_d.get("DISU") if dis_key is None: @@ -286,64 +407,29 @@ def load( "in the ext_unit_dict: " + str(not_found) ) - # zone, mult, pval - if "PVAL" in ext_pkg_d: - ml.mfpar.set_pval(ml, ext_unit_dict) - assert ml.pop_key_list.pop() == ext_pkg_d.get("PVAL") - if "ZONE" in ext_pkg_d: - ml.mfpar.set_zone(ml, ext_unit_dict) - assert ml.pop_key_list.pop() == ext_pkg_d.get("ZONE") - if "MULT" in ext_pkg_d: - ml.mfpar.set_mult(ml, ext_unit_dict) - assert ml.pop_key_list.pop() == ext_pkg_d.get("MULT") - # try loading packages in ext_unit_dict for key, item in ext_unit_dict.items(): if item.package is not None: if item.filetype in load_only: - package_load_args = getfullargspec(item.package.load)[0] if forgive: try: - if "check" in package_load_args: - item.package.load( - item.filehandle, - ml, - ext_unit_dict=ext_unit_dict, - check=False, - ) - else: - item.package.load( - item.filehandle, - ml, - ext_unit_dict=ext_unit_dict, - ) + cls._ext_unit_d_load(ml, ext_unit_dict, item) files_successfully_loaded.append(item.filename) if ml.verbose: print( - f" {item.filetype:4s} package load...success" + f" {item.filetype:4s} package \ + load...success" ) - except Exception as e: + except PackageLoadException as e: ml.load_fail = True if ml.verbose: - print( - f" {item.filetype:4s} package load...failed" + raise PackageLoadException( + message=f" {item.filetype:4s} package \ + load...failed\n {e!s}" ) - print(f" {e!s}") files_not_loaded.append(item.filename) else: - if "check" in package_load_args: - item.package.load( - item.filehandle, - ml, - ext_unit_dict=ext_unit_dict, - check=False, - ) - else: - item.package.load( - item.filehandle, - ml, - ext_unit_dict=ext_unit_dict, - ) + cls._ext_unit_d_load(ml, ext_unit_dict, item) files_successfully_loaded.append(item.filename) if ml.verbose: print( @@ -373,42 +459,7 @@ def load( else: raise KeyError(f"unhandled case: {key}, {item}") - # pop binary output keys and any external file units that are now - # internal - for key in ml.pop_key_list: - try: - ml.remove_external(unit=key) - item = ext_unit_dict.pop(key) - if hasattr(item.filehandle, "close"): - item.filehandle.close() - except KeyError: - if ml.verbose: - print( - f"\nWARNING:\n External file unit {key} does not " - "exist in ext_unit_dict." - ) - - # write message indicating packages that were successfully loaded - if ml.verbose: - print("") - print( - f" The following {len(files_successfully_loaded)} packages " - "were successfully loaded." - ) - for fname in files_successfully_loaded: - print(f" {os.path.basename(fname)}") - if len(files_not_loaded) > 0: - print( - f" The following {len(files_not_loaded)} packages " - "were not loaded." - ) - for fname in files_not_loaded: - print(f" {os.path.basename(fname)}") - if check: - ml.check(f=f"{ml.name}.chk", verbose=ml.verbose, level=0) - - # return model object - return ml + return files_successfully_loaded, files_not_loaded def fmt_string(array): From 23e40521dda8054f1e6f4fae1d8029c41bcfea9e Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Sat, 2 Oct 2021 14:06:20 +1000 Subject: [PATCH 07/14] mfusgbcf linting --- .pylintrc | 3 + flopy/mbase.py | 11 +- flopy/modflow/mf.py | 4 +- flopy/modflowusg/__init__.py | 1 - flopy/modflowusg/mfusg.py | 28 +- flopy/modflowusg/mfusgbcf.py | 530 ++++++++++++++++++++--------------- flopy/modflowusg/mfusglpf.py | 2 +- flopy/pakbase.py | 2 +- flopy/utils/utils_def.py | 40 +++ 9 files changed, 364 insertions(+), 257 deletions(-) diff --git a/.pylintrc b/.pylintrc index d69339662f..5bbe9bd609 100644 --- a/.pylintrc +++ b/.pylintrc @@ -346,6 +346,9 @@ single-line-class-stmt=no # else. single-line-if-stmt=no +# Good variable names which should always be accepted, separated by a comma +good-names=kv,nr,nc + [SIMILARITIES] diff --git a/flopy/mbase.py b/flopy/mbase.py index 0a7c3e17a7..37f579ca92 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -1,5 +1,5 @@ -""" -mbase module +"""mbase module + This module contains the base model class from which all of the other models inherit from. """ @@ -16,11 +16,11 @@ from subprocess import Popen, PIPE, STDOUT import copy import numpy as np + from flopy import utils, discretization from .version import __version__ from .discretization.grid import Grid - ## Global variables # Multiplier for individual array elements in integer and real arrays read by # MODFLOW's U2DREL, U1DREL and U2DINT. @@ -28,11 +28,10 @@ # Printout flag. If >= 0 then array values read are printed in listing file. iprn = -1 + # external exceptions for users class PackageLoadException(Exception): - """ - FloPy package load exception - """ + """FloPy package load exception""" def __init__(self, error, location=""): self.message = error diff --git a/flopy/modflow/mf.py b/flopy/modflow/mf.py index cb39448599..05438cd453 100644 --- a/flopy/modflow/mf.py +++ b/flopy/modflow/mf.py @@ -1,7 +1,5 @@ """ -mf module. Contains the ModflowGlobal, ModflowList, and Modflow classes. - - +mf module. Contains the ModflowGlobal, ModflowList, and Modflow classes. """ import os diff --git a/flopy/modflowusg/__init__.py b/flopy/modflowusg/__init__.py index ba349bd612..eb7174d6d6 100644 --- a/flopy/modflowusg/__init__.py +++ b/flopy/modflowusg/__init__.py @@ -1,5 +1,4 @@ """Initialize modflowusg""" - from .mfusg import ModflowUsg from .mfusgdisu import ModflowUsgDisU from .mfusgbcf import ModflowUsgBcf diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py index 15f7ea87f4..61841353fc 100644 --- a/flopy/modflowusg/mfusg.py +++ b/flopy/modflowusg/mfusg.py @@ -1,10 +1,10 @@ """mfusg module""" - import os import flopy +import warnings from inspect import getfullargspec -from ..utils import mfreadnam +from ..utils import mfreadnam from ..modflow import Modflow from ..mbase import PackageLoadException @@ -51,7 +51,6 @@ class ModflowUsg(Modflow): -------- >>> import flopy >>> usg = flopy.modflowusg.ModflowUsg() - """ def __init__( @@ -61,17 +60,20 @@ def __init__( model_ws=".", **kwargs, ): - """Constructs the ModflowUsg object. Overrides the parent Modflow object.""" + """ + Constructs the ModflowUsg object. - valid_keys_defaults = { + Overrides the parent Modflow object. + """ + valid_args_defaults = { "namefile_ext": "nam", "exe_name": "mfusg.exe", "listunit": 2, "external_path": None, "verbose": False, } - for key, default_value in valid_keys_defaults.items(): - setattr(self, key, kwargs.pop(key, default_value)) + for arg, default_value in valid_args_defaults.items(): + setattr(self, arg, kwargs.pop(arg, default_value)) setattr(self, "version", "mfusg") @@ -190,7 +192,6 @@ def load( >>> import flopy >>> ml = flopy.modflowusg.ModflowUsg.load('model.nam') """ - # similar to modflow command: if file does not exist , try file.nam namefile_path = os.path.join(model_ws, f) if not os.path.isfile(namefile_path) and os.path.isfile( @@ -325,7 +326,6 @@ def _ext_unit_d_load(ml, ext_unit_dict, ext_unit_d_item): ext_unit_d_item : :class:`flopy.utils.mfreadnam.NamData` instance. Must be an item of ext_unit_dict. """ - package_load_args = getfullargspec(ext_unit_d_item.package.load)[0] if "check" in package_load_args: ext_unit_d_item.package.load( @@ -370,7 +370,6 @@ def _load_packages(cls, ml, ext_unit_dict, ext_pkg_d, load_only, forgive): files_successfully_loaded : files_not_loaded : """ - files_successfully_loaded = [] files_not_loaded = [] @@ -424,7 +423,7 @@ def _load_packages(cls, ml, ext_unit_dict, ext_pkg_d, load_only, forgive): ml.load_fail = True if ml.verbose: raise PackageLoadException( - message=f" {item.filetype:4s} package \ + error=f" {item.filetype:4s} package \ load...failed\n {e!s}" ) files_not_loaded.append(item.filename) @@ -467,6 +466,9 @@ def fmt_string(array): Returns a C-style fmt string for numpy savetxt that corresponds to the dtype. + Parameters + ---------- + array : numpy array """ fmts = [] for field in array.dtype.descr: @@ -479,14 +481,14 @@ def fmt_string(array): fmts.append("%10s") elif vtype == "s": msg = ( - "mfcln.fmt_string error: 'str' type found in dtype. " + "mfusg.fmt_string error: 'str' type found in dtype. " "This gives unpredictable results when " "recarray to file - change to 'object' type" ) raise TypeError(msg) else: raise TypeError( - "mfcln.fmt_string error: unknown vtype in " + "mfusg.fmt_string error: unknown vtype in " "field: {}".format(field) ) return "".join(fmts) diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py index 578667c9dc..8a07bb0ae9 100644 --- a/flopy/modflowusg/mfusgbcf.py +++ b/flopy/modflowusg/mfusgbcf.py @@ -1,13 +1,15 @@ -""" -mfusgbcf module. Contains the ModflowUsgBcf class. Note that the user can -access the ModflowUsgBcf class as `flopy.modflowusg.ModflowUsgBcf`. +"""mfusgbcf module. +Contains the ModflowUsgBcf class. Note that the user can +access the ModflowUsgBcf class as `flopy.modflowusg.ModflowUsgBcf`. """ +import warnings import numpy as np from ..modflow import ModflowBcf from ..utils import Util2d, Util3d from ..utils.flopy_io import line_parse +from ..utils.utils_def import get_util2d_shape_for_layer class ModflowUsgBcf(ModflowBcf): @@ -63,20 +65,20 @@ class ModflowUsgBcf(ModflowBcf): (default is 1.0) vcont : float or array of floats (nlay-1, nrow, ncol) vertical leakance between layers (default is 1.0) - kv : float or array of floats (nlay-1, nrow, ncol) + kv : float or array of floats (nlay, nrow, ncol) is the vertical hydraulic conductivity of the cell and the leakance is computed for each vertical connection. sf1 : float or array of floats (nlay, nrow, ncol) specific storage (confined) or storage coefficient (unconfined), read when there is at least one transient stress period. (default is 1e-5) - sf2 : float or array of floats (nrow, ncol) + sf2 : float or array of floats (nlay, nrow, ncol) specific yield, only read when laycon is 2 or 3 and there is at least one transient stress period (default is 0.15) wetdry : float a combination of the wetting threshold and a flag to indicate which neighboring cells can cause a cell to become wet (default is -0.01) - ksat : float or array of floats (nrow, ncol) + ksat : float or array of floats (njag) inter-block saturated hydraulic conductivity or transmissivity (if IKCFLAG = 1) or the inter-block conductance (if IKCFLAG = - 1) of the connection between nodes n and m. @@ -113,60 +115,69 @@ class ModflowUsgBcf(ModflowBcf): >>> import flopy >>> ml = flopy.modflowusg.ModflowUsg() - >>> disu = flopy.modflowusg.ModflowUsgDisU(model=ml, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) - >>> bcf = flopy.modflowusg.ModflowUsgBcf(ml) - - """ + >>> disu = flopy.modflowusg.ModflowUsgDisU(model=ml, nlay=1, nodes=1, + iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) + >>> bcf = flopy.modflowusg.ModflowUsgBcf(ml)""" def __init__( self, model, - ipakcb=None, - intercellt=0, - laycon=3, - trpy=1.0, - hdry=-1e30, - iwdflg=0, - wetfct=0.1, - iwetit=1, - ihdwet=0, - ikvflag=0, - ikcflag=0, - tran=1.0, - hy=1.0, - vcont=1.0, - kv=1.0, - anglex=0.0, - ksat=1.0, - sf1=1e-5, - sf2=0.15, - wetdry=-0.01, - extension="bcf", - unitnumber=None, - filenames=None, - add_package=True, + **kwargs, ): + """ + Constructs the ModflowUsgBcf object. + + Overrides the parent ModflowBcf object.""" + valid_args_defaults = { + "ipakcb": None, + "intercellt": 0, + "laycon": 3, + "trpy": 1.0, + "hdry": -1e30, + "iwdflg": 0, + "wetfct": 0.1, + "iwetit": 1, + "ihdwet": 0, + "ikvflag": 0, + "ikcflag": 0, + "tran": 1.0, + "hy": 1.0, + "vcont": 1.0, + "kv": 1.0, + "anglex": 0.0, + "ksat": 1.0, + "sf1": 1e-5, + "sf2": 0.15, + "wetdry": -0.01, + "extension": "bcf", + "unitnumber": None, + "filenames": None, + "add_package": True, + } + + for arg, default_value in valid_args_defaults.items(): + setattr(self, arg, kwargs.pop(arg, default_value)) super().__init__( model, - ipakcb=ipakcb, - intercellt=intercellt, - laycon=laycon, - trpy=trpy, - hdry=hdry, - iwdflg=iwdflg, - wetfct=wetfct, - iwetit=iwetit, - ihdwet=ihdwet, - tran=tran, - hy=hy, - vcont=vcont, - sf1=sf1, - sf2=sf2, - wetdry=wetdry, - extension=extension, - unitnumber=unitnumber, - filenames=filenames, + ipakcb=self.ipakcb, + intercellt=self.intercellt, + laycon=self.laycon, + trpy=self.trpy, + hdry=self.hdry, + iwdflg=self.iwdflg, + wetfct=self.wetfct, + iwetit=self.iwetit, + ihdwet=self.ihdwet, + tran=self.tran, + hy=self.hy, + vcont=self.vcont, + sf1=self.sf1, + sf2=self.sf2, + wetdry=self.wetdry, + extension=self.extension, + unitnumber=self.unitnumber, + filenames=self.filenames, add_package=False, ) @@ -183,19 +194,17 @@ def __init__( model, (njag,), np.float32, - anglex, + self.anglex, "anglex", locat=self.unit_number[0], ) # item 1 - self.ikvflag = ikvflag - self.ikcflag = ikcflag self.kv = Util3d( model, (nlay, nrow, ncol), np.float32, - kv, + self.kv, "Vertical Hydraulic Conductivity", locat=self.unit_number[0], ) @@ -204,24 +213,54 @@ def __init__( model, (njag,), np.float32, - ksat, + self.ksat, "ksat", locat=self.unit_number[0], ) - if add_package: + if self.add_package: self.parent.add_package(self) return - def write_file(self, f=None): + def __getattr__(self, name): """ - Write the package file. + Get class attributes to avoid pylint E1101 false positives - Returns - ------- - None + Will only get called for undefined attributes, given dynamic variable definitions. + """ + warnings.warn( + f"No member '{name}' contained in {type(self).__name__})" + ) + return "" + def _write_hy_tran_vcont_kv(self, f, k): + """ + writes hy/tran and vcont/kv file entries + + Parameters + ---------- + f : open file object. + k : model layer index (base 0) + """ + if (self.laycon[k] == 0) or (self.laycon[k] == 2): + f.write(self.tran[k].get_file_entry()) + else: + f.write(self.hy[k].get_file_entry()) + + if (self.ikvflag == 0) and k < (self.parent.nlay - 1): + f.write(self.vcont[k].get_file_entry()) + elif (self.ikvflag == 1) and (self.parent.nlay > 1): + f.write(self.kv[k].get_file_entry()) + + def write_file(self, f=None): + """Write the BCF package file. + + Parameters + ---------- + f : open file object. + Default is None, which will result in ModflowUsg.fn_path being + opened for writing. """ # get model information nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper @@ -229,15 +268,12 @@ def write_file(self, f=None): if dis is None: dis = self.parent.get_package("DISU") - ifrefm = self.parent.get_ifrefm() - # Open file for writing - if f is not None: - f_bcf = f - else: - f_bcf = open(self.fn_path, "w") + if f is None: + f = open(self.fn_path, "w") + # Item 1: ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET, IKVFLAG, IKCFLAG - f_bcf.write( + f.write( ( f" {self.ipakcb:9d} {self.hdry:9.3G} {self.iwdflg:9d}" f" {self.wetfct:9.3G} {self.iwetit:9d} {self.ihdwet:9d}" @@ -247,57 +283,182 @@ def write_file(self, f=None): # LAYCON array for k in range(nlay): - if ifrefm: - if self.intercellt[k] > 0: - f_bcf.write( - f"{self.intercellt[k]:1d} {self.laycon[k]:1d} " - ) - else: - f_bcf.write(f"0{self.laycon[k]:1d} ") + if self.intercellt[k] > 0: + f.write(f"{self.intercellt[k]:1d} {self.laycon[k]:1d} ") else: - if self.intercellt[k] > 0: - f_bcf.write( - f"{self.intercellt[k]:1d} {self.laycon[k]:1d} " - ) - else: - f_bcf.write(f"0{self.laycon[k]:1d} ") - f_bcf.write("\n") - f_bcf.write(self.trpy.get_file_entry()) + f.write(f"0{self.laycon[k]:1d} ") + f.write("\n") + + # TRPY, + f.write(self.trpy.get_file_entry()) transient = not dis.steady.all() structured = self.parent.structured - anis = False - for k in range(nlay): - if self.trpy[k] != 1: - anis = True - break + anis = any([t != 1 for t in self.trpy]) if (not structured) and anis: - f_bcf.write(self.anglex.get_file_entry()) + f.write(self.anglex.get_file_entry()) + + # , , , , , , for k in range(nlay): - if transient == True: - f_bcf.write(self.sf1[k].get_file_entry()) - if self.ikcflag == 0: ## mfusg - if (self.laycon[k] == 0) or (self.laycon[k] == 2): - f_bcf.write(self.tran[k].get_file_entry()) - else: - f_bcf.write(self.hy[k].get_file_entry()) - if (self.ikvflag == 0) and k < (nlay - 1): - f_bcf.write(self.vcont[k].get_file_entry()) - elif (self.ikvflag == 1) and (nlay > 1): # mfusg - f_bcf.write(self.kv[k].get_file_entry()) - if (transient == True) and ( + if transient: + f.write(self.sf1[k].get_file_entry()) + + if self.ikcflag == 0: + self._write_hy_tran_vcont_kv(f, k) + + if (transient) and ( (self.laycon[k] == 2) or (self.laycon[k] == 3) or (self.laycon[k] == 4) ): - f_bcf.write(self.sf2[k].get_file_entry()) + f.write(self.sf2[k].get_file_entry()) + if (self.iwdflg != 0) and ( (self.laycon[k] == 1) or (self.laycon[k] == 3) ): - f_bcf.write(self.wetdry[k].get_file_entry()) + f.write(self.wetdry[k].get_file_entry()) + + # (if ikcflag==1) if abs(self.ikcflag == 1): - f_bcf.write(self.ksat.get_file_entry()) + f.write(self.ksat.get_file_entry()) + + f.close() + + @staticmethod + def _load_laycon(f, model): + """ + Loads laycon and intercellt file entries. + + Parameters + ---------- + f : open file object. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + + Returns + ------- + laycon : Numpy array of laycon values + intercellt : Numpy array of intercellt values + """ + nlay = model.nlay + ifrefm = model.get_ifrefm() + + if model.verbose: + print(" loading LAYCON...") + + line = f.readline() + + if ifrefm: + laycons = [] + line_split = line.strip().split() + for item in line_split: + laycons.append(item) + # read the rest of the laycon values + if len(laycons) < nlay: + while True: + line = f.readline() + line_split = line.strip().split() + for item in line_split: + laycons.append(item) + if len(laycons) == nlay: + break + else: + laycons = [] + istart = 0 + for k in range(nlay): + lcode = line[istart : istart + 2] + if lcode.strip() == "": + # hit end of line before expected end of data + # read next line + line = f.readline() + istart = 0 + lcode = line[istart : istart + 2] + lcode = lcode.replace(" ", "0") + laycons.append(lcode) + istart += 2 + + intercellt = np.zeros(nlay, dtype=np.int32) + laycon = np.zeros(nlay, dtype=np.int32) + for k in range(nlay): + if len(laycons[k]) > 1: + intercellt[k] = int(laycons[k][0]) + laycon[k] = int(laycons[k][1]) + else: + laycon[k] = int(laycons[k]) - f_bcf.close() + return laycon, intercellt + + @staticmethod + def _load_hy_tran_kv_vcont(f, model, laycon_k, ext_unit_dict, ikvflag): + """ + Loads hy/tran and kv/vcont file entries. + + Parameters + ---------- + f : open file object. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + laycon_k : tuple of two ints: (k, laycon for layer k) + ext_unit_dict : external unit dictionary + ikvflag : int + flag indicating if vertical hydraulic conductivity is input + instead of leakance between two layers. + + Returns + ------- + _hy : Numpy array of hk values (or 0) + _tran : Numpy array of tran values (or 0) + _kv : Numpy array of kv values (or 0) + _vcont : Numpy array of vcont values (or 0) + """ + k = laycon_k[0] + laycon_k = laycon_k[1] + util2d_shape = get_util2d_shape_for_layer(model, layer=k) + + # hy or tran + _tran = 0 + _hy = 0 + if (laycon_k == 0) or (laycon_k == 2): + if model.verbose: + print(f" loading tran layer {k + 1:3d}...") + _tran = Util2d.load( + f, + model, + util2d_shape, + np.float32, + "tran", + ext_unit_dict, + ) + else: + if model.verbose: + print(f" loading hy layer {k + 1:3d}...") + _hy = Util2d.load( + f, model, util2d_shape, np.float32, "hy", ext_unit_dict + ) + + # kv or vcont + _kv = 0 + _vcont = 0 + if k < (model.nlay - 1): + if model.verbose: + print(f" loading vcont layer {k + 1:3d}...") + _vcont = Util2d.load( + f, + model, + util2d_shape, + np.float32, + "vcont", + ext_unit_dict, + ) + elif (ikvflag == 1) and (model.nlay > 1): + if model.verbose: + print(f" loading kv layer {k + 1:3d}...") + _kv = Util2d.load( + f, model, util2d_shape, np.float32, "kv", ext_unit_dict + ) + + return _hy, _tran, _kv, _vcont @classmethod def load(cls, f, model, ext_unit_dict=None): @@ -321,7 +482,6 @@ def load(cls, f, model, ext_unit_dict=None): Returns ------- bcf : ModflowUsgBcf object - ModflowUsgBcf object. Examples -------- @@ -330,9 +490,7 @@ def load(cls, f, model, ext_unit_dict=None): >>> m = flopy.modflowusg.ModflowUsg() >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> bcf = flopy.modflowusg.ModflowUsgBcf.load('test.bcf', m) - """ - if model.verbose: print("loading bcf package file...") @@ -354,76 +512,35 @@ def load(cls, f, model, ext_unit_dict=None): dis = model.get_package("DISU") njag = dis.njag - structured = model.structured - # Item 1: ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET - line already read above if model.verbose: print(" loading ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET...") - t = line_parse(line) + text_list = line_parse(line) ipakcb, hdry, iwdflg, wetfct, iwetit, ihdwet = ( - int(t[0]), - float(t[1]), - int(t[2]), - float(t[3]), - int(t[4]), - int(t[5]), + int(text_list[0]), + float(text_list[1]), + int(text_list[2]), + float(text_list[3]), + int(text_list[4]), + int(text_list[5]), ) try: - ikvflag = int(t[6]) + ikvflag = int(text_list[6]) except IndexError: ikvflag = 0 except ValueError: ikvflag = 0 try: - ikcflag = int(t[7]) + ikcflag = int(text_list[7]) except IndexError: ikcflag = 0 except ValueError: ikvflag = 0 # LAYCON array - ifrefm = model.get_ifrefm() - if model.verbose: - print(" loading LAYCON...") - line = f.readline() - if ifrefm: - t = [] - tt = line.strip().split() - for iv in tt: - t.append(iv) - # read the rest of the laycon values - if len(t) < nlay: - while True: - line = f.readline() - tt = line.strip().split() - for iv in tt: - t.append(iv) - if len(t) == nlay: - break - else: - t = [] - istart = 0 - for k in range(nlay): - lcode = line[istart : istart + 2] - if lcode.strip() == "": - # hit end of line before expected end of data - # read next line - line = f.readline() - istart = 0 - lcode = line[istart : istart + 2] - lcode = lcode.replace(" ", "0") - t.append(lcode) - istart += 2 - intercellt = np.zeros(nlay, dtype=np.int32) - laycon = np.zeros(nlay, dtype=np.int32) - for k in range(nlay): - if len(t[k]) > 1: - intercellt[k] = int(t[k][0]) - laycon[k] = int(t[k][1]) - else: - laycon[k] = int(t[k]) + laycon, intercellt = cls._load_laycon(f, model) # TRPY array if model.verbose: @@ -434,19 +551,13 @@ def load(cls, f, model, ext_unit_dict=None): # property data for each layer based on options transient = not dis.steady.all() - structured = model.structured - anis = False - for k in range(nlay): - if trpy[k] != 1: - anis = True - break - if (not structured) and anis: + anis = any([t != 1 for t in trpy]) + if (not model.structured) and anis: if model.verbose: - print("mfusg: loading ANGLEX...") - t = Util2d.load( + print("loading ANGLEX...") + anglex = Util2d.load( f, model, (njag,), np.float32, "anglex", ext_unit_dict ) - anglex = t else: anglex = 0 @@ -463,65 +574,23 @@ def load(cls, f, model, ext_unit_dict=None): for k in range(nlay): - # allow for unstructured changing nodes per layer - if nr is None: - nrow = 1 - ncol = nc[k] - else: - nrow = nr - ncol = nc + util2d_shape = get_util2d_shape_for_layer(model, layer=k) # sf1 if transient: if model.verbose: print(f" loading sf1 layer {k + 1:3d}...") - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "sf1", ext_unit_dict + sf1[k] = Util2d.load( + f, model, util2d_shape, np.float32, "sf1", ext_unit_dict ) - sf1[k] = t + # hy/tran, and kv/vcont if ikcflag == 0: - # tran or hy - if (laycon[k] == 0) or (laycon[k] == 2): - if model.verbose: - print(f" loading tran layer {k + 1:3d}...") - t = Util2d.load( - f, - model, - (nrow, ncol), - np.float32, - "tran", - ext_unit_dict, - ) - tran[k] = t - else: - if model.verbose: - print(f" loading hy layer {k + 1:3d}...") - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "hy", ext_unit_dict - ) - hy[k] = t - - # vcont - if k < (nlay - 1): - if model.verbose: - print(f" loading vcont layer {k + 1:3d}...") - t = Util2d.load( - f, - model, - (nrow, ncol), - np.float32, - "vcont", - ext_unit_dict, - ) - vcont[k] = t - elif (ikvflag == 1) and (nlay > 1): # mfusg - if model.verbose: - print(f" loading kv layer {k + 1:3d}...") - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "kv", ext_unit_dict - ) - kv[k] = t + hy[k], tran[k], kv[k], vcont_k = cls._load_hy_tran_kv_vcont( + f, model, (k, laycon[k]), ext_unit_dict, ikvflag + ) + if k < nlay - 1: + vcont[k] = vcont_k # sf2 if transient and ( @@ -529,28 +598,25 @@ def load(cls, f, model, ext_unit_dict=None): ): if model.verbose: print(f" loading sf2 layer {k + 1:3d}...") - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "sf2", ext_unit_dict + sf2[k] = Util2d.load( + f, model, util2d_shape, np.float32, "sf2", ext_unit_dict ) - sf2[k] = t # wetdry if (iwdflg != 0) and ((laycon[k] == 1) or (laycon[k] == 3)): if model.verbose: print(f" loading sf2 layer {k + 1:3d}...") - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "wetdry", ext_unit_dict + wetdry[k] = Util2d.load( + f, model, util2d_shape, np.float32, "wetdry", ext_unit_dict ) - wetdry[k] = t # Ksat mfusg - if (not structured) and abs(ikcflag == 1): + if (not model.structured) and abs(ikcflag == 1): if model.verbose: - print(f" loading ksat layer {k + 1:3d}...") - t = Util2d.load( + print(" loading ksat (njag)...") + ksat = Util2d.load( f, model, (njag,), np.float32, "ksat", ext_unit_dict ) - ksat = t else: ksat = 0 diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index 1188dda4ef..010c82086e 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -128,7 +128,7 @@ class ModflowUsgLpf(ModflowLpf): is a combination of the wetting threshold and a flag to indicate which neighboring cells can cause a cell to become wet. (default is -0.01). - ksat : float or array of floats (nrow, ncol) + ksat : float or array of floats (njag) inter-block saturated hydraulic conductivity or transmissivity (if IKCFLAG = 1) or the inter-block conductance (if IKCFLAG = - 1) of the connection between nodes n and m. diff --git a/flopy/pakbase.py b/flopy/pakbase.py index f8019c0594..d9deb2327d 100644 --- a/flopy/pakbase.py +++ b/flopy/pakbase.py @@ -593,7 +593,7 @@ def __setattr__(self, key, value): vo.dtype, v, name=vo.name, - fmtin=vo.fmtin, + fmtin=vo.format.fortran, locat=vo.locat, ) ) diff --git a/flopy/utils/utils_def.py b/flopy/utils/utils_def.py index c5efb92d8a..c53512e436 100644 --- a/flopy/utils/utils_def.py +++ b/flopy/utils/utils_def.py @@ -2,6 +2,7 @@ Generic classes and utility functions """ +import warnings from datetime import timedelta import numpy as np @@ -55,6 +56,17 @@ def read_record(self, count, dtype=None): def _read_values(self, dtype, count): return np.fromfile(self.file, dtype, count) + def __getattr__(self, name): + """ + Gets class attributes to avoid pylint E1101 false positives. + + Will only get called for undefined attributes. + """ + warnings.warn( + f"No member '{name}' contained in {type(self).__name__})" + ) + return "" + def totim_to_datetime(totim, start="1-1-1970", timeunit="D"): """ @@ -136,3 +148,31 @@ def get_pak_vals_shape(model, vals): return np.array(vals, ndmin=2).shape else: return (nrow, ncol) # structured + + +def get_util2d_shape_for_layer(model, layer=0): + """ + Define nrow and ncol for array (Util2d) shape of a given layer in + structured and/or unstructured models. + + Parameters + ---------- + model : model object + model for which Util2d shape is sought. + layer : int + layer (base 0) for which Util2d shape is sought. + + Returns + --------- + (nrow,ncol) : tuple of ints + util2d shape for the given layer + """ + nr, nc, nlay, nper = model.get_nrow_ncol_nlay_nper() + if nr is None: # unstructured + nrow = 1 + ncol = nc[layer] + else: # structured + nrow = nr + ncol = nc + + return (nrow, ncol) From e82cbb7c6b18ab075ddec07a5db5043949f76483 Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Sat, 2 Oct 2021 16:47:17 +1000 Subject: [PATCH 08/14] refactor(mfusglpf) linting --- .pylintrc | 2 +- flopy/modflowusg/mfusg.py | 4 +- flopy/modflowusg/mfusgbcf.py | 19 +- flopy/modflowusg/mfusglpf.py | 377 ++++++++++++++++++++--------------- flopy/utils/utils_def.py | 40 ++++ 5 files changed, 266 insertions(+), 176 deletions(-) diff --git a/.pylintrc b/.pylintrc index 5bbe9bd609..bbe7e660a1 100644 --- a/.pylintrc +++ b/.pylintrc @@ -347,7 +347,7 @@ single-line-class-stmt=no single-line-if-stmt=no # Good variable names which should always be accepted, separated by a comma -good-names=kv,nr,nc +good-names=kv,nr,nc,sy,ss,iu [SIMILARITIES] diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py index 61841353fc..22dc7f68bb 100644 --- a/flopy/modflowusg/mfusg.py +++ b/flopy/modflowusg/mfusg.py @@ -367,8 +367,8 @@ def _load_packages(cls, ml, ext_unit_dict, ext_pkg_d, load_only, forgive): Returns ---------- - files_successfully_loaded : - files_not_loaded : + files_successfully_loaded : list of loaded files + files_not_loaded : list of files that were not loaded """ files_successfully_loaded = [] files_not_loaded = [] diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py index 8a07bb0ae9..a094a29bba 100644 --- a/flopy/modflowusg/mfusgbcf.py +++ b/flopy/modflowusg/mfusgbcf.py @@ -9,7 +9,10 @@ from ..modflow import ModflowBcf from ..utils import Util2d, Util3d from ..utils.flopy_io import line_parse -from ..utils.utils_def import get_util2d_shape_for_layer +from ..utils.utils_def import ( + get_util2d_shape_for_layer, + get_unitnumber_from_ext_unit_dict, +) class ModflowUsgBcf(ModflowBcf): @@ -624,17 +627,9 @@ def load(cls, f, model, ext_unit_dict=None): f.close() # set package unit number - unitnumber = None - filenames = [None, None] - if ext_unit_dict is not None: - unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowUsgBcf._ftype() - ) - if ipakcb > 0: - iu, filenames[1] = model.get_ext_dict_attr( - ext_unit_dict, unit=ipakcb - ) - model.add_pop_key_list(ipakcb) + unitnumber, filenames = get_unitnumber_from_ext_unit_dict( + model, cls, ext_unit_dict, ipakcb + ) # create instance of bcf object bcf = cls( diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index 010c82086e..21e844a946 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -1,3 +1,4 @@ +# pylint: disable=W0223 """ mfusglpf module. Contains the ModflowUsgLpf class. Note that the user can access the ModflowUsgLpf class as `flopy.modflowusg.ModflowUsgLpf`. @@ -5,14 +6,17 @@ Additional information for this MODFLOW package can be found at the `Online MODFLOW Guide `_. - """ import numpy as np from ..modflow.mfpar import ModflowPar as mfpar from ..modflow.mflpf import ModflowLpf -from ..utils import Util2d, Util3d, read1d +from ..utils import Util2d, read1d from ..utils.flopy_io import line_parse +from ..utils.utils_def import ( + get_util2d_shape_for_layer, + get_unitnumber_from_ext_unit_dict, +) class ModflowUsgLpf(ModflowLpf): @@ -192,11 +196,8 @@ class ModflowUsgLpf(ModflowLpf): >>> m = flopy.modflowusg.ModflowUsg() >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> lpf = flopy.modflowusg.ModflowUsgLpf(m) - """ - "Layer-property flow package class\n" - def __init__( self, model, @@ -231,6 +232,7 @@ def __init__( filenames=None, add_package=True, ): + """mfusglpf object constructor""" super().__init__( model, @@ -308,8 +310,6 @@ def __init__( if add_package: self.parent.add_package(self) - return - def write_file(self, check=True, f=None): """ Write the package file. @@ -346,7 +346,7 @@ def write_file(self, check=True, f=None): f.write(f"{self.heading}\n") # Item 1: IBCFCB, HDRY, NPLPF, , OPTIONS - if self.parent.version == "mfusg" and self.parent.structured == False: + if self.parent.version == "mfusg" and not self.parent.structured: f.write( ( f" {self.ipakcb:9d} {self.hdry:9.5G} {self.nplpf:9d}" @@ -374,22 +374,18 @@ def write_file(self, check=True, f=None): transient = not dis.steady.all() structured = self.parent.structured - anis = False - for k in range(nlay): - if self.chani[k] != 1: - anis = True - break + anis = any([ch != 1 for ch in self.chani]) if (not structured) and anis: f.write(self.anglex.get_file_entry()) for k in range(nlay): - if self.ikcflag == 0: ## mfusg + if self.ikcflag == 0: # mfusg f.write(self.hk[k].get_file_entry()) if self.chani[k] <= 0.0: f.write(self.hani[k].get_file_entry()) f.write(self.vka[k].get_file_entry()) - if transient == True: + if transient: f.write(self.ss[k].get_file_entry()) if self.laytyp[k] != 0: f.write(self.sy[k].get_file_entry()) @@ -404,6 +400,156 @@ def write_file(self, check=True, f=None): f.close() return + @staticmethod + def _load_hy_tran_kv_vcont( + f, model, layer_vars, ext_unit_dict, par_types_parm_dict + ): + """ + Loads hy/tran and kv/vcont file entries. + + Parameters + ---------- + f : open file object. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + layer_vars : dict. Key/value pairs must be: + "layer": layer number k (base 0), + "layvka": layvka for layer k, + "chani": chani for layer k + ext_unit_dict : external unit dictionary + par_types_parm_dict : tuple of (par_types, parm_dict) + + Returns + ------- + hk_k : Numpy array of hk values for layer k (or 0) + hani_k : Numpy array of hani values for layer k (or 0) + vka_k : Numpy array of vka values for layer k (or 0) + """ + par_types, parm_dict = par_types_parm_dict + k = layer_vars["layer"] + layvka_k = layer_vars["layvka"] + chani_k = layer_vars["chani"] + util2d_shape = get_util2d_shape_for_layer(model, layer=k) + + # hk + if model.verbose: + print(f" loading hk layer {k + 1:3d}...") + if "hk" not in par_types: + hk_k = Util2d.load( + f, model, util2d_shape, np.float32, "hk", ext_unit_dict + ) + else: + f.readline() + hk_k = mfpar.parameter_fill( + model, util2d_shape, "hk", parm_dict, findlayer=k + ) + + # hani + hani_k = 1.0 + if chani_k <= 0.0: + if model.verbose: + print(f" loading hani layer {k + 1:3d}...") + if "hani" not in par_types: + hani_k = Util2d.load( + f, + model, + util2d_shape, + np.float32, + "hani", + ext_unit_dict, + ) + else: + f.readline() + hani_k = mfpar.parameter_fill( + model, util2d_shape, "hani", parm_dict, findlayer=k + ) + + # vka + if model.verbose: + print(f" loading vka layer {k + 1:3d}...") + key = "vk" + if layvka_k != 0: + key = "vani" + if "vk" not in par_types and "vani" not in par_types: + vka_k = Util2d.load( + f, model, util2d_shape, np.float32, key, ext_unit_dict + ) + else: + f.readline() + key = "vk" + if "vani" in par_types: + key = "vani" + vka_k = mfpar.parameter_fill( + model, util2d_shape, key, parm_dict, findlayer=k + ) + + return hk_k, hani_k, vka_k + + @staticmethod + def _load_storage( + f, model, layer_vars, ext_unit_dict, par_types_parm_dict + ): + """ + Loads ss, sy file entries. + + Parameters + ---------- + f : open file object. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + layer_vars : dict. Key/value pairs must be: + "layer": layer number k (base 0), + "laytyp": laytyp for layer k + ext_unit_dict : external unit dictionary + par_types_parm_dict : tuple of (par_types, parm_dict) + + Returns + ------- + ss_k : Numpy array of ss values for layer k (or 0) + sy_k : Numpy array of sy values for layer k (or 0) + """ + par_types, parm_dict = par_types_parm_dict + k = layer_vars["layer"] + laytyp_k = layer_vars["laytyp"] + util2d_shape = get_util2d_shape_for_layer(model, layer=k) + + # ss + if model.verbose: + print(f" loading ss layer {k + 1:3d}...") + if "ss" not in par_types: + ss_k = Util2d.load( + f, model, util2d_shape, np.float32, "ss", ext_unit_dict + ) + else: + f.readline() + ss_k = mfpar.parameter_fill( + model, util2d_shape, "ss", parm_dict, findlayer=k + ) + + # sy + sy_k = 0.1 + if laytyp_k != 0: + if model.verbose: + print(f" loading sy layer {k + 1:3d}...") + if "sy" not in par_types: + sy_k = Util2d.load( + f, + model, + util2d_shape, + np.float32, + "sy", + ext_unit_dict, + ) + else: + f.readline() + sy_k = mfpar.parameter_fill( + model, util2d_shape, "sy", parm_dict, findlayer=k + ) + + return ss_k, sy_k + @classmethod def load(cls, f, model, ext_unit_dict=None, check=True): """ @@ -437,9 +583,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): >>> m = flopy.modflowusg.ModflowUsg() >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> lpf = flopy.modflowusg.ModflowUsgLpf.load('test.lpf', m) - """ - if model.verbose: print("loading lpf package file...") @@ -455,7 +599,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): break # determine problem dimensions - nr, nc, nlay, nper = model.get_nrow_ncol_nlay_nper() + nr, nc, nlay, _ = model.get_nrow_ncol_nlay_nper() dis = model.get_package("DIS") if dis is None: dis = model.get_package("DISU") @@ -464,31 +608,34 @@ def load(cls, f, model, ext_unit_dict=None, check=True): # Item 1: IBCFCB, HDRY, NPLPF - line already read above if model.verbose: print(" loading IBCFCB, HDRY, NPLPF...") - t = line_parse(line) - ipakcb, hdry, nplpf = int(t[0]), float(t[1]), int(t[2]) + text_list = line_parse(line) + ipakcb, hdry, nplpf = ( + int(text_list[0]), + float(text_list[1]), + int(text_list[2]), + ) item1_len = 3 - if model.structured == False: - ikcflag = int(t[3]) + ikcflag = 0 + if not model.structured: + ikcflag = int(text_list[3]) item1_len = 4 - else: - ikcflag = 0 storagecoefficient = False constantcv = False thickstrt = False nocvcorrection = False novfc = False - if len(t) > item1_len: - for k in range(item1_len, len(t)): - if "STORAGECOEFFICIENT" in t[k].upper(): + if len(text_list) > item1_len: + for k in range(item1_len, len(text_list)): + if "STORAGECOEFFICIENT" in text_list[k].upper(): storagecoefficient = True - if "CONSTANTCV" in t[k].upper(): + if "CONSTANTCV" in text_list[k].upper(): constantcv = True - if "THICKSTRT" in t[k].upper(): + if "THICKSTRT" in text_list[k].upper(): thickstrt = True - if "NOCVCORRECTION" in t[k].upper(): + if "NOCVCORRECTION" in text_list[k].upper(): nocvcorrection = True - if "NOVFC" in t[k].upper(): + if "NOVFC" in text_list[k].upper(): novfc = True # LAYTYP array @@ -528,30 +675,29 @@ def load(cls, f, model, ext_unit_dict=None, check=True): if model.verbose: print(" loading WETFCT, IWETIT, IHDWET...") line = f.readline() - t = line.strip().split() - wetfct, iwetit, ihdwet = float(t[0]), int(t[1]), int(t[2]) + text_list = line.strip().split() + wetfct, iwetit, ihdwet = ( + float(text_list[0]), + int(text_list[1]), + int(text_list[2]), + ) # parameters data par_types = [] + parm_dict = {} if nplpf > 0: par_types, parm_dict = mfpar.load(f, nplpf, model.verbose) # print parm_dict # ANGLEX for unstructured grid with anisotropy - anis = False - for k in range(nlay): - if chani[k] != 1: - anis = True - break + anis = any([ch != 1 for ch in chani]) + anglex = 0 if (not model.structured) and anis: if model.verbose: print("mfusg: loading ANGLEX...") - t = Util2d.load( + anglex = Util2d.load( f, model, (njag,), np.float32, "anglex", ext_unit_dict ) - anglex = t - else: - anglex = 0 # non-parameter data transient = not dis.steady.all() @@ -566,161 +712,70 @@ def load(cls, f, model, ext_unit_dict=None, check=True): # load by layer for k in range(nlay): - # allow for unstructured changing nodes per layer - if nr is None: - nrow = 1 - ncol = nc[k] - else: - nrow = nr - ncol = nc + util2d_shape = get_util2d_shape_for_layer(model, layer=k) if ikcflag == 0: - # hk - if model.verbose: - print(f" loading hk layer {k + 1:3d}...") - if "hk" not in par_types: - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "hk", ext_unit_dict - ) - else: - line = f.readline() - t = mfpar.parameter_fill( - model, (nrow, ncol), "hk", parm_dict, findlayer=k - ) - hk[k] = t - - # hani - if chani[k] <= 0.0: - if model.verbose: - print(f" loading hani layer {k + 1:3d}...") - if "hani" not in par_types: - t = Util2d.load( - f, - model, - (nrow, ncol), - np.float32, - "hani", - ext_unit_dict, - ) - else: - line = f.readline() - t = mfpar.parameter_fill( - model, (nrow, ncol), "hani", parm_dict, findlayer=k - ) - hani[k] = t - - # vka - if model.verbose: - print(f" loading vka layer {k + 1:3d}...") - key = "vk" - if layvka[k] != 0: - key = "vani" - if "vk" not in par_types and "vani" not in par_types: - t = Util2d.load( - f, model, (nrow, ncol), np.float32, key, ext_unit_dict - ) - else: - line = f.readline() - key = "vk" - if "vani" in par_types: - key = "vani" - t = mfpar.parameter_fill( - model, (nrow, ncol), key, parm_dict, findlayer=k - ) - vka[k] = t + hk[k], hani[k], vka[k] = cls._load_hy_tran_kv_vcont( + f, + model, + {"layer": k, "layvka": layvka[k], "chani": chani[k]}, + ext_unit_dict, + (par_types, parm_dict), + ) # storage properties if transient: - - # ss - if model.verbose: - print(f" loading ss layer {k + 1:3d}...") - if "ss" not in par_types: - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "ss", ext_unit_dict - ) - else: - line = f.readline() - t = mfpar.parameter_fill( - model, (nrow, ncol), "ss", parm_dict, findlayer=k - ) - ss[k] = t - - # sy - if laytyp[k] != 0: - if model.verbose: - print(f" loading sy layer {k + 1:3d}...") - if "sy" not in par_types: - t = Util2d.load( - f, - model, - (nrow, ncol), - np.float32, - "sy", - ext_unit_dict, - ) - else: - line = f.readline() - t = mfpar.parameter_fill( - model, (nrow, ncol), "sy", parm_dict, findlayer=k - ) - sy[k] = t + ss[k], sy[k] = cls._load_storage( + f, + model, + {"layer": k, "laytyp": laytyp[k]}, + ext_unit_dict, + (par_types, parm_dict), + ) # vkcb if ikcflag == 0 and dis.laycbd[k] != 0: if model.verbose: print(f" loading vkcb layer {k + 1:3d}...") if "vkcb" not in par_types: - t = Util2d.load( + vkcb[k] = Util2d.load( f, model, - (nrow, ncol), + util2d_shape, np.float32, "vkcb", ext_unit_dict, ) else: line = f.readline() - t = mfpar.parameter_fill( - model, (nrow, ncol), "vkcb", parm_dict, findlayer=k + vkcb[k] = mfpar.parameter_fill( + model, util2d_shape, "vkcb", parm_dict, findlayer=k ) - vkcb[k] = t # wetdry if laywet[k] != 0 and laytyp[k] != 0 and laytyp[k] != 4: if model.verbose: print(f" loading wetdry layer {k + 1:3d}...") - t = Util2d.load( - f, model, (nrow, ncol), np.float32, "wetdry", ext_unit_dict + wetdry[k] = Util2d.load( + f, model, util2d_shape, np.float32, "wetdry", ext_unit_dict ) - wetdry[k] = t # Ksat mfusg + ksat = 1.0 if abs(ikcflag) == 1: if model.verbose: - print(f" loading ksat...") - t = Util2d.load( + print(" loading ksat...") + ksat = Util2d.load( f, model, (njag,), np.float32, "ksat", ext_unit_dict ) - ksat = t - else: - ksat = 1.0 if openfile: f.close() - # set package unit number - unitnumber = None - filenames = [None, None] - if ext_unit_dict is not None: - unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowUsgLpf._ftype() - ) - if ipakcb > 0: - iu, filenames[1] = model.get_ext_dict_attr( - ext_unit_dict, unit=ipakcb - ) - model.add_pop_key_list(ipakcb) + # set package unit number and io file names + unitnumber, filenames = get_unitnumber_from_ext_unit_dict( + model, cls, ext_unit_dict, ipakcb + ) # create instance of lpf class lpf = cls( diff --git a/flopy/utils/utils_def.py b/flopy/utils/utils_def.py index c53512e436..c9efbba766 100644 --- a/flopy/utils/utils_def.py +++ b/flopy/utils/utils_def.py @@ -176,3 +176,43 @@ def get_util2d_shape_for_layer(model, layer=0): ncol = nc return (nrow, ncol) + + +def get_unitnumber_from_ext_unit_dict( + model, pak_class, ext_unit_dict=None, ipakcb=0 +): + """ + For a given modflow package, defines input file unit number, + plus package input and (optionally) output (budget) save file names. + + Parameters + ---------- + model : model object + model for which the unit number is sought. + pak_class : modflow package class for which the unit number is sought. + ext_unit_dict : external unit dictionary, optional. + If not provided, unitnumber and filenames will be returned as None. + ipakcb : int, optional + Modflow package unit number on which budget is saved. + Default is 0, in which case the returned output file is None. + + Returns + --------- + unitnumber : int + file unit number for the given modflow package (or None) + filenames : list + list of [package input file name, budget file name], + """ + unitnumber = None + filenames = [None, None] + if ext_unit_dict is not None: + unitnumber, filenames[0] = model.get_ext_dict_attr( + ext_unit_dict, filetype=pak_class._ftype() + ) + if ipakcb > 0: + iu, filenames[1] = model.get_ext_dict_attr( + ext_unit_dict, unit=ipakcb + ) + model.add_pop_key_list(ipakcb) + + return unitnumber, filenames From 2d5896e7ea1b3cc85dda8cbfb3a09ff0de44ebe7 Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Sat, 2 Oct 2021 17:12:00 +1000 Subject: [PATCH 09/14] refactor(mfusgsms, mfusggnc) linting --- flopy/modflowusg/mfusggnc.py | 32 +++++++++++++++----------------- flopy/modflowusg/mfusgsms.py | 8 +++----- flopy/pakbase.py | 7 ++++--- 3 files changed, 22 insertions(+), 25 deletions(-) diff --git a/flopy/modflowusg/mfusggnc.py b/flopy/modflowusg/mfusggnc.py index 17a48c2239..d2a2dcfcdf 100644 --- a/flopy/modflowusg/mfusggnc.py +++ b/flopy/modflowusg/mfusggnc.py @@ -1,9 +1,9 @@ """ -mfusggnc module. This is for the Ghost Node Correction (GNC) Package for MODFLOW-USG. +mfusggnc module. + +This is for the Ghost Node Correction (GNC) Package for MODFLOW-USG. Contains the ModflowUsgGnc class. Note that the user can access the ModflowUsgGnc class as `flopy.modflowusg.ModflowUsgGnc`. - - """ import numpy as np from ..pakbase import Package @@ -76,7 +76,6 @@ class ModflowUsgGnc(Package): >>> import flopy >>> m = flopy.modflow.Modflow() >>> gnc = flopy.modflowusg.ModflowUsgGnc(m) - """ def __init__( @@ -93,6 +92,7 @@ def __init__( unitnumber=None, filenames=None, ): + """Package constructor""" # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowUsgGnc._defaultunit() @@ -283,30 +283,28 @@ def load(cls, f, model, ext_unit_dict=None): break # Item 1 --NPGNCn MXGNn NGNCNPn MXADJn I2Kn ISYMGNCn IFLALPHAn [NOPRINT] - t = line.strip().split() + line_text = line.strip().split() imax = 7 npgncn, mxgnn, numgnc, numalphaj, i2kn, isymgncn, iflalphan = ( - int(t[0]), - int(t[1]), - int(t[2]), - int(t[3]), - int(t[4]), - int(t[5]), - int(t[6]), + int(line_text[0]), + int(line_text[1]), + int(line_text[2]), + int(line_text[3]), + int(line_text[4]), + int(line_text[5]), + int(line_text[6]), ) options = [] - if len(t) > imax: - if t[7].lower() == "noprint": + if len(line_text) > imax: + if line_text[7].lower() == "noprint": options.append("noprint") # Item 2 -- read parameter data if npgncn > 0: dt = ModflowUsgGnc.get_empty(npgncn, mxgnn, iflalphan).dtype # Item 3 -- - pak_parms = mfparbc.load( - f, npgncn, dt, model, ext_unit_dict, model.verbose - ) + mfparbc.load(f, npgncn, dt, model, ext_unit_dict, model.verbose) # Item 4 -- read GNC data gncdata = ModflowUsgGnc.get_empty(numgnc, numalphaj, iflalphan) diff --git a/flopy/modflowusg/mfusgsms.py b/flopy/modflowusg/mfusgsms.py index f7887e39db..b40e68bfd4 100644 --- a/flopy/modflowusg/mfusgsms.py +++ b/flopy/modflowusg/mfusgsms.py @@ -1,9 +1,9 @@ +# pylint: disable=too-many-instance-attributes """ mfusgsms module. This is the solver for MODFLOW-USG. + Contains the ModflowUsgSms class. Note that the user can access the ModflowUsgSms class as `flopy.modflowusg.ModflowUsgSms`. - - """ from ..pakbase import Package from ..utils.flopy_io import line_parse @@ -230,7 +230,6 @@ class ModflowUsgSms(Package): >>> import flopy >>> m = flopy.modflow.Modflow() >>> sms = flopy.modflowusg.ModflowUsgSms(m) - """ def __init__( @@ -270,6 +269,7 @@ def __init__( unitnumber=None, filenames=None, ): + """Package constructor""" # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowUsgSms._defaultunit() @@ -434,9 +434,7 @@ def load(cls, f, model, ext_unit_dict=None): >>> import flopy >>> m = flopy.modflow.Modflow() >>> sms = flopy.modflow.ModflowPcg.load('test.sms', m) - """ - if model.verbose: print("loading sms package file...") diff --git a/flopy/pakbase.py b/flopy/pakbase.py index d9deb2327d..9a5a250438 100644 --- a/flopy/pakbase.py +++ b/flopy/pakbase.py @@ -844,7 +844,7 @@ def webdoc(self): if wa is not None: wb.open(wa) - def write_file(self, check=False): + def write_file(self, f=None, check=False): """ Every Package needs its own write_file function @@ -853,11 +853,12 @@ def write_file(self, check=False): return @staticmethod - def load(f, model, pak_type, ext_unit_dict=None, **kwargs): + def load(f, model, pak_type=None, ext_unit_dict=None, **kwargs): """ Default load method for standard boundary packages. - """ + if pak_type is None: + return # parse keywords if "nper" in kwargs: From a46bfc9a1c88874aae1165b25778c94d5e6592b8 Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Sun, 3 Oct 2021 17:06:22 +1100 Subject: [PATCH 10/14] refactor(mfusgwel) linting --- flopy/modflowusg/mfusgwel.py | 517 ++++++++++++++++++++--------------- 1 file changed, 291 insertions(+), 226 deletions(-) diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py index 60e4c98cef..859d09df77 100644 --- a/flopy/modflowusg/mfusgwel.py +++ b/flopy/modflowusg/mfusgwel.py @@ -1,22 +1,21 @@ """ -mfusgwel module. Contains the ModflowUsgWel class. Note that the user can access +mfusgwel module. + +Contains the ModflowUsgWel class. Note that the user can access the ModflowUsgWel class as `flopy.modflowusg.ModflowUsgWel`. Additional information for this MODFLOW package can be found at the `Online MODFLOW Guide `_. - """ -import numpy as np from copy import deepcopy -from ..utils import MfList -from ..pakbase import Package -from ..modflow.mfwel import ModflowWel -from ..utils.recarray_utils import create_empty_recarray -from ..utils.flopy_io import ulstrd -import warnings +import numpy as np +from numpy.lib.recfunctions import stack_arrays +from ..modflow.mfwel import ModflowWel from ..modflow.mfparbc import ModflowParBc as mfparbc +from ..utils.flopy_io import ulstrd +from ..utils import MfList class ModflowUsgWel(ModflowWel): @@ -177,7 +176,6 @@ def __init__( ): """ Package constructor. - """ super().__init__( @@ -196,12 +194,12 @@ def __init__( self.autoflowreduce = False self.iunitafr = 0 - for idx, opt in enumerate(self.options): + for opt in self.options: if "autoflowreduce" in opt.lower(): self.autoflowreduce = True if "iunitafr" in opt.lower(): - t = opt.strip().split() - self.iunitafr = int(t[1]) + line_text = opt.strip().split() + self.iunitafr = int(line_text[1]) if self.iunitafr > 0: fname = self.filenames[1] @@ -215,7 +213,6 @@ def __init__( # initialize CLN MfList # CLN WELs are always read as CLNNODE Q, so dtype must be of unstructured form - dtype_model = self.dtype dtype_cln = ModflowUsgWel.get_default_dtype(structured=False) self.dtype = dtype_cln self.cln_stress_period_data = MfList( @@ -231,25 +228,67 @@ def __init__( return + @staticmethod + def _get_kper_data(kper, first, stress_period_data): + """ + Gets boundary condition stress period data for a given stress period. + + Parameters: + ---------- + kper: int + stress period (base 0) + first : int + First stress period for which stress period data is defined + stress_period_data : Numpy recarray or int or None + Flopy boundary condition stress_period_data object + (with a "data" attribute that is keyed on kper) + Returns + ------- + itmp : int + Number of boundary conditions for stress period kper + kper_data : Numpy recarray + Boundary condition data for stress period kper + """ + kpers = list(stress_period_data.data.keys()) + # Fill missing early kpers with 0 + kper_data = None + if kper < first: + itmp = 0 + elif kper in kpers: + kper_data = deepcopy(stress_period_data.data[kper]) + kper_vtype = stress_period_data.vtype[kper] + if kper_vtype == np.recarray: + itmp = kper_data.shape[0] + lnames = [name.lower() for name in kper_data.dtype.names] + for idx in ["k", "i", "j", "node"]: + if idx in lnames: + kper_data[idx] += 1 + elif (kper_vtype == int) or (kper_vtype is None): + itmp = kper_data + # Fill late missing kpers with -1 + else: + itmp = -1 + + return itmp, kper_data + def write_file(self, f=None): """ Write the package file. Parameters: + ---------- f: (str) optional file name Returns ------- None - """ - if f is not None: - if isinstance(f, str): - f_wel = open(f, "w") - else: - f_wel = f - else: + if f is None: f_wel = open(self.fn_path, "w") + elif isinstance(f, str): + f_wel = open(f, "w") + else: + f_wel = f f_wel.write(f"{self.heading}\n") @@ -263,7 +302,7 @@ def write_file(self, f=None): line += "\n" f_wel.write(line) - nrow, ncol, nlay, nper = self.parent.get_nrow_ncol_nlay_nper() + _, ncol, nlay, nper = self.parent.get_nrow_ncol_nlay_nper() kpers = list(self.stress_period_data.data.keys()) if len(kpers) > 0: @@ -284,7 +323,6 @@ def write_file(self, f=None): cln_last = -1 maxper = max(nper, last, cln_last) - loop_over_kpers = list(range(0, maxper)) if first < 0: first = maxper @@ -294,46 +332,17 @@ def write_file(self, f=None): fmt_string = self.stress_period_data.fmt_string cln_fmt_string = self.cln_stress_period_data.fmt_string - for kper in loop_over_kpers: - # Fill missing early kpers with 0 - if kper < first: - itmp = 0 - elif kper in kpers: - kper_data = deepcopy(self.stress_period_data.data[kper]) - kper_vtype = self.stress_period_data.vtype[kper] - if kper_vtype == np.recarray: - itmp = kper_data.shape[0] - lnames = [name.lower() for name in kper_data.dtype.names] - for idx in ["k", "i", "j", "node"]: - if idx in lnames: - kper_data[idx] += 1 - elif (kper_vtype == int) or (kper_vtype is None): - itmp = kper_data - # Fill late missing kpers with -1 - else: - itmp = -1 - - # Fill missing early kpers with 0 - if kper < cln_first: - itmpcln = 0 - elif kper in cln_kpers: - cln_kper_data = deepcopy( - self.cln_stress_period_data.data[kper] - ) - cln_kper_vtype = self.cln_stress_period_data.vtype[kper] - if cln_kper_vtype == np.recarray: - itmpcln = cln_kper_data.shape[0] - lnames = [ - name.lower() for name in cln_kper_data.dtype.names - ] - for idx in ["k", "i", "j", "node"]: - if idx in lnames: - cln_kper_data[idx] += 1 - elif (cln_kper_vtype == int) or (cln_kper_vtype is None): - itmpcln = cln_kper_data - # Fill late missing kpers with -1 - else: - itmpcln = -1 + for kper in range(maxper): + + # gw cell wells + itmp, kper_data = self._get_kper_data( + kper, first, self.stress_period_data + ) + + # cln wells + itmpcln, cln_kper_data = self._get_kper_data( + kper, cln_first, self.cln_stress_period_data + ) f_wel.write( f" {itmp:9d} {0:9d} {itmpcln:9d} # stress period {kper + 1}\n" @@ -348,6 +357,205 @@ def write_file(self, f=None): f_wel.close() + @staticmethod + def _load_dataset2(line): + """load mfusgwel dataset 2 from line""" + # dataset 2 -- MXACTW IWELCB [Option] + line_text = line.strip().split() + n_items = 2 + ipakcb = 0 + if len(line_text) > 1: + ipakcb = int(line_text[1]) + + options = [] + aux_names = [] + iunitafr = 0 + if len(line_text) > n_items: + item_n = n_items + while item_n < len(line_text): + toption = line_text[item_n] + if toption.lower() == "noprint": + options.append(toption.lower()) + elif toption.lower() == "autoflowreduce": + options.append(toption.lower()) + elif toption.lower() == "iunitafr": + options.append(" ".join(line_text[item_n : item_n + 2])) + iunitafr = int(line_text[item_n + 1]) + item_n += 1 + elif "aux" in toption.lower(): + options.append(" ".join(line_text[item_n : item_n + 2])) + aux_names.append(line_text[item_n + 1].lower()) + item_n += 1 + item_n += 1 + + return ipakcb, options, aux_names, iunitafr + + @staticmethod + def _load_itmp_itmpp_itmpcln(line): + """Reads itmp, itmpp and itmpcln from line. Returns None for blank line.""" + # strip comments from line + line = line[: line.find("#")] + + if line == "": + return None, None, None + line_text = line.strip().split() + # strip non-numerics from line items + line_text = [item for item in line_text if item.isdigit()] + + itmp = int(line_text[0]) + itmpp = 0 + if len(line_text) > 1: + itmpp = int(line_text[1]) + itmpcln = 0 + if len(line_text) > 2: + itmpcln = int(line_text[2]) + + return itmp, itmpp, itmpcln + + @staticmethod + def _load_dataset6( + f, itmp, model, aux_names, ext_unit_dict, structured=False + ): + """ + Reads dataset 6(a, b or c) from open file + + Parameters + ---------- + f : open file handle + itmp : int + Number of items to read from dataset6a + model : Flopy model object + aux_names : list of auxillary variable names + ext_unit_dict : dictionary, optional + External unit dictionary. + structured : bool, default if False. + model.structured, or if loading CLNs from dataset6a + even for a structured model, False. + + Returns + ------- + bnd_output : Numpy recarray + Wel Dataset 6a for itmp values + """ + + # get the list columns that should be scaled with sfac + sfac_columns = ModflowUsgWel._get_sfac_columns() + + if itmp == 0: + bnd_output = None + current = ModflowUsgWel.get_empty( + itmp, aux_names=aux_names, structured=structured + ) + elif itmp > 0: + current = ModflowUsgWel.get_empty( + itmp, aux_names=aux_names, structured=structured + ) + current = ulstrd( + f, itmp, current, model, sfac_columns, ext_unit_dict + ) + if structured: + current["k"] -= 1 + current["i"] -= 1 + current["j"] -= 1 + else: + current["node"] -= 1 + bnd_output = np.recarray.copy(current) + else: + if current is None: + bnd_output = None + else: + bnd_output = np.recarray.copy(current) + + return bnd_output + + @staticmethod + def _load_dataset7(f, itmpp, model, aux_names, pak_parms, bnd_output=None): + """ + Reads named parameters from wel file + + Parameters + ---------- + f : open file handle + itmpp : int, must be > 0 + Number of named parameters to read from dataset7 + model : Flopy model object + aux_names : list of auxillary variable names + pak_parms : named package parameters + read using mfparbc.load() + bnd_output : Numpy recarray of non-Named Parameter stress period data + Named parameters will be stacked on top of this. + + Returns + ------- + bnd_output : Numpy recarray + Wel Dataset 7 for itmpp values + """ + + if itmpp <= 0: + return bnd_output + + iparm = 0 + while iparm < itmpp: + line = f.readline() + line_text = line.strip().split() + pname = line_text[0].lower() + iname = "static" + try: + kper_iname = line_text[1].lower() + instance_dict = pak_parms.bc_parms[pname][1] + if kper_iname in instance_dict: + iname = kper_iname + else: + iname = "static" + except ValueError: + if model.verbose: + print(f" implicit static instance for parameter {pname}") + + par_dict, current_dict = pak_parms.get(pname) + data_dict = current_dict[iname] + + par_current = ModflowUsgWel.get_empty( + par_dict["nlst"], + aux_names=aux_names, + structured=model.structured, + ) + + # get appropriate parval + if model.mfpar.pval is None: + parval = float(par_dict["parval"]) + else: + try: + parval = float(model.mfpar.pval.pval_dict[pname]) + except ValueError: + parval = float(par_dict["parval"]) + + # fill current parameter data (par_current) + for ibnd, vals in enumerate(data_dict): + vals = tuple(vals) + par_current[ibnd] = tuple(vals[: len(par_current.dtype.names)]) + + if model.structured: + par_current["k"] -= 1 + par_current["i"] -= 1 + par_current["j"] -= 1 + else: + par_current["node"] -= 1 + + par_current["flux"] *= parval + + if bnd_output is None: + bnd_output = np.recarray.copy(par_current) + else: + bnd_output = stack_arrays( + (bnd_output, par_current), + asrecarray=True, + usemask=False, + ) + + iparm += 1 + + return bnd_output + @classmethod def load(cls, f, model, nper=None, ext_unit_dict=None): """ @@ -387,14 +595,12 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): print("loading wel package file...") # open the file if not already open - openfile = not hasattr(f, "read") - if openfile: + if not hasattr(f, "read"): filename = f f = open(filename, "r") elif hasattr(f, "name"): filename = f.name - else: - filename = "?" + f = open(filename, "r") # dataset 0 -- header while True: @@ -405,11 +611,9 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): # dataset 1a -- check for parameters npwel = 0 if "parameter" in line.lower(): - t = line.strip().split() - npwel = int(t[1]) - mxl = 0 + line_text = line.strip().split() + npwel = int(line_text[1]) if npwel > 0: - mxl = int(t[2]) if model.verbose: print( f" Parameters detected. Number of parameters = {npwel}" @@ -417,47 +621,16 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): line = f.readline() # dataset 2 -- MXACTW IWELCB [Option] - t = line.strip().split() - imax = 2 - ipakcb = 0 - try: - ipakcb = int(t[1]) - except: - if model.verbose: - print(f" implicit ipakcb in {filename}") - - options = [] - aux_names = [] - iunitafr = 0 - if len(t) > imax: - it = imax - while it < len(t): - toption = t[it] - if toption.lower() == "noprint": - options.append(toption.lower()) - elif toption.lower() == "autoflowreduce": - options.append(toption.lower()) - elif toption.lower() == "iunitafr": - options.append(" ".join(t[it : it + 2])) - iunitafr = int(t[it + 1]) - it += 1 - elif "aux" in toption.lower(): - options.append(" ".join(t[it : it + 2])) - aux_names.append(t[it + 1].lower()) - it += 1 - it += 1 - - # get the list columns that should be scaled with sfac - sfac_columns = ModflowUsgWel._get_sfac_columns() + ipakcb, options, aux_names, iunitafr = cls._load_dataset2(line) - # dataset 3 -- read parameter data + # dataset 3 and 4 -- read parameter data if npwel > 0: - dt = ModflowUsgWel.get_empty( + par_dt = ModflowUsgWel.get_empty( 1, aux_names=aux_names, structured=model.structured ).dtype # dataset 4 -- pak_parms = mfparbc.load( - f, npwel, dt, model, ext_unit_dict, model.verbose + f, npwel, par_dt, model, ext_unit_dict, model.verbose ) if nper is None: @@ -466,143 +639,35 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): # dataset 5 -- read data for every stress period bnd_output = None stress_period_data = {} - current = None cln_bnd_output = None cln_stress_period_data = {} - cln_current = None for iper in range(nper): if model.verbose: msg = f" loading well data for kper {iper + 1:5d}" print(msg) line = f.readline() - if line == "": + itmp, itmpp, itmpcln = cls._load_itmp_itmpp_itmpcln(line) + if itmp is None: break - t = line.strip().split() - itmp = int(t[0]) - itmpp = 0 - try: - itmpp = int(t[1]) - except: - if model.verbose: - print(f" implicit itmpp in {filename}") - - try: - itmpcln = int(t[2]) - except: - itmpcln = 0 # dataset 6a -- read well data - if itmp == 0: - bnd_output = None - current = ModflowUsgWel.get_empty( - itmp, aux_names=aux_names, structured=model.structured - ) - elif itmp > 0: - current = ModflowUsgWel.get_empty( - itmp, aux_names=aux_names, structured=model.structured - ) - current = ulstrd( - f, itmp, current, model, sfac_columns, ext_unit_dict - ) - if model.structured: - current["k"] -= 1 - current["i"] -= 1 - current["j"] -= 1 - else: - current["node"] -= 1 - bnd_output = np.recarray.copy(current) - else: - if current is None: - bnd_output = None - else: - bnd_output = np.recarray.copy(current) + bnd_output = cls._load_dataset6( + f, itmp, model, aux_names, ext_unit_dict, model.structured + ) # dataset 6c -- read CLN well data - if itmpcln == 0: - cln_bnd_output = None - cln_current = ModflowUsgWel.get_empty( - itmp, aux_names=aux_names, structured=False - ) - elif itmpcln > 0: - cln_current = ModflowUsgWel.get_empty( - itmpcln, aux_names=aux_names, structured=False - ) - cln_current = ulstrd( - f, itmpcln, cln_current, model, sfac_columns, ext_unit_dict - ) - cln_current["node"] -= 1 - cln_bnd_output = np.recarray.copy(cln_current) - else: - if cln_current is None: - cln_bnd_output = None - else: - cln_bnd_output = np.recarray.copy(cln_current) + cln_bnd_output = cls._load_dataset6( + f, itmpcln, model, aux_names, ext_unit_dict, False + ) # dataset 7 -- parameter data - for iparm in range(itmpp): - line = f.readline() - t = line.strip().split() - pname = t[0].lower() - iname = "static" - try: - tn = t[1] - c = tn.lower() - instance_dict = pak_parms.bc_parms[pname][1] - if c in instance_dict: - iname = c - else: - iname = "static" - except: - if model.verbose: - print( - f" implicit static instance for parameter {pname}" - ) - - par_dict, current_dict = pak_parms.get(pname) - data_dict = current_dict[iname] - - par_current = ModflowUsgWel.get_empty( - par_dict["nlst"], - aux_names=aux_names, - structured=model.structured, + if itmpp > 0: + bnd_output = cls._load_dataset7( + f, itmpp, model, aux_names, pak_parms, bnd_output ) - # get appropriate parval - if model.mfpar.pval is None: - parval = float(par_dict["parval"]) - else: - try: - parval = float(model.mfpar.pval.pval_dict[pname]) - except: - parval = float(par_dict["parval"]) - - # fill current parameter data (par_current) - for ibnd, t in enumerate(data_dict): - t = tuple(t) - par_current[ibnd] = tuple( - t[: len(par_current.dtype.names)] - ) - - if model.structured: - par_current["k"] -= 1 - par_current["i"] -= 1 - par_current["j"] -= 1 - else: - par_current["node"] -= 1 - - par_current["flux"] *= parval - - if bnd_output is None: - bnd_output = np.recarray.copy(par_current) - else: - bnd_output = stack_arrays( - (bnd_output, par_current), - asrecarray=True, - usemask=False, - ) - if bnd_output is None: stress_period_data[iper] = itmp else: @@ -613,7 +678,7 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): else: cln_stress_period_data[iper] = cln_bnd_output - if openfile: + if hasattr(f, "read"): f.close() # set package unit number From 8d486592212799c7872fb65ff0d06e11be93b06a Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Mon, 4 Oct 2021 16:41:15 +1100 Subject: [PATCH 11/14] refactor(mfusgcln and other mfusg files) linting --- flopy/modflowusg/mfusg.py | 7 +- flopy/modflowusg/mfusgbcf.py | 13 + flopy/modflowusg/mfusgcln.py | 1097 +++++++++++++++++---------------- flopy/modflowusg/mfusgdisu.py | 16 +- flopy/modflowusg/mfusggnc.py | 14 +- flopy/modflowusg/mfusglpf.py | 14 +- flopy/modflowusg/mfusgsms.py | 140 ++--- flopy/modflowusg/mfusgwel.py | 12 +- 8 files changed, 696 insertions(+), 617 deletions(-) diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py index 22dc7f68bb..4fd0e7ee0e 100644 --- a/flopy/modflowusg/mfusg.py +++ b/flopy/modflowusg/mfusg.py @@ -72,10 +72,15 @@ def __init__( "external_path": None, "verbose": False, } + for arg, default_value in valid_args_defaults.items(): setattr(self, arg, kwargs.pop(arg, default_value)) - setattr(self, "version", "mfusg") + # remove "version" from kwarg if inadvertently provided + try: + kwargs.pop("version") + except KeyError: + pass super().__init__( modelname, diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py index a094a29bba..262b1f0409 100644 --- a/flopy/modflowusg/mfusgbcf.py +++ b/flopy/modflowusg/mfusgbcf.py @@ -7,6 +7,7 @@ import numpy as np from ..modflow import ModflowBcf +from .mfusg import ModflowUsg from ..utils import Util2d, Util3d from ..utils.flopy_io import line_parse from ..utils.utils_def import ( @@ -131,6 +132,12 @@ def __init__( Constructs the ModflowUsgBcf object. Overrides the parent ModflowBcf object.""" + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg + valid_args_defaults = { "ipakcb": None, "intercellt": 0, @@ -494,6 +501,12 @@ def load(cls, f, model, ext_unit_dict=None): >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> bcf = flopy.modflowusg.ModflowUsgBcf.load('test.bcf', m) """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg + if model.verbose: print("loading bcf package file...") diff --git a/flopy/modflowusg/mfusgcln.py b/flopy/modflowusg/mfusgcln.py index ec271cd976..3aa154a62d 100644 --- a/flopy/modflowusg/mfusgcln.py +++ b/flopy/modflowusg/mfusgcln.py @@ -1,5 +1,7 @@ """ -mfusgcln module. Contains the ModflowUsgCln class. Note that the user can +mfusgcln module. + +Contains the ModflowUsgCln class. Note that the user can access the ModflowUsgCln class as `flopy.modflowusg.ModflowUsgCln`. Compatible with USG-Transport Version 1.7.0. which can be downloade from @@ -16,12 +18,12 @@ volume finite-difference formulation: U.S. Geological Survey Techniques and Methods, book 6, chap. A45, 66 p. """ - +import warnings import numpy as np from ..pakbase import Package from ..utils import Util2d -from .mfusg import fmt_string +from .mfusg import fmt_string, ModflowUsg class ModflowUsgCln(Package): @@ -56,7 +58,7 @@ class ModflowUsgCln(Package): clncon : list of list are the CLN-node numbers associated with each CLN segment. Only read if NCLN > 0 and ICLNNDS > 0. It is read NCLN times, once for each CLN - segment. The number of entries for each line is the number of CLN + segment. The number of entries for each sublist is the number of CLN cells (NNDCLN) associated with each CLN segment nja_cln : int is the total number of connections of the CLN domain. NJA_CLN is used @@ -111,11 +113,11 @@ class ModflowUsgCln(Package): [IRECTYP FLENGTH FHEIGHT CONDUITK TCOND TTHK TCFLUID TCONV] is read for each rectangular conduit. Total rows of the table equals nrectyp. Last 4 fields only needed for heat transport simulation. - BHE : bool - is a flag indicating that BHE details are also included in a heat transport - model. Specifically, the thermal conductance and BHE tube thickness are + bhe : bool + is a flag indicating that bhe details are also included in a heat transport + model. Specifically, the thermal conductance and bhe tube thickness are included in transfer of heat between groundwater and CLN cells along with - the heat conductivity of the BHE fluid and the convective heat transfer + the heat conductivity of the bhe fluid and the convective heat transfer coefficient. grav : float is the gravitational acceleration constant in model simulation units. @@ -163,69 +165,87 @@ class ModflowUsgCln(Package): def __init__( self, model, - ncln=None, # number of CLNs - iclnnds=None, # number of nodes - nndcln=None, # number of nodes in each CLN segments - clncon=None, # node IDs in each CLN segments - nja_cln=None, # total number of node-node connections (NJAG) - iac_cln=None, # number of connections for each node (sum(IAC)=NJAG - ja_cln=None, # node connections - node_prop=None, # node properties - nclngwc=None, # number of CLN-GW connections - cln_gwc=None, # CLN-GW connections - nconduityp=1, # number of circular conduit types - cln_circ=None, # circular conduit properties - ibound=1, # boundary condition types - strt=1.0, # initial head in CLN cells - transient=False, # OPTIONS: transient IBOUND for each stress period - printiaja=False, # OPTIONS: print IA_CLN and JA_CLN to listing file - nrectyp=0, # OPTIONS2: number of rectangular fracture types - cln_rect=None, # rectangular fracture properties - BHE=False, # OPTIONS2: borehole heat exchanger (BHE) - grav=None, # OPTIONS2: gravitational acceleration constant - visk=None, # OPTIONS2: kinematic viscosity of water - extension=[ - "cln", - "clncb", - "clnhd", - "clndd", - "clnib", - "clncn", - "clnmb", - ], - unitnumber=None, - filenames=None, + **kwargs, ): - if model.version != "mfusg": - err = "Error: model version must be mfusg to use CLN package" - raise Exception(err) + """Package constructor""" + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg + + valid_args_defaults = { + "ncln": None, # number of CLNs + "iclnnds": None, # number of nodes + "nndcln": None, # number of nodes in each CLN segments + "clncon": None, # node IDs in each CLN segments + "nja_cln": None, # total number of node-node connections (NJAG) + "iac_cln": None, # number of connections for each node (sum(IAC)": NJAG + "ja_cln": None, # node connections + "node_prop": None, # node properties + "nclngwc": None, # number of CLN-GW connections + "cln_gwc": None, # CLN-GW connections + "nconduityp": 1, # number of circular conduit types + "cln_circ": None, # circular conduit properties + "ibound": 1, # boundary condition types + "strt": 1.0, # initial head in CLN cells + "transient": False, # OPTIONS: transient IBOUND for each stress period + "printiaja": False, # OPTIONS: print IA_CLN and JA_CLN to listing file + "nrectyp": 0, # OPTIONS2: number of rectangular fracture types + "cln_rect": None, # rectangular fracture properties + "bhe": False, # OPTIONS2: borehole heat exchanger (bhe) + "grav": None, # OPTIONS2: gravitational acceleration constant + "visk": None, # OPTIONS2: kinematic viscosity of water + "extension": [ + "cln", + "clncb", + "clnhd", + "clndd", + "clnib", + "clncn", + "clnmb", + ], + "unitnumber": None, + "filenames": None, + } + + for arg, default_value in valid_args_defaults.items(): + setattr(self, arg, kwargs.pop(arg, default_value)) # set default unit number of one is not specified - if unitnumber is None: - unitnumber = ModflowUsgCln._defaultunit() - elif isinstance(unitnumber, list): - if len(unitnumber) < 7: - for idx in range(len(unitnumber), 7): - unitnumber.append(0) + if self.unitnumber is None: + self.unitnumber = ModflowUsgCln._defaultunit() + elif isinstance(self.unitnumber, list): + if len(self.unitnumber) < 7: + for idx in range(len(self.unitnumber), 7): + self.unitnumber.append(0) # set filenames - if filenames is None: - filenames = [None, None, None, None, None, None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None, None, None, None, None] - elif isinstance(filenames, list): - if len(filenames) < 7: - for idx in range(len(filenames), 7): - filenames.append(None) + if self.filenames is None: + self.filenames = [None, None, None, None, None, None, None] + elif isinstance(self.filenames, str): + self.filenames = [ + self.filenames, + None, + None, + None, + None, + None, + None, + ] + elif isinstance(self.filenames, list): + if len(self.filenames) < 7: + for idx in range(len(self.filenames), 7): + self.filenames.append(None) # Fill namefile items name = [ModflowUsgCln._ftype()] extra = [""] - exten = [extension[0]] - units = unitnumber[0] + exten = [self.extension[0]] + units = self.unitnumber[0] # set package name - fname = [filenames[0]] + fname = [self.filenames[0]] # Call ancestor's init to set self.parent, extension, name and unit number Package.__init__( self, @@ -241,108 +261,134 @@ def __init__( self._generate_heading() - # Options - self.transient = transient - self.printiaja = printiaja + # CLN output files + # reset extension (overwritten by package init?) + if "extension" not in kwargs.keys(): + self.extension = [ + "cln", + "clncb", + "clnhd", + "clndd", + "clnib", + "clncn", + "clnmb", + ] - # Options2 is for Darcy-Weisbach equation. Not used. - self.nrectyp = nrectyp - self.BHE = BHE - self.grav = grav - self.visk = visk + for idx, attr in enumerate(self.extension[1:]): + setattr(self, f"i{attr}", self.unitnumber[idx + 1]) + if getattr(self, f"i{attr}") > 0: + model.add_output_file( + getattr(self, f"i{attr}"), + fname=self.filenames[idx + 1], + extension=attr, + binflag=True, + package=ModflowUsgCln._ftype(), + ) - # CLN output files - self.iclncb = unitnumber[1] - # >0: File unit for CLN CBB; 0 No budget output; <0 budget in List file - if self.iclncb > 0: - model.add_output_file( - self.iclncb, - fname=filenames[1], - extension=extension[1], - binflag=True, - package=ModflowUsgCln._ftype(), - ) - self.iclnhd = unitnumber[2] - # >0: File unit for CLN HDS; 0: No head output; - if self.iclnhd > 0: - model.add_output_file( - self.iclnhd, - fname=filenames[2], - extension=extension[2], - binflag=True, - package=ModflowUsgCln._ftype(), - ) - self.iclndd = unitnumber[3] - # >0: File unit for CLN Drawdown; 0: No drawdown output; - if self.iclndd > 0: - model.add_output_file( - self.iclndd, - fname=filenames[3], - extension=extension[3], - binflag=True, - package=ModflowUsgCln._ftype(), - ) - self.iclnib = unitnumber[4] - # >0: File unit for CLN IBOUND; 0: No IBOUND output; - if self.iclnib > 0: - model.add_output_file( - self.iclnib, - fname=filenames[4], - extension=extension[4], - binflag=True, - package=ModflowUsgCln._ftype(), - ) - self.iclncn = unitnumber[5] - # >0: File unit for CLN concentration; 0: No concentration output; - if self.iclncn > 0: - model.add_output_file( - self.iclncn, - fname=filenames[5], - extension=extension[5], - binflag=True, - package=ModflowUsgCln._ftype(), + # Define CLN networks and connections + self._define_cln_networks(model) + + # Define CLN node properties + if self.node_prop is None: + raise Exception("mfcln: Node properties must be provided") + + if len(self.node_prop) != self.nclnnds: + raise Exception( + "mfcln: Length of Node properties must equal number of nodes" ) - self.iclnmb = unitnumber[6] - # >0: File unit for CLN mass flux; 0: No mass flux output; - if self.iclnmb > 0: - model.add_output_file( - self.iclnmb, - fname=filenames[6], - extension=extension[6], - binflag=True, - package=ModflowUsgCln._ftype(), + + self.node_prop = self._make_recarray( + self.node_prop, dtype=ModflowUsgCln.get_clnnode_dtype() + ) + + # Define CLN groundwater connections + if self.nclngwc is None: + raise Exception("mfcln: Number of CLN-GW connections not defined") + + if self.cln_gwc is None: + raise Exception("mfcln: CLN-GW connections not provided") + + if len(self.cln_gwc) != self.nclngwc: + raise Exception( + "mfcln: Number of CLN-GW connections not equal to nclngwc" ) - ## Define CLN networks - if ncln is None: + structured = self.parent.structured + + self.cln_gwc = self._make_recarray( + self.cln_gwc, dtype=ModflowUsgCln.get_gwconn_dtype(structured) + ) + + # Define CLN geometry types + self._define_cln_geometries() + + # Define CLN ibound and initial heads properties + self.ibound = Util2d( + model, + (self.nclnnds,), + np.int32, + self.ibound, + name="ibound", + locat=self.unit_number[0], + ) + + self.strt = Util2d( + model, + (self.nclnnds,), + np.float32, + self.strt, + name="strt", + locat=self.unit_number[0], + ) + + self.parent.add_package(self) + + def __getattr__(self, name): + """ + Get class attributes to avoid pylint E1101 false positives + + Will only get called for undefined attributes, given dynamic variable definitions. + """ + warnings.warn( + f"No member '{name}' contained in {type(self).__name__})" + ) + return "" + + def _define_cln_networks(self, model): + """Initialises CLN netoworks""" + if self.ncln is None: raise Exception("mfcln: CLN network not defined") - self.ncln = ncln - self.iclnnds = iclnnds + if self.ncln < 0: + raise Exception( + "mfcln: negative number of CLN segments in CLN package" + ) if self.ncln > 0: # Linear CLN segments - if nndcln is None: + if self.nndcln is None: raise Exception( - "mfcln: nodes for each CLN segment must be provided" + "mfcln: number of nodes for each CLN segment must be " + "provided" ) self.nndcln = Util2d( model, (self.ncln,), np.int32, - nndcln, + self.nndcln, name="nndcln", locat=self.unit_number[0], ) - # consequtive node number. No connection between segments + # consecutive node number. No connection between segments if self.iclnnds < 0: self.nclnnds = self.nndcln.array.sum() - self.nodeno = [x + 1 for x in range(self.nclnnds)] + self.nodeno = np.array(range(self.nclnnds), dtype=int) + 1 # Node number provided for each segment to simulate CLN networks elif self.iclnnds > 0: self.nclnnds = self.iclnnds - self.clncon = clncon - self.nodeno = list(set(clncon)) + self.nodeno = ( + np.asarray(set(self.clncon), dtype=object) + 1 + ) # can be jagged else: raise Exception("mfcln: Node number = 0") @@ -352,121 +398,64 @@ def __init__( self.nclnnds = self.iclnnds - self.nodeno = [x + 1 for x in range(self.nclnnds)] - - self.nja_cln = nja_cln + self.nodeno = np.array(range(self.nclnnds), dtype=int) + 1 - if iac_cln is None: + if self.iac_cln is None: raise Exception("mfcln: iac_cln must be provided") self.iac_cln = Util2d( model, (self.nclnnds,), np.int32, - iac_cln, + self.iac_cln, name="iac_cln", locat=self.unit_number[0], ) msg = "mfcln: The sum of iac_cln must equal nja_cln." - assert self.iac_cln.array.sum() == nja_cln, msg + assert self.iac_cln.array.sum() == self.nja_cln, msg - if ja_cln is None: + if self.ja_cln is None: raise Exception("mfcln: ja_cln must be provided") - if ja_cln[0] == 0: - # convert from zero-based to one-based - ja_cln += 1 + if abs(self.ja_cln[0]) != 1: + raise Exception( + "mfcln: first ja_cln entry (node 1) is " "not 1 or -1." + ) self.ja_cln = Util2d( model, (self.nja_cln,), np.int32, - ja_cln, + self.ja_cln, name="ja_cln", locat=self.unit_number[0], ) - else: - raise Exception( - "mfcln: negative number of CLN segments in CLN package" - ) - - if node_prop is None: - raise Exception("mfcln: Node properties must be provided") - - if len(node_prop) != self.nclnnds: - raise Exception( - "mfcln: Length of Node properties must equal number of nodes" - ) - - self.node_prop = make_recarray( - node_prop, dtype=ModflowUsgCln.get_clnnode_dtype() - ) - - if nclngwc is None: - raise Exception("mfcln: CLN-GW connections not defined") - self.nclngwc = nclngwc # number of CLN-GW connections - - if cln_gwc is None: - raise Exception("mfcln: CLN-GW connection not provided") - - if len(cln_gwc) != self.nclngwc: - raise Exception( - "mfcln: Number of CLN-GW connections not equal nclngwc" - ) - - structured = self.parent.structured - - self.cln_gwc = make_recarray( - cln_gwc, dtype=ModflowUsgCln.get_gwconn_dtype(structured) - ) - + def _define_cln_geometries(self): + """Initialises CLN geometry types""" # Circular conduit geometry types - - self.nconduityp = nconduityp - - if self.nconduityp <= 0 or cln_circ is None: + if self.nconduityp <= 0 or self.cln_circ is None: raise Exception( "mfcln: Circular conduit properties must be provided" ) - if len(cln_circ) != self.nconduityp: + if len(self.cln_circ) != self.nconduityp: raise Exception( "mfcln: Number of circular properties not equal nconduityp" ) - self.cln_circ = make_recarray( - cln_circ, dtype=ModflowUsgCln.get_clncirc_dtype(self.BHE) + self.cln_circ = self._make_recarray( + self.cln_circ, dtype=ModflowUsgCln.get_clncirc_dtype(self.bhe) ) # Rectangular conduit geometry types if self.nrectyp > 0: - if len(cln_rect) != self.nconduityp: + if len(self.cln_rect) != self.nconduityp: raise Exception( "mfcln: Number of rectangular properties not equal nrectyp" ) - self.cln_rect = make_recarray( - cln_rect, dtype=ModflowUsgCln.get_clnrect_dtype(self.BHE) + self.cln_rect = self._make_recarray( + self.cln_rect, dtype=ModflowUsgCln.get_clnrect_dtype(self.bhe) ) - self.ibound = Util2d( - model, - (self.nclnnds,), - np.int32, - ibound, - name="ibound", - locat=self.unit_number[0], - ) - - self.strt = Util2d( - model, - (self.nclnnds,), - np.float32, - strt, - name="strt", - locat=self.unit_number[0], - ) - - self.parent.add_package(self) - @staticmethod def get_clnnode_dtype(): """ @@ -479,20 +468,20 @@ def get_clnnode_dtype(): """ dtype = np.dtype( [ - ("ifno", int), ## node number - ("iftyp", int), ## type-index - ("ifdir", int), ## directional index - ("fleng", np.float32), ## length - ("felev", np.float32), ## elevation of the bottom - ("fangle", np.float32), ## angle - ("iflin", int), ## flag of flow conditions - ("iccwadi", int), ## flag of vertical flow correction - ("x1", np.float32), ## coordinates - ("y1", np.float32), ## coordinates - ("z1", np.float32), ## coordinates - ("x2", np.float32), ## coordinates - ("y2", np.float32), ## coordinates - ("z2", np.float32), ## coordinates + ("ifno", int), # node number + ("iftyp", int), # type-index + ("ifdir", int), # directional index + ("fleng", np.float32), # length + ("felev", np.float32), # elevation of the bottom + ("fangle", np.float32), # angle + ("iflin", int), # flag of flow conditions + ("iccwadi", int), # flag of vertical flow correction + ("x1", np.float32), # coordinates + ("y1", np.float32), # coordinates + ("z1", np.float32), # coordinates + ("x2", np.float32), # coordinates + ("y2", np.float32), # coordinates + ("z2", np.float32), # coordinates ] ) return dtype @@ -514,122 +503,122 @@ def get_gwconn_dtype(structured=True): if structured: dtype = np.dtype( [ - ("ifnod", int), ##CLN node number - ("igwlay", int), ##layer number of connecting gw node - ("igwrow", int), ##row number of connecting gw node - ("igwfcol", int), ##col number of connecting gw node - ("ifcon", int), ##index of connectivity equation - ("fskin", np.float32), ##leakance across a skin - ("flengw", np.float32), ##length of connection + ("ifnod", int), # CLN node number + ("igwlay", int), # layer number of connecting gw node + ("igwrow", int), # row number of connecting gw node + ("igwfcol", int), # col number of connecting gw node + ("ifcon", int), # index of connectivity equation + ("fskin", np.float32), # leakance across a skin + ("flengw", np.float32), # length of connection ( "faniso", np.float32, - ), ##anisotropy or thickness of sediments - ("icgwadi", int), ##flag of vertical flow correction + ), # anisotropy or thickness of sediments + ("icgwadi", int), # flag of vertical flow correction ] ) else: dtype = np.dtype( [ - ("ifnod", int), ##CLN node number - ("igwnod", int), ##node number of connecting gw node - ("ifcon", int), ##index of connectivity equation - ("fskin", np.float32), ##leakance across a skin - ("flengw", np.float32), ##length of connection + ("ifnod", int), # CLN node number + ("igwnod", int), # node number of connecting gw node + ("ifcon", int), # index of connectivity equation + ("fskin", np.float32), # leakance across a skin + ("flengw", np.float32), # length of connection ( "faniso", np.float32, - ), ##anisotropy or thickness of sediments - ("icgwadi", int), ##flag of vertical flow correction + ), # anisotropy or thickness of sediments + ("icgwadi", int), # flag of vertical flow correction ] ) return dtype @staticmethod - def get_clncirc_dtype(BHE=False): + def get_clncirc_dtype(bhe=False): """ dtype of CLN node circular conduit type properties. Parameters ---------- - BHE : borehole heat exchanger (BHE) + bhe : borehole heat exchanger (bhe) Returns ------- dtype """ - if BHE: + if bhe: dtype = np.dtype( [ - ("iconduityp", int), ## index of circular conduit type - ("frad", np.float32), ## radius + ("iconduityp", int), # index of circular conduit type + ("frad", np.float32), # radius ( "conduitk", np.float32, - ), ## conductivity or resistance factor - ("tcond", np.float32), ## thermal conductivity of BHE tube - ("tthk", np.float32), ## thickness + ), # conductivity or resistance factor + ("tcond", np.float32), # thermal conductivity of bhe tube + ("tthk", np.float32), # thickness ( "tcfluid", np.float32, - ), ## thermal conductivity of the fluid - ("tconv", np.float32), ## thermal convective coefficient + ), # thermal conductivity of the fluid + ("tconv", np.float32), # thermal convective coefficient ] ) else: dtype = np.dtype( [ - ("iconduityp", int), ## index of circular conduit type - ("frad", np.float32), ## radius + ("iconduityp", int), # index of circular conduit type + ("frad", np.float32), # radius ( "conduitk", np.float32, - ), ## conductivity or resistance factor + ), # conductivity or resistance factor ] ) return dtype @staticmethod - def get_clnrect_dtype(BHE=False): + def get_clnrect_dtype(bhe=False): """ Returns the dtype of CLN node rectangular conduit type properties. Parameters ---------- - BHE : borehole heat exchanger (BHE) + bhe : borehole heat exchanger (bhe) Returns ------- dtype """ - if BHE: + if bhe: dtype = np.dtype( [ - ("irectyp", int), ## index of rectangular conduit type - ("flength", np.float32), ## width - ("fheight", np.float32), ## height + ("irectyp", int), # index of rectangular conduit type + ("flength", np.float32), # width + ("fheight", np.float32), # height ( "conduitk", np.float32, - ), ## conductivity or resistance factor - ("tcond", np.float32), ## thermal conductivity of BHE tube - ("tthk", np.float32), ## thickness of BHE tube - ("tcfluid", np.float32), ## thermal conductivity of fluid - ("tconv", np.float32), ## thermal convective + ), # conductivity or resistance factor + ("tcond", np.float32), # thermal conductivity of bhe tube + ("tthk", np.float32), # thickness of bhe tube + ("tcfluid", np.float32), # thermal conductivity of fluid + ("tconv", np.float32), # thermal convective ] ) else: dtype = np.dtype( [ - ("irectyp", int), ## index of rectangular conduit type - ("flength", np.float32), ## width - ("fheight", np.float32), ## height + ("irectyp", int), # index of rectangular conduit type + ("flength", np.float32), # width + ("fheight", np.float32), # height ( "conduitk", np.float32, - ), ## conductivity or resistance factor + ), # conductivity or resistance factor ] ) return dtype @@ -661,35 +650,8 @@ def write_file(self, f=None): f_cln.write(f"{self.heading}\n") - if self.transient or self.printiaja: - f_cln.write("OPTIONS ") - if self.transient: - f_cln.write("TRANSIENT ") - if self.printiaja: - f_cln.write("PRINTIAJA ") - f_cln.write("\n") - - f_cln.write( - ( - f" {self.ncln:9d} {self.iclnnds:9d} {self.iclncb:9d}" - f" {self.iclnhd:9d} {self.iclndd:9d} {self.iclnib:9d}" - f" {self.nclngwc:9d} {self.nconduityp:9d}" - ) - ) - - if self.nrectyp > 0: - f_cln.write(f"RECTANGULAR {self.nrectyp:d}") - if self.BHE: - f_cln.write("BHEDETAIL ") - if self.iclncn != 0: - f_cln.write(f"SAVECLNCON {self.iclncn:d}") - if self.iclnmb != 0: - f_cln.write(f"SAVECLNMAS {self.iclnmb:d}") - if self.grav is not None: - f_cln.write(f"GRAVITY {self.grav:f}") - if self.visk is not None: - f_cln.write(f"VISCOSITY {self.visk:f}") - f_cln.write("\n") + # write items 0 and 1 + self._write_items_0_1(f_cln) if self.ncln > 0: f_cln.write(self.nndcln.get_file_entry()) @@ -730,6 +692,38 @@ def write_file(self, f=None): f_cln.close() + def _write_items_0_1(self, f_cln): + """writes cln items 0 and 1""" + if self.transient or self.printiaja: + f_cln.write("OPTIONS ") + if self.transient: + f_cln.write("TRANSIENT ") + if self.printiaja: + f_cln.write("PRINTIAJA ") + f_cln.write("\n") + + f_cln.write( + ( + f" {self.ncln:9d} {self.iclnnds:9d} {self.iclncb:9d}" + f" {self.iclnhd:9d} {self.iclndd:9d} {self.iclnib:9d}" + f" {self.nclngwc:9d} {self.nconduityp:9d}" + ) + ) + + if self.nrectyp > 0: + f_cln.write(f"RECTANGULAR {self.nrectyp:d}") + if self.bhe: + f_cln.write("BHEDETAIL ") + if self.iclncn != 0: + f_cln.write(f"SAVECLNCON {self.iclncn:d}") + if self.iclnmb != 0: + f_cln.write(f"SAVECLNMAS {self.iclnmb:d}") + if self.grav is not None: + f_cln.write(f"GRAVITY {self.grav:f}") + if self.visk is not None: + f_cln.write(f"VISCOSITY {self.visk:f}") + f_cln.write("\n") + @classmethod def load(cls, f, model, ext_unit_dict=None): """ @@ -759,226 +753,104 @@ def load(cls, f, model, ext_unit_dict=None): >>> import flopy >>> m = flopy.modflow.Modflow() >>> cln = flopy.modflowusg.ModflowUsgCln.load('test.cln', m) - """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg if model.verbose: print("loading CLN package file...\n") - if model.version != "mfusg": - msg = ( - "Warning: model version was reset from " - + "'{}' to 'mfusg' in order to load a CLN file".format( - model.version - ) - ) - print(msg) - model.version = "mfusg" - - openfile = not hasattr(f, "read") - if openfile: + if not hasattr(f, "read"): filename = f f = open(filename, "r") - line = f.readline() - - # Options - transient = False - printiaja = False - if line.startswith("OPTIONS"): - t = line.strip().split() - if "TRANSIENT" in t: - transient = True - if "PRINTIAJA" in t: - printiaja = True - line = f.readline() - - t = line.strip().split() - ncln, iclnnds, iclncb, iclnhd, iclndd, iclnib, nclngwc, nconduityp = ( - int(t[0]), - int(t[1]), - int(t[2]), - int(t[3]), - int(t[4]), - int(t[5]), - int(t[6]), - int(t[7]), - ) - # Options2 - if "RECTANGULAR" in t: - idx = t.index("RECTANGULAR") - nrectyp = int(t[idx + 1]) - else: - nrectyp = 0 - cln_rect = None - - if "BHEDETAIL" in t: - BHE = True - else: - BHE = False - - if "SAVECLNCON" in t: - idx = t.index("SAVECLNCON") - iclncn = int(t[idx + 1]) - else: - iclncn = 0 - - if "SAVECLNMAS" in t: - idx = t.index("SAVECLNMAS") - iclnmb = int(t[idx + 1]) - else: - iclnmb = 0 - - if "GRAVITY" in t: - idx = t.index("GRAVITY") - grav = float(t[idx + 1]) - else: - grav = None - - if "VISCOSITY" in t: - idx = t.index("VISCOSITY") - visk = float(t[idx + 1]) - else: - visk = None + # Items 0 and 1 + ( + transient, + printiaja, + ncln, + iclnnds, + iclncb, + iclnhd, + iclndd, + iclnib, + nclngwc, + nconduityp, + nrectyp, + cln_rect, + bhe, + iclncn, + iclnmb, + grav, + visk, + ) = cls._load_items_0_1(f, model) + + # Items 3, or 4/5/6 + ( + nndcln, + clncon, + nja_cln, + iac_cln, + ja_cln, + nclnnds, + ) = cls._load_items_3to6(f, model, ncln, iclnnds, ext_unit_dict) if model.verbose: - print(" ncln {}".format(ncln)) - print(" iclnnds {}".format(iclnnds)) - print(" iclncb {}".format(iclncb)) - print(" iclnhd {}".format(iclnhd)) - print(" iclndd {}".format(iclndd)) - print(" iclnib {}".format(iclnib)) - print(" nclngwc {}".format(nclngwc)) - print(" TRANSIENT {}".format(transient)) - print(" PRINTIAJA {}".format(printiaja)) - print(" RECTANGULAR {}".format(nrectyp)) - print(" BHEDETAIL {}".format(BHE)) - print(" SAVECLNCON {}".format(iclncn)) - print(" SAVECLNMAS {}".format(iclnmb)) - print(" GRAVITY {}".format(grav)) - print(" VISCOSITY {}".format(visk)) + print(" Reading node_prop...") + node_prop = cls._read_prop(f, nclnnds) - nndcln = None - clncon = None - nja_cln = None - iac_cln = None - ja_cln = None - if ncln > 0: - nndcln = Util2d.load( - f, model, (ncln,), np.int32, "nndcln", ext_unit_dict - ) - if model.verbose: - print(" nndcln {}".format(nndcln)) - nclnnds = nndcln.array.sum() - if iclnnds > 0: - nclnnds = iclnnds - clncon = [] - for icln in range(ncln): - line = f.readline() - t = line.strip().split() - - iclncon = [] - for i in range(nndcln[icln]): - iclncon.append(t[i]) - - clncon = clncon.append(iclncon) - if model.verbose: - print(" clncon {}".format(clncon)) - - elif ncln == 0: - line = f.readline() - t = line.strip().split() - nja_cln = int(t[0]) - if model.verbose: - print(" nja_cln {}".format(nja_cln)) - - nclnnds = abs(iclnnds) - iac_cln = Util2d.load( - f, model, (nclnnds,), np.int32, "iac_cln", ext_unit_dict - ) - if model.verbose: - print(" iac_cln {}".format(iac_cln)) - - ja_cln = Util2d.load( - f, model, (nja_cln,), np.int32, "ja_cln", ext_unit_dict - ) - if model.verbose: - print(" ja_cln {}".format(ja_cln)) - else: - raise Exception("mfcln: negative number of CLN segments") - - node_prop = read_prop(f, nclnnds) - if model.verbose: - print(" node_prop {}".format(node_prop)) - - cln_gwc = read_prop(f, nclngwc) if model.verbose: - print(" cln_gwc {}".format(cln_gwc)) - cln_circ = read_prop(f, nconduityp) + print(" Reading cln_gwc...") + cln_gwc = cls._read_prop(f, nclngwc) if model.verbose: - print(" cln_circ {}".format(cln_circ)) + print(" Reading cln_circ...") + cln_circ = cls._read_prop(f, nconduityp) + cln_rect = None if nrectyp > 0: - cln_rect = read_prop(f, nrectyp) if model.verbose: - print(" cln_rect {}".format(cln_circ)) - else: - cln_rect = None + print(" Reading cln_rect...") + cln_rect = cls._read_prop(f, nrectyp) + if model.verbose: + print(" Reading ibound...") ibound = Util2d.load( f, model, (nclnnds,), np.int32, "ibound", ext_unit_dict ) - if model.verbose: - print(" ibound {}".format(ibound)) + if model.verbose: + print(" Reading strt...") strt = Util2d.load( f, model, (nclnnds,), np.float32, "strt", ext_unit_dict ) - if model.verbose: - print(" strt {}".format(strt)) - if openfile: + if hasattr(f, "read"): f.close() # set package unit number # reset unit numbers unitnumber = ModflowUsgCln._defaultunit() - filenames = [None, None, None, None, None, None, None] - + filenames = [None] * 7 if ext_unit_dict is not None: unitnumber[0], filenames[0] = model.get_ext_dict_attr( ext_unit_dict, filetype=ModflowUsgCln._ftype() ) - if iclncb > 0: - unitnumber[1], filenames[1] = model.get_ext_dict_attr( - ext_unit_dict, unit=iclncb - ) - model.add_pop_key_list(iclncb) - if iclnhd != 0: - unitnumber[2], filenames[2] = model.get_ext_dict_attr( - ext_unit_dict, unit=abs(iclnhd) - ) - model.add_pop_key_list(abs(iclnhd)) - if iclndd != 0: - unitnumber[3], filenames[3] = model.get_ext_dict_attr( - ext_unit_dict, unit=abs(iclndd) - ) - model.add_pop_key_list(abs(iclndd)) - if iclnib != 0: - unitnumber[4], filenames[4] = model.get_ext_dict_attr( - ext_unit_dict, unit=abs(iclnib) - ) - model.add_pop_key_list(abs(iclnib)) - if iclncn > 0: - unitnumber[5], filenames[5] = model.get_ext_dict_attr( - ext_unit_dict, unit=iclncn - ) - model.add_pop_key_list(iclncn) - if iclnmb > 0: - unitnumber[6], filenames[6] = model.get_ext_dict_attr( - ext_unit_dict, unit=iclnmb - ) - model.add_pop_key_list(iclnmb) + file_unit_items = [iclncb, iclnhd, iclndd, iclnib, iclncn, iclnmb] + funcs = ( + [lambda clni: abs(clni)] + + [lambda clni: clni] * 3 + + [lambda clni: abs(clni)] * 2 + ) + for idx, (item, func) in enumerate(zip(file_unit_items, funcs)): + if item > 0: + ( + unitnumber[idx + 1], + filenames[idx + 1], + ) = model.get_ext_dict_attr(ext_unit_dict, unit=func(item)) + model.add_pop_key_list(func(iclncb)) # create dis object instance cln = cls( @@ -1003,7 +875,7 @@ def load(cls, f, model, ext_unit_dict=None): cln_rect=cln_rect, grav=grav, visk=visk, - BHE=BHE, + bhe=bhe, unitnumber=unitnumber, filenames=filenames, ) @@ -1012,66 +884,223 @@ def load(cls, f, model, ext_unit_dict=None): return cln @staticmethod - def _ftype(): - return "CLN" - - @staticmethod - def _defaultunit(): - return [71, 0, 0, 0, 0, 0, 0] + def _load_items_0_1(f, model): + """Loads items 0 and 1 from filehandle f""" + # Options + transient = False + printiaja = False + line = f.readline().upper() + if line.startswith("OPTIONS"): + line_text = line.strip().split() + transient = bool("TRANSIENT" in line_text) + printiaja = bool("PRINTIAJA" in line_text) + line = f.readline().upper() + + line_text = line.strip().split() + + line_text[:8] = [int(item) for item in line_text[:8]] + ( + ncln, + iclnnds, + iclncb, + iclnhd, + iclndd, + iclnib, + nclngwc, + nconduityp, + ) = line_text[:8] + + # Options keywords + nrectyp = 0 + cln_rect = None + if "RECTANGULAR" in line_text: + idx = line_text.index("RECTANGULAR") + nrectyp = int(line_text[idx + 1]) + + bhe = bool("BHEDETAIL" in line_text) + + iclncn = 0 + if "SAVECLNCON" in line_text: + idx = line_text.index("SAVECLNCON") + iclncn = int(line_text[idx + 1]) + + iclnmb = 0 + if "SAVECLNMAS" in line_text: + idx = line_text.index("SAVECLNMAS") + iclnmb = int(line_text[idx + 1]) + + grav = None + if "GRAVITY" in line_text: + idx = line_text.index("GRAVITY") + grav = float(line_text[idx + 1]) + + visk = None + if "VISCOSITY" in line_text: + idx = line_text.index("VISCOSITY") + visk = float(line_text[idx + 1]) + if model.verbose: + print( + f" ncln {ncln}\n", + f" iclnnds {iclnnds}\n", + f" iclncb {iclncb}\n", + f" iclnhd {iclnhd}\n", + f" iclndd {iclndd}\n", + f" iclnib {iclnib}\n", + f" nclngwc {nclngwc}\n", + f" TRANSIENT {transient}\n", + f" PRINTIAJA {printiaja}\n", + f" RECTANGULAR {nrectyp}\n", + f" BHEDETAIL {bhe}\n", + f" SAVECLNCON {iclncn}\n", + f" SAVECLNMAS {iclnmb}\n", + f" GRAVITY {grav}\n", + f" VISCOSITY {visk}", + ) -def is_float(s): - """ - Test whether the string is a float number. + return ( + transient, + printiaja, + ncln, + iclnnds, + iclncb, + iclnhd, + iclndd, + iclnib, + nclngwc, + nconduityp, + nrectyp, + cln_rect, + bhe, + iclncn, + iclnmb, + grav, + visk, + ) - """ - try: - float(s) - except ValueError: - return False - else: - return True + @staticmethod + def _load_items_3to6(f, model, ncln, iclnnds, ext_unit_dict): + """ + Loads cln items 3, or 4,5,6 from filehandle f + Parameters + ---------- + f : file handle + File to read from. + model : model object + ncln : int, number of cln segments + iclnnds : int, number of cln nodes in model + ext_unit_dict : dictionary + External unit dictionary. -def make_recarray(array, dtype): - """ + Returns + ------- + nndcln, clncon, nja_cln, iac_cln, ja_cln + """ + nndcln = None + clncon = None + nja_cln = None + iac_cln = None + ja_cln = None + if ncln > 0: + if model.verbose: + print(" Reading nndcln...") + nndcln = Util2d.load( + f, model, (ncln,), np.int32, "nndcln", ext_unit_dict + ) + nclnnds = nndcln.array.sum() + if iclnnds > 0: + if model.verbose: + print(" Reading clncon...") + nclnnds = iclnnds + clncon = [] + for icln in range(ncln): + line = f.readline() + line_text = line.strip().split() + iclncon = [] + for i in range(nndcln[icln]): + iclncon.append(line_text[i]) + clncon.append(iclncon) + elif ncln == 0: + if model.verbose: + print(" Reading nja_cln...") + line = f.readline() + line_text = line.strip().split() + nja_cln = int(line_text[0]) - Returns a empty recarray based on dtype. + if model.verbose: + print(" Reading iac_cln...") + nclnnds = abs(iclnnds) + iac_cln = Util2d.load( + f, model, (nclnnds,), np.int32, "iac_cln", ext_unit_dict + ) - """ - nprop = len(dtype.names) - ptemp = [] - for t in array: - if len(t) < nprop: - t = t + (nprop - len(t)) * [0.0] + if model.verbose: + print(" Reading ja_cln...") + ja_cln = Util2d.load( + f, model, (nja_cln,), np.int32, "ja_cln", ext_unit_dict + ) else: - t = t[:nprop] - ptemp.append(tuple(t)) + raise Exception("mfcln: negative number of CLN segments") - return np.array(ptemp, dtype) + return nndcln, clncon, nja_cln, iac_cln, ja_cln, nclnnds + @staticmethod + def _ftype(): + return "CLN" -def read_prop(f, nrec): - """ + @staticmethod + def _defaultunit(): + return [71, 0, 0, 0, 0, 0, 0] + + @staticmethod + def _is_float(s): + """ + Test whether the string is a float number. + """ + try: + float(s) + except ValueError: + return False + else: + return True - Read the property tables (node_prop, cln_gwc, cln_circ, cln_rect). + @staticmethod + def _make_recarray(array, dtype): + """ + Returns a empty recarray based on dtype. + """ + nprop = len(dtype.names) + ptemp = [] + for t in array: + if len(t) < nprop: + t = t + (nprop - len(t)) * [0.0] + else: + t = t[:nprop] + ptemp.append(tuple(t)) - Parameters - ---------- - f : package file handle - nrec : number of rows in the table + return np.array(ptemp, dtype) - Returns - ------- - A list of lists with length of nrec + @classmethod + def _read_prop(cls, f, nrec): + """ + Read the property tables (node_prop, cln_gwc, cln_circ, cln_rect). - """ - ptemp = [] + Parameters + ---------- + f : package file handle + nrec : number of rows in the table - for _ in range(nrec): - line = f.readline() - t = line.strip().split() - ra = [float(s) for s in t if is_float(s)] - ptemp.append(ra) + Returns + ------- + A list of lists with length of nrec + """ + ptemp = [] + + for _ in range(nrec): + line = f.readline() + line_text = line.strip().split() + prop = [float(item) for item in line_text if cls._is_float(item)] + ptemp.append(prop) - return ptemp + return ptemp diff --git a/flopy/modflowusg/mfusgdisu.py b/flopy/modflowusg/mfusgdisu.py index 079c0a10d4..cf8a1f0873 100644 --- a/flopy/modflowusg/mfusgdisu.py +++ b/flopy/modflowusg/mfusgdisu.py @@ -1,9 +1,10 @@ """ mfdisu module. Contains the ModflowUsgDisU class. Note that the user can access the ModflowUsgDisU class as `flopy.modflowusg.ModflowUsgDisU`. - """ import numpy as np + +from .mfusg import ModflowUsg from ..pakbase import Package from ..utils import Util2d, Util3d, read1d from ..utils.reference import TemporalReference @@ -193,7 +194,6 @@ class ModflowUsgDisU(Package): >>> import flopy >>> m = flopy.modflowusg.ModflowUsg() >>> disu = flopy.modflowusg.ModflowUsgDisU(m) - """ def __init__( @@ -228,6 +228,12 @@ def __init__( filenames=None, start_datetime=None, ): + """disu constructor""" + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg # set default unit number of one is not specified if unitnumber is None: @@ -545,8 +551,12 @@ def load(cls, f, model, ext_unit_dict=None, check=True): >>> import flopy >>> m = flopy.modflowusg.ModflowUsg() >>> disu = flopy.modflowusg.ModflowUsgDisU.load('test.disu', m) - """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg if model.verbose: print("loading disu package file...") diff --git a/flopy/modflowusg/mfusggnc.py b/flopy/modflowusg/mfusggnc.py index d2a2dcfcdf..4416c1e670 100644 --- a/flopy/modflowusg/mfusggnc.py +++ b/flopy/modflowusg/mfusggnc.py @@ -10,7 +10,7 @@ from ..utils.recarray_utils import create_empty_recarray from ..utils.flopy_io import ulstrd from ..modflow.mfparbc import ModflowParBc as mfparbc - +from .mfusg import ModflowUsg from .mfusg import fmt_string @@ -93,6 +93,12 @@ def __init__( filenames=None, ): """Package constructor""" + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg + # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowUsgGnc._defaultunit() @@ -258,8 +264,12 @@ def load(cls, f, model, ext_unit_dict=None): >>> import flopy >>> m = flopy.modflow.Modflow() >>> gnc = flopy.modflow.ModflowGnc.load('test.gnc', m) - """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg if model.verbose: print("loading gnc package file...") diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index 21e844a946..549d558a36 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -8,9 +8,10 @@ `_. """ import numpy as np + from ..modflow.mfpar import ModflowPar as mfpar from ..modflow.mflpf import ModflowLpf - +from .mfusg import ModflowUsg from ..utils import Util2d, read1d from ..utils.flopy_io import line_parse from ..utils.utils_def import ( @@ -233,6 +234,11 @@ def __init__( add_package=True, ): """mfusglpf object constructor""" + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg super().__init__( model, @@ -584,6 +590,12 @@ def load(cls, f, model, ext_unit_dict=None, check=True): >>> disu = flopy.modflowusg.ModflowUsgDisU(model=m, nlay=1, nodes=1, iac=[1], njag=1,ja=np.array([0]), fahl=[1.0], cl12=[1.0]) >>> lpf = flopy.modflowusg.ModflowUsgLpf.load('test.lpf', m) """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg + if model.verbose: print("loading lpf package file...") diff --git a/flopy/modflowusg/mfusgsms.py b/flopy/modflowusg/mfusgsms.py index b40e68bfd4..2b057736d2 100644 --- a/flopy/modflowusg/mfusgsms.py +++ b/flopy/modflowusg/mfusgsms.py @@ -7,6 +7,7 @@ """ from ..pakbase import Package from ..utils.flopy_io import line_parse +from .mfusg import ModflowUsg class ModflowUsgSms(Package): @@ -235,65 +236,78 @@ class ModflowUsgSms(Package): def __init__( self, model, - hclose=1e-4, - hiclose=1e-4, - mxiter=100, - iter1=20, - iprsms=2, - nonlinmeth=0, - linmeth=2, - theta=0.7, - akappa=0.1, - gamma=0.2, - amomentum=0.001, - numtrack=20, - btol=1e4, - breduc=0.2, - reslim=100.0, - iacl=2, - norder=0, - level=7, - north=2, - iredsys=0, - rrctol=0.0, - idroptol=0, - epsrn=1.0e-3, - clin="bcgs", - ipc=3, - iscl=0, - iord=0, - rclosepcgu=0.1, - relaxpcgu=1.0, - extension="sms", - options=None, - unitnumber=None, - filenames=None, + **kwargs, ): """Package constructor""" + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg + + valid_args_defaults = { + "hclose": 1e-4, + "hiclose": 1e-4, + "mxiter": 100, + "iter1": 20, + "iprsms": 2, + "nonlinmeth": 0, + "linmeth": 2, + "theta": 0.7, + "akappa": 0.1, + "gamma": 0.2, + "amomentum": 0.001, + "numtrack": 20, + "btol": 1e4, + "breduc": 0.2, + "reslim": 100.0, + "iacl": 2, + "norder": 0, + "level": 7, + "north": 2, + "iredsys": 0, + "rrctol": 0.0, + "idroptol": 0, + "epsrn": 1.0e-3, + "clin": "bcgs", + "ipc": 3, + "iscl": 0, + "iord": 0, + "rclosepcgu": 0.1, + "relaxpcgu": 1.0, + "extension": "sms", + "options": None, + "unitnumber": None, + "filenames": None, + } + + for arg, default_value in valid_args_defaults.items(): + setattr(self, arg, kwargs.pop(arg, default_value)) + # set default unit number of one is not specified - if unitnumber is None: - unitnumber = ModflowUsgSms._defaultunit() + if self.unitnumber is None: + self.unitnumber = ModflowUsgSms._defaultunit() # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] + if self.filenames is None: + self.filenames = [None] + elif isinstance(self.filenames, str): + self.filenames = [self.filenames] # Fill namefile items name = [ModflowUsgSms._ftype()] - units = [unitnumber] + units = [self.unitnumber] extra = [""] # set package name - fname = [filenames[0]] + fname = [self.filenames[0]] # Call ancestor's init to set self.parent, extension, name and # unit number Package.__init__( self, model, - extension=extension, + extension=self.extension, name=name, unit_number=units, extra=extra, @@ -302,41 +316,11 @@ def __init__( self._generate_heading() self.url = " " - self.hclose = hclose - self.hiclose = hiclose - self.mxiter = mxiter - self.iter1 = iter1 - self.iprsms = iprsms - self.nonlinmeth = nonlinmeth - self.linmeth = linmeth - self.theta = theta - self.akappa = akappa - self.gamma = gamma - self.amomentum = amomentum - self.numtrack = numtrack - self.btol = btol - self.breduc = breduc - self.reslim = reslim - self.iacl = iacl - self.norder = norder - self.level = level - self.north = north - self.iredsys = iredsys - self.rrctol = rrctol - self.idroptol = idroptol - self.epsrn = epsrn - self.clin = clin - self.ipc = ipc - self.iscl = iscl - self.iord = iord - self.rclosepcgu = rclosepcgu - self.relaxpcgu = relaxpcgu - if options is None: + if self.options is None: self.options = [] else: - if not isinstance(options, list): - options = [options] - self.options = options + if not isinstance(self.options, list): + self.options = [self.options] self.parent.add_package(self) return @@ -435,6 +419,12 @@ def load(cls, f, model, ext_unit_dict=None): >>> m = flopy.modflow.Modflow() >>> sms = flopy.modflow.ModflowPcg.load('test.sms', m) """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg + if model.verbose: print("loading sms package file...") diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py index 859d09df77..f054a5e82c 100644 --- a/flopy/modflowusg/mfusgwel.py +++ b/flopy/modflowusg/mfusgwel.py @@ -12,6 +12,7 @@ import numpy as np from numpy.lib.recfunctions import stack_arrays +from .mfusg import ModflowUsg from ..modflow.mfwel import ModflowWel from ..modflow.mfparbc import ModflowParBc as mfparbc from ..utils.flopy_io import ulstrd @@ -177,6 +178,11 @@ def __init__( """ Package constructor. """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg super().__init__( model, @@ -588,8 +594,12 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): >>> import flopy >>> m = flopy.modflow.Modflow() >>> wel = flopy.modflowusg.ModflowUsgWel.load('test.wel', m) - """ + msg = ( + "Model object must be of type flopy.modflowusg.ModflowUsg\n" + + "but received type: {type(model)}." + ) + assert isinstance(model, ModflowUsg), msg if model.verbose: print("loading wel package file...") From ef9eff709c97752d55df42a5d9538116fdf0647e Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Mon, 4 Oct 2021 16:56:35 +1100 Subject: [PATCH 12/14] refactor(mfusgbct) remove bct package for now --- flopy/modflowusg/__init__.py | 2 - flopy/modflowusg/mfusg.py | 1 - flopy/modflowusg/mfusgbct.py | 176 ----------------------------------- 3 files changed, 179 deletions(-) delete mode 100644 flopy/modflowusg/mfusgbct.py diff --git a/flopy/modflowusg/__init__.py b/flopy/modflowusg/__init__.py index eb7174d6d6..afc81fa56a 100644 --- a/flopy/modflowusg/__init__.py +++ b/flopy/modflowusg/__init__.py @@ -5,7 +5,6 @@ from .mfusglpf import ModflowUsgLpf from .mfusgwel import ModflowUsgWel from .mfusgcln import ModflowUsgCln -from .mfusgbct import ModflowUsgBct from .mfusgsms import ModflowUsgSms from .mfusggnc import ModflowUsgGnc @@ -16,7 +15,6 @@ "ModflowUsgLpf", "ModflowUsgWel", "ModflowUsgCln", - "ModflowUsgBct", "ModflowUsgSms", "ModflowUsgGnc", ] diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py index 4fd0e7ee0e..1697e86a55 100644 --- a/flopy/modflowusg/mfusg.py +++ b/flopy/modflowusg/mfusg.py @@ -125,7 +125,6 @@ def __init__( "lpf": flopy.modflowusg.ModflowUsgLpf, "cln": flopy.modflowusg.ModflowUsgCln, "gnc": flopy.modflowusg.ModflowUsgGnc, - "bct": flopy.modflowusg.ModflowUsgBct, } return diff --git a/flopy/modflowusg/mfusgbct.py b/flopy/modflowusg/mfusgbct.py deleted file mode 100644 index 491a8b3878..0000000000 --- a/flopy/modflowusg/mfusgbct.py +++ /dev/null @@ -1,176 +0,0 @@ -import numpy as np -from ..pakbase import Package -from ..utils import Util2d, Util3d - - -class ModflowUsgBct(Package): - """ - Block centered transport package class for MODFLOW-USG - """ - - def __init__( - self, - model, - itrnsp=1, - ibctcb=0, - mcomp=1, - ic_ibound_flg=1, - itvd=1, - iadsorb=0, - ict=0, - cinact=-999.0, - ciclose=1.0e-6, - idisp=1, - ixdisp=0, - diffnc=0.0, - izod=0, - ifod=0, - icbund=1, - porosity=0.1, - bulkd=1.0, - arad=0.0, - dlh=0.0, - dlv=0.0, - dth=0.0, - dtv=0.0, - sconc=0.0, - extension="bct", - unitnumber=None, - ): - - # set default unit number of one is not specified - if unitnumber is None: - unitnumber = ModflowUsgBct._defaultunit() - - # Call ancestor's init to set self.parent, extension, name and unit - # number - Package.__init__( - self, model, extension, ModflowUsgBct._ftype(), unitnumber - ) - - self.url = "bct.htm" - nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper - self.itrnsp = itrnsp - self.ibctcb = ibctcb - self.mcomp = mcomp - self.ic_ibound_flg = ic_ibound_flg - self.itvd = itvd - self.iadsorb = iadsorb - self.ict = ict - self.cinact = cinact - self.ciclose = ciclose - self.idisp = idisp - self.ixdisp = ixdisp - self.diffnc = diffnc - self.izod = izod - self.ifod = ifod - self.icbund = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - icbund, - "icbund", - ) - self.porosity = Util3d( - model, (nlay, nrow, ncol), np.float32, porosity, "porosity" - ) - # self.arad = Util2d(model, (1, nja), np.float32, - # arad, 'arad') - self.dlh = Util3d(model, (nlay, nrow, ncol), np.float32, dlh, "dlh") - self.dlv = Util3d(model, (nlay, nrow, ncol), np.float32, dlv, "dlv") - self.dth = Util3d(model, (nlay, nrow, ncol), np.float32, dth, "dth") - self.dtv = Util3d(model, (nlay, nrow, ncol), np.float32, dth, "dtv") - self.sconc = Util3d( - model, - (nlay, nrow, ncol), - np.float32, - sconc, - "sconc", - ) - self.parent.add_package(self) - return - - def write_file(self): - """ - Write the package file. - - Returns - ------- - None - - """ - nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper - # Open file for writing - f_bct = open(self.fn_path, "w") - # Item 1: ITRNSP, IBCTCB, MCOMP, IC_IBOUND_FLG, ITVD, IADSORB, - # ICT, CINACT, CICLOSE, IDISP, IXDISP, DIFFNC, IZOD, IFOD - s = "{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13}" - s = s.format( - self.itrnsp, - self.ibctcb, - self.mcomp, - self.ic_ibound_flg, - self.itvd, - self.iadsorb, - self.ict, - self.cinact, - self.ciclose, - self.idisp, - self.ixdisp, - self.diffnc, - self.izod, - self.ifod, - ) - f_bct.write(s + "\n") - # - # ibound - if self.ic_ibound_flg == 0: - for k in range(nlay): - f_bct.write(self.icbund[k].get_file_entry()) - # - # porosity - for k in range(nlay): - f_bct.write(self.porosity[k].get_file_entry()) - # - # bulkd - if self.iadsorb != 0: - for k in range(nlay): - f_bct.write(self.bulkd[k].get_file_entry()) - # - # arad - if self.idisp != 0: - f_bct.write("open/close arad.dat 1.0 (free) -1\n") - # - # dlh - if self.idisp == 1: - for k in range(nlay): - f_bct.write(self.dlh[k].get_file_entry()) - # - # dlv - if self.idisp == 2: - for k in range(nlay): - f_bct.write(self.dlv[k].get_file_entry()) - # - # dth - if self.idisp == 1: - for k in range(nlay): - f_bct.write(self.dth[k].get_file_entry()) - # - # dtv - if self.idisp == 2: - for k in range(nlay): - f_bct.write(self.dtv[k].get_file_entry()) - # - # sconc - for k in range(nlay): - f_bct.write(self.sconc[k].get_file_entry()) - - return - - @staticmethod - def _ftype(): - return "BCT" - - @staticmethod - def _defaultunit(): - return 35 From 8dd920af2dd81d326cd1e1dc6bf69e4fd7dc1d52 Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Tue, 5 Oct 2021 17:59:33 +1100 Subject: [PATCH 13/14] refactor(mfusg) undo some refactoring --- .../Notebooks/flopy3_Zaidel_example.ipynb | 29 +- examples/Notebooks/flopy3_gridgen.ipynb | 73 ++- .../flopy3_mfusg_conduit_examples.ipynb | 138 ++---- .../mfusg_test/03_conduit_confined/ex3.cln | 2 +- flopy/__init__.py | 8 +- flopy/mbase.py | 5 +- flopy/modflowusg/__init__.py | 2 +- flopy/modflowusg/mfusg.py | 157 +++--- flopy/modflowusg/mfusgbcf.py | 445 ++++++++++-------- flopy/modflowusg/mfusgcln.py | 220 +++++---- flopy/modflowusg/mfusgdisu.py | 2 +- flopy/modflowusg/mfusggnc.py | 7 +- flopy/modflowusg/mfusglpf.py | 10 +- flopy/modflowusg/mfusgsms.py | 129 ++--- flopy/modflowusg/mfusgwel.py | 10 +- flopy/pakbase.py | 4 +- flopy/utils/utils_def.py | 4 +- 17 files changed, 655 insertions(+), 590 deletions(-) diff --git a/examples/Notebooks/flopy3_Zaidel_example.ipynb b/examples/Notebooks/flopy3_Zaidel_example.ipynb index 783d2ab5d4..0da7185938 100644 --- a/examples/Notebooks/flopy3_Zaidel_example.ipynb +++ b/examples/Notebooks/flopy3_Zaidel_example.ipynb @@ -26,11 +26,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.8.10 (default, May 19 2021, 11:01:55) \n", - "[Clang 10.0.0 ]\n", - "numpy version: 1.19.2\n", - "matplotlib version: 3.4.2\n", - "flopy version: 3.3.4\n" + "3.7.9 (tags/v3.7.9:13c94747c7, Aug 17 2020, 18:58:18) [MSC v.1900 64 bit (AMD64)]\n", + "numpy version: 1.21.0\n", + "matplotlib version: 3.4.3\n", + "flopy version: 3.3.5\n" ] } ], @@ -137,18 +136,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "FloPy is using the following executable to run the model: /Users/jdhughes/.local/bin/mfusg\n", + "FloPy is using the following executable to run the model: C:\\Users\\chris\\.local\\bin\\mfusg.exe\n", "\n", " MODFLOW-USG \n", " U.S. GEOLOGICAL SURVEY MODULAR FINITE-DIFFERENCE GROUNDWATER FLOW MODEL\n", " Version 1.5.00 02/27/2019 \n", "\n", " Using NAME file: zaidel.nam \n", - " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/08/06 16:18:11\n", + " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:50:31\n", "\n", " Solving: Stress period: 1 Time step: 1 Groundwater Flow Eqn.\n", - " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/08/06 16:18:11\n", - " Elapsed run time: 0.018 Seconds\n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:50:31\n", + " Elapsed run time: 0.006 Seconds\n", "\n", " Normal termination of simulation\n" ] @@ -166,17 +165,17 @@ ], "source": [ "#make the flopy model\n", - "mf = flopy.modflow.Modflow(modelname=modelname, exe_name=mfexe, model_ws=modelpth)\n", + "mf = flopy.modflowusg.ModflowUsg(modelname=modelname, exe_name=mfexe, model_ws=modelpth)\n", "dis = flopy.modflow.ModflowDis(mf, nlay, nrow, ncol,\n", " delr=delr, delc=delc, \n", " top=botm[0, :, :], botm=botm[1:, :, :], \n", " perlen=1, nstp=1, steady=True)\n", "bas = flopy.modflow.ModflowBas(mf, ibound=ibound, strt=strt)\n", - "lpf = flopy.modflow.ModflowLpf(mf, hk=0.0001, laytyp=4)\n", + "lpf = flopy.modflowusg.ModflowUsgLpf(mf, hk=0.0001, laytyp=4)\n", "oc = flopy.modflow.ModflowOc(mf, \n", " stress_period_data={(0,0): ['print budget', 'print head', \n", " 'save head', 'save budget']})\n", - "sms = flopy.modflow.ModflowSms(mf, nonlinmeth=1, linmeth=1,\n", + "sms = flopy.modflowusg.ModflowUsgSms(mf, nonlinmeth=1, linmeth=1,\n", " numtrack=50, btol=1.1, breduc=0.70, reslim = 0.0,\n", " theta=0.85, akappa=0.0001, gamma=0., amomentum=0.1,\n", " iacl=2, norder=0, level=5, north=7, iredsys=0, rrctol=0.,\n", @@ -228,7 +227,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -277,9 +276,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.7.9" } }, "nbformat": 4, - "nbformat_minor": 1 + "nbformat_minor": 4 } diff --git a/examples/Notebooks/flopy3_gridgen.ipynb b/examples/Notebooks/flopy3_gridgen.ipynb index fc423c64f1..7df9348bd4 100644 --- a/examples/Notebooks/flopy3_gridgen.ipynb +++ b/examples/Notebooks/flopy3_gridgen.ipynb @@ -20,10 +20,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.8.11 (default, Aug 6 2021, 08:56:27) \n", - "[Clang 10.0.0 ]\n", - "numpy version: 1.19.2\n", - "matplotlib version: 3.4.2\n", + "3.7.9 (tags/v3.7.9:13c94747c7, Aug 17 2020, 18:58:18) [MSC v.1900 64 bit (AMD64)]\n", + "numpy version: 1.21.0\n", + "matplotlib version: 3.4.3\n", "flopy version: 3.3.5\n" ] } @@ -69,7 +68,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "gridgen executable was found at: /Users/jdhughes/.local/bin/gridgen\n" + "gridgen executable was found at: D:\\Software\\GRIDGEN\\gridgen.1.0.02\\bin\\gridgen.EXE\n" ] } ], @@ -97,8 +96,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Model workspace is : ./data\n", - "Gridgen workspace is : ./data/gridgen\n" + "Model workspace is : .\\data\n", + "Gridgen workspace is : .\\data\\gridgen\n" ] } ], @@ -253,7 +252,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -262,7 +261,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAANOCAYAAADj0sYQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9aXBb6X3uiz4LIAiAE8B5nmeCWIui5nkiJbU6bre74zh2nHgnzo6TnZzsnXtP7aqTW3XPrdqn7q6z07bbseMpdmy3fd0eulvdLYkaWgM1T5zWAghOIkVxFsV5HoH7gXpfLYALwFoQ5W51v7+qfIhECAtoSF5/PO/v+XMejwcMBoPBYDAYDAaDwdgYdB/3BTAYDAaDwWAwGAzGpwk2ZDEYDAaDwWAwGAzGBsKGLAaDwWAwGAwGg8HYQNiQxWAwGAwGg8FgMBgbCBuyGAwGg8FgMBgMBmMDCfu4L0BOQkKCJycn5+O+DAbjU4nb7cbY2BiWlpYQHh4Os9kMs9kMnY5918JgMBgMBoMRCvX19SMejyfR99c/UUNWTk4O6urqPu7LYDA+ldy7dw81NTXYvn07Hjx4gOHhYeh0OhQVFYHneRQWFiIs7BP1TwKDwWAwGAzGJxqO4x4q/Tq7o2IwPiNIkoSkpCQcO3YMHo8Hjx49giiKcDqdaG1thclkgs1mA8/zyMzMBMdxH/clMxgMBoPBYLyQsCGLwfgMMDo6ir6+PlRVVQEAOI5DSkoKUlJSUF1dja6uLkiSBFEUUV9fj9jYWPA8D57nERcX9zFfPYPBYDAYDMaLBRuyGIzPAJIkAQDsdvu639PpdCgoKEBBQQEWFxfR0tICSZJw5coVXLlyBenp6RAEAeXl5TCbzX/oS2cwGAwGg8F44WBDFoPxKcfj8UCSJOTl5SEmJibgzxqNRlRUVKCiogLvvfcempubsbi4iJqaGpw9e5b5WwwGg8FgMBgqYHdJDMannN7eXkxMTODAgQOqH7OysoKOjg7YbDZ84QtfwNDQECRJgsPh8PK3BEFARkYG87cYDAaDwWAwZLAhi8H4lCOKIgwGA0pLS1U/pr29HQsLC+B5HhzHITU1FampqczfYjAYDAaDwVABG7IYjE8xKysrcLlcKC0tRXh4uOrHSZKEqKgo5OXlef16MH8rIyMDgiDAZrMxf4vBYDAYDMZnFjZkMRifYuSJlFrm5ubQ0dGB7du3B1xULPe3Jicn8R//8R8YGhpCX1/fOn9Lr9dvxMthMBgMBoPBeCFgQxaD8SmGJFK5ubmqH9Pc3Ay3261pMFtZWcHU1BQOHz6M/Px8un+rpaUFZrOZ7t9i/haDwWAwGIzPAmzIYjA+pczNzaG9vR2FhYVwu90BUyk5oigiKSkJKSkpqp9LkiRwHAdBEBAdHY3U1FQcOXIEnZ2dkCQJTU1NqKurQ1xcHPW3YmNjQ31pDAaDwWAwGJ9o2JDFYHxKcTqd8Hg8aG9vxze/+U2aJmVmZvpNk0ZHR9Hf30+XFquBVMTn5uYiOjqa/rpOp0NhYSEKCwuxuLgIl8sFSZJQW1uL2tpaZGZmgud55m8xGAwGg8H41MGGLAbjU4okSUhKSkJ1dfW6NkC73Q5BENa1AQZaWuwPNRXxRqMRmzZtwqZNmzA5OQlRFHHlyhX09vYyf4vBYDAYDManDjZkMRifQkZGRtDf34/q6mrFNsCrV6/i6tWryMjIAM/zKC8vh8lkUr20WI7WiniLxYKEhAS43W4cO3YM4+Pj6/wtQRCQnp7O/C0Gg8FgMBgvJGzIYjA+hRBHSp5IydsAp6amIEkSJElCTU0Nzp49i4yMDExMTGDv3r2qn2dlZQXNzc0hV8Rv3boVOp3Oa/8W87cYDAaDwWC86LAhi8H4lOHxeOBwONY5UnJiYmKwZ88e7N69G0NDQ5AkCXV1dQCAjz76CAMDAxAEIWgbYHt7OxYXF5+5Il6v1wf0t7KyssDzPMrKypi/xWAwGAwG4xMPG7IYjE8ZPT09mJiYwMGDB4P+LMdxSE1NRWJiIhoaGpCbm4vIyEgvf4ukSb7+FhBaRbzT6QxYEe/rb0mShMbGRpw6dQpnzpxBUVERBEFAQUEB87cYDAaDwWB8ImFDFoPxKUOSJBgMBpSUlKh+THt7O5aWlrB7927k5+d7+VtXrlzBlStX1rUBql1arHR9aiviLRYL9u7di+XlZVy7dg12ux3t7e3U3yovLwfP88zfYjAYDAaD8YmCDVkMxqeIZ3WkSCIl97cmJyfhcDggSRJOnz6Ns2fPorCwEGazGW63G4IgqH6eUCvinU4n8vLy8PnPfx6rq6t0/1ZjYyPu3buH+Ph42O125m8xGAwGg8H4RMCGLAbjU0RbW9uGOFJyLBaLl78liiKcTidmZ2fBcRzq6urA83xQfwsIvSJ+fHwc+/fvB7DmbxUVFaGoqAgLCwt+/S2bzQaTyaT6eRgMBoPBYDA2CjZkMRifIiRJQnR0dEiOVLBEivhbqampqKysxA9+8AMkJSV5tQGS/VtKaRJZWryRFfEmkwmVlZWorKzExMQETdyYv8VgMBgMBuPjhA1ZDManhNnZWdy/fz8kRyo5ORnJycmqH+N0OsFxHP7sz/4M4eHhNE3y528BTws5Ai0t9mVlZQUulwslJSVBjz9arVbs3bsXe/bswS9+8QsMDAzg4cOHaGlpQUREBN2/lZaWxvwtBoPBYDAYzxU2ZDEYnxKam5vhdruxtLSEsbExxTZAX+RLi9VCKuLz8vJoRby8DdDhcEAURepvFRUVged5tLW1aVpaDKwVciwsLGg6/jg/P4/e3l5s27YNVVVV1N9qaGig/hZpTLRarar/XAaDwWAwGAy1sCGLwfiUIIoijEYj6uvrUV9fj4yMDPA8j/Lycr+7pZSWFgcjUEW83N8aHByEJElwOp1oaWkBAMTHx2N4eFh1GyAp5MjLy1N9fWTYFATBr791+fJlXL58GdnZ2XT/FvO3GAwGg8FgbBRsyGIwPgWMjIxgYGAA1dXVKC8vp25STU2NV5pUWFiIsLC1v/ZKiZQaiCMVqCKe4zikpaUhLS0N1dXVqK2txfXr1zExMYGf/vSniIuLo2mSvzbAZ62I9z3+6OtvSZIESZJw8uRJ1NTUoLi4GDzPM3+LwWAwGAzGM8OGLAbjU4A8kYqOjsbu3buxa9cuPHr0iLYBtra2wmQyUTdpdXVV9dJiAnGktFTE6/V6PH78GFFRUfi7v/s7tLW1KbYBlpWVeSVuJJHSclRwdHQUfX19qKqqCpiUWa1W7Nu3D3v37kV/fz9+9atfoa2tDS6XCxEREXT/FvO3GAwGg8FghAIbshiMFxx5a588keI4DikpKUhJSUF1dTW6urogSRJEUUR9fT2MRiN0Op2mwotnrYiPiIjw8rdImiRvAySJmyiKqpcWE7RWxHMcB7fbjcXFRbzyyiuIiIiAJEmor6/H3bt3mb/FYDAYDAYjJNiQxWC84PT09GBychKHDh3y+zM6nQ4FBQUoKCjA4uIimpubcerUKXg8Hvzwhz9UbANUYiMr4i0WC20DHBwcpIlbS0sLTCYTFhYWsHXrVng8HlVpUqgV8ZIkwWAwwGazITw8HMXFxdTfEkWR+VsMBoPBYDA0w4YsBuMFR40jJcdoNMJoNMLj8eALX/gCpqenvdoACwsL1/lbwNOK+B07dmxoRbzc3zpy5Ag6Oztx4cIFLCws4N69e+jq6oLdbg/obwFrS4tDqYhvbm5ed/xR7m+Nj49Tx+3kyZM4c+YM9bfy8/OZv8VgMBgMBmMdbMhiMF5glpeX4XK5UFZWptqRAp4mUuXl5dDpdNi1axeGhoYgSRIcDgdaW1thNpths9nA8zwyMjJCcqS0VsTr9XoUFhbizJkzyMnJgd1uV/S3bDbbujQp0NJif3R0dAStiI+NjaX+1sDAAOrr69HU1ITm5mbqbwmCgNTUVOZvMRgMBoPBAMCGLAbjhaa9vV2zI6WUSHEch9TUVKSmpnr5W01NTairq0NcXByWl5cRHx+vyeEKpSJenkgJgkDbAEmaRPwteRugx+NRvbTY9/qioqJUHX/kOA7p6ekYGBhAY2Mjjh49it7eXupvJSQkUH/LYrGovgYGg8FgMBifPtiQxWC8wJBEKicnR/VjgiVSvv5WS0sL6urqMDY2BgD4j//4D1X+FqmIz83NDakiXp5IWa1W6m8NDAzQ/Vsulwtmsxnp6emalxbPzc2hvb095Ir47du3Y8eOHVhYWEBzczMkScKlS5dw6dIl5OTkUH/LaDSq/rMZDAaDwWB8OmBDFoPxgvK8HCk5RqMRFRUVGBsbQ39/P/bs2YO2tjbqb8nbAH3dpEBLi/3hz5EikDQpPT2d+luSJMHlcgEAzpw5A0EQVLUBblRFvMlkwubNm7F582aMj4/TxsQPP/zQa/8W87cYDAaDwfjswIYsBuMFxV9rXyC0OlLA09a+/Px8HD58GIcOHcLQ0JBXGyDxtwRBQHp6OjiO01zIAWg7/qjX61FUVISMjAy4XC7k5eVhdXWVtgFmZWVBEAS/bYAkkdrIivjY2Fjs378f+/btQ39/Px24iL9FCjyYv8VgMBgMxqcbNmQxGC8oTU1N4DgOly9fVmwDVCIUR8q3Il7ub8nTJLm/VV5eHjCRCnR9ah0pgtPphMfjQXV1NVJSUjAxMUGHm5MnT3qlSQUFBdDr9TSRCmXYVFMRz3EcMjIykJGRgZWVFYiiiMzMTNTV1eHOnTvM32IwGAwG41MOG7IYjBeQkZERDA0NITs7G319fWhtbYXJZKJtgJmZmeuSEn9Li4MRKJHS6XQoLCxEYWEhFhcX4XK5IEkSrl69CgAYHBxEfX09ysrKAvpbgPfS4lAcKZJIWa1WrzZAURTR3NwMl8tF2wCXl5cBqF9aDIReEd/S0gKbzYbXXnsN8/Pz9D1i/haDwWAwGJ9e2JDFYLyAiKIIjuPw+uuvIzIykrYBSpKE+vp6xMbG0qQkLi4OgLqlxb5oqYg3Go3YtGkTNm3ahLfeegv9/f3weDy0DTCQvwWEdvxxdHQU/f39qKqqWvd7cn/r6NGjuH//Pn1/VldXYTAY0NjYqMrfAkKriG9vb/cq5DCbzQH9rZKSEupvaRk0GQwGg8FgfLJgQxaD8YJBWvvkiZRvG6AkSbhy5QquXLmCjIwM8DyP3t7e5+pIEWZnZ/Hw4UPs2LEDVVVVGBwcpG2AxN8qLy8Hz/PU3wK0FXIQyPHHYNen1+tRXFyM4uJidHR04Ne//jViYmKov5WdnU3TJCV/a2VlBS6XK+Tjj3l5eet+z9ffIomb0+mk/pYgCEhJSWH+FoPBYDAYLxhsyGIwXjAePnzoN5EibYAVFRWYmpqCw+GAKIqoqakBAMTExKCzs1OVvwWEVhFPEime58FxHNLS0pCWlua1f6uxsRH37t1DfHw87HY7MjMzQy7k0FoR39raCoPBgL/5m7/B7Ows3b918uRJr/1b8jZA30RKDeT447Zt2wKmUnJ/69ixY/jBD36AmZkZ6m8lJiaC53nY7XbmbzEYDAaD8YLAhiwG4wVDkiSEh4cHTaRiYmKwe/du7Nq1Czdu3MDFixextLSE3/3ud9TfEgQBGRkZiknJRlfE6/V66m8tLCzQxK22tpb+jMfjwcLCgmKa5EuojpQ8kQoPD6f+FmkDdDqdtA2wvLwcgiBAFEXNhRykIl7L8cfJyUmMjo6iqqoKlZWVdP/WxYsXcfHiReTk5EAQBJSWljJ/i8FgMBiMTzBsyGIwXiCII6Xl2BrHcejt7UV0dDT+8R//Ed3d3ZAkCaIo+vW3gNAr4gcGBoImUiaTifpbExMT+NGPfoTV1VVcuHABly9fXtcGqMRGOFIEeZrk62/dvXsXAJCZmYmpqSlV/hbwtJBD6/FHYK2Qw2w2Y8uWLdiyZQvGxsaov/XBBx/g9OnTzN9iMBgMBuMTDBuyGIwXiFAdKZJIhYWFBfS3MjMzwfM8bDYbJElCSkoKkpKSVD9XKBXxk5OTWFhYwKuvvorExES6f8vlclF/SxAEpKWl0cQt2NLiQNcXHR0dMJGS+1sLCws4ffo0nE4nent78Z3vfAfZ2dl0/5a/NElpaXEw5McffSvi4+LicODAAezfvx99fX00cXM6nYiMjKT7t5i/xWAwGAzGJwM2ZDEYLxCiKIbsSPkmUnJ/a3JykrpJp0+fxpkzZ+hjVlZWVPlboVbES5JEE6nw8HCkpaV57d+S+1skcRsYGNA8bIZSEW8ymTA+Po7k5GR86UtfWtcGqORvkdcEaK+IHx8fx759+/z+DMdxyMzMRGZmJo4ePYrW1lacOHECd+7cwe3bt6m/xfN80F1eDAaDwWAwnh9syGIwXhBIIrVz507NjlSwRMpisWDPnj3YvXs3hoaGcOrUKbpjqr29ne7f8udvAaFVxPtLpPR6PYqKilBUVISFhQW6W4q0AZrNZhiNRqSmpqp+rmepiK+url7XBujP30pJSVG9tFiOJEkICwtTffwxLCwMer0ebrcbf/zHf4z5+Xkvfys3Nxc8zzN/i8FgMBiMjwE2ZDEYLwhOpxMejyckR+rIkSOqfp7jOKSkpGB2dhb5+fnYvn07JElCU1MT6urqEBcXR6vFY2NjvR4baGmxP9ra2oImUiaTCZWVlaisrMTExAQaGhpw7do1AMC3vvUtVf4W8GwV8fJEytff6ujo8PK3LBYLJicnsW3bNtXPIx82tQxEkiQhMjISpaWl0Ol0fv2t0tJS8DyPvLw85m8xGAwGg/EHgA1ZDMYLQlNTE+Li4pCYmKj6MWRpcXl5uerHkIr4w4cP0zbAxcVFmiYp+VthYWGqlxbLUeNIybFarYiKigIAvPbaa+jr66P+VkREBG1MlPtbgHcipRY1FfF6vR4lJSUoKSnB/Pw8mpubaVvi+fPn0d7eTvdvBRqeOjo6QqqIb29vX1cR7+tvkf1bDocDUVFRNHFLTk5m/haDwWAwGM8JNmQxngsD/VO4fakVA52PseL2IMZiwqYDpbALKQgL8582MJR5/PgxhoaGAADf/e53aZokbwP0RWlpsRqUKuKNRiNtA/T1t86ePYuUlBQsLi7CZrOpfp5nrYi32+2w2+1e/lZDQ8M6f8tqtYZUyNHT06OpIt5sNqOiogIXL15EcXExUlNTvfytQG2AgZYW+yNYRbzc3zp27Bg6OjpQV1eH27dv4/bt20hKSqL7t5i/xWAwGAzGxsKGLMaGMjO9iF//8Boe945hR90HqOxugH51BaPWFNx1/DFOJubitb/YhnJ7ysd9qS8UpEjh2LFjaGtrw9WrV3H16lVkZGSA53mUl5fDbDZ7PUaeSKlFXhFvMBgUf0bubw0ODkKSJNTV1QEATpw4QdOk9PT0gEkJGRK0pDcjIyPrEqlg/lZWVhYeP36M7OzskAs51EIq4rdu3Yr8/Hzqb5E0ibQByv2t+fl5xURKzfWprYgnrtejR4/Q1dWFQ4cOob29HRcuXMCFCxeQm5tL929pSSIZDAaDwWAow4YsxoYxO7OE7//fF8Bffxdfv/oL6D1u+nuZw/dR0X4dPSlF+MXS/4WVr+1CRWX6x3i1Lw4kkSooKMD27duxfft2TE1N0TSppqYGZ8+eRVFREXieR2FhIcLCwlQvLZajxpEicByHtLQ0WCwW3L17F6WlpdDr9V7+FkmTfP0tYOMcKTm+/hZxpebn59HT04N33nlHsQ3Ql2epiJcvLZb7WyRNIkPpnTt3kJiYiLi4OM2FHGNjY89UEb93717s3bsXo6OjkCQJDocD77//vtf+LeZvMRgMBoMROmzIYmwYJ966jbLbJ3Hsys/8/kzWUDu+/uv/jh/rv43c/HhYLKY/4BW+mCglUjExMdi9ezd27dqFR48eQRRFOBwOtLa2wmQyobS0FE6nM2AipQRxpLRWxHs8Hhw4cABJSUle/lZtbS1qa2uRlZVF3SSz2ayYSAVD6/FHq9WKffv20WGroqICLS0tXm2APM+v87eA0PaRBauIV/K3JElCW1sbAODcuXOq/C1gzbUDtFXE9/X1YXx8HPv376e/Fh8fj4MHD+LAgQPo7e2FJEmK/lZKCkueGQwGg8HQAhuyGBvC5MQ8OjpG8X9ceyvoz6aNdMPedg13rxeh+uWyP8DVvdiIoug3kSJtgCkpKaiurkZXVxdtlltdXcWDBw9QW1sLnucD+lvAU0dq165dz1QR7+tvkes5deoUzpw5g6KiIjrUhOJIHTx4UPVjVlZW4HK5YLPZ8Ed/9Ed46aWXcP/+fa82wISEBOomWa1W+pq0FHIATyvi1QxmZrMZW7ZsQW5uLr73ve8hLy8P4+PjqvwtMmwqLS0OBGl/VDr+yHEcsrKykJWVhWPHjqG9vR2SJOHu3bvM32IwGAwGIwTYkMXYEOpuP4TQdg2mpXlVP7/z7nv4mW0/G7KCsLy8jJaWFpSVlQVNpHQ6HQoKClBQUIC5uTn09/cjPj5esQ3Q198CniZSWh2pQBXxFosFe/fuxZ49e6i/5XA4MDc3B51Oh2vXroHn+aD+FhBaRTxJpMhRPL1ej+LiYhQXF1N/SxRFXLp0CZcuXUJ2djZKSkrQ3t4eUiFHUlKSptSHuHaf//znER0d7dUGqORvcRynammxL+T4Y0lJSdDjj2FhYSgrK0NZWRl+/etfo6enBwaDgfpbeXl5dP8W87cYDAaDwVCGDVmMDWGkZwR5DyXVP5860o2ZZWB5eRUGA2sb9IcWR4owOzuLrq4u7Ny5E9XV1ZiamqJpEmkDLCws9PK3AHVLi31RWxFP/K20tDQUFxfjrbfeQmpqKhobG2kboN1u9+tvkUQqFEfK3/FHub81Pj5OHbdz584BAIaHh9He3h7U3wKerSJevrTYtw1QkiTcu3eP+ls8z2N4eFhzIUeoFfGdnZ3Ytm0bjh49Sv0tSZKov0X2b+Xm5jJ/i8FgMBgMGWzIYmwIHg+gZeMO9+T/PJ7ndEGfEiRJQkxMTEiOFElvYmJiaBvg0NAQRFGE0+lEa2srzGYzbDYbsrKyNC0tBkKviHc4HDAYDPiLv/gLuN1uv/6WzWaDybTm7IUybBJHSk0iFRsbi3379mHv3r34wQ9+gJmZGQwMDODtt9+m/pYgCEhNTVVM3MiwqeX4Y29vr9+KeNIGWFpaSv0tURRx8eJFAEBkZCRaWlpULy/eiIp4X39LFEX63y4qKoquFdBSZMJgMBgMxqcVNmQxNoS4tFgMpBUDrouqfn44Nh2mMCA8nKVY/piZmaGOlJalsf4SKY7jkJqaitTUVK/dUqQNEACmp6cxNjYW1N8CnhZyHDp0SPW1kYp4+dJieRsgSZOIv1VcXAye5yGK4nN1pAijo6N4/PgxqqursX37dr/+Fs/zsFgsALwdKS3DZiBHSg7xt7Zs2YK7d+/izJkz4DgOH3zwgVea5K8N0N/S4mD4q4iX+1svvfQS9bfu3LmDW7duITExERUVFbDb7ZreDwaDwWAwPk2wIYuxIWzZlYt/vXgYx2p/ivCVxaA/f3vL57F1V87zv7AXmFAcqcePH6tKpHQ6HQoLC1FYWIiFhQX867/+KwDg1q1buHXrVlB/CwhcyOGPQK19VqvVy98iiZvL5QIApKSkYHBwULENUIlnrYj39bdIGyDxt3JycsDzPKKiojQtLQZCP/7Y1dWFqKgo/Lf/9t8wMDBA/S15GyDP89TfAoIvLVZidHRUVUW83N+anZ3Fv/3bv2FqagofffQR3b/F/C0Gg8FgfBZhQxZjQ4iLj0B2TiyubvtjVN38/wX82RFLKhpsVfjH/QV/oKt7MZEkCampqZocqWB7pJQYGhrC/Pw8XnvtNWRlZdE0ifhb8v1bxE0ihRwb6UgR5P7WkSNHcObMGdTX1+Px48f4yU9+gvj4eJomkTZAX0KtiCeOlG8CYzKZsHnzZmzevBnj4+PUTfrwww/BcRw4joPBYIDb7VaVFpGlxaEcf9y2bRv0er2iv6XUBvgshRxaPkdjY2OYn5/H5z//eWRmZtK1AszfYjAYDMZnETZkMTaML/ynHfj+0AxMi7PYXf++oqM1HJuO//jK/8Kx1wTExUX8wa/xReHx48cYHBxEaWkp5ubmEBER/L0ix9by8/MRFRWl+rnkiZTBYFD0t1paWqi/JQgCxsfHQyrkuH//vqbWPr1ej8HBQSQnJ+M//af/RB2gy5cv4/Lly8jKyoIgCCgrK6P+FhDasNnT06Pq+GNsbCz279+Pffv2oaenB2+99RY4jsPvf/97xTZAJXyXFqvBXyIl97fm5uZo4kbaAAGgrKwMi4uLqvwtuWuntSKeXIvRaMShQ4dw8OBB9PT00P1bZMgm7xHztxgMBoPxaYUNWYwNw2o142//+2G8ZQ7D3a2vYufN36Ggpwlhq8sYsabi7vbX0J5ZgT/6ooCtO3M+7sv9REOShJaWFrS1tXmlSaQN0BelpcXBkDtS8or4YP6WwWBAeHg49ZLUQBwpLcfWSEV8dXW1VxsgWTAsSRJOnjyJmpoa6m/l5+eHVMihtSKe4zjMzs7C7Xbjy1/+MtxuNyRJQl1dnVcboN1u93qfgi0t9oc/R0pOREQEtm7diq1bt2J0dBQffvghenp64HK50NHRQfdv+fO3ANCKePnS4mCQinjfIg6O45CdnY3s7Gzqb4miSP2tpKQkCILA/C0Gg8FgfOpgQxZjQ4mLi8B//X8fw/2OUdy25eBq3wRW3UB0ZBg2HSjFa9syYTYH3vf0WYccW8vPz0dVVRU9dtXa2gqTyUTTpIyMDK+kJBRHqq2tDUtLSwETKbm/tbi4iMbGRlpz/r3vfY+2AZaVlfn1t4DQKuL9JVJWq5W2AcrdJJfLBZPJhIWFBVRUVMDj8ajyt4gjJS/kUAMp5CgoKIBOp0NJSQltA5QkCRcvXsTFixepv1VWVhZyIYcaR0pOXFwcpqenkZubiwMHDtA0Se5vkcRNjiRJz6Ui3tffampqwsWLF6m/RfZvqdnlxWAwGAzGJx02ZDE2HI7jUFiUgMIi9d+EM57S3d2NqakpVFVVISUlBSkpKaiurkZXVxckSYIoiqivr0dsbCx1k6KjoxUTqWBorYg3Go30Jv+rX/0qBgYGvNoAlfwtIPjSYiUCOVIEjuOQnp6O9PR0HD16FPfv38fZs2exsLCA2tpaOByOoP4WEPo+svv3769LpORtgL7+Vk1NDQwGAywWi+ZhE9DmSMkTKdIGeOzYMdoGqORvRUREqF5a7Ht9kZGRqiviIyMjYTQa4fF48Cd/8id0UfWJEydgMBhQVlYGnueRk5PD/C0Gg8FgvJCwIYvB+IQhSdK6REqn06GgoAAFBQVYXFxES0sLJEnClStXcOXKFcTFxWFpaQnFxcWqnyfUinhRFJGSkoL8/Hzk5+fTNkBJkuBwOKi/RZru0tPTVS8tlqPWkSLo9Xrk5+djfn4e5eXlyM3NhSiK1N/Kzs6maZLc3wLUFXL4oqa1T+5v9ff3486dO3A6nZifn8e3vvUtVf6W0tJiNSglUvI0ScnfSkpKwsLCgqYU61kq4hMTE1FSUoLS0lLqb5H9WyQlJEuqmb/FYDAYjBcJNmQxGJ8g/DlScoxGIyoqKlBRUYGpqSlIkoRr164BAN555x0UFhYG9beA9UuL1UAKOeSJlLwNsLq6mvpbjY2NuHfvHuLj4zEzM4PMzMzn6kgBTxOpTZs2IS8vD5WVlRgfH6eNiSdPnvTav5Wfn4+FhQXNhRyAtop4juOQkZGBjo4OAMArr7yCjo6Odf4Wz/PrBqlAS4v9IXek/CVSvv6WJEm4desWAODEiRNobW1V1QYYSkX82NgYent7cfjwYTpcyv2t48ePo62tDZIk4fbt27h58yZSUlJo4qal2IXBYDAYjI8DNmQxGJ8g1DhScmJiYlBRUYGLFy9CEASYTCY4nU60trbSNkCe59f5W8DTivjExETV1xestU+v16OoqAhFRUVYWFhAS0sL7t69i8XFRfT09OBnP/sZ3b/lmybJUVparPb6fBOp2NjYdf6W0+lEc3MzIiIikJiYCLfbreko3rNWxG/atAmbNm1S9Lfku6WMRqPqpcVytFbEx8fHY/v27bh27RpsNhuMRiNtcoyKiqJpklINvJpCDqXHAPB7fWFhYbDZbLDZbJidnYXT6URdXR3Onz+Pjz76iPlbDAaDwfjEw4YsBuMThCiKmhwpYC2RAoBdu3YhKSlJsQ0wLi6O3ijHxcXRROro0aOqn0drRbzJZMKmTZvQ29uL0dFR7Nq1C83NzdTfImlSQUGBl78FBF5a7I9gFfFK/pYkSXTZ8bvvvkuTkkD+FhB6RbxvIiX3t8bGxqi/9cEHH+D06dMoLi5Ge3t7SI5UKBXxHo8He/bsQUpKCm0DlCTJbxtgKIUcZNjMzc1VdfwxMjIS27dvx+PHjzE+Po7t27ejubkZJ06cQHh4ON2/xfwtBoPBYHySYEMWg/EJYWZmBp2dnZodKd+lxb5tgL7+VmZmJr1h1+JIPWtF/IEDB7B//34MDg7SNMnlclF/SxAEpKWlgeO4kBwpLRXxer0excXFiI+Pp9c3MzODS5cu4dKlS8jOzqb7t3x3S6kp5FAiWGtfXFwcfY/6+vogiiIkScLy8jI6Ojpw7tw5miYF+nw8a0U8Sat8/S2n0wlJkmgbYG5uLj3SqmXY7Ovrw/j4OPbt26f6MfLjj9XV1aiqqsLDhw/pkCz3twRB0FQqwmAwGAzG84ANWQzGJ4RncaT8JVJyf2tycpK6Sb29vQCAmpoaxTZAJUKtiJcnUnJ/S564NTQ0UH+rpKQEHR0d2Llzp+YhIdSK+GPHjiE6OlqxDVDub+n1es2FHIA6R4rAcRwyMzORmZmJqakp9Pb2Ijs7W7ENUCkJCsWRkidSSkRERGDbtm3Ytm0bRkdH6VqBiYkJcByHixcvqvK3AO+lxWrxrYjnOA45OTnIycnxStxu3brF/C0Gg8FgfCJgQxaD8QkhFEdKS2ufxWLBnj17kJaWhl/+8pcoKChAT08PbQMk+7fS09PXJSVqCjn8vSZ/iZSvv0UcoBs3bgAAHjx4gIaGBsU2QF82qiLetw1QkiQvf6u8vByTk5MICwvTNGyGcvxxbm4OnZ2d2L59O44cOUL9LVEUaRugr78FaCvkIGipiI+Pj8ehQ4eQn5+Pn//858jKyqIlFdHR0TSVVHp+f0uL1VxfZGQk8vPz1/2ewWBY529JkuTlbwmCgJKSEk2fXQaDwWAwngU2ZDEYnwD+EI4UweFwIDw8HH/yJ38CvV6v6G+RprvY2FgA2gs5gKeO1K5du4KmGyaTCZWVlaisrMQPfvADzM3NYWlpCSdPnvRKk5T8LSA0R4ocf1RKpEgbYEZGBo4ePYqOjg5IkoT6+nqsrq7CaDTizp074HkeFosl6HORAUSLI+W7tDiQv1VTU4OSkhLk5OSgr68v5EKOUCriv/KVr0Cn09FBi/hbycnJNE0iQ6yapcW+zM/Pq66IJ/7W9u3b8aMf/QhTU1MYGRnBe++9h/DwcK/9W1qO5DIYDAaDoRU2ZDEYnwBEUQQADA0Nobe3V7EN0Bf50mK1KCVScn+LpEm1tbWora1FVlYWeJ6Hy+UKqZDD4/FouqEeGRnB8PAwjhw5gh07dtBlx8TfioiIoIkb8bfIkKB12CRDQrBESq/Xo6SkBCUlJWhsbMSHH34Ii8VC/a2cnBy6f0spnZmdnQ3ZkUpOTlZs9FPyt5qbm+FwOACsVaQPDQ0hOTk56Oco1Ip4l8vlVcghT5NIYyLxt0gbYHNzs6alxcDT449aPkfk9R8+fBi7d+/Gw4cP6f6tpqYmxMTE0CIY5m8xGAwG43nAhiwG42OGDAnR0dH0OFhsbCxNk+Li4hQfp7S0OBitra1+Eymj0UirxScnJ2lScurUKQBrx8Ta2tpU+Vvk+rQ6UvLjj/I2wCNHjtA2QLm/xfM84uPjn6mQQ0trX2trK6Kjo/GNb3zD6z0i/lZJSQn1t8hAFaojpaYiXu5vHT16FG+++SYAoLGxEfX19UH9LQAbXhEfGRlJ/a2RkRH6Hp04cQIAkJCQgO7ubtVtgKIoIjExUXHY9Ie8Il7ub8n3b928eRM3btxASkoKBEFAeXk587cYDAaDsWGwIYvB+Jjp7u7G9PQ0Xn/9dRQWFq5rA8zIyIAgCLDZbDCbzQCezZFSk0hZLBbs3bsXe/bswfnz53H79m3Mzc3ht7/9bVB/C1g7/hiKI0WOP/q29pE2wOLiYi9/6/LlywDWho2FhQUsLCwE9beAjamI9/W3SJrkdDoRGRlJ3SRRFENypLQefxwcHMTc3BxeffVVFBYW0jSJ+FskTZKXb2gp5PC9vqioqKCJVEJCAg4dOoSDBw/Sz9HU1BR++ctf0jZAnuf9vjdjY2Po6+vzWlocjEAV8QaDAeXl5SgvL8fMzAz1t86dO4fz588jPz+f7t9i/haDwWAwngU2ZDEYHzMkkSouLobBYFBsAzx9+jTOnj2LwsJC8DyPpaUlzY5UKBXxHMfh4cOHSE1Nxde//nVV/hZ5TaE6UsESKbm/9fjxY/zoRz9CWFgYampqcP78+XVtgEo8S0W873su97eOHTtG/a26ujrcuXMHAFBQUIDJyUlV/pZ8SNBSES9PpMLDw7F161Zs3boVo6OjNE16//33cfr0abpbamFhIaRCjo6ODlWOFIHjOPT19SEpKQl//dd/TdsAb9++7dUGWF5e7vWagy0tVkJtRXxUVBR27NiBHTt2YGhoCD/5yU/w8OFD3L9/n/lbDAaDwXhm2JDFYHyMBEqkSBvg7t27MTQ0RHdLtba2QqfTwWAwQK/Xw+PxqLoJfNaKeN82QJK4+fpbZWVlIRVyhHL8cXh4GKurq/jyl78Mk8lE0yR5G6AgCEhNTaXvEXGkQqmID5ZIyf2t+fl5vPfee7h//z7u37+PN998M6i/BSgvLQ4GcaSUEqn4+HgcPHgQBw4cQG9vLyRJoimXXq+HwWCgCakanrUiXk0bIM/zKC4u1rS0mBBKRfz4+DhWV1fxpS99CWFhYXT/ltzfEgRBU/Mng8FgMD7bsCGLwfgYIY5UoBtWjuOQmpqK1NRUHDlyBM3NzXjvvfcAAD/72c8QFxdHj13587eAja2IN5lM1N+amJigidupU6dQU1MDt9uN0tJSrK6uqvK3yLBZWloa0vFHsp8pPT0dR48epf5WfX097t69i4SEBOomtbW1aR42SUW8ltY+k8mEkZER5Ofn4/jx46r8LfKaNtKRInAch6ysLGRlZeHYsWNwOBz48MMP4Xa78e///u9ISkqCIAhebYBKiKLotbRYDf4q4uVtgL7+VlhYGFZWVlBaWgq3261qIN6IinidTofc3FxFfys1NZV+jiIjI1X/+QwGg8H47MGGLAbjY0SSJFgsFmRnZ6v6eZ1Oh9nZWQDAX/3VX+Hx48cQRZH6W5mZmeB53svfAtYSn+dVEW+1Wqm/NTg4iBMnTmBkZAS3b9+GKIo0TSJtgEr4Li1WA3GkfBMpX3+LpDakDTA8PBwxMTGqju4RQjn+SBKpgwcPrmsDJI2Jvv5WQkJCyI6Ulor4sLAwLC8vAwC+9rWvYXh42KsNUL5/S34dpJBDS6Ml+RwFS6Tk/tbDhw9x6tQpjI6O4ubNm3A4HDRNClSkEkpF/NzcnGJFvBp/SxAEesyXwWAwGAw5bMhiMD4miCO1e/duTc4HSaRI854/f6uoqAg8z6OwsDCkIUFrRTzHcUhMTMTU1BQEQUBZWZliGyDP87Barete00Y5UnJMJhM2b96MzZs3Y3x8HLdv38bdu3extLSEN954Q5W/pbS0WA3EkZIff/RtAyT+1r1793Dnzh3ExMRgcXFRcemuP4gjFWpFfHZ2NrKzs4P6W7m5uZqWFhN6e3sxPj6O/fv3q/p54rjNzs7CZrOhpKQEkiTh1q1bXv6W3W5fN/yrLeSQo6YiXu5vPX78GHfu3EFDQ4OXvyUIArKzs5m/xWAwGAwAbMhiMD42HA6H5j1S/hIpub81ODhIk5KWlhaYzWasrKwgPT0dERERqp8rFEeKLC0WBAG5ubnU35K3AV6+fJn6WzabDaurq6qXFvten5aK+NjYWJrKfOUrX0FHRwecTmdAfwsIvLTYH4EcKQLxhkpLSzE/P4/m5mZcvHgRAHDixAk0NTXRNCnQ0TcybGo9/qhUEe/rb5HdUmQIXlpaQnp6ekhLi7UcfySJVEVFBQoKClBeXq7ob8nbAFdWVlQvLfa9Pi0V8YmJiYiKioLH48Hrr7+Ozs5O6m9ZLBZ6dJf5WwwGg/HZhg1ZDMbHRCiOVLBEiuM4pKWlIS0tDUeOHEFnZydu3ryJ7u5u9PX14Xvf+55iG6AvG1kRL28DnJiY8Nq/debMGSQmJsLj8cBms6l+HuJIhVIRX1BQQBcwy9MkX3+L53lYLBbVS4vlkOOPagcfs9mM0tJSnDlzBhUVFfR5P/jgA680KS8vb90AoaaQwxc1nyPib7300ktob2/H7du30dvbi/7+fvzwhz+kaVKgdI84UvKlxWqvzzeRkvtbjx8/pp+j9957D+Hh4UhMTAxpaTEp5AilIp4cJzx+/DhaW1shSRJu3LiB69evIzU1le7fYv4Wg8FgfPZgQxaD8TEwPDyMoaEhHDt2TPVj5EOCmps2nU6HwsJCuFwuhIeHo7q6Gs3NzbQNMDMzkx7r822XC7S02B8zMzM0kfJ3w2q1WrFv3z7s3bsXAwMDtOocAH71q1/R/VuB/C3gaSHHs1bE+7YBktSG+FtZWVkYGBgIaUjQevyRHFvbsWMHkpOTqb9FGhMdDgciIyNpUpKSkoKxsTFVS4vlyB0pNccfw8LCUFZWhs7OTgwODuLQoUNobm6m/hZpA1R6j9QUcvjiz5GSk5iYiMOHD+PQoUN4+PAhRFGEKIoAgN/85jf0PQqWcoZy/FGpIt5gMMBut8Nut2NmZoYe3T179izOnTuHgoIC2pjI/C0Gg8H4bMCGLAbjY4Dc3Pm29gWCOFJabqjlidSWLVuwZcsWTE5OrkuT5P6WXq9XvbRYDqmIV3NDzXEc0tPTER4ejrt372LTpk1YXFxU5W+pLeTwRRTFgMcfzWazl79FBsCVlRW0tLTg3XffVWwD9MV3abFafBMpub8l37919+5d3L59G0lJSfT4Z6iFHGohiVRZWRl27tyJnTt3YnR0FKIowuFw4MSJEzAYDF67pXQ63TM5UmpSQI7jkJOTg5iYGDQ1NaG8vByLi4u0DTCQvxVoaXEgglXER0VF0feIFIo0Njaio6MDRqMRpaWlzN9iMBiMzwBsyGIw/sC43W40NTUBWPvWnSxhDbarSJIkGI1GFBcXq34upYp4i8Xi1QYoSRIcDgf1t4qKioImUv6uLzU1VbUjRR7DcRwOHTqEqKgoRX8rOzub7pYymUyqlxbLWV5eRktLi+qK+NjYWOzfvx/9/f3o7+9HWVkZmpub17UBpqSkrHuP1BRy+OLPkSLI/a25uTnamNjd3Q1gzeFS428BCOn4Y3t7+7r2x/j4eNoG2NPTQ/dviaKI6OholJSUoL29PaRhMykpSfPxRwCorq5GTEyMVxugkr9lMBhoIUewpcVy5Mcf1VTEJyUloaqqCiMjI3j48CGKiorW+VukVZLBYDAYny7YkMVg/IHp7u7G7OwsysvLMTw8jJqamnVtgGFh3n81n8WR8lcRL/e3qqur0dnZSQcuYC1RCA8PD+pvAd5Li9WilEj587dOnjyJM2fOoLi4GHNzc8/dkQK8K+Krq6u90qS6ujrcuXMHiYmJNCkhlfDPw5GSExERga1btyIpKQk///nPUVJSgkePHuGDDz7w2r+l5G/J90iF4kgpVcRzHEcbCl966SW6W6qurg4ejwft7e2IiooK6m8B3kuLtTpSeXl5NJHybQP09bfKysowNzcHvV4fUiGHls/R/Pw8Ojo6sHXrVhw7dgxLS0v0PSL+VlpaGv2yhflbDAaD8emADVkMxh8Ykki98sorCAsLw6NHj+ixq9bWVphMJuomZWRkgOM4VUuLfdFSEa/X61FUVISioiL88Ic/xMLCAqxWK/W3SBugkr8F+F9aHIhgiZSvvyWKIpxOJ+bn5xEWFoYLFy6A5/mg/hagXMgRDHL8kbznvv4WSZMuXryIixcvIicnB3l5eSEVcoRSEU8SqS984Qs0mSFpksPhQFRUlFfiBoS2j0xLRXxYWBhsNhtsNht+/OMfY3p6GiaTSZW/RV4TEJoj5a8iXu5vdXd3Q5IkuFwuLC0twWAw4Nq1axAEQVUBDVla/CzHH8PDw6m/NT09TRO3s2fP4vz589TfKioqYv4Wg8FgvMCwIYvB+ANCjq3ZbDZ6A5WSkoKUlBRUV1ejq6sLkiRBFEXU19cjLi4Odrsd3d3dmpYWA6FXxD969AhHjx7Fjh07MDExQSV+4m+R3VIFBQXQ6/XPzZEiEH8rPT0dGRkZOHHiBNLT09e1Adrt9nX+FvA0kQrl+KO/iniz2Uwdt7GxMZqUXLp0CcDaAJmQkBDU3wLWHKlQKuKJI0WGFdIGeOzYMbS3t6/zt3ieR2dnp6alxUBoFfGjo6MYHBxEVVUVdu/ejZGREfoenThxAuHh4bQxkfhb5HMkT6TUQPaRBUukOI5Dbm4ucnNzkZeXh/feew+JiYnU30pNTaVpktLnWE0hhxKBKuKjo6O9/C3yZUt7ezvCw8Pply1ZWVnM32IwGIwXjA0ZsjiO+ycAfw3AA8AB4C8BpAL4DYB4APUA/tzj8SxtxPMxGC8qgVr7dDodCgoKUFBQgMXFRbS0tECSJFy5cgXA2g1ZfX09bDZbUH8LWLu5S0tLe6aKeKvV6uVvkTTJ5XLBbDajvLycLiAOtZBDy7f1TqcTMTEx+NrXvobFxUWaJpE2wOzsbNqYSJyZUIZNLRXxcXFxOHDgAPbt24dvfetb0Ov16OnpQVtbW1B/C1BeWhyMQIkUaQMkR+LIe3ThwgUAa06ew+FQfWQw1OOPwNNEKiEhwcvfIvu3iL9lt9uRlJSkaWkxEHpFvMvlQlRUFL7+9a9jbm6Opknnzp3zSpPkbYBqlhb7MjY2ht7eXhw+fDjokJSUlITq6mocOnQIb775JjweD5xOJxobG2GxWGgRDPO3GAwG48XgmYcsjuPSAfwjgDKPxzPPcdzvAPwpgOMAvu3xeH7DcdwPAXwdwA+e9fkYjBeZQI6UHKPRiIqKClRUVODy5cu4evUqDAYDTp8+vc7f0uv16x6/0RXxSvu3JElCQ0MDVldXAax5WRMTE4ppki9kabGWG1bfRMpkMnm1ATocDoiiiA8//BA1NTU0cRNFUdPSYiC0ivienh7Mzs7iC1/4Amw2Gzo6OiCKIu7du+flb/E8T5MasrRYnkipQW1FPPG3tm7dSj9Hbrcb77//vtf+rdzcXMV0JlghhxJKjhRB7m8dP36cukm3b9+G2+0GAExPT2NmZkZVKkocqWepiPf1t0ia9O6771J/i3yOtCwtBp4Om1qub2BgADMzM3jllVdgs9no/q3r16/j2rVrzN9iMBiMF4SNOi4YBsDMcdwygAgAgwAOAfjKk9//BYD/D9iQxfgMMz09rdqRktPe3o60tDT89V//NYaGhmiaRNoAbTYbeJ6n/hYQmiOltiJe7m9NT0/jO9/5DkwmE65evYqrV69Sf8tms8FkMin+GRvhSMmJjY2l/lZ/fz8kSYLT6URzczMA0H1XqampQd/7UI8/ylv7gvlbubm59MZbqyMVakV8Z2cnkpOT8Y1vfAO9vb00TSKlFvL9W/LXpHXY7O3txcTEBA4cOBDw5+T+1uTkJL73ve/BYDDg4sWLuHTp0ro2QCU2uiI+MTERVVVVOHz4sJe/RdpAs7OzMTIyoiodDrUiXpIkmkaS4hme5zE9Pe21f8s3cfMty2EwGAzGx8sz/6vs8Xj6OY57A0APgHkA57F2PHDC4/GsPPmxPgDpSo/nOO5vAPwNsHYjxGB8Wgk0JPhDnkhxHIfU1FSkpqZ6pUlNTU2oq6tDXFwc/YZby9JigiRJCA8P11QR393djdXVVbz++uuIjY1dt3/L198CfJcWtwI4A+D/EfS5RFFEampqwBtcjuOQkZGBjIwMHD16FO+++y5aWlrQ39+Pf//3f6f+Fs/ztA3Ql1Ar4v0lUv78rQ8++AAcxyEsLAwrKytwu92qhqZQjq3JEymO46i/9dJLL1F/686dO7h16xaSkpIgCAL9HKldWkxQ60jJ6e/vx8rKCr70pS/BarXSNIm0AZLdUjk5OXRIJomUmkIOOWoq4uX+1vHjx3HixAm0tLSgp6cH3//+96m/Zbfb/f4dU1paHIzV1VW/FfHR0dHYtWsXdu3ahUePHtEm0Pb2dhiNRpSVlTF/i8FgMD5BbMRxwVgAnweQC2ACwO8BqD6j5PF4fgzgxwCwZcsWz7NeD4PxSYU4UlqcCpIk+CZSOp0OhYWFKCwspP6WKIq0DRAACgoKMD8/r8rfepaKeJJIcRzn1QZI0iSXy4WIiAgq8ff09DwZNn8F4C0AZgD/AMD/cblQKuJ1Oh36+/tRUFCA1157jaY2xN/KycmhjYnyG1q1hRxylPZIKUH8rf3796OjowNvv/02AODtt99GZGSkV5rk70aZFHJsREW8r79F3CTSBujxeJCXl4elpSVVxxnJ8cdQK+JJ7TxpA3z48CFNk0RRRExMDH2PHj58qHnYDKUiPiwsDENDQ8jNzcVrr71G06RA/hYQfGmxEh0dHZifnw/6mpKTk1FdXY3Dhw+jra0Nv//97+nSY6vVSvdvxcfHq35uBoPBYGwsG3G+oArAA4/H8xgAOI57D8BuAFaO48KepFkZAPo34LkYjBeSUBwpt9sNSZKCJlJyf2tychK/+c1v8OjRIzQ2NkKSpKD+FqC8tDgYpCLet7VP3gZ45MgR3L9/n/pb9+7dg17vRlTUDAyG97HWlTMHoA7ALr/P5W/YDAQ5/lhVVQWz2ezlb5E0ifhbZLdUVlaWpqXF8utT40gROI7D+Pg4AOAv//IvMTk5qdgGaLfbvY6akUTqeVTER0REYNu2bdi2bRtGR0fxzjvvYGhoCA0NDbQoI5C/BawNm6E4UkoV8RzHIScnBzk5OV77t0gboMFgQFRUlOYjnYC2inj50uKoqCivNkCSJr377rswGo00cUtPT9e0tJggiiIiIyORn5+v6ud1Oh1mZ2fh8XjwF3/xF3S3HPG30tPTabodERGh+joYDAaD8exsxJDVA2AHx3ERWDsueBhrd0yXAfwx1hoGvwbggw14LgbjhUQUReh0Os1DwvT0tKYbarPZjLGxMQiCgG3btin6W+QmUD4YqS3kkKPm+KNer0dxcTGKi91YWPgAd+70orb2EGZmYvCd7/wTsrO7wfMSysouw2RSHrLkhRxab6iVEqnY2Fjs378f+/btQ39/P0RRRHNzM5xOJ4xGIxYXF5Geng6Px6Mq7QjVkSKtfaRQpLS0dF0b4IULF6i/VVpaGtKwGUpFvMViwfj4OOx2OzZv3kz3b5FhkjQm+qZpgZYW+0PN8UeDwYDy8nKUl5djdnYWd+7cwbVr17C8vIxvfetbqvytQIUcgSCOlG8ilZSUhKqqqnX7t5qamhAREYGFhQVNzuH8/Dza29uxdevWkCriMzMzqQ8p97fOnDmDc+fOobCwkO7fYv4Wg8FgPH82wsm6w3HcOwAaAKwAaMTa8b/TAH7Dcdz/9eTXfvqsz8VgvIi43W6Ioojk5GRN32qTpcVaHCl5IqXG3+J5HgaDIaRCDkmSgjpSQAuA/wHgNzCZPFhePgyOc+PrX/93dHYWQpJ4nDz5Cs6cWURx8TvgeR75+fleiRtxpKqqqlRfm5rjj3J/69ixY+jo6MDp06exuLiImpoa3L17F4IgwG63+/W3gND2SPmriJe3Afr6WzU1NQDW9qppce2epSJeEATaBkj8LVEUqb+VnJxMEze9Xq96abHv9SUlJalu7YuMjATHceA4Dn/xF39BP9vE3yJtgHJ/C1BfyCGHVMSXlpb6/bur0+mQl5eHvLw82ph47tw5AMCpU6fQ0NCgqg0wUCGHP/xVxPv6W8Rxa2trg9FopGU5zN9iMBiM58eGfJ3l8Xj+TwD/p88vdwHYthF/PoPxItPd3Y3Z2VnMzs7im9/8Jk2T5G2AvigtLVaDUiLl628RN4n4W1arFR6PB0VFRaqfZ3h4OIgj9XS4WjsSCHg8HBwOHvn5nUhPH0R6+iD27r2KgYF0iGIlnM4oNDc3IyIiAuXl5eB5HmlpadSR0jJsaq2I1+v1yMjIwOzsLLZv346EhASvNkB//hYQeGmxP9QkUnJ/q7e3Fzdu3EB7ezsGBwfx7W9/22v/lj8CFXIEuz7fpcVyf2t2dpYmW8Tfio+Ph9vtRllZmernGR0dRX9/v6YBmiSbubm59Dgh8bdIY2JTUxP1twRBQGJiYkiFHFor4sPDw5Gfn4/5+XlUVlbSz9HZs2fXpUm+f68DLS32h5qK+OTkZBw5cgRVVVV48OABbt26hcbGRjQ0NMBqtdIvW5i/xWAwGBsLOzPAYDxnyLG1L3zhC1Tgr6+vR2xsLL3BiYuL83pMoKXF/pienkZXV1fARMpoNGLTpk3YtGkT9YDIsuNf/OIXim2A/l6TcrX3+uGK0N2djakpC6qrP6K/xnFAeno/0tP7cfTof8f9+4mQJAn19fW4e/cu4uPjMTExsa5UIBjPUhFfWVmJpKSkdW2Avv5Wfn4+xsbGVC8tJqh1pAikDbCpqQkGgwGf+9zn4HK5gvpbgPpCDjnk+GOgRCoyMpL6WyMjI9SVAoC33nrLK00KlGo9iyMlX1os97fk+7eIv5WSkoKRkREUFBSEXMihFpJIbdmyBampqdTfImmSvA2Q53lkZ2djfHxc9dJigtaKeJ1Oh/z8fLS2tkKn0+Gll16Cy+XCtWvXcPXqVeZvMRgMxgbDhiwG4zmytLQEl8uF8vJyujeJtAGSAefKlSvIyMiAIAiw2Wwwm80QRfG5OFJyLBYLiouLcenSJezcuRNut5u2AZrNZpom+fpbykuL/Q9XBEkSEB6+iOLiVsXf1+uvorj4n1FcXIyFhQU0Nzfj9u3bWF1dhcvlws9//nOaJvnbvwX4VsRrO/7om0jJ06S+vj7qJjmdTkRGRtJjhFocKXL8UYsjJV9abLfbYbfbFf2tvLw86m+Fh4drLuQAtB9bS0hIgCAIuHbtGrZs2UL/e4miiOjoaNoG6OtvhepIBUuk5P7WzMwMnE4n7t69i5WVFbS1teHXv/61YhugL75Li9WilEglJSXRNkDibzmdTjQ2NsJisdDPkZZhOJSKePnxR1IEQ/wtURSZv8VgMBgbCPvXk8F4jrS2tmJ5ednrhlXeBjg1NUWTktOnT+Ps2bPIzc1VbO0LRigV8WRp8e7duxEZGYnq6mrquDQ2NuLevXuIj4+niZvVavVZWhx8uAKA5WUDXK4ylJW5YDCs+PmpWgD/DAAwmUzYvHkz2trasLCwgC1btkCSJJw8edJr/5avvwWEto+MVMT7S6Q4jkNmZiYyMzOpvyWKIlpb1wbGX/7yl/Q9CjYwyJcWq4U4UvKbcLm/NTo6Sj9H77//Pk6fPo3CwkJ0dHSEXMihpSKefI727duH6OhorzTp9u3buHnzppe/FR0dHbIjpaUiPioqCjt27EB3dzcWFxdRUVEBp9OJd999N6C/BYTuSAWqiPf1t1pbWyFJEjo7OwEAv/3tb1X5W8DGVcTL/a2hoSHamNjW1gaTyUT3b2VmZjJ/i8FgMDTAhiwG4zlCHCl/i7ZjYmKwZ88e7N69m97gNDQ0AADq6+tp+UAgfwsAHj16FFJFvG8ipdfrUVRUhKKiIiwsLNDE7fLly7h8+TKysrLg8XgQHh6G4uL/CeBtBBquCK2txVhaMoLnxQA/dQPAEsi+LJJI7d6926sNkKQAcn+LFH1wHKeykMMb/8cf16PX61FSUgKTyYTW1lZUVFRgdHSU+lvyNkBff+tZHSl/iVR8fDwOHjyIAwcOoLe3F6IoQpIkeDweiOLae072bwVCvrRYLXJHihx/DAsLg81mg81mw+zs7Lr9W3l5eVhdXdU8JDxrRXx1dTWqqqrWtQFaLBaauJHPjZqlxb6Q91rN5yg8PBw8zyM2NhadnZ2w2WwYGRnB2bNn1+3f8k2T1BRyKCFJUsCK+JSUFKSkpFB/S5IkiKKIhoYGxMbG0veI+VsMBoMRHDZkMRjPCeJI7dmzJ+g3wBzH0TbABw8eYHl5mZY+1NfXIy4ujt7g+PpbwNrN00ZXxJtMJupvTUxMPDlSdA+jo9PgODfef38ZPF+IgoL70OvdAZ9LkgTExEwiJ+dhgJ/y3pdFEilyQy1vAzx69Cg6Ojq8/K2EhATk5+drXlpMjq3l5+drqognhRzHjx+HwWBY1wZ4+vRpuluKLNl9FkdKTSJF/K2srCwMDg5ifn4eycnJtA0wKSmJNiYq+WBahk1CT08PJiYmcPDgQcXfj4yMxPbt27F9+3bqb0mShMnJSeh0OtTU1Kjyt8j1aa2IJ+2P8s9Rbm4ucnNzaeImiiJu3LiB69evIzU1FQUFBZqXFsuHTa3HH8PCwvC5z30ORqMRjx49ommS3N8SBIG2AWot5ACeVsSrOf5I/K38/HyMjo5iamoKVqsVV69exdWrV5GRkQGe52Gz2Zi/xWAwGH5gQxaD8ZxwOBxeQ4IahoeH8ejRIxw7dgzbt29X9LcyMzPpDY7ZbFZMpNSgpSLeah3E3r0/gMXixIkTr6OkpBXd3TlwuWyIiJiFzeaEIEhIS+uH7z3pzEwkOjvzsXv3DXBcsNSrFmTICpRIkTSppKQE8/PztDHxzp07AACXy0VvToN90y9fWqwW0v4oX1rs62+R/VsOhwORkZGw2+0YGBhAVFSU5kKOUCriyfHHnTt3Ym5ubl2aJE/cwsPDNRdyELQcf0xISMChQ4eQnJyMd955B7m5uWhtbfXytwRBUGxq9Le0WM31+auIV/K3JEnCtWvXAACdnZ3UXQxWvCJfWqwWpUQqOTnZy98iu+4aGxthtVpht9vR39+PyMjIkAo5tPx7NDY2hv7+fhw+fBh79uzB1NQU3b9VU1ODs2fPei07Z/4Wg8FgPIX9i8hgPCdCdaTkiZTc35qcnKQ3OMTfKioqQlJSEqanpzWlN0tLSyor4r2dK4fjz2CxTOCLX/w93G4OnZ0FkCQeDQ2bce/edsTHj4DnRfC8BKt1EgDgdNrh8eiCHBUk1AL4Z+pIqXlNZrMZmzdvRmVlJb71rW8hPDwcs7Ozim2ASjfn/pYWB0K+R8oXJX9LkiTcvXsXbrcbERERuHXrlmIboBKhVMQTR4p8jiIiImgboJK/VVpaipSUlJAKOciQoOX4o8PhQFRUFL7yla9gdXUV7e3tkCQJt27dws2bN5GSkkL9LZIuhjJsaqmIJ/7W9u3b8e1vfxt6vR6jo6N49913YTQaUVpaSveGKaVb/pYWByJQIiX3t15++WXqb12/fh0ejweRkZGoq6tT3Qb4LBXxJNmMiYnB7t27vfZvOZ1OtLa2wmQy0f1bzN9iMBgMNmQxGM+FR48e4dGjR3jppZdUPyZYImWxWLz8LXKD09LSAgDo6uqCxWJZ1waoRPCK+PWFFjMzUV6JlF7vQVFRO4qK2rGwYITLVQZJEnD58mFcvnwY2dnd4HkJTU0CUlMHkJg4ouJdWPOyyJCg5dhad3c3ZmZm8Prrr8Nms6G/v5+mSaQNkDQmEn9LzdJiJdRWxJOb7tLSUly7dg2XLl1CdHQ0bQMM5G8B/pcWB4IcW/OXSMn9rZ6eHtqYSG6oBwYGVBdfKBVyBMM3kdLpdIr+1vnz5/HRRx8hPz8fPM+jqalJcyEHOf6o5fp6e3sxPT2NV199FTzP+/W3BEGgX6A8qyMVLJEi/hbP8/RzZDQaaRtgQUEBBEHw2wbob2lxIEiymZOTs24ZN8dx1N+qrq5GV1cX9bfq6+thsVhQUVHh93gzg8FgfBZgQxaD8Rx4FkcqWHoj97cOHDiAN954A9HR0bQ0Iy4ujt6QxcbG+r0+5Yp4/22BDke530TKZFpEZWUjKisbMTFhhSTZIUkCTp58BQCQkjKI9vYi5OcH87fm4PHcC/n4I1laLPe35GlSXV0d7ty5Q2vHw8PDNe8jI46U1vbH1tZWpKSk4Bvf+MY6f0ueuBF/C0BIw6bainiO45CdnY3s7GxUVVXhW9/6FiIiInDv3j3cuXNnXRugEkpLi4MRKJHy9bfIbqn33nsPAKizqNQG6It8j5SW44/yinhff4ukScTfSktLA8/zCA8PD6mQI5SK+Pb2diQlJeFv//ZvFfdvkTSJ+FuAuqXFvpCK+L179wb8OZ1Oh4KCAhQUFGBubg5vvvkmVlZWvNZTkMZEs9ms+vkZDAbjRYcNWQzGBiNPpLRI4cSRKioqUv2Y9vZ2rK6u4tVXX0VKSgp1k2pra1FbW4vMzEwIgoCysjJ6g6O8tFjdnqu0tP6giZTVOoF9+65h795reP/9VyFJAiYnLXj77a8gImIW5eVO8LyItLSBdf4WAHR3X8bU1KqmhrtAiZSvv0VSm4sXL9Lfn5iYwOLioqoUIhTXzjeRkvtbvb29NE0ix+hI4hZKIUcoxx+7urqwsrKCz3/+80hOTqbvkbwNkOd5lJSU0GOBapYW+7s+NYlUQkICDh8+jEOHDuH999+HJEkYHR3FW2+9hZiYGFoE4+8YJSnkCKUiXv46CQaDge4om5mZoUd3z549C2DtczQ/P4/l5WVVqWiojpS8kCM5ORlHjhzxagN0OBxoaGiA1WqlQ7KWpcUEcvyxrKxM9WN6enqwvLyML37xi0hOTqb7t5i/xWAwPouwf+UYjA3mwYMHmJ6eRkZGBsbGxlQdl5EvLdZ6bI1UxHMcR9sAJycnaVJy6tQpnDlzht7gjI6OyvZIqdtzNTychKGhVBw7dkb1tQEcurtzUVjYgS996Te4f78AkiSgvn4z7t7djoSEx+B5CXb7U39r7TUNwGjMUlXIQQh+/HENs9mMLVu2YMuWLejr68NPf/pTGAwG1f7W2vWF7kj5JlLyNkBff+v27dsAgKysLExNTam6QSbDplZHSl4Rr9PpqL9F2gAdDgdOnDgBg8FAd0s9fvw4pEIOrRXxwNrNe35+Pr70pS/R/Vs3b97EjRs3FP0t8poCLS1WQm1FfFRUFHbu3ImdO3eip6cHP/vZz6DX6/Hee+/RwhWe5/36W+T6/BVy+MNfRby8DfDll1+mZTnXrl3D1atXAQAZGRmYm5tT9cXPysoKnE4nSkpKQq6I1+l01N+S79+S+1tq1lMwGAzGiwobshiMDYYcFWxpaUFLS4uq4zJKS4uDEagi3mKxYO/evdizZw8GBwfpbqmWlhZwHIeICCMWFv47PJ6fq2j8A0SRB8e5UV7uVH193d05mJqyoLr6PPR6N4qL21Fc3I6FBdMTf4vHpUuHcekS8bdEFBZ2wOWKRVlZ8DY3OWodKTl9fX0AgL/8y7/E4uIiTZPk/pYgCEhJSaHvb7ClxUoQRypYIiX3t+bm5vD222+jv78fTqcTTqeTpkmBBqhQHKlAFfGkDfDgwYPo6emBKIpwuVy0oEVrfXcoFfFkafHBgwe92gBnZ2dpmuTrbxUUFIRUyEEq4rW09j169AgA8LWvfQ0LCwv0c9TY2AiLxUKP7soLcIItLVZCbUV8eHg4BEGAIAiYnp7Gb3/7W/T398PhcKC5uRmFhYXged6vvwUELuTwB6mI37Jli9fnSH68WcnfslqtEASB+VsMBuNTBxuyGIwNhLT2CYKAAwcO0DQp2HGZYEuLlVBzbI3jOKSlpSEtLQ3V1dWorz+NM2casbAwh5/+NBtxcf9A2wBjYycU/wy3m4PDwaOg4D4iI2dVX58k8TAaF1Bc3Ob16ybTAiorG1BZ2fDE3+IhSTxOnvw8dLpVuN16xMfPYXV1FXq9PujzzMzMoLOz0+f4o5rrW6uIJ4mUvA1QFEXqJiUmJtIb5VCGBOJIHT58WPVjDAYDHj9+DEEQsGfPnnVtgCUlJRAEAbm5uV43tMGWFivhu0dKCbm/dfz4cdTV1eHcuXOYn5/HD3/4Q1X+VrBCDn8QR8r3+GNkZCR27NiBHTt24PHjx/Q9eu+99xAWFoaVlRUkJSXB4/Go+lw8a0U8KVPJy8uj+7dIG+C1a9eov1VeXr6utU8NoVTEm81mjI6Owm63Y9euXTRNamtrg8lkovu3fNsAgy0tVqK5uRmrq6sBvyiS+1uLi4uoq6vDhQsX/K6nYDAYjBcZNmQxGBuIPJGKiYnxagP0d1zGYrGoXlosR5IkpKenq6yIb4Fe/z8wOTkCnW4H/v7vv4uHD3MhSTxqaw+htvYQsrIegucllJU1w2xeoI/s7s7B9HQMjhw5p/ralpcNcLnKUFbWDINhxe/PrflbV7F371UMDKTj97//IqamYnDx4n3cuvUtmiaRG1glQnGk/FXEB/K3Ll68CL1ej8TERE0pG1larMWRki8tlrcB9vb20jSJ+FvETYqOjsb9+/exc+dOzUNCSkqK6ta+sLAwzM3NgeM4fOMb36Dte4H8LSD40mIl1FbEJyYmUn+ru7sb77//PqampnDhwgXcvXuXtgEq7VwjqBk2fRkdHVVMpMLDw6m/NT09TRsTz549i/Pnz0Ov1yMpKUmzs6n1+KM8kSJtgFVVVTRN8vW3eJ5HREQE2tvbsXXrVs2fIy0V8UajESsra/82fP3rX6efI/l6CvKFlJovWxgMBuOTBhuyGIwNRJIkWK1Wr0TK97hMZ2en13EZs9kMj8ej0PTnH/UV8U+dK7cbcDj+CQUF9xEXN4G4uEZs2tSIiQkLHI61NOnUqc/hzJmXUFzcBp6XUFBwH5IkKCZSgWhtLcHSkhGCIKn6eY4DLJYJTE3FYOfOG8jKiock/THq6+tx9+5dJCQk0JtA3zrpQEuL/eG7R0oJub81NjaGq1evQhRFDA8P44033kBpaem6NkBflJYWq70+3+OPcn/rpZdeorul7ty5g1u3biEqKgoejwcFBQWqnyfUiniytJgUWJA2QJImnThxAuHh4fQ9ysnJ0bS0mCAfNtVAyiBmZmawbds2ZGZmevlbqampNE3yPboZiiOlJpGKjo6m/tbw8DCuXbsGp9NJP0ckTZK3AfpChs1QHSn58Ud5mkSSd0mScPXqVVy9ehVWqxVut1uTE/ksFfG5ubm0CVRpPYXZbKaNiczfYjAYLxJsyGIwNohAjhRBp9OhsLAQhYWFWFxcREtLC86cWSuT+NWvfqX6uIzv0uL1rC+06O7Ow/R0DI4e9U6krNZJ7N17DXv2XMPgYBpEkYfTaYfLZYPZPIfFRSMKCjoQFuY/kfJFknhYLBPIzn6o+jFkafGmTSISEuZQXPxLLCy4aZp06dIlXLp0CTk5OeB5HmVlZZicnMTQ0JCmRczk2FpBQYHq1r64uDhwHAeDwYAvf/nLaG5upm2AkZGRNE2S+1tA4KXF/lBTEU9a38rKyjA3Nwen04kLFy4AAH75y1967d8KlACpGTZ96enpUayIl/tbDx8+pLulRFFEdHQ05ubmkJ+fH1IhRygV8ZWVlUhOTkZ5eTlmZmZomnTu3DmcP38eBQUF4HkexcXFmJqaUr20mCAfNtW29iUlJcFoNEKv1+OLX/wiWlpa4HQ60djYCKvVShO3+Ph4r8eF4kipqYiX+1tTU1NwOBy4cuUKgLV/jwoLCyEIQtA2wFCOP/b392NsbMyrIl7+hdSRI0foF1JNTU2oq6tDXFwcfY/8radgMBiMTwpsyGIwNghybE3tDbXRaERqaiqWlpZw4MAB6PV6Vcdl3G43nE6nn4p4/22BxJEqKlJOpDgOSEsbQFraAI4cOY/OzgJcvboX/f2ZaG8vwb/92z+A5yXwvASrdcLv6/JdWqwWUVyriE9IIBXxdTCZdmHz5s3YvHkzxsfHaSU0aQO0Wq0AAJvNpvp5uru7MTU1FVJFvM1mo3uTlNoA5f5WTExMSIUcTqdT0/HHiIgI5ObmYnl5Gbt376afI+JvkTTJ19/aaEeKwHEccnJykJOTQxO3GzduYHp6Gu3t7fjRj36k2AboC3GklAo5AqFUER8VFeXlb5HdUu+++y7Cw8PpDbuWYZMUcmitiG9ubkZZWRmKi4tRXFzstX+L+Fvp6ek0cYuIiIAoipoLOUhFvNp/j2JiYlBaWooLFy7QwczpdFJ/i6RJvv5WoKXFgRBFkZa9KOH7hZTL5cLt27eZv8VgMF4Y2JDFYGwQxJHy/RY62GN0Oh22bt2KiIgIVcdlSEW8d3oTuIp9aWnNkSovdwR0pAh6vRtFRe24e3cbYmImsH//VUgSj8uXD+HyZeJvibDZXDCZFrweG2hpsT+GhxMVKuJrAeyi/19sbCz27duHvXv3or+/ny4XBoAf/ehHdLdUIH8L8F5arJa2trZ1FfG+bYC+/lZWVhZ6enqwffv2ZyrkUPsYjuOwY8cOREVF4cCBA+jp6aFNdyQRIo5bcnKy6qXFcsgeqbKyMlWJlMFggM1mgyRJmJqawp49e+BwONa1AZaUlKw7ThmKI6WmIj4xMRFVVVU4fPgwuru7IYoirUb/2c9+RlPJYMdP5UuL1aKUSIWHh9PBfHp6mjYmnjlzBufOnUNubi66urpCcqSSkpJUu3bkMQCwe/duxMTEKLYBxsbG0jQpLi6OLi3WUsixurqq6fij0WjEpk2b0NHRgenpaezcuRMOh4P5WwwG4xMNG7IYjA1AvSP1FKWlxWqOyxgMBtmQoG7PVWtrKZaXw1U7UgAwPR2Frq487N593acN0A5JEnDq1Cs4c+b4E39LREHBfej1btVLi+VIkqBQEV8L4J/X/SzHccjIyMDy8jLu3buHnTt3YmJiAnV1dbhz505AfyvQ0uLA1xc4kYqIiMDWrVuxdetWjI2N0XQLAOrr6zE3NxfU3wLWCjkGBgZCOv4or4iXtwEq+VvJycnQ6/UICwvT5Eg9a0U8+b+RkRGaJr333nvU3xIEATk5OeA4TvXSYjla2h85jqPpniiK2LJlCyYmJnDjxg1cv36d+lt2ux2RkZFejw20tDjY9QVKpKKjo7Fr1y7s2rULjx49giRJqK+vh8fjQVNTE1ZWVsDzfEB/Cwi9It53abFvG6Cvv5WRkQGdTge9Xq952Jyfnw+5It7fegryhZQgCEhPT2f+FoPB+FhhQxaDsQEEd6TWo5xIPUXpuIwoinj4cM1zeuut/xcE4eKTNsDAx/KII5WV1aP6+ogjJR/M1toAr2Hv3msYGEiDJAlwOsvhctkQETGLvLxODA2l4uhR9UuLPR4ODoddoSL+BoAlAMo3saIowmg00v1J8/PzcLlcfv0to9GoemmxnJmZmaCOlJy4uDgcOHAAbW1tMJvNyM3Npf5WVFSUV5rk++eRIUHL5yhYRbzc35qdnUVzczNEUcTAwAAA4He/+51iG6ASoVTEk2Nr8vc8ISGBtgE+fPgQoiiipaWFFn4UFBRoXloc6vFHUshRXV2N8PBw6m+JoqjobxkMBrq0WItrp8aRkpOcnIzq6mo8fPgQs7OzyMrK8moD9OdvAf6XFgciWCJlNBpRUVGBiooK6m+JoojHjx+D4zi8//77iusplNiIinjf9RQkcZN/IUW+bGH+FoPB+DhgQxaD8YyQRKqwsFBzJbPRaFR1bI0cl9HrH+Hhw4eorKxDT082bQMsKmp/ssz3PvT6Va/HkkRqz57rmhwpSeJ9HKmncByQnj6A9PQBHDlyDp2dBRBFAc3Na8PBvXvbsLQU/sTfmgz4PGRp8ZEj531+Zw5AHeRHBgmktU+eSJnNZi9/izTdEX+rpKQEo6OjIe2R0uLaAWuJFCnk2LFjh6K/lZSURJOSmJgY1UuLfdFSER8ZGYlt27YhIiIC7777Lux2O3p7e3HixAl69E3J3wICLy0ORKBESu5vyXdLNTQ00NdGkqlg78lGVcTL/a3h4WFadf7uu+/CaDSitLQUo6OjiIyM1FTIodWRAtYq4kkhx+7du/Hyyy8H9bfULi32JZgjJScmJga7d+9GbGwsfv/736OoqAi9vb3r1lMotQGSRGojK+L1ev26L6QkSUJtbS1qa2uRlZVFv2xh/haDwfhDwYYsBuMZefDgAWZmZjSlI6Q62W63B/3Wd421Y4GiGAarNQ5/9EenAXgwOJhK06SWljKYzXOw2ZwQBAnp6X3gOMDhsIfgSCU9caRqgv4s8bcKCjrw7W//EyIi5mA2L+Dy5cO4fPkwsrO76f4tk2lx3eMDF3LUQmnIIomUvxvW2NhY7N+/H/v27UN/fz913BYWFmAwGHDu3DkIgrCuDVCJUCrifRMpf/7WhQsX6G6ptLQ0zUuLlYZNtdcXHR2NV199FRzHoaenh+7fIr9H3CQyHBFHSsuQoMaRIhgMBpSXl8Nms+HNN9+EwWCAXq9X5W8BwQs5lAhWEZ+UlISqqiq6f4s4bsvLywgPD8fly5chCIKqXXXP4kiRRCqYv1VYWIi0tDTNjpR82NRSEU/aNf/kT/4EABT9LXK9cXFxAJ4mUlr+vdRSEU++kKqoqMB3vvMdcByHubk5nDp1CmfOnEFRUREEQUBBQQHztxgMxnOFDVkMxjNCvm0nN9ZqjsuQpcXBbzSeOlfT01F48OCfsGfPNZpIpaUNIi1tENXV59HZmQ9JEtDUtAl1ddsQFzcKnhfhdNqfJFKjGl4TD51u1ceRCkx3dw5mZmJw7Ng52GzNT/yttf1bJ0++4rV/Kz9/zd8iS4ttNn9Li2uh5GVJkgSLxRJ0txjxtzIyMmC1WnHhwgVkZmZSf4u0AdrtdsVmNH9LiwNB3BZ/iZTc3xodHaWJW1dXF4A174k0Bgb7pv9ZHCn50mLib8nTpNu3b+PmzZtITk4Gz/N0aXEohRxajq319PRgamoKX/jCF8DzPB4/fkzfI+JvlZWV0f1bHMdRRypYZb3S9UVFRQVNpHQ6HfLy8uhusPPnzyM5OZn6W2lpaTRN8vW3AP9LiwMRrCLe198ijltb29qXFQ8fPkRcXNy6NkAlQqmIV0qklPwt3zbAxsZGTUuLgdAq4vv6+jA5OYlXXnkFFRUVGBwcXFcoRMpymL/FYDCeB2zIYjCeAZJIJSYmoq+vz6vu2N9xGUB5abE36wstSCKlVF6xliZ1oKioAwsLRrS0lEGSeNTWrjXHxcaOob5+8xN/a2Hd4+W43RwcDv6JIzWn+r0gS4tJIrXmb13F3r1XMTCQDlHk0dxcjubmckREzKK83ImIiFksLRkDpGzrvayZmRl0dnZi9+7dmm6MnE4nUlNT8ed//ueYn59f1wYo3y1Fvs0PZY8UqYhXs3MpPj4eBw8exO7du/HGG28gJiYGnZ2daG5uRlRUlNf+LSWepSJeKZEKCwuDzWaDzWbz8rc++ugjer2SJKnyt+RDwrNUxCcmJq7zt1wuF5qamhATE0OLKUIZNjs6OrB9+3ZNx9aam5uRlJSEv/qrv8L09DTdv3X27FmaJvE8j6KiIpq4hTIkaKmIT05OxpEjR3DgwAG88cYbiIyMRHNzM5qammC1Wmma5K/5VGlpcTACHX+U+1uTk5M0cTt9+jSAtf+mra2tqr6QkhdyaKmIlySJ+ohyf0teKNTY2Ih79+4hPj6e/l1j/haDwdgo2JDFYDwDLS0tWFlZwcsvv4yMjAx0dXXRSmh/x2UCLy0OvOcqPb0P8fGBEymTaRGbNjVi06ZGnDz5R2hsrATHeai/RdKktTbA1XWP7+7OVVxaHIilJQNaWkoVE6k1f6sf6en9OHr0HO7fL4AkCaiv34zV1TDodKvo6cmC1Tqh4G+t97K07iMDgOHhYa+lxWazGVu2bMGWLVu8/K0PPvgAp0+fRklJCex2OyRJ0rS0GHhaEa/12Nry8jJefvllZGZmrmsDJP4Wz/N0YNFayCG/PjWJFPG3tm3bhpMnT6KhoQHLy8s4ceIEbQMkaZLSkOJvaXEgAlXE+/O3bt68CY/HA51Oh+HhYSQnJ6v67/WsjhSwlibt3LkTO3fuxPDwME2T2tvbYTQaUVZWBrvdDlEUNS0tBkKriL9//z79HGVlZSm2AZLdUsQf1VrIIb8+NYmUxWLBnj17sHv3bpw6dQoNDQ2YnZ3F7373u3XrKZQ+xxtdEa/X61FUVISioiIsLCys87cyMzMhCAJsNhtMJpPq52QwGAxf2JDFYDwDJJEiR3LUHJeZnZ1VGBICV7E/epSMR49S8NJLp1Vfm9vNoaOjCIWFHfjTP30bg4NpEEUeTqcdLpcNZvMcysud4HkR6en9IPc3wZYWK9HaWhIkkVpDr3ejuLgdxcXtGBmJx7/9298jKmrGx98SUVbmkvlbtZAPWZIkIS0tTZUHI3+Mv2Nrcn+rr6+PejdO59pRyeTkZAwODqrytzaiIp7jONoGODc3R5OSCxcueCVu09PTmpYWA08r4o8cOaL6MR6PB52dncjPz8ef/dmf4eHDh5AkibZdEn9LEASvwS0UR0rt8Ufib5WXl2N4eBg//OEPYTabqb/l2waoxLNUxCtdX1JSEqqrq+n+LVIt3tjYCGDtczQyMqLqc/usxx/JqgBBECAIAm0DlCQJNTU1OHv2LAoLCyEIAiYnJzXvIyMV8WocKTkPHjxAbm4uvvrVryqupyCfI3mapKWQg6C2It5kMqGyshKVlZUYGhrCj3/8Y4yMjFB/q7i4GDzPM3+LwWCEBBuyGIwQmZqawoMHD7B37951NxrBjsuYTCY8fvwYVusg9Pr/L4LtuXrqSDWrvr4HD0gidRYcB6SlDSAtbQBHjjz1txoaKnHv3jbEx4+A5yWUlLg0LS0mSJIAi2UC2dnqK+I7OgoB6PDnf/4W9PpVOBw8RFHAyZOf99q/lZ9/BXr9mpdFEqljx46pfh7StlZQUKDoyxA4jkNmZiYyMzNx7Ngx/OpXv8LDhw/R1dWF+/fvU3+L53m/iYTS0uJgBEqkIiIiaJok97fef/99cBwHs9mM6elpJCQkqEohQnGk5EuL5WmSfP8W8bdSUlJoOYWWpcXy69Pa/vjgwQN4PB78+Z//Od15RdoAlfwtQFshB0F+bC3Q8Ue5v3X8+HG8/fbbePjwITo6OtDe3h7U3wJAK+K1fI7m5ubQ0dGhmEiRNkCy7Jw0Jra1tYHjOJhMJiwtLcHj8agamsjxRy3XJ0+klNZTKH0hVVxcrGlpsfz6tFbE9/X1wePx4M/+7M/AcRz1t1wuF/W3BEFAWloa87cYDIYq2JDFYIQIObYW7EZDflymubkZ7777LtzuFfz2t7990gY4BZ5PR0ZGH5T+t5s4UoWFHYiI0O5IFRe3e/26r7/lcpVBkgRcvnwIly+vHe0ymxewsGCCyRTY3wK8lxZrq4gXvAo5iL/V359OGxOf+lunIQib4HQ6Q3aktNxQu91uDAwMQBAEHDlyRJW/tfaaNtaRkkP8rQMHDtBBa3l5Gb/61a8QHR3ttX9LiVAr4v0dfzQYDF7+Fknczp8/j/Pn1+r4o6Ojsby8rCrV26iK+KqqKq80ifhbFouFejcOhyOkQg61jhRBp9NhaGgIdrsdVVVV9MuWs2fPrtu/JXeT1BZyyFF7/DElJQUpKSmoqqpCU1MTTp48iaWlJfz85z9HbGwsTZPI8WZflJYWq4E4Ur6JFGkD3LRp07ovpM6cOQO3243Y2Fisrq6qSpPkS4u1fo4SEhLoEOXrbzU0NFB/i3zZYrVaVf/5DAbjswcbshiMEJEkCenp6X5lcl84jsPAgBM6nQf/2//2P2n9elNTBerqtj5pA5TA8xJiY8fp4x48yMPMTDR4fn3hhT+II1Ve7kBYmP9EymRaRGVlIyorGzExYcUvf/nnmJiw4ubN3bhzZztNk9b8Lbfin6G0tDgY/iriOQ7IyOhHRobc3+JRXx+Fu3froNPpEB8fj5UV9SkbWVqsZh8ZQb60WO5vjY2NrfO3iJuUlJQUsiOlpSKe4zi6APbv//7vMTAw4OVvkTZAu93ulbgEW1qsBDn+GOzYWmRkJLZv347t27djZGQEb7/9NsbHx3H9+nXcvXs3qL8FhOZIjYyMYGBgYN0AzXEccnNzkZubi+PHj9PdUqQNUK/XIy4uTvNNuFZHSp5I+bYBkjRJ7m+ROvhQCjlIRbza1j6dTofJyTUH8u/+7u/Q39+v6G+Vl5d77ZYKxZFaWVmB0+kMWhEv/0JqcHAQ77zzDsbHx3Ht2jXU1dXRQqFAbYC+S4vVMD4+jt7eXprWEvz5W5cvX8bly5eRlZUFQRBQVlbG/C0Gg7EONmQxGCEwNDSE4eFhvPTSSyof0QK3+3/A4UhDYWE/oqJmUVh4H4WF97G4aITLVQpJElBbewC1tQeRmdkDnhdhszXLHKn24E/zhNbWUiwvh0MQ1O/G0utXMD4ei927r6OkpJWmSS6XDRERs3T/Vlpav1fiFmhpsT/UVMTr9asoLm5DcXEb5ucFXLmyGXfu3MHIyAjefPNN5OTk0AWj/m7cnmWPlFIiFRcXhwMHDmD//v3o6+uDKIpobm6Gw+FAeHg4PB4P0tPTVR+7CrUiniRSVqsVVqsVZWVltA1QkiR89NFHdP8WOb6nZWkxIdgeKSXMZjMmJiawY8cOFBUVrfO3SArgW7whiuJzqYg3GAyw2+2w2+2YmZnB1atXce/ePYyOjuKb3/ymKn9LaWmx2utTSqSSk5O9/C1yNK2xsRFmsxlutztA8+h65BXxapEvLU5ISEBCQoJff6uoqAg8z6OwsDBkR0rL8UeO4xAbG4vJyUls27YNBQUF6/wt8jnybQMMtLTYH2qOP8r9rYmJCVy/fh0NDQ3o6elBTU0N87cYDMY62JDFYISAJEnQ6XQqjq09LbRYS6T+fF0iZTQuYtOmJmza1ITJyRjqJp0+/TmcPfsS3G4dcnO7NB3FE0UBVus4srJ6VT/maUW8iISEUaSnD+DIkXPo7CyAKApoaNiMe/e2P/G3RPC8hMVFo+qlxYRQKuLN5itYWLDBaDTir/7qr2ipyIcffoiamhqUlJSA53nk5+d7ffsfbGmxEmoq4n39rY6ODnzwwQcAgN/97ne0DdButwc8UhWKI+WvIl7eBjgyMkKTkhMnTsBgMGB1dRW5ubmabgDJYKT1+KPb7UZFRQWSkpKovyVvA7xx4wb1t+x2OxYWFkIq5NBaER8VFYWVlRUYDAZ87WtfQ0tLC/W3jEYjSktLIQgCsrOzvf7bhzJsEkcqUCIl97defvlltLa2oqZm7e/Sb3/7W6Snp9M0ibQBKhFqRbxSIkX8Lfn+LafTidbWVphMJiwvLyM7O1vzsBlqRXxFRQVSU1PX+VukDTArK4t+2TI/P696aTHB4/FAFEXk5OSoroi3Wq3gOA46nQ5f/epX4XK50NzcDJfLhYiICLp/i/lbDMZnGzZkMRgacbvdcDgcKCwsDHDjs74tUE0iZbFMYc+e69i9+zoGB1Nx8eJhdHUVoKurAN/85v+Tpknp6cr+FgBMT0fjwYNcr6XFapAkAenpfV5Li9f8rXYUFbVjYcH0xN/iaRtgTMwkOM6NwkL1KVt3dw4t5FDL0tJduFwHUF5ejqSkJCQlJWHfvn3o7++naZLT6URkZCS9wUlNTVW9tFgOcaTU3lCHhYUhISEBi4uLOHjwIMxmM20DlKdJvikIGRKCFXL4oqYiPiEhAYcOHcLBgwfR09OD2tpadHd3o7OzE2+++SZ1kwI16yktLVZ7fb6JlLwNcHZ2liYlpA2QuC1ajnQ+S0V8aWkp0tPTkZ6eTvdvKflb5PheKI4UGTbVfo7Cw8ORnp6OxcVF7N27FyaTCZIk4cyZMzh37hwKCgogCAKKioq8/K1gS4v94c+RInAcR/2t6upqdHV14dq1a+jp6UFXVxe++93vrltPoQRxpDaiIt7X3yJHd0kbIEm1ysrKVD8POf64d+9e1Y+RV8STIpijR4/i/v37kCQJ9fX1uHv3LvO3GIzPOGzIYjA08uDBA8zMzPi5eVKuYl9aCkdLSynsdimgI0VYawMcBMDBYhnH8eM1cDh4NDVtQl3dtif+lvjE35rwemygpcX+ePQo6UlFvP9EymRaQGVlAyorGzAxYYUo8rhyZT88Hh2+//1/QElJK3heQn6+f38L8F/IEYjW1iwsLy97veccxyEjIwMZGRk0TZIkCXV1dbhz5w7i4uIwNjaGrVu3avo2WRRFTY4UeQzHcaisrERUVBS2bt3q5W+9//77dP8Wz/PIy8vDw4cPNRdyaK2I5zgO2dnZMBgMiI6OxtGjR73aAP35W4D6Qg45xJEKlEhFRkZix44d2LFjBx4/fgxRFHHz5k0AwI9+9CPFNkAlNqoiXqfTBfS3kpOTMTw8jM2bNz9XR4o8huM4bN26lTpcJE2S+1tkt1RWVpampcUE+fFHNa19Op0OBQUFqK+vR0REBC3x8G0DtNlsXv4WEJprp6Yi3mKxYO/evdizZw8GBwchiiLu3bsHAPjJT35Cv2wJ5G8B3kuL1UIq4uWvSa/Xo7i4GMXFxdTfEkWR+lvZ2dk0cWP+FoPx2YANWQyGRpqamhAeHo7CwkLZrwbec9XSUvLEkVI/+ExNRaOrKw/79l31agNsaVlLk2prD6G29hCysh6C5yWUlTXDbF5QvbRYjiQJQR0pOVbrBDIz++Dx6HHo0AVMT0ejuVneBri2fystbcArcVtaMtCKeDXDpvz6LBb4TaT0ej1KSkpQUlKC+fl5NDc348aNGwCAe/fu4fHjx0H9LWD90mI1yCvi5a19cn+rt7eX7t9yOByIioqC2WxGWFiYpvTmWSvildoAlfyt8PBw1UuL5ZBhU237Y2JiIgoLC3Hjxg3s3bsX09PTNE2KiYmhaZLvwCsfNkOpiPeXSPn6Ww6HA7du3YLH40F9fT2mpqbA8zyKiooCDrlkafFGVMQnJyfjyJEjqKqqwoMHD+gx0IaGBlitVphMJs2OVKgV8SSRImnS1NQU/SLh9OnTdP8W8bfCwsLosKl1HxmgriKeNAGurq7i7t272L59O2ZmZtDY2EjbAEly6+tvBVpaHOz6AlXEy/2t8fFxOBwO3Lt3DydPnvTav5Wfn8/8LQbjUwwbshgMDSwtLaGlpQWrq6v4wQ9+AJ5PA8+fRFzcLxFoz5UkrTlSmZnq90g5HHYAnNeCX5NpEZs2NWLTpkZMTlogSXZIkoBTpz6HM2deQnb2Qzx6lIKjR7U6UnYUFNzXWBG/dvxxx47bMBhWZG2AAurrN+Pu3e1ISHgMnpdgt0uwWifR2qp92CQV8Xv29KpKpEgbYH19PZKSklBWVqbK31p7TaE7Uv5uqDmOQ1ZWFrKysmji1tTUhPb2tSTvJz/5CT1SFMwtEkUx5Ip4+Q2rbxsguVE+ceIEwsPDkZubq9jaFwgybGpxpMhrCg8Px969e2EwGHD8+PF1/lZqaip1k6KiokJypLRWxEdFRWHnzp1obm5GeHg4iouL17UB8jy/zt8CQvscBauI1+l0yM/PR35+Pl5++WW0tLRAFEU8ePAAAPDWW2+p8rfI9ZGlxWpRSqRiYmJoG6B8/1ZrayvMZjMKCgpCcqRCqYgnhRwHDx6E0Wj0agP09bdsNhtMJpPqpcVytFbEx8bGYt++fbh//z5tK3Q6nWhubqb+liAISE1NZf4Wg/Epgw1ZDIYGyIC1Z08J+vvrceXKGK5cyUNm5l+C5yXYbM0wm+e9HiNPpLT8byhxpOLjxxR/32KZxN6917Fnz3UMDqZBFHk0NGwGAFy9egBjYwngeRHp6f0Bn1e+tFgt8kSKLC3W690oLm5HcfGav9XcvLZ/69Klw7h06TCys7sxN2dGTMwEsrLUD5ukIp7nzwFYAhA8uZAvLd6+fTv27duHvr4+mibJ/S1BEOiRLjVLi30hjpSaRIokDqurq2hvb8f27dvR39+PCxcurNu/5ZvQkEKOUCriAyVScn+LuEkkSbh16xZmZ2chCELQROtZK+JJMiT3t2ZmZmjidu7cOZw/fx75+fmYmZlBVFRUSIUcWm6o5UuLd+3a5bV/i7QBWiwWOiQnJCSoXlrsi5aK+PDwcAiCAIPBgAcPHqCyshL9/f3U3yJpkq+/BQReWhzs+vwlUhzHITU1FampqdTfIq4kANTX12NlZSWovwWEXhHvm0j5tgESD5D4W8XFxZiamkJERISmpcWkIl7L54hUxB8+fBh79uxR9LcSEhLo50htAQeDwfhkw4YsxnPF43Fj6dEFzDnexMpUG+AB9NH5iLD/I4ypL4HjXqyjEpJ0C1brEg4d+jI4zkPbACWJx+nTf4SzZ4+hqKgdPC+hsLADev2qYiIVjKGhZAwPJ+P48dNBf3bN3xpASsogmpttSE4egtU6iYaGSty7t+1JG+Da/i2rdULhNYXiSAVOpEymBWze3IDNmxswPm594pNVYHw8DjrdKt5993XwvIj8/M6A/haw1pS4VhHfB6AOwK6g1+d7bE2pDVCSJNy7dw937txBYmIiMjMzn7sjJb8+i8WCo0ePguM4jI6OrvO3yG6p3Nxc6HS6kBwpLRXxHMchJycH2dnZ6OzshNlshsViof6WvA1QaZmxmkIOX4IlUlFRUev8LUmSMD09Db1ej5MnT6ryt8j1yZcWq8E3kZK3Acr9revXr+PatWtIS0tDZmbmMzlSoVTEv/zyy3TxMUmT2traYDKZ6P6tzMxMcBwXkiMlr4gP9j4Tfys/Px99fX0ICwtDdHS0Kn8LwDNVxPt7TVardZ2/5XA4MD8/j7CwMJw9exaCIKhqAyRLi1NTU1Vfn2/7o6+/RVYvXLp0CZcuXVK1noLBYHzyYUMW47mxPOnA+MU/Ajc8gch3pxHV6QE8wHJOF2Zev4OplEhYD72P8LhtH/elqqAFU1P/80kidZO29snbAIeGUiGKPJxOO1paymA2z8Fma0ZnZz7S0vwnUkoQR8pmU+dIAWtLi2dno3H8+BmUlbmwsGB80gYo4PLlQ7h8mfhbImw2F0ymBbq02G4PxZFSl0jFxk5g376rCAtbxkcfHYXN1oz79wtk/pYDgiAhNXVgXeJGCjmeVsTXItiQRdof/SVSSv6WJEloaGgAANTV1WFlZUVVKcBGVcTHx8fj4MGDOHDgAHp7eyGKIj3qFB0djfLycnR0dIRcyKHWkQJACzmqqqpgt9u9/C3SBpifn0/9LYPBoJhIqYG8PjWJVGJiIqqqqhAVFUXTGt82QJ7nFd8ff0uLAxGsIj48PJwmD9PT0/Q9unPnDoC15Iw4d75pki8bVRFP2gD9+Vs8z6OtrS1kR0rL8ce+vj5MTEzg1VdfhSAImJycpGkS8bfk+7f0er3mQg759ampiCf+VlpaGuLj43HmzBlkZWWhoaGB+luB2gD9LS0OBPkc+auIN5lM2Lx5MzZv3ozx8XH6ZcuHH37oVZbD/C0G48WDDVmM58LypANjZ/ci5ntTMF33QP4/R4ZuIKJ2CgtbpjC+ehixVRcQHr/947rUIDwttHA4dgHIX7fnClhLk1JTB5GaOogjRz5CZ2ceJElAY+MmrK6GYXHRiCtX9j9pAxwP+Ixutw4Ohx2FhR2IiJgP+LNyfCviTaZFVFY2orKyERMTFpq4nTr1Cs6cOY7i4jbExExieTlcU8r21JG6rqki3uFYK+R47bX3sLqqf+Jv8aiv34K7d3c88bdE8LwDFsvkk9fkW8hRC+CfAz5Pd3c3pqenVaU3xN8SBAH/8i//gvj4eExNTeGDDz5Yd4OjdLRqoyvi5f7WSy+9hPb2dnrj7na7ERUVhZs3byq2AfoiX1qslDz5w3dpsa+/RVKA9957D+Hh4SgtLUVMTEzIjpTWiniHw4GUlBR86UtfwvLy8ro2QOJv2e12OmSH6kiprYiPjo7Gzp07sXXrVvyv//W/YLVa8ejRI7zzzjvU3xIEAVlZWYo358EKOZQIdPxRyd+SJAlXr14FsNbMV1dXB5vNFtTfki8t1upIyY8/WiwWL3+L7N9qaWmB2WyGzWaDxWLRXMgRakW80+lEYmIivvrVr3rt3yJtgFlZWRAEwasNUEshB6G/vx9jY2PYs2dP0J+NjY3F/v37sXv3brzxxhuIjIxEV1cX9bfIFwnM32IwXgzYkMXYcDweN8Yvfg7R35+C+br/m3BTHYA3ZjCu/xySXusHp1P/Dfjzx7st0ONZG2IyMnqDJlI6nRuFhfdRWHgfNTUvoa5uKxISRlBbexC1tQeRmdnzJE1aawP0pasrFzMz0ZoGn6cV8cqJlNU6ib17r2HPnmsYGEiDJAlwOssxNxcJjnOjubkcYWGrSEsL7G8BTyvitVzfo0dJGBpKpRXxev0qiovbUFzchvl5E1wuGySJx6VLVbh0qQo5OQ9gt0uQJLvP0uIbCOZlSZIEo9GIoqIi1dfX2tqK5eVlHD16FNnZ2ejr61u3f4vc4KSkpIDjOFVLi/1dn5pEitRKl5WV4cyZM7h79y6io6NpG2Bubi4EQaBtgL74W1ociOXlZbS0tPg9/piQkIDDhw/T3VKiKKKlpQWLi4vgOA6dnZ2IiopS1UgYqiMlr4j3bQP09bcKCgrA8zxEUQypkENrRXx7ezv9HOXm5q7zt6xWK21MjI+PB7A2bAZbWqwEOf4YrCKe+FuCIODs2bO4c+cOwsLCUFNTQ9sABUGgbYC++FtaHAi5I+X72ZT7W0eOHEFnZyckSUJTUxNWVlbAcRz6+voQHx+/rg1QiVA+R2NjY16FHL7+FkmTTp48iZqaGhQXF8Nut6OpqUnT0mLg6fFHLRXx9+/fx+LiIl5//XXk5eWtW0/B/C0G48WADVmMDWdp+CK4x+MwXw2ecpjqgJm+RSwMfAhzxut/gKsLhnIV+6NHKaodKYLbrUNLSxmKitrxp3/6G682wNOnP4ezZ1964m+JKCy8D71+FcBaemMyzQdcWrzuqmlFfODBh+OA9PQBpKcPYOfOm/jOd/4r4uNHfPyttTRJyd8i1+e7tDgYgSrizeYFbN5cj82b6zE+boUk8ZAkASdPfh4AMDc3gY6OQuTnd0Knm0MgL2tpaQkulwvl5eWaj62RRMqfv3X37l3cvn0biYmJ4Hkey8vLmpYWA08dqWPHjql+jMfjQWtrKwoLC/GVr3zFy986ceIETQvk/hZ5TVodKaU9UkoQfysnJwf79+/Hd77zHVitVty6dUuVv0WubyMr4uX+1vDwMD0q9+677wJYSwm6u7sV2wB9kS8tDrUiPpi/lZ6eDp7nsbS0FJIjFUpFfFtbG/Ly8vDVr36V7t9yOp3U3yL7t4i/RV6T2kIOAnGkgn2OdDodCgsLUVhYiPHxcXz3u9/18rdIG2BZWZmiv0Wuz3dpcTACHX+0Wq3Yt28f9u7di4GBAfpli8vlArD2Oerv71flb21ERbxOp/M63kwSN+ZvMRiffNiQxdhw5hzfQcR701D73X7ku1OYL/r2xzxkBd5zJYq8ZkfKN5HybgNMpWnSU3/LibIyF1paSiAIEsLCVlU/VygV8S6XDYAOf/qnv0Vk5OwTf4vH5cuHcfnyWhsg2b9lMi0CAB49Sg66tNgXLRXxsbET2L//Kvbtu4pf//or6OrKw+hoAn796z9DZOTMk/1bl5GaulPxBockUlr3SPlLpIiAX1pairm5OepvXbx4EcBaStDf34+YmBhVNzihOFK+FfFK/ha5rujoaNjtdpSVlYVUyCFJkuaK+La2NgDAn/7pnyIyMpJ6N/78LUDd0mJf5McfgyVSSUlJqKqqwqFDh/D222+js7MTg4OD+MUvfkH9LUEQkJCQ4Pc1bYQjRfD1t8h7dObMGfr7o6OjiI+PD+pvAU8/R1qOP8qXFnMcR/0t0gZIBvf6+nrExsbCbrfDZrOFPCRorYi/f/8+PB4PvvzlL8NsNsPhcEAURdoG6OtvAeqWFvsib38MlAJxHIf09HSkp6fj6NGj+M1vfoPOzk709PTgJz/5SVB/C8CGV8Sbzeag/pYgCH6PNzMYjD8sbMhibDgrk+2IvK/e1TF0AtOznc/xigIReLgC1hIpp9OOoqJ2jY6UciK11gY4iLS0QVRXn0dnZz4kSUBT0ybU1W178pwcxsetiI2dCPo8oVfEey8trqxsQGVlAyYmrDRxO3nyFdTUHEdJSSt4XkJXV46mpcUA0N29VhF/7Jj6ivjlZQMePsyBIIh4+eUadHSs7d+qq9uCO3dWkJDwfcXjMqE4Ug6HQ1VrX0REBLZu3YqtW7eio6MDv/71r6HX66m/RdKkvLw8xRsc+dLijaiI9+dvkTZAYK3kY3p6WtUxOfnS4mepiJe3AZKbQOJvkd1SnZ2dmoeEUCriV1dX0dvbC57n8fLLL6/zt9LS0uhuKfl/k2dxpIJ9jqKjo7Fr1y7s2rULra2t+O1vfwsA+P3vfw+j0UjTJH/+ltyRCuX4o28iRdoACwoKsLi46OVvEYfLZDJhfn7eb5okR760ONSKeI7jqL81ODhIj1wSf6u8vBw8z6OjowOANkcqlIp4YM2tstlsePnll+FyuSCKIvW3srOzaZpE/C3ymgItLVZCbUU88bf27duHlpYW/P73v0d7ezuam5vXradg/haD8fHAhizGc0D9gBXKj28MwYcrwtNESv0C3aWlcLS2loDnAydSer0bRUUdKCrqwMKCET/96dcxMRGLxsbNaGzc/KQNcC1NUvK3AOWlxcF4mkitP/5otU5g375r2Lt3zd8SRQHNzeVobi4Hx7lhsUxifNwKs3lO1VDnW8ihhtbWUloRr9evoqSkDSUla/5Wc/MmSNLX1x2XyczMRFdXV0iOVFpamt9UQ4mHDx+C4zj8l//yXzA2Nkb3bzkcDkRFRdEbHHLDCARfWqyE2op4ub81OzuLn//85xgbG0N9fT0aGhqQl5dH0yR/x98CFXL44/Hjx34TqcTExHX+FmkD5DgOFosF8/Pzqks5fAs51CBv7fP1t0iadPbsWZw7dw4FBQUQBAHp6emalhYTQqmIHxgYoJ8jshRa3gbo628BwZcWK6H2+KPRaERFRQUqKiowNTWFX/7ylxgbG8O9e/dQX1/vlSb5S9w2siJe3gZYXV1N/a3Gxkbcu3cPOp0OVqsVq6vqU/9QK+JJIiX3t8bHx+nn6OTJk3T/Fs/zSEtL07S0mECOP6qtiOc4Do8fPwYA/O3f/i09Kkv8LXK82W63M3+LwfgDw4YsxoYTFlOAlZz7CO9S9/PLuYDenPNcr+kp6ocrAkmkCgu1OFKlmlv7lpaMGBlJxL59V7BpU6OsDfBzOHNmzd8SBBEFBU/9LXJ9gZYWK0GOP5aXN/v9Gbm/dfToOVy/vge1tYcwNRWDn/zkb2T+lgSrddLPa1pbWqy9Ip5XrIg3mxewZcstbNnyBsbHX/M6LqPT6eDxeGC1WuF2u1Xd2MiXFqtFnkhFRUUhKioKWVlZiv5WUlISvcEhhRxqlhYTQqmI93g8GB0dxa5du1BRUUFv3Im/RdKknJwcr/eIFHJocaTUtPbJ/a3jx4/j+vXruHr1KiYnJ/H973+ftgGWl5f7HbhIIcdGVcRHRUVh586d2LlzJ4aHh2ljYkdHB8LCwuB2u+liYTUDu3xpsVrkFfEWiwUWi2VdG6Cvv1VeXh6SI9Xe3q65tS8sLAxjY2PYunUrBEGgn6PW1lbqbwmCgIyMDK/3iCRSG+VIEfR6PYqKilBUVISFhQWaRk5MTOBf//Vfqb9ls9m80iQ5SkuL1SCKomIiFRsbu87fcjqdaG5uRnh4OFZXV5GWlqb6cyRfWhxKRXxcXBzi4uLWrae4ePEiLl68iJycHAiCoLkin8FghAYbshgbjrn8HzH9+k2YL02p8rLmXo9BhPDfnvNVaR+uAGBxMRwuVynS0wewvByOsDB1xwUliUds7BgyM3tVP9fTREryagMcHExbt39rzU0SodevYHg4WTGR8seaI8U/qYgP7EgR9Ho3xsbiYTQu4B/+4btoayt+sn9L7m+JKCtzUX8LeJpIhVYRfy1ARXwtYmN30eMyfX19ePvtt7GwsIBTp07h8uXLqo7LbIQjRfDnb124cAEXLlyghRoej/rP37NUxBPn6NChQzh48CB6enpomiSKIvW3BEEAx3GqlxYTQqmINxgMmJ6eRnh4OP72b/8WbW1tXm2A+fn5EAQBxcXFXsNUKI4UqYgPlkglJSWhuroahw8fRnd3N9555x2srq7iww8/xJUrV4L6W8DGVsTL2wB9/a1z584BADIzMzWnI1FRUZqOP5JEqqKiAikpKUhNTfXyt0RRpP4WObrr8XhoIqUW8jnKy8tTXRFPji+GhYXhP//n/0w/R8TfImlSQUGB124ptYUccogjtXXrVr/vua+/df/+fXzwwQcAgBMnTuDatWv0yxZ//hYQ2j4yfxXxZD3Fli1baNouSZLq9RQMBuPZYUMWY8MxphzFVHI0FnZMwXw78M8u8sBKVhhM6V94TlcT2nBFH91SitVVA3p6svHGG/+7rA2ww+8xwKeO1BXVjpS/ivg1f2sAaWkDOHLkPDo713ZLkTZAk2keHOdGRkaf6tf04EFeCMcfny4tjoqaxebNDdi8uQHj41aauJ08+Xm6f4vnReTnd0KSeFit48jK0jZsejw6CEKg66sF2ZfFcRzCw8MxPz+PI0eOIDY2VtVxGbK0uLCwUJMjJYpi0ERK7m+Njo7iwoULaG1tRU9PD9544w0qqMvbAH3ZyIp4juOQnZ2N7OxsHD9+nN6UEn+LvH4tN+GhOFLy44+xsbFe/hZJk959910vfysnJyekQg61jhRBp9MhJiYG8/PzOHToECwWiyp/Sz4kbHRFvNzfGhoawuXLl9He3o6HDx/im9/8Jt2/JW8D9CVQIUcg5I4UwZ+/RdoAyZBUWFio+nlIRfz+/ftVP0a+tDgpKQlJSUnYs2cPBgcHaZrkcrmovyUIAtLS0kJ2pLR8jvR6PZKSkjA/P499+/YhJibGqw0wOzub7t+Sp0kejweiKD6Xivi4uDgcOHAA+/fvR19fH65cueK1noL5WwzG84ENWYwNh+N0iD30AcZWDoL71jRMd5V/bpEHJv6PSMQeeB+cTn1NsjqebbgirLX2jeGLX/wdHA4BDocdra2lMJnmYbM5IQgSMjJ6vYYph4MHSaTU8rQi/pTfn1nzt9pRVNSOhQUjmpttqKk5Do9Hh3//92888bdE2GwumEzK/tbaawrdkfJNpGJjJ7Bv31Xs3XsV/f3ptDGxubkcZvMc5ufNqKhogJb/Bk+PPwaqiPfelyVJEnQ6HXieR2RkpN/jMrm5ueB5HqWlpejv71e9tJgQbI+UEvHx8VhZWUFMTAxee23tiKPL5aL+lnz/lhxSyKHlW/fh4eGgiVRYWBhsNhtsNhtmZ2fhdDpx/vx5AMCPfvQj5OXl0f1bgV5jKI6Uv0QqMTERVVVVNE0i71FTUxOio6MxPT2NTZs2aR4StFbEk0SqoqIC0dHRtA2Q7N86e/as1/6t4uJi9Pf3Y2JiAgcPHlT9PMSRKisrU10RTz4fUVFReOWVV+B0Or38LZImyf0tILQ9Uv4cKTlyf2tychIOhwOXL18GAPz4xz9GYWFhUH8L2LiKeLm/Jd+/1dDQgHv37iE2NhYTExMQBCEkRyqU44+bN29GTEyMYhsg2b9F0qSBgQGMj49j7969qp9Ha0U8SdPDw8NhMpnw8ssvw+l04t69e15fSPE8r2nxNIPBUIYNWYzngiF2M2KrL2FC/0eYGZhHxDtTMHQBnAdYzgHmXovBSpYBsQdOIDxR/f+oBGdjhisAmJqKwYMHudi//wrS0oaQljaE6uqP0NWVB1EUIIoVqK/fitjYMfC8BJ4XERs7rphIBeNpRbx/R0qOybQIi2USbncYjh8/ifn5CEiSgFOnXvFKk9b8LTd93NOlxZImR0oUhYCJFMcBGRn9yMjox9Gj53D/fgEuXTqI+fkINDVtRl9f1pP3SILFouxvAVoq4p/uyyKJlG9rX7DjMlFRUQgLC0NBQYHq9yEUR0qeSJE0Sd4GeOfOHdy6dYv6WzzPIzo6mhZyBFtaLEfrsbXIyEgkJSXB7XajuroaCwsLXm2ApDHR199SW8ihdH2BEimO45Cbm4vc3Fy6W+rq1auYnp5GY2MjhoaGaCoZKH0MtSKeOFLyRCo6Opr6W48ePaJuUnt7O4xGI6KioqDX6zW5ds9y/HH79u10t5Tc3yJtgBkZGdRNioiIeG6OlByLxYKsrCy43W4cOHAA8/PzcDqdaG1thdlspo2Jvv5WoKXFwa4vUEW8r7/lcrlw48YNeDweNDU1YWxsjKZJ/vwtYP3SYjXIK+Llg4q8DbC/v582JjY3NyMiIoJ+jkIt5FALOf64efNm+mVLsC+kmL/FYIQGG7IYz43wuC1IfK0Pi4OnMFf4JmZm7gPwQB+Rgwj+v8KU/gVwOvU3aIHZuOGKIHekCDqdGwUF91FQcB+Li0a0tJRCknhcubIfV64cQHLyEIaHk1FVdU7187jdOjgcfMgV8Zs2NSEsbJW2AZI0yeWyISJiliZuaWn9sqXF6lO26eloPHiQG8SReopev4ri4jZcvnwQqan92Ly5HpIk4NKlw7h06TBych48aUx0wWhc9Hrs00IONRXxtQB2obu7O2gi5XtcprGxEY2NjQCA7373u15pUqCbqY2qiJe3Ac7NzdGk5MKFC7h48SLS09MxNDQUktsSakX81q1bYTAYcPDgQTx8+JCmSb7+VlJSEtra2rC0tBTSkKC2Ip60Ad66dQuJiYmorKyEKIrU35KnSb6DXiiuHTn+6OtIyUlOTvbyt5qamuBwOAAAP/jBD+iQHKyp0l8hRyCUjq3J/a2pqSnqb9XU1ODs2bPIzs5Gf3+/piOd8mFTS5pBEqmdO3ciPDzcK01qampCXV0d4uLi6N+1uLi4kAo5tFbEkzZA8vedlHicPHnSK03y9bfIawK0OVJ9fX0YGxvzm0hxHIeMjAxkZGTg6NGj6OjogCiKaG1tBQD89Kc/VVxPoUQoxx9dLhdWV1e9PkfBvpAKtp6CwWAow4YsxnOF04XBlP4qTOmvPqdn2PjhClhzpERRQEZGL+LilBMpo3ERFRVNqKhowuRkDBwOHjdv7gIAXL58+El6E9jfAoCurjzMzkaFVBG/lkit/dnyNsAjR86hs7MAoiigoWEz7t3bjvj4EbjdHKKjJzUtLVbnSHkjr4iX+1uSxEOSBHz44edRU7OWuAnCmr8FeOB0qltavEYtgH9W5UgRyHGZ8fFxNDY24sCBAxgaGqJtgIGOyzyLIxWoIj4iIgLbtm3Dtm3bMDo6StMtALhy5QqGh4fB83xAfwvYuIp4eRug0v6tlJQUrKysICoqSrMjpWYfmZzHjx9jcHAQR44cof4Wqagm/pbRaERpaSkEQaDDbyiOFBkS1Bx/1Ol0yMvLw/z8PBwOB3bv3o2hoSHFNsCIiAivx6ot5FC6vkAV8TExMdi9ezd27dqFR48e0WIKALSFj6w6CPT5lS8tVovckSKJlE6no4kb8bdEUaT+VmZmJpaWlhAZGalpaXEoFfHypcV79uyhbYAkTXK5XIiIiKCNiWlpaQBAEyktjpQkSaor4vV6Pf28tba2Ytu2bRgaGlq3nsLX3wICLy0Odn0JCQl+K+J9v5ASRZH+ffO3noLBYCjDhizGC8rzGa4IQ0MpePw4KaAjJcdimcKuXTdx+/Z25OQ8QHLyEJzONX/LbJ6DzdYMnheRkdG3rgxDkviQK+IFQbm1z9vfMsHlKkNDwyb092cCAH7xi/9E92/J2wCV8F1arAalivjY2Ans338V+/ZdRX9/BkSRp/u3IiNnkJnZg+npGBw9qnZp8Q0sLc2gpaUF5eXlAb2P9a9pLZHat28fOI6jx2VEUfR7XEbt0mI5Wivi4+PjsX//fjQ0NCAxMRFJSUn0GE90dLTXDY7Sa1JaWhyIYImUwWBY5281NjZiZGQEAPDrX/+a7t8KdmxQFMV1hRzBUDr+mJSUhKqqKrp/S+5vkWNrz1LIofXYWnR0NA4dOgSdTqfYBihP3MLCwkJypLRUxHMch5SUFCQnJ9PlvYmJiZAkibYBklQyLi5u3eP9LS0ORLBESsnfampqwujoKDiOwzvvvEP9Ld80yRelQo5gkESKXJ+8DZAkbqIoUn8rPj4e2dnZmpcWa3Wk5NcXGRmJo0ePQqfTKfpbvm2AZGmxln+PxsfH0dPTg0OHDgUdkMgXUhkZGejq6kJYWBji4+MV11Mwf4vBUIYNWYwXjOc7XBEkSdDkSAEkkYrGyy/XoLS0BUeOfITOzjxIkoCmpgrU1W1FXNwo7HYJgiAhNnYci4trjpQgiAHTLl9EUVBdEW8yLaCysgHz8yb092dix46b6OgowsmTr9A0ScnfAgIvLfaH283B6bT7rYhf87f6kJHRh2PHzqGjowCSJKC1de0b3dragxgbiwPPOwL6W8AcWlvPYXl5WdONxvT0NLq6urBnzx56o6HmuExfXx9SU1M1LS0mhRxaK+JnZmZw9OhRlJeXK/pbycnJ9AYnOjr6uTlSciIjI7F9+3Z4PB6cO3cOlZWV6OzspP6WvA3Q9waOJFIbWRGv0+nW+VvkG3cAuHXrFubm5ta1ASohX1qsFqVESt4GSNIkub9ls9nw8OHDkIaEUCviDx48CEEQvNoAff2t8vJymM1mxURK7fWprYi3WCzYs2cPwsPDcebMGdhsNjx48IAOhCRNSk9PX/c5UlPI4Ys/R4qg5G+RwgwAaGhogNvtDupvAU8dKS3/Hs3Pz6Otrc2rIt7X3xJFcV0bYHd3NxISEkJy7bR8zvv7+zE+Po7Pfe5zqKysVFxPkZubS/dvafncMBifdtiQxXhB+MMMVwBxpOwhOFLeiZRO50Zh4X0UFq75Wy5XKSRJwJUrB3DlykFkZvYgLm4UKysGv4mUEqSQQ0tF/Nr1rbX2HT16HkeOnMfAQDpNk4i/RfZvpaUNgOPULS325cGDXExPx4DngydSev0qSkrakJf3AP/yL/87UlMHAXC4dKnqib9F9m+1rPO31l5TM00v1EKOrfm70ZAfl+nt7aVHihYXF2E0GnHu3DlVx2XcbjckSQrJkZIff5T7W7Ozs/QG56OPPqI3OHFxcSEVcmhxpOTXl5qais997nPweDzr0qSYmBjq3ZBmPzIkhOJIqUmkiL9VUlKCN954AwkJCXC73Th79ixNkwRBQFFRkeIQGoojFSyRSk5OxpEjR1BVVYUHDx7QwX1lZQUmkwmXLl2CIAjr2gB98VfIEQzf1j55mqTkbxUVFSE2NlbzsBlqRbzD4UBSUhJef/11uN1uRX+LHN2NjY2lrwnQ5kiRing1iRTxt3iex7/8y7/AarVibm4OJ0+e9Nq/lZ+fr5i4kURqo44/yv0t+bLze/fuwe12IzIyEjdu3Fi3nkIJ+dLiUI4/kop43/UU5IuN999/32v/FvO3GAw2ZDE+8fzhhivCU0dK/eDzNJFqUkykjMZFbNrUhE2bnvpbaw2FmwB4cPPmTghCJAoLO6DXB060lAo5gjE0lPykIn4tkVrzt/qRnv60DVCSBNTXb8bdu2v+lt0uQRQFTUuLgaeFHFoq4ltaSrCyEo7Dhy8iO7sH4+OxT/wtHh9++Cpqal5GSUkreF5Cfn4ndDr3k6XFbuzZw2+oI0XgOA5ZWVnIysqCwWDAnTt3kJmZqfq4jJpCDl9IRbzNZlMcBiIjI6m/NTIyQm9wurq6AACNjY1YXV0N6m8Bz+ZIkdfk62+R/Vs3b97EjRs3kJqaCrvdDlEUNS0tBkKviF9aWsLhw4eRl5eH4eFhmiZ1dHTAaDTSxC07Oxscx2F2dhYdHR3YuXPnhjpSBJ1Oh/z8fPr6b968ieTkZFX+FuB/aXEggiVSSv6Ww+Gg5QstLS0IDw9f1waoRCiOlDyRAtb7WyRNqq2tRW1tLbKysujnKJRCDrWOFKGjowNLS0uoqqpCQUEBBgYGaJpE2gDLy8vB8zzS0tLokeNgS4v9XZ+ainjib5WUlOCjjz7CzZs3YbFY6PHmQP4W4H9pcSBWV1fhdDpRXFysmOLFx8fj4MGDOHDgAP1Cqrm5GQ6HAxEREeB5nu7fYjA+i7Ahi/EJ5Q8/XBFEUXiSSHWofkxLS+mTRCr44GOxTGHPnuuw2yW8+eY/IT29H729WWhtLXvib621Aaanr/e3/C0tDsbT44/rW/v0ejeKi9tRXLzmbzU3l0GSBNTWrt3UjY3F4f/P3p8HRXLf6d7ok1VALew7FPu+FGQ2DU1vLN3Qe0tqWd49Hns84/Gc8RyNPe85b9xz50a8cyNuxPueE0eyNLYsWbYs2RpbGsnaeqcXoKFXuqEhs6DYodn3fSvWun8UvySryKrKLJCtpZ6IEyfGaqis6mzI7+/5Pp/n8eMcZGYanea3XEXEW/rIthDxgYFTKC6uQlFR1WZ+i0FTkx6Njdnw9p5HVpYBgBlmMwWalv7wNDIyIisjBVgcqaamJqSkpODb3/626LpMYmIin98iD7XEkUpNTZX8WgQRL8VJCAkJQUlJCfbt24ef/exnCA8P54ccQgOkadruECBWWuxMjqh9np6eyMrKQlZWFp/f4jiO7+DSarUwGAyS8ls7WX8UOlJhYWFWNEDiStbX18Pf3593ROQOm64i4puampCUlITvfve7ovkt0i2VmprKZwyllBbbSioinuS3IiIicPjwYfzsZz9DcHAwD80IDAzk3SSx/BYgfdi0/RpA3JFSqVTIyclBTk4OZmZmeAfw8mXLAZG3tzdaWlok5beEw6YrGamkpCSr/NbJkyfR0dHB59sePnyIkJAQ0DQNs9mM9fV1WS6gq4j45uZmxMfH4/vf/77VerO9/BYgrbTYVlIR8cIDqSNHjuCll16Cl5eXO7/l1pde7iHLrc+Y/nLDFWBxpFpa0u06UvbEcZaMVHS084wUEXGknnvuI/j7T6OrKwkcR6OhIQe1tfkICprgu6UCA6cACEuL5WSkLOuPFkfK8fqjWm3iaYDvvfdNdHQkY31diYsXzwn6tzgkJW3PbwHYESK+sHA7It46v1WG9vYUcByN2tp9WF/3gIfHKlpaKpCd/ZSkFRhXM1JCR0psXYbjOKt1Gb1eD6PRiKysLNlDglxEfGOjZXD+6le/isDAQH7QIjRA2/wW8OlkpIQi+a39+/fjvffeQ1tbG5aWliTltwDnQA4xCRHxtk4CoQEmJiZa5bdId5Knpye6u7vh7e0tabVzJ+uPxJES5reGh4d5V7K1tRVqtRqZmZnIyspCU1OTy0AOKRkpIqPRCLPZzN9HJL8lpAGS/i2NRgNgy5GSQ7SUg4j39/dHYWEhCgoK8P7776OtrQ3T09N47733oNFoeDdJLL8FiJcWO5MjRDzpQ0tLS4PJZOIPWyoqKgBYDhqGhoYQFBQkaahzJSPV399vVVpsSwMkBwnC/FZ2djYaGxtdAnJotVpZiPjW1lZsbGzg61//OgICAiQdSLnl1hdV7iHLrc+I/rLDFX8VzZlYW/PEwoIP+vpiEB3d5zT3JCwtlrq1ZnGkrBHxKSntSElph8mkQnNzJjiOxq1bR3Hr1lHExvaApjkMD4fZdaTsqasrAfPzvrLWH1dWvNDZmQSaZvHUU5cwMBAF0r/V1JS1md8ygGE4REYO8u+bOFKuIOKdXZ8lv9WC9PQW9PTE4ne/+1v4+MyhvLwD5eUvOy3PtFda7EyOHClH6zIAsLKyguHhYUnrMnNzcy4j4oWOlJAGSIiJJL9FHnCGhoZkgxRcRcR3dXWBpmk888wz6OnpAcuy2/JbDMNYOWpygBxEhP7o7IHVy8uLd2d6enrwu9/9Dmq1GmVlZdv6t8SIlTvNSIk5UsRNEua3DAYDD1/Y2NjAxMSE0/wWYF1a7Mr6I7lXhfktoZtUVlbGO26Dg4Oy7yNXEPHr6+t48uQJ9Ho9zp07x+e36uvreRogcW5Jfou8J1czUs7uI7VajdzcXOTm5qK7uxtvv/02PD09Jee3nAE57Mk2I0VEaIAxMTF8/xbJb5FKCA8PD8zOzkp6PWFpsTPH0Pb6CCKeoiiHB1Kkf0vKerNbbn0e5R6y3PoL67MxXBFxHA2VyoSOjmS0tGQgMHASNM2CpjkEBU3Z+RpXMlIWRPzZs9sR8Wr1MnJy6pGTU4+ZGX9wXDY4jsGlS08DMMPXdw59fbGbNEDnbpurGSniSFncpAFERwvzWzTq6vLw8OEBhISMgaY5JCZ2ChwpyS+FLUS89PXH1tY0KBTr+Pu/fwMmUyk47v+wogGKrcu4kpFaWVmR5EgJ12VOnTqF3/72txgfH0dzczOampr4dRmapu0+mLuSkXKEiBfLb3Ech48//hiAxUkZGRlBfHy8pAecnSLihfmtM2fOiOa3SGDeVSBHREQED9uQoo6ODlAUhb//+7/H4uIiP9wQGmBmZiYYhkFsbCx/La5kpKQi4oX5rbNnz+Ktt97C2NgYDAYDDAYDTwPU6/Wi+S3AtYyUI0S8n58fCgoK+C4wlmXR2NiIlpYWUBQFX19fTE9Pw8fHR9Lf104R8fZogML8Fnlwl1NaTCQ1IyVUT08PAOBHP/oR5ubmeDdJmN9iGIYfPIAtR+rTQMSTDFpGRgaWlpbw9ttvY3R0FA0NDWhoaHB6IAWIlxY7kyNEvO2BFDlsIYMwyW/JWTt1y63PutxDllt/IX22hitA6EjdwsGDD9DcnAGOo61ogDTNQa9vgkZjWbsTc6SkiOMYKJVrThHx/v4zKCy8g4KCO3j4MB9lZWewsuKF//zPb0OjWeRpgFFRA6KDDSktpmlO9vqjmCOlVK4jLa0VaWmtWFpSw2jUg+NoVFSUoqLCQoHz8FjF8rJKlAZoq+Fh1xHxpLRYqy3HkSMfWJVnCnHH5IRbTmkxUUtLC1ZXV2Wt8ywtLWFkZAQFBQU4cOAAn026efPmtv4t4QO3VCCHUFLX1kh+6+jRo6ipqcG1a9ewtLSE//iP/+DzWwzD2B1QdhsRL8xvzc/P85/RtWvXQFEUzGYztFotVldXJb2esLRYqoTrj76+vvD19XWY3yJDsisZKVcQ8aurqxgdHcWBAwewf//+bTRAsfwW4HpGypkjRVEUIiMjERkZiRMnTuDBgwe4ceMGFhYW8OabbyIoKIj/t2Yvv7VTRLytI0VogHv37sX09DT/GV26dAkKhQIbGxvw9/fH+vq6JDdGWFrsCiLe398f/v7+iI6OdpjfIveRK0AOKRkpW42NjWHfvn3Iz8/nD1uE9RRiNECWZR2WFotJyvqj8EDq9OnTuH//PioqKvDgwQPRegq33Po8yz1kufVn1mdvuCISOlIq1TL27GnAnj2EBmhxky5ffgplZaeQmtoGmubg4zNr15GyJ2FGigxrzkRRwMBANNTqJfz0pz9DT088OI7B48d78ehRPk8DtOS3pvmvI6XFclYFZ2d90dWViKKiaoeOlEZjQm5uHXJz6zA1FYDf/vbvsLysRkXFMVRXF/P9W0lJnaL5LWALyOEKIn6rtHgRQC0o6hC/LiPEHZPwNQDodDosLi5KXs9xNSNF1ta0Wi3vJjlal/H29nYJyCEXEU9RFEZGRuDl5YWf/OQn/GoayW9FRETwDzjC3JUrGSmpiHgfHx8cOHAABw4cwNjYGH7/+99jaWkJN27cQHV1NTIyMsAwDE8DFJMrPVL2EPH28luEBkhRFHQ6HdbW1iQPCjtFxBMaIHGTbPNber0eNE1Do9FILi0mIsNmQkKC5IdahUKBiYkJeHp64vnnn+fLfB3ltwDXhk2piPiAgAA+vzU0NIR3330XCwsLuHbtGqqrq3k3idAAxbSTjJStIyXMby0tLfGuTUVFBSoqKqBQKGQNMIBl8CFADqkipcVk+BXmt8iBlMFgsDqQUqlU6Ovrk1RaTOQKIt7DwwNzc3Pw8PDAj3/8Y/5ntrCewp3fcuvzLPeQ5dafSZ/d4QrYcqQs3VXWa4EWGuBdHD58F8PDkWBZGo2N2WhuzoSHxyooagMBAVMwmyFpTa6zcyeIeBYq1SpSU9uRmmrJbxmNWzTAW7dKNvNbLPR6IziOllxaTLSFiJdzfSosLPji9OnL0OmG+P4tkt/KzjaApllERg7xn9HGBiUAcshDxKtUJqSlCdcfbwE4xP9ftusy169fR0NDAwYHB/HSSy9JWpcRKy2Wdn3ijpTYugwJhZMHCDnuA1l/lOPeCB0prVZrld8S0gBv3LiBpKQk0DSN9PR0sCwrOyPlyvojYMkUnThxAhERERD2bxEaIE3TVvktOUAOoaQg4oX5rbm5Ody8eRMcx2FgYAAvvvii0/wWeT+uIuIjIiK23RPC/FZXVxc/uNfV1fGY7ejoaMmv09vbKzsjtba2BqPRiIyMDPj6+vL5rZmZGd5NIvmt1NRU0DSNlJQU3pGSA+SQmpEioigKKpUK8/PzKCkpQXh4ODjOUi5M8lvk7zQgIID/OlczUlIcKY1Gw+e3pqamUF5ejqamJgwMDOCFF14QXW+21U4Q8baOlDC/JXYgRQ5t5GTZdoqIDwwMtDqQIrUC7vyWW59nuYcstz5lfbaHK6Lh4UinjhRFAZGRQ4iMHMKJEzfQ0ZGM99//OgDgj3/8a1EaoJhIRsoVRLzt4KNWL2Pv3nrs3VuP6Wl/GAyWbqlLl57B1atnsL6uhF7fiI0NpaT8Frk+VxHxWVmN0GqXNmmA19Debunfqq3NQ00NyW+xoGkDxsdDXAJyWBDxBhtE/C0A/yr6NRqNBnNzc/D398df//Vf8w+BztZlnJUWi8lRRorIdl2mpaUF58+fBwD8/ve/l7wuQ4AcctcfxUqLhTTA8fFx/gHno48+gqenJ1ZXV6HX62E2myUPnDtBxBMnLSEhYRsN8M6dO9DpdHy31NjYmOTSYiLSR5aRkSF5/dHX1xcmkwm+vr749re/zeekSH6LuEnC/Bbg2rApBRGvUCiQnJyM5ORkLC8vo7m5GZcuWX5+vfXWW5LyW8D20mIpEmakhPL39xfNbzU3N0Oj0WBpaQlZWVmyDi1YlkVYWJisjBRxpBiGgZ+f37b8VmVlJSorK/n8ll6vx+joqOyMlCuI+MDAQKyvr0Or1eKb3/wmDAaD1XozcdwiIiKsPidXsnZSEPHCAylST0FqF9544w1JB1KAfSCHI9lbfwwODubXm3t7e3mgEHGEyWfkzm+59VmXe8hy61PS52O4ImJZWlJGikih2IBCsYH1dU985SsfYH3dY9NNOoJbt0h+i93Mb5n4r9spIt6RIxUQMIPCwtsoKLiNwUEdrl07hb6+WDQ1ZaOrK4mnAep04vktYHtpsRRZO1Jb648WGmAr0tMt+a2mJj04jkFFxTFUVJTC23seHh4riIt7Ivm1CJBj+2B2F8AKgO0rJUJHKjg42O66jI+Pj9Uvb5ZlZWekWJaVhYj38PCAVqvF2toann76aaytrW1bl2EYBunp6VbrMmRIcCUj5Wz9MSQkBKWlpSgpKUFPTw9u3ryJgYEBNDU1obe3l3cBHAEmdoKIT05OtnKkPD09kZ2djezsbKv8VllZGa5duwZfX18olUrZmGm5a2uE2nfgwAE+myRGAwwICOAzbsHBwS4BOeQi4lUqFf/wfurUKf4+IvktoZskdNx2kpFyhIi3zW91dnaisrISS0tLaGxsxODgIH8fCWmAtpqYmMDAwABfWixFwvVHoSNlm98iDuClS5dw9epV+Pn5QaFQyOq12ykiXgjLIW5SbW0tampqEBoayh+2+Pv7uwTkcNRHJiatVovIyEisra2hpKQEa2trMBgMOH/+vFX/lu2BFHGkdhsRT1EU4uLiEBcXh9OnT6OtrQ3V1dW4f/++O7/l1udC7iHLrV3W52u4AiwZqcbGbKSmtknOSAFbpcWZmc3w8FhHTg7Jb1ncpMuXn0ZZ2enN/BaLlJQOHhHPMHIyUvIQ8RQF6HSDWF5WISqqD0VFt8FxNB4/zsWjR/sRHDzOO24BAdNWX+uotNieursTnTpSGo0JeXl1yMurw9RUIOrrc3D7diEACi+//H8gPb1ls3+rEwqFeH6LXJ+wtHhLllyWcGWQiKC9hSfAztZlgoKCMDk5KWuFaqeI+OzsbHh6elrRAA0GAz7++GPeaSDrMvYcKUean5+XhYgnNMCNjQ2+rFZIA7SX3wKsHSmpkoKIF+a3CC3t/v37AICf//znfP+Wo/wWsLOMlPAzt6UBkm4pkt8KDw/HyMiIrPvIVUQ8AXLk5OTAy8sLhw4dwsjICO9KtrS08PkthmEQHR3t0rApNSNFpFAokJKSgqqqKoSGhuLgwYOiNMDMzEyr/BYgf0gALIj4qakpFBcX2/0zAQEBKCoqQmFhIQYHB9HQ0IDa2loAwC9/+Uv+M3KU3yLXJwbkcCSx9UelUon09HSkp6djaWmJd23Ky8tRXl6O6Oho9Pf3o7i4+FPNSAFb64/5+flQqVSi9RTCA6mIiAiXgBxk/TEvL08SlIS4ZDU1NQgKCkJ+fj4MBsO2egrbAym33PpLyj1kubVL+vwNV0RbGSnpCHZ7jpQlv3UHhw/fwdBQJEi3VHNzJjSaRXh4rMLPbwZRUf2SX8sVRPxWafElpKa2ITW1DSaTejO/RaOysgSVlSWIi3sCmuaQmWmEl9eK5NJi6+ujZSHiAwOnEBw8AYDC2bMXMTISgaYmPRobs+HtPc87bhERQ1ZDJSktLijYXlps0S2IDVkcxyEqKspux5DYukx1dbXlO966xbs3zk77dxMRL6QBiq3LKJVK+Pj4yAJySO2REmp0dJR3pAgN0Fl+y8PDw+VhUw4iPiwsDDqdDgBw/PhxjI2NoampiacBEjfJ1ol0VFrs7PocOVJeXl5gGAYMw2Bubg4GgwF3794FAFRXV2NoaEiUBmgr29JiKRJmpMg9SlEUn986fvw4n99iWRZ1dXUIDAwERVHw9vaWlZESGzadSYiIz8nJQU5ODmZmZra5SULHTaFQ8MOm3IyU1PVHiqIQFRWF2dlZ1NbWori4GGNjY07zW8DWkLDbiHiNRoO8vDzk5eVhamoKHMfxPVd3797FxMSE0/wWsL20WIrEEPG29RRtbW1WB1Lk34NGo5HlJhNEvJyfR0JEvHC9WVhP4enpaVV27s5vufWXlHvIcmuH+vwOV0Qcx0CjWZSZkXLsSFncpCHodEM4fvw6urqSUFubi7a2NAAUfvnL5/n+LSEN0FauIuJZlt50pLbWH9VqE/bufYy9ex9jejoApH/r4sVncOXKGURF9WN+3hdZWdKHOZKRko+IpxEQMIXc3DpQFHDqVBna21PAcTRqa/ehpuYgQkNHQdMcsrM5+PvP8qXFDGPv+m7BNpc1MjKCkZERnD59WtJ1abVa5Obm4vbt24iPj0dsbKwVDdDeuozlPbmWkVpdXbX7wGq7LtPa2orHjx+jq6sLAPD6669LXpdxJSMlRu0T5rfGxsb4B5yPPvoIXl5eiImJwezsrKwVr50i4g8ePAiKopzmt7y9vV0aNqVkpITy9fXFwYMH8fDhQ8TExCA6OtqKBkj6t2JiYrY5E45Ki+2JOFL27iOx/FZ9fT16ey0VDW+99RYYhtlGAxTTbiHi/f39rWiAxLkl+a24uDhMT087dKRsRYZNuW4GcaSKioqgUChE81txcXG846ZWq10aNgki/tixY5IcqcDAQBQVFaGhoQEBAQGIioqSlN8i72m3MlJE5PtlZmbyB1IEKAQAf/zjHyXTAMWAHM4kRn+0PZAi/Vssy/L1FDRNu/Nbbv1F5B6y3HJRn//hCrBQ8Vpa0rFnT4NkMARgGRKCgiYQHe3ckVIqN5CS0o6RkXC0taWjtPQGOjuTbWiAHDIzrfNbwFZp8Zkz8hDxZP3RniMVEDCNoqLbKCy05LdYlsHjx7kAgKtXz6KvLw40zUKnG3S4orhbiHhLfqsF6ektWFrSbOa3aJSXH0N5eSni459gYiIIkZEDmy6YmLbnsuRmpABrR0qv19tdlyG/vCMiIqwcKUcuha1IRio2Ntbpn/Xw8IBer8fs7Cy6urpQWFiIrq4uSesyUoActhJmpOw5UqGhoVb5LZZl+QehGzduYGRkxGl+C9gCcuwUEW+b3yKQk7KyMly/fh3JyckYHR1FeHi4rIyUK+uPQkR8dna23fwWcUqCg4MllxbbSs76o0qlwp49e7CysoLe3l7s378fXV1dPA2Q9G/Z5reArYzUbiLiCRJfp9Ph+PHj6Ozs5KmSAHD79m3MzMw4zW8B9oEcjiTMSJGDE3v5rYsXL+Lq1atIS0vD8PAwQkNDZQ+bgLz1x/7+fn7Y3LNnj8P8FsH9k6ydKxkpqYh4rVbLkw4HBwexd+9edHV1SaIBOiottidn64/CAylh2fn9+/cd1lO45danKfeQ5ZZMfTGGKyKjUZza50gzM1ulxVIhWRZHikZMTC8KCu6ioOAuZmb8eTfp0qWncfXq6c1uKQ7JyR1QKtfhSo9UVxfJSDl3pCgKiIoaRGjoOOrrc5CU1A6VagV1dbl4+JDkt9jN/NbMtq//NBDxGs0S8vJqkZdXi8nJQHAcjfr6vZib88fCgg8+/PCrm/1bXTb5Letc1sbGBhobG5GcnOyQrrb9PVk7UvbWZWpqanD//n2EhYUhNDTUoSMlpp0i4ktKSlBSUrJtXcbLy4t/wCHrMnJBCoC0jBQRyW+Rk/aYmBh4eXnx+a3IyEjeTRJ7wCGOlCuIeHsP1D4+Pjh48CAOHjyI0dFRsCwLlmWxsLAADw8PXLhwAQzDbKMB2mq3EPH28lvV1dWorq5GdHQ0QkNDdwTkkLu2Fh4ejlOnTsFsNlv1b7W0tECj0fDExOjoaFAU5dKwSRDxR48edfpnlUolUlNTkZiYiPb2doSFhcHDw2Nbfkuv1/O4etv35GpGyt6/Xdv8Fsm4mUwmeHp6oqysDDRNO81v7RYi3ll+KyEhASEhITvKSLmy/vjUU08BAF9PQZxA2wMp8jWAvD4yOYh4ciCVnp6OF154AQEBAVAoFPx6szu/5dafS+4hyy2J+mINV0Qsy4CiNnD9+gkwDLdJA3ScRzIYaMjNSIkh4v39Z1BYeAcFBXcwNKTj+7eMRj00mkXo9Y1obMxCSoo8IAfJSKWkSMtIAQQR74WiomrExvbBZFKjqcnSv1VZWYrKytLN/BaLzEwj1OplgSMlDcgBWK8/SkHEBwVN4ciRKiwvq1BTsx/Z2RxaW9P5/Bbp34qIGN68hlsgQ1Z3dzfm5uZkuTfOHCmxdRnicAFAVVUVGIaRtC7jakbK1pFyti6TlZUFuaXFwM7WH48cOYL4+HgrGuC1a9dw/fp1q/yWp6enbCCH8PoiIyMlOVJhYWE4fvw4KIrC3bt3kZaWZpXfIi6AGEnSXmmxIzlDxAvzW7Ozs7zjVl9fDwCoqamByWRymt8CrEuLpUqYkQKsaYBCN4kAIYKCgpCdnY2GhgbZQA5X1h/b2tqwsrKCI0eOICkpCdPT0/xnRPJbaWlpoGkaycnJUCqVsoEcwusLCwtz6kiR/FZUVBTUajW/UlxXV4eHDx8iJCSEd0ps81vAFpBjNxHxwvzW5OQkf9jS3d3NvzeKokTXm20lLC2WKuJICRHxwnoKsQMpmqbR0NDgMpBDzvpjR0cHTCYTjh49itTUVEkHUm65tZtyD1luOdEXc7gCLI5UT088EhO7MDfni8uXn0JZ2alNGiCHlJT2bSuEQkfKtrTYkRwh4gkNUKcbxIkT19HZmQSOY1Bfvxfr6x4YHIxCVVWR0/wWYF1aLDcjJXSk1GoTcnMfIzf3MaamAnhi4sWL53D16hmkpbXCw2MFrgM55CHiLeuP7Xj22fNYW7u0md9i8PBhPh48IPktFjR9D+SQmAwJcpDMzjJSQpF1mfT0dPzsZz9DTEwMpqamJJdnEkdqtxDxYrhjjuPw4MEDmM1mjI6O4v79+5LWZXaSkRIi4oU0wLGxMav+LS8vL2RmZsLDw0P2sLlTRPzXvvY1rKys8PktQgPU6XRgGAZZWVm8+ymltNhWzjJSQvn5+eHw4cPYs2cPXnjhBeh0OgwODqKtrY2nAdI0LZrfAnYvI0VEaIApKSl8fovjOFRVVQGwrGTW1tZKym/tBBEvLC0OCAiwym+R/i2j0QiNRsMfisgdNicmJmRlpADLfdTY2IjExER85zvfgclk4g9bKioqUFFRgbi4ODAMg8zMTH44IhkpOX1kchDxQUFBOHLkCPLz8/HCCy8gNDQUHR0dfH5L6CbZu49CQ0NdykiJ3Ue2B1LksOXmzZsALPcRy7KS7g0C5EhLS9sRIl54INXT08OvpQrzWwzDyFoldsstR3IPWW7Z0Rd3uCIijtRTT11CQMAUhocjeTeJ0AD1+ibQNIvo6H5QlNCRuij5deQg4pXKDaSmtiM1tR3vv/91tLenIDBw0ia/xUKvN0KtNm37elJaLBcR78iRCgycRlFRNQoLqzEwEMUTE5eWtFAo1vHwYT4YhkNkpOP8FiAEcriCiLf8QvfwWEdGRgsyMlqwuKjh+7fKy4+jvNyMhITfIzNTD6PRCJqmZWekAgICJGWkiAwGAwDg3LlzCAoK4tdlyIMXWZcRlmfKBXIA8hDxnp6e0Ov10Ov1+OCDD9Da2gqtVitKAxQboj4NRHxoaCiOHTuG0tJSPHnyhH/AWVlZgUKhAMuyYBhGEpiDrK25sv5IgBxeXl68gzU3N8c/BF69ehXXrl1DcnIy9Ho9T+1zBcghd/0RsNxHISEhPA2Q4zieBkjuo6CgIADygRyAPEQ8yW/t2bMHH374IYxGIxQKBZ/fEtIAxTDcu42IF+a3SP8Wx3F4/Pgx1tfXoVQq+eFUzE2ylaMhYX19HQaDATU3b2JmchJKDw/EpKQgNTvbChGvVquRm5uL3NxcngbIcRwuXLiAK1euIC0tDXq9Ho2NjbJKi8n1eXt7y1p/NBqNMJvNePbZZxEaGrqtnoK4SdnZ2fzaopTSYlvJQcRrtVrk5+cjPz8fH374IZqamrCysiL5QMpVRHxraytyc3O33ZtkvTk+Pt7qQIrkt8LCwrBnzx53fsutHcs9ZLlloy/+cAVYHCmWZRAT04vAQIsjFRk5hMjIIZw4cQOdnYngOAYNDXtQW7sPQUETyM7mMD3tL6u0GAA6O5NcQsS3t6eCYRrw1FOXMT3tz7tJly49w7tJNM1u5rcs2SRSWhwd7UpGyvH1URQQHT2A6OgBMEw93njjHxAWNoK6ujw8fHgAISFjfP+Wv//2/BYZNncTEa/VLmHfvlrs21eLyckgcBwNjtPi8uUnAIDp6Wl0dHRIWpfZSUZKiIh3tC5DyjOnpqZ2BOSQqtXVVbS3tyM7OxvPPPMMxsfHt7lJYusyto6UFDnLSBFRFIWEhAQkJCQgLy8Pb7zxBoKCgrblt7Kzs0WHSVczUgQRL+ZIERrgwYMHMTIywmeT2tos99zi4iJ6enqc5rcAa0S83PtIiIi3pQHa5rdomsbExITsYbO3t9clRDy5j86dO4fh4WHeTSI0QNItFRUVxb9vAuT4NBDxJL+VmpqKwcFB/OY3v4Gvry9PA4yNjeXdJLH8lnDYtM1INTY24g+//jWCJidR8OgRQmdnsaZQoDUuDh8UFMDT21v0ICYwMBDFxcUoKirCwMAAOI5DY2Mjv068srKCwcFBREZGOr03xIAcUiRExFMUta2egrhJpOycpmmMj48DkAfkkJORIlpfX0dnZyf0ej2ee+450XoKYSG88D1JBXIQEUS8s/tIeCBF7qOlpSXJB1JuueVI7iHLrU19OYYroqGhSIyPh4o6UgrFBlJSOpCS0oHlZRWMxgxwHIOqqiMAKGg0i2hq0m/mt7a7SbbiOHoHiHjL4BMQMIPCwtsoKLDQAImbZDTqodUuQK9vRHJyp6zSYmBr/VFqRoqosTEbCsU6/vqv/wMKhZnPb1VUlKKiohTx8d18/5ZKtQwA6OpKwPy8ryyXjSDis7M5eHisOfyzQUGTOHLkFoqLj+GNN3T8Kf8f//hHq/LM8PBw0QccsdJiZ3LkSNlbl7lx4wYAy+luR0eH5PC1q+uPQmpfSEiIFQ1QbF0mJSXF5YyUTqeThYhvbm4GRVH4m7/5G34NS5jfSk5OBk3TSEtL4x9w5AA5iOSsP4aHh+P48eMoLS3Fm2++idHRUTx58gTt7e0ICAjg3SR7vWu7jYgXuknC/NaVK1cAWJD6/f39ojRAMZEeKbkZKeJICfNbQjdJmN8iWamOjg6XMlJy1x9bW1sBAD/4wQ+wsbFhRQMkbpIwvwVYMlLT09PbiqIbGhrwx9deww8vXkTa0JDVf0sZGUFrURFUQ0P4+f/z/+C//9u/iR4EUBSF6OhoREdH4+TJk3jrrbcwPDyMjo4OtLa28vktmqbtukBipcXO5MiRIuvN+/bts8pvnT9/HoDlPhobG4Ovr6+kvy9XMlJCR0psvZll2W0HUikpKbJKi4lcQcR3dHQAAP72b/8Wq6ur/GGLcL2ZHEjJ+dno1pdX7iHrS68v13BFxHGMJEdKpVpGTk4DcnIa0NBA4/z55+DpuYrLl59GWdnpzfwWi5SUDlEE/E4Q8WKOFKEBRkUN4sSJa+jsTAbH0Xj8OBePHu3nX3N6OgABAdNOX0dYWixVYoh4YX7L4iYxuHDhHK5c2XLcDIZsl4Acq6teDrqxtmt+/j6GhvJRWFiIwsJCSesygPPSYjFxHCfJkRKuy9TX1+PChQsAwJdnOluXsVdaLOX6xBwp23UZW9wxYDnpn5+fl+QWkdLinSLiSX5rdHSUf8D58MMPoVKpkJGRAYZh+IyUHCBHa2urbET80tISBgcHcejQIRQVFW3Lb0VFRfHERCG90taRkiKp1D6S3zp06BDq6+tx8eJFrK2t4f333+fzWwzD8DRAW7mKiCdDuO36o21+ixDlCA0QsDgFS0tLTvNbwHYghxSJOVJCGiBxk4xGI7RaLf8ZNTQ0bCstnp2dxduvv45//ugjxG+6O0K1p6bCpNHgqx98gNqYGLz729/ih//8zw6vb3l5GUNDQ8jPz0dRURH/GZH8Vnx8PN+/JVwlJEAOe6XFYpJK7SP5reLiYtTV1eHy5ctYWVmRfCAlVlos9frEHCnhgdTCwgLvbN24cYM/lNJoNFhZWZF037qKiGdZFnFxcfyqqW09hdFoRENDA/z8/PiMmzu/5ZYjuYesL62+nMMVQIaErM2MlHMniqizMwUazSKef/7nGB0N492krfxWIxiGQ1RUP+8kEUS8HPdGKiLekt9qQ2pqG5aW1Hj11R9jZcULDx4cxIMHBzdpgJb+LbV6WfR7iJUWOxNxpMTWCwMDp1FcXI2iomoMDESDZWk0NWWhqSkLgBlhYaMYHQ1DZOSQJLeNlBbHxPRKvj6DYZ53EkjQ3NG6DHElXM1IpaSkyELEP3nyBCqVCj/96U/5h0Bn6zIEyCFnSJibm5PkSHl6eiIrKwtZWVlYWFjA66+/DpPJhLt37+LevXuS1mV2GxEfFhaGY8eObXPcGhoa+P8+PT0t2TXbKSLeNr9F3CSS3yLdUoGBgRgaGpKdkZK7/khRFPr7++Hp6Ymf/vSn6O/vB8dxYFmWz2+R6yX5LcDakZIqqYh4lUqFnJwc5OTkYGZmBm+++SYWFhZQXV2Nu3fvOs1vAY6BHPZkz5ES0gBPnDiBjo4OPr/16NEjUBSFsLAwLC4u8g/ud6ursae7W3TAAgCOpuEzN4fE7m5E9fbiX9PSMDMz4zCTJETEazQah/ktUnYeGBjoEpBDLiKeoiiMjIzAw8MDP/nJT/j1PWcHUq5mpKQg4r29vfkDqfHxcfzHf/wH5ufncevWLdy9e9fKTbL3fVzpIyPrj4cPH7b634UHUsL+LbLeHB4ejj179titp3Dryy33kPWl05d3uCLaykhJH3yEjpSHxzp0uiHodEM4fvw6urqSwHE0GhpyUFubj6CgCb5biuMYBAVNICrKeWkxkSuI+OnpAMzP++Hs2UtITu4A6d+6ePEZKzdJmN/a2FDAYKAdlhaLieMYp46UJb/Vj+jofpw6dQ3Xrx/Hw4cHMD4egt/85h8281ssaNogmt8CxEuLpV1fBqKi/Lc5UsJ1mYmJCf4B55NPPuF/WXt7e2NjY0PSugxBxMt50FhZWUFzczPvSAnXZcgvb9t1mezs7B1lpLLpbDQP30HvVCPW1lfgpw5FTswp+Ki2F7suLCzw2PvExET+M3K0LiOltFhMUhDxCoWCz2+dOXMGN27cwKNHjzA2NoZXX30VOp2Od5PsvbZYabEUsSwr6kj5+vri0KFDOHToEEZGRvhsUmtrKz88BAYGwmw2S3o9VxHxxJFSq9Wi+a2qqipUVVUhOjoaDMNAr9fzg7ycYdOVtbXV1VUeMpKQkMC7SY7yW+Q+kouIJ+uPjqh9SqUSaWlpSEtLg8lkws2bN1FXV4eRkRH8+7//O+Li4kDTNG7fvIl/qKsT/R6LGg3aUlOxv6YGio0NaDY2kNvVhbu3b+PMZkeUmOwh4m3zWwSW09jYyB9mhIWFSb6P+vv7XULENzY2Ij09Hd7e3g4PpEi3VEZGhksZKYKIl7OOrVQqMTs7i6NHjyIuLm5bPQVxk4SfLRk2hY6UFBH6o6P1R9sDqfLycjQ0NNitp3DLLfeQ9aWRe7gi2spIdUj+GnuOlFK5gZSUdqSktFvltwgNEDAjNbUVJpNakmvmKiJeuP6o0SyhqOg2Cgst+S2WZdDUtJXfyspqBE2zWFzUygZyrKx4oaUlHTQtHRGvVK5jbCwMgYGT+OEPfw2jUb+Z3zq2md8i/VvNfH4LcF5aLKbh4XCMjETg9Ok5h38uODgYR48exZEjR9Db24s//vGPAIAPPvjAal3G0arObiLiSXmmXq/fti5z8+ZNmM1mpKWlYXV1VfKaF8dx8A1S4ZXys/CYmEFG7TQ8TWtojfPFh1n/FxhdKZ498G8I1EZafQ1xpLy9vSWtyywsLHyqGSkiT09PTE1Nwc/PDz/84Q/5/FZZWRlPA7TNbwFbw6achzuCiHfmSIWHh+PEiRM4duwYurq68P7772NjYwPvvfceAgICeDfJ0QqqK4h4e46UbX6LDMmEBri+vo60tDTJBwnA1vqjK4h4mqbh6+sLnU5nt3+LfEazs7OSS4uJXEHEq9Vqfg32Bz/4AX8fXbx4EV4BAXh45AiWOQ5JHR1QbmyVnTdlZWFDqQTNbv08SujpQfuTJ3ZfSwoiXpjfImXnH3/8MQDgnXfeQUhICBiGQXZ2tkPHzLa0WIrsIeIdHUhdvnwZa2trsn7uAdZADjlfAwAMw/CHTEI36cGDB7h3757VgdTMzIxLQI7GxkakpaWJQlLE5O3tjeXlZWg0Gnzve9/j7yN3fsstodxD1hde7uFKKJOJOFL1MjNSzh0pYX5rZsYfFy48ja6uZLS1pePFF/87UlPbwDDETRJ/bbHSYmeyOFIWap8QES/Mb508eQ0dHcngOAZ1dbl4+HA/VCoTPDxWERY2Ivm1XMlIzc5a1h+Liqqg1ZqQl1eHvLw6TE0Fbua3aFy48CyuXDmL9PQW0DSHxMROyCktJuI4BgrFOrKyaiT9eYqisLa2htXVVTz33HNQKpWS1mWII5Wdnb3riHjbdZkrV66gu7sbra2teOGFFySty4yMjGB4eBiU5iG+9/81IKl1GVu/5qcw76vAzacm8b9G7uGnZz9GhF8SDwywdaScrctoNBoolUpERUVJ/hx2gog/dOiQFQ1wdHSUJya2t7dDpVLxn1FcXBw4zlJaLAfIIXdtTaFQQKlUYnV1Fc888wyUSiVYlsXt27dRXV2NqKgo3k0SrpaS0mK5fWT2MlJC+fn5oaCgAIcPH8bw8DCuXbuGnp4etLa24sUXX3Sa3wK2MlK7gYgX0gBNJhPvuJH8lre3N5RKpSyXzZX1RyEiPigoiM9v9fT04LVf/hJPEhJgzMqCdmEBWQYDGI5D5OAgOJpG2MgIIka2fl4qzGZsCAYxW8ldW1MqlfD29sbq6ipOnz4NhUIBjuNQXl6O8vJyu/ktMmzuVkZKKOGBVF9fH8rLy9Hb24vW1la89NJLVv1b9rSbiHjbAykhUOjmzZs8uCM5OVny59DR0bEjRDwBtZSUlFjVUwgPpKTWU7j1xZJ7yPrCyj1cicmW2idFMzN+ePIkHkeOOM5ICeXnN4PZWX9ER/fi9Omybf1bxE2Kihqw+p6OSovtqbMz0en6o1K5gbS0NqSltcFkUoPjsnH16mkACrzyyj9v5rdYZGYa7ea3LNfnOiLe9jMPDJxCcXEVioqqNvNbDJqa9GhszIZGs4ilJS0OH74NsxmSPveNDYofNrXaKgArAKRT+zIyMvh1EdvyTNt1GVczUnIR8SEhIVhcXERkZCROnjwpui4jVp55oeJtABv4r/+zCkFT2/8+feY28Oy7kwgZWcUvFN/Av331Dvp7hzA3N+fwgVq4LjM/Pw+WZVFeXg6z2Yxf/OIXktdldrL+aDuYhYWF8TRA8oDT1NSE+vp6+Pr6Ym5ublvOwpF2iognq6C2+a0rV66grKyMz2+lpqa61CNFMlIHDx6U5EYRGuDq6iqfdRPmt4KCgvgHZWF+i7ynTwMRr1ar+fzW9PQ0WJZFVVUVzGYzfv7zn4vSAMXEcdalxVJEEPHCz5yQ7tYXF/FX77yDubAwcAyDurw8PDxwAIGTk5gKCsLh6mqr7zUQHo4gnU70dRwh4h2JrK0xDAOVSoW8vDwrGqBtfispKYl3pOQcWpCM1L59+yTfR7GxsTCbzQgJCcHRo0et1pvDwsJ4x8123XMnGSlHjpS3tzf279+P/fv3Y3x8HA0NDbh37x7MZjNeeeUV0XoKMXGcdWmxFIkh4oX1FGIHUs7qKdz64sk9ZH3h5B6uHIllafj4zCI8fMj5H96UKxkpISJepxuETjeIEyeuo7MzCRzHoL4+B48e5SM4eBzZ2aRbalZyabFQWxkpaYh4tdoEL68VAAp8/evvYXw8FBxH4+LFc4L+LQ5JSVv5LWDLkZKLiGdZiyMVFCTuSFnnt8rQ3p6CGzeOY2lJg7t3C9HWlgaa5pCdbfmM7GmrtJgFsAigFsAhh9dnz5ES0gDF1mVUKhW8vb0RHR0t7YPAzhDxp06d4vNbYusyERER/C9vL5UH+rvGEd/Tj6CpBYffv6BiDg1Fk3jUcwFjBpXTjJRQPj4+8PPzg9lsxrlz5zA+Pi4Jd+ystNieWJZ16EgpFAokJiYiMTERZ86cQUtLCyorKwEAd+/eRXd3t9P8FrDzjJRwuBTLbxkMBrS2tkKtVsPLywtarXZXhk1HEiLihTTA5uZmfsCpqqpCTEwMaJqGXq+HWq0WdaScSS4iPiAgACEhITCbzTh9+jQmJiZ4GqBGo+FXd3U6ndX94qi02JHsUfsoisLBwkLcMxjwtdu3kdbWBpNajabMTFRv5pzuFhWhPzYWDMsipaUFDzIz8X8WFoq+jj0ghyMJ1x+FjpSQBkggJyS/5e3tDS8vL6jValnDphDIIVVCR8pePYWwf4uUeIs5Us4kFxEfEhKC6OhomM1mlJaWYnJyUtKBlKPSYkdyhoi3PZBqbGzEvXv3HNZTuPXFk3vI+sLIPVw508yMP3p6LL+EXnrpv0GvbwJNs4iO7rc7NIiVFkuRGCLeQgNsR2pqO0wmFYzGTKv8VmjoKBYWfJCe3iz5dZaXLRkphmmQnJEi1xcYOImMjGZQVDMKC6sxMBDFExObmrI281sGMAyHyMhByaXFQg0PR2BsLEwyIl6pXEdqahsuXz6L5OR2pKW1guMYlJcfQ3m5Jb/FMCwyMoxQqVZs3pNtafEtOBuympubnTpStusytbW1MBgMAICXX36Z/+XtLLOyW4h4e+sypDzTL0gDxZoWe+saJb3GkY+H8Un6r6DsOgG9Xu8SIp5hGFAUZeUm2VuXcaVHanR0FMPDw5KLmL28vJCdnc2vWKWmpvL5LdsHHNt1T1cyUlIQ8cL8Vnd3N+rq6tDcbPm3/sorr/Cfka2bZKudIOKF95EwvzUzM8M7biS/FR0djZmZGVlDgquIeALkIOQ5Yf8WoQEGBwfz+a2AgADJpcVCTUxMYGBgAMeOHRP978XHjuH/vnULR+rrETI/D7XJhL2PH+NuQQFienqQ1NkJjmFw4dw5UE89hSAPD8zMzCAkJGTbA7oUIIet7GWkiCiKQkxMDGJiYnDq1Cm0t7fj8ePHaG+3HLC9/vrr/GfkzD3bSUZKeH3ODqRiY2MxNTWFQjvDqJh2gojXarU4ePAglEqlVSE8qacQHkj5+PhILi0WSi4i3sfHB/v370dtbS0iIyORmJjI11OQAymGYRAXF+fOb33B5B6yPvdyD1dSxXGWVYVnnvkEXV1JaGjYg9rafQgKmkB2NgeG4bYNUo5Ki+1pfd05Il6tXsbevfXYu7ce09P+MBho3L1rWWm6cOEcWlvTQdOcw/wWIFx/lA6HEHOkLG7SAKKjBwT5LRp1dXl4+PAAQkLGsLSkRmTkgF1HSkwkI+UKIj4n5woyM5uRl1eHyUmS32Jw/vyzuHyZ5LdYJCV1YW3NQ1BaTD6vWwD+1cn1Oc9IEZF1mf7+fhgMBpw6dQrd3d2iNEDbk39HpcX2RBDxjqh9tusyLMvi7r3bAChcOXsW3YmJoFkW8U+eQGEW//mQyZnw5hQFf5k9UmKOlNi6DMuyVusy8/PzCA8P/1QzUoA1Ij4rKwsHDx7EyMgISP9WW1sbn99iGAaxsbFYW1uTDeQg1ycVEa9QKJCUlISxsTE0NzfzOY7q6mpUV1cjOjqad5NsqwEclRbbkxRqn7+/v1V+i6wSAsC1a9cwMDAAmqYd5reA3UPE2+a3SLdUZWUlKisrERsbi9nZWYSGhsoGcgD219ZCQkLw1Fe/in9fWcE/f/ABQufm0BcTg6mgIBTfugWG41BUXY3LBQV4cPgwVN7eePfdd6HVannHLTIyEuvr6zAajZKLxoXX5+Pjg8TERKd/VqlUIj09HXNzc2hvb0dBQQF6enr4/JbQTbIdVHaSkXKEiLc9kGJZFuwmKKSiogJjY2OSDqR2iognA6+np6fDA6mkpCRMTU0hODhYVmmx1D4yoQYGBjAxMYGnn34ae/fuFT2Q8vf351d33fmtL4bcQ9bnVu7hSo4s1D4GsbE9PJxieVmF5uYMsCyDqqojqKo6ipiYXtA0u0npM4k6Us4kFxEfEDCD/PyHqKoqQkZGE3x959HYaKEBWvJbFjdJpxvY5rhxHI2goAlER0tHxFuGTfuOlFK5jrS0VqSlWaiITU2ZqK3dh4UFXyws+OL3v//+Zv+W0YoGaCsC5HAVEb/lSAFBQVM4cqQKxcVV6O8n+a0sNDZmw9t7HhERw1hd9bJ5T3fhKJc1NzeH7u5uFBYWyjo9JI4UGW6crct4eXmBZVlJpcVCEUS8VPcmJCQEhYWFuHO3GsETXYjtmYExMxPsnj3wnZ1FNseB4TiEjY5afZ3CDGhnk+Hr5ytrbc3Z+qPYukxdXR3m5uYwPz+Pd955R9K6zE4Q8balxeHh4dvyW42Njaivr4e/vz8iIyNllxa7iognjhQpzZ6dnd2W3xJ2S3l4eEguLRaKrD86ykgRkfxWaGgo6uvrkZCQAG9vb1EaYGDg9gqATwMRr1arsXfvXuzduxfT09PgOA719fWYnp6GQqHAn/70J0n5LakZqZLjx6FQKvF/e3mB6emBp68vPFZWEN7bi/spKbh14ABMYWF4/l/+BSEhIXzZeV1dHR4+fIiQkBBERETIzkgtLi6ira0N+fn5stcfQ0NDeVdFmN86f/48Ll++zGeTEhMTeZgGIG9IkIOIJwdSOp0ORqMROp0OWq1W0oEUeU+uIuLtvSexAymWZTE3NwelUonz58+DYRinNEB7QA5nskXE2x5IkbLzu3fv4s6dO4iMjATDME7Xm936bMs9ZH3u5B6uXNHQkA7j46F46qktR0qlWsaePQ3Ys6cBMzN+MBgspLvLl59GWdlppKS0o7s7Hikp8kqLOY5xCRG/vu6JgwfvIyamHydOXENnp8VNevw4F48e7Udw8Dho2pLfCgiYllxaLBQZNh1lpIRSq03IzX2M8fFQjI6G4tCh+zAaM3Hhwjmr/q2kpE6r/BYAdHUlykbELy97obk5AwwjjoinKCAmph8xMVv5LY5j0NJiWe26fPkpvn/Lz28WjnJZrqytiTlSwnWZ8fFx3ikh6zLp6elob29HcnKyrNJiKT1StmppaQHMCoRMP8YzF5pw+soVtKalgWMY3D90CPcKChAxNASaZZHd2Aif+XmMB/nCYykS9N5s2UOCTqdDSEiI0z/r4+ODAwcOYG5uDuPj49i3bx9aWlrw4Ycf8tARe+syjkqL7ckZIl4sv8VxnOXzA3Dz5k3+AcfZ39lOEPHCAdrPzw+HDx/m3SRyH7W0tECtVkOv16OlpQWJiYmygRxyMlLA1vpjQUEBEhMTsby8zLtJhAYYExMDhmGQmZkJjUYjubRY7PoInc2ZAgICUFRUhNXVVdy5cwc0TaOtrQ1GoxFarZYnJtrmtwALkENqRupISQny8vNxu6oKDx89wuryMl76q79CdFQUzp49i6ysLP49pqenIz09HUtLS/xn1NhoWdW9ffs2Zmdnt9EAxeRqRsoWEW+b3yL9WwaDAd7e3sjKyoLRaER8fLxLQA5X1h8LCwuRkpIieiBFgELE9ZNaWix2fY4yUkKFhISgtLQUSqUSVVVVSEtL4/OJwnoKsZVcKUAOWzlDxHt6eiI7OxvZ2dmYn5/nD1uc1VO49dmXe8j63Mg9XO1EhNqXmSnuSPn7z6Kg4A4OH76DoaFIcBwDlmWwvKxBV1cSLl8+A4bhEBVlP78FWBDxra1pLiPiiSNlyW+1ITXVQgO05LdoVFaWoLKyBHFxT6DRLMLVjJQriPjU1HaUlpajpKRcNL+VnW0ATbOIjBwCRW1lpByVFtuqudnSRybFBfTwWEdGRguiogbQ0pKO5OQ2mEwalJcfR3n5MSQkdIOmK5CRkSv6gONKRsqZIxUSEoKSkhIcPXoUvb29fFHt6uoqent7cf36dUnrMsLSYrmIeG9fDZoOr2DjD4Dn2hqympqQ1dSEBW9vNGZlgaNpXD91CjdOnEBSZydm/VZAQYE9e3Ikvw7JSJ06dUry15D1x5SUFJw+fRqnTp2StC7j6rAp1ZHy8vLiT/lffPFFxMfHY2lpCVevXt32gCP2d7ETRLy9+ygiIgIRERF8/xahAa6trWF4eBi3bt0SpQHaaqcZKeJIqVQqngY4MzPDOyWXLl3C1atXkZqaCrVaLXtIIIh4OQO02WxGY2MjEhMTce7cOayvr6OzsxMsy9rNb5H3JCcj5ePjg7iEBDysrcUPfvhDp66KRqNBbm4uMjIy8MILLyAqKgpzc3OiNECx4YEAOeSsP5JVPDFnUyy/xXEcHj16xGPn7969u62eQkz2gBzOZOtI2TuQ+vjjj/m/G7Va7VJGqq+vT3JGCthyyOPj4/H1r38dq6ur22iAtvktQD6QA5CHiPfx8cHBgweRk5OD//2//zfCw8MxMjIi6UDKrc+e3EPWZ17u4WqnsmSksh1mpIgoCtDphqDTDWFuzgcdHclITu5AQ0MOamvzERQ0wbtJYiAM1xDx/g4R8Wq1CXv3PsbevY8xPR0AjssGxzHo6YkHYEZ5+THQNOnfst/ZAogDOZxpy5Gy/EK3zW+1t1v6t2pr81BTY8lv6fWNMBozsGePa0COmBj5iPhTp8oQHDyJyckgkP6t8+fXcfnyC9vWZYaHh13OSKWkpDh1NwgSOi4uDqurq2hpaUFMTIzkdRl7pcWORBDxhw8fxr2JCzDk9IN5vLWm6b2wgP01NdhfU4OxkBBwDAOOpjHr7w9QlgcuqeWZrqw/PnnyxGr90dm6jE6ng16vR1NTk0tADqkZKSLiPpw5cwahoaFWNECS39Lr9aBpGrGxsaAoStSRciaybiQFEU/6fpKTk/HRRx/BaDQiNDSUpwGS/FZWVhY0Gs22r98JIt6eI+Xv74/CwkIUFBRgaGiId24WFhZAURQePXoEhmEQFRXl9D5yJWtHHClSWuwsvxUXFwe9Xo/GxkZZpcXk+lxBxJvNZpw9exbh4eEYGBjg3SRCAxSWnVMUJam02FZkSHCUkSIiDlRGRgY++eQTGAwG+Pn58fUUjvJbwM4yUvbWH8UOpIxGI5aXl6FQKGAwGKBQKCQNna5mpISOlHC9eWFhgXeThPmtrKws3pFyBcghd/1xY2MDZ8+eRWRkpN0DKYZhJG0TuPWXkXvI+szKPVztljo7k7C46C0LDmEyqdDWZnGkzp69guVlFYzGjE0a4FHcunUUsbE9m9mkJn54IxkpR6XFtnKWkRIqIGAaRUW3kZzcgd/85h8QF/cET57Ew2jUb9IALf1bOt3gtoHNXmmx8+uj7SLilcp1pKe3Ij29FUtLajQ16cFxDKqqLA9Ag4NRqK/fg8zMZof5LcC6tFjOAZ1taXFQ0CSOHLmF4uJb6O9PBsu+iKamZhgMBvj4+CArKwuLi4uy+3+6u7sxPz8v6xf5ysoKWltbQdM0nn76aSwsLKCpqcnhuozlPUkHchAJM1K6tf+J3y79AEH/1oOYntVtfzZ0fBxHbpWjLWcEs/gaonRR22iA9tZlpAA5xEQcqdTU1G3/zd66zI0bNwBYHA/ycONs2HIVEW/rSNnSAMmp++PHjxEQEIDs7Gx+sJA7bM7Oztol3IlpdXUVbW1tyMrKwrPPPispv0Xek9yMlFRqH0VR0Ol00Ol0yMnJwa9+9SuEh4dLzm/ZKy12JkeIeLH8FvmMAGBmZgZtbW1ISkpyiuveLUR8dHQ0oqOjrdyk2tpa1NTUIDQ0lO9TA+T1SPX19UnOSBGtra2htbUVer0ezz333Lb8ltBxIwdS5D15e3tLAnIQOcvaEQkPpA4cOIDXXnsNQUFBkg+kXM1IOXKkvL29ceDAARw4cABjY2NWxETAcm90d3dLOpDaKSKerL4K15uJ4yY8kJJST+HWn1/uIeszJ/dwtdsiGankZOkZKVtqn0q1zAMzZmb8eTfp0qWncfXqaaSmtiEpqR1PniTgyJEK2Rkp+Yh4y/rjN7/5Pry8ljdpgAzq6nLx8CHJb7Gb+a0ZANJKi21FMlJSHCmNxoS8vDrk5dXht7/9W4yPh2B5WYULF57FlSuEBsghKakTCsV2x801RHw4RkfDcebM5W3/zZLf6kBMTAhOnfpv/APOw4cPsbGxAS8vL9TX10talwEsv/TUarXokGBPBBFPHli9vb23rctwHMevy2RmZiI5ORmdnZ0uATlIRioEBfjO0X/Hvyv+BQVlEyi6No2gCcvf37oSYPdqcP2bOlA+xVCMKvDtb38bXl5edsszs7KyeNfF1pGSIrL+KMWRIusyBw8exJtvvonR0VHMzMzw6zKkf8veuowrWTtHjhShASYlJeHs2bNoaWkBy7K4c+cOzGYz1Go1jEajpPwWsAXkkJuRWl5e5u8jkt+y7d8S5rfS0tLQ3t6OQ4cOyR4S5CLiGxsbQVEUvvOd78DT0xPNzc1W+a3Y2FjQNM3ntwBppcW2IvRHKY4UyW8VFhbid7/7HYaGhjA2NmZFA6RpWjS/Rd7TbiLiCQ2Q5LfIYUt5eTkAy4DY2dkpKb8F7CwjRf5tCPNbfX19IP1bwgOptLQ0tLa2ujRsykXEG41GAMB3v/tdeHh4oKmpCSzLOjyQcjUj1dTUJMmRCg0NRWlpKUpKSvC73/0Og4ODGBgYwNtvv72tnsLee5K7/jg9PW0XEU/qKbKzszE3N8dn3IT5LYZhkJqa6s5vfQbkHrI+M3IPV5+GTCYVWlrSsXfvY5kZKeJIDWz7b/7+MygsvIOCgq38lsGQjeZmy4nY5GQQ+vujEBW1nQZoK1cQ8RsbwvVHiyOVltaGtLSt/BbLMqisLEVlZSni4p6Apll0dCTLKi0G5GWkiGZn/dDfH4Pi4ioUF9/CwAChAep5GiAhJkZEWPJbwtJi4khJEcsSRLyjTqhb8PA4xK/LGI1G/OlPf4KPj4/VugzDMHYf3uyVFjsTcaRiYmK2/Td76zIkZzE/P4+RkRFJ6zJiQI69sWegO5eGW4m/wf/vzEfwn6fguUZh0mcdEX5JOMr8F9z9pBOxyTr+9NOWBshxHF+emZSUBJqm0d7ebteRsic5GSmi+fl59Pf34/Dhwzh69Ci/LtPU1MTTAMXWZVzJSIn1SImJ5LdomkZTUxM++OADqFQqPr+VkpICmqaRmpoqep84A3LYk731R4qi+PzW8ePHrfJbBMG+srKCyclJp/ktYPcQ8SS/NT09zTtuJL+VlpYGmqbR3NzsEpBD7vrj0tIS+vv7sX//fpSWlqKjo2MbDZA4JSS/BcgDcgi/hqIop9en0WiQl5eHvLw8NDY24sMPP4RSqZSc39ppRsrWkSI0wNjYWJw6dYrvlnr48CEePHgAwPL3PDs7K+lAaqeIeOJI2TuQ8vLy4lfAjUaj7IyUK+uPJpMJAwMDyMvLQ2lpqaQDKUAekEP4NYBzZ9PX15c/kCJF8H19ffzPaGE9hTu/9ZeRe8j6i8s9XH2aMhozsb7uIWtIsGSknDtSwvzWsWPX8Ytf/ARrax4wGvXguD0IDh5HdjbJb02Lfg/XEPH2qX3C/NbUVABPTLx48RwAMwIDp9DVlYSkJOf5LXJ9riPi2c38Vj+io4U0QBq1tftQU3MQoaGjoGkO4eFDskqLga1hMyWl3Qki/haEfVmtra1Qq9X4x3/8R6sQv5AGaLsuY+tISdHs7KwkRLxwXeb06dP45S9/ieXlZbAsi/r6etHwta04bntpMQBE+CXhW4f/J76y///C+HwvVtdX4KcOQZC3Dl1dXZibY3Hy5PYHDUIDJOsyxCn56KOPAFhOwPv7+yWty5Dr8/f3dwkRT9O0XRqg7bpMRESErNJiwBoRL4fa19HRAS8vL/zTP/0TJicn+c+I3F/kAScmJob/jKSUFttKKiJemN9aXl7Gr371KywuLqK2tha1tbWIiYnh+7fE8luAaxkpR4j4gIAAq/wWAcEQxyI4OBhjY2N23SSx6/P19ZWdkSKOlFKpRFpaGtLS0mAymXg3qaKiAhUVFYiLi+PvI1eAHGRIkLP+2N3dDU9PTzz//PMYHR3lDxLs5bcA56XFYpKKiCcDS2ZmJhYXF/Gb3/wG8/PzqKmpQU1NDe8mOXITdxsR7+xAKiQkBDMzM5Ld150i4sXqKYQHUgSWEx4eLqu0GLDcRyzLIi4uzmrod6a+vj4olUo8//zzPJ1UWE9BDofc+a0/r9xD1l9M7uHqzyEyJIg5Uva/xvKAIWdtbXQ0ArOz/njqqYub0IfMzfxWCW7dKtnMb7HQ641Qqy35LSmlxfbekwUR79iRCgycRlFRNQoLq3Hr1hFUVx/B4qIW7777nc38lsVNiozcnt8ChKXF8hHxMTG9CAqyXn+05LdakJ7egqUlDZqaLJ9RefkxWP4NmGE2U1he9oJKteL0tUhpsfOs3VZflq0jZVueKbYuwzCMQ0fKnlxZW5ucnMTMzAxOnz7Nh/WF4WuxdRlhRsreuprKQ4uoAGvHwFFGSqjQ0FAcO3YMpaWlqKiowJ07dzA3Nyd5XUYI5HBl/dH2+wrdJNt1GfL9PT09sba2Jsl13A1EvLP8FrleV4Eccu+j2dlZTE9P48SJE9Dr9fxBwuXLl7flt0hORA6QQygp64/C/NaJEydQUVGBe/fuYWpqCm+88YYoDdBWBMjhytqamCOlVquRm5uL3NxcTE1NwWAwgGVZXLx4kf/+3t7eWF9fl5SlkYOIJxKuP6pUqm00QJZl8ejRI6v8Fk3TYFlWcmkxkdSMlFAmkwnT09M4duwY0tPTRQ+kGIZBQkIC/5lJKS0Wk5T1R9sDqcrKSty/fx8TExN47bXXJB1IiZUWS70+MUfK3oEUcScBIDAwEGazWdLPP7L+ePjwYcnXJlx/1Gq1ogdSd+7cwe3bt935rT+z3EPWn13u4erPpelpf/T0xCM+vgtTU4HbHvrFJCwttuc+iUmIiFerl7F3bz327q3H9LQ/7yZduvQMrl4l3VIcNjbgQkbKsv64Z0+D5PVHigL6+mIRFDSBf/zHV/n+rbq6PDx8aKEBEmKiv/8M/3VygBxEUhHxGs0Sn98aHw/Gr3/9IwAUrl49ixs3Tmzmt1gkJXWJ5rcs18dIRMQvgvRl2XOkpKzLJCQkYG5uTvKDw04R8Vqtdlt5JsEdC9dl1tfXXcpIkRyR1LU1iqIwNDQEf39//PjHP0ZbWxtYlt22LpOdnW31y9uVHimpiHjhuszw8DDeeustrK+v49KlS7hx44akdRkyJOwGIt42v0WySdXV1aiurgYAJCYmYmlpSXJnmisZKaEj5ePjg4KCgm39W83NzdBoNDwxcW1tDTMzMygtLZX8OmTYlEPtUyqVGB8fh6+vL/7Lf/kv/EMgoQGS/JZer7fqFHKlR0oqIj4wMJDPb/X39+MPf/gD1tbW8Mknn+D69ev8YUtkZKTD+0gOIh4A2traRB0pR/ktkuFKTEzE6uqq5HVBWyCH1K8BwOdWhQdSxE0iB1IElrO6uuoSkKOxsRHp6emS34+npyemp6fh7e2Nf/iHf+CpkkIaIDmQEv6Mc1ZaLCapiHjhgVR3dzfee+89bGxs4MMPP8TNmze31VOIiQybchHxi4uL2/5t2B5ICfu3yAo4wzB26ync2rncn+qfTe7h6s8tg8HyQ/TJkwT84hc/QUxM76ab1GTXORIrLXYmgohPS2vd9n0DAmZQWHgbBQW3MTSkA8tauqWMRj2UyjUolavQahdhNkOSW2Q0ZlgBOaRIWFrs4bGOtLRWpKW1wmRS825SRUUpKipKER/fDZrmkJFhtOtIORLLyl9/nJ4OxOqqCl//+nvw9Z3bzG9l8fkt0r8VETHMf0bLy15oaUkHTXMSEfG3AByS5EjZrstcuHABra2t6O7uxksvvSRpXWZ4eBijo6O7hogn5ZklJSXo6ekBQfkS0ppSqRQluNnTThDxBQUF8PLykrQuk5aWZgXkkCqpGSmhlpaWsLKygueeew7e3t6S1mV2OyMllJeXFxiGAcMwmJ2dxeXLl9HW1oauri68+OKLTvNbwBaQw5WMlK0jRVEUIiMjERkZiePHj6OzsxMcx/E0QJVKBaVSKSuDtFNEvFarFaUB2ua3kpOTwbKsyxkpqeuPFEXBbDZjZWUF586dg1qtFs1v0TRtRbITZqR2GxEvzG9NTk6irKwM7e3t6OrqwgsvbK+nEJNYabEz2XOkhAdSp0+f5g+kCA1Qo9FAoVAgOjpa8ufgyvqj0JHy9fUVPZD66KOP+AMphmEQHx+/o4yU1OujKApeXpbNiTNnzvD3EVlvtncg5ay02NH1OUPE+/r64tChQzws58aNG+jo6HDntz5luYesT13u4eovIYsjRSM2tgfPPfchDAYLDfDy5adRVmahAdI0h5SUditHyFlpsZgIIt6R42PJbw1CpxvEiRPX0NycgY8++ioA4K23/m6TBsht0gCn7X6frfVH6Rkpy7C53ZFSq03IzX2M3FxLfsvSLcXgwoVzuHz5LNbXPZCXV4P1dYWk/JYwI+UKIj41tQ0eHuuIiRHmtxg8fJiPBw9IfosFTRvQ1ZWA1VUvGS7gLczO/ld0dXWhqKhI8i8RrVaLqakpREdH49lnn922LkMecITrMpb3JJ6RciQpiHiKohAfH4/4+HicPn0aTU1NuHDhAsxmM37zm99IWpch1+fv7y8LEW9vbc3Rugx50Ni3b5/kdRlXEfEsy0KlUvEn147WZRiGQVZWFjo7O13KSMlFxPv5+WFubg6RkZF45plneDfJUX4L2FlGypEjpVAokJKSgpSUFCwvL6OxsRGXL1+G2WzGa6+9Jim/Ra5vtxDxQhrg4OAgPyQbjUao1WqYTCbk5+dLvo+EPVKuIOJJgTNxk4hTQvJb8fHxPDGxs7NT9rDpCiI+KCgIS0tLCA0NxVNPPWW13uzt7c07JcL8FnlPgDxEvKOMFJHtgRRxksxmM1599VWr/i1Hw+dOMlK295GjAykfHx/Mz88jPz9f9rDpKiKepmmoVCq+nqKxsREsy4oeSHV1dbkE5JCLiA8PD8fa2hqCgoJw+vRpqwMpUk/BMIysLQy3xOUesj41uYerv6QGB4kjdQH+/rMoKLiLw4fvYng4EixLo7HRQgPUaBah1zduku4G7TpSjiQXEa9UbmB11QtmswJ//de/3ywYZlBZWYLKSkt+i2FYZGZu5bcA56XFYiLDpjNHKjBwGsXF1SgqqsbAQBQuXXoaIyPhqK3dD6Mxi3eTIiOH7L72ThDxDGONiPfwWEdGRgsyMkh+Sw+Oo1Fefhzl5cegVpug1c4jLGxE4ivdhcHQAEBeGJs4UmfOnNmW3yLrMuQ0WphNklpaLJTUjBSRp6cnFAoFzGYzvvnNb/IQD2frMkJHSm5GKioqyqEjJVyXefLkCa5evYqxsTE8evQIbW1tktZlCCJejnuzurqK5ubmbY6UvXUZQgNUq9XQaDSyTt13iognNMBjx47xNECS3woMDOTvo8DAQJcyUizLykLEq1QqqNVqmM1mfPWrX+UdJUf5LWDLkTp48OCuIuIpikJUVBSioqJw4sQJdHR04ObNmzCZTHj48CE6Ozud5reA7aXFUmTPkdJoNFb5LXLYQmiAGo0GGo1GFtiFDJty7iNhabFwvVlYT/HgwQOEhYXxhy2+vr6SS4uFIsOm1PVHrVYLf39/mM1mPP300zxZ0tmBlLPSYntyhoi3PZBqbW1FZWUlAODhw4fo7e2VdCC1m4h44YEUgZyQAyny71ClUsnO2sldf5yenkZPTw9KSkq21VMID6SioqL4/Jac32Vubck9ZO263MPVZ0Fb1D4j/79RFBAZOYTIyCGcOHEDnZ2J4DgGDQ05qK3Nh6/vLBYXvZGY2Cn5dXaKiE9I6AZFYTO/FQDSv3Xx4jO4coXkt1gkJ3e4mJGK3MxISVt/JMTE+XkfpKc3g2FYcByD2to81NSQ/JbFTRLmtyzvSRqQQ6itPjL778mS36pFXl4tJieD8OjRPjx4cAAAhRdf/D+RkdEMmuaQmGg/v2U2L4LjHiE6OlrW6RxxpPR6Pf+/OVuXCQgIwPz8PFJSUiS/zk4R8WlpaaAoCvv377cqzyTrMqRbKj4+3qUhYWRkBMPDw5LXH0lA3WQy8Se1YjRAsfA1GTZdyUg5Wn+0XZch1D0AePHFF/lskrN1mZ0g4oVOgi0NkDzgkPxWSEgIZmdnUVhYKPl1yLCZkZEha/2RZVn4+flBr9eDoig+v0VogML8FsMwiIqKcilrJxcRr1QqkZqaiqtXryI+Ph7Z2dlW+S1CA8zMzNy2XuWotNie2tranDpSgYGBKC4uRlFREQYGBlBXV4eGhgYAwMsvv8z3bznKbwE7z0gREVhERkYGFhcX+fwWqaeIjIzE1NQUDh48KPl1yLApJyNFrs/b2xt79uyBQqHgaYDEcSPOJ8m4hYeHuwTkkIuI9/T0hF6vR2VlJWJiYngYjLMDKcBxabE9EUS8o38bYWFhOHbsGEpKSvDkyRPU19ejsdFSRfLKK6+I1lOIieM4BAcHQ6fTSb4+sfvI2YGUlPVmt7bL/UntmtzD1WdFhNqXltZq5QQJpVBsICWlAykpHVheVsFozOApd5cuPQOOY0DTHDIz7ee3ANcQ8dPT4oj4gIBpFBXdRmHhbQwO6sBxW/ktrXYBGxsUwsKGERAgJyNFu4yIZxgO6emtSE9vxdKSehNNT6Oi4thmfsvSv5WZ2QwAPJBDWkbKIo6jERg4iejoPkl/PihoEj4+8wAofO1r76O7OwFNTVkwGGj4+MzxxMTw8GGrz3ZkJAKjo/M4c0Z6GJusraWmpto9xbNdl2lsbMStW7cAAJcvX4bRaJS0LkOAHHIeNOw5UsLyzJ6eHt5xa2hogJ+fH9bW1hAWFiYrI+XK+qOwtFiv1/PrMsLwNSnPJOsyZrNZNpCDXJ8cRHx4eDg/bD/99NPo6emxogHaW5chQA5XEfH21h9VKpVVfstgMODOnTsAgKtXr/LuTUpKisMHHNvSYikijpQQES/Mb504cWJbfisoKAirq6sICQmRBeRwJWsnLC2maXpbfuvixYtW+a2kpCT+PnIlIyUVEU9RFKKjozE4OIiGhgacPHkSvb29qK2tRU1NDUJCQsAwDLKzs7etmZHSYlcQ8YmJiXYdKa1Wi3379mHfvn2YnJwEx3G4f/8+AODGjRvo6+tzmt8Cdg8Rb0sDtD2QCg8Ph8lkQlBQ0I6HTWfq7+/nHamcnBxJB1IbGxs7GjalrD+SeoqpqSk0Njbi6NGj6Ovrk3QgNTU15RIinuM4h4h42wMp0rvX2toKlUol+UDKLfeQtQtyD1efNXV2Jm9mpKQNPirVMjIymnH58lOgaRahoeOw0ACfxtWrJL/FIiWlY5tbxXEMgoPHZSHiCZDDniNFUUBU1CCioiz5rY6OZNTU7Ed3dxJMJi1++cv/uukmcQgImBH9HoBtafHOEPEajQm5uXXIza3D1FTgZn6LxoULz+LKlbMIDx/B2ponsrKku2xbiPgq2euP0dF90OuN0OuNm/mtVHAcjYcP9+PBg0MICxsBTXPIzubg5zcHlqWhUGxYOVLO1NXV5TQjJZRWq8WePXtw8+ZNZGZmIjg4WNK6DLDlSMnJSBFHyt4DtXBd5syZM2htbcWjR4/Q29uLxcVFvP7663w2ydG6jBREvJjE1h99fHx4GiBZl+E4jg9fR0REYHV1VdbDkysZKcDywB8ZGcmDF6Ssy7iSkZKLiPfz80N+fj6qqqqQmpqKoKAgGAwGtLS0QK1W825SdHT0tvf7aSDibfNbRqMRdXV1mJycxNzcHN566y3eTXKU3xIrLZYiMUfKNr/FsiyamprQ1NQErVYLnU6H5eVlWX9PJCN14MABlxDxZA1MjAYozG+pVCqX7qO+vj5ZiPigoCAUFBTgwYMHSExMRGBgoGg9RXh4uOh95Coi3t7PI+GB1MLCApqamvD48WPMzFh+h/3xj3/k3SRHg7GrGSkxap+zA6moqCjZGSkhkEPufRQSEsL3KtrWU9i6SZ6eni4Nm4ODg5iYmMChQ4ck/fnw8HCUlpaioaEBcXFx8Pf3F62ncOe3xOUeslyWe7j6rIrjaGi1C5IzUsCWI7Vv3yNERw/g8OE7GBqK5N0kkt/KymoETbOIihrAzIwFEX/0qOPSYqGEQA4piHilcgNpaW3o7k5ET08cjh+/jpaWTFRWlqKyshRxccRNMkKtXrb62s7OJLulxfZEqH179tTbXX8MDJxCcXEVioqqMDAQDZal8fhxLgDgT3/6Ju8mRUTYz28BriHiLY5UuFVpsSW/1YyMjGYsLpL8FoObN4/j5s1jSEjoxuBgJJKSuqDVylvFU6vVstb+iCO1f/9+xMbGSlqXmZ2dlQ3kINcnFRFPyjOHhobQ19eHo0ePorm5mQ9fO1qXETpSUiUFEW+7LkMGLgA4f/685HUZV9YfxRwpZ+syycnJ6OvrQ2JioiwghyuI+NbWVqyuruLAgQNISEjA8ePH+fwWOVUODAzkrzcoKEhyabHY9UVGRkpypFQqFXJycjA5OYmBgQEUFBSgpaVFlAZoG8KXAuSwlZD+KPbgLcxvnTx5Eh0dHeA4Ds3NFne9rKyMd5OcFbu6kpESQ8QLaYBi+a309HR0d3cjPj7epWFTLiJ+eXkZBw8eRHJystP8lp+fn+TSYluR9Ucp9Edvb2/k5+djcXERIyMj2L9/P1paWvDxxx/z79HegZQUIIetSEbKniMldiAlvI8qKiowMTHh9EAKcB0Rb+tICespRkdHeaBQW1sbTwPs6OhAbGysrNJiV9YfOzo6sLS0hEOHDiE1NdWqnuL27duorq5257fsyD1kyZZ7uPosy2RSb2ak6iQR8YhsHSmSTdLphnD8+HV0dSWB42jU1+fg0aN8BAePw8/PcgInZ0hwBRFvcaSykJbWhgMHHuLAgYeb+S2Lm3Tx4jmr/q2kpA4olRvgOPpTyUgRURQQHd0PX99Z1Nbug15vwMaGErW1+1BTQ2iAFjfJ33/W6mutS4snJV8fyzJQKNbtrj9qtUvYt68W+/bVYmIiCBxnGQCXlzXo6orHRx+9BZoudbous7KygpaWFtA07VJGiiDibddlyC9v4boMWf2Rm5EaGRlxGRFfWFiIwsJCKxqg2LoMRVEuZ6SkIuLJukxoaChYlkVqaio2NjYkrcsA9kuLHcmZkyC2LtPQ0IClpSX09vbi4sWLojRAW+0WIt42v0UecKqqqlBVVYXo6Gj4+vrKHjZJRsrV9UfiAgwNDfGEMqPRCI1Gw2eToqKi+PtIDpADkJaRIlIqlUhLS0N0dDSam5uRlJSE1dVVngboKL8F2C8tdiRn95Ewv9Xf38+DDpaXlzE4OMgPgbY0QFuR0mJnLo/Y9QkdKWf5rcTERPj4+MjuI9spIv7UqVP8uqUQKOTr68vDcsjfCxkS5AybJCMl5T4iB1JJSUl44YUXEBMTg5WVFasDKdItJfZv+tNAxIeFheH48eM8UIjcR2tra1hbW0NFRQVs6ynEJARy7AQRL6ynIAdSLMu681si+nK/e1lyD1efBxFHSsqQQERKi+05UkrlBlJS2pGS0g6TSYXm5kywLI3ubssPnI8//gos/VtGuxkwIlcR8bbUPkt+qxqFhdUYHIziiYlNTVnQaheQkWFEc3OGQ0dK/PpcR8SXlFQgKGhqkwZo6d8qLz+G8nJLfothWGRkGKFSrUguLRZqY0MBg8Gy/qjVOkfEBwdP4ujRW5icDEJbWxr0+kY0N3vAYPij1bqMWBbAlYyUM0fKw8MDer0eer2eX5chq3KAJXsjZV0GsC4tlqru7u5tjpQtDZDgjsm6jF6vR1NTk0vDpiuIeAA4fvw4QkJCtq3L2OKOPTw8JJcWCyUlIyVUeHg4Tpw4gYWFBTQ3NyMtLU3yuowUIIetnDlSKpUKe/bswZ49ezA7O8s7Jf39ln+zlZWVkvJbgGsZKVtHiqIo6HQ66HQ6q/6t+vp6PHr0CMHBwfx9JBfI4Soi3mw24/jx4wgPD8fU1BT/ECiW3yLlyK5kpKSuP1IUhZiYGMTExGBtbQ0GgwHx8fF49OgRampqEBoayt9HYnkrUlos5z4i64/2HClhfmtiYoK/j7q6ugAA9+7dA8Mwom6SrXYDES88kBK6SQ8ePMC9e/cQHh6OrKws2aXFgOuI+I2NDZw8eRKRkZGi9RS2B1KktFgqkAOQt/5IDqQSExOhVCrR0NCAiIgIq3oKRwdSpLR4NxHxwgMpYdm5ML8l5UDqiyr3kOVU7uHq8ySOoxEcPA6dbvcyUkKp1cvIyalHWNgI3njjR0hPN2J8PBSXLj1j5SYlJ2/PbzkqLXYkliUZqe3rj5b81gCiogZw8uR1dHQkbzpue7GxoURHRwpu3y4ETXPbaIC2mpnx2xVEvIUGWIe8vDpMTpL8FoPz55/F5ctnkZ7egtVVDygU8oAcXV2JLq0/trZaSoufeuoSzpxZRlvbSw7XZQDLL+XAwECHpcW2MhgMAKQ5UmRdJjY2Fq+//jqSkpIwPj7Or8sIf3nbPuBsbGygsbHRZUS8mCNFURQSEhKQkJDAP+CwLIsHDx7AbDajp6cHDx482FaeKaadIOKFpcVS1mVWVlYAQDaQQ05GCrA4Ui0tLdDr9Th37hxPgxTSAKOjo0G6pcjfi1wgBwBZ1D4/Pz8UFBQgNTUVr732GuLi4tDX1ycpv2WvtNiZHCHiCQ0wNTUVJpPJ6jMCgKGhIdTV1UGv1zs9SReWFruSkSLOR2BgIJ/fGhgY4B03kt/Kysri7yM5Q4KriPjm5mbo9Xp85StfEc1vCbulyCBBHCkpQA4iZxkpoUg9BU3TeOWVVxAVFYX29nY+vyXs37KVsI9MLiLeniNleyBFDlvKy8sBgB8KpRxI7SQjJUTEOzqQ8vf3R3Z2NpaXLSv7cu4jVxHxhCL6ta99zWq92d6BFHlPzkqLbWWvj0xMpJ4iLy8Pv/jFLxAQEPClz2+5hyy7cg9XnzdNTwfsKCPlqATYVgQRf+7cBahUJgwN6Xg3yWjUb+a3LNkknW4AFCWttNhWJpMKra1pkhwppXIdaWmtSEtrxZtv/gATE8Hw959BRUXpJg2we5OYaIRKtbzt6+2VFjuSM0R8UNAUjhypQnFxFfr7o/mMm8mkgVK5hqqqIjAMi4iIYad/Z6S0OCWlTfL1NTdnWJUWe3jcQWZmMk8DFFuXSUlJQVdXF4qLi2WfRrqKiH/uueeg0Wis1mVYlhVdlyGOlJzTSDmIeLIuk5WVhd/97ncYGRmBl5eXaHmmmCuxE0S8PUdKbF2msbERq6ur8PDwQE1NjaR1GWB3EPHCdRlCA+Q4DleuXEFZWRlSUlKQmpqKjo4Ol4ZNuYh4srb2ta99DVqtlneTSH4rKCiIv4+CgoIAuJ6REusjE5NarUZOTg5ycnLw+9//HoODg1hfX5eU3wLslxY7Ell/FBugCQ0wOjoaJ0+e5LNJdXV1WF9fh6enJxoaGkDTtCSgwm4g4oX5LUID5DgO58+f52E5aWlpaGtrc2nYlJqREn4NAHzjG9+AVqvdRgMMCwvjM27Evevr68PU1BSKi4slv46wj8yZI+Xt7Y39+/dj//79ePvtt9Hf34/FxUV8/PHH8PLy4vNbYgdSgLwhgcgRIt72QIrAcu7evQuz2QwvLy/+Z60Up3wnGSlyH9muNxM3SXgglZGRgZaWFuTl5UkuLQZcW38kWwnf+ta3oNVqJR1IfVHlHrK2yT1cfV5lASkAvb2xaG5OR0pKu1OcuLC0WKrEEPE63SB0ukGcOHEdnZ1J4DgG9fV78ejRfgQHj4OmOfT3R8kqLQbkZaSIZmb80dcXiyNHbqG4uApTUyS/xeDChXNW/VtJSZ1QKjesHKnAQDmIeEYSIp6igJiYfsTE9CMpqR3vvfcdREQM4dGjfEF+y9K/5ec3u+3r7ZUWOxPHMQgMnERMDEHELwKoBXDI7rrMtWvXAFiKiDs7OyWty4yMjPClxVIlzEiRXzSO1mUiIiJA0zT6+vpklRYDWxkpuYj43t5eFBQUoKSkZFt5JlmXYRgGcXFx/MMIAXJ8Goh44bpMRkYG/vM//xPBwcFW6zKEmCj2y3snGSl7jpSfnx8OHz7Md0sJ12UAywNbb2+vpHUZYWmxVIk5UkIaoG1+KyYmBjRNo6enR3ZGiiDi5dxHCwsL6OnpwcGDB3Hs2DEMDQ3x/VtGoxFarZZ33HQ6ndV95Ki0WExSqX1KpRLp6elIT09HW1sb3n33Xfj5+fH5LVsaoK1IRmo3EfFBQUE4cuQIiouL0d/fzxMTiUM+Pz+PoaEhp/ktwLq0WM5BEVl/JI6UbT0Fx3G4ceMGbt68yTtuT548kQ3kcAURv7S0hJ6eHuzbtw8nT55ET08P7yYJD6QYhrG6Z2wdKSmSSu3z9PREdnY2srOz+ftIo9FIPpByBuSwJ5Zl7TpS4eHhVgdS5N9afX09AMvPwImJCUmHgbuFiHd0ICUsO/8i5re+eO/IZbmHq8+zC7rt5QABAABJREFUCEjBz28Gw8MReP/9b0GtXoJe3wiGYREd3S/qlIiVFjuTI0S8UrmB1NR2pKZa8ltGoyWbVFlZAgDw8ZkFyzKbNEDnK4OktFhORsqW2hcYOI3i4moUFVVjYCCKd5NIfisry4CoqAGMjYW5BOSQi4hvasqGWr2Ev/mb32F11WuTBkijvPw4ysstNECaZpGR0QyVyrLG09ycIXvYtI+IvwXAGl9L1mWKi4vxi1/8Aqurq+jp6UFrayu/LkNogGIiGandQsTbW5e5fv06AMuDfXNzsygNUEy7gYgnNEBH6zJRUVEuAzmkZqSImpuboVKp8Hd/93cwmUyiNEDbdRlXM1JSEfFkXebYsWN45ZVXsLS0hPb2dhiNRgQGBvL3EXGTbOVKRoqsPx47dmzbfxPmt2ZmZvjP6PLlywAAf39/dHZ2IiUlRdLp9k4Q8QzDWOW3hP1bjx8/5vNbNE3z/VNSS4sB6x4pOdS+lpYWeHp64kc/+hEWFhb4wxYhDZDkt8hhi6vDZnt7O/bv3+/w0EaY3zp16hRee+01PsNpMBic5rcA13qkHDlSWq0W+fn5yM/PtzqQ+uSTTwBYkPp9fX2SDqTI9Xl7e7uMiBfSAIX9W/fv37c6kIqOjnY5I5WQkCALEd/e3g4PDw/84z/+I2ZmZqwOpFQqFTIyMrYdSMkBchCR9Ud7GSki4YHU2bNn8etf/xqzs7NoaGhAfX29JBrgbiPiyYGUECjU2NiIlpYWqFQqHpbzRcpvuYcs93D1hdDgYBQmJkLw9NMXsGdPAzo7E8FxDFh2D+rq9iEoaALZ2RxomuOzQ1JKi8XEsowkRLxavYy9e+uxd2897tw5hPLyE1Aq13Hx4jNWbpIlv7WdhDgzI15a7EhCap+tI2WhAQ4gOnoAJ09eQ3t7MjiOQV1dHh4+PADAjNlZX8zM+DvNbwGuIuJVVqXFHh5LyMurRV5eLSYng0CIiefPfwWXLz+FjIxm0DQHlmVklRYDgMFgDxF/C8C/in7N6OgopqencebMGeTk5IiWZ5L8FnmQIxkpR6XFYiKIeGeOlHBd5s6dOygvL8f6+jpPA3S2LrOTjJQYIt7ZugwALC8vY2FhQdLQtBuIeE9PT6frMgzDgGVZ2RkpZ31kYhofH8fU1BROnjyJnJwc/jNytC4jBHLIyUhJpfb5+/ujoKAAhw8fxp07d1BRUYHl5WW899570Gg0fMGoWH4LcA7kcHR9Yo6UbX6LEOUqKyv5P2M2m2EymSSR0ISlxVJFHCmCiPfy8uJpgAMDA7yb1NjYCG9vb/4hkDgnn1ZGimhmZgaTk5M4duwYcnJyJOW3pJQWi4njOEmOFDmQOnLkCKqrq3Hr1i0sLCzgD3/4w7Z6CjG5iohnWVbUkfL09HR4IEX+zOrqqqQDqd1AxAvrKYSOm/BAimEYl4AcRqNR9vrjwsICJiYmUFJSgj179ogeSDEMY0UDlFJaLCYp648URfEHUsePH0d1dTWqqqrs1lN8nvUlHrLcw9UXSVvUPiMUig2kpHQgJaUDy8sqGI0Z4DgGVVVHUFV1FDExvaBpFmq1SVZpMWBBxLe2pslGxHd0pCIoaAL/9E+/wPCwDixrcZOMRj202gXecdPpBvmBiqw/ykPER0pCxCuV60hPb0V6eisWFrT4+c//GUrlBqqrj6C6uhjx8aR/q1k0v2W5PvmIeKPR4kiJfeZBQZObK4630N8fA5al0dSUtZkVMyM6uh8jIxEID3ee3zKbLcNwdHSfCCL+LoAVANvXfISOlLA809G6jJeXl6zSYmALES8lIyVUd3c3AgIC8Pzzz/P9W87WZVwZEqQi4oXrMrOzs3j11VcBWHplKisrna7LAOKlxc7kaP1RuC7T3d3N57fIukxMTAwmJyclZ+dsgRxSv4asralUKknrMp6eni4BOeSuP1IUhb6+Pvj5+eGf//mf+f6thoYG1NbWIigoiH/ACQwM5L/OWWmxmMbGxiQ5Umq1mi+Fnpqawuuvv46NjQ3cuHEDFRUVVm6SvdN7VzJS9hwpYX5L2C1VW1uLmpoaAEBsbCzm5uYkux07QcTTNG213myb3xI6bh4eHrJKiwHrjJTU9UeKojA0NAQfHx88//zzfEeZowMpwLVhkyDinTlSwgOpsbExvPnmm1hdXUVZWRkqKiqcHkgBu4uIVygUdg+k7ty5A8CyIr60tCTZxd8pIl6snkJ4IEUOWxQKBSYnJ3H48GHJr+MKIl6hUGBsbAxarRb/9E//xB9sCuspiOPmqOz8s6ov4ZDlHq6+aFpfV6CpSdyRUqmWkZPTgJycBszM+MFgsDglly8/DYragFK5hvV1JdbXlZJQ5ztFxCsUwvzWNXR2WmiAjx/nCvJbLLKzOXAcI7m0mIisP8pBxA8ORmFlRY1vfvNdhIeP8m7ShQvP4soVCw3Q0r/VCYXCMlhuOVLyEPEcZ0HER0fbX3+05Lf6EBPTh1OnynDhwtMwGPZgcFCH11//LwgLG+H7t/z85kS/B0HEC0uLt7SVyxLKkSNluy5DfjF98sknUCgUUCgUUCqV2NjYkHQ6SxDxch40Zmdn0d3djcLCQigUCqt1GZLfsl2Xyc7OtutIOZIriPixsTEsLy/ja1/7GkJDQ/mHwPb2drvrMlJKi8UkhdqnUCiQlJSEpKQknD17FhcvXkRjYyP6+/t5gpqzdRlXEPGO1h8drcsolUooFAp4e3vDbDZLcotaW1uxsrIia/AROlJKpdIqv0XcpFu3buHWrVt8fkuv1/NAjk8jIyXUzMwMlpeX8eyzzyIkJIQfkoU0QJqmrfJbzkqLHV2fM0S8ML+1tLSES5cuwWg0ore3Fy+//LLT/BYgXlrsTMK1Ndv1R2F+q6+vDxzH8euEHh4eUCgUCAoKknwfuZKREiLiST4zMzPTqp6CHEglJiby9RQ7AXLIRY+bTCY888wzCAwM3AYUIgcJwvuZDJufBiJeeCA1Pz+PK1euoLm5GT09PXjxxRetuqXs/SzcSUZKDBFP6imOHTvGH0gRGqCXlxfvOEnVThHxWq3Wqp6CVC98nvNbn4+r3BW5h6svqjo6LBkphnHsSPn7z6Kg4A4OH76Dnp44vP3290FRZvzpT9+ERrO46SZxiIoSz28BriHiOU4cEW/Jb7UhNbUNJpN6M79Fo7KyFJWVpZtf0wCTSQW1WtxNEoqsP8rNSG05UhbsfHFxFYqKqjAwEM27SY2N2fD2nkdWlsVxGxoKdwHIYUHEFxdLR8QrlesYHtYhJqYX3/rWu5v5LQY3bx7HzZuW/Jalf6sZXl4rgvfkuLRYLJflKCMlVHBwMEpKSnD06FF0dnbinXfegUKhwLvvvitpXcZyfdalxVJkj9onpAHarsvcuHGDd7GkrsvsBiLew8ODX5exl99iGAaDg4Oyh02y/iglI0Xk5eWF8fFx6HQ6fOtb39q2LmOvPHMnGSlHD9S26zJtbW3405/+BLPZjLffflvyugzLsjvKSAmlUql4GiDJlJD81tWrV7GxsYGcnBysr69Lym+5iogn64/EVYmKiuLzW2Sd6OHDh3x+i6ZpDAwMuJSRkouI12g0mJ6eRnh4OL75zW9Kym+R9yR32CSIeEeOFEVRiI2NRWxsLE6dOoWWlhZ8/PHHMJvNePPNN0XrKcTEsuyuIeJJPUV+fj7Gx8f5B3dST7G6uoqcnBzJA6Bw2HQFEU+G3/j4eCug0L1793D37l2rA6m+vj6XgBxyEfE+Pj6Yn59HSEgIvva1r4muN9M0bXUgBbg2bEpBxNseSDU1NeHSpUswm834zW9+I+lAilyfXEQ8WX+0fU/CAykhUEhKPcVnSV+CIcs9XH3RxXGWjFRSkjRqH0UBk5PBMJsV+N733oTJpAHH0WhoyEFtbT6CgiZA05b8ljDXtIWIL5edkXKGiFerTdi79zH27n2M6ekAfPjhc+jvjwHH7YHRqOf7t5KSxPNbgHhpsTPZc6Qs+a1+REf349Spa2hvTwHH0aitzUNNzQF4eq5Ao1mAj892EqA9uYaI3yot1mqXsG9fLfbtq8XEhCW/ZTDQ+OSTr/D9WzTNIj7+iYTS4luwzWWRjFRKSoqka6MoCvPz8zCbzfjOd76DpaUlSesyzkqL7UmKI2W7LnP+/Hk+W0LQ28LyTDHtJiJeGL4WW5dRqVRQq9WyXDY5PVJEQkfK3rpMa2sr1Go1n9+Kiori6Y9ygBxyEfEKhQKrq6vY2NjAt7/9bSwuLkpalyFADlcyUs4Q8f7+/igsLERBQQGGhoZw6dIlDA0Nob6+nu8LI5+Rvdd2FREvRu1zlN+qrKyERqOBSqWSderuytqaEBEfGBjI57f6+/t5N0mY3yKHLVJLi4WSmpEiIg7WxsYGvv71r/MQD2E9BclvCT9b4kg5A3KIXV9YWJjDzzwkJIQ/kOrt7UVZWRmGh4dRX1+Pjo6ObfUUYnIlI2XPkbI9kCKHLeRASqvVQqVSyQIEuYKIF5YW29IAyX1UX18Pf39/q24pe46UI3EcJwsR7+XlBa1Wi42NDZw7d47/eeTsQMpZabE9sSyL4OBg6HQ60f9OURQiIyMRGRmJ48ePo6urCzdv3sTjx48/F/mtL/CQ5R6uvgwiGancXHkZKeJIEepgSkq7VX7r1q2juHXLkt9iGBaZmU2CjJRB8usMDuowMRGCgwfvSf4aX99ZTE4GIyPDiMOH74JlGTQ1WdMAGYZDZOSg1bDHcfZLi+2JZKQcuYCW/FYL0tNbsLSkQW1tLioqjmF11Qv//u//Iim/JVZaLEX2EPHBwZM4evQWjhy5hb6+GHAcg6YmPQwGS5eWyaRBbGyPg+9sncsiqGuGYWStIXCcpbQ4ISEBFEXx4WtH6zJySouJhoeHMTo6KovaFxwcjJmZGaSmpuLgwYP8ukxDQwP8/Pz4Bxzb9S9XMlJk/dHRe/Ly8uJ/Gc7NzaGurg5VVVUAgJdeeonPbzlalwEsv5TlZqTsOVKO1mXIabMYJcue5PRICUWofSkpKaAoil+XIU6J2LqMK8OmXEQ8ecBZWFhAUlIS8vPzJeW3AMelxfYkhdonzG9NT0+jrq6Oz7e89NJLfP+Wo/wWub7dQMTb0gBJfuvRo0eoqalBQEAApqenceDAAcmv40pGilyfj48P0tPToVAottVTfPLJJ7h8+TLS09PBMAwSEhL4YVPOzyMhIl6KiOO2vLyMuLg47Nu3Dxy3VU9h70AKcD0j5cyR8vb2xoEDB3DgwAGMjY3h8ePHePDgAQDgZz/7maQDKWD3EPH2DqRIPUVISAgmJyexb98+ya+zvr6OxsZGlxHx2dnZUCqV29wk2wOpmJgYl4bN6elp9Pb24ujRo5IOiojjVlZWhqioKOTm5lodSAnXmz8r+a0v4JDlHq6+TGpqsmSk5Lg39hwp6/yWPzguGxzH4NKlp3H16mkolesIDR2Br694DkhMriHikzbXHzlERQ0iKmoQJ09eQ0eHNQ0wJGSMzyap1SbJpcW212dBxEtbf9Rotpyh733vd+jpiYOlf0uY32KRlNTF57cA56XFYrIg4rORktJu9bpCURQQG9uH2Ng+nDp1FW1tqbh27RRMJjWuXz+FhoaczYybwSa/ZZ3Lam5uxtramksZKdvSYrF1GY7j+HUZpVKJkJCQbQ+ljsRx0nqkhOru7sb8/DwYhuHzW2LrMpGRkbxTIizSlDtsykHE+/r68g+P3/rWt9Db2ytKA4yNjbX6bAmQw5WMlCNHynZdprm5GTdv3gQAXLt2DY2NjWAYxml55m4i4v38/HgaoNi6jEKhQHBwsMtADqkSIuKFbhLp3yL5rdjYWD6b5OHh4XIfmbOMlFABAQH8KuJzzz2Hvr4+NDU1WeW3GIZBZGSk1WdLHKndRsTb5reamppw69YtAEBZWRlaW1u30QDFZFtaLEX2HCkhDbCvr48/bDEYDPxnFxQU9Kn0SAklRMSL0QDFDqQUCoXk0mLb65ND7QsNDeXd9Keeegr9/f3bDqQYhtnm/joqLbYns9kMlmUdOlK2B1KNjY24ffs2AODGjRvo7u7eVk8hpt1ExAvrKWwPpAICArCxsYHAwECXgRxSRRDxTz/9tN16CtsDKTnO2m7rCzRkuYerL6M4jtnMSA3K+BrnjpS//wwKC++goOAOhoYice/eITQ1ZWNsLBwvvvjfeBpgVNSA3dVBVxHxxJESIuKVyg2kpbUhLW0rv8WyDCoqSlFRUYrg4HGsrXkiI0P6MLcTRHxsbA8SEp4gIeEJiour0N8fzbtJW/ktAxiGRUTEsOTSYqE6OxNlrT96eKwjKakTi4taMEw9oqKGwHE0bt48gZs3jyMxsQs0zQnyW7dAhiziSEVHR0u+Pim/IGzXZR48eICWlhaYTCa8/PLLktZlxEqLpV6fLSJeuC4zPz/PP+CQ8sywsDCsrq7K6vuam5tDd3e3y4j4tLQ0pKWlWa3LEBqgcF2GQBDkDptyEfEkD3T58mXo9XpERkZauUn21mXIe3IVEW/vPhJbl3n48CHa29uxuLiIV155hb+PHK3LkCFBbh+ZGCJerVbz+a3p6Wn+AefSpUu4evUqIiIisLKyIus+IhmpgwcPyl5bi4iI4KECJ0+e5El3JL8VEhLC30f+/v78sCnnPpKLiNdoNNizZw9u3ryJtLQ0REREgNAAiZsklt8i70luRqqxsdGhIyXMb5FuqdraWnR3dwMAXnvtNf4zcrTWuJuIeOF6s+2BlJeXFyIjI2EymWT9PZEhwVVE/N69e5Gbm+v0QMrHx8elYZOsPxYWFkr6876+vsjPz8ft27eRlJTEr586O5AC5A+bgHNEvNiBVF1dHfr6LPUqb775Ju8mOfp9tRNEvFKptFp/FNZTDA8P80Ch5uZmSfUUn6a+AEOWe7j6smp6OgC9vXEuZaTi4p44zEgRURSg0w1Bq12EQrGG5577GM3NGTb5LXYzv2X9/RyVFtuTyWTJSO3d+9iuIyXMb01NBcBgoHH7tiXU+u67f8X3byUldTpcodwtRLyFBtiPmJh+nDpVhvb2FLAsg0eP8lFTcxChoaOYnvZHQkKXTCAHIxsR39ycibU1T+Tm1iMmpg/79j3azG8x4Lit/Jalf6sBCQkbmJ+fF3WkHIn8goiOjpa0B05RFOLi4tDS0gKKovD000+jpaWFX5cRhq9tIQHEkdqNjJRQPj4+VusyLMvy6zLvvfee5HWZ3ULEO1uX0el0mJiYQHx8vEsZKVcQ8Xl5eYiPj9/mJomtyywsLEguLba9PmcZKSKFQoHk5GQ8efIE7e3tOHnyJNra2iSty0gBcthKCiI+ICDAKr9F4BQA8NFHH/E0QEf5LcC1rJ2YI6VUKvnB3WQy8au7FRUVqKioQFxcHEZHR0WpfY60E0R8fn4+EhMTUVxcjP7+/m39W2RIjoiI+FQzUkQkozMyMoLu7m6UlJSgtbUVN2/e3Na/Zbuu2NfX5zIiPj093e76o/BAinRLsazld+elS5dE6ynE5GzYFJMYIt7ZgVRSUhKGhoYQFxf3qWakgC1Hav/+/UhJSRE9kAoICOA/o+DgYJeAHOT6pCLivby8wDAMpqen0dfXh4KCArS1tVkdSDEMI0oDdFRabE/OEPHCAynbsnOy3kw+IzmbJDvR53jIcg9XX3YRal92tvQhgZQWHzokPSNFEPEZGS3Q65ug1zfBZFJt0gAZ3LpVglu3ShAb2wOaZqHXG6FWmySXFgtFEPFSB7PAwGnQNIvKyhLs3VsLpXIDjY3O81tCR0oOIp44UvYQ8bb5raYmPWpq9mN1VYWOjhS8/fb3Nt0kI1SqFdHvAQDLy15WpcVSxXH0ttJiS36rEkeOVKKvLxYsS8No1IPjNPDxeYkfkuRmpMbGxnDmzBnJX0OofWlpabwLIEYDFK7LeHl5gWVZSaXFQslFxIeGhmL//v24e/cu35EiZV0GkAbksJUzRLztuozBYEBtbS2Wl5fR3d2Nd999V9K6zG4i4oXrMqRbiqzLBAYGIjAw0GUgh5wiZkLtS0lJ4YdkKesyxJGSCuQA5CHiKYqCTqeDn58fHj58iIyMDCgUCjx+/BiPHj2yogGKnVwTR0pORsoZ/VGtViM3Nxe5ubmYmpqCwWBAXV0dlpaW8OTJE3zwwQdgGEbUTRJqtxDx9vJbDx8+xIMHDxAaGorAwEDZQI6JiQmXEfGJiYkoLCxEYWGhaH6LdEslJCRAoVDww6acjFRbW5tkah9FUYiPj0dYWBgaGhr4nKKUAylgZxkpe9cndiDV0NCAhYUFLC8v4/z585IOpGxLi+Vcn9CRcnYgFRUVhYCAAFFqnyPtBBEfFxeH0tJSlJSUWNVTkAMp4ibFxMSAoihJpcW2koOIVygUSElJQUxMDIxGIxISEmA2m//s+a3P4ZDlHq7csgwJDQ0MADP+8IfvITvbQgN0BlXYKi2WvrZGEPFCx0etXsbevfXYu7ce09P+fP/WpUvP4OrVM0hO7kB7ewpycuQCOSzrj1IzUgCh9gEFBXcQGDgtyG/RNvktFjRtgL//jMCRuiD5dSzrj9mSEfEazRLy8mrR0xOHuTkf5Oc/RGNjNs6ff1bgJnFITLTObwFbjpQcF3B21g/d3QkoLq4SdTYt+a1exMb24vTpMrS1pYJlf4y2tl4AwPvvv283fG0rsrYmZx1KDBHvbF0mLS0NRqMRpGRUqlxFxANAUVERgoOD+XUZlmW3rctkZ2fD29sbw8PDkkqLhSLDZnJysqT1R0IDHB0dxfz8PHJzc9HU1CRpXcZRabE9EUS8vfVH4iYlJydjeXmZf8Dp6uoCAP6By9m6DLCzjJTwgdrZukxGRgYaGxuh1+tlDZuuIuIB4MiRIwgLCxOlAZL8ll6vh1qtllxaLBQZNqVS+wIDA1FUVISpqSk+Y2c0GtHU1MTTAGma3pbfAlzLSDlDxBOYQ0ZGBhYXF3nHra2tDYAlCyglvwVsDZtyM1K2jpRYfotcl6+vL/R6PRobG10GciQmJkr+mqamJpjNZpSUlCAiIkL0QCopKYk/kPL09JRcWiyUXER8aGgojh07hqWlJTQ0NCAjI0PygdROMlL2HCmxAylCKASAqqoqSQdSwO4g4m3rKciBFFnfDQwMRFZWFjiOk1VaTK5Pq9UiOTlZ8tcYjUZsbGygtLQUUVFRf/b81udoyHIPV25taXAwClNTwdiz5zGmpwNRVXUEVVUWGqDFTWraNggQRyo9vUVS7xSRM0R8QMAMCgtvo6DgNoaGdGBZBg0Ne7CxoURjIw2FAmAYFjqd/fwWYF1aLG/9kbZypJTKdaSltSItrRUmkxpNTRbHraLiGCoqShEf/wQUtQGFwjUgh6uI+JKSShw9Won+/hi+f8tgoOHjM4esrEbQtCW/RVEWx8xZabGtLOuPlKTr8/BYQ2amEYGB02hrA/R6Paanp/nwtaN1GZKREistdnx9jhHxYusyBoMB6+vraG1txY0bNySty+wWIt7Zugz5RSc320IQ8XLcG6EjdfLkSRw/fpwPX9tblyHvSW5GiqytSXnQUKlUPFjhtddeQ2pqKqanpyWVZzoqLXYkR46UvXWZhoYGbGxsoKuri3/ocrYus1NEPLlPbWmA5IGL5LfS0tJgNlt+p8sZElxFxDc3N0Ov1+Opp57C6dOn+fxWbW0tampqtuW3yHuSA+QA5K2tabVa7Nu3DwkJCfjlL3+JxMRETE1N8fkt4iYlJiZue9Amw6ar649ijpRYfovjLPUUZrMZvb29uHfvnqQDKWFpsSvrjySvansgRaoXPvroIz5HSe4jOUOCq4h44mw+99xzWF1d5Q9b7B1IkfckNyNFqH1S3hM5kMrIyMDPf/5zxMbGYnBwkD+QIm6S2IGUo9JiR3K0/mh7IEVgOQTiMTIygkePHm2rpxATQcTv3btX1iDEcZwVIl54IDU0NMT/DhHmt5zVU8jRrgxZFEUFAHgDQBYsE9DfAmgF8B6AeABPAHzDbDZLZzfzcg9Xbm0XyzLw8FjFyZPXoFYvY2bGj3eTLl9+GmVlp5Ga2gaa5pCS0g6lcl3UkXImOYh4S35rEDrdIIaHwzE1FYiYmD48frwXjx7lIzh4HKR/SywPRhwpeRkp3baMlFBqtQm5uY+Rm2vJb3EcDY5jMDkZDIrawOXLZ2Hp3+rc5ibZameIeMt7suS3+hAT08fntziOwcOH+Xjw4CDCwkaQmtoqu7SYrD/KRcRzXA+UylicPXsWGo0GExMT/C9ve+syXV1dWFhYkPWLXA4inqzLxMfHY2pqCqOjo4iKisL9+/clrcu4iogfGRmxu/4oti5jMBgwOzsLhULBD4C25Zm2WttYxwfVN7CiMGMhUPoJJnGkyAqVbfhabF0mNTUVnZ2dKCwslPXL0lVEvEKhwDPPPAOtVmu1LmOvPPPTykgRkXWZlJQULC4uYmhoCMHBwTwNMCYmBgzDIDMzU/QB59NAxAcEBKCoqAiFhYUYHBzkH3AWFxehUChQXV0NhmGg0+mc/p25goi3daSE+a2lpSXecSP5rfj4eKSlpaG9vd0lIEd4eLhDqI3Y11AUhWeffRY+Pj7o6+vjXQlCAxT2b1EUJam02FZkSJDiSJEH6MzMTPzhD39AX18ftFqtKA1Q7Hu50kcmRMSL3QchISH8alpPTw/fA7i8vAylUomHDx9CrJ5CTDtBxJP35OnpyYNXyIEUy7JWB1Lp6eloaWlxadiUmpESfg1gIW76+vqK0gBtD6SklBbbiiDi09LSnLqtKpWKpwG+8847ePLkCSiKknQgBTgHcohpenoaPT09ooh4st6s0+msHDdSTxEYGAiGYSQdSDnSbjlZ/w6gzGw2f42iKC8AWliaPsvNZvP/pCjqfwD4HwD+X9K/pXu4cktc6+tKAbXP4kj5+8+ioOAODh++g+HhSLAsjcbGbDQ3Z0KjWYRe34jx8RBoNNJLiwHXEfG9vRZEfFHRbav8VmVlCSort+e3zGbL4OistNhWctYfAwOnUVxcjYiIIfznf/4VkpM70NmZJKABNm7SAIe2DTcmkwqtrWnIyXEVEb/dkfLwWEdGRgsyMlqwuGjJb3Ecgzt3LCeKnZ1JCAiYRkZGs8P8FmBdWixVGxsKGAz+SElJ4h8yg4ODrWiA5AGHnGRnZWVhbGxMVmkxsIWIlzP4zM7O4smTJygqKsLRo0clrcsA4IEccjJSctYfybpMfHw8/vjHPyI2NpZfl/H39+dD/LbrMo/HevGvtz9CXt80OrXr+H/XXEDZuX+Gp8L5qSRxpMQQ8fbWZSorKwFY1qKMRqMoDdBWO0HECx0psXUZAoQg5ZkjIyOySosB1xHx3d3dOHz4MEpLS/l1GZZleTdJbF1GDpCDyFlGioiiKERFRfF0yf/4j/9AZGSk5PwWcaQyMjJ2DRGv0Wis8lvEcbt27RoAS36uvb3daX4LsC4tlioxRDxxk8TyW2FhYaBpGsPDw59qRopocXER3d3d2L9/P06cOMGvNxsMBr6ewvZACpAH5CCSSu0THkjRNI23334bISEhvJvk7EBK2EfmSkZKbP1ReCA1OjrKf0bt7RaA0/T0NJ48eeL0QArYKi12JSMldKRsD6RYlrU6kKJpGoODgy4DOeTcRyaTCV1dXcjNzcWpU6esCuHtHUgBzkuLxSR1/VGpVPIHUt3d3Xj77behUChE6ynk5rd2PGRRFOUPoAjA3wCA2WxeAbBCUdQ5AEc2/9jvYeElSxiy3MOVW47V0ZGMpSWtqONDUUBk5BAiI4dw4sQNdHYmgeNoNDTkYG3NEyrVEu7cKdykATp3PHYDEW+d3wrAVv+WJb+VltaKqKg+2aXFJCOVltYqi9pnMFgcqW9+8z0AQHu7pX+rtjYPNTUHEBo6CtK/5e8/C8C1jNQWIr7SqSOl1S5h375a5OXV4pVXnsfamgcWFnxw/vxXrPq3EhO7RR03VxDxXV0WRDzDbP+hSWiAcXFx/LoMy7KoqanBxsYGNBoNHj58KGldBthCxLuSkSK/IITrMmNjY/xDIFmXyczMRHR0NEZHR2UDOVxBxBsMBqjVavzVX/0VzGYz7ybdvXsXd+7cgU6nA03TiEtNxi9a7uDtlgdIWlDA0+yFDu91DE+P4NeNt/FP9BGHr+MsIyUUWZc5dOgQXnnlFZhMJoyPj+NPf/oTTwO0ty4DuNZH5ggRb29dhpQwa7VaNDQ0SFqXIde30/VHKesysbGxskqLga21taSkJNEHWnsyGAzw8vLC97//fayvr2/Lb8XFxfEPOCS/IaW02FZyEPGBgYEoLi5GUVERXn31VSwuLmJgYADvvPMOn99iGAYRERF27yO5GSlHiHh7+S3S5ebj48MPnVKyUmTYdAURTwZ823oK0r9Fvnd2djZiY2NllRYD1uuPchDxTU1N8PDwwA9+8AOsra3xhy2ODqSklBbbSg4iPiwsDMeOHUNJSQl+9atf8d2Kra2t/IEUwzB2XfPdyEgJZe9A6urVqwAsPz87OzslHUiR69NqtS6tPzIMYze/ZXsgFR8fL6u0GHAdEd/c3AylUokf/vCHWF5e3rbenJqaCoZhkJycLGltcTecrAQAYwDeoiiKAVAH4CcAws1m89DmnxkGIMEz7wOgh3u4csuROI52mJEiUig2kJLSjpSUdjx4kI9r184gKGgKt24dxa1bRzfdJA6ZmdvzW8AWIr6kZPcQ8QEB0ygquo3CwtsYHLTkt5qasmA0Wu77wcEoREQMQ6cbdPqaWxkpOeuP2x2p9PRWpKe3YmlJzbtJ5eXHUF5uyW/RNIv6+j2ySosB1xDxw8ORmJwMxtmzF5GbW4e+vhiQ/q2t/Bbp3xoBIK20WEwsS9YfmwA8a/fPCddlampqUFZWBm9vb8nrMvZKix1JiIgXc6RCQ0O3rcsQNwmwnKSPjo5KWpfZLUS8cF2G/PIuKyvDRhkwrF5HgrcCKfNKzCk3MKyyDMovNZTjqYRsxPnad92c9UiJaWRkBBMTEzh16hT27dsnui5DHjbI57uTjJQURLxwXYbcR15eXpLXZeyVFku5PjFHynZdRpjfqq2t5V9zampK0rqMsLRYqmzXHz09PUXzWxcvXsSVK1f4bimWZT/VjBTRxMQExsfHceLECeTn5/NuEslvhYaG8k4JcQ2klBaLSSoinuS39u3bx99HAPj15vT0dDAMY+UmCbUTRLzY+qPwQErYLUVogIDl58Xc3Jykz4OUFsvNSAkdKZVKZbXeLHYgRe4je46UPblyH01PT2NsbAylpaXYv3+/3QOprKws/mePlNJiMUml9gkPpO7fv4/r169jbW3N6kCK1FOI/byxV1rsTPbWHx0dSJFDKfK6Ug6kdgMRr1art9VTCA+khPUU9rQbQ5YHgL0AnjebzTUURf07LKuBvMxms5miKNHJiaKoHwH4EQDExnrBPWC55UhLSyQjVSuL2tfcrEdIyBj+/u9/jdlZf4Gb9DSuXiX5LRYpKR388PFpIuIpCoiKGkRU1CCOHbuBF1/871Crl8GyDB4/zt3Mb7Gb+a0Z0e8hVlrsTMSRYpjtjpRGY0JeXh3y8uowNRW4md+iceHCswCAsLBhdHQkIylpOw3QVsKMlBTHkIisP+r1TZs0wD7Exvbh1KmraGtL3cxv7ceDB4cQFjYCmmbh4zO36UjJAXJsIeKVyhUA/x9JX9fa2orAwED8+Mc/tsIdk3UZYbeUcF0GkHcaOTIyIsmREq7LnDp1Ci+99BI8PDzw6NEjPHz4EBEREWAYhi/PFBMBcuwWIt7HxwfRWWn41XwrHsOE5EUlkheUKJ3wghlmTHiaEbGswLBqA6b1Vfzr/fP4w/Ef2B0cCJBDTkZK6EiJlWdyHIfq6mpUV1fz6zI+Pj47AnLIWVvr6OiAv78/nn/+eYyMjPADoKN1GVeGTZKRcrb+qFQqkZqaitTUVCwtLeHnP/85KIrC3bt3cffuXUnrMgTIIbdHyh4i3ja/RUh3hJoWERGBoaEhSfktcn07QcQrlUqkp6cjPT0dS0tLvJtUXl5u1S3l7e0tq7QYkJeREqqrqwu+vr74yU9+goGBAf6wheS3hP1bRLaOlBRJRcR7eHhAr9dDr9djfn4er776KjY2NlBdXY3bt287PZACxEuLncmRI+XsQIr070ldi90pIl6Y35qbm+NXwMvKynDt2jUkJyeDYRhotVpZpcWA64j4vr4+eHt746c//akVdMnegRTgWkZKKiJeeCA1MzODX//611hdXUVlZSWqq6v5Qnh7B1KA9GFTKHuIeOGBlBAoVF9fj0ePHjn8mbcbQ1Y/gH6z2Vyz+X9/AMuQNUJRVKTZbB6iKCoSwKjYF5vN5l8D+DUA5OV5mwHH2Qu3vtwyGvVYX/fgQQpSZOtI+fvPoLDwDgoK7mBoKBIcx8Bg2MpvZWU1IjubRUMDcaTEhxwxbWWkpFP7njxJxMqKGs899xHi4no381s0KitLUVlZiri4J7zjRjJoUkqLxcRx9Ob6o2NHKjBwCsXFVSgqqsLly2dRV7cPs7P+eOed727mtyz9W2L5LUC8tNiZiCMlhoj38FhHZmYzMjObN/NbWeA4GjdvngBghkKxjqUlDVZWvODl5fxniPX64yQsP3ccP9zYOlL21mXIKTv5RUocKSmlxUQEpCAHEd/X14fl5WU888wziI2NFS3PtF2XIY7UbiHi1zbW8UbTXbzYcANLa6uAF/DIaw21/ms4NOmJzAUP+K8BT4+qMKfcQIf3OhpW23Gxm8Mzidt/WYuVFjuTI0eKlGcyDIPZ2dlt6zIKhQJmsxlra2uSPg9XEPFCR0qhUPA0QLIuw7LstnUZmqY/1YyUUMPDwzCZTPjqV7+K6Oho/jMS0gBpmrZal5ED5BCK4ziniHhhfuvkyZO4cuUKHj9+jLGxMbzxxhtO81uAeGmxMwnXH20dGI1Gg7y8POTl5Vnlt86fPw+KokBRFDw9PbGxsSHJLdrJ+uP+/fuhVCrt0gDv37/P57fIfSQXyOEKIn5ychJLS0t49tlnERUVZXUgRWiAtgdSwtLi3cpIEQkPpM6cOYMrV66goaEBQ0NDePXVV3kaoKMDqd1GxPv6+uLgwYM4ePAgRkdH+WxSe3s7lEolKIqCj48PzGazpNfbKSLew8PD4YFUdHQ0SPXCToAccu6j+fl5LC4u4qmnnoJOp7MCCpH1ZpqmrQ6knJUWO7o+Z4h44YGUyWRCWVkZ/77EtOMhy2w2D1MU1UdRVJrZbG4FUArAuPn/vg/gf27+/+d3+lpuucVxNEJCxhAZKScjJe5IWWiAQ9DphnD8+PXN/BaD+vocPHqUDwAICxvF1FSApMJegoi3ADmkZ6TI+mNycgeUyg3s3fsYe/c+3sxvWdykixefwdWrp5GW1gqa5jA767M5bMoBclgyUnIQ8QDQ0xOP2NgefO97b2/SAGnU1u5DTc3BzfyWpX/Lz2+W/xpnpcVi6uxMwsKCj9P1Qkt+6xH27XuEoaEI/OY3fw8Pj1VcuHAOV6+e5vu3EhK6oFCIO+McR9sg4msBOF4rsOdISVmXSU9Px/z8vKSsCumRchURT/bpxWiAtusyMzMzsocEe4j4x2O9+B/3PoZxcmjb15gpIHxFgRGvDVwJW0bckhIpC0owsx7ImfVExZ8+gX/BHPL25FgNRs5Ki8XkKCMllJ+fHw4fPozDhw+jr68Pv/vd76BQKPDhhx9KWpcBXMtIEUfK9gRYyrpMZmam5HUZMiTsBBHv6ekpui5jNBqt1mUmJycllxYTzc/Po6OjQxYiXqlUYmhoCBEREfj+97/Pu0mO8luAa0OCVES8ML/15MkT/OEPfwBFUXj//ffh7e1t5SY5uo/kZqTsUfuE682Li4v8YcvNmzdRXl4Os9kMvV6PlZUVSa7ZbiDivby8ttVT2B5IMQyD8fFxl4AcUjNSRJ6enhgfH0dYWBi++93v8veRkAZIuqWEhwaubCVIRcSHhYXh+PHjKC0tRVdXF/7zP/8TFEXhnXfekZTfIte3W4h4ewdSZL15Y2MDWVlZWF9fl3Qg5WpGimVZKJVKvlNPrJ6itrYWQUFB/L+1sbExyaXFRAQRL2f9Ua1WY3p62uEB6m7RBZ8H8MdNsmAXgB8AUAB4n6KovwPQA+Abu/Rabn1JNTXlakaKdupIKZUbSE1tR2pqO0wmFd5775vo6YlHa2sGWlszttEAxUQQ8XIGH5NJvelIbUfEW/Jb1SgsrMbgYBRPTGxqyoJCsQ61eglmsxlmMyR9HjtDxF+AUrmO9PQWpKe3YGlJw/dvlZcfR3n5MSQkdIOmOaSmtsgqLSbiOHozI9Uu+WuGhyNgNivxV3/1FgAFWJaG0WjJlfn4zCE72wBL/9YI/zUzM6S0WIiIvwVHQxb5BRETE+P4B6pgXWZhYQEffPABnjx5gpaWFrS2tkpalxErLXamlZUVtLS0iDpShAZYWlqKJ0+e8A84DQ0NUCqV/O65VNkCOWZXTPhfddfwdssDmO2sewetUAheVeBu4ArWFECn9zo6vdehWQeSFzyQvKDErZvlqK6o5B9wUlJSZJUWE5GMlBxq39TUFDY2NvDd734X6+vrVusygYGB/C9v4bqMHCCH7fU5Q8Tbrst8/PHH6OnpgdFoRGtrq6TyzN1ExNtblyE0QE9PT6hUKlkPT3L6yIjI+uOJEyegVqutaICEmHjx4kUrxy0xMdElIIdcRDxFUVhcXMTGxga+853v8PfRo0eP8ODBAz6/RdO0laPhrLTYnqQ4UlqtFvn5+cjPz8fExAQuXLiA3t5evsxbjAZoq91ExAvdJKHjRg6kVCoVvLy8ZK107hQR7+vrK3og9eGHH1odSMXFxdl1pBxJLiJeoVBgbW0N6+vr+MY3voHV1VWn+S3AeWmxPZH1R0eOlPBAanh4GJcvX0Z/fz8aGxvR0dHBu0mODqR2gohPT0+3+h0lrKcgB1Isy/IHUhqNBp6enrJIhGT9UW7WjiDi7WlXhiyz2dwAIE/kP0lvCXTLLScijpScIWFggGSk7kr+Gk/PNYyMRCAz04hjx27w/VtCGiBNc5vO09aqnrPSYjEZjZlO1x8t+a0BREUN4OTJ62BZGhcvnsPKihd++9sfISRkjKcB2hskhaXFriDibUuLNZolPr81OUnyWwzOn38WSuUa1tc9EBo6io0NhdP8FmBdWuwKIj4mpn8zw9WL06fL0NZm6d+qqdmP+/ct+S2GYZGdbdgcNimbz/wWLK0T4hoeHsbY2BjOnj0r+do0Gg3GxsaQnp6O0tJSSesylvfkuLRYTCQj5egXBEVRSEhIQEJCAs6cOYOGhgZcuXIF6+vreO2110TLM8UkXH+89MSAf6u5iJHFWbt/HgBSFpTYgBmdWuu/2yUlYPBbg8FvDd+LYnCUCoHBYEBbWxs8PT2xurqKvXv3Sl6XEWak5K4/+vv7Iz4+HhRF8W4SCaiLrcu4kpEaHR3F8PCwLES8r68vJicnkZycjJKSkm3ha7F1GfKePg1EvO26TH19Pa5fvw4AfAEq+YwcDe9k/VHOA7U9al9gYCCf3xoYGAAhJjY1NUGtVsNkMsm6j3aKiCeYd2f5rYyMDJdACuPj45IyUkIFBQVhdnYWiYmJKC4u5jNu5JqF/Vu27+nTQMR7enpaHUjV19ejvLwcAPDyyy+LrjeLiSDi5faRAdvX1hwdSHl7e2NhYQE5OTmSX2en649paWlQKBTbaIBlZWXbHDchtU+qCCJezvpjeHg4FhcXERcXh4KCAv73GllvJo6b7WEkx9kvLbanjo4Op+uPtgdS9fX1vPP/8ssvSzqQAj49RPxuOVluufWpymwGGhr2IDh4HF5ey5K/juMspcVyMlJbiHgWAQEzKCy8jYKC2xga0vFuktGo38xvWbJJQUETkkuLra9PWkaKSKlcx/y85TT2Rz/6Nfr7o8BxDCoqSlFRYclvMQyLzEwjVKqtz0noSEmVEBHvaP0xKGgKR45Uobi4Cv390fj4469gaioI1dVHUFeXJ3CThu06bralxVI0M+MnWlrs4bEmyG9p0dhocbZu3DiBmzePwcNjDUFB4/D2XhB8t7twlMsSrixIlbC0WJjfcrQu4+/vL7m0WCi5iHhPT0+srFiya3/7t3/LP5g6W5cZHh7G6OgoDpYU429u/h7l/S1OX4syA0mLHujVbGBZ5HdcWkA4/teh55AXblm5Iw84ly5dwtTUFKqqqtDQ0MC7AI4cINvSYimy50ipVCqH6zKenp4IDAyUvfoiNyNF1h9PnDjB57fsrcuQz8jHx8fljJSc9Ue1Ws1/Zt/97nf5+8hRfgtwXlosJimIeIqiEB0djejoaJw8eRIdHR0oKyuDyWRCZWUlDAYD/xk5IrbtJCNl60gJ81uTk5NW+a3Lly/D09MTAQEBsrJ2riLip6encfToUYf5rfDwcP6wRaPR8NQ+OUAOjuPg4+Mjef3R29ubH0K+8Y1vYHBw0Gq92d6BlLPSYjGR+ygxMdGuI2V7INXS0sLj8isqKvgcq7MDKdvSYilaWlpCa2sr9u3bZ/VehTRAISynra0NKpUKHh4e8Pf335Vh05GEjpTYerPtgVRWVha8vLwklxbbXp8cRLy/vz+/0vrss89iaGho24EUwzCIioqyul+mp6c/NUS8e8hy63OhgYEoTE9bTkZefPG/b9IAOaSktNt1PsRKi6VoCxHfyf9vlvzWIHS6QZw4cR2dncngOBqPH+fi0aP98Paex/q6BxISOh18Z2tNTwegp8dSWiwXER8b24Pw8BGEh48gN/cxpqZIfovBhQvncOUKcdxYJCV12nWkHKmzM1kWIp6igNDQMczN+WHv3lokJ3fCQgPMx4MHBzdpgByys63zW4Dj0mJ7EnekrKXVLiI//xHy8x9hYiIY9+4dwuPHuZicDMELL/z3zfwWi4SEbigU4rksYUZKThEhy7LbHCl76zL379/HvXv34O/vj7W1NYfBW1vZy0g5E3GkYmJiEBMT43BdhmEYxMXFoYFtACgK/9JZjhnzqqTX0ZkU8F6ncN97zep/Vys98S97SvGjrEKrQmKFQoHo6GjMz8+DYRgkJiaC4zi+PFOn0/HERNs1QgLkECsttid7GSmhyLoMecC5f/8+OI77/7P3n8Ft5GmWL3wSAGHpPQl6bwGRopMXJUolla+20z1tZrpma3tm+87G7N4bsXNjInbfuG9MxLxbbqan2k3bqnbVXVVyJU+KlKcTqUwCoCdFL1L03sDcD8l/MgEmgMwkq7veCJ6I/tIligkwReT/Oc/5HaytreGtt94StS7D7yOTg4jnO1Ke6zKkn4iUZ0ZERGB9fV0S6W+niHgSmCc0QOIm2Ww26PV67gGHhNelHjbFZqSIlEol0tLSsLKygoKCAqSkpIBhGNy6dQu3bt3iCmzz8vK2PfiJAXJ4Sgy1Lzw8HMePH8exY8cwPDyMhoYGWK1WrKys4J133nFzk7z9DOQi4okjxb8n+PmtpaUlztki9RTR0dFYW1uT5D7sBBEfHR2NnJwc5ObmcjRAz4EUOSRHR0fLOiQQRPyxY8dE/Xni4pEKgeTkZNA07XcgRV6TVES8mPXHmJgYLr/15MkTNDU1oaODHXj927/9m6iB1G4i4vluktBAKi4uDisrK5KGlHIyUsAWIt5kMsFsNvsdSIWFhcnK2olFxO8dsvb0/xdiQQob+OY3P0B7ey4sli0aYH6+BWYzA6Nx2O2wwnekxEoMIp7Nb3UhK6sLq6sa2Gx5uHGDnch++OHXkZQ0wLlJvhwgz9JiMRodjRcsLQ4Lm8WxY3dw9OgdjIyw7pbFUgCrtQB6/RLW19VIShqARiM9IyUHEV9U9BgJCSPIzSX5rXzQtBnV1adQXU3yWzRyc9uxuqoTXVpMRNYfpSDiIyKmEBCwDoXCjq9+9ffo7MzlesGCguZRUFADszl92ySwt7eXc6TEiqya+XKkPNdlLBYLbt26BQD4wx/+IHpdxjMjJUbEkfJExPtal9EFGrC4tISnaofoAxbArgquUS4M6rb+PR0zZuGfD7zitR+LrD8WFRVxMAPP8kyCOyYPOCsrK7IzUkajUbCPzFOkPDMwMBAUReELX/gCV1TtSQP0XJcRC+Tgi6yt+XKkNBoNioqKUFRUhLm5ObS1teHOnTsAgD/+8Y+i12Xkrj96OlJ8GqBQfisiIgKLi4tISkr6TDNSwJYjVVxcjNTUVC6/Rdykixcv4sqVK8jOzobZbEZ6ejpWVlY4IIfUQ4JYRDxFUUhMTER3N5s/femll9Dd3Y3GxkbU19dzNMDCwsJtbouv0mJvImtreXl5Xh0pg8HA5bcmJye54Q8AfPzxx6LyW4B8RLynI+U5kCJAoQcPHuD+/fuIjY3F3NwcEhMTJWWkdoKI379/PzIyMlBRUYGJiQnOTfr444+h0WiQm5vLDaRWV1clAznI9YlFxCsUCqSlpWFwcBAdHR04c+YMuru7uYEUqacQGkgRIMduI+I9B1I0TaOpqQkAcPHiRfT29m6rpxCSnPVH4kjxEfH+BlKJiYmYnp5GQkKCLCCHvwHE3iFrT597ORxKWK0FyMnpRHLyIJKTB3H69M1NGqAJjx8Xobm5DOHhUzCZGJhMDMLCZgQdKX+SiojXateQltaPtTUtKiruQ6dbBcOYcenSy25uEiEHEvkrLfYmhjH7dKQoCkhIGEFCwgiee+46ursz8ODBIQwNJaG/Px0/+MF/4WiAISHeQSBbiPhHkjJSNG3eVlrM5reaUVLSjOnpcBBi4oULr+HKlRcQHj4FACgoEH/YfPo0Ds+eReOFF6Qj4rOzu5CV1YOsrB6cPUv6t0xoaAjEw4c/cluXCQoKAsMw0Ol0kjNSdrtd9AeEwWBAbm4url27hpKSEmi1WkEaIMkMEfkrLfYmf4h4/rrM4aoTePf6xxjo7Ee0SwHjmhKvPtWg22BHr96BVR9DRpUTSFlRosfggIMConSB+F9lL+HlVJPPD1ghR8rfukxkZKSs0mK5iPjMzEwUFBSgoKBAkAbIX5fR6XScIyWlj0xMRoqvkJAQ7Nu3DzU1Ndi3bx80Go2odRnAe2mxL/lbW/PMb9lsNjQ2NmJtbQ0DAwP45S9/KUgD9NRuIuL5NEDSLUX6twwGA3cfSXFH5CLiGYZBeno6V8BM8ls0TaO6utqt7Jys7IktLearq6tL0vpjZGQkysvLce/ePeTn50OtVnMPp2S92WQyCa6myUHE+3OkAgICuH9rZCDV3NyMlZUVDA8P4ze/+Y2ogRQ/IyVn/ZHvSEVHR6Oqqmqb4/b48WOEhIQgMjJSctZuenpackaKj4gvLy9HeXm534GUSqWSlZGSgognA6mQkBA0NjYiOzubu3/9DaQA76XFvuTvPvIcSJHhz9LSElZWVvCHP/xB1EBKCiJ+75C1p8+9uru3O1IKhROZmd3IzOzG2poGNlsuGMaMurpK1NVVIiFhCCMj8SgqapGckZKLiC8vb+QyXKOj8ZybZLPlQ69f2nTcaMTHj4ouLeaLzUiJR8SzNMBOWCyF0OmWUFlZC4ulELduVeHWrZNISSH9W+75LUAckMNTs7MhGBhIwfHj3hHx4eHTOH68DseO1WF4OBE0za5cAsAvf/nXXMYtJsZ7fgvYQsTn50tBxKdtIuK37iM2v2VDXp4NS0sRsFovgmFs3LpMSkoKBgYGYDabJa8shIWFISEhQfTXEEfqwIEDCA8PFyzPDA4O5h5woqOjRZcW8yUWEe9yuXB5wMKBLY6rAhCyTqE1dAMZSyocnFGjYsaFYa0T3QYHBnQOODwGtqnLSgS4KHTrHfhGdjn+cf8ZhGh8r1wuLCygv7/fpyPFX5fp7+/nDlwA8Jvf/IbLuPk7eO4WIt5zXYY4JWRdJiMjA729vZJLi+Ui4gHg0KFDiIyM5Pq3fK3LyAFySEXEa7VaFBcXY2hoCNPT0zh48CAsFgsuXbrErWKZTCakp6dv+7fmq7TYm0hGyhsinp/fIg4AwzBob28HAHz00Uei8lvAzhDxfEfKW37r/PnzuHz5MrKzs9HZ2Sn5kEBW7aSsP1qtVrhcLhw5cgQxMTGC9RSeAymxpcV88dcfxThSBoMB5eXlmJiYwOzsLEpLS2G1Wv0OpABxQA5P+UPEKxSKbfkthmHQ08NugHz66aeCNEAhyVl/FELEew6kyAo4GUjl5eVxhwQ5QA4piHibzQan04mjR48iPj7e60DKbDYjPz8fOp1OdGkxX1IR8SEhIThy5Ajm5+fR2tqKffv2ob29nRtIkXoKoYGUt9JiIe0dsvb0uRfDmGEwLHp1pDSaNRQVPUZR0WPMzYWAYQrR2FgOl0uJx4+LsbJigMlEIzOzx6crs4WIr5a0tkbT7qXFLA1wFEbjKE6fvo6engwwjJnLb0VETEKrXYFCIa20eCsjJQURv+VIlZY2o7S0GTMzhAZo4vJbOTkdMJkYpKf3QqFwgmHMkoAcgDREPEUBiYlDUCrtePSoFPv3N2FpKRCNjeWorz+4md+iN/NbC25fyzpSBTIQ8eZNRLzw+qPBMIWyMqCs7G+4dZnm5mbOuSBTSc/wtac8S4vFiOzH80uLPcszhdZlNBoNKIqSDOTwh4gfWpjGP9Vf5MAWnCMV6EBbMPu/sHUKGctKZCwpcXJKjXXKhX69A10GB55qnAAFZCwrsaKm8KPX3kBpbIqo6xOTkSJSKBQcCIFhGJhMJiwtLYlalyGHTamIeJqmfVL7goODcfjwYQ53zDAMWltb4XA40N7eDpVKJWpdZmFhQXZGio+IVyqV3LrM6uoq94BD1mWSkpK4g5/Uw6ZcRHx+fj6XTRodHXVzk/R6PfeAEx8fD4qiZGekxN5HSqUSOTk5iIiI4KiCi4uLovJbYoAcQhLKSPHFz28NDQ1xB66NjQ309PTgxo0bIP1bvrRbiHjPegriuJGBVFpaGrcaLTUjtRNE/OnTp3Hq1CmvAymz2cy5s0KOlD9JQcQHBASgsLAQRqMR3//+95GZmYmFhQVcu3YN169fR2ZmJkwmE7KysrYNW/iOlJSMFHGkvK0/xsTE4PTp06iqquIGUgzDwOFw4MmTJ7h165aogdROEPF8R8rbQOry5cu4du2am4sk5T4iGalDhw6J/hr++uOLL76Is2fPcuvNra2t3HozGWyGhYVxr8lfaTHR3iFrT59rraxo0dWVhZIS7xkpvkJC5nDkyD10d2dCpbIjO7sTFkuBR36LhtE4su0gtYWIF7+2NjJixPR0BA4duif435VKJ7Kzu5Cd3YXVVS1stjzQtBmDg+xk+ve//wuYTCS/5RvOQdNmrrRYrLYcqa2DWVjYDI4du42jR29jZCQBNG2C1VoAi6UQBsMiMjO7/TpSnuIj4sUUNxOR9ceTJ2ug061ieVnH5aSqq0+juvoU0tL6YDIxyM1th1q9Lrq0mC/xiPg6AAc5GuDg4CCHz/akAfpalwGkZ6SePXvm1ZHir8ssLi5yBaMDAwMAgHPnzolalyHX5w0Rb3c68FPrfbz1+CZW7Fu5K86RMmy9dzNqF5rUdjSH2BG3pkDmkhKpy0pkL6mwoHRiWA8krCpw6Mgh0Qcscn1iM1JExJF67rnnoNfrBddl+A84KpUK/f39WFhYkOTerK+vo729XRQinqIojgZInKK0tDTR6zJSDglE/hwprVa7bV2GpmlMTU2BoihcuXJFkAYoJCEghz+R9Ufyb4Of3yI0QIKDbmxsRGRkJHJyctDd3S35sEnTtOz1x+effx6BgYGC+S2+46ZQKCQDOQD39Ud/jhRFURwNcG5uDsPDw0hKSuJogCS/ZTKZBEEY5JCwm4h4ofwWwzCYm5sDRVGoqakRNZAC3EuLxcrTkfI3kIqLi0NOTg66urpkHTblIuJffPFFBAcHY2JiQtBNIv1bFEWJLi3mS0xGiogMpNLT07G2tob+/n7ExMSIGkgB8jJS/hwpz4EUqadYWlqCQqHA/fv3BesphCQE5PAnT0S853qz0EAqNzcXHR0dKCkpEbXdsnfI2tPnWlYrm5GS4t7MzIRiaIh1pI4cuYdTp25s5rfMHvktejO/NctlpFJS+n1mlTwlBRGv1a6iuLgFBsMiBgeTUVhIY3TUiEuXXnHr30pP79l2oFxdZYEcQqXF/q6PdaS2rz+y+a1hJCQM48yZ6+juzgTDmEDTZu5rlUonCgsZhIT47kGSi4hva3MvLdbrVzjHbWqK5LfMOH/+NVy+/AJyc9sxNxcMrVZaabF4RHwdSF/W3NwcBgYGuGmy0LpMbGws98EUFBQkurTYUwzD+MxI8RUYGIiKigpERkbiN7/5DXJycjA6OipqXcZXaXHLs0H8jwfnYJse2/Y9M5eUmFc5Ma7efu+5KGBU68So1on7YRtIXlGi3BGM3Fn2Z9rd2YUgQ6CodZmnT5/KykhZLBZkZmZyDwfe1mU6Ozuh1WqRl5eHubk5qNVqyRkpOYh4sv544sQJwXWZxMREkG4pQrD0dKTEiNxHYhwpsi4THx+PX//610hLS8OTJ09gs9n8rsvsZkaKSKlUIjs7G9nZ2VhdXeVId/fusQOs/v5+tLS0+M1vAbuHiOfnt4aHh8EwDKxWKywWCwwGAwoKCjAzM/OZZ6QA1pHq6+tDRUUFTp06heXlZe49qq6u3ta/RQ5vcjNSYtcfyUAqLS0Nv/rVr5CUlISOjo5t9RRCQBCSkZKLiBdypLwNpGprawGAK9EVogF6Si4injhSZP0xOjrajQZIyJutra0ICQmByWTC9PS0pNJiYCsjJRUR393djdLSUpw5c0bUQAqQBuQgEjtw5A+k8vLy8Itf/AJxcXFu681ksCn0uUpKi3cTEc8fSM3OznLv0fXr10W9JqK9Q9aePtdiGPNmRmr7g5/3r3F3pFgaYDeysrqxuqpBe3seGMaEuroTqKs7gaSkASQmDmJ6OgKHDws7UkKSj4hnHalXXrkAhcKJ0VEj5yYRGiDJJsXFjYKi5GakxCPi2fxWB7KzO/D97/8fAACDYQk1NVWoqSH5LRp5ee3b8luA99JiX+rtTfe5/hgRMY3KyjocP16HoaHEzYxbPtbWdAgIWEdNzUmw/Vvjfr+XeET8Vl+WJ7XPc12GfHjfuHEDN2/eRFpaGpKSkiSXFpN1RH8Zqe2viXWkvvjFL0KpVG6jAQqtyxBqH/9DeX59Ff/y6Dre76iHC65t38dgB+LXFGgJtgN+7qMwQyD+WyULtnjvvfewsbEBhUIhal2GvCapGSniSHn70BNal2lra8PGxgbUajXu3r0Lk8kkyjkTAnL4kye1z7M8k3x4k3WZrKwsJCcnS85IkftIbEaKf30ajQZf/epXoVAoBGmAxCkhWQepQA5gCxHvLSPFl1arxf79+7F//3784Ac/wMrKCtbW1nDp0iW3/i2h/BawdUjYLUQ8oQEmJia65beamprgdDqh0WjQ0NCAwsJCUateBCAhBxFP7iO9Xo/S0lKUlpZiampqW34rNzcXycnJGBkZkQXkkIqIb2trQ0BAAL7+9a+DoiiunsJzIFVYWMgdYuUcNqUg4slAqqKiAj/60Y+wsLCAubk5t3oKbwMpQF5GiiDihRwpQgNMS0tzy2/du3cPLpcLOp0Ojx8/FjWQAlj3ZqeIeP5Aiqw3ew6kUlNTZQM5pCLiLRYLVCoVvvGNb4CiKFEDKTGlxZ6SgogPDQ3FkSNHcPjwYfz4xz/G+vq66NLivUPWnj63mpkJw9BQkuSMlC9HSqtdQ1FRK4qKWjE7G4K2NjabdP/+EQAudHZmQa9f3qQB+qbqyUHEE0eKX1psNI7AaGRpgCS/9ehRCRobKxAZ+QwmE4POzizJGSm5iPiZmQi89NJFFBe3YHqa5LfMuHjxVVy58sJmfotGenofFAqn6NLi7dfnOyNFRFFAUtIQkpKGEBs7isuXX0Zc3CgaGsrx8CGb3zKb2fxWUNDCtq+fmwvBkycpOH68TsR9tAygGS7XAdA0jcTERG4Pmy8Svi4vL3dbl+ntZXODT548QXh4uKh1GX5psVgRN4SPiOeHr4XWZUwmE9rb2zkghyfYwpvSl1WgQKHH4PvfAx9s8fTpU0xNTeH5559HaWmp13UZs9mMpKQkUBTlRu2TetgUQ+3jr8skJSXh008/RWRkJO7evYs7d+7AaDRy4Wuh7++ttFjM9XlzpEJCQgTXZQh8YWxsDENDQ6LWZUhGSsoDNUHE5+fnc4deTxogcQFqa2uRlJQEk8kEq9UqGcghZ/3x2bNnePbsGZ577jmUl5dzZccWi8Utv2U2mxEXFweKomRnpMQi4kl+KycnBy0tLbh06RKCg4NRU1OzzU0SmqovLS2hu7sbBw4c2FFGiq+IiAhUVlbi+PHjXH6LuFwA68iMj4+LcrN2gojnO1K+BlKknqKtrU1SaTEgb/2RvP6qqiocPHhw20AqJCSEc0rIQEpMabGQ/GWkiNRqNTe8IPeRVqvFtWvXtvVvCa0mk4zUbiLiY2NjERsbu20g1dLSAoAdlExNTYkaSPFLi8WK70gRt9rfQMpkMvl0pLxJzvrj3NwcxsfHJZUW7x2y9vS51U4yUmIcKUICPHDgAd588/+CwbCIoaEkdHbmQqdbRkEBoQFuz2+R65OKiLda87yuP3rmt6zWPDCMGbdundy83hk8flwkSAP01E4R8WT9MTx8BseP38axY7cxPJwAhjHDas3n8lsFBW0IDZ2VVFoMsECOzs5sFBX5y0i5y2otRHj4FP7qr3652b9VAIYx4ebN0x79Wx1Qq9c3X1MhAErC9dVhbCwFk5OTohwpsi5z7NgxvPnmm9BoNOjp6YHVavW7LsNen/eMlDf5QsR7W5chaw7h4eG409yAX0zZUD3W5fsbudhVwXG1A/MB210uAMgOjcG/HPwCSmK2Hrg9EfFi1mVCQ0P9Ajk8RTJShYWFfjNSfNlsNoSGhuJv/uZvsLi4iLa2NtA0zdEAhdZlpAA5iAgi3p8jxV+Xqaqqwttvvw2VSsXBBci6jNlsFjz0A+IPm3x5ZqT4IjTA4uJit3WZTz/9FAD7YN/V1SUqv0WuT2pGil9azKcBestvkXD63NwcqqqqRH8fueuPHR0dCA4Oxne/+13Mzs5yw5YLFy7g8uXL2/JbgLzDplhEPD+/9dxzz+Hdd98FALS2tuLRo0fbaIBCkoOIJ31kQveR50CKDFs++eQTAGw335MnT0QNpMj1RUdHy1pbKywsdKun4LtJ9+/fx71797iBVFhYmKTSYsD9sCllba27uxsGgwHf+9738OzZM+5w420gBcg7bIpFxPMHUs8//zz+7d/+DU6nEw0NDWhoaODqKbwNpAB5GSlfiHh/A6no6GiMjY0JrjcLaSeIeCnv+d4ha0+fSxGQgtSMFE2Lz0gR9fRkYG1Niy9+8WOkpfWitzcDDGNCS0sxmprKEBExCdK/RQ4sYkqLheQrI8WXVruK/ftbsH9/C65fP4X6epaYQ2iApH8rPb1X8PuT0uLdQsSzNMBhJCYO48yZa+juzgRNm9HUVAanUwmKcmJiIhpxcWMIDvad3wK2SouluICsI7VVWszmt5pQWtqEqakIEGLi+fNfwOXL68jNbUdhIQ2aNm8COcSVFgN1YJhiKJVKydS+1dVVvPLKK0hPT+fWZR4+fOh1XUbIkRIjsYh4/rrM9evXUV9fj9mlRdRduQ4j5cJRfQC6DQ6MbdIAPRW+QSF8Q4F7Yevb/ptWGYB/2HcSbxQcQYBi6yFbKCNF5G9dhqIozM3NYWlpSdS6DFl/lPKhRzJSR44cAUVRotZlzGYzaJqWDOSQs/44ODiIlZUVfOlLX+KAK/7WZYQcKbHXJ8aR4q/LXL9+HQ0NDVhaWsLvf/976PV6rn+L0AA9JVRa7E++HCl+fmtlZYV7j0iZN0VRWF1dxdramqiH3Z0i4hUKhRsNcHh4mCMmkvwWcUpomhZdWkwkZ/1xdHQUy8vLeO2115CRkcENWwgNMDU1FWaz2Q0HT6h9YoAcntcXFBTk15GKjIzEyZMnceLECVy7dg2NjY2Ym5vDBx98gKCgIM7Z8fbeEES8lAO0L0Q8oQEWFhYKDqSIM7qxsSHq3xUpLd4JIp5fT+E5kAoNDeWGLZ9lRoqviYkJLC8v4+WXX0Z6ejo3bPE1kJIC5PC8Pn+OFH8gdfr0aVy7dg1NTU2YmprCz372s231FEL6UyDiifYOWXv6XGpkJAHT0xEIDp7D8HACjMZhv6teW6XFHX6dHr74iHiFwomsrC5kZXVhdVUDm411k2prT6C2ls1vmUw0NjYCZGWkWES8/4wUkcsFdHdnIzn5Cb797V9iZMQI0r/lLb9FXhPrSInvkerpEYeIJ/mtnJwOzMyE4Pvf/3sYDMu4deskbt06sekmMcjNtUGj2f5wzl6faVtpsT9trT9uf88jIqZQWVmL48drMTSUBJo2wWZjKYUAEBLSg/HxGMTE+M9vOZ0PYLGcQlZWFvcQK+76tkqLyQHN37rM2tqapNJiQD4i3trVgXm9Eh9GzAnSAHsMDvQYHJjlOVaZS0o44EKf3t1tPGbMwj8feAXJQdsPHGIQ8YD7usz09DTee+89aDQa3LhxA9XV1X7XZYDdyUjxxV+XId1S/HWZjIwMTE9Pi4KayM1I8R2pgIAANxogcdw812XW1tYkZ6TkIOIpisLAwADi4+Pxne98R1R+i7wmqT1SZP3R3wO1Tqfj8lvPnj3Dj3/8Y6hUKly+fBnXr19HdnY2zGazm5vkKV9ADm/ydh95y281Njaivr4eAJCZmYn5+XlRa2hyM1J8R0qtVnM0QH5+69y5cxzZz2Qycdk3OYdNMRkpIoqiMDIygpiYGLz++uuC9RSeAylAfkZKDCKeP5AaGxvDz372MygUCly4cAHXrl1Dbm4uzGYzRwMUki8ghzd5c6R8DaTu3r0LgF3tXVlZEbVeLQTkECOy/kjqCw4dOuQGFLJYLNxAKj8/H6RGQ2pGiqw/islIESkUCoyPjyMyMhKvv/66IA2QVC/wP8vl3EcEEX/w4EHRXwPsHbL29DkVTZuhUDgwPJyIn/3sbzZpgMwmDVDYkdgqLRZ/8OEj4hUKd0dIq11DcXEriotbMTsbCoYpBMOY8emnLwNwQa1exfx8IGJiFKLcLLL+WFgo/vr4pcUsDXAECQlsfqu7Wyi/RSM/3wKLhT1sygFySEHE9/enweVS4i/+4vfQ6VY4N+nChVc5GqDJxCAtrY97f2dniSMlFRHv35Fi81uDSEoaxNmz1/Dhh19BT08GnjxJxY9+9LeIiXkK0r8VFLQo+Hf09sZjaUlc0SDR2toaOjo6sG/fvm0fEL7WZSiKglqtxsbGBufk+JPUaeT8+ir+f7XnEDA9CyZsHaCAMa0TY5s0wJQVtuvKPK9C0XwAnqmd6DbY0adzIGNJhSGdE2ubLylKF4j/VcaCLXw9aGi1Wklra0NDQ3A6nfiLv/gLaDQaUesyno6UWIlBxCsUCmRkZCAjIwPr6+v44x//iJ6eHvT09OD73/++qHUZodJif1pfX4fNZhMsLeavy4yNjXET7vb2digUCqjVaigUCtH30U4R8Z64Y8/8VnJyMpdNknvYFJOR4mt8fBwOhwNf//rXoVar3fq3CA3QZDJx+S2AzZn4Ki32dX3+HCmSzcnNzcXy8jI++eQT9Pb2oru7G++8847f/BYgXFrsT74cKc/8FnmPGIaBUqlEQECApOGSlB4pIj4inr/e7GsglZ2d7dWR8iU5iPiZmRk4HA585StfQUBAgGB+y2w2u+Us/ZUWe5MYR4o/kFpYWMD58+fR19eHrq4uvPXWW8jIyIDZbHZzkzy1m4h4iqK4gRS/7Jys7wYEBCAgIMCrkyQkm822I0S8UD0FWW++evUqN5DKyMjggBxSHCk564/A3iFrT59DsY5UPvLybHjxxU9hs+WCYcyoq6tEXV0lEhMHYTbTyMuzupXR+istFpJYRHxo6CyOHr2LI0fuorMzGx9++DW4XAp8+OHXodcvcf1b8fGjggcHsv7ILy0WI0Lt83SkWDepEzk5nVhZ0W66NibculW1meGiYDAsYm1NI8rV2zkins2tHT9eh2PH6jA8nMgRE9vaTDAYFlFY2AaTiUZ3N5s9knIYHhuL20TEXxL9NQqFE2Nj8cjN7cCLL34Ki4V1tm7efM6tfysnpx1q9VYnFMOYoNNBUkbKZrPBbrf7Pfjw12VsNhs++ugjOBwOfPDBBxwN0Ne6jBREPB9skTqygjwotzlSDgXQa3Cg1+CAzgGkLymRuaTCwRk1KmZcUIDCvMoJpRP4Wu4W2MKbCCJeakaKOFKJiYmgKIpblyHha6F1mc7OTq+OlDfJQcSrVCqMj48jOzsbzz///LZ1GfLhnZmZ6faa/ZUWC4kg4n29JoqiEB8fj/j4eJw6dQpWqxXnzp2D3W7Hz3/+c1HrMoA8RDw/I8WXZ36LPOBcunQJly9fhtPpREFBARwOh6gp9U4R8ampqVyGi+8mNTc3o6GhgctvERiMHCDH2NiYJMiITqfD5OQkMjIycPbs2W35LeImpaWluT2kM4zv0mIh+cpIEfHzW+R6Ll26BKfTiZ/85Cei8lvk+nYLEc8fSJFsEsMw+OSTTxAQEICNjQ3k5+eLHiTsFBGfkZEBhULhNb8VHx8PUuFhs9kkHzanp6cxPDwsidpH+ttSU1Px3HPPbQMKETeJP5ACtg4JchDxvu4j/kBqbW2N+90IAO+9956ogRS5vt3KSJF6isOHD28bSGk0GqytrUm6j4SAHGK1d8ja0+dO3d2ZnCOl0ayhqOgxiooeY24uhOcmvYSrV88iK6sLJhONhIQhr46UL0lFxFMUMD7Ofph897s/xLNnUWAYM1pa9qOpqXwzv0Vv5re2DlMjI8SRui/62hwOBbf+6MuR0ulWsX//I+zf/wgzM2H43e++hsnJSDQ2VqClZf8mDZDh1iGFJFRa7E9biHh3R4rNbw0hMXGIy28xjBmNjWWorz8ApdKO0NAZSYc5mpa+/rhVWkxDr19GWVkTysrY/BZNm9DWZsK5c19AQMA68vJsMJkYxMaObpYWj4leWQDYX/bh4eF+M1JEFEVhZoZ15N544w1MTEyIWpchpcX+gBxDC9P4p/qLqBnuAOUCqpa0GOQ5UkJaUQKWYAcswQ6ErVM4OalGqB0wLQSgeE2PgkgFZsbGEexjXUYIEe9P8/Pz6Ovrw9GjR93+Xn74+oUXXti2LqNSqRASEiJ5pXMniPjg4GDBdZmOjg5uXYZATsSWFntenxRqn1KpxNLSEgDgO9/5Dncf+VuX8VdaLCSx64+hoaE4evQojhw5gtHRUZw/fx6Tk5N48OABh6c2mUxe81uAbyCHN3lzpPg0wJWVFc61uXXrFm7dugW1Wo2QkBDJK1RS1x/5iHh+fotPAyS0PUJMDA8P31FGSuz6o0qlwsYGO2j61re+xd1HJL+VlpYGUnbOvw5/pcVCIlm71NRUn4e3qKgobiA1MDCATz/9FFNTU7h//z7a2tq21VMIaTcR8Z75LTJsIfUUGo0GwcHBkvsRAWkZKb4j5a2eoqWlxW0gFRISIgvIQRDxYql9Go2G+7f39a9/naPK+htIzczMYGhoSFZGyhci3nMg1dvbi+vXr2NtbQ13796FzWbjBpu+BlJyEPFEe4esPX3uxDAmQUcqJGQOR47cw+HD9zA2Fsdlk9rb8xAQsA6HQ4WYmDG4XBC1hrZTRHx4+AzCw2c4GiCb3zKhtvYkamtPIjn5CUwmBnl5VkgpLSbaykiJd3x0uhVMT4ejpKQJJlMb5yZt0QBZxy02dsztNTOMSRSQgy9fGSkilcqB3NwO5OZ2YHlZhwcPDuL+/SOYnQ3DO+/8A48G2O41v0UQ8fzSYjGiaWFEfETEFE6cqEVlZR0GB9n+Las1HzS9D1rtCuz2ACQmNoP0ZfnT3Nwcnjx5IjkjRRyp6OhoREdHc+sy5MPbc10mJyeHW+nxBuSwOx34qfU+3np8Eyt29qHJuKqA3kmhx2AXdW0AsKhyIchBQZsShy8cPglbm8XvugzAfiiHhYUhMTFR9Pfy7CMTkue6zIMHD1BfX4+5uTm89dZbguFrT+0mIt7bugxN03j06BEMBgM2NjYkoal3iog3Go0wGo0+12XMZjMyMjI4+qOUwyZZfxTr3lAUhejoaMzPz8NsNiM3N5dbJ2psbPSa3yKvSWpGSsz6o06nQ0lJCUpKSjAzM4OHDx+iqakJ6+vrePPNNwVpgJ7aTUQ8300Sym8FBwdjbW0NGRkZor8PyUhVVFRIXluLjY1FSkoKUlJSUFZWxtVTtLW1cfktfreUnMPm4OCgqIwUEXEkFxcXUVBQwK0NetZTFBQUbPt5EEdqtxHxgYGBOHDgAA4cOICJiQk0NDSgpaUFq6urePvtt7n3yFd+S25GSsiR8hxIkWwSGUiFh4djdXVV0go3yUiVlpbKWn/MyMhAZmbmNqCQ50AqISFB1mFTKiJeqVQiPT0dKysryMnJQVZWluBAKj8/f5tbJQbI4U17h6w9fa60lZFq8uq6UBQQHz+G+PgxnDp1A7296Th//lVsbATg4sXXcO/eUc5NCgub9fq92IyUC9IQ8QmCiHitdhXFxS0oLm7ZzG+x2aRLl17G1atn4XJRMBpHEBCw4eVvFro+8yYiXnxGiu9IGY2jSEgYxpkz1zfdJBOam0vQ0FCBqKgJmEwMCgsZuFwK0aXFRPyMlFhEvF6/go2NACiVdrz++k/R2Zmzmd96za1/Ky2t3+1n76+0WEhiEPEU5UJy8iCSkwdx9uxVdHZm4fLlFwC4cO7cS3jw4PswmQ74XZchhwQp7o03R8pgMHDha891GbVaDafTifj4eMGVhZZng/gfD87BNu3uymYuKbGqcGFQJ945PKMxQuWaxl+eeB6JiYnISs9w698SWpdxOBzo7+/f5kj5EnnQSEhIEE3tCwoKAkVRUCgU+OY3v4muri6OBuhrXaa/v/8zQcR7rsu0t7fjxo0bAIBPPvkEjY2N3Hvky3XzBeTwJm+OlOe6DB93rNPpYLfbYTQaZR02pa4/rq+vY9++fUhJSUF2djZWV1c5N8kzv5WXlwe73S66tNjz+qQg4sPCwjhX5mtf+xq6u7vdaIDETYqNjXW7Dl+lxd5E6I+5uble1x8981tWq5WjJX788cdobW3l8lu+XC1SWrwbiHhST1FZWYnBwUHOcaNpGkFBQVhbW4PRaJQE5CDrj1LW1ogjtW/fPqSnpwvWU9y4cQPp6ekwm83Izs7GxsaG6NJivqQi4qOjo7nD3Re/+EWuvoPUU3gbSPkqLfYmMYh4tVoNs9kMs9mMhYUFtLW14c6dOwCAc+fOwWKx+B1IAfKydkKIeD4NUGggFRYWhpWVFRiNRkmlxTtBxBcVFSErKwtFRUXb6in4ZecZGRnY2NgQXVospL1D1p4+VyIZKbHUPqXSiaioSaysGHDsWC1CQubBMCbU1Z1AXR2hATLb8ltbiPgnEhHxJr+OFJvfuoMjR+5gdNSI27ePobs7C4ODyXj77f+OggILTCbv+S1AuLRYjBjGhMjIZ26OFJ8GuLKihdXKZpNqaqpQU3OSOyRlZ3eK/j4EEX/ggFREPFtaHBf3FHFxT3HsWB2GhrbcpLY2EwIDFzhiYkzMU4gtLeZLKiJepbIjIWEEKysGHDx4FyEhC2CYF/yuy7hcLp+lxd5E07RfRLznuszdu3fR19eHoaEhvPvuu9yHtyYkCP/y6Dre76iHC+5dVgFOIGVFiS6DA04Rz6sEbDF79zHmwlxu649qtZpbl1lYWOAecMi6DDkkSfnQGx8fx8TEBJ5//nnRX8N3pMjU3du6DHFKIiIiZAE5pCLiNRoN0tPTsbq6irKyMgQHB4talwHkZ6R8OVL8dZnTp0+jt7cXDx48wMDAAIaGhvDee++JWpfZTUS8VqvlaIAzMzPcA86lS5dw9epVREZGwuVySXLZSEZKDiI+IyODA3gI5beioqK41d2QkBDRpcV8iclI8aXX65GXl4erV6+iqKgIQUFBYBgG58+fd+vf8sxvAeKAHJ4ijpSv+yg5ORnJyck4e/YsOjs70dDQgKGhIQwPD+PHP/6x4Hqzp3aakeI7Unwa4LNnz7hs0scffwy1Wo2oqChZpcVyEPGktJgAPPzltwwGAwi1T2pGSgoiPigoCPv27UNNTQ33sxGqpyBZWL52goj35mwKDaQaGxsxMzODkZER/OxnP+MK4X0NpHYTEc+vp+APpGw2G3Q6HaKjoyUDOfjaO2Tt6XMlhjEjKmoCsbHiMlLs17COVFFRK0JC5lFU1IrZ2RC0tbFuEslvsd1SDDIyejA6GrfpSN0V/X0IIj47u1MUTIKiwLlXOt0SXnrpEiyWQjx6tB+NjeWbNEDWTfKEYfgqLfYmkpHyhYjX6VZRUvIIJSWPMD0dBoYx4e5ddpL205/+J85NSk/v85ltI4j4/Hzx64+9vdvXH1ka4BCSkoZw5sxVdHVlbea3ylFffxCRkROYno5AYSEjqbR4J4j4kpJHCAubRVlZCCYnf8u5SefOnYNareYC6ikpKXj69Kno0mIi0iMlFhFPURRSUlLw6NEjaDQanD17FlarlVuXmdUA7bp1aA0urHgM2lKWlVC5KHQb/L9338hmwRbU2gbeeXLe5/pjUFCQ27oMTdMcnvoXv/iFIA1QSJ6lxWIk5Eh5W5e5e/cu7ty5g/j4eDx9+lRWRkouIr6srAwRERGi1mUmJiZElRbzJRURT2iANpsNY2NjqKqqgtVqFbUuIzcj5Q8RHxYWxuW3RkZGuMMNAHzwwQecm8SnAQqJADnkIOL5eSJv+a2amhrU1NQgOTkZw8PDsoAcUjJSwNb6Y0VFBaKjo91ogDabjctvkUNybGys6NJivqQi4lUqFfLz89Hb24uxsTFUVlbCZrNx681paWlc/5bneyT1sAl4z0jxFRUVhaqqKrduKZpmPzt/97vficpvAfIR8Z6lxZ7rzfyB1I0bN5CWloaBgQFkZ2dLPiTIRcQfOHCAKzv3N5ASW1rMl5iMFF8ajQb79u3DyMgIJiYmcOTIEVitVq6egqyACw2kxAA5PEXWH0tKSgQdKaGBFKFKhoeHSwJy8LV3yNrT50bT02xG6uRJqRkp4khtleCGhs7hyJG7OHz4LsbG4kHTJlgshbDZ8qHTLSMwcAFKpR25ue2ir28LES/+4MMvLSbZpNVVLaxWtn+L7ZYi+S0aeXk2aLVrHJBDWkZKGiI+PHwGmZk9uH27EocO3cHamg5Waz4vv8W6SZ75LV+lxf6uT6db9oqIV6kcyMtrR15eO5aXdbBaC/Dw4QE4nUrQ9D4sLASD7d9qh1otnN8C+KXFchHxs5v/731ERga7rcuQBxyyLhMYGCj5kNDb24ulpSXZiHiz2YzwtERU3zmH0Z4+ZCypcGBWjfJZF4a1TnQbHBjQOeBQsKuCcyonJtTeD8zZoTH4l4NfQEkM6zbca3oEQPx+fHR0NAoLC/HgwQOUlZVhbW2NowGGhIRwH96eDo2v0mJf8udICa3LNDQ0cIcS8pDnb11mtxDx/tZlwsPDYTAYJJfN7hQRX1paitLSUr/rMkqlEjRNSwJyANLWH0nuRq1Wo6mpCUVFRVhbW+PyW3waoOcDHN+RkoOI97b+yM9vTU9PcwdAh8MBm83GvTZf+S1ge2mxlOvjO1KeNEBSdt7Q0ICHDx8iOjqae/1ygBxyEPH5+flckTfJb/HXm/kDKYVCwR02pWSkpKw/UhTFATUIZGV1dXVbfquwsHDbveKrtNiX/CHi+QOp8fFxMAyD1tZWbGxsoKurCxcvXhQ1kNotRLy3gdSdO3dw584dJCQkcEMWuUAOsSKOVG5uLo4dO4ajR4/i6dOnXoFCCQkJoCgKDMNIAnIAW4h4Ma+JDKSioqJgtVqxb98+SZ8BfO0dsvb0uRFxpKT0SG1lpIQdKTa/NYr4+FGcPn0Dvb0ZoGkzbLY8ABR++tP/BNK/5S9bJAcRb7NtX3/Ualexf38L9u9vwcxMKNraTKBpMy5degVXrz6PtLQ+DA4myzgkyEPEq1QbOHz4PrTaNY4GSNNmNDWVoaHhwGZ+i4bJ1Ibg4HnRpcV8ra5q0NGRs4mI9++q6PUrKC1tgtWaD6eTgtlMg2HMOH/+Nbf+rdTUPigU7ityYoAcnhobixdAxC8DaAZw0G1dhmSTaJpGd3c3AOD9998XtS7DXt9WabFYtbe3w263I7+wAD9qu7MFtghmiYChGxQyl9i+q5NTaqxTLgxpHYhfU6Al2A4I3EdaZQD+Yd9JvFFwBAEKdrLHz0hJoWQRR+rYsWPQ6/WC5Zme6zJiS4v5EpOR4isoKAgHDx5Eb28vXC4X8vPz3cozfa3LyMlIjY+P+0TEC63L0DSNJ0+eAAA+/PBDzk3y53LKzUh50h/56zKjo6MguGObzQa9Xo+srCzJpcXk+qRkpMjXUBSFkydPwmAwuOW3CA0wJSWFy29pNBpBR8qfpCLiCQ1wZGQEo6OjyM3Ndctv8d2k3biP/DlSJIuSl5eH5eVlzinp7+8HwGZvxOS3gN1DxHvmtzwHUjk5Oeju7pYF5JCLiD99+jSCgoIE81v8svOAgADRpcV8kcOm5xq5N8XExODUqVOYmprCwMAAsrKyRA2kAPkZqeHhYVRVVQn+2+UPpObn57lhy/DwMADgypUrMJvNgm6Sp+SuP/IdKf5Aiu8m8QdSubm56OzslAXkkIuIlzK08NTeIWtPnwsRJyE1td/NkfInmibUPv+OlFLpRFZWF5xOBWy2fJSXP8TTp3GorT2B2lqS36KRn2/b5tDwS4vlZKTi4oQdqbCwrfzWyIgRDGPG48f7AAANDRVYXtbDbGYQF+c9vwXwS4ulIOKVXEaKIOLd81u6zfyWCTU1p1BTU4XU1H6srWmg00krLd4Ccog/+MzOhmBgIAXHj9/CsWN3cPx4HYaGkkDTps1eMDMCAxe4/q3Y2HEvjpR/eesjA+oAuDe8k3UZtVqN7u5uFBUVYXx8XJAG6PkA56u02JcYhoEhJAhvtJyDbebptv8+G+BCU6gdTSF2xK0puAMXBQo5SyooAPQYHJgNYA+kx4xZ+OcDryA5yB02IRYRzxdxiLKysjhHynNdho87Jg84q6ur26h9/rRTRHxlZaWbm+RtXQZgD47+Sos9JYXaR9ZlgoKC8OTJExQUFGB8fJxbl+HntzzvFb4jJQcRL7T+SFEURyjkP+CQBw2r1cr9XP2VeMpBxAs5Up75LXI9Fy9exJUrV5CdnY2VlRWfjpSQdrL+ePDgQVRVVQnSAEl+i+D+AXkZKSnrj3q9HmVlZYiOjsavfvUr5OTk4OnTp1x+i7hJqamp2x5K+YfN3ULEe+a3iOPW3NwMl8uF7u5uBAUFiRpI7RYinp/fInh6kt/SaDTIzc3F0tKS5ENCV1eXpIwUsLX+WFZWhueee06wnsJoNHIDKfI7lWEYREdHSz5sAuIOCaSeIjExEb/4xS+Qnp6OkZERbiBFgEJCAymStZOTkfLmSCkUCmRmZiIzM9NtIHX/PvuM8+TJEzQ3N4saSPFLi6WuPyYnJ0sqLfbU3iFrT58LDQ8nYGYmHEeP3hH9NaS0OCenQ1RGiogg4k+fvgmFwrlJAyT9Wy/j6tXnN/NbNDIyeqBUOkWXFvM1MxOKwcFkUYh4igISEkZgNI6gpycdKpUdkZFTePSoBI2NFZv5LdZNEgJ1iAFyeKqnJ4PrIxOSTreCkpJmlJQ0c/ktmt6H2dkwKBQOXLjwKkwmBmlpvvNbgHtpsVi1tbEfXOT62PzWIJKSBnH27DV0dbH9Ww0N5Xj48CCio8eRmtq/6UhdFP19fCPi6wD8315eE+tIvfDCC1AqlZicnOTC1/x1GbPZjJSUFFAUJbq0mK+RyQn09fejJWQDthk/GHYKGNM6MaZxImpNAYXLhfkAF8zzKhTNB2BGAxQUFuIvDp4WfMDxh4gXUl9fn8/1R+ImkW4p8qC8uLgIpVLJTUv9rcuQ6yOlxWLliYjnu0nEGfNcl0lJScHExISk0mKy/piRkSGL2vfKK69AqVS6rcsQGiB5wCHrMkKOlD9JQcSTdZmsrCz88Ic/xNraGkJCQgRpgEKkS2+lxb7kz5EKCwvjVopGRkZA0zSsVitWVlagUqlQU1MDk8nkN78F7A4ink8DJPktmqa5/FZqaipSU1MllxbLRcST9ccvfOELUKlUXH6LOIEkv2U2m7kHdTk9UlIQ8QEBAcjPz0d+fj5+/OMfY2lpCWq1WtRAirwmuYj4yspKwf8eHR2NqqoqDihEcjfr6+sICAjA3bt3YTKZRDmwO8lIkfvI20Dq6tWruH79OjIyMpCWlubTkRKSXEQ8caS+/OUvIyAggBtIkfqFsLAw7j4i2w47zUj5u4/IQGrfvn34yU9+gvn5eTidTlEDKfKagM8WEe9Ne4esPX0uRNNmAE48erQfdrsS+flWv51IW6XFUjJSOnR2ZqO0tJE7GLA0wLs4cuQuRkfjQfq3bLZ86PVLyM+3YGAgGRER4kuLga2MlDREvBEzMxF46aULKC5uxcqKdtO1MeHWrSrculWFlJT+TWKiDRrNmhuQw1dpsdD1iUXEh4fP4Pjx2wgKWsCnn76MrKxOdHdnoq2NPbBuuUlPtx0ovZUW+xJZf/TmSKlUdl5+Sw+LJX/zwFUBwAWLpRAqlR25uR0+81vAFiJeuIj5PoT6slZXV7c5UpGRkW40QPLhTdM0goODUVhYiP7+ftGlxS6XC5cHLPjgynnkAejWiwd/RGxQCLcrcC9sHe1BDugcwFcMaciac2CkuQ1vP7JsW5fhU/ukFvxqtVpR649kXSYyMhIXL15ESkoKty7DL88Uco+8lRb7kj9EvLd1mXv32IoGMnUXsy5DSouluDfkkMd3pITWZR4/fozm5maEh4fDZDKhr69PNpBDKiJ+YmICZ86cQXl5OWZnZ7kHrkuXLnFuEj+/JRXIQSR2/ZHkt8j/zp8/D6PRyNEAfeW3AHFADm/X5239USi/RVYcAfbBPyoqSpAG6Cm5iHibzeaGiPeV34qJiYHJZEJvb68sIIdUat/k5CSePn2KU6dOcfktz4EUv3+LoijRpcWeErv+qFAouINwamoqzp07h6ioKK80QE+JAXJ4uz5vjpTnQIq8R11dXQDYTYOBgQFRA6ndQsR7rjd7DqRMJhO6u7slZ6SsVqvojBTRzMwMxsbGcPLkSRw6dAhjY2PcejN/IGU2m2E0Grn7SAqQg0gOIl5Ie4esPf3ZZbcrYbEUICZmAmtrGly+/BKuXTuLrKwumEw0MjN7BHM8W6XFfaK/F5vxUQqurbE0wFEYjaM4ffo6l99qadkPh0MFvX4Jd+8e2cxv+c498UuLpSDiPUuLdbpV7N//CPv3P8LMDOsmMYwJFy++gitXnkdOTgfCw6dkZKTkIeLb2tjS4q985Q9wOJSb/VtmNDaWob7+AKKjxzeJiWx+i31NO8lI+Xek9PpllJU1Yf/+R3jzzf8TgYGLmJ0NxfnzX8Dly+ub+S0aqan92/Jb7PWZfQA5tnJZfJGMlJCTQGiAKSkpHO6YYdjyTJfLhcDAQNTX1/tclxlamMY/1V9EzVAHvjSrwVO1CwsB26/dmzKXVHDAhT69YxvYwtu6TEREhCwgR3t7O8xms6S1tba2NoSFheEv//IvsbGxIWpdRkxpsaekIOLJukxFRQXeeustaLVaPH36FH/4wx/8rssAwqXF/uTLkfJcl7HZbGAYtjyTXG9LSwvy8vJEHYp3AxEfGhrK0QBHR0c5p4TktwoKChARESGptBiQnpEislgsCAkJwbe//W1R+S3yNVIPm1IQ8SS/dfToUbz99ttQKpV48uQJOjo6EBgYyBETY2JiBO8jOYh44kgJ3Ufe8ls3b94EwHaqWSwW0bkisv4oJyNFHClvA6nHjx9zA6nIyEifjpSQ5CLibTYbAgMD8frrr2N5edltvZm4SWazGVlZWdz9KeewOTU1JdqRiomJwenTp3Hy5Em8++67ANgsnMVi8TuQAuRnpLytP/LdJP5A6sqVKwBYp7mzs1PUQIpcX1RUlOyMlDcaoOdAKioqSrIjRYAcUumPQto7ZO3pz67u7kysrelw8uTHyMjowdOncRwNsL09DzrdMvLzLTCbGRiNw6AocaXFQmIYkyhEPMlvZWV1obr6JO7fP4ywsBnU1p5EbS2hAbL9W0LukbfSYl9iM1LeHamwsBkcO3YbR4/exshIAmjaBKu1ABZLIQAXenvTERi4iLi4Mb+OEUHEC7s3wtpypFhEvErl4IiJLA2QdZOqq0+huprNb5lMNGh6n6TSYmArIyUNEZ+O1VU9Xn31ArKyujA4uNW/xTBmBAXN8/q3xgHwgRwtPoAcdfA8ZDEMg/DwcBiNRp/XFBAQwHWn3Lp1C3fv3oVer/e6LmN3OvBT630ObBGxQSFsQ4G7Yb7dOL4oF5C+pMSw3oX/VnbGDWwBuK/LENwxWZcBWEpUVFSUqIdxX4dNb5qfn3crLfa3LkNQvjRNSyotBuQh4p88eYKVlRW8+OKLyMnJESzPJNdL1mWkAjmIxCLiNRoNioqKUFRUxN1HKpWKowH6W5fxB+QQki9Hip/feu6559DT08OtEzkcDlAUhcnJSczOzorKM5CMlJT7yNOR4rtJQvkt0i1F07RkIIec9cfBwUEsLS3hC1/4AnJzc7flt6KjozlYDlnnElNaLCSx648kv1VWVoaamhrcu3cPTqcT586d4wh53vJbgH8gh5B8IeL9DaQA9vfF4uKiqNXJ3UDEBwYGbqunaGtrQ3d3NzQaDee4SS0tBuSBFEZGRrC4uIhXX30Vubm56OjoAE3TPgdSYkqLvV2fwWDwu/5IBlIHDx7ErVu3cO/ePayurroNpPg0QE/tNiLe30AKYH9Hr6ysiBpIyVl/9Ka9Q9ae/uzaovb1gaKAuLgxxMWN4fTpm+jtTQfDmPD4cRGam8sQHj4Fk4kGRTklgxTkIuLb2/OQkvIE3/72r9zyW5cuvezWv5We3sO5QjvLSPk++LD5rWEkJAzj+PE6vP32f0dIyKxbfstsplFYyHiFiBBEvDcgh/DXeF9/ZGmAzSgtbcb0dDjnuF248BoANt/V05OOtLR+v4difmmxNES8GXo9C+SgKBeSkweRnDyIs2dJ/5YJDQ0VePjwEGJinm6+zy4RWbs68HNZc3NzePLkCY4fPy7pA6KjowOJiYn4zne+g2fPnnEPgWRdJiYtCVc3xvBwfZKjAXKOlIieKyLjqgJ6J4W/qnoBR02lXv+cQqFAWloa0tLSUFVVhXfeeQeBgYF4+PAhHjx44HddBmA/lMPCwkStPxL5cqS8rct0drJF2YmJiaLXZXYDES9EA2QYBrdv38bt27e5dRkAkkqLAWkZKb66urpgNBrx+uuvi1qXIa9JLJCDSCwiXqlUIjs7G9nZ2VhYWMC//uu/QqvVcu+Rv/wWuT6piHhfjpS3/JbFYgEAJCcnY2xsTJAG6Ck+kENKRorvSPHzW8vLy5zjVl1d7VZ27nK5vDpS3rS0tITu7m4cPHhQ0n3U19eH2NhYvPHGG240QAK14Dtu/Nck57ApBhHPH0jNzc3h+9//PtRqNWpqanDr1i2/+S1gC8ixW4j46OhonDp1yq1/y2q1orW1FQCQkpKCyclJUQMpuYh4sv5I3DkxAymn0ykLyCEVEU9RFAYGBhAVFYX//J//M9e/5WsgRV4TIP2wKcaR4g+kpqen8cMf/hBKpRLXrl3DzZs3/Q6kyPV5lhbL1d4ha09/Vq2s6NDVlYWyssZtD98KhROZmd3IzOzG2poGNlsuGMaMujr2l7VKtY6RkXiEhs74zW8B8hDxw8PuiHj3/JaRc5Os1gLo9UsoKLCgoKCNc6SkAjnYjJR4RHxHRw6cTiW+9KWPERY2zbk2NTVVqKk5iZQU0r/Vzl3LFpDDe2mxp9wR8bM+/2x4+DSOH6/DsWN1+OMfv4yOjlxMTkbiN7/5JgIDF3hu0vb8FiBcWuxPvhDxbH7Lhrw8G5aW9LBaC8AwJty8+RwAF1SqdUxNRSA6egJq9YbA3+6ey5IToh0bG3Oj9kVFRXHrMraebnx4+zp6O7tR4KKQotSgx+BAj96B9CUlBnVOrItc+Y/SBeJrijisLU7hkKlY9PX19PTA6XTiS1/6EkJDQ93KM/kf3vx1GeJI+Sot9pS/jBRfZF2mqqoKf/zjH9HR0YGnT5/il7/8pSAN0FMEES/lgdWXI+W5LkMOyWRdJiAgAMvLy7Db7aLcLJKRknJ9fEeKvy7DJyZ6rssUFBRwhwQ5QA4p649PnjyBw+HAl770JYSEhHAPgZcuXXLr30pPT+cecHaSkYqPj/fpSPHzW2fOnMFHH32Ejo4ODA8P4yc/+QlHAywsLPSa19htRLxer+c6yqamprj76Pz586AoinW07XY4nU5RD7ty1h/5jpRQPYVQfovcR2JLi4lIj5SU9cfh4WE4HA588YtfRHBw8LaBlGd+C9gCcsjJSPlDxPMHUs8//zw++eQTdHZ2YmBgAO+9956ogZRcRDyh9nmuP/IHUvyy887OTigUCqhUKqhUKrhcLlH/rgiQQ8p9xHeklEqlz4FUYmIiN2z5U2WkJiYmYLfb8eUvfxmBgYHce+RrIOWvtFiq9g5Ze/qzimSk/Lk3Gs0aiooeo6joMQYGkvDLX34HavU6l98ibhJLA9w+9ZeLiN/KSLkj4tn8FksDfO656+jpyQDDmPHo0X40NpYDYB/uZ2dDRPVW8UuLpSHitxwpigJKSh6hpOQRRwNkGDMuXnwVV668gJycDphMNIaH2RU3KYfNLUT8A9Ff43QqMDCQgtzcdrz22ifo7mbdpMbGctTXH9zMb9Gb+a0F3msycY6UWIlFxBsMyygra0RZWSP6+1Pw/vt/BaXSweW38vJsMJkYpKTw81tbuSxySEhKSkJYWJjo6xOi9hGwxf9suYRx5TyURiB5RYnMJSVM8yrsm2cfztYULugcwIqf3/ffyC7Hfy+oxE++/54sRDwBclAUJbgu09XV5bYuMzQ0BOCzy0jxNTw8jJycHLz22mvch/fdu3dx584dwXUZ8prEAjmIxCLig4ODcfjwYRw6dAh9fX349a9/DQCi12XI9UlFxHtzpJRKJbcus7q6yr1HdXV13MpMZmam6HUZPiJeytoav7SYoiguvzUyMsI5blarlctvmc1mPHnyRBaQY2xsTBJkRKFQYHR0FJmZmXjttdc4N4lPAyTdUvwVK0Ltk4KI7+zsFIWIj4iIQGVlJY4fP46uri78/ve/h9PpxG9/+1uOBkj6t7xpNxHxpJ4iPz8fS0tLHDHx5s2bqK6uhsvl4qicYjJPO0XEk7VFfn6LOG78/JbZbEZ/f7/kHik5iPiAgACMj48jLS0Nr776qttAyrN/iz9s8VdaLCRfGSm+YmNjERsbi6qqKrS3t+Ojjz4CAPzqV78SNZACtoAcctYfPa/P20Dq8uXLuHr1KpxOJzIyMkQPpEhGSi4iPiMjAwqFghtIectvEaiQVCCHL+0dsvb0ZxVNmzczUtu7f7ypvz8VgAtvvPETLC0ZwDBmtLUVwmbLh063jIICC0wmGkbjCOeUDA8nfmaIeKXSiezsLmRnd2F1VYtf/epbmJiIAU3vA03v28xv0cjLs3ml/wmVFvuTL0Q8oQEeO3Ybw8MJXDbJYikERTkRFDSHlRU9QkLmRLlZ3nukvItfWszmt9qRm9u+md9i3aTq6tOorj6FtLQ+sOXCvZJKi4nkIOKHh1kM+Btv/BgLCyFc/xZN70NQ0DxHTIyJmQDJZY2NjWFychIvvvii6O9D1taysrK4B1wObDHcwf05hwLoMzjQZ2BpgM9NqBGxoUDOkgpZS0oMa53oNjgwoHPAwRvU8sEWjx8/loyIn5ub8+pICa3LEBqgQqFAUFAQnE7xQwE5GSl+aTGfBkjWZWia3rYuk5ycjI6ODphMJlkZKbGIeIqiMD7O5vv+03/6T5ibmwNN037XZXaSkfK3/qjVarl1mbm5Ofz+97/H+Pg4WlpaQNP0NhqgkHaCiPd0pPhukmd+q7GxEUqlEkFBQZIfwneCiPdGA7xw4QIuX77M5beSkpJkATmkIuIpisLMzAwA4Dvf+Q5HcSRuEslvmUwmNxdJbkZKDCLeYDBw+a3JyUl89NFHGB8fx6NHj8AwjJub5M052gki3tOR4ue3+I7bgwcPcP/+fQQEBCAoKEgy9l4qIp7vSAUFBXEDKVJP4TmQMpvNiI+Pl1RazL8+KYh4hUKB5eVlAMBf/dVfcfe2Jw0wPz/f7XeIv9JiIYlFxPMHUqS/bWJiAk1NTbBYLNvqKYS0m4h4fj3F6uqqW36rrq4OGo0GERERkoAcvrR3yNrTn03T0+EYHk7EyZM3Ja6tbTlSISHziI8fw6lTNzbzW2a0thahqakMERGTMJkYmEwMl5HKzRWfkdpCxIs/+LhcwLNn0SgtbUJ5eT3a2kygaTMuXXrFrX8rPb3XzbHyV1osJDGIeIoCEhOHkZg4jDNnruHhw3LU1JzG4mIQfvKT/4yoqAmQ/i1CA/QUKS3OyemQiIg3CzpSbH6rCaWlTZiaIvktM86ffw1KpR0OhwoREVNwOilBGqCnSGmxXER8ePgswsNnkZw8gOefv4rOziwwjBn19RV48IDkt7pQWLgAmqahVColrSz09vZy1D5PsIU32SkgzK5Ae6ADtiA7Vy58ckqNdcqFfr0DA0EUvlZRif9ceJQDW9A0LRoRTySG2ue5LlNfX4/a2losLCyIXpcRKi0WI2+OlK91mYCAAGxsbCAmJkb0uowcRDywVVocFRWFqKgov+sy+fn5kkqLiUhGSsqDhk6nw9TUFMxmM0pLS7n+LZvNBp1Ox7lJ8fHxbq+ZZKSkIOI9e6SExM9vra6uor6+Hrdv38bCwgLeffddQRqgp4RKi8XIGyKe0ACPHTuG4eFht/yWRqPB+vo6jEaj6PtocXERPT09kjNSxJEiK6CeNMDq6uptjpuU0mIiOYj4kJAQzM7OwmQyobi4mHOTaJrmioVNJtO2lTviSElBxHv2SAmJn99aXFxEQ0MD7t27h42NDbz11lvb6imERO4jueuPno4UqacQGkjp9Xqsrq5Keh9IRkouIj4hIQGJiYnb6imuXLmCa9euua2Ay8lIDQ8PS0LEUxSFqKgoLCwscE6/p5tE7iP+QIq8JrmIeF/3kVarRXFxMYqLizE7O4vGxkY8fPhQ8uqyL+0dsvb0ZxPJSEnpkfJWWszSALuRldWN1VUN2tvzwDAm1NaeQG3tCVCUA3FxY3C5pPyyIoh48RkpfmlxWNgsjh69gyNH7mBkxAjSv7WV32KzSVrtsujSYiI5iHil0oH5+VCoVBv4u7/7d/T2ZoJhTKipOYWaGkIDZJCba4NGs0Wz81daLCSxiPiIiGlUVtbh+PE6DA0l4Y9//DKWlgy4du153Lt3hNe/Ne717/AsLRaj0VFhRLxKxRIN8/PZ/JbFUgCGMePmzVRUV78DiqIQGxsreRVPp9NhMVSD5y/9O2zT/rvWUpeVULko9BjsmA1woSnUjqYQO+LWFOyBazUA2Usu2Gtp3Jl0ci6PHCAHwzBITEzc9sHmTWq1GisrK1AoFPjud7/LUdP8rcv4Ky0W0vr6uihHir8u09/fj3PnzmFjYwNXrlzBgwcPRK3LyEHEP336VLC0mL8uMzc3xz3gkPJMcs1Spto0TctGxO/bt08Qd9za2oqmpiZERERw75FSqZQF5JCKiNdqtdjY2ABFUXj99dc5h4vQAIXyW8DuZ6SIKIpCYmIiEhMTcebMGXR3d+Py5ctYW1vD5cuX0djYyL1Hvib3Yg6bniKIeE9Hik8D9MxvXb58GQDbqyZlaLFTRDzJb/H7t+rr6/HgwQPExsZyGTeKokSXFvMlJiPFV2BgICiKAkVR+Na3voWenp5t9RTkuvn3s7/SYiGJQcR7DqQ6Ojpw/fp1AMClS5fQ0tIiuN7sKTkZKW+IeEIDJG4SfyCl1WrhdDoRFxcn+bApBxG/srICs9nsRgNsb28HTdOCAykAokuL+SKIeLHrj6GhodxgZ7dWBYG9Q9ae/kwiTkJqar9XB0VING3260hptWsoKmpFUVErZmdDUFNzEhaLCaOjCXjzzf+Tc5PY/JbwAYAAOaQj4klGautBmqUBjiAhgZ/fMnE0QL1+CQCQkvJE9PcZGTHuCBEfFjaHkpJmlJQ0u+W3Llx4FZcvv7DZLcUgLa0PUkqLiUhGSmx3F0UBwcHzWFwMwtGjdYiJGQdbLlyOhw/Z/BZLTGxDUNBWfsvlYu8JMUAOvhjG7BcRbzAso7y8EeXljZicjERd3f8Dq3Uco6OjeOuttzjcsa91mdXVVbR3dGA9LhSvXf0JXBDXdZW5pMScyokJNe/PU4A9TI+vPvcSzibkoqurCzRNc+WZ5AMyIyND9Pvw9OlTNyCHGPEdKeLeEBqgt3WZpKSkHWWkxH7oKRQKREVFYWlpCYcOHUJUVJSodRkpQA6+xFD7QkJC3NZl7ty5g46ODoyOjuLtt98WtS6zm4h4b+sytbW1qK2tRWhoKFwul6QM0vj4OJ4+fSopI8VHxBMcvCcNkOS3yIQ7Li7OqyPlS1IR8SqVComJiVheXkZ5eTkiIyNB07Tf/Bbgu7TYm8SsrfHzW0NDQ7h//z66urowOjqKd999V5AG6CmCiJe6/kgcK74TExAQ4JbfIo4bqaeIiIiA0+mU9BAuJyPFp/aRdUK+m0TyWyEhIdx9RH4vSAVySF1/VKvVyMjIwIULF7B//36Eh4eDTwP0NpACdpaR8nUf8QdSfX19ePjwIfr6+jA2Nobvf//7XMbN19Btp4h4viPlbyAVFRUFh8MhyfXfbUT8TrR3yNrTn0VbGanbor/GblfCai3YzEiJ6w0KDZ2D3R4AvX4RX/va79DWVgiLhc1v6fVLXP9WfPyIm4tEHClpGSkWEe/LkVIqHcjO7kR2didWVrSwWvNx/Tr7YPLzn/8NUlJYNykvz+YzB+ZZWixG3d3CiHj3/FYiR0xsa2OdvOVlPfLyrJL7yNiMlJT1R/aDoajoMUJDZ5GX147lZT0slvxNN+m0W/9Wbm4Hnj2LlAzkYBHxBZIQ8ZGRkwAmoNVq8eUvf5lbueKvy5jNZrfwucvlwu/v3oTDbsen68NwacQdsAx2CnFrCjwKsXMod4AFW/zj/jMI0bC5Lv66TFtbG27dugUA+NnPfiZqXQYAt/4oJSPFX3/ky9e6TEhICObn55GXlyfpkEDTNMLCwkRnpIAtR6q4uBjh4eFe12X4KN/JyUnJQA6xGSkiiqIQFxcHtVoNtVrNwRc812XMZvM2qApxpHYbEe+5LtPW1obbt9nfyb/4xS9E5beAnSHi+e6NJw2QuKTNzc1oaGhAREQEZmdnfWK8vV2fXET8/v37ERUV5TW/RYYtaWlpmJqaEl1aTEQe7vxlpIgoikJSUhJaW1sREBCAF198ETabbRsNsLCwcJszIadHimSkDhw44HWYZDAYUF5ejvLyckxOToKmaTx8+BAA8MEHH4gaSAHyMlJCiHiKopCamorU1FQuv8UfSMXFxWFiYgLZ2dmyMlJyEPElJSWIjY11q6ewWCzcQIoMW5KSktwyUmIlFRFP6ik6OjqgVCpx5swZtLe3+x1IAeKBHHyRjFRpaanXe8BzIEXTNJqamgAAv/3tbwVpgEL6LBHxUrV3yNrTn0U0bYJCYUdWVqfor+nuzsTqqk5SgS4fEU/cpNOnb6C3l3WTWlr2o6mpfDO/RcNkYhAaOgexpcV8SV1/1OlWERs7Drs9ACdP3oTDoQRLA3wFV648v0kDZJCe3ut2wCGOlD8gx/brM/tExLP5rSEkJg7hzJlr6O7OxJ07x7C0FAirtRATEzF+81vA9tJiMSLrj56OlF6/jLKyJpSVNWFqKgKkf4vQAIOD56FQOJCT0+79L/fQFiJe/H3EIuIdKC4u5FZBfK3LhKcm4J/baqB91AeDinJ3pPwoY0kJChR6Nrux+GALIQUGBiIlJQV2ux1Hjx6Fw+EQtS4jBOQQI3+OlNC6zL179+ByuWC1Wrlsh791GbmIeFJazJ/E8ssz+Q84HR0d0Gq1CA4OBkVRkrJ2/f39HJBDrPiOVE5ODnJyctzKM4XWZXQ6naAj5U9SEfGhoaHIysrCrVu3cPDgQdjtdm6YoNfruQccz/yWr9JiX/LnSCmVSu49WllZgdVqRX19PUcaIwd9X/ktQD4iXqi02Ft+q62tDYGBgdzDrdTy6/n5eUkP1MSRIg/mJpPJLb9FaICpqakwm80ccEEqkAOQvv4YGRkJs9mMe/fuoaSkBA6Hw+9ACvBdWuxL/hDxnvkti8WChoYGOBwOtLe347e//a2ogZRnabFYCTlS/HoK0i3V1taGlpYWhIaGcveRlN8tO0HE5+XlcSAYfwMplUrFOVJigRyAuKwdERlIaTQaNDQ0wGw2w+FwCNIAPQdSch0pOYh4Mdo7ZO3pTy67XYm2tkI4nSr8+7//PfLzrTCZaCQkDPt8KCelxWlpfaK/l8WyHRHP5re6kJXVhdVVDWy2PDCMGbW1J1FbexLx8cMYHU3AsWO1kkEKKSlPRGekgK3S4tLSZmg0azh69A5GRhI4N8liKYTBsMgRE+PixmRlpFZWtOjqyhKNiGdpgB2orz+A8PBJVFTUg+3f4ue3aOTmtm9zFcUAOTw1Ohrv15GKiJhCZWUtjh+vw+BgImjajNbWYgAUfvSjv+X1b3nPb5Hrk4eIV8Bk2lp9EVqXoWkaN27cgBMuaDVOxK8p0RK84eZI+ZSLXRV8qnFgQ6PCP+47iTcKjnBgC28ijlRFRQV0Op3PdRmz2YzIyEivjpQvra2toaOjA2azWZQjRcozHz9+jPX1dZSVlW1blzGbzcjKytr298nNSD179syrI0UydbGxsVy3FDlwAawLKEQDFBJN01xpsVgJrT/yyzOF1mVSU1PR29srKyMlFxF/6NAh6PV6t/xWS0vLtvxWaGio6NJivshhMz8/X5QjRWiABI1eXFyMtrY2Lr9FaIDp6enbHoDJYVMqIv7p06deX5NQfoumaa40+9e//jXnJvlzFQgiXsrampAjxc9vTU5Ocg/u586dQ0BAADIzM2WVFu8EEX/06FEEBQXh7NmzHA2QlJ3z81uBgYGiS4v5koqIDwwMREVFBfr7+7G+vo59+/bBYrFwAylCTPQcSAG+S4u9aWpqCiMjI14P0AqFAunp6UhPT8cLL7yAjo4O0DSNvj72GefDDz8UNZACdg8RLzSQamtr4wZS2dnZ6OzslFRaDEjPSJGvAYATJ04gODjYbSBFaIBJSUncsEWn00kGcgDyEfFitHfI2tOfXN3dWVhf1+L48VuYnIzC48f70NxcivDwKY4GGBY24/Y1vkqLfYlhfCPitdo1FBe3ori4FbOzoWCYQtTXVwAA7t07gsnJqE03yXt+C9heWixGLCLe3ZFi81vDSEgYxpkz19HdzfZvNTeXoKGhApGRz0BRTuh00kqLtxDx4t0bfmlxaWkzSkubMT1NaIAmXLjwmlv/VlpaPyjKCbGlxXyRjJSY9UeKciE5eRBra1q0tu7HoUN3MTkZhYaGCjx8SGiAzLb8FsACObYQ8dLuo/DwKRiNowC2r4oYDAYEpMXho6f1GMEqMpeUyFtgf70WLqgQ6KDQbXBgVOP0eeCK3KAQZldgPCkMNa/+JZKD/D8gCzlSnusyHR0dYBiGW5eJj4+Hy+WSlZGy2+2SHjT4jhShAfI/vIXWZQBwGSmxQA7yNWIR8WRdBmAfoMrKyvDs2TPOTSLrMgUFBducPgLk2I2MFF/8dZmxsTEOTgEAzc3NWF1dFbUusxNEPL+02F9+Kzk5GQ6HA2q1WjKQQ0yPFF98R4q4Sfz8lsVigcFg4LJJsbGxoCiKA3LsdkaKiIT/tVotOjs7sW/fPkxOTqK6uhrV1dVIS0vj8lueBwExQA5v1+fLkYqMjMSJEydQWVmJwcFBbsURYB/GAQjSAD21E0Q835Hiu0lC+a309HRsbGxApVJ9phkpYGv9saKiAqdOnUJVVRU3kLJardx6M38gBUgHcpCvAcStrZGBVGhoKPr6+pCfn4/Jyclt9RRCAym73b7riHihgRQ5uLtcLrS3t0Or1YoaSO0kI8VHxHsOpMh9/emnn+Lq1avIysrC+vo6lEqlLCDHbgIviPYOWXv6k4tQ+44cuQeFwom1NQ1stlwwjBl1dZWoq6tEYuIgTCYa+flW6HSrokuL+ZKKiA8NncWRI3fR2lqEsLBZJCQMe9AAWTcpPn5029/nrbTYl7YyUsKOlFLpQE5OJ3JytvJbjx/vw8hIIgAXPvjgm2D7t9r9rg1uIeKlrj+6lxaHh0/j+PE6HDtWh6GhRJD+rbY2EwIDF5CS0o+pqUgcOHBf9PeRk5ECWOCFXr+EyspaKJVOLC3puf4tkt8i/Vs5Oe1QqzdElxbzRRDxx4/fAkXFAjjk9t/n11fxL4+u4/2OehZsEQA0h9iRsqTEksKJZ2oXUpeVyFpSYVHpRI/BgR69AzMCK4SmNR0oBYU3v/g3oolh/hypgIAAFBYWorCwkMtv0TTN9Tv94Q9/4D68/T3oMQwjGREvVFjpb10mLS1NdkZKLiL+1KlTUKlU3LoMTdNe12XElhbzRQ6bR44c8fugQVEURwPs7++Hw+FAXFycqHUZYKuPTEpGqr+/36cj5ZnfYhgGNE1jenoaFEXhwoULgjRAIcnJSHmuP/rLb0VFRSEtLU0ykGMniHi1Wo3nn38eAQEBgjRA4rilpaVBoVCILi3mSwoinqIojgY4OjqK1dVVREdHc+vNvvJbgPfSYl8iiHhvjhQ/v/Xs2TPuPZqfn4dCocDVq1e5/Ja/17cTRDx5z8UMpNLT03cE5BCTkSIijtTLL78MtVrtNpAiNEACFEpMTARFUejq6uIGMGJFEPFiHCkykMrIyMDU1BQWFhYQHh7uNpAym83cerOnhD4D/MmfIxUSEoIjR47g8OHD3ECqra0Ny8vLUCqVqKmpgclk8juQItcnFREvVnuHrD39SbW8TBypBs6R0mjWUFT0GEVFjzE3FwKGKQTDmHH58ku4du0ssrK6MDERhchIaaXF8hDxiZidDcexY+exb99jnD5NaIBmPHq0H42N5YiMfLbplLD5LbGlxduvzywaEa/TraKk5BEoChgZScT+/c3o70/DxYuvurlJ6el925y+mZkw2Yh41pHavv5IUUBS0hCSkoZw5sxVdHdngWHYFUcAqK8/gNVVHQoL2xAcvLDt6/nilxaLlRAi3mBYRllZI8rKGjE5yea32tpMOHfuCwgIWEdubjuePo1BeLi00mJ3RLwGwP8NgP0QvTxgwf9suITxZfeMWuQ6hTCHAndD1tER6MD9sA0kryiRuaSEaV6FffMBmAxwottgR6/BgRUl8I3MMkQ87EVydrLkQ4JOpxPlSAUGBuLAgQPQarW4ePEiTCYT+vv73WiA3tZlfJUWexOf2ic07fRclyHdUi0tLQCA1tZWuFwuUesychDxBB/MX3/kr8vwccdkXSY/Px9jY2MICQmRDOSQurY2Pj7OIeLLyspYWuXme+RtXUYqkINICrUvNDQUR48eRUhICM6fP4/s7Gz09/dzNMCCggKYTKZt+S3Ae2mxmOvzhogXym8xDFvmC7AP1iSf6G8daLcQ8Z40QOKUkPxWYWEhRkZGPvOMFMAi4sn6Y0VFBZaWlrj3iOS3iONG3BCxpcWekkLti4qKwsmTJxETE4OPP/4Yqamp3HpzcHAwRwMUWlXkO1K7hYgXGkgxDIO7d9kNld7eXoSEhAjSAD1FEPFSM1I2m83N9fQ3kDKZTBgaGpIM5JCSkSKanp7G6OgoqqqqcOjQIczPz3OHZLLeTBw3MpASW1rsKbGIeP5AKjExER999BGMRqNbPQW5j4QGUt5Ki3dLe4esPf1JRRwpb05CSMgcjhy5h8OH72FsLA4MYwbDmLCyokdAwDquXHkeZjMDo9F3fks+It69tFipdCI7uwvZ2V1YXdVu5rdMuHXrJG7dOonk5CeIjp4QpPb5EslIlZQ0S6b2RUY+wwsvsB0pw8MJnJu0ld9is0mxsWOgKHkZKYKIP3TIPyKezW+1IyurC2+99d8QGjoHpdKB6urTqK4+xblJubntUKu3UyG9lRb7kj9EfGTkFE6cqEVl5VZ+y2otwPq6Bmr1GqqrT8FkohETM+Hz+/BLi8PCZgHcB7COoYVF/FP9RdQMdwh+XeaSCg640Kdn4RUOBdBncKDP4IDWAaQvKZG5rMKBWTUqZoHoRCMyV4LwYHlZVkZq3759kru7wsPD8eqrr8LlcgmuyxCnhDzU7iQjJQYRr1arYTabUVhYiDfffBOBgYFwOp2i1mXIa5K7/ij0mkj4Oi4uzm1dhqZp2O12aLVa3L59W9S6DLk+qRkpT0dKq9X6XZeJjo7eEZBDyvpjW1sbQkJC8JWvfAVOp5Prunr06BEaGxsRGRnJOSWhoaEA5B0SSEZKjCNF8lvFxcV4++23odFosLi4yNEAfeW3AGmHTSJf64+EBpiUlIQzZ85wsJyGhgY4nU7o9Xo8ePBAVH6LXJ9cRDy5jwwGw7b8FsMwOHfuHNRqNXJzcxEdHS25tFhqRoqora0NQUFB+PrXvw6Hw8Hltx48eID79+8jLi6OW90lBz45GSkpiHgykKqoqMA777wDpVKJZ8+e4aOPPtpWTyE0LCCHTSlra8SRErqPvA2k7ty5w13vo0ePBGmAQiJADinrj2TVlDibwcHBbjRA/kBKp9MhPz8fsbGxkjNSchHxZGX429/+Nvc7TWgglZ+fD61WC0BcafFOtHfI2tOfVAxjRnT0OGJifDtSFAXEx48hPn4MavUa7t49itTUPjx+XITm5rLN/Ba9md+a3fb1Q0O7j4jXaldRXNyC4uKWzfwWm00aGEgB4MLjx0VwuSikp/f6zfvwS4vFimSkTp7ccqQSE4eRmDjM0QAZxoTm5lI0NBxAVNQETCYajx/vk1RaDMhDxLNADgNeffUCsrK6MDVF8ltmnD//Gi5fZh03s5lGamofFAqX6NLi7dcnDhFP8lvJyYMICprHnTuVMBqHUV9fgQcPSH6L9G8tbvt6z9Jiu3MFP7X+Hm897saKfUP4e7qA9GUlBnROrAsMxlaVgDXYgd4wBf6PtDLkraphabPgwRAL/Whvb4dGoxG1LmOz2SRnpObm5txKiymKcqMBkgece/fu4e7du4iPj+fgFVJKiwF5iPi+vj6srKzgpZdeQm5urmB5pue6jJAjJUYMw4hCxPPXZW7fvo26ujpERkZ6pQF6yltpsS+RrJ03R8pzXYYAPNrb2ZXlvr4+BAcHi1qX2Q1EvFKpRHZ2NrKzs7n8Fk3TuHXrFm7duoXk5GTuPpJSWgzIW3988uQJlpaWcPbsWeTl5bnRAMnDGJlwk/zWZ5WRIiL0sry8PNy5cwe1tbUICgoSld8CtkqLdxMR75nfomma+9kBwOjoKGJiYkSBL3aCiCeOFPk582mADMPg+vXruHHjBtLT07n7SCqQQy4ifmFhAa+99hoKCgpEDaTElBZ7uz4xjhQZSJnNZu4+UqvV3Hqzv4GUt9JiXyLOppAj5TmQIrCcx48fw263c99zenpa1OfHThDxZP2RP5Ai9RT8gRSpp6BpWjKQQ4r2Dll7+pNpaorNSFVVictIAayTYLEUIjW1H1/72u+xuqpBezvrJtXVnUBd3QkkJQ2A7ZZi81vA1iEhN1dKRopFxIs5+ISGzuLo0TsoKWnCW2/9d0RFPcOTJylc/xZxk+Litue3yPXJy0i53DJSRGx+qwM5OR1YWdHBas0Hw5hQU8NO7FQqOx4/3ofcXJvfjjF+abFWK2X90b20OCJiGpWVdTh+vA5DQ0mgaRNstq38VmFhGwIC1iUfNuUi4q3WQiQnP8G3vvUBlpb0sFgKwPZvPcdz3Gjk5HRArd7YfE1bpcUtz+LwPx48B9u074NnwqoCOieFboPd6585ZszCPx94hQNbHD50GG+++SbCw8O5TABZlzGbzV6n1sSRMhqN4t4I+N6PV6vV3LrMwsIC94Bz7do1AOxaltVqFbUuwz8k7AQRzy/P9LYuExAQsCMgh5QHDZvNhoSEBLz++uuCNEB+fou4iwTIIScj5e9Bg78uc/z4cbz11lsIDg4GTdN49OiR33UZcn1yEfFC18fPb83MzHDv0aVLlwCwP9Ouri5R+a2dIuKzsrIEaYAMw6CxsRH19fWIiori7iMppcWAfER8R0cH4uLi8MYbbwjmt0i3VGpqKue4eTpSYiQWEc/Pb1VVVeGdd96BXq/n3iNPGqCQ5GSkfDlShAZYUVGBZ8+ecdmkTz75BAC4zKKYgdRuIOI96ymEBlJmsxkBAQGSD5tyEfFdXV2Ijo7G3/7t3woOpAhQiAykAHk9UkNDQ6IcKYVCgczMTGRmZmJpaQnvvvsuNBoN7t27h3v37vkdSJHrk4uIF3rPQ0NDBQdSNhv7WS4FyCFVe4esPf3JtHVIkJaR4jtSWu0aiopaUVTUitnZELS1sW7Sp5++hKtXzyI7uxP5+RZYLPmCeHHf10cyUuIR8TZbPpxOFV555SKio8d5+a0SNDZWbOa32G4p4iSR0mK+I+VPJCPFIuJ9rz/qdCsoKWlGSUkzPv74NdhsBbDbVbhw4VVcvvwCcnPbYTIxSEvbnt8CvJcW+5IvR4rNbw0iKWkQZ89eQ1dXJhjGjIaGcjidSiiVdjx5koLg4IVtNEAhkdJiaYh4oxsi3mBYRnl5I8rLGzE5Gcm5kufOfRFq9Rpyc9uRn9+GtrYCpGV24/9pPYz3O4rhEsFiz1xSYlXhwrBu+3sbpQvE/yp7CS+nmtx+qXd0dMDpdOKVV15BTEyMqHUZT0dKjMiDRmJiotcHbqKgoCAcOHAABw4cwCeffAKLxYLl5WXR6zJyEfHeHCl/6zJKpRJjY2OIiIgQtS4jZ/2RZKQIkEOoPJO4SWRdprCwEAzDyMpISUXEd3V1weFw4NVXX0V0dLRX3DF/XUZMabG36xPjSIWFheHo0aM4cuQIzp07h7a2NszNzeF3v/sdl98ym82Ii4sT/P67jYgnOY/c3Fwuv0XTNGpqagCw99Hs7CzW1tZErSqR9Ucp95GnI+WZ3yJuEnE2yCGZYRhkZGRIzkhJRcT39fXBbrdz95EnDTAtLY3r3yLvr5jSYm/XJ8aRioqKQlVVFU6ePMn9Pnr27Bnef/99UQMpOYh4oYwUkbeB1NWrVwGw99HKygrsdrsod303EPH8gRRZbybru2FhYW73kVQgh5z1x8HBQdjtdnz1q19FVFSUqIGUpyMl5fr8OVL8gdTp06dx/vx5WCwWSYdNqdo7ZO3pTyKXiwUIyM9IbXekQkPncOTIXRw+fBdjY/GgaRMslkLYbOxq0tqaBsPDRhiNI34PM/IR8VulxRQFt/yW1cr2b926VYVbt6qQktIPk4nB9HQYvDlS3jQyIg8R39ubibw8G77whY8xPJzAZZPa2ljCY2FhG0wmGrGxT7n3yF9psZCs1jxRiHiVyo68vHbk5bVjbCwWP/nJd2EwLKG6+rRH/1aHYH7LW2mxP9G0ySsiPjJyEidO3EJlZS0GBpLAMGbYbHmg6X0AgNvDqXgwmwqXiELhACeQvKJEp8EBp8c9943scvzj/jMI0QjTl4gjRSbV3tZlMjIyYDKZMDk5CUDaIWFsbAyTk5OiMlJETqcTfX19yMnJwZe+9CVuXcZisaC1tRWhoaHcAw4/b7STjJS/Bw3+uszo6Cj+4z/+A1qt1i2/ZTabufC1p7yVFvsTWVvzXH/kr8vwu6UIDRBgH7pmZmb8Hm4B+Rkp4kiRqTWfBuhtXebZs2eSM1JyEPEk+5eVlYWvfOUrXvNbJpPJrUSU70iJlVhEPMlvlZSUYGhoCD//+c8REBDA5beIm0RogEISKi32J0Lt83Sk+Pktftl5Q0MDHj58CABITk7GwsKCKDdmN9YfKYriaICTk5NubhLJb5lMJkxMTEi+j+Qg4gHWVUlPT8dXv/pVzvn3HEgVFha6OZ/+SouFJHb9kT+QGhgYwC9/+UsoFAq3/i1fAylAPiKeoqht18dfbya5XTKQIkOp5ORkLC8vixr8kPVHqT1SfEdKoVD4HUiZzWaMjY15daS8SQ4iXqFQYGRkRHJpsVTtHbL29CcRyUgdOyY9I+XPkWLzW6OIjx/F6dM38Mtf/jWePo1Fb286urqyERExicJC0r81K/h3CJUW+9P0tHdHSqtdxf79Ldi/vwUzMyS/ZcbFi68AcEGvX8LERAyCghZFHerIYVMaIj6TQ8RTlFB+y4zGxjLU12/lt7KyuiSVFhNtrT/6zki5Xx/70PTXf/0LOBxKzk06f/4LuHx5nXPcSH4L4DtS0hDxVqt/RDxFuZCSMoCUlAEUHr6Hn/zidQQs6hG7qMGXFilMBmzi1w12rHjZcEpbVkLlcl8VzA6Nwb8c/AJKYoRx1b4cKW/rMh9//DEoioLBYMDs7CxCQ0NFfbgwDCM5I8V3pDzXZciHN1mXMRqN3GSSADnkZKSkIOJJcedf//VfY2Njg/vw9rUu46+0WEj+MlJE/HWZtbU1fPDBBxgbG4PNZoPNZhO1LrPbiHj+uszo6Ch3SLbZbNx9tLq6CpfLJfo+kpORIo6UZ36LkO5IfislJQUmkwkZGRmw2WwoKCiQfEiQiogfHh4GAHznO9/B6uoql98iNEDiuMXExHDvkb/SYiHxEfG+HCl+fmt5eRm//e1vMTo6ira2NlgsFqSmpnJukrfcz24j4iMjI3Hy5EmcOHECAwMDYBiGy28pFApJ65yA98OmL/ER8Z40QG8DqbS0NFlADrL+KIXaR6ox/vqv/xorKyuiBlLEkZKDiE9NTfV54NZoNNxAan5+Hh9++CFGR0e5zxLPegohyclIeUPE+xtIqVQqGAwGyYc5YHcR8bulvUPWnv4kYhgzh9EWq+7uLNEZKaK1NQ1GR+NRVtaAY8dub9IAzR75LRr5+Ta3B25/pcXCr8l7RoqvsLBZHDt2B0eP3kFLSxE+/fQV2O0B+O1v/3KTBsj2b8XFjQk6bkKlxWKvTwgRz9IAO5Cb24HlZZLfMqOm5hRqaqoAUNDpVrC2pha1bskvLZa2/uheWlxZWYvjx1kaICEmMowZQUHzXMZt67ApDcghFhFvd1L4qbUU//boEL64qEdHoAMtIRtIX1Yic0mFitkAlM2qMKJ1otvgwBOdAw7egDtjSYk5FduNpVUG4B/2ncQbBUcQoPCeOxH7AcFfl3n06BEuX76M1dVVvP/++1x5pslk8jpRdzgc20qLxcgbIp6UZ5pMJiwsLHBOydWrV3Ht2jW4XC4EBQWJXpeRm5Ei64/kocWzPNNzXcZsNnOHBKlAjsXFRUkHH4qiMDExgX379uHo0aOi1mUAd0dKrMQg4imKgtFohNFoxOnTp/Ho0SNcvXoVKysr+OlPf4qIiAjuZ0pogJ4SKi0WI2+OlFarxf79+7F//37MzMxwP7OLFy9CoVDA6XQiIiICTqdT1PrQThHx5N+Pt/xWdHQ055TIASnIQcQHBATg2bNnMJvNOHz4MPeAfO7cOW6FyzO/RV6TXES8v/soJSUFKSkpOHv2LJqamnDz5k0sLy/jhz/8oaj8llBpsRh5W3/kD6QmJia4bNLHH38MlUoFu92O6Oho0YOEnSLi4+LiAMDvQKqgoEDWfSQHEa/X6zE9PY3CwkIcPHiQu4/49RRmsxkJCQlu7xFN015Li73JV0aKyHMg1dTUhJqaGtjtdnz/+99HYmIizGYzV08hJLmIeIZhRCHid6q9Q9aePnPZ7Sq0tRUgLGwaS0sGwTUwITEMC0hIS+sX/b2s1gIOEa/VrqG4uBXFxa2bNEC2f+vTT1/G1avPIzu7EyYTjfDwaUmlxcDW2lpqar/fjBQRRQFPn8ZDpdrAf/2v72JwkF1Na24uQUODcH4LkJeREouI1+tXUFrajNLSZkxPh+NXv/oWFheDcPt2JR48OMT1b6Wl9Xv9e4RKi/3JmyPFpwGePXsVXV1s/1ZDQwUePjwEinIgOnoCGxtq0VAOsYj4LbBFDLIXlVCBdaRWlYA1yAFrkAMhGxQyl5TIWFLixJQa65QLT/QOdBscmFe6EL+mRHPIBo4luIMtvIl8QCQlJYlaI2PfIwqTk5NQKpX4+7//e26iTMoz4+LiYDabUVBQ4DZZlpuREoOIDwoKwsGDB3Hw4EGMj4/jt7/9LRYWFlBbW4sHDx5wbpK/dRlgdxDxnusy/PzWnTt3oFAoEBUVJfkhXM76I3Gk+PktUp4ptC4THBwsurTY8/qkIOJJ9kihUOC//Jf/wq2B1tbWora2FklJSdwDDslvAf5Li4W0vr4uypEKCwvDsWPHcPToUYyMjOCPf/wjFhYWUF1djYcPH3L9W97yW8DuIuL5+a3l5WXOcSM0QKVSiejoaMkum1qtloSI5ztSERERbjRAQrojrgtx3AwGg+jSYs/ri4uLE03tCwgIwMrKCiiKwne/+10OTkPyW4QGyM9vAf5Li4VE1h/9Ufuio6NRVVXFOW7nz5/H/Pw8bt68icbGRr8DKUDcIcFT3hDxvgZS169fh0KhQHR0tOThl1xEvNls5vJbnvUUZCBFrler1aK7u/szyUjxpdFoOBLh66+/zt1H/HoKoYGUHEfKbrfDYrFIXn+Uo71D1p4+c3V1ZWJ9XYuJiRj827/9VyQmDsJspt1ogJ4SKi0WI4YxCSLiWRrgXRw5chejo/FgGDMslgLYbPkICFgH4EJ09DO4XBB10BoeTtgEctwRfW380mK9fgU5OZ3IyenEyooWNhtLA2TzWyeRkvIEJhONvLx2yAFyyEHEU5QL8/OhqKysRkrKAOcmERogcZNiYrbyW/5Ki71JjCPF5rdsyMuzYWlJj1u3TqClpQTj43F4551/4Pq3cnLaORqgp8Qg4ufX1fiXR0fdwBaZS0rMbjpSfM0FuNAcakdziB1xawpkLimRuqxE1pIK6xT7Z79SchTfOHRK1IMNyUi9+OKLfv8skcPhQFtbG7Kzs7nAN39dhqZpXLt2DdevX+fWZbKzs706Ur5EEPFSHjS0Wi3m5+dx9OhRJCUlcRNlQgMUWpfhO1K7jYjXaDTYt28f9u3bh/n5edTW1uLx48cYHx/Hm2++KWpdZieIeE9Hih++5j/gkHUZvV4Pl8sladVNLiKelBaHh4cjPDycy28RN+nSpUu4cuUKl9/KyMjgHCmpPVJS1h8pikJISAgWFhZw8OBBJCQkgGEYNDc3o6GhAZGRkVynmmeeQiyQgy8xa2t6vR6lpaUoLS3F1NQU7ty5A4ZhuPuI9G/5ym/tJiKeTwM8e/YsB8sh+a2goCC4XC5kZGSI/j5yEfGktDg6OhrR0dEoLy/Hs2fPuPuI5LdI2XlKSopXR8qXpCLiyeFlcXER5eXlMBqNbgMpUk/hOZAC2HtCbkbKlyPlOZC6d+8eLBYLxsfH8dZbb22rpxDSbiLivQ2kSD1FaGgonE6npH/v09PTshDxxJFKSEhAQkICRwP0NpAyGo2iS4v5krP+KFd7h6w9feZiGDMCAxfwne/8DFZrAWjazNEAs7K6YDLRyMzsgVLp4L7GX2mxkMQg4ikKMBpHYTSO4vTp6+jpycDHH38RFOXC7373dURETMJkYvNbvsAKNE0Q8eLX1rYyUu4HH51uFfv3P8L+/Y8wMxPGZZMuXnwVV668AIdDiaysTtHfB9haf5SOiAfMZtZJS0oawpkzV9HdzbpJjY3lqK8/iOjocZhMDAoLGczPB4suLSZiEfGFkhDxBsMyVld10OuX8O1v/xIWCwvvOHfuC9waqslEIzW1n8tvAVtADqHDpssFXB7Ixv9sOInx5a11lUA7hbhNR8orTJACxrROjGmduB+2geQVJU7MagGHE301D/ETa7/fdRlAXo9Ub28vlgVKi32ty6jVamxsbCAzM1PyNDI8PFxSRopQ+8xmM8LDwzkaoK91mbm5OdGlxURyEPHBwcFwOBzQaDT4xje+wWVu/K3L+Cot9qb5+Xn09fXh6NGjXh80lEql27qMzWbj6GQffPABRwP0tS4DyEfEC5UWh4aGcjRAkt2wWq2w2WzQ6/VYXV1FRkaG5PLrkJAQSYh44kjt27cPkZGRyMnJwcrKCkfdq6mpQU1NDZffysvLw+zsrOjSYiI5iPiIiAhQFAW1Wo2vfvWrsNlsgvktzyk+AXJIRcT39PT4XH9UqVTIz89Hfn4+lpaWYLVaUV1dDQB4//33uf4tX/ktQB4injhSnqXFUVFRbvktQkx8/PgxgoKCsLy8jIyMDFkZKTmI+OLiYkRHR3MDKeImCQ2k5ubmMDo6KjkjRXqkxK4/xsTEQK1WQ6VS4Utf+hJsNtu2egriXvLV1dX1mSDiPQdS5LAFAL/+9a+5/i1fAylge2mxGAk5Up4DKc/8Vnh4OObn55Geni4LyJGeni76a+Rq75C1p89Uy8s6dHdnory8AWFhszh8+B4OHbqHsbE4zk1qb8+DTreM/HwLzGYGRuMwxJYW8yUVEa9UOqHXr2BjQ4Pnn/8USqUTDGNCbe0J1NaeQHLyE65/i38Y8Fda7Ov6/DlSYWEzOHbsNo4evY2RkQRUV5/EwEAqOjtz8fbb/41zkwjNUEi+gBzeRDJSnqXFbH6rHbm57W75rerqU6iurkJw8DwUCjsyMrpFvw9saTEL5BCrLUeqGdHRz3DiRC0qK9n8Fk2bN51ANr9FiIkxMRNgGLNgafHQQjD+qf4Uaoa3T3kzltiHx26DY9t/E1JGeAz+MeMo7n/yKU6dOgWFQiFqXYZkpLKzs93WsfyJOFK+JtSe6zK1tbUYGhpCV1cX/vVf/5Vzk3xN+3eKiOc7Uv7WZUJCQqBQKCRNS3eKiCfTUn/rMuHh4SBADqkZKUD8+qNGo0FcXBw2NjZQWVkJiqK2rcuYzeZtBxy+I7UbGSkifn7rueeeQ09PD+7evYuRkRF0dXXhvffe85vfAnaGiDcajW73qE6n85rfunLlCgeAycvLE/195CDiNzY20N7ejry8PA4Ec+bMGY4GKJTfCg4O5g6bUlxKqYh4g8GA1NRUbGxscO85wzBcfovvJvEftv2VFnsTTdM+HSl+fot0S92/fx8LCwvo7OzET37yk231FELaTUR8YGAgRwOcmJjgsknd3d3QaDTc/SzlsEkyUpWVlaK/hjhSeXl5HAiGP5C6e/cu7ty5A6PRCLPZjPz8fOj1eu6wKQXIQQ6bYu+j4OBg5ObmoqamhlsVFDOQ8lVa7EuE/ujNkVIqlcjKykJWVhZWV1fR3t6Ohw8fwm63o7OzE7/4xS+21VMIiSDiS0tLJd1HcrV3yNrTZyqSkeI7CSwNcAzx8WM4deoGenvTwTBmPH5chObmMoSEzGBuLgyHDt2VdEhoazMhLa1PIiKedaRMJgYazTqKi1vc8luXLr2MK1e28lsZGT2SSouJVlZ06OzMRmmpOEQ8RQEJCcNwOpWIjJzAiRO30NZmQnNzKRoaCA2QdZM8M2FigRx8bSHivTtS/PzW1FQ4aHof7t07DJdLgX//979HTk4HzGbajQYoJM/SYjHaQsRvvSZ+fuv556+iszMLDGNGfX0FHjw4hMjIZ5icjMLBg1v3EQFbvPX4EFbsAhNUF7sqOKZxYFHlG9muVTrxD/uexxsFR1B9/QaUSiWKi4uh1Wo5GqCvdRlvjpQvra6uorOzE0VFRaKcBIVCgdTUVNy5cwdhYWE4fvw42traRK3L7GZGii/PdRmaplFfXw+Xy4Uf/OAHotZlyPVJXX8UQsT7W5eJi4vD2NgYDhw4IPmwmZCQIDojRV6TQqFASUkJ9Hr9tvJMsi5DsklGo5EDckj5OUlFxBMaYGNjI4KDg3H06FG3/FZycjLnJnk+4IgBcnhqfHwcT58+9bn+6Jnfommaw+X/+Mc/dnOT/N1HchHx/PvIkwbomd9KSkrC4OCgpPuIXJ9cRHxFRQUMBgOX3yJuEk3TCAoK4rJJMTExokuL+SKHzdzcXFHrjwEBARzoYWFhAYcOHUJbWxtHA/Q2kALkZe3EIOKjo6Nx6tQpnDx5ksslEifm5z//uaiBFCAPES/kSHkbSF25cgXXrl1DWloaent7ZWWkoqOjRWekyNcAwKFDhxAcHOzmJpGBVHh4OHcfhYeHiy4t5ksqIl6r1aKoqAhdXV1YXFxERUUF2trattVTCDnuJGsn5T7aifYOWXv6TEUyUrGx44L/Xal0IiurG1lZ3Vhd1aC9PQ+3b7P/OO/fP4KhoSTOTfKW3wJ2gojfXlrsnt8ygqZNsFrZ/JZevwSNZg1a7TLS0qRlpKSuP26VFt/kaIArK1oeDbAKNTUnN7ulGOTm2qBWr0NsaTFfUql9ERHTiI8fgculQFXVDUxPh8Nm28pvbfVvuf/c+Y7UbiLiVSo78vNtyM9n81tWawHu3TsMAHj48BDGx+MQnDqAH4xnwDLnPdAdtU4h1K4AE+zboTxm7MM/H7iL5KD/LxwOCDpSvtZlgoODoVarodFoJGUm5Kytzc7Oco4U+fAWWpchqyBZWVlQqVScIyUWyAFIX3+MiYlBamoqHj58iGPHjmFmZkbUugwfyLGbiHihdZn6+noAQENDA2ZmZkSty3iWFosRcaSysrI4R8qzPJM84LS2tqKpqQkRERFQKpVQq9WSDglyEPELCwvo7+/H4cOH3dwkch9dunTJ7QEnPT0dSqVSVkZKyvojRVFISEjA+vo6mpubceDAAczOznL5raioKO4+8pysiwVyCF2fL0fKM7/FMAyampoAAE1NTZwD60kD9NROMlL89Ud+fou4SeTefvDgAWJjY6FQKGT3SEm5j/iOFPkfv55CaCBF3DgxpcV8SUHEk3oKpVIJmqZRUlKCmZkZUQMpX6XFvuTPkRIaSLW0tMDlcqG1tZX7N+xvILUTRDy/tNiTBug5kCLXoVQqP/OMFB8RT9ab+QMpm83GDaTMZjPi4+O5+0gKkGOn2jtk7ekz09RUxGZG6oaoP6/VrmHfvlbcvXsEiYkDyMzsAcOYuPwW6yYxyMhwz28BrCMlHxEvfPBh81sjMBpH8NxzbH6rtbUYnZ3ZACj88Id/t0kDZPxCH/ilxWJFHCmTaWv9UadbRUnJI5SUPML0NMlvmXHhwqu4fPkFJCUNYGYmHIcOSSstloeIZ6l9FRX1UCqdOHv2Grq62P6thoZyPHxI8lssMTEoaEHQkfKn2VlpiHiDYRmlpY1obCxDfPwIElKeoKFlP6jeDOynXIjYpAGOaZxwefx9mUsq2OFCv154VTBKt4j/VXYLL6e2b15LM3p7I306UkLrMq2trVy/089+9jNR6zIA+9AQEREBo9Ho/43YlNDamrd1ma6uLmg0GqSkpGByclJWj5RcRPyRI0egVCrxwgsvbKMBJiQkcKsger1eFpBDKiI+ODgYhw4dAk3T3AqWxWJBR0cHF742mUzb1mUA76XFvuQtI0XkuS5DHInBwUEAbIZLzLoMsDNEPP+BOiwsjHvAGRkZ4QLqVqsVer0eaWlpGB8fl52RkrP+WFlZyRHviJtE8lupqakwmUzIzc2FRqPhgBxSe6R6e3tFI+IjIiJQWVmJzs5O6PV6JCcnc7mywMBAzikRAiyQQ8JuIuI981sEljM6yg6wPvzwQ65/y9/BcyeIeP59xK+nIG4SfyCVnp4uubRYLiKeOFKnTp2CWq3GwsIC17917do1t/6t7OxsqFQqyUAOgD1sdnd3i0bEx8TE4PTp0xgYGMDy8jKSkpK4gRS/nkIIHCQHET80NOQTEc8fSM3NzaGtrQ00TWNychIUReHChQuCNEAhkX8LchDx5D7yNpBqaWnhBlKZmZmSS4t3qr1D1p4+M0nNSAHujpTZTOPw4bsYG4sHTZtgsRTCZsuHTrfMdUsZjSNwOFSw2Vhqn1g8PLk+g2FRlCOlVDqRnd2F+flgdHbm4MiR2xgYSEFt7UnU1p7czG/RyMuzbYM5bGWkpCHiaZpFxHtbfwwPn8Hx47dx7NhtDA8ngGHMaG0tAgDU1p7E5GT0ppv01Of35ZcWixVBxPMdKZYG2I68vHYsL+thsZD81mnU1FQhNbUfc3MhiIiQVlosBxE/MsIi4pMPNuCfpjMxHuVC7NoaMpeUSNukAS4qXejV29FtcGBG7QLlYsuEB/UOrAt85n0juxX/uP82QtwOonVgGNZ5EONIkXWZ9fV19PX1oaKiAgMDA27rMmazGdnZ2dsecGZnZzEwMMDldcRIDCJeaF2GHMzu3buHhYUFmEwmv07EbiHi1Wq1W3mm57pMZmYmpqenJZcWy11/JIfN0tJSwfJMsi5jNpsRFhYmurTYUzRNi0bEa7VaFBcXQ6lUYnBwEMXFxRgcHBS1LiMGyCEkX4h44iYlJCRw+S2CFgeAxsZGDkHuSQP0lJyMlJAjpdPpUFJSgpKSEkxPT3OruxcuXMDly5eRm5uLyclJBAcHS8pIyVl/nJiYwPj4OJ577jlUVFTg7NmzXH6L0ABjYmK4/BYhA0oFcgDSEPEGgwHl5eUwGAz4+OOPUVhYiMHBQc5NIv1bnvktwHdpsb/r8+ZIURSF1NRUpKamcgMpmqbR2toKwP3Q6e898Qbk8CU+/ZE4UkFBQdxAanx8nPv9SAZSeXl5ePbs2TZqnz/JRcQTIMfBgwdFDaTElhZ7yl9Gii9STxEWFoaPPvoI2dnZGBwcdKMBehtIeSst9iey/ig0nBAaSPG3Ev4UVEGivUPWnj4TEZACm5FaEP11nqXFbH5rFPHxozh9eiu/1dJSjKamMkRETCI2dkxyRko+Ip6l9lVW1oKi2CLetjYTaNqMS5de4fVvMUhP7+FgGp6OlD9JQcRTFJCYOIy4uDFYLPkwGkeg1y+jsbEM9fUkv8W6SUIHNm+lxb5ks+VvOlLC77lev4yysiaUlTVhaioCDGPC48f7MD8fAqXSjvPnX4PJxPjNb5HDZkpKvyRE/IPmUjgVTvx/Bk3YUACggKdaJ55qnXiwSQPMWFKicEEF80IAJgOcmFQ7oXNS6PZwsbJDn+FfDl5HSczItu+zunoXHR1O7oFXrBiGQUREBE6fPg2KotzWZQgN0HNdRipIAZCGiCfrMsnJyeju7kZoaCh0Oh1HA/S1LkNek9yMlLfXRNykQ4cO4enTp1wWYHl5GSqVCpcvX4bJZPK7LiMXEU/W1ogjJbQuQ9O027pMXFyc5NLi9fV1dHR0wGQyyULEk5+vmHUZOffR+Pg4xsfHRSHiSX4rMzMT77zzDvR6PbRaLW7duoVbt2650QCF8hefBSI+PDwcx48fx7FjxzA8PMw9KK+trSEgIAA3btyAyWTym98i18cvLRYjTyfBM79FnJKbN2+iuroaqampiIuLk1xavFNE/GuvvQYAXPeeZ37LbDZzhyOpQA6AXX8U60iRgVR+fj7eeecdaDQaKBQKbiDFd5OEXqscRLw/al9MTMy2gZTFYsHGxgY0Gg3q6upEDaTI9e0UEe9vIJWVlYW4uDjJpcVy1x8JXfPLX/4yAAgOpMjqLhn6yclISUHEk4FUUVER3n33XYSHh0sCcuxUe4esPX0mGhpKwuxsGI4frxX9NXa7iuuREnKkPPNbNlse2C4n9hfO3btHMTcXgvx8G7Ra7/ktwL20WKymp8O3lRaHhc3i6NE7OHLkDkZGjCDERKu1AHr9EgoK2tDenouUFO+OlJAYRh4ifnVVj8OH7yIzswcrK4QGaEJNzSnOTTKZaC6HJra0ePv1mTYzUv7XHyMipjYPpQ7cvn0Cubnt6OzMBqEBbvVvbc/tjYwY/QI5+LI7KfxHWxkG20wY0TrZA5aHHAqgz+BAn8EBrQNIX1Yic0mFnCUVXHAhb1GFAJcDTwNX8ffF9/FGQRMCvLw3NtssHA6HpA8IIUfK17pMSEgICgoKYLVakZSU5JPk5imSkZJCWyNAjpdeegk5OTmi1mXElhZ7SgoinpRnarVa1NbWIj09HQzDcDRAX+syYoAcnhLKSPEltC5DyHLA1tRdzLoMyUjtFBHvb13GZDL5dKS8iaw/ykHEnzlzBvn5+YI0QM/8FnGkxAI5iMQi4imKQmJiIhITExEaGorq6mokJiZyNEBf+S3Ae2mxL/lzpPR6PcrKylBWVoapqSlu2ELWiTs7O6HT6fzmt4CdIeL5jhRZb+b3bz18+JDLb5lMJjx+/FhyRkrO2trAwAAWFhZw6tQpFBYWbqun0Gg0yM3NhdlsRnJyMiiKcistlnrYFIOIJwOptLQ0REVFobq6GlFRUaIHUt5Ki33J3/qj0ECK0AAB9n0kv2v9HUxIabEcRDzfkfKsp2AYBnV1dairq0NiYiLMZjMeP37s1ZHyJrmI+Pn5eUn0x93Q3iFrT5+JaNq06Uh1iP6ari6W2ufNHeFLq11DcXErcnI68eab/x0JCcNYWjLg009f5rlJ9GZ+a/sDsrfSYl/y5UixNMARJCRs5bcYhqUBOp1KuFwK3L17BCYT44ZIFxK/tFgaIt69tFinW0FJSTNKSpo98luv4fLlF5Gb2w6tdllyafHMTNhmRkoaIr6tjS0t/uIXP4bdrkJXF9u/1dBQgYcPDyEm5ukmMZHNb5HXJBbI0fIsDv/jwXNYHI7Dc04FegzCBcV8rSoBaxCb0frLYS2mA1wI3aBwYkoN1TxgDI3DUGAyUlKeCDpuDJODiAg94uPjxb0R8I329lyXISjfBw8ewOVyweVyob6+XtS6DB8RLycjRRwpMesyer1+G7XPn+bm5iRlpAD2QcNisSAxMRF/8Rd/wR3uhNZlCgoKuNctp4+sr69P9PojWZcpKSnBm2++iYiICAwPD3MPyPzyTKHXutuIeG/rMrW17NArPDwcLS0tgjRAT+0UEU8cKU8aoGd+q7CwEDqdTvJhUy4i3mKxID4+Ht/85jdF5bcAaSAFIn8ZKb4iIiJw4sQJHD58GP/7f/9vhISEoLu7GxaLBUFBQZwr6e2BdCeIeKF/u8RNKigo4PJbpJ4CACIjI9HW1iYqv8UvLd4JIp7UU3gbSJH7SE5GqqenR3RGishmsyEmJgavv/66Gw3Q20AKkHfYlIKIJwOp48eP480334TBYIDFYkFra+u2egohkYyUnPVHoftIo9GgqKgIRUVFmJub44Ytn376KQD2Z9rZ2SlqILUTRLzU0uLd0N4ha0+7LtaRKkBubrvEjBRbWpyaKp7aZ7Hkw+VS4vnnryAmZhyjo/Gcm0RogKR/Kz5+BBQlrrTYU2T90VdGikipdCA7uxPZ2Z04f/5ltLWZEBo6i1u3TuLWrZNISenfJCbaBEETJCMl5rBJtLLCrj96Q8S757cSOWLi6qoOCoUDbW2FUChciInxnd8CtjJSUtYfPR0pNr9lQ16ezS2/dfPmaVRXVyEtrQ8FBRa0tRUgO7vTJ5Bjfl2Nf3l0FO93FMMFCieXVFhRuDCkFe/MpS4roQIFW9ws/uvRGzArltHWZobNlgea3oegoHmwJdU0oqOfAWCBHAMDKaisXJWVkfLnSAUEBKCwsBCFhYW4ePEiHj9+DK1WK3pdZieIeG+OlK91GYVCga6uLuh0OlEuCb+0WKw8HSmNRuN3XaagoIA7JEg9bIrNSBF1dHTA4XDghRdeQEJCgqh1GeJIST1sikXEk3WZ4uJi7j4CgEuXLrm5Sd4Khv0BOYTkCxHvmd/q7u4GwzBobm6Gw+GAQqHA4OAgQkND/ea3gJ0h4okj5Su/deXKFeTk5KCwsBAMw0jOSNE0LXn9sbOzE3a7HS+++CISEhI4N8lbfguQDuQgEouIJ/mt8vJyXLp0CS0tLVhbW/NKA/SU3IwU6SPz/B3nbSB1//59uFwuKBQKTExMICYmRtTPi/RIyUHEkwO0EA3QYrG4DaSImywXyCFl/bGnpwcbGxvcfUTeI7LeLDSQElNaLCRfGSm+QkJCcOTIERw+fBiXLl1Ca2srFhcX8eGHH4oaSBFE/LFjx0RfG0HE8wcmfyrtHbL2tOvq6srC2poWs7Oh6OjIRmbmdhqgp/ilxb4yOp4ipcUEFW40jsJoHMXp09fR25sBmjajpWU/mprKERExCZOJxtKSHlKBHMPDiZsZKWmI+M7OXOTlteOLX/wYMzNhIP1bFy++wvVvmc000tN7ucORFCAHkVhEPJvfGkJi4hDKyxvwgx98DxERU2hsLEd9PaEBsv1bQlk6b6XF/uTLkeLntyYn2fxWW5sJFy68CgBYWtKjtzcNqan9bveGywVcHsjG/2w4ifFl9sNK7QSSVhToCHRsIwf6UuaSEk79Ms597UcI3QSXpKYO4OzZK9xq44MHB3H//mHExo7BZKKxuMh+cJtMjaK/z+joKCYnJ/HSSy+J/hqHw4HOzk7k5ubiy1/+sqh1GUBcabGnhHqkhMRflzl8+DDee+89hISEcOsyRqOR+/AWcj/4GandQsSTdRnPBxyyLrOxsYGhoSFR6zL80mI5iHiSEfO1LpOUlMR14QDSM1JyEPHd3d3IysrCV7/6VYyOjoKmaVitVthsNuj1eq5/i+S3yGuS0yMlxpFSKpXIyclBTk4Onj17hh/84AcIDAwUnd8i1+dZWuxPvhDxnvkt8h6RoQDAHvZjYmL83ke+Dgn+ro84UhRFudEAieNG8ltpaWkwmUyYm5uTlZGSg4jv6elBRkYGvv71rwvWU5DeJP4qob/SYiGJpfbxB1ITExP44Q9/CJ1OJ3ogBfgGcniTL0eK0ACrqqrQ39/PDaQIxCM2NhZTU1OiBlK7gYhXKBR+B1Imkwmzs7OSgRxTU1OiM1J8PXnyBGlpafj6178uaiBFXpNYIAeRHET8bmnvkLWnXRfDmKBWr2FqKgIffvg16HTLnJtkNA4LOiVCpcX+NDUVgZGRBEFEPJvf6kJWVhdWV7Wb+S0TamvZKZpWu4Kengzk5Vm30QCFREqLpSHi3dcfw8JmcOzYHRw9egcjIwmcm2S1FsBgWERBgQXZ2R3o6MhGebm40mIiOYh4qzUfgAt/+Ze/RkDABte/VV19inOT2P6tLUdSTGmxpxwOJSwW/44UAERGTuHEiVpUVtbhV7/6FoaHEzA2Fo9f//pbCAqa5/q31vWr+Kf6U6gZdj9ApG06Ut0Gu+jrM+mnEbdmRGXlQ+6ARRQQYEdBgRUFBVYsLRnQ1lYAhjHjxo0zAFzQapcxNDQGg2EJAQH+p6UMw8jOSJEPCLIuQ/q3hNZlcnJy0NHRIQvIER4eLgkR397O/pv45je/CZVKxX14X716FdevX0dGRgbMZjPXvwXIz0iJQcRTFMWty5w6dQrvv/8+hoeHMTAwgJ///Oei1mXEHjb58oWI97cuo9PpMDExgZCQEFE/LzmIeH5pMUVRMBqNMBqNbjTAR48eobGxkctv5ebmSiot5l9faGio34wUX93d3QCAb33rW1AoFNvyWzk5OVx+i0zYpQA5iPiIeF8OBz+/debMGfzmN7/B4OAgent70d3djejoaM5N8ra2JDcj5c2RMhgMXH5rcnKSe4/OnTsHiqKg0+mwsLCAiIgIUS7EThDx5IHas56CrDffv38fcXFx3OFmJ0AOKYj4/v5+AOx9RP4OhmHQ3d3t5ibxB1JiSos9xe+R8uVIKRQKpKenIz09HS+88AJ++9vfYnBwEF1dXejs7PQ7kALEHzb5Ioh4IUfK10CK3EcbGxtwuVyiDk2E3CoVEU8cKc/1ZkJM9BxIZWVlcaXFUg+bBoNBEiJ+t7R3yNrTrmp5Wc85UidPVqOvLx0sWa4Izc1lCA+fAumWCgub5b7OX2mxkMQi4rXaVRQXt6C4uAVWay4++uirUKnsuHTpZVy58jxycjrcaICe8lZa7P/6zIKOFJvfGkZCwjDOnLmO7u4MMIwZzc0laGioAAA4HArMzYWIcovkIuI9S4tLS5tRWtqM6enwzfyWCefPv4bLl1/YfI9odHRkSyotBoDu7oxNRLz4A/TqqgbDw4koKWlGVVU1OjuzwDBm1NdX4MGDQ5hWOzChd0JnsGOF90yauaTEjMqJSbV/N1Sr3MA/7LuPvBkt7nQY/a4/GgxLqKhoQEVFAyyWPHz88VcAAJ988hLU6neQl1foc12Gn5Hyl4Phi2EYQUS8QqHwui5z7x57CFYqlVhaWhK1LsMvLZa6tsZ3pDzXZfj5LYLytdlskjNSchDxGxsbGBkZQVFREaqqqgTLMwnumH9wI46UFES8WGoff13GYrHgk08+gcPh4NZliJvkbV2Gf9iUmpHSarXbHClCA8zOznbr36qtreUyXDqdDqurq6LuW35p8U4Q8fz8FnGTLBYLDAYDl03y5Uh5kxxEvNPpxMjICMxmM6qqqjg3qbq62s1N8nQa5GSkhPrIhBQZGYkTJ06gsrISNE3jwoUL2NjYwAcffMDRAE0mk9f1rZ0i4j0dKX5+a3FxkctvETfJ5XIhKCgIGxsbog5au4WIJwMpst5stVrR2trKDaTMZrOsrN3g4CDm5uZw4sQJ0V+jUCjw9OlTmEwmnDx5cttAyrMQnv+afJUWC0kMtc9zIPX48WNcunQJa2trogdSQqXFYuTNkdJqtdxAanZ2lnuPPv30UygUCjidToSHh8PhcIgaSMlFxO+W9g5Ze9pVWSxkbY2GUulEZmY3MjNZGmB7O+sm1dWdQF3dCSQlDcBkYhAbOyaptBiQj4jv60tHQMA6vve972NyMsrNTWJpgGz/Vnz8KHdg8VdaLCSSkSor8+1IKZUO5OR0IienEysrWvzHf7yBhYVANDWVo6mpDCkppH+r3asLxDBmyEXEHzmyHREfHj6N48frcOxYHYaGEsESHPPR1sYeaiMiJjEzEyr6QExKi+Ug4k0mGiqVHfn5NqxFz+ADtQ72kVhkLqlQMRuAslkVRrROdBscmApwInZNiaaQDcDPZ/IxYx/++cANJAXO4b33vofk5CcIDZ0VfX2Dg8lQKu34+7//N4yPx4Km/3rbuozZbHbLOcjNSIlxpPjrMouLi/j5z3+O+fl51NfXo6Ghwe3D29sDzm4j4oXWZUh5JkVRiIiIwPLysuiclBxEPL+0mE8DnJ+f5ybcly9f5vq3yEOpHCAHTdNISEgQjYinKAqjo6NQKBT43ve+h7GxMTAMg9bWVo4GSB6U+esyfEdKrAgi3p8jxc9vzczM4IMPPsDc3Bzu37+PhoaGbTRAIYk9JPDlzZHi57fOnDnjlt9qaGiAQqFAeHg4Njb8Q26IdoKIN5lM0Ov1KC0tRWlpKaamprj7+vz587h8+TJycnK4f/tyM1Lx8fGi1x8piuIKYL/3ve9xiPr6+no3GmBhYaEbcEIKkINILCI+MDAQFRUVqKiowLNnz/C73/0Os7OzuHv3LhoaGvzmt4DdRcTz15uFBlJKpVK0+0ckJyPFd6SE8lttbW3o7OyEVqvl3qOIiAhZQA6piHiFQoG5uTlQFIW/+7u/w9DQkKiBlL/SYiHxM1K+HKnQ0FBuIDU2NoY//vGPmJubw+3bt9HY2LitnkJIchDxu6m9Q9aedlUMY0ZMzNNtOG6tdg1FRa0oKmrF3FwIl0369NOXQFFOAC4YDMtwOJR+81uAfEQ8KS3WaNZhNI7AaOTTAM149Gg/GhvLERn5jMsmMYwJgYELkjJS5LApxb1ZWdFhZiYcVVU3kZdn49ykixdfxZUrL/Act638lhQgB19bGSnv648UBSQlDSEpaQhnzlxFXd1x3L9/BDMz4fjxj/92M7/F9m8RGuD217SFiBdyCb1f3xYi3hNsgSAHbEEOhGxQyFxi+65OTKnhAOteLajYYmGhTFaUbhH/q+wWXk5tB0UBw8NsafHBg/dFX5vDoYDVyq4/6nSrSEl5gpSUe3j++cte12UKCgq8OlK+ZLPZJCPi7XY7ZmZmUFlZiZycnG1uktC6jJjSYiGJWX/0XJepq6vDw4cPMTU1hX//938XtS6z24j44OBgHD58WBB3TA4hUVFRotdlyPqj1IwUcaSCgoIQFBS0jQbouS6Tn58vC8hBEPFS7iOlUomZmRkcOXIE2dnZ3EoRoQGSB5y4uDi39+izQsTz81srKyuoq6tDY2MjJicn8e6774rKb/FLi+Ug4j0dqYiICFRWVuL48ePcQynJb2k0GrhcLkmrt3IQ8fz1x5CQEISEhHD5LT4N8ObNm5zjlpOTwzlSUoEcpFRarHQ6HWZnZ3HgwAFkZGS4rTd7G0gBW0CO3UbEq9Vqzp1ZWFjAnTt30NzcjMnJSbz99tuCNEBPCZUWi70+IUS8r4GUTqeD0+mUtHorFxHPMGxpcUREBCIiIrwOpEh+KzMzU1JpMZFURDxFUQgNDcX8/DxKS0u5+g7PegqTybQNKCUWyPFZae+Qtadd0+Qkm5E6dcq3IxUSMocjR+7h8OF7GB2Nx/vvfwt2ewAuXHgVN26c5twko3HE6/obTZtlI+I9Dz5KpRPZ2V3IzmbzW1Yr279FaICAC2lpvVhfDxCV3wK2SotjY6Uj4gsL2dLgY8du4+jR2xgeTuDcJIulcDO/xXZLbWyoRJcWE7kj4sW9HpXKgenpCBgMi/jud3/IuZLV1ac9+rfcO874jpRYzcyEcoh4T7AFX3MBLjSH2tEcYkfsqgLPTapBuVw4MaVG2awLvXo7ug0OzGyuDn4juxX/uP82QnivWQoinqinJwPLywYP+uN9BAS4/K7LpKWlwel0ij4oMAxbWiwFEU/248kHjhAN0HNdZn19XXRpMZHD4eB6pMS6UWq1GgsLC9DpdHjjjTe4w4S/dRniSElFxD958sSnI0VRFOLi4hAXF4dTp06ht7cXH3/8MRwOBz766COEh4dzbpIvh4qsrcnNSPHFd5M812WuXr0Kp9OJtLQ0ye6IXES82WxGRESE1/xWZGQk94CzsrIiKyNlsVgkIeLJ+qJGo8Hrr7/Ore/5ym8B/kuLhUQQ8b4cKYqikJSUhKSkJJw5cwZdXV24ePEiAODDDz/k8lvEwfAmckjYDUQ8nwbomd9Sq9Ww2+1ITU2VNLSgaVpyRoqPiI+OjubWmzs7O0HT9LaBVGFhIZaXl2UBOaQi4oOCguBwOKBWq/Gtb30LNptt20DKbDYjKSnJ7Wfvr7RYSGIQ8Z4Dqfb2dly5cgUA8Pvf/x5GoxFmsxn5+fk+/63sBBHv6Uh5G0i1t7dDp9NhfX0dycnJkrN2chHxRUVFiI2NFaynqK2tdRtILS0tyQJy7Kb2Dll72jUxjAkU5RRN7aMowOFQYX1di5dfPgeDYRkMY0ZLSzGamso2aYAMTCbGbZWLlBbLRcSnpfV7/TNa7Sr272/B/v0tmJkJ/X/Z++/oOPL7zBt9qhM6IOecMxpVJAECYAADAKahJmnGsqxg77XXSWvvyrt799h+97277znvu+f6SCNpJCuMNGMreTTyaIbD4TABBAlmAgQBdAHdyDkRGSDQ3Ujdff8o/ArVjeruqgZHHt3F9xz9o2ET1c0CUL/v8zyfB9eunUVPTz4GBrLxxhv/le/fysrq96rMkNJi+Yh4ZocixdEAx5CSMoazZ6+htzcHpH+rsfEQtFo7FAoHkpJGJX8OBBEvT2XbVqSCg604ePAxDh58jLk5kt9i8NFHn8fly+soKOgETbPIyBiAnNJiMgQR/89LyajtO+L/BRTgULigcVG4G7GOdQWQbVWieFkFZlmNFe06Du5vwQv0AwQLDlhCIIfUwzN3fcT+2Cf4f20AmgEcBrDTLlNbW4u+vj4MDAzgm9/8piS7jFhpsb/xhoj3Z5cxGAx8iF3qBGJ/FCpS4eHhvF1G+MtbaJdhGAYpKSm8IiVHFZCLiFcoFAgODsba2hpOnz4NnU4nyS7jr7TY20hRpDztMvX19RgYGEB/fz/eeOMNSXYZsdJiqdfnqUh55rfI4YbQAENDQ3mqotQZHBzE8vJywIj4mJgYNxogWSR45rfi4+N5RUqOKuCrR0psVCoVoqOjsba2hqqqKmi1Wj6/5dm/JVRBhH1kcjNS/uyPwvzW8PAwGhoaMDw8jP7+fnznO9/hly2+VCMC5AgkI+WpSPnLb5GfXXJUtkAR8YTaR0Aw3hZS5JAcHR3tVZHyNXIR8RqNBklJSVhfX0dlZSWCgoIgpAF6W0j5Ky32Nv6ofZ4LqYGBAdy5cwejo6MYGBjAP/7jP4rSAD1nt4j4+Ph4/v/zXEgJgUJXr17lr0POYfN5z94ha2+ey7hcFNrbOduaN+uY2JDS4qIi7sCUm8vltzgaIINbt6pw6xbJb5lQVGTBwEAm1ta0sjJS7oh4aba1iIhF2GwGxMRM4cUXP0Z7O9e/tZ3f4tSkhIQJt8OUVCCHcKQg4rn8Vhfy87tgt+vAskZcv34WLpcSP/jBXyE9fQgMY0JBgcUnoMNkci8tljJms7giFRU1j5MnG3DiRANGR1NhMtGwWDhKocGwAqs1GGVljyQfNjccFO42l+OpdhO1M9LD4jlWFTYpF/oNDmwogAGDA2HYxP8rfBQJM2HofFiBrkdlyMrqB02zyM/vwsBA5tZhU/p9tLqqRXd3HkpKnogcshtADlnCiYmJwcbGBiIjI3H+/Hm0t7dLtssA8jJSExMTmJubw6FDh7z+GU+7DMtyBawulws/+MEPJNllyPUFmpHyfNAg4Wsxu0xoaCiePXuGsrKyXQE5pAxBxO/btw86nQ779u3D0tISryaJ2WUGBwdlAznkIuIpikJiYiJcLhfCw8Nx9uxZ/vPxZ5cJJGv39OlTTE9P+1SktFotSkpKUFJSgoWFBZhMJty5c4e/j6Tkt4DAEPHE/ih8T0IaoLB/6/Hjx2hsbERUVBTm5uZk3UcAd0/IyUiR1ygUChw4cAAGg8Etv8WyLJ/fKigoAE3TyMjI4BUpOYQ7uYh4skhRq9UIDQ3FqVOnwLIsHj586DO/Bcg/bALSEPGeCymibgHAj370I37ZIrQ3i83zQsR7W0iReor4+HhMTU2htLRU9iEhUET8wYMHERISskNNEltIySktJiM1I0VGoVAgOzsbzc3NMBgMPMSD2Ju9LaSAbUUqUES8twkPD8exY8dQWVmJiYkJPruZnp4uC8jxvGfvkLU3z2VGRlKwuBiBkyflZaTESou12jUcONCKAwdasbgYhvZ2Lpv0yScv4erVF6DT2aDV2pCaOiT5awWGiN9WpFJSxpGSIsxv0XjypBRNTRVb+S0umxQauhRQRspkomUh4nU6O0JDl+FyKfHSSx9t5dwYXLz4ihsNMCtrwO1Q6a+02NsQ+6M3RYrLb40gNXUE585dQ09PDm7erILVGoympgoMD6dvZdy857daZhLwf9e9BGbFgO5I6QqlwgVk2ZQY1nEHLGAbbJEWwtEZZ2ejYTJx/VsffvgaNJo16HQ2BAXZkZEhHchhNhf6sD82APj7Hf+vUJES++UtZpfR6/VgWRZpaWl+S4uFQzJSUm1rISEhfPbo7NmzfH+KP7uMv9JiX9fnS5ESs8vcvs0tHpqamjAxMcH/8valGk1OTgaMiPcsLQ4LC3Ozy5BsErHL6HQ6aDSaT6WPTDhCRLwnDdDTLsMwDJ9NYllppcXCkUvtI1ZEl8uFqqoqLC8vu+W3iOXSM7/lq7TY3/X5QsSrVCoUFBSgoKAAdrsdZrOZJ242NTVhZmaGV5N8lZMSIEegGSmhIuWZ3yLdUkQV0Wq1UKvVsvvIdoOIJ2qSWH4rKyuLz2+p1WpekfJXWiwcudS+mJgYZGVl4f79+zh69ChWVlZ21FPQNL3jGqQCOTzHnyLluZBqb2/Ho0eP4HK58OTJEywtLUlaSD1PRLxwITUwMOC2kIqIiEBQUBBUKpWsw2Yg9kehIiWsp/C1kFIqlSBADqEi5W/kIOJJPYXD4UBTU9O/GfCCzN4ha2+ey7Asl5HKz5feI0VKi30dfMLDl1BZeRdHj97FxEQiWlpK0NJyAACF73znP/P9W4mJ3vNbAKfePA9EvFLpQF5eN/LyOBogp9rQuHmzBjdv1iA+fgILC5E4dEg6SIFDxBsDRsQzDAuFwonjx7n8lsnEwGw28vkt0i0VH/9UcmmxcLYR8TckKVIq1SYKCjpRX1+DlJRhGI0dYFkGdXWnceMGl99iGBPy8zuh0Wy4gS0OzWuwSbkwqPcPPyGTYldA66TQa3DsAFuQiY6eRXX1TVRV3cLwcCpaWg5s0RIpfO97/2nLlmpCbOyMz6/FsgyiomaRmDgh8l/vA1gHoPF4zU5FypMG6GmXSU5OxtzcHMrLyyV/DrtBxOt0OpSWlkKpVEqyywRySCAZKamIePKAc+/ePSQmJqKwsNDNLiP85e35gCP3sAn4R8QL7TKnT59Gf38/Wltb+Z6wH/3oR5LsMuT65CLixe4jb3aZS5cu4cqVK0hLS8P09HRAhwQ5GSlyfUFBQTh06BBUKpWbmkRogML8VlhYWEBADrmIeHJvNzc3Q6vV8tCHixcvuqlJmZmZO5QJuYdNwD8iXpjfOnfuHHp6etDW1sb3hL3zzjv8ssWf3csbkMPXEPqj8D4S5rdmZmb4++jDDz+ERqNBZmYmJicnZR8S5GakyHvSaDQ4duwY1Gq1qL05MTGRh+UYDIaAgBwkI3X48GFJihShAZrNZh4YIlZP4bmQIu/peSPiiZqUnZ3N27BNJhPfE/aLX/xC0kKKXJ9cRDyxPwo/c38LqezsbL+KlOc8b0T8b3v2Dll7s+txz0jJQenSCAl5howM7xkpMhQFJCVNYHw8CQCFc+euYGQkFS0tJXj8uHwrv8WpSZ4obl+lxd7G5QLa2wkiXlyR0ulWUVLyBCUlT7CwEA6WpfHwIWcXq609i+HhDDCMyY0GKDaktFiOymaz7UTEi+e3GDQ1leHRo0OIiZnG+roakZGzskqLtw+b0g9m26XFd7F/fxvKyh5jbi4KhJh44cLnoVavIyRlHJc3wmGGFhQ4RWpIoEhJmWyrCjaFC8fpFvzdwQY3sIXnUJQL6enDmJuLRns7g6qqGxgdTcWDB4dx//5RxMdPgqZNKC7uQHDwittrFxc5IMfJk/VeDpvuuSxg+xeEL0VKaJeZnp7mLU4AcOPGDUxMTEiyy/T19T0XRLw/u0xSUhLsdjvCw8NlZaQCsT8KEfElJSWi5ZlarZZ/wCFqipTSYrHrk2p/VCgUyMnJgdVqRWdnJ44ePYqxsbEdNMDCwsId1+CrtNjbkPvIFyJezC7T0tICALhz5w7m5+dB07TP/BYQOCLeU5HypAES1Ybkt9LT02G1WhEWFiYbyLEbRHxZWRmf3yL9W+3t7QgODuY7yuLj43fVIyXV/qhSqVBYWAiHw8GrAmNjY6irq3Pr3xIrX/VVWuzv+nwpUjExMaiurubLzgmdFAAePHjALyL82d6EpcVSR0yR8lxIEaXk2rVrfNn58vJyQBkpuYh4oSJ16NAhVFdX77A3h4eH8xbwqKgo/ns3KytLVkZKDiI+KCiItx4PDg7iwIEDGBsbk7SQ8lVa7GvEMlJkxBZShLwJAM3NzXy1hr+F1G4Q8fn5+T6V6t/G7B2y9mbX093NKVLFxXIOCaS0+BEUCv/FsWQIIr6srAllZU1YXdVu5bdo3LpVjVu3qpGWNgSaZlFYaIZWuxZQRmp0lMtIHT/uPSMlnIiIRRw5ch8PHx5CVlYfIiLm+f4tjgbIERMTEiZ3PKBLAXJ4DlGkvB3MVCoHCgq6UFDQBZtNB7O5CC0tB7C0FAvAhV/84g+3aIC+1TOx0mIpQ+yPQkR8VNQcTp68hRMnGtDclY/3bp/CymA6Drko0EoXpjUOaJ0U+gzSVSyNE0hfVSDT2IE/Onpd8usIkOPo0XugKMBqNaCjwwiWpVFbexZ1dae38lsm5Od3Q63e4IEcvjNcDRAeskhG6vDhnVktsYmNjcXJkyfR0tKCtLQ0RERE7LDLMAwjmg9h2cAR8d4eNMTsMq2trZifnwdFUXjvvfck2WUCRcSTjBRBxHuWZxK7DKHdRUREICkpKaCMFAFyyLWtRUREoKqqChRF8XYZk8nEh6897TKBZqSkIuKJXSYhIQFmsxlxcXEICwvjaYC+8lvkPYmVFvsaf4qUTqdzy2+xLIu2tjYsLi5CoVDgww8/FKUBio0YkMPfeCLihfktYf9WU1MTHj16hNjYWCQnJ8suLRYi4uXa1sLCwnDmzBlQFIW5uTn+cHPhwgV+I0/yWwqFIqDDphxEPMlvpaWlob+/HwaDASEhIby9OT4+HgzDwGg0iipVRJGSm5HypUgFBwfj0KFDOHToEL+QMplMWFlZgVKpxKVLl+BZT+FtAslIedofPe3NYgup5OTkgIEcgSLiz58/D4qi3Pq3xBZSFEUF1CM1NzcnGRFPFlLZ2dkYHR2FRqOBwWCQtJACtg+bnyYi/tOcvUPW3ux6TCYGFOXE1avnt9QkFhERiz5fs11aLF0dEUPEa7WrOHCgBQcOtGBxMRykf+vSpZdw5coLyMvrwvBwOjIy5JUWbyPipdsfe3tzsbamQ0XFQ2Rn9+Ps2evo7eX6t5qbS9HY6J7fCgtbEihS0oEcgDxEvF5vx8GDzbBag/H0aQIqKh6huzsPFy++isuXP8fTADMzB3Zcg6/SYm/DIeKNooj4TSeFt80H8UbbEdiDNFAmryLVrkC2VYV0O6ekHFxUI3zDgT7DJuw+4j5a5Qb+InIE1jEjTlU8kHx924j4bUXKYLCivLwR5eWNmJmJBssyYFkaH374OjSaNRQUWDA4mInU1CGEhy/5+NsbIMxleR4SpExfXx/sdjsOHz6M3NxcSXYZkpHyV1rsOQQRL0WRInYZh8OBmzdvYv/+/ejp6ZFkl/FVWuxtiP3RmyLlaZfp7OzkLY4AcP/+fSwvL8NoNPpVtISlxVJHTJES2mVIubDQLmM0GtHb2yurtBgIHBFvtVpx/vx5FBQUiOa30tLS+AccrVYrubRY7PrCw8MlKVIRERE4fvw4VCoVbty4gaKiIvT19YnSAD3vo6dPnwaMiM/Ozha1TQnzWzabjScmEhWwubkZGxsbfvNbgHtpsdQhipTQ/hgVFcXTAEdGRngVgDxEFxcXo7u7WzaQI1BE/PLyMk6fPu2VBuiZ3wo0IyUHER8bG4uamhoYDAbU1tYiOzsbZrN5Rz2F2OfjrbTY1/ij9oktpFiWRWNjIwBOgVUqlTtogGLzvBDxYgspk8nEL6RomkZXV5es0mJg+7Aph9o3OjqKpaUlvPLKK2AYRnQhRWA52dnZUCqV2Nzc5OmPcg+bwcHByMzMlPyaT2v2Dll7s6uxWvXo68tGZmY/HA4VGhqq0NBAaICcmqTTre54nbfSYl/jDxEfHr6IY8fuorKSy2+ZTNyD8tqaDuPjKly9eg40bUJi4oQXuxc3wtJieYh42k2R4miA3cjP5/JbZjNH3ePyW9VITx9CSMhSABmpQBHxHJDjzJnrOH36OkZHU0D6t9rbuWsnxMS4uKegKGmlxZ6zjYh3f08tMwn42wdnYJnf/mHuoIBBvRPj2nV8ZUyLqSAHVC4KFYtqlC2qMKF1osfgwLDOgU3BgpuALerffw26ABHx3uyPMTGzqK6uR1XVTQwPp8FkomE2G7GxocH6ugY3blSDYVjExIjlt7ZzWQ6Hg7csyM1I6fV6ZGVlAZBmlwkNDZVdWrxbRPyLL74Ip9Pp1y5D3pPcw6YcRHxQUBD27duHgoICfOMb30B8fDzW19cl2WXI9YmVFvsaX/ZHQgNMTEzk+7fIg7vD4cDGxgZu374tyS7zvBDxvvJb5AEnJCREdkYqUER8e3s7kpOT8fnPf563ywnzWzExMXw2KSwsjH9PcjNSBBEvRb3R6/U4ePAgGIbBN77xDURHR2NxcREXL150698Sy2+R63seGSkyFEUhLS0NaWlpfH7LZDLh0aNHcDqdvLIkJb/lDcjhb4giRXDqYjTA9vZ2Pr9VWFiIkJAQ2RmpQBHx7e3tSEhIwBe/+EWsr6/zhfDeFlLkPck9JMhBxJOF1MGDB/GNb3wD4eHhmJycRG9v7w4aoNh73Q0iXuwz97aQIlChsLAwPH78WNJCihw2MzIyArI/EkXK20LKYrHwC6mQkBDZihQBcpSVlcmyP35as3fI2ptdjdlshMulxKlTdYiLm96i3HFq0iefvIirV88hN7cHDGNCdnYflEqH5NJi4chBxJP8VlLSBDY3VWBZGpmZg3jypARNTcL8FiuqSngrLfY1/hQpnW4VpaVPUFr6BAsLEXw2aWgoA4AL9+4d2cpv7VSTPMdk2g0inlOkOBrgKFJTR3H27FX09uaCZWk0NZXj0aPDiI2dgtHYjo4OcUXK17AsvYWI56h9QrCFC+K/PDOtSihB4VHEBuY0LoRtUMi2KpFjVaJqToONLRjGTMQKvna8Fi9nWbC4yAE5qqqkATkAof1x0I8iRfJbQ0hPH4JC4URb2z4kJo7jwYMjuH+/EgkJE6BpFkZjO4KDrVuv2s5lBZqR6u7uRklJiagi5WmXIQ84vb29oCgKT548wcbGhmS7DBB4RgoQpwF62mWKi4tllxaT6wsEEe9wOHD27FkkJSV5tcswDIPk5GTe4uevtNhzhIh4f4oU2V7n5ubi8uXLePLkCSIjI3fYZYqKikQP40SRep6IeM/8Fsm42e123kKkUql20ADFJlD749TUFG9/9MxvEdWmvr4e9fX1SE9PB03TYFk2YCCHXGrf5uYmzp49i9TUVIyOjvJqkjC/RRQ3YLu0WCqQQ3h9UhQpkt8qLCzElStXeHy2lPwW4L202Nf4U6RiYmJQU1PjBsuxWCxYX18HRVHo7+9HcHCwJCLh80DEazQafiFFCJdkIUXUruLiYj4jFQiQQy61b2NjA2fPnkV6erroQoqoX2QhJaW02Nv1SVGkyEJq3759uHr1KpqamqBSqSQvpLyVFvsaX4h4z4UUUdxaW1uxubkJiqIwNjaGqKgoSaTdQOyPn+bsHbL2ZlfDsvSWIjUNAAgLW0Jl5T0cPXoPk5OJMJlodHQUo7OzEDqdDUZjB9bXVQCklxYDgSPiLZYiFBVZ8OqrF7C6qoXZTPq3hPktEwoLLXwhbWAZKaNkRSoiYgHHj9+G0diOf/zH/4jk5DEMDGTBbC7eym9xalJ8/M78FgFyBI6It+z4b1x+qxMFBZ18fosobgDBnzOSyp+FpcUU5cQnQ3n4H43VmLL53njl2JRYUDsxp+byeUtqF56Eb+JJ2Cbi1xTIsSqRtwbkjoVj4OOzuFGciPV17oc1TUu/j8bHk7aAHPckv8bhUKKzsxAFBV14/fXfYGWF5LcYXL9+FrW1XH6LYUzIy+uCWt0A4PAORUrK+MtICSc2NhanTp1CSUkJvve97yEuLk6yXcZbabG/8WV/1Gg0YBgGDMO42WWuXbsGgFM8LBaLJLsMOWzu378/YES8t/yWp11mfZ27pwPJSMlFxHd2diI/Px9f+MIXsLi4yH9G3uwyAPeZ+yst9hyp9EeS30pKSsKhQ4fw3e9+F1FRUXx+i9AAi4uLvd4ngWSkfNkfCQ2wtLQU8/PzvOL28ccfA9jeVEvJb+0GEU9Ki4U0wLNnz6Knp2dHfovcR3JBCnIyUmScTie6urqQk5ODP/iDP8Ds7Cz/GV24cAEajYbPb6Wnp/OfETlsyin4lYqIpygKGRkZyMjIwLFjx/Dd734X4eHhovUU3lS0542IDwkJEV1I9fT0AAAiIyMxPDwsam/2HGFpcaCIeG8LqTt37uDOnTtISkoCwzBYXV2VfUgIFBHf3d2NrKwsfPnLX3br3/K2kCLvKZCMlBT7o1KpRE5ODnJycrCwsIDvfe97CAkJkbyQItcXGxsry/74ac7eIWtvAp5tRWoncICigMTECSQmTuD06Vr092eBZRm0tu7H5qYaavU6Wlr2S8pvAdsZqcAQ8dzBR6tdRUlJC0pKWrCwEM73b1269DKuXn1hC83ehZ6eHFRUyM1I0YiNnUJcnP+MFBkOIe7C7/3ev8JgsG3RAGk0Nx9EYyNHA+S6pVgeOkGAHL5Kiz1HDiKe5LcOHmzGL37xFYyOpmJ1VYuPPnrVrX+Ly2/tBJaQ0uK47D78uxuvoX7MP4QhZJNC/JoSTWEb2CF0UUBY/BT+y+Hr2Bc1he7uXLAsg0ePDsHpVEKjWYPFUoji4vYdNECxMZmI/XHnYdPb9PVlu9kfg4OtqKhoREVFI2ZmYvj+rQ8+4PJbhYVjyM/vRldXF49FlzokI5WYmCj5NSSD9Pu///vQ6/V+81uAtNJizxEi4v0pUsQuc/jwYfzyl7/krTbvv/++JLsMOSTIeWD1hYj3Z5fRaDQYGBjge6/8DTlsBpKRIu8pPDwclZWVOHr0KCYnJ3k1SWiXKSgoQGdnZ8BADjn2R4uF+5744he/CIPBwKtJhAaYlpbm1r8FbJcWSwFykJGDiI+MjMSJEydw/Phx/Mu//AuGhoYwMzODd999129+CxAvLfY3vhQpoZokzG/duHEDAHcfjY+PIzQ0VFKGxBPIIWU8EfHR0dFu+S3Sv2Uymfj8VmFhoazSYjKB2B+7u7sBAH/wB38AnU63I78lLDsn1yKltNhz5CDiyUKquroa7777LgYHBzE+Po6f/vSnO+opvL2nQDNShw4d2rEMEC6kSDchy3L1FACnNs3OziIyMlLS9/1uEfFCGqDQ3uy5kCoqKpJVWiy8PrmI+N7eXrhcLv4+IosEXwspYWmxHDX505y9Q9beBDwsy/jMSJFRKp3Ize1Fbm4venuz8O67X0VY2JJHfsuEoiILtNqd+S2iSAWCiA8OXkZGxsCO/xYRsYhjx+6gsvIOxseTwLIMOjo4GiAALC8HY2IiEQkJvvNbgHtpsdyMFIeI5+yP+fldyM/vgt1O1CQa9fU1qK+vRkbGIGiaxfBwqqzSYkCIiJee+7LbdRgaysDBg004c+Y6RkdTYTLRsFg881smt+4xE8tAGbKMLzx4EXaHtB/C2VYlXHDtoApqlRv4m3338WfGx1BvHXiLiiwoKrKgtzcb7777Fej1NtTWnkFd3SlkZg5s9W91Qa3eeZ8QIEdeXrds+6Neb0VWVt+O/xYTM4OamnpUV9/E0FAaWJaBxVKEtrb3AHC2rZmZGUnbWZKRIr/0pIwYIl4Yvhazy9A0jaGhoYB6pAKxPw4PD2P//v04e/asJLsMwD18+iotFhup9kehXaanpwe/+tWvoNFovJZneo630mIp1ydmfxTaZYS445aWFh7l73K5sLi4KEl13C0invw7eNIAiZp05coV/gFnYGBANpBjcHBQNiJ+Y2MDIyMjYBgG586d4/Nbjx8/dstv0TTt1qVDgBzeSovFxldGSjgkv3Xw4EF0d3fjvffeg1KpxEcffeTWv0VogJ6zm4yUmP1RmN964YUX+GzSo0eP8OABBwZSqVRYWVmRZJN7Xoh4sfzWBx98wOe3GIbh7c5yMlKB2B8dDgdGR0dB0zTOnTu3gwaYmJjIExOFC4DnnZESTmhoKI4cOYIjR46gq6sLv/71r+FyuSQvpLyVFvsbb4h4QgPMycnZsZAiSymtVgu73S7p55+wtDgQ+yOx43pbSOn1el5xIwd8OffRpz17h6y9CWhcLoo/JISE+FcQyHR1FUKtXsef/umPYbPpeTXpk09e4tUkmib5Le7BmiDi5WWkpCHiKQpITh5HcvI4zpy5jh/84C9htQajs7MQHR30Fg2QBU2zCAsTz/AE0iPlCxGv09lRWtqM0tJmzM+T/BaDixdfAeBCWNgiRkZSJeW3uOvjSoszM3ceNr2NsLSYy2+NIDV1BOfOXUNPD+nf2s5v0bQJ9hAbxkZT0RS2AbtjU9oXcgE5ViUmg5ywqrb/nQjYIi1E/DPv6cmDSrWBv/iLH2F5OYTPuH344WtbNMBO0LRpK0/F/b29vUSRkn4fra5q0d2dh5KSZv5+FBuKciEjYwgZGUN44YUreOut/wfPnm3w20CpdhlA3i8IX4h4oV1mamqKP9wQu0x4eDimpqYk2WXI9ZFCSakjVKT82WWSk5NB0zSSk5MxPDwsubQYCBwRPzAwAKVSib/8y7/E0tLSjvJMQkwU2mVIabEcOw95WNm3b59PZVOY31pdXcU777yDxcVFtLS0oKWlBampqbya5MsuA8izP05NTXlVpAgN8NixYxgfH+cD6mazGRRFISwsDIuLi9DpdJLvo90g4oU0QLH8VkZGBo+ollNaLLy+pKQkWdS+kZERKBQKfO1rX8P8/DyvJhHKWXFxMUj/Fhl/pcViIxURr1KpUFRUhKKiIlitVvz0pz/FwsICmpub8eTJkx00QLGRetgUzvT0tFdFylt+q62tDRRFITw8HDabTfKB0xPIIWWEiHhvNMCrV6/yQCHyve9NkfJ3fXIR8ePj46AoCl/72tf4UmiykIqIiOAt4MIcKHEJeCstFhtC7fOHiBcupJaWlvDLX/4S8/PzaGpqwpMnT/wupIDtw+bzQMT7W0gplUrZpcWf9uwdsvYmoBkZScXSUjiqqm5Kfo1nabFGs4TKyrs4epSjARI1yWIpgl5vRVFRBxiGhcnESC4tJhMIIn5xMRzz89GoqalFSUkLn9+6ebN6iwY4uEVMtPBKiHtpsXREPMtKQ8RHRi7gxInbOH78Nu7dO4qbN2tgt+vx7rtfgcGwguLidtC0CfHxT0VVNLHSYmnXR28h4t2pfSrVJgoLO1FY2AmbTY+OjiK0mvbhxo3TcMEFwIVNygWVE240QG8Tu65A2KYCraGcjTFGt4L/WXYTL2V0elUFOUWqiAdyBAWtoarqJk6evIXh4dQtNakQJtM+hIQ8Q3ExC4ZhwbLMliLVL/lzMJsL4XCoZN1HVqsBc3M2VFVVYf/+/ZLsMlJKi8VGKiI+Li6Ot8vcvXsXDQ0NWFlZkWyXESstljLCjJRwfNllyAOxXq/H5uamJLtMIIh4okgRap9er99RntnW1obm5mZERkbyDziBADkCsT+ur69jdnYWx48fx759+3g16dKlS25qktAuI6W0WGyIbc2XIkVRFJKTk5GcnIwzZ87wh+Nnz57hJz/5CZ/fommapwGKvafOzk7QNP1cEPHe8lsXL16EQqGAy+VCeHg4nE6npAdkYWmx1BEqUsHBwQgODkZqaipPAyQY74cPHyI2NhYMw/DwhUAyUnLtj06nE3Nzczhy5Ah//7Isy9MACwoKwDAM0tPT3Q6jgWSkpFD7hPmtF154AXfv3sXdu3exsLCAH/zgB0hISODVJG8HrkAR8SzLiiLihfZmz4WUSqWCy+VCTEwMXC6XpAN7oBkpYn8MCwtDWFgYb28mipvnQqqoqIjPSMntI5Nrf1SpVJifn0dZWRlompa0kAKkAzmEIwUR77mQunfvHu7fv/+Z6MYSzt4ha28CGpOJlp2R8qZICWmAp09fR39/NliWRktLCR4/LgfgQkrKCJ49C0N4+KKkrxUoIp5Q+zzzW0RN+vjjl7f6t7rBMCao1WuySosBkpGSh4inKGB8PBnBwcv467/+Lp9xa2oqw6NHJL/F9W8JgRj+SovFZn6eo/ZVV/u2P+p0NkzHPsOPQ9VYda7ipakgqFzA4UUNDi65MKRzoNfgwITWCZeXvyfHqsQm5cKQ3oGv5LXi70puI8yPlc8bIp6jAQ4jPX0Y585dQU9PHliWxsOHh/HgwVEALqSmDsNu10vKbwHcfRQdPYOEhAlJf557DUHEF7vhjkl5JrHLBAUF8Q84KpVKVmkxgIAQ8QqFAtPT09Dr9firv/or3nYlpAGS/JbQLkOAHHIR8d4yUsIhdpnDhw/j6dOn+PnPf87j12/evLmjPFNsAukjI4qU5y9lMbuMyWRys8ukpaVhfX1dsl1wt4h4TxqgEHcstMtQFCW5tJiM52FTyiiVSiwsLECr1eJrX/saf5gg+S1CAxTmt4DAMlJSEfHC/NbY2Bh+9atfYXV1FZcuXcKtW7dgNBp5NcnXfbTbjBQZz/wWWbYQGiAApKamwumUs/ySn5ESUvuE+a3h4WFeTSL9VERxA7i8XSAZKTn2R7VajeXlZWg0GvzFX/wFf5gQ1lN4LqSAbSCHXER8X1+fX0S8cCE1ODiIDz74AA6HAxcvXsTt27d31FOITSA9Ut4Q8UFBQV4XUgQqlJKSIltlk2t/JNS+ffv2IS4uzudCiixbHA6H5NJiMoEg4ol9US6Q47cxe4esvZE9GxtcRqqw0CIzI+VfkeLyWz3Ize3B6qoWly+/gI4OGqOjaXjzza9v0QC5/i1CA/ScwBDxOzNSZCIiFnH8+B0cO3YH4+PJfG+S2WyESrUBhcKB8PAFuFyQlMnq7c3F6qoODCMPEd/bm4OyskZoNBsoKOhCQcF2fstkYlBffwr19TVb+S0TCgo6Iae0mAw5bPqi9o0uh+K/PzrFgy1iXRS0LgoNEet4pnYhx6pEpk2JHJsKVqUL/fpN9BocmNdsWwIVLiDTpsR8mA3vf+5dlMaNS74+ISJebNTqTRQVmVFUZIbVasDVq+dgNhsxMpKOb33rPyMrqx80bUJ+frdofgsQLy32N+Q+SksbQXi4+wMrKc+sqqpye8Bpa2uDRqMBRVGyrCW7QcQfOHAAOp1Okl0mLy8vICCHXLQ3RVFwuVxYXV3FCy+8gIiICH7rTsLXYnYZf6XF3kaKIuVpl7l+/To6OzsxPDyMN954Q5JdhmSkArE/eiLihTRA8oBjMpl4u4xWqwVFUZJKgckMDAzIzkgJS4tDQkJ85rdIt1RWVhYIkEPO9QVyH6nVatjtdpw+fRrh4eEQowEWFxe72Yr8lRZ7G5PJ5FeR0uv1KCsrQ1lZGebm5lBXV4fu7m4MDw/jm9/8pt/8FvB8EfEURSE9PR3p6eluihuhAZJDkpwy190i4iMiItxogN4WUmlpaV4VKV8jFxGvUCgQGhoKu92OqqoqhIWFSVpIyQFyCMdkMvlFxAsXUlNTU7h58yZ6e3v5n0diNEDPeZ6IeM+FFLHIEhog+f6So/oHiogPpLT4tzF7h6y9kT09PXlu1D4pQ0qLKyp8Z6SEo9WuYn4+CnFxT/HFL74H0r916dJLvJrkmd8C/JcWi83oaCoWFyNw4oR3RDyX3xpDcvIYzp69jq6uPHz44WtwuSj89Kd/vJXf4tQkb/ktcn3egBzexhsi3j2/Fclnky5efBWXL38Om5tq7NvXApdLAYryvzElPVLeEPGbTgpvmw/ijbYjsG9u/zDjFSmDAxsKYErrxMPIDaTaFci2qmBcVoFeVmNO7USvwYF+/SaSNl3QOin80bmLyJd4wNpGxD+WbH80GKx49iwU0dEz+MIXfg2W5WiAH35IaIAW0DSL9PQhUNT2vUkUKTn3+fh4EubmonH48EWQvizPUSgUbnYZi8WCjz/+GC6XC++8844oDVBsdoOI93zQ8LTLCHHHGo0G6+vr2L9/v+SvE2hGiihSxcXF0Gq1O2iAYnaZsbEx2YdNYsHxl5ESTlhYGOx2O3qRiFUAAQAASURBVCIiIvD666/zapLQLsMwDI+PJxNIRkoKIt7TLmM2m3HlyhW4XC689dZbSEtL49UkX0onyUjJtT+KlRZ75rdMJhPMZjM6Ojqg1+ths9lk3Ufk+oRADqmvUSgUYBgGer0eBQUFO2iAN27cQEZGBhiGQUFBAUZHRwPKSHV2dsJoNEq2P0ZFRWFzcxOhoaF49dVX0d7ezl9XSEgIT0z0tFcFmpHyh4hXq9Vu+a329nbU1dUBAH70ox9Jym8BzxcRL1xIeea3QkJCsLy8jP379+8KyCH1NRRFYf/+/QgODva6kMrJyQFN08jNzcXY2Jjk0mIyGxsb6OzslIyIJ/UUFEUhODgYL774Ijo6OnbQAGma3mEblgrkEM7s7KxfRSooKAj79+/H/v37sbS0xB+2AOCtt96StJACAkfEyy0t/m3N3iFrb2SPyURDq7UjLm7S/x/eGnJIkGNbm52NwsREEk6duo7w8EUcO3YXlZVcfstkYmA2b+e3jMYO0LQJCQmTkkuLPd8Tl5HqkvTnlUoHKMoFp1OJ3/u9X8Nm04N0S3H5LdK/1elGsiMZqfLyRsmHTUAaIj4ych4nTjTg+PEGjI6m4Nq1c5icTEBb2wH09eXw/VtxceL5LWBnabFwWmYS8LcPzsAy7/7LnyhSQzrugEXGQQGDeicG9esIcgBZNiVyrCpULKpRvqiCTmeDU7OK9NRhyZ8DQcTLyUgtLGyXFsfEzKK6+iaqqm5heDgNJhONzs5CtLXtR2joEp9xi4mZASkt9nVg9hyWFSLiGyB2yBKOWq2GVquF0+nEK6+8ApvNtsMuwzAMcnNz3X75+ist9n59/hWpuLg4nD59GjU1NRgcHERdXR2mpqbQ2tqKwcFBSXaZQDJSQkS88FAgVJPE7DIGgwEajUYWHthisUjqkRKOsLRYLHwtZpchKkpKSkpAh02p1D6tVovQ0FA4nU6cP3+ev48uXbrkhjvOyspyu1/8lRb7uj5fipQwv3X27Fn09vbi5s2bsNlsaG1txdjYGK8mectvAc8XES+kAc7NzfFKCaEBGgwGqNVqWYdNkpGScx8JFSlPNclkMvH5rbi4OP4zCgkJEVWk/I1c+6PBYEBsbCycTidOnToFu92O9vZ2Pr9VWFgI0r8lPODsJiPly/6oUCiQmZmJzMxMnph4584dLC8vo7W1FVNTU5IWUs8TEe9tIdXd3Q2tVguDwQCVSiUbyBEoIr6iooJftojRAMlCymg08ih0uRkpKVk74ZCOOafTiRMnTsBut0taSPkqLfZ3fcHBwbJ+B/y2Zu+QtTeyhihSLpcS3/72f0Fubg8YhqhJDq+v8ywtljJiiHhhfuvMmevo68sGyzJ48qQETU3lCA1dxLNn4SgvfyT563BADqOksl3P6wsOXkZ+fhcUChdKS59gYYHQAGl8/PEruHKFdEuxyMrqD+iwuY2Ir5VkW6MoICVlFKurWqSnD6Ks7DFYlvagAXL9W57WSLHS4mfrGvzDk2P4edcBuHYUWQGpdgW0Tgq9Bu///mtKwBLiwEzsEv427zEiZsLx8OEhABS+9a3/wtMAMzIGfR4+t+2P0g/424qU8D5yIT19COnpHA2wuzsPLMvgwYPDuH//KKKiZjA/H4XS0seSv47DoURHB4eI56ysDQD+XsL1cYqU0WiEUqncUZ7Z29uLoKAg/gEnLS0NZrNZcmkxGYKIP3nypKQNMHnA2dzcRHJyMg4ePAiTyeTXLgME1iMlBRHvaZd58uQJmpubAQDf+c53JNllAO9ADl9DbGvCB2p/dpn4+HjMzMzICsALM1Jy7Y9arZbv1CL5LaImmc1m/j6jaRqJiYkBATmI/dFfRoqMUqlEfn4+bt26hcTEROzfvx9CGqC3/BYgDcjhOVIQ8VFRUTh58iROnDiB0dFRtLW1obW1FQDwve99z61/y9fsBhEvvI+E+S2r1corWyS/lZSUhKmpKdTU1Ej+OrtFxB88eBBqtZq3NxNiYltbG5/fYhgGMTExkkuLhSMXEa/RaFBcXMwDRAgMxrOewnMhBfguLfY23jJSwvFcSLW1tfG9hT/84Q/5ZYs/FTZQ+6Mntc9zIUWsu2QhlZ6ejomJCVn3UaCIeKJIHTp0CBqNxq1/S2whFRERIbm0WDiBIuJ/W7N3yNobWdPRYYTLpcRrr72PsbEUdHQY0dlZCJ3OxqtJSUnjbocBX6XF3kYKIl6pdCIvrwd5eVx+y2IpxK1bJwEA16+fQ1dXwZaaZPGa3wJ2lhZLmW1EvLsiFRGxgOPHb+PYsdtb+S0GZnMROjqKYTCsgKJciIiYCxjIIXWEpcUFBZ0oKOiEzUb6txjcuHEKN27UIDNzADTNoqCgEwqFw6202OUCLg/n4X80VmPK5v2Ha7ZVBZvChXGtb/ueEGzR3FwKgMKLL36EsbEUWCxFfGaP9G95Hsi3gRw3ZGekfClSavUmjEYzjEYuv9XebsTdu8cAAHV1pzEwkOU3vwUIS4vJAfo+gHUA3jdy3hQpYXkmscuYzWa0trYiLCyMp6bJyUgFYlsjiPjPfe5zPvNbQrsMRVGiipSU65OKiCd2mYSEBADAmTNn+AOFP7uMr9JibyPMSHlTpMTsMqSfqL6+HqOjo2AYxo0GKDbegBy+htgfhYqUML915swZ9PX18fm2pqYmREdHw+FwIDQ09FPNSAHuipQYDVAsvwWA7yOTk5GSg4inKAqpqalYWFhAa2srTpw4gcnJSb/5LWB3GamkpCSvD94Gg4HPb83OzvJ5MgC4ffs2ZmZmeDXJ10NlIIh4YlsTKlLC/Jawf4vktxISErCxsYGQkBBZQI7dIuIrKip2LKR6enr4hRTDMPzh99PKSJEh9RREsTly5AgmJyd5e3NSUhIYhkFRUdGOe5koUocPH36uiPjQ0FAcPXoUR44cwdOnT/nvfQA8zVHKQkpYWix1iCIlRMR72puJ4kYWUqmpqVhdXZWtSAVif/xtzt4ha29kDcsyiI+f5B9KT52qxcBAFliWRmvrfjx+XIaoqFkUF3PdUhERi6KKlL/ZRsTXS/rzWu0qaJpFbe1p5Od3IiFhEixL49KllwX9Wyyysvp29B0FkpEiiHhvipR7fusaentz8PhxKQYGuAfIH/7wa7yaFBa2M/tEhmSkAkHEe5YW6/V2HDzYjIMHmzE3R/JbDD766FVcvnweCQkTWF3VwWhs3wG28DZBDk7JsoQ4vBIE88Jn8A+Hr7uBLQgifv/+Nhw40IYXXriK7u5csCyDxsYKPHx4BHFxT0HTJhQXtyMkZEVw2JSTkUrG/HwUjh69K+nPGwxWHDzYjDt3jiM7uxfx8U/B9W8J81smpKcPu+W3yHtyR8Tb4C2XRYYoUt42wJ52ma6uLjx58gQjIyMAgLfffluSXSZQRDzLsjsUKaFdhvzyFtplkpKSYLPZZJG1douILy8vB0VRXu0y5AGH2GUAeYeEyclJvxkp4YSFheHIkSN49OgR0tPTERcXh/b2dt4uQ9QkT7sMeU+BIuK93UdKpRJ5eXnIy8vj81utra0YH+e+J3/2s5/x/VueapJwxEqLpYyYIuVJAySLhI6ODhgMBqSkpGBlZUXWfUQyUsXFxQEh4ok6J5bfyszMBE3TvJVJTJHyN3IR8dHR0Thx4gRaW1sRExODmJgYngYYEhLC0wDFrF9EkZLTR+ZPkVKr1TAajTAajXx+q62tDbOzswCAd999FwzD7KABig2xP+4WES+2kOro6OAXUqmpqbsCcgSCiK+urgZFUaL2ZuFCSqVS8UAOuRkpqYh4iqKQkJCA+Ph4WCwWREdHIyoqil9IkXoKsYUU4L202Nf4sz9qtVp+IbW4uMjfR/Pz86AoCr/5zW8kLaSAnaXFn7XZO2TtjeSZnY3GxEQSTp/eVqSUSidycnqRk9OL1dUgdHYWgmVpNDRUoaGhCqmpw5iZiUFa2pCs0uJtRLy0jBSwjYgvLX2MrKwBVFbewfh4Ekj/ltls3MpvcdmkhIQJ2O3SSos9h2UZxMZOIT7evyKlVDqQn9+Fycl4DAxkorq6Hj09eaivr0F9ffUWDZBFQYEFQUHudsVtIEeD5GsjiHiiSIlNVNQ8Tp5swIkTXH6LZRm0tnKB9F9/+Bo6tBQ6dS5A4/szybQpoQSFXsPO8mGtcgN/s+8+/sz4GGoBpEIMEa9SbaKoyIKiIgusVj3MZiNMJgZ1dWdw48YpZGQM4OnTeKSlDfk8lHqOyUQyUtKrBkhp8cGDTcjN7UVV1c2t/BbXv7Wd3+L6t2JiZmC3eystboCvQxbLsoiOjuYVGV9DyjMXFhYwMjKCyspK9Pb27rDL5OXl7XjA9FVa7G28ZaSEEx8fj/j4eN4uQw5cAHD9+nVMTk5KsssEioj3LC32Zpe5fPky/4AzPj4uOyMldtj0N8T+WF5ejvz8fDe7TGtrKx4/foyoqCj+ASciIiIgIAe5voiICEmIeK1Wi5KSEtjtdoyPj6OiogK9vb28muQtvwX4Li32Nv4Q8YSGmJKSwue3TCYTuru7AXDqzcLCAmia9lsy6g3I4WuWl5d3lBaL5bdYluXzWwUFBRgZGUFiYmJAQA65iPiVlRWcPXsWRUVFbmrSo0eP8ODBgx35LamlxWLXJxURbzAYUFFRAZfLhdraWhw4cAB9fX344IMPfOa3AGlADs/xh4gXW0gJfx49ePAAVqvV70IKcC8tljpCRYq8X2JvFqpJwoVUYWEhhoeHERcXJ4ssGygi/tmzZ6iurgZN06ILqZSUFB4opNPpAqb2yUHEh4eHo7KyEhqNBteuXUNRUREGBgYkLaS8lRZ/lmbvkLU3ksdk4qh9RqO4IqXVrmH//lbs39+KpaUwsGwxnjwphd2ux8hIGt5///dA06zf/NbzQsRzatI4kpPHBfktGk+elKKpqQLR0TOIjJyTXVo8N8fZH2tq5CLiGWRmDuLo0fs4evQ+5udJfovBxYuv4PJlkt8yIStrAAqFUwDkkHNI4BDxUnJfFAWkpo4iOnoWT1r2Yy7UiuUNLfKWFChcojCndqLP4ECffhM2kZ8W2VYl5tVOzKndD2PHkwbwvw7VIi1kp0XPHyLeYLChrKwJZWVNmJ2N5lVSmy0YY2NafPTRK1s0QN/5Lc/SYqnDsowbIl48v0XjwYMjuH+/EgkJE4iImN8Ccnh+5g3wlssih6WqqirZtrW0tDRUVVWhqqpqR3mmp12GoqiAeqTkIOKJXSYpKQkdHR38g5UYDVDsQfvTQMR72mVMJhNYloXdbsfq6iouX74MsfJMz9lNRkqoSEmxy0RERMjOSC0tLWFwcBDHjx+XfR+RYuHTp09jfHycVwGE+S2GYZCQkMDfR3IzUnIQ8SS/lZmZiW984xtITEyEy+Xi81sZGRm8miSmuBFFSq790Zci5ZnfIiWs6+vrsNvtqK2tFaUBeo43IIe/8UTEq1QqNxqgZ/9WZmYmIiIiAjpsyslIkSGK1IsvvgiXy7WDBhgWFsYvEohqRRQpuYdNqYoUWUgVFBTgG9/4BmJiYuBwOCQtpMj1yc1I+buPhAupgYEB/uC+ubkJnU6HW7du7ainEJtAEfEkI0UUKc96CqK4kYVUbm4uwsPDsba2Jus+ChQR397ejri4OLz22mtwOBz8QorUU3gupIDADpu/7dk7ZO2NpHG5KLS3+85ICScsbAmVlfcwPx+B9nYa+/e3wmIpgsVStJXf4tSkxET3/BawO0S8N0VKqXQgL68beXndWF3VwmwuBMsy6OnhfuBcu3YWXP+Wxe8DOUHE++qR8hwxRHxk5AJOnLiN48dvY2yM5LeMfH6rqKhjC6QgvbQY4NSb4OBlZGZ67yMTzrN1Db7xyWtQuZS4rVdiTrNNA8y2qlC+qMbBRRUmtBx+fUjnwKYCCNmgEL+uRFP4BggPI0a3gv9ZdhMvZXSK5qb8IeI9Jzp6FlVVN2G16mAy7YfR2I6urgKYTPsQEvKMpwGKAVW8lRb7mm1EvKcixY1avQGjsQNGYwdWVgzo6CgGy9KwWIwAXLh16yQYhkVeXhfU6k34ymUFYlsbHx/H/Pw8jhw5wv9/wvJMMbuM0WhEe3u7rNJicn16vV5SRoqMxWKB0+lEdXU1kpKSJNll5AI5AHmIeGKXSUhIgNPpxJMnT5Cdne0WvvZll9lNRsqbIiVml2FZlreBPnz4EDabTZJdJtCMlLC0WEgD9JbfKi4uhslkklVaDASOiN/c3ER1dTVSU1Pd8lsXL17k1SSappGZmQmFQiG5tFjs+nxlpMiQ/FZqairUajWampqQkpLilQboOSQjJbePzBci3mAwoLy8HOXl5Xx+i2VZ9PdzC6KWlhY4HA6/+S1Afo8UsFORoijKrZ6CKG7379/HvXv3kJCQgOLiYrS1tQUM5JCLiN/Y2EBNTQ0yMjIkLaSklhaLXZ8URLxCoUB2djays7Nx/fp1PHr0CDExMZIXUlKAHJ4jtD+KKVJhYWE7FlKEBghwP9fVarXfhRSwXVq8G0S850LKEyiUmpoKmqZhMplklRb/W8zeIWtvJM3wsLyMFMApUp2dRTAazTh//grOnr2G/v4ssCyDlpYSPH5cjqioWdA0l98KD18EwB1iQkKeIT1d2iEBEPZI+VdvtNpVlJS0IC1tGN///l8jK6sPCwsR+Pjjl936t7Ky+nc8aBOQwvNExHM0wDGkpGznt1iWwePHB+FyKTE6mop7946Aptv9HkyEpcX+eqSEYIvygSioBYoUoQFaQhwI26CQbVUi26rEyTkNNigXhnQOuAC44EKfnrMKCsEW3sYXIt7bbG4qYbFwQI5XXrmIjY3L6Onh1KRHjyrw4MERxMdPbmXc2hEczC0BpJQWe47FwiHipaiAwcFWVFQ8Ql5eF777Xa4oe3o6Dh988DqCglZRUGABw7BIS3sMijri9lpySEhPT/eJsPYclmV5EpnneLPLPHjwAC6XC0+fPkVTU5MoDdBzhKXFu0HE+7PLFBUVwenk7lO5GalAEPFmsxl5eXn4whe+wNtlTCaTV7sMeU9yM1JyEPHELlNcXIw333wTSUlJGB4eRmdnJ/R6PU9MTExM3PGA46202N8Q25qYIiXMb9ntdv4B59YtbkE0NzeH1tZWv/ktYPuwSdP0rhDxnvktQkxsb2+HwWBAcXFxQPfR06dPZWWkAE6RslgsyM3NxRe/+EXYbLYdapJQcSMPtUSRkpuRkqpIRUdHo6qqCqWlpfj2t7+NuLg4/pBD8lsMw3i1pQWCiPelSAnzWysrK/xnVFvLOUCWl5d5O7I/S+NuM1JEkRIupIi9mSykwsPDUVxcDJfLJTsjFSgivrOzE9nZ2fjyl78supASdkuR7x85QA4yUql9woXUkSNH8O1vf3tHfktIAxSb542I12q1OHDgAA4cOIDFxUV+kfDJJ58AgCwgx7/F7B2y9kbSsCwDjWZNVkbKU5FSKp3Ize1Fbi6X37JYODXp1q0q3LpVhbS0IeTldaG3NxuHDsnLSJlMTACIeE6RevnliwgOXhbNbxGlJCFhEhQlrbTYczY3OfujFES8SuVAQUEXCgq68C//8iWMjqYiJGQZ9fWnUF9fs5XfMnnNW3krLfYcIdgidINC3LoSjQJFSjhLaheehG/iSdgm4tYUyLEqkWlTIshFwQEXKtc38KUjdagq9K/siSHi/U1vb46b/VGt3kRRkRlFRWZYrXp0dBjBsgxqa8+gru4UMjMHUFBgQXd3Lg4elF5azF0fg+joGSQkyEfEv/rqRwgNfYahoTSwLAOLpQhtbQcQFnYDxcWrbnYZokgdPXpU8teRkpEiQ+wyNE3j3XffxdDQEFQqFU8D9GeX2U1Gypsi5c0us7GxAZVKhdbWVkl2GeD5IOKl2GXy8/PR2dmJ/fv3BwTkkIOIJ+jn1157DaGhoaJ2GWH/FiCttNhziG1NiiKl0+lQUlKCkpISvPfee+jv74fD4RClAYopJYFkpHwh4sXyW4S+53Q6oVKp0NXVJUoDFJtAMlKDg4NuipRer+dpgHNzczzpTpjfKiwshMVikX3YDAQRT+6j119/HWFhYfxB6+HDh3jw4AHi4+N5xY3YzQLJSDmdTrAsK0mRCg4ORkVFBSoqKvDee++hr68PVqsVH3zwAYKCglBQUACGYZCWlib6s2M3iHgxRYrYm7OysnD+/Hl+IXXv3j24XC6o1WoMDQ0hODhYkmobiP3RU5HyrKcgalJXVxe/kCoqKuIzUnIPm1IzUmQsFgtcLhdef/11hIeH71CTxBZSRJGSU1khBxFP4DSVlZX49a9/jf7+flmlxf8Ws3fI2hu/w2WkCrcOCXIyUt4VKa12DQcOtOLAgVYsLoahvZ3rlqqt5X7IT03Fobs7dyu/5fshWVhaLHXc7Y+cIiXMb/X2cv1bzc2laGzk8ls0bcL0dKys0mIA6OkhhwR5iPiBgSyUlzfi9OlazM8TGiCNixdfxeXLn9vqlmKRmTnAHyT8lRZvOim8bT6IN9qOwL7JbVizrUq44EK/fie8wm0oYErrxJSWy2m9OB0ETdgzpM0H4+77r6En7givJompfByQw+gTyCE22xmpnfRHg8GG8vImlJdz+S2TiUZ7O41PPnkJALCwEImBgQykpw/5PbQLS4vlIeLdS4szMoaQkcHlt7q68sCyVbxdJjExETRN4+nTp14VKW/T19cHu90ua8O6urqKgYEBlJSU4Ny5c26/vIldpqioCDRN83YZILCMlFT7o9AuMzg4iJ///OcIDw+XbJeRc9j0vD5vipQ/u4zVasXY2Jho+NpzAkXEm0wmNyCHmF3m1q1buHXrFtLS0kDTNCYmJgI6bAZif+zv7wfDMDh//jzGx8d5NYnQAIXdUsL7SCqQg4xU+6NKpUJBQQEKCgowNDSEn/3sZwgODuZpgP7yW4FmpHxR+6KiolBVVYWTJ09iZGQEhJhIvjfW1tYwNTUlacu/G0S8UJES0gCFalJdXR2ysrJA0zTGx8cDAnIsLy/LeqDe2NjA4OAgaJrGiy++6DW/xTCMm6ImB8hBRqr9UbiQIvdRUFCQaD2F2AE50IyUN0WK1FPEx8fj1KlT/EKKqEnka87Pz0taSFmtVvT29uLQoUOyEfFCRUpYT9He3g6TyeS2kKJpGmNjY7IPm4Eg4h0OB4aGhrzaHz9Ls3fI2hu/091NFCnpBbokI1VR8dDvw214+BIqK+/i6NG7+MEPvgabzYDJyQS8996XtmiAXP9WYuKE6MNvYIj4FCwuRuDkyZ2KFEcD7EZ+fjfsdi3fLXXzZg0AFwyGFZjNhSgs7JQEVCClxbtBxEdGzuPEiQYcP96AsbEUmEw0zGYj2ts5/LzR2I60tCGfpcUtMwn42wdnYJkX/IJ3ATk2JSaCnLDK+GlQSVmhVCnw//7L78PhUKGjg/uM6upO48YNTnFjGBPy87cP5tuKlJyMlA49PbkoK2vyq0hFR8+iuvomqqpu4Yc//AssL4dieDgNPT15W/ktjgYYGyuudoqVFvub8fGkLUT8vR3/Ta3eQHFxB4qLB7CyMoaOjm6YTCZcu3YNALfd7e3tlWSXAbhfynq9nu8QkjKepcWe5ZnEvtfS0sLbZTIyMgLOSMlFxHd1dUGpVOJP/uRPsL6+LskuI6W02HOI/dGfIiW0y5w+fRpvvfUWFhcX0dvbi87OTkl2mUAyUsT+KKZIebPLXLp0CQCH1B8ZGZGU3wJ2l5FiGMYtvyVUk5qbm9HY2IiYmBjQNI2MjIxdATnkUPu6u7uhUCjwp3/6p1hdXXXLbwkVN5LfAqSVFnuOVEQ8RVFIS0tDWloazp07h7fffhtzc3Po7OyE2Wz2m98C/IMUxIYg4sUUKWF+a2Zmhv+MPvzwQwCckjI9PS1KAxSbQDNShNrnmd8iapLnQiojIyNgIIeUjJRw+vr6QFEU/vzP/xxWq5VXJbu7u70upIgiJafgV6r9UbiQWltbwz//8z+7Ze/IQspoNHqF8gSStSOIeDHIiHAhNTk5yVsuOzs7QVEUQkJCsLS0hODgYEn/Xp8GIv6zNHuHrL3xO4Tal54+JPk1HR3SbGvCmZuLxuxsLE6fvo6yskb09xMaYAmamkh+y7SV3+JUAymlxd7eE4eI903t0+lWUVr6BKWlT9DUdBBXr56HQuHCxx+/gitXCA2QRVZWv+ghYLu0+Pkg4rn81ihSUka38lu5YFkaTU3lePToMAAXVle1ePYshO/VerauwT88OYafdx2Ay8MPGLeuQOimAi2h0pSlGN0K/j8lDej58HPI4RWpdZSVPUZZ2WPMzkaBZTk16cKFz/NkRJo2wWTiFKnMTOmHTbPZdx+Z2CwshGNmJg7V1TdQXv5oiwbI4OHDw3jw4OhWfsuE4uIOPr8lpbRYbLYR8b7sjzYEB3eiouIwKioq0NjYiGvXrsHpdPJ2GYI79maXsdvt6Onp2VFa7G+8KVJidhmTyYR79+7h7l2uU8zlcsFms0na8j8PRLxWq91hl2lvb3ezyzAMA5PJJLm0mAzJSMn5pby8vIzp6WmcOHECFRUVonYZ0i1FHnDkADmEIxURL7TLNDY24vr161hfX8d7773H0wBpmhbNbwHipcVSr09MkSI0wPz8fNjtdl61qa/fzu6qVCqsra35zW8Bu0PEE0VKr9fz+a3R0VFeTWpvb0dwcDCvuJHDppyMFLE/yrmP7HY7pqenUVlZibKyMv4zEtIAaZpGfn6+21ZeKpBDOFLtjzExMaiurkZVVRUePnyIuro62Gw2/PznP0doaCgPgvGW3yKlxUVFRc8FEa9Wq1FcXIzi4mKsrKzwy5Zr166Boii4XC7o9XpsbGxI+nrC0mKp46lIBQcH+1xIkWULUaTkHDYDQcRvbm5ienoahw8fRllZGX/Q8rWQAvyXFouNr4wUGYqikJiYiMTERJw6dQoPHz5EfX09VlZW8M4770haSBFEvFxFitgf5ZQW/1vN3iFrb3yO1WpAb2824uOfYmIiCUlJY5KsVKS02JtqIDZCRDyX3+pBbm4PVle1W/ktGrduVePWrWqkpQ2Bpk0ICVmWDeTY3FTxPVJy7I8DA1kIDl7Gf/pP38bkZNIWDbCIpwESYmJ8/CT/GRFFKhBE/KlTvhHxXH6rEwUFnbBadfj+9/8KTqcS9+4dw717lcjIGIAraRrfn87GxKq4jSHHqsQm5cKQ3jtSnwwBW0wMZID1okhFR8+hquoWTp5swMgI179FlEDAhYSESczMREvOzplMDGJiphEfL25/FBthabFavckXZ1uthq38FmdLras7jaysftA0i5CQZ7JKiwGCiDdKRMQ3gPRlDQ8Pw2Aw4Otf/7qbpYjQAMXsMoFkpKQi4oV2mWfPnuGtt97CxsYGGhoacOfOHb92GWD7kPA8EPFS7DKJiYlYWlqSDHsIJCMltD8GBQW52WWE4eurV6/yDzgGgwEzMzOygByBIOIpisL4+Dh0Oh2+/vWv8w+BhAYolt8C/JcWiw3JSPlTpHQ6HUpLS1FaWor5+Xn80z/9E9bW1lBfX4/bt2/7zW8B4qXF/sYbIl5IAzx79ix6enr4/NajR48AgC/OlpLfAgLLSBFFitwfJL8lVCQuXLgAtVrNL1t0Ol1AQA5fPVJiQ1EUpqenERQUhP/4H/8j/7324MED3L9/XzS/BbgrUlJHKiI+ODgYhw4dwqFDhzA9PY2f//znPCr/9u3bfhdSgLRDgucQRLynIuW5kCLVC3fv3sWdO3f4w4bUAyC5vkAR8aQvTmhvJgdAz4WUVquVXFpMRk5GioxSqcT8/DzUajX+6q/+is+TetIAhQspIDBFiiDiy8vLZdkf/61m75C1Nz6no8MIQIGZmVi8886/R2TkHE8DjIhYEH2NWGmxv/GFiNdqV3HgQAsOHGjB4mI4WLYYLMvg0qWXQVFOUJQDSuUmHA6F3/wWsF1aLEcdESpSSqULycljSE4W0gBpNDcfRGPjIcTETG9lk1iwLAFy+C8tJkOAHHLsj3NzMbDbDXjllQtITh7FveaDeNxaAvVgFk5v0QD7DA6Ma51wbf1eUriADJsSgzoHNnz8rMoLn8E/HL6O0rhxAMA11r8iRVEupKWNIC1tBOfOXcWVK+fQ2lqCqak4/OhHX0Nc3NMtNandqwI5Px+JsbEUt9Jif7OdkdpZWmwwWFFe3ojy8kbMzESDZRmwLI0PP3wNCoUDFOWEXm+Dy0WBovyrjqS0WJr9sQHA3/OKVGlpKVQqFU8DFIavPe0yRqMRLCu9tJgMOSTIedBYXl6GzWbDiy++iKSkJDe7DCnPZBgGKSkp/APObjJS/hDxnnaZa9euoa2tDRMTE/je976H5ORkMAzjFr72HLHSYn/jS5EKCwtDZWUljh49yttl2tvb0dnZCZVKBYqiEB4eDpfLJenr7RYRT7boeXl5PvNbhYWFAWWkpGbthLO+vg6r1YoXXngB8fHx/CLBV35LDpDD8/r8KVIk/1hYWAibzYbr16+DZVmMj4/j29/+Nq8m+SpdJaXFlZWVzwURT2iAJL9lMplgsVh4+xQAWYQ2AuSQo94IS4uJEipGAxTmt/Lz82EymT61jJTnWK1WnDlzBrGxsTsWUmSRIFxI+Sst9jYsy/ql9mk0GjAMA4ZhsLy8jLq6OrS3t2N8fBxvvPGGpIXUbhDxnoqU0N5MFlImk4lfSJGfx3J644j9UU5GSmh/DA0NFa2nIAspUnaenZ0dEJCDIOLl3kf/VrN3yNobn8OyNOLjJ/FHf/RTdHZyalJDw0k0NJxEauowuG4pM3S6Vf41/kqLxYYg4qurfStS4eGLOHbsLior72JkJBU///kfgqKA3/zm97fyW5yalJAgnt/i3pN7abGU8aZIcfmtLuTnd8Fu1/H9W/X1NaivrwZAoaioA2trGkmwB2J/DBQRn5PXiZ/37sMb04WwxzoQt77G0QCtSuTYVLApXOgzbKLX4EDoJgWtk0KfQVzF0io38Df77uPPjI+h3rJC2mzSM1JkVKpNzMzEIjZ2Cl/96s9gsXBqUl3dGdy4wdEAadqE/PwuN2XRX2mx2IyNJUtCxMfEzKK6uh5VVTcxMJCBX/3qSwCA9977EkJDl3iqZGzsjNe/w7O02PdwfVlEkfJ8YBXaZQjamNhlamtr4XQ6UVRUBIfDIcnmFWhGSlharNVqJdllZmdnA85IyUHEBwUFYWFhAVFRUfjqV7+6gwZIHnA87TK7yUj5UqQ87TJ9fX14//33AQC//OUvJdllgN0h4j3fk6/81pUrV+BwOGA0GuF0OiV97sKMlBxEPLmPSFbEkwbomd+iaRrT09MBHzblUPv0ej1WVlYQHh6OL3/5y/x9JKQBkiyQcFMuVBKkDslI+VKkhPktkk366KOPAAA//elPeTXJaDT6VBYCzUiJ2R+FNEDP/JZGo8H6+rosuAG5PrmIeGHZrMFg2LGQIvZm4UJqenpacmkxmUAQ8SEhIVhdXUVoaCi++MUvor293e9CCgjssEkQ8b4UKc+FlMViweXLlwEA77zzjigNUGxYlpWdkfKGiCf1FGQhRYBCFosFOp0OdrsdxcXFsg+bchHx/5azd8jaG68zM0MUqWvQatewf38r9u9vxdJSGK8mffLJi7h69Rxyc3tA0yZkZ/ehvZ1GVla/7IyUHEQ8RQErKyFwOlX48pd/AYdDCZZl8ORJKZqaCA2QU9yEGZttIIf8jJQ/RUqns/P5rfl5rndreDgNZrMR3d15W/ktE7KyBrweUAiQIxBEfGz6MF65/qVtsAUFTAU5MRXkxMOIDaTYFcixqlC0rAK9rMY65cI65cKCaue1HE8awP86VIu0EPd8EslISekjI0MUqZqaOgQH21BW1oSysqat/BanJl248BrU6nUUFlpA0yzS0gb5w6aU0mIyLMvIQsRTlAsbGxo4HCp84QvvweFQgWVpPHhwGPfvc/kthjHBaGxHcLCVf52wtFjaYdMGoBks2+1XkQoJCXGzy3zyyScYHR2F2WxGX1/fjvJMsRErLfY3pEfKs7TYm12G0AB1Oh3UarUsEuFuEfGeNEBvdpmkpKSAMlLCw6aUUSqVUCgUcDgc+PznP4/NzU1Ru0xRUZHbZ7u6uuqztNjbEPujL0VKmN+amJjAtWvXMDY2ho6ODgwMDPBqUkJCgtf7yLO0WMoIqX3Chzlf+a36+noYDAaoVCpZVrxAMlLC0uLo6GicPHkSJ06cwOjoKK8msSyL4OBgPpsUHx8Pk8kkOyNF7I9SDyQqlQo6nQ4OhwMvvfQS1tfX3dQkb/ktf6XF3kYKtU+Y3xoaGsKNGzcwMTGBjo4OjIyM8PZmX4CJQBHxYoqUv4VUcHAwVCqVLEBQIPZHoSJF1CRhPQVZSEVERPD3UVRUFAIBcsi1PwYFBSEiIgIOhwNnz57FxsaG20JKmN8S/tzxV1rs6/p8KVLChdTp06fR39+PW7duwW63o729HRMTE6L2Zs/xLC3+XZi9Q9beeJ1tal+H2/8fFraEysp7OHr0HiYnE2Ey0ejoKEZnZyGCglaxtqbF/v0tcLkgyeYlRMSr1fIR8RzC3IW8PC6/RdSkmzercfNmNdLTB7cUNwvfIyXHKjg7Ky0jJZyIiEUsLYUhM7MfJ040gPRvkfwWUUri45+6fUYEyCEHEW+yFGB1VYe3F1MwtiZ+cHRQwJDeiSH9OoIcQN6KEmVLalCg8AeTWoxrneg1OLASuYT/s+ImXsro9Epy9IWIF5vtjJS7IsXlt27i5MlbGBlJhclEw2Ipgsm0D3q9FTabAfv2tUj+OpubSnR0kIyUHEQ8V1qcl9cDhcIJo7EDKyskv8Xg+vWzqK0l+S0T8vO7YTZLLy0ms7BwCyMjm34zUsKJiYmB1WpFWloajh07BkJy8mWX4d6T99Jib+MtIyUcoV3m2bNnaG1tRUNDAwDgO9/5jiS7DLm+54GI97TLkCwAscuEhobi2bNnOHnypOSvQ+yPcjJS5Pp0Oh0KCwuhVCol2WUCyUjJRcSTB5y1tTUkJyfj6NGjbvmt6Oho/j7yLMaWClIQzsDAgF9FyjO/1drainv3OELnd77zHV5NEtIAxYbYH+XYocSUTWF+69y5c3x+q7GxEQ8fPkRkZCTm5+dl3UeeQA6pQxQpQjAsLy/fkd/SaDT8Z5Seni6rtJiMXEQ8oQE6nU7Ex8fjyJEjbvmthIQEXk3yRJnLPWwC0hDxngup1tZWPm/35ptvSlpIAYFlpMQUKaGaRA6+woVUXFwcpqamZN1Hu0XEHzhwAGq1WrSeQqfT8cTE5ORkyaXFwiEZqYqKCkkZKaVSidzcXNy+fRuxsbEoLy93szd7W0gBgWXt/q1n75C1N6LDZaSKkZXVzxPYPIeigMTECSQmTuD06Vr092fh6tVzWFsLQkNDFdrbaRQXk/zWotevtTtEvLsipdWuoqSkBSUlLVhYCOf7tz7++GVcufIC1OoNhIcvIDp6VvLXCiQjJUTEp6SMISVlDGfOkPwWg6amMjx6RPJbJtB0O/R6mwDIIcVaCFwezsMndZ9DqNKFca00ZW5NCWwoAAoUrkevIWZdgWyrEifnNFA9C4NTl48B1zoyMgbcPluhIiUvI+VbkeLyW8NISxvGuXNX0dOTh7q6UwBcuHWrBp2dRSD9W97uRWBnabGU2Vak3EuLg4OtqKhoREVFI2ZmYvj+rQ8/fB0azRrU6g2EhS3IBHIMAEiV9QtMWFpM8ltC3LHQLsMwDIxGI4KCgnaVkZK6AQ4NDeXtS6+++iqePn3qZpchv7w97TL+SovFRor9UaFQICcnBzk5OVhbW0NnZydu3eIU4Vu3bqGvr0+SXSYQRDyxrXki4v3ZZVQqFUJDQz+VPjLhCEuLhfktoibdvHkTN2/eRHp6Op/fUqvVfEZK7mFTDiI+MjKSV4c+97nPYXJykqcBGgwGNzVJeL/4Ki32NlIQ8Z75rY6ODp642dDQgOHhYb/5LWBnabGU8YaIF+a3hoeHwbIsn98KCQmBUqlESEhIwEAOqSNUpMTyW9evX0dtba1b2blSqQw4IyXH/hgbG8t/H50+fRpTU1P8QorUUzAMs+Pf3Vdpsb/r86VIeS6k2tvb8eDBAwDA7du3MTk5KWpv9hzP0mIpQ+iPwtJiz3oKspBqa2tDc3MzIiMjQVEUDAaD7MOm3IwUQcSfPn3azd7sayGlUChkAzk+C7N3yNob0RkeTpOUkSKjVDqRkTEIu10Po7EdGRmDYFkGDQ1VaGio2spvmVBUZIFWu+r22t0h4r0/UEdELOLYsTuorLyD8fEkNDWVo72dht2ux7e+9V94NSkhYdLroUGstFjKiCHiORpgFwoKSH6rCCxLo77+FOrraxAbO421NS0KCsx+//7R5VD890encG84G19Z0aAjZJMHWkiZHKsK82onRnRO6BKn8MVD1xG3ruT7t0i3F+mWioubgskkrkj5vM7RlK2M1G1Jf16t3kReXhc++eRzKCiwIC1tGCzLoLb2DOrquPwW17/VtUP19FVa7G2IIuWL/hgTM4OamnpUV9/E0FAampsPwmLh6Gdvvvl1/jOKifGe3+IOmyFIT0/boRb4GpPJtEOREtIAl5eX+V9MpDwzPj4edrtdFqGNZKQCRcSTB2GhXYaoJcQuwzAMIiMjAzokyEXEEyWgrq4OOTk5SE1NlWSXIe/peWWkyIjZZZqbm9Hb2wsA+MEPfiDJLkMOCcLSYilD7I/Ce0Kr1aKkpAQlJSVYWFjgC0Y//vhjXLlyBYmJibBarbLUB3K4DRQRf+DAAVAU5ZbfIjTA2NhYnnQXGhoaUNZOLiJer9ejtLQUd+/eRUZGBlJSUiTlt8h7et6IeIqikJ6ejvT0dF5xa2lpwcAA9zPvxz/+sSgNUGwCzUh5KlKe+S0Cy/nggw+g0WiQkpISUGnxbhDxFRUVoChKdCGVlJTEK256vX5XGSmpkJHQ0FAcPnwYjY2NSE1NRWJiIjo6OtzszWILKcB7abGvIdQ+b+/JcyFlsVjQ2tqK0dFRAFwWUMpCCtgdIl54HwkXUhMTE7xrw2KxQK/XIzU1VTaQ47Mwe4esvREdk4mWlZECthWp/ftbkZk5iAMHWrG4GMarSZ988hKuXn0BeXndoGkW2dl9WF3Voq8vG4cOPZCdkZKKiKcoIDl5HD09iwCcePnli+jtzUVzcykaG0l+i1OTPDuSfJUWexspiHguv9WM0tJmzM9H8jkgAPjgg9/b6pZit6yQ2wrLppPC2+aDeKPtCOybGhTalFCAQq8XeIXYhG5QiFtX4EnEKv6utMENbJGaOoJz566hp4fr32psrMDDh0cQF/cUz56FIiVlRHZGinRlSZ3e3lysrupw4EArsrP7UF7ehNnZaIGa9Bo0mjW+fys9fQhra5widfCgdCAHuT4OET/p989SlAsZGUMYGUmDxVKIs2evoK8vFw8eHMH9+5VISJgA6d8yGKxurx0fT8b8fASOHpW+yRVmpLx1DIWEhODw4cN8txR5KAWAixcv8uqNP7uMZ2mxlBFTpDzD1+QBh9hlkpKSsLi4iOTk5ICBHFKHKFIlJSXIy8uTZJdZW1uTVFrsOXIQ8cQuMzU1hd7eXlRXV6Ovr0+SXcZXabG3kYKIj4iI4PNb4+PjYFkWLS2cVffKlSsYHR0FTdM+81vA80PEq1QqFBQUoKCgADabjVfcbty4gRs3biAjIwOzs7NITEwMKCMlZwFBSovPnTuHwsJCnDhxwq16geRRSMYtLi5Ocmmx58hBxKvVahQVFWFpaQkDAwOorKxEf3+/KA3Q86Diq7TY20hBxMfExKCmpgbV1dUYGhrily0AUFdXh6mpKdA07TePFGhGyhMR728hlZ2djenpacTHx8vKSAmBHFJHaH80Go2i9RQRERH89UZGRgYE5ADk2R9JPcX6+jpGR0dRXl6O/v5+SQspoSIldfwh4imKQlJSEpKSktwUN4vFApVKJeuw+VmYvUPW3uyYjQ0VOjsLUVhokZmRYhAauuSmSIWHL6Gy8i6OHr2LiYlEPptksRRBp7MhJmYaLpdCIgabm0AR8SxLIytrAPv2mbBvn8kjv1Wzld/i+rcKCzsRFLQGk0laabFwenrkIeIjI+dx8GAT7typhNHIIihoDWazEe3tNIKDl3li4riCwt89PLMNtgCQbVVhTu3EvEb6ATXbqoQLLvx/X/85ChMndvx3lWoThYUWFBZaYLPp0dFRhObmg7Db9RgdTcUvfvFV0LQJBQVdPm2Nm5tKmM1FAWekhIj46OhZVFffRFXVLQwPp4JlGVgshTCZ9iEk5BliYqYDAHJEYHQ0FdXVN2TbH9PTh1Be/hjl5Y+38lvFYFka16+fQ23tGWRn94GmWeTldUGt3oTJRG+VFvdIvr7e3l7Y7XbJDxpxcXE4evQoHj16hLy8PAQFBbnRAL3ZZQDul3J0dPRzta0FBQXtsMs8efIEVqsVNpsNv/71ryXZZchhMxD7o7C0WIpdJiYmRnZpsdyMFOCOiD969CiOHj3qRgMUs8solUqwrLTSYuHIQcRTFIXk5GTExMSgpaUFWVlZ0Gg0PA3QV34LkAbkEHsN4P0+0uv1OHjwIA4ePIj5+XmwLIvW1la+buDDDz+UlN/aTUZKqEgJaYBi+a24uDhER0cHlJHaDSK+qqoKVVVVPA2wvb2dpwGSbqn09HRQFBVQ1o4cEqSoNyS/lZSUhI6ODqSkpECtVvP1FCS/RaiBnhMIIt6f/VFsIWUymWC1WqFSqXDp0iVJC6ndIuKJ/dFzIUXyW7dv38bt27eRnJyM6Oho2YdNkpEKFBF/9uxZuFwuvp7CcyFFgEIURQV02JSDiCcLqczMTPT29u4AvvwuzN4ha292zHZGSvrBx2o1oK8vG4cPiytSFAUkJU0gKWkCp09fR39/NliWhtnMPSy8//4XeBpgePiiz68VCCJ+ZCR1R2mxZ36LZWmwLIOPP34FV66cR25uD3p6cmSXFhMghxxEvNlshMulxNGj9xEXN7XVv8WpSU1N5Xj06DDm1U6oDA7o9ZuwqYCwLUWqMVz6tcVoV3DIqUNSxojoActz9HobysoeY3o6DgsL4Sgra4LFUoSPPvo8Ll9e59WkjIzBHf/uRJGS10fmGxFPUS6kpw8jPX0Y585dQXd3HliWQW8vZ+36+OOXeTXJV34LcC8tljqcIuVeWszltx6houIRpqdjwLIM2tuL8cEHr28pbhZ0dhYgL68LQUHPAPwfkr4Wy7IwGAyyKFkWiwVOpxPHjh1DYmKiKO7Y0y4jtbRYOHIR8aGhoThy5AgWFxfR2tqKAwcOwGKx7KABJicn77gGKUAOzyHUPm+IeDG7DMuy6O7uBgDU1taCYZgd5ZliE4j9UQwR70kD9LTLFBUViVL7/E0g9sfOzk44HA4cP34cKSkpsNvt/Gcklt8KCgqSXFosHLmI+MjISJw4cQKrq6toamqC0WhEd3c32tvbERwc7KYmeV6Dt9JiX+NPkRLmt6xWK69smc2c5fv27dtgGEbSw+HzQsQLaYDDw8M8MbGtrQ2hoaEwGo1oa2sLOCMlx/7Y1dWFzc1NnDx5EmlpaVhZWeHVJLH8llqt5oEc/kqLxa4vMTFRkiIVFxfHE+oePHiA3NxcyQspUlr8PBHxQUFB2LdvH/bt28cvpEwmE9ra2gAATU1NWF1d9buQAgK7jzwVKc96CqK4CRdSNE3DZDLJBnIEgojv7u7G+vr670w3lnD2Dll7s2PEFCl/09Fh3FKk/D9QK5VO5Ob2ICJiHmazEYWFHbBag3HrVhVu3eLyWwxjQmHhzvyWr9JiX0N6pLzZHyMiFnH8+B0cO3YH4+PJMJm4A9fmpga9vbm4du0MGIZFfLz3/BawXVosHxFPuyHiVSoH8vM70a9z4rIjGiGzYcixKlG+qEbZogoTQU5sUC444UKfflPS1/hKXiv+MLYf7//LV8HU1Em+NqJIFRR04dSpG6ipqcfISApYltnKlXGZOk5xMyEubpp/T8HBy8jMlHPYlI6IV6s3YTSakZg4id7eXOTmdmFlJQS1tWdRV0dogKxofouUFmdkDO4oLfY1JhOzpUiJK5uxsTOoqbmB6up6DA2lg2VpdHQYsbmpxuBgJurrWdD0BGJifCtGwtJiOa32RJEiiHh/dhmhBUTONlJuRgpwtz++8MILOHv2rF+7DHlP/kqLPUcOIp7YZTIyMvDmm28iIyMDy8vLvJrkyy7jq7TY1/iyP3raZfr6+vh8m9PpxPj4OO7cueM3vwW4lxbLtT8KS4t1Op1bfosobiS/lZ+fz//9gQI5pA5RpPLy8vDKK69gc3PTb36LvKdAM1JS7iODwYCysjLk5+fj29/+NlJTUzE3N4cLFy5ArVa7qUli39PPGxEvzG+98MIL6O7uBsuyePjwIVwuF6anp/Ho0SNRGqDnCEuLA8lIEftjcHCwGw2QKG4ffPABgoKCUFBQAJVKJTsjFQgi3uVy8crm7/3e72F9fd3vQoq8p0D6yKQqUmQhRdM0vvWtbyExMRGjo6OSFlLk+uRmpHwpUkqlkl9Ira6u8oobocpqNBo8efJE0kLq00LEf5Zn75C1N26zsmJAb282jhx5AIqSd0jgMlLew/87X8Mh4s+du4bg4BUsLoaD9G9duvQSrlwh+S2uf0updPKlxUJFyt9wiPgiFBZa/CpSXH5rDMnJY1haCsPoaArS04fQ3HwQjY2EBsiiuJgVfTgnQI7dIuIJ2KJ+bOvBMsSBzhAHQjcoZFuVyLEqEepQwgkXyhbV6DM4MK51isIv8sJn8A+Hr6M0bhyXLn0u4IwUeU8cDXAEaWkjOHfuKrq7c8GyjFt+q6DAgu7uXJSXN8rOSAWKiD9//gpCQ59hZiYapH+L5LdI/1Z6+hAoyiW5tFg4DofQ/rjm889y+a3BLRiMFkNDGUhImMT9++W4d+8nbuWZYtvkQDJS/hQpT7sMCaivrKxAoVDg7t27ouWZYiMG5PA3fX19bvZHKXaZwsJCdHV1obS0NCAghxz7IwEpvPjiiwgPD5dkl5FSWuw5chDxSqWSpwH++te/Rn9/PyIiIvj8VlpaGq8miVkp/QE5xGZpacmnIhUREYHjx4/j2LFjGB8fh8lkgtlsht1uh0KhQFNTExiG2UEDFJtA7I+eiHh/+a3MzEwUFBQEDOQIDw8PCBH/0ksvITIyEiMjI7yaRGiABBRDClWfPn2K6elpn6XFniPH/qhWq3ka4Pvvv88TQIma5Cu/BeBTQcTHxsaipqaG798iuZv19XUolUqYTCYwDCMJzEEOCXLtj0JFSspCqqioCGazOSAgh1xEPFFDX3nlFURFRUlaSEkpLfYcOYh4rVaL/fv3Y//+/fjNb36Dri5uae3N3uw5vw1E/Gdt9g5Ze+M2HR1GAAr092ciIqIEhYVm6HSrPl8jLC2WOmKI+PDwRRw7dheVlVx+y2RiYDZz+S293oqiog4sLYVBrZYH5OjpCcT+qEd/P4eIP3WqDna7lldt6utrUF/P5bcYxoSCAgufOdpWpPwDOcgIEfGeYAvPeaZ2oSV8ExNBTrw4E4TJICdS7Urk2FSwKVzoM2yi1+DAvMYFrXIDf7PvPg+2IKXFUhHxZEwmxqsipVJtoqjIgqIiC6xW/RaZkEZDA+e3HhtLAcvSyM/3b7mcm3s+iPiYmFlUV9ejquomhofT+P6ttrb9CA1dQnFxOxYXw2SVFgMcIt5u18tGxPf15aC09DHOnr2OlZVgtLf/N7CsE9euXePD10K7DLBTkZIycmxrcXFxOH36NPLz8/HP//zPSEhIcLPLkF/eYlv13WSkvCHiPe0yRCmpreUWD1NTU+js7JRkl9kNIl6oSAntMmL5LZqmsbCwEFBGymazyXpgXV1dRV9fH/bt24fz58+75bcuXbrk9oCTlZXFP+AEkpGSSu0j+a3k5GQwDIN33nkHsbGxfH4rJiaGV5PE8lveSov9jS9EvDC/NTc3x39Gly9fBsDdG/39/aI0QM8RlhbLta0JEfEkvyVUkx49eoQHDx4gLi4ONE1jfn5edkYqUER8b28vaJrGSy+9xOe3WJb1mt8i70moSEkZqbY1hULB11McPHgQb7/9NiIiIvj8lr+FlBQgh9j4UqS8LaSIndhms2FkZETSQkoMyCH1+oSIeF8LqZSUFNA0jdnZ2YAzUnIR8X19fTAajXj55ZdF6ymMRiNomuYXUuQ9yVWkCCJezn3+WZq9Q9beuA2xCm5uqvHJJy/i6tVzyM3tAcMQNWknxc5babGv8YWIF+a3zpy5jr6+bLAsg5aWEjgcKgQFreLRo4qt/NaSyN/ueX30FiJeXkZKqEjpdKsoLX2C0tInWFiI2Mpv0bh48RVcvnwe+fldSE8f3FKk5AI5GGRmDqB3NRh/e/M1N7CFt8m2KbFBuVAbsw4nBaTaFcixqlC0rAK9rMaafhVHStpQmW7hyYE9PaRHSvph02bTobc3B2Vl/hUpg8GGsrImlJU14Uc/+nMsL4dgeTkEFy58Hmr1ukBN2pnfAryXFvuasTHviHguvzWE9PQhvPDC1a38FkdxdLkU0GrtaG09AKOxHcHBVpG/fef17RYRHxy8gkOH7uLQoVreLsOyLHp7exEUFITCwkJkZGRgdHQU1dXVsg8J6enpshDxHR0dUKlU+MpXvgKFQsH/8r579y5PA2QYBkVFRfy2PNCMlFREfGhoKI4ePYojR47gxz/+MRYXFzE7O4t//dd/lWyXAeQj4r0pUiR8nZubK2qX0el0MJvNkuwy5PqEQA4p40nt88xvETXJbDZDr9fDaDQiMzMzYCBHSkqKpIwUmY6ODiiVSvzhH/4hAPBqUn19Perr65Geng6GYVBQUMCTMuUAOcjIQcRHRUXh5MmTOHHiBH7yk59gbm4O4+Pj+OUvf4ng4GC3/i2xCQQRTxQpMUS8SqVCUVERioqKYLVa+W6pujrOuq3X69HX1yc53B9oRkqoSAnzW0I1ieS3iouLkZ2dLau0WHh9chHxFosFCoUC/+7f/TteqWNZll9ICcvOyUJKSmmx58ih9pGFVE1NDd555x3MzMxgcHAQPT09fhdSwHZpsZz7yBciXriQWlpa4hU3skgwGAwYGxsTtTeLzW4R8WL1FARO8/jxY0RFRfHqVm9vLw4dOiTbAh8XF8ervr9rs3fI2ht+ZmZiMDmZiDNnrqG8/BEmJxNhMtHo6ChGZ2chdDobjMYO0LQJSUnjoChppcViIxURr1Q6kZfXg7y8HrS07MOlS68gLGwJt25V49ataqSlERqgBVrtTgvXdmnxQ1kZKZOJ8apIRUQs4Pjx2zh27PZWfovLJnV0FANwYW4uCpOT8YiPf+pXkSFAjrmUKfzdJ1+FC/5/iSldQKZNiSGdA5tbP6uG9E4M6deRqLHizyOH4RqPRfPdY2i+W4nMzAHQtAlmcxGCg5eRkSHnkED6yKQfzObmIjE1lYCamlocPvwQIyOpvJpEaICko4x8vi4X0N7uu7RYbAi1z5/9Ua3egNHYAaOxA62tDD7++FXo9TZcv34WtbUkv2VCfn63KFHTW2mxvxFHxN8HsC5qlzGbzWhtbQXAbdJnZ2clPaQIS4ulDrGtCRUpQgMU2mWuXLmCa9eu8Q847e3tskqLgW37oxz1ZmlpCU+fPsXJkydx9OhR/pc3sctERkbyD8rkQCBUpOQg4qXa1oR2mdbWVnz88cdQq9WS7TL+gBy+rk8MES/Mb505c8Ytv0VQ/mtra1hcXJT0eewmIyW0P5aWlqK0tJSnAbIsi4sXL+Ly5cvIz8/nQ/NySouBwBDxy8vLmJyc5A+lnjTA2NhYMAyD4uJiHiktpbRYbAi1z999ZDAYUF5ejvLycrS0tODSpUsAgAsXLkCj0fD9W97yW88bEU9ogBkZGW6K24MHD3D//n0A3GditVolqUViQA5/I6ZICfNbRE3q6enhF1LkPgo0IyXnPrLZbJicnMSRI0dQWVm5YyGVnJzMVy8I7ZueipSUkWp/DAsL4xdST548weXLl7G5uYlf//rXO+opxA7IYqXFUsab/dFzIUVgOcTeDHDW1dXVVUkuiEAQ8Z+12Ttk7Q0/QmofRQGJiRNITJzA6dO16O/PAssyaG3dj8ePyxAVNYviYhaRkfNbitQNyV9nY0PNZ6TkIOK7ugoREvIMf/7nP8LS0nb/1qVLL7v1b2VlcfktQFhaLAcRH4WJiSS/ipQwv3XmzDV8+9t/A4oCTKZ9aGkp3cpvcf1bYgcHlwv45H4lNiknfrGYCpfE5U6qXYEg185urK/kteLvSm4jbCsvNDcXxStuH330eQAuREfPYHAwExkZA5IOnSxLB5yRKi5u38pvDSMtbXhLTeLyW48eVeDBgyOIj58ETbOIiJjDwkIkjh+XVloMECCHEQUFnbIQ8T09+TAYVvAf/sP3MTcXJejfel2Q3zIhPX2YzyVKKS32HO+IeBuAZgAcNEJolzl37hy++93vwul0orm5GY8fP/ZrlwECy0j5QsQL7TJPnz7lA+rELhMTE4Px8XFJdhlg9/ZHTxqgN7tMZGRkQEAOz8OmlOnv74der8df//Vf8w+BnnYZhmGQmJjIf0YEyPFpIOKF+S273Y4f/OAH2NjYwMOHD/Hw4UO/+S1AvLRYyufgTZEiNMDjx49jbGyMXyR0dHCuh9jYWMzMzEjKbwE7gRxSRqhICWmANpvNTU0i/VvkPpJTWgy42x/lIOKHh4eh1Wrx9a9/ne8o88xvMQzjBjLwV1osNv4yUmSE+a2VlRW89dZbWFtbw71793D//n1Re7PnPG9EfGxsLE6dOuXWv9XR0cEvpOLi4rC0tCRZNSP2RzmIeKEipdFo/C6kGIbhs51SS4sBd0S8VGofRVEYHx+HRqPB3/zN3/A9bkJ7M7mPhIAeokh9Goh4rVaLAwcO4MCBA1hcXMQ//dM/wWaz4fbt27h3757fhRQQWNbuszZ7h6y9AbBN7eMUKXfrFEcD7EVubi9WV4NgsXDdUiR3Q1FO2O06rK5qd9AAxaa7Ow/r60EBIeJJaXFExCKOHbuDyso7GB9PAunfMpuN0OutfLeUySS9tJjMtv1Rum1tfDwJNlswXn31A+Tk9G3lt2jU159CfX0NMjIGwXVLcQeC0eVQ/J8PTiOxLwsjAkVKymRbVbAqXZjQcgdJIdhCOFFRczh58hZOnLiF69dPo7HxMJ49C8Mvf/lVBAcvo7iY0ACnRL/OdkaqVmZGirM/hoYuu/03z/xWR4cRLMugtvYMABcoygmnk8LGhlrS4XsbyCH9PrLb3RHxMTEzqKmpR3X1TQwNpYH0b23nt1gwDOtFkfI9vhHxDSCHLOFMT0/DZrPhpZdeQnZ2tptdRog7FtplhBkpb6XF4tfnPSMlnPj4eMTHx6Ompga1tbVobGzEwsIC/vmf/xkRERH8L29v9rLnjYj3ZZcRltk6HA5JahHJSAVif9y/fz9UKpWoXaalpcXNLkPTtFdFytcEYn9cWFjAysoKzp8/j6ysLEn5LSmlxd6uzx8inqIopKSkICUlBWfPnkVtbS2ampowOzuLH//4x3x+i6ZpngboObtFxHsqUnq9HmVlZSgrK3PLb3300Ue8emQwGOB0OiXZm0hpsRx1RKhIqdVqngYo7N96+PAhHjx4gPj4eD7j5k2R8jUkIyXn+qxWK1/EnJGRwatJH3zwAZ/fYhgGaWlp/L+JUJGS20fmz/4oXEi98MILqKurQ3NzM6anp/H9739f0kIq0IyUyWQSRcT7WkgRlTEyMhIul0vS19stIj4oKEi0nsJzIVVUVBQQkCMQ++Pm5iaWl5dx6tQppKWl8YdkYT2F50KKHDa9lRb/rszeIWtvAABDQ2l49iwMNX7Q3lrtGg4caMWBA62YnY3Cj370F1CpHLh69Txqa8/wapK3/BbAPXwGioj3VBI4NWkcycnjgvwWjSdPStHUVAEAyM7uweJimKT8Fiktlo+IZ3hEvEazgdLSZpSWNmN+nuS3GFy8+CouX/4cVAnTuLwRDmyokOGi0BMs/jmJjdbBKVntIZsIUrmDLbwNRQFjY6mIjZ3Cn/7pT9DTw/VvNTaW4+HDw4iLe7pFTGxHSMj2wSiQjNToaCoWFyNw4kSDzz9nMNhQXt6E8vImPH0ah7ff/vdQKFz4+ONXcO3aOb5/Kz19yKviJlZa7G8IIt4TXsHRAIeQkTGEF17g+rdMJgYPHhzB/fuVAICcnC7YbAYYDP7zW/4R8Q0A/l7kPbH8tj0oKIi3y5DyTE+7DMMwsNlssNvtsh6eCCJeSkaKjEKhwOTkJKKjo/Hv//2/53HHd+7c8WuXAT4dRLzQLjM+Po6f/exncLlcuHDhAq5du+bXLkOuLxBEvJhtTYpdJjc3F2tra5JUs0AR8UL7o06nc6MBkgccYX6LYRisrKwElJGSi4hXKpWYmZlBZGQk/uRP/oT/jEh+i6hJwvwWeU+AvMPm1NSUJEVKmN8aHh7Gv/zLvwAA3n//fYSEhLj1b3mbQO2PYtQ+tVotmt+qra1FXV0dXC4X8vPzsbm5KdnmxbKsbES8UJHS6/WoqalxU5NIfissLIy37j579kxyaTGZQBDxGo0GCwsLCAsLwx//8R97XUjl5eW5WSoD6ZGSiogXLqQGBgbwr//6r6AoCr/61a8kLaSAnaXFUob0SHm+J1JPsX///h0LqWvXrsHhcCA/Px8ulxySdOCIeJqmERwczNdT+FpILS4uSi4t/izP3iFrbwBwD4RcRqpb8muePo2Hw6HGl770LrTaNZhMnJpksRRt5bc4NSkxcZxXQlZWtkuLA0PEe1eklEoH8vK6kZfXjdVVLT744PPo68tBX18u3nwzF2lpQ3z/ljcEt1hpsb8h1D4xRHxk5AJOnLiN48dvo75jH35zuwoR44modlLYhAsblAvrlAtwARLiWMi0KaEAhbCMYdTXXEJaiP+D49zcNiJepdpEYaEFhYUW2Gx6dHRwxMS6utO4cWNbccvP7/KqSPka0kcmBxE/Px8Jh0ON3//9X0Ct3uTVpO38FqcmCf/t/ZUWexuWpbcUKe/2R2F+a2XFgI8+egX9/dno7c3HG2/kIju7DzTNIi+vC2q1eEeZf0Q8l8sCtgPuwh4pT0WKlGeK2WXUajXUarUs4IWcHikyQkUqKCiIt8uQ8kyhXYZ0S2VnZ3tVpHyNXPsjRVGwWq3Y3NzEF77wBahUqh12GfLLW3hY2U1Gyh8i3tMuc+nSJQwMDKCnpwff/OY3JdllAkHEe1OkhDTAM2fO8N1SJL8VFBQElUol6+EpkIyUEBGv1+t95rdINikjI4NXpKwTTZho6YJzcwO68HikFn8OQQbxAyjpkZJqf6QoCpubm9jc3MRrr70GhULhlt8iNEBhfgsA37FELIlSRwoiXpjfmp2dxeXLlzE0NISuri5885vfREFBARiGcaMBes5uM1LCpYlnfossWwgNUKfTQalUyrJ07gYRf+TIEYSGhrrRAL0tpFJTU3kgh5yMFMuysmxrCoUCSqUSGxsbePnll0FRlOhCymg0un2PygFyeF6fP0VKuJCanJzE9evXMTIygq6uLrzxxhs76inEZmZmRnZGyhsi3t9CKjg4GCqVShaQ47M4e4esvdnKSBXKzkgREmFGBtc9xOW3rqO/n1OTWlpK8PhxOaKiZkHTLGiaRVdXnuTSYjKBIOKDgtYwMxOLrKx+nD//Ca8mffzxy279W1lZ/Xx+C/BfWiw23d25PhHxz9Y1+Icnx/DzrgNwGSgo9KvIsipwfF4Dlwt4dUqLebUTvQYH+vSbsPn4riywU9BGLOKfXvmlZAufEBEvHL3ehrKyxygre+yWTfroo89DpdrA5qYahYVmOJ2UpPxWoIh4luUQ8VlZg1AonEhPH8a5c1e2aIAMHj48jAcPjm7lt0woLu5AZ2e+5NJiMvPzkVsZKemIeIPBivn5KGRkDOLs2atgWQbt7cX44IPXERS0ioICCxiGRVrasNvSgGUZP4h491wW4DsjRcbTLiOkSv3whz+UZJfhri/wjJSnIkXKM4W4446ODnR1dUGj0WB9fR0FBQWS7TKBZqSIIpWbm8sXaArtMg0NDWhoaEBKSgoYhkFhYSE6OztlHzYDQcSHhYXh2bNnSElJwZkzZyTZZQDfpcXeRgq1T6lUIj8/H/n5+bDb7bwCAADf+973kJ6ezue3fFlQTSaTbPujN2qfZ36LEBPb29uh0+lgt9sRs2lB1+MniOucA+VwYiY5DKa0/wvJBafAvPZ/QReyfUAkh4Tc3FzZtjWtVov8/Hz+oC+W38rMzOS7pQLJSAWCiI+OjobNZuOrBUwmEzo7O2EymXgaIE3TOw7KvkqLvQ1BxPtSpNRqNYqLi1FcXIyVlRW0tbWhvp5bUL755puS8ltAYIh4Ylvz/N71XEiRn0etra0ICQnB8vIyKisrJX8dYUYqEEQ86dTyt5DKycmRVVpMZmVlRVJGigyhAW5sbCAuLg7V1dWSFlLkPX0aiHjPhVRbWxvu3r0Lo9Eoq7T4szh7h6y9EWSkpD+wbitS990eLrn8Vg9yc3uwuqrdym/RuHWrCrduVUGjWUNY2KIsdSQwRHwqj4iPiFjE8eN3cOyYr/yWCdHRM5JLiz2vTwwR73IBl4fz8D8aqzFl2956OilA46JAgcLHsauI2lAgx6pE+aIaZYsqTARxB65BvXtW66vJndCOHEBlZZOMjBRnf8zIGHSzAnpOVNQcqqpu4eTJBoyMpODSpRcxNxeNBw+Oor2d5j8jX/1fzxMRr1Zvwmg0w2g0w2o1bOW3aNTWnkVd3WloNGsIDV1CZOSc5K9F7I80LQcRv61IxcbOoKbmBqqr6zE0lA6WJf1bBxAWtsgTEyMiFgSlxb4Omw0QHrJYloXBYJBM7RP+8vnyl7/MI+H92WV2k5FKT0/3qkhRFMXbZU6dOoWBgQFcvXoV8/PzuH//PiwWC//L25ddxrO0WMqQjJSnIuVplyFKCaEBBgUFISQkRBYeOBC0txART2iAxC5jMplE7TIhISH8YVNORspkMvnNSAlHp9Px99Lrr7+O2dlZsCyLjz/+GFeuXOFpgFlZWW7ZJKlADuFIQcR75rd6urvwyYVfAS41ZlSFoBRR0DtYFLMsQu+PYk2nQOfh91E38BBVX7+E4EhOFfIsLZYy3hDxwvwW+Xza29tx4cIFqNVqBAUF8TYoqbMbRPy5c+f4/JYYDVCY39Lr9QEBOcghQaptLTg4mM/Tvfzyy5idneXzW0FBQbziJsxvAdKBHGLX5wsRL1xInT9/Hl1dXbxl9+7duxgYGOAXUr4+l91mpISHS18LKa1WC41GA71eHxCQQ86iSFhaTPJbnvUUDQ0NSE1NdYPlSC0tFo5cRHx4eDhiYmLgdDplvafP6uwdsvYGJhOzlZEalvwabxkp4Wi1qzhwoAUHDrRgcTEcDx9WoKmpAuvrQfjmN/8rryZx+S1xy1egiPht++O2IuWZ3+rt5fq3SH4rJOQZ1ta0yMrql/x1vCHiR5dD8d8fnUL9mHjOI9uqwpzaiWmtC9NaBzpDHAjdoJBtVSLHpsSJeQ2OLLgwpHNgNW4e/+3Ux1jpzME9mUCOkZGUrYzULUl/nqJcSEqagNUaDKOxHQUFXTCZGDQ2VuDhwyNb+S3TVn7L/d+DKFKBIeK9H/ANBivKyxtRXt6ImZloNDaW48mTg1hb0+GNN/6roH9ryKsFVay0WMqYTDsVKS6/NYiMjEG88MIVdHVxitv9+0dw714lIiLmYLfrkZvrTw1tAMll2e12dHd34+DBg7I7RKKjo5GVlYXs7Owdv7y92WUAeQ93chHxCoUCGRkZsNvtyM/PR15enlv42ptdhrwnuYh4KfbHsLAwVFZW4ujRo5icnMTjx4/R1tYGAPjWt74lyS7jC8jha8QQ8f7sMjExMbDZbLLsMuSwKScjRa4vMjIShYWFoCiKz28RNamjowMGg4EvGCXl1YD8Q4IcRLxKpYK961+xubaJ7IEh5Pb0gGUY3Dh1CjdqapA5MACaZVF4txO65SHcVn8B5/7+DhRKNa9IBYKI9/WeoqOjUVVVhZMnT2JkZATNzc08LfHNN9/k1SRfB/fdIuKFipSQBmi1WnmlhOS3EhISsLKyIksN3S0invQnifVvkfwWwzCIjo4OKCM1NTUlKSNFRqPRwGg08gRJYmO+evUqXwjPMAxyc3N3vF+5h03APyJebCHV0tKCzk7OZv+P//iPkhZS5PrkIuLFFClhPYXYQio5ORlLS0s4efKk5K9DEPFy7Y+ErCkHyPFZnb1D1v/ms7JiQH9/1g5Fyt+wLIOEhAnExMxI+vPh4YtbVkQnvvzlf0FPTy7MZi6/xalJXP9WYuKEm0rjq7TY22xsqGCxFKKgoNOr/VGpdCA/vxv5+d2w27Uwm4tQX8/J2R9++Hm0tBwATbM+81vATkT8ppPC2+aDeKPtCOyb4jJ32AaF2HUFHoW7X9sztQst4ZtoCdtE7LoC+TYK+auAazAWd9/9fWxsqJGUNOZTkfIclmW2MlLS7Y9Ekdq3j7NTFhZyNECzmVOT6urO4MaNU1v9Wyzy8zuxualGb28OyssbZfWREUR8fLw44dBzYmJmt8ATLrz++vvo68veUpMIDZBTk2Jj3e9LX6XF3kYKIl6t3kBxcQeKizuwshKM9nYjbt8+AQC4cOE1tLczoGkT8vK6RfJb27kss9kse3O3sLCA0dHRHYqUsDxzcHDQLb8VHh6O1dVVJCUlycpwCYEcUofYH/fv34/c3Fzs27ePt8uYTCZRu8zm5qbk0mLhmEwmvxkpMsQuQ6wwL730Evr7+yXZZUhG6tChQ5KvTYr90dMuQzIuAHDx4kV0d3fvoAGKTaAZKU9FSpjfOnv2LJ/fam5uRmNjI6Kjo2G325GQkCALyCEXEb9uXwL7pAEbQdU40NKCgq4uHGxuxnxkJFiaBkvT+OjVV3H5/Hnkd3Vhc2Yao5Y6xOdWSy4tFg5BxPvKSJGhKAppaWkYGxtDR0cHzp49i4GBATx69AgPHjzwmt8CpAM5hCMFEW8wGFBRUYGKigrMzMzweTIAuHz5MgYHB/n+LV+qEclI7RYR72lvJoobyW8lJiZieXkZ8fHxskqLd4OIP336NIxGo9tCSpjfIrCc1NRUbG5uwmKx8JY/OdcnFRGvUCiQnZ2N2dlZdHZ2oqqqCoODg6I0QM+FlK/SYm9DDvi+FCnPhRRR2wHg+vXrGB8fB03TPhdSwO4Q8XJLiz+rs3fI+t98OjqK4XIpYDRKt+IJS4ulDkHEZ2f38//bpgEyePKkBE1NJL9lAk2zCA9fklxaLJzu7rytjJQ0+6NOt4qCgk5cvfoCDhx4jNDQFbAszee38vO7tvq3+ndAFlh2GxHfMpOAv31wBpZ539ajHKsSTrjQZxCHJoACCjL78L8O1SJJt4Le3lw8elSBkZE0jI2l4oc//EteTfJlu9zcVMFsDjwjJVSkDAYbysqaUFbWhNnZKLAsA5alceHC56FWryM2dhpOpxJGo5zS4igeES91hKXFBAfP9W/lgWVpPHhwGPfvc/kthjHBaGxHcLBVcmmxcHp75dkfg4NXsG+fCTdunAJNtyEkhLuPentzERS0yvdvpaWNbC00tnNZLMsiJiYG8fHxkq/PnyKlUCiQlZWFrKws3i7T1NSExcVFjI+P4+2335ZklxEeEnaLiBfaZYS4Y2KXiYuLk90jtbi4iJGREVkZKaEiRba3/uwyOp0u4IyUHER8eHg4ysrKcPv2bRQUFCA4OBhms9mNBkjT9I78FuC9tNjX+LuPPPNbZrMZzc3NsFqtsFqt+NnPfiYpvxUIIn6w+TdYW02H1mlHTm8v//9Hzs/jREMDjjc0YDQlBSzDwFxUhFUdjb4L95GaOS/7sLlbRDyBU1itVpjNZphMJtH8lkajkQ3kALYR8VLvo5iYGFRWVuLRo0fIycmBwWDg1SSS32IYRlQB+TQQ8RqNhs9vLS8vo6OjA0+ePMHy8jJWVlbwq1/9akc9hdiIlRZLGTFFSmwh1d7ejpaWFoSHhyMuLi6gjFSgiPiEhARUVlaisrLSbSFFaICkED4nJwcqlSqgHilif6ypqfH7Z8lCKiYmBq2trcjIyIBer0draytvbybKrdiyZTeI+P9/sAoCe4es/+2nrY3LO/3853/Eq0lJSePw9bNBWFosdcQQ8UqlE3l5PcjL285vmUwMbt2qxq1b1UhNHcb4eGJAQA4uIzUk+TVEkSovf4zY2GkcO3Yb4+PJMJkYmM1F6OgohsGwAqOxAwxjQnz8JObmuNLiY9U38H88rOHAFv4QgS4g26rEuNYJu8hCOka3gv9ZdhMvZXTy/wYFBZ3o7c3GxEQCqqvrYTYbcePGaTc1Sewg1dOTK+uwCQA2m96vIhUdPYeqqps4efIWRkZSYTLRaGvbDwB4770v8WqSr/wWECgifqci5UkDJP1b16+fRW3taWRm9mNkJA15ef4yUp7XxwSMiK+oeISEhKeoqiL5Le4+am0l+S2OmBgd3YD5+XyMjo6iurpa1sOdyWRCenq6JEVKo9GApmmMjo7i6dOnOHbsGCwWC2+XIb+8xewygWSk/CHiKYpCQkICEhISeLsMUdwA4MMPP+R/eUuxywDyM1KeiHihXWZxcZG3XRG7TG5uLvr7+5GbmxsQkEMuIt7pdOLw4cM8DbCvr8+NBhgdHc0rJeHh4bvOSElRpHQ6HUpLSzE7O4uZmRkcOnQIFovFb34LkAbk8Jyn7Xcwa0jF/tY2qBw7qy4oAKmjo0gdHcXZq1fRWZCL2lcq0N/PuQg++eQT/jPy1r9FJhD7o5giZTAYduS3WJbFhQsX+GxKT0+P7IwUQcT76pHyHKJsHjlyBGlpaaL5rYSEBH7ZEhwcvKuMlFREfEhICA4dOoSVlRU8fPgQBw8eRGdnp6i92fMafJUWextif/SmSHkupMiyhZSv37hxQ9JCCgisj4wg4oXvyddCSqfToaioCBaLRXZGiiDi5diQu7u7sbGxgcrKSmRkZLjZmz0XUkVFRdBqtbKBHMLrk4uI/yzPcztkURSlBLeWHXe5XJ+jKCoDwHsAogA8AfBVl8sl/Qlnbz71mZmJwdRUAg4caMbamhatrfvx+HEZoqJmUVzM0QAjIhbdXrOtSPXtKC32Nf4Q8cL81sJCONrbaTx+fBAOhxoWC+k2YpGV5T2/BewsLZZzfUJEPJffGkNy8hjOnr2G3t4csCyN5uZSNDZWICZmGnq9FYAT/8fwPoysS9uoxa8pEOJQ4HH4zm+Fr+S14u9KbiPMw564jYjvREVFIyoqGjE3F8kTEz/66FVcvnx+q1uKRUbGABQKF1iWRkjIM2RkDO74Wt6mo0O8R0psKMqFtLRhBAevoLW1BDRtwuqqFo8eVeDBgyNbNECuf8szT0cyUnIR8dv2R3FFKjjYyn9GMzMxMJlotLYewMaGBt3debh48WVw/VvDPu2xnqXF0q/PHRGvULiQmTmIzMxBvPDCZXR15W/lt47i3r1jSEych15/FYC8HqmxsTEsLCzIomQRRHxBQQGOHTuGY8eOudlluru7odVqUVhYyNtlKIqCyWSSBeQA5CHiiV0mKioK7e3tKCgowOrqqiS7TKAZKX+KVHh4+A67jMlkwvr6Ovr7+3HlyhVRGqDn7AYRL1SklEol8vLykJeXh9XVVZjNZrAsi5s3b+LmzZtIS0vjPxs5hwRif5SakQK2Fam8vDy+N2lsbAwsy+7IbzEMg/j4eB5hLQfIAQBPrWo4VGrQJv8/j1QOB4wdnWg978SKKg3Z2dlYXV3FjRs33NSkgoKCHcQysrRITk72e6gXjj9FyjO/RbKSGxsbGBkZQV1dHRiG8ftASRDxgWakiCIlzG+trKzwxMTr16/zsBytViv7kLAbRHxOTg7OnTuHM2fO7KinCAsL4627xE5IFCk5h0051D6NRgOGYZCVlYU33ngD6enpsNlskhZS5Pp8ATnExhe1z9tCqrW1FQ6HA5OTk2hoaADDMH4XJc8LEe9pb/ZcSBHXg9ys3ezsrGxE/Gd9nqeS9Z8AdAIg66J/APBtl8v1HkVRPwLwJwB++By/3t7scogiVVV1CwaDFaurQVs0QAYNDVVoaKhCauowaNqEoiILtNpVXpE6dcp3abFw5CLiIyIWcezYHYyOJmNykkJhoUWEBsgiIWFih+ImBcjhObOzBBF/XfS/c/mtLuTnd8Fu18FsLsTjlgMYHs6ACy4Uj0ZAu0UD3PBjIc6xKrFBuTCs297K5oXP4B8OX0dp3Ljoa7YR8dsPGlFR8zh5sgEnTjRgdDSFV0qI1S8/vxM9PTmoqHgk+7AZF/dUckaKew13H9XU3EBIyDKsVj2vJtXWnkFdHVHcTHxZs9TSYuEQ+6N/ah83MTEzqKmpx+xsNIaH05GX1wWLpVCQ3+LUJLFcobfSYl8zPx/hExGv0WyApttB0+1YXg5GR0cxWHYf+vr6AABXrlwRpQGKzW4yUsJfev7sMgUFBTyQQ+4hIVBE/OnTp3llxrM8U5jfUiqVkkuLhUMOm1IQ8cQuk5iYyNuAsrKyRGmAYoe8QPrI/CHitVotSkpKUFJSgoWFBd5SNDw8DIqiUF9fLym/BYgDOfyNpyLlSQPs7e2FyWTC48eP0djYiJiYGBQVFaGzsxP79++XdR9NO+MQvLKA5LExSX/eFqKETcVt6M+dO4fIyEjMzc3xatJHH320o39LoVDwQA65GSlif/SnbpD8VlpaGtbX19HT04OkpCQ+vyWkAYqpEt5Ki30NsT9WVlaK3kfBwcFu+S2ybHn27BkoisK9e/ck5beA54OI98xvkf6te/fu4e7du0hMTERRURHMZjOKi4s/tYwUGaJsnj9/HtHR0W5qknAhxTAMUlJSQFGU5NJi4chBxJOFFFHFLRYLoqOjJS2kAO+lxb7GnyIltpDq6OiAzWYDRVFobm6WtJACtkuL5SwcP+vzXA5ZFEUlAzgP4P8B8J8p7pOsAvClrT/yMwD/E3uHrM/MCBUpDiQAaLVrOHCgFQcOtGJxMQzt7TRYlsYnn7yEq1e5bim7XQu1eg15edIzUl1dgSHi+/u50uKamhuC/BbN0wCjo2dA+rfCwrhSXimlxZ4jx/6oDlpFc5ASv0QYTgMY1DkQtcF1XhEaYK/BgXGtEy6PnydKJ1cmTNDsWuUG/mbfffyZ8THUPtQSYn8UU6QoCkhNHUVq6ijOnr2Gnp4cnpjocinQ05OH4GDrFg3Qt2IkLC2WOkJqH/n7DQYbysubUF7ehNnZ6C3FjcaFC69Bo1lDQUEnrFYdVCp5pcXbiHg59kcdentzUVbWiDNnanH+PNe/ZTIxePDgCO7fr0RCwgRI/xb5XjCZmC0gh/fSYs9hWQZSEfEhISs4dOghkpPH8E//9CfIzs7G5OSkJLuMr9Ji39fnHRHvzS7z8OFDANwD0ePHj1FUVOT3gXI3iHihIiUsz3z69Cn/y7uzs5O3y1itVtkZqb6+PlkZKWCb2ldSUoJz586J0gA97TKAtNJiz5FjW4uIiMCxY8eQlZWFt99+G6mpqRgYGHDLbzEMg4SEBNH7SG5Girwnb4qUWH6LWIoAjlLZ1taGgoICv/fu0tIS5lc1SEanlJ52AMDAvlBYDTSSY7cVqaioKJw8eRInTpzA6OgoTCYT/28XHBzMdzzJzUgNDAzIykgBHCK+u7sbDMPgc5/7HKxWK68mERpgVlYWn98iBwkppcWeI4faFxMTg5qaGhiNRrz11ltITEzcQQOkaVo0vyUFyCE2vqh9xN5M0zSWl5f5ZUtdHbfcnZ2d5Rcl/hZSwtLi3SDiCQ2wpqaGV5OECylyrYFmpOQi4ru7u1FcXIyXX35Z0kKKvKdPKyMlXEjt378fb731FuLi4iQvpLyVFv+uz/NSsr4D4L8BIAidKACLLpeLJPvHAIgmcSmK+jMAfwYAqam/26Vjv0szNJTuU5EKD19CZeVdHD16F5OTiTCZGLS3G2G3G6BUbqKu7hQYhkViou/8FrBdWhwIIp48UCuVDuTldSMvrxurq1qYzZzidvNmNW7erEZ6+iAyMgZklxaTw2ZWVv8OJLnnCMEWlc/UWKdcaIjagIMCYte5rqtMmxLZNhVsChf6DQ70GjYxp3YBFJBmV0LjotBrcOB40gD+16FapIUs+fya24h4/4qUSrWJwsJOFBZ24q23/gxWqwE6nR11dadx40YNMjIGQdMmFBR0iYIwvJUW+5ptRUocER8dPcvnt4aHU8GyDCyWQqytaaFWr+P27WNgGFbSoZiodJmZ0u2PRJEiyubO/FYxWJbG9evnUFt7BtnZfcjM7N8CckgvLQ4cEU9DpeL6idRqtSS7jJTSYs8hGanS0lK/xCZil2EYBj/5yU+wuLgIADwNUIpdBnh+iHihXYZ0S5HyzM3NTWg0GjQ2NnoNX4tdXyAZKSGQQ4wG6GmXycrKkl1aTGxrqampASHif//3fx8ajYanAXrmt2ia5jN8gWSk1tbW0NXVJQkRT/JbpaWlePvttzE/P4/V1VVcvHjRTU3KzMwUvSfJYTNUN4XplCDEjnqnvALAhoZCe0UWVtaVOC7yQEhRFFJTU5Gamopz586hp6eHp+85nU4EBQWhra1NlAYoNs8DEW8wGHhgxuzsLK8mffjhh9BoNCgoKEB2drbs0mJyfVIzUsLXKBQKfOlLX4JarebVJEIDJPmt4uJiXnWRC+QA5CHiQ0JCcPjwYRw+fBjvvPMOpqensbi4iN/85jd+F1JAYCAFX4qUUE0i74NlWdy5cwcA97OBEAmlHDp3g4gnn7mUhVROTg56e3sDOmzKRcSbzWZQFIUvf/nLUKlUOxZSaWlpPCyHLKSklBb/Ls6uD1kURX0OwLTL5XpCUdQJua93uVw/BvBjACgtNbg4pPHefNrDshy1z58iRVFAYuIEEhMnkJQ0hgsXXkNy8ihaWkrw+DGhAbJbNMDFHa/fLSLeE8UNcPmtkpIWlJRw+S2STbp1qxqAC8PD6YiKmkNWVr/P/BbgXlrsbZ6ta/APT47xYAuiSA3pHXBsPRtMBzkxHeTEw4gNpNoVyLaqULisRPGyCvNqJ/oMDiTaFbCrHPj7UxfxcpZF0gM8AXLIUW9mZ6Pw9GkiTp26jsOHH2JuLopXkz766PO4fHl9K79lQkbGIBQKl+TSYs8xmaQh4inKhfT0YaSnDyMjYxAffvgaYmOn8fDhYTx4cHQrv8WpSWJ9aN5Ki/0Ny3KKVFzcTkWKy289QkXFIz6/1d7O0QABFyYnEzA0lI60NN/5LWB3iPj8/Bl+q+/PLsMwDPr6+mRnpMxms2xq38LCAiYmJlBVVYXKykpJdhlhafGngYhXKBR8eWZHRwc++OADhIeH8+Frf3YZoSIl1/7oTZEKDw/HsWPHUFlZiYmJCf6QbLFw3Wrz8/MYHx+XZJch9sdAEPFCRUqoJpEHHJLfSk9PB03T6OnpkZ2RslgsASHix8fHceLECRw7dgxjY2N8/1Z7ezsMBgOvlJD8lhDIcajif+CB7Ws4+dNhhM2JE1k31RTu/UEqNhJroFzxb38k91phYSF/HxkMBp4GmJGRAYZheBqg53grLfY3vhDx0dHRqK6uRlVVFYaHh0G6pUxbebSVlRVMT09LAgIIS4uljpgiRWiAJL9lMpnc8ls0TaO7uzugjFQgiPjx8XEcPXoUJ06cwNDQEH+YIPUUhJgoPFgGkpGSan8ULqSEh2PhQophGJ4G6DnPKyNFxtdCqrm5GQB3wF1YWJC0kHpeiHixhdSlS5dw5coV5OXlgaZpdHZ2ygZy/C7M81CyjgB4iaKoFwBowWWy3gQQTlGUakvNSgYgHjjZm9/6bGekzCLdPd6nvZ1GaOgS/uiPfo61NQ2f37p1qwq3bnH5LYYxobCQy28B24h4ORkpOYj4iIhFHD9+B5WVd/Gtb/1nqFQOjIykors7H3q9lSfdJSRMih5qxEqLybhcwOXhPPyPxmpM2bY3m0JFynOcFDCkd2JIv44gB3cYy7YqUbaohgsuhIY+Q/qKBuvrGkm5IpKR8kfqc3+NuyIVFTWHkydv4cSJWxgd5WiAFksRb0M0GtsREzMtq7QYCBwRbzYXITh4GX/8x+/Abif5LRq1tWdRV3caWVn94Pq3uvgMn5TSYs+Zm4uUrEiR/FZV1U18+9t/A4BCb28OzGbjFg2Qu49iYmZFX78bRDzDfALSl0XGm13m6lUOkhEeHo7Ozk5Jdhlgdxkp8iDkyy4TERGB4uJixMbGyiotBgJHxHd2dkKv1+PP/uzPsLKyIskuE8hh019GigxFUUhKSkJSUhJOnTqF7373u/x7Iz1evuwyQOAZKZvNJnrw0el0bvkt8oDz8ccfA+DshgMDA6I0QG/XtxtEvFh+i2VZNDU14dGjR4iJiQEp8iWlxcmFpdj4g39AvfJvkf14AVnNizAscz97N1UUhgv06DoZj/D9pzAzG4WcnBRZ9seenh5otVr85V/+pVsJ64ULF6BWq3fkt4DA+sikIuIpikJ6ejrS09Nx9uxZfP/738f6+jpaW1vR0tLiN78FBNYj5UuREua3pqen+e/9Dz74AABnyRwbG0NaWpoklWQ3iHiapt3yW6SeQriQSkpKAk3TiI2NlZ2RChQR39/fj6CgIPyH//AfMD8/zx8AyUKK9G+RhRTgv7RYbKQi4oULqbW1Nfzwhz+E3W7H48eP8fjx4x31FGLzvBHxngspsmyxWCygKAoMw8g6bP4uzK4PWS6X6+8A/B0AbClZ/9Xlcn2Zoqj3AbwOjjD4RwAu7vZr7c3zGZKRknPwIYrUkSOcIuWe3woHyxaDZRlcuvQSrlzh8ls0bYLJRMsqLQYCQ8SPjKTBag3B5z//GxQWcshzlmV4GiCX3zKBptv5/Jav0uLR5VD890enUD+201KUbVViRenCZJBvRWVNCXSGOOBMeYqjqln0tRwABeDixVfcaICZmQOi6szsLIeIP3VKHMghNsT+mJk5sMP+yOW3RpCaOoJz566hpycXLEujsbECTqcSgBPPnoVieTnYr3USeD6IeIPBivLyRpSXN2JmJhqkf+vDD7n8FtctxcJkkldaDASGiB8fT8bKSihefvkCioos6OrKA0cDPIJ79yqRmDgOmmZhNG7nt6SUFotfH0HEd4L0ZYmN0C5z8+ZN3L17F+vr65LtMvPz8wEh4r0pUkK7DLGPCe0yAKcY2Ww2SXaZQOyPnoqU0C4zOTnJq0lCuwzDMLJKi8kEYn+cmprC8vIyXnzxRRQWFkqyy0gpLfZ2fTqdzq/9MSIiAsePH8exY8dw8+ZN3Lt3DzabDe+++y5PA6RpWjS/BYiXFvsbX4h4lUqFgoICFBQUwGaz8fmt+vp6t9ev/f/Y+/PoNu47zRt9CgtBAtz3fd8JVmkjKUqiNlIbldhOnKSdxFm63+5Mp7vnvjPzvnOnZ86cM33nvGfu6dNx0nEWZ1+cjmM7kSVbKyVqsSRSJCWKrAJAgou4k+K+7yCA+0fxVyyABaAKVO4Zy3rO6T86FsgCWBLr+3u+z+dZW0PG3lcRlcKg687Pce3xeQSsAyonhRXtBmJT92J31bexqErC0mbXkly5O1Li/NbAwAAIMZHjOISEhAgZN+JIJScny/5e/iDip6enMT8/j+rqasF185Xf2mlGypcjFRsbi6qqKhw/fhy3bt1CXV0d5ubm8Nvf/lbIbzEM49E52iki3v3rejuQIl9fq9ViY2ND1oHUThHxAQEBwoGUmAbIsiyam5uFAylyH/kD5FBK7Zufn8fc3BxOnTqFgoICyXoK9wMpMZDjWSPixQdSp06dws2bN/HgwQNF7+mToj9nT9Z/AfAuRVH/D4AWAL/8M36vF1IgjmMQFjaLtDQlGalil4yUWOHhszh8+B4qKu5hZCQRHMfAbDairY0/jU1N7cPwcCISE7fTAN0lzkgpQcRvlRZ3bNIAO5Cfz4M6eNeGxq1bVZv5rb7N9+HcNiRsOCj8wlKCN1oPYmVj+5pIoB1IWVWBC93YBrbY9mdFYIvf/PL/QHz8U3zrWz/F0FAKWJaGxWKEyUTDYFgUnJL4+FHhM+I4RnFGamCAz0gdO+bdkeLzW20oLGzD/HwIfvCD/xcCAtZx61YVbt8+LvRv5ee3IyBAmgi5E0S8lCMVEzOJykreTervTxMcN9LBlZbWi/HxGMkVUneJS4uVZ6RswuBdXGxGcbEZi4vBMJl4YuK1a2dQU8Pnt2iahdMJRaXFAL/+6IqIvwNPQ5ZYfX19iImJwb/7d/9uW37L27oMoAwR7y0jJZZOpxPWZWZmZvDjH/8YarUa169fR21trcsvb08POCQj5c/6o/sJsDh8LX7AEa/LZGRkYHZ2Vta6zLNAxHvKb128eFHIb9E0DYfD4ReQQykinqIoDA0NITIyEt/+9reF/q1Hjx6hsbFRMr8F+DdsykXE6/V6lJSUoKSkBJOTk/jZz34GgM8B3rhxQ+jf2v2F/y+YV/4Jy3NP4bDbEBQSA52BB1ycO3fO74yU1H1EaIDu+S0Cg8nMzMTi4qKs/NazQMTr9XohvzUxMSHcR2RFjVQv2O32P2tGikilUuHp06cIDw/Ht7/9baF/i+S3EhMTQbqlxI6QPz1SchHx4gOpp0+f4te//jUcDgcuXryI69evC26SpwMp4Nki4t0PpMT5LXIolZWVhdXVVdnuqz8ZKbEjFRwc7PVAihy2rK+v+wXkULr+qFarMTk5qRjI8UnRMx2ynE7nHfBPC3A6nT0ASp/l13+hnWtxMdjFkZIrjiOOlPS6FMA7JUlJI0hKGsHJkzU4d+4LaG8vwPBwMn7xi29t5rfYzfyWNPBBqrTYl3hHqkgSER8UtIq9e5uxd28zZmYihGzSRx+9AopyQKOxwWbTwOFQoXUqTgBbeFLWshoqUOjWb18VFEsMthAj4ikKSEkZRErK4Gb/Fu8mNTWVoqGhHLGxY5tOiQmkR0qOq0TEsjS02nXk58tfWxsaSsHGhhavvfYHhIfPCdmk8+c/D612XXCT0tN7BfjGliPlHyI+Ls6zI8Xnt/qQnt6H6uor+OCDz8NqLcDAQBreeuvvER//FAzDwmg0eRzESWnxkSPKM1JSjlRw8CLKyxtQXt6A8fEYwXHr6sqFSmWHRrMOtdoOp5OS9fdqOyL+DoD/5vU1YkdKrVa70AA9rcsUFRX5lZFiWVYxIn5sbAwbGxv44he/iNDQUGFdxmq1elyX8VVa7Ely1h/VarXLusyFCxdgtVrR29uLN998U9a6zLNGxHtal7FYLFCr1dBoNNDr9XA6nbJO+d2BHHI0OzsrOFIajUaSBuie3yooKADHcUhNTZU1nBL5s/44MzMDm82GL33pSzAYDIKbZDKZEBwcLLhJcXFxwmckBnL4k5Hy5kiJ81tLS0u4ePEiOjo60NPTg+9973tC/5an/BaAZ46Ij4mJcclvEWJia2srtFot1Gq1op/TThHxAQEBQn5rYWFBcNyuXbu2rVvKHyCHP4j4lZUV2Gw2vPrqqwgKCnJZbyY0QJqmXa5jfX0dbW1tMBqNzxwRr9PpsGvXLuzatQvz8/O4dOkSurq68OTJE3znO9+RdSAlVVrsS54cKfGBlDi/1dLSgocPH0Kn00GtViMuzvPzkLv+HIj4T7r+nE7WC/1vKJPJ6NGR8qStjNRV2a9RqZwYHk5CTk4XPv/5DzbzWzRu367E7duVSEvj3SQ+v7VFjfJVWiyljo78TUS8dychImIGR458jMOHP0Z3dzbeeeerAIB33/0qnAHrMOsojBnswCYNUEo5SxpMah2YCZB+kI4JWsQ/ld7CSxntgiNF1h/dHSmNxo6CgnYUFLRjeTlI6LmqrT2B2toqABSysrqwtiYvv0VKi/mMlO8+MiKxI6VSOXH8+G0cO3YHAwNb/VssuwshIfOC49bfn+5C7ZOjyUnliHiNZgOjownIzOzB5z73gdC/VVNzGtevk/wWi/z8DpcB21dpsZS6unJlIeJjYydQVVWL48dvoqMjD++//yUAarz99jc281t8/1Z0tOcDCY5jXEqLgTq457K2v0bakfK2LnPt2jU4nU5kZWXJXpfZKSI+OzsbKpXK67oMud7e3l7FPVL+IOIDAgIwMTGBtLQ0fO5znxNcADENkKZpZGdnuwx7/gybchDx7usy7e3tOHfuHCiKwq9+9SvBTSouLvbqoPmTkfK0tiamAbrnty5fvgy73Y7S0lI4HA5Z+a2dIuJzc3OhVquRmpoqmd+KjY0VPqOenh4Xap8cyc1IiaXX6zE9PY2UlBS89NJLwoM7yW8RNyk9Pd3lMyIZqWeNiBfnt6qrq2GxWPDRRx/B6XTiZz/7mUADJA6GJz1LRHxISAjKy8tRXl6O8fFxgZjY2dmJgIAArK+vo7S0VPZBAhk2s7Oz/UbEa7XabfUU9+7dw927d4UDKaPRiO7ubsXDpj+I+NDQUCwsLCAhIQGf/exnhftIfCDFMAySk5NdvibHeS4t9iQ5iHj3/JbJZMKVK1fgdDrx4x//WLKeQko7QcQ/j6uCwIsh61On1tZdCA6eh0YjH3ixNSSYZb9GjIgPDFzFnj2PsWfP4838Fu8mXbz4stC/RdMcUlP7FZUWE3EcvYmI75P15ykKmJ6OAkAh5/QN/LblAGKmQ1C4oELxghYzWge69HZ0G+xY0mwNU2E2CjHrKjwIlx54Xs9rwX/d+zHCdFtDo+v6o2dHSq9fQUnJI5SUPMLUVCT+9KcvYnQ0Ho8fl8BkYpCfbwVNs8jM7PVI1yOlxUrgEEtL0o4URTmRljaAtLQBnDlzFR0dueA4Bg0N+1FffxBa7TqCg+eh18tf6dwZIv7OJg2wEfv3u+e3viDKb7FITh4USouVADk4jlaEiFepnFhcDAagwje/+QvMzvJOaV3dIdy/f3gzv8Vu5reWhddNT/NADtfS4mV4y2WRtbWMjAyvjpR4XWZsbAznz5/H2NgYHj16BLPZvI0GKKVniYj3tC5DyjMDAgJgMBgU48oBZeuPYkcqLCxMsjyzra3NZV0mPj5edmmx+/UpQcSr1Wqsr/P36euvvy4MOMRNkspvAVtADn8yUr4cKXF+a2hoCJcuXcL4+DiamppgsVgEN4nQAKX0LBHxnvJbtbW1qK2tRWBgIAwGgyzyHpE/64/EkSIFtcePH8exY8cwMDAguEksyyIkJMQlm2QymWSVFrtfn5L1R61WK5AZX3vtNeE+IjTArKwsMAwjDB1E8/PzfzZEfGxsLE6cOIHKykr09fXh2rVrmJiYQFNTEzo6OoTDFm/kP/fSYjny5EiJaYDkQIplWVy9ehU1NTUIDAyEXq9XlNncKSKe0AB9HUhFRET4BeQgGSm5iHidTofAwEA4nU58/vOfF1acfR1I+etIcRyH+Ph4RX93P0l6MWR9ijQ+HoPx8XgAwJtv/gekpvaDplkUFW3RAN0lVVosR54Q8Xx+6y4qKu5iZCQJLEvDbC6GxWKETreK9XUdEhOH4HRCFuJ8cdGA7m6+tFjJ+uOjlt1YM6zgP3HHADWAGJ4GmLGsRs6SGqVzWpTMafBU50CnwY4+vR05S2o4wPdfiZUXPoF/PlCDfXHbAZr9/Wk+EfHuCg2dx8xMBGiaxd69zYKbZDLxQ4DRaALDsNsgEIQWmJ6upEfK6NOR0mg2UFTUhqKiNiwt6dHYWIZ7947AZgvA9773nzbzW+zmUCM9HJP7SDkinpZ0pMT5rb6+NJD+rdbW3QgKWsLqahDS0vpkf5+tjJR/iPjk5CGkpAyhuNiEhYVgoX/r2rVqoX+Lpjnk5nYIQI7tpcV34GnIGhoawszMDA4fPiz72qKjozE/P4+ioiLs3r1b1roM/548lxZ7khxqn/u6TGNjI+rr67G+vo433nhD1rrMTjJS7o6Ur3WZkJAQLC8vIzMzU/b32SkiPiMjA5mZmQINkDwEuue3srKy/AIpkIzUZz7zGVl/nnxGi4uLAmWP4zg8fPgQjY2NAg2wuLh42/BPHKlnjYgX57empqaEawGAN954A/n5+WAYxoUG6C4xkENJRkpq/VGc36qurhaySQ0NDaivr0dERASWlpYUfQ47QcSHh4cjNzcXFEVh//79mJiYENykc+fOueS30tPT/bqPlCLiVSoV0tPTsbKygpycHBiNRpf1Zk/5LfKe/OmR8uVIiQ+kRkdH8ejRIzQ3NwMAvvvd78o6kCLX5w8i3p3a5+tAKiYmBvPz8zhy5Ijs7+MvIp5lWYSGhsJoNIKiKOFAivwOER9IMQyDxMREv4ZNfxDxnzS9GLI+RSIghb/+65/jyZNscByNS5decnGTsrO7oVZvDRFbjpT8FS85iHg+vzWMpKRhnDp1Hd3d2bh48TNYW9PhypXPoqlpP2iaQ3Gx5/wWsL202Jc2HBR+8uAopsbi8Th8HcDWe11TA9YQO6whdoTYKORs4tePTgdgY8YJJ4AprQOrm7+3xWALrYcH8y0gh/ceKbE6O/M2HSkOqamDSE0dxOnTVzdpgAyamsrQ0HBgM7/ForjYBLXaLru0WCyOo31mpMQijgxFOfCNb/waT57kgONonD/P0wBJ/1Z6ep/LdQwMpPiFiN9af5R2pCjKiYyMPmRk8Pmtjo48XLt2GoATly69hObmfSD9W94OCdxLi+WIOFLuiPiQkEWUlz9AefkDjI/HChm3zs486HSrcDqB+PinEsPmHXjKZZEhoaCgQPb1EUeKYRiX/JZ7+DopKQkMw6CoqAgURckuLRaL4zjExMTIRsSHhoYK+ZWvfOUr6OnpkbUuQ4AcBw8elH1tcqh9arUaubm5yM3NxerqKtra2gTK3cWLF8GyrKx1mWeJiI+IiBDyW8PDw0JA3WKxQK/Xw+FwIC4uzm8gh1yJEfF5eXnb8ls3b97EzZs3kZGRIeS3nE4nOjo6ZJUWi6V0/TEqKkpYg3v11VfR29uLtrY2Ib8l7t8SS+xIyZWY2udp/VGj0aCoqAhFRUVYWlqCxWLBnTt3AACXLl1CW1ub0L/l7aHXvbRYjjw5UjExMaiqqhLcJNK/1drairCwMNhsNsTGxvpVWuwPIn7Xrl3CkOee3xL3b+Xl5cHhcCgGcpDrCwsLk42Ij4+PF97/Zz/7WfT398s6kBobG/MbEZ+Tk+PRkRIfSM3NzcFkMuH+/fsAeBhMV1eXzwMpwDOQw5ukEPHuQCH3A6moqCisra0hJiZGEZCDrD8quY8+aXoxZH1K5HDwZbPZ2d1ITHyKxMSnOHToHp4+TRTcpLa2IgQFLW86JRwSE4fBcTR0ulXk5cnPSFmt+YoQ8Wq1HUlJQ1heNqCs7AFiYibBcQxu3arErVt8fov0b+lEq3iA99Jidz2eSMA/1p+CvicJjIQjJdaC1onHYRt4HLqB2HUVmHkN0lfUiLGp8ZXhQKzFTePrh69id2a3R8fNZtOgvV0aEe9NJCMldqQ0GjsKC9tRWEjyW3y3VG3tSdTWnkBU1BQcDjUKCiyyv89WRso/RHxa2iDS0gZx7NhtDAxs9W9t5bf4bFJs7LgoI6Vk2MxVRO3Tam3IzHyClZUg7NnzCDExU+A4GjU1Z1zcpLw867bh31tpsSexrG9EfGzsOE6cqEVl5U309WWgvr4cT57kYHQ0Ed///v8JvsibRXT0FDzlsjY2NvzKSLEsu82REq/LzM/PC/ktUp4ZExMDu92u6JfeThHxJAtA1mVYlpVcl4mMjATHySstFqu7u1vR+iMpWb5y5YpAapSzLgN4Ly32JF9raxRFITk5GcnJyTh16hS6u7vR2NiI3t5erK6u4sc//rEkDdBd4mHTn4yUeP1RnN+anp4W8lsffvghLl++jLi4OGxsbCha6dwpIt5oNMJoNErSAEl+i6ZphISECMOm0oyUkvVHg8EAhmFw48YNFBUVCfcvoQESZ9A9vwV4Ly32JF+OFEVRyMjIQEZGhlB2/vDhQwwODmJ5eRk/+9nPBFfS2zras0TEi/NbY2NjglPS2dkJnU6H+Ph42Gw2RffRThHxhAQqdSCVnJwsHLbo9Xq/hk2liPiwsDCUlZXh7t27yM3NRUREhAAUIvUUNE1vO5Ai7+lZZ6SkDqSam5sxNTWFxcVF/PrXvwbDMNvWm90lVVr8POrFkPUpUV9fOhYWQnHy5NYDNUUBiYkjSEwcwcmT1wV36/HjvXj4sAyRkVOYmwtDbu72h1Jv4jjab0T83r0tiImZwN69jzEzQ/JbDD766GWX/q2srCeYno6SVVo8vx6Af24+jLete+B0UnhtSY2hQAdW5BywUsC4zoE1lRPrcIJNmEeVZgELwwm4+G+voyFmHKR/yx0V3tGRp7hHamnJsOlIPfDoSPH5rYcoKXmIqalIkB4nAHj77W8K/VsZGT1eXS1/MlLEkRIj4vn8Vj/S0vpRXS3Ob5Wjvv4Q4uJGMTkZhdzcTr8yUhkZPbJfQ9YfS0oeIT5+DPv3N2BiIkZwk86dI/ktCxiGQ1paP6anIzYdqeuyVlSBLUR8ZmaPLES8SuVEZmYP2toKoVbbUF19BW1tRbh//xDu3RPnt+phMBx1eW1XVxdWV1f9ykiVlJR4dKRCQ0Nx8OBBHDx4EKOjo8JDKQD8/ve/V7QuA+wcEe9rXSY5ORljY2PIysryKyOlZP2RUPtKS0uRmJgomd/S6/WC45aYmIi5uTkMDAz4LC0WS+n6o1qtRl5eHnp6etDf348TJ06gvb19Gw2wsLBw20BOHCl/+sh2797t0ZGKjIzE0aNHceTIEQwNDYFlWbS0tAAA3n//fRc3Sc595G9GikhMA1xeXhacktraWsFxGxoaQlZWlqJhk2VZxeuPxJEqKytDSkoKjh07hv7+fsFNcs9vxcbG+gXkIPdRcnKyLEdKq9WiuLgYT58+xdDQEI4ePQqr1Srkt8RukrvjJgfI4S45iPi4uDiX/BYZ3AHgww8/lKynkJI/PVLEkRKvP/o6kMrJyUF/fz8yMzMVZ6T8QcTbbDaUl5cjPT3dZb2Z1FNERkYKf9ciIyNllxZLXZ9cRDypp5iensbIyAgOHToEq9WKixcv4sqVK14PpLyVFj9PejFkfUrEcYxXR0qtdiA3txO5uZ1YXdWhra0QDx4cgN2uQXu7Eb/+dYjgJnnKbwHPAhG/5UhFRMziyJG7OHz4LoaHk0D6tywWI/T6JYSFzQJwoKhIekhwOoHL/Xn4H42VGFvmu0wS1lQIsavw0AO8QkpqB5/VUiVO4Pdf/yXCdGtYWSE0QBo3b57AzZtVyMjoBU2zAgKc4xhFQA6AX39UsrYWFTWN4mIOd+8ewb59jXA41Ju9YAyCgxdE/Vuu64BOJwWOY/xAxDNeEfHu+S2z2YjGxjLY7VpYrQX4/e+/Cr5/y+rV3XMvLZYrjtteWhwTM4GqqpuorLyFvr50cBzp39qDsLBZhIbOQWlpsf+I+CIUFrYLRd4LC8Ewmfgibz6/9TGys58KDzgajcbvjJTD4ZC9Hx8fHw+dTocHDx5g165dsNvtwrqMuDzTPb/irbTYm3xR+6TWZR4+fAibzYauri68//77wrqMt3U0fzNSLMu6IOI95bceP34srMuEhoYCUDYk+IuIN5vNyM/Px/79+7F///5tNMArV64I3VJZWVlQqVSSjpQvKVlboygKKSkpCAkJQXNzM4qKimC32wUaIMlv0TQtfFZE3kqLvcmXI6XX61FaWorS0lJMTU2B4zg0NzdjfX0dPT09OH/+PGia9prfAp4dIl5MAxQ7biS/FR8fL/RuKR0SxsfHFSPiCZDj8OHDOHz4MMbHxwU36dy5c9DpdCgoKADDMEhLSwNFUQKQQ8mQoAQRr1KpkJmZiZiYGLAsi7y8PGxsbGyrpzAajZJOmj8ZKV+OFDmQIkAh4ravrq6iv78fly5dgns9hZSeFSLenQZIys7JgVRKSgqCg4MVD5vj4+OKM1IEEZ+TkyPUCkgdSBGgUGJionAf+Sotfh70Ysj6FMhm06K9vcBrRkqswMA17NnTgvb2Qqyt6bBv3yPwNMCXXNwkPr/lmkXyBxE/Pu4dEU9RQHLyMJKTh3HqVA26urLBcQza2wsAUHj77W8KblJYGJ/fGlwIxX9vOIGbQ64PFDlLaqxTTvQFee+5EqtctYQAZxC+XnVVIAcGBa1g375H2LfvEaanI0GIiR9++DlcvvwZ5OR0oauLB3IoHRLi458iNnZcwWv4rN3hw/cQErKIM2eubea3aDQ2luHBAz6/xTB8fiskZAEDA6mYmwvH8eO3ZH8fkpEqLGyThYg3GJZRVtaEnp4srK3psHt3C8zmYnzwwasiGiCH9PS+bQM5KS1Wch9NTUUJjpSU+PxWLzIyelFdfQVWax44jkF3dzYACu++++XN/i3v+S1gp4j4rQE6JGQRBw48wIEDDzA2FguOewkmU4iwLpOXl4eOjg6Ulpb6lZFyz6L4eg0AHD16FGFhYcKDpbd1GQLkqKiokP19lCLiw8LCcOjQIQwPDwv5AovFIpRneluX8VRa7E2zs7NeEfFS6zIsy6K3l1/vvXDhgiQNUEo7yUiJH57ENMDh4WGhf8tsNsNgMCA/Px/t7e2KSovJ9UVFRfmFiK+srERERIQLDVAqv6XT6RQDOQDXHik5jlRUVBSOHTuGqakpdHV1oaioSHg4DQkJcenfcpe/GSlvjpRWq3XJbxHHraurCwBw9epVkP4tXw/k4tJiuZJypGJjY1FVVSX0b7nnt4qKitDe3g6apv0Ccviz/njixAlERUVtq6eoqalBdnY2GIZBbm4uNBqN7NJisciwKQcRT1EU4uPjER8fj+XlZbS3tyMvL08Y3t3Xm91FHKmdZqTE0ul02L17N3bv3i0cSHEch8HBQQDA7du3ZR1IAc8GEe/pQKq5uRlNTU2IioqC0WiExWJBUVGRomHzk6gXQ9anQFsZKfkPrFuO1H0RDTBRcJPa2oqg1y+hqMgMhmGRmDgCiuIfPhMTh72WFruLDAlyEPFqtR35+R3Q6dbQ3l6I3bubMTUVjVu3qoT81kzUAn4+nYZ5h2u2hThSvXo77DKeVwnYItychfFQrUdHKjJyGkeP3sGRI3cwNJQClqXBsgwAFVpbdwvDQnz8qNd1NHFpsVzxjpRrabFGs4HCwjYUFrZheVkPs5l3tm7cOInaWt5xs9tV0GiUlRYTRLzcjBTAI+K7u7NRVtYguEn9/akQ0wBDQ+cEx41k60hpsbsD502E2ifHkdJqbSguNiMsbA7d3TkwGjlMTsbg2rUzqKkh+S0WeXkd2w4miCPlPyJeev0xLm4cJ068g8rKKfT28qADi8UCp9OJtrY2YX3F17qMvxkplmVdEPE6nc7rukxubi5sNpviIcFfRHxXVxf27t2LM2fO4NSpU5LrMmLcMSCvtNhdStYfybpMbGwsfvnLXyIvLw+Tk5PCuozYTXJ/wPFWWuzr+jwh4sX5LXG3VEtLCxwOB7q7u3H//n1JGqC7PAE5vEkKES+mAUrltwoKCrC+vg6VSqV42PQHEU+AHGfPnkV1dfW2/FZcXJyQTSKuEgFyeCstdpeS9UeDwYCysjKkpqbiZz/7GbKysjAxMSHkt8Q0QPefBRk2/clIeXKkVCrVtvwWx3Gor68HAAwMDKCxsVGSBuiuZ4WId6+nEPdv6XQ6FBUVYW1tTTFIQWlGCthafzQajXjppZc8rjcTx40cArg7UnJE1h/lHBSRA6mcnBz85Cc/QWpqKgYGBlwOpBiGQVJS0rafhbi0+Fkh4qUOpMhnBChzaz+pejFkfQq0lZEakP0a4kiRtTWeBjiCpKQRnDxZg+5u3k0i+a2oqElkZT3B6GgCTp+WX1rMgxSK/UDE86XFZ85cg1Zrw8xMBGoeHEAruwtB/Vq8uulWdRvsGAp0wEkBaStqBDgpdHsBXhAdSerB/yq/jmjVBt64cAoHDvhef6QoICVlECkpgxgeTsLqaiDi48fQ1FSKhobyTRogT0wMDd2OMSd9ZEaj/LW1/n7iSEkj4vX6ZZSWPkRp6UNMTUWBZfmM29xcOFQqOy5f/gxomhWKiL3pWSDiKcqJ9PR+pKf348wZngbIcQzq6w+gru4Q4uOfIju7S3FpsdMJYdiU+my9vSetdh2f/ewlBASsY3w8BhzHwGQqxrlzX4ROt4qCgjYwDIu0tAFQlFN2abFY8hHxy1CpHiMr6wCysrIwOTmJhYUFxMTEKFqXAZT9AvOFiJdalzGZTFhaWoJarcaNGzckaYBS8mf9kWSkyIOGp3WZO3fu4M6dO0hJSUF2drbi0mLx+qPS7i6NRoNXXnkFOp0OIyMjgptEaIDu6zKktFiJy7a6ugqr1SrLkVKr1cjPz0d+fj5++ctfYnp6GiEhIYKb5C2/BfgGKUjJlyMlzm8NDg4KBwmrq6tQq9W4e/eu4CbJuY/8RcST9yTObxEaIMdxuHHjBmpra5GZmYmcnBy/M1L+IOJVKhU+//nPIygoaJubFBoaKuRuSK8QcaSU3Efr6+uwWq2yqH0kv1VcXIxf//rXmJiYgEajwbVr11BTU4OcnBzQNI3c3FxJV8Kf+8iXIxUXF4eTJ0+iqqoKvb29woqjzWaDRqNBQ0ODrAMp4Nkg4t3rKUj1gvhAKicnB0+ePEFFRYXiYVPp+qPJZAJFUfjSl76EwMBAoX/L24GUnNJidylBxJMDqT179uC3v/0tpqamFAE5Pql6MWQ951pY2HKklGWkeEcqOnq7I6VWO5CX14m8vE6srgaira0QHEejqakMAJ8r0mrXN/Nba9teL5a4tFiuthDxfGnx/HoAvmPdi7fHiuCM20Dsuh3ZSxpkLauRvazBsoonCUavUVhUOTCi8/yQGxO0iH8qvYWXMtpBUUBjY5nLsClHExPRGB1NxMmT11Be3rBJA+TdpNraE4KbxDCsgCcXlxYryUiRIUEOIj4qagrHj99GbOwYzp37EjIznwhDTkjIvECVlMK5E0fqWSLitdoNGI0WGI0WLC0ZYDbzxMT79w8DcKKrKxshIfPIz+/wSWfcKi1Whoi3WFwR8bGxE6iqqsXx4zc381uMS36ruJjD0FCyotJiQF4f2ZbuADgghIkrKytx6NAhyXUZ8QOORqNxKS12z714ExkSfCHixesyycnJ+NOf/oTk5GSPNEB3eSotlnN9nhwpqXUZlmVx+zZ/LwwMDMBqtcpalyEZqZ0i4pOSkpCUlCTQAN3XZWiaxuDgoN9ADqXrj0NDQzh27BgOHz4sK78ldqT+HIh4iqKQmpqK1NRUZGVl4f3330d8fLyQ3yI0wOLiYsn72FNpsS95c6QMBoOQ35qcnBQe3J88eQKAf/B/8uSJz/wWsDNEvLi0WJzfIv1b9fX1qKurQ0JCAmiaRn9/v6LSYkBZRopofn4eAwMDOHz4MI4dO4bx8fFtbhJx3Eh+C5BXWuwusv7oy5FSqVRCPUVBQQHee+89REZGyj6QIhmpZ4mIFx9IEaAQqacAtjYN5BxIiUuL5UrKkSIHUqurq4LjRg6kUlNTQdM0+vr6/Bo219fXFd1Hi4uL6O/vV1xa/EnViyHrOReh9ikZEsbHY2Q7UoGBq9iz5zF27WrBd7/7nxAYyEMhLl582aV/Kytre34L8Fxa7E1Wax7W13UoLmZxqc8VbMHTAJ0Y19nQEGFDyooKOUsaFC6ooQaFFZUTzLwG3QY7ljSuw8LreS34r3s/FnJXAA96cAdy+JL7+iNPA3yEkpJHmzRAnnR34cLncPnyWeTnWxEX91RxabHNphGGTTkZKSKTiR+qvvzlP8DhUKOzMxcsy6CxcT8ePDiIuLhRoX+LDHxkSFDi3ihBxBsMSygra0RpaRO+973/ALXagenpKHzwwRdE+S0W6en9kocFW6XFShDxOR4R8TwNsBeZmb2orr6Mjo58cByNurpDcDpVMBgW8fDhvs381rLP70WAHPIQ8XcA/LdtjpSndZmOjg4BOx4fH6+4tFhpRoqI5H2+/vWvw2azyVqX8ScjNTMzI9uRIusyBw4cwPe//304nU48ffoU7733ns91GcA3kENK3hDxhAaYl5fnkt8iAyDBicvJbwHPBhEvzm8NDQ0JbhL5eRqNRiQmJirOSPmLiLdYLAgKCsJf/uVfYm1tTXCTamtrBTeJ5LdIt5qc0mJ3KUHER0dH4/jx4zh69CjefPNNbGxsoLe3F1arVaAB0jQtmd8CfAM5pOQNEa/VagVEvTi/VVPD/9saGhqK9vZ2Wfkt4Nkg4mNjY7fRAC0WC1paWhAWFia4tv4COZSuP7a3t0On0+Fv/uZvsLKy4vNACvAvIyUXEU9RFBISEpCQkIATJ07ghz/8oQDisVgsPg+kAOnSYl/y5kgFBga6HEiRw5ZLly4B4P/9fPLkiawDKcC/9Ud/Sos/yXoxZD3n4jjaoyPl+TXM5tqa74wUUV9fOpaWQnD69DUUFVkwMpIElqVhsWzRAIlTkpDA57fklBZ7uj5DyDz+P917cXPYMynLQQH9egf69etgZtUonQ/AktqJ0jktSuY0eKpzoMtghyZhDP+r4hr2xQ27vH5iIloWIl4skpHKynqC4ODtjlRU1DSOHbuDo0fvYHAwBRzHwGIpgsnE54mGhpIQEzMuK4tESouVIeJdHSmVaiu/tbSkF/q3btw4hdraE8jM7AFNc2hp2bXpSCkHcihFxC8shOGVVz4ATZvQ358m9G9t5bf4/i0y+MopLfZ0fXIQ8QEBNhQXm1BcbMK9e4dw61YVAgNXNmmAW/1bubnb81sAMDUlXVrsWXVwOte8OlKe1mUeP34MAJiYmMDU1JSs02N/M1JiRLz7ugz55S1el6FpGizL+g3kUErtm5+fx0svvQSapmXlt8RDgpJhUy4iXrwuc+/ePdy6dQsqlQoXL1506d+Sym8BO89IuTtShAaYkpLikt969OgR7HZ+pXphYQHz8/OyXNGdIOKJIyXObxEaIMdxuHDhAi5fviw4bizLKiotBvxfW5ubm8PZs2exa9cuwU0iNECp/JY4I6W0j0yOI0XyW2VlZcJ9ZLfbZeW3AP8yUt4Q8YQGmJmZ6ZLfun//PpxO/kBsbW0NS0tLsrI+pLR4J4h48YGU2E0SH0gxDAOWZREeHi67tBjwDxE/MTGBmZkZnD59Grt27dp2IJWSkiIAhcg9I6e0WEosy8pypMLCwlBRUYFDhw7h3r17uH37NtbW1oQDKbLe7OlA6v8fiPjnQS+GrOdY4+OxGB1NQFzcU1itecjJ6YZa7T2PJC4tVpqRIoh4Pr81jKQkngZI8lvNzfvQ1LQf0dEToGkOAQFrikqLAWB2PhjdT7JgDlvHAy8DlrsyVjWY0DpwIWENITYKOctq5CypcWQ6AJr5ePRT+xFGs8jK6hEyM1vDpvwhoa8vDfPzYaiq8r7+SFFAauogUlMHUVl5A9/97v8FvX4Fjx6VoKlp/2Z+i3eTPGWMtkqL+2RfH0HESw1mBsMySkubUFrahMnJKHAcA46jcf785wEACQnD6OnJRHq67/yWFJBDjsSlxXx+qw/p6X2orhbntw6irq4CCQkjoGkWAQHrikqLAT4j5Q8ivrMzD7GxY/j2t9/C+His0L/V2ZkHnW4VhYV8fis1dUBw3LaAHHKvbxmDgzdlOVLidZlTp07hX//1XxEQEID6+nrU19f7XJfhr+/ZIuJDQ0Nx6NAhl/4t8bpMUlIShoaGZK3LPAtEvHv42tO6TEBAgF/Dpj+I+O7ubkRFReHv/u7vXHDH4vwWwzBISEhwWbsC/EPEl5eXe/1z4vzW4uIi3nzzTWg0GuEh0J0GKKWdIOKl7iNCAzx69CgGBwfBsiza2tqEYYn0pskZ2J8FIl6j0UjSAMX5LZqmodVqsbS0pOiknoATGIZRtLbW29uLiIgI/MM//AMGBgaEz0ic32IYxuWB1t9hU44jFRAQIBxezM3N4cc//jEoisLNmzdx+/Ztl/4tT+9zJz1SUu+JrDd7OpBKTU3F9PS07HVGsv7oLyJeqp6C4zhcvnzZ5UBKrVYrBnKQjQI5GSkiiqIwODiIsLAw/MM//IOQ32ppaRHqKYhzK/674++wqRQR/0nXiyHrORYBKczPh+K9976MoKBlgQaYlDQseapOSotPnZJPuCOI+KKi7Y6Ue37LYikExzG4daty879vYHo6AgkJT6HTec9vPZ5IwPcvfBGZThXa5R8QItxGIWZdhQeb3VgLWidCCjvx7/dfh3ouRHCTzOZiGAyLMBpNoGkOHFe86UgpB3Lk50v3kUnpyZNsbGwE4OWX/4D4+FHBTaqtPeniJomdGjmlxZ6uT44jFR09hePHb+HYsdu4cOEVcByN6eko/O53X0dIyLxAA/T0dfxFxLtnpIjE+a3FRZLfYlBTcwaAE2r1BpaWgmCzaWS5ov6sP245UjyQIzZ2HCdO1KKy8ib6+jLAcTTMZiNaWvj8Fg85YUH6yJQBOZplZaTE6u/vh81mw5e+9CXExsbKWpchQ8KfAxHvvi5z4cIFmEwmjI2N4Ve/+pWsdRmp0mJfElP73AcCb+syFEVBrVbDbrfDbrfLGpr8zUiR0mKVSuU1vxUdHS04JRwnv7SYiOM4xWtrIyMjsNlsePXVVxETEyN8RmIaIE3TyMzMFO4ZJUAO9+vz5UiJ81tnzpzBhx9+CLPZjJGREfz0pz8V8ls0TQtukrv8zUh5QsSL3SSS3+I4DufPn4dKpYJarYZarYbD4ZD198rbsOlJYkS8SqUS8lvV1dUe81tGo9GjI+VN/iDiJyYmsL6+ji9+8YuIiooShhtxfothGKSmpgoHCXJKiz1dny9HSnwgdfbsWXz00UewWCwYGBjAD3/4w231FFLaKSLe3ZEi683kQIoctrS3t0OtVkOlUkGv18PpdMpyi/zNSBFHSqPRSNIA3Q+kioqK/HKkyPqjEkT8J10vhqznVA4HD1LIyenCl770Hp48yQLHMWht3Y1Hj0oRGTkFvluKQ0TErPA64kjl5sofEggi3tcDa2DgKvbufYy9ex9jeDgJv/jF/wGtdt0tv8UiK+uJS35rfj0A/9x8GG9b9+DliUBMBDgwq5U/WOQsqeEAD79wB1sgdA4pKUM4ffoaurpywLIMHj4sRWMjf/KbmjqI+flQhIbO+/w+7kAOuRKXFqtUTpSUPERJycPN/BbvJpH8VkFBO2iaw8REtKLSYoDPSClFxANAf38asrKe4LXX3kVHRy44jkFDw37U10vnt4CtjJR/iHjv91Fw8BL272/E/v2NGBhIwa9//ZdQq+04f/4LuHzZd34LkC4t9iWOYyCFiOfzWz3IzOxBdfVlWK354DgG9+8fwr17vBOVkjKApSW9rPwWj4hfQ0HBHsVrawaDQXj4PXjw4DY3yX1dZmxsDA6HQ9FppD+IeIqiMDQ0hPT0dLz22muy1mUA/zJSctcfxesyfX19+N3vfgeKovD+++/LWpcBdoaId78+9/wWySbdunULt27xhxXJyclYW1uTdV9IATnkXh9BxKvVaoEGODQ0JBATTSYTDAaDcMI9MjICu92u6D6anZ2VnZEiUqvVGB0dRUpKCl577TXBTaqtrd3Wv0XyW4B/GSm5iHiS3zp27Bi6u7vxhz/8ARRF4Z133hHyWwzDCDRAKZGMlBJEvCdHSpzfWlxcdMlvXb9+HU6nE7t27YLNZpPldoiHTX8R8RqNZlt+y2w2o6WlBeHh4cJnNDQ0pBjIsbCwgN7eXp8ZKbECAgIwOTmJpKQkfOlLX9pWT5GTkwOGYZCTk+My7MkFcoglBxEvPpA6efIkOjo68Mc//hEA8PbbbyMyMlL4jLw5sc8SES9eb56dnRU+o0uXLuHq1auw2+3YvXu37AMpfxHxn3S9GLKeU/X1ZQiOlFrtQG5uF3Jzu7C6qtukATK4c+c47tw5jtTUftA0i9zcTo+OlDexLKMYET8wkAJAhb/8y19hfV0H0r8lzm/RNIfH6yH4pyYebBGxTiHGpkJ9uPzcDZxA9pIaQ4EOvFq4HWxBxPdvWZGfb8XKShDeeefLGB5OhtlcDLPZiIyM3k03qQ06nfT37+jI2xw2lfRI8Y6UVGkxn9+6jaNHb2NwMFXIJnEcA5XKDr1+EU6nkl1o5euPW47UTWg0GygqakNREZ/fIm6Sa36LRVZWt6LSYvH1hYTMIyNDPrVvdDQe5D5aWQmCuH+LpwHyjpu4t42UFv85EPEBATbQtAk0bcLCQjDee+8vMDycBJOJgcViFPVvdUKjkf47xiPitaBp+S7W8vIyOjs7JR0p8boMWQUh6zIkB6OkEHIniPiKigrZ6zKZmZl+ATnkZqSIKIrC9PQ0nE4nvvGNb2B5eRkcx+Hx48de12WUADmIyNqaL0cqMDAQe/fuxd69ezEzM4Nz5865lAzn5eWBYRiBBiglfzNSUo6Up/wWoQFqtVro9XqPTpKUdoqI1+v1Ag1QKr9FHLe0tDRFpcVEShHxFEVhcXERTqcTX/3qV4X7iOS34uPjBVcyODhYeJ2v0mIpkV675ORkr4j44OBg7N+/H/v378fExAQuXLiAkZERtLa2or29HQUFBWAYxoUG6C6p0mJf8oSI95bfunfvHnQ6HYKCghS5bEp6pIjEjpRUPYXZbBYOpEjZeVJSEsxms6zSYrGUIuJVKhVsNhucTie+/OUvY2lpSdaB1E4yUr4Q8eHh4cKB1NOnT3Hp0iU8ffoULS0tsFqtwnozqaeQkj+I+OdBL4as51QcR0s6UoGBa9izpwV79rRgdjYMJhMNjqNx6dJLUKnscDjUCA+fht2u9pnfAnhEfE9Ppt+I+NhY/uE3OZnPb3V18fmtR5v5rRmNA/EGOxYNdmQvbzlScpWwpkKwXYWKYzfx0oF7sl6j0WxgfDwODMOiouIeOI7/jD788BUXNykzcyu/xb8nWnCk5Ir0kXlzb/j81gBSUwdw5sw1PHq0FzU1Z7CyosdPfvLtTTeJ23STpAcAfzNSLCuNiDcYllFW1oSysiZMTkYLn9H5869Co7FhY0OLmJhxOByUrHVGcWmxP+uPxJHKyNjKb7Esg7q6g7h/n89vMQwLo9EMjqMVAzn8QcQHBa1iaioaxcVmHDx4H6R/ayu/ZdnMbw26/N3ZKi2ekv29SEbK24OQSqVCdnY2srOzsba2hkePHqG2thbLy8v40Y9+JGtdZqeIeHdHytu6TEBAANbX15GQkCB7XUaMiFe6thYdHS24VnLXZQB5pcVEw8PDmJqawoEDB2S/JjQ0FDMzMygoKMCBAwcEF8BisQg0QJqmXfJbAH/q7qm02JPkrD+SNdaCggIsLy/j0aNHuH37Nmw2G/71X/9VVn5LqrRYjsj6o/t9JJXfIk5gUFAQVlZWFMENdoqIJ9AJ9/zW9evXcePGDWRlZYGmaeTn5/t1aEHWH5VQ+6KiojA/P4+8vDyUlZVB3L8VFhYmHCS4r3/JBXKIJQcRL85vLSws4NGjR7h79y4A4Lvf/a6s/Ba5vmeBiBfXU5w4cUI4kCLru8HBwVhcXFRU70AQ8Uaj0S9EfE5ODiiKcqmnkDqQysnJ8WvYVIqIJ5/R0tISsrOzUVJSsu1AivxM3Q+ROM5zafHzrBdD1nOo9XV+bc1oNHt1pMLD51BRcQ+HDt3D06eJeP/9L2F+PhS3b1ehoeEAjEY+v5WYKJ3fAvxFxMdKIuLVajuycztxxxaGd5eTkLAQhJwltUADtAOY0Thhl3lIE6i24dXAeTgDYnCm9IHs69typFhERk7j6NE7OHLkDoaGUgRioslEw2BYFJyS4OCFTUfKd2mxWBzHID7+KWJj5SHiNZoNLC0ZQFEO/O3fviV0Od24cVLo36JpFgUFVpdck6/SYinJRcRHR08K+a3+/lScP/85zM+Hobb2JBob9ws0wNhYzzkwZT1SvKamoiRLi7VaG4xGM4xG82Z+qxgcR+PatTOoqTkFtXoDMTHjCAxckf29doaI57NrJ07cQGVlLfr6MsCyDMzmYrS07EV4+IzwGQUFLYtKiyMByMsiyclIiaXT6WCz8T/Tv/7rvxZWeNxpgO7rMr5Ki6W0sbHh05FyX5d58uQJLl26hPX1ddy4cQPNzc3baIBSIkOCkgdWT46Ur3UZlUqF2NhYRe6Np2HTm8SlxcnJyUhOTsapU6dcaICNjY1Cfoumaeh0OnR0dPiVkVKCiBcP49/4xjeE+8hbfgvwXVosJbvdLvRIeXKk3PNbnZ2duHaNp8PW1NSgtbV1Gw1QSjtBxLs7Uu75LVK9QGiAFEUhJiZGcdZOaUZKXFqckZGBjIwMFzeprq4O9+/fR2JiopDf0mg0fgE5lCLiQ0JChPXO1157Df39/S75LeImifNbAD9s+pORIvRHT4dJ7gdS7e3tuHmT/9157do1mM1m4TPy5o66lxbLkSdEvPhA6unTp8JhS3t7O4KCgkBRFKKjoxUPmztBxEvlt27fvo3bt28jNTUVDMMI8CG5pcXPm14MWc+hrNZ82GwBYBh5oX6KAkJC5jE/H4oDB+qQmjoIjqPx+PEePHxYiqioSdA0B5rmEB4+6/JafxDxBMjhjoh/PJGAf6w/hbZpvntkLtgOa7AdIRsUds9pkLekQdQGhdeHA9EXZEe3wY6hQAekNuaOJPXgf+67hfd/+q3NjJQSRDxxpPpdPqOUlEGkpAwK+S2OY9DUVIqGhnIEBy/A6VQhK+uJ7O9DEPEnTypDxJPS4tjYCcTGTqC09CGmpqIE0t2FC5/H5cvrm44bi4yMXigpLSZSioinKCdiYiawuBiCsrIGpKQMgeNoPHhwAPX1hxAf/3Qzv2Xehrf3VlrsSeQ+8uZI8fmtBuzf34CJiRjcu3cIJhOD8fF4vPHG/42CgjYwDIe0NM/5rZ0i4sWlxeL81tmzl2C1FoAvYK7AvXtHEBY2A4dDjdzcTgBOAP/N5/eZnp7G0NAQqqqqFK+tZWRkCOAF93UZq9Xqsi6TkpIiZKSUADmUIuJVKhWSk5OxtLSEvXv3IikpycVN8rQuA/APDc8qIyWWeF1mZGQE9fX1aGtrw/j4OL773e8K/Vve1mWeRUaKSEwDXFlZER5wSH4rKioKdrtd0c9pp4h4Al44cuQIBgcHQXqTTCYTgoODhZWiuLg4vzNSStYfNRoNsrKysLKyIvxsxDTAjIwMMAyD/Px8l/wWIA/I4S6y/ujtgTo6OhqVlZU4fvw4+vv70dDQgI6ODkxMTOBf//VfhSHZW35LqrRYjqQcKa1Wi+LiYhQXF7vkt65du4aamhrExsZiY2ND0aGAP4h4cn1JSUlCLlGKBijObxGYhtKMVG9vLxYWFmTfRwTSceXKFRiNRsTHx8s6kCLvyVNpsSeRHilP10dRFBITE5GYmCg4bk1NTcJhzA9/+ENZB1L+IuKl1h/dD6SIA3jx4kVcuXIF8fHxioEcz4teDFnPoTiOz0ilpsrPSBFHateuVkRHTyE3t9Mlv3X79nHcvr2V3yoqasPcXOimI3VF9vchQA4xIl4MtnBi+z/KC5ulwetwoiZmDZkrGmQtq5G9rMGyil8f7DJsYErrRIx+C2xhNhtlATnEWlw0+HSkNBo7CgqsKCiwYnk5CBZLEW7cOAkAePvtb4jcpHaP+S1ge2mxHBFHyr20OCpqCseP38axY3cwMLDVv8U/6M9jZUWPrKxuhRkp/xHxu3e3IC5uHEVFFiwtERogjevXT+PGjZPIynoCmuaQn2/F3Fyo7NJiIjJsZmT0elyRdFdMzAS0Whs0mnV88Yt/RHt74Wb/1p7N/BbvJrkfGHgrLfak5WW9CBG/vYQbIPkt/vBiYSEEJlMx7tw5CgD4t3/7GnJyeKpkbm6hz3UZQNnampQj5WldhmVZNDc3Izw8HAsLC8jKyvILyKEUEW+327Fnzx4kJia6rMuwLCu5LjM/P4/BwUG/MlJyEfEURSEpKQl6vR5qtRqf+9zn0N7eLmtdxltpsSeRHilviPigoCCX/BbJuADAO++8I3RLectvAc8OES92k6TyWzExMZidnUVmZqbiYVNJRgrYcqT27duH5ORklJaWCjRAk8mE8+fPQ6vVCo5bRkYGFhYWFAM5lCLiKYpCeno6rFYrVCoVzp49C6vVKtAAPeW3AO+lxZ4kBxEvzm+Nj48LeTIAeP/994X+LW/5LcC/rN3o6Og2RLw7DdBqtYJlWSG/lZSUhImJCWRkZPiVkVKCiCfrj/v27UNaWtq2QnjxgRRxnBcXF2WVFruLZVmfGSkitVqNnJwc9PX1obu7G6dOnUJHR8e29ebCwsJtB1JygBzukoOIDw8Px+HDh1FRUYGRkRGwLIvHjx8jJCREEZDjedGLIes5E8lIHTqkNCNFHKmtHIhrfiscHFcMjmNw6dJLuHq1GuHhs6AoOwoK2mR/H4KIP3myBk4ncLk/D/+jkQdbeJLaAWQsq9FrsGM0yInRIBsaImxIWVEhZ0mDwgU1ihc0cBiWUZFpRkkUv964Re3r9/i13WU2GxWtP+r1K0hP74fNFoBDh+5CrXZs5rc+hytXziI/3wqaZpGZ2evysM0PCcUeS4s9iWUJIl7akaIoJ9LSBpCWNoAzZ66iszMX9+8fwuJiKDo78/GTn/ytJA3QXVulxcoR8fHxT13Q7gbDEsrKGlFW1oiJCT6/ZTLR+OCDVxEQsIbw8BkASoEcKYozUjwi3ojCwnYBBFNdfQVWK9+/VVd3CPfvH0Zi4jBomoPRaIbBsCQ4Ur5Ki8Uym4sUIeJDQhaQl2fFjRsnUVb2ACqVAyYTjY6O8wgMvCo84Livy/ibkfLlSEmtyzx48AB2ux2dnZ345S9/KWtdxr20WK7I+qPYkfK1LkMebpVmpPxFxOfn5wu9SVLrMmlpacIDTmBgoGIgB7A1bMp9YI2IiADDMLhz5w727NkDlUoFi8UCs9ks5LcYhkF8fLzkffSsEfHu+S2LxYLGxkbYbDZ0dXXhd7/7nSQN0F3upcVKrs/dkRLTAMXdUhzHISQkRLiPlAI5doKIJy7A0tKSsJYqld/SarV+Z6SUrD/GxsaitLQUdXV1oGlauI9aWlqE/BbDMNsGAW+lxd7ka/3RPb9lMpnw8OFDrK+vo6enB++++y7c6ymk5C8inuM4F0S8rwOpiIgIRERE+A3kkJuRAlwdKTIku9dTXL16Fbm5uWAYRqCG+jNsKkHEkwOpsLAwPHz4EAzDKBo2nxe9GLKeM5lMxT5BCu7aykh5dqTCw2dx+PA9VFTcw8hIIlh2Fx492genU4Wf/vTbQv9WYuKIx/wWsIWINyQ+xTdrX8XNId+h7PQVNQKcFLpEwAsHBfTrHejXr6MoeBLfiu7DXG8a6j4+hrqPjyIlZQCDgykoK2tQnJFKSBhBTIy8jBSwtbZWVtaI4OAlHDlyB4ODW26SycSDDIxGExiGRXz8GPr70zYdqVrZ38dm06C9vRAFBe2yEPEazQYKC9vAsgzm5xdQUXEPJhPtRgPkkJ/fvs3hIo6UMkR8tE9EfEzMJCorb+H48dvo708DyzJobd0FgMIvf/k3QsbNV0ZNXFosV52d2xHxWq0NxcVmFBebsbgYDJOJJyaS/FZmZg96ejJRUqKstJjjGD8Q8Xxp8YEDDxAaOo+qqlr09v5PcFyuy7oMediIiorC4OCg3xkpb2ACsQgNsKOjAwsLCygvL4fJZJK1LuOttNiTfCHi3ddlnjx5IqymARAe3H2tywD+ZaSk1h99rctkZ2ejq6vrz56RIq8BgIqKCoSHh7u4SSS/FRMTIzglYWFhgiOlBMihdP1Rr9ejpKQE/f39WFxcRGlpKUwmk0ADzM/PF/JC7gO5Pz1SJCPlyZGiKAppaWlIS0tz6Zbq7OwEALz33nuy8luAf31kBBEvfk8Gg8GFBkjuI5LfysvLg8Viwa5du/zKSClBxJP76MiRI4iMjPSZ3zIYDLJLi8USDwlyHKmQkBDBSVpaWsKePXtgsVi21VOkpKRs+7nLAXK4yxciXupAiuM49PTwh3Iffvihx/Vmd/mz/ijlSInrKcRl5+RAqrCwEBaLBUajUTFZ1h9EPKDs0OJ50osh6zkTofaJHSlfYlkaKpV9W0ZKShQFJCWNYG0tEA8fluLAgfuYnY3A48d78fBh2WZ+i93Mb825vJaUFqsSxnHy8jewsuH55FKsnCU1FtQOPNW5rl0Fqm34j7vq8C3jQ2hVDuAYMD0dAY6j0dRUCkCF5uYSLC2FbKLFezyubgHAxEQMnj5NxKlTVz3+GXeRtbXs7G6htJinAQ4iNXUQp0/zbhKf3ypDQ8MBxMaOQaPZgFarrLS4o0NZRgrgEfFdXTkoL68X0QCjwNMAGZw//3loteub3VIc0tN7oVI5RUAO76XFYm1l7Xw7UhTlRHp6HyjKidbW3SgpacTsbATq6w+grs57fstbabE3kfVHT4j44OBFlJc3oLy8AePjMeA4Bs3Ne+F0qtDaugc2m26TBjjgdXAnQA5SWixHPCKelBbznWwqlRNZWXeRlfXfcfbsWeGX971793D37l0kJSUJxadKM1Krq6uKfumJEfHkl7e4f0tqXYaiKMVADkDZ+qNarRayKeThc3Z2Vta6DBkSnjUiXmpdhmVZwblQqVSgadprfgtwLS3eCSLePb9FqHs3b94UuqUA/mHRHyCHv4h44iYRGmBbW5uQ3yKkO3Lf+JORUrL+qNFoUFRUhIiICHR2dqKoqAgzMzNCfiszM1Nwk9wdN2+lxb6uz9v6Y0xMjEt+izwoOxwOdHR0ICgoCAzD+CyD9RcRTxwpgoh3z28Rx+3atWu4fv06srOzBQqoP0AOpYh44kidPn0aJ0+elMxviQ+kgC1HSi6QA1CGiCcHUgkJCfjJT36C3NxczMzMCOvNpBBe6kDKW2mxN3lzpMQHUgQoxHEcWlpa4HA40NPTg48//ljWgdROEPFKS4ufJ70Ysp4jjY3FYmwsHqdO+ZuR8l2USkQQ8UeP3oFWu4HV1cDN/BaN27crcft2JdLS+kDTHAoLLQgMXMPVpv1YX9fh4kosVgI9DztiBdmBpFUV2NANiONaR5J68L/KryMtxHWQi4ycwdGjH6OjIw96/TIyMvpgsRTBbC6GwbC46SZxiI9/us1x2wIpyM9I9fWlYX4+DCdO3JD87xqNHYWF7SgsbN/MbxnBsgyGh5MBOPHuu6+B79/yPTCIS4vlSmr9MTpanN/a6t9i2V0ICZlHdnb3piOlHMihHBHPU/uqqmoREGDbpAHybpJrfotFfn4HtFqb7NJisbYyUvIQ8bGxE5tOUjqWl/VISxuAxVKElhY+v8VnqVjJwwziSPmHiL/j9l/qAKwjICAADMOAYRhhXYZlWYyP80Pw+fPnZa3L8Ne3VVosV+6IeDENkKzLkGGCrMvk5OQoLi1WmpEiIuuPp0+fhk6nk6QB5uXlgaZpYV1GKZADUIaIJ+sySUlJGB0dxezsLFJSUtDc3Iympiav+S1gZxkpT45UUFAQ9u3bh3379mF6elpwSmZmZkBRFC5fviwrv0Wub6eIeCkaIMdxaGxsxIMHDxAbG4vc3Fy/M1L+IuLPnj2LoKAgIb/FcZyQ3yKru+np6VCpVLJLi8VSgogn+a309HTMzMxgcnISCQkJQn4rISFBcJPc81vkPQHPFhEfHByM8vJylJeXY3x8XMgmLSwsQKVSoba2FgzDbFtvlhJZf/QnI0XuI/f8FjmQunv3Lu7evYvk5GTk5ubuCMjhDyL+5ZdfRlBQkEs9hdVqRVBQkAAUIgdS/mSkxIh4X44UOZDKzc3Fb3/7W4yNjSEiIkKynkLKmd4JIl7Je3re9GLIeo7EcQwAJ5qa9m8+hHKIiJj1+pqt0mL5D9RbiHiTQO0LDFzFnj2PsWfP4838Ft+bdPHiS7hy9QzWo2YxPR2JQJUDozp5AxYAZC2poQKF7s1VwZigLbCFp38nx8djMDrKO1L79zcKNECWZfDwYSkaG8sREzO+6biZEBo67+JIESCHHHEcn5HKy/O9tqbXr6Ck5CGCglZw7twXQNMcBgZSceHC51z6tzIyerYNAt5Ki71fH+3RkeLzW/1IS+tHdfVVdHTwjhu/vge0tOwGQMFo9J7fAnaCiHctLeZpgI3Yv5/ktxhwHI0PPvgCAgLWUFjYhsnJaAQHKystJhkppYj4kREeEX/gQD2qqy+joyMfPA3wEO7dI/ktdjO/tezSR+attNhdW4j4drf/sgzgEYCth2ayLhMREYH3338fBQUFGBwclLUu46202Ju8OVKe1mWampoA8A/WxOXyddIvLi2WK3FGijhS7uWZ5AGnra0NQUFBMBqNmJiY+LNnpAAeEU+AHBUVFVhdXRXcJE/5LX8zUoTaJ8eRioyMxNGjRxEfH4/33nsPWVlZ6O7uFvJbYjfJ/T4iGalnuf5I1jYLCwuxvLwskO4IxOPJkycIDw/3md8C/EPESzlS4vxWf38/SLcUy7IICQlBcXExxsfH/QZyKLmP5ufn0d/fjyNHjuDo0aMuNMCamhpcv359W35LypGSIyVra7GxsThx4gTS0tLwhz/8AampqS75LXKQIAVyIKXFNE37lZGScqTEB1Lz8/PCYcutW7cAAIODg2hvb5d0k9y1E0S8uLTYvZ6C4zi0trbi0aNHiIyMRHFxMcbGxhSVFgNbiHgl99HCwgL6+/tx6NAhHD9+XNaBFCCvtNhdHMeBoihFOdnnTS+GrOdEvCNVjLi4UQQFreLOneO4c4fQAHk3KShoddvriCOVl9cp+3ttIeKlH1j5/NZdHDp0F39sLseV+gokTkQjxkHBRjlRPqNFl2EDkwFOSMAEXZSzpMFEgAOzWidez2vBf937McJ0a15f407tU6vtyM+3Ij/fipWVoE3qHo2bN0/g5k2+WyohYWTTkZK/4mWzaYUeKX8Q8a+8cgGAE4ODW24SgSyQbBLJ9MgpLXbXVkbK9wCt0WygqKgNhYXt+N73/gN0ujVotRu4fv0Ubtwg+S0W+flWSULhzhDx0vcRn9+6iePHb6GvLw0cx6CtrRDr6zoEBKzh1q3jYBhOVn6OlBYrQcS7lxYHBNhQXGxCcbEJCwvBov6taly/fgrZ2d1ITBz2C8jR1la0+dlKuZl3IB6ytq6PQ3BwML7whS8AgBC+JusyERERwoMyOYX1NyMlFxFP1mUYhsH3v/99qFQqbGxsSNIApR7On1VGisjTuszjx49ht9sRGBiI+/fve3STpK5vp4j4wMBAFxogecC5ePGi8ICTmJjoV0bKYrEoRsSbTCbo9Xq89tprcDqdkjRA8qBM4CpySovdpQQRr9frUVpaipKSEvzgBz+A3W7HwsKCkN8S0wClDguUDJtE3hwpsZskdtwaGhrgcDgQFBSEpqYmSRqglMj6oz8ZKXJ9YhrgxMTEtv6twsJCJCcn+wXk8NVHJiWz2YzAwEB89atfhcPhEPJbhAaYmJgIhmFgNBqF4YM4UkqHTbmOVGhoKA4ePIiDBw/iBz/4AdbX1zExMYH3339/Wz2F1NfaCSJeCl6hUqmQk5ODnJwc4UCKZVl8/PHHAPhMXmtrq6wDKXJ9SjNS7oh4OQdSKSkpikqLAf/XH583vRiynhP19m45UkVFbZidDYPJxLtJly59FlevnkFeXgdomkN2djfUaruLI6XRKBkSfCPiBxdC8d8bTvBgi1CAdm6gbE6LUZ0D+YtqGBc1mNE40G3g+64WNdvdmYh1CtE2FboTp3Gh+hz2xQ37vDZC7fPkSAUFrWDfvkfYt++RkN/iOAa9vZkAnLBaCxAYuIbMTO/5LQCwWvOeCSI+NXUAqakDOHPmGjo7+f6txsYyPHjA57cYhgXL0opKiwH/1h/7+1OxsBCGEyfOobjYhMnJaMGVPH+epwGS/q309D6oVE7ZpcXu2kLEe3ekKMqJjIw+ZGT0ITZ2DNevn0Z8/Cjq6w+irq4CCQkjmzRAk5CLE2tyMsovRDzHeUbEh4Qsorz8AcrLH2B8PFboKOvszAPgRG9vBsLD53zmtwDX0mJp3YF7X5aUI0XcJJJXcF+XoWkaLS0tiI2NRVxcnOzPgmX561KKiJ+bm8PLL78MhmFc1mVI+Np9XUZOabGU5CLixesyDQ0NqKmpQUREhEt5prd1GbEj9azWHyMiIoT81vDwMAgxkUA8RkZGEB8fj4SEBJ/fU1xaLFdSiHhCA/SU36JpGq2trX4DOZRS+2ZmZvCZz3wGe/bsEfJb5LpCQkJc+reArazds85IEWm1WoEqSe4jg8Eg0AAzMzOF/i2pFS5PpcXeJEbESzlSMTExqKqqQmVlpVAI3dbWhtbWVgDA5OQkJiYmZOVinhUiXkwDJI7b1atXUVNTg+zsbOE+UlJaDPiPiJ+enkZ1dTX27t0rHEhxHCesNxNiIvl8lQI5iORS+8iB1K5du4T7SKvVyj6Q8lRaLOf6pBwpbwdSDx8+FL7n7OysrAMpcWnxp1kvhqznRITaRxyp8PA5VFTcw6FD9/D0aSJYlobZXIy2tiIEBS3DaDRDr1/06khJyRcifsNB4ReWErzRetAFbJG1rMZEgAPXYtcRsIlkz1lSo2ROi5I5LUZ0/LDVo7fDtnkwmb9CAZQDP3jtVwiXmfPp60uX7UiR/NaBA/X4l3/5zwgLm8OTJ1mwWIwwGBZFbtKo5Gris0bE8zRAkt/Sw2zmnS3SwRUVNQmWpVFQ4Mnx2JK4tHgniPjo6EkcP34Lx47dRn9/quAmkfxWcTEHvX7JDyAHQcTLy0gRWSxGxMWN4i//8teb+S3eTaqpOY3r108iO7sbNM0hL88quIvujpQcEUT8sWO+HanY2HGcOFGLI0c+xne+858RHLy4mXHbjfDwGaF/KypKGkYjVVrsKj6XBWz9ffLmSHlal7lyhc9qxsTEwGq1ylqXcTqdMJlMO0LEi/Nb3tZlDAbDjjJSStYf29vbERMTg7/5m7+RxB17WpcBlD3cyUXEUxSF5ORkJCcno6qqCm+88QYCAwPR2tqK5uZmREdHCw+tnrJq/iDiiSMl9Z485bc+/PBDAEBcXByePHmCzMxMn5+9OCPl7/qjr/xWXFwcaJqGXq/3a9i0Wq3YvXu3ovXHjo4OREZG4u/+7u8wNTW1zU0ijhvJbwHySovdRTJSvhwpiqKQkZGBjIwMnD59Gt/73veg0WjQ1NSExsZGIb9F/r5JiWXZZ4qIDwkJEfJbY2NjgttOKI7x8fEYGBiQld8C/MtIiRHxntab3Q+kDAbDjoAcStYfu7u7ERYWhn//7/+9ABRyP5BiGAZJSUnCZ+SrtFhKJCPly5ESH0gtLy/jzTffhEqlQl1dHerq6ratN0uJDJtK1h+fR70Ysp4Dra/z1D4pR4qigMTEESQmjuDkyet48iQbHEfj8eM9sNs1UKns6OtLQ1jYHMLDZ31+L2+I+McTCfjH+lNom3Y9JSeOVH0EPxisq4COYDs6gu0I2aCQvcQPXIenA3Bgxon+IDsCU4aRPRWJ5Ox+2QMWIF5/VEbt29gIwGc+cxnJyYPo6uLdpKamUjQ0lCM2dgw0zaG42CSQ3xYXg/HkSRYOHvRcWix9ffIQ8Xr9MkpLH6K09CEuXfoMmpv3wmbT4sKFz+Py5XXBTcrI6JUcUrYQ8coyUp4Q8TwNsB/p6f04c+YKOjvzwHE0Hjw4AKdTBZXKjtHReMTGTsga6ggiXtn6o6sjxee3GrB/fwMmJmIEN+ncua38VnExJ2SklAA5ttYf3TNSntXdnQObLQBnz15GSsoArNZ8cByD+/crcO/eESQlDYH0b+n1PGRGTmmxVC6L4zhZjhRZlzlw4AAuX76M5uZmLC0tyV6XedaIePd1GdJPRNZlVCoVZmdnsbKyIsuFIBkpJQ+sMzMzGBgYEIAc7jRA8oDT1tYGvV4vfEYsy/oN5FCyttbb24v19XW8+uqrQr6FZEpu3bqF9PR04QGHfL5ySoulRNYffTlSJL915MgRXLp0CY8fP8bs7Cx+//vfIzg42MVNkrqPpEqLfUmMiHe/Fzzlt27c4AFEKpUKKysrWF9f95nfAraGBCUPrO6I+OjoaBcaoFR+i6ZpwZFSAuQgw6YSat/g4CDW1tbw8ssvIyUlBWazGSzLCvkt4ibl5eUJjhsBcngrLZaSXER8XFwcTpw4gcrKSly6dAktLS2YmprCb37zG4SHhwtukqcBSqq02Je8OVJiN8n9QIqiKKhUKjgcDmxsbMj6PPxZfxQ7UiqVStJNEh9IkcMWJaXFRATIoWT9cXR0FGtra/jCF76ApKQk4bCF1FNIHUjJKS3+tOjFkPUcyGot2HSkvD+wqtUO5OZ2Ije3E5OTkfjRj/4BwcELbvktFkVFbQgM3J7fAqQR8fPrAfjn5sN427oHTomQVc6SGg448URv3/bfFjROtIRtoCV0AzHrFOg1J3JXVLB3pGEFgMMxipGRRCQkeO/fAsQZKYvCjBS//piW1g+KcqKgwIqCAusmDZB3k2prT6C2ls9v0TSLhYVgxRmpLUS8Mmpfd3c2srO78ZWvvIOBga3+LY5jEBIyLxATxXkjlqW9lhZLiSDifd1HWu0GioosKCqyYHw8Bm+99W0EBS0L/Vs8DZBDfr7VY5+XVGmxL21l7bY7UjExE6iquonKylvo60sHx9FoaytEa+tuAEBc3DgmJqIREzPp8/u4IuKVrT+S0mKVygmaNoGm+fyWycQXeV+9Wo2amlPIyekCTXOYmwuROWzeARmypqamZGekxOrp6UFGRgZef/11yfJM8stbvI5EMlJ/DkS8TqfD7t27sXv3boyNjeGnP/0pAgICcOXKFdTU1PhclyHX96wQ8WIaoKd1mbi4ONnrMuKMlL+IeLVa7ZLfIg84H330kcsDztzcnGIgB8lIKVl/BID+/n6kpaXh9ddf35bfio2NFZwSsfPpb4+UHEQ8yW+VlpZieHgYv/zlL6HRaPDhhx/iypUrPvNb5PqeFSLePb9F+rcePHiA+vp6APxK5uLioqz8FgEp5OTkKFp/FDtSGo1GyG+Nj48LbtK5c+eg0+lQUFAAhmEwMzOjuI/MH0Q8RVEYHh5GcnIyvva1r23LbyUlJQnERPFgJHak5Kq3t1eWIyU+kBoaGsJvfvMbqFQqnDt3TrKeQkoEyEFKi+XIE7XP04EUoQECQFFRkewDqWeBiNdqtdvqKSwWi3AgZTQaQdM0pqamZJcWP+96MWQ9B+I4GuHhM0hNHZT9Gj47osLXvvY7aDR2cBz/EHjp0ku4erV6M7/Fbua3+BN2gog/c4ZfO3I6gcv9efgfDZUYW5Eua6ScQPayBoOBDqx6O2ClgNP0Y/zj3o8RrNnAv/3bVzEwkIa+vgz8/Oc5iI6eEGiAYWFzkl/Cas3H+rpO0frj4qLBoyPF0wAfoaTkEaanI4Vs0ocffg4U5UBg4DLm5sIQFTXtM78FKOuRIhKXFvM0wAGkpQ3gzBnSv0WjsXE/Hjw4iLi4UdA0i4KCdkWlxUT+IOL5LJsKX//670BRDnAc7yZ98MGrgpvE92/1CZ+vnNJid4mpfd4cKT6/1YuMjF5UV1/BO+98Gf396ejqykFnZ95mfovv3/JEkZQqLfYlb4j4kJBFHDjwAAcOPMDYWCw4joHJVIyOjnzhPlpb08HphORBgtMBOG03QQX8V6F7ClCWkSKO1JEjRzyuy3z88cf4+OOPhXWZ/Px8RaXFRP4g4gcHB+F0OvG1r31N+Bq+1mV8lRZLiaytZWRkeHWkxOsyq6urePfdd9Hf3w+r1Qqr1SprXcZfRLwnRyoiIgJHjhzB4cOHMTw8LDzgWCwWqFQq4TpIV5Ev+XMfiRHxZPguKCjA8vKy4LjV1ta6dEvl5uYqKi0WX19QUJAiRPz4+DicTidef/11OBwOoX+L5LeImyR2gH2VFktJLiJeq9XCaDTCaDRiaWkJf/zjH9Hf34/29nZYrdZtNEApSZUW+5I3Ryo2NhZVVVXbHLfW1lao1WoEBgYq/vsOKFujFZcWBwQEuOS3iJtE8lukWyo7O9vvjJQSRDxFUZienobD4cDXvvY1bGxsyDqQIqXFFRUVzxwRLz6QmpubwwcffICBgQFYLBZYrVZZB1LPEhEvPpA6deoUuru7hXxbU1MTAgICEBoaqgjI8bzqxZD1CdfCQshmRuqe4rW1pKQhwZE6fPgeKiruYWQkERzHwGw2oq2tCHr9EoqKzGAYDhZLoVBa7AK28KKENRUMdgoN4dtdLKK88An884EaAWxhs2kxMpIEhmFx4sT1TeoejVu3qnDrVhXS03s3iYlt0IlIgxxHC46UXJnNntcfxYqMnMbRo3dw5MgdcFwxLlx4FRsbWvz+919DcPCCyE2Szm9JlRbL0VZGynX9kc9vtaGwsA1LS3pYLEZwHI0bN05tZrgohIQsYH1dK8uNESPild1Hroj4yspbOH78Nvr70wRiYmvrboSGzgkZN5OpWPGwOTBAEPG3ZL+Gopx4+jQRNM2hqqoWJhPfv1VTc0agAdI0i7y8Dhfnk2UZr6XFUiLrj74G/Li4cZw4cQOVlbVgWQYfffQKbLYA/OY3f4Xw8BmQ/q2I4GksNAKzH1JYmwIo3AFUQQhmXgG7sQeZmZmKMlIcx0Gr1W5zpKTWZViWxZUrV3Dt2jU4HA5ERETIXpfZKSKeAB4SExOF/i1P6zL+DAkkI6UEEa/VajE+Pg6j0YjKykpZ6zLkPckBcoglh9onzm+dPn0ara2tuHTpEtbW1vCLX/xCVn7rWSPi9Xo9SkpKUFJSgqmpKcEpuXDhAtRqNex2O2JiYuBwOGTdF+LSYiXrjyzLCtQ+iqKQlpaG6upqwU1qaGhAfX29kN8qLi72a0jwBxFPercKCgpw7Ngx4T4S0wBJfkv8kC4XyCGWt4wUkUqlEvJb1dXVaGlpwdWrV2G32/HWW28hMTFRcJM8OR/+IuLJ2pq7I0XqKQ4cOICxsTEh49bR0YGAgACsr68jMTFR9kECyUj5i4hPS0sDRVEeD6RSUlIEWA5xpJQOm0oR8SEhIZiZmUFOTg6OHj0q/F0jB1LETRIfSJH39OdAxKvVauTl5SEvLw+rq6t4/Pgxbty4gdLSUkXD5vOqF0PWJ1wkI6XEvXF3pIgoCkhKGkFS0ghOnqxBd3c2OI7B48d78fBhGVQqOyIipvFr0z78a+deF7CFJ+UsqbFO8TkrdwWqbfiPu+rwLeNDaEVOEHGkaJpFUNAq9u5txt69zZiZITRAGh999DKuXKlGfr4VNM0PN/5lpGgkJg7LWiMjn9HERBwoyoF/+IcfYGQkCRxHo6mpDA0NBzbzW+xmfmuLSuertFhKroh4z4OSwbCM0tImlJY2YXIyCn/4w1cwMxOB+/cr0NhYJnKTpPNbwBaQQ9n6ozQins9v9SE9vQ/V1VfQ0ZEHjmNQX38AdXWHoFJtIDJyyuf6p1ikR0pJRmqrtJhDcPAiyssbUF7egPHxGMFNOnfui9DpVlFQ0AaG4RAdPe4XkIPjaEWIeJXKidnZCABOfPvbP8LwcAo4jsa9exW4e/cIoteHkDvGgbltRmrvMiinExu6NVj7GjF3pAB7UA/nxmugNL733cXUPm/5FPG6zOjoKP74xz9idnYWd+/eRVNTk6x1GffSYjny5Eip1WphXWZ1dVV4wCHrMhqNBlFRUbIyN0RiIIdciR0p9/yWp3WZiIgI2aXFYilFxKvVaiwt8Yc23/rWtzA0NOQzvwX4Li2WkriPzJsjFRUVhWPHjuHo0aMYHBzEhQsXMDMzg48//hjNzc0u/VuetBNEvLsjpdFoBBrg0tISLBYLWJbFjRs3UFtbK9xHSlaodoqIj4mJcclvEcettbUVoaGhwmcUFhYmu7RYLKWIeK1Wi/V1PjP9V3/1V8J9dO3aNYEGyDCMsDJG5Ku0WEpiRLw3RyouLg4nT55EVVUVent7cenSJayvr+P27dtoaWkRDhK8OUDPEhHvfiBFhmRCA9RoNIiMjFSc2VSakRI7UiS/deLECWG9uaWlBQ8fPkRUVJRwHxkMBsGRUjpsKkHEBwYGCp/Zi1VBXi+GrE+4OI5GUtKQR3KZ9GsYwZHyJLXagby8TuTldWJ1NRB37hxGY+MBTE3FANeOo1JnR5cbDdBdmk2K4BO9HXa3P3MkqQf/q/w60kK2r/6xLMlIuSLiIyJmcOTIxzh8+GMMDyeDZWlYLEaYzcUICFiD06lCfPyIx7Urd42P8xmp06ev+v7DmxIj4sPC5hEWNo+CgvbN/BbvJtXWnkRtLemW4lBQ0A4lpcVEHR0EES9/gA4KWsXMTATKy+uRm9sluElbNEDeTXLPQrEsoxgR795HJiWtdgNGowVGowWLiwbcvXsYDx+WYWoqBt/97n/azG+xyM/v8DhIkh4p5Yh4RhIRHxs7gaqqWhw/fnMzv8VsOm57EBi4AodDjZQU+W7oFpBDfsea0wlh/TEqagZRUbyLNdUbgvofFGPATqM+pRoNXz2FnK4u0CyL3M5O9BqM0K6vI+X+uxgLmEXcP7zj87RQbkaKiKIohIWFYW5uDqWlpcjOzpa1LgNsATn8yUh5u77AwECXdZl79+6hubkZU1NTeOONN5CbmwuGYba5SWJJlRbLvT53R8rXuozBYIDdbkdGRobs70OAHEoR8SzLIi0tDfHx8YiPj8e+ffsk81v5+fmgaRpZWVl+ATkIIl7JfRQbG4v5+Xns3bsXmZmZENMASX6LpmmEhLium3Oc59JiT5KD9jYYDEJ+a3JyEnV1dWhtbRXuIykaoLueJSJenN8SO2719fWoq6tDWFgYNjY2FLlY/mSkxIh48n/l5eUYHx8X3KSuri7odDrBcUtLSxMyUkqGBKWIeJVKhZSUFGFlMjMzEyzL4t69ey40wKKiom1DGwFyPGtEfGhoKA4dOoSDBw9idHQUDx48gMlkwtraGr773e9uq6eQklRpsRyxLLvNkXJfb3Y/kIqKioLNZkN+fr7s7/OsEfGfVr0Ysj7BGhuLk3SkvImUFmdndwuEM19aVzlQP5CNDcqJD+PXkLmsRjahAU470a/n8euDgQ44RX8X01bU0DopdBm2XKyYoEX8U+ktvJTRLjkIEUT8wYPSiHiAH6CSk4eQnDyE06dr0NWVgwsXXgbgxJ/+9BeIjp4Aw7AoLuYQFjbv8X2RIcHbsOkuT4h4Pr/1ECUlDzE1RfJbDC5c+BwuXz4Lu12N9PReqNWe1ya3Xx+tOCNFSosZhkVs7ATS0vpRXX0VHR254DgGDQ37UV+/ld8qLjZhdTUQT58myiotJiLDphJEfHDwEjY2tNBq1/HNb/4K7e38GugHH3xBlN9ikZ7e7/KzFztSciUHEa9SOZGZ2YvMzF5UV19GR0c+Ll8+C8CJ9977ChIThwUaoKf8FuAfIn5wMFWytHjt3UUcvFmPz3L1GIuLA0vTMNE0OvLzEbiyAptWi7S+PqRemsWA4TKWj9+EoajK6/fiOL60WElGijhSu3btQnx8vKx1mZWVFcVADnFGSu76Y1hYGCiKglqtxuuvv4729naX/JandRl/M1K+EPHu6zIWi0Wg3L377ruy8luAfxkpsv548OBBl//dU37LbDbDYDBgdXUVaWlpfgM55Io4Urt370ZSUpJAAxTnt8T9WyTfJbe0mEhuRkqs6OhoBAQEQKVS4bXXXkN7e/s2GiDDMIiNjXV5nVwgh1hk/dGbIyXOby0uLsJsNuP2bf7fh3fffVdWfgvwLyPlCREfGxsr0ABJ/5bZbEZLSwvCwsKwvLyMtLQ0xcOmP4h4m82GPXv2CH124vwWWW8m+S2CHpdbWux+fcnJybIQ8aSeIjg4GBRF4fOf/zw6Ojq21VNIHUh5Ky32JLL+6M2REh9Izc7OwmQy4d69ewCA999/3+N6s7v8WX+Ui4j/NOnFkPUJFg9SsCM7u0v2a0hp8enTvh+oCdjif9ZX4uRoDHr1dsxpXWmAOUsaZC6rkbWswYqKJwh2GTYwGeBE7pIaC2oHRnX8KuDX8lrwj3s/RpgoR+UukpGSu/6oVtsRGTmNtbUgHD9ei6CgFXAcg5s3q3DzZiXS0/tA0ywKC9td8lu+Sos9iWUZn4j4qKhpHDt2B0eP3sHgYCpu3z6Kvr5M9PRk43vf+0+i/i3Pq2VSpcVyRKh9YkdKo9lAUVEbior4/JbZzGeTCA0wLGwWgGNb7sub/EXEk/XHxMRRJCaO4vjxW+jrSwPp39rKb/HdUjExEx4dKW+yWJQh4gMCbEhIGMHaWiAOH76NwMB1cByNa9fOuNAAc3Nd81ska8cDObaXFnsSy/KI+IKCLWfTNgUsdwLxbfz/Hzc2hpM3bqCqtha9GRm4e/gwBtLT0ZOdjR/+/f+J3CEOqx/+CAVehiySkSorK1OckXJHxIvXZebm5oQHHLIuQx5ulbgjQ0NDfiHizWYzCgoKBBdAigYoXpeJiIjwKyOlFBEfGBiIzMxMrK2toby8HIGBgUJ+S9y/RciBROLSYiUZKUJ/9PSZu+e3urq6UFdXh6GhIfT09OCtt94Sskne1px2goh3d6Sk8lscx+HChQu4fPmy8DCqxB3xJyNFHKn8/HxhLVXcv0XyW/Hx8cJnFBwc/GfLSIkVHByMgoIC1NTUYN++fdDpdC79W57yW75Kiz3JFyJepVIhMzMTmZmZqK6uhtVqRUNDA+bm5tDb24uf//znPvNbgHRpsRxJOVLi/BbpliL5rcDAQGFIUnJosRNEfG5urjAk+zqQCgoKEjJScoEcwFZGSu59FB4ejl27duHWrVvYtWsXAgIChHoKciDFMAwSExO3DaL+OFL+rD8+73oxZH1C5XBQYFkGTqcaP/7x32/SALlNGqBnt4SUFufmdnr9+mKwRfbSdkcKFDChc2JCZ8ODCBtSVlTIWdIgf1EN46IGcxoHQjYotAVvIC/CFWzhTSQjFR0tLyMFbFH79uxpgcGwhH37mjE9TfJbPFzgypWzm/ktFllZPejvT5NdWkxks/F9ZHIR8RQFpKYOQKOxIyRkDqdP14CnAZbhwQM+v8U7bqZtD+jeSos9aWIi2ici3mBYRllZE8rKmjA5GQ2WpVFXdwiACj/5yd8K/Vvp6X1eM0n+IOI7O/O2Uft4GmAfMjLE+S0a9fUHUVdXgbi4UYyPx2Lv3kd+ZqSUIOL5+2jfvmaEhCyivPwBxsdjhf6tzs486HSrguOWljagqLSYyBURv1UqvdAEhPQBKrdbS+V0IqunBw9LS2FYWEBVbS1MNI2HRRVosqmQ9POfgdm1W3Jdxp+MlBxEfFhYmMu6DMuyaGpqAgD8/Oc/l7UuA/ifkXJff3Rfl3HHHScnJ2N4eBh79+71C8jhz/pjWVkZwsLCUFFRgeHhYcEFsFgsQn6LYRgkJCTILi0WS9wjJYfap1arkZ+fD5PJhKCgIBw9ehRmsxk3b97EzZs3kZ6eDoZhJGmSZNj0BxHvzZFyz2+xLIuWlhYAwG9+8xuX/i1v8qdHSsqR0mq1Lvkt0r91/fp13LhxA+np6ejv7/c7I6UEEU/W1g4cOICIiAgXN8k9v8UwDGJiYmSXFotF1tbkrj8SGmBXV5cAkTGbzbh27dq2/i33QUrpsAl4zkiJRVZlSX6LDO4A8M477wifka/B0xOQw5ukEPG+DqSys7PR3d2tuLSYZKSUIuIB4NChQ4iKivJ4IEVWd8PDwwUghxJHyl9E/POuF0PWJ1S9vZlYXg5GZeUNLCyEwGwuRltbEYKClmE0msEwLBITh11W8khpcXHx9tJiog0HhV9YSvBG60EBbJHj5ki5y0kBA3oHBvTrCNjMYe2a00AFCsZFLVLnHFANx2I1bBKBgZ5drPHxWIyOJuD0aaXrj/Q2RyoycgZHj36MI0c+xtBQMki3lNlcDINhEXr9MrTaNeTmyndvdoqIJzTA5WU9zOaiTTfppEv/VkGBFQEB65BbWizW1vqjvLW16OhJZGX14P79w6iouIPFxVC0tRWK8lu8m0TIgUSktNgXkMNdhNrnaf1Rq7XBaDTDaDRjcdEAs7kYDx6Uw+lUobl5H+bmwkHTHPLyrF6HXJKRUo6IZ7Yh4mNjx3HiRC0qK2+iry8DHEfDbDaipWUPwsJmERi4Ao1GGZBjCxHveh/ZJyhoJ6QHyWW9Hl05OShrbMQulsUulsVCSAjufHMfBiNfFtZlxChfjUazo4yUnBNgsi5js9nQ2NiI/fv3Y3FxUZIG6L7G5a202Nf1eXOkAgMDsWfPHuzZs0dYl2lsbITT6URLS4vwYO1rXWYniHhxabHYTZLKb0VHR0On0ykGKXR3dytefxQ7UiSbND09LTyUfvjhh7h8+bJLfkulUglADiUZKSVraxRFITU1FWq1Go8fP8aePXuwtLQk5LfENED3/JbSYVN8fd4Q8QaDAWVlZSgrK8Pk5KSQSSQPk2To9JbfAnaGiBeXFlMU5UIDJN1SJL+VkJAgrD8qHTaVZKQAV0T8wYMHcfDgQYyNjQluUmdnp5DfYhgGqampQv2EnNJiseRkpIhUKhWysrJgMBjAcRwYhsHCwgLu3r3rM78l7iN7loh4qQOp1tZW2O12tLe3Q6PRbKunkNJOMlJiRLynA6nbt2/j9u3bSE1NhVarBUVRfgM5XmhLL4asT6g4joZOt4r9+xuh0Wzg5MnrePIkGxxH4/HjPXj4sBRRUZObSGgO4eGzQmmxpxWqxxMJ+Mf6U2ib3jo11G8AiasqtIZuQKJneJvWVUBHsB2lq3ZE6BfBGE3gOAYXL77s0r+VlfVE6N8iYlnaJ5DDXX196VhYCPX4QE1RQErKEFJShnD69DV0deWgpWXXZk8YhV/84lsg/VuhoZ7zW8CzQ8Tr9csoLX2I0tKHmJqKAiEmXrjweVy+vI6MjF6/MlIcR29mpJSsP/KOVEVFHbRaG86cuYLOTt5NevDgAOrrDyE+/ilIt1Rw8KJQWqwsI8WvP5aX18typIKDl7B/fwNMpmIEBKwjL88Kk4nGuXPe81uA8mETECPipdcf+fxWDzIze1BdfRlWaz5Ydhd6ejIBUPjtb78JmmY381ves47i0mIXBQBOD89q5qIiONRq0OzWfRSysIDC+Sac/urbmFrXCA84VqsVgYGByMrKwtDQECorK2V/DuThzh9EvEajwdGjR6HT6STLM93XZZQCOYCtjFRJSYksRyo8PBwVFRXo7OyEVqsVOpvkrssAytaNhoaGvDpS4vzWysqKkAEaHOQ7Dt99911JGqCU/MlISa0/RkZG4ujRozhy5AiGhoa25bdycnIwMDDgV0ZKKSKe4/jS4hMnTiAwMBDLy8uCm0RogBkZGWAYRqBl7iQjJRcRHx0djcrKSgwMDGBmZgbZ2dku+S1ykOCe3yLvCVCOiPfmSGm1WhQXF6O4uFjIb7Esi/5+/nfT+fPnBTfJW36LXN+zWH+Mi4vzmt/Ky8vzG8ghNyNFRBypkydPQq/XC/UU4vyW+4FUT0+PrNJisUhGSo4jRQ6kEhISMD4+jvHxcaSnp8s6kAL8y0j5QsS7H0iRw5apqSlQFIUrV67IOpACXEuLX2hLL4asT6DW1wO2OVJqtQO5uZ3Ize3E6qoObW2F4DgGt28fx+3bx5Ga2o+VlSCEhs5uKy2eXw/APzcfxtvWPXC6TVJZy7wj1W2QB2yICVrEf8lpRsel09h/5DZKS5tw+PBdDA8ngfRvWSxG6PVLQrdUQsKIS4+Ur4dUscj6o7eMFJFabUd+vhU2mxadnfnYv78ew8PJuHnzBG7eJG4Sh4KCNuh06y6vXVwM3nSkPAM5pMSyxJGSXn+MiprCsWO3cfToHQwMpIDjGLAs/4urvv4gFhZCNvu3vKPBCSK+qkopIr7IxZHSajdQVGRBUZEFS0uGzfwWjevXT+PGjZPIynqChYVghIQoA3L4s/4oLi0uL3+Aysrt+a2wsFkh4xYTMym7tNhdW4h43+uPAQE20LQJarUdPT1Z2LPnEYaHk3HtWrVb/1bnNsfYW2mxLt2J+VwKMG2/vziGQezYGOLHtu6DtTAAWi00oXGI12iFdRnSLWWxWAAAjx49wsbGhmT42l2Dg4OYnZ3F0aNHfX4ORFKOlHt5pvu6TG5uLubn56HX6/0CcihZN5qenhaGzUOHDslal5FypOTIV0ZKrKCgIOzduxcGgwHvvfceiouLMTw8LNAA8/LywDCM4CaJ5a202Nf1eULEUxQlkOVIfotQJclrVSoVaJr2OYD7i4h3d6T0er3guE1NTQmku/Pnzwu9b3Nzc4pLi/1FxA8MDAgD6ZkzZ7bRAN3zW/4AOYCtYVOOIxUcHIz9+/cjKioK77zzDvLz8zEyMoJz585Bp9OhoKAADMMInU9iEUfqWSLipfJbHMcJ68Tt7e3Cuqwvx0hcWixX4vVH8vVJPQVxk9wPpIqKijAzM6N4SCBADiX30cLCAvr6+lBRUYFjx45JHkgRuEdhYaGwwkkcKSUZKSX0R1JPkZSUhH/7t39DVlYW+vr6hHoKUuEhdSDlqbT4hV4MWZ9Itbfne3WkAgPXsGdPC/bsacHsbDg4rhitrbsxMxMJinLgT3/6wqab1I1rQzn4Hw2VGFsJkfxaOUtqjAc4MKf1PVgQsEXT3cMujhRPAxxGcvIwTp2qQVcX37/V3LwPTU37ER09geTkQSwshOLUKfkrXmT9sahIXkaKiDhSJ0/eAEU5MT1NaIA0PvzwFVy+fHYzm8QhM7MHKpVDRO2TPySMj8dgdDQBp075RsRTlBNpaQNITR1EV1c2DIYlhIXNo7FxPx48cKUBSg0PBBGvBF6xhYiXvo8MhiWUlTWirKxRyG+xLIOFhTCoVBv48MOXwTB8fsvX4OleWixHJGtHHCn3/JbVyvdv1dUdxP37FUhIGEFKyoBXR0pKO0XEnz17GSqVE2NjsSD9W1v5LQsYhkNq6gAoyum1tDh4LzARAayHAgEiU3UqKgrDycmouu6aH5yjAxFW9bcuXVkqlQrZ2dnIysrCwMAAAgICEBISIoSvybqM0WiUzF+wLCtZWuxNnZ2dXh0p8brM06dPhQec5eVlaDQaXL16Vda6DLCzjBS5Pl/rMmlpaUhOTlYM5NgpIv7ll1+GSqVyoQFaLBYYDAaBmEjKmv0ZEpQg4klOLj8/H2+++SZUKhWCgoKE/JaYBij1Xv3pkfKFiI+KisLx48dx7NgxDAwMCAcJa2tr0Gq1uHnzpqz8FvBsEPFiGqBUfisrKwspKSmKgRxKM1Li9xQUFIQvfOELoCgK/f39LvmtsLAwAQQTExMDgB82yQGMXBHYhRxHiuS3iouL8cMf/hB2ux0UReHq1atC/5an/BbgX0bKlyMlzm+RAymO42Cz2aDT6XD//n1ZB1LAVmmxUkS82JFyP5Ai13Pp0iVcvXoVubm5SE1NVVxaTNZa/Vl/1Ol0+Iu/+AtQFCWsN3s6kALklRZ/WvViyPoEiuMYhIfPbHOkpBQePovDh+9BrbajtvYkiotN6O7ORltbEeyaDVgDAbthAwhwblsHjFynEGVToS5iXfqLbyovfAts4QsRz7tJHcjP78DKSiDa2niMd2vrHgBAU1MJ1tcDUFjY5kIDlJK4tFiupBypyMhpHD16B0eO3MHQUIrQv2Uy0TAYFlFcbEJXVzYSEpQBOeT0SLmrry8NCwthOHnyBoxGM5aW9EL/FqEBkv6t/Px2BATYZJcWb78+goj3vf4YHT2Jyspb0OuXcP36GeTmdqK9vQAsu2uTBsi7SVI9W1uOlFJEvGdHSqu1objYjOJiMxYXg2Ey8cTEpqb9AJzgOBoqlQN5eR0+B/BnhYiPixvHiRM3UFlZi76+DLAsA7O5GC0texEePoPiYg4dHXkeS4tVWiD8tBNjkxSSP3KC2tym5WgalMMB2rS1/rgSDSzkaJFa9XeS1zc4OIi5uTm88sorYBhG1rrMxsYG2trafJYWu0suIp6iKKE8MyIiAteuXUNaWprsdZmdZKQ8IeI9rcvU1dUBADo6OgSXxNdJ/04R8eTru9MAOY7Do0eP0NjYiOjoaNA0DavVqqi0GPBvbW14eBizs7P47Gc/iz179kjmt0i3VGZmJlQqlezSYqnr0+v1Ph0piqKQlpYmdINduXIFCQkJsvJbgDwgh7t8OVLi/NbExITwGXV3dwPg8yqRkZHbaIBS2klGSuxISeW36urqcP/+fSQmJoKmaVgsFkWlxYCyjBTR6OgopqenUV1djZKSEoyNjQmuJMlvEVgOyW/JLS12l1xEPDmQys7OxqNHj3D58mVERUXJPpCSA+TwdH3ijJRYBJRz6NAh4UCK1FMA/Oc4NDQk60CKIOL9WX8UI+LF9RRSB1I0TcNkMikqLf406cWQ9QnT/HwIenszUFFxT9HamsnElxZ/9uUL+LmpFJcfHEbagg55i2oULWowq3Ggy8D3XS1q+K+bvaSGAzyWXUqBahv+4646fMv4EFoV/0RIEPHeCHdEQUGr2Lu3GcXFHP7lX/4zoqMnsbgYgo8+ehlXrlRv0gA5ZGU9gUq1HbrBcdKlxd4/B8+OFJ/fGkRKyqCQ3+If3EvhcKgRHLyAurqDKC72nd/yFxHvXlpsMCyjtLQJpaVNmJzk81smE43z5z8PrXYdhYVtCAmZ92PY9A8RbzLxiPi/+Iv3YbNpNmmADOrrD6Cubnt+C9hypJQMm/393jNSYgUHL6K8vAH79j3Cv/zLf0Z4+CwmJmJx7twXodOtoqCgDQzDIS1te34L8Fxa7E3EkZL6zMX5rbNnL8FqLQDH0bh/vwJOpwqhoXNoaiqF0WjedhAR+Tlg7Qkw7KQQd8MJzQoFjqaR0duLkIUFOAEspQBjlQbE/ft3oI2SPkF1d6TIusyBAweEBxyz2eyyLhMaGorV1VVF7sjy8jK6urpQWlqqiNpnNpsRGxuLr371qy64Y1/rMoCyhzsliHiyLlNeXo7vfOc7CA4OxsDAAKxWq7DeRNO05LoMuT5/EfFS74nQAPPz87GysiJ0S926dUu43tbWVln5rWe1/ugpv2UymRAcHAyj0Sj0J/kD5JCbkSKyWCyIiorCN7/5TZf+LZLfyszMBOmWIgcH/gwJShDxMTExqKysxJEjR/Cd73wHgYGB6OzshNls3kYDlJI/GSniSEn93XXPb5HDlmvX+N/RkZGRsFgssvJb/iLi3dfW4uLicPLkSRcaoMlkwuPHjxEeHo7i4mKEh4crHjbX19dhtVpB07Qial9bWxsiIiLw13/915L9W+4HUoD/w6YcR0p8IFVZWYnvfe970Gg0MJlMaGlp2VZPIaVnjYj3dCB18eJFAEBFRYWiYfPTohdD1idMJtN2kIIvkdJiY8V9VF/8Bg+20AHdOhsCHDZkLKuRs6RGyZwWJXNaPNXZ0a23I3tJg4EgB9YkfucdSerB/yq/jrSQOZf/fSsj5R0RL5bVmo+NjQCcPl2D1NR+DA8nC24SoQEajWbQNIuEhKegKHmlxVLiOEYWIl6jsaOgwIqCAiuuXDmNhw9LERo6j9raE240wPZt+S3Ac2mxN7k6Utvdl+joKRw/fhvHjvH5LZZl0NZWhLW1QFCUA11dOdDrl2Vhy/1DxMe4IOK12g0YjRYYjXx+i7hJ4vwWTXMiIIf8jNTW+qMyRLzNpsPp09eQnt6Hvr70zfxWEVpb92zmt3hiIvn5yykt9nR9chDxfH6Lh89cvXoKTU1lCAhYw9Wr1aip4fNbDMMiN5fPb1EqIOH/cmIqmUJ/FIW55VTMRkSgzHwb0zQwR1Ogoigk/O2H0OdLAy2II1VQULDNkaIoSliXOXHihLAuw7IsNjY2QFEUBgYGEBERIeshaicZKYKIF5dnelqXoWkaLMsqKi0GtoYEJeuP3d3dWF9fx+nTp5GZmbmNBii1LiOntNjT9clxpIKCgrBv3z7s27cP165dQ2NjIwAI+S13GqC7njUi3lN+q6mpCQ6HAxRFYWxsDPHx8bJ+Xv5mpMSOlMFgEPJbk5OTwn1E8luFhYUoLi4Gy7KKgRz+IOJ7enqwtraGV155BVlZWdvyWwkJCYJTEhwcDEBeabGU5CLig4ODUV5ejvLycuE+WltbE/JbpH9LKr8FeC4t9iaxI+XuCBEaYFZWFs6ePSsctty/fx9OpxMURWFubg7Ly8uy3Cx/MlLz8/Po7e0VHCmpAyn3/BbDMGBZVjGQQ0lGimhgYAArKyv44he/iMzMTI8HUkVFRcLfUyVADvfrCw8P94mIJwdSFRUVuHbtGpqaml6sCnrQiyHrEyaOY5CUNISoqGnZr3nYshtOyoH/0rMHq2q3wOImDbAj2I7gDQo5S2pkL6lRMcM/nC3YgdQVFQYDHXBSPNjin0pv4aWMdrj/G0wyUkajZ0S8p/cUFja7mVsBkpOHkJw8hNOnazbdJBqPHu1DYyOf36JpFjab1o+MlH+IeKu1EDk53fjKV95xy299zqV/KzOzV3DcCP1RDpCDyGr1npEiIvmttLQBHD78Mb7//f+A8PAZ2fkt/vqUI+LdM1JiGQxL2L+/Efv3N2JiIhocx4DjaHzwwasA+LXV3t4MWfktUlrM90gpW38kiHjeTepFZmYvqqsvo6MjHxzHd4Ldv38YiYnDoGkOa2vazYyU/EOLyckojIwk4cQJZYj4zs58ZGX14PXX/w1jY3Hb+reKiiygaRapqYOI/ooTkZ8Hzv+WhmZ0HYknrdiIphBf4URgthMU5Tmr4SsjRSRel5mdncWbb76J0NBQAXfsTgOUEkHEy8nBEBGQghS1z31dhjhuZF0mIiJC9rrMs0DEq1Qql3UZ4pS4r8usra35lZEaHByUlZEicjqd6OrqQnp6Or7+9a9jaGhIyCYRGiAhJsbHxwtfVwmQg0guIp4MsQUFBZiZmcEPfvAD6PV63Lp1C7du3RJogFJDP5E/GSlvzmZ0dLRLfotlWYEGCPAPiePj45I0QHftFBGfk5MDtVot5LcIDZDjONTU1OD69evIysoCwzBYXV1V3CPlLyL+yZMnSElJwTe/+U2BBmixWAQaIHHcxKAFf/vI5DhSAQEBYBgGDMNgcnISb731FnQ6HWpqanDjxg3k5OSApmnk5uZ6HBxYln1miHhvB1LNzc0AgJycHExPT8s6kNppRoq8b3IgReopxAdSpOx8ZWVFcUbKH0Q8yf4pLS3+NOnFkPUJ0uhoHMbH43DmzGVZf97pBC715qP+UQlGA53bBix3LWqcaAnbQEvoBk6Na5G0pkbYhgqnJnRYUTmhTRrF6/trkJvWt23AAiAg4pU8sBJH6tCh7Y4UoQHm51uxshIIi4Xvlrp1qwqAEwEBaxgcTEZIyILP/BawM0Q8AXKI81uDgzwN0GIpgsnEY7mNRhOKitpgsRT6AeRgZGekiKzWQgAqfPnL70KvX9qkATJu+S0W+flWYWBxd6TkiGSk5CDiY2ImUVl5E8eP38Lvf/9l9PZmYXQ0AW+//Y3N/BbvJnka8KRKi31py5F6sM2RCgiwobjYhOJiExYWgmE2F4PjaFy7dgaAEzrdKiYmYhARMS3r57WVtVOCiHctLY6LG8PJkzdQVVWL3t4MAZjx+PFWfquoyIKumSIU0u1I/Zy7W3oHgDS5jWSkMjIyZF9fZ2cnnE4nXnvtNej1esEFENMAyboMOWGXU1rsLqfTCZPJ5NOREq/LnDx5Eu+++y6ePHmCwcFB/PKXv5S1LrOTjJTU+mNgYCD27t2LvXv3YmZmRnjAuXjxIiiKgk6nw/z8PGJjY2W5EP5mpIgj5clNIvmtmJgYYeXSbDYrBnKwLKsYEd/T0wOn04kvf/nLCAwMFO6jCxcuuPRvkfwWsLOMlC9HSpzfqq6uxnvvvYfu7m709vbirbfe2kYDlJK/iPiOjg7s3r17271AaID79+/HxMSE4JScO3cOFEUhICAA6+vrgpPjSztZfzx79qxHGqB7fovcR/4AOeRkpMQaGhqCw+HAl7/8ZWi1WmGdsKOjA4GBgUL/VkpKivAZEUfqz4GIFx9Ira2t4Y9//COePHmCrq4udHV1yTqQkiot9iVvjhSpp3A/kGpra4NKpUJAQADUarWi+8jpdCoa8P0pLf606cWQ9QkSxzGbQ4LF558dXAjFf284AWtXLqrtanQZfA8hRBonkLCuRqfBjrpIG/arF1GlWsBEfyre/e03N90kDsXFHMLDt9YFOY6WDeQgkrv+GBS0in37mrFvXzM6O7Pxhz+8Do1mAx999IqLm5SV1SOZ33ItLVaOiHcvLaYoIDV1EKmpgzh9+io6O3M381tlaGjgH37Vajvm50MQGrrg8/uIS4uVrT/SLo5UWVkTysqaMDkZLThu58+/ioCANYGY+ORJhuIeKX8Q8RsbagwNpYKmOVRXX9nMb9Gorz+IujqeBkjTHIxGk8vg5qu0WEreqH1ihYQsorz8AcrLH6CjIwfvvvtVAMCf/vTFTRog37+VljYg+XPwHxHPbCLiXUuLVSonsrJ6kJXVg7NnL6O9PR8cx+D+/Qrcu3cEAKDTrWJ5We+W37oD4L9t+z4kI1VWVqZ4bU1cWiwuzyQPOO3t7QgKChIC6l1dXQCU9UgNDg4qpvY5nU4MDQ3BaDSiurraI+5YvC5D3pPBYPALEe/rQSgiIkJYl2lvb8cf//hHOBwOvPvuu0J+i2EYgQYo9Z78yUixLCvpSHnKbxEaIMA/3K+trckatMiw6S8inuTWjh07hqNHj2JwcFBwSsT5LYZh0NnJr5Yrefj0BxFPURRGRkZQWFiI6urqbTTAzMxMoX9LnE2SC+QQSy61LyYmBlVVVaisrITFYsG5c+dgt9vxu9/9TlZ+y+l0gmVZl9JiOfKEiCc0QJqmsbCwIHxG165dQ01NDZxOJ8LDw7GxsSFrDU1cWqx0bY04UsRR8pTfItdrtfKr5Up7pJQi4rVaLcbGxpCXl4fq6mpZB1LkPXkrLZYSWX/09p7cD6TMZjMuXLgAm80mHEi5rzdLyRuQw9trlK4/ftr0Ysj6hMjhUIFlaYSGzmNmJgJBQcuSbtKGg8IvLCV4o/UgVjYCcHRJjTXKiYGg7YOHJ6WvqKF1UugPXcM/7rsrgC1WVwNhsRRuukmVuHWrEmlpfWAYFikpA5uOlDIgB1l/jI6ekv2a/v4MqFR2fPvbP8LMTKTgJm3lt/j+rfj4p8Jn5O5IydH6Op+RMhrNXh0OjcaOwsJ2FBa2Y3k5CL/5zV9iejoSzc0laG7eJ9AA+fU3aVKjVGmxL3lzpKKjJ3H8+C0cO3Yb/f2pIN1SLLsLFOVAePgslpcNsouL/UXEE2qfVmuD0WiG0WjG4qJBcJNqak7j+vWTm91SHJKTBxWVFouvTykifng4BRTlwLe//SNMTcWA42iYzUa0tPD5LT5Lxbrcm75Ki6VEEPG+1h8DAtbBMLzLt7AQgt/97muYmorCw4dlaG7eh5ycLtA0yW/VAVgH4Lp+ZTabFWekpqamMDw8jBMnTrj87+LyTPG6DKEBqlQqREREwG6X16EH+JeREpcWu4evPa3LJCUleXSkvIllWUWIeIqiMD7O33N/+7d/K5DlSH6L0ABpmnYZpvzNSBFAgbdBSZzfmp6exh/+8AdMTU2hoaEBjx498pnfAvzLSHlCxFMUhdTUVKSmpuL06dPo7OwU8lsNDQ1Qq9UIDw9XfCigFBEvdqTENEBxfuuDDz5AQECAQEyMj49XVFosvj45GSkiiqIwMzMDAPjWt76FsbExyfxWcXExDAaD8DqxIyVXchHxISEhQn5rbGwMf/rTnzA5OYkHDx7g8ePHgptEaIBSkiot9iVPjpSn/BZZb9ZoNAgPD1e00rlTRHxoaKisA6nY2Ng/a0aKSK1WY2mJ/53+13/918I1kfVmTwdSvkqLpUTWH7Ozs13uyRdy1Ysh6xOinp4MLC8HY3XVjl/84m8QFTUpBOrDw2cBAI8nEvCP9ad4sAUAjYMfmLoNdjgUQF9yltRY163jD6/9DOmhW05VYOAq9u59jL17H2NmJhwmE9+b9NFHL0OlssPpVCEsbB52uwpqte+hbmwsFmNj8ThzRllGilD7goOXERy8jJSUIYEGyLIMHj4sRWNjOWJixgXHzZMj5U1Wq/c+MunrU2NyMhoHD97Hrl2tQjbpwoXPufRvZWT0uAwRvkqLpeQtI0VEUU6kp/cjPb0fZ85cwf37h3D37lHMzobjrbf+bpMGyKG42OQRTOE/Ip6sP/a5/O/BwUvYv78B+/c3YGIiRsgmnTv3BajVG3A6VYiO5ouF5Qzs/iLiiSMVFraAsLAFZGb2oLr6MqxW4iYdwr17JL/Fwmg0ixwp+UCOLUS8/PtIrbZjaioKZWUNm/AQfp2woyMfgYErm/1bN5CSUu3yIMJxHOLi4hRlpDiOA0VRXh0p93WZ+/fv4/79+5iZmcGbb74pa11mpxkpd0fK27pMQEAAHA4HEhISZK/LiEuL/UHER0ZGIjIyclt+i2ST0tPThbUrT46UN5H1RyUPrEFBQZiZmUFJSQmMRqNAAyT5LbJyKc5vAfKBHGKR9Udv9xF5z4WFhVheXkZdXR3q6+sxOzuL733vewIN0Ft+aycZKSlHSpzfEndLsSyLwMBA2O12RT1IZP1RaUaKIOJjY2MRGxsr0ADd81vibilPjpQ3+YOIDw8Px+zsLPbu3YvCwkIQtDjJb5GDBPdcDhk2lWSk5KzRivNb8/PzqK+vR2NjI2ZnZ/HGG2/Iym/tFBEvdqTcD6RI2Tk5kDIYDLDZbIpc9YWFBfT29irKSJHrS0pKEtwtdxqg+4FUdna2MGwqcaQIIv7UqVOyX/Np1Ish6xMijmMQGLiCv//7H6Czk8dm3759HLdvH0dSygD6Q9bwznwS1lRbfxmJI9XlAcEupRTNMpJXA1FRcd9lwHJXRMQsDh++i4qKuxgeTsI773wFa2uBuHTps7h167jgJiUkjEg6buQ9Kc9IZUg6Uq75raDN/BaNmzercPNmJSjKiZSUATgcSk5Ld4aIj4qaxrFjt3H06G0MDqaCZenNXjAGwcELQreUSuWQXVpMRDJS/LApz43SajcwPx+GgIA1fPvbP9qEQTC4fv0Ubtw4IdAA8/OtLsOUr9JiKW0h4uu9DkoxMROoqrqJyspb6OtLwx//+EWsrqrw0Uev4OOPjwqfkbfh81ki4nkaoAk0zee3TKZicByDa9eqcf06/8skJWVAscsWEjKPjAzliHiG4RAXN4b4+OuoqrqB3t5MEIz/48ePEB7eLTzgAJB0pLxJPCRIdQpJSafTYXl5GVqtFt/61reEDIevdRmxIyVXy8vLPh0p93WZJ0+e4MKFCwCA8+fP4+7du7LXZYBng4h3z2+RBxxCA3Q6nUhOTlZ8qq0UES92pBITEyVpgA0NDUJ+i6Zp2O122aXFRHIzUmLp9XrYbDao1Wr81V/9lUDfI/kt4iZlZGS4/Ox9lRZLiVD7vK0/UhSF9PR0pKen48yZM+jo6MCVK/wB4AcffID6+nqf+S3g2SLixfmt8fFxwSkhNEC73Y6kpCS/gRxyJUbEp6SkbMtv3b9/H/fu3UNiYiIYhoHRaITNZttRRkouIj40NBQURUGlUuFrX/saOjo6YDabhfwWcZPE+S2Ad6T87SPzhogHQspSAAEAAElEQVRXqVTIyclBTk6OUE9RU8M/r/zpT39CY2MjGIZxqaeQ0k4yUu6OlJgGODIyIgzJbW1twt/D5ORkxVk7nU6HvLw82a/5NOrFkPUJ0Pp6AKzWfBQXcwgOXsaePS3Ys6cFMzPh+NO9Y7BaihAyqMFX4MSA3o4uvR2DQQ7kLKkxr3ZgTCdvVfBreS2o2ljF/Z7jsuEVFMU/vK+sGHDq1BWEh8+B4xg0N+9DU9MWDZCmTQgL2xrafJUWexKh9nlzpIKCVrBv3yPs2/cI09MRuHHjBKzWQgwMpOM73/nPPvNbwLNFxPP5rQGkpg7gzJlr6Ozk+7caG8vw4MEB6PVLAByKHsJJRurECfkZKbEjFR4+75LfIm7SBx9s5bcYhkV6eh9YVjmQgyDi5Q5mFOVESMgiVlYMqKy8jrCweXAcg7q6g7h/n+S3+P4tce+YK5Dj2SLiQ0IWceDAAxw48ABjY7G4des4Ojvz0d+fge985//edJO4TSqm9D3iPyKe3lZazOe3niAr68lmfusL4LjTwroMGZKUZEcGBgYwOzuLo0ePyn6NGBEfHR3tsi4jpgGSdRmGYZCUlASWZWWVFoulFBGvVqsRHR2NlZUVHDlyBKGhoS7rMoQGWFhY6PJg6qu02JOII+Vt/TEiIgJHjhzB4cOHMTw8jI8//hjd3d3o7+/Hd7/7XcFN8pTfAp4tIl5MAyT5LZZlhfwWGZLy8/Nlfx+y/njw4EHZrxGXFpMhmeS3iONGIC4kmxQXF+d3RspTH5mUtFotkpOTsbKygoMHDyIkJMQlv5WVlQXSvyXOb/kqLfYkQu3z5mzGxsaiqqoKx48fR39/P+7fv4+enh4MDAzg+9//vnAfecpvATtHxIsdKff8FlndvXr1KmpqaoQhSYlbSxDxSjJSYkeKDMni9WayvhsRESHcR5GRkX4BOeRkpMTS6XTIzMzE6uoqSktLhfvIvZ7C/UAK4O8JpRkpX44URVFISkpCUlISTp48ie7ubtTX12NgYAADAwP40Y9+JOtASqq0+IWk9eLT+QSovZ1Q+7ZC/YMLofjvjypxcyobiLMhen0DOUsaZC2rkbmswarKCZ0D6DD4drHywifwzwdqsC9uGG+99W3FiHhC7aNpvlw1P78DKyuBm64NjVu3qnDrVhXS03tB0xwKC9swNJQku7SYaCsjZZJN7YuMnIHNFoDQ0Fm8+uo5cJxr/xZxSuLjR10cN5KR8g8R79mR0mg2RPktPcxmI65fPwlAhZ/+9G9F/VtWj/ktYHtpsRx5QsRHR0+isvIWjh+/jf7+NLAsjfZ2Pr8VHDyPxcUQ7N79WPGwyWeklCPid+3iEBy8iOLirfwWyzKoqTmD69dPbea3WOTldWB4OAlzc+GorJSfkfIHEc/3YVEIDp7Hyy9fgMnEwGwuRkvLFg2Qdy9ds4UWi+fSYk+anIzC8HCy1441Pr91AQzza8zPr8JkMgkltT/96U+Rk5MDhmFcyjOlxHGcS2mxHEkh4sXrMsRNEq/LREREYHZ2FgzD+AXkULr+CAB79uxBaGioZHnmlStXXNZlRkZGFAM5yPqjXGofRVFITk6GVquFXq/HZz7zGZhMJoEG6Cm/BXgvLfYkkpHytv7ont9iWRb3798HAPzsZz8T3CQxDVBK/iLi3R0pcX7rzJkzQn6rsbERDx48QExMDCYnJ8EwjOIhwV9E/L59+xAeHo6ysjIhcyfOb5FuqfT0dIyMjMguLSYi649yqX0qlQoZGRl4/PgxAgMDcfr0aZjN5m00QKPRuC0r409GSg4iPiQkBAcOHHDpliJdbr/61a9k5bcA/0AKUo6U+3qze34rMTERo6OjfmWkIiIiFK2PEmeztLQUUVFRsg6kCJDDn4yUXES8Wq1GXl4e2traMDo6iqqqKlgsFp8HUoD30uIXctWLIesTIELtS0kZ2Aa2AABQwKTOiUmdDQ0RNqSsqrBvVotAhwr5SxrEr6nQZbCj22DHombrQTlQbcN/3FUngC2UIuKBLWpfTk6XiyMVFLSKvXubsXdvM2ZmIkBIdx999DKuXKmGwbAIjWYdOTldsr8XyUgpGXzEiPgtGuC1zf4tBk1NpWhoIPkt3nELDZ0Hy8orLRZrKyMlb21Nr19GTMwE7HYNTp68itVV/WZ+6/O4fHl9M7/FIiOj18UF8VVa7Em+EPF8fqsP6el9Ag3w7t0jWFwMRUvLXjx9mii4Sd5co4mJ6B0i4re+tji/NT4eI2STzp3jaYDkPlIybO4UEZ+d3YPs7B6cPXsJVmsBOI4WaIBJSUObxET+wIFl5ZUWi8VxZP3RF/1xGcAjhIYeQHJyMhwOB44dO4aVlRVZ6zLijJSn/Iv09XlHxLuvy7S1taGurg5OpxOtra2Ynp4Wfnl7e6j0FxEv5Ui5r8sQp4SsyxgMBoHQJ1f+rD+KHSl3N8lTfkun0/3ZMlJiRUZGIicnB3fv3sXBgweFXJk7DTAuLs7l57HTjJSn9Uf3/JbZbMaDBw8Eot78/LzP/BbwbBHxMTExqKysFNwk0r/V2tqK0NBQGAwGxSAFfxHxxJEi2aTFxUXBTSI0wOzsbDAMg9zcXAGFrgTIAShfo42Li0NxcTEePHiA0tJSrK6uCvmt8PBwwU1yd2i8lRb7uj5vjpROp8OuXbuwa9cuzM/Pw2QyobGxUfh+a2trgpvkbeByLy2WIylEvK8DqcjISBgMBlAUpTgjtRNEfElJCUpKSrYdSInzW1lZWVCr1YqBHJ9mvRiy/jfX/HwIenoycfjwx2iZdAVbSMlJAQNBDuybBca1DlhDNpCzpEbJnBYlc1o81dnRZbAjMesJ/p+Ka0gLESPY5SPiiXp7M7G4GAKa9jz4RETM4MiRj3H48McYHk5GS8suPH68FwCFN9/8P2E0mkHTLBISnsLbv13i0mK5kqL2aTR2FBRYUVBgxfJykNC/dfPmCdy8WYWkpCGMjcWjqko+idAVES8vI8W/J379cd++Zmi1Gzh69A4GBrb6t0ieh2Tc4uLGBEdKSR+ZUkS8VrsBo9GC+vqDiI0dxe7dLZv5rdO4cePkZn6LRX5+xzYYBumRUoKI7+9P8+lIxcZOoKqqFseP30RfXzpaW3fBZKIBUPjxj/9ecJN8Dcbi0mK5kkLE8/ktHj6zsBACk4nvKLt6tRo1NaeQmtqPkZEkHD8uf6WTDJs8It43+p/0ZRFHav/+/QgICJAsz3Rfl+ns7BQeMORKKSJep9Nh9+7dePz4MaKiosAwDEwmk8u6DMMwyM7O3uZMKB0SgK2M1JEjRyT/u3hd5tSpU+ju7gbLskLZ8S9+8QtZ6zLk+pRmpIgjJT4BFrtJUvmtzMxMDA4O+gVS8BcRX1FRAZ1OJ5nfio2NFbJJoaGhfvWRkR4puYh4vV6P0tJStLW1AeDvCZPJ5DO/BfiXtfOFiBfnt6qrq9HR0QGWZdHd3Q0AePvttwU3yVt+i1yf0oyUlCMVHBws0ADHx8eF/q2uri7odDpkZ2ejr6/Pr4yUUkQ8WX88evQogoKCcPbsWVitVsEpvXfvHpKSkoTPSK/X+wXkIC6VXER8aGgoDh48KPycSPeX1WoVDqQYhhHQ8WIRR0ppRsobIl7qQIrjOPT19QEA3nvvPVkHUsCzQ8R7OpCyWCzQ6/XIzc3FkydPUFFRoQjI8WnViyHrf3ORh8haezDevvQ1OOH7po5cpxBlU+F+xDo6gu3oCLYjeINC9pIa+csUDk8HQDOfjYfLJ7BGc8jK6gZF8Z1V7o6UL21lpDp9/lmKApKThzA9HYnHj/fh+PFaPH2aiEeP9qGxkc9vMQyL4mIOYWHzLq/1Vlrs6/q8IeL1+hWUlDxCSckjTE9HguNoNDSUAQDu3DmOsbEE0DSHzEzP+S3AP0T8liO1VVpMUU6kpQ0gLW0AZ86Q/i0ajY378eDBQcTFjWJjQ42QkDmkpSnJSO0EEX8V+/c3Yv/+RkxMRIMQEz/44AsICFjb7JbihKGF4+SVFovFsrTPjBSRSuVEZmYvlpf1MJkYHDp0F6OjCairO4T79wkNkHeT3AfepSUDurpynjkiPiRkQZTfigPL0mhu3gcAqKurwOxsJGia3cxvef4+AwOpLqXFvnUHGxv/722OlK91meTkZKyvrysuLSaIeCUPQmJH6uDBgwINkISvybqM0WgU8OsAZJUWu4tlWdnrj2RdxuFwoL29HWVlZXj69KmsdRlvpcXexHGcV0S8e36LZVm0trYCAJqamgS6oDsN0F3PChEvzm8tLy8LjlttbS1qa2uRmZmJlZUVBAUF+TVsKrmPxI7U4cOHcezYMQwMDID0b3Ech5CQEBfHzR8gByAvI0Wk1WphNBoREBCA7u5u7N69G6OjowIN0FN+C/BeWuxNvhyp2NhYnDhxApWVlejr6xP+rgHA48ePhUHfnQbormeFiPeV38rJycHy8jJ0Ot2Oh01fmp+fF4bNo0eP4uTJk5IHUuR6IyMj/QJyAMoQ8eRAKjQ0FH19fTAajRgdHZWkAbrfK95Ki73JmyMldSBFDoAAZcPmp1kvhqz/jeVwAPcflWA60IZzg/LXD3KW1LDDiR4RVXBR40Rx6UP8lz0fY2mKBx1YLEZYLEbo9UtISRnE4mIIiovlP4Svrwegvb0AxcUmaDRK1tb49cdDh3hXZWUlUOQm8TTA9PQ+0DSLwsJ26HRrskuLxRob4zNSchHxkZHTOHz4YzQ370Fs7ARiY8dhsRTBZKIRHLwgcpNGtz0o+4uI5x0paReQz2+1obCwDUtLelgsRrS07MbUVAwAJ37/+69u0gB9Z4t2gogXU/tiYiZRWXkTx4/f2sxv8f1bra27ERo6h9TUfsWlxTabBu3t/iPi/3/s/Xd0HPed7Yvu6gB0I+ecM9DdVQwgSIIBJACCSaYky+MZH8/YHtvX4zkzPjNzZu56d51z13p33XfvW+/ckZzjjBxkybYsmaIoiiRABJIgCYIJQFU3GjnnnHPo90f1r1DdqO6ualAz8hnuPyU2u7pRJOv729/92cXFt0FRNiwsBAj9W+Xl51FRcdbeLcUhK6sNWu2mAORQsnK6g4iXN0BHR4/hzJkqNDcbEB4+icjISZjNJjQ08Pkt0r8llXtkWVqytNi1HqC93erWkZJal2lsbMTU1BQoisL7778va10G2F1aLEfOjpSYBih23BobG/HkyROEh4cjKSlpTxkppeuP/v7+KCsrg0qlwszMjPAQ6Gpdxpthc3p6GgMDA7IQ8SS/FR8fj66uLmg0GkRERAj5LUIDNJlMkk7VJ4GI9/PzE1aKpqamhIfSubk5qFQqXL16VVZ+C3AsLZYrZ0eKoigkJycjOTlZoAGK81vR0dFITk5WXFosHja9WX+8ePEi1Go1JiYmBDdJKr9FUZTs0mKx5GSkiFQqFdLS0pCamorBwUEAvFMhJ79FPtPzRsSL81vibqnFxUWo1WrcvHlToBh6+nzPAxHv6kDq7t27uHv3LhISEpCSkqK4tJgMm3IzUuLr0+l0ePnll6FWqx0OpKxWq3AgRYihFEUJjpSSwYcg4uU4UuRAKjs7Gz/+8Y+h1WoVATn+I+vFkPUp1cBCEP7P6s8gYTYE1lDXAARnUTYgY0mDAf021uyHHWKwBQCExA8hPn4IZ89WoLMzAxzHoKWFP/m9fbsE09MRMJk4hIS4RrgDQEsLyUjJH3wWFgJ3lRbr9fy6XH7+M0xPk/wWg48+egU3blxETk4rBgfjERenrLTYW0T84mIQzp0rh8FgxblzN9HRwbtJjx8fRn19IaKixkD6t4KCFmSXFu++PtqOiPfsSPn7L6Og4DG2tlQYHY3FwYNP0dmZiStXPgutdl3kJvXscmjGxyP3hIiXWn+Uym/xZb78g3Rd3TEsLQXAaDR7dLTEpcVytbS0GxEfGLiIo0cf4ujRhxgfjxKIie3t2fD1XUVenhX9/YmIjlZWWiynj8xZ/f1JmJ/n1x9p2mynAfLI/Hv3TqC2luS3WBiNzfDzW5ZdWuyoZXDcfQQGBspypMi6jEajQXl5OUwmE7q6umSty7gqLXYncgKclpYm6Uip1WphXWZ1dVV4wGlsbAQAPHv2DFtbW7vKM6X0vBDxoaGhwrrM0NCQ8IBD1mWMRiN6e3sRERGxp2FTjsj646VLl7B//36H/BahAaakpIBhGKF/TEzt86aPTI4jFR4ejtOnTyMwMBDXr19HVlYWOjo6duW3pL4fV6XF7uTJkdJoNDAYDDAYDFhaWhK+o8ePHwPgXVGNRiNrAN8LIl5cWhwZGYnS0lIHN0mc3zKZTOju7v7EM1IA70hNTU3hpZdewsGDB7GwsCD0b5WXl+/q39JoNLJLi6WuT+76Y0xMDGJiYhAZGYmPPvoIKSkpMJvNaGhoQEhIiOAmST3Quyotdifx+qOUI+V8IEWcGwKD6ejoQEBAgKwDKVJarGTwkXKkxAdSJL8lPpCiaRqdnZ0ICQlRDOSw2WyK7qOxsTFMTEwoAnL8R9eLIetTJjHYgp7wQ6yTI+VJ8asq+G1T6PDf3AW2cJZavY3s7HakpvaivT0TcXHDACjU1JSgpqYEycnETbJCp1vb9XqOYwQgh1wRR8qVkxAWNoNTp+6iqOguBgcTBNDB2poOy8v+KC8/C4bhEBPjPr+1V0R8dja//sjnt1qQm9tiz28ZwXE0qqrOoKqqFGlp3QgNnVZcWry4GGDPSClHxMfGDuOll67DZqPQ37/Tv8Wy+xAYOC8QEwlsgWSklPRI9famyEbEa7UbMBotyM5uwz//8z8hKmoC29sqVFScw61bZXYaIIfs7FbJIdRVabE7eULER0WN48yZKpSU8Pkt/j4yYnPTBzrdCmpqikHTrMeh3TEjJR8R71xazNMA+cwYn9/iiYk3b15ERcU5ZGZ2IDR0SjGQY3nZDx0dEzh8+KiitTWz2Yzo6Gi8+uqr2N7e9rguw38m1mNpsbMGBgZkI+J1Oh32798Pk8mE119/HSEhIVhdXZW1LgPsADmeFyKeuEkJCQkO6zJPnz7F9vY2/Pz8cP/+fUkaoLPEQA4lGSlnap8zDZA8BF69ehXXr19HTk4OwsLCFGekvEXEm81mRERE4POf/zy2trYEGqCr/Bb5TICyYdNTRkosf39/FBQU4ODBg3j99dcREBCAmZkZXLlyBVqt1sFNkvqse0HEu7qPUlNTkZqaKuS3OI5DXV0dbDYbAgIC8OjRI5hMJkk3SaznhYgPDAwU8ltjY2OCm9Te3g5fX1/k5eUhPDzc6x4ppYh4s9mM0NBQfPGLX8TGxsau9eb4+HgwDAODwSC4Qt4MmwQRL2f9MSgoCMePH8fRo0fx+uuvQ6/XY3h4GB0dHR4PpMj1eYuIl7qP1Go1srKykJWV5XAgdfv2beF6GxoaZB1IAZ8MIv6FduvFkPUpUsPEDtiCsgEZi46OlBxlLKmxRtmQkt6F3xyrcABbuFJLSy42N31QUlKNpKQBzMyEwGymwbIMrl17GTdvXkB2dpu9W6oLavW2CMhR63bYcRbJSDmjrp1FUUBi4iASEwehVm/g8ePDSE7uw5MnBXj0aDcN0Fk7pcXeIeKl1h/5/NYTHDr0BFNTYYLj1t2dDsCGhoaD2NzU2PNb7gcncWmxXDk7Unx+qw/JyX24cOEm2tqywHEM6uuPoK6Oz2/RNAeW9Q7IoRQR39aWjY0NX5SUVCE1tRcTE5GCm3T5sji/xSIlpQ8UZZNdWix1fXIQ8SS/lZbWAz+/RTx8WIiYmFHcv38c9+6R/BZrz2/tHsZJabE3iPi8PKukI8Xnt+pQWFiH0dFo4SChrS0HgA1WqwFa7SYSE93ntwAC5FC2Hz85OengSHlal0lMTITJZALLsopKiwFlGSkiAuQoLS1Feno6RkZGBNyxq3UZOaXFUpKLiBevy1RVVeHBgwcICQlxSQN0lqvSYnfy5EiFhYXh1KlTKCoqwuDgoBBQX11dBUVR6OrqQkBAgMf8FrA3RDxxpKRogM75LZqmwbKsVxkpbxDxq6urePXVV5GZmYn+/n6BBsiyLAIDA4VuKfLzVwrkIJKLiCf5LaPRiOrqaty/fx96vV7Ib4ndJOf8FuC6tNidxPRHKUcqOjpaMr+1sbEBiqIwODiIiIgIj/ktAF6vP4odKR8fH4GYSNabOY7DjRs3UF5ejszMTOE+cuVIuZI36489PT1YXV3FpUuXkJ2dLbhJ5EAqLCxMuI/ItcgpLXZ1fXIcKXIgtX//fuHvI7VaLftAanR01CtEvDfrj//R9WLI+hRoft0H/+PZSfy69YAAtohfVcHPRiF4g0L2oho9fltY9/DsoNkGUlfUiM7owv999j3Zww/H0QgNnUZi4gAAIDR0FidP1uLEiVoMDcWD4xhYLDv5rZ21KUphRioaY2MxihHxVqsRmZmd+MIXfoeVFUIDpAUaIN8txSE31wpf33XhM4kdKTlqbd3dR+ZK4eHTOH36Dg4efIrvfOe/IiZmDB0dmUJ+a6d/a0zy9VKlxZ7kzpHSaDZhMFhhMPD5LYuFJ91VVpYBAObnl8FxJuTktHpcRfMeEU87IOIjIydQWlqNkpIa9PYmg+N28lvBwbMwmfh1BeVADpKRUoaIt1qNyMjowhe/+BssLATAbDaB4xiUl19w6t9qF4ZslvVcWuysHUS85/soJmYMMTG3cPToA3znO/8VERFTTvktFjTNueyt40uLxxAdLf9Um+M4l46UeF1mbm7O4QEH4F2ClpYWWesy4tJibxDxaWlpDvktMe7YeV3GZrMpKi0GvEfEW61WpKam4ktf+pIkDdA5vwXIKy12llxqH0VRSExMRGJiIoqKivDd734XwcHBePLkiUN+i6ZplxCRvSDipa6P0AALCgqE/BbHcfjwww+F/9/V1SVJA3TW80DEi/NbYjepvr4edXV1iImJEe6jvQA5lNxHra2tSEpKwl/+5V865LcuX74MX19f5ObmgmEYJCcnC7+vEiAHkVxEPMlvpaWlobi4GN/73vcQEBCAuro6PHjwYBcNUEreZKQItU/q+sh6M+mWIo5bWxuffU5KSkJ/f7+s/Ja4R8pbRLwzDbClpQUsyzocSNE0je3tbUWlxQC//tjd3a0IEQ/wf08kJCTgq1/96q4DKT8/P8FxIwdS5DMpdaR6enqwsLCg6DO90Ish699VNhtwvS8b/+/6EoytOJ4OZy6psWE/2T857YPCaRv6/bbQ4beFAf02bBJ/Br8YPAjNYCYuHb8re8Canw8SEPHOr+FpgENISBDnt3hq2taWBhrNBqzWPNC0GcHBnh0zUlqsDBHv6Ejp9SvIz3+K/PynDvmtq1dfwfXrF+2rfc1obuavSymQQykivrnZBECF1167jJCQWbS38/1bjx4dxsOHJL/FO24EyS2ntNhZ/NqaSZYj5e+/jMOHH+Pw4cf4/e8/j46OLKyu6nDlymvw8VkT+rdSUnolHTdvEfG8I7UbEU9RNqSm9iI1lc9vtbZmg+MYPHhwDDabClrtOrq70+DvvyzLbfNm/dEZER8YuCiiAUYJbtJOfqsZBkOzUFqsDMhBEPE9sl9jtRpgs6nx2mt/QGjoLFpa+P6t2toi1NaeQkLCAGiag8FggZ/fCgBxaXEFgKcAPK9SiTNSnhyp4OBgHD9+HMeOHcN7772H9vZ2zM3N4b333hPKM2madrkuI1Va7EkEES/lSDmvyxDcMVmX0Wq1GB4eRkhIiKyH8b1kpIgj5UwDdM5vmUwmGAwGWCyWTzQjRdTW1obt7W38yZ/8CUJCQtDc3AyWZYX8VmpqKki3FLmWmZkZ2UAOIiWIeJLfOnXqFN577z20tbVhcnIS77zzDgICAoRaAVduYmdn53NFxDvnt4jjdusWX/6t1WoxNTWFyMhIWYcD3iLixY6Uu/xWcHAwTCYTjEajW0fK3fXp9XpF649dXV3CfRQcHLyLBuic3wKUATmIPGWkxCL5rdLSUrz//vtoa2vDyMgIfvnLX+6qp3D1mZ4nIt7VgdT16/whslarxdLSEra2tmS5ou6GTVcijtSFCxdcHkg1NDQ4HEgZjUZFpcVEHMfB19dXESL+hV4MWf9uGlgIwv9efwbVg7v/4tNuAykranT4b+F+6AYi1ilkLmmQvqxG2rIGKyo+p9Xhv4kJHxuyQ3mwRcutYsyIHCk5MptN4B0p96fuavUWsrPbkJ3dhr6+RPzqV19DYOACampKUVNTipQU3k3Ky7PC13d3fstVabEnEWqflCPlmN9KFIiJPPYeWF31xchIDGJidtMAnbUXRLzYkcrLa0FeXguWl/1gsfDExKqqMpHjxmJkJEZRaTEgzkjdkv2ajQ0turvTYTJxuHTpGvr6kgQ3aSe/xeeExCAI0kfmDSLekwuo1W7AZLLAZLII95FOt4KKivNOblKbpItGhk3n0mJPcoeIj44ex5kzlSgpqUJvb6oA8GhsPAiAv3enpsI9rrgCjqXFShHx4tJihmHBMCzm5wMFx+3GjYsoL+fzWwzDYmgoVlRafAdyhqz+/n7Mzc2huLhY9rVtbW2hp6cHRqMRL7/8smR5pvO6DP+Z3JcWS8ldRkosnU6HAwcO4MCBA+jt7cVbb70FrVaLa9euObhJrtZlbDab14h4KUfKOb9FuqUIDRDgh8S5uTlZmSxvM1JiRDxFUW7zW6RbamCA//dCybDpDSJ+e3sbfX19yMvLwyuvvCLkt8Q0QJLfEh8AiB0puZLqI5OSv78/Dh8+jMOHD6O7uxtvv/02VCoVrly5Ah8fH+E7cpXf8hYR72ptzTm/1draCo7jBBogwN/7S0tLHvNbgDSQQ+71ESAHRVECDXBsbExwSkh+ixy29PXx/158UhkpsQYGBpCTk4OXX35Zsp6CpmmH/Bb5TN5kpOQg4sUHUp2dnfjtb38LALIPpKRKi+WIOFLO95G7AylyKBUQEIDV1VVZB1LeIuJf6MWQ9W8uMdhiZVP6lCxlWQ2NjUKH/xZAAZO+Nkz6bqA+dAMJqypkLqmRvaiGYVEDdcAijqd3ImbDhusuHClXstn4ISEhYcDlOpKU2tpyoVJt4etffxNra77gOP4h8KOPXsaNGxeQk9MKmuaQnt4ldEvJKS121vq6VhYins9vDSAxcQDnzpXjzTe/junpcLS25sJqNXrMbwE7QA5vEPHnzu1GxPv5LaOg4AkKCp5gairc7rjR+PDDzwKwITBwHqOjMUhN9ZzfAvi1NX7Y9A4Rz9MA+5CS0ofz52+gvZ2nAdbXH0Vd3XHExIyAplmkpXUrKi0m4jjajoh3n5ESq7MzCxS1jW9841+wvOwnuEmXL/8JfH1XkZtrBcNwSE7uE65lx5Gqkv0+chHxfH6rG2lp3bhw4Tp+8YuvYnIyEhaLCWYzY6cB8v1brg4KpEqLPWlyMhzDw/F2R8pRQUELOHaMz2+NjcWAZfkBsK0tBxS1jcDABczMhCIg4A4o6r95fC+SkcrJyZF9feLSYlflmc7rMmlpaYpKi4nkZqTE6unhHcNvfOMbWFpa2rUuQ/q3xOsyAwMDbkuLpUQQ8WIXSEpqtRo5OTnIycnBysoKfv3rXwvlsCzLesxvAfKHBLHcIeJd5bfMZjMoikJQUBBWVlYQFBQky4XwNiNFHClX+a3KykpUVVUJjltqaqrXGSml648Ecf5Xf/VXmJubE9wkcX6LYRhERUUJr1EC5CCSu/6o1WphMplgMpmwuLiId955B+Pj42hoaEBjY6PH/BawA+R4Xoj46OholJWVobS0FD09PcL6XkNDA1QqFYKCgrC97bpP0llk/dFbRLxUPYU4v5WVlQWappGUlCQAOZRmpEJDQ2WvP1IUhfFx/qDsG9/4hrBOLD6QIqu7YnCJp9JiKYnXH905UuIDqdnZWbz77rsYHx/Hs2fPwLKs5Hqzs6RKi19Inl4MWf+GEoMt3ClzSY15zTbGfBz/srJRwIB+GwP6bZyO7sCXQgYw1J6Fu3eKcfcOfzKt0WxhddVXkgborLGxGIyPR+PCBSUZKZVDabGf3zKKimpx8mQthoYSBDfJYjHB338RRqMFNM2CZeWXFhORjJSSwWdlRY/x8WgcP34PR47Ui/q3zji4Sbm5LUJ+C+CdBHelxVKSi4gPD5/C6dO3cerUHdTXF+DWrfNYXdXjnXf+AoGB86L+Len81sYGP2yKS4vlXZ80Il6r3YTBwK/DifNbt26dA2ADQEGnW8HGhlbWmpy4tFiubDYK4tLigIAllJZWobi4Gn19KeA4npjY1HTAnt/iHbcdR0r+sOkNIn5jwwfj49EoLKzD4cOPYDbz39HNmxdQUcE7bgzDIiur3eEAwFNpsZR21h9dI+IpCoiJGUVMzCjOnKlCff1hVFaexdKSP375y68hNHQGJlMVGOaAy3UZbzNS5CHT2ZEi5Zn79+/ftS5DURRsNhsCAwNlr8t4m5Eym81IS0tDcHAwgoODd63LPHv2DI8fPxbWZWiaBsdxioEc3iDiAWB8fFzIJznnt3JycoQHHPEwKnak5ErO2po4v3Xu3Dk8fPgQNTU1WFhYwM9+9jNJGqCzvEXEsywr6UiJ81uTk5PCg/uHH34ItVqNra0thIeHY3t7W9bAPjs7uydEfGhoKEJDQ5GSkuLQv/Xw4UOH/BaBwXxSGSmxNBoNJicnBWeSfEckv0WIieL8FuC5tFhKcu4jlUqF9PR0pKen4+LFi3j48CHu3LmD+fl5/PCHP5SV33reiHiS3xI7bmazGa2trdBqtdjc3BQKquXcF94i4lmWRUJCggALcT6QunPnDu7cuSMcSBkMBkWlxUTeIOL9/PwwPT2Nffv24eDBg7vWm6UOpAD3pcUv5F4vhqx/A0mBLVzJfxOIW1OhIWgTUr80Ur+I/6OgBpdSW3jHqrAOMzPB+PnPv461NR1qakpw926RyE3qhFotfbJEMlIGg/y1te7uVLsj5Tj48PmtQSQkDOLcuQp0dPD9W0+f5uPRoyMAbIiLG8LSkh+Cg6XdpN3XxyPik5KUrT+StTWeBvgUhw49xfQ0oQHSuHr1VaF/i6ZZ+Psv2YEc8kqLAUdEvBSVTkoUZcPYWCx8fVfxd3/3HfT0pIPjaDx6dAQPH+7QAE2mnfwW4Lm0WEpyEfHi/NbkZAR+9auvYHVVh6qqMtTWFiE3twUMw+e3XP0+UqXFntTbmyxZWqxS2ZCa2oPU1B57fisHHEfjwYPjuH//JChqG3Fxw1hf95Gdk9orIp6nAZL8VvSu/i2DoRk0zcLPb1lRaTGwM2wqQcSrVNuYnIyAVruOb33re+jq4v+s1dY+QG3tA2Fdxmg0Ojy8tLW1YW1tTdE/yktLS+js7PToSInXZUZGRvDb3/4Wy8vLuHXrFu7duyeEr8n6kZS8yUi5cqQ8rcuQ/IKSU3eSkfIGEU9OrsX5LeImWSwW+Pv7C8REHx8frzNSStYfNRoN5ufnodFo8Dd/8zfCiiOhAaampgr9W+KhXC6QQyyy/ujJkYqIiEBxcTFOnz6N/v5+vP/++1heXsbNmzdx//594Tty53Q+T0S8mAbonN+qrKwERVGIjY1V7LJ5i4inaRpRUVEoLS1FcXGxkN9qbm5GY2OjkN8iGSJvgBxKEfE+Pj5YWVmBWq3GN77xDaHqgOS3CA0wKyvLwUXyNiPlCRFPUZSQ3yJl5x9++CE2NjZw/fp11NXV7aqnkNJeEPHOjpTzgRQ5bLl+/TrKy/m8eUxMjOLMpreI+H379iE+Ph7x8fHCgRShJT5+/BgRERHCQYJKpZJdWvxCu/ViyPoE5Q5s4UoZyxpQoNDpv7sb6y+yG/G/HbyLYKfM09qaHktLgTh//mPExw9jNw2Qd5Pi4oaFVcLtbRUsFhOystqFIL0ccRwDnW7FrSOlVm8hJ6cNOTltWFnRoaLiLFh2P4aHE/Dd7/4DUlJI/1aLZH4L4EuLe3pSHUqL5V6fFCI+LGwap07dQVHRHQwMJILjGDQ3G2A209Bq1wFsIzJyHDYbZK1b7g0Rb4Fez+PM8/J4GiDp36qsLENVFe+4MQyLnJwWl46UO3mDiN/eprC0FICyspuIjR0Dy9JoaeHzW0FBcwIxUYxN91Ra7Eocx3h0pPj8lhkmkxmLiwGorCwFx+3D0FAC3njjH5GZ2QGa5pCVJZ3fAuA1Ip5lGUlEfHT0GMrKKlFaWoWenlRhxbGh4SB8fVcB2BAfPyj7ffr7eUR8cbF8RDwpLc7LsyIwcAn79rHYt4/F/Pz/BbP5FFiW3bUuk5mZCY7jEBgYiJSUFNnvJTcjRURRFHx9fbG0tISSkhJER0fLWpfxVFrsSnIcKed1merqalgsFgwNDeGNN96QtS7jLSKeZdldjpQ4v3Xu3Lld+S1y8q/k57RXRHxISAgOHTqEQ4cO7aIBkv4tsgbqDZDDXY+UlMgK49LSEoqKihAZGSkrv+VtRkrO+qM4vzUxMYHbt2+jpaUFQ0NDeP311x36t1w9jO4lIxUeHu7gSIlpgGJiIslvke9FyTC3F0R8VlYWoqKiEBUVtctNamtrg06nQ15eHhiGQWJioktHyp3kZqSIVCoVIiMjsbS0hGPHjiEiIsJhvdnVgZQSIIdYrjJSYgUHB+PEiRM4fvw4RkZGUFtbi7a2NgwPD+ONN96QdSC1vr7+3BDxrg6kSD1FSEiI4tLiF9rRiyHrE5I7sIVL2fieqzGfLcxrdx4Is0N4sEV+9JDky8TUPj+/FcTHD6OsrMJ+wk3j2bODePz4MCIiJuxOCYfJyUgvMlI+aG3NgcnEQaORV5Cs169iYSEIISEz+Iu/+DXMZt5N+uijVxzcpPT0biG/BXguLZaSHEQ8RQFJSQNIShrAuXN8txSfk6Lw619/RaABmkxmBAUtuPx9vEPE50iuP/r7L6Og4DEKCh5jcpLPb5nNNK5c+Sy02nVsbGhhMJhlD4D89XmPiKdpC/z9l5CSwtMA29p4GmBdXSEePNjJb5lMFkxMRMouLSZyRMTLc6MCAhaxsuKHoKA5/Kf/9BvhO9qhAfL9W8nJ/Q7DlKfSYilNTERgZCTOLSJepbIhPb0b6enduHjxOlpacvHxx/yDyS9/+TV7fou1/5l07XQ6lxbLUVtbluT6Y1DQXRw79t9RWFjogDtubW2FTqfD6uoqjEajotNIjuMQHR2tKCNFEPEMwyAwMNDlukxSUpKQTZqYmJBdWkwkzkjJXX8MCQnBxsYG/P398Wd/9meCCyBel2EYBrGxsQ7fk9JhE+AzUoODg24dKef8VnNzs3Cy/fOf/xwpKSmCm+TulJvjuOeGiBfTAAcGBoTvyGw2w9/fH8vLyzAYDA7Dpm3bhvW6Xqw/6IZtbhlUWAB8S7OgZfi1o70g4vft24eQkBCBBtjc3OyQ3yL9Wzk5ORgfH8fU1BSOHTsm+328QcRHRkaCoijo9Xq89tprQgawqakJQUFBAghGnN8ClA+bgDxEvI+Pj5DfWlhYgNlsRk1NDQD+PpKiAUrJ2/VHKUfKXX4rODgY8/PzMBgMXgM55IpQ+w4c4FepSX6LHCRIHUhNTEwoBnKQjFRWVpYsah9x0318fODr64uXX34Zzc3NHg+kAO8yUnIQ8c4HUhzH4d69e4iNjVUE5HihHb0Ysp6z5IAtXCl8g0LYhgr3Q/mskE69gX/Y9wDfMD6BViW91uLKkVKrt5GV1Y6srHasrupgteaB42jU1JSgpqYE/v6L0GjWkZgo3x1paSE9UvIfWMWlxWFhMygquouTJ+9icDBBcJN28lt8NikmZgRyS4vFUoqI12i2oNOtYXNTi8985kNsbWnBcTSqqspQVXUGaWnd4Pu3WuDjs5Pf8lRa7Eo71D7XiPiIiCkUF9/G6dN30N+fiMrKMxgaSkRzM43+/hTBTSIUOil5g4jf3ubX1pwdKa12E0ZjM4zGZiwt+QvZpFu3zqGysgwBAQtQqzeQltYp+73a2nhEvJLBR4yI52mAVSgpqUZvb4rg3DY28vktmuZA0ywiIqbAcQxiY4c9lhaLpRQR7+OzjuDgWWxuanH+/HVsbvL30c2bF1FRcU7kuDnmtzyVFru7PmlE/AMA66AoH8TGxiI2NlZYl6mpqcHIyIjg4MhZl3EuLZYj8dqa2GFwtS5DyjMDAwOFE1W52isiXkwDJCtOzusyNE0jODjYKyCH0nUjvV6P6OhobG1tobS0FBsbGxDTAF3lt8iw+bwR8RRFISkpCUlJSTh37hza29tRW1srrM2Nj4/zD6XDPqC+/wDU3BR0Iw+h2lrBtjYIc28fBRUdhq3/9aTXGamUlBQHR8rf339XfovjOFy5cgVarRZBQUFQqVSKwC57RcSTbJLYTSLdUjExMWAYBkajEQEBAYIj5am0WCylaO/AwEAkJydja2sLJ0+exObmJsxms0ADJG5SUlKSw8/DU2mxK3lypJzzWy0tLbh//z5sNhssFgtmZ2claYDOIqXFzwMRHxQUJKw3Sx1IkftIybDZ3d3t9fojqVXIzc3F6uqqQEyUOpDS6/UgQA5PpcViKb2PQkJCkJWVhdu3b2Pfvn2y3+eFHPViyHqOkgu2cKXMJQ22wOPZi+K78f89egvJge77p3YyUq4dH51uFQcONODAgQbMzoagsXEfamuLAFD43vf+AdnZbXY3qctlfgvYXVosRzuI+J0Hap4GOIjExEGcO1eOjo5McByNp08P4dGjowgNncbMTBhOnZK/QrW9TcFiMXmNiKdpCzSaTRw69ARTUyS/xeDDD1/F9eu848YwLFJTuxWVFhMpRcRTlA3Jyf3Y2tIgNnYIx449AMcxqK8/gro6kt9i7fktxywPyUgpRcQvLAS5zRP5+y/hyJFHOHLkESYmItDUtB91dYUg9xHvJnFu81vA7tJiOSKOlPg752mAPUhL68GFC9ft+S0G9+8fx717JxEVNYbx8WicPi3/PvIWEU/WH/fvb4JWu4HCwjqMjkYL64RtbTnQ6VaQl9cMhuGQmNivqLSYaAcRXy9BpVyGc1+WSqVCRkYGbt++jcjISBQWFjqsy4jD184PVsSRUpJt6e/v9+hIOa/LNDU14cmTJwCAH/zgB0L42t26DLm+54GIV6vVyM7ORnZ2trAuw7KssC4THx+PoaEhrx7uvEXE5+fnw9fXV6ABkoA6yW8RpyQmJkZwpJS4IysrK2hra8OhQ4dkrT+SVbr6+nqEhYXh8OHDMJvNfH7LBqRkDIFpfIy8+Rb4rPMHUgHjFVgLyEHNm7NAnrJsixxEvHN+q6mpCU1NTQCAn/zkJ8J35Gkw3gsiXvyZxPmtxcVFIb9VUVGBW7duISkpCX19fYrKZsUZKW8Q8UePHoVOp3Po37JYLEJ+ixwkREREeAXkIMOmu4yUWD4+PmAYBk1NTdjc3BQgHsRNcpXfArzvkXLnSJFMHTmQItmk5mb+oPbNN9+UdSAF7C0jJf5MOp1OOJCanZ0VgELkQCotLQ3d3d04fvy44vvIW0S8ktLiF3LUiyHrOUgJ2MKVKBuQvqTGWMA6vl380Q7YwoNIRiozU97aWkjILEJDZwBQeOmlqxgbi0Fzszi/xbtJsbHDDu+/40jJR8ST6+MdKWlEPJ/fakVOTitWVvRobjagtpbPFdy5U4y+vlS7m2R1oAE6i5QW07SSjJSPJCI+PHwap0/fwalTdzAwkASW5Ul3ZjNtd242ERAwr6i0mPRIKXFvxI6UwWCFwWB1oAFWVp4VOW4scnJaodFsCn1kSjNSShDxkZGTiIkZAUDh7NlyjI1Fw2rNQ1PTfnt+i6cBOiPd3ZUWe7o+d4h4H58N0LQZNG3GwkIALBYTHjzgV4bu3j2FoaEE8P1b7W7dR28R8VKlxTExY4iJuYXS0kr09KQJK44NDfkICZmBSrUFf/9FRaXFO4h4V/fRHTj3ZU1OTmJ4eBhnzpxxWZ4pfsDJzMyEWq0WMlKeSovFUkLtI+sys7OzePLkCU6dOoWJiQk0NjYK5ZnkQdl5XYY4Ut4i4l1R+8TrMjMzMzCbzaivrwcA3Lt3DxMTEx7zW4B3GSkpR0pMAxT3bz1+/Bj19fWIjIwEwLtg3gA5vEXEFxQUgF4Kw8Avfot+XR0sphxcffVV3Lh4EbktLaA5Dqnd3fBdbEFnzBTiJkLhN7QKyOgIA3bWH+U4CRRFITk5Gaurq2hqasKxY8cwMTGB+vr6XTTAgIAAh9e6Ky32dH3uHKmAgAAcOXIER44cwcTEBFiWxdOnTwEA9fX1mJ+f95jfAnaXFsuR1Pqjc36L9G/dv38f9+7dEyAwOp1OUYZLaUYKcETEHzt2bJebRPJbpFuKuDXEkZIL5ACUIeJJPQXA//k4dOgQJicnZR1IuSstdidPjlRISIjDgRTLsmhsbAQAPH36VKjW8HQg9Uki4l/IvV4MWXuQN2ALV4pfVcFvm8LnSq7jUFqLrNesrfFDAsM0yc5IAfwDa2joNA4caARFAWfPVqCzkyeUPXuWj8ePj9jzW3y3VHDwnL3g13NpsVijo9GKEPF6/QoOHHiGu3eLkJrahaSkfnAcg6tXXxHcJKn8FvlMShHxLS3SGSkiPr/Vj6Skfpw/X4729kw0NBxAV1cGAAo//ek3he9ITAOU0k5psbL1R2dHypkGSIiJV668Bh+fNSQkDHh0pJzlPSKeX388fPgRKMomym/RqKs7hgcPTiA2dhh8t5QZAQFLskuLxdpBxMsboAMDF3HkSD3q648gMbEPiYmDMJtNovwW7yYlJfXvGvT2hoiXvo/4/FYX0tO7hPxWY+N+9PUlA6Dwy19+FTTNwWCweITQeEbE3wHg2Jcl5UiJaYCjo6NCt1Rrayv0ej2SkpIwNzeH06dPy/4evMlIkesLCAjAiRMnoFKpHMLXzusyBoMBOp3OqyFBjIiXo9DQUJw4cQKNjY0ICQlBQkKCA+6YDIDO+S3AdWmxO3lCxJPfLzc3V8hvNTU1YWiIz+q+8847wtqRp7XBvSDiyX209N1qJJrfR+aCBcU1FRhISgJL07AaDOAYBgELC0jp6cFMWAgKqluw9LN7CPne5zy+j3hIULr+6Ofnh9OnT0OtVkvSAMX5LR8fH6/6yAgiXi61LzIyEiUlJWhpaUFISAhiY2N35bcYhhEGZufP5E2PlDtHysfHR3BnSH6LZVmMj4+Doii89957svJb5PqeByKe0ABLS0vR3d0trIE+e/YMoaGhSE1N9SojtRdEfFlZGTQajeSBlDi/pVarvRo2CSJejrNJDqRiY2PR09OD7e1txMTEoKGhQTiQIj9TKcfTG0R8T08PFhcXXwAv9qgXQ5aX8gps4ULZIRP4U+06RifTcPvWOUwM86fu8fFDbl2jlpZcbG5qFT2wzs8HoacnFUVFO46UWr2N7Ox2ZGfz+a3m5jxwHIOamlLU1JQiObkH09NhiItz7UhJifRIKUHEk9Li8+dvIi/PiqIiPr/FsoxD/xbJJsXEjGJjgzhSnOKMlFxEvEaziby8FszOhqCrKxMnT95BV1cGqqrKnPq3Wh3yW4D70mJX4hHx7h2piIhJFBfX4PTp2+jrSwLHMWBZ/i/5W7fOYmQkFgzDeexs2kHEK8lIBewqLdZqN2A0WmA0WrC46A+LxQSOo1FRcQ63bpUhI6MTExMRiIlRVlq8M2y67pFylhgRbzJZUFJShd7eVHAcX+bb2HgQISEzguMWHj5lB3IYFAE5AHFGqtfjr/XxWQfDsFhd1aGvLwVHjtShuzsdN25cRHk5n99iGBaZme27Dk5IabH7AZrPZQH8kCOm9kk5UuJ1GXG3FFmXuXv3LmZmZmSty4hLi+VKypFyDl87r8tkZ2djbGzM64yUUkQ8WX9kGMYhv0VogM75LbmlxVLXJ5fap9frkZ+fD4BfrTtw4AB6enqE/FZubq5AA3R2+tyVFruSOCMVHByMjfYJbPVOwXfBCoBvG0nq70dSfz/Ol5ejPSsLHE2j2b5m1GAKx9xQG44MjiM4IcrNO3mPiHd2pMQ0wMnJSYF0d+XKFfj4+CA3NxcjIyMIDw/3Csih5PqGh4cxPT2Nz3zmMzhw4ICQ32JZVshvxcbGCo6bv7+/V0AOcn1yEfGBgYEoLCyETqfDtWvXYDQa0dvb6zG/BfDDpqvSYlcSZ6SkHCmy3pyRkSHklTiOQ0NDAwCgsbERNpvNY34L2DsingyYrg6kWlpaoNfrYTAYMDQ0JBzEyJU3649jY2MCIv7QoUOS9RTOB1LiYVOJI8WyLHQ6naKc7Avt1oshS6H2ArZwFgFbfDmTxXff+Eekp3fC13cdjY378eRJAcLDJ+0hfg4hIbO7Xk8cqYQE+RkpjiMZKenBTKdbxcGDDTh4sAEzMyH29aYDWFgIxtJSAP7wh8+BYfj8lrObJJZjabESRLxjabF0fovB48cFqK8/isjIcURGjnuRkdobIv706Ts4ffoOpqbCBTfpww8/i+vX15Gb2wKaZpGa2gOVyiYMm95kpM6e9exIUZQNKSl9iIsbhtlsRFJSH3x8NlBffxR1dYQGyPdvSeWMdhDx8tcfCSLelXsTELCEI0fqceRIPSYmIsGyNJqa9mFpKRBq9SauXn0ZNM0iJaXP7fcvRsQHBHiPiOfzW91IS+u257dywXE07t8/gXv3iuxF1BN2IIeSjBS//nj0aJ1ERsrd9dGIiRnB2bO3YLPxxeAsyw+AJL9F+rcSEwdAUTtADvfDpmMuq6+vD3NzcyguLvZ4TWRdJjU1Fe3t7YiKioJGo5G1LgO4Li12J4vFIvRISUlqXYbjOKyurkKr1eLGjRtgGGZXeaazvEXEsyzrsP7onN8ipDuS30pJSUFkZKRiIAfpkVKKiCeOFFknGxwcFDIlZrMZAQEBDt1ShPQHKBs2yfrjiRMnAAAbllH4rHSBwu5/AzSbm8izWpHd1obX//EfETozA5XNhnrTJh79/KdITUsVHDcpx/OTQMRHRESgpKQExcXF6OvrEw4S1tfX4evri6qqKjAMs4sG6Ky9IOLF1D5P+a2MjAxERkZ6lZHaCyL+1Vdfhc1mE2iAJL8VEhIiOG4k0+PNkEAQ8XIcKV9fXzAMA5PJhNdffx2BgYHY3NyUpAFKOW57QcRLfSZXB1KNjY3Y2tqCXq9HbW2t5Hqzs8SlxUoyUs6OlBQN0PlAKjIyUrEjRRDxJpNJ0frjC+3Wi29PgfYKthBLDLZoatqHrS0tTp68h8TEAayu+tppgAxu3y7G7dvFSErqA02zMBis0OlWJR0pT7LZ+Ae1hIQBhIV5dqRCQ2dx8mQtlpd1ePz4MBimCa2tuWhuNtppgHz/VmzsyK5rcFVa7E47GSlpR0qj2UJubityc1uxvMzntziOgdVqBGDDnTun7G5Si9v8FrBXRPyOIxUePoXTp2/j1CmeBkiIicTdMBotYFlaUWkxIF5/lL+21tqag81NHxQV3UVKSp9DfuvWrbOorDyD9PQu0DSHnJxWaLUbWFiQV1osdX18RsozIj4ycgKlpdWw2YC6umPIyWkR8lvBwbOCKyn1exFH6nki4vn8Fn94sbAQKBATWXY/ABvq649gZUW/iwYoJSkghydNTkY4OFIUBcTEjCImZhRnzlShu5vv3+LrF/IRGjoNk8mMxsZ9MkuL74AMWSQjpYS21tbWhvX1dZw+fRppaWmy1mXklhY7iyDiPa2tkXUZgjy+f/8+UlNTZa/LiB0pudrc3ITVahVWy5yl0+lw8OBBHDx4EDMzM8IDTm9vLwCgqakJNpttFw1QSp6GTSlJOVIkvyXu3yL5raioKJhMJjQ1NSE1NRXBMvNRgERGan0T1KZ0xyFRR0YGVv38cPrKFWR2dKDr6D+h+6+Owjo9IPRvEcctNTUVKpVKGDbz8/MVDwlyEPEURSElJQUpKSkICAgQ8NQPHz70mN8CXJcWuxPpI3PlSEnlt8xmMzo6OgDwD/6+vr5ITk726Bg9D0Q8RVEONEDn/FZ8fDxomkZTU5Oi0mLA+/XHlZUVXLp0SXCxxevNJL/FMAwSEhJAUZSs0mIpsSyLsLAwj44UOZDKzMzEnTt3cPfuXYSHhwvrzZ4OpFyVFruTJ0cqJCQEJ0+exIkTJzA8PCwMyVYr7zZ3d3cjKCjI44EUsAPkUHIfvZC0XgxZMvQ8wBZEkfpF/B8FNQ5gC0LtI46UTreGAwcaceBAI2Zng4VuqY8/voSbNy8gO7sNGs06lGekYjAxEYULFz6W/ZrtbRWam03Izm7HpUvXcPHiDXt+i8bTp/l49Gh3fov/TJ5Li51FMlJyHlj9/FZw6NBT5OS04dvf/gckJfVjdjYEV6++iuvXX7K7SRzS0nbnt/jr2wsifrcjRWiAycn9OH/+Jtrbs8BxNOrrj8BmU2FsLBp1dYV2GqD7/Ja4tNibjBRxpJzzWyzLgxc++IDPb+XmtkCj2VA8JIyPR2J0NBZnz8pHxNtsFCwWGpmZnfjc5y5jY0OL1la+f+vBg2O4f5/kt/j+LbIiSRyp7GwlPVLyEfGBgQsoLHwImubwxhv/iLi4YQwPxwn5LeImJSUNSA6hxJHytJIplrv1R5VqGxkZXcjI6BIylxzH2GEwFHx8NvDkST6Mxmbo9a4c4jsA/hs2NjZgtVqRl5enOCMlLi0Wr8uMjIwI/3iL12U0Go1XGSlvEPEWiwVpaWn4whe+4HJdhmEY5OXlCQ+1zo6UHClBxIeGhqKoqAj5+fl44403EBUVhe7ubjQ3N8Pf319wk2JiYiQfcPaSkZK6PnF+a3l5WXDcqqt50qZWqwXLsrLyc+LSYrL+qArzw5afe9eHYxj4Ly4ivasLNgBBy4E4degYSnOj0N/fL7hJ5H4zGo3QarW7qH2eNDMz4xUivrm5GSkpKfjyl78smd9KT08X8ltarRaAvNJiZ3V2dsp2pCIjI1FaWopjx47h9ddfR1hYGFpaWsCyLIKDg4UcoFR+C/AM5JCSO0dKKr/FcRxu3uT/7tdqtbBarZI0QGeJS4u9RcRTFCXkt0g9BcdxYFlWyG+Rgl5vgRxFRUWK7iOr1YrExER89atfdaincHUgRT6T0oxUd3e3LEeKoijEx8cjPj4eRUVFeOONNxAcHIzGxkY8ffrU44EUuT7n0uIX8k4vhiw3ep5gCwD4i+xG/G8H7yLYd+cEcMeRuiPpSIWEzOHEiXs4fvwehofjQDqBlpf9oVJtob7+MBiGQ1yc+/wWIM5IyeuRAoDu7jQHRLxavYXs7DZkZ7dhZUUHq9UAvn+rFDU1JUhJ6YXB0IyWlhzQtPzSYnJ9ISEzSExUsrZmAqDCpUsfISxsGgMDO24SoQESYmJ09CgoigdyeCotdhZBxGdkdHpExPP5LSvy8qz4wx9eQ1tbDvz9l1BZWYaqqlKhfysnp0WyH8lVabE7eULER0RMoqSkBsXFO/ktqzUPa2s6qFRbaGzcJyu/BSjvkQL49UexI6XVbsBkssBk2slvsSyDiorzuHXrLDIyOmEwWNDcnAeDwapw2PQOEQ+o8PLLVxERMYmeHt5NMptNaGjYnd8C+NJi3pGST7Qk64/p6V0eHSlf33Xs28di3z4Wf/jDa2htzYVKtYUbN15Cefl5ZGW1g6Y5ifwWn8tqb+9QnJEijtSRI0d2uS9iN0n8gENwzGq1Gq2trfDx8ZF1us2yrGJEvLMj5Wpd5tq1a7hx4ways7NhMBhgsVi8BnIoofZZrVbYbDa88soriIyMFNwkkt+KjIwUnBLiJMkpLXaWEkS8n58fDh06hEOHDuEPf/gDrFYrNjY2BDeJ9G9J5bcA6YyUz/FUzGljsaUJgXpzdtdrVnQ6tGdlIf/pU6i2t7GuTwGCg6DJjRJogMnJyTh//rzQLfXo0SNsb29DrVajt7cXgYGBssiW3mSknBHx4vzWxMSEcB998MEH8PHxQV5eHgwGA8xm8yeakSJqaWnB9vY2XnnlFURFRQlu0oMHD3D//n3ExcWBpmkYjUb4+/sDkFda7CyytiYHEU/yW4WFhbh8+TKam5uxuLiI999/HzqdTshvJSYmSr7/XjNSzo6Uc36LdEvdvXsXAH/QQDJ3coa654GId66nkDqQMplM4DhOcUbKG0R8e3u7w33kfCCVnJwM0r9F7mk5pcUvJF8vhiwXet5gi/9RWIH86KFd/89TRoqIooD4+GHEx/On/W+++Q1ER4+hoeEgnjw5bM9v8W6SVH6LZKScS4s9ieNol4h4vX4VBw8+w8GDzzAzEwLSLXX9Op8PmJkJRUdHhiQN0Fni0mJliHjaARGflDSApKQBnDt3Ex0dvJv0+PFh1NcXIipqDDTNYXo6VFFpMbCDiJdLuAN4R6q9PRsmE4dLl65hcpLPb5nNNK5c+Sy02t35Lf4zeS4tdpZcRDzJb6Wk9CE//wn+9V//CuHhU3j4sFCU3+LdJKn8Fg/kMO0qLfYkjqNdOlLi/Nb4eKQw3HR08IHbxUV/9PamIDnZfX6L/Nq9IOJJaXF6ejfS07vtNEDSv7WT36JpFtPTYYqHzb6+JDsiXn5318aGBp2dmTAaLXj55Q8xOhojfEetrbn2/JYFDMMhIWEAFMXnsjiuz8GRkiO5a2tqtVpYlxkeHsa//uu/IigoyGV5prNsNhvMZvOu0mJPcudIOa/LkGwSWZdZW1vD0NCQrHWZvSLiSf4pJycHOTk5WFlZER5wqqurUV1djZSUFDAMg8lJfk1WycOdt4j4rq4uGAwGfPazn8XAwIDgJjnnt8SOGsuyuzJSKj8f6C8ZsDRZgqDBy7veq9lgwJZGA5plYQOwlHAefl89tut712g0MBgMAjzgzTffhL+/PyorK1FVVbWLBugsZyCHXLlDxBMaIMlvsSwr0AABfm1rfHzcY34LeD6IeHIQYTKZsLi4KLhJ5eXlqKioQEZGBmiaxsQE/3eXUiDH1NQUjh49Kvs1W1tb6O7uRm5uLl577TUhv2U2m9HQ0ICQkBDBKRHnjbzJSFmtVlmOlK+vr1BPMTg4iJ///Ofw8fHBjRs3UFFR4VBPIeW4uSot9iRXiHjnAymS32pqahJQ/mq1GjMzM7IOpJ4HIp6iKLcHUuSwZWxsDICy++iFXOvFkOWkTwJs8Q3jE2glhgySkUpM7EdY2Izs39diMUGt3sRf/MXboCibPb9F4/btEty+XYLk5F7QNIe8vGbodLxr1tWVhqWlAEXuyA4invXoSIWGzqKoqBYnT9bizTe/jqmpCIyOxuK3v/1ze36Ld5NiYnbntwDp0mJPIo6UFCKez2+1IDe3xSG/VVV1BoANfn7L6OjIRG5uyy4aoJR2eqTkrz86lxZHREyhuPg2Tp/m81ssy9idQD6/ZTKZkZ7eoai0eOf6lCPim5sNUKm28OUvvwUAQjbp1q1zqKwss+e3WOTktAnZph1H6pbs99nJSHlGxEdFTaC0tArFxdX4+c+/homJSPT3J6OzM8ue3+LdpIgI6SzY80bE8zRA/j35/BZPTLx58yIAG/z9l9DfnyQrvwUALEuAHPLXH3dKi1lQFBAbO4rY2FGcOVOJ7m6+f4tl9+HZs0MIDZ22u1s16Oy0STpS7kQyUkqofa2traAoCn/5l3+J7e3tXeFrqXUZOaXFziIZKU+OlHhd5uzZs/jlL3+JsbExdHZ2oq2tTda6DEHEK3nQECPinYcJvV4vmd+6evUqAN5JGRsbQ0BAgKyf114Q8QzDgKIoJCUlISkpCefOnUN7e/uu/Bb5mbW3t0uWFvv/lyJMV7djaWUM/lP3Hf4fxzCImJhAzMgIFuJfwXYWDb/P73N7fZ2dnQCAr371q9jY2BC+oytXrkCr1SIvLw+kW4pci5zSYmfJRcSL81sXLlzAW2+9hZGREbS2tqKlpQUxMTFgGAZGo1EyvwVIlxZ7kjtHKiAgAEePHsXRo0cxPj4ufEcdHR2gKAr+/v6YnZ1FcHCwLBdir4h4lUrlkN8iblJtbS1qa2sRHx8PhmGQkZGhqLRYfH1KEfE9PXzv4Ne+9jWsra0JA6Cr/BbgubRYSiQjlZmZ6dYpU6vVyMrKQlZWFlZXV/HOO+9gZGQEzc3NaG5u9nggBXjXR0YQ8VLrj64OpJqbm6FWqxEfH68IyPFCrvViyBLpkwJbuNLoaCwmJqJw8aKyjBSh9pFMxoEDDThwoAGzsyHgOBM4jsG1a5dw4waf36JpFmazye5Idch+L4KIV7a2FoTh4XicPHkXJ0/eQ0cH37/19OkhPHrE0wB50h2H4OB54XUEyPFJIOJJfuvQoadobNyHjz56BRRlw4cfvir0bzEMi9TUbklCnKvSYs/Xx1P7nEuLxfmtCxduoq0tCxzHoL7+COrq+ALdrS0VFhYCZEAO9oaIFztSR448wpEjjzAxESGAFz744HPw8VlDXp4VNM2BZZWVFgNAa2u2HREvf/BZXvbDyEgcjh17gJMna9HamgOOo/HgwXHcv38ScXFD4Pu3LA6OGsfRbkuLpSQXEc/nt+pQWFiHhob9uHbtZWxtqfH++5+HTrci9G8lJvZLHiRsbGjQ0rK7tNiTOI6WRMTz+a1OZGR02g9E+MOWu3eLcPcufyii0WiwsrIia12GlBaXlZXJvjYpRLwzDVC8LmM0GkHT9CeekSJaW1vDyMgIDh8+jJMnT8JqtYJlWbfrMgA/xLgrLZaSXGofyW+dPHkSDQ0N+Pjjj7G+vo7f/va3svJbe0XEO68/EkcnLy/PIb9VVVWFqiq+lFuv12N9fd1huFWH+yP0d1/BzF+osD62D34Dt+Cz1IHZ0BAMJCWh6J4ZM4b/FUjLQOhbfw5Kr3V5bVKOVHFxMU6fPo3+/n7BTSIES5JN8iYj5Q0ifmtrC6Ojo8jPz8eJEyd20QCl8luAdxkpueuPUVFRKC0tRXFxMZ4+fYqbN29idXUVb731lpDfYhgGERERLj+Tt4h4vV6/a/3Rx8cHDMOAYRjMz88LjtuNGzdAURRsNhuCgoKwubkpy40RlxZ7g4gnjlRsbKyDm0TyW2FhYQ73kTfDptL1R4qiMDY2hv379+P48eOS9RQ0TSMjI8NhGCWO1PNGxDsfSD158gQVFRUvgBfPUS+GLHzyYAtXYlkaavWm4oyUK0cqJGQWJ0/ew4kTfH6LdEtZrQYANkRGjmNsLBpxccOyVvIIIj4xUT4ifseR4qBWbyEnpw05OXx+i7hJ1dWlqK4usXdLcQgLm1RUWgzsrK0pRcT39qZCp1vB3/3ddzEyEgeWpWG17uS3dvq3xoTXeCotltJORso9Il6j2YTBYIXBYMXSkh9+9rNvYnVVh7q643j4sNCe32KRk9Mqmd8CdoZNZYj4VJeI+MjISZSUVKO4uAZ9fcl2x42nAQI2REWNYWYmVFit86Sd9UclGamd9Uc+v2WGyWTG4mKA4LiVl59HRcVZZGZ22O+jKbsjpQzIQTJSShDxAwOJ8PFZw9///XcwOJgorIE2NOQjJGTGTi9kHQ4NPJUWS2lpyQ+dnRk4cuShW0Q8n99qwr59TZifD8Kbb34dKyuhqK2txYMHDzyuywA7pcVGe7eRHPX390si4sXrMs644ydPnoCiKERFRWFpaUl2TooAErxBxDMM45DfmpmZER5wrl275vCAExISgqGhIdmlxYDj+qNcRDxFURgZGYFGo8Hf//3fCzAI5/wWTdMOv6en0mIpLS8vy0LEi/NbU1NT+PWvf43FxUXcuXMHDx482EUD1CSGIOLmX2PlRgsWfpaNrZElPMtbB2zbSA0vhf8/nYZvSQYorXv3wpUjJc5vkW4pjuNQX1+Puro6UBSF6OhoAcUuRyQjpQQRLy4tdkUDFOe3yH2kpLQY8A4Rr1KpMDk5CbVajf/yX/6LgKh3l98CPJcWS0kuIj4oKAjHjh0TuqV+97vfYWFhATU1Nairq/OY3wK8y9oRRDypNCAS0wCd81t3796FSqWStf7pfH3eIuIZhpGspyA0QPGBVGBgoEtHypXEiHi5649qtRpzc3OKgRwv5F7/oYesfwuwhSttb6tgsfAZKdeUsN1iWQZ6/bJbR0qc3zp7tgKVlWV49OgIpqfD8eab3xDltziEhEg7bd4j4mlJR0qvX0V+/jPk5z/DzEwoSLfU1auvQKXaArANvX4Z29sqj/ktYKe02FtEvFa7iaSkfiQl9eP8+XK0t/P9W48eHcbDhyS/xWfclJQWE3mDiF9cDMDCQhDOnbuB9PRu4Tu6cmWHBkjTHFJSdvJbjhkpJYh42iMins9v9SIlpRcXLtxAZWUpnjw5jImJKPzkJ39jpwFyMBrNLgcUqdJiudcnhYgPCFjE0aP1OHq0HuPjUQIxsb09G2r1JgAbQkJmYbNRst5PXFosV+LSYl/fdaSndyE9vcshv1VbexK1tUVISBgATXMwGCzCWqic0mIii8WI7W21ovtofd0HCwtBOHMmDamppx1wxyR8TdO0w7qMp9JiVyKOlDtEvPO6THV1NZ4+fYqxsTF8//vf31WeKaW9ZKSk1h9DQ0N3rctYLBY0NzcLTkRkZCRsNpusB5uBgQHMzMygqKhI9rWJHSk/Pz+H/JaYBlhdXY3U1J1uKW+AHN6sP1IUhfn5eRQXFyM5OVlwk8j7E6ckOjoafq/R0H/WhO25VXT+8mdICQ5G8v/xl7LfS44jJc5vLS0tobq6Go2NjRgdHcV3vvMdj/ktAM8dEU9ogCUlJejt7QXHcUJ+iwx9Slbd9oqIDwoKEvJbCwsLguNWXl4u9G/RNI2srCyvgBwEEa/kPtLpdJifn8fJkyeRmJjokN8KDQ0V7iPxMED+PvIWEe/uPhLnt+bm5nD79m2wLIvR0VG88cYbkuvNzpIqLZZ7fc6OlKsDKVJPQeAYSrK1nwQi/oW803/YIevfCmzhSjsZKfkPT2trPmhtzcG+fU2yqX1q9TbGx6MQGjqN/+V/+RdR/5Y4v8UiL88q5LcA+UAOscbGYuyOlPv1x9DQGRQV3cXJk3cxMJCEt9/+cwBqXL78JygvXxS5SaMuBzwC5FCGiM+VRMTzNMAW5OW1YHnZDxYLyW+Vobq6FDYbhaysVmxsaGXlt/jrYxQj4sWOlL//MoqLa3D6tCMNkGX32fNbfE6IDGZKgRxKEfFa7QZmZsIQHDyLr33tTcGVrKg4h1u3pPNbgOfSYintZKTcO1JRUeM4c6YKJSXV6OlJxe9//2fY3lbh97//AoKDZwU3yV1Ozbm0WI52EPGO95E4vzU/T/JbDG7cuIjy8nPY3lYhJ6fVfpAg788vxzFeI+JNph4EBv6nXeWZJHwtXpeZn5+XXVpMJDcjJRZ54AoMDMRXvvIVYZjwtC4jdqTkanJy0iMi3nldpqOjAx988AEoisLvfvc7RERECDRAd84C6SPzJiPl/MCq1+uRn5+P/Px8TE9PO+S3rl+/js3NTUW9Z+T6vEXEMwyDoKAgJCUl4fz580J+69GjR3j48CGio6OF72h2YRYz83M4cUr+sCmFiPckf39/rK6uwt/fH1/60pdgNpthNptx5coV+Pj4CI6bOL8FeDckyEHEUxSF1NRUpKam4sKFC2htbcW1a9cAAO+88w5iY2OF70jsJjnLubRYjggi3vnPRmBgoEN+izhu7e3t8PHxwcbGBrKzsxUfWoSHhysaHMna2r59+xAaGirQAAkxkeS3EhIShMOW2dlZSUfKnbxBxAcHB2Nraws6nQ5f/OIXYbFYdtEAnQ+kgB0gh5L7yF1Gisj5QMpqtaK8nP+3/a233pJ1IAV8soj4F1Km/3BD1r8l2MKdWJaBVruOiAj52ZGWljzFGam5uR1EPE8DbMDBgw2YmQkR+reuXXtZ6N/iu6U6hYyUnNLinc9EK0LEUxT/wL+56YPXXnsfGs0WOI7GkyeHUF9P8lu8mxQUtJPfIo6UckQ87RER7+e3jIKCJygoeIKpqXBcv34BPT3paG/Pxeuvpwtukqv8FiBdWuxJrhwpMQ3w/PkbaG/PBt+/dRR1dceh0y1Drd5AfLz8Ad9bRDwpLQ4MXBTltyJF/Vvi/BaLlJQ+KCktJtoZEuStP6pUNqhUNmxs+ODll69ApdoGTwM8jnv3SH6LFYZXIk+lxa60g4jvdflrgoIWcOwYn98aG4tBRcVZ9PamorU1F2+88U9C/1Zi4oDLg4Sd0mJvEfHjAP47AOl1GZZlhXUZf39/qFQqJCcny36vtrY2rK2tKRp8xKXFYWFhHtdlGIZBXFycV0AOsv4oFxGvVqvh5+eHjY0NXLhwASqVChzHoaamBjU1NUhOThb6t8TDAHGk3Dkorq7PkyMVFhaGU6dOoaioCIODg6iqqkJ/fz9aW1vxne98R1gpcpXfAp4vIt45v0WcEkIDDAwMFNDacuVNRkrsSEVFRTnQAImbJM5vMQyDqKgol46UO8nN2hFptVqEhYVhY2MDZWVloCjKIb9F3KTs7GyH/JZ42PQGEe9u/TEqKgpnzpwRHLfbt29jcHAQra2t+N73viespbrKbwHeI+KlHClfX1+X+a3y8nIEBwdDpVIhKytL9vewV0R8QkICEhISXB5Ike8oNDRUAHIoyUgpXX/U6XSIjY3FxsYGTp8+Lfweng6ktre3YTab/00Q8S/kWf+hhqx/a7CFK62t+aK1NQdbW1r86EffQlJSH2iahcFghU636vJ1HEcjLGwKCQmDst/LbKYh5UiFhs7i5MlanDhRi6GheJD+reZmI3S6Fayu6lFYeA82G2StC4rXH5Uh4vnS4pycVmg0W8jJacXKCqEB0qiuPoPq6lJ7fotFbm6LV0OCN4j48PApLC/7Iy5uEGfP3rJn3HZogDv9W2MOr3NXWuxKOxkp1w/UWi2f3zMYmrG05AeW5WmJNpsK3//+39ndJA45Oa1uh4a9IOKdXcDIyAmUllajpKQGvb3JguPW1LQfAQELWFwMxPHj92S/DxkSvEXEGww8wZCmzVhYCIDFwtMAy8svCP1bNM0iO7tdAHIouY92EPF1stYRKQqIiRnF2povoqNHUFpaJUBFnj3LR2jotOBKOh9oKB02AaCvL1mEiO8CsA7A8cHfeV2mqakJd+/ehc1mww9+8ANZ6zLA7tJiOSJra+LBzNO6TEhICGZnZxUR5PaKiGcYBj4+PrtogB999JHQv0XTNNLT070CcsjNSBFRFIXExERsb28jMjISp0+fhhQN0GQy7cqEeZNtkYOI9/PzQ0FBAQoKCjA1NYWmpiY8ePBAuI+c81uuRIAc3makiMQ0QHH/1sOHD1FXV4eIiAhMTk7i2LHdKHlXEgM55GakgJ31x/3790On0+HIkSMCDdBsNuPy5ctCfothGCQnJysqLSZSiohXqVRIS0tDbW0twsLCUFRUBI7jcP/+fdy7d89lfgt4vhkpsUh+q7CwEGNjY2hqasLjx49hs9nw4x//WJIGKKXnhYh3PpAiK7KkniIuLg7Dw8MoLCzcE5BDjsj646FDh6DX64X1ZtK/ZbVa4efnJ3xHcXFx6O7u9mrY9AYR/0Ke9R/i2/z3Alu4ktWai60tLf7kT97F5CTfC/Txx5cc3KSMjE6o1TsujafSYimRjJQ7RDxFAQkJQ0hIGMLZsxXo7MzArVtldvjCCbS359jXrjgEB7seKJ1Li+VofZ1ff3R2pPT6FeTnP0V+/lNMT5P8FoOrV1/F9esvQadbRUDAgiL3Zi+I+PPnr4vyWzfR3s73bz16dAQPHx5DdPSonZhohr//ouzSYrFIRkouIt7ffxkBAUuw2VR45ZUPMDkZYXeTxPktFikpvQ6Om6fSYnfXxyPipR0pirIhNbUXqal8fqu1NRu3bxcDsOH+/RPo6koH6d9yNzw9T0R8YOAijh59iKNHH2JsLAqkW6q9PRu+vqvw9V2Dn9+iQiCHN+uPERgZiUNZWTkyMrqQkdEl1CPw+a0i1Naesue3WBiNzdDpVkVADs+ESSKWpUWI+A0ATwG4zncEBwcjIiICNpsNFy5cwNTU1K51GYZhEB8f7/BA4a602J08OVJS6zKkXPT+/fvo7+8X3CR3p/3eIuJJRkrsSIlpgENDQ8IDTnNzM/z8/ODj4wO9Xq8IyCE1bHoScaRKS0uRm5uL3Nxch/wWoQGmpqaCYRjk5uZCq9VKOlKepBQRT1bIbDYbSktLMT09LVxXYGCg4Eo6/9zFjpTS+8jd+qNWq4XRaITRaMTS0hIsFgsePHgAAKirq8PY2JgkDdBZe0XEi+9RQgOUym8FBwdDo9FAp9N5NWx6i4gn7szCwoJD/5az46ZWqwVHSumwKXf9kaIoxMTEIC0tDY8ePUJRURGmp6cFGmBoaKhwvc6DChk2nzci3tfXF/v378f+/fsxNzcnQFcAoL6+HjMzM7IOpLxFxJvNZgdEvHi9mRxIsSwrHEiFh4dDo9HAx8fHKyDHi1XB56//qYesf0+whTtxHIOwsCnk5raColoFGiBxk6xWA/T6ZcEpiYsb8iojpRQRr1ZvITOzA9eufQaZme3Izm4DxzGoqSlBTU0JUlJ4GiAf+Hf8DtyVFrsSyUi5e2ANC5vBqVN3UVR0F4ODCXj6NB8cxwCg8N3v/oPITXKd3yJ9ZN4i4sWlxXx+y4q8PKtDfquysgxVVaWIiRnFwkKQIpDCTkbKO0Q8TZtBUTYUF0vnt0g2KSpqQgByKBkSxscJIl4etU+r3YDB0IyqqjNITe1GVlYHOI5GRcV5kZvEITu7dVcmbGfYfL6I+OjocZw5U4mSkir09qbi2bMDduomhR/84L8IbpKnDJ1zabEccRyzy5HiaYAs9u1jMT8fJPRv3bjxEsrLzyM+fhBzcyE4deq27PeRRsTfgbshi78+/kH44MGDUKlUstZl5JYWiyUnIyWWTqfD/v37ce/ePSQlJSE9PR3i8kxX6zLkM3mDiF9bW3P5mSiKElaKSH6rsbER7e3833k//elPhe/IUzEux+2UFssVy/J/ZsVra67yWx9++CGuX7+OxMREzMzMKBoSxOuPShDxpLT46NGjUKlUQn6LZVnJ/FZgYKCkI+VJMzMzGBgYkL3+6O/vj4KCAjx+/BhxcXFIS0sDx3G7aIApKSm7fj9vEPGdnZ1u1x+l8luNjY1Cv9PPf/5zoX/LXX4LeH6I+MDAQBQWFgpuEnHc2tvb4evri5SUFExNTeHIkSOy30c8bMrNSJHrI66NWq2WpAGS/JbRaIRer/eqR0opIj44OBjHjx93cPDlHEgBrkuL3cnT+qPUgVRTUxMGBnhA1zvvvAOpegopiUuLX+j56n/aIevfG2zhSnNzQejtTcGpUzuOlJgGWFZWga6uDLAsg4aGg3jy5DDCwyexsqJDbOyQotLivSDi9+9vRG5uq5DfIm7SRx+9LPRvMQyL9PQu+8OdvNJisTiOlo2IpyggMXEQ/f1JACicP/8xenrS8fjxYdTXExog378VFLTg8NodIIe3iHhpR0qc35qcDLdnpfh/hD7++DPo6soATbNITe1xmd8CdpcWy5EUIt45v9XWlg2OY1BXV4gHD44jJmYEi4v+iI4eUVRa7N36444jZTQ248iReoyPRwpu0uXLn4Ov7ypyc61gGA7JyX3Y3NTILi0WSwkiXqWyIS2tG+PjUbBajSgpqURvbyru3z+Be/eKEB8/CNK/5fxzd1da7Er8+qPJrSMVFDSPY8ceoLDwAcbGYsCyDJ4+zQcAVFScw+BgAhiGQ0KC6/wW4AoRfwfAf3P5mqWlJXR0dAgPxoDndZmkpCTMzc0hMjLyE81IATuOFDl1dy7PlFqXIdkWJUAOcn0BAQGyHCm1Wo2cnBwsLCygvb0dJ06cQF9fn5DfSklJER5wnAcVd6XFrkTWH9PS0lw6Us75LZZl0dTUBACoqanBxMSE0L/lTuLSYrkijpS4tFic31paWhKcLZLfSktLw8zMDCIiIj6RPjKxiCN16dIl7N+/X8hvEWJiU1OTQOajaRpRUVEO1D6lfWRyEfFarRYmkwnr6+vo6enB4cOH0dfXh/LyclRUVLjMbwG8I/VJIOKjo6OF/FZPT4/g3AK8mzw/Pw+GYTyW1XqLiG9ra8P+/fuFgxPxevP8/LxwkEDyW1lZWZiamkJoaKgiIIc364+jo6OYnJzExYsXkZ+f79C/5epASm5psdT1yV1/JPUUKpUKAwMDOHDgAPr6+mQdSMkBcryQ9/qfbsj6tIAtXMlVRopIrd5GVlY7srLasbqqg9Wah6dP8zE1FYHl5QD86ldfEdwkd/mtvSDinUuLQ0NnUVRUi5Mnd+e3/P0XER09qhjIMT8fZM9IyUfEAzuOVEHBUxQUPMXysl7ISVVVnUFVVam9W4pDbm4LfHzWRUAO+UPCDiJe3uATETGF48cf4OHDo8jKaoO//yKs1p38FiEmRkfvpsS5Ki12J0+IeK12E0ZjM4zGZiwt+cNsNqKh4SAWF4OwtBSA3/zmi5I0QGdJlRbLEcftLi2OippAaWkViour0deXAo7jO8qamg4gOHgW0dGjikuL94qIP378AY4ff4CFhUChf+vmzQuoqOAdN4ZhkZXVDo1mU3ZpsVg7Gakqj7+W5LfCwyfR0LAfaWl98PdfBsvuw7NnhxAaOi24klKHLRzHSAA5HkAql0VksVhgs9lcPlBLrcs0NjZibm4OFEXhvffek7Uu4y0injhShKbnTAPs7Ox0yG+Fh4cjJibGrSMlJW8R8aS0mFAZpfJbOTk5Qn6LwDQAZUOCEkQ8yW/FxsbCYrEgPj4efn5+svJbgOvSYnfytP5I3KSCggJMTk4KD6ULCwtQq9W4evWqJA3QWVKlxXLk7EiJ81vi/q26ujo8ePAAMTExiImJUQzkUJqRIiJAjrNnz4KiKCG/xXEcOjo64Ovri9zcXCG/RWAagLIhQQkiXqVSIT09HSkpKejo6EBoaCj0er2Q34qPjxfcJCnAAhkSlEBQPK2tBQUF4fjx40L/FvmOlpeXodFocP36dVn5LW8R8c6OlLObRBw38YFUTEzMnoAc3iDiSQZO6kCKwHLi4uJAUZSs0uIX8l7/Uw1ZnxawhSvZbPwQk5jYj9BQz46UTreKAwcaMD4eibGxKBw79gBWqwHXrl0S3CSaZu35LcchsKsr3WtEPMNII+Kd81sdHRngOAYtLfxKzrVrlwQaoLv8FuBYWixXo6PRuxDxfn4rOHToKQ4deorp6TCQbqkPP3wV169fRHZ2Kzo7M5CRoay02DtEfA42N31QWPgAycn9uHDhJtrassBxDOrrj6CujuS3WJhMZgQGLsouLd59ffIR8f7+Szhy5BEWFoIwORmOgoLHaGnJc6IBckhJ6d11De5Ki11pY0OLlpZcl46USmVDamoPUlN77PmtHHAc33UFAJWVZwQ3ydNg5w0ifnx8NyI+MHABhYUPUVj4EGNj0Q79W76+qzAYmtHamo20NGWlxTsZKaWIeB2OH3+A1NQeh/zW3btFuHv3FBIT+8H3bzVDr1/B0tIOkMPRNV2Gu1wWx3GIiYmRVcQZHByMEydOYH19Hffv38e+ffvQ1tYmrMuQf7yl1mVclRa7E1lby8vLk3Sk1Go1srOzkZ2dLazLkAcKAKitrcXc3JysdRlvEPFTU1O7Soud81vkeiwWC/z9/WE0GmG1WhVnpLxFxK+treHEiRPIyMjA8vLyrvwW6ZYirp9SIIf4+uQi4iMiIgQcem1tLXJzc9Ha2upAA6RpWtIl9TYj5W79UZzfWlxcFIiJxAV8/Pgx1tbWPOa3AGkghycRR0qMiCf5reLiYsn8lslkgsViUVRaDHiHiO/q6sLKygpefvllZGdnO+S3bt68iYqKCqHsPCsrCxqNRnZpsbPkIuIpikJsbCxiY2Oh0+lw584dpKWlycpvAfKAHM4S90hJOVJkvXn//v2YnZ0VvqPHjx8Ln42QNz19J95kpKQcKakDqWfPnuHx48cIDw8HTdOKS4tfSJn+pxiyPm1gC1caGYnF5GQkLl68Jvs1xJHKzm5HcfFtnD59G8PD8WBZGs3NfH7Lz28JRqMFNM0iLm4YFMUPCZ5Ki51FEPFynAS1egs5OW2IixtBS0suMjPbsLqqR01NqT2/Rfq3Wnblt9yVFrsTyzJuEfFhYdM4deoOioruYGAgUVhNW1/3RX9/Mm7dKgPfvzUm+XoicWmxsoyUY2mxRrMJg8EKg8GKpSU/NDcbwbIMKivPoqrqDNLSuqHXLysuLd4LIj4zsxPnzlXg7Nlb6OtLBsvu0ACDguaEbFJk5IT9M3kuLXZWa2uO3ZHyPPhotRswmcxITe3BG2/8V6SmdmNlxQ/l5eed3KQ2yYGN4xjExQ0pQsRLZaTEio4eQ1lZJUpLq9DTkwpCA9zc1GJkJBa3b58GTbMe711xabEyRLyjI+Wc3+I4vn/r+vWXUF5+DpmZHdDpVtwMm3cgNWRNTk5ieHgYZWVlsq+NrK2lp6fj0qVL2NraEtZlGhsbBTeJPCiTU2I5pcXO8pSREousy2RnZ+ONN95AQkIClpaWcO3aNQfccXp6uuQDjreIeEDakRLnt86dO4eOjg5wHIcnT55ge5s/ELt//z5MJpNHR+Z5IeL9/Pxw6NAhHDp0CFNTU0LuhuS3cnNz4evrqzhrNz09rSgjBTjSH1977TVsbm4KblJ9fT3q6uoQExMjOG4BAQEAvMtIKUHEBwQE4MiRI2AYBq+//jqio6MxMTEhK78FuC4tdid39xGhAaalpQn5LY7jBIqjzWbDo0ePZOW3vEXEsyzrUFrsnN8i/VttbW3Q6XTCoYY3QI7e3l7F648WiwVJSUn4whe+IJnfSkxMBOmWIsMRofYpHTblOlIhISE4ceIEDh06hNdffx3h4eFC9YJzPYWr++h5IuKdD6TIYcvt23zmV0nW7oWU6Y96yPq0gi1cieMYxRkp59JiPr81hPj4HRogxzF49uwgHj/m81sGQzNaWnKwf3+TA6HQ8/XxGamEBM8ZqZ3X8I7UuXMVCAubxswMoQHS+OijV3DjxkXk5LSCpjmkp3dBpdqWXVoslhJEPEUBSUkDSEoawOqqL9rbs5CU1IdHjw7j4UOS3+Idt8DAhV2vd1Va7E4LC4Ho6Ul16Uj5+y+joOAxCgoeY3IyQviO5uZCQFHbuHfvhN1Ncp/fArzLSPX0OCLi+fxWL1JSeBogn9+iUVd3DA8enEBs7DDy8ixobs6DySS/tBjYWX9Ugog3m40AVLhw4SYiIiYxPh4luEkdHVnw9V0V+reSk/tBUTaMj0cqAnIAOxkpOeuPKpUN6endSE/vhs0GWK15iI4ex717J1BbS/JbPA1QKrfnqrTYncSOlNR9FBQ0j+PHH+DYsQcYHeXzWxaLCUtLAaCobTx5UgCaZpGQMCg6JLoDqVwWy7KKM1J9fX0OjpRU+Np5XcZoNLp1pFyJOBtKEfE2mw0XL15EVFSUsC4jpgGSB5zY2FhQFKUYyAE4rj96cqRIfisnJwdXrlyBxWJBcHAwqqurUV1d7Ta/BbguLXYnT45UeHg4Tp8+jVOnTmFgYAAcx6G5uRmrq6vCSqNKpZI1dD4PRLxGo4HBYIDBYBBogBzH4datW6isrERaWhqMRiMsFotiIIc3iHir1Yrt7W289NJLiI2N3eUmkfwWwzCIjIwEIK+02FlyMlJEPj4+gjvz4Ycfwmw2w9fXdxcNMCsrS9Jx2wsi3pUjFR0djbKyMpSWlgr5LbPZjI2NDahUKrS3t0Ov13vMbwHwam3N2ZFyrqcgbtL169eF/JbRaATHcYpKiwHvEPEtLS3Y2trCSy+9hLi4uF31FMRNomla+PnPzc0pzkgpQcTrdDocPHgQBw8exNWrV8GyrCIgxwsp0x/tkPVpBVu4Ej8kGO0ZKddZKmdxHOPSkVKrt5Gd3Y7sbD6/1dycB4KEBoDBwQQ0NOy357fcD47i0mJliHjH0uLQ0BkUFd3FyZN3MTSUIHRLWSwm+Psvwmg0Y3nZDxQlv7QYALq7UxUj4tfWfNDeng2a5vDSSx875bfKnPq3WuHjsw5AXmmxszxlpMSKiJhEcXEN8vKa8bOf/TXi4wfR2poj0ACJmxQVtTu/tb1NwWJxD+SQ0k5Gavf6o1a7AaPRAqPRgsVFf1gsfDapupp3OMbHo2CxGCVpgM4SlxYrXX8UI+KjosZx5kwVSkqq0dubAo7j76PGRj6/ZTJxWFryt2ekvAFyyKc/bmxo0daWA5PJgpdfvmrPb/E0wJs3L6KigneTaJrkt7bsn8lzabGz5CLiKQqIjR1FbOwo9u9vwE9/+jeIjh5FU9M+PH16CGFhUzCZ+OqFsLDduSyxI0VcAjlyzkiJRdykAwcOOKzL3LjBO64zMzNoa2uTtS7zvBDx7tZlIiIiBHy10mFzYGDAK0R8e3s7DAYDPvvZzzrQAF3ltwB+2PRUWuwsuYh4iqKQlJSEpKQkHD58GD/+8Y8RHh4u5LecaYDOclVa7Ekcx7lExPv7++Pw4cM4fPiwkN/iOA5Xr14FwN8b3d3dHvNbgPeIeJZlBUfKmQbY1tYGlmWF/FZsbKxwHwHKgRxyM1JEW1tbaG9vR25uLj73uc9J0gBJ/1ZSUpLwoK4EyEFktVplrT+S/FZ6ejqOHTuGn/zkJwgODpad3xJnpLxZf5QaEggNkOS3yGFLS0sLAGB9fR0DAwMe81uAY0bKG0Q8eQ+pA6nbt2/j9u3bSEpKAk3TmJ+fBwBFK6feIuI7OjqQnZ2tqLT4hZTpj27I+rSDLVxpJyMlPztCSov37Wv06EjpdKs4eLABBw824M03v4bp6XBsbGhx7drLDv1b6em781uAZyCHlEZHYzAxESXpSPH5rUEkJAzi3LlydHRkguNoPH16CFtbGvj4rKGh4SBMJg7BwfMe34uUFu8FES/Ob01NkfwWgw8//CyuX19Hbm4LMjI6FJcW89dHy85IiV+jUm3hC194F1rtOtrbeTepvv4o6up4GiDp3yJkOuJI0bR8wt36Op+RkoOIDwjg81tHjjzCL37xlxgfj8bCQiAuXxbnt1ikpPRJDlGuSovdyZ0jxdMAe5CW1oMLF67b81sMHjw4DptNBV/fVVgsBnt+y/PQuYOIb5V9fc6lxXx+qw6FhXUYHY0W1lLb2nKg060gL68ZmZnt6OjIUAzkYFnliHiLhQdyfPGLv4VWu4GWllywLIO7d0/h7t3T9vzWhzAYPiOc3BJHqqSkRPb7bGxswGq1ynKkyLrM8ePH8atf/Uo4cX733XdlrcuQIeF5IeJdrcvU1NQA4AfEzs5Ol26Ss8j6o1JEvNiRcqYBEoqbOL+VnZ2N9vZ2r4ZNpYh4kmX78z//c2g0ml00wNTUVIf8FiCvtNhZnjJSYpH81unTp/GrX/0Kw8PDGB4exttvvy3ktxiGcZkp3AsiXsqRcpXfqqjgM6t6vR6Dg4Pw9/f3mN8CdobNvSDixTRA4rhZLBY0NjYiODhYoBN6C+RQiohvbeX/bv3Sl74EtVoNs9kMlmVd5rcA7zJSrvrInCXOb5WVleGtt97C0NAQ+vr68Itf/GIXDVBKUqXFnkQQ8VKOlPOBFDlI+Phj/llKr9djfHwcQUFBsn5e3iDivSktfiHl+qMasj7tYAt32slIdcp+jdWaKzsjRTQ3F4yhoQScOnXH7iY50gD5/BbfLRUby+e35JQWS3+m3T1SUuLzW63IyWlFc3Me/vCHzyMwcAHV1aWori6xu0kccnOt8PVd3/V6V6XFcq7PFSI+PHwap0/fwalTO/kt4nIBvCMzNhaN6Gj3+S3AsbRYrqQcKYOhGQZDM5aW/AQ36dats6isPIP09C7QNIf29kx7Rkr+sOktIn5wMBHHj9/H6dO30dubDNK/5Sq/BXguLZbSzn3k3pHy8dkATZtB02ZYLHm4fPnz0OlWUF5+wal/q01ymHRVWizn+nhHajciPiZmDDExt1BaWomenjRwHL/i2NDAI9jX1nSYmgqTlT0kpcV7RcTv29eEffuaMDcXBLOZX0u9fr0F5eXtyMrKAk3TaGlpgY+PzyeWkSJaXl7G4OAgjhw5guLiYlnrMsAOkOOTQMSL12UsFgsuX74MtVotuEme8luuSovlXJ+UI0VogImJiUL/FslvPXr0CAB/6jw/Py/LLfIWEe/sSDnnt8T9W7m5uaBpGlarVVFpMaAsI0W0urqKoaEh5Ofno6SkRMhvPXz40GV+C1AG5BC/BvC8tkbyW0eOHIHZbMYHH3wAm82Gy5cvy8pvyR0SpK5PypFyld8ibhLAHzYsLS15zG8BjqXFSu8jsSNF8luEBuic32IYBhaLxaseKaXrj+vr6xgeHsaBAwdQUlKya71ZKr8FeC4tlpLc9ceQkBCcPHkSJ06cEP6MbW1t4d13391VTyH1c9gLIl6n0ylaf3wh5fqjGLL+WMAWrrS66ouWllwEBc2jszNdkgYoJVJaHB8/KPu9xKXFzjRAPr9F49mzfDx+fAQREROgaQ4xMaOKSosBfv3RbFaOiCen/d/85k/sIX7eTbp69RVcv07yWyzS07uhsruLOxkpZYj4np5Uj4h4cX7r3Lly/OAHf4v1dR+w7D40Nh600wA5Ow1wd34LkD9siuXOkfL3X8bhw49x+DCf3yLZpA8+eA2ADWFhU+jvT0RKSq/H/BZ/fbQdyKF8/ZGmWVCUDampvUhN7bXTAEn/1k5+iweKjNodKWVADo5Tjojv7ORzWn/zNz+yUyV5N4nQAPPymsEwHJKS+gUnaQfIoQQR74+urnQUFrp3pPj8VhfS07tw8eJ1/PjHf42VFT88fZqPp08PISFhwE4DtLjMFBIgx/NCxAcHz+P48fs4duw+RkdfAcv+lcO6THh4OMbGxiRpgNLXxynOSIlLi13lt5zXZWJiYjA0NKQYyOENIr6npwdarRbf+ta3MDExIbgArvJbgPfDphxEPBlYcnNzsbKygn/5l3/B0tISHj16hEePHjm4Sa5coL0g4qUcKef8FumWIu8TERGB2dlZ2QMxKS1WsrYmdqTEbpJUfis9PR2k68obIIc3iPiBgQFoNBr83d/9HUZGRhzyW4QGSNO0kN8CPJcWS2llZUWWIyXOby0sLOAXv/gFFhYW8PDhQzx69Mihf8sVInwviPijR4/u+n8Ei19aWoru7m5h4GpoaABFUQgPD8fS0pLsgXOviHjnegriuInzW+Q+UlJaDCjLSBFRFIWRkRGo1Wp861vfEvKkng6kCJBDictGACEMwyhCxL+Qcn2qv90/NrCFK7W05GFrS4OVFT3effc/wc9vCQaDBQzDIS5uSHIIkCot9iSSkZJCxKvVW8jObkN2dhtWVnT2DicaNTVkXWgbW1sqrK357qIBSmkHyKFk/dHHXlrMI+LDwmZw6tRdFBXdxeAgyW8ZhfwW6ZZqamIUAzm8QcRPToZjfj4EFy5ch8HQDIuFd7YqK8tQVcXntxiGRU5OC3x8eFqcnNJiKZGMlCdHKiJiEiUlNSguvo2amtO4f/8kFhaC8PbbX0Zg4DxIb5Kr9bKFhUCvEfG8I+W4/sjTAC0wmUh+i88mVVScB2ADYINGs4mNDY0st6i3N8VrRLzBwDtS0dHjOHOmEiUlVejtTQXH0bBYTGhsPIjg4FnhO9oBcnguLSbyZv1xbi4Yc3OhOHu2HHl5zfb8FoMbNy6ivPwcsrLaQdMcMjN38luOjpQSRDzjERHP57duITb29ygrK0N1dTXq6uowOzuLn//857LWZaRKi+XIFbXP3boMeZDR6/XY2tqStS6zF0Q8GVgIDVDsJjnnt2iaFhwpOaXFRN6sPy4vL2N2dhalpaXIzc11yCaJ3aS0tDThZ6IEyCGWu4wUkTi/df78edTU1ODhw4eYmprCT3/6U4/5LWAnI/W8EPHi/BYZkomrRO6bkJAQ2Gw2WQ/I3iLixY6UOL8lpgHev38fsbGxYBhGgC98Uhkp5+ubnZ1FcXExsrKyZOW3lAA5xCLUPneOFMGYZ2RkYH19Hbdv30Z9fT0mJyfxwx/+EAkJCYKb5CortBdEvJQjJc5vkSGZHEiRtc/IyEjZ95G3GSmCiA8ICHB7IJWcnCzAcrwFcihdf3wh7/SpHbL+2MAW7sRxNMLCpvDXf/0jdHfzblJDw0E8ecLTAAnpLiRkVniNNxkpuYh4vX4VBw8+w8GDzzA1FYaf/eyvQFFAefkFVFWdEfq30tO7XDpuOxkpJYh46fVHigISEweRmCjObzF4/LgA9fVHAdiQmtqNhYUgBAV5zm/tHRHPuw0FBU9QUPAEU1PhIDTAK1c+C62Wz2/RNIvtbZUdyCF/2NxBxHvOSBFRlA3Dw/EICZnBX//1j9HenmV3kwrx4AHJb7EwmSzC2higDMhBNDYWhbGxGI+OFJ/fqseRI/UYHY3CL3/5NWxvq/Dxx5dQWVmG3FwrGIZDcrJ0fgsQD5vKEfHO3zmf3+pGWlq3Pb+VC46jcf/+cdy7dxKADWlpXVhZ0cseiElpsXgl0pPEpcUBAUs4dozPb42NxYBl+QGwtTUXOt0KDIZm0DSLrS217NJiop31RzmIeL4vS6UqxMTEBIKCgvDXf/3XkuWZ5B9v8eqJp9JiKclFxIvXZYaGhvD2229jc3MTV69eRWVlpcd1GcA7RHxbW5ukIyWmAa6srAgPODU1NUKGKz09HRsbG7Ipd6S0WOnaGkVRoGkagYGBDvkt0r9lNpvh7+8vOCXr6+teATnEw6YcaTQazMzMwN/fH9/85jeF74jkt0j/ljN23pthUy4iPjIyEiUlJUK31Lvvvovt7W1cvnwZlZWVwnfkrhPueSLitVotTCYTTCYTFhcXBRBMeXk5KioqYLPZkJ6eju3tbdmDwl4R8SEhIUJ+i9AASX4rJCREyLitrq56BeRQuv7o4+ODhYUF+Pn54etf/7pwH924ccPBTcrMzHRwXLwZNgki3p0jRVEU4uLiEBcXhzNnzqCrqwuXL18GRVF4//33ZR1IAd5lpFwh4l0dSF27dg03btzA9va2okEd2CktVoKIfyHv9Kkbsv5YwRauNDcXjN7eVJw6VQONZhtZWe3IyuJpgFZrHjiOxu3bJbh9uwTJyb32bFIzWJZBUlKfrNJiIm8Q8dPTYdjY8MXnP/8uAgMXhf4tkt8iblJs7IjgqHkqLXZ3fZ4cKY1mC7m5rcjNbcXKih4ffXQJra256OlJx3e+8w8iGmCLZH4LwJ4Q8bwj5bjOFR4+hdOnb+PUqdsYGEgSiIkcx0Cj2YBaveEwIHtSS0uOA5BDjggi/sSJe/Dx2YDR2AyjsRlLS4QGSOPWrXOorCyz57dY5OS0wTsgh7yMlFjLywFYX/fFa6+9D3//ZXAcDavVgKamHRogw3AOWS1nR0r+9XlGxPP5LZ6ut7AQiI8/voj29hx0d2fgjTf+0Z7fYpGd3e5y0JUqLfYk3pGidzlSFAXExIwiJmYUZ85Uobt7p3/r2bN8+PisQaXalCRKupJyRPwdLC7S6OzsRGFhoUN55tzcnIObdPPmTYcHHJKRklNaTESGBKPRKOvXUxSFra0trK+v4+WXX4Zer5eV31IC5HC+vsDAQLeOlF6vF/JbMzMzuHHjBjo7O9HV1YXXX39dkgboLKnSYk8SZ6TErpA4vyXu3yI0QJ1OB5VKpejhaa+I+ICAABQUFKCgoABTU1NCb9KVK1eg1WodskmfZEaKiKIoaDQarK+v46WXXoKvry84jhNogDExMYKbJM5vKQFyOF+fJ0cqICAAR48exdGjRzE+Po5bt26hq6sLXV1deOONN5CbmwuGYZCcnOxyAHieiHgxDfDixYu78lv+/v6gKErRarA3GSmxIxUaGopjx4459G9ZLBa0trZCp9PBYDCApmkkJibCGyCHUkS8Wq1GQEAA1tfXcfbsWeE+8nQg5am02JXkOFLiA6nh4WFUV1ejp6cHnZ2d+Pa3vy0Uwrs7kJIqLX6hT06fqiFreVOFC9e+/EcJtnAlPiOFXQ9COt0qDhxowIEDDZidDQEpGL127RJu3LiArS0NDh16hK0tlaz81l4R8VlZHVCrt+w0wAp0dPD9W0+f5uPRI5Lf4h23np5UuyOlPCNVVOQ+IyWWTreC6ekwJCQM4NVXrwhu0tWrr+L69ZfsbhKHtLSd/BbgubRYSjuIeNefic9v9SMpqR/nz9+E1ZqHDz98BTYb8K//+lf2/BZrz28tuvx9nEuL5UickRLL338Jhw8/wuHDjzAxESE8uH/wweeg1a5jY8MHBQWPYLNRstYFyfojn5FSsv5IqH18aXBqao89v5UDjqPx4MFx3L9/EnFxQ6BpDkajBd3daZKOlDstLipHxAcGLmB+PhhxcUO4dOkjIeNG8lvETUpKGnD4PT2VFkuptzfZIyJepdpGRkYXMjK6sLbmA4vFiOvXX4LNRuGnP/3P9vwW37/lLu+oHBF/BxZLMWw2264HjeDgYIEGSNZlzGYzWlpaoNPpsLq6ioKCAtnrMt5mpFiWFaABPj4+Ag3Q3bpMV1eX4owUQcR7ykiJFRoaipWVFURFReEzn/mM4CaJaYAMwyAmJsbhO/I2I+XJkRLnt5aXl2E2mwWH5Ic//KGs/Ba5Pm8R8c7feXh4uEAD7O/vB+nfIjmspaUlHD58eE9ADjki649GoxG+vr6SNMBbt24J+a2cnBx0dXV5lZEiiHi5blRUVBQ2NjYQHh6O8+fPw2w278pvMQyDiIiIXZ8JUJaRkoOId85vsSyLmpoa2Gw2/OhHP5KkAUrJubRYjqQcKYqihPzWmTNnhPwWy7J49uwZgoODMTc359V9lJSU5NaBkvpMarUaDMNAr9e7PJAisJyMjAyvqH1KEfEURSE+Ph42mw2hoaEoKyuD2Wzetd5M3EuxvLmPXsh7faqGrM5Zf8zvccD69wBbuBLJSPGO1KzLXxcSMouTJ+/hxIl7GB6Ow7VrlzA2Fo0nTw6judkIo9ECmmYRFzfs8jPtDRHvWFrM0wDbkJPD57eIa1NTU4qamhLodKvw919UtEIlBnLIFXGkLl78GGFh0zh16g6Kiu5gcDBRcNzMZhoBAQsCMTEyclwAcngqLXa8Pn79US61T6PZhM1GwWZT4Qtf+I19UGZQWXkWVVVnkJbWbXeTWoX8FuDoSCnLSBFHyvX6Y2TkJEpKqlFcXIO+vmTcuHEeExNRePz4MFpbcwRX0h0e3Lm0WI7W1/m1NaPRsbSYz2+ZYTKZsbgYALOZJyaWl59HRcVZ6PUr0OuXEBc3LPu9vFl/HB+PEhDx0dFjKCurRGlpFXp6eDfJbDahoeEgQkJmBMctLGxadmmxWBzHZ6TkIuJ9fdfh67sOm02F1157D3NzfJn3jRsvobz8vD2/xSIzs8PBNV5cJKXFShDxD8BxrFtHSmpdprKyEqurq3j8+DG6urqEtSt3DyvOpcVytLm5CavVuova525d5ubNm9DpdNDr9UhMTJT9XnJ7pMQSI+JJfkvsJj19+hSPHj1CZGSk8IATFBTkVUZKKSLez88PgYGBsNlsuHTpkvAgePXqVYf+LXF+C/BcWuxKnhwpiqKQnJyM5ORknD9/Hu3t7aipqREgHn19fSC9Se6GcG8Q8WT90dmREtMASX6L4zh88MEH8PHxgV6vh06nUzRskiFByQOr2JEibhLp3xLnt+Li4oTvyM/PD94AOZQi4gMDA4Xs0blz5wQgRFtbG3x9fQU3SZzfAjyXFru7PneOlDi/RWANtbW1AIBHjx5haGhI+I7cuUZ7QcQ7O1LOB1LEcbNardDr9dDr9fD19VU8bO4FEU/Wm53rKWpqahwOpIgbpwTI8UJ706dqyMIeyYH/XmALVxoZicPkZCReesl9RoqIFIwuLgYgJ6cF+/Y1geMYPHt2EI8fi/NbHEJCHB06lmW8RsS7G8z0+lXk5z9Dfv4zzMyE4vHjQ/acFIU33vgnOw2QQ3p6l4ObJJZUabEcsSy9a/2Rz28NIDFxwJ7fygLH0Xj8+DDq6wsRHDyDpaUAZGTIz4p5j4jnqX2ZmR2gKKCg4AkmJ/n8ltlM48qV16DVrtu7pTikpPS4dKTcSSkinqJsSErqw8qKHzIz20HTZnAcLeS3eBogJ2SGHD+T69JiV2ptzfFIfwwIWMTRo/U4erQe4+NRePKEp+4BFL797X8U+reSk/vdDg3eIOJ3MlI7jhRPA+xGeno3Ll68bi+DZnD//gncu1eEiIgJzM8H4+TJu7LfxzEjJX/9kWVpBAbNITevBWqVDYWFD+z5LX4A3Mlv8bCchIQBr4AcExN+GBkZlU3tU6vVyMzMxI0bN5CamgqTySS5LmMwGHZlMDjOdWmxK7nKSInlvC7z7NkzNDY2AgC++93vylqXIdcnBeRwJylEvHN+izzgVFdXo7q6GjExMZidncWxY8dkv4+rYVPO9QUEBIBhGKhUKhQVFWFgYEBwk8xmMwICAgTHLTo62qthc3p6GoODg7KpfcRxq6qqQlJSEgwGA8Q0QFf5LWAnI/W8EfHO+a3GxkZhnez73/++4CaJaYBSEpcWy5WUk+Dj4yPktxYWFgTHjeS3EhISMD09LUntc6W9IuKJO1daWirktwgNMCQkRHC/wsPDvc5IKUHE+/r6gmEYYQAlMBhP+S3A+4yUu/VH8YFUWVkZurq60NTUJNBbf/rTn0quN0tpL4h48XcurqeYmZkRiInkQCopKUkxkOOF9qZP2ZDlnf69wRauRIaEvDz5a2vEkWIYPi+Snc3nt5qb88BxjFN+i0VenhUAn8+QU1osFkHEJyTIQ8SHhs7YV8gofO5zv0dvbxqamw0CDZC4STExIw6OGyktVo6Ip5GZ2eFyZYrPb7UgN7cFy8t6NDcbcOfOaQDAxx9/BlarwZ5xa4GPj3R+C9hdWixH8/OBkqXFERFTKC6+jdOn76C/PxEsy8BqNYBl9yEwcB5bWypERY0qAnJ4h4hPw+JiIPbt4+8Ro5HQAHk3qaLiHG7dcsxv2WyQXVrsfH3BwbOyEfFRUeP2PjYKly5dQV9fKpqbDWhsdJ3fAsSOlDJEvNnsHhHv47PukN8ym024d+8EAODGjYvo6MgCTXPIynKd3wJ2lxZ7EjcZjV8/KoB/ZyaaA9fx3V/9E2jdKL58qBEvpbbi7NkKnDlTie5uvn+LZffh2bNDCA2dxsaGBpGRYwrdZAYUpWxtTVxabDKZsH//fszOzgohfql1me3t7T1lpOTkQMi6zOAg/3fXuXPn0N/fL2tdxl1psSvZbDaYzeZdGSmx9Ho98vPzkZ+fj+npaXAch/r6egBARUWF4N64y28Bu0uL5UgKES+mAZ47dw7t7e0O+a2oqCisra0hPDxc8bAJKFs3EjtS+/btQ0FBASYnJwU36cqVK/Dx8RGIiSkpKdje3lYM5CDXJxcRT1EUUlNTMTU1BbPZjOLiYgwMDAj5rdjYWOE+cu6Wclda7EpyEPGBgYEO+S2WZfHkyRMAQFVVFYaHh3fRAKXkDSKeOFJiRLxzfovAcmpra1FbW4v4+HisrKwgNDRUUUZqL4j4l156CQcPHsSxY8cc+rfE+S2GYZCQkCBkpLwZNuVS+0g9xdLSElpaWnD8+HEMDAzsqqeQOpAijpS3iHhXGwWhoaEOQCGO49DY2AiVSqVo2HyhvemPesj6NIAtXGlriwcpKM9I7S4t1ulWcfBgAw4ebMDMTIhQMHrt2su4efMCoqLGsbmphckkv1/He0Q8X1psMLTAYGgR0QBpPH16CI8eHUVk5Dj4bikOwcHz8AbI0d2tDBHv57cCmuZw69ZZGAwcwsOnwXEMPvzwVYf+LT6/5eiUsKzr0mJX2kHES18fRdmQnNyP5OR+XLhwE21tWXjypAB9fSlYXg7Az372VyD9W2IaoLO8R8TTuxDxPA3wEY4ceYSJiUhR/9bn4OOzhpiYEfuwqay0mEfEy89IkeuLixvC/v0s9u9n7TTAHHAc45TfYmE0WuDvvwyWpRUDOQgivqxMHiI+MHABhw49wd27RcjObkFY2AzMZpPQ70b6txIT+3f9uXFXWizW5jaF/3a7DHfbUvG5Z9NYTqLwk//fmwidmsRdYyp+dekAvp1xDG+9/AdkhUwhI6MTGRmd9gqEPDx9mo+hoQQsLgbhF7/4Kvj+Lff5LZuN7yNLT592CPt7EslIiR2pkJAQt+sycXFxWFtbUzTMkYzUkSNHFK+txcTECBhvV+syDMM4rMvIKS0Wq7+/XxG1LywsDMePH8fDhw+Rnp6O0NBQWCwWj/kt8pmUIuLFfWRSIitjeXl5WF5eRnNzM549e4a5OX4j4p133hHyW+4GY28zUlKOVEREhEN+i/RvsSyLwMBAxMXFKR42SUbq0KFDXq0/Hj9+HBRFSea3xN1SWq3W64yUEkR8VFQUiouL0dDQgLi4OISEhAg0wODgYMEpcc5vkc+kFBFP+shcfSYfHx8wDAOGYTA/Pw+z2YzGxkZMT0+Doij8/ve/l5Xfel6IeIqiEBsbi9jYWCG/xbKskN8KDQ1FfHy8V0COtrY27N+/3ytEPBm8PR1IqdVqr+6jkZER2Y4URVFISEhAXFwcmpubkZiYqAjI8UJ70x/tkPVpAVu4UldXOpaX/RXBIVZX+YzU/v2uHanQ0FmcPFmLEydqMTQUL6wTAsDvf/9ngpsUG+s6vwV4h4gfHY3d5Ujx+a1W5OTwNEA+v0WjuroU1dUlSEnpxfBwLNLSuhSVFnMc7QUiPg+bm1ocPvwEiYkDOHXqDgYGEsFxPA2Q5LdINikmZkx2afHu62NkI+I1mk0YDFYMDSWgvz8RxcU1aGnJw61bZ1FZyee3+P6t1l0obuJIPW9EfGTkBEpLq1FSUoPe3mRwHAOW5dcOrlz5rOAmeXJKvFl/lHKkeBqgGTRtxsJCgNC/VV5+AbdunUV6eicGBhKRltalEMjBCEAOuSKI+CNHHiElpRelpZXo6UkT1kAbGvIREjID0r8VHj4tu7TYZgP+X9XnMHIvEDX/z8/xmy//JYKHhxE5wX/PJVw3Srhu/KHQgC9s/ymufO43SLL/Hefru459+5owORmOoaE4nDhxD62tubh+/SWn/q2OXX9/ECBHaek1AOsAPDtMGxsbaGlpQW5urtAVI5bUugwpYQWAGzdugGEYWesyZEjYKyLeeV2GOCUfffQRbty4gezsbPT09Lh1pKRE1h+VrK21t7djfX0dR48eRXp6ukP/1pMnTxzyWzRNIygoSHZpsdT1yUXE+/n54dChQ1hcXMTY2BgOHz6MtrY2fPjhhw79W6mpqbuuwV1psSt5QsSL81vibFJbG/9ntqqqChMTEzCZTB4PCLxdf3RGxDvntwgx8fLlywKYpaurC8nJyYoyUt4i4ldXV1FYWIisrCyH/i1CAxTnt/z9/WWXFjtLCbUvKCgIx44dw9bWFm7fvo39+/ejvb0dbW1t0Ol0Qv9WYmLiroME4kg9T0S8VH6LIOoB4P79+1hYWIDBYPA4ZIhLi+VKypESH0gNDw8L12O1WuHn5weDwYD29na3jpSU5PSROYusP+7bt0/2a15o7/qjG7I+TWALdyLUvowM+RkpMiTIeWClKCAhYQgBAYt48qQARiOH7W01nj3Lx+PHhAbIr0AFBzsOojYb795IlRa7k1RGSiy9fgX5+U+Rn/8U09N8gP/Zs3ysr+vQ3Z2Oy5dfA9+/1e0yvwXsLi2WK46jHRDxPA1wAElJAzh37qbQLfXo0WE8fFiIqKgxBAXNQfmwGW1HxMvLSAE7jlRWVgeOH3+A48cfYHIyAoSY+MEHr8HHZ03o30pJ6YVKZROGTblADkAZIp6ibEhN7UVExBSamhhkZ1uxtaVFXd0xPHhwwp7f4vu3pNbtXJUWu5MnRyowcBFHjz7E0aMPMTYWBY5j0Ni4H6urfujtTcVHH30GDMMhKcl9fmt9fa+IeN6R4vNbXUhP78LFi9fR0sI7brW1J1FbW4SEhAEEBs7LykjVjSThcUsCyv+fX2E5KAQjcXE4e3M3Iv5zdc0YDQ/E/xl+Gm9e+lD47wQRn5nZaV9LvY3RUT6/ZbGY0NKSB71+WSAmJiQMgqJ2gBw5ORyApwA8P9zIyUgRkXWZ+Ph4NDc3Iz09HZubmw7rMsRNknpA8gYRz7KsW0R8aGgoioqKcPLkSWFdhuM4rK2tYXBwEDdv3gTDMIiNjXW7piMeErzJSBFHSkwDlMpvpaamIiAgQPGQsBdEfFpaGs6dO4ezZ89iYGBAcJPItRPICRneCEhBaUZKriOl0WhgMBiQlpaGf/7nf0ZycjLW19eF/JaYBig1+O8FEe/K2YyMjERpaSlKSkrQ29srZNw2NjawubmJ6upq0DTtMb+1F0S8eP3RmQYo7t8ijltAQIBXGam9IOI/85nPYHt7W6ABkvxWaGiocB+Fh4cLn0mtVisaNjs7O2U7Ur6+vti3bx9ycnLwz//8z4K7fv369V35LakhlGVZxRkpd44UWW+Oj493OJBqaGjA1tYWNjc3UVtbK+tA6pNExL/Q89cf1ZD1aQNbuNLqqi9aWnJw4ECDwowUX1ocHy8/W8Y7UkBxcQ1CQ2cd8ls1NSWoqSlBSkoPaJpDXp4Vvr5rskuLxSI9Uvz6o2dHKixsBqdO3cXkZAQ6OrJgNJphtTrnt1jExIzuGpZ3SoufHyJeo9lCXl4L8vJIfssIlqXR2ZkFwIYbNy6C799qdZvfAhxLi+VKypGKiJhEcXENTp++jf7+JLAs7ZDfMhiaYbXmgaZZxX1k3iDiARXOnKlGePiUPb/Fu0kVFedx69ZZe7cUh+zsVmi1m7JLi8VyzEh5dqSio8dx5kwlFhf90dKSh5ycVlgsJjQ2HkRw8KzgJkkNea5Ki91pBxEv7Uj5+KyDYXiXb36ez29xHIOWFgMAG6qrS0DTrD2/tftn9tazA/j61afwX9vAQ5oGtb0Nk0X6PvpKZQMOf+abGF4KRJz/AoDdiHgCy4mNHUVZWSW6utLAcQyamvbh6dNDCAubgsHQjObmPBgMpLT4DuQMWRzHISgoSFFXDjk1LisrQ1RUlGR5pvO6jNzSYrFIRkoOIp6syyQkJGB9fR0WiwWpqam78ls0TUu6EkqGTSJPjpRUfovjOPT09AAAHjx4IEkDlNLzQMSL81uEBshxHB49eoSHDx8iKioKJpMJFovF64yUUkS8zWZDWVkZYmNjHfJbhAYo7t+iKEp2abFYcjJSRCS/lZqaCoqiwLIsYmNjBRpgbGys0L/lnN8C5AE5nOUJER8YGIjCwkKhW4oMNwsLC6AoCk+fPpWV3wK8u4+cHSlnN4k4biS/lZCQAKPRCLPZjJycHK+AHEqpfdvb2zh37hzi4uIwOjoqrDe3tLRAr9cLxMSEhARhxa+vr++5Z6SIyIFUVlYWPv74Y2EQlaqnkPp+XJUWu5NSRPwLPT/9UQxZn1awhStZrXnY3tagoyMLtbWLdhrgrNvXiEuLlWakxIh45/wW75Qw+Oijl3HjxgVkZ7dhc1MDlUpZRqqri2Sk5Ds+a2s+aGvjS4tfeuk6zp+/ac9vMXjypECU3+L7t4KC5gEoB3Lwr5GPiPfzW8GhQ/xK4c9+9k1kZHRgcjISH374WVy/vi70b6Wm7s5vuSstdn99rh0pPr/Vh+TkPpw/fxPt7dngOBqPHh2GzaZCb28KHj48ApPJ4ja/BfBAjr0h4vlhhc9v1ePIkXqMj0eCoM4vX/4cfH1XkZtrxcaGFhSlNCPlHSK+pSUPRqMZly5dw/q6Fq2tueA4GvfvH8e9eycRHz8I0r9FsmsEyOGutNhZZrNR9vpjUNACjh2rQ2ZmB37yk79BSkoPhobinfJbLBITB0BRwOKGD+6Op+DbdTdgoyiYaRoZnZ3wX5IGcgSsruOlJ2346Eguvml6LHwmV4h4lWobmZmdyMzsxNqaL1pacsGyjB3iQWFoKA5Pnx6EwXAPng5ASUaqsLDQq4wUcaScaYBS6zIbG/yKrDdADiWI+I2NDbS2tsJoNOKVV17BysqK4NqQ/FZKSooD7ph8Jk+lxc5Ssv4YFhaGU6dOwWg04kc/+hESEhLQ0dEBs9kMf39/BzfJ+aFP7Eg9L0S8c36LZJOqq6sBQFifk+PseYuIZ1nWYf1RnN/q6+sT1lKbmpoQFBQEk8mEtTX+8NVbIIdcbW1tobW1FXl5eXjttdewuLjo4CZVVFTsym8ByoAcRJ4yUmJFR0fjzJkzOHDgAH74wx8iOjpayG+FhIQIxETiJolls9nAsqzijBSh9kk5UoQGKM5vke8I4NfrWlpaJGmAznoeiHhxfkvsJjU1NeHp06cICwsDTdNe3UfeIOK3t7fR2tqKnJwcfP7zn5c8kBKXnZPP7Y0jRRDxL7qx/u31qR6yPs1gC3fiOAb+/gsIDp7F7dvFuH272E4D5JCX1wydbrcT56q02J08IeJDQ2dRVFSLkydrMTSUIHRLraz4Qa3exN27p0DTLGJjRzwOdmT90ZuMFHGkeBpgK3Jzd/JbLMuguvoMqqtLkZrag8zMdrsjpRTI4Q0innekXn31CvT6FQwM7LhJHMcgMHBeyLhFR48BkFda7KydjJRnRLxWyw+/BkMzfvWrL2N8PBo63Rpu3TqHykpHGqBzfgvwLiM1NkYQ8dKOVFTUBEpLq1BcXI2+vhRwHP8dra/7QqPZQH39UdA0i8hIz1j1ndJibxDx/J8NPr9FaIABgpt08+YFVFTwjltWVhu6urwBcvDrj3I+i/g1FLWNz33uMvT6FXR3k/4tPr8VGjoNk4lDZHo3QtdXEbC6jp6UFMwHB+NMpevSYgBI7Z/B2ByfQ1GCiPf1XcO+fU3Yt68Jb731JYyMxAGgcP36Z1BevomsrHdB0/tcrsuYzWbJ0mJ3cudIOa/LdHZ2OqzLaLVaNDQ0yFqXAbxDxLe3tzs4Unq93m1+KycnB1lZWejo6PAKyOEtIv7zn/889Hq9kN8S0wDF/VuAciAHsIOIl0KmO8vPzw8FBQUoKCjA22+/jYGBAayursrKbwHeZ6QGBwdRWlq6a6ikKAopKSlISUlxcNzq6upgs9ng4+MDq9UKo9EoC/Di7fqj2JEKCAhwoAESN+ny5cvw9fVFbm4ucnJy0NbW5hWQQykinrjJf/Znfwa9Xr8rvxUfHy/kt/z8/ADsADmUVA2Q9Uc51D6S3yosLMQ777wj3LfvvfeeQAOkaVoyvwVIlxZ7kjtEvEqlQmZmJjIzM7G2tiYctty5cwcAPyB2dXXJym8B7odNV3J2pJwPpEjZeXNzM/z8/GA0GpGbm4uWlhavgRwJCQmyX/NCz0ef2iHr0w62cKXZ2WD09aXg1KkaFBXV2ktq+YfAa9cuCW4STbPIyOiEWr0tu7TYWXIR8Xx+axAJCYNIT+/C73//BcTGDuPp03w8ekTyW7yb5JzfAlyXFnsSWX+UcqQc81thQjbp1q1zAICRkVh0dmbYaYDuB2zvEfGOpcVJSf1ISurH+fPl9vwWjUePjuDhw2OIjh4FTXMYGEjwIiOV6zAkyNH8fCD6+lJw8mQtTp++jcnJiF00wJ3+rV5hkOA4xmNpsbPkUvtUKhtSU3uQmtqDnBwr3n33iwgPn8SDB8dw//4JOw2Qs9MAd7szO6XFzw8RHxi4iMLChygsfIixsWjhO2pvzwYATE+Ho68vCUlJAx6HLXFpsVzxGSnH0uKMjC5kZHQJ2UI+v1UE1J7CYe0GnuTnoz8pCb6rq8hudV9avKFRwcc+UClFxAN8aXFfXwoKCx+gpKQao6OxYFkaFosfWlrahHUZhmEQHx8vPIzsJSPlyZFSq9XIzs5GdnY22tvb8bvf/Q7BwcGy12U2NjaeOyLeOb9FHnDIA+vi4iKGh4c95reAvSHixeuPJL9FaIAcx6GqqgpVVVVITU0FTdPo7e31Csixurqq6IF1eXkZvb29KCgoQFlZGfr7+4VsEvlexf1bRATI4Q0i3tN9pNVqYTAYBHjA7373O/j5+Qk0QE/5rc3NTVgslj1npMSKiopCaWmp0L8ldtwAfm1rcnJSkgborOeFiJfKb928eVNw3BiGQXd3t2IgB8lIKbmP1tbW0NfXh4MHD+Ls2bNCfktMAyTXKy7LVQLkEL+GfH538vX1xf79+wVwx+9+9ztotVrZ+S1XpcWexLKspCMlPpA6e/ascCBF1psB/uc8Ozsr60DKG0T8Cz0/feqGrD8WsIUrkYwUcaRCQmZx8uQ9nDhxD8PDcWBZBs3NRlitBvj5LcFotCAubtjuSH0k+328RcRbLCbo9cv4ylfewvq61k4DZFBTU2rPb5H+rRb42rNvckqLnTU3FyTbkQoLm8apU3dw8uQd/OAHf4eNDQ36+5PR3p6DgIAFkZu0O78F8I6U94j43YOPRrOJvDwr8vKsWF72g8XCf0eVlWUAbAgMnIfVakBOTgt8fHa7Sc4ipcWJiUrW1hwR8RERkygpqUFx8W309SWB4xhYrXloatqPoKA5mExmxMUNYnw8WnZpMcBnpHbWH+VT+6xWI3x9V/H1r/8cq6s6mM18/1Z5+XnBTaJpFtnZbYLr4uxIyZESRHx09BjKyipRWlqFH/7wb7G6qkdHRyasVgNCQmYEYiJZiXSWVGmxJ/X2ptgzUrd2/T+eBshi3z4W8/NBYDkTPqw9jRsvvQTYbAiem0NnZiYy29uh2ZI+vKg7lIw/jeS/L7mIeLHEpcV8fmsEsbEjKCs7ga6u/yS5LhMfH4+RkRGvMlLp6emKEPGtra3w8fHBN77xDSwtLTmsy4hxx+J1GW8yUnIR8eL81rlz5/DjH/8YS0tLsFqtMJvNiIiIAMMwMJlMLjM8e0HEnz59etf/IzTAQ4cOYWpqSnBKrl69CoA/Ae/v75eV3yLXpxQRL3akxDRAqfxWdHS04Eq4cqRcyVtEfHt7OzQaDb75zW9ifn5e+I5c5bcAZUAOInFGyt13rVKpkJaWhrS0NFy4cAE/+9nPsLCwAJZl0dTUtIsGKKXnjYh3zm8RYmJ7O39gGBoairGxMVn5LXJ9ShHxxJGiadolDfDu3bu4e/cuEhIShPtISWkxsHMfJSUlKVp/7Orqglqtxn/+z/9ZcLed81vOB1KeSoulJBcRLz6QWl1dxZtvvom5uTk8e/YMz54983ggBeyUFr9YFfz30adqyArXrePOq29+6sEWrkSofVKOFEUB8fHDiI8fxtmzFejszADBrz9+fBiADXNzwZidDUZIiGf3zltEvLi0WK/fQn7+M+TnP8PMTKjgJn300Su4cYN0S3FgWeUZKW8Q8WNjMZidDcXFix9j375GdHTwbtLjx4dRX8/TAEn/VlAQDwIQZ6S8Q8S7d6T8/JZRUPAEBQVPcP/+MVRXn4HNpsKVK5+FVrsu0ABTU3t25bcAcWnx80HEU5QNKSl9SEnpw/nzN9DWlg2OY1BXVwibTQXAhtVVHRYX/REQIJ31Eaunh89I0bTSjNROaXFAwCKOHq3H0aP1GB+PEtykjo4s+Pqu2h03FixLgBzKhk2l648TE5GYmQnHuXM3sH9/E1pbc8CyDO7fP4F794rs+S0WRmOzMFjKKS2W0s76o3tEfFDQPE4cf4A6jQrLv0uDKiwVa76+eO9P/xS6lRUYmpvBsCwSBgZAbpOumDC0JEbifHK7gIh3BeRwd32xscO7UPwq1V1kZv53l+syAP+gsrKyIut0VlxaLFdiR0qr1cpal6FpWuhRUgrkULq2NjMzg+npaZw5cwb79+/fRQOUym/JKS2Wktz1x/DwcJw+fRqnTp3CvXv3cPv2bSwvL+M3v/kNAgICHNwkqQfSvSLinR0pcX5raWlJ+I4qRWuwGo0G6+vrslxHbzJSzoj4yMhIlJSUoLi4GH19fQIxUZzfYhhmTxkpJffR0tISpqenUVJSAoZhhIybmAZIuqWI46YEyCGWXER8dHQ0ysrKUFpainv37uHOnTuYn5/Hr371K4SEhAhuklR+C5AuLZYjsv7o7EgRGuC+ffuEIZnjONy4cUO4j/38/LC5uekxvwXsHRGv1+uFzj/SvyV1IEXTtFcZKW8Q8Wtra5iamsKpU6dA07TgSro7kFIC5HihT0afqiErPmD1j3bAAoDh4ThMTUXg6NE6t79Ord5GdnY7srPbsbSkx/e///fQaDZx714R7t0rsue3WOTlWSXzW8DeEPFSTkJo6AyKiu7i5Mm79vwW3y1lsZgA2JCQMIjR0VjExHjOb4lLi8PC5CPixaXFfH6rBbm5hAbIu0lVVWdQVcXntxiGhVa7pqi0GPAeEd/dnY7Q0Gn87d/+wKF/i+S3SP9WdPS48JodR+r5I+K12k0Yjc0wGpuxsOCPH/7wW1CpbLh9uwR37pz2mN8CdnqklKw/traS9cfd33lU1DjOnKlCSUk1entThO+osfEAABsSE/sxNRWOiAh5mSdvEPEcxwjrjz4+66L8FqEB0rh58yIqKs4hM7MDNM1Bq11TVFoMiDNS8hHxf2Fswv8n7gRSJxfwj9/+DnrS0sDRNFiGwbP8fIROT4PmOORZzPjfv1GKL5sa4KveQqPFu2FzZCTOBWTkAUhflnhdZnZ2Fj/96U+xvb2NyspK1NTUICsrCwzDCDRAKUmVFnuSc0aKSM66TFJSEubn52WfUnuz/ih2pFzRAMX5LZqmodFoXDpSruQNIp6iKAwPDyMgIADf+ta3hO/IXX4L8FxaLKWpqSlZjpS/v7+Q35qYmMAvfvELbG5uory8HNXV1Q5ukqsBzx2Qw5VcOVLi/Ja4f6uurg4PHjwAwN9Hy8vLst3XvSLiAwMDHfJbYjfJ19dX6JZSqVSKSosBx4yU3PVHlUqF8fFx+Pn54W//9m8FV5LQAKXyW4AyIAcRyUh5Wn8MCgrC8ePHcezYMYyMjODtt9/G+vo6rl+/jurqasFNIjRAKXmDiHflSKnVaiG/tbq6Kjhud+7cEQ6lSNWA3HVBkpHyFhEfGhoqHEiRegqLxeJwIMUwDGw2m+zS4hf6ZPSpGrL+2LUzJFhlv2ZoKAHr67747Gc/QFTUGMxm3k26du1l3LxJ8lsc0tP5/BawU1rsPSLetSMlzm+dO1eOq1cvwWxmMDwci3/5l7+y0wB5Nyk4eF7y99gpLVaGiCcZKWdHiqcBPsWhQ08xNUXyWww+/PBVUNQ2VKpNqFRb2N6mJN0kZ+0g4pVkpHZKi1UqG5KT+5Gc3I/z52+irY3v36qvP4K6OpLfYmE0ml06Uu7kDSJ+fDwG6+s6/Mmf/B6RkRPgOAZ8/5Y4v8UiJaVPcELklBZLiaw/ukPEq1Q2pKX1IC2tBxcuXMe1a5+BxUJjcDARP/rR39rzW6w9vyW9pkgQ8a6AHFIifWRSiPjAwAUUFtahsLAOo6PRIMTEtrYcqNWbUKk24ee3DJsNslxHgohXch8FYRsxaxo0RW+imk7DmaZOZHR2Ys3HBy25ueAYBneLinD31Cmk+i+h0NaNlRU9WJaxO1LygRw7649mif+7DKm+rJmZGaytreHVV19FRESEsHZF1mWImyRel/FUWuxKchDxzusyH3/8MZqbm9Hf34/vfe97SE5OFvq3XD1YeouIJ9Q+Z0eK0ACLioowODgoZJMsFgs0Gg1UKhVCQkJgs9lkrTe5GjbdSexIkXU4QgN0zm+lpaWBpmnk5uYKjtTz7JGS0srKClZXV/Hyyy8jNDRUcJOIC0mIiWJnjAyb3mak3CHitVotjEYjjEYjlpaWcOPGDVitVvT39+Pb3/62JA3QWc8bER8VFYUzZ8449G8RGqCPjw8oilKUZSNADiUum7i0WK/XS9IASX4rMzNTcNz2kpGSex9RFAWbzYbV1VVcvHgRISEhYFnWY37LU2mxu+vT6/VuEfE6nU44kJqbm0NFRQVaWlrQ19eHN954Q9aB1OzsrOKMlHj9UexIidebpQ6kdDodVCqVotLiF3q+ejFkPSfxGSkjsrPboNPJz0iJHSm1egsnT9bixIlaDA3Fg+MYWCxGNDcb7fktPps0MhKNrS2NwoyUckS8SrWFkZE4JCb24wtf+J3dtaFRXV2K6uoSpKby/Vu5uVb4+u50S3kqLZaSXER8ePg0Tp++g1On7qC7Ow2/+c0XQVHAu+9+UZTfYhETM+by9+A4xqG0WI6II+X8QK3R8EO1wWDF0pIfmpuN4DgalZVnUVV1xp6HacT6ulZWfstbRDzLMgKQQ6PZQklJNYqLa9DXlywQE3fyW3w2aXg4VnZpMdHCQqA9IyUfEe/js4GJiSjExw/iT//0XaF/q7z8glP/VpvDsCd2pORqBxHv3pGKiRlDTMwtlJZWor09E++//6cAgLff/jJCQmZA+rfcDcfOpcVyZLGYAJsKX7lwA/8j+iT+75lT+Pwt8/+fvf+MjiO9z33Rp7qBbuScc85dDZIASASSIAgwajQz0iiOJdmSLe99tr2397HPuXt53S/3w133rHWUbWXLsqSxpNEMhxGMAAmSAAiQBMCqbjQaOeecM/p+qH5fVOeqBkceHeO/lpft4TRRaDY49dbz//0exM4sYV1lQn3kElqjF/Cm3xziFv1x985l3L93AXt7SuTnt2JnRykpfSWlxWlpPU7WRutgfcjieR4qlYoemMi6DNEdt7W14cWLFwgNDaU3yqOjo9jc3JS9QtXd3Y2SkhLJNxpeXl6Yn59HVFQUPv/5z9ukSfbWZQDXpcX2ZmhoyKUinmEYxMfHIz4+HhcuXIDRaMRHH30Ek8mEX/7ylwgPD6c3gc74InLweB2KeHv8Fs/zuHbtGm7duoWdnR0cOXIEe3t7ktYF3VXEk/VHIidJTEy0SJOamprQ2NhI+S2NRoORkRHZjJQ7inhfX18sLy8jPDwc77zzDj1MXLlyxSG/Rb4nQN5h0xkjRcaa3zIYDLh58yZMJhN+/vOfS+K3yPXJXX90ZO0jNsDS0lJMTEzQhy2dnZ1Qq9XY3NzE0aNHJX8dcWmxO4r4vLw8eHl5OeS34uPjwbIscnNzMTQ05BYjZTQaZSniAwMDsba2huDgYHz2s5+14bfsPZAC3GOkpCjirR9I6fV6Ku6QI+Q4nNc7h4es1zS9vWlYW/OVdcO6n0i1WCRSQpo0iri4URG/xaKlpQDPn5+Ah8cWvL3XXHYmicc9Rfx+abGlDZDwW1pcv/4WqqsJvyWwSe4IOeQq4hkGWF4OgMmkxLvv/hLr6z7gea0Vv8VBo9FRfgtwXVpsb8j6oytFvK/vGoqKnqOo6DlmZkJx7dpb5tXLI+joyKH9W0lJ9vktYF8RL4e129pSwWjMslHEC/zWAJKSBnDp0h0zv8WisbEUDQ0noVJtwNt7zaEIwt4QRkpOeiNOpPz9V1Bc/AzFxc8wORlB06Surkwzv9UOrZZHXNwQTaTkCDkII5WR4ZyRIqNQmLC1pcbenhJf/vJvsLbmC8EGeApPnpxGXNwwWJZHbq7e4tDrqrTY2fXFxIziXI4eVdl6vJiKxQ02G/qlSHipdlCWOIDvpN2Gn+cWTCbBnHnr1hsYG4vBq1dHYTRmIzdXD62WQ1zciMPP8L6Qw5kivg7AP9L/z5qRIiMuz7S3LuPl5QUvLy9Z6Yher5etiJ+enqaJlLUN0NG6TFRUlOTSYvGQtTWp64/kxmxvbw+f+9znsLa2ZsFvERugdZGvVCGH9UhRxIv5reHhYdy5cwcTExNoa2tDd3e3Rf+Wo7EuLZYy4kRKvP7o4eFBbYCrq6uUTXrw4AFqamrg4+MDtVotSzPtriKeJFIRERGU37K2AQYGBtL3iKS6HxcjRUalUsHLywt7e3t4++23sbKyYpffyszMtGCTpAo5rEeKIj4qKgpRUVGorKxEX18fampqMDk5idbWVvT19bnktwD3GSnyORInUmJ+a3FxkR6SiQ3Qx8cHKpVK1kOLgyjiy8vLLeopnD2QCgoKsptIuRq5ingvLy8EBgbK/p4O5/XP4SHrNQ3Ps/DxWZXFSBkMOdjd9XB6w6pU7iIzsxOZmZ3Y2PDCy5fHUFtbhZ0dFb7//f+JpCQhTcrJMVAboPW4q4gXM1LiCQmZR3n5Y5w+/RgjI4TfyoNer4GX1zo2NrwRHz8kee1qc1PlliKeCDmEFTggJ4fwW0KaVFNzDjU1VUhJ6TMnbh2QU1pMZnIyysxISVfEh4TMY3ExCBkZnSgpeUbTJI7LN/NbQpoUETFl8Tqe10oScohHiiLe03MbeXl65OXpsbLii5aWY6irOwOAwXe+8/eiNMnolC+yLi2WMo4SqcjIKVRVPcDZszUYGEgGz7PQ6zVoazsGX98VrK76oaSkQfLXESvipTJS5PoCAxeQltYHhjFBq+WxtET4LS1u376Mu3cJv8UhI6NLVmkxmakpgZEiiniGAYoiR1HkoGSdYYTEbWXFD2lp3Sgqeg6e14Lj8tHSUoiQkFloNAJvZs0+8jzrsLR4f/a5LECw9m1tbTk9+IjXZRYWFtDS0oL6+noAwLe//W2aJjlblxGuj0d0dLTbjBQZ63UZ0i1F1mUCAwOxuLiIEydOSP46B1XEZ2VlQaFQ2PBb169ft+iWSklJoYcEuX1kchTxJHHb2NhAUlISCgsLIbYBRkREUGOi9UH0dTJS4vH19cXx48dx/PhxzMzMoKWlBU1NTQCA7373u/Q9csZvAQdTxIuvj2EYJCcnIzk52SJxa2hoQH19PUJDQzE/P4+ioiLJX0d8SHBn/TEvLw8KhYLaAEmaZM1vJSQkuMVIzc/PY2hoSLIiXqFQIDU1FXfu3EF8fDyOHTtmwW8RG2Bubq4FvwXIP2wC+4p4Z99TYGAg5bcmJibQ2tqKly9fAgC+973v0f4tZ/wW4J4i3l4iZf1ASiwUqqurQ1RUFGZmZnD+/HnJX8ddRbw7Qo7Def1zeMh6DbOx4SVKpKSXJvO8FqGhM4iJsX+TZT1eXhtmgxzw53/+r1QscOPGmxb9W6mpvRbX4aq02N4Ia2t5ThMphgHi40cQHy/wW93d6bh79yI2Nrxw//4FtLUdBenfCgiwz28BtqXFUmZxMQADA0k2iniB33qBwsIXmJ0NBTEmXrv2NqqrL0Oh2EN4+BSCgqQLOfYZKTmKeCGRys/nkJg4iMTEQXOaRPitYjQ2liEqatzMuOng6bkFozELLOu6tFg8chXxfn6r5kMIgy9/+T0MDiZCp2Nx5co7UKs3kJ1tgFbLIzFx0CKlcVVabG8II+VMES/wW31ISenDpUvVMBqzqC7/3r2L0OlYaLUCv+Us1doXcshXxJeWWiriAwKWUVraiNJSW37Ly2sdDLOH0NBpyQIPYL+02F1FfHp6D9LTe7C5qTb3b7F4/Lgcjx+fQXz8kDlxa4eHx47E0mJLLksKIyWeoKAgur702c9+FsPDw9Dr9TAYDHRdRqvVIiYmxuIGhzBScm40pCjilUolsrKykJWVhfX1dRgMBjx69AgAcO/ePXR2dtrYAO2NO4yUo0TKmt8ixkSdTkffu5CQkAMfNl2NuLRYzG9Zp0nixE2hUEguLRYPx3Hw8/NzykiJJywsjDI1b7zxBkZGRmz4La1Wa/MeOSstdjRSFPFifmtlZQV6vR5Pnz4FANy/f5+mN874LcC2tFjKOEqkIiMjLfgtjuMovxUUFIS9vT0EBwfLKi0+iCK+tLTULr91+/Zt3L17F+np6dBqtUhPTwfDMJJLi62vT6oinmEYREdH0+///PnzGB0dtbABks+RdYLkrLTY0ThipMTj5eWFo0eP4ujRo1hYWIBOp0NjoyBFq6mpwfDwsKQHUu4q4o1GI/Lz82XZHw/n9c+BD1kMw8QD+DWASAAmAD8zmUzfZxgmBMD7AJIADAD4vMlkkn5n+yc0JJHKynJeLCoeUlp85ox0RkqsiCfihVOn7PNbxHQXHT0uubRYPL29qbKsfR4eu0hJ6cfamg/y89sQGzsGjtOitrYKtbWVZn6LQ3Z2hwW/BUgTcliPFEV8aOgszpx5hPLyRxgeTsCzZydgNOZgetoL3/3u/w6NRuC3IiMd81v2SouljL1Eyprf0uuFbqn798/jwYMqhIdPY3tbhZwc6Tfh7iriOU4oLSY37mfPPsTAQCKE/q1cvHp1FIGBC/RzFB4+I7m0WDxyFfEq1Taysoy4desN5OXxiI6eAM9rcefOJav+rS4bWQdhpOQo4sU9Uo5mn9+qQV9fMp4/P47u7gysr/vin/7pv9NU0tkqqb3SYinDcVobRbxavYn8/FfIz3+FxcUAKsuprv4U7t69gMjICWxtqZGba094YT11AEqwsrKCnp4eWYwUsG/tIzel4nWZ1tZWui5DVooIvC6XkZKriPf29gbLsnjw4AGysrIQFRVlwW8RG2BqaqpNUkISKTmKeFeJlDW/1d3djRcvXqC/vx+rq6v4yU9+YtcGaD32SoulDGGkxImUj48PtQHOzs5S0921a9dQXV2N6OhobGxsyPpzOqgi/siRIzh69KhF/9azZ8/Q2NiIqKgo+h75+fmB44T/Nsk5bMpVxPv5+aGgoACPHz9GWloaIiMjodPpcOXKFajVamRnZ0Or1SIxMdHm5+bjUMSL+a3Lly/DaDSipaUFQ0PC33m/+MUv7NoArcddRTzP8zaJFOG3xP1ber0enZ2d8PLyQmxsLNbW1mT9OR1EER8aGorjx4+DYRiLegp7/Ja3t7dbh00pjJR4goKCUFJSgmfPniE5ORnh4eH0gZSPjw81Jlo/kCLfk7uK+MNVwf/4eR1J1g6AvzeZTK0Mw/gDaGEY5gGAPwdQazKZ/i+GYf4XgP8F4P/1Gr7eJ26Ixeu3v32XpkmCyMJxqmVdWixl7Cnirfmt7m6hf+vlywI0N59AWNg0FhcDkZLSJ4uR4jjCSMlZfxSsfceOtSIubsTMbxEbIIvr199GdfWnKJuUktKH5WU/9Pcno7zcdWkxGbmKeIYBEhKG0NGRDYViB2+8cQtGYxaam4/j2bMSsw1QSJP8/ZctXuustNjRkPVHZ4mUr+8ajh9/juPHn2NmJszMShUDAN5//0u0fyspacCpMdGdPjKiiBeXFjOMCcnJA0hOHsClS7dhNAr9Ww0NpaivP4no6FHMzYUiOblPJiPlviK+oKAFiYlDKCl5hsnJSHCcsE5I+K3c3HawLIeEhGGsrPhKLi22vD7WrIh3nUgpFHtIS+tFf38yurvTcOHCXXR2ZuHJk9N48qTczG9xyM1ttzmQOystdjTb20IfmTNFfGDgEsrK6lFaWo+JiWhwHIuXLwsBAB999A59jxzzW3UA/pEyUnL+ozw9PW1TWuxoXebRo0d49OgREhISMD09jaSkJFmlxe4o4klpcWFhIVJSUii/RdIkvV5P17IIv7W2tuYWI8VxnEtGioyHhweys7MxPj6O/v5+nD17Fp2dndQG6IjfApyXFjsaKYr40NBQVFRU4MyZMxgaGgLpBAKAW7duWfRvORt31h/tKeI9PT3t8lv379/HgwcPkJKSgomJCSQmJsoScpC1NXfWH4uKipCenm5hA7Tmt7RaLcLCwg7ESElVxKtUKrAsS9f+Tp48ia6uLrs2QOtuKSlCDutxZe1jGIbyW+JuKb1eeCh39+5djI2NQavVWtgA7c1BFPHiREpcT0H4LY7jKL+Vnp6O0dFRxMfHuyXkkGPt6+3txfr6Oo4fP47MzExJD6SklhZbjzuK+MP5eObAhyyTyTQOYNz8fy8zDNMBIBbAmwDKzf/aryD81/z/cYeshYUgDA0l4dixF1Aq96DX58FgyDXbAPVgWQ4xMWMWNzjkkJCQMIigoAXJX8uVIl6p3EVWVieysjqxvu6F9vZcNDcfx/a2Ct3d6fjVr74GoX+rwyG/BdiWFsu5PutEKiRkDuXldTh9ug4jI/HgOBbt7XnQ6Vj4+S2bn/4z0GjkHBIOoojvpinA2poP9Hqh5+rBg3O0f0tI3IxQqbYgtbRYPISRkpoChoXNoKDgJZ4+PQmWbYNSaYLBkOOS3xILOeQo4vcZKfvJpqfnNjQaPTQagd/S6zV48aIQm5te6OtLxW9/+2VzmtTpdB2NlBa/DkV8ZOQkzp17gMrKGvT3J9P1vdbWYwgKmkdw8JxsRmpyMgITE9G4cEHu+iOL9PQeekheWgqg/Vu3b38Kd+9eREZGF1iWR3q6YHuUWlosHjmKeIYBoqPH4e+/jObm48jJ0UOhMOHVq3y8fCnwW6QvLDhY/GBC4LIIIxUeHi75+lytrVmvyxBWan19HYODg/jggw8krcsQRby1kEPK9YkTKTG/RdIknufx8uVLNDc3Izw8HMHBwW4xUmNjY5IZKWA/SUhNTUVZWRnKysps+C1x4paSkgKFQiFbyAHIW39kGAaJiYkIDw9HW1sbMjIyAIDyW2IboL0k7eNQxFvzWxzHoa2tDaurq9jY2MC1a9eg1WptbIDWY11aLOf6xImUNb9lNBot+K2YmBgEBQXJlg4cVBFfUVGBiooKmiaJbYCETUpISADDMG4zUlLXHxUKBdLS0hAXF4f29nb6M2jNb+Xl5dnljByVFjsbV4mUmN8aHx8Hz/PgOA4bGxvY2NhAdXU1tFqtjQ3Qel6XIt7VA6nExEQEBgbKLi1eXFyUrYg/nI9vXiuTxTBMEoAjAJoBRJoPYAAwAWGd0N5rvgngmwCQkCB97/uTMsTaV1bWgKCgBZw7dw+9vcQGeAzPnx9HaOiMmU3iERS0iLExgZF6440bkr+OXEW8t/cGCgpazEprfxw/3gy9XoMbN97C7dvEBsgjNbUXCoVl4uastNjRCIr4JIeJlMBvDSM+ftjMb2WA41h0dgo3C++//0WQ/i2xDdDecJx9IYez2VfE79+E+/isoajoBYqKXmBmRuC3dDoW1659BtXVW8jI6ERHRzby89tkMlKCIj4+Xr4i/vTppwgJmcPFi7fNNkAtnj0rEfFbHDQaPfz8VkRCDuelxeKRwkiJx89vFSdONGF8PBrLy34oKHiJ9vY8XLnyObMNUOjfSkwcskmQSCL1OhXxCoUJqal9SE3tw+XLAr/FcVr09Qn8x7Vrb0Po32p3+f25p4hPsiktDghYQmlpA0pKGjA5GQWOEw6ARmM2vLzWkZ1tgF6fi7w8vUwhh3xFvE6XB0CB8vI6hIfPYHNTDYMhGzyvRV3dGdTVCfyWVsshJ6cd3t5rmJ6uw/j4uGxGihwSpCRSQUFBOHXqFObm5tDe3o78/HwYDAa6LkN0x/bWZUgi5Q4jVVxcbDdJsOa3SLdUV5fwMOXu3buS+C3AfUbKWhEv5reGh4dB+rd0Oh38/PyQm5sLvV4vm5HieR5+fn6yFfEmkwlnzpxBVFQUVldX6XtE+C3Sv0WuR5xISR3x+qOURCosLAxnz57F2toaOI5Dbm4ujEYjOI5DQEAAtbjZY9ykCDmshyRShYWFdj9Hnp6e0Gg00Gg0WFlZoWySwSA8CH306BG0Wi0yMjJcPiBwRxE/MjJik0hFRkbi3LlzqKysRH9/PxVmtLa2IigoCHl5edDpdLJKi8n1SWWkyJBks7KyEjExMVhaWqIPEgi/lZGRAZZlkZ6eDg8PD9lCDkCeIp5hGMTExCAmJga7u7tobW1FamqqBb9F0iR7vNVBGClHinh7D6R4nsfgoPB3/7NnzyQ9kALcY+0O5+Ob13bIYhjGD8AVAH9nMpmWxD8cJpPJxDjY4TGZTD8D8DMAKCjwNQm2qz+NIda+xMQBmkgplXvIyOhCRkYXNjbUMBhywPNaPHp0Fo8enUVi4gAUCqFANydHemnxwRTxrbRbSlCKa9Hengu9XgNf3xXavxUVNQ6GcY+RkmPt8/DYRXZ2B4KCFtDZmY28PB4LC8GoqalCTU2lhQ1QpbL8PEgRcti/PsJI2VfEh4XNoqLiEc6cqcPQUDyEMl8N9vY8YDTmQK3eglbLO+W3AMvS4oMo4j09d5CX1468vHasrvqa+S0W9+9fwIMH55Ca2gvABIaRV1rc35+ClRV/WZ8jcWkxSZMGB5PA8yza23PR1kb4LSFxI6t3UkqLrUeOIl6l2gLLCn8mP/nJf0VmZgcWFoJx585l3LtHbIC8uTvM8nDjrLTY2ZD1R3uJlGADnEBU1ASqqh6gry8FpOpgd9cDvb1pqKsrB8tyLtdc9xXxctcfLUuL1epNHDnyCkeOvMLiYiB4XjAm3rr1Bu7cERI3k0mwuslhbwYGBrC0tCTrhnp7extGoxF5eXm4fPkyLly4YFOeab0uI3xP8oQcAGStP3p7e6OgoABJSUn44Q9/iNTUVMzNzUnit5yVFjsbZ4kUwzBISEhAQkICLly4QNmk58+fw2QyYXh4GA0NDS75LWC/j8xdRookUr6+vpTfmpmZoTeBV69epX1Ye3vCwzo5h4Th4WHMz8/j9OnTkl+zs7ND7Y9vv/02tre3qQ2wsbERDQ0NNvwW+Z5clRZbjxxFvJ+fH4qLi5GZmYl/+qd/QmJiIiYnJ/Hhhx/a2ACtDw9iIcdBGSkyxAaYmpqKy5cv0+qFhoYGmEwmTExM4Pnz5y75LcCytFju2ppYER8QEGBhAyQHQKPRCC8vL+Tm5rr1OXJXEU/ELp/73Ofs1lMkJCTQhy0kcZNSWmw9chTx5IGURqPBD37wA8TGxmJgYEDSAykpQo7D+ePOazlkMQzjCeGA9e8mk+kj8z+eZBgm2mQyjTMMEw1gyvHv8Kc5Y2OxmJ0NQ0lJo91f9/LaxNGjbTh6tA0LC0H0Bmd2NgwMs4dbtz5lTpOc81uAkN64q4gnN9QCvzWCuLh9GyDPCwxHc3MxwsOnkJHRJbu0mBw24+OHrFaRnA8Rcly6dBve3huYnQ2hN6XEBkj6t1JS+qBQmERCDvmMVH7+K5eJFMOYqFRkdjYEMzNhiI0dQ3PzCTx7Vmrmtzgzv2XbU+aotNjZuFLE+/qu4vjxZhw/3ozp6TDzAZDF0lIgFIpdPHhwDkL/1oDLG3JxabHU6ejIskikFAoTkpP7kZzcb+a3ssDzLBoaylBffwoxMaPIzOxEb28KTp2SXloMuKeIJ0KOT3/6Jnx81ii/pdOx1AZI+rfi44fAMNJLi8VD1h9zcx0zUmQEfqsHaWk9WF31wfh4NEJDZ/D48Wk8fizwW1qtwG95e9sKVYgiXs7naGoqHBMT0Th//o7dXw8MXMTJk/UoK6vH+Hg0iCxnddUEhUKBx48fS1qXAfZLi91hpMgTVuvyTHvrMpmZmeju7kZpaalbQg451j4i5HjzzTfh5+eHkZERmibZ47cYhpFUWmw94kOCq0SK3EDn5OTgvffew8jICHx9fSm/RdIkR7yVOz1Ss7OzGB0ddXiADgsLs+C3OI6DwWDA5uYmlEolmpubwbKsJD7NHUV8V1eXRSIltgGurq7SNInwW6mpqcjKykJnZ6dbh02pjJT4NQDwmc98Bn5+fpTfam9vR1tbGwIDA+mDhLCwMADyhRyAPEW8SqWiNsB///d/x9DQEJRKpSR+C3CvR8pZIiW2ARJ+i+M4cByHnZ0deHh44NWrV2BZ1iW/BbweRbx1PQX5HN26dQt37txBRkYGsrOz0dHR4baQQ876I2HZPvvZzyIgIEDSAym5Qo7D+fjnddgFGQC/ANBhMpm+I/qlGwC+BuD/Mv/v6wf9Wp+02bf2uU6kgoIWcOrUU0RGTuL3v/8y0tK60d+fTG2AJE2Kjh6zOdxsbHihszPTLUW8kEjZKuIFfsuIrCwj1te90d6eYxYdCGsHPT3pCAxcQna2wcYGaD3i0mKpIyRSlqXFoaFzNHEbHhbSpPb2XMpvaTQ6TE2FyyotBvbXH+WkN0tLARgcTMLp049RXl6H1VUf2r/14MF5i/6trKwOqFTb1P7oqrTYeuQo4sPDZ3D2bC0SEgbw299+BYmJgzAYcvDq1REEBCxSG2BExLTNax2VFrsantc6TKQEfksHjUaHlRU/6HR55uRWuOkcGkpAe3suMjM7XXJZ+4p4eeuPer1labElv5VC10BbWwsQFDQPluUxNRUuq7QY2Gek5HyOVlb80N8vKOLPnn2IpaUA+rCF2ABJ/1Z6ejf9c+F5rWQhBxmiiNdonCebDAPExIwjJmYc6emdeO+9ryEmJlryuoyj0mLX1+c4kXK0LnP/viAKmZiYQFdXF1JTU13e3IhLi6WOPWuftQ2Q4zi8ePGC8lssy2JiYkI2I+Xu+mN/fz9OnDiBqqoqzM7O0veI2ACzsrKg1WqRnJxMDxJSSouth6w/uro+wm8lJiYiLy8Pv/nNbxAWFoampiY0Nja65LfIYdOZkMPR9TlSxPv6+uLEiRM4ceIEpqen6XvU0yM8nJybm0N/f79Lfov8u+4yUmJFPLEBivu36uvr8fTpU8TExIBlWYyNjbkl5HBHEd/f34+CggJcuHDBIk0iNkCSuMXHx9PvW0ppsfVIXVsj/FZaWhr6+vrwm9/8BkFBQQ5tgNZDDpvuKuLtJVJBQUE4efIkysrKMD4+To2JHR0dAISfx5GREUkPpF6XIt76gRTHcRYPpFiWxejoqKzS4sP5+Od1JFmlAL4CQMcwzCvzP/tHCIerPzAM8w0AgwA+/xq+1idmdncVaG+XzkiR0emE0uIvfOF9AEBPj2ADbGkpwPPngg2QAOqBgYsApJUWW48cRby39zoKClpw7FgL/umf/hZ7e0qsrvri+vW3LNKk1NQ+G34LcFxa7GycKeIFG+AwEhIEfqurKx08r0Vz83Hs7Snh7b2Gpqbj0Gh0LvktYL+0OC7O/fVHX981FBU9R1HRczO/JaRJV69+Bp6eW8jJMSA2dhjT0xGySovdVcTrdEIi9eUv/ztMJobyW42NJWhoKEN09BhYlkdeng5+foIyXEppsfUsLfmjvz8ZJ0+6TqT8/FZQXNyE4uIm/PM//w02N9WYnQ3Fhx8SfktIkxISbPktYD+RciTksDdEEX/+vK0iXuC3epGa2ovLl6vR0ZEFntfiyZNTABj4+Kzg1asjyM3VS3rvSWlxYqJ0Rbx1IhUQsISysgaUljZgYiIKROBB+K3cXD0SEobMQg77iZS9sVx/lK6I1+uF0uKvfjUTu7t/JmldRkppsfXIUcSTdZmTJ0/ihz/8IdbX1zE+Po7f/e53dF1Gq9UiOjra7u/lDiNFFPH2EilH/FZtbS0AYU2MHBakMC7uKOL1er2FkCM0NBRnzpxBeXk5hoeHaZpE+C2NRoOEhARZpcWA5SFBzvpje3s7PD098fWvfx3b29s2/VvW/BZgm0hJGaKILyoqcplIhYeH4+zZs6ioqMCPfvQjrKysYGBgAF1dXZTf0mq1DmUv7rAtzhIplUpF+a3l5WX6Ht29K/zd5e/vj56eHmRmZtpNk+xdn7uKePI9ERtgZWUltQESfis4OBgajQZJSUluM1JyFfFGoxEeHh74xje+gc3NTZomiW2AYn4LkFZabD3E2ueIkSIj5rfOnTuHn/70p1hcXERnZycMBgNCQ0MpB+hoPc9eabGrcZZIiR9Izc/P0/fo5s2bYBgGWVlZskqLD+fjnddhF6wH4OgnT1qpyZ/g9PS4w0gJpcXHju0nUpmZXcjM7MLGhpfZKKfFw4dn8fDhWSQl9YNlebx6Ja+0GHBPET8+HoP5+VB86lM3cfRoC0ZG4uhKEeG3SFISFTUBhtkXcshnpFhJingPjx3k5HQgJ6cDzc2FuHv3Mvz8llFTc06UJu3bAK3HUWmxsxGvP9pLpAR+6yHOnHmEoaEEcBwLgyEXHJcPwITp6XBMTkYgMtL1hqy7iviOjmxotRxNPgi/JdgAhTTp3r0LuH9f4LdYlsOrV1pZpcXAPiMlz9oXidnZMFy8WI2Cgpe0NLu9PQ9tbccQGLhgfpDAISxMWAskiZRUIQeZfUbK+fqjSiUwdVotTz9HavUWbt++bJEmCfyWbcrnqLRYyvXZS6QEG+AEoqMFfqu3NwU8rwXH5aOlpRCACUtLAZibC5ZUU+CuIn6/tNgPnp4nna7LZGZmgmVZKhn4uBgpMjMzM5idncX58+dRWFhosy4TFhZGEzdyIyeltNjeSF1/JPxWQUEBmpubcffuXTAMg+vXr6O6uhrZ2dkWNkDrcVRaLOX67CVSYn5L3C1FbICAcEO5vLws6dAkLi2WOtaJlEqlsrABivktlUpF3yNSWixHyOHO+uPc3BxmZmZQWVmJoqIiG34rOjqamu7IZ0ZKabG9IYyUq0TK398fxcXFKC4uRlNTE+7du4ednR1J/BbguLRYyvXZS6TEadLW1hZ92EJsgIDwnqytrbnkt4DXo4j38vKy4LdImmQ0GuHt7U2NiRzHyRZyuLP+uLy8jOnpaZw5cwZFRUV0vdn6gVRubi5N1EwmEziOkyTkEI9URXxwcDB9INXU1IT79+8fdmN9wua12gX/Mw3PH5yREo+X1waOHm3F0aOtmJ8PogWjN268CQCIiJhEd3c6UlN7Xa4MikuL5SjixaXFgg1wBPHxIzh/nvBbWjx/XoSmJoHfYlkOfn7LskqLAWBzU21mpOQp4o3GHISEzOK//tcfY24uFKR/i9gASf9WcnIf7ZZyr0cqyqyId55ICfzWIBITB3H+/D1897v/Ozw8ttHSUoAXL46bbYBC/5afny2/BQiHTXcU8Y7WHwUbYDNOnGjG9HQ4ZZM++ugdACZERk5gYCAJSUmDkg4LPK81M1Jy1h/3EymFwoSUlH6kpPTj0qVqM7+lRX19GZ4+FfgtrZaDr++yrNJiwFLIIUcR392dicDABfzt3/4TJicjaJpkyW9xiI8fpgdzKaXF1jM1JU0Rr1Ds0VLo9XU1fvCDvwPDmNDYWILGxlLExw+B9G85epDhTMjhaIzGTNH64xqEBQRhHK3LEGtaVFQURkdHJa3LCNcnXxEvLi225rdImvTw4UM8fPgQSUlJYFkWvr6+skqLgf31R7lra319ffD398f/+B//A2NjY7R/S6fTwdfXlz7hJvwWsJ9IyT1sSlHEi/mt1dVV/PCHP8Te3h6ePn2K+vp6i/4tR9+nvdJiV+MskRLzW4ODgyDmPVIkHBMTg5mZGcns3EEV8WJ+a2VlhaZJ9+7dw/3795GWlkY/R3IZqZ2dHej1etmK+MHBQfj6+uLv/u7vaEeZXq9HW1sbgoKCaOIWGhpKX+OqtNjezM/PY3h42GUiJea3FhcX8dOf/hQ7Ozt49OgRHj9+bGMDtDfOhByOxpEiXsxvibulyHozAMTGxmJpaUmy7MEdRkqcbFqvNzt6IOXt7e2WkEOuIp5hGIyOjsoWchzOxz+Hhyw3hjBS4kRKyvA8a06kxpz+e8HBCzh16glOnnyC6urLaGkpxNJSAH73u3fh47NK06To6HG76Yy90mJXIyRSGmRmdtrcyAk2QCOyswm/lQueZ1FbWwXABIViF2trPtjcVLnkt4D90mL5ivhklJc/AsMAoaGzOHPmEcrLH2F4OIH2b/G81sxvCSuXckqLybijiB8eTsDmphfefPMaEhKGaJp0//55PHiwn7hlZRmhUm0DECdSroUc4pGqiA8Pn0ZlZS3Onn2IW7cuobW1EHNzofj1r//czG8JyU54uC2/BdgvLXY1+z1StomUSrUNltWBZXVYXvaDXi90S925cwnkc7S7q8TOjoekQ5O1kEPKkESKlBZHRU0iKuo+Kitr0NdH+rcEfis4eI6+R3JKi8nsHzal2x/Hx2OwseGNd975AHFxw/RhS3X1G1b9W930AYWU0mJ7w/NaBAQsIilpEIKXaAuA5c239bpMdXU12traMD09jV/84hd24WvrIaXFchXxjhIpLy8vHDt2DMeOHcP8/DxNSm7cuAGGYaBQKODh4YHd3V1JcPpBFPEnTpyAUqm04beIDbCpqQkRERGUTXJHyOHO+uPMzAzW19fx9ttvIzY21obfImmSmN+SUlrs6PpcJVIMwyApKQlJSUm4ePEi7ty5g7a2NoyPj+PHP/6xXRug9RxEEW8vkfLz87Pgt0i31JUrV6BQKMAwDHx8fGAymSQ9SDiIIr6oqAgeHh4W/Bbp3yL8VmxsLE3cDiLkkHN9y8vLWF9fxxtvvIGYmBiLNInYAFmWteC3yCFBipBDPFISKYVCgfT0dKSnp2NzcxN37twBx3EYHR3FD37wA5f8FnBwRsr67znxA6mxsTF6SDYYDPDw8ADDMAgKCpL8OXJXEe9OafHhfPxzeMhyY9rbHSdSjmZhIcjMSNVKXlsDBAtaYuIAvvKV35j5LRYvXxaguZnwWxxYVkf5LcB1abG96e1NNa8/Oj/4CPzWSxQUvMT4eBR+/vO/gqfnNm7efBN37lyiaZJgA7R/ALVXWuxqSB+Z9fUJ/NYQEhKGcPHiXXR1ZYDnWWoDBICsrHYsL/vD3981v0WEHOnp3Xatb46vj6WKeA+PXVpUOzMTRtOkq1c/C5Vq0/wecVhcDJB92CSK+NOnpSviARNGRhIQFzeMr37112Z+i0VjYykaGk6a+S2hf0vM87gqLbY3UhXx/v4rKC5+huLiZxgZicUvf/l1KJW7+Oijz0Kt3kBubjtYlkNCwrDDxM2ZkMPROFp/FGyAvUhL6zXbKLPB8yyePDmNJ0/KAQA5OXqsrXlL4rfIYdNdRXxGhlD0XFZWj9LSekxMRIPjWOj1GnR05MDbe42+R/PzwZJLi8nsK+IbzO/vGoCXABw/cVUqlZiYmEB0dDS++tWv2tgA7a3LCN+T/EOCVEV8cHAwTp8+jVOnTmFwcBC/+c1vwDAM/vCHP8DHx4emSY74LXJ97jJS1kkCWRXLzs7G2toaTdyIDRAAcnNzsbm5KekG9HUo4lUqFeW3SFJCrsvf358ybrOzs7IPm4SRkmPt8/T0xNTUFCIjI/GVr3yFpkliGyDht8RiFXd6pIgi3lUiFR4ejsrKSpw9exa9vb34/e9/DwD43e9+h8DAQPo5cpbEHkQRb/2eq1Qq+vBieXmZJiXEBri3t4e8vDzs7u5K4rfcZaSItS83NxdqtRpRUVHUBkjKfFtaWhAcHEyvd3p62i0hR1dXlyxrn1qtxvz8PMLCwvDuu+9Cr9eD4zjKb4kTN/Hv6c5hU4oinmEYxMbGIjY2FufOnUN3dzc+/PBDAMBvfvMbSQ+kyPU5EnI4GoPBILu0+HD+OHN4yHJjiAbbZGJgMkHSze7+IUEn+euIFfFK5S4yMzuRmdmJjQ0vcLpcvGzNx8OHlXj48CwSEgeQr+WQmWmUVVq8f31aeHuvyVp/nJiIhsmkxLvv/isABU2TiA2QGBMjIyfoe7SfSL1+RbzAbxmQk2PA2poP/vCHdzA4mAyjMRedndlITu6HVstRG6C9sVda7GqcJVJhYTM4e/YhKioeYXAwATyvNbN3+VAqd6BWr0Ol2pT8tYgiXs76o7i02NNzG3l5euTl6c38lpAm3bt3Effvn0daWo85KemUVVpMhhw25SjiZ2dDsbenxFe+8mvs7Skh2AA1aG09hqCgeZomibXuy8uCkMNRabHj6xPWHwkLZm+ETjQOWi2HpaUAfPTRZzA4mAiDIQ9GY7YoTbLPbwH7pcVyFfEGQ45NabHAb40jOnoc5849QG9vKniexatX+Xj5shCenltQq9cRELDo5He3HCLksPyc18HZIUucSDmyAVqvy6SmpoLneaSlpcHX11fy9clVxDMMg5WVFezt7eHdd9/Fzs4OeJ7Hy5cv0dzcbJffAlyXFju7PleJlI+PDwoLC1FYWIi5uTlcv34dQ0NDaG9vR1dXF+3fcsRvAfZLi12NI2uf2AZoj99Sq9VQqVRUKy5l3Fl/JIr4qqoq+Pr6Un6L2AB1Oh0++ugjym9ptVokJibSw6ZcRkrO+iPDMNje3sbu7i6+8IUvYHt7G6Rbqr6+nvJbGo3G4vMsTqTkfI44jnOZSPn7+6OkpAQlJSWYnJzErVu3MDIyAr1ej+7ubpomOeK3APulxa5GbO0TPxAQ81ubm5uU3yI2QG9vb6hUKlmreAdVxAcFBVF+a3x8nKZJHR0dlN/SarWIiYkBz0srLRYPz/OyrH1KpRIKhQK7u7v4zGc+Qz9H1jbAnJwciwdSrkqLnV1fSEgIYmNjJb/mcP44c3jIkjkLC0EYHk6EQrGLX/zirxAaOkNtgI74J3ulxVLGniJ+ZkWJWt4bzf0TiFq7iSCFH5ZVWegfy8TQ4FtQKHawt+eBsLBp7O0pHKZJ4hGXFsthpEhpcVzcqJnhGjb3bwlp0vPnx9HUVIKIiEkzm8Q7TKScDVHEf+pT0hXxXl4bmJmJQHZ2ByoqakE03sQGSNKk5OR+ym8J35PWbUW8sySBYUxIShpEUtIgLl68jVev8nH79mXs7irxk5/8b2Z+S0iTHPFb7iviWbMi3nJtTeC3mnDiRJMFv3Xlyjvw9NzC9rYKUVFjMJkYSQeZfUbKPUV8YuIgGAZISekz81tCmlRffxJPn55GbOwIWJZDXl67rNJiMvuKeOeMlHj8/JYxNxeC9PQuVFQ8ou/Rvg1Q4Lfi4oYtHhqIEympYzS6Xn8U+K1upKd3Y3NTjba2I7h37zwAFf7pn/4H4uOHoNVyyMlxzG+R6xOXFgtTBzGXZT1iRko8Yhug9bqMWq3G5uYmjh07Jnld5qCK+NTUVGrZWl9fp4mbNb+Vk5PjtpBDriI+ODgYi4uLSE1NxalTp2iaRGyAJE2KjIy0eI+clRY7Ginrj9b8VltbG7Ulfv/737drA7Q3B1HEWydSYhvg4OAgNSaSNbK1tTUcPXpU8tch649y19ZIIpWRkQGFQgGNRkP5LY7jbPitzMxMh4mUs5mbm8PIyIgsRXxERARWV1eRlJSEkydP0hXH1tZWBAUF0QcJYn6LfE9yGSmiiHf2s6FWq5Gfn4/8/HwsLS2htbUVjx8/BgB85zvfkcRvketzVxEv/hyJ15vFiRvhtwICArC0tCTr590dRgrYX3/MycmBUqm0eSB18+ZN3L59mz6QSktLc+uwSdYfy8vLZXUJHs4fZw4PWTKH54W/RL/5zZ9gdFSw7z16VIFHjyqQkDBovsExWKRI+4lUg+SvY08R3zutwk/uh6Pkzgr+33cnEDK7C4Gl6MNUxH3ceTsNfQkXodgLwJMn5WhpKaBpUlSUfX4LcC7kcDQLC/YTKYHf6kB2dgfW1gi/pUVNTRVqairh6bmNkJAZ2StURMghdcSlxYIN8BHOnKnD0NB+/xbPa+Hvv2R+jzgEBS1ILi22vD4WwcFziIuTtrbm6bmDzU01AAbf+MbPMDoaD55ncf/+BTx4QGyAPLKyjPD03E/ciJBDriKe9JE5W3MT81sDA0m4efMNzM8H4/HjCrx6dZRygJY35ZZDGCn3FfH7/1zgt4SHF8vL/rR/686dy7h374L5czRrsSbratxhpMSlxVFRE4iKmkBVVQ36+oT+LY4T6heCg+eoMdHPb8VcWqyXzUjJUcSr1ZswmRgADL761X+jNtBbt97AnTuE3+KQnt5j8fDEcWlxA+xxWcA+25KWluaQmbFel+nt7cWdO3ewubmJR48eged5Sesyr1MR7+3t7ZDfun37Njw9PREcHCwrvXF02HQ2RBF/9uxZagN0xW95e3tLLi0WD1kDlGrt8/X1pb//F7/4RYyOjoLYAEkKZM1vAZaJlNSRoogX81ukW+rBgwcAgIcPH8JgMLjktwD3FfH2EikxvzU1NUUTtytXrkCtVkOpVCIwMFD2YRNwXxFP+K3Lly9Tfuvp06d48uSJBb+lVqsPdNiUau0LCAigf6Zvv/02xsfHodPpLPgtrVaLuLg4i59RZ6XFjoZ8jpwlUkqlkvJbGxsb6OjowKNHjwAIn6Oenh76sMWZ8vwginjr9UfrB1JElmMwGODj40M/R3IOm+4o4g/njzeHhywZIyRSLBITBxAZOY3IyGkcPdqGhYUgkILRmzc/jdu3LyEzsxMsyyEtrQccx8LDY1tSaTEZoojXaoWDz9SyB358Pxx//n/PIo+zfUIdMbWDL/xqAP/3/+GLzWAD3qrQo69Tg5cvC9HcTGyAQpoUGLhk8VqeFxTx9kqLHY0URbyPzzoKC1+isPAlZmdD0NhYitbWY5ibC8O3vvUPtH9L4LfsJyW7u/s9Uu4p4vcTKcEGOITExCFcvHgHnZ0ZEPq3BH4rIGAROzueSEuTvurmDiMlXn+MixtDXNwYjh9vxvR0GEj/1kcfCfxWTo4BLMsjKWmAMlJyhBx9fclmRkrawYdhTIiNHcXKih/y89uQktIHoaS6FPX1JxETMwqhf0tv08dEEqnXrYj3919GSckzlJQ8w+RkJBobi8Hz+djc9MK3v/33tH8rPn7I4Z+BvdJiKcPzrE0iJfBbPUhL66GrojyvxePHp/H4cTlCQmaxtaVGVpZR8tdxXxEvCDmSkweQnDyAsrJ6jI9Hg1Qv7PNbemi1PGJjR+C4tNgxl0UYKak31EqlEsnJyVhbW0NeXh6Sk5MlrcsAOJAi3tmNhpjfGh0dRXNzM/R6PdbX1/Gd73yHpkliG6D12CstljL21h9d8VsRERHY3NyUZfo7qCKeGBzPnDmDoaEhmiaRgxthkyIjI91i7YaHh2Up4kmKV11djZycHMTHx0vit8j35Ki02NFISaQiIiJQWVmJiooKDAwM4MWLFzAahZ/1H/zgB9QG6Ozg7q4injBS4s+EK34rOjoa6+vrLnXg4jmoIp58TlzxWyEhIW4dNokivrS0VNK/7+XlBZZl8eDBA6Snp9PPEVlvdsRvke/JHUZK3EdmPeIHUufPn0dPTw9aWlrQ3S3cr/zoRz+S9EDKXmnx4Xyy5vCQJWNGR+0nUkFBCzh16ilOnnyKsbEYeoNjMOTCx2cVW1sqJCQMQa2Wzt4QRXxqqsBI3W0JQPm1ZbsHLDKGnBzsKT2QYeTRXzyJz3++A+vrXjAYiA2wErW1Z5GUNACtlkN2tgHr696SS4vJkMNmQsIggoMXJL0mNHQOnp7bUCh28MUv/g6dndlob8+14rc4REVNWrxuX8jxehXxHh6CGCQ314DVVR+0t+ehtlbgHt5//0tmGyDvlN8CxKXF0q/PkSI+PHwGZ8/WoqLiIQYHE2n/1qtXRxAQsIj1dW8kJg7IKi3mea1bivjtbRWOHHmFhIQhaDR6rKz40TTp7t2LuHdP4Le0Wg4ZGZ1YX/c2J1JPZIld5CriIyMn4eu7BobZxTvvfIjOzixqAwwKmqdpkvXv56y02NHsM1I6h4mUWr2F/HwO+fkCv8XzGnPZMfD++18UpUndTtPRgyni9xMphgFiYsYREzOOqqr7Zn5Li1evjuDlyyKEhMxiddUXiYkDDkqL62DvkEUOCZmZmZKvjyRSx44dQ1JSksN1GcImpaamYn19Hb29vZJKi62vLzo6WpK1j2EYxMXFobNTODi/+eab6OrqovxWeHg4TUqsJQHiRErqiBXxjtYfxfzW7OwseJ6nPVdXrlxxmCZZj3VpsZSZmZmxSaTE/BZJk3ieR1NTExobGxEZGYnFxUXEx8e7JeRwRxF/9OhRpKamUhsg+RwRfisnJwcsyyIpKQnr6+uSS4vFI0cRr1AokJKSgqGhIRiNRly8eBHd3d2U34qJiaFpkjWP6Ky02NFIWX+05rc4jsOLFy8AANevX0d3dze0Wq2FDdDeWJcWSxmSSInXH13xW3FxcZibm0N8fLwsIcdBFPEFBQXIyMiwqacg/FZeXh5YlkVsbCw2NzcllRbbuz6pinhSTzE5OYnu7m6cPXsW3d3dkh5IjY2NOSwtPpxPxhwesmQMz2udJlIMA8TGjiE2dgznzt1DT08aGhpKMTyciL6+VPzwh39jtgHyCApyvOZkrYhf3WLQNuKD/8995+p3nmUROjODi1d78P87FYU3Cxbh7b2BY8dacOxYC+bng0G6pa5ffwvV1ZepTCAvT7qQY3w8RjYjRUqLs7I6kZ7ei/T0Xly4cMdsA9Ra8VscNBodAgKWRYyUnD4yeYp4X981ZGYacefORRQWNsHLaws8v89v7adJlvyWZWnx61PEC/zWAJKSBnDp0h10dmbi2bNiLC0For8/FT/96V9Dq+WQl6eDn5+9G2Vh7JUWSxmeZ20SKT+/FRQXN6G4uAlTU+Eg3VIffvg5qNUbCA2dgcmkgEYjp4/MXUW8BhkZ3bSk+vJloX+L47R4+vQknjwR+C2tlkNurh4+PuuUkXJVWiweozFb1vpjQMAStFoOtbVnceRIC9TqLeh0GhG/pTfzWyM2B1GOs19a7Gw4jgXD7Dlcf1Qq95CR0Y2MjG5sbKjR0ZGD5uYibG6GYmAgBb/85V+AZXkrfqsO1lzWQRipwMBAJCYm0n/maF2mvb0dPj4+CAsLc5lIWc9BFPFpaWmUKVlfX6dpUm1tLWpra5GUlAStVku7j+QKOQDhkCDH2hcaGoqioiI8ffoUeXl5UKlUNE3y8/Oz6N+yntfJSJEhdrnc3Fysrq5Cr9fj5cuX2NjYwNDQEN577z1J/NbrVMSL+a2BgQGQ/q1Xr14hICAAYWFhbgk5iCJe7tpacnIyioqKUFRUhJWVFZom3b17F/fu3UN6ejpYlkVGRgY8PT3tJlKuRq4iPjIykpbUkj8bKfwW8PoYKfGI+a3FxUXodDq0tLRgbW0NGxsb+MMf/uAwTRKPu4wUSaTI+qN1PQXp32pra8OLFy8QGhqKsLAwtxkpdxTxiYmJKCsrQ1lZGebn5+nn6ObNmzZCIaVSCSLkkJNSHs4fdw4PWRJnd1cpsva5TqSUyj1kZnaZDwmrqKh4CL1eg0ePzuLRo7NITBwAyxJ+y/L3s1bEd016IWVwEwFLjiUWC0FBGExKwpnaWoRP7yJqahu9MypkR+3/3sHB8zh9+jFOnXqM0dE4cByLlpYCAMC//us3RGnShNM0QlxaLHXEjBQZD49deqMs8Ft54HkWNTXnUFNThcTEAQwPx0OrfSVTyCFfEU9Ki0+caEZIyDzOnHmEoaEEmiZxXD78/ZcomxQZOSW5tFg8chXxxAbY2ZmJ2dkQnDr1BHq9BvfuXcD9+4Tf4pCV1WnBbwHOS4sdzdKSP/r6UnDqlOP1x4iIaVRW1qCiohYDA0l0xREA3nvvq9QG6OrAcDBF/P7nSKXasuK3BGPi7duXcffuBaSm9qCvL0V2aTHPswgMXEBCgvT1R71eA0CBkpJGhIXNoqrqAXp7U8DzWnBcPlpaChESMkt73EJC5jE5GYHJySiXpcXiEfeR2U+kLMfLaxNHjrRhcDAR8/PBKC5+hvb2PMpvCevNPNLSnkGptOSyjEaj24xUaWmp3RsNe+sy5EYZAD744AOaJrmygB2UkSLj7e2NgoICFBQUYG5ujiYl169fR3V1NTIyMtDV1SX7sMlxnFuKeJPJhJMnTyIiIsKuDTAiIgJarRYajQb+/v6SS4vFI3f9kdgAp6amsLCwgKKiIrS3t+Pq1avUBkjSJOsESe5hE3CtiGcYBsnJyUhOTrZI3Mja1Y0bN2ia5IzfAtxTxNtLpPz8/FBcXIzi4mJMTU1ROUVXVxfUajWysrLQ0dHxsTNSgJBImUwmnDp1CtHR0bh8+TJNkwi/FRcXB1K94OPjI7m0WDxyFfGBgYEoKyvDwsICXr16hSNHjqCjo8PCBsiyrA2/BewLOV4HI0VGqVQiIyMDGRkZ2NjYoA81SNp9//59+h65Oti9LkV8cHAwfSBFOEm9Xk8fSOXm5kKn08k+bB7OH3cOD1kSp6cnDevrPrKseOJEqqBA+B+B3xLSJNItRW5wUlN7oFTuUUaKlBavbyvgt+DcEsib/8PAmiFIv6U9rG/bX5NgGJifpu/h5csiFBQ8x+qqnxW/JfRvBQRY8lvOSoudXp8LRbzAb71AYeELzM6GgvSB7e15QKfTYnfXEyzLIznZMb8F2JYWSxmy/ihOpAR+axCJiYPmNElI3JqaTqCxsRRRUeNQqTahUMgrLXZXEW80ZkGrfUXZJLEN8KOP3hHxWxySkgbBMCZILS0WjxxFvEJhQkpKP3x81sBx+dBq27C66oeGhjLU158y81ucmd+y5KBIIuWOIl5gpOwnUgK/1YiSkkZMTESC57VoazuC3V1PGAy5UCj2oNVyiI8fdvr5sC4tlnN9YkW8YAPsQXp6DzY31WZ+i8Xjx+V4/PgM4uOH4Om5DYaRK+SQr4gXlxaXlz/G6dOPMT4eQ/u3DIZceHuvIS/vPWi15xETEwOGYUCsfa+bkSJD1mVCQkJoYrayskJtgM7WZZyVFjsbjuOcJlIhISEoLy/H6dOnMTIyQg9cOzs76Orqwr1792ia5OxGlDBSJSUlB1LEi22Aa2trtFvqwYMHqKmpQXJyMrW3yTkkDA0NYWFhAWfOnJH8GpJI5eTkoKqqCpWVlRgcHKSHZHKoJGwS+R7kCjkAeeuPnp6eyMvLQ3R0NLq7u5GRkYHl5WVqA0xNTYVWq0VmZqbNIdlZabGzcZVIRUREoKqqCmfPnqWJW3t7O3Z2dtDf34+HDx+CZVmX4hV3FfHWpcUqlQparRZarZbyWxzH4fbt27RbihxC3GGk5CriyRrt5cuXcfHiRZomERtgSEgI/RwR5sg6kZIyZP1RSiJF6ilSUlLw/e9/H8nJyVheXrapp0hLS7M5sEkRctgbjuMcKuLJenNcXJzFA6mWlhbZq8GH88efw0OWxOF51oKRkjIkkSLyCoDwW09w8uQTjI3F0m6p9vY8+PisIiOjC0NDiSgv3y8tVnvsYc3f8X/ITQB4rRaJAwMIWlgAAKz7KuDl4fzmkFj7zp59CC+vDayve6O9PQc8r0VtbRVqayuRnNwPluWQnd0BtXpLcmmxeDY21OjszMSRI44ZKfGEhs7izJlHGBhIxPz8DtLTu81cmRZ+fsvQaITELTJy0ua17ijiJyaizYmU/fVHa35LrxfYpKGhJAAmXLnyWXP/ltEmTbK9vtejiLe0ASaC9G8Rfiszs9NtIUdc3LBkRop8TwrFLs6duw8fn3UsL/vR/q27dy9Z9G9lZnbCw2NHcmmxeCwV8a4TqaioSURF3TevJUYgJaWP8lvBwXM0cbOnw5ci5LCeyUmBkXKkiFerN5Gf/wr5+a+wuBgAnY4Fx7EYHk4Aw+yhuvpTEPq3ul3+nLiriBeXFgv81hhiYsZw7tx99PYKZeetrT548eJfEBoaiqysLPT09KCsrMwtRspZeav1kETq0qVL8PX1pesyHMc5XJeRWlosnu3tbXR0dEhKpBiGQXx8POLj47GwsICRkREkJiZSGyDht1iWtXtzLuewScaVIt7Hx4euphF+i+d5LCwsgGEY1NTUSOK3APcU8daJlNgGKE7cnj17hsbGRkRFRSErKwtdXV1uCzmkMFLi1wDA5cuXERAQgOnpaZomXblyxYbfYhhGcmmxeMTrj64SKcJvpaSkYH19HYODg4iKikJ9fT2ePn3qlN8C3GPt5ubmMDw87FARL+a3JiYmQIyJKysrUCgUePr0KViWdclvAfuHTXcU8eR7UigU1Aa4ublJ0yTCb8XHxyM7OxudnZ0oKCiQzUi5u/746U9/GoGBgTb1FITfIv1bDMNIKi22HnEfmatEijyQyszMxPvvv4/BwUFZQo7D+ePP4SFLwqyvk0TqJZRK171TZHhei7CwaURH27JUAr81itjYUZw/L/Bb4rUrjsuHQgFoNDzSw5fxXkooVn0Z+K7aHpzGYmMxGxaGksZGAMBCkBIj0Z5IDnO81kgYKbEi3tt7nSZuc3OE39Li+vW3UV39KWRnd2BxMQBeXvJKi8khQa4ifmgoCeXlD3H69BNcvHjXzG+xaG4+jmfPShAZOWE2Jurg778subTYesj6o5REytd3DcePP0dIyBx++9s/Q3a2AWNjsdQGSPq3kpIGbBI3kki9TkU8w5ioWe7Spdvo7MwEx2nx8mUBAAYGQw68vNah0djaAK1HXFosdfb29u2PRMjh77+C4uJnKC5+hqmpCJq4dXVlQq3eQE5OOxYXg6BWyystdkcRv7zsj4EBobS4ouIRtraq0dGRBZ7X4smT03jypBxxccNgWQ65ue30e5BSWmw9++uPrhOpwMAllJXVIzp6DO+991WkpvZgaChBZANsB8va57cclRa7vj7WrIgftPk1gd/qQkZGFzY2VmAw/H9BSlgBoLe3F0FBQZLWZQgjdeHCBcnXJmakyE2mq3WZvLw8LCwsfCw9UtazurqK3t5eFBcXo6qqyi6/lZycDJZlLW66pZQWW4+c9cfQ0FCcOXMGSUlJ+PWvf43ExES6Mufv72/Rv2U9jkqLXY2zRMrT09OG3+J5HnV1dQCE9TqdTmfXBmg9B1HEi0uLw8PDUVlZaZEmEX4rMDAQGo0Gc3NzsoUcchkpQFh/7OnpQVFREc6fP4/l5WX6Ht29e9emf4ukk9aJlJSRs/4YFRWFqKgoZGZm4t/+7d9oaa89G6D1kEPC61x/VKvVOHLkCI4cOUL5LWKVBICpqSkYjUaX/Bbw+hTx1vUUPM+jtbWV8lssy2J2dtYtIYc7ivju7m7ZQo7D+ePP4SFLwhgMueZESvrN3cJCEIaGElFRUesySSD8VkZGF37wg/8OhWIPfn6rePjwLB4+FPitZM8ePKlYx8Wbtjd9HMtCubODHDPP8OS8HwoT1uDt6TjJ6u1Nc2rtCwmZpytFpH9Hr8/DxoY3PD23UFNTCZZ1zW8Bws3dQRXxHh5CKXNOjgFraz7Q64Vk68GDc6ipERK3hIRB2UIOcY+UO+uPn/nMR1Aq9zA4mEDTpH1+S0hKIiKmALh32JSjiCf8Vm6uHj/84X/Dzo4HPDx2cO/eRas0yWj35txRabGzcaWIj4iYQlVVDc6ercXAQDJ4XlhN295WQaXaxJMnp8GynKTDzEEU8eRnV6XaglYr/LksLRF+S4vbtz+Fu3eFbqmEhEHZpcVk/VGuIl6nE9Yfv/CFP0Ch2KP81qtX+Xj5UuC3CG9GHhxIKS22npUVP/T2pkpSxHt5PcHRo3k4evQofvjDH2JjYwNbW1uS1mUA9xgpZ4p4Z+syu7u7UKvVaGpqAsuykniQg6w/knUjV/xWdnY2EhMTZZcWu6uI1+l08PT0xJe+9CUoFAobfisyMpIybuT3dfew6YyREg/ht44fP44f//jHWF1dxdLSErUBOuO3gP3P0etSxFvzW6RbqqGhASaTCd7e3mhra4NGo7GbJlnPQRTx5HPk7+9P+a3JyUmaJhF+KycnB8nJybJLi8VCDjnWPr1eDw8PD/zZn/0ZGIaxawMkiRvplnKHkZKjiCf8VmlpKX72s59hYWEB09PTeP/99ym/pdVqERsba/f9cYe1c5ZIOeK3SAeXj48PXXuWwkodRBEvR8hxOP8xc3jIkjA8zzpMpJy9BoAs29roaCwWFkLwxhvXcfRoG+bnCb+lxfxcJZoLyjEZ2oWShjak9vZCubeHXYUC7Xl5yOzshNfGBjpy1XjyKT/8n/m2q3TW1+fjs+oykWIYID5+BPHxI4iImMDt228gJmYUz58Xoamp2GwDFPq3AgKWbV5PSotfpyLex2cNRUUvUFQk8FskKenrSwVgQn9/MoKC5pGc3O+U3wLsCzlczb4ifj+RSkoaRFLSIC5eFNIkntfi2bMSNDaWISpqHCzLwWDIQUjILOLipAs53FXEz86G49KlWygsfGlhA7xyhfBbQrdUYqLAb0ktLba9PmmKeIHf6kNKSh/i44dw69anER4+jfr6Mjx9egqxsSMg/Vv2Din7Qg65injWrIi3PcQFBCyjtLQRpaX7/BaxAQImjI3FYHg4HnFxzvktQFxa7J4inqw/ivktg0Ho36qrO4O6OoHfYlkO7e25skqLAUCny5OhiBf6sqam0jAzM4Pz58/j+PHjNusyBL4Wr8vYS6SkjFRFvHhdpqWlBbdu3UJgYCDlt5KSkii/Ze+puqPSYinX5yiRsua3iDGRlITOzs5iYmICkZGRLr/mQRTx4tJiwm+trq7SxI3wWykpKWBZFjqdTjYjZX1IkDIzMzOYmppCVVUViouLMTg4CI7j0NHRQfktkpSQ91fMSH0cinhPT09oNBpoNBq0trbi5s2b8PLyovyWOE2yl7g5Ki12NUQRby9ZjIyMtOG39Ho92traAAif3dnZWbs2QOtxRxFvL5Ei/NbS0hJNk8T8Fsuy4DjOLSGHXEX8wsICJiYmUFFRgZKSEtq/Jea3yOeI8FsfByMlHsJvHT16lP59pFQqaT2FqwdSroQcjkaOIv5w/mPn8JDlYubnhUQqMHAera1HkZtroOt1jkZcWuxM1W491or44OAFnD79BKdOPcHoaCwePTuKHiYXg0k58FldRZ5Oh6D5eaz5+iKji8edtwJQ+1l/fPPcDCL8Ha8RbWx4wWjMwtGjLbLWH9vbNQgNncHXvvYrbGx4o71d6N+qqamiaZLQv9UBlWoLgLTSYuuRo4gPDZ1FRcUjnDr1GN/61v8Bb+8N9PSkob09D/7+S2ZjIm+X3wLslxa7GqKIt3fw8fTcQV5eO/Ly2rG66mvmt1jcv38BgAnBwXPQ6zWS+C13FfHWpcXEBiikSUngedK/dRSBgQvQaHQICpqTVVoMCIyU0ZgFluVlrT8aDLkICprHN77xL+b+LSFNunPnEu3fYlkOmZld9PCxL+SQw0hFmhMp1+uPhN+qqKjBd77z9/Dw2KWpZHDwHEj/lqM/ByLkeF2KeLV6E0eOvMKRI6+wuBgIUnZeXf0GABNCQ2fQ2ZmB9PQeSZwjz8tVxNeB59dokiC2AZJ1GY7jbNZlgoODZZUWA+4r4o1GIwICAvBf/st/sejfunHjBr3B0Wq1SE1NpTfC7jBS09PTkhIpMb91/vx5fO973wPDMGhra0NLSwsiIiJomuRIruBKyGFvnFn7fH19Kb81MzNDk5KrV68CEFbp+vv7JfFbwMEV8WJ+S2wDbGxsRENDA6KiokAKWOWUFgPurz92dXXBz88Pf/M3f2PxHl25cgVqtRrZ2dnQarVITEykh2R3DptSFfFifuvixYv4wQ9+AJPJhOfPn6O5uRmxsbE0TfLx8bH7e7iriHeUSAUEBKC0tNSif0uv19MS5oiICIyOjtq1Adobsv7oDiPFsiyUSiXltzY2NmjiVldXh7q6OiQkJNDPkZzSYsDysCnH2tfX1wcfHx/89//+3+l71N7eTh9Ikf4t8kAKcF1abG/cUcQfzn/cHB6yXAxJpBQKE27d+rTIBsghLa3H7iGFlBaXljbY/JqjcaaIF2yAo/jK50YxOHMfN2o1mBjOxfPjhQCjBLCH3309Dalp6/iHsjFEBTjnNAyGHDfWHwMtSosFfuslCgpeYm4uBMSYeO3a26iuvoysLCM0Gg4cJyRSQUELkr+WO4r4vr5UbG564623riEtrRddXRngOC2am0/g2bNSM7/FmfmtFQDSSovtDVHEu0qkfH1Xcfx4M44fb8a9e+fQ1FSC7W0V5bf2+7cG7K5w7Qs55CnirRkpMgK/1Y/k5H5cunQbRqOQuDU0lMJkUoBh9rCwEIjVVV9JWnBSWnwQRby//wo1Jk5ORtA0ifBbhE3iOHmlxcD++qMcRfzgYBLW133xzjt/QFpaj9kGqMXjx6fx+PE+v5WX104V/CSR+rgU8YGBizh5sh5lZfW4d+88mpuLsbbmi/ff/5KZ39JDq+URG2vLbwH2S4tdzd5eHXQ6b7uJlKt1GYZhsL6+jo2NDUk3KUQRL+eGdWVlxaK0ODg4GKdPn8apU6cwOjpq0b/l6+tLb3A4jpNcWkzGVY+UvRkdHcXa2ho+85nPIDU1laZJNTU1FmmS+EBAhBzOSosdXZ8URXxYWBgqKipw5swZ3L17F8+fP8fi4iLee+89agNkWdbhAcpeabGrcbb+SGyAeXl5WF1dteFuGIbB3t4etre3Jb0fpLTYHUU8SaQiIiJQWVlpt3+L8FtardZpIuVo3Flbm5qawtraGt58802kpqbS9+jOnTu4d+8e0tLSoNVqkZGRQfktKaXFjq7PVSLFMAzlt6qqqnDv3j08f/4cc3Nz+Nd//VeX/BYAqoh3Z/3RniLey8vLgt8iD1tu3boFhmHAMAw8PT2xu7srKS1yl5EiiZSHh4fdeoqWlhY8f/6cPpAifx/JTaTcUcQfzn/cHB6ynAxJEpKS+vHVr/4KY2Mx4Dgt2tvzYDDkwsdnlRaMxsSM0RscV6XF9kaqIj4xbBN/+4WXWFxvxaveCDz+6K+g8loD5gsx9qIA96YHIBSMGqBW2xdfEEYqJkY6I0UOm/auLyRkDuXldTh9ug4jI/HUmEhSrMDAXkxMRCIqyvkKI3BwRTx5sk/4rdVVH9q/9eDBedTUVCElpQ8sy2Nz01NWaTEALC4GYGAgCadP18laf+ztTUN8/BD+4i9+icHBRNq/RWyApH8rImKavk6OkINMX580Rbyn5zY0Gj00Gj1mZ4Pxox/9DdTqDdy/fwEPHpwTpUmdDuUKRMjxuhTxkZFTqKp6gLNna9Dfn0wPXK2txwAAaWndmJ0Ntbv6Zz3iHil5ivj90mIPjx3k53PIz+ewtBQg6t/a57dYlsPGhpfsw6Y7iniGEdYSY2JG8fWv/wK9valmfusIXr4sMvNbnJnfWqCvc1VabG8GBoYlJVLidZnp6Wn89Kc/hYeHB27fvo179+4hKyvLwgZob+yVFrsaa0aKjJjfunDhArq7u8HzPF6+fInm5mYAQHp6OhYXFyWxKq9DEe/p6YnCwkIUFhZa8FvXrl1DdXU1fY/W19fdYqR6enpkWfsYhsHIyAgiIyPxl3/5lzRNampqQmNjo11+C3DvsClVEe/r64sTJ07gxIkTmJiYwL/8y79AoVDgxo0buHv3ro0N0N7YKy12NY4SKXGaJE7cGhoaUF9fDwDIyMjA2tqapLVY8WHTXUW8Wq2mNkCSlIj5LdIttbq6KvuwKYeRIqNQKDA+Po7w8HB8/etfp4yb2AZIuqUIvwW4d9iUqogPDAzEyZMnUVZWhpGREfzqV78CAHz00Ue4c+cOfdjiiN8i1/e6FPHi9eaNjQ36sOXRo0f0oVRmZiY2NzclPZByd/3xcP7j5vCQ5WRGR+MwNxdqvhECYmPHEBs7ZmEDbG09hhcvjiM0dIYaykgi5eiQY2/kKuIDvffgtxkDk0mJr7z7O/j4rNM06caNN3H79iVkZRkh9G/1QqEQEreFhSBzIuVayEGGHDZdJVICvzWM+PhhXLhwF++//3n09KRjYCAJP/3pfzXzW0KaZI/fAsRCDvmKeHuJlK/vGoqKnqOo6DlmZkJBDI5Xr34GDLMHlWoDm5sq7O0xLvktYL+0WM7BTKyIZxgTkpIGkJQ0YO7fygTPs2hsLEFDg8BvabUccnLaZZUWk+F51sxISV9/HB5OwN6eEl/84u/h5bVB36Pu7gyo1RvIzjZAq+WQmDhEDwQkkfo4FPEKhQmpqX1ITe3D5cu38Ic/fA69veno7U3FP//z35r5LSFNcnSAslda7Gr2FfG2iVRAwBJKSxtQUtKAyckocNw+v6VQ7EKl2gTDmGAyQdL74a4inpQWCzbAbmRkdGNjQ42OjhzwPIu6ugrU1VUgIWEQLMsjK8sgq7SYDM9nQa32cMlIiWdiYgK7u7t49913oVKpLNIkR+syJJFyVFrs+PpcK+KVSiWysrKQlZWF9fV1XLlyBb29veju7sb3vvc9l/wW4D4j5UgRL+a3hoeHQXqTdDodlEolPD09Za0oEbW3XEaKlBZ7eHjYtQFa81uZmZluCTl4npdtf5ybm8Pu7i6++MUvwsPDAxzH0TQpICCApkniP3tXpcXOrs9VIqVST9+3XwABAABJREFUqSi/tby8jGvXrqGvrw9dXV349re/jfT0dLAsi4yMDIeJG1HEnz59WvK1OVPER0ZG4ty5c6isrER/fz9dcWxtbYWnpyc8PT1l3YTL6ZEiI06kvLy8kJ+fj/z8fMpvcRyH6upq3L17l75HaWlp4DhOcmkxGbmKeIZhsLq6it3dXXzhC1+AQqEAz/Noa2uj680kuSX8FnAwRsqVIt7LywvHjh3DsWPHMD8/j5s3b6K/vx+dnZ349re/bVNPYW/cUcQfzn/sHB6ynAzHsXYTKWIDzMzswsaGl5nd0OLRo7N49Ej4j7Gv7wo2NtQ2q3/25iCKeFJazDDA6dOPcerUY4yOxtE0Sa/XwNd3BXl5QuLW1SUYbFhWJ/nrjI3FYHY2DMXFjZJfwzAmjI3FISenA5cv3zLzW1rU1JyzSJPE/JbwPbFOS4vtzX6PlPMb1rCwWVRUPMSZM49gMGTjww8/j91dJd5776tmG6CQJkVGTtl9vbi0WJ4iXms3kSI2wLw8PVZWfGn/1r17F3D//jmYTAoEBc1je9vTJb8FCIr4jo5saLVyFfH7pcUMA1RW1qCigvBbWit+SzDzdXZmQmppMRl3FPEeHruYnIxGZmYnLl+upmnSnTuXce/eBaSnd4NleWRkdFkcjFyVFtsbooh3dvBhGCAqagJRUROoqnoAvT4HV69+Fjs7HvjlL7+BkJBZaDSCDdAZR/c6FfFeXps4cqQNR460YWEhEDqd8LDl1q03cPv2JeztKaHR8NjdVUpai90vLd6VvbYWGBhI0wZH6zJhYWE0Keno6JDNSE1NTWF8fBznz5+X/BovLy9MT08jLS0Nly5dsuG3xImb+CbdHUZKirWPYRgkJCQgISEBFy5cgE6nw40bN7C3t4ef//znkvgtwD1FvKNESmwDJGwSz/O4evUqPDw8sLOzg9zcXOzt7Uk6yIhLi+UwUkSGkZKSAoVC4ZDfio6OpmySwWCQ3SMllZESj5+fH+bn55GSkoLz58/bpEkkcRPzW8D+YfN1K+IVCgVSU1ORmpqKy5cvg+d5VFcLf7/+6Ec/ksRvketzVxFvfX1ifkvcv2U0GqFWq7G5uYnc3FyYTCZJ7/tBFPE+Pj5U82693mzNb+Xm5rp12FxYWJCtiA8KCsLS0hISEhJQVVVFJSfiB1JarRbR0dEWv6dUIcfhfHLm8JDlYHZ3lWhvd51IeXlt4OjRVhw92or5+SD87ndfwsxMOJ4/P4HW1mNmfotHaqp9fgs4mCLeOpES+K0RxMWN4MKFe+juTgfPs3j5sgDNzSegVO4gKGgeDCPvMCccEqSvP4oV8T4+6ygsfInCwpeYnRX4LZ1un98SuqV4REePmoUcrTIZKRYhIbOSFfEMY8LcnLAv/td//VNMTQksUFPTCTQ2lpptgEL/lp/fCn2dq9JieyNY+/JcKuL9/FZx4kQzTpxoxvR0OP7wh89hdjYMTU0laG09Zua3OCQlDTpcL7NXWuxqHCniBRtgP1JS+nHpUjU6O7PA8ywaGspQX38KHh7bCAycl5XWHkwRz8HffxklJY0oKWnE5GQktUp2dmbBy2udGhMjIydklRaTIYr4hARp648KxR5WVvwBMPjLv/w5JicjzfxWOR4/JjZAHrm57RZp5L6Qwz1FvK+v4/XHoKBFnDz5FGVlTzE+HoOrV9/GzEwYGhvL0NZ2FHl5erAsh9jYUYeJm3VpsZRxlEg5WpchNkBPT08EBgbKTkfkrq2JS4vF/NbIyAhNk/R6PeW3tFotQkND3RJyyFXEe3h4YGtLeND053/+51Tl7YzfAlyXFtsbcY+Us/dczG8NDg7i1q1bmJ2dRUNDA3iep2mSs8Odu4r4np4em0RKzG+trKzQxI3YAFUqFQIDAyWZ98i4s7YmTqQiIiIc2gADAwMpdxMUFEQPCXL7yOQo4lUqFUwm4b8N7777Lqampiz4LXHiRvgtwHVpsb0xmUzgOA7JyckOHwIwDIPo6GhER0ejqqoKfX19uHPnDjY3N1FfXw+DwUA/R+I0yXoOooi3TqTE680LCwuUcSP1FCqVCv7+/rIfWgDuK+Id1VNYP5Dy9/eXXFp8OJ+cOTxkOZjubsJISV/n8fLawNxcKAoKnkOr1YHjhE6g9vY8+Pis0hscMb8FHEwR7yxJUCp3kZVlRFaWEevrXmhoKEVDw0ksLATje9/7n0hKGgDLcsjJ6XB4s2yvtFjq9dlTxIeGzuHMmTqUl9dheDgePK+lKZdavYHdXQ+7pbuOhijiy8vlKuKF9cfw8BmEh88gN1fgt0iadP/+eTx4QBI3DllZRoeJlLNxRxEfELCEhYVgHD3agtzcdpD+rX1+S0iTwsOnLV7nrLTY0ThjpMioVNvQaHTQaHRYXvbDs2clePasBIuLwfj2t/9elCY55rcOqoi3TqQiIydx7twDVFaK+S0Wra0F8PFZxfa2CklJA5K/zvKyP/r7hdJiqYwUub7Y2BFER08gOnqC8lv7NsBP4e7dC2Z+i0d6erdIyCGHkZKniGcYICxsGouLgcjPb0N2thE8z6K19ShevCgyrzcLiZv1CvB+afEdAFsAXN8Y6nQ6u4yUeKzXZZqamqh8Qeq6zEEV8eJESmwDFPNbL168QHNzM/z9/bG1tSWLzXBXEc9xHKKiomi6VVhYiNnZWRt+i3RLJScnu9VHNjQ0hMXFRVRUVEj69wnjtrKyAo1Gg8zMTAt+i9gANRqNDbMmVcghHinWPj8/P8pvTU9Po6mpCa2trdjc3MS3vvUtSfyWvdJiKWMvkbLmtwibVF9fj6dPnyI4OBgbGxvIyMiQ/HUOoogPDw9Hamoq0tLSbNKkzs5OeHl5IScnB1qtFvHx8W4dEuQq4hUKBZKTk7G+vo7s7GxkZGRI4rfI9yRXES+lRyooKIjyW+Pj43j+/Dk4Trjf++53v2tTT2FvyGHTHUW89fqjqwdS4eHhsoUch/MfP4eHLAfD81r4+q4gNbVX8mtIIpWfzyEmZhyxsaM4f/6+md9i0dJyDM+fH0dY2DRIt5TJxEguLSbjjiLe23sDW1sqKJU7+MY3/oV2Od248RZu375s5rc4pKb2UX4LcF1abG82NtQuFfEMAyQkDCMhYRgXLtxBV1cGbt0S9NRXr34WjY2lNE3y97fPbwHuKuKj7SrifX3XcPz4cxw//hwzM2GUcbt6VbAB7u0pEBs7Kpu1c1cRr9VyiI8fQXLyAC5dEvq3OE6LxkbhsBwdPWZm3PTY3VWaEyl5Qg6OExipkBBp1j5//xWYTIBCsYuvfvXf0NWVCZ2OpTbAnByB30pIGLI4rLgqLbY3RBEvJFL2k01LfqsaHR1ZuHdP0OV/9NE7eP78uDlN0js93FmXFksZR4r4gIAllJU1oLS0ARMTAr+l12vQ0ZEDb+817Ox4IDZ2BN7e0oUcHKd1QxGfZVbECwloRkYXNjbUMBhywPNaPHpUgUePCL/FITfXgJ0dD1FpsdCXBbje/+d5HjExMQgLC5N0bcHBwTQdevfdd9HV1SVpXcZZabGjkaKIt+a32tvbUVtbCwC4cuUKWltbaZrkbGXJkZDD2UxPT2N8fNwmkQoNDcWZM2dQXl6O4eFhyiaRhGNrawtxcXFu9Ui5s/6Yn5+PlJQUG37r/v37ePDgAVJTU8GyLLKysrC1tSVbyAHIV8SHh4fTw/Y777yDnp4el/wW4Ly02NGIrX2OEimVSkUTrOXlZeh0Ojx58gQAcPXqVeh0Osq4idMk63FHET83N2e3tJjYAO3xW0FBQdjY2EBcXJwsRornebcV8UeOHEF6ejry8/OxuLhI0yTCb5H+rfT0dGxtbckWcpDrc8VIkWEYBjExMTRNe+ONN9DX12dTT0FSSfFIFXKIZ3d3F3q93mkiZf1AiqzJenl5ySotPpz/+Dk8ZNmZ9XUvdHVloKBALiNFEqlx+s+Uyl1kZnYiM7MTGxteaG8XbnAePjyLhw/PIjBQ4DYyM42Svw5RxJeUyFHEK9DenoesLCN96n769GOMjMTRNGmf3xK6paKixsFxWkmlxeKRq4j38NhFTMw41td9UFb2BAEByxBsgOdo/xbLcsjONlrwW65Kix0NWX90pogPC5uh/NbgYALq60+itzcNQ0OJ+N73/idNkyIi7PNbwOtVxNvyWwKbdO/eRdy/fx4hIbMAGFna+4mJKExPR+DSJXmKeJJIJSYOIzFx2Ny/lQyeZ6HX56GtTeC3SLdUWNgsTaRclRaLhyjiXbF2ZFSqLSQn92N93RvHjzchIGAZHKfF7duXcfcu4bc4M79l+efhrLTY0bhSxDMM6M/auXMP0NubgsbGUgwMJGN4OBH//M9/S9MkZ4zf1pbASIlLi6UMz2ttSou9vDZx9Ggbjh5tw8JCEE3cSD1FWNgMTCaFKGWrg6tD1tTUFCYmJnDhwgXJ17a3twee55Geno60tDSkpaXh/PnzNE2yXpdhWRaBgYE0kZIj5Ojs7MTW1pbkJ8De3t7IysrC7du3cfToUfj7+4PneVy/ft3CBmjNbwHShBzW42r9UcxvXbx4EV1dXWhqasLw8DCGh4fxk5/8xK4N0HrslRZLvT7rRMqa3yJs0kcffQSVSoXw8HDs7e3JSkcOqognAg9xmmTNb2k0Gvj6+kouLRYPUcRLPfj4+/sjPz8ftbW1YFkWfn5+NvyWVqtFQkKCTVJyEEW8o8+5Nb/V0dGB58+fY2FhASMjI/jFL35B0yRn/NZBGCnrRCowMBBlZWUoLS3FxMQE7d/q6OiAt7c3IiIisLu7K+tzND8/L5uRElv7yDqhdT3Fo0ePkJiYSGU5Xl5e9LAph5Hq6emRtf4YHByM48eP48mTJygoKJAl5Dic//g5PGTZmfZ2IZGSk96Q0uKKihqHSYKX1waOHWvFsWMCv8XzLJ48EWxDP//5N2n/Vmpqr9PDnbuKeGtrn2ADHEF8/AguXLiL7u50cJwWL14Uobm5GGFh05idDQHL8m4KOeQo4oW/RI8da0VQ0AIKC1+Y+S3BdHft2mdQXb1l5rc4JCf3Y2KCJFI3JH+d3d39HikpinjBBjiIlpYCeHmt4eLFO9DrNXj2rASNjWVmfktIk8T8FiBOpF6vIl7gt5pw4kQTpqfDwXEsnj0TboR/8Yu/omxSYqJjfguwLS2WMmJGiozAb/UhJaUPly5Vw2jMAs9rUV9fhqdPTyE6egyTk5HmQ4L0wybHad1WxBcWvkBo6BxKShoxMREJooMn/Bbp34qPH5ZVWkxmb4+h9kcpiniFYg/p6T3Q6zVQqTZw7tx96PUa1NWVo66O8Fucmd+y/Fw6Ky12NFIU8UFBCzh16ilOnnyKsbEY8LwWL14UAAB+/euvmespXiImxjmgzvM8FAqFrLW1gYEBLC8vW6Q31mkSucEh6zIJCQkYHR2VzUhxHCeLkQL2E6njx48jIiICp0+fxsjICDUmEn6LGMqioqIwMzMjW8ghVxFPbui6u7sxMTGBM2fOoL29ndoAk5OT7fJbgPPSYkcjRREfFhaGs2fPoqKiAoODg+B5Hq9evQIA/O53v6PvkSvO5SCKeHEi5enpSW2AhN/iOI7yWykpKRgaGkJmZqZbjJQ7ivji4mJERUVRfoscJqz5rbCwMLeEHOSQ4IyREo9KpYJWq8Xw8DAmJydx6tQptLe34/bt29QGqNVqkZ6ebpO4kURKTsq2vr6Ozs5OFBYW2v0cifktUnZOWElAULCT98gZvwW41yNFEilxabE1v0VWd2/evInbt28jIyMDvb29yMjIcEvIIVcRL1fscjifjDk8ZNkZntfaJFKuX0PW1qRZ+4KDF5Ca2oe6ugqcPPkEGxte0OvzRPyWkCZFR1vyW85Ki119T84U8Zb8ljfa23PR2FgCk0kJjsvH0lKg2QZogFq9Zff3AMSlxQdXxAv81iOUlz/C8HAC7ZbieS38/Zfg67sChUKukCNV9vqjOJFiWR1YVofVVWIDZGm3VGpqr1mbbYSn5zZNpGJjnZcWi0euIj48fBq5uQY0NJzE8ePPsLnpZWUDFIyJ4eEzFq9zVlrsbPYTKfvrjyrVNn2Plpf9oNNp0Nx8HHt7Suh0LDY2vCH0b3U5TWWIkIOUFsu5PuvS4qioSURF3UdlZQ36+pLpwb2lpQDBwXPw9V0Fw8grLe7vFxgplpXGSAGWinjysGVxMYDaAKur37Do3yKdb1JLi8Wj10tXxJN6Ck/PHTx/fhxHj77Exoa3uZ7CA6Gh/wyW1dpdl9nb23ObkVKr1Q4TKW9vb5t1mRcvXmB3dxcGg4EaCe2lSeKxLi2Wc33i0mJH/Nbz58/R1NRksbYm57B5UEV8cXExiouLXfJbRGEtl5GSo4hnGAZJSUnw8/NDW1sbSPcXSZOc8VtShRzW48raJ+a3iAiitbUV29vb6OzsxPXr16HVam1sgNZzUEU8sfaJ+a3Lly/b8FuxsbF0hcwdIYdURgqwVMSfOnUKJ0+epP1ber2e8lukfys+Ph4Mw9BESqqQA5C3/qhQKJCeno7Q0FDo9XpkZ2djfX3dxgaYk5Njw285Ky12Nq4SqaCgIPoejY2NgeM48DyPra0t9Pb24s6dO7Cup7A3B1HEyy0tPpxPxhwesqxmfj4Yw8MJKC+Xf0hISupHYKA0RgrYV8SXljZArd7E+fP30N0t9G+1tBTg+fMTZn6LA8vqEBi4KCotlsNIEUW8Y0ZKPN7e6ygoeAm9Pg8mk8A76XQsrl9/y8IGmJJiyW8B8g+bgGtFvMBvDSEhYQgXL95FV1cGOE6Lrq4MAAz+7d/+HKR/y99/xe7vsX99+6XFUsdeIuXru4rjx5tx/HgzpqfD6I37Rx8J/FZaWg8GBpJx+vQj2YyUfEW8UFp8+vQTeHuv49Kl2zAaBeauoaEU9fUnERMzCpblkZenh6/vquTSYvHIVcT7+6+gpOQZenrSATDIzdVDr9eI+C0hcbPmtwBpQg7rmZiIdKqIVyj2kJbWi7S0Xnrg4TgW/f0pABj87ndfommSq4MnEbUcVBEfGLiEsrJ6lJbWY2IimspyCL+VkdGJ3t4U2UIOjtMiJmZUliKelBZXVDyCr+8qrafg+a86XJchjJQcw52zHil7Q2yAw8PDmJiYQHZ2to0NkGVZG34LOBgj5SiRIixKdnY21tbWKKA+MDAAYP+puyt+C3h9ingxvzU0NERTAHKwyszMRHd3N4qLi2UfEtxVxFdWVsLf3x+rq6uUu7HHb3l6esoWcgCWhwQpiVRERAQqKysxPT2NoaEhZGRkUH4rMDCQ8lv2uEJ3kgRxImVv7PFbPM+jt1fgwKurqyXxW4D7jJRYEc8wDOW3iA2QHNxbWloQHByM7OxsGI1Gtw6b7iriz58/j8DAQAt+i9gAMzIyoNVqkZaWBqVS+bExUmRINUVsbCx9gJOSkkLXm53xW4B7fWREEX/mzBlZD4oO55Mxh4csqyGHhObmYqyt+dm1AVrP6GgsLS2WOvYU8UKa1ImsrE6sr3uZUxsWDx9W4uHDSiQl9WNzUwVv71VZQo729hzZ64/i0uJTp56ivLwOIyPxtH9Lp2Ph67tCk5KoqAkAws2nIORYkPy15CjiPTx2kJNjgIfHDrq6hG6xiYkoPHhw3qJ/KyurAyqVZbcUKS0+csQ9RspRIhUePoOzZ2tRUfEQg4OJVC0OAC0tBdjZ8QTLcoiImLb7ejJEyCFfEW9ZWuzpuQ2NRg+NRo+VFT/odIIx8e7di7h37zzS0nqwsaGGWi2vtLijQ/76o1gRX15eZ2ED1Os1aGs7hqCgecq4hYbOUtbOVWmx9eyvP7q29qlUW9BqOfj5raC/PxUaDYfJySjcvv0pUZrEIz3dlt/aT6RenyJe4LfGER09bua3UkGqDgAFdDoWHh67Zn5rwenXEZcWSx1BEW9ZWrxfT/FZLCz8D5t1maysLKytrUGlUskypxmNRmxtbcm60VhZWUFfXx9KS0tx9uxZizTp5cuXaG5utuG3APcYKTnWPh8fHxQWFiIsLAy//vWvkZ2djYmJCcpvkTSJdD6JR4qQw944S6QYhkFiYiISExMpv0Vukk0mEzo7O+mao6vE6HUp4n19fS1sgORzRPitnJwcrKyswMPD47X3kVnP2toaVcSfO3cO29vbNE1qaGhAfX09YmJiQLqlSDppnUhJGTnWPn9/f6rz/uUvf4m0tDSMjY1RfoukSfb4LWelxa6uz5G1T6FQUFZyc3MTHR0dlHEDgP7+frx48QJ5eXk2aZL1uKuIt06kxPzW+Pg4iDKf8Ft5eXlYXl6W3SN1UEX8xYsXKb/FcZzDB1KAPCEHGXfWHw/nkzOHhyzRkJu7iIgJhIXNUhugoDvmzLpj26SK4+QzUq4U8d7eGzh2rAXHjrVgfj4YPM/i1SstFhZCwDB7uHbtbQj9W702aZL1iEuLpQ5hpEgiJfBbw4iPH6b8Fs9r8fx5EZqaihERMYnExAGzkEN6afFBFPHe3gIjpVTuYnY2lB5url79DDw9t8zdUjySkvqhUJhoj5Scw+biIlHEu06kBH5rAImJAxgejgcAhITMo7GxBA0NAr+l1XLIy9PBz2/VzvfkjiJeSKQcySH8/FZQXNyE4uImTE2F08RteTkACsUObt++DJblkJhomybZu76DKuItbYC3YDRmg+dZ1NefxNOnpxEbO4KkpH7ZpcVk/VFgpOSsPwqlxZ/+9E0olTuYnIyiaZLRmG3mt/TQannExQllzSSRksdISVfEC/xWN9LTuzE5GYHtbU8EBS2irq4CdXXEBsgjJ8eW3xK+J/ulxc5mYCDJrIi/Z+dX6xAU9I826zJ6vR7r6+vw8PBATU2NpHUZ4fqE0uLExETJ10cU8eRGw54NUMxvJSUlITk5+WNnpMTfk0qlwttvvw0PDw8MDw/TNEmn08HPz48aEyMjI8EwjGwhB7DPSJWUlLhMEsj6U05ODn7yk59gbW0NXl5elN8i/VuObHkkkXqdivjw8HALfosYE7e2tuDp6YknT57YtQHaG3LYlMNIkfVH8p6L+a3l5WVqTLx79y7u3buHtLQ0pKSkOE2k7I27ingi5Pjc5z4HDw8PuzZAkriRTjAppcXWQw4JUhTxarUa+fn5yM/Px89+9jMsLS3BZDJRfktsA7SXuLlzSCCK+JMnT9r8GrEBxsTEWPBbbW1t2NnZgUqlQlNTkyR+i1yfXEbKWhEv5rfm5+dp4nbz5k3cuXMHmZmZlAV0V8ghRxF/OJ+cOTxkiWZ0NA5zc6H49Kev4ciRV6J1GRaPHp3Fo0dnkZhIuqUM8PLapIlUVpZRptpbuiI+OHgep08/hq/vCqqr30B2dgd6e1NFNkChfys6etzmIEBKi+Ur4h0nUh4eu8jONiI724i1NW/ac/XixXEAJvC8YF3Lzu5wym8BYiGHO4r4/dLi0NBZVFQ8wpkzdRga2u/f4rh8+PsvQaPRYWAgUVZpMSA+bMpTxM/OCor4Y8dazDZAIU26d+8C7t8n/BaHrKxOeHpuSy4ttr0+rWRFfETENCoraxAaOoMbN95CSkof2ttzqQ2QpElhYTM2r91PpF6fIl7gtwS73vKyP3Q6wZjY0HASgAldXRnw9V012wCdJ0b2hByuxl4iFRU1gaioCVRV7fNbHJePlpZCBAfPgWV59PUlIyhoHvHx0hkpdxXx09ORuHjxNoqKnmNxMRD7NsA3cOfORVp2npYm8FtSS4utZ3/9sdPOrzaA9GWJ12ViY2Nx7do1xMbGSl6XWV5etlta7Pr6HCdS3t7eKCgoQEFBAeW3iBEMELin0NBQl/wWYFlaLHXsJVLEBmiP34qIiADLsujt7ZUt5LA+bEqZmZkZTE5O4ty5cyguLsbMzAy9cb969So8PT0tuqUUCoXbjJRURTzht8j/XLt2DRERETY2wLy8PLuHXUelxa6GKOLtJVL+/v6UcZuamqLGxO5u4e/WiYkJDAwMuOS3APcV8QaDweLQa20DtOa3WJZFd3e3rNJiwPawKWXm5uYwPj6Os2fPorS0lPJbOp0ORqOR8ltarRZxcXFgGEa2kIOMVGsf4bfS09Op3TIoKMiG38rNzbW7CuiotFjK9TlKpIKDg+kDqdHRUZq4EYnH3NwcxsbG7K43W4+4tPhw/jTn8JAlmv1EqgOAeF2m1aw7FgD1mzffxJ07l5CZ2YmQkFlzIiX95sldRbxOJyji33nnA+ztKc1pEouXLwvQ3CzwW1otB42GR2DgEoD99UeNRvr1jY3FSk6kfHzWUVj4EkePtuJb3/oH+PuvYGkpANevv23Rv5WS0m83cSNCDvcU8bY31AxjQmLiEBITh3Dx4h3KbzU1ncDenhJ+fstoaipGXp5rfkss5JDDSFkr4gUbYDNOnLDmt96BSrWJnBwDQkNnZZcW7ws5Xslaf9TphNLiL3/5t9je9kRnZ5b5cFOG+vpTZn6LM/Nba+bvyR1GSroi3t9/GSUljThxognf+tY/wNt7HRMTUfjgg89Drd6gNkCB37J9vaPSYmfjLJES81uEReN5LR4/Pg2AQUDAIlpaCsw2QNfJ2cEU8UIiFRi4iJMn61FWVo/x8WgQY6LBkAtv7zXk5ekRGjojq7QYEBTxBkMO8vL0Dsqk7fdl6fV6BAYG4mtf+xo2NzdpmuRsXcYdRkqOIp7wWydPnsS3v/1teHp6YnBwEEajkfJbWq0WUVFRdm9w7JUWuxpniZQjfqumpgYAqJZeKlfkDiNlvf4YFhaGiooKnDlzBkNDQzRN4jgO/v7+0Gg0CAsLc0vI4Y4i3mAwwN/fH1//+textrZG0yRiA0xLS6NsEjnEutMjNTs7K1kRHxERgaqqKlRUVOC73/0uTR7JZ94ZvwXsHzbdUcTb+xwRG6BWq6X8FsdxuHPnDgDhc280GpGRkeGS3wIOxkixLOuQ3+I4jvJbLMsiPDxctpDDXUV8R0cHfH198dd//ddYXl6mD1sIv0XKzgm/BUgrLbYeqYp4UuQdFxeHc+fO4fvf/z4VBb169cruerP12CstPpw/rTk8ZJlHSKRyHSZSgu74CU6efIKxsVi6UtTengdgDz09afD1XbWxAdqbgynihUTK1gYo9G/V1laitvYskpKExO3VK62s0mJgX6QgVxG/seGDt9++hvT0LgwP76dJOh0LP79lszGRQ1TUJIB9IYez0mJ7I1URT/itnBwDamsrUF9/Cr6+q7h//zwePCD8FoesLKMNvwU4Li12Nq4U8WJ+a2AgETyvhcGQg60tNRhmD8PD8QgNnUV4uHN+C9gXcsj5HFknUirVNjQaHTQawQZI+rfu3r2E+/cFfkuj4amQIyRE3mFTviI+BevrPnjjjZvIzDRSfkun06C1VeC3SP8W4bWklBY7uj4piZRavYX8fA75+RwePjyDp09Pw8NjB9XVn7Lo30pP77b79Scm3FfEp6X12CjiGQaIiRlHTMw4qqrum/ktLdrajmBnxxMMs4fp6QgsLIxJYiNJabHzz1EdxIcsAn2XlZWBYRib8kxyEyhel2FZFhzHySotBuQxUmQGBwextraGz372s8jOzqZp0osXL9Dc3Izw8HBquiM3OAdhpKQkUoTfKiwsRG1tLerr67G3t0dtgKR/yx6/BTguLXY24vVH60RKzG9dunQJnZ2d4HkeTU1N2NvbA8MwWFxcxMrKiqTVydehiBfbAKenp2lScuXKFcpvkc+RnNJiYP9zJMfaNzo6itXVVbz11ltU+uCK3yKJlNSDMxmiiHeVSBF+q6SkhH6ONjc38cEHH8DLy4v2bxEboPU4Ki12Ns4SKUf81uPHj+m/s7GxgfX1dZf8FnAwRoqUFgcGBuLkyZMoKyuj/JZOp4PBYKD8llarBcdxfxRGamJiAisrK/j0pz9NxT3W683kgRQ5WMoRchzOJ3cOD1nm6e5Ol5RICbrjUcTGjuLUqcf47nf/HkFBC5TfEmyAwgqUI9PgwRTxttcn2ABbUFDQgrm5YHPipsWNG28BENKm7u40pKba2gCtR1xaLI+R2lfECzbAYSQkDOPChTvo7s4Az7N4/vw4mppKEBExSW/o5JQWA2Ihx0NZa2tGYzYSEgbxF3/xS8zMhNI06epVwQZI+reSkgagUAjMDMe5Li22HqmKeIYxITl5AMnJA6ioqMH3vvc/4e+/gmfPitHYWIro6DGQ/i0iIrAee6XFrsZZIuXvv4Li4mcoLn6GqakIyrh1dQma7fj4IQwOJtq1AVqP+4p4lpYWW/Jb1ejoEPq3njw5hSdPBH6LvM9ySosBYGnJH319KTh16oksRXxXVyZiY0fwjW/8CyYmougB0JLf4hAXN0J/331GSr4i/sIF54mUUrmHjIxuZGR0Y2nJDz/4wd/B23sdjx+X4/HjcjO/xSE31+Dw59leabHt1AH4R/r/OVtbc7Uuk5iYKHld5iCKeFJa7Ijfqq2tRW1tLe2W2tvbk81IraysUEZKzvpjb28voqOj8Vd/9VcYHh6maRLht8T9W+LvSe4hQaoi3sPDg5b5Liws4Ic//CE8PT1RW1uLhw8fIiUlBVqtltoA7c1BFPH23vPw8HBUVlbSbime56kNEACSkpIwPT0tid8ih83k5GS31h/JgUlsAxTzW+LEbW9vTzYj5a4ifmBgABEREfjmN79J3yMxv0Wul/BbwMEYKVeJlJjfmpubw49//GMolUrcu3cPNTU1SE9Pd8pvAcJ77kjI4WiItc/6exLzW1VVVRb81osXLwAAycnJWFxclMQ8vQ5FvFqttqmn4HkeN27cwO3bt+kDqd3dXdmHzcP55M3hIcs8PM9KZqTIGI3Z2NtT4p13PkRw8DxNkx4+PIuHD88iKanfDKgbaDpGFPHOSoutR44iPiRkHuXlj3H69GN88MHnYTRmYnY2FL/97Z+Z+S2hfysqypbfAuyXFrsaZ4p4gd/qQHZ2h5nfErqlamrOATDB03ML09NhCA+fhkrlnN8C3GWkYixKi8PCZlFR8RBnzjzC0NB+/9Y+v8UjL08HvV56afH+9clXxPf0ZGBvzwPvvPMhgoLmaZp0795FmiaxLI/MTCNd55JSWmw95HMkJZGKiJhCVVUNzp6txYcffg5GYxYmJqLwb//2FwgMXKBpkiNF+MEU8ZxNIiTYAAVmbGmJ8Fta3LlzGeRztLLih50dpaQ0a1/IIf36SCJ16VK12QY4gejoCVRVPUBfXwo4bp/fCgmZpZ+jfSGHO4yU9PXHgYEU7O4Kn6PAwAXav3Xr1qfpejPLcmZ+S/g5lVJaLMw+lyVcH+8ykRKvy5w/fx4ffvghjEYjRkZG8POf/1zSuoy90mJX4yyREvNbc3Nz9Abn+vXrYBgGHh4e2N7ext7enqSb3YMq4hmGofyW2AbY3NyMZ8+eUX5Lo9G4JeRwRxE/OjqKnZ0dfOlLX0JAQAB9j4gNkBgTCb8FSCsttjdk/dFZIsUwDJKTk5GcnIxLly7hypUr6OzsxODgIH70ox9Rfkuj0Tg8iNsrLXY1zhIpMb81OTlJDzddXV1QKBTw8PCgbJuUw/dBFfFKpdIuv/XkyRM8efIEcXFxNClxh5Eia2ty1h8nJyexs7ODz3/+8/Dz86OyHKPRCG9vb2pMJPwWsJ9IOSotdjRk/dFZIqVUKpGRkYGMjAxsbGzg2rVr6OzsRH9/P77//e8jISEBWq3WYr3Zeg6qiLdefyTrzadOnbJ5IKVUKuHt7S3rsHk4n7w5PGQBWF/3NjNSL1wmPeLheS3Cw6fogYUUjM7PE35Lixs33sTt2/s3OKOjsQDk9Ui5o4jf21NiYCAJOTkdeOutq9QG+OJFEZqbixEePgXSvxUQsGTxPTkrLbY3hJFydcMq8FsvUFj4Av39Sfj1r/8cSuUu5bdI/1Zych9Nk8TjqLTY1ZD1R2tFvMBvDSIxcRCXLt1BZ2cGeF6LpqZiNDYKf4mq1RtYWfGDn59zfgs4iCKepYp4hgFOnGjCiRNNmJ4Op2nSlSuE3xK6pYaH4yCntBgAJiaiMT0dgcuXXTNS+8NgaCgBmZmdePvtj2A0CmlSfX0Znj61z28BQgrorLTY3uwr4p1/jgICllFa2ojS0kb09qbgvfe+AoYx4YMPvgAvr3X6HsXH2+e3AOFz9LoU8QK/1YO0tB5sbqrN/BZrTpPOAAB8fVewvu4l6cAuLi2Wp4jfLy1mGBNOnnyKsrKnGB+PoevNBkMufHxWqTFxYCBBYmnxPpclh5EiwzAMRkdHkZGRgbfeegsGg8HluozwPTkvLbY3UhXxISEhKC8vx+nTp9HV1YXf//73AIDf/e53VHNO0iRHN8qvUxEvtgGK2aSamhrU1tbCZDIhPT0dW1tbktbQSB9Zdna224p4hUJB+a3BwUGaJon5La1Wi/7+ftmMlDuKeA8PD0xMTCA1NRVvvfUW9Ho9OI5zym+R7+l1MlLiiYyMRFVVFc6ePQuj0YgPPvgAAPDrX/8agYGB9EGCswcSHMe9NkW8mN9aWlqipjtiA9zb20NaWhp2dnYk8VuvQxGvUCgQHR1tYQN89eoVXr58iZCQEPqz1tfXJ/tz5I4iXq1WY3p6GklJSXjzzTctbIDiNEnMbwHuMVJS1h+tH0gZDAZcvXoVGo1GlpDjcD55c3jIwj4jJeeGlSRSZ8/aJlLBwQs4ffoJTp16gtHRWAidQHlob88Dw+zB338Rq6s+CAhYlJRCuKOIF5cWi22AAr8l9G/V1lahtrYSycn99HAjp7SYDM+zshXxw8MJAIBvfvOnWF4OoGkSz2vh57cs6t+apK9xVVpsbwRFvMalIt7DQziE5eYasLrqg/fe+zNMTkbi1auj4Lh8sw2QR1aWEZ6etvwWgNeuiA8Pn0ZlZS3Onn2IgYEk8LzwHr16dRQKxS78/RexsyP9L+D9w6Y8Rooo4gUboA4sK/BbJE0S81vCymU/jMYsyaXFZNxRxE9MRANg8Jd/+TMsLgaZ1/dYtLYWIDh4DhqNsLorPky5Ki22N8Ta50oRr1ZvIj//FfLzX2FxMQC///0XMTkZhdbWAnBcvqh/q9vhQdxeabGr2U+kLBXxAr81hpiYMZw7dx+9vWngeRatrcfw4sVxKJU78PdflHiYqwNQAo7joFAoZDFSJJE6f/48vL29Xa7LaLVaJCQkyCotJiNXEc8wDObnhWT3G9/4Br0mYgMk/BbLshZP/12VFtsbqYp4Hx8fFBUVoaioCLOzs/jggw8wOTmJly9fguM4miYlJyc7fOLvTo+Uo0RKbAMUJ25NTU1obGyEp6cn/P394ePjI/lrHVQRL+a3pqamaJp05coVqNVqZGdnQ6vVIjY2VlZpsfj65CjiFQoFVlaEh3F/8Rd/QZNSaxtgXl6exftEhBxyFfE6nc6lIj4gIAClpaUoKSnB5OQkrl69iqmpKbx48QI6nY6mSY74LcA9Rfza2ppdRbzYBkj4LY7j8PjxYzx+/BgqlQp+fn6yV/EAaX1kZMSJVFBQkAW/RRI3g8EAHx8fWnYeGRnplpBDriJeqVRia2tLdkJ+OJ/MOTxkQTgkkERKzmsAk1NrH8MAcXGjiIsbxfnz9/Ds2XHU1p7D6qoffv7zvzbzW0Ka5GgN0F5psdTrExIpy/VHgd96iYKCl5ibCwExJl6//hYUih3s7XkgOHgWe3sKSakeYaTkK+JZJCYOIDh4AcHBwtP3ixfvoqtLSNyam4/j2TOB3xKMiTrIKS0m09srf/1RqdzFzEw4CgpaUFT0nL5HH330WWoDFPq3BixuaDlO+7Eo4gV+qx/Jyf24dOk2nj07jkePKrG8HIAf/ehvEB09Zu7fcsxvkdJiYf1ROiPFcfYV8f7+KygpeYaSkmeYnIygbFJXVyY8PLaxs+OJyMhJmEyMS34LsCwtlvs5iosbRnj4LMLDZ6kNkPRvPXlyGk+elCMubhgsyyM3Vw+Ok15aTKa/P0W2It7bewOzs2HIz29FYWELTZM6OnLg7b1G0ySSYJJxVlrsaKQo4gV+qwsZGV3Y2FCjqekEHj8+g+XlQHz/+//TXE8h9G95edn7u6YOe3v/y21GSq1W25QWW6/LcByH9vZ2tLe3Q61WY2trC3FxcZLXroiQw11FPDGmWdsArfmt7Oxst0QK7ijiAwICMD8/D61Wi6NHj9L3iBwCxP1b1t+Tu4yUs5s7T09Pym+trq6iubkZT58+xfb2Nr7zne8gNTUVpH/L0eH4dSviIyIiUFlZSfu3xPyWj48PNjc3ZfWyuctIEUU8SSUIv0WSkjt37tD+LZK4uXNIGB4exvz8PE6fPi3p32cYBmFhYVhaWqKfF2sbIEklQ0JCbL4nuYp4KeuPYn5rcXGRrshubW3hO9/5jkX/lqM0x11Gyl4i5ah/i9RT+Pv7Y319Xdb6nljI8boU8YfzpzX/6Q9Zc3OOEylHQ27ukpIGqCrd1SiVu1hcDIaHxzb+5m/+GT09whPlhw8rzfwW6d/qsDhMuSottjfr64SRcq6IDwmZQ3l5HU6frsPISDz+8IfPY3XVF/fuXUJ9/SlRmjThZO3q9SniBRtgB3JyOrC25gO9Xki2Hjw4h5qaSjCMCVFR4zJXOoXSYjmKeHEiFRY2Q/mtwcEEEBvgq1dHEBCwSN8jlWoLg4NJKC+XJ+SQq4j39NzG2poflMod/PVf/xg9PenmNOki7t3bT5MyMzstdNyktFieIl4lSREfGTmFqqoHOHu2Bv39ybh27W2srHjg9u1PobGxlPZvOdOXu6OIn5yMMidSluuPavUWtFoOWi2HpaUA2r91+/Zl3L17AQyzh6iocUkM4P71sW4o4rOxva1Cfj6P6OhxREeP49y5B+jtTQHPa/Hq1RG8fFmEkJBZKsvx8NiRXFpseX1aWYp4L69NbG+roFDs4hvf+Dn9HN28+Wncvn3JXL3AIzW1R/R3SAMGBnpoIiV1tra2YDAYkJeX5/CmW7wuQ7qlbt26hc3NTdy6dYuWizrjtwD3eqSmpqbsJlJiG6A1v1VdLaSg0dHRkoxpZA6iiCfpniN+KzIykrJJCoVCcmmx9fXJUcT7+vrSA/DXvvY19PT00L4isQ0wKSnJ4tBLhByOSovtDWGknCniFQqFBb9lNBpx964gj7l58yZaWlpsbID2Rsph03pmZmbsKuLFNkBxt1RXVxfUajVMJhOio6PdFnJIHZJIabVauzZAa34rNzcXACSXFotHriI+MDCQ/pl++ctfRm9vL/R6PTo6Oii/RVJJ8efIWWmxo5GiiLfmtwwGA2prawEA169fx6tXr+h6szPzH1HEy/n7SKoi/nD+NOY//SGLJFKJif2SX0NKi8vKnkp+jVgRHxi4iGPHWnDsWAvm54kNkMWNG2+JuqV4pKb2Qk5pMRmDQd76I8MIPUUrK/4oL3+IiIgp8LwWz58Xoamp2GwD5KHRWPJb4kTKPUW847U1H581FBW9QFHRC8zOhuLRo3K0t2swNhaHb33rH6gNMDm53y6/BYhLi1tkMVL2EimGMSEpaRBJSYO4ePE2OjszwfNaNDaWoKGhDH5+wvsi5zC3L+SQrogXlxaT9Ka4uAlTU+E0Tbpy5XNQqzeQnW2AVsshMXFIJOSQw0jJW39UKEwID5/ByoofysqeIDx8FjzPor7+JJ4+JTZAHnl5egsJBDlsOiotdjSkR8rZ+mNAwBJKSxtQUtKAyckoPH58CkZjDsbG4vDtb/8D7d+Kjx92eDgmjJRwCJLH2lkr4hWKPaSn9yA9XeC3DAahf6uurhx1dWcQFDQPk0mBzEx7pcD2Z3KSKOJvS36NuLQ4JmYCMTETOHnyKcbGYizWm318VmnZeUzMGHi+zi1Gant7W/KNhlKpRGxsLNbW1nDixAmEhoZK4rcA9xgpKdY+Mb81PDyMhoYGdHV1YWxsDN/97nct0iRHN0avUxHviN968OABampqEBISApPJJOsm3B1GSrz+SHTw9tKkgIAAyt1ERERQRkruYVPO+qOnpydSUlKwsbGBY8eO0c/R3bt3ce/ePWq6y8jIsPnzIImUHEW8lM9RZGQkzp07h8rKSvT39+PZs2fo7e3F+Pg4fvCDH9A0SWwDtB57pcVSr886kRKnSYTf4jiO8lvh4eHY29uTtdJJFPGVlZVuKeLJOqEjfos8bAkODobU0mLxyFXEe3l5ITs7G7dv30Z+fj79utb1FKmpqTZplTuJlDvJ5uF8cuc/9SHLZAI4Lh8A8K//+lfmdRkOOTkGB+sywliXFksZR4r44OB5nD79GKdOPcboaBw4jkV7ex70eg18fFaxvu6N3Fy97PRGUMRLZ6RIIqXVcggKWkR2ttFsAxTSpJqaKtTUEH6LQ3Z2B2Zmws2JVIPkr0PWHwVFvLT1x9DQWZhMCnh7r+Jzn/vA3E8mXJe//xI1JkZGTlq8br+0WI4iPtBlIuXpuYO8vHbk5bVjddUXOl0eamuF9Z9f/OIvzfwWh6ysTof8FiDtsGk9vb2pdq19ERHTqKysQUVFrZnf0lJ+KyBgEcvLfsjJMbgl5HBHEX/kyCuEhAidVsvL/jRNunPnEu7dO2/uluKRkdGF6ekwyaXFZMTrj1IU8QwDREVNwNNzB2r1Ot5++yra2/PAcVq0tAj8FkmTrA967jBSUhTxavUmjhx5hSNHBH5Lp2NRV1cOAPjlL79u5rc4pKf3OP1zsy4tljIDA8k2pcVCPcUYYmPHcO7cPXParqX1FCEhM1hYGEd2dq4kYJ6MXEYK2Lf2HTt2DGFhYSgoKLDLb5FuqdTUVMzMzMgWcpBDgtT1R2IDbGtrg0qlwqc+9SkYDAbKb4ltgNasDBFyvG5FvJjfmpmZAc/zaGwUtgR+9atfSeK3APd6pOwp4q35LdK/1djYiIaGBkRFRWF6ehqZmZluMVJy1h/J2lphYSEiIyNRXFyMqakpmzSJJG6JiYmySovJyFXEKxQKpKamwmAwwMPDAxcuXIDBYHDJbwHShRziccRIiUfMb01MTFAuEQDee+89miaJbYD2xp1Dgj1FvDW/RWQ5dXV1qKurQ3x8PCYmJpCenu62kEPqEEV8UVERoqOjcfLkSYyNjUFsAyT8llarRXR0NBYWFmQnUuL1RylK+cP55M9/6kPWyEgcFhaCUVV1Hzs7HuB5FjdvvinSHVuvy7guLXY0rhTxAr81gri4EVy4cA/d3el4/Pg01tZ8odezmJyMMqdJvNMVxf3SYnnrjxxnW1os2ABforDwJWZnBX5Lp2OpDdDffwkKxQ6ysqQfNg+iiD96tIV2S128eAddXUL/VnPzCTx7VorIyAkI3VI6+PuvQGppsXh0Osd9ZPbG13cVCQnD2NnxxOnTD7G762nmt94R8VsckpIGLda/iJBDviKedaqIVyhMSEnpR0pKPy5dqkZnZxbq68uwtBSI9nYN5udDaJrkiN8C9hmp8vKDK+L9/ZdRUtKIkpJGTE5GUmNiZ2cWvLzWERCwBIaRX1osMFLSP0ektFjQ4XchM7OLauN5XovHj0/j8WPCb3HIy2uHt/c6FXLEx8tjpOQo4gMDl5CW1o3a2kqUlDzF7q4n9Po8K36LQ2zsqMWfh7PSYmfDcYIiPjPT/vqjUrlH36ONDS8YDDlobCzG3p5ww7GysiJpXWZ5eRl9fX20tFjq2FPEi/mtkZER8DyP9vZ26PV6+Pr60kMNWXOSMoSRknNDLU6kNBoNNBqNBb9VU1ODmpoapKSkUH5LpVLZTaRcjVxFfFhYGDQaDZ4+fYrCwkKaepADCkmTrBMaqUIO63G1/ujp6Ym8vDzk5eVhdXUVOp0Oz58/x+7uLjo6OvDv//7vLvkt4GCKeOtEKiIigtoASbdUe3s72traEBgYSD9Hcg4JRBF/5swZya8h1r6cnBwqgrHHb4kTNw8PjwMxUlI+RwzDIDo6Gmq1Gk1NTcjPz8fu7q4Fv0XSJGt+y1lpsbNxpYhXq9U4cuQIjhw5gsXFRfA8j5cvX2J7exudnZ34wx/+4JLfAmxLi6WO9fojwzCIjY1FbGwszp07h56eHgt+KywsjB625RyG3VHEH84ne/5TH7JIInXs2Euo1Vs4efIJxsZiaZq0vy4jJCXR0WOiREoOIyVPEa9U7iIry4jGxhKEhMyguPgZeF6L2tpK1NY65rcAcWmxfEV8aaljRXxo6BzOnKlDeXkdhofjwXFatLYeA8Dgxz/+b6I0yTG/Ra7PXUW8WO0t8FsG5OQINkDSv/XgwXnU1FQhPn4YQ0OJOHVK7iGBNTNSC5KvjyRSJ048h5fXBioqHmJwMJEaE/f5LYFNCg+fllxaLJ7NTbWZkZKmiFeptqHR6NDaehRBQXMoLHwBnY6l/NZ+mmTJbwHuMVJSFPGRkZM4d+4BKisFfovj8umB5Oc//yZI/5Yrtbq4tFjqEEZK/J6r1VvIz+eQny/wWzwvGBNv3/4U7t69iOTkPrO1T3ppsXj90R1FfGnpM/j4rKGq6j76+lLB86wVv8WBZXkEBy9ILi0Wz9aWJzo6spGXJ00R7+W1gaNHW2Ew5GBrS41jxy5DpzNIWpdxl5FylkgxDIP4+HjEx8dTfovjOBiNRgCCOpukSa5geHFpsdSxp4gX81uzs7M0cbt27Rqqq6uRlpbmVmnxQdYfT506BT8/P1y6dImmScQGKOa3/P39JZcWi4ccNqUq4n19fXHixAn09/djc3MTR44ckcRvAc5Lix2NI0aKjEKhQEpKClJSUii/xfM8enuFB6G///3vJfFbwL4iXs76Y1dXl836o5jfImmSTqdDZ2cnvLy8kJGRga6uLreEHBEREbLXHwHgzJkzCAgIsOC3iA0wLi4OWq0Wubm58Pb2pkIOV6XF4pGriA8MDKRF5yQZFvNbxAZozW8BjkuLnc38/LxTRbxSqURmZiYyMzMpv8VxHPr7BQTl2rVrDtebrccdRfzhfLLnP+0ha2dnf21NrRYAeGFdZhSxsYINcH9dpgDPn59AWNg0GMYEb+9VpKb2Sf5aB1HEV1TUoKCgBQUFLZibI/yW1orf4pCa2geG2YPU0mLx8Lx0RTzDAAkJw1hf90ZrawHKyp5gejoCz58fR1NTiZnf4sz81rLFa52VFju/PueKeF/fNRQVPUdR0XPMzISC51m8eFEEAHj2rASLi0FmG6BjfguwLS2WMvYU8QK/NYCkpAFcuiTmt0rR0HAS0dFjMJkYeHnJKy02GHLMPVLSP0ektLi8vI7aAKemImia1NWVCbV6Azk5Ar+VkDAEwEQTKalCDkCeIl6hMCE1tQ97ewrodCyKipowMxOOJ09O4ckTgd/Sajnk5upt1gGdlRY7vz7niVRAwBLKyhpQWtqAiYko8LwWra1HATB48eI41td9oNXyiItzzG8BYiGHu4p4IZFSKveQnt6N9PRubGyo0dGRA55nUVdXgbq6CiQkDGJ3VwGVSl5psdEoHDblfI7EivjTpz+LU6f+G8bGxqju2N66DMMwdhMpVyNHEa9UKimbYjQaceTIEczMzNi1AVrf4ByEkXK2/hgaGoozZ86gvLwcw8PD4DiO3rC+evWKHjpdSQEOoohPSE7CrGkTa2smhHv7WdgA29vbwXEc5bdSUlKwvb3tNiMlRw6xurqK7u5uFBcXo7KyEmfPnsXg4CA4jrPht7RaLT1cflyMFBmVSkWlKr29vcjLy8PMzAzu3r1r079lvSorPiS4w0g5UsQT0yXht0jiZjKZ0N7eTq/ZGb8FWJYWy11bEyvirW2AJHGrrq7G3bt3aYebUql0S8gh5+Czvr6O7u5uFBYW4sKFCxb8VltbG168eIHQ0FCa3AYHBwOQVlpsPXLWH728vHD06FFERETgF7/4BbKysjA9PW1RT+HogRQRctgrLT6cP935T3vI6u5Ox8aGt8MkwXpdpr1dMMqNjMQDAH79669CqxX4LVdrgwdRxIsTqZCQeZSXP8bp048xMhIHnteivT0Xer0Gvr4rSErqd5lIWc/urhJ6fZ75kCBn/VEoLS4vr4NSuWfmt4Q0qabmHGpqqpCS0geW5ZGd3QGVagvt7dJKi8VDFPFnzkhTxIeFzeLMmUdob89FQMAiYmNHYTDkguPy4e+/RG2AkZFTNq91VFrsbFwp4sX81sqKL/T6PHBcvrnfyYT33/+CeX3NaJMmWY+4tFjqCOuPlolURMQUqqpqcPZsLQYGksHzLPT6PLS1HUVg4AJSUvrMiZRcIYd8RTzPC6XFVVUP4OGxi6Ulwm9pqQ1QSNw4ZGR0wcNjV3JpsXjI+uOpU64V8QwDREdPIDp6Ar29KTCZFIiKmgDH5aOlpdDMb3Fmfsv2ELov5Hh9ingvr00cOdKGI0fasLgYCJ7XgOPyMTsbBobZw9Wrb4NleaSlOee3AMvSYqljqYivA8OU0HWZ8+fP212XSUlJweTkpCxGam9v70CK+IsXL8LT09OuDVDMbykUCsmlxeKRo4gn/FZCQgLGxsawsbGByMhIagMk/BbLsnY5HkelxY5mZ28XHzx/jMXFRdxWTOEn7+mwqmQQrPbBV49W4HMZhQj09bXht3iex+LiIhQKBaqrq2ma5CopeR3rj2J+S5y4EX4rOjoaqampbgk53FHEk0TqjTfegEqlwuTkJE2TxPwWMT0yDONWH5kcRTzht1JTUzE9PY2VlRWEh4fbtQHa6yn7OBTxgYGBKCsrQ2lpKSYmJujDltXVVSiVStTU1IBlWZf8Frk+X1/fA60/WtsASeJG+K2EhASkpqbKLi0+qCL+rbfegkqlsvtAihwAyQMpuUKOw/nTmP+0h6x9a5/rRMrLawPHjrXCZGIwMhKPgoLn6OtLxY0bb+L2bcJvcUhN7bVJaA6uiLdNpBgGiI8fQXz8CC5cuIvu7nRwnCA6AIT0Zm3NByxraQO0N+LSYqmzn0jtK+IFfusFCgtfmPktLXiexbVrb6O6WkjcJiYiERo6Lau02J31x7GxGMzNheGNN27g6NFWXLp0B52dGeB5LZqaTqCx0ZbfklpabO/6pCri/fxWceJEM1SqLdy8+SZYlsPAQDKuXCH8Vju0Wh6JiZb8FuC8tNjRkM+Ro0RK4Lf6kJLSh0uXqmE0ZoHntWhrOwIAaGk5ht1dpZnfcs77HEQRLy4tDghYRmlpI0pLGzExEQliTCT8Vk5OO8bHoxEUJK+0eJ+RkrP+GInpaUERX1j4EpubajO/xeLx43I8fnwG8fFDEPq3BH6LHDZdlRZbjxxFfGDgIk6erIe//xKuX/8MsrI6MDCQBIMhF97ea8jLE/itmJhRm8+Ko9Ji19cnVsTXAfhH+mvW6zKETSLQPHnqLmVdRlxaLHW2t7dtSovFNsCRkRHaLUX4LY1Gg9HRUQQEBMgSchxk/fH8+fM4ceKEhQ2wpqbGJnFTqVSyGanFzXX85c2fIKpjAhHbnrj6f34bvptbMAF4mRaLf/uUET/VpuNXn/7fkBMiPMUPCwtDRUUFwsPD8dFHHyElJQVGoxEcx1F+S6vV2tW5E0bKnfVHR4p4Mb+1srJC36P6euGhYXd3N/z9/ZGZmekyeRSXFksde4lUZGSkDb+l1+vR1taGoKAgaDQaDA8PyyotBtxTxM/OzmJ8fByVlZUoLS2lNkCe56kN0JrfklpabD3ksOkqkSL8VnR0NOLj4/Hhhx8iLi7OwgZIDhPW/BYgTcjh6PocKeK9vLwov7WwsEDfo0ePHgEQPhudnZ1IS0tz2V01MjIim5Gyp4i390Dq5cuXaG5uRlhYGFiWxdDQkKzS4sP505j/lIcswkgVFT2Xae3TIjx8CpcuCark0dFY2OqO9/kthpFWWmw9chTxhN9KT+/Gt7719wgOnoeHxy5qa6tQW0tsgDyysw10LdLye7JfWuxsSCLlaN1I4Lceobz8EYaHEyjjtrnpBZVqEw8enIPQvzVp9/VkLBXxC5Kvj5QWk/VHDw8hncrNFfgtvT4PQv/WeZq4RURMuSHkcE8Rz/OCIv6tt64BYDAwkAixDTAwcIEmbuHhM+bXuC4ttp7x8ej/P3t/Gt3GeaZro3cBBAiC4DzP8wigwEESSVETR022Yydxpk466fS4u5PevXfvvb619vlz1lnrnPMjjpNOutNJx0m37bQzdGxZtgZSpEhKIilRpEiiAM7iPM/zPOD8KLyFAlgAqiD5rM+2np/dhliEyk69dT/XdYtOpJTKfdC0CTpdF9544x/h57cOi0WGqqoruHOH37/VL8jxPIsi3tl9FBk5i8jIOygvr8XQUJL14G7AwYECKtU2GhougKYZt9wTv7RYCiNlKy1m1x+9vXeRk9OJnBxiA2QTt5s3X0JV1SWrVn9OcmkxUcTr9dIU8SYTW1r8+ut/xNERhcHBFO6Q3Np6CiEhC5wxkfz7I6a02HFmZ8MdFPFNAPYAHF+NUqlUyM/PR25uLt58802oVCpsbm7arcsYDAYuTXIcZ6XFrsZVIiXEb5ED4NHREdRqNZqamkDTtKiHULL++CyKeL4NUIjfysrKQnh4uGghx+7hAb778b8io/oe/MK0yO42w3fXugIP4OTTSZz88e/xYUE2vmk5wodf/kfE+9keeE0mE/z9/fGNb3wDBwcHXP8W4bciIyM5fosc+EgiJZWREptIaTQaFBYWoqCgAG+++Sa8vLywuLiI999/H97e3sjKyoLBYEBCQoLgIc9ZabGrcbX+6IzfamxshMVigUajQVtbm6ANUGg8XX8EbIkU3wZI+rfMZjPHb2m1WkREREgqLQZsh02piniz2QyNRoM//dM/5VZx+fxWXFwcl7iRbjkxpcWOs7S0JDqRCgwMxNmzZ1FcXIwf//jHAFi5xMDAAMdvGQwGREdHC/5Zz1sR7+yFVF1dHQCgoKBAUmnxi/m//3wuD1ldXVocHcklPQjZEqka7u1wbOwkYmNZfmtg4Di/RdNGdHbmIilpWHRpMeCpIj4VOztqlJRcQ1raAJaWgkH6t65ffxU3b161dksxSE4egkx2JLq02HEYxiBKEc/yW2OIjx+Dr+8GHjy4gNjYCbS0FODhQxu/RdMm+PmtH/u8s9JiV8MmUjqniZSv7xYKCh6joOAxFhZCue9ocDAVgAVdXdlQKPaQmDjikt8Cnpci3sIZEwm/ZTQa0NRUjMZGlt9i76McSaXFgO2wKcXaNziYjO1tX7zyykfIzOzD7Gw4lybZ+C02cYuPHwNFWXhCDtelxcevj0ZQkPtESiY7QmrqIFJTB9HQcA737pUiLGwe9++fx/37xAbICPJbgPPSYlfjThEfEMDnt6JgNNIwm/Xo6ckGYMHgYAr8/NYRGzvhNnkkQg5pjJSfXWmxXG5BevoA0tNZfqu7OxsMY0B9fSnq61l+i9xHUkqLAZuQw6aI3wLQBuC0088MDw9jc3MTly9fRnZ2NiYnJ7kUoKurC76+vhygTtZlxJQWC1+fOEU8sZdlZWXh3r17aGhogJ+fnyh+C3Av5BAad4p4IX6LPHgB7Jv0sLAwlw/jHw51Qt7Vja89GsK1L+eBZoTvo1dbujEcFYI3olLxk0t/BuB4IqVQKOz4LZIm3blzBzU1NUhOTobBYEBnZ6ek0mLAc0X8xsYGXnvtNej1ei5NIvxWQEAAl5SQg6+Y0mKhEauIJywUTdO4f/8+6uvr4e3tzdkAXfFbgHshh9AIMVJkKIri+K2KigoMDQ1xB/f9fbZCZH5+HktLS4JpkuN4wkg5JlKONkBHfis9PR00TcNoNCI8PFx0aTFgO2xKtfatr6/jlVdeAU3THL/V3t7O8Vvk75So08WUFju7PjGKePJCKj8/Hw8ePEBdXd2LVcHP4HwuD1lGo8HKSM2I/owQI0WGTZP6kJnZh+1tFbq7tWAYGnV1bHeSQrGPjo5cUfyW54p4+9Li4OAlXLjQgPPnGzAxEcelSSYTq5LX601QKPY8EHJ4pojv6tIjIWEE3/rWu9jaUsNsJv1blbzEzYisrF4olexbWE96pGyKePcH6NDQBZSW1qGoqAlvvPG/ERy8hP7+DJhMBiu/xdoAw8OP81sA+50/T0W8QrEPnc4Mnc5s5bfYbqnq6ssAAC+vQ5jNWmRkHLcBOg6/tFiaIt5gp4iPiJhDRUUNyspqMTKSBKPRALNZj46OfAQGLkOvZ6BQ7EkqLQZYIcfwcBLOn5dmf+zu1iE2dhzf/e6vsbZG0iSa47fYbikGaWn9XCokprTYcYaGkkQp4ll+axpRUdM4f74BP/zh/4K//5pVmnECwcGL3H3k7IAsVFrsblwlUirVLvLyOpCX14GVlQCYTOyLhBs3XgEAREZOo68v3cpvuX65IiTkYKcBrg5ZJJHKyMgARVGIjY1FbGwsLl68yKVJjusyCoUC+/v7klao1tfXRTNS/Ont7UV0dDT+8i//UpDfIt1SycnJXOJGEikpxaxiFfF8fqu8vBxvvvkm1Go1Wltb0dLScswGyJ93Ht/B/3y/Hma6EP6rq0gcGXH6c75T04ozV09jcWcDISqNy/VHX19fFBQUoKCgAAsLC1y31AcffAAAiI6OxtDQkCh+61kU8SSRoigKSUlJSEpKskuTmpqa0NjYiOjoaNA0DS8vL8mMlKeK+P7+fkREROBv/uZvuDSJz29ptVrQNM3xW+R3knrYHB8fx8rKCi5cuODyn5PJZEhNTUVqaio2NzfxT//0T1AqlWhqakJTU5Nbfotc3/NUxPP5renpae5lS08P+xI5NjYWk5OTgjZAx/FUEc9PpBz5LZK41dfXo76+HvHx8TAYDPDy8pLMSHmqiB8YGJBcWvxiPh3zuTtkLS0FY2Iizi6RcjdEyZyUNOyWcfLx2UF+/hPk5z/B++9/Ed3dWhweyjl+i7UBMkhJGRRcVXRWWuxqtrdVVkV827E/k+W3xhEXN87xWwxjwOPHp3B0JIdcfoChoSRoNOvHbIBC8zwU8Wr1Fk6dasWpU61YXAzhTHcffvhF3Ly5h6ysHuh0JpjN0kqL2etjhRxiGCkyPT3ZODrywquvXkd4+Cz6+zPAMDQePSpCc/MZREZOW/ktMzSaDQB8IYfz0mLHkaKIZ/mtRygsfIQPPngNZrMe29s+eP/91+HtvYOsrG6n/BbgvLTY1bhSxPP5ratXb6C3l2WTGhvPwmKRQS7fx9RUNEJClkT1NQkJOdzNzEykXWmxv/8aioubcPp0E2ZnI7k0qbc3CyrVNrTaLuj1JjAMLbq0mAwRckhRxPf1ZeLwUIFXX/0QERFz6O4m/Vt8fsto5bfYg6+Y0mLh66NFJVKBgas4e/YBzpx5gGvXXoPJpMfqagB+97tvQK3e5Pq3oqOnBH8+KS2maUdFfAP4XBZ/9vb20NPTA51Od+xNPrEBZmZmYnt7m3vAIesycrkcS0tLiIyMFPX2WGqPFHA8keLzW+Pj4yAWN5PJBI1GA51OB71eD4ZhPBZySFHEP336FAcHB3j11VcRHh7OJVvEBpiUlASDwYDMzExM765jemMZJ4bn8E+vpeJ0UxMoi/MEPmhzBxe6R1E91o1vpJ8CUcS7S6RCQ0NRVlaG0tJSXLt2DSaTCQsLC3j33Xfd8luAcGmxu+HbHx0TKYVCwXWU8fmtqir2PpXL5djc3OSsie7Gk7U1x0QqIiIClZWVdjZAk8mE9vZ2jt+iaZpjpKQIOcj6oxRr3+joKPb39/GVr3wF4eHhx/gtkialpaVx/56SROqTUMRTFIXo6GhER0ejoqICH374IcxmM6anp/GrX/0KwcHBXJpEbICOI1Ra7G5cJVLEBpiXl4eVlRXuZcvHH38MiqIgl8txeHiIw8NDUWt8RBEv5b9HRBEvpbT4xXx65nN3yHKVSDmbiYlYLC8H49y5+6I/c3Agx9OnacjO7sYXv/g+JidjuTSJ2AAJoB4ZOc094LgrLRYaooh390Dt5XWIrKxeZGX1YmoqEr/85d/A13fDgd8yIiurR5DfIofN56mIDwlZRGlpPUpKGjA2FgdiTGQY9j9Sh4cyzM5GICLCNb8F2JcWS11/JIkURQFabRe02i47fuvOnUuoqalESsogaJrBwgK7diHlkDA15ZkifnAwFZmZvXj99f/CyEgiGIZ24LfYpCQ0dIH3O7kuLRaa7u4sUYp4lt9iWZ/JySi89dZfQaXa5fgtW/+WML/FF3II2fmcjW1tzT6RoiggMnIGkZEzqKioxdBQMhiGhtHIru8CgEx2iKWlYAQHu2ey+KXFUhgpfmkxRQG5uZ3IzSX8Fns9N2++jKqqy9bEzYj5+VBIKS0GWCEHy0iJV8RbLBRGRpKQkdGP11//AwYHU8EwNNrb89HaWmDlt4xWfsv27zYpLT4u5HDOZfX29opKpHx8fLh1mfHxcfz617+GQqHg+C1HG6DQeKqIF0qk+GmSI7/16NEjAEBCQgLW1tZEvUV/FkU8sfZRFHXMBmgymXDt2jUoFApEJMUjY+UI3VotLDIZDE5WBfkTMzWHxe1NjxTxACsOSE1NxVe+8hXOBvjw4UOn/BbAfueuSouFRqhHSmgIv1VYWIjR0VH8x3/8B+RyOT744APOBkjTtFN+C3i+ini+DfDq1auc6a6xsREPHrCcdUJCAra2tkTxW8+qiCdprCO/ZTKZ0Nvby/FbBoMB09PTkg+bnijiZTIZJicnkZSUhK9+9avcyxa+DZB0SxF+C3BfWiw0Yq19gYGBOHfuHM6ePYvh4WG8++67oCgKv//976FWq7nvyBm/BbgWcjgbT9YfX8ynZz5XhyyLBejsNMDXdxMzM5Hw9d0Q9TBOGKmsLPFqb74inqKA2NgJxMZO4NKlamuaRKOt7QRaWgoRFjZnXXHqk1RaTMbGSIlXxA8MsGD5d7/77zg8lPP4rdfs+reSk4e5ayGJ1Jkzz18RT1EWJCSMISFhDJcv38bbb38b09NR6O/PQG9vttUGyFhtgMKJm1BpsbtxlUg58lskcfvggy8BOIKv7waWl4MQELAqytRmY6SkKOJtpcUUZUFS0jCSkoZx5cot9Pay/VtNTWfQ2HgO0dGTVo13v6TSYv71SVXEDw+nAKDw53/+K+ztKbnvqK8vE97eO9Bqu0DTRiu/xX5GTGmx47B9Wu4V8Sy/9RSpqU+xu6vEb37zLUxNRaO7W8utGtK0ETpdl9M/x8ZIPR9FPMtvNaK4uBHT01EgspyenmxQ1BF8fdexva2GxbIkKs1ydth0NaS0mKarIJcfIT29H+npbD0Fy2/RqK8vQ319GRISRrj7iBVyCJUWO+eyGIZBYGAg4uPjRV/f+DjL5X33u9/F7u7uMRsgAdQjIyO5BxxPGCmxing+v7W1tYX33nsPU1NTMJvNMJvNSE5OtrMBCs2zKOKFrH3EBlhSUoKxsTFWdNDVhcw9f9RWVsJ3YwNHIm6gHR8Vwry8PFp/5CdSfBugEL+VkpLCHZId7Y9ihlgOpSjiZ2ZYBOA73/kOdnZ2uFSyo6OD47cMBoPdofxZGSlXiZRSqYTBYIDBYMD6+jp+//vfY3JykjvkONoAhUbsYZM/zhTxzvgto9GIJ0+eQC6XQ61WSz7MAZ4p4s+dO3eM3yJp0o0bN3D79m0ucUtKSpJUWkzGaDSKYqTIUBSFpSX2Zdx3vvMdbGxsuOW3AGlCDjKeKuJfzKdnPleHrImJOKyuBkGp3MVvf/sNqw3QDJp2vi5DSoudpTvOxpkintgAMzN7sb2t4lKbu3fLcfduGQAKKtUudne9RTFZ/NJiqeuP/ESK8Fvj47Y0yWSiodGsW42JRpeJlLMZGJCuiD848ML0dBTy85/g3Ll7XP9WTU0lamvLuf6tzMweKJX73OfclRYLjVhrX2joAsrK6lBaWo+2tjzcuvUydne98c4734a//ypnAwwPnxf8vDshh/PrMwgmUgrFPvR6M/R6MzY2NDCZ2MStquoyKOoiLBYZ/PzWsb/v5ZbfAvilxdIU8UajfWlxZWUNystrMTycxAkz2ttZfotNv4ySSovJ2BTx4u8jgF0xzM1tx7lzD8AwpH/rJbs0KS1twC6xIqXFz1sRT1FAdPQ0oqOnUVFxB0+enMDt21ewva3Gr371FwgOXuQSQmf8lnNGyvUwjHAipVLtIC+vHXl57VhZCeS+o48/fgUy2SGOjuQIClrC4aFM4IVUAxwPWevr6xgaGsKZM2ckq7351r7Y2Fi7NInwW2FhYVxSIqW0mAxRxEvpXFIoFJifn0dOTg6Ki4u5h0BiAySJG5/fIr+TGCEHf8SsP1IUhYSEBCQkJKCkshzf+sX/B7krCmyp1fj53/4tImZmQBuN0JtM8NvYsPvsEQXU56XjhyGxaK65LpmRcpZI8fmt+fl57jv64IMP4OXlhYODA4SFhcFisYi6LwgjVVRUJHltLSIigmNb3PFbOp3OI0bKE0W8j48PFhYWQNM0ioqKuFSS2ABJ/1ZcXJzdd+SutFhoxKw/8vmt3d1dtLa24u7du9ja2sJPf/pTxMbGwmAw2NkAHceVkMPVEEbKMZEKCAjA2bNncebMGUxPT3PGxJ6eHiiVSuzt7SE6Olr0fUQYqZMnT3qkiCepFbEBOvJbCQkJXOLmyWFzcnJSsiL+xXy65nN1yCKJ1H//7z/CxES8dZ0oH48fF1htgAz0evt1GVsiJYWREqeI9/HZwYkTT3DixBMsLQXh7be/jY0NDe7du4CmpmIuTUpJGXL653iy/mhTxNsnUqwNcBzx8eO4dOk2+vvTrfxWAR49Og2KOkJ4+Bx2d5WipRyEkfJEEU/TRvj6buHUqcc4deoxFhZCrImbAdeufREKxZ7VmGhEUNCypNJiwHbYlKKIpygLFhbCIZcf4O///p8wOsrq15ubT6OpSZjfAtyXFgvNzo43+voykJvrOpHSaDZQVPQIRUWPMDcXhv/8zz/B+rof6uvL0NxcjOzsbhgMRs4GKDSeMFLT01FYWAg7poiXySxISRlCSsoQrl69iZ4etn/rwYOzuH//PGSyQ4SFzcFikfIQThgpKYp42/qjvz/fBhjJHQBt/JbZ+s+tWoUc7kuLyXiiiJfLj7C8HAiZ7BDf+95PMDLCrjg2NJSgoaHEagNkkJ3dZScucVdaLDQ2RbxQImWbwMAVnDv3AGfPPsDUVDT+8IevYH3dH3fvVuDhw9MCL6Qa4MhlEZGClPRmdnZWsLTYkd8ibBKxAcrlcoSFhTlNAITGE0aKJFI0TQvaALu7uzl+i3A3Go3GIyGH0WhEVFSUaEW8n0qNnIAoYHkef/Ozn2EkORlGgwE1Fy+itqICyUNDoI1GZPb2Qrm/j8asRKgCgxG2jWdipFwlUmFhYRy/NTo6imvXrmFtbQ01NTVoaWnhviNXHJgnrJ0zRbwjv0XYpKqqKty5cwcymQzh4eFODxJC8yyKeJqmuTTJGb9FkhIfHx/RpcWO1yfF2uft7Y39/X1QFIW/+Iu/4BIuYgMkiRuf3wLECzn4w19/dJZI8fmtyspKDA4O4saNG9jb20N1dTVaW1vd8luAayGHs3GWSLnit27fvg2KohAeHi75pYVURfyL+XTN5+aQxSZSWmRl9UCt3hFcl6mrK0NdHVmXMSI7u5tLpJKT3ZcWkzGbpSviAWBtLRClpbVITBzh0iQbv8X2b/H5LXelxc7GaKTdJlJeXofIzu5BdnYPtrZ8UFdXiidPTmJ2NhI/+tH/5NKkrKwezgboOETI4aki3jGRCg3l81ts/xZrcjRAqWQPfVJSrKmp6GdSxPv5bUCn64JO14XNTV8uTbLnt4zIzOwD6SOTIuTo7s6WbO3z9t7D2logzp+vQ3z8OHcfdXSw/BZJk0JDbcIEkkiJEXLwR4wiXqncg8HAMmPswa8EHR15mJ2Nwg9/+I9Wfsto5beED5JCpcVir88xkWJtgDOIippBRUUNhoaSYTQaYDTm4MmTk/Dx2QJAISFhVPTPeRZFfFraAIKCVhEU1IHc3A6srgZwadKNGy/j9m02cTMYjEhNfQoppcVkenoysb+vFH0fURQrFVlf90dxcSNiYyfA1lM4vpAyITDQnstiGAYxMTEICQkRfX0Mw7hNpHx8fHDixAmcOHECS0tLuHfvHhiGwezsLN544w1R/BYpLdZqtc+siOfzW5cvX+a6pVpaWvDw4UNoNBpYLBZJhjZ+abHYsVgs0CztYNDnCOP+Spx6/BinHj/GQmgoGJoGQ9O49qUvQbG3h5T+Pvy2IBF/U3AFDMNIZqT6+vq4w6aYoSgKoaGhWF9fR2FhIWJiYsAwDJqbm9HU1ISoqCguTXJ8MHVVWuxsxKw/ajQaFBUVoaioCHNzc3jw4AHMZjN3H5E0iW8DdBxXQg531+dYWuyM37p//z7u37+PwMBAHB0dSXopsLi4iMnJSZSXl4v+DN/aRw43xcXFmJmZ4dIkR34rNjbWIyGHVEW8XC5HbGwsNjc3ceLECURFRQnyW1qtFiqVyu6znxQjxee3pqam0NTUhJ6eHszNzeHNN9/k6ilc8VueKuJfzKdrPjeHrIGBdMFE6vi6DMsmffzxF3D79hUcHMiRkdEHF8KmY0NKiz1TxDMICFhDXNwEZwM0Gg1obT2FlpYiK7/FdkutrvqLLi0mwyridZIU8Wr1Nra2fOHru4Fvf/s/OLX4hx++Zte/lZQ0ZNctxZoVPVXEO0+kWH5rFAkJo7hy5Tb6+tJx/fqrACz4z//8lpXfMlr5rQ3hPwTHS4vFjDNFvK/vJgoLW1BY2IL5+VCwxbk0Pvjgy1Aqd7G/r0B6ep9k1o5lpMQr4sn6I6sMX0Fy8jCuXLmJvr5MsDbAM3jwgPBbRuh0ZqyuBliFHO5Li8l4oohn1xcV8PHZwje/+RuYzTqYTHr09WVCpdrm+rfi4sbs/u5tpcXSGSlXiZQ9v+WN7u4s3L59GYAF77zzbasNkLHaAJ1zYI6lxWLGpoi3/50CAlZx9mwjzpxpxPR0tF3/lo/PFnZ3vZGW1i+ZtQsMXEZ8vLT1R4tFhpycToSELCEjw/ZCymg08F5I/RwGw1lkZ2djZWUFs7OzuHz5suifI5aR4k9wcDAoioJSqcTXvvY1dHd32/FbJCnh81uAfSIldsQo4smb6OzsbGxtbcFsNqO2thYA8M4774jitwDP1N4jIyPYXN/A+Qtn8GfBe/h//vpjvNzai9CFBZTW1aGkvh4j8fGoP1MEs06L3E0ZRm/cw+bmJtLS0jwWcogdkkjl5uYiPDwcOp3OzgZYXV2NO3fucPxWZmYmVldXRZcWkxHLSPEnPDwcCoUCXl5eeP3117n7iPBbJClxlKp4wkiJUcTz+a21tTWYTCY0NDQAYO+jtLQ0GAyGY2mS43jKSDkmUhRFISoqClFRUVyaxOe3goKCsL6+juTkZI+FHGKHJFJ5eXmIiori0iSSShJ+KyMjAzRNIzU1Faurqx4zUmIV8RRFISYmBr6+vpDL5Xj11VfR09ODJ0+e4PHjx1w9hV6vt+O3APFCjhfz6Z7PzSGLWPtcJVLsusx9nD17H1NTMaipKcfoaBL6+rLw5pv/yKVJUVHC/Bbw7Ip4fmmxPb/lY+W3aM4G6Oe3DpnsQNIqno2R8kwRHxa2gJKSely4UI/xcfs0SaNZ59ikyMhZMAwtqrSYP0QRr9eLuz4vrwMEBq5if1+JysrbkMksYBgDamouora2wpq4GZGZ2WvHbz0LI+UukQoLW0BZ2V2UltZhdDQBdXWlGB+PR19fFn7843/gbIBhYcL8FiBUWux+yH3kmEgplfvQ603Q601YX9dwh2RiA/T3X4VMdoj09F6xX8MzKuI7ER09hejoKZSX12JoiPBbNNrbT1j5LdZ0FxKyBIahERy8iNhY8UIO9rApfv3R23sXUVEz2N/3tvKN7H108+ZLDv1bA3YHHL6QwxNFvLNEiuW32O+osvIOBgdTcP/+eUxOxqKvLwv/8i/fg15P+K0Vpz+HlBafPftAlJyFf32sIt62/sh/IbW8HGjt3yrlbIABAQGgKErSW+3h4WGsr69LSm/4pcWkN4nwW0ajkbMBEn6Lpmn4+/vDaDR+IowUf9RqNRITE7G/v4+zZ8+Coig7fov0byUlJdk9bLsrLXY2JJH60ukSpGZm4P/rH4L/9/IcXr3fiYjFVWz4KHHnbC7WQ4LxdycuwkAFoLGxEevr6+jr68MvfvELQRug42xsbNiVFku5PsdEim8DnJ+ft+vfUiqV3MOoJ0IOKYwUSaS0Wi3Xm8Tnt4gNMDo6GgaDATqdDmq1mkukpBw2pSri/f39kZGRgdraWhQWFoKiKDt+i/RvOfJbnjJS7hIpmUyGtLQ0pKWlYXd3Fz09PWhubsbBwQH6+/vx61//mkuTXK1dOpYWix2hRCowMFCQ3+ru7oaPjw+3RijlsOmJIp6//khEMDs7O9x6c11dHerq6pCQkACDwYDs7Gx4e3tDbGnxi/l0z+fikLW1RRipFlFJAkUBMTGTODz0QljYLEpL78JkYnXQjx8XWtdl2DTJcU3vk1LE+/hs48SJNpw40YalpSAYjTl48IDtKPrpT/+eS5OSk53zW+z1GSQr4kkixX+gZvmtMcTHj+Hy5Sr097P9Wy0tBXj48DRCQhawuBiK4mLx/T/2jJT09cfc3E6oVLucDZCkkteufQlK5S73HSUmDksqLSZDFPH5+eIU8RRlQWLiCGSyIwQHL+DChQaYTDSam4vR1HQWUVFToGkGOp0JGs2m3WddlRY7m+npaLeJlJ/fBoqKHqKo6CHm5sLR2WnAo0dFsFhk+Jd/+T6XJrnit4BnU8Tzv3M2TRpEauogxw4xDI3798/j/v0LiIycwsxMFE6fbpR8H8XGjotStpMhQo4TJ57Ax2fbym9FHUuTiDExNnYCQ0NEyCH+72l3l/09DQajqPVH1gY4gJaWQgQELOPcuftgGAMaGkrR0FBq5beM0Gq7j70wIImUlPt8dta9Ij4oiLyQ8sbk5K9hNBrR1tYGAPj5z3/O2QCjoqJcPpR7ykg5KuLd8Vvx8fEYGxvjHljFzrMo4gsKCuDr62vHb5HrIvyWwWBARESE6NJi/jgyUiciEvD+V/83epZmUFVgwuTGGtQqH/xfUSk4H5MGGSXjrm9jYwNnzpwB3waYnJzM9W85JlyeMFJiFPFhYWEoLy9HWVkZRkZGwDAMOjs7AQBvvfUW9x25Y9T4pcViRyiRUiqV3MF8fX2dS9xu376N6upqJCUlYWhoyKMeKU8V8adPn4afnx/Ky8s5VophGC5NIt9RcHCwx4xUd3e3aEW8t7c3cnJy0Nvbi83NTRQWFsJkMnH8Fr9/y7FbylNGypUiXojfIqwkALz77ruCNkCheV6KeJVKxdVTLC8vc39n5IVUamqqR0KOF/Ppm8/FIauri2WkpKytkUSqvLwGmZn9yMxk12W6urLBMAbU1ZWjrq4ciYnDVkC9G0rlLhiGFlVazB+pivjg4GVERU3DYpGhoqIKS0sh6OrSwWRi0zpbmjRj92DqqrTY1dgSKWFFvJfXAY/fUsNs1qKxkbXlNDefwfR0DNj+rV6n/BZwvLRYzJD1R0dFfGjoAkpL61BSUo/R0XgwjMG66pQDP781KJV7UKm2JDNSYvrI+MNXxNtsgL5cmlRdfQl37lQiNfUpaJpBRkYvvLwOILa0mD/kkJCdLW5tLTx8DklJI3j4sBgXLtRheTkYZrMeHR2sDZAkbo6Ftzs7zkuLXQ1Zf3SWSLH8lhEGgxFra/4wmfR4+LAIAIVHj05jaSnUmiY557cAW2mxdEU8jbS0AW41kOW3phEVNY3KyhoMDiaDYQzo7MxBW9tJBAcvwstrH0rljqTSYiLkkHIf8UuL8/I6kJfXgZWVAGuaROPGjVdw+/YVZGT0WfXrTyGXH8JoPJ5IuRujkRatiKeoJsTGhmN3NxNtbW0oLi7G8vLysXUZmqaPKYpdlRa7GsJIOVPEO/JbpOsKANra2rC5uSloA3Sc56WId8dvRUREQC6XQ6lUeizk4E9WcCSygoUZFH4iRWyACwsLx9IkkrglJiZCJpOBlBaLFXIA4hgpMhRFISkpCRRFobOzEydPnsTy8vIxfkuv1x9L+p6VkXKWSPn5+XH81uzsLHewsVgsaG9v5757V/wW4Lki3mQyISkpiVt/dLQBOvJbsbGxoChK8iGhv79fEiMF2Cvi+WkSwzCcDdDHx4fjt2JiYrhU111pseMYjex/J8UkUnK5HOnp6fDx8UF3dzdycnKwvLzM2QBd8VtihBxC4y6RCgoKwvnz53Hu3DlMTk5yLxKkHjZfzKdzPheHLIYxIDx8FhER0hkpvd6WSKlUO8jPb0d+vm1dxmg04KOPvoBbt64gLm4My8vBOHNGWmmxjZGSoohnD1SFhazBkPBbrA3wFB49KkJ4+CwHqPv7r4kuLeaPjZESp4hXq7dw8mQrWloKERMzjuTkIZhMND788Iu4edNmA0xKGrbjt9jfSboi3pZICR+g2TRpFImJo7h8+Rb6+zPQ0ZGLwUG23+mtt/6S+474NkCheV6KeI1mE4WFj1BY+Ajz82Fct9T777P8VmLiiNXaJ6202GzWS2KkyO/k47OFM2eaIJcf4sqVm+jtZW2AjY1n8eDBecTETFgTNzPU6i0eIyX+pcXqagBGRpJEK+L9/ddw+nQTOjvZNdSkpGGYzXwbIJsmkeJf+9/JvZDDcWyJlPC/GzLZEdLSniItzcZvdXbmYGwsAQCFd975tjVN6nL7/fNLi8WOTRFvu77AwFWcPfsAZ86wNkDSv9XdrYWPzxaSkwcxNxeBS5fElxYfHVGckEOcIp7ty2KYWXh7e+PChQvw8vISXJdJTEzkdMfe3t6iS4v5I1URHxwcjAsXLqC3txe+vr5ISEhAV1cXZwMkiVtERMSxP++TUMQL8VtGoxFTU+x/U373u99xaZK7A8OzMFL87zw0NNTOBsgwDLq7u7meqtTUVMmlxWRtzVNFfEVFBRQKhSC/lZqaCpqmkZGRAYVC8YkxUvyJiIhARUUFhoeHsbOzg/j4eDsbIEmThIQvniriV1ZWUFJSIvj/J2lSTk4Ox28ZjUbMz8+Doihcu3ZN0AYoNJ4o4s1ms936o1CaRA4TbW1tCA4ORmpqquTSYv5hU+r6o5eXFy5dugRvb287G6AQvyWXyyULOQBpiniKohAbG4vY2FhMT09jZ2dHkpDjxXw65zN/yFpctCVSUpXMrhIp27rMfUxOxoBhDGhvzwUA3L1bgbm5SNC0EVFR0y5/Lr+0WOwQRTy/tNjL6xBZWb3IyurF1pYP179VW1uB2tpyJCUNY3U1AMHBC5JKi59FEf/KK43Ize2w2gBt/VsMY4Cf3xrHuEVEzIouLRa6PlYR7z6RUijYB+/dXW8MDqaisLAJY2OJuHPnImpqKqw2QAaZmb1QKPbtPmtLpJ6vIj4sbB7l5XdRVlaHkZEETpgBAA8enMfqahBo2oiwsAWXP4uUFkuRQ5BEiq+IVyr3QdMm0DTLb5lMrOnu9u0rqK6+iLS0ASwtBSEoSFppsdg+Mv7MzERhYYFNpE6caENFhY3fYusXTiAoaAmkWyo4eIljpPiJlLjro0Ur4r29d5Gb2wmKAsbGEpGf34rR0UTcvPmyQ//W02NJn6vSYmfDX38USqTY9eYpxMRMobKyGoODqWAYlpUEgJaWIuzustIfd1UFttLi2+IuDsDeXj16etiHSPJA525dJjMzEwsLCy4TKaEhingpD0Jzc3OcIr6goMCuf4vwW+Hh4VxS4u/v75GQA5C2/qhWq3Hq1Cn4+Pjggw8+AE3TGBsbw7Vr1zg+RojfAlyXFru7PmeJFEVRSExMRGJiIi5fvoy+vj4wDIOOjg4AQEdHBywWi1t+CwC3/ijFcEfsj1lZWdy6Ip/fmpubA1Gdv//++/D29kZWVhYWFhag0WgkHzalJgkLCwuYnp5GZWUlioqKBPmtmJgYzpioVqs9EnIA0hTx/v7+KC4uRmBgIP74xz8iIyMD4+PjgjZAx3vFWWmxuyGJlNAhwZHfIt1SJE3u7u7mesHcafP5pcViRyiRcrQBktXd7u5uqNVqaLVazM3NQa1WeyTk8GT9UYqQ48V8euczf8gSSqTczcREnJWRuuf2n6UoIDZ2EpGRM2AYPWJjJ+Hru4m2thNoaWH5LYPBCL2esZNa2K5PuLTY1ZBEylmSoFZv4+TJNpw82YalpWAwDI2OjhysrbG9PNeufRE0bURy8rDLtUFbafGzKeJZG+AYEhLGcPky6d+i0dJSiIcPixERMYOoqGnJpcVSGSkyJJGqrGQP3gsLoVya9MEHfH7LaGWqLNzBR8phc2oqRrQinqIsSEoaQXz8GPr60hEcvAQfnx00NRWjsZHwW2z/lq/v5rHPk9JiKeuPJJFy9p37+W3g9OmHOH36IWZnw7nDzeamBnL5Pm7ceBk0Tfq3nP8cch/xS4vFjGNpMZ/fIlwTwxhw79553Lt3AbGx44iKmvJAyEEYKamKeBpBQUu4epVNiqano7g0ycZvsf1bMTEToChxpcWOY1PEu0+kWH6rH6mpAxgZSYBGswGVahf19aWory+11lOw681Cwhd3Qg6h6enpxv5+utODj9C6jMlkws7ODhQKBaqrq2EwGI7ZAIXGU0aKn0iRdaqsrCxsbW1xiVttbS1qa2uRnJyMyMhIj4Qcz6KIf/XVVwGwKQZhSshKGz9xAz45RoqMQqGATqeDVqvFm2++CZVKBblczvFbfBug0O/qqSJ+d3fX6e8UHh6O8vJyu8Stq6sL+/v7UCqVqK+vB03TolYaPVHEE9aO3EeO/BYx3RF+Ky0tDVFRUZKFHFIZKTIknX399dcBgOO3+DZAcr3BwcEAPDtsSlHEe3t7Izc3Fzk5Ofjxj38MuVyOvb09Lk1yxW8BzkuLXY2rRIrYAGNiYnDx4kU8ffoUDMOgvb0dh4eHUKlUaGxsFMVvkevzVBEvJdl8MZ/e+Uwfsmw9UlIZKZoruhU7AwPp2N31wZkzjUhNfYrtbZXVukfj7t1y3L1bhsRE0r/VA2/vXdGlxY7DMLRVEe8+kQoOXsKFCw0ALLh37wK0WjMGBtJhMtHQaNZ5adLMsQdlW2nx81PEs/xWN7Kzu7G5qUZXlw4MQ6OzMxeABS0thdjZ8UFmZo+dDVBoSGmxlPRGKJEKDV1AWVkdSkvrMTqawBkTCb+l1zPo6tJKKi0G+IyU+PXHwcFUbG/74uzZj5CR0cfxW0ajAdXVl3HnzkUrv2VERkYfFIoD0aXFjkOsfWIU8RERc6ioqIG39zbq68uRljYAk0mP9vZ8qw2Q7d8SSlqclRa7GtIjxa4/Hk+kvL33kJNjRE6Ojd9iqw4KAFjQ2ZkDAEhLG3B7cLKVFj+bIj46ehrR0dOoqLiDoaEU7r5uazuF4OBF0LQRUkuLARsjpdWaRX9meDgZm5t+uHLlFrKze6z1FGwq+fHHr+DWLcJvGa381hGvtJiReNhUIDDQfSLFX5fx9/fnhBRtbW1oaWnhbIB6vf4YvwU4Ly12Ne4SKbVajZMnT+LkyZMcv8UwDIaG2JdePT098Pb2dstvAZ4p4kkixVfEJyQkICEhAVeuXOHSJD6/RdO05NJiwHZIkKqI39jYwMWLF6HT6TA/P899R4Tfys7O5vgtiqJElxY7jtj1R5lMxlklw8LCUFNTg4iICDQ1NaGxsRHR0dFcmiT0d+6stNjVkLU1Z4mUn58fTp8+jdOnT2N2dpZj3Pr6+gCwFs3AwMBjNkCh4ZcWix2hREqI37p37x7u3buHuLg40DSNzs5Oj4UcUq5vfHwca2trePXVV0HTNMdvmUwmp/zWszJS7hIpuVyOjIwMZGRkoLm5GTU1NQgMDOT4rYSEBG692ZHfApyXFrsakmwmJiYK/jfuxXz25jN9yBofj8PKSjAODhS4f/+sdV3GdSLzrIwUUcT7+OwgP/8J8vOfYHk5iHvA+eijV3Hr1lVkZvbCx2dLcmnx0lIQxsfjUVYmjpEC2MOmycSWFn/xi9dwcCDHwACbJj1+XIBHj05b+S2jld9aB8BPpKQcNtNEK+J9fbdw6tRj6PUM3njjfyEycgaLiyG4du2LUCj2kJ3dzdkAHfktwFZa7IkiXiiRIjbAxMQRXLlyC319GWAYAx4+PA2LRQaLhcLDh4XQ681u+a3DQxlPyCGNkeIr4vn81txcGFjVuR7vv/86vL13kJXVDR+fLckiBRsjJU0RbzKxivivfvUP2NtToLeXtQE+eHAW9+8TfssIna6LY3o8YaRsinj395G//xqKi5uQn9+KN9743wgJWcTkZCz6+zOt/BabJsXGHue3yPU9T0W8XH6EtLQBpKUNYGfHGz09bNl5QwP7NttiWcSTJ/nIznbPb/FLi6Up4u1Li9l6igc4e5blt4xGA7q6WH5Lrd6ETmeGj88W9veVkli7tTU/DA8n4OzZYEmrL2azGTExMfjmN78paAN05LfY38l9abHjEEZKTHpD+K2ioiL84Ac/QGBgIAYHB9HV1cXZAEn/ltAIlRa7G1frj15eXtBqtdBqtdjc3ERXVxeMRiNqamoAACEhIWAYRhS/9ayKeLL+GBYWZsdvkcSts7MT/v7+0Ov1UKvVHh02PVHEd3V1ITIyEt/97nexsbHBpUlVVVWorq4+xm8Bnh02pSjiIyIiUFlZifPnz+OHP/whNBoNurq60NnZicDAQC5NclbYLVRa7G5cJVKO/BY5JN+8ySbj4eHh6OnpEcVv8XukPFl/zMrKsuO3KioqBPktmqahVqs9EnJ4oojv6elBeHg4/uqv/squf+vjjz+247dSUlK4xE1MabHjeKKIfzGf7vlMH7LYh7t9BAUto76+DPX1Zbx1mS5B9sdWWiz+gdWdIj4oaBnnz9/HuXP3MTkZC6ORRleXDtvbalAUawADKERGuua32N+JrD+KfxCamLBPpFh+qwdZWT1WfotNk2prK7luKZ3ODLNZWmkxuT5PFPFHR164evUWoqKmMTYWL5AmscbEiIg5AOJKix2HJJtiEimF4gA6XRd0ui5cv/4yGCYHavU27ty5hJqaSiu/ZURmZt8xfgtwXlrsanZ2VOjtzURe3hPBRCo8fB7l5bUoLb2L0dFEjrvZ2/OGTHaIvr4MqFS7CA11zW8BnjFSjop4lt9ieaj1dT8rv0Xj9u2rqK6+hLS0Aeh0DEwmaaXF7PURRbx7RopMb282Dg8VeOmlG4iJmcLQUDIYhobRmIMnT05a+S2jld9i1xZtiVTDJ6KIV6l2kZvbgdzcDnz00cvo7MwFRQE3bryM27dZfstgMHI2QMdxVlrsalwlUnx+6+LFajx9mgqGMeDJk3wcHnpBJjvEyEgC/P1XRdUo2BTx4iUeJJEipcV8G6Azfkuv14NhGI8ZqfT0dNGf6evrw+HhIV5++WXExMQcswESfoumae5Bkwg5XJUWO7u+6Ohot4mUr68vTp06hVOnTuGjjz5CR0cH9vf3OX6LnyYJPVw+D0U8f/j8Fj9xa25uhsVigUwmw8zMDMLCwkSJL8j6o5QHVsdESqPRcDbAubk5Lk0aGBiAt7c3srOzuftIqpDDk/XHp0+fYn9/Hy+99BJiY2PR29sLo9GIBw8e4P79+4iJiYHBYIBWq4VarQYgXcjBvz4xiZS/vz/OnDmD4uJi3LhxA+3t7djY2MAf/vAHLk2iaVqQ3wJsQo7npYgnNsD09HTs7OxwiRspYZbJZFhZWcH29rZbfguQ3kcGHFfEBwUFHeO3zGYzurq6oFarodPpoNfrYTQaJQs5PFl/fDGf7vnMHrIODrzQ1aVFdnYPvvjFDwTXZTIze0HTDFJSnnJMD8Owa3TJycOif1ZXl06UIp7ltyYQGzuBU6ce42c/+x5CQxfQ1nYSLS1FCAubA+nfElpvdFZa7G5s1r7jiRTLb7Xi5MlWLC6y/BabuH0BALCx4YvBwRQkJQ0Jpkn8eXZFPFvynJAwioSEUVy5cht9felgGAMePSpEczPLb9G0ERsb7IOWlMOmjZFqEv2Zw0M5+vqykJXVgy9/+Y+Ynw8FkVN88AFrA7QlbiNct5SY0mLHIYp4d/eRTGZBUtIwkpKGcfp0I372s+8jMHAFTU1n0Nh4DtHRk5wNUIjfclZa7G5cKeL9/NZx+nQzTp9uxuxsBMe49fWxDyW7u0qMjcUjLs41v8X+s7bSYk/WH2NjWf4pNfUpUlOfWpkrNk26d+8C7t0rQVzcmPVw6AupjJSnivj+/gxkZPThK1/5Paano4/1b+l0ZtC0ETExk9x35BkjlSUqkZLLj5CR0Y+MjH7Mz4fiZz/7W2g06w4vpIxWfkv4RYuttHgUwP9D1PW5svY58lsEUDeb2VXJo6MjTE9Pi+K3+KXFnjBSRM3NtwHy+a27d+8iKSkJNE1jbW1NMiPliSLeYrFgcHAQaWlp+PrXv27HbxEbIEnc+A/cnvaRiUmkCL+l0+kwOzuLn//85/Dx8RHNb5Hr85SREkqkwsPDUVFRYde/1dXVxUk8oqKisLCwIIrtI4dNqYwUXxEvk8kE+a1bt26hqqoKaWlpoGkaq6urkg8JnijiAZbZSklJwTe+8Q3BNIncR4TfIr+Tq9JioRGriFepVMjNzUVubi6mp6fxy1/+EkqlkuvfcrQBCs3zZKSc8VukngJg76OVlRVR/NbBwQHMZjMyMzMlrT++mE/3fGYPWf399tY++3WZGC5N6urScesy6em96OtLR0GBuNJiMgxDS1bEd3XpAFjwzW/+JxSKPc66d/duBe7eZW2ANM0gK6ubW1sUU1rsOCwjpRWVSIWELKGkpAEXLjTg7be/jcnJWMzMROE3v/kWNJp1Xv/WrJPf6fkq4r28DqDVdkOrZfkts1kHhjGgpuYiAAtUqm2MjcVDre51y28Bx4UcYubp01S79cewsAWUld1FaanNBtjdnY3Ozlz4+69Cr2fthM8i5IiOds9IkentzQYAfPOb70KhOIDJxH5HVVWXORsgTTNIT2f5LYCfSH0yiviIiFlUVtagvLwW77zzp5iYiMP4eDz+/d+/a+W32DTJGZckVFrsblZXnSdSLL/ViZycTqyu+nPGxJs3XwJggY/PFmZnI+DvvyaKRTIan0URz4CigOjoKURHT6Gy8g4GB1PA2knz0Np6CiEhC9b7qAe9vZmgaamMFI3AwGXExY2J/szAQDoAGf70T9+BTHbE9W99/PEX7Pq3+C+kZmYiMDcXYS0t7gKwB8D1QyhhpNLS0ri390LD57cuXbqEd999F+Pj4xgeHsa//du/cfwWTdNO3yQ/b0U8n99aXFzkErcPP/wQFEXBx8cHq6urCA4OFpVCOIoUxAw/kaIoiuO3+P1bjx49QnNzMyIjI7nDzSfJSPFneJh9Ofntb3+b+x35/VuO/BZgE3J4wki5S6RkMhmSk5ORnJyMK1eu4L333sPY2Bj6+/vR19fnlt8ChEuL3Y2rRIrPb83MzHBsUl9fH3cf7e7uwmKxiEpFPVHEk9LikpKSYzbAnp4eGI3GY/xWRkYGx0hJPWxKVcRPTEzAYrHgT//0T2GxWLg0qbu7Gz4+PpwIJjo6mvuO3JUWCw1//dFVIsXnt3Z2dvDb3/4WY2Nj6OnpQU9Pj1t+C3At5Hgxn935zB6yGMYgmEix6zKTiImZPLYu8/hxAQD2YLKyEiBqXeZ5KeJPnHiCEycIv8U+4Fy//ipu3rxqNd0x6OnJkFRaDPAZKWlraxMTcThxohXl5XfR38/2b7W0FODhQ5bfYo2JJvj5rXOfszFSUhXx7q19vr5bKCh4jIKCxzCbs/H++18BRVlw7ZqwDdBxWEW8/rkp4okNMCmJz2/RaG4uRlPTWQCATHaIjQ1faDTH0yTH4ZcWS72P+IlUUdEjFBU9wtxcOJcm9fdnwNt7x5q4GdHdnWU9JEgRckhXxO/tKTE5GYvc3HZUVNSip4ft37p//zzu32dtgDTNQKs12/FGnjBSJhMNMYlUQMAazpxpQnFxE8xmHT744Ms4PJTjD3/4mtUGyPZvkTTMcfiMlGeKePtEirUBDiA9neW3urvZsvOGhlKO4fL23sHOjkoU22crLRaviAfYgyNfyOFYT2E2819IsbIck0nHKy1m+7KA0y5/zvDwMDY2NiQ9aBweHmJqagoGgwEVFRXH+C2SJjkC8u5Ki4VGrCI+JCQEJSUluHDhAoxGI65fv479/X385je/EbQBOs7zVsQrFAo7fot0S925cwd37twBwD7c7+/vizpoCQk5xF4fX8hRXl5ulyY58lsGg8GjQwJhpMrKykR/hqIozMzMgKZplJWVcd9RVVXVsf4tPptEEsJPQhEfGRmJyMhIlJeXo7OzEx9//DF2d3fx7//+7wgKCuK+I36axB+h0mIx40wRz+e3VldXucTt5s2buH37No6OjhAUFITDw0OnaRJ/nocinjBc/P6t9vZ2tLa2IiQkhHvZ4om1zxNFvJeXF+bm5qDX61FSUsK9bHHFb5HfyVVp8Yv5bM5n8pC1teWDgYE0p4wUGf66zM6OCr/4xV9hc1OD1tYCtLYWiFyXeb6KeJbfuodz5+5hYiIWpFuKfYi0ICRkEUtLwYiMPG4DdHZ9z6KIZ22APcjO7sHWlhpms9aaJlVy/VssKzXjkZCDVcQPS1LEj40lwstrH9///j9hdjaSS5P4NkCDgUF4+Bz3GcdESsyIVcQrFPvQ6czQ6czY2PDFr37151hf98ejR6fR0lKIlJRBGAxGZGT0cmmS43jCSE1NOU+kwsPnUFFRi7KyuxgZSeQelDs68kBRRwgJWcTGhq9oKcezKOINBgZK5R4MBvbvZW3Nj0uTbt26iqqqS9ZuKQbh4bMYGUnEhQtSGSkacXFjHGvlbiiKXR+Vyw/w93//Y0xNsYeJzs4ctLWdRHDwIncf8bXzg4OuS4uFRqwiXqXaRV5eB/LyOrCyEoB33vk2VlcD0Nx8Bi0thcdsgELjiSKeJFKOinhSTxEby38hRePJkxN4/LgQFHWIkJAl7O+Th/YGuDtkecJI8RMpPr/FtwFev34dN2/e5LqlwsLCJJUW868vJiZGtCKeoijMz89DJpPhe9/7Hqeod7QB6vV6u4dgd6XFQiPW2ufr64uCggIUFBRgYWEB7733HlZWVvDgwQO0tLRw35EzfgvwjJFypoinKIqzAfK7pZqbm9HU1ASZTIaQkBBJf0+ktFgKI8VPpPz8/Dh+a3Z2lkuT+vv7OX6LlAs/ffoURUVFkg8JUtYfCXtEURT+9m//FhMTE2AYBvfv38f9+/cRGxsLmqbt+C3AfWmx0PCtfa4SqYCAAI7fmpmZwX/9139hZWUF9+7dw+PHj4/ZAIXGsbRYzCwuLgomUo78Fqk4IDZALy8vhISESE7ZpK4/8hMpoXoKR37LYDAgMDDQIyHHi/n0z2fykGVjpMQ/CG1uqrGyEozy8jvIzu52si5jRErKIPeAQ6x9rkqLhYasrblSxFMUEBc3gbi4CVy6VIX6+gtoajqL5eUg/Nu//Y3VBshYbYDCP3t72wd9fRk4eVKqIt4gqIhXq7dw6lQrTp1qxeJiCJe4ffjhFyGTHQCwwN9/BUdHlFt+C+Ar4htFXxu/tNjHZxeJiaNITBzF5cu30N/PpkkPH55Gc/MZREZOg3RLSSktJuOJIv7gQIGVlWCUlNxFVlYvlya9/z6f3zIiMXGU47fElBYLjc3a5zyRksksSE4eRnLyMK5cuYmGhgt4+LAYi4sh+Jd/+b6V3zJa+a0twT+DlBbn5bV7qIi3T6T8/ddRXNyM4uJmzMxEgBgTe3uz4OW1D4BCaOg8LBaIOmjNzERZGSlpiniTiV1/9PXdRlraU6SlPcXurje6u0n/Fp/fMkKr7eIYKSlCDv5hU+zIZBYsLwfh7Nl7yMjo5w7JxAZIjInR0TZ+y11psbNhGINbRbxcfoiMjD5kZPRhZ0eFhobzaGkpwsJCGH784/+BxMRh0HQ3srN3nfIGpEeKX1os7voYBAYGHkukiA3w/Pnz3EOp2WyGyWSCUqmExWJBVFSU6LUrRyGHmOEnUgEBAQgICOD4LZKU1NTUoLa2FklJSTAYDMjMzHwmRkrK+qNKpcLKygpOnz6N1NRULk3i81sGg+HYYcBVabGzEWPtUygU0Ov10Ov12NjYwL1799DW1oaFhQX88Ic/FLQBOo5QabHY6xNaf4yIiDjGb5nNZnR0dEClUsFisUhKQz1VxJPS4pCQEISEhMBgMGBtbe0Yv8XvliKHBE8Pm2KGoigEBARgdXUVBQUFSE5OPsZvkTQpKCjI7rOuSoudjZhESqVSIS8vD3l5edwLhPb2diwuLuKNN94QxW+Rw6ZURkpIEc9fb7548SJXdk74LY1GI/mw+WI+G/OZPGQZjQaEh886ZYeEhp9I+fuvi1qX2d+XY3k5GOfPuy8tJkMU8VlZPaIV8XL5IRYXQ+Hru4H/9t9+xkH8tbUVdmmS45/Z1aUVJeTgz/KyOEV8SMgiSkrqceFCA0ZH4/Db334D+/sUrl37MmprK3n9W87/DjxhpAYGUgXXHxUKlpHRaruwuelr5bdozgZosQDJyYM4OpKL5qSeVREfGLiC8vK7KCs7zm8FBKxwjNvenlJ0aTEZlpGSpohXKvexthYAtXoTf/mXv0BPD9vjVlV1xaF/qx9eXrbEjQg5pKQ3KyviFPGRkbOIjLyD8vJaDA4m4f33X8fhoRx//ONXrDZAxmoDdH5ocCwtFjO2RMr+3w1v713k5nYiN5fwW+yLhJs3X0ZV1WUcHcmQnDwoaRWPlBbHxoo38JFEKieH/d1jYqZQWVmNwUE2TWpvz0drawFCQha472hnRyW6tJjM0RHFHTbFKuJVqh1sbflCpdrGn//5WxxP+tFHIbh16w2n6zI9PT3Y39+X9KDhipEiQ1EU4uLiEBcXxz3gXL9+HQDwhz/8gbMB6vV6l9zF81TEq9Vqzga4uLjIsUnEBnhwcIDk5GRRK1f865OqiOeXFoeFhSExMRGXL1/mbIAPHz6047f0ej22trZElxaT8UQRr9FocHBwAKVSiW9/+9vo7u6GyWTC+++/D29vb2RlZcFgMCAhIcHu795dabHQEEbq9OnTTpMER36rt7cXt27dAgD87ne/Q3R0NAwGA3Q6nUue0BPWbmxsTFAR7+/vj+LiYi5NIolbb28vVCoV9vb2kJSUJJm181QRn5OTg4iICI7fImlSQ0MDGhoaEB8fz7FJW1tbkoUc/MOmWGtfYGAgKIqCXC7HN7/5TfT09HD8llqt5hI3Pr8FeMZIiVHEy+VyZGZmIjMzE9vb2+ju7kZNTQ1CQkIkHTZfzGdjPnOHrMXFEExOxqK8/I7oz5BEKjl5iOuIAtyvy3h7b0MmO5AkKrAp4sUffPilxb6+Wzhxog0nTrRhaYnwWwZcv/4a179F00YkJw9DSmkxGamKeIqyWItMVbh69SOo1TtgGBotLYV4+JDYAJlj/Ja70mLn12ewJlLOFfG+vpsoKGhBQUELFhZCUV1diadP0zE0lIY33vhfyMrqgcFgtLMBOs7zVMQ78lu9vWz/VlNTMRobz0Kt3gBFHSIhYUT09zA46Iki3ptTxAcGrqGo6CGKih5idjacS5Ns/FYXDAYG8fFjHCMlprSYDLveKn79USY7gq/vFnZ3Vbh48RZ8fHbB2gDP4949wm+x/Vt8Fsq+tFiKIt7gVhHP8luNKC5uxPR0FO7eLcfQUAoGB9Pwwx/+I5cmxcQI81uAcGmxuyH3kaMinuW3+pGezq43s/wWjfr6UtTXl8LPbxUUdYSUFPEp2/BwslURL/6/R3t7SvT2ZkKvZxAausirp4gBw/y/YDYPcesyxFAWFRXlNJFyNYSREvtA7eXlheDgYOzu7qKsrAwqlQrEBkjSJCF+i59IuXqAdhwx648hISEoLS1FSUkJxsbG0NDQgJGREQwODuLHP/6xW34L8JyRMhqNxxTxfBugI79VU1PDlaRKSUeeVRFPepNI/xaf3woICODuo7CwMHgi5JC6/qhUKhEVFYXd3V2cP38eSqUSDMPg9u3bx/q3+Kmsu9JiZ+OMkeIPn98aGhrCgwcPMDY2hsHBQfz0pz/l0iRn/BZgY6SehyLe29ubswGurq5yq7s3btzA7du3uVQrOztb9M8hQg6piviuri5kZ2dztQKVlZWcDVCI3woMDAQRcrgrLeYPUcSL/e+Rj48PkpKSsLu7K3l1+cV8NuYzd8jyhJEaH49zm0jx12W2t1UwmfSoqroEi0WOn/3se9Z1GQbZ2d0uDw2OpcVihiRSjg/UwcHLuHDhHs6fv4eJiTjOmGgysatxW1u+OHXqoeifY7GwKaCnini9vgve3uxK3OammuvfIvxWcvIQaJq1pg0NJUtmpIgiPj+/TXQaFRq6gL09b4SEzOPq1Zsg3VJGY47VBsimSeHh8w6/E/s/xs9bEa9Q7EOvN0OvZ/ktNpEsh8Uix7/8y/d4aVKfU36LXN/zUsRHRMyhoqIGZWW1GBlJAsOwavGOjnz4+69ibS0ABQUPn0nIIWbI+qPBwMDHZwcGgxFra8QGSOPWrZdQVXXZym8ZkZY2gOFh4UTK1ezuKiUp4lkb4DSOjmQIClrEpUtVMJlodHbmoq3tFIKDF7k0ic9vsb+TdEZqdjbSmkg5V8SrVDvIy2tHXl47VlYCYTSyB1KLRYaf/ex7ovgt9vqEhRyuRkgRb3shNYOLF/8vbl2mra0NLS0tCA4OxtLSEk6dOuURI+WsuNXZZ2QyGfLy8qBWqwX5LdK/RdM0kpOTMTw8LLq0mIxURTyxAcrlcvj7+6OyslIUvwWIF3LwR4wins9vzc/Pw2g0ormZTdT/9V//VdAGKDSOpcVipq+v75giXiaTCfJbTU1NaGxsREREBGZnZ3Hy5EnJ95FURTwRcpw4cQIajQanT5/G7OwsZ7oj/BbploqPj/dIyME/bIrhiWQyGVJTU9Ha2gqNRoPS0lKYzWbOBkj4LZ1Od6xbyhNGSowiPiAgAGfPnsWZM2cwPT0NhmE4zfm//du/QafTgaZpl/wWYF9aLHaEEilHG6AjvxUbG4vJyUnk5+d7JORw10fm+BlAWmnxi/nszGfqkEUe7hwTKXfDMAYoFHsuGSn++PjsQKPZgMUixxe+cA2rqwEg3VL2/VuDdiyUu9JiZ2M0EkZKWBHP8lvjiIsbx6VLVRgYSENdXRm2ttR4/LgIIyPJVjbJ5PJ7eZ6KeF/fLZw69RinTj3GwgLLb5lMNK5d+yIUij2o1VtQqbaRlCT+sNndrZXMSPETqeM2QAOam0+jqcme3/L13eAxUuKFHEajQdL6o0aziZCQRVgscly+fBNrawEwmfR4//3X4e29g6ysbhgMDBISRu0SN/vSYmmsnStFPMtvDSE5eQhXrtxEb28W7t07DwBoaSnCxEQcSP+WWi3MbwHHS4vFDJtIHS8t9vdfQ3FxE06fbsLsbCTXLdXbmwWVahtq9RaUyh2kpnrCSElTxI+MJOL8+QY7GyBZ3W1oKEFDQwni40dhKzvfAcMYrEIO8YyU0UgYKXHrj4GBK4iJmYTFIkd5eQ1WV/3R1WXjt0j/VnT0lN1BmZQWP19FfAPk8v9jty7T1dWFxkaWu3z8+DHm5ua4lSJXLMSzMlL8RMqR3yL9WyaTCRqNBiqVCgqFwmMhh9jhlxbzbYDEmEj4reTkZE6/TlIUMaXF/CGHBLFra2FhYUhJSUFTUxPOnTuHtbW1YzZAmqaPHVTECjmErs9VIuXIb5lMJjx8yL40bGtrw8rKilt+C/CckRJSxEdERKCyshLl5eUYHh7m1vfa29sRGBgIb2/vT5yRAmzrjwUFBVya5I7f8vLyEkyk3I0U+yMxAe7v76OlpQWFhYVYX19HR0cHlyaR+8iR3yKlxeSeFztGo9FlIuXIb5EDoMViQUdHB7a3twXXmx3nk1TEv5jP7nymDlnj4/FYWQlCcfED0Z8hpcVZWT1QKsUxUoBNEU/TJshkR9Z1mVguTTKb9fD13eAecKKipj1ipJaWWEV8WZk4RbyX1yEyM3tRU1OJ+PhR6HRmMIwBtbWVqK2t4NIkod+XJFLPWxEfGrqI0tJ6lJQ0YGwsDu3teWAYAwAKP/nJf+fSpIiIOad/Bnt9tMeKeH4ipVAcQKfrgk7H8lukW4rwWzExE1haCkFBgfgUkC/kkKaIZ9cficGwtNRmA+zu1qKzM8/Kb7Gmu9DQBdGlxfxZWQmQpIhXKveh1zN48OAsoqMnOOnD7dtXUF3N8lsGgxHp6fb8FuC6tNjZDA6muLT2URQQGTmDyMgZVFTUYmgoGR0duejuzgZA4Wc/+zuQ/i13hkFnQg5XI6SIV6l2kZvbgdzcDuuLFtaYeOPGy7h9+zLi48cwPx9u7ZESN3whh1hGiv2dWCFHQcEjeHkdCtZTsPwW+x0FBq5yiZSUlVP3ivgm8PuyiA2wtbUVERERyMrKAsMw+Oijj+zSpJSUlGNvlF2VFjsbd4kUn9+6dOkSBgYG0NnZif5+Nsl76623RPFbgGeKeD4jRcbX15fjtxYWFrjEjfBbSUlJmJmZ+cQZKfI7eXt748yZM1AoFLhy5QrHbxEbYFRUFJeUaDQaj4QcGxsbHCMl5oFVo9GgqKiIk5pkZGTAZDJhYGCAswHSNH2M3wLECTkcx10iJZPJkJKSgpSUFFy9ehW9vb3o7OzkesLefvtt7jtyt37KLy0WO0Jra4Tf4idufH4rJSUFk5OTKC8vF/1zPF1/JEKOkpISKJVK7OzsoKenR5Df0mq1UKlUXGmxlPuIrD+KtfYFBgbi3Llz6O/vh1KpRGpq6jEbIE3Tx/gtgL2PAGmK+ImJCcmK+Bfz2ZrP1CHLaKQBHKGq6oo1vbEvzxQaW2mx+AdWIUU8uy4zgdjYCVy6VI2BAfYBp63tBFpaChEaOo+9PQVCQuYllRaT9Ud3PVL8sSni7yMnpxMnT7ZhaSkYNhvga7h5k+W3DAYjkpKGYLHIeImU+MOm0WgQrYinKAsSEsYwPx8GhslBWVkNxsfj8ehRIZqbCb9F+rc27D67vBzktLTY2dhb+4QTKV/fTRQWtqCwsAXz86FgGAMePz4FALh7twLT0zGgacYlvwU8P0U83wZ49epN9PZmgmFoNDWdQWPjOURHT2J7W4WgoEVJLKBURgqwV8Tn57fj9OmHmJ2NONa/Rbql4uPHcXREcX1kUhgpo5EwUu7XH2WyI6SmPsX6ugbd3VqcO3cP4+NxDjZABlpt17EuK1Ja/LwV8QEBqzh7thFnzjRiejoaRiMrpwCAhoYSLCyEgaaNiImZdPlz+aXFYsemiDdyiZRjPUVXF9u/VV9fhvr6MiQkjGBzU21NpKQIOdz1kR3vy5qZmcHc3BwuX76MU6dOcbpjkiaZzWb4+vpybFJkZCT3cOeutNhxpFj7vLy8kJWVhf39ffT396OwsBATExMcv0XSJCHVtRghh7Pri46OdqqIDw0NteO3jEYjt27U1NSE9fV1QRug4zwrI0WSIT6/tbGxwfFb1dXVuHPnDlJSUrC+vg5/f3+PhRxih19aXFRUZGcD7OrqQkdHB8dvGQwGhIaGii4tdhwpinilUgmapiGTyTA8PIy8vDxMTk5y/FZaWhpomkZ6evoxq6ar0mJX4yqRoiiK47cqKiowNDTEfUcAmwISAY0rfgt4fop4lUrFJW4rKytc4kb4rYyMDKyursLX11eSkEMqIwWwinhy2CwuLsbFixc5fovYAENDQ7mXLYGBgXZ9ZFISKaPRyP135sV8Puczc8hiEykdUlOfIihoGV1dfBug8LoMYEukpKytuVPEy+WHyMzsQ2Ymy291dWnR3p6PhYUwABa88863wfZv9bjkt4RKi8WMTRFvS6SCg5dw4UIDzp9vwPh4HPj9WxrNOmJiJiWXFhMhh6eK+OLiJlBUEzY31VYboAE1NRd5iZsRmZm9UCr3uURKymFzcjJGkiI+LGwBFy40oK0tH4mJwwgMXOFsgCy/xaZJYWHzxz7riSLenbWP5bdM0OtNWF/XWDmpXCwvh4CijvDb337Dmia55recCTncjZAiPiJiFpWVNSgvr8XwcBInzGhvz0dg4DJiYiatQg4ph01v9PVlICenQ6IinhVyXLhQD4piJRMkTbp58yW7/q20tAHI5YeiS4v5I0URz/JbU4iMnIHZrENk5AwCAlbR0ZGL1tZTCAlZgF5P+K0Vgd/JM0bq4EDh9D5SqXaQn9+O/Px2LC8HWnmyHCwvB0MmO8T7739Z1AspvpDDtSK+AfxDlqO1j687JmkSn98KCwtDTEyM5NJioojX6XQeKeIrKytBURQWFxe5NOnDDz+0699KSkqCTCbziJGanZ11y0iRIfxWXFwcBgYGoNFo4O/vj0ePHh2zAQodHj4JRbxGo0FhYSEKCws5fothGKyvr0Mul+Ojjz4SxW+R65OqiHdcWxOyAfL5rejoaMTGxnrESPX09Hi0/ujn54erV69CJpPZpUl9fX1QqVRc/1ZcXBwoihJdWswfMYwUGcJvpaSkYGxsDEqlEhqNhuO34uLiuDTJkd8CxAk5HMfd+mNgYKAdv0UYt62tLXh5eaGqqkrQBig0z8JIkfvIkd8iq7t1dXWoq6tDQkICYmNjJSdS/MOmFEX8i/lszWfmkNXfn47dXRUKC1uQkjIoal2GJFIFBS2iep3ISFHE+/js4MSJJ1hf98P0dBSKih6iry8DH330qp0NMCVl6NhBxVVpsbMhinhniRRFAfHx44iPH8elS7cxMJAOhqHR28v+R7S2tgJzc+GgaXsboNA8L0W8r+8WCgoeo6DgMRYWQrnE7dq1L0Gp3EVmZg+Gh5ORkCCttJisP0pVxO/sqFFU1Iz09AEev0WjubkYTU1nERU1ZWWTTNBoNrG9TRIp8UIOgL2PWEbKvSLez28DRUUPsb/vhfr6MuTltaO/Px0DA+lWGyDbv5WQMHYscSOJVFGRlPVH14p4mcyClJQhpKQM4erVm+jpyeQO7gDw4MFZrK76Q6frcslvAZ71SK2uEkV8PXcf+fuv4cyZJhQXN2FmJpI7APb0ZMPHZwtabReePk1BbOzYMUGFqzEaDR4p4re2NHjppRvIyurFzo631QZoQENDKRoaSq38lhFabTdUqh3RpcWOwzAGBAUtiUqkgoJWcO7cfchkB7h7txJarRlPn6Ydq6eIijr+Qsom5HC3/tgA4P8AsDFSzhIpR90xecDp7OwEwDJce3t7oh5UnoWR4idSISEhKCkpwYULFzA+Ps6lAMRGptfr0dfXJ6m0GPBcEb+xsYGLFy86tQEmJydz/VsKhYJLpLRareRDglhFfFhYGMrLy6FWq1FTU4O0tLRj/BbRxjuOs9JiV0PYFmeJFEmTaJrG+vo69x0R+QL57h1tgEJDFPGeMFL80mJ3/BZN0+jt7fVYyCFlbY0o4l977TXQNI21tTXuRcLNmzeP8VtyuZxjpNyVFgtdnxhFPOG3oqOjERQUhOrqasTHxzu1ATqOs9JiV+NOEa9SqZCfn4/8/HwsLy9z31FTEyuz6u/vh1qtdstvAZ4p4l/MZ28+M4cshqHtEikx6zL+/muC1j5X86yK+MrKO6iouIOJiVjuodTGb7EPOJGR06Aom0hBrJADYBmpnR0fUVC/l9chsrJ6kJg4gr6+dCQkjOLgQIHa2krcvcvv3+oV5NU+CUV8aOgCSkvrUFJSj9HReJCOsv19Jfb3FaipKYfBwCA83DW/xWeknkURr1DsQ6czQ6djbYBmM2u6q66+hDt3KpGa+hQazboHjBQr5CgpkaqIZ9cfX3rpBo6OKI7fMpt16Og4zm+R34llpMQfNqUo4pXKPRgMDDIy+vCDH/xvREdPYX9fidu3r6K6+hLS0gZA04TfOn548ISRYq19wuuPFAVERc0gKmoGFRU1GBpKhtFoQEdHDg4PFdjbU6Kh4TwMhuM2QMdxJuRwf332pcUq1S7y8jqQl9eBlZUArn/rxo1XuLJzjWZd8mGTKOKdM1LHh/3vEVta/MUvXsPhofxYPUVo6DxnTCQvNoxG2m1pMTs2LmtoaEh0IkX4LZqm8YMf/ABhYWFYW1vD9evXcfPmTZf8FuC8tNjVuFLEUxSF+Ph4xMfH49KlS+jv7wexAR4dHcHPzw/Nzc2CNkDH4Qs5PGGkSCLFtwHy+a0PPvgASqUSWVlZ8PPzO2btczeeKuJNJhOioqLw1a9+Ffv7+1ya5Mhv6fV67vf2pEeKrD+K4Yn8/PxQVFSEEydO4Ac/+AGCgoIwOzuLP/7xjxy/ZTAYEB8fL/i7PosiXug+cuS3CJt0/z4rmAoICEBrayu0Wq3b1Vj+IeFZFPH+/v44c+bMsf6tnp4e+Pj4QKvVws/Pz6PD5sDAAAoKCiStP5rNZoSHh+Nb3/qWoA0wPj4eBoMB2dnZUKlUAMSVFjuOFEV8UFAQzp8/j9OnT+ONN96ARqPByMgIenp6OH7LYDAgKirK6X3kWFr8Yj5/85k4ZG1tqV0mUkLrMkajAaOjiQAsaGw8a02TBt0mEc9DEc/aACcQFzfB2QAZhkZb20m0tBQhLGwOOp0JZrO00mL2+gweKeItFjkqK+8gKmoGi4uE3zLgww+/iJs3WfMiTRuRlDQMmcyCpSWSSIkTcgA2RXxi4ohbRTxFWZCYOIrExFFQ1CE6O3MREzOBR4+K0NxMbIBs/5ZGs3Hs885Ki12NO0W8RrOJwsJHKCx8hPn5MI5NGhhIB0UdobX1JGjaaL1m18moJ+uPU1PRdqXFfH6LtQGyaRKf39LrGZhM0kqLyfV5oog/OvLCxYvViI2dxMxMBJcm9fVlQqXa5vq34uLGQFHiS4v5Qw6bcXHuEynCb6WmPsWNG1fQ3p6P0NAFB37LaOW3jn8/NiGHFEbKm1PECx0qAwNXcfbsA5w588DKb7GH5K0tX1DUEUwmHWSyI0RHu+a3AFtpsZSDmaMinl9PwX8hVVdXhrq6MiQmDkOvN8Fk0iMtbUCEkMPGZTEMA5VKJcna19PTg4ODA1y8eBHx8fF2NkAhfouiqGdipMQo4r28vJCdnY3s7GzcvHkTT548gUaj4WyA/P4tobf+zkqLXQ1Zf3SWSPH5LX631O7uLiiKwsDAANRqtaiURGofGWBTxJPfydEG6MhvpaamQq/Xg2EYpKamSmKkiCJeytpaX18f9vf3cenSJSQkJHD8ltls5vgtkpSQRFKqkIN/fWISKaVSCYPBAIPBgFu3bqG1tRUKhYKzAbritwDnpcWuhiRSQop4iqIQFRWFqKgoVFRUYHBwkEuSDw4OQFEUxsfHERwcfMwGKDTPwkiR9UchGyDDMPj4449x69YtZGRkQK/Xw2g0SiotBjxXxO/t7eHy5ctISkri1psd+S2aprmOOTGlxS/m8zGfiUOW2ax1yUjxh6zLZGd34V/+5fuIixvH0FCyqHWZT0IRz/JbvcjM7MX2tg+6urRgC0bZHfK5uTB0duYgK6vb7WGLX1osjZGi7RTxISFLKClpwIULDRgfj4fRyHZLMYwBfn5r0OlM2NtTQrqQg1XEnz0rTRHf06NFdnYPvvSl9+34rTt3LqKmpgIpKYNg+7d6oVDsW38n96XFjiNFER8WNo/y8rvIy3uCn/70HxARMcPxW2yaxBoTw8IWjn3WU0aKrK0JJVJK5T5o2gSaZvkttlvKgOpqVn+9shKIrq5sZGQctwE6zrMo4vmlxZGRs4iMvIPy8hoMDyeDaPzb208gMHAZNG203kfShBzT01FYWAgTxUiROTqSobc3G5mZffjKV/6A1VV/Lk26efNlXv+Wjd9ifyfabWmx43R3u2akyBB+Kzp6CoWFD/GTn/x3hIYuoL09H62tZL2Zsa43rxz7PHlp4Vha7G5sidTx9UfHF1LkZcvHH78CgH2h1d+fJuKFVAP29k6gt7cXer3eI0aKJA2ONkCGYdDa2srxWzRNY29vT/IhwVNFfF9fH9LS0vD1r39dFL9Ffid3pcWOQxgpd0kCRVFcCevZs2fxk5/8BIGBgXj48KEofotcnyshh7PPOFtb4/Nbc3NzXFIyMMD+exQSEoKRkRFBG6DjPA9FPEVRgvxWY2MjHjx4gOjoaBgMBuzs7Ehm7ebn5z1SxPf39yMlJQXf/OY37dIkZ/wW4BkjJXb9USaTIS0tDWlpaVhaWsI///M/w9/f347fImmSEL8FuBZyOBtX9xGxAZ49exZTU1PcIbm7m/3fwODgYExOTorit55l/ZEo4mUymd16M0ncCL+VmJgImqaxvb0t+bD5Yj6b85k4ZDGMARERM4iIcM9IkTGZaFDUEV5//b+gVm9xNkD7dRkjaNrErcsQRfyFC/Wifw5RxLMCB9eHJB+fbZw40YYTJ9rw7rvfxMREHPb2vHH9+qucDdAZvwXYDptS0htXiRTLb40hPn4Mly9Xob8/DQxjQEtLIY6O5FAqd2E266w2QPeHThsjJWX90d7a58hvkTTpgw9YfisrqweZmT3o60vHiRPSGClPFPHE2vfVr/4evr5b6O3NsKZJxWhsJPwW6d/aBCCutNhxDg9l6OoSl0j5+W3g9OmHOH36IX7zmz/B6GgC1tf98Mc/fsXKb7FpUnz8cX4LcF5a7GpcKeJZfmsQKSmDdvzW/fvnAVBQKnfx9GkatFqzKG25TcjhuSI+IGANZ840ori4ETMzUVz/lo3fMiMrqwc9PZnIzRVXWsy/vuDgRcTGil9/ZFk2Cl/72u+gVm9Z+S0a9fWlqK9n+S2DwYjs7G7u739mJhLz8+EuS4sdh11/FKeIDwpawfnz93Hu3H38539+EyMjiVhYCMVvf/snUKs3uRcJUVHTAolbA3p6rkpmpNbW1jA8PIyzZ88ee2gilq6srCw7fuvu3bsAAG9vb4yPj0Oj0YgCzZ+HIt6R3zIajdyDl5+fH3Q6HbKzsyWVFpORwkiR6e3tBQB84xvfgI+PzzF+KyUlBaR/i1yLmNJix5Gy/hgeHo7y8nKUlpbivffew/DwMKampvD2229zNkCapp1KMIRKi92Nq0TKkd8iprvbt28DYO+j+fl5BAcHi3o54AkjRRTxJJEiNsDy8nLOBkj4raCgIOj1eu4+EltazL8+qYr4gYEBWCwWfP3rX4dKpTpmA3TktwBpQg4y/B4pV+uPFEUhJiYGMTExqKys5O6jsbExvPXWW275LQCcIl7KfeRKEe/j4yPIb3300UegKAphYWGSDpsv5rM5n/pD1sICy0hVVEhjpIi1jxwO+DZANrWhUVdXjrq6ciQmDoOmGYyOxlsTqV7RP8umiBd/8Nna8sHISBJOnWpBZSXLbxmNBrv+LfKAExk5wz3gEGufs9JioRGriPfyOkB2dg+ys3swMJCK9977Jnx9N1FTU4na2nKufyszswdK5f6xzzsrLXZ/fUQRfzyRCg1dQFlZHUpL6zE6mgCjkUZPTzaMxhwA7NrW3FwYwsOP2wAd53kp4vV6M/R6G79lNLJp0p07bLcUTRsxMpIgWcjx9Kl4RorMzo4KIyNJyM9/gosXqzAykmRdTdOjoyMfAQEr1qTEiNDQRe5zDEO7LC0WGtv6o+uDGeG3DAaGu4+8vXdx69ZVVFWx/JbBYERamjC/RYQc0hkpWlARz/Jb04iKmkZlZQ0GB5PBMAZ0duairY1V+R8dybC8HCRKlsEvLfZk/ZEkUnl57cjLa8fKSiCIMfHjj1/BrVssv0XTRgwNJUsqLQaAoaEkbGz4SbqP9vaUGB1NQE5OJy5fvi1YT+H4QgpoAsN0IjAwEHFxcaJ/llhrH+G3Tpw4gf7+fvz2t7+FTCbj+C2SJpG3z45zdHQEs9n83BTxfH7r8uXLdvwWKdCVy+VYX18XxdLwS4ufRRFP+K35+XnuwZ3wW6RbamBgwGNGSsoD9eHhIcbHx0HTtFMbIOmW4h/cnjcjxR8/Pz+cPn0ap0+fRk9PD/7whz8AgGh+y1NFvLP1R2IDTE1Nxe7uLvcd3b9/n2O4vL29sbW1Jeq+fV6KeD6/RWyAfH7LYDCgr6/PIyGHWEaKjMViwdTUFHQ6Ha5cuXKM30pISAApOyf8FvmdNBrNJ6KIJ/zWuXPn0N3djT/+8Y8wGAyS/t19MZ/N+dQfshiGTaSkMVLOEykfnx3k5z9Bfv4TLC8HgZjuPvroCwAsCAhYwehoAlJSBkWt5BFFfHLysOjr41v7hPkttsvp0SOW3yIdRVJKiwHbw51URXxfXwa8vPbx13/9c2xs+HHf0bVrX+TWIvn8FiCutNhxCCN14kSby++a5bdGkJg4gitXbuEXv/hrq87bAKMx18pvsWmSEL8FeMZIuVLE8/mtubkwjk16//3XAVgQGLiCmZkoJCS457fY6zN4xEgRRTzLbw0hOXkIV6/eQG9vFhiGRmPjGTx4cA4xMROgaZaVklJaDNjuo/j4UUnrj0+fpkIuP8Df/M3PsLYWyKVJhN8i/VtxcePctbgrLRYaGyPlWhEvkx0hLe0p0tKeYnfXG7/85V9gdTUQ7e15aG/Pt9oAGWRnC/NbgJgeqeNDEqmrV48nUoGBKzh37gHOnn2Aqalo7mVLd7cWwBGCglawvBwEH59tUX9fjkIOMcNXxAvVU7D8VrmV3xoBTRsRGzuBoaERnDt37hNhpPgzMjICmUyGv/u7v8PS0hLHb5lMJmg0Gq5glPBbgC2R8kQR7279kc9vbW1t4d///d+xvLyMtrY2PHnyhOvfyszMdJpIeNIj5SqRCgsLQ1lZGUpLSzE6Osolbp2dnaAoCoGBgdjc3BQt5XgWRTxN08f4LZKUVFVVobq6GqmpqaBpGjExMR4zUlIV8VNTU6AoCn/7t3/LHUoJvxUYGMgZE/n3prvSYqEh64/u1ta8vb05fmttbQ3vvvsulpaW8PjxY7S1tdmlSc7uR08YqYWFBUxNTR07QPP5rcrKSjt+q62tDTKZDIGBgTg4cL2Ozh9SWiyFkeKXFrvit0j/Fk3TiIqK8kjIQRTxkZGRov55iqIwN8dKuaQcNl/MZ3c+1Ycsi4WCyWSfSIkZo5EWlUgFBS3j/Pl7OHfuHhobz6Curhzb22q8996fWG2AZhfrMnBQxEtjW8LDZ4+VFrM2wF5kZdn4LaPRgLt3KwBYAFgglx9id1cpSpbxPBTx3t6LKCmpx4UL9VZ+y8A9ePn5rXGJG8PQokuLyXR1aV32SAnNxoYfFhfDUFpai7y8DphMhN+6hJqaSiu/ZURmZh/Hb5FkMzFRmiKe2B/dJVLh4fMoL69FaeldPHhwFg0NpdjY0ODtt78jaAN0HKHSYjFjS6TsFfEsv8WyPuvrftx3dPv2FVAU++f7+Gzj4MDLLb8F2IQcRUXNoq+NTaTY0mK1egdq9QwiI2dQUVGLoSG2f4vY7oKClrjviGHElxaTIYyUGNaOzM6OCouLYbhwoR45OR2cLOfGjZdx+zbLbxkMRqSmPuUObmJKi4VGjCKeooCYmCnExEzh4sVqPHhwFvfulWB1NQBvvfVXx+ophOZ5K+JJPcWJE44vpF6FTMb++f7+/jg6OhL1YMMvLRY7fEW8r68vfH19j/Fbjx8/xqNHjxAeHs6xSZ4yUqTEVewcHh5icXERZ86cgcFg4HqTrl27BoVCwaVJiYmJdt+RJ4yUmPVHPr915coVPHjwAA8ePMDKygr+9V//lbMB6nQ6p8nMs/RICSVSGo0GRUVFKCoqwtzcHPcdDQwMwMvLCxaLhSsWFnPQelZFvL+/P/z9/TkbYG9vL4xGI8dvxcTEcN+RlNJiMp4o4uVyOZaWllBQUACaprk0qbe3FyqVikuTYmNj7b4jo9H4iSji+fzW7u4uHjx4gKamJiwvL+MnP/kJ4uPjuTTJGb8lVFos9vqEEilHfou8bOnq6oJSqcTR0RFXdC7mPuIr4sWOp6XFL+azO5/qQ9bYWJyHjBRr7XPHSJGhKGByMhYazTr+/u9/jMFBMesyttJiaYr4YExMxKG83HUixee3FheD8dZbf4mDAy/cuXMJdXVl1jSJQXKyML8F8EuLn10Rb89v3UZ/P9u/9ehRIZqbiwFYEB8/is1NNfz8hNMkxyHrj1IYKX4i5eu7icLCFhQWtmB+PpR7cP/ggy9Dqdy1dksx8PLal1RaDJD1R2mKeJnMgrm5CKjVm/j+9/8JAwNs/xbfBsj2b9n4LQDo6nJdWiw0KyuB1kTKtSLez2+d47dmZiLw9tvfxv6+ErduXcXdu2VcmhQfP+40cRMqLXY3g4MpgqXFrA1wEKmpg9yhgPBb9+9fAHCE+Pgx7O0p4ePjnt8i18cXcoj7jE0Rz+e3pqejQJT5hN8iL1so6kh0aTEZwkilpQ2I/n3k8iMsLYVApdrG3/3dT9Hfnwmj0b6egi0774ZKZbs3SSLliSL+/HnXinj+C6mJiVj89rffwO6uCjdu3EB9ff0xG6DQeNIjNTw8LKiI5/NbW1tbHL9VW1uL2tpabr3v6EhKr53RY0U8TdMICQnhbIBjY2Mg/VtGoxF+fn4cmwTgE2WkyCgUCqytrcHb2xt//dd/jb6+PvBtgEL8FuC+tFhoxCriw8PDUVFRgbKyMoyMjOCPf/wjDg8Pcf36dTQ0NHBpkqvDJzkkPA9FvCt+q7q6GhaLRZS8w/H6pDJSpLQ4JyeHS1YqKio4fstoNOLJkycICgrirvfo6MgjIYdURTxZX1QoFPjLv/xLbsWR8FskTUpNTbXrlnJXWiw0hJFylUjx+a2LFy/i6dOn+PDDDwEA165dw4MHD7iXLc74LcBzRfzy8jLOnz8v+jMv5rM9n+pDFsMYIJMdICBgFRYLRK3LkNJiaYyUTRGvUIhbl8nO7gHD0KJLi22/k3RF/OamL3Z2fPDKK9cQErIE0r9lMrHdYcSYGBFh47dIIvVJKOJZfqsb2dnd2NxU4/btK+jq0mFsLBE/+tH/tPJbRqsM5Di/BfCFHFIZKeFEKixsAWVld1FaWmfltwycDVCp3AVFHSI8XPzfkyeKeFsi1QaVag96vQl6PWsDJP1bVVWXUV190dotxSA9vQ8MI760mIyrHilnc3johZ0dNV566SMEBq5wK47t7fkIDFzm0qSQkEXeZ1yXFju/PjaRcrX+6O29h5wcI3JyjFhb80dV1UX09GgxNpaIN974XzwboDC/BfBLi59dEc/aAKcRHT2Nioo7GBxMAcMY0NGRi9bWU1CptkFRh5L6vgYHkz1Yf7QlUhrNFsdvkXoKhqHx8cdf4Pq3aJpBSspTLpGKjXVfWkyGKOLF3kcUBSgUB9jeVuPSpRoEBPwcDNONtrY2OxugXq/ndMeA+9JiZyMmkVKr1Th58iROnjyJxcVF1NTUoK+vD6Ojo3jjjTe4/i1n/BbAMlLDw8MeK+L5hwKKopCQkICEhASO3zIajXj06BGam5uhVqu5xEnsPKsiPigoiLMBklU5fv8WP3HzRMghlrUjI5PJ4Ofnh+3tbZSVlcHf318Uv0UOCZ+EIp7Pb83MzKCurg4DAwMYGRnBD3/4Q0EboOMIlRaLvT7HRMqR3yL9W8QGSA5JKSkpon/Osyjis7KyEBYWhrCwMJw5cwbT09PcymV3dzd8fHy4ly3R0dHcYVMKI0UOm2LvI7lcjtDQUOzs7ODChQvQaDTg2wATEhI4YyJfluOutNjZeLL++GI+2/OpPWQdHHjBbNbCYpHh7bf/jCvP1Oudr8sA7EO4n98akpLEM1LOFPH8dZmlJbIuY8BHH72KW7eu4uBAgZycdhwdyUStC/JLi6UwUnxrn7f3HuLjx3Hp0m0MDLBp0uPHBXj06DTCw2e572hyMsYq5BD/EL61JV0R7+u7hbU1f4SFzeH1138Pk4m1AV67ZrMB0jSDxEQbv8X+Tq5Li4VmcjLWmkg9cPrPOPJbPT1ZuH79C7BYZHjrrb+y2gAZ6HQmaDSbTv8cTxTxJJFyTBL8/DZQVPQQRUUPMTcXzhkT+/szoFTuYm/PGzk5TwBQYNdCXY+QkEPMGI00l0ipVDtISRmyswE2Np7FgwfnrfyWETpdFyYmYj0QcnhbFfHtoq19/v5r2N5WIyhoEa+//l/cAbC3N8vKb5lhMDCIjR23O0x5ctgkiviXXnKeSMnlR0hPH0B6+gB2drzR3a3FzZtXYLHI8W//9t+s/JaR+y6djW39UQojlS2YSJF6irNn72NyMoZL3Lq6dPDx2cL2tg/y8p6I/jnPqojX69uhVq8hM/Mrx2yAd+/eRWJiIgwGA7KysjAxMSG6tJiMWEaKPyEhIdjf30dAQABee+01mEymY/wWSdz440mPlBhFPJ/f2tzchNlsxp07d2CxWPCLX/xCFL8FPF9FPJ/fIt1ShN/y8/PD+vo68vLyPnFGipQW5+TkQKPRcGkSMSZWVVVx/Vs0TSMjIwPj4+OShRyeKOLJ/eHn54dXXnkFJpOJswEGBgZyaZIjW+gJa0cYKVeJlLe3N3JycpCTk4O1tTVOBAEAv/jFL0TxW8CzKeL5vxNFUYiOjkZ0dLRd/1ZHRwdaW1sRFBSElZUV5OTkfKKMFPkMRVHIy8uDn5+foA2Q9G+RsvPJyUnJQg6y/uju39UX8/maT+0hq68vHXt7KnzlK7/F1pYv+OWZztZlbInUI8HSYmcjRhEfHLyMCxfu4fx5dl3m9u3LmJ6ORmdnHgYG0rk0KTJSmN8CjpcWixk2kdIeS6RYfqsHWVk92Nry4RK32toK1NaWQ63ehLf3tqS32kTI4akiPixsEaWl9SgpacDYWJw1TdLCaMyx8ltsUhIWNgeGEVdazB+y/ihWEa9Q7EOp3MPRkRyvvfY+trbUYLulLuHOHZbfMhiMyMjohUJhY5PclRY7G4YxWBXxzhOp8PA5VFTUoqzsLkZGElFTU4mZmSh0duZjeDhF0AboOM9TEc+3AbL8Fpu43b59FdXVl6BWb0Kp3EFioviXFnwhh9jhlxZHRc0gKmoGFRU1GBpi+7eMxhw8eXISQUFL3HcUFLTMCTmCglZE/yyy/pidLc7ap1Ltws9vHUdHXnjppY+s/z2icePGK3ZpEp/fAthEylVpsfPro10mUhQFxMZOIjZ2EhcvVuPp01TU1ZVie1uN9vYTGBtL4Jg8Vwzi81HENwA4bWcDXFpa4h5wiA3Q19cXCoUCqampon9WT0/PMyniSZp06dIlzgYoxG+RFEWqkEOqIt7X1xdhYWE4OjrCxYsXsbW1BYZhcO3aNSiVSs6Y6Mhv7e3tfSKKeIqikJSUhKSkJFy5cgV9fX24d+8e1tfX0d7ejunpae47crWi6FhaLGYI2+KYSPn5+XH81uzsLIgxsb+/H97e3vD19YWXl5ekw+azKuJJmnT16lUuTSI2wJiYGBgMBmi1WqjVasFEyt2Qw6bY+8jf3x9xcXE4OjpCaWkptra2YDKZ3PJb/MPm81TEy+VypKenIz09HTs7O+jp6UFjYyMsFgs6OjqwuLgImqah1WrtbICO41haLGacKeL5NsDJyUkucevq6oJarYavry/kcrmkw6YnivgX89mfT+0hi4gVMjL6IZNZuPJMAqjbr8sYkZIyyEukxL/VlqqIZx9wJrC9rUZS0hBOnWoFw9BobT2FlhZiA2TTJMcDhKvSYmczMJDuVhGvVm/j5Mk2nDzJ8ltPnuTj4cPTACi8+eY/IjOzFwaDEUlJQy4Pn89LEU9RFiQkjCEhYQxXrtxGX186GMaAR4+K0Nx8BsHBC1heDsbJky2ifw5hpKQr4mmrxKQLMtmRld8K49Kk99/n81tGJCaOSiotJrO8HGhVxLtmpMjIZBYkJQ1jf1+BuLhRnDjRZk2TWBsgy28ZrfzWlt1nbYfN56uIZ/mtZpw+3YyZmQi0t+ehtfUUAAo//vH/5Pq34uLGXP6OZP1RCiNF+sj4iRTLbz1FaupT6wod2y1179553Lt3ARERM1hYCENlZZXon3N4KIPJpPdYEZ+Twxr4zpx5gOnpaM6Y2N2ttfJb7MuW6OhJLpGSctgUy0iRkcsPkZ7eh7t3yxATM47c3A67F1KkniI7u/vYvzfsOrZURXyyVRFP/p4aAPwfu38mODgYFy5cwPnz5zExMYGOjg50dHQAAH7yk5+I4rfY62OeiyLe0QboyG/FxMRgdnZW0sMdUcSnpqZ6tP6Yn58PhULB8VvEBsjntwwGA8LDwzkhh5TDJlHEi11/VCgU0Ol0aGpqQkREBHJycuz4LX6a5HjQ86RHSowiPiIiwo7f6uzshMnE/u/Mz372My5NcicPMRqNHivi+feRUqm0swESfuvWrVuoqqpCQkICpqamPBIpSGGkyO+kVCpRWFgIhUJhlyYRfis4OJjjAIODgz1ipKQq4lUqFXJzc/HkyROEhoaCpmlR/Bbg2X00Pj7uMpGiKAqxsbGIjY3FxYsXMTAwAKPRyPXNvfXWW9x9xF9vFhp+afGLeTFkPpWHrM1NNZ4+TT2WSLlal1GrN0FRRwgOXpDE3jyrIj4zsxeZmTYbIMPQuHu3HHfvliEpiX3Aycrqhlx+JLq02PH6pCjiQ0KWrJwJhS984UNMTMTa8Vu2/i3772hpKfgTUcR7ebHraVoty291delw7945AEBNzUUMDaWC7d/q5WyAQmNTxIs/QDtTxIeFzaO8/C7KyuowMpIAhrHxWwEBKzg6ohAYuOSRkEPK+iM/kaJpE2ia5bfYNMmAqqordv1bGRn9oKgjXiIlrY9MiiI+MpKwhhQuXbqFqakYmEw02ttPIDBwmUuTQkLs18xclRY7G8LauUqkWH6rEzk5nVZ9v94qXAHu3i23pjdGpKUNuEyNbEKOZ1PEs/zWFKKjp1BZaeO32tvz0dpagJCQBRweyhEQsCyptJhdf6QkXR9fEZ+f3869kLKtN3/Brn8rJWUQFAXusCmmINp2fbRVEd9v/b80AdgDcPzNOEVRiIuLw9LSEjo6OlBaWoqpqSm0trba8Vs0TR/jItbW1jA0NOSRIj42NtZpIuXIb5GuKwBoaGjA7OwsaJpGUlKSy4dKx9JiMSOUSPH5LZImMQzD8VuRkZHY39+Hn5+fJCGH0CHB3fAV8QUFBRy/RWyA77//Pry9vZGVlQWDwYCEhAS7REqskAOwMVJiFPEymQzJyclcYkN4IGIDdMZvATYhh6eKeGeJlL+/P4qLi7luKYZh0NbWBgB48OABlpaW3PJbwPHSYjHDV8ST+8jRBujIb8XFxWF3dxcajcYjIYeU+4hfWnz69Gnu74sYE7u7u6FWq7nELTo6GgAEEyl3Q9YfxTBSJLk6OjpCb28vCgoKMD09zfFbiYmJnDHRsezcVWnxi/l8z6fykEWsfc6SBKF1mdbWExgcTMPmph9+9rO/E7QBOs7zVMTzbYB8fuv69Vdx8+ZVREVNYWfHBzqdJ4yUZ4p4g4F9KL10qQr9/Wz/VktLAR4+JPwW+x35+a0LJlLuxqaIvy/qn/f13UJ+/hM0NFxAWlo/IiNnwNoA+fyWEYmJI8cSN5siXgoj5VoRT1EWJCWNICmJ5bd6ezPw5MkJjI4mAgB++cu/Aunf4tsAHYccNhMThyUyUscV8X5+G5wNcHY2nGOT+vsz4O29g5iYCWxt+Uo6zD2rIv7UqcegKFj5LbZ/6/79c7h//zxiY8dB0wy0WjPU6m3BRMrdTE9Hu2Wk+OPvv4aiood4+LAISUmDCA+fg9nM8ls+PlucMTE2duLYQc8zRbwwI0XmOL+Vjfb2PExOsgnM229/h0uTXPFb9qXF4hXxNvujLZEKClrB+fP3ce6c8AupuLgxbG5qoNd7IuQw8g6yWwDaAJx2cX1sIkVSFcJvGY1Gjt9KSkoCTdPIysqCt7c3l1hIebgjivgrV66I+udDQkJw/vx5PHnyBOHh4QgLC+OKTzUaDZcmkcJWx9/Jkx4pV4mUl5cXtFottFotx2+RdSsAeO+99wRtgELzvBTxYWFhKC8v59IkPr8VEBCAuLi4/78wUuR38vf3R2lpKSiKsrMBCvFbXl5eHjFSUhXxkZGRiIiIQFdXF0JDQxEaGsrxW0FBQdx9FBwcLPg7SVXEu0uk+PzW6uoqTCYTOjs7sbi4CIqi8Mc//pHjtxzTJKHr45cWixnHRIrPb/H7t9rb29Ha2oqQkBDEx8d7zEh5qoivrKyETCYT5LeILCclJQUymcyjPrIX8/mYT+Uhi2FoKyM15/aflcsPkZHRh8nJaAwOpqC8vBb9/RlWG2C5y3WZT0oRb89vxcFopNHRkQcA+OijV3lp0ozLt/22w6b4B1aSSPEV8awNsAfZ2T3Y2lLDbCb8ViXu3i1HUtIwZmYikJAwIknIYVPEi19bI4nUyZOPkZb2FCUl9Rgbi4fRSNvxWyQpCQ+fF11a7DhSFPEKxT70ejOWlkIwOpqIc+ca0N+fgerqyw5pUp8dvwW4Li12NoeHcp61TziRioiYQ0VFDcrKajEykmQ9uLP/w3X79mVMTsYcswEKzfNSxLP8lhEGgxFra35c4nbr1lVUVV1CWtoAJiejERcnrbSYCDnEMlIASaQ0KCj4GBkZfaisrMHgYDIYxoDOzhy0tZ1EcPAi9HqWTQoOXsbOjjf6+jLclhY7DsPQVkW8+0RKpdpFXl4HtrZ8MTkZh8LCZgwMpOPjj1+xS5NYfsv+Xp6ZiXJaWuxsjo7464/HEynHF1IDA2w9RW8v+1BXX1+GxcVQty+kAPvSYvtpgLNDllAi5Y7fysrKwtjYGKKjoyUxUkQRr9VqRX9meHgYm5ubuHLlCrKzszkbIEm4Hj58iIiICI5N8vPz80jIQa4vICBAVCLl6+uLgoICHB0d4c6dO8jPz8fTp085GyBJkxITE48lJbOzs89dEe/IbxGNt9lsBgA0Nzdjc3NTME1yHGdCDldDGCm+Ip5vA5ydneWSEsJvZWdnY2xsDJGRkR4JOaQo4kdHRzlFvF6vt0uTCL8VGxvLsUlqtVp0abHjSFHEBwQE4MyZM/Dy8kJ1dTX0ej0GBwfR09MDHx8faLVa0DR9jN8CnJcWuxp3inhHfou81CDrxE+ePMHh4SGys7Nd8lvA81PEO/JbpH/LbDbD19cXOp0Ow8PDkoUcL+bzMZ+6Q5aNkaoW/RmSSKWkDKG4uBnFxc3W8ky93bpMZmavVXc8CJnsiMdIuS4t5o9NEe/+4ENRQFzcOEJCFtDenof09F7IZBY8fnwKjx4RfotNk4QON0QR71ha7GrcKeLV6i2cOtWKU6dasbgYAoah0d6ei60tDSYmVLh27TXQNOOW3/JUEW80GuxKi1l+axQJCaPW/i22W+rhwyI0NZ1BZOQ0goKWJDNSz6qILylpQElJA+bmwrg06f33X4e39w6ysrphMDBISBgFRVlgsz9KY6TErj/KZBYkJw8hOnoKJpMOSUlPQVFwsAGy/Vtq9daxz3umiLf1kQmNv/86iotZfmt2NhJGIyun2N5WW/uTXgJNGxEXN+7y++eXFktjpOwV8TLZEdLSniIt7Sl2d73R05MFo9GAe/cu4N69EquufUlyabFNEV8v+T6KixvDxYt3UFl5B1NT0Vya1N2thVq9yfVvRUdPgaL49kdpjBSriHd/H8nlbD1FUtIw+vv/N2JixmCxyATrKYS4R2elxUJcFhl3iZQjv0UelHd3d7Gzs4Pq6mouTXK1dvW8FPGO/BYx3dXU1KC2thZJSUkIDAyUXFoslZHiX19MTAxeeuklWCwWjI6OcmkSYY0Id0NW2zzpI5OiiFcoFNDr9cjMzMQPfvADTuZRVVWF6upql/wWub7nwUjxJyIiApWVlSgvL8fw8DAnzDg4OICPjw/q6upgMBjcHtrJ+mNKSookRbxjabGjDdCR30pPT0dgYKDHjJRURbzJZEJkZCRee+01HB0dcWlSZ2cn2traEBwczK3uBgUFAfCMkZKiiFepVMjLywNN0/jBD36AoKAgbG1t4eOPP7bjt1JSUgQTt+etiOfzW/yy89bWVhwdHUli7V7M52c+dYcshjFIZqRIIlVSYkuk2PJMsi4TC6ORRleXDmazHr6+G8jO7oLJpENmpvjSYvb6WLYpKcl5j5TjdHXpYLHIUVJSj8jIWTsb4N27FVyaRNNG7tAitrSYP+ThTqwiPiRkESUl9djY8IXRmAOdzoTe3ixOOmLr3zrOuJHSYmmMFLv+ePKksCJeoWAfMLXaLmxuqmE268AwBvT0aAFYUFdXCrZ/q88lvwU8P0V8ePg8ystrUVp6F6OjiWAYNnHr7MxDQMAKdDozGEYvqbSYXB+riBe/ttbVlY2jIy+UldUhOnrKagNkv6Pbt6+guppN3AwGI9LT++HldYCVFVbI4a60mD/kPmIV8Ssu/1mKAiIjZxAZOYPDQzmePDmBtLR+MAyNJ09OIChoibNKCmnCBwdTBUuLXQ1JpHJzhRMpb+9djt9aXfXnuqUYJgeABU1NxTAYGKSlDbhNtDxRxNsSKXb9kaKAmJgpxMRMobKyGoODqTAaDXjyJB+PH7P8ll7PgGFoSaXF7PXRHiniDw8VKC+/i7i4cesLKfY7IvUUji+kXAs5hLks8lbbFSNFhvBbcXFx8PLywuPHjxEXF+fUBug4zkqLXY27REqtVuPUqVM4deoUFhcXOTZpaIj9b397ezsODg7c8luA9B4pwJZIEUU86dZKTEzE5cuXOX6rubkZTU1NiIyMhF6vh9Fo9IiR8kQRv7+/j4qKCiQmJmJubo473BB+i/RvkUJfsaXFQtcnRhEvk8mQkpKClJQUqNVq7t4h/FZMTAzHbwkdxp2VFrsad+uPhN/iJ27EBggAXV1dUCgUgmmS43jKSPEV8Y78FkmTGhoa0NDQgLi4ONA0DaPR6JGQQ6oivr+/H3t7e6ioqEBycjKmpqa4lJTYAHU6HWiaRnR0NCiKElVaLDRk/dFdIkX4rczMTNy5cwcPHz6UdNh8MZ+f+VQdsiwWijsk+PltiP4cSaQyM49b+4gNMDZ2Apcu2dZlnjw5gaMjOcbGEtDYeEbQBug4nirijUaDXWkx3wa4tBTMPeBcv/4abt58CVlZPbBYAKmHBE8V8d3dWmRnd+PVV6/j4OAm+vvZ/q2WlkI8fFiMiIgZqzHRxLFrYkqLHYco4sWsP/r6bqGg4DHS0gbw05/+dyQmjmB+PgwffMC3ATJITBwBRdn/XdgYKamKeINTRTyxASYlDVv5rUwwDI3m5tOwWGSYno5CS0uB1QbonN8C7EuLn0URz9oACb8VYde/5e29A622y3ofSTsk2IQczaI/QxTxmZm9eP31P3L8DsMYcP/+edy/f8HKbxmh1XZxsgVySBAr5AAgydoXELCGM2caodWa8JOf/A/Exo5jfDwevb3ZVn6L7d+KiTnObzkrLXY3RuNxRooMy2/1Iz29Hzs7KnR3s8bEhgb2ze/iYgja23OP1VMIDfmOc3I6Ja8/8hXx7Aupezh37p7gCymdzoyjI8B5abEwlzU7OyuJkQLYRKqrqwvp6en42te+JmgDTEpK4vq3yJqV0WiESqWSdEiQoogPCQlBaWkpTpw4gR/96EeIjIzkDjl+fn6cMdEZuyJUWuxuXCVSxAao0+k4foskbgC49EQMv/W8FPHh4eEoLy+369/q6upCR0cHAgICoNfrYbFYJB82pTJSAHvA7+7uRlpaGr7xjW/Y8Vu3b99GdXU10tLSQNM00tPTuUO2J4yUWEU8RVGIjIxEZGQkTp8+jTfffBOhoaEcnxQUFMSlSUL8Frm+56mI9/b2Rm5uLnJzczl+y2g04ubNmwAAjUaD3t5eUfwWv7TYk/XHpKQkUBSFmJgYxMTEcPwWsSU+fvyYMxYeHR1JZqQ8VcT39PRILi1+MZ+f+VQdssbG4rG6GojS0jrRn2EZKfaQoFS6TjfIukxmZh9+85s/wcRELPz91zgboLt1GU8U8YuL7PpjebmwIj44eAkXLjTg/PkGjI/HgWEM6OrSYmfHB3L5AR4+LLKmSa75LeD5KOJZfqsb2dnddvxWTU0lamvZxC0zsxt9fekoKBBfWsxeH21VxEu19lnw6qvX4O+/jtHRePBtgP7+q7z+rXkAwMRELJaXg3H2rDghB0AU8VpRiniW3zJBrzfhvfe+jpGRRCgUe6iquozq6otISxsATTNITz/ObwHOS4tdDUmknCniIyJmUVlZg/LyWgwPJ3Erjvv7Ssjl+2hvzxPFbwF8Rkr8+qMtkWLvI9YGaEROjhFra/4wmfQwGg24deslVFVdRnp6PzIzu9HTk4n8fPGlxYBNyCFFEW82sw9AX/ziBwgIWLPaAGl0duaire0UgoMXQbqlyIFKTGmx47A9UjpRiniVagd5ee3Iy2vHb3/7NQwNJePwUO5QT8EgJeU4vwVIO2yScZVIHX8hlQaGodHWdgKHh17w8tpHd3e2kxdSDXA8ZBGRghRGamhoyC6RErIBMgyDDz/8EDdv3kRmZiays7PR09MDg8EgmZGSqognDNKXv/xlBAQEoL+/H0aj0Sm/BYgrLXYcPiPlbv2R8FsFBQX43e9+h6dPn2Jra4vjt0iaJMRvAbZESur6o7NEitgAk5OT7YyJTU1NsFgsUCgUGBoa4vqK3A05JDyLIl6I3zKZTOjr64NKpeJWRLu6uqDVaj0SckhZf+zuZv/b+vrrryMgIOCYDZDwWzqdDj4+PgDElRY7Dn/90V0iRfit4uJi/P73v8fAwABWVlbw+9//nuO3DAYDYmJiBO8jodJid7O5uek0kXLGb9XVsc+HCoUCk5OTCAgIcMtvAZ7dR+4U8S/mxXyqDlnE2ieUSDmbvj7xjBSZzU01hoeTUVDwCJWVNS7WZYxISRniDhJiSosdxx0jRYaigPj4ccTHj0OrNeGdd/4M4eFzePy4AI8eERsg27/l73/chEhKi6Uq4o1Gg1NFPJ/fWlhg+S2TicatWy8DABYXgzE4mIykpGG3yR6/tFiqIp6fSCUmjiIxcRSXL99CX18GGMaA5uZiNDWdRVTUFGiawcxMhKTSYsBzRfzQUApOnGjDpUtVmJsLP5Ymkf6thIQxLnETU1rsODZGyvX1yWQWpKQMISVlCDk57XjnnT9DUNCyA79lhE7XJchvOSstdjdGo3NFvL//GoqLm3D6dBNmZiK5A2BvL6vdXV/XYHw8DrGxrvktwFZa/KyK+LS0AaSlDWB31xvd3Wzi1tBQgoaGEsTHj4KmGUxNRXok5BDLSJHZ3fXG0FAKcnI6ceXKTUxNxXBpErEBktXdqKgp7vcmQo5PQhHPvpBi6ymGhxPwzjt/Bj+/dRcvpBrA57JIj1R6erpkRspZIhUSEoKSkhJcuHAB4+PjXFJCuK+dnR3MzMyIgtOfRRHPLy0mD+ebm5tc4kb4reTkZNA0jcnJyU+UkSKzt7eHoaEh0DSNl19+GaOjo1z/VmdnJ8dvGQwGu7U7d6XFQiPW2qdUKqHX66HX6zE8PIx33nkHKpXKqQ3QcT4JRbwzfqu9vR0Ae+8uLi6Kkq7wS4ul3kf8RIrPb5EXCXx+i6ZpTExMSD4kEEV8WVmZ6M8cHBxgZGQEer0eL7/8sih+i/xOYoUcZMRa+wi/lZeXh6GhIbz77rtQKBSi+S1yH32SivgX8/mcT80ha3/fC2azDkrlHsxmnah1GcBWWpyYKK5HCjiuiOevy0xMxHJpkm1dxoSEhFFJpcWAIyMlXhFvNuuhUOzhO9/5D04wwTA0amsrUFtbjuTkIbD9WzaeTExpseNsbflgYCBNlCI+NHQRpaX1KClpwL/+699gfd0fY2MJGBjIgJ/fGmdMdGaE9EwR7zyRUigOoNN1Qafrwuamr5XfolFdfQmABRrNBgYG0pCR0SuYJgldn1RFPCktJt95ePgcKipqUVZ2FyMjiZzooKOD5bf0egaJicOSSosBeyGHOwMcf3p6tPDy2sef//mvsL+vtNoAady+fRXV1ZesiRvht9gkiZQWS5FDkPXHvDzXiniKAqKiZhAVNYOKihr84hd/jZWVADx9mobe3mwEBS1xVklnCvPnrYj39t5Fbm4ncnM7sboaACLLuXHjZQAW+PmtY3Q0AWlpT0WlbZ4wUt3dNmsfy29NIibGVk9B1psfPy5EaOg8J6YZHk7ChQsNkl9aSFXE9/dnQiY7xF/8xS+xs6OCrX+L/0KqFykpO5DJ2DfKjomUmNnb20Nvb69bax9FUYiPj0d8fDwuXbqEX/7yl1heXkZPTw+6urrc8luAeyGH0MzMzDhNpHx9fTl+a2FhgXtQvnbtGgCWy5mZmUFiYqIohuRZFfF8foufJhF+Kyoqiku3PBVySFXEDw4OgqIo/PVf/zU2Nze5NIlvAzQYDIiPj+euRUxpseOIVcTz+a2rV6/iV7/6lV1aGhMTA4PBwNkAhcaTPrL5+XmniZS/vz+XJpH+LcJvURQFPz8/LC8vw9fXV9Tf17Mq4h3TJJK4EX4rPj6eu4+klBbzr0+qIn5kZIS7j9bX1zkbIJ/fMhgMiIqK4r6jsbExjxTxnqw/vpjP13xqDln9/RnY3/eGj8+Ow7oMW54p9PBGSosLC6UzUkKKeNYGOIG4uAlculTFrcu0tp5CS0sRAAu2t1VYW/MXJZbglxaLnYMDL3R32xIppRI4ebIVJ0+2YnExmHvA+fDD13Dzpi1xMxqllRYDninil5eDMD8fgfLyGhQUtKCvLx0MY8CjR4Vobib8ltHKb7FcnZjSYqGxWftcJ1K+vpsoKGhBQUELWlpOoarqCo6OZHj/fT6/ZURi4ugxfgtwXlrs/vpoayJlv/7I2gCHkZw8jCtXblr5LQOams6gsZEtYj48lGFzUw1f3+NpkuNMTrKMVHFxk+hrc1TEq1S7OH2atQHOzERwaVJfXyZUqm1kZ3fBYGC4REqKkKO7W/r649qaH+bmIlBSUoeCgkfo6WHZpHv3zuPePZbfMhhYfouIIPiJ1CehiA8IWMXZs404c6YRLS0FqK6+jL09JX7/+6/Dx2eLswHGxEwKHmyESovFDMMYBBMpufwIGRn9yMhg+a2urmwwjAF1dWUAyqz/zAF2d71FSVeeVRGvVm9Drd7m1VPEci8S2BdSP4JOlwuDwcAxUmlpaaJ/lhRGiszW1hbm5uZw7tw5FBQUHOO3SJrk+KDkmEiJGbHWvtDQUJSWlqKkpAQPHz5ETU0Ntre38e6778LPz4+zATp7sCSM1PNSxPP5rY2NDY7fqq6uBkVRsFgs8PHxwf7+vqg1OX5psdhxVMT7+vqioqLCrn+L9IIFBARwSYmnh829vT1J99He3h7m5+dx+vRpnDp16pgNUIjfAtyXFguNGGsfRVGIiopCVFQUKioq0NzcjLt372JzcxO//vWvRfFbQqXFYq9PKJFSqVQcv7WyssJ9Rzdu3ODuI39/fxweHrrltwD70mKxQxIpwkj5+/sjJiYGFy9exNOnT8EwzDF+i9xHUhOp/v5+7OzsSDpAv5jP33xqDlkMQ8PPbw1///c/xvS0TXfsal2GHBKkpDcLCyGYmopxq4jnr8tsbfngn//5ezg6kqGx8RwaG89abYAMsrK6nSrMhUqL3U1/f5rTRCokZAklJQ24cKEB4+O2bin27b4FUVFTmJsL4wQb7uZZFfFeXgfQaruh1XZjc1PNJW41NRdRW1thTdyM0Gg2JJUWA/brj1KsfSMjSfD13cD/+B9v2n1HnZ251jSJTdzCwha4z5DSYinpzfJykDWRcq2IVyr3QdMm0LQJa2sa/Pzn/w2Hh164d68EDx6c4/VvsTZAoXneivjIyFlERt5BeXkNhoeTuTXQ9vYTACyIjp7EykogQkKO2wCFr4+2KuLFM1L89UeW32JtgGtr/lyadPPmS1z/FrmP2ETqI9E/xxNFPEWxRds+Plv4h3/4EZdKdnTkorX1FGcDZPmtFe5zJJGScthcXfXHyEgizp93nUipVDvIz29Hfn47lpYC8atf/QX29rxx924F7t274PaFFOCZIn5wkCji7f/d4L+QuniRvJD6OlpbW9HS0gIAiImJwdbWlmhgnGEYBAUFSWKk+ImUO34rKysLNE3Dx8fHIyGHVEU8RVGYnZ2Ft7c3/uEf/oFbu3r06BGam5sRGRnJcTf8FSZPGSkxiZRGo0FhYSEKCwsxPz+P//iP/8Du7i7u3LmDhoYGt/wW4FmPlLNEypHfIv1bxAZIimzFHgCBZ19/JDZAxzSJz28ZDAaoVCqPhBxSFfEymQxLS0tQKpX4/ve/zx0mCL9FbIBarZbjtwAbI+WJIt5dIhUYGIizZ8/izJkzmJ6exnvvvYetrS1UVVXh3r17nA3QGb8FeK6IX1lZQUlJid3/XS6XIyMjAxkZGdjZ2eFettTV1aGuro4Talgs4l/Gk9JiKYr4F/P5m0/FIYufSMnlFrvyTHZdhnZYl2G7paSUFpPxRBE/Px+G7W1fvPbaB4iNHefSpOvXX8XNm1eRldUDmmaQnGzjt8SUFju7PneJFMtvjSE+fgyXL1fh1q3L6OjIx+xsJH7xi/9m5bfYNMnZmuKzKOKFEilf3y2cOvUYp049tvJbBjAMjWvXvgSZ7BAUdQQfny0cHVGiUkcbIyX+4MNXxMvlR0hMHEFi4giuXLlt5bdoNDUVo7GR8FtG6PVmkNJi6UIO5z1SQrO2FoDtbV+88sp1REdPcmmSjd9i06T4eBu/xU+knrcinuW3BpGSMoirV2/i9u1L6OzMw9RUDP75n//eagNkoNWaORug4wiVFrsbkmwKJVL+/ms4c6YJxcUsv2U0GmA2s/yWXL4PijpCYOAKLBaI+nnPqohXKveRnj6A9PQB7Ox4c4lbQ0MpGhpKrfyWEVptN5dIiSktJsO+IKEkHcx2d32wtaXBlSsfIypq5tgLKfIiISpqmvuOWCGH3gNFvAEq1bbL9Ucvr0NkZfUiK6sR29vXUVVVBYZhMDk5iR/96EdISkri0iRvb2/BP8MTRsqVIt6R3yJsEnmjDUBSQe2zKuJVKhW0Wi20Wq2dDfDOnTuoqanhErfMzEwQIYeY0mIyRBEvJb05OjrC1tYWLl68iIiICJD+rc7OTs4GSNO03ffEP2x6ooh3lUgplUoueVhfX0dNTQ1MJhMmJyfxwx/+0C2/BeC5K+KJDbC8vBxDQ0N2/BaRLcTExIj+OZ4wUvz1R41Gw/FbxAbIMAxu3rxpx2+lpaXB0z4yKdY+iqKgVCqxubmJsrIyhIeHg9gSW1tbERISwv2dBgYGcp/jJ1LPWxGvUqmQn5+P/Px8LC8v4+7du+jq6sLExATeeOMNZGZmcvyWs4Okp4r4F/P5m0/FIctsFk6k5PJDZGT0ISOjD9vbKnR3a8EwtLU8k+2x0GrNotdlnociXqnct1uXMRoN6OrSwWRimR7ygLO0FCxZyGFTxLtnpMh4eR1gfj4c4eGz+Pa33+ZsgLW1lXZpUlaWvRDDkx4poog/d861Ip7lt+pQUlKP4eFEvPfenwAAfve7b1j5LdYGGB7u/HBMFPGktFjMOFPEKxT70OnM0OnM2Ngg/JYB1dWXcefORVgsMuh0JhwceInitzxlpGyK+G54e++ioqIGZWW1GBlJAsPQMJv16OjIR0DACscmLS6GenDYlK6IVyr3sLQUgpCQBXzrW2/DbGbTpFu3rnJpksFgRFqajd8C+D1S4g+bU1PRWFwMRVGRc0U8n9+qrKzBwEAq/uu/vgIA+M1v/hTBwYtcmuSKL/JEEd/dLWztU6l2kZvbgdzcDqysBHD9WzduvILbt6/g8NALOh2DoyO5qHVBfmmxNEU8m0jpdF3w8dk59kKqre0EWlrsX0jNzYVhc1MjKa3d3VWitzcTBkOn3d+582mCj48c6+vrCAoKwp/8yZ9wD4HXr1+3S5OSk5PtHl48YaTEKOL5/Nbly5fR29uLDz/8EADw9ttvC9oAheZZeqQcfye+DdCR31IoFNjf34dOp4PFYhF9UHiW9Ue9Xg9fX18kJSUdswE2NjYiKioKBoMBOp0Os7OzkoUc+/v76OnpcctI8cfPzw/b29sICAjA1772NZhMJjt+S6vVgqZpO34L8KyPbG5uzm0iJZPJkJqaitTUVOzu7qKnpwc3brBrt7/+9a85G6Arfgs4XlosZpwlUnwb4MzMDFfk3dPTA5VKhZ2dHej1+mcScoj9DEVRMBgM8PPzO2YDrK+vR319PcdvabVazM7OCiZSroYwUtnZ2aIZqaCgIOzv70Oj0eArX/kKTCYTzGYzzGYzfH19ucSNz28B0g+bL+bzO5+KQxbDGBAZOe0ykfLx2UF+/hPk5z/B8nIgrl9/FaOjCejq0qGvLwMZGX0wGIxceabQPIsink2kbIp4YX7LgMePT+HRoyIolbtQKncREjIv+mcRRbyUB2pbInXHzga4uBgCYkz88MMv4ubNPS5xS0wcAsMYJAs5yNqaWEU8RVmwu+uNw0MvfPWrv8XhoRcYhsajR0Vobj6DyMhpkP4tjcZ26HVXWuz8+twr4jWaTRQWtqCwsAXz82H4+OOXMD4eD7NZj4GBNGRldcNgYJCQIMxvAcKlxe6GVcQfT6RYfmsIyclDVn4rCwxDo7HxDB48OAeVagtK5a4kEyERcniqiA8IWEdxMctvzc5GwmhkD4CE39Jqu0DTRmuqaxBVWswfhiE9UuLWH2WyI1AUcHjohS996Q84OFDCaDTg3r0LuHevBHFxYyD9W/yVwJ0dlpHKy5OqiCeJlPP1x8DAVZw9+wBnzjzA9HQ0bt++hImJeJjNNAYHU7n15uhoYX4LOF5aLGZIIuWoiHf9QqoMvr6bUCh2ER8/KvpnEUW8+PtoC2trjRgeHsb58+cREhKCCxcu4Pz585iYmOAAdZPJBI1Gwz3gkBRFTGkxf6Qq4r28vKBSqXB4eIhXXnkF+/v74NsA+Ykb/yHOXWmxq+tzl0jx+a3R0VHU1NRgamoKZrMZo6OjnA3Q1UPvsyri+YmUM36rqqoK1dXV0Gg08PLykrRC5QkjxU+kSJpE+C0izGhvb0dgYCD3HYWEhIAIOaSklFLX1ry9vREQEIDDw0NcunQJBwcHdvwWP03i3y9ihRxC1+cqkeLzW6Rbqq6uDjMzM1wSKGQDdBxPFfEMwxxLpPg2wJWVFe5Fwo0bN3D79m34+flBLpdLYjafZf2xoKCAKzvn81ttbW1oaWlBaGgoDAYD9Ho9AgIC4ImQ48V8Puf/9oeshYVQTE3FoLLSNSPFn8DAVaysBCI5eRAlJQ12umNSnum4LgM8qyLe+cHHti7D8lsdHbmora0AQOGf/ul/WPktI7KyepzyWwD7cMcvLRYzzhTxISGLKCmpx4UL9VY2iTUmMowBPj5b2N5WIze3XfTPIYyUu9/h+PWxiVR6+gBksiNotV3Y3FRzadKdOxdRU1OBlJRB0DSDzMxeXiIl/rDpiSI+NPT/x95/Bsdx3mnf6NUTgMEg55xzmmYmQYIZzFSytLK1trz22uvHfnb33ed931N1qp4vp07V+XCqjmRZlmyvLGvlIFvJlCgxgzmTIEigB8Ag55xzDnM+DO8bPT0903c3QK93PVeVPtgixJ5BA9P3/39dv2sQU1OBSE5uw969N+Ho38pHZeUqDZDnrYiIGHL6OkGwaEDEZyhupBz5Lcd2ZnIyEE+ebMSNG/sBcPjZz/4vpvwWIAZyqEfEizebHAfExPQhJqYPhw5dQUtLKrWBPn68BYGBE5icDFL1fXJkpNQj4on9MTe3Dnr9CjZsqMT4eBDdJp079xzt37JYrMjMbBQBOdivb2wsGO3tKdi3jw0R79i49WBuzg+Jie0oLr4Lq9WCJ08249Gj7QgPH6LfU+lB1FNpsTu5y0iJJR1IVVRswu3buwFweOut/+spLMfqcSAFuJYWs6iqygFnET8IcRxHH3COHj2KxsZGWK1WlJWV4cGDBwgLC8PIyAgOHDjA/PesFRFPDkzbtm3D8PAwfXCX5rdSU1M1ATkmJyfR2trKTO0jNMDl5WXExcWhqKgIVqsV9+/fd8pvFRYWumR5yGFzvRHx0vxWRUUF7t+/DwD4+c9/jtzcXPA8j+TkZI+vUUtGSs7+KM5vnThxwiW/FRUVhYGBAVX30VoR8Zs2bYLRaHTq36qurkZdXR21iFosFiQmJjKXFotFDgmsiHidTofMzExcv34dUVFR2LFjB8Q0QHf5LUBbjxSxP3p6z0NCQrBnzx7s3r0bPT09FAUPAO+++y7t34qLi1O8j9YDES/Ob83OztKN29WrV3H16lXEx8erBnJ49berv/pDliBYwHErKChgtxutbqSuSsozHbhjObuM2TwNm42ttFgsgohPTWWj9pnNszAaFwFweO21P6KnJx5WqwVfffUSzp07KZvfApRLi+VEsi2eNlLO+a0LaGjIQmnpIczO+uH69YOw2fLpNikw0P1WSysivqEhC9u2OW+k/P1nsH17GbZvL8PQUATtlvrii5fh4zMPg2ERwcGjiIpSc9jksRZEfGpqG1JT23D8+HnU1Tn6twgNMC6uGxaLFQUF1TCZ5lBTU6AayLFqf2RDxAcGTiIgYBoAh29843P09sY59W+RbVJSUqfTxm101HNpsZzsdscDv2MjJW9/1OlWkJHRjIyMZszP+6C2NhfXrx8AYMe1awfR0JAF0r/lKfMjLS1m0epGyhkRHxw8geLiO9i16w56e2NpNqm2Ng9+fjPQ65cQFDSG2Fh2IIc2RPxqaXFWVgOyshowN+cLm81BA7x+/QCuX3fkt3heePo7aIG5tFgsMiTJzGSzP4aGjiE0dAQAh5Mnv0JfXyxqaggNcIpu3GJinAdS4+OktFgdIl4QJpGQkO2WeGYwGJCbm4vc3FzMzMygpqYGt245gDjXrl1Da2urYn4LWF9EfHh4ON0mdXR0gPRvkYc6nU6HwMBA1UAOtRkp8UaKbJPk8lvp6ek0v6XX61FdXa0KyAE4HqjVUPsiIyNp/9jhw4cxMDDgkt/ied4F6b6WjJQnRLw0v1VVVYW7dx0H/Bs3btDtjZQGKNV6IeI5jqMbt0OHDtH8liAIePz4MUJDQ8FxHAICAlRnpNTeR4ODg+jt7cXhw4cpDXB8fJxuk+TyWzqdTjWQAwDNOLLYHwl8YmxsDOXl5di3bx8GBwcV81sAO5BD7vo8baT8/Pyc8lsETANA1WHTq79d/VUfsux2DlVV6jNSqxupVWqfgwZYj5wch12GbG2IXSYychDz8yZVWywC5Ni+XR0inpQWk8D83r030NmZCNK/VVXlwK2TB5zo6D5YrY7DpppDglpEvMGwhKysBpw58xxyc21ISWmHgwZ4GFeulCA1tRU8L9DsmfNr0oKIV7Y/RkQM4eDBazhw4Dra25Pw6NFW2GyOiezbb/+fTPktT0AOT5JDxBuNiygsrEZhIclvObqlLl48hkuXjiAmphezs2ZVBbViRDxrRspxfY6NVEFBDQoLa1BScgWtrakUmPHkyWaEhIzS9yg8fFh2I6Wk7u54jIyEY9euO0x/3td3AYWFVbh8+TCysuqRlNQJQeBx/vxJyTapwSXL46m02J2UEPEcB8TF9SIurheHD5eiuTkd5eVb0NDgeID8xS/+lW6TPGWf5EqLWUTsj+J7wmSax6ZNFdi0qQJjYyEgxMQzZ57H+fPHER/fjenpAFXDpbUi4jdtqgDHVUgGUlvx8GERIiMHQMrOg4MnKJBDzWGzry8Gg4P+OH6czb5nNpuxefNm3Lp1C2lpaUhISKD5rfPnz9OAujS/5XhN1nVHxHMch+TkZCQnJ+PYsWOor6/HkydP0NLiyIW+9957TPktcn1qM1JyGylxfmtwcJA+KH/xxRfw8fFBQkICJicnVT0QEvtjQUGBJkT8jh07wHGcEw2Q5Lfi4uIoMdHf31/TYVMtIj4wMBA7duzAgwcPkJSUhPj4eFkaYGJiostBby2IeHcHfLn8VkVFBTo6OgA4MlzkPZJuk6RyB+RQ+hrpRio4ONiJBkiQ+bW1tfDz80NSUpLiRkoq8WFTTY8UGV7s3r0bOp1ONr+VnJwMi8WCvLw8mEwmupFSM1RRi4gPDQ3Fnj17UFFRgdjYWFVADq/+dvVXfchqb1/dSLFqcdGguJHy85vDli2PsWXLY4yOhoJQ5QDg1KlXaLdUenqLR7uMtLSYRUND4S6lxY5tUieSkjpx9OgFNDZmwWq1oKxsOx482ImoqH5MTAQiMbHD4zZJqrUg4jdteoKMjGYRDdCxTfryy288/W/WwmIRkJrairk509ONFDuQAxDbH5UR8RxnR0pKO9raUgHYcfz4OTQ2ZuH+/Z2i/JaDBijObwEO3LYWRHx1teeNlCO/9QA7djzAwEAkrFYeDx9uBwB89dWLaGx09G8lJ3fAXX4LcC0tZtHqRmoVEe+gAbYgPb0FJ06cQ22to3/rzp3duH17L+LjuzA6GoLExHa3Gyk5aUXEz8z4Y/PmJ8jKasDOnQ4aIDkA1tXlPs1vVYPnrUhI6MT8PFtpsdz1sSLidboVZGY2orc3Bg0N2SgpKUVTUyZu3NiPGzf2P6UBWpGXV+OyQVotLVaHiCc9Uu42UiEhY9iz5zZ2776Nnh5HPcXjx5sBAOfOnURbWwp4XkBcXI/HrdF6IeLdDaSuXi3B1asHkZLShuHhcMTHd6oqLbZaeeh0y8jPZ9/MkY3U8ePHkZubS2mAZJskzm/xPI+YmBj64MrzvOqMFCsi3mAwID8/H2NjY5R62NzcTPNbYhqg9AHTU2mxOxH7o6eNVGRkJA4ePIgDBw6gvb0dgiDAanXcC5cuXUJvby8sFositEBcWswqOUS80WhEYWEhCgsLMTU1RSEnJL+VmZmJ/v5+xMbGqiotJocELfbHw4cPo6CgACUlJWhtbYWYBhgSEkI3JeHh4c8sIyWWr68vNmzYgLm5OXR0dGDHjh1obm5WzG8Bq6XF64mIJ0j8uLg4HDp0iNYK2GyO3/03b97E6OioYn4LcC4tZpXcRspdfuvMmTN02NLb24uoqChVGSmtiPjx8XFVQA6v/rb1V33Islp5+PjMO22klNTQkK2YkRIrNHQUW7Y8ws2be1BYaIWv7zxqavIV7TKO69OCiLd4RMQ78lu1yM2txcyMH2pq8vHo0TbMzZnR0ZGMP/zhdTj6tzyj30lp8Xog4h00wOvYv/8GOjoSIQj80+C8wyoZETGourR4ZGRtiPitW8uxdWs5pqcJDdCC0tKjuHz58NP8loCcnHoYjYs0I5Wby35IaGx030cmp6ioQezadQf37+9ATk4NTKYF1NTko6LCc34LcGxv5EqLPUkJEe/jswCed/ydk5OBqKoqxOPHmzEzE4DZWTM++eRbsFisyMrynN+SlhazX59zabGYBnjo0GW0tDj6twRhAx4/3orQ0BFERg5qAHIErwkRv2vXPezadQ/j48F0m3T27HO4cIFs3ARkZjZBr18WZaTY76Pm5nRm+yPHAfHxPYiIGMbjx5uQkdEAH59FSX5LeJrfcj0kPwtEvNxA6smTTZicDML0tD9OnXqZaSDlXFpsArCP6fqkGykxDfDo0aNoaGhwym9FRUUhIiICS0tLqg4JExMTaG1tVYWIJ9cXHx+P/fv3Y//+/bI0QHG3lE6nA2tpsVitra2YnJxkemAl+a24uDhUV1cjKSkJRqMR9+7dw927dxETE0NpgHIP2mtBxLu7voCAABQVFaGoqAgDAwOwWq2orKzE9PQ0pqen8fXXX4PneRcaoFTrhYjX6XRIT09Heno6Tpw4gdraWlitVty+fRu3bt1CfHw8IiIiNAM5WDNS4uuLjY3FkSNHYLfbnfq3xPktnueRkJAAjuM0HTbVIOL1ej2ysrKQmpqKxsZGREVFwWAw0PwWoQHm5eXJbty0ZKQItc/dfSTNb5Gs5NzcHIxGIy5cuACLxaKY33IH5FCSltJir/629Vd7yFpcNKCmJk/WmuZJpLQ4JaWN+Wuqqwtgt+uxa9cdREcPiGiAFrd2mdWNFDuQw9n+qLyRMptnsXVrOfr6YjE6GoLt2x+ipqYAp0+/hHPnTiAnpw48LyA1tcXFrrhaWrx+iHiOsyM5uQPJyR1Pu6WyYLXyaGhwYItPn34RpH9Lyd7pDsjhSXIbKX//aWzf/hDbtz/E4GAEBS988cUrTw/otaitzUVOjjYgh3pEvAF79txBbGyvh/yWgIKCavj7z2B01AHkUCotFoscElgR8YGBk9i58x5GR0MwPh6EzZufwGbLozRA0r+VmNjhcg2rpcVqMlIEES+/kXLkt5qQkdH0NL/l6JYi99HFi0fA89anNEDPnU1a+sjkEPHBwePYvfsOiotX81tVVYU0v5WXV/M0I6UWyKEuIwUQ+6MRe/feQkJCF+bmTE/zWxZcv34Q168fRHJyGywWR37LZJqnG6l9+66rztqxIuJDQ0exd+9NzMyYUF6+FRaLFfX1OZKBlICYmD6Xa2hpEQM5RgD8b8W/T2kjZTAYkJeXh7y8PJrfEk/dr1+/Dp7nXWiActKCiO/r63NBxItpgB0dHbR/SxAEBAYGoqCgAJWVlaozUloR8UtLS9i3bx+Sk5OdaICXLl1CaWmpU37LaDQylxbLXZ+njJRYUVFRKCkpwcrKCu7fv4/s7GzU1NSgoqICwcHBdJsk998iGSk1hDuCiM/Pz5fdSPn4+IDnefA8T/NbgiBAEBy/8x48eICZmRnF/BawtowU2UiJaYDibZI4v2WxWFBZWak6I6UVEb+wsID9+/cjLS0NY2NjdCtJaIDZ2dmwWCzIyMiAXq/H9PQ0GhsbUVRUtK4ZKSKS34qPj4ePjw/u3r2L1NRUPH78GGVlZR7zW8DqRkqN/XFpaQk1NTVMv0+88oror/aQVV+fjYUFx8PahQvHYLEo22VWS4vvq85IiRHxDrtMHXJy6jA76/fULmOhdpnU1Nan8Ap1pcUdHYkYGwvF/v1sGSlgFRGfl1eLkpKrOHjw6lMaoAU222p+i/RvEfIg2UilprIfEtQg4g0Gx0Q/JqYPDQ3ZyM6uxeRkEC5fPuLUv5WTU+dySNaakVLaSEVGDuHgwas4cOAa2tuTKVp8acmIlpZ0XLlSAotFQFSUZ2y+dkS8c2mxc34rAFVVDmLixYvHUVp6BBkZTTAYHO+NmkMCyUhpQcTn5NTj2LELOHLkIlpb06gN9MmTLQgJGQXp3woPHwGwmpFiBXIAQE1NHrP90dd3ARs2VCIlpQ1vv/2/kJbWhMnJIJw7d5L2bzm2SY0u+S1y2FxPRLw4v3XokCO/ZbXyqKzciOVlA7q6EnHz5p6n+S3Pf6e4tFhdRsritJEymeawadMTbNr05Gl+y0FMPHPmBVy4cBzZ2fVPt5HqMlIEyKEWEV9TU4isrEa88MLXWF4+52Yg5QAKkZ9vQRCXFncAWADg+UGltrYWS0tLTAcfs9mMrVu3Ijs7G2+99RaSkpIwOjoqSwOUPvR5Ki32JE+IeHF+S9wt9eDBA9jtdvT39+P+/fsoKChQnKSvFyJeSgOU5rfy8vKg1+s1AzlYM1KAM/3xlVdewcLCAn2PCA1Qmt8CtB82Wal9gYGB2LlzJywWC958801KkmPJb5HrU5uRItQ+uY0UoQFmZmbSoYPVasXNm44uytHRUZSXl8vSAKVaL/tjSEiIU36LEBNtNhv8/PxQUFCg6T4iiHg1kBG73Y7q6mqkp6fjtddew9zcHB22uMtvAWylxVJpQcR75dVf7SHLMQGeRkpKGx4/3oyyMmW7DCktVmM3UkLE+/nNYsuWcmzZUo6RkdCnDzg8RkfDwHErKC09wmSXIa9JLSK+oSHLqbTYmQZ4EQ0NmTQLdP++I7+Vm1uLhoZM7NihHsihFRF//Ph5BAVNYmgogj4EfvnlyzAaF5CXZ4Ojf6sVOp2dubRYLAcivoAJEe/Ib7UhJaUNMzNmtLenIC6uB/fu7cTdu8WIje15SgOsekroc9baEPHyG6mAgCkUFT1AUdEDDAxEUWLi5GQQOG4ZN2/uAc9bkZTkOb8FiEuLtSPiHfmtZqSnNzvlt27d2oNbt/YiIaETubk21NdrAXKQjJR6RPxzz51FcPAY+vpiIAg8qqsd+S0/vxlR/1YXOG51I7Vzp/vSYqnUIOL1+hUKp/n001fR3JyOsLAR3LhxADduHHia3xKQn2+T/W+RHik1W8Dx8WC0taW63Ug58lu3sHv3LfT0xNN6ipkZf+h0y3jwYAd43orYWM8DKUB82FSPiCc/G+4HUodw9aoDlpObW4Pa2hxs2EBKi2cAlAPYqXB9VuaMFBHZSL3wwgsIDQ1FZ2cn3SZZrVYEBASgsLAQFouF0vBYSoulYslIEZH8Vn5+Pj7//HM0NDTAz8+P0gA95bcAZSCHnAgifvfu3bKHAXF+q62tjW4AFxYWoNfrUVFRAZ7nmQ4LWuyPUkS8j48PzW9NTk469W+VlpYiIyMD+fn5sNlsKCgoUH1I0IKIBxz3UXh4OKUBkvxWaGgoJSYSUiZLabFUShkpsUh+a8OGDfj8889RX18PjuNkaYB6vd7l69eKiJcOJ8T5LdK/ZbVa8eTJEywvL0Ov16Ourg4+Pj6y2ySp1pKRIhspk8nkRAMkG7czZ87QjVt+fj5qamo0AznUdMB55dVf5SFretofTU0ZKCq6h0OHrmBuzoSaGoI7lrfLAKsbKU+kOanUIOLDwkaxb99NpKS04Xe/+z5SUtrQ1JRB7TKr2yRXu4y70mIlEWqf3EbKYFhCXl4t8vJqMTNjRnW1Iyd18+Y+AKAbr9zcOsVc1noh4iMihnDgwDXs3++gATq6pfIgCBsQGDiBwkIrxsZCVJUWA+KMlBr7ox+amjKxbVsZjhy59JQG6NgmXbp0FKWlrvktwHGIcWyklIEcRKv2R+Xri4oawKFDV5CdXY8PP/wBEhK6UVNTgIqKzQgOHqPbpIiIYZevXd1IrR8iXpzfmphw5LesVh6XLzseFvr7Y2Cz5T7Nb3neyIhLi9Vm7cQbKZLfOnz4Mpqb055ukzagvHwrwsKGUVhoxehoqAu1T0kEyKEWEd/YmIVNm57g+PHzGBsLpv1bZ88+T7dJFosVGRlNdGslCMqlxVJZrY4HDKX73JHf6kZ8vKM+4IMP/gnR0f14/HgLyspIPYXD3iw3kHKUFq8FEd/o8u/cDaTOn38OADA6Goqmpoyn9RQ34OmQRTJSe/fuZbat2e12CIKAhIQE+uBL8lvHjh2j+a2HDx/i/v37iIqKAs/zGB4eVlVaDGhHxDc2NsJiseC5557D0NAQzZR8+eWX8PHxoRs3kt8CVjNSWhDxStfHcRxSU1ORmpqKzZs344MPPkBYWBjNb8XGxlJiolwGyl1psZI8baQCAwOd8lvkPWpoaADgyD21t7cr5rcAx2FzLYh4csgkNECyVbRarbh16xZu3bqFhIQEWCwWDA0NqT4kEPtjSUkJ89csLi6iqakJhYWFeP7559HX10e3SYQGSPq3SH6LvCZWIAcR631E8ltZWVno7u7Gb37zGwQFBdFtEslv5efn022SWFozUp42UoQGuHv3bnR3d4MQE2tqHJ8X8/Pz6OnpQWxsrOK9IS4tVmN/9Mqrv8pDliMjpaMbKZNpDps3P8HmzU8wOhpCH3DEdpmUlLanG6mLzH+PVkS81eqg9n3rWx9Dp1t5apfhUVa2DQ8eyNtlWEqLpVrNSClvpMzmGWzb9gjbtj3Cr371Y0xPB2BqKgCnT38D584t0P4tufwWeU3aEfE3XP4doQGmpLTj2LHzaGjIhtVqwYMHRVhZ0cNkmsWTJ5tRWFjlQgOUEzkkpKWpzUit2h8dNMCH2LHjIQYHI0X9W478Vl6eDamprejqSlRVWryakWpDcDC7/bGqqhAGwyK+/e0/guNWUFdHaIDFuH17D+Lju0D6t8zmGQDijRT7YVMNIj4oaBK7dt3Dzp338Otf/whjYyEYHg7H559/8ykN0LFNSkzslH1/tCDie3ri3W6kHDTAJmRmNmF+3he1tbkQBDJI4GA2T6O6uuBpfkv5sECAHNoQ8Y77KCRkHLt330Zx8W309sZRW6rNlg8/vxkUFFQjLa1JVWkx4AzkYMlIEVVXF0KvX8Lrr/8eHAc6kLp27SCuXXMMpEj/FjmYNzenP81IsX+fVhHxlYr2RzKQ2rv3Jt5//58wPByOnp54/PGP33laT9EGi6UXMTExbm1XgPqM1ODgIE6cOOHy76T5LbIpuXz5MgCH3bCxsZE5b0GAHGpsa9KNVEREhBMNkGyTSH6rsLAQGRkZHjdSnq5PLSLeZrNBp9Phe9/7Ht3UifNbGRkZsFgsyM7OppskAuRQs71ZWFhg3khFRUXh0KFDOHjwID744AMMDg6ira0NjY2NCAkJodskd69TS0bKEyJenN+amJigm5Lz588DcCD1Ozo6ZGmAciKlxVoyUhaLxSm/Jd4mkULfsLAwWCwWpKenqyotFl9fTEyMIpFSrLq6OnAch+9///tYXl6mtlR3+S2ArbRYKlZEPMdxSEhIQEJCAo4cOYL/+I//wMDAABobG1FXV4eIiAia3woODpb9b8iVFnvlFYv+Kg9ZVqvF7UYqNHTVLtPdHQ9SMFpTUwDAjsHBSPT0xDHZZdYLEZ+bW4fc3FW7jCDwTnYZi0VATU2+qtJiYDUjpcb+ODwcjoGBGBw6VIqiontPt1k8xTAHBk6I+rcctkC7naMZKW2IeM8bKaPRYUnKz69BRcUGfP31izCbp1FaegSXLzvyW47+rTq6TRLLXWmxkjwh4iMjB59m3K6hrS2ZbtwqKzcCsGNiIhiDg5GIjPSc3wJWS4vVIOLlNlIWSxUslipMTgbQ/q0LF47j0iVHfstiEVBVVaiqtBhwHDbVIuLHxkLQ1xeHAweuYteuu2hpSaVQkcePtyA0dIQSE8PCHPkt540UOyJeECxPN1KeqX2+vvPYsKESGzZU4smTDThz5kUYDIs4d+45Sf9Wo+whgAA51gsR78hv9SAurudp/1YGCH3v0aNt9O8cGwthyoyJS4tZJbeREg+kyDbp669fwPnzZOMmwGq1uN1IuRNBxKu5jyYng9DbG4e9e2+guPiOaCCVhQcPfo2oqCi6KQkKCgLgnJFyV1osJ6vVCr1er7iRMpvN2LZtG7Zt24YnT57gzJkz4DiOKb8FOCbgdXV1sFgsqnuk5DZShAaYkpJC+7esVivu37+Pe/ccg4eVlRVMTU0xQQ7WCxEvzm+RbdKpU6dofovnedWlxcAqIl6tba23txfFxcUoLi6m/VskvxUfH0/zW2L7phogB5GnjJRYQUFB2LVrF3bu3IknT57g7NmzWF5exmeffSZLA5RqvRHx0vwWscgSGiDgGDbMzs4q5rcA59JiVontj2QjJaYBkm2SzWaD2Wym75GWjJQWRPzc3Bz6+vqwY8cOFBcX0/fo2rVruHbtGlJSUmh+S1x2zgrk8Morqf7qDlmDgxFMGymOAxISupGQ0I3Dhy/hrbf+T3CcHVYrj4qKzdQuY7FY3RLYVjNSWhDxrgcfZ7tMGM0mffXVSwDsiIgYQktL+lO7jPJDHiktJochFokR8c75rQtoaHD0bz18uAP37+9CdHTf0wD/sKrSYmAVEe8AW7BT+xoashEQMIl//udfYmQkTLRNehk+PvO0fyslpY1u3FhKi6ViRcRznB2pqW1ITW3DsWPn8fOf/xtWVnQoL9+CR4+2Pc1vOfq3/P1d81vAao+UWkS8u41UYOAUioruo6joPvr7o0BIdxkIZJ8AAQAASURBVI7yXDsiIwfQ2ZmApKROxfwWuT7tiHjrUxpgMzIymp/SAHOf5rf24tatfUhI6ITFIiA0dOTpRuou89+zvKyjh0011L7m5kyYzdP413/9OQYGoumwhdAASf9WfHwX/f4rlRbLaWws5Cki3vNGypHfakBWVgNmZ33xy1/+CxYXjXjwYCcePNipmN8CQBHxauyPZCMllx8MDR3D3r23sGeP/EAqKqof/f3RTAMpYBURn5DAjoh32B8dQA5HPYVjIOWop/gQVusUrly5gitXriA1NRU8zyM0NBSDg4OqM1IE7c3yAEnU1tYGk8mEf/u3f6MPgSQ4T2iAPM87PVyRjZSah7uJiQnap+Vpk2A0GlFQUICCggJMT0/jvffew9zcHO7cuYO7d++60ADltN6I+MjISJSUlODgwYNO+a3KykoAQHR0NEZHR5lhD1oyUmQjZbFY4OPjQzcPhAZotVpx4cIFXLp0CRkZGeB5HiEhIapKiwFt9keO49DV1QUfHx/8r//1v2iPm5QGaLFYnIYGaoAcRFNTU0wbKV9fX2zcuBEbN27E+Pg4PvjgA8zOzuLmzZu4c+eOYn4L0JaRcoeIF9MAycZNEAQ8efIEjx49AsdxiI6OxszMDHNOaq2IeD8/P6f8Ftm4ff311zh//jyys7PB8zyCg4NVlRZ75ZVYf3WHLKuVf3pIqGb+mq6uBMzMBOAb3ziFzMxGF7tMSkorHAWjq3YZx0Yqz2Npsfz1EUS8541UWNgI9u27gb17b6C09AgePCjC5GSgyC5Dtkmu+S1AvrRYSZ42Uo78lg15eTan/Nbly4cB2MFxK1he1mNhwcj0fhBEvBo4xOpGyoGIj4gYwsGD13DggPv8Fs9bPW6k3EkQ1CPi+/tjMD0dgBdeOI2MjEa6Tbp06RilAVosVmRn18FodHRLOYAc+U83UmoQ8RamjVR09AAOHbqMgwevoLT0MB4+LMLoaBh++9t/REjIKH2PwsNd81sA1h0R76ABCtiwQcDERNDT/JYF58+fBMetgONWoNcvYWlJr5jfAsQZKfaDjxgRbzCsUBqgY5uUDqvVgsrKjSgv34awsGE6bLFaLcylxUSsGSmxRkfDMTUViJMnv0Z6egtW+7fE+S3haX7LMWxxADk8lxbLX59jI+XJ/igeSB05cgmXLh3Go0fbMTQUifff/9HTgZTD3uxuIOUAcqRg374bqu+jxMQOl9JiRz1FM7Zu/d8YGRmhDzinT5+m2yN/f3+srKwwZSBaWlowPT2t6oFVjIg3Go2UBkjyW4Ig0PxWdHQ03bitBcih5vomJycxOTmJ48ePIyUlhb5HYhogyW+RB27xYXO9EfHi/Nbx48dRWlqK8vJyDAwM4Je//CViY2Np/5a7A8p6I+IJDXDnzp3o7+8HgVM0NDTQw0NISAjsdjvT3ycuLWaVeCPl6+tL81tSGuDNmzdpfqugoEBTRkqL/XFhYYG+puTkZLpNEue3eJ5HfHw8fY/UADnEYkHEi/Nbc3NzuHLlCh4/foy+vj68/fbbsjRAqeRKi1lE7I/SjVRoaCj27t2LPXv2oLu7G4IgoKamBjU1NXSYoeaw6ZVXRH91h6yqqkKkpzcz5XSIxKXFRuOiol2G5wXMzvqqzkitIuLZqX0cB3R2JiI6ug8//OH7aGx0bJPKyrbjwQMHDZAE1Ak8wvGaPJcWy4kVES/Ob/X3R+H9938EnW4ZZ868gIsXj9FtUmpqq9vXqQURX1MjT3+U5rfq6x3dUvfv78S9e8UAgMzMekxPBzDdF3a7o2R1LYh4X98F7NjxADt2PMDAQCTdJp069Qp8feeQm2sDz1sxM2NS3SO1mpF6xGx/1Ons6OmJR2TkAH7wg/dRX58Lq9WCO3d24/btvU/zWwIKCmpofgvQ1iPV3Z3wFBF/x+OfCwqawK5dd7Fz51309MThww+/D44DTp9+GRcvHqfbpIQE+fyW4/qcS4tZRDZS0vfckd9qRGZmI+bnfWGzOTZuN27sx40b+wEA2dm1mJszMR1kxBkpNYh4Yn8kW6s9e25j9+7b6OmJo9skmy0fZvP00/dIwNSUv2ogB8lIqUHE6/XLGByMQljYMH7wg/dRW+ugAV67VvJ0INXmMpACnDdSrOrri8XgYBROnDjr5k/cAPC/ERYWhn379mHv3r3o6OjARx99BAD4/PPPERAQQLdJhAYoJ0EQnEqLWUQQ8dIHVnF+a3p6mm62Ll++jCtXrsButyM7OxuLi4uqpu5qEfFkI5Wfnw+z2eyU3yLExMrKSgQFBVFi4uTkpCYgh1pEvNFoxOjoKIKDg/GDH/zAiQZItknS/BbADlIQy1NGSqzo6Gia32ppacGnn34KjuPwySefICQkhG6TPH0PpKXFLCIbKel9JKYBTkxM0EPy+fPncfHiRaysrCAnJwfLy8vM7/taEPGFhYUICAhAXFycU/+WNL9lsVgwPj7OXFpMRPrIcnNzme2PJpMJk5OTCAwMxPe+9z16H505cwbnz59HTk4OzZSJN25kI6UFEe/pAC3Obx09ehSNjY344osvVAM5vPKK6K/qkLWwoMf4eAgOHlSbkcpDbm6tS57Hk11Gr1+C0TgPX9952O1gms6uIuLZH4TEpcUOu0wtcnNrn9plHNukK1cO4cqVkqfdUlbk5NSqKi0m0oKIHx6OwPKyAd/61scwGhchCDxsttX8FiEmkg4xQFparAYRb0FUVD+io91vpIzGJRQU1KCgoAbT0/748ssX0dycgcbGbPz0p5lPaYBWt/ktAOuOiI+KGkRJyRUcPHgVbW0psFodHWWVlZtgMCzCaFxQdZgjGSk1tjWykTp48Ap8fRfpdmZyMoDSAC9cOIFLl0i3lBWZmQ2wWi3MpcVE5LCplJEi4jhgaioQy8tGfPObf4LBsAKr1QJB2IDHj7ciNHSEEhPFGw2l0mJ3slotiIgY9IiI9/Wdx8aNldi4sRLj48H4+uvn0dKSjvr6XLz5ZubT/JaAzMwmtwcU7Yj4QhdEvIMG2IP4+B4cPnwJTU0ZsFp5PHmyGY8ebYePzzwMhgWmDCCRzbY2RLzZPIfNmx9j8+bHGB0lNEALHUjl5NTBYrEiLa2ZbqTUADlWD5vu7I93Ie7L4jgOi4uLWFpawssvvwy9Xg+r1YqysjI8ePBANr8FrGak3JUWuxPZSCUkJLj9M/7+/jS/NTQ0hHPnzqGtrQ319fV44403nLZJ7ibqcqXFSnK3kRLnt8T9W4QGaDKZYDAYEBcXx/x3abE/ijdSUhog2SadOnUKvr6+yM3NBc/zdIuiJSOlxv6o0+mg0+mwtLSEF198ERzHwWq14vbt27h165bb/JZSabE7sdgfg4KCUFxcjF27dqGvrw+XLl1Ce3s76urq8OabbyrmtwDX0mIWkY1URkaG00ZKuk0iGzeS3/L394der1dl6dTSIyXeSIWFhTnlt8TbJLPZjIKCAlgsFsTFxdGNlBogB7E/st5Her0efn5+qusTvPJKrGd+yOI47iiAtwHoAfzGbrf/f9392ZkZH7qRYlV9vSMj5engI7XLVFcX4PTpF7GyosNvfsNmlwG0IeJX7Y/OmwSHXaYcW7eWY3iY5Ld4nD79EgyGk1haMiIvrwYrKxzTQWatiHhHTsyO5OQOHD9+AfX1WbBaeTx4sAP37pH8loDCwirU1uaqzkgND5OMVCmz3chsnsbISDhSU1tx7Nh5EPACyW+t9m+1OWWTVjNSahDxWYqIeEd+qxWpqa04fvw8rNZCnD3rwFP/+7//T8TFdVMaoLv8Frk+cWkxi9wh4gMDp7Bz533s3Hkf/f3RNONWX58DH595LCz4Ije3hnmQQIAc2dn1KhHxFpjN008PLSvIyGhyym/dvLkXN2868ls8LyA/vwY2W64mIEd7e4oqRHxQ0DjGx4ORlNSGI0cu0a0kyW8VFFTDYhEQH9/t9N8kPVKsh00AaG5Wtj/q9SvIzm5AdnYD5uZMEAQLLl48CkCHd9/9P57WU1iRl1dD6ynktFpavHb7Y2joKPbuvYk9e26iuzuB9m9VVxfCz28Gs7NmFBffYr6PHEAOYn+cdfOnXPuyyEYqJycHBoMBubm5mJmZodskkt8i3VK5ubluN1KepAURHx4ejpmZGcTHx+PQoUN0mySmAVosFhcrkngjxarW1lbFjZQ4vzU1NQVBEHD16lXY7Xb8/Oc/Z8pvkesTlxaziGykpO95VFQUSkpKXPq3KisrERAQgKmpKRQXFzP/PWtFxBOohLv8VmZmJiwWC7KysjRnpNQg4gkNcGFhATExMTh48CAEQVDMbwHOGylWEUS8pzyRyWSi+a2xsTFUVlbSsuOf//znyMrKAs/zTjRAOWm1P0o3UuL81pEjR9DU1ASr1YrHjx+jrKwMISEhGBsbw+7du5n/nmeBiPfKKxY900MWx3F6AL8AcAhAF4BHHMd9bbfbZZ9a5uaMyMuzud1QyMlq5REUNI6UlDamP6/XL2NuzgSAw/e//x8ULOBslxGQl1fr9JCpVFosJ5KRUkLEh4ePYP/+G9i37wY6OxPx9dfPY3g4AvfuFcNq5UX9W+4BGKulxersj3KIeIPBYXXKz7dhetqMmpoCCIKjN+nKlUPw8VlAUNA4pcqxaPWQoAYRv7qRiowcwsGDV3HgwDW0tydDEMg2aSOCgsbpexQWNkIPm1oyUqyIeKNxEXa7DgCH73zndxS+cPHiMUoD5HkBWVn1NL8FKJcWy4lQ+1JTWz0i4qOj+3H48GWUlFxBa2sqLlw4juFhH9y9uwc1NYV0mxQe7v77Ji0tZtHsLNlIOSPipfktkk06d+4kLl48Ch+fBQQGjiMqSm35tXZEPMlvHTpE8ls8Kio24tGjbQgPH0JhoWNDGBQ0wVxaLL0+pYyUWCbT3NOhiA6vvvoxBgej4aineB4XLhyj/Vvp6U1O7+3qRmp9EfGOgVQXEhK6cPToJTQ2ZqK09BBmZ/1w584e1NfnUHuzp3uRlBYr2wtvgByy3G2kzGYztm7diq1bt2J4eNgpv3Xu3Dn4+PggMDBQ1fZGCyJeXFpM8lvibdKDBw9w7949p/yWv7+/5oyUGkR8QEAAAgICYLfb8dJLL2FgYABVVVUe81uAcmmxp+vzhIjX6XRIS0tDWloafY+uXbsGALhz5w5aWlroNsnT4UlaWswid4h4aX6LEBPr6+thMpng4+MDf39/TYdNtfZHspHylN9KTEyEuFtK62HTx8eH2f4YEhJCt4zHjx/H0NCQU36LbJPE+S3Ac2mx0vV52kjp9XpkZ2cjOzsbc3NzqKmpwa1bDorv7du30dHRoZjfArQh4peWlpgQ8V555UnPepO1DUCT3W5vAQCO4z4B8AIA2UPWygqHtDR2NDUpLd658x4TZY2IIOITEzuRmNiJLVukdpkXcf78CWqXSU9vVlVaTNTRoQ4R70BC92JqKhAFBVXIza2F1crj4cPtuH+f5LccGzepjZAAOdQg4t1lpMTy95/Btm1l2LatDENDEXj4cDvKy7dift6EN9/8f9D+rZQU9/ktudJiFhH7o3gj5chvtSElpe3pxs3Rv3Xv3k7cvVuMkJARzM35ITOznvnv0Y6ItyAycgBpaa1IT29FUdFqfstqtaCxMQu+vnNPN24CkpM73G6kPIlkpHbvvs3053U6R8ZtZsaM3FwbcnLqIQg8bt/ejVu39j6lAVqRn18Ns9l5y+CptNidbDZl+2NQ0ASKi+9i16676OuLQVnZNlRWbgIAvPXW/037txISutweGtYTEe+gATYiK6sRc3O+sNnynua3DuDGjQOIiBjAzIw/cnLYt1hzc46MlAMRz5aRclyfg9qXk1OP3Nx67N59Cz098bR/q6amAGbzNN24xcX1uN1IeVJvb5wqRLxev4ysrAacPXsSWVn1yMxshNXK4+rVEly96n4gBXguLXbWDQD/G4D7jJRY4eHh2L9/P/bt24fOzk6Ul5dTqMTPfvYz2pvkCbWsFRFPbGvijZTBYEB+fj7y8/MxPT3t1L915coVxMTEYGpqCnl5ecx/D8lIaUXEFxYWguM4WRogyW/xPI/IyEhNh4T+/n5ViHgfHx/k5+fj8uXLSEtLQ0ZGhlN+S7xNkm7ctGaklCxe0dHROHz4MEpKStDa2orHjx+jttbxOfPOO+8w5bfI9YlLi1kkR+0T57fGx8fpxu3cuXO4ePEi4uPjMTExoTojtRZE/JYtW8BxnFP/FqEBhoeH081taGiopvuIJSMllslkwqZNm3D79m0kJycjLS0NgiDgzJkzTv1b0vwWeU1qN1Ja7I9eeSXVsz5kxQPoFP3vLgDbxX+A47gfAfgRAMTFxeKLL17B48f/BIslHnl50TCZ3P9yqK5ug91eB4vl/wng/8N0QYODU+jpuYPDh3MAfJ/+/6GhwN69wJ49dnR3j0MQulFTY0Z1dSH8/X2wuLiM+PhABARcBsA28ROEahiNvcjJ+RVY3+r6+j7Mz1diw4Z/RHp6BPLygJmZBVRX98JqDcaVK9G4evUwUlPDYbHEITc3GktLK2hsvI4dO1Kg091n+nsAwGq9j+joFURHf8X05yMiALO5EUAzXn11Axobh2Cz+T+lAfqisDAOPB+HqCjndXxn5yjGxh5i3749AP6Z6e9aWlpBTc115OREwNdXvn/KaAQKChz/TE3No7q6FzduNAFYwpdfvgqr1fEe5eREw2h0b3OoqenAyooNFsv/DeD/zXR9IyPT6Oy8jYMHs8Bx36X/f1QUUFICHDhgR1vbCKzWbtTU+KOiYhOCg02Yn19CfLw/goPZqZGCUAODoRu5ue+C9T5qbOzH7GwFNm78LjIzI2GxAJOTc6iq6oXVGojz5xNx8eLJp/8uDllZUVhcXEZDwzVs2ZIEvZ49h2S1PkRExAJiY09B6WeD44DYWCA0tBlAI154oQDNzcOorAxAeflWhIWZUVgYB4slDmFhzpP/np4xDA8/wM6d+wD8mOnalpfJfRQOk+mG7J8xmYBNmxz/jI3NoqqqB3fu6AEs46uvvom6ukhYLPHIyIiAXu9+SmuzdWF5uRo8/28A/l9M1zc2Nov29pvYty8DHPdtACS/5fjnyJEVNDUNwWrtxuPHgSgr246ICH/MzCwgLs4PoaHs5euCUAu9vgN5eT8DwPbQ1dw8iOnpx9i48TXk5ERjyxZgZGQGVmsPrFZ/fP11Ks6f/wZycqJhscQhPT0ci4srqKu7hg0b4qHXK+H8VyfELBkpIo7jkJSUhI6ODgDAsWPH0NLSIksDlNqDSGmxloxUVlaW242Uv78/tm/fju3bt2NoaIhutwDg3LlzdHvjKb8FrB8iXkoDrK+vhyAINL8VGxuLyclJxMTEqAJyqM1IAc4bqfz8fJrfItukhoYGau/jeR5JSUn0kFBQUKD6sBkcHMy0kdLpdEhPT8fAwABqa2tRUlKClpYWmt8iNEACHxGLFcghljgj5W4jFRwc7JTfIlZCALh48SI6OzthsVg85reA9UPES/Nb0v6tpKQkjI+PIyoqSlVGirWPTCwxIr6wsBC7d+9Gd3c3CDFRnN/ieR6xsbGaN1JaEPFeeSXVfzr4wm63/xrArwFg48aN9v379z+ly1TjwoU6xemEY9Vcwvz3Wa1Xn06RTgBwRZM67DKOf44eXUZjYyPu37+Pjo4OdHWN4Ve/ekI/vN21gwNkinQdeXkF8PHZpeL6PkZgYCBSU48BcHwQm83Atm2Of5ztMlU4d64OkZGRWFmxo6DgEIBYpr9naGgI3d0Xn3q1tyv+eYBMgB8gLS0NubkvIDcXOHZsEQ0NDU8fKJpw714rYmJi6HsUEBAAQTgDo9GI3NyTED9UeVJjYy3m5hZhsRwAkKH45wMCAItlBpcvvwmLxYLAwMCndhmrR7sMAFit1YiKikJMTAlYD9BW6w0AgMVyAkCQy7/X6YC0NMc/x48voK6uDmVlZRgf70Z39zjef9/KZJdZXl5GTc1N5OTkwddXzX30Gfz9/ZGefhzkPgoMBHbudPzjbJephMlkQlRUFJaX7SgsPATHfERZo6Oj6Oi4iAMHDoDjdjB9jd1uhyCUITk5GRs2vIwNG1Zx2oIg4ObNJty82eRkl/Hz84MgnH9KfjsBwL01RKympnrMzCzCYtkPQNl6FRICbN06hxs3/n/Iy8tDQEDA0/LMJ9Quw/M84uLiZO6jWoSHhyMu7jBY76OqKsd20mI5DiDU5d/r9UB2tuMfYpcpLy/HzEwfZmYW8dvf1jLZZZaXl1FdfQtZWTnw82PPxAjCn+Hn54fMzBNwxGqBsDBg3z5g7147urq6QLqlqqt74e/vj+hox+CnsLAEAJv1anx8XHVGimykEhMTKZxiZmbGZZuUmppK81s+Pj40I6Xm4U4tIj4iIgLFxcW4f/8+srKy4O/v75Lf4nle9qH0WSDipfmt6upqPH78GFNTU5iensaf/vQnWRqgVHKlxSySKy2OioqiNECycauurkZFRQWCg4MRExOjGjqwVkT8rl27sGvXLprfEgSB0gDF3VIGg0HTIYElI0VE8lsRERF48uQJ0tLSYDabZWmAoaGuvzueBSKebJM2bdqEsbExWK1WVFRUYHx8HDqdDp9//jksFotifkuutJhFUkS8mAZ45MgRNDY2OuW3IiIiEB0dvSYghxr7o1deSfWsD1ndAMSfFAlP/z9Z6fV6F7qMu+kEWTVrIe2wdj/o9Xrk5OSgoaEBvb29OHjwIGpqanD16lVcvXrV6cNb3A4OaGsjZ/nBltplBEFARUUFAODjjz+WLc+Uk5aiwY6ODoyNjWHfvn30/zMajbJ2mdLSUly+fBmpqano7OxEdna2qimSIAgICAhAWloa89fU1NRgZWUFRUVFNFSsZJcZHh5GV1cXSkpKVD/cpaamOlHO3ImUZ3Z2dqKvrw979+6FzWbDxYsXUVpa6oQ7lk5sGxsbMTs7q+o+mp2dRUNDA7Zs2eL2PpLaZQgRDABOnTpF3yMlO5WWbEt3dzdGRkawa9fqoVHJLpOZmYmWlhZkZmZ6PEzIXZ/ZbEZ6ejrz19hsNqysrGDnzp1O5ZlSuwx5wCFB7Pb2duzfv1/1fZSUlCT7kCSVyWTC5s2bMTAwgIGBAezcuRM2m43JLtPc3IyZmRlV36e5uTnU19djw4YNsg9MHMchMTERiYmJFHcsCALq6hzgorNnz9L3SOnnREuPFNlInThxgv5/ZrOZHrjk8ls5OTlobGxUXVpMMlJaEPG7du1CUlISjh07RvNb9+/fx71791wGUqylxXLXx4qIDwgIwI4dOzAxMYHh4WFs27YNtbW1OHXqlOJAylNpsTsR+6O7jZQ0v1VXVwer1Yr6eoflu7S0lGkgBawfIl6c3+rr66O/H+vq6mAymZCXl4fa2lqkp6c/04wUsGp/3L17N1JSUjA/P++yTZIOpNQCOcTXx4qIDwkJwZ49e7CwsIC7d++C53nU19fDZrPBbDZTYqLcQMpdabEnKSHiyfNaTk4OZmdn6XtUU+Ogm966dQvj4+O0z8yTxKXFXnm1Fj3rQ9YjAJkcx6XCcbj6FoC/V/oiJbpMREQE/cWmddXMKrGvmVhBxOWZX331Ff3wJg84Op1O06qZHBJYfrCJXcZsNuPJE8d2bX5+nskuQw6bakk7xNecm5sr+++ldhnS6L64uIi6ujqcPn2ayS4zMzODxsZGbNu2TXWINioqih4wpXYZ8uEttsuQaayaw2ZXVxdGR0exZ88e5q9ZWlpCdXU1cnNzsXv3buzevdulPFNqlyHoYcdGiv2QUFNTg+XlZaYJMLHLhIWFwWq1Ijc3F/Pz87h165aiXYYcElJSUjxudaWyWq20i0hOcnaZyspKLCwsoLm5GefOnXMpz5QTOSRs3rzZ41RVKkEQnm6kHCAFd3aZ69ev4/r160hKSqIP7Go+lHt7ezE0NISTJ08yf41jI1WNnJwc2pukZJch95FjI7X2Hik5kQec2NhY1NXVITMzE3Nzc0wDKfFGSm1GSq/Xu6X2yQ2kqqqqsLi4iI6ODpSWljINpMSlxWpsa4IgOG2kxNskuYFUeno6HSCoPWxqRcRnZWXh6NGjOHLkiMtAKjg4mOZuyEM3S2mxVCwZKSIykEpNTcVPf/pTpKamYmZmhmkgRa5vvRHxMTExiImJoVZCq9UKQRCwvLyM3t5e3LhxQ5YGKNVaMlJiRLyvry+lAZKBlCAIdCCVlZUFk8mk+rC5VkT8888/j+XlZTQ3N9PPfrmBFMBWWiwVyUix3Ed+fn7YvHkzcnJy8MYbbyAxMRGTk5P4+uuvcf78eWRnZ4Pnefq8JpW70mKvvFKrZ3rIstvtSxzH/QuAS3B4Tf7Dbre7K02RlRxdxmq1or29HYBj6k7sMkrTCS0/2HIbKXF5ZldXF+1zqK6uhr+/P52Wql01C4KA6OhoVT/YZCNVUlKCwMBAt3YZnueRk5MDHx8fupHav38/89+ztLSEmpoaarlRUkREBA4ePIiBgQG6ySJ2sMDAQPpLV84uQw6bamwiShspo9GIwsJCFBYWUruM1WpFc7MD8ECm7kp2GcDxfSJ4aVY1NjZibm7O6T4Sl2fK2WXy8vJQX1+v6bAZGRnpsbxV7msA4MiRIwgODsbExATdJrmzy5CNlBokMzkkZGdnK26kiF0mNjaWTvjT09OZ7TLksKnmQWNsbAwdHR1uN1Jydhmr1UqzQZcvX2ayywDKhwQ5STdSLHYZMnVXe9i0Wq0ICwtDfDybdRRY3UgdO3YMoaGhsgOp3NxcWCwWpKWlQafTyW6klERsa1lZWYobKTKQSkpKwtzcHBobG5GQkMA0kALUHTaJCCLe3UZKPJAaHBykw5bx8XFwHIfbt2+D53nZbZJU64GIdzeQunv3Lu7cuYPY2Fjk5+fDZrNpAnKwZqSIyH104sQJhIeHMw2k1AI5AHWIeJ1OR2mAdrsddXUOqz6hAZKBVEFBgew96a602JOUNlLigVRvby/9DJmengbHcSgrK2MaSAHaMlLE/lhS4ohsKA2kkpOT6X2kprQY0G5/BICTJ08iMjIS3d3dTv1b/v7+lJhIBlJqgRxeeeVJzzyTZbfbzwM4vx7/LWKX2bx5M0ZHR+mHt3g64c4uo3WKRA4Fcj/YcnYZYikiv4TNZjOTXYb8YLN4tYnkNlJiuwwJX1dVVeHLL7+kW6jp6WkYDIY1HzaVNDMzg6amJmzfvh2HDx+WLc+U2mUA140Ui8ghgWUjRewycXFx+PDDD5GRkYH+/n7Z8kzpB5P4sKl0qJden7uNlDu7zP37DohJc3MzysrKXMoz5TQyMoLOzk4cPHhQlW1NEASnjVRQUBDNJ8jZZYg9VK/XqyKnNTU1qbY/zs3NoaGhAZs3b8axY8fc2mV4nkdeXh59wLFarYiIiHhmaG9il0lLS8MHH3yA1NRUtLW1Mdll1Bw2pddnNpuRkeGaU3RnlyHI466uLlRUVDANpMbHx9HW1oZ9+/apvo8SExPpodfdQKqqqgr+/v506KH2kNDc3KwqIwU4NlINDQ3geR4nT57E9PQ0HdqRgRTp3yIDKUAdkINIjf0xMjISBw8eRF5eHn79618jPj6eDqSIvdndQMpdabGSPCHipQMpMmy5cuUKAIe9jty7Sp+la8lIiRHx0oEUiRJUVFRQoiK5j7QCOVi1sLCAhoYGFBYW4vnnn2caSJHXpFRaLBXJSCndRxzHIS4uDnFxceB5Hr/+9a8RHR3NPJByV1qsJGJ/lHuWcDeQOn/e8Tg4NjaG+vp6poGUGBGv9j4SI+LJQEr8vFZeXo6HDx8iIiICFosFExMTqg+bXnnlTv/p4AutCg0Nxd69e7Fnzx5Zuwz5YCLTifr6etWkHfKDXVRUpLhJIJuN3NxcvPfee5iZmUFAQACTXQZYW0bK3UYqIiICBw4cwP79+9HR0UH9yfPz8zAYDLhx4waTXYZcnwPIkcp8fVJfM4tdJi0tTXNGKi0tjSkjJX5NRqMRr7zyCoxGI9rb2xXtMnIbKSWRjBTLRorYZSwWC95//30aKCblmSx2GUCb/dFduaOcXcZqtWJxcRE+Pj64f/8+k12GXJ/ajJTU/ii1y5DrOXv2LC5cuICsrCykpaWho6PjKZBD3X2UnJxMbS0sqqqqgl6vx6uvvgqj0UjtzZ7sMmvJSG3cuFHxoYTYZTZv3oz3338fo6OjmJ+fpwMpqb1ZKi1ZO2J/lNtIuRtIlZWVYWVlBb6+vnjy5AkKCwuZfobXw/7o7+/vcSCVl5eH9PR0zUAO1oyU+DXpdDq89tprMBqNTAOplpYWTE1NqdqOkIxUYWGh4kYqICAARUVFKCoqwgcffIDBwUGMj48zDaQA96XFnuRpIyUeSJ04cYIOpO7cuQO73Q6TyYTq6mqmgRSg3f4ofpYgAylx/1Z1dbXTQCozMxNNTU2agRxqEPE1NTXgOA7f+c53oNfraf+WmAZI3D9kIKUGyEGkZnBNBlK7d+/Ghx9+SLfXn3zyCbU3WywW2YEUwH7YFMvTRko6kCLDlmvXrtGtrpoohVdeudN/2UMWkTu7jHQ60dLSsu6kHTkNDQ2hr68Phw8fRlFREZNd5lm3kXMcR8szk5OT8eWXXyI6OprZLkMyUtu3b9eUkZKzrcnZZaxWK5qaHCWuPT09aG1tZbLLdHZ2ugA5lEQ2Ujk5OfTQ68kuExcXB4vFgqamJvj7+2sCcqj5gBgZGUFPTw8OHjyI4uJipw9vYpfJz8+HxWKhdhkxkGM9M1JEYrsMKToNCwtzssvwPE/D11LNzs5qykiRjVRsrCs5Mzg4GLt370ZxcTG1y1RVVdHOm6GhIXR1dTHZZXp6ejA8PIydO3cyX5vcRkpsb5azy1gsFjQ2NsLPz092I+VONptNtW1tbGwMPT092LdvHx1ISe3NUruMWiAHkdVqZbI/igdS1dXVOHXqFAICAnDlyhUXGqDcQIqUFrsDcni6PncbKelAShAESgMEHBuZ/v5+poGUuLSYVWL7IzkcSGmA0oGUxWKhRbpqD5tqqX0TExPo7u7G7t27sXfvXrf5LZ7nnfJQ0o0Ui8hhU2mTIB5Ikd9Hvr6+dCAl7t+SO0y6Ky1muT65jRTHcXQgdejQIaf8FkGwz8/PY2RkhGkgRUqL14qI9zSQIu4fm82mGsihZXA9MzODrq4u7Ny5E/v373fJ28sNpADHs46n0mI5Efuj0sDRz88PW7ZswZYtW+h9pOZnwyuvPOm//CFLLHd2GdI0HxwcjMrKSia7DKDcRi4nqa/Zk10mICAABQUFiIyM/Iu1kdfU1CAwMBD/+I//6DTB8WSXIRsptRmp7u5upskYscvs378fP/3pT6HT6dDU1ASbzaZolwFWD5tqMlINDQ1uN1Lu7DIXLzo6iUJCQmCz2ZjsMsDaMlLk+tzRAJ88eULtMlFRUaqBHA5EvPNhk0W1tbXw9/fHP/3TPzm9R2IaoNQuY7PZmIEcRA5EvPJGSmyXKSkpwdtvv42VlRX6O0DJLgOsZqTU2h/dbaTc2WXOnHGUAYeGhqK5uVnW3iwnq9XqBORgkdi2Jh5IubPLEKy4WiCHmoyUWPX19fDz88NPfvITp4fAr776ymnjRgZSgLbDJisiXjyQOnbsGN59910sLCygsrIST548odukgoICtwMxudJiJZGNlNx9ROzNO3bscBpIffHFFwAcgI/Ozk6mgRSwWlqsFhFPNglSezPZuEkHUtHR0WvKSKmxPzY1NcHX1xf/8i//guHhYVE9Rb3sQApQB+QgIvZHJWqfeCA1Pz+PX/3qV5idncWjR4/w6NEjFxqgnIi7Zb0Q8dKBFBna2WyOwvWIiAj09/czDaTI9akdXIvvI3d5e+lAKioqCr29vaoyUmpJ0kStra2qc/teeeVJ/60OWWKJ7TJy+S0lu8zg4KDq8KMnap+SXQZwTJ0nJiaY7DJa2siliHg5u4zVanWyy1gsljUBOdTa1qanp/Hiiy9S6IPYLhMbG0sfcMgvTnLYZAVyiK+PBREvtstcu3YNt2/fxuLiIrXLkPfInV1Ga0aKbKSk9wKhAaanp8vaZQDHtHBmZobpIWU9EPFydhmS3/Lz86MPOIIguN1IuZMW21pfXx+mpqbw3HPPUeiDnF0mPz+fbp/E1L71ykiJJbbLXLt2DXfu3MHMzAw+/vhjJrvMeiPi3dllrl69Sv/M8vIy5ufnmQ7fWjNS4o2UeCDV2dlJ7c3igRTP8xAEQTOQQ63daGJiAidOnEBubi5qamogCALdJskNpFhKi+VEMlJKGykykDpw4ACuXr2Ku3fvYmJiAr///e9d6inktBZEvNxGysfHhw6kJicn6caNDKQAx+ZycXGRaSBFEPFqtjdSRLzSQIoMW7QAObS4W8bHxzE+Po6jR48iNzeXfs6KaYBkIEWGLSylxXIi9kdPGynxQOrw4cO4evUq7t+/j9HRUXzwwQdut0liyZUWs16f3OBamrcnxMQzZ87Q5zOz2Yzl5WWmgdRaSNJqnyW88sqT/tsessSS5rfk7DI8zyMmJob+wtBySGD9wRbbZcbHx/Huu+/Cx8eHTnDIh7enH3aSkVJrf3RnW1Oyy6SkpGBgYIBpqyc+JGixPxLqkJxd5tKlSygtLaV2GbvdrjojpRUR39raiqioKPzoRz+i+a2amhpKA3RnlwHUPdyxIuLFdpnR0VH88pe/hMFgwOXLl3H16lVFuwy5Pq2IeOlrcmeXIeFrwGHJHB0dZbLLrAci3mQyUbvM2NgY3bhJ7TLLy8uagBz19fXYtGkTs22N4zh0dnYiPDwcP/7xj2n/lpgGSKy74gccLYeEnp4epo2U2C4zODiI999/HwBw4cIFXL58WXEgBWjLSJGNlNx9RGiA0oHUgwcPAABpaWmYnJxkGkitByLez8/P7UDKx8eHWsCXlpZUHzYXFhxl5WqofRzHoaenB6Ghofjxj39MC+E9DaQA7X1kAwMDihupwMBAOpDq6+vDhx9+iJWVFZw5cwalpaUuNEA5ac1IyW2kpAMpMmy5ffs2hcGkp6djdnaW+UBMMlJqEfFkI+Xv7+9UTyG2N4sHUouLi880I0Wk1+sxODiIoKAg/PjHP6bvkbieQjqQArQdNgkiXmlwHRoaSgdSXV1d+Oijj7C0tITTp0+jtLTUpZ5CTutFkvbKq7Xqb+KQRaRkl4mMjKQfTFpWzVare9KOO3V1dWFpaQmvvfYagoOD6Ye3uDxTapfR2kZutVoVN1JSu8wXX3yBuro6dHR04Fe/+pVs+FoqudJiJXnaSEntMmRT8sUXX0Cn08FgMNAsCctUTQsifmRkhAI59Hq9LA1QapfJz893u5HyJC2I+L6+PiwtLeHVV19FUFCQk12GlGfyPI/ExET6HpGM1NatW1XfR0obKald5vTp06irq0NrayveeecdJrvMeiPiQ0JC3Npl9Ho9DAYD7ZdhuY+02B/FGymDwSBrl7l27RquXbuG5ORk8DxPp99qgRysGSmxRkdHsbi4iG9+85vw9/engwRPA6m5uTnNGamwsDCP1D7xQGpmZgZff/016uvr0dLSgrfeeotpILUWRLxcabF4ICWG5ZCfW71er2oooDUjRRDxPj4+HgdSBJaTlZW1JiCHGtva9PQ0FhYW8Morr8DPzw9Wq3M9BRkOiQ8raoAc0usLCQnxuJHy8fEBz/PgeR6Tk5M4c+YMGhsb0dzcjDfffJNpINXf3+9SWqwkd4h4cT2F3EDKx8cHer1eVVRhrYh4Pz8/J3uzu4FURkYGrFb20mIitYNrjuOwvLyMhYUFvPjiizCZTLIDKYvF4vTzRkqL15Mk7ZVXWvU3dcgSy5NdhlhmyAMii11GvGpWG6IlP9g6nc6pPFNqlyHZpPb2dtWHBC2IeIPBgL6+PqSnp+Oll15yCV+npaXR/i3xa7ZaPZcWy8lTRkqsyMhIlJSU4ODBg6ivr8enn34KAPjDH/7AZJch16cWEU82etIPCPE2SWqXuXTpEux2O9LT07G0tMT04LAeiHidTsdkl2ltbVV9H42OjqKzs1MVtc/HxwcDAwNISUnBSy+9xGSXIa+JBcghFov9UWqXqa2tpfmWDz/8kMkuQ65PbUbK3WbTUz3FuXPnsLy8jLS0NGa7zFoQ8WQjpdfrnezNgiDg0aNHTgMpi8WC5uZmTRkptYh4Pz8/DA8PIzExES+88ILLQIpsk1JTU52GBlr7yJQ2UhzHISUlBSkpKTh27Bhqamrw9ddfw2634/3332caSJHr04qIl77n7gZSp06dgtFoxOLiIrZv3848SFgLIp7Y1gwGg8tA6s6dO7h9+zYdSBUUFKC5uRmLi4uqNglaEPGBgYGYmJhAfHw8Tp48SX8/ehpIkdekFRHvaXsjHUhVV1fj3LlzsNvt+NWvfsU0kCLXt16IePFAqqenhx6SbTYbTCYT5ubmVN1HWjNSZCNFDkzZ2dkueftr164hJSWFEhMbGxs1RylYSNJeeaVGf7OHLLHEdhlCAyREIEEQmOwy65GRIpLaZYgVhNAADQYDAgMDVQXMtdgfxYh4MQ1waGjIaZsktsskJCSoKi0WX19AQAAzIp7jOExMTAAAvve971GwgNQuU1hY6DRBVCotlhP5gFDaSIntMv39/fjyyy/R39+P8vJyVFVVMdll1hMR784uc+vWLdy6dQs+Pj4ICAhQjb0H1NmNxBupoKAgRbsM2ZSQjJTaw6YaRLxer8f8/Dzsdjv+4R/+gf78K9ll1pKRUtpISe3NZ86cwcDAAMrKyiieWskuoxURX1dX52J/VBpImUwm+Pv7q7JQabGtiRHx4eHhTgMpYm8mv0fEsBwtQA7WjBQRGTLZ7Xa89tpr9KAspQFKB1JkI6UVEe/J/igeSLW1teHChQsYHBzEw4cPUVdX51JPISdpaTGL3G2kpAMpMVCotLQUJpMJZrNZNdhlLYh4cT2Fp4FUaGjoM8tIieXr6wsfHx/Y7Xa88sor9D5SGkgplRa7kyAIHjdSHMchPj4e8fHxOHz4MJqbm1FaWoq5uTk8fPgQTU1NTAOptWSkpBsppby9yWSCn5+fKrCLFvujV16xyHvIkkhKAyQTHE92GWBtGSlPP9hkkp+Xl4eZmRk8fPgQt27dwuTkJN566y0n3LG7Q816I+IjIiJo+Fpql/Hz88P8/LyqMPFaEfEEKEJogO7sMtnZ2fSQoOaw2dnZqZraFx4ejvHxcRQUFGDjxo1MdhnymtQi4j1l7YjEdpmJiQmUlZXh7t27WFhYwE9/+lMmu4zWjBSxUYk3UlK7DMkmEbtMYGAgZmdnVb0P5LCpFRGfnJyMlJQUFxqgO7sMoD4jpQYRT96jqakpOsRgscuQ18QC5BCL2B89vSbpQKqsrAwPHz4EALz55psu9RRykistZpGc/VE8kDp27JjLQCokJATT09OqsmIEyMHzvGrbWmhoKDIzM8FxnNuBFIHlpKSkaDpsqkXEEwv47OwssrKyUFBQ4GRvdjeQAhw/u+5Ki92J2B89vabAwEDs3LmTwnLKy8tpbvPNN99kGkgB64eIVxpIRUREYHJyUpUFntjW8vPzNSHi8/LywHEcHUgRe7N0IBUfH6/psDkwMIC+vj7mIma9Xo/MzEycO3cOaWlp1A4vpQGSLKxYWjJSLIh46UCqvLycuk7eeustl75Ud3IH5PDKq7XKe8hyIzENUNy/JWeX0ev1mlbNan+wzWYzXc9/73vfow+mSnYZMkXSgoj3dHiT2mXq6+spVers2bMoLy9nssuwHBKkcoeIF9tlBgYG6GSS0ADtdjtiY2NVHTa12B/JRornedn8ltguw/M8CgoKwHEcc2mx9PrUIOKDgoLow+O3v/1ttLS0MNllurq6NGWklBDxOp0OmZmZyMzMxPz8PGpra3H58mUAwNdff42KigrwPO9Unimn9UTEi2mAUruM2WzGysoKYmJiVAM51CLiyUaK53lkZ2fL1lNI7TJ2u112I8VyfWqofWFhYfSh/O/+7u/Q0tJC7c3+/v70AUc6kPJUWuxOLIh46UCquroaN27cAACcOXMG1dXVigMpwLW0mEXuNlLuBlKVlZUICgrC0tISoqOjVQM5tCLiN2zYgNzcXJd6CrmBFLmPnkVGSqzo6Gh62H7++efR1tZGB1KknoLneZeDlKfSYndiQcRLB1JVVVW4c+cOAODcuXNobGyk2yRP74u0tJhFchsp8UCKbJPEA6mwsDAsLCwgKipK1TZZi7tFjIgvKCiQraeQ0ptJlYbajJTVyo6IJ3l7UpNz9OhRtLe3u/Slyg2kPJUWe+XVWuU9ZDFIHL6Ws8uEhYXBbreregjX8oMt3kiR6a0nuwzP84iOjqaHBLVTJDX2R6PRiLS0NMzOzmLLli2IiIhgsssAq0AONT1SLEWDUVFRKCkpoQ849+7dQ1NTE3p7e/H2228z2WXkSotZJLeRcmeXIeWZERERWFlZUfXwRIAcWhHxJAtQUlJCw9fELhMaGkrvo7CwsGeWkRKLWGvOnj2LDRs2IDw83Gmb5M4uA7ABOaRS2mxK7TJNTU14+PAhWltb0dfXh1/84hdMdpm1ZKSkGyklu0xUVBSWl5dVPTwR+6OajJQYEU8ON3I0wKioKDpsCQoK0gTkUIuIN5vN4Hkely9fRkFBAb1/lQZSACgiXk1GSmmzKTeQevToETo6OjAzM4P33nuPDls8DaTWExEvrqeQG0hFR0dryki1trZi9+7dmhDxhAQqrae4ffs24uPjaX7LbDbTw6aajBRBxLNub4KCgrB161bcuHED2dnZCA0NRXV1Nerq6mAymSgNUDqQAhz3kdqMlNJGSjqQstlsKC8vx8jICKampvDhhx/SYYungdRaEPHS0mLpQIrQm2tqamA2mxEbG4uFhQVVv4/Wiogn0Qbx85rcQMrX15e5tNgrr7TIe8hSKbn8VmVlJQDgd7/7HZNdBnAtLWZRR0eHi69ZyS4TFRWF4eFhZGdnq85IBQYGMmekgNWN1JYtWxAdHY3t27e7lGdK7TIjIyPMpcVE4owUy0ZKp9MhNTUV1dXVMBgMOH78OGw2mwsNkCB2xWIFcog1MzOjuJGS2mUEQaC2q48++kiVXQZYOyJeGr4mDzjELhMfH4+BgQFkZGRoBnKwimyktm7diri4OCa7zNjYGFNpsVisGSkiUp7Z3NyMjo4OHDp0CLW1tUx2GU+lxe5EMlKe7I9y9RRPnjwBAHz66ae0f0vJLrOWjJQYES+lAZIHnCtXruDKlStITU1Fd3c30tPTVWektCLit23bhsTEROzbtw8dHR2wWq30ugIDA6kFPDo6mgI5nkVGiojUU3R3d6Orqwv79+9HbW2tSz2F3ECqpaVFUx9ZbW2tR/ujeCDV1tZGf2cDwJdffilbTyEncdksq+Q2UkoDqfT0dHR2diI9PV0zkINVdXV1WFpaQlFREZKTk51ogCS7HRoaSq83LCyMubRY7vpYEfG+vr7YuHEjHdju3r0bdXV1TgMpnueRkZHh8vvDU2mxOykh4sUDqSNHjqCpqQlWqxW1tbUAgPPnzzMNpIC1IeLFB2jx85rcQCo7OxttbW2qgRxeecUq7yFrDZLmt8gER1qeGR0d7fSLVkzaUZuR8uRrlrPLPHz4EMvLy6itrcUf/vAHSgP0dOBaT0S8uDyzvb2dbtyIXYas7rUAObQg4vPy8ui0VGyXITTAjIwM8DyPrKwsGI1GuhlUkw1Si4iPjo7Gli1bcP/+fWzcuJFuPZTsMp5Kiz1JCRHv6+vrYpd59OgRFhcX0dDQgE8//ZTJLiMtLWaVdCPFYpchr18LkGPXrl3MXyO2P5JpqdQuI85vpaenQ6/XP7OMFBGxywQEBKC8vBwFBQVYXl52ssvwPI/CwkIXuwzJSMmVFnsSofa522yazWZs3boVW7dupQOpx48fY2FhAc3Nzfjiiy+YBlLrhYiX1lNIB1LR0dH097Ga+0grIp5spIqLi1FcXKw4kOI4TjWQA1i1P7K8Jp1Oh7S0NERERFDo09LSEtNACnDcE2ozUkobKbmBVGVlJebm5tDW1oYzZ87AYrEoDqTWgogXlxZLB1Ikv3Xz5k3cvHkTCQkJCAwM1JyR0oKIz8zMpLUCvb291N5MBlJk2BIfH0/vIy2HTVb7IxlIxcfHw2azIT09HYuLi0wDKcDxnmtFxLu7j8QDKZK3r6qq8nZjefVM5T1krYPE+S0Wu8xa28hZfM1msxnbtm1Dc3Mz5ufnsXHjRlRXV+PLL7+k+SJ3dhlySFDzi2doaMjjRkpslzl+/Djq6+shCAKampoAAB9//DH98FaaKGnJSMltpKR2GRJQb2xspIWYWjNSahHxZGq8b98+BAUFUbuMIAhu7TKspcViqbU/BgUFYdeuXejq6sL8/Dw2bNjgYpfheR4JCQkuDzjuSos9iWSk3Nkf5ewyVqsVbW1tAEAf3KU0QDlpsT/KbaSU7DK5ubmKGyl316cVEX/w4EGEhITI2puldhkC5CgqKmL+e8gggJXaRwZSg4ODaGpqQkFBAWw2m+JACtCWkVJCxIsHUtPT06ipqXH6fUSm7koDKUBbH5ncRkppIJWXlwebzYYNGzZoAnKooa2RzWZJSQnCw8Nl6ynEsByj0chcWiyWuI+MZSMVHR2Nw4cPY2pqCnV1dcjOzpalAcod8khp8Xoi4n19fbFhwwZs2LCBDqQEQUBXVxcA4OrVq0wDKUD5sCkngogn2xtxPYV441ZRUYFHjx4hPDwc+fn5qKmp0QTkYM1IEVVXVwMAjhw5gsjISIyOjtLBpruBlNxGSklk4MiykRI/r5GDt5oohVdeqZH3kLXOYrHLLC8vq85IaWkjF2+kyIe3kl0GcPyyVyotlkpNiJbYZQIDA9HU1ITCwkIMDQ0x2WXEPVLriYiPiorCoUOHKO6YTALtdjtqampgNBqZ7DJaEfEka0c2Mkp2mczMTCwuLkKv12sCcqhFxDc2NmLLli04cuQIk10GeDYZKbGIXSYyMhIffPABcnNzMTg4KEsDlB5u1pqRkrM/urPLVFRUYGVlBQ0NDQgMDERhYaGiXWa9EPFy9maxXSYnJwcLCwuqQQpiIAer5ubm0NDQgA0bNuDEiRM4duyY4kAKUA/kIF8DsG2k/P39qaXw17/+NTIyMjA0NEQHUuJtknTYIt4krBciXm4gRTZudrsdbW1tePDgAdNAaq2IeHJYEddTiAdSDQ0N8PX1RV5eHubn51Vb4ElGSi0ingA5nnvuOfqgLLU3iwdSgHogB6DO/kgGUhkZGfj3f/93JCcno7Ozk2kg5a60WElkIyVHfyQ0wMzMTMzNzTm9R4CDdvr48WOmgZRWRLx0IxUaGkoHUt3d3fRzlgykCgoKMDc3BwCqD5sTExMoKSlh/prFxUXU19erPmx65ZUaeQ9Zz1Biu8zw8DBdT4+OjkKn01Gbg5JdBlgfRLzULiP+8CZ2mfT0dNWlxcT+qBYRTzZSJ0+ehI+Pj1N5pju7jJbDphpEPLHLpKWlYXBwEFNTU4iMjGS2y6g5JBCRjdTevXtl/72cXaaqqgpTU1PQ6XQoLS2VpQHKSUtGimykyH3EYpfJyMhAZ2enJiCHVkT8Cy+8AB8fHye7jM1mo3YZnucRFxcHjuNUAzkAxyGhvr6eaSNF7DLZ2dn44IMPMDo6iuDgYBq+ZrHLAOuLiJerp6ipqcHs7Cz0ej1u3LghW08hJ5KRUmN/lG6klAZSaWlpyMjIUF1aTO4jtYh4Yn/8xje+AZPJhI6ODrpNEgSBHpAtFgsdQKkFcgBsGSkiMpAqKCjAhx9+iMHBQfj4+MjSAOUeFJ8FIt7dQGpxcREGgwEPHjyQraeQEzlsakHEk/tIjgYoHUhlZmaiublZE5CDNSMl/hqdToe/+7u/g5+fH9NASrqRYhE5XLIcEkwmE7XJ//a3v0VfXx9WVlaYBlKAtqydp40UsTcnJCQ4DaQeP35Mh9AVFRWyNEA5ESDHs4R7eeWVFnkPWX8hScszyQOO1C4jR9hbS0bKHSLeYDAgPz8f+fn51C5jtTrKfAHH5iwgIIDJLiMuLWaV3EZKWp5ptTrjjgsLC9HV1aUZyKEWEd/T04OSkhLs2rXLxS4jfcAxGAzMpcVSkT4ylo0UscvEx8fjz3/+M5KSkpjtMixADjlZre4R8VK7DNmUEHR2W1sbwsPDmewy4tJiVskh4sV2GZLfEttlLBYLOjo6VJUWA66HTRaNjY1RuMGePXucwtfu7DJqgRxEShkpIrFdJi0tDZ999hliY2Nl6ynk7mN3pcVK8rSRkhtIWa0OOinggGw0NzfL2pulWi9EPBlIibdJDx48wL179xAdHU3vI60ZKbWI+I6ODuzdu5faLsmw5dSpU7IDKZK1YwVyELEi4sUDqdzcXHzyyScIDw93qqfwNJBaS0YqJCRE1v5ItknSsvP6+noADhprR0cH00BqrYh48po9DaQSExNhsVjQ1tbmdiPlTloR8R0dHdi1axcOHDiA3t5eChQi9RRk40YGUoC2jBQr3Es8kKqvr8cnn3yCoKAgtzRAqZSAHO6kxf7olVdq5T1k/YUlpgEePXqUhq892WVYSoulUoOIJ3aZrVu34qc//SkMBgPGxsaY7DKA+9JiT/K0keI4DqmpqUhNTXXKb927dw92ux3+/v4oKyuTLc+UEwFyqEHESzdSYrtMf38//fAW22ViYmI8bqTkJM5IqbE/knLs119/HUtLS7J2GZ7nkZ+fT+0yWrJ2IyMjzBupoKAgFBcXY+fOnXj77bcBOKAAn332maJdBpAvLVaSp42UXq9HVlYWsrKynOwy169fB+D4nlZWVjLZZYC12R/J9UlpgHJ2mdjYWFWlxcDqYVOt/ZH8vd/73vewsLDgkt8Sl52TBxw1QA4ipYyUWGQgtXfvXvz85z/H8vIy2tvbUV9fT+spLBaL259nLRkpTxsp6UCKDFtIl1tQUBBsNhvzz7AUyMEi6X3kaSAVHByMwsJCxMbGYnBwkLm0GFCfkSKy2WwwmUz44Q9/iNnZWSegkNxACnDdSLGI2B9ZNlIxMTGIiYlBSUkJ3nnnHczPz6OhoQE1NTWKAylgfTJSYokHUuPj4/Q9OnfuHAAgODgYzc3NsvUUciJADq2IeHF+SwwUkg6k4uLiVJUWA86IeDXUvrq6Ovj4+OB//I//gampKRd7c3Z2NnieR3p6On0WYSktlkorIt4rr9TKe8j6T5SUBihnl7FYLKisrFTdRq4VET81NYWXXnoJhYWFbu0yPM/Ta2EpLZYTsT8qbaTEdpnbt2/j2rVr8PPzY7bLKAE55CSXkRIrOjpa1i5TUVEBwEGJGhoaYrKYaMlISTdS7uwy58+fx8WLF2lAXRAEVaXFgDb7Y3d3NyYmJvD888+D53m0tLRAEARqlwkLC6MPymTCzlJa7O76WOyPYrsMuY/0ej2zXcZdabEnedpISe0yJJtE7DKA42AyPj7OZJdZCyKebKTc5be++uorp24p0iP1rDJSRH19fRgfH8fJkyfB87xsPQV5UCY2ZbVADvH1sSDi/f39KVWS3EcrKyv48ssv4ePjQ98jdwOptWSkEhMTXTZS0oEUqV64e/cu7HY7AMf3eXp6mmkgRUqL1Rx8pBspqb1ZbiDF8zwEQXC7kXInrba1sbExHDt2DDzPu9RTJCQkUFgOOViSw6an0mI5ecpIiRUcHIzi4mLs2rULt2/fxvXr1zE/P49PP/2U1lNYLBa3A6n1RsRLB1IEKEQGUoDjPpybm2Ma4qwHIl6unoIAhfz9/SkxURAETUAOtfeRV15pkfeQ9Vcid3aZ06dPg+M4xMTEMNtltGakxBspcX5Lzi4TExMDi8UCHx8fzM/Pq/pQnp6eZs5IiVVfX4/o6Gj8+Mc/li3PzM3NBc/zSE5OdrI5qC0a7OzsZELEi+0yhw8fxs9+9jP4+vri/v37uHfvHuLi4mjBqLsPagLkWC9EvJJdJi4uDp2dnUx2GTEiXk1GympdpfYp5beIXcZoNKrOSGlFxDc1NSEiIgI/+clPnPq3lOwygLrDplJGikiv1yMnJwc5OTmYmprCO++8A4PBQB8Clewy5Pq0IuLl7iNP9RQAkJCQgL6+Pqb8lri0WCsiXq6eggykxBs3g8GgKSOlBRHf2tqKsLAw/PM//zMFCnkaSAHaD5ssiHij0YjCwkIUFhZiYmICv/jFL8BxHK5du4br168rDqTI9WmxP7rbSEkHUuRnjQykkpKSMDIywox8t1qta0LEy9VTiAdSpOxcr9drykjZbDYUFBQw29Y4jkNHRweCg4Pxr//6rzS/Ja6nIPeR+GdHS48UKyLeZDJh06ZN2LRpE0ZHR/Hee+9hZWUFpaWluHr1quJACpAvLVaSO/ujeCAlpjeTegrAYe2dmJhg/pwi9kc1g2uvvNIi7yHrr1DS/BbZJn300UfULiOmAUq1FkR8Xl6ey0bKnV2G5CXIB9Li4iLTh4vaHinAdSNFyjM92WUKCwtVlRYTqclIEbW1tWFxcRGvvvoqoqOjXcLXcnYZspFSe9i0WtkQ8WK7zOnTp1FVVYWBgQF8+OGHCA0NpfeRu7yGFkS8p42UJ7sMx3HQ6/VYXFzE8vIy08PuWhDxBw4cgE6nk7XLPHnyxMkuU1hYqDkjpdb+2N3djYWFBbz88suIjIx0scvk5OTQ/Ba5Z9QAOcSyWpUR8dJ6iq+//hpVVVXo6enBr3/9a1l7s1RypcVKEtMfpRspUk+xbds2l4GUTqeDXq+HXq/HysoK088VKS1Wi4gnGymdTkdpgOL+LelAqqCgwO1GypO02B8HBgawsLCAV199FeHh4UwDKTVADun1KW2kxAOpEydO4MyZM6iurkZnZyfeffddWRqgVFoR8YT+KP3vkoGUGChE6in0ej10Oh3MZjPsdjvTtogg4tXcR2JEvJgGKK6nkA6k8vPzNQE5tLhbxsbGMD8/j2984xsIDw93GUiRbZJ4IPUsM1LigdTs7CzOnj0Lm82G9vZ2/OxnP2MaSGlBxHvllVZ5D1l/xRLnt9yVZ5IHHPEhQqm0WE6s1D6xXaajowMffvgh9Ho9Tp8+jfPnzyvaZQD50mIludtIebLL3LlzBwCQmJjIbJdZi/2RbKR0Op0LDbC6upraZYgVpL+/XxOQQy0inuM4dHV1ITU1Fd/85jeZ7DKAcmmxnFipfWK7TFtbG/7whz+A4zh8/vnnTHYZYH0yUkSe7DLEMpOQkMBsl1kPRLxer5e1y5A8HnnA6enpUX3Y1IKI1+v16O3tRVJSEr75zW/K1lNI81sAO5BDLIKIV3pN4oFUU1MTPv74Y3Achz/96U+y9RRy8gTkcCd31D6j0eh2IHX58mXY7XZs2LCBeSC1Hoh4g8GAkpIS2r8lN5DieR5dXV3MpcVEExMTaGlpwZ49e5jvIx8fHwwMDCAhIQGvvvqq7ECKFMKLD3uE2qcWET81NeXxNRGnSExMDA4dOoSGhgZ89tlnAIDf//73TAMpcn3i0mIWubOtkXqKjRs3ugykLly4gJWVFVpczzJYEd9HahDxgiDA19eX1qlIB1KPHz9GWVkZHUhZLBZ0dnZqykipRcT7+flhdHQUsbGx+Lu/+zumgRSgXFrslVfrKe8h67+I3NllLl++7PSAk5GRgdraWubSYiKSkVLja+7t7QUAfP/738fc3ByTXWatGSlPGymxXWZqagqffPIJuru7UVVVRf31SnYZudJiJRFEvBy1j9AAS0pK0NraSifKT548gV6vh9lsVv19AtTZ1jo7O+lGitUuk5qa+kwzUkQcx2F4eBh2ux3f+973MDMz42KXIR/eYruMGiAHESsiXmyXGRsbw5///GcKqbDZbC40QDk1NTWtGyJeyS5jMBhgNptV9+sA6hHxZCMltjdL81viB5zk5GS3Gyml61ODiOc4DlNTU7Db7fjOd75D7yOlgZQaIAeRp4yUWOKBFOnd6unpQWVlJR3k8DxPaYByWk9EvE6n8ziQ8vHxgZ+fn6otmxZEPNlIHT9+3G09hXQglZCQ4HYj5UmsGSkinU6HhYUF2O12fPvb36bwBelAqqCgwOl+Viot9nR98fHxHjdS4oFUb28vzp49i97eXlRUVKCuro7am+Pj493+3VoQ8YuLi6itrXXZSCkNpEwmE0wmk6rsr5aMlHgj5S6/JR5IkWGL1cpWWuyVV+sh7yHrv6CkdhnywXT69GkYDAYsLS0hIiKC2S6zFkS8mNpH7DIkv0WyScQuQ2xXajNSHR0dGB8fx4EDB5i/xmQyYWhoCBaLBbt27aIPgY2NjTR8TR4CxR9MZCOlBhHPYn/U6XRIT09Heno6Tpw4gfLycly+fBkzMzPMdhmtiHiSkZJupOTsMlVVVZTwtLCwgNjYWGa7zOzsLOrr67F161ZNiHhiOZHaZW7cuIEbN24gMTERPM8jLy9PM5BDLSI+MDAQIyMjyMvLw86dOynkREwDlNplyGtSi4j3lJEiktplysvLce3aNSwtLeHtt99msstoRcS7s62J81vSegqTyYS5uTkkJiYy30drRcSTn+m8vDynegoykCJAoZycnGeakRIrLCwM4+PjyMnJwfbt2yEIAmpra2lon4BgpBkRViCHWCyIeOlAqry8HDdv3gQA/PSnP6WwnKysLLdDILnSYhaRjZT0PvI0kPL398f09LSq38taEfEEyJGeng6O41zqKaQDqczMTE1Ajv7+fvT19THbH8nGbWpqCpmZmdi6dSvTQApQf9gEVjNSnu4j6UCqvLwcd+/eBeC4j1gGUuT6tCLixZ8BSgOp4OBg1aXFXnm1FnkPWf/FFR4ejgMHDmD//v00fF1dXY2rV6+irKyMyS6zFkS8dCMlpgHK2WX0ej0iIyNVWai0IOLFRYMkv3XgwAGa36qpqUFFRYWTXcZsNmsCcpCMFOvkjsBCAOCf/umf6DWJyzPJA4744YBspLQg4qUWLrGkdpmWlhacOXMGCwsLuHz5MsrLy13KM+WkJWs3Ojoqu5GSs8sIgkBpgDqdDlFRUaqmkWtBxJNJcXx8PLXLEFpiWVkZIiIi6CDBZDJpykgJgqDK/ujn50cJcv/wD/9A7yMluwwrkEMsFvujXD3FxYsXMTc3h0uXLtFyUU/5LUAbIn5sbEx2I0XqKbZt24ahoSH64E7qKXQ6HSIjI1WXX2tFxJPNVUpKihNQ6N69e7h7967TQMpoNFIgh9qMVGhoKDMiPiAggB6k/v7v/x5tbW2yNMCkpCSn91aptFhOnjJSRNKBVG1tLa5cuQIAuHjxIqqqqhQHUoA2RPzk5CRaW1tdNlKknkIKFKqrq4PJZALHcYiIiNB02NSKiJfLb5GBVFJSEh226PV61UAOcn1qEPEhISH09/HLL7+Mjo4OSgMkAyme5xEbG+v03g4MDKjOSIkR8e42+NKBVE1NDW7cuAGDwaDqWcIrr9Yi7yHrv4nENECS3xIEQdEuA3guLXYnlo2U2C4zODiI27dvU/jCG2+84VKeKaf1RMSLw9dydpng4GCsrKyomhqLM1KsEtMfCXhBuk2qr6+HyWSiDziJiYmagBxqEfE6nQ7x8fGYmprC1q1bERcX5xS+dmeXATyXFrsTyyZBape5e/cubDYbBgYG8OabbzLZZdaCiJdupNzZZUh5ZlhYGJaXl1V9n8bGxtaEiCcP7oQGSAYJUrtMTEzMM81IERkMBqSlpWFmZgYbN25EbGysU36LbJPkfq4JkGM9MlJiRUREOA2k7t+/j/r6egwODuJnP/sZ3SZ5GkjJlRazSG4jJR1IEesuGUhFRkZiaWlJ1fdJKyKelBaTB3cxUEg8kCLDloiICObSYrFIRor14EOw+OfOnaMdcoIgKA6kADYgh1TiHik5cRyH2NhYxMbG0oHUw4cPqT34nXfeYRpIiUuLtdgfxdQ+6UCKbNzIQCo6OhqLi4uqvk9aMlKAYwARGxtL7+sjR46gqanJKb9FBlIWiwXBwcGa3C1qEfF+fn7geR6XL19Wfdj0yqu1yHvI+m8ocX5LyS4zMTHBXFpMxJqREisyMhIGgwEGgwGvvvoqbDYbDV97ssuQjZRaRHxTU5PHjZSPjw/9RT85OYnq6moKOPjoo49kaYByWktGSrqR8mSXCQkJweTkJNLT01UfNv39/VUh4slmkzwcs9hlJiYmNGWkBEFgtj+S8kyz2Qy9Xo+XXnoJtbW1THYZViCHWAQR72kjJbXLWK1W3L59GwDwxz/+UZVdBlg7Il5KA2xsbIQgCHj06BEePnyIiIgIjI+PIy0tTROQQwsiftOmTUhISJCtpzh37hxycnLA8zxSU1MxMTGhGsihFhFPBlK1tbXQ6XQ4efIk6urqKA3Q00BKa0ZKCRHv7++PHTt2YMeOHRgcHKR2awD45JNPmAZSwNoQ8eKNlLuB1J07d3D79m3ExcVhaGgIqampqg4JgiBoRsRv3boVSUlJ2Llzp0s9hXQgRTJSaoAcgDpEPKmnaG1tRXNzM44ePYq6ujpZGqD0QK4lIyVGxLv7TAoODsbu3btRXFyM3t5eCIKA8vJyAMCpU6eovdnTQApQPmzKiSDixa9Jr9cjOzsb2dnZdCAlCAIdSCUnJ6O/vx+pqamqM6VqEfFaSou98mqt8h6y/ptLzi5jtVqpXYY8lKiZlmrJSJGNVH5+Pp2WytllYmNj6aYkICBAE5BDrW0tMDAQWVlZKC0tRVFRETiOY7LLKJUWu5PVavW4kZKzy9y7dw/Ly8toaGjABx98IEsDlEpaWqzm+qQbKSW7DLmP1BwS1oKIz83NpRS3ubk52r8lZ5fx8/NTDeQA2DJSYoWEhKCwsBDXr1/Hli1bwHEck11GDORYT0S8nF3m4cOHWFxcRGNjI37/+9/L0gClWmtGSryRcldPUVVVhYCAAHofqXkQ0oqIr6qqQnZ2Nt0CiO3NcgMpHx+fZ5aREisyMhJbtmzBnTt3wPM8OI5zGUjxPO+SX2EFckjlLiNFJDeQevToERYWFtDS0oKPP/6YaSC1sLCAuro62mem5vpCQ0OdNlLiegrSLSUeSGm5j/r7+9Hf368ZEU8+Z6U0QHEhPKE9ym2klKQGEU8GUoGBgSgrK6Pf24qKClpPQQabcoMJq1U9Il5pIyXt36qqqsLjx48xNzeHtrY2/PnPf2YaSD1LRLxXXq23vIesvyFJ7TKEwAMAH3zwAZNdBlh7RopIbJeZmpqiDziXLl1CaWkpUlJS0NbWpumQoBYRT0K0RUVFCAwMdLLLkPJMqV2GtbRYLHFGimUj5ePjA57nUVtbi6mpKRQVFaGqqopukzzZZbRkpEZGRtDV1eV2IyW1yxCUb3V1NQDgd7/7HZNdBnAP5PAkuY2UyWSiD8pjY2P0AYfYZTIyMtDY2IjNmzervo+0IuJ37dqFkJAQJrsM2Ujt2rWL+e9Ri4j38/PDli1bqF1r27ZtqKqqwldffYVz587R6gVSQSCW2sMmoIyIl6unEAQBDQ0NAEAf3C0Wi+K2fL3sj1IaoHgg5ePjg6ysLNhsNmzcuFF11k4rIn7v3r0IDQ1lGkhpAXKQQ0JWVhbTRiowMBBFRUXo7e3F9PQ0Nm3ahJqaGsWBFLC6kVpPRLy47JyALqxWK1paWgAAp0+fZhpIAc6lxaxqbW112UiJ7c3isvO6ujr4+fkhJycH1dXVmg6bWhDxALBv3z5EREQ42ZulA6n8/HyYTCbm0mKxWDJSYoWGhmLPnj0YGRmBzWaDxWKBzWajAynyLCIdSAFsQA6ppqam0NTUhJ07d6rabHrl1VrlPWT9DUqc3xJ/eEvLMwsLC13AAp5Kiz1JaSMVEBDgZJchUAG73Y4nT57QA5qSXUYrIl5aWsxil9HpdKoPCWtFxBcXF6O4uFjRLsNxHAVyqO0jA9gmwDqdDpmZmTCZTKiurqaHHBa7jHgjpSYjJQiCx41USEiIi12msrISKysrTq9NyS4jLi3WkpEiGympXYZYd4ldhvw8qD0krBURT7ZJXV1ddNhSVVUFf39/+oATExND7yOl0mKp1KC9yTYuODgYDQ0NKCgowOjoKK5cuYKrV6869W9Jf+d4Ki32JKWNlHggRbqlqqqqsLKygtraWlqFoJRjXSsinmwZlAZSGRkZsNvtqjNSLS0ta0LEHzlyBIcOHXIZSJGtLs/z1Hont5FSkpr7iAykoqOj8d577yEnJwcjIyNOAyme5+k2SSwWIIecPG2kxAMpcbeUIAhYWVlBU1MTbty4AZ7nFW2ua0HEizdSUnuzdCCVnZ2NlZUVAFAN5FCTkQJWEfH5+fk4efIkjh07RgdShAYoHUiR16QGyAGsIuLVHMy88mo95D1k/Y3LYDB4LM+U2mVYS4vFUouIj4yMpDaQubk5JCcnM9llADYgh1QdHR0eN1JSuwwh3Q0MDABweN1Z7DLk+tYDEe/JLhMaGoqMjAzVpcXk4U4tIp7Y1o4cOQJfX19Zu4w4v6XX69eUkWJBxBO7TFxcHHp6ejAxMYHExEQ8efKE2mXI91TOoqcl26KEiDeZTNi8eTM2b95M7TKCIGBkZAQcx+Hs2bOyNEA5yQE5lFRTU+NE7ZPLb1mtVpSVleHBgweIjIxEVlaWpoyUIAhISkrShIg/ceIETCaTbH6LbNxSU1Oh0+lUAzmA1cOmp4wUEcdxFCoyPDyM4eFhxMXFMQ2kAO09Up42UnIDqaqqKkxMTECn06G0tJRpIAU4lxazitgfyWtSGkjFx8cjKytLdUZqrYj45557Dn5+fk6F8GQgRfq3yECKpbRYKrI585SRIiIDqczMTExPT6Ovrw/h4eFMAylgNSOlBRHvbiMlN5Cqrq7GzMwMdDodbt68CZ7nXeop5KTV/ijeSLEMpLKzs9HU1KTpsKkWEe+VV+sh7yHLKyolu0xubi6Gh4cREBCgytdMQApqPiCGhobQ29uLQ4cOYefOnXTjJgiCi12msLAQ/v7+moAcgHJGSixSnhkSEoLPP/8ceXl56OzsZLLLkI2UWkS8IAhuEfFiuwwJ2FutVjx69AiA48Hax8eHyS6jJSNF7I9iap87u0xtbS38/PyQn5+PwcFBmM1mVUCOtdofi4uLZcszpXYZ1tJiqYj9kWUjRewyUVFR+PTTT5GRkYHm5mYnGqA7uwzpI1OLiPe0kSIb2dzcXMzMzNAHHNJ509TUhKCgIKbNI7E/FhUVMV+bnP1RnN8i9RTkugIDA1FQUICBgQFVpcWA+owU4NhIdXR00D4wuYFUeno6HUgZjUbZjRSL1CDiyUAqKSkJH3/8MZKSkuhAitRTWCwW2YdLd6XFSvK0kZIbSJGfNcAB/bHZbLL2ZqnWCxEvracg26THjx8jNDQUhYWF6O/v19QjpQUR39bWhuLiYhw4cMCpnsLdQApgKy2Wihw2lTZS4oFUZmYm/vjHPyIuLo55ILWWjJS7jZR0IEWeRS5dugTAMYhobGxkGkiJS4u98uovLe8hyytZydllbDYb5ufn4evri6tXrzLZZQBtGSnpRorFLhMbG6sJyKEmIyW+voCAALz88ssAQGmAnuwyWg4Jw8PD6O7uZkLEEwuTxWLBz372MxgMBiwvL8vSAOUecMhGSgsiXu41ubPLVFZWYmlpCSaTCbdv33YbvpZKDsjB8jXAKpBDjgYotcvEx8erLi0WHxLU2B+rqqpgNpvxzW9+EwBk7TI8z6OwsJAe+LRmpDo6Opg2UmazGVu3bsWWLVvw85//HHa7HVNTU/jqq6+c+rfk8luA+9JiT/K0kZKrp7BarXj48CFWVlbg5+eHhw8fytIA5SQH5GD5GmB1IyUdSJFt0hdffEEHUgkJCZoyUloQ8VVVVfDz88N3vvMdrKysuNRTSAdSgLbDJkHEs2ykyECqqKgI7777LhYWFjA4OIjPP/8cvr6+dJskN5ACVjNSau2P7jZS0oEUyW/dunULgON7WlFRIVtPISer1YGIV5ORklL7pPUU5DNEPJBKTEzUDORgzUgRVVdXw9fXF9/97nexvLzsMpBKTk6mQCEyDNGakWJFxIeGhmLv3r3Ys2cP3n33XczNzaG7uxt/+tOfXOop3N1Hat0tXnm1XvIesrzyKLFdRvyAc//+fSa7DCktXk9EvDu7TGNjIwDHA1tQUBCSk5MVf4FrsT/KbaTENEA5u4zFYkFlZaWmwyagHhE/MTGBF198ERaLxal/i9AASbdUQkICOI5jKi12d30siHixXeb+/fsoLS1FWFgYDV8r2WVGRkY0IeI9baRCQkKwZ88e7N69Gz09PfQBx2azAXBs9qKiopjsMlrsj8S2tmXLFjqxJnaZ2dlZ+oBz9epVXL16FSkpKfQ+0grkUHN9PT09GBsbw3PPPYeNGzeis7OTbpMIDVBcds5xnGogh/j6WBDx4noKch8FBAS4pQFK5a602JOUNlIRERE4ePAgDhw4gPb2dgiCgNraWgiCAMDxO3BgYIBpILUeiHi9Xo/CwkIUFhbSgZQgCE4DKXIfqSktBlbtj2oeqPv7+zEyMoLjx49j8+bNsvUUZFNCBlLiw6bajJTJZFLcSPn6+mLDhg3YsGEDHjx4gEuXLsFoNDIPpNaSkZJDxIu3SeKNG6mnABwH3NHRUaaB1FoR8UajEUajUXYgdebMGZw/f57WUwiCoDojpQURPzg4iJGRERw5cgRbt26l9mYykIqMjKTPIuT3vVogh1derbe8hyyvmGU0Gj3mt6R2GWB1I6UmRNve3s68kSJ2mT179uCNN95AQEAAPeQo2WUAx5RLWlqsJGJ/lPuAcGeXuXDhAr1eVruMVkS8uLSY4zhFu4zFYoG/v79qIAfJSKmlP9bW1iIyMhI//OEPnfq3lOwygLpDArE/7t692+Of4zgO8fHxiI+Px8GDB/Hmm2/CZDJBEAQ8efJE0S5Drm+tGSmx/Pz8ZO0yX3/9NQBHp1pTUxOTXUYOyMEiMbVPTAOUy29FRUXR+0hLRkoLIr6+vh5hYWH4yU9+4pTfIvUU0vwWoC0jRRDxShsp8UDq6NGjeOutt2A0GlFWVoaHDx8qDqQAZSCHnGw2m1NGSizxQGpgYIAebk6dOgXAYaVrb29nGkiJS4vVIOLFGym5egqr1dEtd+vWLTqQMpvNmjJSdXV1KCwsVGV/bGxsREhICP71X/8V/f399D1yN5ACtB0SWBHxer2eDqRmZmbwzjvvgOM43L17F3fv3nWpp5CT1oyUO/qjdCBFYDlkIBUbG4uenh6mgRS5vrUg4uXqKaQDKZ7nYTabVQM5vPJqPeU9ZHmlSWK7DCnPFNtl8vLyUFhYCEEQNGek1CDiGxsbsbi4iJMnTyIxMdHFLhMXF0dxx2SixVJa7O76WDZSxC6zc+dOnDlzBk+ePMHMzAw+//xzWRqgVFoR8TabTXaS784uc/PmTfrvR0ZGMDs7y2SX0ZK1IxspAuSQlmfK2WXItFQtkENNRoqopaUFCwsLeOWVV5CYmMhkl2EpLXZ3fSwbKbFd5syZM6ioqMD4+DizXaa7u9ultFhJhP4ot5Fyl9+6cuUKAMd9NDMzg4WFBSYL7nog4uXqKcj3LjAwkG52rFb20mIiLfbHjo4OzM/P48UXX0RiYiIdtngaSLGUFru7vrCwMMWNVFRUFEpKSnDgwAGcPXsWFRUVGB4exu9+9zs6kOJ53u2Dr1xpsZI8baQIDZDnedmBlE6nw/LyMpaWlpgOTQQRr9b+SIAcOp3OqZ7C3UDKYrG43Uh5khZEfG9vL+bm5vDKK68gISHBxd4sN5BiKS2WEwu1TzyQOnLkCM6ePYvKykoMDAzgN7/5DdNAar0R8aSeYsuWLU4Dqa+++gocx8FoNKo6bHrl1XrKe8jyas2KjIx0scuQ8DXHcYiOjma2y6wHIl6n0znZZciH98WLF3Hp0iVkZGSA53lMTExozkipRcS3tLQgLS0N3/72t5nsMoDzRopVrIh4sV2mv78f7733Hnx9fXHhwgVcunRJ0S4DrE9GikhqlxHnt4hdJiYmhtkuIwfkYL0+gojX6XQe7TIkmzQ+Pq76kKAFEQ+Abh1ef/11t3YZi8XidBjVcthsampi2kiR/NbWrVvR09OD3/zmNzAajfj6669x4cIF5OTkgOd5p22SVJ6AHO7kbrOpVE8BALm5uZicnGQa/BD7o9qMlHgjpdfrnezN5D4SD6QsFgtGR0c1ATna2tqwd+9e5vuI4zh0dXUhMTERr7/+OtNAirym9cxIiSUeSHV0dOC3v/0t9Ho9Tp06xTSQIte3Xoh4TwMpMpTKz89nHkiRw+ZaEPEGg0GWBkgGUgSWMzw8rAnI0dLSwpSRItLr9ejr60NcXBxef/112Gw2CILgcSAFrGakngUiXjyQam9vx0cffYT8/HxVQA6vvFpPeQ9ZXq2bxHYZ8QNOU1MTGhsbERMTA57naXmmnNYbER8QEICioiIUFRU52WX+/Oc/g+M4mEwmzM7Owm63M324aAnRko3U/v373dplbt26Re0yPM8jOzt7TUAONdS+jo4O2O12vP766/S/oWSXUSotlhMrIl6v1yMrKwtZWVmYm5vDJ598go6ODtTV1aGuro7JLrMWRPyWLVtc7iN3dpmamhrodDqYTCasrKww30da7I9iRLySXYZ0S2VlZT3TjJRYfX19sNvtFL5Ahi0kvyXu3yJSKi2WE7mPlBDx0nqKzz77DB0dHaitrUVdXZ1ifgtYn4yUWJ4GUnq9HiaTSdXPu5aMlBgRbzQaPQ6kSNl5RkaGqtJiIpKRUmN/HBkZgd1ux9///d9jeXmZaSClVFrs6fqUNlLigdT4+Di++OILdHR0oKamBnV1dfQ98jSQIqXFWhDxUvujeCAlBgpVVFTg0aNHMBqN8PX1VeUe0dIjJd5IiYFCpJ6CDKQIUIhYdwn9UU1GShAEVfZHjuMwOTmpevjllVfrLe8hy6tnIjENcHp6mv7SJeFrObsMsJqRehaIeLFdRhAEfP3111hcXGS2y8iVFrOIbKSk9kexXWZiYoK+R+fPn8eFCxdgt9sREhLCbJfRioi3Wq0UEU+IgOJtErHLhIWF0QfltWSk1CDiDQYD+vv7kZ+fj4MHD8qWZ5KHQPEDrXgjxSpPGSkiqV2msrISZ8+excLCAj744ANanllYWOj2AKAVEU/oj9KNlCe7jF6vx/LyMiIiIrCyssJ0X4hLi7Ug4knRc1JSkgsN8P79+zS/pfU+0oKIN5lMGBoaQl5eHvbv3++U3yI0QNItJX6P1pKR8vRwJx1IVVRU4MKFC1heXsavfvUrSgP0NJBab0S8dCBFYDkNDQ0wGo1YXFxETEwM8yBhrYh4khNzN5BKSEigsBytfWQDAwOqqH2BgYEYGRlBVlYW9u3bR7dJdXV1TvZm8UCKvCatiHhPr0k6kHry5AkuX74MAHjnnXdc6incSRAE1RkpdxspUk8hHkhVV1ejpqYGvr6+mJ+fx9atW5nvI1JavJ6IeK+8+kvJe8jy6pnL39+fyS4TGRmJpqYmFBUVPZOMFJFOp8Po6Cg4jsP//J//E93d3Ux2GaXSYjmxIuKDgoKwa9cu2i312WefYWxsDLdu3UJZWRmTXUZLRmp4eFi2tFhMA5Szy+j1eoSHh6v60FsrIt5deabNZnOyy4SFhTGXFotF7I+s1D69Xo+pqSkAwI9+9CN0dXXBal0tz3Rnl1EqLZaTOCPlyf4otst0dXXhyy+/xOjoKG7evIny8nKnbZK7+4jlsCmVu42UmAY4MzNDYTlXrlzB1atXYTAYEB4erno7shZEvLt6CjLgIcOWoKAg5tJi6fWpQcQbjUbMz88DAH74wx9SiqN4IEW22+KfN6XSYjmJbWuebG5RUVE4dOgQDh48iLa2Npw5cwZjY2O4ceMGKioq6CHZ00P5WhDxUvujp4HUxYsX6X2kttdObUaKlBbzPO+2nqK8vNxpIBUQECC7kVKSIAiqEPHi3zHf/e536e8jpYEUAXKoyUixIOKlA6mmpiZcuHAB8/PzuHbtGqxWK72PPH3fnjUi3iuvnqW8hyyv/qIS22Xa2troA05lZSUtglXjqV8rIj4sLIx+IE5OTtKHwIsXLzrhjrOzsymQQ21GSq39MSgoCOPj49i+fTvS09Od7DKkPJPneRfCl3gjxSp3GSmxpHaZ27dv4/HjxxgeHsabb74pG76Waj0R8e7sMqQ809/fHysrK6osk2tFxJNDPqEBurPLkO+n2oyUWvsjgUFMTExgy5Yt9O8lNEB3+S1gfTNSYpnNZmzbtg3btm3D8PAw7t69S+ELb7zxhiwNUKq1IOKlpcVK9RRBQUFYWlpStcUiGSktiPikpCT6UCqtpzh16pTTQColJUVVaTGRWvujTqdDfHw8pqamsGHDBqSmpsJqXa2ncDeQAlY3UloQ8Z6ujwykdu7cif7+fty/fx9Wq5X+PiLbJE8DKbnSYhbJbaSkAykCXCEDqbCwMCwuLqoCOU1OTqK1tVUzIj41NRWpqakoLi52qacgAyme5xEXF6fpsKkWEa/X65GamorZ2VkUFhYiOTnZaSBF6iny8vJcPh+0bKQI/VHN565XXj0LeQ9ZXv2niOM4+kFA8luCIKC5uRmffvqpbHmmnLSEaDs6OmQR8YGBgW7tMr6+vlhcXERKSopqy4JWRPyGDRsQHR1Nw9ckoC5nl5mdnWUuLSYi9kc1iHgycdTr9Xj99ddRW1srSwOU2mXIRkptH5kSIl5ql7HZbCgtLQUAfPzxx8x2GZbDplTuNlJiuwzZkhK7jNlsxvz8PFJSUlRn7dQi4gm1b+PGjYiLi1PMb+Xm5mJ2dpa5tJhICyI+PDwcBoMBOp0O3/rWt1BXV0evKzAw0Kl/SyxPpcXuxIKIl6unuHbtGgDgk08+cWtvlkqL/ZEg4k+ePOn0/5N6CrJNEg+kgoODMTMzg+TkZM1ADlaRjdSmTZton53SQGpmZkZ2I+VJahHxpJ7CbDaD4zi8/PLLNAcspQFK/3usQA6x3GWkxPL19cXGjRuxceNGjI+Po6qqipYdf/rpp0wDKWD9EPHibZLcQCosLAxTU1NITk5WlZHSan9cWFjApk2bkJKSIltPIe7fSk9Px+zsrKaNlNVqRWxsrNvqFq+8+kvJe8jy6j9d4vwWKc8U22XEH97iBxzxIWE9MlJiSe0yt27dQnt7O1paWvD2228z2WVIRkoOyOFJcvZHX19fj3YZkslQs2Xr7OzE6Ogo9u7dy/w1ZCOVl5dHKW7u7DLkPQoNDdUE5KipqVFlfzSZTEhJScH8/Dx27twJX19fJrvMemekiDiOQ0JCAhISEqhd5s6dO+jq6kJzczN++ctfMtll1hMRL85vjYyMOOW3zp8/Tx9G1QwtSEZKCyI+NzeXbgHk8lvR0dF02BIYGAhBEFQDOchhk/U+8vf3R3Z2Ni5evIitW7fC19fXqZ7CXX5LvJHSgoj3dB+JB1J1dXW4f/8+xsfH0dLSgl//+tdMAykxkENLRkq8kRIPpMTdUmQgRUASaoYWa0HEZ2dn00OynL2ZDKQKCgrg5+dHgRxqDglqEfHBwcHgeR5Xr17Fxo0b4ePj4zKQ4nmeZhjFYgFySKWEiJcbSD18+BALCwtobW3Fhx9+CJ7nXezNUklLi1klt5ES25vlBlIRERGqN1JaEPFeefWs5D1kefVXJXF5pju7DM/zSE5OVlVaTER6pFgR8TqdDmlpaXj48CECAgJQUlKCqqoqapch5ZkFBQUuthMtGamhoSFFRLzULiMIAh4+fAgAeP/992VpgHLSgoiX20i5s8vcuHEDN27cQHx8PHp6erB582ZNGSkt9sft27cjKCiIhq/Fdhmz2Uzfo7i4OObSYrHIIYEVEa/X65GdnU0PCfv370dVVRWTXUZLjxQLIj4sLAz79u3D3r170dXVRcuXAeDDDz902iYp3UeeDglykkPEi/Nb09PTdLN1+fJlXLlyhf7Mb9y4UTOQg1XEtlZUVITQ0FAnGmBtbS3Nb5FDclRUlNuNlCepRcQTGmBDQwO9Z6uqqhQHUoDn0mJ3cpeREis6OtppICUIAv05/Oijj6i9WenAoMW2JreREtub5QZSGRkZaG5uVp2RslqtCAkJ0YSI37VrF8LDw536t9wNpPr6+phKi8Uih82MjAwm+yOhAZKccVFREaqrq2k9hbuBFMAG5JCKIOLd2R+lAylST1FbWwsA+Oyzz5gGUsBqabGa+8grr56VvIcsr/5qpWSXMZlMMBgMqrzu9fX1mhHx27dvd1ueSfq3yAOOwWBQDeQAnFvtlUTsMgsLC3jw4AGKioowNTUlW54ptct4Ki1Wuj5PGympXYbkgOx2O548eULzIEp2mfVCxMvZZchh4tGjRwgPD4evr6/qQ8JaEfFyNECxXYbnedrVJQgCU2mxWGrsjxzHITExETqdDo8fP8aWLVswNTVF81uEBlhYWOhiK/VUWqx0fZ7sj/7+/jS/NTQ0BKvV0QdGvsfksOApvwWsHRFPNlLu6inu3buHu3fvIiYmBj4+PtDpdKruo7Ui4km3lLie4tSpU/D19UVubi4dSHEcR4EcajJSauyPZCBFNkU8z2NqaoppIEUyUlr6yDwh4uUGUhUVFVheXobNZoNer2caSK0FEZ+QkEAPmHq9ng6k5ubm6MaNDKSSkpJgMBhUHxIIIl7N9ka8kSLDFnE9BRlIEaBQXFwcvY/UZqQIIp7lPiL1FGFhYaitrUV+fj4mJyeZBlIsQA6vvPpLynvI8uqvXnJ2GavViubmZtjtdvz2t7+l/VtKv1hJ5kMNIp7Y1sSbBHF5ppxdJj09XXNGSisift++ffDx8WGyy7CWFovFkpESKzg4GLt370Z9fT2MRiPtbGK1ywDri4iXs8sIgoCOjg4AjgyXHA1QTgTIoSUjJb6PpHYZcf+Wv78/MjMz0dnZqemQkJKSwpyRAlbtjwcPHoTJZMLMzAzdJl25cgVXrlyh3VKElkk2Umq2bGoR8YQG2N7ejrGxMaSnp9NtKaEBWiwW2WHGemakiNzVU5D76IsvvmDKb5HrWw9EvLieQkxMJAOprKws1aXFYkQ8S0ZK/Jr0ej2OHDkCPz8/twMpnueRlZUFg8GAlpYWTYdNVkQ8GUjFxMSgv78fAwMDSE1NZRpIAWxADqlIRsqd/dFkMrkMpKxWK4aGhsBxHM6ePcs0kALWhogn95EcDZDk28rKyhAeHo6cnBw0NzdrAnJoQcTrdDocO3YM/v7+sgMpUghPBlKspcVeefWXkveQ5dV/KSmVZ3qyy3gqLfYkpY2U2C7T2tpKrWkAUFZWhvn5eSa7zHoh4qV2GfLBROwyWVlZmJiYcKH2KUnusKmkkZERetjctWuXU/+WO7sMa2mxVGoQ8cQuYzab0dHRAYvFgu7ubmqXEX94Sx9wPJUWe5In+6PYLnP06FFqlxEEgb42juOY7DJaEfFSap/ZbMbWrVuxdetWp/zW6dOnce7cOeTk5GB8fBx+fn7r3kcm1djYGAVy7Nmzx2mb9ODBA9y7d88lv8VaWiyVGvsjqacICwvDxx9/jNzcXHR3d7vUU6SkpLg8lJLDphb7oztEvE6nkx1IPXr0CADogINlIKUVEU+ofWQjJR1ISYFC+fn5GB0dha+vryYghxZE/J49e7B//37ZgRSBe+Tn59PXsJaMFAv9kQykYmNj8cc//hHp6elob293+n5ZLBbZgRQLkENOZCMlh4gn9ubs7GzMzc3RYcvdu3cBOGyaoaGhTAOp/v5+1RkpuY2Uu4FUdXU1/P39UVBQgJGREVWlxV559azlPWR59V9W0vJMJbvMs8pIEel0OqSnpyMtLQ3t7e3w9fVFYGAgk10GcHzorTciPigoCMXFxbR/izwoz8zMQK/X4/z580x2GXJ9UVFRqu2PwKptTbpNkrPLJCQkqC4t1oqIFwQB/v7+eOGFF8BxnJNdhoSvpXYZckjQkpFisT8Su0x2djZ+/vOfQ6/Xw2w2M9llyGtSi4hvamryaH8U57dIj1N1dTXm5+dhNBpx9epV2r+lJJKRWgsi3mAwuNAAxfmttLQ0JCYmqi4tFh82tVD7Xn75Zeh0OprfItukoKAgmk0ixDNySFDz+0gNIp4MpAoKCvCLX/wCy8vL0Ol0TgMpsk2S27hpQcQrbaSio6Nx+PBhlJSU0IFUVVUVFhcX4ePjg1u3bjENpID1QcS7G0idO3cOFy9eRGZmJpKSklSXFmtFxFdVVcFkMuGb3/wmOI6jA6mKigpqbyabW2JlJUCO9cxIiWUymbB582Zs3rwZv/jFLzA/P4/5+XnZegq5YYGWrJ0nRLy7gVR5eTkdAqoBcnjl1bOU95Dl1X8Lie0ycvmtwsJC1NfXIyYm5pllpIgIIv6ll16iuGOpXSYzMxMWi4XaZVhLi+WuLyAgQBERz3EcLc8MCQnBxYsXVdll3JUWe5K4j0xuIyW2y4yNjdH36N69ewAcdhbSbaQ06deCiCcbKXFpsZJdxmKxoK6uTjOQQy0ifmxsDM8//zw2btzIZJdhLS2Wuz4WRDzHcUhKSkJSUhKioqJw4cIFxMXFURogyW9ZLBZZyyvZSHkCckilhIj39/fH9u3bsX37dprfInZiwPHAFhoa6kIDlJNWRLx0I+Upv0XqKWw2m6rSYkC7/XF4eBgnTpzAli1bnOopGhsb4evrSzduZCDFWlosd30s9kcykEpPT0diYiLOnTuHiIgI5oEUC5BDKnIfiTNSYkkHUqTsvK6uDoDjfezs7GQaSJHS4rUi4qX2ZulAymKxoKqqSlVpMaCtR6q/vx9DQ0M4evQotm3bJksDJLCc2NhYeh9pyUix2h/JQConJwePHz/G2bNnVQ2/vPLqWct7yPLqv5VI+DotLc3pAefu3buw2+0IDg7Gw4cPmewy4kOCmowU2UgRIIc7u0x9fT1MJhPy8vIQFBSkGshBEPHbt29XZVurqqpCVFQUvv3tb6uyywDqDglqEPEhISHYvXs3duzYgTfeeAOBgYHo7OxEfX29ol2GXN962h/d2WWuX79Or7eiooLJLrNeiHixXaarqwtWq9XFLhMUFKQayKE2I0VUU1OD8PBw/MM//INT/9aVK1dc+rfI4EDLfaQGEU/yW3v27MEbb7wBPz8/NDY2orq6mua3eJ5HVFSU7NeTQ4IaRLwn25qnegrAsSEkh2Kl6ftaEfFkIyWtpyD3UUVFBR1IBQcHa85IqUXE22w2hIaG4oc//KGTBdzdQIq8JkB9RmpgYEARES8eSJWUlODNN9+E0WhEdXU1KisraXk9z/Nuvw8EyLFeiHhib960aZPTQOrs2bMAHPd9Q0MD00CKXF98fLyqjJR4IyVXTyEeSEVERFBrs5rSYkA7Ir6urk41kMMrr561vIcsr/7bysfHh+a3pOWZ0g9vuV/m7kqLPUncIyW3kfJkl+E4Du3t7QgJCWGyyxD7o5rJ3fDwsBOQQ2yXIeWZYrtMVlYWCgsLPW6k3EmL/bGpqQkLCws4evQoUlNTXcozyTbJYrHQrYZaIIf4+lg2UmK7zIULF1BWVgYAzHYZkpFaL0Q8oQEmJia62GWWl5fBcRz6+voQHR3NdKjTYn8UZ6Q4jnPKbw0PD7vkt3Jzc1FYWAhBEFSVFgPaEPHNzc2Yn5/HSy+9hLS0NNq/RfJbMTExNL8VEBAAgK20WE6s9kdxPcXFixdpR5G4nsJdfgtQBnLIiWyk5Kh90oEUyW+RgRTHcRgbG8P09DTTFkKL/VG6kRIPpIi9WTqQslgsqkqLidRkpIja2towNzeH5557Dunp6RTf72kgRTZSFovlmSDiyUCquLgYFy9eRFlZGaampvDJJ5/QgRSpp5C7j+RKi5XkaSPlbiBFyrw5jsPs7Czm5+eZtutaEfFaSou98upZy3vI8upvQuLyTLFdhoSvSf9WUlIS/SXNUlosFSsiXmyX2bdvH9555x0EBQVRuwyhAebn57v19CsBOdx9DSC/SQgODpa1y5CuktDQUGa7DDlsqkXEC4JAEfE6nU7WLnP9+nVcv36d2mXm5+dVZ+1GRkbQ2dmpGhHf2NiIlJQUfPe732Wyy5DXxArkIGJFxIvtMiMjI3j33Xfh7+9P3yPxNsndA47V6lparCRPm4Tw8HDs378f+/btQ2dnJ80mka8JDQ1Ff38/0327VkQ8mezL5bdKS0tx+fJlpKenw2KxYHZ2VhOQo62tTTX9sbm5GUlJSfje977nYm+Wy28B2g+bLBspHx8fOrwYHh7GL3/5S/j6+qK0tBRXrlxxqaeQEwFyrBcintAApQMp0uWWkZGB4eFhpoGUGBGvJiMl3kgZDAbFgRS5j9QeErQg4slQLj4+Ht///veZBlKAcmmxnDxlpMQSD6QGBgbw3nvvwWg04ty5c7h06ZLiQAqQLy1WEkHEe62CXv21yXvI8upvTnJ2merqamqXIYcbNaXFRFarekR8Y2Mj7HY7XnvtNZjNZlRVVUEQBEoDlLPLqAFyECllpIjEdpnDhw/jT3/6E1paWtDZ2Yn/+I//cKEBuntNc3Nzqj70iP1RbiMltcuQTQmxy/j6+mJ8fBxRUVHMdhlAGyJ+9+7dzHaZ/Px8VaXF4utTi4hvaWmh95HJZKLv0VdffUVpgOL8FsBWWiyVUkaKSJzfOnbsGD755BO0tLSgtbUV//7v/+5CA5TTWhDxchspaX6LDFu++OILcBwHX19femhn2YpqQXuLN1Lu6imk+a28vDxVpcVErBkpsTo6OrCysoLXXnsNPj4+9HDjaSC1loyUEiJePJA6ceIEPvvsMzQ3N6OpqQnvvvsu00BKCyJ+YWEBdXV1stQ+TwMpnU4HX19fcBxHN4JK0nIfiUuL5eoppAMpnueRk5OjqrSYiGSk1FD7+vr6sLKygm9961swGAyyQCHpQEoNkEN6fWoR8V559ZeQ95Dl1d+s3NllyDYJcEx4We0yWhHxgiA4baQ82WXy8/NhsVjQ2NioGsjR2dmpGhG/srKC7u5uFBQU4MSJEy7hazm7DMAO5BCLFREfEhKCPXv2YPfu3airq8Nnn32GlZUVfPrppzCbzbR/y51dRisi3mq1ylL7xHaZ2dlZ+h4RGiDgeLhntcusBRFPNlIcx1EaYFdXlwvumBDK6uvrAagHcrBmpIgIuTEvLw/Hjx+XpQGSbinxUIMVyCGWXB+ZnCIiInDw4EEcOHAANTU1OHXqFJaWlvDRRx8hMDCQDhLc5bfWioiX2tak9RTV1dUQBAGXLl1CaWkp7HY7QkJCsLi4yJRVIfbHDRs2aELEk4210kCKwGAAqDoMa0HEGwwG9PX1IScnB8eOHaPbJPFAiud5ZGZmOh2MyEZKLSLeXUaKSDqQqqqqwunTp7G4uMg8kCLX5w7I4elr5DZS7gZSZ86cwblz57CysoLCwkIsLy8z3RfijJQWRDyBqUhpgNKBFIHBqAVyDAwMqEbEe+XVX0reQ5ZXXsHZLkNogIIg4NGjR3j8+DGTXUZLj9TQ0BB6enpkN1Jiu0xLSwv9sHz8+DF0Oh2Cg4OxuLjI/HcR+6NaRDyh9vn6+jqVZ5L3SGqXiY+PR0NDg2ogh9WqDhFPskcA8JOf/ASDg4MQBEHRLqNUWiwnsf3R00HJz8+P2mVGR0fxpz/9CcPDw3j48CEeP36M7Oxs8DzvtE2SSisivrOz02Uj5S6/VVZWhgcPHkCv1yM0NFT192ktiHiz2Yxt27Zh27ZtTvmtL7/8kt6fFosFsbGxmoAcrBkpIo7jMDIyAgD48Y9/TIcbZJskl98CtGWk5PrI5CTObw0MDODzzz/H8PAw7t+/jydPnrjUU8hJS48UQcRLN1JKAymDwYCQkBDV9QlqEfFi+2NQUBB27drlBBSqrq52GUhFRUUxlxaLZbU6EPFKGSkinU6HqakpAMAPf/hDeh9JaYB5eXlOA6m+vj4mIIdYrIh48UCqp6cHX375JYaHh3Hv3j1UVlYqDqQA19JiFrnbSIntzWJYDhlIGY1GhISEqAJNabE/euXVX0reQ5ZXXkkkpQGy2GUAx4dyTEyM28m3nKxWZUS8TqdDRkYGMjIysLCwgNu3b+POnTsYGxvDO++8w2SXWSsiXkrtE9tlent76YS7trYWRqMRKysriI6OZrbLaEXEV1VVITU1FaGhoQgNDXVrl0lOTqYPOM8yIyWWyWTC6Ogotm3bhoKCAie7DKEBksOE9D7Sioj3dH3kNefm5mJ2dhZ37tzBvXv3MDo6irfeeospv8V6SJC7PrmNlFx+izx4+fr6Ynl5WVXGZ2xsDO3t7aozUmQjFRERgYiICBQUFGB6eppuSqT5rZycHM2HBLWI+KCgIIyNjWHz5s3Izc11ym8RGiDP8y5WKbKRUoOIJ7Y1Tw/U0oHUvXv38ODBA4yNjeHNN99kGkh5AnJ4ktxGiuM4OpA6dOiQy0DKbDZjaWlJlYVbS0aKXF9CQgLdbpGBlNjefOHCBWRlZYHneWRkZNCNlJr7SC0inuM4REZGYmJiAhs3bkR2djZTfou8Jnelxe5EEPGe7iM/Pz9s2bIFW7ZswejoKO7du4fy8nKMjY3hjTfekLU3S6UVEe+VV38peQ9ZXnnlQdHR0U52GTItraioQEhICH3Asdvt6O7uxuHDh5n/21oQ8cS+aDQa8aMf/Ygi6oldhmyTpHYZpdJiObEg4jmOQ1xcHOLi4nDo0CE0NzdTu8zp06dx69YtZrsMoA0RL91IebLLnD9/Hna7HYmJiaqn2mozUuKNVGxsrGx55sOHD53sMsvLy5qAHFarOkS8n58fFhYWYDAY8IMf/IBuJkh+i2yTCICESKm0WE6zs7OKGylpfquhoYHm7b744gvcvXtXMb8FaMvaEUS8tLTY39+fbpMGBwfpffTFF1/Ax8eHHgDVZu3WgohPSEhAWloaTpw44UQDvHPnDuLi4mi31NLSEnNpMZE4I8WKiA8MDITdboder8frr7+O+vp6p4EU2SZJB1KsQA6x5ufnUVdX53EjJR5IEaQ8weWfOnUKDx8+pO+Rp8Od1oyU3EYqODiY0gDJQKqqqgq1tbXw8/PD0tISEhISNB02tSLik5OTKQ3QZrNBEATZgdTi4qLmjFR8fDyz/TE0NBQ+Pj7gOA6vvfYaGhoaXOopeJ5HTEyM03WwAjm88uo/S95DlldeMUhslxE/4BC7DHnwU/MQrhURb7PZkJubS6fuUrtMXV0dtcuQBzMtGSmCiGd90NDr9QgPD8fs7Cz27duHoKAgJrsMK5BDKmJb87SRktplbty4gaamJrS3t+OnP/0p3SZ5ssvIlRazXp90I6VklyFTZDUPTwQRX1xczPw1Ymof2QLs3bsXnZ2dsFodvUlVVVUICAigDzjR0dHPNCNFZDAYEBcXh9nZWezatYveR0r5LVYgh1RWq1VxIxUZGUnzW+3t7bh16xZaW1vR3t6On/3sZ7I0QKm0IuIFQXDZSInzW3L1FAQkocbSqSUjJd5IJScnIzk5WZYGKB5IhYeHawJyqLU/+vr6Ii0tDXNzc9ixYwcCAgKYBlJKpcXupLSRkhtI3bt3D+3t7ejo6MAvfvELmpX0dMiVKy1mvT5pabF4IDU6Oko3t6SeIjw8HHa7XdWWbS2I+MzMTPqP3EAqMjKSDluCg4PpxlvN70uvvPpLynvI8sorlZLLb1VWVmJychLvvfeeLA1QTuuFiHdnlxEEAY8fP0ZISAjGxsawceNGTRkptbY1juOwadMmBAYGYuPGjS7lmeJuqYyMDHR3d6sGcojtjyybBI7jEB8fD4PBALPZjOeeew5VVVU0fO3JLqMla8eCiJfaZQRBoMCV999/n8kuA7iWFrNIzv4o3ibJ5bciIiIwPDwMnudVZ6S0IuK3bNmCkJAQbNu2DUNDQ/TB/csvv4SPjw/duKWkpKC3t1c1kEOt/ZHjOKSkpKC8vBx+fn44evQoqqurXWiABQUFTvktQP1hE1i1P3raSMnVUzx48AAA8MEHH9BuKU/5LWDtGSkiKQ2QlJ2TgVRcXBz6+vpQWFioGcih5msAYOvWrQgLC3MphJcbSLGWFoulFhFPaIDV1dXw9fVFSUkJampqXAZS+fn5LvclC5BDqsnJSbS2tnrcSIWGhtKBFKmnKC8vBwD8/ve/ZxpIAeuHiHc3kLp69SquXr2K5ORkdHV1wWKxqCot9sqrv6S8hyyvvFqDpPkt8uFdX1/v0S6zuLi4JkS8u42UnF3mzp07AICKigoMDg6C53kXGqBU0tJiFompfWJLl7g8s7e3l27cbDYb/Pz8EBAQQD9QWUUQ8Wrtj6S0mHx4i8sz5ewyBIX+LDJSYoWGhiI9PR03b95EcXExvS4lu4yn0mKl6/NkfxTnt2ZmZlBTU4N79+7BbrejsrISExMTNL/l6f7VioiXKy2OiIjAgQMHsH//fnR0dND+LUEQEBgYCH9/f+h0OtU9UmozUuKNFDmYExqg1WqlNEBxfstoNKoGcgDqbWtRUVHIz8/HvXv3sGPHDszOzjrRAN3lt9aSkfK0kfLx8QHP8+B5ng6kHj58iJWVFVitVvozrDSQGh8f14yIF5cWKw2kQkNDYTabwXGcqsNmS0uLqowUsIqIt1gsdNiiNJDS6/V0I8UK5ADYMlJEhARoNBrx6NEjbNq0CXNzcy40wMLCQpeBFLmPlIAcUgmC4BERLx5IjYyM0AOg2qGFV179peU9ZHnl1TopOjoahw8fdmuXIQ9k4eHhmjJSBBHPSu3z9fXFhg0bUF5ejoiICPA8D6t1tTyTbNykdhlgdSOl5vqUEPFiu8zhw4fR3NxMH5QBx/bG3TZJKnFpMavIRkr8msTlmcQuIwgCtcukpKSgs7NTE0hBKyK+uLgYvr6+THYZLUAOMSKeZZNgNpuxdetWVFdXU0iL1WrF6dOnnfq3pPkt8poAddkWYn/ctWuX7L/nOI5a044fP476+noIgoDGxkYAwO9+9ztZGqCcBEGgpcWskttIiWmAhHJJ+rd8fHyQkZGhuJGSSgzkYM1Ikdek1+uxZ88e+Pn5OdEA5fJb/v7+a8pIsSLiyUCKfJ9I9xehARKgUGJiost7pDUjNTg46HYjJTeQEgQBbW1tAIBPPvlEtp5CTmtBxItfk9JAKjs7Gy0tLbSrj1VqM1LA6kbq4MGDMJvNTgMpYm9OTk4Gz/PIy8uDr68vWltbMTk5qfqwWVtby4yIDwsLo6CcoaEhVUAOr7z6S8t7yPLKq3WWO7vM7du3cevWLcTHx2NxcRH+/v6qiFdaEfGktHjnzp20PJMcAOXsMgBkN1JKUoOIJ3YZkjHbvn07+vr+/+39Z3Qc55Xvjf6rG+iAHBo559xNMFMEM0BSwZZnZL32OePxzNGc4/E5Z87M3HXveu8793y46344H96lYB17ZHk8ki05yZatxJzAJAYQIAlUoxEJgkQmCRIAASIRoe4H8HlYXajuriqAZtq/tbwskgBRaFRLtZ+9/799w2t5pq9xGX9Li/0RaPxRbVymvr4eAFBTU4Px8fFFyzPVMKqI93g8Xh2pQOMyWVlZmJqaMpyR0vMgJO9Ibdq0iT/kKPNbLFOSmJhoSMgB6FPEBwUFoaSkBEFBQbhy5QpWrVqFgYEBVRugcqTI39LiQNfnryMVFxeHyspKr91SrEi4ePEiH/Xyl98ClqaIl3eklOPN8vzWkSNHkJubi8nJSd1FQnNzs2FFPNvhVlVVFfBASuvSYiV6rH3sQCosLAzXr19HWVkZbty4oelASt6R0pOREkXRpyJe7UCKiVeAhaIzKChI04GUfGmxVlhHSr60WHkgxa5nz549OHDgAAoKCjA+Pg6LxaIrI2VUER9o/JEgngSoyCKIR4jauIwoirh16xYEQcCnn36qaVwGWLy0WAtKRbx8eSYblxFFkY/LxMTEID093VBGigk5jCjid+7cCZPJpGlcxmhGSqsino3LpKSk4MqVK7BYLHA4HKrLM9WKBy1CDiWBxh/VxmVEUcTIyAhMJhO++OILTfktYOE+MpqRYtenzG+1t7fD7XbjwoULOH/+POLj45GRkWFIyLEURfyLL74Is9nM81tyG6A8v2UymZaUkdLS2RQEAVlZWcjMzER3dzdMJhOioqIW5bfKyspU9dOPQhEvz2+x9RRutxv37t2D2WzG/v37VddTqLEURTy7Pl8HUqdPn8bp06eRmpqKjIwMQ0IOPRkp+fdks9nwzW9+E2azGTdu3PASCtntdj4CzpY1G8lIjY6O4tq1a5oU8exAKj8/H++99x7m5uYQERHhdSDFuklq7xlWbOrJSLGOlC9rX3R0NLZs2YLNmzfzA6nGxkZMTU0hKCgIR48e1XQgxa5PKeQIBBt/1HNQRBCPAyqyCOLPhDy/Je8maRmX8be02Bdsj5QvRbzauIzb7UZDQwMAoK6uDjMzM5rGZeRLi7WipoiXj8v09/fD7XbzcZmQkBCUlJSgq6sLcXFxuotNQJ8ivre3FyMjI3j11VexYsUKTE5O8v1bbFwmMzOT57esVqtuIYf8+rQq4tm4TGhoKD9B7ujo4PkteTdJeR/5Wlrsj0AdKdZ1Ki4uxsTEBO+U1NXV8e/NZDJpKsCNKOJZR0quiA+U33I6nejs7NSdkTKqiB8aGsI3vvENrFy5kue3RFHk+S35bqng4OAlFZtarX1sPUVsbCz27t2LrKwsr/wWO0hQ5rcA746U3qydL0W8/EBqdHSUH7acPXsWwIL0JyQkRNOBlNHxR+XSYnYgJe8mNTQ04OLFi4iJiUFZWRk6OzsRHR2tS8hhdPzx9u3beOmll7BmzRrV9RTKAymtS4uVMGufr4wUgx1Isd1ge/bsQUpKiuYDKV9Li7VcX3Jysuq9SRBPElRkEcRjgIWv1fJb0dHR/EGZzdArO1Ja6O7uxsjICLZt2xbwY9m4TGlpKd58803ExMTg/v37fFxGrjtWG60KJORQw58intkAU1JSvB5wLl++jLm5OYSEhODrr7/WNC5jNCOlXFpst9sDjsvExMQYzkjpVcQ3NjYiLi4Or7/+Oubm5hbZAFl+y+l08u97KRkpLR2pkJAQrF27FqtWrcKbb77JF+my/BbrJmVlZal+rywjZWQfma/7iOW32P4tt9uN8+fPY35+HmFhYaipqdGU31qqIp6NP8rzW7du3eLv/c8++wxWqxVFRUWIiYkxJORoa2tDeXm5rvHHxsZGxMTE4D/+x/+ImZmZRespUlJSeH6LPagbKRLY+KOWjlRERAQ2btyIDRs24M0330RISAhu3LiBP/7xj3y82el0qh5IAcYzUrOzs6rfk8lk4mpxeX7r1KlT/HovXbqk6UDKqCKeZaRYZ1O5nkJ5IFVaWoqYmBhDQg4jiniPx4OoqCj8zd/8jddCeF8HUoA+IQeDKeJ3796t+XMI4nFBRRZBPEa0jMuUlZWhoaFB19JiYOFBQ68ivr29Hffv30dlZSWys7O9xmXY8kyW30pJSYEgCJqWFvu6Pi2KePm4zNGjR3Hu3DlER0f7tAEq8bW02B+BOlLKcRlRFNHU1ISmpiYAC+N/ISEhmsZllkMRL7cBsvyWKIpe+S2n0wlRFHVnpIwq4qenp1FVVYXc3Fz09PTw14gV5PL9W8DDYtPf0mI1tFr7goODUVJSgpKSEhw7dgxnz55FSEiIpvwW8HBp8XIq4uPj41FZWcn3b7ndbjQ3N+P+/fsQBAHd3d2IiYkJmN8CHmak9DxQKztSausp3G43Dh48iMOHD/OOmyiKuoUcrNjUO/44NTWFV199Ffn5+dwG6Ha7uQ2QGRNZXkvL0mJf1+crIyWHHUitWLEC1dXVOHPmDIKCgjQfSBlVxPuy9ikPpDo6OvjrMzc3B0EQcOvWLSQnJ2s6HFATcgSCZaSYkCPQgRST5YiiqFvIYWT8kSAeF1RkEcQTgq9xmYMHDwJYOAFvaWlRDV8rkRcJRjJSWVlZXvktX+MyTqcTkiTpLhKMKuKbm5uRnZ2Nv/7rv9Y0LsO+p+XOSDHk4zJbtmzBO++8g+joaM3jMsBCEWNUEa/W2VTLb7ndbnz11VcAFrpNHR0dqjZAJfKlxUbHH+X5LXk3ieW3EhIS+H2kNyNlVBHf2tqKjIwM/O3f/i1u3769yAbIdktlZmbyv1fZkdJCR0eHpo6UyWRCVlYWsrKysH37dvzoRz9CREQEzp8/j3Pnzi2yAaphJCPlr7Ppaz1Fe3s7ACA9PR1dXV2a8lvLoYj3Nd4sP5Bi95FeIQfLSOlVxLe3tyM1NRVvvPGGpgMpYHFHSgtaFfFmsxkFBQUoKCjA6OgofvzjH8Nut+PUqVM4depUwAMpYPkzUr4OpDweDwAgIyMDAwMDquPNStj4Y25urs/3AUE8SVCRRRBPIGxcRv6A4/F48Omnn2oal1FbWhwIfx0p5bgMGwU5efIkgIUuQW9vLyIiIjQ9RC2HIl45LsP+4y0flykpKYHH4zGckdKjiG9tbYUkSXj99dcRGRm5SHesNi7DhBz+lhYr0WPtY/mtLVu24A9/+APa29tx584d/Pa3v0VYWJhXN0nt6y9VEa+8j3zlt44ePQpg4T4aHByEw+HQdDhgJGun7Eg5HA7s2LFjUTepoaEBERERKCsrQ2lpKbc/GhFy6FHEX7lyxes+Yocthw4d4t0kl8uF/Px83nHTsrRYiR5FvHw9xR//+Ee0tbVhYGAAH330EaKiong3yVdHYrkV8fJukvxA6sCBAwAW7qOxsTHMzs5q6mYZGaNlHamXX35Z84FUaWnpkoQceqx9165dw9zcHF5//XVERER4HUjJhUI5OTn89TVq7dOiiJcfSO3evZvfR729vfj5z3++aD2Fr+/Jn5CDIJ40qMgiiCcYLcszWadErjdeSkYq0Amw1WpFeXk5ysvLcf36dXz88cewWCzcBhhoXMbX0uJA+FLEy8dldu3a5TUuU1tbCwDcXKhlXEa+tNjI+CMrWFg3yd+4TG9vLwB9D3dGFPHz8/Po7u5GSUkJXn311UX5rfj4eP6AI8+t6RFyMPxlpOSw/NbatWvR2dmJX//61zCbzZrzW0YzUszap+xICYKAzMxMZGZm4sUXX0RbWxvcbje3AQIL3eZ79+4FzG8B6kIOLcjHHwVB4DbAW7du8W7SlStXYLVaecetu7sbgLGMlB5FPLBw2FFYWIhvfetbvJvkL7/FvietQg6G1vFH+YFUR0cHfve73wGAV36LradQKxzUlhZrwZf90d+BFDuUCg0NxeTkpKYDKVZs6lXEs44UO4hTHkh5PB40NTXxAymXy4Vr167pzkgZUcQLgoD+/n4UFBTg1VdfXbSeQu1Ain1PWoQcBPGkQEUWQTwl+BqXYaMgbFwmKysLHR0dWL9+ve4iQa8i/tq1axAEAT/4wQ9w7949Hr72Ny7DhBxGFPGFhYV+OxzycZmpqSl8/PHH/OFUFEVN4zJqS4sDwTJSaop4+bhMb28v3G43H5cRBAEREREYHx9HeHi4ptNjpZBDC/KOlDy/NTExwR9wjh07hmPHjiE7O5uPyulZWsxwu926FfE9PT0AgL//+7/H3bt3+WvEDguYCEZ+bwZaWqwGG38M1JEKDg5GaWkpSktLMT4+jl//+tcYHBxEfX09GhoakJOTA5fLxW2AahjZR+ZPER8fH4+qqiqv/VtNTU2or6+HyWRCREQE5ubmNH8tX8WmP+QdKbX1FPL8FtstlZ6ermtpMYONP2q19gmCgJs3bwIAfvCDH/Bx4kAHUoGWFqshz0j5K5TkB1J3797FJ598glu3buHSpUtoaGgIeCAFGMtIjY6OorOzc5EiPtCBlNlsRkREhO5izqgi3ul0+hxvVh5IpaWl6VpaTBBPAnSnEsRTiNq4jCiKOHDgAARBgCRJCA8P1zwuI19arBV2ApydnY2IiAhEREQgOTnZq+OmHJdxOp1cyKGnSGCKeD0nrPPz87h16xbvlrCHQH/jMoB2IYccLWNrgiAgLS0NaWlp2L17N86fP4/q6mrcu3dP87gMy9rJlxZrvT61jlRISAjWrFmDNWvW4M6dO/wB58svv4TZbMbc3Byio6MxPz+vqWBninij449RUVGIioriNkDWTaqpqcG5c+d4fqusrIxn7R5FRkoO27vFHgTZa/TZZ5/5zG8B2oUccrSMrZlMJmRnZyM7OxsvvfQSzp8/j5MnT2J0dBTvvfeepvyW2tJirden1pHyt54iODgYs7OzSEhIgCRJmu4Lo4p4t3thabHD4YDD4fB7IOVyuVBSUmKoSNCakZJjs9lw584dlJeXY9WqVfw1YgdSpaWlcDqdXgdSgHYhhxwt9kflgdT58+dx+vRpjI6O4t133/XZTZKzVEW8cvxRPt7MDqQ8Hg88Hg+sVqvufWQE8bihIosgnnLk4zLsAcftduPw4cM4depUwHEZYHkV8WazmY/LTE1N8QccNi4jCAKSk5MxPz+v+WvJhRxakVv7oqOj+bgMW56pNi5jtVo1Ly1mGFHEm81mjIyMICgoCP/9v/93fqKstAEqs2RahRxy/GWk5MTGxmLbtm3YunUrenp68Omnn2JiYgKHDh3CmTNnvPZv+cJIRsqXIj4oKIjbAMfHx3ln6+jRozh27BjPwejt1upVxMs7UnFxcV75LbZ/S57fcrlcCA4O1ry0mGFk/NFisWBiYgJmsxk//OEP+RjooUOHFu3fkh+2BFparAYbWwukiFeup/jiiy8wMzOD/fv34+zZs/ywxV9+x+geKbWlxcoDKfbvR2YDBBb2YfnqSKrBMlJGFPErVqxAcnIyP5Bi+a36+nrU1dUhNjaWv9fMZrPmpcUMI4p4m82GmZkZmEwm/N3f/R2/j+TrKdQOpK5du/ZIFPHyA6ldu3bhypUr2L9/P6xWqy4hB0E8bqjIIohnBHn4Wk9+K9DSYl+wjpQ/RbzNZvMalzl27Bg8Hg/6+vrw1ltvqdoAlSxVES8fMZOHr9XGZdipfkZGhuavwzJSW7Zs0fw5cvtjVFSUTxvg/v37+bhMTk7OkjJSWk+ABUFAeHg4xsfHsWXLFsTHx3vZAH3lt/QIOeRoUcSHhobyjuTt27dx4sQJNDc3o6+vD2+//TbPb2VmZvq8R5aSkXI4HF4dKXl+66WXXlqU32LvIz3Ci6Uq4ln3ZsOGDbh58ybvlLS3t/P8lsvlQnp6+iPNSDFMJhMcDgfGx8dRUVEBh8OhagMsKSnx6oIEWlrsC18ZKTkRERGoqKjAxo0bcePGDZw+fRqtra3o6+vDO++8w4VC/g6k1JYWa4F1pOTjj/L1FGoHUqzY1rOGw6ginnWkWAHIbIDKAylWACYlJRkScugdfwwKCkJqaiomJiZ0CzkI4nFDRRZBPIMEym+lpaXxB5xbt25pXlrMMKKIj4yMxMzMDEJDQ/Hd734XjY2NfHkmG5dxuVw88M/wt7TYF3fu3AnYkZKPy7DdUocPHwYAfPjhh5rGZQDfQg5/+OpIKcdl5Lrj0NBQjI+Po7S0VLf5y6givry8HJGRkYtsgMr8VlFREW7evKl5aTHDiCLe4XBAkiTY7XZ8+9vf5veQKIo8v+VyuRAfH+/1eVqFHHJYRsqfIl6e37p37x48Hg+OHTsGAPjggw+8ukn+uiVGFPG+OlIJCQmL8lsejwf19fWIiIjA2NgYSkpKDGWkjCjiV65ciejo6EXrKQ4cOIBDhw7x/FZ+fj5u3bqleWkxQ68inh1IBQUFwWq14lvf+haampq8xptZMaGUYbCO1HIr4uUHUixPdvr0aQAL/z7SciAFGFPEq3WklAdSrLt18eJFXLhwAbGxsRgeHkZxcbEhIYcRRTyNChJPG1RkEcQzjnxc5u7du/wBh43LhIWF8RE/rbS3t2N6elrXf/TGx8d5R4r9x1uuO5aPy7COW1RU1CPLSMmx2+2Ij4/H7OwsKisrMTs7u2hcxuVyIScnx6tTIs9I6d1H5k8Rr8xvXblyBadOncL4+Dg8Hg9u3rzJXyN/I4rKpcVa8NWRktsAlfmt/fv3Izw8HCaTSdep+1IU8atWreLZJPn+LZbfSkxM5B23sLAw1Y5UIPTeR2FhYUhLS8Pc3By2bt2KmZkZNDY24rPPPoPVakVRURFcLhcyMjK8fh6Blhb7uz673e6zY6bMb7W2tuLMmTMYHR2Fx+PB0NAQXC7XIhugkqVkpJSKeF/rKdra2mCz2RAREQGTyWRYyKEV+dLiwsJCFBYWBjyQstvtuoUcgH5FfFRUFPLz83HixAm88MILmJ2d1XQg5W9pcaDr89eRMpvN/DWanJxEc3Mzzp8/z78eK9ACHUgplxbruT69S4sJ4kmAiiyCeI6IjIz0GpcRRRFutxtzc3P4yU9+omlcBnioiM/MzNT8teUZKYZyXIbpjk+cOIETJ04gOTkZ/f39ukbxlEIOrbDxx9WrV8NqtS5antnU1ITQ0FAeUE9KSjKUkdKriGc2wHPnziE2Nhbr1q3TlN9i3xOwPBkpOcr8VkNDA+rr6wEAP/3pT3k3KZCp0sj4I8tIye+j4OBgr/wW67gdOXIER48eRXp6Orq7u3UvmzWqiA8KCsK6detgs9m8ukksvxUZGclfI4fDYUjIMTU1hdbWVqxcuVJTR8piscDpdOLy5cuIiorCmjVrvGyAvvJbgLE9UoEU8WrrKVjBBSx0AdlrFEitbmT8Ua0jFehAKisrS3eRIBdy6FXEm0wmbNy4ESEhIV4HUpcvX1Y9kDIi5NCSkZJjt9uxatUqNDc34/79+1i5ciUaGxsX2QCVB1KA/6XFvrh586ZuRTxBPClQkUUQzyFalmeyBxxlLoJlpJZbEW+z2bBy5UqsXLkSIyMjaGxsxPnz5wEAZ86cweDgoKZxGeXSYi2oWfuUyzOV4zIOhwOCICAkJETX0mKjini2tJjZANXyWyyblJ2dDUEQuJBjuTNSDEEQkJ6ejomJCdTX16OiogKDg4M8vyW3ASrzfnIhx3Iq4kNDQ7Fu3TqsW7cOt2/fhiiKqKurAwCcO3cOIyMjAfNbgPGMFBt/ZB0pQRCQlZWFrKws3k1yu904e/Yszpw5g+TkZMzNzfntSKmhVmwGQr60mNkAWTdJnt9ihy1spEutIxUIPYp4Nt4sSRI8Hg/Wrl2LwcHBgPktwP/SYn+oZaTkqB1IXb58GQBQV1eHycnJResp1PAl5PAHy0jJlxYHOpBKT0/H3NycqrXPHywjpXf8kSni2Xiz/ECKjTezjltiYiIEQYAoiro7UqzY1GN/JIgnBSqyCOI5x9fyTF/jMkYyUnoV8VFRUaioqODCjtTUVD4uExISwo2JynEZYHkzUgzluAzLb/T19QEAfv3rX2salwGWpoiXX588v9XT0wO3e2FvUmNjI8LCwpCRkYHh4WFs2rRJ89eR75Eyoojftm0bTCaTV36L2QCzsrL4aJbFYjGUkRoeHkZ3d7ffjJQch8OB7du3o6mpCVFRUUhOTtaU3wL0FZuMQB2p4OBglJWVoaysjOe3Ghoa+H6nP/zhD3C5XMjPzw9ouzOiiFez9iUkJGDnzp3cBsiEGazjlZWVpXtpsXz8UY8iXhRF2O127Ny5E2azWTW/Jd8tFRQUpFvIASyMPwbKSDHYgVRiYiKuXr0KYMGgqLaeQq0IZVk7PRmpzs5Ov+OPygMpJjgaGhqCIAj44osvNB1IsetjS4u1oryPAh1IxcXFISsrC7du3dLVkTI6/kgQTwpUZBEEwVEuz1SOy+Tn5+PmzZuLrH2BMKqIv3v3LrZt2waXy6VpXIYtLdYj5AAWHu7CwsI0daTY8kxJktDX14fVq1ejs7NT07iMFiGHkkCKeNZNSk9P93rAaW5uBgCcP38eExMTi2yAaiwlIyVXxMvzW7dv3+YP7l988QUvgAcGBhAbG6trabGRsbW+vj4MDw/jG9/4BlauXOm1f+v8+fOq+S21jpTW69OqiA8LC8P69ethsViwd+9eOJ1OXL9+HX/605+4DdDpdC7KbwH+lxb7wldGimEymZCTk4OcnBy8/PLLPJvExkAvXbqEubm5gPktwJgintkf5R0ptfxWY2MjWltbYbPZUFJSgr6+Pr8dKTWMKuKZkGP16tVeB1LMBpiWlgaXy4Xi4mLY7XYva5/efWRaFfFRUVHYvHkzwsPDsWfPHhQWFuL69euaDqR8LS3Wcn2+FPFqB1Jutxu1tbUAFjr5wcHBmg6k5EuLCeJphIosgiBUkY/LDAwMcEPZ+Pg4LBYL9u/fr2lcZqmKeNaRCjQuk5GRAYfDYSgjdeXKFc0ZKfn1xcfH4+WXX+YFV6BxGSMZKaaI37x5c8CPZfmtvLw8vPXWW4iJiYHZbFa1AaoVoY9CEc+6Sdu2bUN3dze/j+7fvw+LxYKjR49qym8ZVcS73d5Li+U2QLX8Vk5ODuLi4gwXCXoV8aIoIjY2Ft/61rcgSRK6urp4V7K+vn5Rfot9T8DyZqTkWCwWLsR46623EBERgfn5eZ7fktsA1XI8gYQcaviz9qnlt1j3ZnZ2FjabDadOnVK1ASoxmpFSdqSUB1JsdHffvn04ePAg8vPzERcXZ0jIYUQR39jYiOjoaLz++uuYn5/n6yl8HUixzwH0F5taFfHsQGrlypV4++23YbfbMTY2pulACvC9tJggnhaoyCIIwi9seTBbnskecLSOy/haWuyPQIp4tXEZt9uNrq4uAMDly5cxNze3aHmmGmpCjkCwjFRlZSUAbeMyZWVlEEVR19Ji4OHYmt7xx+npaWzbtg15eXmqNkD2gJOdnQ2TyaR5abESrYp4QRCQkZGBjIwMhIaG4uuvv0Zqaqqm/BagTcihJJC1T57fGhwc5K9RR0cHgIen7pmZmQFP+vXuIwMWOlLd3d28I6Ulv+V0OtHQ0ID09HTdQg69Y2tXr17F1NQUvvWtb6GgoIAvO29sbOQ2QLZ/Ky0tDYIg6BZyMLQq4uXrKU6cOIHTp0/D4XDw8ebU1FS4XC4+3qxkqRkptb8zMjISmzZtQkVFhdeBVEtLC4CF1zE8PDzggRSwNEU860jJ11P4OpBi95GepcWAcUX8xMQEXn75ZRQVFaG3t5e/Rr4OpPQKOQjiSYTuXIIgNMNU78r8FhuXSU9P59kk9jDCMlJ61N5MEa/lhJWNy6xatQpvv/02EhISvMZlmA1QbVwGUF9aHAhRFAGod6R8jcscP34cwEInpaGhQdUGqERebBrJSLGOlNIGKIoimpubeX6LPcjoLRKMKuI9Hg8yMzPx13/91xgfH+evEctvsY6bXI1vNCOldfwxLi4OO3bswAsvvMC7gKzIiYiI4HuT1PJbQGAhh6/PAdQ7Ccr8FhvdPXToEADwXJuaDVDJUhTxISEhvCPFukm+8ltOpxNms1l31s6oIr65uRlpaWl44403MDo6yotkNt7MOm4svwUYLza1dKTkB1KbN2/G22+/jcjISL4QPtCBFBBYyKGGv46UrwOpvXv3AgCSkpLQ3t6u6UBqORTx8vUU8v1bdXV1/EDK6XQiKChI19JigngSoSKLIAhDaBmXKS0t1b20GAAXE2RlZWn+nKamJkiShFdffRVxcXF8XObSpUuora2Fw+HgnRLWATCakWLjj4E6UmxcZvXq1fjss894SJ/ZAAONyxhRxLOOlNr4ozy/Jd8tdeHCBczPz8NsNqOzsxOhoaGaum1LGX9kQo7Q0NBF+S23283zW8XFxSgpKeFFgt5iU2tGitHc3Iz5+Xn8xV/8BeLi4nh+69y5czh79iySkpLgdDpRWlqKsLAwAPqFHIA+RXxYWBg2bNiADRs24E9/+hOam5sxPj7uld9yuVxIT09X/fpLyUiVl5cvevj2ld9iy3PNZjP6+/sRExOj6WF8KeOPrCMVERGxyAbo8Xi88ltOp9NvR8rf9elVxLe3t3vdR+w1Uh5IlZSU8MJXy9JiJZIkQRRFTR0pdiC1adMmfP755/B4PBgZGcEnn3yi6UCKKeL1HMT460ixDn1RUZHXgVR1dTWAhZ+pnqXFBPGkQUUWQRBLRjkuwx5wWlpa+AhRb2+vpnGZ8fFxdHR0YN26dYYyUmxsTTkuI4oijh8/juPHjyMjIwMulwu3b98GoK9I6OnpwfDwsK7dXbOzs+jo6EBJSQn+4i/+Ar29vYvyW6xTwsZl2Pfkb2mxGloV8awrVFxcjL6+PnzwwQcIDQ3VnN+SCzmWkpGSo8xvsY4b6xzOz8/j5s2bmrqOk5OThjJS8o6UIAg8v8VsgG63G4cPH8aRI0eQk5MDp9OJwcFBAPruI6OK+GvXrqGoqAivvfYa378lz2+xTgnLb7HvyYgiXsvYGstvuVwu9Pb24sMPP4TNZtOc3wok5PCFL2ufr/UUrJsELBSJQ0NDmjJZS1HEs6XFgiDwAym2nkJ+IFVQUACn08ktk3ozUoODg5oyUgxJknD9+nUUFBTg9ddf13Qgxb4nrUIOhlZFvPxAqru7G7/85S+xYsUKXUIOgnjSoCKLIIhlQz4uI3/AaWtrQ3t7O2JjY3kx4euBykhG6s6dOz4V8fJxmeHhYf6As2fPHgALnZQbN24gNDRU00OUUsihhfb2dt6Rko/LyPNbtbW1qKmp4eMyeXl5upYWy69PS0ZKzpUrVwAAb7zxBmZnZxflt9j+raysLH4teoQcDK2KeHl+68UXX8THH3+MGzduoK2tDS0tLYtsgGoY2SPlryPFbIDr16/H4OAgN919/vnnABbuo+HhYURGRmp6MFyqIt5kMiE7OxvZ2dle+a0zZ87g66+/RkpKCtd4G81I6VXEX7t2DQDwd3/3d5ienuaHLSy/xbpJLL8F6BNyMNj4Y6COlHI9xa9//WsMDAzw5eLK9RRqGMlI+VPER0VFqR5INTc3QxAEhIWFYXJyEpIkabqP3G637oyUfGmxMr8lH2+WH0ix+4iN8mnFiCK+p6cHgL5ikyCeRKjIIgjikeDLBuhvXAYIvLRYDa2K+OjoaD4uc/nyZezbtw8zMzNe4zIul4t3MZQEEnL4uz41RbzauIwoiqiuruYjMzabDdPT05rG5IxmpJQdKWV+iz14sfyWy+UyLOTQq4ifnZ3FjRs3sHr1amzatGmRDTA7O5vv35LvllrujJScuLg4VFZWYseOHairq8PBgwcxPT2NX/3qVzy/5XK5EBcXp/r5y5WRYlgsFt7BGhsb46/RwYMHIQgCJElCeHg4ZmdnNT0gL5ciXmkDZN2S6Ohor/tI69JihtaMlJKbN29i5cqVqKioUF1PwQ435MWoViGHHC3WPuWBVF1dHQ4fPoyJiQl88MEHqjZAJWpLi7Ugz0jJsdlsWLVqFVatWoXh4WH+M9uzZw9MJhPm5+cRHR2Nubk5TQX7UhTxepcWE8STCBVZBEE8cpTha1/jMlFRUbqWFgPeRYJWRbwgCOjv70dwcDD++Z//mavFleMyTqfTaxRO3pHSilZFvHxcZmhoCB999BHGx8dx8uRJnDlzhneTmA1QDSPZFl8dKX/5rfPnz0MQBCQkJOD+/fuac1JLUcQ7nU4vG+Dt27e9ukkWi4W/RpGRkYYzUnoU8YIg4Pbt2wgKCsI//dM/4fr16xBFcVF+q6ysDKGhofzz9Ag5GFoV8eHh4Ty/dfPmTfzud7/D2NgYjh8/jrNnz/Jukq/8FmBM7d3f36/akZLbAJmenOW3Tp8+DZPJhPj4eEiSpPlrGclIyZcW+1pP0dLSArvdzndLhYWF4dq1a7qFHHoV8WazGSMjIzCbzfiHf/gHXpQyG6CvA6lAS4vVuH//vqaOVHR0NLZs2YLNmzejr68Pn376Ke7du4djx47h3LlzAQ+kgKUp4vUsLSaIJxUqsgiC+LPib1yGdSIcDofmcRmmiN+6davma5AvLbbb7X7HZTIzM7kxkXVz9Ao59I4/SpKEsbEx7NixA+np6Tx3w2yA7AEnISGBv0aBlhb7QktHSp7fmpiYwLFjx1BfX48bN27gRz/6EbKysng3yVeHj2Wk1qxZo3v8Ua0j5XA4sGPHDmzfvp3vlmL5LXYNekbdlqqIZz8XX/mt3NxcOJ1OFBQUGBJyyItNrVitVoyOjmLr1q1IS0tbZANk3SR5x0CPkEOOr4yU8npWrFiBFStWYHR0FMePH4coirhx4wbefvttr26SrwJAbWmx1utjGSmGr/Fmtp6CjRBmZGRo/jpGFfHM2hcVFaVqA1QeSOXm5i4pI6X1PhIEARERERgbG0NFRQVSUlI0HUix+0ivIp6NP5aWlmr+HIJ4UqEiiyCIx4LaA44oimhra8Mnn3yiaVwGWHpGSo6/cZkDBw5gdnZWl4qeXZ9eRby8I8UMW2r5rfj4eN4puXv3ru6MFBt/DJSRkhMSEoLJyUmEhobi+9//PjweDxobG7kNUC2/BRjfR9bT0+O3IyUIAjIzM5GZmYkXX3wRbW1tPG/3m9/8RlN+C/Av5PCFr/FHeX7r1q1bvLj57LPPYLFYMDMzg4KCAt3Fpt6MFLuPXC4XoqKiAua3SktLMTIygtu3b2PDhg2av46R8ceIiAi+SPh73/sev4/kNkCXy8XFEQyjGalAinhlfqu5uRkHDx4EAHz88cdIS0uDy+XyWk+hxnIq4uU2wP7+ft5xa25uht1ux9TUFAoKCnQvv46OjtaVkWIdqfLycsTExPD1FGwEXO1Aanh4WPPSYgYbf9SriCeIJxUqsgiCeOz4ym8pl2cWFxd7PcQtNSPlryOlHJc5duwYurq60NrainfeeYfrjv2NyyxFEa/sSMnzWxMTE7zjxmyA4eHhXK2tlaUq4uPj41VtgG63G+Hh4V4dNyNCDr3jj8HBwYiKisLMzAx27doFQRC88lvMBqjMb7EiQU+xya4vUEcqPj6e57euX7+O48ePo7e3F62trfjf//t/cxGMr/wWsHhpsRZ8daSU+S02ustsgBERETCZTIvyOv4wqohnQo6UlBSkpKR45beYDTA6Oppfb0xMzCPLSMmxWq1ITEzEzMwMtm/fDgCL1lOo5bdYR2q5FfGCIPDXiB1InTp1Cv39/WhtbcV7772n6UBKubRYC/KOlHz80W63+z2QYgIYPYdf165d40IOgngWoCKLIIgnCn/LMw8cOOA1LqNnaTGDZaS0KuIFQUBqairm5uYQHx+Pbdu2we124+LFi7hw4QIcDgdcLhfKysoWZXmM7JFiinh/HamQkBCsWbMGa9aswZ07d9DQ0ICzZ89CkiT85Cc/4fu3/OW32PXpzUh5PJ5Fini5DfCll17iu6VYfsvhcOD27duoqKh4pBkp4OH4Y3l5OaxWK9atW4fBwUF+H7H8VnFxMZxOJzIzMw1lpFixqVURLwgC7+7FxsZiy5YtcLvdOHv2LM6cOYPk5GTeTZLntwBjWTstivjw8HC88MILeOGFF3Dz5k00NDTgwoULkCQJ7733Ht+/JbcBquFLyOEPZn+Uf0++8lunTp3CqVOnkJSUhIGBAWzcuFH3Hqm0tDRdinjWkVq9ejXsdjsfb2ZdSWV+KyUlxZCQQ66I1yIlYQdSNTU1fHVGY2NjwAMpwFhG6ubNmwE7UsoDKVEUcfHiRQDAz372M37YIl9PoYYoiqpCDoJ4WqEiiyCIJxbluAwz3TU3NyMkJAQWiwUhISHIzMzU/HeqFQmBYB2pqqoqFBYW8nEZ+fLM6upqr3EZi8UCt9utaWmxHL3jj2yETJIkVFVVYWhoSDW/pewg+VtaHOj6/HWkgoKCUFJSgpKSEoyPj6OpqQlnzpwBAJw9exYDAwO8m+Sv+6hcWqwFX4r4uLg4r/wW67g1NDQgIiICwcHBsNvtupcWL0URX1ZWhrKyMty7d493kw4dOoTDhw975beCgoKWlJHSOv6YkJCArKws1NTUYOvWrRgaGvLKb7FOiTJfI+9IGVHE++pIKfNbbrcbNTU1AIDz58/jzp07AfNbwOKlxVpQ60jJx5urqqoW5bdiYmIQFBQEq9WqOyPFhBxakS8tZt0k5YGUPL/Flp0byUiJoqhZEc8OpKampnDx4kVs3LgRQ0ND/ECKradQO5BiQg61pcUE8bRCdzJBEE888nGZXbt28eWZbW1tmJubw/vvv69pXAZ4qIjXO7amVMTLbYBq4zLp6ekYGRl55Bkpdn2hoaFYv349TCYTdu/ezW2AavmtiIgIzUuL5QwNDaG3t1ezIj40NBRr1qxBTU0NUlJSkJ2dDbfbzfNb8m6SstBbzowUQ57fYh23+vp6dHZ2AgA++OAD3k3yl99i12dUES+/j8LCwrgNkOW33G43rly5AqvVioyMDNy5c+eRZ6TY9YWEhKCiogJmsxkvv/wyWltbIYoivv76a5w+fRqpqancdBcSEmKo2NSriI+IiMDGjRvR0NCA8PBwZGRkwOPxBMxvse9puTJSDOV4c0tLCxoaGtDd3Q0A+NWvfsUPWwKNDYqiuEjIEQi1zqavA6mmpiaEhIQgOztbt7VvqYr4rVu3IigoKOCBlNVq1by0mCCeJqjIIgjiqUK5PJMZ5bSMy/hbWuwLLYp4tXGZ+vp6AEB1dTVu3rypaVzGqCJe2ZFS2gCV+a3s7GwMDw/D4XA80owU4K2IX7FixaL8liiKCA8P59mkhIQEzUuL1a5P6/hjcHAwSktLMT09jc7OTmzYsAHXr1/nNkBf+S3A/9JiX8jHH30dBLD81vbt23H9+nU+mgYAp0+fxsjICFwuFxwOh9+vJV9arBXWkZKPP/rKbx04cACHDh1CXl4e7ty5g5iYGF1CDiNjawMDA7hz5w5eeeUVrFq1yssGyPJbMTEx/D6KiYl5ZBkpOTabDeXl5QAWTKerVq1CV1eXqg1Q2eljQg61pcW+8JWRYvg6kGpqagIAXLhwAdPT0ygrKwt4IGVEEc/GPF0uF+9IKddTKA+kCgsLcfv2bd1LiwniSYeKLIIgnlrk+a3h4WH+EKg2LmM2m1U7UoHo6enRrIhn4zKJiYlobGxEamoqQkJCFo3LMGugEibkUC4t9kcga58yv8VGnEZHR2EymfDll1+q2gCVLJciXp7fku/fqqmpwblz55CYmIjExETDGanVq1cbGn+sqqqCIAgYHBxctH9L3nFjMg1AX5GgRxFvMpmQnZ2NjIwMtLW1ITY2FjabTVN+i31Py5GRkqPMb4miCLfbjfHxcQQFBWH//v1wOp0B81ssI5Wenq5r/FG5tFhpA2xpaYEoijy/lZaWhsTExCVlpIwo4tlYonI9hd1u56O7ycnJEATB8B4prYp4diCVl5eHt99+GxEREbBYLNwG6O9Ain1PRhTx/sYfY2JisHXrVmzZsgW9vb3cmDg1NaV7aTFBPOlQkUUQxDNBdHT0onEZj8fDx2VKS0vR3NyMzMxMzUuLgYWHOyOK+OnpaWzatAk5OTmq4zJZWVlwOp0oKiqC1WrVvLRYiR5FfGxsLLZt2wZgoTNSUlLCJRVhYWF8b5La3+VrabE/Ao0/BgcHe+W32G6phoYGAAun7lNTU6rdJCVG9kixjpR8/DEuLs7LBsj2b7H8VllZGTwej24hh5Hxx46ODv7wmZ+fj7GxMf4aHTp0aNH+raCgIM1Li9WuT6siPiEhATt37oTVasXJkyf5ziZmA2T3kVqnhQk5jIw/+upIyfNbd+/e5YctdXV1ABbewwAW2QDVYEuLl6qIV9u/dfnyZdTV1SE2NhZlZWVwu/UtLWbfi97xx87OTkxMTOCVV15BUVERP5ASRdHngZRaR0oLbrdbkyJeEASkpaUhLS0NEREROH78OFkFiWcOKrIIgnim8DUuc+nSJczNzUEQBHz99deLlmeqIV9avBRFvK9xma+++gr79+9HUVERbDab7j1SS1XE/+Vf/iVmZ2d5N4nZABMSEnh+ixWkWpYWK9GjiA8NDcW6devgdDrx5ptvIikpCbdv3+bdJLZ/Sy2/BSxfRorBbIBZWVk8vyWKIs6dOwdJkgAANTU1KCsrU+0myZFnpJaiiA8PD+f5rZs3b/Jxwvb2dlitVp4B0lts6s1IAQ/vo4yMDHznO9/B/fv3uQ3w9OnTqvkt9j0ZyUhNTExoem9ERkaioqICq1atwttvv43Y2Fj09PSgtbWV2wCdTqdqfotdn15FvL/Opq/1FCdPnuQfc+nSJZSUlATMz8mXFusdf5R3pOQHUn19fbybJD+QstlsuotNuZBDz33k8Xh0CzkI4mmAiiyCIJ5ZlPkt1k1SW56p9vBrNCPlTxHvb1zGZDJBFEVIkhQwvwUYU8QrO1LK/BbrlBw9ehTHjh1DVlYWSktL4fF4eNdNK0YU8U1NTZAkCa+88goSExPR1dXFu0ny/JbL5UJ8fDyAhY5UT0+PZiEHoE8Rz/JbpaWl+PLLL9HY2AibzcbzW/JuklrHLZCQQ41AHamEhARUVVV5ddw8Hg9mZmZgMpnQ2toKq9UaML8FLI8i3mKxwOVyweVyYXR0dFF+Kz8/H6WlpWhsbDQk5LDb7brGH1tbWzE3N4dvfOMbSE5OVrUBstFdpnbXsrRYCbuPtCji5ePNX331Fe+waclvAYGFHGr460ix8ebU1FTs2rWLLztnB1ImkwnXr19HRESEpq7to1LEE8TTChVZBEE8F9hsNr/LM5XjMsDCw114eLjfpcVKtCri5eMya9aswfvvv4/Y2FifNkAlvpYWB8JfRyokJARr167F2rVrcfv2bd4p2bNnDwDg3r17uHr1asD8FqAu5NCCXBEvtwG++OKLfLTx/PnzPL/FpAyAvmJTT0aKMTc3h/b2dhQXF+O1117jNsDGxkZ89tlnPL/lcrmQkZHBH9SVHSktsPHHQJ0Elt/Kzs7Gxo0b8dOf/hSRkZFe+S2Xy4XS0lJVQ5yvpcWBUGak5DAb4MaNG3Hjxg3+GrW2tgJY0HX39PT47CbJWYoinnWkBEHwym/Ju0knT55EWloanE4nRkdHAegXcty+fRuvvPKK5s+Zn5/HlStXUFhYiNdffx39/f28SGbrKZgxkeW32PdkNCMV6D4ym818PcWtW7fw/vvvIywsTPOBFMva+RJy+EKPIp4gnjaoyCII4rlDaQNUjsuUlZUhPz8f7e3tXIuuFZaR0mPtY+av733vewgODl5kA1Tmt4CHS4u3bNmi+euwjJSWjpTD4cD27duxbds2fPTRR+jv70d/fz9+85vfIDw8nIf4fWXBjCrifXWk5N0keX7ryJEjABZGMru7uzXlt4CHxeZSFPHMBqiW34qMjERZWRkKCgq4kENvkaB3/LGlpQUA8P3vfx9ms5l3kw4ePKi6fwvQtrRYCbM/aulIMZFJZWUlfvWrX6G3txddXV34xS9+gejoaN5N8vVgHkjIoYa/jpTVakV5eTnKy8tx9+5dftiyf/9+AAv30c2bNxEREaHp56V3Hxng3ZGSjzfv3LmTjzfL81vMcqlnabH8+qKjo3Up4tvb2wEAf/M3f8NFL0oboHz/FvBQyKGnIyW3P+pRxBPE0wIVWQRBPLf4GpdhNkBBEDA3N4e7d+9qGpe5ffu2YUW8fGmxr/yW/AGnpaVFt5BDT0aKMTk5id7eXqxduxY7duzg3SR/+S0g8NJiNbSOP7L81rp167gFEIBPG6CS5VbEK/Nbra2tcLvdvJsELHScxsfHA+a3gKUp4uUdKbkNUJnfYtkkj8djSMihNSPFuH//Pnp7e7Fy5Urs2LGDv0bMBpiamgqXy4WSkhKvvNFyZ6TkREZGYtOmTaioqIDb7caXX36Jubk5/OEPf+D5LZfLxbthSgIJOfxdn5oiXm09hdvt5uspgIUicWpqStO4pdGMlFLIoVxP0dTUBI/Hg9DQUJSWlsLpdMLtduvuSHV2duLevXskvCCeWajIIgiCgPe4zOTkJM8A1dbWora2NuC4DKC+tDgQ/hTxyvwWe8Bh2QeHw4GhoSEkJCRoeohiRYJRRXxQUJCXDZB13Fh+Kzs7m++60rO0GPBWxOux9nV3dyMoKAj/+I//iBs3bvD9W3IboNPp5PktwFhGSqsiPjg4GGVlZSgrK8O9e/fw4YcfYmxsDOfPn0dNTU3A/BZgLGvnryMlz29du3aNF1yXL1+GIAiIjY3F+Pi45pyUkfFH+dJiq9Wqmt/av38/37/ldDoRFxdnSMjhdruRnp4eMCPFEAQBAwMDMJvN+B//43/w8T1/+S3AeEZKiyJent8aGRnBxx9/jNHRUZw9exYXLlxQHW9WYiRr50sRLz+Q2r17t+qBlMPhwMzMjOavZWT8kSCeJqjIIgiCUGC32/3mt9TGZeQZqeVWxMvzW7t378bx48dx/vx5DA0N4d/+7d8C5reApWWk1BTxoaGhi/JbbrcbX3zxBf/7IyMjMT8/r+nrGVHEyztSNpuN57eYDdDtduPcuXM4e/YskpKS+G4po0IOLRkpOTMzMxgZGcH27dtRUFDAX6MrV65wG6DT6fTKby0lIxWoI2UymZCTk4OcnBy8/PLLOHHiBGpqanDnzh3867/+K1JSUvhr5Gt8a7kV8Sy/Jd+/xfJbbCwuLi4OkiRpKrSMZqSY/TEsLMzLBsiMiSy/lZ6ezg9bfHWk/GFEES8IAkZGRrjKX209hdPp9MpvqXWktKDF/qg8kDp58iRqa2sxODiId999V9OBlFFFPEE8TdCdTRAE4QdlfkttXMblcmF6elrz0mKGPCOlVREfFBSEoaEhhIWF4e///u/5QyDLb7FukvLvDLS0WA2tinh5fqurqwuffPIJZmZm8Pnnn+Po0aO8m+Rvl5dRRbxaR0qe37p37x7PbzEboCRJyMnJ4QY1LSxl/JGtC6isrMT27dt5fqupqQn19fU8v+VyuTA1NYWhoSFs3LhR89eRK+K1dqMsFgtGR0cREhKC//Jf/gsfTWP5LdZNys/P93oINrKPTIsiXhAEnt+qqqrC1atX8ac//QmCIODTTz9FTEwMv4/8FQ3+hBy+8NWRstlsPL81MjLCO27MBjg/P6+rUAeMjT+yzjXbPaa2nqK2thYOh4MftkxOTmpeWsyYn59HY2OjLkW83W7H5OQkbDYb3njjDX4f+TuQAgIvLSaIZwEqsgiCIDQQaFzGZrPBZDLpenhiS4uNKOLXrl2LsLAwrFmzBmvWrMGdO3d4p+TLL7/k+7ecTieysrJ8dqT8oXdsTRAEmEwm3L9/H6+88gpsNhvcbjdqamq8bIBlZWUICwvjnxdoabG/6wvUkQoLC8P69euxfv16DA4O4vDhw7h69SquXr2Kt956K2B+C/Av5PCFL0W83AYo77ix/FZISAhMJhMyMzM1vw4dHR1LUsRHRUV55bdYN6mtrQ02m40bE9PS0nx2pPyhd2zNZDIhJCQE9+/fx+7du2G1Wr3yW8wGqMxvyYtNPRkpURQDKuKjoqJ4fmtgYADHjh3DtWvX0NHRgbfffpt3k3zlt4ClK+LlxWWg9RTh4eEQBEGX9n6pivi4uDh+IMXWU6gdSCUmJnIhR6ClxQTxNENFFkEQhE6U4zJNTU0QRRG9vb147733kJmZCZfLFdDi53Z7Ly3Wgq+OVGxsLLZt24atW7eip6eHP+Cw/MzExATWrVune9msXMihBbfbjaCgIJSWlnLBgtIGePToUd5xKywsxNWrVw0JOdra2rBmzRrN3ai4uDjcv38fDocDL774IhobGxflt9jDovJ7ApZfEW+xWHh+a2xsDG63G9XV1ZAkCe+9956qDVCNpWak5CQkJGDnzp2orKxclN+KiIjA6Oio7vvIyPgjG1tzuVyw2WxYsWIFRkdHvWyAbP+W0+lEXl4eX1pspNgsLy/XNP4oCAKSk5MhSRKio6Oxa9cu/vrIbYBOp3PR97ucGSk5yvUUoiji9OnT/D7Skt9i16d3/FFNEa8cb2YHUnV1dbhw4QJiYmIwNDSkS8hBEE8jVGQRBEEsAbvd7tMGuH//fp/jMoGWFvsikCJeEASkp6cjPT0du3fvRnt7O44fP46JiQlcuHAB165dg8vlWmQDVLKcini5DfD27du8U/LFF1/AYrHAZrPBZrMtS7HpD/nSYnk3iZnulPmtsrIyhISEqHakAqFXER8eHo7Y2FhIkoQXX3wRd+/e9bIBsm5Senq614Op0YyUKIp+FfHK/FZLSwtOnToFALhw4QJ6e3u5DdCfftuoIl5t/DEiIgIVFRWL9m+1tLTAbrfDZrPBarXqKjaNjK2NjIzwjpQ/GyDLb5WUlPBunB4hB/Bw/FGrtS86OhopKSmQJAk7duzA6OjoovyWy+VCUlKS130kF3IspyJe7UCKGTdpVJB41qEiiyAIYplQ2gDZ/i21cRmtS4vlyDNSWmAZp2PHjiEjIwMlJSVeNkD5/i1lJkyLkEOJFkW8w+HAjh07sH37dnR1deHy5cs8c/LjH/+Yd5PkNkA1lpqRYihtgMr8VkpKCoaHhw3tkTIy/hgSEsILJvn+LY/Hw/NbrFPicDgMCTlGRkZ0KeItFgucTie+/vprpKSkoKioCG63GwcOHPCyASrzW4DxjJS/jpQgCEhKSkJSUhLPb9XX1/M9Ye+//76qDVANNv5oJCMlvz6lDZAdtrD8Vnp6Om7fvm14j5ReRbzNZsP69esRFBTktZ5Cmd9ieUEjxaZeRTwTCtXW1iIlJUWXkIMgnkaoyCIIglhm5OMy8gccNi4TFxeH6elpOByOR7JHSo68I+VyuTTlt+bn59Hc3IzCwkLNQg52fVoV8YIgIDMzE4ODg2hsbMSOHTvQ3d2N8+fP+81vAcYzUqIoIisry+f4ozy/devWLbjdbtTW1gIAjh49ir6+PrhcLi8boBpLUcTLO1LK/BbruJ05cwZff/01kpOTMTk5iZiYGF1Li5eiiP/GN76BlStXLuomqeW35ufnveyPWhFFESEhIZryRCaTCXl5eRgbG0NLSws2bdqE3t5ebgNMS0uDy+VCcXHxokKFdaSWWxEfFRWFzZs3Y9OmTVwHf/nyZQDAiRMnMDg4CJfL5WUDVGOpinhW8Kqtp5DntzIzMzE2NqZ7afFSxh/1FJsE8bRCRRZBEMQjhHWTioqKvPJbg4ODAIBf/epXvJvkr+uhtrRYC263e1FHSpnfYrul3G43wsPDkZSUpDsjtRRFfFxcHDZu3IiKigrV/FZOTg7PbwUHBxt6uNOriI+Pj8e2bdtw6dIlpKSkICoqiue3mA2Q7XJS+570KuJ9ZaQYrJvkdDoxNjaGxsZG1NfXY3h4GIIg4Pe//72m/JZcyLFURTyzAVZWVqKzs9MrvxUdHY3k5GTDGamVK1fqVsTHxMTwgomNW8q7SfL8ltlsVu1IBUKPIl4QBKSkpCAxMRGNjY1ITExERESEpvwW+56MZqR8fU9q6ykaGhowMjICk8mEzz//XHW8WclSFPF6lxYTxNMKFVkEQRB/JgLlt1g3KTs7e9EDjr+lxb6QW/vUOlLy/NaLL76I9vZ2uN1utLW1AVjo3ty6dStgfgswlpEaGhpatLRYnt8aHBzkr9Hnn38Oi8WCoqIiXL16FZmZmYaEHEbGH1944QXk5eV5dZOYDTA5OZnvlgoNDdW8tFhJoIyUnPDwcLzwwguYmZnByZMnsXLlSrS3twfMbwEPO1LLqYg3mUzIzc1Fbm4u76Qw8QoAnD59Gnfv3g2Y3wICF5tqqCniIyMjvfJbbLcUy2+VlJTgypUrSEtL011s6slIAQsdqcnJSWzcuBGFhYWq+a2MjAy+W8pms2leWqx2fTExMZo6Umw9hclkwvHjx1FSUoKOjg6v8Wan07kovwVoE3IoYYr4/Pz8gPcBQTwLUJFFEATxGFDmt9j+rcbGRoSFhfH8VkJCAgRBMJSRam9v19yRYl2KzMxMvPXWW8jMzMT9+/d5fktuA1Qr2JaiiPd1fXFxcV75LfYazczMYHZ2FseOHYPT6QyY32IZqUDdQiWiKHp1pJT5LdYpOXToEA4fPozc3FyEhYXpLhKYkENrRgrwtva98sormJ+f5zZAlt+KioriGbfY2Fj+PekRcgD6FPFWqxUulwsFBQV48803kZKSgunpaZ7fkneT1DpuRhTx/jpS8vzWzp07cfXqVbjdbtTX12Nubg6zs7M4deqUpvyWkX1k7HuSd6R85bf27t3Ld0uFhobqXlrMFPF6rH3MIpqWloa//Mu/xNzc3KL1FA6Hg8tymPzFSLHZ2dmpe/yRIJ5mqMgiCIJ4jPjSHdfW1qKmpgbx8fEoLS3VvbQYeKiI15KRYjQ1NUGSJOzcuROJiYm4c+eOlw0wODjYa7eUyWTSvLRYDisS/GWkGCy/xXZZiaKIlJQUbgNMTEyEy+VCaWnpovwWsLSMlC9FfFhYGDZs2IANGzbg1q1b/DUaGxuDIAioq6uD0+kMmN8CjGVblIp4pQ1Qmd9KSUlBWVkZGhsbUVBQYEjIoWf8kXU2d+3aheTkZL5/y+PxoLW1FTabDSUlJXC5XEhNTYUgCJqWFiuRZ6QCdaRYfisvLw/79u3D5cuXERsby/NbchugWhH1KBTxyvwWO0iYmJiAIAhobGzk2vhAr4mR8UdlR0rNBshWC1RXVyMzM5PfR3qWFgMPhRx6xh8J4mmGiiyCIIgnBHl+a2JiwmvBKAD+MK+l2DKqiBdF0UsRHxsbi+3bt2Pbtm3o7u7mY2CiKCI8PBxlZWWYnp4GYEzIoTUjBSyMP7a0tKC4uBivvfaaqg1Qmd8C9Ak5GHrGH+Pj41FVVYXy8nK89957SExMRFNTE7cBsm6Sw+FY9Lm+lhYHgo0/qnWk1PJbrOMGLIzXNTc3q9oAlbB9ZHoV8fKOlCAIPL9VVVXF81uiKOLSpUuIjo6G0+nk95GeIqG/v19zRooxNzeHlpYWFBUV4fXXX8fdu3cX2QDZbqnc3Fz+fbOOlJ4Fv1qtfSy/lZKSgvXr1+MnP/kJHA4HtwEGym8ZzUj560j5Gm/eu3cvgIf/jgmU3wK8lxbrUcQTxNMM3ekEQRBPICEhIVizZo2XDbCxsZHbANn+LbX8FvCwSNCriO/r61NVxAuCgIyMDGRkZPD8liiKqKmpwfz8PCwWCzwej6b8FrC0jBQrfOQ2wMHBQd5NYvmt4uJiFBQUoLW11dA+Mr2KeI/HAwD4zne+A7vdHjC/BWhbWqxEPrYWqCPF8lsvvPACfv3rX6O7uxt3797FH//4R24DdDqdqvktwHhGypciXpnfamlpgdvt5ju4rFYrrly5gtLSUk1dEra0WG9GSt6RioyMxKZNm1BRUYGBgQE+ctnc3Ay73Y7S0lIUFhaipaXFULEZExOjSxHPsmz/4T/8B9jtdn7Y4iu/BRjPSGlVxMvHm3/zm9+gq6sLg4OD+N3vfrdoPYXafaS2tJggnnWoyCIIgnjCUdoAWTdJmd+SFwSBlharoVXtzTooxcXFaG9vxyeffILQ0FDN+S1fS4u1XJ+vjlRcXBwqKyu9dksxGyCwMLY1ODioagNUYlQRr+xIybtJrON26NAhHDlyBLm5uXA6nejs7NSdkTIy/jg1NYWuri6sXr0aO3fu5PktZgOMiori18vyW8DCa65VyCH/HCDwfWS1WrFixQqsWLGC30cWi0VzfmspGSk1RTwby0tOTub7t1h+q66uDsBCYTIyMqJJliFfWqz3PkpLS+MZMaUNkHWT5B23jo4OQ8Wm3ozU/fv30d3djfLycj7eLIqi13oKdh/Jx4ADLS0miGcRKrIIgiCeEuQ2wN27d3MboDy/5XQ6kZqaqmtpMWBcEd/W1obg4GD88Ic/xOjoKH8I/OKLL7gNUJ7fArQtLVbCMlKBFPGCICArKwtZWVl46aWX8G//9m8YGxuDKIpoaGhAUlIS37/FuklKllsRHx4ezvNbN2/e5MVNe3s7gAXL240bN3x2k9Suz0hGam5uDk6nc1F+i3WTTp8+jdOnTyMlJQUulwspKSm6lhYD3kIOPdY+ViT81//6X7kMorGx0Wd+CzCekWptbQ2oiDebzcjPz0d+fj6mpqbwwQcf4O7du7h06RIuXboUML8FGMtI+VPEMxvg5s2b0dfXxzturPMVHR2N4eFh2Gw2zfeRXkV8c3MzH38MlN9iy85TU1N1LS0miGcFKrIIgiCeQuTdJHl+69ixY/xjzGYz7t+/r0mWYVQRL19a7HA4vPJbbP+WPL/lcrkMCTk8Ho/u8cexsTHcuXMHlZWVcLlci/JbrJtUUFDA81t6hBxytI4/JiQkoKqqCjt27MDp06dx6tQpjI2N4aOPPkJkZCTvAqjltwD1pcVar0+tI2WxWOByueByuTA6OsrzWwcOHOAPxHa7HbOzs5qyNH19fbhz5w5eeOEFzdfG7I8FBQWw2+2w2+1ISkri+S1RFHl+KyYmhu8o89WR8oeR8cepqSncuXMH27Ztg9PpXLR/Sy2/pWVpsRosI+WvsykIAlJTU5Gamopdu3bx4vju3bv493//dzgcDn4f+cr5GVXEs/FHZUfK33oKdihCVkHieWNJRZYgCG8C+AaA+wCuAvhPkiSNPPizfwHwdwDmAPyjJEmHl3apBEEQhBpq+S1RFHH48GEcP36cd5OysrJ8doGWUxEvz2+99NJLaGtrg9vtRk1NDc6dOwcAyMjIwMTEhKoNUA0jGSn52Jo8v3Xr1i3eKfnss894fsvlcsFkMhkScrB9ZFrHH00mE27duoXQ0FD8wz/8A+9KMhtgcnIyNybKdwoZKRKGh4c1daQiIiKwceNGbNy4EQMDA/jVr36FmZkZ7N+/H9XV1fw1SktL8/n3+BNy+KKjo0O1I+Uvv8UyXBkZGbh//75my50RRby8sxkVFeWV32LGxObmZoSEhPCOGwBDQg6tGSmG2WzG0NAQ7HY7/tt/+2/8vXb8+HEcP34cmZmZPL8lvzdZR+pRKOLl+a2enh78/ve/R0xMjC4hB0E8Cyy1k3UUwL9IkjQrCML/DeBfAPy/BUEoBvBdACUAkgEcEwQhX5KkuSV+PYIgCMIPyvwW6yax7hHrJsn3WckzUsutiA8KCkJJSQlKSkowPj6OAwcOoLm5GV1dXXjnnXdUbYBK1JYWB8JfRyo+Pt5nfstisUAQBE3ZLcZSFPGrV6+GzWZTtQEePHiQ799iHbelZKT0XN/c3BympqbwyiuvIDIy0iu/FR0dze8j+YPzcmek5MjzW3fv3sWhQ4fQ2tqKrq4uvP322175LV+dmeVUxMvzW/L9W5cvX0ZdXR0f2dOTQTIy/ijvSIWFhanmt/bs2YMDBw6goKAALpcLOTk5hoQcbPxRa2EmCAKCg4MxOTmJFStWaP46BPGssKQiS5KkI7Jf1gD49oN/fhXA7yVJmgZwTRCEDgBrAZxfytcjCIIgtCHPbzEboNvtxoULF3D+/HkkJCTwbFJPTw+mp6d1PdwZUcSHhoZidHQU8fHx+Pa3v82LCWYDLCoqgsvl4vuwGMudkWIo81vNzc3Ys2cPJEnCBx98gKSkJN5N8pXfYtcnX1qsBXlGSo7cBijfLdXe3g6LxYL79+9j5cqVmr+OUUU8W1pcWloKq9XKu0nMmMhG1FJTU3k2qaenx5CQQ68iPjIyEpOTk4iJicFrr73Gs0ktLS2w2+0oKSnhWSD5fWQkI9Xf3487d+5gw4YNPj9Gmd/yeDw4ePAgJEnCz372M1UboBpLyUgpCx9lfovt32pqakJISAgmJiawatUqzV9HTcihBSNLiwniWWE5M1lvAPjDg39OwULRxeh98HuLEAThBwB+AADp6enLeDkEQRAEsDi/xbJJzAZot9thtVp1nWobyUjJlxbHxcXx/FZXVxfvJomiiIiICJ67iYuLM5SRYkWC1vHH4OBgWCwWzM/P4y//8i9x7949bgNUdpPkHbdAS4t9wcYf/XWkEhISsHPnTlRWVuLatWs4evQobt68icuXL6Ozs5N3k+Q2QCVGFfEsIyUfMbNarT7zW4cOHUJoaCgsFgsyMjI0fy1fxaY/5B0ptW5SQ0MDLl68iJiYGK/dUqIo6hZy6FXE22w2REREYH5+Hq+88grGx8dVbYA5OTleRSUrNo1mpHy9d+X5LWYDPH78OCYmJnDp0iV0dXUFzG8Bj14RTxDPIgGLLEEQjgFQG4L/n5IkffXgY/4ngFkAv9V7AZIk/RzAzwFg9erVkt7PJwiCILQTEhKCtWvXYu3atbhz5w6XCkxMTOCdd97RlN8Clk8RLwgCMjMzkZmZiRdffJFnSs6dO4ezZ88iJiYGw8PDWLt2reavs1RFfElJCUwmEzZs2MDzW263G1euXIHVauUdt4yMDF1Lixl6FfEmkwnZ2dmYmZlBeno6Vq1aBVEUeX4rJSWF79+S57fY9/QoFPEsv8U6bpcuXcLFixcBAO+++66qDVCNpWakGCaTCXl5ecjLy8P09DQfkT158iROnjyJhIQE3LlzB6tXr9b8dZYy/mi323nBtGnTJvT393vZAENCQlBaWgqn04nk5GRDe6RYRkqrIt5sNqOgoADV1dVITU3lEppA+S3AWEfKiCKeIJ4lAhZZkiT5dQALgvC3AF4BsEOSJFYk9QFIk31Y6oPfIwiCIJ4QYmNjvWyAbP+W2+1GeHg4378lz28B/pcW+0KLIj44OBilpaUoLS3F+Pg4PB4PTp8+DQA4cuQIrl69GjC/BRhTxE9MTKgq4ll+a/v27YvyW5GRkZifn0d0dPQj2UcmR96R8pffysvLg9PpRH5+PgRBgMfj0SXkYNendfxREAQkJiby73/37t18PO3SpUuIjo7m16sUH7ClxUYyUv46UlarFeXl5SgvL8fdu3fR2NiIs2fPAgCOHTuG7u7ugPktYPkU8YIgICUlBSkpKbzjxl6f2tpaOBwOzM7OIjIyUlc32cgYrVwRv2rVqkU2QJbfYsvO2T1gpCNlZPyRIJ4llmoX3A3g/wSwRZKkCdkf7QHwO0EQ3sGC+CIPQO1SvhZBEATxaJDbAFl+SxRF1fxWeHi4oSJBryI+NDQUq1atwsmTJ5GXl4eEhASv/FZxcTHfv6V8QDeiiGcdKV8PrKyblJ2dzY2JFy9eRHd3NwDggw8+4N0kf/mtpWak5B0ptfxWY2Mj2traYLPZkJycjMnJSV0/J7mQw4gifu3atRAEQdUGyPJbpaWlsNvthooElpHSqoiPjIzEhg0bcO7cOWRnZyMuLm5RfovtBFPeR6IoLrsiXpnfam5uxuXLl3H79m0AwMcff6wpv2U0I8XGH+X3kdwG2Nvbyw9bPB4PQkNDkZqaivHxcV33kVFFPEE8Syw1k/WvAKwAjj74l1ONJEk/lCSpSRCETwE0Y2GM8L+TWZAgCOLJR57fGh8f550tlt/KysrCjRs3kJmZqTsjpVcRzzpSa9euRW5uLrZv346uri5uTGxoaOD5LZfLhbi4OJ8dqUDoGX+0WCwoKyvDnTt30N3djc2bN6O9vR2HDh3y2r+Vn5+/qOPGhBybNm3SfG0sI+WvI6XMbzEbIAAcPHgQfX19cDqdfvNbwMMiQU/ho6aIl9sA5UuqWX4rPz8fvb29i6x9gdCyR0rJ1atXMTk5iXXr1iE/Px9VVVV+81vR0dE8IxVoabESPeOPNpsNK1euxPj4OPr6+rBhwwa0t7cHzG8B/pcW+2Jubg6NjY0+O1KCICAtLQ1paWk8vyWKItra2gAAx48fx507d1BWVhbwgEC+tJggnleWahf0ebwjSdL/AvC/lvL3EwRBEI+P0NBQnt+6ffs2f1CemJhAb28vvvzyS95N8lfQKJcWa0XZkZLnt+T7t1h+KykpCVFRUYYyUkzIYUQRv23bNmzbtg23bt3i3aT29nZYrVa+Wyo9PR2CIDyyjBTDZDIhJycHycnJ8Hg8yMrKAgBuA0xJSYHL5UJJScmi/BawUMQstyI+IiICFRUV2LhxI27cuMH3uE1OTmJ6ehr79u3TlN+SCzn0ZKRYR4qNvim7SazjxvJbrPDTu49sqYr4nTt3oqqqCv39/YtsgGx0Nykpid9HRopNreOPZrMZhYWFyMrKwptvvomUlBRIkoTq6mpUV1cjKysLTqfTZ+7R19JignieWE67IEEQBPGM4nA4vPJbrJskiiLCw8O5DVCZ3wJ8Ly32R6COlDy/de/ePW5MbGlpAQBUV1fD5XItsgGqYWT8UU0RHx8fj6qqKq/9Wx6PB/X19YiMjERpaSncbvcjzUgxmpubMT8/j8rKSiQlJanaAOX5raCgIAwPD6Onpyfg0mI5esYfBUFAUlISkpKSMDs7i8uXLyM3N1dTfgt4uLRYT+ETSBFvs9l4fmtkZIS/RmwM9OzZs3C5XMjNzQ3Y0VpqRgrwzm/t2rULHR0dcLvdXvmtsrIyiKL4Z8lIsc5mVVUVUlNTvfJbX331Ffbv3++V3zKZTLqFHATxrEJFFkEQBKEZeX5L3k2qqanBuXPnkJiYyHM34eHhAJaWkdLyQB0WFob169cjPz8fP/nJT5CZmYlbt27hs88+C5jf8re02B/+FPHK/BbbLXXu3DlIkoT+/n5cuHAhYH4L8M5IGVHEs/FHZgOUd5Pk+a3i4mLMz88D0FckLEURX1RUhG9/+9uq+a20tDS+f4sVEmxpsd5iU+v4Y1RUFDZt2oTS0lL8+Mc/RmpqKrq6unh+i9kA1fJbvpYWB8Lf+COzARYUFGBqaoqP7p44cQLAgoCmvr5e1QaohBWb5eXlS1LEK/NbrOPG8ltlZWWG7iOCeBahIosgCIIwRFBQEEpKSlBSUsJtgG63G0eOHMHRo0eRnZ2NwsJCtLe3Y/369YYyUmqdMX+fAwB/8Rd/gfDwcFUboHz/FrAg5Ai0tFiJHkW8xWLh3Znf/va36O7uRnBw8KL8VkFBAYKCFv8nme2R0tO9YRkpX4p4ZgOsrKxEZ2cnL7hmZmYQFBSEy5cvw+VyqXaTlKgJOQLR0dHhNf4oz28xG6Db7cb+/ft5fquwsBCtra2GhBx6FfEsy/baa68hPDyc57cuX76Muro6xMbGeu3fAvQLOQBvRXygjpTNZsOqVauwatUq/O53v8O1a9cwOzuragNUe58xRbyewsdfR0otv+V2u1FbWwtJkpCamqpLyEEQzyJUZBEEQRBLJjQ0FOvWrcO6deu88lv79++HIAi4c+cOOjs7A+a3AO+lxXrH1uSK+KysLGRlZXl13M6ePYszZ84gKSkJTqcTAwMDupYWA8YU8ZOTk+js7MSaNWuwe/du3Lx5kxc3vvJbwOKOlBa0jj+aTCbk5uYiNzcXnZ2d+PWvf42oqCie32I2QF/5LV9Li7Vcn6+OVGRkpFd+SxRFbgMEgLGxMfT09ATMbwEPM1JGxh/linilDZB1k06cOIH09HQ4nU709/c/0owUY2pqCteuXcOKFSvw0ksvoa+vj4+lsm4S67ix/BYQeGmxGlrHH9n7p6ioiN9Heg4FCOJZhYosgiAIYlmR57e6urp4N6m9vZ3nt1wuF+Lj41U/36gifnh4GFu2bFn0Z77yW4cPHwawoEK/cuWKpvwWu77Q0NAljT8mJCTw/BazAbL8VlRUFMrKypCRkaFraTFgXBHf0tKCoKAg/Of//J8xPT29KL+Vn5/Pd0uxjhsTcuh5oJ6cnPSbkWLI81s7d+7Ez372M9y9exdXrlxBS0vLIhugGkbuI38dKWYDXLlypVd+a9++fQAWRjK7uro05bfY9dntdl2KePnSYkEQkJqaitTUVK/81sWLF3HhwgU4HA6+NFtvRko+/qinI9Xe3q57aTFBPKtQkUUQBEE8EuQ2wBdffJF3k86fP++V3yorK0NYWBiAhYe7xsZGv0uL1XC73ZoU8Sy/tX79etTU1ODw4cOYm5vDZ599BqvViqKiIv5gqvZAuhRFvFpHitkAc3Jy8PLLL/P81pkzZ/D1118DWOgYTUxMqHaTlLCM1FIU8VarFRs3bvTav+XxeNDa2gqbzYaSkhI4nU6IomhIyKF3/HF0dBSDg4PYtm0b1q1bx7tJzAaolt/SsrRYDa2KeJbfqqiowPnz53H06FFMT0/j97//PUJCQvj+reTkZNX7SG1psRZ8daTk+a3JyUn+GlVXV/OPCQoKwvT0tKauoxFF/Pz8vKGlxQTxrEJFFkEQBPHIkXeT1PJbOTk5cDqdCA0N9dmR8gXLSOlVxF+/fh1hYWH453/+Z3R3d6vmt1wuFxwOB/8cPUIOxtDQkKaOlDy/NTo6ip/97GeYnZ3FyZMncfr06UU2QDX8CTl84UsRLwgCz29VVVXx/BazAQJASkoKRkZGNOW3gIdLi40q4q1WK7cBsvyWKIpe+S2n04mQkBBDGSl2H2lVxAuCgL6+PoSEhOCf/umfeA7QX34LMFZsjoyMaOpI2e12nt8aGhrChx9+iPv37+PYsWM4efJkwPwWYHwf2fj4OAkvCOIBVGQRBEEQf1bk+a3BwUGeTfr8889hNpshCALsdjskSdI03sQyUnoeWCcmJnDlyhWsXbsWZrPZK7/Fukksv5WcnMyNiUsRcuiVDkxOTuKb3/wmkpOT+f6ttrY2WK1W3k2S57e0LC32dX2BOlLy/Nb09DQOHjwIURTR19eHn/zkJzy/VVpa6rOLoba0OBD+OlLy/NbAwAAfuWSjj4IgIDIyUvN9xBTxejNSbGmxxWLxm9/KyMiA0+lEcXHxkoQceq9vYmICL7/8MhITExfZANn+rcTERK/7yEhHyoginiCeZajIIgiCIB4bcXFx2LFjB7Zv346uri6+f+uTTz5BREQEtwH6ym8BDxXxbPGuFnx1pIKDg1FWVoaysjLcu3eP524OHTqEw4cPQ5IklJWVYXZ2VlN+y6giXr602Gq1YufOnaisrOT5rcbGRly+fBlRUVG8UzI4OKh5aTHDiCLearViaGgIDocD3/ve9zTlt9j3BOjLSPX19QXsSAmCgOTkZCQnJ6OqqgodHR344x//CAD4zW9+oym/xa7PqCJeeR8p81tMBLN3714cOHAAc3NzXHeuZVzQaEaKdaRKS0ths9mQmprqZQNk+a24uDj+Gt24ccNQsdna2ooVK1boGn8kiGcZKrIIgiCIx448vyW3AZ47dw5nz55FYmIiXC4XSktLeX4LeJiRWrdu3bIr4sPCwrBhwwZs2LABt27dwr59+9DT08ONgGz/lq/8FqC+tDgQ8vFHeUdKmd9iu6WYDdBms8FisegaxTOqiGdLi5U2QFYAyvNbLpcLKSkpXMihJyMlLza1wB7w5+bm8Nprr2FmZsYrv8VsgMXFxV5dmkBLi/1dX6COVFRUFDZv3oxNmzahv78fBw8eRF9fHxobG3H16lVuA/SV3wKMZaTkinj5+KPZbEZhYSEKCwsxOTnJ929VV1ejuroaoaGhCA4ORnp6uuavJRdyEASxABVZBEEQxBOFPxvgkSNHeH6rsLCQd6T0nLobUcTHxcXh3r17yMzMxKZNm+B2u9HU1IT6+npERkbyLoA8vwUsb0ZKjsVigcvlgsvlwujoKC5fvoxTp04BAH70ox9pym8BS1PEy69PbgOsqqriu6VYfis8PBxjY2MoLy/X/HV8FQlari8kJARFRUUwm808v8W6Sfv27cPBgwdRUFAAp9OJ3NxcXmzquY+YIn7btm2a7iPWcZuamkJaWho2btwIt9uNS5cuoba2Fg6Hg4tglIUo60jpsfZpUcTb7XasXr0aq1evxvDwMC5fvowzZ84AWLiPioqK4HQ6kZ2d7fcQw4giniCedajIIgiCIJ5Y5DZAlt9yu934/PPPYbFYEBQUhKioKEMZKSOK+M2bNyM7OxvZ2dleHTdmA5Tnt6xWq+alxcrr02Pti4iI4N291157Df39/Ty/ZbPZ+P6ttLQ0r2JAq5BDjhZFvMlkQl5eHvLy8jA9PY2WlhYcP34cAFBdXY329vZFNkA1lEuLteCrIxUZGcltgAMDA9yY2NzcDLvdDrPZjMjISMNCDq0wRfyGDRu4DXBqaop3k44fP47jx4975beCg4MNF5t6FPHR0dFcYPLKK6/gxo0baGpqQmNjI0JDQ/norjy/BfhfWkwQzzNUZBEEQRBPBfL8FrO4NTU1YWJiAu+++y63AcbFxfn8O9SWFmtBTRFvsVh4fmtsbIx33A4dOoQjR44gMTERU1NTuroPLCO1Zs0aQ4r4kpISlJaWorKyktsAWX4rOjqaPyjHxsYazkgNDQ2hoqJC08dbrVaUlZXhyJEjyM/PR1paGl9SrcxvKcf0jGSkAo0/yvNbO3fuxNWrV3Hp0iW0t7cDAH7605+q2gCVGFXEu93uRR0pm83GbYDDw8M847Z3714cPHgQycnJmJiYQGlpqeavY1QRL4oiYmJisHLlSgiC4JXfqqurQ01NjVd+KyIiwlCxSRDPA1RkEQRBEE8VgiB42QCV+a2kpCQ+dhUaGur1uT09PRgZGcHWrVs1fz1fGSk54eHhXvktURRRW1sLAPjiiy94N0luA1RjuRTxShsgMyay/FZKSgqGhoaQnp6ua2kxG3/Uo/Zm44+rVq1Cfn4+z2+xblJLSwvsdjs3Jqampi4pI6VVEW82m5Gfn48bN26gvb0dO3bsQEdHB7cBsvxWSUnJog6Sv6XFvtAy/hgdHc3zW319fVwHDwD79u3D9evX4XK5kJSU5Pc+MqqI7+rq8upIBcpvZWVl4fbt27qFHATxPEBFFkEQBPHUEii/lZubC6fTiYKCAgQHB0MURU1Li+UwRbzWk/r4+Hhs3LgR58+fR1FRESwWCzweD+rr6xEVFcU7brGxsYs+d7kyUnKsVqtXfquxsRGXLl3C5OQkenp68Ic//EHVBqhkuRTx8vwW6ya53W40NDTg4sWLiImJgcPhMFQkGFHEi6KIjIwMVFRUoKKiAiMjI7ybpJbfMpvNhopNPYp4QRCQmpoKh8OBS5cuITc3FxaLZVF+y+l0qhbJj0IRL89vDQ0Nwe12o76+HmNjY7r22hHE8wIVWQRBEMQzgTK/xXZLffbZZ7BYLCgqKkJzc7PupcWiKCIsLAzZ2dmaP6epqQmSJGHTpk1ISkry2r/F8lspKSk8vxUSErKkjJRWRXxERAQ2btyI4eFhNDQ0YOXKlWhpafGyATqdzkX5LUCbkEOJXBGv1pFS5rfYbik2vnfo0CFN+S3AWEaKjT9u3LiR/15UVBTPb/X39/P9W83NzQgJCUFxcTEaGxuRn59vSMihNSMFLHSk5ufnsXXrVqSkpGBycpK/Riy/lZmZyfNbVqtVt5AD0K+Ij4mJwdatWzExMYFLly7pKjYJ4nmBiiyCIAjimSMuLg6VlZXYsWOHV35rZmYGnZ2dqK6uhtPp9JvfAryXFhtRxLOOlMVi4Z2HsbEx3ik5ePAgDh8+jNzcXN5F0lMkLEURX1RUhJdeegm7d+/m+S1mA4yOjubXy2QIeoUcAHRZ+6xWK8rLy5GZmYkf//jHyM7OxujoqKb8lhYhhxr+FPGCICAlJQUpKSleHbfLly9jfn4ePT09OH36dMD8FuC9tHgpini73e6V32IimD179uDAgQMoKCjgf7+e+8ioIr6pqQkFBQW6lhYTxPMCFVkEQRDEM4syv8W6SWfPnsWZM2eQlJTE928p81uAsYxUIEV8eHg4XnjhBbzwwgu4efMml1OMjY3BZDLh1KlTcDqdAfNbwMMiYSnjj8r8Ftu/derUKZw6dQqpqakoKipCW1ubISGH1oyU/HMA4Jvf/CYiIiIwMDDAu0ny/BbbvyUIAl9aLO9IBUKPIp7lt/Lz8/H73/8e165dQ3R0NM9vyW2Aan/XUjJSvjpS0dHR2LJlCzZv3oy+vj6IooimpiZMTk7CZDKhpqYGTqczYH4LWJoinnZjEYQ6VGQRBEEQzwXBwcHcBnjv3j3eTTp06BDvJsnzW8DijpQW9Fj7EhISUFVVhfz8fHz00UdITk7mNsCoqCjeTVLLb8k7UsuliLdarVixYgVWrFiB0dFR3ik5evQoAODmzZtoaWkJmN8CvJcWL0URz2yA8v1b8vyW0+nE0NCQoYyUEUV8R0cHVq1ahRdffBEjIyP8Ndq7dy/vJsnzW4CxjJTW8UeW30pNTUVZWRl++ctfIiEhARcvXsSFCxcC5reWso9MjyKeIJ43qMgiCIIgnjvCwsK8bICsm/TZZ5/BarWiqKgImZmZvCOlFUmS0NjYqDkjxWhsbERQUBC+973vQRAE3nH7+uuvuQ1Qnt8ClpaR0jL+GBERgYqKCmzcuBH/9m//htHRUQwODuLTTz/l+S2Xy4XU1FTVImopGSk1Rby8mzQ1NcU7bidPngQAhISEwOPxoLi4WNP4miiKS1bER0VFcRtgf38/7yax/FZpaSmysrKWlJHSo4hvamqC2WzG97//fUiStGj/ljK/BWhbWqyEjT+Wl5frGn8kiOcJKrIIgiCI55r4+HhUVlZ67d9qbm5GQ0MDBEHA6Ogobt++DYfDEfDvki8t1opaR8pffisvLw9OpxOiKCI0NFS3kGN+fl7XA/Xw8DBu3ryJHTt24IUXXkBnZydEUfSb3zKakdJq7bPZbCgvL0d5eTkuX76MvXv3IigoiNsA8/Pz4XK5vLpJclixuVyKeHl+a9euXejo6IDb7eY2QGChMBkZGdFUNMmXFmtFrSPFbIBq+a3CwkJ+HxkRcszOztJuLILwAxVZBEEQBIGFbFJ2djays7P5/i1RFFFXV4fa2lokJyfzbpJafgtYnoyUHGV+ixkT29raACwUiL29vao2QDVEUTSsiC8rKwuY30pLS+MiCD1LiwFvkYKe8cerV68iNDQU//iP/8hfI3l+q7S0FE6nk+e3AGMZqeHhYU2KeLPZjIKCAhQUFGBychLvvfceZmdncf78eZw/fz5gfgtQX1ocCH+KeF/5LY/HA2BhbPXWrVtITEzUdB+53W7ExMQgJSVF8/URxPMGFVkEQRAEocBisfD81tjYGN+/xfJbrJuUn5/P81tLzUgF6kglJCRg586dqKysxOHDh1FbW4uhoSH88pe/DJjfAhaWFvf29hpWxCs7UvL81t27d3nHbf/+/RAEAYIgICgoCHNzc5q6RUbHH9va2rginuW3lDbAuro6xMbGoqysDE6nc0lCDi1ZO8bQ0BDGx8fxjW98A1lZWfw12rt3r9f+rZycHP4aLSUjFagjJc9v7d69G4cOHcLFixcxODiIn//854iLi+OLvH11II0o4gnieYSKLIIgCILwQ3h4uFd+i3WT2tvbYbVaUVxcDJfLhXv37ulaWgwsKOK1ZqQYJpMJAwMDiI+PxxtvvLEov5Wamsp3S7H8FmAsI6VVER8ZGcnzW319ffjoo48AAJ9//jkOHjzI92/5ym+x69OriGcdKeX3pMxvsd1SJ0+e5BmugoICTE9PaypkWLGZkZGhKyPFrH2sa8XyW319fdyY2NTUxPNbbGG00YyUnvFHs9mMwcFBxMbG4o033uCvUXV1Naqrq5GVlQWn07no0CDQ0mKCIBagIosgCIIgNBIfH4+qqiqv/Vsejwf19fUIDg5GcHCwLuGFkYwUW1pcWVkJq9UKl8sFl8vF81uiKOLAgQNeu6Vyc3N1LS1msIyU1vFHQRBw7949zM3N4bvf/S5MJtMiG2BZWRlcLpfX0ttAS4t9oaUjZbPZsHLlSqxcuRIjIyPYs2cPrl27hra2Nrz11luqNkAlakuLA8E6UoWFhV6FnLybpJbfslgsCA4ODrjDTY6vYtMf8o5USEgIz28NDQ3x/NZXX32F/fv38/xWdna2ISEHQTyPUJFFEARBEDpR5rdYN6mzsxPvv/++pvwWsLyKeHl+68aNG9yY2NraCovFgvv376OkpASSJGka82Ljj4WFhYbGH/Py8mAymZCXl4fp6WneKVHmt0pKSnQtLWawjJSe8cfIyEjcvXsXGRkZqKqq4kUyswEyY2JycrLX3+lvabEvtCji5fmtqakpNDQ04PDhwwCAn/zkJ6o2QDWWUxEfExODrVu3YsuWLejt7fXKb9ntdkxOTupaWkwQzytUZBEEQRDEErBYLKo2wEOHDuHIkSNe+7fku6VYRsrX0mI15Bkpfx2pxMREJCYmorKyEp2dnTh48CCGhoZw5swZNDU1LbIBquFPyOELlpFSLi22Wq3cBsjyW6IoYv/+/Th06BAsFgvCw8MRHx+v+WsZyUjJFfHMBsjyW6IoeuW32GsUHh6+pIyU1vFHm80Gi8UCAPjOd77DF1UzG2BBQQFcLhdycnK8XlsjGSkt44+CICAtLQ1paWnYvXs3rly5gqNHj2J6elqXkIMgnleoyCIIgiCIZUJpA2TdJGV+Kz09HaIoAtBXJLCM1JYtWzR9vMlkQmZmJiYmJlBcXIz8/HyvbhLLb5WWli7aLWUkI8XGH/1Z++T5rYGBAdTV1aGhoQEA8M477/BuktwGqGQ5FfG+8lsnTpzAiRMnEBcXh8nJSRQWFmr+OkYyUsDDjlRBQQEKCwsX2QCbmpoQGhrKjYlJSUmGsnZMEf/CCy9o+vigoCDk5+dj3759i8YfCYJQh4osgiAIgngEJCQkeOW3mFq8vr4eUVFRmJqaQmpqqu6MVHBwsCFFfHl5OXJzc7lcgXXclPmtvLw8zMzM6BZyAAtFglZFvCAISE5O5p2UV199FR0dHV75LdZNkue3AP9Li33BFPH+xh+V+S23242zZ88CAL788ku0tLQEzG8BMDT+qNaRUtoAr1y5ArfbjYsXL+LChQtwOByYmJhASkqKrowUU8TrGX80srSYIJ5nqMgiCIIgiEeIPL/18ssvo7W1FaIo4tq1a+jt7cUHH3zAu0lyG6ASeUaKjZVpQU0RHxERgY0bN3rt3/J4PGhtbYXNZkN8fDzm5+d168p7enoMKeIzMzO5Dn5qaorv32I2wPT0dJ5NstvtmpcWy9GriI+KisKaNWtw6tQpFBcXIzQ0FE1NTTy/xbpJyvwW8FDIsRwZKYbZbEZhYSEKCwsxOTmJpqYmXLx4ERMTE5iYmMDHH3+sKb/1KBXxBEE8hIosgiAIgvgz4Su/dfDgwUX7t+T5LcBYRiqQIl4QBJ7fqqqqQmdnJ5dBAMCf/vQnTfktYOkZKYbNZvPKbzHT3b59+3Dw4EHk5eWhs7MT+fn5hoQcehXx8/Pz2LhxI5KTk1VtgPL8VlRUlOalxXL0KuLtdjtWr16NW7du4fbt29iwYQOam5t5fovZAJX5LcD/0mJfTE1NobW1FStXrtQ1/kgQzzNUZBEEQRDEY0CZ32L7t9ra2mC1WvluqfT0dAiCALfbjbCwsIBLi+VoyUgxTCYTcnNzERMTg8bGRhQXF2NyclLVBqjMb/lbWuyPQB2pyMhIbNq0CRUVFRgYGIAoihBFEffv38fVq1dx4MABOJ1Ov/ktwFsRr3f8Ua6IV9oAm5qavPJbGRkZvDukp9jUm5ECvMcfd+zYge3bt3vltzweD89vuVwuJCYm8vtIb0eKKeK13EcEQSxARRZBEARBPGYSEhKwc+dOVFZW4tq1a1yYcfnyZURFRaGoqAhtbW1Yt26d7iIhPj4eCQkJuj4HAHbt2oWIiAiMjo7ybhKzAcrzW2azWfPSYjlaMlIMlt9KTk7G6Ogorl27hpycHC8bYFlZmWp+CzCWkQrUkbLZbFi1ahVWrVqF4eFhbkzs6uqCIAg4duwY7yYF6v7IlxZrRdmRCpTfiouLQ3FxMVpbWw3tI9OriCeI5x0qsgiCIAjiCcFkMiEnJwc5OTl4+eWXeTappqYGkiShs7MTtbW1AfNbAHDnzp1lUcRHRERwG6B8/1ZLSwvsdjtKSkowNjYGs9msW8ihJyMFLHSkrly5gtWrV2P37t1eNkBlfqukpIR3lZiQw9/SYiV6rH3R0dHYvHkzsrKy8Itf/AIZGRno7OxEU1MTz2+5XC4kJSUt+lnIi83lUsSr5beYVRJYsFQ2NDSgqKgoYIFrRBFPEAQVWQRBEATxRGKxWOByueByuXh+SxRFTfktwFhGyl9HShAEJCUlISkpySu/1dDQgNnZWVgsFpw/fx4ul0u1m6R2fUYU8fKxNaUNkGXcWH6roKAA2dnZSxJy6Bl/bGxsRFBQEL7zne8gODh4UX7L4XDw/Bb7e41mpLQq4ll+a/Xq1fj5z3+OkZERTE5O4quvvsL+/fv95rcAfcUmQRAPoSKLIAiCIJ5w5PkteTepra0NNpuN799KS0uDIAiQJAmNjY3Izs7WrYgPCgoK2JFi+a3c3Fy43W588cUXiI6O1pTfApaWkfKliI+KiuL5rf7+fi7waG5uBgDcvn0bfX19qjZAJUYV8UprH8tvTU5O8o7b8ePHcfz4cWRmZsLpdKKtrU3X0mJgcbGphZGREQwMDGDbtm3YtGkTent7F+W32Mgly2/pFXIQBPEQKrIIgiAI4imC2QArKyt5N0me33I6nXA4HLqWFgMPFfFaRsjktLS0IDQ0FD/4wQ+8jIm+8luAsSJheHhYU0dKEASkpKQgJSUFVVVVePfddyFJEjweD0RRXGQDVGO5FfF2u90rv8Uybnv27AEAxMTE4OrVq5ryW8BiIYcW5B0pQRCQlpaGtLQ0r/xWbW0tampqEBcXB6fTifj4eN1CDoIgFqAiiyAIgiCeQuTdpPv37/P81unTpwEsFBtsh1Kg/BZgTBHPOlJMER8ZGemV32L7t+T5LZfLBVEUNS8tZhgZfxwYGMD4+Di++c1voqioiHeT5DZAtluKdZ/0CDmU16elIxUdHY0tW7Zg8+bNqK6uxtmzZzE+Po5PPvkEISEhvJuklt8CAgs51PDXkWKdy6KiIp7fEkUR1dXVABbuMz3FJkEQC1CRRRAEQRBPOfL81ujoKM9vHTlyBMeOHfPqJqnltwAYUsR7PB7Mz88vKszk+a2dO3fi6tWrPL918eJFAEB2djZGRkY05beMKuLdbjfvSFmtVq/8Fusm7d27FwcOHEBBQQGcTifm5uYMCTna29s1ZaQYgiCgp6cHDocDf//3f8/zW8wGqJbfYt8T8GgU8fL81uDgIP793/8dubm5uoQcBEEsQEUWQRAEQTxDREREYOPGjV77tzweD1pbW2Gz2fj+LZbfAgIvLfaFv4wUw2QyIS8vD3l5eZiensYXX3yBtrY2dHZ24sc//jG3ARYXF6vmt4AFIcfQ0BA2bdqk+dr8daSioqKwefNmbNq0Cf39/Tyb1NzcDLPZjKCgINjtdkiSpKlbZGSPlLwjFRQUpGoDVOa3ioqKDGWkjIw/Dg0NYWZmBitWrND8OQRBPISKLIIgCIJ4BhEEgee35DZAURRx6dIlREdH807J1atXNS8tZgwNDaG3t1eXtc9iseDWrVvIysrCq6++usgGmJ+fD5fLhdzcXK+OEOtILbciXp7f2rVrF5qbm/HFF18AAD788ENN+S12fUYzUsqOlLybpMxv7d+/H3Nzc8jLy8P8/LymglhNyKH1+vQKOQiCeAgVWQRBEATxjCPPb01PT/P8FrMBWq1WhIWF6TIRGlF7yxXx8vzWwMAAtwGy/FZpaSk33RnNSOlRxJvNZkxPT0OSJHz/+9/H0NBQwPwWsPwZKTny/FZvby/27t2LwcFBXLhwAR6Ph+/fYjZANTo6OnSPP+pRxBMEoQ4VWQRBEATxHGG1WrFixQqsWLECo6OjvLt1+/ZtvP3225ryW2pLi7WgpogXBAHJyclITk726rjV19ejrq4O4eHhmJyc1NVRmZycRFtbG9asWWNo/DEzMxNZWVncBsg6bnv37uX7t9huKSPFJlNaIAFaAAAUYklEQVTEb9y4UdPHs9fo3r17KCoqgtPp9MpvMRtgWVnZosyakY4Usz/SbiyCMA4VWQRBEATxnBIREeFlA2Q6eHl+y+VyITU11atT0tPT43NpsS+YIt5fR8psNvP81tTUFFpaWnDs2DEAwFdffYX6+nq+f8vf6FtTU5Pu8Udfivjo6Gie3+rr6+Mdt6amJoSEhGBubg5JSUm6u4BGFfErVqxAfn7+ovxWdXU1qqurkZmZCZfLhaKiIkiSZKgj5Xa7ERsbi+TkZM2fQxCEN1RkEQRBEMRzjtwGyLpJoiiq5rdiYmIMZ6T0KOJtNhsKCwuxf/9+lJeXIzo62iu/xbpJyvwWoE3IoSSQtU8QBKSmpiI1NRW7du1CR0cHampqcP36dQwMDOCnP/2pqg1QyXJmpOT5LTbe6Ha78dVXX2H//v2Ij4/H3NycLhPhyMgIuru7sW3bNs3jjwRBLIaKLIIgCIIgOIHyW6mpqbhx4wby8vIeaUYKeDi2tmbNGiQlJaGiogIDAwPcmNjc3MzzWy6XC8nJyZqXFsuRJAmiKCIzM1OTIt5sNqOgoAAdHR3o6elBVVUVmpubF9kAmTpejpGMlBZFfExMDLZu3YotW7agt7cXoiiivr4eAPD73/9eU34LMJa1IwhiMVRkEQRBEAShijy/dffuXb5/a3Z2Fm1tbfj00095fsvfOJpyabFWlB0peX5Lvn+L5bdiY2MRHh4OwJiQw4givqioCOvWrcO6desW2QDl+7dycnJgNpshiqLujJQeRbwgCEhLS0NYWBguXbqEsrIyzMzMoK6uziu/5XQ6F404ahVyEAQRGCqyCIIgCIIIiNwGeOPGDd5NYjZAtn9Lmd8CHmak9BQ+Q0NDfjtSZrMZ+fn5yM/Px9TUFJqbm+F2u3H9+nUAwOeff65qA1RjKRkp+fcktwH29fXx/Vssv1VUVGQ4I2VUEb99+3ZERUVhYmJiUX4rKyuL79+yWq2alxYTBBEYKrIIgiAIgtCMPL8l7yY1NDTg4sWLiImJQVlZGVwuF6KjowEsWAWNZqS0FGY2mw0rV65EXFwcfvGLX6CoqAiDg4PYu3evVzdJLb/lb2lxoOvzNf4oz2/t3r0bV65c4R23+fl5XLlyBV9//XXA/BawNEV8ZmYm70iFhIRgzZo1WLNmjWp+q6ioCNPT0zCbzbqKTYIg1KEiiyAIgiAIQ5hMJm4DnJ6e5t0klt9KS0tDbm6u7qXFS1XEv/rqq7BYLIvyWyEhIXz/VnJyMgRB0LS0WAkbf1y9enXA8Uez2YzCwkIUFhbiww8/xPDwMMLDwzXltwBjGSmmiK+oqFD9c3l+q6enB263G01NTZienkZRUZEuIQdBEOpQkUUQBEEQxJKxWq0oLy9HeXk5z2+xZb4A0NXVBYfDETC/BXgvLdYKU8Sz0TcAqvmtS5cuoba2FrGxsXA6neju7jYs5NBT+AwPD6O3txfbt2/Hpk2bVPNbhYWFPL9lMpm8OlJahBwMreOPgiAgPT0d6enpyM7Oxh//+Edd2nuCIHxDRRZBEARBEMuKPL81MDDAd0v94Q9/4Pktl8uFlJQU1e6W2tLiQPhTxPvKb7ECMDw8HA0NDZryW8DSMlLs+nzltzweD0JDQ1FaWorExES/HSk15Ip4PeOPLDemp9gkCMI3VGQRBEEQBPFIkNsA2f4tZX6Lme5YfkutI6UFlpHKzs72+3Esv7Vy5UqcPn0aJ06cgMlkwt69e732bzEboJJAQg41/HWkfOW3Ll68iLm5OQDA3bt3cffuXU3dLCPjj1NTU4aEHARB+IaKLIIgCIIgHjlms5nnt6ampvj+rZMnT+LkyZNIT0+H0+lEUFCQrqXFADAxMWFIEd/R0YG4uDj88Ic/5PktuQ2Q7ZZKSkriBVWgpcVqBMpIMeT5rXv37uHHP/4xgoODecYtUH6LXZ/ejhQbf6RRQYJYPqjIIgiCIAjiz4rNZvPKb7Fs0r59+yAIAsxmM2ZmZjA3N6eps7JURbzJZEJKSgpSUlKwa9cudHR0eOW3HA4HnE4nysrKDGWk2PijHmtfb28vZmZm8PrrryM2NjZgfgvwFnI8akU8QRD+oSKLIAiCIIjHRmRkJDZt2oSKigovG+Cnn34Ku93ObYC+8lvA4qXFWvBl7TObzSgoKEBBQQHPb4miyG2AAJCRkYHp6WlN44zLoYg3mUzcBtjb26ua33K5XOjr6zMk5NCriCcIIjBUZBEEQRAE8diR57fkNsD6+nrU1dUhNjYWZWVlXvktYKEj1dvbi8rKymVXxMvzW8PDw/jTn/6E/v5+NDQ0cLmEv/wWYCwj5UsRLwgC0tLSkJaW5pXfqqurw4ULFxAcHIyQkBCEhoZq/lpGFPEEQQSGiiyCIAiCIJ4ofNkAlfmtkpISQxkpI4r48PBwDA8Po6SkBOvXr+fGRJbfYgWgPL8F+F9a7AstGSlmXywqKsLk5CTq6upw4sQJzMzM4N1330VWVhacTqdfgYhRRTxBEIGhIosgCIIgiCcWeTdpZGSE79/at28fDh48CJPJhPj4eF3dG6OK+MnJSbhcLm4DlOe3Ll68iAsXLvD8ltPphMVi0by0WI7e8Ue73Q5JkgAAf/u3f4tr167B7Xbjq6++wv79+1FUVASn04ns7Gyv69Aq5CAIQj9UZBEEQRAE8VQQFRXF81v9/f1cBnHr1i28/fbbPJuUnJzsc3RwqYp4eUdKmd9qamqC2+3m+a3Y2FjMzc2hsLBQ89dZqiI+IyMDGRkZ2LJlC3p6euB2u9HU1ITGxkaEhYXxjFtiYqLmpcUEQeiHiiyCIAiCIJ4qBEHgNkB5fuvy5cs8v8W6SVFRUV6f629psS9YRmrNmjU+O1I2mw2rVq3CqlWrMDw8DLfbjTNnzgAAfvvb36raANVYLkW8IAhIT09Henq6V36rtrYWNTU1iIuLw8jIiO6lxQRBaIOKLIIgCIIgnlp85bdOnDiBEydOICMjg++WstlsmpcWy2GKeK17pKKjo+F0OnHy5EmsXr0agiDA4/EssgEmJiZ6dauMZqQCKeLl+a2JiQk0NTXhwoULmJmZIeEFQTwiqMgiCIIgCOKZQJnfYuOEe/fuxYEDB5CbmxuwI6XGUhTxFRUViIyMxK5du3g3ieW34uLi+P6tyMhILuTYtGmT5q+jVxEfEhKCNWvW4Nq1a5icnNQl5CAIQjtUZBEEQRAE8cwRFRWFzZs3Y9OmTejv7+f7t1i3CFjQlvvLbwHGM1KiKHp1pMxmMwoLC1FYWIjJyUme36qurkZ1dTUyMzP5x+nJSC1VEa9naTFBENqhIosgCIIgiGcWeX5LbgO8dOkSamtr/ea3AGN7pAJ1pOx2O1avXo3Vq1fz/JYoihgeHoYgCNi3b5+m/Ba7Pr2K+ObmZt1LiwmC0AcVWQRBEARBPBf4sgH6ym9pXVqsRI+1Lzo6Glu2bEF8fDw+/fRT5Obm4urVqzy/xfZvKfNbgO+lxYEQRREOhwNJSUmaP4cgCH1QkUUQBEEQxHOH0gbI9m/t3bsXBw8eREFBAZKSknQvLdabkWKwjtR3v/tdSJLE81t1dXXcBsg6bqzg07K0WMnw8DB6enqwfft2zeOPBEHoh4osgiAIgiCea6Kjo3l+q6+vD263Gx6PB01NTRAEAb29vYiPj0dSUlLAwmQpGSm5kMNffisrKwtOpxMNDQ2GhRw0KkgQjxYqsgiCIAiCILCQ30pNTUVqaqpXfquhoQGXLl2Cw+Hg3SRfinUjGSl/inh5fmtoaIgbE7/66isAQEJCAq5evYrs7OyAI4NGFfEEQeiHiiyCIAiCIAgFvvJbx48fx/Hjx5GZmcnzW2wscHJyEm1tbY9MER8TE4OtW7diy5Yt2LNnDxoaGjAyMoLf/va3CAsL4/u3EhISVDtuakuLCYJ4NFCRRRAEQRAE4Qdlfot1k/bs2YMDBw6goKAATqcTIyMjupYWA8YU8QDQ1dWFzMxM/NVf/RXPb9XW1qKmpgbx8fF8/5Zc2BFoaTFBEMsHFVkEQRAEQRAaYTbAzZs3L8pvmc1m2O12zM/PQ5IkTUXTUhTxmzdvRlBQEIqKilBUVOSV3zp27BiOHTuG7OxsOJ1O5OfnGxJyEARhDCqyCIIgCIIgdKLMb7FuUnt7Oz744ANN+a2lKuKLioq8ft9XfuvLL7+E2Wym3VgE8WeEiiyCIAiCIIglYDabVW2A/vJbgHdHSiuzs7OaOlLy/FZvby8+//xzTE9P6xJyEARhHCqyCIIgCIIglgl5N0ktv1VYWAin04mcnByekVJ2pPyhVxEvCAIcDgfGxsZ0Ly0mCMI4VGQRBEEQBEE8ApT5LVEU0dTUBI/Hg9DQUExNTSErKwsWi0Xz32lUEa93aTFBEEuDiiyCIAiCIIhHiDy/tXv3bly5cgWiKKK9vR0dHR14//33uQ3Q3/4qtaXFWtCqiCcIYvmgIosgCIIgCOLPhK/8VnV1Naqrq5GZmQmXy4WioqJFmSt/S4t9YVQRTxDE0qAiiyAIgiAI4jHgywb41VdfYf/+/V75LZPJZKgjxRTxZWVlj+rbIAhCBSqyCIIgCIIgHjNKG6Ayv5WXl4eenh5s375dc0dKroj3N4ZIEMTyQ0UWQRAEQRDEE4IgCEhLS0NaWhrPb7EOFwCIoghBEOB0OgPu1jKiiCcIYnmgIosgCIIgCOIJhOndi4qKeH5LFEWe38rKyoLT6VTNbwG+lxYTBPHooSKLIAiCIAjiCSdQfquoqAhOpxPZ2dkwmUyYnZ2Fx+MJuLSYIIhHAxVZBEEQBEEQTxG+8luNjY0ICwtDaWkpwsPDMTU1pXlpMUEQywsVWQRBEARBEE8hvvJbtbW1mJ+fR1RUlK6lxQRBLB+CJEmP+xo4giCMAWh73NdBPBYcAG4/7osgHhv0839+oZ/98wv97J9f6Gf/fPOs/fwzJEmKU/7mk9bJapMkafXjvgjiz48gCBfpZ//8Qj//5xf62T+/0M/++YV+9s83z8vP3/S4L4AgCIIgCIIgCOJZgoosgiAIgiAIgiCIZeRJK7J+/rgvgHhs0M/++YZ+/s8v9LN/fqGf/fML/eyfb56Ln/8TJb4gCIIgCIIgCIJ42nnSOlkEQRAEQRAEQRBPNVRkEQRBEARBEARBLCNPTJElCMJuQRDaBEHoEATh/3rc10M8OgRBSBME4YQgCM2CIDQJgvBPD34/RhCEo4IgXHnw/9GP+1qJR4MgCGZBEOoFQdj34NdZgiBcePD+/4MgCJbHfY3E8iMIQpQgCH8SBKFVEIQWQRA20Pv++UEQhP/Hg3/newRB+EQQBBu9959NBEH4hSAItwRB8Mh+T/W9Lizw4wf3gFsQhJWP78qJpeLjZ//mg3/vuwVB+EIQhCjZn/3Lg599myAIux7LRT8inogiSxAEM4D3ALwIoBjAfxAEofjxXhXxCJkF8P+UJKkYwHoA//3Bz/v/AlAtSVIegOoHvyaeTf4JQIvs1/83gB9JkpQLYBjA3z2WqyIeNf8bwCFJkgoBuLBwD9D7/jlAEIQUAP8IYLUkSaUAzAC+C3rvP6t8BGC34vd8vddfBJD34H8/APD+n+kaiUfDR1j8sz8KoFSSJCeAdgD/AgAPnv2+C6Dkwef89EFN8EzwRBRZANYC6JAkqVOSpPsAfg/g1cd8TcQjQpKkAUmSLj/45zEsPGilYOFn/vGDD/sYwLceywUSjxRBEFIBvAzggwe/FgBsB/CnBx9CP/tnEEEQIgFsBvAhAEiSdF+SpBHQ+/55IgiAXRCEIAAhAAZA7/1nEkmSTgMYUvy2r/f6qwB+JS1QAyBKEISkP8uFEsuO2s9ekqQjkiTNPvhlDYDUB//8KoDfS5I0LUnSNQAdWKgJngmelCIrBUCP7Ne9D36PeMYRBCETQDmACwASJEkaePBHNwAkPK7rIh4p7wL4PwHMP/h1LIAR2b+A6f3/bJIFYBDALx+Min4gCEIo6H3/XCBJUh+AtwB0Y6G4ugvgEui9/zzh671Oz4DPF28AOPjgn5/pn/2TUmQRzyGCIIQB+AzAP0uSNCr/M2lhtwDtF3jGEAThFQC3JEm69LivhfizEwRgJYD3JUkqBzAOxWggve+fXR7kb17FQrGdDCAUi0eKiOcEeq8/nwiC8D+xEBn57eO+lj8HT0qR1QcgTfbr1Ae/RzyjCIIQjIUC67eSJH3+4LdvshGBB/9/63FdH/HI2Ajgm4IgXMfCWPB2LOR0oh6MEAH0/n9W6QXQK0nShQe//hMWii563z8fVAK4JknSoCRJMwA+x8K/D+i9//zg671Oz4DPAYIg/C2AVwD8lfRwSe8z/bN/UoqsOgB5DyxDFiyE4PY85msiHhEPMjgfAmiRJOkd2R/tAfA3D/75bwB89ee+NuLRIknSv0iSlCpJUiYW3ufHJUn6KwAnAHz7wYfRz/4ZRJKkGwB6BEEoePBbOwA0g973zwvdANYLghDy4L8B7OdP7/3nB1/v9T0Avv/AMrgewF3ZWCHxDCAIwm4sxAS+KUnShOyP9gD4riAIVkEQsrAgP6l9HNf4KBAeFpOPF0EQXsJCVsMM4BeSJP2vx3tFxKNCEIQKAF8DaMTDXM7/Bwu5rE8BpAPoAvB/SJKkDM4SzwiCIGwF8P+SJOkVQRCysdDZigFQD+B7kiRNP8bLIx4BgiCswILwxAKgE8B/wsJhH73vnwMEQfj/AfgOFsaF6gH8ZyzkL+i9/4whCMInALYCcAC4CeD/C+BLqLzXHxTd/4qF8dEJAP9JkqSLj+GyiWXAx8/+XwBYAdx58GE1kiT98MHH/08s5LRmsRAfOaj8O59WnpgiiyAIgiAIgiAI4lngSRkXJAiCIAiCIAiCeCagIosgCIIgCIIgCGIZoSKLIAiCIAiCIAhiGaEiiyAIgiAIgiAIYhmhIosgCIIgCIIgCGIZoSKLIAiCIAiCIAhiGaEiiyAIgiAIgiAIYhn5/wO5hAq95Wi06AAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -314,7 +313,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -323,7 +322,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAANOCAYAAADj0sYQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd1gU5xbGXwmaYg1iNxqjxhix686ydBAExIIoCCrFgiVqFKRLUwHFjpUigthb7B3UiIo9icaKhaixIKLSpCzn/kGYC2xhZ9WYmO/3PPvcy8ycOcMw8Zmz53vfU4OIwGAwGAwGg8FgMBiMd4PGh74ABoPBYDAYDAaDwfiYYEUWg8FgMBgMBoPBYLxDWJHFYDAYDAaDwWAwGO8QVmQxGAwGg8FgMBgMxjuEFVkMBoPBYDAYDAaD8Q7R/NAXUBFtbW36+uuvP/RlMBgfLdnZ2cjLy0PdunVRr1491KhR40NfEoPBYDAYDMa/losXLz4nokZVt/+jiqyvv/4aFy5c+NCXwWB8tPj6+iI8PBypqak4dOgQNDU1MWDAAPTo0YMVXAwGg8FgMBgCqVGjRoa87f+oIovBYLw/7t27h9atW0NDQwOGhoYwNDREQUEB9uzZg61bt0JbWxv29vZo1arVh75UBoPBYDAYjH81rMhiMP4jbNmyBWPGjKm07fPPP4e9vT3s7e2RmZmJLVu24I8//sB3330HOzs71KtX7wNdLYPBYDAYDMa/F1ZkMRj/AYgIL168QMOGDRUe06hRI/zwww8AgBs3bmDp0qX47bff4OLiAgsLC2hqsn8uGAwGg8FgMFSBvTUxGP8Bzp07B47jVD7+u+++w48//ghLS0t88cUXCA4ORs2aNTFgwAB0796d6bcYDAaDwWAwlMCKLAbjP8C+ffsQEBAgKCYiIgLDhw+HsbExjI2NUVBQgN27d2Pz5s1o1KgRHBwc8NVXX72nK2YwGAwGg8H498KKLAbjI6eoqAhEhE8//VRQXHJyMk6fPs3//Pnnn8PBwQEODg54+vQptmzZgkePHvH6rbp1677rS2cwGAwGg8H4V8KKLAbjI+fgwYOwtLQUFJORkYH69etDQ0P+vPImTZpg8uTJAIDr168jKioKubm56NKlC4YOHcr0WwwGg8FgMP7TsDchBuMj5/Tp04iIiBAUExQUBC8vL5WO7dixIwICAvDzzz8jKCgIV69eRc2aNTFw4EB069aN6bcYDAaDwWD852BFFoPxEZOdnY0GDRoILnRu3ryJPn36CIqZM2cOYmNj0b59e+Tn58vot1q2bCnofAwGg8FgMBj/VliRxWB8xKxfvx52dnaCYn7++Wd88803gmJKS0vx4sULtG/fHgDwxRdfYNiwYRg2bFgl/VbHjh0xePBgpt9iMBgMBoPxUcOKLAbjIyY5ORnr1q2DtrY2AgICoKurW23MnDlzsGTJEkF5EhMTYWBgIHdfRf3WtWvXsGTJEuTl5cHIyAh9+vRh+i0Gg8FgMBgfHTWI6ENfA0+vXr3owoULH/oyGIyPgrt37+LIkSMYN24crl+/juDgYPzxxx/4/vvvMXPmTLnL90pLSyGRSJCWliYol6GhIfbu3Yt69eqpdHxpaSlcXV2Rl5eHLl26YODAgejatSvTbzEYDAaDwfhXUaNGjYtE1KvqdvYVMoPxkbJ161aMHTsWQJk5xZYtWwAA+/fvh5ubG3JycmBlZQUfHx989tlnAIA1a9bA0NBQUJ7c3FwQkcoFFgBoaGjg9u3bOHXqFN68eYNdu3Zh06ZNaNy4MRwcHNCiRQtB18BgMBgMBoPxT4IVWQzGRwgRITs7G1paWjL7rK2tYW1tjZKSEixbtgxmZmbQ1NSEu7s7EhISsG/fPkG5IiIi4OTkJCgmIyMDdevWhYaGBr744gs4OjrC0dGxkn7r+++/x+DBg1GnTh1B52YwGAwGg8H40LDlggzGR0haWhoeP34MW1tblY5/8eIFAgICsHHjRujr6yMwMBAcx6kUKxaLcfr0aYUzteTh4uKCESNGwNzcXOExv//+O3766Sfk5eXBxMQEZmZm+OSTT1TOwWAwGAwGg/G+YcsFGYz/EPv370dAQIDKx2tpaUFLSwtz586Fnp4eQkND8eDBA3Tq1AkzZ85UuHzv/v37SocWK+LmzZtKCywA6NSpEzp16gSpVIoTJ05AIpHAysoKtra26Nq1q6B8DAaDwWAwGH8nrMhiMD4yioqKQET49NNPBcUlJyfzHamtW7cCAPbu3QsXFxfk5eXBysoK3t7evH4LEDa0uJzU1FS0adNG5eM/+eQTGBsbAwC8vb2xc+dObNy4EU2aNIGDgwOaN28uKD+DwWAwGAzG+4YVWQzGR8aBAwdgZWUlKObevXto0KCBTEfKxsYGNjY2KCkpwdKlS2FmZoaaNWvC3d0dw4YNw61btwQPLQ4PDxdsEV9uyPHFF1/AyckJTk5OePz4MbZs2YLHjx+jU6dOsLW1ZfotBoPBYDAY/wiYJovB+Mjw9fVFRESEIDt0Z2dnuLi4wMzMrNpjnz9/jpkzZ+Lo0aPIzs7G7t270bt3b5XylJaWQldXF2fPnlX52gDAwMAA+/btU+hgePXqVfz000/Iz89n+i0Gg8FgMBh/G0yTxWD8B8jOzkaDBg0Ez5u6deuWSgUWAGhrayMqKgrW1taIjIzEnDlz8PDhQ3Tu3BkzZ85UunzvfVnE6+joQEdHB1KpFMeOHUNgYCBevHiBiRMnokuXLoLyMRgMBoPBYLwtrMhiMD4itm7diqFDhwqKOX78ONq2bSsoprS0FC9evOCXEwLA7t274ezsjLy8PPTr1w/Tp0+vpN8CoLZF/PDhw1U69pNPPkGfPn3Qvn17uLm54erVq9iwYQOaNm0Ke3t7pt9iMBgMBoPxt8CKLAbjI2Lnzp2wtrYWFDN37lwsW7ZMUIy8jtSAAQMwYMAAlJSUICoqitdvTZgwAUOHDkV+fj5KS0sFDS0G/m/IIYSgoCD4+fnB3Ny8kn7rzz//hI6ODtNvMRgMBoPBeK+wIovB+Ei4e/cuWrduDTc3N+Tm5sLS0hI+Pj4y3aSKlJaWIjs7W3AnKzExEXv37pW7T1NTEx4eHvDw8MDz588RGhqKRYsWITMzE0OGDBGUJyMj451YxDdr1gw//vgjAODKlStYuHAh3rx5AxMTE5iamjL9FoPBYDAYjHcKK7IYjI+ErVu3IiwsDFpaWigpKcHy5cvRp08faGpqYuzYsXB0dJQpVuLj42FkZCQoT25ursodKW1tbSxduhQA0LVrV6Snp0NXV5fXbzVt2lRpfGBgIKZPny7o+qqziO/cuTM6d+7M67dmzJiBTz/9FH369IG+vr6gXAwGg8FgMBjyEPb1MIPB+EdCRMjOzoaWlhaAsm7Sjz/+iNTUVOzYsQMXLlyARCJB//79Kzn7JSYmChpaDJRZsI8cOVJQzL1799C0aVNs374dZ86cQb9+/TBixAjo6uoiPDwcRUVFcuNu3bpV7dBiedc3c+bMao8r129FRESgWbNmCA8Ph4+PDxYvXozHjx8LyslgMBgMBoNREdbJYjA+AtLS0iAWi+Xu09LSwqJFiwAAv//+O0JCQvDgwQN06NABhYWFgjVSKSkpgjVSwcHB8Pb25n8eOHAgBg4ciKKiIixduhQmJiaoVasWJkyYAHt7ewDAzz//jG+++UZQnnJDjvbt2wuKW79+Pfbu3Yt69erhzz//xKZNm/DkyRN07twZtra2qF27tqDzMRgMBoPB+G/DiiwG4yNg//79CAwMrPa4Tp06YevWrQCAoUOH4vXr19DV1YWVlRW8vb2V6rcAxUOLq0ORRXytWrXg6ekJT09PXr+1cOFCNG3aFE+ePEFSUpKgPImJiTAwMBAUU9WQo3nz5pg2bRoA4LfffsOCBQvw5s0bmJqawsTEhOm3GAwGg8FgVAsrshiMfznlS+1q1aolKO7Bgwe4du0aSktLsWzZMt4NUJF+CyjTSHl5eQnKc/z4cZU6UhX1W7/++itMTU0xcuRIdOvWDSEhIdXqt4AyjZk6FvFOTk5y93Xp0gVdunSBVCpFSkoKZsyYgc8//xyDBw+Gjo6OoDwMBoPBYDD+O7Aii8H4l7N//37Btu0VO1IaGhqYOnUqpk6diqysLMycORNRUVFo3LgxgoKC0Lt3bz7u9u3bKg8tLmfu3LmIiooSFHPhwgWMHj0akZGR2LlzJ4YPH46CggL0798fnp6ecgtKVYYWy+Po0aM4deqU0mM++eQTmJubw9zcHLm5ubCxscF3332Hjh07wsHBQaUCkMFgMBgMxn8HVmQxGP9y0tLSEBERISgmMDCwkkaqnIYNG2LJkiUAgKtXr/L6rc6dO8PCwgLt2rUTlEddjVRFi/hBgwZh0KBBKCoqwpIlS3j91g8//FDJEl7I0OJyMjIyUK9ePUHLH+vUqYM3b95g1apVlfRbXbp0waBBg/DFF18IugYGg8FgMBgfH6zIYjD+xWRnZ6NBgwaoUaOGoLjbt2/D1NRU6TE6OjrYtm0bAGD37t1wc3PDV199hdmzZ2P69OnV6reAsuV7xsbGgq5NkUV8rVq14OXlBS8vLzx79gyhoaGYP38+mjVrhsDAQLWHFr+NRXzz5s0xdepUAGVLHOfNm4fCwkKYmZnB2NiY6bcYDAaDwfiPwoosBuNfzJYtWzB06FBBMSkpKYI7UjY2NmjXrh1OnTqFpUuX8vqtcePGwcHBQWEnaO3atQqHFisiPDwcI0aMUHpM48aNsXz5cgDAL7/8Ai8vL9y8eRMTJ05UWb8FyA4tVoWIiAgsXLhQZnvXrl3RtWtXSKVSJCcnIzAwEJ9//jlsbW2ZfovBYDAYjP8YbE4Wg/Ev5u7du2jbtq2gmMjISJXmSFUkLi4OxsbG0NTUxLRp03Dq1Cls27YNp0+fhq6uLgYMGIDz589XilFXI5WSkgJ3d3eVj+/WrRuaNWuGbdu2wdzcHE5OTpBIJJgzZ47C+VtA9UOL5VFaWoqsrCx06NBB4TGffPIJLCwsEB4ejmnTpuHy5cswMTFBVFQUnjx5Iigfg8FgMBiMfyesk8Vg/Eu5efMmdu7ciS5duih0A6xKaWkpsrOzBRdmSUlJMq59Fd0Ay/VbDx8+RJcuXRAaGoqlS5eqNbT4bS3i7ezsUFRUhMWLF8PY2BifffYZJk6cWEm/BZR1zMr1Z6oi1CK+Tp06sLOzQ3R0NOzs7LBx40Y8efIE3bp1w8CBA5l+i8FgMBiMjxTWyWIw/qX89NNP2L9/P86fPw+JRIL+/fvj7NmzSmPi4uKq1WJVJTc3FwCUdqTK9VtpaWno168fRowYgRUrVuDJkyd48+aNyrmCg4MFW8TLG1pcq1YteHt74/Tp09i0aROSk5PBcRxsbW3xyy+/qG3IsWbNGpXmkVUkIiICjo6OaNGiBaZNm4Y5c+agY8eOmDdvHvz9/ZGSkoLS0lJB52QwGAwGg/HPhnWyGIx/IUSEly9fom3btli8eDEA4Pfff+fdAL///nvMnDkTLVu2rBSXlJSEAwcOCMoVFhYmqCM1cOBAdOnSBe7u7qhduzav35owYQKGDh2qtEulaGixMubMmaO0I9W4cWOsXLkSAHDp0iWEhobi119/Re3atfHs2TM0btxYpTx5eXlyDTmq48iRI5Us4mvUqIFu3bqhW7duKCkpQXJycqX5W506dRJ0fgaDwWAwGP88ahDRh74Gnl69etGFCxc+9GUwGP94zpw5g2fPnmHgwIFy9+/btw+LFy9Gbm4urKys4O3tjaKiIvTr1w8nT54UlEssFuP06dOClvCNGDECbm5ufMH0/PlzhISE4Pz582jatCkCAwPRq1evSjEnTpxATEwM1q9fr3Ke0tJSSCQSpKWlqRwDAIaGhhg7dizWrFmDgoICDBo0CNOmTVM60HnGjBlo3rw5Jk6cqHKejIwMuLu749ChQ9Uem5OTg59++gnXrl2DpqYmJk+ejCZNmqici8FgMBgMxt9PjRo1LhJRr6rb2XJBBuNfyP79+2FlZaVwf79+/XDkyBGcPHkS9erVg5mZGb7//nu0b99e0NK0O3fuqKWRSk9Pr9SR0tbWxrJly3D27FnMmjULEREREIvFcHd3580g5s6di9DQUEF51qxZA0NDQ0Ex5YYcI0eOREpKCk6cOAEigrGxMUxNTbFjxw65ccnJyRg/frygXEIs4uvWrQtnZ2fY2Njg8uXLWL9+PXx8fLBx40bk5+cLystgMBgMBuPDwpYLMhj/MgoLC1GjRg2lXZdyNDU1MXXqVEydOhW9e/dG3bp1IZFI0LhxYwQGBqJ3795K44OCguDr6yvo+o4fP67UIr5Lly7Yvn07AGDnzp0YPnw48vLy8OjRI7Rq1UpQropDi1UlIiICTk5O/M+1atWCr68vfH198eTJE4SEhCAyMhLNmjVDSEgIunbtqtbQYgC4ceOGYIv48PBwLFq0CB06dAAR8fO3ioqK0KdPHxgZGQm+DgaDwWAwGH8vrMhiMP5l7N+/H9bW1oJi7ty5A21tbV679PvvvyM4OBgPHz6Ejo4OZs6ciebNm8uNEzpMeO7cufwMq+oYNGgQBg0ahOjoaKxfvx4mJiaoVasWfvjhBxk3wKooGlpcHcqGFjdt2hSrVq0CUKbfCg4OxuPHj5GVlYXw8HBBed6FRXxV/dbRo0cREBCA2rVrY/Dgwfj+++8FnZ/BYDAYDMbfA/s6lMH4l3H27FlwHCcoJigoCD4+PvzPnTp14t0ABw0aBBcXF+jq6mLWrFm8G6A6Q4vLLeKruv1Vx/r167F3716cOnUKmzdvRkpKCsRiMWxtbXHp0iW5MeHh4YIt4u/fv4/69eur1Anq0aMHdu7cibNnz6JGjRpYuXIldHV1ERkZqXT+VsXrEzqPLDExEfr6+nL3aWpqwtLSEhEREfjxxx9x7tw5+Pj4YMmSJbh//76gPAwGg8FgMN4vrJPFYPyLyMrKwpdffokaNWoIiktPT1fYkbKxsYGNjQ1KSkqwbNky3g3w+fPn2L17t6A85UOLhVB1aHHjxo2xYsUKAMAvv/yCmTNn4s8//0S3bt0QEhKCpk2bAigrAhV1pBQRFBQEb29vQTGpqano1asXNm7ciKKiIixYsICfvzV58mTY2trKxJR3pL799ltBudasWaPSPa9bty5cXV0BAFOnToW3tzfatGmD7t27Y+DAgfj8888F5WUwGAwGg/FuYe6CDMa/iFWrVsHCwkJQpyg5ORlr1qzBunXrVI7JzMyEjo4O2rRpo7J+CwAMDAywf/9+1K1bV+Vc/v7++Prrr+Hu7q70uJ9++gnLli1DQUEB9PX18csvv+Dw4cMq5wHKnBKFOhFaW1tjyZIlMjO1njx5guDgYPz6669o0aIFgoOD0aVLFwBAfHw8rl+/jnnz5qmcJz8/HxYWFkhNTRV0fbq6ujh16hRq1KiBX375Bbt27UJxcTHMzc1haGjI9FsMBoPBYLxHFLkLsk4Wg/Ev4t69e4KX4s2bN4+fE6UqO3bswKhRoxAREYGrV68iJCQEDx8+ROfOnREaGipXv1U+tFhIgQUAx44dqzRHShG2trawtbVFUVERRCIRSkpKYGpqiokTJ1ar3wLkDy2uDmVDi5s2bYro6GgAwIULFxAUFITHjx+jd+/eOH/+PI4cOSIoV1VDDlWoasjRvXt3dO/eHSUlJThy5Aiv37Kzs0PHjh0FnZvBYDAYDIb6sCKLwfiXkJ6erpZG6uXLl4INGJKSknDw4EEAgI6ODrZt2wYA2L17N0aOHIm8vDzY2Nhg+vTp+OyzzwCUDS12dnYWlOfevXsqa6TKqVWrFj777DOkpaXh2bNnCAkJwfz589GsWTMEBwejW7ducuOqG1osD1Ut4nv16oWdO3eCiLB27VqsX78elpaWsLOzw48//ghNzer/qT1y5Ijg5Y/BwcFyLeI1NTVhZWUFKysrvH79Gjt27EBCQgJatmwJBwcHlQcwMxgMBoPBUA9WZDEY/xJiYmKQkpKCM2fOYObMmWjZsmW1MbGxsTA1NRWU5/Xr16hRowbq1Kkjs2/AgAEYMGAASkpKsGTJEl6/NWHCBBw7dgxhYWGCcgUGBgrWSB0/fhxt27YFIKvfCg0NxePHj9G9e3eEhobyxYSyjpQyhFrE16hRA7du3UJYWBhGjRqFBQsWwNDQEF988QWmTJmCAQMGyI3LyMgQXGwCqlnE16tXj9dvPXjwAH379oWpqSlEIhEGDBjA9FsMBoPBYLwHWJHFYPwLICLUqFEDFy5cwL59++Dq6orc3FxYWVnBx8eH7yZVZd26dThw4ICgXGFhYXBxcVF6jKamJjw9PeHp6Ynnz5/jxx9/xK1bt2Bra4vAwED06iWzNFku6enpgovAuXPnYtmyZTLbu3Xrhp9++gkAsH37djg6OqKgoAADBw5EgwYN1B5arK5FvIaGBgICAhAQEIA///wTISEhCA8PR8uWLRESEgIdHR0+RsjQ4nLUsYhv0aIFPv30U8yfPx+XLl3CnDlzUFJSAgsLCxgYGDD9FoPBYDAY7whWZDEY/wJOnz4NiUQCAOjXrx/69esn4wY4duxYODo68i/Kr1+/BgC5HSllnDhxAhERESofr62tDaBMx9WwYUNev9W1a1fMnDmTdwOsSnVDi+VRbhFf3slShJ2dHezs7FBUVITFixfDx8cHnTt3xvbt22FnZ6dSroiICAwfPlzQ9SmyiG/evDliYmIAAOfPn0dAQACePHkCkUiE4OBg3Lx5U/DQ4oiICCxevFhQTFJSEvT09FCjRg307NkTPXv2RHFxMa/fqlOnDuzs7PDdd98JOi+DwWAwGIwqENE/5tOzZ09iMBiyBAQEUGFhocL9WVlZNGXKFOI4jvr3709nz54lLy8viouLE5QnPT2dLC0tBV8fx3Ey23766ScyNTUlsVhMYWFhMtdvaWlJd+7cEZQnNjaWvL29BcXk5OSQvr4+PX36lMaPH08cx9GgQYPo8uXLSuM4jiOpVCoo18iRI+nw4cMqHSuVSmnTpk3UpUsXatiwIS1YsICKi4tVjpV3z6vD0NCQsrOzFe5/9eoVxcfHk4+PDy1btoyePXsmOAeDwWAwGP8lAFwgOXUNWxvCYPzDKSwshIaGBmrVqqXwGC0tLSxZsgRpaWmIiIhAZGQkYmJicPr0afz5558q56o6tFgVFA0tHjRoEJKTk3HixAnUrFkTxsbGMDY2xpYtW3hDDqFuf4mJiQgICBAUEx4ejhEjRqBx48ZYuXIl0tLSEBgYiNDQUIjFYkycOBHPnj2rFHPv3j00aNBA8PI5IR0pDQ0NODg4oGXLljh+/Djy8/NhYGCAPn36VDsrKzExEQYGBoKuLT8/H6WlpWjQoIHCY+rVqwc3NzfMmTMH/fv3R2JiIvr374+tW7fyQ6oZDAaDwWCogLzK60N9WCeLwZBl+/btlJaWJijm1q1bZGVlRXv27KE+ffqQrq4uzZo1iwoKCpTGqdMd6du3L929e1elY58+fUoTJ06k1q1b0zfffEPnz59XOU9OTg7p6ekJvr7qOlJbt24lExMTEovFNHfuXCosLKQRI0bQ0aNHBeU5ceIEOTo6CoqR15F69OgRjRkzhjiOIzs7O7p69apMnIGBAb169UpQrsDAQFq+fLmgmIyMDDI3N6fz589TUFAQBQQE0IkTJwR3+BgMBoPB+FgB62QxGP9Ozp49C5FIJCgmODgYPj4+sLGxwZEjR/Dzzz+jdu3aMDMzg7GxMTZu3IjS0tJKMcnJyYLd94RaxDdu3BjLly/HV199hbVr1yI8PBwcx2H8+PF48uSJ0tiwsDCMHDlS0PWp0pEaMmQIUlJScOLECUilUhgbG2Pv3r28pk1V5syZg9DQUEEx8izimzdvjtjYWKSlpcHHxwf+/v7gOA5TpkzBixcv+I6UUEOOI0eOYPz48YJigoKC4OnpiV69eiE0NBTBwcHIyclBQEAAwsLCcPPmTUHnYzAYDAbjv0KNsgLsn0GvXr3owoULH/oyGIx/DFlZWVi9erVgm3OxWIy0tDS5+54/f46ZM2fi3LlzaNSoEYKCgtC7d29YWlpi5cqVghzrYmJicP/+fYSHh6scU+6KePLkSX7bTz/9hKVLl6KgoAADBgyAp6enzPJIsVjMu/apyogRI+Dm5gYzMzOVY44fP47FixejadOm+OWXX9C8eXOEhISgS5cuCmNKS0shkUgU3nNFGBoaYu/evdUWTKWlpdi8eTNiYmJw+/Zt9O7dG1u3blVp/hZQZhHv7u6OQ4cOCbo+juNw9uxZuftevXqF7du349atW2jVqhXs7e15ExQGg8FgMP4r1KhR4yIRydgqM3dBBuMfzJYtW2Bvby8o5ujRo/j2228V7tfW1kZUVBQA4OrVqwgJCcGDBw9w//59fPrpp4JyJSUlqWURX3Vosa2tLWxtbXk3QGNjY3z22WeYOHEihgwZgrt376qlkUpPTxdUYAFlFvFRUVF8V+/ixYsICgrC48eP+Y5O1WJC1aHFFRFiEa+hoQFHR0c4OjqC4zh0794dBgYGqF27NqZOnQobGxul8YqGFisjNTVVqWaufv36GDVqFICyIi4hIQHPnj3D119/jVGjRikcK8BgMBgMxn8B1sliMP7B+Pr6Ys6cOYJi+vbti+joaHz99dcqx0RHR+PQoUN4/fo18vLyYGNjA09PT6Uvyq9fv4aNjQ1+/vlnQdenakfq2bNnCAkJwaVLl/DgwQMEBgYKWu52/PhxxMbGYv369SrHlJaWQldXV2H3ZsuWLVi5ciUKCwsxePBg/Pjjj6hZs6bKHamKBAQEoGXLlpgwYYLKMVU7Ug8fPkRISAiuXr2Kli1bIjQ0FJ06dZKJU9bZVES/fv2wcOFCdOjQQeWYxMREHDx4EB06dEBJSQn69u0LPT09Nn+LwWAwGB8trJPFYPzLuH37tlpzpF69eiWowALKOlIHDx5EnTp1UFJSgqioKJiZmaFWrVoYP348hg4dKvOiLK8jVR137tzBl19+qdJLd+PGjbFixQoAQJcuXXDo0CEkJCSge/fuCA0NRePGjZXGKxparIz4+HgYGxsr3G9vbw97e3u8efMGCxYsgJGREWrWrImsrCy1hxYLoerQ4pYtWyIuLg5AmXbP19cXz549g1gsRnBwMLS0tNQaWlxaWoqsrCxBBRYArF69Grt370aDBg1QXFyMQ4cOISAgAHXr1sWQIUOUdlgZDAaDwfiYYF8vMhj/UKKjo6tdBiYvRujyuNevX0NDQ4MfWqypqQkPDw+cOnUKW7duRWpqKiQSCQYOHIiKneYTJ07wy8VURR2L+GPHjqFLly746aefkJaWhj59+sDR0RESiQSRkZEoKiqSiSktLcWLFy+qHVpcFVUt4j/77DMEBATg9OnT6NatG+rXrw+O42BnZ4fffvut2viMjAy5Q4urQ5lFPMdx2LNnD86cOQORSARbW1tIJBKMHj0aQUFBgvKUDy0WQn5+PqRSKW8RX7NmTdjY2CAiIgI//PADTp48CV9fX6xcuRLPnz8XdG4Gg8FgMP5tsOWCDMY/ECKCra0tnj9/Dk1NTYwdOxaOjo7VvpQbGBjgwIEDfMGkCt7e3ujQoQNGjx6t9Lhy/dbDhw/x9ddfIzMzE8nJySrnAdRbtmZlZYXly5fL6IPK9Vs7d+7EZ599hh9++AF2dnYAygw57t69K2ipZW5uLiwtLZGamiro+ioufzx//jxmz56NJ0+eQCQSITg4WK4ZhLOzM1xcXAQVxKmpqVi+fDk2btyockxeXh6+/fZbtGrVCrVr14aHhwesra2rjTM0NOQ7UqoSFBSExo0bY9KkSUqPu3//PrZu3Yrnz5+jZ8+e6NevH2rXrq1yHgaDwWAw/kkoWi7IiiwG4x9IamoqXrx4gQEDBuDFixeYOXMm0tLS0KhRI8yYMQMcx8nEvG+NVEUMDQ2Rl5eHWrVqwcbGBl5eXkqHJQNly+PWrFmDdevWqZxHVde+Z8+eITg4GJcvX0azZs1w7949nDx5EnXr1lU5l5+fH77++muMGzdO5Zh79+5hwoQJOHjwoMx1b926FatWrUJhYSGGDBmCKVOm8G6A6hSb1tbWWLJkiSCb/TVr1uDatWuYN28eHj58iKCgIFy7dg1fffUVQkND8f3338vE5Ofnw8LCQnCxqauri5MnT6rseEhEGDhwIBo3boymTZvC0tISenp6qFGjhqC8DAaDwWB8SJgmi8H4F3Hw4EF+iZeWlhYWL14MAPj9998REhKCP/74Azo6Opg5cyZatGgBAJg9ezbc3NwE5bl9+za0tLQEL1srKirCxYsXUVxcjKioKJiYmKBmzZqYOHGiQjfEefPmYeXKlYLyxMXFwcTEpNrjGjduzJ87NTUVAwcOhIWFBbp3746QkJBq9VtA2bJEoRqp4OBgeHl5yWzX0NCAg4MDHBwc8ObNG8yfP593AzQxMVHq2ieP8uWPQueYrVmzBnv37gVQpt+Kj48HAKSlpcHb2xuZmZmQSCQICgrCl19+CQCIiIiAk5OToDwZGRmoW7euygUWANSoUQNPnz7F7t27ef2Wv78/6tati6FDhwr+XRkMBoPB+Echb0Lxh/r07NnzHc9gZjD+fRQUFFBgYGC1x+3Zs4fMzMxILBZTaGgo9e7dm6RSqaBcjo6OdOLECUExR48epZEjR8psz8zMpB9++IE4jqOBAwfS+fPn+X1SqZQ4jhOUh4hIX1+fcnJyBMX4+PhQdHQ0ERFt3bqVTExMSFdXlyIjI6mwsFBuzN27d6lv376Cr0/o7/To0SNq3rw5devWjezs7OjKlSsqxcXFxZGXl5egXDk5OaSnp6f0GKlUSklJSWRoaEgSiYSWLFlCIpFI8HPk7OxMhw4dEhRz8uRJcnBwkNmenZ1NsbGx5O3tTStWrKDnz58LOi+DwWAwGH8nAC6QnLrmgxdWFT+syGIwiLZt20Znz55V+fji4mLy9vYmLS0tMjQ0pHXr1qn8kqxO4dO3b1+6e/eu0mN++eUXsrW1JY7jaOzYsRQREUF+fn6C8rx69Yr09fUFX5+8IqGwsJAiIiJIV1eXTE1NaceOHZX2Dx8+nJKTkwXlOXbsGDk5OQmKqVhsnjt3jgYMGEAikYgmT55MWVlZCuMMDAzo1atXgnL5+/vTihUrVD4+Ly+PJk2aRF9++SX16dOH9u/fr3KsOs+RtbU13bhxQ+kxd+/epblz55K3tzdt27aN3rx5IzgPg8FgMBjvE0VFFnMXZDD+YZw7dw69e/dW+XhNTU388ccf2LVrF7Zv346zZ89CV1cX/fv3x/nz5xXGJScnC7bULi0txcuXL6u1BO/atSt27NiBtLQ0WFtbY+7cuTh69CgiIiLkugHK411axNeqVQu+vr44ffo01q9fj0OHDkEsFmPw4MH47bffkJ6eDlNTU0G55s6di5kzZwqKWbNmDYyMjAAAvXv3xq5du3DmzBno6urCzs4Oenp6WLhwIUpKSvgYIUOLK5KcnCxIX/bFF1/g9evX2Lx5M1avXo0tW7aA4zjY29vj+vXrCuNSU1MFjwwoLS3F8+fPq7WIb9OmDby9vTFnzhy0bNkSYrEYM2bMQGpqatm3hAwGg8Fg/FORV3l9qA/rZDH+62RmZtLcuXMFx8nrJFy5coXs7OxIJBLR6NGj6dGjR5X2W1hY0P379wXlWblypVodKQMDAyosLKTIyEiSSCRkbGxMW7ZsURrHcZzgZWtOTk6UkpKi8vEXL14kjuOoYcOGNHHiRMrMzFQpTt3lj9V1pAoKCmjWrFmkq6tLZmZmtGfPHsEdKSKi+/fvk4WFheDrE4lEMttSU1OpX79+JBKJaNq0aZSdnV1pv5WVVbUdqaokJCSQh4eHoJi8vDzS09OjoqIi2r17N/n4+FB4eDjdunVL0HkYDAaDwXiXgC0XZDD++axYsYLu3bsnKObw4cPk7Oys9Jhdu3bx+q1Zs2ZRXl6eWkWCnp6eYI2Ut7c3xcbGVtr29OlTmjBhAq/funjxYqX96enpZGlpKfj63mb54+bNm8nY2Lha/RYR8ZohIeTk5Aha/vjw4UMaPXo01atXj+zs7Ojq1asqx44cOZIOHz4s6PpOnjxJw4YNU7hfKpVSYmIir99aunQpFRUVqV1sVi3WqiMwMJCWLl1aaRvTbzEYDAbjQ8OKLAbjX4CPj4/gGCEdqeLiYlqwYAF9/fXX1LJlS9q4caPK3aLyjpRQqutIXb58mddvjRs3jp48eUJOTk50/PhxQXmSk5Np+PDhgmLkdaTevHlDYWFhpKurSyYmJjL6LaIyQw6hGik/Pz9atWqVoJhyQ460tDSysbEhkUhEU6ZMUarfIpLfkaoOKysrlbtCeXl5FBgYyD9HBw8eVDlPXl4eSSQSwdcnFoupuLhY4f67d+/SnDlzyNvbm7Zv3870WwwGg8H4W1BUZDFNFoPxD+HWrVuCbatLS0vx6tUrtG7dWqXjNTU14eHhgZYtWyI1NRWnTp2CRCLBgAEDlOq3gDKLeBcXF0HXl56eLlcjVZFu3brx+i1zc3M4Ojpi7969OHPmjMr6LQCIjIzErFmzBF2fPIv4Tz/9FP7+/rx+6+DBgxCLxbCzs8Nvv/2G3NxcABCskUpJScHYsWMFxZRbxHMchz179uDMmTMQiUQYPHgw9PT0sHjx4kr6LQD4+eef37tF/BdffIGZM2fiq6++woEDB7Bx40aIxWI4Ojri5s2bSmMjIiIwfPhwQdenikV8mzZt4OPjgzlz5qBFixYICwuDk5MTTp06xfRbDAaDwfjbYXOyGIx/CNu3b8eECRMExaxatQrm5uaCYl6/fo0aNWqgdevWWLp0KQDg6tWrCAkJwcOHD9GlSxeEhoaiWbNmleJ+/vlnzJkzR1CuoKAg+Pn5qXy8nZ0dGjRogLi4OGhoaMDIyAifffYZJk2aBDs7O4VxqhpyVCUpKQkHDhxQuL9Zs2aIjo4GAFy4cAFBQUE4d+4c2rZti+fPn0NbW1ulPPfu3UODBg0EzyO7desWzMzM+J81NDQwfPhwDB8+HG/evEFkZCQMDQ1Ru3ZtTJs2DdbW1oiIiEBUVJSgPAkJCTAwMBAUk5+fj9LSUujo6CAhIQFAmQmGh4cHnj9/Dn19fQQGBqJBgwaV4o4ePYpTp04JyhUSEiJ3Hpk8atSoAY7jUFJSgmvXruH58+fw8/ND/fr1MXToULRr105QbgaDwWAw1EJee+tDfdhyQcZ/FalUSiKRiNLS0gTF6enpUV5enqCY6dOnU3x8vML9O3fuJFNTUxKLxTR79mx68+YN3bp1i6ysrATlIXo3FvFPnz6l8ePHE8dxNGjQILp8+bJMzKpVqwQbcgjVSJXDcRxt2rSJ12/Nnz9f6TI2ojKN1NGjRwXlOXHiBDk6Oqp07IMHD2jUqFEkEomoYcOGgvRbROotf5wxYwYtX75c7j6pVEoJCQlkaGhIenp6tGzZMpJKpWobcqjzHPXr16+SIceLFy8oOjqavL29aeXKldUuuWQwGAwGQxXANFkMxj+Xn3/+mRYvXkxDhgwhjuPIzc2NHjx4oDQmOzv7vWikyikuLqb58+eTRCKhRo0aqTQguSKKhhYrozrXvosXL9KgQYNIJBLRhAkT6OnTp0Sk3tBiX19fGUOO6qg6tLigoIBmz57Nz9/atWuX3DixWCwoDxGRpaWlYOe8uLg4cnBwIBsbG+I4jqZOnVptMaHK0GJ5qPocleu3xGIxNW3alMLCwgTlqc6QQx7VPUd37tyhOXPmkI+PD+3YsYPptxgMBoOhNqzIYjD+wQQEBFBRURH/8969e3k3wNDQUCooKJCJmT59Oq1Zs0ZQHnU7Uj169KBJkybxboDnz5+vNsbCwqLaocVVEdKR2rp1K5mYmJBIJKLWrVsrdQOUhzoW8cqGFj969IjGjBlDHMeRnZ0dXblyhYiIjh8/rtbQYnXMKyp2pKRSKa1bt46MjIxIIpHQ4sWL5Xbc1LWINzc3F3x93bt3JxcXF+I4joYNG6ZSEanK0OKqJCYmqmQRX1paSmfOnKHAwEDy9/envXv3UmlpqaBcDAaDwfhvw4osBuMfSkFBAQUFBcndV1xcTIsWLSKJREJGRka0bt06vjBQp0gYNmwYnTx5UlDM4cOHK3Wkfv31Vxo8eDBxHEdjx46lx48fy8SoWySoYxHv5eVFAwcO5N0At2/fXm3M+7aIP3fuHA0YMIBEIhG1bNmSzp07JyhPbGwseXl5CYpR1pHKz8+n4OBgEovF1KdPH9q/fz+/T53nyNnZ+a0t4k+ePEnW1tbEcRxNnz5d7nJFdeeRGRoaqmURP2bMGPLx8aGIiAhKT08XnJfBYDAY/z1YkcVg/EPZunWrSi/hz58/pylTphDHcWRsbKyWDbY6L6zKLOLL9Vu6uroUHh7Od5NWrFih1tBidTVS5UXC48ePady4ccRxHNna2tKvv/4qN8bJyYmOHTsmKE9KSopgi/iSkhL65ptv+G7SggULqtVvEamnkfL396eVK1dWe9wff/xBbm5uxHEc9evXT+2lgkJRZBEvlUopPj6e128tX76c/3u+zdBioVS0iM/KyqLo6Gjy8fGh6OhoevHiheDzMRgMBuO/gaIii7kLMhgfmAsXLih1ziunYcOGWLJkCQDA2toaRASxWAwdHR3MnDkTzZs3Vxp/+PBhdOjQQdC1VWcRP3DgQAwcOBBFRUVYsmQJTExMUKtWLTx69AiXLl0SlGv27NlwdXUVFHPnzp1KFvFNmzbFqlWrAACXLl1CcHAwHj9+jJ49eyIkJASNGjXi44yNjQXlioyMxIoVKwTFrFmzBkOGDMHcuXPx5s0bzJ8/H/r6+qhduzZ+/PFHDBgwQCYmNzcXRCTYIj45ORmnT5+u9rivvvoK8fHxAABLS0uUlJRALBZDIpEgKChIxg2wKqmpqYJdHJVZxGtoaMDNzQ1ubm7Iz89HREQE9PT0UK9ePTx69AipqamCcs2ZMwfDhg0TFPPHH3+gTp06vEW8lpYW3N3dAZQ9K9HR0Xj58iXEYjGsra1Rq1YtQednMBgMxn8QeZXXh/qwThbjv0ZmZiZFRkYKjqvYSdizZw+ZmZmRrq4uzZw5U65+i6jMtU/VocXlrFixgvz9/QXF3Lp1i5o0aUJisZgGDhxIFy9eVClOnWVrjo6OKg0t3rx5M+8GOHbs2HdupKAIRR2pBw8e0OjRo3n9VkU3QF9fX7WHFgulfEmnVCqlpKQkMjIyIj09PYqKilLYcbO2thZsyBEfH0/Tp08XFHPt2jXS1tYWpN8iqn5osTxcXFyqHahcWlpKp0+fpsDAQJoxYwadPn1a8PPKYDAYjI8PsOWCDMY/j+XLlwsufA4ePEguLi4y24uLi2nBggW8fmvjxo38S6BUKlXL4U4djdT06dMpLi6OiIguX75Mtra2xHEcjRs3jv7880+5MX+XRXxhYSG1a9eOevbsSaamprRjxw6V4qKjo8nX11dQLlUt4tPS0qh///4kEoloypQp1L17d8Ev7yNGjHhnFvF5eXmV9FsHDhzg96n7HBkYGLyVRfyJEyfIysqKRCIReXl5KTxXRkaGWoYc6jxHvXv3pqlTp9KcOXPozp07gnMyGAwG4+OAFVkMxj8QHx8fwTHKNFLlZGZm0uTJk4njOOrfvz95eHjQjBkzBOXJzs5WSyMlEonkFglLly6lxo0bk1gspoiIiEpugI6OjnTixAlBeY4ePUojRowQFFOxSKio3xo8eLBC/RaR+hbx0dHRgq5twYIFpKWlRRKJhBYtWqRyR+ZdaqQqkpGRwbsB2tvbU2hoqGBDjrfRSFV9jqRSKcXFxZGBgQHp6enRihUrKh3j4uJChw4dEpQnNTWVHBwcBMVUNHbJysqiVatWMf0Wg8Fg/EdRVGQxTRaD8YG4efOmXI2KMkpKSvD69WuFGqlytLW1ERUVBQC4evUqjI2N0aZNGzx58gShoaHV6rcAICwsDKNGjRJ0fbdv30bDhg15jVRFTp8+jW3btoHjOCxevBjGxsb47LPPMHHiRNy9exeGhoaCcs2bNw8rV64UFBMbGwsTExMAlfVbFy5cQFBQEB4/foxevXohNDQU2traAMo0UgBQp04dQbmOHTuGsLAwlY/X0NDApUuXsGXLFujp6SEyMhKGhob44osv4OHhAWtra7lxx48fR9u2bQVdmzKNVEVatWqFhIQEAGVarIEDB6JNmzbw8PBQSb8FABEREXBychJ0fRkZGahXr57Mc6ShoYHRo0dj9OjRyM3NRXh4OHR1ddGgQQN4e3vjxo0bsLCwEJQrPDwcCxcuFBSTlJQEPT09AGX6rXHjxgGorN/S1dWFlZUV028xGAzGfxV5ldeH+rBOFuO/RFhYGL18+VJQzNKlSwUPBa44tLjcDZDjOJo1a5ZC/RbRu7eIl9dtefr0KVlZWVGjRo1o0KBBdOnSJZXyqLtsTZWO1ObNm8nExIR0dXVp/vz55OXlRTExMYLypKenq6WRknePHjx4QKNGjSKO42jIkCGV9FtEZUOLb9++LShPXFycWhbx+vr6JJVKKSEhgQwMDEgikdDSpUuVdtzkdaSqw8XFRZBF/N27d8nMzIwaNmxIjo6OKtuvqztqwMDAQKlFfGlpKZ06dYpmzJhBgYGBdObMGTZ/i8FgMD5SwDpZDMY/h9LSUrx+/Rr169cXFLdp0yYcPnxYUEzFjlS5G2BxcTGioqJgZmaGWrVqYcKECbC3t+djbt68CS0tLbkdKWVcunQJIpFIZvuRI0fkOhs2btwYUqkU586dw8uXLxEaGorHjx+je/fuCA0NRePGjeXmiY2NhampqaBre/36NWrUqFFtR8re3h729vYoLCzEggULEBMTgx49eqBx48YYOHCgSrmCgoLg7e0t6PqOHTsmtyPVsmVLrF69GgBw9uxZ+Pr6IjMzE7q6upgxYways7PRrl07QbkSEhKwb98+QTEREREYPnw4NDQ04OLiAhcXF+Tn52POnDnQ19dHvXr14Onpib59+/IxijpS1XH9+nWYm5urfHybNm3w6aef4tSpU3jy5AkmT56MrKwsGBsbIyAgQKFTY1JSEvT19QVdW35+PqRSqdIuXo0aNSCRSCCRSFBYWIj9+/dDIpFg0KBBsLe3F+zOyGAwGIx/IfIqrw/1YZ0sxn+Fw4cP03fffUehoaFKu0kVyc7OJkNDQ8G5qutIZWZm0qRJk4jjOBo4cCCdP3+eHBwcBA8tPnToEPXs2ZN0dXXJ2NiYtmzZwu9TpCNT5Nq3bds26tixI+no6NCcOXMq6beI1NNIeXt7U2xsrKCY8qHFjx49orFjx/JugFeuXFEap053xNLSUlAHZt26ddSuXTtq1qwZLV68WGX9lrKhxcqoriN1//59Xr/l4OBAN27ceCdDi1VB3nMklUopNjaW9PX1SU9Pj6Kjo2WuX92hxUuXLhUUk5GRQX369KHnz5/TypUrycfHh2JiYph+i8FgMD4CwIwvGIx/DgEBAVRQUECLFi3i3QDXrVun9CXWw8ODEhISBOW5ceMGWVtbq3z8r7/+SoMHD6Z69erR2LFjFboBysPc3JwvpJ4+fUoTJkwgjuNowIAB1KVLF7kxyizi9fX16cWLFzRnzhzS1dUlExMT2r59O7169Ypf/igEdZatyRtafO7cORowYACJRCKaNGkSZWZmVtqfnJwseGjx21jEP336lEJCQng3wP379yuN8fPze+8W8SdPniRra2uqV68eTZ8+XZCzoCqGHFVZs2YNeXp6Ktyfk5NDvr6+xHEc9e3bl5KTk9/J0GJVcXFxqeTSSER0+/ZtCg8PJx8fH9q1a5fMFwkMBoPB+HfAiiwG4x9CQUEBBQUFVdqWlZVFU6ZMIY7jyMbGhs6ePSsT9641Uoo4ePAgOTs78/otXV1dCgsLU/oSqKxI8Pf3p3bt2pFIJKLx48fT06dP+X2KOlLyCqlyN8CmTZtSly5d6PLlyyr/Tunp6e/cIl4qldKmTZvI2NiYJBIJLViwgIqLi6lv376CLb1jYmIEO03K60g9ePCA3NzciOM4Gjp0KF27dk0mTp3naOTIkYIt4k+ePEkODg4UHx9PhoaGpKenR8uXL1eaW91i08DAQGV94927d2n48OHUvHlz6t69u8rdQ6Kybt27togvLS2l1NRUXr+VlpbG9FsMBoPxL4IVWQzGP4QtW7bQ+fPnFe6/evUq2dnZEcdxNHr0aHr06BFdv35dUEeqHHWWrVXsSBGVzQSKjIwksVhMXbp0oc2bN8vELF++XKFFfMVZW9u2beNNJUJDQxV2Ery8vPhZW1XhOI7Onz9PAwcOJJFIRBMmTKhUuMnDyclJLYt4VTtSBQUFNHv2bBKLxdSgQQPatWuXoFz6+vr0+vVrQTHVDS0+ffo09evXj0QiEU2dOpWys7PVHlqsTuFTdWhxXl4ezZgxg8RiMVlYWMhdRqjO0OK36UgdOXKE+vbtSyKRiHx8fKr9Gzg7O1c7tLgqQizi37x5Q9u2bSMvLy/64Ycf6O7du4JyMRgMBuPv570WWQCmAfgdwFUAGwF8BkALwBEAt//63y+rOw8rshj/BXx8fFT+pnrPnj28a5qLi4vK+i0iov3795Ozs7OgaysuLlZYmC1fvpymTp1KEydOJJFIRAMHDqSLFy8SUVkhlZeXJxPz8uVLubO2CgsLSU9Pj9q2bUvGxsa0bdu2SvsVzdqSN7R48+bNZGxsTLq6uhQZGSm346ZOkWBhYSH4JTc6OpomTJhAY8aMUVm/perQ4qqo2pGSSqWUlJRERkZG1KhRIxo3bpyg5W6KhhZXl1PZPb9//z45OzsTx3E0bNgwvhh726HFqnL//n2ysLCodL3R0dGkr69P+vr6cvVbROp9adGvXz+6ceOGoJjExEQaO3Ysr9+KjY0VrB1jMBgMxt/DeyuyALQAcA/A53/9vAWAK4BIAL5/bfMFMLe6c7Eii/Gx8+zZM5o3b57gOJFIVEm/tWHDhmpfsKt2pFRBmUV81ULq8uXLZGtrS7169aKmTZvS48ePZWKmT59O8fHxcs9XXiQ8ffqUxo8fTxzH0aBBg+inn34iS0tLuTHKhhYXFhZSeHg46erqkqmpKe3YsYOIyjpSI0eOVPp7V+VtNFIVlz9W1G9NnjyZsrKyZGJ8fX0FW8Sr25Hq3bs3BQcHq6zfIlJPIyXEIv7EiRNkZWVFvXr1oubNmwsustRZ/qjMIr6ifsvS0pLX5L0rQw5VqGrIcevWLabfYjAYjH8o77vIevBX50oTwF4AFgBuAmj21zHNANys7lysyGJ87CxfvpwyMjIExezfv59cXFz4nzMzM2ny5Mm8fuvcuXMyMcXFxWq93CnqSFWctVUVT09PmjBhAq/fioiI4F8CFb0Ay+tIERFdvHiRmjdvTh07dpS7DFDV36lcv8VxHDVq1Ij27t2rUlw5q1atIj8/P0Exr169UtiRkkqltGHDBjIyMiKJREILFy7ku0nqFAnDhw+n5ORkQTHHjh0jJycn/ueMjAxydXUljuPI3t5ebrflbTRSQoslf39/cnJyIgMDA9LX16cVK1ZUe1/eh0aqIunp6eTk5EQcx1HTpk3pyJEjgvIkJCSQh4eHoBhlyx9LS0vp5MmTFBAQQIGBgXT27Fmm32IwGIwPzPteLvgjgFwAmQDW/7XtZZVjshXEugO4AOBCq1at3v+dYDA+IELNDYjKOlKKCrMrV67w+q0xY8bQo0ePiEj9ocWNGzfmbdwrMn36dFqzZo3cuIpFQmFhIc2dO5ckEgmJxWLq1q2b3Jj/G3IUElFlB8PyJVlbt27l9Vtz585Va/mjVColHR0dXr81ceJEGTdAebxPi/iCggIKDQ0lsVhMEomEunfvLigPkXrLH5VZxKempvL6rWnTpvFdlLi4OPL29haU510sf8zJySF/f39ev6XIdENdi3hVNVLlSKVS+u6778jS0pI4jiM/Pz+Vng91LOKDg4NVsogvKCigbdu2kbe3N4WFhckMqWYwGAzG38P77GR9CSAFQCMANQHsBDBC1SKr4od1shgfMzdu3KDVq1cLihHSkdq1axeZmpqSWCymFi1aCJ7BU24RX27jznEcjR07lh4/fqyw26LMIn7w4ME0cOBAfhngpUuX+H16er2JKIOILhLRBSIqIqKyWVtVC6nCwkKKiIggbW1tunfvnqDfaeXKlZUs4jdv3swXbvPnz5erTVLWkVKGOh0pW1tbsrS0JJFIREOGDFHpRTk5OblSR0oVVO1ISaVSSkhIIAMDA5JIJPT1118Lfo78/f1pxYoVgmKqaqSq7hs5ciRxHEeOjo6VCkV1NFLW1taCNVIJCQm8RbxUKqVVq1bx+q24uDi5f/e/0yJ++PDhNGXKFL7QZ/otBoPB+Pt4n0XWUACrK/zsDGAFWy7IYFQmLCxM8BKqqKgowR2pzMxMat26NUkkEjI2NqZNmzap9PIvr0jYuXMniUQiatCgAYWHh8toQZRZxFd8Ab58+TINGjSI9PR6k6urKfn4mFNZcVX+KdMqCR1aXB2KOlLlboDl+q2dO3fy+7y8vAQPLb59+7ZCHZkyKt6jtLQ0srGxIZFIRFOmTJGr3yIitSziY2NjBXeknj59Si1atCCxWEzm5uYqu+qpM49M1Y5UuX6r3DDDzs5OUJ53bRH/6tUr8vb2Jo7jyMrKqpJeUN2hxW+7/PHmzZsUFhZG3t7etHv3bioqKhJ8PgaDwWCozvsssri/nAW/AFADQCKAyQDmVTG+iKzuXKzIYnysSKVS8vX1FRynSCOljGnTpvFDizMzM2nSpEn8UGBF1vHKLOKHDRtGKSkpFBkZyRdu5Tbuil5Yy2dt/Z9CKu9cOTi0Ize3LuTq2pni4ydRUdEZIrqv9AVY2dBiRag6tPjRo0c0duxY4jiOBg8eTJ06dXonQ4urQ9HQ4nI3QENDQ5JIJLR48WK+s/F3aqQqDi3OyMggFxcXEolE5ODgoLATdO/ePbUMOYR2pKRSKXXq1Il69+5N+vr6tGrVKpX+ZupaxEskkmqPu3XrFjk6OhLHcTRy5Ejq2rWrWkOLhVrEnzp1iuzt7WW2S6VS+vnnnykgIICCgoLo3LlzTL/FYDAY74H3rckKBXDjLwv3JACfAmgIIPkvC/dkAFrVnYcVWYyPlZSUFNqzZ4+gmOzsbDI0NBScS9GytStXrtDgwYNJJBLxywDLcXBwoNTUVIXnq8jTp09p4sSJ9O2331KLFi14G/eK/L8j9f/iiugCSaXnyNlZh4guUFHRGUpImEyurp3Jza03jRo1igICAuReQ8VZW6qibNaWIrZv306NGjUikUhEkyZNUkm/RaSeRqpv377VWsQXFBRQSEgI7wY4YcIEwcX6u7aIP3nyJFlbW5NIJCIPD49KS9PUGVp84sSJt3Lty8nJIT8/P+I4jvr27avUEOTvsohft24dNWzYkDiOI39/f5WfXXWeo379+tH169eVHlNQUEBbt24lHx8fmjdvnmDXUQaDwWAohg0jZjA+IOWdEhsbG0pLS1MpZtq0aZSYmCgoz7Vr16hfv37VHrdz505evzV79myFnYQDBw4oNJuwsLCg/fv3k62tLXEcR+PGjaPHjx9TcXGxHM1V2WfLFh9asWI0VV4qeIGysg5TixaNqXfv3jRo0CC6fPkyn0eZs6Ey1NFIDRs2jE6cOEFSqZQ2bdrEz99asGCBwq7E0aNHacSIEYLySKVSwd2bBw8eUOPGjalXr140dOhQ+v3331WK8/X1pejoaEG5VLGIr6rfWrZsmVoaKXUs4levXi23I3X37l0aMWIEcRxHTk5OlfRbOTk5amuk1LWIl0qltGLFCtLX1ycDAwOF+i0iYUOLy1Gns/ns2TPS0dEhb29viouLk7sMksFgMBiqw4osBuMDkZ+fT8HBwUREdPXqVd4NcNSoUfTw4UOFcYoG8ipj6NChCjtS8igsLCRXV1dq1KgRGRkZ8csAy1GkkSouLiaxWFxp27Zt28jc3IgkkpY0enT3v5YBVi6mRo3qSvn5qTLbX78+RlZWZS+Lly5dokGDBhHHcTRhwgQaP368wllbilBkEV8d8l5YK+q3zMzMaNeuXZX2qzO0eNWqVYI7Uq9fv+Y7UqdPn+bdAKdOnarUnOLvsIjPy8sjR0dH0tbWJnNzc5Ud/97n8sdjx47xboDe3t7k4eHxTg05lCHvd3r16hV5eXnx87eqzntTd2jxtGnTBMVUXP5448YNCgsLIx8fH9q7dy/TbzEYDIYasCKLwfhAbN68mS5cuCCzfc+ePWRmZkZisZhCQ0OpoKCA33ft2jWFGillqNNJKLeIL18GyHEcDRw4kM6dO6fwBVjWIv7/ywLd3LpQXNwEcnXtTO7uvejIkTlUXkiNHt2NqhZYRBdo4cLhtHlzpEyerVu3UoMGDXgbd1WHsJZ3pIRw5MiRaocWP3r0iMaMGUMcx5GdnR399ttv79SQQxk+Pj4yhhxV9VtRUVGVOm7qDi1W53eysrKi27dv0/3798nZ2ZlEIhENGzZMaZdKyNDicoQuf5RKpRQTE0P169cnPT09io6OVrnoVDa0WBGqDC2uqN9ydname/fuvZOhxaoQHBxMUVFRlbZJpVI6ceIEr986f/48028xGAyGirAii8H4QPj4+Ch9YSkuLqZFixaRRCIhIyMj2rBhAw0ZMkRQR4qobGixq6uroBh5HSkiol9++YV0dHSoWbNm5O7uXkm/RVTRkKOy5qpqIZWVdZjCw+3I2bkT9e/fnFatGkvyiixn504klf4qcx3lHalyG3ddXV0yMTGhHTt2KP291HlhFdqROnfuHH3//ffUrFkzmjx5skI3wKqoashRleo6Unl5eRQcHMzrt/bv3/9OhhargqKOVLkboEgkounTp8t0n/T19dUaWqxuRyonJ4d8fX15/VZKSorSOHWeI6EW8YcPH6aOHTtSkyZNKCAggHJzc1WKU9WQoyrVWcQXFBTQli1beP2W0OHpDAaD8V+DFVkMxgfg2bNnNG/ePJWPz8zMpMmTJ1O9evXIxsaGzp07p3Ksubk5PXjwQND1LV26lIKCguTuKy+kduzYweu3wsPD6enTp2Rqqk/yNFcLFw6n3buDSV4h5eDQjjw8jMjZuROFh9tRVtZhIrpA9+5toylT9KjivKxy5FnEP378mMaNG0fNmzcnW1tb+vXXysWZvFlb1aHusjU9PT16/fo1bdiwgYyNjUkikSjVbxGpPrS4Iunp6YIs4jMyMsjV1ZXq169P9vb2gl76lQ0tVkR1FvFSqZTi4uLIwMCA9PX1acWKFfTq1Su1NFLqLH+UZxGfnp5Ow4cPJ47jaPjw4TIFtiodqaqo+xwZGhpSVlYWrVixgvT09MjAwIDi4+OV/p5BQUEyHanqyMjIoD59+qh8/LNnz2jZsmVkYmJCq1evFlwQMxgMxn8BVmQxGB+ApUuXCv4meN++feTq6kpXrlyhIUOGkFgspjFjxtCjR48UxijqSFWHRCKRaxEvz9mwsLCQ5s0Lox49tGnQoFb8MsDKHSkdkkrPyWyvXEhdoCNH5pC7e09yde1MQ4d+Q+fOraKK87LKUfTCWl5IXbx4kQYOHEi9e/emiRMn0rNnzxTqyJShrkV81WVrBQUFNGvWLF6/Jc9RUp0i4W0s4lNTU3n91rRp05QuL/s7LOJzcnLI39+fmjZtSt9++y0dOXJE5Tzva/ljcnIyr9/y9fWlnJwctQw5Kg4tVhV5Q4tfvnxJ06dP5+dvyZtFp87QYldXV9q/f7+gmNTUVBo6dChdv36dwsLCyNfXl/bt2yc4N4PBYHyssCKLwfgACB0AS0TUp08fmY7Url27eP3WrFmzKum3iMqGFpeba6jKixcvFC438vDw4GdtlfH/ZYHOzjr0/PkhCg8fQs7OOuThYUzXr6+ju3crF1IVP35+FnTpUpzM9qKiM2Rp2YjXb+3fv5LPePjwYaXOhlULqc2bN5OhoSHVr1+fIiMjVdZvEb0fi/iHDx/S6NGjef3W1atX36khR3VUtYiXSqWUmJjI67eWLl0q86KsztDit7GIv3v3Lo0cOZIfLnz79m2lMe/bIl4qlVJ0dDRJJBKqX78+xcTECCqIDQ0NBbv1VTe0+ObNmzRs2DBev3X//n26f/++WkOL1dFsWltb07Vr1/ifpVIpHT9+nAICAig4OJguXLjA9FsMBuM/jaIiSxMMBuO9cOPGDXz33XeCYkpKSpCTk4OWLVtW2j5gwAAMGDAAJSUliIqKgpmZGWrWrIkJEyZg6NCh2LRpE44cOSIoV3BwMF6/fg2JRIL+/fvD09MTtWrVAgCkpqZi3rx5AIoAPAHwHADh3r37aNCgARo2bAg/P18AwM2bNxEbG4vLly9DR6czXrx4AS0trUq5Hj36E927d5O5hgsXLkAkEiE0NBTPnz/HihWrERKyBi1atMCjR4+wZcsWmZjS0lK8evUKrVu3rrTd3t4eWVlZEIvFKCoqgpGREb744gtMmTIFAwcOVHgfXr16BQ0NDdSpU0fI7cPPP/+MOXPmKNzfokULxMXFAQDOnj0LPz8/nDlzBnp6enLvkSJSUlLQrl07QddWWlqKly9fok2bNvw2DQ0NODs7w9nZGfn5+ZgzZw4MDAxQt25deHp6om/fvkhMTMS+ffsE5QoPD8eIESMExdy7dw8NGjRAmzZtsHbtWgBl93PKlCl48eIFjIyMEBAQgHr16lWKu3XrFszMzATlmjNnDpYsWaLSsRoaGnB3d0fNmjVx6dIlpKenQ1dXF1paWvDx8YGxsbHC2Pz8fEilUtSvX1/Q9R05cgQnT55UuP/bb7/Fxo0bAQCHDx+Gu7s7Ll++DGNjY+Tn5+OLL75QKc+pU6dk/pupjtLSUjx//hwdO3bkt2loaMDIyAhGRkYoKCjAnj17sHXrVmhra8Pe3h6tWrUSlIPBYDA+WuRVXh/qwzpZjI+J2bNnC9YwLF68mEJCQlQ6NjMzkyZNmkQ9e/akhg0b0vnz5wXlKl+2VlhYSJGRkSSRSMjY2JgWLVpEAwZYkjzNla+vOV2+LNuRKjevOHp0Lrm79yJX184UHz+JiorO0OnTSykoyEZuzMSJHP35554q24vo/Pnz9OWXX5JIJOKXAZazfPlymjFjhtzfqWpH6tGjR/yMssGDB8vot4iIpk+fTqtXrxZ0727duiVII1WOSCSidevWkZGREUkkElq0aFG1y64sLS0FW8RHR0erbBGfkZFBLi4u1LNnT2rUqJFgG3F1Rg2MGDFCYUeqon5LT0+PVq1axbvfOTo6CsrzrpY/lrsBikQiGjlypNy/hzpDi9+mI7V8+XJ+/lZCQkK1f4P3bRFfrt/y9PSkiIgIpt9iMBj/GcCWCzIYfx9SqZR8fHwEx0kkEpmlgNUxdepUmjlzJj9/a+zYsTJugFVRNLT42bOHpKf3FQ0d2pY8PIzo2rV1VFVzJa9YSk1dQkFB/ajiMsCEhMnk6tqZTEzq0ZYtPjIxxcVp5OzcSc75sioVUps3b+aHAkdGRpKurq5CHZky175z587RgAEDSCQS0aRJkygzM5OI3m5osRCOHj1aySK+oKCAQkNDSSwWk5mZGe3bt08mRiqVqqW1U8ci3tfXlzw8PMja2po4jiMPD49q7cHft0V8Tk4O+fn5Ecdx1LBhwypLWKvnfVjEHz16lPr27Uscx5G/vz9/n99maLEQqg4tzs7OJg8PD+I4jqytreW6kr6NIYc6FvHe3t40e/Zspt9iMBj/CViRxWD8jRw7dkzuS7MysrKyyMjISHCuqkXCrl27yNTUlHr37k0+Pj5yi7ahQ4fS6dOnK2yprLkiukA3bqwnT09jcnbWobCwwbR//2yBHamyQsrJ6bu/bNzL9Fs3bqwnogu0aZMXrVgxRs757lewiK9whYWFFBgYSPXr1ydTU1MZG/fp06erNLRYKpXSpk2byNjYmHr06EHffvut4JdAdbQtVTVSFXnw4AG5ubmRSCSiIUOG0O+//05EZUOL/fz8BOV5G41U+XMklUopISGhkn5LXgHxd1rEd+3alUaOHElisZicnJxUckAUYshRjqoW8VKplHcDFIlE9N133wkust61Rfz169fJwcGBOI4jFxcX3nRH3aHF6rg/VjTkqKrfunjxItNvMRiMjw5WZDEYfyNOTk507949QTFTp06lpKQkQTGKOlJEZYXUpEmT+GWAmzdv5vf9/+Wu8pyrso6UbCGVkjKPjI3rkpNTB34ZYOWOlPwOV9VC6tq1deThUVa49enzpdzC7NWrUwo7Up6enpSQkMDbuFdcBqhOR8re3p5Gjx5NYrGYTE1NadeuXdXGHD58uNqhxVUR0pE6ffo07wbYtGlT+uOPPwTl8vX1VcsiXlFHKi8vjwIDA0ksFpOFhUWlzos6xaalpWW1BhdVqWrIcezYMd4N0NvbW24h9S6KTVUZPnw4DRkyhDiOI0tLS5W6nO/bIn7//v1kbm5OYrGYWrRoodSdVB7yhhZXhzKL+Pz8fNq0aRN5e3vTvHnzBD/XDAaD8U+FFVkMxt9Efn4+OTo68m6AoaGhKi0BVEfbItuR+j8VX8YyMzPphx9+II7jiOM4GjTImuRpriZMENGff+4leR0pFxedSssA3d170ZEjc2jjxum0cqW8jtQFGjWqK+Xnp8psf/36GA0e3JrXbyUkTOYLt4ULR1BCgvwiQd4L8Pnz58nY2FitAb8Vi4RHjx7RmDFjeDfAK1euyI1RxyJ+5cqVgi3iX758Se3ateO7SYsXL1ap46auRbwqHan79++Ts7MzcRxHxsbG1L9/f0F51F22pmhosVQqpdjYWDIwMCADAwOKjo7mf3d/f39auXKlTIwyyocWC6Xi71Su3+I4jkaOHKnwWRE6tJiozCLew8NDUMzr16+pdevWJJFIyMDAgBITE1V6PjiOe28W8U+ePKGoqCjy9vam6OhoevHihaA8DAaD8U9CUZHF3AUZjHfM7t27MX36dPTo0QMlJSVYtmwZ7wbo7u6OYcOGQUNDo1LM77//jsaNG8tsr44//vgDurq6MtsPHDhQyRFMW1sby5YtA1AEW1tdfPXVK7i49EP79u0wfvx4aGtro6SkBHl5+WjWrKnM+bZt2wZdXV3UrFkTLi4ucHFxwYsXLxAdHYODBw+iW7duuH79Bjp2/L+bYk5ODjQ0NPD555/JnC8uLg6urm7o398GxcXFWLduPdzd3VGr1qd4+vQJduxYJBNz8+ZNNGzYUOYe9erVC02bNsUPP/wg5Nbh0KFDldwfmzdvjtjYWADA+fPn4e/vj6dPn4LjOISEhEBLS0uhs2F1rF+/HgcOHBAUEx4eDl9fX4wePRr5+fmIjIyEvr4+6tatCw8PD1hZWcnE3LlzB19++aXg5yg9PR2mpqbVHte6dWskJiYCAMRiMWrUqAGxWAwDAwMEBgbKuAFWJT4+HkZGRoKuLTc3F0Qk99waGhoYM2YMxowZg9zcXISFhUFPTw/169fH/fv3ce3aNUG5goKCMH36dEExqamplVwc27dvjw0bNgAocw50d3fHq1evYGZmBj8/P9SpUwelpaXIyspChw4dBOVavXo1du/eLShm3rx5mD59OiZNmoSXL19i5syZWL58ObS1tTFjxgy5/3788ccfqFu3LjQ1hb0iXL9+Xe5zWZUmTZpg8uTJAAAzMzOkp6fjk08+gaGhIczNzQXnZTAYjH8k8iqvD/VhnSzGx4C3t7dc3UFmZiZNnjyZOI4jGxsbOnfuHL9vyJAhlJaWJijPTz/9RE2bNqVNmzbJfDMtO2urbFlgcfFZcnH5/9K+lJR5NG5cL3Jx0aEpU/Ro+fJRJLQjNXp0N7pxYz2/DDA83I6ysg7TwoXDaffuELnnUzS0+PLlOLK0bEQDB3YjW1vbSm6Aw4YNkzuUlUg9bYu5uXm1HSmpVEobNmwgY2NjkkgkZGtrK1gj9erVK7W6bIo6UhkZGeTq6kocx9HQoUMrzTB6m6HFQqjYkZJKpRQfH0+Ghoakp6dHy5cvV9gpUUcj5efnR6tWrRIUc/z4cWrSpAlxHEdOTk4quzOq8xypMrS4XL9V7gbo4uKilkZK0Vw7ZSjqSF27do2GDh1KIpGIXF1dK/174eLiQgcPHhSUJzU1lezt7QXFSKVSvpsslUrp2LFj5OfnR0FBQXTp0iWm32IwGP8KwDpZDMb75+nTp2jUqBFq1Kghs09bWxtRUVEAgKtXryIkJAQPHz5E586dcffuXXAcJyjX8uXLcejQIcTGxmLhwoVo2rQpAgMD0a1btwqztirPudq2bWulb65NTExgYmKC4uJi2Nra4tWrV/j1118xZMgQmJubA1DekYqNjcWgQYPQoUMHLFgwHwCQnJwMPz9/3LhxHa6uriguLkbNmjX5mPIZSfK6LZs3b0Z4eAS6d+dw6VIRgoOD8fjxY/To0QO3bt2Cvr6+TMyhQ4cEdwRKS0vx+vXrajtSGhoacHR0hKOjI968eYNvv/0Wf/75J/r06YOpU6fCxsam2lyzZ8+Gi4uLoOu7ffs2tLS05N6jVq1aYc2aNQDKZh95eXkhMzMTenp6uHnzptJZTvKIjIzEypUrBcWsXr2az6OhoQE3Nze4ubkhPz8fERERkEgkqF+/Pry8vNCnTx8AyjtSykhJScHp06cFX9/69ethZmaGlJQUTJgwAS9fvoSJiQkCAgLkzkT7+eef8c033wjKU1paihcvXqB9+/ZKj9PQ0MCECRMwYcIEvH79Gt9//z2aN28Oa2tr+Pv7y32uqxIREQFHR0dB15eRkYF69erJ7Qx17NiRn0O3f/9+jBo1Cq9fv4alpSWuXbuGvn37CsoVERGB+fPnC4rZsGEDJBIJgLJ7ZGxszM//2r17NzZv3oxGjRrBwcFBZnYgg8Fg/OORV3l9qA/rZDH+7URFRQkWdAcEBFDTpk1JLBbTrFmzVNJvFRcXyxgp/PrrrzR48GBq1aoV9ezZmZ48OUdVNVejRnWlggLZjtTLl8k0Zkx3IrpAWVmHKSJiCDk7dyIPDyPy87OgPXuEdaTu3t1GkydLKum3jh6dS6rM2qo4L6scX19fatKkCW/jXlhYyO9TpSNVFWWzthRR0SL+wYMHNHr0aF6/dfXqVYVx6mikHB0dBVnES6VS8vLyosaNG5NEIqGoqCiV9DTqaqT09PTo9evXSo+5f/8+jRw5kjiOo2HDhtHo0aMpOjpaUJ53aREvlUopOjqa9PX1SV9fv5J+i0i1jlRV4uPjafr06YJiKrr23bp1i4YNG0Ycx5Gzs7PS51gdjZSzs7OgjlRxcTFNmjSJtLW1ydDQkNauXavSs/s2FvHV6bGePHlCS5YsIW9vb1qzZk21zx2DwWD83YB1shiM98/Dhw/x1VdfCYpJS0vD+fPn0bRpU0RFRfH6rXHjxsHBwUFuN2P58uWwtLSstK1Lly7Yvn0jBg+WYPz4IQgOnog3b97AyMgII0aMQEFBAT755BN89pl8jdSgQYMAAFpaWvD19QVQpoOaOHEiHj58iN9++w3u7u7Q1tYGoLwjFRMTjVGjRqFbt24V9FvRWLt2LR48eABXV1eZmFOnTuHrr7+usCUHgBYA4OLFizh37hyaNm2KBQsWwNjYGJ999hl++OEHlTpSVdmwYQMOHz4sKCYsLAxubm4AgJYtWyIuLg4AcPbs2Ur6reDgYGhplV23so6UMu7evQtDQ0OVj9fQ0MBvv/2GtLQ0NGnSBHPmzIGBgQHq1KkDT09PmWelnNjYWJiYmAi6tpycHNSoUQN169ZVelzr1q2xdu1aAGVdokGDBuG3335Deno6ZsyYoVJHKzAwEN7e3oKuT1FHSkNDA+7u7nB3d0dOTg7CwsIgkUjw5ZdfwtvbW6WOVFXWrFmDvXv3CoqJiIiAk5MTgDL91saNGwEAhw8f5vVb5ubm8PPzwxdffAFAeUdKGTdu3BDUkdLU1MTdu3eRmpqKRo0aYdasWbx+KyAgQK5+CwDWrVvHd6RUJT8/H1KpFF9++aXS45o0aYIpU6YAAK5duwY9PT1YW1vD2NgYffr0YfotBoPxz0Ve5fWhPqyTxfg3c+3aNVqzZo2gGHkdKaIy/ZaBgQG1a9eOBgwYUEm/RSRvaHGZ5urlyxS+I1U+FDgxcQq5unamvn21KSJiCAnrSG2lKVP0iegCHT06l3cDjI+fRF5epvTLL6sVnk/R0OLJkyXk4WH0l35rCGVlHab/z9qq6Gx4n79H8r4l//PPP0ksFlPz5s15G3dVqG5osSKq60iV67eMjIxIIpHQokWLyN7enn7++WdBeaoOLVYFRZ2EjIwMcnFxIY7jyMHBQcbNTk9PT/DQYh8fH7U7UlKplOLi4sjAwID09PRo1apVSu+pOt0RS0tLlWZolZOenk69e/empk2b0vDhw1XWb+Xm5qplEV/d0GKpVErLly/n9VsJCQk0cuRIOnTokKA879Iivly/xXEcubm5VdF7qj+0WKhF/IMHD6hPnz4klUopOTmZ/Pz8KDg4mC5fvsz0WwwG44MB1sliMN4v27dvx48//igoZtmyZXLduLS1tSGVSnHlyhWkp6fz+q0uXbpg2rRpqFmz5l8dqcqaq9jYGNja2vLnqVmzJpydneHs7IwRI0YAAFxcXKGt3RBjxoxFx47fVdORisGoUWXdGzMzM5iZmaG4uBgbNmzA2bNn8erVK9jb28PMzIyPke1I/Z8NGzZgxoxA3sHwyJGj8PPzQ2FhITIzM6Gt3bDC0TkAgFWrVsHCwkLmXM2aNcMnn3yC27dv49q1awgKCsLjx4/Rq1cvhIaG8h23qsyePRujR4+Wu08RqnSkquq3IiMjcejQIbx48QLTpk2DtbW1SrnmzZsnWCMVGxsr1x2wVatWSEhIAFD2d/H09MTz58+hp6eHqVOnokaNGnL1Sco4fvw4wsPDBcWUd6Q0NDQwevRojB49Grm5uQgPD4dEIkGDBg3g7e1d6Xc4fvw42rZtKyhPaWkpsrOzBcW1bdsWn332GW7evIkLFy7w+i1TU1P4+/srvD8VO1KqkpGRgbp161b7HE2cOBETJ07Ey5cvMXv2bOzatQtZWVmoXbs29PT0VMoVERGBhQsXCrq+pKQkueevqt9yc3NDbm4uLC0tMXnyZEilUjRo0EBQrkOHDuHkyZOCYoKCguDh4QENDQ2YmprC1NQU+fn52LVrFzZu3IgmTZrAwcEBLVq0EHReBoPBeC/Iq7w+1Id1shj/VqRSKfn6+gqOk+1IlZGVlUWGhoYy23ft2kXNmzenDh3aUFTUdCoqSqOqmqbqOlJEF+jmzQ3k6VnmBtivX1P6+edFMjHVdaSCg20oK+swhYfbkbOzDnl4GNONG+urnbUl73zr13vQ2LE9yMVFh9zde1FKyjwq12Xp6elRXl6ezL3Izs6We482b95MxsbGpKurS/Pnz5fRsaijkVLmbKiIw4cPk7OzMz148IBGjRpFHMfRkCFDlOq3hAwtroi+vr7KHSmpVEoJCQnUvHlzatOmDS1btkzl+5Genk6WlpaCr6+6ocV3797l9VtOTk58HiEdKSLZocWqkJOTw2ukypFKpbRq1SpevxUXFydzj9R5jpydnSsNc1aFkydP8l3Icv2Wi4sLZWRkKIyp6NonBCEdqeLiYlq8eDH/HK1bt07l+6FsaLEyqutsPn78mNdvJSYmCu7SMhgMhjqADSNmMN4fKSkpdODAAUExT58+VfgiNGXKFFq3bp2cPYU0YEA3KipKo7Vrp5KbWxdyd+9Jhw9HUHr65kqFVMWPt3cf+vXXeLn7Bg36isaN+/8ywPKhwOWFlLyYCRNE9Phx5ULq+vV1NG2aIRka1uFt3Cvu37TJi1atGiv3fG5uXXiL+MzMgxQWNpicnTuRo2Nf6tGjh9x75OHhQQkJCQrvb0FBAc2ePZvEYjGZmprSzp076caNG2Rtba0wRhHqLFuTN7Q4LS2NbGxsSCQS0Y8//khZWVmV9q9YsULw0OJXr16ptWyN4zjKycmhwMBAEovFZGFhUW0B4OTkRCkpKYLyJCcnk5OTk8rHHzt2jPr27Uv16tUjb29vQZbv6ljE+/v7K7WIf/XqFXl7exPHcWRpaUnHjx+ne/fuvfXQYlWxsrKSWeZ58OBBsrCwILFYTIGBgTJfQrytIYcQxGIxPXv2jKZMmcKPp6huHIWqQ4srcvr0aRo6dKjKx1+9epVCQ0OpX79+dOjQISopKRGUj8FgMFSFFVkMxnvE399fsPPXpEmTiOM4EovFNGbMGHr06BG/T/Zb8jLNVXr6Fvrxx8qF1IsXR2nuXHsyMalHbm5d6Pff11LVIkZRR+rkycV8IVWu3yor3HrRkCFtZAqp6jpSGzdOp1WrxtKRI3N4/VZCwmQqKjqjdNZWRR1Zxc+UKQOpa9eu1Lt3b5o4cSJlZmYquUeKefToEY0ZM4a0tLRIX1+frly5ouqfiQ4ePEguLi4qH09UvduaVCqldevW8fqtxYsXU3FxsaCOVDleXl4UGxsrKOb27dsyHan79+9X0m/dvHlTJk6d7kjfvn0Fd6RiYmLIx8eHYmNjycDAQK4bYFVycnLULjZVfY5u3bpFjo6OpK2tTcbGxirrt4jU10gpu+fFxcW0dOlSkkgkvH5LKpWqVWwGBgbS0qVLBcVkZGSQubl5pW1Xr16lIUOGkEgkotGjR1f6d60cdYrNfv36VZoJpwpJSUk0ZcoUOnr0KPn5+VFISAj98ssvgnMzGAyGMliRxWC8J/Lz86ljx46ClssQVX6527VrF5mZmZFYLKZJkyZV6LaUFVflVuze3mb0228JpMj+/NatjTR9ugk5O+vQrFmDKDPzIJ08uZhCQvrLjZkwQURPnuyT2f7s2UEyM2vALwO8fn0dVS2k5J2vaiFVVHSG4uMn0YgRHcnYuG6FZYD//yxY4KRwaLGjY2f+HlVcBujt7U1WVlaC/k7l9/zcuXNkY2NDvXv3pkmTJlUq3OQhryNVHStWrFDZIj4/P5+Cg4OpZ8+e9OWXX9K+ffsE5VJn2Vp1Q4tPnjxJ1tbWxHEcTZ8+nV69ekVHjx59q6HFQqhabObk5JCvry9xHEd9+/al5ORkmRh1hha/jUX84cOHycLCgkQiEfn7+1dbHL9vi/js7Gzy8PCgnj17kpaWFqWmpgrKJRaLBX9RVN3Q4j179vD/roWGhlJBQcFbDy0WgqGhYaVucW5uLq1fv558fHxo4cKFcgtABoPBEIqiIosZXzAYb8muXbuwfPly7Ny5E0uXLkWjRo0QGBgIkUikMObq1ato1KgRL4AfMGAABgwYgJKSEnTv3h21agH29mKMGjUAFhbm/HFPnjxF5846Muc7eTIV33zzDdq3b4958+YBKDMOCAwMxPXr1zFo0CCZocAlJSXIy8tHkyZNZM6XnHwUQ4cOxbhx43Dz5k3ExMTi+fPn+O67Drh27RpiYmJlYl69eiUztLhmzZpwc3NFdvYLWFv3w5kzZ5CQkIhGjbQxbtw4tG/fHr/++humTp0qc7579+6hUaP60NCQAtCAvb097O3t8ebNG3AcJ3jw6aFDh9CxY0f07t0be/bsQWlpKTZv3oyhQ4eiqKgIdnZ2mDJlSiVL6NLSUrx69UqwRfz69etVtoj//PPPERISgvz8fNjb22Pbtm2YOXMmWrVqhdDQUHTs2FFhrLoW8Xfu3FE6tFhfXx/79u1DaWkp1q5di/79++PKlSuYMmUKSktLVc4XFxcn2CI+NzcXACoZTtSpUwcREREAyp6LwMBA+Pv7o23btpg1axa++eYbtYYWBwcHw8vLS1BMuUW8ubk5zM3NUVpaiujoaFhaWqJGjRoYNWoUXFxcKt2j0tJSZGVlCbaIj4+Px759+1Q6tkGDBliwYAECAwNRWlqKpUuXwtPTEx07dsTMmTOVjpZ4XxbxNjY2sLGxQUlJCZYtWwYzMzPcvHkT3t7egp6j9evXC7aILygoQElJCT9OAQBq164NJycnODk54fHjx9iyZQseP36MTp06wdbWVrAJDIPBYChFXuX1oT6sk8X4N+Lj41PJPvjq1atkZ2dH3bp1I3t7e7nfltrZ2cnYspdRSP37dyWii/wyQGfnTjRtmiElJU2l0NABJK/jM358b7kdqeLiNHJ27lRhGWCZfovoAm3Y4EnR0e5yz1dRI1Xxs3t3CBkZ1ZHRbxFdoPnzHVUeWnzt2jry8DCmYcPak5VVY3rx4qhMzP+HFlfWLRGpr5FSZBZQUFBAs2bN4vVbu3btIqK3H1oshKodqdOnT1O/fv1IJBLR1KlT5RoSDBs2TNDQYqIyi/gRI0YIipFKpdSzZ0+aMWOGyvotImGGHOX4+vqqbBGfkpJClpaW1L17d2rVqpXgXOpqpBR1pF6+fEnTp08njuPIysqKN0uJi4sTrJGSZ8ihClUt4vfv30/m5ubEcRwFBwfLNZFxcXERbMiRmppKDg4OgmLKn6OK+i35/w5WRpWhxVUJDg6mxYsXq3TslStXaObMmeTp6UkbNmxg+i0GgyEIsOWCDMa758mTJzR//ny5+4YMGULz58+XWS5DJO/lrmxZ4IkTi+Qu7bt1axOZmTUgJ6fvaNasQfTs2UGqWEgp0khVLaSysg5TRMQQcnbWIROTenLNMF6+TKaxY3vIPd/8+Y60b99MKio6QwkJk8nVtTO5u/eio0fnquxsWPHj7d2HYmLG8fqtxMQpfOH2fx1Z5aV6+/fvF6yRUjRrSx6PHj2i0aNHE8dxpKWlpdJLYEWmT59O8fHxgmJu3bqlcPmjVCqlxMREMjQ0JIlEQlFRUfyyLnU1UkK0REREq1atquSeef/+fXJ2diaO42jYsGFyi463MeQQuvxx+PDhNHXqVN4NsDr9FhHR8ePHydHRUVAeIcsfb926xbsBamtr02+//SYol7+/P61YsUJQzP379xUachQXF1NUVBRJJBIyNDSktWvX8vdInWLT2tpaxpCjOhITE2natGn8z1euXCE7OzviOE6hfisvL48kEong6+M4TvDyRzc3NwoLCyN/f38KDQ1VefYeg8H4b8OKLAbjPRAVFSUzmLOcii8uxcXFtGDBAtLV1aVOnTqRgYHBXy84lTVXyjpS5YXUsWPzady4XuTiokNxcRMoIWEyxcSMk4kp70i9eXNKZvvLl8nk5NSB12+FhQ2mzMyywq28kFKlI1VeuHl7m5GxcV3exr1qIaXI2dDZuRP//8v0Wz+Qq2tnGjasPbm79/xrX2WTCnNzc6X21fJYunQpBQYGCorJzs6mrl27Uv/+/UkkEtGUKVNk3ADl8T4t4vPy8ig4OJjEYjF1796dTExMBOV5Vxqpipw4cYKsrKxIJBKRl5cXb7jg7e0t2JDjbTRS5VTUb1laWirUnllaWtLt27cF5YmLiyMvLy9BMTk5OdSxY0eysLAgjuMoICCAcnNzq417nxbxWVlZNHXqVOI4jnR1dQXbqav7HCmziN+9ezeZmZmRrq4uzZo1i/9CKigoSPDQ4oyMDDIzMxN8fRW/tMjNzaV169aRj48PLVq0iOm3GAyGQhQVWUyTxWC8BY8ePULLli1ltu/evRs6Ov/XTmlqasLDwwMeHh4wNjbGt99+jUGDeuCbb+ph7Ngx6NSpE0pKSlBQUCBXI7VlyxZ+SKixsTGMjY1RXFyMTZs2IS4uDu3bt8fXX38Nc3NzPubVq1fQ1NTEp59+KnO+mJhYjBgxgh+EfOzYMcyYMQNv3rzB06dPMXnyZJkYRUOLyzQPNbBkyRLUqlWrgn7rO4wb544nT56gS5cuMuc7deoU2rRpw/9cpt9yg5ubG9zd3dGoUSO4uLiiceNGGDlyHrp06YmSkhLk5OSgVatWMudTxqZNm1TWSJUze/ZsTJs2DS4uLigtLcWmTZswePBgFBcXY+jQoZg0aZKMhkVdjdS9e/egr69f7XFffPEFQkJCEBISAhMTE2hpaUEsFqN169aYOXMmOnTooDQ+Jiam0uBoVXj9+jUAKNSrGBoawtDQEKWlpVizZg1sbGxQWlqKhw8fIj09XVCuwMBA+Pr6CoqpOrS4on7rzp07CAoKgq+vL9q1a4dZs2ahTZs2/NDidu3aCcqVmJiIvXv3CoqJiIjA5MmTMWHCBJSWlmLVqlXo27cvNDQ0MGrUKDg7O8s8LxkZGahfv77g5+jmzZuV/g1QhJaWFhYtWgQAMDIygqamJjiOw/fff49Zs2bJ/TetIoqGFisjPz8fJSUlCocW9+/fH/3790dJSQmioqJgZmaGmjVr4uHDh7h+/bqgXMHBwfD09BQUc+bMmUr/rtSuXRvDhw8HAF6/9eTJE16/Vbt2bUHnZzAY/0HkVV4f6sM6WYx/E7/++iu1b9++0jLAckxNTeV+81lcnEeDBvWg8s7V7dubyMvLlJyddWjEiI60aNEIEtqRGju2B714cZTmzBn6lxugEf3++1qaN28Y7d8/S+755HWkypYlbiRb21a8jfuRI3NItY6U7HLFo0fnkr19WzI1bcDbuFfcL2/Wlrzlj7//vpaGDy/rlEgkEsHaFkVDi6tDUSehoKCAQkNDSSwWk5mZGe3du5ff9zZDi4VQdWjxyZMnef2Wh4eHwm6Bnp6eYN2SOh2p3377jb7++mtev3X06FGV4tTpjqg6tDg5OZksLS2J4ziysLAgDw8PQXnU1UiJRCK5z1G5GyDHcWRtbV3JDVDdocXqWMRXvOf79u2jPn36EMdxFBISIndQOpGwocXlBAUFCbaI/+WXX6hFixbEcRwNGDBA5aW76lrEKxsUXs5vv/1GoaGh5OfnR/v372f6LQaDwZYLMhjvmlmzZtGLFy9o0aJFJJFIyMjIiDZs2EBFRUUKNVfr1nlQbOx4kleoDB78Nbm79yRnZx2KjR3PF1XKNFKRkbKF1K1bG8nT05gMDWvzNu4V96enb5aZtSWvkMrKOkzh4UPI2bkTeXgYkb19W7kxFWdtVf1MnMjRw4e7KD5+Eq/fSk6O/MuQQ76OTL5FfJkuq0OHDvxsqfnz56ukuahuaLE8VB1a/ODBA16/NWTIEOrSpYugPETqW8TLG1oslUopISGBDA0NSU9Pj5YuXcq/BKqrkVJUJCijokX8/fv3aeTIkcRxHDk6Oio0jUhOTv5bLOKlUim1a9eOny0VGxur0u/n5+dHK1euFJTr7t27Kg0tvnHjBq/fcnZ2pu7duwvKQ6SeRfyaNWvkfmlRXFxMixcv5vVbFcdTvM3QYqEaqYpDiyvqt8aOHUt//vmn3JhTp04JGlpMpJ5FfElJCXXv3p18fHwoNDRUsOaOwWB8PLAii8F4h0il0kpGAEREmZmZNGXKFPrqq6+oXbt2f33rWllzpagj9eLFUb6QKi5Oo7Vrp/JugBMncko6UvLNJsoLqZSUebx+Kz7+ByoqOlPNrC35hc+GDZ5kZdWYnJ11KDzcjrKyDvP7FM3akmfIkZl5kMLCBpO1dRMaNOgrunVro0yc/KHFVyp1pAoKCmj27Nmkq6tLpqamtGPHDoV/q/epkarIokWLqHnz5sRxHE2dOlUl/Za6839U6Ujl5eVRYGAg302ytbWluLg4QXlu3bolM7RYFRQVPor0W0TqGXLExMTI/HdYHRWHFr969Yq8vb15/ZYyp0Z1nqORI0eq3MUrZ86cOdSkSRMSi8UUGBgo1w2wKupqpFQZWpyVlVXJDdDZ2VlwR+r+/fsyQ4tVQdHvtGvXLjI1NSWxWExhYWH05s0bfl+/fv3o+vXrgvIkJSXR1KlTBcUUFBTwhhy5ubmUlJTE67cUFYAMBuPjhBVZDMY7JCUlhQ4cOCB3n0QioYsXz9C4cVbk7KxDM2cOomfPDtCLF0crmDlU7Ug50P79s2W2v3hxlMzNtXgb999/X8vvu317k5KOVOVCqqIboKFhnUrLACt2pFQZWnz06Fxyd+/JF24jR34vN2bjxulKLeJ/+WU1eXgYkbNzJwoPH0JZWYfp9etjNGZMd7kxnp5TKDExUeZ+//nnn3xxM3jw4EqOYNeuXaN+/foJ++OS+hbx9+/fJ6lUSuvWreM7bosXL1b4Df7y5cspICBAUJ6XL18K7kjdv3+fGjVqRCKRiBwcHFR2hXN0dFTLIn7kyJFKj5FKpRQbG0v6+vqkp6dHK1asUKvYVMciXtHQ4tu3b5OTkxNxHEcjR46sVPC9C0MOVSnvSBUXF9PSpUtJT0+PDA0NKSEhQWGRJ2RocTnqdKSuXr1K2traJBKJaNSoUfTw4UOV4pydnZUOLZaHKhbxhYWFNH/+fH4lwaZNm97J0GJVCAkJkWsR/+jRI1q0aBF5e3tTUlKSSiYnDAbj3w0rshiMd4i/v7/cF+fMzEc0dChH5Z0rogt0/PgCGj++N1lYNCRPT2O5nSxFGqnbtzfR1KkGVL4MsNwNcNasQTR5soSuXk2UiVHWkfr558Xk52fx1zJAHfLwMKZr19YRkWrOhhU/RUVnaMoUPbKyaszbuFftSCnSkVUtpA4fjiB3955kYdGQvL3NZPRbRBfI3Lyn3JfMioXUuXPnaMCAASQSiWjSpEnUv3//SloXVTh48KBgi3hFnYSCggIKCQkhsVhMffr0oX379lXar6enJ/glbPr06bR69WpBMRU7UidPniRra2viOI48PT3p5cuXCuPUKRKEdqRycnLIwsKCmjdvThYWFpScnKxy3PuyiD9y5Aj17duXOI4jf39/Gjp0qOCO1Lu0iC/Xb4nFYurXr5/MM61KR6oqM2bMoOXLlwuKqWgRv2fPHrnjKeShrkZKiEV8ZmYmGRkZUdOmTWnAgAF0/vx5leLUtYhXZfnjr7/+yuu3jhw5wvRbDMZHCiuyGIx3RF5eHoWEhFTZWrYscM4cezpwQLYjVb60r+IywEOHwkkqPae0I+XlZSq3kDp2bH6FocA/VCpKfv5ZcUdq/Pje9OzZAf7nGzfWk4eHMTk7d6I+fb6k588PycRUN7S4oCCVMjMPUni43V/6LWO6eDGm2llbiu7R6tUTycVFh9zde1FKyjwiKpu15eoq367cwcFB5qVTKpXSpk2bqH79+qSrq6uyfotI+dBiRagytPjBgwfk5uZGHMfR0KFDKS0t7Z0MLVYFeUOLy/VbBgYGpKenR8uXL690XlU6UlV5W4v4O3fu0PDhw4njOHJyclJqaCFkaHE5QjtSUqmUVq5cSfXr1ycDAwOKi4tT+d5bWloK1kipYhF/7do1cnBwII7jyMXFha5fv/5OhhargryhxcXFxZV0qevXr6903pMnT6o1tFhdi/gXL17Qr7/+Sra2tiQSiWjcuHH0+PFjhTHBwcGCLeL/+OMPQbb3JSUldPjwYerevTvTbzEYHyGsyGIw3hFxcXHUtWvXv4Zn3qOKmitFGqnbtzfRtGmG/M8vXhylyEgHcnbWIXNzLdq9O1gmRnlHahHNnDmQiorOUGLiFL5wO3w4QnBHiugCrV/vQV5epvxQ4Pj4SXzhVp2zYdXt166to379mlL//s35ZYCqdO3u3t1aqdh89uwgzZo1iJydO5GFhTbt2hUm9++haHnQ/v37ydXVlQoKCmjWrFm8G+CuXbsU/m2FDC2uiEQiUUk7U86ZM2eodevW1KZNG5o6darKTm03b95UOLRYGdUtocrLy6MZM2bw+q3Dhw+rPbTYz89PUMyrV6/kFpvJycnUt29fEolE5OvrK7MsUN2hxap2yso5duwYOTk50atXr8jLy0sl/Za6WjuhHan9+/dTq1atqHXr1hQcHKzyM6hsaLEyqvtvo6p+69y5c2oNLU5ISBDs/qioI7Vjxw5evxUeHk6FhYWV9r+tIYeqpKWl0dChQyknJ4eSkpLI29ubFi9ezPRbDMZHACuyGIx3hI+PD5WWvqEjR1bTuHG9ycVFh2JixtHvv68V3JEiukD29m15G/dZswbRs2dlboDlhZQqHamywu0IhYfbkaFhHfLwMOKXAVYspFQZWlxRvzV6dDcaMqSN3JjIyGHVDi0uXwbo4qJDiYlT6NatjTRlivx7pMwi3t6+LU2bZki6ur3ohx9+oMzMTCIqe8lUtLTP3Nyc/vjjj0rbHj16RGPGjCGRSESDBw+mK1cqDzpWd2ixuh2pkpISSkpKIkNDQ5JIJBQVFaX0hc/BwUEti3ghHalyN8D69evTsGHDBHVj1NFIVWcRL5VKKTo6mvT19UlfX5+io6MpPT1dLY2UOoWPPIv4W7duVXIDrOoOGRsbS97e3oLyqGsRz3EcFRYWUlRUFK/fSkxMVFqA/h0W8VeuXKHBgwdT/fr1//pCSvVhvgYGBoIt4gMDA5V2pAoLCykyMpIkEgmZmJjQ1q1bKSMjQ/AgZiL1lj/a2NjQ77//XmlbRf3WunXrmH6LwfiXwoosBuMd8OTJHxQTM4Mqaq6Ki9No/XoPMjauS8OGtacDB2bLdGoUdaSOH19QqZAq12+5uOiQjU0zevhwl0xMdR2pmJhxdOPGevL0NCZnZx0KCxtMmZkHlXakFJlNzJ5ty9vKe3gY040b6yv8TvK7dnfvbpUppIqKzlB8/A9kYlKPnJw68MsAVblHqalLeIt4qTSTNm3aRMbGxqSrq0tt27aV220pLi6uNEdKHufOnSMbGxvq3bs3TZo0iZ4/f056enqCOlJE6lvEV+1I5eXlUXBwMK/fkvdNuTpFwttYxJe7AXIcJ+MGWBV1LeKFdKRycnLI19eXGjZsSD169KCUlBSV8yQnJ5OTk5Oga1OlI3X48GGysLAgkUhE/v7+lJOTo5ZGSh2LeHkdqezsbJo2bRpxHEf9+vWj06dPy8SpUyS8TUdq9+7dZGZmRrq6ujRr1iyl+i11LeI5jlO5I/X06VOaMGECaWtrU+/evenixYsq5zl9+rRaFvHV3fNffvmFQkJCyNfXl44ePcr0WwzGvwhWZDEYb0WZ5mrjRi96+nQ/ye/edKLs7KMUGTmMnJ116Mcf9enq1cS/CqlBcmPkdaSILtCbN6fI2rpJpWWA5fuSkqYqnLUlr5BKSZlHo0Z1JUPDOpWWAVbsSKkytPjatXV/6bd0yNfXnCZOFMuNUT60uBNv4+7srEOensZ069bGSoVU1c/EiVyF5Y//LxZyc3OpRYsWJBaLydTUlHbu3Mnvi4qKouDgYJX+slKplDZs2EASiYTq169PCxYsELR8SJ1la9V1pDIyMsjV1ZXXb12/fp0OHjyo1tDit9FIVTxPXFwcGRgYkL6+Pq1YsULmd/b29hZsEZ+enq62RXx6ejrvBjh8+PBqlzb27dtXpaHFFYmOjla5IyWVSmn58uXEcRw1aNCA4uPjBT0X6lrEHzlyROH+a9eu0dChQ0kkEpGrqys9ePDgnQwtVpWqQ4uLi4tpwYIFleYKVv2dAwMDBVvEv01H6vLlyzRo0CDiOI7GjRtHT548URrTr18/unbtmqA8QiziS0pK6NChQ+Tp6UnOzs4y3XYGg/HPQ1GRpQkGg6GEIgBPADwHQMjMzETjxo1ljjp+/DjatWuPBg0awMtrOgAgPT0dMTExOHfuHMRiMTIzM9GoUSM+pqSkBAUFBZW2lbN161bY2tpizJgxyM5+idjYGKxbtx4NG2rh0aNHWLt2rUxMdvZLaGpq4tNPP6203cTEBBcuXMTgwYPx/PlzjBs3DjVr1sLQoUPQp08fXL16BZ6eHjLnu3PnDr78sgE0NDQAAB07focFC+YDAFxcXCGVlsDNzQ3GxsZwcnJCzZo1AQBPnjxBly5dZM6XmpqKb775Btra2vD39wcAXLt2DatWrcLFixehr6+P7OyX+PLLBpXuUV5eHpo0afLXlhx+X3x8PMaMGYOQkBD8+eefCA4ORkREBFq2bIk7d+7g1KlTMtcgDw0NDTg6OuLChQtwdXXF48ePYWBggNq1a2Pq1KmwsbFRGHvz5k00bNiQv0eqcu/ePejr6yvc36pVK6xZswYAcPr0aXh5eeHUqVMYOHAgXr58iQYNGqiUZ9WqVTAzMxN0ba9fv0aNGjVQp04dfpuGhgZGjx6N0aNHIzc3FxEREZBIJKhfvz68vb1hZmaGEydOICIiQlCuoKAg+Pj4CIpJSUlBu3bt0LZtW6xfv57fNnHiRGRnZ8PExAQBAQGVrr+0tBTZ2dlo27atoFxJSUnYt2+fSsdqaGhg4sSJePjwIezt7XH16lXo6uqiYcOG8Pf3V/r3vnfvHho0aCD4Obp16xb69OmjcH/Hjh2xZcsWAMD+/fvh5uaGixcvwtHREW/evMFnn32mUp61a9fCwMBA0LXl5+dDKpVWelY1NTXh4eEBDw8PPH/+HDNnzsSSJUvQpEkTBAYGolevXjh8+DBSU1MF5QoKCsL06dMFxZw6dQpff/01unXrhp9++gkAsH37dv7eDBgwAB4eHqhVqxYfU1paiszMTHTs2FFQrri4OOzYsUOlYz/55BNYWFggLS0NDRs2xKVLl5CUlIQWLVrA3t4eTZs2FZSbwWB8QORVXh/qwzpZjH8OlYcIE5WZV+zeHULyui3jxvWS25EqLk4jV9fOlZYBxsaOpzdvTtHatVMpLm6C3PMpWtp38WIMmZrW5/VbmZkH+X1ls7aq70gRXaCsrMMUHj6E7O3bUZ8+X8rot8o6UsqGFnei/y8DnESurp3J3b0XRUW5qjRrq+o9cnbW+Uu/VWa8sXbtVCouTqONG6fTqlVjq8QUEZFis4kjR45Q586dBf/Fq3YSHjx4QKNGjSKRSERDhgyhq1evysSoo5E6cOCA2h2pxMREXr+1dOnSajtuqgwtroqXl5fKHan79++Ts7Mzde3alZo0aUK3b98WlOtdW8RX1G8ZGBhQbGwsv83Hx0dQHnUt4qu69t24caOSfkuec6U6Q4tPnDihlkW8SCSiqKgovpuUlJRUbQdNneWPgYGBtGzZMpWOvXLlCtnZ2VH37t2pefPmgvRbRO/eIr6wsJDmzp1Lurq6ZGJiQtu2bSOitx9aLISqhhwPHz6khQsXkpeXF23YsEHwsmYGg/H+AFsuyGCogmxxVf5ZsMCJnJ070Y8/6tOVK/8vPpRppJKSKhdSxcVplJQ0lR8KvHt3iIyu6cWLowrtzyMjHXiL+JSU+TRuXC9+KPCIER0VOhsqM+TYvTuE12+Fh9vxboDKnA3lFVKZmQepb19tcnL6jl8GqMo92rDBs1IhVVh4mrdxNzKqU2mpZNkni7KyssjQ0FDuX3DatGlyhxYro7qhxWlpaWRjY0MikYimTJnCDy79uzRSVS3i8/LyKDAwkMRiMZmbm8sd9Po2hhxCl605OjrSokWLVNZvEZVppEaMGCEoj5Bla69evSJvb2/iOI6+/PJLmRll1fE+LOIPHjxI5ubmxHEcBQYG8i/KbzO0WAjx8fGVLOKzsrJo6tSpJBKJFOq3cnNz1baIF6orcnZ2psDAQF6/NXv2bKX6LSLVhhZXRchz9PTpUxo/fjxxHEdaWlqCh3MrGlqsjAcPHihc/lhaWkqXL1+mkJAQ8vPzo+TkZMH/vTIYjHcLK7IYDKUoLq6ILpBUeo6iolypvGgpdwOcOXMgLV8+SnBH6sWLo+Tq2pnmzrUnZ2cdmjbNkH7/fS0RXaC5c5XN2pK1Py8qOkPz5g0jU9P6Mvqt8kJK8dDiTpV+Pnp0Lrm796LBg78mR8dv5Q4FVsUivqJ+KyJiCMXGjlc6ays/P1Vm+8uXyXzHztlZh6ZPN6HbtzcR0X2aOnUqrV27Vu5fUl2NlCpDi6VSKa1bt46MjIzo+++/p+7duwvSb70Pi/iMjAxycXEhkUhEDg4O/Lfz06dPp/j4eEF5bt26pZZFfMXfqaJ+S09Pj1atWiX376GORXx0dDT5+voKinn9+jX16NGD12+NHDlSpbzqWsSr0pEqLi6mpUuXkp6eHnXp0oV69+4tKJe6GillHamrV6/SkCFDiOM4cnNzowcPHhARUUBAwFsNLRZCxS8tiouLaf78+SSRSMjY2Jg2bdok9x6pY8iRmJhI06ZNExSTl5dHXbp04fVb48ePp6dPn1Ybp45FvJubm0pfChQXF9PBgwfJz8+PAgIC6Ny5c4LyMBiMd4OiIotpshj/cSprrhRx8eJF9OrVEwDQrl07REZGAgBOnDiB4OBgtGrVCkSEkSNH8pqo7OyXqFmzpoxGCgBiY2Pg6OgICwsLAMDt2+mIjY3B06dP8fDhI7i6usrEpKeno2FDLRndRs2aNfHs2TNERUWhWbNmiImJwbp166CtrY0xY8bi6dNn6NSpk8z5fv75Z7Rr167SNjMzM5iZmWH8+PHo3Lkzr9+ytx8KMzMzXkf2f43U/9m6dSskEgmAyvqto0ePYvbs2Wjd+mt89tlncHR05PVbr169gqamJj7/XFYbEhcXBwcHe1hbWwMAfv/9d6xYsQKPH89GcvJTXtdVkevXr0NbW1stjZSenl61x2loaGD48OEYPnw4zMzM0K1bN16/5eHhwV+rIlatWsX/zVXl5cuX+OSTT/DFF1/I3d+qVSskJCQAKNO9letdMjIycP36dUG5goKC5N5XZSQnJ+Pbb7/lf66q3woPD4dEIvlLr+gFMzMzlJaW4uXLl2jTpo2gXElJSThw4ICgmLCwMIwbNw7u7u789U6YMAEvX76EmZkZ/Pz8Kum3AODu3btqaaTS09NV0sBpampi0qRJmDRpEiwsLNCqVStIJBJev1Xds7hmzRoYGhoKurbc3FwQEerVqyd3f6dOnbB161YAwL59++Dq6orc3Fw8ePAAt2/fFpQrODhYsEYqNTW10vOgqakJT09PeHp64vnz5wgNDcWiRYsq6bdKS0uRlZWFDh06CMoVHx+PnTt3CoqJjIzEmDFjMHnyZADAtm3bMGzYMLx58waDBg3C1KlTK+m3AODhw4eoU6cONDWFvWr9/vvviI+Pr/Y4TU1N9O3bF3379oWNjQ3q1auH7du38/otef9OMxiMvxF5ldeH+rBOFuPvQ3nnqupn2TI3Ki5Ok9levrSvfBmgm1sXGju2Bx04MJvmzBlKhw6Fyz2fooG8t29vouHDv+OXAcbFTaDCwtNUfUdKdinejRvraeTI78nUtAFv415xvzIdWcWlfWX6LTtydtahIUPaUHj4ELnXUN3Q4nIbd1fXzjRuXC9KSZmn0qytqtvT0zdTjx6deRv3+fPn898UDx06VO6SJ2Uom7WliKodqQcPHpCbmxvvBlh1Hk45QocWE5VZxAvtSN24cYO+//57MjAwIIlEQsuWLVOpU6KuRurevXvVHnf37l0aMWIEcRxHPXr0oAkTJgjKo2hocXUo6khJpVJatWoVr9+Ki4vjjxs+fDgdO3ZMUJ7yocVCqNqRunbtGjk4OBDHceTi4iJXv0WknkbK39+fVqxYISgmPT2d2rVrx+u31q1b996eIysrK5U6Ur/99hsNHjyYOI4jAwMDGj9+vKA86lrEK+pIFRYWUkREhIx+i6isIyV0aPHp06dpyJAhgmKqjhp48OABLVy4kHx8fGjjxo2Un58v6HwMBkMYYJ0sBgNQtXNVkYKCN6hZs6bcbyOjo1dhyJAh0NTUxIgRIzBixAhkZ79EXFws9u8/gMePH6NFixaVOkmKOlIAEBMTAz8/P3Tq1AnFxcXYuHHjX92kmgo7UidOnEC7drKuaR06dEDt2rWxadNGXLlyBQEBM1BY+AZGRkYYNqzMQUues+GWLVsqfZOupaUFPz8/AICTkxMyM5/BxcUV3333HcaNc4eWlhbfkZLXtYuJiYWtrS1q1qwJNzc3uLm54fnz54iJicGhQ4fw9OkTtG/fHu3bt+djlLmtxcTEYNWqeejduy/evHmDBQsWwNDQEJ9//jkePnwIXV1dmRhlLFy4EKtXrxYUs3LlykodqZYtW/LfPJ85cwbe3t7IzMyERCJBUFAQvvzyy2o7UopITU3FvHnzBMWEhIQgOjoa+vr6yM/P590A69WrBy8vL5ibm8vEHDlyRHBHoLwj9fXXX1d7bJs2bZCUlAQA6Nq1K+7cuQOxWAwjIyMEBAQo7LCUExYWBmdnZ0HXV+aQ+aXc50hDQwPjxo3DuHHj8Pr1a8yePRsSiQRffvkl/vjjDxgbGwvKNXfuXCxbtkxQTHx8PIyMjPifO3bsiE2bNgEADhw4gDFjxiAnJwcWFhbw8fHBF198gdzcXJSWllZ7v6qSnJyM06dPC4qZOXMmVqxYAXNzc2RlZWHmzJmIiopCo0aNEBgYCI7jZGJSU1NVeh4qIqQj1blzZ2zfvh0AoKOjg+vXr0MikaB///7w9PSU6SZVZe7cuRg2bJig6/vjjz8UdqRq1aoFX19f+Pr64unTpwgJCcG8efPQrFkz3LlzR6WOVEXCwsIwd+5cQTEbN26EWCzmf27ZsiWmTZsGIsIvv/yCyMhIFBUVoU+fPjAyMhLcoWUwGGoir/L6UB/WyWK8P4R1rip+duyYodRlT1635datTTRtmmEl/dasWYPo2bODgjtSRBdo795QsrVt9ddQYKNKboDVORtW1W8lJEwma+smZG3dlI4cmSMTV11HqvznI0fm8G6ALi46tGdPiMLfSVFHasoUfbp2LYk8PIzI2bkTRUQMoRcvjlY7a6vivKxykpKSqG3btsRxHNnZ2ak0X0aVocXyUGVosVQqpaSkJDIyMiKJREIGBga0evVqQXlu3LhB1tbWgq9PUSeh3A1QJBLRsGHDKhknvM3QYiFU7EhJpVKKjY3l529FR0cr7JSoo5FycnIS3JFKSEigr776incDVOWevA+NVDkV9VuGhoZkZWUluCN17949tTRSin6ncjdAjuNo9OjRldwArays6ObNm4LyxMfHk4eHh6CYvLw83v2xsLCQIiMjef3Wli1bFMapo5FydXUV3JFavXo1NW3alDiOowkTJqik31Jl+LU8jIyMeDMeRRQXF9OBAwfIz8+PZs2aJdctlcFgqAdYJ4vx30R456oqly9fwt69e6CpqQlbW1tYWFhAQ0MDt2/fVqj/iY2NwejRo2X0W0FBgbh27To6dOiA9u3bV/rWtWzWVjuZcwHA3r17ER0djUaNGuHWrVuIiYlBZuZztG/fDrm5uXI7Ups3b5bRdtSsWRMuLi44fvw4wsMjkJCwBklJSdDW1sbYsWPRrFmzajpSg/mf+/Tpgz59+qC4uBiDBg3Ctm3bsGfPXl6/BcjO2qp8vhiMGTMaHTt2xIIFC0BEOHLkCHx9fXDjxk3o6Ojg+++/r/TtcfmsrYrzsspJTEzE8ePH0bJlS5w/fx4zZszAkydPIBKJEBgYKPcerVy5En379pV7zxXx8uVLaGhoVNuR0tDQ4Lub+fn5+PbbbxEbG4uNGzfCw8MDVlZW1eYKCQnhu4iqcujQIXz33Xdy97Vu3RqJiYkAyjR5P/74I7KysmBgYIDs7Gy0bt1aUK4NGzYI1kjNnj0bLi4uAMru0ZgxYzBmzBjk5uYiLCyM1295e3vD1NQUAHD79m2FHSll3LlzR3BHauPGjTh+/Di++eYbHDlyBO7u7nj16pVC/RZQph80MTERlKc6jVQ5FfVbL1++xPfff4+srCzs27cPAQEBKnVu1ZkjVVUjVREdHR1s27YNALBnzx44OzsjLy8P1tbWeP78eSWNniqsWbMGu3fvFhQzZ84cODo6AijrJnl5ecHLywvPnj1DaGgoFixYgKZNmyIoKAg9evQAUNaRqlu3rmCN1PXr11X677UiO3bsQEpKCjp27FhJv2Vra4sff/xRbsdtw4YNvK5VVd68eYPi4mJoaWkpPU5TUxOWlpawtLRETk4OxGIx+vfvjxYtWsDBwUHu/EcGg/GWyKu8PtSHdbIY7w71O1cVP5mZB2ndumlUrr+KjHQgZ2cd+vFHfRo9uhvvCKhqR+rYsfk0c+ZAWru2TL9V0Q1QVY1UxU9goDXZ2DQjV9fOFB//QyU3QGXOhlUt4q9fL3MDNDfXorFje/A27qp2pMot4jMzD1JY2GBydu5EHh7G5O7eS0kXUP7vdPLkYgoK6kdxcRPIxUWHxo3rRceOzSeiqrO2ivi/tqKOlFQqpZEjR1Lbtm1JIpHQggULKn2LrY5GSl2L+PKOVEZGBrm6upJYLCZ7e3ulOhR1uiNCO1JSqZScnJyoZcuWpKenR8uXL1epY/SuNVIVSU9PJ6f/sXfdYVFcffdIBI3xtaIxxmiMvcZYWDpIExAr1UITWLALCAIKLCCg2DUqTaSpRI2JMVZAVBTQmGZBEGOvdDt1f98f60522dllhyRfkvflPM88Dzszv7l3h2HZe88958yeTRoaGjR79myytLTkzEhlZWXRnDlzONXIY6QaGxtpx44dpKOjQ3p6epSUlCT1HnR1dTnnkQUGBv4hi/jCwkKytbUlHo9HLi4ujBsgG/4/LOLr6+vJxsaGPvroIzIwMKC9e/cq9Rz9EY1Uc9f/+eefacaMGcTj8cjT05NsbGxY4w4UoaUW8WyMVG1tLUVFRZGWlhYZGRnRoUOHpI7r6+s3y0g1RUst4o2NjZmfN2zYQP7+/pSRkdGq32pFK1oAtFq4t+J/A3/O4Eq87d27nJ49Oyazv6QkgyZO7PTOxn261OAoJ2c9RURMZ72ep+d4KQOKysqsdzbuI2jixE6sg7amWVuSm4vLKKqpuUB1dfmUkrKEGbgdPhxCfP441hrJrC22gc+pU2uIzx9Hzs4jKTl5MdXV5SvM2pIXWlxYmEYTJ3YiR8fh75YBZjLHzp3bTGFhU1mv1zS0uLT0OIWHT6e5c4eRkVFnunkz492x37+MbNmyhQQCAesToa2tTW/fvqW3b99SREQEaWlpkbGxMe3du1du1pYitNQini20+Pz58zR58mTS0NAgb29vqqqqYo4dP36csyFHS5etiZc/vnz5koKCgojH45GZmRllZmbKreESWixGSyzis7OzqWvXrqShoUEBAQFKD2b+Kov46upqWr58OfF4PLKwsKATJ078KaHFykBeaPHRo0eZ/K3Q0FCpL8pnzpxpcWgxV+jq6tLz58+prKyMFi9eTDwej6ZMmaLQWnzVqlX/LxbxX3/9NXXp0oU0NTUpKiqKamtrlapTFFosD8pYxD958oQ8PT2Jx+PRjBkz6OLFi39KaLEycHV1pSNHjkjtEwqF9NNPP5FAIKCgoCDKyclpzd9qRSuUROsgqxX/5fhzB1fibetWZ9b9p0+vo9WrZxDRZTpzZgN5eU0gZ+eRlJDgRe7uX8g4+REpZqRSU5dRVJQ1LV8+kdFvia/BhZEiErkB2tj0p2nT+pCPj6GUfks8kFImtFjkBriIXFxGkZFRF0pKWsja96ZZW5IDqfDwaUR0mU6diiY+fxy5uIyi1NSlxOePZx28NhdaHB4+jby99cnJaQQFBztRWVkZEf0+kGqKiooKMjAwkNn/8OFDGjp0KA0YMICsra2V1ic0F1osD80NfBobGyklJYX09fVJW1ubtm7dSsbGxnLd5eRh+/btFBwczKlGXmjx3bt3ydHRkXg8nox+i6jlocVcw1yzsrJo7ty51NjYSHFxcaSrq0u6urqUkJAgt/0/MtjkwkgVFxfT4MGD6dNPP1Vav0UkYqTMzc0596+591RfX09bt24lHR0dMjAwoLS0NDI3N+ccWpyYmEjLly/nVPPy5UtWRkpSv+Xu7i6l3yJq2WDT2dmZTp06xalGzEjV1tbS2rVrSUtLiwwNDenAgQNya1r6HOnr60tNmDSHy5cv08CBA6lv3760YMEC5nOtOSgKLVYEZZ6jY8eOUUBAAEVERFBhYSHnNlrRiv8ltA6yWvFfir9mcCUedMgzc+Dzx8sMpOrrCyglZQnp63dkbNwlBzOpqc0zUuLXOTnryctrAjk6DqfJk3uxhgKvXWtHJ05Esl5PPJAqKtrDhAJHRVnT5ctxtGyZHmuNIkOO2bOHvlsGOJJ8fAypuHgviQZSm0ggmMJa4+U1QWb5Y21tHsXHe5G+fkfi839fBig5kFIUWiy+R42Nl+jYsRgyMDAgDQ0N6t+/P+ts7rJlyygtLY31ydHQ0KDGxka6ePEiTZkyhTQ0NGjJkiUKl+vY2trShQsX5B5nA1eL+NevX1NwcDB16tSJTE1NOS1vUsaQoymUCS0+e/YsWVhYEI/HIz8/P/rpp59aFFrcEnaEjZF6/vw5+fv7E4/HI3Nzc5mlhLGxsRQYGMipnefPn/8hRurkyZNkZmZGPB6PVq1apfD3MGfOHMrOzubUzpkzZzhZxFdWVtLSpUupU6dONHnyZE7RBi21iG+OkTp8+DAZGxuTpqYmrV69moqLi/9UQw5FYAstfvbsGXl5eZGGhgZNmzaNfvrpJ6njLQ0t/iMW8V999RVNnDhRJp6CDS2xiC8oKOBkEf/8+XNKSkoiTU1N2rZtm1IGHq1oxf8a5A2yWn08W/EvRR2A+wCuAShDS00tFGH//v0YPXq0zP76+nrU1dVCXV1dan/btm3Rpo0KnJwcsXZtDK5evQpX13nw8fHB9evXkZNzGnPnzpW5HltosaGhIXbu3Inhw4fj888/Z6ymMzMzmXOuXy9kteKWtIgfMmQINmxYj5SUZGhoaMDf3x+PHj3C7t3JqK+vl6qTZxGfm5uLoUOHICgoCCkpyXB3d0dcXDycnV2wenUkIz6XhDi0uKnZhJqaGj74oAPmzJmN1atX4/z583B2doGfnx9KSkqQmZnJmCJIoqlFvIqKCiwsjHDmTCY0NTWZUGATExMpAX1+fj5mz54tc73CwkL06NEDKioq0NDQwHfffYf8/HzweDzMnDkTOjo62Lx5MxoaGqTq7t+/z1mYvmnTJoSHhyt9focOHdCzZ08sXboUiYmJjD2zg4MDiouL5da11CI+NzeX9Z5LQl9fH8eOHUNeXh6GDBkCMzMzPHjwAHFxcRAKhUq180cs4psaMHTq1Alr165FQUEBtm3bhoSEBPB4PDg5OeHOnTtIT0/nHKocGRnZ7H1oCsnQYjMzM5w8eRJ5eXn46KOPYGZmBn19fezevVvmHt26dYsx9VAWa9eu5fQcde3alQkUX7duHTZt2gRNTU3MmzcPDx8+lFv3Ryzivby8FJ4zdepUZGVlITc3F++//z50dHTw+PFjfPXVV6JZXyWgyJBDHuRZxPfs2RM7d+7ExYsXIRAIEB4eDk1NTcyfPx+lpaXYtWsXQkJCOLUVExMDe3t7TjUPHjxgLOLt7Oxw+vRpnD59GjU1NdDX14exsTEOHz4sU1dYWMjZkCMiIgICgUDp8zt16gQ1NTVoaGhg2rRpSEtLw4oVK/DVV1/h7du3nNpuRSv+58A28vq7tlYmqxXN469jriS3hoaLFBQ0iVkGGB/vybAoKSlL5C6da8pIiRmxxYu1ycCgo4x+i+iy0qHFlZWZFB1tQ05OI4nPH0/u7l+w1jRnES+2cRfpt8ZTVtZaOnt2I7O0TxlGSszcTZvWh7FxT0lZwjBue/b4UHy8J+v12JY/Xr+eSgsXapK+fkdas8aWKiuzpI7HxDjQsWMRLNerkFq29ujRI3JzcyMNDQ0yMzNjXSpI1Hxo8du3byksLIx4PB4ZGxvT999/T8eOHSMXFxe5NWxoGlqsLNgYqdzcXJo8eTLxeDzy8fGRWY7k4+NDycnJnNopLi5uESPF4/Ho5cuXFBgYSDwejyZNmtQsM2NmZsZZI7Vz505OFvFZWVk0ceJE6ty5MwUFBXFa+teS5Y/NhRZXVVWRj48P8Xg8srS0pNzc3D8ltFhZsDFSR48eJRMTE9LU1CSBQCCzzDYwMJCzRXxLNFJEonteVlZGixYtIh6PR9OmTaMffvhBYQ0bI9UckpOTOVnEHzx4kPT09Khz5860Zs0apfVbRKL39GdbxD969Ig8PDyYeIorV65QXl4e2dracmqnsbGRJkyYwKmGSNYiXigU0uXLlykkJISCgoLozJkzrfqtVvxPA60W7q34d+OPW7FzwY8//ggrqynQ0tJEQ0MD9u/fDy8vL7Rt2xalpaU4cOCATE1VVTXU1NRk7M8HDhyI3r17Y8qUKVBTU0NwcDBqa2uhq6uLuXPnorCwEH5+fjLXaxpa3LVrVwQEBAAA5s+fD+A9ODu7YMiQweDz+Qyzpji0eCBj4+7s7IzKykrExcXh5MmTGDFiBIqLi6Vme+UxUoDIIn7y5Mnw8PBAfX090tPTwefz0a5dO5SWlmLfvn0yNfJCi4cPH45+/T7F5MmT8d577yEgYAXq6upgZGSMWbMccO3aNfj6+shcr6TkJykb/d69eyMxMRGAyGJeKBSCx+OBx+NBIBAwNsf3799XaH3dvn17hISEICQkBA8fPkRISAi++eYbaGpq4vr166z3lw07d+6Eubm5UueKIY+R0tXVxffffw+hUIi0tDRMnToVjY2NmDVrFubPn48LFy5wDi0ODQ3lzPiIGamOHTsiKioKgCg8WnytAQMGIDw8HAMG/B6QLRQK8fz5c84MRHp6Ok6cOKH0+cbGxjh58iRmzZqFxsZGmJubo02bNnBxcYGrq6tcC3hFocWKcOvWLYUW8V26dMGGDRsAiGzAw8LCcPLkSRgYGOD+/fvo27evUu00DS1WBvIYKUtLS1haWqKhoQFffvkljI2NoaqqCg8PD8yaNQvZ2dnIz8/n1FZwcHCLLOI//fRTqKurY9u2bQCAq1evQiAQ4NGjRxg9ejTCw8PRq1cvpoZLaLEkkpKSWJkgebC2tsavv/6KmTNnoqamBoaGhmjfvj0WLlwIa2truXV/lUV87969ER8fDwBMPEVubi7MzMxQXl4us6pCHvbu3SsT69Ec2Czi27Rpg3HjxmHcuHGor69HZmYmVq5ciQ8++AA2NjZyIyRa0Yr/ObCNvP6urZXJaoUs/n+Yq6bbtm0u1NBwUWb/7dsHycxMnbFxl2SMoqNtGDt2NgZJ8nVdXQGlpi4jO7uBNHFiJzp5MoqEwh+kzlm+fKICi/jfzSZOn15Hnp4iNmnVKgtOGikxI+XsPJKxcRfrtyoqTlFa2jJKSPBivZ48Q47btw+QqWk3cnIaScuXT6SbN/cxx+QzUrKGHDU1FygxcT45OAwiI6POdObMBpkaHx8zuYyUeOa/sbGR9u7dy4QC8/l8cnV1lffAsULMSOXl5TFugMuWLWvWbrklGikuFvFi/dbo0aOpe/fudPLkSU5t/RUW8Tk5OYx+y9/fn54/f07bt2//Q6HFXNCUkXr+/Dn5+fkx+i02442WhBZnZ2e32CL+2LFjjBtgcHBws8+I2LWPCwIDAyk2NlapcysqKmjp0qU0ZswYUldXp4KCAk5ttURr11xo8bfffsvotyIjI6m2tpaSkpI4G3L8UY2UGE+ePCEvLy/i8Xg0ffp0+vnnn2VqnJ2dOWukLly40CJGSkNDg/bt20cGBgakpaUlE0/BBmVCi5uCi0V8dXU17dq1ixYuXEgrV65s1W+14n8GaGWyWvHvwv8vcyWJt29roKamhvfee0/m2FdfZcDPbzlMTExw69YtxMfH49mzZxg4cCBu3LjBME2SEIUWd5fap6raFo6Oc3Hlyq/w8fHG2bNnsWfPXnTv3g3u7u4YPnw4SkvLMHz4cJnrnTlzBoMGDWJeT5w4ERMnTkR9fT1sbGzQuXNneHp6wdbWBiYmJgBEjFRNTQ0rI5WRkQFdXV0MHToUGzasByDSVwQGBqGo6AacnJxQX18PVVVVpqaqqlpuaPHBg1/Dx8cH5ubmKCwsRGxsLMrLyzFs2DBcuXKFlZFiCy1u164d3NzccPPmTcyfPx9nz55DUtJufPhhT/D5fAwcOBDl5Y+hpTVe5nrHjh1j7p2KigpmzZqFWbNmoaamBqNHj8apU6dkahRhx44dMDc3h5aWFsMm7d27FzNnzkR9fT0cHBwwf/58qRnslmqk8vLysH79eqXO7dChA8LDw1FSUoLg4GDs3bsXISEh+PTTTxEWFqZwxl9RaLE8iBkpRaHFhoaGMDQ0hFAoRFJSEqysrHDlyhWEh4dDKBQqzRZJhhYri5KSEnTr1k2qjU6dOjGB4CUlJQgNDYW/vz8GDx6MiIgI9OvXr0WhxTExMdi5cyenml27dmHixImwsLCAhYUFGhoasHPnTpiamqJt27Zwc3PD3LlzpfqvbGhxU5w+fRp5eXlKndutWzds3rwZTk5OWLBgAdavX48HDx5gxIgRCA8Px8cffyy39ty5c1KspTIQCoWorKxUGFo8bdo0TJs2DXV1ddi2bRsmTpyIwsJCbNq0iVNba9asYdVlKgIbI9WrVy/m9/3TTz8hLCwMT548wdixYyEQCNCzZ88WhRZHRUUp/fcuxp49e6CtrQ0HBwcm5Hj9+vXQ09PDBx98gCVLlmDq1KlSNcqGFjfFiRMnkJubq9S5nTt3xrx585CXl4f+/fsjNTUVZWVlGDduHKZMmYL333+fU9utaMW/Hmwjr79ra2WyWvF3MVeS27Fjq6XYF0WMlHhLT/cmI6MujI27JMOjLCNFdJlu3txHy5dPpBkz+tL06Z+wWsE3zdpqykgRiWzco6Js3rkBGlBMjIPSzobirbIyi9zcxjA27nz+eMrOjiERI2VPx47Jz9pis4hPTl5MRkad39m4L6P6+gLmmLysLbZ7fu1aCnl769PMmf1oxoy+VFl5S+YpMjExYQ1nlRda3BwUhRa/fv2aQkNDSVNTk0xMTJiZ7JaGFv8ZFvG5ublkYWFBGhoa5OvrS9XV1TI1XEOLiUQW8atWreJUU11dTVpaWhQYGEiamppkbm6ulLNeSy3iz5w5o9S5p06dIjMzMxo2bBgNGzaMk36rpRopRaHFVVVV5O3tzei3xAxtQEDAHwot5oKm7+nIkSMMmxQWFsYak8A1tJiIWsxITZgwgRYsWMDot3788cdm61pqEa+sq+eBAwdo4sSJNGrUKBoxYgQn/dYfsYiXx0g9evSI3N3dSUNDQyqeoqWhxX/UIr5Vv9WK/wWglclqxT8bfx9z1RRHj37P6pJVXFwsd+37zz//jG3btmLw4MHYty+DYTWsra1RWlrKykjl5ORIMVIAMGjQIKxbtw5eXl6wtLTEqlWrUFNTAwMDA8ydOxdt2rRBTU0Naz/27cuAnp4eANHMdGBgANPvBQsW4OOPP0ZpaSk8PT2Z2Uw2Z0MxEhMTYGNjA3Nzc7i6uqC8vBwJCQlISUnF/fv3MG3aNJmaW7duyTBSYly/fh2bN2/B4MGDkJ6eDnd3d7Rv3x4ODg54+vQZRo0aKVOTm5uLAQM+k9o3YsQIbNy4EfPnz4ehoSHmz5+LBw9UYG1tjSVLlgAQzf736dNH5nrbt2/HpEmTZPYrQmVlJdq2bSuXkerQoQMEAgEEAgHu37+P0NBQhIWFoaSkBB4eHpzaCgsLQ2BgIKeaEydOYNiwYVL7dHV1cezYMQiFQqSkpGDKlCkQCoWYPXs282w3x0ixYe/evZxZwNWrV8Pd3R3z5s0DINJvBQcHy9VvAeyMlDK4ffu20tolU1NTmJqawtzcHDo6OrCwsECbNm3g6uoKZ2dnhW0nJiZi4sSJnPr26tUrAEDHjh1Zj3fp0gUbN24EINLoCAQCeHt749atW/jpp584tRUcHMyq81SEM2fO4LPPpP/WrKysYGVlxei3jIyMoKqqCk9PTzg4OAAQ/X00/RxrDklJSTh69CinmujoaLi4uGDBggUAgF9//RVhYWF4/PgxxowZA4FAIKXfAoB79+6hU6dOnJ+jGzduKP05YWNjAxsbG1haWmLYsGEwNDTE+++/j0WLFmHGjBkKa9PT0zm7lb558wYNDQ1yGanevXsjISEBgEi/FRQUhKdPn+Lu3bu4evUqp7ZCQkLg7e3NqebixYv45JNPmNdN9VunTp1CUFAQ/vOf/8DGxoazvq4VrfhXgW3k9XdtrUzW/yL+fuZKcistPUEbNswmPz8jcnIaSeHh0xgdk6+vbLCvPEZKzAQtXKhJJiZdydtbX4bNYsvaaspIEYlCgVNSlpCLyyiaMqU3rVhhwtoHRaHFfP44IrpMWVlric8fT87OIykpaRFFRVnT8ePcGKmSkgxydR0tod+yoYqKU0TUvLNh031lZSdo/nwNMjbuIqPfIhLpyOSFFv9+vav09u1bioiIIC0tLRowYADZ29uzPm3a2tr05s0b1mPyoChrSx4KCwuJx+NJ6beUCSdtyay2qampUqHFr1+/plWrVhGPx6PBgweTg4MDp3bkhRY3B3EeGRtOnz5N5ubmxOPxKCAggGF5HBwcKDc3l1M7WVlZ5OjoyKmmKZPw/PlzWr58OfF4PLKwsJDbB0WMlDy0lJEaM2YMmZiYEI/Ho9DQUKWe35ZopJQNLS4rK6PFixeThoYGjRw5kvM9lxda3BwUMZuHDh0iIyMj0tLSoqioKIZNaklocW5urtzPD3lo+hw9efKEPD09icfj0cyZM+nXX39lrdPT0+MUWkxEFBoaSlu3buVUc+/ePRo2bBijS924caNSDogt+TyysrJSKtxdrN/y9/enmJgYevLkCee2WtGKfwrQymS14p+Ffw5zJYmsrEw4Ojoy2qWzZ88iJCQEb9++RWlpKT77TNYdLScnh1Vb0LVrFzQ0NGDfvn2oqqpCfHw8SktLMWjQILi7u7NmbQHSjBQAqKqqwsnJCU5OTnB2dkbnzp3h7OwMdXV1uLt7YNiwoQoZqYSEeMYRy9jYGMbGxu/cAPfgxIkTuHv3LlRVVWFsbMzUNHU2lERcXBx8fX0Zh73MzCwEBgairq4OpaWlrPdC5Gwoq9tQV1cHEWHfvn0oKytj9FsjRoyAm5sb3r59i549e8rU7d+/Hzo64hngWrRv/x5WrVqFVatWgcfjoUOHDtDU1ESfPn0QFhaGESNGoLKyEqqqqpx1Afn5+YxDnLIIDQ3Fpk2boKWlBaFQiPT0dEybNg0NDQ2s+i0AOH78OGeNVENDA168eKGUS12HDh0QERGBiIgIaGhoQEVFBTweD5999hnCw8ObZSNWr14NV1dXTv27efMmunfvLpdJEOsJhUIhEhMTGTfAR48eYc+ePZzaiomJQVxcHKeahIQEqbyqTp06MQ6NJSUlCAkJwfLlyzFkyBCEh4ejX79+ePHiBdq0aSOXkZKHnJwcREZGcqoJDg7Ghg0bYGRkhIaGBuzYsQMmJiZo27Yt3N3dMWfOHJl7e+bMmRZrpJRhpNTV1bF161YAwIQJE/DixQvweDyMGjUK4eHh6N27t8L66OhozJkzh1P/7t27h86dO8t9jmbMmIEZM2agrq4OmzdvxsSJE6GmpoYHDx4gOTmZU1vR0dEMo6gs0tLSpFz7evXqhdjYWAAi/VZISAiePn2KcePGISwsDOrq6njz5g0aGxvRpUsXTm2dPHlSaY2UGKGhodiwYQMsLCxQU1ODmJgYRr+1bNkyWFlZydQ0ZaSUgVAoRGkpu7ttU4j1W4CIea+rq8OLFy8wfvx4TJkyBe3bt+fUdita8Y8E28jr79pamaz/BfyzmKum25YtTqz7MzPXkJPTiHfZUuPo5MkohuWRx0jV1eWTi8somf05OetpypTeZG7eg3btWsBkS3FhpIguU1HRHvL1FbFJM2d+SgcOBLD2XR4jdfNmBnl761N5+UmKirJ+p98ypKKiPc0wUrKsHZHI5XD27CHk4jKKPD3H0+nT65hjnp7jFTobSu5rbLxEJ09GMfcoLU1av8V+j0T6hIqKCqlsrIsXL9LUqVOZWXdl3dbEuHbt2p+ikRKjqX7r+PHjzDFlGSlJbNu2jYKDgznVVFVVkb6+PvP67NmzZG5uThoaGuTn5yfXxU4RIyUP9vb2nBmpb7/9loYOHcrot5Rx/fsrNFKSEOu3eDweaWho0Pbt2zm1c+vWLTI3N+fcP3nvqaKigpYtW8awpZIOm+bm5lRSUsKpnYSEBPL39+dU05SROnz4MBkZGZGmpiZFRESw6reIWqa1c3Jy4sxIHT58mPr378+4ASqj3/ojeWTKMFJfffUVTZw4kbS0tGjixImcNVL37t37wxopSTx48IDc3NyIx+ORjY2NFAOlLCMlifT0dFqyZAmnmrdv35K2tjYRifRbly5douDgYAoKCqJz58616rda8a8AWpmsVvy9+GcyV5IoKbkldwb44MGD2LBhA9TV1VFVVY3ExATs2bMXXbp0wfPn1XIYqX3Q19eX2W9oaIiUlBR8+eWXOHToEPh8PtTU1GBjY4Px4yfIZaTi4mKlMlqGDBnCuFLNmDEDmZmZ+P7772FgYIi5c+dAVVVVISOVkBAPNzc3dO/endEB3bhRhPj4eFy+/CO6du2Kjz76SGrtvzhriw379+/H5s2b0aNHD5SXlyM2NhbJyclQV1fH8+fP5WZtNc1tUVFRgZmZGTIyMrBly1bs3/8VPDw8GP3WmDFj8N577zW5Ry8BdENYWJiUDkpDQwOHDx+GUCh8p5fbh9TUVNja2mLRokXN5tkIBAKsXLlS4TlNcfz4cRmNlBhN9VshISEQCAT45JNPUFZWpnRukhgZGRmcNVIRERHMDDIA6OvrQ19fH0KhELt374aVlRWEQiEcHR3h4eEBFRUVFBcXK2Sk5OHOnTvQ1dXlVLNz506cOHGCcf0LCQlBQEAABg4ciIiICNasrbi4OCkmVhlwYaTE+i2hUIiBAwdi7969yMjIwLx58+Dk5NTsfQkJCcGKFSs49S8nJ0fu51G3bt0Yl70bN24gNDQU3t7eGD58OON2ygWpqan4/vvvOdVERUVh7ty5zOupU6di6tSpaGhowJYtW2BsbAw1NTV4eXnB1tYWKioqzTJS8lBcXAxTU1NONXFxcThx4gQGDx6MX375BeHh4Xj06BG++OILhIWF4cMPP5SpSU1N5Zwj9ebNGwiFQqUYKTs7O9jZ2aGurg4DBgzAV199he+++w5Llixh1bg2RUhICHx8ZN1ZFSE/P1/u50qfPn2YXMGLFy8iICAApaWl0NTUxNOnT5XOAxQjISEBhw4d4lQTExMDW1tbACL91oQJEzBhwgTU19fj5MmTWLlyJaPfUuRG2YpW/CPBNvL6u7ZWJuu/Ef9s5kpyi4/3pNevz8nsl8dIEV2mDRtm08yZn5KT00iKiJhOpaW/M1ouLqNkWCo2Rkq8LzrahkxMutLs2UNYtV9OTiNlsrREjNQ+8vbWZ/qanLyYcQOcO3cYJ40U0WU6c2YDhYdPp1On1hCfP46cnUdScvJiqqvLV5i1pegeTZ/+CTk5jaDoaBuqrMxijslj7aqrs8nDY6zUvtLS4xQePv3dPRpKJSUZEsevEpH8WXJJRurt27cUFhZGmpqaZGxsTEePHpU5X4yWaqTYnA0VYdmyZfTZZ58Rj8cjHx8fpWbFmzJSykIZJuHly5cUGBhIPB6PJk2aRHp6epwZqRMnTpCTkxOnGkVMQlZWFk2aNIk0NDQoMDBQioFqiUbKz8+PEhMTOdVIMlJVVVXk6+vLuAGeP39ebl1LniNzc3O6desWp5qFCxfSJ598QpqamiQQCOSySZJ4+fIl6erqcu6fMs9RWVkZLVq0iHg8Hk2dOpXMzMwoMzOTUzu5ubmc9YOKnqODBw8ybFJ0dLSUG2BLNFLBwcG0bds2TjWSjNSTJ0+Iz+c3q98iatlzNHnyZCosLFT6/MbGRvL09KTevXuTtrY2bd68WSn9liQjxQVN88jYINZvBQQE0I4dO6isrIxzO61oxV8JtDJZrfj/xT+fuZJEY2MjsrOz8cknn8DMzExqpnXv3r3Q12d3LLty5QoyMvZBVVX1nX4rGDU1NZgwYQLatm0rlS0lRlxcLGxsbKT2de3aBQEBAbhxowhBQYFISEhAWVk5hgwZDD6fj6qqKqird0ebNm1krhcfL2KkAJF+y9nZGc7OzqisrIS9vT1iYtZBXV0dfL4H4+R05swZubPdGRkZCA8PR48ePWBqavJOv5UOd3cP3Lt3F9euXZNxVsvIyJA7A3zt2jVkZGRATU0NmZmZCAhYgdraWujo6EBFRYWVtYuPT8DMmTOl9vXo0QPBwavg7HwLfn7LsWPHDlRUVGDEiBHg8/l49KgBPXr0YJ0lFwgECA4OBgC0b98eISEhCAkJwcOHDxEaGorw8HB88sknEAgEzOytZNaWsmhoaMDLly9ZnQ0V4YcffsDVq1fRvn17pKWlYdq0aWhsbISDgwMWLFjA+p4iIiKY37uyUJaR6tixI6KiogCI2CgNDQ0sX74cAwYMQFhYmFJMycaNGxEfH8+pf7GxsUy2W1OI9YRCoRAJCQlMHpGdnR3TZy44d+4c1qxZw6lGkpHq0qULwyQXFxcjNDQUvr6+GDJkCCIiIhj2IDs7mzOzJNZIcdVW/frrr7h27Ro6dOiA7du3M/otDw8PzJo1i/X3HhkZKcVIKYM7d+6gSxd2F1FJqKurY9u2bQCAq1evYuLEiVi1ahX279+PsLAwfPTRR822FRUVhS1btnDqX0pKipSuVRLW1tawtrZm9FsGBgZo37493NzcWqSRyszM5KyRCgkJga+vLwCRfkusJfzhhx8QHByMZ8+eYcKECQgNDWVWSVy4cAGffvopp3aEQiGTUagsVFRUUFRUhKtXr6JDhw6Mfqtjx47w9vaGpaUla11MTAzzt6gsHj58iA8++KDZFQWS+q27d+9CX18fU6ZMwYQJE2BlZdWq32rFPxdsI6+/a2tlsv4b8O9hriS3/Pwv6dSpNRQT40BOTiNp6VJdhgGSx0hVVJySYaTErI6z80iaObOfjH5LxCCxa5pu3txHPj4GUvtOn15Hnp7jycioM0VF2bD2Qx4jlZOzniIiphPRZbpxI13CDdCaXF1Hc2akUlOX0ebNjhQZOZOcnEaQr68h4waorI5MvNXUXCAnpxE0ffon5Ok5nnJy1su8J3nOhkuX6jKvGxsv0fHjq8nDYywNGNCVFi5cyDorqozbWkFBAVlZWZGGhgYtWbKE9PT0ODNSW7ZsIYFAwKlGHiP1+vVrCg4OJk1NTTIzM5PRpLRE29ISjdTx48cZRionJ4dxA/T395er32qptkVHR4devXql9PnPnz+nsWPH0meffUbm5uZKZ2TdvHmTLCwsOPdPmfd0/PhxMjMzI01NTQoODiYjIyO6ffs2p3bi4uIoICCAU408176KigpasmQJ8Xg8srKyooKCAqnjLXmOHB0dKSsri1PN2bNnadasWUQk0t2J9VuRkZFUU1PDWvNHNFLynk02PHv2jD7//HPq168fTZ8+nX7++Wel6u7evUtmZmac+9fc51FjYyNlZGSQoaEhaWlp0fr168nCwoKKioo4tZOamkre3t6cauQxUg8ePCBXV1dW/RaRcoxUU7i6utKRI0c41Vy8eJGsra2l9FsrV66k3NxcEgqFnK7Vilb8WUArk9WKvxb/LuaqKX744TIWLJgPU1PRLPqtW7cQHx+PR48eo7y8DNXV1TKaori4eNjY2Mpcq23btiACvv76a1RVVSMhIR579uxB9+7dYWpqCnV1WW2S6HpxMsyE2H3NyckJH3/cG56enlBVVYOtrQ1MTEzeZW3JZ6RWr14NABg6dCg2bBDNumdmZuLEiZPw9/eHoaEhZs+ezTBuGRkZcjU0p09nIzY2lmGeCgsLERsbi2fPnqGsrBxv3ryRYaUSExNYs2JE57XB119/jYqKCsTGxmH37mR8+GFPmJuby83aSkhIgLu7O/NaRUUF5ubmMDc3x9Sp8/Dhhx9CT08PHTp0wLJlyzBlyhR8//33GDlSNoOrKXg8Ho4cOcK4AaakpMDe3h52dnZYuHBhs7OtgEhjlp2d3ex5kggPD5d6T2J06NAB4eHhCA8Px7179xAaGorg4GD0798fjo6OUFdX56xtuXv3LmeN1KZNmxhGytDQEIaGhhAKhUhKSoKVlRWICI6OjnB3d2f6Exsby1lDU11dDRUVFXzwwQdK13Tq1AmqqqooKSnBb7/9htDQUPj7+2PIkCEICwtj1W8BIre1gIAATv3Lzs5WShMifh4bGxuxY8cO/Pjjj3BxccG8efPg6Oio1O8sLS0Nx48f59S/yMhIODk5yezv1q0bwwRdv34dAoEADx48wIgRI+Du7q4UI9UUN2/e5KyBW7NmDdOPadOmYdq0aairq8PWrVsZN8AFCxZIsSGKGCl5ePXqFYRCITp16qR0Tc+ePfH+++/jp59+wi+//AKBQIAnT55g3LhxEAgErA6ngDQjpSzOnz8v97kUQ0VFBfb29rC3t0dNTQ3Wr1+PvLw8LFiwAEuXLsXUqVOVaisxMRGHDx/m1L+1a9fC3t5eZn+fPn2QlJQE4Hf9VllZGbS0tODu7o6OHTsq9RkpicLCQuaaymL16tWIjo6W0W+dOHGCyd+ytbXlnN3Wilb8FeD2ydqKVsigDsB9ANcAlOHfOMB6+/Yt2rVTw3vvvcfsGzhwIGJiYjBy5EhYWloiJCQELi4uSExMRG1tLQCgqOgGMyiThGRocdeuXeDv74+UlBTMnz8fmzdvxsOHD7B69WqUl5dL1ZWVlcsNLR46dCicnJyQlJSE6Ogo/PDDZTg7uyAiIgLGxrJ9aGhokBta/PTpMzg5OSI+Ph5CIYHP58PT0wvZ2dk4ffo069IhNov44cOHY8OGDfj8889hbGyEgIAAuLq6Ii0tDfX1DQCAa9euw8zMTOZ6kqHF4mWAKSnJcHZ2xpo1a/Do0SPExMSgqqpapu9sA6bc3FyMGTMAwcHByM/PR0pKCg4fPgwejwdPT0+Eh4fL1MiDiooKqqqq4OPjg+zsbFRXV0NPTw+mpqY4duyY3DqxRTzXpSt5eXnNWlr369cPycnJKCgowMKFC+Hq6orbt2/D19cX1dXVSrXTUot4ttBiFRUVuLu749y5czh+/Dju3r0LHR0dmJub4/Tp09i7dy/nUOXIyEjOFvGSocWDBg3C3r17cfHiRTg6OsLLyws8Hg8rV65kgoDFuH37NqspjSKsW7cOYWFhSp8vNmdZsGABDh8+jCtXrkBbWxuTJ0/GhQsX5Na9ePECAPfljzk5OayDdUmMGDECBw4cQEFBAWbMmIHp06fj3r17CA8PR01NjVLt/JkW8Wpqali+fDny8vJw8OBBnD17Fpqampg+fTp+/PFH7N69m1nmqyyio6Mxe/ZsTjWSocVjx47Ft99+i4sXL8LIyAgODg7Q1tZGTEwM6urqpOqKi4tZP9+a6x+X56h9+/bo27cv3NzckJaWhiNHjkBTUxPW1ta4du2a3LqWWsSfOHGCCXyWB/GEVF5eHsaNGwcjIyM8ePAA27ZtQ0NDg1LttNQi/tmzZzKGHKqqqpgyZQqio6OxYMECnDt3DgEBAdi5cycqKio4tdGKVvypYKO3/q6tdbngvwn/zmWBbNvRo+EyIbjiTdJevL6+gNLSlpGr62iaM2cozZ49hHVJm+LQYtH1cnLWk5fXBHJxGUVJSQvp1KloWr16BmuNp6c8i/gCsrMbSL6+huTsLFoGKA4FTk1dRomJ81mv5+IySmZpX1nZCQoJmUwGBh2llgGKt7Vr7ejkySi570l8H2pqLlBi4nxydh5JTk4jae7cYaw1zYUWi5cB8vnjyNV1NKWlLaPTp9dTePg01prfDTnqpJ7S+vr6FgWzamtry5gGiJfLaGhokI2NjYyYvKWhxS21iG9sbKTk5GTS09MjHR0d2r59u8JlX/8fFvG3b98mGxsb6tKlC82ePZuTcUNLlq01F1rc2NhIO3bsIF1dXdLT06OkpCTKzMz8w6HFyoLNkKOwsJDs7e2Jx+ORs7OzzO/E39+fc2jxrVu3aNKkSZz7x+PxqL6+njZt2kTa2tpkYGBAe/fuVfh7aIkhR2JiIvn5+Sl9/q+//kpTpkyhzp07k6enJ6eg2r/CIr62tpaio6NJS0uLjIyM6NChQy0OLW7J55G+vr6MIcelS5fIysqKJkyYQIsWLZIxg2hpaHFLLeKbxlMcO3ZMYc3kyZP/cov4O3fuUEREBBkbG9PBgwflLkttRSv+KCBnuWArk9UKjvj3M1dNcevWLdalBSKTgN+ZoLZt22Lu3LlISkpC9+7q6Nu3L1xd58HHxwfXr19nzisrK8ewYbKMwenTpzFkiGi5kaGhIXbu3In4+Hi0bauKyMhIlJSUIDMzU6qmvr4etbXsocUZGftgZmaK9evXIzk5GRoaGggMDIKrqyv27dsLBwcHmRp5ocXq6ur44IMPEBQUBDc3d8TGxsHZ2QVr1qxBVVUVrl8vZDUkaGoR365dO7i5uSE5ORldu3ZBz54fwtnZBX5+frh16xZTxzYbCYgYqYEDBzDLAOPi4rBz507U1NQgLEyAO3fu4Ny5c1I1DQ0NePv27bvlnC+ljn355ZeYPHmyTDuKII+REi+XuXjxInx8fODn5wcejwdvb29UVlYiPz+f8wx6aGhoiy3iVVRU4OzsjHPnzuHUqVN48uQJdHR0MGnSJJnniEtosSQyMjI4Lavr378/+vbti40bN8Ld3R2LFi2CpqYmAgMDZdgkSfxVFvEqKiqYP38+cnNz8f3336OwsBC2tra4e/cuJ7OC+Ph4qdBiZSDPIn7YsGHIyMhAQUEB7O3t4ebmBh6PB4FAgDdv3uDs2bPNMlJN8Ucs4tu2bYtly5bhwoUL+Prrr1FQUABtbW1MmTIFP/zwg1SNUChEVVUVZyYrJSUFq1atUvr80aNHY9SoUYiOjsakSZMwZ84caGtrIzo6WoZNkkRLLeKLiooULm9VU1NDQEAA8vLysGfPHpw8eRJTp05FWVkZrly5onQ7aWlpnJfrymOkJkyYgCNHjjC/L1tbW2hra2Pjxo1oaGjAyZMnMX/+fE5thYaGttgiXhxPkZ+fj127dmH//v3Q1NSEnZ0dbty4IVXDJbRYEgkJCQgNDVX6/E8//RRCoRCTJ0/GJ598gqioKAQHB+PChQsQfS9uRSv+YrCNvP6urZXJ+ifjv4e5ktxKS4/TtGl9KD7eU4bdEQfzsrMtv5tXlJRkkJ+fETk5jSBPz/EUHGzJWsPnj6fy8pMy+8UW8ZWVmRQdbfMuFNiACgvTKSVlCSUlLWS9HhsjJX5Pkyf3ehecPJ6ystYyx6KjbZRipMRbZuYamj17KBka/odSUpbIGG80x0iJf75+PZV8fAzIyWkELV6sTatWWbDWKLKId3Ia+c7GfRo5OY0kPz8junXrK9qzx4fi4z3fnXtX6qllY6Saw5IlSyg9PV2pcxsbGyklJYXGjh1LXbt2pa1bt3ISf7eEHTExMaH79+/LPX737l1ycnIiHo9HDg4OdPPmTdq6desfDi1WFk1DixsbGykuLo50dXVJV1eX4uLiZJiG5hgpNpw6darFFvE3b94kBwcH4vF45OTkRHfv3lVYp6Ojw9ki3t/fnxISEpQ6t76+nrZu3UpffPEFde3alVJSUjixMX+FRfzVq1fJ2tqaeDweubm50aNHj1ocWvxnWMTX1tZSTEwMaWtr08SJE+nAgQMyNY6OjpxDi/8II/Xjjz/StGnTSENDgxYsWNCstTgbI9UcuFjEi+MpxowZQ127dqXDhw9zaqulFvHXr1+Xe/zChQtkZWVFPB6PvL29qaqqitLS0v5QaDEXNDXkqKuro++++45WrFhBUVFRnIO7W9EKNqCVyWpFy/Dfx1xJIjMzE7GxsejQoQPmz58PDw8PnDhxgrG+FVueSyI7O1tK2yLWb6WkpKCqqhqPHz+Gi4sLdu3axei36uvrUVdXi+7du8tcTxxa3LVrVwQEBCAlJRmenp7YtSsRu3Yl4eHDhzL6raqqKqipqbHan+/atQtLly5l9FuXLl2Cs7MLfH2X46effmKdsZUXWmxiYoLevT/Cli1b0NjYCD6fDy8vL+Tk5AAAnj1jn41sGlos1m/t3r0bT548waNHj97pt9KZNfzSjJQ0RIYcOu/0W8GMfmv79u2Ii4tHeXk5nj9/Dkkmq6UaqYsXL2LWrFlKnauiogInJycMGDAAhw4dQnl5OXR1dWFqatqscYGi0GJ5aGhowKtXrxRqGfr164eUlBQUFBQwQvng4GA8f/6c0fsog6ahxcpArEeUfI5UVFTA5/ORm5uL48eP486dO9DR0YGFhQXOnDkDoGWhxRs2bOCktQN+Dy0eNGgQ9u3bh4KCAsydOxd8Ph+ampoIDg7GmzdvpGq4hBZL4uzZs0rfv7Zt22Lx4sUYNmwYkpOT8fPPP0NLSwtWVlbIz89XWHv69OkWWcQ3x0iNHDkSBw8eREFBAaZNmwYnJycsX74cqqqqSuu3ANnQYmVw9+5dGUMONTU1+Pn54cKFC8jIyMDp06ehqamJGTNm4KeffgLQstDiqKgozs9RSkoKdHV1pfRbBgYGsLW1hY6ODtavX4/6+nqpmpZqpDIzM+Hl5aXUueJ4ijFjxmDr1q347rvvwOPxYGNjI7Xagg2KQovlQSgUoqysTGHUhba2NqPfGjNmDKZNm4ZFixahV69eSuu3gJZZxD9+/FjGIl6s31qzZg3mz5+PM2fOICAgALGxsa36rVb8+WAbef1dWyuT9U/Cfydz1XTbssVJ6nVlZRbFxNjTtGl9yMKiJytLw+ePZ7RPbIyU6OcCSk1dSi4uo8jDYyytWGGikJFiDy3OJD5/PGPj7uw8kpKSFlJdXT5FR9vQqVPRrNeTZ+l+4kQkmZh0fWfjbiP1HpYvn0jXr6cqdb2yshMUGTmTpk//hCwtP2TVsylipMQ6N7F+y8VlFHl6jqeQkMmUkODF2gdFocXu7l8wNu6urqNpy5b1VF9fT0uWLKG9e/cSF1y7do2srKw41RDJzgDfu3ePnJ2dSUNDg2xtbVmtl1sSWrx161YKDQ3lVFNZWcnokcT6rR07djTLlPzVFvG3bt2i2bNn09ChQ6lfv36cbM4bGxtJU1OTU9+IFDNSjY2NtH37dtLR0WHuV2NjY4tCi2/evMmEFnNBU71OYWEh2drakoaGBrm6urI+L5MmTWqRRfyKFSs41Ygt4jds2KC0fovor7eI//nnn2nGjBk0fPhw+vTTTznpt/6IRbw8Rqq2tpaioqIY/da3335LRCJGavv27ZzauXfvHpmamnLuX9P31DSeoqKiQqaGa2gxEVFaWhotW7aMU82bN2+Ix+Mx+i1TU1M6ceJEs3UtsYh3c3NT2iL+9u3bFBMTQ4sWLaKEhIRW/VYrOAGtFu6tUA7/bit2LigpKZHRYnXt2uWdfug3eHi4Izk5GaWlpRg4cBC8vDzRpUsX1NXVolu3bjLXkwwtVlVtC0dHRzg6OqKqqgoODg54/Pgxrl69Cnd3d2bmr7KyEmpqanJCi+Nga2vD2LjX19dj79694PP5uH37DsaPH8/6ntTVZdkyQDQjumXLFgwfPhxZWVkIDAxCXV0tDA0NUVpayjobeebMGRmLeHV1dQQFBcHLywtOTk6IjY1lAi89Pb3wn/90RE1NDSsjtW/f7xbxYv2Wm5sbysrKMGfOHNy9exc3b94En89nZufl6cgAUWixtbU1Y5tdW1uLLVu+g56eHoqKiuQG28qDQCDgpB0B2EOL+/bti+TkZACiEFFfX1+UlZVBV1cXwcHB6NixY4tCizMyMmT0Vs1BbBHv5OQEV1dXvHr1CtHR0dDW1kbnzp3h7+8vY8d948aNFlnEc2GkBgwYgD179mDSpElwdnbGggULUFVVBSMjIwQFBSlkjhSFFsvD8+fPFTJSKioqWLBgARYsWIDq6mpERkZCR0cHRUVFOHLkCKe2QkNDOWuksrOzZT6Phg0bhv379wMQPWfi35+5uTlWrFgBNTU1VFdXN2sJ3hRpaWkKnTLZILaI5/P58PHxQXl5OcLDw7F582Z8+OGHCA4OxoQJE6RqlA0tbgouFvFjxozBoUOHYGlpicmTJ2POnDl4+/Ytpk6dCh8fH6ipqcmtTU5O5mwR/+bNGwiFQrmMlJqaGgIDAxEYGIinT58iJCQE0dHRuHnzJrMCQFmIA665gC20WDKeYt++fZg5cybq6+tha2uLRYsWQUVFhXNoMSDSSH3zzTecamJiYjBr1iwsXboUAoEA9+/fR0hICEJDQ/Hpp58iLCxMZgXJw4cPW2QRf/XqVSQmJip1bv/+/eHn54dp06ZBW1sbkZGREAqFsLS0hJaWFtq0acOp7Va0AkArk9UKMf43mCvJLT7ek968yZXZL8lIibczZzaQl9cEsrT8kLy8JrCyKopDi8cTkShw2NdXFAq8evUMCg62pMzMNaz9k8dIFRXtoQULNCkqylpKvyVmpAoL0+RcTzYEua4un4KCzMnUtJuMfotIvrOhJCMl3k6diiY+fzxZWvaiBQt4VF9fwHqPmgstvnYthby99cnJaQTFxNhTePg0On58tdx7JOvweJeuXr1KRkZG5ObmJjc8kw0t1Ugpw0iJ3QD19fWpf//+ZGZmRg0NDUq3U1FR0SKNlCIm4fbt2+To6Eg8Ho9mzZpFN2/eJKKWhRYfO3aMs0aqoaFBipFqqt9KSEhg7buOjg69fv2aU1vLly+npKQkTjU3b94kHR0dRr/F5gbIhpY8R8oyUvX19bR582bS0dGhgQMHkqWlJSem6M/SSElCUr/l7u5Ojx49IqI/HlqsLJoyUrW1tbR27VrS0tKSq98iErk/cgktJiJatWoVZ0bq7t27NGHCBJo2bRrxeDxWN0A2tFQjpUxosVi/pampScOGDaMpU6Zwauf169d/ikZKErm5uWRpaUkTJkwgHx8fhi10dXWlo0ePcmqnoKCAbGxsONWwPUfffvstrVixgqKjo1v1W62QC7QyWa1gx/8OcyWJxsZG1NbW4v3335c5tnfvXhgaGkrtMzAwgIGBAVxcXKCpqYn58+ejbdu2sLERhQJXV1crYKTiYWcnCi0eNGgQ1q8XhQLn5JxBWJhoJu/BgweYO3cuUy+ZtdUUCQkJWLRoITPrWFxcjPj4BJSXl+Hx48f48MMPZWpycnJY9WWqqqqoqCjH3r17mWunpqaiR48ecHNzk5u1tW9fhswMsKmpKUxNTeHq6ooxY76Ah4cH2rVrBwcHBxgaGipkpCRDi0eMGIGNGzdCKBTi1KlTWLNmDe7cuYPy8nI4ODgws5mSWVvSeAmBQIA1a9YwM+vi8Eyxo9X69etl2EhlQ4slIdZIKcNIid0AnZ2doa2tjfHjx0NXVxedOnWCr69vs3k7ERERMmHVzaE5Rqp///5ITU0FIGItlyxZgsrKSty/f58JIFYWmzZtUnrWWIymocVi/Rafz8eLFy8QGRkJbW1tdO3aFStWrIChoSETWtyhQwdObeXm5mLt2rWcakJDQxEVFcVkap08eRIeHh548eIFTE1NERAQINMPZUOLJSEUCpVmpNq2bYulS5di6dKl0NLSwqeffgptbW306NEDK1euhKampsL6yMhIODo6cupfc4yUWL8FAIcPH4ajoyNev36Nhw8fcn6OJEOLlcXu3bulcs/U1NTg7+8Pf39/lJaWIjQ0FOvXr8dHH32E0NBQjBkzBq9evQIRcQotBkQrAvLy8jjVhIaGIjIyEqamphAKhThw4ABsbW1RW1sLa2trLF26VIalUSa0uCkUaYmbQqzfCgkJgba2Nrp06QJNTU307dsXAoFAoc4KaJlG6sGDBzIaKUno6uri6NGjEAqFSEtLw9SpU9HY2IhHjx4hISGBU1urV6/GmjVrONVkZGSAx+Mxr9XU1Jjg7KqqKhw8eBAJCQno378/7OzsWFe0tKIVUmAbef1dWyuT9f+J/z3mSnI7e3Yj2dp+RuHh02S0Q4oZqXHM68rKLFq71o6cnEaSpWUvSkpaxNpWU8ZHkpHy8TGgurp8SklZ8s4NcBxlZq5RKmur6Xb69Dri88cTnz+eXFxG0e7di5j3oShri61/hYXpNHPmp2Ru3kNGv0UkXyMlyUgRXabS0hMUETGdnJxGkpXVR7R7N/s9YmekRM6Ny5bpUU3NBUpI8CIXl1Hk5TWBzp7dqNDZUFt7ArHh8OHDpKenRwYGBqStrU2bN29mZlWNjY2ZGXhlsXnzZgoLC+NUU1FRQQYGBszrpm6A8mahm7r2KQM7Ozu6cOECp5pjx44Rj8cjXV1d0tHRodjY2Gbbra+vb9Gsu7KMVElJCc2ePZs0NDRo8ODBFBMTw6md4uJisrCw4Nw/ee+poaGBvvzyS9LR0SF9fX1KTk5m7pGZmRlnjVRsbCwFBgZyqnn+/LkUI3Xt2jWysbEhHo9H8+bNo4cPH7LWaWpqcn6O5syZQ9nZ2ZxqMjMzafTo0aSlpUUGBgaUkZFBQqFQYc0fySNThpH66aefGDbp888/pzVr1nBq5+7du2RmZsa5f/Le09u3b2n16tWkpaVFxsbGUm6AlpaWSjFSkkhJSSEfHx9ONa9fvyYdHR3mtaR+a9myZaz6LaLfM9a4oCWMVHZ2Ng0ePJh4PB6ZmJjQyZMnm61paR6ZgYGB3Pcrid9++43WrFlD/v7+tG/fvlb9VitamaxWiPG/yVw1xa+/XsG+fftw4cIFhISEoKamBjo6Opg82Qpqau3kaqQkZ+66du0Cf39/AICDgwMKC6/D2dkFgwYNhJeXF9TV1RUyUvHxCXB394CqqiqcnJzg5OSEyspKxMXF44cfLoOI4O7uIZW5JZm11RRfffUVIiNXQ11dHfX19dizZw/4fD5UVVVRXl4uN2tLcgZYjGHDhqJz507IyNiHM2fOIDAwEHV1dZg4cSIsLCzQtm1bVkYqISEe1tbWzOsePdQZjZO9vT2uXLkCZ2dnjBgxAh4efHTt2kWus6HoHsXD3d0d7dq1g7u7O9zd3VFWVobY2DhcvHgJAODp6Snlknb27FmMH88+k7tlyxZkZGSgd+/eqKmpQUxMDPT09NChQwc8efIEvXv3Zq2Th/379yM7O5tTTUREhFQOktgNEBDNXvv4+KCiooLRb3Xu3BmFhYXo0aMHZ23LvXv3oK2tzalm48aN2L9/P/r27YtXr14xbFLnzp2xYsUK1ryo2NjYZpm4pqiursZ7772nFCM1cOBA7NmzB4CI6czKysLXX38NY2NjBAYGNuv8FxISgqCgIE79y8zMlMtIvffee1i4cCEWLlyI6upqREREQEdHB127dsXDhw85MxDp6enNulE2hVgjJcaIESNw4MABACJW1tnZGa9fv4aFhQX8/f3Rvn17/Pbbby3SSN26dYtzTtiGDRtw6NAhDBgwAOXl5QgNDcWmTZsY/RabprQpI6UMuDBSX3zxBb799lsAwODBg3Hy5EkcPnwY06dPx7JlyxTqtwDRc7R8+XJO/VPESLVv3x4rV67EypUr8fjxY4Y5/fjjj/Hw4UOlGClJ7Nq1C4cPH+ZUExMTA3t7e+a1pH5r7969jH7L3t4eCxYsQNu2bXH//n385z//4ayRKiwshKWlJaeajRs34ptvvsHw4cNx7949hISEIDg4GP3790d4eDjr3+i+ffuaZXSboqamBvX19UqxU5999hlWrFgBIsLYsWMZ50YLC4tW/VYrpNA6yPqfQevgSow3b96gfft2eO+996Cvrw99fX00NDQgIyMDTk6O6Ny5M06cOAEzMzOpLyNFRcUIDAyUuV5xcTE+/rgP1q1bB0C07Co4OBhv377Fy5cvERYWxtqP8vIymdDibt26QVOTByIhrK2t3y0DLMfQoUPg6emJr77aj8jI1TLXahparKqqChcXF7i4uCA2Nhbnz5+Hs7ML1NXVwed7MP+8c3JyEBsbK3M98dI+VVVVZhlgfX090tPTMXv2bHTq1Bk5OTmYOHGiVN3164WsX0JKSm7h448/ZpYBZmVlISBgBerq6vDy5UuEhISw3iM2i/gePXrAwED0RWzGjOn48ssvUVlZiZEjR4LP5yMjIwMCwZcy12poaMCbN2+YgZTkcpmwsDAcOnSIWS4TFhbWrAi8pRbxeXl52LBhA+uxpstlpkyZAqFQiJcvX2LHjh2c2mmpRfzLly8ZK+eOHTsiOjoagGjJWHBwMIKCgjBgwACEh4czg9uMjAycOnWKU1sttYj/9NNPmXsUHx8Pc3NztGnTBi4uLnB1dWUdQNy9e5ezRfz69esRFxfX7HldunRhfp8CgQC//fYbNDU1MXToUISHhzdriy221W+JRbz4d9MUVlZWsLKyQkNDA7788ksYGxtDVVUVtbW1iIyM5NSOOLSYC5paxKurq2P79u0AgCtXriAsLAwPHz7EmDFjEBYWhl69egEQWaN///33nNqKjo7mbBF/584d9O/fHydPnkRdXR02btwIQ0NDtG/fHgsXLpSaKJJESyzio6OjsWnTpmbP6927N7MkLiQkBD/99BN4PB40NDQgEAhY4z8k0VKL+BMnTuD8+fMy+1VUVDB37lzMnTsXb968wbp166Cvr48PPvgAjY2N8PPz49ROXl7eH7aIl5yQys3NxbJly1BRUQF9fX0EBwczA+2EhAQcOnSIU1sxMTGwtbXlVPPkyRN0794dERERqKurw/HjxxEYGIguXbrA1taW899NK/4LwUZv/V1b63LBvwL/28sC2bbvvw+jkpIM1mNOTiMZG3cnp5Hk7a1P166l0I0b6eTjY8haIy+0uK4unywtP2SWAUparmdlraXIyJms12Nb2pedHUMeHmNJX78jJSUtklnOqCi02NV1NNXW5pF4GaCPj8h4IyxsKs2bN4a1pjmL+NLSE7R69QxychpJvr6GdPPmPiopySAfHwPWmuXLJ7Iu7aupuUDm5j2YZYBnzmxgjp05s4HCw6ezXq+pRXxj4yU6dmw1ubmNIX39jpSa6i+zlGXDhg1yl/ZJhhbn5eXR5MmTm10uwyW0WIxr167R5MmTOdW8fv2aPvroI9LU1CQzMzOlw1abCy1mw9atWykkJKTZ806fPk3m5ubMPZJcbqQsWmLtLS+0+Pnz5+Tn50c8Ho/Mzc3p7NmzzLGTJ0+2OLSYKyQt4o8dO0ampqaMXbW8ZZEtsYi/desWZ4v4iooK+vDDD4nH45GVlRVdunRJqbrmQovZoGxo8aFDh8jIyIi0tLQoLCysRUYKLbWIZ/s7evLkCXl5eZGGhgbNmDGDfv75Z+ZYbm4uOTg4cGrnj1rENzY20r59+8jQ0JC0tbVpw4YNcpfocQktFuPevXtkYmLCqeb+/fvUo0cP4vF4ZGtrq7Tte0st4pcuXarwnMbGRql4ii1btvzphhzyIM8ivrKykolJiI2NVWoJYiv+3UDrcsH/NbQyV/Jw+/ZtTJ48WWZ/UVER1NXVGRt3QLRMJj4+HpcvX8aYMWNQVlYmY01eXl7Guqzj3Llz0NXVRWBgIKqqqhAXF4f09D1QV++Op0+fsoq7mzJSYhgZGeHBgweYMEEDKipt4OnpCTU1Ndja2sLY2Bg5OTmsAnMx2yJeBjNs2FBs2CAy3li4cCFevHgOV1dXGBoaYvbs2cwyyRs3ihAQECBzvZKSEnTv3g09eqhj5cqVAERLQGJjY/Hzzz9j7NixqKqqRteuXaTqxIYTTVFQUABtbR0EB696twwwFklJSejZsyeePn2KjRs3ytSwhRarqKjAwsIcFRXlGD9+PGpqnsPQUAft2/8Hy5Ytg5WVFQ4ePIjTp0/LXK+iokKKkdLS0sL333/PLJeZMWMGGhoa4ODgwBieACIzDWVmqCUhEAgQHBzMqebs2bOYNGkSdu/ezbpcpqntN6BcaDEbvvrqK6UYKXGsgFAohKmpKUpLS6GrqwsnJye4u7s3uxytuLgY3bt3/9Ms4jt16oSYmBgAomc0JCQEfn5+GDJkCH777TfG2EVZiEOLuaCpRbyFhQUsLCzQ0NCAnTt3wszMDO+99x7c3Nwwd+5c5r2fO3eOs0A/JCSE9e9TEX755ReYmJggPT0d165dg0AgwMOHDzFy5EiEh4ezLpVVJrSYDSkpKTh69Giz582YMQMzZsxAXV0dzMzM8PTpU0ycOBELFixQilVoqUW8PEaqV69e2LlzJwDgp59+gkAgwOPHjzF+/HgUFRUpxWxKIiUl5Q9bxDs4OMDBwQE1NTVYv349s7x56dKlmDp1KlOXmZmJ3NxcTm21ZPnjgwcPYGhoiP379yM/Px/+/v4oKyuDtrY2QkJCWJk0sSEHV2Y9MTGxWUZKRUUFrq6ucHV1xevXrzFp0iQ8evQIkyZNgp+fn1JRD2yhxcrg2rVrrGY/Xbt2BZ/PBwD89ttviI+PR1VVFTQ1NWFpacm61L4V/6VgG3n9XVsrk/VnoJW5UrQ9e3aM9uzxYT0mj5ESszdiG3cXl1GUmDifamouUGbmGoqKsmatkRdafP16Khka/oecnEZSZORMKdYqOXmxXAONpoYcFRWnKCrKhmbPHkJGRl1Y+x4VZUOnTim2iK+ry6ekpIXk4jKK+PzxlJ7urZCRkh9aPIJOnowiPn8cubiMotTUZVRfX0A5OespIkI5Rkq8/fLLrnf3aAStXWtHVVVZzLG0tGVKhhZX0IMHD8jV1ZXGjh1L6urqrDbuixcvbja0+PXr10x4pomJCe3YseNPCS1WBvIs4s+dO0cWFhakoaFBy5cvlxL+b9myhXNocVVV1R+yiH/58iUFBAQwbNLp06fl1rTEIv7EiRPk7OzMuaZLly7E4/EoKChIbhBxUygKLZaH5cuXN8tIVVVVkbe3N/F4PLK0tKSMjIw/1ZBDEeRZxB85coRMTExIU1OTIiIiGEaXSBRaHBAQwKmdP2oR/+zZM5o/fz7xeDyaNm0a/fjjj3Jr5s6d+/9iEZ+RkUGdO3cmTU1NiomJodraWqXq9PT0/hKL+IcPHzLxFNbW1pSZmfmnhBYrAzZGqrGxkVJSUkhfX5+0tbVp69atUqxQamoqeXt7c2rn7du3f4iREhsKaWhokIODAxNPwQYuocViXLp0iaytrZU+XygU0oULF2jEiBG0cuVKysvLa9YIphX/HqCVyfpvRytzpQy+/fZbnD9/HpcuXYKHh4cUuyLP+jYrKwtDhw5lbNzF+q358+fj9u3bWLRoEYRCodRsan19vdzQ4osXL8HJyRmuri7IycnBqlWrUFtbC319fZw5cxaJibJWtaLQYmlDjm7duiEwMABr1qyBiYmpjH6rW7duKCoqQmAgOyMlDi1WVVVlZgLLy8vh7OyCjh07Yvny5fD09JRiSkpLyxSEFg+CmZkZzMzMUFtbi/T0dHh4eODu3btYtmyZTE1DQ4Pc0OIrV65i7ty5cHV1xalTp+Dv74+GhgYYGxsjKyuLdUZZ1iL+Jfr06YekpCQsWbIEVlZWjI27pqYmQkND0a1bN1y6dAmbN2+WuZ4kOnToAIFAwIRniq3X7ezslNJvASIzguZskZtCkUW8np4e9PT0IBQKkZKSAisrKwiFQsyZMwcZGRmcDTnCw8P/kEW8pH7rt99+Q0hICAIDAzFw4EBERERIif9bopHauHEjZzvw3377DYsWLUJYWBhiY2Nhbm7OzHw7OzuzMiDV1dUKQ4vl4dy5c81axHfp0oVhZ2/cuAFTU1N07twZrq6uiIiIUCoKgC20uDkosoiX1G9t3bqV0W95enoiNTUVJ06c4NTWH7WI79mzJ6M//OWXXxAeHo7Hjx8z+i3JiIqSkhLOjGNLLOJfv34NPp+P8PBwbNiwAQYGBnj//fexePFiJnqiKcSMFFeL+KysLFy4cEHhOR9//DHDoFy6dAkzZsxAx44dsWTJEggEAqXMG9hCi5uDPEZKRUWFMW968+YNYyj0n//8B76+vkhMTORsyLF27VopQw5lIBlaLKnfOnfuHJYuXYrKykro6+tj1apVUr8XeYyUIkRERMjVRLKhTZs2uHfvHoyMjBAcHIxjx44hICAAXbt2hZ2dHT777DNO7bfiXwK2kdfftbUyWS1BK3PFZduyxYmIRNbgfn5G5OQ0ksLDp9GBAwEUFWXDWiOPkaqry6c5c4YyNu7e3voMy5OUtIiSkxezXo/NIr6uLp927HAnA4OOjI17U0ZK2dDirKy1xOePJweHQTRz5qesdvS+voYKGCnR9a5fTyUfHwNychpB0dE29N13oXIZKUWhxbNnD6HwcJGNu5+fEaOHS01dRomJ81mvx2YRX1NzgbZscSIDg47k5TWBzp3bJHU8JsaeTpyIlNh3lcSQ1G00NjZSWloa6evr09ixY//QDPD58+cZ/Za3tzcTnskGY2NjpUKLJbF582YSCARKn//y5UtatmwZde7cmczMzDjN8rfEIt7e3p7Onz+v8Jzs7GwyNzcnHo9HAQEB9PXXX3NmpBoaGv40i/iqqipavnw58Xg8srCwkGHUli9fTrt27eLUzs2bN/8QI6WsfotI+dBiScTFxXGyiC8rKyM+n0+dO3emKVOmKK3fImqZRmrOnDnNPqtff/01TZw4kbS0tCg6OppOnTpFs2fP5tTOH9FINWWknjx5Qh4eHsTj8WjmzJn066+/Sh1vaWhxSy3iGxsbae/evUw8xaZNmxRqjFpqEc+Fkbp37x7NmTOHOnfuTPb29pzaa4lGqjmL+MbGRkpMTGT0Wzt37qS8vLwWhRa3xCLe0NBQRp9VUVFBsbGx5O/vT3FxcVRZWcn5uq34+4FWJuu/Da3MFVfcvHmTmQEeOHAgo+E4d+4cQkND0bu3aHbQ0dGRYUMUMVLp6XtgamoKZ2dnACIHvfj4OJSWluLRo0dIS0uXqRExUrKhxaqqqqiurkZwcDC++OILxMXFIy0tHerq6nB3d5fLSLFZxBsbG8PY2Bi+vr748MMPwefzoabWDnZ2tsysr6RjkyREocUiS9zhw4czrmmZmZmIjIzExx/3QVpaOmbN+j0UWMxIyQstNjIyYhiS69evY8eOHaioqMDjx49ZtTLyQovbtWuH2tpaBAYGYsyYMYiPj0diYiJ69eoFPp+Pa9euw9fXV6KiFkA9rl0rlrI/l3TNsra25uySJRlarKOjw+i30tPTMW3aNFb9FpfQYklwtYgXsy9ffvkl9PT0EBISgpUrV+Kzzz5DWFiYXAbkxo0bLbKIv3v3LnR0dBSeY2RkBCMjIwiFQiQmJsLd3R0DBgxAYmIi5s2bp1SbLbWIZwst7tKlC+MEWlxcDIFAgOXLlzNugMowUk3xRy3iJfVb27dvh6mpKdq2bQsPDw/Mnj2buUdcQoslkZaWxskiXl1dHd26dcO6deugpaXF6LdGjRqFsLAwuVEHt2/fbrFFfHOM1MyZMzFz5kzU1dVh8+bNsLOzw6BBg/D111/LdQNsij/TIr5Xr14Ms3r58mWEhITg8ePH4PF4CA0NVYqRaorQ0NAWW8SrqKhg1qxZmDVrllQ8xQcffMDoUsXgElosicTERHz33XdKn9+3b1+GyR47dix8fX1RVlbGxFPIc0K8f/8+w0hxQXMW8SoqKnBzc4ObmxtevXqF6OhoBAUFYciQIcjOzlaaFc3IyGiRRXxdXZ3Md4lu3brB09MTgOjvIC4uDtXV1dDS0oKFhUWzsQKt+IeDbeT1d22tTJYyaGWuWrrFxfHpzZtcmf11dfnk4jKK6usLKC1tGbm6jiYPj7F0/PhqSkpayImRIhJppWxs+pOnpygUOClpIXNeVJQ1ZWWtZb0eW8hwUdEecnf/giZO7ERRUdYyjJqPj3KhxWVlJygqypqcnEaSk9MI8vMzYq2RH1qcT87OI6m2No927VpALi6jyNNzPOXkrFfISLm4jJITWpxJM2f2Iz5/HLm6jqa0NJF+i+gyrV1rRydPRsl9T01Di69cSaZ588aQoeF/KCbGgaqrsyWOV5C1tbXcmfiWzGo3F1r8+vVrCg4OJh6PR6ampnTixAnatGnTHw4tVhZsjNTZs2fJwsKCeDwe+fn5yczK29raUl5eHqd2jh07Ri4uLpxqxKHFz58/J39/f0a/debMGYV1yoYWS2L58uWUlJSk9PknTpwgLS0t6tKlCwUHB3NqryXPkZmZGd25c0fu8YqKClq2bBlpaGjQ5MmTKS8vj2JjYykoKIhTO8+fPyc9PT3O/WMLLT58+DAZGRmRpqYmrV69Wkq/RdSy0OKcnJwWMVIaGhqMfktTU5OmT58u5QbIBmVDiyURFBREO3bsULpfGRkZNGHCBOrSpQutX7+eExvTkueoOUbqwYMH5ObmRhoaGmRjY0PXrl2j5OTkPxxarCyahhY3NjZScnIy6evrk46ODm3btk3mHrm4uNCxY8c4tZOfn0+2tracasTP0e3bt8nR0ZF4PB7NmjWrWTdNZUOLJREREUEbNmxQ6lyxfmvx4sVkb29PBQUFrfqtfzjQymT929HKXP0RNDY2oq6uDu+//77MsfT0dBgaGqJt27YMw1FVVY2EhHgcPXoUY8Z8gQkTJkgxPxUVFQpDi728vGBsbIz6+npkZGTA09MTqqqqePr0mdysLTYmaMiQIejUqTN27NiBR48eITAwCHV1tdDXN8DcuXPerY8fKlOXnZ2NoUN/n6VUV1dn2nV2dkZNTQ2cnV0wdOhQeHry0a1bN7nOhoAo3FFfXx9qamqYN28e5s2bh/LycsTGxiIzMwvjx49DSUmJFFNSVVUNNTU1OaHFCfD09GT0W2lpaXB3d8f777+Pp0+fss7mygstHjVqJLp37wZv72V48OAB/Pz80NDQAFNTU9jazsfDhw8xYcIEmesdOXKEYaSURUNDA16/fq0wtLhDhw4IDw9HeHg47t+/j5CQEHzzzTcwNTVFcXGx0rPHYWFh8PDw4NS/69evszJS4jw4oVCI3bt3Y/LkySAiODo6wsPDA/fv34eWlhantjZt2oSkpCRONWJGqlOnTgxbJNZvrVixAoMHD0ZYWJgUU8MltFgSXBkpsYPjmjVrcPXqVSYnz83NDY6OjnLZmczMTM6MgFAoxPPnzxVqYrp168a4V16/fh0CgQCZmZmwsrLCw4cPlWZFm4YWKwN5ocVTp07F1KlT0dDQgC1btsDY2Bhqamrw8vKCra1ti0KL165diy+/lM21U4SkpCQYGhrK6LfCwsLw5MkTfPHFFwgLC0PPnj2ZGi6hxZI4ffq00oyUiooK7O3tcezYMYSGhuKXX36Bvr4+3n//fRk3wKZQFFosD0KhEBUVFQqfvz59+jB6o4sXLyIgIAC5ubmwt7dHZWWlUvotoGUaKbbQYhUVFTg7O8PZ2Rlv3rzBmjVrpPRbkyZNwo0bN2BhYcGprcjISGZ1irIQhxb3798fqampAERurosXL0ZlZSUMDAywcuVKqWeGS2ixJI4ePaq0+2ObNm2gra2NpKQk2Nra4vHjxwgMDGT0W1yfk1b8jWAbef1dWyuTxYZW5urP2M6c2UAXLmxlPSaPkSorO0GenuPp5s3f9VsREdOptPQERUbO5MRIEV2mixd3kKVlL3JyGkk+PgZSDFRzzoZNWaXk5MU0ffonZGbWnbUfinRkLi6jmNeZmWuIzxcxbosWacl17XNxGcVkbUlulZVZxOePk9JvrV1rR5WVWc1mbTVlpIguU0HBdrKw6Mnot27d+oo5Ji9ri+0e1dRcoPh4T5o8uR/16tWLdZ1+c4wUGzZu3NhiRio3N5cmT55MPB6PfHx8FOq3iFqmbbGxsVGakXr58iUFBQXR4MGDqVevXpwYiPr6etLU1OTUN6LmGamsrCyaNGmSlBugj48PJScnc2qnqKiILC0tOfevqc6iqqqKfHx8SFNTkyZPnsyqPzMzM6O7d+9yamfHjh0tZqSOHDlCxsbGxOPxSCAQyLBJTdGS52j27NmUk5Oj1LllZWW0aNEiGjp0KH300Uf0ww8/KN1OSzVSzTFSBw8eZPK31q5dS7W1tRQYGEixsbGc2rl9+zZNmjSJc/+avqdHjx6Ru7s74wZ49epVmRpLS0sqLi7m1M7u3btbxEhpa2szulRtbW3avHlzs4xbSzRSzs7OdPz4caXOvXv3Ljk7O9OIESPo448/5qTfaqlGShEj1djYSAkJCaSnp0e6uroUGxtLjY2NFBYWRps2beLUzqNHj8jY2Jhz/5q+p/Lyctq5cycFBARQQkJCs/9DWvH/B7QyWf82tDJXfybOnz+P3377DcnJyZg5cyYzS11eXo527dgZqfj4eNjb22PQoN/1W2fOnEFw8CrcuHEDH374IWpra6WYGnmMFCDKINq4cQOGDBmC4uJiJCQkoKysDIMHD8azZ09ZZyObMlKASL/l7OyMvLx8+Pv7Yf/+/UhNTYO6ujr4fA989tlncnVke/fuldIkmJiYwMTEBPX19Zg+fQZevnyJy5cvw97eHhMnTgTwu46MbW14XFwsbGxsGP2WUChEVlYWAgJWoKioCB9/3AcNDQ1SM5nirC02ZuDgwYNYv349hg8fjuvXr2P79u2oqKjAyJGj8PjxE9asrbNnz2LgwIFS+9q1awcPDw/8+OOPCAv7Etu3xyEiIgKffPIJo01qjpFiw4EDB1izthRBzEjp6uoy+q20tDRMnToVQqEQs2fPhpeXl9T9kMdINQcujFTHjh0RGRmJS5cuMe57gYGBGDBgACIiIhRmI+3cuROTJk3i1DdlGCmxnlAoFCIhIQEWFha4evUq82wpez8EAgErY6wIJ0+exNCh0qxwly5dGF3ijRs3EBYWBl9fX0a/1adPHzx//hz9+vXj1NbevXs5aaQAYPXq1XB2dpZyA/zyyy8ZN0APDw/MmjVL6h799ttv6Nq1K+fn6LfffoOhoaFS56qrq2Pbtm2wsLDAkiVLEB0djYcPH+Lzzz9HeHg4evXqJbd2165dSrcjhjKMlLW1NaytrVFXV4eNGzfC0NAQN27c4OwgFxoaylmzycZI9e7dGwkJItfYH374AStXrsTTp0+hoaHBuJxWVFQwGj1lkZSUxEkjBYjcFWfNmsWs2pB0A/zggw/g6+srwyK1VCNVVFQEc3Nzpc7t168fkpOTMWXKFNjb28PHxwfl5eXN6rcA0d+TtrY2p741x0ipqKjA3d0d7u7uePXqFaKioqCjo4OioiLs37+fU1shISGsDruK8MMPP8jkHHbv3h1eXl4ARCs7YmNjUV1dDW1tbZibm7fqt/6JYBt5/V1bK5NF1Mpc/fnb69fnKD5exNBUVmZRTIw9OTmNIG9vfVq2TI9On17HWiePkSosTCdvb31KTV36LltqHMPYKGakRrDu37hxDpmZqZOz80gp/RaR8owU0WW6cSOdfHwMydLyQ5ozZyhrnbPzSLk6Mj5/HBGJGLzVq2eQk9MI8vU1JD8/o2aztppuN2/uoyVLdCkxcT65uIwiL68JdObMBiJqLmtL9nqNjZdo/fpZZGbWnVxdR9OePT6MfotIftZWfX3Bu+v9PlNZUFBAVlZW1LdvX5owYQInJ6eysrIWaaQUMQli/ZampiaZmZnRqVOniEjESOXn53Nq5+jRo+Tq6sqpho2RysnJYdwA/f39WRmDlmikvL29KSUlhVNNUVERmZqaSum3zp4922xdS2a1uTBSYjfATz/9lLS1tTndi5ZqpBQ9RxUVFbRkyRLS0NAgKysrunjxIhGJGKnm9G5NkZWVRXPmzOFUw8ZIffvtt2RsbMzot9iypXR1denFixec2goICGgRI6Wvr09eXl7E4/FoxowZzeq3iFqmkbKwsFCYySSGWL9laGhIAwcOJD09PU5MUUs1UooYqXv37pGLiwvxeDyytbVl8rC4MFJinD9/nuzs7DjVNH2OxPotsRvg9u3bWf8GWqKREggEtHnzZk41Dx48IE1NTZo7dy7xeDyaPXt2s/otopZ9Hk2ZMoU117EphEIhnT9/nlatWkXLli2jnJycVv3W3wC0Mln/dLQyV38VTp8+DSMjESvTtWsXZmby1q1b4PP5qKyswvnzF+Dl5clkNt24UYQePdgZqcTERHh6emLIkCFwdHREVVU14uJikZ6+Bw8e3IdQKJSpEWVtsWcpFRUVY9++vfjPf/6DvXv3vnMDVMPMmTNRXy/rRgSIGSkDqX1Dhw7Fhg3r4erqCgcHB0a/ZWhoiNmzZ+Ply5dyWbu4uHjY2toCEM1Mr1y5EoDIrWnRokV49qwUP/54GZ6eXujatQsA6awt2evFwcvLE8OGDYObmxvKysoQFxeHpKTdePDgPuOmJAlR1tZAmf0qKiooKSlBeno6OnXqhNTUVEa/ZWdnLzdra9++DOjp6QJ4CUB0D3k8Ho4cOQIdHR24ublhxowZqK+vl3EDZEN4eDhrvxXh2rVrChkpSf3WvXv3EBoaiuDgYNy6dQuRkZGc2tq0aRN2797NqWb79u0yM82GhoYwNDSEUChEUlKSjH7rxYsXLdJI5eXlYf369ZxqQkNDERoayjgYlpSUIDQ0FP7+/hg8eDAiIiJkWKTjx4/LMFLNobGxkRMjJXYD1NHRgbW1NczMzPDee+/Bzc0Nc+fOVcgcRUREwMXFhVP/SkpK0K0bO/sLiPRb4uyna9euMW6At2/f5qxTWbduHXbu3MmpJjExkWG+xZg2bRqmTZuGuro6bNmyBYaGhmjXrh3mz58POzs7vHr1CgDwn//8h1NbOTk5yMvL41QTHByM0NBQRi/2008/MfqtsWPHQiAQSOm3AJGmj2t2kVAoRGVlpVI5ZmL9lr29PXR1dWFgYMCwSUuWLFGo3wKA6OhozJ49m1P/7t27J6ORkkTfvn2Zz5D8/Hz4+/ujrKwMd+/eZfSByiI6OpphgZVFenq6FCPVVL8VHR0NbW1tdOrUCX5+fjA1NW2xRurEiRNKa6TECAkJwapVqzB58mQAov9ZixYtQlVVFat+CxDp4JoyUs1BKBTi2bNnrCs3mqJNmzbQ0dGBjo4ODA0NMW7cOAQGBqJbt26ws7PjnIXWij8ZbCOvv2v732SyWpmrv3rbutWZdX9hYRr5+hoSkUiz5eU1gZydR1Ji4nxaulSXMyOVmbmG/PyMyNfXkJycRlJk5EzGqU8RI+XqOlpmf0XFKZo7dxhZWPSU0W8RKXY25PPHS10/KWkROTuPJDMzdVq/fpac9yTLIBGJ3A19fAyI6DKdOhVNfP44cnEZRSkpS971K43T9XJy1tPSpbrk7a3P6LeqqrKISJGzYQE5O8te7+nTozRnzlCysOhJ/v7GUvot8T0SORtK6x+aMlKvX7+m0NBQ0tTUJB0dHbmuVi3JkbK2tmZYBWVx5MgRmjRpEllYWJCGhgYtX768WUe0lmqktLW1m9X0EIn0WwEBAcTj8eiTTz6hFStWcGqnsLCQJk+ezLl/ipiEzMxMGf0WEZGpqSlnjdSXX35Jq1at4lRTVVUlxUhVVVWRt7c38Xg8srS0lKuNa4lGatasWUoxeJLIysoiXV1dhk0KDw9v9nf9RzRS4vuvCM+ePaMFCxaQhoYGffbZZ7Ry5UpO7fxZGilJ7N+/nwwNDUlLS4tiYmIYxk1ZRkoSu3btIj8/P041r169kmKkxPotTU1Nsra2lstmtOQ5cnZ2ppMnT3KqOXfuHI0bN47Rb23durVZxq2lz5G+vr5SOqO7d++Sk5MTaWho0NChQzn/7T548IBMTEw490/ee2psbKT4+HjS1dUlXV1diouLY343VlZWSjFSktizZw8tXryYU83bt29JW1ubeV1eXk47duygFStWtOq3/h+AVibrn4ZW5ur/A6WlpVBXl2U5ANHsK5/PBwAYGBjAwMAADQ0NyMjIwM8//4KNGzfC2toaJiYmzAxyZmamXEbqwIGDiI6OYmbUcnJysGrVKrx9W4Py8jLWGds9e/bAwMBAZn+3bt3Qtm1bHD58GL/99hsSEhJRXl6OoUOHwM7OjjVrCxAxUnZ2tsxrVVVVuLq6wNXVBXPmzEVtbS2cnV3Qo4c6+Hw+Bg8erFBHlpCQAHd3kcOdqakpTE1NUVdXh/T0dFy+/CNev34NBwcHKV2FZNZWU2RkZGD16tVQV1eHUChEZmYmVqxYgdraWpSVlbOuu8/I2Ac9PT2Z/R9++CHU1NTwzTff4ObNEmzbtg1VVVUYOXIU7O3tJJwNRXlZgOh+hYWFYf78+cx1OnToAIFAAIFAgPHjx2P//v0ICwtD3759ERYWhmHDhuHatWvo2bMnZ23Lw4cPoaGhwalm8+bNSE5ORp8+fSAUCpGSkoIpU6agsbGRVb8FsDNSzaGyshKqqqpo3759s+d27NgR0dHRAICxY8fiwYMH4PF4GDhwIMLDwxXqtwDRPeeqkWqOkRLrCYVCIeLi4pj3//jxY84zx/v27cOpU6c41URGRsLV1ZV53aVLF2zcuBGASL8lEAjg7e2NYcOGISIiAn369GmWkZKH27dvc853WrduHVJTU9G/f380NDRg69atjH7L09MT9vb2Mv1ITEzk7A744sULAL9ntClCz549sX37dgDA559/juvXr0NTUxNjxoyBQCBQqN8CRIyUv78/p/6dOXNG4fNpa2sLW1tb1NXVYcOGDQzj9vjxY6UYKUkkJyfj+++/51TTlJFqqt8KCgrC06dPwePxIBAI0K1bN9y7dw+dOnXi/BwVFRVxzptbs2YN9uzZgyFDhkjptzp27AhfX1/Wz5309PRm8/Oa4s2bN2hsbFSovRKjX79+SElJAQCMHDkSP/zwA3g8HvT19REcHNysg2RISAi8vb059U8RI6WiogIPDw94eHjg5cuXiIyMhLa2Njp37oz79+8rxUhJIj4+HocOHeJUs379eqm8uO7duzP/50pKShAbG4vnz58z+i227w+t+AvANvL6u7b/DSarlbn6/9y2bXOhGzfk5UixM1KnTkVTdLQNVVZm0dq1duTkNJK8vfXp+vVU4vPHKa2REm+JifNp4UJNcnUdTXz+OMrM/F3fpCwjJd6ystaSmVl3mjatD+3evUimlo3xIZJmpIhEujKxG6ClZS8qKNgu5x6xX+/06XUUGTmTSktPUETEdHJyGkHLl0+kmzf3NZu1xXa9pKRFTK6Yl9cEOnt2o9Q9Ys/aymJ0ZOKtsfESHTsWwdyjvXt93+m3fl+vL28G+OrVqzR16lTmdV5eHllZWRGPx6NPP/2UMjMzZWoU4bvvviM3NzdONYoYqdevX9OqVauIx+ORmZkZZWVlMceUZaQksWzZMkpLS+NU05SRys7OZtikgIAAuWxGS2a1TU1N6d69e5xq1q1bRxoaGsTj8cjCwoJyc3ObramqqiJ9fX3O/VOW2RTrt3g8Hg0dOpTR3SmLU6dOkZOTE6caRUxCWVkZLV68mHg8HllZWUllyCnLSEnC39+f4uPjOdXcunVLipE6ePAgTZw4kTQ1NSk6OppVv0XUsufI3NxcKd2MJDZu3EgjR45k9Fu//vprszUvX74kXV1dzv1ThpFqbGykvXv3kqGhIeno6NAXX3zBOUcqNzeX7O3tOdUocu27d+8eOTs7E4/HIzs7Oyk3QGUZKUmEhobS1q1bOdXcu3ePYaQaGxspMTGR0W/t2LFD7n1tyXPUEkZq/fr1NHDgQOLxeDRnzhy6fft2szVNGSlloYz7o1AopNzcXFq5ciUFBwdTXl5eq37rTwLkMFltRMf+GRg/fjxdvnz57+7GX4RW5urvQHBwMMrLy1FTUwMdHR04OjqiXbt2yMzMxI8//oiAgACZGk9PT6xZs5bRHgFASYnIyefy5cswNTWBl5eXFPuze3cyVFTawNnZWeZ6rq6uiI+Ph6qqKiorKxEXF4+ioiJ07twJVVVVSEtLk6mJjo6GhoYGawK9s7MzEhMTkZ6+B+fOnYWaWjvY2dmiT58+iI9PwIYNsroXX9/lcHd3Z83Umj59OuOUaGRkhFmzZkFVVRWnT59GQUEBgoKCZGq8vLwYRkqM69evIz4+Ab/88jMmT54MDw++mTZhaQABAABJREFU1D1MTU1FY2Oj1Oy/GPPmzUNcXBxUVVVRWlqKuLg4xhmtoqKCyTCRRExMDMaMGcM6M+vs7Iy4uDikpaXhwoULqK/vjDlzgvDJJ59g1apVOHz4sEyNjY0NVqxYIZOpJRQKMWjQIPTpI3JKVEa/BYiYltTUVE4Ohps3b8aLFy8QEhKi8Lx79+4hJCQExcXF6NOnDx48eICLFy8q3Q4AaGpqIi8vj9NsuJ2dHby9vWUcDIVCIRITE5ln2dnZGfPmzYOKigqOHz+O/fv3c9KLNTQ0QFdXFwUFBUrXAICOjg4yMzPRoUMHlJSUICQkBLdv32bcANk0V76+vhg9ejTr3648FBcXw8fHB0ePHlW6pqGhAQMGDECfPn3Qtm1beHh4YPbs2c3e/0mTJiE+Pp6Tg2FsbCzu37+PqKgohedJ6reGDh2KoqIizve8Jc/RnDlz4ObmJsOa1dXVYfPmzfj222/Rvn17LFiwADY2NgBEDPmuXbuQnp6udDtCoRDa2tqc35O+vj6+//57dOrUCT/++CMiIiLw5MkTjB8/HmFhYazM/8qVK9GnTx8plrw53Lt3D3w+HydPnlS6pqamBgMHDkTfvn3RoUMHLFu2DFZWVs3WWVpaYtOmTZwy3VJSUnDlypVmtVUXLlxAdHQ0ysrKoKmpiUuXLiE/P1/pdgBAS0sLubm5nBwMXV1dYWdnJ+OG+OrVK0RHRyM7OxudO3eGv78/8780Pz8fmzZt4uQQKBQKoaWlxfkz1sDAAN988w26deuG06dPIyYmBtXV1Zg4cSJWrlzJyv6Gh4ejU6dOnNwIHz9+DEdHR2RnZytdU1NTg3HjxmHKlCmt+q0/AW3atPmRiMY33d+6XPAvR+vg6u/CzZs3oaOjA3Nzc2YZoPjLcXl5Oaudb319Perq6qQGBwAwaNBAjBw5Ap9/Php9+/ZFcHAw3r59C319fTg6OuLcubOIj4+XuV55eblUaHG3bt0QGCga2K1YEYDq6up3ocBD4OnpySw1LCoqZl1eVVRUBHX1HlLLAMvLy5GQkIDVq1dj4MCBuHnzpowVsLzQ4pycHGhoaCAoKAi1tbVIT0+Hh4cH2rdvj8rKSlYBvLzQ4hEjRmDcuLH4/PPR+PjjjxEQsAL19fWYONEIs2Y5ICcnh/UeVVVVQ1VVlblHPXv2RHBw8Lt7tAKNjUI4Oztj5MhR4PM90LlzZwDA9euFrKHFIov47mjfvj2zhOPp0yoEBe3F4cOHMXr0aBQWFkqFSwOQG1r8/fffw8jICAkJCVLLZSTDM5tCmdBiNhw4cECpf5SSy2VsbGxQU1MDTU1N6OvrY9WqVc0ul/mzLeJVVFTA5/PB5/Px4sULZrlM165d8ezZM9ZBrSLs3LmT87KmphbxgwYNwr59+wCI7Nn5fD6eP38OU1NTBAYGMudduHAB69at49RWSyziT58+DUNDQ6SkpKCyshIRERH48ssvGaMZtvsqDi3mahGfnp6OEydONHveyJEjcfDgQQDAzJkzUV1dDS0tLVhZWcHX17fZpaQttYiXF1qspqYGf39/+Pv7o7S0FAKBAOvWrUPv3r3x+PFj5vepLJKSkliXYytCU4v4cePG4dtvvwUA7N+/H7a2tqitrcWMGTOwdOlSxjabS2ixGCEhIayfYYrwww8/QE9PD/v27cPDhw8hEAiwevVqfPLJJxAIBKxL08SGHFxDs3ft2qWURbyOjg4TTzF9+nSUlZVBV1cXDg4O8PLyanbgxBZarAzkhRaL4ykiIyNx584dhIaGYuXKlfjss8/w6NEjxMbGcmpn79690NTU5FTT1JDDyMgIRkZGzISUuN+SE1KAaJl0Sww5uFrEX716FcOHD8eaNWtQXl6OAwcO4N69exg4cCBsbW2Z/7Ot+GNoHWT9ZWgdXP3dOHv2LObOdQQAtG3blskFKSsrw+zZs+Ht7YPu3bvBzc2N+ceUnp4u45Ileb2EhASoqqrC0NAQ9fX1yMj4Ci4urnj8+BHOnDkDU1NTqZr4+Hg4ONizXu/p0ycMQ5Odnc24AQ4fPhzdu7M7JSUkJDA6MjHU1dURGBiIoqJi+Pj4Ii4uDuXlFRg6dCg8Pfn4+eef5WqkvvrqK8bFrl27dnBzc4ObmxuePHkCR0dH+Pj4omfPHuDz+Yw+oWnWliTOnDnDMFKTJk1CbW0t0tLS4OzsjMePHyMvL0/mS484a4v9Hj1DenoaiAinTp2Cn58fGhoa8Pnnn6NbN/Yvd/Hx8XB3d5fa16tXVyQlxUFTsxDR0dFYsWIFSktLoa2tjeDgYJw/fx6jR49m7cOWLVsYhkZSv3X//n2EhIQgNDQUn376KcLCwpgvMVu3boWlpSXr9eShoqJCaY2UJB4+fIiff/4ZALB7925YWVmBiDB37lx4eHiw3iOBQIBVq1Zxauf48eMyA1M2dOrUCWvXrgUgmujQ1taGra0tBg0ahPDwcJkMITZkZGQgMzOTU/8iIiLg5ubGemzSpEmYNGkShEIhYmNjYWpqivfeew8WFhYtGiTcuXMHurq6nGo2bNjATDJ069aNcWu7ceMGQkNDsWzZMowYMYLJ3wJELp1sbLYivHjxAioqKkpppCTx+PFjFBYWQigUMvotNTU1eHl5wdbWlvUehYSEYMWKFZzaOX36tFJap549e2LHjh0ARG6AJiYmmD17Nr744guEhYXJuAGyITU1lbNGKioqCnPnzmU9ZmdnBzs7O9TU1GDDhg0wMDDA+++/D3t7e3Tu3LlFGqmm/zOaQ3R0NOMk2adPH2ay8OLFiwgICEBpaSk0NTWZ/C1AxEhxfV65aKTEUFFRQVlZGYqKilBXV4c1a9Y0OyEFiJ4jX19fTv3Ly8tD3759mz2vf//+zP/Zs2fPYsaMGXBxcYGhoSGrGyAbEhIS8M0333Dq39q1a2FnZyezX9GE1Lx581qUR3bt2jXOGXCrV69mmG51dXWGgb158ya2b9+O58+fQ1dXt1W/9QfROsj609E6uPonoKGhAbW1tXj/fdkvrEeOHIGTkxMcHR1x69YtxMfH49mzUgwcOBBFRTeQnJwsUyMKLW4v9WGjqqoKR8e5ePDgPhwc7PHjjz8iPX0P1NW7w93dA8OGDUVx8U3W5XY3bhRJGXKIQ1hFduKz0K6dGjw9vWBnZyv1Jau8vFxhaPGwYUOZpR1ZWVkIDAxCcXER7OzsUF9fL9V/MSPVvbusDfupU6cwZ84cuLq6orCwELGxsSgvL8eIESNw5coV1qVfIiMFaUOOdu3awd3dHeXl5Zg+fQbOnTuHpKQkfPjhh+Dz+Rg4cCBu3ChiXbYptohv06YN2rRpA3Nzc5ibm6O2thazZ8+Gqqoq5s+fj9mzZ0sZY5SWlrEOBo4d+wqjRo2CpqYmjhw5AqFQiL1792LGjBm4evUqli1bJhOc3NDQgDdv3rAyUn379mWelfPnz8PX15eZwc3NzcW5c+dkahQhLCyMs0V8U0ZKPEgWh2dqa2ujSxdRbIHkcyQ2ruCCjRs3craIP3nyJBYtWgSBQIDs7GzMnz8f1dXVMDIyQlBQEOtAoLq6Gm3btuVsEa8MI6WiooIFCxZgwYIFqK6uxoQJE9CuXTtMnjwZQUFBSon12UKLm4MiRmrYsGHM0qVjx47B1dUVr169grm5OU6ePMnZkEMcWswFt27dYgabKioq8PHxYcJgw8LCsGnTJnz44YcIDg7G+PG/r4jhElosRkxMDGeL+MuXL8PT0xPR0dE4ePAg7O3tUVtbi2nTpsHb25s1hFWZ0GI2nD59ulmL+Pbt22PlypVYuXIlHj9+DD09PaiqqsLa2hqhoaFyJ2wk8WdbxIvjKYRCIfbt24cZM2agoaEBtra2OHjwIKelrYBoMDdnzhxONZKMVNu2bZl4CvGEVEhICD777DMIBAKp/2NFRUWcw82joqI4R0I8ePAAzs7O2LBhA2s8BdsguaamBg0NDX+JRbzkhFRJSQlMTU3Rrl07ODo6Kj0h9cMPPzCTMspCKBTi6dOnrKzn4MGDERQUBKFQiAsXLiAsLAwqKiqYMmUKxo8fjzZt2nBq638drYOsPw2tg6t/EsRuQ2w4d+4cEhJEsz4DBw5kcmSOHDmC06ez4eHhAT09PcydO/edO51I4yCPkRIPpKZMmQJA9GEZHx+P+/cf4NWrlygvL5dZWidyNvSQuZaqqio6duyIlJTkd/qtOKSmpkFdXR2jRo2U++Vu//4DiI6W1l+YmJjAwMCAyZTi8/lo164d7O3tMXHiRNasLTHOnDnDzLoPHz4cGzZsgFAoxDfffIPjx4+Dz+fDyMgYs2Y5MIMSUdYWOyPVdCB1/fp17NixA48fP8arV6/w/PlzmeUJcXFxrMxEu3bt0LHjf5CSkoxnz54hLi4OiYmJ6NWrF8aMGcOatQUAaWk7sGHDQea1iooK5s6dCwcHB2hra0MoFDKuWT4+PrCwsMCWLVuYTBRF0NXVZZbL7NixA0lJSTAxMWH0W++9916z17h06RI2b97c7HmSEAgEzNJKSXTs2JGZpWy6XGbixIlKMVKSaGhowKtXrzj/M5dkpMQTCUKhEAkJCcxyGRcXF7i6ujJfcMLDw+UyUvJw48YNqKurc2ISunTpgu7du6OgoAA3btxAWFgYfHx8MHToUERERMidJd+4cSPrsldFELNnzcHS0hKWlpZoaGjAunXrcOPGDUyePBl8Ph+zZs1S6v2dO3cOa9as4dS/kJAQ1okOdXV1bNu2DYC0fmv06NEwNjbm7L4nFApRVVWl1JdHSaSlpeH48eMARMtjbWxsUFdXh40bN8LQ0BDt27fHwoULpdzVIiMj4ejoyKmdO3fuoEuXLpyeo969e6NHjx4oKCjADz/8gODgYDx9+hQaGhoIDQ2V69y6Zs0ahpFSFsnJyaxOq5JQUVHBnDlzMGfOHLx9+xarV6/GtWvXYGNjA29vb6UZ9qysrD9t+WPTCSnxAF5XVxdmZmactUBCofCd2y63yQ4xI6WiogJ3d3e4u7szE1I6OjrMhJTkUlZ5jJQiPHz4kDMjNWjQIPTq1QsFBQXIysqCl5cXqqurYWJigsDAQLnMtCQjpSy++uqrZifZVFRUoKenBz09PdTU1ODrr7+Gl5cXHBwcYGdnx3kJ8/8quHHbrWBBHYD7AK4BKEPrAOufgYMHv0b79u/L7C8vL0f79u2hqir74ffrr78iNDQUiYmJUFMThWby+XycOnUKJSUlrMsIb9y4IRNaPGjQIKxbtw59+nyMWbNmYdWqVXB1dcXu3btRX1//rh9lrIyUKLRY9I9DpN8KREpKMvh8D6SlpePateuIjo5GZWUlUyPSkdWyzrSlp++BoeFEpv3Vq1cjPz8fzs4uSE5OBo8nay9eWVkppSMTQ0VFBTdvlmDlypWIjY1FXV0tPDw84OXlhbNnz6KoqAgmJiYy17t586ZMaPGIESOwceNGfPxxH0yfPh1+fn6YN28e9u7di4aGBgBAWVk562BAMrT4ww8/REhICFJSUjB37lwkJiaisLAQ69atx/Pnz5mahoYGqKiwa6S2bNmCadOmQSAQID8/H7t27cL+/fvB4/GwceNGTpoJFRUVFBcXY8eOHTh16hRKS0uhq6uLSZMmKWQkmgstlocHDx40axEvXi5TUFAAT09PBAYG4ueff8aKFSsY++3m0FKLeDZGSkVFBZ6ensjNzcXRo0eZJYWWlpY4d+4cLly4IHe5ljy0RCN1/Phx5m9w2LBhyMjIwMWLF+Hg4AB3d3doamoiJCQEb968YWq4hhaLsXfvXk79a9u2LSorK7Fx40Z88803uHTpErS1tTFlyhSF4vs/YhHfnHZJrN8qKCjA5MmTMX/+fFy7dg3R0dGoq6tTqp2EhATOyx/FocVNv2SqqakhICAAeXl5yMjIQFZWFjQ1NTFjxgz88ssvyMnJkVk23BxCQkI4W8RLMlITJkzA4cOHkZ+fD11dXdja2kJbWxsbN25kPtcAbqHFkkhOTmadVJGH999/H23atEFUVBR2796NgwcPgsfjwdbWFtevX5db91daxOvq6uLo0aPIz8/H6NGjMWvWLOYzUygUKtVO09BiZfDmzRtWRko8IZWfn89MkGlqamLOnDn47bffcPz4cSxcuJBTW3/UIt7ExAQnT55Efn4++vTpAwsLC+jr62PXrl1S94hLaLEk4uPjIRAIlD6/ffv2uHv3LubMmQMXFxccPXoUK1aswK5du6T+z7ZCFq3ugi1GK3P1T8WbN2+wZcsWVFVV4dmzZxg4cCC8vLzQo0cPrF69Grq6uqxLXJydXZCSkiy1r6qqGlFRkfjpp5/w+eefw93dXeqLv6+vLzw9PWWMJpper76+Hvv27cOZM2fw8uVL9OjRg9EbSMLT00sqa0uM+vp68Pl87N69G9nZ2Thw4ABqa2thaGjILHFrztlQEpWVlVi8eAl69frwnSnGMHh6eqFr1y6Ijl4DDY0JcpwNZe9RWVkZoqOj8csvv2D8+PHMMkAxli9fDjc3NwwbJpsvJnm92tpapKam4sKFC3j7tgbq6t2ZTB1JsDkbAqKBlIeHB3bt2oUTJ07g22+/RUNDA0xNzVBXV4uGhga4uW2BOC9LDB0dHWRnZ8toocrLy2FtbY2zZ8/K9EEReDwe8vPzpb6g3Lt3D6GhoSgqKpLRbwHynQ0V4fvvv8e3337LaS1+Q0MD9PT0cOHCBSQlJSE1NbVZ/RYg/x4pgre3N8aNG6f0gKmkpARLlizBxYsXYWVlhYiICKUHM5qampwd5MzMzJCQkCC3jYaGBsTGxmLfvn1o27Yt3Nzc8OLFC5SWliI8PFzpdqqrqzF16lTOy0fZXPuuX7/O6AGb6rcAYNasWZg/fz6nTK3s7GykpKSwOnjKg9i179y5c9i2bRsOHToENTU1zJ8/X+Gsv56eHo4fP85JLxYYGIgBAwYoPWD66aef4O/vj59++gkODg4QCARK6beAlj1HlpaW2LJli9wBU01NDdavX4+jR4/igw8+wJIlS1BWVobi4mJmFYUyEC8hPX/+PKf+sT1H+fn5iIyMRFlZGaNLlfyf4+Ligjlz5nDSi50/fx7bt2/nZE4ifo5Onz6N6OhoZGVloVOnTli+fLnCtvX19fHdd99x0osJBAJ0794dixcvVur8M2fOIDQ0FFeuXIGnpydWrlzJmnXJBh6Px9mJcMqUKVizZo3cAdOLFy8QERGB3NxcdOvWDUFBQXjw4AEKCgo4MaI1NTUwNjbmzFKyuT8WFxfj66+/xosXL5jJxP9V/Varu+CfhtbB1T8dp0+fhr29PTO7ePbsWYSEhODt27d49uwZ/Pz8ZGoKCwvRs6dsaHHXrl0YsTwgmgEqLS3DoEGigVt5eQXrACszM1PKzU9VVRVOTk5wcnKCm5s7evXqBWdnF6irqzPW6ooZqXRmYCip30pP34PU1DQMGTIYffr0kRoYyWOkANFSvHnzXJnzMzMzERAQgLq6WpSWlsLPT5a9kRdaLGZgtm/fAaGwETt27EBFRQVGjhwJPp+PsrIy1gFW09Didu3aMW6Abm7u6NKlK5ydXdCrl0i/NWDAANTXN6Cmpoa1H/v2ZUBfXx8qKirMsqu3b2uQlpaKPXv2YOjQYejX7xuYmPz+JVDk/qjGOngICwvDggULZPYrgrzQ4n79+kktl/H29kZFRQV0dXURHBws19lQETZv3szpizEAfPnll7CwsJBZLhMZGQkdHR3G7lhyuQyX0GJJ5OfnN2v9LIlBgwahU6dO+P777/HmzRt4enqiuroaxsbGCpfLHD9+nPX5UoSGhga8fPlS4SCubdu2WLRoERYtWoTq6mqEh4cjKSkJPB4PeXl5Ss+kNw0tVgbyGKkRI0bgwIEDAESDbBcXF7x+/RoWFhbw9/fHnTt3OIcWx8TEcHZbi4uLg5GREdTU1ODr6wtfX1+Ul5dDIBBg48aN6NWrF4KDgzFu3Dim5sWLF2jTpg1nQ44zZ84w5jzKYOzYsejVqxcOHjyIyspKODg4oKamRsYNkK2d5kK1m0IoFKKiokIhI9W+fXusWrUKq1atwuPHjxEaGooDBw5AX18f165dw8iRI5Vqq2losTKQx0hpaWkxy5vFutSGhgbY2dlh4cKFLTbkEIdxK4u0tDTo6OigQ4cOiIiIQEREBBNPERwcjP79+yM8PFzq/rbEkAMQaSm5uPYZGhris88+g5+fH54+fcoss3R0dIS7u7vcCan8/HylDDkkIRQKUVZWppCR6tSpE6M5FcdTHD9+HGZmZrh3757SE1JNQ4uVwePHj/HBBx/ILH8cMmSIlH5LIBCgbdu2mDJlCsaNG9eq3wJaw4iVR2uI8L9l27rVmXX/lSu7ycamP7m6jiYPj7F04kQkNTZeIqLL5ONjQDdv7mOtYwvkzclZT9bWn5KxcRfatWuBTCgwnz+OKiuzZOqahhaLQoINyclpJM2ZM5R27HBn7YOz80iFocXl5ScpKsqanJxGkq+vIRUX76WoKGvKylqr9HsiukzXrqXQjBl9ycVlFHl6jqecnPXMMR8fQyoslBfsLH29xsZLdOJEJHOP0tKWvQsF/v0cRaHFkvfoypVkWrpUl5ycRpCLyyjascONtQ/ygp0rK7PIw2MsPX78Pfn62hCPxyNbW1sqLCykRYsWUUZGBrFB2bBZSVhbW0uFuypCY2MjJSUl0bBhw6hHjx60fft2pdtTFFqsCM2FFv/22280Z84c4vF4NHv2bLp161aLQouvX78uFVqsLJqGhDY2NtKOHTtIV1eX9PT0KCkpSeYemZqa0oMHDzi1s23bNgoJCeFUIw4tLiwsJFtbW9LQ0CAXFxe6f/++wjplwmabwsHBQakgZSLRs7Bp0yYaNmwYqaurU3p6utLtKQqbVQQdHR2FocW//PILzZgxg3g8Hnl6etKTJ0/I39+fEhISOLVz69YtMjc359y/ps9RbW0tRUdHk5aWFhkZGdGhQ4dkaloSWpyQkED+/v6cal6+fEk6Ojp06dIlmjJlCmloaNCSJUuooqJCYV1LniMnJyelw69fv35NoaGhNHz4cOrRowensGNF4deK0Fxo8blz58jCwoJ4PB4tX76cnj9/TiEhIX8otJgLmv5tvHz5kgICAojH49GkSZPo9OnTMjWTJ0+mwsJCTu2kp6fT0qVLOdWIQ4tPnTpFZmZmxOPxaOXKlfTq1SuFdcqEFjeFu7s7HT58WOl+7d+/n+bNm0fe3t6cA+X/rYCcMOJWTVazaNVc/Zvw7Nkz9Oghy0gBInvrqKgoJCUlYe3aGPz6669wdZ0Hb29vPHz4kHU2MjMzE8OHy86SGxoaonv37sxSIj6fD09PT2RmZsnN2gKkGSlANBO0YcN6pKQk4+3bt/jll5/f6aeSJfRbss6GYsTFxcHOzhbdu3dn9Ftubu6Ii4vHiRMncenSD1L6LUCctcUuxk5K2o3o6GhGv3X+/Hk4O7vAz88PDx8+YM3aEjsbSkJFRQWTJk1C9+7qSEtLQ01NDTw8PDB//nycPXtWbtYWAOzbt09qNn7UqJHYvHkzdu/ejerqavz444+YN28e9u3bx+gcqqqqoaamxnqP4uPjYGNjg48+6oX160NRUFAAb29v+Pn5MVql6upqqZorV66gV69enDUJXBgpFRUVuLq6onfv3sjLy8Pjx4+hra2NSZMmNWtf/uWXX3K2iFeGkfrss8+Qnp6OgoICuLu7Y9GiRUhKSsLVq1fx8uVLpdsSG21wARsjpaKigvnz5yM3Nxfff/89CgsLGf3W+fPnGUaqJYYcXK3HIyIiMG/ePMYN8OLFi7C1tcW8efOgqakJgUAgpd8CROxv9+7d/1KL+LZt22LZsmX45JNPcOrUKVy8eBFaWlqYMmUKfvjhB4W1cXFxrDpKRVCGkfr8889x6NAhFBQUYNKkSZg9ezbi4uJQWlqqtH4LaLlFvORyZUBav7Vnzx6cPHkSmpqamDlzJq5cucIYcnBlslJTUzk/52LXvgkTJuC7775Dfn4+NDU1YW1tDR0dHWzatElKvwWInoeWWMQXFxcrzUiJ4yn69euHAwcOMOYIdnZ2uHHjhsLatLS0v8QiXk9PD8eOHUNeXh6GDRsGKysrZmmcsvotQPR55OPjw6l/Fy5ckGGHOnbsiOjoaBQUFGD79u3YtWsXNDU1MXfuXNy5c4dhpLgy6wkJCc0G0DdFTEwMbG1tYWpqipMnTyIvLw+9e/fGpEmToK+vj927d8vcI3mMVHO4evUqpk6dqtS57du3h62tLcrLyzF16lQcOXIEK1asQFJSktIa4P8qsI28/q7tn8VktTJX/8YtLW0ZlZeflNnf2HiJnJxGsNakpCwhK6uPyMlpBIWHT6fS0uPMMWUZKSIRqxQdbUPm5j1o5sx+rKyPPEaqrOwEeXqOZ66dnLyYXFxGEZ8/jvj88ZSdHcPad3mMVGFhOvn4GFJm5hri88eTi8soSklZQnV1+eTjY0BFRXs4XW/37kVkadmLnJxG0tq1dlL3hM8fTxUVp1jvkbOz9PVKS49TePh0srT8kGbO/JRu3fpKpk4RI8XnjyOiy1RTc4Hi4z3J2XkkzZ+vQQsXatKpU9Fy3tMIhrEUbXVERPTrr7/S1KlTKSUlhfT19UlbW5u2bt1K9fX1NHPmTKUZKTEOHz5M7u7unGrYGKm7d++Sk5MT8Xg8cnBwoJs3b8rUNcdIsWHJkiWUnp7OqebatWs0efJkio+PJ11dXdLV1aW4uLhmZ9Rbwo6YmJgozUjdvHmTHBwcqF+/fjRixAi6e/eu0u1UVVWRnp4e5/4pYhLq6+tp69atpK2tTfr6+pSamkqNjY2cGCkxTp48SU5OTpxq2JiEq1ev0syZM0lDQ4Pc3d3p0aNHMnXNMVJs8PPzo8TERE41JSUlZGZmRjExMaStrU0TJ06kAwcONFvXEnZk0qRJdPv2baXO/fHHH2n69On06aef0ujRo6msrEzpdl6+fEm6urqc+6foOXr79i2FhYWRpqYmGRsb05EjR4iIyNHRkTIzMzm1c+7cOXJwcOBUw/YcnT9/niZPnkwaGhrk7e3Nyjzp6+tTdXU1p7aCg4Np27ZtnGru3btHEydOpFWrVhGPxyMzMzPKyspqtq4ln0eWlpZKM1LZ2dk0adIkGjhwIH3xxRec/qbEjBRXKGKkqqqqaPny5cTj8cjS0pL5DHJzc2OeKWVx6dIlsra25lTDxpDfuHGDVq9eTStWrKCjR49yZtP+6YAcJqtVkyWDVs3VvxX0LrBWXV0dZmZmUrN+WVlZctc7X7hwAampaejatQvOnDmD4OBg1NTUQEdHB7W1tXIZqaZug926dUNAQACKi4vh5+eHxMTEd7lWg5kAYXmMVHx8POztRRbxqqqqcHZ2hrOzMyorK2Fvb4+UlFQcPXoMfL4HY5hQXFws42woRmKiKLR4yJAhMDExeaffSgefz8edO3fw+PFjGXdDNkZKjPz8fKSlpaJLly7IyspCQMAK1NXVwdDQELW1Naw6sr1798o4lvXo0QPBwaswb948LFmyBNu3b5fSbzU2NsplpCRDiyX1W8+ePcOcOXPw8uUrZGVlw8vLk7GILikpYWESXgLohrCwMCb3x8nJCW/evEFMTAz09PRQVFQkE/rcHCRDi5XF1q1bZSzi+/Xrh5SUFAAi57KlS5eisrIS+vr6WLVqFRoaGuTqyBTh4sWLTACushBbxPN4PHh4eDD6LXH+VkBAgIyJzLFjx/5yi/hBgwZh37590NHRQUBAAPh8Pp4/fw5TU1MEBgYqzNgKDw/n7DrXHCPVtm1bLF68GIsXL0ZVVRXCw8Oxfft23Lx5E0uWLOHUlmRosbJgCy0eOXIkvv76awDAd999BycnJ7x+/RqTJ0/G8uXLUVdX16LQ4pZaxAcFBcHAwAB+fn4oLS2FQCDA+vXr8dFHHyE4OBhjx46VqmFjpJqDUChEdXW10hbxY8eOxTfffAM9PT24u7szQcPN6bcAkdaOqwtmcxbx7du3Z/KkHj58CIFAgNWrV+PmzZucGT3J0GJlkZKSImMRr6Ojw+i30tPTMXXqVDQ2NmLWrFnw8vJCXV0dhEKhTARHc8jMzOSkkQJ+ZzYnTZokpd8KCgrCZ599JqPfAtgZqeYgtohXlpEyMjKCkZERDAwMMGPGDGaVgZOTE+bNm6eQgWyJRfyjR48UWsR36dKF0W8VFxdDIBBg+fLluHXrFmfGrCUW8QcOHJBxvR06dChWrlwJoVCI3NxchIaGQlVVFVOnTsUXX3zxX6vfanUXZNA6uPq3o7i4GFeuXMXdu3dw7dp1dO/eDW5ubhgxYgQ8PT2xZs1amQFTbW0tvLy8ZEJW6+vrsWyZN+7du4vevXsztLwYLi4uSEhIkBkMlJeXY9WqVVJC8tOnT+Orr/bjzp3bGD9+PMLCwmTq2Fz7AFG+1K5diVi/fj2KioqQkJDA5IM8evQIixcvZrWCl3e97OxsnDlzBu+///67QVoPeHp6YtCgQUo5Gza9d97e3rh37z4++aQPZs2aJTWoUuRsGBgYhLg40T0SCoU4deoUDh06hHv37jH5Mk3/gch7TyUlJYiNjcWGDRtw9epV7Po/9r47rImsb/smgqKrrgUUG1as2F1BqoAgKHaQIlUhAbs0RUooKvZeKCpF7LouFlABRUVF3VXXBoqKiop0pNec749sZhMyCRn2ed7veZ/X+7pyeaWczDBOZs75/e5y5AhKS8swZsxofPr0CRwOp9mkXwlAf4lOYgkJCTh+/Dh++uknZGZm0roBNofAte/+/fsSP0MHWV37eDweoqOjERsbi+zsbEyfPh1Hjx6VmT708uVLrFu3DpcuXWK0f9Lc1t69e4fAwEC8e/cOQ4YMQWhoKAYOHIhp06YhJiaGEYVv7969KC0tBZfLlXlMSUkJ5s2bR7k/CgxqTp48CTk5OTg7O8PR0VHsGNG5rbUEa2trrFixQqawYgGuXbuG/fv3o3379vj06RNGjhwp5gbYHAK3NaYOdzo6Orh69WqLC6bGxkbs3bsX58+fx8ePH2FmZoaIiAiZj0V2djZWrVqFxMRERvsn7Tx6+vQpgoOD8fXrV4wfPx5BQUFQUVGBmZkZDh48yChTKzIyEjk5OQgLC5N5TGVlJczMzKgJf11dHXbs2IHLly+jffv2WLlyJebMmSM2js5FtCXY29vDycmJkY397du3ERwcjA4dOqCgoACamprgcrlSw3F5PB6mTJnC2OFOT08Ply9fbjHAubq6Gps3b0ZycjJlCkHnBCsJHz9+hKurK+OgbWnn0e3bt6l4E319ffj7+6Nz584wNzfHtm3bGFH44uLi8PTpU0ZGHtXV1TA2NqZc+8rLy7Fx40bcunULXbt2xdq1a2ldjelc+1rCkiVLsGDBAkaU8UePHmH16tXo2LEjysvLYWxsjHXr1kktSLX2PDIwMMDZs2clyhIEqKmpwaVLl/D48WO0a9cOixcv/l+bv/XDXVAifiyu/ltw69Yt2Ns7oH17/oT17du3iIyMRH5+Pr5+/YrGxgaxMfHx8TA0FL/hKSgooKqqEr/99hsqKioRERGO+PjjUFLqDgsLC4kdKX5osbXIa4Iql4ODA4YNGwY2m422bdvB0tIC06ZNQ2ZmlpSO1N+hxcOHD6fc2lJSUnD16jWEhYXBwMAAtra21P4IZ201hyC0WHCDfvXqFcLDw1FQUICCggLIyYlPGI4fP04bWtyuXTvU1NTgt98uoKysDOHhETh6NBo9e/aAlZWVlI6UaGgxi8WCqakpTE1N4eDgAFXV/lSAsq2tLXR1dWmztv7+vgi4uPCP0ejRo7F7927weDxcu3YNFy9ewvbt22FsbAJLS4u/bmQVSEhIwJgxY2i/b+/evTh27BiVqXX37l3KPU1bWxsBAQFiOoI9e/bA3Nyc9vskQZqzYXOwWCwsWbIES5YsweTJk9GnTx+qm+Tt7d3ipC0oKAj+/v6M9u/KlStSO1KDBw/G8ePHAfAX7+7u7igpKcGXL18YO3+dPn0aqampjMaEhoaKdKRYLBaWLl2KpUuXoqysDBs2bICWlhalV9TR0WlVaDEAfPjwgdECC/g7tFgwaUhMTISzszNlxb127Vqx/3tZQ4uFUVZWJrNrn7y8PDw8PODh4YFJkyahXbt20NLSQs+ePeHv79+inpDL5dKGFktDamqqVPe9cePG4cKFCwCA8+fPw9bWFtXV1fj69Sv69OnDaFvCocWyonlocbt27bB+/XqsX78eeXl5CAoKQlhYGPr06QMul4sxY8a0KrQY4C9SmeaEbd68GeHh4VBTUwOPx8PJkycxf/58NDQ0UG6AzSfo0dHRLeaeNUd1dTV4PF6LCyyAr98KCQlBSEgIJk2ahMrKSmhoaGDgwIEtFqQA/nnk6enJaP/u3r0rNbRYT08Penp6VEFq5syZ4PF4tKyNlnDkyBEkJCQwGrN161aKjQLw3QC3bNkC4O+C1Lp16zB06FAEBwdj4MCBrQotBvhFsyNHjjAaExoaisjISIwaNYoqSE2fPh0sFguLFy+Gvb292PksS2hxc9TW1qK+vr7FBRbAz3FbuHAhFi5cCE1NTXTv3p36/1qwYIFM5+J/POg4hP+/Hv+zmqwfmqv/pkdDQwbZv9+Z9r2oKDcSGDiTuLn9QpycRpPDh91Jbe1dQghfI9Xc9Y4QUY2U8OPNm5NkxgwVMmdOX7Jx43wxdzxJmqaXL+OIp+dU6nlx8XWyaZMFcXBQJ9OmdSWJiRtox0nSkSUnbyabNlmQ+vr75OjRZcTRUZ3SbknTSDXXkQkeR48uI+vWGRM2eyJxchpN4uL+dgNsydmw+esvXsQSM7MeZPbsvmTLloWktDRFpmPEd1rUp55/+3aFhITMIQ4O6sTEpLsUzRX99924sZ2Ehs4l1dXpJCKCTem30tP3EGPjqSQvL480R11dnUTXvqamJkq/pa2tTfbt20fxylujkVqxYoVEZ0NJeP78OTE3N6eev3//ntjb2xMNDQ1iY2Mj0R2tNdoWIyMjxq59u3btImZmZpR+KyoqqkX9VnFxMdHX12e8f7K6rWVlZRErKyuioaFB+vXrR+ssJw2JiYnE0dGR0Rhp7o8NDQ1k9+7dRFtbm+jr64u4AWppaZGqqipG2/Ly8iJHjx5lNObNmzcirn3Pnz8nCxYsIBoaGsTV1ZV8/fqVdlxrtC1MNFICHDhwgOjq6hJNTU0ydepUcu7cuRbH/Ds0UsJ4+PAhmT17Npk8eTIZPHgwOX/+PKPt3Lx5k9ja2jIaI839UVi/NW3aNHLlyhXqPV1dXfL9+3dG2/L39ycHDx5kNObDhw/ExMSEen7nzh0yY8YMMnnyZOLh4SHRObA116MZM2aQrKwsRmPCw8PJxIkTKTdAWfRbVVVVRFtbm/H+yeral5KSQqZPn040NDTIqFGjZDq3hZGRkUEsLCwYjZHm/lhaWko8PDwo/VZ6ejr1nr6+fouul80RGhpKduzYwWjMly9fiKGhIfVcoN9at24dSUxM/F+h34IETdb/Qbrgj87VfyPu3bsHBYW2+OUXsW4tnJyccPjwYcjLy6OxsRGnTp3CjRs3ICcnh4qKCpw6dUqsgiNLaPHNmzdx+vRp1NXVQU9PDxMnTsSxY8coLrQwpIUWW1lZoW/ffn/RAIeBw+GgW7duSE5Oxh9//EFbOeZwOAgLCxOhjBQVFeHQoUNISUnBpEm/wM2NI1JBjo6OAYsl12JocV1dHeLj45Geno42bdqgoqICp0+fFhsjPbTYEdHR0UhOTsavv/6KhoYGGBoaYuLEiTh8+Ah27NguNoYfWuxC62C4cOFC9O7dG6WlpVBXHw022xU///wzbt68ifv372P9+vViY+hCi/PyvuHQoYOIi7uDyZNNERwcLEIj2bZtGxoaGmi/TxjCdBlFRUUUFxfj2bNnUsc0R2toa9JCi9PS0rBlyxaUlpZCX18ffn5+VO5Ua0OL/wn9UZgu8/PPP2P16tUwMzMTG8M0tBgAMjMz4e3tjcuXLzPavxEjRkBVVVVmugzADy0+fPgwo+yb/fv3yxRaXFJSgtDQUGRkZKBr167Iy8vDkydPZN4O0LrzSFpocUJCAvbu3Yvq6mrMmjULXl5eaNu2LZKTk3Hs2DHGocXa2tqMzyPh0OL8/HwEBQXhyZMn6NWrF7hcLsaNGyc2xtfXF4MGDYKrq6vM23n37h2WLVuGq1evyjyGEIKhQ4eiX79+qK2txYIFC7Bq1aoWuxFmZmbYt28fI53Z4cOH8ebNmxZDiz9//ozAwEC8evUKvXv3xqdPn8B0LtWa80hSaDGPx8OxY8dw9OhRNDU1wdbWFm5ubmCxWK0OLW4t/VEQWpyTk4OAgABkZ2djyJAhCAkJoXWTZBpaDACfPn3CkiVLWnSFFQaPx8PgwYMp+rCTkxOcnZ1bPP4thRbT4fjx43j48GGLGj2BfuvDhw8YMmQIMjMzGZ9HraE/urq6wtzcXIyWy+PxcPv2bSQnJ//H67d+0AV/LK7+q/HHH4+xbJl4cGxhYSEUFRWpH7y8vDzs7OxgZ2cHLpeL0tJSODsvRvfu3eDi4kLRo7Kz39LSq16+fEmFFhsYGMDAwAANDQ04efIkVq1ahT59+iAlJUXEFpkQgqKiIomhxePHj6cWUikpKfD1XY/6+joUFhaK6aAAUBbxzTn5SkpK6Nu3L5YsWYJJkyYhPDwchYWFGDlyJDgcN9y6lYaoqCix72seWtyuXTuKmsblcpGfnw9HR0f06NEDbDYHamr8SUJWVhZ8fcUXgILQYoGN+/Tp01FXV4djx45h6dKl6NOnD27duiVGZ+ELjcUXWDdv3sS4ceOo0MNr167By8sLTU1NKC4upv2bJFnE9+qlgiFDhsDbexQmTJgHHx8fFBYWQktLC4GBgbhw4QJu3rwp9n3NIUyXcXZ2RmNjIzQ1NTFw4EAEBQW1SE958eIFevbs+S+1iJ86dSqmTp0KHo+Ho0ePwtzcHIQQ5Ofn48aNG4y2IwgtZoLmFvHCdJklS5Zgw4YN1LER0GUA5qHFQOst4jU1NREdHY3GxkaEh4fDxMQEbdq0kUiXaWxsRHl5OeNw0VOnTsmkN+nWrRtlRrJ48WLk5+dDU1NTJv0WwP+t0YUWtwRpocVz5szBnDlzUF9fj3379sHAwABt27ZFQUEBYy1WZGSkSLC1LGhuEd+zZ08cOnQIAPD48WMEBQUhLy8PEydORFBQEHr06AGAeWgxwDdS8PHxYTQmLS0NkydPxvHjx1FbW4sdO3ZAT08P7du3x6pVq2itrgUW8UyNPGJjY3HlypUWP9e3b18cPXoUAH+yXlNTAw0NDWhpaSEgIECqfgvga6RaYxEvKbSYxWJR5k2CgpS2tjY6d+6MoqIinDhxgtF2/hUW8QMHDkR8fDwA/v/h8uXLxQpSAPPQYqB1FvEPHjzAL7/8gjNnzlAFKS0tLXTt2hW+vr60v08ej4eCggJGCyyAbxH/66+/tvi5YcOGUYtfBwcHfP/+HZqamjAxMZGpIPVPLOLp7uMsFou6r9XU1ODixYs4c+YMlJWVYWlpyfi6/P8D/wcWWT8WV//tqKqqws2bN9C+vSLs7e3Rrl076r3w8AjY2NjQjvvw4SNlpPC3fqsAyspKEjUlR44cgbu7u8hrCgoKsLe3R2rqDezatRMREZE4diweSkpKcHFxQW7uJ4mi23PnzmHz5i3U82nTpmHatGmorq6GhYUFfHx80LZtOyxcaEl1jJpnbQnj9u3bVEdKMHFNTk6Gh8cafPjwAadOnYK1tQ0UFP7+6QuytuiP0QfK6e7ly5c4dOggiouL0bt3b/z8Mz1fOjIySqya3K5dO7i4uCA9PR1bt25FREQEjh49ip49e4LD4eDjx48SFyanTp3Gxo0bAPAvumZmZjAzM0NlZSUsLS3h4+ODDh06wNbWlroRN8/aEsbNmzcRGRkLBYXxuHTpEuWaZWpqiqamJpHzRxZkZmbi/v37kJOTQ3p6Ojw8PFBUVARdXV0EBATQum61RiN18eJFjB49usXPsVgsuLi4wMXFBWVlZRg5ciQsLS0p/ZYsk96zZ88y1kiFhIRI7CK8fPmSqpInJyfDzc0N379/x7hx41q1SPj06ROmTJnCaMyuXbuoiai8vDyWL1+O5cuXo6ysDKGhoZgyZQq6d+8OPz8/Sn8VHh4OU1NTRtspKytDmzZtWpyQNMerV6/w6NEjsFgsXLlyBU5OTqiqqoKZmRl8fHxotXtcLrfFrmtzXL9+XSaNStu2beHp6QlPT08UFBRAXV0dVlZWUFFRQWBgoJgbIB3i4+MZdYkAvkbKwcGB9r0JEybgt99+A8C/dlpbW6O2tha6urro3Lkz4/Po7du3jBeBW7duxf79+wHw3QD9/Pzg5+eHr1+/gsvlYtOmTejbty+CgoKgrq4OADh69ChjjVRlZSUIIYx1Ka9fv8bz588B8B1eW9JvAfzFppeXF6PtpKeny2RKIlyQ+vDhA3755Rc4Ojpi4MCBtG6AdDhy5AguXrzIaP82b94s8d7fvCAlcHg1Nzdv1SIhMzOTcVFq48aNFOtFuCCVnZ0NLpcLb29vsYLUyZMnoaWlxWg7tbW1aGhoaHGh3RzZ2dlUPppwQWrJkiWws7Oj/a0FBgZi1apVjLbz6NEjmUyS2rdvDysrK1hZWSE/Px+6urqYP38+hg8fjgULFqBTp06Mtvs/hf/iRdaPxdX/Fdy4cRNbtmzBgwcP4O7uDnl5ecyfPx8mJiZ4+/YtAgLoO1I9e/agng8ZMoSiZPAr2m3g7OwMPT092NnZQUFBgbJ1lRRaPGrUSHTr1o3q7rx+/RpRUVH4/fffoa+vj5KSEpELnbTQ4tOnT8Pa2hoODg4oLi5GZGQk4uKOQUlJCZ8/51IVOWHwQ4vbiZlNGBsb49GjR7CxscHnz5/h6uqCdu0UYW1tDQODqcjKeg1fX1+x78vMzIKS0t/BzqNGjcLOnTvB4/EoyqGzszOMjIxgbW1N3ZgE7ofNcePGDQwbNgw9evRAQEAAAOD58xfYt28fnjx5CiMjQ3z//l1kUcLvSNXSimh//fVXLFy4EM7OzsjPz0d4eDiioqKgoqKCjx8/0tqp/x1azAPQAEABLBYLDg4OePDgAeOJkCC0WEBf0NHRwZUrVyi6zKxZs8Dj8UToMgCz0GIB9u7dy4iqBQAxMTFwd3dHQEAARZdZv349Bg8eLJEuU1xc3GJoMR0yMjJo3bhevnwJZWVl6m83NjaGsbExeDweJkyYADk5Oejp6cHJyQlOTk4tTpSTkpJaZREvKbS4S5cuVEEiMzMTwcHB8PT0xPDhw/H8+XPGVW1BaDETNLeInzlzJmbOnInGxkbs378fRkZGVOi5jY0N9TkmocUCbN++nbZqLA3nz5+Hq6srNm7ciGfPnlFugGPHjqXcAJujvLy81RbxsrgDWlhYwMLCAvX19Zg0aRJ4PB4MDQ2xfPlyzJ8/v8XxrbWIlxRa3Lt3b+q4Pnr0COvXr0d+fj4mT56Mhw8fMqKSAcCmTZtEDDlkQfPQYgFrQzieomPHjvDw8BBZFDAJLRbeP6YW8bdu3YKjoyO2b9+O9PR0Kp5CUJCiW1DKElpMB1ks4oULUgLzDh6PRxnTNI9pocO9e/cYd1SkhRarqalRnT5BQaqsrAzTpk3DrVu3GC82BaHFTNC8I9W8IHXw4EGqICW86Hvx4gUjWjrAL84xcQMF+J3I6dOnY/PmzcjMzMTevXtRWVkJPT09GBsbM14k/zvxX6jJ+rG4+r+Gffv2ifCnS0vLEBUVid9//x1lZWXYtWuXWHvdw8MDS5cuFbvJ8ng8ODs7IzY2Fg0NDTh16hRu3rwJBQUFDB48GIQQ2rwSaRbxHA4Hjo6OQvotfdjZLUJ8fDzatGlDW7WVZH9+/34G/P390LdvPwwfPhwcDptauG3atAlTpkyhvTE4OjpSHSmAvxAKDw/H8+fPUVZWhv3794stHj09PamsLfHv4+vSBDTA9PR0tG/fHsOGDUNNTQ3toq0li/iFCxfiwoULaGxsxLRp07Bw4UIcP36c+j9pjsWLFyMiIkLsGN25kw4uNxD9+qlizJjRcHV1pW7emzdvxsSJE/+aUAwE8Pe+SLMHloQFCxbA19cXkyaJawEFqK6uRlhYGFJSUtC5c2doamoiLy+PURbSv9oiXli/ZWBgAD8/P2oyvHLlSmhoaGDRokUyb+fPP//ErFmzcOvWLbHqtqWlJby8vGhdqgTHvLy8HKGhobhz585fhQpfsbweAYyNjREdHc3IIn7fvn0oLi5GUFCQzGPOnj1L6SinT5+OtWvXytSdaq1GatmyZVIXTMXFxQgJCcGDBw+grKwMIyMjPHnyROR33RL+1Rbxv/32G/bt24eamhrMmjULnp6eVLaUj48Phg0bhiVLlsi8nXfv3mHFihWttoj/9u0bgoKC8PTpU/Tu3RtBQUESXURNTU1x8OBBDBo0SObtREVF4d27dzLnhPF4PMTExMDT0xMjR47EggULsHLlSpkmga05jxwcHODo6CjVwfDTp0/gcrnIzMyEqqoqZs6ciatXrzLWSLXmPNLT08OlS5dECmk8Hg+xsbGIiYlBU1MTFi1aBA6HQ/3dAQEB6NmzJ5YvXy7zdv6pRfy7d+/A5XLx9u1bSr8l6TwxNzfH9u3bJTr60iE+Ph5//PGHzLmFPB4Pe/fuRVBQEEaPHo3FixfTxlPQoTUaKRcXF8ydO1eqY25mZiaCgoLw8eNHjBgxAvPmzUNcXBzOnTsn83b+iUX8uXPn0L37347DzfVbc+bMwbhx4/7H9Fv/BzRZPxZX/xeRn59PcfIF6Nq1C3x8fODh4QE3NzfExsYiP78AQ4YMgZsbB927d0dRURFtFVM4tFhAA7S3t0dpaRmsra2hrKwET09PuLi4UFWouro6iR2p+Ph4GBlNE9FvnThxAmw2G+/f52D9evHFCN/aW7wjBQA3b96Av78/DAwMRPRbU6dORVZWFi11KDMzE8rKyiKvKSkpwd/fH56eXnByckJ4eDiKiooxatRIuLqy0bVrl7+ClMUXWMKhxQIaoIuLCwoLC2FnZwclJWX4+PiAzWZTx5jftauTGFqsp6dP0QDr6uoQFxcHFxcXfPjwgTY7ia//obeIT09Ph6+vL4yMjJCUlARPT080NTXB2NgEmZmZQkYi/FBi4O+OFFN8+fJF6gIL4NNlQkNDqfBMDQ0N9OnTBzY2NjLTZehCi1tCUVGRxI5Uc7rMjBkzQAiBvb09MjIysHv3bkbb2rBhA7y8vODu7o6ysjIYGhpi/fr16NixI3Jzc2kXWMKhxZ07d6aoM9nZ2TAwMECfPn0wfPhwhISEUDboTEOLBTh9+jTjCdf9+/exe/du2Nra4tChQzLRZbKysqSGFkvC+/fvW+xIde/eneocvHjxAoaGhujbty9cXFwQEhJCRQ5Iw7/aIn7u3LmYO3cu6uvrsWfPHkq/tXTp0laFFgcEBDC2iBfuSKmoqFAZhY8fPwaXy6X0W8HBwVRHXBBazGSBBfDzk5gsAFksFrKzs7F582Y4Ojpi27Zt0NXVRYcOHbB69WrMmjWLdlxrLeLfvHnTokW8qqoqpfW9d+8e5syZg969e8PDwwOBgYEydYzoQotbgsAivjl9msViwdnZGc7OzlRBSqDf8vHxQXJyMtLT0xltKzAwsFUW8YLrzODBgym2yI0bN6hYiOYFKQG7hckCC+AbmsiikRKAxWLh+/fvCA4OhqOjI6Xf6tatG9avXy/x2vHly5dW0R9l6UiNGDGCMsRKSkqCvb09+vTpg6CgIIrC3xL+iUW88AILENVvVVdX4+LFizh9+jSUlZX/Mhdjds/4V+G/oJP1Y3H1fxnx8fGYMWOG2ORduCMlQFpaGk6dOoVv376hU6dOOHz4sJj+hs1mY8uWrVJDi9+8eYPIyEgUFhZh6FA1dOrUCV27doO9vbg7mrCzoTCKiorg4+MDNbWhyMrKgpKSEthsVwwbNgwbNmyAtrYODAymin1f844UwF/AbN++AykpyVBTU4OVlZVIN0uWjpTgmKWkpOD8+fMoLCxEp06dceSI+L7LElosyPEoLi6Guro6OnbsCEXF9nB2dhLbB2mhxWvWeGDQoIF4//49VFRUwGazMXjwYISFbcYvv0wSMRiRdoxqamqxfft23LzJpyza2dlBW9sQAF8zsWDBAvj5+cmkMxEgISEBV65caXVH6s6dOwgLC0NxcTH09PQk0mUA2UOLhbFy5UpMmTJFoi6hOSorK7FixQpcvHgRv/zyC9atWydR+9ccGhoaVDWSx+MhKioK8fHxKC0tRefOnZGeni42YZQUWix8jJKTk7F9+3Z8//4dxsbG6NSpE2pqahiFFpeWlmLevHlIS0uTeQxA30koKytDSEgI7t27ByUlJfj5+Ylow1oTWpyUlIRTp04x6kg1NjZCW1sbDx48wOXLl7Fnzx5UVlZixowZ8Pb2lnie6Ojo4Pr164z0Yt7e3hgxYoTMFMiCggKsXLkS169fh76+PgICAmT+XbWmm2xqaopDhw5J1QedOXMGhw4dQl1dHebNm4cOHTrg8+fPjGhKFRUVmDFjBmP6KN159PnzZwQFBeHFixfo27cvgoODRdgWrQ0tDg8PZ2QqIehI3bt3D/Hx8Thy5AgaGxthbW1NUe/pIGtosTACAgLQq1cvLF0qblBFh48fP2LVqlW4desWTE1NZS5IAa07j8zNzbFjxw6JekUej4fDhw9TNHRHR0coKCjgzz//ZBRaXFNTA2NjY8YLR7qO1OvXr8HlcpGTkyNWkAL4hkPz589nVKB78OABtm/fjrNnz8o8hsfjUef5oUOHcOrUKcjLy8PV1RW2trYSiwUGBgY4f/48I73Yhg0b0KFDB5mNRgRSgrS0NDg5OWH+/Pn/Fv3Wf2En68fi6v86CCFiOicBrl+/TomOBRBUOVxdXTF58mTqJmJhwQ8FbmhoQGNjI21H6tixY1Ro8dChQ7F9O9+C/ObNmwgODkb//gPQ2NhA6bcAoLCwSMTZUBjh4eFwcHCgJrGvX79GZGQUioqK8PXrF9ob0atXr8Q6UgC/41ZUVIjw8HB07doVkZGRiImJhbKyEjgcjsSOVPPQYhaLBRMTE5iYmIDNZmPs2LFwdXWFoiJfv6Wvry+1IxUff5zSNAnrt65fv47NmzdjwIABaNeuLRYuXEgdk+bOhsKIiIiAvb0dtZAS6LdKS8v+OkbuYmP4zobix6h9e0V8/16GAwcOokuXLggPD0dkZCQaG0ciMDAUX758YbTAAvjdJUEYr6wQDi3W1dWFrq4uRSkyNzdHU1MT7OzsROgyTEKLhfHw4UNGHamOHTuioqICSUlJ6N69OxU8O2TIEISGhkqcxF6+fFnkt8ZiscDhcMDhcGBoaIgRI0ZAS0sLP/30E9avXw8jIyM0NjaiqqqKtrp44MABymxCWL8VHh6O9evXY9SoUVBVVZWZLhMSEiISWiwLJIUWd+nShZpQZWZmgsvlYs2aNZQbYGtCi3ft2sVYIyUQogP8yaG5uTkaGxuxd+9eGBkZQUFBARwOB1ZWVtTfUFZWBhaLxdiQ486dO5QoXxb06NEDcnJySEhIQKdOnRASEoKvX79i3LhxEvVbAL9DTufAKg2CjlRLBgyCwNP6+nrs2LEDfn5+GDt2LBISEsRsoyWheWixLJDUkerbty/VKXjw4AHWrVuHgoICaGpqgsvltjq0mKlGKjo6Gnp6epQu1cHBgdJv6ejooFOnTmL6raqqKplDi4WRkpKCu3fvyvz5/v374+eff8bp06ehqKhI6bf09PTg7+8vcfuyGnIIQ6CRkmYIw2KxwGazwWazUVFRgY0bNyI8PBwTJ05EWlqazAWpLVu2iIQWywJJocXDhg3DqVOnAPBdEdlsNlWQ8vX1bVVo8YYNGxh3oE+ePAlNTU3Iy8tjxYoVWLFiBRVPsX//ftqClKAjxdSQ48qVK4wKHT179sSXL1+wZs0aDBkyBHv27EFVVRX09fUxbdq0f79+iy486//XQ7Yw4h8hwj8e/MeLF7Fk/vz+JCRkDikoSBJ5j82eSMrKUsXG1NbeJc7OY6jnJSUpZPNmS+LgMIrMnduPbN9uQ7utlkKL6+vvk9jYlcTJaTRhsyeS5OTNJDR0Lrl5czvt90kLLbazG0HY7EnEyWk0iYlZQQUBe3jok9evT8j8fa9exRNb22Fk2rSuJCzMgpSUpDQ7RrKFFhcUJJGQkLnEwUGdzJ8/QOIxcnIaLTW0uLb2LomM5BBHR3Xi5vYLuX17F9m0yYKkpGxhdIwyM+OJjc1Q4uIynjg7jyEnTnhR/zeenlPJq1fxMn9fRkYiGTduHFFWVpYantkc9fX1ZMqUKTJ9VhgthRZXVFSQ9evXEw0NDWJiYkKSk5PJ8uXL/3FosaygC6xMTU0l48ePJ0OHDiXr1q0jFRUVIu8bGRmRz58/i41rHsirqalJLC0tiYaGBhk/fjzx8PCg3QdJx0gQWlxaWkq8vLyIpqamWHimpL9JlrBZYSxcuJDcu3dP5s9fuXKFjBkzhigpKREul0uqq6tlGtfQ0NCqYNaWQosLCwvJihUryOTJk4m5uTl5+PAh8fT0JDExMYy28+bNG2JmZsZ4/+j+pvPnzxMDAwMyZcoUEhYWRurq6kTeb01ocXh4OPH19WU05vv370RHR4fk5eURNptNNDQ0yPz588mff/4pdVxrzqNFixaR1NRUmT7b1NRE4uPjyejRo0n37t3Jrl27ZA5hlRY2Kw0thRZ//PiRODo6Eg0NDbJw4UKSlZVF/Pz8WhVabGxszHj/mv9NTU1N5PDhw0RXV5doa2uTQ4cOif2ftCa0OCYmRuL1SBIEocVv374ltra2RENDg9jb27d4DssaWiwMZ2dnkbBpaWhqaiIHDhygzqPo6GiZz1tp4dfS0FJo8atXr4ilpSWZPHkycXJyIrm5uSQkJITs2rWL0Xa+fPlCjIyMGO8f3Xl048YN4uvrS7hcLnny5Anh8XiMv1cYkBBG/L+ok/Wjc/UDorh79y6OHz+OBw8eIDAwEDU1NdDR0YGVlTUaGhporbP5Ham/LXu7du1CGVnY2tri69c8ODo6YujQoeBwOFBSUhLL2hJGeHg4bGxsoKCgQFUCS0pKEBERieTkFJSWlqJnTxWR/CfhrK3mOHLkCAIDA6GmpoaGhgbExx8Hm81G27ZtkZ+fLzFriy5fasSI4ejYsSP27dtHhRrX19fBwMAAlpaWaGigryI1t4hXVlamHBptbGyQm5sLR0dHjBo1itJvtdSRWrjQEu3atYOrqytcXV2Rn5+PyMhIpKSkoqysFAMGDBBx7BJkbdHh8OHDCAgIxIgRw1FTU4u4uFi4uLigQ4cOyM/Pl5i1NWyY+LHT0OA7QiYmJuL69euYPXs2mpqaYGNjAzc3N4lVrj179kjUU0iCLB2pjh07YuPGjdi4cSM+fPiAwMBAJCQkoKioCBMmTJCZLsPlchEYGMho/y5duiTW/QUAQ0NDdOvWDRcvXkRiYiJV1Rbk4FRVVaFPnz5i4zZu3IjOnTujvr4ejY2NaNOmDc6cOQMAGDVaHc+fP4empiZFKevYsSNKSkogLy9Pe4xCQ0Ph6uqKLl26UPotQXimra0tDAwMEBISIuL0Jakj1RI+fvzIyCJ+xowZ2L17NxISEpCQkEBVSJu7ATaHcEdKVshiEa+kpIS9e/cC4OsrgoKCkJKSAgsLCxgbG8uk3wL42hamFvHJycm0HYH58+dj/vz5qK+vx+7duzF16lS0a9cOy5Ytw/z58/H9+3fGHYj4+HgkJSUxGiOwiFdRUUFERAQA4Pfff0dgYCDy8vIwefJkcLlckevPu3fv0LVrV8bnUXZ2tswW8SwWC4sW8Q2RTp48ifPnz0NXVxc//fQT1qxZI5XyFR0d/W+xiFdVVUVMTAwAUPEU6enpWLx4McrKymR2/AsMDIS3tzej/UtPT8eAAQNEXmOxWFSGY2VlJcLCwqClpUXFUxgYGKC4uFimiAJhHD16FAkJCYzGbN26FVZWVhg8eDDFaEhNTaXVpQrw6dMn2o5US3j16hVmzJgh02dZLBaWLl2KpKQkREZG4uzZs9DS0kL37t2xfv16qZ12QUeKCWSxiB8xYgR17U9MTISzszMePnyIVatWoba2VmaWBpfLxcqVKxntH51FPIvFonTy1dXVSEhIwMmTJ9GzZ09YWVnR3s9aDbqVF9MHgC4AzgHIApAJYAr4ivJkANl//du1pe+h72T96Fz9eIg/GhoyyP79zmKvHTu2mpiaKhNz817k2rVNpKnpochnJHWkCgqSiJvbL9TzGze2EQ5nEnF0VCc2NkNJcvJm2v2Q1G158SKWeHsbkqys48TDYypxcBhFNm6cTwoLr5I1a/TImzcnxcbweI8kft/58+vJ/PkDiIODOvH0nEqyso5T77HZE8W6VISId6QErx09uoyYmfUgs2b1pu20OTqq03akioquETZ7EiHkd9LU9JBcu7aJsNkTibPzGOLgoE6uXw9jdIwEx+bZsxiyapUOcXAYRbZutSZlZanEw2MqycyUvSMlOEZz5vQlDg7qxMdnGnn//qzQMZpECguv0hyjx2IdqaqqKhIQEECGDBlCdHR0yNWrV0lzTJkyRawS3xJa25GaPXs2SUtLI2ZmZkRDQ4N4e3tLrT4TQlpVjTQ0NCRfvnwRe715R4oQfjfAx8eH9OvXjwwcOJDcvHlTbNyUKVNISEgImTJlCunfvz9ZvHgxIYSQd3mfieZcM1JaW0WamprIkCFDiLa2NtHV1SUGBgYkLi6Odv8kdRJevnxJZs6cSa5evUpMTEyIpqYmCQgIIFVVVcTS0pJRR4oQQhITE4mTkxOjMXQdqeLiYrJq1SqioaFBzM3NSUZGhtg4bW1tqR0pOnh4eDDuSGVlZZEZM2aQhIQEYmhoSDQ1NcmGDRukdlUJoe9ItQQTExPy4cMHmT6bn59P3NzciKqqKhk0aBB5/PixzNsRdKSYQlpHisfjkVOnTpGpU6eSKVOmkO3bt5OGhgZia2tLbty4wWg7qampxNbWltEYuo5Ubm4ucXZ2JhoaGsTCwoK8ePFCbFxLHSk6rF+/vlUdKRMTExITE0N0dXWJlpYW2bdvH2lsbJQ6rjXXIyYdqffv3xM7OzsycOBAoqamRt6+fSvzdgQdKaaQ1pFqamoi4eHhREdHh+jo6JDDhw+TpqYm4uTkRBITExlt5969e8TS0pLRGLqOVFZWFrGysiIaGhrEwcGBfPz4UWxcSx0pOgQHB7eqI2VoaEh27dpFtLS0iJ6eHomPj2+x49aa69Hs2bPJ8+fPZfpsXl4e2bNnD3F2diZ79uwh5eXlMm8HEjpZzMoykrEHwFVCyHAAY/9aaK0DkEoIUQOQ+tdzBqgH8AnACwCF+NG9+gFhPHz4EJMni7rSyMvLw87ODj179kR0dDSePn0KZ+fF8PDwwKtXr1roSEXA2tqaem5gYEDlLn3//h3Hjx8Hh8MRyTppnrUljCNHjsDVlW82sWPHdsTGxkJDQwN+fv74448/kJ5+Fw0NDSJjBFlbdLh69SoOHz6M2NgYLFnigsjIKDg6OmLTpk2oqamR6GzY3M5dQUEBzs7O6NmzJyIiIpGeng5HRyd4e3sjOzsbRUV8HZm0jhTwt34rIiIChw4dQmFhAU6cOAF3d3fcvn2bGsPP2qLvSEVGRoHNdsXo0erYvXs3oqOjoa4+Ct7e3vj999/x5MkTNDY2iowRdjZsjmvXruPIkSOIjY3BokW22L17DxwdnbBjxw7U1tbQ7sfJkzGYM0e0QigIz1RWVkZ0dDROnDgBDQ0N2NjY4PXr11QemcCqWlY8evSIcV6JILRYX18fiYmJuHfvHoYNG4aZM2dCR0cHERER4PF4ImMuXrwo0bZaEgSufXQdjv3794tV0QXhmX379sWlS5cQFRWFYcOGwdraGjk5OX91NtsiICAA9+7d42sJ5dtggslUGM6fBU0tLXyt+o6PuZ8wYMAApKen4/Lly8jKysKBAwfEDAaaZ20Jg8vlws/PD9OnT8e1a9dw9+5dqKiowMTEBMnJyXjz5o3YMZKGnTt3IjQ0lMHRAw4dOoTp06eLvNatWzfs3r0bGRkZ2Lx5M7Zv3w5NTU0sXrwYnz9/brVG6u7du4y1QUFBQfD19cXs2bORmpqK27dvQ1FREUZGRpg6dSpVZRaGpI6UNPB4PHz//l1EfC8NPXr0wKFDh6Cqqoq4uDiEhIRAU1MT7u7uKCgokDp2w4YNVF6frHj79q3UjpScnBysrKxw8+ZN3LhxA7W1tdDT00NiYiIqKioYbWvr1q0ICQlhNObo0aNi2p6+ffvi6NGjyMjIgJeXF9atWwcNDQ2sWbMGJSUlrQ4tvnHjBjgcDqMxgtBiR0dHyi47Pz8f2tramD59Om0WWHp6OmMXRx6Px6gjNXDgQBw7dgx9+/bFrl27sGLFCmhqamLt2rUoLy+XOnbz5s0i935Z8OnTJ3Tq1EliR0qgS71z5w6uXLmCN2/eQFtbGwkJCfjpp58YbWvjxo0IDg5mNObkyZNinXiBfisjIwM2NjZwcXGBpqYmAgMDUV1d3erQ4qSkJEb2+gD/PFqzZg1Wr16Nu3fv4sKFC3j48CG0tLQwa9YsWkv3R48eoV+/foy2w+Px8O3bN1qGBh1UVFSwcuVK5OTkYMKECdi9ezd8fX1x7do1NDU1Mdq2AP+YLignJ9cZgB4AJwAghNQDqJeTk5sDYOpfH4sFkAZAPGBIDD9ogT/QMv744zGWLRM3hygsLET79u2hpKQEHx8fAPwba2RkJJ48eYLBgwejqKhIbMItKbT4zZs3GDlyJLZt20bRAOPj46GkpISysjLaPCjBDUJNTdQi3sjICDweDwIHTVdXV7Rr1w4LFy6EkZERzp8/j82bxQXm9fX1aGhooBZSI0YMx44dfOMNX19flJWVwdnZGQYGBhR1EeC7TdE53wkWCb16qcDfn/83v3z5EocOHcLz588xdOhQlJaWiS3cXr9+Q0sdev8+ByNHjsT27dtRWFiI8PAIHD16FD169EBpaSm8vLzExgj2Q/gmymKxYGZmBgUFBdy/fx+VlZUUDdDW1hY6Ojo4c+YswsI2iX2XwJBDYOs6ZswY7NmzGzweD+vXr0dxcTEWL14MExMTWFhYUDfHmzdvIiJC3Nq7sLAQ7dq1w5AhQyjXNwFd5o8//sCECRMY0WUEFvFM6UbNQ4ub02U2bdpE0WV8fHxgaGiIPXv20AYxS8Pu3btRWFgIXV1d2Nvbw8XFhdrXs2fPIjU1VWyMgP44atQoHD9+HFOmTMHixYvh7u6OP//8ExMnTkRlZSWKi4vRsXcPrN7IBQGBtbU1HjzIwIULv0K+vgkbvfnnVG5uLiZOnIhLly4hOzsburq6GDBgAIYNG4b8/HyJE43c3FyRCYWALjNgwAAcP34cz549k5ku8++yiB81ahTl1nXlyhU4Ozvj5cuXmDRpEiO6TGst4puHFisoKMDT0xOenp4oKipCUFAQdu7cCRUV/jVh0qRJ2L59OyPnTIBfiGFq2FBeXg45OTloa2tT/zfnz5+HjY0NampqMGfOHKxZs0asqNEai3gul0ubc0gHRUVF+Pn5QVNTE/v27cPly5exadMm9O3bF0FBQVInbgJDDrrQYmmIjY2VahGvoaGBS5cugcfj4cSJE5g/fz7evn0LTU1NNDY2ykxDax5aLCuahxY3j6fgcrkICAjAwIEDKTfA1oQWt9YivqmpiQryFsRTmJubgxACOzs7uLq6iv3NsoQWNwcTi3hBQeru3bsIDQ1FeHg4fHx8MHToUAQHB0ulyEoLLZaGqKgoqRbxpqamMDU1RWNjI0VZzs3NhZaWFng8nsznxefPn/8lFvHdunWjzpGXL1+Cy+UiNzcXo0ePpuIpNmzYgE2bxO/90nD27FlMnjyZ0Zja2lrU1dVBR0cHOjo6aGpqwq1btxAQEIC2bdti3rx5GDt2rMzf96/QZA0Cv9UULScnNxbAHwBWAehJCMkDAEJInpycHH3JXwQN4HeufiyufkAyqqqq0L69Iu2FIDw8HLa2tiKvDRkyBFu3boWjoyOsra0REBCAmpoa6Onpwd7eHm/evIGKSk/abUVFRVFVGn5IKr8hm5WVhaVLlyI0dAOGDRsKNptNLdyEs7aa49y5c1RosbOzE4qKihAVFYWYmBh8/foVBQX5Yosbuo6UAN++fcOvv/4KHo+H+Pj4vxZuipgxw0yiRioyMlLM3UjgBujo6Ig5c+Zg3bq1qK+vh6GhEWxsrJGd/RbKypI1Umy2KwBR/dbLly+xfPlybNq0Cerqo8Fmu1I6OWkdqbNnzyIsLAzdunWj9FsCN8AvX76grKxMrNomyNpqDhaLhfz8/L9CjptE9Ftz5sxB27bt0LZtndi4oKAguLuLuhfq6OjgypUr0NDQgJWVFWbPng0ejwdbW1u4ublJvTEFBwdTC1pZkZCQILUj1bFjR+qmk5OTg8DAQPj6+uL9+/eoqalhtK0LFy7g1atXaGhooDJYunbtCjc3N4k6MoEj2oULFzBhwgR06tSJcqfU1NSEubk5ps8yx9uiPBibmaKJ8PAhJwfFJSUoL6/AsmVLcfjwYWzZuR1cLhdt2rShJvWFhYXQ19enFi9WVlZYtWoV5Zol6P5cuXKFytpqjl27domEFmdlZSEoKAienp6U3bGwfgsADh48KNaRagmyaKSEIZgEamhowMDAgHIDdHV1larfAvjnJVON1LVr16Tm+CgpKWH//v0A+MWA4OBg5Obm4uPHj2IRFy3h+PHjuHr1KqMxdB2pBQsWYMGCBaivr8fOnTsxdepUKCoqYtmyZViwYAGys7NbpZF69+6dzC5wAmzduhXh4eHUZPjRo0fw8/PDt2/faPVbAP+aKOmaLQmVlZUAIJO9NIvFgp2dHezs7KChoQF1dXXo6enhp59+EnMDpAOXy2Wskbp9+7bUBUH//v1F9FurV69GUVERPn36JJZl2RKio6Nx+fJlRmPCwsJEAtRZLBaV4VhZWUld137++WesXbsWhoaG+PjxIzp37sx4kZCVlcX4OhEWFoY9e/ZQhcWUlBRKv2VkZARfX1+xLLrjx49DS0uL0XaYdKTk5eWxfPlyLF++HJMnT4aKigpVkPL3929RlxoYGIjVq1cz2r+WOlKjRo2iAo0vX74MBwcHVFZW4suXL4yLFuHh4Yys6AFgx44dWLBgAfW8TZs2MDQ0hKGhIaqrq/Hbb79R+q2FCxe2qN/6xzlZcnJykwBkANAmhDyQk5PbA6AcwApCSBehz5USQrrSjGcDYAOAqmrviR8/XvxH+/MD//04c+YMEhIuokcPZbi4uIgsaIRzn4Tx4sULxMXFYevWrQD4nY9Tp07j5s0b+PjxIxwcHMRu9HRZWwJcv34dT58+hY+PD1JTU3HmzFnU19dBT08f9+7dxdat26RmbTWHIFMqPz//r3DDEeBw2OjWrRucnJwQFRUltmAqKipCQEAADh06JPa6qyt/0TN48GBwOBwRwwRJxygzMxNHjhyh7Onr6uoQHx+PO3fuIDf3M5ydnWBnJ54FJun7UlJS8OjRI6xduxbXr1/Hr7/+isbGRhgZGeHWrVvYvHmz1Kyt5oiNjcXnz59RWFiI0tJSjBkzBi4uLvj555+lZm35+q5HRES4yOt5ed/g7u4GABgyZBRcXfeIdNWEc5+E8ezZMwQGBuK3334DACo8MyUlBZ07d4aXlxdt2GtrcluMjIxw/PhxRiHJO3bswLNnz1BQUICysjLo6+vDz89P6sStqKgIFhYWYjlS7969oyYSmpqaYjbumpqauHDhAoKDg3H+/HkMHjwYkZGRYLFY8PVbj4PxMSitq4aDgwNUVVXx+PFjNDQ2gu3KxtmzZ9C+fXvk5n5Gx3aKOBy2A05OTlBVVUX79u1RWlqKEydOYPjw4UhMTMT58+cRFRVF5QAJAkzj4+MRGxsrNWuLDklJSdi1axfKy8thYmKCdevWoUOHDtDW1kZycjIjCp+HhwfGjRsHBwcHmcdkZmbC29ubmkiWlJQgODgYDx48QI8ePRAQECDSwRQ+5kzPo+nTpyMyMlJmCh/AX2ympKTg+/fvqKmpwaxZs+Dp6SmVIvv9+3fMmjVLhC4sC+hypOjw7ds3BAcH4/Hjx8jNzWVszZ+amoqYmBhGXV4ej4cpU6bQXgt4PB7OnDmDiIgI1NfXY8GCBVi5ciXk5eWhq6uLpKQk2gBnSfD19cXAgQPBZrNlHpOTkwN3d3dqYZubmwsul4tXr15BVVUVwcHBtF2Q1pxHM2bMwJ49e2Q23wH497VTp06hrq5O5oJUVVUVpk+f3qocqbt377Z4Hr1//x6BgYF4+/Yt8vLyEBQUBGdnZ5m3c/fuXezbt4+yTpcFgjwyumPO4/EQERGBEydOQE5ODo6OjnB2dgaLxYK+vj4uXLjAiMIXHByMLl26YNWqVTKP+fz5M5ycnJCSkgKAf30KDg7Ghw8fMGLECISGhtJ291tzHs2aNQubN2+WWIimw/Hjx3Hw4EEA/IUhh8OBtbW11P/r2tpaGBkZMYoNAOjzyOiQl5eHM2fO4OvXr5gwYQKsra3/bTlZnwF8JoQIrkLnwNdf5cvJyfX6q4vVCwAtwZoQEgkgEgAmTRr9o4X1Ay0iPz8fx4/HUzTA/PwCDBkyBFOnTpWqkRLmDSsoKMDe3g6LFtnC3t4BeXl5cHR0gpJSd7i4uGLEiOG0WVsCnDt3Dlu28BdsRkZGMDIyQkNDA2JjY/HmTTbWrVuHhQstRagz8fHxVNZWc9y5c0cktDglJQW+vutRU1ONsrIy2jHh4eG0eRtKSkro3LkzYmNj8erVK4SHh6OwsBCjRo2CgYGB1I6UMEe/Xbt2FDVt0aJF+PDhAxwdndCzZw+w2WwMGTJELGtLGIKOFIvFougJdXV1OHo0Gq9fv4Gfnx9sbW1FaCHx8cclVprT0tKohRSPx8PVq1fh7e2Nuro6lJV9h5ycnNiYiIhIWFpaiL3eq5cKfv65C2JjY/5aLK/Bt2/F0NHRwdy5c9GrVy/afQgKChJx7ZOFLtNSR4oOjY2NqK6uZrTAAvg0qxs3bkBRUZGiy8yYMQNNTU1YsGAB1qxZI3ZjCg4OptVmDB48GEpKSrh37x5u3rwJd3d3lJaWwsjICHPnzoWysjJ69eqF8PBwPHnyBPv370dgYCDSHz/ChKk6ePftC3I/fUJ+fj6+fPmCRYsWISUlBcnJ1ykXwc2bw7Bhw0Ys9/WGrq4uTp48iS9fvmD8+PFwdHREnz598OXLF/z6668UDXDp0qVUKPDvv/8ODocDX19fETqccNYWHczMzGBmZobGxkYcOnSIWhgLNIlMcPfuXaowISu4XK4I1ZiOLvP582eoq6tTdJmkpCSpHSk6NDY2MtJICXDixAkqtLi+vh579uyBgYEB2rZti6VLl9JqCzds2MBosgrw3fe6desmU0dKRUWFKiiNHj0aV65cQVRUFCZOnIigoKAWuyXbtm0TK0i1hKioKInugCwWC9bW1rC2tkZtLT/sXFdXF+3atUNJSQmjBRbApy5v3LiR0ZiAgACKFg8A/fr1w9GjRwEA9+/fh7e3NwoLC6GlpQUul4suXbrg9u3brdJIlZSUMFpgAfzCmCC0WFCQEnSTvL29acPkm3ekZIGgIyXLeTRo0CDEx8cDAEaOHInTp08jPDwchoaG8PPza/H/LSwsDDt27GC0f/Hx8RI7UiwWC+7u7nB3d0d5eTlCQ0OpYyQpB1QakpKSGC9QAwMDRcJ9R4wYQS0ik5KSsHjxYlRUVGD69Onw8fFBhw4d8ODBg1ZppAoKChgtsAD+3OTSpUvo1q0bioqKEBISgr1790JZWRmBgYG0Bant27eLdKRkwdevX9GhQweZOpu9evWiFrJr1qyR+Ll/vMgihHyTk5PLlZOTG0YIeQ3ACMCrvx6OADb/9S8zf8wf+AEafPv2jQrkFdAAAeDWrVsICuJCWVkZhw8fhr29PUV1Edwg6FrN169fx7hxYynqRHZ2NiIjI1FQUIi8vK+Uxa8w6urqaEOLBV0UV1cXzJgxAxERkTh27Bi6d1cCm+2K27fv4MiRw2LfJ5jYCf+wp02bhmnTpiEkJAT19fV/2bi3g7W1FUVDyc5+S0tBEw4tHjlyJHbs2AEej4eUlBSsW7cOyso9cOxYPGxsrEW2WVRUTGsRn5KSAnX10RRV8uXLlzhw4ADVeQsPFz9GfI2UuEV8u3btoKioiMWLnWFqaorIyEgcPnwYKioqYLPZuH37Fq0OpLlFPIvFwowZMzBjxgxs2LABFRUVFA1w0aJFlLYjKyuT2m9hCFvEjxs3DgkJ88DjdUF8fDzmzp2Lvn37Yv/+/WI27oKqFR2a02UE4ZmfP3/GjRs3aMdIgnBosaxobhEvTJdxd3fHnTt3cPbsWXTpwo8tEJxHDx8+pNVMvHjxgjKbEBQSeDweoqKiYGZmhr59++LIkSMYOnQoBg4cCPVxY7EzNgrzbawxcPAg2C1ahNraOpibm+OPP37H06dPUVhYiIKCAqz388OB/fsRHR0NHq8JVXIEflz+4jU1NRV2dnbYuXMnMjIy4ODgIEbJ6NKlC1RVVeHh4QFra2sEBQXBy8sLw4YNQ0hICM6cOUOrI2sO4fDMZcuW4e3bt4zoMv/EIl6SNqw5XcbR0RGVlZX49u0brbGANLTWIl7YkKNt27bw9vaGt7c3CgoKEBQUhB07dkBFRQWBgYHU74FpaDHAn9ytW8fMEyslJQXjx49HXFwcAH4xx8rKCnV1dZg3bx5WrVol1nGTNbS4OWS1iFdUVIS/vz/8/f2xfPlyPH78GJqamujbty+Cg4NbnFRKCi1uCW/fvpW4CJwyZQouX75M6bfmzJmDxsZGFBYW4uJFZowhQWgxE1RWVoqEFjcvSAUGBsLf31+kIAXw/3/v3bvHaFsCQw4mSE9Px9ixY3Hy5EnweDwcPnwYpqamkJOTE9OlCsDj8cS0xLLgyJEjMlnEd+7cmYqnWLlyJfLz86GpqUld11oqlrTWIv7ly5fU4rw5mhekTExM0KZNG4ptwASttYgXnkvQxVM0L0gBzEOLgdZZxH/58kXqdeUf0wUBQE5ObhyAwwDaAngPwBkAC8AZAKrg2wRaEkJKpH3PpEmjye+/x/zj/fmB/14cOxaPmTNniE3eBdQ+AT3hxo0bUFBQwIIFC9DU1IQXL17C21v8IszhcLB161axTK26ujrY2NigR48eqKurg56eHuzs7KCgoIDDhw9DUVGRljrn5OQk0pEC+BP6vXv34eXLF5g+fTo4HI7I/m/YsAE6Ojq0HRxHR0eKrlhUVITIyEi8fv0GiortwGKxaCuznp6ecHNzo606Ojo6ITIygqIBKioqwtqanysmyNKiO0YCjZQw6uvrsXDhQvTo0QMNDQ0wMjKCtTV/4RYdHQ0Wi0Xr/kVH7Xv+/AUOHNiPzMwsmJubi+i3AH71cPLkybSiemG6Yl7eN0REhCMn5wM6dvwJTU1NCA8PFxvj5eWFJUtchDK1lADwb2AaGhq4efMmNm/ejOTkZHTq1Amenp6orq7GtWvXaL9PEurq6jBy5Ej07dsXTU1NWLRoETgcTouTKS0tLaojJStWrFjxV06ceHdTmJL17t07BAYG4t27d1BWVkZNTQ1FExGGpaUlfHx8aKuEGhoaSE5OxsaNGxEVFQW1iWOx1McDFZWV2LZ1KyqrqqCvp4e3b9+iX79+ePz4MeobGrByxUqcPn0Kbdq0wciRI+Hn54eGhkbMnz8PKl27o11lPb59+4aMjAzKna+8vJw280tbWxupqakix+jatWvYtGkTKioq8PjxY5mPXfNjlJmZCS6Xi48fP2LkyJES6TILFy7E6tWrGekmkpKScObMGVpKrCTU1dVBTU0N/fr1g4KCAjgcDqysrFo8j3R0dKiOlKzw8vLC6NGjW3Tue/r0KUJCQvD161cMHDgQhYWFtOeRNLSGbmRqaorw8HCxDKX6+nrs2LEDly5dQvv27bF8+XLMmzcPAH+xmZuby6hTVF5eDnNz839Ef3z06BE2bNiAb9++QUNDA0FBQbSdCTs7OyxZsoSRjistLQ1RUVFURpMsqKqqwtChQ6GqqoqOHTvC09NTasdXAF1dXVy5coWRg6Gfnx/69u0rpm1tjtu3b2PLli0oLi7GuHHjkJ2dLVOBRBitOY9mzpyJnTt3ii2YysvLsXHjRty6dQtdu3bF2rVrqXtzbGwsnj17xqiTVV1dDWNj439EW0tOTsb27dvx/ft3MV2qMJydnWFpaSlzphbA73ju3LmTkXappKQEI0eOxIABA6CkpAQ/Pz+ZcgWnTp2KX3/9lVF3LjQ0FJ06dWpR+3Xx4kXs3bsXVVVV0NPTw6NHjxgXN1tzHu3atQs2Njbo1avXv40uCELIUwBiXw5+V+sHfuBfAkIISkvp2+fXrl2Duvpoysbdzs4OpaVliIqKxJUriVBXV8erV69ERPJ1dXUSQ4vj4uKwYMECLFq0CA0NDTh58iQ4HA4UFBTw7Vs+zp8/JzZG4GzYvIo0bNgwqKioYOFCSzQ2NmL9+vWoq6vD1KlTYWtrK7EjxQ8t/psCo6SkRIne2Ww2eDwCR0dHjBgxAhyOG7p27QJCCIqKimkXWILQYmEaYGFhISIiIpCSkoIxY8bg7du3GDLkb1fEhoYG1NXV0R7z48ePY/78+XBwcEBdXR3i4uLg4uICRUVFFBQU4PTp02JjJIUWjx6tjv79+8PS0hL19fXw8vJCU1MTjI2NYWlpiays17ROjs1Di3v1UkFQUBAAvnsjIQSOjk4YO3YMXF1dKW1SUVFRs9Bivj3z+fPnMX78eMrGPSQkBJ8+fUJgYCASExPx7NkzsX2Qhr1798LFxQW+vr5idBkfHx/aRaMsocV0ePTokcSOVM+ePakJuXB4pp6eHhobG6GpqSkWnpmbm0u7wBJYxHfu3Bl+IUFI/vMhAsI2ISI8HPfu38fECROQl5cHFouF4uJifPnyBfb29khNTcXz58/Q2NiIgoJCiuZ09uxZzJ49B17LV6BTIwsB/v6YMYNfSPn06RPlximMkpISKCgoiB2j6dOn4+rVq5g0ie52JBnNO1LNwzMXL16M8vJymJqaUnQZgN+RYipM37lzp8SqsSRERkbC2dkZwcHBFF1mz549UvVbTA05BEhPT6cYAtIwbtw4ysFMW1sbdXV10NLSwuzZs+Hh4dFixEFrLeLLysrEFlgAv+Pm6+sLX19ffPv2DUFBQdiyZQv69OmDd+/eMaZQCUKLmaB5aPEvv/yChIQE8Hg8nD59mgpjtrS0xIoVK6h7xdu3bxkbZWzZsoUyLJEVJ0+ehJ2dHbZs2YJPnz6By+UiKCgIAwYMQHBwMO3/R2st4lNTU2XqSOnp6UFPT4/SLVVXV0NHRwf29va0boDNkZ6ezrhDKc0iXuAGCIAqSK1btw5DhgxBVlYW40LCli1bWmURL9yRMjY2hrGxMXg8HtWdFuhSHR0dqWPEJLRYgI0bN8r0exdGYmIirK2tsXv3bqogtWbNGqn6rX9iES9LoWP27NmYPXs2GhsbMWXKFFRVVcHAwABubm6wtLRs8TyiCy1uCYQQfPv2TSqt/1/SyfpX4Ucn6wek4fnzF/j8OZfWOYnNZmPbtm20HSl3d3f4+q5HVBRfv6WmNgRubm64cOE3/PRTBzE3QoC+IwXw6YTLl6+AiooKlJSU4OLydzckNHQD9PR0oa8v7nLX3ByioaEB8fHHcfVqEoqKirF+va/YhNvDwwPu7kvFrOCbG3IkJyfj3LnzqK+vQ+/evdGxYydaihyHw6GcDYUhMJvw8vKiDDhGjRoFNpuNCxcuMOpIAXznpZUrV6JXr97o2bMHOBwORdUMCwuDhoYGLcWl+TGqra1FXFwcUlNTUVRUhODgYBHdDQB4enqBzXalvVkKvo/H4yExMREJCQloamqCqqoq2rZtS+PSNgaGhtNx4sQJsYtmfX09pk6dypjGoqWlhbS0NLEJp4Au8/r1awwaNAjBwcHUwnjZsmXQ09Oj7UhJwpMnT2BmZoYTJ06IHVsLCwusXbtWYkfqwYMHFF1GYAowZswY1NXVidjsCjBlyhTUNTRgpo0FFH7uiJycHKxZswaNjY1wdHTE+PHjcfv2bZSXl2PWrFn4888/0bFjJ6ipDcGaNWtQW1sLJycn9O7dB8XFRSguKMQfqbeh3LmLyHYePnyImTNnYvDgwWJ0mVWrVmHy5Mm02g1ZjRSEsXDhQqxZs0ZqNbaxsREHDhzAmTNn0KZNG0yaNAklJSUURVQWtGTIIQmSDDmE6TKjR49GcHAwRZfx9PTEmDFjGGVJvX79Gh4eHrhy5Qqj/RNUgOvr67F792789ttvUFRUxNKlS2FhIa6JBFpnyHHo0CF8/vyZUUcqLS0NCxYsgJqaGiZNmoSgoCCJ2X3N/yam59GiRYvg6uoq1cGwtrYWW7duRVJSEn766SdMnToVWVlZlE5IFkgzUpAGPT09SiMljLt37yIsLAyFhYXQ1tZGYGAgFU+xfv16qKqqws3NTebt5OTkwM3NDdeuXWO0f4LrUWVlJcLCwnDjxg1KvyUpGqA1hhyxsbF48eIFRc2TBYmJibCzs8PQoUNhYGAgk34L4J9H6enpjCh8zs7OWLhwoVSXyLKyMmzYsAF37txB9+7dMWPGDNy+fZs2804SpBm7SIMkQ47ExETs2rULFRUVMDMzw9q1a6lCWEhICDp37szIjfDr169wcHBodYdcMG949OgRevbsiYCAAIkFuNmzZ//lhCxbphbA7+ZnZmbCxsYGcnJy/75O1g/8wP8Erl27ilevXuHChQuYP38+Vc0RaKQkdaSmTZsGNbW/9VtpaWnw9/dHZmYm7Ozs0NDQILJQkNSRAoBTp05j/Xpf6Ovr4/Xr14iKikJhYRGGDRuKrKxM2qwtutBifiiwE54/fwZvb28kJycjLu4YlJWV4OrqCjU1NdqsLUDcIl5Q5WpoaMD8+fPRrVs3uLm5wdramrrZ19fXo76+XmposcDGXaDfWrt2HbKysrB4sbNYBosga4vOIv7XX3+Fr68vDAwM8Pz5C+zbtw+lpaVQVx+Nly9f0nak6EKLFRUVwWaz8fr1G6xcuRLJycmIioqCikovcDhsDBo0SCI/XtginsViwdzcHObm5qipqYWFhQW6deuKpUuXwt7enppY19cXo7a2lrYqtWfPHsyaNUvsdWmQFlrcv39/apF8+/ZtrF69GsXFxdDT00NGRgbjCvWGDRtw6NAhHD16FOvXr8fgwYMREhKCwYMHi2VtCSBsyMFiscBms8Fms1FRUYFRo0ahR48e1I1ScB41NjaiqZ08on87jZi4OMTu3o3BgwcjMSkJJcXFaGxsxOXLl6Grq4vPnz+jb9++ePr0KV69eolp04zAIwQxMTGYP38+rBZaQa66Dq7WdmILLIDfKd29ezcWLVqEa9eugc1mU3SZe/fuYdeuXWJjpIUWS8PHjx9bpLvIy8tj1apVlNZu7Nix6NGjB8zNzWWmy9CFFrcEaR0pdXV1Sr918eJF2Nvbo7q6GjNnzsSdO3cYTSKBv0OLmeD69evUb7Bt27bw8fGBj48Ppd/avn07evXqBS6Xi3HjxgFgHlosQGss4hMTE7Flyxa4uLjgzJkzsLS0RF1dHRYsWIBVq1bRXuf/nRbxioqKCAwMRGBgID5//gwNDQ306NEDFhYWMum3APrQ4pYgrSOlra1N6beOHTuGOXPmoKmpCdbW1khJSWG8mONyuSKGHLJA2JCjY8eO1EL6w4cPCAwMhJ+fHwYNGoTQ0FCqaNdaQ44jR44wtojPyMhASEgIli5dSulSAT6lf/HixbTnSmst4l+9etWiDX+XLl0ow53Xr19DX18fPXv2hKOjI0JDQ8XiKehw4sSJVlnENzY20nakBDppQUHKyMgI8vLycHV1RVJSUqvyyFpjES/oSCkpKWHfvn0ARAtSY8aMQUhICHWvZxpaLEBCQkKLUQg/Flk/8L8CjY2NaN++PY4ePUrRAE+ePIlu3bqhW7dutC5FAL9C17waP3XqVIwaNQr+/gFQVGz/l6lEW1hYWMDY2Jg2a0uAt2+zqYXUsGHDqItcdHQ0bty4AWdnZ+jp6cPObhG1ABHO2hKGgLIwadIkqrqSmZmFyMgovHv3FvLy8rTuQpJCi3k8HpSUlBAdHY2ioiJEREQgOjoGPXooo1u37hLpKM1Di1ksFkxMTDBhwgT4+vqioaEBLi4uaN++PaytraGvr0+btSWAcGjx6NHq2L2bHwp85MgR5OV9w+LFizFt2jQsXLiQuvkIZ201R1FRkUhQ6bNnz7Bnz158+vQR8vLyKC8vF5s4nDlzBmFhYWLfJS/fBj16KCM6Ohp5ed8QHh6O8PBw9O7dGx06qGL27Nm0+/Dbb7/h5s2btO9JApfLbVGPAIjSZYKCgvDx40fo6urCzs4ObDZbpone58+fMW/ePEqDkpaWhuXLlyMnJwfy8vKoqKgQs3Hfu3cvrZ11+/bt0adPH9y/fx/v3r2Dnp4e+vXrh4FDh6DbgL6YYjYNcm34zmqXLl3EuHHjce7sWbx//x5jx46FgoICmpp40NPTh5WVFaZPnw4PD0/k5uZisbMzcnNzsXf7Tgzpooy1IV5YQfPbAIAHDx5QC6np06dj+vTplMZO0FlcsmQJ7O3tqWMUFBTEOI8sMTGRsdtV586d0adPH2RkZODVq1cICgrCmjVrMHLkSISEhEiknbQUWkwHWa3KBXSZhoYGrF+/Hu/evYOhoSHc3d1lossA4qHFsmDHjh20ZjU9evSgbJefPn2K4OBg5OXlYfz48VBVVWUcWvz9+3ewWCzGrn3CocULFy7EwoULUVtbix07dkBPTw/t27fHqlWrRH77XC6XsSHHjRs3RKjWsqB3797o168fMjIy8ODBAyp7TlNTE1wuVyK1Ki4ujnG3cdOmTbQ6YmEIWAuOjo6orq6Gt7c33r59C1NTU3h6espcIHjz5g3j/9/NmzfT0p0HDBhAmZzcvn0bK1asQElJCfT19aGqqtqq0GJhQw5ZIQgtZrFY4HA44HA4lH5LS0sL3bp1w7p160QMQpiEFgtw9+5dxsUHNTU19O/fHw8ePMDVq1fh4uIiFk9Bh6ioKFy4cIHRtrZs2YKFCxdK/UzzgpSnpyeysrIwd+5cBAQEQENDQ6ZtNQ8tlgWSQoubF6Ts7OxQVVUFc3Nz9OvXT+Z9EqCxsRF1dXUt0rF/LLJ+4H8FMjIyKFearl27UFWyt2/fgsPh4M2bN3j37j3c3DiUs15+fr7EjlR4eDjs7BZBV1cX9vZ2KCkpQWRkJOLj4/Hp0ydaigu/I0UfWvz8+XNERERAVVUVJ06coBZulpaWKCkpob358l37RCsnI0YMx44d28FmszFjxgz4+q5HfX0dDAwMYGNjAx6PJ7UjJbCIF4hRAX5VbMWKFejTpw++ffsGV1c2NV5aRyoiIgK2trYwMDCAi4sLCgsLER4egaNHo5Gb+4l2kcV3NhSn4rBYLGRlvcbBgweom6Zg4bZo0SKZOlICjBkzBnv27AaHw4GhoSE8PT3R1NQEExMTWFhYgBBC62wIiIYW9+qlguDgIADAkydPsXy5B+rrh6KwsBABAQEUXaagoEBiR0oafv/9dxw4cEDmz7NYLLx48QJXr17F8OHDKf1Wly5dpNJlEhISxBLop06diqlTp8LQ0BAzZ86kePoC1ywej4fq6mqKWiaM7du3U2L4Xr16YcDAgTh/PRFXbqXCZ+1a9OndG8XFxVBUVETfvv1w7txZDB06FCoqfFv8goIC3L2bjk6dOqKsrAxRUVGwslqI6dOno40cC5V5hdi1cTP2BITi7du3ItbBAkjqSLVp0wbLli3DsmXLUFZWRtkdd+/eHevXr0dubi7jm6UgtJgJDhw4QFWaR44cSVF0rly5AmdnZ1RWVsLMzAw+Pj4UXUZgW89UI3Xv3j1GFvEKCgrIzc3FxYsXMWzYMAQHB2PXrl0t0mVaCi2mg6wdqXHjxlGTufPnz8PFxQVqamro3Lkz1qxZI9Nva8OGDXBycmK0f5Is4hUVFeHn5wc/Pz98/foVQUFB2LRpE/r27YugoCC8f/+elvYtDVu3bmVsES8cWqyhoYFLly5RboDz5s1DY2MjFi5ciGXLllH3MUFHSpbQYmGkpqYyoql26NAB5eXlOHv2LNTU1Kju28CBAyXqtwD8Wy3ihQtS0dHR8PLywvDhwxERESGTfgvgU9YlFVEl4ePHj+jUqZPYXEJYv5WdnU118IYOHYrg4GC8fv26VaHF/8QiXhCX0tjYKKLfal6Qqq6ultiRkoarV68y6kh169YNcnJyOH78OPr374+goCDk5ua2WJBqKbSYDoKOVEtFM2H91p49e7By5UrqOt7SAlKA1NRUicV9YfzQZP3A/wrs27cfy5YtFbuI5ufnIzg4GAcPHkRaWhpOnTqF2tpa6Orq4tOnTzA2NqatzEoK0H358iX27t2HTp06UjRANpsNJSUlrF69GitWrBCzgpcUWswPwvVFTk4ORo8eDVdXV5FJjDRnQ+HQYoF+6/btWygqKsL48eMREhIitu+SdGRFRUXw9/enAkbPnz+P+vp6GBoa4cOHHOjq6rbobCiMV69eYefOnejcuTOKi4uhrq4ONpuNn3/+uUVnw+bHPD8/H/7+/vjw4QMmTJhI0QD/PkZuCAvb1GJocU1NLeLiYnH//n2UlpZh/PhxlAGGMKSHFvvi0KG7OHbsFI4cOYKmpibY2tri+fPnmDZtmkRtCR2ePn2KoKAgKrRYVtC5G+Xk5IDL5eL169cYPHiwCF0GkBxa3Fz/U1lZiY0bN+LmzZsoKSmBjo4OrQHD+PHjoaioiPbt26Njty6YaKSHeZYWKC0t+8seXwt1dXW4ffs2BgwYgIqKCowePRq5ubl4+/YtJk6ciNraWsybNx/nz5/Dp0+fcPnKFXRV7IDeP3WBAqsNAH6VcvHixejWrRu+f/+OadOmUa5Z0pwN6fD69WssXrwYb968wcyZMxESEiITXeafaKSaOxs2/979+/fj7NmzUFBQgKurKx49eoRJkya12E0QRvPQYllBdx49e/YMwcHB+Pz5M8aOHStClwH43cKoqCiZjpsABw8eRF5eHkJDQ2UeU1ZWhtmzZyMlJQW7du1CQkICFBUVsWzZMqm5Nq3RSNnY2MDd3V1m+/FHjx5h+fLlePfuHWxsbMDlcmXSb7VWI9VSaHF1dTW2bduGq1evomPHjlizZg3u3LnTqtDi1mik6M6j9PR0hIWFoaioCDo6OiIFKYBPGdu7dy+jrt6RI0fw+vVrRgYMgkJGUlISNm3ahJs3b1KGQpJs7QHZQ4uF4eTkhEWLFtEGzdMhNTUV69atw/v37+Hm5gZfX1+ZOrCtPY/09fXx22+/oWvXrrTvC3IF7927h+7du8PPzw/Xr19H9+7dsWLFCpm38/nzZzg7OzOOkqA7jy5fvozdu3ejsrISM2bMEClIAfyFUFhYGCOWwcmTJ3H//n3K4l0WCEKLExISKP2WiooK/P39pRoorVu3Dps2baLOox+arB/4X4vKykp06NCe9qIoTO0TVO8bGhpw6tRppKXdQl5eHmpqakQuji9evICKCn1HKioqCj4+3tQk9ubNm/Dz80dtbS0KCwtoJyCSQou7desGQgjOnDmD/Px8REZGoaioCMOHD4OTk7NEZ8Njx46JdC0E+i1nZyc4ODigbdu2cHR0grKyEjgcDtTU1FBYWCiWtSV8jATp6CYmJjAxMUFdXR3i4+ORkpKCL1++UMdPAOGsreY4cuQI1q5dCzU1NfB4PFy/fh0+Pj5oaGhAfn4BrdOTpNBigevd6dOn8eXLF+zduxelpaUYM2YMnJycUF9P72zYPLS4fXtFisJhZ2dHuQr26qUCNzc3DBgwQKKzIcDv2vEpVVUidJmwsDCcPHkS7969Q6dOnWSuSoaEhNDajkvDhQsXxDpSADBw4ECKLiOgAZaWlkJfXx8+Pj6oqamRqCMTztrq2LEjRaGcNGkSamtroampiX79+mHr1q0YOHAgioqK8PPPPyPlRiqefXiLGRbzkVNRjOs3UvHzzz/DxMQYCQkJ6NOnDzp3/hmqqv1RVVWJtLQ0DB8+HIMHDwGPx4OVlRX09fUxaNBAHNi7D4N+VkbntqILEi6XiwMHDuCXX34Rc80qKSmReYEF8Km77du3x5MnT/D8+XOZ6TL79++XycJaGJKcDYUhLy+P1atXY/Xq1SgpKUFwcDBiYmLw9u1bDB06FJMnT5ZpW1wul8agRTokhRaPGTMG58+fB8Dvfi5atAjV1dUwNzfHmjVrUF5ezmiBBfA1UkwnXBs3boSzszPatm2LtWvXYu3atcjPz0dQUBC2bdsmpt8CmIUWC+P9+/eM8p1++eUXdO3aFQ8fPsSjR48ot9MFCxZg5cqVErU10kKLJaGiogJycnJSJ98dOnQAl8ulwqkDAwNx/vx5mJiYQEdHR8QtVxoCAgKwdu1aRvt369Yt2mxJHR0dXLlyhdJvzZ49mypIcTgcicwNaRCEFjOBoCPVsWNHih6Wk5ODgIAAMV2qAExCi4WRlZUl8wIL4Be+evTogbi4OKSlpcHMzAxycnJwdHSEs7OzxO0fO3aMsUZK0JGStMAC+PqtnTt3AuAXboKDg5GUlIS5c+ciNzdX5o5RYGCg1OBdOkgKLRbopAUFKSMjI6ogZW1t3arQ4oiICMrxVFZs27YNCxYsENFvCQpSX758EdNvAfzf7k8//STbeUQI+Y95TJyoTgj5/cfjx0PkcezYavL77xG07zk4qNO+/uxZDPHxMSIlJSkkLMyCODioEw8PffLq1TGyerUuefv2tNiYpqaHxMFhFO33XboURBwd1YmT02jCZk8kycmbqffY7ImkrCxVbExt7V3i7DxG7PXk5M1kxgwVMmOGComJWUHq6++LvO/oqE4aGjLExhUUXCUcziTq+atXx4iHhz6xtx9J5s1TJZcvB0s4RvR/08uXccTLy4AUFCSRkJC5xMFBnXh7G5Ls7FNkzRo98ubNSUbH/MqVEGJrO5w4OqoTN7dfyO3bu4SO0SRSXHxdbEx9/X2xY9TU9JAkJoaSmTNVyIwZPcmJE55ix8PJabTYcSPkd1JcfJ2w2ROp50+eHCYrV+oQB4dRZOHCweTixaAWjtEHIownT56QuXPnkg8fPhBHR0eioaFBrKysyOvXr4k0aGhoSH2fDgYGBiQvL0+mzzY1NZGoqCiiqqpK+vbtSyIiIkhTU5PIZ7S0tEhNTY3Y2MLCQjJ16lTqubq6Opk+fTrR0NAg48aNIwejD5OXxV9I0rOHpMe44UTbcjbx2hlGuo8eSkYZ65E+v4wh051tidUad9J11GAyfqYR0bOeSy48vE3MliwiXUcNJnPcF5OkPx8Q80ULScaDB7R/w+TJk2lfP3nyJLG1tZXpOAjQ0NBANDU1xV7bt28f0dbWJnp6eiQ2NlbsGE2ZMoX2GEnDqlWryLFjxxiNefXqFZk5cyZ5/vw5WbBgAdHQ0CBLliwhX758kTquNeeRsbEx+fjxo0yfraurI1u3biX9+/cn/fr1I6dPn5Z5O6WlpURXV5fx/mloaIj9Pwjjjz/+IHPnziUaGhrE3d2d5OfnE2tra3L79m1G27l+/Tqxt7dnNKapqUnsPKqpqSGhoaFEU1OTGBkZkYSEBLFxOjo6pKKigtG21q5dS6KiohiNef/+PZk+fTq5d+8emTlzJpk8eTJZvXo1KSkpkTquNeeRqakpyc7OlumzVVVVxN/fnzqPrl+/LvN2KioqiI6ODuP9a+k8unHjBjE1NSUaGhrEx8eHfP/+nTg4ODDaN0IIuXPnDrG2tmY0pqmpSeyYf//+nXh7exMNDQ1iZmZG7ty5IzZOV1eXlJaWMtpWYGAg2bt3L6MxHz9+JEZGRiQxMZFMmzaNaGhokMDAQFJVVSV1XGvOI3Nzc/LixQuZPltYWEhWrFhBBg0aRPr160cyMjJk3k5NTQ3R0tJivH+ampqkoaFB4vsXLlwghoaGZMqUKWTTpk2krq6OxMTEiP1NAH4nNOsaZsv5H/iB/w949+4dDh8+DCcnJxw5cgR1dXUA+JbukjpSR44cBpvN1x6tW7cOsbExcHNzw5EjR/D48WOcOnUKRUVFImMEWVt0uHjxIvbs2YPo6GiEhYXh0aPf4ejohDVr1qCiokKCs+ExWh3NtGnToKyshHPnzoHHI2Cz2eBw3JCamirV2TAiIhw2NjbU8xEjRmDHjh2IjY0FIQQXL16Cs7Mzjh2LR2NjIwDxrC3RY3QEbDYbysrKCAjwR2xsDBwdHXHgwAH88ccfuHDhAsrKykTGCLK26JCQkID9+/chJiYGQUFBSEtLg6OjE7y8vFBZWSGhIxUvRlVksVgwMzODsrIyTp06jYqKCri4uGDp0qW4e/duix0pYU71uHHjsGfPbkRHR6O2thYXLyZgyZIlOH36NHWM+Flbgq5dhcj3BQcHIyAgAP3790dMTAwyMjKwfPlyrF69GgMHDoS3tzfKy8tFxpw/f16kCi8L6uvrJXak6MBiseDi4oI+ffrg6dOnyMnJgZaWFkxNTXHjxg2pWVseHh7U/n38+BG9e/fG1atXcePOLZS1acLBk3GYb2GJdWvXYc2aNcjOfoPExCtQUJBH9+7dMHfuHDx69BCvXr1Cr1690LVrV7i6umLQwIGwtraGlpY2Fsyeg52+XNy+dBUXExJQWVkpsg+CrC06HD58mLEr3v79+8XcuOTl5bF8+XKkp6cjISEBT58+hZaWFmbOnIn79+/L1JGiw/379xlrOrhcLvz8/CjxdUZGBubOnQsHBwdMmTIFoaGhqK2tFRmTlJSEESNGMNpOY2MjKioqZO5ItW3bFt7e3ujbty/u3LmDW7duQVNTE3Pnzm0xzHnDhg1YsmQJo/17/fo1unfvLrUCPGHCBFy4cAEZGRkwMDCAlZUVkpKScP/+fdTX18u8re3btzOiMQL860fzjpSioiL8/f1x//59xMXF4dKlS9DU1ISFhQVevnyJ8vLyFjtSdEhLS8PixYsZjfH394ePjw+mTJmCy5cv4/79+5gwYQLmzp0LbW1t7Nu3j7quCXDjxg3ajpQ0CDRSsnakOnTogNDQUPTr1w+JiYmIj4+HhoYGbGxskJ2dLXVsazVSP//8s9TzyMDAAElJSbh37x6GDBmCmTNnIiEhATk5OeDxeDJvKywsjJZ6Lg3Hjh2jjJoE6Ny5M7Zu3YqMjAzs2bMHBw4cgKamJhwdHfHx40dUV1ejqalJhHopC65duyaTwZIwuFwuPD09YWZmhuTkZKSnp0NJSQkmJibQ19fHsWPHxI7R/fv3GXe6eTweCgsLZe5IKSkpYe/evejXrx9OnDiBbdu2QUNDAy4uLvj69avUsVu3bmVE6Qf4FvE//fSTVPfHuXPnIjU1FWlpaZCXl4eBgQFiY2Nl/pt+0AV/4D8aeXnfMHz4cHC5XDQ2NuLUqVNwd3eHgoICysvLaW+iPB4PpaVlYjcWNTU1GBkZoWdPFUyaNBH+/v6oq6uDnp4e7OzscOHCBdrJXXOL+G7dulE5VGFhm/H582c4Ojpi+PDh4HA41GLi7t10WmccwUKqfXtFigZYVFSEyMhIbNoUhj59euPNmzcYOnSoyDhJocWvXr2Cmpoatm7dStEABaHAFRWVCAri0h4jutDiUaNGwczMDD179sS4ceOwdu1aNDQ0wNDQENbW1jh37hyts+HfFvF8yoJAZC84Ru/fv4ejoyPU1UeDzXaljmVzZ0MB+IuEdujUqSNlLZ6X9w0REeHgcrno06cvcnJyxKiJkkKLs7OzMWSIGnbs2I6amlrExMTAxcUFP/30EyoqKiiTEKAOQAMA/gIuLy8PEyZMEPkuHR0dLFmyBMnJyRg5ciRmzZpF0WXc3Nxw4MABnDhxQmwfpGH37t0SnQ0lQWBa0r17d4oG+P79ewQGBiI5ORmDBg3Cu3fvxH4HmZmZmDRpEjQ0NPDlyxf4rvfFt+py3P3zD1Q11qNtfT1WrFiBTZs2ISaGr8lr374DOJyF2Ld/HwoKCjBx4kRs2rQJ8fHHERsbg9raWixcaIWECxewyTcAGupj8XM9oNqrD/r27QtTU1PIycnB2dkZTk5O2Lt3L0WBFEZjYyOqqqpoDTmk4ezZs0hNTZX4Ph1dJi0tjbK4lzWEUlC0YEo3+vTpk5jFuzBdZt++fRRdhsPhwMrKCrt27WIcWvxPLOL79+9PGbX8+eefCA4OxtevXzFuHF/f2LwAIGtosTC4XC4ji3hLS0t07tyZmvRNnToV7du3x/LlyyknTTq01iL+xIkTSEpKkvh+7969ERUVBYCv31q/fj0ePXoENTU1WidYSWgeWiwr3r59K7IIZLFYsLe3p6z7t27dCl1dXXTs2BGenp4wNTXF1q1bGRnwAPwCXGst4tXV1UXiKVatWoXi4mLo6+vD399fzNVP1tBiYQQGBsLLy0umz7JYLLi6umLEiBHYtWsXVZDq0qVLi/otaaHF0nD06FEkJCRIfF9NTQ0nT54EwC9cstlsvHz5EsOHD0d1dbXM5jifPn2iNeRoCZmZmSJFKXl5eaxYsQIrVqyg9FsHDhygDLSmTJmCjRs3Mi5+nTx5UqZoC2EIQot1dHQoPf3Fixfh4OCAqqoqzJw5E15eXmLFsdZaxK9atUqmzwoKUjY2NswoiXTtrf9fjx90wR+P5o+4uFW0NLOSkmQybVpX4uCgTtas0SMvX8ZR7125EkK2bbOm/T5X1wki1L76+vskNnYlcXBQJ/r6HUVogIJHZCSHxMevof0+YWpfSsoWwmZPIk5Oo8n+/c4itDXhR0jIXJKWtoP2PQcHdYoG6OAwioSFWZCSkmTy4kUs8fY2pB2zZo0eyc4+JfZ6fn4iMTLqQhwc1ImXl4EI/e/atU1ky5aFEo9RSUkK9by29i6JinIjDg6jiL5+R9p9P3JkKYmLW0X7fQJqn4AG6Oo6gTg7jyGRkW4Sj9HGjfNJSsoWicfozz+PklWrdIiDgzrZscOWlJffJK9exRMPj6m0Yzw8ppKsrONir3/9epkYGnYhjo7qxNfXhOTknCOEFBNCCDl37hxxc3MjdDAwMCD5+fnUcwFdZvLkyaRr164kJSWFdpwkTJkyhdTV1TEas3TpUon0Lg0NDZKamkqmT59Ohg0bRnx8fEh5eTn5888/yZw5c6jPqU8YR0zsLMn4mUakn8ZYcvC3U6SfxlgyzGAKUR47jIycpkP2/XqCKI3hUwUH6Uwik+eakkuP75E/C3PJ3nPxxHIVh9zIekpsl7FJ5y5dyLx588iff/5JjIyMROhwZWVlxMvLi/zyyy+kW7dutHSZnTt3ktDQUEbHobi4mOjr6zMaQwifrpiYmEiMjY2JpqYm4XK5LdJlLCwsGFFYCCHkypUrxNnZWabPCugygmP08OFDRtvS1tZu8W9oDg8PDxIbGyvx/V9//ZUYGhoSTU1NEhYWRurq6khWVhaZMWMGo+0Q0nr644cPf9N48/LyCIfDIZMnT6bOteY4ePAg8fPzY7Sd79+/t5r+GB8fT6ZOnUq0tLTIzp07pdKPCCHE1taW3Lx5k9F2UlNTyaJFi2T67MePH4mTkxOZPHky6d69O8nKymK0LR0dHfL9+3dGY3x9fUlERATte01NTeTw4cNEV1eXaGtrk4MHD5KmpiaK/sgUrTmPzMzMyJs3b6jnb9++Jba2tmTy5Mlk0aJF5P3792JjoqOjiZeXF6PtVFVVEW1tbcb7N3nyZLJ//36ira1NdHV1ydGjR6XSIQkhxNHRkVy9epXRdtLT08nChQtl+uyrV6+IpaUlmTx5MlFWVia5ubmMtqWvr0+Ki4sZjQkODia7du2ifa+hoYHs2LGDaGlpEX19fXLy5EnS1NREcnNziZGREaPtENK682j79u3k27dvYq9DAl3wRyfrB/5jQQhBaWkpbXUwIyODyu54+/YtIiMjkZ9fADW1IcjOfou9e8XzNuhCixUUFODg4IC6ujro6Gjj0aPfcexYPJSUlODi4oIRI4bTZm0B4qHFRkZGMDIyQkNDA5ycnFFbWwsOh4OFCxeK0Abfvn0rNbRYQAME+FWudevWITs7G2ZmM8SCk/mVNnpax9OnT2FiYgIfHx+8fPkShw4dQnFxMUaOHImsrCzs3Cke5lpXV4eGhgYRi/h27drBxcUFbdq0QU1NDW7fvoOjR4+iZ8+e4HA4GDx4MO7cuYPIyCix72tuEW9mZgYzMzPU1dVh8eLFqK2txdKlS2FrayviAvn69WtawX9mZhaUlZUwZswYKn8rMTERHh4eePfuHWbNmi0WnCzYD7pq5MuXLzBtmhF8fX3x5MlT7Nq1Cx8+hGLIECM8fPiQMgoQRn19PWpra0VomAK6TKdOnVBQUIC4uDj4+/tjwIABCAkJkWpN3FqL+D/++IO2Qv3s2TOoqKjA0NAQhoaG0NDQwODBgzFjxgxkZWVhyZIlqG9swKVbqeg/cQw2beKHfs6bNw/79u1DbW0tFBQUsH37dnj7+GDP7t3Q1tZGSEgIHj58iLVr1yLA3x8aGhp48uQJtm3egnEDh+LTL1ro3b4zrKys4Ofnh9zcXJGO1M8//4xt27Zh586d+PDhAw4cOAAvLy8MGzYMISEh6N+/P86dOye1I0WHoKAguLrSZ6xJwosXL6CsrEydj42NjTh06BBMTEzQpk0buLq6wtbWVqzT8O+2iBfQZfbt24fnz59jy5Yt+Pz5M0aPHo3g4GCpHT5pocXScO/ePakVakH+Wn19PXbv3g0DAwNkZ2dj6dKljLZz7do1xh0BHo+H8vJykY6UiooKwsPDAfBjEgIDA5GXl4dJkyYhODgYSkpKOH78OGMnvQ0bNsDR0ZHRGIEhx6JFi7Bo0SLU1tZi27Zt0NXVxU8//YTVq1eLmM8IIEtocXMwsYhXVVVFdHQ0oqKicOPGDXh6eqKwsBDa2toIDAyUSkkTUHuZ5kjdvHkTd+/epX1PYCG+ZMkSVFZWIiwsDNra2vjw4YPMnQQB/lUW8YMHD8bx48cB8CmV7u7uKCsrg4GBAfz8/NCxY0ccPXq0VYYc1tbWjMYI6I/C8RTC+Vvr16+ndUnOyspqlUW8rJEQI0aMwJkzZxAfH4/Tp09T8RSmpqZYu3atVKq1oCPF1CJeWkdKXl4eHh4e8PDwQFFREUJCQrB79258+fKFcWjxw4cPZWYwCEAIQUFBgcQoH9p9ZrSFH/iB/0FkZWVJ1CQIU/uGDBlC0VaSk5ORkpKCVatWQU9PD/b29tQEPzY2tsXQYsHk/PXr14iKikJeXh6Kiorx/ft3dO/eXWSMpNBiBQUFyMu3wfnz51BSUoKIiAjExR2DkpISDA0NJOrIDh8+jGXLlom8ZmxsDCMjIzg6OkJJqTtcXV3Rrp0irK2tYGBggJSUFIwaRe8wJRxaPGrUKOzcuRM8Hg9JSUlISkqCh8caGBoawcbGmvq7+Vlb9PSJ27dvIyoqivrs8+cvsG/fPhQWFqK4uBjV1VVi2rSIiAjaPK127dpBXl4B588fR35+PsLDwxEVdRgqKj3/0qzROxs2Dy1msVgU7crOzg4dOrSnaIB2dnaYMmUKbdaWAGfPnqWoduPHj8P48XvA4ykgOvoRjhw5gvnz51M0QMGEWxq177fffkNaWhq1YBLQZUpKSqCnp0dLlwkKCmI8Yf3zzz8l6re8vb1RU1ODJ0+eoLKyEoMGDaIol5MmTUKtHIHmbFPkfvlMBWXeuHkTVVXVqKurx959++Dl6Ynt27dDsV07tGkjj5UrVwIAvuXnY+7cuVixciXOnT2LN4+fYb3LMjg7OSEmJgZXrlxB586dYWBgIHExcv78eRH78+vXr8PV1RUlJSUoKChgpJcA+O5Vu3fvZjQmKCiIorMC9HSZ/fv3i9Blrly5wtjtqrGxEZWVlYxv5qdOnUJKSgrat28PQDa6TEhICGONVFZWVosaKQHatm0LHx8f+Pj4YNKkSVRobq9evRAYGIjx48dLHb9z505aarA0hIeHS3V1mzRpEhWTcObMGVhaWqKqqgqFhYW0mk1pEA4tlhXNQ4sVFRUREBCAgIAAfP78GUFBQdiwYQP69u2L4OBgjBo1qlWhxTweD2VlZbTOrdIQFxeHxMREdOrUCTweD/Hx8ZgzZw6amppgbW0NNzc3sYLUxo0bYW9vz2g7OTk5LWqkBOjYsSM2buQXdsaPH49Xr15BU1MTgwYNQkhISIvHRlJosTTExsZKDS0WFKR4PB4OHz4MMzMzNDU1oaCggLHWTqBxYoLmocVdunSh5jdv3rwBl8sVK0jdvXsXAwYMYLQdvkygiHEeXlRUFGUR39jYiAMHDmDatGmQl5eHi4sLbUFKltDi5vj8+XOLGikBBAUpABg7dizu378PTU1NjBkzBsHBwejVq5fU8Rs2bKDu/bLi6dOnLV7nmuOH8cUP/Mfi5MmTtBkltbW1Yh0pAXJycsDhcBAVFQUFhbaUrXdycjLu3btH+6PPz89Hhw4dRH7Yw4YNw/bt2zF06FCYm5vDz88Pzs7OiI6OQUNDAwDg7dt3tBfu589fUJUOvn7LF7GxfA3Q7t278eHDR4SFbUZJSQk1RprQOCUlBaNHj4azszNiYmKwceMG3L17F46OTtiyZQutuUZdXR1taDGLxcK3b9+wZIkLwsPDUVdXCxcXF7i5ueHWrVtIT0+HtbWN2PcJOlLCx2j0aHXs3r0bI0aMwLRp0+Dt7Y3FixfjxIkTlPj6zZtsKmxTGMKhxT179gSXy0VsbAzs7OywZcsW5ObmYseOHfj+/bvYftBVw5OTUzBqlDo4HA5iYmLg7x+Aa9euwdHRCZs2hVFhvMJoaGigDS1msRpQWlqAdevW4fr168jLy4O2tjamT5+O5ORkJCQk0Abo0nWk9PT0kJiYiHv37mHYsGEwNzeHjo4OwsPDqcXE48ePYWlpKfZ90rBu3Tq8e/cO69atQ0WFqFnH9+/fsWfPHoSEhGDOnDng8XgoKCjAud8uYKjWJCz2XIGjsTHo0aMHzp07j7lz5/5V3dwGBQV5+Pv5YerUqYiPj8eRI0dQWloCT09PeHt749TJU3BxcUFHhXboWMODp6s7Eq9cwevXr5Gfnw8rKyvcvn0b58+fp9VMFBUViZlNmJiY4Pr165gyZQoMDAxgYmICPT09xMTEtLjgevHiRas0UtI6UgL9VkZGBrZt24Zdu3ZBU1MTS5YsYbwYPnDgQKst4gULLABUrtSdO3fQoUMHGBkZwcDAAKdPn6aO0b179xhlcAH8xSYTjRQgMAhSx8GDB5GRkQEul4uQkBBoamrC3d0dBQUFYmMaGxtbrZGSdf8WLlyImzdvQldXF+PGjYO+vj6Vf9MSsrOzZV5sCkOaRXzfvn1x+PBhZGRkwNvbG+vWrcPkyZPh4OBAe/2QBuHQYlkhuC4IQotZLBYcHBxw69YtXL9+HQUFBdDV1YWJiYlI1+/mzZtwcXFhtK2AgAB4e3szGnP79m2MGDECcXFxyMjIgJubG1auXAkNDQ2sXbtWzFAIkD20uDmio6NFiiqSwGKxwGazcefOHejp6UFVVRVaWlowMzNDWlpai+MFHSmmGilpHamhQ4fi5MmTyMjIgK2tLdhsNjQ1NWFvb8/Yll84tFhWCAw5BHpreXl5rFq1Cunp6fj111/xxx9/QEtLC7NmzRLJwrp69apY0bglBAYGMv5tPHjwAEOHDqUMhQQFV4GOTGCUJgwej4f8/HzGRbOLFy9izpw5jMb8CCP+gf9INDQ0YvPmzaioKEd+fgGGDBkCNzcOlJWVERERgc6dO4s47QlAF8hbWlqGXbt24vbt25g4cSKWLFkiki8SHBwMIyMjCaHFfwfyNjQ04MSJE0hLS0NDQwPatGlDG9YrS2hxSkoKzp49h/r6OhgYGKB79+549eoV7Y2KzWZjy5atYgumuro6ODg4om/fPigqKsbIkSPAZnPQtWsXHDlyBG3btoO9vfiki+4YFRYWYufOnbh//z5++eUXcDgckQXfhg0boKOjIyG0+O+Q4bq6OsTFxeHu3bsghEBOTg4xMTFiY1oKLY6OPoqrV6/iwoULaGpqgrGxMbp3744//nhMmY4Ig8PhICwsjDa0eNGiRejVqzfKykoxduxYuLq6olOnToiOjgGLJUdLEZo+3Q2XLt0VWTB9/PgRXl5eSElJgampqRgN0N3dHUZGRi06HAnoMjdu3KAmdZJoNpIgCGY9evQodQ7a29tDSUkJV69eRWRkJBVs6eXlhb3RUXj58T0sLC3gymYj8coVREZGoba2FiEhwdi9ezcIIaiqqoKcnBzi4o5BWVkJ8fHxqK+vx+LFi/HkyVN4eqzBgG49MVl9LB4+eID09HSRBVN2dja8vb2RlpaG2bNnIzQ0VGRivWLFCujo6NB2N4XDZsvKyrBhwwakp6eje/fu8PX1pf19WlhYwMfHR+bcKYAfgvnbb7/RUoAlobGxEaNGjYKqqqrMdBmg5dBiOqxZswYTJ05sccFUVFREhWd26NAB9fX1jCvodCGhLUFaaPH58+dx4MAB1NbWYs6cOVizZg3atm2L/fv3o6CggDZEXRIEocW3b99mtH/C51FeXh64XC6ePXuGPn36gMvl0rpa2trawt3dXWq3ozlSU1MRGxtLa+AiCU1NTRg6dCj69euHhoYGWFpaYvny5S1OynV0dKhAYlmxbt06qostDZ8+fUJgYCCysrKgrKyMsrIyxgYCrTmPZsyYgX379tHeJwXXNUII7O3t4erqChaL9Y9Ci5n+TcKhxdnZ2eByuXj37h2GDRuG4OBg2q6ik5MTbG1tYWJiIvN20tPTsX//fpw6dUrmMY2NjRg8eDBUVVXBYrGwePFi2Nvbt1gk0NfXR0JCAiMHw6CgIJlCizMzM8HlcvHp0ycMGDAAX79+Zfzb1dDQwIMHDxiNmTVrFjZv3iy2YGpsbMSePXvw66+/om3btnB3d6eK7MePH8fDhw8ZdUQbGxvB5XKpLmxz/Agj/oH/VcjIyMDMmTMoZ7dbt24hICAAtbW1yM/Pp3V3oetIAUDXrl3Qpk0bbNiwAT179kRkZCQKCgoxdKgaOBwO3r/PAZcrPoHjW8T/TclSUFCggmqXL1+Ozp07w9HRCUpKSmCzXTFs2LC/nA1LaS1zhUOLp02bhmnTpqGhoQHx8cexbds2DB48GDdv3hSpWAp0ZM0XWADfJnbWLH7VhsfjISUlBevWrUV9fT3y8/Nx4cIFsTFFRUW0ocXKysro0OEnBAUFQVlZGQcPHkRxcTHU1dXBZrOlOhv26PE3ta9du3ZwdXWFq6srli9fjnbtFOHo6AgVFRWw2WzquNA5GwJ/W8SzWCzMmDEDM2bMQE1NLeLiYhEeHoEhQ4bg7t27Iva4kjpSAD+0eObMmXB0dASPx8OVK3z9loAKcu7cObExfJcwBTGNVP/+/aGkpITDhw+jZ8+eFA1QV1cXAQEBePz4sUyaCWG6jKmpKdq0aUPRZUJDQ1u0W75w4QLGjRtH2bi7uLigsrISGzduxNq1azF27FjcuHEDOTk5mDJVD6ONdLFLexKWLFmCd+/ewWKBBcrLv2PNmjU4ffoM9u7dh+rqatTX1+PgwYPw8vKmFrIFBYU4e/YMAOCP9HsIWroGy92XIioqCul37ogtHtTU1NCvXz9ERESgW7duYLPZ+P79O4yNjeHr64tHjx7R3tiad6S6dOlC6QZev34tQpcJDQ2lJvi5ubmMFlgAn+7JZGIM8C3iFy1ahMDAQIouY2RkBHl5ebDZbNjY2IhNcP6JRbxAkykNwuGZpqam4PF4FF2meXgmHSSFFkuDoCMlycp5wYIFWLBgAaXfmjp1KhQVFfH582c8ffqU0bZCQ0Ph7OzMaEzzjlSvXr0oiuKjR48QEBCAb9++YfLkyeByuRRT4v3794wWWAA/xFRWjZQAhw8fhpWVFTZt2oTa2loRN8A1a9bQdtz/iUW8IKRXGlRVValCmImJCRoaGqChoQEdHR0EBAS0OCEXuHQygaAjRTeu+XVt06ZNlBvg58+fGTsRttYiXji0WE1NjXKMTU1NpfRbRkZ8Pa/g/yYzM5PRAkuwfwLnU1lx/PhxWFhYYMeOHSgrK0NoaCi0tLTQvXt3rF+/Xsw+HsA/soiXZYEq0G8B/PlNRUUFpkyZAjMzM/j4+LR4HWytRbyk0GJ5eXl4enrC09OTKkjt3LkTKioq+PDhA27cuMFoW8nJyRLlJtLwo5P1A/+R2LdvP5YtWyo2cfn69Svc3Zeie/duUFBQwIIFCzBt2jSwWCwEBwdj2rRptBcY4Y6UAGlpaYiKOoy8vK+wt7eHnZ2dCI9/1arVWLlSekcK4E8CIyOj/lrAtIOqqqqQJfjfYLPZ2LZtmxjNsa6uDu7u7ti6dSsiIyPx+vUbKCsrgcPh4NatW1BUVKStatN1pATHiMPhQElJCYqKirC2toa+vj4AfkdKV1eXei7tGPF4PFy/fh1xcXHIy8uDi4sLrKysRLbXUkdK0OF6/vwFjhw5jNLSUnTq1EnE4l0YHA4HmzdvFkuvb2hoAIfDwcaNmxAREY6cnByoqPSCmxsHaWlpaNOmDRwcHMS+z9nZGZGRkWL6jC9fvoDN5kBZWUlEvwXwb3qTJmnD2Fg82b55xZbH4yE2NhZ79+5Fjx49GIvthSt3Ak1ISUkJJVCno8QaGRnh+PHjYpPo+vp6TJ06FceOHUNAEBdJ6begYaCHpUvdcevWLSr3zMHBETdv3qBsrquqq7F1y1Zs27YVNTU1sLGxga2tLb5+/QoXFxf0VFJGd3lFfHn3Ac+fPweLxcLy5cuhq6vbYkdKcIzCw8MRGRmJ3NxcbN++HY6OjiK/bQsLC6xduxa//PKL1ON19epV7Ny5E+Xl5VBVVUWHDh1oO6WS0NjYCF1dXdy/f1/mMYDkjlRJSQmCg4Px4MEDKCsrw/8vQxCA39H+5ZdfsGjRIpm3k5mZCW9vb8Zie+HzMiEhAXv37kV1dTXMzc3h7e1Na6pibGyMI0eOMJrYtKYj9ebNG+jp6WHAgAHo3bs3AgMDZcqR09DQwP379xlR+GxtbbF06VLarqcAPB4PZ8+e/YsuXQd1dXXU1NTg2LFjMm9H0CVm2r3R1dVFUlKS2ILp8+fPCAwMxMuXL6GqqoqgoCBq4rh27VqoqakxovC9e/cOy5cvl2pHTwfB9YjH4+HYsWM4evSoSDwF3f+FmZkZ9u/fz2ihdfjwYWRnZ2PLFvE4EEl48eIFDAwMMHjwYAwePBghISEybbP59UgWODo6ws7OTqoekMfjISIiAidOnICcnBymTJmCDx8+4PTp0zJvh8fjYcqUKYy7N5I6UllZWQgKCkJOTg5GjBiBkJAQ6vfN5XKhrKyM5cuXy7ydT58+UXElTCC4HjU2NmL//v04e/YsFBQU4OrqSluQAviRFlu2bGFE4WtNR+rhw4cwNTXF0KFDJcZT0MHX1xcbN26UeB796GT9wP8aVFRUokOH9rQnc2RkJHx8vKGtrY3S0jJERUXi+PHj6N69O758+QIuVzwTSuC21hxTp07Fb7/9hqAgLu7fvw8OhwMFBQVYWlrC0NAQZWX0HanmocXDhg3Djh38qrulpSV4PB4WL14MfX192NraQkFBgdbZUIC4uDhMmzYNSkpKlKNeZmYWwsMj8Pvvj2BqaorS0jKRbpa00OIjR47Ay8sL+vr6KCwsRHh4BI4ejUbPnj3w8eMn2o4UXWgxi8WCqakprl+/Dj8/P9y7dw8uLi5o37495QbYUkdKAIF+i8fjwdJyIaqrq7F48WIYGxvD0tIS8vLyVEeq+QIL+Du0uFcvFSoY8unTp9i9ezeePv0T5ubmqKiooPQHAFBcXCwxtDg2NhZeXp4wMDBAXl4ewsPDER4egV69VJCT8+EvHcjfeVmC7TUX07JYLDg7O+PixYsIDAwU2440nD9/XkREq6enBz09PfB4PIwePRoZGRlgsViws7Oj6DLSQov37NmDWbNmoVsfFazaEIiXbhx07PgTfHx8kJ+fj1mzZuHFixdIT7+D79/LUV7+HWvXrkN8/DHExESDEILa2lpKQ3Q8/jgCPXzgYmWLd2/fwcfHB1paWhg6dCiePXtGiY6F8eIFX48o/NtlsVhYunQpbty4gR07duDq1atU1VVAA/z8+XOLCyyA37ExNTVFY2MjRo4cia5du0JfX19muszevXvFQotbgrSOVLdu3agb/MuXLxEUFIRPnz5h1KhRePLkCeMKtSC0mAmahxbPmTMHc+bMoegyBgYGYnQZpqHFApw6dQrXr19nNCYiIgJbtmyBo6MjHj9+jODgYCp/LigoiDYsnR8QrtQqjZS0BRbAPx+trKxgZWWF2tpajBo1Cl27doWRkRFWrVolU15dREQErRZWGgQaI7qOVN++falMtPv372Pt2rUoLCyElpYWbt26xVigHxgYCB8fH0ZjhA05WCwWxdqorq6m3AA7d+4MLy8vavEhjbkhDXFxcYwLCSdPnsSGDRvA4fALa8uXL0dpaSn09fXh5+dH64b44cMHmQ05hPH69WupCyyAf4zc3d3h7u6O8vJyjBkzBt26dcOMGTPg6+srU2c0Nja2xfO1OaR1pIYPH07RDpOSkuDi4oLy8nKYmJhQgd5MwOVyGWukhDtS8vLyWL16NVavXk0VpPbt2wdlZWUEBARQLASmocUCREVFMcusAr9QFxgYiNWrVyMhIQF2dnaorq7GrFmz4OnpSVuQqqiowE8//cT4PAJ+dLJ+4D8QCQkJGDt2LK1zjnB3RBiXL1/Gvn37oaLSE2pqanBzc6OoINI7UotFvq+kpASRkZG4f/8+mpqasG3bdpHFAtByR+ro0aNoaGjA8ePHcevWLbRt2w5dunTB2LFjaGkLkjpShYWFCAgIwIIFC3Du3HlKv2VjY4PNm7dAT0+2jpQAFy9exP79+9GrVy+MGjUKrq5sauHm4eGBpUuXihlvNO/aAXxaZmRkJH7//Q/weE3YvXu32LHld6S2iNEcGxoawGazER0dTdEA79+/jw4dOqB79+4YOnQorbOVpI5UUVER/Pz8YW5ujoSE38Dj8WBiYgILCwts3boVmpqatG6Jks6jCxd+w4ED+9GnTx/066cHL69N1M1s3rx54HK5tFX41nDJDQ0NcfLkSTE7WEFH6t69exRd5ubNm/j555/Rp08fqKmpiTiaCTBitDq6DOgDK/tFePXqFR48eIDc3FxoaWnh27dvaNu2LQoKClBcXIwlS1yQlnYT5eXlcHR0wqxZ5vial4c1q1eja9euaKiqwfdPeXjz8pXYdsLDwxEYGIjBgwfD0NBQhC4jrSPVvAv4+vVrBAUF4enTp5g0aRKjToJwR0rgBnjv3j2pdBmgdRqpVatWQUNDgxHlaP/+/QgODsaQIUNkpssArdO2GBsbIzo6WqqDobB+S0VFBYMGDULnzp2pgoUsKCsrw5w5c3Dr1i1G+yepI3Xu3DkcPHgQtbW1mDdvHlatWkVNcGxsbLBs2TJGE9Br167h5MmTjDqbwh2pr1+/gsvl4vnz5+jbty+CgoIoendzSOpISYOPjw+GDRsmswMkj8fD9u3bsWXLFgwfPhxWVlZYunSpTKYKrTmPTE1NceDAAakLpo8fPyIwMBCvX7/GgAEDMGLECNTW1jJaBLZWI0XXkRLot+Li4ij9louLC/UZBwcH2Nvbt7hgEkZ6ejoOHDhAhQXLAuGOlEC/9f79ewwdOlRMlyoMPT09XLx4kRGFLzAwED179pTZVKKxsREbNmzA3r17oa6uDhcXF9jZ2cm0YGjNeWRubo5t27ZJdIYG+MW44OBg5ObmQl1dHaNHj8aHDx+wa5d4rIwk1NbWwsjIqFV65vT0dJHfUX19Pfbs2YPffvtNrCAFADExMdDQ0JD6N/3oZP3A/xpcvnwZ7dq1o0SdAkjqSAF8d7nw8EMYOHAgbt5Mg7+/P2pra6Grq4vSUnru99WrVzFmzGiR17p164Z169bB1dUVbm5uOHLkMAoLCzFs2DCw2Wx06tSpxY4UwNdvOTk5wcnJCSUlJbC2tsa3b3n444/HlH4LkN6RCg8Ph42NDfT19WFsbPyXfisebDYbOTk50NUVn4Dws7boLeLT0tJw8OBBDBo0iNJvNTQ0wMDAEEVFRRKdDZtXlwRUPw6HA0dHR+zbtw+lpaVQVx8NNtsVioqKqKuro9WRxcfHU5qz9u0VKffHb9++wc7ODh8/fsSLFy/h5sahhMXNs7aEERkZSdnZz5pljpqaWsTE8J0cP3z4QLsIFWRt0SE9/Q4OHDgANTU1nD9/C7Nnz6boMl+/fqVdYJ07d47SDsoKQdYW3f+VsEV8x44dKV1FTk4ONDQ0MGDAADx//pyiyxBC8Co3B12G9kfY5s2IjIjA1atXMXr0aLBYLFRWVqGqqgrv3r3DnDlz/nIC/Iba2joUFxejd29+dy78UDi8PDwxx9AEOS8yJbpxJScnIzExERMmTEBERATMzMwgJ8c3EMnNzaVdYCUkJIgZDgwbNgwnT56EkZERI9oQwO9IzZw5E8DfboAAn24XHBwMT09Pii7Tr18/APzzqG3btow1Ug8ePGB08wf4GtLLly9j4sSJ2LdvH6Xf4nA4sLa2pp3gJCYmihjyyAJZLeKF9VvPnj2DkZERBg4ciK9fv8qk3wL4FvGLFy9mtH+ZmZkSO1IWFhawsLBAfX09du7cialTp6J9+/ZYvnw5cnJyGFf4W2MRHxERQV2ze/fujagoftbfo0ePsH79euTn50NDQwNBQUGU5rO1GimmFvEsFgt//vknzp8/j8mTJ4votzw8PCR2ZFtrES9LR6p///5Uwe3OnTuYO3cuBg4ciMbGRgQEBMiUrbVp0ybGLpg5OTno0qWL2HlEp0sV6Ld8fHzw5s0bRgsswf61xiJe4DIprN9KTk4Gh8PB9+/fKf3WTz/9BIDfkeLxeIw1Ukwt4uXl5fHhwwecPHkSGhoaCAkJwYEDB6CkpAR/f3+KJt8cd+/eZewGKuhISVuMAIC6ujrOnj0LALh06RIcHR0pC39ZC1Jbtmxh7Mr7+fNndOzYUWy+1bZtW3h7e8Pb2xsFBQUi+i2BKYyTkxOjbQnwo5P1A/9RyMvLQ1JSEoqKivDy5Ut0794dLi4uGDlyJFatWo3Vq1eJufrQdVsAftfE3z8AT58+wYABA2BhYSFywZWlIyVAamoqzpw5i0+fPmLIkCHYuXOn2KRfWkcqMDAQhw4dQmZmFg4fPkxlVVRUlMPMzIyWWiCpI/Xy5UtERESgR48eyM5+ix49lMFms6GmpoY1a9Zg2bJlMnWkBH+rv78/nj17hkGDBonotwDJHam6ujq4ublRIas8Hg/Xrl3DhQsX8OXLF6ipqWH79u1ix8LJyekve336jlRERDiePXuGo0ePorS0DGPGjMb3799hYGBAa2EsqSOVmZmFffv2Qlm5Bz58yEHv3r3B4XAwYMAAeHp6iSx0JR/zdgDUUV1dDVtbW2RkZGDMmDHw9vYWOY8EVtp0tCdJ8Pf3x4sXL/Drr7+KTRy0tP4fe+8Z1sT2foEuI11FRVCwd0SwHQsdkWLvKEWQ0IuiIEVFkGpFBbHSpAhiw44VUVQUVOxiAxUUBOlNWiBzP+RkDiGTkPhr/3uv63n4kLIzk81kZva73rWWBkfWFhtlZWUwNTXFnTt3cPfuXZiammLY2NH4a5Y2Kmqqoa6uDkNDAxQWFmLrVj/IycmisrISBQUF0NLSQlVVNRoaGmBry2pl/fTpE0JDQyErK4uioiL8+FyAB6k3MGbUaBgZGcHb2xvTpnEV5iirm3V1dTA3N8eTJ08wdepUrvBMXjqyf7dGqiOuX7+OsLAw1NfXY86cOSgtLcXMmTMpXUl54e3bt/D29saVK1eE2j+qOaqsrERQUBCp3+rYLgMIxkh1xoEDB1BVVfXbjNTFixdx8CDL+GTx4sU822XY30lYbYupqSlcXFwEXjCVlpaCTqfjxYsX0NLSQkBAAKUbYGf8rkZKS0sLN2/eJG98qT739OnTiIqKQmtrK4yMjPDjxw8oKSkJlUmWl5cHV1dXXLt2Taj9ozqOvn37Bn9/f7x//x5Dhw5FcHAwx7ls7ty5OHr0qFCZWlFRUfj69etvMVL37t1DQkIC4uLiwGQy+eq3AE7XPkFhaWkJOp0ucIvm169fYWtrizdv3mD27NkIDg4WKMD4dzVS2traZEYgr8+NiIhAcnIy2WL++fNnDBw4UKhYiMLCQjg4OAit/aU6jthugIWFhRg/fjyCg4M5zj0LFy7Evn37hAoQT0xMxPPnz4UqSjU1NcHAwAD37t3j0G85OjrCxMSE73H04MEDoezybWxssHz5csqAcCq8evUKXl5eUFNT61KH+ofJ+oP/V+D27dtYtmw5eVOfn5+PqKgo/Pz5E8XFxejZsxfXGBYjxX0hFhUVRVVVJc6cOYP29nZERkYhKSkJsrKysLS05MlIJSQkcFW/9PX1/w4FtsJff02Fg4MDxMTEsHLlShgYGODnz598GSl2q5GS0jhSv5WWdhvbt29DSUkJvnz5Quq3AM6src44duwYXF1dyarju3fvEBERgfLycpSWlqJfP26W5vbt25StL+Li4qitrcXp06fBYDAQERGJuLg49O/fH9bWNpRZWwA7tPifCx6NRsO8efMwb9480OlWUFJSgr29fSf9FsvZkIqRioiIgKkpy0Rh4sSJpH7r+vXr2LNnD4qKivDz50+sWLGCnOOOWVudERMTA1dXV/IC8eLFS4SFhaGmpgalpaUYOHAg5Rxxuq21AGBASkoKdXV1eP36NZqamuDn54etW7dixIgR8PX1RUtLi1ALLIC1aNfV1SWrrl5eXtDX16fM2mJj69at5AV58NChGK85A2GRR3Dp4iWcOZ+CgoKvKCv7iXfv3qFPnz7IycnBpEmTMGXKFKirq+PixYv49q0QhYWFYDDaEB0djfWurpikPAGDevbB0wcPsW6tC2pqavD9+3dK57kLFy5g0qRJXM9LS0ujsbERr169Qn19Pfz8/Eg3QD8/PzQ2NvLUkbEZKUFBlbVFBfbx2NbWhqNHj2L//v14//49yUwKcpPXObRYEFy7do3yt9avXz+yQv727VsEBASgqKgIKioq8Pf3/63Q4tOnTwstSu8YWrx06VIsXbqUbJdh67fWrFnDUSXmx0jxA3uBLyjk5eVBEARycnJQUVEBf39/lJSUYOrUqQgMDKTMTQS6Di2mQk1NDWg0Gs8FFsA6r5mZmcHMzAzNzc3Yu3cvoqOjMW3aNAwYMEDgm7XOocWCID09nVLvOnToULK49fDhQ3h4eKC8vByamprw9fX9rdDixMREoU0y2KHF7EWDtbU1fv36hZ07d0JDQwO9e/fm0G8BvBmprvDp0yehNHAjRoyAhIQEHj16hO/fv2PNmjWoqanBrFmz4OPjw5OFjIuL45l7xgsNDQ0gCIIvi8fWpbL3Y/v27YiKioKGhgYmTpwo8G/E39+fI7RYEPAKLe7oBnjt2jXY2Nigro5V9PXy8uKZSckPMTExlK7G/LB7927SUIut36qoqEBQUBDCw8MhJycHPz8/jg4JXoxUV3j37h1H8bwrTJo0CXPmzBE6nJsDBEH8n/mbOlWFIIicP3//P/1jMp8SBw7QKV+7ejWIWLdOg3B0nEbQ6SpETIwz0dLyiCCIHMLe/i+itvYO15impkzC2noi1/MfPpwgli0bSsyfL09s376cKC+/wfE6na5CMBjZXONKS68Szs4zyMeVlbeIHTuMCEtLZWLevP5EcrIn5b5bWipTPv/mTTyxcaM+0dqaRcTGriWsrCYQjo7TiDt39hCurlpEfv5prjHt7U94ft61a9sIZ+cZhIPDVMLKagJx/Lgb+T0cHKYSNTXpXGOamx9SztHbtwnE0qVDiPnzBxAhISZcY62sJlDOUVnZDcLRcRrHnAUELCIsLVWIBQvkiZMnec2RCuXzubnHCQ8PXaKxMZOIiLAn6HQVYs0aVeLRo4OEu/tM4tOnk0LN+a1buwg7uymEnd0UwsZmEnH69Eaivf0JOUeVlbc6jakkWlpaCHV1daIz7t27R4wePZoYNGgQ4enpSdTW1nK9hwo/f/4kdHV1ycdfvnwhLCwsiBkzZhAjRowgDhw4QDlu7NixxIwZM4gFK5YR2isXEzHXLhCvyr8TJ+5eJ8bMVCUMLI2JJc42RF/lUcRfCw2IGUvnEhorFhKJ6VeJV+Xfibhbl4kF9pbEhj3BxNRFhsRwjb+I4oYaop3ZzrGd8+fPE+rq6oSWlhahpaVFxMTEEO3trPfMmjWLKCkp4dq31tZWQk1Njev5W7duETNnziRGjRpF+Pr6Er9+/eJ4XV1dnWhqahJo3thwcXEhTp06JdSYN2/eEIsWLSKqq6uJDRs2EKqqqsSCBQuIR48e8R2nqqoq1HYIgiAMDAyI4uJigd9/6dIlYuTIkcTAgQOJoKAggeejsrKSmDlzptD7N2PGDPL/SYWfP38Szs7OhKqqKrFkyRLi2bNnxMqVK4mHDx8KtZ1r164RdDpdqDEMBoNyzk+fPk3o6uoS6urqREhICNHS0sLxuqamJtex1RU8PT2J2NhYocZ8+vSJmDdvHvH9+3fC1taWUFVVJVasWEG8ffuW77gZM2YItR2CIIg5c+YQX758Eei97e3tREJCAjFy5EhCQUGBOHDgAMFgMAQaW1tbS2hpaQm9f6qqqnyPo4KCAmL16tXEjBkzCFNTU+LTp0+Eubk5kZ6eLtR2MjIyCDMzM6HGtLe3cx1H7e3tRGRkJHlei46O5tp/LS0tgc/jbGzZsoU4cuSIUGMKCgoIQ0ND4uPHj4SpqSmhqqpK0Ol0orCwkO+43zkfzZ8/n/jw4YNA72UwGER4eDgxatQoQkFBgTh+/Djf/3FH/Pr1i9DU1BR6/9TU1Pgeq2/evCGWL19OzJgxg7CzsyOKi4sJa2tr4tq1a0JtJzs7m1ixYoVQY5hMJrFx40aB3gsgh6BY1/xhsv7g/wzev3+PceOoe3kvXLiAvXv3onfv3mAwGDh16jTZklBdXU1ZRWIxUtyZFYqKipCWlkZMTAzu3bsHHx9ftLQ0Y+ZMXRgaGlBmbQGcjBTA0m+xXOgAExNT5OQ8xY0brOwZR0dHyMjIcGVtdURMTAzWrVsHUVFRshJYUVGByMhIvHjxAkePHoWjoyNHNbNj1hb3HJ0n2x9bWlqQlJQEe3t7iImJobKykpK1S0xMpDSGUFZWRu/evREdHYP09NvYuHEjGAwGyeiJi4tTzlFkZARMTU3JxwMGDCAdH42NjZGdnY3r169j4sSJsLOzQ+/evbmytjri2LFjcHJy4tBvlZSUIjIyAjk5zxAbG0u2AbKRlpbG8zhKSUnB7t27ISMj87d+Kw42NjaQkpL6Ox+rc9ZWPUJDo7B06VKuz9LR0YGcnBzu3r2LpKQkLFy4EEwmE+bm5nB0dORZrfX39+ew0R0xYgRp+qCsrIxr167hxIkTZIuCtLQ0Xr58iXEqygiLjcSzt6/h7LwGYWFhGD16FKqrq6Gjo4Pz589j4MCBGD58OCQkJCAuLo6XL1/i7NmzkJWVRXxcPDZu9MLgwYMxZvhIPEu/h4E9uI+JQ4cO4fz585CXl0ddXR2pc+jduzfKy8t5MlJUVX1DQ0MYGhqS7TKzZ88mK98LFiz4LY0Ur6wtfmAzUp31W/7+/tiwYQPGjx+PoKAgDiYpNTWV52+NF9gaKSqmlBcWL16M3bt34+bNm4iKioKenh7ExMS6bJcJDg4WytYbYH1nOTk5vkxC//79ceTIEQAsR83AwEDcuXMHMjIyGDVqFE+GvTPCwsKECnwGQB4jnWFsbAxjY2O0trZi3759HPqtWbNmgUajQUpKSqhtPXjwQGgtoJ+fH7Zs2YLBgweT3+3x48fYvHkzysrKoKamBn9/f47zSFpamtCMAJPJFIqRotFosLS0RFRUFM6fP49Dhw5BW1sbvXr1goeHB+bMmcNz7Pbt2ykD2fnhy5cv6Nu3L9/jaNiwYWQe3f3797F+/Xo8evQIAwcOxLRp0wTSbwEspoPKyZQfqBgpGo0GBwcHODg4oL6+Htu3b4empib69OmDTZs2Ydq0aV0yUlRIT08XOrvLz88PXl5eGDt2LGmwcfPmTdjb23PkCnY8pjMzM4VmKJlMJiorKwU+/kRERLB+/XqcO3cO8fHxOHDgAId+S01NjefYkJAQykgPfvj+/XuXjJSKigrOnTsHgGXetXr1auTk5GDkyJGYNWuWwNePbdu2CaWJBIAXL14IrbfuDOH9CP/gD/5DuH//PnR0uLVJTU3NYDKZ5CJBVFQUq1dbIDY2FhMmTCBDgT08PPD+/QdyXFZWFlauXMH1eR1Di/X19REZGYHo6GjQaN1Ap1uhoqICt2/f5hr35Qu1GPvNm7cYPnwY9u3bh4SEBEyfPh3e3ltgbW0NP7+tlL37vITGsrKy+Ouvv7Bw4SLY2NggIiICdDodu3btQnV1DS5cuAAHBweuz2tpaQGDwSDnSFxcHLa2toiLi4OKigokJSVBp1th48aNyM/PJ8dlZmZyLIrYKC8v/7u1TwRz585FZGQkjh49iqamJpibW6C6uprSHSovLw+6urpcz7979w7Dhg3D/v37ERcXByUlJXh5ecHGxgZbt/pRzhFBEJQW8QoK8tDU1MS8eXNhYmKCsLD9oNPpCA0NRX19PVJSUuDoyD1HLIv4FvIGSFJSAs7OzoiPj4eSkhJERERAp1thy5Yt+Pbt29+j6nH58mW4ublxfV5ZWRm5mLG1tcX9+/dx48YNFBUVYcSIETAwMEB6ejrXuBcvXsDIyIjr+ZcvX2Ls2LG4fv06Hj16hNTUVCxYsACaWlqwcLaHudsaNDBaUF1dDSkpSUhJSWLcuHF4+/Yt7t+/j4EDB6F3794YPnw43r17h6qqahgYGGDR4sXYsWMHXr16iUsXL6I3RHH26DFs8w/k2ofOFvHS0tLYvXs3srOzSbt5NTU1WFpaoqCggBx3/vx5vm0s7HaZzMxMXL58Ge/evcOECRNQXV0tlIibyiJeEFBZxLPbZbKzs7FixQpYW1tDXV0dgYGBaG5uxv79+4XKgwJYC9TfsYgXEREhDQ0ePXqElJQUPHr0COrq6liyZAlycnK4xmVlZQkdsiqsRfzkyZPh4OCA5cuXY/bs2TAzM4OGhgZ27dqF1tZWnuP+FYt4fm11YmJi8Pb2xqNHj3DixAncvHnzb21rPV6/fi3wdvLy8iAjIyP0cURlyKGqqoorV64gKysLM2bMwPLly6GpqYn9+/ejra0Ne/fuRWAg92+NH6Kion7LIr5bt27o378/goKCkJWVhZiYGJw8eRJjxozB8uXL8fHjR65x9+7dE9rQxM/PD5s2bRL4/To6Oti0aRMWLlwIRUVFLFiwAFpaWoiMjASTyeQ5jh1aLKyRR0JCAmVUCRu9evXCrl27kJWVhYMHDyI6Ohpjx45FU1MTvn79KvB2CgsL/20W8XPmzMHNmzfx6NEjKCgoYM6cOZg5cyYSEhLAZDKxc+dOobSXAKuIystplRcaGxvR1taGESNGICwsDNnZ2QgJCUFoaCjU1NRgY2ODoqIirnE3b96Es7OzUNvy8/MTyiJ+8eLF2LZtGwwNDSEpKQl9fX1SE93VcfQ7FvGXL18WKNKBH/4wWX/wfwIMRhvS09MhIiKC1atXQ1xcnHzt+HFujRQbL168IM0m8vLyEBUVhbKycgwZMhiioqI8GanOAaGioqKg0+m4c+cuwsJCERkZhcREln7LwcEera2tkJfnpZFiMVJsGBgYwMDAAK2trViyZAl27NgBcXEJmJgYk6xR56ytjrhw4QLJSO3btw8EQSAtLQ2enp7Iz8/H5cuXYWpqBlHRf77b8ePHec7Rs2fPEBcXBxEREeTm5uLIkSOoqKjAqFGjICIiwmOOIrkMAsTFxWFnZ4cHDzIRErIbUVFRiIk5Bnn5AXBwcODplseaIxYjBbBuuOfPn4/58+ejqakJy5Ytw+7duyEpKQlzc3PyotA5a6sjUlJSSEOO8HCWfuvatWtwc9uA/Px8pKWlwcjIiOO7dXQ2pJqj48ePQ1RUFC9evMTevXtRW1sHJaVxEBenUWqk/P39uWx0e/bsie3btyM9PR3R0dHkTe3IkSMRHByM+vp6rqwtNjw9PUkHo/v370NVVRWR8bHIK/uBBUsWwc/fDz179kJrawtcXd2wY+cOVFVVQU5ODr1798akSZNw9uxZVFdXY8qUKairq4eDgwP69++PH8XFUBk1FioKw2G2eBnevXuH1NRU2NjYcNwgsLO2qHD//n3k5ORAXFycwzVLU1NTII0UG3369MGePXvw4MEDxMfHIzAwEJ6enhg3bhxHeCYVAgIC+N48UeHy5cuYMIH6t8YG+3hsa2vD4cOHoaenh/fv3+Pu3bs8wzOpcPbsWcqFNT8EBQVxFU46ugF21G9NnDgRQUFBqKqq+i2N1Ldv33i6ifFCaGgoYmNjMWTIECxfvhytra3Yv38/dHV1IS4uDhcXF66iwdGjR/myJ1SoqalB9+7dBWak5OXlERERgZcvX+LgwYPw8/NDSUkJpk2bxle/BfzDSAmDrhgpGo0Gc3NzmJubo7m5GSEhIdDS0sLHjx/x/v17oViIpKQk3LhxQ6j9o2Kkhg4divj4eKipqWHDhg1wd3dHRUUFtLS0sHXrVlRWVnbJSFEhPz+fspjGD7t37yZDi21tbdHQ0EDmb/Xu3RsbN27k6qqIjY2ldIjlh4aGBjCZTIEZqdGjR+PEiRNQVVXFjh074OzsjJqaGujp6WHLli18XSS3bt0KT09PofavK0aqs34rODgY6urqyMvLE1onFRsbi0uXLgm1f7t37+a69o8fP55Dv2VtbU0an2zcuBFlZWW/pZF6//690EWp7du3k6HFHh4eZDwF2w1w69atXIZNycnJQp/32trawGAwICkpKdS4zvizyPqD/xPIzs7Cxo2b8PHjBzg7O0NUVBRGRkYwMDDAo0dZOHaMu+2kpKSUo7VvzJgx2LNnDwCWK15DQwOsra2ho6MDCwsL0nDhy5evlNUdtkU8qw2QVU39+PEjoqKi8eLFc0ybNo2rpYzFSNVQWt+mp6dDT08fXl6eqKioQFRUFBISjkNOThYlJSVkS05HUIUWd+vWDbNnz0Zh4TfMnKmD1tZW2NvbQUJCAqamptDV1cXDhw8pW3M6W8QrKysjNDQUTCYTTk5OqK+vh42NDfT09GBqakq+Lz8/D1u3UocWDxjQn7RxB1hM3qFDh/Dq1SuoqqqitraWY/+ZTCbP0OIHDx5g1qxZ2LRpE0pLSxEZGYmoqGjIy8ujuLgIBw8eopyjzoYcNBoNCxcuRFlZGTQ01FFVVQ07Ozv06NEDFhYWUFdXx/379yktnlkW8f8YckyZMhlTphwAk8mEo6MjWloaoaWlxdUG+Pz5cxw9epTr8168eAEFBQWMGDGCo11m3bp1ePz4MebPn4+6ujqum4CKigqy1ed7cREiko/jS2050u/dJefRZZ0LvDw9cfjwIfTp3Rs9e/bCvHnzEBkZgcrKKixduhTm5uaIiorCixcvEBISgjWOTrh18hyuXbgEaWlpNNTWwcDAAHl5eVBXVydjC2bOnIkLFy4gIyODxxyJk8WPjm2Aenp6QrcbvX79GgMGDMC4ceMo22Vmz56NzZs3c91wCxpa3BEHDhwg/w9dQUREBK6urmhvb0d5eTmePn1Khmf6+vpCVVWV51h+ocX8kJ2dzTe0WEVFBSkpKQBYVvjm5uZ49eoVaVjByw2wM65du9altXJnsNsf2Tb4AItN2rhxI3lz5e/vjz179kBBQYHMkTt9+rTQocXBwcFCOfYBrPNzv379MH36dFy8yMrJO3v2LFauXImWlhYYGRnB1dWV6+ZPWEMOANi7d6/AFvESEhLw8/ODrKwscnNzkZKSQsYJBAQE8K2o/65FPK/Q4s+fP6Nv377Q1taGtrY2mEwmEhMTsWTJErx//x4mJiZgMpkCL7R+1yK+pobzOskuSAEshpC98B01ahQZT5GQkICrV68Kta0dO3YIbVTANuRgt8MzmUxER0eTCwA6nc5VkALwH7eI79OnD/bt24e4uDhkZGTg0KFD8PDwEKggxS+0mB9u3brFN8Osc0GKfS2xsLAQ6jh69OiR0Ew3FSPVOZ4iMDAQxcXFZEFKXl4eMTExQocWp6WlUbYuC4s/i6w/+D+Bly9fYe3aNZg+fRosLCxQXV2D6OgoxMfH4+fPMnz69IkrQyYykpuRYqO5uRknT54Eg8HAyZMn4ejoCFFRUUybNo2nRurYsVi4ublyPKeoqIg9e0JgbW2DOXPmYMuWLWhpaYGuri5WrVqFtLQ0rqwtNs6fP4+9e1lOgrKysmTl9PXr13B1dcX69euhpKQER0dH9O3bFwBn1lZnPHyYSbJ2tra2KC8vR2RkJKKjo/Hz5098/fqVayHDcu3jbgek0WhoaWnF6dOn0dLSguPHE2Fnx1q4aWpq8nTLO3bsGJfl7IQJKti3bx+srKygo6MDLy8vtLW1wdDQECtXrsSdO3egrEyd/3Pu3Dns2sXSRcjLy5P6rWfPnsHT0xNubq6YNGkS7O3t0asXy1mys7NhRzx48IAMLXZ2dkJJSSkiIiJw6NAhlJWVobi4mMtpKSoqCiYmxlyfRaPR0NrKwKNHN9HYKMfhmrVkyRIMGjSIch8CAwO52jp0dHSgo6MDVVVVzJw5EwsXLkR9fT2cnJxgb2+P8+fPQ11dHUePHkVlYwNmGOrCy5+1yG1ubsbBg4ewdu1a+Pv5oUePHpCUlIStrS22b9+Os2fPYvTo0Whra4ODgwN69OiBoUOHwdraGnO1dLE/eCfePnuBzZs3IyAgABcvXuSwiGeHZ7q7u6OoqAjFxcVclVZ/f3/KVhAajYbm5mah240CAwO5XPvmzJmDOXPmoK2tjdTmdO/eHTY2Nli9ejWuXLkikJ13R7S1teHXr19CaaQA1nHZ0SI+NzcXAQEB+P79O6V+i/2dqFp5+SE3N7dLjVRHLFmyBEuWLMGMGTOgpKREugF2Ds+kQlhYGOlKJyi6YqT69+9PFhqeP3+OwMBAFBUVoaioCA0NDULppB4+fEgWyQRFQEAAqYsFWMejiYkJTExM0NzcjH379kFbWxtSUlJYv349lixZglu3bv22RkrY3KDk5GTcuHGDXDCx9Vvl5eVQV1fH1q1buXSg27ZtEzqTh1/7Y+fWPhqNBjqdDjqdjunTp6Nv377Q1NSEtLQ0lxsgFUJCQiiLS/xw7NgxvsxXR11qRkYG1q1bh4qKChQXFwu1HYC1CBRWI+Xv74+NGzeSj2k0GqkBrqurw7Zt26ChoYG+ffvC29sbOjo6uH//vkC28B3Bbn+kKjjyQ1xcHFJTU8nC3I0bN2BnZ4e6ujqeBaldu3YJFVcBsJjuXr16CcRIsQtSrq6umDZtGtra2qChoSFQQQpgLTbZ90eCIjk5GRoaGjxfnzhxIqnfYhekfv36hR8/fvxWrh27CPCv4I8m6w/+56ivb0CPHlIcF4i+fVlhgmPHjoWjowPi4+NBp1th27ZtqKioAAB8/VpAyUi9fPkS8vKslixRUVFYWloiNjYWO3fuJG2sPTw8OfRbrItoNSWNzw4t1tfXR0REBKKiosBkEnBwcEBISAjGjh3LNYaKkWLj8ePHsLe3R0JCAqZOnYrNmzfD2toaiYmJyMx8SHmzRBVazD6ZjRs3DnQ6HUePHgWdTkdISAiqq2sAAPn5nynbLdiMFMBqA7S3t0N8fDyCgoJw8uRJfP/+HRs3bsTnz5855qiykro/Pi0tDSoqKpg3bx6ioqJw9OhR1NfXw9bWDjt27KC8OaZipNh49eoVbGxYmjJFRUW4u7vDxsYGp06dwv37D2Bmxr1wZIXNcoYWKyjIIzCQVTk2NjZBWFgY6HQ6mZ8EsKrhVOYf/4QW10NKSgrBwcHIzs5GVFQUtm/fjvz8fJiZmSEvL49jXGlpKc/Q4qlTp8LOzg4ZGRno3r07CgsLoampCQcHB8zU18OX2nKEH49BC6MVtbW12LlzJ9ra2rFhgxtERUUgKiqGwMAg/PxZhgMHDsDc3Bwp51JgYMDKx3J1dcXFixdxL+02/Ne4YbaaFiZPmoTdu3dDT08PS5cuBYPB4GA/2OGZampqsLOzg5OTE1RVVeHj44OGhgYArEUv1XHJLyCcH4qLiykzuADWxdvFxQWZmZm4dOkSXr9+DXV1ddjY2Ahsmc1Gx9BiQUEVWqysrIyzZ89y6beCgoLQ3NwMgPW7pipo8MPvtD+yLeI9PDzw8OFDnD17Fg8ePICamhrmzJlDqd9ia6SEtYg/deoUx80nP/z111+4cOECtLW1sXTpUpiamkJDQwMhISF89VvA71vE8wstlpCQgI+PD7KyspCYmIjU1FSoqqrC3Nxc6JvP37GIr62t5WKk2PqtR48eYerUqaR+Kzw8HG1tbQBYN3fW1tZCbWvTpk0oLCyEu7s7ampqOF77/Pkz5QInPT2dDOzOyspCVFQUabizdOlSrvMaILwhBxvHjx8XWAuoq6uLa9euQV9fnyxIaWtr/33d5a27Af4zFvHS0tIICQlBdnY2Dhw4gIiICKiqqsLY2Fho45mEhATKTEx+YIcWd+x8mDt3Lm7duoXMzEz0798fhoaG0NHRIfVbAOuazG7RFxR+fn6/ZRE/atQohIeHIzs7G7t27cLevXvJ68mPHz+4xrC6WyooY0L4ITo6WuBIjSVLliA9PR1z5szBxIkTyaxNdtsjP9TV1aFnz55CH0dU+BNG/Af/c1y8eBFTpkyhrBJ2DpvNyMjAqVOnUF1dAyazHcnJyVy5S4KEFn/8+BHR0dEoL6+AouJYjBw5EsXFxZQnGHt7e9LZsCNaWlpga2sLZWVlfPjwEXJysrC3Z4XcRkVFoWfPnpTCdKrQYgaDgSNHjuDixYtQVFQk2wDZCA4Ohq6uLuUJ2srKCvHx8eR3vH37Ns6dO4fa2lowmUwkJydzVabc3d2xdu1arjbHjnP05s1bHDsWg6qqKkyYMBGjR49Gfn4evLy8uPbBwcEBu3eHUIYW29jYYuzYMfjy5Qvk5eXh4OCAUaNG4dixYxATE8fq1RYCzVFTUzMOHz6E1NRUjB8/nkO/BbAqwJqaml2GFjOZTFy9eg2XL18iRb4nT57kOqFyhhZPBPDPccYOd7x//z52796NyspK6OjoQFlZGdnZ2ZSV3ilTpkBFRQV79uzB5cuXyfDPlpYWTNefiZETxuPb92/4/v07wsPD4evri7a2NjCZBLp3p2H//v1wdl4DaeleEBUVBUEQSExMgqioCA4fPgwFBQXMmzsP0fvCce4462Zp06ZN8Pb2JsM/16xZAz09PaxYwW0I0zGwkslkIjIyEidOnACDwUBbWxuePn3KNUfLly/Hli1beC6YqHDx4kVcu3ZN4NYrgLVImDp1KpSUlFBQUCBQuwwgWGhxZ6xfvx7q6upd3oi3tbWR4ZksU5VWPH/+XKgLM1VIaFfgFVrc1taGv/76C2PGjEFxcTEmTZqEwMBAyMvLIzw8HNXV1UIJ56uqqrBs2TLcu3dPqP1TVVVFVlbW30xwK0JDQ3H58mVISEjAxcUFy5cv5xpjamqKdevWCSXSv379Ok6fPk2e+wQBk8nExIkTMWrUKJSWlmLGjBnw9/fnq98Cug4tpoKXlxeUlJS6ZHkbGxsREhKCmzdv/t1h0EK5UOYHdlB0UlISjh07hvb2dpiamkJRUREJCQlISkriGsMrtJjJZGLChAkYPnw4Kisroa2tja1bt0JaWvpfCi3m14LG7zvRaDQ0NDRg+/btuHv3Lvr06UOp3wIACwsLWFtbC2Uacu/ePURGRiI5OVngMUwmE+PHj8fw4cNRU1MDfX19eHt7d8mW6OjocDBSgmDr1q1QUFDoMrSYrd/KzMxEz5490dDQIHSo8u+cj/iFFqempmL//v349esXqd+SkJDA8ePH8eLFC6FCixsbG2FoaIiHDx8KtX8dQ4vLysoQGBiInJwcKCgowM/Pj9I9MC4uDurq6kItAnmFEf9hsv7gf45v375RLrBevnyJgQM5TQJ0dXUREREBefkB0NbWJil9diAnv0rb9evXySBVRUVF7N27FwkJ8VBXV0dkZCRevnyJuLh4MBgMckxTUzPa29t5hhYvWLAA3t7eSEiIh62tHaKiokGnW+H06TOU9vEdnQ07QlRUFDU1NQgKCsK2bdvw6NEj0OlW8PLyQl5eHvLzP1MusDqHFtNoNMyePRuRkZEYMEAe06dPh52dHZydncmbJbatK5WOrKNF/IQJKti/fz/i4+OhoqKM8PD9eP36NZKTk8mqK/APa8crtHju3Lnw9/dHQkICzM3NceDAQdDpdJw+fRoLFsznGsMOLe48R5KSEmhubv7bjtsPt26lgU63gre3NwoKCpCXl0e5wOpsEU+j0bBo0UJER0dDTk4OEyZMgI2NDdaudeG4wHCKjOvJ58+ePYupU6cCYF00r169ikePHmHcuHFwc3PDs2fPcPToUY6qa2trKyQlJbF8+XKYm5tj48aNEBcXR9Wvevge2AuDpQsRFByEI0ePol8/WWzZ4gMGgwEGg4FDhw6y9FguLrCzs0VKSgo2bNiA8vJy2NvbYefOnXj48CHoJqvw1+CREGOw9ASHDh1CdHQ0SktLQafT8fXrVzx//pxygcVif/9hpGg0GpydnZGZmYkbN25g1qxZ0NDQwPz58zlulvgxUrxw4MABoV37wsPDYWxsjFOnTiE7OxsmJiawtbUlLbMbGxu5xlAxUoLgyZMnAlkRs8MzHz58iIEDB0JRUREaGhpYtGgRnjx50uX4q1evCu12xdZIUTFShw8fhpGREc6dO4fs7GzMnz8f5ubm0NDQwJ49e7BhwwahthUcHAx7e3uhxnS2iBcTE8PmzZvx6NEjJCcn49atW1BTU8Py5cs53AALCqi7EvghLCxM6OMoIiICy5cvx6VLl5CVlQVNTU2sXLkSmpqaCA0N5TivsSFIaDEVHjx4IFDbn5SUFAICApCVlQU5OTn0798fampqMDY2xvv377scn56ejrFjx5I27vfu3cOtW7dQXl4OY2NjfPnyBTdv3uQYw+86GRMTg8WLF5PntfHjx2PRokXQ0tLCrl27ONozBQE7tFgYdGakevbsiZ07dyI7OxtHjhxBbGws1NTUYGFhgS9fvpDj8vLyhHZl3LVrl9Duj3FxcVi8eDFu3LiBR48eYdCgQZg7dy60tbURFxdHybgJa8jBxu3btwVipNj6rcePH0NaWhoSEhJQU1ODtbU1vn//3uX4zMxMytBifmAzUrzabxcuXIjbt2/jwYMHkJaWhr6+PnR1dbF9+3ahQ95DQkKE7hTobBHfv39/HD58GI8fP0ZAQAC2bdsGNTU1ODk5obS0lBz38eNHoVk2XvjDZP3B/xQ/fvyAi4sLpkz5C05OjpCT++dm2NXVFRs2bOD64bPYFhuSmaiurkZUVBTevXsPBqMVI0aMxPbt27i2ZW9vj9DQUFLbw0ZTUzNcXNYiIiICycnJf+tVxLFy5Qp8/vwZ0tLSlFVtKrYFYLWLrVu3DjIy/dDa+o9+S1RUFIGBgdDX16dscaHT6UhISOB47t27d9i7dy8KCgowd+5c2Ns7cCxm3NzcsG7dOr6MFMBqN4yIiER+fj6YzHYMGzYM27Zxz5GDgwPpbNgRLS0tcHZ2xtGjR3H8+HFkZj6ElBTLDfDDhw+QkJCAhQU3I2VtbY3o6GiuOSorK4Oz8xrIyPRFe3s7DA1nY+XKFRAREcG2bdugpaVF2eLSmdkEgBcvXiI8fD8KCwuxaNEiDv0WAHh4eMDJyYmyD77jnJeUlCAiIgIFBYXo1g0YNGhQh55sWQCsQgC75aDjsQqwFlK6urq4desWdu7c+ffiVAUbN24kWaCNGzeirq4Oc+fPg/6yRbh+7y6+fPmMLVu2YPbs2QgLC8O9e/fQ0NCAAwcOwMfHB5KSUmhtbUFLSwsuXryI7t27Y+fOnVBVVYWenh5STp/B4R0hUBw2EkuXLkVKSgrXTX56ejp8fHzw6dMnODk5cblmLV++HL6+vl1mguTl5cHPzw9fv36FmJgYBg8eLFQFmD1HwmomeDFSbW1tOHr0KE6dOkVqFS0sLECj0bBu3TpoaWkJld3y9u1b+Pj4CO3I1bECnJubC39/fxQVFUFFRQVBQUGUmjADAwMkJCTw1PZRYf/+/aitrSW1ix3Ba45+/vwJVVVVDBo0CGJiYlizZg1Wrlwp0HdiMwmCwtjYGG5ubnx1EwBLvxUcHIwfP35AVlYWvXv3Fuo4amtrg5aWltBVdy0tLdy6dYtLv9Lc3Iy9e/fi2rVrkJKSgpubG9ma6unpCWVlZaFa+D59+gQ3Nzdcu3ZNqP1TVVUl2YesrCxs374d5eXl0NTUhJ+fH6WJAT9GSkNDA2fOnIGfnx8+fPiA4cOHIzAwEBkZGSgsLMSOHTu4Pk9bWxvXr1/nYmVKS0sxbdo0DBkyBNLS0vDy8uKpH+6I3zmOLCwsSEMmfrhz5w5CQkJQU1ODkSNHgsFg4OzZswJvh8lkQl1dXWjGhxcjVVtbi23btuHBgweQkZHBli1byGu9j48PBg8eLJTNeWFhIRwcHLgWyV2h4/no+vXrZLzJ3LlzsXHjRkqtJD9GiheOHz+OV69eYd++fQKPKSoqwrRp0zB8+HDIycnBz89PIDOjjoyUoLC2toaxsXGXDoYXLlzAoUOH0NjYCF1dXQwcOJDDMVoQ/GGy/uD/JG7fvo1jx2Kho8NqSaDTWQuX5uZm1NTUUlZWrl27hkmT/tH49O3bF5s2bUJCQjy6d++OpqZG0OlW2LFjB6nfYjNSnRdYwD8W8Wwb97i4OOzcuQNPn+YgOTkZT58+5dBvAdzOhh0REREBV1dXREZy6rccHZ3w4sULnllbVNqW8ePHQ1paGtHR0Zg8eTI2b970t34rCQxGG2XWFsAdWiwnJ4etW32RkBAPJpNAbW0t6HQ69uzZg9raWgD8dWTs0GKWfsseCQnxCAgIQHp6OhITk/D69WsO/RYAlJdTM1IAEBkZhfXr1yE6OhqHDx9BXV0tybg9f/6cZ9YWVWjxlCmTISMjg8jISIwZMxYbNmyAjY0NTp8+jba2Np7OhiyL+H/c1hQUFBAYGIiEBBabWV1dDTqdjv3796OhoQQAa5HQ0tLCtcACWFbXS5cuRc+ePbFp0yaMGjUKkZGRSEhIwK5du/D8+XN8/vwZfju3Y77VKqykW2Dvvr0YOXIk4uPjYWxsjMtXrsDT0xNycnLw9PSEg4MjkpNPYOdOVoiira0t1q1bh5ycHOjr6UNWshc+Zz3H2cRk8saJquKur68PBQUFpKWlYdiwYZg3bx60tbVx7NgxMJlM/PjxQ6DQxTFjxuDkyZPIzs5GfX09SktLSQE/FZvUGfws4nmBHyMlIiKCdevW4eHDh7h06RJevnwJDQ0NLFy4EHfu3BFoMdERv6ORunLlCsdvTVlZGSkpKcjOzsbSpUthaWnJpd9iG3IIs8ACWEYUhYWFHFVXgL+z4Y4dO7Bt2zY8fPgQp0+fRkZGBtTV1bF06VKejNvvaqS+ffvW5QIL+Ee/9fjxY3z79g2FhYUk49aVfgvgHVrMD/ws4iUkJODr64tHjx4hISEBFy9ehJqaGlasWIGbN28K7Z7577CIV1dXR2pqKrKysjB58mQsWbIEmpqaOHjwIMm48WOkoqOjoaenR9q4Z2dnw8XFBe7u7ti0aRPq6+u59Ft1dXUAQNn2FhYWRjJuUVFRSExMhJqaGqUulY0vX778lkYqPz+/ywUWAOjp6ZFs0suXL/Ht2zfo6OggJiamS/0WwLI4F9aKnh8j1bt3b+zZswfZ2dnYv38/Dh06BFVVVdDpdFy9ehWOjo5CbcvPz+9ftoifN28e0tLSkJmZiX79+sHQ0BAzZ87E8ePHyTnqipHihZiYGKEZqaioKPj4+CA7Oxs7d+5ESEgI1NTUYG9vT6nfAljnlf+kRfyyZcuQnp6Oe/fu4f3791iyZIlQ2+GHP+6Cf/A/A0Gwbvb79u2DmTNnYubMmWAw2nDq1Km/3aFacOvWLRgYGHCcpC9fvkxZOWlqaoaoqChph3z37l34+vqiubkZYmJiPNsI2KGNHSEjIwMrKyt8//4Njo6OiIqK/luoqQhHR0e+zoYdxdiioqKwtraCtbUVHjx4gJCQENDpVpCTk4WjoyN58x8TE4P167krJx1Di0eNGoXZs2ejpaUFSUlJWLFiBVpampGRkcF1oTh//jylU1dLSwvExcVw8CCrBe3WrVvYuHEjmQfBK0cqMzOTa44GDBiANWvWoKSkBKtXW+LgwYOorq7GxIkTYWdnh8hIamdDgHURZVvES0pKkG2fDx48wM6dO0Gn0yEvrwAnJ0fygsHK2uKuAhIEgcrKSowdOxZjx47FokUL0dTUjPj4eBgZseYoKyuLKyeDnbXVGWxjiCNHjoDJZCI1NRVubs749EkC0tL9sHTpUsrvlJiYiJ49e6KtrQ2VlZWwtLTE8OHDsWfPHhQVFcHW0QEO3h54nvsGRkZGqK9vwKGDB9HQ0ICysjK4urrh8uVL2LFjJyQkJMBgMKCqxnJoYi9qp06divv372NnYDDslhpjzPAReJebS96Q/Pjxg2dVsaSkBFOnTsXUqVNJ16zt27dDSUkJampqlGN4gd3+eOfOHTCZTPKml0ajwdraGnQ6nfLGipdFPD/4+/sL3C7D/u1fvHgRzs7OUFdXx/jx4xEcHCyQ6cPvWMSHh4fztIhfuHAhFi5ciLa2Nhw4cAD6+voQFRWFgoIC5s6dK9R2qqqqIC8vT9r0NzY2YuHChfD09ERgYCDP1r7s7GxS+8BulwFY54ilS5di6NChmDx5MgICAshCj7ChxQCrYv47FvE9e/bEw4cP0drain379kFXVxeSkpJwcXHBsmXLKMedOnXqtyziBXHBHDRoEHmuO3PmDFxcXKCurk62pnZ2A6TCv9Mint0GaGlpicbGRuzevRtaWlro1asXRo8ezfO6lpSUhOvXr3M8p6WlhZMnT2LBggWYNm0alixZgvb2dpiZmcHZ2Rnbt2/n2eLY0SJ+2LBhZAfA/fv34erqiqqqKujo6MDX15dcgPj5+fENl6bCnTt3KAuHXaFXr154/Pgxqd9iuwFu2rSJ50Lq+PHjSE1NFWo7O3bsoOza6IyxY8fi1KlTAEBa0WtoaMDQ0BDe3t4COW9ShRZ3hZ07d1JGQrALUuvWrUNVVRWCg4Nx5MgRyMrKYsKECb8VWvy7FvHsAHoVFRWSebx8+TIsLS3x69cvLFiwAJ6enmTRiO1+KwyysrKEtogXFRWFoqKi0OP44c8i6w/+Z3j37h3XRVlUVASrV1vg3r0M+PsHIDn5BE6cOIF+/frBzs4OI0aMRHs7k5KRio+P57AbZrvJMBgMLF26DLdv38b9+/excuVKss2BHyPFXkgpKipi3z6W1Wh6ejq8vbfgw4cPGDFiBGbMmMFhvMFyW6MOmz137hzCw8MxcuRIvH//ARERkaioqICS0jhUVlZQXlioQovFxcVha2tL2gGfOJGMuLh4DBjQHw4ODhgyZAhPRqqjRTyNRsPcuXMxd+5ctLS0YNmyZfj16xcePXqEVatWkRowKmdDNiIiImBmZkbqt5hMJm7evAkvLy98/PgJo0aNQltbG8fYjs6GnXHhwgWEhx/AmDGj8fLlS+zfH46aGtbCraysDGPGUDsbdrb3l5SUgLOzE16+fAE3tw04deokIiIiMXCgApycnDBw4EAwGAyeOjL2YpNGo2Hx4sVYvHgxGhrkMG6cBsrLy5Geno6NGzeSNzilpaUYMGAAbty4gQMHDuDYsWOYPHkypKWlkX7nDizXOkJ+giLcNnlh165deP36NRwdHfHjRzFWrVqFnJxniIuLhYQES3fm4eGO+Ph4bPH2RmtrK0pLf8LfPwDdu9Fw4/R5pMYnY8qUKbh79y4CAgKgpqaGWbNmoaioiJKROnfuHKZMmcLxnLS0NHbv3o2nT59i927uxSY/7N+/n2SkOodnbt++HZqamn/nzXmTN5vsrC1Bc53YePbsGQ4d4s5L44ekpCRcvnwZ06dPJ8Mz6+vrMW/ePGzatImS8REktLgz2tra0NjY2KVFvIiICNzd3ckw2AkTJuDz58/IyckRuF2GbRHPPh4ZDAbCw8Ohp6eH3NxcSgYpNzcX/fv3p1zwnjp1CufPn4eamhouXLgAc3NzNDU1YdGiRSgoKBA6vDMsLAyxsbFCjeloES8mJgZvb294e3ujtLQUAQEB2L17NwYNGgR/f3/SoVTY0GI2fsci/sKFCzh//jw0NDRw8uRJLF++HAwGAytXroSLiwvlOfF3LeJra2u7tIiXkpJCYGAgAgMD8e3bN0yfPh1Dhw7F58+fERgYSG6XHyPFXkixbdwbGxuxa9cuaGpq4sOHD+TCoCPYWVtUxxE7noLJZCIuLg4LFy4Ek8mEubk58vLyhGaKQkJCyEKAoIiJiSG3w9ZvsfebvdAbPXo0goODyaJdQ0MDCIIQWiP1Oxbx6enpOHXqFPT09DgKUjY2NrC0tKSc165Ci6nA1lt3dfzJyMiQhZf3799DR0cHQ4cOhbW1tcAFqX+3RTz7vNa5IOXk5ITc3NzfCi0W9vf+/PlzUm/978KfRdYf/M/w4MEDyj73pqZmEASBIUMGk/keeXl5iIqKwps3bzBgwABUVFRwOUI9fpxNGchbUVGJYcOG4siRI6iqqkJkZBQSE5MgK9sPDAaDZ1WKyiJeX18fcnJySEpKAkGw2gDFxMRhbLwS+vr6OHYsFq6u67k+ix1azM7VUFIaRy7cdu3ahYqKClhbW2PWrFkwMzMjF24ds7Y6gt3aN3LkSJIRys3NxZEjR/D+/XsMGDAA1dU1XIsIXqHFdXV1GDp0KCIiIvDz509ERUUhJuYY5OUHoK2tnQ8j9ZmjXYBGo2HevHkYOnQoYmNjUV9fDzs7O0hJSZFugFRZW+w5qqysJBdSkydPRng4a+G2e/dulJWVw8aGlVdmZGREnqhTUlKwe3cI1+exjSOUlMaRwuYXL15i3759yM/Ph4KCAurr67kW7LxCixsbf0JRURHp6ekoKCggW4JGjhyJ9vZ2rFu3DmJiYmTrQUJCAnyDA3H27g3k/6qEiIw0kk+cQFNTE75+/Yo5c+ZAVrYfbty4ATExMdQ3NMDMbBXu3r2LPXv2IDQ0FOPHj0d2djbCw8PhbGUDKQZQVVFBLpjYhQR2cHJRURG0tbW5wjMPHz5MefPU2tqKpqYmoW3Y2VlbndGnTx/ywvbx40cEBATA09MT48aNQ1tbW5cOWZ3Btojv1q2bUOM6MlKdwzPZF287OzusWrWKnCNhQovZOHDgAObP5zZv4QcajQZFRUVkZGTg7du3CAgIQFFRESZMmIDAwECeC7bHjx9zuHGJiorC09MT8+bNg5ubGx48eICwsDD06NEDu3fvxrRp0xAQEMCTkfr27RvJYC5btgzLli1Da2sr7OzsUFhYCD09PaxZs4bSKKUzftcinldosby8PCIiIgCAXIiWlJRg2rRpaG9vFzqXjR1aLGzb2pcvX8gigbm5OczNzdHc3IyQkBBoa2ujR48e2LBhA0dMwL59+4RyzgRYxSphDRv69OkDRUVF3L9/H5mZmfDw8EB5eTm0tLTQ2trKxUgRLW0gWtvxNOMhdgQEk89LSUkhKCgIq1evhq2tLU6ePAl/f39Sv6WoqMiVtUUFGo0GW1tb2NraoqGhAXZ2dvjy5QvmzJnDUZDih46dG8IgMTGRMrR41KhROHHiBADW4sjZ2Rk1NTXQ09NDa2vrv2zIISg+ffpEFjc7FqSCg4OhoaGBfv36YcuWLRz3G8KEFrPxOxbxw4YNg6KiIjIzMwUuSAGs4qawjpGCtD92LkjZ29vj69evWLJkCbZu3SqQ0RK7/VFYZv3KlStdHufC4s8i6w/+J2Aw2sBkMiEuLs71Wnx8PFe//ZgxY7Bnzx5YWVlh9erVZBvgzJkzYWFhgYqKSvTo0YMn28Ju7WNV11ntCx8/foSzszMiIyORkZEBR0dH9OvXDwC321pHsEOLR4wYASsrK1RUVCA6OhoJCQkoKiricCdkg521RYUvX77g9OnTkJKSQlJSErlwMzJaztPZ8Pjx41xtBMrKyggNDQWdbgUTExNs3rwZDEYr9PT0YGpqiurqar6MFNtufsCAAeTC6c2bt3B1XY+Kigo8efIUDg725P7wY6TYC6nRo0fDwcEBJSWlpEatqKgI3bt35xpz+/ZtSrc1Go2GgoICnDp1ChISEoiPj4ednR169OgBExOTLhgpzr7+KVMmY8qUA7CyssLChYuwYcMGEASBuXPnwsjICFVVVVxZW//M0R64uLgAAIYPH07ekN+/fx9Lly5FYWEhsrKy8PXrV3hu9EKLpAi0l87Hi2/5LIOGvxfAU6dOhYyMDF6+fAVRURFUVVXByGgFvnz5jKdPn+LXrwa0tbWRFdbkxCScOhKNCWPGISYmhmy16DxHnz9/xqtXryApKcnRLuPh4YHm5mbKgOn9+/cL3X9eVlYmECOlqKiIkydPAmAxsmZmZsjPz8ebN28owzOpEBgYKLRG6tKlS5S5bB3DM9ntMocOHYKcnBw2b978L4UWC4PAwEBSm6GiooKUlBQALCZtypQpGDlyJBYuXAgPDw/yBuft27c8Q4vZLlmqqqp4+PAh/P39sWPHDhQXF6OgoAAHDx7kGnPt2jUu9hdgsUklJSV49uwZxMTEEBAQgL1790JBQQH+/v6U+W9A16HFVBCUkZo2bRouXrwIgNW+5+joiNevX6OiogKurq4C6TT8/f2FdsW7ceMGpcOYhIQE/Pz84Ofnh6KiIvj7+yM4OBhDhgyBv7+/QIxUZ7BDi4XBtm3byCKllpYWUlNTwWQykZiYCFdXVzx//hxNTU1wWGUFWkkNiPJK/PhegBkiPcHMfg9CTga0wbKg9ZEEAPJ7sHMVMzMzsWHDBlRUVKC6uppcrAiCnj17oqamBk+ePAGNRsPWrVvh4+ODkSNHIjg4mOciKiYmRiAtVkcIykjp6elBT08PTCbLfXXTpk2YMGECySgJsnDy9/enjDDhB16hxWw3QOCfgpSHhwcUFRURFBT0L4UWC4Ndu3aR135eBSl7e3uYmZmRc1RYWAhpaenf0kgJc56QlZUFg8FAZmYmGAwGWZCaOHEigoKCeN6jdRVaTIW2tjZSNvHvxJ9F1h/8T3DvXgbu37+P/Px82NnZcVzws7OzcewYN9tSUlKKHj16QF9fH/r6+mAwGDh58iQcHR3x/ft3LF68mHJbvOyBm5qaoKqqip07dyI9PR1btmxBa2srZs6ciWfPnlH2AFMJjWVlZeHt7Y3U1FRkZmZ20G+Ng6OjA2RkZHDx4kWeGqmOrX3W1tawtrZGeXkFXF3Xo66uDl5eXnBwcOA44fJipFgW8ZKYN28e5s2bh5aWFiQmJsLOzg4lJSU854ilkeIWsNJo3TBt2jTs2rWLbANsa2uDgYEBHj9+wlNHVllZyRFarKAgj4CAANy4cQNpabf/zu2pwaRJE0k3wHPnzlFqpDqHFjs7O8HZ2QklJaXYsMEN9fUN2LJlCxwcHDiMUu7du8eD2ayAuLgEli1bimXLlv6t34qDtbUNfv4sxZIlSynn6PPn9/Dz4w7D7dGjB3R1dZGSkoK4uDhEJSWgsKUO8xbMx8OHD9GvXz88efIEY8aMwZQpU1BaWgoxMTH8/FmKWbNmYdiwYUhLS8OhQwcxdOhQpKen4/LlywjZHYKGnxX4+bkAwwawbv6Tk5N5MlIdF1K7du36e58/Y9OmTaiqqoKFhQVHuwzAm5Hih4CAAKxdu1aoMQMGDICOjg7Onz9Ptst0794dNjY2WL16Nc8bnN+1iO/qhrBju8y7d+9gYmKC6upq2NjYICgoSCBGpqKigqfZBD90ZqTYGDlyJGbMmIHz589ztMs4OzvjzJkzHItNgiDQ2lSL1sofKH2Tidx7ihg/oj9Cdm3H4cOHoaioiNTUVOzdu5fUby1evBgeHh4QExNDWFgY4uLiuPahs0X8kSNHALCKToGBgSgpKcGUKVMQGBjIsWg/deoUbt++LdQ8BAUFwdbWVqgxbO1ISkoK9u3bBx0dHUhKSmL9+vV8iwX8Qot5ISwsrEtGavDgwTh27BgA1v/V2NgYNTU12LBhA7Zu3SqQfottEd9VxlJnPHjwgPyds0Gj0aChoQENDQ2kpKTgiO9OrB4/DYOHyWGFhTFSr16FsZURRHoxQFQVg1laCuaoEeg+vB++fPnCEVyvpaWFa9eu/W1OdUyofet8nexYkFq3bh0qKyuhq6sLHx8fjsVRYmIil46sK2zfvh2WlpYCv58dc3LhwgWcOXOGLEjJyMhg8+bN0NHR4TmWX2gxL+zatatLRqpzQWrOnDmora0lWx0FKUj9+vXrtyzi09LSuLKnOhekAgMDcfDgQcjJycHX1xdHjhwROrT4d9sfOxpysAtSly5d4tCldixIASzTF2EdYm/duiW0mY4g+LPI+oP/Cd6//4CTJ0/i8+fPiIqKws+fLL3NsmXLeLrIREREcLT2iYqKkoJgCwsL/Pr1C3S6FWRl+8HOzh5KSuMos7bYiIuLx4YNbgDAsXBLSjqB169fY9euXTA2NuY4qd64cYPD2bAjLl26xBFanJZ2G97e3mhubkFFRQXliTIhIYEyT0tOThZiYmK4ePEiPn36hIiICJSXl0NZWRnLly/n62zYMQBZXFwcdnZ2sLOzg7m5BaqqqkGnW2HAgP5wdHTEqFGjeDobAixGau3atWQbIHvhlpCQgJcvX2Dfvn1YtWoVxw1MWloah9taR1y4cAEhISHo3bs3mEwmrl+/Dnd3979dACvQqxf3jUZSUhL09LgvbAoK8pCQkEBSUhLevHmLsLAw1NTUYPLkyVi2bBlPZ8OICE5DDpZ+yxnOzs4wNzdHaWkJ6HQrDBo0EE5OThg6dGgHZ8N6AJw3TkFBQQgMDEQrsx0Sg/tDd+kCbPb2RlxsLJ49e4bBgwdjwoQJaGhoQHNzM4qKijBlyhTMnj0bffvK4PHjbNTX1yEvLw9Dhw7F2bNnERayFxOHjoQ4TQRRUVFYsGABmEwmSktLKYNT2c6GnTFq1CjywpSens7RLmNnZ/dbGqnnz5+TN9+CIigoCFu3buXSb/Frl7lw4QKZayco2BopYdof2Q6eT58+RXp6OqytrckAVXZ4JhU6MlKCoitGys/PD6KiovDw8ICHhwcqKioQGBiI27dvo62tDVu3bsVE5TH4VZALkbpGvHj0DHqjJ6Ppw3dsmLcAv6pK8O3NI4wZPRL79+9HUlISBg8ejNbWVuzfvx+6uroQFRVFaWkpz6wtKkOOyZMn48KFCwBYNzosY6JmLFmyBNbW1hAVFRW6Avzo0SPKVmh+CAwMhLe3NyQkJODj4wMfHx/8+PEDAQEB2LVrFwYNGoSAgACO88/vGnIIy0ipqqqib9++ePLkCS5dukTqt4yNjbF27VqeVf/t27cLZQ8PsNrneWmk2Dfm4rUMLBg9DmVKA7HBwx0RkZHIfPgQTCYT/fr1w7Bhw9BNkkD75y948CSbJ2uyd+9eynB1foiJiaE0Ueqo34qNjcWCBQtAEARWr15NnpOFXWzevXu3Q9SGYNi6dSu8vLxIXSrAmlN/f39s3LgRY8eORWBgIMeiICMjQ+g2RiaTKTQjNWfOHPTv3x9ZWVk4ceKEwAWpnTt3clz7BQGbkeLH4snIyJCLxNzcXAQEBODWrVsQERGBsrKywA6pvAw5+CEpKYmyQL5kyRIsWbIEra2tOHjwIPT09CAmJgZnZ2csWrTotww5Hjx4IPRxJAj+LLL+4L+O+vp69OzZA926dcPo0aMREsLS02RkZMDNzQ3S0r0RGxuL1atXc7Rt8RJjv3jxEkOGDCFdjD5+/Ijo6GiUl1fg589S0v66I9iVts4W8aKiopCTk8WSJUtgZWWFyMhIHD+eCFlZWTg42OPChQuUJwqq0GJDQwMYGhrg6NEIvH//Dvb29hAXl4CpqQl5AcrKykJ0dDTX53UMLR4/fjz27dsHJpOJ27dvY82aNZCWlkZiYhLMzEw5Lt5fvnyhzNB58+YtBg8eROq33r59i0OHDqGqqgoVFRWUJxdeocXi4uIYMmQoFi5cBEvL1YiIiEB0dAzk5QfAwcEB586d48naMRgMco5oNBoWLFiABQsWIDIyEi9evCD1WxYWFiTdn5mZSTlH5eXl5EKK1QYYDiaTiatXr5Hs2NmzZ2FkZMRxEcnLy6dsQXv37h1p4w6wFhN79+5FbW0dqqoqERwcDKpF1vMXL2Dvvh6jJqmgoLAAAQEBkJKUxNChwzB+/HjSie/169cYNWo09PUN8O5dLnx8fCEnJwt5eXnk5+fhyZMnSIiLB6OqDjNGKJI6JCcnJzg5OSEoKAhpaWlQV1cnXbPYx9Hly5e7ZKTYhQQmk4moqCioq6ujT58+iImJEbhd5uXLl1BQoC5a8MOPHz+4BMWd22X8/f3h4eGBcePGISgoCIcOHRKqRQlgOf2x840ERUeLePbx2NbWhkOHDvFslwGAp0+fCq2Z2Lx5M8+efypnQ1lZWcyZMweNjY1wdXXF9iBfNL7Lgdq4aXB0XItTp84jMDAQcnJySE1NxdOcp3iUdApHD+xHaRWDXEiJiYlh48aN2LhxI3bs2IGUlBSoqalBXl4efn5+pFnKmTNnumx/XLFiBVasWIHW1laEhoZi4sSJ6NOnD86dOwcjIyOB5uF3LeK/fv3KddM1cOBAknF6+vQpfHx8UFpaihkzZsDf3x+hoaFCMzH/ikV8z549OfRbu3fvhra2Nnr27Al3d3cuAf+DBw+ENp7x9vbGxo0bKV/LysrCt6+FsJ80Ey/fZmLturVQUFDAgvnzQTCZWLZ8OUJDQ/Hlyxfo6+vD1sYWVw5EICiO+1jmZxHPD10xUjQajSz+NTQ0YMeOHRg3bhz69OmDO3fuCNwy+K9YxHdmpMaMGUNmtd2+fZssSOnr68Pb2xu7d+8W2oAnLi6OLzNGBXb7Y9++feHi4gIXF5cuC1IAq4jWmZHqCv7+/kJZxCsrK8PV1RXdu3fHsmXLQKfT8evXry4LUr9rEX/s2DG+jJSYmBhZkCovL0dAQADc3d3Ru3dv5OTkCNwFUVdXh549ewp9HAmCPzlZf/BfR3p6OiXlzgqBG2G+XVwAAQAASURBVIRTp05CVFSMtPVOS0vDixe8Gan4+DiOirKioiL27t1LurVFRkbA2toacXHxpF6qc9ZWR1y6dAn29vakO1pCAksDdPToUXz6lEcuTjri+PEEnhflx4+zERoaivj4eGzfzsqrodOtsH79ehAEIRAjBfzT5jBw4CAkJyejtbUFdnZ2cHJyQkZGBt68ecOHkYqBg4MD+VhFRYV0AxMREcHRo0dhY2ODEydOkBksnbO2OuLChfNwcLDHgAED4O/vj4SEeFhYrEZ4eDg+fvyEmJgYMn+LDXbWFhWysrJw6NAhxMfHY+tWP9y6dQt0uhXc3d35zFEklyEHjUbDokULMXDgIJw4kYyKikrY2Nhg7VoXZGdn88zaYs3RMY7j6K+//sKBAwcQF8dyTDt06BBWr16KAwcOkPkix0+fxMwVi3HsTDLU1NWQl5cHLy8vREZG4vLlSxg6dCjy8/Px/ft3rFixEra2rJbEkpISnDx5Er9+/cLVq6lwWbcOuwKCsFJ3NugrTCiNHm7cuIH09HQ8fvwYhw8fRkxMDNTU1GBsbAxRUVGBGSkajQYnJyeMGDECT58+RV5eHjQ0NDBv3jzcv3+f79jAwEChc1EuXLjAU8vDhqKiIk6dOoXs7GyYmprCxsYGz549w5EjRwTK32Lj/PnzQrexBAYGclnEi4iIwM3NDQ8fPsT58+fx5MkTaGhoYNGiRXjy5Anevn3L07WPH/Ly8uDt7Y1Zs2bh9OnT5HGUmprK87e2f/9+BAUFQUVZCcvVJ2LWFB1oas6Ej68vct+9w8VLl8BgMHDp0iV4enjCf+sOGM3QxOpl1Oejq1ev4tGjR8jOzkZAQACCg4OhqqoKW1tb0Gg0gdsfxcTEsHnzZowYMQIZGRlIS0uDmpoali1bhpcvX/Id+5+yiJ8+fTouXbqErKwsaGlpwcjICE+fPkVKSgp5XhMEJ0+eFNp6PDg4mIuRkpCQgL+/P7KyshAXF4ezZ8+Sv9n379/j06dPkJGREfo4evPmDby9vTF79myOoNq0tDTo6Ojg7oVr6CHCxIvXL7Fnzx7cuHEDCcePw9HREVMmT8bChQuhqamJkSNHws19A/JyX+Du+Wtc2VLsrC1hUFdXh27dugnMSPXs2RM7duzA8OHDcfXqVcTFxUFNTQ3m5uZc2YudsXXrVqGNCgRhpAwMDMj8rcGDB2POnDnIyspCRkaGQPlbbCQkJAitKaVipNgFqezsbOzduxcHDx6EmpoarK2t8f37d4EYKSp8+PDhtyziAwMDsXDhQty+fRsPHjyAtLQ09PX1oauri5MnT3LNUWJiotDtusJaxMvJyeHw4cMYOnQoEhMTsWPHDqiqqsLJyYkrV7Azzp07J5DBz+/gD5P1B/91fP/+nbK16cWLlxg0aCBERUWxerUFVq+2QHV1DaKjo3D9+nWMGTMG796949BvsSpt1KHFV69eg46ODtzd3cFgMJCcnEyaSlRUlCM+Pp5rDK/QYiWlcWSeEEuDtQWtrS3Q1dXFqlWrKLO2AJa1d8fWPllZWfKkyzJdACwtLTF+/Hg4OjqRuiN+jJS8vDxp425ra4vy8nJERETizp10KCoqIj8/n0MPxc+x6datW9DS0oaXlydaWlpw/Phx2NnZQVJSEpWVlZQMEq/Q4gkTVDBx4kRMnz4D/frJkPotQ0NDrFy5kjJrC+C2iGfrt9hz1NbWBjqdjkmTJpEMFcCZtdURLNtqOdLGnaXfKkFERCTu37+H8ePH49u3bxxZGOxKG1VbR3p6OjQ1NbF582Y0NDRARWUVkk+dhJS8HEpqK3H0bxe0Hz9+YPDgwaDRaOjWrRvy8vJQVlYGNTU1/Pz5EzY21ujRowc+fcrDjBkz0Lt3b7i5ueF7QSGeXE+Hi50Drl6+QslIlZaWQkJCglxIdXTNWrJkidDaFjYj1bldxs/PD15eXqT4uvPvqqSkRKDQ4o4QlpGaO3cu3rx5g1mzZqF3794wNDSEiIgIbG1tYWFhwfNGgl9oMT90xUhRtcvcuXMHampq+PHjh8BmGZcvX4a2tjZiYmLINsCwsDAMGDAAxcXFuHz5MteYtrY25ObmwsbGBh7r7ZFx7gpCdoSjV69e+FpQgPFKSkhNTcWD+/fx7ds3PH78GAYGBkhPy8SOyN1ob2tFd5F/Ft+dQ4s7tgEuXLiQZ/YfL7x//x5ycnJQUFAg3QCfP3+OgIAAMpctICCAy3Tl27dvQlvEC8NI0Wg0mJiYoKysDJqammhqaiLdANevX89Tmwr8vkV8ZmYmX8vowYMHkxb3WVlZ8PLywuPHj6Gjo4OamhqBbybZi9mEhAR8+/YNfn5+pBtgYWEhkpOTQaush8yAvpg3dy4cnZwQFRmJt2/fYsfOnXB0cGBlBO7ejb59+qCltRUlhcVoKiiGpqYmpKWl4enpCUNDQ8qsra4grEYKYGlH+/Tpg5EjRyIxMREAqw3QxcUF1dXVmDVrFnx8fLgWbp8/f+aZ7cgLwjBSNBoNzs7OEBUVxZs3b/Dx40fSUMjb25svS/W7FvHp6el8LeKVlJRIXe7169dhZ2eH58+fw8DAAI2NjQIft5mZmZT3TfxAxUixC1Jubm6oqKhAUFAQwsPDIScnR8ZTxMbGCq2R2rVrF09XY15ghxZPnToV58+fBwAynqKzLrUjPn78KHTLrsAgCOL/zN/UqSoEQeT8+fv/8N+3bxeJkyc9KV9bv16T+Po1hev59vYnhKWlCvHp00nC03MWYWmpQmzbtowoL79BXL4cQISGmlN+nq3tZKKu7i7X8z9+XCEMDPoSdLoK4e6uS3z4cIJ87cgRO577R6erEAxGNvm4tTWLiI11IVatUiR0dXsRd+7s4Rrj77+QyMwMp/w8S0sV8vvdvLmDcHCYSlhZTSB27zYmPD1nUY5xddUiPn8+QzlHq1ePJ96+TSBcXbWI1avHE7t3GxPV1beJa9eCiZAQU8rPs7f/i6ipSaf4P10g9PX7EJaWKsTGjfpEfv5p8rWoKEfixAl3geaosTGTiIiwJ+eIai6CgpYQGRn7upyjK1cCCDu7KYSNzSQiNNSC5xxt2KBDfPp0ksdxpEw8fx5DrFunQVhaqhBhYRZEfX0GcfPmDmLnzhWUn7dq1Tjy+585s5nw2b6ByK0sJq48e0jIThxLjJmpSsy2MiVUZusQW4+GETIqo4nBMyYSs8yNiEnz9IjlLnZEX+VRhCHdhDj9II34a6EBkfPjK/G6vIgobqghauvqiM2bNxNTpkwhZGRkiPT0dKIzHB0diXPnznE9TxAEoaqqSvk8PyxdupR48eIFz9dv3bpFzJ49m1BVVSV8fHyIhoYGIiUlhXBychJqOy0tLYS6urrQ+6eurk60tLSQj6urq4kNGzYQqqqqxPz584nMzEyuMWvXriVOnz4t1HZev35NLF68WOj9U1VVJa5cuULo6+sTampqRGBgINHU1MR3jJ6eHlFcXMz1/IsXLwgZGRlCVVWVsLe3J0pKSsjX9u3bRwQGBhIFBQWEq+lcQq9PT2LLnDlE4fnzhIWSEmE1YQKh07MnsUZNjTi2Zg2xc8UKwnzcOEKvd2/iZfwRorGmhGNb69evJ5KSknh+p/b2dqHmYeXKlUR2djbP18+cOUPo6uoS6urqxO7du4mWlhbi2rVrhJWVlVDbYTAYv3Wca2pqEr9+/SIfFxcXE3Z2dsSMGTMIIyMj4s2bN1xj3N3difj4eKG28+HDB2L+/PlC79+MGTOI48ePEzo6OoSmpiZx4MABgsFg8B0ze/ZsoqCggOv5+/fvE3369CFUVVWJPXRXwmHCFKLq9m2CyMkh4lxciI0GBoSlsjLhqqVF6PTsSQQtXUqUXb9O2EyaRDSkZxCtjz8RBEEQBQUFhKWlJTF16lRCTk6O+PTpk1Df6XeOo1WrVhF3796lfK29vZ2IiooitLS0CC0tLSIqKopob28n0tPTCXNzc6G2097e/lvHkba2NlFbW0s+/vTpE2FqakqoqqoSlpaWlP+PLVu2EBEREUJt5+vXr8Ts2bOF3r8ZM2YQBw4cIDQ1NQkdHR0iISGhy//BvHnziI8fPwq1ndjYWMLd3V2g975584YwMjIipk2bRvTv35/y3McPampqXf4WOsPKyoq4fv065WstLS3E7t27CXV1dUJXV5c4e/YsQRAEUVhYSBw6dEio7VABQA5Bsa75w2T9wX8VqalX8PTpU9y9exdGRkYwMDAAjUbrkpGaPHkSaeMOsCh/X19ffPjwgbTx7qjfampqBpNJHVp88eIl2NnZwcTEBB8/fuzgBqiIt2/fkkn2HUEVWiwqKgpraysUFhbAwsICWVlZiI9PgJycLBwdHTFmzBjKrC3gn/wf4J82wNmzZ6OlpQWmpqaQkpKCk5MTzMzMSMenzllbHXHjxg1MmDARysrKZCjwrVu3sHHjRnz8+AkWFuZcocC8GCnW592EjY0NVq1ahTdv3uLgwYOorq6GisoEvHr1kpIFpAotlpSUgKOjI8rKymBiYoK0tDRERUVDXl4eTk6OGDFiBFfWFhsdLeJpNBoWLlyIhQsXoqmpGaampujRQwpr166FhYUFWRX/J2uLm5FiW8SzbdyZTCZSU1OxYcMG5OXlgU63ApPJ5GBKWlpa0NLSjL1796KhuQU/fjUiOCQabUwmUlOvknqAhQsXIiAwELGxsRg7dix+/fqF4cOH4+XLl6ipqYGrqxuUlcfj4MGDLO2epBQG9ewDyb9Zhp07d6K6uhp2dnaIjY3Fli1bOMIzX758STIFHfH8+fPf0kiVlJTwbeEzNDSEoaEhmEwmIiIiMGfOHOTm5sLPz49rjvihY2ixoCgvL+cy5OjTpw+phXz//j38/f3h7u6O8ePHIygoCEOGDEFOTo7QmonfsYhnhxazj8eO+i0xMTE4ODjAxMSEY474hRbfuXMHGzZsgK+vL5drVmpqKu7evQtxcXEMl+8PdXtnjBkzBtt37MC3798xbOhQ2NvZ4WxKCsL374eIiAj27N0LXV1dJCedxJtj0Rg6fgYCAgIgLy/P09kwNzeXpyEHP3z79g2qqqo8X1+5ciVWrlyJ1tZW7Nu3D7q6uvjw4QOXK15XOHr0KKUhBz+wXfs6VvYHDhxIsvMd9VuqqqoICAiAjIzMb4UWBwQECG0Rf/PmTSgpKWH16tVYvXo1GhsbyfwtXvotJpOJuro6SkOON2/eYM2aNQgODsal3RF4l50OTw8PzJ49G/fu3cOQIUNQUFiI5uZm2NrYYNiwYdiyZQuL/ZCQRLso67w9bNgwJCQkYNOmTWAymaTDnI6ODnx9ffkyM/wMOfjh8+fPPEOLaTQa7O3tYW9vj4aGBjLs/NOnTzhw4IBQ2+kYWiwoqBipMWPGkG6AaWlpsLe3R21tLQwMDODt7Y2ePXt2yUhRgd1JIAwyMzMxcuRIrFu3DuvWrUNNTQ2CgoJw9OhR9OvXDz4+PlysMduQY+zYsUJtKy4ujpJxpwI7noKdcWdpaYlfv35hwYIF8PT05NtxwC+0mB/ev3/P8zzRUZdaVlZGxlMwGAyh4xOEQTfWAuz/BqZNm0Dk5MT/r3fjD/5DIAgChw4dwrp168g2wNzcd+jXTwajRo0Cg8GAm5sb1zg7OzuEhYVxLZiampqxZo0zZs2ahYyMDIiKimLlypUwMGCZTcjI9IWJiQnX51lZWSEmJobrB3z2bAqOHj2C4cOHY+bMmVi1ahW5cAsICIChoSHlgolOt0JCQjz5+P37D4iJiUFR0Xc0Njbi+PFErhwnV1c3MmurI5hMJqytrZGQkIDy8nJERkYiLy8fAwb0h6KiImpqaig1J/b29hzOhmy0tLTA0dERmpqayMx8CCkpSaxatQra2tqIjo5Gjx49KB2JqOaIyWTi9OnTiIqKwvDhw2FoaAhjY2PyPcHBwdDV1aUMQ+w8Ry9fvkRcXBxKSkrQ0tKCpKQkrv+vu7s7mbXFa45KSkoRERGBgoICDByogPHjx6OkpIRSFO7o6Ihdu3Zz/S9aWlpgb28PdXV1PH78GN27d4e9vT3U1NRw7NgxiIqKY/YKI3wpK4evry/a27ujoWEAqqur4e/nD6+NXujevTsUFBTQ2tqKuXPnIi4+Hj2kpDB9+nR8/vwZ8QkJoHXrhp07dmKe5kysXr6SS3elpqaG7Oxs8vGdO3cQEhKC8vJy/Pr1Czk5OVztMkuXLkVAQECXmqeOOHfuHG7fvi2UY1hrayu0tLQwc+ZMPHjwADIyMtiyZUuXffYaGhrIyMgQysFw7dq1mDVrlkA98teuXUNYWBjKysrQ2NiIV69eCdXm1XnOBYG+vj4SExMpF0zsdpknT55wtMvs27cPTU1NlAs6TU1NpKenc9x0MBgMbN++HeHh4Zg8eTKcnJxw9ch2xIZEkwspFWVlVFVV4fr16ygqKsK6deuwbNkyWNvYIC42FgxGAxgjhyAt6w0OHTqE6upqNDQ04O3bt1z/j5UrV8LT05Pvgqkzrl27hpSUFLIFThC0tbVBVVUV06dPx4sXL0g3QKpcs85zlJaWJtT/1t3dHZMnT+6ydY19XouMjER9fT1+/fqFt2/fCnWD9zvH0Zw5cxAVFUW5YPr27Rv8/f3x/v17DB06FMHBwVBUVMSRI0dQUlLytwkPJ7S0tHDjxg307NkT7aV1QO47tEq0IzIiAhcuXkTfPn2gpqaGN2/fIj4uDqKioggPD8fw4cOxcOY8YJwSug/qw/GdHj16RBZB4+LikJCQAIIgsGrVKjg6OnItplatWgUHBwehFjLp6emIi4tDUlKSwGOYTCb++usvKCsr4/PnzxwFKX7Q1tbGtWvXKIuvvLBlyxYMHz6cQ9PMa58iIiL+1ku3kr81YRacv3MczZ8/H+Hh4ZSFRXZB6tu3b1BSUkJwcDAGDx6MuLg4vHv3TqhiQmNjI2bPnk2Z08gP6urqePjwIWg0Gtra2nDgwAGcO3cOYmJicHJywsqVK7nmyMrKCmZmZkJlaj18+BAHDx6kjDjhBYIg4OnpSRow/Svo1q3bM4IguJw2/jBZf/BfQ25uLqmn6tu3D3kjnJeXDycnJygoyGPbtm1wcnIibar5MVLx8fGYP38+Vq5cCUtLS1RVVSEqKgpJSUkoLCykrGqzs7aoLqBv377Ftm3bMH36dA79lrHxSp6MFEvbwmk2oaQ0Dvv27YWrqxumT5+GzZs3obW1FbNmzYKZmRm6d+/O07Hp+vXr5A0HO5OCPXfr16+HvLwCQkJCYG/vQC4WWlpa+IYWz5kzB2ZmZrC3t8fPnz8RFRWFmJhj+PatkDIHpqysjDK0mEajIT8/H0FBQZg2bToSE4+TboDm5uYCMVJsTJ48GeHh4XBzc8OECRPg7u6O9vZ2zJ49GytWrACNRkNlZRXXAgtg6cjYocUKCvIIDAwAwNL0eXi4Q0FBAWFhYbCzsyOPm85ZWx2RlJQEQ8PZf+sAV8PZ2RnXr1/H0aMRKCwpgV9oGMoam3H+/AXQaN0hKdKKTbYrcGzPDlzauxZzR/dBSYsIDJYvxJ6wozh58iS2+vpCTU0NoaGhKCoqhuv69XC2ssWX7OewDD3MtQ/Pnj3jumlnh2e2t7fj2LFjmD9/PgCWho/tBtgVI0WFw4cPC3UhAliMlJGRESkyp3ID7HyzWFZWxqEjExTPnj3D4cPcc0QFdnjm8uXLMXLkSFK/xYosMOd7g8MrtJgf+DFSAEtzya6uv337FoGBgSgqKkJ+fj6ePn3K9X5eOjJRUVFUVVXhyJEjMDQ0RGBgIMrr6rF5sxdsbOzx9u1beLi7g0aj4VNeHmxtbfHu3TusWrWKZBLa0Q6aRA8sW7YMy5Ytw4oVKyAvL49Zs2ZBXFwca9asIRey379/F2qBBYBn1hY/HDlyBIsXLyb1pjk5OWSle9q0aQgMDOSKKKiqqoKIiIjQGilBLeJpNBrMzMxgZmYGY2NjSEtLQ0dHB1JSUnBzc+vSrZJXaDE/MJlMvhbxQ4cOJef24cOHpHvat2/f8OzZM67319TUcJhN0GR6oE2kByTEWtCtWzdscHPD1KlTcfDgQRQXFcHPzw9OTk54/uIFXNa6gNkoDhHZfwo4eXl5HIYcNBqN1AA3NDRg586d0NTURO/eveHl5UUaWfFjpHhhz549v2URP2/ePOzcuRMAZzwFL/1WQ0MDAAi1wAJY2jBBXPs6xlOYmZmhra2NzN8SpCDFK7SYH/h1bgAs/daZM2cAsIoi1tbWqK+vR1FREZ4/fy7Utv4dFvEiIiJwd3eHu7s7WZBi61K3bt1KugF++PBB6HDznTt3Cr1YevbsGdTU1IQaIyz+MFl/8F/D0aMRsLW14brpampqhovLWhw7dgwZGRk4deoUmpuboa2tjcbGJgwY0B/GxsZcn2dlZYXY2FiuG6mSkhJs2rQJ/fv3R3l5BRQVx8LBwQGysrLw9w/A3LlzKEXXdDqdq1WwqqoKQUFBePPmLSZPngwHB3sO0aerqxs2bHDjanPsyLYA+Dt/Kwn3799HXV09hgwZjP3793PtAz9GytnZGTExMbh9+zbOnTsHBoMBPT09NDQ0QFpaWmBGCmBZxHt4eEBWVpZsA3RwsEfv3r0RFBSEWbNmUTJSVlZWXK2CP3/+xLZt25Cbm4vp06eTznVsuLu7Y+3atVzGG53nqKmpGQkJ8cjKykZzcxMGDhxI2drk4OCAkJAQLqF4S0sLnJyccOzYMVy9eg2XL19Ce3s75s6di7q6OoiLS2D1aguuz1uyZAkWLlwIS0tLREREYPjw4ViwaBFyvxfDd8dONDU1QUJCAg11NfBxWImbsUko/swEo60vGG3tWLXKBKdPxkBCVhTMQSPw7kcrkk6wrIB9fHxgsmIlJg0fDU8XV+Tk5GDu3LkICgrimA9BGSl2u0xGRgaampowbNgwoQTFra2t0NXVFbqNhR8jdfPmTYSGhqK2thaGhobw9vaGlJQU1qxZAz09PaFcm9iht2wzBkGhrq6OrKwsAEB1dTWCgoKQlZUFWVlZynYZgMVInThxQqhMLX6MFC9UVFRAR0cHAwcO5GqXWb9+PdTV1WFmZsY1riOTAACNNSX4knoFB/dHIS8vD3p6enBycoKHpycS/v5Nbty4EXQ6HePHK6GGVgfpiVroLiIOgJXj9PjxYwAg22WeP38OgiCgoKCAixcvCvyd2traoK2tTc65oKBi7dg4c+YMIiIi0NzcDCMjI7i6ukJERAQbNmzAlClThDJTeP/+Pby8vJCamirU/nVkEoqKiuDv74/c3FwMGTIEAQEBZHGnI2bPno2YmBgOI52uwI+R4oXq6mrMmDEDAwcORFtbG8zMzODk5AQRERF4eXlBSUkJNjY25Pvbv1eB+JgHWzc7xMWxrpPbtm2DlpYWevfpg8OHDiE/Px9mC0xh4uODPhOGk2PNzMzg7Ozcpf14YWEhtm7dik+fPkFKSgrS0tJCHUdMJhMaGhpCszfa2tq4fv0610KKyWQiOjqaZMXodDpZkPL29saIESO6ZKQ64uvXr3B2dha6nazj+ejjx48ICAjA169foaioiODgYMpjhR8jxQvHjh3Dhw8fhGKkamtrMWnSJAwePJgsSK1atapLxq0jIyUorKysYG5u3qWD4du3bxEQEICioiLIycmhe/fu/5XjyN/fn8zd+1fxh8n6g/8pGIw2EAST8iYtPj6O7KPV1dWFrq4uGAwGTp48iZSURIwdOwZ9+/bl+KGWlJSgRw/qXIOIiAg4OzuTN1Z37tyBj48vWlqaUVZWBl9fbutglkU8d3VaRkYGBMGyQG9qau6g3xoHBwd7yqwtgG0R/0+QKku/ZU3+9enTB3S6Ffr3l4ODgwPGjBlDmbXFBiu02JBLv5WYmIiTJ09i3DglDBo0iNRvAZxZW1Rz5OjoBG1tLTCZTNy8eZN0A/z58ye2bNnCNebNm7cYMGAA1/MDBgyAiIgIoqOj8evXL+zfH46ammpMnDgRdnZ2lFlbALdFvKSkBJkJZW1tDSkpKdDpdCgoKMDJyQnDhw8ndWRUTlzs0GK2jfuiRSz9Vnx8HE6dOoXx48djzJjRHJWr8vJyyMvLQ1JSEs7Ozvj8+QvWb96ED1U1iEpKAoPRiqamRtjZWuPBmUhcCY8Hk+iF7qJtMDa1QFRUNGKOxWGdiyuUxo1D+p3TKPjyANbWVpipo4sfn75glcF80LrRICkpiTt37qC6upp0zZo5cyZ8fHwEZqR69uxJVm/V1dUhKioKNTU1jBkzBkFBQV22y4SGhmLJkiVdbqcjysrK+IYWz5kzB3PmzCHbZWbPng0ajYaioiKhNVLs0GJhcPHiRY7fWt++fcnF+bt37xAQEIANGzaQ+q3BgweDwWAIHVoMsFot79y5I9SYwMBA+Pn5wdTUlGyXYedv/fjxg7KQQBVaLN6zHwZNUESfPr1w8OBBlJeXw8fXF2U/fyIuLg4WFhb4WVYGZWVlNDVXQ2T4EHKBlZqaigkTJpCf1b9/fzJQWk1NDa2trVBTU8OUKVMQGBjI5QbYGbxCi/mhs7NhZxgbG8PY2BjNzc3Yt28fdHR0ICkpiW/fvgldofb396c8h/HD9evXORipwYMHk26Gjx8/xubNm1FWVgZ1dXX4+flBRkYGbW1tqKurE2qBBQDJycm4deuWUGN27NiBLVu2wNraGo2Njdi1axe0tbXRq1cvfP/+nStriza4Lz7n0dBc3oL1ji5YaLQYeXl5ZIFgkKwCXCxdkM9gYOlaOtqY7Vi1ahWcnJzw5csXgfKdhg0bhuPHjwMAZsyYAYIgoKamRp7XunLW+12LeIA6tJhGo5HRL3V1ddi+fTvJJn39+hW5ublCbWvr1q0888h44d69exyMlKKiIqnfunnzJqnfmj17NjZv3gwpKanfCi0GWPcFwhYSQkJCsHHjRqxZswZVVVUIDg7GwYMHIScnh61bt1Iy2v9pi3i2fgsApk6dCgkJCairq2PhwoXw8PDochGUlJRE5moKCgaDgfb29n/LAosvqNww/ld/f9wF/7/7d+1aMHH37l7K1+h0FaK9/QnX8z9+XCHWrFEjqqrSiJ07VxCWliqEu/tMIjf3OOHnt5DIyjpE+XlsR7rOf0+eRBArV44krKwmEA4O04i0tF3ka105G3Z+Pi1tF7F06RDC0FCGiI9fR7S2ZnG8bmc3hdLZsLExk7CxmUQ+zs09Tri7zyQsLZUJc/NxRGzsWp5z1NG17585SiWcnKYTZWXXiaCgpYSlpQrh5aVH5OefJgICFhEPHuwXao6ePYsili8fRtDpKoSz8wyO8a6uWhwug5xzpMz13NWrQcSyZUMJQ0MZ4uRJT6795+Vs2Nz8kLC2nkg+fv48hli/XpOwtFQm6HQVIibGWag5Kiu7Tjg5TSd+/LhC+PktIObPH0Bs3mxIFBaeJ4KClpLH5acvKcSq9dqExz4LYukaDUJt+Ugi4nIQscRZjVi6ejix2WwkYTd7GHE1wo2wnzOaWDxZiTDVmEYs/UuF+HT7KvHp9lXCeYE+kZG8k3hf/IawtLUm5OTkSCejzq5W7e3tRHR0NKGoqCi021pn177bt28Tc+bMIVRVVQlvb2+ivr6eclxn1z5B4OTkRKSkpAg15t69e8SIESP4ugFS4Xecv/T09Dgc+Xjh6tWrhIGBAaGqqkro6+sTAQEBQm2nvLyc0NXVFXr/eLmtlZeXE3Z2doSqqiqxePFi4unTp+RrRkZGxJMnT7jGNNdXEHRNZYKR/ZAgcnIIIieHaM3KIhLWryeWDR1KGMrIEDd2+BHVHx4TbYx//s/6+vqU7l4MBoNQU1MjH6ekpBB6enqEuro6sXPnTp7HioaGRpduip3h5uZGJCYmCjXm7t27xKBBgwhVVVWeboBU+J3jyMDAgCgsLOT7nvb2diIpKYmYOXMmoaGhQSxbtozw9fUVajvV1dWEjo6O0PvH6zgqLCwkjI2NiRkzZhAmJibEhw8fyNdMTU2Jh9fuEOV3XhD+s5YTy2SGElu05hJvjyQT9Cl6RFt5PcFkMgmCIIhfv34Rvr6+hJKSErFixQqh9q2ja197ezsRExNDaGtrE1paWkRERARPpzstLS2e5ype2LhxIxEdHS3UmLS0NGLAgAGEqqoqsXr1auLLly8Cjfud42jevHlEfn4+3/cwGAzi4MGDpBsgnU4nPD09hdpOfX09oaWlJfT+8TqO3r59S6xYsYJQVVUlrK2tie/fv5OvWVpaErdu3RJqOw8ePCBMTU2FGtPxOGptbSX27t1LaGhoELq6unydY3V0dIjq6mqhtpWamkrcu3dPqDH8gD/ugn/wv8TLl69QWFiAuLh46Ohow8LCAuLi4igpKeGZtB0REYHVqy3Qt29fMhjy48ePiI6OxtOnORATE8Xo0aM5evjZWVtUSEpKREhICIYPH46qqipERkYiMTER/fr1Q2npT57OhlShxQYGBjh9+vTfieSX4eDgAHFxcZiYmEBNTZ0yawtghRZ3rOyMHz+erNIuW7YM2dnZuH//PvT09GFmZgoRERFKZ0M2IiMjYG5u/ncV6h/91uHDh/Hs2TNISUlhwoQJHOwYv9Di48ePIyQkBKNGjcLPnz8RERGB6OgYyMsPQGlpKSUjdfPmTaioTOB4jkajYf78+bh48SIiIiJw4cIFUr9lYWGBqVOn8nQ27BxazHIDDAeTycTy5cvx6FEWHj58iDlz5pCiWSpnQzbYocUKCgqwtbVFTU0NjI2NsXfvXrx69Qo9e/XEEGUV7D2eiKXGJlBUVMSXr19w6uRJnDiRhF49e2BINwbU1Bbhzt37SDmbAisrKygozEBmZhZSUs5hwwZ3jB49GpXllZgweCJ6dWtB6fdiPH36FJKSLLORzlVKGo0GOzs7nDhxQmg3s3379nFkzenr60NfX59sl2G7kllZWcHa2ho0Go0ra0tQvHjxQmjNRFhYGM6fP4/JkydT6reoKv+ChBZ3RmtrK5qamgRipNj6rba2NowZMwa/fv3CnTt34ODgADMzsy6rtFShxV3h9evXGDBgAOVny8rKkk53r1+/JvVbEydOxNevXzF9+nSuMbfuPoKE0l+ol2qDaMMviHeTAI0mCnNzU+TkPISN61acuXMHgVbr0H+AAvz8/DBx4kT8+vWLkqk/dOgQh4OdkZERjIyM0Nraiv3790NXVxcSEhJYu3YtjIyMAHTNSPFCVlaW0IzUkSNHcPbsWairq3O4Ac6YMQP+/v5c+i1AsNDizmhra0N9fX2XjBSNRoO5uTnMzc3R1NQERUVFFBcXIysrC+7u7qRukh+Cg4M52voEwcePH9GvXz/K42jo0KE4ffo0AJbTHFvvoqWlxQoan8fKkXoXykRwKqsNd73HBvQe3g/dO+iwpKSkEBwcjCdPngikZeuIqKgo8pzdWb+1Y8cOaGhooE8flg6b/T5hQ4vZuHfvHsnmC4q4OFY3g66uLod+S19fn3QD7AxBQos7g81IdTVOREQELi4ucHFxQU1NDZSVlTFo0CAsWLAAW7ZsodR/d8bvaKQKCgrQu3dvyuNIWVkZZ8+eBcBivq2srNDQ0IB58+bh/fv3vxVaTMXS80NiYiL53UVFReHh4QEPDw8yVzA0NBTy8vLw9fUl9VvChhaz8eDBA+zYsUOoMb+DP4usP/iPo76+HvLyA+DtvRkMBgOnTp0mA/4YDAbPHumCggIuUaKioiLMzS0gJiYGdXV1sg1w5syZsLCwQHx8HDZs2MD1WZ0t4mVkZEjL3cjISOTn54NOt8K4cYpwdHSEjIwMAODy5UukdXRHsA05ZGRkYG1tBWtrK1RUVCAqKgq7d++GtLQ08vLyuG6seYUWl5SUQl5eHkePHiXd9uzt7SEuLo729nZYWVlRztHXr1+5BLXKysqwtraGqKgoJkyYgI0bN4LBYEBfXx8mJiY4duwY1q9fTzlHHUOLBwwYQArUIyMj8fZtLuh0K0ycOAF2dnbkAunChQuUiwR2a1///v3JFo6SklJERkYgKCgIvXv3QUFBAdfilldocWVlJRQUFHD06FGyDdDa2ubvCyTBM7jw6dMn+P79G1paWnD37l1YWVljypTJEBMTQ1RCAiSGDMPmbTvw/ft3KCqOw5gxo3H2zFk0NPxCW1sb5s/RReXtW8i4lwmAgIiICOTk+gNoRnr6HcjK9kNDwy8MlhuAj1k52ODsBdXZSqivqySF7e3t7ZQXnNbWVrS0tFDeLPLD5cuXce/ePa7n+bXLAICLi4tQ22GHFguLju2PioqKXOGZdXV1HO0yAHDw4EEkJycLtZ3w8HChLeJramowbNgwZGRkoKqqCoGBgWS7jK+vL08DiCdPnvANLaaCoBbxEydOxLlz5wAAmzdvxo8fP6ChoYEFCxbAy8uLXBiHh4fj+PHj6C0/AK2NNWgqLwKzpQntTOCzCAHlJabYYWwHAHj16hUCAwPx7NmzvwtJpVyL0bNnzyI9PZ1rfzrbHfv7+2PPnj1QUFCAmJgY7O3thZqHd+/eQVZW9rcs4tlt39OnT8elS5fAZDJx9uxZGBsbo6WlBUZGRli/fj1ZYAkNDRXK8RD4PYv4lpYWjBgxAvfu3cP379/h7++PwMBADB06FEFBQTwXev9Ji3gtLS1cvXoVTCYTXl5e+P79OzQ1NWFqaorCsh9QVmcFiYtKS1Kej7oy5OCFpKQkSt1Sz549yRvZr1+/km2co0aNgri4OOh0ulDb+fz5879sEd+xIBUZGYl58+ahW7duoNPpZEEKEC60mI3Y2FiOln1BICIighEjRiAzMxPv379HYGAgPDw8oKSkRMZTUOH27dtCayL9/Pzg6enZ5fs6xlOsX78eBQUF0NXVhb29vUAFKbYhh7AW8bxCi2VlZXHw4EEA/xSkiouLMXHiREhJSQkdWlxbW4tevXoJfRz9Dv4ssv7gP47bt9NJ9yFRUdG/XdwsUF1dAxMTYxw9GoEzZ87A3t6evDDx0kgBLA2Xu7s7hg0bBj09PTAYDCQnJ8Pe3h4FBQXIz8/nunFnZ21RIScnBydOnECvXr2Qnp4Ob+8taGlphpaWFtra2ng6G86ePZvjOVlZWWzZsgWfPn2Cl5cXIiIiUFFRASUlJTg6OqG5uZmvRsrCgmXKIC4uTlYCy8vLsWrVKkRFRePSpUtwcHAgHfdYWVvUN8DshdTIkSMxd+5cUr9lZ2eHgoICFBcXczkZUTFSbDx79gzJyaw5unHjBqnfmjWLNf+8nA0NDAw4nlNQkEdAQACsrKywfv16hIXtR01NNSZNmgR7e3s0NzdDQkKC5xyxK3eSkhJwdnaGs7MzSkpKYGGxGrGxcbhx4wacnJzIm4Tc3FyMGzcO3t5bEB0dhUePstDS0gIRMVEcOp6ERWYWGDpkCHr26YP79x/gxo3ruHcvA2Vl5ZgzZza+fPmKa1cuIWDJCvTpMwyvXr1CVlY24uJi0dIiivr6Buhqz0TG1Ru4ceY8zqakoLe0NLaHeaGyvARaWlowMzPjuZDat28fli1bRjnnvFBaWgpJSckuGSlpaWlSp5GXlwcNDQ1UVVXh4sWLCAwM7FK/BbAWCeyFtqA4d+4cpkyZQvnavHnzMG/ePLS1tXHot6ysrARmpDriwoULyMjIEGqMv78/1qxZA4BVbGEvnHJzc+Hv74/v379jwoQJCAoKIs9B7Fw7YS/KRUVFlIwUP+Tk5ODZs2eQk5NDeHg4Zs2aBVFRUTg6OnI4G0r07AeJnv0AsBYW6obLICr+T0V+0qRJOH/+PDQ1NbF+/XqSfVm0aBE8PDzQ0NAgECPVv39/ksl88eIFDAwMUFBQgMzMTIH0WwBrkeDjw62F5Yfr16+TbrQdQaPRYGJiAhMTEw79lpSUFFxcXNDQ0MDzxpQXTp8+LbRGKjg4GLa2tgCAIUOGkAu7rKwseHl5oby8HBoaGvD39yer7PwYKX6gKqbxA41GQ25uLhklsH37djQ0NGD27Nnw8PDguZCKjIwkr9WCoq6uDjQarUtGasSIEaR+KyMjA8uXL0dubi4+ffokkH4LYC0S2A6nguLOnTuULrU0Go28htTV1WHbtm3Q0NAgO2c6FhwFRUJCAq5evSrUmB07dmD16tUAWG6AHQtStra2qK+vx+zZs7Fp0yayIPX161cyo1EYfPz4UShGSkREBIWFhXj48CFkZGQQFBSEgwcPon///ti6dSvPc1tCQgKlcRY/CMpIdSxIXbx4EdbW1lBUVER9fT08PDwE6tRISUkRypDpX8GfRdYf/MdRVPQdy5Yt5Xq+oKAA06ZNw44dO5CXl4eoqCiUl5djzJgxKCwspBQusxmpjhcIUVFR0Ol09O3bF2/evMHTpzlITEyCrKws7OzsoKQ0rktGir2QYle5GAwGXFxcUFFRAUdHJxgbr+S4+Dx+nM2TkZKSkoKysjLZGpOWlobNmzfh8+fP0NTU4gpOZs3FV8oWgZKSEvz111Ts3r0Lubm5OHLkCCorK6GsrIyvX79SinLZjFTHRZS4uDjs7OwwcOBAPH36FBkZGYiJOQZ5+QFwcHDAqFGjcP78eco2kc6hxey2q+bmZri4uKC8vBxr1qyBubk5x3d4+PAh5RyxW/v++usv/PXXX2Aymbh27Rrc3d1RWFgIbW1truBkADwt4quqqjB16l8ICQnBixcvsW/fPtTW1mHKlMnIz8+Hm5sb+vbtA21tbfz69QuLTMyw/0QycvPyIXr9OlauXInU1FS0tjJQV1eP8ePHQ0FhINLT76Bv3z5gMgkQBBMAa7FpsXo1evaQwr17j1D69SXSzl7AiOEjUNVdFH3/vkBUVFQgJ+c5uon0wNy5c1FUVIS5c+dytMsAvBkpfggICMC6deuEGlNfXw8tLS1cuHAB6enpcHJyQm1tLd92GaDr0GIqCGIR37ldZsGCBSgqKsKCBQvg4+MjkIiZKrRYEPCyiFdWVibF16mpqWR45vz585GTkyN0aPGlS5c4DDkEQWeLeE9PT3h6eqK8nJXRVltbi6VLl3K0ywCshS0VI1VZWQlRUVFyUdKxDbC4uFjotisxMTFoaGjgypUrSElJgampKZqbm7F06VK4ubnx/F90ZKQERWhoaJcW8RISEvDx8YGPjw9+/PiBZcuWobi4GCtWrEBAQACHsQ4v1NTUoHv37kJbxPNipNTV1ZGamgomk4nk5GQsWbIEbW1tMDU1RWZm5m+FFv+rFvHbt2/H9u3bUVhYiBUrVqC4uBimpqYICgriYBtOnDghtJPetm3bhGakBg0aBDU1NaSmpiI2NhYLFiwAAKxevRp2dnY8Fw+/YxEfEhLSZbuztLQ0QkJCALAKUqampigpKQGdTqeMp6ACVWixILhz5w6l22vHgtTRo0cxe/ZsdO/eHba2tkhLSxOIkeqI+/fv/3b7I7sjh12Q6ugGqKKiwlGQAljtmcIacuzatUvo9se//voL06dPR2pqKsLDw6GrqwtxcXE4OztTOlKz8enTJ7JA8p/Gn0XWH/xH8ePHD55sS1xcLHmiGDNmDHnBunv3LtLS0hAYGAgdHR1YWFiQi5LU1FRMmTKZ8vMuX77MEVr88eNHREVFo6zsJ37+/InW1lauMfHx8ZR5DKKiomhpacGFCxdQU1ODqKgoHD9+HLKycjAyWs4za6sjI8WGoaEhDA0NYWlpiWHDhv7dBigBU1NTzJqly7cl69ixWLi5uQJg3QSGhoaCyWTi1q1buHr1GoKDg6GnpwdTU1Nyf27cuMEz/+fixYvYs2cPuWB68+YtDh8+jPLycpSVlVGOYTsbdoaEhAQYjDZcvHgRlZWViIiIQFRUNOTl5bFy5Qo+GqkIjpMpjUYj2xMsLS0hJycHOzs79OjRAxYWFlBXV6fM2mIjOjqabINj6bcOgMlk4sqVK7hw4SJ27tyJuXPnIv3efVi5bYBYn76Y/NcUiIqL49u3Qhw+fOjvsMbxGD58OF68eA5p6d5ob2+DouI4NDf0x+2Hd1BZxEBtbR1EutMg0b07vr/JQdzBo5CSYl2gy37+BN3KCqNHDQdDhIme0v3QjSaC9vZ2fPnyBYWFhRztMuvWrROIkeqMly9fIiIiQqgxwcHBJCPVuV1m7ty56NatG4d+C2BV+/766y+httPa2orm5maB2A02+vTpA4Ig8PnzZ3z+/BmBgYFwd3fnCM+kQkBAANauXSvU/rEZqa7QsV3m0KFDuHfvHmpra+Ho6AgTExOBKsgHDhzAiRMnhNq/AwcOkDecHSEnJ4fIyEgA/7QBFhcXY/LkyXB1daXM2gJYTKSjoyP5uGMboKqqqtBtNgEBAeRic8WKFVixYgVaW1sRGhqKmTNnQlJSEi4uLli+fDk55urVq5SMFD+0tbWhoaGB5/+eCgMHDoSIiAg+ffqE3Nxc+Pj44OfPn5gxYwYCAgLIltnOCAoKEvqG6/379122P9JoNFhYWMDCwgKNjY0ICQnBzZs3UVVVBXd3dw4tHD+EhoZS5hnyQ0REBFcXAcByAxQXF0d+fj5ycnLg5uaGyspK6OjoYP369b+lkbp//z527dol1Bh/f39s2rSJ1KXa2dmR8RRU+i2AlYUlrPseqyhLnUnJC2PGjIGUlBQ+ffqErKwsODg4oLa2FgYGBvD29kaPHj0ox23fvl2omAFAMEZKREQE69atw7p161BTU4OgoCBcvnwZ1dXV6Nmzp8DFi127dgnd7pyQkEDJoHZ0A7xy5QosLS3R2NiI+fPnY82aNWAymUIvNtPS0gTKI+sIPz8/kr3y8vKCl5cXysrKEBgYiH379kFBgaVL7XgdKygoELod9l/Bf74h8Q/+f40TJ5IxZAj3hZJVaaO2vq2rq8PSpUsRFRWF7t27kxqTtLTbuHz5Muzs7LjGNDU1gyAIjtY+RUVF7Nu3FxoamtDU1MSWLT6wtrZGfHw8GAwGABYjxRZ0dwTLIp61kGK3ASYkJMDOzg7BwcEoKSnBzp27UFVVxTGuoKCAsgr/8uVLDBo0CDY2NoiPj8e2bcF4+DATdDodXl5elAs9XhcIdnL64sWLcPToUTQ3N8POzg7Ozs64d+8eaTLRGZ0ZKQCYMEEFoaGh0NLSwrRp0+Hl5QUbGxskJyejra0NACvUc+XKlVyfx7KIZy2k2PqthIR4mJuvgq+vL0pLSxEaGor6+nqOcfn5nylbCXJzcyEvLw8nJyfEx8fD13crbty4CTrdCu7u7pShoOxKW+d2EBqNBnFxcSxcuAAHDx7C5/IKvCwuQdjhw3j16iXu3buPhoZ6lJWVgckEtLV18O1bIb5+/Yrm5hYMHDgQGhoaePLkMSxtHLHMzgrK40dh2NAhOBMXi9iwffhVUwsJCRbD9e7dO5w8eRIJ8fFoairHp6pmaGrpwNfXl1xsjho1CklJScjOzoadnR2MjIzw/ft3bN68mWuOeCEnJ4dnGy0//Pjxg4uRYrfLZGZmIjU1FR8+fIC6ujrmz5+PBw8e4MiRIwgICBBqO/v37+cw5BAEHUOL2e0y2dnZMDY2ho2NDdTV1REQEIDGxkaOcc+ePRO65aPjIkEQiIiIYNiwYTA2NkZKSgqysrKgoaGBRYsWUYYLs8FmpH7HIt7Dw4Pve9htgI8fP8bcuXNhYGCA79+/Y+fOnVyFpCdPnsDExITrM96+fYv+/fsL3W5EFVosJiaGzZs3Iysri7QmV1VVxfLly/H69WuEhYUhKChIqO0cPnxY6DDSjqHFbP3Wo0ePoK6uDiMjI2hqaiI0NJQ8r7Hx6NEjrsJYVwgMDBSKkZKSkoKqqiqWLl2KY8eO4cyZM1BTU4OJiQk+fvzIc9zvaqSSk5Mp96+mpgY0Gg1SUlLQ0dHBtWvXkJWVhfHjx0NVVRU/fvzAkSNHwGQyBdpO59BiQfHlyxcu7RI7niI7OxuHDx/GsWPHoKqqCnNzc3z58gV79uwR+jiKiYnBrFmzhBrDDi3u2bMnDA0NcfPmTTx69AiDBg3C3LlzoaOjg7i4OK45unv3LuV1lx+2bt0KLy8vgd/fp08fLF68GAsWLMCePXsQFhYGNTU1WFtbo6ioiOe437WIj42N7TJSY9GiRbh9+zbu379PGm2VlJTg1KlTAh9H/4pFfOfzRP/+/XH48GE8fvwYAQEB2LZtG9TU1ODk5ITS0lJSz/nfwh8m6w/+YyAIAs3NzTh//jyOHo3AmDGj4eTkBFlZWVy5cgV//UWt27h8+QrCw/dDVFQUlpaWsLS0RFVVFQ4fPoK8vHz4+/vDzs4eSkr/tFB0zNrqjMePs8nQYrZ+i2220dzcjO7du3ONoWKkAEBJaRz69x+AhIR4pKWlwdvbG62trZg1axbGjx+PgQN5sXbx2LDBjXzMFtkzmUyYmJjgypUriI+Px/jx4+Hg4Ii+ffvgxo0blM6GAKsVad++fWQboJ2dHcrLy3Ho0CF8+pSHbdu2wdHRkWPxkZCQwKUjY4NtyCEiIoKWlhYcP34cdnZ25GNejJS5uTnX8xMnTsSAAfKIi4vF9evX4e7uDiaTCUNDQygpKUFenjtrC2AxUh3b4BQU5BEYGEDO0blz53Ds2DFMnjwZdnZ26NWrF27dusWR/9MRFy5cgP/2Hfje0oo2yR4Yp6SE2tpa3L//AEVFRejXrx90dHTw6tUrfP6cj1+/GjFw4CBMnjwJpaU/8elTHtra2vDjRylGDhqI4uJceNpugqSYOJqam3HxwgV4ea1Bwy9ptLa2QkREBATRihrU4Ob9V2iHOLS1tSlNRmbNmoUhQ4bg0aNHiImJIV3JumqX2bZtGwIDAylf44UzZ85g6tSpfN/Tu3dvkklmaySePXsGLy8vgdtlABZTKqxGKiAggNRIdQSvdhk7OzuoqKj8liFHcXExR5udIGAbcsjKyuLAgQMAWIsUthugiooKAgMDORa/4eHhlEUBfqioqBDatW/ZsmXYvXs37t27x9Eus3btWowbN47nQiogIAB+fn5C7V9qamqX7Xfy8vIky8pusczJycGOHTsQEBAgMMN55swZ3L59W6j9Cw4O5jLkoNFoMDMzg5mZGZqbm7F3715Sv+Xm5oZRo0b9liFHQUGBQA5wHREWFkaGFrPbIB8+fAgPDw+Ul5dDU1MTfn5+HJqUiIgIoV3dqqur0d7eTtn+uH37dlhbW3M8R6PRYG1tjYiICNy+fRu7du2ChoYGevfujY0bN/LVaPn5+QmdR5aWltalIcKoUaNIFvjOnTtwdnZGdnY2oqKi4OPjIzDblpiYiOvXrwu1f9u3byc1Umx01m8FBweThkJbtmzBwIEDf0sjlZeXJ7QGbvfu3Thw4ADGjBmDM2fOAGDlctrY2KC+vh5z587Fpk2bOM4jcXFxAuWedYSw7Y8iIiJwd3fH2bNncenSJQQHB2P//v1d6rcAFrMpbPtjZmZmlwzl5MmTcf78eQDA+fPnsWrVKvTo0UOohe2/ij+LrD/4j+Ht21xoamqQlH9GRgZ8fX3R3NyM8vJyJCVxt9KwqtUE10lURkYGsrL94OKyFhMnTkR0dDTKyyugqDgWDg4OePz4MaWjVOfQYrZ+i06nw9vbG42NjaDTrSArKwsHB3soKioCYF1EqWj4jhbx7DZABoOBpKQkeHp6YujQobh7NwOzZumSY9iMFK/QYnV1dXIhcvv2bWzevAmtra2oqKjA8eOJXGPYOrLOJz85OTkMGjQITk5OmDBBBYcPH0ZVVRVUVFTg4OCArKws0jK6I0pLOS3ixcXFYW9vD3t7e2zZsgXV1dWg0+mQl5cn9VsA8OXLV/j7c7cSvHnzFvLyLNvqBQsWYMGCBWhqasbx4wlwc3PD0KFD8fDhQ46bFH7Wtzdv3sKMGarw8vIEk8nE1avXyPkqLy9HQkIC15hfTU34VF4Jl4BATJkyBc+fv8Dw4cPx4cMH1Nc3QF1dHZ8+fcS3b99RW1uHHj16YPHiRbhzJwPu7hvQvbsIkpOTISEhjisXz6Oh6DsGSXaDqGQDiDYaJCUk/r55E4WPTxyY7e2ws7eEwhhpFNP6obtYL3QH0K1bN8qFaE5ODgYNGgQajQYHBwc4ODigvr6ebJfp27cvNm3axKU/KC0tFVrnc/ToUdLiWRCMHTsWU6dOxfTp0zF58mSyXcbQ0BDe3t48tSsdGSlh8Pz5czIYlwpU7TKurq5QUlJCVlaWwO0yFy5c4GnIwQu8LOJVVFRIu+PLly+T+q0FCxbA09MT58+fp9RI8UNgYCCcnZ2FGvP2LSsgXFxcnMMNMCAgAJs2bcLAgQPx/PlzrrbP3zHk2L9/P2lcIAimTZsGfX19TJs2DePGjYOJiQlaWlqwbNkyssWRCmyLeElJSaH2ryuLeAkJCfj6+sLX1xc/fvyAn58fLl68iPHjxyM3NxfKysoCbed3LeKpQos1NTVJ/VZSUhKHfsvZ2fm3QouDg4PR1NQENTU1aGtrY+vWreS14sGDB/8Pe+8Z1UTev/+/jEgTFRW7rm1tay+riL33LooNkK6iYBcL1d67gAVQ1LX3XtfuYu+uFUVBuoBITf4PYmYJmUCGe+/7+zvn73WODwQmMwyTyXzeV9MoLQblYKV06dIUK1ZMzb81b948Qd7s4+OjwYRIDeQAWL58uSB91QWdO3fm1atXNGvWjOrVqwsyS2tra+zt7bUubAoaEX/p0iUWLFig9fvFixcXBlKvXr3C09OTc+fO0aRJE8LDw3UeSF2+fFk0kCMvaGOkctZTbNiwQSg7d3BwYOTIkQUqLV60aJHoZ1deUDFSZcuWFdIAc/q3GjVqhI+Pj8aATNfS4tzHJ+az14bBgwfzyy+/8O7dO0n7+U/xc5H1E/81XLt2DXv7f/pAOnbsSMeOHUlKSmLEiJFMnTqFIkWKMHToUOENFhSknZG6des2QUFKRkoV0HDp0iWmTp1GePh7QkK2M3r0KLVQCVXXlhg+f44kJCQYgOfPXxAYuJm4uFhKly6NmVkZ0W3EIuJVC7fLly+zYsUKAgMDCQ4OpkwZM5ydnXn58mWejJTqRiGTyejevTvdu3cnKSkJKysrJk92x/DHA71KXpG7aysnVMyInp4eq1atQi6Xc+bMWSZOnMiHDx/Ys2cPw4cPV2OmAgICtN5MP336LJyjR48esXbtOhITE6hQoYLW2PGtW7doBDMYGRni6OjIjRs3WLx4ieDfqlixAs7Ozjx//pyGDcXP0aFDB4UPNZlMRr9+fenXry9fv35l+PDhTJ48maJFTbCysqJdu7YkpKWzYeduegwaRI/u3Tl27BiRkZEkJibSokULPnwIJz4+jri4eBQKBaNHK1PXrl+/QUpKMpcuXaZzl868fPmS9YsXUsGkKAvmL6Bdu7YUql2HrKhwCn1NRpZZBJDxNfEtm4LWoChZjMtPI7m1MhBzc3Pq1KlDuXLirJ2fnx9+fn5qXytWrJjgbXjz5g2enp7MmjWLX3/9FT8/P8LCwvJlpHJDFREvxSMFSp39pUuX0NfXp3v37sjlcrU0QDs7O6ytrdUecLy8vCR7pKRGxJuamrJy5UrhOvfy8mLy5Mn5+rdA2Qkl1SO1Zs0a+vfvn+fP9O/fn/79+5OVlcXatWtp164dr1+/5siRI0KPmy4ICwuT7JkQkz+WLVtWWLQ+ePAAHx8fPn/+TLNmzfDx8eGvv/7SKRAiJ7KysrR2beWFvXv3cuHCBQwNDYXI9RUrVgj+rUmTJmnIS319fSVHxD99+lQSI1WxYkW2bNnCkydPWLZsGbNmzSI6Ohpzc3O8vLy0+rdAyUhJjYhXvXe0QSaTCaqN1NRUlixZgrm5OW/fvuXq1auSpJPXr1/n3r17gDLhtV+/fmRnZ9O5c2et8edijFTVqlWFRfWVK1dwc3MjPj6e9u2VMujbt28LQ0ldoZI/ig0c80JoaCinTp3CxMQEJycntXoKbQOpgnikpEbE16pVi927d2Nubs6MGTN0HkhBwSPi8wr+0NPTw83NTfhbqdik9+/f8+zZM41KnLxw4cIF0UCOvCAWEZ/Tv3X06FHBo9i3b1+mTp3KnTt3JHnm4J+IeKnX37FjxyQHz/yn+LnI+on/CjIzM1Eo5KLTyh07dmBra4ul5VASEhLZvDmQ0NCdmJmV5uPHj6LJZNpKizt16sTly5dxdHTgzZs3ODk5oa9vgKXl0B9Rw+GiN5bcpcX16tVlxQrlwm3kyJEUKaLP2LFj6dix44//F9Ho2soJZUR8E8G/BUqfjr+/P3fu3KVr1y4kJCRSsqSpsM3372laS4t3796NtbU1VlZWxMTE4O8fwLZtQZQrV5YPHz4QGhoqco40S4tlMhm9evXk9u1b2NnZ8erVK+ztHTA2VhbktmvXjrdvxZMNc5cWN2rUiDVrViOXyxk5ciT6+vrY2dnRrVs3LC0t0dPT0+jayglVRLxKBgjKh8BVq1bz4MEDevToTnJystr5EPORqbB3717BWP7q1WvGTZxIyWo1KFm+HJ8/R+Ln50vhwnrExsbRsGFDoqO/IJdnEx0dQ2pqGn379uHWrVu0bdsWmawwHz9G0KdPb8LDPzDf05OU8Pd8ev6MSi1b8vr1a6HsWVa9NIqMJOTfk3j94gX6jSoj+82CQnrF6fZLIbr1skQul9OkibKLq127dmoyQLlcTlRUlNZwElCXy6jKM2/fvs2YMWNISUnReTpb0Ij43IyUTCZj/PjxjB8/nsTERCHuuHTp0nh4eNC2bdsClRYXNCK+SZMm1KtXT00uM3bsWJKTk+nVq5eGXCYjI6NAHikpEfEquYzqPnTt2jVWrVpFuXLlmDdvXp4yxcePH2stLc4L+TFSTZo04dAhZQHtgQMHsLKy4v79+zg7O5ORkaEz67hu3TqdgxpUECstNjAwYPbs2cyePZvIyEi8vLxYvHgxlSpVwtvbm4YNG3Lr1i1JE2ooeER8vXr1aNWqFceOHUMul7N7924GDx5MZmYmlpaWuLq6qt1PVaXFUgI5AP744w+dGSljY2N8fHxISUnBysqK3bt34+XlRbVq1fDx8cnzwTJ3RLytrS22trakpqbSvHlz9PT06NGjB9OmTVMb1OXHSLVv35727dsjl8sJCgqib9++PHnyhMmTJyOXy3W+bgsaEZ+bkcpZT/H69WshSKN27dr4+voK/WVS0zMLGhFfs2ZNYUCaeyBlb2/PmDFj1M6RrqXFubF9+3adGalSpUqxatUqZs+ejUwmY+XKlXz48IHffvsNX1/fPK/h9+/f/1ci4nMOpNasWUOXLl148eIFs2fPRqFQUKhQIZ32s337dsly3czMTLKzsyWXqP+nKKRQKP6nO8wLLVo0VNy5E/x/fRg/8S/g8uXLmJqaisY/29jYCoxUTly7dg1vb28qVapM7dq1cHZ2FtgSLy8vevXqJbpgsrGxFdgWUH64BwQEcvfuHZKTk1m9eo2afwtg0qRJgrwvJ+RyOWPH2hESEvxDBriTK1f+RF/fgGrVqmFoaCBaduzg4KCWbKjC9+9puLpOEDxFGRkZdO7chREjrNi8eQulSpUUNabb2toKjFRO/Pnnn/j6+lG5ciVBBqhagHh7e9OtWzfRm0/uc/Tlyxf8/f158uQJSUnJbNy4QeOG7+7ujpubm8aUSXmOxhISEiLIAG/cuImxsRG//vorcrmC6dM19dXOzs4sXbpUY8GUnp6Oi4sLQ4YM4fDhw8jlcnr06MGQIUMICgqiaNGiotGuw4YNIzg4GCMjI+avWUupqtVp164dYWFhbN26heLFS9CkSWOePXtO3bp1uHr1GoaGhtjYWGNasiR7/tjD+/fvadnyd4YMGcqqVauY7+tLOWNDShsaEBUVxaZNm35IDJMJDNysEeIyZcoUHB09qFdPnX2Vy+W0bt2a27dvC6lZly5dwtTUlGbNmpGUlCRpipmWlkanTp2wtbUVFti50wDFYGFhweXLlyVJ+FxcXOjRo4dOi7OXL1/i7e3N06dPiY+P5/r165JM+ubm5ty6dUvnnwelfGjXrl2iCyaVXGbv3r3o6enh6OjIyJEjWb58OdnZ2ZKmmLGxsVhaWnLp0iVJx2dubs7NmzeFB4bcchlfX1+NYx8yZAizZs2SJOE7evQox44dE5UAa0NWVhZt2rRhyJAhHDlyRPBviYX/5ESbNm0ERkpXuLm50bJlS50kR2FhYcyfP5/379+TkJDAvXv3JBV0t2rVitu3b+v886CUewcFBYk+bKalpbF06VJOnjyJiYkJkydPpk+fPqxbt464uDhJgTCJiYkMGDBAclWDubk5N27cEN7f165dY9GiRcTFxdGmTRvmzZun0Sk0YsQIJkyYILpgUr3XwsPD8fT05OXLl1SvXp2uXbty5coVUdm1Nsjlclq2bEn37t25dOmS4N/KmQYohnbt2gmMlK6YMWMGderU0SkB8sKFCyxbtowvX76QkJDAkydPJO2rIPejnj17smGD5ucnKP/2fn5+XL9+ndKlSzN79mzatGlDYGAgb968EZVuakNKSgq9evXi6tWrko4v93V08uRJVq1aRUpKiqh/CxBYVbGESm24du0aGzZsYPfu3TpvI5fL+f3337GwsCAsLEyngRQoF/1Hjx7Nt1MrJ44fP06JEiUk93fpikKFCt1VKBQaB/6TyfqJ/wr2799Pv379NKZcnz9/plgxTUYK4OzZs0ISzKVL//i3OnTowLt373RipEA5wfHwmIWbmxsDBw5ky5YtxMbGUrduHZydnTE1NdWabHjixAmhtLhIkSKMHWvL2LG2xMbGMmrUKMqWLcu0adNwdnYWdNG5u7ZyQlVarPqXnp5OaGgojo6OvHv3TtR8LsZIqXDp0iX8/HwxNzfn7NmzzJgxg8zMTLp06cLbt29FF1hisdWqNEA3N3fs7Xuybt06EhISaNiwIY6OjhQrVoyEBPHo25wR8UZGhkL6Y2RkFDY21pQtW5aZM2fh4uIsbJ8XI7V9+3a6desmxGZ//55GcHAw9vYOhIe/Z/78+RrbREdHk52djYubG5nGJsQkfGX5SOXD3K1bt6hSpQrfvqViZGRMbGwMN27E0bq1Un7TrJlSclesmAlTpkwhJSWZ5cuXY1bUmNoli1Pkx7VZoUIFfH19mTx5Mh07dmTZsqUkJSXRrFkz7OzsMDY2Ji4ujnr1NB/S9u3bR8uWLYF/UrNAmarVrl077t+/r7FNXlixYgWDBw8WznVOuUypUqWYNWuWhrFZ19Li3JASEV+nTh12797NoEGDBB9fUlIS3bt3Z9asWXnKZfIqLdYGVUS8NkYqt1zGx8eHdevW8ffff3P06FFJ+/Ly8pLskXr06BHlypVTm8jmlsuMGjVKTS5jaGjIp0+fJHuk1q5dK8kjpdqmX79+av4tLy8vli1bRoUKFfDy8tIYjKm6tqROgG/fvs2qVat0+llVGqClpSUNGjTA0tKS9PR0hgwZgpubm+i9UIWTJ0/q7KdSIb+IeENDQzw9PfH09CQiIgJPT098fX15/fr1f1RarCvESovbtm3LiRMnkMvl7NixgwEDBpCdnc2IESMYN24cMpmMt2/fii6wcnZtVa1aVVhQXblyBUtLS8kLC39/f3r27Cncm9+9e4eXlxdz5syhRo0a+Pr6aiw6CuqRkhIRr6qnGDlyJOXKlRPqKWxsbLCzs8tzIKWttDgvqPzW2hgpU1NTwSf4/PlzoZ7i7du3kgOCFi5cKDkFUywiPrd/q2vXrsJAasSIEchkMv7++29JCyzV8RUkIr5z586CHeDRo0dCPYW2gZSupcW5cf369Ty9dv8t/GSyfuJfR1JSEtu3byc1NZWnT59RunQpHBwc+O233/D09KRv377CA2hO2NjYaEzTMjMzWbp0KZcuXaJmzZpq/i1QTkunTp2aJyOlwoULF9i3bx+RkVGYmZXG399foxQ4P0Zq69atPH/+Qli41atXlyJFilClShXRWFBtjFRkZBRz586levVqvH79mrJly+Lk5MSvv/6Kt7c33bt3F42Cz81IgXIBo0wYu0Lt2rUEGeA/58gdd/e8GSnV/8+cOcOhQ4eIiYmhVKnSBAT4axy7k5OTWtdWzuMYN24c27Zt48GDBwQFBZOYmECjRo3Q19fHzMyMESNG6HyOYmJimDFjBr/88gvv37+nZMmSuLu7U61aNbx9fWnUth2/NlIWDqtMtlWqVCE2NoauXbtx8OABFApo2LAhnz9/pkqVyjx48IBq1arTp08f9u3bh4+PD0VkMjYs8MN9nIvGh6zYOTp69CgnTpwgPj6ekiVLEhgYiEzWBPjnWurUqRP79u3TmManpaXRuXNnyVr31q1b8+eff4oumF69eoWXlxdv376ldu3a+Pj4UL16dUmMlAr37t1j/vz5QiKTrsg5Ac7KysLf358//viDwoULY2dnpyGXAeU52rNnjyS/2NKlS5HL5cyaNUvnbaKjo+nduzc1atTQWS4DBWNHhgwZgoeHR76TWJVc5uDBgyQlJVGmTBkuXryo836ysrJo37695OsoL0bq3r17Qj1Fs2bNhDRANzc3WrVqJako9OnTp3h4eEhe2OY852lpaaxYsYITJ05gbGzMpEmTRP1xeTFS2rBmzRoSExMlSVUTExPp2LEjVapUITo6GgsLC+bNm5enfws0mQRdYGVlhaura76hEqmpqSxevJjz58+Tnp6OqampaOBKjx49CAwM1GCZs7OzadOmjeRFVtu2bTlz5oxoZ9Tly5dZsmQJCQkJdOjQgTlz5lC8eHFmzJhB3bp1sbOzE3lFcbx69Qo3NzdOnjwp6fhy3o+SkpKYP38+V65coWTJknh4eIgm7fXs2ZNNmzZJ8gcFBgby7t07SbLElJQUWrZsSZUqVfj69atOAynV7yT1OrK2tsbGxiZfiaZqIHX79m1kMhnFihXjzJkzOu9HLpdjYWEh+Tpq3749x48fF00wPHLkCOvWrSM1NZV+/foJfVjz5s2jfPnykvy/iYmJbNy4UXISphT8ZLJ+4n+G8+fPM2DAAKpUqQIob5SBgYFER0fz6dMnJk7UjLS+d++e6IdkkSJFiI6OZtu2bZiYmBAQEEhoaChmZmY4ODiQmPhVlJESKy1WTbns7R0wN2+Fs7MzRYroM2yYJV26dOH79+95MFL/BHLk9G+dO3eeBQvmU61aNdLS0hgxYoSwcIuMjMqztNjBwV5IRnv69CkbN24kLi6Oz58/4+bmrrHNgwcPRCPiDQwMiIuLZ8uWzRgbGxMYGMiWLVspX74cjo6OWssYT548qeYLUvq3lLHZDg4ONG6sjEo3NjZm1KhRtGnTRidGCpReEJV/6+TJkyxbtpwaNapTqFAhhg4dKpyTL1++5FlabGdnT7t2bXn37h3e3j6sWrWKmJRvRCSn0NNW+WF95MhhihUzIS0tDQuL1uzatZv9+/dRq1Yt4uMTMDEpRnx8HImJCcyePQcjIyMCAwOIjo5m69rVuNuNJTk2RnSKefbsWbWQAJlMxsCBAxk4cCAODg7Uq1cPOzs7UlLKMH78XDp37kxaWhrp6emicqfly5fnK83KDVX6ozZGqlatWuzatQv4x7+VmJjIhw8fhIAYXZGztFhX5C4t1tPTw9XVFVdXV0Euo/JvqeQyBQ3kKGhE/KxZs4ROrRMnTmBra8u3b9/o1asXM2bM0Fh0KN9r0vvIdI2I19PTY+rUqUydOpUOHTpQvXp1zM3NKV++PHPnzs33NdasWSNaWpwX8ouIb9asmeDf2r9/P1ZWVqSlpfHhwweWLl0qaV9eXl6S+shAec/OyUgZGhoyZ84c5syZw+fPn/Hy8mLhwoVUqlQJHx8fGjRoUKDSYvgnkEMKfH19mTZtGqNHj0Yul7Nr1y4GDRpEVlYWw4cPZ/z48Rr3MV1Ki8Wga2qfsbExvr6++Pr60qFDB0qVKoW5uTnVqlXD19eX2rVr59m1VZCIeFXXlrZSXlXAlVwuZ9u2bfTt2xeFQsHHjx958+aNpH15eXlJGqiA8h6YMyK+ePHiwvWrGkhNnz6dOnXq4OfnR9WqVQtUWgwFj4h3d3fHyclJqKfo1q0bhQsXFvVvgW6lxWL4+++/dfLAlSpVSmCh2rdvT+HChTE3N6dBgwb4+vrmey8MDg6WHBH/7du3PEuLBwwYwIABA8jIyGDt2rV06tQJfX19Pnz4wN9//y1pX/v375fcqfhv4eci6yf+dURERDB48GDh/7Vq1WLZsmXcu3eP9evXM2+eUgbYvn17xowZQ5EiRQgODhbtSVCFTagWUh4eyhvuy5cv8fT0IjExgYULF+Lk5KT2UHvkyFHWrFmt8Xrfv6cBCkHaFBcXR2BgINu37+Dr10StNyRtEfENGtSnfv36rF69mtDQUJycnDAwMGD48OFcvvynVno/d0R8/fr1WblyJffvP2DVqpXMmjWTzMxMOnfujJWVFXp6ehpdW+rnKEH4gFCVBz5+/IS5c+cSHx/PsmXLcXJyVFscHTlyRPQhPD09HblczsSJrsA//q3AwM2kpKSoxdPnxPXr19myZYva12QyGb///jv16//GihUrBRmgiUlRRo8ezdmzZ7VOyG/dukWLFr8jl8sJDAxkgtskzGrW4sHzFwQHBzFjxkzKlDEjPj6BkSNH8scfuwkODqFatWokJydTtWo13r17x+3btzA3b83r16+Fhb9+oUKErlpOQnQ0s2bOJD4+njVr1mBvb68mZzl06JDoA2Z6ejrZ2dlCcezHj9+ZPTuA2bNnk5KSQr9+/UR/pxMnTkjW1Ht6eop2bYlBNUgICwvD3t6eXr16CXKZ/PxboAyYEfNR5oWNGzeKhtWAuFxm6tSpZGRkSC6bjY6OxsDAQLL88e7du2oR8apagaysLNavX0+XLl3Q09PD2dkZKysrZDIZvr6++ZZw5sahQ4ckx+tnZWWRkZHB1q1bgX/kMhERETRu3FhULgMUOCLe2dlZp58dOnQoQ4cO5f79+1hZWdGpUyeMjIxwdXXViRmNiIgQVSvkhdWrVxMcHCz6vYoVKwres7CwMObMmUNUVBR6enoapbb5QSyQQxfcuHFDuF/KZDIhdCc1NZWlS5fSrl07ihYtytSpU4WQEKmlxVDwiPj09HShVuDatWtMnjyZ2NhYihUrpvUc7d69W7L8UaxrSwwymUzocHzw4AEDBw6kTZs2mJqa6uTfAqW8WurD+7Jly7QG8OQcSJ07d05IAzQ1NZUcRZ+UlATwH0XEi9VTbNq0idKlSzNnzhxBzTJv3jxmzJghaT+XL1+WHKwhl8vJyMgQmMPjx48L9RTaBlKgXGQVJCJeF3ZcX1+fadOmMW3aNO7fv0/fvn1p06YN5cuXx9PTU6OeQgyvXr2SXBT9b0HasvgnfiIfREREaJ16BAcH4+3tjb+/P5s3b0ZPTw8nJyccHR358OGDKCOlrbS4Tp06FCtmwoEDB2jVqhVz5sxl7NixBAUF/7j5aXZtKY8hiJ49/0nJUqWjhYQEY2hoyPv377GxsWXRosXEx8cDml1bOeHvH8Do0WN++LfGEhQUxPz587l58yaXL1/i4MGDvHr1Sm2b+/fFGSnV8fn6+hIQEMCmTZtIS0vDwcEBFxcXPn78oLVrS+zhrmHDBhQrVoz9+/fToEF9pk+fjp2dHbt27eLbt29kZ2eLMlIhIeoR8Sr/VkhIMHp6hXn16hU2NrasXLmS5ORkQLkQ0+Yj8/f3Z+TIkRgZGTJunAshIcHMnTuP06fPcPHiJU6ePMn79+/Vtnn8+Am1atXiyZPH2I4dy7WHj/icJSclM4t9+/aRna1sku/WvTtGRoZs3bqV4sVLYGpqSsOGDUlNTeXixYt4e/uwZs0avn79Snx8HAvn+/Hi9k2IjaZ65co0a9YMU1NT9u7dR9WqVXF3d8fe3p59+/bz/XsamZmZoudox44dagvyKlVM2bFjhyCXuH//Pubm5sycOVP4MP78+bPWc5QXHj16xIABAyRts2DBAkJDQ7l69SrHjx/n5cuXWFhY0Lt3b65duya6jS6lxbmh8kjpwkjVq1ePP/74g1u3bpGWlkZYWBitW7fG29v7Rz9e3vi3I+L19PRwd3fn+vXrHDhwgFu3bmFhYUG/fv2EXh4pWLduneSi6NwR8Y0aNeLAgQPcvn2bXr16MWrUKFq3bs2iRYvIyMgAlIyUvr6+5EVCWFiYaMhOXlBdRzdu3GDnzp2cOXMGc3NzBg8ezKNHj0S30aW0ODdUEfG6MFIq/9bNmzeJjY3l5s2btGnThlWrVpGVlZXv9n5+fpIfuPJipIyNjfH29ubmzZts27aNvXv30qpVK4YNG8bz588LVFrs6+sraZvcEfEq/9bNmzfp378/N27coG3btmzcuBG5XHnvTExMpHDhwvnK1HLj6tWr2NjYSNpmyZIlhIaGcuvWLTZu3Mi2bdswNzdn1KhRWnuLcjNSukAKI9WtWzfOnDnDjRs3eP36NTdu3KB9+/YEBQUJ5ygviJUW54c3b95oZaRU9RS3bt1i+fLlrF69GnNzc8aOHcuzZ890WpTmxJIlSyTfj4KCgtQW5H379uX8+fNcvXqV4sWL07lzZzp06MDu3buFcyS1tFiF8+fP4+LiImkb1SDm1q1b+Pj4CB5+FxcXoqKiRLd5//695MqAfxM/mayf+Fdx/vx50UmnUrLwT9hEkSJFhASbXbt2ceTIUWxsbH7IAB2FNMBjx46xevVqjddLTU1FoVBOkVTT+8zMTHbt2sWwYcMwMDDk/PnzGubNvEqLS5cuLUzdz58/j4fHbDIy0klLS2P8ePGHOyUjpR7IYWZmRq9evUlJSWH06NH4+/v/8G/Vw9nZRbRrS3WOcpYWGxgYCJPA3bt3c+DAAWxsbClXrizOzs7ClOrw4cOiBvOcpcUqGWB6ejrbt29nyJAhGBoacu3aNY0JnqqDSPMcRQmyArlczunTp5k6dSrZ2dlkZGRofXARKy2uUKE8Q4cOIS3tO8OGDWfVqtW8ffuGzp074+DgIHRtlfvlF45ducbp8+dZtWoVJUuWJDY2lqGWlly9coXgoGDKlSuLiYkJFhatOXfuHOfOneOXX34hISFBYDeTkr6yceUKyhoYMGv6NKK/fGHKlCnY2NiQmZlJyZKmggwwNTWVbdu2MWjQQAwNDfnrr780pvLXrl3LdY7SgUw+f46hfPnynD59GrlcztatW+nTpw8KhYLs7GzJ8cCq0mKpyBkRLyaXmTZtGnXq1MHX11eQEW3atEmYhOuKlStXavQc5Yfo6GjKly/P+fPnBblM9+7dKVy4MA4ODowaNUr0IeTevXsFiogXC5fJDTMzM9auXQsoH3LXrFkjSS6TXyCHNhw4cECr/HHQoEEMGjSIjIwM1qxZQ8eOHTEwMEBPT0/yw4mqtPg/iYgvX768EIhy7949vLy8iIyMpHnz5vj4+AjvNamlxaDsMJMaEZ+YmEiFChW4fPkyaWlpLF++XGCT3N3d6du3r+h2+ZUWi0EV6pAffvnlF4KCggBlWM3169dp2bIlbdu2xdPTM1+zvrbS4vywe/duzp07p/F1mUzGpEmTmDRpEt++fWPRokVYWFhQokQJjIyMJPmjQDyQQxfklD/WqFFDSEi9ePGiIG/u1KkTc+bMEYajS5cuJTAwUNJ+AgMDJS9GUlJSqFixIleuXOHr169CPUWpUqWYPXu2Vobr8uXLBYqI10X+mLOeYuHChZw6dQpzc3N69uzJjBkz8l0Yq6pUpAZ5aCstVg2k3N3diY2NxdfXlzVr1lCmTBlKliwpya8JytLiEiVKSL6OcpYWN27cWPAOHzx4kJEjR/L9+3f69+8v+LdAOTyUep3/m/i5yPqJfw0KhYJz586RnZ2NtbW1WqjE0aNHRRkpUN5ot27dgomJCS9fvmTz5s3ExMRSs2YNMjOzRBkpsdJiVSnwpUuXWL58OZs3b2bHjh2YmZnh6KiUymlnpPzVplJdu3ala9euZGZmMnDgQLZt20poaChWVsPp1KkTIJ5sqIJqIVWtWjVWrFghnJuZM2fw8uXfXL16jcqVK6uxGqquLW3nKCgoiGLFivH06VM2bNhAXFwcdevWIzMzU9RHJlZabGBggKOjI9euXWfx4kUEBgayefMWypcvh5OTE8bGRbWyLQEB/oL8USaTCSlF37+nMXjwIIKCgtizZ4/g3wLNrq2c2Lp1KxMnTqRmzZqkplpy9uxZfv21FpMnT+bv1284f+cerYqbcuDIMTIy0sjKyqJ58+b8/fcr9vyxBzMzMwwNDWhtYcGN6zc4fPgIy5Ytw8TEhO3bd/D58ye8vLyoV7sWel+/0uAHe1ioUCEOHTpMRMRHZs3y0LiOjI2NcXV15e7du/j4+BAYGMiGDRuoXLkKLi4uGBoaYGhoKHKOkvHy8hKkfTKZTJClpqSkULt2bRYvXoy/vz8zZ84UrqO8IFZanB/yYqS0yWU6derE9+/fJcVmg/J9LdUjlZOREpPLbNiwATMzM+bMmSNIau/fvy+ptFgFVYiDFBw7dozbt29Trlw5jh49Kshl+vTpw7Rp00QZpDVr1miViGpDbGysTvJHfX19pk+fzvTp04mOjqZRo0asXLmS3bt36yyXESstzg9Hjx7Vykjl9G/t27dPSAMcOHAgycnJkv1s+/btK5D8UVVabGhoyNy5c5k7dy4RERF4e3szf/58KleujI+Pj+D1evbsGWXKlJH8cPfhwwc1ebcuOH36NLdu3aJSpUqEhoYyYMAAsrKysLKyYty4caL3WNXAQQp0ZaSKFi3K/PnzmT9/PuHh4fz+++9ERkZy+vRpfH19hbTcvODt7S1Z/nju3Dmt3V6dO3emc+fOyOVytmzZIiy0x4wZQ2JioqQ6CFCWFp8+fVrSNjlLi0uUKCEk3eX2b/n4+AjHI7W0WIU3b97kWSYshqtXrwrVGBs2bKBbt25q9RRix7Bt2zbJMlpdGamcA6knT57QsWNHXr58yd27d3UaSIF4aXF+uHbtmlaGcvDgwQwePJiMjAxWr15Np06dMDAwYPz48cTFxUn+XPs38XOR9RP/Gp48eYKtrS1RUV9+hEoUEdIAjx8/ngcj9Y+0r06dOoLuffr06SQlfWXs2LG0b9+e0aNHCwu3v/4KIyhIk5H6/PkzRYuaYGZmJnwYvHjxgs2bt/DgwQN++60e8fHxGolQ2kqLnzx5SuPGjVm4cCGxsbEEBgYSHBxMmTJltPaliJUWFypU6EeEewa1ar0gIyMdR0dHDAwMsLKyomPHjhw5kjcjpVpIqfxbcrmc6dOnk5j4FTs7O7p06cLw4cOFD++bN29qZaSKFjUWIptBKc9bt24dT548oUGDBnz9+lVDJvfu3XtR6curV3/TqFFjlixZTGRkFAEBSv9WxYoViI6OYc4czUQfuVzOixcvWL9+PQ4ODuzcuZN58zypUKE8aTIZJZ4951NCIj7ePkRFRWFh0ZqKFStx+vRpSpcujZ6eHr//3oJnz55z8cIFihUrholJUYyLGv/4e75j8aLFVChuwjLPeSTHRmNvb0/nzp0pVKgQRkaG1KpVi2LFTBg71lbj+GJiYjA0NOSXX34RYorv3LnD0qVLeP78OY0bNxYpBU7m8ePHor1Fz58/x8LCgv379/PmzRs8PT3x8PDg119/xc/PT/TDQ5fSYjHoykh169aNbt26IZfLGTBgAFFRUbRv356xY8diY2OT7wOEWGmxLtBWWqySy4DyfHl5eTF58mTq1atHRESE5PCF/yQivly5coB6eebatWvp0qULRYoUwdnZmeHDhwvnSEppsQoFiYj/8uUL5ubmHD58mAcPHuDj4yP46Hx8fITjzo38SovFoGtEvKWlJZaWlmRkZNC/f38+f/5Mly5ddPZv/dsR8ZUrVxbue7dv32b27Nl8+fKFVq1a8e7duwKXFkuBKpBD5QFVqTZUaYBt27alePHiTJ06Vc2b+Mcff4gyUnmhIBHxaWlp/P7775w4cYIrV67g5uZGXFwcHTp0YO7cuVoftHUN5MiJ5cuX58tIyWQynJyccHJyIiUlhYEDBxIRESEUi+uyMElKSkImk0n2SGkrLc45kDp79qwwkOrWrRsvX76UHMhR0Ij4hIQEQbWSs57Cz8+P9evXawykQFppsQoFiYg3MTGhRYsWnD59mqNHjzJmzBhSU1PzHEiBOiMl5fjEniFzQl9fX62ewsXFRfJ+/m38XGT9xL+Ga9euY29vh76+PmPGjCYhIZHNmwMJCQkhMjJSiE/OiW3bttG7d2/R14uOjuHAgQNkZ2eza9cunJyc0Nc3oGvXLpiY5MVIqd8o6tZVpgHa2NgyYMAAQQbYsWNHRo4cyZMnT/P0SKnCDczMzIQI0KdPn+Lq6oqnp6cgAyxZ0hRQ79rKjaNHj7By5SqKFTPB3t6emJgY/P0D2LJlC5GRUXz58kWDlVJ1beWGTCYjNjaOAwf2k52dzfbtO3BwcMDIyIhevXrl6ZHKXRDasGEDVq9ejY2NDT169GD69OlkZWXRrVs3LC0tefbsWR6M1Dbc3JTsTYUK5YWF5/37D5gyZTI+Pj40btxY6N8C5ZS3a9euDBw4kICAAJ4+fYr/li30Gz2G/ecv4ObmjomJCSYmRfny5Qu3b//1Y2FciHr16hEXl8DZs2dZtWo1BgYG7N27Rxms4O1DsWImZH//Tv1yZhjp6ZGYkMDBgwfJyMggICCA1NRUJkxwpX//floYqX98ZDnRokULWrRogbW1NW3btsPd3R2FAvr06c3AgQN59uymVk+Jn58fCxcuBKBmzZrs3LkTyFsuk7NrS1fklWyoDTKZjLi4OP7++29SU1PV+rfykst4e3szceJEScd37949nRipnHKZkydPMmrUKMaPH6+1PFMMGzZs0BrIoQ2rV68WZaT09PSYMmUKU6ZMITY2Fh8fH1avXk358uVxdXUtcCDHhg0bJG3j4+MjMFJNmjQR2KQDBw4wYsQI0tLS1OKOQclINWzYUNJ+VB4pKYyUvr4+ycnJvHr1isTERLy9vVmyZAmVKlXCy8tL67DA19dX50AOFZ4+faoTI9WqVSuOHDmCXC5nz549hISEEBcXh6WlJa6urjr5I1etWiUqMc8LmzZtEg12yZkG+OHDBzw9PfHy8qJatWpMmTKlQB6pa9euCeyLrvDy8hKGkO3bt6d9+/bI5XKCgoLo27cvcrmc0aNH4+TkJJzjnF1buiKvZENtMDFRJsW+fPmSL1++CBK7vAZSoGSkpHrFXr9+rRMjpeq5lMvl+Pv7s27dOqKiorSmAYph6dKlkuXOW7ZsEV1glipVShgw5BxI/fbbb8yaNatAHqmLFy9KroTw9PRk+vTpgPpAas2aNcJAaty4cVhaWgrn6MqVK9SoUUPSfuRyOfHx8ZI8emXLlqVBgwY6hbT8N/FzkfUT/woyMzMBhdqDRsmSyhSh9evXA0qJX3R0DLVr18LZ2RkzMzPCwu6IMlKfPn0SFlIymQwbGxtsbGyIj49n7Fg7ihTRY+rUaTg5OapJEcLDxRkplbQvpwwwNHQnTk5OhIeH4+jopLFN7mTDnHjz5g0DBgzAzc2Nc+fOMWvWTDIyMujcuTOXL18WnbgoGSkFxYr9M2krU6YM8+bNZdMmf75/T2XDhg3Ex8dTv359HB2dKFnSlNu3b+XJSOnp6f2QDzjg6OhAdHQ0jo6O6OkVYcaMGWr+LVCyPGKM1MOHDylfvoLg3/r+PY0dO7bj4ODAx48fcXHRnLqrkg3FbpqRkZ/p27cvkydP5vjx4wwcOIhq1arSvXt3zp07x4oVKyhRogTNmjWn3K+1KFvjV5avW0d4+AfOnDlNv/79uXr1GoUKFSI7O5sqVSrz6681ef36NZmZWRQuXJhseTaglAHNmzcPfb0ihKxfS1ZqCi72DlSt+gsGBobCOVJ54SIjIwW2dc6cObi4jKNKlX8WSK9fvxFNl3v69Cnly5dn0KCBDBqk9G9t3bqNsWPtiIiIYMSIhaLnKCoqSlR6pU0uY21tzc6dO4USW12xYsWKAkXEq0qL9fX1hQe2ly9f4uXlxdSpU6lbt66afwuklRarUJCI+O/fv2NlZcW6devYsGGD8OHt4OCgVS4jJZAjJ3SJiDczMxN62Z48eULfvn0pUqQITk5OWtMAc0OsIFwXREREiMa7DxkyhCFDhghymY4dO2JoaMiECRPYuHEjO3bskLSftWvX/kcR8Tn9W3fu3MHT05PIyEhatGih5t8CaaXFKkiVP8pkMkqUKMHgwYPZuHGjWhrglClTtA76srKySE5OlhwRrwsj9csvvwhpitevX8fS0pLChQszdepU5s2bp1PZ6vPnzwskf3z//r3G8EQmk2Fvb4+9vT0pKSmCf8vU1JTp06ezcuVKyR6pgkTEf/36VWCkTExMhIGUqp4iISGBLl26MHv2bDXWShsjlRc8PT0l+WRlMhl16tShb9++rF+/XvBv5aynEMN/EhGfX0dY7oFU165dKVy4ML6+vlrTAHPj34yIz1lPoRpIrVq1inLlyjFv3jwWLVokyA11RXBwsFr3py7IzMxELpdLZsj/bfxcZP3Ev4Jr166LlucCwkJK9Qa+fPkyc+fOJTk5hZSUFLKzszXe3AEBAdjYWGu8VqlSpTA1NSUkJJiXL18SGLiZ2NhY6tatg7l5a60hATkZKeBHGqAtNjbWjB49mnfv3mJjY0uZMmY4OztTq1Yt0a4tFY4ePcrq1asFGaBSCphOUFAQr1+/Ydq06YwYYaU2hQoODqZnT/HYatVCSk9PD7lcLvi3UlNTSUlJEd0mt49MhbJly2JqWpKQkGBBBpiQkECDBg1/yO7Ep9NBQUG4ubkJ/zcyMsTJyQkHBwdGjx7Ns2dPsbE5Tvny5XFxcaZ69eoaXVs5cfDgQVasWIFMJuPbt28MHz6MMWOs2bJlC69evWb27NkMGTGSQ9dvMN1jNgYGBrz8+yW//fYbV65c4+HDR8TExFC7dm2aNWvK5cuXWbVqFYUL67Fjxw6+f//OyhUryMzM4tu3FEwNDahczIQvb98SumM7MpmMCRMmMGTIYI1jq1ChAiVLliIkJJh79+6xbNlSvn5NonnzZrRu3Zpy5cQfzrds2aKWcGdsbMzEia7I5XJGjRpFWNhFtmwJ4ddff8XX15caNWqwZ88e0YV/TuSUyyQlJeHj48ODBw8YM2aMznIZUCa7SY2I9/LyEmWk6tSpIzBBZ86cUZPL9OrVq0A9UgWJiFcxUnp6eqJymTJlyjBnzhy1c1zQQA6p8scGDRpQvnx5bt26xZEjRxg1ahSpqan07duXqVOnav2Az8lI6YojR47kKx3NLZeZN28ed+/eZfz48Tr7t0DJjP1bEfEtWrTg8OHDyOVyNf/WkCFD6NKlS4EWCR8/fqRVq1aStlm1ahVBQUEYGhri6emJp6cnEREReHl54evrS5UqVfD29lbr6tqwYYOGZzM/xMfHo6enJ4mRatOmDRUqVOD69euCfys7O5sRI0Ywbtw4refHx8dHsmzt1KlTWj1SKpiYmLBgwQIWLFjAu3fvmDdvHrdv38bDwwM/Pz+do8F37dolOSJ+/vz5ouyDKuBKLpezefNmYSBlY2NDu3btKFWqlOTr6O3bt5I9UqqIeFNTU8Ha8PLlS7y9vZk6darQv5VzOLt58+YCBXIAon5rbejdu7cQ4rFx40ZhIOXo6MiIESO0nh+V90wKdGGkcg6kHj9+jLe3Nzdu3GDZsmX4+Pjo7LMtSET86dOnJb93/xv4ucj6iX8FT548xtXVVePrnz59olgxdWmfqqxwzpy5GBkZ5vBvWdKtmzINMDw8XFQqpSwtVi6k6tSpI5QCX7hwAT8/X8qVK0dwcDCjRo0S/Ft5MVJHjx6lZcuWuLu7A/D8+Qv8/QOIjY0lKipS6K/Jie/f09R8ZCoYGBigUChwdZ1Ax44dCQgIICgoiLJllWmAt2/f0ppsmLO0WCaT0aNHD3r06CFM/R0cHDA0NGTEiBGCofX9+3eiZuycpcUqGaAqDXDu3LmUL19eSGFU7VOp/dZeWtyiRQumTJkCKBmv1avXkJiYQFRUlOg5Sk9PJyIigkmT3KhRozp///2Kbdu2/pBVFcHR2Zl6rVrjv307Hz5HsnHjRoYPH87jx4/R09MjJSUZU9PiDBkyhGPHjhIfH09mZhbhHz5Qo3oNXr9+jZe3F7JCMrYE+FM4JRnvSZPQ1y+CTFZIuN5SUr6JSi0fP34iLKSaNWtGs2bNkMvlHD16lJkzZ1K+fHkOHDjAoEGDhNdSSRa0lRY3a9aM6dOXAFW5ePEi48ePJzExkejoaO7cuaOxjTYUL16cUqVK4enpSb9+/fDy8mLmzJnUrl0bX19frdNQVWmx1Ij4hw8fEhAQkOfPqK7HrKws/P396devH7/88gshISE6y2VylxbrAm2MlJhcRiVH9vX1LVAgh7e3938UEa8qz8wpl9HX12fcuHEMGzZMbTtdS4tzYu3atcJUXxeULVuW2rVrM336dHr16oWfnx+RkZE0bdoUHx8frSxffqXF2vDXX38JhaZikMlkDB8+nOHDh5OWlsaKFSvo0qUL1apV48iRIzrXFBQ0Il6stLhy5crC/ev27dvMmjWL6OhoWrdujaenZ4FKiwvikVJFxBcuXFhQbaj8W23atKF48eJMmzZNgxUqiEdq1apVosoIbahevTqtW7emRo0adO7cGVdXV+Lj4398hs/RKktTlRYXJCJ+yZIlWr8vk8lwdnbG2dmZpKQk5s+fz8yZM6lRowZ//vmnzoEP/2ZEfJ06ddi9ezegHEg5ODiQlJRE9+7dmTVrFqGhoQUqLZYaEa9ipPT19YU0wPj4eHx8fFi3bh1lypRh7ty5GgMKXUuLc2Lx4sV5vt9zo2HDhvTu3ZuaNWvSpk0bRo8ezffv3+nbty/Tpk3TOtxKSUnJs7RYG65fvy6Z2fxvoJBCofi/PgYBLVo0VNy5E/x/fRg/IRFJSUmMHWtH06ZNcHFxUZOCzJs3j379+okumGxsbAkJCQaU07/AwEBevHhB4cKFMTIyEmSGOTFp0iSmTZumsWCSy+WMHTuWLVu2sGvXLi5fvoy+vgHDhlmSkpLC+/fv1VgaFeztHVizZrXGgun79++MGjWKMmXKkJGRQadOnRgxYgRFihRh06ZNmJmZYWlpqfF6tra2bNu2Te2h8+nTp6xdu46XL1/Qu3dvQQaogpeXFz179hRdMOU8R9HR0QQEBPD69RsMDPQxMDAQpkQ54ebmzuTJ7hrdEMpzZEdAgD87duzg+vXrGBkZMWrUKL5+/crLly+FhVROODo6snLlSo2JmlLGNYKyZcuQnZ1N9+7dGTp0KHp6egQGBlK8eHGsrKw4deo0S5cuoWrVqrRp04aLN2/hsXgpyGRs3ryZEiWK8+DBA4oWLUp4+AdKly5F9+49OHToECYmJsTFxVG1alVatGjOixcviIr6QkpKMr6+vvxaoTyzxo9n+49z9PHjRwICAvj4MUKQUopJE9zd3YVkQ7FztGmTssslLOwOxYqZYGNjQ2xsHE+ePBad+Dk7O7N06VJKlCgL/PMA+P37d9q2bcvdu3c1tskLrVu35urVq2oLpgsXLrBs2TISE5Wl2R4eHmrXrZOTE3369JHUqXXnzh0WLVrEgQMHJB2fubk5p0+fxs/Pj+vXr+crlwHo1KkTe/bskSThW7x4MTKZTOcizpMnT7Jo0SKePHnC5MmTdZbLgPJ3UvWc6YrBgwczd+5crYtHlVwmLCyM8uXLM3fuXD5+/MiZM2ckSS0zMzNp3749N2/elHR8bdq04cKFC2rnYP/+/WzcuJHv378zaNAg3N3d1R5wJk6cSJs2bbCystJ5P0+ePMHDw4Njx45JOr7WrVtz4MABvL29efToEZUqVcLHxyfPRVTXrl3Zvn27JCZV1ZWnS5y/XC5n9+7drF+/nhcvXgiLb12HF61ateLmzZuSWJXhw4fj5uamVQ0SHh6Ol5cXL168oFq1avj6+vLmzRv27t0rRMbrgqysLNq2bSv5Om/bti1nz54VFkxyuZxt27YREhKCQqFgzJgxODo6qv3O06dP57fffpPkiXn16hVubm75SuRyo3Xr1mzfvh0vLy/evHkjpAHmJc/r0aMH/v7+kiR8AQEBhIeHC/7avKAaSIWGhvLy5UtWr16t80AKlPejGzduSLqORo8ejZ2dnVbW7OnTp3h7e/Px40fq16+Pr68vr169YvPmzZIGOHK5HAsLC8nXUbt27Thx4oSwYFLVUxw6dAgDAwPRgdScOXOoVKkS48eP13k/iYmJbNy4UfDQ/y9QqFChuwqFQmNy9pPJ+on/GOfPn2f16tW8efOauXPnkpaWRrt27RgzZgwfPnwQXWDduXNHbapYqlQpQfagmgLa2NhSp05tnJycMDMz0+jaygllRHwzIcZd5d8KCAjg9OkzNGnSmJcvX6rJJJQFqOKlxUFBQYwYMQJLS8sf/q1QnJycMDAw4MuXL6IPpSpGKvdNsX79+pQvXx5bW1uSk5OYNWsmmZmZdO7cGSsrqx9dW5oLrNwR8WXLlhV8QnZ2dhQqpPSqNWjQACcnJ0qUKKHRtZUTyoj4xhgaGgrR4l++fMHf35+LFy/RrFlT3rx5o7bwyJ1smBPbt2/HysqKESOs+P49je3bQ7C3d6BoUWOioqIEnfizZ0+ZPn067bt0YXVQMO+/JuPp7UXPnr2Evoy4uHjS0tIYOXIkR48e5cKFC6Snp1OiRHFsbW3Zt28v3bv3oHv3Hqxdu47a1c3ZsWoFKfHxat6WKlWqCGmAdnZ2P/x8tjRr1hR7e3tMTEwERkpM8nLmzFkaNGggxLiDknUICAjgzz+v8PvvLfj4MULNv5Wenp6jtFjZlwVKFnXFihUaISP5QZmQWVTjoS6nXCYgIIBevXpRqFAhbGxsGDt2LI8ePZLsmZg/f77k4lNVRLypqanQN6R6GM3p38r5Pi2oR0oqI9W7d2+OHTvGxIkThZQ7XeQyeZUW54XPnz/nyc7llMs8evQIHx8fLl68SO/evYmKitLZl1XQiHix0uKhQ4cydOhQMjIyWLlypeDfmjhxIoMGDSIsLEzShBqULKAuC5icOHbsGA0aNKBixYrCdRsWFiakAbZs2RJvb29Kly4tbFOQQA5AEiMlk8kYNWoUd+7cwcHBgYiICNq1a4eJiQmTJ0/W6t+CgkfEh4eHa11gAVStWlXwb127do3Jkydz48YNhgwZQlJSks5Tfn9/f9FAjrwgFhEvk8mEDseUlBQhLMfUVOnD7ty5c76MlBg8PT0lPxifP3+e2rVrq6UBqopuv379KjqQ+k88UrpGxOvp6eHq6srHjx+xsrLi0aNHOvm3oOAR8a9fv85Tlli/fn0hefb48ePY2Nhw7949Ro8eTVpams4DqdylxbpALCI+Zz1FTEwM3t7erFy5kvLlywvy5gsXLkgO5Ni/f7/oEPz/Aj+ZrJ/4j7Fu3To1T0dmZhZ//LGbI0eOkJCQyKxZMzVkDhMnTmTGjJlqD6vwDyMVEhICwKVLl9izZw9paWmULm1GlSqVBWlfTmhjpFJTU5k4Ucl+bdmymdjYOOrWrYuzsxO7d++mbNlyWFoO1Xg9GxtbNR+ZCk+fPmXKlKmUL1+esmXL4OTkJPSLeHl50atXL1H/TU5GCpQP5qobdkJCIp6e8zRuWm5ubkLXlrZzJJfLOXPmDIcOHSIrK4vy5ctTunRpNf+ZCg4ODqxatUqEkUrD1XUC7u7ubNmylcTEBBo1aoSjoyO7d++mRIkSolNtGxtbtm7dorEYePz4MVOnTqVChYqUL1+e9+HvWbVlK3FpGaxesxpDQyM+fvxIxYoVePToEXp6Reg/oD/nz53HyMiIqKgoTE1NsbGx5u7dezx58oTk5CTGjRtPk0aNmD9zBrs2B1CoUCHc3NyZONFVQ8KX+xwdPXqU48ePo1AoqFy5MiYmJqKMlJOTE8uWLdOIr09PT8fFxYUJEyYQEhJCUlIyzZs3w87Ojj/++ANDQ8Mc8bfVAWVFgBgjlR8cHR3p168f/fv3z/dnVXKZkydPEh0dzcGDByXJhwrC3nTq1Il9+/ZpTTA8deoUq1atIikpiR49ejBz5kzWrFlD4cKFdWakQBlXPmLECC5evCjp+HL/Tiq5zO3bt7XKZQYNGoSXl5ckv9ihQ4c4e/aspMSwjIwMOnbsyMyZM1m3bh2pqakaaYBiaNOmDRcvXsTAwEDnfU2cOJG2bdsyfPjwfH82KioKb29vbt68SVRUFOfOnZNUHVCQ6ygvRkoul7N37178/f3JzMxkyJAhTJo0ifXr15OcnCwaSqMN8fHxDB48WLJ8NDeTEBERgaenJ8+ePeOXX37Bx8dHI9rd0tKSKVOmSOrUOnXqVIEYqTZt2jBu3DiCgoLIzs5m5MiRuLi45PlgnpuR0gVTp06lUaNGOiX3qfxbT5484cuXL1y7dk1n/xYU7Drq0aMHgYGBogmGqoHUrl27KFSoELa2ttja2v5QO3zUiZFSISkpiT59+kj2vOa+jp4/f46Pjw/v378XHUgBjBo1CkdHR0l+scuXL7Nlyxah6FkXyOVyWrduzYgRI9i3b59oPYUY2rdvz/HjxyVJ+ObMmUOVKlV0KlJXDaTevXvHly9fuHv3rqSgoFmzZrF48WKdf/7fgDYmS9oy+Sd+Ihc+fozQ+JAsUkSPMWPGUKFCBdauXcO9e/ewsbFl6tSpPHv2DLlcTlJSssYCC+DIkaNqk+FOnTrh7+/P5s2befnyBffvP8DZ2YXz588LP5MfI9WzZ0/q1avLihUrCAkJ5vffW+DhMZu9e/eSkpLyIxnxH0RGRmqNiN+7dy8+Pt6EhAQzduxY/P39sbGxYfHixbx+/TrPZMOcMDAwwMHBgYoVK7J8+XKuXLmKjY0tM2bM4M2bN6JdWyrkLC2WyWT06tWLwMBANm3axMOHj3j48CHjxo3j6tVrwjYqH1lepcUNGzZkzZrVBAUFUa9ePaZOncquXbvJzs4mKysr1zn6J9kwNw4cOICXlxchIcG0bNuWz5nZTJjpQejOUKKjY9DX1ycuLpbHj5/Qu3dvihcvxl+3b5OcnMTXr4lMmDCeQoXgt9/qM2bMGMqUKcOECRO4c+0q891cSY2J5sOHDz98ZOIeqTNnztCgQUPhHA0cOJAtW7awbt06wsLCePToERMmuPLXX38J26Snp5OVlaWxwFKeo+1069aNFi1asG7dOoKCtlGlyi+4u7uzY0coBgaGyOXyHz+dDGhnpPLD48ePdVpggdK/tXTpUmrWrMnWrVvZsGED5ubm2NjYEB4enue2eZUWa0NGRka+EfG9evXi7NmzXLt2DTMzM7p168aSJUsoXbp0jnOUP7QFcuQFsYj4UqVKsWbNGm7dusWiRYtYtmwZ5ubmODg48PnzZ6BggRzr16/Hx8dH0jYqRmrAgAGcP3+ey5cvo6enR6dOnejUqZPA/uZETIzyPSNlgQVKVii39EYbVGmAv/76K0uXLsXLywtzc3MmTJhAbGxsntv+NyLiZTIZVlZWXL58mQsXLpCamkq7du3w9vbWqAHJDzlLi3WFWER85cqV2bZtG7du3WLy5MlMnz6dVq1aMXnyZBITE4GClRavXLlScuG4KiLe1taWP//8k7NnzxIZGUmbNm3o0aOHaLKhrqXFuXH9+nWdvUHVq1cnNDSUevXqMXPmTFxdXTE3N8fDw0NrgJMKZ8+ezTeQIzfyi4iXyWQ/Pguvcvz4caGvcM6cObRv317SvubPn4+tra2kbcQi4uvVq8cff/zBrVu3GD58OPb29pibm+Pt7f3jWaZgpcVLliyRrErYtm0bHTt2xN3dnevXr7N//35u3ryJhYUF/fr1IywsTGMbXUuLc+PChQs4OWmmOIuhUaNGHDhwgAYNGmBvb8+oUaOwsLBg8eLFZGRk5Lnt+/fvJZdY/zfxk8n6if8IQUHBDB48SOPBVOVtycnevHr1ioCAAP7++2+MjIzYsGGDxsOag4MDq1drZ6S2bt3yQwao9G+ZmZlhYlKUhg0bMnSo7ozUp0+fWLBgAb//3pKrV6+gr6/P8OHD6dSpE56envTu3VsnRkoFf39/Dhw4QOXKlencuQsjRlgJD9f5+chUrB0oP9y3bt3KmzdvMDIyIiAgQOPc5sdIbd26VZABvn37jvLly1GsWDFq1aolOtXWxkhFRiqn282aNeXmzZsYGxszatQo2rRpg7e3N927dxeVuAwfbsWOnaF8+Z6Oz7IV9O7dixo1a7Bv7z7+/PMyCoWCdu3a8/TpU0qUKM67d+8pUkSPWbNm8fHjRw4fPkxi4ld69OhO7969WTR/PkGrV1FcXynBu3//AUFB2wgPD8fY2JjNmzdrXC/5MVJBQUF8/vwZf39/wsM/ULlyJUqUKEHlypU1+rFA6bVTpT/mRExMDLNnz6ZRo8bcuaP0b40Z40CrVvY4ODgwcOBA+vbtq/F62hAWFsaSJUskRberppG3b98Wvnbu3DmWL1+uVS4D+TNSYli0aBF6enqSkqiioqKwtLTk999/5/r165iZmTF37tx8H0YLMtUeOHAg3t7eOi2Yjh49ypo1a/j48SPFihXj+vXrOstlVIyUVBmLhYXFD7+oJmsVHR2Nj4+PMLVVyWUmTJhAhw4ddF4wgXISPG/ePI4cOSLp+Fq1aqV2Han8W2lpaQwaNAg3NzeNY+/SpQs7duyQJOFbuXIlqampkhIW4+Li6NOnDw0aNODx48dCGmB+IRgF8bZYWloybdq0fBMM5XI5oaGhbN26ldjYWIyNjbl586bOg5WsrCzatWsn2WuXFyMVHh6Op6cnL1++pHr16vj6+lKrVi2mTJlCkyZNsLbWTO3VBpVP98SJE5KOL+d7V1VPoaoRGDNmDA4ODhp/j7wYKW3YtGkTERERLFiwQOdtvn79SufOnalduzbv3r2jTp06GvUU2n4nqdfRyJEjcXZ2zldal5WVxcaNG9mzZw8pKSkYGRlJ2te/5ZHKiSdPnuDt7U1ERAQNGjTA19eXihUr4uHhQbVq1SR12717945x48bpLLVUIef9SOXfOnz4MAYGBowfP170mW/p0qXY29uryYz/F/jpyfqJfx0KhYKUlGTRyf+RI0dp3lzdq1CrVi2WL1+Og4MDQ4YMEfxbHTp0YPTo0WRmZqJQIMpIKUuLlZGtpUqVwsND6d968eIFEyZM4P3797x69QpnZ+cfpbXiyYYqKCPibWjVqhVjx9oSGxtLYGAgwcEhfPz4QXRyJ8ZIqfDs2TO2bNlC+fLlCQ0NxdHREQMDA4YPt9LqIzt+/DhNmjRV+1r9+vVZuXIlDg4O9O3blxkzZpCZmUmXLl0YPnw4mZlZWj1SOUuLy5UrJyQTPn78BDe3Sbx69YqIiAgcHByEv1lejJS/vz+2tja0bt0aZ2dnIiOjCAjwJzBwMx8/fsDGxlZjm0ePHpEKWE1yp1iJEsTGxgpM08uXf9O0aTPev39PbGwcCQnxJCTEY2U1nAsXLlCxYiUqVqzE5cuXmTp1GmFhf+E5ZTIWDRsICyyApk2b0LTpWhwdHenSpQvu7u7I5XJ69erFkCFDyMzM1MpIhYSECNLVihUrCpO/u3fvMm3aNKpUqUJMTIzg3wKlbM3IyEjrObK2thY6PD59+sSmTZuYMiWAly/fMmfOHI1t8sL8+fMlPTCAeGlxt27d6NatmyCX6dmzJzKZjLFjx2JjY0NGRgYZGRmSFligXJj8+eefkrbx8vJiypQpDBo0CPgnDdDd3Z3ffvsNPz8/jdS3e/fuFSgiPioqSmdGSlWe2blzZzp16iT4t3SRy6xevVpntlGF6OjoPEuLy5YtK5QTq+Qynz594u3bt5LkcaBkb6Ruc+TIERo3Vi9Rz+nfWrFiBR07dsTIyAhXV1cGDRpEVlYWqampkv9WBYmI9/X1xc3NjREjRgDKNMA5c+YQFRVFq1at8Pb2Fu79KuhaWpwbukbEy2QyrK2tsba2pkuXLjRp0kTwb02ZMkWIGdeGjRs3SvZIxcfH58lIVa1aVRjcXblyBTc3N+Li4oTwDCnw8vKS7JHKXVqcs54ip3+rZMmSQj1Fdna25NJigJ07d0p+cJ8/fz7jx48XvN9nz55Vq6fw8PDQOLevXr0qcES8Lt4lPT09Jk2axKRJk+jWrRtVqlTBwsICMzMz5syZk+9AasuWLXTq1EnSseXHSDVo0EAY9qn8W9++fSM8PJzXr19L2te/ERGf078VHR2Nt7c3y5cvp0KFCsybN49mzZqhUCiIj4//ny+w8sJPJusnCoz79++zcOFCqlSpgoODg5qMIz+P1NatygjZzMxMdu/ezeXLl/ny5Qvm5q2ZN09zupkXI7Vo0SLWr1/PhQsX2LdvH+np6bRv34HXr18zYED/fJMNc/9OgYGBGBsXJTY2lnr16uLs7ELJkqa4ubkxdepULYyUncbrxcTEMGvWLCIiPtG4cSOcnJzUpG1KRmq1WjkxqDNS8I9/6/r168TExNC6dWvRh3dtbEtkZBTz5/uxbt06Tp8+zeHDh8nKyqJbt248f/6cnj17ijJS2s7RgwcP2LhxI0ZGxiQmJvDrr7Vwd3ejiJEx42fPYdjo0VSsWIlz585x/PhxChcuTL169QgPD6dq1ao8fPgAhQL8/HzJzpazceMGoqNjqFevLoMGDWLLli0s8fOjkokxbuPHizJSaWlpjB8/XojE//79O0FBQdy+/RcJCfG0bt0aDw8Pnc9RTEwMnp6ebNiwgSNHjv7o5FDQu3dvnjx5QufOnUXLELWdo3v3Epg40YtixYqRmJhIp06dmDNnjugAQQUxRkoX6MpIff36lfnz53P16lViY2Pp0aOH8FCvC6Kiohg5cuR/7JHKiZMnT7J69WqSkpLo1asXM2fOxNDQsEAeqf3793Px4kU2btyo8zaq5NDr168D6mmAZcqUwdPTk99//11ju7wYKW0YP348nTt3Fp2+asOjR4+ws7OjRIkSpKam0r9//3z9W1AwFrBLly6EhobmGwCi8m89ePCA5ORkOnfuLJpyqg2xsbFYWlpy6dIlScenjUmQy+Xs2bOHgIAAMjMzsbS0xNXVFT09PZ0ZqZw4fvw4Bw8eFK3b0IbcjNSHDx/w8vLi+fPnVK1aFV9fX1EpXJs2bTh/XulF1RWTJ0+madOmkhipZ8+eMWzYMEqVKiV0+jk7O+e7aPi3PVI58ebNGzw9PXnz5g1ZWVm0bt1a0nWUmJhIv379JHuktKU/yuVy/P392bVrFzKZDDs7O6ytrZHJZILfTYrE8MKFCwQHB0sqApfL5bRp00a4jsTqKcSKsdu1a8epU6fy/HzJDQ8PD6pXr66zhA+Ui83evXtTtmxZnQdSoMmQ64LevXuzZs0awfOuDQ8ePMDX15fPnz9TuXJlRowYwZAhQyTt69/ATybrJ/513Lp1i507dxIeHk5gYCDR0THUrl0La2sbtHmktm7dRp8+/6QzFSlSRJgEjh49Gj09PWxsbDEzM8PBwYF69ermyUipmAT4J30tMzOTnTt3cu3aNWJjY0lOTlbrgMjZtZUbQUFBeHh4CAupc+fOMWvWTNLT04mJiRF9ADl27JhoaXGZMmUoVKgQBw7sJzw8nI0bNxIXF0f9+kqvkdIjpXmOgoOD1Er0VP4tVSlwdnY2Nja2lC9fDicnJ2rWrKnRtZX7HI0ePRqZTEbv3r3p3bs36enphISE8OefV4iNjUWhUKilHeXs2tI8R8F4eMymevVqXL16jaDgIMbP9CC1cGESEhIoV64coEzBqlixAl+/fsXIyJCkpCTCwsLo2LEjL1++pFQp5bSpcOHCLFmyhE+fPrE9JITvUZEcC96GjbW1TowUgJGREePHj2f8+PGMHj2ab9++YWNjQ6VKlXBxceGXX37Jl5EaOXIUMpmMQYMGMmjQQFJTU9m6dRsXL14kJiYGQ0NDtQfuJ0+eaC0t3rhxCYGBgdSvX1+Qy/Tq1QuFQsGQIUNwc3PTuJ737NkjuWA1LS1NZ0aqRIkSLFu2DIDmzZsTFxeHubm5znIZT09PJk2aJOn47t69myfLoboes7Ky2LBhg8AmRURESApeACUroCpP1hWrVq1Si7zPmQaYUy7TsGFDfHx8qFixYoFKi0F535GyAARlal9AQADNmzcnIyOD1atXC2mA2uQyhw4d0mCk8oOKkdIlYVHl3wJo2rQp79+/p1WrVrRo0QIfH598r0VfX1+dzO858eTJE62MlEwmY8SIEYwYMYK0tDSWLl1Ku3btKFq0aIFKi1evXi0k+emK3KXFv/zyixBkce3aNaZOnUpMTAxt27Zl3rx5mJqaCqXFUhZYADdu3BBSPXWFj48PgYGBWFhYkJKSwqJFi7CwsKBEiRLMmDFDtCPp1KlTaoyULpDCSNWsWVOIDW/YsCEvX77E3Nyczp07M3v27HwXDAsWLMDOzk7S8eXFSMlkMuEzJDExET8/PyEN8P3795I9XKrSYinIzUjVq1dP8GmePHmSsWPHkpKSQs+ePYWBlMrrJmWBBcpQMamqCR8fH/z9/enSpQuxsbH4+vqyevVqypcvz7x580S7/y5fvizqm84LqgTg/BZYAE2aNOHgwYMAWFtb/z9RQJwTPxdZP1EgqMIi9PX1qVWrlvDwdvnyZZydnShcuDDbtm1jzJgxQikwKKPbJ0zQnBB++vQJU1NTQQb48uVLAgM3ExsbQ2JiIq6u4gZ4sYj4IkWK0KhRI9q2bcPUqVMJCAhg+/btmJmVwcnJkeDgYKZNm6bxWmIR8SrZ1YEDBzhx4gROTk7o6xtgZTVcuBkePXqMNWtWa7xeztJilQxQLpdz/vx57O3tkclkhIaGYmVlpfbgf/v2ba2lxSVKmApRyY8fP2HDhg3ExcWTlPSV8ePFi1TFIuINDAz4/feWvHv3Dnd3d/z9lTLA8uXL4+LiTFBQMJMnu4ueo5cvXwg39u1//IGDxxxMTEty+fJlLl68gLu7OxUrVuL79+/Ur1+fW7duc+XKVVq0aEFExEeioiJJSEhgwYL5tGvfAblcjomJCS0bNWBg65YURjlNHjNmDIUKFWLfvn0MGTJE7YPx5s2booWaX758oXjx4kKM+7179354k5JITf2mdWr3+vUbDXmVsbExHTt2JCLiIxMnTsTf35/16zdQuXJlXFxc2Lp1q2gBt1wuJzX1C/Xr1wfU5TJbt25l48aN7N27F1NTU0EuAxAYGCi5r2rFihWSp3aq9EbVguTMmTP5ymWAAkXE+/n56WTG1tPTw83NDTc3N7Zt28aKFSuwsLDQmgaYGwWNiD9y5IjW1LmccpmjR48yZswYvn37RmZmpuj9Iy/8JxHxqnASfX19ZsyYwYwZMwS5zLJly6hQoYLg3wJl2qsqylpXrFmzRpJ3EJSMlKmpqdCNtXfvXoYNG0ZaWpowSBAbaPz111+sXr1a0r50jYg3NDTE09MTT09PgoODmT9/Pubm5oJ/S/We1AZtpcX5Ia+I+LZt23L8+HHkcjk7duygf//+ZGdnU7hw4QKVFv+nEfEmJiYsWLCABQsW8O7dO7y8vJgzZw41atTAx8dHeLCVWloMymGVWPl7XkhMTKRkyZKcPXtWbSBVqFAhrK2thSqO3ChoRLyYwiE3ctZTbNu2DW9vb8zNzbWmAebGfxIRr620WGwgpaenR9GiRXMk2+qGt2/fYmpqWqCIeNWC3MzMTOig1DaQAmUghxSGEpTDbqmL2oyMDKpWrUrRokUlbfffxs9F1k8UCNeuXRfteejYsSNBQcFs3hzIH3/8gbOzM0WKFGHoUEt++62eVkZq06ZNavKHOnXqsGLFckAZr7x//3527dpJ+/YdGD16FEWKFPnRtVVF9PhUCymlf0t5U33+/AUBAQE8fPiQnTt34ezspKbhV3ZtNRV9vVOnTrF27VpMTEyIjY0lICCA4OAQzMxKk5b2XXSKpGSk1DX5MpmM7t27s3Pnrh/ShJ04OjpiaGiIlZUVtWvXpmhRbaxdAGPG/HMzbdiwgbBwGzRoMPv27WX37l107dqVYcOGoaenl6ePLDg4iMmTJ6v5tx49esTq1at58OABBw4cwMnJSc3/deLESVq0aMH20B2EJ37lc0IiGT8S486fP0fhwnoUKWJA7dq1uHPnLufPn6du3bokJMSTmZlBSkoKcXHxrFq9irS0dJYvW8bvzZpSrbiJmu+qf//+HDx4kPXr17Njxw7GjrXDxMQEa+sxVK1aNR9G6p/gimbNmtGsWTPkcjkDBw5kz549/PHHH/Tu3ZtBgwYhk8l4/PgJ5cuXEz1HW7duYeLEiVSuXFlYuIWF3WHJksU8fvyYEydOYGdnp/b3P3PmLE2b1idnX5YKO3bs4Ny5c5QqVYrXr1/j5eXFzJkzqVmzJikpKRqekvxw/PhxyXKZ3IxUjx496NGjhyCX6dGjhyCXUZVnhoWFUamSOPubF6KioiQzUjt27ODy5cuUKVOGZ8+e4e3tna9cZuXKlQwcOFDSfqQwUir/VlZWFjVr1mTdunUEBAQwbtw4LC0t831YKYhH6tChQ1rlkmXLlhVYsQcPHuDj40NkZCSNGzcmOTlZUtwxKD1SUmWgPj4+aozUsGHDhEXWihUraN++PUZGRkyaNElgC5XsbznJD3cRERGiss28EBoaypUrV6hYsSK3b99m1qxZgtx63rx5ou+19evX59mDJYb4+HiKFCmSb2iKsrNP2eGYmppK7dq12bRpEzt37mTq1Kk6ebNUCyIpOHXqlEbUvArVq1dn+/btgHJAOmnSJOLj42nfvj2JiYn5LiZyY/fu3Zw9e1bSNgsWLBAKi3MOpJKSktT8Wx4eHsKDt1IJId0j9e7dO8kP73v27OHKlStUq1aNM2fO4ODgQFJSEt27d2fWrFmiA6nNmzeLsoN5ISkpiUKFCuXLSOUcSMXHx1O/fn3i4uI4duwYc+fOFQ3syg1PT09JdRqgvD60xfHnHEgdOXKEMWPGkJqaSt++fYmLi5PMZAUHB0sOWzl9+vT/cywW/Fxk/UQB8eTJY9Epvkrap6+vL8gA4+PjCQwMZPHiRVSuXIXnz59r3PQ/fozQWlr822/1WbBgPpmZmezatUtgk75+TWTZsuUa22grLa5Xry7t27enWrVq1Kv3Gx4eHkJK2MiRIzl+/LjohDU1NVUtkENlRgXlg0ZERAQ2NjbUq1dP8G9B3oyUiYkJRkaG2NvbY29vT0xMDP7+/vj6+lKlShVev36tcWN6//696A304cNH1K//GwsXLiQ9PZ3t27fj4OCAkZGR8EEldo7EIuIbNWpE167dqFatGnXq1GHy5MnEx8czbNgwhg4dytGjR5i3aDEpssIcP3mSN2/eMG+eJ6VLlyY5OYV27dry7NkLzpw5Q7Vq1SlUCExMihIVFcWzZ89p0aIFHz9+QL+IPgZF9DHIymS6zRj0i6gvRiIjozA2NsbExIRx48Yxbtw4IiMj8ff359q161SrVpUPHz5o/I3fvn2Hl5dmT9STJ0+oV68eS5YsITU1lW3btjF2rB3FipmQlJQkaghXRsQnaHyw/P57C+LiYqlatRpVqlTBzc0dUNCnTx8GDhzIoUMHfzC7yaj6skAp7cvMzBQe7n799VdBLmNra8vXr18lyWUKGhH/8OFDUUYqt1xm/vz5glxGVewtBf9JRHyZMmUA+O2330TlMr169WLGjBnCg63U0mJQPrBOmCDO/mrDkydPaNasGYcOHRL8W6ryTG1yGVC+5/MqLRbD+vXrhesjLzRp0oRDhw4BMHr0aGJjY7GwsGDAgAFMnjw530VkbGwsBgYGOicrqqCttNjQ0JA5c+YwZ84cPn/+jLe3N4sWLaJSpUrEx8ezdOlSSfs5duzYfxwR36pVK44dO4ZcLmf37t0MHjyYzMxMhg0bxoQJE4T30L59+woUyCE1Iv7du3c0adKE48ePC2mAnp6eVK9eHR8fH61R5gWJiF+1apVO/rKOHTvSsWNH5HI5I0eOJCoqirZt2zJmzBgcHR3zXdAUNCL+ypUrooxU8eLFha+rBlIzZsygdu3axMTESF5snjt3rsAR8arPSdVAKisrS2DtChcurDaQAmmlxSosWLBAks8OICEhgSZNmnDq1CmePn0qDKTq16+vdSAF+ZcWi2HJkiWsX78+358bMGAAAwYMICMjAysrKz59+kTHjh0ZN24cw4YNo1ChQnluX9CI+Bs3brBo0SJJ2/wv8HOR9ROSkZiYSNGiRUXfLBs3btIoLSxVqhSzZs3i+fMXzJ7twebNm4mJiaVOndo4OTnx7t17rTeDkJAQZsyYCShlgKpJYGxsLFZWVsydOxczMzOcnByFG+jRo5rJhiqoFlImJiZ069aVzMxMQkNDsbe358OHD4SFhWmk9Ki6tsTw9u07du/eTaFChQT/VkZGBi1atMDY2FirjywnIwVK/9a8efN4/foN06dPF/xbDRo0wMnJibdv3+XLSIFSBujo6IijoyNRUVGMGjUaLy9vNf8WqLq2xH0bR48eYeXKlUJow9evX/n69SvW9vaEJ3zl8oNHNGnShD//vELhwjIKFYLatWsRExPL2bPnqFSpIqamppQrV5bv31N5+PARa9euoZBMxuJFi5UJU95edGjSiJIyNBZYAAEB/owaNUrtaxUqVMDHxwcbGxsmTJggyACbNWuKvb0979690zrB37p1G5MmKSWnxsbGwoBAtUD29fUTZICq/racXVu5cfDgQSGQY9CgQYJ/y9bWlo8fP/L336/4/fea5FxkLVu2TKu07++//+bZs2fIZDICAwPp2bOnUJ45duxY0evIy8tLskcqLCyMKlXE2d+cMDU1Zfly5QDjxYsXtG3bFicnJ+rUqYOfn59OE+5Nmzaxb98+Sce3YsUKIYUwN3LKZdavXy/4t4YNG5Znap823L9/X7JnwsfHR1iQ5/RvqdIAIyIiaNy4Mb6+vsK1ePDgQckdXBkZGaSmpkpmpN6+fcvLly8B5cO1yr81YcIErdeel5cX48aNk7SfR48e6cRIVaxYUVjQ37lzhx49euDq6krLli3x8vLSyUu4Zs0agW3RFevXrxdN9pPJZIwaNYpRo0aRlpbGkiVLhDRAOzs7nRip3Lh16xYrV66UtI23t7ewSMiZBnjt2jWmTJlCbGysmn8L8maktCErK4vk5GRJ8keZTEZERAQvXrxALpcLbJKpqSkzZszQ+nDu5+cn2SP18uVLzMzM8r2Ocg6kLly4IASaaKunEMPy5csly50DAgJEGSk9PT1cXV1xdXVV82+ZmZkJflupHqk///xT8iLB09OTmTOVz0f169cX7rfHjx/H1taWb9++aQykLl26JKkgGrQPHPOCvr4+MTExPH/+nIyMDLy9vVm1ahXlypXLcyC1cOFCnXvZVEhISKBEiRL5LuD+L/BzkfUTknHixAn+/PMKt2/fZujQoWoBBBERH0VlHcqHu8rUqVNHeHi7dOkSc+fO5eXLl/Tv35/MzEw1/1ZepcVXr16jf//+TJo0iefPX/zwb8VSt25dnj9/Jmowz81IgXLhNnbsWFJTU+nUqRM3b94kODiYMmXK4OzsTK1atQgLCxOdBH769EmttLh79+50796d9PR0rK1tkMuzcXFxYcSIEWoxru/fh+dZWpzTv3X27FmmT5/O69evGThwIFlZWWrMhUr7LVZaHBZ2h759+zJ5sjuPHz9m3bp1JCQk0LBhQx4/fsL69Zo66e/f03j//j0rV67ExUVZ+rxx40YS5QoisqFWYRlbt27B1NSUxMREmjZtQvXq1bly5Srly5fDxKQolStXJiYmhkePHlO+fHlkssIULqw85oz0dLavW4tJoUKMHWtLdnY2Eya4MmbMaLVz8u7de1E56oMHDyhfvoKaDPDYsWO4u7vz9u1bhg4dilwuV/vQVp4j8Q+Ix48f07NnL6ZPn8adO3dYunQJSUnJNG/ejAcPHrBq1SqNbcRKi42NjZk40ZXNmzeTlpbO4cOHWbVqAzJZI/z8/KhevTonT54UlfZ9/vwZY+N/YvRdXFxwcXHJUy6jOvbNmzdrvF5eKEhE/MOHDxkxYgTr1q3TWS4jJZAjJ44dO5YvI6Wnp4e7uzvu7u7Ex8fTrl07srKy6Nevn07+LVAusAoSEa+ttFhVnglKuczo0aNJTU2lX79+nD59mj179kjaz78RET9z5kxmzpzJly9f1Pxb3t7easEYd+/elZQyCQWTP37+/JkhQ4bg7+/Pvn37sLS0JD09PU//Vn6lxdqgCyNlaGiIl5cXXl5eRERE0LVrV7Kyshg2bBg+Pj46LWgKGhGvjZFq27YtJ06cQC6Xs337dvr37y8wSwcPHpQcyKEqLZaC3IyU6sH/3bt3zJs3j9mzZ1OzZk18fX3V7qnXr18XvNm6wtvbWyePVE6o3utBQUEEBgYK/i0bGxutA6n8Sou1YdeuXVo9Uirk9G89f/6cAQMGkJWVha2trU7+LVAmLeYuLdYF2kqL+/btS9++fTUGUs7OzoSEhEh+v2/ZskVyOXJuRkrFgj18+BAfHx8+f/5M48aN8fHxURsmXbx4UXL/4P79+7G0tJS0zf8KPxdZPyEZ8fHxhIQEk5CQyObNgYSG7sTMrDTm5uZaPVIhISEaN9NOnTrRoUMHbGxsKF269A//lj6WlkPp2rWraNeWCsePHxfCJurVqyv4t06ePMmZM6eZOHGiIANULdxydm3lxl9/halFxD979gx/f38iI5UhDV+/JgkyQBUCAgKwttacuKikNyEhwT9kgAFs2xZE2bJlaNeunVZGKihom5qhXiaT0bNnT7p3746trS3GxsaCDHDkyJG0a9fuR9dWE9HXUzJSykVCw4YNWb16NXK5nKNHlRHlbm5udOvWDUtLS+EBJzg4GAcHBypVqsScOXN4Ff6R5dtD6dmvH3fv3aVwYT0yMzMpWbIUjRs35vz585QubYahoSEVKlREoZBz79591q1fh6yQjFWrVpGZmYmXlxcVTEtQrpCcskWVH97KcxTyQwYYwKZN/lSsWIEOHTponeAHBQXh7u6udo4GDBhAv379sLa2RqFQYGdnR9GiJtjYWNOyZUtOnz6t1Rd08OBBYdHfokULWrRogVwu58CBAxw4cJApU6bSp09vBg4cKFwb27dvp2vXrqKvd/36dbWI+IsXYxk/fjzR0dHExMSQlpamMeH09PRU+51UyCmXefXqlZpcZvDgwZLN+XK5nKioqHzLW3ND9VAM4nIZmUyGvb29mlxmxYoVDB48WNJ+oqKiMDIyksRIlSpVimLFinHr1i1BLvPx40e18kwx+Pr6Su4MOnDgAE2bins2cyKnXGbVqlXCIlUll9EFhw4dktxH5u3tLcpIlStXTmDs7t27h5eXF5GRkbRo0QJLS0vJbBkoB0zaJtHasGbNGkJDQ5HJZAwfPpzhw4eTlpbG8uXLhTTASZMmqS0u165dS58+fSTtJzY2VjIjVblyZUxNTblx4wa3b99m+vTpxMTEYGFhgZeXl8Am5Ya3t7ekQmVQfkblF8Ahk8mwtbXF1taW1NRUFixYwJ07d7C3t2fatGlqg828sGfPHskeKV9fX9FAjurVqxMaGgooB6Surq4kJCTQsWNHhg0bRunSpQvUI9W2raa8Oy+sWLGCzZs3I5PJ1AZSKnmz2EDK399f53Omgq4eqZyoV68epUqV4saNG8JAKjk5mR49ejBjxgytUkpdAzly4uLFi/l6nXIPpLy9vbl58ybu7u5a6ynEsGPHDk6ePCnp+BYsWCDKSDVu3FhIAzx06BCjRo0S6ikGDx5coECON2/eSJbs/q8g7Tf5if/f4+PHCMEAX7KkUj4QEhKMi4sLgYGBvH37hvnz5xMbGytsI5fLSU5OETXOHz58mJYtW2Ftbc22bdtYtGghYWF3sLGxZd26taI34NTUVLRFxL99+5aJEycSGBiIXK7AyckJZ2cXLl26RFjYHVEpUm5GCpRekBUrVvDrr7/St29fZs2axdixY9mxI5SsrCwAwsM/iE7Nc4ZNKGWAcwkJCcbW1pa1a9fy5s1bli5dSmJioto5yqu0uFmzZjg4OBAcHIy3tzeXL1/GxsaG1atXi8oZvn9P+1FarH6OZDIZkZGRjB8/no0bNxIdHU2vXr0YP348165d4/btWwwZMgRzCwsq1KvPKDc3DIoWxdfHh4SERIyNjRg8ZAivXr3i3r376OnpYWZmhrl5Kz58COfzZ2WUvOJHGEZiYiJ+3t6ErFrB988RfEtKYuzYscyfP5/y5ZVpa0oZoDchIcEMGzac5cuXEx7+ntWrVwsphqpzpC2x6fTp0zRt2pQJEyYQHBzM3LlzfhQo2rJixUpRM3t6ejrZ2dkaEfEymYyEhARcXJxZt24tnz59ZuxYO1xdXQkLC+PateuiD8sxMTEagRydO//OqVOnaNy4MX379qVXr160a9eOrVu3Iv9xjp48eZJvslutWrXYtWsXt27dEjwSL1++ZM6cOWrnKC/s2bNH1PeYF9LS0khPT9dgpFRymWvXrnH06FEePnxI69at6dOnD9evXxcW8VLg6enJxIniKaLakLO0WCWXuXXrFgMHDsTa2prWrVvj6+tLWlqa2nbaGKm8sGHDBnx8fHT+eX19fQoVKsSsWbPYu3cvf/75J+bm5gwcOJB79+5p3a6gEfF3797NdxHXrFkzDh8+zO3bt+nYsSNDhw7lzZs3LF26lIyMDJ32c+TIEclhJtoi4g0NDZk7dy43b95k+/btHDt2jFatWjFkyBCePHnCgQMHJCc5+vr64uzsLGmbnBHxrVu35vjx49y8eZPmzZszcOBA2rZty7p164R7vwofPoh/BuSFVatW6ZS4qYKxsTFly5Zl8uTJBAYGEhoairm5OSNGjODVq1dat0tISCiQR+rGjRv5ptV16tSJU6dOcePGDWrWrEn37t2FKhfVfS0/FCQiPisrS5SRKl68OEuXLuXWrVusXbuWTZs2YW5ujo2NDeHh4ezatUvyIsbPzw9bW1tJ2+SMiO/Vqxdnz57l6tWrlC5dmu7du9OhQwe2b9+ucY7evHkjOZBj6dKl+Pn56fzzpUqVokGDBowfP55FixaxZMkSzM3NcXBw4PPnz1q3U32+5AzA0gWXLl3Kd+EzaNAgLly4wJ9//omenh5t2rTh8+fPgg9XF7x7905UyfP/Cn6WEf+EJAQFBTNkyGANU2LOQt7Lly+zZ88e0tLSaN++PSYmJkRFfWHiRM2gDHt7B9atW6vxQZCamoq9vT2VKlUiJiaWunXr4OzsTKlSpVi3bj2VKlUUnZSLlRbHxsaybNly/vrrNs2bNxdkgCrMmzePfv365VtanJ6eTmhoKNeuXSMjIwNDQ0OhMDgn8istDgraxtmzZzl06BCZmZl06dIFY2NjwsPDRRkNBwcHwUeWE9+/p2Fra0vFihWIj0/44d9ypESJEmzatAkzMzNRCt3GxpZt27ZSuHBhli1bRsOGDWnSpAkrVqzgzp07NDa3oM/IkWz0D8DL2wtZIRkbN26gadNmhIaGUqJEcRITE6lS5RcaN27E6dNnhCjXNWtWU7RoUSIiIlDIFRRFzvYN65H9kHOEhISQlZXFyJEj8fX11fiQzXmOjh8/LpjVe/bsiaGhIX///TdTp07V+J2cnJxES4u/f0/D2noMFSpUICkpiWbNmglpgIGBgRQrVowRI0ZovJ5YafGnT59YuXIld+/epW3btri4uKixSX5+fnTs2Il27XIOBsyAqmpljCoZ4JUrV9DT06N06dIcPnxY4xi0QVVafPPmTaE8s1ChQtjZ2WFjY6N1CtixY0f2798vScK3YMECDA0NRc+5GJ4/f860adO4ceMGAwcOFIJcdEFBik8HDhyIj4+P1l4olVxm3759glxGT0+PS5cuSS4t7tixo2QZi1hpcU65TJMmTfD29lZjkwpSWqxKGFQFYOgKc3Nzrly5wooVKzh27BiGhoZMnDhRqy8OlH2EO3fulMSArVixgrS0NJ3DCsLCwpgzZw5//fUX1tbWeHt765y8qa20OC8MHTqUGTNmaB1CpKamsnTpUs6cOYOJiQlTpkwhOzubQ4cOiX4GaEPu0mJd0aZNGy5cuKDGzl25coXFixcTFxdHhw4dmDt3rtrn8uTJk2nevLmkeO/nz58zffr0H2XsusPc3Jzz58+zYMECLl26lK9/C5Ty+s2bN0uS8K1fv54vX77ovLg4d+4cCxcu5P79+7i6uuLh4aFzxHdBrqP8SosTExPx9fXlxo0bQoBWamoqISEhknyHcrkcCwsLyfdLsdLiY8eOsWbNGlJTU+nduzfTpk1Tu84KUlr87t07xo0bJzn8w9zcnKNHj+Lt7c3du3c16inEsHTpUuzt7SldurSkff3b+FlG/BP/MRQKBSkpyaKpL4cPHxbkI6qUoszMTP744w/Wr9/Ar7/+yrlz59Qo+2/fvgGITtq2bt2GpaWlsJC6cOECs2fPJj09naioKI4cOaKxjRgjBUqDepEieixduhQTk2L4+wcQGxtLvXp1cXZ2Ee3aAs3SYgMDAyEN0MXFhZIlS2Jra0vZsmVxdHSiVq1fBe23GCN19OhRmjZtIsgAe/bsSXp6Ojt27CAwcDO1av3KlStX1G7QObu2ciM4OIihQ4dgaWmJXC7nzJkzTJs2jezsbL58+SL64B4ZGUlUVCR2dvZYWLTm4cOHTJ06FZlMhkFREyZ6+6LQNyBg81YiIyMJCQ5h+PBhvH8fzsePEcjl2RQpos/oMWO4dvUqf/55hUKFChEfH0epUqWJj0/Azc0dY73CLJnjQQkjI8bajsXAQF+YYstkMoyMjEWnmCdPnqRx40bIZDIhNvv79zSCg4P444891K1bh1u3bqn5t9LS0rSWFm/fHsLgwUMYMcJKkEq6u7ujUMCXL1EcOqR5jr58+aLmkVKhUqVKFC9eHD+/+RgaGrB48WKSk1No0aIF9vZ2ol1bkMzt27fVroecMsDu3btLlq2pSotzpwGq/FulSpVi9uzZaixwQT1SJ06c4MqVKzr/fL169ahUqRIhISEUKVIEOzs7UlJS8pXL3Llzp8AR8XkV7+aUy8TGxuLn58f27dtp0aIFYWFhOstl/s2IeG1ymQEDBjBlyhTu3r0rubTY19e3QBHxjRs3Rl9fHw8PDzw8PIiKisLb25vFixdTqVIlvL291VgrFSMlVWJ48OBBSal9v//+O3Xr1sXOzg6FQiGkAQ4dOpSJEydqTdTMq7Q4L3z8+DFPltfY2Bhvb28hvc3Ly4vDhw9jYWHBy5cvdU6t0xbIkRe0RcS3b9+e9u3bI5fLCQoKom/fvigUCkaOHImzszM3b94sUGmxVMZHxUiZmJgI/q03b94IErhatWoJvlQVtDFS+eGPP/6QJH/s1q0bZ8+eZcyYMaSlpQn1FGPHjs1zIJVXaXFeePv2bZ6MlKmpqRCS8vz5c3x8fDhz5gydOnUiIiJCZwn4li1bJKcDJicnA5qlxf369aNfv35kZWWxdu1aNf/W8OHDC1RaPG/evAJHxIvVU3z+/JmmTZtqDKQUCgXx8fH/5wusPKFQKP6f+de8eQOFQnHn57//R//dvLleceyYt+j37OwaK759u6Lx9W/frijs7Joo4uLOKhYtGqqwtq6vmDKlg+LZs1DF2rU2ioMH54i+nrV1A0V29l8aX3/3br+if//KirFjGymcnFoozp9fInxvzpyeitu3N2p9vdxfO3t2sWL48F8VnTuXUISETFJkZNxU+/7EiRaK8PCDGttlZ/+lsLauL/z/yZMQxeTJ7RXW1vUVTk7NFUuWDBM9Bnv7Jork5MtazlFjxZcvJxW+vgMU1tYNFNOnd1a8fr1HsXGjvWLv3lmir2djI36O3r7dr+jbt4LCxqaBwsXld8WFC0uF73l69lHcuLFekZl5S7Fq1WhFp07FFXb2TRQ7j3orBo63UDyMOad4GHNOMWp6N8WWkwsVXa0bKfo4tlC0HlJD0dOumSL04kpFV+tGws+NmdlDsWL3TIXVlM6KHmObKPo6tlBEJF5UZGXdVjvnN26sV7i6tlZYWzdQjB/fSrFo0VDR38nBoakiKemSxtdTU68pxo5tpPj8+ZjC07OPwtq6gcLDo7siPPygwt/fUbF79zSt5ygz85boddS7dzmFtXUDxYQJ5oq//tokfM/bu5/i6tXVOl1H2dl/KQ4cmK0YNuxXRadOxRUHD87R+JsMGNBb8eTJE0VuZGdnK1q2bKnx9fzQsWNHRVxcnNbv//333worKytFq1atFNbW1or3798r/Pz8FMuXL5e0n0+fPim6dOki+fhatWql9v/MzEzFmjVrFBYWFor27dsrtm/frsjOzlb7mQEDBigePnwoaT979uxRjB8/XtI26enpCgsLC8Xjx48VQ4YMUbRs2VLh4OCg+PTpU57btW7dWpGeni5pXy4uLor9+/frfFxLly5VNGrUSFG6dGnFvn37JO0r9znXBZ06dVJERkZq/X5YWJhiwIABipYtWyrGjx+viImJUSxfvlyxYMECSfuJiYlRdOzYUfLxtWrVSu06+f79u8LX11dhbm6u6Ny5s+Lo0aMa2wwePFjx119/SdrP0aNHFfb29pK2yczMVJibmyuuXbum6NOnj6Jly5aKyZMnKxISEvLczsLCQvH9+3dJ+3J3d1eEhobq9LPJycmK2bNnC9fR+fPnJe2rINdRt27dFOHh4Vq/f+HCBUXPnj0VrVq1Unh4eCiSk5MV69atU8ybN0/SfhISEhTt27eXfHy5r6OEhATF1KlTFa1atVL07t1bcfXqVY1trKysRL+eF86ePauwtraWtE12drbC3NxcceLECUW3bt0U5ubmCm9v73yvkbZt2yqSk5Ml7WvmzJmKwMBAnX42JiZGMXHiREXjxo0VZmZmirCwMEn7Ksh11LNnT8Xr16+1fn///v2KTp06KVq3bq1YtGiRIj09XXHr1i3FwYMHJe/rvwHgjkJkXfPTk/UTOuPGjRtCNOjWrVvJzMwEVJrdQloZqb59+wox7iEhITg5ObF16xb279/Ps2fP1PxboIzV1lZavGXLFubOnSP4t/766y9sbGyZOnUar1690tq1JTYh6tatK2XKlGHz5s1kZ2fj5OSEi4vSv5WXR+rIkaNq9LUqDTAoKIjY2Dj+/vtv7OzsCA39x78llmyogioivmzZssybN4+QkGDGjLFmw4YN/PHHHt69e8vXr1/VtomMVHqfxM5RcHAwc+bMIThY6QNbsWIFNjY2zJw5kxcvXtK6tTl6enp8/vyZJatXM97Lh/O3/yI6+gsLFy7k9evXJCQkcOTIEVJTv/H9+3emTJ1Kauo3tm8PIT09jYcPHyBXyElOTqZr1654eHhQppgJvVs0Y95kd4YPH64WsNC6tTnr1q0jKGgbkZGRvHr1Cnt7e/bs2SPo0//xkWlqv7dvD6F79+5CjHtISDBDhw5l+fLl7Nq1i8jISA1vkqprS2zqrQpiCQkJxsPDg2PHjmFjY8ucOXOFyPLcePTokUZpsUwmY/DgwVSoUJ5169YRERGBnZ0dEydO5M6dO8jlcr59ixI1uu/evVun4sicUDFSeUmnatWqxe7du7l16xajRo0SpJRxcXE//Iy6oaAR8bnfa3p6ekyaNInr169z6NAh7t27h4WFBX379hVkUwUpLd60aZMkjxQoZWsDBw4UyjNv374thKa0bt2a+fPna/i3vnz5UiCP1P3797XGpueGvr4+06dPp0aNGuzZs4eLFy9ibm7OoEGDuH//fp7bHjhwoEAR8WlpaXkyUi1atBD8Wx06dGDYsGH4+fkhk8k0vEl5IXdpsS4QKy02NDRk3rx53Lx5k5CQEI4cOYK5uTmWlpY8ffoUKFhp8erVqyV5pADWrVtHr169aNOmjeDfatKkCQMGDKBNmzasX79e4xzpWlqcG7du3RKVNIvBxMSEBQsWUKdOHQICAggJCcHc3JyRI0fm6d+CgkfEJyWJf06q0LlzZ8G/Va1aNXr16sXcuXMpV66czv4tKHhEfO5ADlU9hSp6f/369Wr+LVDK3aQGcixfvlzydRQYGEjnzp3p3bu34N8yNTWlS5cudOzYkdDQUI1zlJSUBIg/S+SFy5cviwaaiMHMzIy1a9dSv359Fi5cyOLFizE3N8fJyYnIyMg8t9UlkCM3dImIHzJkCBcvXuTy5cvIZDKhe0tqefj/Gj/lgj+hEzIyMjAyMsbf3/+HDHAPTk5OFClSBCMjI63G/bt37zBhwni1r9WpUwc3N3eWLl2ChYUFc+fOJT09nfbtOzB69Cj8/f01urZU+Pjxnw/RUqVKCdKG/fv3s2XLE2xsbKlbty7Ozk7Cg2jOrq2cUEbEJ1GjRg1q1KjB2LFjiY2NJTAwkJUrVyKTyXj16pWafwvgxAnx0uK0tDRMTUuwZcsWQQaoSgM0MTHR2rWlSjbMiYYNGzB9+nTmz19Aw4YNmT59OllZWXTt2pVhw4b96NoS75J48uQxs2bNApQPYEuXLhVCAR48eICNjQ0NGjXiTVwCBhWVfpmkpCQGDhzIn3/+yY4dO/j6NRGZTMbkKVPYuGEDm38EiRQqJGPKlCmcO3eekJDtQCFioiJpWqM6hb8mMs7JiXFOTtjbO+DsrKnhTk/PoGTJkmzduvWHDDCYsWPtKFrUmBIlSmhNgLpx4yZbt25R+1qzZs2oUKEivr4+VK9e/YcMUEHPnr0YMmSwaNeWCm/fvhVkepUqVRI+HP/44w/CwpQL9+bN//FvgXrXVk6oPiDq168vLKY+fozA398fP7/5ZGQU5t27dxqBHZs3bxZkY7pi6dKlkrw63bt3p0GDBowePZrKlSsLcpnc5ZliKGhE/Pz587V+v1SpUkIs/rNnz/Dy8uL+/ftCN4+uchlVafG/ERGvkqWq5DKdO3dGX18fFxcXhg0bVqDS4gcPHmiEPOiCz58/06VLFyHM5sGDB/j6+gpyGR8fH8qWLau2zYYNG9i9e7ek/axZs4Z+/frp/PPDhg2jc+fODB48mOzsbNq3b4+RkRGTJk1iwIABeW6rrbQ4L+SX2le5cmW2bFHeD27fvs2sWbP4+++/f0iX43X2b6nkjwWJiL948aLwf5lMhrW1NdbW1qSmprJ48WLatWtHsWLFmDp1Kj169MDHx0dyAtrTp0916pHKjQ8fPjBkyBBhkX/lyhXc3NyIj4+nffv2Gv4t0L20OCc2bdpE9+7ddfpZmUyGk5MTw4YNo3fv3nz48IE2bdpQsmRJZs2alW/ww38jIr5OnTr88ccfgLIX0cnJiY8fP1KoUCFSU1N1Dg0paET8zp071SLi9fT0cHNzE/5Wfn5+rFu3jjJlyjBnzhxat27NggULtD4faUNBI+Jfv37Nzp07hev26NGjjBkzhtTUVPr06cPUqVM1hgZLly6VLHfetm2bWs1NXtDX12fGjBm4u7vj5+eHgYGBpH39r/FzkfUTOuH69eu0bavsLSpSpAhjxoxmzJjRJCQkMHz4cBITE7l27SoODg7CNOzjxwiKFSumtZDXxsaGFi1a0KlTJzIzM9m1a5dQvCvWyaDq2hLDn3/+yebNW6hSpTLnz5/Hw2M2GRnpdOjQgaSkJNHtlBHxzdW+ZmZmxuzZs3FwcGDcuHH4+/v/8G/Vw9nZBQMD/XwYKaXe3sDAAAcHBxwcHIiJiWHkyJFER8cQFvYXTk5OwqRHm49MdY5U/VG9evUiPT2d7du34+joyLt37+jaVXNBcv/+A4yMjJgwYTyFCxcmOjpG+HtcvXqVgIAAipUtx9KAQKJTvuHh4UHHjh3JyMjg7t17fP2ahFyezbjx49mxfTtbNm8mMzNLSElbv349NWrUxNm5JvPn+zF64ECObA5g/YcPlCpViuTkZPT0igDije0hIcHCQsrIyJBx41wYN86FyMhIxowZw+fPn3n48CEuLi7CB1ZkZBRFi4ozUgEB/owePZo2bdowcOBAUlNTCQoKYuxYO8LD34tOuZSMlPgD8M2btwgICKBq1aocOXIUNzd3APr06U1CQrzopO3MmTMaLEyVKpVZsGA+jo6OTJpkI/imOnXqxOzZs9HTU0bh6/owqMKpU6dEu7bygioivn///sJxqMozS5cuzezZszU6ycQYqfygiohv2FC8wDk3fvvtN/bt20enTp1wdHRk7NixJCcn06tXL2bOnJnnxD+v0mJtyC8iXk9PjylTpghlsD4+PqxatYpXr17h4OAgaV85S4t1xYEDBzQM3k2aNBEW4gcOHMDKyoq0tDT69+/PlClTAOVwp1y5chqvlxcOHz7MpUuXJG3j5eWFq6srw4YNY86cOXz+/Blvb28WLVpEpUqV8PLy0ngf6FpanBsfP4r3LYqhVatWHDt2jC5dujBo0CAGDx5MRkYGw4YNw9XVVat/C5QR8VIn4bGxsejr62u9Po2NjfH19cXX15fw8HA8PT3x9PTk9evXkkufCxIRf+rUKX777Te1r2nzb40ePRpHR8cfCcDSSouhYBHxfn5+ODs7CwsFlX9LVU/h4+OjMZB68eJFgSLipTBSqnqKHj160KZNG631FGLQVlqcF/KLiM85kFLVU3z48IE3b97ky27nRs7SYl1x8eJFjQFz7oFUly5dhIGUKmQrMTGRGjVqSNrX9u3bJYetnDp1SrK/8f8CPxdZP6ETnjx5iqur5jQ3JSWFOnXqsG7dOv7++28CAwOJiYmldu1axMfHa524REREqPWsFClSBBsbG3777Tf27NlDWNgdduzYgZmZGQ4OjtSrV1e0awv+YaRUC6muXbvStWtXMjMzmTVrFl++fMHFxYXhw4fTqVMnYbucXVs5oZL2NW/eXFiEnTt3jlmzZhIeHk79+g00SoFBnJEC5dS9Tp06rF+/nqdPn7Jx40bi4uJo0KABMTExjBkjnv6Uu7TYwMAAR0dHmjdvTkjIdi5fvsSWLVsoX74cTk5O1KxZk6CgbSxcuJBffvmFU6dOsXXrVsaOtaNEieJExsQgL1maT6lpPH/5khYtWvDmzWuePHlMYuJXYmJisbGx5tixY+zetYvv39MoXLgwixcv5tLlS0Kf1I0bN2jbqiXG35Lp37E9/TsqP7xPnDjJlClTiIiIoEGDBmRnZ1O4cGG13+nWrVvCBFodhahTpw4bNmzg/v37rFixgq9fv9K0aVOio6O1sna5S4uNjY2ZMGECbds+ZOvWrRw/fpwNGzZSuXIlXFxcqFKlClu3bsPdXTNeXFVarPqAHzRoIIMGKRduquvI1dUVGxsbtQfAQ4cOiU5YVaXFXbq0pUuX8cjlhdmyZQu9evUiPDycVq1aaRQn54XPnz9TtGjRPB8axfD48WO1c56zPPPly5d4e3szdepU6tatK5Rn+vn5sXDhQkn72bdvX4Ej4keOHMnIkSPVyjP19PRwcnJixIgRGudIl9Li3PD29sbVVTPhVAxmZmasW7eOe/fuMWXKFBYvXkxERASNGjXCx8cnX5ZKlRwoBevXr8+ztFjFTGRkZLB69Wo6duxIVFSU5Ajx6Oho9PX1CxQRn7PEtGLFigQGBgLKRfm8efOIioqiZcuWeHl5YWZmVqDS4v8kIt7V1RVXV1fS0tJYsmSJ0L81ZcoU0cXUgQMHJAVygDJkRFdGqmrVqoSEhPD06VMcHByYOnUqsbGxtG3blnnz5mnt31Lh48ePkv++Kum6GFSLBnt7e1JSUli4cCEWFhYkJCRI3k/u0mJdkZuRqlmzJjt37gSUAVfjxo0jMTGRLl264OHhgYmJCd7e3syePVvSfs6cOSM5Il7FSKkWxqqBVOvWrYUBbO6BFOhWWpwb8+fP15mRUilR3rx5w9ChQxk7dizfvn2jV69ezJgxI18JqrbS4rywdOlSoV8vN7QNpL59+6YxuM4PuUuLdcXNmzeFoJX/l/FzkfUT+eLr168UL16MQoUKaXwvp7Svdu3awoP4pUuX8PHxEeJlR48eLZQC58VIqRZSqqSxly9fEhi4mZiYaCIjIzEyMtLY5vDhw6Jv7CJFipCY+JUDBw7w/ft3AgMDCQ4OoUwZM6ytrdHWtSVWWtytWze6dev2YyFYD0dHRwwMDLCysqJjx455MlLK0mJr4B//llwu5+zZsyxevJjY2Fhev36NlZWV8ACds2srN4KCgpg+fbqgg3/8+Anr1q0jPj6eqKgoIWXv6NGjQpT7qq3beH7lGk4TJ1KnTl2gEKmp30hKSiY6OoaBAwdy48Z1Tp48xbdvqWRlZeLu7s7OnbsoVqwY/fv158H9+7hPmsSFw4eZ7r+BUSNHCsckk8no168v/fr1xcbGhurVq2Nvb0/RoiaMHj2a1q3NiYyM1OqR8vf3F6KGmzZtStOmTZHL5Rw7doxDhw4TFRVFREQEQ4YMEc7xw4cPtXpKtm0LYsqUKUJ/xp07d1i6dClfv37ly5cvlClTRmMbbaXFxsbGfP/+nb1795KcnIy/vz/r12+gcuXK2NvbaU02DAkJySGlSUYmK4WTkxNOTk6Ym5tTvXp1IQ1QF7mMttLivKB8r2mPUK9Tp44gNVOVZ379+pWIiAjJ08icpcW6YsWKFWq+pdzlmT4+PoJcZu7cubRq1apApcWglN75+/tL2sbPz4/Vq1cLC6YjR44wevRoUlNT6du3L9OmTdOQq+zfvz/PyGExqDxSuaWAYlDJZWbMmEGrVq0oXrw45ubmVKhQAS8vr3wXd97e3pLlj0r2V7t/6/fff+fIkSPI5XL27duHpaUl6enpfPr0SfJic+3atezYsUPSNmvWrFErLTY0NMTLywsvLy8iIiLw9PTEx8eHX375BV9fX+rVq1eg0mJQyhPF5OJ5wdvbm7Vr1/L7778jl8vZvn07/fv3Jzs7m5EjRzJu3DiNz46TJ09qMFL5ISsri5SUFJ0YKRMTE2GQ0rJlS7KzszE3N6dmzZr4+vrm6Y8B7aXFeeH58+d5yh9VUlm5XE5gYCC9evWiUKFCRERE0Lp1a0n7WrlypTAE0BW5S4tzDqRUaYBTpkyhXr16wkCqIKXF8E8EvxR4enqyZs0a2rdvrzaQKlKkCI6OjqIDqQsXLmgwUvlBJYEX66TMDdVACpQ+zsTERMzNzWnUqBG+vr75JpFqKy3OCwkJCZiamoo+k/6/hp+LrJ/IF3v37uPXX8VvuLkZKRVMTExo27YtXl5eggxQX1+foUMtOXr0iOAZygmx0uI6deqwYsVyDh48yJUrV/DwmE16ehodO3Zk1KhRFClShBMnTmplpACKFi1K0aJFhUnY8+fPmTVrFnK5nMWLF+Ps7ELJkqbCdmFhd0QZqU+fPlGsWDFhEhgTE0tAgD/BwcF8+fJF63QzPFwzIl4mk1G2bFksLCzw8vJix44dODo6YmhoyMiRI9m/f79oN5GKtctpNG7YsAGrV6/myJEjnDt3junTp5OZmUlMTAxFTEz4OzGJi3+FUa58Ob5+TaJwYRmpqd94+PAhnTp15vnz59y5c4fk5BSys7NYuWoV796+xd8/gOzsbHbuDKVr124YKhS0qlGNttOmYPP4EVZWVhrHFxkZhYmJiRAtHhkZib9/gCC7dHQUl129f/9e40NUJpNRtWpVWrc2x9PTU5ABmpiYYGNjzc6du0QXHarS4pwFhS1atKBFixY/ureOC/6t3r17M2jQIGQyGYcPHxZlpNLS0oTS4hIlSgieo7CwO7i7u5OdLWfduvXY29upTXVv3LiRg0FKBpTSQNWCfOnSpYAyLtjLy4sZM2bwyy+/sGTJEtEPt9yMlC6QwkippDI7d+4UvBaFCxfG3t6e0aNH58m4FTQi/vjx41rlj6VKlRK8PCq5zMePH4mLixO9f+SFu3fvSvbdgGZp8YABAxgwYAAZGRmsXbuWTp06oa+vz/jx44Ui4A0bNuTJSIlh5cqV+XqbciM6OpqiRYsSEBAAKCsnVHHHzZs3x9vbW3TRdu/ePcmeCR8fHzw9PfP9OZlMxvDhwxk+fDj79u1j0aJFtG/fHmNjYyZNmkT//v3z3L6gHqkDBw6oeaRyonLlyoLX6ObNm0yfPp2YmBhSU1MlB7s8efKEsmXL/kfyR5lMhq2tLba2tqSmprJo0SIsLCwoXrw406dPFx7yV61apZWR0oYNGzZo9f5qQ3x8PEZGRgKbdPnyZVxdXUlISKBDhw7MmTNHlGW4fv26MFTVFbpGxMtkMlxcXHBxceHAgQPMnTsXCwsLSpYsiYeHR74DKVUgh1SP1K5du7TKH+vVqyf4t06dOoWDgwNJSUnI5XLJgRwFjYjPWVosNpBau3atEKCleuZYtmyZVkZKGzZv3iw5Ij4pKQkjIyOhOubIkSNCPUX//v2ZOnWq6GCsIBHx+/fvl+RN/r/Ez0XWT+SLmJho/v77JcHBIdSq9SsuLi6YmZnx119/ab2JqRgplQzQxsaG+Ph4/P39efToEStXrhRkgCrk7NrKjRMnTgqlxZmZmYSG7sTJyQk9PT0SExNFp0hbt26jTx9NiUi9evUwNS1JUNA2Lly4wKxZM8nIyKBTp0506NBBa7Lhpk2bBEYKoEwZM0EvP3z4cK5du8aRI0eoX78+jo5OlCxpqtG1lRPBwcHCJDynf2vTpk08ePCA9evX4+zsrDZRVHZtNRV9vWPHjgmlxVuDgrl07x5202eir2+AXC6nbNmyxMbG8ddfYTRv3ozIyEjCw9+TkpLM9+/fGTx4CLdv30K/iD516tSlePFizJs3j79u3mTLkkVkp37j4L59tGnTBhMTcdlaTkYK+JEG6A0oCz8vXbrEoUOHadKkCQ4ODhQrZsKDBw+oWFFcfhUUFMzkye6CDHDCBOWDr/Ic3Wfz5kDGjRunxtaourbEcOTIEZYvX06JEiVITU1l69ZtQvDG169JWhmpbt00zd2//96CUqVKsXnzFo4dO8rEicoHtj59emNhYZGLtUsWtvP09BT8NKBMA9y1axcADRo0wMXFha9fv6rJZW7fvq1zqa8KcrmcL1++qKU86oLNmzdz5MgRSpcuLchlNm7ciJmZGR4eHqJymeXLl+ucpKdCVJT29MfcUMllAOrWrcvu3bsF6aUuchk/Pz+8vb0lHV9ejJS+vj7Tpk1j2rRpxMbG4uXlxcqVKylbtiwJCQk6MVI5cfToUcnyx9yBHM2aNRPKiPfv3y/4twYOHIi7uzv6+voFDuT49OmTZHbO39+fkydPUr58eT5//oyXlxcLFy6kcuXKeHt7i16Xa9as0RqipA35eaRyonXr1hw/fhy5XE6tWrUIDQ0lJCSE4cOHM27cuHyvRW9vb50Wmzlx/Phxre9BY2Nj/Pz88PPzE/xbc+fOpWrVqsTFxUn2SO3du1ey/NHPz09tQKjquZTL5Wzbto0+ffqgUCiwtrbGwcEBmUyWLyOlDe/fvxe9f+SFgIAAzpw5wy+//KI2kKpTpw6+vr6izyC5GSldkJioDHvSRf7Yq1cvevXqRVZWFrVq1WLHjh3s3r1bp4EUKD8DpA6KLly4QO3/j733Dmsi7bvHD5EuCiKiFMWuqGuXKgoiVkSwV0IvKmIBBKUkgBWRLsUCiL333tZFAQti74pSBaRIb5nfH3FmEzKBhN33+z7P7/Vcl9cuSe7M5M5kZu7POZ9zBg6kfY63IPXy5UuwWCzk5uZiyJAhKC4uFomR4sXBgwfFlj+2NOTgLUhFRETA2NgYMjIycHV1pQpSX758gZKSUrsWm+KayPxv4fci6zdaRU5ODrS1takm87t371JugKWlpbSuUXSMFMA9EQwaNAidO3eGmZkZEhL2oKSk+JcboDMuXbpE0c68IBkp8uQnJSUFW1sb2NraICQkBG/fvgWTyYSKSjc4OTlSwZCPHz/GypXCGCnuQoqUATY0NODgwYOws7NDt27dcOfOXZiYGLeYi1zanpMnT56gf//+2Lx5MzgcDm7evIkNG7zQ2NiI8vJy7NoVRjtHdBbx3bp1w/Dhw6GoqIhJk0wRFRWFsrIyDBv2B5ycHHHhgvA+svz8fFRXV6NRUgpXM59iw8ZNkJaSRkpKCj5+rMeDBw8weLA25OTkUFVVhZqaGpSU/EBkVCRqqmuweXMwGhoaERq6ExMnGkNOTh7dFTrCcfYsOFtyQ4GTk5PAZDLRvXt3pKWlCbBPdIwUwJU/DhgwAFu3bqX6t9au5bJJ5eUV2LlTkEGiY6QA7sJNR0cHSkpKMDY2RkhICCoqfmL06FGwt7fHuXPnqMBHXtTW/s1IAdzjyc2N26Ozc+dOVFRUgMm0gaam5q/+Le4NTlpaGi2DRIYWS0lJYs6cOZgzZw6qqqqwf/9+LF26DN27q+Lx48e/Cgf1ABoBSOHVq1fYt2+fwPtlZGRAW1sbJ06cAIfDQXx8PCWXKS0tFdtB7ujRo+2yiG9sbKTCHenkMuvXr6fkMuTC79KlS+0y5HB3F+yNaw2PHz/G0KFDcerUKT65jLS0NJycnLBw4ULaC3ZhYaHYsjVRGSkVFRWqV8nd3R0fP36Erq4uRo4cCTab3aZcRlhocVt4+vSp0Ar1vHnzMG/ePDQ0NGDXrl2YOHEi5OTkUFlZSTFfouLMmTPtsojnDS1WV1ennCofPXqETZs24fv379DR0QGLxaIMYFpjpISBzWaLbSjx+vVrDBkyBBcuXEBNTQ127NgBIyMjKCgoYM2aNXzSQ16IY8hBIjw8HAcOHGjzdWT/FgC4ubnhyZMn0NXVxYQJE+Dn59dmz0p7LeKFhRYzGAyq+FdVVUWFnSspKaGqqooKVBcV/4ZFPG9B6saNG3BychIoSAHihxYD3EWCuPLHL1++QFtbG5cvX0Z5eTkCAwMRGxuLrl27Um6Awsa1xca1REhIiEhyZzKeAgBcXV1RXFwMfX19kQtS7ZU//vnnn7Q9UmQ8haenJ4qKisBisRAaGgo1NTWq31kcfP78WexF4/8mfi+yfqNV3Lx5C3PnzqH+JqtcDQ0NsLS0RGBgIKSkpDBv3nyYmU0GwL0ojxtHz0hdvnyFYqRCQ7lSg1u3bsHLywsfP37CsWPHsWzZUqp/C/g7a4sOL1++RGJi4q/q2lskJCSgpKQEPXv2hJycrFBGqmXDqbS0NOzs7PDnn/ewc+dOSgaoqtqNOpELqyomJSXB09MTAPfCNGXKFEyZMgV1dXWwsrICm82CnJwcFi1aRNmUnj9/HqNH0zNSFy9epBip8PBwcDgcXLt2DWvXrsWnT59x/vx5LFiwgK/qmpiYCH2jCfDaHoKKunpUVFSA4BAAgGfPsqCsrAxV1e6QlOyApqYmfP78BSNHjkRxcTEYEgwoKChAWloGm7dsQX5ePnZt3wovJyeod/y7qicnJwsXFxekpaVj27ZtiIuLQ1xcPNTV1eDs7IyysnKhfWRJSYlYu3YtNUdk/1ZNTQ2srOaAzWajY0cFyk0R4LKXI0eOoH0/ciHVqVMnjB49GhwOB+fPn4ebmxs+f/6C69evUzJAEmTWFh1evnyJ5ORkSEpK4tGjR9i+fRsqKysxZMgQyMjICGXtlvD0pQFcmezq1avx5EkmgoODEBcXj6ioaPTq1RMODptRUFAvlJEKDg6mNPoMBgOurq5wdXVFRUUFBg8eDEdHRygrK2Pjxo0iOWYlJCSIbREfEhIiVIYhTC5jYGAAOTk5sQ05nj9/LnbPRHBwMGW3zyuXKSkpQWBgICIiItCtWzf4+/tTN8PHjx8XuxlbnB4pXjx8+BBZWVmQlpbGmTNnRJLLtNcivq3FG8A9r3l7e8Pb25vKInN1dYWGhgZYLJZIBhPR0dGUlExURERECJUG8vZvHT9+nDLzmD59OiQlJcVeJLTXIp5kpOTl5cFisSj3Nl1dXWhpaVEGMGTR7vz58+0y5KiurhZb/piZmYlXr15BWlqacgPkcDhYsmQJXFxcaK9rQUFBYrtgispIKSgoUDfQnz59gp6eHtavX49+/fohKChIpP7N9lrET506lfY5skDasiBFFlrENeRITU0Ve+Ho7+9PtSEoKSlRxb03b94gICAAa9euhba2NoKCgqj7hxs3blDHlKgQVnBsCy9evMDr168hKytLuQFKSUnB2dlZaEFq8+bNfIodUSCqRbyqqiolVc7KyoKpqSk2btyIkSNHgsViiXROO3HixH8NiwX8XmT9RisgCAJVVZW0FbRz585j5syZWLlyJUpLS5GQkIBDhw6ia9euyMvLoz2ZVlVVQUICAic/U1NTvH79GlOnTkVNTQ3Vv7VgwQKYmprSZm0Bghbx2tqDqYqcvb09amtrYWNjAxMTEyxZsoRauPFmbfGCDC3mlQG+evUKsbGxePr06S8XpnK+/i26HikSV69exfTp07F69WoUFxcjLi4e+/fvh6qqKnJzc2kziOhCixkMBqZPn47Pnz/DzMwMVVVVYDJtAAAuLi4YP94Qf2U9h8+WLZCQYCApKRH19fVYt24dVFRUICkpiU6dOqO5mYP37z8gMioSABAcFIS6ujoEBrIxePBgKCp2hhSjA3QGDYC6tDSmmBgL7N/Tp1xpn5paD0oGmJWVhbCwcDx//gwTJkxAZWUlX6Aw9wJRQXuBuHXrNqZNm4q1a9f+6t+KQ2xsHDQ01PH16zfExQlW6klGincbDAYDlpaW+P79O0xMTFBQUABbWzt06qRAuQEKY6RahhaPGzeOalC3tbVDbW0N7O0dYG4+E7Nnz6aOt8+fvyAgQFhocQ/07NkTmzdz+7cePnwIP781uHTpJSwtLVFVVcX3HXM4HBQXF9OGFl+8eBELFixAREQEPnz4AH9/f3h4eLQqlyEZKXEt4i9fviwSI8UrlzE0NERVVRUmTpwoslymPRbxBEEIDS0mwzMBfrnMH3/8gRcvXohtDxwaGoo5c+a0/UIetDTksLKygpWVFSWXIfu3Vq5cybeQbY2REob2WMTfv38fc+fORWxsLJ48eQJ/f38UFBRg7NixYLFYtGYwDQ0NqK2tFenmhxdnzpxpU/7IYDCwaNEiStZoZGSEiooKTJ48WaT+LaD9FvHCQouzsrJgbm6OPXv24P79+1i/fj2Ki4thaGiIx48fU0UGUREdHS2UFROGlowUrxsg2b+lqKgILy8vPttwYYxUa/D398emTZvEGvP+/XuYm5sjMTERt2/f5oun2LRpEy0D0tTU1C6L+KNHj+LGjRutvoa3IPXz508YGxujoqICM2bMELkg9e7du3b1SAmziNfW1sbx48cBcM+pdnZ2qKysxNSpU3Hv3j2xe+3+DYt4XjfAwMBAhIeHQ1VVla8gBQhnpFpDeyziy8rKMH36dBw8eBCnT5/GkiVLUFtb22pBiiAIlJWViX1d+9/E70XWbwjF8+fPhWbeXL16hZL2ke5oANfxbe3atXB1XYFBgwbCycmJaobn6rvpGanHj58gMXE/GAwG1b8VHx+PvXv3ori4GB8+fBCo/nCdDW1o36+pqRmHDx/+1b91EE5OTpCRkcGYMWNadTZsGVo8dOhQ7Ny5E7a2dpg4cSIlA5w0yRSLFy/ChQsXhVbJSUYK4MoA/fx8f33Wx/D09MTKlSsxbNgwODk5URK2xMRETJ/eemgxg8FAaWkp+vTpg6t37mDngRT8qKhAXl4+NDU18eLFS8jJyUFOThZdu6qgubkJL148R69evaCq2h0MCe6FpLmZgy1btqK+vh6nTp1CZVERovw3QV9HB5pCnQ338/UTAdwsn7CwXbC1tcXYseOwbt06cDgcTJkyBfPnz2+VkTp//m9pH7d/iw2Am1e1caMPVq1yo2SA5MUiKSlJKCNFLqTIBVNeXh7i4+MRHh6OoqIiFBQUCnz/wkKLuRdcAsePH6f6t+zs7NCpUyeMHz9e6I3nvn374e7O31Cvo6ODpCRD6Os7Yty4cZg2bRokJCRgY2MDW1tbHDlyRKi0LyEhgeq1GTBgACUbvH79OsWyTp48GT4+PujYsSMArv0umVsiKvLz80XukSIhKSkJCQkJvHr1ipLLkP1brcllgoODxW52Pn78uEhSLV65zOnTp3Hy5ElYWFhgxowZ8PDwEIkpaa9FvJubYFg1nVxm586dUFNTw7x589rVI1VQUCC0N1MYYmJiqEXCmDFjqAb148ePY8GCBaivr8ecOXPg7u5OFaTEDS0GuD1SMjIyYskfZWW5qoN3796hoKAA/v7+VP8Wm82mLT4A3MWmuDlS58+fF3pdi4yMpKR9hoaGVP9WcnIy9u/fj/nz52Px4sVwcXER6Xdy4sQJsXukhIUWKygoYPPmzdi8eTO+fv0KPz8/bNy4Ef369cPy5cvRrVu3doUWt8e1j1wkTJo0CZMmTQKHw6F6JAHA2toa9vb21P60xkgJQ3ss4jt37gxpaWl8+PCByt/ijacQ1kPeVmgxHa5fvy4SIzVjxgzMmDEDTU1NiImJQWZmJqytreHo6IglS5aI9J39mxbxrRWkbG1t2xVa3F6LeJLVIuX2vPEUMjIyAgWpjIwMsaMG/rch3kz+xv8pHD58GLW1tQKPcxkpCdqT359//gk3t9VITk6Cvr4+fH19YWNjg8TERDx+/BizZwtWJ3NyctC5M39osbKyMnx8fNC3bz+4uroiIWEPmEwbbN26DaWlpQDIaqSgLJHXIp7bv2WLxMREBAcH4/Tp0/j8+TM8PDzw4cMHagyXkaoUGlo8duwYTJkyBQkJCYiLi0N9fR0cHBwQERFO24xKx0iRSE9Px8qVK5GYmIg//vgDnp6esLW1xaFDh/Dw4SPaCnpeXh5yc3MQH5+A2to6vHzzBrrTpmPhilXQ0NKChYUFtmzZAh8fHzQ3N0FZWRlDhgzBy5cvUFr6A2pq6pCSkoaUlCQCAgKwc+dOavGrICeHjS5OOLU3AQG+fjhy5Ai+fPmCDRu8kZ2dzTdHFRU/aRmpS5cuY9SoUZg1i1sFjo6OQWlpGezs7LBrVyhGjBBcZNXW1oHD4fAxUiSysrLg4uKCxMT90NLSwpo1a2Bv74ATJ04iPT2NVtLGDS3mN+TQ0NBAYGAg+vcfgCVLlmDHju1gMm0QGRmJqqoqAIJZW7z7QIYWk/1bSUlJ8PLagP37E/H1azZ8fX2Rl5fHN0fl5WW08plr187D0FAHLi4uSE1NxaVLl/Du3TsYGBhg9erVmDx5ssCYuro6NDU10VbupkyZgmvXruHBgwdQV1fH1KlTMWHCBCQlJeHKlSsiZ0KRaK9FPFmdJuUy6enpCAkJQVhYGHR1dWFra4vc3FxqDBlaLK4hR1xcnNjszbt377Bx40bcu3cP8vLyMDU1hbGxMY4cOQIOh0M75p9YxLcVkEzKZdLT0xEQEID169fj06dPcHV1RVFRkUjbOXXqlNgLrNbkjwsWLMCdO3dw584dNDQ0YMKECZg0aRLOnj2Ls2fP0rqctoaAgACxe6SePXsGNTU1SEhIQF1dHXv37kV6ejo8PT3h7e0NHR0duLu7U+d+Enl5eWL3SAUGBvKZ85AQJu1jMBgoKyuDh4cHbty4geLiYhgZGVG/P2EQx5CDFxkZGVi8eHGrr9HS0sKBAweQkZEBFxcX2NjY4PPnz/Dy8sLPnz9F2s6/aRHPYDDg5OSEv/76C5cuXcLHjx9hYGCA6dOn4+7duzh27Bi8vLzE2lZgYOA/kj+SBamMjAwsWbKEis7w8/Oj+rxJiBNaTCI0NJSSLosCSUlJisk+c+YMnjx5AgMDA5ibmyMtLU3ouH9iEd+W6yFZkEpPT8esWbNgaWmJr1+/YvPmzairqxNpO7dv30b//v3F2jdhFvFkPMWDBw9w7Ngx3Lp1C3p6erCyssLTp09x+fJlscPD/7chQRDE//Y+UBg79g/i8eOk/+3d+A1wL8pRUVFobm7Gq1evoaLSFfb29hgyZAgiIiKgpaUFS0tLgXFMpg3FtpBobGxEdHQMLlw4jwEDBmL+/Hl8N5SbNvnCysqS1lmQybRBcnIS9ffNmzdx4sRJlJeXQUJCAikpKXz9WwCwatUqvqwtEqT8Kzk5Ca9fv8a+fftQUlICbW1taGhooqyslNbSl7uYiqBYAhI1NTVwdnbGwIGD8PHjR6iqdoOzszP69++P6OhoqKmp0Tqu0c1RfX09IiOjcPnyJQwaNAhLlizha4z19/fH9Okz8PVrNk5cuoyC6hosWbYM442M4LHeA9LSUqipqYGamjoGDx6MK1euoGtXZUhISEBRUQlycvL49Okj1bsQEBAABwcHjBrYHz3k5cD4lTfBO0dZWVlITExCeXkZRowYAQ0NDeTnF2Dt2jW0c0T2kfGitpa7GO3fvz+ys7OhoaEOZ2dnaGlpITY2DsrKXbBw4UKB97OxseFjpMj5joiIxPXr1zBkyFAwmdZ8RiQBASxMmzaVtjLLZDKppnIOh4Nz587j0qWLqK6uBoPBQEpKikD1zt3dHWvWrBG4EHDnyBbJycl49OgRkpOTUVlZhXHjxkJDQxOfP3+ivTF1cnLC9u3H0aULfxxCXV0d9PX1MXjwYHz58gUDBw5EUFAQtLS0wGazoaioKPLip7y8HJ6enjh58iT09fVFlssAgJ6eHtLT00V6LYnZs2djy5YtQpkGgHszFxYWhsrKSkybNg19+/bFo0ePaE1uhKGurg6TJk3CgwcPxNo/fX19/Pnnn3wLJlIu8/DhQ3Tv3h1+fn585x4nJydMnz69zQUTLx4/fowtW7aI3QNHzvmpU6cQExODuro6WFhYYN26dUIXeZMmTcLRo0fF6hfbsWMHOByOyE3mBQUF8PDwwOXLl2FiYiJy/xYA6OrqIiMjQ+R9A7iV7I0bNwp1l+VwODhy5Aj27NmDxsZGzJ8/Hz179sS1a9fE6utramrCqFGj0Lt3bxQVFVERGqTBS21tLS0zZmhoiFu3bvEtmL59+wZ/f3+8ffsWvXv3BpvN5mM2Vq9eDX19/TYXTLx49eoVfHx8cP78eZHHANzj6MGDB0hMTERycjIIgsCyZcvg6OgolJUwMzNDYmKiWBK+yMhIlJWViVzs+PjxIzZs2IBbt27B3NwcQUFBIpsWkJ9JHFZl0aJFcHNzE+pgyOFwEBcXh8OHD4PBYMDW1hZqamo4evQokpKSRN4Oh8OBgYGB2OfL8ePH4+rVq3zXSbJ/69u3bxgyZAgCAwP5vhNPT09oa2uLZRP/4cMHuLu74/Lly2Ltn56eHlJTUxEREYHTp09DWloaLi4umD9/vtDvYdq0aYiNjRXLjCIhIQFfvnwRWZaYlZUFPz8/KCoq4uDBgyJv5/8lJCQknhAEIXAC+y0X/A1apKamYsqUqfjjD261+cOHD0hISEBRUTFyc3Nptel0jBTAZZNKSoqxc+dO9O7dG/HxCUhJOQgVFRU4OTkiNzeH9uJKF1o8efJkTJ48GStWrKBcCaWlpbFw4UKYmJgIdTYE+C3ihwwZQunXb9y4gS1btqBXr15ISTmIxYv/DgUmGamWCyyAKwuztLSkFlKvXr1CdHQ0ysrKkJ+fj+PHBYNZeZ0NeSEjI4PKyp/Yvn07tLS0sG3bNmzbtg1//PEHnJyc8PXrN4waNw7dhwzFpafPsWLaVOxJSMDFi5fQ0FCPzp07Ydq06Th8+DAV1NepU2doavbE8+dZkJKSpiq0HIKDDpxmTPpjCORaSF4uXryIUaNGAuDKACMiwik3wNDQndDS0sKxY8cwd+5cao5qa+tAEPTBzklJibC0nE1J154+zcKuXbtQXl6BgoJ82vDagoICAUYK4LJJdXW12LJlC3r37o3Y2FjExOyGpqYGXFxchDobtrStZjAYsLKyhJWVJdzc3NCjRw+B/i2y0ZjuwsEbWszbv3XmzBlERIRDS6s3zpw5i9mzLajvub6+Hk1NTejSRfCUu337dtjY2FBOe7yuWUVFRXj//r3AGGFQUlJCc3MzUlJSMGDAALBYLKp/KygoiLZ3EGhfjxTJSLW2wAIE5TKrV6+GtrY2Dh48KLJcpmVosSggLeJbLlaEyWWGDx8ONpuNZ8+etcuQoz0W8SQjNXfuXMoAIjw8HCYmJpRchvdzt9eQ4+zZs2LJH9XU1KCoqIg9e/ZAS0sLfn5+KCgooNwAheWhtdciPj8/X+gCC+D+ZpcuXYqlS5eirq4OO3bsgL29PYYNG4ZLly6J3PcUERGBRYsWYdOmTeBwODh8+DBmz56NpqYm5Obm4vXr1wJjhDFSvXr1om7Myf6tkpISGBoacqMvHj4UO7Q4ICBAbPkjyUgxGAy+/q0tW7ZQboBeXl58uUft7ZEi2QVR0b9/f/Tq1QtRUVFQV1eHq6srysvLMWnSJGzcuFEoO/M/ZRHPYDCoDEcynmLt2rUYMWIE7t+/L7K9/D+xiG/5mVv2b9na2qKqqgrTpk3Dhg0b8Ndff7XLkKO9FvGSkpJYv349dTyz2Wzs2rULPXr0EChItXadbA0pKSliyR9HjhwJe3t7dO/eXazt/EeAIIj/mH9jxgwjCOLx73//Af8iI5kEh/NI4PGvX08TixcPJJydxxI2Nn8Q+/evJBoa0giCeExs3DiVePIkgfb9rK0Fv9u3bw8RTOYwYtIkRWLLlrnEjx/X+Z5fuVKPyM09JzCuufkhYW09lPq7uPgqsWXLXMLaehixaNEAgsWaRbsPdnYjierqewKPV1ffI+zsRhJ1dfeJvXtdCRubPwhn57HEnTs7ichIG+LUqY1CP1Nz80OBx3NyzhILFvQjnJzGELa2w4mUlDVEY2M6QRCPiU2bphEZGbvbnCMPDxPi9euDxPPnScRy62GE0YwehEeoNXH/yxnCjDmcmGo7ijCc35+Y6TiOSL4RQujP7UuYMYcTpsuHE3PdjIig/W6EydIhxLPiG8Sz4hvEXLcJhBNrNmG1woCYxxxOsNgWtPtgbz+SqKy8K2SORhA1NanE7t0OBJM5jFixQpd48CCK2L3bnjh+fAPt+zGZ9HOUl3eemDOnN2FvP5KwsxtBHD++gXqdv785kZYWLWSOhgo89uRJAmFtPZQwMelMhIcvF9j/1asNic+fTwo5jv6e89zcc8SmTdMIa+thhLX1MIItZI4cHEYR5eW3BB6vqUklbG2HE5WVd4mICGuCyRxGuLkZEE+eJBDx8U7E4cPrCYJ4QbSEnp4e0djYKPD4169fCSMjI4HH24KOjo7AY1evXiXMzMwIXV1dws/Pj6iuruZ73sLCgnj58qVY2zl8+DDh5uYm1pja2lrCwMCA+PHjB+Hu7k7o6OgQM2fOJNLS0lodJ2yOWoOjoyNx9uxZkV9/7tw5YsyYMUSXLl2I4OBgora2VuSxdHPeFkxMTIjv378Lff779++Ei4sLoaurS1haWhJPnz4ltm7dSmzfvl2s7Xz//p0wMTERe/90dXX5/m5ubiaOHj1KGBsbE/r6+sTOnTsFvhMrKyvi0aNHYm3n9OnThJOTk1hj6uvrCT09PSInJ4ews7MjdHR0iHnz5rV5DBsYGNB+r9++fSN69uxJ6OnpEZMnTyYuX75MPbdq1Sri6NGjIu1Xc3MzkZSURIwePZro0qULERUVRTQ3N4v8uVrOuSgwNTUlcnJyhD7/+fNnYvny5YSuri6xZMkS4uPHj0RYWBjBYrHE2s6PHz+IiRMnir1/urq6fHPQ3NxMxMbGEoaGhsT48eOJvXv3CszRwoULidTUVLG2c/nyZYLJZIo1pqmpidDT0yPevHlDLFy4kNDV1SWsra2Jr1+/tjrOwMBA4BzaFjw8PIj9+/eL9NrGxkYiPDycGDVqFNGlSxfi4MGDYh1H7TkfTZ06lfj8+bPQ5589e0bMmTOH0NXVJRwdHYmCggIiLi6O8PHxEWs7lZWV7bqubdiwgeBwOGKP+38FAI8JmnXN756s3xBAeXk5OnfuDIlfEjJexMXFwdPTE3FxcUhISECHDh3g7OwMZ2dnvHr1ijawkhtaLFhBHzRoEBQUFHDgwAHo6OjAx2fjr/6pJNTX1wtlpLgW8X/r8MmQ1OTkJEo/z2TaYNu2bSgrKwcAVFdXAxB0NgT+Di2WkZGBvb09EhMTERQUhNTUVJw8eQIPHjzAx48f+cbk5eVBQYE+tDguLg4eHh6Ij49HbGws6urq4OjoCFdXV7x+/Zo2ayszMxOFhYVwcHDAxYsXUVRUBG3twegzeBAY3Xtg07Yd6Ne/LwIDA1FTU4Pm5masX78e5eVlOHDgAGRlZSEvL485c6zA4TTj7p27UFRUohgUDqcJG9etxbGocEjW16KkuBjW1tYIDQ1FZSU3KLc1RioxMRHTpk2DnJwsXF1dkJSUBF9fP1y9eg1Hjx7D48dP+Pq3AJKRop+j+PgEeHp6YO/evYiOjkFJSQlsbe2wcuVKvHz5gtYEgutsKGjIMXr0aCgpdcG+fbz9W/Y4deoUmpubf1XaeguMaxlarKGhgeDgYCQnJ6GhoR6FhYVgMm0QFRVNafhbZm3xgrSIJ23cSWv/U6dO49ChQ3j58hXy8j6Dm5fFRW5uLhQUFGib6AMCAsR2bMrIyKBlq6ZOnYrr168jNTUVqqqqmDJlCiZOnIjk5GQ0Nzfj+/fvbTJSLZGQkCA2e0OGFisrKyM8PBwZGRnYvn07QkNDoaenB3t7e74eN4B7HIlryAFwjXtmz54t8ustLCygoaGBmzdvQlZWFqampjAxMcGxY8dAtCKrP378eKssDB0aGhpQX1/fKiOlqqqK2NhYpKenw9/fH2w2G1u3bsXHjx9F7t8C2m8R35KRYjAYWLhwIe7cuYPbt2+jrq4OEyZMwOTJkyl5W15enthzERUVRRneiAoytFhTUxP79u1DRkYG1q9fjw0bNqB///5Ys2aNQP9Waz1SO3bsQEhICNLS0rBv3z4cP34curq6WLBgAVJTU0U2kSGNm/r06YNz586hqKgIhoaGmDp1apsuea2FFgsD2UfWGiPVp08fHDhwAOnp6XB0dISbmxsCAgLw8+dPkfu3gH/PIp7BYND2pU6fPh337t0D0L7Q4rCwMLF6pIC/GanBgwfj6NGjSE9Px+LFi+Hg4AA9PT34+/sL9G+1x5ADAP766y9aIwo6SEpKwt3dHQMHDsSBAwfw8OFDGBgYYNasWW1KcdtrEV9RUdEqIzV8+HCcOnUK6enpmDlzJpYtW4YNGzZASkoKDQ0NIm+rPRbxpDqH7p70Px50K6//rX+/maz/jH8nTnjTMkhcJoH+O7pxYxsxe7YmYW09lFi3biLx+vVB6rnWGSn+92toSCOSktwIc3M1Yvp0VeLmze0C44QxUlVVfxJ2diOpv69f30o4OY0hbGz+IOztRxInTngL/Ux0bEtu7jli5Uo94uXLZGLt2gmEtfVQYvv2BURp6U2RGSnef9evbyPMzdUIa+thhKfnJOLt20PUc25uBsTXr6eJnz/vEKtXGxKmZsqEvcck4sT9aMJyhQHFSFmuMCAuZO4jJiwaRJguH0ZMXKxNTLcfTRy8vYswYw7nY642J64m5rqNJ0yXaBOrvSYTzc0PKUaKnP8LF1iEg8MowtZ2OOHiMo44etRTrDnKz79ArFihR2Rm7iVWrzYkrK2HErt2LSV+/rzTBiMlbI62EjNmdCesrYcRPj5TiK9fT1PPrV5tSHz5clKk46i6+h4RHW1LzJqlTkyfrko8fBgrMM7BYRTx8+cdgcdJRop871OnNv5i3EYSq1cb/mKkBPedyRxGMZa8/woKLhIuLuOIjIzdxMqVeoSZ2Rhi48aNRGVlJWFra0tcunSJoEN7qpHm5uYiM1JlZWXEunXriH79+hE9e/YUq3JMMlLioi1G6sKFC4SpqSmhp6dHsNlsora2lnB0dCTOnTsn1nYePXpEzJkzR6wxzc3NxLhx4/geKy4uJlatWkXo6uoSFhYWtCyNsbExUVxcLNa2/gkjdeLECcLExITQ19cntm/fTtTX17c6rj3siJWVFfHkyRORXpuXl0c4ODgQ/fv3J3r16kW8eCHI1gpDfX09oa+vL/b+6evr0zJSxcXFxMSJE4mUlBRiwoQJhIGBAREREUE0Nja2yki1ZFtIJCUltZu94UV2djbBZDIJXV1dYuHChcTbt28FxpiamhJ5eXlibScsLIxgs9lijfnx4wcxYcIEYs+ePYSRkRExfvx4Ij4+vk2mRNgctYb58+cTDx48EOm179+/JxYvXkwMGjSI6N27N5GdnS3ydhobG9t1nBsaGgplpBobG4moqCjC0NCQMDIyIpKSkojm5mZi/fr1RFJSkljbefv2LTF9+nSx96/lNeDly5fEvHnzCB0dHcLe3p72eJkyZYpYc0cQBBEXF0ds3LhRrDEVFRWEoaEhsWPHDkJfX58wNjYmjh071ua49hxHcXFxxMePH8Ua8/8aEMJk/e7J+g0BXLp0CRUVFVi+fDlfP0N6ejotIwVwNf8xMTHQ0NDAu3fvsGfPHhQXF2PgwIEoLy+nZaROnz4t4A4oJSUFJpOJe/f+QmAgGwcOHMCBAylU/5aGhgZt1hbAtYjnDS0mwwobGxthaWmJS5cu4ebNm1T/FkBmbdGzLWRo8dChQ7Fr1y5wOBzcvHkT3t4b8PbtWwwePBijR4/mq7CTWVt0OH/+HHbvjkXPnppITEyCh4cHlJW7YtiwoSgrK6MYiMrmZrBjE1BZXYXdu3ejvLwc0dFRWLBwIWpqqhG2axckJCQgKSkJDw8PnDlzBnv27IGsrCzy8/OgrNwVADDLfBZs5s+D9wpXaKqowNbWDpWVP6lGbAaDAXNzc5ibm6O2tg5z5ljh8uUr+PPPP7F06VKqklhQUNAqa7d8+TKMGjUSo0ZF/OrfuoS1a9fiw4ePGDp0CHR0dPjGPn2aJTS0+OLFi4iJiUHv3r2RmZmJnTt3oqKiAqNGjcKPHz+EOhu2tIiXl5fHypUr8fTpU3h6euLgwYOIjo6BpqYmXFxcoKKiItTZMDn5b4t4BoNB2cvW1NRgzpw5qKiowIMHD8BkMqmqfcusrZZztHTpUujo6EBHRwccjjL27LmO6dOn48WLFzA0NASHw+Gbo7S0NKF2w8LA4XBQVFQkMiNFNvs/efIE27ZtQ3h4ONavXy8QnkmHnTt3tssinq7Xjhfk8djU1ITo6GgqQ2/ixIkCc9QagoKCEBQUJNb+nThxQsCpTkVFhTLoeP78OdhsNnJzczFixAgEBgZCWVkZ9fX1QnuUhOH8+fNiW8STjNTcuXMxb948NDQ0YNeuXTA2NoasrKxA/xbwz3qk6FQJdFBXV8eePXswadIkeHp6YtOmTSgsLISuri5YLFarmTb/xCKejpFis9lwdXXFwoULsWzZMtTU1GDHjh0wMjLC27dvKYtxXrx48UJo1taFCxcQEhIi1v7RWcRraWlR/VupqalYu3YtSkpKMGHCBPj5+aFjx47tCi1uj0V8YGAgnJycsHTpUjg4OFD9W4aGhlT+Fm//FsDtN26PRXxOTo7IFvEDBgzA4cOHYWZmBhsbG6ov1dTUFD4+Pq2668XFxf3rFvGSkpJYtWoVVq1aRcVTxMbG4v3792IbkwQEBFChxaLi2rVrGDx4MN9jQ4cOpfqYL168CGtra1RXV2P69Onw8vKCtLQ0KioqxL52HDx4UGyL+M2bN8PGxgYODg7w9PRESUkJAgICqP4tf39/gXOIqKHFLfH582f069ev7Rf+B+L3Ius3+PDt2zfMmDETtbVc5zwpKSnMnz8fZmZmSEk5CF9fweDClmYTgwYNws6dOwEAQUHBKCsrg42NDSZONMayZUspN8ArV67QOoyRocUaGhpUdsWbN2+RkJCAly9fQlOzJ0pLSwUu3o8fP6GVxRQWfkffvn0RFRWFkpISJCQkICkpGaqq3VBTUwMbGxvauWgZWsxgMDBlyhR06dIFp0+fRn19PRwdHSErK4tFixZR8quWWVvkHBUUFFCLi/T0dCQmJkJZWRnBwcH48eMHmPYOGDHRBOVgoJOiIjopKqKpqQkuLq44cOAAtm3dhqamRhAEAW9vb8TE7Ia6ugZWrlwFNpuFhQsX4fDhI8jOzoamajd07yABqYYGyMnKwtPTAwCwbNkyWot4ru14P8TERKOgoPCXHHQP1NXVUFtbi+XLBS2PASA7+yuftI/BYGDWrFnQ1OyJI0cO48ePH7C1tYOCQkcsX74cenp6tFlb5BzxhhaPHj0ao0ePBofDAZvNRklJCezt7TFt2nTMnTuHOlHzZm3xgpQ/kqYPAHcRvGPHdnz8+BG9evUSCAUmvxu60OKKip/o27cvdu/ejZycXMTFxSEqKho9e2qirq6ONmsLELQHZjCq4ezsjOHDh2P79u2UXKZLly7w8fHBhAkTsHnzZuzYsYP2/YShtawtYSBDi/X09CgzmytXrvCFZ3p5eQnciFy6dEmk0GJeBAQE0Lp30kFSUhJr1qyBoaEhWCwWMjIyEBkZ+Stvzq/VrBTytyaqGx6J2NhYKl+LDqRcBuBKlpcuXYr3799jyJAhaGhoENnyvbCwELKysmJbxLcMLZaWloa3tze8vb1RWFgINpuNkJAQqKurIyAgACNGjGhXaPE/sYgnQ6o5HA5lkNPQ0IC5c+di9erVAgtsUUKLW6I1i/hHjx5RDqoAt9jCYrEwZ84crFu3DidOnKAWx6GhodDW1gaLxRJqNiEstLg18GZt0WH8+PG4fPkylb81a9Ys5OTkQFtbW6xCQsvQYlGRnp7Od75UUFDAli1bAHDPVbz5W4GBgejXr1+rcyQMly9fhra2tlhjSIt40uSEw+EgPj4e06dPh4SEBGxtbcFkMgXm6OjRo7h+/bpY2woKChLZsY+Mp3j37h3s7e0RGRlJFaQCAwOFGgqRaK9F/J49e4Q+z1uQioyMxKRJk1BUVIQhQ4aIdRy11yK+ZWixiooKYmJiAPxdkMrLy8PIkSPBYrGohZe4EvhPnz7RRqL8t+D3Ius3+HDr1i3MmzcPnTp1grW1NUpLS5GQkICUlBTk5uairKxMoDJ66tRp6OjQX4iys7Nx4sQJSElJ4fDhw3BycoK0tPSv6iV91lZLRgoAtLUHIzQ0FEymDRYtWgQfn41oaKiHsbExlixZgsLCQlpnQ4AMLeZqoVVUVKiK0uvXr7Fq1SpER0dDW1sbzs4u6NJFCQC9syGJ5ORkbNjgjZ49NWFvb4/i4mLExcVj//79yM3NRX29YL7EuXPn0bFjR9ja2qFz504oLy+jqt9fv31DVPIBlDc1Y+fOUJSVlYPFCsCMGTPQoYPkrx6hRjQ2NsDb2xvh4eHYunUbpKWlcf9+Kv744w9ISUlh8ODBGKqtjeANXlhsZopNXp6/XLvGoampCd+/f4eiohI6dOhAO0fkQkpNrQfYbBYALuu0bt1alJWVIS0tDQ4ODhT70xojlZi4Hx4eHujVqxdcXV1RUFCAuLg47N69W6DnhgQ3a2ukwOMMBgN5eXk4ceIEOnTogMTERMoNcOHCRUIZKbrQ4rFjx2Ls2LFgMm0wdepUuLuvAUBg5syZsLS0xPfvRUIZKd7Q4p49NbF5czAA7rHi5eWF4uISPH36FHZ2dtRxzZu19TfqATRi8+bNCAkJoW5EPnz4gICAAHh6euLLly+0jpatgTe0WFTQhRaTN8pNTU2IjY3FlClT0KFDB9jb22PZsmUoLBTMIxMFL168aPWmgQ7BwcHYvn071avC6wY4bNgwBAYGClT/6RiptlBXV4eGhgaRGSkrKytYWVlBX18fkyZNosJBt213AAEAAElEQVQzV6xY0SbDJyy0uDVkZma2ynL06NGDWoBlZmaCxWKhoKAAX758EZsd4Q0tFhXh4eF8jBSDwcDixYuxePFi1NXVYefOnZgwYQI6duwId3d3mJubo6ioSOzQYoBb4c/KykJBQQFWrlxJHYfPnz9Hjx49BK4BDc1N2LQ1COsDNmLE8OHIzHyK0OCtVPU9OzsbAwYMENjO+fPnxV6oC8vaogNpIW5rawt9fX2MGDEChoaG6Ny5Mzw8PNp0rxMWWtwaXr582Soj1adPH8oi++7du1i1ahXKysrw7ds3KoBYVISFhYk9pmVoMYPBgKurK1xdXfHz508EBQXBwMAAysrKVDxFe3uk7t+/LzZLyWKxsG3bNmrBdPnyZdjb21PxFHQFKTpGqi1wczt/isRISUpKYt26dVi3bh0MDAygqakJAwMDdOvWDf7+/m2eC4WFFreGDx8+QFlZWehxRFeQqq2tRU5OjtjHxIkTJ+Ds7CzWmP8k/Da++A0KBEGgqqqK74ZVWVkZ3t7emDXLAhMmTMD+/fvBZDKxZcsWlJSUAACuXr0CW1tbgfcjGSl5eXlKBpiYmIitW7ciJSUFxcVFWL9+Pd6+fcs3LjMzExYWgqHF3759g6JiZ5iZTUZ8PNd4g8Mh4OjoCFtbW6FNw7m5ubTN2FVVVTAwMEBycjLGjBkDb+8NsLW1RUrKQSQlJdFWS7msHX9oMbe67gtLS0vo6+tj9+7dYDJtEBISgoqKCgB/y+CSk5PQr18/cDgcMJk22ODnj3IpGVRLdICUlDRKSkowdeoUcDgETp8+jZqaavz8WQlnZ2coKHT6dVGQgLS0DAIDA5GdnQ1vbx9UVVWj4MsnKNRUoqssdxG7Z88enDx5EurqanBwcICtrS1Gj6avULdkpEgQBAf6+vpITExE//4DsG7dOtjb2+PYsWPYv38fXFxcaOeoouInX3VPTU0NbDYb8+fPx5gxY7Br1y4wmUyEh4dTocDnzp2lbazmDS0mZYDJyUnw8fFBREQ4vn//jk2bNiEnJ5dvXEZGOq3td0FBIRQUOmLOnDnYt28voqKikJeXD1tbO9jY2Ai9KH358oW2GVtKSopi6NTV1eHmthr29g44c+YsEhMT4eIieIHgcCpQXFzMV+kl5TJubm7Q19enwjN9fX0p4xZhaC20uDVcvXpVaGixpKQk3NzckJqainPnziErKwsGBgYYN26cwOK1LfwTi3je3zVveKaFhQWsra2hr6+P4OBgKjwzNjZWbCOF9lrEy8nJYcOGDVR45t27d6GnpwdLS0tkZmbSjhMltLglgoKC4O/vL9JrR48ejTNnzsDT0xPDhg3DokWLYGBggJCQkDYb1P+JRbyw0GJZWVn4+vriwYMHSE5OxtmzZ6GnpwcdHR2xpYLPnz/HsGHDcOvWLZSXl8PIyAhmZma4fPmyANvS0NyE7JICfHz3ApWPH6Hyr/uQfP0Gx3Zsg/cmTyQcSoLXL6OM2bNnw9DQEFFRUWhqagLAlTKKexxFRkaKbCdPoqSkBLKysti6dSvS0tKQkJCAgwcPQldXF4sXL8aHDx9ox5EmDeKAzWaLzEgZGxvjypUr8PX1hZaWFqZPnw4jI6Nf1136IG8SwkKL20JrocWdO3dGSEgI0tPTERERgZiYGOjp6UFXV1csgxsAePv2bbss4lsyUjNmzMCNGzeQmpoKZWVlmJmZYeLEiTh48CA1R7t27Wq3IYc4qKiogKSkJBV2vnXrVmzfvh16enpwcHBAfn4+7bh79+7R3r+1hoCAAJEt4q2srHDr1i0EBASga9euMDExgYmJSauqARIEQaC8vBxdunQRa//+k/CbyfoNCs+ePRNaubt69SqioiKpKs2dO3fg6+uLmpoaSrbQEvv27RNgpADuwk1WVg5HjhzBu3fvsWfPXpSUlGDw4EEwN5+Fzp07C3Gki+eruEhJScHW1ga2tjZYunQZV3LHZKJbN24o8IABA1plpA4cOEDJEcn+rfr6eqSkpODly5cICgrCokWLYGxsTI3hzdpqiYsXL1FzxOFwcP36dXh5eaGurh4/fpRQso5nz57hwMGDKGloAjskFNX19fD09MCoUaOhqNgZDx6koaamFlVVlbC1tcWlS5cQHx+PDh0kQRDAihUrcPToESgoKGDp0mX4+O49WGtX4+DefdiV9ZTvhC4nJ0e5Py5duhQ5OTmwsbGBmpoanJ2d0bt3bzx9+lQoI5WUxO0d48oAzTFrFrd/KykpEc+fv8D27TuwfPkyvgUab9ZWS5w7dw5hYWHo1KkTOBwOzp8/jzVr1qC5uRmlpaW01cikJK6zYUtoaGhAQUEBR48eRVZWFnbs2I6fPysxZsxozJw5UyjbEhcXh2XL/pY/ysvLw82Nu9BYsmQJPn36BCaTiZ49e8LV1RUaGhpCGCkuEhOTsHbtGr7+raqqKuzbtw9ZWdxcMBsbG4wZM4ZnHg7CwMCA9v327NmDM2fOQFlZmZLLTJ06lap808lltm/fjgULFtC+nzDk5uaKzEiRchmAm1ny+PFj6OnpidS/BXCrpaQkSVScOHGC1omThIWFBSwsLCi5jKmpKTp06IDCwkKxF5sXL14UW/7o7+/PJ39UVVWl5DJZWVlgs9koKCjAyJEjwWaz0b179zYZKWEg30cckIyUqqoqGhoaEBoaCmNjY8jJyWHVqlW0C72wsDDaAldrKCoqEln+qK6uTklxhw0bhj///JNy8gsICGjze2OxWPDz84OsrCwCAgIQEBCA3Nxc+Pv749atW+jQoQMCAwPRd+AAfM75DOXvxficmoYJA4ci5+UbeB4+htxv36C68DuaOr1HdGI8jh47Bk0NDb7+LXl5eRQUFIjdz3bq1Kl290iR0NLSooLT7927B3d3d5SWlmLChAnw9fVF586d8fLlS6iqqrarR6o1qS0dwsPDceLECWhqaqKqqgqbN2+m5M0bNmzguz6SiImJoT1nt4bS0lJISkqKxEgNGDAAR44cAcDNvLx27RqOHz8OMzMz+Pj4tPkeLBaLuvaLitYYKUlJSaxevRqrV69GaWkpgoKCEB0dja5duyIvL0/sHqnDhw+LLX8MDg7ma30gC1IAl5Vdvnw5ampqMHPmTHh4eEBWVrZNRkoYPn/+jAkTJog1JiwsDGfOnEGfPn1QVFQEFouFnTt3Qk1NDX5+frQ9oGlpaWJL4P/T8HuR9RsUSDlYS1RWVgqYTZDViLCwcOTn5/H1b02ePBkAkJn5lFYWQzJSDAbjlwyQ279169YtrF27BkpKSkhOTsaSJUv4Fm+5uXl8N6okHj16hD59evPJAOPi4lBcXIzi4mKqP4wXwkKLZWRkoKysjHnz5mPRooWIj49HYmIiVFVV4eTkjEuXLiMyMkLg/UibV3KOGAwGpk2bhmnTpiEiIgJfvnyBo6MjOnTogIrGZnyprkUTh0B29mcMGDAQxcUl+PDhPaqra1BeXg5Ly9l4/Pgxjh8/Rt0E7wwNQWrqfYSGhqJz5864du0q9IYNg5acNP4YMADbt28Dk2lDexHNzMyElpYWZbn97NkzhIWFo7y8nAqKppujlowUAMjJyUJDQwNWVpZYuHAh4uLiERsbB3V17sLt/PnztCGctbW1IAiCYkoZDAYsLS1haWmJqKgovHnzBnZ2dujYUQFMpjV1g52RkYF9+/YJvF9BQSE6duTan5MyQA6Hg3PnzsPZ2ZnqnbO0tOS7iLQWWqylpYXg4L9lgNu2bcPPn5UoLf1BKy0hwxhbGnIoKCigX79+sLCwwIIFCxAXF4/IyChoafX6NUeHEBp6TeD9ampq+BgpXrlMeXk5dYPDK5cBuEWQ9iwS1q5dK9aYhw8fYsCAAXzhmWT/Fhme2bJHRNTQ4pZoq0eKBK9cZtOmTbhz5w4MDAzQvXt3gfBMOvwTi3hhocUjR46kpJunTp2iZHOlpaWUHEtUnDx5UmQTChItGSlpaWn4+PjAx8cHhYWFYLFY2L59O9TV1cFisaji2rlz59rVI7VixQqxxmRlZaF///44e/Ys1b81Z84cNDY2Yv78+Vi1ahXt95Gfny9wDdDU1ISFhQUkJSVha2sLD09PlDVUYrp6L7gz7XD86DEEBwdDRUUFZ8+exdOnT3H00CEUFhRAToYBQp57jSH7t8iF3IULF6Cnp4fevXuDzWa3aYtdUlLSrh6p1kKLJ0yYgAkTJoDD4SAxMRHm5uaUmkLcwOx/wyJeQUGB6sP59OkTFXrbv39/BAUFURbgx48fF3ux2V6L+L59++LixYvgcDiUAYaEhATs7OxgbW1Nu4Boj0V8Wz1SJJSVlREWFgYA8PX1xadPn6Cnp4chQ4YgMDCwzYIUGVrcHot4YaHFvAWpiIgImJqaQkpKigr2FgdkaLE4aBlarKqqit27dwP4uyCVn5+PUaNGUQUpgHt9EZXB/0/F70XWbwDgXpTv3LmDHz9+UO5rJPbt2ye0upmV9RSJiYlgMBgoLS1FfHwCUlIOQkGhIyQlOwhlpOjMJkxNTXHgQAr27t2DgwcPwdHRETIysli4cAEUFBSEOhsmJyfzVaWGDBmC0NBQcDgcWFnNQWRkJBoaGjBp0iQsWrQYUlKSOHPmjNCbr0uXLlOMFCmtePXqFSIjI/Dx40fExMTA0dGJ6t/izhE3a4sOmZlPkZi4Hw0cAt5bt6GqrAwrVrmhZ8+eUFLqgrKyMtTV1aCkpAQTJ07E16/fcPv2bXToIIn6+npYzZmDx48egyHBwAQjI9y6eRObA/xx5+xp7GL5o1OnTkhNTYW8vDw0NQVdHAFuzpWnpyf194gRIxAREY7m5mZYWVlh165daG5uxtSpUzF37lxISkri/PnzQuWF586dR0REOBQUFPj6t0JCduLDh4/Yu3cvHBwc+JppyawtOjx58gT79+8Hg8FAQUEBYmNjEROzGyoqXdGhQwehfWS8jBTAXZRYWVni7NmziI3djX379lP9W0wmE5KSUlBXb52RIjFu3DiMGzcOzc3NmD17NkJCuAtRc3NzzJ5tAQaDIZC1xT9H56gFMdm/lZGRgaCgIHz+/BZhYTuwYYMv3xzt2LEDCxcupH0/JSUlaqH3/v17+Pv7Y/369ejVqxckJSXFXiS8fv0aM2bQH7PCEBQUhG3btlF/z5gxAzNmzEBTUxNiYmKoi7eDgwOWLFkCBoOBo0ePil09Jw05xHXtu3XrFlJTUyEpKcnXvzV8+HCw2WxaZkIcQw4Sjx8/pnVMpcPcuXMpA4h+/fph9erVkJWVxYoVKzBv3rw2x+/evVvsHqldu3bB0tKS9rkePXogLi4OAPdz+Pv7o6CgAMOGDUOHDh3+sSGHKAgMDKRunlr2b5FsUseOHbF27VpKfnfmzBmhbF5kZCQOHz6MHj164PCpEyh6mYUPl29i3bp1+PDxI27evIl58+bh4sWLCA/nnrdSUlJQ19CAn4V5aFTsCinG3+eY27dvIz09HbKyskhNTcX69etRUlICAwMDbNq0CV27dhXYB9LZUBy01SNFgsFgwN7eHvb29qiqqsLAgQPh7u5OuQGampq2ua3w8PBWDTnoEB0dTevICAD9+vXDoUOHAHB/d66urigrK4OBgQE6dOgg9mIzLS0NoaGhYo0JCAjApk1cMy4Gg4EVK1ZgxYoVVEHK0NCQKkiRi6orV66I3SPV1NQkco8UL+7cuYPMzEzIy8vj8uXLsLW1RVVVldCCFMBlpEQ15CAhKiMlKSmJ9evXU8fz0KFD4enpiR49eohUkAKAkJAQsX/vpPsoHYQVpMzNzUEQhNjno/80/F5k/QYAbhXE398fJSUl8PPzo4Imly1bhqdPs2hvQriMlCL1w1ZWVoaPD1eny2WwJMBk2mDw4EFwdnamqvO5ubmthhbzygBJN8Dr169DW1sb79+/56uiCGOkAO5F2cxsMlatWoX6+nocPHgQjo4OkJGRRXFxEW1Fubq6mtYifujQoRg4cCBMTEzQsWNHbNjghcbGRkyaZIrFixfh8ePHWLlyv8D7ZWdno+JnBb6V/0Qlh8DLDx+gpKSMLl26gCAIcDjNyM7OwciRI6GkpISXL19CQkICzc1cE4y8vFxs3boNnTp1QkJCPEaNGIE+XbtAu1tXDHFywkonJ3z//h1xcXG4c+cOhg4dhi9fvvCFCpJNtHQOSBcuXICpqSnc3d1/yQCT4ODggI4dO6KoqIi2SZXL2gmGFo8aNRJDhmjD2HgiZGRksHbtWnA4HEybNg1z585FRsZDJCYKzlHL0GI1NTVK8rhy5So0NDSAybTB6NGjYG9vT22Xy0gJCy1W45MB5uXlITY2Fvfv38cff/yBnJxcPhmpMEYKAC5fvoJJkyZh3bp1qKqqwv79+ykDk6KiIlonQjK0uHPnznyP6+rqIisrCxMnTkRtrQqmTZtGuWbZ2Njg2rVrIjFSAwcOpG68p0yZgurqaujp6Yksl8nIyEDPnj3b3A4vWrOIJ8MzSWkTKZdRUVFBbm4ubt++Lda2yNBicdDSIp5OLlNdXQ1zc3OsX7+eusFpjZEShvZYxJ89exYWFhaIiYlBUVERAgICEBISAjU1NQQEBNA6+rW3R0pUi/ixY8dSbJKZmRl1kzx37ly4u7u3uXBvr0V8Xl4e7TVAVlYW/v7+8Pf3R25uLlgsFoKCgtCzZ09kZ2fjwoULAmMaGhpQW1uLHj16AAB+VPyAShMwYMYMlJSUQEdHBxUVFbC1tUVubi6ysrIwfvx43L59G3FxcSipqkVpTSW6KygBEAwtHj9+PMWUTJkyBcbGxlBUVMSiRYvg6upKFYBaOhuKAhaLJXal/s6dO5gxYwb27t2LL1++UAuNvn37IigoiNbqWhxDDl6IahFvamoKU1NTcDgcmJqa4vv37zAyMgKTyYSdnV2bN/90ocWi4Nu3b7SqBN6C1Lt378BisbB+/XoMHjwYHz58oKSGoiIuLk7sPtSWhhwtC1KTJ0+GpKQkHB0dsXjxYuqzp6amis0u+fv7i20R//TpU0ybNg3Jycm08RTk74kXLRkpUSGqRTxvQcre3l7snsP/RPxeZP0GAG5Ve9KkSZCQkICxsTEaGxtx9OhRMJlMFBYW4tatWwKNmHFxcUIbJn/+rERychIAbpVr48aNqK+vR+/evaGpSX9zx9sjRUJFRQXe3t54//49Vq92R3x8AkpKSqCtPRjOzs64ffu2QNYWicuXryAqKhIAVwZIVgKzs7Ph6OgIV9cVUFXtBicnJ8pdav/+/Zg5U7CPDMCvhdRKMBgMTJ06lerfWrZsGYqKivDXX39h4sSJfGNi9+3HYCNjeLDYaGxsgJycPOTlZcHhcPDx4wf069cPAwYMRH5+ARgMCVRU/ISOzjjK6EBDQxNdu3YFm83GxxfPEbNlM/bv3cOXfE7Koj5//gJnZyeEh0egvLwMw4cPh5OTE27evEUrswRAVXYBrgzQ1dUFrq4u+PLlCxwcHLFy5SpKBkguQLiMFH118+HDR0hM5DJSFhYWVP8W6Ur38OFDAY01r7NhS1RVVSIlJYWvf4sgCAwbNgxqaoIXAYDbw9VSBqehoYHAwEDY2tph+fLl2L59GyorqzB27FjY29vh1q3bAllbJM6dO0vJPxQUFKiCw4cPH+Hi4oxVq9zQq1dPuLi4UIt93qytlkhLS8PevXshKdkDdnYeqKioQHBwMMaMGdMu2drPnz+RmZlJyWWmTJlCVb6XL19Oe+MSHBzMx0iJAlEt4nnlMllZWTA1NcWMGTNElssA7beId3d3p32OTi4jLS0NU1PTdhtytMcinsy4UVVV5XMDDAwMREFBASWXIRdVrTFSwvD9+3exLeIZDAaqq6vx8uVL1NXVITQ0lOpNWr16tVBjATabLfYiQVSLeE1NTaqAkZqaCgsLC8yePRv6+vrw9/eninYRERF8SovainL06sD9Dd25cwcJCQmQkpJCfX09Jk6ciKDgYKh07Yrv378jPz8fyr00UFpdBfxaZLHZbFpDHwaDgcrKSjx79gx1dXWUy1znzp1hZWUlNGurNbTHIj48PBwpKSkAuG6AJDvF6wY4ceJEbNq0iSrytMZICUN7LOIZDAZqa2vx5s0bgf4tb29vgesjCV5GSlRcuXJFJIv4QYMGUYuqy5cvY+nSpViwYAGmTJkCb29vkWR57bWIt7e3F3i8ZUGKzWYjKioK3bp1w7Jly9C1a9d/bMghCnbu3EkVl3jdAM+dO4elS5eipqYG5ubm8PT0pM4le/bsEYk15cXPnz8BQCyLeGlpaWhoaIh9zP4n4vci6zdQVlaOzp078924S0lJYfny5Xjz5g2cnZ2RlpaGgwcPQUWlKxwcHKGtPRh5efm0F8v09HT07v03rU5WuUi9fadOneDi4oL58+dTP9jWGKlTp05j3LhxfP1b3FBgH7x9+xbLli1DY2MjX/8Wr7NhS5w/fx4rVqyAlZUVXr16hdjYWPz48QNDhw7Fs2fPkJIimLXFDS3mt4iXkZGBg4MDsrOzYW9vj3v37iE2NhZdu6rAbY07OvZQx/vScrDduTf8oaE7IScnj6ysp1BTU0e/fv1QW1sLBkMSNTXV2LUrDA2NDfDewD3xb926FX379kG/3lro3VkBwyYa4VySGq1k4dy58xgzZjSGDx+OiIhwcDgcXLlyBevWrcP79x9gZ2eLpqYmvhv4mpoaEAT9ye/y5ctwdXXBvHnz8PRpFtW/NXLkCDx58oRWdkIXWsxduLmisLAQS5YswZUrVxAbGwcNDXW4uLigV69eQp0NuYwUt/LK279VU1ODRYsWoVOnTli1ahWYTCZ1o9Iya4sXZGgxKQPkcDg4e/Ys3NxW49Onj3BychLIF+F1NmyJ27dvwdHREYsWLcLDhw+xdetWVFZWQUdnHJWDJjhHvKHFlQAARUVFhISEwNbWVmzzirS0NIqhbCmXIe2Ou3btyieX4XA4KC4uFrtHas+ePTh9+rRYY86fPw8/Pz+sWbNGZLlMfn5+u3uk2uqZaCmXGTNmDLp06QJLS0v4+vqKJJdpj0V8Q0OD0NBi0g0Q4PZfLVq0CHV1dbC05Mpe7927J9a2yNBiccDLSMnKymLTpk3YtGkT8vPzwWKxsHXrVmhqaiIgIIAvaJdcGIqDmJgYHD58WKwxDx48gJeXF7y8vHDkyBGqf2vBggU4deoU3xwRBAEGJFBWXk5ZjzOZTKSmpkJKSgqNDQ3o1q0bJk6ciPCICBRVVkBafxwitoZCSUlJKCPFaxEvLy+PwMBABAYG4uvXrzAyMqLYLVH6twD60OK20NTUhJqaGlpGytjYGMbGxuBwOFQMCkEQWL58OY4fPy42m9wei3je0OLOnTtTPUJkPIWXlxcGDRoENpvNx4YIY6RaQ1hYGPbvF1RGtIZPnz7B3d0dvr6+VEGqQ4cOsLOzE1qQam+PVGpqapsW8crKytSx9urVK0ydOhVKSkpwcHCgjaegw/Xr10U63njB7bemDy2ePXs2Zs+ejYaGBkRFRVHxFK6urkhJScHVq1fF2lZ7LOJLS0vRpUsXvnvS/1b8XmT9Bm7evCHULjQvLx8TJ06kKlDv379HQkICsrOz0djYiJKSEoEbB2GhxR06dICiohKSk5N+9W/F48CBFKioqKB3by2hWVuksyEvJk+eDD09vV8Blx3g5OQEGRkZLFy4ECYmJq0yUk+ePKFsq4cOHYpdu3aBw+Hg6NGjuHr1Kuzt7SkZIHmjFxcX12poMelOuH69B8ZOmIgdicnIL/yO5uZmKvD269dvUFDoiF69eoEggA4dJFFWVo5u3VQoCaSkpCQ6deoENpuN0tIfOJmUiLJvX7HZzxd9+vQRykhdunSRr3mawWBg5syZMDExwYoVK1BXVwcHBwfIy8tj6dKlMDQ0RGJiIqZPp++RIhkpgCsDHDWKu3A7ePAg8vPz4ejoiClTpmD+/PnUhak1Rio7+yvYbDblNpmZmYmdO3eioKCAsvttudgTFlosKyuLLl2UkZychLy8PMTHxyM6Ogaampro37+f0L4NXkaKnKM5c+Zg+vQZcHFxwY8fpbCzs0OnTp3AZDIxduxY2qwtEiQjBQA6OjrQ0dGhGtRzc3Ph7OyCWbPMYWFhQc0Rb9YWmZcFcIsDb968EbtyR2ZttYSSkhLV3/DmzRuw2WysX78egwYNwujRo8W+oSF7pMR17bty5QrFSPHKZaKjo6n+rZZyGX9/f6GMlDC0xyJeWVkZPXr0QEZGBl68eAEWi4W8vDwMHz5cqFwG4B7nJCMlKkJDQ2lDwFti3rx5mDdvHhoaGsBisfD+/XtMmzYNq1atEmk8wJUBkT1XokJYaLG6ujpV7X706BF8fX1RWFgIHR0djB49ul2hxbzSPlFx9uxZ3L17FwwGgwqqra2tRUhICH7+/IkZM2Zg3bp13GxBaWnUE7WIj4uDl5cXSku5v+vi4mL069cPK1asQGJSEnW+9Axmo7azImbPno3Kyko0NDTQhrmy2Wz4+fkJ7JuWlhbU1dWRnp6O1NRUrFu3DiUlJZgwYQL8/PwEJMMkIiIiKEZKVIhiEc9gMODg4AAHBwdUVVVh48aNePPmDSwtLeHl5SW0N6YlMjIy+M6XokBYaDEZTwFwC6QuLi4oLy/H5MmTMWbMGAwZMkSs7TQ1NaGysrJdFvHXr1+HpKQkVq1ahVWrVrVakAK4/YN0jFRraI/8cejQodDU1ER6ejouXrwIa2trVFdXY/r06fDy8hLKKIaGhootd46Pj6cMyoRBWlqaryDl7e2Nly9fYtmyZfD39xfZjOfevXtiqyZOnDjRZt7gfwt+L7J+A/n5+bQVk7S0dAFGYODAgdi5cydWrlwJExMT+Pr6oq6uDhMnTsSyZcvQoUMHVFVV0er0T506DV1drmMct3+LKw18+/YtVq5cCXV1dfz8+ZOvf6s1Rmr//v2YNcsCVlaWsLW1pfq3kpKSkZPzjfZG49u3b7QW8QwGA69evcaOHTvwxx9/ICUlBQ4ODpCTk8OiRYuEZm1lZGQgPz8PFy5chOm0qfhWXQum4XgMNRyP7du3Y/jw4fD09ESnTgro0qULpKQk0a1bN7x9+xZhYeEAgI0bffDjxw8EBARAUVERQ4ZoQ16yAwb07Q3jLZsBcKuoa9asgbq6Onbu3AlHR0coKioCaJ2R4s7RLMydOxfOzs4oKChEXBw3YywnJ4e2nygvLw+dOinQztHHjx+xZcsWjBgxEklJSZQb4PLly1phpAQt4kePHo3Ro0fDzc0No0eP/tW/Rfzq3+LeTFZU/BTCSF2iLOJJGSDAlXN6eXlBXV0dkZGRsLOzo+akNUYqKSkJM2ZMpwwncnJyERcXh6ioaOTm5iApKUlgDNfZUND+nMFg4Nu3HAQHB2PEiBHYt28f1b9la2uLL19aulpVAlDG/fv3xW6qJhmptiQz2traVP/WlStXsHTpUvTt25dyBhOlQksXWtwWWvZIkZCUlMSaNWuwZs0aAbmMr68vXrx4QXtctobAwEDK9UxU8FrE//HHH3xymWXLlqGmpgazZs3C+vXrKblMXV2dUEaqNVy4cAF//vmnyK+XlpZGaWkp9u3bB319fbDZbOzYsUPADbAlMjMzRTbk4IUoFvHjxo3DuXPnwOFwcPz4cbi6uqJv377YtWvXr2JX27cT4eHhYmcaCbOIl5OTo/q3cnJyEBAQADabjR79e8PbcjbevH1LZfm8efMG9vb2SE1NxYkTJ1BfV4cXL1/ij2HD8KasBIeDjqOztCwsLS3RrVs3GBkZoVOnTli/fj0VjpuXl0d7DTh37hz1fYwfPx6XLl0Ch8NBSkoK5Qa4ZMkSuLi4UOfU9vZIiWsRT57/YmJioK+vDz8/P2zcuBH9+vVDUFAQ+vbtSztOVEOOlhDFIn7y5MmYPHkyFU9hb2+P/v37/zpX2oq0zd27d/OFFosCYaHFLQtSvP1bgYGBuH//Pq37bmtgs9li90jxWsSbm5vD3NxcoCDl5OSERYsWUXPUGiPVGg4fPiwWI6WiogJlZWWEhoZi3LhxYLPZyMvLw8iRI8FisYQWTf6JRbywY/O/DRIEQfxv7wOFsWP/IB4/Tvrf3o3/U8jOzoaHhwe0tLRgb2/PV1FauXIVfH03CSyYOBwObG3tqJ6rxsZGHDlyBHfv3kVpaSn69etPyfp4YW9vj+joaMjJyfE9XlVVhTVr1mDv3r24efMmTpw4iYaGehgbG6O0tBR9+vSh7UtgMm2o/h9efPv2Df7+/ujateuv/i1tODu7oEsXJWzatAlWVla0F0sm04b6TCSKi4vBYrHw9u07jB49Cs7Ozujfvz/1PFkNO3H1Gu49zUJjYyNWrFiJgYMGYo27OyQlpSEnJwsZGWkMGDAQd+7chpKSEjQ0NODuvgZNTU3YvDkYAQEsNDc3wcfbG/EhO9CrqzIfVV5TUwM3Nzfs2bMHV69exdmzZ9HU1AQzsykoKSmGuro6rVGAsDnKy8uDt7c3lJW7ory8DCNGjICjoyM6deoEf39/mJub02YUMZlMKsOFREFBAYKCgvDu3Xvo6Izj698CgNWrV8PDw0PAeKPlcVRTU4PExEQ8evQIVVVV6NevH60lrYODA+UQxova2jqsWrUSe/bswblz53Hp0kUQBDBz5gwUFBRARUWF1rnPxsbmV48U/01iQUEB1q9fj65du6KyshJjx46FnZ0d5OXlERDAwrRpU2kZIbo5+vbtGzZv3oKPHz9g/PjxcHFx+fW7UgGgBXNzc+zcuVMs16uDBw/iyZMnYlWb6+rqYGpqij///BOxsbE4evQoJCUlYW9vj2XLlgm9GOrr6+Ovv/4SS8Ln4OAAS0tL2qw8Orx8+RKrVq3CixcvYGVlJbJchsPhBmZnZGSIvG8AV1518uRJoQumhoYGREZG4syZM5CWloarqys+fPgAWVlZocG7dCgsLMTSpUvFtrTW09NDeno632OZmZkICgpCQUEBxowZAxaLhW7dulHPW1pagsViiZWpdfLkSdy6dUssx7CGhgZMnDgRd+7cwc6dO3Hp0iV07NgRq1evbjVny8DAAHfv3hWrX2zFihWYNGmSSE6MAHDvwX1sZm9CfUYWZs2YAUdHR7itXo3kX8USDw8PTJ06FTdv3cKHnK9421EG185eRs+ePfnmnLyOvH37Fh06dICmpiaOHTsmsD1TU1McOnRI6I1mTU0Ntm7dips3b6Jz587w8PDA8+fPUVtbK3IwMMA15Jg3b57YFvt6enp48OAB32/7zp072LFjB8rKymBiYoJNmzbxnU/nzZsHLy+vVnPqWuLSpUs4deqUWBK+pqYmGBkZ4erVqwgODsa9e/fQtWtX+Pj4wMjISOg4Q0ND3LhxQywJ37p16zBy5EhYW1uL9PorV66AzWbj3bt3WL16NTZs2CDy9uh+u21hypQp2LNnj9AFE1mQysjIgKqqKvz8/PDo0SPq+isqKioqMGvWLLFlyHTH0ZkzZxAdHY3a2lqBghQAqrggTqbWx48fcfv2bb7suP8GSEhIPCEIQuDG8l9jsiQkJDoAeAwgjyAIcwkJCWUAxwD0BpANYAFBEGX/1vZ+49/B7du3kZiYiMLCQiQkJKCoqAgDBgyAs7NzK4zUKejp/V2tkpKSgrW1NaytrWFjY4MuXZTAZNrw9W9xs7YkBBZYAH9oMVnlamxsxMGDh3D27FkMHjwYioqKMDExocbwZm21RHx8PFavXk3R2Tdu3IC3tzcaGurx/ft3sNlsgTHCQou7desGCQkJHDiQjPLycrBYLFRXV8PAwAAODo4oq6mFRHc1zF5mjWefv2LBgvmIjIyAjIwM5OTkISMjDT19fZw9cxbl5eUYMGAgqqqqqDDNuro6DB/O1eXLSUhArQMDWiqC9sD79u3HjBkzwGAwKNlVbW0dDhxIxsmTJ6GtrY3u3bvzNb8KY6TIOXJzc6MkbpcuXabcAIuKimib2YVVydXU1CApKYnExP348aMUu3btQkVFBUaN4roB0mVtAYKhxfLy8lQvCZNpgw4dOoDJtIGmpgZcXFzQs2dPKmuLjrUjQ4tJG3crK27/1v79+3HixAkMG/YH+vbty9dPQzobCgstdnNzg76+Pl//loQE11wgIEBwjrKysmgXBr169YKsrCz27duHwsJCBAdvRlVVFUaP1oOd3a5fYdzi2QqTocXigAwtlpSUhJubG9zc3FBeXo7AwEDExMRARUUFvr6+fItHcUKLeSEuIzVs2DB06tQJ9+7dw5cvX0SWyxw7dux/xCJeWloaHh4e8PDwQElJCQICAnDo0CFMmDABJiYmIstlWoYWi4InT57QHkct+7cWLlyI+vp6WFpawt3dHYWFhWKHFv8Ti3hZWVn4+vrC19cX+fn58Pf3x+bNm9GzZ0+w2Wy+vj9xQot5kZmZSWXqiIIJBoYI6aIC94RoNL39hLXr1uF7YSGOHj2KefPmobi4GGZmZhhvaoKlW9hwmW4BOzs75OXl8S0qevXqRbHYY8eORWlpKfT09GBoaAg/Pz8oKSmhsbERNTU1rcof5eXlKTfKr1+/IiAgAGfPnoWZmRk+fPhAmS61BWGGHK1BGCNF5lxyOBzs3buXkikvX74cDg4OyM3NFWuBBXB7pOhY/9ZAhhaTfakAl/3w9/eHp6cnBg0ahMDAQL6FhzihxbwQl5GaPn06EhMTERISgqysLJiZmYlUkPqfsojn7d8i4ylu3ryJ2bNnC1Uj0SE4OFioYZkwCGOkrKysYGVlhYaGBkRERMDExAQyMjJUPMWnT5/EDi0+efIknJ2dxRrzHw2CIP6VfwDWATgM4OKvv3cA8P71/94Atrf1HmPGDCMI4vHvf/+P/jU3PyQiI5kCj9++HUJYWGgSU6aoEPv3ryQaGtL4nrezG0HU1KQKjPv58w5hbz+S+vvt20PEunXGhLX1MGL+/L7E4cPraffD2noo0dz8UODxr19PE25uBkRx8VVi8+Y5hLX1MGL9emPi/fsjhI/PFOLJkwQh70d/HKWmRhALFvQnbGz+IJydxxJ37uyknlu5Uo/IzT1HO0e87+fkNIYoKblGXLwcRExdNIgwWjiICNrvRjzMvUgYLxlCGC8ZQky2Hk7MdBxLxJ5nE7pWfQjjJUOIhWtNiNmueoTHLmtiqu0o4lnxDeJZ8Q1ipuNYguk1hVhiO4JYsmQQcejQOqGfiW6OcnPPEStX6hH5+ReJgABzwtp6KOHlNZn4/PkksWnTNOLhw1ix5ujBgyhizpzeBJM5jFixQpd48CCKes7NzYD4+vV0m3NEPnbunD91HB0/vkFg/+3tRxKVlXcF3q+6+h5hZzeC+vvJkwTCzc2AsLYeRixfPoRISVlDu+9MJv0c5edfIFas0CVyc88RmzZNI6ythxEbN04jvn07S/j7mxNpadFCj0u6x9PSoglLy54EkzmMcHMz4DsOV682JL58OSnyHB0/7k0MGtSXUFNTI/bv3080NzcToqC6upowNDQU6bW80NPTIxobG4U+//r1a2L+/PmErq4uYWNjQ+Tk5BC2trbEpUuXxNpOeno6MXfuXLHGNDc3E+PGjeN7rLGxkQgLCyMMDAyIiRMnEocPHxaYI2NjY+LHjx9ibSsoKIgIDQ0Va0xeXh4xadIkIisri7CysiJ0dXUJZ2dnoqCgoNVxurq6Ym2HIAhi9uzZxLNnz0R6bX19PbF161aif//+hJqaGnH69GmRt1NfX0/o6+uLvX/6+vpEfX290OcfPnxIWFhYEDo6OoSbmxvx48cPwsXFhTh58qRY23n69ClhaWkp9v7p6uoSBZVlxKsXj4nC9FSi4q97RJyjIzFbU5OY3KM7cSY6jHjx5ikxdrwBNWbSpEm03yXvHDU3NxNJSUmEkZERYWBgQFhaWhLBwcFi7VtxcTExceJE4t69e8T06dMJHR0dwsPDg6ioqGjzM4l6fiAxd+5c4uHDhyK9trKykvD29iYGDBhAqKmpEXfu3BF5O42NjYSenp5Y+0YQBGFgYEDU1tYKff769evElClTCF1dXcLX15eorq4m1qxZQ6SkpIi1ndevXxMzZswQe/90dHT4/i4tLSXWrFlD6OrqEjNnziQePHggMMbMzIz4+vWrWNuJiooi/Pz8xBpTVlZGGBkZEefPnydMTU0JPT09IigoqNX5JIj2HUeLFi0i7t27J9Jrv3//TqxYsYIYNGgQoa6uTjx58kTk7XA4HGLDhg1i7dt/CgA8JmjWNeIJJYVAQkJCE8BMALxly9kASM1MMgDLf2Nbv/Hv4dmzZ7RVTxMTE6iodMXJkyfBYDDg5OQEZ2dn3Lhxg4eREqwqtwwtHjRoEEJDdyI5OQmNjY24e/dP2NraIjGR+zcgmLXFC65FvB1UVFSwceNGJCcnwd7eAXFx8bh//z6uX7+OsjJ+cpTM2qLDkSNHsGtXKBITExEcHIzU1FQwmTZYv94DpaWlQpwNT6GkpATu7u54/PgxGhoawOiogD66+pDqrAgfH2/cunkLnp6e6NCBAWlpKdjb26O0tBRHDh+GmpoaOnXqhNGjR6GxsQmPHj1Ev379wCE4+PmzAsoy0ti/bTNS9u5BdXU17ty5Azs7Oxw5cgRNTU0AWmekYmNjwWQyoabWAywWC8nJyVi8eBHCw8Px11+p+Ouvv1BZWck35smTJ0JDi48cOYLwcG5F0tfXF1evXgWTaQNvb28UFxfTMlJ0ocWkhXu3bio4ePAgiouLYWtrh5UrVyI9Pf0XI0XfR9bSIn706NGIjIxEYuJ+VFRU4M6du7C3t8epU6fA4XAACGZt8YJryLEcGhoaCA4ORnJyEqysLLFjx3bcvXsHjx49/pX99Td4nQ0F5+goVbX18PDAqVOnwGTawM/PDyUlJUKytgRDixkMBubPn4f+/bsjLS0Nr1+/hoGBAWbMmIHU1FTabZNoLbRYGHJzc6GgQM/akdDW1sbx48eRnp6O+fPnw87ODqdOncLDhw9RW1sr8raCg4NpGePWcOTIEQH5Jdm/df/+fZw8eRJpaWkwMDCAhYUFHj16hLq6OjQ0NIhtyHHp0iWx2SXSIn7EiBE4ffo00tPTMXXqVCxduhT6+vrYunUrGhoa+MaIE1rMC3Es4qWlpeHt7Q1NTU1cv34d165dg56eHubMmYPnz5+3OrY9FvGiMFJk/1ZaWhr09fUxZ84cHDlyBDk5OdR5TRQEBgbSmk20BjK0uIeCEvoM/gONgwYip7sSjNxd0DhiMFz3xeJY1jMsXLAcVSWlePPmDZqamoQackRERGDWrFkAuL9ZJpOJe/fu4caNG3j27BmtOU9rYLFYcHV1hZGRES5fvoy0tDQMHjwY5ubmGD9+PGJjY6nzGomXL19CVVX1f9QiXkFBAVu3bkWvXr1w4sQJ7NmzB3p6eli2bBm+fPnS6tj/KYt4MzMzXLt2DQ8ePICamhqmTJmCxMREypxEVLTXIr6lIUeXLl0QFhaG9PR0hISEICwsDHp6erCzs0Nubi5lyEF3nWwNR48epfoHRQVpET9r1izcvHkTf/31F+Tl5TFp0iQYGxvjyJEjAnPU3h6pL1++tCrf5IWqqipiYmKgpaWF+Ph4BAcHQ09PDy4uLigsLGx1LHm++P8T/i25YDgALwC8XeXdCYIoAACCIAokJCRo0xQlJCScADgBQK9e4jWB/sY/Q1paGhwdBXWvlZWVYDAY6NRJAUwmE0wm85cbYAJCQkKgrKyMN2/eQlubnxJvLbS4V69eiIiIQGNjIw4dOgRHR0fIyMigvr5eqJMY1yJ+JN9j2tqDMX/+PHTsKI+xY8fC29sHDQ31MDExweLFi2mztgBBi3hSFgUAUVHR+PjxI5hMJoYOHQp7e3t07cqV7F29eg0nThxHUVERPLy9UU5IwDc0DDNnzkRjYwO2b98BBkMCDAYDbm7uCAnZgd27Y6Cs3BUAAWNjE9y8eQPTpk3HtGnT4e/vBwWFjgj290dV7jfMmz0bDAkJ5OXnQ1NTE9HR0aivr0dycjLlBtjQ0CCUPs/JEbyIjhw5EsuXL4OCQkcMHDgQ69atQ3NzM6ZOnYq5c+ciOTkZHh4etHNUUfGTCqlVU1OjbpQjIyPx8uVLMJlMjBw5Eg4ODpSJBG/WFi9IQ45u3VQoa/GCggLExcUhIICFrl2VqWODF7zOhrz4/v07NDV7IiYmmpIB2tpyzS2am5uEuj/SGXKMHTsWHTpI4vjxY9DQUIebG/e4nTlzBiwtLWmztsg54g0t7tWrFzZv5pqThIeHIzMzE0ymDXR0xsHW1paStJw9e5a2d6q2tg4yMg3Q0tISkMs4ODhg9OjR2Lp1q4CMRNTQYl74+/uLdUM4Y8YMdO3aFSEhIejSpQsVnung4IClS5cKvVC3FlrcGtqyiFdRUUFkJNdllJTLpKenQ11dXSy5jDBDjrbw4sULAYt4XrlMeHi4gFymPaHFx48fF+oiKgykRfywYcMow58nT57A398fBQUFGDt2LNhstoA8UtTQYl6IYxHPYDCwePFiaGtrw8/PDz9//oSRkRE6duyItWvXtumUl5+fL7Isk0R0dDQOHToEAJCTlIamUjdoKKqgpr4OpWXVsJpuiTkzrABwJWSenp54/vw5NDQ0UF5eDiUlJb73O3PmDO0c1dTUoFevXrQS+Nbw+PFj6jgGQGXa2dvbo6qqClu3boWBgQEUFRXh5eUFU1NTsFgssReb/8Qi3tDQkDLouX37NlasWIGysjJMmjQJGzduFCiOiRpazIvAwECRLeLJeAoTExO4u7vjzZs3Qt0A6fDt2zcYGBiItX+7du1qtb+MLEgBoOIpPnz4QMnaRT0uhBlytIX79+/zOctKSkpi3bp1lLslm81GeHg4VFVV4e/vj3HjxrUrtPjGjRvttognDTwA4PTp01iyZAnq6upgYWGBdevWCRRqLl++LHbu3n86/vEiS0JCwhxAEUEQTyQkJIzFHU8QRAKABIBrfPFP9+c3REN9fT0kJBiQkhI8BLiMFL8DFNcN0Btvfzk27d27FyUlxRg0aBDVvyWsR4prf87VAEtJScHGxgY2NjYoKSnB4sWLER4eARUVFTg5OVI/5pZZW7xISTmITZs2Ql1dnad/6yAcHR2RnZ2N9+/fC1SPT506LdQiPisrC0eOHKb6CxwcHKCkpPSrckNATk4OsqrdwVFRxQ5fP7x+8xohISFgMCTA4XDg4eGJnTtDERKyA506dYKEBGBnZ4eTJ0/gxInj6N1bC1VVVaiuroZCx47wdHJEV1kZLFmyBJ8+fQKTaYOKinKq0iYjIwMnJyc4OTnh+/fvWLJkKaKjY9CjRw+4uDhT+SKPHz8WamGbnJwML68N6NlTE+bm5qitraOYwK9fs5GXlyewuCGztujw7NlzHD16FPLy8lT/FkEQmDRpktAeKS4jxW8RTy7cmEwbuLmtoiyYR48eDXt7e1RWVgpkbZHgtYiXl5enbPjz8vJgbc1EbGwsLly4+Kt/izsvXEZKsK8Q+Du0uHfv3pgzZw6qq6t/Ldxs8e3bN1pWiszaosOrV69w9OhRdOzYEadPn6b6t6ZNm4bm5mahzoZz5/JbxA8YMIBidZYvXw4nJydUVFTAzMwMPj4+KCkpaZORosPr16/FrjaTocVDhw6lwjODgoKo/q1NmzYJVB5FDS3mhbgW8cOGDcPJkyehr68PT09PLF++HDU1NZg5cyY8PDxarY4HBASIzWK1ZREvLS1N5TgVFRWBxWIhJCQEHz9+FIu5AfhDi0VFaGgorKys+B4bM2YMzp49C4C7cFuwYAHq6+sxZ84cuLu7o6SkpN09UuKYZADcfqKgoCCMHDkS/v7+yM3NRUBAAIKCgtCzZ0+wWCyBRbmoocW8EGYRLyEhgd1R0bAwn8VnKGRoaIiLFy/CwMAA9vb2sLCwQHNzMxYvXkzZjMvIyNDOUUBAAFxdXcXavxcvXrQaWqygoIDNmzdj8+bN+PLlCwICArBx40Z8+vRJbBvsyMhI2jzD1hAVFYUZM2bwPTZp0iRMmjSJr39LQkIC1tbWsLOzQ3l5udihxQD3Gr9r1y6xxpAOkuQ55927dwJugC2va5cvXxYptJgXZKwIWXBsC2SftKGhIWbPnk0VpBwdHbFkyZJWmaOgoCDY2dmJtX/v3r1rNbRYRUUFUVFRAP4uSOXk5ODLly+Uk6Ko4A0tFhXx8fECocVz5szBnDlzqIKUsbExZGVlsXLlSsydO/fXPamE2Oej/3T8G0yWIQALCQmJGQBkAXSWkJA4COC7hISE2i8WSw1A0b+wrd/4l3D79m2kpqYiK+sp5s2bx5eTJYyRys7OhpKSIl8o8K1bt7Bx4yZ8/PgRxsYTBUKBAXpGCgA+fPgIAwMDsNlsvHnzFgkJCZQBwOfPnylrbl5wOBxUVVXxVa2lpKRga2sLBYVO+PLlM9LS0pCUlAxV1W5wcnLCgAEDaLO2AC5rV1dXR1WRCgoKcPz4cXA4HLi6uqKo4ieWr/eEntEESEvLQFJSEsP/GA5paSk4O7sgNjYW27Zth4JCRzQ1SYHJtMbJk6fQv39/eHv7ICAgAOONjBAZGYH8z58wedxYKElJ4t27d1BX16BspxcvXkwr6/j27Rv09PSweXMwnj9/jvDwCJSXl2H48OF4//4DrTsVh8PBz5+VfEYecnKycHFxQffuPfDq1UtcvXoNcXHxUFdXo9wAW2ZtkeBK6f5eSM2aZY5Zs7gLN1dXF5SWlmLlylVYvnwZ3821MEaKDC0eO3Ysxo4dCw6Hg/Pnz2PNmjXIzs6m7H1bXkCEWcQXFRVDV1cHW7ZswaNHj7Fjx3b8/PkTY8eOxZs3b+Dl5UU7Ry1Dizt27Ag3NzecP38emZmZOHPmLKKiotGzpyZcXV2hoaGB8+fP0d4YtLSIJ/OOqqqqsHLlKvz4UQI3NzfY2tryVeYzMtJ/mUP8nZcFcL93BQUFTJ8+HdOnTweHw0FcXBymTp2K9+/fY9GiRbRzJAy8ocWigi60WFlZmWLk3rx5g4CAAKxduxZDhgxBYGAgNDU1kZCQILYhR3st4uXl5amLd1NTEyIiIii7Y1dXV74cNxJ0jFRbCA4OphjLtqCqqordu3fj2LFjOHnyJIKDg5Gfn4+RI0eCzWaje/fuQsfW19e32yK+NUZqwYIFWLBgARoaGhAaGooJEyYgOzsby5bR59oJw79lEa+pqYl9+/YB4MZgeHt7o6ioCHp6eggICICysjJiYmLENuQgs/cWLFgANpvNd3MtjJEqKSmBjIwMxSbV1NRg27ZtMDIyQkFBARYvXky7rcePH1M3sqJCWI4UHfr06YMDBw7g3LlziIuLw+rVq1FaWoqJEydi06ZNQvO3gPZbxJNOk3QgWwecnJzw8+dPbN68GQYGBsjPz8fy5cvF2g5vaLE4aBlaPGjQIBw5cgQAl913dHTEz58/YWZmRsVThIWF0QbDt4bY2Nh2W8STZjkt4yn8/PxoDXpaMlKigMVi0Sp26EAWpG7cuIHg4GCqIGVubo7169e3ujhur0X8oUOHhFrECytIMRgMsReA/w34x4ssgiB8APgAwC8my4MgiGUSEhIhAJgAtv3677l/uq3f+Pfw4cMHHDyYgvLycsTHx+PgwUNQUemKGTNmQEmJvkcqISGBYqRImJqawtTUFEwmE7169YKTkxOkpaWxYMECmJqa0mZtkTh48O/QYu7CjfsDu3HjBq5evQYfHx+YmJhgyZIl1MKtNUaKXEiRC6bXr18jNjYWRUVFKC4uQX19gwAlv2/fPkhKSoLJZKJHDzVISEhASkoKTRwOqqRkEBwXj4ryCmzeHAwA2LFjO6ZMmQoZGRmEhYWhY0d5yMvLgcVi4fjx479OqKp4//4dpKRk0KWLEiYajseSqVOw0t4OaqqqcHBwQEFBASVve/ToEfr160f7mZKTk7FhA1erPXz4cEREcEOBL1++jPPnLyAgwB9TpkzBvHnzKGbj3LnzGDu29dBicsGUlZWFsLBwlJWVoqioiDSx4cP+/ftpGRCyL+/s2bP4/v074uLiEBsbBw0NdVhZWbXaR8YbWsxgMGBpaQlLS0ssX74cCgoKsLW1Q6dOCrC2toaOjg5t1haJxMT9lPxx3LixGDeOu3A7c+YMTp48haCgIMycOROWlpbU/ly6dJl24Q9wZTZhYWHUgunhw4fYunUrKioqUFJSgg4dOgiMSUpKor0oKygoQEKCO0f5+fmIi4tDREQkevfWgpWVFY9sjZuXRaKltI+Uy6xYsQLjxo2DtLS0WHIZYaHFreHw4cOt6uPp5DKVlZXIy8sTW/rCG1osKvz9/bFmzRrqb0lJSb7wTDabjbCwMHTv3h1+fn4YO3bsLxdR0arTJDgcDgoLCzFs2DCxxpGhxeSC6dSpU1i8eDHq6uowe/ZsrF27VqBqK2poMS8KCwshJycnUgVYWloaPj4+8PHxwZgxY1BeXg49PT1oaGiAxWK1KS8LCgqiDS1uDSdPnmxV8qerq4sLFy6Aw+HgyJEjmDNnDurr61FQUNCuXrt3797h0aNH8PT0RHFxMQwNDeHi4iIyIyUvL4/AwEAEBgbi8+fPYLPZ0NXVRZ8+fcBmszFo0CA8f/4cPXr0EHuRkJeXJ3KPFInIyEikpKRAXV2dCjsn87eWL18OR0dHgf2IjIwUOTqBRElJCaSlpUVipDp37kzFa4wePRrZ2dnQ09PDwIEDwWazKbWFMIiz2CRx+fLlVkOLp06diqlTp6K5uRlxcXGYMmUKJCQkxJISkzh69Chu3Lgh1piWocW8boCvXr2i2CTegtTbt2/FDi0GuD1SvE7ComDnzp04cOAAtLS00NjYiMjISL6C1IIFC/hYXoB7DmsrtLglKioqICEhQatuaQmyIAUAbm5uYrvE/jfgfzKMeBuA4xISEvYAvgH4/0d88/8PUFZWBiUlJUhISKBLly5Uw+WHDx+wapUbOnfuhC1btsDJyYmvoiqMkeIupPq06N+Kx4EDKcjNzQWLxRIYQzJSdBbx5eUVWLhwARwdHXHw4MFfCzcZLFq0EFevXqGtHtKFFg8ZMgS7du1CeHg4Kisr4e29AXV1ddDX14eDgwMkJSXx9GkWlSO1evVq1NbWYom9I9S1tSHVWREMCQa6dOmCxsYmWFpa4q+/7mHv3j2Ql+8IgiCwfLk1rl27Cnn5jrCx4YbNOjs74/TpU3j58iWG9tZC57oavP34DlpaWnB0dISjoyMKCwuxZ88eMJk2yMvLFcraVVZWCVjLMxgMNDY2Yt68eXBwcMCBA3/3by1duhQXL15EZGSEwPvRhRaPHDkSERHhiIqKRlHRd6xbtw4cDgdTpkyhWIBHjx7TMlJ5eXmUtI+3fyszMxM+Pj5QUOiEiIgI2Nvb823z69dvtIxUZmYmevXqxScDjI+PR0zMbhQU5AudIzqLeAaDASkpKVhZWcLJyQn79u2nFm5Mpg3OnTtLy9rV1taBIAg+aZ+Ojg50dHQQGxuH7Oxsqn9r1ixzWFhYgMFg4OHDDFq7ct7Q4l69emHLli0AuFKZDRs2QEFBATExMbCx8UDHjn/fUL5584Z2YXv//n3069ePWjC9e/cOAQEBWL9+PQYNGoSgoCDaPDJRQotbYu/eva32SPGClMuwWCw8ffqUTy6zePHiVm8i2msR//LlS6EW8bxymRcvXoDFYiEvLw95eXlISUkRazu8ocWigi60eO7cuZg7dy6fXEZGRgarVq2iMu4uXrwoVmgxwL1hdXNzE2vM48ePoaWlRcmAHj16BF9fX3z//h3jxo1DQEAALZsmSmhxS4hqEc9gMLB06VIsXboUW7Zswc2bN2FkZAQFBQWsXbtWQMbWEkVFRdRCipQBcjgcHDx4EBMmTICioiKioqLg6urKd6w9fvwYMTExtO/Zt29fKvMuNTWV6ncpLi4WKw8K4BZaRDUzIdGSkWrZv0WySUpKSvDy8sKkSZMAiB9aDHAXCeJmE718+RIaGhpUD9ytW7fg6uqK8vJymJqa/roOCN5sixJa3BKiMlIdOnTAypUrsXLlSmzfvh2nT5+GoaEhlb/VVkGqvRbxDx48EGoRP3ToUEoCfPHiRdjY2KC6uhoVFRWIjo4Wazu8ocWioiUjJSUlxVeQYrFYVEHK39+f6gk9fPgwrl27Jta22mMR/+PHD2hqaoq92PxvwO8w4v+DOHHiBMaPH0+7wCEDee/cuYNjx46hrq4OEydORP/+A3Dz5k2w2SyBMa2FFi9evBiamj1/yQC5/VvKyso4ceIEioqKaBuo7e0dEB0dxdc4WlJSgqioaNy9exfjxo2Fs7MzX75IREQEtLS02gwtDgoKQl1dPfLyciEhIYH6+nocPnwYALDM1g6B4RH4WV8Pf39/cDgcEAS3t+HDhw8oKCiAvLwcKioqsNzaGlevXEVxcRG6dOmC8UZG6KnZE/fvp8LFxRXykh3AWrsGrg72OHz4MN6/f4+kpCQBqQ2Hw8HChQuhoaGBsjKuDNDBwQGKioo4ffo08vLy4ea2inaOeFk7gHtDHx0djdTUVOjp6cHV1YWPRYyKioa6ulqbocW1tXVISkpCRkY6JCUlUVtbh0OHDgqMaT20mPt+Fy5cwIULF0AQ3N6kPn164/Tp09RigxethRbPn78A6upq+PmzEmPGjIadHdfw4vz58/j8+TMfo0GCLrQ4JycX0dHRSE9Px/jx47FihSvfdxIbGwsVFRVa6ZqtrS327t2LDh06oKqqCvv27UNm5lPIysqgpqaG9ua99dBi7hydOnUa589fxdevnWBra4sBAwYgKiqKNvjU3NwcoaGhtI3IV69eRVhYmIBc5p+EFt+/f1/kMQB/aDFveGa3bt3g6+tLe2NlZ2eHefPmtXkTzYuMjAzs3LlTrN4lDoeDwYMHU43ppFxGRkam1XHGxsY4deoUZYYjCjZv3ixSaHFRURECAgLw9OlTKCsro6SkBA8fPhR5O0D7gk+FhRZzOBycOHECcXFxqK+vx9y5c+Hu7g5JSUmcPHkSt2/fFiuzqqGhAcbGxnjw4IFY+2doaIg7d+5AWloaubm58Pf3x+vXr9GrVy8BGSCJ1kKL9fT0cPv2bezYsQPXrl1Dp06dsH79enTv3h0sFovqXRMFHA4H/fv3R8+ePdHc3EwFrrZ1gzhp0iQcPny41UytlggNDUVdXV2bznhfvnyBn58fPn78iJ49eyI3NxdpaWkibwegD5ttC/PmzcOGDRsE2DkOh4P4+HgcOnQIEhISsLGxga2tLRgMBi5duoTTp09TclFRQIYWi/uZeEOL37x5AzabjezsbKH9WwCwdu1ajBkzRiwp7Zs3b+Dp6YmLFy+KPKapqQn9+vWDpqYmpKSk4OzsjIULF7Y5/1OnTsWePXvEkn/v3r1bpNDi58+fg81mIy8vD9ra2nj79u3/k+MoNjb21/1B6wzofzL+x8OIf+O/B4WFhbQLrLS0NOqmnAwrbGxsxOHDh+Hn5wstrd64efMmH33c3NzcamixsbExJcW4efMmfHw2UqHAdNVNrkU8BJx5VFRU0KWLEtatW4sBAwYgLi4OJSUl0NbWhrOzCzIzn9JWc798+YLi4iJ8//4dampq+PjxE5KTkwAAHh4eaGxshDWTCUZnRXC6qqCqsQkMRgdUVFRg5MiRKC8vx4MH9yErK4v6+npMnz4dT58+RcqBFHTpooROnTqDxWbj0sVLiIqKgoaaGr4+fwbZ5kYMGzQQhoaG0NfXh62tHW0vw9mzZzFhwkS4ua0Ch8PBtWvX4OnpiaamJhQXF1MLQF5UV1cDgEClTU2tB3r06AF399Xo27cvwsLCUV5ejhEjhsPR0RGPHz+irQS2tIiXk5OFq6sLXF1d4OHhAWnpGjCZNtDQUIeTkxN1jHz9+o12gZWZmQlNTQ0wGAzMnj0bs2fPRk1NDRITExETE40+ffrg4cOHfGOFMVIAt9/EyGg81qxZAw6Hg3PnuP1bBAGUlBTj4EHBBSCXtRM05OjZUxO9e2th7Ngx6N27N7Zu3YrKykqMHTsO9vZ2yMjIoK1QcxfYHSmpoIKCAuWK6enpCYIgwGQyoaWlBRcXF6rynJ39hXaBxQ0tVqNs3OfPn4fy8l7YvHkH1q1bh6FDhyI1NZVPEsLhcFBSUiLU6WnatGmYNm0ampqaEBcXBzMzM3To0AGFhYVi34STocXioKVFvDC5zLBhwxAYGEjN0evXr8VaYAF/G3KIg2PHjmHatGmIjIzkC8+UlpbGihUraD8vacghzgIL4FarRZE/qqqqUiYSZPFDV1cXo0ePBpvNhqoqrSkvhcePH4sthQKEM1IMBgMLFy7EwoULUVdXh9DQUBgZGUFeXh7fv3/H7du3xdpOey3ieaV9mpqa1G8yLS2NkgEaGBjAz8+PkhQKCy3OysqCmpoa5OXlwWKxwGKx8O3bNwQEBODSpUu4cuWKWPt3/vx5TJ48GQkJCaipqcHWrVthaGiIzp07w8PDg6+/mYQwQ462cPr0aZEYqT59+lDnQUtLbgi7rq4ujI2N2+zfAoSHFrcFYRbxDAYDrq6ucHV1xc+fPxEcHAwDAwN06dIF379/x4ULF8TaDhlaLA5aMlLa2trUPceVK1fg4OCAyspKTJ06FV5eXtTr0tLSxO4NIg1KxMGNGzdgYmKCpKQk/PjxA4GBgYiIiEC3bt0oN8CWaGpqQkVFhdj9tYcPH8b169fbfN3w4cNx6tQpAMDs2bNRVlYGfX19WFhYYP369W1KkttrEZ+dnf1fvcBqDb+ZrP9j+PDhAx4/foLFixcJPLdy5Ur4+vpBTY3/QtDU1AR7eweEhe1CfHwCpSN2dHTA8+fP8ePHD1qXJXt7e0RHxwhkapWVlWHZsuXo3l0VUlLSWLhwASVzCA8PR9++ffnytkjwsi0kbty4gQMHDiAnJwf29vZYtGgxn2Pixo0boa2tjfT0DPz4UYK6ujocOXIEcnJyYDJtELN3D/KqauAfGAgJCQkUFRWhVy8tSEpKIifnG2RkZFFUVARjY2N8//4dHz58QJcuXVBRUY7Zsy2Rk/MNdnb24BAcbPH1xS6WP/bv2YOMjAz0798fq1evRlZWFvLzC0RmpADuBWLZsmVQVVWFvLw8lixZQt1wR0VFQUNDg7Z3o+Uckf1bx44dQ05ODlxcXPj6twDA19cXs2fPpj2pM5lMSi7z9GkWkpISUV5eDjU1NRAEQenyeeHm5gYvLy+B3hcOhwNbWzts27YVsbGx+Pr1GzQ1NeDs7IzMzEx8/fqV1s7f3t4BERHhAgumHz9+YMmSpVBT6wEFBW7cAPkZYmJioKqqSstI2djYYP9+/jk6c+YMTp8+g7y8XLi7r8Hs2RZ8x1lAAAvTp0+jlTmS7C/AlQGmpBxEVVUVtLR6oa6uDjt27BAY4+6+BmvXrmnRr9gHHI4S9PX1kZKSgoCAAHz58gWDBg1CYGAg/vzzT2RlZYnlyJWfn48xY7gLSlHlMgC3GpmamiqWhE9URoq0/K+ursawYcPw48cPkWWJAPf70tfXR0ZGhshjAG7h6NSpUwJ9PiUlJQgICMCTJ0/Qo0cP+Pn5UXKZ4OBgyMvLi2V9TxoBiCvX4mWkTp48iZiYGNTX18PS0hJr1qyhvcGxtLREYGCgWDK048eP488//xQqkaNDdnY2dHR00LdvX2hqaoLFYonUo2ZgYIC7d++K5Rjm6uqKyZMn0zLuJDgcDg4fPoy9e/eisbERBgYGeP/+Pc6dE2z9njNnDnx9fWn7wtrDApqamuLQoUMCC6avX7/C398f7969Q58+fRAYGEipLUJCQtDY2CjWjXhJSQnmz5+PO3fuiLV/JJMAcCW/KSkpIAgC1tbWcHBwoL0Bnj9/Pry8vMTqF7tw4QLOnTsnVLJLhzdv3mD8+PHo378/JW8WxVTBwMAAt2/fFsvB0N3dHePGjWuVkSILUkePHkWHDh0wffp03Lt3D5cvXxZ5O0D7jqMpU6Zg7969Agsm0g0wNzdXoCAVHR2NoqIiWum8MJSXl8PCwgL37t0Ta//I44g0FDpz5gxkZGSo/i06LF68GCtWrBA5Uwvg3pPevXtXZDv//1T8ZrJ+AwBw/fp1PH/+AtevX8OECROwbNkyrtFDUxOqqqoFFlgAl5HS09OjbNwBbi/Inj178OjRI0yePBmlpaV8Ny9k1hZdaHFSUjKcnZ1gYWGBkpIS7NmzB8nJB9Ctmwq+ffsmNGuLziLezMwMd+7cgZubG168eAFHRwfIyspi0aJFMDY2Rl5ePrZs2YLly5dj7dq16N+/P1atWoXK6hpAUREfy3+CIcFAYWEhunVTRd++/VBQkA9paRlUVPzEqFH90LNnT6Snp6Fz585QUOiIzZs349mzLEpadubkSfRS7IQJfwyFppoalfPw4sVLREVF4enTLEybNhUVFRVQVFSk9r26ulqgj4wEaUlvZWVFmUrs2bMHPXqoITs7G0eOCDJcubm56Ny5E98cMRgMmJubIz09HS4uLnj58iUcHBzQsWNHLFu2DPr6+rRZWwBpEf/3QmnUqJEYNSoCHA4HixYtgpycHOzt7TFt2jTMnTsXDAaDx9lQ0FyADC1WU1OjLhKZmZnYuXMnnj17DnPzmaiqquJbTLV0NuTF0aNH4eDggPnz5yEvLw+xsbGIjo6BpqYmPn36SMsC0oUWMxgMzJ07F8+fP4eDgwNevHgOW1s7dO7cCTY2NhgzZgzV2N0ST59m8Rly6OnpQU9PDxwOBwsWLICsrCwcHBwwa9YszJo1i5oj3qytv1GJlJQLGD9+PAYOHMjnmuXk5ISsrCy8e/dOYB9aQ0JCAjZu3Ag3NzdKLrN+/Xpoa2sjMDCQ9nsinQ3bYxEvCiNFZqc0NTXhjz/+gLy8PExMTODk5CSSXKa9FvHCQotVVFSoBcfz58/BYrGQn5+PESNG4NGjR2LL98jQYnHQMrSYdKck3QCNjY0hJyeHVatWUVbtBEGIFVpMoj0W8UeOHIGnpyc8PT3x6NEjbNy4Ed+/f4euri5YLBbtvIoSWkyHp0+ftmkRz2AwsGzZMixbtgw1NTUYOXIk5OXlYWZmhnXr1vH1MwrL2jp16pTY/WWtMVJaWlpUQerevXtwd3fHjx8/MGHCBNy9e7fNgPGWYLFYcHFxEWvMy5cv+SziSTfAlv1bGzZsgImJCTUuJydHbEOO8PBwsfsbr127Bnd3d/j7++PGjRtUPMXkyZPh4+ODjh07CowRJbSYDunp6W1KpCUlJbFq1SqsWrUK5eXlGDt2LOTk5GBubk4bT0GHK1eutMsiXlhoMekGCHALUkwmE1VVVZgxYwauXLmCmzdvirWt4OBgPkMOUcDLSElLS1O/fdINMDQ0FGq/7nV4f1vihBaTOHnypNhRCP9N+L3I+j8EDofzSysdh8bGRhw5coRyA+zRo4fQG5fr168jOpq/6jlo0CDKvtnAwICSAU6YMBHLli3F3r17BbK2SGRlPYW7O3chpaKiQlmR3r59G1u2bIGtrR20tQfD2dkFXbooAeC63Nja0mdJ5OXlU+YE9vb2KC4uRnx8PKKiolFTU42PHz+ib9+++PHjB8LCwlBWV4+VG32hoqoKt1VuUFRURN++/VBa+gNVVVX48eMH+vXrD319fTx7loXOnRXR3MxB3759qZv9oUOHQU1NDeHBwUi9chl79+zBhQvn+fbrjz+GITg4GO7uazBixAh4eHigqakJZmZmWLBgAfbv34+ZM+kdoJ48yaQMILp37045et24cRPbtm2Dra0thg8fDicnJ8qkIS4uDkwmk/b9cnJyqYBJZ2dnFBQUIi4uDjt3hqK2tgbZ2dkCN/1k1hYd5OTkkZyc9Kt/KxF2dnbo2LEjevfuLTRr68KFi4iICOd7bPTo0Rg8eDDc3NwwYMCAXzJAAjNmzICVldWvrC36bCdei3gNDQ0EB3MdIK9cuYr09DTY2tph7NixsLe3oxayvFlbLZGd/RUmJsYwMTH+NWc5iIuLx7Zt21BTU4O8vDwByaew0GKAawmfnJyMqqoq7N27F7a2dlBU7IwBAwYIydqqxL59+3D+PP9xNHXqVBgZGWHKlCkCQaltgTe0uKVcxt7eHj9//sS0adOwYcMGSqJLGmmIg/ZYxDMYDHTu3BkZGRkoKSkRSS4DtB1aTIeQkBCRLOKHDx9OvffevXtx4sQJGBkZiSyXAdpnES8stJjXDbCwsBAsFgvbt2+Huro6xo0bh7FjBQqnrYIMLf4nFvHjxo3D+fPnweFwcOzYMcrMY968eXBzc6MW5wEBAWIbcpDSPnEgLy8PZWVlpKenUzJANpuNXr16wcDAQGjWVkxMDG0hpjVERERg1qxZbb5uwoQJmDBhAjgcDqKiovDx40dMnjwZS5YsgbOzs0hyqkePHvGFFosCYa59CgoKVFzIp0+f4O/vDx8fH/Tv3x9GRkbtDi0WV6rKG1psZmYGMzMzvngKCQkJ2NnZgclkUnPEZrPFNuRoj0W8kpISVFRUkJ6ezhdPoa2tjaCgIKE5eWFhYWKboIhqEc9bkNq+fTvevHmDGTNmiNy/BXANW+jUFK1BWGgxrxtgVlYWAgMDqXgKExMTsUOLCYJARUWF2Ne1/yb8XmT9H0JWVhZVuZOSkoK1tTWsra1RVlaORYsWQlVVFR8/foCDgyO0tbnuNa0xUnv37sXs2ZaUjTvZv+Xk5EQ14rYEN2tLifbkcPPmTYSE7MSoUSNx48ZNeHtvQENDA0xMTJCbm0vrbEgXWkw22a9cuQoLFszH7t278fnzZzCkpfE0Jw8SsrLIzc/Hj7JS9O7dG1VVVQCA79+L0KNHD4wfPx4vXrxAbW0NZGRkERgYiLKyMvj6+qJrV2UUFhZCRVER08eOQU/FTphlPhO3bt6gZaT2798Pc3Nzyn2tvr4eyclcN8AvX7IRFCRI++fkCDJSJP788y62b9+G0aNH48qVK1i3bh2am5thZjYFOTk5tDdddEGqamo9wGZzXclmzZqFsLAwlJeXY+TIkRTT1TJriwRvaDG3f4urvS8oKIC1tTV69OiBjRs3wsXFhbrxbo2RSkxMxIwZMygb95qaml+hwHbIzs5GSIjgBYLM2qKbo7S0B9i8eTN0dHRw9uxZyg1w5swZIjNSANCzZ09s3hwMd3d3TJo06Vf/VhV0dMbB1tYWsrKyAllbJC5dukT91hQUFChjjm/fvsHOzg49evRAQEAAXFxcqJvK2toKAI20F5wdO3Zg0SJBiW9raI2RIvO3mpqaEBsbS/VvOTg44NWrV2KHFv9Ti3gVFRXqhrI1uYy4ocUkLl++LLZFfEZGBpKSkjBt2jSqf0tGRgYrVqygNVcA2g4tpgNpEd8WI9WjRw/ExcUBAJ48eYKpU6dCS0sLK1euBJvNFmnhRBda3BaEWcQzGAwsXryYsqXfsWMH1b+1Zs0aZGVltSu0WFyLeN7Q4l69elF9pw8ePICXlxdqa2uxbt06+Pv7U7+t9vZICcvaEgYGg4H3798jPj4eM2fOxNatW2FgYABFRUV4eXkJBLaSeP78OdTU1P61Hile9OvXj3IDvH37NubPnw8tLS34+Phg06ZNIllvR0VFYebMmWLtmzBGijeeory8nGLcSHlzRkaGWKY9AHexSXf/0Rp4LeKFxVNMmzaNr3+LZKTE/c0fO3ZMpB4pEqSRUHh4OGbOnEkVpFRVVeHn5yf0O28rtFgYRLGIHzlyJFWQOnPmDOzt7dG7d29s27YN69atE6kg9eDBAxgYGIi1b/9t+N2T9X8Iu3fvhqOjE1/PEsBdSK1btw579uyhZIDFxSUYNGggOBwORowYiVmzBBkXuh4pgLuQ2rZtG7S0tPD27TuoqKjAyckRgwYNgo+PDxYsWEi7YOLtbSHR2NiI4OBg3L9/H/3798fChQv5ZA6tORva2tohOTmJq0df6YaxJiZIS0tDSUkJVFRU0NDQAE1NTTx8+AhKSkoYPHgw3r9/B0VFJeTl5aFHj+4YPmIELGZZoKa2BjtDQsEO8EfZt2wkxkSjsaEBf/wxHATBwYABA2FlZUnzmZhITEwUmKOcnFwEBrKhqamJz58/o0ePHnBxcUGfPn2waZMvrKwsaRdMdHNUW1uH4OBgpKenY9CggVi6dClf382qVavg7e0tcCHgcDiws7NDUlIS9felS5dx7txZFBeXQE2tB3bv3i2w78J6pGpqauDmthr79u1FZmYmkpKSUFFRgVGjRqG5uRlaWlq0N6fCjqO8vDz4+flBU1PzV/+WJlxcXNCzpyYCAgIwffp0IT1Sf/eR8e5bUFAQHj58hCFDtMFkMvnmtzVnQ1tbW+r9yP6ty5evoLT0B9TU1BAdHS2w7w4ODnxZWyRqa+uwatVK7Nu3D2lpaTh48BCqqqqgp6eLpqYmyMgMhpOTt8Bn4nXtExW2trZYsGCByAumsrIyODg44M8//4Senp7Icpn29khNnDgRZ86caXXBdP78eURGRqK6uhozZ86kJH90bpLCkJ+fD2tra7FlNnR9FqRcJjMzE2pqavDz8+OTy1hYWGDLli1iZWodO3YMqampYgXb1tXVweTX+ez48eOIjY1FfX095syZA3d3d4FAeBL6+vr4/9j7zrCmsrXtm0hvIkWavXcRRZoNu9JUxIJK6EXALgoCCUWxC6JSBCm2saCiYHfGUbCBir0r0lF6r9nfj5g9CdmBhHPO9b1nztzX5Q+TrOxkZbP3etZzlz///FMkCp+bmxvmzJkjdHGWn58Pd3d3PHjwACYmJggMDOQJtO4IXdG2TJ8+Hb/99ptAkxCOjXtcXBxaW1uxbNkycmNN2EBXgP3bL126VGSNlL6+Pt/fBke/9fHjRzJ/i9st18rKCj4+PiJ1KlNSUpCWlkba8gsDjmtfRkYGqd8SExODra0tHBwcBC7OjY2NcefOHZE1UhMnTsSKFSuEev2HDx/g5eWFrKwsmJubIygoSOhQ3K6cR7NmzUJ8fLzAgqm1tRWHDx/G2bNn0a1bN7i4uKC8vBzl5eWUMTWCUFlZCUtLS5GjGqhc+7g3pEaPHo3AwECe7uKyZcvg6ekpUqbWjRs3cPr0aXJdIAw494D79+8jLCwMKSkpkJKSgoeHR4faSj8/PwQEBIhMKf6/iH80Wf/jaGpq+pUdxP+TsztSbGrf0KFDyayH33//HUFBQfj8+TNKS0uxcuUK8ubN7kgJDi12dXUjC6n3798jJuYoSktLUVhYgM2bN/ON4XY25IaEhARKS8tw/PhxSEhIICYmBomJiVBTU4OTk5NAZ8OTJ0+hsrICGVnPoNi7N+q7dYOJyXSYmExHUFAgBg4chDt37qC6uhrjx49HXl4uysrKICZGg4+PD1gECxs3bED28+d4+eIFJCWlMHfqZAzpoQgJFR1Mio0Fi8XCzZs3sXPnTgwY8B4NDfVYsmQJuRDOzc2FoiK/jgxg09ZcXV3Jm+jLly8RFhaOysoKFBUVYcsWb74x7CBV/huAjIw0qqoqkZSUCBqtG6KiohATcxSamhpwdXVFTU0t5Y2D3ZH665pAo9Fgbm4Gc3MzODg4YOTIkb9ogPJYtWolDAwMOuxIsemPbE2Orq4udHV1wWKxcOXKFezffwADBw4AQQBWVovIOWnvbMiN6OhouLq6krbfWVlZ2LNnN6qqqlFcXER5Hj179ozSxVFWVhZ1dXWIjz8GMTEaoqKiEBFxCL17sws3Qc6GqampPHQjjn7LysoKDg4OGDBgAKnfsre3h66uLhoaGsFisfgKLIAdWjx79mwA7AWvoaEhWCwWkpOTcejQYaipDYOUlCZWrVpFzklubi4UFBS6pJESpSPVo0cPNDU1kR0fBoOBdevWYeTIkWR4JhVOnTol8m5kY2MjWltbO+1IWVhYwMLCAq2trTh48CD27t2LsWPHQkNDA0uWLBFqh7Z9aLEwENSR6oguw2QyUVJS0uXQYlGwb98+csNiyZIlWLJkCekGOGXKFMjKymLNmjXkdR1gd6RkZWVFXtBkZ2eTHTRh0KtXL4iLi+POnTtoamrC1q1b8ePHDxgYGIDBYAj8zbk7UsKiubkZjY2NHbow0mg0krVRX1+PnTt3Ijw8HBMmTICurq5QtC2A3R1ZvXq1SJ9PEP2RSr9VXl6OKVOmwM/PDwUFBSJTQQ8ePEh2qEQZY2pqChqNRuq3qquryW4SJ0dz6tSp5JjS0tL/mEaKG0OHDoWioiKuXbuGyspKUr81a9Ys+Pj4CMyxSktL6zC0mApsTTr1fZIDcXFxrF27lvytgoKCkJCQAENDQzx8+FCoDSmAP7RYGLx7944ytJhbv3X58mXY2tqirq6OjKfIyckRObR4//79IhXqAMjwZ0lJSXh7e8Pb25vckNqzZw80NTXBYDB4NJCNjY2k5utvDYIg/s/8Gz9+FEEQWf/8+w/8O3duK3HlCpPyOVvbUURb2xO+x79+PUesWTOJaG5+SCQkeBF2dqMJF5cJxK1bO4mtW2cRz57FCnw/qsczMg4SDg46hKvrBMLObjSRkOBFNDc/JAgii1i92oAoLLzCN6at7Qnl+719e5ywth5AzJ6tSoSGLibKy2/zPG/noEPce5lAuDAtianLhxGmznrE7beniIe5KcTkpUOIqcuHEY7+5oSFmz7hFbqEmLFqNDFj1RiCEe1OvPh5i/jz0zli6XoT4sXPW0RW3mVi3oI+lHP0/fsFwsvLiGhszCBiYlwJOn0U4eamR9y7F0b4+s4hnj6NEWmOHj8+QtjajiKcnXUJe/sxxOnTm4iWlkcEQWQRHh4GRH5+itBz9Px5LGFl1Y+YPVuF2LfPhqiu/oPneQcHHaKu7h7fuLq6e4SDgw75/8LCK0RAgClhazuKWLiwDxEd7UL52el06vMoPz+F8PAwIOrq7hGHDtkTtrajiNWrDYjHj48Q/v7zicePj4g0R1lZ0cSKFcMIBwcdwsFhLJGc7Ese18vLiPj+/YLQc/TkSSQ5RxERdnzz4eioQ9TU3OUbV1+fTjg4jOU5D3x95xC2tqOIxYv7EzExbgLniPN7cv8rLLxCrF6tT1RVZRAbN24k9PX1ifnz5xPp6ekEnU4nrl+/ToiC9PR0YunSpSKNaWtrI/T19fkeT0tLI2bOnEkYGBgQTCaTaGho4Hl+ypQpRFlZmUjHYjKZRFhYmEhj8vLyiJkzZxI/f/4kvLy8CH19fcLCwoJ48uRJh+OovlNnsLCwIF6/fi306y9cuEAMGzaM6NmzJxEaGko0NTUJNa6hoYEwNDQU+fMZGBgQLS0tAp8vKioinJ2dCX19fWLRokXEixcvCGdnZ+LSpUsiHSczM5NYtGiRyJ+v/Zy3tbURJ06cIKZOnUoYGhoSBw4c4Pv8JiYmRElJiUjHCQ0NJUJDQ0UaU1JSQkybNo3IyckhbG1tCX19fWLp0qXE+/fvOxzXlfNo4cKFRGZmplCvbWtrI2JjY4lhw4YRampqRFRUFNHW1ibU2JaWFsLAwEDkz2dkZMT398yNz58/EzY2NoS+vj6xatUq4uvXr4Snpydx6tQpkY7z6tUrwszMTOTPN3HiRJ7/t7S0EBEREYSxsTExZcoUIiEhgW+OZsyYQeTl5Yl0nLCwMILJZIo0pqysjJg6dSrx5s0bwtramtDX1yfs7e07Pba+vr7QvysHS5cuJdLT04V6bUtLC7Fv3z5i+PDhhJqaGvHbb7+JdB515Tw3NjYm6urqBD7//PlzYsGCBYS+vj7h5uZGlJSUEOfPnyceP34s8rH+rwJAFkFR1/zTyfofwdevX/Hjxw+cO3cOQ4YMgaurK1RVVfHt2zeBGqmYmBjY29tBQkICdDoddDod5eXliI6OwYMHD9Hc3AxpaWlSvwWwObb9+/ej/AwnT55ESEgwNDU10dLSghMnTsLFxQUSEhIoKysTmLVlYMAfYDp8+HAoKCggMTEJ6en34eDA1sjMn2+KybNno05OAd01teHh4UlSywICAtCtWzf07dsP1dVVUFLqjh8/SuDkxLYO9fHxQU7ONzAYDDQ1NcLczByqMlJorqvGwF+5T+0RHR0NOzs7SElJwdnZGc7OzigpKUFMTAzS0zPQ2tqK7t27Y+DAgeSYJ0+eUHakACApKQk7dmyHtrY2GhoakZTE1m9JS0vj589SgVlbVLueOjo66N69OxISEvDHH3exYcMGsFgszJ49m+TTU+0GxsX91ZECAE1NTQQGBgIAli5ditevX4NOp0NHZxycnJygoCD/qyNFrSOLioqCra0tZGVl4eHhAQ8PdgcrOjoaf/75J9ra2qChocHTSXr69Cl69eL/rgDbkGPHjh3o06cP6uvrERd3jDTeYFvwU2dtUVFU9fT0oKSkhPj4eNy6dQteXmsgJgaYmpph9uxZlFlbANvwgju3pU+fPti+fTsAtjNcdnY26HQ7Ur8lKytLOhtSdaSioqKwcuVKKCpKYe/eUAAS+PDhA5hMJq5evQqCIDB8+HChzSVCQ0NFzno5efIkZUeKoyfk0GVmzJgBcXFxuLi4YMGCBWhraxNZI3X9+nWRNVIBAQFYv369QP3WmDFjEBgYyHMdYXd/+R0UOwJHIyUsxQ0AFi5ciIMHD+KPP/5AUlISpk2bBmlp6U7pMnv37u3weSoUFhZCVla2w86mhoYGuRudlZWFgIAA3L17F1JSUjA2Nhba+CIkJEQku2iA7RbGscDngEajYcWKFVixYgUaGxuxa9cuTJ48GfLy8li/fj1mzpzZaUeKCikpKSLTrhgMBjw8PHi6Senp6diwYQNKS0sxadIk+Pv782gju2LIAUCkjhSNRoOjIzu8Pi0tDbGxsaQboLe3NxlzQoXw8HCYmVGbKAlCaWkpJCUlO+xIceu37ty5A3d3dzx8+BDy8vIwNzcXSr8FsLuAHNddYZGamspnyNHeDTA4OJjUb/n6+kJfXx91dXUia6TOnj0rcuRCcHAwnJycMGLECFK/lZaWBjs7O9IN0Nvbm2d+371716U8spycHKGiNwD2HG3YsAHXr1/HqVOnEBcXhwMHDkBdXR3+/v4dno+cjpQoqKysBI1GE9hZBNhrkYsXLwJgr+mWL1+OhoYGkcPu/xvxT5H1P4CKigpoaGjA25tNQfvjjz/g5+eHxsZG1NbWYutWfg0IABQW8gdWKisrY+rUKWhsbISNzXKSBjh0KLtwO3nyFKW70V8W8ewblYSEBOzt7WBvb4eEhATcuHEDdLod1NRU4erqSvLTr1+/zudsCHBCi8UgIyONWbNm4dSpUzgQEYGYs+dgu3YdZGRk8PjxYwwZMgTl5Wy6oba2FhoaGjFw4EDcuHED5eUVmDBhAlgECz9KfkBZWRkbNmwEi2Dh4Z/38PTGVWRevoj6+nqBbmv5+QV89sDq6uqYM2cOmpubsWTJUkRERKCiohKjR4+Cs7MzkpKSKLUALBYLNTW1ZCElIyMNV1dXuLq6IiEhgbyAa2howNXVjSxm09KuIiKC34WKrTsQ+3VDZNMA2W6ACbCysoK8vDwePnwEQ0NeXVNWVhY8PPjdkgoKCqCmpoaDBw+CxWLh8uXLv2hYBBobm7BmDbWTWG4uf2ixtrb2rwU6C4sWLcTevXtRVVUFXV1dODo6IiEhgTxf288RN7VPVlaWzB+Lj09AauoV0Ol26NWrF9zd3cib7ZUrVxAWFsb3fuzQYkBBQQGLFi3CokWLUFtbi2PHjmHRIivIy8vh6dOnfIvGjkKL1dXVcfjwoV80wAtk4dbS0iLQkjknJ4eLblIDQBlDhw6Fp6cnCIKAjY0NnJ2dUV1djVmzZmHr1q0Cb2osFgs/f/4U2ekpNjaWMmeIg/Z0mcDAQHh7e5MOgRxaZ2doH1osLKgs4rnpMikpKaSlt5mZGTZt2oTg4GDSVU1Y/Pbbb0J/Fw44FvGc6yyHLsNgMATSZQD2QlJUa28Gg0EZcyEIEyZMgJ+fH2g0GiZNmgRra2s0NTXBysoKa9eu7fB36IpF/JEjR3DmzBmBz0tLS4PBYIDBYCA/Px8BAQFwdXWFoqIi3r17J7Qd9o8fPygNOToDlUX8pEmTkJaWBhaLhePHj8PCwgJtbW2wsbGBu7s7goKCRDZSuHjxYpfojw0NDRgwYAB27NgBgG1CwGAw4OPjg4EDByI4OJhn0w4QPrSYG4GBgSJZxM+YMQPq6urw8fFBv379MG/ePIiJiYFOp8Pe3r7DwqGrFvFJSUkCn1dSUiI3kjjxFDY2NujevTtyc3OF3pDqqkU8VWixqakpTE1N0draikOHDvFsSC1fvhxMJlPk0OJr165h2LBhnb+QC62traiuroaOjg6p9Xz16hW5ITV27FgEBQXxGb+cPn0at27dEulYwcHBsLe3F/r1VlZWmDp1Ko4dOwYxMTGRjvXfiH+KrP8B3Lp1iyeF3sTEBCYmJmhpacGCBQtw+PBhSEpKwtraGjNnzgQAZGRkUGqkAPaONye0eN8+tn7rzp078PHxwYcPH3D9+nUe/RbwV9YWFe7fv49jx+IhIyONd+/eISoqCj9//sTgwYPBYrEonQ2joqJRWlqKgIAAtjZBQRF5jS2Ya7EAfz58BAcHR0REHERrayvU1HqiubkJ+voGuHAhGbdv34KOjg4KCwsgJSWFQGYgKioq4OGxGt3ExKAlJwc3qwUQW7yQDAM9cuQIZGRksHz5cjIH4smTJ+jbl/pCnpiYBF9fH2hrayMsLAwsFgs3btzApk2b8PHjJ9y7dw/W1tY8C5yLFy9CT496l+n+/ftITEyErKwsXrx4gbCwMFRWVmLEiOFgsdoEOhtyd6QAjhugGx49eoTQ0B2Ijo5GVFQUtLQ04erqCgkJCYEaqcjISNIinkaj8bgBLlq0CEeORCIpKQl0Op0sqthZW9S7igkJCdi82Ru9e/fC+PHjwWKxkJJyGWvXrsXnz1/w5MkTaGvzdhA5WVtUyMhIR2JiIuTl5ZGZmYmdO3eipqYW48bpoK2tTaCzIXdHCmC7Aa5ZswZPnz5DcHAQoqNjcPBgBPr27UPaL7fP2uKAbRG/ipwja+vFsLZejNraWlhZWSEqKhqnT5+Gvb0D2VljOxtyd+3YRRYA7NixA/v378fQoUMxZ84cMjxz1qxZqKqqwubNm3n0WwBw/PhxoXc9Oaivr0dra6vQVrrKysoIDw/HkydPEBMTg6CgIOTl5ZH6LaqOKwf+/v4ihfsC7KK2s46UpaUlLC0t0dzcjIiICJiYmODt27d4/fo1RowYIfQNPSYmRmSLeKqOVM+ePcnF/PPnz8FkMlFcXIxx48YhMDAQra2tkJOTE7nYfPnyZZct4seMGYOlS5dS6rfaB8CfPXuWb3OhM3As4tXU1IR6fa9evXDs2DEYGRlh165d2Lx5M37+/AkjIyMEBASgR48eAsdyOlKioLOOFI1GI1kb9fX1CA0NhbGxMd6/fy9yZtWhQ4dE1khRWcT379+fLDbu3r0LT09PVFRUYOrUqdi2bRuam5s77UhRITMzE+Hh4SKN4XSk9PT04Orqyqff8vHxwZQpU3jGXL58uUsW8XV1dUJbxHPiKYyNjeHt7Q0nJyfU1NRgzpw5PG6AVAgMDBQ5CFeQRooDcXFxrFu3DuvWrSM3pCIiIvDx40eRr3379+9HXFycSGOoOlKjR49GcnIyAPaG1IoVK1BfXw9zc3Ns2rQJ9fX16NatW4dzRYX09HSRnWXPnTsnMND474Z/iqz/ARQXF1PeWJ48eYIJE/QQGMgkaYDHj5+Aqqoqfvwowe7d/H84gkKLZ8yYgdLSUnLX09nZGVJSUliyZAlmzJhBmbUF8HakAPbFkrM7tHbtWlRXV8Pe3h4mJiZYtmwZuWv5+vUrXLhwAfcePYZX8A5Iycni+InjmDx5MlpbW7F//z4oK6ugpaUZc+bMwYkTJ3DhQjIGD2Z3tmRlZSArKwcbGxsA7Bv2xDGjoSUnCwmuC+fz58+hp6eHoKAg/Pz5E1FRUYiNjYO6ek+UlPzAjh3b+b4Ti8VCbW0tz0KTRqNh3rx5qK+vx8iRI1FTUwMnJyfIysrCxsYGkyZNwtWr1zrsSHEufmPHjkV4OLtwW7t2LSorK+Hg4IA5c+bAysqKXLRxZ21xg2M2oaWlRdIAnz/PxoEDB/D69Rvo6o7jCwUGIDC0+O3btxg/fgK2bw9BUVERIiMjcfgwOxS4qKiIPEb7OaqqquahTdJoNNKh8fPnzygsLIK9vQPk5eVhZ0eHnp4eUlNTO+hI/UXt09PTg56eHlgsFtasWYPy8nI4OjrB1JRtFc+5OXJnbXGDYxHPpgGG/HrtE4SGhuL9+/cYP3486uvr+W5IgiziP336jPHjx2PHjh3Izc1FVFQUwsLC0K9fXxQWFmLbtm1cr64h56isrIynI8WhyygoKODx48d4+fIljI2NSbtjY2NjyqytzrBr164uW8SPHj2aNG7ghGfW1dVh3rx5fHQZgL1AEdUiPiQkBDt37hTqtZKSkti4cSM0NDTwxx9/4N69e0LTZbpqEZ+WltYh/XHcuHG4dOkSAPaG07Jly/DmzRvMmjWLXCQLg3+F/sjdkZKWlsa2bduwbds2FBYWgsFgYMeOHejVqxeYTCZGjRrVpdDiffv2YcGCBSKNKSkpgbS0NCZPnozJkyeDxWLh1KlTWLhwIVpaWrBs2TK4u7vzFaPPnj3rkkW8sLQ1WVlZBAcHQ0dHB+fOncOpU6cQEBCAfv36ISgoCEOGDBE49j9lET9t2jRMmzYNLBbr1yaaKT5//ox58+aBxWIJTUN79eoVT2ixsGhvEa+oqIhdu3YBYAfYMhgMeHt7Y8iQIQgODkbfvn0RHh4ucmjxwYMHhQo25wanI8XZbOFsSM2ePRvdunWDo6MjVq5cyfedu2IRz2Aw2l2zBYOzIXXt2jUcOXIEe/bsQV5eHkaPHs0TT0GFjkKLO8Jvv/3WoUU894ZUeHg4pk2bhu/fvwuVAceNDx8+dFhsCsL3798FbuL/3fBPkfU3R05OjkDb05MnT8Lfn33DUVZWho8Pmzb47t07eHh4YOvWrSQNUEVFBQCbb9+eXsYBp5CSkZGGvb0dSktLERMTg2PH4lFcXIzc3O98FCZO1hYVKiurcO7cObS0tMDZ2RlpaVehpKSE6dNNoNC9OwrqGqA8ZBgkZGRBp9vh1KmTSE9PR48eypCRkcHChQuRlJSE48eT0Lt3H9TV1cHIyAhXr17Fw4cPMWnSJLS1teLju3cYpqaCvgr8nY7jx0/Az499MVVTUyMpI69evcaaNV7w9fXFqFGj4eLijO7duwMAkpMvYOJEamoEp5CSlZWFi4sLSkpKEBUVhaioKBQVFaOkpAT9+/fnGcPJ2moPGo2G6uoaJCcno6mpGYmJCWTG1ezZswVmbUVGRsLOzo7nsXHjdDBuXDjodDqmTJmC9evXg8ViYe7cubCyssLTp88EdqS4Q4s1NTVJDcfTp0+xceNG+Pn5Y9w4dv4Wpwjiztpqj9TUVB6L+IKCAkRGRiI8PBxFRcWoqKjkKwA5WVtUc1RTU4uLFy+ioaHhV/6WPRQUFGBqaiYwaysyMpIvtJgTeM3p1HFogGZmZrCwsMCLFy8F3jC5Q4v79OlDUoEePnwEH5+tYDCYMDDQh52dPdiZwC04fvyUwI7UsWPHkJKSQnaeOHSZdevWITc3F9XV1SIFPN68eVNkjRSDweDbleUOz+TQZSQkJODi4oJly5bh8ePHIi8YOPRHUTRSwF+hxZyC6eXLl2AymSgoKICOjg4CAwP5FsG7d+8WKrSYG8JopLjBcaecOHEiRo0aReq3PD09sWjRog7HhoSEkNo/YXHu3LkOqVpaWlpkZywzMxPbtm1DUVERcnNzRV48cYcWC4v2ocU0Gg0rV64kqZ979uwh9VsbNmzAvHnz8OzZM5GDcAH25omoFD5OaDHnXElPT8e6detQVlaGKVOmwN/fH4qKijxjwsLCRF6wlpaWQkpKSqiCm0ajwcnJCU5OTpg4cSLU1dWF1m8B7GKTitbfETrrSA0ePJgMd759+zZcXV1RUVGB/Px8vvnpDMnJyV2iP3KHFrfXbwUFBeHIkSNQUVGBn58fDA0NuxRaDLA3mIR1E+SAE1rMuY+mpqaSboCCNqQiIyP5mBadQRiNFAeSkpLYvHkzNm/ejAkTJqBbt24wMDCAhoYGAgIC+KQQ7cFkMkWKQQCAjx8/8sQV/N3xT5H1N8fx48cxduxYvsfZ7fh6vo4UALx48QJLly6Fq6sr7ty5A1/fbWhubsKUKVNx796fOHKEf/eQKrRYVVUVvr6+OHDgAGRkZBATE4PS0jIMGzYMrq4uUFZWRnb2C6xdu5bv/T5//gxZWRnQaDRISUlBTIyGM2d+w8+fpVjl6gqaUg8wdu2Cnp4eFBXlceTIEXTvrviL9rgYJ0+ewtGjR3/psBowZsxofPr0GQYGBpioPxFMBhMKCgrY5e+P4k8fsMaLX0/E6UhRdQHfv3+PxYsXw93dHTdu3MTmzZvR2tqKmTNn4vbt2zh06BDfGE42C/fFT11dHQwGA+Hh4RATEyNt3MeMGQMXFxcoKCgI7EhxhxbLyEjDzc0Nbm5uKCoqhrMz2yzDx8cHrq6uPLtGeXn5AkOLe/fuDXNzc5ibm//Sb8XDwcEBubm5lDbYLBZLYGhxbm4uFi1aBE9PT1K/RRAE5s+fj6tXr1JSVags4rW1tRESEoLDhw+jvr4Bu3fvQnV1NSZM0IOjowNkZWUFdqQKCgrIQkpOTo5czOXl5cHNzR3S0tLw8/ODu7s7T+fx+/fcDkKLtcmFcm1tLeLi4mBvb4/8/HxKKgiLxRIYWvzz5w9YWi7A2rVrkJycDE9PD4iJiWH6dEfExZ2l7EjV19ejra2Np4ji0GUCAgJQUlIiEl2mqxbxHXWkuOkyZWVlCAoKwsGDB/H161eR8qAA3tBiYUHVkRozZgxPeCaHLmNhYYGNGzdCUlIS165d65IhB9U1rCNw/ta2bt2KrVu3ori4GIGBgdi9eze0tLTAZDL5tFCcjtR/0iJeT08PKSkp2L59O16/fg0rKys0NzfDysoKa9as6VS/1RWNVEcW8bKysqR+Kzc3FwwGA4GBgfj+/TvlNbYj/CsW8dzFOJt1cBUsFguJiYkwMzMDi8WCjY0N3NzcQKPRcOnSpS4Vm+7u7iKNefmSvbHD0R1+/foVAQEB8PX1xaBBgxAUFIQBAwbwjRMmtLg9Dh482KFGihszZ87EzJkzsXfvXvzxxx+kfsve3h50Or3DokYYQw4qdNSRUlJSwv79+wGwr1tMJhPr169HYWGhyNcj7tBiYUEVWsy9IXXw4EFyQ8rV1RVLly4FjUbDb7/9JrJGqqsW8WwtMZtt9OLFCwQGBvLEU1B1ZYUJLW6P5ORkkc/z/2b8U2T9jcFisSAtLY23b98iOfkCVFVV4OTkjOHDh+H8+fMwMqJeuNy6dYuk9s2YMQMzZsxAS0sL4uLi8O3bN6xbtw5LlljzpNXHxsbCwsKS8v2ys1/whM3evn0bPj6+qK2tRX19Hdra2vguukePHkVjYyPodDv069cPqqqqaGxtQ42kFGQ0tREYGIiv375i75696N5dEWJiYrC0XIC0tFRER8egZ081SEpKwtnZBb/99hsuX76C4cOHo7S0FJ8/f8awgQOwib4KUvZ0rFplizdv3iAl5TJ69lSDq6srBg0aJNDZEGAbckREHPxFA5yLefPmoqmpCTExR/Hly1ds3LgRNjYrMHnyXxeguLg4ylBnAHj27Dk5RywWC9evX8fGjRvR0NCA+vp6SipIVFQUqZHihqamBlRUVJCYmPiLBsjWb+nojIWurq5AZ8PExEQeExS2fssdrq6uWLlyJZ4+fYrk5AvQ1taCm5sb+vTpg5SUFIH0q9TUNISHh/Hpt6KjY/D58xds3boVdDqd52Z/7NgxgTQRTiHFmaNLly7By2sNWlqaUVdXTzkmOjqaryMFAL1794aqqioSExNIGmBNTS0mTtTDuHHjoK1NvUseH38MmzZtIv8vLy+PtWvXkousjIwMnD17Dv369YWbmxs0NTWRlpZG6WwIsHeHDxwI+6Xfsoa1tTVqamqwd28CXr58iRUrVsDX15eno7Vz506S5toet27dIkOLW1tbERkZ2SldJiAgQKCxiyBkZGQIHQyqoqKC8PBwsFgsknp14MABjBo1qlO6DMC+toiqkeqsI7Vw4UIsXLiQpMuYmJhATEwMtbW1Ihebr169QmxsrEhjgoKCeAw5NDQ0SOrbs2fPEBAQgKKiIkyYMAFMJhNqamo4d+5clww5mpqahHYT5CA1NZU8jxobG7F3715MnjwZsrKyWLt2LZ9+C2DvalNtBnUEUTpSffr0QXx8PABg5MiRSEhIwJ49e0j9Vmed28OHD+O3334T6fOFhYVRfleA3U2yt7eHvb096urqEBoaCiMjI8jIyKC+vl7kYvPp06fkIldYtO9IDRgwACdOnADAzrlcvXo1KisrMW3aNGzbtg0KCgpISUkR2cxEVI0UBxcuXMDvv/8OaWlpVFdXk26AysrK8PX1pVygBwUF8XSkhMHr16+F7kgNHz6cNGYZNmwYDh8+jNDQUMydOxdbtmyBDJtKIBAHDhwgz0NhceTIEYF5bBw3QI67ZVBQEMLDw6GsrIyGhgaRNVIPHjwgs06FRWBgIE9HauzYseQ198KFC7CxsUFjYyPMzc3JDakbN26IbMhBEASqqqpEYln8t+OfIutvjOzsbBgaGpIXsk+fPiEmJgY/fvxEQUE+aV/LDaqOFMB2A6yvr8emTZtgZGSE6OhoJCUdh6qqKlxcnAV2pKgs4jm7XFu3boW8vDxcXFzQrVs3WFktxrx57NZ4cXEJEhMTwGKxsHTZMhByili1cRMGDBgALS12Z6lfv36QkJCAiYkJMjMzkZCQADU1VcjJyWLatGn49u0bNDU1sXbdWgQyAzFj5gwci41FzuuXWDBrJtDSiuTUVEyaZEzurLx+/RqHDx9GWVkZiouLKbnktbW1EBPjtz+XkpICi9WGDRvWw8DA4Jd+KxYaGupwcXHBs2fPeWgxHOTm5qJ7979Ci2k0Gmmb7ePjA0lJKVK/tWLFCnLBnZ9P3ZFiW8SzdRtsGiBbv5WWdhVMJhNaWto4c+YMrK2tyWNynA2pKIGXLl2CoaER6eL37Nkz0g2wuLgEJ07wzxG7IwU+Wp+srCwkJMSxZo0XDAwMEB0djUOH2PotNzc3ZGVlUbr2tQ8tptFopBvgtm3bwGKxyFBgOp1Ozsv3798pO1LPnj0jLeI5NEAWi4WLFy/C19cX2trauHjxEiwtLXjmqKPQYgMDA7Lb9/DhI4SEbEdtbS1+/ChBUhL/HDU0NIIgCCi0o6kqKChATU0a27dvx8yZM8FkMrFhwwYMGzYMwcHBuH37NqUj3ffv33k6UuLi4vDy8oKXlxcPXUZVVRXbtm0ju0Pv378XOpCVg9DQUJFv5CdPnsTMmTPJHWXu8ExTU1Ns2rSJb/e6qxopYTtS3HSZVatWobS0VCS6TFc1Uj9+/BDYkdLV1SX1W2fPnsWSJUvQ1NSEoqIiPHz4UKRj7du3T2SLeE5oMec84nR7OSG53PqtwMBAksYpamgxwDbkYDAYIo05d+4cpk6diiNHjoDFYuHEiROkBkeQfkuY0GIqCNuRkpOTQ0hICEJCQmBra4u2tjYYGBhgwIABCAwM7JQe9Z+wiJ8+fTqmT58OFouF2NhYcvOqpKRE5C5beHg4GfshLNp3pBQVFUmDhE+fPpGbO8OGDUNQUBC5afPkyRNK3W1HYDKZIrs/pqamYtKkSYiNjSU3pGbOnAlxcXE4OzvDxsaGr2gTJrSYCmfOnMHt27c7fR13PAWdTkdJSQkMDAwwevRoBAYGdlrkdmbIIQgdhRZz7rPNzc0ICwvDtGnTICUlhdLSUqSlpYl0nIyMDJFNmf7bIcbO0Pq/gQkTRhNZWQn/vz/G3waHDx+Gq6sr3w2HbSbhADU1VTQ2NmLq1KlYuXIlJCQksH//fgwZMoRSA0Sn0xEfH8/zB/zhwwfs378fHz9+xOzZs+Hq6sqzIPLx8cHSpUv5rIvZ72eHxMQEAMCaNWsgJyeHwsIidOtGQ/fu3XHgwAFUNzXBft0GMIJDUN9QD5+tPlBQkIeEhARGjBiJ/Px8fPz4AcrKKmhra0VQcDBSr6Ti+vXr6NWrN8zM5qO8vAIVFRVwWmkDFfFu8Fq9GvPnz8f169eRn5+PS5dS+IrKmpoa2NraQk1NDS0tLZg5cyaWLl0KcXHxX4YF/SgF3nS6HU/XDmDrtw4eDMenT59gZmYGZ+e/9FsAsG3bNlhZWVEu6LjnqKioGNHRUfj2LQeSkhKQl5enpEd4enrCx8eHz+GNU4hERUUhISEBjx8/gpycPFatWonCwkIUFBSShRQ3HB2dSB0ZN2pra7FixUr07KkGFov4pd9aBBqNhoiIQ9DW1qLUmFDNUVZWFiIjo/Dly2csWrQIDg4OPAWav78/zM3N+azg289RXl4+oqKikJ+fDzk5WUhJSVHO0Zo1a7Bp0ya+gok9R/Y4fPgw4uLi8OzZcygqKpB0wK9fv1LSJp2cnBAWFsZXVNbX12Pp0qW/FndisLS0gJmZGWg0GiIjI6GqqkrZcbGzs0NcXCa6dfvrvLx27RpCQkLw9u1beHl58dm40+l02NjYdFowvXv3DgwGA9+/f4eKigokJCQ6tG5vDxaLBSMjIzx69EjoMQAwdepUHh0ZBxy6THJyMh9dJjAwEEpKSiLR8fLz82Fvby8yzcbAwID8TtnZ2QgKCiLpMoGBgVBXV+cbY25ujp07d4qkFzt9+jQePnxILqaEQXV1NUaOHIlevXpBRkYGXl5eWLhwYafjDA0NyY6UsHBxcYGpqSksLamZCRw8efIEISEhpI60vr5eZMMVfX19PH78WKQxJiYmOHPmDF/BVF9fj927d+PGjRtQUFDAxo0byb+FnTt3QkxMDFu2bBH6OD9+/MDSpUvxxx9/iPT5uM+je/fuYefOnSgvL8eUKVPg5+dHqU9atGgR/Pz8Oi3quXHp0iVcv35dpMK2vLwcI0eORJ8+fdCjRw9s3boV06ZN63SckZER2ZESFl5eXjA2Nu7UUOfGjRvYv38/qqqqoKOjg7y8PJEX79xzLixmzpyJpKQkvsKlvLwcwcHBePjwId+GVHh4OCorK0XaGCgvL8eiRYtELmwNDAzw4MED0Gg0XL58GQcPHkRdXR3MzMywceNGyt9iyZIlWLduHWXeoSBcu3YNZ86cQUJCgtBjioqKMHbsWPTv3x+amppCbUgBgJ+fHxgMBo/z9N8FYmJiTwmC4Nvx+KeT9TdFY2MjxMXFKW+uR48ehYODPUxNTdHS0oLTp0+T9t3FxSWUi0hBocVDhw6FsrIyDhw4gNLSUvj4+KK5uQnTpk2DjY0NZdYWwKYyNDY2or6+HtLS0qiqqiIXHXZ2dmhsbsESVzd0k1eEdt9+AAApSUm0tLSgX7/+YLHa8Mcfv0NZWRliYmLQ1R2H1tY2SEpIwszcDK9fv4KXlyeSk5Px5OFDTBg0AC0lxTjz55+YPn0GrK2tMXfuXKxfv57SIj4uLg52dnawtLREU1MTkpKSyFDgkpISypya9h0pDkaPHgU1NTW4ubnhx48f2LRpE9ra2jBr1ixYW1tTZm0B/BbxmpoaYDKZANiFRUNDA+h0OsaOHQtnZ2coKCjwZW1xgxNazLFxd3d3Q1FREaKionH37l3o6U1ATk4Oj3aISkfGQXx8Auh0WyxatAj19fWIj48n3QCLi4sodSDtO1IcTJgwAZqaGnB1dUFBQeEv/RZIN8Dc3DzKAqu9RXzv3r1IN0BbW1u0tLSATreDnt4EODiw9VsddaQuX76McePGkTRAgP27RkdHIz09A4aGBigsLOS5Mbd3NuRGYmIibG1tSRpgbGws7O3t0b17dxQVFVHmCXFCi7t1qwfw17k5b948nDlzBn5+fvj8+TNmzZpF0gBXrVqFDx8+CNWRGj58OBmeqaenBykpKRgaGpJ0mc4WUidOnBDpJg5Q68g4EESX6dmzJ75+/Yrs7GyRjsUJLRYF7S3idXR0SLoMJzyzsbERFhYW2LBhAyQlJcFisVBSUiKyIUd0dLTI9MeDBw9i3bp12LhxI4qKisBgMLBr1y5oa2uDwWBQ0r8KCwu7bBHPCTLuCBMnTsTly5fBYrEwYcIEiIuLw9jYGNbW1vD09Oz0uP+KRTxVR0pWVhZMJhNMJhO5ubkICAgAg8FAv3798O7dO2RmZop0LAaDITL9sX1HasqUKZgyZQpYLBbi4+NhZmYGgiCwcuVKODs7k9fBwsJCkQosAIiIiBDZIj4+Ph6enp7Ytm0bvnz5goCAAGzZsgWDBw9GcHAwn+kS0HWNlLAW8XPmzCHjKXR1ddGtWzdMmTIFDg4OsLW17bQrk5qaKrJOsSP6I2c9A/y1IbV+/XoMHz4cL1++FDlAlxNaLArad6QsLCxgYWHBo9+SlJSEm5sbDyMlNzdX5GtzVyzik5OT4ebmhqCgIGRnZ5P6LV1dXQQGBlL+fTY2NqJbt25/ywKrI/zTyfqb4tatW+jVqxdlsCNVJwFg3yB8fX2hptYTqqqqcHJywvDhbM7tli1bsWKFDeXNnLuTALBDV0+cOInU1FRUV1fBx8eHz+1o9erV0NPTQ3p6BiorK6CqqorIyEiwWCzYurrDb88etLIIeHt7Q15eHlVVVdDW1kLPnj3x6NFjKCkpobT0JwwMDNDU1ITnz5+jZ091jBnDdj+SlZOD6bz5kG5rxc5tPtiwfj3i4uLw+vVrTJ8+HW5ubkhISMCAAQMoOfeC5uj58+fw8fGBuro61NXV4erqSgZD+vr6wtp6CaX+pv0cNTQ0IikpETdv3kR1dTUYDAZfu97Dw5PM2uIGpyPFoVNevXoVly5dAovFgppaT/Tq1UvkjtS6devg4eGJhIR4VFZWYty4cXByciLdkITtSAFsbYGvry80NTWhra0NV1dXsqDx8/ODpaUlpei6/RzV19fj2LFjuHv3LqqqqrBjxw6+cV5eXvD23sKnM2s/R5cuXUJa2lWIibEdEFVUVCg3ExwdnXicDbk/i5fXGjg7O+H48ROorWXrt+zt7REfH4+ePdVhbb2Y7/3s7Oxw7Bj/HGVmZpLdxn79+sHNzZ00oWEwGJg3bx4MDMwA8Oqe2u/YcmiA169fx+DBg7vckWptbSVDZCUkJODk5ERJlwEEd6Q6ApPJhIqKCiVdVhBu376N5cuXY+DAgULTZYCu7WoL05Hi0GUuXboEaWlpjBgxAjQaTaSOVGNjI6ZPn44HDx6I9PkEdaQyMzMREsKOTtDX1weDwSD1V87OzjA3NxeoKaJCVlYWQkNDyTwdYcGZ88bGRuzevRvXrl2DnJwc1q9fL5BmJqgj1RFCQ0PRrVs3yqByQbhy5Qrs7OwwePBgGBsbw9/fX6hztyvn0cKFCxEQENChwUZtbS127NiB33//HUpKStDX1yddZoVFc3Mzpk2bJvJ5ZGxsjDt37vAVTHfu3MGePXtQWVmJ6dOnw9fXl7wGenl5YdKkSVi6dKnQx3n9+jW2bdsm0vUI+GvOKysrERISgvT0dKioqPDpUrkhqCPVEcLCwlBdXS20nT/AtkVfvXo1hg4dKvSGFOc7cTpSwmLJkiVYv359h4Y/paWlCAwMRGZmJtTV1WFiYoIXL16IpBdrbW3FpEmTRD7PJ02ahJs3b/KtJc6fP4/Dhw+jsbERlpaW5IYU57m+ffuKbLjy34J/Oln/Y0hOTsbEiRMxaNAgnp2Dr1+/UnakAOD06d+wc+dOjBkzBh8+fMDRo0fx82cphg0bivz8fMoCiyq0WEJCAvb2dsjMfIKQkGBcvHgRiYlJUFNThaurK/r374+6unpSNOzk5IRBgwbD1tEJ5W0s9B86FK0sAs0tzaitrYG8vDz09fWRkZGBiooKNDc3Q11dHcOHD/t1EVaFmpoamIFM/H7nd5w9exZ9tTQxSFEeeV+/wtLCAiNHjsT+/fvBYrFw8+ZNbNmyBe/ff4CTkxNaW1t5Fi+5ublQUupOOUfnzp1DaOhOjBung1evXiMiIgIVFRUYNWo0cnNzKQusx48f84UWy8hIw9XVFa9evYK/vz8uXbqEo0ePQkNDE25urujbty9f1hYH3KHFNBqNdClqaGiEldUiFBcXwcPDAytXriQv0h11pNh5K2akjTtbv5WG9evX4+PHj1i9ejWf8QbblpfaIv7ChYsICQmBnp4el36rGrq645CTk0N5kaUKLZaVlYWnpyc+fPiALVu2IiXlEo9+S1tbS6CzIXdoMbd+q7a2FtbW1lBTU4OXlxfs7e3JHWQqZ0MOOKHFBgYGMDAwAIvFQnLyBXh5rcHnz5+xfv06vjnidKSo5ig1NRUhISEwMDDAw4cPERISjNraOhgYGODLly+/dGQ1PGPS09P5dpo5rlnv37/H7t27+Y7TEbhDi8XFxbFmzRoyUyw4OBgRERFQU1Pjoct01JHqCDdu3BDZte/kyZNISkrCvHnzePRbHdFlHj161GWNVGcdKUlJSXh7e8Pb2xs/fvyAjo4OtLW1sXDhQjAYDMqOfXvs3r1b5BDOjjpSHDdAFouFc+fOwdraGk1NTbCysupSaHFISAgZwSAsuDtS0tLSCAgIQEBAAPLz88FkMhEcHIw+ffqAyWSSrmwddaQ6Qlcs4tPS0hATE4OFCxfi+PHjsLS0RFtbG5YtWwY3NzfKee2qRkoYi3h5eXkywuHbt28wNDSEtrY2bGxsEBwcTG7adQSq0OLO0FFHimNwxWKxcPToUdINkE6n4/HjxyKHFjMYjH/JIl5JSYnUfL5//x5MJhMbN27E0KFDyfMJYBcJ9fX1IhtynDt3TmSL+IcPHyIiIgJLly7F4cOHMWPGDIiLi8PFxQXLly+nvM6/ffu2SxopYSziVVVVSWdEzuZxr1694OLigqCgIKEy2rpqES8otHjx4sVYvHgxmpubsX//fjKewsPDA1lZWSLrQ/8O+KfI+huioqICBgYGoNFocHFxgaSkJBYvXoxZs2YhOjoajo4OlOO4AyuHDh1KXuQOHTqE0tKfsLe3x5QpU7Fy5QqycOPO2uIG5+I3fPhwspv27t17REVF48OH91BUVER5eTnk5OTQxmJhlYcH5tY3wj/AHw0NDVizxgtycnIwMZmOR48e4c2bN2S4o6npfNy8eQsqKiro1k0cWlpaGDV6FGhiNEycMB6vM+4jbHsIjh07hmvXruH69evk56LRaJg7dy6GDx+OPXv2oKmpEc7OzpCWloaNjQ0mT56MqKgo2NnZU85RQUEhWUiNHj0KYWFsU4mIiAiUlJTAwcEBM2fOxJIlS8ibd1LScfj68mdJcCzidXR0yAVadnY2wsLC8eXLZ3TvroSamhooKCjwjBMUWtzW1gotLS3Exsb+ogGy87c0NTUhLS1NqbMD+EOLaTQazM3NMW7cOGzfvh3l5eVwcHCAnJwcVq1aRZp6UDkbAkB+fh5ZSOnq6kJXVxcsFgvh4eEoKSmBo6Mj5s+fj4ULF5I3H+6srfZzVF1dAz29CWRhmZWVhd27d+H79+/o3r07ZSjwlSvsrK32oNFo0NLSQlxcHPLy8hAVFY3w8IPo27cPpKSkBFqSt7eIZ7sBLsakScZgMpnIycmBvb0DundXhL29A8aN00FUVBSlsyEA5OT8ZchhaGgIQ0NDtLa24sCBAyguLoaTkxMsLRfA1HQwaDQpAOxdfI5pRPs5ah9aLAw4WVvtwU2XefPmDZhMJvLy8jBixAjIy8t3ObT4X7GI56bLhIeHC6TLhISEkOGowuL06dOU5igdQVFREf3790dGRgZJl+EssAXRZQDhDTm4wWAwOtWk0Wg0LF26FEuXLkVjYyPWrFmDL1++YMaMGQLdANuDxWKhqKhIZOc5QaHFvXr1Il0XHz9+jC1btuDHjx8wNDSEvLy8UJoybhQXF0NaWlpk177nz5+TXSI6nQ46nY76+nrs3LkTkydP5tNvAWy3NVENObpiEa+trY0BAwbgwYMHuHv3Ljw9PVFRUYGpU6di27ZtAvOlOgstpoIwFvE0Gg2urq5wdXVFdXU1vLy88PXrV5iamsLHxwdTpkwR6lj/Tov4YcOGka6Q169fh5OTE6qrqzF79mzIycl1ObS4qxbxNBoNa9euxdq1a1FeXo7AwEByQ8rPz4/HAVSU0GIOrl27JrJF/LBhwzBgwAA8evQIKSkpWLlyJerq6njiKahw5syZDkOLqRAcHNypRbykpCQZT/Hjxw9s3LiRlHb8r+GfIutviFu3bmHu3LnQ0NCAra0tysvLERMTgxMnTiAvL4+ygMjIyED//v0o3+/du3dISkqCsrIyTp06xVW4WaO+njprix1azLsTM3z4MOzbtxcODg6wtraGj48vcooKoTV8JAqra9Hc3ITS0jLU1rJDg58/z8b79+9RU1MDWVkZWFlZIS0tFbW1tejZUw0MBhNfv37B7t27UVJSgqIvX8CqKAd9sRUUFRWxYMECfPv2jXIXiV1sOpEhuT9//vzlBhiH/Pw8yovIo0eP0K8fv201jUbDx4+fyDlKTEwk3QCXL18usCOVnHyB70ako6OD8PAwODg4wNzcHBs2bEBbWxtmz56NxYsXo7GxkdLZEOANLdbU1ERgYCAAdrbTxo0b8PXrV+TkfIOTkxNZuHFnbbVHVFQUHB0dMWHCBLi7u5OFW2RkJPLz8yltdgW5rdFoNHz9+hXHjsVDRUX5VyiwAxQU5GFrayuwI0UVWjxhwgRMmDABjo5OmDlzJry82Po4jn6rsbERgjpS3BbxvXv3JvVbT548wZYtW/Dx40eUlJTA3t6enOOioqIOQ4sdHBzIG2tubi6ioqIQFhaG/Px8uLm58Y1hZ23x77yKi4sjLy8PsbGxUFFRQWxsLObONYakpAa2bt0qsJBKTEzE5MmT+R7vCMJ2pEaOHEkuoFNTU7Fq1SoMGTIE5eXllOGZVKAKLe4MDx8+pNTMiYuLY+PGjdi4cSNJlzlw4ADU1dXh5+fXpdDimJgYXLx4UaQxu3btIg1LdHR0yPEc/VZDQwMWLFiAdevWkQucrmqkXr16JVJHiqMbvXv3LpSVlXncAJlMpkD9yrlz5yh1jx1BWIt4fX19XLlyBSwWC6dOnYKXlxeGDh0KSUlJeHh4CDUn/06LeFlZWQQFBSEoKAjfv38ns7j69etHFszCdCa58a9axE+bNg3Tpk0Di8Uir+VU+i1RQou5IapFvKKiImpra3Ht2jUoKSmBwWDA29sbQ4YMQXBwsMAIh5SUFMpszo4gbEdq7ty5mDt3LlpbWxEVFQU/Pz+MHDkSvXv3xqpVq4TqGAUGBsLZ2VmkzycotFhZWZns8r158wYMBgN5eXkYOXIkgoKCuhRavH//fpEt4g8fPkx2pCwtLWFpaYnm5mZERETAxMQEUlJScHNz4+mid9SR6ggZGRmkS6Qw6NmzJ4yMjARuYP7d8U+R9TdESUkJT6tYWVkZW7duRXp6Os6dO4+4uFj8/FmKoUOHwMXFBaqqqjh16hQlP5kjEOU4a3F2AsvLy7FhwwaUlJRg48ZNcHFx5lkAcmdtcYNjET9rzhyMmjQFa7b6QLtvXzLo0sBAH+/ff0Bubi4qKirAYrVhyZIlSEtLxePHj8FisSApKUFSJaRlZDBk4ECEBTLx5N6fiI+PR0JCAXJz8/DmzWuhOlIAoKamBn9/fzx8+BAnT578ZeNejlGjRsHFhe0GePz4cUoKRPvQYhcXF7i4uKCkpATe3t4oLi7Bli1b4ebmykP34mRttUdtbS1oNBqZ5cPRb7GLwVJMmzaV8jsJCi1WVVXFyJEjER4ejrS0q1i/fj1YLBbmzp2LFy9eCOxItQ8t5hRumZmZiIuLI23cOfoteXl5JCYmUibAtw8t5nzOgoKCX7tdP7Ftmx/c3Nx4iq3UVOqOFMcifvnyZVi+fBnq6+sRF8cu3MrKSjF16jTK75SZmUUZWqytrY0RI0YiIuIgLl68CC+vNRATYwdGPn36VGBH6vv3XJ6dyz59+mDHjh14/jwbhw4dIm3cDQz0YWdnDxkZab6sLe45qqr6K7R4/fr1WL9eFe/e1WPlSrYDpJ2dHYKCgngKkPj4eFy5coXy8wnCzp07sXz5cpHGjBkzBnp6erh69SoOHTpEhmc6OzsLpMsAHYcWC8L27ds7vZFz02VevXoFOzs7FBQUiESX+Vcs4qls9Dkh1VR0mWvXrlHqADtCZmamyHbRHEMOTjHFKdAyMzOxbds2FBcXY+LEiaROjgNRQos5ENUinkajYebMmRg3bhxSU1Oxe/duTJ48GXJyctiwYUOHXYn/lEV83759SWe19PR0LF26FIWFhdi0aRP8/f15nGAF4d9pEU+j0eDk5AQnJydSv2VsbIzu3bvD29u7S2GuL1++FOrvoT0KCgrIjcBTp04BYN/bXVxcUFVVhRkzZsDHx4dnQ+vgwYMiG3KIahEvLi6OZcuWITk5GRcvXkRQUBAiIyM71W8BHYcWCwKTyeyU/jhy5EicP38eAPu+NX/+fBQVFSEoKEjoDamuWsSfPXuWz01VUlKSb0Nq//790NDQgL+/P06ePNml0OKu0B+/f//OJyv5X8E/RdbfDN++5QjcYTp16hQYDAZZMP3+++/Yts0PjY2NKC39SbnQOHeOvyMFsAu3bt264cKFi8jJyUFMzFGUlv7EsGHDsGLFCsqsLQAICwtHPcRw/+NniHXrhtLSUty7dw9jx45FXl4eKiurUVZWhtraWlhZWeHOndu4f//+LytVP9Q31MN7szdSUi7jzu07EGuow1p7eyhJS2H27NmYPXs2mpqacOLECTx8+AhVVVVYtmwZpk79qzB5+PChwD/4EydOws9vGzQ1NUn91ubNm9HS0oKfP39CTU2Nb0xy8gXK0GJ1dXWIi4vj4sUL+Pz5M8LCwlFZWYExY8bAxmaFwI5UXFwcD7WPo99ydXXFihUrUVtbCzrdDlpamnB1dUW/fv0EOhsCf4UWs2mAZjA3Z+u3EhLikZ6ejsrKSrS2tvJQpthZW4JDi/39/aGtrQ0Wi4XLly9j7dp1YLHaUFZWRqllEBRarK2tDUlJKVy8eAFv377F7t27UF1dg/HjdbF8uQ066kiZmv61IJOVlSXNPlasWIGqqkrQ6Xbo3bsX3N3doa2tLdDZEGB3Nul0tpMVZ6FcW1uLY8eO4d69+6isrISkpCSPAxh31lZ7xMcfA4MRgD59+vzSbyWThWVp6U/Km2hqaioF3agGw4ePgpycHD58+ICMjAw4OTmhpqYGc+bMgaenJ9ra2oRaCHLj1q1blEVCR+Dk2oiLi2PdunVYt24d6QZ48OBBcqOCu+ik0mx2BhaLhZ8/f1Ka9gjC6NGjoaCggLdv3+L+/ftC02V27dolkqAfYFOhOqM/ctNlSkpKwGQycf78eZSXl6NPnz5CU/JCQkJI/Y6wOHv2LGVHqr1+i6OdsLKygqur678UWiwKGAwGvLy8+NwAGQwGuYEQGBjI8/tnZWWJrLsBIHJHatKkSVBWVsaNGzdw/fp1mJubk0Hjbm5uAheXYWFhlJEeHeHHjx+d0h/b67cCAgJw+fJlVFZWYvz48ULptwDhioT2uHTpEuV5OmvWLMyaNQssFgvR0dGkfsve3h4rVqxAfX29yAXdhQsXRNZIcUKLObpU4C83wA0bNmDEiBEIDg7mudaKElrMjby8PJGCwM3MzBAeHo4rV67gwoULpH7L1dUVy5YtE3h87o6UsCgvL4e4uHiHHSnuDamXL18iMDAQt2/fxrJlyzB79myhf6/2ocXC4OPHj53mxP2d8U+R9TfD77/foVw0cNrx3FkvnLDCkydP4t69+79ogFKwtl6MmTNnAgBu3bqJI0eO8L0fd2gxhwYIsB3BXFxcICUlhcTERNjY2JD6rcbWNrwsKMKiVbaIOxaPnJwcDB06BD9//oSEhDhKS3+ioqICpqbz8fAhW4fV1NSMlpYW2Nqyuy2FBYUYMmQwtm7YAFZFGTatXYvxurwLUykpKQwbNgzTpk2Fp6cnoqKicexYPNTVe8LFxYUspNqjfUeKo9+aO3cuTp/+Dbdv34KTkxNkZGRgY7MCkyez3QCvX78msGsHiEFWVhZjxoxBeDhbv3X9+nXY29tBSkoKv/32GxYvXsyzYHv27JnA0GIVFWWSBpidnY0DB8JQWVmJqqpKbNzI3x0B2Bqp9gWOjIw0xo8fj6KiIri7u5M0QG1tbbi5uSEpKUlgR4rbIp5Go2HBggVYsGABfvvtN1y7do20cafTbcnFXmpqGmXXjtORkpWVJWmALBYLKSmXsWrVSkhKSiI5OZlHvwWgw9BiJaUeCAlh0wAzMzMRGhqKmppa1NbWYu1afut9gN2Rar8wlZeXx6RJk1BSUgJXV1dER7P1W/369SXdKTvqSHG6TWz9ljWsra1x9uxZpKSkwN7eAUpK3WFvb08uAlNSLlN07ZpQX18FFosFRUVFzJs3D/PmzSPpMmPHjoW0tDSSkpKwcuVKoRYP379/h6KiIrp169bpa7lBFVrMHZ75+vVrMJlM5OfnY9SoUQgKCkJoaCj27dsn0nFOnjwpcmAld0eKmy4THh5Ohme6u7vzmU5cv35d5CJBVIt4dXV12NnZ/Yq48AGDwUBRURF0dXXBZDIFdj9YLBaKi4u7ZBHfkTtge/3W3r17Sere5cuXhXYjLCws5AktFhbZ2dmIjo7meaxPnz4kRerhw4fYvHkzfv78CWNjYwQEBCAkJIS87gmLs2fPimyLzulIqaur8+i3QkNDYWxsDEVFRWzatAmzZs3iGZeSkiJynhaTycTq1auFfn3//v2xceNG1NbWwtnZmdRvmZiYYNu2bZSbURx0FFosCAcPHiS7V1Sg0Whwd3eHu7s7qqurERwcjEGDBkFSUhLp6ekCw23bo7S0tEsaKarQYu54iqtXr8LBwQHV1dWYO3cuvL29wWQyRXIUBLpuEV9bW4u+ffv+YiSs59uQCggI4JMLnD17VuRiMzg4WCT645gxYxASEoKmpibMnTuXLIw725AC2KHFol6bz58/Dw8PD5HG/J0gWjn/D/5Pg8Vi4c6dOwgPD0dpaSnPc+fOnRPIDb5z5w4OHgxHfHw8QkN3IDMzE3Q6HWvXrkNzczPlxe/o0aOUYZUzZ86EhoYGzp07BxaLBUtLSzg5OyP55m3cffsOMkrdMXLkKHh7e0NVVRUaGpooKytDZmYWpk6dhu7du+P9+/dQUlLChg0bEBYWBjGxbrh27RoCA5mIiY6G8xJrDOyugJ+FhRg3jvomeurUKbi5uf3aXfdDYmIC6HQ6Dh06hNevX+HEiROoqqriGZOcnCxQAH/r1k0cOnQYCQkJYDKZuHv3D9Dpdti4cROam5sFZm1ZWPA6QNFoNMyfPx/q6hr47bffUFVVBScnJ6xevRoZGRm/OlLUzobR0dGws7Mj/8/Rb8XHHwNBEEhKSoSjoyPOnDkDFosFgH0jotK2AEBSUhJcXV1JGmBiYiIWL16MPXv24NWrVzh37hzpSsgBJ2uLeo5uIzIyEomJCfD19UFqairodDts2bIVzc1NArp2vB0pzhwtXLgAGhoaOHXqFAoLi2Bv7wBPT09kZmaioKCgQ40UnW5L/l9PTw+HDh1CfPwxNDc3ITExCY6OTrh48RI5R0+fPhVIz0hISCAt6Ldv347ExATMmzcPISEhePHiBa5cuUIWihxwsraocPPmTURHRyMxMQHr16/H2bNnQafbYds2P7S0NFMulMLCgmFjY8PzmLi4ODw9PdG7d288efIE2dnZMDIygpmZGR4+fEh5bA4YDAZlcdgRhOlIjRo1CufPn8ejR49gaWkJW1tb3L9/H2fPnv2lkxMOsbGxIi+Edu3axVdASUpKYvPmzXjw4AHOnDmDP//8E/r6+liwYAGePXuGvLy8Lmmk3r59KxK1CWB3pJhMJnR1dXHx4kU8evQI06dPx7Jly2BkZIQ9e/agubmZZ8yZM2dENuRobGxEc3Oz0PRHaWlp+Pn5oXfv3rh79y4uX74MAwMDLF68GG/evOlwLIPBoMwL7AhULqLtYWhoiNTUVDx8+BA6OjqwtLTE3bt3ce/ePbS2tgp9rMjISDJXUFjs37+fryMlKytLhtNytM0GBgZYvnw5Pn36JFRHigrPnj3D4sX8sQ8dISgoCP7+/pg2bRquXbuGBw8eYMCAAZg3bx4mT56MmJgY8rrGwcWLF0XWl7W0tJBGU8JAUVERe/bsQa9evXDp0iUcPnwYBgYGoNPp+P79e4djAwMDRaY/vn79Gurq6h1uKs2fPx83b94kbeBnz56N27dv48OHD3xz1BHCwsJEdtyk6khxNqQePXqE0NBQ7Nq1C/r6+nByckJhYWGXDTkePnzId3/oDBxDjoULF+LOnTv4888/IS4ujmnTpsHExISkPXLj2rVrIrELAI5MoFpkpsXfCf90sv5GeP78OVavXo2Wlhb4+bFpgFOnTsXKlStx69Ytyo5UVVUVxMXFISXFdjBTVlYmOxjbtvmhtPQn6HQ7DBs2FK6uruTN+8WLlwJDi7t3V4KkpCTs7e1x+346nHz98Nu583jyJAZaWtr4+u0rWG0sVFSU4+7dPzBhwgR8+5YDAGhtbcG3bzlYbsPWi7x8+QJDhw6Bq6srZMWAtNMnEbVvL+KlpFBRUcm3k8V+j1bU1tbx0dZGjhwJY2NjDBkyBAMHDoS3tzdaWlrIxc7169c71JFxCil1dXX4+/uTc9Tc3AI6nY4xY8bAycmJvKA8f57dYWixjIwMSQMsKipGdHQU7t+/jwEDBuDbtxw+IxJBocVZWVkYO3YsgoKCftEAE365AcqjoqKcUtsiKLRYV1cX3759w5AhQ9C3b99focAE5s6d+8t45KpAHRnwF/1RW1ubvDFt27aNDE4eP348HBwcyGLi6dMseHjwd6Q4lCx5eXmSBpiXl4+oqCg8evQQAwcORF5ePh+lMS8vn5Iq9fz5c4wZMxbbt4eQNEB7e3soKCigsrISoaE7KeeIKrTYwMAAxcXFGDx4MHr2VIeXlxfExMRgYWEBMzMzgc6G7NBikN+9X79+JBXIx8cHdXV1sLOzg76+Aezs7MjzLTPzdyQn89uzczpSKioqfHQZTnhme7oMwO5Itd+J7ww7duygdDYUBHNzc1RUVGDkyJGQk5Mj9Vuurq5YunSpwMVRfX09WltbRbaI76wj1bNnT1L0n52djaCgIKSnp0NHRwfFxcVCLybbhxYLA0EW8dx2x/v27cO0adMgIyMDT09PLFy4sEuhxXv37hXZJpnTkerTpw/pBpiZmQlfX18UFxfDwMAADAaDr3DrikV8cHAwgoODhXotjUaDra0tpKWlcevWLZSVlWHKlCmQk5PDxo0bO6RVddUi/vLlyx269vXt2xeJiYkAgHv37mHt2rV4+vQpJkyYgOrqaoFugO3RVYv49qHFNBoNzs7OcHZ2Rm1tLbZv3w4jIyMoKSlh69atmDZtGiIiIjrsSFEhPDxcpHw14C+L+FGjRuH06dMAePVbs2bNgo+PD99mm7ChxdwQhf4oLi4OLy8v9O/fH6dPn8bTp09x6NChXxKEbR0aU3QUWtwROutIcTakAJDxFG/evIGhoSEaGxuFLrS6qpFqb8jB2ZDavHkzfvz4ASaTib1790JTUxP+/v7Q1dXF/v37KdkjHSEjI0PojubfFf8UWX8jPHr0CK6urhAXF4eJiQlaWlpw+vRpODg4ID8/H+np6SQNkIPY2FiBXPL8/HwcP34cNBoNt2/fho+PL5qbmzBmzBiB+p+DBw+isLAA4RGHMEhXFzK9+kBWQREODg74/PkzjI2NEB4WjqamRowYMRI/fpSAIAioqKhg+fLlWLpsKfy2+eHVy5e4c/sOKioqEMxkop+iPBQlJbD2l66luLgYK1euxNatW9CzJ5sGyOH9dtSR4hRSMjLSmDNnDpqampCUdJwUzWdmPuGzqY2NjRV4w8nPz8fp0+wb2I0bN7B582a0trZi/PjxAvU/UVFRsLfntdHX1NQAk8kEnW4HT09PhIWxaYBjx46Bs7Mz3r59y5e1xUFiYhK2bfMFwKYBuru7wd3dDYWFhVi1yha+vtugra0FFxcXshvBnbXVHhyLeFlZWVhYWKC+vh7x8fGwtbVFYWEhXr9+zVfIcDsb8s9RAUnhSEm5/KtwA4yMDAXmSFFZxPfu3Qvbt4eATreDs7Mzdu3aiZqa2l9Ogw54+/atwF3yxMREbN7MDjCVl5cni9/v37/DwcEBfn5+6Nu3D1xdXcnCkztrqz1SU1MRFsYOLba2XoyamlrExcWSc/Tp02e+zDRO1hYVCguLcO7cORAE8Uu/5QEajYapU6dCTU2aco4CAgKwefNmnsc6osts2bIFT58+5cva6gxdtYiPi4sjQ4s3bNhA0mXCw8PRs2dP+Pv789Fldu3a9R+3iNfR0cGFCxegr68PV1dX2NjYoKGhQSi6TEhICHbu5C/IO0JnFvGSkpLw8fGBj48PiouLwWQysWPHDnz79g35+fkimXKkpaX9WyziufVbZ86cIc08rK2t4enpiefPn4sszicIgicmRFhERkaSocUc/VZAQACYTCb69u2LoKAgvnNz3759IlvEl5SUQEZGRuiO1JQpUzBlyhTo6+tj0aJFMDMzA4vFwooVK+Dq6trhwjcoKEjkbm1ycnKHHSl5eXmEhoYCAL58+QIGg4EtW7bg69evaGhoEOlYFy5c+LdYxHPrt6KiojBnzhxSv0Wn0/H27dtOO1JU6IpFfFhYGE9oMbd+a/jw4QgKCuI7pyMiIkQ27RG1I8WJp5g4cSKMjY0xffp0Mp5iyZIlHc5NQEBAlyziO+pI9ezZk9yQ58RTFBQUIDc3V+Ru7Y0bN0SOQvi74Z8i62+CxsZGiIuL8yw0JCQkYGtri5KSHzA3N0dmZhaOHz8BVVVVODk5YfjwYXj58hWlvuDbt2/o0eOv0OKZM2di5syZaGlpgY2NDWi0bnB1dcOSJdaYMWMGOa68vAJRiUk4mZqGkP1hUFNTxfXr16ChoYnm5iacPXsOAwYMQFVVFVRUlPHx40dkZmZh+vTpaG1txZMnjzFs2HDY2q4Cq60NIb5bYTx4AGjt8hX+/PNPWFkthru7G968eYPIyEiUlZVh5MiReP36NaKjY/i+U/uOFMDWbzk7O6G2tgZz587Fn3/+ibi4Y1BX7wlXV1cMHDgQ2dnZlDk1379/5wkt5uhlmpqasGLFCnTr1g2rV6+GjY0Nz25Oe2dDDh49eoS+fftg7NixpH7r6tWr2LBhAz5//owlS5bwBSdzdGRUO20PHjzAwoULfi2KsnHgwAFUVlZCR2ccsrOzERnJ39mkCi2WlZWFh4cH2traIC8vj9TUVBw+fAS9emmTVDpBzoZ5efk8xebChQuwcOEC1NfXY9WqVejWrRs8PT1Bp9N5bpp5eXkdhhbr6elBT08PLBYLly5dgpfXGnz9+gU2Niv4QoE5HSkqI49nz57D0tISa9aswePHj7FjRyhqa2ugp6eHp0+fkmJhbrTvSAGAgoI81q1bh8OHD4NG64Zz584iLOwA+vXrBzc3N2hqavJlbXFQWFjIQ39csmQJlixZgpqaGtjZ2f3qks3Dli1+PHz4zjpS8+fPx/z589Ha2oojR45g5syZeP/+Pby9vfnmqCNwhxYLCyqLeEH6rdGjRyMwMBBaWlq4efNml4qErlrEc7sBhoWFkW6Aq1ev5qNyCRta3B5Hjx4VuiOloaGBqKgoBAUFoby8HAEBASgqKsKECRMQGBjYoTHFf8IinkajYfny5Vi+fDkaGxtJN8BPnz6JXCScPXtW5IUxxyKeuyPVp08f0g0wIyMDGzduxM+fPzFp0iT4+/tDSUmpS6HFDAZDZIv47OxsaGlpwdHREY6OjqQboKGhIZSUlODt7c1zf+SgsLBQ5Eytw4cPC92RGjhwIE6cOIHdu3fj7du3WL16NSoqKjB9+nT4+vp2qN/6VyziDx06RPkcjUbD6tWrsXr1alRWVpIdt2/fvgnd2eSAO7RYWFBZxLffkLK3t0dtbS25ISUtLY3z58+LrJHqqkV8z549+dwAw8LCSOYMFU2/KxbxBw4cELojxYmniIiIwN27d8nrgIWFBTZs2NDhOdLY2Ihu3bqRmvz/VfxTZP1NcO/ePUyZQm3t/fr1K2zcuIFcVH348AFHjx5FQUEBqqqqUFlZybdbGhUVTWnvKSEhAVlZOSQmJqC0tBQODg6Ij4+HhoYGxo6fAOXBQ1BQ34gpJia4knYVM2fOws2bN1FaWopevXqjWzdxDBw4APfvp+PPP+9BX38icnJyICMjjZCQYBQWFsHW1hay4t3w4NYNzJqox1dgAWxtC4faN3LkSOzfv/+XYUIKrl69itWr3TF9+gwsX76MXHSwO1L8OjIAyM5+gfj4Y+QcvXr1GhEREfjx4weqqqpQU1PDxytma6T4LeKlpKQgJyeHxMRElJSUICoqCkePHoWGhgb09fUps7YA4PjxEzyGHDQaDWZmZpg/fz7pDujk5AQ5OTmsXLkShoaGSE6+gIkTqRcu165dI4uEceN0MG5c+C+nuwtISbkELy8vkgbI+d5xcXEwNxccWsw9R8+ePcPevXtRVlaGqqoq1NfX89282cHOdnzvJSsrC3l5BSQmJqCgoACRkZE4dOgwevXqBSMjQ/TqRU3Jah9aTKPRsGjRIixYsAC2trZoaKiHvb0DFBUVQKfTMWHCBMqsLQ7S0lJJyqm+vj709fXBYrFw+vRpfP36DWvXroO5uRksLCzI783O2uo4tJjz2ocPHyIkZDsqKytQXV2NpiZ+/Z6g0GIFBQVyjj58aAaDEY6NGzdi2LBhMDU1xYABAyg/Q3uIi4tjzZo18PT0hJ6eHoqLi2FkZCQUXYbzfalCizvCzp07O+xIUdFlKisrUV5ezreR0Bm6ahG/e/dfFExJSUl4e3vD29ubpMvs2bMHWlpaYDAY0NHRwalTp2BkZCTScf4Vi/j79++T83D27FlYW1ujsbERixYtwtq1a/kWOAEBAZ2GFreHKBbx0tLSCAgIgJ+fH8aPH4+XL1/CwMAAvXv3BpPJ7LT4jIyMpNR6dITOOlLGxsZITU0Fi8XCiRMnYGlpiaamJpSVlYls7NIVi/j2ocXt3QA52pcBAwYgODgYAwcO7FJocXNzs0gaKQ44FvGSkpJgsViIjY0l3QBtbW3h4ODAt9nCYDBEMuQA2NRRdXV1ocJmlZSUSAq7jo4O/vjjDxw7dgxDhw5FcHCwQA0xB4JCizsb01E8APeG1OHDh0nGT1lZmcjF5r/DIp7bDZB7Q2rMmDFkPMXVq1dF3vBpbW1FTU2NyF1oTmixrKwsmpubceDAAdJQyNPTk5KinJqaSkbt/C/jnyLrb4IPHz5Q7mp/+fIFSko9eC6kQ4cOxd69e7Fly1YMHTqEpAFOmTIVK1eugISEBIqLiyl3i+7evUvS1pSVldGjhzLiE+KR8fI1toZsR48ePXDkyBEMHjwYPXoo4dSpU9DU1ISCggLGjh2N9PR03Lx5C6NGjURpaSmampoxdOhQWFhYYu68eQgODETB29cIupiM/LxccuebGzU1NRATE+NbrNJoNOTk5JDuT8ePH4eTkxOkpaWxfPlygR2pnJwcno4UAIwePQphYWHw8fFBnz59SRrgzJkzsWTJEoiLiwvsSHFbxKurq5M34ZcvX2L9+g3o2VMN+/bt49FvtXc25AbbIt6AR78VFRWFqKho5OXlUmrt2B0pMT7+O41GQ2FhAdatW4c5c+YiISGe1G+tWrUSz549p3Q2zMvL4wst1tXVha6uLrZt2wY1NTWSBjh//jzSDZDK2RDghBazL/Ta2tqkG2BWVha2bGFTQCMiDsHR0YH8Du2ztrhx6dIlTJw4kaQBcvRbERGHkJ+fT7l4oupIceaooqICa9Z4Yc6cOYiNjYW9vQO6d1eEvb29wKwtKkMOQ0NDGBoaIiAgAHJycvD09ODRb9FoNHz//p2STsYdWjx0qBYZdHrt2jXY2dnh3r17fGM6QmJiIqZPn04ucLj1WyNGjKCkywgbWtwet27dErojxaHL2NnZQVxcHDNmzCDpMtbW1h123DIyMjpdlLUHxyJ+xIgRlM9T0WWKioqQk5Mj8pxzhxYLC6qOFKe72djYiH379mHq1KmQlZXFmjVrSAOi169fk5oqYREcHNwli/hJkyaRi8DHjx//yrr7IVC/xTHk6IpF/J9//tnp6zj6LVtbWzg5OaGyshKTJk2CoqIiNm7ciNmzZ3c4XlBocWfoyCK+f//+ZDHw559/wsvLC2VlZSgoKBC5yxYWFkZpNNURfv78ydORotFoZIZjdXU12U3q0aMHtm7dSsacPHv2TKTQYoBdbHJ0ysIiJSUFEydOREwMm3Vy48YNODs7o7q6GrNmzcLWrVv57l/Chha3R3JyslAdKXFxcaxduxZr166Fu7s7vnz5AiMjI6ipqcHPz69TG/euWsTn5uYKpBRzb0ilpKSQboDFxcUid9m6YhHfPrRYUlISW7ZswZYtW/Djxw8wGAzs2bMHmpqa5IYUwO5siqoP/TtCjCCI/9+fgcSECaOJrKyE/98f478O5eXlcHFxQd++feHk5Izhw4eRz23ZsgUrV67C6NH8FqR0uh0SExMAsN2ETp06hbt376KhoQHdu3fns9kFACcnJ7S1tYFG64bevXtBUl4BVo5OqG9uxvr16zF16lR8//4d799/QM+ePVFTU4Pp002QlZWFkpIfGDhwAOrrG2C1eDGuXE7B9++5MDExwcKFC3H32lVoyclipc1y1NTUwMXFBVpaWigtLcXIkSPh7OyCHj2UcODAAQwaNJiy40Kn2/F0EgD2zWbXrl14+vQp9PT04OLigkGDBpHP+/r6wtp6CWXBRKfTSaEzW7+VhIyMDLS0tEBeXgHR0fyLdw8PTzJrixssFgsODg44duwYrl+/josXL6KtrQ2zZ8+GmJgYysvLKV2WHB0dERERwXfDqa2thaOjEzQ0NH7RAMfCyckJCgoKCAsLQ79+/Sj1dlRzVFRUhD179uD58+cwNDSEm5sbz+J12zY/LFy4gLJg4j6P6uvrcezYMWRmZoHFaoOcnBxlgePp6QkfHx8+4w0WiwV7e3vEx8fj0qVLSEu7CgCkA2FBQSFphME7R04IDw/jK5jq6+tBp9Ohrq6OmppaTJyoB3t7e8jKyuLQoUPQ0tLCokWLhJqj3Nxc7N27F69evcLkyZPh7u7O8xsHBATA1NSU8kbMPUc1NTWIjY1FdnY2APZmAdUcrVmzBps2bfr1O0gBGEXOkZGRER49esQ3piNMmTIFqamplOL8q1ev4sCBA3x0mYCAAGhoaIi0s/39+3c4Ozvj5s2bIn0+AwMD8jtx6DKZmZnQ0NCAn58f5blnamqKvXv3iuR6lZSUhOfPn4u029zY2IgxY8agV69eaGxshKWlJdavX9/pLrehoSFPR0oYODk5YcGCBQI1jhwUFhaCyWTixYsXkJWVhYSEhEhzzmKxYGhoiMePHws9BgCmTZuG8+fP8xVMnA5wTEwMWltbsWTJEnh4eEBcXBzbt2+HtLQ0Nm7cKPRxiouLsWLFCpEXktzn0ffv38FgMPD+/Xv0798fTCaTUlu4cOFCngWiMDh//jx+//13yk0uQWhqasLw4cOhra0NgiCwatUqODs7d7ooNzIyIjtSwsLDwwMmJiadOhh++vQJDAYDX758Qc+ePdHc3IwbN24IfRyAd86FxYwZM3Dy5Em+7lxbWxuioqJw+vRp0Gg0ODo6YtWqVaDRaNi/fz8aGhpE0iGVlpZi8eLFIhe2BgYGePDgAWg0Gt68eQMmk4m8vDyBG1IA28xm8+bNImVqpaam4sKFCyKZSjQ0NGDo0KHo3bs3JCUlKeMpqGBsbIw7d+6I5GC4YcMGjBs3DqtWrerwdc+ePUNQUBCKioowevRoDB48GFu2bOlwzN8JYmJiTwmC4LtJ/dPJ+hvg1q1bOHToEGpqahATE4MfP35i6NAhcHFxQXFxCWWBlZ6ejgED/hLAS0hIkLkgLi4u0NDQAJ1uByWl7nB1dcWIESPQ2tqKlpZWJCYmoLq2FovsHCCrqoZMP3/0798PI0eOwq1bt6CqqgpJSUmMHTsWX79+QVraVfTu3RsqKsrQ0NBA9+7dMWb0aAwaOAD79u2HhpoaDgUF4vuH91i3bh1YLBaOHj2KFStWkGLi27dvY+vWLWhubkZJSQk8Pfm7Ld++fYOSkhLfDUtNTQ0SEhLYv/8AJCTEceTIEZSVlWHUqFFwcXH5xY/X4Xu/9rbVbP0W28nJxcUFyso9QKfToaGhARcXFwwcOLCTjlQy9PX1SRv3+fPno6GhEUlJiTh16hSGDRuGjIwMHv0Ld9ZWe8TFxWHFChtYWFiAxWIhLe0q1q9fDxaLhZKSH0hJucQ3RlBosaamJmRkZLB3717QaDTs3bsXVVVVGDduHJycnAR2pJ48ecJjyCErK0vqGpydnSEnJw863Q69emnDzc0dvXv3EuhsCHAs4vVIGuCiRYtQX1+PuLhjOH/+PEaMGI6srCyez8KxUKfSGcTFHcOyZctgZWUFFouFixcvwsuL3e368aMEly7xz5Gg0OI+ffpASUkJu3btQlsbCyEhIaitrYOBgT7s7Ozx/Xsu5c21fWixgoICqYN0cnKClJQU6HT6L/2WOzQ1NSicDZsAtACQQGJiIiZPnsx3nI5QX19PZm1RgZsuc+jQITI8Mz8/Hx8/fhTpWJzQYlHQ/m9NGLoMi8VCaWmpyLbCcXFxuHjxokhjdu3aBQ8PD6xduxbNzc3Yv38/qd/y8PCg3LHNz8/vkkZK2I6UlpYW2QWYOnUqWltboa+vj4kTJ4LBYHTaNTp79qxIi0Gg444UjUbDihUrsGLFCjQ0NGDPnj2YPHky5OTkkJeX16klfHsEBAR0ySKe+7rSt29fUr+Vnp5OGrBw67cA0UOLAeDIkSNkd1lYhIeHw9XVFVu2bCH1W8bGxlBSUsLmzZsxffp0vjE/fvzoskZKmI7U4MGDSa2XsbExWCwW9PX1MXPmTPj4+HSo3wLY1+yxY8eK9Nk4HSkq+mO3bt3g4eEBDw8PVFZWIjg4GEZGRlBRUUFOTg6ePn0q0rECAwPh6uoq0pj2HamRI0fi3LlzANjmMhz91rx58+Dt7U0WLaKGFgPsLiXnHBUWMTExcHR0BIPBQGlpKZhMJvbv3w8NDQ0EBARQuhB31SL+wYMH2Lt3b6ev09XVJe+nbm5unW4S/a/gnyLrb4AfP35AQ0MDGhoaJBXojz/+gIeHB0pLyxAfH4+VK1fyCBBPnjxJmSHS2tqK5uZmMvjR1tYWMTExqKiohJgYoKs7DhWNTfhWXYdGGg39evaEiooyMjIyoKysDBqNhiFDhqCmpga3bt2CpqYmNDU14enphXPnziIj4wGGDx+O3Lxc3L93DxbTTbDCwgw/TabAz88Publst7eSkhLSIp5Go2H27NmYPXs2Pn78iM2bveHi4gxpaWksW7aMpDnExMTA3t6Oco64CymOfuvmzZtwcXFBaWkZTp48iaVLl/IsiE6dOkVpE8tisdDU1Ew6Ob18+RIHD0agsrICkpKSAh3pqCziZWSkYWNjg8zMTDCZgYiOjkJMTAw0NDTh5uaKlJQUvqwtDripfTQaDebmZjA3N8OnT5+wYcOGX/otNg2QQ0Von7XFjfz8AowfPx4AMG7cOLBYLKSmpsLBwQFlZeU4d+48rKwW8RQfHYUWNze3kCHVWVlZ2L17F6qrayAvLydwQZOWlsZnNiErKwtHRwdkZ2fD13cbSQPs3bsX3N3dceHCRb6sLQ6ysv6i9tFoNNLo4NOnT1i3bj0cHByhqKgAe3t78sYUGRkJW1tbyvfjDi02NDT4pXFLBp1ui7Kycly5cgWmpqY8c9RRaHFLSwtpX5yRkYGQkGDU1tZBSUkJY8e2d2GrAaCM+Ph4pKamUn4+QQgNDRUqS0VcXBzr1q3DunXr8OLFC5iZmcHY2FhougzApi63Dy0W5vMJCi1uT5dZuXIl6urqoK2tLXKOFMcivisaqfT0dABsuszWrVuxdetWlJSUkPotTU1NMJlMcsEZEBAgsiFHVy3iGxsb8fjxY7BYLJw9e5a0hl+4cCHWr19PWeh1FlpMBWEt4mVkZBAQEICAgAA8ffoUpqammDx5Mnr37o3AwEChCuOXL1+SRaSwCAkJEZhpNGnSJKSlpYHFYuH48ePk5tTgwYO7HFosqkU8RyMF8Ou3/P394evri4EDByIoKAgDBw4EwNZIiRrmmp2dLbJ+C2B3kR49egQWi4Xo6GhSv0Wn02Fvb0/ZcYuIiMDJkydFOk54eLhQi3AlJSXyuvDw4UNYWFhg2rRpGDZsGIKCgoSiCnfVIl6QsYupqSlMTU15NqQkJCSgq6vbJY1UXV2dyBopbot4VVVV0nDk5cuXCAwMRGFhIcaOHQsmk0meB8HBwXBychLpOF21iFdSUhJ5Lv6u+KfI+i/Ht2/fKENCTUxMcPbsWYSFheHWrVtwdXWFhIQErK2tMW3aNDQ0NEBdXZ1vXHx8Anr06EEWEuLi4qQxwEJrazz+8g33NntDQkISs2bNxp07t6GkpASCIKClpYUhQ4YiIyMD6uo9IS8vh759+2DgwIHo0UMJVlaLUFZWhgULFiDl7Fm8f/wYPWbPRNWUyaRl96RJk/Dt2zeEhYVR/mHHx8cjMJAJHR0d/Pz5E1FR0Th2LB7q6j2Rm5tLuXhn75Lz2lbTaDTMnTsXV65cwZ49e3Djxg04OTlBRkYGNjYrYGhoQJm1BfBbxI8ZM4Z0A7SyssKrV6/g4OCAWbNmw9p6McTFxQXqyABOaLEFaeMOsG+SYWHhyM5+DgsLC9TU1EBBQYEcI6gj9dccBUJXVxdFRUWIiopGZGQUtLQ08e3bN8oFxePHj/ks4mk0GiwsLHDz5k2Ehobixo0bsLdnZ1zR6baYMGGCwI5Ue4v4CRMmYMKECWCxWFi0aBEaGhrg6OgEU9P5WLBgAWg0mkAdGXuO2KHFHBt3gH3z3LlzJ16+fInFixejvr6eZ6ygjhTA1icxmQzo6ekhNzcX0dHROHjwIPr27YuvX79SZm1RBanSaDRYW1vj3r17CAwMJOdISak77OzsMXbsGMqsLYBjEf/Xb2FsbAxjY2O0trbCysoKVVWVJHVs/vz5oNFqUFsrCYIghM7j4eDWrVt48OCBSGM4LlSzZs0i6TK5ubkYNWoUgoKCKH/39PT0TkOL24OjkRLGIt7S0hKWlpZobmZrOfPz82FiYiI0XWb37t3/Vot4dXV1REZGAmB3LJlMJoqKiqCrq4vs7GyRc2W6YhHPHVpMo9GwbNkyLFu2DI2NjRg1ahSSk5PJ2AJOFIWoocUcdMUiPioqCtHR0bC0tMTDhw+xefNm/Pz5E0ZGRggICECPHj34xrTvSAkLYSziaTQaydqor6/H8OHDoa6ujtmzZ2Pz5s1CZchRhRZ3ho5Ci/v3748TJ04AYOuePT09UVlZialTp+LJkyfkOSYsAgMDRXZ/5A4tptFocHd3h7u7O6qrqxEcHAxDQ0OoqKjA19eXdMvtqiHHhQsXRKaBnjp1CocOHcLSpUtx7do1ODk5oaamBrNnz8aWLVso7xvChBZTQZC7LTe4N6TKy8sxZswYaGhowNzcHP7+/pT3kPY4dOhQlyzixcXFKTtSY8aMITdOLl26RHaVzc3NkZGRIXAjSxA4xi2i4MOHDxgyZIhIY/7O+KfI+i/HnTt3sHz5cr7HW1tb0dDQAE1NTVIQXF5ejujoGBw4cACSkpJ49+49j34LAB48yICOjg7s7R1QUVHOpg8QBL6U/ICEdm9s9fNHa2srNm7ciPr6erS0tEJRURF6enq4fv06VFRUoK2tBT9/f/x+53ecPXsW+fmFIAj2H5/p/HkwHjUCo1WUEF5fh/Hjx2Pr1q34+vULBgwYCAMDA4HOhgC7I8W5EaipqcHfn91pOnXqFF69egU63Q6jRo2Ei4sLaSpx8uRJ+Pvz33A4ocV9+vQhaYAlJSWIiYnBrl07ISkpiS9fvpA7ihwICi2uq6uDiooKYmNjSRqgk5MTZGVlIS0tLTBriyq0WEdHBxs2rMe+ffswZMhQkgY4e/ZsLF68mDJri4OCgr8CKzU1NREYyAQAnDhxAs+ePQedToeOzrhf+i02FSQp6TiZtcUNDrVv4MCBpAVvYWEhoqKiEBwcDElJSeTm5vIVEZysrfaor6+HqqoqYmNjSf2Wg4MDFBQUICMjAzMzU8rvlJXFH1qsp6cHDQ1N7Nq1E9ra2vDyWgMxMcDU1AyWlhaIjIzky9riIC/vr5yVPn36YPv27b/mIQkPHz4EnW7Ho98C+J0Nueeouroaw4cPJ3foc3JyEBMTAwYjABISkigqKoamJu9ChJO11R5sOpYa4uJiUVNTg6NHj+LcufOQk+uBqqreQnWkuPH9+3d0795d5IUGt0U8N10mNTUVdDoddXV1fHSZ0NBQkUKLga5ZxLe2tkJLSwsZGRl8dBl/f3+yI9seN27c6JJFvDD0R11dXZKGGBISgvz8fBgZGWHhwoWUboDt0VWL+I5Ci9XV1ZGRkYHCwkIwGAzs2LEDvXr1Qs+ePbscWiwq/ZE7tNjQ0JB0Azx16hQWLFiA1tZWLFu2DO7u7uR7h4SEiGztffbsWYG/uyCIi4tDW1sbDx48IPVb/v7+6N+/P4KCgsjsxfboLLSYCsJ2pKZNm4Zp06aBxWLB398f379/x+TJk7Fq1So4OTkJ9XfMKfRFQUREBBkizA1FRUWSIcOx7t+0aROGDh0KTU1NkR3kOKHFotLWuDtSnLiU1tZWREVFYdasWRAXF4eTkxNWrFhBzlF71z5h0BWLeEVFRfTq1QuPHj3ioTdzNqQEGXWcO3euSxbxLi4unb5uwYIFWLBgAZqbm7FlyxZ8+fIFM2bMgIeHR6c6PQ66YhHPznkULQrh74x/iqz/YrBYLDQ0NEBOTo7vubNnz/ItXJSVleHjsxUODh+xYcMGxMXF4tu3HIwdO4YUKEtISJAOfCtWrERZTS2sV3uhur4eM2ay8z4qKyvR3NwMcfFuWLpsKc6fO4+6unqIi4tDSUkJs2bNAk2MhmHDhmHIkCFY7bEal1NS8PxBBsRKijCiR3ecOXMWjo4OGDNmDGbNmoXm5macOHECzs7O+PbtG+bN43fAoepIcZCeno74+Hj07NkTN2/ehLe3N1paWmBiMh11dXV8C1yAOrSYk0nh4OCA1atXIyIiAhUVFRg1ajRcXNgCZUEdqdjYWNIBSkZGmscNcNWqlSgrK0NGxgO4ubmSgbC5ubl8zoYccAqpceN0YG5uhoaGRiQkJMDJyQk5OTmUNzdO1hYVHj16hISEeKirqyM1NRXr168DQRCYM2cOamtrKG8EVKHFWlpaCAoKgqOjExwdHX7pt6qhqzuOpzim2lk8duwYTE3NyOc5F+OCggLY2tJRUlKCrKyncHNzI10E8/Ly+ZwNueeITreDnt4ELFq0CLW1tTh27Bjs7R2Qm/udcreZqiPFQWZmJuLijkFbWwvJyRfIws3MzAzV1dRZW2yLeN7FXb9+/bBjxw7yph8SEoK6ulro6xvAzs4OBMECQRCUegfu0GIFBQWScvbt2zcYGbnh8+fPePLkCYKCgoSilnEWRaIgPT1dYGixmZkZzMzMSLrM9OnTISEh8Yt6W9ql0OLLly+LNIbbIp6bLvPixQuSLqOjo8NDlxE1tJiDrljEP378GHfv3sWgQYOwb98+TJs2DTIyMvD09BRoSd5ZaDEVOrKI3717N7mY0tLSIgudzMxMzJ07FwMHDkROTg6YTKZQHa2uWsRTnaM0Gg0rV67EypUrUV9fT+ZvycvLY8OGDQLdbTtCZGQkuREgLLgt4tvrtyZPnox+/fph8uTJ8Pf3J7vHxcXFIoUWc/D8+XOROlI0Gg1v377FrVu3MHjwYGzfvp3Ub23ZsgXTpk2jHNdVi/jGxkZKdgs3Bg8eTBZit27dwtKlSzFo0CDU1dXBx8eHci3SHlShxZ3h1atXlB0pcXFxeHp6kp2/oKAgHD58GKqqqvD19e1SaHF4eDiOHz8u0hhui3huevOVK1dga2uLuro6zJ8/H5s3byaLy65qpES1iJeUlERBQQHS0tIwYMAAMJlM7N27F5qamvD39xdYjHcWWkwF9qZsjchMi78z/imy/ouRlZWF9PQMvH79GosXW2PWrJnkc7dv36a8oFdVVUFcXByjRo3C3r17YWdnB0NDI/j6bkNOzjfo6OigpaUFxT9KIaHWEyvXsRd43t7eyMrMwu1btyEpKYFVq1bht99O4/atW+jduzd8fHzw7VsOdu0KRU1NLZ49e46ysjJYWlqiu5w8zI0N0Zb3HR4eHoiOjsbr1695aB2SkpJwcHDA0KFDcfny5V9FUwJ69lSDi4sLBg8e3GFHiltEO3fuXMydOxdNTU3YtGkTfvz4AXd3dyxfvhxTpkwhx3FnbXGDE1rMTXG7ceMGNm/ejO/fc6GrO44yyyc7+wXlIqSpqREjRozAwYMH8eLFC4SFhaOysgJjx45FYWEhZdYWABQWFvEYcsjISMPd3Q3jxung3LlzuH79OqKioqClpQVXV1f069cPJ06cgK8vdUeK25CDY5vd0NCATZs2o6SkBB4eHrC1teXR3Vy9epUykLe2thZiYmzXKyMjI7BYLFy+fBlr165DQUE+xo8fTxl4Kyi0mMUiMGLEcERERCAz8y/91oQJ45Gfny+wI8W+if5VBHJoUZmZWThx4gQuXryEiIhD6Nu3D1xdXaGtrd1JR+ovi3hr68Wwtl6M2tpaeHt7o7i4BGvWrCELXw5SU1MRHh7G935si3gCJiYmMDExQWtr669dPg8UFRUJnCNBocXS0tIwNh6D8+d/x9WrV+Hg4ICamhrSDVBGRoZyjgTFO3SE0NDQTm/k3HSZ0tJSLFmyBLm5uTA3N0dAQIBQixuOIYeoFvE3b94kNVLcGDt2LNnVuXjxImxsbNDQ0AALCwu8fftWZEMOTmixKOB0pDgW8T4+PvDx8UFxcTGYTCZ27doFLS0tMJlMnmugKKHFHPj5+WHYsGGUz3GyttpDW1sb48aNw82bN3HmzBksWrQILS0tWLx4Mby8vAQWoa9evRLZIj4kJITsEguCrKwsmEwmSUe1sbHBt2/fsGTJEqH1W01NTV2yiBcUWjxo0CCMGDECt2/fRmJiIszMzNDW1oYVK1YgOztb5J36Z8+eUVLPO0NRURFZMHE0wF++fAGDwcDWrVsxaNAgBAcH82yIHD58WGRDjrCwMJE7UuPGjcPYsWNx584dREVFYc6cOaDRaLC3tydzHakgrCEHN5hMZqcW8UpKSmQX/d27d3BwcMDXr19hb2+P4OBgoXRP/26LeHNzc5ibm6O1tRURERGkfsvV1RUPHjwQ2ZDjzZs3/7JFPHc8RVBQEOWGFCBaaDEH6enpJJX0H7DxT5H1X4zMzEycPHkC1dXViI6OwYkTJ6CqqoJly5ZDQkICUlJSfGMOHjyIqqqqXyGUvSEnJ4dZs2Zi1qyZoNPpGDZsOOxWeyC3sgpTTUwAsPnJtbU1aG5uwrJly3H27BmkpqaiubkZYmI0WC1m005aW1swYsQorFnjhcePHyMuLhbJiQmoMTTAs6dZWLt2Lfr06YP58+cLTAE/efIkGAwGuaP29u1bREVF4efPnyguLqbc9Tl//jxlS1tKSgp1dXW4cOEiamtrEBUVhbi4Y1BX74mVK1eCRqNRdqSOHj0KS8sF5P9pNBpJT7C1tUX//v1JGqCNjQ0mTZpEmbXFAduQg03tGzt2LKnfunr1KlJSLqO8vBxz5syBlZUVucB5+PCRwNDiEydOYNu2vyzinz/PxoEDB1BRUYGSkhIoKPDvIiUnX6Bc9MrIyKCxsQEXLlxAVVUVIiMjceTIEWhra8PW1hZiYtQaqWPHjvEIl2k0GklPsLW1haamJuztHaCgIA9bW1tMnDhRiI4Uu5DS05sAPb0JZLj0+fPJKC0t49FvAbxZW+2RlMQupDjPP3nyBKGhoaipqUFJSQlUVPh37lNSUihDi+Xl5dHc3Izk5PMoLy9HVFTUL4v8vr8+M3VHih1a/Jchh7i4OJYuXYqlS5di1apVUFZWhoODA7p3V4K9vR10dHRQWFjIl7XFQWRkJNavZwuXud0AIyMj0a9fPwwbNoyPLtNRR0oQWCwWysrKROLVq6qqoq2tDe/evUN+fj4YDAbpBhgYGChw0dJZaDEVcnNzoaio2GlHauHChVi4cCGam5sRFhaGK1euID8/H7W1tULTZXbs2METWiwMBIUWa2hokFb9z549Q0BAAIqLizF+/Hj4+Ph0KbT4/v37GD16NAwMDNCrVy8wmUyMGjWKMmuLA45rH41Gw/Lly7F8+XI0NjZi9+7d6N27N0aOHIl169bx/H0L6kh1BBaLheLiYowaxe9uKwh9+vSBhIQE3rx5g/fv35P6LWNjYwQEBAgsxvft20cZxdAROupIMRgMeHl5kUWDvb096urqEBoairNnz+L79+9QVFTEjBkzhDpWUFAQpdFURxDUkRo4cCCp3/r999+xevVqVFRUwMTEBJs3b/6XDTmEBYf+SKPRSCp5ZWUl2XFjM2d8eBbdL1++7JIhR0FBAaW7rSAMHz4ccnJyyM7ORnZ2Nuzt7VFTU4N58+aR8RRUOHjwIExNqSnrgiAM/VFcXBzr16/H+vXryXiK48ePIycnB4MGDRK629YV+uPVq1cpMwF1dHR4NqQ4+i0LCwusXbu2S6HFN27cEPk8/9uDIIj/M//Gjx9FEETWP/+E+NfQkE5ERTnzPf7+/UnCzEyTsLDQJrZvX0T8/Hmd53lb25FEbu5FYtu2ucT06UqEo6MOkZt7ifj8+QzhuW4y8aXyD+LFz1uEhZs+Yec7n5i6fDgxeekQIuJCADHbbixh7jqRMLQaQMyijyFO3T1ATF46lFiw2ohYsXkWsWC1EXHtRQLx4uct4rc7ewm/QAuiufkhceyYB7FoUV/C1XUC8fvvewh394lEcXEa32dvaXlE0OnU58CpUxuJDRumES4u4wk7u9FEUtI6oqXlEUEQWYSDw1iivj6db0x19R+Eo6MO3+OvXycSpqYahLm5FrF791KisvIO3xy1tT3hG/ft23lizRpj8v/FxWkEk2lO2NqOIubOVSNSUwMpP7utLfV3evAggggIMCPq69OJyEgnws5uNLF6tT7x4EEEsXq1PlFYeIVvTFvbE4FzdOaMN+HpaUg4OuoQDg5jibNnt5Dfw8FBh6iru8c3pqbmLuUcPX0aQ5iaahBmZprEgQMriZqau3zfiWqOcnMvEp6ehuT/8/NTiG3b5hK2tiOJ+fPVibS0IAFzNJLy8SdPIolt2+YSdXX3iIMH7Qhb25GEh4cBkZkZRXh4GBD5+SmUcyRozpOTfQl394mEg4MO4eCgQ1y86MczR+2/J0FkEXV19wgHB/45evjwEDF/vgZhaqpBHDniyHcOCpqj/PwUwsPDgPz/16/nia1bZxG2tqMIU1ONDuZoFEEQr4j2uHfvHrFs2TKirKyMWLduHaGvr0+YmpoSDx48IObNm0d8/PiRb0xHOHbsGLFp0yaRxtTV1RHGxsZ8j6ekpBAzZswgDAwMiODgYKKhoYHneX19faKlpUWkY9HpdOL69esijUlPTyeWLFlClJSUEO7u7oS+vj6xYMEC4unTpwLHtLW1Efr6+iIdhyAIYurUqURZWZnQrz9z5gzRu3dvok+fPsSePXuI5uZmocbl5+cTM2bMIP//5MkTwsLCgpg4cSIxZMgQ4uTJk5TjBH2nJ0+eEFZWVkReXh7h6OhI6OvrE4sXLyZev35NmJubE69e8Z97HeHUqVOEp6enSGMaGhoIIyMjnsfa2tqIhIQEYvLkyYSRkRERERHBd84YGBiIfB7Z2toSSUlJlM9NnDiR8vGnT58SCxcuJHJycghbW1tCX1+fWL58OfHp06cOj9WV88jExIQoKSkR6rVtbW1EdHQ0eR4dPXqUaGtrE2psSUkJYWJiIvLn6+w7vX//nli2bBmhr69P0Ol04vv378SiRYuIzMxMkY5z6dIlwtnZWaQxLS0thIGBAd9jYWFhhJGRETFlyhTi+PHjfHNkaGjId43qDF5eXsSpU6dEGvPq1SvCzMyMePXqFWFlZUXo6+sTzs7ORGFhYYfj2n8nYTBz5kwiLy9PqNc2NTURu3btIvr06UP06dOHOHfunNDHqa+vJwICAkT+fH8XAMgiKOoa0XqO/+D/DO7du4cpU6byPT506FAoK6vg4sWL0NfXx7Ztfr/CXRPw/v17KCn1QO/evRESEoJevXrB1dUVO3fthMPadWjpoYKf1TX4+OkjKioq8PHjR5iamkJBQQG/37mN2tpaVFdXY9269b/yspIwfPgwBAYGYtWqVfjxowQx0dFIjAjHteOJ8PzlaGhvb4/k5GSEhIQgPT0Db968xZ49e/Dp0yeez37u3DnKHWCAzf8OCQlBdHQ0oqKi0NzcRJpV1NTUCOxIUWlyRo4cCRUVVVy8eBGjR4/G5s2b4eDggFOnTuHz589QUupB2Ulg25//Re1TV1cHg8FAYmICFBQUcPPmLdDpdOzbt+9XvhWbbiTIbe3EiZNwc3OFjIw03NzcEB8fDz8/f1y7dg2vX7/BwYMHkZOTwzOGk7VFhRs3bmDXrl2IjY3FoUOHUVpaCgcHB7i5uaG2tkZg1hYVTURXVxcqKqq4dOkS+vXrh3Xr1sHR0RHJycm/jBSonQ2jongt4rW1tRESEoLExETIyMjg2rVroNPpOHjw4C83QU7WFnXXLjExEe7u7pCVlYWXlycSExOxZctWXLx4Ea9evUJkZCQKCgp4xrCztqh3PdPSrmLv3r2Ii4tFeHgYcnNzYW/vAA8PT9TW1grsSFFZxBsYGEBVVQWXLl2CqqoqPD094eTkhMuXLyM/P1+gs2F0dDSPRXz//v0QGhqKxMQESElJIS0tDXS6HaKiotDQ0AiAO2uLk5f1F0JDQxEUFARlZWUcOHAAjx49wp49e7B//35kZGQgNDQU+fn5lPNBhfj4+E6pOe0hyCLewsICt2/fxv379yErK4sZM2bAxMQEZ86cQU5OjlAdqfZ49+5dlyziAwMD0bNnTxw5cgSPHj0Cg8FAcHAw9PX14ebmhuLiYp4xJ0+eFHg9EoSONFKCsGTJEmhra+Pdu3dobm7G1KlTMWPGDKSkpHQ4LiAggIy5ANhGMCkpKXj48CGZNWhsPAmhoXtRUVGH2pomZGQ8Erg7HRISgsDAQPTq1QuxsbF49OgRNm3ahC1btuDPP/9EbGwsysvLhf5e0dHRIu9q79u3j8+Qg+MGeO/ePdy6dQs/fvzA5MmTMXv2bNy4cQPFxcVdMuR49uzZrzkyxpEjR8BisQB07GwYFBSEgIAA9O3bF4mJiXj06BHc3NywZs0aGBgYYMuWLaiuruYZc/78+f+4RTyNRoOLiwt69eqFZ8+e4dOnTzAyMsK8efM67VAxmcwuWcR3Rn8cOnQoTp8+jUePHmH58uVwdnbG7du3cfnyZTLbUBgcPHhQoC2/IFBZxIuLi2Pt2rXIyMjAxYsXkZWVBUNDQ5ibm+Px48ddNuR4/Pgxli5dKtIYDv2Ro9969OgRzMzMsGrVKhgaGmL79u1obGzkGZOWltYli/ja2lqhO1KSkpLw9vZGr169cP/+ffz+++8wMDDAwoULkZ2d3eHYK1euCDT3+l/GP3TB/1II0ll8/vwZPXqwA3lnzJiBGTNmoKWlBadOncLq1auhqamJO3fuQEVFBVpamhiuo4M1g4ZgyzY/yMsrYssWbzQ3N2PWrFl4+vQZnj7NQlVVFQDAffVqJCYkkuLi1tYWWP+yTf769QtmGBvBf40Xsh4/wc6dO/lEtKqqqhg0aCDU1XvC2NgYkZGRKCsrw/Dhw+Hq6oZbt24J1JF169aNLKSkpKTg6OgIR0dHbN++Hd++fQOdboeePdXg6uqKQYMGAWCL4LkXIRxwQou7devGo99KSkqCi4sLNDU1cf/+fb7A1/YaKQ4yMjIwfPgIBAYywWKxcP36dWzcuBGtra0oLy8nRfncEBRarKmpgVGjRkFTUxOGhoY4cCAMlZWV0NEZCycnJ4HOhhyLeE4hxdZvsS14Q0ND0djYCDrdDtraWnBzcyN1JtxZW9zgWMR369aNpAHW19cjPj4eDg4O0NDQxJMnT/hsavPz8ykdvp48eYIRI0YgKCgILBYLly5dwtq16wAQqKysotQ0CQot7t27F8aPHw9NTU1MnDiRpAHq6enBwcGBMmsL+Cu0mDNHHP0WAGzfvh1VVZWg0+3Qt28fuLu7k79NVlYWJTedbRGvAHFxcVhbW8Pa2ho1NTWIi4tDeHg4tLS0kJ2dzRcrwJ21xY1nz55h2LBh2L59O49+i0ajoaqqinT44uRlceaovLyczwVt+PDhmDdvHvr3749p06aR4Zkc/ZaghURdXV2HocWCcPv2bWRkZAh8XlxcHBs2bCDDYAMDA+Hp6YkBAwYgMzNTaLpMV+mPpaWlfNolHR0d0g0wOTkZNjY2aGxshIWFBTZs2IDY2NhOC5322LVrl8gLrvz8fMjLy0NWVha+vr7w9fVFUVERGAwGQkNDoa2tDQaDwWdN/ubNG8TFxfG9X2ZmJnR0dBFz+Cgqc/LhYbMUHy9cgqS0DMqa27AhKAj1dc2QlfuLJseh9rVfxOnr68PGxgb9+/eHnp4eqd9asmQJaZZEBU6xqaKiItJcpKWl4d69ewKfl5WVRVBQEIKCgkg3wFWrVmHgwIH48OGD0KYrWVlZGDJkCJKTk1FbW4vQ0FAYGRmhe/fuqKysJE1C2oMqtHjKlCmYMmUKWCwW4uPjYWZmBhaLhVWrVsHZ2RmHDx/GmTNnhJ4DgG0RzzFREhac0GIVFRXs2rULAFu/FRAQgK1bt2LIkCEIDAzk+/t59uwZqdMRFkFBQSJtxMyZMwf19fXo27cvaZffrVs3ODg4YNWqVQI1Ri0tLQJDiztCZxbxysrKpLMrJ57i/v37GDJkCAoKCoSOD3j9+jV69uwpskYqPz+f7x7A0Um3trYiPDwcM2bMgKSkJNzc3LBkyRIcOHAASUlJIh3n8OHDpImSsOAYcvTp04dHvxUYGEhqBDkbVtx49uwZrK2tRTrW/wL+KbL+C/Hz50/IyspCTEyM77mYmBg4OzvzPCYhIQE6nY7ff/8dBw4cQHR0DG7cuoneo0bj9xevUVFRgaqqKmRkpMPIyBCfPn1GTk4OqqqqUF5eBjs7e1y8eBG/nT6NESOGw9HRCU1NTdi8eTOOHD4MKXEJNJYUISkmGhI0GnJyvgm04uYUUlJSUmQo8O3bt7Fhw3p8/foNZ8+ew/Lly3hu3rGxsQIzST59+oRjx46BRqPhzZs3OHToEMrLy9GnTx+B2haq0GIpKSk4OzsjPT0Du3fvQkxMDGJj46ChoQ4XFxcUFxcL7EixQ4vZNxwajUbqZerq6mBlZQU/Pz/IyspixYoVpOMjlbMhB9evX8fhw0cgIyPNo99as2YNvn79hsuXU7B48WJ069aNHMPJ2qLC+/cfEB/PnqNnz579cgOswqBBgyAvL9dB1453jmRlZeHh4YEnTzKxY8d2REdH4/DhI+jVqxfc3NxQVFQo0NmQO7SYRqNh0aJFpBuglZUVtm3zg4KCPOkUCHTekYqIOAhZWVlMnDgRLBYLFy9exOrVq/HtWw5u3LgJS0sLnu8WF3dM4Hn58eMnJCUlgUaj4dGjRwgJ2Y7a2lqMGDEcsrKyAjVS7Q05FBQUsG7dOjx/no3AQCZiYmJw4ABbv+Xm5o6CgnyBu4rcocXc+q2qqipYW1sjIIABJSUl2Nqux/jxbP1JfHw8j5lL+/dLTU2FoqIiqd86fPgwZs6cCXFxcTg7O2P58uU8303Y0GJucPQpwi40VFVVERERgSdPniAuLg4MBgMFBQWkfqujHfKuWMSfOHGiU4t4Tkh1c3MzDhw4gEmTJuHTp0+4c+eOSFbn169fF9kiPiAgAOvXr+d5TFNTkwzizczMhL+/P4qLizFx4kQwGAx8/vxZoEZq61ZfrHfwBO3jB+Q/fYiJw/uByWTix48fWG5jg6Nb1kGhz2Cs3LoJE43YGyLcWVvtERMTgwsXLkBZWRkrVqwg9VscN8D169fzaA8B4UOLuSGqRTzHDdDAwAB79uwhC/hJkybB39+/QzMV7tBieXl5bN++Hdu3b8f3798xfvx4ODs7Y8CAATw27mfPnu1QF0Sj0cjNv9raWuzYsQOGhob4+PEjXr16JbR+C+i6RXx7Q46BAweSQcF37tyBu7s7KisrMX36dPj6+uLz589dMuQoLCwUuTt36NAhnDx5EhoaGvDw8EBlZSWCg4NhbGwMFRUV+Pj48P2dChtazA1RO1KceAp9fX14e3vDzs4OtbW1fPEUVOgotFgQrly50qFOUVxcHBs3bsTGjRvJDal9+/bhy5cvKCwsFMmUgzu0WFhQhRa335Di5PBZWlpi/fr1qKyshKqqKuWa9H8d/xRZ/4W4evUqHj16hPv372Pq1KlYuXIlaSRRUkKds3Lv3j0MHDgQysrKcFm7Fpl5BVhCt8OFCxfx7t076OiMRWFhEerq6lBZWYkfP37AysoKf/55F0+eZKKtrRXV1fWYOZPtYHj37h8wmTYNziuWQ7y+DociIuDp6Qk1NTXk5+cjMTGR7zNwnA25DTloNBpmz56NV69eYcGCBSgtLYWTkxOkpaWxfPlyTJ06FS9fvuJbhADsjlT37krk4m7kyJEIC2MXJfb29mhtbYODgwOmT5+OZcv+KtwKC/l3IwF2R6p//36kjTsAvHr1GhEREXjx4gWmTJmKqqoqMn8L+Ctri8oiPjU1FZaWC+Du7oaiomJER0chJuYoNDQ0kJeXi7g4/u4Ix9mQm/5Io9FgZmaGz58/w9TUFD9/lsLR0RFycvJYuXIlDA0NKLO2AP7QYl1dXejq6oLFYoFOp6O1tRWOjk6YO3curKwWka/Lz8+nvImyqX19oK2tTS5SsrKysGfPbrx8+RIzZszko90J6kgBbIqjhYUFPDw8kJeXj6ioKBw6dAi9e/fCt285OHo0hm8Mx9mQm/5Io9FgZWWFwsJCzJ49G7m532Fvbw9FRUXY2dlh/PjxePo0Cx4eq/neLy+Pl9pnYGAAAwMDsFgs2NraoqWFPUeWlhYwMzMjX8edtcUNjkU8x8YdAB48eICQkBC8ffsGs2fPQUNDI89vzGKxUFX1/9j77qgm9rXrTaSJIKh0FcHeFY/SbIiKioigomAhhA6KBRBEOoIFRSkWmiIWPIqIBXvvDXvv0qv0XjLfHzFzEjIJCfd913fve91rnbUOgclMfk5m5nn2s/euonSyu3nzJkxNTbF69Wr8+PEDe/YkYOXKCAwbNgxv3rzBjRs3KNeIaBdazB6XWbNmDcrLyxESEoLY2FgoKSnB398furq6uHbtmsihxf+KRTw7LBdgGY8sX74cDQ0NMDU1haenJ9e1gm3IIapFfFJSktAW8ZKSkvDx8UFDQwO6dOmCa9euISIiAurq6ggKCqK8brCRm5vbKYv49+/f8xQpnGCPATKZTKSlpcHS0hKvXr2Cra0tj8tpa2sbxGrbcDkhFumVpSgrK8Pe305uz549w+xZs7B+/Xq8ev0Ga5fR0azWC3+NH4OnT5/i/PnzPPumGn+UlpZGYGAgAgMDkZeXh8DAQISGhkJDQwPBwcEYPnx4p0KLg4KCKK9hgsAe7Zs0aRLOnz8PJpOJw4cPw8zMDFVVVXBycoKrqytPA4BfaDF79GvPnj24c+cO+V2ZMmUKHjx4QD5odgRZWVls3rwZW7ZsQXl5OZKTk7Fx40YMHDgQoaGhPNmLnCguLuYbWiwIHVnEsydbmEwmEhISMHv2bHz8+BEuLi6ULqf8wBlaLCyoQosVFBTIcNxPnz6ReXRDhw4lz6dTp05RXt8EISQkBC4uLiJt8+bNG6iqqvLEU7DdAKkaUgA6ZREfFRUltEU8uyEVFRWFDx8+kKPfY8aMQWhoqECGr7MW8Q8ePBAYWty+IWVoaIiamhrK68cfAGIsvda/B8aPH0VkZR38/30Y//aIiYnB6tWr0dLSgmPHjuHWrVuQkJDA8OHDUV1dTUnj29raogXA5Lnz0CoujtycHCxbthytra0ICQlGv3798ObNWzQ0NGDmzJl4/foVJCWlMGDAACxduhRNTU0IDAxEr149UVdXj7qKcpxIjIdCu1yMp0+fwsfHB3379iXHAHv0UADA6m4OHz6c8oGCTrcl2RaAxdbFxbGs3svLf2Hv3n0YNGgg1zY+PhuwbNlSypslnU5HSkrK7zHAw7h//x6kpaUxZsxYFBcXUWoF3NzcEBgYyHPhYhciVlZLcOrUKbS1tWHmzJmwtLREeno6yssr4OrKe1G3t7fH7t17ePRiDx8+gp/fRvTtq4ExY0bD0dERcnJyAFi2qQMHDqTUSbVfo8LCQsTFxePTp48oLy9HQkICD9u2ceNGWFouphxzpNNtkZJykBwDfPLkKWRlZTF+/F/48eMH5Rz8ypWr4O/vx9P9ZBe25uYWOH8+EwQBmJjMgYWFBTIyMlBYWEhpe2xv70AyUpy4c+cOgoKCoKHRD+PHj4e9vR35NzExMejbVwMWFuYdrlFOTg7i4+Px48cP/Pr1CwcOHOAp9vz8/GFubs6TB8a5RuwxwBcvXkJevjv09PTw/v17hIWF8Wzj7u7O5WzYfo1MTExw5coV0Gg0mJnNx9y5Jjhz5ixycrIpIwAcHBwQFRXVTi82GunpZ+Hg4IAhQ4bw2Lj7+fmhT58+QuXRsMdlvn37hqKiIjx58kQkVyldXV08fvxY6L8HWO6Iu3btoiyYmpubERsbi1OnTkFSUhKurq5YvHgxUlJS8Pr1a4EPAO1RX1+PmTNnChxlpIK+vj7u3r1LFjDPnz9HaGgoab0fHBzMMy7DYDCwePFikTK1Hj16hMjISJHynZhMJnR1dWFubo7MzEzIyMhgzZo1MDMzQ8rBVOTduAO/NY5oaWmBuYUFVFVVIQawzv/kZPRQUMDx48dRVlENi3UbceXJTaxbtxbDhw+HpaUlVq1aRX7u0NBQdO/enXLsuj0eP36MsLAwFBQUoLi4GG/evEGPHj2E/lx6enp49OiR0H8PAPPnz0d4eDgPM8BkMqGjo4M5c+bg2rVr6N69O7y8vDBz5kycOHECt2/fprQRnzZtGtLS0ris4Nn6th07dvDoiDuCgYEBbt26RRZMt27dwrZt21BRUYGpU6fCz8+PZzTXxcUFxsbGIrklsse5hC0C2Rg/fjymT5+O27dvo0ePHvD19eXLjLMxffp0kpESFtu3b0drays5zSAIFy9e5HLL/fjxI6WemB90dXXx8OFDkUb4Fi5ciA0bNlAWTOyG1OPHj6GsrAx/f3/o6Ojg7NmzOHfuHN/RUiq0trZi8uTJePjwodDbAMDEiRNx/fp1smDKyMjA7t27UV9fDzMzM3h6evIU5WvWrIGOjg6WLVsm9H7evXsHHx8fZGZminR8Pj4+5IjqfyvExMSeEQTB8xDxh8n6D8P379/JmWoJCQnY2NjAxsYG5eXlWLp0KXr1UoSnpxccHBwwbBhLg9Dc0oImSSl4BAbj9JkzuH79OjQ1++H5i+coKipCU1Mznjx5Cj09XWRn50BCQhxMJoHc3FySucrMPIfp040wZ9ZsSLU0I9THm6fAAoBbt25j/fr1mDNnDq5evYoNGzagpaUZ06ZNw6tXr8hgVU78+PGD1JGxoaSkhIAAf/j4+MDKygr79u3Fr1+/MGLECDg6OqFHDwW+3UgWI8VaI9YYoAMcHR1QXFwMGxs6FBV7wdvbG87OzmRHsX3WFifYo31sG/eGhkYcPnwIDg4O+PHjJ4KCeMcF2BopKkOOR48eYt06D8yda4ILFy7Aw8MDbW1tMDY2xsuXLykftKks4tXU1BASEgxfX1+Ym5tj165dqKyshLa2NhwcHCArK4v8/ALKAuvRo38s4tljgCtXsgo3W1tb9OrVC35+fnB2dibZFX46MtYanYKOjg4sLMxhYcHSbx04cAB2dnb4+fMnNm3iLUbYxhdUN9CXL19i9eo1mD/fDKdPn4a7O6vDbWpqimfPnlEWbO0ZKYBlCR0eHg4/P3/MmjULmzdvQW1tLXR0JoDBYEBGRoYna4sNztBi9hgg+9/CyckJvXr1QlBQEFxcXMg1aZ+1xQl2aDF7DLCmpgZJSUlgMBjIycnB5s1beLZhZW2BwpCjBs+ePcPmzZvh6OiIvXv3co0BXr9+XWhGij0uQ6fTYW5uTuq3hBmX+Vcs4vkxUpKSklzjMkFBQdi5cye+fPkico7U1q1bYW1tLdI2OTk5pNaOjXHjxuH06dMAWEYG7HEZc3NzrF27FpKSkp0KLQ4PD8fWrVtF2ubYsWMwMDCAn58f/Pz8UFBQgKCgIISHh6OhpA5JvqxrbHp6OszmzYOzszPKysqwbNky2DEYUFFRQXl5OVIOHUJNdRWys3PJ85g9BtitWzesXbuWb9YWFXR1dXHu3DnY29uje/fusLCwQEtLC6ysrODq6iqQ4WNFiohmFy3IIj4tLQ36+vrYtGkTNm3aROq3AgIC8O3bN8qHyIaGBjQ1NfFkbdFoNJSXl8PJyUmk46OyiDc0NIShoSGYTOZvQx3W+PKKFSvg4OAAGo2Gly9fklb/wiIkJARBQUEibZOeno4JEyaQD8dfvnxBUFAQvL29MXjwYISGhvI07diGHKJqpDIyMoQef2TfZ93c3FBfX0/qt+zt7cnoFX5gW8R3RiPFj5Hq2bMnoqOjAbCKEHY8xc+fP3HhwgWR9tMZi/jy8nKe8UfOeIro6GgYGhpCSkqKbEgBoocWA6zxRz8/P5G2EUUL+d+IP0zWfxiSkpJgbW3Nk6ze2toKBwcHHDx4EJ8+fcLq1auhqqqG/sOGgtZTEUwxGiwsLNDY2IigoCCMGTMG79+/R0lJCUaOHIGysjL06NETAwb0h5nZfNTU1CAycgf69dPEz58/UVJSgk0bN2LymJGIityJkSNHUD5QtGcSAJZ4ddeuXbh06RIGDx4MKysrrrR6H58NWL58GUaNGkXxfnRy9JCt32KxR+WQlJRCSspBnpu3m5sbV9YW1Rq9efMW+/cnoaKiAiNHjoKioiKam5sowwH5MVI1NTWkeP/79x9QVVWFi4sztLS0sHPnTgwaNBjz5vHOk1OtUUNDI6KiduHq1asYNmzY7zHAf7K/hGGk2Gt0/vwFnDlzGjU1NZCQkCC1RpwQzEjZISXlIJ4/f46DBw+iqqoa48Zpo1evXqiqqqJ0ouLHSNXW1sLFxQWamprIzc0j9Vt9+/ZBdHQ0+vXrR6m3o1qj2tpa7Nq1Czdu3MDIkSPJMUA2/Pz8YWFhTqmbaL9G6emncOnSJdTV1UJSUhIHDx7kWSPBjBRrjR4+fIgjR46itrYWenp66NWrJ4qKiijHnqgZKVYh5ejoiL59+6KwkKX9YxVuqti9ezfU1NQo9C2K0NNbggcPHnAdd0VFBdatW4cPHz6IzC5xMgnscZm0tDSB4zKCGCl+SE5Oxvv37zmMPDpGfX09DAwMMGDAAOTn51OGZ1KhPSMlDBgMBqysrDp0MGxubsbOnTtx9uxZNDc3Q0JCQqQONZPJhL6+vsj/ToaGhqRGihP19Q2wMpyLAdIsw52i4mKkHDwIVVVVxO7ejWvXroEmJobAoCB4eXmhT+/e6DdgGK4Vl+DOvetca5SXlwcPDw98//4dWVlZIh0f53lUX1+PiIgIXL58GbKysvDw8KC8b/BjpATh+PHjuHfvHqXJDRUjBbDGH//66y/069cP5RW/ME5nJNa62kCaxkTqsWMQl+4Gx1U+kO3aC11o/2Q56uvr4/bt2yKN8Lm4uGDWrFmwsLAQ+He1tbUIDw/HzZs3QaPRQKPRKIO2BaEzLKCRkRH+/vtvSgfDq1evktrdGTNmwNfXF926dUNERASYTCY2bNgg9H5KS0uxePFi3Lx5U6Tj4/xMlZWVCA0NxYMHD9CrVy/4+/tTZmMKYqT44cyZMzh//jypgRQGra2tGDFiBDQ0NFBXVwcTExN4eXl1OJrXnpESBmvWrIGenl6HzaKSkhKEhIQgKysL3bp1Q1tbG27fvi30foDOnUfh4eFwd3cX2Szp/xr+MFn/B8BkMtHQ0MhTYAEs84WJE1mhfxoa/aDepy9Co6Jx9f4DJCQkQFVVFS0tzQAAeXl53Lp1C/37awFgOeM0NTXjw4f3UFNTRWNjIzIyMmBsPAsGBgaQoNFQl5+LYwcPIiWqDPn5ebCzY/Acw7dv33gYKYDFuP369QvR0dFQU1NDXFwckpMPQllZiTSVoCqw7t27h/79+5M/s/VbxsbGcHV1xdChQ+Ho6Ejqt6ZMmUIyUu0LLIA7tHjUqJGkfottfd6vXz/Iyclh8eLF5AOHIEYqMTERlpaWpDD39evXiIqKRmVlBQoKCmBvb8+zDb/Q4q5dpVFdXY3IyJ1kaGlcXDzU1dXg7OzMl5FiWcT/Y39Oo9Ewb54p5s0zhZubG7S0tGBnZ4du3bphxYoVpNaIPyOVDh0d1g2KU7919uzZ3wG8mkhPT4eFhQX5Gag0Umzs378fixYtIguprKwsRERsQ3V1DQoLCyiZCVbYLG9osaysLBobm7Bjxw4oKysjLi4eMTGx6NdPA87OzsjLy6UssNqHFtNoNFhaLoKl5SK4ublBXV0dDIYd5OW7g8Gwg7b22N86MmpGimXIwSru9PX1oa+vj7a2NqSnp2PPnr3Q0tLEuXOZmDvXhPwM/BkplkX8ggULyELq/v372LQpFHV1dSguLqYcAcrL+wAFBd7vWo8ePcBkMkktmLC4e/cuFyMlLi6OtWvXYu3atfj16xdCQ0MRGxsLZWVlBAQEYMKECZ3WSCUnJ4s8jrJlyxY4OjqSBT5neOa8efMox2WoGClhIKxFvKSkJDZs2IANGzbA2NgYPXr0gJ6eHtTV1REcHEzJsnOCX2ixIAiyiN++fTtmGxvDzWLm72bLeQQGBqKlpQXFxcXYtWsXVq9eDd8NG7Da3R3z58/H6cwruHnpCs8a9enTB927d0dISIhIx9eekZKRkUFwcDCCg4ORk5ODoKAghISEQENDAyEhIRg2bBiYTCaKi4tFKrAAICIiArKysrh8+TLXv1djYyMlIwWwLOLt7Ozg5u6I7I8PscHGCdsfPQeziYni4hIcTz+Opg9vUdBdHD00RkFWupfA0GJBEJaRkpWVxZYtLBZ71qxZ6NKlC/T09Ej9Fuc9kAqdtYhvamriaxE/c+ZMzJzJOo/i4uIwa9YsiImJIT8/Hx8+fBBpX52xiG8fWqygoEAa3nz48AHBwcFYt24dhg0bhk2bNpHnNsnYuAABAABJREFUXGc0UjExMaQ5iLCIjo6GjY0N/Pz80NraitjYWFK/5ezsjCVLlvBcm/8Vi3hhGCllZWVyBNbY2BhMJhN6enpCN6QyMzMpQ4sFgX2f/G8vsAThD5P1H4QbN27g169flDaZS5cuhYSEJOTkZCEprwCNUWNgNGMGqmuqERgQgLFjx6K6uhpv375Dnz59UF9fh379NFFYWPh77G4UqqtroKevh/v37qO0tATR0dFQkukKVZmuoP12jfn27RsCAgIgJ9cdzc1NmDZtGqytrSEhIQEfHx8sX74Co0bx3iw5mQQ23r9/j61btyI/vwCzZhmTY4BsCMNIAWz9Vhy+fv2GxsYGaGtrU3ba7OzsSNc+TtTU1MDDwwO7d+9GSkoKHjx4ABkZGSxduhRPnjzB4MGDKR2OqNgWgDXS6evri+7du5NjgIsWLYK4uDg2btyIxYsXUwqHOVk7Nl68eIkdO3agqKgQpqamcHBwIPVbgHCMFMDWb8Xh58+faGlpwejRoynXyN7eHrGxsZSM1Nq1axETE4MDBw7g6dMsyMnJwsbGBg8ePED//v0p3Q35rVF2djY8PT0hL68AAJg71wTm5uag0Wjw8/ODhYVFh4wUG0+ePEF0dDSKioqwYMECcgyQjVWrVsHX15dHi9V+jXJychAXF4f8/AIABIYOHQZfX6o1ckBMTDRPs6O+vh7u7qsRFbULSUlJePnyFRQU5MFgMHDv3j2oq6tT6iz4rVFubi5Wr16NHj16oEuXLpg/fz5MTFiFW2BgIAwNV8PIiLcY6Ew30sTEBNHR0TxW8O3x9u1bBAcHIy8vD126dMGYMWNEsn9mj/+I2qnX19fHvXv3uBw1AZDjMqdPn4aUlBTc3NywaNEiAMIzUpy4f/8+YmNj8ffffwu9DZPJhIGBAbnmnPqt8ePHIyQkhPKBf+rUqcjIyBApUyskJAQKCgqUI8X6+vo4HpOMPmK15PUaAHLz8uDq4gJpaWl06dIFTU1NOHXqFGg0GoI3R2KUtTUWLuLVgHZWI7V58+YO83wePHiAzZs3o7S0FD169EC/fv0QHx8v9H4aGxsxffp0pKamIigoCB8/foSWlhaCg4Nx8uRJSEtLw9PTk2e7wYMHY39KPDQVCJyM2I8BGgNhZmaG/Px8ODk5QVFJCbKyslhstQgDp4+B/KC/4OHugzlz5nTISHEiKysLmzdvFnm8lXPNb9y4ge3bt6OiogLTpk2Dn58fZZNGECPFD9u2bYOYmBi8vb2F3ubr168wNDREnz590LNnT2zcuBGTJk0S6TMJiwULFmDjxo0C3RwBln5r586dqK2tRd++fSEnJ0cZa8AP/1MaKTbKysoQGhqKJ0+eQElJCYGBgWTRt3r1ahgYGMDKykro/bx9+xa+vr44d+6cSMfHueZs/VZDQwMZT0HVMJgxYwYOHjwo0tju7du3SSbvvx1/mKz/A3j16hXy8/ORmXkempqacHdfBUVFRVRUVEJOTg7Re/bixfcf8PLzx9df5Xjx6iW6dpXBmDFj8eDBQ6ioKENOTg7KykqoqpLEixcvMHDgAGho9EVdXR1mzJwBnQk6GDRwENL/PobBPeTRtV2HMyEhAb6+GzFq1Ei0tLTgyJGjcHJygpSUFEpKSigLrLt37/5mzbgxfPhwyMrK4ujRI3j9+jU2bPBBc3MzjIymY/FiS76MVPvQYpZ+i2X2YW1tjcLCItDpthg5ciScnBwhLy+P6upqrqwtTrBDi6WkpODk5AQnJycUFxcjLi6ODOMbPnw4V0eRnbVFNfudmJiIDRt8oa09Fg0NjTh0KAUODg6QkZFBcXExX2dDKot4be2xUFBQwPbtEXj27DnWrVsHJpOJWbNmYcGChair489I6en9E1rM0m+xutJWVlbIy8sDnU7n0m+xApTFKBmppKQkmJmZQUZGhtRD5efnIz4+Hrdv38HEiQbQ1h7Hxfy0dzbkREJCAjZu3Ihx48ahvr4e+/cfAINhBzk5WRQWFlHeXNnOhu2ho6MDBYUe2Lp1G548eUzqt1iM3jy+zoYZGRlc+9HQ0CAZoCVLliAnJxt0ui309HRha8tA167SZNYWFZu8fz8rtFhOTo50w/zx4wcSEhLw4MEDGBoaQl/fgMuJkpW1RR01kJiYCF9fX+jo6KCqqgpJSUlISzsJBQUFFBYWIDSUt2N7586dDjvf7cFmpDoqsACQ4ZkAS8v14cMHGBgYCD0u869YxLcvsAAWm7R+/XqsX78eJSUlCA4Oxo4dO6CmpoavX78iOTlZpH1t2bJFJGMNgDe0mFO/deLECVhaWqKpqQkWFhZYs2YNJCUl0dDQgNbWVpEKLIAVhTB79mz8+vWLK4OKnbXVVVUJjbk1kJH6p8g6sH8/fDZswORJk5CVlQV/f1ZAvYqKCr5UtWGjGe8D0uPHj/laxPMDv6wtKhgYGCAzMxNMJhMjRoxATU0NJk6cKJR+C/gntJht4w6wJh88PDxw//59MBgMVFZWctm4FxYWQl6+Ow7s2wzmu0Lkfc/HsdRUACx2df369TA0NMTTrCwEBgRAOVkZ0tq98fhFoUijZMA/wc6i4MSJE1yMlJGREYyMjMBkMpGUlESOWdLpdNjZ2YFGo4kcWszGmTNnRLaI37lzJ6Kjo7Fw4UJKN0CqQHlhQoupkJ+f32GBBfyj32ptbcXQoUPRq1cvGBoawsHBAUuXLu1Qm9VZi3h+rn2KioqIiYkBwN2QGjVqFLKysshsLmHRGYv4zMxMLlaYU78VFRUFQ0NDSEtLczWkRA0tZuPKlSsin+f/bfhTZP2HoKGhETIyMtixYwcAYNGiRfDz80dTUyPamEzMsVyML5XVqG9jWbEqKChAS6s/Ll++DEVFRcjIdIWSkgrExbvg+fMX6NOnDwYOHIgFCxbgzJnT+PTpM5SVVTB86FBcPvE3PFYs4ymwAKCoqJgspCQkJMBg2ILBsEVmZiaSkpJAp9tCSUkRzs7O5ENbamoqpZsfp9mEqqoqjI2N0dTUhCNHjmDBggUQExPD7du3MXXqVK7tBIUWy8rKktlSV65cwfr169Ha2goxMTG+4Y6vXr3mcc9SUVH5bShSgeXLlyM6OgaVlRUYPZrlBkiVtcUGZ2hx167ScHZ2hrOzMzIzMxEfHw86nQ5VVTW4urqQhRVn1hYn2traUFtbC3V1dairq2PePFM0NDTi4MFkmJubQ0yM5Vaor8+dcSMotFhWVha7d+8mxwDXrl0LJpMJCQkJmJnxdrQBUFrE9+7dGw4ODqisrMSCBQuwfXsEqqqq8ddf42BnZ4e4uDierC028vLyyQcKGRkZuLuzCrdz5zIRFxcHOt0Wffuy3PHYBRJn1hYn2OOPffv2Qd++fbBw4ULU1tbiwIED5L/58+fPeUZqLly4iNjYGJ73q6urg6ysHPbt2/dbv5WOVatWQUyMZV9tYkJtbpCVlYWVK7lt+bW0tLBq1SrU1NTA2NgYYWGbUFdXBz09PdDptti3bx9sbGwo348ztFheXp7szJ87dw579+7F/PlG6NlTm2tcZuvWraRIW1gkJyfzfMc6Ql1dHXr06IGbN2+itbUVMTExHY7LAKzvrqgW8UG/NUQdQVlZmWTVkpOT4efnR47LhISEUDZsOMEOLe6MRTy/0OLFixdj8eLFaG5uRmRkJAwNDdG1a1f06NGDFKgLi9zcXGhpaWHKlClYuHAhWlpasHDhQqxevZrM2pJV7I6afGl0JZrIzJrXr1/D28cHAJB28iS2bt2KsWPHIi3jHK78fQqTJrFGXoOCgsiiLywsTGRDDkFZW/zQ3NyMnj174v79+6R+i52/5eXlxZeFpAotnjRpEhITE7FixQqMHTsWZmZmYDKZWLp0KVxcXBAUFAQfP09M0lRE849abNiwAUFBQWhoaEBxcTHJ6mScOoXw8HCMGzcOKReO4MKdl9DT08OUKVPg7+8v1GhUUVERxowZI9Ja7Nu3jzK0mEajkc2/6upqhIeHw8DAAD169ICqqirfDEl+KCkp6ZRFPGdo8ZAhQ0i29/Lly3ByckJVVRVmzpwJX19fslEXEhIiUmgxwGp+aWtri7QNk8mEkpISHj58iIqKCoSGhmL37t1QVFSEn58fpX4L6Di0mAohISFCubZyNqSioqJw+vRpTJw4EXPnzhWqIQV03iKeKrRYUlIS3t7e8Pb25mlIaWpqimza09DQAAkJCZHHsf/b8Gd1/kNw5sxp9OzJ6lwWFhZCRUUVe/bsRkV9PRbZO+FY5gUcy7wAKSkpLFq0CCdOHMevX+WQkpJEjx49MGLECNy6dQuqqqpQUVFGt24yMDWdh4EDB8LUdB6kpa9CZ/RIJG/bis8fPuDZ0CEYMmQImb8FsBipgQOp8z3Onz+PxMREKCkp4cOHD4iLi0NZ2S8MHToUNTU1fBmp9uGDUlJSsLe3x7179xAWFoYDB5Jx4EAyVFSU4eTkBCUlJZ6sLTaSkpLIkQ4ajYbZs2dj9uzZZBf51KlTuHjxIpYuXYrJkycDEMxIxcXFg8GwxahRo8jC7dKlS/Dy8sKnT58xZswYjBw5kusiw4+RAlijDQkJiVBTU8XLly+xa1cUKisrMGbMGNTU1FBmbVGFFnftKg1XV1eyK33w4EHExe2Duro6XFxc0LNnT746Ms7QYhqNBnNzc5ibs9wAFyxYgFOnMnDlylXQ6TbkA74gRiouLg4MBgPa2toYP348mEwmzpw5izVr1uLr16/466+/MHbsWK5tOZ0N2+Py5UtISIhH79698fTpU2zZsgU1NbUYP/4vVFVV8WWk2rsDysrKYvXq1Xj16jV8fLyRkpKC6OgY9OunAVdXV8jJyfHVkbFcv0zINbK0tISlpSVqamqwaJElampqcefOHTAYDJKVpHI2ZIMdWjxhwgRMnDgRra2tvwu3lfj69Rupk+PcltPZsD2uXLmC+Ph4aGgMwoULOWAwGKipqcHs2bNRVlYmFCPFiZSUlE5ppNjWwOLi4vDw8CDDYENDQxEVFUXmzbEfErKzsyEvz6tH7AgfP37EzJkzRdrm5MmTuHnzJoYMGYL09HRYW1ujsbFR4LiMMKHF7VFfX4/W1laBwbcA6wHH19cXvr6+5AN4bm4uGVXQkX4LYOWReXh4wMTEBEuWLEFjYyN27NiByZMn4+PHjzA3N4e0tDhqe6ujMvsHenRlFVjS0tJYtXIlaDQaiouLMXr0aDS3Erj88iMOph3F6DEjcOzYMSxYsAAtLS2wtLRESQl13qIgxMfHizwexxla3F6/FRgYiKCgIGhqaiIkJIQsfgWFFgcFBZF29nQ6HfX19diyZQsmTpyIjx8/Yu48A8g2S2BzXBzWe3tDe+xYvHnzBqGhoTAzM0Pfvn1RWlpKNmRe3s7C0QO7MWnyQiQnJ8PU1BRMJhPLli2Ds7Mz5bl84sQJLkMeYSAsI9W9e3fSDfDbt2/Q19fH+/fv8fbtW4SEhAjl9BkUFCSyRkoQIzVr1izMmjWL1G+x3QDt7Oz+pdBiURAdHU3e13r06EFqmD58+ICgoCCsW7cOw4cPR2hoKHld7axG6unTpyI3su7du4cLFy5AW1ubbEhJSkrCxcUFlpaWlOdRR6HFVGhtbUVdXV2HgcWcDamXL19ixowZ6N+/P4qKihASEiIUM3ru3DnKqJk/4MafIus/BLm5eaipqUZmZiYrsNfJEbk1dXj19RsaW1vRlWDCwmIBkpOTcfnyJdBoXSAr2w1TpkxBRkYGyst//c6tcsbZs2dw48YNtLW1wdTUFJfOn4eXoz1GDhwIdWkp3Lp1C0wmAScnJ0hKSmHxYkty/p0qO6m1tRUNDQ1QUlICAAwbNowcuQkMDERlZSUYDAaMjKbD2vqfUGBBjJS4uDh69+6NgAB/ACzr1L179+Lt27fo378/TygwAL6hxQUFBRg0aDCio6NQXFyMhIQEJCXth6qqCqqrq/l2pYqKuEOLaTQaTExMIC8vj0uXLqGqqoocA1y2bBkmTpyIo0ePIiCAl95vH1o8duxYsnALCAjEr1+/YGdnh1mzZmHhwoXkGl2+fJkvI0Wj0aClpUXS9S9evEBkZCQ+ffqEAQMGoKamFnJy3DP8/EKLS0pKMHjwYMTExKCgoABxcXHYs2cPevfujZqaGtjZ8Zp4APhtyPFP15FGo8HCwhzq6mo4c+YMCgsLyTFAdqFx+PAR+Pvz2sS2Dy2eMGECabDg7++PX79+wcHBAXPnmmL+fDPyxnThwgVKhzG2IcfgwYMRHh4OgFXghYWF4+vXrxg0aCDq6+t5Cq2srGeUDyGVlVUYPHgQYmNj8fPnTyQkJGDXLpYZSHV1Feh0OuUatQ8tFhcXx5IlS9C/f3+cOHECnz9//j0GKA97e3uMHj0aKSkp8Pb2oVyj6urq37b6TTAxmQkTExO0trZi2bJlyM/Px9SpU+Hk5ETpBki1RkwmU2Th8vXr1ymzpwSNy5SXl3c6tFgUtDfk4AzPZI/LSElJYeXKleS4DMBqQPBjpPhh27ZtImksANYD9ejRo3H16lVkZWUhMDAQRUVFmDBhAoKCgij1WwDrgZFT+yAtLQ1/f39Mnz4dYWFhOHfuHDZv3ow+ffrCc6UXBtKksD/lCBl+e+3aNeyLT4CdyxqIqfbFu9JcjNVmGQ4tW7YMy5YtQ2NjI6ytrZGTk4MZM2Zg3bp1QllOCzLkEIQLFy7wMFIAa3S3/RhgaWkpJk2ahNLSUr6hxW/evOHKLZKRkcGmTZtgZmYGPz8/XDibgVNZX1GQXUgG1u7btw/i4uLoIi6ORYsWsZoitrbo1bMnikuL0V+jD2g0Guzt7WFvb4/a2losX74c27Ztw5AhQ+Dt7Y3p06eT+9y7dy/JYAiLyMhIkXKxANbI8qhRo3D9+nVcv34drq6uqKyshJGRETZu3Eip3wI6Di2mgjAW8TQaDW5ubnBzc0NlZSWWLVuGnz9/Yu7cudi4caNQDYzm5ma+USqCwM8iftiwYThx4gQA1rnGbkiZmJggPz9fKEaKE2/fvoWKisq/ZBHP2ZAKCQnBrl27yIYU54hkdHQ0JSMlCLt37xaZkerbty9GjhyJW7dukQ2phoYGrngKKjx79ozSH+APuPGnyPoPQFlZGdTUVLF+PesBZb71UmTcf4hDV66jpqYWrq4uSExMxMmTJ0EQBCQkJLBixQokJyejrq4eCgrykJWVw5IlSyAjI4MhQ4aitrYOZvPmIfP43/j+6AGOiXeBm5sr/v77b4SGhkJJSQkMhi3KysqQkJCAgwcPoqCgAOXl5WQxxcaJEyf4XkDz8vKQnp4OMTExHDlyBI6OjpCSksK8efP4MlIJCYk8N5wRI0Zg586dZJaPt7c3WlpaYGRkBCsrK2RnZ1M6GwIsRsre3g4AyIsZALx58xarV7sjMjISI0eOIvVbAJuRon64S01NRWBgIFRUVODs7IzCwiLEx8chPj4e+fn5aGxs5NmGipECWDemoqJCnDyZDgA4ePAgHBwc0K1bNyxYsAA0Go2SkWJppLjHH7W1taGtrQ06nY5Zs2Zh3bq1IAgCs2fPxsKFC5Gbm0vpbAiwutAMBmuN1NXVyWL62bNn8PLyQlTULowbNw729vbkzVsQI3Xo0GEuQ47c3DzEx8chNjYW+fkFaG1to1ijU5R5VewO/MmTJ8l8GQbDDt27s85pfjoyFiPFPW+vp6dHjupNnToV7u6rISYGmJmZwdTUFPn5BXwZKdYYI6uQ0tTUJPVbDx8+xMaNG1FeXgE9PT3Y2tqS/2aCGKmUlBT4+GwgdWxs/daOHTtQUFAASUkJnm3YWVv/oAZAT4iLi6OwsBAfPnz4HTAegtjYWCgpKZFjc1TYvHmzSGGVAMshs3t3amaTE5zjMmfOnIGtrS0KCgrw5MkTeHp6CtVB3rJlC+kqJiwOHz5MeT1qPy4TFBREjst4e3ujra2tQ0aqPa5cuSJ0jhQbQUFBZF7g+PHjcfr0aRAEwaXfWrhwIdasWUM2Wx4+fEjm1bVHeHg4duzYgWHDhgFgddrDwsJQVlqJupJKrFTUREmbFFKv3Id//FFojh2BxOR40D7xPoRLS0ujoqIC7969Q319PQIDAxEaGkq6AfJzH4uIiBD5gUsQI8WJSZMm4fz582AymTh8+DDWrl2L79+/IycnB66urqRWT1DWVlhYGHbu3AnFnm1QyK/BuxfvsWPHDlRWVqK4uBju7u5ITU1FxPbtOHzoENTV1ZGSkgLZbFly7JINWVlZVFVVISsrCzU1NQgKCoKfnx/69+8PPz8/NDc38y2U+eHcuXMia6SCg4NJfez06dMxffp0MjiZ/aBta2sLBoNBfldfvHjRKY1UYWEhpZaYHxQUFNDQ0IBXr16hsrISwcHB8PT0xJAhQ7Bp0ya+53JUVBSlgZIglJSUQEpKqsPxRxMTE7IhtXv3bkRGRuLjx49oaWkRqiEFgMxaEwVnz56ldE9WVFQkm4Nv3rxBSEgI8vLyMHr0aAQGBgrFSLVHWlqayOOPoaGhcHR0BEDdkJKWlsbKlSu5YkRKSkqgpKTE8934AwoQBPFv899ff40kCCLrz3/t/ouJoRMnTvgQDS2PiXMP9hKOQWbEq9KrxIuSy4TR8hHEbLtxhMGigcQshjZx7HY0MdGS9f8uoQuIV6VXicTzYYSuhRZhsdKACDuwmliybhrx+PtJor7lEXH2bDCxc+cy4vHjvYSbmy6xYEE/ymM4etSDCA01Jzw8phI2NiOIzZsXEb9+XSEIIotgMEYTjY33ebapqLhGODqO43m9pOQSsXChJmFm1ofw8ppGfP58jOv3NjYjiba2Jzzbfft2glizZhL5c2PjfSIx0YWg00cSRkYKxMGD7pTHbmMzgvL1e/eiiaAgU6Kt7Qlx4cImwtFxHMFgjCZSUz0JZ+fxREFBJs82LS2PCDqd+jw9dsyLCAgwIdasmUTY2IwkIiOXEtXVNwmCyCLs7MYQ9fX3eLaprr5JODho87xeUJBJLFigScybp074+hoTP36cFGqNfvw4SaxePZH8ub7+HrF3rz1hYzOSmDGjB3Ho0FqR1ujhw91EYOBcoq3tCXHqlD9hZzeWsLMbQ5w86Uu4uekRBQXneLZpa3tC2NhQr9GJExsIX19jYtUqfcLGZiQRE2NL1NXdIdeI/f+c/9XU3CLs7cfyvJ6Tk0FYWGgQ8+apEwEBJkRe3hmh1ignJ4NYtUqf6/137VpO0OkjCWPjXsTRox581oj6Mz15so/YuHE20dr6mDh+3JuwsxtDODhoE2fPBhMrV+oROTmn+awR9ZqfOuVPeHgYEm5uuoSNzUgiLs6RPHfs7ccSNTW3OP7+J0EQBFFTU0NMnDiRaI+3b98Sw4cPJ0aMGEHY2dkReXl5XL/X0dEh2traeLYThBUrVhBXrlwRaZu7d+8SVlZWRFNTE7F9+3ZCX1+fmDp1KnH8+HG+27S1tRG6uroi7YcgCGLKlClERUWF0H///PlzYuDAgYSGhgbh4uJCFBcXC7VddnY2MWPGDJGPr6PP1NDQQISFhRH6+vrE9OnTiTNnzhBz584l3r17x/O3bW1thI6ODuX7HDp0iJgxYwYxbdp0YtKkqcSgQUOIpqZmgiBYa/Tr1y/KfRsYGPC8/vDhQ2Lu3LmEjo4OsXbtWp5t9fT0iJaWFoGfqz3s7e2Jc+fOibTNkydPiIULFxJ1dXWEv78/oaurS8ycOZO4cuUKYWZmRrx584ZnG841+lWVTVQ+vkoQWVkEkZVFXAoPJxzHjSMWaWkRS4cOJUzV1Ii2J08IIiuLcBw3jsi9cpooLv3I9X4NDQ2Evr4+z35u3rxJ9O/fn+jTpw/h7e1NVFVVCfWZCgsLCSMjI5HWgSA6Po+qqqoIb29vQldXl5gzZw5x+/ZtwtzcnHjx4oVI+zl58iTh4uIi0jZNTU2Ua3ThwgVi5syZhK6uLhEQEEDU1dVx/V5PT49oamoSaV+urq4CryNUePXqFWFmZkb8+vWLWL16NaGrq0uYmpoSjx49ErhdZ65H06dPJ/Lz84X++9OnTxP9+/cnevfuTYSHhwu9HmVlZcTUqVNFPj5dXV2B94Di4mLCxcWF0NXVJc+f2NhYIjs7W+R9/V8GgCyCoq75w2T9B6C+oQGvfvxE6pp1KC0tIRmHZ1nP0NzcAgBYv94LO3fuxNGjRyElJQVxcXFyjKWxqQmGhlOxePESXDifidx3b5G0dSuWLLbE2bNnsHPnTsjJyeHz58+ULAwA1qjJvn0k83T16lX4+vqivr4elZWVfNzRkmBhwTsCoaSkiG7dZJGcfAAfPnzAvn378OvXL4wYMeJ33gw1IxUfnwB7ewfyZykpKTg4OMDBwQHLli1HTk4O6HRbqKgow9nZGQMGDBA4bnT06FEEBQWBRqORLkVNTU1ITk7Ghw8fsGlTKJYuXcplU8uZtdUeV69eJUOLmUwmLly4AA8PD7S0tKCiohISErxft8TERB5GCgDU1FQhK8tao1evXmPXrl2orKzE2LFjMWvWLIGMlK3tPxlmbP2Wq6srli5diq9fv4BOt0Xv3iz9loaGxu+sLeo1Yo/2sccALSzMf7sB7sfbt28QFhYOW1s61zhcevopMmurPS5dukSGFjOZTJw+fRru7u5gMpmoqKigZDf2799P6QDFsuztjuTkA8jKyiL1WxMmjMesWbMos7YAFrPJacghKytLGp9YW1vj7du3oNNtoanZ73cosBpP1hYn2IxUly5dSKODmpoaJCYm4s2bt9ixYzuXfgtgZ21Ru2edP59Jhha3trbi5MmTWLnSDWJiNJSX/2rH2tUAYDFSK1as4HmvESNGQE5ODg8ePMCFCxdga2uL2tpazJkzB4sXL+arRxSEz58/i6yR2rJlC3bt2gVJSUl4eXnBy8sLZWVlCAoKws6drGw4f39/rjVJSUkhtZPCor6+XmRGSltbG4qKirh79y7OnDkDKysrNDY2djguI6whByfu37/Pt4vPhrS0NPz8/ODn54eCggIEBQXh7t27CAwMRHBwMJdOQ1DW1v79+8nQ4sbGRmzduhVTp05B165dUVpaSjnat23bNkpDDj09PdINMDU1ldRvLVmyBObm5ujWrZvIAvi3b98iKSlJpG3CwsIQHh5OjgFu2rQJ2dnZCAoKwsuXLxEWFobQ0FAMHjyY3CYtLY3Ul8rKKKG02xd0byAgJiaGU6dOYVtEBHooKCA1NRVXrlwBw84O3WRkUFlZiS7KMpDrzs38sJ0N28PQ0BDKysq4desWDh8+DFNTUxAEgeXLl8PR0ZHv9ywoKIhkpITF8+fPO2Q5OPVbX758QVBQEG7cuAE5OTmEhoby1Q63x+7duykNOQSBHyPF6QbIqd+yt7fHrFmzOmXI8ezZM5FiJADW+GNgYCB69uxJ6qvY4825ubkYNWoUQkNDudb4zJkzQmknOSGsRooT8+fPR0REBC5duoSEhARMmzYNEhIScHNzE2iWExoaCmdnZ5GO7+3bt1BSUhJ4D1BWVibHS9nxFNXV1SKfs/+t+FNk/ZvjzafP6DF4KOZMmgwmwYTfxo04d+4sjh//G42NTfD08kR0VDT27NmLCRMmgE63/S1eDEZ0dBSUlVVQUFCAjRt90atbV/SVlADDciHMzc2RmJj422UmBM7OTrhx4wblrHZFRSXPaB87rDAiIgK/fpWTNu5Lllhh2jRDAKwvsKenB8/7cYYWs8cAmUwmrl27Bk9PT/Tq1QuHDx/h0m8B+B1azCsEvXfvHgYPHkTS+G/fvsXu3btRXl6O4uJi7N69m2cbfqHFUlJSkJeXx9KlS2Fubo64uDgkJiZBVVUVzs5OZCHVHlVVVVyjfTQaDaampjA1NcX27TtQWFhAjgEuX76cLNSonA0B7tBibe2x0NaO/h0wegHu7u5QVFREWloaFi5cyHWB5HQ25MTDhw8xaNBghIQEA2BdLHfs2IGqqmqUlpZQapr4hRbLyMhAVVUVVlZWMDMzw759+7B79x706dMHLi4uuHTpokCNFLtIoNFoWLBgARYsWIAdO3bgx4+f5BggnU4nH7ifP38Bd3d3nvfjNOTQ0dGBjo7ObzfAU3BxcUGvXr1w+vRpmJmZca1RXl4epTD96dOnGDBgAMLCwn6vGUu/VVtbi1+/yijFzmwdWfsCTE5ODpqamli0aBFMTedy6bdcXFxw/vwFxMTwvl/70GJ2s8TKygo7d+7Ep0+fwGDYQUFBAfb2dr9v+i24ceMGpWsfp7EL+3xkj8tMmjQJampqSE1NhZWVlVDF1r9iEc/54AuwxmXY4ZmvX79GcHAw8vPzoa2tjeDg4E6HFotqEc8ZWsw5LrNz506+4zKA8KHFnNi8eTPpECsM1NXVSbe9pUuXws/PD0VFRdDR0UFwcDCSkpIozSbq6+u5NFLS0tKkqYSXlxfu3LkDPT099O3bF8HBwaTJxaVLlwSOP9JoNCxfvhzLly9HfX09tm/fjr/++gtqamq4ePGi0HoQQaN9/MC2iG9vBtDexn3t2rUoLy/H5MmTERAQgH379pFjq5LiXSGurIbqn4WQbu6KvLw8tLawGpXXr1/Hvn370LVrV+yKikJFUzlsvdejZ89hCA0NJQ1lMjMzKdeoqKgIMjIyXM2/2tpa0g1QQUEB3t7eMDIy4tru1atXImWEAcCmTZs61EhxYtCgQViwYAEUFBSwYMECuLi4oLKyEtOnT4evry9f/VZHocX8cPr0aYHjj+Li4li1ahVWrVqFyspKhIaGYv369VBTU8PDhw/5NjLb4+XLlyKP1AEsi/j29wDO8ebMzEzY2NiQGVDr16/vdGhxZyziJSUlIScnB09PT3h6evI0pAICAniOX9jQYk4EBweLNP44btw4hIeHi5x79t+MP2HE/6ZoZTJRWNeArTGx0NDQwKzZs3D71h1kZJxCS0szVq9eQ3YBm5qa0KVLF2wKC0N3OTlcuHABLS3NmD/fHK9evcS+3buh1aMH9LTHIivrKRISErgKpg8fPmLv3j148+YNZs2aDWdnJ64u5/bt2zFq1CjMnj2b5zg5g1TLysoQFxeHL1++ols3GbS2tlLmi3QUWpyQEI8jR47g7t27kJaW/j0v3QU3blynvLHwCy1uaWnFokULoaqqipaWFsyYMQOLFy+GuLg4jh07hpqaGjg5OfG8H1Vo8Zs3bxEXtw9v376Dmdk8ODg4cBlvREZGYsiQIR2GFhcWFpGhwAoK8mhsbKS8wfr6+mLx4iWUBROdbou4uDgcPJiMx48fo1s3WaxYsRxMJhOXL18hCylO8AstbmlpxYIFFlBRUQFBACYmrNBNGo2GtLQ0lJWVUYqD7e3tSdaOjaysLCQlJeHDh49YtGgh7OzsuPKkoqKiBIQW05GcnAwajYbc3DzExcUhLy8XioqKqKmpoTyP/Pz8sHDhQkr3KjrdFnv27EZSUhJevHiJ7t3lwGAw0NraiszMTEoDF36hxa2trTA3N4eKiiqXfotGo+HUqVPIzy8gLei518iBZO3YuH//Pg4dOoSPHz/B2toKdLot1xrGxu5G794dhxb/+PEDcXHxKCoqAo3WHz9+VFE+1NjY2IBOp3MJ89nQ09PDhQsXEBISgsePH0NZWZnLDZAKwoYWc2L//v34+PEjtm/fLtTfZ2RkYNeuXXj9+jV8fHzg6ekpdHdbX18f9+/fF4mds7W1hbW1Nd+Cie24xWYPgoKCUFtbi927d4scWqyvr4/Hjx8LvQ3AG1rMZDJx4sQJxMfH4+PHj1i/fj1Wr17N1ZAKDg5Gz549KQ0i9PX1cffuXYiLi+Px48cICwtDSUkJRo8eje/fv4us6dDT08OJEycQFBSEDx8+kPottkaMCsKGFnPi2LFjePjwIWmsIghMJhMpKSm/Gfe32Lx5M1xcXECj0dDGbEFR4Wuc2bEHRV+KUVJcgvr6evwqL8fpjAyIi4vDdhUdoUcToK75Fx7ef4KtW7fi169fmDBhAt68eYPbt2/z7NPJyQlz587lGxXy/ft3BAYG4uvXrxgwYABCQ0NRUVGBLVu2ID09Xeh1ADoX8Ns+tJjJZCI+Ph5Hjx6FmJgYGAwGbG1tub47W7duBY1GEym0uKSkBFZWVrhx44ZIx6erq4uDBw8iJCQEP3/+xLBhw7jiKaiwYMEC+Pv7i+RgmJGRgUuXLglV2La2tiI2NhZpaWn48OED9uzZI3RDCuAfWiwIq1evxsSJE3/rjXnx8uVLhIaGoqCgAGPGjEFISAjKysr+5dBiYREWFobVq1eLbJb0fx1/woj/g1DR2ITC+gY0t7VBRkYGr1+/wtWrV1FbWwt7e3ucPp2BAwf2o6WlGW1tTGzc6IuIiO3YtTMSEhKSKC//hc1btkAMQMHnz1hjbQXLRQtx9GgqGhubeMwmhg0bCg0NDZiamqJLly7w9d2IlpZmGBoakuNT7IweTnz9+pVrtE9RURH+/iw3QBcXFxAEATqdjhEjRsDR0Qk9eigA4M7a4sTdu3cxYEB/0sbd3t4epaWliIuLw/Xr1zFy5Eh8/foVAwcOJLfhx0gBQFraCcydOxdOTk5oamrCoUOH4ODggK5du6KkpASpv4MoOVFVVUUZWjxq1Ej0798fJiYmEBMTg5eXF9ra2mBsbIxFixbh9evXlM6G7S3i1dRUySLIxcUFLS0toNNtMXbsGDg4OEBOTg4ASxROVWCxLeI5xwALCwsRFxePO3duY/ToMcjJyeEaSeLHSAHAqVPpMDGZC1dXF9TX1yM5ORl2dnaQlZVFcXExDh06zLNNTU0NpUX8+PHjce/ePcyePRsEQWD16jUAgLlzTWBubs7X2TAnJ4fLSKFv3z4ID2exSc7OLmhsbCSdCe3s7MiihTNrixPs0GLOMcCcnBzExcXhwYMH0NbWRmFhIdd6tHc25MTZs2cxe/ZsMu8qKSkJDAYD8vLyKCoqIrvonGCHFrc35Jg4cSKeP3+OmTNnoq2tDatWsay158+fDxMTE8qsLYA3tFhLSwvbtrFyjJYsWYmamhbo6+tj9uzZ8PHxIW/qnz9/piywbt++jf79+1OOy+Tl5WHkyJE84zJMJhPl5eUiW8QfPHgQ58+fF/rvLSws8Pz5cyxatAhNTU2YNm0aJCUl4ebmJtBcgR1a3BmLeEGMlKqqKte4TEhICG7fvo0ZM2agpKRE6C7/v2IRz9n0otFoJLvJaeMuIyND2pdfvnyZkm1hhxazCzJdXV2cO3cOTCYTRkZGcHNzE+n42KHFGhoaZPDzw4cP4e3tjdLSUhgYGCAwMJBrfFOU0GJOJCQkCF2M0Gg0MBgMFBQUYO7cuSgsLISBgQHk5eWxfv16TDMyxKn3r5EUuQXdG4ADe5NQXFQMR09HNHQXR1VPGahrjodEFylMmTIFU6ZMAZPJxJQpU1BeXo5JkyZhxYoVXGOAr1+/Fhha3L9/fxw5cgQAcOPGDaxcuRJPnz6Fqakpamtr+bJJ7fE/ZRFPo9HIe0hVVRXCwsJgYGCAnj17YuPGjZg0aRLOnj0rsiFHUFCQyOcR2yJ+2LBhZOPi4sWLsLOzQ3V1NWbPng1vb2+e62lnLOJjY2Mp7/1UEBcXx7p168gMvUePHiE6OhrKysoIDAwU2JDqrEX8kydPBIYWjx07lmSvMzIysGzZMrx69Ypk4IVtSHXGIp7JZKKuru5PgSUC/hRZ/0ZobG1DQV09altaAQBv377Dhw8fUFZWhkWWi3Dn9h2cPp2B+voGNDc3wdPTC3Fx+xARsR2zZs+CyRwTFBTkY/PmzdgaGore3bqhKDcH64+l/mZRCvgG6L59+w6enp6g0WiYMWMGWlpacOTIUaxYsQIlJSW4ffs2pk2bxrVNQkIC6UrTHg0NjUhJOUiOAW7Y4IPm5mZoampiwADqcaPU1FSe9HAlJSX4+vri27dvcHV1xd69e0n9lpOTEy5evMj3wYWtIwNYY4COjo5wdHTEt2/f4OLiAicnZ6iqqsDJyQkDBrDyvzizttqDbRHPtnJvaGjEoUMpWL58OUpKSvDw4UOeY2G59tl2uEbnz7P0W0wmEwMHDuQ7L08VWqympoaAAH/Y2/+Era3t7zHAKmhra8PBwQEXL17k6y53+fJl7NnDmmeXkZEhrcu/fPkCFxdXuLi4oE+f3nBxcSVH4jizttrjxYsXWL169W8Nl8Vv/dYBLF26FKWlpXj+/DmPFomdtUWFpqZGHDp0CEwmExkZGXB3ZxVpI0YMh4ZGX8ptqEKLNTQ0EBYWBgbDDosXL0FYWBhqa+ugq6sDBoOBCxcuUDobAsD58xfI0GI5OTmymP7w4QNWrVoFV1e33/otV9Kif//+AzA1pba+zsrKIlm7JUuWkPqto0ePoqSkFG/fvuWZ/WdnbVGhS5d6PHv2Gq2trdizZw9mzJiBLl26YOLEiXxH+7Zu3crDCLQfl6HT6eS4jJeXF44ePSpyaHFtbS0IghD5pnzt2jWSkVq/fj0ZnhkZGQlVVVUEBgbyPFx1RiMlqkX8uHHjkJ6eDgMDAyxatAhLliwhc/jWrFkj8AGnMxbxERERAi3i2Tbu/v7+yM/PR1BQEIKCgpCfn49Pnz7xFDLs0OL2oNFoaGxsFDkgmSq0WF9fnyzcjhw5gvnz56OtrQ1LliyBq6sr0tLSRA4tbmxsJIOLRQF7tE9cXJzUbwUGBsLb25vlBCvRGwpaPXAx7wtSU49BUrob1q7egAWz50GiC3czkkajobW1Fe/fv0dtbS02b95MjgHOmzePskHDD0ZGRjAyMoKuri4mTpyI2bNnQ0xMDCtWrICDg4PARsG+ffuQlpYm0jpERkYKDC2Wl5cnmeYvX74gMDAQa9asQV5eHgoLC9GvH7WLLBWeP3/eKYv4wEDu6BNO/da+fftI/ZajoyOWLl2K06dPi+R4CPxTbIpqEX/q1CncuHGDbFB31JBifyZ2TICwENUi3sLCAhYWFtDR0cGAAQP4xlNQoTMW8Xfu3MGUKVNE2ua/HX+KrH8DMAkCJQ2NKK1vBOfw5tUrlzFu3Di8efMGd+/cQX19HWpr6+Di6oK0E2k4duwYeeE3nGoIALh+9RpW022wcPYsfP78GbGxsWAw7DB06BC8efOG8iHk69ev6NWrJ9cXW0JCAgyGLT58eA93d3fcvn0bKSkpUFRUhLOzMwYNGoTiYurAytu3b5OhxTQaDcbGxjA2NkZTUxMsLS0hLy8PFxcXWFtbkw9t7Kwtqq4w2yKeU7915coVeHt749Onz2AwbNHa2so1LsNmpKgs4k+fPo1169bBxMQEb968QUxMLCoqyjFq1Gi8fPlCKEYKYJlKODs74/v3H3B2dsbVq1eRkJAIVVVVuLg4Q0tLi6/17f3796GlpUmu0bx5ppg3zxQNDY1YvJi1RitXrvqt39Ij14gza4sTbIt4ln4rBkwmE5mZmVi3bh0+f/4CZ2cnnsBbdtYWlUX8+fPnsWbNapiZmSErKwsREdtQXV2Dv/4ah6ysLEpGiipsVkZGBu7uq1BYWABbW1tkZJxGbOxu9O3bB66urujduzfy86m7kU+ePCEZORqNRuplamtrsWSJFRQUFODu7g4Gg0FuL4iRysjIgI7OBOjr60FfX++3fisdq1atwtev37Bq1UqeNWqvI+PE1atXsWrVKlhYWODBgwcIC9uE2tpa6Onp4enTJ1i58iDPNqzQYm5DDjk5OXh4eMDf3x9WVlY4ejQVkZGR0NLSgqurK1RUVHiyttjIysqCllZvAC0QF5fAmjVrsGbNGpSXl2Ps2LFQVFTEvHnz4O/vD11dXXKNOmKkOPVb7PDM9+/fY/v27TxrJAicocXCgoqRah+eyR6XGTt2LIKDg6Gqqtqp0OLOWMSzGSm2yUlTUxMiIyNJ/Za7uztPo0bY0OL2uHTpEu7duyfU3/bu3ZtkWZcvX46NGzeiqKgIurq65Pjg+/fvubK22BBkEc8PTCZTYGgxjUaDjY0NbGxsUF9fj4iICEyePBmfPn0S+SE8IiKC0mxCEKgs4vv164eUlBQ4Ojpi4cKF8FjnhdLSUlRUVKOrlBq6y3XHpw9fkZLMO6qVlZVFXldkZWXJCIcfP36QI52i4MSJE5gwYQKcnJzg5OSE6upqUr/Vo0cP+Pj4wNDQkGsbtkbqf9MiftCgQTh27BhcXV0xZ84cODs7o7KyEjNnzoSvry/ltZCNzmqkBDFS4uLicHd3h7u7O6nf2r17N758+SJykRAdHS1ygC6bkeJ8luBsSJ09e5bUb82dOxdeXl6QlpbuVGhxcHAwOQ0kLM6ePYsxY8ZwxVMEBweT8RQBAQE8a9sZQw6Adc9r3wj/A8H4o8n6/4zalhbk19ajqY3J9XpTUyNOnz6NT58+o6qqCjU1NbCyWoLbt++gpqYW5hbzMWXyFJSUlmDH9h0s4XZLCxpLCpF+4gTPQ9Dhw0dw8OBBaGj0haGhIZYuXQoJCVYOj7e3NznW1x50Oh0pKSnkzx8+fERSUiJ+/vwJgiCwf/8BcgyQDRcXF2zatIknT6u1tRUODg44ePDg7zHAeHz9+hUqKspQU1ODrKwsJTNmZ2fH5WzIRlVVFTw8PKGnp4v79++ja9euWLp0KSZPnozt23dgxIjhlA8UnNoWNphMJg4ePIijR4+iX79+mDlzJiwtLckbtI/PBixbtpTSXYhOt0VKykHy55cvXyI5ORm5ubkQExPDwYMHyTFANlauXElmbbVfI3t7B6SkHCTHAH/+/Al1dTX06dMHNFoXuLrydseodGQAq5Bas2YNxo8fj8ePn0BWVhZ0ug10dHSwa9cuDBw4CPPmUenI/tFIca7R/v37cezYMWhp9efSbwEd68g41+jp06c4dOgQCgsLQRDA4cOHeG7e/HRkTCYTDIYdUlIOIicnB/Hx8cjLy0e/fhro21cDTU2NlM5HVBopgFVIrVq1CmPHjsWLFy8hL98dDIYdtLXHIiYmBn37asDCwpzyM7U/j9g6xLS0NAwYMADz55tj7lwT8m/8/PxhYWFO6SzYfo3u3buH1NRUlJaWAmBlj7X/93V3d4e3tw/69p0M4J8uP5PJhIGBAR49eoR3796RrlnDhw/HkCFDUF5eTjqPCYPa2loYGRlBT08PT548gYqKCvz9/QWOywCd00jR6XQsX75cqIIpIyMDu3fvRklJCQiCwPPnz4Uel+FcI1EwdepUnDlzhrJgKioqQlBQEF69eoXevXsjKCiIzL1RUlKiNHDhh5ycHNjb2+Pq1asiHR+nzoLJZOL48eOIj49HdXU1CILA06dPeZwAWQY92wXqqNrj6NGjePLkiUgPko2NjZg0aRJGjRqFDx8+QFNTEyEhIWRwND9w6siEhYODA8zMzChZ9/ZrlJycjJSUFFRXV4PJZOLly5c85+z8+fMRHh7OM2LVWa3dtGnTkJaWRlkwffv2jdRvDRo0CJs2bYKWlha2bNkCcXFxrF+/Xuj9FBUVYdmyZZ3S2nGuUVxcHFJTU8lRTDqdzrNGFhYWCAoKEolhSk9P55o6EQbNzc2YMGEChgwZgtzcXAwbxjIn6chMZeLEibh586ZIDoYrV67E1KlTO2R52Q2p9PR0tLS0oLW1FVlZWSJd+zqjkZoxYwYO/c52a4+XL18iJCQEhYWF0NbWRkhICJSVlbFz507U1dWJZHrBbpQEBweLdHz/Lfijyfo3A9vYoqKpmfL3jx8/xvv3H1BYWAhjY2N8+PABX758RUtLM+rqatG3D6vrmHHqFBg2KzDHQB/Znz5i3759lF/qN29eIyYmGoMHD8aRI0fh5OQESUkpLF5s2QEjNZDrtWHDhiIyMhKurq6YMWMGNmzYgObmJhgZTYe19W/L+MZGngIL4A4tVlJSQkAAq2Pz7t07rF69Gurq6qisrISTkxNpKlFVVSUwtHjRooWYM2cOHB0dUVxcjISEBCQl7Udubg7lg/H3798pLeJpNBo+ffqEXbt2YfDgwaR+S0ZGBsuWLUNRURFlgcXJSLExduxYREdHw83NDZMmTSJnutn6LQCoq6uj1JGdPHmSHKVRU1Mj9VsvXryEp6cHevfujcbGBi79liBGijX+uADz5pnCzc3td+EWhz179iI3N4fUUXDi58+fPIwUe41+/PiByMidGDJkMA4cOAA7OzvIycnBxsaGr46MKrR4woQJmDBhAtzc3DBhwgSSGZs71xTz57MeivjpyDgt4jU0NBAeHg6A9Z3ZsGED+vTpQwq52QWVIEbqwIEDmD/fnDxffv78iYSEBERFRSEvL5fUUXAiNzeX0iJeXFwc+fkF2L59O4YMGYLExEQwGCehoCAPOzs75OXlURZYT59m8TgUTpo0CZMmTcLKlaswcuRIrFzphi5dusDCwoI0oamurv69HSuUmPMzsVniESNGkONF58+fB4PBwNevX3mOQRA2b94MOzs7cvyFc1xm1KhRCAkJ4bnJ//jxg/I86gifPn0SmpFij8vMmTMHo0aNEugG2B6HDh3qlEZKkEW8qqoqKajPyspCYGAgioqK8P37d7x+/VqkfQUGBpKhxcLiwYMHXIwUjUaDtbU1rK2tUV9fT+q3unXrhrVr18LU1BRMJhOlpaUiFVgAK36CytlQECIiIrB8+XJSK3n//n14enqitLQUEydO5NFvASw9Ymcs4t+8eUNpEd/e2ZBGo5Ea4Llz56J3796YOHEiqd9ih/xSORsC3BbxwqKxsVEgIzVgwADSye769etwdXVFZWUlcnJy8O7dO5H2FcwRWiws2lvE02g0uLm5wc3NDZWVlQgLC4O+vj569epF6rcAkOyyKNizZ49IBjIAy0TJysqKHAu/cOECGAwGamtreXSpbJSUlEBSUrJTFvFsF1RBEBcXh4eHBzw8PGBmZgZpaWkYGBhARUUFAQEBfCM72OAXWiwIHTFSY8eOJRnW9PR0WFtbo6GhAbm5uXj//r1I+zp79qzIQdF/8IfJ+v8CtrFFK5P/2m/evBmqqiooLS1FVVU1Fi5cgL/+Go+c3BykHEyBnJwsKioqUZWfhxP7E6HYqxfWr18PBoOB4cOH87xfe0YKAH79+gV/f398/foVY8aMIccA2RCGkQJY7oZsN8CKikqMGDGcHKXgBD9GqrKyEt7e3oiLi8OVK1eQkZGBlpYWGBkZIT8/H6NHj6a0BqZiEgBWF3DTpk1QUFBARUUFRo4cBScnR8jLy8PHZwOWL1/Ox9mQd41YnelgfP36FePH/wUXFxcuDQc/Z8P2a9TQ0IiDBw/i0aNHqK6uwrBhwyjXiMq1D2AVUh4eHoiPj8f58xdw5sxpEASB2bNnIzs7G0OGDOXDSFGv0Y8fPxEUxHqgqaqqxrhx2rC3t4esrKxIjBTAeggKCQnBt2/foaenBxcXF66CQTAjxSDXvLa2FgcOHMCzZ89RW1uLYcOGknbq3GvEn5Fau3btb4H8KVy6dIl0A/z+/Ts0NTUpdQn81ig3Nw8bNmyAgoIC6upqoaurB1tblhugKIwUwCo4wsPD8ePHD0yaNPl3/tY/Y5/u7u7w8fHh6cRysnYAq+nAyt96g4aGBgwePPj3GkkB+OecnjJlCjIzM3m0UOyMLEE23VTQ09PDgwcPKAums2fPIiYmBnV1dTA1NYWnpyekpaUFOhvyw71797Bnzx4cO3ZM6G3aM1LscZkXL15ATU0NgYGBlA9+U6ZMwdmzZ0Ua4QsMDISysrJID63Z2dkwMTGBsrIympqasHDhQqxZs6bDoqEzXW1TU1Ps2LEDQ4cOFfh3eXl5CAwMxLt379DW1obhw4eLNHrV2NiI6dOn4/79+yIdHz9Gislk4vDhwzhw4ADa2tpgZWUFFxcXiIuLw97eHhYWFiJZYT958gSmpqag0+kICAjg+h4IYqTYTC3A+s4GBQXh8+fPkJCQQP/+/XnuD4BgRoofwsPDIS0tTWkoxQ8FBQWYOnUqqSeytbUFg8HosInRmfNIWEbq06dPCAoKws+fPyEpKQlNTU2RzqPmZpbBFlX8hCAYGBjg1q1bPAUTW5d64sQJiIuLw8nJ6bc7MatINDIy6lCrxInXr18jMDAQp0+fFun4ONecsyE1evRohIaGUmrCpk+fjsOHD4s0wrdz507U19eLNGJYWFgIfX19qKurQ0pKCqtWrRJqFNfHxwdbt26FmJiY0Pv6b8IfJuvfAO2NLfihsrISY7XHogutC3Jzc1FWVoaqqiowCSZOpadj2fJlGDloEHrLyuDB7dvw9/NDU1MTiouLKXUWt27dwsCBvK/36tULBEEgNfXYb/v1eJSVlWHo0KFwcLDny0j9/fffXAG9nG6AdDodXbt2BZ1uC2VlJTg5OWHQoEGorOTN2mIjMTERCxYsAI1Gw+zZszF79mw0NTXh8OHDuHDhAn78+AEZGRku0T1n1lZ7JCQkwNPTE6NGjfpta34Z69evR2trK4qLSzBsGO8DyL179yhNAlRVVdGlCw2pqUdRXFyMqKhoVFZWYMyYMbCzs+PrbNg+tJjlBugCV1cX0Ol0dOnSBXS6LdTV1eDs7AxNTU2BjFRiYiLmz5/Po986eDAZ586dw/fv36GkpMglKOfM2uJdo3isW+cBbe2xYDKZOHv2LNauXQuCIFBSUkKyQ5xghRZr8rzeu3dvSEhI4siRw8jPzyf1W+PH/0V2F6kZqXSu45WVlSUZrRUrVqCtrQ10ui369dOAs7MzevfuLZCRYocW02g0WFougqXlItTW1mL//v3IyMjAmDFj0K+fJlfxyHI25BdaHAcPj3X466+/0Nra+lu/xXIDLC4uxqZNvDbw/EKLtbS00LVrV6SkpCA7OxubNoWirq4eBgb6sLGxQXV1DeWoS/vQYnl5eVJXuWLFCjQ0NIJOt0X//lqwt49Gnz5aqK2tBQBKs4nw8HDK0GJBoNIjcoI9ktXa2oro6GhMnz4dEhISyMvLo3ReFIQtW7YIdNaiQvvQ4vb6Lapxmfr6ejCZTJE1UleuXBFaI8VGYGAgIiMjMXv2bDQ2NiIyMhJTprBCgdlugO3BdhEVBWwHtI4KLADo06cPDhxguViOGzcOJSUl0NHRgb6+PoKCgjo0mOAXWiwIeXl5fBkpGo0GOp0OOp2O+vp6bN26FZMnT4acnByys7Oxf/9+kfYVFhaG69evIysrC/PmzUNbWxuWLl0KZ2dnvozU8ePHSd0iwPrOsguGixcvIiYmBnp6epg6dSr8/PzQvXt30pBDVI0Uv6wtQQgJCcH27dthbm7Oo9/y9fWlNCR49uxZpzRS/LTE7TFkyBCShRozZgxyc3Ohp6cHY2NjbNiwQaB+C2AVCfws7/mhpKSEb2ixuLg4ly41NDQUsbGxUFJSwvfv3zsVWizKSB3AG1rMqd86c+YMli1bhvr6epiammL9+vWQlJQkXZJF/bdKT08XeQx08+bN2LJlC6ytrVFSUoKgoCBs374dampqfAvr4uJiKCsr/ymwOgOCIP5t/vvrr5EEQWT9n/uvjfmUKKy7S7wuvUq8EuK/iCNexM3Px4lXpVeJ43djCfsAU8JvjwNh7mZAzFgxiiitv0cwmU+59nHt2jZi2bKhBIMxmnByGk9cu7aN/J2z83iipOQiz3G1tDwibG1H8bx+9epWYt48dWL2bCUiJWU10dz8kOv3DMZoorHxPs925eXXCEfHceTP794dIjw8phI2NiOIRYu0iJMnfSnXx8ZmJNHW9oTn9S9f/ibWrJlElJRcJEJD5xM2NiOJ9euNiK9fjxPe3tOJ168P8nm/EZSv37ixnViyZCBBp48kXF11iLt3o8jfubrqEEVF5ynXiE7nPi/b2p4Q584FE6amasTs2UrEsWNeREvLI541qq+/x/N+1dU3udbo+fMkYvXqiYSNzQjCymoQkZa2QaQ1+v49jVi9eiJRUHCOCAgwIWxsRhC+vsZEdvYpYsOGmcSLF0l834/q9Zs3dxCLFmkRdPpIYuVKPeLx473k79zc9IiCgnM827S2PuZ5v7a2J8SpU/7EvHnqxKxZikR6+kae47ezG8NnjW4R9vZjyZ8fP95LrFypR9jYjCSWLx9GnDjBb41GUK5RdvYpwt3dgMjOPkX4+hoTNjYjicDAuURBwTli48ZZxNOncSKvkYWFBkGnjyRWr57EtcYrV+oReXlneK8BbU94zqOWlkfEsWNe5HmUmRlCsUZjibq6OzzvV1d3h7Cz+2eN7tzZRZibTyF0dXUJfX19Yvfu3QQVdHV1iba2Nsrf8cOyZcuIa9euibTN6dOniQEDBhC6urqEmZkZ8fTp0w63aWtrI/T09ETaD0EQxOTJk4mqqqoO/+7kyZOEkZERYWBgQBgaGhLR0dEi7efnz5/EzJkzRT4+HR0dytfz8/MJBwcHQldXl1i4cCHx5s0b8ndz584lPn78KNJ+UlJSiLVr14q0TUNDA2FgYEAQBGv9Dx8+TEyZMoUwMDAgoqKiiJaWFsrt9PT0+P6OHxgMBnHu3DmRtjl9+jTRp08fQldXl7CyshJqTdra2njWvK6ujvD39yf69+9P9O7dm/J8njp1KlFWVtbheycmJhKTJ08mJk2aRJiamhLbt28X6TMVFhYSRkZGIm1DEKzvLhU+f/5MWFtbE7q6usSKFSuI79+/k7+bP38+8eLFC5H2c+LECcLV1VWkbZqamgh9fX2CIAiipaWFiI2NJQwMDIjJkycTBw8e5HvN0dfXJ5qamkTal6urK3Hy5EmRtklLSyNUVVUJXV1dgsFgELm5uUJtx2/NBcHIyIgoLCwU+DctLS3Ejh07yGuRtbU1ERYWJtJ+SktLialTp4p8fDo6OpT/Hs+ePSPMzc0JXV1dwtXVlSguLiZ/FxMTI/Sa/bcCQBZBUdf8YbL+l8HP2EIQHj58gPz8fCxYsADnzp3DihUrWO5ZL57jw+OHUKRgOtLS0hAVFQVFRUWUl5cjPj4ehw8fRs+ePVFZWUnJSB07xs1IsTFjxgwcPXr0dwjfSTg5OUFKSgpLlizB2LHakJCQ4MNIJXDRzsOHD0dkZCQIgoCFhQUuX76MzMxMUr8lLi7Ok7XFiYSEBNjbO/zWb7G6Se/evcOePXvw7NkzKCoqQkOjL1coMCtrawDluqalpSE6OhoqKiooLi5GXFwcEhOToKyshMrKSj5ZW2kwMDDgeo1Go8HU1BSnTp3Crl278Pfff8PR0RFdu3bF8uXLMWLECMqsLdYaJXKNrLHcAKPBZDJhYWGBS5cu4cKFC5g9ezYWLVpE6qD4MQkJCQlgMBhQU1MjA3afP3+OHTt24NWrV1BRUcHAgQO5MlgEdcnT0k4iJiYGampqyM/Px759+7Bnz57ferkKAYyULtdrLAt3c2RmnsP27dtx9GgqGAw7yMnJwtbWFkOGDKHM2gKA/fuTuLr7Ojo60NHRAZPJhLm5OS5duoTLly/B1NQUZmZmoNFoPFlbnIiPj4etrS00NDTIEc1Hjx4hPDwcb968QZ8+fTBixEiuY2FnbVHh5MmTiI2NRe/evfHjx08kJMRj164oaGr2Q0VFJV9nw7/+4p4kEBcXh5WVFa5evYbw8DAcPXoUJ06kQUFBAfb2dqQekpq1O4C5c/8xdZk8eTImT7ZAa2tvDBw4EKmpqThx4gTXuExHjBQ/fP36VaSRP4C15hcvXsSgQYPw5s0bclxmzJgxfMdlDh48yMVICYO6ujowmUyhLOLZ7pTNzc0YOHAg/v77b5w+fVoo/RbAYqREGe8CBFvEq6urIzExEQCLAfXz80NRUREmTJiA4uLiDs0g2mP//v0ijzVt27aNtIin0WhYvnw5li9fjvr6emzfvp3Ub3l4eJAmQu2ztoTF+/fvSfZMWOzfvx+XLl3CiBEjcO/ePXh4eKCsrAyTJk1CQEAAJRP5999/czFSAOs7tGnTJty7dw+7du3Czp074efnBy0tLYSGhqJv375oaWlBr169BB4PjUaDg4MDHBwcUFtbiyFDhqC0tBTXrl2Dt7c3jIyMOvxMgYGBlO6sgsDpbNgegwYNInOfOPVb06dPR15ensgaqb179+L48eMibbNz507yviYuLo5Vq1Zh1apVpBvgvn370KtXL/j5+ZH3U0GMlCA8f/5cZEYqNTUV58+fx7hx45CZmQlbW1vU1dVhzpw58Pb2psyyysjIEHntWlpaUF9f36FFvLi4ODw9PeHp6YmysjKMGjUK3759w9OnT+Hv79+hfgtgsWyurq4iHd/bt2+hrKxMeQ8YN24cqd86efIkmcNnbm6O0tLSDk1F/oAaf4qs/yV0ZGzBD7m5uZg+fQakpaWxd+9e5Ofn49nTJ3BabIm96WmUGpXW1lYuEW3Pnj1JQWhkZCSys7NBp9ti6NAhcHZ2JkdBbt68QenoU1FRCQkJCcjKyoLBsAWDYYuysjIkJCRg8+bNUFZWxpcvX3hGE9+9e09pEf/t2zdoamoiKiqK1G85OjpCSkoKDQ0NfNPki4t5Q4tHjBgBCwsLKCgoYNSoUeQY4IwZM7B48WLKrC32GnGO9qmoqCAoKAgAsGPHDnz58gV0Oh2jR4+Go6Mj+dB29epVyjViG3LIy8vD2dkZzs7OKCwsQnx8HIKDg6GsrIyfP3/yFDOvXr0mRd+cyM7OhqamJqKjo8kxQDs7O3TrJovGxga+rmQFBbxjHePGjUNDQwN69OgBLS0trF27FkwmE3PmmGDhwgWUWVvsNeIc7evduzd5vm3fvh3v3r0DnW6Lv/4aRwYWAyybaXbWFifYocU9e/aEuztLw5Kbm4e4uDhkZT2FiooK8vPzeR4e+IUW5+XlQVNTEzExMaR+i8Gwg7x8dzQ0NPC94VCFFrPHFDMzM6GoqIhVq1ZCTEwMZmZmMDU1pczaAngt4rW0NLFlyxYALFF/ZWUl6HRb6OvrgU63JQu3CxcukllbnGCP9qmqqpIP8D9+/EBcXDxevnwJVVVVFBcX8zQAqEOLa5Cbm4uhQ4fi0qVLKC8vR0hICGJiYqCsrIzGxkbKzyQIt27d4tu04If2FvGjRo0iQ2T5jcsArCIrMzNTpH1t2bIFS5cuFWmbwsJCDBs2DJcvX0ZxcTGCg4M7HJcBWPoTQaHF/I5PGIv4CRMm4MyZM2AymaRBzcSJE7Fw4UKsXr26w4KGbcjRo0cPkY7v0qVLlGNrMjIyZOZWTk4OgoKCEBoaCg0NDTQ1NVHGXAgCO7RYFDCZTBQXF5OmTJMmTcL58+dJ/ZaZmRmYTCaWLl0KFxcX8sExISGB0pCDPdo3duxYcgzwzp07WLNmDd6/f09mBAqL6upqDBs2DNeuXcOPHz8QEBCAjRs3YsCAAQgNDeX7vekotJgKYWFhZBNNEKZPn04adTg4OCA/Px9TpkyBra0tbG1tO2ywUIUWC4MzZ87g9u3bPK8rKCiQ5/+HDx8QEhICDw8PDBs2DE1NTSKvOfuaKCo4LeI54yl2795Njjc7OjqSDSkA2L17N2k+Iiw6YxEPAEOHDsXNmzfx+vVrhISEkFp0fg0pAJ22iG+fR0aFRYsWYdGiRWhubsb69es7NXL6Byz8KbL+FyCMsQU/ZGVlYc6cOZCWlobOhAmQF++C66cz4OHmhuzsn3j58iVmzJjBtc2xY3/zDYh79+4dUlNTISUlhWvXrsHXdyOam5ugq6vLN0cqMTGBRxyqqKiIjRs34tOnz/DxYZlUlJWVYdiwYXB2dsGvX2U8WVtscIYWc+q3SktLYW1tjYiI7VBRUYaTkxPZvadyNmQjNTUVoaGhUFJSIvVbhw4dgr29A7Kzf+LTp088N4m0tDS+TmLv37/H8ePHISEhgUuXLsHLywutra2YPHkKxMRolGuUlJTEY6KgpqaK4OBg0Ol0rF27Drt2RbH0dWPHwMHBAWVlZXyZhLi4eNjZ2QFg67dc4erqisLCQixfvgK7dkVBXV0NLi4uZDCkIEaKXUipqali/vz5qK+vR3JyMhgMBnJycpCbm8OTt9VeI8WJjx8/4vjxE5CSksSZM2ewZs1aAASMjIwgJkatI9u/fz/mz+deo759+yA8PAx0ui1WrnTD1q1bf+u3xsPe3g6lpaWQl6dmpFihxaw14tRv5eTkgMFgIDo6Bv36acDFxYW8KVA5G7Jx+PARbNzoi969e8PS0hI1NTXYv38/uUalpaU8BWBGRgbf0OJPnz4jLe0EJCUlufRbbCdAfs6GnIwUwNKCbNu2Fba2trC3t0dISAjq6+thYGAAOp2OkpJSyMnJUqxRE4KDN5NNi549e5I34bdv32Lq1KnYuHEj3/BMKmzbtg27d+/u8O84kZyczDe0eP78+Zg/fz6am5sRHR0NQ0NDSEpKws7OrlOhxdevXxfZfCEwMJBsBqmoqJBNlOfPn5P6rXHjxpHNEkD00GKAVST8+vVLJEaKRqPh/fv3ePv2LaSlpbncAFevXs3X3SsiIgJLlvBmOwlCTk6OUIyUhoYG6UL68OFDmJqaoqioCFevXkVgYKBQhd2mTZtEigwAgGPHjlFej9rrt7Zs2QIDAwN0794dq1evRktLC6WmbMeOHbC0tOR6bcqUKZgyZQoMDAxELhyDgoLIa5CWlhbpQnrz5k2sWrUKFRUVXPotgNfZUFjwc7flBzZz/ebNG0hKSiIsLAwTJ05Ejx49uNwA2yMyMpIn402YY+vatWuHjNSwYcNI/dbFixexdOlS0nXTx8enQ/0WwGJv2M1RYXHq1Cloa2vzvC4uLo61a9di7dq1KCsrQ2hoKGJiYqCkpIQNGzagoaFB5IIuIyMDN27cEGkbztDi0aNHkw2p06dPY9myZWhoaMC8efPg6elJrvHr169FCi1mIy+POm+RHyQlJaGkpAQ3NzeR9vMH/+BPkfU/CGGNLfiByWxDS0szpKWlISPeBb1lZdBVXBwMWzrEu3RBZWUlnj59isOHD0NRURGOjo6/OyA3SNtgTrAZKXaRMGPGDMyYMQMtLS1wcHBAdXU1nJ1dsGTJYq4xB36MFDu0mD0GCLCYng0bfPD161cYGxvzhAID4OpGcuL9+/eYOtUQAQH+5BhgeXk5RowYgU+fPmHr1q0827BDiznHH6WkpODo6AgZGRkUFxfj1q1bSEraD1VVFTg5OWHAgAEdMlLsNTIxMYGJiQkaGhrh5OSImpoauLm5YdmyZVxF2uvXbyhvyt+/f4eCQo/fY4BRYDKZuHDhAjw8PPD9+w/MmTMbbW1t6NKlC9d2RUVFGDNmDOX7TZ48iXRLi4yMRFVVFbS1tfH+/XuEhPB2N6lCi2VkZLBy5UooKiri58+fyMzMxJ49e9GnT2+4uLiib98+uHLlCnbv5rWqbW/IwbbNrq+vh5OTE2pqWDlTdDqd6wL+8iU1I8U25OAcAzx9+jTc3Vfj58+fMDWdSxl4m59PbRGfn1+ASZMmISQkBI8fP0Z4+GbU1tZCR2cCXr9+g+Bg3psyk8lEbS13aLGcnBzWrl2LkydP4uPHjzhx4sTvMUBN0g3wwoULiI2N5Xk/NiPFflBYsmQJlixZgpqaGri4uJB5Zfb29lwPS8+ePad0qmOHFrPGACejtbUVaWlpcHNzQ3Z2NubPn0+5RoWFnylHlkpKSjB79mwcPXoU586dI8MzTUxMsH79espxGSaTiYqKCpGZrJSUlA4ZKUlJSaxfvx7r169HSUkJZs2ahcrKSpibmyMwMJBvMCknqEKLhQG/0GLOcZm0tDQsWbIETU1NMDc3x40bN0TuGh8+fPhftoj39/eHv78/CgoKEBQUhM2bN6NPnz4ICQnhuqZevnxZZCOFoKAgkS3iARZb8vfff+PIkSMwNzdHa2srrKys4OrqSlmwdRRazA8JCQkdBvyyxwA3bdqE7OxsmJqaorq6GtbW1ggNDeWatrhw4QLu3LnD8x5UocXC4M2bN+S4JyemTZuGadOmkbmCc+fOBcAyqsnMzKR0lRWEEydOCDU+xon2ocUREREAgC9fvpBNhiFDhiA0NJRs2gEsp1AqRkoQgoODRcp/A1jNDUNDQ6SlpWHfvn0wNjZGly5d4ODggGXLlvH9TrMNbETB7t27O7SIV1RUREwMa9Lg7du3WLJkCaqqquDg4CB0Q4oqtFgYPH36lNw3J8zNzWFubk42pKZNmwZJSUm4ubnh77//7lRosagW8UwmE3V1dTw5n38gPP4UWf8DYBIEShoaUVrfiH/FEP/Dhw8YPmw41Lt1RS9pKS4nlxs3riM+Pp7sZHz69AkJCYkoLi5CaWkpampqeLp3CQnxlFoDCQkJiImJ4dSpU/j16xcSEhKQkpICJSUlzJo1C4qKvQRopOy5Xps5cyZmzpwJGxsbKCkpwcHBAdLS0rCysoKhoeFvRorX2RBgzc6zRyBGjBiBXbt2gclk4tKlSzh//gJ8fHxgZGQEKysr8gbImbXVHtevX+eyiH/z5i1iY2Px69cvlJaWorGxkecCmJCQSNm569pVGjRaF5w6dQrFxSWIj49DQkIiVFVVMXeuCV8dWXx8POzt7cif2fotU1NTrFixAt26ycLe3h7dusli+fLl0NfXo8zaYiM1NZWk97W1taGtrQ0mk4kzZ84iI+M0/P39MXv2bCxcuIA8Hs6srfZgF1LsgikrKwvbt0egoqICZWVlaGvjbRAkJSXBzIzXAUpGRgZduogjI+MUCgoKEBcXh92796Bv3z4wNTXlm5GUkJAAW1sG1xotWLAACxYswIoVK9ClSxcwGHbo3l0OdDod48ePF8hIHTlyBP7+fgAAXV1d6OrqgslkksVSQEAAOQbIPh7OrK32uHjxEpdF/MOHDxEWFoaammr8+vULYmK8n+nAgQOUFtNycnKQkJDA6dOnkZ2djYSEBERG7oSWlibmzzcX6GxIp9PJn8XFxcm8o+XLl6O5uRkMhh169FCAvb0DRo0aiadPszBsGHWXPCIigtQxzJs3D/PmzUNraytiY2PJcRlnZ2csWbKEPB7OrC1hUVtbKzIjpaysDCkpKXz79g2vX79GaGgombcTHBzMt5scEBBA2QwSBH4uou1haWkJS0tLNDc3Y8eOHXj06BHc3NywatUqoTv9+/fvx9mzZ0U6vq1bt8La2prn9fb6rY0bN6KoqAi6urpwcHDolEbqw4cPlNEYghAeHo7t27eDRqPBxsYGNjY2ZEjp5MmTISsrCw8PD673TU1N5XJaFQaNjY1obW3t0OWQE/369YOsrCxevHiBBw8eYM2aNfj16xemTp36+5pL7WwYGBhIOcItCMIwUjQaDY6OjnB0dERtbS02bdqE27dvw8vLS2j9FsC6Fpw4cUKk4+PHSA0aNIiMR7h69SqcnZ1RVVWFGTNmgMFgCMVItcfLly8RFxcn0jahoaEIDg6GuLg43N3d4e7uTuq39uzZA0VFRfj5+XGdN+np6SIXWJ0Zfxw5ciTk5eXx4sULXLp0iWxIzZ07F15eXpQNKYDVtBBVI8VmpAS59rVvSIWEhOD69etgMpkICAgQqiEFADExMSLZ6wOsiSJR7wF/wI0/Rda/iM4YW/DDt7dv4eXkAGkJCa7XKyoqeUL0hgwZgsjIHdi6dSskJCTIMUBDQ0MsXboUEhISeP/+A6XeicVI9YKYmBg5Bgiwbrpr166FvLw8tmzZCmdnJ66bnKDQ4sGDB8POzg52dqyRr/j4eCQnJyMvL4+yc0fFSAGsG1N5eTmWL18OG5sVOHz4MFm4WVtb802Gr6jgtYgfNWokoqKisH37DrS0NJP6rZkzZ8LS0hLi4uJ4+/YtPD15u7mcFvHsMUCAdVH08vKCvLw8du7cCUdHR64uj6DQ4gEDBpA27qxQ4HjExcUhPz+PL2tHFVpMo9HQ1NSIpUutYWNj83sMkKWRotNtcOXKFb4aqfYW8ePHj8f48eOxc+dOVFVVkWOAJiYmsLCwAI1Gw8uXr7BmzRqe9+O0iO/Tpw+p32I/BMrLyyM2djfs7e24RkH4MVIPHz5C//79ucYA4+PjERsbi4KCAkREbOfZhs1ItTfkoNFoEBOjYfFiS9DpdCQlJZH6LQbDDpcuXeTLSLW3iNfX14e+vj6ioqJQXFxMjgGamc3H3LkmoNFoAhipXJJt0dLSIvVb9+/fh7f3enTvLo/4+HjY2NC5/l34hxY/haamJqnf+vbtGxISElBUVIyioiJs27aLco0qKyt5igtxcXGsW7cO69atI8dloqOjoaysjICAABw6dEhkjdTmzZuxfPlykbZhnUes79rYsWNJPU1GRgap35o/fz48PDy4roGfP38WOrSY8/hEYaQkJSWhpqYGBwcHeHl5ITg4GNu2bYO6ujqCg4P5jnB11iL+6tWrHTJSnPqt48ePY8aMGejVqxeioqKwatUqoYqthw8fcoUWCwN+ocUyMjIIDg5GcHAwcnJyEBgYiJCQEGhqaiIkJASJiYkdMlLtERERwTPa1xE4Q4vZY4BMJhPJyclYsmQJWltbsW/fPjg7O3M1Nt6+fUsZWiwIYWFhIjFSsrKyGDduHGxsbLB27VoEBgbC19cXgwYNwqZNm/iOonYUWswPwjBS7AYpk8lEfHw89PX10aNHDyQnJ4NOpwvFELcPLRYWRUVFPNrH9vqtoKAgrFu3DsOHDyeLr86EFosaoFtaWkoacnDGU8TExJANKRcXFyxevJhrjYQNLeaEqBbxysrKMDY2RktLC9zc3LgaUiEhIZTmXUDHocX8cO3aNUqN+x8Ijz9FVifRWWMLKkjQaOjVRQxv7tyG3/dvcHBw4Mpyio+P4xug9+HDRzKotKWlBUeOHIWTkxOYTCba2tooOyQstsWe5/Vhw4ZBVVUNKSkHcfXqVfj6+qK5uRlGRkZQV1fnq5FiMVKbyJ+VlJTg7++P1tZWLF26FMePH8fevXsxYsQIODo6oUcPBZ6sLU7cuHGDZKTYTk4lJSWIjo7Bt2/fERAQAGdnZ64xpqQkVtYWFd6+fUuGzbL1Ww4ODgAAguAduQL+cTZsj9GjR0NNTR3JyQfIMcC2tjYYGxtDXV2d783y6NGjXLPkampqCAkJRmtrK6ytrXH48GHExsZCW1ub7Ey3z9rixNWrV0lGys3NjRTLR0dH49u37wgL2wRnZ2euByl21hYVXr16heTkZNBoNNTX1+PAgQOws7P7/cBGCHDtY/C8PmHCBKir90Zy8oHfY4DuAMRgamoKFRVlvjoyTkYKYGlBwsPDwWQyYWm5GPv3J6GmhjUGyGAwICMjg/T0dL6M1KVL/zBS7E51dnY2YmNj8fXrN2zbtu33GOA/BRo7a4sKL168JM+jmpoasnCTlmYV9vwYKVtbW57XJ06cCHX13ti/PwknT54kCzcLCwsoKipSZm0BrFG8DRs2kD8PGDAA27ZtA5PJxKJFi5CQEIvXr2NhbDyXdM1KSkrCtGnTKN+PjfbjMn5+fnj9+jU8PT0REhIi9M35xo0bIgeLBgYGYv369Tyvs8dSm5ubERUVBUNDQ0hLs853FRWVTmmkOA05hEVyMiuLTl5enuzYZ2VlITAwEIWFhRg/fjxCQkK4HoQ7Y8iRk5MDOTk5oRkpGo0Ga2trREdH49atWySb1K1bN6xdu1ZgeG94eDh27Ngh0vGlpqbyOK22h4aGBpmNdv/+faxZswavXr1CWFgYAgMDhS46L168KPL4IxUjRaPRSA1wbW0tqd+Sl5eHt7c3unfvLrJGislkoqioSOTxx7i4ODK0mG2ocOPGDdINcNq0afDz8+Nygo2MjOR7X+MHYTVSbNBoNLi6uiIlJQWXLl0i87d69eoFX19fvvdp4B9GShScPHmyQ/Zl2LBhJHt34cIF0Ol0PH/+HPv27YOPjw9fNqk9Tp8+jVu3bol0fMHBwTwaJHFxcXh4eJDuliEhIYiKioKKigoCAgIgISHRKUOO/Px8kUdBY2JicOTIEaipqZENqfT0dFhbW6OxsRFmZmY8Dano6GiRwrwBVqNIUlJSZIb8D7jxZ/U6gX/F2IITYgB6dZWCqkxXXL50CWFhm8BkMpGYmIjS0jLSDfDDhw9cD1ZsfPnyBYqK/1jOSkhIkG6Aa9ashZSUJOh0WygqKsLZ2QmDBw8GAJSUlGL48OE873fr1i0MGsQqpNhdLlbhdgShoZvQv78Wbt68hWnTDMltWltbf4cW83bajh37G8bGxnBwcACTycS1a9ewYYMPWlpaUFxcjLS0NJ5tqBgpgNXBUVCQh6/vBvTt2xd79uzBr1+/MHLkSDg5OeHt23eU9srtLeLZ+i1HR0esWbMWYmIAnW4LVVVVuLg4kw9uRUVFPM6GAHvcSItrDLChoRGHDqUgLi4OAwYMwIMHD7geRto7G3IiLS0NM2bMgLOzM5hMJs6fv8AVCkxlpVtVVUUZWqympgZlZWWsX+8FdXV17NixA1VV1Rg3Thv29vZ8nQ1Z1t49yDWSkZEhWZm1a9eipaUFdLot+vTpAxcXF7IAKCjgx0ixQos5xwDZboDR0VEYOHAgsrKyuG4u/BgpgHUDmTFjOlxdXcFkMpGefoos3EpLS8jxF07U1taCRhPjEVP369cPffr0waRJk6CiooqwsHDU1tZCT08XtrYMPH/+glJfkJOTw2XIIScnR2ryWOyfGOh0Wy79FkDtbAiwLOL79u1D2rhbWVmhpqYGiYmJOHv2LAYPHozXr19zMSUsZ0P+ocXTphnB3X0VWlv7YvfuVLLrWlxcjKdPn/Jsww8jR47E8OHDMXfuXKiqqpLjMqampvD09OT7gNNZi/jPnz8LtIiXlJSEt7c3vL29UVJSguDgYBw7dgza2tp48eKF0CNE7UOLhQHbIp4zJgJgMcBsu/QTJ07A0tISjY2NWLBgAdasWYNr1651ypBDVIt4tvmNtLQ0AgMDERgYiLy8PAQHByMsLAx9+/ZFcHAwV0EgSmgxJ0RlpCZOnAg9PT3Mnj0bPXv2xPz589HW1gYrKyu4uLjwfXgTFFosCG/fvhUYWiwrK4vw8HCEh4fjx48fCAoKQmZmJiZMmICvX7/ybSK2R/vQYmHAL7TYyMgIRkZGYDKZSEpKIscsbWxsYG9v36nQ4s5axKurq0NBQQHbt7MmBj59+oTg4GBSv7Vp0yYe9lPY0GJO7N27VyRGysTEBK9fv8aMGTMgIyODGTNmoEuXLlzxFFTorEV8R4yUoqIiOQXx9u1bBAcH4+bNmzAwMEBhYSHlPYwKGRkZlDpsQWBbxLffB2c8RVRUFKZNmwYpKSkynuLUqVMihxafPXtW5KDoP+CFGCtD698D48ePIrKyDv7/Pgy++FeNLTjBaWwBALGxsTwPdzdv3sT+/fuRn58PGxs6li9fBgmOUUIvLy/Y29vzjG8AAJ1OR0pKCgAW25WUlIiysl+Qk5NFz549Ke1gXVxcEBYWxnMjaG1thaOjI7Zv3464uDh8+fIVyspKcHJywqNHj9Hc3ETJjDEYDMTFxfEUTCUlJWAw7KCkpIiuXbvCysqKnPuNiIjAmDFjKK2S6XRbkkkAWA8Lly9fxpEjR1FQkA9HR0csXryY6+bs4+MDGxsbyq4jnW5LsoBv3rzB/v37UVFRiR49FCAnJ4dNmzbxbOPm5oagoCCegqm1tRX29g7YunUr4uLi8PPnT6irq8HZ2RkPHz5ETU0NnJyceN7Pzs4Oe/bs5SmYSktLYWNjAxUVFXTr1g0rVqwgdVaRkZEYOnQoKajuaI3Onj2LtLQ0FBQUkJoSzhvThg0bYGVlRXmz5FyjrKwspKSkoLq6BioqyqRrVXusXLkK/v5+PDeC1tZWODg4YNOmMMTFxSEvLw8aGn3h4uKCBw8eoKysjHKm3d7enktHxkZRURFZILPGABnkA3dUVBT69+9POSpCp9NJ1o69Runp6Th9+jQKCgrg4eGBuXPncq2Rn58fFi1aRPlAz7lG9+/fR2pqKmpra9G3b18QBIHw8HDKNWI7G3KCyWSCwbBDcHAQ4uLiUVRUiP79+8PFxQX37t1DQUEhaYfPvUYOHDoyRQAs/VpOTg7MzMzw8uVLnm0EQU9PDw8ePCDXgD0uk56eDklJSbi4uMDS0pJrjVasWAFbW1uRMrVu376N+Ph4MudHGDCZTBgYGCAuLo50A9TW1kZISIhA7cXkyZNx/vx5kfRi/v7+UFdXF8pdq7GxEZGRkTh58iSys7ORnJws0kOKnp4eHj16JPTfAyw76sjISL4Oho8fP0ZYWBhKSkqgp6dHFhYvX74Uylqejfr6esycOVPkwlFfXx93794lr8n19fXYunUrrl69Cjk5OXh6evJc6+3s7LBw4ULK6xs/PH78GDt27KBs3PED+zzaunUrtm3bRukGSIVp06YhPT1dJL1YeHg4unbtKpTRSHV1NcLDw3HlyhXk5OQgPT0dhoaGQu+rM+eRubk5QkND+Y6/Xr58mRwpNzY2xoYNG5CZmYnbt2+LNCLX3NwMQ0NDkdluAwMD3Lp1iyyYysvLERoaikePHpGTM+0LXzc3N0yfPl2oDDw2Xr58iZCQEJHHW/X09ODr64uYmBgynsLLy0ugCYaRkRFSU1NFYsB27NiBpqYm+Pn5dfi3JSUlCAoKwuPHj5Gbm4urV6+KVBBv2LABW7ZsEagX+4N/ICYm9owgCB5a8g+TJQT+p4wtAKCLmBhUZKS5jC1KS8soQxCnTZuG8+fPw8fHB8+fP4eTkxMkJaWweLElpk+fjtLSMsoC6+bNm1wjMcOGDSXdABcvXoyGhkYwGAxMmzYN1tbWkJCQ4Mna4gQ7tFhRUZF0tHn//v3vvKNnmDXLmCxO2GjvbMiJlJQUrFmzGsbGxigtLUVcXBwOHDgAFRUVZGdn83U2bG82QaPRMGfOHNy6dQteXl7IynoKBwcHdO3aFUuXLsPkyZNQVETtbHj37l0MHPjPuOGoUaMQFcVyA1yyZAlkZWVhZ2eHmTONYWm5COLi4gIZKZYhhwHU1FQREhIMgDVetmtXFF6+fAFTU1PU1NRw6bfYzoZU9ueHDh2Cu7s7TExMSP3Wvn1xUFdXw48fPyidDVlMgjzPGpmbm+PRo0dYvXo1nj59SoYC29jYQEdHh283sr1FPFu/xR7fk5WVhb29A+bONYG5uTloNBra2toEMlK6unqkjTvAYnS2bNmCN2/ewtzcHPX19VzsEztri2qN/v77b6xc6QYzMzPk5OQgLi4OUVHR0NTshy9fvlB2c1mMFO8aWVpa4uXLl3Bzc8OTJ6w1UlCQh60tA9raY5Gfn09ZYLUPLZ44cSImTpyI1tZWLFmyBDIyMnB0dMT8+fNhYsLSb1E5G7LBtohn27gDLPY0JCQE7969w6JFlmhqauL6XtXX1wPg1JHVkL/bu3evyFk0VIwU1bjMrl27yHGZ8ePH48uXLyKHFm/btk1k177k5GRMmTIFY8eOJR+G0tPTyfDM+fPnY926dVwd7M4YcgAsTYKwD4TS0tLw8/PD58+f4eXlRTrJ9enTB0FBQQItuDtrEV9WVibQIl5XVxfnzp0Dk8nEsWPHYGFhgVevXpH6VGHZooiICDK0WFjk5ubyGHLIyMggNDQUoaGhpH4rKCgIWlpaCA4OxpAhQ/Du3TuRQ4vDwsIoda2CcOzYMejq6sLQ0BCGhoZgMpm/IxXmgiAIrFixAo6OjlzfAzYjJUqBBUAkRqp79+5k0efo6IiEhAT4+PhgyJAhCAkJEXieCAot5geCIDq0iJ81axZmzZqFtrY2xMXFwdjYGO/evUNISAilyyk/cIYWCwsqRqpnz56IiooCwIqpCQ4ORm5uLqnf6tOnT6dCi0XVSAH/hBaz4ylaWloQExMDIyMjsiG1ePFirmKFbcgh6ojhqVOnhLaIV1ZWxr59++Du7g5VVZaunB1P0VFDqri4GMrKyn8KrP8B/CmyOsD/pLGFvJQE1LvJQKLdBenatat8BdylpaUYNWoURo0aBTqdjvLycsTHJ2D37t1obm7Gp0+feG6yx48f5xtaLCMjg/37k7j0W1JSUlBSUuI7SkMVWjx8+HD4+wfAx8cb48ePx4YNPr/1W9NhbW2FxMQEARqpf0b7lJSUyIvaxYsXERkZCQaDgZEjR8HJyZEc0+HM2mqP4uLi35bpY+Ho6Iji4mLEx8dj585INDe34Nu3bzw21OysrfZgMpno1q0bkpOTyTFAduGmrq7O19mQypBDW3ss+vcPgZeXF4YOHQYPDw8wmUwYGxtj4cKFlFlbbHBaxLP1WwDrZs0qAhhc+i2AlbXFYPBqpACgsLCIdN4DWLPg8fHx2LZtG5qampCbm8ejA+IXWsxkMiErK4uUlIOor6/H/v0HyMKtT58+HTobckJHRwfDhg3D2rXroKHRF+7urMJo3jxTmJmZYf/+/XyFyy9evCALKQ0NDVKIfubMGdy7dw8Mhh10dXVI1yzWGv2TtdUe+fn5ZJEEAD9+/ERCQjzCwsLQ1NSIwsIinmyxlJRD2LiRN+CXRqNBTk4OBw8eRHV1NRITE5GWlgYFBQVoamrxzdqiCi2eNGkSxo4dizVr1kBRsRdcXV3RpUsXLFiwALNmzcL+/QdgasrZ9W8C0AJAArdu3RLZMjogIIBvQDhAPS7z/v17NDQ0oKioSOgHh85qpKgs4jnHZXbt2kXqt9jjMp3RSGVnZ/N1yBSET58+ISUlBcuWLQPAMisJCAhAUVERdHR0EBQUxNPMEja0mBOiWMTTaDQsW7YMFhYWmD59Otra2kg3wHXr1sHExETg9v8bFvGc+q179+7Bw8MDOTk5aGhoQGVlpdD6rc5axCcmJnKFFtNoNFIDXFtbi82bN2PixImkfsvIyAg7duwQiRkBWGPVnRl/ZIcWs1nU69evk/qt6dOnw9fXl0u/BYC0sxcFJ06cwF9//SXU33bp0gUrV66Eo6MjJk6ciOzsbFK/tXHjxg7Px7Nnz4qskQoKChLYKBoxYgTJYF64cAEMBgMlJSVoaGhAY2Oj0PotAGQRIgrahxZLSEjA09MTnp6efBtSndFIlZWVQUpKSqTPA7CuPw8fPiQLppMnT5INKXNzc6xdu5ZnpPLEiRNYvHixSPv5A2r8KbL44H/a2KK3rAy6S0pQ/r60tJTHZQ9giWLbF1A9e/aEr+8GuLi4gMFgICEh8fd8PUu/JScnJ5CRYo/lceq3ysrKsHTpUmRnZ+P9+/dwdnYmH3z4aaSAf0KLjY2NYWxsjKamJhw5cgSOjo74/v0HdHR0eLZhZ21RPbiws2iGDRuGK1euwNvbGy0tLZg+fTrfrK3bt2/zFFAqKioIDAyEq6srrKysEBMTi4qKcowZwwoF7tatG6WzIcBtEd+1qzScnZ3h7OyMwsIi2NisgJqaGr5+/QYXFxfSdr2qqopvsHNSUhIWLFiAOXPmYN48ln7r4MGDcHBwwM+fPymNLVhZW9Talrt372HXrp0YOXIkzp07R+q3Zs+eg8LCAr6MVHuL+N69eyM0NBRubm4wNzfH9u0RqKqqxl9/jYOdnR2kpaV5srbYSE9Ph74+q5CSkZEhx9dyc/PAYNhCTU0N+fl5cHV1JbuqVM6G/6zRfsyfz3JxWrhwIanfYjDskJ39k2RhOfHz50++D8Cs0aFIjBkz+nco8CqIiYnBzMzsNyPFu0aPHz/myosBAC0tTWzZsgUrV67C7NmzEBa2CbW1ddDT04OtrS2kpCRRW1sjgJFiGXJ0796dbCr8+PEDDg6OUFNTJccj2cwolbMhGyyL+HmwsDCHtbU1qqqqkJCQiL//Po7s7J8UOSs1+PatAj169BC5SPj69avQ9tIjR47EyZMnMWfOHMyfP590AzQ1NcX69esF6iEEhRbzQ21tLZhMJl9GSlJSEj4+PvDx8SHHZbZv347Pnz/j2rVrIu2LM7RYWFAxUpxugGlpaVi0aBGam5uxaNEirF69GjQaTeTQYoB1Tpw5c0akbSIiIrB06VK4u7uT+i22G6CGhgaPfgsQPrS4Pd6/fy+0RfykSZNw/vx5mJqaQl9fn8yBs7a2houLi8BzmF9osSA0NjbyDS0GWPotdnPix48fCAgIwMaNG/Hlyxc8fPhQpH1xhhYLCyqL+OnTp2P69OmkG+CcOXMgJiYGW1tb0lynsLBQpNBiANi3bx9Onjwp0jaRkZFYvHgxaVjz8eNHBAcHw9PTE0OHDkVoaCiPfktUQw42Xrx4QekoTAV2zqW5uTkGDRpE6lIdHR0F6rcA1n1NVH1Zc3OzwNBizobU69evERISgvz8fHz79g1ZWVki7auzFvGqqqpcjNSiRYvIa9DOnTsxdepUdO3aFe7u7qTtf35+fqdCs/+AF380WRT43zC2oPGhXb98+QI/Pz/06NEDlpaWmDFjBvk7Z2cXhIfzaqRaWlrg5OSE5ORk8rXr16/jxIk05OXloV8/DURHR3PptwD8LsoSeF6vqKjEhg0+iI+Px4cPH5CUlISyMtYoYmNjIwwMDGBsbMxz7O31P/98pq/YuTMSvXv3xpcvX6GiogwnJycMHDgQ3t7eoNPpfDRS/+jI2GhqakJwcDCysrIwYMAALF26FFOmTCF/7+rqitDQUJ6Cia3/YXdK2flbp0+fRmFhIfr164eoqCieBwc7OzuurC02qqqqsH79eiQkJODly5dITj6IysoKjB07FvX19Rg3bhzlAwW/Nfr27RsiIiKgqqrGpd/S1NSEj88GLFu2lPJmyan/YaOhoQHBwcF49uwZhgwZCjrdhqvAXblyJQIDA/nqyNjvx87fOn8+EyUlJejXrx+io6N5jp2fjqympgYeHh5ITEzE06dPkZKSgpqaWowfPx4NDfUYNmw45s3j7d6110ix8fPnT4SFhUFFRQV5efno108Drq6uUFNTg6+vLxYvXkJZMFGtUU1NDYKDQ/Dq1UuMGDECDAaD64bKT0fG1kix36+1tRXp6em4cuUKysp+QVOzH3bt2sVz7NwaqX9QW1uLNWvWYv/+JNy7dw+pqamoq6uHgYE+6urqoKXVHxYW5pSfieo8ys3NQ2BgAJSVlVFUVETqt1RURmDZso1wdHQUSc9x48YNHDhwAEeOHBF6G7a2ha0DaW5uRkxMDDIyMiAhIQE3NzfKrmhnNFJ+fn7o06ePSA8bP378gJWVFdTV1clOdXBwcIfZOZ3RtpiYmCAqKoo0GeKHxsZG7NixA+fPn0dlZSUGDx4sUsFUX18PY2Nj3Lt3T6Tja6+R4sTDhw8RHh6O0tJSGBgYICAgAD179oStrS2WLFkiUqbWgwcPEBUVJVK+E5PJhJ6eHp48eQKAW7/VvXt3eHl5UU58TJ06FRkZGSKN8IWGhqJ79+4i5WMVFBSQZjDC6reAzp1H8+fPR3h4OEaO5DVf4kR1dTXCwsJw9+5dNDQ0QEtLSyQ9UWNjI4yMjP5ljRQnLl68iF27dqG6uprUb8nIyMDFxQWzZs0SOmcOYFnEh4WFcTGOwoBzzcvLy8mgevbkDFUD2MjICMeOHeNrg06FiIgItLW1wdeXd5qBH0pKSmBoaAg1NTU0NDRg3rx58PT07LD47Mx5tHDhQvj6+nboYFhUVITg4GC8fPkS8vLyWLx4MaXO/g/4448mSwj8bxpb8MOtW7eQkpKChoYGxMcn4PDhI1BU7AUGg4HmZn6M1DGuQgP4p8tla2uLv/76i0e/xc7aal9gAdwW8cOGDSOZg6tXryI8PBzZ2dkoKioi9VvAP86GVJ2hxMQErFq1iiyk3r17h7179+LXr18oKCigFG3yCy2WkpJCZWUlUlNTwWQykZCQgP37D0BVVQUODg58Ganjx49zjS7QaDSyy8VgMDBixEg4ODhARkYGy5Ytw8SJE1FZyZ+14wwtHjt2LKKjo0g3wB07duDbt2+orq7GwoULyQeY79+/8w0tTkhgrRE7gf3Fi5eksLioqIjLypyN+/fvo39/3nn8rl27oqamBkePHgWTycS+ffuwZ89e9O6tDkdHJ8qsLYA1NmBg8A+TxrIQN4eFhTkYDAYGDhwIOzt2/hYdEyZMQE1NDbp06cKHkfontHjChAmYMGECmEwmTp8+jejoGHz69Bmtra2YP9+MXJMfP37yZe0SEhKwcuUqspB6/PgxwsNZboCFhUWUs/P8Qovl5OTQ2NiIw4cPo6mpCQkJCdi1KwqamppwdnYSoCPjDi0WFxfHkiVLsGTJEjAYDPTu3ZvUb9nZ2WHMmDECGSlOi/hJkyZh0qRJaG1tRVpaGlJTj2HgwIGQkpLE7NmzyTVhZW3xDy1euXIleRO9e/cugoODUVXViNu3fwl0W6NCRESE0F1jNtqHFktKSsLLywteXl4oLS1FSEgIdu7cCVVVVfj7+2P8+PH/kkaqM0xCWFgY+YAuzLjM3bt3O20R31GBBbD0W/7+/vD394eBgQF69OgBXV1d0g2wo4frrVu3iqyR6sgiXl9fH5mZmWAymUhNTYWFhQVaW1uRm5srco7U5s2bSZc6YZGamsp1zebUb2VnZyMwMBABAQHQ0tJCaGgoBg0a1KnQYqDzFvGbNm2Cqakpqd8yNTUl9VsODg4831FhQovbg20R39E5ALBY8oiICACsf78uXbpAT08PgwcPxqZNm3jY+faIjIwUefyxI0Zqzpw5mDNnDplLNnPmTHTp0gX5+fkia6Q2bdrEFX0iDNqHFvfs2ZPUfbLHm/Py8jBy5EiEhoZCXV2d1EiJUmABrImFjvLI2oOdKbd48WI0NzcjOjoa06ZNg6SkJFauXEkZ18NmpESFsBbxqqqqZDzFunXrRI4N+AP++FNk4X/f2IIf2tra0NTUhK5du6Jr167w9WXZtH/69AkbN25EQ0MDNm/eDGdnZy5jjFu3biE+Pp7n/crLyyElJUXmgrD0W/E4dOgwfv0q4xvu+OHDR0qLeE1NTYwbNw7btm0jxwClpaVhZWWF8+fP8+10tB/tGzFiBHbu3Ilbt27h6NGj5BigkZERrKysIC4ujmPHjlHOkrcPLWY/WL958xb/j73vDmsi7bs+RJQiKCoodrGsDRUVpdtFUQRRUQRMCCUBe0NAgYSiKIq9hCIIInbR1XXt3RU79t6VLoL0lvn+iDOmTELC7vO++7yf57q4dgm5Zya3k5n53ed3zgkICEBFRQXWrl0nod8CRMyevNDiJk2aiIUC5yA2VoC4uHgUFX1TmLUlHVrMYDDQp09vDBxogqio1VQbYNOmTeHu7o6jR4/RZm0BQE5OLlVgAfihKduMa9euITExEYsWLfrRBjgeU6dOBYPBkMnaEp8jcUMOUmt27949LFmyGOXl5di0aRO8vLwkevgVhRarq6tTAcRfvnzBjh07sHXrNhQXF8m9KWdmZsqEFjMYDAwcOAgmJiZYuTKSagNs1kwXLBYLhw8fps3aEu1X0iKe1JRdv34dAoEA8+bNh5oa4ODgAHt7ezAYDOzenUpboEpbxJOtQDdu3MDcuXNRVlaOHTtEmVbiBSSZtSU7R6VgMBpR2qV3794hLi4O69dvQFlZqVxXOTqLeHV1dVhb2+DGjRuIiIhAXFw89u/fDz29FvD29sa+fftos7YA2dBiGxsb2NjYICMjA69exWPUqFFo3LgxuFwuXFxcFLbLkKHFqhYXycnJ+OOPP2j/ZmBggK1btwIQZbGFhYUhKysL5eXlmDVrlkr7aahF/IsXLyQYEOl2mREjRkBLS4ty3gREGilVDTkaYhFfXl4OBoNBMe5kkHdubi7MzMzA5/NpCwhlQouloaxFPIPBgLu7O9zd3XHhwgXMnj0b1tbW0NXVxeLFi+tltEhDDjpTJkVQZBHfuXNnqsvh6tWrWLBgAQoLCwFA5QfCL1++NKj9UTy0WFq/RWZL6enpUfotQFQkqKqJPHjwIC3TogiVlZVQU1Oj2v7Onj0LLpeL4uJiSr/VtGlTmXENtYini7mQhrq6OubNm4d58+bh8uXL8PDwgIWFBWWgJS8DUhwNsYhXFFpMtjcDwPHjx6l4Cm1t7Xp1idL4OxbxZLHZpEkT+Pv7w9/fH3l5eQgLC8O6devQtm1bhISEUPowPp+vsiHHsWPHVG4dFQqF0NTURIsWLVQa9wvy8f99kfU/YWwhD9JZQSR69uyJZs2aYd++fbhy5QqWL1+B6uoqDBs2HBMnTkDjxvIYqTiJQkqk3xLR2DNmuODhw0dgsTzQq1cvcLkctGzZUiZrSxxxcXHw9vb+od9ig81mo6CgAAKBgGrp4HA4EsJ1UdYWvZB93759WLUqCgYG+qiqqsLu3bvh7e0NDQ1NFBQU0DJS8kKL+/Uzhp6eHtLS0nDx4kXKLWvs2LGwtbWVy0glJMRLtCu0bWtIhSlOnz4d9+7dx4ULF9G/fz9wOBzo6urizZs3ChkpLy9vaGlpihVuIjfAjIwbYDDUqDZAEmTWFh3S0tIQFRWFNm3a/NBvJYHN9kTTptrIz8+Xk7VFH1o8aNAgtGjRAnv27MHp06cp/ZadnR21ukjHSEmHFrdv354yUnF2dsbNmzdx7tx5mJoOhqenJ5o2barwATguLhZstgd0dHQobcKnT58hEAjw1183oK6ujtatDSS0TWTWlrw5io6ORtu2bVFaWoqdO3fC09MTurq6yM/Pk+tsaG4um21jYWGBFi1aICUlBSdPnqRCgR0cHDFixAgFjFSCROujkZERoqKiAABTp07DjRs3cO7ceVhaWoDJZEFLS1Mma0scZGhx8+bN4e8v0gG9efMGcXFxyMi4iSZNGqNDhw4S//5k1hYd9uzZg0OHktC580AUFBQgPDwcmzdvhr6+PgICAmiLAWVCi6VRWloKAEoxUgMGDKDafnr16oU///wT6enpSrfLhIaGKjTkoMOVK1dkNJskmjRpgsDAQAQGBlLtMmvWrIGhoSG+fPnSoNBiaUOO+iBtyDFkyBD8/vvvEAqF2L9/P2XmMW3aNMybNw/q6uoqhxaTeP78OW00hiKsX78eR48eRa9evSg3QD6fj86dOyMiIoJWR5aamqrUA7Q4ysvLlWakyIUEoVCI3377DSdOnMDvv/8ONzc3cLnceovw0NBQWndWRVDESOno6FDf/Tdv3oDH42H58uXo1q0bxZiogoZqpMQXv8icS6FQCIFAgHHjxoHBYIDNZoPFYoHBYCAnJwfa2toNNuRQBRs2bKAe+p89ewYej4eFCxeiT58+iIiIoJ1bZUKLpVFdXY2qqqp6W4EBYNKkSZg0aRJqa2vRo0cPVFRU4Ny5c+ByuZgxY0a95xGfz1fZuTUzM1Nujlbr1q0pO/zMzEyEh4cjK0uks/7w4YPS5iQkNm/eLGHIoQwuXbqkUnv5L9SP/2+LrP9JYwt5uH37Nq22oLCwkGrtI9sAa2pqkJaWBldXV+jp6eH8+fMydsnPnz+n2DBxvHz5Eh06tEdMzDoAwNmz5xAUFITq6mp8/14CPp+ejqcLLdbX16eKnilTpkAgEKCg4Cv69u0DHx8O9u3bh4gIemdD8dBiDQ0NaiVQIBDgypUr8PDwQOvWrcHlcqkHowsXZJ0NgZ8W8ZqamlR7QlVVFVJSUuDi4oLmzZvj2rVrMgWaotDidu3aUTbuJ0+exOLFi1FXV4eysjIsX76cdo7oQovbtm2LsWPHgMFQg4ODIzZs2ICioiKYmJjA29sbaWlpSjFSosLND35+foiNjcWFCxfAYrHQvn17+Pr6UsLis2fP0LZhfP/+/UchpYXJkydTFumJiYmYNm0a9PT0cOvWLZlVU0Whxe3atadaJY8dO4b580XMVXl5mdwH4Kws2dXIjh07YMIEO6irN8LEiRMRFRWFkpJSDBliCk9PT6Sm7qFlpGprayUYKR0dHYo9EwgEyMrK/hEK3PlHKLDofadOnZJxNgR+WsTr6Ohg+vTpmD59OkpKSpCQkIAtWzajefPmyMzMlDl+cWdDcXz8+BHt27fD5s2bUVtbi0OHDmHOnNlo1KgRqqqq5ArgP3/+LPNA0a1bN0ydOhVNmjTBqFGjEBYWhvLyclhZWYHJZCIlJYVWC0CGFnfuLHpg1dfXp4wxeDwefHxErG///v0RFhaGdu3aARC51f3555+0xycPK1eubBAj1aVLF5w6dUrpdhmg/tBiOqxevVopRkq8XSY0NBQPHz6Eubk5Bg8ejLCwMNq2bXGQocUNaX+ky55iMBiYOXMmZs6cicrKSqxduxY2NjZo2rQpamtrVdKAALJxDMpAOrRY3A3w+vXrWLJkCfLz82FlZYXQ0FDKDXDnzp1UULOyiI6OVtnNLCsrC0ZGRjh79izKysoQFRUFS0tLyg1Q3rny5MkTldtoIyMjlWKkunXrRukZV6xYgStXrsDc3BwjR47EihUrZNwApSEvtLg+yGOkGAwGZs+ejdmzZ6OoqIhi3Fq1agWCIBoUWqyqRTwACYv43r17U1o90g2wpKQEdnZ2CAgIoNzzVA0tBkSLAqoG6BYWFsLIyAgXLlygFqQ2bdoEAwMDhIaGUgZG0hBnpJRFeHg4QkND632fiYkJtSC1dOlSZGdnw9LSEg4ODli8eHG9C1I1NTUKDTnk4fz58wgLC1NpzC8oxv+XRdb/pLGFPJSVlUFNTQ2NGjWS+VtsbKxMa1/jxo3BYrFw4cJFrF8fg7i4OKSkpEBf3wAcjsjaXN6FWcRI/bQ/Hzt2DMaOHYOamho4Ojpi/fr10NDQwIwZM6iVbFHWVnfa7e3bt48KLY6JiYFQKMS5c+ewbJk/Xr58hVOnTmHmTBeJFbK9e/fJbaW5desWkpKSoKGhgSdPnmDbtm34+vUrevToATU1NbnOhtJtaxoaGvDx8cG1a9exZs1qxMbGIj4+AYaGhuByORAKhQoZKW9vUWsfg8GAvb097O1FboBOTpOxYcMGqg2QXKUVZW3Rz9GePXvA5/PRpk0bDBy4idJvLVy4CK9fv8bly5cxbdo0iWM5ePAgLC0tabd38+ZNpKSkQENDA/fu3cO6detQXFwMY2NRyyGdrWt8fLyMRby2tjbmzp2L27fvYOXKSMTGxmLbtu3o0KEDfH19UVtbI5eRio2NhZeXJzVHTk5OcHJyQnl5OZycnLBx4ybo6v7UbwGKH+5EFvHBaNu2LYYOHQqhUIgjR45g7ty5ePPmLW7evAkHBweJYxExUvSr5Ldv30Zqaiq0tDSRkZGByEiRfmvwYFHxQsfa0VnE6+rqYtGiRcjMfAAeLxTx8fGUfsvX1xc1NdVo1oyekYqNjaVa+9TV1eHi4gIXFxd8//4d06ZNw5YtW6GnpwcvL0/qoUM6a0scZCHVvn172NjYoLa2FgcOHICvry/evXuHhw8fom3bthLHkp6e/oMhL5HZ3vnz53Hnzh3o6Ojg999/p9plbG1tKWt+VXDx4kXasGVFELeIl26X4fP5tO0yly5dkstIyYNQKKSuI6rg4sWLyMzMRLNmzSgr48rKSjg5OWHBggW0DzgNtYiXdx6JQ1NTEyEhIQgJCaGKcR6Ph4SEBFo3QDpERUXRunQqwu7du+Vej6ysrCj9VmpqKhwdHVFXV4dp06ahpqZG5XajU6dOqWziERoaSlnEN23aFJGRkYiMjMSHDx8oN8CuXbtS+i1AdB3t2LGjSvsRCoVy3W0V4a+//sKDBw+gp6eHhIQEqs2SxWLB09OT9t993bp1chcZ5CErK0spRkpPT4/Syb148QLW1tYoLCxEeno6rRsgHSIjI2mjTxRBkUU8qZOura3Ftm3bKDdADw8PVFRUKMVIiePvWsSLL0g9fvwYPB4Pnz9/llmQUsRIKcKXL19UZufu3buHe/fuUdlgZDzF7Nmz5Z4rmzZtwqRJk1TaT3l5OZo0aaIys/kLivH/1Wz+bxhbyMO5c+dw584deHh4YPjwEXB3d6NaAEWMlOxK5YsXL6Cvr49WrVpRf3/27Dni4uJx//49DBw4EIWFhTItF6LQ4l4y2yOZnuXLl6OgoABxcXHYtWsXDAwMkJ2dg02bNsqMoQstZjAYsLW1RU5ODoYMGYLq6ir4+PhAQ0MDM2fOxPDhw2mztgDZ0GJSvyUUCjF37lwUFxfD09MTY8aMwfTp06kLwJMnTxWGFhsaGlJs0aNHj7F582Y8evQIpqamKC4ultBvASIdGV1bx507t2FlZYWQkBBkZ+dAIBBAIIhFu3ZtkZWVhXXr1tHOUUVFhURrF4PBwKRJ9igpEdmkf/369UernQ5mzXKHubk5zp49SztHZGgxOUeDBg3CoEGDIBQKqRVKLy8v2NnZYcqUKdTNWzxrSxxka1+HDh0oHdydO3cQHb0GT58+xdChQ1FaWirzwC0vsPL+/fswN7dAWBifagPcunUrOnToiC9fPiMqSjYkVMRIlUncqBgMBqZNm4a6ujrk5OTg48ePlH6LzWZj0KBBtFlbgGxosbm5OczNzSEUCuHn54evX7/C29tbQr9FHrv80OJm6Nq1K9UKdP36dURGRuD58xewtLRARUWlTOFGx0gBIjtrc3NzhIeH4927dxAIYhETsx5GRl3w+fNn2tVDESMlGVqsrq4OV1dXaGho4O3bd3j8+An27duPli1F+q2+ffuKZW39zMsCRMwmydoBIi2bg4MDamtrMWbMGOTk5GDEiBFUeGZ9D/+KogYUQZ5FfOvWramV4czMTEq/NXDgQDx//hzx8fEq7UfakEMZSBtykOxmVVUVYmJiKLvj+fPnSyxgqBJaTILH46lsEf/+/XuMHj0ae/fuxc2bNxEYGIi8vDyYm5uDx+PRttsJhULk5+erbBG/c+dO/P777wrfw2AwwGQywWQyKcfD7OxsjB07FkuXLlWqPbGh7Y/yLOI7d+6MlJQUAKJ20fnz56OwsBDDhg3Dw4cPVc4jI0OLVYF0aDGHwwGHw0FJSQnFJrVo0QIBAQES7Vl//PFHg/LIpLWw9eH79+8YPnw4Dh06hNOnT8PHxwfFxcUYO3YsgoKCaFuklQktpsOOHTuoHCt5IDXApNZu4sSJ+PLlC+zt7REcHKyURX9ubm6DNFLyLOKNjY1x+PBhAKLibdasWSgrK4O9vT1u3rypMuMjbcihDKRDi5ctW4Zly5bJLEjxeDyJbosjR46oXGweO3ZMZRbwF+rH/xdF1v+WsYUifPz4EUlJSVQbIOkGaGVlKZeRio+Pp9gWEr1790JMzDqwWB6ws7NDUNByVFdXYcSIEXB1dcXVq1fRsye925V4aLG+vj7VEvfo0SPMnz8fS5YsQe/evcHl+qJFCz0AIkZK2tmQxMWLFyEQCCjzjfz8fMTGxiIuLg45Obn49OmTDPNDx0gBopt3WVk5Dhw4gJqaGqSkpFChwMOHD5ebtRUbGysTWtyvnzE2btwIFouF4cOHU/otW1tbTJs2DdevX5fLSImHFrdta0iFAotMJZZg6VJ/mJiI8rd0dXUBSGZtSYMMLdbQ0ICfnx+l39q6dStycnKQm5srs6KYkJBAa3vLYDBQUVGBQ4cOobKyEklJSZQb4JgxY+Q+AAsEPxkpEqampjA1NQWL5YGhQ82wYMFCAAQmTpyIyZMnK9RI7dmzByEhohaIjh07YOVK0Tl140YGgoJEmhdTU1N4eXlSN2/xrC1pkIUUWcB8/PgRAoEA69evR25uLoqKvkFLS3IVUZS1NZl2jiorq3DkyBGUlZUhIWEn5QY4fryd3KwtutBiMqiYyWTC2NiY0m85OjpiwoQJuHXrltw52r07lQotNjIywpo1osLz6tVrCAkJxooVK2BpaQkWi0UV0+np6RLOhuIgCylyPt+8eYPY2FhkZWUhLy+PEnOL2CzRg97KlSvBYrFktqWuro6qqiq8evWKsjveuHGjRHgmHRqikVKWkTIxMaFMEA4dOoR9+/aByWTC0dFRqXYZQMQCNkQjRYYIi0NDQwPLly/H8uXLkZ2dDR6Ph9WrV6N9+/bw9vZuUGjx8+fP5YbQKzo+skgwMzPD8ePHIRQKsXfvXkyZMgU1NTVwdnbG3LlzqaJl9+7dtLpWRSgvL0ddXZ3SgcCAiCWvra3Fq1evkJWVBR6PR+m3wsLC5BZ59YUW0+HGjRtKMS/Dhg3DsGHDKDfA+Ph4cLlczJo1Cz4+Pkr9m0mHFiuD6OhoWpZBV1cXq1eLvvtv3rxBaGgoAgMD0aNHD8yePbtBGqlHjx6pvABBsn4AMG7cOIwbN47Sb9na2qJRo0bw9PTErFmzqDk6cOCAUk514iA1Uqq0P7Zs2RJqamp4/fo1Xr16BT6fj0+fPqFPnz4IDw+Xq42rL7SYDsoyUuILUps2bcKVK1ewePFi+Pn5wdnZWanzaNu2bUhLS1Pp+OQxUnQLUtnZ2Rg4cCDmz58PDQ0NlYvNBw8eqOxY+gv14/98kfW/aWwhD/n5BZRbINkGyGKxUFhYiFmzmNDR0cGSJUvg4+ND9cOT4+gYqfPnz6Nnz98wZswYjBkjagNMTd0DDoeD9+/fU7oZcdTU1Mi9+GVmZoLJZMLDwwNnz55FYGAAqqurMWrUKJw/f572gk669om39hkYGCA4OBjR0dEYMaIlZePet29f+Phw0KKFHp48eUoFGopDPLSYbAP08fFBbm4uPD29oKPTFAEBAeBwOBIPbXl5eXJDi7t370G1J1RUVGL37hT4+Pjg/fv3tMcg7WwojmfPnsHV1Q1eXp6UfksoFMLW1hZnz56l9B3ikGakAJF+KyxMtCKlqan5ow3wOwYOFOm3dHR05DJSb968gZ6eKGxWW1ubusF8+fIFPj4+aNq0KVasWAFfX1+JFhl5q5FkaDFp415eXo6dO0VugJ8+fURAQADtHJWVldOGFn/8+AEzZ86Ej48Pjh49innzRIzRpEn2OHXqFLZvl109pAst7tSpE1atWoUNGzYAEBULJSWlGDp0CNhsNrS1tX84G8oyUu/fv4eenugBWNQGuJB6ffbs2WjatCl4PP4P/dbPzyDtbEjixo0bMDIyomzcS0pKEB8fj4MHD+Hz50+02j3S2ZBOy5CbmwNnZ2dwuVwcPHgQs2fPBoPBwJQpU/DHH39QznziIM0mxFebu3XrhujoaGzevBnl5eXg8XioqKjAoEG28PGJhKamJi5fvkyxcuIQnUeiglw8PFPc7rh///4IDw+X6PFXJbSYxJo1a2g/kyIUFRWBy+UiIiICGzZswPDhw6GpqYm5c+fKdbpsqEX8+fPn62Wk2rZtSwn/b9++jcmTJ6NZs2aYN28eeDyeUg+UdKHF9YFsf5QuVhgMBtzc3ODm5obKykpER0fDxsYGOjo6WLRokVKMlDT+rkV8p06dqBzHa9euYfHixSgoKIC1tTVCQkIkirdnz56plMEFiK4BqljEi64pWvDw8KD0VXRugNKoL7RYHpSxiO/WrRtlTHD+/HlMnToVOjo6VDGvTOvu37GIF3e3BWT1WxEREZR+a/ny5RAIBPUyUtKIiYlRKRcLkLSI79u3L7VPcf3WhAkTsGzZMok2+czMTNr7riKEhYWpZBGvrq6OLl26wNXVFRERERLxFIoWpKQZKWWRnp5eLyMlviB1+PBhjBo1Cjo6Oli9erXSC1I5OTlo06bN3yIOfoEe/2eLrH+DsYU8nD17BmPHyob7tmzZEvr6rZCcnIwXL14gLi7+h/C4J3r37i2XkTpw4CBWrfqpixC5AXrA3d0NHh5sPHv2FEePpsPAwABcLhc9evSgzdoiceHCBcTFxUFNTQ22trawtbX9kS0Uj/fv32Pu3HmYOdNFos1BPGtLGk+ePMWuXUlQU1ODUCjEmTNnEBCwDKWlpaiqqkZdXZ3M6p1I/yNrEd+mTRvo6+sjOXkXHj16jC1btuDbt28wNu6Hvn370GZtASIdmXgvuZaWJjgcDjw9PcFkMnH79m3s338AhoaG8PXlwsjISCEjRVrES+u3BIIdePfuHRYvXiyh3wIks7ak8ejRIyqQVygU4sSJE1i0aBEqKipQVVVFO0bkbOgp83r79u1hYNAaycm7frQBRuP79xIMHjwIffr0UehsKC7K1dbWxrx5c1FbW4tZs2bhypWrSEvbi44dRWGw7du3x6FDh+S2cpCMFFk0TJkyBaWlpdixYwfevn0Hf/+l8PDwkLgxiWdtSSMz8wEVyCsUCnH48BHMmzePWi2VN0d0FvFdunSh5ujGjRuIjIxEaWkpzM3N0KdPH9qsLQAyhhykrbVQKISrqyvOnj2LlJTdMDLqAj8/P7Rp00Yma0scf/4psohXV1enjA6Ki4uxfft2vHnzFsuXL4eXl7eEuYp41pY07t69R81RbW0t0tIOY/To0airq0N5eTntmNDQUNoCWtzu+NixY3Bzc0N5eTns7e1hamraII1UYWGhyuNIi/gmTZogICAAAQEByMvLA4/Hw9q1a2nbZVatWgV3d3eV9tMQi/ghQ4agY8eO+Ouvv3Dw4EE4OzujqqoKU6dOxYIFC+SyEqtWrVLZIj4lJaVeRkpTUxOhoaEIDQ3F58+fsXz5cjx8+BA+Pj5K67cA0Xf372ikxGFtbY0//vgDQqEQu3fvpvRbrq6iwHVlGClxkO2PDbGIP3LkCHR0dCgTi3fv3iEkJARBQUHo3r07wsPDJc7P6OhoudEn8pCVlYWmTZuqxEiNHj0anTp1wl9//YX4+Hiq6PTw8ACbzZZ7Tv6nLOL19PQoDd+LFy8QHByM+/fvY+nSpUrrtwCRTbqqbWt8Ph9z586VeV1cv7V161ZKv0UuRjdEI0W696mCrVu3Yv/+/RILUg8fPkRYWBi+fPlCuyC1ceNGGe1vfcjLy1OZkZo6dSrWrl2LK1euSOi35syZozAPjdSe/sI/j/+TRda/wdhCEb5+/Uq57Inj/PnzFHPVs2dPyg3w/PnziIyMRLt27ZGcnAxXV1dKv1VTU4Pq6iqJHC0Se/fuxZgxo8Fmix4ynz17TrkBfvnyGXv37pUZ8+3bN9rQYg0NDZSVlWLFihUwMTGBQBCLpKQktGnTBj4+HLlZW6RFPLlCwmAwMH78eIwfPx5LliyBvr4+1QY4c+ZMqvBTxEiRhhxkG6BQKMTp06exZs0atG/fAWlpaRL6LUWM1L59+zBq1CiqDfPhw4fYuHETioq+ITs7m5be//aNPrRYS0sTtbV1CAgIgInJwB/6LQHat28PDodDm7UFkDqyFtSNVGQhLmpPWLp0KXR0dMBmk6HATOoGmZOTq5CRAn62AYrcAH9HZGQkOnbsiMOHD8PJyYnap4iRkh9aPGLECHC5XACi1dPVq1fj+/cS5OTkYO9e2TmiY6QAkRtgo0aNsHTpUgwY0B+xsbHYsmUrOnfuBC6Xi8zMB7T6AunQYgaDAWfnaXB2noZly5ZBXV0dbLYnmjdvBjbbk2Kh5DNSP0OLLSwsYGFhgbq6Ohw+fBg8Hg8dO3bE8eMnMHHiBGqf0llb4jh8+AhsbGwoNvH69esICwtDWVk58vJyac8jeaHFzZs3h7a2NhYtWoh+/fpR7bZduxrB19cX9+7do82pkbaIV1dXB5M5A0zmSkybNhN1dXWwtLREmzZtEBwcTJmTvHnzpl7bXkdHRzg6OqKmpgabN2+Gi4sLevToodLNOSEhQWV7YHmMVOvWrSkdxb1798Dn85GTk4NBgwaBz+fjwoUL/yMaqatXr6Jr165gMBgUu1lZWYmYmBjY2NhAW1sb8+fPl9A6kMWmqoYciYmJOH78uNLv79ChA7p06YLIyEgMGTIEgYGByM/Ph4WFBUJCQuSyM6Qhh6pta/UxUgwGg+raKC8vx+rVqxEcHIzffvsNZ8+eVbp1Mi0tTa4hhzzIY6SMjIwoN8BLly5h7ty5+PbtG4YPH44VK1Y0OLSYzp1VEW7duoUOHTqAwWCAy+WCy+Xi+/fviIyMpPRbQUFBEgujpCGHqhbxqjJSPXv2hImJCczNzdGnTx94e3vj+/fvsLW1RWBgIK1+C6g/tFge6mOk1NXVsXDhQixcuJBqb543bx769OmDmzdvKq2fa6hFfGVlpYwhR//+/Sn9lviClIODA5YsWYKjR482qNicPXu2SmPI0OImTZpI6LcULUgBomKzIa6Rv1A/1Aji76qU/jmYmvYj7tzZ1eDx/yZjC3l48OAB7t27RxU+4uByfREVtUrmRlBTUwMOh4O4uDikpu7BlSuX0aSJBqZPd8bnz58hFBJgsz1ktufh4YH4+HiZgqmwsBA+Phzo67ei2gBdXGaicWN1rF69GoMHm2Ls2DEy22OxPJCcvEvitSdPnmD9+g14+/YN7OzsqDZAEv7+/mCz2TJW8NLby8vLQ2xsLF6/fg1ADW3atKaS7MXh6+uLiIhImSK1trYWXl7eiIuLRUpKCq5fvw5tbW24urri/fv3qKyslNGzAYCnpyelkRLHt2/f4OXlhVatWqGuro7Sb6mrq2Pt2rXo168fxo8fT/OZWBQjReL+/Uxs3boFb9++hYODg4R+CwACAgLg7j5Lxgpeeo5E+i0B3r//AHV1dejrt8KaNWtkxsyePRs8Hk+mYKqtrYW3tze2b9+OxMRE3LlzB7q6umAymXj9+g2+fy+mCilxeHl5SWikSBQVFYHF8qD+LSZOtIejo8gNcP369fjtt99oGRcWy4NiW0jcunULO3aIWEBnZ2eqDZBEUFAQpk+fQVswic/Rhw8fEBsbiy9fsqCtrQVdXV3a82jOnLkIDl4hUzAJhUKw2Z7YunULEhISkJmZiebNm8PT0xOvXr1Cfn4+7Y3Py8tbQiMlPkezZs1C69atKUfG8ePHg8FgYONGkWOhtAOkvDm6du0aEhIS8P79e7i5uYHJZEqctytWrMDUqVNpHhyMYGZmh5s3bwIQtQGGhYXh8+fP0NfXR7NmzVTKUxEKhbC0tMSJEyfA5/Nx584dGBoaIjg4WKFmw8bGBn/88YdKLXxBQUEwMjICh8NR6v2HDh3C2rVr8fLlSwQFBWHhwoVKP+SZm5sjIyND6WMDRKvrmzZtklswkdqkR48eoX379ggLC8Pt27fx9OlTldrdSFMJVdklCwsLXL16lSqYhEIh0tLSkJCQgJqaGkyfPh1z5syRKKg8PDwwc+ZMlTK1rl+/ji1btqhkuU2eR/v37wePx8Pz589hZGQk4QZIh+HDhyM9PV2lFr6wsDDo6ekpZRBB6rfi4uLw6tUrrFmzBt7e3koznGZmZtR3TVk4ODggKipKLtP46tUr8Hg8vHnzBj179kRYWBgyMjJw48YNyg1PGVRWVmLUqFEqL0BIn0e1tbUQCATYu3cv1NXV4eXlBXd3d4k54nA4mDhxokpmCnfv3sXKlStV1sCZm5tj586dlBugsbExwsPDKTdAOowcORL79+9XycFw9erVUFNTo2X+pUHGU+zfv5/KPFSFFW3I9WjKlCkIDg6WWzzeu3cP4eHhyM7OxuDBg8Hn85Gfn4+7d++CyWSqtK9fkISamtpdgiBkboD/J5isf6OxhTxcu3YNb9++A4vlgZ49fwOHw4G+vj7FSNHdONLS0jBs2HCqDZDN9kBhYSFiY2Nx6tRpmJoOxqtXryRuTIWFhdDQ0JAbWuzn54sxY8aguroaqamp4HBEboA5OTkKGSlp9O3bFy1a6GHbtm349OkTAgKWoaamBqNHj4aLiwtt1hZAhhb/NJto3bo1lWhO2kozmUz069cfHI4o10c6a0scIkMOGxn9lkAgwIULFzFkiCnevn2Lrl27UmPkMVKAaNWdw+Fg/PjxqKioREpKMry9vaGtrY3c3Fy5WVvijBSJgQNN0KpVKyxcuAjv37/HokWLQBAExo8fj6lTpyInJ5e2wJIOLRbpt0SORu7u7iguLgaL5YFBgwbCy8sLOjo6Mllb4iAt4kkbd0Ck3xLllF2FhYU5Pn36LBFwW1xcLDe0eOfOnfDx8Ya9vT1KS0uRmJhIuQFmZWXLzdqia8kaOnQo0tPTMX/+Arx+/Rrz5s2HmtrPwMisrGy5Gilxs4nOnTtT7TNubu6ora0Fi+UBc3MzeHiwoaWlibq6OgWMlCi0mLRxJ485Li4Of/11A9bW1sjOzpHQb5WWloLBUKNd0d21axe8vb3h6OiI4uJiJCQkYP/+A9DT00NW1heFzobSc2RtbY2TJ09izpw5ePXqFfz8/KCurg4nJyeMGzcOnz/T2wNfv34Kv/32s9XY2NiYWskeOnSoSg/7wM/QYn19fUpfJd4uY2JiAj6fL9EuU1IispNXVSOlqkX8tGnTcPToUYSHh+P+/ftUu8zcuXMxZcoUueOuXLkicW1QBsowUu3ataM0rLdv30ZQUBCuXr0KZ2dnFBQUKG0I8Hcs4sULKAaDAXd3d7i7u6OiogJr1qyh9FuLFy+GnZ1dg0KLG2IRn5qaCktLS3Tu3JnK37p27RrlMGdjY4OQkBCJc6aiokLp0GJxnDp1SmlGisFgwNvbGzdu3IC/vz/u3bunlH4L+M9ZxPfo0YNiw8+ePQtfX1/cunULHh4etE6w8tAQi/js7GwZQw51dXXMnTsXc+fORVFREcLDw7F9+3ZKv2VlZdWg0OKIiAiVLeJJRqpv375Ue/OJEyfAYrFQWloKOzs7Gf2WKqHF4lDFIp6Mp3j79i38/Pxw6dIlxMTEwNDQEKGhoQpZtIZaxGdlZSnc7qBBg6gMu0OHDmHGjBn4+vWrykX3L6gAgiD+NT+DBxsTBHFHpZ+S6hvE88LzxIP8s3/75/33S0R13S2Vj0HZn9ram8SWLR7U7+fPRxMcjinh4dGPmD3bjEhMnEM7zsOjH1FdfUPm9a9fzxAcjinx9GkqsXjxCILJNCZWrZpGfP16hli1ahpx9uxq2u0xmfTzfOPGVsLOrjXBZBoTS5eOJF6+3Ev9bcmSEcTTp7uV2l5l5XUiPt6XmDy5IzF2bEvi0qUYmTFcrimRn39K5vXq6gyCxRJtr67uFnHyZATh4zOIYLP7E/PnWxFxcb60x8Bm9ycqK6/LvF5YeI7gcEyJBw8SifnzrQkmsy+xbt1Morj4ArFmzXTi9OlVcj9THc25cOPGVmL8eAOCyTQmAgPHEu/eHaL+5u8/inj8OFmpOSovv0Zs3+5FODl1ImxtWxE3bmyVGePrO4TIyflD5vWaGsk5Sk8PJry8TAhPzwHE0qUjCYHAR6U5Kio6T3h7DyRu3xYQc+daEEymMbFpE5MoKblErFs3k/jjj3A5n6kv7Rz99dcWwta2FcFkGhMhIROIz5+PUX8LCBhD3L+foNQclZRcIjZunEVMmdKZsLXVJ+7dkx03e7YZkZV1XOEc1dbeJPbvX0Z4eg4gvL0HEsuXjye2bfOkPQZPzwFEefk1mde/f79IeHmZENeubSL8/IYSTKYxsWOHN1Fefo3YsMGdOHYsVKXz6Nq1TcSYMS0IJrMvwePZS/w7BwXZ0n5Wujn69u0cER3tQkyZ0oWwtdUnHj3aJTOGw7Ek3r59S0ijrq6OMDc3l3m9PlhbWxMlJSVy/56enk6MGjWKsLCwIFatWkVUVVURAQEBRGxsrEr7efv2LTFu3DiVj8/MzEzi9+zsbILL5RJmZmaEk5MT8eDBA5kxdnZ2xMuXL1XaT0JCAuHv76/SmNLSUsLKyopIS0sjhg8fTlhYWBAxMTFETU2NwnHm5uZEXV2dSvtisVjE6dOnlXrvx48fCQ8PD6JPnz5Eu3btiKdPnyq9n7q6OmLo0KEqHRtBEMSwYcOIb9++yd1mYmIiMWzYMMLKyorYtm0bUVdXR/B4PGLz5s0q7efTp0/EmDFjVD4+6fPo9evXhJubG2FmZka4ubkRb968kRljb29PPH78WKX97Nmzh5g/f75KYyoqKggLCwti27ZthJWVFWFtbU0kJibWe46Ym5vXe65Jw8fHhzh27JhS73369Ckxffp0wtjYmOjQoQPx8eNHlfYlPefKYMSIEURubi7t32pqaogNGzYQlpaWxPDhw4m0tDSirq6OWLVqFbFmzRqV9pObm0uMHDlS5eOT/kz3798nnJycCDMzM4LL5RLZ2dkyY5ycnIi7d++qtJ8jR44QXC5XpTG1tbVEUFCQSmN+gR4A7hA0dc1/LZP1bza2kIfbt29LpIePGjUKo0aNQk1NDSZPdkJZWRkyMm5i+nRnKq2+sLCQViMFiMwhpk93pmzcAZFFeFDQcjx//gzt2rVFTU2NxFgya4sOhw4dQkzMevTu3QtPnz6l9Ft9+vRGTk4OrdD44sWLMoYcGhoa8Pb2xp07d7Bo0SIcOHAAiYmJaNOmDTgcDjp37iLX2XDfvr1UaDGDwYCdnR3s7OxQVVUFJycnFBUV4d69u3B1daXep5iRisfUqVPQv39/bNok0m/9+eefWLJkCV6+fIkOHTqgtrZWYpWOzNqiaw9JT0/HunXr0LdvX2RmZmLDhg349u0bTExMkJWVRbsaKQotlhT7a2lpws/PDw8fPsTs2bNx6NBh7NghQPv27eDr64t27drJZG2REDfkYDAYmDx5MiZPFrkBTp06FXl5eXj06BGYzJ/6LTpnw59zJLKIl9ZvLVy4EK9evYKRkRGEQqHEfIgYKVnWDgCOHj2G6OhoDBgwALdu3UJUVBRKSkoxZIgpPn/+TCs0pgst1tHRwYIFC/Dy5Ut4enri4MEDP1rsOsPX1xcGBgYyWVskDh8+DDMzkSFHo0aNqLyjkpISTJvmjM+f2+DFixdgs9nU8UhnbYmDDC0mbdxra2tx6NAhzJkzG2/evMXSpUtl5kgeIwWI8nCio6MxcOBAXL16DXw+H+XlFbCyssTnz59pWbubN2/KhBbr6enB338p5s6dC1dXV6SkpCA3Nw/du3eDr68vWrVqhcrK7zAyknUgi4+Pp8LHlcX3798BQOHKOXk+ku0yI0eOxJMnT1Re1RYPLVYWdBbxhoaGlMbj3r17CA0NRXZ2NkxNTREWFoaWLVs2SCOVnJzcYIt40uRE3A1QW1sbCxculLFsVja0WBrPnz+Hra2swRIdOnbsiKSkJEycOBHu7u5YtmwZ8vPzYWlpidDQUIVW7v8Ji3gGgwE2mw02m43y8nJERUXBysoKz58/p9USK0JoaCitO6si0DFS3bp1o/RbFy5coFz4Ro4ciRUrVkBbW1uullgR4uLiVG6PW7duHZydnSXcAMn8rZYtW2L58uUy/yYNMeQAoBIj1bt3b+zfvx+TJ0/G2LFj4eXlhe/fv2P8+PFYtmyZXP0WoDi0WB7qY6TE9VsFBQUIDw/Hpk2b8OLFC/zxxx8q7auhFvHSjoImJibUv3d6ejrc3NxQUVGBSZMmYcmSJWjSpEm9jBQdtm7dqlLbNyC6Xqqqk/0F1fBfWWT9240t5OHOnTvw8/OTeb2kpAQdOnRAbKzgRxtgHHbv3o1WrfShpga5wvLnz1/IhBaPGTMGHTt2hEAggFBIgMPhQENDAzNmzMDIkSNps7ZIiBybRMYbffr0QUxMDAiCwPr165GfXwA2m41Ro0Zj5kwX6kItnrUljpqaGlRWVqJnz55UG+CTJ0+wfft2qtCjCwW+cOECrei1vLwCHTt2RGxsLNUGmJCwE4aGhmAw1OS2QDx+/ESitY/BYGDixIno2bMnNm/ejJKSEqoN0M3NDVZWVoiLi5PJ2iKRk/OzrcPExASbNm2CUCjEunXrkJeXBy8vL0q/1ahRIwCSWVviIA05+vXrR9np3r9/H+vWrcObN29hYKBP2wpCZm3RzXnHjh0RFxeHL1++IDY2Ftu2bUeHDu3RqFEjuc6G0hbxIu3QZJiYDMC6dTH48iULbLYndHV1KDdAgSAWnp6yukLRHOVgwIABAETtaEOHDoVQKMSaNdE/5sgbkybZw8HBgXpwFM/akp6j0tIyDB48mLoBZ2RkYOXKlfjw4QP09fVpQ4HlhRYDoiwvUtsUGxuLDRtE2ih19UZyHaCkQ4vV1dXh4uICS0tLrFq1Ci9fvsChQwehp9cCXl6e6N+/P23WFgmRIYcomNLGxho2Ntaora3F6tWrkZWVBR8fH0yZMgXjxo2j5iglZTdWrJBvEW9paUkZAly+fBmhoaH48uULDAxao7IyH5qakvqE1NRU/Pnnn7THJw8rV65UunefbJeZMmUKvLy8cPnyZaxfvx5t27ZFSEhIvQ8R/wmLePF2mQMHDsDZ2RmfPn1Cu3btZBakFKGhFvHSocXSboB8Ph8rV65Ex44dKTfA0NBQlQ05GmoRX1BQQBWAQqEQqampcHR0RG1tLVxcXKgWVXEkJibi2LFjKu0rOjoaM2bMUOq92traiIiIgI+PD2bOnIm9e/eCz+crpd8CRKHFEyZMUOn4IiMjqTwrOpALpEKhEAkJCZgwYQJyc3PRtm1bmcUWRWioRbx0aLGenh7V9vvixQvweDwsWbIEvXr1Qnh4ODp37gwej0fbnqwIf8cifs6cOZgzZw5qa2uxY8cOjB07Furq6vD29oabm5vMHG3fvp1q91MWMTExtJpWOujr62Pz5s3IycmBvb09NmzYgMWLF6Nfv34ICwtTqN8CRAs0dPddRajPIt7JyQlOTk6orq7Gxo0bMXLkSBQXF6vcKlhdXY2KigqVLeLPnz+PiIgIlcb8gmr4ryqy/huMLeShoqICGhoa1IO3OGJjYzFjhqiQatmyJYKCRJqoFy9eYPbs2cjPL8CtW7fA5XKpi7EiRiouLh4cDhe9e/cCm+2BgoICxMXFYdeuZHz69BFcruwxiLK2ZMMi1dTU8PLlK+zZkwpdXV2kpqbCx0ek3yLtiumOY+/evRg+fLjEa3379sX69evBZrMxdepUKhR4zJgxP1iGUjRu3JiWbREPLW7Tpg114Xr06DEWLJiPrKwsyqqYLNzEs7Zk5ygOXC4Xffv2BZfLRXZ2DmJjBYiLi8fnz59oi2FR1pZsaDGDwcDbt2+xZ88e6OjoYteuXVSWl6ur6w8dmayz4f79+2Us4gcOHIiBAwfC09MT9vb2WLhw4Q/9lh2mTp2CkpISuYxUfPxPi/j27dtThR0ZnPzhwwe8evWKCiwGJDOSpCEQxILL5VAOhp8+fUZsrABbt27Fp0+fMX++rMOduLOh9Bx9+vQRKSkp0NHRofRbzZs3w6xZTLlZW4cPH4alpYXEa+bm5jA3N4enpyfGjBmDuXPnQE1NDQ4ODrC3t0dZWRmtsyEgYu1IIXaXLl2o3Kjr169jxYoVeP36Db58yYKHhwc1/v379wpDi7lcX4p5evfuHQSCWMTErMfnz59phfYZGRm0FvHq6urIzs7B7t27oa2tjbi4eOzbtx8tWujBy8sLpaWltA8C6enpEgw5IDIHGD58ODw9PWFtbQ1X10koLNQFl8vFjBkzqKwtZbUcJORlbSlCaGgoeDwexZplZmYiPDycsk+W1m8BosUWeQHh8iAUCvHt2zelLeJJdtPGxgajRo3C8OHDoaWlJeMGSIeGaqQUhRZ36CAq/gERkxIUFIS8vDy8e/eOyohTFuKhxcpC2iKewWCAyWSCyWSivLwc0dHRsLa2pmIL7OzsGhRaDACnT59W2bWPx+MhODiYcjC8cuUKpd8aNmwYgoODZYpeZUOLxSEUCpVmpBgMBjgcDjgcDmxsbGBiYkK5AQYEBNTLEsgLLVaErKwshaHFPXv2pAxITp8+DQ6Hg+LiYnz8+FHl2IDIyEiVNJGASPsrfj1SV1fHvHnzMG/ePBQWFiIiIgLbtm2Dvr4+VqxYAQsLC1RVVaG6ulql0GKg4Rbxy5cvpzSav//+O6UDnzhxIpYuXSqh3wJE99CGuO+RAcH1QdwNcNiwYejYsSPMzc3lugFKQ15osSKUl5fLfSb9hX8O/xVF1n+TsYU8HD58mPbBGKBnpEiYmAxETMw6nD9/HkFBy1FVVYkRI0bg4cOHtE5wAFBQIBlarK+vj+XLl+P8+fM4efLkjzbAAvTu3Rtcri9atNCTydoiQRpykBc/Ly8veHl5IT8/H4sWLcK3b9+wbNkycDgciYeiixcv0rYYkKHFZLZUVVUVUlJS4O3tjZycHIwbJ+vYB4iytuhWczU1NWBiYoJ169bh1KlTVOE2duxY3L17lzZrCwBycyVvom3bGoLP5+Py5cs4cuQIZeM+YMAA+Pj4QFdXVyZri8RPQw5RIeXn5ws/P19kZ2dj6dKlKCwsRFBQELhcrkRLHJm1JQ2ytY/MliovL0dSUhLYbE/k5+fRuhoCooKTLqemefPmGDBgANavX0+1ARIEMGGCyHGOLmsLkA0t7tixAyIjI3Ht2jWkpaVRNu6mpqbw8vKEtra2TNaW+ByVl5dTD9PkiurHjx8RGBiIwsJChIaGgsvlStzM5DFSpEW8q6srXF1dUVJSgp07d4LN9kRBQYHcORKFFssWPu3bt8eAAQMQExODw4cPY+7cOWAwGHB0dMT169frYaRMqN+NjIywZs1q3LiRgaSkRISFhaG8vByWlpZgsVjQ0NDA7t2pEllbJKQt4v39Ref7mzdvsHz5CioglGyVJHHy5J/YskXWYUxkyMH4YZbDRUGBIcLCwrBx40bk5+erHDb75s0bWmMXZcaJtyWKt8scOXKEWohwcHCgwjOjo6NVXjVOTExskEU8IHrwIm3geTweoqKi0L59e/B4PNqYhAsXLuD69esq7SskJERpRsrMzAy///47rl69iqVLl2LKlCmoqamBs7Mz5s6dq7DlS15ocX1ITEyUG1qsra1NzdHHjx8RGhqKsLAwFBUVqZwjJR5arAqkLeKHDRuGYcOGQSgUIikpCfb29hAKhXBzcwOXywWDwVA5tBhouEW8UCjExo0bAYjO+dDQUAQGBqJHjx4IDw+nZRb/0xbx48aNw7hx43Dz5k34+PjA1tYWDAaDyodU9F0mGal/0iK+ZcuW1ILBs2fPwOPxsHDhQlRXV2PixIkq7eefsogn41Jqa2uxefNmKn/Lz88Pzs7OYDAYiIiIUCm0GBA98ylTYImjuroatbW1SExMpI41LCyMKtbCwsJoWyOPHj2KixcvqrSvo0ePKs0C/kLD8a8vskpravCltBxVdcK/va3mGo3Rrqk2Gqv4kPBPIC8vD9XV1WCxPKCv3wre3j7o3bsXnj17TuuWB5CMlKhtbfTo0Rg9ejRqamqQmroHd+/ew/r1GyT0WwCZtUV/cz1w4KCERfzZs2cRGBiIqqpK5OcXyLTuAaSzoWxosYGBARo3boyjR4/i5cuX2L59O75+/Yq+ffvC2Xm6Ah2ZZGixuBugm5s7Skq+g8XygKGhSL/VrVs3ytlQHiPl5eUFBoNBhRVWVFRi9+4U3L59G+Xl5VQbIAnxrC1pkIWUgYEBhEIhTp48iUWLFqGurg4FBQVo0aIF7Ri60OK2bdtCQ0MDR48exdOnT7F+/XoUFxfDxGQgnJ2nyWWkpEOLtbW1f7ReiBzzCgoKwGJ5oH37dvDz80PHjh1/PADTM1KiOfKm2gCdnET6rZ07E3Hz5k2Ul5eDxWJJrD5ev35dYWgxaREvFApx9OhRzJs3HwCB/Px8Wtbu0KFDEsHMJDp16gQtLS2kpx/Fo0cPsWpVFEpLSzF06BDqBkfHSMXHx8PRcTL1u66uLvXg4erqiqysL2CxPNClSxf4+vqibVtDhWGzZGixuro6lXdUUlKC+Ph4/PXXXygvL0ejRl4SD9ziWVvSSE1NRVhYGNq2bYva2locPHgQs2fPhpqaGvLzC2i1dvJCi7t16wYdnaZISkrE3bt3ERoaioqKClhZWWHq1Km0WVuAdGhxFfT1m1PhmSYmJnjx4gXMzc2VbpeRF1qsCOfPn1fISJELCWS7zIgRIyhNgqrtbsnJyTh58qRKY6RDiw0NDREbGwtA1N5N6reGDBkCPp8PfX19vHv3TiEjJQ8vX75UOguKRFRUFFJTU9GjRw8J/VbTpk2xaNEi2gfT5OTkf1wjJY5OnTpRboD9+vXD3bt3MXToUMoNsL5thIaG0rqzKsL169fRuTP9d43BYFCLf6WlpZR+S1dXF58/f1Y5tDghIUFljZR0aHG3bt0ofcz58+fh5+eHoqIijBo1CsuXL4eOjg4+f/7cII3U48ePKcZTWaxatQp79+5F3759qcUaS0tLCTdAaSgTWiyNyspKud0t0ujduzcOHDgAQCRPuHHjBszNzWFnZ4eAgAAZNkka8kKLFeHOnTtyr3Pq6upYvHgxFi9ejIKCAoSFhWHDhg1o06YN3r59q3Jo8bZt21SKNABkQ4tNTEyQnp4OQFS0zZw5ExUVFRILUg0JLQZEcUKqsvG/oDr+tUXWf6OxhTzk5+ejbdu2mDlzJgBRq19cXDwKCvKRn58vd4WkoCBfZjWycePG6NSpI8aPHw8fH2/Ex8cjJSUFBgYG8PHxoQopadBZxI8dOxZjx45FUlISbt26RbUBuri4UCvCly5domWkRIYcIot4sg1QKBTi3Llz8PXlQktLC6mpqXBxcZG4icgLLX7x4gUMDdtQLMijR4+xZcsWfPv2jWI56EDX1qGlpYmePXv+EN56U22AhoaG8PXlYu/evYiIkNWRSYcWMxgMinFLTk7G1atX4e3tjaZNm8Ld3Z0qGi5cuEC76v7tWxHV/ki2AQqFQpw4cQKeniLm5+DBg5g6darEA5u80OI3b96gdWsDik27e/cuoqOj8f37dxQVFdPqdQDQWsRra2vDxMQEhYVf4e3tjR07dmDr1m3o0KEDfH19sWfPHtrzUhRa/NMinsFgUA/KKSkpuHDhAmXjzmKxqNykM2fOYNu27TLbEw8tFtdvHT58BLNmzYKWlhZ+//132NvbS8zRgwcP5FrEGxi0plrabty4gcjISJSWlqK0tESukQJdaLGuri4sLCxQXFwMDw8PxMXFISZmPYyMusDPzw+pqcoxUurq6pTOZffu3Th9+jTYbM8fbYDe1L/NqVOnaBkpkf25yCLexsYGNjY2qK2txYEDBzBz5kxoaWnh1KlT1Co1iXv37kuFFpcAaInXr1+jXbt2VHjm77//jlmzZlFZTEFBQbQPOK9fv1aZKYqOjlYYLEpCvF0mJiYGKSkpKrXLkIyUeP6cMlAUWmxqaiqj36qurkZZWRltPp0iXL16tUEaKXFDDmn9VmhoKCIiIiT0WwCQlJSkUmgx8NOQQxV8+PAB7dq1w8mTJyEUCrF79244ODigrq4OM2fOxOzZs2kL0f+kRbyOjg7V3rZhwwYIBAKYm5uja9euiIiIqLeVtKKiokEaKUWMFLlAKhQKER8fT7FxtbW1WL6c/potD7dv326QRXxOTg51fujp6VFzKa7f6tmzJyIiIqj2SlVDiwGRRops61cWOTk5aNu2Lc6fP4/a2lps3boVo0ePhrq6OjgcDmbOnEl7Ht2/f1+pa4s4IiMjwefz632fvr4+tSAVExODBw8ewNzcHP3790d4eHi92id5ocX1QVFo8dSpUzF16lSJBSmy3U/V0OLs7GyV9Vu/0DD8K4us/1ZjC3kQpdn/dHnq2bMn5QY4efJkJCYmYceOHRg+fATc3d3QuHFjnDt3Dr169aLdnjgjRbYZPnv2HAKBAM+fP0NsbBy4XI7EjYLM2qLDlStXEBcXh8aNG6OgoAACgQBJSbugp6cHoVAoN2vL2Vmyl5zBYMDW1hZ79uxBXJzIvMPb2xtaWlpwcXFBu3btaLO2ABEzId7a16+fMTZuFLkBOjlNQXx8PCWedXZ2hrq6+o+sLXrRM1lIGRjoUxfVhw8fYsOGDXj27Bl2706h2gB/jtkndwX48uXLVGixKBQ4FgJBLFq3NkBdXZ1cZ0NpswkGgwEHBwccPnwY27dvR3JyMthskUZq1ix3GBgYoGVL+pas2NhYiTkizSCEQiEmT56M2Ng4xMbGws7ODlOmTAGDwZDJ2hJHWtoe8Pl8tGnThjIvuX37NlavXo0nT57gwIED8PT0RNOmTakxBw8ehJUVfSvNpUuXIBAIoKmpiU+fPkMgEGDLlq1o29YQdXV1ChgpSf0Lg8GAs/M0nDhxAlu3bqHaAJs3bwY22xN6es0VMlLiwdwWFhawsLCAUCiEg4MD4uLikZCQAAcHR0ycOAEMBkMma0scokIqGG3btpXQb4WFheHJkyc/+vlZEp+NzNqSN0dxcXHQ1tamAipzcnLRuXMn1NbWymWkJk2SDHVWV1eHq6srTp8+g40bNyAhIQF79+5DixZ61Hkt62woKrLINiYSZLtMTU0NfvvtN5w7dw6NGzfG7NmzKdOd8+fPq+y+JxQKUVRUpHJxcfToUVy/fh06OjpKt8usXLkSs2bNUmk/iphNaZD6rcrKSvTo0QNhYWGIjo7GggUL5JqliCMqKkplPUxycjLloCqNDh06UC1FN2/eRGBgIPLz82Fqaorq6mrargRFOHfunMrtjzwej2p/ZDAYYLFYYLFYlBugpaUlmjdvjqVLl1IMHp2LaH0gDTlUbX88duwYMjIy0KJFC1y5cgXz5s3D169fMWLECKxYsYLWtGTNmjVyjabkQVlGisFggMvlgsvl4vv37+jZsydWrlyJHTt2IDAwkLZjRBrh4eEKDTnosH//fpiZ0V+PxPVbp06dgre3N75//47Ro0ejsrJSZY3UiRMnGtT+SLaPi7sBFhYWIiwsDFu2bIGBgQGCg4Opz3Hnzp0Ga6RUZaROnDiBW7duoXXr1jh27Bjc3NxQXl4Oe3t7+Pv70zJI69evV7kVLy8vD5qamvUyUuILUnl5eejXrx/WrVtHLYwq8/kOHDigtPHML/w9/KuKLIIg8La45L/S2EIRvn79StsSeO7cOZiZmSMoKJBqA+RwOGjSpAkKCr4iPl6WQaqpqUFNTbXMSlvv3r3Qv/8A9O8/AB06dEBQUBCqq6sxcuRIzJw5E5cvX6baYMQhzkgBohWc4OBgAEBAQADq6urAYnmgb98+8PHhoEULPQCi1UjSoEMcpCEHaePu7e2N/Px8CASxuHjxAnr06IE3b97IrCjm59OHFl+5cgVDhpgiODhYQr+lra2Nr18LsW2brJOYvNDi/v37Y8iQoRgwYADatGmDxYsXQygUYuzYsZg2bRouXDhPuzImzkgBZCgwHwDg7++PqqoqsFgsmJgMhLe3N3R1RWYC0s6GJMjQ4qZNm1IWvKLCTYBr166he/ce+Pjxo4xgOzc3j7Y//vr16xg8eDB4PB7Ky8spUwldXR18/fqV0glIzxGdRfyQIUPw+vVr9O/fD61bt/5x81ODvf1EODo64uzZs3J1ZI0aNaIYkI4dO2DlSlHhtnTpUlRUVIDF8sCQIaYUiwcoZqT09PQk2gA/fvwIgUCAjIwM9OrVC9nZ2TIuTFlZ9DfRGzduYPBgU4SF8VFSUoKEhASqYPv69SutboN0NpTeh5WVFWXX37x5c0q/5eTkhPHjx+PUqVNydWRqaj9Di7t160YxIkuWLEVZWSk8PDxgZWUFJpNJnW/SzoYkSIv4Fi1awN/fH4Do3IqLi8Pdu3fRp08fqfZNUSDw27dvaR/orly5AhsbG6SkpKCgoAB8Ph/r16+HoaEhsrKysH//fpkxihAfHy/RyqwMpC3ipdtlXFxcUFFRgcmTJ2PRokXUA4mqocVAwyzib968CRsbG6SlpSErKwt8Ph+rVq1Chw4dwOfzab+fyoQW0yEpKUkpi3gzMzMcP34cQqEQjo6OKCgogJWVlVw3QGn8HYt4uvZH0g0wIiICHz58AI/HQ0hICLp06YIvX76o3OpGhhargvLyctTW1lLt3eL6rcTERNjb24MgCLi7u8PHx4f67KdOncK1a9dU2ldDLOKfPXsGa2trHDx4EK9evQKPx8OyZcvw22+/ISwsjHZhQhVDDnHExcVRrLUijB8/HuPHj0dtbS0cHR2RnZ2N4cOHw8vLC+7u7vWeH3ShxcpAnkV8y5YtqYWJJ0+egMfj4fPnzzA2NsaHDx+wbt06lfZz4MABqrNCWUhbxDs6OsLR0RHV1dXYsmUL1d4sviAFqBZaTILP56tsEZ+VlQVLS0ukp6fj3r171ILUoEGDwOfz5TJpWVlZ9baH/8I/g//9CkQMlXV1f7vA+t8ytpCHV69eydUkHDx4iGrta9y48Q+Bugdyc3Ph5uaGRYsWQ19fHxyOD7WKl5q6R8a1j8SVK5cpRmrs2DE/CrdUeHh4ICsrC9euXZPJxSGztuiQk5OL1NRUqg0wMDAA1dXV6NevH1q1om+nEFnES9qfGxgYICQkGK9fv8b8+fOxbds2fP36FcbGxuBwOLh37x5+++032u3t27ePYlnE9VtfvnwBk8nC0qVL0aaNIbhcDrp27QpAxEjJWwG+ePECxUjZ29ujoqISKSnJYLFYyMrKwt27d2Vu6OLOhtLIy8tDWloaAOCPP05i8eJFEAqFGDRokEK2RdoiXlS4hYHF8gCXy8G6detQXFyMQYMGwcvLC/fv35fJ2iKRlpZGsXXa2tpUn/rHjx/BZrOxbNkydOjQEb6+vujYUWTHK561JQ2ykNLQ0ICTkyi/LTExEbNmMZGdnYVHjx7J3KzIrC065OcXUKul6enpP1rY1GBubib34U7E2kmaTXTq1AmrVq0Ci8UCk8lEZORKlJaWwtzcDB4ebNy7d1fuKnlaWhqCg0VRArq6utRD0du3b+Ht7Y3AwCAJ/RZAMlLmtNsjCyktLU24uLhQ+q20tDRkZ2fj1auXMoYJCQk75bIeBQUFOHDgAIRCIQ4cOEA9HNvY2CicIw8PD4nXunfvjujoaLBYHpg2bRql37KxsYG7uzuuXTsl97u2du1aqoDW19enrNAzMzMxatQozJw5EwMGDEBYWJhSrSb/tEW8eLvM+vXrKTfAadOmKc1IiaOhFvHkg1+7du2oh8Pbt29jxYoVyMnJwdChQ8Hj8SgWICkpSSmWQhylpaUQCoUqWcQzGAzk5+fj5cuXqKqqQnR0NIYNGwYdHR0sWrRIwjRCHP9Ji/jOnTtT+q2rV6/C0dERTCaT0m8pw7jt3LnzH7OIZzAY1OJfaWkpVq1aRTFuHh4e0NHRUblIePr0KcUqKgtxi/gePXpQ95Bz585R+q3Ro0cjKCiIWnDYu3ev3OuRPFRWVqK6WnZRVhHU1dVRWFiI169fo7S0FOHh4di+fTtatWqFFStWyC14G2IRrywj1bdvX8re/fjx42AymfD19cWECRPg7+9fr34LAHbs2NGg9kc6RqpJkyZYsmQJlixZgoKCAvB4PGpBavbs2UoxUtK4d+8etm+XbalXhLCwMCoiZ9CgQdSC1KFDh+Di4oLKykpMnjwZCxcupI7n0aNHKpuZ/ELD8a8qsv4u/jeNLeRh9+7d6NChg0wGizxGCgBOnjyJWbNmgcVi4dmz54iLi0NBQQF69eqNx48fY9euJJkx0owUQBZubOTk5GDaNGdcv34du3btgoGBAbhcLnr06CHX2VDcIp5sA7S1tUVVVRVcXV3RpEkT+Pr6YubMmRJFn3jWljjI0GJx/dbp02fg7++Ply9fwtXVVSYUuKamVq6I9vz583Bzc4WnpycePXqMzZs349u3IvTv3w8PHjxAfHy8zBhpRgoQ6be4XC6KioowadIknD59BrGxcWjXri3lBijP2fD169do2fKnRfykSfaYNElUuLm5ieZozpy5mDXLXeLmmJubqzC0eNCgQRg0aBCEQiF+/13kBvj69WswmUyZDBZ5jBQgehBycXGBj48P7ty5g+joNT/cAAfjzp07tKuHdKHFTZs2xbx581BVVYVx42yRnn4UW7ZsRceOHeDn54f27dvLZG2RkG7JIh+US0tL4e7uDg0NDcybNw9sNlsiNyk7O4fW1U1kEW9E2biL9FsiN8C3b9/Cw8ODdo5EjJRsYXD79m04O0+Hn58vrl+/jsjICJSWlsHc3BwZGRm0zCZdaDFpa71hwwbo6upiz540xMSsR9euRvD19UWbNm2QmXkfCxbIZ6QYDIaEY2JxcTGYTBaaNGmMRYsWwcvLS+Lm+PnzF9qsKdIinrRxr62txb59++Dn54fLlz9i/ny+zBwJhUIUFxfTPjhnZGTA19cXq1atotplpMMzpfH9+3eoqan9RyzimzRpgsDAQAQGBiInJwdWVlbQ1NSEk5OT0u0ydKHF9UERIzVkyBAcO3aMKpJJ/dbUqVNx+PBhlYvNhmqkSEMOLS0t8Hg8avWfdAPs1KkTwsLCJMwgXrx40SBDDlUt4t++fQs2m421a9ciOTkZkyZNglAohKurK3x9fWmL5P+kRbyOjg5WrRItcr579w6jRo1CkyZN4ObmhvDwcKXOj3/aIn7MmDEYM2YMhEIhYmNjMX78eKipqcHDwwMpKSnUQ7SyWLt2rcruj+KhxXp6etS/87NnzxAWFobFixejd+/eiIiIkMjQUiW0mATJeKqC8vJyuLq6YtOmTZR+q3HjxuBwOHBxcaE9j0hG6j9hEa+vr49t20SdCw8ePICDgwOaNGkCLper9IJUZmamytlYACjWShrTpk3DtGnTqAWpESNGQFNTE3PnzsXjx/QuxL/wn8H/iSLrf9vYQh7q6urQqlUraGho/GgD1ICz8zSMGTMGqampckXkpEYKELUBkiLV9PSjOHNGlHsxYsQIuLq6UkWVIkaKLKScnCYDEK28CQQCfP78GaWlZfj2rYhqAyQRF0cfWqyhoQFdXVEWFNkGmJiYhNatDdC//wC5ffPSocUMBgN2duMxZsxoeHt7UyuMWlpacHV1hY2NDfbt2yt3BfjixYtU+6O4fuvw4cM4ceIE/Pz8JPRbgIiRkpdJ8vTpM/j7+1MX6MzMTGzYsBG5uTkoKytDWVmZjKg+Li6Odo60tDShq9sMycm7KP3Wjh0CtG/fDgMHDkT37vRtQ9KhxQwGA5MnT4a9vT08PT1RUVFBZVwxmUwMHTpUISMlHlpsamoKU1NTCIVC7N27Fx8+fMDs2XMwceIETJ48mfrcihipR48eIykpkXrvrVu3EBUVhcLCQpSWlqKyslJGUyQQyDJSgOgBp3lzPSQn76LaADdt2ozOnTth8ODBtFlbgCi0WNwERaTfcoaTkxPYbDa+ffsmod8aONAEhw4dksnaIiFuEW9lZQUrKyvU1tZiz549+PDhPebPnwdHR0dMmDBBYo7EnQ3FkZn5QGKOrl27hvDwcBQVFaG0tBQ1NTUy+j15ocXNmzeHnl5zJCcn482bNz+CuPPQvXs3DBkyRK6zobRFvLq6Otzd3eHq6opJk9h4/fo1LC0t0aZNG4SEhMDU1BRxcXFyWZ3U1FScOnUKgGS7zKZNmzBy5EiqXUb8YU6V0GISDbGINzQ0ROvWrXHjxg2V2mXqCy2mQ2JiotwuAhIMBgMuLi7UKvLKlSvx5MkTTJkyBfPnz1dKvwU0zCJeHiMlrt+6ceMG/P39kZ+fD0tLS9ja2jbIkKOhFvHHjh37ESvABpvNVqjfAlQLLSbx8eNHlRkpIyMjtGnTBhkZGbhw4QLmzJmDb9++YdSoUVixYoXcxYKVK1ciOjpapeNLS0url5FiMBjw8/ODn58fiouLwefz8eDBA7i7u2P58uVKu0f++eefuHLlikrHJ4+R6t27N9WR8Oeff8LT0xMlJSUYN24cRo0a1eDQYrrFNEXYsWMHDh06JKHfKigoQHh4ODZv3gwDAwOEhoZKuOXGxMTIva/JQ05OjsqM1IABA9C2bVtkZGQgPT0drq6ulBugvAUpoP7QYjooYxEvvSDF4/GQk5Oj8uLXLzQc/9VF1r/F2EIebt26DQsLCwwdOhQsFguFhYWIjY3D7t2p+PjxA+1NvqCgQIaRIvH8+TMEBwdj2LBhYvotDbi4zFCKkSLRp08fxMTEYMmSJTA2NqbaAEeNGo2ZM0VugNJZWyTEQ4vJNkBA1DM9f/58tGnTBtHR0eBwONTqY01NjdxVpLS0NIwYMQJsNhve3t7Izc1FXFwcEhIS8OnTJ7mufU2aNJG5YJGhwEFBQbCxGYaUlGSqcHN3d8eTJ09pNRivXr2SCS02MTHBpk0bsWzZMnTt2pXSb9na2mLq1KlQV1eXy0iJhxaL67fu38/E0qVLYGhoiI0bN8Lb25u62Ek7G4pj//79GDZsGFXQffnyBbGxsdi2bTs+ffpIy9rRMVLkHGVlZSMgIADDhw/Hzp0/9VssFguPHtEzUnQW8aQbYEBAANq3b//Dxl3E6Dk4OIDBYCA3VxEj1QXAzzZAQMSaLF++HIaGhti2bRvYbDZVuElnbYnj0KFDsLa2prLj3r9/j7i4OGzcuAGfP3/Gzp07ZcaIOxuKg2yXWbJkKUaMGI74+HgcPHgIenrN4eXlJTdr6/3799DTk7T2tra2hrW1NQIDA9GqVSvKcW3KlCkYN24cGAwGrbMhAAlDjm7dulEPc1evXgWPx4OhoSHi4+Ml9FvSzobiOHz4CGxtLbBggcg16/Hjx+Dz+fj8+TPevn2LjIwMmTHyGKkmTZrA398f/v7+yMvLQ1hYGGJiYmBoaIjQ0NAGhxarahF/4cIFinEQb5c5ePAgZsyYgaqqKjg5OWHBggXU9ULV0GISKSkpSmmkSGhqakIoFGLNmjWYNGkSeDweVq5ciY4dOyIsLEyutqahFvHKMFIWFhY4ceIEhEIh9uzZAzc3N3Tu3BlbtmxRSr8FiLoz5LVjy4M8RkpavxUaGoqQkBAYGRkhPDy8waHFqq7U//XXXxQjNWrUKIwaNQpCoRAJCQlUmyWTyaTiQgDReSRPS6wI8fHxKjFSzZs3R4sWLRAWFoYJEyZQxXTPnj0RHh4u19q+vtBieXj06BHtPUUcdnZ2sLOzQ21tLXbs2AEnJyd07twZKSkpSum3gH/WIl5fXx+bN4ucWR8/foywsDB8+vSJiqdoaGixpDtr/bh37x6ldXJycoKTk5OEG6CmpiZmz54ts9jbEEMOVS3iDQ0NMX36dAiFfz8O6ReUhxpB/N14338OfU16E3vPbVHqvf8mYwt52Lp1K/z8/GQStQsKCrBw4UK0aWP4ow2wJ7hcLlq2bIlVq1bB3NycdlWZxfJAcvIumW1FRUXh/v37GDRoENUGSGLJkqUSmi5526uqqkJqaiquXbuG8vJyCQpcHFyur0TWFomamhpwOBzs3LkTZ86cQXp6OqqrqzFmzBhUV9cAIMBms2W2x2azKR2ZOL59K8KcObPRunVrfPv2DcbG/cDh+KB58+ZYvXo1Bg8eTPtAwWJ5YNeuJAk9XnZ2DtasWY2HDx9iyJCh8PXlSqze+vv7w8PDg/ahR3yOKioqsWvXLty8mYGqqiq0atWKtlD28/OjsrbEUVtbC29vbyQmJuLEiROUWH38eDtUVlaisrISPj6yzJinpyelkRJHUVERuFxftGnTGsXF3zF48CCK6Vq7dh2MjfvS6jBYLBaSkpIkboSfPn3G2rXRePToEaysrKg2QBIBAQFwd3dHv379aLeXnJwMQKQlSUxMxN2791BXV4uWLVtSNz9xzJ49m8rakjdHhw8fxqlTp6CmpgYHBweUlZXj+/di2hBuLy8vSiMljpKSEnh6eqJ16zY/9Fvm8PDwgJaWJjZs2IDu3XvIOPeJPpOHBCMFiB5+162LwdOnTzB8+HD4+flJHP/y5cvh7DydtmASP4+Ki4sRHx+PR48eAyDQvHlz2jmaM2cugoNXyBRMQqEQbLYndu5MwIEDB3Du3DkqvLqkpAT5+fm0lr5eXt7YsmUztLXNAfz8vn3//h1mZmZo166djGvWsmXL0LNnT7mh3tLIzMzEkiVLcP/+fUyfPh18Pl9pq2CyRVMVjB8/Hjt27JDLxlRXVyMmJgbHjx+HlpYW5s6di69fv+L169cqubSVlpbCzs5O5Qd+CwsLXL9+XeI8un37NiIjI5GTkwMzMzPw+XyJ6ymTyQSTycSYMWOU3s+VK1ewY8cO7N27V+kxQqEQlpaWuHDhAqKjo3H69Gno6OhgyZIlcsO8AZGJxIkTJ1TSi4WGhqJ169ZK5xpduXIFoaGhePDgAXx8fBAcHKz0/szMzHDz5k2ljw0A7O3tsXbtWrmZWt+/f8fKlStx+fJltGjRAgEBAfj8+TPu3r1Lhesqg8rKSowePVplltLS0hJXrlyRKJjOnj2LtWvXori4GGPHjkVQUJCEE6y3tzfVCaEsbt++jejoaJW0S0KhEBYWFjh9+jTCw8Px119/QV9fHytWrKDNRiQxcuRIHDx4UKUWvpUrV0JTU1PpnLXff/8d0dHRePJEZEK1dOlSpfRbQMOuR/W1LOfl5YHP5+PevXto27YtQkJC8O7dO4muE2VQXV2NESNGyI2fkIcVK1YgPDxc5pn0F/4+1NTU7hIEIeOs8u+tUOTg32ZsIQ/l5eXQ0NCkPZnJAF3ShOL8+fNYvnw5qqqqkJubSzmFiUNeaDF5gdqxYweEQgICgQAFBV/Ru3cvcLm+cq1vpS3iNTQ0qEBHLy9vtGrVCiyWB9q0aQ0Oh4Pu3bvTZm2RIEOLGQwG5VJEugGmpqaiV69e6Nq1q0S7jUhHJj+0mM1mY+zYsT/0W6exdOlS1NbWIi8vj7Ythgwtlj4v2rY1ROPGjbF169Yfq0qbUFT0DQMGDICPj4/c/niRRfxP0xItLU34+fnCz88XXl5e0NXVpUKBORwOunTpopCR2rdPZBFP2rg7ODj8KNySsG/ffvTp0xu3bvWXWN2j05GRiI9PgIeHB+zsxkMoFOLYMZF+iyCAvLxcLF4sy0i9fv0aenqyLVkdO3aAlpYWNm/egsrKCkRFRaGkpBSmpqbw8vL8kbUlW2CJLOK7Ur/r6OhQrSZeXt5o3LgJWCwWOnfuDF9fX7Rr104ma0scZGgx2Qbo7OyMkpIS7Ny5E+npR2FsbIz79zMlChl5jJRojuLBYrFgb2+P2tpaHD58GHPmzP7BsuXStsXIs/Y2MjJCs2a6WL9+A8rLyxAeHo7S0jJYWlqAyWQpxUgBoNqiyDlSU2OAxfKQ0G8pZqQOY+jQIZSNu6urK759K0JCQjxOnPgD/fv3w5MnTyTO6dLSUrHQYpGVO4nIyEgsXboUXl5eqKmpwebNm6k2wJycHJWKERMTE7Rp0wbp6ekoLCyk9Fvi4Zl0uHDhgsLQYjooYxHfpEkTBAUFISgoCDk5OeDz+di3T2SM8/DhQ6VblVauXCkRWqwM5DFS4vqt/fv3U2HMzs7OmDdvHl6+fKlSgQUAq1evbrBFvLa2Nvh8Pvh8Pj5+/IjQ0FDw+Xx06dIFYWFhEveP8vJylQ05AFFBoEqBOmzYMHTp0gUBAQHIysqCvb09hEIh3NzcwOVy5TIlikKL5YFkpBSFFjdr1oxyAn3z5g1CQ0Pxxx9/YOzYsXj37p3SLZf/pEU8mXMpFAohEAgoZpzNZoPFYjUotDgyMpLqKlAWJCMlrd/i8XhYtGgRrX5LldBicahqEe/g4IATJ05g0aJF+PDhA0aPHk3pycmwezrcvXu3Qe579TFSrVu3pswtMjMzER4ejosXL8Le3h65ubm090Q6bNiwQenWYxJlZWVUrtYv/A+CIIh/zU+fAb2IB/ln5f68/36JqK67RRDEnX/9z/HjfOLVq320f2MyjWlff/gwiZgypQvBZvcnOBxT4ty5NdTfFi8eQTx/vkfp7Z05E0VMndqFGDOmBZGcPJ+orr4h8XcOx5T4+vWMzLjq6huEh0c/6vfHj5OJRYuGEUxmX4LJ7Evs2OFNewweHv1k9kEQd4ivX88QHI4pkZPzBxEe7kgwmcaEv/8o4vXr/cSqVdOIs2dXqzRHjx7tIhwdOxAsljHh6zuEuHp1I/W3JUtGEE+epCi1vbq6W8Tx43xi6tQuxOjResTevUuJmpoMifdwuaZEfv4pmW3V1GQQLNbP7d27l0DMn29FMJl9CU9PE2LbNk/aY2Cz+xOVlddlXi8sPEdwOIOJrKzjRGjoRILJNCaCgmyJDx+OENHRM4g//4yU+5nqaL4Pjx7tIiZNakewWMbEnDnmxK1bO6i/+fuPIh4+3KX0HB0+vJyaoyNHgmX25+c3lMjJ+aPeOcrI2EbMmWNOMJnGBJdrSmzdyqY9Bk/PAUR5+TWZ14uKzhPe3gOJd+8OEYGBYwkm05gIDZ1IZGUdJ2JiXInjx/kqz9GECYYEk9mXmD/firh/P4H6W2DgWInfFc1RTU0GkZa2hJqjEyfCZPY3e7YZkZV1XGZbdXW3JLZ35cpGwtd3CMFkGhNz51oQW7Z4yJ2jsrIrMq9//36R8PIyIV692kf4+48imExjIjx8MpGX9yexYYM7kZ4e/OO97wlxmJmZEXV1dYQ0MjIyCBsbG5nX64OZmZnE71VVVcSaNWsICwsLYuTIkcTBgwdlxowbN454+/atSvuJjY0lAgMDVRpTUlJCWFtbE7dv3yYcHR2JoUOHEnPmzCHy8/MVjpM3R4owa9Ys4ty5c0q9t6KigggLCyN69epFGBgYEMePH1d6P3V1dTJzrgxsbGyI4uJiuX+/evUqMXHiRGLo0KHEokWLiG/fvhHBwcHEtm3bVNrP+/fvibFjx6p8fNKfqaSkhFi+fDlhbGxMmJub087txIkTiefPn6u0n5SUFGLhwoUqjSkrKyMsLS2Jc+fOEePGjSPMzMyIwMBAoqSkROE4c3NzoqamRqV9sdls4o8//lDqvd++fSMWL15M9OnTh2jdujVx9epVpfdTV1dHDB06VKVjIwiCGD58uMLvzx9//EGMGTOGMDc3J/h8PlFRUUFEREQQ69atU2k/WVlZxKhRo1Q+PunzKD8/n5g7dy5hZmZGODg4ELdv35YZ4+joSGRmZqq0n4MHDxJ+fn4qjamqqiIsLCyIQ4cOESNHjiQsLCyIqKgooqqqSuE4CwuLet8jjdTUVOLBgwcqjfkF5QHgDkFT1/xXMFn/VmMLRTh+/AQePnwIDocjsVrz9OlTtG4ty3IAwK5du7Bq1Ur07Nnzh34rFikpu6Gvr48vXz4rxUiRGDt2LA4dOoxt27bh5MmT8PHxgaamyG7aysqqHkbqJ9sk7gY4bdo03Lt3D56enhg1ahRcXFwo/Yo8HRkZWkyK7AGRgcKWLVtw//59qKurY8iQIRJWvi9fvpQbWrxr1y5ERa1G7969kJ2dg9hYAeLjE2BoaIgvX77Q9sdfunQJv/0maTbBYDBgb2+PEydOYNOmTTh+/DiVv+Xu7o6hQ4fKDWOUtogfONAEAwduglAoxJQpU3D37j14eXlh/PjxmDp1KhgMhkJGigwtJm3cAVFv97p16/DgwUM0btwY1tbWEroYUdYWvW11SkoKoqKi0LdvX3z58gU7duzA1q3b0KFDhx996rL2rVevyoYWk9ohUVvKOhw//jvYbE80a6b7IxfMRC4jdfDgQQmrXzMzM5iZmVHBydXV1fD29sakSZMwadIkMBgMKmuLjpESmU04okuXLpTW58aNG4iMXInHjx9j+nRnVFRUSoxVFDa7Z88erFwZCRMTE7x79w5xcXHYsGEDjIyM8PHjJ9rVyL/++kvGIl5dXR0zZ87EtWvXERW1GseOHcWBAwehp6cHb28v9O7dmzZrC5ANLbaxsYaNjTVqa2vh5OSE0tJScDgcODk5UavUJSWlEllb4ti5U2QRT9q4AyJ9YGhoKJ4+fQp391moqqqChkYJNebVq1cSDpni2Lhxo4RZjTKgCy2WDs/k8/lYt24d2rZtCx6Ph/79+zcotDg1NRUnT55UaQwZWmxqaoqjR4+CIAjKDbCqqgpTp07FggULJFgDVUKLxfHy5Uulc8I0NTURGhqKjIwMxMfHIykpCZGRkejYsSP4fL7CbKSGWsQTBKGQkbK2tqb0W7t374ajoyMePHiAiIgIGSdYReDxeLTdGYpAF1qso6ODlStXIjMzE4sXL0ZycjJWrFiBrl27IiIiAkZGRsjPz1fZkCMhIQFHjx5VaUx0dDSmT5+O0aNHY/To0RAKhYiPj6fasz08PMBmsyXOmc+fPzfYIn7ChAlKvVdPTw8xMTF49eoVVq9eja1bt2LJkiXo1asXIiIiFDoh7tu3T25osTxUVlaipqZGISM1YcIETJgwAbW1tdi+fTtGjx6NJ0+eYNOmTTIup4rQUIt4aUZKX18fW7bI6lL79++P8PBwGBoaIicnBwMGDFBpX9u3b1dJIwX8DC0Wj6cg9VsaGhqYO3euTHxMXl4eNDQ0VLaIf/TokcqOpb/w9/GvLrL+7cYW8pCXl4cRI0agTZvWWLEiGNXVVRg2bDjc3d2wc+dO+Pr60o4Tb+1r2bIlZWSxa9cuPH/+HCyWB3r16gUul0MVSAcPHqQVmJOtfW3atKGcnAoKCiAQCLBmzRpoazfFq1evZB6ILl68SCt6LSoqgoFBa8TGClBVVYXdu3dTphIMBkOBs6FsaHG/fsbw8/NDXFwcjI37wt/fH7W1tRgzZgymT5/+w7XPh3Z7+fk/DTnatjWk8qGSkpLw6NFDsFgs9O/fHxwOh3IDFM/akp6jyspKtG/fHr6+vvD19UV2dg4EAsGP3m8tvH//XuZmT2ZtSaO4+DvatGmD2NhYqg3Q09PzR6tHY7lZW48fP5bpMR80aBCaNWuGrVu3okuXLj/aAAnY2dlhypQptFlbJHJzf7Y/tm/fnvrsO3fuxN27d+Dh4YHBgwdTxwYAaWl7qLkUB9n+aGTUhbrBffr0GQKBADweD02bNsWXL19ksk7khRaXlJSgTZs2iI+PR2lpKXbu3AlPT080a9YMTZo0oc0kAUT2wNKGHBYWFjA0NMSGDRtgYGCAuXPnQE1NDY6OkzFx4gTExsbC01NWBwhIhhYbGRlR36H4+HjcuHEDLJYH1QZIFm579uyhgrql56isrBQ9enSn2gDfvHmDuLg4PHnyBE2bNqVtBZEXWkxa8ickJKC4uBhxcfHYt28f9PRaQEtLU26byP37mTIPIcOHD4eRkRHWrl37o91VZG4wZsxiTJs2E6GhoVi+fDnt9uSFFiuCeNYWHaTbZcLCwpCZmYlmzZohLy9PrhugNKRDi5WFdGixmpoaZsyYgRkzZqCyshIxMTEYNmwYtLS0MH/+fDg6OiIkJETlIuHSpUsSbbTKgHTtI81SAFH4cWBgIPLy8mBpaYmQkBCZxbHk5GSVDDkAkQW7q6urUu9lMBhgsVgYMWIEPD09kZ+fDxsbG+jq6mLJkiUYN26cwvHyQosVYdWqVbQW8eQckcUNINJvzZs3Dy9evEDz5s3x/ft3pdsZpUOLlYV0aDGDwQCXywWXy6X0W5aWlmjZsiUCAwMxbNiwBoUW37x5Ex07dlRpDGkRTy5gASI3QG9vb3z//h22trYIDAyUWaiJi4vDkSNHVNrXunXr5N7XpKGuro758+dj2rRpmDFjBjIzM7F9+3YYGBggODi4XsfFhljER0ZGSjj2SsPY2JjK3/r999/h5uaGT58+oXnz5j8WpGQXRekgHVqsLKRDi6UXpHg8HtauXUstSJmYmIDH4ymtbSSRnZ2ttDb2F/5Z/GuLrP8GYwt5OHPmDMaPHw99fX2MGjUKNTU1SEtLA4fDwbt37/DhwweZ4ubs2bNye8Jv3LiB3btT0LJlS5w7dw5BQct/FG7DUFVFz0ilpu6RsYjX19dHcHAw2Gw2Fi9eTOm3+vbtAx8fDghCCA0NeYzUT4t4DQ0NKtAxPz8fM2fOxO7du3H69GlwuVzKtYvO2ZAEGVrcu3cv2NnZUfotHx8fvHv3jvZhm8zaokNGxk2kpIjm6OTJk1i8eDHq6uowZswYBYyUrEV827aGCAvjw9PTE76+vtiwYQOKiopgYmICb29v1NbWKdBI/QwtJh9o/fz8kJ2djVmzZqGo6BsuXboEX19fakVRxEjR21aThVTfvn0xefJklJeXIylJVLh9+PCB1o6ezNqiw507d7B79260atUKx479jgULFoAgADu78XKztugs4jt27ICVKyPh6ekJT09PSr81ZIgpPD09UVNTQ+tsKPpM8ZSVro6ODuXSJwpOFj3A3bx580cosIj9ETEJ9HMkEMTC29sb/fv3x/Tp01FSUoKEhASw2Z74+PEDXFxcZMbQrZKTyMzMxK5dyTAw0MehQ4cwd+6cHxo6R4UaKTMzyQeEbt26Yc2aNfD09ISbmxv4fD7KyytgbW0FJpOJ6upqmawtEgkJO+Ho6AhApN/y9xcVbq9fvwaXy0V2djYePHgAX19fSvsnnrUlO0cCeHp6YuDAgXB3d8e3b0VYvXof1q/fgpcvX9KKyM+ePUvLkCuCMhopcZiYmCA9PR02NjZU5l5FRQUcHR2xaNEihSu1DbGIf/v2rUJGSlNTEytWrMCKFSuQlZUFPp+PqKgovHr1CoGBgbRj5GHNmjW0ZiaKQGcRb2ZmRhnk7N27F1OmTEFNTQ2mT5+OOXPmoLKysl5Gig7nz59XWTQfGhqKwMBAjB07FuHh4ZR+KzQ0FEZGRjL6LUD50GJxCIVCuVri3bt3y1yPhg0bRv04OzvD3t4eBEHA3d0dPj4+CpmSNWvW0F4jFOHjx4/Q1dWVy0iJ67devXoFHo+HZcuW4fXr1xLxE8pAPLRYWezdu1eGkRJ3AxQIBLC1tUWjRo3g6emJWbNmobq6GjU1NSqFFgPAH3/80SD3R39/f2qx6MmTJ+Dz+fj06RP69OmD8PBwGTv427dvN8giPjs7W2ndJamTHjFiBOUw2bhxY8yePbteHZ280GJFyM3NVWgR37p1a2rB6v79+1Q8xdu3b6mOF2Wxf/9+lbWAv/APga6H8H/rp8+AXsTjgnNEfvk1Qii8TdDpEf7tP0LhbWLjxlm0fztzJooIDbUnVq2aRjCZfSV0VhzOYKKw8KzMmOrqGwSb3Z/2dT+/ocSECYYEl2tKXLiwVuLv9WmkxI/39OlVBIczmBg7tiWxYsV4GW0SnRaF/Hn+fA+xePEIgiAk9VvR0TOIefMsiadPU2nHydvehQtrieXLxxF8/iSCyTQmli0bTbx+vZ8gCPkaqerqGxL6H/KnvPwaweWaEhMmtCH8/IYS165tkpmjqqq/ZMaRGilx7czvv/MJLy8TYuzYlkRo6ESitvYm7Wei0/+8erWPWLRoGEEQd4i7d+OIefMsCSazL7FhgzuxYIE18fhxskpzdOlSDOHvP4oICZlAMJnGxPLl44iPH48SBHGH8PUdQuTl/SkzRlojRf6UlV0hOJzBhJ1daxn9FkHI15GRGinxOTp0KIjw9DQhbG31CT5/Eu1cMJl9aV9/+/YgMX++NUEQd4gbN7YSc+aYEyyWMbF9uxexZMkI4sGDRJXm6Nq1TcSiRcPE9Fv2RFbWCYIgRDoy8v+l54hue6TWadw4fWL+fGuZY5GnIyPHiW9/z57FBJvdnxg3Tp8ID58sZ47oz6MPH44Q8+ZZEgRxh7h8eT3h6zuEYLGMibg4X2LZstHEvXsJKszRe+LMmTPEhAkTiKlTpxJmZmaEj48PkZ2dTRAEQdja2hLv30tqt+rD9u3bieXLl6s0pri4WEL3VVVVRaxevZrSbx06dIh2XEM0Um5ubsT58+dVGnPx4kVizJgxhIODAzF06FBi7ty59eq3GqptqU8jRaK8vJzg8/mEubk50alTJ5V1IO/fvydsbW1VPj5Fuq+rV68SEyZMIIYOHUosXryY+PbtG0EQBDFhwgSVNVIJCQlE+/btCRcXF+Lly5cSfxs2bBi1bXGQGikSJSUlRFBQEGFmZkYMHz5crjbOzMxMZY2Uh4cHcfLkSZXG/PXXX4SVlRUxbtw4wtzcnFi+fHm9+q2Gau2GDx9OfP36td73kfotMzMzolu3bsTcuXNV2s+XL18apJFS9N04fvw4MXr0aMLMzIwICwsjKioqCIIgCAcHB+LRo0cq7Wffvn3EnDlzVBpDaqRI5OfnE3PmzCHMzMwIR0dHWv0WQTRMI8XlcuVe3+Th/v37xODBgyn91po1a5Ta77Jly1Tazy+oDvw3aLIaMdTwW4tmaKxi7/u/CS9fvsRvv9H3hB86dAirV6+hgn+fPXuOuLh45OfnIScnBwSNnb680OLGjRujoqICR4+m/2gpiqNW4GfMmKFAIxULF5ef4Y5qamqwtbWFra0tmEwmjIyM4OPjAw0NDcycORPDhw9XyEjFxcWDwxG1rYnrt86cOYMTJ/7A2rXRVBsgufJ3/vx59OpFP0f79u3HypWR1P5I/VZhYSFyc3NpP1NaWhptSKiWliaqqqpw9OhRFBR8hUAgQFxcPNq1a4uZM2eicePGtKtI4owUIGoFmTTJHpMm2YPJZMLQsC08Pb2go6ODWbPcYW5ujlevXstkbf2cozjKAnvQoEEYNGgQhEIhjh8/jvT0o4iJiYGdnR2l3wIks7Zk52ifhEX8nTt3EB29BsXFxcjLy4OWlhbtGCsr2QBLbW1t1NTUID09HXl5+RAIBNi6dSs6duwINzd3hYzUlClTJOaI7CtnMplo0aIF1Qbo4eGBQYMGKQybFQ8tNjc3h7m5ORUuvW/ffhQVFcHBwQH29vbUePGsLWmkpaUhNDSUYueuX7+OyMgIlJaWIi8vTyavBxAxUnShxbq6uhAKhUhPP4qcHFG4dEzMehgZdQGTyZTrbCgdWizuBjhr1ixoamqCzfZEixZ68Pb2hrGxMW3W1s85+hlaTK7c19bWYt++fcjIuIlv375hypQpsLW1pcbfuJEhJ7S4BOvWrUNcXBzlxnbs2DG4ubmhrKwMX758oWXtFGHPnj1UaLGyWLlyJVgsFvV7kyZNEBAQgICAAOTm5oLP58u0yzQktBgQMYHyApflYc2aNRAIBOjWrRuEQiEOHjwIZ2dnVFdXY+rUqZg/f74Mo5GYmCg3aF4elNFIkdDS0gKPxwOPx4OpqSkqKipgbm6OTp06ISwsTKFLHiA/tFgR6mOkrK2t8ccff1D6LQcHB9TW1iI7O1uma6M+pKSk4PHjx3j48CHmz5+PwsJCDB8+nOpOoPvurl69GjNnzqR+19HRoVzyTE1NkZSUhBUrVqBbt24IDw9Ht27d6mWk5OHZs2e00RiKsHLlSsTHx6N3794QCoWIjY2FnZ0d1NTUwGKxZPRbgIiRUmSBTgdSI6UMI0XqtwDRfSk3Nxfm5ubo3bs3wsPD621TDA0Npc0LVIT6GCl7e3vKCXbr1q0YPXo0GjVqhKysLJXzyAQCgUpW9ICIkRK/9+vr61MxLQ8fPkRYWBi+fPkio9/S0tJSWSOVmZkJgUCg0piwsDAkJCTAxMQE1dXVWL9+PZW/NW/ePNrA5UePHtE6A//C/xDoKq//rZ/Bg+lXpf+bfgQCH9pVbXmMFEHcIRIT5xDLl48nOBxTwsOjH5GUNJdioeQxUvn5pyQYKfLn6dPdxIQJbQhHxw5EVNQ0orDwnMTf5a38P32aSjFSBHGHyMv7k4iImEwwmcbE2LEtiTNnomjHMZl9aV8/d24NsWrVVKKy8joRF8el3ACvXNmg0NmQjm0hiDvErl3zCH//UYSPzyCCze4v4QYob46kGSny5/79BMLOrjXh4NCBWL/ejfj+/aLMHNExqS9f7qUYKYK488MN0J5gMo0JW1t9lZ0SL12KIcLDJxNlZVeIrVvZBJNpTMyebU5kZGxTmZEiiDvE7t0LiQULrAlPTxPC03MAcehQEMWIKGKkfHwGybx+69aOH3PUnti82UPGzU4eI/X69X5iwQJr6vcPH44Qy5ePI5hMY2L8eAPi/Plolebo6tWNBJ8/ifj+/SKxYYM7wWQaE/PnWxH37iUo7Wwo/pOWtoSYPduc8PQ0IXx8BhHHj/Opz6EsIyV+bHZ2rYlJk9oRsbEcmfmVN0fv3h0i5s+3kpgz0g1w4kRDBXNE/13766+tRGioPVFYeI5Ys2Y6wWT2JRYtGkY8eZJCzJ5tLtfZ0MqKfkV58+bNxIgRIwhLS0tixIgRxP79+2nfJw5pRkpZKMtI3b17l3IDNDIyIo4cOaLSfs6fP0+4ubmpNEYRI0U6pJmbmxOjR48mjh07Rv3N2tpaKUZKHEFBQYRAIFBpzNu3b4lx48ZRv//111+UG+DChQtpGR+CUMxIyYOdnZ0Mq1QfYmNjiSFDhhBmZmaEra0tcebMmXrHlJWVEVZWVhKv1dXVUexWly5diO3bt8ucM/Jc+z58+CDhbHjx4kVi/PjxhJmZGdGnTx/i8OHDKn2ma9euEc7OziqNUXQeFRcXE/7+/oSZmRlhZ2dHXLlyhfqbsoyUOMLCwogNGzaoNObLly/E6NGjqd9PnjxJjB07ljA3NydCQ0OJsrIy2nENYWvt7e1VZqTi4+OJvn37EkOHDiXs7e2JW7du1TumoqJCgpFSFsq6P6anpxOjRo0izM3NiUGDBil1jRTH3bt3CScnJ5WPT953Nzs7m+ByuYSZmRnh5OQk4SIYFhZGlJaWqryvX1AN+G9gsv7bUVtbi8uXL+Ply5eU3ohEamoqlYsljcuXLyM+Ph6NGzdGTU0NUlP3wMfHB40aNUJ5eTktexMXFyfBSJHo3bs39PUNkJy8C2fPnkVgYACqq6sxcuRIDBo0iDZrCxA53HE4HOp3UowKADNmzMCff/6J1NRU9O3bFz4+HLRooSfX2RAADhw4iKioVdDQ0ICPjw98fHyQm5uL7dt34Pnz51izZg04HA6l3wLkM1KASEhOhhZXVFRi926Rfqtx48Zy5yg2VkCrWzIxMYGBgQESExPx559/YvHixRAKhbC1tcWAAQNos7YA/DDk+BkWLHID5AMAnJ2d8fvvv2P37lQMHCjSb+no6ODy5csSWVvi2Lt3LyIiIqCtrY05c+Zgzhzgy5cv2L59B54+fYYNGzZI6LeAn1lbdLhw4QIVWlxeXo6dOxPBZrOhqamFioqKejVS4hgyZAhat26NnTt34tixY5g3bz7U1ICJE+1hbGwsVyMlYu1+zlGnTp0oo4GpU6fhyJEjSElJwZAhQ8Bms6Gtrf0ja4t+lTwtLQ08Hg+6urpYuHAhAODDhw8QCAR48uQptm/f8UO/9VPUS2Zt0eHs2bPYtm07tLQ0UVJSgvj4eBw8eAg6OjqoqKiQm7UlzkiRsLa2hoFBayQkJODQoYOYPXs2GjVqBCcnJ/Ts2VOu/ic2NhYeHj8NObp160a5AU6ZMgUHDx5ESkoKrKyswWTOgoaGhkzWljhSU1MRHLwCLVroYdmyZQBErE1sbCweP36EnTt3gsv1lfjuHz58BHZ29OfR/v37cfr0aTRt2hT5+fng8/lYv349DA0NERoaikGDBsmMiYyMlGCklIEiZ0NpDBo0iHKA69GjB7Zs2YK1a9di8uTJWLhwYb2ryNHR0SqFfQIiJlLeNVtTUxPBwcEIDg5GVlYWeDweVq1ahbZt26KiokJljdSFCxdU1kjxeDwJRsrCwoJyA9yzZw8cHR1RW1sLFxcXyvDk6tWrDdJIFRYWqsxIpaam4ty5c2jWrBk+fPiA0NBQhISEwMjICOHh4bTbi4qKktFIMRgMeHl5YefOnTh16hTWrFkDS0tLNG/eHMuWLUP37t3lMlKhoaESmsMRI0ZgxIgREAqF6N69OzZu3IgNGzZg1qxZ8Pb2rvdcjIqKwtq1a1Wah7S0NAmnVXE0a9aM+u6T+i1/f39069YNZWVlKmuk/vzzT5U1UqGhodS1FZDUb+3YsYPSb3l7e8PNzQ0MBgO3bt1qsCGHsbGsu60i7NmzB5cvX0arVq0k3ACNjY0RHh5Om2clzUgpg5ycHGhrayvFbE6ePJlyye3Rowc2bdqEHTt2wM/PTyntU3h4OK3RlCIcOnQIAwcOpP2boaEhxYrdu3cPPB4P2dnZGDx4MLS1tSVCqn/hfxa/iqx/ELdv38aiRYvQrFkzxMXFo6CgAL169QSXy8WVK1cQFyfr2ldQUAANDU2qSGjcuDHYbA+w2R7g8XjIz88Hi8WCvr4BuFwOfvtNZPzw4sVLWlcw8dBiMqywqqoKqampmDdvHjp06IBLly7JtLMUFHyVaxFvYjIQQUGBEAqFOHv2LAIClqGmpgZfv37Fzp07ZcbICy1u06YNunY1gpFRFwwebIotW7bg27dvMDbuBw7HhyqkpCFtEa+lpQkOhwMOhwMejw+CIMBiecDQ0BC+vlzqIeLZs+e0gnWy/bFRo0ZUe4LIDXAXZs+ejfbt2+PGjRsyD+p5eflyLeIHDBiA4OBgCIVCKvyQdMKic2usra1FZWWlTGhx+/bt0bt3LxgZdcHAgQOxbt06FBcXU26AZCElDWmLeG1tbcybJ3Ig4vH4qK6uAovFQocOHeHr64uOHUUtGyJnw8Uy2yMNORo1aoQpU6ZgypQpKC0tRWJiIjZv3oSOHTvizp07MDWVDDgXhRbTWcRfRf/+/cDj8X60AR7BvHnzAKihqOgbtm2Tddmrra1FebmsRXznzp0xYMAAdOnSBf3790dkZCRKS0thbm4GDw82zpw5QznYiUPaIl5XVxeLF4s+O5/Px/fvxWCxPGBk1AV+fn7Ufh88eCjxEEKCtPZu3Fhk4z5z5kwUFxcjISEBa9euRadOnfDo0WOZ+cjKypYbWtyvX3+EhfFRW1uLAwcOwM/PD40bN8bXr19pjRTkhRZ3794dQ4cORdeuXdG7d2+EhASjsrISNjY2mDVrFk6dOoUtW9JktldUVAQ1NTXqpmxgYED92zx48ABhYWHIysqCiYkJ+Hw+5Vh15coVlQX6PB5PZUOJCxcuwNzcHLt371a6XUZVQw4Su3fvVsoivl27dtR3nMVioaqqCubm5hg6dCj4fH69D8p/xyKeLrSYwWBg1qxZmDVrFsrLyxEdHQ0bGxvo6Ojg69ev2L9/v0r7IUOLVYF0aHHnzp2RnJwMQHQtWLBgAb5+/Yrhw4cjODiYet/Zs2clXPtIfPjwAbq6umjWrBlWrlyJlStX4t27d+DxeDh58iT69OmDN2/eSCzaASJnQzr3wxs3bmDo0KHYt28fSktLKTdAPT3RQgVdWylpyFFfO6Y0EhISkJ6eXu/7evTogbQ00XeSyWTi+/fvsLCwwJgxYxAUFEQb2yAOeaHF9UFeaLG6ujrmzZuHefPmoaioCOHh4di2bRv09fVRUFCgctDx/v37G2QRX11djVatRJEu0m6ATCYTZWVlmDhxIpYuXQpNTdG1XdXQYkBUbKpqEf/w4UOYmpri8OHDyMvLQ1hYGGJiYtC2bVu5C1KAqKBTFFpMB2Ut4gcNGkSdbyEhIQrjH37hP49fRdY/iDt37mLOnNlgMBiIiVkHQKQ/Wrp0Kd6+fYc9e1Lh5uYmwboIBAJaRgoA3r//gOTkXQBEBUNsbCwKCgpgaGgIPb3mtGOkGSlA5Abo5eWFK1euYt26dYiNFSApKQmtW7cGh8PBhw8f5DJSBw8eQlSUqLedwWBg3LhxGDduHEpLS+Hs7Ax/f39oaWnBxcWFYqH27NkjkbUljsuXLyM2NhaNGzfGxo0bIRQKcfr0aSxYsADv3r3HwYMHJfRbwM+sLfo5ekfdvB8+fIiNGzehqOgbOnXqJHeORM6G3hKvidwAfZGRkYHVq1dDIBBAIBCgffv24HA4eP/+vVxGStwiXuREJ3IpKi0txdSp0+Dv74+mTXXAYjExdOhQALJZW+IQZ6QGDx4MoVCIY8d+x5w5c/DhwwecOHECTk5OEg9lZNYW/Ry9R1JSIhgMBm7fvo01a1ajpKQU3bt3l+tIJ83aASKdw/z583H37j1ERkZAIIjFli1b0blzJ3C5XLx79w7dutHbVqelpVErdwwGA87O0+DsPA3FxcWYPn06AgIC0bx5M7DZnlQBIp21JQ6ykNLU1ISFhQWl3/L15eLDhw84e/YcJk6cIDVHCZRrnzTevXuP5ORkMBgMXL9+HeHh4SgrK0Pv3r2hq6sjd47YbA+J15o3b44lS5bg4cNHCAkJQVxcHHJyctG1qxeGyxsAAQAASURBVBF8fX3x5s0bORopkpESZcmJ67cKCwsxY8YMBAUtR8uWLeDt7U3dOKWztsRBWsRraWlixIgRqK2txd69++Dt7Y2PHz/iypU/MG5cLwnWduXKlfD09KTd3oABAyiL5/T0dLi5uaG8vBzW1tYNKhIaYhEvzkg1adIEgYGBCAwMRE5ODvh8PlavXo327duDz+dTrmKKGCl5KC0tBQAqBkJZvHjxAg8ePAAgeqgks2+mTZuGefPm0T4Ah4SEUAyksrhy5YpSFvHa2trg8/ng8/n48OEDTE1NMWvWLHTp0oXWDZAOSUlJ/6hFvI2NDWxsbCAUCrFr1y7Y29tDKBRiwoQJchkpadYOEEUvpKSkwMzMDOHh4Zg7dy7evn0LR0dHBAcH49GjR3LZX3GLeB0dHSrC4c2bNwgNDUVQUBB69OhB5W8Bou+nvOuRPDTUIv7Vq1d48uQJGAwG5QbIYDDAZrPBYrFov2uhoaHUopGyuHnzplKufXp6etR8PX36FDY2NvD29kbv3r0RERGh1DZiY2MbZBEvrv0VB3mfra2txebNmzF69Gg0btwYLi4u0NLSUrnY/LsW8a1bt6YWpDIzMxEeHk67IHXw4EG5xZc8VFdXo7KyUmWL+NraWjg708fr/ML/DH4VWf8QysrKoKmpKXPxGz16NG7cuAFXV1d8+vQZHA4HTZpoYPp0Z4wePRqvXr2mzd559uyZRHtP7969KJGqu7s7dcEdOXIkZeIAQK71LdnaZ2CgT+3vyZMn2LFjB+7du4eRI0fi27ciypQDkM9IAaLiy8XFBSwWC/n5IsOExMQktGnTGh8+fERq6m6ZMYWFhWjcuIlEkclgMGBnZ4fMzEzMmDEDnz9/pkKBXV1dYW1tTZu1BchaxPfv3x+bNokKt1mzmFBTA7y8vDB27FhMmzaNuuiKsrZkVyMvXryEHj26UzbugCh7aMOGDXjw4AHGjBmDkpISiQcvMmuLzhgkPf0opk93hpeXF7KzsyEQCLBt23a0b98O7969w65du2TG0IUWMxgMODlNxqtXLzF16lR8/PgRnp6e0NHRAYvFwpAhQ/D48RNaK+7Xr1+jZcufrX1DhgzBkCFDIBQK4e7uDgDw8vLGxIkTMHnyZOp94llb4rh69Sq6deuKjh07YuVKUWF569YtREVF4fHjxxg/fjzKy8slVl3JrC06i/iTJ09i6tSp4HA4+PjxIwQCATZu3IAuXbrg9evXSExMlBlTXFwMdXV1atWSnCNnZ2d8/PgRDg4OeP36FdhsT+jpNQebzYaJiQlt1hYgyyRYWVnBysoKtbW11Bz5+PjAyckJ48ePp94nnrUlDtIinrRxB0TGAWFhYXj69Cns7e1lMlhqa2t/hBbLZpmcO3cOU6ZMgZ+fH16/fo34+Hjk5OSie/fuePHiOeLjZVeUS0pKZCzi1dXVMWuWO75+LYCdnR0ePLiFiAgz6Ou3RUhICExNTXH16lXqmBXByckJTk5OqK6uhqmpKQiCwMiRIzFnzhzaFl1pnD9/nmLllYUiRkq8XebOnTsIDQ1FVlYWhgwZgtu3b+PChQsq7YsMLVYFb968kTiPSHazsrISa9euhY2NDZo2bYqFCxfC3t6eGtcQQ47Vq1erbBF/7tw5sNlsREdH4/r161iyZAny8/NhZWWF0NBQWkOJ0tJSCUZKWZw9e7be9kcGg0HFQIiYaJHZzbhx47Bs2TKJIGd5WVukIQfZBmhmZobffvsNEydOxNOnTzFnzhyZwFtFFvHdunXDnj17AIgWu/z8/PDt2zeMGjUKly9fVjn8Ojo6GjNm0C+iyoN0aPHs2bMxe/ZsFBUVSeRvLV++XKJ1XJXQYhINsYi/f/8+3NzcsHnzZpw8eRKenp4oKSnB+PHjERAQIHFdJqGKIYc4lLGIV1dXx+LFi7F48WIUFBRQBbyDgwNCQkIwZMiQevdz584dmaxHZZCTk0NrEW9iYkIVlIcPH4arqysqKirg4OCAU6dOqWzIQYYWq4LS0lJoaWmhUaNGKo37hX8Wv4qsfwgXLlzEqFH0q6XihRSb7YHCwkLExsYiNjYWRUVFPxwJJR84EhIS5IYWN2qkjuTkXT/0W6ngcDjQ0NDAb7/9hl696FsZxBkpEn379sWaNWvg4+MDCwsLSr81atRozJzpQpu1ReLKlcvUqo+BgQFCQkQr8NevX0dISAjllsbhcNC8uYhREs/akoaokBKFL5P6LYFAgC1btqCoqIi2FSQuLp42tJjBYEBdXTRHFRWVSElJpgq3vn37ys3a2r9fNrR44EATGBuvg4+PDwYMMKH0W+PHj8fUqVOxd+9euYyUeGixSL8lyra4dOkSwsPDweFwMWjQQHh5eVGhqtLOhuJ48uQpli5dSj0wfPnyBQKBADExMfj2rQhfvmRRbYA/50iWkSLnqHHjJkhO3kW1AbLZnmjWTBcDBgyQm7WVlpYmk9ExdOhQDBo0CN7e3ujWrTvVBjhpkj0cHBxos7ZIiIcWd+rUiXIEO3v2HK5cuQIOh0u1AZIFQ0JCgoLQ4kdYtGgRNUfv3r1HXFws1qxZg8LCb8jNzZMpZMSdDcVBOismJydT+q39+w9AT08PpqamclfJ09LSKEaKhLW1NczNzeHl5YV27dpRGhknJyeMGzfuByNFH8Z56tQpbNsman/s3r07VQSdOnUKFy6ch5+fL6ytrTFr1iyqcJN2NhTH/fuZFLMZEGCEhw8/IywsDO/evUPz5vTOhvLQpEkTaGtrIyMjA3l5eeDz+Vi3bh3VLiNPQ1BfaDEd4uPjlSpGTE1NKf1WcnIy0tLSYGtrCycnJyxYsEApFzDp0GJlEBoaSstIaWpqIiQkBCEhIfj8+TP4fD4iIyPRsWNH2NnZyVzX6gOpkZLnPioP4qHFVlZWlH4rNTUVjo6OqKurg4uLC3x9fakH/KioKLi5uam0nw8fPqh8Huno6EBHRwcZGRn48OEDQkJCsGLFCnTt2hWTJk2S2+q5YsUKqDdi4N71Cyh4/RRjerUDc4wZmFMmwGacA2pqamTaAHfv3i1X1yoOMitJKBRi27Zt1AKJh4cHPD09lfp8p0+fVrltLSQkhJaR0tPTo/RgL1++pNi9nj17YvLkyQ3WSKnaThYfH08VEBMmTMCECRNQW1uLbdu2UWySt7c3XF1dqTmKjo5WmVHJyspSuf1RX18fzZs3R0ZGhoR+q3///ggLC5PrmFpfaDEdDhw4gMGDB9f7PtJ1t7q6GmvXrsWDBw8wY8YMpRekANnQYmWQnp4ut7vlF/7n8Le90tXU1DqqqaldVFNTe6ampvZETU1twY/XW6qpqZ1VU1N79eO/qvHl/2V4//4d7c3y6dOnaN1aUnfTsmVLBAUFoUOHDliyZAliY+PAYnkgKmo1CgsLQRAECgq+0gqDRaHFotY+kX6LjaSkJERGRuL06dN4/Pgxli5dilevXlFjampqUFNTLSe0WGTIYWtri9jYWAgEAlRVVcLb2xu7du2ibQOQ1kiJ48qVK1ixYgWSkpJgbNwP/v7+YLPZ2LNnD549eyaxOkmCziK+TZs24PF46NChI+bOnYfNm7eAxWIhJiYGxcXFAICCgnwJcxES4qHFWlqa4HK52LVrF0JCQnHs2DE8efIUQUFBeP/+vcQcVVVVyQ0tHj58OCZNskd8fDy2bt2GgoKvP8TYibSW/XSMFImMjAwEBgYiKSkRnTt3xsKFC+Hl5YWDBw/hyZMntDqL169lLeLbt2+PiIgIdOrUCd7eXoiOXgMWywObN2+m2p3kMVIii3jR+Uq2ASYn78KyZQHYv38/nj9/geDgYHz58oUaQzJSdC0LZCHl7DwNO3fuxKZNG/H+/Xuw2Z6Ii4ujXe0jNVJ0c/TgQSaWLVuGpKRE6OvrY+7cOfD29sbx48fx4MEDjB8/XmYMnbbFyKgLoqKi0KlTZ7i7uyMyMgIslgd27BCgoqISgPzVSJFFvOjhjtRvJSfvwsKFC5CSkozXr1+Bz+cjNzdXYo7KyugZKVEhZQFXV1ckJiZi7dq1ePz4CdhsTwgEAgwdKrviWlJSItci/tmzZ1i8eAkSEhKgqSkKv+ZyuThz5gwyMzMxcaLsqrboAVi8RbQE/fv3x+HDh9GzZ09ERETIjFGEs2fPUoxA69atsX37dmRkZIDH4yE8PBzm5ubw8/NDXl4eNUYoFKK4uFhljVRqaiqtDlURnj17hrVr1+LixYuoqanB8OHDMXr0aBw7dkzuGGlGSlkow0h16NABCQkJyMjIwNKlSxEYGIgnT55gwYIFKCwsVGo/dKHF9UGeRTyDwQCTycTly5dx5swZ5OXlwcbGBra2tjh9+jTOnz8PLper0r4aahFPLlp07twZKSkpyMjIgK+vL+bPn4+nT58iICAA379/p8YIhUI0qSnB5tmuOBoejI2LAqGeV4KiRy9xblMMZpp0QfgSP9y4cQPbtm1DYmIizM3NsWLFCmpRUBkwGAwUFBQgMjISJ0+exKtXr2BhYQE7OzuFD74fP36UYKSUhTIW8b/99hv27t2LjIwMuLq6wsfHBy9evEBISAjKy8uV2s/evXvlLuzIgzxGSl1dHQsWLMD169dx5MgR3L17F5aWlpg0aRIyMjLw559/Yu7cuSrti8fj/S2LeFK/lZGRgYkTJ8Ld3R0WFhZYuXIlKisrqTEEQci9ByjCjh07VAoFbtKkCRgMBlasWIH9+/fj/PnzMDMzg5OTEzIzM+WOy8nJURhaLA+PHz/+Zd3+L4AaQZPNpNIG1NTaAmhLEMQ9NTU1XQB3AUwG4AGgkCCI1WpqaoEAWhAEEaBoW6am/Yg7d3b9reP530Bubi7mzZuHFi1awtl5msRD8pIlS+Dr6ytTMAmFQrDZbEpPBIjaOQ4ePIS8vFw0a9YMCQkJMoUMl8uVyNoiUVNTAw6Hg6SkJDx9+hQ7d+5EQcFX9OnTGzo6OtDV1QWTyZQ5dg8PD8rZUBxfv37F0qVL0bVrN7x+/QqtW7cGl8tF9+7dERUVBXNzc1qdA4vlQenISFRVVVEPOr/99htcXV0l2J8lS5b+6O+WLZjEtycUCnHq1Cmkp6fj69ev1BxJ38R8fX0RGRkpUzDV1NTAx8cHu3btQmZmJpKSdqGo6BsGDBiApk2bokmTJmCz2ZAGm82mnA3F8e1bERYuXIAuXYzw/v17tG/fjnIDXLNmDQYNGkTb4sJisZCUlCTxEFdeXo5169bh0qVL6N27j4R+CwCWLVsGFotFWzBJz9GxY7/jxIkT+P69GDo6Oti5c6fMA6Ovry8iIiJkjDdqa2vh4+ODpKQk3Lp1CykpKSgpKcWQIabQ1tZGXZ0QPj6yzJinpyelIxNHcXEx5syZg06dOuHLlyx06dL5hxtgW6xbtw59+/alfaBgsTwotoVESUkJ1q5di2vXrsHY2FhCvwUAAQGBcHNzpb1Zslgs6rtWW1uLw4cP4/Tp0ygtLYWOjg4SEhJk5mjOnDkSWVvic0QuQly7dg1paWkoKyuHlZUltLS0UV5eRvtg6uXlRWmkxFFSUgJfXz906ND+RxtgN/j6+sLAwAAbNmz4f+y9d1RT29o9PIl0QYqgqNi7YleqCmJXrKAgLYSOYgPBSkexK1ZCEVEULFjOsfeCx3psx44Fld6RIjXr+yPubUJ2YsK997339w3nGI5zIFl77yx2kvWs+cw50aNHT0ybZiVyPKY5Ki0tw6ZNG3H37l0MGTIE7u7uQmYtK1euxNy5tgLzpgSAb8xhbGyMe/fuiZxHEiZOnCiUtcWEtLQ07N69GzU1NZg+fTrU1NSQm5srE1P07ds3TJ06VWZWwNjYGH/99ZfQHOXm5iIkJATPnz9Hhw4dEBYWJuR45uDgAHd3d5l0XNeuXUNCQgLdaiYNeDweTE1N8ddffyElJQVxcXGor6/HnDlz4OvrK3ZxPnr0aJw5c0amFr7Vq1ejU6dOUhdMX758weLFi3Hz5k1MmDBBav0W0Lz7aMqUKdi2bZvIOQTnKDExEUlJSSCEwNHREaqNlSh/mI753gHgge9+x2azceTIEXz8+BHHjx2FskIN5Lr3hEJ7/qZbdXU1xo0bJ7OTo4mJCW7fvi30N6HcAD98+IDevXsjLCxMaOOAw+Fg7ty5MmVq3b17F9u2bcPRo0elHiM4RzExMTh8+DBatGgBV1dXODk5id0sMDc3x8mTJ2Vq4QsPD0erVq0YjYCY8OrVKwQEBOCvv/7CrFmzEB4eLpV+C2jefTRjxgysXbtWrINhQ0MDoqOjceLECSgqKtLdQunp6di5c6fU56mtrcWYMWNkvo9MTU1x48YNoYLp8ePHiIiIQG5uLoYMGYKwsDChjUxvb29MmDBBrDaNCTk5OTh69KjUf6ff+NchJyf3NyFkeNPf/8vtgoSQXAC5P/6/Qk5O7jWADgBmALD48bQkADcASCyy/l/F5cuXsWfPHrBYLHC5sTh4MBk6Ojrw8HAXy0hduXJFxKlu3LhxGDduHDw8PDB06DC6DdDW1hZjxoz5oZGqEymwAGGL+H79+mHLli0ghODy5ctYt24dOnfuAjk5FubNs6O/KIqKiqCsrCw2tNjJyYnemX358iX27NmD4uJi5OTkwMfHR2TM69dvGJkgJSUllJaWYc+ePdDU1ERMTAzi4xOgp9cWnp6ePxybRAuspqHFLBaLbk/w9PREv3796DZABwcHmJmZSWSkBC3iBw8eTOu3zp49h82bN6Nr1y5QVVWFtbU1PUelpWVQVFQUaxHv6OhIF1JPnjzFli1bUFZWjtzcHCxYsEBkTEZGBlq3bi3yxaeqqorKykrs3LkTmpqa4HK52L17D/T1O8Db2+cXjNTPtiFKvzVr1ky6KOZwXKGurgYXFxcMHz78ByMl6mwI8MX6VGufoaEhDA0NfwTxnsSOHTvRvXs36OrqYPr06fRroDRS4iziHRwc6IXGvXv3EBm5FpWVlcjLy8P8+fNFxvDDZkWZBHV1ddTW1mL79u1o1aoVuFwurd/y9vZGfj7zbiTfIv6nSYC8vDxsbW1ha2sLLy9vdOrUkdZvubq6YtCgQTQjxaQjE7SIHzlyJEaOHImGhgYcO3YMMTFcdO/eDZ06dcLEiRPp18CkkaIQHx+PefPsaJ3O7du3ERISgurqauTl5TG+18SFFlOfDVu3boO6uhpiY2ORn1+Anj17wNvbGzk5OU2cDWsB1OPixWtSL6IpUIyUpAILEG6X2b59O9asWUOzZ9LaLK9duxYuLi4yXZ+40OJ27drRrc4PHz7E6tWrkZeXB0NDQ3rRLKtRxsaNGxkdMiUhISEBFhYWYLFYcHBwgIODA2pqaoTcAJcuXSqks5EltFgQV69elWlB2KlTJ6irq+PIkSNQUVGBn58fiouLYWZmhqCgIEb9FsDvZGiORXxxMbO77YEDBzBq1Cjaxt3NzQ2VlZXYGBmCJ8lc6Lfrg7+fPMfbt29hNnIkxowZA2MTE/guWIBWGpoghIf6jxloUNOCfCtdrF+/XqwhhziICy0WdAO8evUqfHx8UFZWhrFjx2LlypXNDi1ujkW8iYkJWCyWkH4rIiICpqamaN26NVatWiXUst1cjdS5c+cY3R/FoV+/fmjXrh0OHDiAFi1agMPhoLKyEpMnT0ZgYCCjfgv4dWgxE3g8HvLy8iRaxMvLy8Pf3x/+/v4oKipCWFgYkpOTYWhoyOiWKw5btmyRqegBIDa0WNAN8Phxvta9pqaGjqdoTmjx0aNHZdYC/sZ/CEzhWc39B6ALgC8AWgEoa/JYqZgxngAeAXjUqVN7whS2+b/8j8d7SKKjnUV+/+bNIWJv35uMG6dF1q2zFgnf9fQcJhIUTMgjUlNzh7i4DKB/Liy8QNaunU2cnQ3I7NmdydatDozXISm02MtrOKmpuUPi432Ii8sA4u09gty4sYWsXTubXLu2ifF44kOLDxJ7+97E03MY4XAGkuTkpXQosJ+fOXnz5pDUx3v+fD+ZN68XGTtWk2zcaEfKyq42mSPxocWCc5STc4aEhFgRZ+f+xMamK9myxV6mOaJCi6ur08mePe6EzTYg8+cbkb/+2kmiomzIpUuyhQy/fXuY2Nr2IO7uQ4ir6yBy9OhyOpR22bIx5MWLJKmP9/ffscTOriextNQk0dHOpKLihtDjXl7DpQot/vLlFFm9ehJhsw2InV1PsXMkLrS4pOQK8fAYSioqbpDoaGfi7GxAFi40JX//HUs2brQj585FiH1NTIG8GRmpxMamK3F1HUTc3AaT06eD6ecFBo4lz5/vF3M80UDe9PRoYmvbg1haapA9e9xFAoWlDS3++PEYCQwcR5yd+xMnp35i50hSaLG7+xBSVnaVbNxoR5ydDcjixSPJ8+f7yZYt9uSPP0JlnqNZszoRDmcg8fAYSs6fj6Sft3LlBPL4cbzU99GNG1vI3Ln8OYqP92nyPigmEyZMIJmZmUQW7Nmzh6xZs0amMVRocX5+PvH29iZGRkZk5syZ5MmTJxLHSRtaLAh7e3ty/fp1qZ7b2NhIUlNTyYABA0jr1q3J5s2bpQolpcY2J+B35MiR5Nu3b2If//r1K+FwOMTQ0JDY2NiQFy9ekJUrVxIulyvTeZqGFkuLpq+psbGR7N+/n4wePZqYmpqSXbt2ifxNJk2aJHNo8d69e8miRYsYHxs1ahRjsHP520dk/pB+JOv0aRI0ZQoZraZGAseNIx+OHiV73N1JakAAIY8eEfLoEWn86xapeX2XECJ92Kwg2Gw2uXDhglTPbWxsJHv37iUGBgakdevWJD4+Xur7VlJosST8KrT41atXxNbWlhgaGhI2m00+f/5MQkNDZQ4t/vr1q1BosbRoeh/V19eTbdu2EVNTU2Jubk6Sk5NF5mj69OnkxYsXMp0nNTWVLFy4UKYxVGjxs2fPyOzZs4mRkRHx8PAgubm5EscZGxuTuro6mc7l5eUldYh6bW0tiYqKoj+PZA3NXr58uUzP/41/HfhPhxHLycmpAUgDsIQQ8o0pzFVMkRcLIBbgtwv+u67n/wpMphUA0Lt3b6ipqWHXrt14/PhvrFq1CrW1tTA3N8ecOXMkMlKWlj91Szo6OrQOYd68efj69SvYbBf07dsHXl7e0NLS/JG1xayRio2Nha2tLW3j7ubmhsLCQnC5XFy+fBllZWXo2LGjEBsimLXVFPHxCQgODkbv3r1RW1uLAwcOwN3dHSoqKigoKJDobNgUAwYYQF1dHTt37sT9+/exbNkyNDY2Yvz48T+cy5idDQ8fPixkEd+unR5tD25nZ4fMzEyw2WwMGjQIHh4eUFdXl6gjo0KLKRt3Hx9v2g3wxo0bKC8vR8+ePYSMDt69ewcdndaMcxQXF4fg4GD069cP379/R2JiIjgcvhtgXl4eIyN148YNRov4oUOHQkNDAzt27MCdO3ewZMkSEAJMmTIZ06dPZ8zaAvi28oItmR076tOmHra2tvjw4SPYbD6z5ebmClVVVYk6svj4OMyePZvWbwH8HV4ul4v09Dv49q0cAwcOFHJo4mdtMWtb+HMUggEDDFBRUYGEhARwOK7Q0GiF3NxcMVlb6Yy21WZmZjh06BC2bduGW7du0TEKM2fOxMSJkxiztgDR0OKuXbtiwwa+09acOXPw7t07sNkuMDU1AZvNhrKyMr59+yZWI8UPLZ4BDQ0NBATwNSkfPnxAbGws7t27B0tLSxgajhC6FkkZSQkJCQgKCsaQIYNRWlqG+Pg4pKSkQktLk4GR4uOvv/5iNOQwNzfH0aPH6JZULy8vKCgowMbGBmPH2krFSDXFoUOHcOnSJZnGUKHFbdq0oY0vHj9+jLCwMOTm5mLo0KEIDQ0VapeRJbRYEO/fvxdr3NMULBYLtra22LdvH44cOYK0tDSMGjUKqqqqWLx4MaZPny52bHMt4gkhEi3i9fX1aXfNu3fvYvny5UhPTwebzUZJSYnULAQVcCsLmCziWSwW2Gw22Gw2qqursX79epiZmaFVq1ZYtmwZxo4d26zQ4sTERCgoKGDUqFGwt7eHl5cXWCyWSNYWBdJQj5QdW2Ex3godOnTA4sWLkZmZiRY/9C45OTmYNWsW3QrMUlQFSguR+e4VWrVqJbNGSlzWFhNYLBa8vb1x5swZJCYm4ujRo7Qb4MqVKyXmjUkKLRYHaRipvn370vlK58+fh7u7O+7fvw9fX18RJ1hJCA4OZnRnlYT79++LGHLIy8tjyZIlWLJkCUpKShAWFoadO3dCV1cXa9aswYgRI8R+T0pCTEwM0tLSZBpDhRZTzDoAnD59Go6Ojqiursa0adPg7+8vxD7l5uZCVVWVcS0hCbIwUlQ8xb1797Bt2zYcO3YMGzduRLt27RAaGopBgwaJHfv8+fPfWqz/Ifxbiiw5OTkF8AusQ4QQKgghX05Orh0hJPeHbqtA/BH+38WNGzfg7MwW+X1tbS1dSI0dOxZjx45FfX09Dh8+jDlz5kBeXh5Xr14VMYK4ffs2Y8hfUVERNDQ06KyKy5cvY8WKFairq0V9fT3YbBfG62MKLdbV1cXs2bNRVlYGNptNtwH2798fHh6ejFlbgtdBFVJKSkrw8PCAh4cH0tLScOjQoR+hwPw2QMoIhMnZEPhpNtG6dWu6DfD79xocPHgAs2fPhry8PO7cuSPiTCcptFhDQxM7duwAj8fDuXPn6FBgQgjmzZvH+Jpev34tEorarl07ODg4oLKyCnPn2mLbtm0oKyvD4MGD4e7ujtjYWLi5uTEeTzC0WEVFhW7hSEtLw4EDB8BmuwjptwDhrC1BCIYWUynz1dXV2LdvH2bOnAl5eXk8fPhQxKZWUmixhoYGdu/eBR6Ph1OnTmHRokUgBGCx5MS2QDBZxHfq1AkcDgdVVVWYNm0a1q2LQmVlJQwNR9A6NiZnQ4DfOkEVUurq6nTv+PHjx7F//36w2S50GyBlInH48CG6mG46R9XV1WjXrh3dBki5Ae7duxfy8vJ49uyZyBfT5cuXGVu8ysvL6bZWqg1w/vz5aNGiBRQUFDB9OnPWFlNocffufH1VTU0tLC3HIjQ0FN+/f4eZmRmcnZ0Zs7YoCIYWa2lp0gvlY8eOY//+RLDZLujRowe8vb3oQvvQoUMizobAz9Dijh314eTkCCcnR5SWliEuLhYbN0ajqKilTO0yZWVlYLFYUi/QKDCFFv+qXSY4OFjm0OKrV6/KvNinLOL79u2LNWvWYM2aNcjJyUFISAjWrVsHfX19hIaGirQjHTx4EOfPn5fpXGvXrmXUyIqDiYkJdu7cCR8fHwwfPhyzZs1CQ0MD7OzsaKdKcXj37h2j4ZAkrF+/HtHR0WIfV1VVRXh4OMLDw/H582cEBwfDy8sL8vLyePv2rdStp5WVlVBQUEB6ejoqKysRFRVFF25aWlqMrX2kvgbp125CVVUPWtraePz4MVq0aIE7d+7AxMQEmpqa6NylC5YsWYKKykrYzp2LqRNHYuO6cJkNOag4BllAWcQPHz6cfj9lZGQgODgYAQEB6NWrFyIiIkQ2NeLi4qQKLRbEhg0bMHfuXKmfP3nyZAwYMAAuLi7Q09PD+PHjIS8vDzc3NzoaRhxevXrFGKkhCb+yiNfW1qbvsxcvXiAsLAxPnjyBvLw8cnJy0L59e6nOQ4UWy9r+yBRaPGPGDMyYMQN1dXWIjo7GmDFjoKioCB8fH8ydOxchISEyhxY/evRI6tciiNzcXHr9CPA3pEJDQ5Gbm4thw4YhNDRUZJP11KlTjHEuv/Hfwb9cZMnxKasEAK8JIVsFHvoDABvA+h//FW/n9D+ORl4j6hvrQEDQQq4FFOX5O/319fwFMNOudlNGCuC7AbLZbNy4cQMbN25EfHw8Dhw4CB0dHXh6ekBbWxvKysqMX5j80GI7+ufx48dj/PjxqK+vx4wZM3D48CGcOJEGW1tbeveWydmQQkJCAry8vNCrVy9s3boVPB4PV65cwYoVy/HmzVsMGfIQ3bt3F7oWcYwUwA+HjY+Ph7a2Nv755wV27tyJ0tJSGBgYoKbmuxhnQ1GLeBUVZXh6euLevXsIDw9HfHw8YmPjoKenB29vL2hoaEhgpH6GFrNYLFhZWcHKygrfv9dg9uxZOHToML1LRTEYTM6GFKgioW/fPhgyJBo8Hg9nzpzB0qVLkZHxHkZGRujTp4/QF9ONGzfQqxfz4u7SpctISEiAjo4OHj9+jE2bNuHbt28YPHgIvn//LsbZUDS0WFVVFb6+vnj8+DGCgoKxb18Cdu3aDX19fXh7e0NNTU0sIyVoEc9isTB79mzMnj0b1dXVmDVrNlJTj+DcuXNgs9n0AkESIxUbGwsPDw/079+f1m+lpZ3AwoWL8P79e5iZmaFfv35CY2/fvi02SPXq1avYt28f2rRpg7t37yIyMpIu3MRppJhCiyk3wBcvXiAwMBBJSUnYunUbunblF25UfgiTJkDQIl5eXp7OO6KCk48fP4YrV67Azc2V1oBJYqS4XC44HBcMHjwYo0bx9VtHjx6Fj48PPnzgB/IOHDhQaKykxd2NGzcQH5+Adu30cPPmTQQHB9OFW2VlpQRnQ+HQYi0tvq3127dvsXbtbkRFRSErKwuDBw9GWFgYHZ7JhLVr1zKaxEiCNIyUjY0NbGxsUFdXh61bt8LCwgKvX7+WaSEJ/Pss4tu3b4+4uDgAfJ3IqlWrkJ+fDyMjI4SGhtKfj1QEg7RojkU8FVpsaWkJJycnVFdXC+m3/Pz8RDRA0oYWC4KyiJe2SO3cuTOSkpIwevRorFq1CkuXLkVxcTFGjx6NoKAgifoxwdBiNTU1ek4+f/6MESNG4NOnT0hPT0dERAS9affl6xe0adMGq1dHITY2FucvXMAAAwP07NkTFRUVmGtrizEWFhhgYIDo6Ghk5+Rg6ZKlOJ+dCxtn5s1DcRAMLZYWTKHFPXv2REpKCgD+5o6npyfKy8tp/RaLxUJDQ4PMRcL58+dl0kgBP0OLp0yZgoULF6KsrAzh4eHYvXs3dHV1sXr1aiGGH2BmpH4FWS3iDQwMcOzYMYwZMwYeHh5wdnZGVVXVL/VbAD+0WFp9J4WcnByoqqqK3aBQVFREQEAAAgICUFhYiNDQUGzduhXv3r0TG68jDs21iG+66SW4IXX06FHMnTsXtbW1dDxFixYtUFNTg5YtW8p0rt/4z+HfwWSZAXAC8I+cnNzTH79bBX5xdVROTs4NfJ3W/3Ox03UNtfhWWYzvBflQqGmAHA9okCeQ01CHmk47PH34Dx4+fAgOh4PRo83h6OhAL/7FMVKFhYVQVlaGrq4unQv1+vUbxMbG4fnzZ+jZsydjK4i40OJ3796hf//+2LRpE4qKihAbG4vExP1o00YXpaWlWL6c2WukqKhYqM2RxWJhwoQJkJOTw/3791FTU0O3AdrZ2cHc3BzHjh1DVFSUyLEoQw7qmgcMMMD27XxTiZUrV6GkpASurq4YN24c5s6dS3+oCWZtCYIKLaZ2jgE+Bb59ezRevXqJPn36iIQCAxAbWvzly2f069cfW7ZsRm5uHmJiYhATw0X79u1QWlqKxYuXMM4RP7T4Z1HJYrEwffp0qKur4+bNmygqKvrRBtgSTk5OMDY2FstI8Vm7n6HFQ4cOxdChQ8Hj8bBixQraEn7SpMmwtp5NL0QFs7YEQbX2de3ahbbdfvjwETZu3IC3b9+ib99+dLuMIKisrabIyclB//79sHXrVnz9mvUjo2wXOnXqiJKSEkaDCkDUIp4fCmwDPb22uHjxIm3jrqHRinYDPHz4sFhGStAi3sTEBCYmJuDxeAgMDERxcTE8PDwwffoMTJ06hZ4jwawtQVAW8X369KHv2zt37iAiIgLv339Av3598f276CYJlbXVFCUlJejTpw+io6PpNsAtW7aiW7euKCkpEcts5ubmCYUWy8vLw97eHp07d8aff/6JFy9eIDU1FVpaWnS+HFPWFjVHgoWUubk5zM3N0dDQgMDAQBQWFsLLywvW1tYYP348qLbtCxcuYNcuUdaOsog3NOxLt8ucPHkSDg4OKCwsxNy5cxEYGCgi1pY2tFgQwcHBUluwU+0yI0aMwO7du3Hx4kVs2LAB7du3R2hoqES7ZUmhxZKQnJwskZEaMWIE/vjjD/B4PBw5cgTW1tZ49+4dTExM0NDQIHUb2sePHxkNOX6FphbxqqqqCA0NRWhoKL58+YKQkBCEhYWhU6dOiIiIQO/evZsVWpyYmIjRo0fLNIYKLZ40aRImTZoEHo+HpKQkWFlZgcfjwd7eHt7e3iKvWZIhx9ChQ3HhwgXcvHkTCxcuRElJCczNzZH1+SN859pAS0sLNjY2yMvLg7u7OxISEvD4yRN06NABAwwMEBsbC29vb/Tv3x+PHxsg79QF7Nu3D6tWrUKPHj0QEREh8R6RZMghCQkJCRIjAqgNUh6PBy6Xi0mTJuHLly8wMzMTCU6WhOZaxDcNLdbU1KQLydevXyMkJARLly5F3759ERERAX19/WaFFjfXIr6urg729vawt7dHQ0MDdu3aRedveXl5wdbWVmSOpAktbgpZLOJ1dXWxe/duPHr0CMuWLUNkZCRycnIwePBghIaGStyQ4vF4yM3NbZZFvCSXyblz52Lu3Lmoq6vDli1bYGFhgbq6Ojpr8jf+N/DvcBdMByBOgCVbj8L/EKpqK1Dy6R1afeNBi6WCFnI/FmKNQE1eLSry3+Lvx7eQuD8RIPw2HU9PTygqKmLSpElQUVERw0hxhRgpAOjbtw+2bNkMNtsFs2fPxsqVq1BXVwsLCwvY29sjIyNDIiNFuY8J6reotPvIyEi6DZDSgAlmbTXF8ePHERUVBW1tbbi7u6OwsBAxMVwkJCQgOzsbpaWlIgVgcnIyo/aBxWKhoCAfJ06cAI/Ho/VbqqqqsLKyksBIiYYWDxw4ENHR28FmszFp0iQ6FHj8+PGwsbHBhw8fJGqkqLa1du30EBYWCoDvBujntxTr10fRbYBU4SaYtdUUR44coS3ifXx8aP3Wnj17kJ2dw5hTQmVtMc1RUVERTpxIQ2NjIx0KrKamhlmzZkrFSFEYMWI4RowYDjabDQsLc7p4nDp1CmbOnImPHz+KZG1REGx/7NhRH2vX8gvFBw8eYPny5di4cRNGjBgOV1dXukXs1q1bEkOLw8PD6VaGL1++ICYmBtu3b0NWVjZ4PJ7IGHGhxSwWCyUlJThx4gTq6uoQHx9PuwFSRbs4Z8OmYYxmZmYwMzMDm82GoaERfH0X/HBknIVJkybh8+fPYhkpfmgxf466d+9OFxnp6elYs2YNtmzZipEj+W2A1PXws7a6iJ2jNWuC6ILp/fv34HK5yM/PR05ODuTlW4iMERdaLC8vj/LycqSlnUBNTQ3i4mJx6NBhtG6tTYeCinM25Lc/VgDgv69nzZqFWbNmwcjICIqKiiLtMs3VSH369EmqEFhBUIwUtRh+/PgxQkJC6HaZsLAwEQaYy+VKFVosCCp/SRpGisVi0eymoaEhBg0ahNGjR0NVVRVLliyhXSLFQVxosSTcuHFDYmhxp06dkJiYCIB/z/n7+6OgoABfv34Vy9SLw/79+3H27FmZxjQNLWaxWOBwOHQ7cVRUFExNTaGhoYFly5Zh/PjxEkOLg4OD6ZYnaiOBx+MhMTERXC4XcrnvkfelCHfuP6GZdGc2GyoqKjAxMcGaNWvw+s0b9O3XDz26dUbSieOI2paI3j86Ma5duwYfHx+UlpZi+PDh2LBhg8jf/uDBg2JD1MWhuroajY2NYt0XBcFiseDj4wMfHx8YGRmhffv2tH5r1apVv3yvhISEyNwWdvfuXbpFnQl9+/alF/bnzp0Dh8NBRUUFsrKyZGZEBUOLpUXT0GJB/VZRURHCw8MRHR0NXV1dBAcHY8SIEc0KLQaAf/75h2appUVERAR27NhBF0wnTpyAvb09vn//jhkzZsDPz09kQ+rYsWMi7fy/Qm1tLWpraxn11k2hqKiIlStXYuXKlQgMDJS5Nfg3/rP4txlf/P8J3+urUfrhLdpWKUKxhWgRoMxSAvnOg963RhQXf0HbNt3g4uICFxcXlJSU0At6f39/eHh4CLXYvX//HkFBoozUy5cv0bZtG9rGvb6+HsnJyfD09MSXL18YW3OonTamto7s7GxMnDgRy5cv/6HfWo66ujpYWo7FrVs3sXGjqE1sU0YK4O/gBAWtQWJiIvLz87F7924UFxfDwMAAnp6e0NDQwM2bNxk/rJqaTVD6rfz8fHh5eUFOTg7Lly8X0m8BwJs3b2mWTxD81j5dTJ06FVOnTsX37zU4cCAJ7u7u+Po1C+7uzExCU0aKQmlpCcaPH48VK1bg7Fm+fosQgokTJ+Lq1Wt0odF0jmpqaoQWLu3atUNYWBgOHDiAT58+YfPmzSgvL6dzitTU1HD9+nVG1q60tEyoSKACG7OzszF/Pt8CfvXqNfD29kbHjj8tbV++fMnISPFDi1vTC+Xq6mokJPALt+zsLLFaO3EW8d+/f4el5VisXr0KJ0+exMKF/F70adOscP78BURGiobXCurIKHTq1Anr1q3DoUOH8OrVa9rG3djYCC4uHKioKOPKlSsSGSklJSUoKSnRLFNmZia9ExkSEiqk3wKAFy/+gb+/n8jxPn78CE1NLcybZ4d58+xo/daRI0eRm5sjdo7EBVbKycnBwsICa9asodsA5eXlMWvWLPz5558IDg5mnKOmocU9evTApk2bkJqaiidPntBtgCNHjoSTkxOUlJRw6dIliYyUiooyVFSU6UV8RkYGli1bBh6Ph8jISHh5eQuZ2jx9+uzHHFYIHY9qow0MDERgYCAKCgoQGhqKLVu24OvXrzK3vgiGFksLJkZKsF3m2LFjmDNnjlC7jKKiIg4dOoQLFy7IdK61a9eCzRbV1krChw8f0Lp1awQFBSEoKAjZ2dkICQlBZGQkOnbsiNDQUMb31Pv372U2ytiwYQN27dol1XPNzMxw5swZxMXFIS0tDTNmzJBav/WfsIhv2bIlIiMjERkZic+fPyMoKAhr1qxBbm6u2DDXt2/fimQMslgs9O7dG5MnT8ae7RtwZM0yvH+fgb1794LNZiM5ORlLly5Fly5dwGKxcOPGDbDk5OC/xAt/f69FtMD3sKWlJSwtLZGYmIjk5GRMmTIFhBA4OzvDzc0NLBYL+/btk8hIMWHDhg0im6i/wpcvX9CqVSts2bIFwM/8rWXLlqFPnz4ICwtjNKV59epVsyziN27cKNVzKZ10UlIS4uPjMW7cOMjLy8PDw4PeuBGH5lrEnz9/XiwjpaOjQ7OyL168QEhICLKyslBSUiJzSPm/YhEv+B1AtdtT8RRjxoyBkpIS5s+fDxsbvnRh7969OH78uEzn2rJli8gG4a9QWVkJdXV1tGghujn3G/89/C6yGFBWmAXtShZjgUXh4cNHGDXIFMgpQrVWW7RU5O+CaWtrQ129FZKS9uP16zeIi4tDUVER+vTpAwsLC7Rt24bxeHxG6mdLloKCAjgcDthsNpycnPD582ew2Wzo6urCy8sLPXv2xJUrV8T2Ox8/fhzr12+AnJwcJkyYgAkTJqC2thaJiYl49y4DK1eugJ2dnRADJZi11RS3bt2iA3l5PB4uXbqEwMBA1NTUoKysDExuklwuF3Z2olkNbdu2hYaGBpKSkgT0W2UYOHAAzM3NJWik4uDp6UH/rKKiDC8vL3h5ecHe3h5v374Fm+2C9u3bwcvLC126dBHJ2hLEkSNHsXZtJFgsFqZNs8K0aXz9VkJCPN68eYOQkFA4OTkKMQeCWVtNQRVS1Bz98ccfWLJkCRoaGlBWVsb44RcbyxXauaPQoUMHaGpqIilpPx494rcBfvtWgWHDhsLc3Jwxa4t/PGFDDlVVVSxcyC/c5s2bh+fPn+Ps2XPo2FEfPj4+6NChg0jWliBSU1MRHh4OFotF5x1VVlYiLo4/R+Hh4eBwOBg6dKjQGHE7wFevXqVDiyn9lq+vL3i8RpSVlYlxyIxjNOTo0qULNDW1kJi474d+KwKVlVUwNjaGhYW52JYsLjcWbm6u9M+Ufouao4cPH+HPP8+gW7eu8Pb2Rtu2bZGeni6RkQoODqbbAO3t7VFeXo7Y2Fi8fPkSGzZsgJubm5BhQlNnQ0FcunQJu3fvgYqKMhoaGpCamgofHx/IycmhrKwMSkqKImPi4+MxY4aoIUfPnj3pObp16xaCgtagpqYGo0ePxqhRowWytvh5WQB//kNCQoQ2Otq0aYM9e/YA4LPK586dQ3x8vFTtMgBfM8G0ySAJXC5X4q7snDlzaKdWql1GQUEBJSUlMmukbt68ydgKLQnBwcFC7dgdOnSgW8Tv37+PlStXoqCgAEZGRggJCYG2tjauXbsm9r0mDjweD6WlpRKZLCYcPHiQDi2m3ABHjRoFdXV1+Pv7MzrmrVu3Do6OjjKdJzMzUywj1RSdO3fGgQMHAPAzlI4dOwYul4vRo0djzZo1aNWq1Y/3GnMb37p16xAdHY1WbTuBHRoBttN7FJTWY28MF0+fPUNcfDy8vb2RmpqKsLAwaKnJQaWrNlSyKxmPl5iYiD/++AOampqoqKjA2rVrYWpqilatWqGkpEQqRkoQly5dalbbGvX5Awjnb128eJHWb40fPx4rV66Eqqoq7ty5I7MbKI/HQ2FhoUg+569AFZva2tooKSlBREQEdu3aReu3mJj1poyUNJCFkTIwMKDbm3v37o3k5GRwuVxYWVlh2bJlEvVbAJ+RkrWt7tixYzA0NGR8TFFRUWhDKiQkBJs3b0abNm1QXl4uM5v8559/4ubNmzKNOXnypMyF2W/85/G7yGqC2oYa8ErKoNpCvLUuAGTnZGP06FGoqv+OitJ8tGzL/1KnGCmAagPk705duXIFq1evhq5uGyQlJcHe3p5eUP5kpES/fK9cuYJBgwbRO9OvXr1CTEwMCgsLkZ+fDy6XKzKmrq4O9fX1IhbxSkpKUFRUhLu7OyZNmoiYGC6t3/Ly8hLLSDW1iGexWHTvfUREBKqrq+Hh4QFlZWXY29vTRg3iGCm+RTyf5RDUb128eBGBgYFo06YNUlJSaBdGwetg2g2/evUqBgwYQJ/r6dOn2LZtO8rKSsXOUVONFAUVFWWoq6vDxcWFnqO9e2NoN0BxzoZNQ4spC/GZM2di7dq1tC5NTU0Nzs7O9If1q1evGXVzGRkZdPsj5VLF4/Fw+vQfWLp0KXR12yAtLQ2zZs0SWtyIY6Ru3LiBfv360yzqgwcPEBUVhYqKChQWFjIySJRGqmnLgpqaGnR1deDk5IgJEyaAy+UiOjoanTt3hpeXl0RnQ0HWjtJvzZljg6ioKOTk5NBtgC4uHNpZTxwjJRhaTLUBNjQ0IC0tDQsWLEDbtm1x5swZTJkyRWiOxDFS6enp6NOnD0JCQuifw8PDUVVVhaKiIrFzxGTIoaGhAX39jrC3t8e4ceMQGxuLvLx89OjBdxu8fPmyWEaqRYsWdGufvLw8HB0d4ejoiPXr1+PTJ77GTVubr9+i/tY/GSlhCIYWW1hYwMLCAvX19UhJSaFdCS9fvvyDNfjZMiiute/ixYsYOnQo9u/fD4Dfvmhvb4+amhpMnz6dsV1G2tDipjh8+LBUrn2C7TK+vr549uwZjI2N0aFDB4SEhPxSC9Hc9scPHz6ItYg3MjKi9VupqamYPXs26uvrUVBQgHPnzsl0nn379jXbIp5ipATdAL98+YLg4GCEhISgS5cuCAsLoz9Xr127JlNoMQDaNU8W3Lp1C4MGDUJKSgrdBkjpt0pLSxnbzJoacii074UGFgu6nz/AbHh/tNXRgonZKGzeEIXC7A84npYAu6XLsPvkVfx5RrT9sWlrn7q6Oq07WrhwIYqKimBsbCyVfgsQH1r8K0gKLZ44cSImTpwIHo+HmJgYOuC8uLhYol6HCc21iBc05NDW1sa2bdsA8NcilB6wX79+CA8Pp9khSYyUOAQHB4u4s/4KDx8+xIABA3D8+HE0NDQgOjqa1m/5+Phgzpw5Iu9rHo+H/Px8iaHFTIiJicGxY8d++TzBeApfX198+PABxsbGGDJkCMLCwoTiKZiQl5cHVVVVkc/RX+HFixdwcnKSacxv/Ofxu8hqgu91VWhZDUAC45qXl48WP964qixlFJeWgqfbCBarBRISEhhNAiwtLXHwYDLi4+OQnHwIHh4eUFJShp2dLerq6sQyUmlpaVi//qfAvF+/ftiyZQtqampgZ2eHqKioH22AlrCzmwcFBfkfjBSzJuHWrVuIj4+HvLw8veB++fIltmzZgk+fMrFt2zYh/RbwM2uLCe/fv0dSUhIAID8/H7GxsYiPT4CqqgpUVVUYx8THxwsxUgB/wT158mSkph5BTEwMDh78qd9ycHDA9+/fxTobHj16TMgifvDgwYiO3o66ujrMmTMHkZGR4PF4mDBhAqytrSEvLy+RkaIKKQUFBSH91tq16/Dx4yfs3r2bbgOkQGVtMeHdu3f0HOXk5CAmJga7d++BhkYrsXPEZBHP1w7NxKlTJ7F37166DVBdXY3OrmEq1AE+u0QZZACAoaEhDA0NUV9fj9mzZyM8nP+YlZUVZsyYDhaLhdTUVLG6AKqQUlJSoh3B7t27h9DQUHz48PGHboojZPEdHx+HWbOYLeLfvHmLxMR9YLFY+Pz5M7hcLrZv347WrbXRsmVLCaydsEW8vLw8bG1tce7ceezatVNIv+Xq6opv3yrQrRvzYunw4cN0gQUAI0eOxMiRI1FXV4dZs2YjNDQULVq0wKxZs+jFjiRG6vLln4wUpd+6ffs2Vq5ciffvPyA5+aCQfgv4mbXFhNev39Bz9P79e8TGxiI/vwDt2umhZUtVsc6GLi7CrcYKCgpwdnbG1avXsG3bVsTGxiI5ORmKiu3h47MeBQUF6Nu3L+M1bN26VWiTgWI3qXYZCwsLKCsrY8GCBbRmMCYmBuPGjWM8njh8+/YNcnJyMjNSDx8+xN27d8FisfDo0SMEBwcjNzcXI0aMQGhoKOOOckhISLMs4qVhpFgsFs1u8t+fPeHs7Aw1NTUsXbpUyIBAHJKSkpplES+OkerUqRNdJKenp8PPzw/FxcUYMGAAP1dKxmLz7du3Mv99o6Ki6NYvFotFZzhWVlZizZo1cHFxgYaGBu2mCPDnQdBpVU5ODgrteoLXWh/xK4MRvz4Cqory2Gi6AdBui+Q/L2Gq+1K8fv0aqampcHd3F3ptgs6GTfH333/j0aNHYLFYuHr1Knx8fFBWVgZLS0usWrWK8b4U1JFJC2kZKRaLRUeBlJaWom/fvnB1dUXr1q2xatUqqbRj/26L+H79+onotyorK2FmZiZWky4JL168YDQLk4TIyEiakZKXl4e/vz/8/f1RVFSEsLAwbN26FXp6eggKCqKd+o4ePSqWkRKHmpoa1NbWysxI/f3333j27Bnk5eWRlpaGefPm4fv372I3pAD+fSSrRXx2dnazLOJ/4z+P30VWE/Aa6iFPJAcpP3jwAF++fEVISCi6dOkMY8dJ4BEewJNDUVER45fvlStXYGDQ/0cboAs4HBfaDfDixUsYOHAAMjIyhPRVgllbTXHo0CFYW9vAyckRtbW1P/RbHlBUVEJhYQHjLldRURGjRXz//v2hr6+POXPmoL6+HitWLEd9ff2Pws2OMWsL4O9kCbIcbdu2RVAQ3xHNw4NfRLHZbBgYDICnpwc0NDTo65AUWkzZuHt6eiI/Px8xMTG4fv06Bg8ejE+fPgntKFKMFFPvd0pKCmbNmgUXFxd8/16D/fv3w93dHS1btkRubi6OHDkiMkZcaPGQIYPRpUsX2NhY4/v373T+FuUG+Pr1G8aFWlOL+Pbt29N6Fnd3d/B4PLDZLhg2bCjNdAHCWVuCuH79Bnr27CnUBvj1axa43Bikp6dj2LBhyMrKEuo3Z9JIUThy5AhmzpxJL3D4xhsctGrVCnl5eUhOThYZ05SRomBsbIzbt29j9uzZqKysxMKFCwHIYdo0K0yfPh0vXrxgXIQ0tYjv3Lkz/cXp5uaGhoZGsNkuQvotgL/ZwRxafBvdu3eDuro6rd/69OkTYmNjcffuXRgaGiI3N09ID0VlbTFZxKelpWH69Gnw8vJCeXk54uPjceTIEWhq8kOBqfYnQVA6sqZmE6NGjcLDhw8xffp0VFZW0hqZ2bNnY8KECYxZW9T1Cxpy9OjRg9ZWuLm5oa6uDi4uLhg1ahScnZ3p+1dcaPHdu3fRpUsXaGtr0/ftmzefsGpVJK5fv46JEyciLy9PqA1QEiPF1C6zadMm6OnpITMzE3fu3BEZIwkREREya6SaMlLDhw/HqVOnwOPxhPRb1tbWWLx4Mf05+PHjR5nd9JpjEZ+cnAxnZ2faKj84OBjh4eES9VuVlfw2N1mLzRs3bkg15yNHjsTZs2fB4/FgampKawDt7Owwf/78XxZcN2/elLmNUZJFvJqaGrZv3w6Af89Tbas9evTAmzdvcP36dZEx3+t5KKhXhLaRcPujm08fZOYUwsbGBh8/foSpqSk0NTWxfPlyjBkzBleuXGG0P//8+TPU1dXp107lFPF4PMTFxdGsE5vNhqurK/08WUKLKURFRdHdLtLizz//hL29PbZu3Yq3b9/SBhh9+vRBeHg4o7FFdXV1syziL1y4IBUjRem3GhoaYGJigurqalhYWMDDwwPz5s375X304MGDZlnEiwst1tHRwc6dOwHwnYnDwsKQnZ2NgQMH4p9//sGZM2dkOte/wyJemg0p6nplba0+evSo2BzQ3/jv4neR1QRyLeRBIOp8RoEQgqrqKixbxl8sPnjwAPsO7Edx3EG0baMntt85LS1NRHCqo6MDf39/ZGRkYP78BYiJ4aKoiG/S4OXljRMn0kSytiikp6fTrX1KSkr0TuC7d++wcOFCuLm5oU2bNvD09KS/zJpmbQni3bt3WL16NQB+i0JtbS0OHDgIe3t7FBcX4+bNmyLMD5W1xYS6unokJe2n2wCXLVuGhoYGdOzYUSwjxWQR37ZtW6xateqHFTgH27dHo6ysFIMGDYKHhweOH0+DubkF4/EEW/tUVJTh4+MNHx9vvH79BosWLYSHhwfatfup3wKEs7aaQtAifvr06T8Kt0TMmzcPRUXFuH//PoyMhLOI+M6GHkyHQ319PZKSkug2wCVLloAQoHv3bhI1Uk0NOTp25Fvdu7u7w87ODuvXr0dFRSWGDx8ONzdXpKWdEMnaoiDY2qempkbvoL148QKLFy+Bp6cnOnXqBG9vb3To0OHHa4r9ZWgxvxVwDioqKpCQkEDP0bNnzzBkyBChMVTWFhMaGhroOUpLS4Ov7wLIycmhd+8+EhmppoL6rl27IiIiAu7u7pgxYwYiIyNQVVUFExMTODuzcerUSbGtNJcvX6b1SBoaGnSh+Pz5cyxduhReXt5C+i1AOGurKahCimI5SkvLEB8fh8TE/SguLsLr169FFg5U1hbzHDXi4MGDqK/n67e8vLygoKCA/v37i83aSk5OFrGI79OnK44ePQQzMwvY2trSDPK0adPg7++P+Ph4ETMCJgi2y9y+fRszZ86EpaUlhg4dKlW7DMBn3JtjEc/UnsxiseiQ6pqaGmzZsgWjRo2CqqoqRo8eLRRlIQ2aaxEvGFqsr69PB7vev38fK1asQGFhIUxMTBAUFEQvhteuXStzC5CkzDZxoJ777NkzWr9FhQJTboBM2LBhQ7Ms4sV1EQiia9eu9AbG+fPn4eDggAkTJsDc3ByrV6+mWyElMVJXrlzBnTt36Nf34cMHOicqNzcXnz9/FnHNo0wnmoLFYtEa4G/fviEyMhImJibQ1tbGlClTmhVaXFhY+C9ZxPfu3RupqakA+AWRu7s7vn37hgkTJmDFihV0J8HGjRtlNuT4+vWrzBbx8vLyaNGiBV6+fImSkhKEhYVh586d0NXVxZo1a0S+HylERETIbBF/5MgRsccTxMCBA2n91tGjR3Hs2DFYWVlh2rRpWLZsmVRteWfOnJE5j0xcaLHghlReXh7CwsKwceNGtG/fHtbW1vT3rCzIz8//pS72N/47+F1kNYGyoipKVeSgUc/8eObnz+gisJM7YNhA6E83hm6bbpg9eza0tbXh5eWNuXPn0KLt2tpa1NfX00yOIA4ePAhLy7G0jTsA2g3wzZu3cHFxQX19vRCzUlhYCCUlJcYPv6NHj2LlypWwsLDAy5cvsXfvXhQXF6N///54/fo1Y9ZWU0YK4BduHh7uePPmNfz8/HD58mXs25eItm3bwMvLC927dxfJ2qJw5coV2s2PagOcPHkyvn+vwZw5NtDW1oaPjw8cHBzodjQmZ0MKVGjxoEGDEB3N12+dP38efn5+ePcuAx4e7iI5NeIYKQA4deokli9fjnHjxuHJk6fYtm0bysrKMXjwILx48YIxa4sptJhfuPngw4cPWLBgAc6dO4c9e/bS+q1OnTqJdTa8fv06XfxSbYCzZs1EdXU15syZAy0tLfj6+oLNZtP2r+J0ZMDP0OIRI0ZgxIgR4PF4OHXqFBYtWoSMjPfw9V0gksEijpEC+O0fy5cHYsKECQL6LX4o8PPnzyU4GwprW9TV1bFkyRJkZ2fD3d0dR48exfbt29GlS5cfboDtxOrIbt++TRebVNFGFW62trbQ0tLG4sWLweFw6ByqpllbgqBCiwX1W8eOHceCBfPx4cNHLFmyRGSOKEaKSUh9+fJl+Pv7Y8qUKUhPT0dYWBiqq6thZmaGp0+fMmZtMS2AtbQ0ERAQgOXLV8DJyRFJSUnIzy9Ajx49aN1U06wtCoKhxQoK8nBycoSTkyNKS8tgbz8P2tqt4e/vDzc3N3oDiJ+1VcUYWpyYuAMTJ06k3SkFd10/ffqEDx8+iIyRhD/++AObN28Gh8PB8ePHYWdnh+/fv2PWrFlYsmQJ4wInIyNDrLGLJEjDSCkrK2P16tVYvXo1cnJyMGLECLRt2xbW1tYICwuTSqfBFFr8K0hqfzQyMsKff/4JHo+Hw4cP0/qtuXPn4tq1a7h7965M5woKCpJZIyVoES+o3/r8+TNCQkIQFBSELl26IDw8nP7MpxgpWY08kpKSZGYS0tPTsXbtWnh5eWHfvn2YOnUq7QZ4+fJlxjlisojv3r07Dh06BDabDVtbW7r9ztLSEqtXr4aamhrevHnzy82EVq1a0ZumGRkZGD16NNq0aQNnZ2eEhYVJVYA31yK+oaGB0ZCD0kk3NDQgJiYG48ePh7y8PFxdXXHhwoVmhxbLAsHQYm1tbURHRwPgSxJCQ0Px9etXGBgYIDw8nG5vkzW0mAKXy5XZIv7du3cICgqCr68voqOjYWFhASUlJTqeggnNtYh//vz5Ly3i9fT06A2px48fY/LkyWjTpg3mz5+P0NBQqTaknj17JnMG12/83+F3kdUEKgqqKNFSR01eLZRZoovPJ48fY+rUqfTPlfJ1aKXTHTweD7q6uti3bx9KSkrA5XJx4MBB6OjoQFtbS+yXcnp6ukgf8vjx4zF48OAfBRGhTSUoN8CYGK5YalgwtLh///7YunUreDweEhL2IS8vH66urnQbIPWhER8fT2dtNUVRUTGMjY1pByHKDTAzMxMKCgooLy8XKR6PHTuO9etFnbrk5VtAV1cXiYmJyMvLA5fLRVxcHPT09KCjoyNWRN40tJjFYmHq1KkwNjbG8uXLUVVVReu3HB0dYWpqypi1RYHPSPF3vIcMGYwhQ6LpVpC8vLwfocCTYG1tTX9Bx8b+zNpqisLCIowePZpe4D1+/BibN29GVlYWFBQUGEOBqaytplBQUECbNm2QmJiI7Oxs7N27F7t27Ya+vj7atNEVu4hsGlrMYrEwe/ZsjBljiWXL/JGXlwcOxxWtWqmDzWZj+PDhiIuLFasjEwwtpvRbPB4Pe/bsQU5ODjw8POk2wJ9zJKojo1BQUECHcAL44Qa4Fnl5uZCXV2AMBaaytppCRUUFbdq0wf79++k2wG3btqFLl65o27aN2IVL09BieXl5zJtnhylTJmPp0qX49OnjD/2WJtzcXDFw4EDGrC0KgqHFlH6LCs/Mzs6Gt7e3kH4LoLK2XBmPl5eXBysrKzpn6ebNmwgODkZBQSEUFORRW1srUhCLCy1WV1dDmzZtkZS0HxkZGYiNjUVBQSF69uwBPT09sSGhFy4cw8GDt+ifqV1XT09PTJ8+XUhjJw0EQ4ttbGxgY2ODuro6bN26lW6X8fX1FWJGxTFSknD58mWxDLk46OnpoWPHjrh37x4ePnyIVatWIT8/H4aGhggNDUXr1sy5e78KLWbC2rVr4ezsLPE5LBaLNjmpqanBsmXLkJGRgYkTJ0qt3wJEQ4ulwYYNG+j2KkF07txZSL+1dOlSFBcXY9SoUdDX15eKkRIEFVrcXIt4FosFd3d3uLu7o7KyEmvXrkVZWRmmTJkipN8CJGuk3rx5g6SkJKxYsUKoDbCqqkpmRqp79+7o3Lkz7t27hytXrsDb2xvl5eUYO3YsVq5cKbbVMyEhAX/88YdM55LGIl5eXh6+vr7w9fVFWVnZj83Id5gxY4bU+i1AsiGHOIgLLe7fvz9tGnHmzBk4OzujqqoKkydPRseOHZsVWtwci3gqtFheXh4BAQEICAhAYWEhQkNDaf1WcHCwkFuuLKHFFB4+fChz++PgwXxJwv3793Hs2DGaeZe0IQUAp06dknlT5Tf+7/C7yGKAZht9FJe+gl6dPFrI/XTAaGhoRENDA73QqWisQl0HDbRWVENC/D76A15bW5teJLx+/Qa+vgugr6+Pr1+z4OXlSX8wFBYWMmqkAP5izN7eHubm5uBwOCgqKkJMTAwSE/fj69cvjNboL1++ZAwtZrFYeP2a70rYqVNHHDx4EO7u7lBRUYGdnZ3YrC2m0GLKDdDT0xPjx09AQEAAGhoaMG7cOMydOxeEENTX10FLS0vkeIIW8Xp6erTJwPPn/PapDh06oKioCO7u7nThVlJSIuRsKAgul19sjh07Fl5eXsjNzUNMTAy4XC6+fv3KWIgyMVLUHL17l4E9e3ajUyf+wsLV1RUtW6rBycmRbuNsimvXromEFg8dOhRDhw6Fl5c3Ro8e9aMNkGDy5MmYPXs2GhsbRbK2KKSkpNCFVIcOHehC7NGjRwgICEDHjh1RWVkppN8qLS0TG1rM5cbA1tYWEyZMAMDXb8XExGDnzl3IyvrK2GbDxEhRc/Tlyxfs3LkTnTt3RkJCAjgcV2hotAKHwxHLSDFZxJuYmMDExATe3t4wMjLCggV8/ceMGTMxdeoU8Hg8RmdDQDi0uGvXrnSL6Z07d7BmzRro6+ujsZGv46IKN8GsraaIjY3DnDlz6AXFp0+fEBPDxZYtW5CVlQ0nJ1EDAXEtWfLy8sjNzcX27dvRuXNnxMbGITX1CLS0NOHm5i7W2ZAptJgKYfXx8cHAgYPg4+MDBQUFWFtbY9y4ceDxeCJZWxSOHz9OL1x69uyJTZv4uXg3btxAWFgYOnbsCGVlJTg6OtLvrYqKCqirg7GQioiIEFtAi8Pbt28ZXfsUFRWxYsUKrFixAnl5eQgNDaXbZUJDQ/Hx40ex7a3i8K9axI8YMYJ2Azx69Cisra1RX18Pa2trLFq0iP6Mbq4hh6wW8crKyrTLXo8ePWj9VqdOnRAWFibWmOT69evN1kj9ipES1G8dOHAAS5cuRe/evbFnzx54e3tLxTyuW7dO5vZHcaHFampqiIqKQlRUFD5+/Ijg4GCsWrUK3bt3R2RkJGPWFgARi3jBNsDJkyfTRj7SQpCRonIueTweuFwuJk2aRAczs9ls+jXIElosCFkt4jU1NUEIweHDh9G5c2eEhYXB398fffv2RUREhNisqF+FFjOBan/8FSNFbSRRG1JLly5Fv379kJKSAltbW6nuo3+nRbyuri527+Y7vT579gxhYWHIycmh4ymkYaSaIjIyUub7SDC0mCmeQkVFBb6+vkKbfo2NjaitrZV58+s3/g9BCPmf+TdsmAEh5NH/xL+yyosk6/keUnk/lvAeHiDk0UFya7sXOb5yJql/mEiK7+8iWV8OkLqGu4SQR8TZ2YDU198TOU5BwXni7T2CEPKIXL68nnh6DicuLgPI/v0LSXCwFblxYwvj+Z2dmefixYsk4uExlPj5mRNnZwOyYcNcUlJyhRDyiCxdOpq8e5ciMqax8QFxdu7PeG0eHkPJ+PHaJCDAkmRkpAo97uk5jD624L+amjvExWWA0M+xsV6EzTYg06a1JyEhVozX7uIygNTV3RX5fWHhBeLpOZw0Nj4gf/4ZStzdhxAOZyA5fHgZiYycRa5d2yTTHL15c4hwOAPJokUjibNzf7Jliz359u06IeQR8fOzIK9fJ0t9vJycP4mr62AybpwWWbFiPPn8+USTORpOCgsviIyrq7srNEdVVbfIrl0cwmYbkBkz9Elo6DSZ5qik5DLx9BxGGhsfkBMn1hA3t8HE1XUwSUtbRdatsyGXLkWJfU083kOR3797l0qcnQ3IggXGxNnZgOzc6UKqqm4RQh6RgABL8uJFktRz9PnzCcLhDCRjx2qS4OCpJCfnT6HHvbyGk4KC8yLj6uvvETb75/G+fbtOtm51IM7OBmT27M4kPHwm4zVwOANJTc0d0fds2VXi4TGU1NffIykpywiHM5C4uw8hf/4ZSjZutCXnzkWIfU2NjQ9Efv/+/RHi4NCH+PgYEmdnA8LletLnDQwcR5492yfmeKLvtYyMVOLiMoBYWmqS8PAZIvMxf74Rycs7+8s5Kim5QjZutCXOzgbE2roLiYgQP0fV1ekiv//27Tpxdx9C6urukqSkRYTDGUg8PYeRS5fWk61bHciff4YSQupIUxgZGZHGxkaR30uCra0tuX37ttTP//vvv4mRkRHR0dEh8+fPJ4WFhVKNa2xsJEZGRjJdGyGEmJmZkYqKCrGPf//+nURERBBjY2MyduxY8scff5DAwEASHx8v03nev39PJk2aJPP1Mb2mv/76i0ydOpUYGhqSJUuWkNLSUqHHJ02aRN6/fy/TeWJjY0lgYKBMYyoqKoiZmRmpqqoia9asIcbGxmTChAnk0qVLEsc15z5ycnIily9flvr5165dI8OHDyfa2tpkxYoVIn/jyZMnk7dv34qMa+59NHr0aJG/gyDKysrIsmXLiJGREZk8eTK5ffs2CQoKIjt37pTpPJ8/fybjx4+X+fqYXtO5c+fI+PHjiZGREQkJCSFVVVVCj0+dOpW8evVKpvMcPHiQLFmyRKYx379/J6ampqSwsJAsXLiQGBkZESsrK/LgwQOJ44yNjUl9fb1M53JzcyOnT5+W+vknTpwgQ4YMIVpaWiQqKorU1tZKNa6xsZEYGhrKdG2EEGJubi7xMy83N5d4eXkRQ0NDMmvWLPLs2TNy8eJFcvXqVZnP9Rv/fgB4RBjqmt9MlhhotGwNxd7KKC/NQ2lRCZRrCN4WfEQ1rw6LY6Kg1FoX7hwvdGihgMLCQqioiGOkYmhGhdrlqq+vR3LyIdy4cR35+Xng8XhCOSiCWVtNkZCQgMDAQHrXka/fWoG6uloUFBQy9oKLCy3W1dWFnJwcjhw5ipycbOzZswfFxcUwMDAAh8MR62zYNLSYr9/ygIeHB90Sw2a7QE+vLTw9PX/ot4rEMlJ8i/i5YLFY9C7X9+81OHAgCZcuXUJ2djYUFRWF2hxev34jMbR4+fLl6N27N3g8Hs6ePQc/Pz80NjaioKCAccdWXGhxu3btIC8vj9TUVHz58hWbN29GeXk5hgwZAjbbBXV1zLauhw8fxujRP1tpVFVVsWDBAgCAo6Mj6uvrwWa7QF+/A7y9fdCxo75I1pYguFwubGxsRPRbCQn7cOHCBWRnZ0FTU5PeCQN+Zm0xBUXHxnIRGBiA/v37g8fj4eTJk1i4kC/SLSxktvC+ceMG49x16tQJSkpKSElJwYcPH7B27VpUVlbCyMgITk5OYp0Nm1rEC7oBOjg4orKyAmy2C7p06Qxvbx+0a6eHsjLxOjJ+a99syMvLw87ODnZ2dqioqEBcXBzOnDmDrKwsdOjQQYhJEszaEj1eLJYvX44BAwagoaEBR48ehY+PD1q0aIGCgkJG/U56erqIkB7guwGqqqri8OFDePfuHYKDg/H9+3eYmZnB0dGRMWsLEA0tpvRb1ByVlpaBzXZBz5494O3tDR0dHVRUVIDFYom0XwI/Q4spG3dnZ2eUlJQgNjYW58+fx7Bhw9Cx42gMGvTz/f3mzZtmaaQyMzPFRgAwYejQoWjVqhUePXqEBw8eYO7cuXS7zOLFi8W2yzTXIp7FYklkpJSVlbFmzRqsWbMG2dnZCAkJwfHjx2FpaQkjIyOpc3aahhZLA3GhxSYmJjhz5gx4PB6Sk5MxY8YMNDQ0wM7ODt7e3s0KLT5w4ADOnhXNkZIEypBDVVUVERERiIiIwOfPnxEcHIygoCB07doV4eHhQh0SzTHkAPg6Gln+vmPGjIGuri6Sk5Nx8+ZNTJkyBYQQODk5wc3NDSUlJYxa4qYW8dJAGkZKQ0ODZpIzMjIQEhKCs2fPYvr06Zg2bZrU+XH/Tot4Sifd0NCAvXv30votNzc3ODg4/OjcYGZLxSE+Pl5mjdTGjRsxd+5c6Ojo0AYqL168QGhoKLKysjBgwACEhYUJ2ZNnZ2c3SyMlq0X8rFmzsG/fPiQkJODKlSsYM2YMlJSUMH/+fLFt9kDzLeLr6uokWsTr6ekhJiYGAOh4iq9fv+Lhw4cynes3/o/BVHn9t/79LzFZgv9q6++Q/JIzZE8ch1TW3iCNvAfk9etk4udnQZydDcjMmR1/7ABLz7a8eJFEli0bQwoLL5C1a2cTZ2cD4u9vQd69SyFLl44WYZUIEc9IEfKInD0bThwd+xIXlwHEy2s4uX59M/2YtIwUdY7z5yPJlCl6ZMqUtuTQIT8Rho7NNhDLSHl5Dad/fv58P1m8mM8m2dh0JWfOhMk0R69eJRN/fwuSk3OGBAdbEWfn/mT58nHk06fjxM/PnLx5c4hxnODOv+C/c+ciyLx5vYizswGZP9+I/PXXToE5Gk6Kiy+JjGnKSFFzdOpUEJkyRY9MntyGHD26XIQJEcdIFRdfIp6ew+ifHz3ikoULTYmzswGZO7eHhPuI+e/+7l0K8fMzJ1++nCKrV08izs4GZPXqSSQr6zRZtmwMefnygEzHO38+ksyZ042w2QZk4UJT8vffsfRj0jJS1BwdPbqcTJ3Kv49Onw4WmSNxjFRJyRXi4TGU/vnOnR1k/nwj4uxsQOzt+5BTp4LE3kdMjFRGRipZvHgk+fjxGAkMHEecnfuTkBArkpd3lgQGjiXPn++X6b68cGEtmT27M3F2NiCLF48UGu/jYygVI0X97uDBJfR77fz5SMY5ksRIUT/fuLGFeHkNJ2y2AXF2NiCnTwfLNEcfPx4jixaNJG/eHCKenhOJkZER8fLyIrm5uTIzUoQQcuHCBcJms2Uaw8Qk1NbWknXr1hETExNiaWlJTp48KTLOzMyMVFZWynSugIAAkpCQINOYd+/ekcmTJ5N79+4RKysrMmLECLJw4UJSXFwscVxz2JGJEyeSjx8/SvXcqqoqEhISQjp37kw6duxIzp07J/V5KioqyMiRI2W+PkNDQ4mM1M2bN8nkyZOJkZERCQgIIOXl5cTJyYlcuXJFpvPcvHmTzJs3T6YxTPdRRUUFWbFiBRk4cCDp3r07uX79usi4UaNGkfLycpnOtWbNGrJ7926ZxmRmZpLx48eTCxcukAkTJhAjIyOyZs0aETapKZpzH02dOpW8fv1aqucWFxeTJUuWkG7dupFOnTqRv/76S+rzUIyUrPgVI3X69GkyduxYYmxsTCIiIsj379+Jq6sr+fPPP2U6z4MHD4i1tbVMY5gYqfz8fOLj40OMjIzIzJkzyePHj0XGmZubk6KiIpnOFRkZSTZv3izTmIqKChIeHi7TmN/4zwG/mazmQ1FeCffTH2LS2Cloqcjf+ezT56cb4MyZM3HmzBmkpaXB3NwcDg4OUFBQkMhIxcXFwdfXFzo6OnQG1evXbxATE4O//36M48ePw8vLW4hJunTpkth+59OnT2PHjp3Q0tJEYWEhuFwuEhP3Q0dHB5WVlWIZqaYW8SwWC5MmTUJqair27NmDQ4cO0/ote3t79O3bF8rKymLZFsHQYkq/xePxMGvWLJw+fRppaWkYP34C5syxgby8/A9nQ+bdGyq0uF07PToU+OnTp9i2bTuePn2CDh06oH379lBXV6fHXLlyBb17MwvgT506hV27dkFbWxu5ubmIiYlBTAwXbdu2QWVlJaOIlim0mK8dmoFTp04hOjoaycnJ4HD4GiknJ0f06tVLrLMh3yL+Zy/5sGHDMGzYMPB4PMycOROnTp3CyZOnMGXKZMyaNQssFkusjgz4aTbRsaM+rd96+PAhoqKi8M8/L9CpU2d06dJFqGebytoSN0d79uyBjo4Ovnz5Ai6Xi+joHdDX10dFRaVYRqrpDjDlBnju3Dls3rwZBw8epEOBXVw46NKli1gdWXx8nJARgqmpKUxNTdHQ0ICZM2fijz/+wJkzZzBjxgxMmTKFDucVx0jFxcXBzc0dXbt2xYYNfFF2eno6wsPD8eLFS3Tr1g09e/YQchC8ffu2WIv406dPY8+ePWjbti0+fPgALpeL/Px8dOvWDd++fWNkpI4dOy5iES8vLw9HR0dcu3YNUVFRSEpKQkpKKrS0NOHh4QF9fX3GrC3qNQlaxFP6rfr6Bsycyb83z549CxsbG1qXIolJiI2NBYfjgt69e4PL3QzAACdPnoSDgwMePXqEwYMHw9DQUCq7Y0A0tFgaUI5oglBUVMTKlSuxcuVKWr+1fv16dOjQASEhIejUqRNYLBZatmwp07lu3bols2U0FVos6AaYkpJCuwHOmTMHvr6+QjvsV69eFfteEwdZLeJVVVURGhqKq1evIi4uDhs2bEBYWBi6dOmCsLAwiRbh/ymLeMoIiMfjYf/+/bCyssLz589hYmKCMWPGSM1mrV+/nnaokxZMjJSgfouycV+xYgV69OiBiIgItG3btlmGHJRFvCygGKmJEydi4sSJ4PF4iImJwYQJE8BiseDq6gpnZ2ehOUpPT2+WRXxRUZHUhjDa2trYtm0bHj9+jA0bNmDr1q20Xio8PFysfguQHFosDllZWb+0iJ8+fTqmT5+OhoYG7NixA2PHjsWrV69o3Zu091FERIRMmkiA2SK+TZs2dJzH06dPER4e/iOLcAjCwsLQqlUr1NfXizXNEYezZ8/i1q1bv36iAE6cOCE2SuU3/nfwu8iSEpmZnzFt2jSR3//zzwv06tULGzdupNsAPT09oaiohMrKCpG8HoD/4VdaWirSDtK3bx+MHz8eenp6GDx4MFasWI66ujqMGTMG8+bNw4kTJ0SytgDR0GIqkwLgZ4hkZmaCzWajf//+8PDwpJ93+/ZtRvqcCi1WVVWFh4c7PDzckZ+fj9jYWISFhaFDB318+PBBpC1FMGtLEG/evEGvXr2wadMmfP9eg4MHD8DDwwMqKiqoqKhgtJWnrqPpAmHw4MGwspoKPb226NWrF90GOHHiRFhbW+PYseOIiloncqymFvHt2rWj/zbr1q3Du3fvwGazMXjwYLi7u9OF282bN8HlckWOR1nEt2rVCvPnz8f8+fORk5ODmJgYBAUFoUOHDvjy5YuIeFgwa0sQ/CDqXtiyZTOqq6vpUGA1NXVUV1chMJC53YgptHjEiBGorKyEnp4eOnRoT7cBWllNxYwZMxiztoCfocVUQdepUydavBsZGYnKygq4uLhgxIgR4HA4dOEmmLUlCMqQo3Xr1nTALlW4PXz4EPr6+sjNzUW7du2ExlFZW02RmZmJHj16YPv27aioqEB8fDxduFVVVTFapgN8176mocUjR44EIQTXrl2j/4by8vK0G+Dhw4cRGhrKOEeCocXdu3en35MREZEoKyuDi4sLzMzM4OzsTBeRly9fYpyj8vJyyMvLo23btggMDATANx7hcrl49uwZOnbsiMLCQpHiljKLaYqsrK/o0aMHoqOjUVpaBi43BsnJh9C6tTaqqqrh4+PNOEc5ObkCFvG1AOoxa9YsKCsrIyUlBSwWi3YD/FW7TENDg9jQYkk4dOgQLl++LPZxpnaZ+/fvo3fv3igqKpLYaiOIpqHF0qKpRTyLxYKDgwMcHBxQU1ODjRs3YtSoUWjZsiWWLl2KqVOnNiu0OD4+XqgdWxpQocV9+vRBYmIiAP7C3N/fH4WFhRg5ciSCgoJE2tquX78us0A/KCiIvld/Bapo6NatG/bs2YOsrCyYmppCQ0MDgYGBtPEIEySFFktCYmKiRIt4ysYd4H92zZ8/H//88w/69OnD6AQrDp8/f0arVq1kvo/evn0rFFrMYrHo75CysjJERETA1NQUrVu3pt0Ao6KisHXrVpnOk5ycLDb7Txyo9kdjY2McPXoUAD/Og8PhoLKyEpMmTcLy5ctFIi2kDS0WRHBwsNjP7KaQl5eHn58fzMzMEBkZibt372L79u3Q09NDUFAQhg8fLnYsj8dDfn7+v90ifvDgwfTjaWlpsLOzQ0ZGBgwMDFBXVyf1hlROTg5UVFRkbn989erVLx1Lf+O/j99FlhTIy8tjdO0DgISEeCxcuBAA336bw3EBh+OCwsIizJtnh4iISOjo6MDT04MuGC5duiS2n//kyZPYuHEjNDQ0MH78eNTV1SE5ORnu7u74/Pkznj59KmJ1TmVtMeHdu3c4ciQVLBYLV65cwYoVy1FfXw9jY2OxWVtMocVt27ZFUFAQ3r9/j2XLlmHnzp0oLS2FgcEAeHp6IDs7m5Hl4M9RAry9+Ys7FRVleHp6wtPTE/n5+bC3d8C6dVHQ09ODt7cXvXsrmLXVFMePH0dUVBS0tbVp/db+/fvh5uaGL1++4O3bt0I6FuBn1hYTMjIycOzYMbRo0QJnzpzB0qVLQQjBqFGjIC8vL4GREl5otm/fHuHh4WCzXbBw4UJavzVs2DC4uroiOztb7EKQH1rMt4hXVVWFr68vAL4boIsLG+vXr4e+vj68vb3RsSN/R/H69RsizoYUKIt4HR0dzJ49G1VVVXTh9uXLF2RmZopcC5W1xYQPHz7g6NGjUFBQQFraCSxcuAhycsDYsePEaqSYLOKpwo3NdoG7uzsiI/n6LWNjI7i4cJCdnQVtbS2xbAsVWiyo3/r06RPc3d2xceMmdO3aBT4+PnQRxGekRDVSwE+LeF1dXcybNw/l5eWIj49Hamoqvn79ioKCQhFWisraYsKnTx+RlpaGFi1a0PoteXl5TJ48WayzIVNocY8ePbBp0yaw2S5wdHRCUFAQvn+vwejRo+Do6IicnBxoaDAzCTExXLi68i3itbQ0sWIFv6B/9+4dvL29sW3bNvTs2ZPWbwHMzoZABQD+znZ8fDw6deqEwMBAFBQUICQkBBs2bICamhq2bNkiZHfMvwZRRupXKCsrQ4sWLaR2yRo+fDhOnToFIyMjOuOmtrYWs2fPxuLFiyUuWJpjEX/16lWJocXKysoIDg5GcHAwsrKyEBwcjLCwMHz8+BHV1dUynUswtFhaMFnEjxw5ktZvHTx4EDNmzEBjYyPs7Owwf/58ZGZmQkuL+b0mCe/fv5dYHDFhw4YN2LVrF7p37461a9fi06dPCAkJwerVq9GtWzdERESIbNolJib+MvesKSorK0EIkZqRsrS0hKWlJYyNjWFjY0M7jLLZbLi6ukqcm+DgYMa8QElo6mzYFJqamtiyZQsAfjEWGhoKPz8/fPr0CSoqKjKdSzC0WFps3LhRqBsFAKZMmYIpU6bQboBjx46FgoICPDw8MG/ePOTk5MgcWgzwiwRpYwkoUBbxVMEkqN8aOHAgwsLCRDbtUlJSpAotFgSlkZLWIt7a2hrW1tYwNjbG6NGjMWbMGHpDytraWuLY5ljEZ2dnC+nUfuN/F7+LLClw8GAylJWVRUKBKUaKSWj899+PMHHiJAQELMPr128QGxv7g7rvi7dv3zC2QDCFFisqKsLV1RU8Hg8mJiZIT09HYuJ+tGmjC09PT/Ts2ZMxawsQtYifMGECJkyYgNraWnA4HNTW1sLHxwd2dnZCLXGCWVuC4FvEtxFqA7x48SICAgLw/v172pa16YdtURGzRfzz588xbtw4rFy5As+fP8f27dEoKyvFwIED8erVK2zevFlkDD+Qt1bow48fCuwNZWVlVFR8w4ULFxETw0WHDu3h6emJLl26iGRtUWgaWky1J3z/XgNXV/4cLVjgC2dnJ6EP6jdvXksMLRZsAzx9+g8sXrwEmZmfMHPmTMY2B3Ghxe/fZ2Ds2LFYtWoVHj58hI0bN+Dbt28YNmwYnj9/ztjyRM2RYBHVsmVLLFy4EAcPHkRBQQFOnjyFnTt3omPHjvDx8UGHDh1EsrYoNLWInzPHBnPm2KCyshLu7u6oqanBokWLwOG4YsiQwfQ4wawt4dfEt4in2gB5PB7S0tLg67sAmZmfMXv2LMY5ErcbmZWVBQsLCwQFBeHOnTsIDw9HVVUVTExM8PfffyMiIkJkDBVaLLgxoKGhAX9/fxw+fBifP39GcnIy8vLy0K1bV3h7e6Nt27YiWVsUKEaKmiN7e3vY29ujtLQM3t7eqKmpwZIlS+Dh4SH0GgSztgRBtWSNGWOBMWMs0NDQgJSUVPj4+ODLly+YM2cO4xzl5eVh0KBBIscrLCzE6NGjERoaiuvXr2PNmjWoqamBubk57t+/z8DaVaChoRW+ffsmxMa2adPmR3bbLjx58gQRERHIzc2l22XatGmDlJQUiYwUEyIiIujiUFq8ffsWrVu3hq2tLZ0ps2XLFowePRoqKipYtGgRZsyYITLu06dPMhscyMJI6evrY9++feByubh9+zZWrFiBwsJCmJiYICgoSOLCrbkW8Tdu3BDLSLFYLLDZbLDZbFRXV2P9+vUwMzPDp0+fGNnQX52nORbxTb8nu3btigMHDtDH9PX1RUlJCczNzbFmzRq0atWqWaHFUVFRjLEUkkBZxHt7e8Pb2xvfvn3D2rVrYWZmBi0tLaxYsYKx2JMmtJjp+qRlpHr37o2UlBQkJSXhxIkT8PDwQHl5OSZMmIAVK1ZI3JCQFFosCRcvXhTLSMnLy2PJkiVYsmQJSkpKEBYWhp07dyIrK0tqRorCvXv3ZM6RYgotNjAwwPHjxwHw27gdHR1RXV0NKysr+Pv7Q1lZGXFxcc0y5GiORbyamhrd3kxtSG3atAnt2rVDSEgIY6D8P//8I7NF/JEjR2S+z3/jv4PfRdYvQAiBvHwLqKmpwcPDA0pKypg7dw7Gjh2LixcvwsBgAOM4ipEC+G2A1O7UuXPncPHiBSxevBhjxoyBvb09vcDnM1LMIZJ37txBXFwcXcC8fPkSe/fuRV5eHkpKSlBRIaq7ionhMgYXUi5/hw8fRmFhIWJiuNi3LxFt27bBuHHjJLB2CfDxmU//zGKxaJciZ2dnqKur06HA9vb2GDlyJGPWFgWKkQKAgQMHIjqaX7idOXMGf/75J5YtW4bx48fDxsaGft1NnQ0FQRVS1Hw+efIU27ZtQ1FRMUpKilFTUyPCSokLLVZRUYaiIt8xj9Jv7dmzFx06tMf48RMkMlIeHj9DiwXdAB0dHSEnJwcOxxXq6mpgs9kYMWIErl+//ktGCgBGjBiOESOG/yhKTiAt7QSWL1+OqVOnYubMmfSCWzBrqymuXbuGmJgYuhh48OABoqKiUFZWhtLSUjQ2NoqM4XJjGNvD1NTUoKSkjMOHDyMri5+/tX37dnTp0hkTJkxgzNoCREOLKf3WnDlz4OjoiLq6OroNkMPhYPDgwYxZWxQEQ4vNzMxgZmaGhoYGHDlyBG/fvsOaNWuE9FuAcNZWU1y5cgV79+6l5yg9PR1hYWGorKxEcXEJ4xhxocVaWpo/Wu4O4+PHj4iNjUV+fgF69OiOyZMni9W2NA0tlpeXh5OTI5yc+GG15eXl4HA4aN26Ndzd3dGvXz8xjNTPOQoK4ocWjxkzBmPGjKHbm1+/foOQkBDY2MzB+PGUi1sFrRNhQmpqKi5dukQv9I4fPw5bW1tUVVWhoKBA5l3tO3fu0A5s0iIkJITWswJ8Nmn16tVYvXo1cnJyEBoaiqioKHTo0AFhYWEwMDDA5cuXJWqUmMDj8VBeXi61RooCFVqspqYGHo+Hw4cP0/qtuXPnYsGCBSLzJE1ocVN8+PBBatc+VVVVhIeHIzw8HEOGDMHr169hbGyMLl26IDw8XCJbB/xkpGTBvn37JIYWW1hYwMLCAjweD/v27cPUqVPR0NCAwsJCmYtNKrRYFjRlpFq1akUHaL9//x4hISEIDAxEr169EBYWhq5du/6SkWICj8dDcXGxzPffvn37cPr0aWhqaqKhoYF+X7Zo0QJubm5wdHQU+duvX7+eMSdSEr58+QJ1dXWp3rva2tr0RvHgwYNx7949GBsbo3///ggPD0eHDh0kjl+7dq3MmsiUlBSJocUzZszAjBkzUFdXhx07dsDS0hLy8vLIy8tjzO2UhPPnzzer/VGQkaI2pADg8ePHCAsLQ25uLoYOHYrQ0FC0adOGbpuXBYQQ5OfnQ09PNB/xN/738LvI+gXevHmL/v37Y8KECeBwXFBSUgIul4sDBw7i69cvYjVSTRkpCtnZ2fDw8MDcuXORnJxM67fs7OykZqQAfoL61q1bERERATU1dVq/ZWk5FvPm2UFeXh7v379HUBAzI0W1Qenq6tLPefHiBZYuXQpt7dbYtGkTPD096ddAfUH07Cm60L18+TL69etH27jn5+cjJiYGcXHxyMr6SheYgqirq2Ok41ksFoqLi+Hq6oo5c+biwIEkunBzcHDArVu3GBkpJov4IUMGY8iQaKxduxYtWrSAn58feDweJk2aBGtra7BYLLx585axdUjQbEJQv/X48WMEBARCR6c1oqOj4ebmJrQQKCxkFhpfvXoV/fr1o9sAs7OzweVysWvXLmRnZzPubjIxUtQcff9eDRcXNubMmUO3Aaqrq4PNdsH169cZ56i0tBSKiopCbWuGhoYwNDTE+vXrUVdX96P1VQ7Tpllh+vTpP4Ks3zBaUAuGFnfq1Anr1vG1cHfv3sOaNWvQurU29u7dCxcXjpB5g6TQ4t69+9C7opmZmYiNjcX27duRnZ2N7du3i4xhYqQAflFCCIGjowPs7OwQFxeHY8eOQ1NTE25urnQh1RRNGSmA33Y1cuRIbNq0CWVl5XQbIKXfYrFYePHiBfz9/USOJ7gA7tGjB/15cfPmTaxYsQLa2tqIj4+Hk5OT0Dnz8nLFhhb36NGD1sRkZGQgNjYWBQWFyMvLxfbtogx5Q0MDqqqqRL6UFRQUoKKiDHv7eZgzZw643FgkJydDR6c13N09cPToIVy4cFXkeEytfTY2NrCxscHSpUvx9etXWr+1YMGCX7bLUIzUv9Mivn379vR74OHDh1i9ejXy8vKQlZUlMzvC5XLFbn6Jw7dv3wCA/mxgsVhwdOQXyDU1NdiwYQNGjRoFNTU1LF26lG6bkjW0GGi+RXy/fv2QlJQEgL+RsHTpUhQXF9P6rabfX5RGqjkW8dLMOYvFgru7O9zd3bF8+XI8efIEpqam0NTURGBg4C//BuJCi38FcaHFAL91l9JvXblyBT4+PigrK0N+fr7M7MiBAwf+ZYt4eXl5+Pr6wtfXl9ZvUUZFK1eupDeOLl++LHOREBISIrNF/N27d9GrVy9av3XmzBmw2WxUVVVh8uTJCAwMFNFvSRta3BSxsbE4efLkL5+nqKiIZcuWYdmyZVixYgVu3boFExMTWvIgSb8FiA8t/hUkWcQPHTqUvnZqQ6q2thbFxcVISUmR6TzPnj1jZMR+438Tcnznwf8NDB8+gDx6tP+/fRlC4HK5YLPZIh8UtbW1cHZmQ19f/0cbYG94eXlBW1sbcXFxaNmyJSOd6+Ligvj4eKE3cFFREbZt24Y7d+5g+PDh8PLyEmqvi4iIgIWFBeMHNJvtgqSk/fQ1JScn4/bt23Qr0f79+0XG+Pn5Yf78+SLMAI/HA4fDQWJiIi5duoQTJ06gvr4e48aNg7a2Nv755x9GwbOnpyc2bNgowqTV1tbCyckJ7du3R2lpGQYOHAB3d3doaGhg3759kJeXZ9y15XA4QowUAOTm5mH79u24f/8eTExM4OXlJeS2tG7dOtq5StIcUfqt+/fv0flRlFBcEP7+y4R0dE2Pl5i4j3a5I4Rg0qTJ0NLSxMOHDxmLNi8vb6xdGylSMNXX12PevHlo164dvn2rwLBhQ+HqyncqTEpKAo9HwOG4SDVHX79mYfv27fj770cYOXIk3QZIYf369Rg2bBjjgkJwjiorK5GQkIDHjx/Txcq+fftExgQGBsLFxUXEeENwjtLS0nDhwgXIyclh+vTpaNWqFW7fTmcs/n18fGiNlCAaGhpga2sLPb12P/RbxnBxcYGKijKSk5NRU1ND69kE4erqKsRIAfxWsR07duDJkyewsLAQ0m8B/LYwAwMDWpvB9JpYLBbKy8sRGxuHFy9eQFlZCQ0NDUhISBAZs3z5cjg4ODAWTGy2CxIS+Bqwa9euQUFBAdbW1lBRUcW1a1cREhIiMmbBggUIDg4W0Yo1NDTAxsYGenp6qK2txejRo+Ho6AgFBQWkpqaivLwcXl5eIsdzc3PDrl27hYrgt2/fYvfu3fjjj38waZI9QkNDhQo0f39/DBo0iPG9a2RkhLt374LFYiE/Px8hISF4+vSpxHaZefPmYcGCBTJlal28eBGHDx+miwRp0NjYiN69e6Njx46oq6uDtbU1Fi1a9MvF1KhRo2hGSlosX74cvXr1EmJsmUDpt169eoXWrVvj27dvMi+OjY2Nce/ePZnGTJo0Cbt37xYpmHg8HpKSkpCYmAgejwd7e3t4e3uDxWIhNjYWnz59kqkIrKysxOTJk5v1mv766y+wWCx8/PgRwcHBeP/+Pbp3747w8HDGQo/NZsPJyUmmTK309HTs3r1bpoVuQ0MDevTogY4dO0JOTg5sNhscDueXxd3o0aNx5swZmRwMqfc6lbEoDq9fv0ZYWBgyMzPRqVMn5Ofn4+bNm1KfB2jefWRlZYVNmzaJZGpR+q1jx45BQUEBXl5esLW1BYvFQnJyMv7++29s27ZN6vPU1NTA0tJSZpbS2NgY6enpkJeXx7NnzxAWFoacnBwMHjxY5HONgru7O2bOnAkrKyupz/Pw4UNs2LCBbl2UBrW1tfR9pKysDF9fX6ncAsPCwhAQECC1fvU3/m8gJyf3NyFEpIL/zWRJQENDAxoaGkQKLIBvEztjxnS6kLpy5QpWrlyFurpasbtc/NBiURcZHR0dKCsrIzw8HDo6OoiJiaHDAL28vPH+/Qe61UcQTS3ilZSU4ObmBjc3N/j6+kJFRQVsNhtt2rSBl5cXevTo8YORKmFsvaJCiykb90mTJqG2thYHDhxAbGwcevTogdu3bwsVexRrJ84iftq06XBycgSPx8OFCxewbNkyNDY2Ij8/H2lpaSJjxIUWt2unh1at1BESEgItLS1s27YdZWWlGDRoEDw8PPD27Tuh1iEKr1+/EbKIp/RbPj7etN0ym+2CDh3aw9vbm9afMDkbAj9Di1ksFmbOnImZM/mhwImJidi9exd69uyJBw8eCIUR8p0NxYcWT51qBQ7HRUi/BRAUFhbi2LFjImMoRqrpHHXsqA9dXR1a0xAVFYWKikqMGDEcrq6ueP36NW2EIAgqtJiCmpoa3fbg6+sLQvgLmM6dO8Pb25sW3BYUFDAWWDdu3EDPnj2E2gD5boAJOHXqFPr06Y0nT54K6bcoZ0Mm85SUlFRMnjwZ7u7uaGhoQFpaGhYsmA8Wi4XCwkIcOXKEYY6YQ4u7du2K9u07YOLEiVBTU6P1W6ampmCz2T8YKdHd3KahxRoaGggI4LcYLVjgC0AObLYLevToDm9vb/p15OXlMRZY/NDirrSNu6MjP1g4Li4W586dQ9++ffHq1Suh+aUYKWaL+GOYPHkyvLy8UF9fj5SUFHh5eUFBQQH5+flISUkVGSMutLh3797o2rUrNm+eDTm5LrC3t0dNTQ2mT58OPz8/sa19r1+/ho6ODj1Hbdu2pd0AHz9+jNDQUOTm5mLYsGF0uwzAL3xlKbCA5lnEc7lczJs3DxEREaipqcHmzZtpN8BFixZh+vTpImOaq5GSlpGi9FsAXzPb0NAAIyMjmJqaIiQk5JeaGnGhxZJAWcQzFSosFgscDgccDgfV1dWIioqCmZkZWrVqhaysLNy/f1+mc61bt+5ftojv1q0bkpOTAfDdEH19fVFaWooxY8Zg9erV9N/m7du3ModSr1u3TmaL+AMHDmDOnDnYtGkTvn37hsjISJiamkJbWxsrV65k3Aytrq5ulkX85cuXkZ6e/svn9e3bF6mp/Pf4uHHjUFFRARMTE0ycOBGBgYG/XJDfuXOnWRbxhYWFjKHFgvqtoqIihIeHIzo6Grq6uvj69SuuXbsm07k2bNggYsjxKzS1iB80aBC9Ljt16hQcHBzw/ft3TJs2Df7+/rQboKyhxQB/I5zq5JAWJ0+exKxZs7Bjxw46nmLjxo1o3749QkNDGb83GhoaUFtb+7vA+n8Iv5ksCbhz5w6UlJQY6WVqF7ppwZSTkwMvLy/o6OhASUkJtra2NLsiLSNF4fLly0hMTEReXh44HFe6DZDC0qVLsWDBAjGMlCt9vJcvXyI+Ph4lJSVQU1ODnl47RibBy8sL69dvYGSkfHx8EBUVBS6Xiw8fPkBPTw+enp64ceMGFBWV4OTkKHI8JtYO4LfKeXp6QVdXByoqKnB0dKTbHCQzUmyhnWsej4dz587h8OHDyM3Nhbe3N6ytrYXO9ytGipqjJ0+eYv/+RJSVlUNTUxM6Ojpi54hyNhREfX09PD09sXbtWsTExODz5y/Q1+8Ab28fXLt2VSZGCuB/QXh6ekJXt80P/ZYLRozg34fSMlLUHJ08eRLHjx9Hfn4+Fi5chBkzpgvtugYEBIDD4YhlpKjj3bt3DwcPJqOyshJt27ZBy5YtGdkWb29v2tlQEA0NDfDw8EBISAi4XC5ycnLRpQu/cLty5Srq6moZd/6ZGCmAz9x5eLijbVs9If0WwGekBgwYgEmTJjG+JoqRoq7r2LFjOH36NAoKChAQEEC3AVJYvnw5HB2dRKzgm87R7du3kZKSgurqanTooA95+RaMMQ7z589HSEgIIyPl5uaOoKA1tH6rZ88eP+boilhGytXVFXv27BHZEPry5Qs8PDygp9eObgOkNJJbt25Fr169GHds2Ww2EhMPg8Xif9HX1dVh+/btOHz4ML5+/YrY2FiRNkA7Ozv4+vr+smA6duwY9uzZg9raWvTp0wf19fU4ePCgxDGC4PF4MDU1lXnXfeTIkUI6Mgo5OTkICQnB8+fPoa+vT+u3AD5b26dPH5lMOTIyMrB48WKcO3dOpuujmARKvxUXF4eGhgbY2dnRLapNMWnSJOzdu1cmfVBzGKmXL1/CwsIC3bt3R9euXREeHi6VtbogIyUtnJ2dwWazf2nvHh8fT983xsbGyMrKkomRosykZC0cR40ahbNnz4oUTBkZGQgODsanT5/Qu3dvhIeH0zEGQUFBaNeuHebPn890SEZ8/vwZnp6euHjxokzXR91HDQ0N2Lt3L44cOSJRvwXwGaktW7bIpBc7ePAgnjx5IpO1/KNHjzBx4kT07NkTBgYGCA8Pl8olz8TEBLdv35aphc/V1RXW1taYOnWq2OfU1dUhOjoap06dgqKiIsaPH48nT54wbm6KQ3PvozFjxiAtLU1kLfH48WM6f2v48OFCG1IXL16EoqKizBEPv/Gfx28mqxk4evQY2rTRRbdu3YTeCPn5+VBVZc41SEhIQGBgIEaNGoWioiLExsZi//4k6Orq4OvXLKkYKQrjx4/H+fPnERQUjL/+uvPDeIOv3xo9ejRKSsQzUgYGP/ud+/fvj23btoHH42HOnLmoqamFq6srLC0tYWfHL9yaZm0Jgh9abIm2bdsiODgYAD8fbOfOnXjy5AmmTp2K8vJyoR5+KmuLaY4SExOxbNkyjBljgdzcPHC5MYiNjYWeXjtkZmYyMlL80GJhloPFYsHKygrXr1/HypUrkZ5+B+7u7mjZsiUcHR1hYmIilpG6cuWKkHaK0m/x52gOvn0rh5ubm5B+i8nZkMLhw4dhYWFB27gD/A/LTZs24tmzZ5g5c5ZIBktTZ0NBHDyYDD8/P4wbN442ldi9exf09fXx/v17RkaKKbSYxWLB2toad+/exbJly3Dnzh1wOK7Q0GgFNpuNYcOGMWZtAfxdY0ENnrGxMYyNjcHj8WBjYwN1dXW4ubljxozpsLKyAovFEsnaEkRKSipGjhyJLl260Au8v/76C5GRkXjx4iVsbGzw/XuNELMijpECgNTUFCxduhQTJ07Ep0+fEBPDxbZt29ClS1dkZLxjZKSYQovl5eUxb948PHnyBEuWLMGdO3eQmnoEWlqacHNzw4ABAxiztgB+UdWjx09GYNSoURg1ahTdvqehoQEvLy/MmjWLDhttmrUliGPHjsHMzFREvxUUFIRXr17D3n6eSAZLeXk5WrRowci4Hz9+HAsXLoSVlRXevn2LuLg4FBYWoXfvXnjx4gWjuxyfSdACi1UPoB6AAhQVFREYGIjHjx8jIiIC586dE3HNkqSREgTFbtbV1aFv377Q0tKCpaUlFi5cyGge0hTNtYhnsViMO8Dt27en3b0E9VtGRka4c+dOs0OLZYGgRbygfqu6uprO31JTU4Ofnx/dyipraDGFAwcO4MKFCzKNSU5Oxtq1a+Hp6Ylbt25h8eLFKCkpwejRo2nmvCmkCS1mwrt3735pEc9isegokMrKShgYGEBbW5vWAUmzCG2ORXxVVZVYi/iePXvSRd7ly5dpN8Bx48bh0qVLMi/CQ0JC/iWLeHl5eSxcuBALFy5EWVkZwsPDaf3W6tWr6ZgTKrRYVkOO+Ph4mS3iz549SxtE/PHHH3B2dkZVVRWmTp2KZcuWMX6GSRNazIRXr14xtrkLQlFREQEBAQgICEBBQQGGDx8OLS0tzJw5E8HBwSLxFExgCi3+FSRZxA8dOhSnTp0CwDdoopxTZ82ahaKiIpk/j37jv4vfRZYYVFZWYuDAAejSpQtWrVqF2tpamJubw8HBATExMXBwcGAcxzeb4BdSOjo6dMHwxx9/YPfu3WCzXdC3bx94eXnTBU1cXBydtSUIymyib98+6Nu3D9zc3FBYWAgul0sXTe/fvxcptNLS0hgNOfhmHK2QkBD/ow3wIDw8PKCsrPxjocP8xZaeni5iMTpggAFWr16DNWvWwMDAgG4DHDduHObOncuYtUUhIyODtohv106Pto8+efIkHj/+G2w2m24DpEKBBbO2mqKoqBgDBgzAgAED4OPjTbsBbtiwATweD5mZmSKtEMeOHWPcyW1sbESrVq2QmJj4Q7+VCFdXV7RsqQYdHR2Ym1swXsONGzdE2peGDh2KLl26YMWKFejatQuWLFkCQoApUyZj1qxZjFlbFAQt4vX19WmHwRMnTuDevXtgs10wfPhwuLm50gtHwaytpigsLKRt5YGfocAREREghCA7O1vEESo19QhjaDHV9rJ//35UVFQgISGBLtz09PTEiruZLOJNTU3Rt28/LF8eiDZtdOk2wBkzZmLq1CmIi4sV26cuGFrctWtXbNjA//I5cuQI0tPT4erqChMTEzg7s+nCTTBrqyny8wvoQhLgh89yubHIyHhHt7g2LYwEnQ2bQlNTE/v370dpaRni4+OQkpIKLS1N6Ovri83aunTpEt1iR8Hc3ByDBw+Gv78/VFVbwtvbGwoKCrCxscH48eMRHx8vtjh59uwZXUj17t2bjkVISUnB1atX4ebmhtGjzeHo6EAX+zExXAHWlZ+XRSEzMxPTpk2jg9kp16x3794xtrdIAovFgq6uLu7du0e3y6xfvx4dOnQQ2y4D8Of80qVLMp1r7dq14HA4v3zeiBEjcPr0afB4PGzduhWHDh3CqFGjYGNjg4ULF0q10GsaWiwNxFnEq6qqIjQ0FKGhofjy5QtCQkIQFhaGTp06oU+fPjLvaP87LOJHjx6N0aNHg8fjITExEVZWViCEwN7eHl5eXnRRJUtoseB5ZDXWUFVVhZ6eHu7du4cPHz7QOWg9evRARESE2CL0P2kRP378eIwfPx48Hg/h4eH48OEDLCwswOFwwGazpSo8/50W8ZqamvTvX79+jZCQECxduhR9+/bFgAEDmhVa3ByLeMHQYioupaGhATt27KDzt7y9vTF37lyh+0hWi/i7d+/KbBGvo6ODdu3a4f79+3j69CntBjh48GCEhYUxbooBvw4tZsLmzZt/aQgEAHPnzqUzACMjI1FQUCDzpsVv/Hfxu8gSg2vXrsHSciy6du2CsWPHor6+HocPH4anp6dYDcE//7wQa6t57do17NmzB927d8fly5exYsUK1NXVwsLCQqxjE1Nosa6uLtasWQNPT0+6Rai4uBj9+/eHh4cnVFVVxDobClrEKykpwcPDHR4e7igoKICDgwOys7Px4sU/8PT0pK+HydmQApcbg3nz7GBhYYEpU6bg+/caHDx4AO7u7sjMzGQM/3358qXY0OL09HR6js6dO4elS5eCx+NhwoQJKCoqYmxPuXxZNLSYcgP08vKCg4MDtm3bhrKyMgwePBju7u5QVlYWu4skGFrM12/5wMfHB7m5uXByckJm5idkZLwT0m9JYqS4XC5sbW0xduxYWr/FdwN0xefPmRg3TrSwZWKkKPz111/YuXMXevfuhVOnTmHRokUgBLCymvqjP17U2fD69esi1sxUKLC3tzdmz55N67cMDUeAw+FAQUFBrI5MMLRYXV2dXsRnZmbCzc0dHTq0x5cvX+Dt7U0HQzbN2hIEFVo8YcIE2NraoqKiAnFxceBwjuPz50yMHy9qIy7obNgUjx49wo4d0ejduzeOHTuOBQvmo0WLFpgxY4bYrK2mjBTA14Js2LAePj4+mDp1KsLCwlBVVY2RI83g7OyMFi1aMDobAsIW8VpamggICKCv28vLGx06tEd+fgG8vb3o8eXl5WLnKD4+HrNnz8aUKVPg5PRTv5WcfAifP2cytkX+ZKRE5+jp02fYtm0b+vbtS3+uKSoqYc4cG+Tl5QoYVPwsss6fPy/inEm5Zo0fP562vZYWghbxenp6dHH56NEjBAcHIzc3F8OHD0dYWBh9H0pipCTh9u3bMl0fi8XC33//jdOnT2P48OHYtGkTrd9asmSJWFH8lStXfmmD3hTSMlKdOnWiTXr++usvTJs2DV27dkVtbS2Cg4OlWvDyg8DZMl2fOIt4FotFa4ArKyuF9FuBgYF4//69zK6MzbGIF2SkunfvTrsBXrt2DfPnz0dZWRksLCyE9FuVlZXN0khduXJFJvMFFouFT58+4ciRIzA0NERERATMzMygra2NVatWiY2R+E9axPft25d2Azx37hwcHR3RrVs3hIWFYfny5YxsUlNs2LBB7CaqOHz58oWRkZKXl4efnx/8/Pxo/db27dtpN8DmhBavXbtW5s8jQYv4wYMH026AaWlpmDdvnpAuleokqKmpQX19vdShxRTOnj0rkxmMkpISevToIbMt/2/89/G7yBKDz58/CwmhFRQUwGazMWTIECQkJODBgwc4cOAgdHR0aM1PQkK8WEZKMIyR2uWqr6/H6tWrkZ+fD29vb9ja2mHMGAt6nGDWliAoswnB9q0rV65gxYrl+Pr1K3r16sUYCkxlbTWFnJwcunfvjpiYGLoNsLS0FAYGA1BeXiYVIwXwixJPT0+MHDkSe/bswZUrVxAXFwc9vXbw9vZC165df2Rt+TAeTzC02MrKClZWVvj+vQZr1qxBbm4u5s+fD0dHR6Fdt+PHj2H9etEPU77ZRJ3QruvZs/zCLTc3F7169WIMcxUXWqygoIDu3XuAy43B48ePsXnzZpSXl2Po0KEoLS1lzNoCIGIRr6qqCl9fX7x9+xbbt2/Hn3/+iV27dkNfXx/e3t7o2FEfsbFxYtkWwUJq9uzZmD17Nqqrq+k5WrhwIdhstpCOUBwjRbU/UiHVVP7WwoWLUFCQj169ejPOkbjQYg0NTfTo0R1cLhd3795FZOTaH26ARiguLha7c9c0tFhdXR1+fn7IyHiPjRs34OjRIz/yt7r8KNz0RLK2BCEYWDlvnh3mzbNDeXk5goNDkJ2djcWLl8DNzVWIKRHHSFEW8dT92NDQgKNHj8LHxwdFRUVi7yNxFvG6urro3r0bYmNjcfPmTQQHB+P79+8YOXIkioqKxDJSTUOLtbT4ttYfPnzAunXrsH//fhQUFNL6Lb6BjnDWliAEDTmooNqSkhKEhPDnyN9/Gdzd3dG3789g423btjEKwhsaGlBRUSEUWiwNqKytphg+fLhQu8ycOXNQW1sLa2trZGVl/dKxrymaaxEvuJkWFBSEoKAgZGVlISQkBJGRkejYsSNCQ0OFivbNmzeLMJG/Qlxc3C/b45rCwMAA/fr1w82bN5GcnIyZM2fS+i1vb2+xjNt/yiJeTU2NZro+f/4MV1dXfPjwAfb29oiIiJCKnWIKLZYG+/fvx9mzZ0V+b2lpCUtLS1q/NXnyZMjJycHZ2RkfPnwQ240iDpmZmf+yRTzFJL99+xahoaHw9/dH7969ERERIfT+kSW0mMLBgwfFFm3iYGFhgX79+uHGjRvYvXs3zSa5u7vD3t5e7Gu9dOlSsyzi/fxEYy4EoaOjgx07dgDgG1DMnz8f79+/h6enJ8LCwuhNO0lorkW8uNBia2trWFtb07rUMWPGQElJCQsWLMDLly+bFVrcHIv4169fy7xB8hv/ffwushiQm5tHCw2bIiFhHxYvXoxu3boB4LvXxcbGoaioEDk5OYyhd+JCixUUFFBWVoajR4+ivr7+h35rP9q00YWLi4tYRurAgQNCbQQsFoteKLPZLujf3wDu7u5QUVGBnZ0dzM3NJTJSMTFceodkwAADbN/ODwW+ePEi1q/fgJycHGRnZ2Pu3LlCYcji5ig+Ph5Lliyh2xifP3+O7dujUVpawthyBUBsaLGKijIqKytw5MgR1NTUIiYmBlxuLNq104O7u7tEHZlgKw2LxcK0aVaYNs3qhwtcjx9tgC3h5OQEY2NjFBcXMzobAvw2M6qQGjp0KIYOHQoej4c///wTJ06cxNevX1FSUgpr69n0F5MkRio2Ng5Lliyhdx0fPXqEjRs34Nu3CuTl5TEGFF69epVxl1JVVRVVVdU/DBe+IyYmBjt37kLHjvrw8PBAba04jZRwaDHfDdAGc+bYgM12gb5+B7i6uqJVq1bgcFwxZMhgiYyUYGixiYkJTExMfhRuaUhNPYLMzEzU1tZh6tSfocCSGKnYWC6WLFlCf1neuXMHkZERqKysQn5+Hrp1E12M8UOLRRlPDQ0N1NXVIiUlBd++fUNsbCy2bNmCbt26wcPDQ6yzYdPQYnl5edjb28Pe3h5stgt0dXXB4XCgpaUFd3d3GBgYMGZt/XxNP0OLzc3NYW5ujoaGBqSkpOL8+Qv4+PEjWrRogXHjxtFz8unTJxEd2c/jxWLJkqW0XuzGjRsICgpCTU0N8vPz0bdvhMgYcaHF2traaGxsRHJyMm1RX1RUBDU1E6xeHSq2kNq7dy8jkyYJTFlbTKDaZWpqarBlyxYkJiZi6NCh0NTUxIwZM6Q6V2hoKGOsgiSICy3W19enrfrv37+PFStWoKCgACYmJggKCkJZWZnMLm0HDx6UWSMVGRlJt505OzvD2dkZ1dXVWL9+PUaNGgV1dXX4+/tj4sSJ9Bi+QyYzsykJVKubtOjcuTMUFRVx//59ZGVlYeHChb/UbwG/Di1mQmVlpViNFAVB/da3b99ocyJTU1P0799f6tbOpqHF0kAcI9W7d29av3Xx4kV4eHjg27dvGD9+PJYvX/4vhRbLgvXr19O67MWLF9Nau4iICOzcuRO6urpC+i1APCP1K7x+/ZoxGkMcDAwMfkR+3Mb79+/h5OSEqqoqWFlZwd/fXyzjdvjwYZnbH6VhpChdamBgIAoKChASEoKUlBQ6TFva7Krg4GBGLawkZGVl/TLg+Tf+R0EI+Z/5N2yYASHk0X/934EDi0lx8SWR3zc2PiDOzv0Zx5w7F0EWLDAmnp7DiYvLALJ//0JSV3eXEPKIeHgMJWVlV0XG1NTcIRzOQJHfv3x5gMyYoU+mTNEjGzbMJSUlV4QeZ7MNSH39PZFxBQXnibf3CKGfw8NnEmdnAzJlSlty5Egg47WLe00vXiSRgABLUlNzh8TGehE224D4+BiS27e3kyVLRpF371JkmqMLF9YST8/hxN19COFwBpKUlGX06/D0HCbyOiXN0ePH8WTGDH0yeXIbsmWLPfn27brQ4y4uA+j5F/xXWHiBeHkNp3/OyfmTBAdPJc7O/YmVVTuSmhog0xy9eXOI+PlZkKqqW2TXLg5xdjYg8+cbk/v39xA/Pwvy5s0hMcdjvtevXNlAXF0HETe3wcTVdTBJS1tFGhsf/Jij4aSw8ILImLq6u8TFZYDI7x882EumT+fP0c6dLqSq6pZUc1RcfIl4eg6jf/78+QRZtWoicXY2IDNm6Eu4j5hf07t3KWTp0tHk27frZOtWB+LsbEAWLTIjT57Ek4AAS/LiRZJMc37t2mbi7NyfcDgDibv7EPLnn6H0HHl7jyAFBedFxtTX3yNstuj13b69nUyf3oFMmqRLuFxPUlNzR+hxDmegyO8IeUTKyq4KzVFGRioJCLAkzs4GZPbszhLniLpWwX/v3x8hixePJCUlV8iGDXOJs7MBWbp0NHn58gAJDBxHnj9PlGnOb97cSuztexMOZyDx9BxGLl2Koh+bP9+I5OWdlXqOTp9OJN27dyft27cnUVFRpLa2lgjCzMyMVFVVEVng5+dH9u/fL9OYN2/ekClTppDs7Gzi4eFBjIyMiLW1Nfnnn38kjjMyMpLpPIQQMnHiRJKZmSnVcxsbG0lycjLp1q0badeuHdm2bRupr6+Xamx5eTkZOXKkzNdnaGhIGhsbxT6emZlJnJ2diaGhIZk7dy558+YNsbe3J9evX5fpPFevXiUODg4yjWlsbBSZ88bGRhIfH09GjRpFRo4cSWJiYkSuf9SoUaS8vFymc61cuZLExMTINObTp09kwoQJJCMjg9jb2xMjIyPi5OREPn78KHFcc+6jKVOmkHfv3kn13Pr6erJz5076Ptq/f7/Ev7EgqqqqiJmZmczXZ2xsLPFeffHiBbGxsSFGRkaEw+GQr1+/EhcXF3L+/HmZzpOenk7mzJkj05jGxkZiaGgo9Lv6+nqyefNmYmpqSszNzUlqairh8XhCzzE3NyfFxcUynSssLIxs27ZNpjHZ2dlk7Nix5O+//yYzZ84kRkZGxMfHh+Tn50sc15z7aMuWLSQvL0/mcb/xfwcAjwhDXfObyWoCQgiuXr2Kp0+fCtkdA3zRpjgx9smTJ7Fp0yZoaGigvr4eycmH4OnpCQUFBRQXF4tlpJhyPfr16wdNTU3Ex8fj2rVrWLFiOerq6mBpORbjxo1jzNoC+BoHQVGurq4ubUNua2uLe/fu4ezZszAwMICnpyc0NDQkMlIJCQmYP3/+D/2WBzw8PJCfn4+9e/fi8ePHiI+PF9JvAT+ztphw4sQJ2iL++/caHDiQRGukSkpKpGKkKAwZMhhaWlrgcrm4ePES/Pz8aP2WpaWlREZKMG+D0m8B/F3zO3fu4Ny5cxgyZAjc3d2hpqaG16/fQEeHWUcWGxsHT08PqKqqYsGCBViwgG9RHxMTg0ePHkJZWQne3j7o2PEnM0VlbTHh6NFj2LRpE7S1tVFdXY2EBL5+S02tJUpKisVmbY0eLboDPGLECGhrayEmJgZnz57FwoWLICcHTJ1qBXPz0YxZWwDA5cbCxuZnCwSl3wIAGxsb3Lx5C2fPnoOxsRFcXDhQUVEWydoSniN+a5+6ujrd8paZmYnY2Fjcv/8AKiqq8PZujXbtfuoZ+VlbzBbRR48ewebNm6Grq0vrt44dOw4NjVYoKSllZKRSU1MZdZQjR47Evn37sHv3bpw8eZK2yp41axaMjY2lYqQACLkBzp49G9euXcO5c+dgZjYSzs5OUFJSEsnaEp0jd7oNEAAyMt4jNpaLBw8e/ohe0BN6bVTWFhNSU1OxdetWtG3bFiUlJYiN5eu3tLW1UFJSIsbZ8LjQjjWF6dPHYOPGeJw9exZcLhcWFhZQVlbGggULMHbsWKkYqaYQl7UlCRQj1b59e7qlV9AN0NDQECEhIULvkYsXL4royH4FHo+H8vJy2n77V2CxWLQh0smTJ7F7925av+Xn5ydRTxIZGQkXFxeZri8jIwPa2szsL4XOnTvTcRfp6enw8/NDeno69PT0MHjwYKkNCzZu3MjY9ioJ8fHxIp/ZTfVb69atg6mpKTQ1+fe7oaHhLxkpJly7dk3mgNrg4GAEBASgR48etH7r6tWr8PHxQVlZGcaOHYuVK1cKmYPcunWrWRqpkpISqazuAT5L7uvri6NHjyI5ORnR0dEwNTVF69atJeq3AD4jJY0hhyC+fPkCdXV1iYxU//79aTvzM2fOwMXFBQ8fPkTXrl3pzwFpsG7dOrpVUlokJyeLMFLy8vLw9/eHv78/ioqKEBoaim3bttH6LQMDg2ZppM6fPy9z+yPFSFG6VIDv5mpnZ4eamhrMnDkTS5YsEXKCffjwIWOXiiQQQsR2AP3G/z5+F1lN8ObNGzg4OKBjx46Ii4tHUVER+vTpDS8vL5w6dYpxYVBbW4uGhga6kFJQUACH4wIOxwXR0dF4/PjJj9YiHXh5edEfunfu3GHUOAiGFlNtgLW1tUhOToajoyN0dFrjxo0bIi0ckkKLO3fujI0bN4LH4+HSpUsIDAxEfX09ysrKGHv0KRFtU+fCtm3bwtjYGKqqqpg8ecoP/VYZBg4cAHd3d6SlpTFqpJpaxKuoKMPLywteXl7YsWMH7t+/DzbbBe3bt4OXlxfdcnP79m3ExYnOERVarKioSLcB8t0A92PevHlo3bo17t69BxMTY6FxkkKLO3XqhM2bN4PH4+GPP/7AkiVLwOPxUFlZKdZBjsn6tkOHDjA3N4eqqiomTJiATZs2ory8HMOGDYOrqyuOHj3KOOdUaDH1BaGqqoqFC30BADt27EBxcTHYbBd07KgPHx8fun2AydkQoAw5FKGkpETrtyorK7Fv3z7Y2tqidevWePz4sYhN7Zs3b2hnQ0FkZGSgc+fO2LJlC63f8vX1hZwc39pYUJ8nCEGNFIUuXbpgwoQJUFVVhaWlJd0GaGxsDBcXF6SmpiIiQlRHRmmkqGKD0m8BQHR0NHJycsBmu6Bbt67w9vamv5iuXWPWkVHtjyoqKnQbINUqt23bNmhra+Off16I2LfzQ4tF9QXv379Hx46dEB29HQ0NDUhNTYWPjw9atGiBmpoasW5reXn5Iufo2bMHZsyYATU1NYwaNZJuAxw1ahQcHR1x+PBhxpwyfmjxT4t4bW1t2lJ8x44d+Pz5M9hsF/Tu3Quenp50UXL58iXs2bNH5HjfvmWjRYsW0NDQEGmXmT9/Ptq1a4enT59K3S7TNLRYWjAZDgm6AR47dkxIv7V48eJmhRbHxMTIHGpLufbp6OggJCQEISEhyMrKQnBwMO0GGB4eLhLcevPmzWZZxMvS/jhy5Ej4+flBW1sbAwYMwPTp09HY2Ah7e3v4+PiI/Ts01yL+4MGDOH/+vNjH1dTU6ODWT58+ISQkBI6OjmjXrh0+fPggtSaruRbxTKHFY8eOxdixY8Hj8cDlcmn9FpvNBofDwfr162UOLU5KSpI5ZJsKLe7UqRO2bNkCgP9+CQsLg7+/P/r27Yvw8HAR57zLly/jzp07Mp0rODiYMeZCHKysrKClpYXo6Gi0atWK1m95eHhg3rx5Eu+joqIixtBiSUhISKCLFybo6OjQJinPnz9HaGgo7t+/D319feTl5Yk1IWuKrKysZmmkmEKLbWxsYGNjg7q6OmzdulVoQ8ra2hqRkZEyhxY/ffoUQ4YMkWnMb/zv4HeR1QS3bt0Cm82GsrIytmzh77xcuXIFgYGByMh4j5MnT8LBwUGIAUhKShJrtfrkyRM6tPjVq1eIiYlBUVERunTpCgUFBakYKYDvLuPm5oZbt25j8+ZN4HK5SEzcj7Zt28DT0xM1NTWMWVsA/8NqwYIFAPg7ipMmTcKkSZPo7IX169dDWVkZ9vb2tGsck7MhhRMnTmDDho3Q0tIU0m/5+fnj/fv3uHDhPObMmSP02vhZW8zi7sePHyMpKQny8vJ4+vQptm3bjrKyUvTu3RsKCgpQUGCeo6YJ8Hw3QG/cu3cP69dHISaGi5iYGLRv3w7e3t6oqqqCri6zRorPynnQczRz5kzaDXDWrNmIiloPNTU1sNnOMDQ0BCCatSWIY8eOIypqHbS1tTFs2DDweDycPv0HFi1ahA8fPuL69euYNWuW0BcTlbXFhCdPnuDgwYNQUFDAw4cPaTdAA4P+aNGihVhGqqkoV01NDYsWLcLffz9GREQ4uFwuoqN3oHPnTvDy8kJlZaVYHRmXy6VNBwT1WxUVFbCxscHGjZugqakBFxcOhgwZDIDK2mLeyU1NTaVDi01NTdHQ0IC0tDTMn++Djx8/4f79e5gyZYrQHKWmpoq1iH/27BkOHToEJSUlpKenIzw8HFVVVRg2bDhYLJYY1744EYt4DQ0NBAQsw4sX/yAoKAhxcXHIy8tHjx7d4e3tjfLycomMFGWjLy8vT+cdlZaWwdZ2LjZv3gwtLS14eHjQhSeTsyEFqpBq27YtLCwsUF9fj9TUVHh5eeHTp0w8f/5c5LOHytpiwtOnT5GSkgIlJSVcvXoVq1evQW1tDYyNjSEnx2LcmY6P3w1PT2H78zZt2mDv3r148uQJdu/eTdsdDx06VCg8kwlhYWEya6SYnA0FwWKxYGtrS2fKbNmyBSNHjsTbt2/x7NkzqVkpoHkW8UyMlL6+Pp3Tc/fuXQQEBKCwsBCmpqYICQlBYWFhsww5Pnz40GyL+K5du8LFxQXV1dWIioqCqakpWrVqhYCAAJH7iImR+hUqKyuB/4+9N4+Hcu//x5+mEYlCCqVFm0p7FKWd0p4WkWUMY1CK0kKFQSrtHS3GEiLt2zmnPa20nbbTSSqVkrLvkmXM9ftjuq5mzDWT8bk/v+99f+6ej8d5PA66Znm7zHW93s8NaHZEvKGhIQ4dOgQzMzNs2rQJ3t7eKCsrw/jx47F+/Xq5zFZgYCCV2tlc3Lp1S+4Qx2AwqETZyspKbNy4Eebm5sjKykJ+fn6zWSlAlHr4r4iI79+/P44ePQpA9Hfg5uaGqqoqTJkyBWvXrkVRURHatWun8Hn06tUrCc9ec18fWVrs6+uLkpIShIaGIjIyEp06dUJgYCBMTU0ljqFjpH4GMiK+uYzU4MGDcfr0aZibm2PVqlVwcHDAt2/fMGvWLPj5+UmwSU0RFBT000COpnjw4IHciPjWrVvD398f/v7+yM/PR0hICLZu3Yq3b9+isbFRoef6/fffFa5C+IV/H/wassQgEAggEAikbjQsLS3x/v377zc5AirueNEiW0yaNAl3796lZaREpcVq1LAxYMAAandKZHStApvNxsSJE2Fvb0/dKL97R89IiSLidakYd0DEUu3fvx9Pnz7FqFGjUFZWLiG7EzFS9BHxN27cxKRJk6giPj6fj9jYOOjqdsLnz1+wf/8+qWNI1k78ORgMBqZNm4YvX77AwsICVVVV4HA4UFNTg4ODA8aMGYM7d+7IYO0kS4uHDh2KPXtEg5uHhwcqKkSlwFOmTMH8+fOpf5eV9ZaWOXn58iU6der4XQbIAwA8ffoMO3fuxD///IPRo0dLlQID9IwUIGIbJ0yYgIAAf3z58uV7KfB+GBh0QU5ODu3uZlNGilwjG5u5qKysgJmZGb58yQOb7QoNDXWwWCyYmpr+hJH6IX80NTWFqakphEIh3N25qKgoh5sbBzNnzsScObOpi60sRooM5BCXAT548ACbN29GZmYmLCzGoqamRkoCVlREX1r86NEjjB8/HuvWrcPHjx/B5/OpNMAPHz5QmxXioCstZjKZWLRoEerr62FiUomsrCyw2a7Q1GwPNpuNoUOHymWkxKV9FhYWsLCwgEAggIeHB8rKysDlcjF37lxYW1tTayTetSUOUWmxFnr37k1FAd+5cwdBQUF48+YNJkyYgLq6OqnBraCgkLa0+MWLfzB27FgEBgbi7du3iI6ORkFBIXr37o3s7Pe0ccN0pcXKyspwcnICk8lEQUEBHj9+jOTkw9DR6fA9DbA/rl69SrtGTQM5yN37hoYGcLlclJeXw8PDEwsXLpDY6X/+/DkOHpQ+z0lGasSIEVJymaKiIjg5OUnJZQCRVFTRFDRZyYZ0UFVVxfr166GpqYk3b97gjz/+wKZNm2BgYAAejydz8whoeUT87du35TJS5ubm+PPPPyEUCpGSkoK5c+fi5cuXsLW1pU2ClQVZgRzyQMdIqampISwsDGFhYfj48SOCgoKwYcMGGBoaIjQ0FH379kVycjIuXLig0HOFh4fDyclJoWNIRko8DfDgwYOYMWMGCIKAs7MzOByO1BCRlZWlcCpjREREsxmpdu3aYevWrYiLi0N6ejoOHDiA1atXw8jICKGhoXIH9+YEctDh2rVrchmpadOmYdq0aRAIBDhw4ACmTJmCrKwsODg40KacykJLI+KbXic7dOhAreeLFy/A4/GQm5uLgQMHIjQ0FJ07d0ZcXByVFtpcbN26tUUR8W3btpVIA9yzZw8mTJgAFRUVeHl5wdbWVuq4lkTEb9y4sdkMtJ6eHg4cOICUlBScPXsWwcHByMvLw4gRI8Dj8WRW2gCia0B9fT3atGmj0Ov7hX8f/BqyxHD//n2qJ6EpyEGKyWSCzXZBcXExoqOjERsbi4KCQrx7907q4kfHSJGor6/HsWNHUV9fj+TkZLi7u0NFRRVmZqNkam/pIuKNjY2xfft2sNlsTJo0CWvXroFAIMCkSZNgZ2eHq1evybypOHPmNCV/JHehABGz5Ofnh+XLfb77t9wpKWRSUhImTqTvPiEHKSaTCS6Xi4KCAkRFRWH//v0oKCjAp0+fpD7Y+Xz60mIGg4H6+gYcP36ckgFyOBy0bdsWFhZjZTJSdKXFw4YNxbBhe8BisTBy5Eiqf8va2hrz589Haup12mRDQHTTSEr7OnfuTMkGHzx4gLVr12LFihWUDJAc3MS7tpqCHKTIgenTp1zw+VHYvXs3CgsLkZ9fIOHfEq0RnzYinsFgoLFRgJMnT1IyQDbbFe3aaWDixIkyGSm60uJRo0Zh1KhRYLFYGDhwIOXfmjlzJmbPno1bt27JvLk7duwYVZbcvXt3Sg5x584dBAYGws9vlYR/C5Ds2mqK69evIyoqihoGsrOzER0dje3bt6OwsBClpWUS/i3Re4qmkg3FwWQyIRA04uTJk6iqqkJsbCyOHTsOLS1NWFlZyUk2lC4tHjt2LMaOHQsWi4VevXrBy8sLysrKsLGxwZQpU5CWliaXkSLPHXH/1vXr13Ht2jWsXr2akgGS7/v48eMyd4DJQYr8t2/evPk+uBWgoKAAVVVVUgNgbGws5s6dK/VYysrKEAoJnDp1CuXl5eDz+UhKEtVTWFtPQ/v2mmAwvgKQPJ+Cg4Oxfv16ie+RcpmRI0dCKBRSchlvb2/MmzcPFy9eVFg2JBAIUFlZqXBE/JEjR3DlyhVqYBL3b40aNQo8Hk9qp3zjxo3NKi0WR3M8UiQYDAbFbpqamkJHRwdjx46Furo6/Pz8fprS+L8RES/u37p9+zZ8fX1RWFiIvLw8CIVChZ7rxo0b1MZNc9G0tJjBYIDD4YDD4aC6uhrh4eES/q1Jkybhxo0bUlL2n4GUwCvCRgE/IuLJgenq1avgcrmoqKig9W8BzS8tFsfHjx+bzUgxmUwsW7YMy5Yto5ij0aNHQ0dHRyoNkA4tiYhPTk6WuzkycOBAnDx5EoCIfXF2dkZVVRXy8vIUHhIuX77cooh48Q2z1q1bY/Xq1dQmckhICHbs2AF9fX0EBQVh+PDhuH//vsKfK0KhkFYC/zNER0fj9OnT1GfOiRMnYGtri/r6esydOxc+Pj5SG1JXr15VWLr8C/9e+DVkieHp02dYunSJ1Pfz8vIlGClApAdet24dQkJCMHPmTCrGvV+//vDw4EJbWxvv32cjOFhak/38+XNKL9y6dWu4urrC1dUVRUVFYLFYlHyDy+VSFwR5HSIiad8gCf9WUlISVQpM13HS1EcmjidPnsDNzQ2LFy/G5cuXsXr1aggEAlhaWuLOnTTExcn3kZHQ1dVFcHAwwsI2wtLSEnv27KH8W1wuFxoaGjIZqYyMDEr+SMoAvbw8kZeXD1dXNtq3b4+AgAAJ/xYg2bUlDlFEfH+qZV40uMXD1dUVHz9+xLp166WOIbu26CQLL19mgs1mw8nJifJvEQSB6dOn49atm7R9ZHSlxV27GmDjxo3YvHkzNDW1EBGxBVVVVTAxMYWbmyvU1NSkurZIiEfEkzJAQLSjRwabbNiwQcK/JfpdFcssLTYyMqJkgNXV1YiNjQWbzUZOTg6CgqT9P2TXFt1Al52dDWdnZ7i4uODUqVPw9l4KJSUlzJkzF9evp9LeLNJFxBsaGmLz5s3YunUrVFRUsHFjGL5+/Qpzc3M4O7PQpo2qVNcWCfGI+Pbt21MX4ezsbHh6ekFTsz1CQkIk/FsAflJa3Jvyb5WVlSM2NgZHjhzFp085VIiKOJr6yMSRn58PR0cHsNlsHDlylBrcFixYILNriy4ivm/fvti+fTvlKdywYQNqa2sxfvx4ODo6QllZWapri4S4t0VbW5s61169egUfH1+0a6eBsLA18PCIlJAB5uTk0N7MXbx4EcbGxhJyGR6Ph4iICLx//x5JSUlSx8iDeGlxc0EXES/u3zp27Bi12z1//nwsX74cTCYTaWlptN2E8hAUFETr85QH8vOIx+OBx+MhJycHwcHBCAkJQffu3RESEiK1qUEGcijKQCQnJ8v1SImD7BVcu3Yt8vLyMHPmTDQ2NsLBwQGenp5yB4CWRsRnZWXJLC1WV1enNrnevXuHoKAgBAQE4OPHj0hJSVHoeQ4ePKhQFD1Az0iRPZekf4tkxtlsNhWrn5qa2qJAjpZExPfu3ZsamDIzMxEcHIwVK1agf//+CAsLkwpaaG5pcVPExcU1OyKevM4GBgbi+fPnlH/L09MTtra2cs+R/42I+E6dOmHfPpEy59mzZwgNDcXnz5/x+fNnhc8j8dLi5oIuIn7hwoVYuHAh6uvrsWPHDmpDatmyZVSo0q1btxT2cP3CvxeURMmD/x4wMRlEPHqU8P/kuaurq+HmxoGmpiZsbRdK7PzxeDxYWVnR7uKwWCxqFxAQXTxPnjyJ8vIKEIQQhw8flvLL+Pj4YvnyZVIDk1AoBJvNRmJiIjIyMhAXF4eSkhIMGDAAvXr1wocPH2g/hLlcLpVsKI66ujq4ubnByMgIb9++g65uJ3h4eKBXr16IiYlBmzZt4OjoKPV4bDYbMTExEh9ydXV12Lt3L/7880/0798fixcvljD1hoVtxLhxY2l7TlgsFyQmJlDv8dKlSzh79iyqqqogFIrWqOkH6sqVK7FkyRKp3UqCIODi4oLExEQ8ffoMCQnxKC+vwNChQ9CzZ09kZmZSJn9xeHh4YMuWLVI9Zg0NDXBxEfVmffjwEV26dIanpye6deuG+Ph4tGrVCs7OzrRrJM5IASIdeWRkJC5evIiBAwdSMkASmzdvxsiRI2l3lZuu0dmzZ3HhwgV8+/YNAkEjjhxJkbowrVq1Cu7u7rQXS/LxRKXZh1BVVY2RI03Rs2cvPH36hPam0NPTE+Hh4ejQQTIlsKGhAc7OzjA0NMTnz1/Qo0f376XA+jh06BAaGxtpd//ZbDb4fL7E7lxVVRUiIyNx5coVDBkyhJIBktiyZQtGjBhB63FksVwQH38QDAYDAoGIwbt69Srq6+shEAhw+PBhqTVas2YNWCwW7cBErlFaWhpSUlJQU1ODMWPGwNDQEPfu3aOV7Hp5eSE0NFRqYBIIBHBwcESPHt1RUFCAXr16w9PTAx07dkRKSgq+fv1KWzDt6uoqwUgBokEzMvI3XL9+HcOHDweHw5GQaW7bth0DBxrT3lCwWCzEx8eDwWCgoaEBR44cwc2bN9HYKIRA0EClqYlj7dq1cHBwoE1OJdfo2rVr2LLlAr5+Fe269u/fH2fOnEF8fLzUMVZWVjh48KCUZ0EgEGDYsGHo1asX8vLyYGJigpCQEJmMKwkLCwsJRqo58PPzw+DBg39a3llbW4vt27fjwoULUFJSQm1tLR4/ftzs5wEAMzMz3L9/X6Fjpk6diujoaFrJWXp6OjZv3oyioiKMGTMGQUFB0NTUxIEDB5Cbm6sQU1RZWYmZM2fi9u3bCr0+MzMz3L17FwwGA9XV1di8eTNSU1Op8BO6zzAHBwe4u7srNMhcv34dcXFxtOelLAiFQhgbG6NHjx4oKyvDxIkTsX79+p/6wMaOHSvBSDUH69atQ9euXeHl5SX331VUVGDjxo24c+cO1NTUUF1djYcPHzb7eYCWnUczZszArl270LdvX6mfXbhwAbt370ZVVRWsra2xdu1aqKqqIiEhAf/88w9lXWgOampqKLZeEZiZmSEtLQ1MJhPFxcUIDQ3Fw4cPZfq3ANF1w9bWVqFOrXv37mHXrl04fvx4s48RCoUwMjJC165d8e3bN8yZMwcrV66U698CRAXO4oxUcxAaGop27dr9tB8rPz8fwcHB+Pvvv6Gvr4+BAwciLEy66/AX/v2gpKT0mCAIk6bf/8VkfUdqaioiIragXbt24PP5OHRIJJfhct2RnU3vIRBnpEiQu1w+Pj7o1q0buFwuVFRUsGiRHSZOnPBdH0/PSImXFhsbG2Pnzp0QCoW4du0aNm3ahK5duyIpKRn29nbUUCKPkTp06BCmT59OyRZevHiBvXv3orS0FF++fMGxY8ekjqFjpABR8EZNTQ14PB769euHqKgoxMTEQE9PD1wuF2/fvqXi4sUhzkgBIinI9OnTMX36dPj6+kJXV1fKvyUr2RD4sQMM/JABCoVCnD9/ATt2bEe3bt1w4sQJzJ8/n7rhrqurQ11dHW1RdHJyMqZOnUoNUk+ePMH27dtRUVGJ/Pw82jUqLi6WYqQAkc+hsbERwcHB6Nu3Lw4cOIC9e/fBwMAAnp6e3z1S8hkpco3INEBfX19oampSMkAWiwUTE5Pvvyt6H5l4RPzIkSMp6ZYosGQLunXrhjNnzkr4t0hGqumABYikblOmTKEGqXv37mPjxo2orq5Gfn4BTpyQvrCVlZWhdevWUhcsDQ0NMBgMrF+/Hn369AGfz8euXbvQo4coDTAz8xXtkJyVJVlazGQyYWdnBzs7O6xcuRJt2qh9929pws3NlRoYZDFSotJi0fkl7t86ceIENm7ciO7de+DixYuYOnUq9ZzyGKmjR4/C0nIyNUjdunULQUFB+PbtGwoKCnD8+AmpY2SVFmtpaaJNGzWsXbsWvXv3RnR0NAoLi9CnT294enrKTDZsyiQoKytTRbV+fn7f09JcoKOj892/JWIz8/PzaQcs8dJiS0tLWFq6o75eHTt37gSLxYKRkRFOnTqF+fPnU8cIBAJUV1fTmsIPHDiA+fPng8fjARDJIck0wHnz5sHHx0fqb6q5pcV0r705EfGqqqrYsGEDNmzYABsbGzQ0NMDMzAwGBgYICQn5qSTo8uXLLfZIyfL0jBkzhvJvJScnY86cORAIBPjy5QuePXum0HORpcWKoOl5pK6ujvDwcISHh+Pjx48IDAzEunXr0KtXL4SEhFDKAUVLiwGR94ZkGJqLuLg4zJ49GxERERAKhYiNjaVuyJ2dneHm5ia12dJSj1RzI+Lbt29PnW82NjYgCAJmZmbN8m8BLfdIlZSU0A5YAKjrrEAgwP79+yk26fPnzwoPgGRpsSJoGhGvo6OD3377DYCkf2vw4MEICQmBvr4+AMVLiwFRRLyiDHRKSgpmzpyJXbt2ob6+Hrt376b8W0uXLqWVnzentJgOzY2I19PTA5/PBwCEhYUpXPL+C/9++MVkfcdvv/1Gya1IZGa+wvbt2/DhwwdYWlpRMkASPj6+8PFZjp49e0ocJ85IAaD8W69fv4FAIECPHj0QHi4dTy2PkfLy8sKBAweQlJSEtLQ0tGnTBnZ2dnjz5g3atm1Lq/92cXGhPFLiKCwsxJIlS6CtrY2GhgZYWlpi0aJFYDKZCAsLw4QJE2j9Mk1ZO0A0aO7atQsfP37EjBkzwOFwJF6/LEaq6Rrl5eWDz49CdnY2AKBr166Uz6fpGpHJhk3XyNPTE/v3H0BCQgIePLiPtm3V4eTkiIyMDLRu3ZrWkE3HSAGiYZPL5aJDhw4gCALW1tMwf/48MBgMbNq0Cebm5rTJW+KMFIlHjx4hMnIvcnI+wsbGRsK/BQB+fqvA5cpipH6s+adPuYiKikJubi6YTCb09PRozyMPD08q2VAcZMBBZGQk4uLi8OTJU7RrpwE2m41//vkHQiEBNtul2WtUWloKNtsVHTpoQ0mJgblz52DGjBlgMBjfGSkTWFlJ68np1ig9PR18Ph+fPn2Cre0iuLi4UP4tQMRIubi40AZviD9ednY2oqL4yM/Ph6qqKnR0OtDu/MtjpNzcOPjttz2Ijo7BixcvoKWlCTc3Dv7++xlqa2ul/GwAPSNFrhGLxULHjh2hrKyM+fPnw9LSEgwGA9u2bcPAgYMwbZr0hVSctSNx8+ZNHDx4EDk5OWCxWJQMkMTatWvh6OhEG7whvkavX7/+Lm8uRrt2GmjXrj3tebRkyRIq2VAEHQDdIRAIMHbsWJw5cwY8Hg9Pnz5Fly5dwOPxcOvWLZSUlFCDlDhkMVJ1dXXYsWMH/vjjD7Rp0wbLly+nvGN+fn4YMmQILZssC69evYKfnx/Onz/f7GMASSbhwYMH2LhxIwoLC2FmZobg4GDaGyt5jJQs7N+/H58/f1aIkcrPz4epqSkMDAygoaEBPz+/ZiXDiTNSzUVzGSky7KO0tBTdu3eHkpISlYLXHAiFQowePVph9kYWI1VZWYnw8HDcunULWlpaWLt2LfUe1q1bhx49eoDL5Tb7ebKzs+Hl5YVLly4p9PrEz6PLly9j586dqKiogJWVFQICAmg3DKZPn449e/YonF748uVLhfrmcnNzYWpqiu7duzfbv0W+J5KRai5cXFxgb2//0/P0999/x2+//YavX79i0KBBKC0tpbxdzUFLzyNZjBRZT/H06VPo6+sjODiYUluEhoaiffv28PHxafbzfP78GSwWC9euXVPo9fn7+ytc7/AL/+/wi8mSg7y8PNpOhf79+0FDQwOxsbF49+4dAgLWob6+DhMmTIC9vT3Ky8ukBixAurSY9G8BgIODI6qrq8BisTBgwABwuR7Q0tKUy0glJibC0tISKioqlCG4qKgIUVF8XLt2FSYmphg5cqTEICOLkQJEQQo+Pj4YO3Ys6urqcOjQIXA4HLRp0wYFBQUyu7boAjkGDx4MLS0trFu3HllZb7Bq1So0NjbCysoKCxYslMlINS0t1tfXo27MHBxEkdcsFgtDhgyBu7s7NDQ0UFdXh4aGBpmlxZMmTW7i38pDVBQfN2/egJmZOXJyciRMrmTXFn38OR/Lly/HxIkTUVNTg/h4kX+rbVt15OfnyezaogvkMDExgY6ODvz9/fHq1avv/i1gxozpmDt3rsxkw6YR8V27GlA3w4sXL0ZJSTFYLBeYmprA1VXk36JLNiRBlharq6tTF4mcnBzw+XykpaXBwmIs8vLyqB1F4EfXlqxi52XLvGFpaUmFSpBpgJ8/f5bBSNGXFo8ZMwZnz57F2rVr8c8//2Dp0iVgMBiYM2cuZsyYjoKCQtoBS1Ra/OP8MjQ0RESE6MJkb28PghDCxcUFo0ePBovFgoqKCpVsSMdIiQI5LKgYd0C0Qx8dHY379x9gwoQJKCoqkjiWzkdGIi7uIJYuXQpra2vKv3X4cAo6dNBGbm4ubbKhrNLiCRMm4OLFi1ixYiX++ec5PDw8KP+WlZUV8vPzaQespqXFRkZGVOLjokV2qKn5BjabjfHjx1P1FHTJhkAVAGDfvn2wtraGnp4e5at78uQJgoODcf36ddja2qKwsFDCvyWPkVJRUcG6deuwbt065OXlITg4GJs3b4aBgQHevHnT4tJiRdC0tHjUqFH4448/IBQKceTIEcybNw8NDQ1YuHAhvL29wWQyFS4tJpGSkqLwjfuOHTsQGhoq5o8MQnBwMHr06EHr3wIUC+QQR3MZKdK/JRQKMWjQIKirq8PCwgJOTk5wd3f/6fP+TyLi6Ripdu3aUSmdb9++RXBwMPz9/dGnTx88f/4cT58+Vei5goODFY6Iv337tsQ9wdSpUzF16lQIhULKW0gWMzs5OYHBYChcWkyiJRHxfD4fgYGBWLJkiYR/a8CAAQgNDaUtyiUDOVrikWrORgDp3xIIBDA2Noa6ujomTpwoMw2wKZKTk5s1KIpDHiNF1lMAouoUsp5i2LBhePDggcIsIFlarAhyc3MlfNS/8J+LX0MWRBK0WbNmSX1fFDYhir41NDSEpaUlGhoakJx8mJK53LhxQ+pCIa+0WEWlNRV5evXqVfj7r0V9fT1UVVVlmn/pIuI7duwIDw8uvnz5DFdXNvbt24fS0tLvaYBcucmG4qXFKioqcHd3h7u7O+7cuYMtW7aAxWJRMkBS1ijetdV0jUSJTb3Rp09vTJ8+Hd++1eLQoUQsWDAfdXV1SE9Pl5Jbnjx5EhER0vQ+uUb79u2lZIArV65EY2Mj2rZtK/PiTxcRr6+vj2XLvFFQkA87Ozvs2LED5eUVGDZsKDgcDqKjo6W6tkiIB3KoqalR7/327dvYvHkzWCwXGBh0gaenF5UGKN611RTFxUXo378f+vfvBxsbUf9WXNxBzJs3D7W1tfjrr7+k9Olk11ZTNDQ0QEVFBVFRURAKhThz5gyWLROxsJqa7TFunLQvDqAvLe7WrRv8/PxQXFyCWbNmYuPGcFRXV2PUqJHfPVX0qX0AJKR9GhoaVKjCjRs3sWWLaI1E/i0vKg0wOjqa6tpqiqKiIhgbG8PY2Bh2dnaoqqpCTEwM5s2LRW1tLf7++28MGTJE4hiya6spBAIBVFRUEB0dTckAyVLgDh06yEzJogvk6NWrF/z9A+DvvxaWlpMpGeCYMWPg7OyM2NgYyqjcFOLSPi0tTeqm7caNG9i8eTPYbFdKBkhKRkV9ZNJsGSAqLRbJZIfC2dkZpaWliI6Oxv79+1FbW4vMzFdSoSbySovbtFFFXFwsGhoakJKSQtVT6Onp0ty41AEQJX6mpqZK/GT48OGIi4ujkhYXLVqEuro62NjYwMfHB6GhobQMYFPo6+tT5+iJEyewdOlSmJmZYeTIkeDxeD/1bwH0pcU/w44dO2jDahgMBhwcHODg4IDa2lps3boVFhYWUFdXR8+ePVsUyMFgMJrdI0Xizp071ADRrVs3JCQkABAN0CtXrkRJSQnGjBmDwMBAaGpqAgA1ZCiC1NRUmfIzedDQ0MD9+/dRXV2NTZs2SaUB0uHQoUMKD5vNjYjv3bs35fM6dOgQLl68CHNzc0yePBnr1q1r1vq/efNG4Yh4WaXFDAYDS5YswZIlS1BeXo6wsDCMHj0aHTp0gLGxscK9Z1+/foVQKPwfRcT379+f8jBduHABbDYb1dXVEv4tQPHSYqBl8kcGgwEtLS3cv38fxcXFCAkJwa5du6Crq4sNGzZQMvmmaElEfERERLPkj8OGDaPqKfh8Po4dO4Zx48Zhzpw5WLFixU/9W4DoGhAXF6fQ6zt+/DitX/4X/vPwXz9kEQSBkpJSWr/OhQsXMGSIpFdBWVkZbLYL7t5Nx7p163HkSAoSEhLRsaMOPDw80K1bN7mMlLihn/Rv1dfXw8bGBrW1tUhLS4OdnR01TBQUFMhkpMhBytjYGLt27YJQKMSVK1ewZs0avHr1Cr169ZLqYCG7tuhw5swZ/Pbbb+jVqxf++ecFIiMjUVZWhoEDB6GoqEhOsqHk7nmbNqrw8PDAkydPsGrVKiQnH0Z0dDT09ESlwJ076/+EkRJdlBkMBmbNmolZs2bi27dazJtng8rKKjx8+BCOjo7UTWBxsWTXVtM1srOza+LfOg9fX19kZb1Fnz59pPpFXr58KTMi/ty5c9i9ezeMjIzw5MkTbNu2FRUVlRg+fBgKCvJpd5SvXr2Gfv0kY6vV1NSwbJk3Xrx4gWXLvHH06FHs3bsPXbsawMvLC506dZLJSB0+/CMinsFgUL0g1dXVWLBgAYqLi/H06RO4uLhg+PDhAOQzUqLS4gUwMzODmZkZhELh9zRAb7x9+w7GxgOk1qipj0wc58//id27d6N///64d+8eNm4MQ3X1V5iZmSE/P5+WkaIrLdbQ0MDKlSvx5s0bcLlcpKQcwc6dO2FoaEgNJbKSDcUj4plMJuzt7WFvb4+KigrY2i7Cly9f8M8/LyT8W/IYqdjYGMyfP5+KcRcIBDh27Bi8vLzw7t17DBw4SGqNRF1b9KXFFy9exK5du2BsbIxbt24hMDAQtbW1sLCwQF5eHi0jRVdarK2tDX9/f3h5ecHZ2RlxcbHfvXp9weVyoampScNIiSAqLRYNm8rKymCxWGCxWCgtLYW9vT10dXXx5k2WhJS1rCwHysrKtKXFYWFhcHNzo03N+vTpE7Zvl+5Lk4dTp07hzJkzMDc3x4kTJ6iNrfnz58PHx4f2772lEfHNYaRUVVURFBSEoKAg5ObmYsSIEejWrRsyMzPB4/GaFekcHh7+L42It7CwwPnz5yEUCpGUlIQ5c+agsbERdnZ2ePv2bYtLixVBTEwMtdGorq5OpaFlZ2cjODiY8m+FhoZS15DKykooKSkpPGy2JCL+ypUrOHbsGCZOnEilASopKcHFxQVsNpt2XW/evEmrUpGH5jJSmpqaVOhEZmYmxo8fj27duoHFYiEsLKxZkeL/6oh4cf/Wvn37YGlpCSaTCXd392YzUk1fX0si4snKCh0dHURGRgIA/vnnH/B4PHz+/BmDBw9GaGgopTyqqalBY2Mj7f2bPFy6dEnhiPgHDx4gOTkZlpaW2LlzJ5UGuHTpUglfatNjFI2IJwgCBQUFcgvdf+E/B//1Q1ZGRgYePnwgJZcBRDfUdB8U377VorGxEYaGPSjZWGbmK0RF8ZGR8QJ6enpSpcAAkJ5+lzb+vKysDN27d8f+/ftRVFQEPp+P+PgE6Op2QkNDAxwcHGhfOxlpS4LBYMDa2hpduhggISEBX7/WUDLAxYsXY+zYsbRdW8APRoq8CA4aNBC7d4tKgbds2YLCwiK4urrCysoKCxcupG5wTp8+LZO1a2hoQJ8+fahS4GfPnmH37t3IynoDPT09VFVVQUNDQ+K4tLQ02h3l6uoqdO/eHVFRUd9lgFGIioqCvr4+dVNBh6YR8aLBbRZ69eqF2NhYFBcXUzJAJydHmJmZ0XZtkRCX9g0fPhzDhw+HUCjEpk2bUFRUBDc3DqZPnwYbGxvqYnby5AkqhlgcpLRv4MCBFBvz119/YfPmzcjOzoa+vj5tKfCtW7doS4vr6+vRvXsP8PlRlAxwz57f0L17N0rqRIempcUMBgMLFy7E4MGDsXfvXrx//56SAbq4sDFs2FDari0Sooh40Y2uubk5zM3NIRAIsGnTJhQUFIDD4VAyQHKNxLu2mq5RbW0ttdaA6BwJDQ3Fx4856NKlM759q5XwbwHAjRv0pcVCIYEePbqDz+dTMsAdO3agZ8+eaGxslHmxzMiQLC1mMplwcHDAqFGjsGvXLrx48QJHjx6FlpYm3N3dYWxsTNu1RaKg4EfPyvjx4zF+/HgIBAKEhW1Efn4+PDw8MH/+fFhZWUFJSQmAZNeWOMhADnKtRe//BjZs2EDJThoaGqQGbFmlxa1atUL37t0RHR2NzMxXlH+rX79+KC9vJfP3fvfuXYnEstatWyMgIABz587F6tWrFZatiZcWL1q0CIsWLaLSAMeOHQs1NTX4+Phg9uzZ1DGKlBaTiIqKUvgmUl1dHUZGRrh9+zbu378Pf39/FBYWYvTo0QgMDJRpjBdnpJqL5kTEMxgMakiuqamBm5sbPnz4gKlTp2LVqlW0aZ1NQVda3BzIiog3NDTEoUOHAIiGlmXLlqG0tBTjx49HbW2twqXF79+/p6oGFIF4abGXlxe8vLxQWVmJjRs3YvTo0dDS0kJAQIDEQBoREYG9e/cq9Dzx8fG06bry0LVrVxgZGeHOnTu4dOkSOBwOKisrMWXKFPj7+8sMfElNTZVbWkyH5kTEM5lM+Pj4wMfHB6WlpeBwOHj//j1mzZqFDRs2YNSoUT99npZGxMfGxuL333+X+v6gQYNw6tQpAKJ7MkdHR9TU1GDWrFn4+vWrTDWKLLQ0Il68tFi8niIkJATbtm2Dvr4+eDyehNpCkdJiEk+fPqWudb/wn4//+iHrzp00JCQkgMFg4PDhw5RcZu7cuRAKhVJDAAAcOpQIKytJmUj//v2wY8d2yuxJygAnTpwIe3t7FBeXoG1bNbmMFCCSAZJDQUZGBnVhunv3LtzdudTg9s8//9D6yIAfpcW9evWCuzsHBQUFVHHyp0+faI8hu7aagsFg4MOHDzh+/BhUVFQo/5aamhoWLrSVydolJSVJyUSGDh2KPXt2w8XFBXPnzqVkgFOmTMGCBQtQVlYmh5HiU4OUvr4+1Uf09OkzrFy5AoWFhXj69Ck4HA71O8vIyECnTvRt6nFxcfDy8kKfPn3g5eWFvLw8HDhw4HtM8mdaNkM82bDpGn369AlHjx6DikprqhRYQ0MdDg4OMru26EqLTU1NYWpqChcXF0ydOhXLly8HQQAzZ87AnDlzvqf2yfaRkaXF3bp1o3Z8Hz58iLVr1+LLlzy8fv0abDabunjLY6Sio2OwZMlSSn6Wk5ODqChRcXJubi40NaV/79evX4eRkbTciMlk4suXL0hJSYGKioqEf8vZ2VkOI3VEKoSFTANks9kYO3Ycli5dAiaTiblz58La2hoVFZW0qX2AqLSYHKR69epF3fCSxckfP+YgJycHzs7O1PFv376VySRER0djyZIl1MD09u1bqhT48+fPtJ6O27dv0/oUmUwmCgrykZKSAiZTGdHRfMq/5erqKjPZ8Pjx41Lyx4kTJ2LixIlgs9kwMzP77t9qjYULF8DS0lJmsiEgWVpMfq4Bohu7wMCNuHMnB1++fIGvry8llxGxvx1p14iutPhnkMVIiacBfvnyBcHBwdi0aRMMDAwQGBjYotLio0eP4sqVKwodQ7J2gCgUgPRvpaSkwMbGBgKBAIsWLcKSJUuoz7M3b96gQ4cOCg8Jisof1dTUUFpair/++guAaP0DAwPl+rcAESMlS9onC81lpCZMmIAJE0TpugcPHsSqVasoBQSHw2nWmgQGBtJ2PsqDrNLidu3aUWl0WVlZCA4Oxpo1a9C3b1+EhITI7KSUh8TERIU9UuKMlLW1NaytrSEQCHDgwAFa/xagWGmxOF69etWsYZuEtrY2amtrkZ6eDoFAAB6Ph0+fPmHgwIEIDQ1F586daY9LSkqSW1pMB5KRIqWusjBnzhzMmTMH9fX1iIyMREREBIYOHQpdXd1m+bcA0d/DypXS6azyIKu0WE9Pj9qoevLkCXg8HvLy8jB8+HAEBwe3qLT4999/V/g8/4V/YxAE8W/z34gRAwmCePT/23/19feJvXvZUt8vLr5M2Nv3JWbO1CdWrpxAvHp1WOLnzs4DiYaG+1LHffnyJ+HlNVLs8e8RBw8uJVxcBhFWVtq0z0U+Ht33//77ILFmjSXR2PiQuHx5E8HlmhBs9mAiKcmXWL58DPH27TGpYxobHxLOzsa0j3fhQhixevUkYsWKcYSz80Bi61Y7orw8lSCIR4S7+3Dq/8X/q61NJ9jswVLfz88/T9jZ9SGmT9cj1qyxJN6/PyHxcxeXQbRrVFh4kfDwMKG+rqlJI/bv5xAs1kBiyhQdYv9+jkJrlJFxiFi9ehLR2PiQOHcuiHBzG0qw2YOJY8fWED4+FkRW1lGpY4TCv2Q+3pUrm4kVK8YRy5aNJpydjYndu52IqqqbBEE8IrjcEURp6TWa8+ge4eIySOr7ubnnCFvb3sT06brEunXWRE7OWak1qq+/J3VcUdElgsv9sUZfv94mfvvNhWCxBhLW1h2JqCh3hdYoMzOZWLlyAtHY+JA4ftyfcHUdSri5DSXOnNlArFw5Xur8/vF49OdRaupWYulSM2LJEjPC2XkgsX+/G1FTk/Z9jUyIoqJLzV6j9+9PEAsX9iSsrTsSwcEzifz881JrVFubLnVcaek1gssdQX1dXp5KbN9uTzg7DySmT9cl+HyuzDVqbHwo9f03b44SK1aMIxoa7hOHD68k2OzBhLv7cOLChY3EqlUTiRcvEhVa81u3dhJcrgnh4WFCsFgDiZgYT+p9eHqaEoWFF6WOaWi4T7BY0o/35s0RYsECQ8LauiMRFjZXan3Z7MG0a1Renkq4uw+nvi4puUJs2rSAcHYeSMyYoUfExnrJ/L3TrdHbt8cIHx8Loq6umti8eTNhbm5OTJw4kTh9+jSxYMEC4u7duwQdRo0aRft9ebC0tCRycnKa/e8fPnxI9O/fn+jcuTOxbNkyoqSkpFnHlZWVEePGjVP49Y0aNYpobGyU+fOvX78SwcHBhJmZGTF58mTiwoULhJ2dHXHnzh2FnufKlSuEs7OzQsc0NjbSrvmdO3eIadOmEaampsSqVauIiooKiZ9bWFgQVVVVCj3XmjVriJiYGIWOefv2LWFtbU1UVVUR/v7+hJmZGTF16lQiNTVV7nEtOY+sra2Jt2/fNvvfX7lyhTAyMiL09PSI9evXE9XV1c06rqqqirCwsFD49ZmZmck9j8rKyogVK1YQo0aNImbMmEGkp6cTTk5OxJUrVxR6njt37hCLFi1S6JjGxkZi5MiRUt//448/iMmTJxNmZmZESEgI8e3bN4mfjx07ligrK1PouQIDA4nIyEiFjvn48SNhaWlJFBYWEkuWLCFGjRpFzJkzh3j8+LHc41pyHs2cOZPIyMho9r8/ceIEYWRkROjq6hJbt24l6urqmnVcQ0MDsW7dOoVf3y/8vweARwTNXPNfzWTdv3+PNpWmQ4cOFGuTlSXamRbJZfrDxmauTEaKz4+SkPaJ/FtssNlsODg4oqKiAiyWCzp16ggul0ulHsnySMXFHYSvrw8YDAamTJmCKVOmoK6uDklJSXj27Bm2b98OOzs7CYmCeNdWU5w+fRrbt29H+/btKf/W6tWrUV9fj5KSErRt21bqmEOHDsHSUjqGW1dXFyoqKjh3LgkvX77E7t17UF5ehsGDB2PevPlyPVL29vbU1+JpgA4OjsjPzweL5YLOnfXh4eGBHj16SHVtiSM2NhZLloiS6MiUom/fahEffxBPnz7Drl274OTkJNHQLmKk+tE+3smTJ7FlSwS0tDQhFArx+++/w9fXF42NjSguLkb79tJG4+TkZNqUrC5dukBNrQ2Sk5Pw999/Y+vWCFRWVmLEiBGYO3euzGTD6Oho2Nn9kECQ/i1AlCqYk/MJLJYL5d/q0qULXr16JZORiomJAZfL/S4DXICFCxeguroacXFxePToMRoa9oHNdsWwYUOpY1JTU2XueB87dhybNolKi3/4t0TBIMXFJbSs3ZEjR2j9IYaGhmjbti0OHz6Mhw8fIjQ0FF+/foW5uTlmz54t0yPF50dJBHK0b9+ekvPZ29vj3bt3YLFc0LOnyL+lq6uLt28lu7bEER3Nh5ubG5hMJhYvXozFixdTaYAPH/6F+voGcDgcCa+UeNcW3fvduDEMHTt2hEAgwJEjR+Hp6YlWrVqhpKSEto/s2LFjGDNGmrHo06cPNDQ0kJycjLt372LDhg2ora3F+PHjMWvWLJmMVHS0ZCCHtrY2JQu1s7PDy5eZYLFc0K+fETw8PKCtrY13795BU1NLJmvn5sZB69Z1EnIZHo+HK1euoLGxETweTyJZtaUeKVldW7JgamoKbW1t/PXXX/j9998xf/581NfXY/78+Vi+fLlMaVBYWBhcXV0Ven2vX7/+KSOlpqYGHo8HHo+HnJwcBAcH48KFC2hsbESHDh2avSY7duygenOaCz6fTxvYYGFhgQsXLkAoFCIxMREzZ86EUCikzveWeKRu3bpFK4WWh6CgIKxduxbq6urUsdnZ2RL9W2FhYRKeqOvXr8v8W5MF0iOlCCNlZWWFTp064f79+0hJSaF68thsNlgslszf+aZNmxQOKvj48SPat28v9zzS1NSkLAuk9+/SpUtgMBgwMjJqNmu7adMm7Nq1S6HXl5iYSFvlMnPmTMycORMCgQCRkZGYPHkymEwmPD09MXv2bAiFwp8yUk1x9epVhT1SpPyxY8eOVNfa8+fPERISgs+fP2Po0KHg8XgSip979+4pzHQLhUIUFtKn28rCggULsHfvXty8eRPx8fGYMGEC2rRpA29vb5khSYBoHRRhG3/h3x//1UPWs2fPaBPz8vLyoaYmGqREchmRz+Dq1WtYtmwZ2rVrh8TERCxevFjiJlleabGBgQGlq3/58iWioqJQXFyMoqIiyigsDrK0uKk+XkVFBV26dMGsWbPAYrEQFcXHwYPx0NXtBC6XizNnzsj0SIlL+0j/lrW1Nfh8Pp4/f075txwcHCh5Snp6Oq3HQTwifvDgwdizR+TfunTpErhcd7Rr1w5Hjx7FggULJG5wRKXF9BHxXbp0pvxb5IBUXl6BkpJiWr+OrNLiNm1U0bt3b0yfPg3Ozs6IiorCgQMH0KVLF3h6euLUqVPYskXaF9E0Ip7BYGDu3LmYO3cuoqOj8ejRI0oG6OzsjJEjRwIQyb/oPFLipcUmJiYwMTGBUCjE2bNn4ebmBg0NDZw+fRpz585tEirxhtaD8erVK3Tu3JmKcX/48CE2b96MqqoqlJdXIDQ0ROoY8nU0HZjU1dUxcOBA1NTUwMHBgZIBitIAPXH8+Als2iRtMCd9ZOSQQPq3Fi5ciJiYGNy9e5eSAbLZbKpf5MaNG7RrJArkEK3RmDFjMGbMGAgEApw8eRIsFgvq6ur4888/MX36dIk1kl1anAV9fX1KBpiWloaQkBDU1NSgsrJSwsMoDjpZh5aWJkaOHIna2jrY29t9lwEWonfvXvD09MTRo0fleqRIaR+TyYSTkyOcnBwRGxuLmzdvgs1mo0OHDuBwONTFOzU1ldYjVVFRQQ2bpAywoaEBR44cgb29Pdq1a0d7cZZXWqynpychAyTrKaqqqmRK+/LzC74PmVUARIO0np4eZs+ejfr6enh7eyM4OBh5eXkYMWIEeDwedu7cifj4eNrHk4UDBw4o7JEiI+Lbtm1LhZyQ/q1x48ZBTU0Nvr6+mDlzpsRxaWlpCkfEBwcHKxQR361bN9jZ2UEoFILL5WLVqlUoKiqChYUFgoKCZN6Q/k8i4uk8UiTIoYFMk9u8eTP69esHTU1NhW7ysrKyJEqLmwu6iHhDQ0MkJycDEH1WLF26FGVlZZg4cSLWr1+PrVu3Yv/+/Qo9T2xsrMLyR7K0WFNTUyINMDw8HKNHj4a2tjbWrVsnJd9sbmmxOAIDAxWKiO/fvz+WLVsGBoMBW1tbuLm5oaqqCtbW1lizZo1M/xY5bCrqkYqPj8cff/wh8+dMJhMrVqzAihUrUFxcjNDQUPj5+UFLS4s2LVcWmpYWNxevXr2S+pwYPHgw5d86c+YMHBwcUFNTg9mzZ8PPz6/FpcVkIEdzQUbE6+npISAgAAEBAdSGVEREBDp37iy1IQWINi3o7gd/4T8X/7VDVllZGRoaGmgvEHx+FO2ulJWVJZKTkxAbG4vk5B/+rUWLbKGjoyPTI3Xw4EH4+PhSXw8YMAA7duyAUCiEjc08HDhwAPX19Zg0aTLs7e3AZDKlurbEIc5IBQb+8G9FRkbi9es3iI6OBpfLlfBKJSYmyowbvnfvHlVaXFBQgKioKMTExEJLSxNKSko/9ZGRYDAYmD59Oo4dO46oqCgcOpRI+bccHBygqakpMzEnLi4OS5Ysob4m0wAbGxthY2ODffv2QSgUYurUqViwYAEYDIZU15Y4yEFKS0uT8m89efIEERFb8erVKyQmJoDD4Ujs3IoYKfqL8r1796hC3s+fP4PP52Pfvn3U+5HlkRJnpMg1mjdvHs6d+x0HDuxHXNwP/5ZoqNCQmWwYEyMZET9y5EiMHDkSQqEQc+bMwW+/idKYZs2aidmzZ1NrJN7/I47jx09QpcXkB/v9+/cRFhaGV68ycfz4cbi4sCVCJciuLTrcvXuXWqMPHz4gOjoau3bthoFBFxAEITfZUBxMJhN2dna4ePES9u6NRExMDE6cOAlNTU24ubmiTZs2tF1bosfjSwQzkP4tgUCAOXPm4rfffgOTyYSNjQ21Sy3q2qJPBDty5AjCwkSMFHlxvnXrFjZsCMSrV5k4d+4cnJycJJiko0ePyvTQ3L17F3FxcVBRUUFWVhaio6NRWFiEHj1EN9LNYaQA0fnm7OyM1NTr2LlTFD+enJwMHR0dcDjuUFZmykw2bBrIMXnyZEyePBkNDQ3fz6Pf0Lp1a9ja2lKMiGTXVpXE4+3atQvx8fEwMDCg4o5PnjyJhQsX4tmzZzhy5Ah8fHyaFXdMrt/Vq1eb9W9JhIaGSlUDNPVvBQUFYePGjTAwMEBISAgYDAZ0dHT+1z1SALBz506qtJhMA0xOTsacOXMgEAhgZ2cHLy8vic/aqKgoWhWBPCia2qeuro7w8HCkpqbiyJEjCA4OxoYNG9CzZ0+EhobKTcoLDg5W2DuSmpr6U0aK3EgQCoWIjY2FtbU1Xrx4gdTUVPTo0aPZv6+kpCS5wyYd6CLiNTU1qUE8KyuLYlCMjIwQGhpKMTeKnkctiYjftGkTVVosngZoZWVFpQEuXrxY4rXIYqTkoaamBkKhkNZvTQcdHR389ttv+Ouvv8Dn8xEaGorc3FwMGjQIISEhMv1bQMsi4tPT09GjRw+5/8bGxgY2Njaor6/Hnj17MGHCBGRmZiIjI0Mhdj0mJob6XGsuIiIipDxi4r2Cjx8/RlBQEPLy8mBiYoKQkBC0bt0a6urqCp9Hv/Dvjf/aIev69et49+49WCwW+vXrR8llABEjRScjfPbsGfT09KkYdzbbBcXFxYiOjsaVK1dgZNQPWVlZEhemH11bPaQe79KlSxg3biz8/PxQV1eH5ORkcDgcqKqqoqioGAcPSncr1NXVobGxUerDj+wXGjVqFLS1tbF69WoIBAJMmjQJdnZ2tF1bgGgHXzwiXldXl+rUIWVyLJYLBg8eBA6HQz2vPEZKV7cTFePu4eGBvLx88PlRuHXrFvr3748PHz5IfEDKYqQAEX1uYWGBNWvW4Nu3WiQkJFBpgEVFheDzpdkRWaXFw4cPx9OnT2FmNgoaGhrfS4EJWFtPw/z582i7tgBJRgoQyQBJBsPX1xd1dXVgsVgYMWIEXF1dqRucN2+yaFkBsrRYXAb46VMuoqKicO/eXfTvPwC5ublSxZCySouvX7+O0aPHICDAH9XV1VTwRrt2GigqKqLdAZZVWmxmZobMzFcwNTWFuroGvL2XQklJCbNnz8bMmTNpu7YASUYKAHr06EENbj4+vqitrQWL5QIzMzO4uLhQg1vTZEMSb968gY5OByrGHRDd3EZF8fHXXw8xcOBAFBQUSEWTFxUV0co60tLSYG5uhg0bNqCiogLR0TE4evQYtLQ0UVRURNttI6u0ePz48cjJ+QQTkxFQVVWlbo7JNMDUVOmuLUA6Ir5Pnz7UzduyZctQVVUFFxcXjB07Fs7OztRaymKkyIj4Dh06UKze69evERMTgydPnmDw4MEoLi6WkpHm5xfQbk7cv/8Ao0aNQnBwMEpLS8Hn83HoUBJ0dHRQWFggFsEu6ssClClpX9NzdcGCBfj8+TMVd99cuUxZWRmYTKbMXXlZuHv3rtyI+M6dO1N/2w8fPsS6deuQnp6OcePGobS0VGYaYFO0RP7Y2NgoxUgxGAw4OzvD2dkZNTU1iIiIwNixY6GhoQE/Pz9MnToVKSkpCgdybNy4scUR8eJpgLdv36YS5saOHYvAwECpTqb37983q7RYHIpExDMYDHC5XBAEgVevXuH9+/cYM2YMNDU1sXbtWrnPTZYW/6sj4vv06YMjR44AEIVFcblcPHnyBJMnT6ZNgpWFpqXFzQFdRHzTNMCwsDDs3bsXOjo6WL9+PczNzXHw4EGcP39eoef6n0TEDx48GCdPngQgCnFwcnJCTU0NZsyYgVWrVknVP9AxUs15feJJpvLQunVrrF69Grq6ukhLS8P169exfft26OvrIzAwUG6S37dv3yAQCJr9+UDiZxHxI0aMoLq9jh8/ThW4k71lv/B/B/+1Q9bnz5+xb58oovXatWuUXKZvXyOZHqn4+ASsWOEr8T0dHR34+/vj9es38PX1oWSA/fv3h4eHJ9LT06S6tkicOXOGujFQUVGBm5sb3Nzc8OlTLthsFyxf7oNOnTrCw8ODGkBEXVv0jBQ5SDGZTFhbW6Ourg6HDiWBxWIhLy8P9+7dk9rRkldaXFZWjkOHDlEyQHJwMzY2lstINZVg6uvrISgoCGw2G1wuF7t27UZ5eRmGDBkCd3d3pKenS3VtkTh9+jRVWizu3/r48SNcXd3g6+uLLl06w9PTk9Jay2OkyEGKTKOrqalBfHw8nJyckJeXhydPnlAyQPE1aspIia9RSkoKhEIhzp37/TtjSWDYsGEy2Ra60uKuXQ0QHr4RLJYLWCxnbNmyBVVVVTAxMYWbmyvS0+/KZKTES4vV1dWxfLmomPj9+/dwd3fHihUr0b17N3h4eFAt8uJdW01x+/YtipFauHABqqqqERcXS63RixcZEv4tQMRIkcmGTVFeXo6jR49CIBBQ/i0GgwFTU1N06EB/8aIrLTY0NERExBawWC6wtbWl/FujR48Gi8XC3bt3ZRapipcWt2/fHqtXi6KMs7Ky4OHhAT+/VZQMkByqxLu2moKMiFdRUYGjoyPl3zp0KAn5+Xl49+6d1LAXGxuDefPm0T5eZWUljh07hsbGRhw5cuQ7S94aFhYW0NaW7ZFqGhFvZGSE7du3g8VywaxZs7B+/QbU19dh3LhxcHR0xP3796W6tkikpBwGj8cDQPq3RJK4jIwMeHt7Y82aNWIbUiLJ4N69ezFt2jTaxyNLi1VVVaXkMl26dEFwcLAUW9/c0mJxZGZmKsRIjRw5EufOncPIkSOxcOFCzJs3j6o48Pb2litbamlEvLzSYjU1NYSEhCAkJAQ5OTkICgrC+vXr8fHjR3z69Ekhmdft27cVjoymKy0eN24cxo0bB6FQiPj4eMq/5ejoCC6Xixs3bihcWtzSiPikpCRcunSJGpjI6hJ/f3/07t0bYWFhUo/Z3NJicWRnZyvESJE+6VGjRmHcuHGYOnUqlJSUpNIA6SCrtFge4uPj5faeaWtrU76rzMxMBAcHY/ny5cjJyUFlZaVCxcVXr15VWP4YHBwsFRFP+qQFAgH27NmDyZMnQ1lZGZ6enrC1tcXdu3cVPh+EQqHMDUd5iIuLw7lz5yh57rNnzxASEoIvX75g2LBhCAkJkdq0i4iIUDgiPjc3V6GIeFtbW9ja2mLNmjUK+b5+4T8D/5VD1pcvX6Cvr099bWlpCUtLSzQ0NMDW1hZqam3h4eGJRYtsKU03eYGgo6gvXryIIUMGo3///mL+ravw91+LV69ew8FhsVRPDdm1RUfHX7hwHhwOB3Z2dsjIyMC+fftQWloKY2Nj/P3330hMTJQ6pqCggPKRkVBRUYG7Owefv3zGbFs7/HnjNvbHJkFDQwMLbRdiwJABeJP9AUFB0jeS4qXFpAxw+vTpqKurg63tIrRtq4YlS5Zg8eLFlHRGxEjRG41FgRwDqRh3oVCICxcuYOXKlcjKygKLxZIqTiZ9ZHSlxdeuXQOb7QJHR0c8ffoMO3bsQHl5BYYNG4rHjx/T+kCKioqkAjnU1NQo/f+8efPw559/Yt++/TAw6AJPTy907WqArKwsia4tEi9fvqQi4hkMBmxs5sLGRjS42dvbQ01NDd7e3mCxWBL6dFkXCDKQQ1wGeObMGSxbtgzv3r2Dm5ubVOGtLEYKAG7dug1nZ2ewWCzcv38fmzZtRnV1FUaOHIkHDx7QttA3ZaQAQENDHb6+vti8eQtmzpyJEyeOS/i39PX1ZTJS4hHxTCaT6juqqqqCg4MD1XUk7t8if1eySouNjPpKyABPnDgJLy8vvH//Hp6enlJrRDJSdMEg9+/fh6OjI1xdXXHnzh0EBQXh27dvGDNmDNLS0hEdLR06QFdarKWlidWrV2Pr1q2wtJyMhIQEFBQUok+f3vDw8ETHjjp48SKDVhYjHhEvznCUlZXB2dkZampq8PPzA4fDkWBRxLu2xEGWFovLAFNSUsDlcvHhwwd4e3tLHSMQCFBT8422tPj58+dYvHgx3N3dcfXqNQQEBKCoiICZ2SKcOXMGN27ckDqmtLRUqrRYXC7z6NEjKbmMjo4O7t271+wdahKKeqQA0Wf2gAEDJPxbW7duxdixY9G2bVusWLECM2bMkDhGIBC0KCI+JSWl2fLHbt26ISEhgeoVW7lyJUpKSjBmzBgEBgbKDRSQV1osD+/fv5d5805GiLu5uVH+rdGjRyMrK0vhIIV/VUR8r169cPjwYQAi+aGXlxfKysowefJkrFu3Durq6rh586bCpcWBgYFYs2aNQsfcvHkTvXv3lvBvkf1bHTp0wLp166R82s0tLW4KRSLi+/fvj+PHj2PDhg0oKiqi/HfTpk3DmjVraMvESTQnkIMO8iLimUwm/Pz84Ofnh+LiYoSEhGDXrl14//69wl675OTkFkXECwQCib+foUOHUjLAU6dOUZ8Ds2fPxsqVK9G6dWtcvny5RYEcikbE5+TkKPy58gv/GfivHLKuXbuGWbNmS32/VatWaNeuPRITEygZYGLiIXTsqAMjIyMMHTqE5tGAs2fPSpUWW1lZwcJiLLy8RIli7u7uUFVVhZ2dHSZMmEDbtUWC9EgBIhngrl27IBQKcfz4cVy8eBFcLpeSAZIDgyxGqq6xEW9yC+A0uzem6PVA4v4DGNjNEI+i4nCuugoNKky8+vwFRp31qdJTADJLi5WVlaGp2R6JiYnIz88Hn89HTEws9PT00K9fP5mMVNNADgaDgZkzZ8LKygpcrgdqa+vA4XDQtm1bODo6wtzcnLZri4S4tI/0b5E9Nbm5ufDw8IC1tTXmz59PXSzEu7aagiwtJjuUnjx5gm3btqKgoBC1td9QXV0tJT2RVVqspqYGTU1NJCYmIjdXJAPcu3cfDAwMMGjQwJ8kG/7YhWYwGJg/fz5mz54NNzc3lJWVUTJAFosFExMT2q4tEiQjBYhkgGZmZt+TxQ4hJycHnp5emD17FmbNmkWtkXjXVlOQgxSZDnnv3j1s3LgRJSUlqK2tpS0Fjo6mLy3W0NCAlpY2EhMTkJ2dDT6fj127dsPQsAcGDRokJ9lQsrSYyWTC3t4OCxbMB5vNxufPn78Hb4j8W4MHD5bLSF2/fp1Kbxs7diwlb4uPT8DHjx+wbNkyzJs3j+qsASS7tpoiIyMD8fHx1L+9desWgoICUVFRQUlPmnqToqOjaddIS0sL2todkJiYQMkAi4qKYWTUF4MGDZbDSEmWFisrK4PFYsHBwQEslgvevHkDFosFHZ2O4HLdYWRkhOPHj8PCgv7G5dq1a9SNkJWVJaysLNHQwACPdxKZmZmYPn06vL29JVi6sLAwuYyUiYkJzp49C6FQiBMnTmDhwoWoqKigvCCK3OB9/PhR4ZuunTt3SmwyqKqqIigoCEFBQcjNzQWPx0NYWBi6du0KHo8HY2PjnzJSdCADORSVP965cwd3794Fg8GAUChEUlIS5syZQxWvk4mq4mhOaXFTXL16tdmMAOnfCgsLw/Dhw6nzomfPnggLC/tpih/JSCmC8PBwsFgsmT8nNxKEQiFiYmJgbW2N+vp6Si6oCN6+favwENi0tFhTU5NSp7x+/Ro8Hg9+fn7o168fQkND0a1btxaVFldXV0MoFCrERgGiv13yPCL9W5aWlpR/y97envY8+llpcVOkpaU1m5HS0dFBZGQkhEIhhg4diqNHj2L79u0YMmQIQkNDZXrbSZCMlCKIiIiQee0HgPnz51OJpLt27cL48ePBYDDw9evXFpUWy2L3ZeH48eNwdnZW6Jhf+M/Af92QRRAEKioqaNmRCxcuUNI+HR0d6oKVmfkK3t5Loa+vjy1btsDDw5M6nmSkZJUWW1tbw87ODm5ubigqKgKfz0d8fAJycj7S+jbEkw3FwWAw8OrVK4SFhcHU1BRJSUmUf8ve3h7v32cjOFjSjN0gFOLS9TSovvmAzzfvwNBiDMpKimE5eTIsJ0/G9u07YNXPCFHrQvCFKYT1GHM4OzuDwWDILGMUj4jX09Oj/Ft///03Vq5cCT09fezYsQNcLpdak6bJhuJISkqClZUlHB0d4eXliby8fERFRSEqio9Pn3J+mmzYdI2ysz+Ax+Nh5MhRSEiIp/xbzs5OePs2iwoKEQddRPzw4cMxfPhwrFixAv369fvu3wKmT58GGxsbMBgMFBeX0O5GipcWGxgYUEPBo0ePsGbNGujrd0Zk5F64ublSN18iRqoeWlpaUo+XnHwYkydPpm42cnJywOfzERkZidzcXBw8eFDqmJKSEtrSYgaDgfz8PAQGBmLkyJGIi4sDm+2K9u3bgc1m49Wr17SsAF1psbm5OczNzeHn54cePQwpGeDs2XMwY8b072tURDtUXr9+Hf36iW7uDA0NqeEyPT0dGzZsQOfOncHn8+HszKIGt4aGBrmlxZMnT6b8KKR/a8eOncjNzUViYoLUMWVl5WjdurXU0MNkMlFWVop169bB1HQkYmNjcOTIUWhpacLd3R0ZGS9pb0Kyst5KRXuPHz8e48ePx+rVq9Gpky48PT2hrKyMBQsWULu+shgpUWmx6G+QlAECIjZPVAbaBfHxCXB0dKB+z02TDcVx/PhxTJgwnpIYZma+QnR0DIqLi/H5cy6SkpKljqmoqECrVq2kAjmUlYWoqanAvn37MHnyZAkZII/HazYjxWAwKHZz4cKF0NbWxtixY6Gmpobly5djzpw5co8nGSlFIBAIUFVVJXPn2MDAgPrcefDgAfz9/VFYWIiPHz/i8ePHCj2XeGlxc9E0Ip7BYIDFYoHFYqGmpgZbtmzBmDFj0K5dO6xatYo6j1oSyLF9+3Zaj6U8REdHY8aMGRRTdPPmTXh7e6O0tBQTJkzA+vXrpYYBRQM5SDQ3Ip7BYFAe4EWLFkFJSQmjR4+GlpYWAgIC5MrsyPfQkoh4eaXFRkZGlH/r8uXLcHd3R2VlJT59+qTwebR582aJepjm4MOHDxKMVFP/VkhICCIjI9GxY0ds2LABo0aNAiA6/xSNEd+0aRN2796t0DGia78V9Tlx7tw5Kg1w5syZWL16tdRnc3NLi5viypUrzWKkWrdujbVr12Lt2rVYvHgxysvLYWZmBn19fQQHB0uoLejQkoh4giBQWFgo04LxC//ZUBJ1aP17wMRkEPHoUcL/6nPcu3cfDx8+gI+Pj9TP3N3dsXPnTqmB6du3WixdugQHDx7E1atXcfLkSdTX12PixImorq6GtrY27S6Ji4sL5f8RR15ePlavXoVOnTqhpKQExsbGcHfnQktLEzweD1ZWVrQ7syyWi9TNYmFhITZu3IiMjAyMGDECHh4e1Id+Tmk5Yleuh9O0aXj44D6ePn2Gb7W1WL7MG3369KF8AI0EAR/+AXQz7o2Mp09RU/MVXbp0of3Q5HK52LZtm9TAVFdXBy8vL8TGxuLixYs4e/YsGhsbMWXKFFRUVEBdXZ32IsFmsxETEyO1RkVFRfD19YWOjg7KyyswdOgQcDgcaGhoICwsDOPGjaPdDaRbo7y8PISHhyMzMxOjRo2S8G8BwMqVK7FkyRKpi6xQKASbzabkmTU1NTh48CD++usR6upqoa+vTyuZ8fDwoJINxdHQ0AAul4u4uDicPXsWFy5cAEEAM2fOoAz/dLtZLi4uiImJkRqYiouL4e3tDR0dHVRVVWPkSFOw2Wyoqalh06ZNMDMzo92ZpVujDx8+ICIiAq9fv8bYsWMpGSAJP79VFOsh7/GqqqoQGxuLZ8/+hkDQ8D0qXPpm28PDk0o2bLpG7u7uiI2NxcmTJ3HlyhW0atUKc+bMQUlJCfU7aQo2m035yMRRVlYODw8udHR0UFNTQ/m3VFRUsGXLFowYMYL2hoLFYkkwUoBop3vbtu148+Y1Jk2aDE9PD4lhZvXq1XBxcaEdmMTXqKysHDEx0cjIeAmCEKJjx460a+Tl5YXQ0FCpgUkgEIDD4SAmJgYpKSm4efMmWrdWwcKFC5Cfn49v375JebUAwNXVlfKRiaO8vBxubhzo6Oigvr4OEyZMoOoptm3bjoEDjWl3ZqdM8cClSw8l1ujRo0fUAHrz5k2pY+TBzMwM9+/fByCSdPN4PKr+Ijg4GIMGSff/TZkyBQcPHpQK3pCHyMhIlJSUUP6z5qCsrAyjRo1C586dKVn50qVLf7rLbWZmRjEJzYW9vT2WLl3604Hp48ePCA4OxqtXr6CqqgotLS2FUtCEQiFGjx5NrXlzYWFhIeGREn+8gwcP4tChQyAIAk5OTuBwOGAwGFizZg2MjIwUGjjfvXsHb29vhRMCxc+jrKwsBAcH4/379+jbty9CQ0NpJf/Tpk3Dvn37FAqjiI2NRVZWFlUX0RxUVFRg6NCh6NKlC1q1agVXV9ef+rcAYNSoUbh3755C55GzszOcnJx+OjBlZGSAx+Ph06dP6NChA5SVlalQhuagpefRuHHj8Pvvv0sNTGQa4JkzZ6CiogIvLy8qqS8oKAidOnWilTzLQk5ODtzc3BROLBU/j548eYLQ0FCJegq6oWjWrFmIiIhQaOPn8ePHePfunVQa4S/8Z0FJSekxQRAmTb//X8dkPX78CF+/fgWL5QIdHR3qxvHbt1oIhUJaRiohIYFKv7GysoKVlRUaGhqQnJyMY8eOo18/I+jq6koU0ubl5aNt27YyS4u9vLwwZswYCIVCXLt2Df7+a1FfX4/CwiJa/4+otFiaRu/UqRMYDAZiY2NRXf0VkZGRIv/WoMEYP3EKiOIi9OndC31690J29gewbeZi9+7daNOmDRiMVigqLoGWpibUSsuxyMkZ3X19qIQ8FosFPT09eHh4oGfPnnIZKbK0mMFgYMaMGZgxYwa+fatFYmICjhw5gv79+6NHjx4SwyOdR4pEVFQUPDw8KPP1+fMi/1ZjYyMKCgppU/tklRbr64sSIfl8PiorK7F9+3ZUVFRi+PBhcHV1k5lseO3aNYkPS9JjBYhu6lVUVMBiucDAwACenp7o2tUAdXV13xkpTanHI0uLyRj3efPmoaamBnFxB3Hy5AkMHDgIAwYMgInJj7/T4uJiqKioyiwt9vDwoOKOT506jWXLlkNJSeTRo+uRomOkAFEaoJpaWxw4cAClpaXYuDEc1dXVMDMbBRcXtkwfWWpqKsVIASIZ4IoVKwCIhkNANLD06NEDnp5e0NfXk+sjS0lJwfjx46kYdzs7O1RUVCA2Nha///47hgwZghEjRkgEJoh8ZK1lRMRHwd3dHVZWVhAIBDh+/Di8vLzQqlUrFBYW0nowsrKyaMtme/fujXbtNLBv3z4UFRVR/i0LCws4OTmhsLCIdsBqWlqspaVJPS+L5QKBQJTg2adPb3h6ekJHR0cuI0VGxJMyQBaL9T0NMBqXLl3CsGFDkZn5SoJBrKiokFlaHBMTAw7HDdOmTfv+ufajnqKgIF9m15aBgbRvw8TEBB07dlRYbtSUkercuTPFsPz111/YsGED8vPzMXLkSPB4PHTo0IFipBQZsACR5FTR1L6wsDCsX78eLBYL3759k/BvrVy5EtOnT5c6pjmlxXRoLiPVvXt3JCQkABDdhLdq1QpmZmYy0wCbIioqSuEI8crKSjAYDFpGisFggMPhgMPhoLq6muqW0tTUxIcPH/Dy5UuFniswMFDhiPimpcV9+vRBSkoKANHnuYeHByoqKjB58mQEBARAXV2dYqQUTfs7dOhQsz1SJCIiIuDv7w8PDw+Ul5cjLCxMrn8LUDyQg8SbN2+axUgZGxvjxIkTAER/v6qqqjA3N2+Wfwv4n0XE0zFSZBrg6tWrUVxcjODgYOzcuRN6enp4+/Ytnj17ptBztUT+eO/ePYk00OHDh1OD58mTJ2FnZ4fa2lrMnTsXvr6+aN26NYRCoUwvsTz88ccfCp/nv/Cfg/+qIauhQQAlJSUJGSAplxEIGmBpSf+B9ODBfSnZmrKyMqytp+Gvv/5CaGgooqOjkZCQiE6dOoLL5SI5+bDMBvjs7Gzqw5TBYFApRY8fP8bmzZupUmA7OzuKrYmLOwhfX2n2jbxAkHro3btFoRInLlzEwdBwKBcX4+KlS7CcPBlFRUWIjolBmzZt0EatLWbOnIHY2Bjk5+dDS7sDinML0VGtDZSUlCiJ2/Pnz7Fnz28oLy8DAJn+H7rS4jZtVDFv3jz8/fffCAoKBp8fhejoGOjp6cHT0xPJyUkykw3fvn1HRcQzGAzMmjUTs2bNxNOnTxEaGkrJAJ2cHGFmZvZ9jaSTDck1Ki0tpS6+w4cPh1AoxJ9//glnZyd8/foVJ06cxPz58yQuZPJKiwFQErdHjx5h69YIVFZWoVUrhswLDl1psZqaGuzt7ZCR8QL+/v6IiopCZORedO1qAC8vLyQmJspMNhQvLRaVAi/AwoUL8OTJE/B4PLi6uqJdu3Zgs12pNMDo6BipZEMS4oOUubn598HtFBwcFqO6uhp//PEHZsyYIbFGZNdWUzQ0NEBJSYliaNLT07FxYxiqq79CVVVVpoeGLiK+ffv2cHV1xZs3WVixYsV3GeAOGBoawsvLCwcPxmPhQnofmXhpMZPJxOLFi7F48WI8efLke+KlK7S0NMHhcCg/YdOuLXEUFv64iI4fPx4CgQBHjx6FnZ0dvn79iitXrlCbDSTIrq2mEAgEUFIC9uzZTb33wMBA1NbWom3btjILMK9fvy4Vg62trQ1PT09kZ7+Hl5cX9bnWr58RPDw8EBcXJzPZUBQRLwrkEK+nePz4MQIDA8Fmu6JjRx14eHhQ8tjo6Gj4+tKzEp8+faKkR82FvNJiU1NTnDt3DkKhEMeOHcP8+fPR0NAAbW1thWVNZWVlLfJIiUfEt2nTBsHBwQgODsanT58QHBxM+W1CQkIoqXBwcLDCHqnLly/LTBGVBaFQCCUlJaSmplL+LTINcPHixfD09KS9QU9JSVHYI7Vx40a5HikS6urqlMwvNTUVDg4OGD16tMw0QDrQlRb/DNu2bZMZpEAGXAmFQvD5fFhbW0NJSQndu3dX+HnI0mJFPVLipcWamprU52NmZiZCQkKk/FuAaEhQNJCjpRHxTCYTaWlpEAgE2Lt3LywtLaGsrAwul4tFixbRnkfx8fEKD5tbtmxpVkS8jo4O9u3bB0AUi+7k5AQLCwsMHToUPB7vp/4toGUR8eHh4TIrIRYsWIAFCxagvr4eO3fupOopBgwYQFv9Iw8CgQANDQ1o06aNQsf9wn8O/quGrHv37krcuPTv3w87doj+kObNm4f79+/h9u1bEnIZeYxUVFQUnJycJPxbL1++RFRUFB49egw1tTbo16+/BKvx7NkzCRmWOA4dSsK2bdtgaGiIoqIiREXxcfBgPDp21EFBQT7thYmutJjBYGDchIn4O/k0Vm/0xc2bN7Bq1WpACVBVUYGzszMSEhJhbmYGczMzhISEwGTECPB370ZeeT7sFvwohx08eDCVBmhjMw/p6em4c+cOpkyZggULFoDJZMr0SJFrtHjxYujr61HynKdPn2H37l149uwZ2rZti6FDh0owiLIYKUCk4962bRt69+6NvLw8REXxceDAAejr6yM/P59WH3/16lUphkHkHZqN8+fPg8fj4fTp09TgxmI5Y8iQIXIZqUmTfuwAm5iYwMTE5Psa2SA9/S7u3r2L6dOnY+7cud+9ScW0Hilyjezs7KgYd0C0e79lyxY8f/4c7dq1w6hRoyRuDMmuLTocPnwY27Ztg5GREeXfItMA8/K+0DJSdKXFosFtIa5dS8Xu3btx6tSp76ES7cFms2FsbCyTkTp8+LBEafGYMWMwZswYCAQCzJsnOo8ePHiAOXPmYPp0kX9LPiPFx8KFC6gYd0Bktg4JCUFGRgY6dNBGXV2dBFNDdm3R4ciRI9i2bTv69++Hd+/egc/no6CgEL1790JeXh7tbqSotFiS8WQymXB0dERaWhpWrVqFM2fO4PDhFHTooA0Oh4O+ffuirq6OlpFqGsgxYcIETJgwAQ0NDbCxsUF1dTUeP34s4d+iSzYkERMTjXnz5sHIyIj6XEtNTUVAwDq8eiWKOW+acirq2qKPiD9+/DgiIrZi0KCByMx8hago/vfBrR9ycz9j8GAjkH1ZJM6fP98ijxRd11ZTMBgMiTTAvn37oqioCHfv3sXy5csxe7Z0mFFT0JUW/wzyIuK7du1KeSLv3r2L1atXo7CwEGPGjMHbt29bFMihqEcqKiqKOj+a+rc2b95M698qLy9vsUdK0Yj4uLg4HD16FBMmTMCNGzewZMkSlJWVYeLEiVi/fj3ta0hNTVU4oru5EfEMBgNeXl7w8vJCRUUFBgwYgM6dO2PatGnN8m8B//qI+P79++Po0aMARKyum5sbqqqqYG1tjczMTIUZx5ZGxJOfR0wmE76+vvD19UVJSQlCQ0OxZ88edOzYEUFBQVRaLslIKTpsXr16Fenp6Qodc+zYMSQnJ2Pq1Kk4c+YM5d+aPXs2/Pz8aMvO09LSflpa3BRkRPzPNjtat24Nf39/+Pv7Iz8/H8OGDYOBgQHmzZsHHo8ndV9GhytXrigcpvML/1n4rxqy/v77b1qmIy8vD/r6+ti3b5+UXEbkf6C/KH/4kC21czFgwAA4OTmhdevWGDZsGPz916KhoQETJ06Cvb0d4uMT4OvrK/VYTS8QHTt2pEIaoqKi8OrVK7BYLhg40BhcLpeS7Il3bYmjob4ejY2N0NLShI2NDZ4/fw4PD0+cPHkSBw5EQV1dHZ9yc6GtpQVGq1aYMWM6eqowsWn7ZtpeiKKiInTurI8DBw7g27daHDqUCA6HAzU1NRAEgcWL6U25ZKeJOIYNG4rWrblITExEnz59KRng1KlTsWDBArmMlLi0T19fHyEhPADAgQMH8M8//4DFYmHYsGHgcDjUxfvUqVNU15Y4yNJifX196vm+fPmCqKgoBAcHo1279vj0KRddu0re/MkqLS4tLYW+vj6ioqIoGSApvVRSUpLJSJHJhuIwNTVF27ZtERd3EJ07d6ZkgDNmzMRf0XhvAAEAAElEQVScObNpu7ZIiDNS3bp1owzq+/btw8OHD7+XAotkgGSohHjXljhEYRO16NatGyUD/PDhA6Kjo/Hs2TNoamoiLy8f+vqSO4q3bt2ivVmsrKyEvn5n8PlRqKqqQkxMDE6cOAFNTS0wGErNYqRIWFhYoGPHjuDz+VBXV6dkgPPmzcPUqVNlpvYBIkaKlNP16tULW7eKzo/IyEgUF5fAxcUFY8aMgbOzMzXQiHdtSa6RKCK+d+/eWL16NQDR8BIdLfJdtW/fDkVFRVKDFtm11RTV1V8puVxZWRn4fD6Skw9DR6cDmEymTEYqIyNDShYzefJkdO/eHZGRkVS5a+vWKrC1XYjJkyfLXaP8/AIMGiRi98Q3pHbv3o3i4iK4urpi2LB58PAIoG5wdu3aRUnYmot9+/bB2tpaoWNqampgaGiIW7du4cuXLwgKCkJ4eDi6du2KkJAQWtkmIBqEFI2IDwkJaVZE/OjRo/Hnn39CKBRi1apV+PTpE8aMGQM7OzuqsFoehEIhKisrJWRKzYGs0mI1NTWEhYUhLCwMHz9+RFBQEAIDA2FoaAgVFZUWlRa3RP4ozkhNnDiRkjfHxsZi+vTpUv4tQLHSYhIxMTESkv3moFWrVujZsyfu3LmDrKwsijUyMjJCaGiozN/Fz0qL6RAYGEh9PsjDtGnTMG3aNAgEAvj4+CAnJwfjx4+Hm5sbHB0df7r+LY2IT0hIoC0t7tChAzWwvXjxAjweD7m5uRg4cCDU1NRaXFqs6HmUmZlJMVI2NjawsbGh/FsTJ06EiooKlixZggVim8RbtmxR+O89OTlZpopAFtq1a4eePXsiPT0djx8/pq2noMPt27exaZP0dfcX/u/gv2bIqqqqgrq6Ou0fNp/Pp6R94nKZ4uJi2NvbIyqKj1OnTknIZZ4+fYbOnTvTPhdZWtyjRw9MmTIFdXV1SE5OBofDwYcPH/Dx4wcYGvaQOEY82bApHj9+jJSUFKirq+PKlStYs2YNGhoaMH78eDQ0NNB6pI6lHMaX2hqcOnVK5ANq1Qp6errw9l6KYB4Pi+3tcezoMXz+nAtdXT2UVFWhpLE11NVke6TIQapNG1UqySkvLx9OTo6IjY3F+fN/wsPDk3pvoq4tejo/NjYW3t7e6NWrF2bNmolv32qRkJAAV1c35OR8RGFhoRQrdeXKFZkR8c+ePUNKSgo0NDTwxx9/fE8DJGBpafkTRkoyGKJz584IDQ0Fi+UCb++l2LZtKyoqKjB8+HC4ubmhtrZWro+MDEBRU1PDsmUi/9bnz5/h7MxCZWUirl1LpfxbgGTXVlPExcXBw8MDffv2xbx581BdXY2DBw+CzXZFTs5HfP0qfXETTzZsiufPn+Pw4cPQ1NTEqVOn4e3t/X1wm4G6ulpaRio5+bDUjUuPHj2wadMmsNlsuLq6UjJAMzMzuLi44Nu3GjmM1I/SYg0NDapPJDs7GxwOB6WlZUhLS4OXlxfV2STLRwaIbqzc3bno378fFi9ejIqKCkRHx+Do0WPIyflIK20iu7bo8OJFBg4fToampiaOHTtGDW42NjYyu7aOHj0iJRHt3bs3tm7dCldXVyxevJjyb40dOxaOjo6oqfkml5EibxS0tLSo4TIrKwuenp7Iz8/H48ePweVyqdcjj5GKjo4Gl8uFsbGxmH+Lj0OHkvDpUw4ts0N2bdHh9evXSEpKgpaWFqKjT1NymSVLluDr168Ke6TI0mJFEBYWRoV7dO7cWSINcN26dcjPz8eoUaPA4/Go8zozMxMdO3ZU+Obuw4cPCjFSDAYDL168wF9//QUdHR1ERERg7NixUFdXx8qVK2XGO4szUs1FeXk5GAzGT+WP3bt3pwJ87ty5gzlz5iAzMxOZmZnN8m8BItmaon1ksiLiyYGfy+VK+Le0tLSwevXqFpUWJycnKxySIc5I9enTh0oDvHLlCtzd3VFRUYEpU6YgICCAWuOWeqSysrIUYqSYTCays7ORnp4OHR0dhIaGYv/+/dDR0cH69etlStNaGhHfHPnjwIEDcfLkSQAiLxGLxYKRkRFKS0uxatWqn/q3APrS4p9BVkS8uH+rsLAQPB4P27dvh76+PjZs2PA/Ki1WBFu3bqWu/SNGjKD8W8ePH4etrS1qa2sxb948+Pj4UNfFiooKaGhoKHwe/cJ/Fv5rhqxjx46hsrJSSi4DANnZH2g/sD59yoWpqSk2bdokIZfp378fPnz4QBssQFdarKKiAjc3N3TqpItnz54iLS0NCQkJ6NSpE7hcLnr37o1z585JdW0BPyLiyQ8/a2trWFtbo66uDt7e3igpKYGXlxcWL14scaP34tFfWLVtC3LP/IHAoCC0UW2DO3fuoF//AVBVUYGRkRGMjIwgFApx7949bIuOxsOqIkwwHSFVCgyICivJuHZxFBcXY8SIEYiIiMCzZ8+we/dulJeXYciQIXj37j1WrlxBu0alpZKlxW3aqMLLyxM9evTA/fv3cOnSJURFRaFz587w8PBAjx49cPr0aYmuLRIkI0UOm3PmzMGcOXNQU1ODZcuWo6ioGEuXesPZ2UnCKyKLkRLJH1VhamoKU1NTCIVCnDv3O3x8fJGT8xETJkyg7fKhY6QAfB/ShmHbtm3466+/EBGxBVVV1TAxMUFW1hvaPjKCIFBcXIy+fX8MA+rq6li+fDmuXr2KGzdu4NSpU9iz5zd0794NHh4e6NKli1TXFgkyIp684ST9W1VVVfDx8UFRURGWL18u4d8CgFu3biImJkbq8cjSYvFuqVOnTsHbeylyc3NlrpGs0uL6+noMHToUO3bsQFpaGkJDQ/H161eMHj0amZmZ4HI9pI4BgKKiYomAh/bt22P16lW4ceMGLly4gOTkZOTn56Nnz57w9PSErq6uVNeW+BrV1f0YpBwcHODg4ICysnKsXLkChYWF8PX1hbu7uwRTcv36ddo6BlLaJ152fvToMXh6euLLlzxYWtLfcMmKiFdSUsKQIUOwc+dOXL9+HevXb0BdXS3Gjx+PFy8yaBMFAemIeG1tbQQEBODWrVs4c+aMmH+rHzw8uNDW1pbq2iJBBnKQyVpLlzpj6dKtyM/Px9y5c5Gbm6uQXKa0tBRMJrNZN2fikBURP2rUKAn/1rx589DQ0ICFCxciLS2NNjBHHi5evChz00IWmpYWkymuOTk5CAoKQkhICLp3746QkBAJSZIsRkoewsLCFGakdHV1YWZmhj///BMJCQmUf8vBwQEeHh4yb/qys7MVDjjYvn077d+GOMT9W2TKWl5eHhwdHZvt32ppRLys0mLSJy0UCql+NAaDAVdXV1y9erXFpcWKoCkjRSbZZmZmIjg4GCtWrMCAAQMQGhoqsbGhSGkxiZZExA8ePBimpqY4f/48fvvtN0yePBnKyspUjL6s80heabG810d3fySOTp06UX68Z8+egc1mIy8vD15eXggJCWlWRDpdaXFzIKu02NbWlhqyduzYgXHjxlH1FCUlJRKs2y/838R/zZBVVVWFDh06SMllnj59hi5d6BmphIR4SiIlLpe5evUqLl26hNDQUEyYMAH29vbU4Hb+/AWZpcXnzp3Frl27KP9RRkYG9u/fj8LCQhQVFUEgaJQ65tChRFrNroqKChoaGnDmzBlqZzo2Ng66up2wYMECtFVTg56BLjSsJuNBejrWrF6Ds2fP4ujRoxI71wwGA8PNzaE1ZTJyN4dAT0+PkgE6ODhgzJgxMpMNAcnS4qFDh1L+rfPnL+Dcud+xadMmTJkyBfPnz6cGt8uXr1BdW01x5sxpiYj4p0+fYdeuXSgvL0d+fj4YjFZSx8gqLVZTU0NjowDnzp1FUVERDhw4gP3796NLly6wtbWV4yPjU4W75BrZ2MyFjc1cODk5oX379mCzXaGhIUpgNDU1lesji42NhZeXFwBIDG5nz579PhRFYMaMH/4tQD4jRR5DsnMPHz7E5s2bUVlZiaKiIlp2JDk5mdbcraGhAYIgcPbsWXz58kXCv7Vo0SKZyYZNS4uZTCbVd+To6AhVVVW4urqifXtNsNkuGDp0qFxGSlRaLBoSLCwsYGFhAYFAgJMnT+LJk6fYtWsn5s6dC2tra2qNrl+/LpORIgcp8vnu3LkDHo+HmppvKCoqpE0RPXJEmpECRGmASkpKOHfuHD5+/Ijo6Ojv/q3esLOzk8tIiZcWKysrw8nJEU5OjnB0dIRQKPyectoBbm5uGDBgwPeuLW2ZjBT5tztp0iRMmjQJDQ0NSElJwaNHj1BdXYWFCxfC0tKSOqZpsmHT9xsWFkbJGK9du4aAgHWoq6tFUVEx7Y3G8ePHm7A6dQBEUf2tWrXC27dv8eLFi2bLZUJCQmQOh7KQkZEh0yNFoql/a+vWrbh27RoqKiqwYsUK2jRAOuzcuZO2h04eoqKiaOWP3bp1o6SUpIevqKgIFhYWWL58eYsCOdLS0mg3nuSBLC0mhwZXV1dUV1dj8+bNGD16NNq3b481a9ZIsC6KlBaTEAqFqKioUIiR6tWrF9TU1PDmzRs8fPiQ8m9NmjQJ69atkzlEhYeHK1zm+u7du58yUgwGA0uWLMGSJUtQXl6O8PBwnD9/HuXl5VBRUWk2w9m0tLg5kMVI9e/fH8ePHwcgUsCw2WxUV1fD2toaS5cubVEgR2pqKhXI0VyQqX1MJhMrV67EypUrUVxcjJCQEOzevRt6enrYsGED5d8CFCstJkHaBBQ5/4YOHYp27drhxo0bSE1NpdIAZ8+ejZUrV9L6twCRvFBeaTEdcnJyoK6uLlcOrKqqivXr12P9+vXIz89HUFAQMjIy4OrqqtBz/cJ/Hv4rhqwvX77AwMAACxcuBIvFQklJCaKjo3Ho0CF8/vyZdndTxEhV0Joma2vrMGfOHHh7eyM5OZka3OzsFuH332UzUk0j4o2NjbFz505ERUXhy5cvlH9r0qRJsLOzA5PJxL1792jZFvHS4k6dOlFJfP/88wKrV6+CmpoaEg8cwGDzMajX14NqWzU4OjogK+sNhg8fTj1OdWMjctqqoqymHF309CgJR0FBAaKiRGmAeXlfaBkaWWWMDAYDTGYrzJw5E97e3khISACHw0Hbtm3h6OhIDVJNQRcRP2zYUAwbtgcxMTF4+/YdVqwQyQCtra0xf/58MBgMpKen07It4hHx+vr61M78kydP4O/vD1VVVezZswdubm4SF++3b9/KLC3W19enYtxzc3MRFRWFvXv3Ij+/QOYaFRcXS+njGQwGNDQ0MGPGdCxdupSSAbZrpwEWiyUz2fBHabEm9b2RI0di5MiROHjwIDIyMij/1syZMzF79mwwGAzcunWLdo1EEfGiQI7u3btT+vB79+5j5cqVUFVVxYEDByT8WwBklhZnZr6Crq4etTmRnZ2N6Oho7Nq1G4WFBTKZBLrSYvLcnjp1CpYuXYrY2FgcO3YcWlqacHNzw7Fjx7Fpk/QudENDg5S0j2TcEhMT8ejRI8ojM2/ePGqX+saNG3IZKWVlZUoGCPwoYVVVVUVsbCycnJwkhi3ZpcVZ6NSpExXb++bNG0RHR6OoqAjFxcUyE+noSouVlZXRo0cPWFpaYunSJeDzo5GUlAQdHR1wOO44evSoTEaqtrZWwidGMm5JSUlIT0+X2pACRIOYtFemCqWloteiqqoKExMTCbmMiYkJdHR0YG9vDx8fH4mbkfv379N2zckDj8dTiJFSVRWx0jY2NggLC6PSALt27QoejyfTv0UGcnTt2lWh13f06NGfMlIWFhaUfyspKQnm5uZo06YN9u7dC09Pz5/6t4B/bUS8uro6wsPDER4ejuzsbAQHB2P9+vXo2bMnQkNDW1RazOfzWxQRTzJS5EYC6d+aNm0alJSU4OzsDFdXV4n33dzSYnEEBQUpFJ2tqamJadOmIS9PVObO4/Hg5+cHIyMjhIWFySyhpVNuNAfNYaSmT5+O6dOnQyAQYN++fRg8eDDatGmD5ORkLF68uFnnRkvlj3SlxTo6OoiMjAQg8m8FBwcjNzcXgwcPRkhICDZv3qxwafGhQ4cUDpARLy2eP38+5s+fj/r6euzevRsTJkyAqqoqli5dKrEJBog2E5pTWiyOoKAgSvbeHOjp6WH9+vUKs42/8J+J/4oh6+rVq5g9ew71dYcOHRAQEAChUAh7e3tKNtGvX39KLiNipIbSPh7JSIn8W2yw2aIeoX379uHNmyyEhoaCy+VK3FgnJCTITJF58OABVchbV1eHpKQkcDgctGol+lpW1xYdvT9o0EDo6uohPv4gLl++jIR9v6FeWQX7H97DQG0dqOnqoqKxEQKCQKmKMhp1tGCg3wn81aslIuJ1dXURHBwMoVCIRYsW4dSp04iLi8PgwYPB5XKhoaGBy5cvy2GkzmDbtm2UDNDLyxN5efnYt28vXr9+gy1btlAyQBJk1xYd0tLSERcnKnYW+bfi4erqitatW6O+vl6mR0qckSIxfPhwao1+/10kAwQITJ8+HUZGRjIZqbi4OCxZsoT62sDAABs3boRQKMTChbY4fvwYYmNjYWIy4ntSYVtcu3ZN5k0cyUi1bduWYgM/fcrFvn178erVa+zYsR1eXl7o0qULdQzZtUWHO3fuUIW81dXViIuLA5vtijZtVNHQIJDZtUUXdGJubgZdXV3Ex8d/lwGK/Ftz5sxF7969ZDITsbEx4HK51NeGhobUzc/8+fNx5MgRxMbGwtzcHM7OLLRpo/q9a4s+yYkcpNq3b0/FjGdnZ+PAgQN49eoVdVNK+reAH11bdCAj4pWVlVFWVo7Y2BgcOXIUGhrqqK9voGWk+PwoWlnHhAkTEB8fj9hYUXqal5cXlJWVMX/+fBga9mwWIwUAffv2pcJrbGxskJSUhJiYGIwfPx6Ojo5QVlbGrVu3pJINSZCMlEgGKJJivn79Gnw+Hy9fvkRsbCw8PDwkPHdk1xYdbty4QZUWFxcXUxtSWlpaaGigW6MqhITspGWkbG1tsXPnTty4cQM7d+7EuHHj0KZNGyxfvhy9e/dukUfq06dPCkclkxHxBgYGiIuLAyD63PX390dhYSFGjx6NwMBAiTU6cOCAwtHP5eXlCjFSZBrggQMHkJqaioiICFhYWKBdu3bw8/OT+/z/WxHxhoaGOHToEIAfGwn379/H/v37sX79+mazJCkpKQp7pOgi4sX9W5WVlRL+LX9/fxgYGMj0I8pDSyLit27div3796Nnz56Uf+vy5ctwd3dHZWUlrKys4O/vL/H7j42N/V+PiGcymfDx8cGRI0fw559/IiwsDJGRkd8DtALlVir8Kz1S4hg4cCBOnToFADh37hwcHR3x+PFjHD9+HH5+fs2WCB88KLpOKwI6Rqp169ZYs2YN1qxZg8LCQgQHB2Pbtm3Q19dHcHAwtLS0fspI0SEzM1Omz1IWTpw40awqhF/4z8f/+SGLIAhUVlbSBh+cP38BZmZm1K771avXEBAQgPr6ehQVFSEpKVnqGFmlxTo6OujUSRdLlnhh0KBBiIqKoorpPDw8abu2AElGChDJAMlCR39/f1RViQpvdXU7wcPDg9oNy86mN2P//fff0NPTA4PBoFKK6urqkHDoEILiD6Bb1+64VpKHkWYjodtWDe1aK39n7cpkRsSbmZnBz88PQqEQly5dgp+fHwQCAYqLiykztThklRbr6+uhe/fuGDBgAPr3H/BdBliBoUOHgMPh0HZtAUBhYSHU1H5I+0SDmyiCNyAgAEpKSmCxXNClS2d4enpSO4riXVviIKV9DAYDc+fOxdy5c1FTU4ODBw9i79696N69Ox4+fIiRI0dSxzRNNhTHtWvXMGrUSKxZs+a7f+scli8XDazFxcWIj5eWG5E+sqbnZdeuBujTpw+MjY1hZGSEzZs3o6qqGqamJnB1daXt2iKfh2SkANHOtI+P6DWsX78e9fX1YLFc0KNHd3h6elI1AuJdW+IQRcR3pGLcFy5ciKqqKsTGxmHnzh3o0aMHnj17JrURIa+02MTEBAEBAZQM0Nt7KRXdzufzpY4hS4s7dJCMYTc0NISxsTH69x+APn16IyQkBDU1NVQa4I0bN+T6yMg10tLSpNK+AgICUFlZCRbLBb1794anpwfF8tAlGwIiRkpHRwfKykxKBlhWVo6YmGhs2bIFhoaGePnypVSkuazS4ps3b2L48BEIDNyAhoYGHDly5Dub1BolJSU4cECaZaNjpADAyMgIw4cPx4ABA2BoaIiAgADU1dVh/PgJcHR0oO3aAkRDgrj8UbyeYt26dSgqKgaL5YL+/fvBw8MDWlpaAKpkMlIZGRno2LEj2rRpQ8ll8vLyEBwcjFOnTsHY2Bj//PMPBg2i36xpigsXLvzLIuJHjRqFP/74A0KhEEeOHKH8W7a2tli6dGmLSotbEhFPMlJt27ZFaGgoQkNDqTTAoKAgGBoaIiQkROrvqrmlxeJQNCJ+woQJePnyJUaMGIGePXtS/i0nJye4u7vLHGxa6pG6ffu23Ij4du3aISJCxPCTybVXrlzB4MGDkZ2d3WwpWtPS4uaA9Fs37Z+aOnUqpk6dCoFAQPm3WrVqBVdXVzg5OSEpKYk2tU8e/icR8To6OlQaYEZGBng8Hj59+kTr3wJETLqszU1Z2LRpk0IR8XPmzEFpaSmGDh0KFRUVyr/l5eUFW1tbKCkp0R4nr7RYHq5cuYK0tDSZP+/UqRP1+ffs2TOEhIQgPT0dw4cPR2FhYbP8W4Co/1FR+SPpt6ar9fiF/3v4Pz9kZWRkyLwok4wUCSsrS1hZWaKqqgp2dnZYuXIFJQMk2YOEhASZu4vkIMVkMrFjxw4IhUJcu3YNPj7L8fFjDo4cOQp7ezuJnZKoqCiZpcV5eflITEyg3se+fftQUlICXV1dmUzCwYPxWLHCV+J7KioqcHdzw920NGwNDwWfz8fvRw9DT08XXC4Xr1+/lmlSF4+IZzAYlDyhsrISixYtwooVKyT8W4BI5iDL2EoOUkwmE8OG7aH8W0uXLkVOTg5Onz6NBQsWSFy8ya4tOnz5kket0ZMnT7B9+3ZUVFSia1cDmR1JTRkpQOTfWrJkCf766y+Eh4cjKioK+/bth4GBATw9PfHyZYZMRkpc2ifyb4niZcvKymFnZ4cVK1ZCQ0MdLi4uMDExAUAyUtI+MkDESMXExEJZmYmRI0dCKBTi9OnT8PDwwKdPn/Dnn+cxZ85sqTVatIheS56b+5lao/v372PjxnBUV1ehZ08R20KHpowUIPJvrVjhi2fPniE4OBh8Ph+7du1Gjx494OnpiYyMFzJ3ycVLi5lMJuzs7GBnZ4fS0lLY2dlh1apVaN9eE25urtS5mJKSItG1JQ5xRor0b504cQIcDgefPn3CtWvXMHXqVIk14vOjsXAhvdH4y5cv1O79rVu3qDTAAQMG0G7QiB6PL3VDraWliTVr1iAj4yX8/f0RHR2NwsIi9OnTG56ennjx4oVMRuro0aNUabGysjKcnZ3h7OyMoqIiLF68GKtW+UFHpyM4HA4lrWzatSUOcpAib2rIegoXFza+fPmMtLQ0KTlXTEwMbGxsaB/v8+cvSEo6BAaDgatXr8Lf3x/19fUYPHgwdHXpWTsejydV4aCvr4/o6Gj8/fff2LFjBzZs2ID8/HyMHDkSwcHBMj/bAJH5X1ZpsSzs27dPLiPEYDCokJPa2lpERETAzMwM79+/x82bN5vt3wIkS4ubCzpGSjwNMC0tjfK7jB07FoGBgbh7967CpcWNjY2oqKhoUUT8pUuXoK6uDjc3N1RXV2PTpk0YPXo0NDVF53tTT2xLAjmysrKgrU1/HtGhV69eOHz4MMzMzLBu3Tp4eXmhvLwckydPRkBAgNwBb+vWrQpHxMfGxsqNiGcymfD29oa3tzfKy8sRFhaGUaNG4f379/jnn38UkrzJCuSQh6CgIKmIeGNjY5w4cQIA8Oeff8LFxQVfv37FtGnTsGbNGjx8+LBFpcUtiYgnS4vJzrbi4mLweDzs2rULurq6CAwMpK6PJDZv3tziiPjmMlJDhw7FmTNnMGrUKLi7u1P+rblz58LX11emf4t8fYpGxD9+/BgjRoxQ6Jhf+M/F//kh68iRI1BVbYNhw4ZJSEG+fasFQRC0Bvjk5GS4uLhg4cKFlFwmISEBHTt2RE5ODlJSUqSOoSstZjAYmDJlCtLT08HhcJCVlQV3d3eoqKjA3t4e48ePx4cP9MmGz549Q+fOP0qLSf8WmQLVurUKXF1dJfxbdMmGJC5evPj9ZkiXuun5558XiIyMxNOnzzBlihUqKiok2Ccy2ZAuIv7o0aNwdnaGvb098vLyweeL/Ft6enr4+PEDkpOlWcCCggKpsAkGg4FZs2biyZPHYLFYePMmiyoFdnJyhJmZGW3XFiBdWjx8+HAMHz78uwx0MVq3VoabG+e7f2seGAyGXEbqypUrMDY2RpcuXaib3UePHmHbtq34++/nmD59GqqrqyUu3rIYKQA4ffoUHB1FDMenTyL/VmTkXnTtaoB3794hKSlJ6pji4mKoqqpCWVlyjRYsWIDXr1/DwcEBb968ofxbbDYbw4cPl5ls+PLlS4nSYjMzM5iZmVFSWSZTGRwOB7Nnz8bMmTOpGxxZjBRZWtyjRw9KBnj37l1s3LgRGRkvMHv2bHz7Vivh3yIZKbqI+HPnfsfixYvh4uKC7OxsREXxsWPHThga9sCbN29omdKmjBQgusGxt7fHhw8fsGDBArx4kYGjR499929xMGjQQJnJhk0DOcaPH4/x48dDIBBQoTYeHh6YP38+LC0tqTUimeqmIEuL+/TpQ3kPb968icDAQGRmZmL+/PlSKaeyGCkAuHTpMuzs7ODm5obXr19/TwMsQr9+/fDiRQYOHoyTOoautJispygqKsTcuXPx4MEDHDp0CDo6HeHhwUXfvn3x4kUGJcsUhygi/odvw8rKClZWVmhoaIC9vT3KytQwadIkLFu2TGJI+/Tpk4TxncSff/4JY2NjmJqaUmmAJ06cwMKFC1FXV4f58+dL+beaW1rcFMePH8e1a9ea9W9VVVURHByM8vJyODo64uTJkwgNDUW3bt0QEhIiN2lQXmmxPPwsIt7CwgLnz5+n/FuzZ8/GP//8Ax8fH9oET1n4n0TEi3/mqaurU97N7OxsBAYGYt26dejVqxdCQ0PRq1cv3Llzh2Kcmovg4GBaxlgeUlNT0bdvX0yePBmTJ0+GUCgEn8+n/FssFgtsNltijZpbWtwUSUlJzZY/ampqYseOHfD398f06dMRGRkJPz8/9OvXjzqfZCE7Oxvt27f/l0fEz5w5EzNnzoRAIMDevXsxefJkvHr1CuvWrVPoPIqPj29WYbM4vn79KiV/1NHRocJAnj9/Dh6Ph8+fP2Po0KEICRGFcF27dk3h0uKgoCDazzB5IOWP4v6tnTt3yvVvkX5rRQNh/vjjD4WrEH7hPxf/p4eshgYBDAxE8quAgHWor6/DhAkTsHjxYiQkxMsswHzw4AGVKCUul7l9+zZCQkKpJDAu14O6uebzo+DoSE/vf/jwAePGjcO4cePg5uaGoqIiREXxERkZiaqqarx9+1bqpp/s2qJD69YqSExMkPBvqaqqolevXjK7ts6ePSu14zJo0EBs2bIFS5YswbBhw7B69WoIBAJYWVlh4cKFMpMNAdGNNSnt09fXA4/HAyDyc2zcuBFubm4YMmQI3N3dqUFWHiP1/r3IbD158uTv/q08REXxsXPnTlRWVuLjx49SO7CySosBQFVVBYmJiaipqUF8fDw1uPXrZySza+v06dNUqAEJExMTDBo0CJ6enujb1+i7fwtUGiBd1xYJ8Yj4rl0NEB4uig2/evUa7t69Czc3DkxMTODm5kpp+MW7tprizZssrF+/njpvc3JywOfzERERgcrKSnz+/FnCv0WukYeHdPw5g8GAqmobJCYmUDJANpuN9u3bY8CAAejXj/5mkq60ePTo0TA1NYW7uzu6dOlCyQBnz56DGTOmIzn5sExPwu3bP0qLDQ0NEREhkgpdvHgRt27dAofjjjFjRoPFYlEDg3jXVlM0DeR49+4doqOj8fHjRyp9sekgExMTQ1vIy2QyoabWFomJCZR/6/DhFHTooI3BgwfLvLjSlRZPmDABY8ZYgMPhoH379vDw8ICysjIWLFgAKysruYyUeGmxkZERlXJ67tw5XLlyBZ6enhg3bjwcHR2owS02NkZOabEokIO8qcrMfAU+n4/Pnz+jsrIS5eXlUgOxqI9M2nOlrKyMtm3VcefOn8jLaw0ej4ctW7agS5cuGD9+vMy/td27d0uUFjMYDCqdsra2Ftu3b8fYsWPRtm1bLF++HLNnz8bevXsV9j6UlpZCWVkZbdq0Ueg4MiKeXKN79+5h9erVKCoqwujRoxEcHCwlYWpuabE4Ll682GxGivRvOTg4wNzcHAKBAGPGjKGYgZ8NUCkpKbh69apCry88PFwuI2VoaEhtqN24cQPe3t7Iz89HeXk5qqurFUq5e//+vcI3701LixkMBiUlr6ysxMaNGyn/VkBAAMaNG4fY2FiZn9myUFlZCQAtioi/e/cudR5dvHgRHA4HVVVVmDp1KtasWSPl3wsMDGxRRHxzgzWYTCZ8fX2xfPlymJqaIicnB6NHj0bHjh0RFBREuykijpZGxMtjpAYPHozTp08DEN2rODg4oKKiAmVlZRAIBHLZpKZ49eqVwl7KphHxrVu3hr+/P/z9/ZGfnw8ej4etW7eiS5cuCA4OxpAhQ5CUlKRwIEdDQwMaGxsVrqz4hf9c/J8esu7duwtzc3MMHTqU6qlJTj4MDw8PvH//ntavk5eXh7Zt6UuLU1NTsXFjGMzNzSm5TENDPSZOnIjs7GyYm5tJHUNXWiwyo26Aj48vZs6cgb1796K0tBSDBg2iQiVkMVLipcXi/q2CggI4OTlRqWVcLpf60G3atSWOxETRIEXKAGtra5GYmAgOh4Ps7A8IC5NOJsvPz5cZf3779m2EhobC3NwcFy5cwMqVK9HY2IgpU6bg3bt3tF1botJiXYnv6evrIySEB19fXzg5OWPnzp0oL6/AsGFDqYj5khL6xCZRIIfo5k5NTY0axPLy8uDs7AxdXV2sX78enp5eVCkw6SOj034nJSVh8uTJVIx7TU0N4uJEaYAfP36g3bEVTzZsigcP7iMoKAjjxo3DmTNnsGzZcgCincasrCyZjFTT0uJu3bohPDwcfn5+MDc3x6ZNm1FdXY2RI03BZrOhpqaG4uISia4tEqKIeNHNHSkDBEQbAhwOB7q6eggODpbwbzU0NKChoV5GabEokIO8Ua6qqkJMTAzY7BP4+PEjraSCjpEi8ezZM2zYsAHjx4/HiRMnJEqBX73KlMNISUpEe/XqhYiICKxatQrDhw+nZICkf0tFRQVFRUW0DIV4abG4f+vt27ffwzb0sHHjRnh4eFJsYUODQG5p8YQJ4ykZYFlZGfh8PpKTDyMn5yOtx4GOkRJ/vwEBAZg4cSJSUlK+D26tYWu7UC4jpa0tGRIgqqfYgTVr1qBfv36Uf2vixIlYvHgxlJWVUVBQQCuXvX379vfS4iro6w+kvHWPHj3CtGnTYGBgAG9vb/B4PGpNBAKB3NJiVVVVbNiwARs2bMCXL18QFBSE8PBwZGVlKTwkiJcWNxd0jJS5uTmVBpiSkoK5c+dCIBBg0aJFVFKloqXFgEj+SOdDlYeoqChMmzYNoaGhCAsLo/xbgYGBMDQ0RGhoqJSUS9FADhK3b99uNiM1ceJETJw4EXZ2dujatStmzJgBgiDg7OwMDocjlylpaUS8PEaqXbt21KZZVlYWJacjZaCKIDw8XOGggvfv30ul9pE+6ab+LTc3Nzg6OoLBYODt27cKD4EtjYi3tLSkfr8vXrwAj8dDbm4uBg4ciNDQUKl7F0UDOUikpqY2m5EifdLOzs5o3bo1JkyYABUVFcq/JQ9paWktkj/Ki4jX09OjUmcfP36M4OBgfPnyBTk5OXJ9X3S4cuWKzI3rX/i/CSWCIP5fvwYKJiaDiEePEv5ljxcZGfk9FU3SVElGsPbq1QuvXr1Gx4468PDwQJ8+fRAczMO0adYwM5MemFgslpR8qb6+HhEREbh5U9RHY29vJ7Fr7+PjgxUrVkgNTEKhEGy2K+WVEQqFuHLlCs6cOYOCggJ06NABfD5f6ibd3d0dO3fulJI5fvtWC2/vpYiLi8M//7xAXFwsysrKMGjQIDCZTOjp6dEyJC4uLpRHSnKN8rF+/Tp0794d799nQ09PD56eHpQJe/LkybSmaxbLhXpP4q9ty5YtSEu7g379+sHR0VFCIunr64tly5ZJDUyiNWJTa/6jf+ssSktLoa2tjejoaKmLN5fLlejaIlFXVwcvLy8cPHgQT548QUJCAioqKjF8+DAoKyujffv2tImNstaoqKgIq1evhoGBAT59ykXXrgZUGmBY2EaMGzeWNuWObo2qq6uxZcsW3Lt3D8bGxnBxcZGI2l+5ciW8vLxodfDijycUCnHq1GlcunQJ5eVl0NbWBp/Pl1ojDw8Pia4tEg0NDeByuYiPj8e9e/eQnHwY1dXVMDMzA5PZCioqKrR9NC4uLoiJiZEamEpLS+Hr64vOnTsjLy+f8m/p6+th8+bNGDlyJK3EhW6NKioqsHnzZjx8+BCDBg2W8G8BgJ/fKgm/kqzHEwgElISsqqoK2traOHDggNQaeXp6SnRt0a3RrVu3cPToUXz79g1jx44Fg8EAQRC0/SdsNpvykYmjrKwc3t7e6NxZH4WFRTAy6gsulwsdHR1s3boVQ4cOpb0ws1gsxMfHS7zu0tJSbN68GY8fP8awYcPB5bpL3DysWbMGLBaLdmASXyPRhlQybt++jW/fvkFTU5M23t7T01Osa2swAGVqjceOHYv09HScOHECUVFRlAwQEMmH6CTAslBaWopJkyahe/fuyM/Px6hRo8Dj8WgHfnGYm5sjPT1dIemVra0tVqxY8dMEw5qaGmzduhWXL19GbW0ttLW1kZqa2uznEQgEsLCwwP3795t9DACMGTMGV69epR2Y7ty5g82bN6OkpATjx4/Hhg0bqKTCQYMGwcXFpdnP8/r1a6xYsQIXLlxQ6PWZmZlR76m6uhrh4eG4ceOGTP8WIAqPiI6OVsgvxufzkZOTo5B3qbKyEubm5jAwMEBFRQUsLS0REBCAtm3b/vQ9iTNSzYGDgwM4HI5cHxcgGoBDQ0Opnqr27dvj8uXLzX4eoVCI0aNHK3wejRs3jvJINcXvv/+O3377DV+/fsWMGTOwatUqquvJwMCA6n1sDj5+/Agul6vQewIkz6PCwkLweDw8fvwY+vr6CAoKkrg+kpg+fTp27dql0MCemJiI58+fK+StqqmpwdChQ9GlSxfU1dXBxsYGPj4+P2XcAgICEB4errAU9Bf+/aGkpPSYIAiTpt//P8tkVVVVQV1dnTa1JioqChwOhxqkMjNfISqKj+LiYnz+nCsRZU6CjpECRLRycXEx4uJi0bZtW/D5fMTHx6NTp07gcj1kdm01LS1mMBiwtraGtbU13Nw4GDFiODgcDtq0aQN7e3uMGzeOYqTofGSHDv0Imxg0aCB27xaVAl++fBkRERHo0aMHhEIhbG1tqWGhabKhOPj8KLi5uVE7s3///Td2796DsrJS5Ofn0/ZCyCotbtNGFRUV5YiOjoaaWltERUUhKoqPzp31weV60HZtAZCKiCf9W7NmzQSHw8HAgQOl/Fuykg1Fa/SjtFjcv/X7779j9+7d6NmzJ1RVVWFjYyPhu5FXWsxms6lB6q+//qLSAPPz8+DnJ71GskqL1dXVUVNTg6goPlRUWoPP52PPnt/QvXs3eHh4oKSkhHbAunr1KoyNf/iCRGmAC7Bw4QJwOBz06dMHbLYr2rdvBzbbFcOGDaXt2iIhXlpsbm5OyZJOnTqF/fsPoHfvXtDS0saMGdMl/FvySotZLBY1SKWnpyMsLBRfv35FQUEBfH1XSB0jq7S4ffv2aGgQ4MCBA2AymYiOjsaOHTvRs6chPD09abu2AHyPiP9x0WUymVi8eDEWL14MDocDA4OuYLNdoaWlCXd3dxgbG6OhoQF1dXW0r+PIkSOUrEncv3XkyFHExsaiT5/eMDAwkPBvlZWVo3Xr1jJi9PlgsZypQerGjRvYsGEDamtrv6+Rr9QxWVlZtB1J2traUFJSQmRkJBiMVt/9W8Xo168fPDy4tF1bgHRpsXg9hbu7Ozp16gQWy0ViQ0raR1YFQDT0kNK+pjLAHTt2YPfu3fj06ZPUa5CHkJAQrF69Gg4ODhAKhTh69CiVBrhgwQIsW7ZM6m+0OaXFdMjJyWlWRLyamhp4PB54PB7Gjx8PHR0dmJmZoVu3bggNDf2pDPB/IyKe7IMTCoVITEzErFmzIBQKkZOTIyWF/hl4PJ7CEfFNGSl1dXXKu0l6awMCAtCnTx+EhYXB0NCQKi1WNJAjOTlZ4Yj48PBwrFixAhwOB0KhEFFRUVRADpvNBovFkjpf3r171+KI+J8NWIDIv0VK1caNGwcmkwkzMzP0798fYWFhP/UgHjx4UGZlhSz8jJGaPXs2Zs+eDYFAgN9++41KA8zNzcXr168Veq7AwMD/cUR8p06dsH//fgAilUNoaCi+fPlC+bd0dXVbVFoMiCT1LYmIX758Oby9vVFXV0f5t9q0aYNly5Zh7ty5UsdUVFRAQ0Pj14D13waCIP5t/hsxYiBBEI/+Jf+dPr2B+PjxNO3PnJ2Nab//5Eks4ew8kOByRxAuLoOIxMTlRH39PYIgHhHLlo0msrNPSh3T2PiQcHaWft0vXiQStra9CSsrbSIiwpYoLb0m8XMOZxhRWXlD6riamjTC1XUI9XVBwQUiNHQO4ew8kLCx6UZERrrQvnYXl0FEQ8N9qe9/+fIn4eU1kqitTSf4fC7BYg0kvLxGEnfu7CaCg2cSaWl7ZKwR/e/i2bM4wsGhH8HhDCPY7MHEkSOrqOddvtyCeP/+hIw1kl7zJ09iCVvb3oSlpRaxc6eD1HpwOMOI8vJUqeNqa9MJNnuw2Hv8gwgMnE44Ow8k5s/vQezdy6Z97SzWQNo1Kiy8SHh6mhJfv94mIiNdCGfngcTSpWbEw4cHiNDQOcTNmzsUWqPnzxOIRYt6E25uQwlX16HEqVPriMbGhwRBPCJWrBhHZGUdbfYaPXiwn7C17UVYWmoRe/eyia9fb0v8nMsdIXVuEcQjoq7uLuHiMoj6+uPH00RAwBTC2XkgYWfXR+55RJ7z4v8VFV0iPDxMiMrKG8T/x957RzWxtt3D2wiiCIqIBXvBjhxsdAFBFBUFKYKUhB5QEATFSkex9xKKFLGgYi/Hjl2PXY9iw16QJkivub8/wowJmQDxfd/1+57znL2Wa5mEe2a4mMzMfe9r771hgxNhs0eQefP0yaNHiWTFCmty+fJaqWr07FkqsbMbQNzcNIin5yhy6lQkXaOgIGPy8uXeFm/v2rWNxM5uADE1VSJxcd6kqupmoxqNJYWF58XG1dTcJhzOr+29eZNOFi40IWy2OnFyGkq2bJGuRj9+XKT/HqtXzyJs9ggyf74hef58N4mNtSXnz8dK/J34/Hti72dlpRFr677EzU2DeHuPJRcurKI/W7BgAnn+fHeLa3Tx4mpia9ufmJgokZQUf7Hj9/EZR/Ly/hQbV1t7R6RGz5/vJkFBRoTNHkE4HPVG59EHQkFPT49UVlaSxsjPzydGRkZi7zcHbW1tUl9fL/Z+ZWUliYqKIjo6OsTU1JScPHmS/szW1pbcuXNHqv2cOXOGuLq6SjWmtraW6Ojo0K9v3LhBpk2bRrS0tMj8+fNJUVER4zh9fX1SXl4u1b6CgoJISkqKVGMePHhA+vXrR3R0dMikSZPIxYsXWzROW1tbqv0QQsikSZPIhw8fmv25S5cuEXNzc6KtrU0mTpxIQkJCpNrPz58/yfjx46U+PknnUVFREVmwYAHR1tYmU6dOJdevX6c/c3R0JJmZmVLt59KlS8TJyUmqMfX19SI1P336NJk4cSLR1tYmERERjN8nQggZP348+fnzp1T7WrJkCeHxeFKNefDgAenZsyfR1tYmM2bMIHfv3m3RuN85j6ZMmUJev37d7M9lZGSQCRMmEF1dXWJtbU0CAwOl2k95eTnR09OT+vh0dHRIbW2t2Pvfvn0j3t7eRFtbm8ycOZM8efKE/iwxMZG8evVK6n39i/8MALhPGOY1/1gm6+zZs7hx44ZYu8yjR4/EzAEoJCcnITpa4PxDtcsIcmrkkJ+f1yJGisKIESOgqKiAhIR43LlzB4sXL0JtbS1MTExgZWXFmLUFiIcWd+3aldaO2ds7IDs7GxyOK9TV1eHt7YWOHTs2yUjxeILQYjk5OTrQMTc3FzweD5mZV1BZWQVVVVWRPmYqa4sJSUnJ9ApkZWUVUlNT4OHhCXn5dsjLy5eYtcWUgzNqlCY6duyAuDgerl+/Qeu3Jk+ejBkzLCU6GzYOLVZVVUVUVFRDjezx8uVLcDiuGD16FDw8PKCgoIC8vLwmGCmBIYe8vDz8/PwAAF+/fkVcXByuXr2KqqpqDBgwkNZvAZIZKQDYtSsRMTExUFNTE9FvKSoqIDc3V2LWFhPDoKWlBSUlpYaw0svw95+HVq0E+i1zc/MmGSnhVdQ+ffrQjmC2trbIysoCh+MKHR1tuLq6oV27tmJZW8KgQosF+i0B+/T+/XvEx8fj1q1bqK6uwdChw6Cq+uu8efHiZZNRA9HR0RgyZAhKSkqQkJCAgwcPQUlJCd++fZWYtSXMSFEYP3489uzZg+3bt+PChQu0fsva2hqmpqYSnQ0FocXG9Gs1NTV6tV/gUPgMrq6uMDAwgIuLC+Tk5Bp0ZMyMFBVaTNm4AwLGKT4+Hnfv3kNdXR1GjRolUhMBI6XMyLgnJSUhOjoaw4cPb8gSi0da2h6oqKjgy5fPjM6GjRkpCqampjh06BC2bNmCs2fP0dc1e/tZDSx5JaOzYePQ4uHDh9NtNdbW1nj69Cnc3NxgYmKK2bM5kJHpS5tNMIm7o6KiGI1YmsLz58/RtWtXxhXgtm3bIjQ0FKGhofjy5QvCw8MRExOD3r17482bN02GsDKBCi2WBo0ZKX19fVq/tWfPHsyYMQP19fVwcHCg9VtFRUW/pZG6efMm7VjZUqxZswZpaWkwMDCg9VvLli3DgAEDEB0dLbGLQFqLeGkYKRMTE5iYmIDP52Pw4MEoLy+HoaEh2Gw23N3dm13tZwotbg5NWcQrKSnRdX316hUd0DtkyBBkZWX9Vmjx/9QintJJ19XVYfv27TA1NYWMjAy8vLzg6OgIFov12xqpy5cv0+2JLcWmTZuQmpoKU1NTEf3WyJEjERkZydjpc/36daldHKWxiBd2Axw8eDC+fv0KExMTRjdAJsTGxjJKBJrCp0+fJFrEq6qq0rrUe/fuITQ0FN+/f8e4ceNo7d2/+O/CP3KS9e3bN5iZTcSIEepi7TLJycmM1LXgBlFCW6sKt8vs378fR48eBYfjiq5du8Db25u+ADTO2qJAhRZ36NABkyZNwqRJk1BdXY09e/bA1tYWbdu2xdWrV8VofsmhxTno3FmZbgM8f/487QZYU1MDLteHsRZMYuxu3bo1BPBWwsnJEZs3b0FxcRE0NDRorQnlote4RsKhxe3atYWPjw98fHywf//+hhRzV/TooQoul0tPSoWztoQhbDZBtQFWVlYhJSUZM2daoW3btrhz546YPu7WrVuMYbN5eXlQVlbG1q1b6TbAwMBAEEJQV1cPd3dmlyym0OKePXvSLU4zZ1phzZrVKCkpxZgxo+Hu7i7R2ZDP56OoqIh+0JWXl4e/v2Ditn//fqSnHwCH4yqi3wJEs7Ya16imRmA2QbUBlpWVYdeuXZg5cybatm2LR48eYdSoUSLjrl27xlijgoICqKioYMeOHQ36rcMNukWAEMDJidkBiim0uH///mCzOaitrcWkSWaIiYlGeXk5dHV1wWZzkJiYCG9vZtMBYetbSjMCCCY++/fvB4fDwYABAxoMJgSmKMJZW8KgWvu6dOlCtwEWFxcjISERW7duhZycHP7++xlGjhR1uqOythrjx48f6NxZBXFxPNTV1SE9PZ1+OBbY6TM7G7548ULMgnrQoEHw9vYGn8+Hvr4Bli9fjurqahgaGsLZ2RlxcXESjRny8n5ZxCsrK9NmH3v27MHLly/h6uqKIUOGgMvl0pPI/fv30/EDwqBa+1RVVeHm5go3N1cUFBQgISEB69evh5ycHN68eSP2YCMptLioqBidO3dGfHw8fV3z8mLj69fOYLHkJE6k7t69i02bNjF+JgkRERGMZjCN0atXL+zaJbCzX7duHW7fvg1tbW3o6OggPDy8Wf3W71rEp6enMxpysFgs2uSkoqICq1atwvjx46GgoIB27dpJ/cD1uxbxwqHFwvlb165dg7+/P378+AFDQ0NavwVIH1oM/J5FfGlpKXr06IFr166hpKQEK1asEHMDZEJzocVMaKlF/JAhQ5Ceng5AELp77tw56OjowMzMDEuWLGl2Yvy/bREvIyODgIAABAQE4MePH4iKisLWrVvRpUsXdOjQ4bdDi6U9j16/fk23faurqyMjIwOAQL/FZrNRXl4OCwsLBAcH0wsssbGxUoUWAwKNlCSnVUmoqalBz549cfPmTeTl5SE8PBxr166FqqoqwsPDoampyTju/9IiXjieYuvWrcjPz5dqP//in4F/5CTrwoULsLS0bMiqEDzcX7p0CUuWLMHLly+RmZlJu2ZROHXqFEaN0mTc3qVLl7BrVxIUFRWQlZUFHo+HgoICDB48GLW1dRIYqWQxu2E5OTl4eHjg2rXrWL16FRISEpGUlIyuXbuAy+Wiffv2YllbFHg8Hn0xFdZvVVdXw8rKCklJu7Bv3144OTnRN9TGWVvCSEpKRmBgAPr374/NmwUTt7NnzyIoKAivX7/BnTt30Lt3L5FjOXv2rMTQ4szMTCQnJ6Njx4549OgxNm7ciOLiYowcORI1NbWMjBRTaHG7dm3h6+uLv/76CzExMUhISMDOnTz06KEKHx8fyMvLN8NIOdE1olyKKioqYG1tjeTkZBw8eAgcDhtaWloAmmakEhMT4efnh4EDB2Ls2LHg8/k4fvwEAgICkJ39Fk+ePEH//v1FblZU1hYTrly5gpSUFHTqpIR79+5h1apV9MStqqpaIiNlYiJqDKGgoICAgAA8evQI4eHhSExMxKZNm9GvX1/4+PhARkZWokZK2CJeoN+yg52dHUpLS2Fra4vU1N04fvw43Nzc6BvTixcvRbK2RGuUAC6Xi8GDB0NfXx91dXXIyMiAn99cvH37Fm/eGGPQoEEiNaKytphw9epVpKamQllZGTdu3EBkZCQqKioa9HZVEpwNxS3ilZSUsHDhAmRlPceiRYuQlJSE3Nw8qKkNhI+PD1q3bi3R2VA4tFhGRgbOzs5wdnZGUVEx7O1nYc+eNPz55xl4enrSkyBJOjLB9uLg6emFYcOGYsIEY9TW1iI9PR1cLhdv377D5MmTxdwNqawtJty4cQOpqSlQUVFpuK4J4imaYqSYLOJVVFSwZMkSuLm5Yf78+bQulVqQatWKBRkZGUZnw4SEeHqlmLqueXh4IDdXHhoaxiguLkZGRgbCw8Ppa8azZ8/QpUsXqR/uPn/+TH9fW4pz587hzp076NGjB/bt24eZM2eitrYWs2bNgp+fH+P1Y/v27RJjPSThx48fDVb/TT94y8vLIyoqClFRUfj48SPGjRuH3NxcnD59GlFRUS3SkfxvW8RTsSJ8Ph/JycmwsLAAn8+Ho6Pjb4cWnz9/XqoxMTExtEV8hw4daKc7Sr8VEhKCwYMHIzIykp60SBtaTOF3LOKvXbuG27dvo3fv3rQbIIvFgoeHB1xcXBiP4f/SIl5ZWZlepHj+/DmMjIzw9u1b3LlzB1FRUS1aIAgPDxcLLW4OV69elejax6TfatOmTZNa4qaQlJSE06dPSzVGmJHq2rUrvTD0+PFjREZGIicnB6NGjUJkZCS6dhXc76nQYmnPo5cvX0rlEMhisVBbW8uorf0X/3z84yZZhBCUlJSIWXGbmpqitLQUgwcPBp9PRNplTExMaPODxqioqGgILRZc/ITbZYKDF+Dnz2KhdhkH+uYtnLUljJycHCgotEf37t0RGipYnX3+/Dl27NiBp0+fQl1dXSwUGIDE0OIXL15AU1MTsbGxdBtgQkIiunfvhoKCAkabeqaVNhaLhalTp4LP5yMrKwslJT9pq3QnJyfo6+tLZKQqK6tEzCZGjdLEqFGbwefzERwcjOLiIri7uzeEAtugdevWAESztoSRm5sLeXl59OrVC5GRkQAEbZ7r169HVlYWNDQ0xEKBAeDt23eMjmXv3r2DhoYG1qxZQ7cBbt++A7169UR+fj4WLVrEWKMfP0Qt4lksFmbOtEK7dm3x8OFDfP36jW4D5HA4GDduHGPWFiAeWjxu3DiMGzcOfD4fQUFB+PGjEJ6enpg2zQKWljPoC79w1pYwqNDi/v370+5ad+7cQUzMCrx+/Qp//PEHKisrxfKBJIUWf/78GSNHjsS6devw4cMHxMfHY+PGTejXry/y8vIk3iAaW8TLyMjAwcEBKioquHHjBl6/fo1DhzKgpKREuwEyZW0BoA05qImUgYEBDAwMUFdXh+DgYOTnF8DLywvW1ta0WB0QzdoSBmURP3ToUPpvcvXqVYSGhuLdu3cYNWoUqqurxSYRkkKL8/JyMXKkBtavX4c3b7KRkBCP3NxcDBo0CN+/f5eY2ZafXyBiyCErKwsXFxf06tULly5dwoMHD7Bnj6ANkJqMMWVtUTUStoinQlhra2sRHByMgoICcLlczJo1S8S1UThrSxiURbyGhga9IHXx4kUsWbIUHz68x+jRo8WCkwHBNYupI6C4WDAhOnnypEi7jJaWFt69e0fn6bUUp06dkpi1JQmNGSlqklxVVYXVq1fTbNL8+fMxdepUetzBgwelcgcEfs8ivqKiAlpaWjh16hRu3BC0SRcUFMDAwAChoaGMMRJA86HFTGiJRTw1afDw8EBZWRlmzpyJL1++wNzcXKIbYGNQocXStj9KCi0eOHAg9u7dC0CwyOnr64vi4mKYmJjg9evXvx1aLA0a3yf9/Pzg5+eH4uJiREcLolyoHE3hv4s0ocUUVqxYweja2hTk5eUxduxYnD17FqdPn4arqyvKysowdepUhISESMxiEmakWorVq1c3y0jJyMggKCiIPp9tbW3x+fNnWFpaIjQ0FGPHihmvieF/YhHP1P6oqamJo0ePAhB0izg4OKCqqgpWVlZ4+vTpbxlyMMlGmgIhBPn5+RIX4f7FPxv/uEnWs2fPJTIJJ0+ewubNm6CgoEC3y8THxyMpKQk5OTnIyckRW3VJTpYcWlxYWIAjR47Q+i0vLy/Iyclh0qRJErO2eLw4ODs7i7w3YsQIbNiwARwOh76xUfotBwcH/P33M8Z+Z8Hx/Qot7tatG51D9ffff2PevHkID4+AhsZIOgQVEM3aaozjx4/TFvFcLhc5Od8RF8cDj8fDt285KCoqEpsASgotZrFY+PGjCIcPH0ZtbR1SUlLg4eGB9u0VYGExrUkdWePgwlGjRmHUqFHgcDgwMjKi2wDNzafAxsYaz59niWVtUUhMTIS/vz8AQRsgpd+6d+8+QkIWIioqCmPGjIG7uzs9cTt37rzEh7ujR49izZo1dB2+fPkCHo+HrVu34tu3bygrKxN7UEpLS2N8WGGxWCguLsbRo0dRVVWFpCSBfqtDB0W6HVBSjRpb8uvo6EBHRwccDgfa2jrw8/NHq1aClUYLCwu8fPlSLGuLwq5du+DjI2g57devH63fun37NpYsWYLY2Fhoa+vA1dUV7doJbt7CWVuNcejQIcTGxtITpvfv34PHi8P69evx7ds31NbWio0RdjYUhoyMDEpKSnDs2FFUVFQgPj4B6ekH0KmTEmxtbZvQSImHFlNugBwOByNHjqTbAK2trTFp0iS8efNG4s1QOLR40KBf+q0rV64gIiKCfoB3cXGhrXyFs7Ya48CBAyIW8a9evUJCQgJyc3ORm5vLOEbY2VAYsrKyKCsrw5EjR1BeXo64uDjs3p0GFRUVODg4SMzaSkiIh62trch7EydOxMSJE8HhcOh2Rzk5Odjb22PChAkNWVvMTAKPtxZhYYJzR7hd5tChQ9izZw8CAgJgY2ODgIAAxvO6MTZt2oTdu3c3+3PCkBRa3LZtW4SHhyM8PBxfvnxBWFgYIiMj0adPHyxYsECijqwpUKHF0kDYtc/AwACnT58Gn89HWloard9ydHSEr6+vSIgtU5ZbU6irq0NJya8W+JZAQUEBlZWVeP36NXJzcxEeHo4lS5Zg4MCBEvVbgGCSIG37Y0sZKWohgc/nIyEhATt27EBeXh44HA7c3NxaxESsWbOGMYKgKSQkJDBeswUdMoK/+YsXLxAZGYng4GAMHToUISEhaNWqldShxVevXqVdGFuK0NBQeoFw2rRpmDZtGurq6rBt2zbaDdDLywuzZ8+mayRNaDEFaTRSFFRUVMDn8/Hy5Ut8/PgRERER+Pr1KzQ0NBAVFSVR8/07GqmPHz+iY8eOzZ4HwvqtDRs24NSpU/j27RtKSkpapN+ijk84tLgluH//frMBz//in4t/3CTrxo0b8PAQz6ipqKgAQEQuftQq1I4dO+hwwIKCAgwbNgxcrg86dVLC3bv3kJzMzEhREynhdpn8/Hx4enpCRkYWCxcuBJfLFRGif/jwnpGRevToMXr27CnSBpiWlgYvLy98/PiRMZeCWmljWln58OEjZsyYgYCAAJw7d47Wb5mZmeHixUvYtEmyjky4/VFVtTsiIiIQFxeHnz9/YuPGTSguLsIff/wBLy8vKCoq4vbt2xJ0ZN8hLy9o7ZORkYGvrw98fX2Qk5MDLpcLGRkZLFmyRES/BQiYJ8mhxd1haWkJS0tLVFRUIDk5GW5u7vjy5TNtWtG4RpIs4gsKCjB16jQEBwc1tAEGAiCYNm0azpw5w/jwRDFSwhPNXr16NbQ2JiI39ztWrxbot8aOHQsPD3fIy8vjxo0bjDUSDi1WUFDAvHmCYOLPnz9j7ty5kJGRQVhYGLhcrohhiyRGijIJENZvJSYmws3NHV+/fqG337hGBQUFjDfRsrIymJubY8GCBQ36rblgsViYMcMSJ0+ewOrV4qwdpZESbu3r378/Vq9eheTkZHz48BFRUQIbdz09PXA4HMjJyeHq1auMOjLh0OKOHTti4ULB6uPbt2/ph/Xo6Gj4+PiItMpJYqSo1j7hNsDExATs35+OnJxvdDh0YzRmpITrN2nSJCxcuBD79+9vCAWWha2tLQ4fPoIVK5gZqcYW8UOGDMG6deuQlpaGrKwsLFu2HNXVVTAyMoKzszNkZWWRmZlJC6uFIRxaLCcnR7eVvXz5EgsWLEDr1jKIjY0V0W8Bkhmp7OxsdO7cGe7u7nB3d6cXpFJSUvH9ew4CAsRjLgDgx4/vGDdOU+Q9FouFdu3awcbGBtu2bcP69ethaGgIeXl5zJs3DzNmzGDcFhVaLGmBSRIOHTrULCPVq1cvutPg9u3bdLTF/PnzER4eLpFNEkZWVtZvaaQ+fvwIPT09kfdYLBY4HA44HA4qKioQGxsLfX19KCoqYuHChdiwYQNjZ0RToNrbpIGwRXz//v3pCe6VK1fg5+eHoqIiGBkZYdmyZSJsgyRGqimEhYVJZRHPYrEwYMAAWFpaYuvWrYiJiWmRfut/opE6e/Zskz8zbNgwWr/1559/wtzcHK1bt0ZERARCQkJaxOz9b1rEy8jIIDAwEIGBgSgsLBTRb4WGhv52aPHvWMRTmvSRI0fi8OHDAASLuE5OTqioqMCMGTMQHBwski0liZFqCmFhYVIxUm3atIGBgQHMzc2xefNmREREYO3atejRowciIiIkSiJ+1yL+1KlTUrf5/ot/Dv5Rk6za2lrcuHEdjx8/EmuXaYqR+uuvu0hOTqIvchcuXMDixYtQXl6OsrIy1NfXi10ABRopZ7FtdenSBUpKnZCamkK3ARYWFmLEiBHQ0dGR+MCQkpJMu7YBAp2Dp6cn3N3d4ezsTDvmdevWFVwuFwMHDpTobAj8MuRgsVh0ynx1dTUSExORnZ2NRYsWwdHRUcQ5TDhrqzGoiZSMjAz4fD7OnDmDoKAgVFVVoby8nHFMXBxPjLUDBA48nTopIzU1BY8ePcaGDRvw8+dPjBo1Cjo6OhJXuXbt+sVIAYJ2iblz58LXlw8nJyc8evQIx44dR69ePeHj44PevXuLZW0J4+jRI1i7di3dBjhzplUDUxKPN2/eYOnSZXB15YisQqWlpUlstbhx4wZ27fpVo2PHjsHf3x91dfUoKyuVyGzOnj1b7P3evXvTNbp79y6dv6WlNQ46OjpNOBvuEpmQKygo0Kyfo6Mj7ty5g8OHj9D6LVVVVVy8eJHRqQ4AMjIysGrVasjIyNB5R6WlpeDx4vDq1WtERISL6LcAcWdDYVy7do0O5K2rq8OhQ4fg6+sLQghKS0vpVlJhxMXFiTFSgKClqHPnzkhNTcX169cRFhaGyspK6OvrQ0dHRyIjFR+fINLi1amTEq1RsLd3wPXr15CRkQE1NTX4+HDRpUsXXL58mdHZEAAOHDiIFStiICsrSxsdFBUVYefOnXj58gVWrlwpot8CJDNSgMBsgqpRbW0t9u3bB29vb9pNjCnwMi6Ox7gaO3ToUKioqCAlJYVuA6ypqYaxsTG0tLQYs7YENYoXYSaoBSlBjexx6dIlHDhwQGRB6pez4a+8LAqbN29GWloaHWi6bNkyfPv2DaGhofDx8YGenh4iIiJE2ONt27aJtPO1BE05G0qCrq4uVFVVcfPmTezfvx9WVlaoq6uDvb09zXQyISIiAsuWLZPq+FrCSMnLyyM6OhrR0dH4+PEjQkNDcffuXSxcKGDdW9r2tn//fkZDjqYQHR3NGKRtbGwMY2Nj8Pl8JCUlYdq0aSCEwMXFBYaGhhLPo6YgbMjRUqxbtw7x8fHo0KEDzSS/efMG4eHhCAkJwZAhQxAVFSWiJ4uLixNxo20JSkpKpGakpkyZgh49euD69ev0BJdylHN2dpZYn7CwMMaW9aZw+fLlZhmpzp070y1+z549Q3h4OG7duoXY2FhERUW1ePEiNTUVp06dkur4JDFS1AJpTU0NNm/eDGNjY8jJycHX1xfjxo1rESPVGK9evZLacGXlypXYtGkTunXrRrdRP3z4EOHh4cjJycHo0aMRERFB67cA0A6d0qC2thb19fVSM+T/4p+Df9Qk69atW1i4cCF69eqF+Ph47N69GyoqXcDlejfJSCkoiLb2mZmZwczMDKGhoWjdurVQu4wDJkwwBiBgihq73gEUIyW4eFFtgHw+HxcvXkRERAS6deuGtLQ9IvotwUqbpNDi0xg3bhw9AXv+/Dm2b9+OwsJCfP/+nXF1s7KyqkFHJmrIIScnh9atW8PX1wcTJkwQ0m91h48PtxlG6ldrH4vFgoWFBSwsLBAeHo7a2lp4enqiffv2cHZ2ppm69+/fM2oIhEOLBfqtLeDz+fSKj6qqKg4dOgQbGxv679IUI3Xu3DmMHTuWdvx5+PAh1q5di58/S5Cby1wjSaHF8vLyaN++PbhcLoyMjLBz505s27YdvXr1go+PD27evMnItghCi9uK1Mja2hrW1taIiIhAWVkZ3QbI4XDo/vTs7GxamycMYUMOLS0taGlpgc/n48iRI1i4cCG6d++OY8eOYcaMGSI1aiq0eNSoUbS1+O3btxETswJlZWXIz8/Drl3iNaqpqWG0iFdUVISKSmd4enrAwMBASL/VDz4+PhIZqcYW8TIyMpg9ezZmz56NyMhIFBYWws3NXUS/BQAvX75iXAkUWMQLmCsqhLWurg4HDx7EvHnzoKqqirNnz9JideHjYDIDuHTpEjQ1/6D3Rem3qqqqUFBQwPjdEDBSVWITuk6dOqFXr15wdXWFnp4eEhISkJ+fjyFDhsDb2xuZmZmMOrLGocWysrI0wxEdHY1v376Bw+FARUUFXl5e9O/x4sUL+m8rDCq0GPjVBihob96LuXPnQlVVFZcuXRJbOJAUWnzlyhWoq4+kz1lqQaqmpgaFhYUNLJvoJKuurg4VFRViD3U9evSAuro6+vXrB3Nzcyxbtgzfv3+HtrY2IiIiWsRINUZkZKTUGqnnz5+jS5cuaN26Nc1uVlRUYM2aNbR+KygoSKwFsaWhxcLYuHGjVIxU3759MW7cOAwYMACmpqY0Q2FoaIjQ0FCJ2pXi4uIWGXI0RnMW8SwWC56envD09ERZWRlWrFiBpUuXon///rh8+XKLDR8ahxa3BJIs4gcNGoR9+/bR2/X29sbPnz9hamqKJUuWYO/evc0yUo0RExMDV1dXqcZQ7Y+ysrLw9/eHv78/iouLERUVhR07dkBFRQXLli0TO2fevn37f24Rr66ujilTpkBNTQ36+vpwcXFBeXl5s/qt/22NFIU2bdpg4cKFWLhwIfLy8hAREYE5c+Zg4MCBePjwIUaPHt2i/TQOLW4JqPbHxosVo0ePpvVbGRkZtH5r5syZCAgIwK5du3Dy5Emp9nXu3DmpA8f/xT8MTOFZ/6/+/U/DiLds4YiFemZl7SFc7lhiZKRAVq60FQslDQubRm7f3sa4PeFQz7y8syQ62oqw2erE03MU8fPTZRzj76/HGIJMhRZXVd0kiYm+hMNRJz4+48iVK+vJiRMRZMMGZ8bteXhoSggtvk4sLXsRL6/RxM1Ng+zdG0QH7e7Y4UnS0xcybo8pkPfJkyTi7T2GGBkpkHXrZovtLyysZaHF376dImFhFoTNFvxukmrUXGhxRcUNsmOHB+Fw1MmcOTrk9u1t5MyZaLJmjQPj9ry8RjOGFldU3CDTp/doCAX+gxw6tJgOvI2P55K9e4NaXKN793jE03MUMTRUIFu2cEhZ2VWRz6OiLMnVqxuardGnT0fJ0qXmhM0eQfz99Yi/vx7jmOZCi0tLr5BNm1wIm61O/Px0yYMH8eTcuZVk9epZjNuTFFpcUXGDWFioEnd3TeLpOYqcOBFB12jXrjkkNXUe4/YEgbyiNbpxYzNxd9ckhoYKZOdOT1JRcUPk86ZDi38FMb97d4iEhEwkbLY6CQoyklij5kKLf/y4SNassSdstjoJCDAgz56lkosXV5OVK20k1Ig5tLii4gaZOrVbQyjwGJFQ4ZQUf5KUNJdxe25uGmKhv5cvryVubhrE0FCBJCXNFfu8udBi6v9ZWXtIUJAxYbPVSUiIqcTvWtOhxSNIfv5ZsmKFNWGzR5DgYGPy6tU+cuXKehIdbcU4hssdyxhaXFFxg0yZ0pW4uo4k7u5a5NixY4TC+vXrSXR0NGFC49Di+vp6sm/fPqKrq0s6duxI1q9fzxj6KQmSwmabQnOhxR8/fiSurq5EW1ub2NnZkRcvXvyvhBa3FHp6eiKhxfX19SQpKYmMHz+e6Ovrkx07doj9zvPnzyepqalS7ScrK4tMmzZN6uPT1tYmb9++JU5OTkRbW5s4OjqSt2/fNjmmpaHFwtixYwdZunRpi362vr6e7Nixg2hraxMlJSWSlJQk1XnxO+fR7NmzyZUrVyR+npWVRezs7Ii2tjZxdXUlnz9//l8JLW4pDAwMREKLa2tryfr164menh4xMjIi+/btE/udFy9eLHVo8bt378jkyZOlPj4tLS3y+PFjMnPmTKKtrU24XC7JyclpckxLQ4uFkZSURBYsWNCin62uriaxsbFk3LhxRElJiRw5ckSqfS1evFjq8+hf/GcC//Qw4pKSEigoKIqFeg4bNhRdu3aFq6srSktLsWTJEtTU1GDChAmYPXt2ixgpAOjSRYXWwHh4eKCurg5sNhsjRoyAtzcXnTopiWVtCeP06dPQ1NQU02/xeHG4ePEiRo3SRHZ2toh+SxIjBQApKamYPXs27O3tUV1djd27d8PT0xPt2rVDbm4uDh48KDYmJ+c7o0W8hoYGundXBYfDQXFxMR0KPGnSJNja2uLDB2ZG6vHjxyKtfaqq3REZGQEAcHNzQ5s2bcDhuEJT8w94enpCUVFRLGtLGJRFPGXj7uvri5ycHPB4PFy5chVjx47Fp0+fROoriZECgD170uDg4ABHR0dUVFTQphKKigrIyfmOAwfSxcbk5uYyWsSPHTsWf/75J5ydnVFYWIh58wSalGnTpsLKyooxawsQrJILG3L07t2b1ui4urqidevW4HBcMW7cWLi7C/RbFCPVVGgxZeMOCFbUeTwebt68BR0dbeTk5EBV9Zd1P5W1xWQRv2/fXsyaZQ8XF2eUlpbS+i0lpY749u0bvUIsjF+MlGiN9PX1ceXKFTg6zkZ+fj6t37K0tMTUqVMZs7YAgbZFWEtF6bcAgMNxRatWoBkhSr9FHUdTocXCbYDZ2dkNocB3oaenh/z8fJF9CpwNmUOLDx48AFtbO7i5uaKoqBgJCfHYu3cvOnfujM+fP9MuaMIQtK2JG3JMmDABd+78hVmzZiE3N5fWb9nZ2WHixIl48eIlo3OawJCjM/162LChtBsgm80GIQSurq6YMGGCSDyFcNaWMAQW8YNE2gBfvHiBuLg4PHjwAIaGhvjx44dIPaisLSaL+MOHM2BtbQ1PT0/k5+cjLCwDK1euRK9evZCdnY2//vpLbExBQQHatGkjsorOYrEwe/Zs3L59G1wuF58/f6b1W4GBgbCwsBDbDoWmQoubwufPn5sMLe7Tpw8dUHz79m0sXLgQN27cgLW1NYqLi1uk3wIEFvHSrmozWcSzWCw6w7GsrAyxsbHQ09NDx44dERISAlNTU9y6dYvRCbYp/I5FPBVaPGDAAOzZsweAoJVtzpw5KC4uxoQJE7Bs2TKRtjtpQouFIQ0jxWKx4Ovri3fv3sHJyQlZWVnQ09ODsrIyli5d2mTb1//EIr4p7dKwYcPo+/KZM2fg7u6O+/fvw8nJCVVVVS1uKWscWtwSlJWVAYAII9XYDTAqKgqbNm1C165dERYWhnHjxiEzM1NqjdTvWMRfu3YNAwcOxB9//IEjR44AAI4cOQJHR0dUVlYy6rd+x5ADEEhHWtr+2KZNGyxevBjl5eWwsrLCuXPnsGrVKvTs2bNJ/RYgYJMVFRWlPo/+xT8MTDOv/1f//idM1pEjy8inT0cZPxNeJSfkPqmpuU2SkuYSG5t+xMREiXF1vTlGivr/uXMribf3GOLqOpKEhExshpG6IvZ+RcUN4u7+B/n77xQSGDiesNkjyJo19qS4+BLZscODHDy4iHF7TGwLIffJ06fJZNKkzvQKd3b2AfqzsDALcuvWVgk1Uhc7Lh7Pi9ja9iempkqMTNa8eQbk/fsMCTUaQf//xIkI4uk5iri7/0GWLTMna9cyM1KenqMYGamqqpvEzU2DPHgQT/z99QibPYJs2uRCSkuvkLg4b7JvX7DE34mpRk+eJJGJEzsRNludLF1qTj59OkZ/FhExnVy7trFFNSovv0a2bHEldnYDiKmpErl7lyc2Zv58Q5G/gaQaHTy4mLi7/0E8PDRJVJQVWbXKjvEYvL3HkKKii4w1cnUdSW7f3kbmzNEhbLY62b7dnVRUXCeJib5k9+5Aqc6jhw8TiampEmGz1UlY2DTy7dsp+rPoaCuSmbmuRd+1kpJMsn69I12jJ0+SxMYEBRk1yUgRcp/U1t4h+/YFEzc3DeLlNZqsXj1LakaqpuY2cXUdSa5cWU98fMYRDkedJCT4kKqqmyQpyY8kJfkxbk/A2t0We//ePR4xMelI2Gx1Eh1tRfLzz9KfrVxpSy5cWNWi86iw8DxZudKWzJqlRszMlElW1h6xMQsWTGB8X3h7guuaH3F1HUm8vceSTZtcmmGkzoq9X1t7h7i6jiTnz8fS17XduwNITc0dsnt3IElM9GXcnpubBqmquin0XiEhhJDz588TZWVloqWlRfz8/Eh+fj6h4O/vT/bt20eY0JhJ+Pz5M/Hw8CDa2trExsaGPHv2TGyMjY0NuXv3LuP2JOHUqVPEzc1NqjEUI5WamkoMDQ2Jnp4e2bJlS7OMm56eHqmoqJBqX4GBgS1mpD58+EDYbDbR0NAg3bt3J2/evJFqX7/DjkyaNIl8/PiR8bP6+noSFxdHDAwMiIGBAYmPjyf19fVk+/btZPny5VLtp6ioiIwfP17q42t8Hr1+/Zo4ODgQLS0twmazGdm02bNnk6tXr0q1n4sXLxIXFxepxtTX1xMtLS2yefNmmk1KS0trlvkwMDAgpaWlUu1r8eLFJC4urkU/+/fffxMbGxsyatQooqqqSr5+/SrVvrS0tKT6eUKaZqSqq6vJ6tWria6uLjE2NiaHDh0ihBCSmJhIFi5cKNV+SktLib6+vtTHp6OjI/J3uXfvHrG0tCRaWlpkzpw5Itc1ComJiVKzbP/iPxf4pzNZnz9/xsyZM8Xef/jwoVhAn6ysLNzc3PDo0SOEhobi9OnTSElJRZcuKrSphCRGSji0mMViYdKkSZg0aRKqq6thbW2DnJxv8PHxgYODA91nXVlZKZK1JYyUFIEhh7q6OjZu3Ag+n49z585j4cKFePXqFTw9vVBXVyfCrFDOhkyC7IyMw4iMjISOjg7+/vsZtmzZiqKiHxg5UgPZ2dnQ1Y0QG8MUWtyuXVtwuVxkZWUhJGQRTp8+hfj4hAb9lg/69u0j0dlQYBH/B12j6dMtMH26BSorq2BrawMVFRXMnesHFxdnmkWsrKxCfX19k6HFo0ePxujRo2n9VmBgIN68ycbcuXPA5/NFVowEWVvMocVHjx5FeHg4DAwMcP/+faxZs5oOBX79+g2jsyFTaLG8vDz8/f3w9m02AgICcOzYMWzbtg29e/eCr68vVFVVUVhYyKgjO3/+l0W8IBT4lxugnZ0dVFRU4O/vDzc3N7o/nXI2ZFo5F1jEm9I27nw+v8EN0A/Z2W8RGBgoViMqa4upRqdPn8Ly5cthbGzcoN+KRllZOXR0dPDq1StGZ8PGjBQg0G8FBQUhODgYPj4+2Lt3H9av34D+/fvB19cX3bp1k8hICYcWC+u3fv78CXt7e3Tp0gWBgYHw8PDEyJGCWjbFSFGhxZSNe11dHdLT0+Hr64u3b98hJGShWI2EnQ0b48KFC1iyZAkmTpyIK1eu0Pqt8ePH48WLrCadDYWhrKyMJUsWY8GCBXB15WDXrkTk5xdg6NAhtBtgXl4+o7NhZmYmHVosuK650vEUTk7OUFFRQXDwAnC53rQGobaWYqTEjUH270+HgYEBrUutrq5uiKfwxIcPHxiZyKKiYobQYoEu68SJE9ixYwfs7Oxw8OBB2NraoqamBjY2Nrh9+zZjNiFTaHGvXr1oTdxff/2FxYsXIzc3F7q6uggPD4eysjK+fPkitVXyxo0bkZKSItUYKrSYMjkR1m8pKioiODhYjLGiGKnGuXXN4datWy22iO/bty9SU1Nhb28PLy8vzJs3Dz9+/IChoSGWL1/epK6mqdBiSWjOIp7FYsHb2xve3t4oKSnBihUroKenh1evXjEy5E1hxYoVdGhxS8HESA0aNAj79+8HIGDhKP2WmZkZlixZAnl5+d8KLV67dq1UGilAYBFvamqKefPm0X+r6OhobNu2TaJ+q7S0FEDzocWNkZmZSecpNgd1dXVkZGTA2dkZVlZWYLPZKC8vh4WFBYKDg5tk3H7XIr6p0OI2bdogJCQEISEhyMvLQ3h4ONauXYs3b97g2LFjUu0rNjZWLB6mOTCFFo8dO5be98GDB2FnZ4eqqipYW1sjICAAbdq0wZs3b6SONfgX/zy0EkzA/v+BsWNHkvv3U6Qe9/XrVwQFBUNevh2MjY1F2mXmzZuHBQsWiN0I+Hw+3NzckZr6a39ZWVnYtWsX3rx5g3bt5MHj8cRarDw8POmsLWFUVlbCz88Pu3btotsAs7Oz0a1bVygoKGDYsGGwsxN3SHN1dUVSUpIYpZyTk4PIyEiMGTMGN2/eRLt27eDo6Ijx48cjPDwC5ubm0NUVb3PkcFxFfifqd925cyeOHj2KPn36wMzMDHZ2dvTDdUBAIObPDxSbMAlq5IbU1FT6vSdPniApKRkfPrxHu3btkJCQINbO6OXlRWdtidaoCnPnzqFzyXi8OHz48AE9eqiiQ4eO6N+/n1j2E/U7Ua59wsjNzUVYWBg0NDRw7949tG+vAA6HDS0tLURGRsLExBTjx4u3hUiq0bZt23D8+An069ePbgOk/i5BQUGYO3eu2A2EqUb37t3D7t278fnzZ7Rv3x4JCQliAnQulyuStUWhuroavr6+SEpKwqdPnxAXF4cvX76ib98+6NixI7p168bo2Ojq6kq7PwojP78AS5YsxogRI/D48WN07NgR7u7u0NTURExMDAwMDBhF10w1qqurw5YtW3D69Bn0798PlpZWmDZtKl0jaiLFdLNsvL0bN25g3759yMnJgby8PJKSksRynLhcH8TGrhSbMNXW1sLb2xvJycl4+/Yt4uPj8f17LgYOHIBOnTqhQ4cO4HA4Ysfg5uZGu/YJ48ePH1iwYAGGDRuG58+fQ1lZGR4eHhgxYgRiY2OhpaXF6CjJ4XBE/u7UsW3atBlnz/4JNTU12NraijhfLViwAB4enowTpsY1unTpEg4ePISCgny0a9cOycnJYsfO5fpgxYoYsYlbbW0dvL29kJycjBcvXiIxMbEhnmIolJSU0KZNG0YXOXd3d+zcuVPsb1FUVIz58wOhpqaGN2+y0bVrF3h7e2PQoEFYs2YNNDU1G9mFywFQh46ODm7duiVyfauqqkJQUBAOHDgATU1NBAQEiNi429nZISQkpNkJE5/Px/79+xEfH4+8vDwoKCjg9u3bLcrfAgTn8/jx43H79u0W/TwFfX19XLp0ifFh89OnTwgLC8PLly/Rr18/REZGYsiQIZg/fz7GjBnD+N2VhBcvXmDhwoVSO7vp6Ojgzp07AAQ1Sk5ORmpqKgghcHZ2hpeXl9j9ZtKkSUhMTJQqU2vbtm3Iy8ujcwdbguLiYkycOBFDhgxBdnY2Bg0ahOjo6GbNC7S1tXH79m2pWq9mz56NOXPmYPz48U3+HBXfkp6ejpKSEsjLy4uds02Bz+dDX19f6vNo/Pjx+PPPPxknTC9evEB4eDg+ffqE4cOHIyoqCr169cLixYuhpqZG5/W1BO/evcOcOXOkNv8QPo+oa//hw4fRpk0b+Pj4wM7OTqxGU6ZMwZYtW6Rq4UtMTMTr169pt8iWoKysDPr6+hgwYABycnIwatQoREZGirgBSvqdpPnbAoLrvLOzc7MOhlVVVVi/fj1OnToFWVlZWFlZISgoqMX7+Rf/2WjVqtUDQohY4vY/gsm6ePEi4uJ4aN++Pfbs2Qtvb2+0aSOHWbPsJDJSJ06cwOjRo0TeGz58ONavXw9PT09YWlph8eLFqK2twYQJJpg92wE1NTVonLVFQWARL3CfEmRSCFb6nz9/Dn9/f7x9+xbv37+Ht7c3zUQIZ201Bo8XB1dXV+jo6MDLywu5ubmIi4tDYuIufP78CWy2i9iYxjoyCiwWC69fv0ZiYiK6deuO3btTaf2Wk5MTfv5kZqQEFvGaIu/98ccf2Lx5Ezw9PWFubk7rtyZPngwbGxvU1taJZW1REA4tVlVVpfVbjx49RlDQfPTp0wffv3+Hp6cnXWPhrC3xGvHAZrNpvVhOTg527tyJ7dt34MuXz4wPkYKsLfHQYhaLhXfv3iE+Pg6qqqrYtSuJDidms9koLPwh0dmwsUX8uHHjMG7cOHh7e8PIyAj+/vPQqhUwbZoFLC1noLa2Vixri4JwaHGfPn3o1cc7d+5gyZIl6NOnD37+/Ak3Nzd64iZwNmSuUVwcDy4uLrRW4MOHD7Qb4Jcvn+HhIX6zzsrKYgwtlpGRwdevX8Hj7UT37t2RkJAAN7cMKCl1bMhSkuxs2HhSYWBgAAMDA3h7e0NXVxdz5sxB69atYWVlBXNzc9TX16O2tkYCI/UrtHjgwIF0Pg9l496nTx/U1NSAzWbTk4WmGKm4uDg4OTnREylKv5Wbm4evX78wPtAwMVKAgE3Kzf2Obdu2o3v3boiLi8OePXsb3Bi9JGZtMYUWUyGsXK4PNDU1weVy0aZNG9jZ2cHU1FSisyEApKf/sogX1m9dvHgRMTEx6NevH80OUjURztpqjISEeDg6OtLf36ysLDpX8OvXrwyOftV49uwRunXrJnZ9a9u2LfLy8nD27Fn07NkTYWFhWLFiBXr37o2IiIgWM1IsFgtOTk5wcnKCiYkJxowZg/Hjx6N9+/aYP38+pk2b1uR4SaHFTaE5i/g+ffrQzNjNmzcRHByMgoICfPjwAWFhYVLtKzw8/H9sEc9isWgNcFlZGVauXAk9PT0oKSkhJCQEJiYmvxVaDADp6ek4f/68VGNWrFgBf39/ehHk0qVL8PX1RXFxMUxMTLB06VKx++urV69+yyL+3bt3zU6wAMF1zc/PD35+fpg4cSL69+8PPT09dO7cGUuXLmXUIwtDUmhxU2jOIr6xfovS33369Alv3ryRal9hYWGMzqNNoTEj1Vi/FRkZiY0bN6J79+5Yvnw5xo4d+9saqd27d/+WRbyPjw8dV3L48GHY29ujqqoKlpaWCAoKEou6aGlocWO01CJeOJ4iKipKasbsX/xDwdRD+P/q3+9osvj8e2TLFo7Y+/n5Z4m7uyaZNEmFBAcbk9ev94t87uGhSUpLxTVS5eXXiLu7Jv2acgN0dR1Jpk7tLlHjwGar065swv++fTtJ5szRJvX1d8mff8YQb+8xxM1Ng6SlBZLQ0KktcjZsrJXx9h5LAgIMGvRbDrSOad48/SY0UuLb+/btFHF1HUkmTepMQkImijn+SXY2FOjIhF/v2OFJOBx1Mm1ad4laGUn6n2/fThFfX60G/VY4rd86eHARCQuzINevb5KqRk+eJBF3d80G/ZY6rd8i5D4JCDBoViMl/O/Ll+OEw1EnZmbKYvotQiQ7G1I6Mup1aekVsnkzm7DZ6mTGjJ5k5UpbqWqUl/cn8fEZJ6bfOn48jERFWZIrV9ZLVaNnz1Ib3Bu1CZutTnbs+OUGOH++odj3Rfj4Gr/37t0h4uw8jEyc2ImEhVmI6LcIkexsSGmkqNfFxZfIunWzCZs9glhZ9ZaoS5OkkSosPE+8vceS2to7ZO/eIOLmpkE8PUeRM2diyIoV1uTSpTVS1ejly73E2XkYrd9KTPSldUdBQcbkxYumNVLC/16/3k/XaMUKaxH9lqBGY8XeY6qRQL9lQ9hsdWJj00+im6SkGv34cZF4eY2mdamuriMJlzuWXL68lqxePYucO7dS4u/U2LlV8Hulk9mzBwvptwLp85fDmS5RI8Wk2/jrr7/ImDFjyOzZsxnHSEJtbS3R1dWlX3/+/Jm4ubkRLS0tYmtry6jfIkTc2bAlmDdvHtmzZ49UY/7++2+irq5ODA0Nib6+Ptm6dWuLHMd+RyNlZmZGPn/+3OzPvXv3jri4uBBtbW0yatQo4u/vL9V+ioqKiKGhodTHJ8m1r76+nvB4PGJgYEDGjx9PEhMT6Z+zt7cn169fl2o/586dI2w2W6oxjV37Xrx4Qezt7Ym2tjZhs9kStWf6+vpSa6RCQkJIQkKCVGNevXpFBg8eTOu39uzZ8392Hpmbm5Ps7Oxmf47Sb2lraxM9PT0yd+5cqfZTWlpKDAwMpD4+SecR5Qaoq6tLJkyYQDIyMujP2Gw2OX/+vFT7uX79OnFwcJBqDJ/PJ4sWLZJqzL/4zwf+qZqsZ8+eiQRYUqBWdw8fzsDnz1/A48XR7TIuLi4gRDIjNXXqr9VNYTdAqtXD1dUVXbt2hZeXNwYNUmPM2qIgCC12AYvFgrm5OczNzVFdXY20tDRcvXoV+fn5qK2tFVlxe/RIXCNFISUlGUuWLEa/fv3A5/Nx9uxZLFiwAHV1dcjPzxfTnwGQGFqsqtodMjIyyMjIwNu3b7Fp02YUFxdBQ0MDbDa7RYwUgAY3QB/4+vrA2dkZlZWV4HBc0aOHKrhcLvr16yeWtSWMuDgenJycGvRb0zF9+nRUVlYhJSUZV65koqCgADIyMiIukMJZW42xa1cSli5dgoEDB4LP5+PEiRO0JqmgoECisyFTaHHPnj3Rpk0bHDp0CK9fv8bq1atQWlqGsWPHwtnZWaKz4e7du0UCMBUUFDBv3jwAgJOTM0pLS8DhuKJv3z7gcrno2bNnk4wUjxcHBwcHEf1WaWkpdu3ahYsXLyI/Px8dOnSk9YIAs47sV412Yfny5VBTU0NdXV2DfmsuWrVqhby8PEbW7sKFC4xOdf3790e7du1w8OAhPH/+jNZv6enpwsnJSaKzYePQ4o4dO9JZZ05OTigsLASH44oBA/rDx8eH1m8JZ20JgwotlpGRgaOjIxwdHVFUVIzExAScO3ceeXl56Natm0j+kyBrS3Jo8fLlyzFkyBDU1v7Sb8nIyCAvL09i1hZTaPGgQYMgL98e6enpePr0KZYvX47q6moYGhrC3t4eNTXVjMchCC3+5Vgm0G8JHOAcHR3x/ft3cDiuGDp0KLhcbygrK4tlbYnWiAc7Oztal+rm5oaCggLEx8fj3LnzyM3NQ//+/UVWowVZW8pizq2AgOFatmwZRowYIaTf8oKcnBw+fixkZKROnDjB6MqlpaUFJSUlqV3xGocW9+rVi86iunPnDhYvXoy8vDxav9WpU6ffCi0GBHqwjRs3SjUmMjIS8fHx0NXVRUVFBVatWgV9fX106NABCxYsYFwlP3PmjMSAcEmoq6tDaWkp4z2gMfr374/du3cDELjLvnr1Cjo6OjAyMsKyZcuazUWSFFrcFJpipFgsFrhcLrhcroh+q1OnTvj48aPUIbDr169nzKFrCnFxcSJtwUOHDkV6usCB9uzZs/D09ERJSQkmTZqExYsXQ15eHiUlJWCxWFJrpK5evYrY2FipxkRGRiIuLg7Gxsb48eMHIiMjsXXrVnTp0gXLly9ndMjMzMxkdKltChQj1RJtFaXfAgSdQM+fP4eenh6mT58u5gbIhJUrV0rVQgsI8jeVlJQYzyPKDZDSbEZERGDt2rVQVVXF27dvxdq7m8PKlSvpQOeW4v79+1JrQ//FPxf/8ZOsGzduwsND/GJfUVEBqrWvcbuMl5cXWrdujd27d4u0ywCQGFr87ds3dOyoRAv+nz9/jp07d6CwsBDFxT/h7+/HeHxMFvFycnIYM2Ys3r17h8DAQLoNsFu3ruByuUhOTqIfNoXROLSYxWJh6tSpmDp1Ko4ePYpjx47B09MT8vLycHR0pG9Mx48fY3wwqKysoidSmpqa2Lx5E/h8Ps6cOQMOhwMWi4X09HTY2tqKPPjfuXOHMWw2J+c7OnToQPfoP3r0GBs3bkRx8U+UlZXBx8eHsUbv338Qa8lo164t9PT08OHDRwQGBoDH42HnTh569uwBHx8f7NqVhMDAAAk1+hVazGKxYGVlBSsrKxw7dgyHDmXQNu4cDoe+GB47dowxhFPYIp5qA+Tz+Th27BicnBzBYrFw5MgREf0WIGgVYgqvFUyGFLFy5UoAwN27dxEbG4vS0jJUVVVK7LVnCi1WVFSEmZkZvn37Bj8/P/B4PGzatAn9+vVtqNEuzJkzh7FGwhbxMjIysLe3h729PY4fP459+/bB3d0dHTsqwc3NlW4ZzcjIwKpVqxlrRE2kqDbAuro6ZGRkwN7eHq1atcLp06cxZcoUkRpdu3aN8UGooKAAioqKdI/+9es3EBERgcrKStTU1EgMCX358qWYBXWnTkqwsJiO3Nxc+Pj4NLQB5kJNbRB8fLhITEyAt7c34/aEDTlkZWXg4uIMFxdnnDhxAqmpu8HhuEJFpTM8PDzoB+KDBw8hNnal2LYoQ47OnTtjwoQJmDBhAmpra7F//37Y2dmhVatWuHjxosjEHEATocVFUFRUxIYNGwAIrmtLlixFTU016uvrJbaqMFnEq6iowM7ODoWFhfDwcKfbAIcNGwYuV1AzSedlbm4uPWkVXpA6fvw4Pn1KgY6ODnr16oWIiAh6MWzz5s1IS0sT21ZdXR3Ky8vFQoubQ1OhxTo6Ojh58iT4fD727dsHKysr1NXVoVWrVuByuVLthwotlrbdSDi0WF5eHlFRUYiKisLHjx8RHh6O0NBQEf0WIDDkoGzjW4qdO3dKbRFfXFyMTp064dy5c+Dz+UhKSoKFhUWT+i2g+dBiJkRERLTIIr5Dhw50C3BSUhJt5DRkyBBERUU1a/3+f2ERTy2Q1tXVYefOnXTAebt27cBms6Xaz+9axAuHFisrK9MP/8+fP0d4eDg+f/4MdXV1REVFoWfPngAEocU7duyQaj+JiYlShyOXlZVBWVkZmZmZqKmpwdatWzFhwgRav2Vvb8847vLly79lEb9gwYJmf65bt260GUl8fDx9Ho0ePRoRERHN6rd+t/3x5MmTUrf5/ot/Lv6jJ1nV1dUoKytjXC1JSkoSWd2kMHHiRKSl7UF8fBz27dsHb29vyMnJwd7eHoMHD4aiYlOM1K8VlxEjRmDDhg3g8/mwtrbGoUOHsG/fPpiYmMDBwQEyMjJ4+PAho0YKAJKTk7BgwQJ07dqVzlf6++9n2Lp1K548eYKDBw/B29tLhCURZG2JM1LUZ9u2bYeiogJyc3PB4/GQkJCIrl27oKqqSkLWVkojsbpgUmJhYYFDhzKwY8d2pKWl0RM3FxcX9OvXXyIjxePxRFalRo3SxKhRm8Hn8zFz5kwcOJCO/fv3wdzcHLa2tmCxWHjy5AlUVZkZqaSkZAQGBjTotyIBCNwi165di6dPn+LEiRPw8PAQWUWksraYcObMGezYsR0dO3Zs0BbxsG3bNqiqqqKysrJFjBRVI2tra5w4cQJbt25FSkoq3Nzc0aGDIjgcDnr37t0EI8UTeQDW0tKClpYW+Hw+LC0tkZ5+AAcOHICFhQVmzJgBFovVJCOVmJiIuXPnok+fPvTE7fbtO4iJWYFnz/7GhQsX0LNnL7Rr92vFnsraYsLp06fB48WhUyclvH//ntZv9e3bBxUVFRIZqcbGEDIyMnBwcMC5c+ewbt06pKSk4ODBQ1BSUoKHhzt69OghkZGKj48XuSmPH2+A8eMFEzcrKyukp6cjIyMDM2fOxOTJk8FisfDixUvG/CaqRt7eXlBTU6MnblevXkVYWBiysrIwbNgw9OvXT0SLJGCkmN3WTp8+jYSEeCgrK+PNmze08YKa2iBUVJQz6sj27dsnwkgBAv0Wm81GZmYmVq1ahaSkZKSl7YGKigo8PT3RrVvXJnVktra/jHQmTpyIiRMnora2FpaWljhw4ACOHj2GWbPs6L9N46ytxjWnJouUm92FCxewePFivHz5Ehoaf2Dw4MEi5/SVK1egpsb8APLnn38iNTUBXbqY4N69x1i2bBlyc3Mxbtw4lJaWMk6ktmzZ0qyOqjGYsraYwGKx4OzsDGdnZ1RUVGDw4MHYvn07UlNTERQUxHivaIyIiAhGV82mcPr0aYnftb59+9L6rRs3bmD+/PkoKCiAgYEBfv782SJGShgHDhyQWiMVFRVFO6CxWCx4enrC09OT1m/p6+tDSUmQN0fpjig94u9opKRlpA4cOIBr166hb9++uHDhAu0GaGpqiiVLljAySDweT+ya3RyKi4ub1EhRkJGRgb+/P/z9/VFcXIzhw4ejuLgYR48ebZF+CxBMEpiy8JrCpUuXJDJSI0aMoNmkU6dOgcPhoLy8HFOmTEFhYWGzpiKNkZaWhtOnT0s1ZsWKFfRks02bNggODqb1iJqamrR+KywsjHbLbYqRagqvX7+W+u977NgxOhswIyMDDg4OqKqqwsyZM2k3wMZITU1tkaZPGLW1teDz+Yy61n/x34n/6EnWrVu3kJ39BhwOB0OHDqPbZQABZUu1jAjj69evUFRUgJycnFi7TEzMCvTp0xtv3rwRW734+JE5tPjJkycYMWIEVqxYQbcBUqYSxcXF9IqcMCSFFo8cqQ4TExP07dsXQ4cOw8KFC1FXV4eJEydi1qxZOH78uERGighZxHfr1o22IY+MjERVVRU4HA40NDTg7e1NT7j++usOI9siaH9sj/bt28PHxwc+Pj7IyfkOHo+HGzduoF+/vvjw4YOYWcaHDx+gp6cntr2nT59i2LBhWLVqFd0G6ObmDgWF9vj58yeio2MYa8QUWjx69Gh8//4dffv2Rd++fREYGAhCCKZMmQJra+sWMVKAoA0wOjoaABAeHoGKigpwOK4YM2Y0bXgBSGakBBbx8lBUVKRZzM+fvyAujoc7d+6gb99++Pr1K72iSEFSaDH1sL9mzRqUlZVh165d9MStpKQUYWHiY6iVtsY3X11dHZSWlqB3715QUVGBn58fWrUC7QZ4+PBhiYxUbW0tPZHq378/3dISFhaG0tJSuLq6QldXF2w2h564Xb9+HQkJ4jWiWvs6d+5MM7Pv378HjxeHhw8fYMCAAcjNzUW3bqJGJJJCi9+8ycbQoUOxbt06ug0wPT0dnTp1QmlpqURxN5NFvJGREWpra9GrVy+0bduWbgO0sbGBmZkZDh06RE9ahSFgpH4ZcgwaNIg+30JDQ/Hz50+4urrCyMgIzs7O9ATp6tWriIuLE9seZcjRrVs32vL91atXiI9PwNOnTzBgwECxUGCAmZGi6jts2DCsX78eBQUFSEhIwO7daejSRQU/f/5EUJA4Qw4whxabmZlBVlYWV69eRU1NNd0GSMVT7N+fjpiYaLFt/QotVgFQinHjxuH48ePg8/lwdnZGXl4e9PX1YWNjg3nz5tETt8OHD0tkpCQhKipKIhMpCe/fv8fo0aNx4sQJfPr0CeHh4YiKikKfPn0QGRkpYhwhjE+fPjUZWsyEllrEGxgY4MyZM+Dz+XQbqIGBARwdHeHj49Psg2hRUZFYaHFLICm0WEFBgT7/379/j9DQUCxduhQDBwrOR2knm79jEV9fXy/CSFGxAnw+H3FxcZgyZQpatWoFNzc3uvMCECxonDt3Tqp9rVixQur2x/z8fGhqauLMmTO0G2BQUBCGDx+O6OhoiZPk/0uLeAsLC1hYWKCurg4ODg74+vUrjIyMwOVy6XbzpsAUWtwSSLKILy0txciRI/Hnn3/i6dOniIyMxNevX6GpqYm8vDypDTmuXbuGAQMGSDWmMSNla2tLR0ls2LABxsbGaNeuHfz8/ERigKQJLaZw9uxZmJubSzXmX/yz8R89yXr27Dl4PB7dakO1y4wePboJ1z6eGL2voqKCpUuX4tWr11i4cKFYu8y7d2/FHpYpJCcn09S1nJwcvRKYl5eH2bMdERoaRrcBUi1swllbjXHixAls2iSwiJ8yRaDf2r17N9zc3PDlyxc8fvxYbHWFytpiwrt375Geng4Wi4WzZ88iODgYdXV10NHRaTEjBQj0W5GREeBwXOHn50+3AWpq/gFPT0+8fftWoo4sOTkFgYGBACj9li98fX3x7ds3uLiwERERjh49esDX15eeeJ45c0YiI3Xs2DGsW7cOHTp0gJWVFSoqKpCUlAQ2m42vX7/i1atX0NLSEhlDZW0x4ePHDzhw4ABYLBaOHz+BgIBAAATjx4+XmCPVmJECgN69eyEmJgYcDgc+PlysWrUKJSWlGDduLNzd3fHu3TtGZ0NAwLb4+/sDEDzgBAQENBzbR7i7uyMqKppuA1RVFdRZOGurMTIyMrB69Rp06qQEOzs7lJaWIjExEa6urvjy5Qs+fvyATp00Rcbs2bMHJibiVuWA4AGTWi3NyMiAn99csFgsmJqaQk6uLWRlmWvU2JK/f//+WL16FTgcV7i4uCAyMhIVFRXQ19cHm83Gu3fvGPObBDVKoFtOO3USrK4DglZKb29vrFwZCzW1gfDx8aFZLeGsrcY4dCiDtoh3dnZGUVExEhLisXfvXnz9+hXfv38Xm9xQWVtM+PLlCw4fPgxAoKUSuJy2gbn5FMjKStJIxcPOzlbkvSFDhmD9+nXgcFwxa5YdfV0zNDSCs7MT3r171yQj5ekpcPpTUVGh27NevHiJuXPnYNWqVRg2bCi4XC46deoEAMjMvEJnbTVGeno6YmIEFvEeHh4oKCgAj8dDUlISvn79iuLiYjEGcf/+dKFrlCAvCxAwJR8+fMDLly8BAOvWrYOhoSHk5eXh5ub2Wxqpu3fvMmZtNQWqRQ8QuAFSbXm3bt3CwoULkZ+fD319fYSFhdFOsKdOnZL4XZOEuro6lJWVScVIsVgsfP78Ga9fv0Z9fT1iY2Ohp6eHjh07YuHChRJX8KOioqSy9QYENuEtYaT69++PPXv2ABCwl9bW1ggODsaECROwbNmyFumRNm7cyNhi3hR4PB7jNZvFYtH3kJKSEkRHR0NPTw/Kysrw9/cHi8VC+/btpdrX9evXGRdEm0JYWBi9GNTYDdDd3R0lJSUwNzdHSEgIPfm9dOkSnVfXUggWHIulYqRkZGSQm5uLV69eoaqqClFRUdi8eTO6du2KsLAwiZqhFStWwMVF3Lm4KTTFSIWGhtLXaQ0NDfr6ePToUbi7u+P79+8t1m8BwKpVq7Blyxapji85OZlxUius3/r+/TsiIiKwevVq9OjRAyEhIeDz+VJPNm/evCm11u5f/LPxHzvJKikpgaKiAi3GFm6XcXZ2ASF8cLk+cHCwFxHXf/r0SewBHKBCi3vS7TKEkIZ2mUV4/fo1LC0txUKBJTFSgOCGPWPGdAQEBOD58+fYvn07Cgt/YMSI4fTrxqioqBAz5JCTk4OXlyCQWFZWFpmZmUhM3IXu3bvB29sbAwcOxF9//cXI2lGMFHXMlH6rsrIKrq4c1NfXY86cOXBychJpc/jw4YNYCCLwK7RYuA3w9OkzCAoKwtu3b2FjYyMW5vrrBtGPsebTpk1FUFAQHj58iHXr1uHnz58YNWoUnjx5wvjwRIUWC1/85OXl4efnB1lZWdTV1eHkyZPYvn0HevXqCR8fH/Tu3Ru3bt1qkpGiajRzphVmzhRM3FxdXVFfz4efn5+IfgsQTF7Dw8VbXwQW8d3F9Fv+/vPw4cN72NraMdaoqKiIUWj84sULmJubY+HChbhzR9AGWFZWBi2tcXj48CGtyREGxdoJt/YpKipi/vz5SExMRHl5OQ4ePIiNGzehX79+DRO37rh27Tp27WLWkQlPNh0cHODg4IDS0lK4u7uDz+cjICAQHh7uIhPjN2+ymwgtVhHRbx06dAhz5szBhw8fMHv2bLEaAZBoEf/+/QeYmU3CkiWL6TbAyspKGBgY4K+//mJ8eGIKLe7USWBrnZycgvz8PCQnJyMvLw+DBg2Cj48PVFRUcO3aVUaNlICR+jWRooJqf/z4AS8vb/D59QgODoanp5eIhfvLly+aDC2mbNxra2uxd+9eeHl54fPnzxIfhCRZxH//noOJEydi6dKluHjxIhYvXoKammpMmDABN27ckMjaVVeLGnKoqKhg+fLlSEtLw6dPnxoWpAoxYsRweHl5o1MnJWRmXhZadS+lxzZu7Vu+fDmWL1+Ob9++wcTEBPX19bC1tUVkZKTEFjthMIUWtwSSLOL19PRw6tQp8Pl87Nmzh77mOzg44OjRo4w6sqbQ2JCjJWhsyBETE4OYmBh8/PgRoaGhWLZsGQYMGICoqCiR78Lt27dbHFpM4Xcs4isrKzFjxgwkJSUhMTGRtsB3cXGBp6cn49+CsoiXViO1f//+ZtsfO3ToQDPJb968wdSpU1FfXw8Oh9Mi/RY17nc0Uu/fv2dsf6Tus5R+y8zMDDIyMvDy8kJaWhp4PJ5U+/mfWsQrKCjQE5Nnz54hIiICnz9/xsiRIxEVFSXSuitNaDGFwMBAWFpaMn6WnZ3NeOydOnXC1KlTkZycjM2bN8PY2BhycnKYO3cubG1tGbYkuXOjOaSmpjbLSHXv3p3+uzx8+BCzZs1CXV0d5s6di8jISInmSMIoLi5Ghw4dGA2C/sV/L/5jJ1kXL16Eqan4qh51g0pNTaHbAFNSUtGliwr09fUlriqmpKTQKy4A0KpVK0yaNAkTJ04Eh8NBhw4dxNplmLK2KJw6dYqeJAjrt06fPo0zZ85g3rx5IvotQDRrqzGoiRR1I6D0W/n5+SgqKkJpaamYpkjASIk/jLVr1xZt27ZDamoKcnK+Iy6Oh/j4BHTv3h1GRoZNsHYpmD8/kH4tcAO0wLRpUxvaNVrD3d0d7dsrwMXFGTo6Ojhz5gz++IOZkTp+/Dg9SRg9ejRGjx4NPp+PI0eO4OjRYwgKCoK5uTlsbGzo33v3bsmM1K1bt0VCi+/fv481a9bgx48iFBcXoaqqSmzVlYmRAgQTt3bt5JGamtLgTinQb/Xu3RvGxsYSGaldu34xUlSNrK2tYWVlBTabjdraGroN0M3NDaNHj2bM2qJw5MgR+iFCR0cHOjo64PP5OHDgALKz3yI4OBgzZsyAhYUFXSPhrK3GuHHjhkho8e3btxETE4OfP4tRVFSM2to6MeaOcjZsDEVFRcjLyyM1NZVuA1y/fgP69+8HU9OJjFlbghrtEjFBofKaZs+eDWdnZxQXF8PNzR2dOinBw8MTI0eqM2ZtUcjIOESvHhoZGcHIyAh1dXXYu3cvXr9+g8WLF8Pa2poWqwOiWVuNQU2kqAnTlStXEBoaivLychQVFYEwBLgLnA1nib2vrKwMBQUFpKam4NWrV0hISEB+fgGGDBkMU1NTiTfvhIQEEWZCVlYWrq6ucHV1hZOTE3JychqMN1Tg7e2FIUOGMGZtUThw4ABiYgRtucILUqmpqXj16jWWL18Oe3vRBSmBsyFzW9Ply5fB4/EgJycHPp/fMHFbhKqqKhQVFaF169YNP1kNoBaALCIjI+lcG2H06NEDSkpKuHXrFu7fv4+lS5fi+/fv0NHRQXh4OKPGDRBopKTNnmoJI8VisehJckVFBWJjY/HgwQO4ubkhODi4xeYSTRlySEJUVBRD5phAv0W5AV67dg0BAQEoLCyEoaEhZs2a9VsaKWFDjpZi48aNSExMBIvFgre3N7y9vVFWVibiBrho0SKR7xZlFCENiouLwWKxpGp/HDRoEJSVlXH79m1cunSJ1m+ZmZlhyZIlErclzEi1FBcuXBBrQW4MYf0W5Qb4119/wd/fH8uWLWtx7dPS0qQOEhbWSAlD2A3wxIkTYLPZKC8vh4WFBWbOnPlbGqlPnz7h4sWLSE1NhYaGBqKiotC9e3exrC1hrF69Gtu2bUObNm2wcOFCLFy4EHl5eYiIiMC6deugqqqK0NBQWr8FCJ6PqLzHlqKsrAyEEKkYqdGjR0NFRQW3bt1CRkYGZs2ahaqqKlhbWyMgIICxIwEQdHjY2dkxfvYv/nvxHzvJ+vr1K6ytxSdM9+/fpydSVBsgIGAE/P390bmzClatWiXSLkMxUr179xbb3vHjJzB2rKDdy93dHfn5+eDx4pCcnIxPnz4xsi1MjBQguHl/+vQJc+f6YcaM6UhLS4OXlxfatm0LR0dHic6GgtDi9iIXv5Ej1bFp0yaEhYVBRUWF1m+ZmZnBzk5gYy1gpMR1ZMKhxaqq3REREQFAoC8LCgpGly4q2LBhA7y8vGj9FsVISQotHj16NG3jnpOTAx4vDjt38vDly2ds3bpVbIyws2HjGhUUFMDX1wczZsxAcnIyPXHjcNi4ffu2BB3Zd7RvL9r+OHbsWIwdOxaRkZFo165dg34LmDp1CmbOnNkQQNwUIyWYSPXu3QsrVggeUO/du4fFi5dARUUFW7dug4eHO33zboqROnfuHP74Q5O2cf/06RPi4uKwefNmfP36Fdu2bRMb01hHJlyjsrIycLnemD59BnbtSoSbmzs6duwANzd3XL9+QyIj1diQQ1dXF7q6ug36tFZ0G+CMGZaYNm0qWCwWo7MhIHC1ohyaqDZAQDCRCw8Ph4qKCuLj48HhcGghMGWjLym0WF1dnW6/ffv2LeLj4/H9ey5ycr5h+3ZxlyyKbWn8IC4jIwM+nw8PD3dMnz4DiYkJ2L9/Pzp37gxPT09cvXqVsX2JKbTY2NgYxsbGtO7Sx8cHsrKysLW1pSf8L1++YnROEw4tHjJkCK1/uXz5MpYuXQoVFRUkJ6fA2dlJZJ+SGKlLly5hxIgRIm2A8fHxKCgowPfv3xkZciZGChBM3Nq0aQNXVw6mT5/esCCVgi5duoDL5TbhbCgaWsxisTBp0iRMmjQJsbGrUFxcTF/XHBwcYGTUH4Ay7t69y2iH/OzZMzq0WEtLi9ZvHThwANbW1qitrYWdnR38/PxEzt2WhhYLY9OmTfRkpSWQl5eHsrIygoOD4erqirCwMISHh4u5ATbG71rE37lzh5GdFoahoSEMDQ3B5/ORnJyMKVOmQFVVFTt37gSXy23RQ3Lj0OKWQFJosYKCAr3I8fbtW4SFhWHx4sVQU1NDdHQ00tPTceHCBan2FR0dTRtytBTCFvHC+i0ej4fJkyejVatWcHd3B5vNFqmRJEaqKaxbt04qi3hlZWUMGzYMc+fOhbOzM8LDwzF//nwMHz4cUVFREhd/mwstloSWWMTPmDEDM2bMQF1dHbZs2QJDQ0OoqqoiPT0ds2bNatF5dPnyZQwfPhx79+4FgAbXXSdUVFQgLy+PkUGSdJ/s2rUr7YT4+PFjREZG4tu3bxg1ahQiIiJaxEg1RmxsrNQW8cKhxbNmzcKsWbNQU1OD9evXw8jICO3atcO8efPE2Lvs7GypW3b/xT8frZhWZf9fYezYkeT+/ZRmf+7NmzfIyDjM2Gbj7++PkJBF6N1b9KLF5/Ph5uaO1NQUXLhwARkZGaipqYGJiQnk5eXx9etX+gFYGB4enti8eZPYRa6iogLu7gKXtMLCQowYMYJul9m+fTu6devGSHtzOK5ITk4SuYDl5eVh3bp1uHfvHsaNGyei3wIEbR1TpkxhNN7gcFyRmiqoWXV1NVJTU3Hr1i3U1dVBTq4t48N2QEAA5s+fLzZhomqUnJyEM2fO4Pjx46ivr8ekSZPQtm1bvH//HvPnzxfbnpeXFzZs2CA2YaqsrAKHw4aqqiqKi39i1ChNeHp6QkFBAXFxcejYsSMjQ8LhuIowUoBgorlu3Xo8fPgAenp68PHxFfkbR0REwMzMjNHdSbhGFRUV2LUrCffv3wcAyMm1YbxZBgQEYt48f7EbgXCNjh49ijNnzgBoBQuLaZCTk0NWVhajvay3tzfWrl0rNmGqrq6Gk5MTunfvjtJSQRugm5sb5OXlkZCQiPbt5RmZNldXVxFGChDcHDZu3IjHjx/DyMhIRL8FANHRMTA0HM+4GsjhcOgMEUq/9fjxE8jItEbr1q0ZaxQUFIQ5c+aItW8QQuDq6oZduxJx6NAhXLhwATIyMrCyskLr1q3x5MkTRsEzl8vFqlWrxRwMa2tr4eDggK5du6KyspLWb8nJySE5ORksFgscDkdse25ubiKMFCC4EW7ZsgVPnz7FxIkTweX6iGjAYmNjoaWlJeaW2LhGRUXFiIvj4cWLl2jbVjDZYDK2CA5eQDNN4ttzRWJiAvbt24crV66gTRs5zJolsHP/66+/GCdtXK4PVqyIEZswURORbt26oaamBsbGxnB0dISsrCx2796N+vp6uLm5tahGWVlZ2L59B549e4YpU8zB5fqI/E1WrVqF0aNHM7ITwt81akHqwYMPKCvrjPr6emRmZoqNsbW1xaJFiyROmKqqqrBmzRr8+eefaN++PZ15d/LkSal0PnV1dTAwMMCdO3daPAYQtBFevnxZZMJEaS8KCgqgr6+P0NBQWr8FCK6xWlpacHJyavF+nj9/jsWLF+PkyZNSHZ+uri4uXLiAlStX4tKlS1BSErS9Mp3DFCZNmoSkpCSp9GJbt25FYWEhvSjXHC5duoSYmBg8evQIvr6+LdZvAQLW/tatW1KxKg4ODvDz85M4YSouLsaKFStw48YNKCsrY+nSpSgrK8O+ffukyk/i8/nQ09OT+jwaP348/vzzT5EanDlzBhs3bkRZWRnMzc2xaNEikfNs0aJFGDRokFQP72/fvoWfnx/+/PNPqY5PR0cHp06dQmRkJO7du4du3bohNDQUY8eOlTjG3Nwc27dvF7tPVldXQ01NDb1794acnBx8fX1ppj8xMRHZ2dlYtWpVi47r8OHD2LRpE/7++28sXrwYQUFBLdJvAYLvxs2bN6U6j9hsNlxcXCR2zHz//h1hYWF4+vQpevbsifDwcCgqKuLs2bOMTP2/+O9Aq1atHhBCxL4s/5FM1vXr11FbWwMOhwMVlS7gcr0xePBg8Pl8lJSUik2wAAEjNWaMgHqmVrlqamqwZ88ebNmyFWpqarhy5YpIm4Nw1lZjJCcnw87OjtYhXbhwAYsWhaC2thZ5eXk4duyY2Jhv374xhhZ37doV7dq1w6pVqyAv3x5bt25FUVER1NVHwtvbCx8+fGCcYAkzUoBAv0W1cPj6+kJRUREcjiu6d+8OHx8u+vfvL5a1JQyBRbwmbeNuYWGBysoq7N6dip07eRgyZDBu374t0uYgiZECBC2YNjY2sLe3p/VblBvg9++5OHbsqNgYJkYKAFRVVaGoqICYmBi0a9cOa9euwc+fJRg9ehQ8PDwYs7YA8dBieXl52g3Qx8cHbdu2BYfjil69esHX1we9evVqWGljDmM8d+4cNDRGgsViwcbGBjY2NigrK0NSUhIOHz6CoUOH4v79+yI3JkmMFCCwiLe2toajoyP4fD4OHz4Cf/95aNVKMPk+fPiI2BhJocV9+/ZF586dERkZiTZt5Gj9lo6ONlxd3VrESAG/9FtUjWRlZcHhuIrotxpnbQnjwoULGDFiuEgb4M+fP5GYmIiTJ09i+PDhePr0qYh+q7q6GtXV1RIt4q2sZsLFRRD+fPDgQdoNMDc3F4cOHRIbIym0WE1NDd27d6eZzLCwUFRWVmL8+PFwdnaWyEgJQot/tT926qREu/txuT5o1UowwRgyZDC8vb3pSRCTsyHwK7RYUFsOOBwOfvz4gbi4OJw7dw4jRqjj5cuXIqYdlI5MUmixpaUV3NxcUVtbiz179jQYb8ghPz8PBw4cEBtTVFTEGFo8fPhw9O7dC5aWMwAAixcvaliQMsXs2Q548eIFFi1aJLa9xhbxXbp0aTjf5GBiMg98Ph86OjrQ0tJCREQEzT42x0i1bdsWYWFhCAsLw5cvXxAREYHDhw9DV1cXz58/b5F+C/jftYjX19en9VtpaWmwtLREfX09HBwc4Ovr+1uhxb9jEX/mzBkMGzZMzA2Q0lsNGDAA0dHRItcyaUKLhSGtRbypqSmduVhTU0PrtzgcDtzd3SU++L58+VJiaHFT+PDhQ5OMlJKSEt16/erVK0RERODcuXMwMjLCp0+fGLXVTIiLi5PaQlwSIyWs39q+fTsmTpxI67dmz579W6HFYWFhjN/PpnD58mWoqak1dGgIOk8o/dajR49gampKtwFSoLpbmO6TaWlpcHJywqpVq+g2wPXr10NVVRUfP37EtWvXWnxsNjY2ePDgARwcHFBWVgZjY2O0bdsWc+fOhY2NjcRx79+/pxkpafD69WuJEyxAoN+iFh3v37+PsLAwvHnzRqrf6V/8F4EQ8v+bf2PGqBNC7jf5j8+/RzZvZtOvs7L2kKAgY8JmqxMPD02yZo094zh3d01SWnpF7P3y8mvE3V2T5OX9SaKjrQibPYIsWDCBvH6dTrZudSWHDi1m3B6Ho07q6++Kvf/uXQaZPr0H4XDUiY/POHLlynr6s9DQqeT27W0Styf8ur7+LjlzJprMmqVGTEw6kr17g0ht7R2Rn/H31yMfPx4R21Z9/V3CZo+gXz95kkTmzTMgbPYI4uMzjqxePYvxGDw8NElJiXiNKipuEHf3P8i3b6dIWJgFYbPVyeLFZuT9+wyyY4cnSU9fKPF3anzMhNwn799nkGnTuhMOR53MmaMjUpOwMAty8+YWxu2x2eI1Onp0ObG3F9QoI2OJ2N9k3jwD8u7doWZrdPfuTjJ3rg5hs9XJvHn6ZOVKW8Zj8PIaTYqLL4m9X1V1k7i6jiSfPh0lS5eaEzZ7BFm+fAr58uU4iY/nkr17g6Su0ZQpXQmbPYL4++uRhw8T6M+ioizJtWsbW1yjgwcX0efRiRMRYjUKCDAgb96kN1ujGzc2E19fLcJmq5OgIGOycqUN4zF4e48hP35clFijd+8OkZCQiYTNVicREdPJ9++nSWKiL0lNnSdVjd69O0QmT1YhbLY6CQgwIM+epdKfrVhhTS5fXtuiGtXW3iG7dwfS59G5cyvFahQUZExevtwrYXu/anT58lrC5Y4lHI46Wbp0MomJmSmxRoWF58Xer6m5TVxdR5IXL35d11autCGFhedJSoo/SUryY9yem5sGqam5LfZ+dvYBYmamTNjsESQ42Ji8fr2f/iw21pacPx/bohpVVd0kiYm+ZNasgcTEpCPJzFwnNmbBggnk+fPdjNvT1R1LCCGkvr6e7Nu3jxgbGxNdXV3i7u5OvLy8iDSora0lOjo65M6dO8TCwoJoaWmRefPmkcLCwibH6enpkcrKSqn25e/vT/bt29einy0vLyehoaFEQ0ODdO7cmZw7d06qfWlra0v184QQMnHiRPL582eJn2dmZhJzc3OipaVFQkJCyM+fP8mWLVtIeHi4VPv58eMHMTQ0lPr4tLW1SX19Pf3658+fJCQkhGhraxNzc3Ny9epVsTH29vbk+vXrUu3n7NmzhMPhSDWmvr6eaGtrk7Nnz5JJkyYRbW1tEhoaSsrLy5scp6+vT8rKyqTa18KFC0liYmKLfrawsJAEBgaSP/74g6ioqJA7d+5ItS8tLS2pfp4QQiZNmkTevXsn9j5Vo2PHjhETExOio6NDVqxYQaqrq0lcXBxZvHgx4/YMDAxISUmJ2Ps3b94kI0aMkPr4dHR0RM6j79+/Ex8fH6KlpUWsrKzIo0ePxMa4uLiQixcvSrWfa9euEQcHB6nG8Pl8smjRIqnG/It/HgDcJwzzmv84Juvvv//GyJG/TAKGDRuK9esFOgcbG1u8evUKbm5umDBhAmbPng1ZWdkmGSlBaPEUdOnShV5FfP78OXbu3IEHDx5iyhRzFBUVi6ywf/36lZGRAgQhw8uWLYO2tnZDuwwPSUnJ6NatKz5+/ISoqCixMY8ePRIzm2CxWJgyZQr+/PNPrFgRg8zMTDp/y9HREfr6+hKdDQUW8b8MOTQ0NLB58ybw+Xw6H8Ld3R2TJk2Cra0tZGRkxLK2hEGFFlM27oCgZ3rjxk14/PgRZsyYgdLSUhE2i9KRMdmfJyen0MJfgX6Lh507eejZswfevXtH70MYjx8/FllFo2pkZWWFzMwrCA8Px6VLl+Dm5g5FRQVwOByMGTOGMWsLEA8tFnYDtLGxQUlJCTw8PDFt2lRYWVmBxWI1yUhRFvG9e/em9Vt3795FbGws/v77GWxtbVBRUSEivs7NzZUYWpyWloYlS5Zg/PjxtIvbpk0CN8A3b94wZm0JtC2iocUsFgt2dna4ffs2li1bStdISakj3NzcoKGhgaKiIkZGqnFosb6+PvT19VFXVwcbGxsUFhbAy8sLlpaWmDp1Kl2jmpoaiYyUiYmpmH4rMjISz58/h4ODA6qrq0WCHAsKCiTa6O/duxeLFi3ChAkTkJ2djfj4eOTm5kFNbSBevnzJKGannA2FISMjAxcXZzx+/BjBwQuQmXkZe/fupfVbw4cPl8hINbaInzBhAiZMmIDa2lrY2tpCSUkJXK4P7Oxs6dXvxllbwqBCi4cO/XVdu3TpEpYsWYqXL1+CzXZBbW2tCPsk0P8wW8QfPHgIISEhmDhxIrKyskTiKZ4+fcqYtcUUWiwnJwcPDw+8ePEC8+bNQ2ZmJpKTk9GtWzd4eXlj0CA1xqwtQGAcoqUl0P+wWCya3ayqqoKGhgYuXrwoNqYpUIyUtrY2Tp48CT6fj/3792PmzJmoq6vDrFmzMHfuXJFzpqCg4P/cIl5eXh5RUVHIyspCZGQk9u3bh7CwsGb1W4Cgi4Cpdk2hJRbxlJ6Qz+cjKSkJFhYWePr0KaKjoxkdPCVBOLS4pWCyiO/QoQPt9vnmzRuEh4cjJCQEgwcPRlRUFPr169csI8WE9evX/7ZF/OTJkzF58mTU1dWBx+PRBjkeHh5wcXEROX7KkENai/hr1661uD1OWVkZGzduhKOjIwICArBu3Tp8/vy5Wf0WILhWMOldm4JAk/6T8T6ZmJiICRMmwNLSEpaWlqipqcHWrVsxYcIEZGVlMX43qKwtpu6WkydPMsoymgKTRXy3bt1oB9OHDx8iIiICOTk5GD16NCIjI9G1a1e8fv26yZZZJsTGxjLqRpsCJfP4F/+CCf9xk6ybN28yXuwrKiqgpKSExMREkXYZOTk5tG/fXqKV7r1798XMJkaMGIHg4GCsXBmL0aNHi7XLxMXFMTr3AMDHj78CKwXtMoKH4UOHDuHJk6fgcDhQV1eHt7c3/bAunLUlDMqQQ01NDWpqavDy8kJubi54PB7Wrl2LVq1a4e3bt2J0PZW11RjV1TXo1KkTdu3aRbcBenh4on17QaiupKytO3fuiGm7NDU1sXjxIsTExGDw4CGYP38++Hw+Jk+eDDs7O8asLQrCFvGqqqqIjIwEIMjkuX//PjgcV7oNkJoYN3Y2FK5RcXExhg0bRgu5v379iri4OMTExKBVq1b4/PmLWAuppNBiwQShE5KSkmj9FuUGqKSk1ISzobhFvJaWFvr27Yvw8HB0767a4DrYCtOnW2DGjBkNzobMmg3h0OI+ffrQrUD79u3DrVu3wOFwoKOjA1dXNzoUeNeuXfDz82OsUWFhITQ0NOiJ5fv37xEfH4/w8AiwWK2Qk/Mdqqqik9jDhw8z2p/X19ejc+fOSEpKQmlpKRISEnDo0CEoKSmhc+fOErO2bty4IfYgZGBggCFDhmL58mVQUlLCnDlz0Lp1a8ycOROTJ09mzNqi8ObNG3phRE1NDWvWrAEApKXtwdWrV+Hm5gZ9fX24uLjQE7fGzobCKCgowLhxYzFu3Fh6+/Hx8Xjz5g1at26NgoICsVY9KmuLCcrKykhOTm5oA4xHWtoeqKioQEVFRaJL1pUrV8T0b6amphg1ahQWLVoEFqs13QZobz8LJiYmjFlbFF6+fElrV6l4CkDwfcrNvQA3N7cGl9PZdNZZXFwcnbXVGFSGFNWaSy1IffjwAa1atRJbkAIE3+uoKHHTEhkZGXTu3LnFbVoUMjIycPnyZfo1i8WCk5MTnJycUFlZiTVr1mD8+PFo3749goKCMHXqVERGRoLL5Uq1n/+JRbyVlRWsrKwACM77oKAgFBQUwNDQEKGhoWJuZy0NLRbG9u3bWxx8ymKx4OnpCWtra0yfPh05OTnQ19eHkpIgb645i/Bbt25JbREfERHB2HpLYdCgQdi3bx8AwWIFl8vFp0+faGOfluq36urqREKLW4p9+/aJtD/KyMjAz88Pfn5+KC4uRlRUFHbs2IHOnTtj2bJl0NfXx4oVKxi1jU3hdy3i3717Bzc3N3p/p06dgqurK8rLyzFlyhSEhISILRq0NLRYGE1ZxKelpYlou9q0aYPg4GB4eXnBzMwMd+/exc6dO6GoqIjVq1dj9OjRiImJgZOTE2prayEjIyNiaf47FvHCWVtMGD16NC3PyMjIgIODA/Lz8wEI7uct1W81Di1uKU6ePCl1m++/+O/Bf9Qkq6amBgAYvzS7diVh2jTBREpWVpa+OBUUFGD27NkoKCjA7du3weVy6S/R169foajIzEjt3LkTHA4bWlpamDRpEqqrq7Fnzx54eXnh/fv3jCskVNYWE65fv46EhHj06tUL58+fx8KFC1FbW4uJEydKZKROnjwpFlrcrVs3hIeH06HHW7ZsRXFxETQ0NODp6QlZWVlGZ0NANLS4Xbu24HK54HK5yMn5DhcXZ+Tk5OD+/Qfw8fGhc60EWVsKEgJ54+Di4gIdHR1Mny7Qb6WkpMDd3R0fPnxgtKOnsraYcPv2bcTHx6NPnz44depUw8SNwNx8MoqLixh1ZEwW8T179qStkJ2dnbFmzWqUlJRizJjRcHd3R+vWMqivr2+SkQJE9VufP3+Bq6srPn36hOfPn8PX15dmH5tipKjJpoGBAezsbFFWVoZdu3bBzc0dnz59xPTp08XGMDFSFO7evQsej4f+/fvj8OHD8PObi1atWsHS0hKFhYWM/fFMocX9+/dHbGwsvL29YWtri5iYaJSVlTdM3FzBYrVCbW2tiJifgrBFvKKiIoKCggAIJm6enl7Izs7G27fZ8PX1RbduAofGphipuDgeZs+eDWNjY1q/FR+fgPT0A/j48QMsLa3ExggYKWaL+MePH2Hnzp3o378/0tPTaf2WtbV1E86G4qHFgwYNwtq1a8HlcmFhMR2hoaGoqqqCoaEhvYDQOGuLgnBosbKyMj3RefXqFebMmYNevXohJycHXC6XHs/kbPirRgIbfVNTU7i5uaKgoAAJCQlITd2Nz58/wdZWXJsg7GzYGM+fP8O2bdsxYED/huuaJ+0GKMnZMDMzUyxIlYqn8PHxganpRFqXampqCgcHBxAiMK7o2rWd2PY2b94MCwsLxuOTBEkaKQrt2rVDeHg4wsPD8enTJ4SHhyMyMhLZ2dlSi9L/tyziDQwMcPr0aVq/ZWFhAT6fD0dHR/j4+IDP56O8vFxqjdTBgweltoiPjo6Gr68vff6+f/8eoaGhWLp0KQYOHIioqCixa0hLQ4sb4+PHj4w6WSZQsQJmZmaYMGECpkyZglatWoHD4cDNza3JfVPugdKgOYt4JSUl2uXxxYsXiIiIoPMgHzx4INW+fscinim0mNJJ19XVYdu2bTA1NYWsrCy8vb3phShpQ4sBwbNOmzZt0L59ewQHB9PfrdJSQcYd07PEihUr4OnpCS8vL+Tl5WHq1KlYuXIlSr5/R9nXr3DasQN5jx4BCgpQ6NEDCoqK+PTp029ZxEvK2mKCra0tbG1tMWXKFKirq9NugH5+frC2tm5yrKTQ4qZQU1MDQohI98W/+BfC+I+aZJ06dQrFxcVi7TKAQIA4d664/XlVVRWGDBmCbdu2ibXLFBYWMrqSAcDnz59FQoupdhlNTU3s3bsX165dp9sAvb29oaamJpa1RaFxaLG5uTnMzc1RXV1Np437+vrC0dEJ48f/apM4ceIkNm/eJLY9gUW8aG7S2bNnsWDBAjpksHFwMgCJocUAwdChQ7Ft2zY8evQYmzZtQnFxEf744w/k5eXBxUUyIyVsyNGuXVv4+vpAR0cHyclJOHv2LHg8Hnr0UAWXy0W/fv2aZaSoiRRlL1tZWUnXaO5cP3riS0E4a0sYlCEHlZvE5/Nx/PgJBAYG4tu3bxg5ciRjuwyVtdUYbdrIYsiQwdixYwfu3buHVatWoaSkFOPGjUVOzneJLmKNLeIVFBQQEBCAv/9+Bh5vJw4fPozNm7egX7++tBtgYqJo1pZwjYStb+3s7GBnZ4fS0lIsXboUubm5CAgIgKurm8jk/OjRozTLIwyq/ZGy366rq6Mnbrm5uVBXV2esEZW11RgKCgoYPHgQdu7cSbcBVlRUQE9PDzk5OS1ipACgY8eOWLhwAbKysrB58xbs2ZOG79+/Q01NDT4+PujSpQsSExMlPjQLhxY7OzvD2dkZRUXFWLZsKXJychAUFAQPDw+RVkjhrC1h1NbWora2FtOnW2D6dAvU1tYiPf0AuFwu8vPzRVqXhSEptFhFRQVqaoMQF8ej2wBraqphaGiEL1++YNYs5pyVxoYcKioqWLJkCV69eoW1a9eCx4tDQUEBhg4dCi7XG8rKymJZW8IQnkh5eHjAw8MDBQUFWLZsOb59+4qFCxfC29tbZEKann6AboVtXKPq6mrY2dnCzs4W1dXVSEtLg6enJ4qKihpq9Csvi8KRI0ekniRIytpiQp8+fZCcnIxnz57B29sbixYtQl5eHvT09BAeHs64gCCM/22LeMoFk8Ph0Plb+vr6KCwslDqv6nct4huHFvfvL5hkAwIWlWJxjI2NaTfA3wkt/l2LeOpatnTpUpSUlCA6Ohq6urro3Lkzli5dythGmJ6eLpUhByCdRfywYcNw4MABvHnzBg4ODvD09ERpaSkmT56MRYsWNZvl9TsW8WvWrJEYWiwjI4PAwEAEBgbS+VtbtmxBWVlZk06ATCgpKYGioiIyMzOxZcsWmJqaok2bNvDx8cGDBw8kPh8dPHgQCxcuBJ/PR1hYGAJ9fGA2bBhKc3KwfMkSbA8LQ3V1NcaMGwc7Z2eUdumC0FWrpDbkaCprSxKo+yTVqfL9+3dERERgzZo16NGjByIiIkSkAhRSUlJw+vRpqfZ19uxZ2tDlX/wLJvxHTbI+ffqE7t1VxdplmmakePSFQrhd5sKFC1ixYgUKCgroNkDhENtevcQzswAB07FgwQJ6wiRol9lJ59Qwhd5JCi2Wk5NDaWkpDh/OQHl5OeLi4pCYmIju3bs1tCNKdjYUbhNhsVi0SxGbzcbAgQPh6ekJeXl5ODk5QV9fv0EjxVwjHi+OXtkcNUoTo0Ztot0Ajx8/gby8PHz48IHWbwHizobCSElJRlBQED1hevToMTZs2ICioiLk5eWjc2fx1fXTp89AU1NT7P127dqhoqICGRkZKC0tBY/Hw/btO9CrV0+4urqivr6esfe7cWgxi8XCzJlWmDnTChwOB7169YK7uzsUFAT6rXHjxiEn5zvk5SUzUtRESli/dezYMRw6lIHc3O/Izy+ApeUMkcDopkKLg4KC6BvInTt3GtwAS/H9e66I9ToFSaHFioqKqK6uxsGDB1FUVIT4+PgG/VZfeHh4oLa2VqKzofAKoYyMDOzt7WFvbw8Oh4MuXbrAzc0NSkqd4OHhDg0NDYnOhoIa/QotNjAwgIGBAerq6nDo0CHs3bsPX758QUVFBSZPnkzXqLGzoWiNdmHBggUYNEigF7t+/TrCwsJQUVGJvLxcRvZXUmhxp05KqK+vx4EDB1BYWCik31KDh4e7RI1U49BiWVlZuLg4w8XFGWw2G4qKHRpCgTvD09MLw4YNbZaRoiZSpqamMDU1RW1tLfbt24eLFy/iy5cv9GcUmmKk4uMTEBy8gP6dL168SE/c8vIE+rTGuHTpEmNosYqKClq1EjgV5ubmYufOnXQ8hZube5POhsIrwHJycjTT7uLiQrtTtmrVHwsXxmLEiBG/rZG6d++e1JqJiIgIbN68mf7O7t27F5aWlqirq6PdABufzydOnJA4gZaEuro6lJeXo0cP5uuiMOTl5REdHY3o6GhoaWmhvr4eOjo66N+/P6KiopptWYqOjmYMLW4KzTFSjfVb1MPjly9fGN1tm8KGDRskLOhJRuPQ4g4dOtAPym/evEFYWBgWLFiAIUOGICoqCn379kVxcTFat24tVWgxIJAdMLWLN4WwsDBs3ryZvq7t3LkTZmZmkJGRgYeHB5ydncVq25LQ4sagFhxbwkgpKyvT34cxY8agpKQEOjo6UFdXR1RUVLPn4ooVK8DhcCAjI4OgoCC6rTUyMhJpaWkwNDSEpqamyOSNkih8/fpVsEjw5QtmjRiBbm3bYuuuXQgODsa4cePw/PlzRERE4OH9+5Bt2xafKyulnmxSocXSoHFocffu3ekJ68OHDxEWFoacnBw6Q1NFReW3QosBQRuttO6P/+K/DExuGP+v/jXlLlhcfEnEWSs//yxZudKGsNnqZPJkFXLkyDLGccLOX8L/7t3jkaVLzWnXLA5HnXC5Y0lm5jri56dLPn06JjZG4LbGfIxHjiwj/v56xNt7DHFz0yBpaYG0I1pzzoaN33/6NIVMn96DTJ3anaxbN1vMzY7NZnY2/PbtJJkzR0fo9SkSHi5wA5w6tRs5cmS5hBox/04PHyaSxYvNSEXFDbJjhydhs9XJnDna5NatrWTePH3y/n2GhBox1/zEiXDi4zOOeHhoEnf3P8jBg4vo38PTcxQpKckUG1NRcYO4uWmIvX//fhyxsFAlU6d2J5s2uYjVl81mdqT79u0U8fXVol9/+XKcLFtmTthsdTJtWnepa/TkSRIJCTElpaVXyObNbMJmqxM/P11y7x6PBAQYkOzsA1KdR2fORBNPz1HE3V2TeHhokuPHw+gaNeVsyFSjW7e2NtSoG9mxw5NUVNwQ+VySa19e3p/Ex2cc/VrYDXDGjF7k2LFQqWr07FkqWbjQhBQXXyJr1jjQboBPn6aQ+fMNRRzvqH98/r0mahRDOBx14uamQby8RpM//4yhayTJ2ZBy7Wv8/pUr6+kaJST4kKqqmyKfu7qOZHTty88/S7y9x9KvX73aR4KDjQmbPYLMnNmniRoxfzdevtxLgoKMSWHhefq6RjkattTZUPjfuXMriZPTUOLqOpJwuWNFnBa9vceS/PyzLapRff1dcu7cSmJhoUqmTOlKdu8OFDtnJNXox4+LxNt7DP368ePjZMaMGURLS4sMHz6cJCQkEGnw5MkTMmPGDKnGECLZba28vJyEh4cTHR0dMnHiRHLmzBn6M1NTU/L161ep9rNx40YSFRUl1ZjCwkJiZGREv7569SqZMmUK0dLSIgsWLCA/f/5kHNfYta8lsLW1Jbdu3ZJqTEZGBhk+fDjR0dEh5ubmJDMzs9kxlPujtNDT02vW2Y8QQs6fP0+7AY4dO5bweDyp9vPy5UsydepUqY9Pkvvjjx8/SGBgINHW1ibTpk0TqfGkSZPIhw8fpNrPjh07yNKlS6Ua8/PnT2JgYEC/PnHiBDE1NSU6OjokOjpaoqumpPMoOzubmJubk7///ptYW1sTLS0t4uXlRXJycoijoyN9Hty4cYO4jx9PQqdOJWx1dWLSsSP5dPQoIffvkyBjY/Jy715C7t8nF1evJpYDBhBjfX1iZWVFHjx40OzvRDkbSovx48dL/N4I48CBA7TLqZGREdm6datU+/nx4wdZuXKl1Mf3L/6ZwH+6u+DFixdhZvYrm4JqlwEAe3t73LhxE8eOHcewYUPp8Mx79+41yUiFhCyi2wA9PDzo8MynT//Gli2b4e3NpVfRAdGsrcY4ffo0Nm0ShBZT7TJeXl5o06YNSkp+SmSkpk4Vp5pHjlSnzRco/VZdXR3MzMxgYDBeorMhj8cTae1TVe1OB0fOmjULV65cwbFjR/HHH3/Ay8sLioqKTTJSyclJCAoKotsAfX19kJOTg507d+Lx4yeIi4uj2wCF66CpKc7aAYLVYSq0uLKyEsnJyXBzc0e7dm3x8+dPRkYqNTWFsd9+zJgx6Ny5MxISEnH69CkEBAQCIJg6dSp0dXUZs7YAgf5HuLWvZ8+eiIkRtEDZ2tri8uVLOHbsGMaOHQsPD3fIy8uLZW0JY9euJMyb5w8FBQXaNenz5y/g8Xbi0aPHSE1NBZfLFXGPPHv2LEaOVGfc3tGjR7Fu3Tp07NgRZWVlSExMpB0Tf/78KZGRYsptodps4uPjcfToUfj5zQWLxcKMGZbQ0hrXpI5MuLVP2A3QxsYG58+fx9GjR6GrqwsOh4O2bdvi+fPnEnVku3btwpw5c+g2QECwGhoXF4cHDx5g//798PHxEWG0qKwt5hodwcaNm9CpkxKKioqRmJiA/fvToaTUESUlJU04G4r39RsZGSElJQU7duxERkYGfH19ISsrCxsbG4waNZoxawsA4uPj4eBgT78ePHgw1q0TuAHOnDkTf/75J44ePQojIyM4OztDVlYWL168lKgji49PgLe3V4N+S3Bde/XqFeLjE3D//j2oqHQW0W8BVNaWOGsHAIcPH8GWLVugrKyMgoICxMfHIyUlFSoqnVFS8rMJRkrUkIPFYmHSpEnYt28ftm3bhgMHDsDLy4vWb2lo/MGYtQUIvmvCgex//DEAx48fB5/Px+DBg7Fnzx46b9DPz4/xXBRGZGSk1ALz48ePM7YGAQI2KSIiAhEREfj06RPCwsIQGRmJ3r1748ePHy1ipIRx6NCh32p/FGakDA0NYWhoCD6fj+TkZFhYWKC+vh7Ozs7gcrlgsVh4/vz5bxlyfPr0Seq2RB6Ph3PnzqFXr154+/YtwsPDsXjxYqipqSE6OpqRbdm5c+dvaaRkZGRaxEhROZd8Ph8DBw5EWloa9u7dy+gGyITmDDmYcO7cOYnftU6dOtGZaC9evEB4eDjmz5+PYcOGoaCg4LcMOaQNEo6JiYGrqyv9evr06Zg+fTrq6uqwZcsWmJiYoE2bNuByubC3tweLxWrSkIPK2lJXV8fhw4cBCL5Lzs7OuH//PtTV1aGnp4fta9ZgsacnNEaMwL1795C4axc8vbzQrWtX5Obm0ve9o0ePYuuGDUCvXshrON5v375BU1MToaGhYu7KgMD5ecKECVLVQRpGatasWZg1axZqamqgpqaGvXv34ujRo5g3bx4sLS2bHZ+RkSFyffsX/4IJ/zGTrG/fvjEKg+/du4dBgwbRD8oXLlyk3QB//ChidNmTFFrcpUsXjBgxHEpKHWFiYoKdO3fQ7TJeXt44depUkxopaiIl3C6zdu06PH/+DByOK7p16woul0u3iN29e0/M2RCgLOIV0bp1a0yZMgVTpkxBdXU1UlNT4erKQdeuXXHjxg0x6v3Dh48SQ4vV1NSwcuVK8Pl8nDlzBkFBQaivr0dxcTHWrxfXNFG2ro3NJlRVVTFu3DgoKyvDyMgYGzduRHFxMTQ1R8HT0xPHjx/Hxo3iNWocWtyuXTvMmTMHc+bMwdq161BW9hgcDgc9e/aEj48P3Qp2584dRv2PILS4PWRlZWgnr4qKCiQlJcHFxQVdu3ZltFb98IE5tPjx48cYOFANq1evotsA/f0Fk6aSkp+M9ruCto4isZ7x3r17QV9fH8rKyhg/fjxiY2NRWloGLa1xcHNzk+hs2NgiXkFBAYGBgQCAdevWNWgIXUX0W4Cg9YWpRlRrX5s2beg2wNLSUiQmJmLz5k3o1q0bHj9+LNamKQgtFreIf/78OQYOHIg1a9bQbYCUG2BJSSn9HWxcI6bQ4oEDB8LU1BQqKirQ1dVFeHg4Kisroa+vDzabjcOHD2PVKnFnw+rqatTW1tITqU6dlGgd5Lp16/Dt2zdwOByoqQ2Cjw+XntRcu3YN8fHiFs9UaHG7dm3pNsCiomLEx8dhzZo16NatO7KyssTstV+9es0oZn/x4iUGDhyIdevW0W2AXC4XsrKyKCsrR1iYeF2p42jcVjRkyBBMmWIOFRUVjBs3lm4DNDY2hqOjIw4ePChRRyZsyKGiokIf69q1a/H+/XtwOBwMGzaMXpACBMYWTDqyHz9+QE5ODgoKCiILUnFxcYiOjoaqqiqys7PF/sYvXrxsZBEv0GU9e/YC6urqOHbsGKqqqkTcAOfNm4cZM2Yw1uh3NFJbtmxBWlpasz/Xp08f2t3P398fjx8/hra2NvT19REWFtasfut32x8lhRZTFuIeHh4oKytDbGws9PT06MUXJh1qUzhz5kyLQ5spNLaIHzhwIK3funz5MubMmYOioiKYmJhg6dKl9P0vPT0dFy5ckGpfv2MR/+rVK4wYMYLWasfExEBPT4/Wb0ky3fgdjdSGDRsYvxuNMWzYMBw8eBAAMGfOHBQUFEBHRwdTpkzBokWLmj0/JIUWN4erV68y3qOY2gA3bRJc+8vLyxEeHs64vbdv34q0SQOApaUlFBQUkJSUBFlZWZiYmKDVt2/I1dUFRoxAfHw8ysvLUV9Xh+nTp+PsuXMIDAwEn89HRUUFevfqhYKqKgzW0MCRI0cACMLuDQ0N0a1bN8yYMQNBQUG0sVlqaqrUk80VK1ZIdDWWhK9fv2L48OE4e/Ysvn//jrCwMMTGxqJnz54IDw+XuEiTnZ0tdcvuv/jvw3/EJOvz5y+MKx2A4IsovCplZjYRZmYTUV1dDSsrK0RFRUJOTg729vb0qsjx4yckCkRPnz6DLVs2o3379tiwYQP4fD4uXryIBQuCkZ39FkePHhPRbwG/sraY8OzZMyQnJ9ErkNu3b0dhYSH69++Pdu3aMq4ixcXFgcMRtYiXk5ODt7c3bt68hTVrVoPH4yEhIRHdu3eHjw8XRUVFTTJSlEU8i8WiXYoqKysxc+ZMREZGoH379nB2dqZXOk+dOiWRkTp+/DjN2o0atblBv3Ua8+b549279zh79k/Y2NiI/G5U1hYTnj9/htTUVLRu3RoPHz7EunXr8PNnCYYOHQI5OWZHOiaLeHl5efj5+eHevftYuXIFeDwetm3bhl69esHHxxeFhQWMWidBjVIQGBhA18ja2hrW1tYoKyuDjY0NoqKi0aGDIjgcDn3uNM7aEgY1kerYsSO0tLTA5/Nx9OhRzJ07F+/evUdmZiZmzJghUqPU1FRGRgoQnEdpaWmQkZHB7duUfqsMI0eqQ05OTmKNHB0dRd5TVFTE/Pnz8fjxY0RERCA+Ph4bNwryt3x8fFBYWEA7AjbGrl27MHfuXACCmzeVd1RcXAw7OzvExMRASUmJ1m8B4llbwhBYxK9Bp05KGD9+POrq6nDw4EFwuVx8+PABd+7cweTJk0RqRGVtMeH58+fYt28/ZGVlcPXqVdoNcMyYsQ1si3iN4uPjYW9vL/Jep05KWLRoEV68eIFly5YhLi4O+fn5GDx4MG140Thri0JiYiK8vQU3XoEWSWB08OPHD9jb22PlylioqKjA09OT1lE1xUhRFvHKysqYOHFiQzzFXnh6euHjxw949OiRmNMplbXFhKysLBw4cACysrK4cOECFi9ejJqaaujq6kJWVlYCIxUPOztRQw4qV/DNm2yEhCzEjh2CBSkqniI3N1csa0uAUhFGqm3btggLC0NYWBg9iVq5ciV69+6NiIgI+tw5fvw4/vjjD8bfSRLq6upQUVEhNSP18OFD/P3332jTpg3S0tIwY8YM1NfXY/bs2fDx8WH8rkVFRf2fWcQrKChgxYoVWLFiBd6/fw8tLS3MmzePdgNkyrhrjI0bNyI5OVmq49uxY4dERsrExAQmJibg8/lITEyk3QBtbW1/SyN169YtmgluKSIjI+l7v5KSEj3+1atXiIiIQHBwMIYOHYqoqCh60a4pRkoSqAVHaRmpp0+fIisrC3Jycti+fTtMTU0hIyMDLy8vODo6Mv7do6OjJZpNSEJLLeJVVFSwdetWAIJzz9jYGCEhIRg5ciQiIyPp78mlS5cknlOURXz//v3h7++Pd1eu4MSuXUhLS8Pnz5/h4OCAly9fIi4uDgcOHEDnzp2Rnp6Or1+/AgBa8/ng8/n09p49e4bHjx9DTk4OmzZtgrGxMdq2bQt3d3cAzM6GTSEzMxO3bt2Sakx4eDi9UNe9e3d6Mn3//n2EhYXh+/fvGDduHMLDw+kOgPfv30vt4vgv/jvxHzHJ2rNnD6qqKmFsbCzSLsPn81FaWsY4ATt9+jSmTp0Gf38/FBQUIC4uDikpKejSpQu+ffvGuPIvCC2GSNAg1S7z+vVrmJmZoby8XKRdxsjICPfv32cU+TY25KDsjvl8Pjw9PVFZWQl3d3dMnDgRs2bNom/eHz9+EnHQo0BZxFM27oDgQr5p02Y8ffoEBgYGYqHA1A1CkkmAubk5AgMDkZPzHTweDzxeHHr0UMXHjx8RFye+ckeFFgtf/FgsFqZPn44vX77AxMQUBQUFcHd3R/v2CnBxcYaOjg7++ksSIyUw5GjdujUAQebF6NGjwefz4e7ujsrKSnh4eMDcfApsbKzpWgpnbQmDsojv2bMnoqOjAQgulmvWrMazZ89gZGQklsHSlND42rVrmDRpEoKDgxvaAHnYunUrevfujY8fPzKKcquqqsRCi1ksVkOAbyEMDQ3x8eNHOn/Lzc0No0ePZszaAgQW8fLyv9ofdXV1oKsrcJV0c3NDZWUlvLy8MGOGJaZNm0rXSDhrSxgCQ47utI07IGDDYmKi8eLFC5iYmKCysorO36JqJMki/q+//oKZmRlCQkLw/v178HhxWL9+AwYM6I93794zsr+NGSlAMHFzdHREZWUldHV18ezZ30hPT0enTkrw8vLCiBEjcP36dcYaUYwUNZGiXCXr6urg7u6O8vIK2q7ezMyMzm559eqVREaqS5cuGDRoEP3wlpmZieXLlzdcCyYxupxKCi1++PAhTExMsWTJYroNUPCzg5Gdnc34gNmYkQKoeApXtGoFlJeX4+7du9i9Ow1duqjAy8sLQ4YMwdWrVxEXFye2PYEhx6/WPqrtqra2Fu7u7qioqICPjw8cHBxEVrGFs7aE8fr1a6iodBa5rp0/fx4hISHIzs6GufkUBpfTUnz58oVxkevBgweYPn064uPj8ddff2Hx4sXIy8uDrq4u7t+/j0OHDomNaQq/axEvzEgJuwGuWrUK48ePh6KiIoKDg0UmINKEFlP4HYv4rKwsWFpaIjExEVevXsW8efPw48cPGBkZYdmyZYxtUpRrn7QW8QcOHGg2KJrFYsHb2xve3t4oKSmBsbExSkpKMGXKFCxevFhiHpwwXrx4gc6dO0vd/iipK2HIkCHYv38/AMGkysvLCyUlJTAzM8ONGzeknmxSocXSoHFocUBAAAICAmg3wK1bt9I5mlSuJiC43zBlEzaFsLAwqdsfc3NzMXXqVOzevRsnTpyAi4sLKioqYGFhgczMTMZg58b3yVatWqGjkmBB6siRI3jy5AkePXqE0tJSsFgsCGQqwIWLF7F1yxYAAGnVir72Uqwd9bwSEhKCkJAQ5OXlwczMDKWlpZg5cybCw8MZTbEagym0uCWQFFo8duxYHDt2DHw+H4cOHYKdnR2qq6thY2OD6upqqRdV/sV/J/5/P8kihKB9e3mMHTsWS5YsQXV1NSZMmABHR0ecPHmySUZq61bBF1tFRYW2oH348CEWLFgAX19fsXYZ4aytxqBCi6k2Dkq/FRcXh7y8PLx7905s9Wfnzp2MocUsFgv19Xzs378f1dXV2L17Nzw9PdGuXTtoaWlJvBmmpKSIhRZraGhg48YNcHNzh66uLoKDg1FfXw8zMzPY2tri1KlTGDVKskaKejD4/9j77rgm0q/7K6vbvqsUxd5dV9deIBNCL9IFEVEBadKxISqgooBiL6hYABHBir333vu6rr2jqIiAiIiIIdzfH9mZnSQzycyo+77v75vz+fgHJE8mPE4yc++555xmzZpCcnISAAB1gzNy5Ejo1asnhISEUF+E9KwtZVy8eAlWrcqCunXrQmRkJBQWFkJ6egYsWbIEiouL4dWrVyrFHltosfxLWn6hJ8cASW2SRCJhzdpisog3MjKCPn36QFBQEPTo0YPSb7m4uMCAAQNg//790KMHs5PYzp07qRvgVq1aUhbWZ86chSlTEmD06DFgbGwEw4cPp7q39KwtZZCFFHnj+fz5c0hPT4cFCxZAcXExFBcXq7BtTIwUuUcAcjvdiooKWLVqFQwfPhx0dXXB3NxcrbOhskW8qakpmJiYQGBgIHTs2JHSb7m7u4OzszNj1hYJkpECUNRvnThxAk6cOAHR0dEgkUggICCAyhORZ20xM1JkIUXu0aNHjyAzMxNevnwFJSXFUFZWpqJtYgstlodh6sC2bVuhrOwdrFyZCRs2bAADAwOwtrZh1UhlZa1UCS22trYGa2tr8PPzgxYtmlNjgF5eXmBnZwdHj6pmbZHYsuUfi/hOnTrBggXyc+rw4cNw+PBhiImJAUtLKxg2zJcqguhZW8o4dUpuEU8+9+7de5CZuRJev34NJSUlUFFRoeKWKHc2HKzyWvXq1QMdne9g27ZtUFxcAhkZ6bB6dQ40bmwI/fr1U+NsmKkQWqyjo0PFU/j7+1PF8U8//QTe3t5gbm4OR4/uYGWklixZAuvXrwcAAIIgYM+ePVBbWwvr1q2DnJwcGDRoEAwePBhGjBihUb8FINwinims+ueff4Zp06bBtGnT4NmzZzB16lRITEyEdu3agbe3t+DQYr7jj6mpqZRFPD2egtRv1dbWwrBhwyAsLIx6P0uXLuVtM/327VuoW7cu/PSTar4ZGxo0aAD16tWDBw8ewNOnTyldz2+//QbJycmsnf/ExETeWrsDBw5wYqQcHBzAwcEBZDIZLFu2DP744w/w9/eH4cOHc9JvAaiGFnMBW2gx3Q2QdN8rKCj428EzSHBoMd98J3nsg9xxj4xLkUqlsGTJEnj16hUEBQVBZGQkDB48mCqKlEOL69atC7KffgLpp0+wb98+SEtLg59//hlW5+TAo0ePICEhAT5+/EjFDQAAVNWtC43+vgbMmDGD8f6ocePG8NNPP8H169fhr7/+guTkZCgsLITevXtDcnIyqxvtlClTIDY2ltc+cLGI19HRocbtP336BAsWLIATJ07wzj7T4r8T/+uLrL/++gu6d+8B1tZW0K8fOS6zDsLCwuDp06cQF6faYf3w4QMAAOPIwrlz52HkyJHg4eHx97hMHFRXV4OtrS1cuXIZRozIUVnDZBEv70IlQEJCAri7u6uMy+jq6kJBwQtGRuratWtUaPEPP/wAoaGhEBoaCkVFRRAQEAAGBgYQFxcHYWFh1BeActYWHaRFPGnjXlX1CdasyaWCk5kuYMo6MjquXr0KUVFR4OnpCfv2yfVbtbW1YG9vDxcvXmLUkclDi/+jcPPTrFkzSE5OgsTEJHBwcPh7DLAc+vTpA8HBwfDLL79Afv4zMDFh1pGRhRQ5Bkj+XwwfHgz6+noweXICREREUNo6UiPFHlrckxoD/PjxI6xalU2FAjPNpldVfQKZTMbYHb5z5zaEh0fAkCGDYceOHX8XLXXA1dUVzp8/D6tWrVJZo8xIAci1IDNnzoTk5GSwsrKixgBJ/dbPP/+skrVFgmSkAORjgKR+Kz8/H8LDw0FfXx8SExMhIiISmjVrSu0RPWuLjsOHD0P37t0V9FsrV66ELVu2QkHBc0bNFakjYzKbePz4MYSEhMDQoUMV9FseHh5w5sxZxjwyJov4X3/9FebOnQvTp6eAnp4Ypk6dCp8+fQJTU1Pw8/ODH374AR4+fMR4nt+5cwcaN5YXUvr6etRF+NGjRxAVFQX6+gaQkpIC4eERCiOA9KwtOo4cOQJdunQFf39/8Pf3h7dv30JGRiasXbsOCgqew8yZM1XWkFlbTBbxL1/Kb2h8fHxg/fr1f8dTfA+DBw9mzdoqLS1VsYj//ffOsGDBfJg1axb88MMPlH7L2toavL29oV69eipZWyToFvGGho2ofbx9+zZER0eDgYEBzJ07F0JDwxT+n9WFFnfu3JnSpZINqVWrVkFBwQuYOlWVkfr8+TNUVVWpGMzo6OhAUVERTJgwAcaNG0fpt3755RcYO3YsODszN8U0hRazgYtFfJs2bSA3NxcA5Jlxnp6eYGhoCOPGjYMpU6Zo1G8BMIcWawKbRbyyfmvmzJlgamr6t9HMBNi8eTMcP36c17HIMHc+uHv3LlVsdujQgSqYjx07BpGRkfDu3TsV/RaAMEOO1NRURkabDd999x3o6OjA6NGjISYmBqZPnw4SiYQy0GLTbwm1iD9z5oxGRqpr164UO7tv3z7w9PSEhg0bwrRp0yA2NpbTuXvkyBHB44/K18l69erBuHHjYNy4cVBSUgJJSUmQmpoKTZo0gSlTpsC6desUNFI6OjrwS8uWUHTlCjx//hxu3boFIpEITtMaQEuWLIFnz5/Lv9d+/BHMg4Nh2N+68VOnTjFqSumMVK9evWDHjh0AIDeaGDp0KHz69AkGDBgA0dHRlH4LgF9oMYk5c+ZQI5Rc8OOPP4KtrS3vDDgt/ntRh6R0/zfAyKg7Xr2ao/C7FStWQEhIiMpYzocPH2DEiBHQqVMnuH//PhgaGkJ4eDh07NgRlixZAq1atQYPjwEqxwgICKQYKRLV1dWQlpYG+/btg06dOqmMy5CFFFPXMSAgEHJz5e+ZHJfZvn07lJeXQ506dWDdunUqXdfRo0fDhAmxKsYb8vGv4ZCbmwM3b96CVauyqDDP5s2bQ3FxMYwZM0blPYSEhFAaKTo+fvxIBSU/fZpP6bfatWsHy5Ytg8aNm4CXl6o7DtMeVVV9gsWLF8GhQ4egS5cuMGyYn0JxlJiYCE5OTozGG8p7tHfvXtizZw98+PCB2iPl7t2YMWNg7NixKhcC+h5dvXoVcnNz4f37Cujbtw80a9YcCgqeQ0xMjMp7CA0NpZwN6aiq+gQhIcHQtm07ePGiAFq1agWRkZHQokULyMjIAF1dXUaGJDAwUIFtAZCfk4sXL4YjR45At27dIDAwUIFpTU5OBjs7O8YLuvIebdu2DQ4ePAgfP34EHR0dWLt2rcoeRUdHw6hRo1QKJnKMMDc3Fy5cuADr1q2HysoPQBBiaN68GTx48JBy+aMjLCyM0pHRUV1dDYGBgdC6dRt4/fo1tGvXFiIjI6FJkyawcmUW/PTTj4xsJNMelZeXQ2pqKpw8eRJ69eoFwcEhCk6L06engIWFOeOYEX2PampqIC8vD44fPw6fP3+GOnXqQG5ursoejRs3DiIiIlQKJkSEwMBAyM3NhZMnT0JeXh5UV1eDubk5NGvWHG7c+FPJtEGO8PBwmDVrlkrBJJVKYdgwP2jVqiUUFxdDp06dIDw8HBo2bAirV6+G7777jrFrGxQUpMBIAciLqEWLFsGZM2egb18jCAsLVRhBnDlzJhAEwTjiQt8jsiF16tQpSgfBFJQ7fvx4CA4OYSyYyO+Co0ePwrZt2+Dz589gY2MLTZs2hStXLjN2cyMiIiAlJUWFAZNKpeDr6wv16v0Gjx69BbFYDImJiWBgYADz5s2DmpoaxiJQIpHA8ePHFW46X7x4AVOnToW7d+9Cq1atIDk5WeHGZ+TIkWBhYcHI3LHh1q1bMHnyZNi1axfnNQDyUPjz58/D2rVrYdWqVVBbWws+Pj4QERHBykrY2dnBmjVreOnFFi1aBO/fv+c8Yvj06VOYMGECHD16FJydnWH69Omcg10JgoALFy7wYlW8vLwgJiaGtWCqra2FjIwMWL9+PdSpUwcCAwOhWbNmsGXLFl4jfDU1NWBubg4XLlzgvAZAnt13+PBhhYLp7t27kJycDPn5+Sr6LQD5Z6N79+68dFL379+HsWPHwv79+3m9P7FYDGfPnoWlS5fCli1boF69ehAWFgZDhw5l/X9wcHCAzMxMXnqxFStWwIsXL2DGjBmcnv/XX3/BpEmT4OzZszB48GCYNm0a1QypqamB5DFjoFVtLbx4/hweP34Mb968gezsbGjVqhUEBAbC6uxsQAC4V1oKS3ftguvXr0ODBg3gw4cPjPqpYcOGQUhICCuL//nzZ1i4cCHs2rULfvrpJxgxYgQYGBhAVlYWVdhzQW1tLUgkErh48SLnNQByxiwhIYGaytBCCwCAOnXqXENEldG6/9VM1ufPnwGgDqMYOzs7GwYM8KAKqTt37kB6ejqUlJTAq1evYNOmTSprXrx4wRha/MMPP8C7d+9g3rx50KZNG0hPz4DVq3OgSZPGEBYWBgUFBYwFljy0+J9CiT4uM3LkSGjfvj2l3/Lx8QFzc3OKkVIusAAULeK7d+8GixbJQ4EPHToEc+bMgTZt2sDGjRvBy8uLunFVx0itXr0a3N0HUIXUjRs3YNGixfDu3TsoLHzFqHGQM1Kqe/TTTz9CVVUVzJo1i9qj9PR0aN68GWVUwOZsSDfkkFuIy8cTRo4cCS1atKD0WwEB/pRJxLt37xgZKXlosXzcyMjICIyMjKC2thZ27dr9dwBvW9i+fTsMGDCA+huUnQ3pyMnJgf79+1OF1JUrVyg3wNevC2Hr1q0Me/RahZECkP8f1NTUwIwZM6BVq1aQkZEBaWlp0KaN3A3wyZOnjAWWskW8jo4OeHl5gZeXF4wePRoaNmwIQUHDQVe3AQQFDYfevXv9zUi9Y7xpoocWm5iYgImJCdTU1MC2bdsgNTUV2rZtC3v27FXQbyk7G9KxZs0a6N+/PzWyePbsWZg2bRp8+FAJRUWvKacoOthCi3V1deG7776D5ORkaNmyJWRmZsLr10XQvn07iIiI+NvZUJWRUraIr1u3LgwbNgyGDRsGo0ePhvr160NQ0HBo2NAAgoODoWvXrlBbWwslJSWsjBR5U06GsEqlUsjL2wRz5syGdu3awZEjRxTGPuUaKfbQYhcXZ6qQOnbsGEyaNBk+f66GoqIiygaZDiZGCgCgYcOG8PPPP0NiYiI0bdoMMjMzoaSkFDp37gzh4WGsOjLl0GK5fisIgoKCYPTo0fD9999DQEAgGBo2ohpSAHLWh6nAkhtydKJ0qfb29lBdXQ3r1q2DlJQU6NChPZw8eVLhZkgqlUJ1NXNo8YYNG8DJyQmCgiZAbW0ryMvLg4EDB4JUKoWCggK4d++eyho2Rqply5aUDvbSpUuUlkMikcDUqVPh6tWrvENMk5KSeI+tkaHFOjo6CvqtWbNmgampKdSvXx8mTJigcB7xCS2mg69FfLt27aBly5awbNkyaNGiBYwcORLKysrU6rcA/gkI/9oW8To6OhAZGQmRkZHw/v17mD59OowbNw569uwJp0+f5jzylp6eLsginomR+v333yEvLw8A5COIISEh8P79e7C3t4f4+Hg4e/YszJ07l9exEhMTeY+SHT58GDp16gR169aF6OhoiI6OpvRbS5YsAUNDQ5g6darCfYhQQ47169fDwYMHOT+/R48e0LVrV/Dw8AADAwPw9fWFqqoq6N+/P4wbNw6OXb8OeWlpYPDpEyxJTQWLv5nvt2Vl8J+ff4bPNTVQCgAtCQJW/C01cHaWX3sIgqDGAEnDJSZnQzq+//57iI+Ph/j4eHj9+jUkJSXBpk2boE+fPoxuuWzIzs7mpBmk4/Pnz4CI2gJLC+5gCs/6n/qnHEZ8/Pg8/Ouv1cgUtskWyPv8+U4cPPhXDAvri4GB3RXCMydPdsTLl1ewvh5TiKq/f1e0sdHFOXMGq4Sccg0tfv16H06b5o7+/t3Q2/s3TE52Y3wPwcHqQ4s/fTqHGRlhGBDQDSMijPHMmUW4dGkQbt06kdcevXy5Gz0922JISG8MCuqBeXkTqD2aMsUZL1xYynmP/vgjC/38uqCNjS4uXDgM379XfP/qQ4v/eb1Xr/bg1KkuGBDQDf38uuC0ae6M70FTaHFl5WlMSwvEgIBuOGKEGC9fXoHp6aG4ceN41r+JObR4D3p4tMbhw3vi8OG9cPv2BGovExNd8ezZxZz36MKFpThs2O9oZVUfly4NwsrK00p7ZIaPH2/WuEdPn27F+Ph+6O/fFQMDu7PukabQ4vfvT+DChb7o798NR482xevXszAzMxzXr49hfD220OJXr/aim1tLHD68J4aG9sF9+6ZRezRt2gA8eXIByx6pBuiePp2Kw4b9jtbWDTAzM1wlFHjsWAt8+DCPZY/+eb2HD/NwwgQb9PfvhmFhfTEpqT/rHqkLLX779gjOmjXo71BgS7xzZx1mZ4/A3NzRjK/HFshbWLgXXV2bYVBQDwwLM8KjR+dQj82YMVDhZ03n0ZEjs9HHpzNaWdXHnJxRKsdTH1r8z+vdvr0GY2Is0d+/K44YIWbdo7AwIywtPcy6R2/eHMBp0wagv383HD/eGh8+zMOcnFEKofHMe3QT6SgoKMDWrVujWCxGW1tb3LNnD/VYVFQUbtq0CblAJpPh2rVrsU+fPqivr49LlixBqVTKaS0ie9isOmgKLc7Pz8eAgAAkCAKHDh2KDx48EBRaXFJSohBazBXKYbMymQwzMzPRzMwMzczMMCMjQyWMdtCgQXjhwgVex9m3bx8GBgbyWkOGFj948ACHDh2KBEGgn5+fxvBeU1NTTqHFdMTExGBOTg7n95WWloa9e/dGfX19zM3N5RX8LOQ80hRafPPmTfT09ESCIDA4OBhfvnyJy5cvx8mTJ/M6Tnl5OZqbm/N+f8rnUXV1Nc6dOxd79eqF+vr6uHHjRnz97BkONDHB0tOn8d3p0xjn4oL709Px5f37+OHDB5XXI7F161a0trZGsViMoaGh6Ovry+u9yWQyFIvFeO3aNXR3d0eRSISRkZFYVFSkdh3X0GI6du7ciefOneO1Rov/DsD/xTDinTt3Qb16dRW6rgByS/cGDeqzBvJOmDAejIyMqK5rSEgI/Pjjj1BUVMSoK7ly5Qojs9S1a1do0KAB5OTkwO3btyEuLhZqamrAxsYGhgwZwpi1BaAaWkzONAMA+Pr6QklJCQQEBEC3bt0hLCwUdHV1NTJSzs5OlI17WFgYFBa+hoyMdDhx4gSIxWLo06ePgrBYnrXFHFqckZEBsbGxIBKJoKrqE+Tm5kBoaCj8/PPP8Pr1a5g2bZrKGrbQ4t69e4Genh5MmzYNbt68BWPHRgMigqOjI3h4eLAyUnJDjl7Uz3L9VjIAAHh7e8Pr168hICAQ+vTpTem3NDFSDg4OKvqtFStWwJkzZ8DU1BRMTc0U/r/kWVtsocUZMG7cODA1NYUPHz5QxhsNGtSHwsJCKuSZDrbQYrFYDBs35kFSUhL88cd1Sr/l7u4GLi4u8O5dGbRv315l3aFDhxQMOdq2bUvNsA8ZMhRevHgJAQGBIBaLITAwEH766UeNjFS/fv0oG3cA+UhRZmYmnD9/HiwtLaGw8DWl3wJgZ6QA5OYQ48bFgIWFBZSXl0NWVhZs2rQZ9PT04NWrl2oYKVVDDnNzc9ixYwckJCTAtWvXIDIyEurWrQseHgPB3r4flJa+ZbQVVraIJ/Vb8j0aQo1OmpmZwbBhw+CHH36A6upq+Pz5s5rQYlvQ19enxgUfPnwIGRkZcOXKFbCz6wclJSUKTM0/zobMjHtMTAxYW1v/rd/KgDVr1kKjRo3gxYsCNc6GqkyQnZ0dHDhwACZNmgiXL1/+W7/1AwwdKo+nYHM2lBty/PP7Ll26wIIFC6C2thaGDBkCVVVVEBQUBDY2tlQ8BZOzIQnSIp7UpQLI/1+XLl0K16//CU5OjirB2YrOhvK8LAD5fs2aNQvmz58PXl5e8OLFC0hMTISUlBRo1aoVPHz4EJYtW6byHpigo6MDw4YNgx07dsDixYvh6NGjlH4rJiZGrfmDutBiNnBhpNq0aUPlb509exbGjBkD586dg6CgIHj//j2n0FQA1dBiLmCyiNfR0aE0wB8+fIAZM2aARCIBPT09iI+PBysrKygoKGCcSlAHoRbxjo6O0LFjR8oN8MiRIxAWFgbl5eVgZ2cHEydOVHD7FaqROnfuHGM2IRPq1q0LI0eOhHPnzsGMGTPgyJEjsHz5cmjYsCEkJCSoZeu+lUV8t27dqKmKvXv3QkBAAFy5cgVGjRoFnz594qw9TElJ+SoW8d9//z1MmDABrl+/DlOnToWjR4/CggUL4M2bN3CnTh3o2qULnH33DpL+Dqun4/jx4wrf5Z6enuDp6QmfP3+Gnj17UhosrsjOzgYrKyvo06cP7Ny5EwDkrO+QIUOoKB9l/Raf0GI6Lly4wKgj00ILVjBVXv9T/+hMVlnZUVy9eiTeubMOY2Ks0N+/G86cOQhLSw/jpEmOeOVKOmrq2Cp3gd3cWlBd1wcPNlKPjRghxhcvdqmsUe6Sk2zAypUR6OraDJ2cGjN264cPV89Ika+9b980ik0KCzPCzZvjWf8mJkbqxYtdOGKEGP/8cxWOHm2G/v5dcf58b3z//oRaRioggHmPDh2aic7OTdHfvxvGx/dTYKBGjZLgs2fbWfZI8fU+fjyLy5cHY//+zdHJqTHj+2Bj7UhGinztHTsSMDi4Fw4f3hOjosQCGKm9GBVF4OXL6ThypAn6+3fDJUsCsbLyNE6d6ornz6fxOo8OHZqJTk6N0d+/G06Z4qxw3owebYZPnmzhdB69f38SU1OHUXv0xx8rVdZpYqQQr6JUehHz8ibg8OE9MTi4F44ZY4br1o1l/X9n2qOiov0YEWGMZ88uxshIEfr7d8MVK0Lw48ezOG2aO54+ncqyR6qMFOJVPHhwBtrbN0J//26YlNQfX7/eRz02dqwFPnq0idMevXt3DOfOHYpubi3R2bkJ3rqVq7IuLKwvIyP16dM5DAzsTu3RmjXRf3/O+mJsrC0rI8W2R8XFBzEszAiPH5+H4eFGGBjYHbOzR+DnzxdwxoyBePz4PF57tH9/CvbrZ/D395qnAmOknpHqqvK+ZswYiO7uLdHFpanC99o/e6SekSL3KysrEgMDu2N4uBFOnuzIgZFS/H1p6WEMC+uLBw6kYGhoHwwK6oHr1o1FqfQizpw5CA8fnkV7fimSYOv85+TkoJWVFeNj6qD8es+ePcPAwEAkCAK9vLzwzp07KmtsbGzw1atXvI6zYMECnD59Oq81xcXFaGlpidnZ2Whubo6mpqa4fPlyjUyJSCTixaYgyhmpixcvcnruo0eP0NfXF3/77Tds27YtPnnyhPNxSEaKLyQSCVZVVTE+JpPJcNmyZWhqaopmZmaYnZ2NMpkMx44di7m5ubyOc+fOHXRxceH9/kQikcrreHl5oUgkwsDAQCwoKFBZ069fP41MnDKWLVuGCQkJvNaUlZWhqakpLliwACUSCVpaWuKGDRs0niPKjBQXeHt746lTpxgfU96j69evo4eHB/7+++/Yvn17fP36tcoaBwcHxvNLJpMJYgHNzMywoqKC8bHq6mqcOXMmmpiYoI2NDe7YsQMREePj4zEjI4PXcd6+fYszZ87k/f60+O8A/F9jso4ePQp2dnbQsmVLyu746NGjMHHiJLh37x506vQb9OzZU6F7fPnyZWjduhXj6+3cuROWL18OLVq0gNu3b8OKFSugtLQUunTpAuXl5YxZWzt37lSxiP/hhx8gJCQELly4CImJUyE3Nxeys1dDkyaNITw8/G/7bWRkpOihxTo6OpQbINlt2bt3Lxw/fgx8fX2pRHomZ0MSGRkZ4O/vDz179oTFi+X6rf375W6ADx48gC5duoCRkZECC/HHH3+wBjvv2bMHVqxYDq1bt4br1/+E1NRUePfuHfTs2RPKysoYnQ2VGSkAuX4rMjISrl27BvHx8bB27VpYsWIFtGjRAiIiIsDQsLFK1haJnJzV1Ly9jo4ODBgwAAYMGAAfP36kwoHPnj0LAQEB1Hw6k7MhCdIi3tjYCIyN5fqtnTt3wqhRo+HRo0fQs2cPqK2tVdhfMmuLCfv27Yfly5dD27Zt4fLly5R+y9jYCN6+LWW0KWYKLa5f/xeIjo6mHNzWr18PixYthrZt5fotAwMDVkaKbhFft25dBTfAQYO8oKzsHVy+fBmCgoKo+XQmZ0P6Hvn4+PzN9plCTU0NbN26FUaMiILHj59A7969Vfbo5s1brKHFhw4dguXLl0GHDh3g7NmzkJSUBB8/VoFEYgLFxcWMOjLSLIQOuTvaeHj06CFERERCbm4uFBW9gV9/7QARERHQoEEDjYwUuUd+fsPAz28YlJW9gyFDBsPr10Xw559/QkhICHTp0gUA5IzUjz+yh1+TjJG1tTVIpVLYuHEjhIeHw+PHTxhdRO/cucNqEX/06FFIS0uDTp06wbFjxyg3QCsrKygpKVbDSCl2yRs1agSTJk2C8PAICAoKpHSpZDzFL7/8RyMjBSD/XiMd6oqLi8HX1xeeP38Od+/eocxzAEhGipm1I0OL7ezswNHRUSGe4unTfDA1ldCeXQEABnDjxg1G9hdAzi7xDajdsUPVIr5169YUy3L+/HmYMGEClJSUUPqtX375BT5+/MgaVM6Gbdu28baIJ0OLvb29ISgoCCorK2HWrFkgkUhAV1cXYmNjVQxNbt26JVgjRc9gUocOHTrAunXrwM7ODkJCQiAqKgrKysoY3QCVsWzZMtZYDzaQtt5sDIyOjg5ERUVBVFQUvHv3jmLc7t+/D7t37+Z1LHpoMVccOHBAxUHu999/h82bNwOA3K02KCgIKioqwNHREeLi4qBevXqCNFJCLeKHDx8Ow4cPh5iYGCgpKYFp06bB4sWLoUmTJpCQkKCiI+caWqwMNov4Y8eOwW+//abwu169esH27dvB0dER3NzcwNvbGz59+gRubm4QExMDdevWZc2kzMrKAmtra17vjXSSZjs/v//+e5g4cSJMnDgRXr9+DYmJiTB79mx48OABb8fNLVu28DLS0UILgP/FxheFhYUqeVF2dnbQoEED2LVrF8hkMggLC4MffvgBhgyR3/ysWbOG8ctUObSYHp45Y8YMePv2LQQFBYGtrS0MHTqUusnat28/LFmiaudLhha3bt2aGgO8efMWLFu2DG7fvgOtW7dSGZcBANbQ4pKSEujQoQMsXboUioqKID09HVauzIKmTZvCp09VjK5kAKqhxTo6OuDq6grNmzeHTZs2wbt37yA4OAT+85+fwdfXF0xNTRmztsg9ev/+H4v43r17Qe/ei6G2thamTZtGBQw7ODiAp6cntUf0rC06yNDiX3/9lRoD/OOPP2D+/Pnw8OFDaN26tUooMMA/WVvKKC8vhw4dfoVly5bCy5cvISMjA5YuXQYtW7aET5+qYNgwP8Y9Ug4t1tHRgYEDB0K7du1h/fp18PLlKxg+fDjUr18fAgICwMjIiDFri9wj+vijSCSijDqSkpKguLgYQkJCwNXVFdzc3KiL2c6dOxlHVUiL+K5du1LW3xcvXoQZM2bA48ePoW3btiqhwADAGlr88eNHaN++HaxYsYIaA5QbXbSDT5+qGLO2AORCY7pjWd26dWHo0KHQrVs3yMrKgvv378OWLVtBT08PgoOHQ48ePRiztsg9oocWm5mZgZmZGdTU1EBiYhK8efMGwsLCwMPDAxwcHKg92r59O6PAnAwtlp+PvQBAHtg5depUePbsGbRr1w6qq6tVhMhnz55lDNSsqZFC+/btIT09ncrfKip6Ax07/gpVVVWMTpIAoGIRX69ePfD39wcjIyNYsWIFXLlyFdauXQeNGjWCkBC5U9+qVasYM5cAQKGQsrW1BVtbW5BKpZCYmAiFhYUQHh4Bgwd7Kdxw07O26CBH+8RiMTXmJY+niIcXLwqgXbt2DKHA8owYJov47777Dtq1aw8ZGelw+/ZtKp6ia9euUFlZyehICqAaWkzGU1hYWMDixYvh1KlTsGpVNjRt2gRCQ0fCr7+2geTkZFa3vFevXkHfvn0ZH2NDWloabNiwgfVxiUQCe/fupfK33N3d4dmzZ9ClSxfGPWKDUIt45dDi//znP5CSkgIpKSlU/tbkyZOhXbt2MG3aNOjYsaOg0OK9e/dC9+7M2X9sqKmpgQ8fPsDQoUNh6NChUFtbC1lZWeDk5AR16tSh8qWUb9I3b97Mu9icPn06hISEcHqunp4ezJs3D+7evQvh4eGwbNkyGD9+POUGqKmoYQstVgdNFvFkg7SmpgaWLVsGdnZ28Pr1a+jSpYtKQ0odyNDiL7WIb9SoESz5O/D31q1bkJSUBC9evIDu3btDcnIyNG/eXFBo8dGjR+HZs2cwYMAAmDp1KvTp848MYu7cuVTWFh3kdZIskj9//gyLFi0CKysrKC8vZ2wgAcizE+kW8VwwY8YM8PNjvvYro2nTppCRkQFPnjwBb29vSEpKgsLCQjAyMoLk5GTWPEAST548gbCwMF7vTwst/lcWWQUFBayBvGQh1aJFCwgKCoKSkhLIzMyEnJwcKCgooAogOnbs2MEYWqyjowP5+c9gy5Yt8N1338G6desoN8ABAwYAACjMg5NgCi3u3r0bLFy4EAICAmHgwIEwYcIEqKmpATs7Oxg8eDAUFRVB/frMOjJ6aHGTJk2ozKabN2/C6NGj4d27d3D69GkICwujZoj/+OMPKmtLGWQh1bp1a4iIiIDCwteQnp4OGRkZ8PLlS5DJZCpr5FlbfVR+r6OjAy9fvvx7j+pCTk4OVbh5eQ1m1ZExhRb36dMH+vTpA4GBgeDk5ATR0aR+ywk8PQdCUVER/PLLLyxMQgb4+cltwlu0aEHpxq5evfp3Z7oUrly5DMOHD6fejzpGKidntYJFfEHBC0hPT4e0tDR48eIlY6denrWlqtvQ0dGBwsJC2Lx5M+jo6MCqVaso/ZaPjy/IZDIWjVQu2NvbK/yOvFEOCAgES0tLGDlyJNSpA+DuPgBcXJyhuLhYLSPl6+sLAHJnMfKG/Ny5c5CQkABFRUVw69YtCAgIpAo3dYxUVlaWgkX806dPIT09A+bPnw+vXr1i/H9nCy2uW7culJQUw+bNmwERYeXKLMjL2wT6+noQEBAAUqmUcY/kocWK2ScWFhZgYWEBgYGBIBabUPqtgQMHgr29PZSWvlXDSGVQhRRdv3Xy5ElISkqCly9fwtOnT2HYsGHUOUDP2lLGqlWrYPTo0ZRm9P79+7By5UooLi6BV69eQsOGDVXWyLNtVHNW6tWrB6WlpbBp0yaQyWSwcuVKWLNmLRgaNoLhw4ercTZUDS3u168f9OvXDwIDA6FXr14QGhoKP/zwAxVPoZ6RyoDBg70AQLEhdfToUZgxYyYUFBTA69evFRpSys6GdGRmroRRo0ZTDoY3b96CpUsXwOXLM+DJkwJGzeaOHTs4u4SR+Pz5M3z69ImVGaNDR0eHyjqTSCTQt29fSr81fvx4je51bKHF6sCkkaKDnr91+vRpGDNmDLx9+xaePXvGemPKhkWLFjHa9auDcmixjo4OpQF+//49xSbp6+tDXFwcdR6pY6TYcOHCBViwYAGvNYmJiTBnzhyqaXbo0CFKv9WvXz+YOHGiSrHCNbSYjpqaGoWGozrUrVsXxowZA2PGjAGJRAJt27al8rcmT56sMf8rJSUFgoODeb0/TYwUXb+1e/du8Pf3h8rKSnjx4gVv3dz8+fPh4sWLUF5eDsnJyfDq1Svo2bMnTJ06FcrLyxkZKeXQ4u+//x5iY2MhNjYWXr58CSkpKSAWi6FZs2aQmJgIvXr1gvfv3wMAOyPFhhMnTnC2oicxZcoUmDVrFtjY2EBtbS1s2bIFvLy8oLq6Gjw9PWHMmDEq144nT56whmlroYVaMM0Q/k/9IzVZ2dkjsLz8ODLrNpi1Mlu3TsQpU5wp16xZswZRWo3hw3uqOLohXsWKipMYHNxL5fdv3hzAwYM7YP/+zXHCBBsVVzN1zoYjRoipnz99OoeZmeEYENAN7ez0MTMzgvG9s/1NV66k46RJDpR+i9Q5bNw4HkeMEOPz5zt47dGOHQkYF2dH6bcWLvSlnPo0ORsq//7Vqz04aFA7dHFpivHx/TA/fxunPXr1ag9GRYkVXn/p0iD09++G9vYNcdWqKF579McfWRgf3w9lssu4fXsCDh8u129t3TqRs7Mh/d+ePUkYE2NF6bfS0gKpc0eTs6Hy7589246enm3R2bkpTpnijK9e7VF4nE3/U1i4FyMjRdTP79+fwNTUYejv3w0dHBphTs4olj1i1v/89VcOxsbaolR6ETduHI9BQT0wJKQ37tmThKNHm3HWSJH/9u+fjqNGSSj9VkZGGOUGGBbWV6OOjP7v4cM8HDiwDTo7N8HkZDcsKtrPaY/evDmAERHG1M9v3x7FOXMGo79/V3R0NMQ1a8bwOo9u316D48db4+fPF3DNmjGUfuvw4Vk4dqwFo9aptvYK6+sdPjwLIyNFGBZG6rdGUjqmsLC+GjVS9H937qxDD4/W6OTUmNKl0h9n00iROjL6z9Ony90AXVya4po10bz26N699RgTY0npUkmX05MnF+C4cVZ45846Xufl7t05aGlpiZaWliiRSDA1NZVyA7SxscHCwkLkg7lz5/LWTBQXFyvovp49e0a5AQ4ZMgTv3bvHuE6ItsXT0xMvX77Ma82uXbtQIpFQ+q309HSNx/0WGik6Hj16hD4+PkgQBHbs2BEXLlzI6zhCNVJseh3SDdDU1BQtLCwwJyeH2qN+/frhs2fPeB0nLS0Np0yZwmtNWVkZWlhYUD/fvn0bvby8kCAIDAoKYtRvIQo7j4YOHYpnzpzhtebAgQPYq1cvlEgkaGVlhXl5eRqPy6aR2rFjB/7666/YrFkznDlzJlZXVys8rk4jRcf169dxwIABSBAEdu/eHRcsWMDrb3r06BE6ODjwWoOoqiMjUVVVhSkpKZR+a+fOndRjs2fPxtLSUsZ1WmiB+H9Ik4WIcOrUKbh48RIMGTJYoSOyfft2MDZWZaQAAPbvPwBpaUuoThY5LvPp0ycoLS1RcJYhkZ2dDS4uriq/NzQ0hB9//Ak2btwId+/e/Xtc5i107doF+vfvz6qRSk9PV3DuIcdlQkNDwdd3GLx+XQgBAYHQtGkTCAsLgw4dOqhkbdGRm5sLEyZMUNBvkW6AN2/ehFmzZlFjgCR271Z0NqRj7969VGhxbW0t7Nsn129JpVIoKyuDn376SWXN6tWqjBSA3A3w55//A5s2bYI///wTFixYAOXl5dC7d29wdXVldTZMT0+nGCkAgJ9//hlGjBgBI0YA+Pj4QH5+PgQEBELLli0gPDyc0ocxORsC/MNI6ejogIfHAPDwkOu3Vq1aBX/++SfMnz9fQb8FoJi1pYydO3dCamoq1K9fX0G/BYBQUlLKyGzm5uaoMFIA8nHSX375BfLy8uDq1auQkjIDPnz4ACKRMTg7u3BipAAA6tevD9HR0QAgd168f/8+BAQE/q3fioRmzZqyOhsCADXaR44BDh06FCoqKiAzMxP+/PM6LFmSRo0BkqBnbSljx44dVGhxTU0NbNmyBaKiogCgDpSWljC6P65Zs4YxPPfXX3+F+vXrw6ZNm+DcuXMwdepUqKr6BGZmZuDs7MTqbCjXSP0z2qevrwexsbHUHt28eRMCAgKhY8dfITw8AgwNG6lkbdGRlZUFkZFRUK9ePfDz8wM/Pz8oKyuD9PQMuHbtGqSnp0NISKhCnpQ8a4u5S75161aYPXsO6OvrgVQqhQ0bNkBYWBjUq1cPSkpKWLO2mDQJv//eGRo0aACbNm2CU6dOUfota2trcHBwYGWkMjMzYciQfzQEjRo1okYehwwZCn/+ef1vd8YuEBoaBvr6ehoZqZCQUEqXGhISAsXFxZCeng5XrlwFHR0dCA8PV9DcHTt2jJWF2bAhA/Lytv89Fv0J5syZA+bm5vDzzz9DYWEhJ0aKjh07dsDJkyd5rUlKSoLIyEjq59atWyu4AZJ6FzMzM5gyZQro6enBrVty9pevtuXFixeMeYvqsGTJEtiyZQs0b94cPnz4QOVvyfWKExg/U2lpaeDs7Mzwauzgw0h16NCBCn3t2rUrHDp0CDZt2gS2trYwceJEjWxEYmIiTJ48mdf7Y9JIkSDdAEeOHAnv3r2D6dOng0QiAQMDA3j16hUnRoqOjRs3wpEjR3itmT59OgwfPpz6uUuXLpR+a9++fRAYGAgfPnwAZ2dniI2NhR9//BHu378PDRs25H0ePX36lNJsc0Vqairs3LkT2rRpAyUlJZCcnAwLFy6Epk2bwpQpUxgnfTIyMhjPrwEDBsD8+fNhz549lI7qhx9+gKioKLC3t4c6depwYqR69epFOQl26tQJ9u7dC9u2bQN3d3cVN0AmTJ06FeLi4jjugBzKzoZ0/PjjjzB58mSYPHkyvHr1ChITE2HWrFnQsmVLaNGiBeN3thZaaML/uiLrxo0bEBgYCN26dYPMzEzIzV0DhoaNICwsDA4cOABpaWkqaz58+AB16oDCqAA5LrNo0SJ4/vy5yrgMAMC1a39Qdt900C3i6eMyR44cgZEjR4GBgT6sW7dOYVwGAODFC+bQ4itXrkLbtm0V9FtpaWlQVlYGxcXFjGMTyhopEj/99CM0adIUPD09wctrMGRkpENm5kpo2rQpREREwJ49e2Hx4kUqr6dsEa+jowP9+7tC//6usGTJEnjw4AEEBwfDf/7zCwwbNgxMTOTajsuXr8Dq1ao6MnpoMTkGWFtbC3v37oWIiAjQ09ODLVu2gKenp8JFJD//GWtocZs2bagxwGvXrsH8+fOhvLwcSkpKGQXwbKHFP//8M7Rt2w4GDBgAgwcPhhUrVsDSpUuhZctWEBERAbt374KFCxeqvB6pIyOLBFK/NXDgQEhLWwq3bt2ixgCDgoKo8cqLFy8yzu/TQ4vJMcDa2lrYtm07hISEgIGBPuzevRtcXV0V9khuEsAcWty6dRtKv3XhwgVISUmBysoP8PbtW4UZffoeMYUW169fH37//XeorUUYNMgT0tMzYMGChdCuXVuIjIykCillKFvE161bF7y9vcHb2xuWLVsG165dg6Cg4aCvrwfBwSHQvbt8dPDcuXOMe0S3iLe0tARLS0uoqamBvLw8CAgIAD09PTh48CDY29sr7NGjR4+pzxMdt2/fhlatWimMAU6ZkgCfPn2C8vJyxtESuY7sLXTsqHjx1dfXh759+4COTh3w8PCAzMxMKC4ugU6dfoOwsDDYunUrzJmjqiOTSqUglUopQ4569epRQbXLly+HS5cuQUBAIDRq1AjCwkKpIuT06dOMGim5RfyPUK9ePbCzswM7OzuQSqWwbt168PX1BX19fThx4oRKgXb//gNWi3jSUIgcA4yPj4PPnz/D+/cVMH26aoSD/H0UqxSVhoaGIJFIoG7dutC/f39YtmwZlJaWUvEUmzdvgZkzVfdcKpXCd999pAqpH3/8ERITEyExMRESEhJg3759IBaLoXXr1pCUlESZk7CBtNHXdGOmDHWhxWZmZrBv3z6ora2FtWvXgpubG8hkMqioqGDU+6kDGVrMB8oW8b/88gt1/j59+pQqVtq3bw/Tp0+nPuNbt27lrZESYhF/+/ZtaN++PezZswdqa2th5cqVlH4rICAAgoKCGAsITaHFTEhNTWXUMytDT0+Pup5OmTIFnj59CmKxmNJvaSq4voVFvIuLC7i4uEBNTQ0sXboUbG1toW7dulBVVcV7ZPLQoUO8R0eVLeIbNWpE3Uf99ddfkJycDC9evICePXvCtGnTqM/khg0bGDVS79+/Bx0dHdDX14cJEybAhAkT4M2bN5CcnAzR0dG8A70fP34M7du3hwMHDsDnz58hNTUVrKys4Mcff4QRI0aAp6cn6zq+Rhlz586F5cuXa3xe8+bNqc94dnY2yIkKLbTgj/91Rdb58+chNDQU6tWrR90g3L17D9LS0uDRo8ewePESCA8PU+gqZGdng6urKiMFIL95X706G3R0dKC4uAQyMtJh9eocaNCgPtStW5cTIwUgv+F2cHCADRs2QmZmBqxdu5bSb/n4+MCPP/4IrVoxOxuuWZMLsbH/dFy6d+8GixYtAplMBgMHDoTU1FSoqamBfv36gZeXF9StW/fvrC1m0fe+ff8wUmRe019//QULFsynxPyhoaEKjAKZtcWEa9f+oPaosLAQ0tMzID09HQwM9NXukb+/ouBUR0cH3NzcYNu27bBixXJYvXo1BAXJNVIBAf5Qr973rIzU6tXZMG7cOOrnvn37Qt++fUEmk1GdMwAEZ2dn8PDwAB0dnb+dDXszvh5ZSNWvX5/KRrty5QrMnDkDHjx4ADk5uRAcPFzhYpqTw8xIyffoKmRlZUHdunWhoKAA0tMzYPHiJdC4sSF8911dlqwtRUaK3CMvr0Gwd+9eWLZsKWRlZUFQ0HDQ1W0AQUHDQUenjhpGKhuio8dQP5uYmICJiQlIpTXUHsn/D9zBxcUZdHR0/nY2ZGek5s+fD7q6ujBnzmwAkHfvp05NhPv378OmTZsgICBAwVRizZo1YGdnx/h6V65cofbo8ePHkJmZCa9fF0GLFs1Z90iZkQKQF27Dhg2DI0eOwqJFiyArayVs3LgR9PX1qRtBNkZq1apVf7NqclhZWYGVlRV8/vwZBgwYAPPmzYN69erBoEGDoF+/flCnTh2KzWHCtm3bKEaKLPRPnDgBkyZNgvv3H8DOnTsU9FsAJCNlw/h65B7Vq1cP7t27B5mZK6GkpATatm0LOjrfsTJSQ4cOUfhdvXr1ICgoEE6ePAkLFsz/W5eaC4aGjSA8PBxqamSMWVsA8nwzUsCto6MD9vb2YG9vT7mczps3D3788UcYOnQoWFrK3QeZnA1JbN68BWbNmgkGBgZUQ+rw4cMwfvx4ePDgIRw6dAgGDx6s8P+/ceNGsLU1B3peFonjx4/DpUuX4Pvvv4eLFy9CXFwcvHnzhnID1NfXV3kPiYmJCowUF6hjf+nQ0dGhiuSPHz9Cx44dYcyYMVC/fn1O+i0AgMWLF8PatWt5vb/FixeDi4sL42Pt2rWjNFenTp2CUaNGwdu3b4EgCKhTpw5vjdTFixchNTWV15qkpCTqhppkMcPDw+H9+/eQkpJC6bcmTpxIudPt379fY8GsjJqaGqioqGCd+GDDiRMn4Nq1a/Dzzz/DgQMHICQkBN6/fw+Ojo4QGxvLWEhNmzaNt0bq3r17nBipunXrQnR0NERHR8Pbt2+hS5cuMH78+L/z5qZwcoJcuHAhYyNGHdLT0yk3WmX06NEDtm3bBgByN09fX1/4+PEjODg4sDoAM2VtNW7cmGqy8TWHoDNS33//PcTFxVGf+cTERJg3bx5l3EHqNNUxUmwgm7JMmZTq8PTpU8aGnhZacME3L7Lq1KnjCACLAeA7AMhCxNlsz0VEqFNHR+VG4/ffO0PHjh3B1tYW/vOfX2DixInw+fNnsLa2Bm9vbzWMVIFCaLGh4T/jMiNHjgTEWggICICuXbtS4zIA8rEOJvqcDC1mGpc5fvw4dOnSBR4/fqzAGpCMFHNo8S6ws+sHo0aNhOrqasjNzYWQkBD4+eefoajoDeTm5qisYQst7tGjB3Tq1JnqAMXExIBMJgN7e3sYNGgQKyOlbBEvDwVOAgCAESNGQk2NFAICAqB3794QEhJCHTc//xnjReH69evQokVzhTFAeeGWDqdPn4bu3bvD8+fPFTqK8k7be0aXqP3794OtrS1ER0f/PQYoDwWuX/8XePPmDWN3ky202NjYGK5evQZWVlZQr149KhTYxcUZBgwYABcvXmR0NpSHFv9jEd+qVSuYMSPl7z0aAZ8+fYKAgEAQiYwhKCiIunizuVr9+eef0KxZU/jll1+oMcDnz59Deno6XLhwAXr27AmFhYUKltLkBYJJfHv48CGwsbGGcePGQUVFBVW46enpwuvXRZCZmaGyprq6mtGQw8zMDO7evQsWFuago/MdZSoxYMAAcHR0ZGWk3rx5ozDa16FDB4pZi4qKgsrKDxAYGAimpqbg7+9PFW7qGKkmTRqDvr4eTJgw4e/nyhsIV65cgT59+kBxcbGCRTrpbMh08T1x4gRYWVlBbGwslJW9g4yMdFi/fgM0bGgARUVFsHSpauAtW2ixtbU15Ofng0QigTp16vwdCvw9ZV9++vRpRqZDObS4c+fOVDxFZGQkfPhQAUFBQWBlZQU+Pj7U89QxUoaGjSgbd/J36enpcP36dTA2Noaysncq758ttPjMmTNgYWEJEyfG//29lkHFU7x8+QrS0paorGEKLdbR0QFHR0d4/fo1iEQEVFZWQkhICPz000/g4+MD5ubmcOLEib9vFuVW7iTevHmjwEiJxWKKKdmwYQN4eHiAVCqFIUOGQFRUFHW+Xbt2jXNoMYnk5GTeXfcjR46Ai4sLZGZmwrNnzyAxMRGmTp1KuQEqW1oDyIuEjx8/qg0tZsL27ds5MVIkA1xbWws2NjZQUlIC5ubm4OfnByEhIRpv/oVaxBcUFDBeAxo0aEAxyQ8fPoTExESIjY2F3377DR49ekSN0XHFtHVUGwAA9IxJREFUihUrOBWydCgzUk5OTuDk5AQ1NTWQnp4O9vb28N1330FwcDAMGzaM+tvPnTvHOzYgKSmJ8fOpDpcvXwZHR0fIycmh3AALCgqge/fuMG3aNMZzhUtoMRO4WsS7u7uDu7s7fP78GWxtbeH169dgZWUFUVFRCtblp0+fhtmzVW/jhFrEP3r0SMW4B0BeuK1YsQIA5EZfycnJUFhYCH369IHbt29TY71cIcQi/vPnzwAAvBlyLbQg8U2LrDp16nwHAMsAoB8AvACAK3Xq1NmNiHeYnl9RUcE6a0wWUjo6OtCvnx18/vwZ1q1bB35+fvDmzRs4deqUygeIiZH651gfIDc3hxqXiYuLBalUCr/++iura19ubq6KBaqhoSFMnjwZHj16DJGRkSrjMseOHQMjI+Y5/H379lM3Lj/88APl5JSfnw8hISEwcuRIaNKkKUREhFM31/SsLWVcvXoFVq9eTVm5V1V9gjVrcsHPzw+Kiorg0qVLKmMaZNYWEz58qIDc3FxKv0W6AXbp0oXVtW/16tUqFvGki1BQ0HAIDAz8ewzwPfTp0xuCg4Ph+PHjKllbJHbt2kVZHv/8888wapS8mH78+DGEhYXBiBEjqDFAspDNyclhvShfunQRsrOzqVHADx8+QHZ2Nvj6+kJRkTw7SbnAJrO2mPfoA6xfv44aAyQLt169ekKTJsxd8tWrc6jiikTr1q0hJSUFgoKGw9ChQyn9llhMQGBgEBw/fozR2RBAriMjbwzq168PY8eOBQC541tUVBSMHj0G2rZtCxEREdCsmfw95ebmsjJSZCElHwUcCuXl5ZCVlQXr1q2DoqI3cOfOHZXcLzJriwmVlR8hLy8PampqYPPmzVThZmRkpNa1b8SIEQq/+/XXX2H27NkQFBQEbm5uf+u3qsDc3ByGDRsGp06dgq5duzK+3rZt26jRPn19PYiPl1uN3759G0aNGgXR0WOgY8eOEBERQWmS6Flbyjh16hS1RwEBAfD27VvIyMiA7OxsKCp6Aw8fPlIZrUtPT4chQ5gt4j9+rIJNmzZRY4Dy8eYfQSIxYd0jOiNF4vffO8OCBQsgICAQ7OzsqDFAGxsbGDrUG06ePMnobAgAsGXLVpg1Sz6KKu+uywuQGzduQHR0NIwdGwNdu3aBsLAw0NPTAwDFrC1lnDx5ElauXAn16tWD0NBQKCoqgszMTEhPT4eioiJ4/vw5dOjQDOhFVlJSksr/O4C8cBs2bBgMGzYMPn78CHPnzqXcAN3d3XnrtwDkDSamZpo6LFmyhNIjtWnTRkG/FR0dDaWlpWBhYQFTpkyhnGDVMVJsKCkp4e3ap6OjA58+fYI7d+7Ax48fYebMmZR+KzY2VsWlk4RQi3gmF1FldOzYkbLUP3z4MAwZMgQGDRrEWb8FAJCXlwdHjx7l9f7YGCll/da0adNg+fLl0KhRI/Dx8VHr/sgGIRbxCxcupBoxdDfAPXv2gJ+fH3z8+BGcnJwo/RaAekaKDUIs4r///nuQSqXw4MEDKC0thaSkJEq/5e/vz1pIJSYmUt+rXHHs2DHKmVUd+vTpQ+m3Nm/eDBs2bABfX18YMGAAJ/0WgHwK4+DBg7ze3/79+3nrG7XQgo5vzWSJAOARIj4BAKhTp04eALgDAGOR9fHjR+jWTfUm6fnz56Cr20Dhg/3999/D8OHD4fHjxxAaGgrnzp2DnJwcMDQ0hPDwcOjYsSMrI3X58mVo00bOpCiPywwePBjq168PkZGRCuMyyllbdJChxd26daPGZQ4dOgwTJkyABw8eQEBAgEoGC2k1z/Tlt2fPXoiKioKBAwfCzZs3YfHixVBWVgY9evSA69evM1rzvnz5En75RdEi/qeffoTw8HB4+fIl+PsHwMGDhyA9PQOaN28G4eHh0LZtW5WsLRJyi/iW1B6R+q2qqk8wZMhgqF+/AYwYMRL8/IZRGiuy06YutJiu39q9ezdER0fDw4ePICwsVCVfhNRIsVmFR0REgJeXF1y5chXmzp0D799XgJGREVy+fImxy1VYWAj/+Y+iIccvv/wCo0ePhtLSUhgyZAjs2LET0tLSoFWrVhAZGQktWrRQydoicf36n1THkRwD9PIaBB8+fABvb2+oX78+jBo1SkG/9Q8j1Vbl9Q4cOAA9enRX0m9tg5EjR8Djx48hKiqKcY/YLOJPnToFISEh4O3tDefOnYOUlOlQWVkJYrEYzp07x2jnyxRarKurC+PGjYPk5GTw8PCA9es3wIIFC6F9+3YQEREBTZo0gcePnzDeqN28eQuaNpVbxNetWxd8fHzAx8cHysvLwdfXlzL1CA0NpQok5awtOg4fPgxdu3ZV0W9FRkbCkydPYMyYMSp7RGZtMYUWX7x4EYKChoOf3zA4ceIEJCTI9VuWlpZw+vQZRmaTKbTYwMAAJk6cCCkpKeDk5AxZWVlQUlICnTt3gvDwcDAwMFDJ2iJBt4gnxwCDggKhpKQEAgICqLG0sLAwBaakpKSUkZE6cuQo/P57Z0qXSjakwsJCIT8/H2JixqmsYWKkSPzxx3UICAgAf3//vxtScSCVSsHGxgZOnDjByNq9fftWgbUDkMdTyO2TZ4O1tTWkpaVBUdF0aNzYBhITE8HAwAD++OMPjZqJn3/+GZKSkiApKQmeP38OZmZmoKenB4MHD4bk5GRWgwQ6du7cqRJarAkkI8VU0JmZmcH+/fuhtrYWcnNzoX///iCTycDHxwe2bt0KJ06c4HWsL7WI/+WXXyjtJjnuNGnSJPj1119h2rRpCiNTQgw5hFjE3717F6Kjo2HKlCmQkZEBjo6OUKdOHRg+fDgEBAQw3riThhxMpkzqwIWR0tPTo7S5d+/ehX79+oGenh4EBQXB9OnTOY0nfolFPBMj1b9/f+jfvz/U1NRAWloa2NraQr169SA8PBzWr1/P25BjxowZEBQUxGsNnZEyNDSkGOI///wTJkyYAEVFRRAeHg7JyckKnwW20GJ1mDdvHsVWcUVZWRlERkZS5h1WVlbw008/wciRI8HDw4Nxzfv37zkbctBx8eJFxmxCLbTgDCbLwa/1DwAGgXxEkPzZDwCWKj0nDACuAsBVfX09nDIlBo8d2401NeWI+AERP2BgoBeeOXOQ+pn+z9LSSOHnq1dPoZeXM/bp0wm7dWuHxcX5Kmvc3Gzx6dNbKr+Xyd5Tr/fq1UOMjPRHC4u+6O3thklJE3DKlBjG92BnZ4IVFa9Vfl9R8RptbAicOXMyWlkZo4uLFe7fvwURP+CUKTG4atUS1r9JJnuv8t4WLZqBLVvqo40NgcuXz0Op9B31+PDhQ/DEib2c9uj8+SM4cKAD9u3bGXv06IBlZS9U1ri72+HDh3+q3aNnz+5gSIg3WloaYUDAIJw9ewpOnDia8T306yfB8vJXjHtkaWmEiYnj0crKGN3cbKm/Izk5FjMyFjK+npWVMeMezZ2biC1a6KGtrRhXrVqi8JzQUB88enQX4+tZWPRV+Pn48T3o5maLxsZdsGfPXxn/fz087PH+/T/U7tHDh39iQMAgtLDoi8HBQzE1NQXj40cxvgd7e1N8+7ZA5feVlW/QwqIvTpw4Gi0tjdDDwx7Pnz+CiB8wJWUiLl06h3WP6OcI4geUSt/hzJmTsUULPbS3N8X16zMV9ig8fBgePLiN03l08OA2dHW1RpGoK/bq1RGrqkpU1nh6OuLt25cZ94jc81u3LqGPjztaWhphZKQ/rlgxH8eNi2B8Dw4OZlhS8kzl91VVJWhm1htjYsLR0tIIBw92wWvXTiPiB5w9ewouXjyT8x5VV7/FxMTx2Ly5Ljo6muO2bWsUHh8xIhD37MnjtEc7dqxDJycLJIhu2Lv3b1hd/VZlzeDBLvjXXxfUvt4ff5zBwYNd0MKiL0ZHh+Lq1UsxOjqUcY2jozm+efNU5ffV1W9RIumJI0YEoqWlEXp7u1HHnT8/GRcunM74etbWIpX3XVVVgpMmjcHmzXXRxcUK9+7dpPD46NHBuGPHOo17JJO9x3Xr1qGlpSX27dsXHR0dkS9Im+nz58+ji4sLEgSBY8eOxbKyMtY1Qizi58+fjykpKZyfX1lZiWPHjkU9PT20t7fHo0ePcl4rxNp74MCBGi3ijx07hg4ODkgQBMbHx+OmTZswODiY13G+pkX8u3fvcPz48UgQBDo5OalYk0dHR+PatWt5HedLLeL379+P/fr1Q4IgMDExET9+/Mi6xs7O7ptbxBcXF2NISAjq6emhm5sbrxiAb2URv23bNrS2tkaxWIwzZ87E/fv3o5+fH6/jsFnEa4KpqamKRXxhYSGGh4ejSCRCDw8PvHHjhsLjsbGxuHLlSl7Hefv2Lc6ePZv3+9PivxPAYuH+rYssL4YiK43t+X379sWamho8dOgQTpw4EadNm4Y3b95kzTU4evQo6wfb3t4eFy9ejFZWVmhiYoLz589HqVSq9oOdnp6OEydOVPn9pUuXsGHDhti3b18cNWqUQl5CeXk5mpmZMb5efHw8ZmRkUD8XFBRgUFAQikQi1NfXx5s3b6qsefz4MWv2g6+vLx47dgwrKysxMTERxWIx2tnZ4f79+1n/ppMnT6KPjw/jYw4ODjhnzhy0sLBAU1NTTEtLw5qaGpTJZKx7npWVhRMmTFD5/enTp9HAwAD79u2L48ePx/LycuqxiooK1j2aNGkSLlu2jPr5yZMn6OfnhwRBoIGBAT548EBlTX5+Ptrb2zO+XkBAAB4+fBgrKiowPj4eCYJAR0dHPHHiBOsenTlzBocMGcL4mLOzMyYmJqKZmRmamZlhVlYWymQytedRbm4ujh07VuX3hw4dQgMDA+zTpw9OnjwZP3z4QD1WWVmJpqamjK+XmJiIS5YsoX6+d+8eDhkyBEUiETZs2BCfPHmisub58+doZ2fH+HqBgYG4b98+LCsrw7FjxyJBEOjs7Iznz59n/ZsuXLiAXl5ejI+5uLhgfHw8mpqaoqWlJa5bt47aI7bzaP369Thq1CiV3+/Zswf19fWxb9++OH36dIWbsqqqKjQxMWF8venTpyvkrNy8eRMHDhyIBEGgoaEhY07Ny5cv0cbGhvH1QkJCcNeuXVhUVISRkZFIEAQOGDAAr127xvo3XblyBQcOHMj4mKurK0ZHR6OJiQlaW1vj1q1bqcfY9nzTpk0YFRXF+Ht9fX3s06cPzp07VyGnprq6mnWPZs6ciXPmzKF+vnz5Mrq5uaGxsTEaGhriq1evVNa8fv0ara2tGV8vIiICt27dii9fvsTg4GAkCAI9PT3x1q1brH8TmY3DBHd3d7x69SrjY2zYvn07hoeHK/xOJpNhbm4uWlhYoEQiwSVLllD5W4jq90gduOZI0TFy5EjMy8vD/Px89Pf3R4Ig0Nvbm/F7jcTNmzexf//+vN8f23nJBJlMhhkZGainp4dGRkaYkZHB+WY8NTUVk5OTeb230tJStLS0VPuc+/fvU99r/v7+mJ+fL6hI8PLywvPnz/Nas3//fgwMDFT4nVQqxSVLllDfa2vXrlV4L0KLTVNTU6ysrOS1JiYmBnNycvDmzZvo6emJBEFgSEgIvnz5knXNgwcP0MnJiff741P4VFdX45w5c1BPTw+NjY1xy5YtnNey3W+pg7r7LRJXrlxBd3d3FIlEGBUVhcXFxYLOo4yMDHz8+DGvNVr89+J/qsgyAYBDtJ8nAsBEtuf37dtX4U1XVFRgTk4Ouru746JFi1Q6jw4ODvj06VOVP1b55o4eMvfbb7+x3gixheiVl5ejubk5ymQy3LBhA1paWqKJiQmmpqbihAkTWDskbB/sJ0+eoEgkQldXVxSJRDh69GiqcPPx8cHjx4+zvp4ynj17hnZ2dtioUSP08vLCu3fvKjzu5OSEjx49UlmnXCRUVlbilClTUCwWY+fOndHT05PxPZibmysUUCQqKirQ1NQUZTIZZmdnU+GZy5cvx4kTJ+Ly5ctZ/yamPcrPz8c+ffqgk5MTEgSBsbGx1HH9/f3x8OHDrK+njEePHqG3tze2a9cOfX19VYoSZ2dnxtBR5T0qLy/HCRMmIEEQ2K1bN9aiw8LCgrGLXllZiRKJBGUyGS5btgxNTU3R3NwcV69ejVOmTFEopOgQi8UKN4kknj9/jj179kR7e3skCAKnTJlCXbwDAwNx//79jK/HdDN2584dtLS0xIYNG2JgYKBKUeLq6oq3b99WWaf8WSstLcXRo0cjQRDYs2dPHDx4MON7sLS0ZAx3rKqqQolEglKpFBcsWIASiQQtLS1xw4YNmJSUxBp8yrZHL1++xK5du6KtrS2amJgohGeShRQTmM4jskBo3bo1hoeH4+vXrxUed3Nzw7/++ktlnUwmQ2NjY+rnoqIijIiIQIIg0MjIiHWPrKyssLi4WOX31dXV1A1/SkoKisVitLa2xh07duDMmTNx7ty5jK8nFotVgkMR5YVU586dqe81siGFiBgeHo7btm1jfD2mPbp06RKampqivr6+SkMKEXHAgAF4/fp1zq+nCZoYKXpDql+/fnjw4MGvElrMFUzfb6dOnaK+1yZMmKDyfSo0tDgkJITXGqlUiiYmJlheXo6xsbEKDSl1EFJsjh49GtetW8f5+QcPHkSCIFBPTw8TEhJ4FSVCziM7Ozt8/vw56+P0hpSLiwueP38elyxZgomJibyOoxxazBVM59GuXbvQ1tYWxWIxpqSkqPyfCAktPnz4MPr7+/NaI5PJUCwWKzSk3N3d8dq1a2rXMTFSmqDufksZtbW1mJeXh0ZGRqinp4fz5s3Dz58/cz5WXFwcr/emxX83/qeKrLoA8AQA2gHA9wBwAwC6sj1fucii48WLF7hw4UKMjY3F9evXY0VFBWsXafny5Thp0iTGxwiCwMDAQKrrSrJJ6jokTFRzVVUVJicnY/v27dHGxgb37Nmj8Li6NHJfX1/qQiaTyXDt2rVU17V169aMN4snTpxgZaQcHR3x0aNHePbsWXRxcUGRSIRjx47F0tJS1gvOypUrMTY2lvExgiDQx8cHCYLAIUOGUAWIOkaKqZD68OEDTp48GRs0aID9+vVTGZdRx0jRCymZTIYrV65Ec3NzNDMzwzZt2jAWZuoYKRLHjh1DR0dHJAgCJ06ciO/fv2ftAOfk5GBMTAzjYyKRCL28vJAgCPTz86OKfXWMFFMhVVZWhuPHj8c2bdqgo6OjykWRLKKZQC+kpFIppqWloUQiQXNzc2zfvj3jHp0/f561OCQLqX379qGdnR01LlNZWcl6Hq1btw5Hjx7N+JhIJEJ3d3ckCAKDg4OpritZSDEhOTkZU1NTFX5XXFyMo0aNQl1dXXR1dcUrV64oPP7y5Uu0tbVlfL3g4GDcvXs3IsqLk/nz56NEIkErKyvs0KED45rLly+zNhlIbN26Fa2trdHExARnzZqFnz59Yt2jvLw8RkYKEdHIyAidnZ2RIAiMjIzEoqIi6r2y7RFTIVVYWIihoaHYqlUrdHd3VxmXKSwsVMtIbd++HRHl/zfTp09HsViMNjY22LFjR8Y16hipAQMG4B9//EE1pCQSCaampqJUKmXdo61bt2JERATjY2zgy0g9e/YMAwMDUVdXFwcNGsTYWGFDVFQUbtq0idf7u3nzJrq5ubE+LpPJMCsri2pIpaenq2V/1cHW1lYtq8GEBQsW4PTp0xV+9+jRI/Tx8UGRSMTYkOLCSDFBKCN19uxZXLp0qUJDSt3r7Nu3T4WR0gR15yUT7ty5g15eXqirq4t+fn6MLDkbSEaKD+7du4fOzs6sj9MbUlZWVpiXlyd4FM/e3h7z8/N5rWG63yK/H0QiEUZERFDfayS4MFJMEIlEvM8jHx8fPHToEM6YMYP6Xtu5c6faNY8ePVKYQtJCC034Hymy5McFZwB4AACPAWCyuueqK7Lo+PPPPzEmJgbt7e3x2LFjKh86tg4JyUiRIMdlyK77okWLGI+n6QJRUFBAjcsMGjQIb926xZuRQpSPLHTp0gXFYjHa2toqMBFkIaUMpi9TclxGJBJh27ZtVcZlEDUzUiTOnDmDzs7OKBKJ0MjISOUGmP43sTFS5Bc3OQZIjsv4+fnhkSNHWF+PCQcPHsTffvsNxWIxOjg44LFjx6jHnJycON84keMyHTp0wGbNmuHKlStV3r86Roq+R4cPH6bYJJIJYAIb20KCHAMkCAIDAgKom8IDBw4wPp9tjw4dOoQdOnRAkUiEzs7OeO7cOeoxFxcXvHPnjsoapps7qVSKixYtwr59+2KbNm1UxmUQ5XukjpEisWfPHqrramFhoZZtYWOkbG1tGcdl+DJSiPL/szZt2jB2Xd3c3BhHeZlAjsuQ5xF9DJAEGyP16dMnhSJhy5YtVOHWr18/Vj2AiYkJIyNFgj4uM3LkSCwuLubNSCHKP2utWrVCkUiEAwcOVNgTPowU2ZDq06cPtm7dWqUhhYhobW2tciOmCXPmzMFZs2bxWvPmzRu0srJSaEjFxMSo1W8hCmNHuGikSFRUVOCkSZPwt99+w2bNmil8r2nC19RI0XH06FFKvzVx4kSsqKjgzUghIt66dQtdXV15vz/lPS8rK8Nx48ZR481nz55VWWNnZ8er6EFEXLx4sWBGimxIicViTEpK0sjwfSuNFIni4mIcOXIkdurUCZs3b67SkFIHoYUZ2wQQia1bt6KNjQ2amJjgnDlzsLq6mhcjReLBgwdfpNkk8erVKwwNDUWCIHDgwIGM0wezZs3Ct2/f8j6WFv+9+B8rsvj841pkkZBKpXjw4EGMj4/HadOm4a1btzQyUllZWSq/l8lk+Ouvv1Jd1wULFlA3eg8fPuT1wb548SK6urpigwYNFMYASRw7dgx9fX0Z1zo4OFCFFHmDTTJuvXr1YlyTmZmpltYmxwAJgkA7Ozs8ePCgRkYqPT1d5fcymQzbt29PdV2XLVtGXSyePHnCytr5+fmpMFjkuEzTpk0Zx2VOnz6NQ4cOZXw9JycnSs/w5MkT9PX1pQo3vucPorzYfP78ucK4zMmTJzUyUmlpaSq/l8lk2K5dO6rrmp2dTe2ROkaKCQcPHkR7e3vU1dVVGAMkcfbsWbUaKbKQIruuIpEIAwICsHfv3oxr1q5di9HR0azvp7S0FMeMGYMikYgal9HESDE1LaRSKbZu3RpNTEzQ0tIS169fT+2RJkZK+eacHJdp3Lgx47iMOkaKXkjduHGD0m+FhoaikZER6z6wwcrKCu/cuUONAZJFiDod2YwZMxgL8urqamzVqhXVdSVZJkT1jJQyZDIZ5uXloZWVFTZo0EBhDJDEtWvX0MPDg3G9u7s7VUhdvnwZ+/fvTxVubJ+1LVu2qGWk6LpUsiElVCOlqdhkQlRUFG7evJn6WSaTYU5OjoIuVXmP/vzzT3R3d+f9/oSOP164cEGhIcXUXKNj/vz5KoyUJvAZf5TJZJieno5mZmaoq6tL6VK5YtCgQXjx4kVe72/fvn0YFBTE+vjdu3ephpS/vz8+e/aMNyNFQiKR8NZIjR07FnNzc6mfyYYUOd5M6lLp+FJDDj6wt7fHgwcPUg2p0NBQjUYvy5Ytw4SEBF7HUW5cq0N1dTXOnj0bTUxMUFdXl7EhpQ7e3t546tQpXmuOHj2Kw4YNY32cbLTTG1K1tbXaUUEteOP/yyKLjvfv32Nubi4OHDgQvb29VfQSiOxdJLpAlByXMTExQVtbWzQzM9M4o66Mo0ePoq+vL+WaRR+XcXBwYDQqUNdFio2NxbZt26KxsbGKa5aZmRm+f/+e0/sixdfNmjXDXr16MbI+6nRkZCFVWVmJCQkJSBAE9uvXD62srHgzUoj/jMuYmZkpjMvQCynl56vbo9DQUNZjMYHUSNFBjst07NgRjY2NGf+vCIJgZFuePXuG/fr1Q0T5xYfumkXqQfiALKTS0tLQ1NQULSwsMCcnB2UyGbq4uKjo7xCZGSkSY8eOxZYtWyqMAZJgY6SYcOvWLRw0aBA2b94cjYyMGDvHbIxUQUEBVUiRY4AEQaCrqys6OTkxshyI6kX9UqlUYQyQHJdxc3PDW7duqTxfWSNFR3R0NAYEBLAeiwlMhRQ5LtOxY0c0MTFhZGnY9qiwsJAy5CBdswiCQA8PD3R3d1courjgypUr6ObmRulSbWxsKOaPr0ZKJpPhqFGjsGnTpmhiYqLQkEKUF5tcGakLFy6gq6srVVByPf8Q5bo2rsUmHeq+j+i6VPrn1cPDgxcjgIi4c+dO3t9HTIzUyZMnGXWpdJiYmPDWSI0aNQo3bNjAa83NmzfRwcGB0qU6OjpyuukVqpHiykgdOHAA+/Xrh23atOFtKlFaWipII6VubI2uS3V1daUKzCFDhjCyb+pw8OBB3uOPTNfJnTt3oo2NDaXfYmpOCDHkGD9+PGPjWh0ePHiAVlZWKg0pTRByHrHdbymDbEhZWlpi7969eY8Ga6HF//dFFh0FBQW4YMECjI2NxQ0bNmBlZaVapx1vb288efKkyu9fvnyJ7du353185Q92VVUVJiUloVgsxsaNG+O+fftU1mRkZGB8fDzj65F0vLJr1rx581jZFnUQi8V4+vRpagyQHJfhy0ghygu3Ro0aIUEQOHToUIXi6NSpU+jt7c3pPZHjMgRBoL6+PuOxVq1axehsiMg+/qgOCQkJCs6GyqCPy0yaNAkrKiowPz+fKqSUERAQwFhIPXjwANu0acPrvSHKGSl6IVxWVoYxMTFIEAQ2btyY8YKtjpGysLDAt2/folQqxcWLF6NEIkELCwvMyspiZaTUQSwW486dO9HW1hYJgsDk5GSsqqrCgoICVtYuKCgI9+7dq/L7mzdvYsOGDVX0W4hydnjQoEGc3hM5LiMSidDAwIDx5njDhg2MzoaI8iKBz80+ImJKSgrriCiion6LHJd59eoVq7NhaGgoo2bg2rVr2LJlS17vDVGRkUJEasSSIAhs0qQJ42jk5s2bMTIykvH1yNE+cgyQHG/evn27YEZq9erV1PfaokWL1I7VIiJGRkbycjJDVK8jU0Z+fj4GBAQgQRDYsGFDXvotxK9vEa+sSyUbUl/TkEMTlA05Hjx4gN7e3pQulUnLs3fvXhw+fDiv43wJI7Vw4UJqkoBsSKlDdHQ0rlmzhtdx+DBSt27dQk9PTxSJRKwup+rQr18/3hbx6hgpZV0qWUyUlZVxZqToEKKRGjp0qEJxfu3aNRwwYICKLpUOdU7SbBA6/jh58mTeDLkWWvxXFVkkamtr8fr161SBM2/ePMYvBLYPIslI8YGmDzY5LkMQBHp5eVFjXWw6MrbRPnKcTd3NHROUCymZTIarV69Gc3NzbNGiBUZFRfHao5MnT1KFFDkGKBKJcPz48Whra6vWqpgJ2dnZGBwcjH5+figSiRTGZbjqyLiC640GfVymcePGOGrUKF57xMWQg+mY6s6jO3fuqOi3EP8ppJTBxNohyrNACILgPW70/PlzhdE+qVSKqampKJFIsGXLlhgTE8Nrjy5dukQVUrt27UIbGxvqfTk5OTEyUuqwYcMGHDJkiMIYIHnTq8nZkC9MTEw0FgWI8hucWbNmoYmJCTZt2hTHjx/P+Dy2Pbpy5QrraJ86qGMBL126RI3L0N0A2RgpttG+goIC7Nu3L06ePJnXe1NmpEg3QIIg0NbWlrEhhSisq+3h4aHR8UwZO3bsQBcXF6ohNW7cOHz37p3aNV8y/siFkaqoqMCJEyeiWCzGli1bspo8sUGTIQcb1O05U0MKUW7I8eLFC17HSU1NxaSkJF5rlBkp5XgKui6VDqGGHGyvx4b9+/ejlZUVpUslG1Lq8K3HH8mGFEEQ2K5dO17ZXYjCLeLVfR/RdalkQwqROyNFhxCL+E+fPvHeBy20QPwvLbLoIPVbEydOxOnTp1N21Oo6JEI/2GyMlDLI8EwjIyNs1qwZo/haOWuLDiEXCDJriwkfPnzAhIQEalyGdPc7deqUWmdD5UKK7Lq2bduW13tDVC2kTpw4gY6OjigSibB169aMRZZy1hYXqGOk1MHIyEhBv0V25DRlbfHthLNlbTGBDM8UiUTYsmVLxgusctYWHWzjj+oQFBTEegNcXFyMo0ePpmIKLl26hIjqGSlXV1eVQkoqleK8efOwdevWvN4bomohRR+XadeuHWOnUjlriwvUZW2pQ9++falxGQ8PD4ppUpe15ebmpuIaqAlsWVvKoOu3TExMsE2bNoznxKxZsxSytugQopEis7aYQNel0htSfBgpOr7UIp7UbzHpUumYO3cuzpgxg9dxiouLBbn29e7dm9Kl+vj4aNRvIQqziN+zZw+n0GKZTIbLly+nRsDZXE7VQYhF/JgxY1hDi+/cuYODBw+mnIVJNunf1Ej169ePOq5UKsWFCxdSkwR0XSodfEOLEYUzUj179kQPDw8UiUQYHh7OiYUVahHPhZGiN6SsrKywU6dOvI6DqNmQgwnbt2/HCxcu8D6WFlr81xdZdLx//x5zcnIwLi4Ou3TpwnjB+VZOO0yIjY3FgIAAtLS0RFNTUwU3QLZC6tGjR1/FaYcN9PDMxo0bM+ZSCQktVgd1hhx0Nomu30IUVmyqy9piw5kzZxQMOejjMi1atGAccRR6HrE5G6rDlClTcMCAAZR+Kzc3l9oXNv0PX0MOElxtpulugC1atGB03FR3HqmziGeDOkZK+eJNn73X5P7IBHXOhmy4fPmyQiFFH5dp27Yt4+iyUGtvNmdDdZg+fTqVK2Zra0tZ4COyF1J8DDno4PrZIBtSpGMqX53stm3bVEKLNUEdI0XqUsViMdrb2ytoUk1MTPDTp0+8jhUVFYV5eXm81vz1118KjNTx48epeIr4+HjW65BQjRRfi/hZs2ahWCymdKlcbsi/tUU82ZAiCAI7derE+zxiCi3WBHXuj8q6VPq9yJeEFvOBskX89u3bqYYUPVdQGUK+j4RYxM+ZMwd79OhBNaS4NJr4GHLQERcXh7W1tbzXaaGFtshiwZMnT3DhwoUYFxeHGzduxI8fPyIiUiG6fCA0+4F+gaCHZ1pYWLB+kfn4+PC+QKjL2mKDTCbD33//XWEMkGST1GVtCdFITZo0iTW0mI6KigqMj49HgiDQ0tJSkKugkBsNdRbxe/fuZRyXUZe1xQZ1zobqQC8S6OMy/fr1Y73IqwstZsP58+c5a6RIyGQy7NixI3XzPm3aNKpbra6QYhvtUwemrC0mFBUVYVRUFIpEInRwcGA1w1AHIecRW2gxIuKaNWuocZm5c+dSNzjqsrbYoM7ZUB3ohRRdv+Xm5sb6euHh4bwNOYQwUqTLKanfYoqnYIK1tTVvjRTX0GJ6Q4psKPAFQRC8b+4GDhzIqDmUyWSYmZmJZmZmaGZmhhkZGdT15UtCi/mCzkg9ePAAhw4dSrkBst1oC7WI58tISaVSbNWqFZqamqKlpSVjPAUT6IwUV3ANLSYbUiKRCP39/QXZ8n9Ni/jq6mqcO3cu1ZCiayAPHjwoKLRYyGeDLqW4du0alb0YFRXF2kBic5JWh9LSUtbYDC200ARtkaUBdP3WpEmTsFu3bryLBCEfbHWM1JMnTygrX/q4DKKwmzu2rC11oBdSMpkMs7OzqXGZDh06MOoTvrVGig4PDw+0srJCkUjEeVxGmZHiAq4XCJlMhsuWLUNTU1M0MzPDDh068M7bYLOIVwd1jNRff/2FHh4eKuMyiMK6kS4uLtS4LVesXbuWKqTo4ZmWlpbYuXNnLCkpUVkjVCMlhJEi94cgCM7jMlxCi5XBlZGqrq7GmTNnUm6AnTt35s1IpaSk4Lx583itUcdInT17lhrdpeu3EIV9H3F1FaODHlpMb0jZ2dmx5slVV1cLumEVMv7o7u6OPXr0QJFIxBhPwYQbN258M4v49+/fY1xcHBIEgQ4ODtijR4+vElqsCeoYqcOHD6ODgwOKxWJMSEhQYGuEGCkMGjSI94gXPbT47du3GB0djQRBUPEUTBCaRyaEkerfvz/+/vvvlC6Vy/jk3bt31YYWs4HLeVRUVISRkZFIEPJcQWNjY96M1LJly3hrNtUxUps2bWJsSCEKu5dIT0/Hx48f81qjhRYktEUWD0ilUtyyZQvGx8cr6Lc0QcgHmysjde7cOXRxcaG6pYMHD+Z1HKFdJHVmEzExMdS4DH1Uji1rSx2ePHmC9vb2vN8f/Yb12LFjFJukblyGzSJeHbKzs3HcuHG81hQWFmKzZs14jcsgCisSAgICODFS5LiMWCzGwMBAVv0PG4SOrbFZxBcXF1NB3m5ubgrjMlwZKTrUZW2pA/2zQboBisVinDVrFuuNNp/QYhJ5eXk4cuRIXmvy8/PR0NCQ17gMovw8+vz5M69jcWGkZDIZbtiwAa2srFAikWBMTMy/liPFFlr87Nkzyg1wyJAhCoyzkNDioqIiQa595GeDjKcgG1LLly9nvTawMVLqIMQi/t69e5SDp6+vL2e9sRCN1KhRo3D9+vVqn0M2pMzMzNDc3ByTk5O/WZGgDDaLeDJXUCwWY1BQkMJzviS0mC/IewmyIUXmCm7cuJH1PBoyZAhvjdTBgwd5R1ZcvXoV9fX1eTWkEOXF5ocPH3gda8KECRob1/SGlLW1NS5btkyQIYc2G0uLL4G2yBKI9+/f4+rVqzEuLg6XLFnCmgHzLZx2mCCTybBbt25IEASvcRl1FvFsUKeRooM+LjN06FDs0aMH72LTz8+Pt0bq1KlTjIyUTCbDjIwMalxm5cqV1Pv5kmJTk6uYMqZMmUIZcpDjMuQoCFsXkJ61xQd8/yapVIqdO3fGPn36oIWFBedxmTVr1qgNLWYCV0aKrt8KCQnB3r178y42mUKLNYGNkaqursY5c+ZQF2/6uIzQ80iIRopuEX/16lV0d3dHkUikdlyGnrXFB3y/j6qqqvC3337Dnj17oq2tLee937JlC6tFPBu4uvadPXuW0m+NHTsWjYyMeDNSkZGRCqHFXHD9+nXGYpMeT6HckEL8ckMOrqBbxB87doyTfuvfsogvKyvDDh06YPfu3dHZ2ZlzsbB37161ocVM4Orat2/fPrSzs0OxWEw5FJNyAq5QDi3mAjZDDroboJubm0phLtSQgy8jtXTpUsoinh5Poa4h9W9ZxBcWFmK7du2wS5cuOHDgQM4NqYcPH2JmZibv96eFFiS0RdZXwPPnz3H+/Pk4YcIEBf0WInvWljpoSiNnAv3mrrKyEqdOnaoSnskEIYYc6pwN2bBx40aqW8p1XAZR2NgaF0aqvLxcwQ1w/PjxvA05vkQjxXSBOHjwINrb2yNBECrjMmxZW+pw9uxZQRbx5J5zHZdB5BdaTCIpKQkXLVrEa01WVhYaGBhQ4ZlcO+lCNVKaLOLp4zIDBgzAGTNmsGZtsUGoRoqN2dy0aRNaWVlR8RR01oota0sdhFrEk3teUFBAsZKDBg1Su6dsjJQ6zJ49m9XZkAkymQyXLFmC+vr6aGpqimlpaZyLdqEW8VevXlX7HPoIuLe3Ny5dupS3IYfQsTUmRkpdQwpReGixq6sr7/dHfh/du3dPQb+lLifK1taWt0Zq0aJFvCzipVIpzpgxA/X09NDCwgLXrVvH+cZfyHQLl9BiekMqNDQU169fz5uRkkqlgq67TBbx1dXVOHv2bKohpewYOn78eMzOzuZ1HKGNa/Kze/nyZSqeYuTIkWqbW7NmzeI91q+FFnRoi6yviNraWrx27RomJibipEmT8MSJE4K+rIRYxGdkZDAacqgbl+HKSCmDrUhQBzK0WHlchu4GqAx61hZXCGESHj16hIaGhmhkZITDhg3jvPeaQouZkJ+fr3H8kRyXkUgkaG5ujtnZ2YLOo69pEU+OyxAEoTIuw5a1pQlfYhEvlUoVwjPz8vJYzyM+ocUkhIw/Xr9+HRs2bIh9+vTBiIgIzsXC9OnTeefaqQstJlFVVYUpKSkoFovRxsYGd+7cKahIcHd3/2oW8RcvXkRXV1cUiUQ4evRohcL8S3KkhDBSW7ZswcrKSpwyZQqnhtS/ZRF/4sQJbNiwIfbu3RtjY2M5N6TUhRazgQsjpdyQOnnypKAiQYhF/O7duxkt4ukNqSlTpijc3H/NYlMToqOjce3atVhaWoqjR4+m3AAvXrzIuubfsojfuXMnGhgYYO/evTElJYXzZyQtLY01tJgNXBipoqIiKp6C1F0KNeQ4ffo0rzVHjhxRsYhXjqeYP3++wvWotrZWOyqoxRdDW2R9I0ilUty7dy/6+Pjg9OnT8e7du5zWfUuL+DNnzlDjMjExMTh69GjejJRyaDFXMN2wkuMyYrEYHRwcVHK6mLK2NEGoRTzJSLGFZzJBSLEZEBDAa/yxrKwMBw0ahA0bNkQnJyeNnUwSQjVS5ubmGi3i9+3bR4VnkoYwixcv5nWcZ8+efbFGioSmcRmmrC1N2LBhwxdZxNPHZWbPnq32BkeI1o4vI/Xy5Ut0dXXFhg0b8hqXQRTG3mgaf5TJZLhu3TrKDTA1NRVTUlJ4MVKIqqHFXMH02SDzt8RiMQ4dOlSlQTFgwADeocXbt28XbBFP5goyxVMwQUiRMHLkSF4W8Q8ePEB7e3vU19fnpd9CFDaVYGNjo9aQo6amBpcuXYqmpqZobm6OOTk5uHDhQkxOTuZ1HOXQYq5gKhJu3bqFgwYNYmxIIcpDi9VNBTBBqEU8QRBYXV2t0JCix1MwgWtoMR18LeKvXbuG1tbWqK+vz6shhSjs+0iTRTxTQ+rcuXO8WX8ttFCGtsj6F1BeXo7Z2dkYGxuLaWlpar9QhKSR881+IMMzdXV1USKRYFpaGtbU1HBaqy60mA1cLOLp4zI+Pj744MEDwUWCEIt4ZUaKnr9lZmaGWVlZChdTLowUE4RcIEhG6s6dOzhkyBBKv6VuXCYnJ4dzaDEJvoyUVCrF1NRU1NXVRXNzc17jMoGBgayhxWy4cOECenl5qX2O8rjMq1evBOdI8R1/ZAotpudvMY3LCA0t/hKLeD7jMlxDi+ngy0h9/PgRk5OTUVdXF62trXmdF+pCi9nAppGi48yZM+js7Ew1pMrKygQbcnwNi/iKigqcOHEiisVidHR0VPkO/rc0Uoj/MFJHjhxBe3t7FIlEGhtSu3bt4hRaTAdfRqqsrAxjYmKwQYMG6OjoyLkhhSjMIv727dsaxx/37NlD6beSk5OxqqpKsEbq+fPnvNYwhRYXFxfjiBEjKDdA5TFWoRqpL7GI37JlC9WQmjNnjtqG1OHDh7+5RTwZT9GtWzfeDLkWWihDW2T9y3j27BnOmzcPY2NjcdOmTSqCWaGhxStXruS1hrSIp4/L2Nvb46FDh9Su+zcs4k+ePIldunTBpk2b8hqX+VYW8crjMqdOnfoqocVcwHaBoIdnKo/LIHJjpJQxdepUXLJkCa81pEV8aWkpjhkzhtO4DKKw88jV1ZWXRfzOnTuxc+fO2LhxY5wxYwbnC+a3sohXHpf5888/MTg4WFBo8dewiJfJZLhx40a0tLREExMTXLBggcr7F2LIMXPmTJw7dy6vNaQhR0FBAQYFBaFIJMJBgwZp/P8WahH/xx9/cHou2ZAiz6Nly5Zxvpn8VhbxT548QV9fX6oh9ejRI4yKitLIUCjj5s2bCqHFXKG85zKZDJcvX065ASo3pBA1M1JMWLhwIU6bNo3XmpKSErS0tMS7d+/ikCFDqHgKTQWKkCLBy8uLs0U82ZDq3LkzGhoa8mpIfSuL+Bs3buDAgQMV3AC/RmgxVyifR2RDSiwWo7W1NaObqZDQ4uXLl+OkSZN4rfn06ZNKgaqFFkKgLbL+h1BbW4tXr16l9FunTp3Cd+/e/WtdJCaL+Pz8fFb9FiLi8ePHBYUWCx1/fPfuHa5cuRLNzc1VwjOZIMQi/unTp7wYqQcPHqC3tzfq6uqin58fry98IRopTaHFUqkU09LSUCKRoIWFBebm5uKHDx++OLSYK5gs4slxGZFIxDguc/78eY2MlDKEjj9aWlri69evcd68eZzHZYRaxPNhpK5du4YDBgzABg0aYGRkJK9xGaEW8SNGjGB9vKqqCqdPn45isRhtbW1x165d+OnTJ0HFphCNFJNF/Pnz56nx5ujoaBVm8Y8//vhXNFKIckbqyZMnCg0pTU0WIRbxfBmpEydOoKOjIzZo0ECtGyATPD09eVvEawotLi8vxwkTJijEU/ybGikmRooeTzF16lSVwuPWrVuCDDmEWsTfvHmT0m/1799fo06Na2gxHXwZqR07dqCNjQ02aNCAV0MKUbhFvDpGqrCwEMPDwxXiKWQymaDzSEjjetu2bRobhVpowQXaIut/AT5//kzptzw9PTnrtxDVhxarg6YLxJkzZ9DJyQlFIhGOGzcO371798WhxVzBxEhVVFRgfHw867gMorBi08/PD48cOcJrDclIHT58mBJfaxqX+RKLeK6MVFlZGY4dOxabNWuGnTt3xnPnznE+jrrQYnXQVPjs2bOH0m+R4zKurq4KAdpcsHbt2q9iEf/mzRuMioqixmWYbjKFFJvBwcG4e/duXmtIRoo+LqMcnqkMocUmH0bq5cuXGBwcjC1atMAuXbrwKuiEWsSr+2zIZDJcu3Ytpd9avHgxSqXSLw4t5gqm8UfleAom7aiQYjMqKkohEoALbty4gW5ubpiZmUmNN2tqSCEKt4jnykiR8RStWrXC7t2782pIFRcXs4YWq4M6a2+pVIpLlixBU1NTqiElk8lw0KBBvG+o9+3bJ8giXrlIoI83BwcHM+6tEI2UUIt4R0dHnDt3LtWQ4nIufguNFB1kQ6pNmzbYq1cvXsw6XykFibi4OKytreW9TgstlKEtsv6X4d27d7hq1SqMi4vDpUuX4ps3b9Q+n2toMR3Hjh1DX19fTs+VyWSYnZ2NZmZmqKury2tcBlHeReKrkYqPj1fLSD1+/FhlXEaoIYeQC4SyRbzyuEx2drbKHmVnZ+P48eN5HedLLOJv3ryJgwcPRpFIxGlcJiAgAA8cOMDrOGfPnuXMSEmlUly4cCGKxWLU1dXFDRs28DqPLC0tv7pF/J9//okeHh4oEokwLCwMCwsLv0poMVf0799foYCh67dsbGwYx2U2btwoyCJe6PjjuXPnsH///igSiXDUqFEa/w+4hBYr49q1a5wt4isrKzExMREJgkA9PT1OQdt0WFlZ8baInzVrllpG6vTp01RDavz48VheXi7YkEPIeaQcWkw2pAiCYDQUQhQWWvwljNTevXuphtTkyZM1hs9yCS1WBh+LeLIhRRAE6uvr8zaiYAstVgdNFvG7d++mGlLTpk3DqqoqfPv27Vcz5NAEZUaqqKiIakixmb7s37+ft0W8UEbK1NQU16xZw7khhcgttFgZJSUlvA14tNCCDdoi638x8vPzce7cuThhwgTcvHkz4+iEkIuyEIv4zMxMHDt2rEJ4pqZxGaEaKT5Bg8ePH0dHR0ds1KgRenl58RoLOHXq1Fe3iC8vL8fx48crjMsgCjPkoIcWc0V+fr5KaPH+/fvRzs4OCYLAxMRExuBMIeyIi4sL7/HHNWvWYHh4OI4aNQpFIhG6urpqHJf5VhopOrZv3442NjbYuHFj9PHx4cVAXLp06atopOhgGpdBFGbIQQ8t5gplRkomk+GGDRvQ0tISJRIJLly4kHFvhVrE82WktmzZgj4+PhgQEIAikQi9vLw0sqNCNVJisZjT+SCTyXDVqlVobm6OTZo0waCgIF43ut/CIv7Ro0fo4+ODIpFIwQ3wS0OLuUKZkSLjKUg3QKaGFCL/sFlEYRbxe/bswQEDBqCXlxfVkNJUPH3r8UeyISWRSLB58+YYFhbGay++hUX89evX0cPDQ0G/hSg35FBnwMSEZcuW8dY7KY8/VldX48yZM6mGFJsLoJBic8WKFbzvj7TQgg3aIuv/AGpra/HKlSs4depUSr8lk8nw6NGjKtkPmvC1LOLz8/PRz88PRSIR67iMkNDiJ0+eCHLtE4lEvMdluIQWK2PVqlWcLeLJcRkjIyNs3Lgxb8GuUIt4tqwf5XGZtWvXokwmwzNnzggKLRZyHllYWCiMP968eRMHDhyIIpEIQ0JCGMdlkpKSeFvEFxQUCBp/NDY25j0uI9Qinisjde3aNXR3d0eRSIRNmjThbUTxtS3iq6qqMDk5mdJv7dmzBxHlocUDBw7kdRxE4RopOiN19uxZSr81duxYxhHbWbNm4ezZs3kdp6ioSJBrn7GxMSYkJFD6raNHj2pc4+Hh8U0t4o8dO4YODg4oEomwRYsWvHUqQi3iN27cyPhYWVkZjh8/HsViMTo7O1MNqZs3b2L//v15HQdR2Hlka2ur8J2zb98+qiGVlJTE+PcuWrRIkEW8kPFHIyMjKp6Ci34LUW7IwcdZEZEfI0U2pMRiMbZq1Yr3SKyQ8Ud1ocX0hhQ9nkJoaDFfeYMWWqiDtsj6PwZSvxUfH49dunTh7XDHFlqsDppCi0+dOoVOTk5IEAROmDCBYmyEdJG+hkU8fVzG0dGRcZzySzRSfBmphIQEjIyMRAcHBxSLxZiQkKDxIvOtLeLfvn2L0dHRSBAENmrUCDds2MDrOGyhxeqgafxx165d1LjM9OnTqRscIUUCGVrMB8qhxUVFRRgZGal2XEYmk6GxsTGv4yAKG3+cPn06+vr6orW1NUokEpXwTCZ8a4v4goICDA4ORoIgsEmTJrht2zZex/naFvEymQxzc3PRwsICTU1NMS0tjdojIRopoRbxdEZKWb/18OFDxnVCNVJCLOJdXV2phtTKlSs1fk9/a4v4e/fu4dChQ5EgCGzZsiXvfCK20GJ1UMdISaVSXLRoEWUoRDakEOVja3yLzTFjxuDatWt5rVFmpJjiKZggZCrBzs6ONyOVmppKBflaW1tzakh9a4v4K1euUA2pdu3a8dbJPnjwADMzM3m/Py20YIO2yPo/jLKyMszKysK4uDhctmwZpw63EKcdroyUTCbDrKwsNDc3R2NjY+zcuTPvIkuoRTzbjQs5LkMQhMK4TFZWliBDDnXFJhvojBTXcRmhFvFCGKnu3bujl5cXisViRjdAJgixiE9MTORkES+VSnHBggUokUhQIpFgt27d/pXzSB0jRY7LiEQihXGZdevWfVFoMR/Qi02u4zIhISG8LeKFMlJdu3ZFV1dXFIlEOHr0aE5FpBCL+FmzZnHSTNDjKSwtLbFHjx68joP49S3iyYaUSCRSiKf4ktBivpBIJPjp0ydEVI2nYNP3RkVF8QotRhRuEd+pUye0t7dHsVjMGE/BBCEW8ampqZwYKTKeQiQSoYODA/bp04fXcRCFW8SzacV27dpFsUkpKSnU/+eXhBbzBd0iXrkhxTb+K8Qi/sGDB4Is4n/99VeqCOTSkEKUx0/wva5poYU6aIus/0+Qn5+P8+bNw7i4ONyyZQtjp628vFxQkSBUROvj44NisRgdHBw4jctwCS1WBh9G6ujRo1R4ZvPmzXlflCdNmoTLly/ntUYdI1VWVobjxo1DgiAUxmUQvyy0mA+ULeLJcRmxWMw6LvMlhhx8GSkfHx90cXFBgiDQzc2Nk+W0MiPFBXxc+7Zu3UqJr9u0acObSZg2bdpXtYh/9eoVhoaGqozLIAoPLeZrEU9npGQyGa5bt47Sby1atIjx//3Tp0+CigSuGik6hg0bhhYWFqzxFEz4FhopEvSGlKmpKf7666+szAQbmEKLNUEdI0VvSA0bNkxBl/JvaaToocU1NTW4dOlSarw5JyeH8T38mxbxw4YNQyMjIyQIgnND6vbt219dI0VCKpXi/PnzqfHmLl268GakvrZFPPm5IQgCIyIiFMZ6vyS0mA/oocVVVVWYkpJCNaTYmk61tbUYFxfH6zhaaKEJ2iLr/zPQ9VuTJ0/G06dPU1akXxJazBf0G9YnT56gn5+fghsgE/4ti/jy8nJs164dr3EZRGEXCK6M1L1796jwTAcHB96aBKHW3myMFDkuY2pqipaWlgrhmVOmTMG0tDRex3n27JmKIQcX0G806Pqt0NBQ1uJGiEZKCCNVXl6OrVq1QrFYjFZWVpzHyr6lRfzly5fRzc2NMoP4t84jNkaKrt+ys7NTGOGcMWOGoNBiIa599L/pzJkz6OzsrBBPwYR/yyL+7du32KxZM7VugEwQahHPJbT46NGj6ODgQFmLf6siQRlsjFRZWRnGxMRQDSm65mjBggU4ffp0XscRqpGiXwOY4imYoI6RYsO+fft4M1KFhYVoaGiIIpGIc0MKUXNoMRPGjh3LiZGiN6TGjRv3TeJmmMBmEf/y5UuqIeXp6anQTDpz5gxv1l8LLTRBW2T9f4zPnz/jnj17MD4+HmfMmIG9evX6KqHFmnDs2DFWRurEiROUfos+LvMlRQJfjRQ9tJgMzxSJROjo6IinTp1iXJOfn/+vWcQbGxujqakpEgTBeVwmOzsbx40bx+s4lZWVnMbWSktLqfBMV1dX7Nq1q6DQYjZDDjaoCy3euXMn47iM0PPIwsKCt0aKHlr8+vVrjIiI0Dgu829ZxMtkMuzduzeKRCJe4zJ5eXk4cuRIXsfiOv5YUFCAQUFBSBAEDho0CHv06PFVQos1gczZUYZMJsOcnBw0NzdHiUSCS5cuVfh+FHIeKRtycAE9tPjJkyfo6+uLIpFIbUPqSzRSfCCTybBHjx7Yu3dvNDMzw6ysLE7XkG9pEX/37l2qIRUQEIC9e/fmzUiNGjWKtw6VLbRYKpViamoqSiQSlYYUovDQYiEW8SQjdePGDU4NqbKysn/FIr66uhq7du2KPXr0QGtra84NqYMHDwqyiOey5/SG1MiRI3HMmDG8v4+00EITtEXWfwnevXuHCxcuxLi4OFy+fDlnHYSQGw0HBwd8/Pix2ufIZDJcuXIlmpubo5mZGXp7e/Om6oVqpNguEA8ePEBvb28UiUTo5+enMC7j5+fHaeSRjtOnT+PQoUN5raFfIKRSKaalpWkcl0GUF5tsHXk2JCQk8Gakjhw5goaGhkgQBA4fPhxfvHjBaZ2QGw0XFxdOttzkuIylpSVGRkZ+ldBiLmBjpOhugJGRkQo33cHBwZQbH1eQocV8QD+PyHEZsVisdlwGUZhGSohF/N69e9HAwAAJgsDo6GjOBa6Q7yMujFRlZaWCG+CkSZMwMjKS13GEaqTYGKkTJ06go6OjSkMKUXhosbu7O+/3R55HyvottoYUopyR4jv+OH/+fN6MVF5eHurr6/NqSCEKm0rgElqs3JCaN2+eoNBiId+XbK59O3bsoBpSM2fOVDjXxo4di2vWrOF1nC+1iC8qKlJoSP3555+sa/iEFpNYtmwZJiQkcH6+TCbDNWvW4ODBg3kdRwstuEBbZP0X4unTpzh37lyMjY3FrVu3UiyAMo4ePco5tJiEENe+iooKbNGiBcUmcR2XEWoRz4WROnz4MBWeOWnSJDQyMuJ1HERhFvFsocXkuIxIJEInJyeFcRmhGimCIAQxUocOHUJE7uMyZ8+e/Vcs4ouLi7FZs2ZoZGSE7u7uePXqVU7rNIUWM6GgoIATI7VlyxZqXGbOnDmCigQ3N7evZhH/8uVLDAkJofRb9HGZfyOPjERYWBju2LEDZTIZrl27VqN+C1FuyME1tJgOvudRfn4+NmnSBPv27csaT8GE2bNnC7KI1zT+SDak6PEUQs4jDw8PziNkJHbs2MHISJENKYIg0M/PD58+fUo9JlQjZWJiIsgiPi8vT6UhlZuby1pE8QktpoPveXTr1i00NDTE3r17Y3BwMGcNsKbQYiaUlpZqZKSqq6tV4imE6q2/lkU82ZAiCAKjoqLwzZs31GNfElrMd/xx69ateOnSJd7H0kILTdAWWf/FqK2txcuXL1P6rTNnzlD6LUR5F4lvKF9GRgbGx8fzWkNnpMhxGU36LURh3Ui+jJRMJsPRo0ejoaEhmpmZ4apVqzgd81taxN+5c0dhXGbEiBGCQou/lkU8fVzGwsJCZVxGaGgxX4v4jx8/UkUCOS6jHJ7JBCHFZlBQEO7du5fz86urqzEsLAwbNWqE1tbWnK3Ov0QjpYkdunz5Mrq6uqKxsTGOHDkS4+PjccGCBbyO8+rVq69mEV9ZWYmJiYmUfmv//v0KjwsJLd60adMXMVJnzpyhxpvHjx+v9rMpRCMVGRnJyyK+oqICAwIC0MDAgJd+C1H4+KMmYxd6Q2ry5MmYkpKCM2bM4HUc5dBirmC6BpSVleHYsWMp/da5c+cUHhcaWvwlFvF79uyhDIXo8RRMEGLIER0dzcsivqioCAcPHoz6+vro7u7OK59NyHWNS2ixckNq8eLFXxxazBVxcXEK9z5aaPG1oC2ytEBEuX5r9+7dGB8fjzNnzsR79+4Juih/TYt4+rhMfHy8wutyZaSUIeQCQTJS5eXlOH78eCQIAp2cnPD06dOsa/iEFpOoqKjgzUjt378f9fT0UCQSYWJiIucOXkBAgCCLeE3jjyUlJQrjMpcuXfoqocVckJiYyBhaTI7LmJiYqIzLPHv27F/RSCH+Y8hBD8/08PBQcANUxoYNG765RbxMJsMNGzagnp4eisViXLBgAeeiU11oMRu4WMQ/f/6c0m95eXnhnTt3BBebfDVSTBbxMpkMs7Ozqfyt5cuXK9zcc2GkmCDkPCJDi0k3QJFIhL6+vmpHtIVYxH/+/JkXk0DGU+jq6qJEImGNp2ACyUjxAReL+Dt37uDgwYORIAgMDAzEgoKCrxJazAVMFvH0hpSVlRVu2LBBYY+4MFJMEOL+6OXlhefOnaPiKbg0pP4Ni3gynkJXVxfNzc15aTDHjRvHGlrMhpKSEk6REFpoIQTaIksLFZSVleHSpUtx4MCBuHz5ciwpKeG0rry8/JsEDcpkMszMzFQYl/Hx8fni0GIuYGOkHjx4QIVn+vv7q8yNCzHkmDRpkiBGql+/fiiVSnHJkiUUm6RuXAbx37GIv3nzJvbu3RubNm3Ka1zmW1nE08dlyPDMwMBA3qHFFy5c+GoW8XT9VlRUlIoeSmhoMV9GijTkIN0ACYJAGxsbjY6GQs4jd3d3tYWlMs6dO4c9e/ZEQ0NDHDt2LOfi+2trpEiQ+i2CINDe3h6PHDnyVUKLuYJpz48dO0a5ASo3pBC5MVLKmDdvnmBGqqysTKEhpcmCW8hUAl9Gav/+/di9e3c0NDTk1ZD6VhbxxcXFOGrUKKohdfnyZRw9ejTv0OJbt259NffH7du3Uw2pWbNmqXwO7Ozs8Pnz57yOk5aWJoiRsrCwwMLCQgwLC0ORSKSxIYUo7Dxavny5wrirFlp8TWiLLC3U4unTpzhnzhyN+i3Ef8civqKiAuPj41FXV1dteCYThFjEZ2VlaWSk6OMyCQkJWFRUJFgj9TUs4ktLSzE6OhoJgkAXFxcV+2AujJQyhI4/kozU7t27Kf2WpnEZrqHFdDx79gzt7Ow4P7+oqAijoqKwQYMGOGDAAF7jMi4uLt/EIn7Tpk1UeOa8efOwoqJCkEbKxMSE9/gjU2hxQUEBBgcHU26Ayn+zUEMOIYyUpaUlFhUV4Zo1a9DCwgIlEgkuWbJE7d85c+bMb24Rn5+fj/7+/qirq8tLv4Uo3CJeHSMlk8kwIyNDIZ7i06dPgjVS6r7vmcAUWkzGU4hEIsaGlNDQYqGM1PPnzxUaUmvXrlX7vcs1tJgOvhbxN2/exEGDBmGDBg14NaQQ5YYcfC3iNTFS1dXVOGfOHDQxMaEaUkKLTSEaKabQ4itXrqhtSN2/fx+dnJx4vz++ETBaaMEH2iJLC06ora3FS5cu4ZQpU3DSpEl49uxZlRlmIUWCUIt4X19fhfBMX19ftfqxb6mRoh9j2bJl2Lx5c2zXrh2vcRmhGilNN6x37txBLy8vFIlEVHims7Mz3r9/n9dxlEOLuYCJkZJKpbhgwQLKDVB5XAZRmJFCYGCgioZHE86dO4deXl4q4zKvX79mXfMlRQJXRoocl2nRogW2b9+e1zjet7KIv3jxIrq6uqJIJMLRo0djaWkpurm54V9//cXrOHl5eVRoMVdUVVWp3Nwp67cOHDigsk6IRupLLOJPnTpF6bcmTJig8XtDyPcRH0bq/fv3GBcXhy1btsQOHTrw+p598+aNIIt4TWNrBw8epBpSpBugp6cnb0OOXbt2YUhICK81TEWCpoYUojCN1OjRo3HdunW81pAW8bt27aIaUikpKRqPLVQjxdUivqioCCMjI7F169bYsWNHXo2Bb2URT29IkfEUQkKL79+/z7sxrIUWfKAtsrTgjerqaty1axfGxcXhzJkz8eHDh4JDi4VcIBwcHFQKKk3jMkJCi7/EIv7t27c4fvx4FIvFKuGZTPDz88MjR47wOg5fRmrfvn1oa2uLurq6mJSUxOvGQYhGSlNoMTkuIxKJqHEZoaHFQgofFxcXvH37tsLvtm3bRomvmcZl1q5di2PGjOF1nC9x7SsoKKDCMwcOHKhxXOZbW8TLZDJct24dWlhYoK6uLqampvIqiC0tLQVZxKtjpJ49e4YBAQFIEAQOGTIE7927h4WFhV/NkEMTlBkpmUyGWVlZaG5uzqjfQhQWWvwl44937tyhGlLDhg3TaGgUFRWFmzdv5nWcGzducGakyIaUmZkZ6urq4urVq3k16IRopDSFFpMNKYIgqIZUaWnpNyk2maBsEU9vSFlZWWFeXp7Ka+7bt0+QRbxQRur8+fM4YMAAJAgCIyIiNOodx44di7m5ubyOc+/ePXR2dub0XDKewsTEBPX09HjrQ2fMmMH7uqaFFnygLbK0+CK8ffsWMzMz0d7eHkeNGsVZv4X4DyPFB5oYKaZxGZlM9sWhxVzBZMhx7949Sr8VEBDA6LL0JYYcfJCdnY0xMTG4aNEiVjdAZXwrjRQdN2/eRE9PTzQ0NOR9A3X27FnW0GI2aGKk6OMyVlZWlN5GSGhxUlISFVrMFUyMFDkuQxAEjhw5krFYEXIeubm5KVi5c0FeXh6Gh4djcnIyisVitLW11ei2WFVVJahIEIvFnBmpM2fOoLOzMxoaGqKLiwuvG6hr1659dYv4iooKnDRpEqXfIp1NvzS0mCuKiopUioSjR49SDamJEycyGhUJOY8GDhzIm5HauXMn+vv7Y0xMDOUGqKkh9a00UnTs27cP7ezssGnTpjhgwABeDambN29+NY0UieLiYhw5ciQSBIFubm7UPn9paDFXMDFSW7duVavfQhQ23TJkyBDejNTBgwfR09OTakh5enpq/E6rra3lnc2phRZ8oS2ytPhqePz4Mc6ePRtjY2Nx27ZtGuf5mRgpTeBjEU+GZ/bt2xf19fV5jyV+C4t4clxGLBZT4zKnTp0SpJESwt4oF5vK4ZlMYZsJCQm8DTmEMlIEQeDOnTup8Ewu4zJcQouVsWbNGs6hxWR4ppGRETZs2JC3jkbI+GNwcDBr0SKTyTAvL09lXObf1EgphxYXFBQouAEqM4SIwkKLhTJSIpEIc3Jy0NzcHCUSCaalpWn8LAvRSG3ZsoWzRfyTJ0/Qz88PjY2NsVGjRrz1oUIt4tlCi2UyGaanp6OZmRmam5tjVlYWymQyvH79uqDQYiHnkY2NjcL4Iz2ewt/fn7EhNX/+fExJSeF1nOLiYsGM1MKFCzk3pBDlhhyaQouVsXfvXs6M1F9//YWenp5obGyMjRs35m1oIpFI8OPHj7zWjB07ltWQQ1m/RTakvjS0mA+UQ4svX76Mbm5uKBKJWBtSZ86c0Wjso4UWXwptkaXFV0dtbS1euHABExIScPLkyXju3DkV/ZZQjZRQi/jk5GTK7tjPz09jcfetLeJrampw6dKlaGpqigYGBjhz5kxeBV1WVhZjaLE6aGKkbt26hYMGDVIYl0GUFwl8i83AwEA8ePAgrzXKocXV1dU4f/58alxm06ZNKmu+xJCDLyOVmJiIMTExvMZlCgoKeBlykOD6N9HHZRo2bMg7VJkttFjTMdUxUnT9VnR0NLXPQopNoRbxdEZK2Q2QLbpAqEaKLyM1e/ZsDA4OpvRbsbGxGll2JkaKC7j+TWRDiiAINDQ05B3yvn37dgwLC+O1RhMjtX//fuzXr5+CfgtRmEZq1KhRgizi6aHFXBpSiMKKTVtbW96MVGpqKnp5eVH6rRkzZmgswvkacpDg2nAkG1IEQWCzZs1w1apVvI7DFlqsDuos4ukNKYlEohBPMXnyZPz8+TOvY2mhBV9oiywtvimqq6tx586dlH6L7N5mZGTgxIkTeb3Wl2ik6BcILuMyw4YN4xVajIh46tQp9Pb25rVGJpNhnz59MCYmBsViMbq4uGgcl0EUZhGfkJCAy5cv5/RcMjyzT58+2K5dO943NUJuWNWFFtPHZdzd3fHq1auIiJibm8s7tLiyslKQRko5tHjr1q0K4ZlMNzhBQUG8LeIvXrwoyCK+V69evMZlEL+tRbxMJsO1a9eipaUlikQi7NChA+8iS8gNq7u7O/7555+Mj+Xn51P6Lbob4ObNm3kbcnwNi3iZTIYrV65Ec3NzNDMzw/T0dMab2YiICFZGig1CGamePXuit7c3isVi9PPzU3EDZIIyI8UF8+fPx5kzZ2p8nlQqxbS0NDQ1NUWJRIKdOnXi3fT52hbxt27dQk9PTyQIQsENcPfu3V8UWswH9GKT3pCytLRkbEgh8g8tRhTOSHXr1o1qSEVGRnJqRnAJLVYGV4v4qqoqnD59OjXezNfISQsthEBbZGnxr+Ht27eYkZGBcXFx2LFjR95fpmyhxeqgjpGSyWS4fPlyNDU1RTMzM2pcBlFYkeDo6IgPHz7ktUbZIv7u3bvUuAybfktosSmEkfL398ewsDDq4s1lXEaoRTzXG+obN27gwIEDUSwWY5MmTXhldyGyhxarg7rQ4urqapw1axaKxWKFcRnELwst5oP169crWMRzGZf5EkMOvsVSUFAQDh48mHID5OIEefnyZY2hxUzguudnzpyh2KTmzZvzHt9jCi3WBHWhxRUVFThx4kQkCAIdHBwUcgCFFJt8owkQVS3ijxw5gg4ODigWi3HSpEmMDSmhxaZEIuE9/hgWFkYF1Ds7O3OyLhdqEc91z8mGlFgsxjZt2qgNhWaCUIt4Nte+4uJijIqKUmlIIQorNr28vL7YIn7Lli0aG1J8Q4tJCLGIz8rKwuPHj/M+lhZa8IW2yNLifwT37t2j9Fvbt2/nlMcipEjw9fXlFFpcXl6OEyZMQIIg0NjYmLcN9peMP7IxUvRxGXp45qRJkzgzUiSEWsTT/yb6uIybmxtrl5dvaDGicIv43377jRJfz5w5k9NNmzIjxQVcQ4sLCwsxPDwcRSIRWlhY8NalfW2LeJlMhhs3bmQcl5k2bZrg0GK+oP9Nz58/V9BvsenphFjEb9q0CUeMGMFrTVVVFbZv355yA1y2bBmn7xkhGimuocVPnjxBX19fJAgCHR0dBesb+YLNIl65IbVq1Spqj+bOncuJkaJDqEaKXiTQ9VuBgYGs43Z8Q4sR5RbxfBmpqqoqbNWqFaXfWr9+Pafz6FtaxNPjKQYPHvyvnUdsFvFkQ4rUb9HjEpYsWSI4tJgvYmNjVSQMWmjxLaAtsrT4H0VtbS2eP3+e0m+dP3+e8cvv37SIt7S0pDQlXMdlhFrEc3Htk0qlCuGZ7dq1w5qaGl7HYgot1gR1jBTbuMyXhhbzwdSpU6nQ4urqapw7dy6l32Kzn+YbWkxCaMaajY0NGhsbcx6X4RJarAyujBR9XMbGxgY7duz4VUKLNUGdIcf58+fR1dUVCYLAsWPHUufA1zLk4AJ6aLGyfostVoFvaDEJIeeRRCJBiUSCIpGIMZ6CCZpCi5lQXV3NaWzt3bt3OH78eCQIAp2cnPD333/nXWxGRUWxjrSx4caNG6zjj2RDSiwWKzSkEIWHFvO1iF+4cCHFSJHxFARBYP/+/VmLvJKSkm+qkaJDLBZj3759USwWc25IaQotZgLX8UeyIUUQBHp4eGCPHj2+SmixJhQXF/MOKddCC6HQFlla/K9BdXU17tixA+Pi4nDWrFkK4ztfElrMB8pFwuHDh9He3h5FIhEmJCSwXgTUMVJsEGIRf/36dWzVqhWvcRnEb2sRTx+XcXd35+zaR0KoRTwbI0WGZ5LjMvSRqS8JLeYD5SKBHp45d+5c1hscIRqp5ORk3hbx165dw6ZNm1L6La7jiUIKH1dXV436MJlMhrm5uWhhYYGmpqbo5+cniJH6Uo0UHfn5+ejv76+i30IUHlr8JRbxZDwFySZlZGSw3mhbW1urDdVmghCL+AsXLqChoSHlBsilIYX47SziyYaUqakpWlhY4JgxY/5HNFJ0kPEUyg0pRDkjtWHDBl7HIUOL+YLcc2U3QHVaPz6hxSSWLFnC2yL++PHjaGBggARBYFRUFOdGiZA8smXLluHTp095rdFCC6HQFlla/K9EaWkppqenY2xsLKanp6ORkRHv1xBiEc/GSJHhmaampmhubo7Z2dnUlztXRkoZX2oRT4ZnikQiteMyQjVSfG+EpFIptmvXDsViMVpaWuKGDRs4/X2aQouZwJWRoo/LhIeHY+/evXkdB1GYRfzatWsZi83q6mqcOXMmpd+i36hXVVV98zwyEvTQYrp+a9SoUaxFnhCNlEwmQ2NjY15rKisrsXXr1mhsbIx2dnZ44MABTuu+pUX8qVOnKP3W+PHjsU+fPryOgyjMIp4ttJjuBujo6KjQgPoahhxcQbeIJxtSBEGobUipY6TUge/3UVlZGbZo0QL79u2LLi4unBtSmkKLmcB1/HHXrl2UG2BKSgoaGxsLCi2+dOkSrzVsocX0hpSyhu9Lik2+jBQ9tJjekJo3bx6rA+CdO3c4hxbTwXfiRAstvgTaIkuL//V49OgRxsbGYlxcHO7cuZPTjcC30EiRKCsro8ZlnJ2dcejQoV/VkEMd2P4mMjxTWb+FKNdICQkt/hKLeK7jMojCNFIBAQG8LeKnTZuGhoaGasMzlfG1NVJ0FBYWUm6AAwcOxLCwMN4W7C9evBCkkWI6j2QyGW7YsAEtLS3RxMQEU1NTFf5fuDBSytiwYQOOHDmS1xo6I/Xs2TPKDXDIkCFqtX5Cis2wsDBeFvEymQwnT56MjRo1QlNTU1yxYgXnm+RvZRH/6NEj9PHxQYIg0NfXF8eNG4ezZ8/mdRx1hhzqwHYesTWkEOWMFF9Djp07d2JoaCivNfQigWxIadJvIcqLTSEW8XwYKalUijExMWhgYIBWVlaYl5f3Tc8jLqHF169fV4inmD59OiYlJfE6ztu3bwVppJgajp8+fcIZM2ZQjNuOHTsUHh8yZAgnJ1467t27hytXruT9/rTQQii0RZYW/2dA129NmTIFL1y4wCpe5RNaTEKIa9+9e/ewYcOGKBKJeI3LfCuLeKlUiosWLUKJRILm5uaYm5srWE8kxCKeKbSYPi4TEhKiMC6Tn5//r4mxSUaKz7iMEIt4Ia59V65cQQMDAzQ2NsYRI0ZwHpcZPnw4xUhxxaVLlzSGFldVVWFycjJld7x7927BxWZJSQmvNdOnT2dkpM6ePYsuLi4oEokU9FuIwkOLhZxHpEV8RUUFTpo0CcViMTo4OKj9PG/evJlzaDEJIYzU0aNHUV9fH42NjTnrtxDVhxazgbwpV4eysjKMiYlBkUiETk5OeObMGUHsiFCLeKbQYrIhJRaLMSkpSaGgKi4u/tc0Up6ennjp0iWFeAo3Nze1I5F79uz5V8Yft27dinp6eigSiTg3pBDlFvFr1qzhdSwuFvGvXr1SaEj99ddfgj67M2bMwHfv3vFep4UWQqEtsrT4P4lPnz7h9u3bMS4uDmfPnq1im2tqaiootFgII0W69h08eBDt7e1RLBYrhGcyQcgNK1eNFInS0lK0sbHBpk2b8hqXEaqR4uL+qDwu4+Pjw5uROnPmjEJoMRewMZvK4zLK41xCDDmSkpIoQw6uIEOL6eGZJiYmOH/+fLXszL9hEV9QUICmpqbYpEkTHDRoEOe138oiXiaTYU5ODqXfSktLw5CQEEGhxV/LIv7p06fo5+eHBEGgt7e3ih28lZUV79BioRbxVlZWKJPJMD09Hc3MzFTiKZgg5PvIw8ODFyN17949FIvFaGhoiP7+/pwjPL62Ror+umRDysLCAtetW4cjRozAjRs38jqOUIt4pvOI3pAKDQ1VKSyFGHIsWrRIkEW8paUlVldX4+zZs9HExAStrKw0OmMKtYjnw0hdvnwZjY2NsWHDhqzxFEyQyWQYFxfH671pocWXQltkafF/HqR+Ky4uDjMzM/H58+dfJbSYC5gs4unjMhYWFpiTk6PwuidOnEAfHx9exxE6/kgyUrdu3cJBgwYhQRAYFBSkdnSEjZFSB76MlFQqxfnz56Ouri7vcRmhFvGaGCnlcZn8/Px/TSPFFFpcVVWFKSkpaGJigjY2NipFxIULFwSFFvPVSCH+M/548eJFynlzzJgxakciuYYW0/Hy5UtejFRlZSVOmTIFdXV1sV+/frwKdnd3d7xx4wav97dp0yaNocWkfkssFmNsbCwWFxf/axopJot4un7LyckJT506pfA4F0aKCUK+j0hGih5PoakhNX/+fJwxYwav4/C1iC8tLcUxY8ZggwYN0NXVFS9evMh57beyiN+5cyfa2NhQDanKyspvUmwygSm0uKioCCMiIlgbUrdv3xYUWiykwLezs8P8/HxeDanTp0/zZv210OJLoS2ytPj/Cg8fPsRx48ahp6cnZ/0W4reziCfHZcRiMbq4uODZs2fR0dGRd/BpVlaWIIt4pmKTdAMkCAKTk5NVLsBCQ4uFWMQPGTKE17jMlxSbfBiprVu3YqtWrbBNmzas4ZlM+FYW8S9fvsSQkBDKDfDmzZuCQou/lkW8TCbDtWvXooWFBUokEly0aJHKDY6QYvNLLOJJ/ZZIJMKhQ4dqLMSFnEd8LOJlMhlmZWVh69atsXXr1piens75c/WtLOIfPHiA3t7eSBAE+vn54dOnTwUZcmzbto3RkEMdmMYfpVIppqWlUePNyg0pRHmRwCVHkY4RI0ZgXl4erzV//fUXurm58WpIIQovNrkyUp8/f8b58+dT5xEf63uSkeILTQ3Ha9euUQ0pMp7ia4QWcwFTaDE9nsLW1pbxO2Ty5MmsJhpaaPGtoC2ytPj/ErW1tXju3DlKv3Xx4kW14YM+Pj68E+CPHTvGi5G6e/cuDh48GBs0aIABAQGcx2UQhWmkNIUWS6VSTE1NRYlEgpaWlrhu3Tp8+vSpoNBiId1IJkbqxo0bOHDgQBSJRIzjMkJDi4WOrX38+FEhPFPTuIwQi/jz58/zsoi/fPky9u/fH3V1dXmNyyB+G4v4yspKTEpKQrFYjHZ2drh//37BocVCbljd3NxUDDnOnDmDzs7OKBKJMCYmRqXAFhJa/CWufW/fvsWJEydS+i1NAenh4eG4bds2Xschb3y54ujRo+jg4IC6uro4adIkXuPVXAw5lKEptLisrAzHjh1LGQqdPXtWcGixEGtvJkZqz5491HgzU0Nq165dGBISwus4XzL+WFBQgCNGjKDiKTRZ2nMNLaaDr0X8li1b0NraGnV1dXk1pBC/jUU8vSE1cOBAvHnzJlZVVeHUqVN5HUcLLb4GtEWWFv/fg67fmjNnDqOtu5CbOwcHB96MFGkRTx+XUXYDVIYQQw5EfoxUaWkpjh49Ghs1aoTGxsa8LIK/pkaKDuVxmerqat6MFKJwi3jl8cfXr1+rHZdB/DJDDj4gGSlyXEYikeCCBQvUMkffSiNFx7NnzzAwMBAbNWqEJiYmvP4udaHFbNDk/kjqt8zNzVEikeDSpUtRJpN9cWgxVzAZcjx58gSHDRuGBEGgj48P43eIUEMOIRbx4eHhuHz5cjQzM2N0A1SG0GJTIpFwvgG/c+cODhkyBJs0aYJmZma8GlI3btz4ahopEkwNKZlMJkgj9bUs4m/cuEHFUzA1pBCFjcAPGjSI17gkopyR8vf3V2hIacqRY2KkuMDU1JSzRTwZT9GlSxe8cOEC72NpocWXQltkafFfhZKSElyxYgWl3yorKxMcWiyEvVG2iCfHZUj9Vm5urspFUUho8ZdYxKsLz2SCk5MT3r9/n9dxVq9ejePGjeP03Orqapw7dy4aGxujnp4er3EZRGFja5os4pnGZb5GaDFXWFhYKDBSXMZlkpKSeIcWFxQUCGakzp8/j66urkgQBEZHR2ssjvv378/bIj4vL4+zRXxlZSUmJCSgkZER6uvr8x5vFaKR0hRafPz4cXR0dESCIDA2NhbLy8vx6tWrgkKLhZxHyoxUeXk5FU9BugEqQ0ho8ZdYxO/fv58ab546darGG2wuocXK4GMRT8ZTGBkZoYGBAW89lhCNlCaL+B07dlANqZkzZ2J1dfUXhxbzgbJFfGFhIYaHhyNBEOjh4cGofVy0aBHv0OLS0lJBFvFxcXFqJ1m00OJbQVtkafFfi4cPH+KsWbPQyMgIly1bxusG6ltYxCuPy5Dz7V8aWswVp0+fVgktpo/LTJs2TeXmQGiRYG5uzttKNyEhAWfMmIGRkZEoEonQ3d1do7sZEyPFBXxuNDZv3oxWVlZoYGCA0dHRvM6jNWvWMIYWq4MmRkpZv0XqtoTkkQUFBfEWiyszUjKZDHNzcyn91pIlS1Teh9DzSAgjlZKSgvHx8ejv70/ptzS5dn4rjRQJmUyGmZmZaGZmhg0bNsSJEyfy+sxv2bJFkEW8uvPowYMHOHToUCQIQiGe4ktDi7lCObRYKpXikiVLqIbUmjVrGPdIyHlkY2ODr1694rVm/vz5GBkZiZ6enigSiTg1pISOP3K9BpANKRMTE2zUqBFOmzaN13H27t3LGFqsDprGH+kNqaioKOrzKiS0ODo6mgot5oo3b97gvHnzeK3RQouvBW2RpcV/PWpra/Hs2bOUfuvSpUsau15mZmbf1CKeHJfp3bs3NmvWjPfcupBupDqLeOVxmf/X3pnHRVW2b/we89f+ppmamtnyvr2almnJnGFf3BVBwA3NhdzX1JRNZREEIVDTNE0zzR0FtzRzyUxUlFxSUzMzN0BcskJkGYbr9wfNeQeY5TwHcL2/n0+fhJlnnsOcI8597vu6rpUrV8rCftHQ4tu3b6ty7StbJBw9elQelxk6dKjZcRk1ocWpqamqxh/t7OzkcRkPDw+b4zJA+Y6UEiIiIhSHFhvHZd5991289NJLwnup+cDapUsXi4Ycubm5CA8Pl/Vb33zzDYCS0OLRo0cL7VNZ449GN0CtVosJEyaY1T4OGTKkXBiqLdLT01V1pN577z0EBwdDkiS0b99ekVZUjUZKxCJ++/btaNeuHVq1aoVGjRoJfzhW8/vIx8cHP/74o9nHTG9ImcZTpKSkCIcWFxYWVoprn2k8RVRUlNlu1ejRo4UNOYwmN6K89957GDFihKzfUmK337p1a+F/a2bNmqU4tDgpKQnu7u7QarV45ZVXhIt1NVq7uXPnKs6vZJjKhosshjEhPz8f69atk/Vbv//+e7nnqNVIqbWInzZtmmL9FqAstLgsIq59xnEZSZLw/PPP2xTxl2XSpEmVbhGfnJwMd3d36HS6UuGZajVSohbxZUOLjeMyWq3W4rjMnTt3qlwjZWTAgAH46KOPZP3WzJkzbb5GWlqaKot4pYWZUb8lSRJeeOEFYc1EdHS0sEV8ZmamRYt4400DZ2dnODo6Yt68efLf14qEFouwZs2aUh2pc+fOoU+fPpAkCX369DGrJ62IIYcai/gPPvgAjo6OivRbQNVbxJ86dQrdu3eHJEmoW7cujhw5IrTPxx9/bDa02BrWQov1ej0SExPlG1Km8RRqQ4tFRxLLhhYruSFVVXlk5hgzZgz8/PzkG1JKbmAoCS02B2djMfcSLrIYxgI3btzAvHnzEBgYiIULF8qakuDgYCxcuFDotSqikTKi1+vxySefyOGZy5YtM/sPtmhoMVBiET9x4kShNTk5OWjRooVsdzxo0CBFInA1HzT69++vSENTUFCAuLg42Nvbo2XLlsIfGtRaxFsLLU5PT4e3tze0Wm2pcZnw8HDVocWimBY+eXl5mDp1qqzfsjQOeDct4ps1a4bOnTtDq9Vi3LhxisxN1BSbgwcPVhRanJOTg9DQUOh0Otjb26vuvIpiLbR4165daN++PbRaLYKDg+VOemxsrLAhR0U0UkZu3bol67c6depkVr8FiIcWAyUdqaFDhwqtKSgowH//+1+0adMGOp0OERERij7829vbCxcJo0aNUtSRMo2ncHNzg7Ozs9A+gLrryJohx7p16+Du7g57e/tSN6RmzpypOrRYFNOOVFZWFoYMGSK7AVrKrlNjEX/mzBl88cUXwsfHMJUFF1kMo4BffvkF06ZNQ2BgIJo0aSKc22IutNgW1kKL//jjD4wdO7bcuExFQ4tFCA0NLdWRMh2XiY6ONvvB5cKFC3fNIr5t27bw9/eX9VtK7nCrtYhX+iF8zZo1cHNzg06nQ8OGDXHnzh2hvQYMGFAutNgW+/fvt9iRunz5MgYOHAhJktCtWze5qFKrkVJjER8VFYUZM2bI+xr1W46OjpgzZ47ZQupuWsS3a9cOnTt3hiRJ8Pf3x6+//mpzjZLQ4rIo7UgZDAbMnz8fTk5OcHR0xGuvvSb8+8hcaLEtrHWkzpw5Y1a/Bah7z93d3c12W6wRHx8vhxbr9XrMmjULjo6OpdwAy2KtI2UNSZKEjRTatm0LDw8P2Q1QiQasKi3iTW9Iubu744033lDVkSobWmyLkydPWuxIGcebtVotRo4cWUpvqeY6mjZtmvC/awxTmXCRxTACGAwGbN++HZMmTcKUKVNw6NAhRf/YqvkHQmlosem4jE6nExbA5+TkqL5Tb+6Di+m4jJubW6lxmYqEFotQttg0fkCUJAnDhg2z2C2w1pGyhJqO1K+//orXXnsNOp0OHh4eirorgLpis3Pnzoo6UmlpafD09IRWq0WbNm2Ew2bVaqTs7e3NFlK5ubmYMmUKdDod2rZtW0pbV5HQYhGKi4tLXUdG/ZapG6A57pZF/K+//oqGDRtCq9Wiffv22L17t6J1an4fKQ0t3rZtG9q1ayd3JkSLhIKCAlVja/b29maLzZs3b8o3pDw9PUvZk48YMUJYI1UZFvFl4yksFclqLOLVdKTOnDmDF198EVqtViicWo1Gqlu3bjY7UsXFxXI8hb29PQICAtC/f3+hfQwGg7A5FcNUNlxkMYxK8vLysHbtWgQFBSE+Pt6iuPa7775TZRGv5oNQs2bNZG2S0nGZkJAQq6HF5lAaWmw6LuPl5YVmzZoJ7QOUjD+KaqSsdaRMx2WmT58uj8uIdKRMUauRMoYWG90AtVqtHJ5pDtHQYkBdR8pgMKBJkyZwdHSEg4MDZs2apejnsxVabA6lHamLFy+if//+kCQJPXv2xNtvvy20D2A+tNgWq1evNhtaXFa/NX/+fPnDZl5e3l3TSJlaxJ89e1bu3Pbt29esfgsAjhw5osqQQ/T3UVFREd544w3odDq4uLhgyZIlij6Qx8XFWQ0tNse1a9cUufadPHlSHm8OCAhAixYthDtSvr6+whopSx2pgoICJCQklLohZTyeu62RMoYWHz58WB5vtnZDSq1FvOjvo7y8PLz22mto1aqV0A2pPXv24OuvvxY+PoapTLjIYphK4Nq1a5g7dy4CAwOxaNGiUvbkHTp0sPiBxxLG0GIRTA05TMdlXFxcLI7LAOot4nfs2CG05osvvkCDBg2g0+kshmeWpSLjj7Y6UgUFBZg+fbo8LuPj41MpocVKsPQzmY7LjBo1qlQ3RE1o8bJlyypkEZ+Xl4fIyEjZDdDaqKKljpQ1Bg4cKGwRP3/+fNStWxdarRbjx49X1HmsSov4nJwchISEQKfToX379ujXr5+wZXRlW8Tv3LkT7dq1g1arRWhoaCknVJFOhZF169YJdzZNxx9v3bqF8ePHy/qt1NRUi+vUFJsjRoxAUlKS0JpPPvkEtWvXhk6nQ2RkpOLCRM3vIw8PD0X27qY3pEaPHl0pocVKsPRvwNq1a+UbUnFxcaXOi5rQ4i1btlTIIj4jIwODBw+W4yms3TSZNGkSCgsLhfZimMqGiyyGqWTOnDmDadOmISgoCJs2bVL1j3LZ0GIlWAotvnnzJsaMGWN2XKYyDDmU0qFDB9mQY8OGDaX0W5Y+VC1evFjYIl5NRyo7OxsvvvgiJEkS+hCq1iLeVkfKYDDI4zIODg5ISEiAnZ2d0D6AOo2UpdDiy5cvIyAgAFqttpR+CwCuXLmiypBDzXXk5eWFkydPwmAwYMmSJXL+1qeffmrxZsGqVasUhxYbUdOROn/+POrUqQOtVovevXsrGvcFSgw5lFj+m3L48GGbHSmDwYB58+bByckJzs7OWLRoUaWEFivBUmixMZ5Cq9Wif//+uHjxovxYdna26iJBFB8fH6Snp5eLp7B2Q0oktNiIXq8Xvo5++uknvPDCC7Czs8OQIUMU69NshRabQ0lHqqCgQI6ncHd3R0pKiqrrqGxosRIshRaXvSF148YN+bG8vDzhoGOGqQq4yGKYKsJgMOC7777DkCFDhPRbVWkRbxyX0Wq1CAgIgLe3t3Bo8Z49e8qFFtvCUiehsLAQH3/8sTwus2bNmlKPqzHkmDx5coUs4k3DM4cPH271w6Vai/jTp08rfn5eXh58fHxQr149eHh4KNYi5ebmVplF/P79+2U3wLFjx8Lf31/YkEONRsrSdWSq32rXrl053Z+rq6uq0OKEhAShNaYW8bt370aHDh1s6rcA9RbxlpzYzPHXX3+hc+fOePHFF9GxY0f88MMPitZVpUX81q1b5XiKKVOmYNCgQcKhxUePHi0VWqwUc9dR2RtSZccCPTw8hA05EhISKmQRb9Rv2dvbIyYmxup7qtYi/uDBg4qfn5WVhbZt26JOnTro2rWr4pgCvV6v6jp3cHCwahBkMBiwatUquLq6wsHBAYmJiVi5cqXFjDWGuZtwkcUwd4G8vDwkJSXZ1G8BYqHFRtR0pDZv3oyaNWsKj8uotYi31ZG6du0aRo4cKYdn/vDDD6o1Umos4r/99tty37c2LqM2tFitRfzNmzdl/ZZOp7M5LhMeHo5PPvlEaB9Ri3iDwYCvvvoKNWrUgIODA2bPnq14ZNDYkRJBSWjxhQsX0K9fP1m/dfz4cdVFQmVYxBsMBixcuBDOzs5wcnLCggULSl2f6enp8PX1FT4+ta592dnZOHv2rOwG2LdvX6u/j0RCi42IdqT0ej1mz56NGjVqwNnZGUuXLlX8d9haaLEllIQWnzhxAn5+fpAkCQMHDsSFCxdUXUdqNFLmLOILCgoQHx8v35AqOx6pNrRYrUX85cuXZf2WJEkYMWIErl27ZnHN3bCIz8vLQ1RUFN577z1hrR3DVAVcZDHMXcaafgtQH1osahH//fffw9/fv9S4jIuLC1auXGlxf7XaFtGO1LFjx/Dvf/8br7zyisXwTHOotYi39UHD3LhMZYQWK8FSR+rQoUPo0qULtFotRo8eXW4sUI0hR0BAgHBHyhhanJubi/DwcFm/ZTT2MIfaYlN0/PGHH37A66+/jpdffhkTJkxQfA1mZGRYDC22hq2/Gzk5OQgODoYkSWjfvj127dol3JECKtcifvv27bIb4KRJk3D79u1Sj6sNLVZjEe/t7Y1bt25h3Lhx0Gq1peIpLKHm95FoR2rTpk147bXX0LBhQ6EbUpWtkTKSnZ2NESNGQKfTwdvbG4cPH66U0GIlWDLkMMZT2NvbIz4+vtw1o6bYHDt2rGzIoZRr164JayIZpqrgIoth7iFnzpxBdHQ0goKC8PXXX+OXX365axqpjh07lsv8uXHjhtVxmUWLFlXIkEME4weNlJQU2e7Y1riM0tBiU/bu3Ss0/mgMz3zuuefg4+Mj9AG5KiziDQYDVq5cKeu3Zs6cifPnz981jZS50GKjG6BWq0X37t3LFaMrVqxQFVqsdvyxsLAQixcvlvO35s6da/VDrFqLeJGO1Llz59C7d28899xz6NOnj5A5jhqLeFuhxQaDAXPnzoWjoyOcnZ2xePHiSjfksEbXrl3LhRabxlMMGDCgnJ4nOTlZVWix2s5mbm5uKf2WtRtSgPLQYlNOnDghZBH/008/wdfXF88995zQDSmgaiziCwoKEBMTA3t7e3h4eGD9+vWqQ4vV3HD89NNPS+n8GOZewkUWw9wHGAwG7NmzB/7+/ujbty9+/PFHxeMO3333ncXQYmv72fogZByX0Wq1GDRoEDIyMlSHFotaxJvrSBnHZezt7c2OywDqPtx16tRJtUV82XEZax98q1IjZSQvLw9Tp05F7dq18fbbbws596m1iLf1nqempsr6rXHjxuHWrVuqDDmmTp2KxMREoTXmLOJzc3MxefJkSJJkVr8FqDfkEO1IrV69GqNGjcKuXbvQvn17SJKE4ODgUm6AZalKjZSRW7duYcKECahTpw7eeecd7N27V/E+R44csRhabA1b7/mWLVvQpk0bSJIkx1O4u7vj6tWrQvvEx8cLW8Sb60hdv34do0ePtnhDClAXWqymI2W0iDfekLK3t0dsbKzV810RjZTSjlRWVhaGDh2KunXromXLlkJ/P9RaxAcFBQmvYZiqgosshrnPMNVvffzxxzbvyikNLTZF1CJ+48aNcHFxQY0aNRAVFSU09qHmbqSt0OLs7GwMHz5c1m8dPnxYuCMFVEwjVbYjtWbNGlm/ZW5cZsqUKcKhxRcvXlTVkdJqtbh8+TIGDhwISZLKuQGaQ41F/PLlyxVbxBsMBixduhSOjo6oUaOGkH4LUDf+aKsjdeHCBfTt2xdarRa9evXC2bNnK9WQwxZlO1IGgwELFiyAk5MTnJycsHDhwnJ/d9SEFmdlZakaf5QkCWfOnJH1W2XdAM3h7e1dpRbxxngKe3t71KhRw6oboDnUWsSXNeUx5cSJE/D19S11Q+qnn35SZcihViNl2pEqKChAXFwcHBwc4O7ubtZMJDExUVgjZWrIIYJWq8WhQ4fk/K2y8RTmUGMRf/r0aSxevFj4+BimquAii2HuY65du4ZPP/0UQUFBWLx4cbkuktoPd2ot4ufMmYPExER5XGbVqlVWP+CcP3++SjRSphw9ehRdu3bF888/j+7duwuNyyxZsgQfffSR0LHZsojPz8/HtGnT5HEZoxGCJEkVCi1WijmL+LS0NHh6ekKr1WLMmDHlukhqryM1HanIyEhMnz5ddgNs27atTRt8paHFZRH5mfbs2YMOHTrg+eefR9++fYX+fhg7UiLYsoj/66+/EBgYCEmS0KFDB+zevRtAxUOLlWLOIn7btm2yfmvy5MnIzc0tt+5uWsRPmjQJH374odxNOnDggNU1d8MifuPGjfDw8ECtWrUwePBgoRtSGzduVGURby20ODs7G8OGDSsXT6FGI6XGIt6cIYfxhpQxnsLc70U1xWZ0dLTwv2sMU5VwkcUwDwinT59GdHQ0goODsWXLFuj1eixYsOCua6SMlA3PTE9PL7emb9++whbxP/zwA/z9/YXWGDtS69atg5ubG3Q6nc1xGaCkI1XWeMQWU6ZMURxanJmZiSFDhqBFixaoU6eO8DhZZVvEGwwGLF++XLY7njlzJvR6fYVDi0Uo25Ey6reMboDmRjfVhBar7UjZ2dlh0aJFcHJygqOjI+bPn2+zU6JGIyViEf/rr7+id+/eaNmyJerWrSscbq5WI2WpI2XUbzk5OcHFxQVLliyBwWDA2rVrKxRaLELZYtMYTyFJEgICAszmMQ0fPlzYIl5tR8rOzg4JCQnyDanVq1fbvI48PDyQmZkptE9iYqLi0GLjKGerVq1Qr1494cK2si3i8/LyEB0dXe6GlJrQYoPBgODgYKE1DFPVcJHFMA8YBoMB33//PSZNmoQmTZrg+++/F5r7rwqLeFO748GDB8vdJLWGHKIW8WVDi41ugDqdDm5ubmadztSEFgPqOlL9+vXDrFmz5HGZkSNH2vxQXtUW8Xl5eYiMjIROp0PNmjWxatUqob0iIiIwa9YsoTVXrlyx2pHau3cvOnXqBK1Wi/Hjx8sjmRUJLRZh5cqVpTpSOTk5CAkJKeUGWBY1ocWAuvHHwYMHIzw8XNZvhYSEWNVvAcpCi82h9D2/desWxo8fD0mSUKtWLWzatElon+nTp2P69OlCa7Kzs60achj1W2XjKdSGFpc15LBF2dBi4w0prVZr8YaUrY6UJezt7VVZxI8ePVoeb1ZyQ6qqLeIzMjIwePBgSJKE2rVrY8eOHUL7fP/998LOqAxT1XCRxTAPMHfu3MGaNWsQHByMhIQEXLp0yeYatRbxSjtSxvDMt956C82aNRMabVKrkbJmyGFpXKaiocUimP5MBoMBq1evlu2OLY3L3E2L+Pfeew8BAQGK9VuAuiLhgw8+UPRByGAwYMmSJXBxccE777yD5s2bC12zFRl/vHHjhtnHzp8/jz59+kCr1aJ3796yDjIqKkrYkKMiGikjBoMB8+fPt6rfAsRDiwEgKSkJw4cPF1pTUFCAd955R0i/Bai3iFfSkTKNp2jVqhVatmwp/LtPze8jaxbxRjfAsjekKhpaLIJWq5XfB6N+yxhPYcl6/25axL/11lvw8vJSrN8CSgyWRH8fMUxVw0UWwzwk2NJvAepCiwF1OosOHTogKChIDs+0Jhw3smjRIkycOFFoH5GO1OHDh9G1a1dIkoQ6deoI6beAEot4W/qhsuzdu9diR8o4LqPT6UqNy1SmIYctylrEHzhwAJ6enpAkCWPHjjWruRINLTaidvxx2LBh0Ol0Ft0Ay7JixQqbocVlERl/3L17Nzp06ABJklCvXj388ccfQnuZCy22hbXQ4r/++gsTJ06U9Vt79uyRH1Pznru5uQmPksXExJQKLf7mm2/Qtm1bSJKEKVOmmNVvqdVIqfl95OnpCX9/f6tugGVJSUkRtogvLCxU3NncsGEDWrduDXt7ezRs2FBYT1TZFvHGG1JarbbcuGhlGHIowdQi3vSGlIODAxITE80WUnfu3EF4eLjw8TFMVcNFFsM8hBj1WyEhIdi6dav8D5Oa0OLdu3dX2CL++vXrGDlypOwGaG5cBhAPLQZKOlJqLOLfeusteVwmLi5O0d30qrSIz8jIwKBBg6DVatGyZUv069dPaB+144+WOlIGgwHLli2T9VuzZs2Sn6cmtPjAgQPo1q2b0Jqy19GFCxdk/ZbRDdAcagw51HSkrly5gjfeeEPuJi1YsEBRp0TNdaS0I3X27Fn4+/tDq9XC0dFR+DqqbIt4vV6POXPmwNHRES4uLli6dKn8HqkNLa6oRfzJkyfl8eaBAwdaLAREQ4sB4OOPPxa2iM/MzMSrr74qdEMKUK+RUlJgGuMp7Ozs0L59e7z//vtC+6gdf7RkyJGXl4eoqCjodDq0bt26lGvomjVrhEc6GeZuwEUWwzzEmOq3wsPD8c477wjntlS2RbzpuMyQIUPkDzGVZcihBFOLeKN+yzguk5ycbHaNtY6UJdR2pFq2bImOHTvCzs4Oo0ePVlQw2AotNodSi/jc3FyEh4fLH3D++9//Cu0DmA8ttsXy5csthhYb9VuSJGHChAlycX43NVKmFvE5OTkIDg62qt8C1BlyFBcXq7qO3nnnHbi7u0Or1SI0NNSmfgso35FSgtLQ4lu3bmHcuHGQJAmdOnXCm2++KbQPYN2QwxLWLOI3b95sVr91N/LIjJh2pLKzszFixIhS8RTm+Omnn4RCi42ouY6aNWsGBwcH6HQ6xTekbIUWm0NpaHFGRoYcT+Hr64shQ4YI/7vGMHcDLrIY5hHhzp07+OKLLxAcHIzExESz7ltlqQqNlClG/Za9vT2cnZ0Vu/YZMRdarARLP5MxPFOSJPj4+JTqHHTs2FFYI/Xll19i/PjxQmtMQ4sNBgNWrlxpc1wGUFckqLGIX79+PRo1agRJktC9e3dF2VpVaRFvMBiwePFiuLi4wNHRER06dFDs2mdErUW8pevo3Llz6NOnDyRJQp8+ffDbb7/Jj3l5eeHEiRNC+6ixiDctEoxugI6OjnBycsLixYst3phQaxFv6eaEJZKSklC/fn1IkoQBAwYo+n0EqCsSlFjEm+q3XF1d0aNHD0ybNk1on2vXrqm2iDd3Po4ePQofHx9IkoShQ4eW6qr5+voKa6Q2bNiAQYMGCa0x7UgVFBQgJiZGdgO0FgugxiJ+zJgxWL58udCarVu3CutQGeZuwUUWwzyCZGdnY/bs2QgKCsKXX36Jv//+2+zzREOLAXUdqYKCAjRq1Egel1Fqs2wrtNgcSkOLTfVbI0aMgJrfQ87OzsIaqSlTpuDTTz8t9/28vDxMnTpV7iaZWppfvHixwoYcSjENLd6/fz86d+4MrVaLsWPHWvxZRUKLjaixiM/NzUWDBg1k/ZZSh7KqtIjftWuX7AYYFBSk6jpSYxFvKbT41q1bmDBhAiRJQseOHbF37175scow5FCKaWjx1q1bZf1WeHi4Wf0WIBZabERNR+r69euoV68etFqtYv0WYDu02BxKO1IpKSnyDamYmBjY2dkJ7QOUjD+KaqQsWcQbb0hptdpyN6SuX79eqcWmNebMmaPI8Ilh7gVcZDHMI86pU6cQFRWFoKCgUvotQH1o8fz584XWmBpymI7LdO3a1eqs/d2yiB82bBgaNmwIe3t7fPzxxygsLLS5Rq1Gyt7eHkVFRVafc/nyZXlcplu3bvD09BQ25DAXWmwLSx0pg8GApUuXwsXFBQ4ODpg9e3ap68jFxUVVaPHMmTOF1ly+fFnuSF24cAH9+vWzqd8C1F1HXbp0EepIGQwGBAQEoH79+lbdAMtSkfFHWx2pX375pZQbYI8ePYRDi3/88UdVFvHmriO9Xo/Zs2fDwcEBLi4uWLZsWan3SG1ocWxsrNAaU4t403iKQYMGWS1S1FxHvr6+FjWq5igoKECfPn3w4osvwt3dXfENqcrWSJmSnp4ux1OMGDECH3zwgXBo8cmTJ1VZxAcFBQmvYZi7BRdZDMMAKPkQ+N133yEkJATh4eFITU29axopS6HF1sZlfvjhB0UdKVMqMv74559/lhuXWb9+vcU1ai3iRccf09LSUKtWLWi1WowZM0ZxMaPGIl5JaLFRvyVJEtq0aYMNGzaoCi1Wk0cWEBBgtiO1Z88edOzYEZIkYeLEiaVuHBw8eFBVaHFFLOL/+usvBAYGym6Au3fvtrhGJLTYiJqO1LZt21CzZk2rboDmMO1IKWXt2rU2LeJv3ryJsWPHQpIkdO7cGT/88MNd00hZCi3euHEjWrduDZ1Oh6ioqFLFx7Fjx1SFFqsdf8zMzER2djaGDx8u35A6cuSIxTV3yyJ+zZo1qFmzJnQ6neIbUoA6i/hTp05h8eLFQmsY5m7CRRbDMOXIzc3F559/jgEDBiAhIUGxXkKtRbySDxrJyclwd3eHTqdDTEwM2rdvL9yR+uKLL0qFFivh9u3bZjtSpvotX1/fcs5vOp1OlSHHt99+K7TGGFpsMBiwfPly2Q1w5syZFouUiljEi3SkLl68iLfeeguNGjVCjx49FBd1ph0pEWwVPgaDAYsWLYKzszMcHR0xb948dO7cWVVocWVZxJ87dw69e/eW9Vvnz58v9bja0GI1FvE+Pj6l9FvOzs748ssvrV7HaopNUYv4n3/+GU2bNkXDhg0REBCg+PeRrdBiS9j6u6HX65GYmCjrt1atWmWz626OlJSUUqHFSigoKDDbkTK6LkqShGHDhpV7f9VopEaNGiUcUm4MLTbGUxhvSNm6HtX8PoqKihKetGCYuwkXWQzDWOXq1auYPXs2AgMDsWTJEov6LUCdRfyePXvg7++v+PkFBQWYPn06nnvuOaFxGUDd+OOkSZNsdqRMx2VGjhyJI0eOVKohhzXMdaTy8vIQGRkp67e+/vrrUo+rDS2uiEW80Q3Qzs4O48ePt6pVCwgIKHfMtkhLSxOyiM/JyUFISAhq1KiBdu3aKQ7bBkqKhKqwiDfVb4WEhODXX39VpZFSU/h4e3vj2LFjpb5369YtjB8/XnYDTE1NLfX4mjVrMGLECKF9Kura9/XXX6N169aQJAkRERFWC4fhw4dXuUX89evXMWrUKNSoUQNeXl5Co3/u7u7CFvHx8fE2O1Lr1q2T4yliY2ORkZFx1zRS3bp1K9eRysjIwODBg6HVauHr64vjx4+XelxNaLHBYEBwcLDQGoa523CRxTCMYk6ePImpU6ciODgY27ZtK3eH/W5ppIyhxcZxGXPhmWXJyclRXSQo/aBRXFyM1atXo06dOmjSpAkSEhIUdyGUGnKYoqQjdfnyZQQEBMj6rZMnT1ZKaLESzIUWGwwGLFmyBM7OznBwcMCcOXPKvb9qw2bVWsT//vvv6Nu3LyRJgr+/v9XIAjWGHIBYR8pgMGD+/PnydaRUvwWUGHJYCi22RHFxsc33/MyZM+jVqxd0Oh369euHixcvws3NDdeuXRPaS41FvLmOVFk3wOXLl5d7j9T8PvLx8VHVkRo6dGgp/dbgwYOtFlCWOlK2sLe3V9yRKigoQFxcHOrWrYs333xTqOC0FlpsDVvv+aFDh+Dl5QWtVotRo0bh+vXrqkKLd+/eLeyMyjB3Gy6yGIYRpqioCLt27UJoaCgiIiJw7NixSgktVoo5i3hb4zKhoaGqQovVdqTKjsuYhmeaQ2losSlLliwRsohPS0tDhw4dUKNGDYwdO1aoG6NmbM1WaHFubi6mTJkCSZLQrl07bN++Hfv371cVWlxZFvHff/89OnbsCK1Wi8DAwHLX2dSpU4UNOSpiEW+q3+rYsSP27NljdY2Xl5ei0GJTVq9eLdSR2rZtG1q3bo3nnntOSL8FKDPkKMuwYcOsWsTfvHkTY8aMgSRJ8PT0RFpaWqWEFivFXGixMZ5Cp9MhOjq6XGEUHx8vHFpcEde+7OxsDBs2TNZv2dLRqdFIbdy4UbFFvMFgwOrVq+Hi4oIaNWpYjacwR2hoqPDvI4a523CRxTBMhcjNzcXKlSvRtm1bTJw4EVeuXFG8Vq1FvK2O1Nq1a2X91vTp01FQUFDh0GKlmAstzsjIwKBBgyBJEvz8/Mq50lVEIyXakQoLC8Ps2bOxbNkyWb81a9Ysqx9YlIYWl0XkZ7pw4QL69++P559/Hm3btsUvv/yieO2yZcsshhZbwlZHymAwYOHChXBycoKjoyPmz58Pg8EAe3v7CoUWK8WcRfzZs2fh7+8PSZLQt2/fcvottcWmGov4adOmYfr06ZgzZw6cnJzg6uqKpUuXWv07djcs4k+ePIlu3bqhVq1a8PT0FPp9VBUW8QUFBUhISIC9vT1cXV1li3c1hhyVZRFvjKfQarUYPny4WX2cmt9HajpSM2bMQFhYGKKiouTxZlt/V4zmOgxzv8NFFsMwlUZWVhY++eQTBAYGYunSpcjJybH6fKWhxaaEhoYqtogvKChAbGwsWrRogeeff15Yn6F2/NFagWBuXObLL78UNuSoqEbK9HUiIiKg0+nQpk0bsyM4akKL9+/fr8oi3s7ODnv37pXdAD/66CP8+eefVtcpCS0ui4hFfE5ODoKDg9GiRQvUqlVLWHeo5jqyFVq8Y8cOWb8VGhqKnJwcVaHFlWURX1a/tW/fvnJrhg4dKmwRf/jwYVUW8ZIkYfPmzbIbYGRkpM0xu6q2iL9+/TpGjBiBli1b4oUXXhDSbwHqLeKtdaSMN6Ts7e0RFxeHgoICbNiwQdiQo7Is4m3dkAKAVatWCY90Msy9gIsshmGqBFP91rffflsu+0lNaDGg3iJ+9erVshtg165dy4n8y1LVFvEGgwGrVq2Cq6sratSogaioKKEOyZQpUzBnzhyh47MVWmyq3+revbscOlzR0GKllLWINxgMWLx4sewGOHfu3HLn/m5opIwMHDgQ8+fPR+/evaHVatG7d2+r+i2gpKiuyvFHg8GAzz77DE5OTqhZsyZmzJgh9PcjOjoaH3/8sdDxZWVlWXXtO3XqFHr27AlJkjBgwADZDVDNdaRktK0sZTtSZfVbK1asKPceVdSQQ4QRI0YgJiYGPj4+0Gq15eIpzPHTTz9VqUW8aTzF888/j0WLFgntYym02Bq2xh9Nb0iNHj1avpESGBiI4uJiob0Y5l7ARRbDMFVKUVERdu7ciZCQEFm/BVQ8tFiEsh80jOMykiRhxIgRZsX7nTp1EjbkWLx4saqOlL29vdC4DKCuSOjfv7/i0OL9+/ejc+fOaNasGf79738LjSWqHVuzZhGfm5uLyZMny/qtHTt2AAAiIiIwa9YsoX3UWsSXvY6MboBarRbBwcFmO7deXl6qLOLVdKRatWqFiRMnyvlbtvRbQMl1pDTLyMjgwYMVd6S2bt2Kdu3aoXnz5njjjTeE9FuA+hwpSx2p69evY/To0bJ+y9jlqWhosQhlf6aUlBRZvxUTE2O2aFNjyKG2I/Xuu+/KN6R8fHwUafzUWMSPHj1aUWixwWDAypUr4ebmBnt7e4SFhQntwzD3Ci6yGIa5a9y+fRsrVqxAYGAg/vOf/yjOuzHy/vvvC1ltA7Yt4pOSkuR/vOPj41FQUFCphhy2KBtabByX0Wq18PPzM/sBvSKGHKJ07twZcXFxcHFxgYODA2bPnm2zuFu6dKnN0OKy5ObmKu5IXbhwAf369YMkSahVqxZOnz4ttJcai3hrHSmDwYAFCxbAyckJTk5OWLBgAQwGQ4UMOUQ1UmVDi8+ePYtevXpBkiT069cPFy5cKLcmMzPzrlnEe3l5ITAwEA4ODnBxccFXX31ls+OmJLS4LCIdKVM3wNq1a5t9j6xhKbTYGtZCi41ugPb29uXiKSrLkMMWZUOLDx8+DG9vb9jZ2WHEiBFmr8uKGHKITiXMmjVL+DwxzL2CiyyGYe4JGRkZmDVrFoKCgvDVV1/Z1G8B6j7cKbWINx2X+e9//ytsX1wVFvGWxmX69+9fKYYctihbbBoF59b0W4B4aDFQYhGvpiPVsmVLdOrUCZIkYeLEiYqKXDUfWJVaxBv1W5IkoXnz5sIOd1Ux/rh9+3a0bdsWWq0WkyZNwu3btwGoDy0WtYgHSr/nf/zxB8aOHQtJktC5c2fs37/f7Bo1GqnY2FhVFvHNmjWT9VtRUVGKujJqfh8p7UgZ4ykkSYKdnZ3we652/NFaR2rNmjXlbkgBJaHFq1evFtrHGFosSlBQkPAahrlXcJHFMMw958SJE5g6dSpCQkKwffv2cvotoCQXRSS0GFDv2qfT6TBgwAChcZnQ0FCbocVlUdqRMo7LuLq6wt7eHo0aNRIeFTQXWmwLa6HFFy9exIABA6DT6dCzZ0/5tUU6UqZIklQhi3iDwYBFixbJ+q158+aZLV5FQ4uNr63mA7VOp0O3bt0gSRL69OlTzg3QHEpCi8uSkZGhqCNlMBgwd+5cODo6wtnZGa+99ppwJ8Hb21vYIt5aaPGpU6fQvXv3cvqtgoICVdeRGo3UsGHDZFMcvV6PxMREODg4wM3NDatXrzb7Hh09erRKNVKmaLVa+UbC0KFDcfXqVZtr4uPjMW3aNKF9lHakjPEUOp0O7u7u+M9//iN8HamxiD916hS+/PJLoTUMcy/hIothmPuGoqIi7NixAyEhIYiMjCz1Ya5Dhw6qQosrahGfnp4Ob29vaLVajBw50uIY192yiN+5cyfefPNNWb+1efNmm2uq2iJ+79696Ny5M7RaLezs7IQ7CZVtEZ+Tk4PQ0FDodDq0a9eu1IhpRUKLRSjbkdq5c6fsBmhJvwWoKzbVWMTv2rULr7/+uuwGmJqaanNNcXGxqutIqUX8li1b0KZNG0iSBDc3N+EcqcrSSBkx1W95eXmVcgPs2rWrsEYqOTkZQ4cOFVpTNrR43bp1shtgbGysxYLS3t4e+fn5QnuNGjVK2CJ+165daNiwIbRaLXx9fRUX4Gquo6ioKPz999/C6xjmXsFFFsMw9yW3b9/G8uXLERQUhBkzZsDOzk74NdRaxH/22Wflvl9cXIzVq1fL4zIJCQnyh+G7qZEyDS2+fPkyPvjgA0iShG7dulksHkRDiwF1HSmDwYB///vfcHFxgaOjI+bMmaOoYKhKi/gLFy6gb9++kCQJvXr1QsuWLYX2AdRZxFsKLTYYDJg/fz6cnJzg7OyMhQsXysW50o5UWdRaxBs/EJ85c6aUfuvixYtm16ixiFcztqbX6/Hqq6/K2VLLli1TdAPDVmixOZSGFpvqtwYPHqzqOnJ3d1fUhTIlLi7ObLFpqt9yc3MrFU9REY2UKKYdKeN4s52dnRxPYQ6R0GIjBoOBRwWZBw4ushiGue/JyMhAZGQkgoKCsGzZMllTYg21GiklHSnjuIy9vT08PDzg5OSkSiOlxiLeUhZNWloaPD09odVqMXbs2FJFgbOzs3BosVqLeGNHKjc3F1OmTIFOp0Pbtm2tuhqqNeT4+eefhdaEhobi5ZdfhiRJCAwMVFSAV6VF/F9//YXAwEDodDp07NgR7du3r5TQYltYG3/ctm0b2rZtC0mSMGXKlFJugGpCi2NiYkoZcijBNLT45s2bGDt2LLRarVX9FnD3LOInTpyI+vXrQ6fTITo6WlHHqCot4rOzszFs2DA5nsLX11dVaHFljT8aDAaLN6SAEkMO0dDi7777Dt98843w8THMvYSLLIZhHiiOHz9uU78F3D2L+IyMDNStW9dqeKY5lBpymKIktNhgMGD58uVwdXWFg4MDEhISVIWEqrWIN9eRunjxIvr37w+tVltKvwUAqamp6NGjh9A+FXHtu3nzZin9lpOTE+bPn2+xsBYJLTaSkZEhbBH/66+/onbt2pAkCX379lWk3wJshxabQ0lHSq/XY86cObJ+a9GiRapDi0WvI0uhxSdPnpQ1bgEBAaXcSdWGFqu5jtzc3JCdnQ29Xo+EhAQ5f8taYaPWIl60I3X48GHUqlULkiRh+PDhio1DfH19hcORlVjEm96Qat26NVJSUlT9PgoNDRW+jhjmXsNFFsMwDyRl9VvHjx8v9bja0OKKWMSbugFaG5e5Wxbxd+7cgZOTE1599VW0bt1aNomwxYULF6yGFltCyc+0d+9edOzYEVqtFuPHj0fbtm2FDTnKhhYrwVJHKicnByEhIZAkCe3bt8euXbtKPa42tFiJVs6UgwcPyh0pU/1WaGioRf3W3bKIv3XrFnQ6HV5++WXF+i2gdEdKBCXX0ebNm9G6dWtIkoSIiAh4enoKd6TWrl1bKrRYCZY6UtevX8fIkSMhSRK8vb3LFSwODg7ChhwVtYhfu3atrN+Ki4uzuv/dsIjPyMhAq1at8NJLL8HX11fxzYHc3FxEREQIHx/D3Gu4yGIY5oHn9u3bWLZsGYKCgjBz5kzs37+/UkKLlWCuI2U6LuPg4IDExMRSH9TVhhartYjX6/W4fPkyAgICIEkSunfvjlOnTllc069fP8WhxUZSU1OFLOINBgO++OIL1KhRA46Ojpg7d67ioliNRbyS0OLz58/j/fffh1arhb+/P/bu3VuphhzW6NKlSzlNncFgwLx582T91qJFi0q9R2pDiyvSkTp16hR69uwpuwFeunTJ4ho1FvE//vijkF25Xq/HzJkzUaNGDbi4uGD58uWKryM1FvHTp0+3aexy7Ngx+Pj4yPqt48ePV6ohhzXMWcQXFBQgNjZWzt8qq1tTG1qspiNltIgve0Pqxo0bFtesWrUKR44cEd6LYe41XGQxDPNQkZGRgeDgYAwYMADLly9XpN8CSjpSvXv3FtpLSUcqLy8PUVFRshvgxo0bKyW0WAmWDDn2798vuwGOHTu2nF5LTXfE1JBDKUaLeFP9Vrt27azq29RaxIt2pHbv3o169erhv//9r2L9FlDSkaoKi/i//voLEydOhCRJ6NixI3744Qe4urpa/XBqDjUW8ZZCi7du3Yo2bdpAp9MhLCyslH4LUFckqLGIN4YWG90AtVotPD09rVqEV6VGypT169ejXr16eOONNxATE6N4rVJDjrLYes+zsrJk/ZYxnqIyQouVcP36dbi6upb6njGewtINKQAIDAxEcXGx0F4Mcz/ARRbDMA8tP/30EyIjIxESEoIdO3ZY1G8BJR2pX3/9Vej1Fy1ahIkTJyp+fkZGBvr164caNWoI6bcA66HFlrAVWmwwGLBs2TK4urrC0dERs2fPxvfff68qtFhNYWbOIv7ChQvo16+f7AZYtksYHh6O2bNnC+1z+fJl1R0pg8GAhQsXwsnJCY6OjliwYIHV82CuI2WLFStWCFnEnz17Ft27d0eNGjXQr18/XLhwQfFaNeOPgwcPtmrIodfrMXv2bDg6OsLFxQVLly7FoUOHKhxarBSjRsoUUzfAgQMHljNaUBNafPXqVdUdqYKCAsTHx8v5W7aMKXx8fIS7NykpKUIW8YcPH4aXlxdq1KiBESNG4Nq1a4rXWgsttoSt0GLjDSmjfmvTpk24evWqsHEKw9wvcJHFMMxDT1FREbZv346QkBBMnTq1XHFztzRSQImAe968eaXGZUaPHm11/O1uWMTn5uYiPDwcNWvWhE6nE7JUV2sRb2v88YcffpD1WxMnTsRff/2lqkgYMGCAYj2aEXOhxTk5OQgODrao31J7HamxiI+MjERiYiK2b9+O9u3bQ6fTYfLkyeW6SaaoMeQAxK6jW7duYdy4cXj++efh4OBg1Q2wLNZCiy2hpCO1ceNGtG7dGjqdDlFRUcjLy4NOpxPWSA0dOrSUVboSzHWksrOzMWLECGi1Wnh7e5vN27obGimgJLQ4JiYGSUlJshtgfHy81femIhbxSm8UZWRkYODAgfjvf/9rdSSVYe5nuMhiGOaRIicnB1999RUCAwMxa9YsZGVlYeHChapCi52cnIT3L/tBo+y4zIwZM8oVEWpCi9VaxGu1Wly8eBEDBgyAJEnl3ADNoTS02JSwsDDFHSmjfqtVq1aoWbOmkH4LUPeB1VZo8blz59C7d29otVr07t0bv/32W6WEFiulbGixwWDA3LlzZTfAxYsXl3uP1IQWq7WIlyQJp06dQvfu3WX9lqkboDnUWsTHx8creq5er0diYiLee+891KxZE6tWrary68iWRfzRo0fh4+MDrVaLoUOHIisrC+vWras0Qw5blB1/LCgoQExMjKzfMufyOHLkSKsdKXMcP34cXl5ewscnMinAMPcbXGQxDPPIcuXKFTnoeMGCBVa7AGUJDQ0Vtoj//fffrXak8vLyMHXqVHlcxuhQp9aQQ1QjtXjx4nIdqdTUVFm/NW7cuHLFVEUNOUQYMGAAkpOTERoaCkmS0K5dO5tukEpDi00R7Ujt2rUL7du3R40aNTB69GiLboDmUGsRb82179atW5gwYYKs39q7dy8A9aHFlWERv2XLFrRt2xY6nQ4RERHlRs3ulkYKKOlILV68GKNGjYIkSejSpYtV/Rag3iJe5D1ft24d3N3dUbNmTYSEhAj9XPHx8cIW8deuXbPakcrKysKQIUMgSRJ8fX1lrZxWqxXWSPn6+tp8j8ty8uRJLFmyRGgNw9xPcJHFMMwjT3FxMY4ePYqIiAgEBwdj165dNu9wq9FI9e3bV3FH6sqVKxg4cCCaNm2K+vXrC+l81GqkrIUWGwwGLF26VNZvzZkzB3q9XnVocWVYxP/+++/o27cvJEmCv7+/WU1d586drTopmqMiFvELFiyAk5MTnJycsHDhQkXXkRqL+E2bNil67i+//IJevXqhWbNmaNiwoZB+S+11ZK0jpdfrMWvWLDlbatmyZTAYDIiJicHHH38stE9lWcSb6rcGDx6MzMzMcmvUhBartYiXJAlxcXHQ6XRwc3NTZOOuxiJ+xIgRikOL09PT4eXlhebNm6NRo0bCHUc119HUqVPx999/C69jmPsFLrIYhmFM0Ov12LZtG4KDgzF16lSzxY2a0GJAfUcqKSkJnp6e0Gq1GDNmjE39jlqLeKVja6ZugDVq1BDSbwElhhyVbRG/Z88edOzYEZIkyfqtioYWixAZGVnKIv6vv/5CYGAgJElChw4dsHv37nJrLl++XOUaKSNeXl6YP38+2rVrB0mSbOq3gJKO1OjRo4X2EbGIv3nzJsaOHQtJklCzZk2546aUwYMHmx1ns8aPP/5otSO1YcMGeHh4QKfTITo6Gvn5+QAqz5DDFnFxcZg+fbr8dXZ2NoYNGwatVmux0MvOzr5rFvG+vr6IiYmR9VsJCQk2bxKosYg3GAwICgoSPj6GuZ/gIothGMYCf//9N5YsWYLAwEB88sknsqi8oqHFSik7tmYwGLB8+XK4urrCwcEBM2fONPsB525axDs6OqJ///6K9VuAug93nTt3VvTaBoMBixYtgrOzM9544w24uroKdRzv3LlT6Rbxv/76q6zf6tu3L86fPw8ACAgIwNdffy20T1pamiqNlGmxaarfcnFxwZIlS8y+R25ubsLFZnR0tLAbXFZWFuzs7GT9VkBAgE39FqCuO+Lt7a2oI6XX65GQkAAHBwc0bdpUuBhWO/5orSN1+PBhdO3aFZIkYdiwYXIBV9HQYhFM/+7m5eUhOjoaOp0OHh4eFjPR1Bhy7Nq1S/hGDMPcb3CRxTAMo4DLly8jMTERgYGBaNKkiZB+CzAfWmwLax2pvLw8REZGyvlbRve8nJwc1Rop0fHHfv364dtvv5W/3rt3Lzp16gStVovx48ebHT0UDS0G1Lv2OTk5Ydy4cRbdAM0RHh5uM7S4LCIW8Tt37kT79u0hSRLq168vpN8CbBtymGPlypUWDTlu3bqF8ePHQ5IkdOrUCampqQDUG3LY29ursog3/YC+ZcsWOX8rMjLSrFV4enq6Ko2UmsLMyckJAwcOhCRJ8Pb2Rnp6us01aiziRTpSa9euhbu7O+zt7dGwYUPhUUFzocW2SElJwZAhQ8w+lpGRgcGDB0Or1cLX1xfHjx8HUFJsqgktDg0NFb6OGOZ+g4sshmEYAYqLi5Geno6IiAiEhIQo0m9VtUX85cuXERAQAK1WizfeeAOTJk0S2qeyLeINBgOWLFkCFxcXODg4YM6cOfJ7VJHQYhHKGnKcP39e1m/17t0b586dM7tOjUYqICBA2CJ+//79aN68OZycnODs7IxFixYpuo7UaqSUdKROnTqFnj17QqvV4u2338aUKVOE9snMzKzU8Ue9Xo+ZM2fK+q3ly5fL75GXl5dwaHFlWMT/9NNP8PX1lfVbljo0agw5hg0bJmwRf+jQITRu3Fh2A0xOTla0riot4k3jKXQ6nfDvo9zcXERERAgfH8Pcb3CRxTAMoxK9Xo9vvvkGwcHBiIqKws8//2z2eaKhxYB6i/i33npLdgMcO3asog/Xai3ilXSkjPotSZLQpk0bvPnmm0L7AOos4q2FFu/evRsdOnSAJEkIDAyUC9lLly6pDi0WxbQj9ddff2HixImyG+APP/xgds3dtIh/88030bp1a0iShClTpijq3NoKLTaH0tDimzdvYsyYMZAkCZ07d0bTpk2F9gFKik2RwF2gxCLeUkdqw4YNaN26Nezt7RETEyMXVRUJLRala9euckcqKysLQ4cOhSRJ6Nq1K44dO2Z2TXJyslBoMaBu/NFgMOCNN96As7Mz7O3tkZiYqOgGxsqVK4VNRhjmfoSLLIZhmErAqN8KCgrCJ598gqtXr8qPOTk5qQ4tFsG0I2UwGLBs2TK5mzR79myLH3DUfLhT05FKTExE48aNZf3WL7/8YnNNVVrEGwwGLFy4EM7OznBycoJWqxXWSKm1iLfUkTp79iz8/f0hSRL69etXyg1QrSGHGot4Y0dKr9dj9uzZcHBwgIuLC5YuXWqx46bWkEO0I/Xxxx/j1VdfhSRJGDhwIDIyMmyuqUqL+IKCAsTHx8PBwQFubm5CHSUj5kKLlWDpPTfVb40YMaJUcenu7q46tFiE69evw9XVFUBJsR8VFSXrt6wV44GBgcIW8QxzP8JFFsMwTCVjqt/66quvVBUJZUOLlWDJIj43Nxfh4eHQ6XRo06ZNKTdAtaHFaj5Qm3ak9u7di44dO0Kr1WLChAkWi9CwsDBVFvGiHamcnBzUr18fOp1OsX4LKDHksNTBtMSyZcsUdaS2b98uuwEGBweres/VjD8OGjTIrEX8rVu3MG7cOGi1WnTq1An79++XH1MbWlxRi/jNmzejdevWVvVbAO6aRfy1a9fw4osvyvotpbonNRbxSkOLjfotBwcHxMbGqrqO1Iw/WrKIz8jIkDVufn5+pTSGWVlZmDFjhvDxMcz9CBdZDMMwVURxcTEOHDiA8ePHIzQ0FN99952iwun8+fOqNFJKPrBevHgRAwYMgFarRffu3eHg4KDKkOOjjz4SWmOpI2UwGLB48WI4OzvD0dERc+fOLfUeqQ0tFrWVN+1I/fbbb+jTp4+s3zK6AZo7djVFgouLi1BHymAwoGPHjnj11Vfh7OyMxYsXK7qOTDtSIij5EH7q1CnZDXDAgAFo3bp1pYQW2yI/P99sR6qsfmvlypXlrqPCwkKhvYYOHSpsEW8aWnz06FH4+PhAkiQMHTrUavdITeHj7u4uZBFfUFCAdu3a4eWXX4aHh4finy07O9tqaLEllPzdSEtLQ5cuXeR4iqioKFy5ckV4L4a5H+Eii2EY5i5g1G+FhIQgKirKakCuSGixkT179gh3pPbu3YuaNWtCq9Vi3LhxinVPzs7O+PPPP4X2mjJlik2L+JycHISGhkKSJLRt2xbLly+vlNBiJVgKLd61a5fsBhgcHFzKDbAiocWiGIvNW7duYcKECbJ+y1q21MCBA7F582ahfdR0pL7++mvUrFkTkiQhPDwcd+7cUbTOWmixJaZNm2bTIv769esYPXo0tFotPD09sWXLlruqkTLXkUpOToa7uzt0Ol0p/RZQ0mkaPny40D4VHX801W/5+vpaHdkcPny44tBiI0ePHhWyiDcYDFixYoWqYo5h7le4yGIYhrnL/P333/jyyy8RFBSE2bNnl7sbraY7UhGLeIPBgKVLlyrSb1VEIyUy/njhwgW8+uqraNy4MXr16qX4Z0tNTUWPHj2Ejk3J+KPBYMCCBQvg5OQEJycnfP7553BycsIff/whtFdERESlWcT/8ssv6NWrFyRJQv/+/UvptwD1GilRi3hjR0qv12PWrFmyfmvZsmUWz7lIaLEpop3NEydOoFGjRvjPf/6DQYMGKdJvASUW8UoMOcpi6z0vKChAXFwc7O3t4ebmJo/yiYYWT58+HbGxsUJrLFnEp6enw9vbG1qtFiNGjChX+Kr5feTj44Mff/xRaM2JEyewdOlS4b0Y5n6FiyyGYZh7yKVLl5CYmIigoCCsXr0a27Ztu2saKXMW8UY3QJ1Oh7Zt25YLBFUbWqxm/NGYr7Nnzx5ZvzVx4kSrJiJKQ4tNWbp0qVBH6u+//8a4ceNQo0YNdOjQAbt371a8tqos4rdt2ybrtyZPnozvv/8e3bp1E9pH7fijq6srbty4Uep7N2/exNixYyFJEjw9PXHgwIFSj0dFRQmHFmdmZgprpID/FQkbN26Eh4cHJElCVFSURf0WUBJaLGrIIdqRys7OxqBBg1CjRo1SLoFKsBZabAklocVr1qyR87cSEhLkAkwUNb+Ppk6dKpwbxzD3M1xkMQzD3AcUFxfjyJEj6Nu3L4YOHYrdu3cr7vyotYi31ZG6ePEi+vfvL7sBnjlzRlVocf/+/YXHH1NTU8sVmwaDAYsWLZL1W/Pnzy91LBUx5BDtSBlDi8+dO4fevXtDkiT06dPHon4LuDsW8QaDAXPnzsXzzz+Pd999F0uWLFF8vlauXInRo0cLHZuS8UdT/VZAQAAuX74MSZIqHFqsBHOhxXq9HgkJCbIb4OrVq8u9R3dDIwX8L7TY6C4oSRKGDRtm9XXUWsSLFND5+fmYNm0ann/+ebz33ntC73tKSoqwRXxRURFCQkKE1jDM/Q4XWQzDMPcZer0eW7duRXBwMKKjo3H69Gmrz1caWmxKaGioUEdq7969cHFxQc2aNTF+/Hih3KqqsIg36rdM3QCXLFlS4dBipZgrEnbu3Cnrt0JCQsrdlVdjyJGWlqa6I3Xr1i2MHz8ekiShU6dOSE1NtbpOjUV8VFQUEhMTFT9/y5YtcHR0RM2aNa26AZqjKizir1+/jlGjRkGr1cLLywvp6emVElqsFHOufevWrZP1W7GxseUeHzp0qHBosahGyohWq0VmZiYGDx4s67eOHz9udY0ai/idO3fi22+/FT4+hrmf4SKLYRjmPuavv/6S9Vtz5swpd4dbSUfKHGos4vv164dvv/0WS5YsgYuLCxwdHTFnzhyrr3M3LOLPnz+Pvn37okaNGvD19cW5c+cUr7UWWmwJWxbxBoMB8+fPl/VbCxcuVN1lMw0tVoq50OIzZ86gZ8+esn7r4sWLpR6vqCGHCAMHDkRKSgpmzZoFR0dHuLq6Yvny5VavI7UW8XZ2doqf/9NPP8HX1xc1a9ZE7969kZmZqXhtTEwM4uPjhY7PlkV8QUEBYmNjZf2WsbCqaGixUtatW1euI3Xo0CF4eXlBq9Vi1KhR5fRbaovNkJAQFBUVCa9jmPsZLrIYhmEeEC5duoSEhAQEBgZizZo1uHPnDkJCQjB//nyh11GrkSr74c6o35IkCe3atTM7EqgmtHjJkiUYP3680Jrc3Fw4ODhg9+7d6NChAyRJQmBgoM0OX1VbxP/111+YOHEimjZtirp162LPnj2K91FbmNnqSH3zzTdo27YtJEnClClTkJubqzq0WI1GquzPdPPmTYwZM0bWbx08eLDcGi8vL5sdlLKsXr0aI0eOFFqTn58PBwcHbNiwAR4eHtDpdJg2bZpN/ZOaHCkRi/irV69i2LBheOutt/Diiy8KZ2qpHX+01JEyGAxYvXo1XF1dZf2WXq9HXFycsCFHbm4uIiIihI+PYe53uMhiGIZ5wCguLsaPP/6I8PBwNGvWTHH+lpG+fftix44dQnva6khduHChnH6rIoYcIuOIQIlFvGloscFgwMKFC+Hs7AwnJycsWLCg3HukJrQYUOe25unpia1bt8pugH379i3nBliWqraI1+v1mDNnDhwcHFCjRg0sWrRI6DoaOHAgNm7cKHR8tjpSJ0+eRLdu3SBJEgYOHIiMjIxKCS1WSlmL+IKCAsTHx8v6LXNW5mpCiwH1Hanly5fLboDDhw+3qQNTGlpsikhHKi8vD9HR0dDpdKhZsyaSk5OF9lqxYoWwyQjDPAhwkcUwDPMAU1hYiC1btiA4OBhRUVE29VuAug93Ihbxe/fuRadOnfDaa6+hZcuWQnoxY0dKFGsdqZycHAQHB0OSJFm/BZQYcnzzzTdC+6SmpsqhxUoxV2zu2LFD1m+FhoaadVVTo5GKjIwUtojPyMiAs7OzkH4LUHcddenSRXFo8ebNm9G6dWu88cYbaNWqlZB+qyos4rOzszFixAhIkgRvb295/K6iocUilH3Pk5KS4ObmBp1Oh7i4OLPdNDc3N2FDDjUdqezsbOh0OgwaNAiSJMHPz0/RuQ4KChLah2EeFLjIYhiGeUj4888/8cUXXyAoKAiffvoprl27Vu45e/bsgb+/v9Drqu1IOTk5Ye7cubJ+a+7cuTY7JVOmTMGnn34qtM/FixcVhxb/9ttv6NOnDyRJwgsvvGDVDdAcaizily1bZtGQw2AwYN68eXB0dISzszMWL14Mg8Fw1zVSpqHFp06dkvVbAwYMwKVLl8qtOXjwoCqNlJqOlIuLC6Kjo+Ho6Ag3NzesXLnS5nUUHR0tbBEv0pE6duwYfHx8IEkS6tSpI2z04O3tLTzyZ80ivqCgADExMbC3t4eHh4dc9BUUFMhRCCLodLoKW8Sb6rdGjx5t9oZBZmam8JgqwzwocJHFMAzzEHLhwgXEx8dj4sSJWLNmjdwFqEhosQhlXftyc3MxefJk6HQ6i/otoOTDnagAfsCAAeXyvGyxd+9eODs7y/qt4OBgmxk9FbGIVzL++Oeff2LChAmQJAmvv/66sJ26pdBiW1j7mbZu3Yo2bdpAkiSEh4cjNzcXgDpDjpUrV2LUqFFCa8p2pK5fv47Ro0fL+q1Dhw6ZXWdvb3/XLOJbtWol67diYmIUFSdVaRGflZWFoUOHQpIkNGnSBB9++KHQPtnZ2XBzcxM+Pks/k8FgwMqVK+Hm5gZ7e3skJibK52bWrFmKA6IZ5kGDiyyGYZiHmOLiYqSnpyMsLAwhISFo3ry5sKugGot4a6HFFy5cQL9+/SBJEnr16iUXfZVlyKEEU0MOg8GABQsWwNnZGc7OzrIbYFmWLl161yziW7ZsKXeT+vXrZ1O/BSgLLS6LUot4vV6P2bNnw8HBAc7Oznj99deFryNzocW2sGYRf+LECfj5+UGSJAwaNEj+sF5ZhhxKMA0tNtVvubu7Wwz+TUpKEgotNr62mvHH5s2bo0uXLtBqtRgxYoQijdqwYcNUWcR37drV5vPy8vIQGRkJnU4HDw8PDBo0SGgfhnmQqJIii4g+JqIzRHSciNYTUU2Tx0KI6BwR/UJE7ZW8HhdZDMMwFaewsBDJyckICgpCdHS0orG3nJwcODk5Ce+lNLR4z5496NixI7RaLZo0aYL169cL7bN371707NlTaI21sTWjfkun06FDhw7YvXu3/JjSjpQpaiziy4YWb9u2De3atYMkSZg8ebLcTSrL3bKI//zzz/H2229DkiR07twZ+/fvt7mmqscfN27cKHeT3nnnHYsFjiXS09Ph6+srfHyW3vPs7GwMHz4ckiSVs09Xo5EyhhaLkJWVVaojtWbNGrmb9PHHH6OwsNDsOrWGHEeOHBFas3PnTnzyySfCezHMg0JVFVntiKj6P3+OI6K4f/7clIh+IqIniOg1IvqNiB6z9XpcZDEMw1Quf/75JxYtWoSgoCDMnTvX4h3u0NBQzJs3T+i11XSkDAYDXnvtNVm/NW/ePEVFWlVaxJ87dw69e/eGJEnw9/dHq1athPYBKtci3mAwYO7cubJ+68svv5Tfo4qEFotiashx6tQpdO/eHZIkISAgAJcvXza7ZurUqZgxY4bQPhkZGWjdurXQGr1ej0aNGsHBwQGurq5YtWqVouvIy8tLsSGHEaWhxUePHpX1W0OGDFF9HamxiDfXkTK6ARr1W6Yjkko7UmVRU5hNnTrV5oguwzzIVPm4IBH5ENEK/K+LFWLy2LdEZG/rNbjIYhiGqTp+//13Wb+1du3aUi5uakOLLWmuLGFqEZ+Tk4PQ0FBZv7Vz506za6paI2XK+++/j8aNG0OSJISEhCj6cKjWIl7Jz3Tr1q1SboCSJFVKaLEtrHWktmzZgjZt2kCn0yEiIqLUdaTWkKMiFvHXr1/HqFGjIEkSvLy8kJ6ebnZNRfLIRC3i/f398frrr8Pe3h6xsbGKCqesrCy4u7sLH5+SAjojIwODBw+GJEnw9fWFi4uLsCGHGov4oqIihISECK1hmAeNu1FkbSai9//586fGP//z9RdE1M3CuiFE9CMR/dioUaO78FYwDMM82hQXF+PQoUMICwvDpEmTsHbt2rumkerYsaPZjtT58+fRt29fuZt07tw5+bEvv/wSH330kdA+ajVSxiLBYDBg/vz5cHJysqrfAko6UqIW8fv37xe2iD99+jReeOEFWb918eJFRetcXFxUWcTbcoPT6/WYNWuW3E2aM2dOlRUJZbHUkTpx4gR8fX2h1WpL6beAktBiUUOO/Px8VRopY2hxQUEB4uLiZP2WNQ3U3bKIT09Px/PPPw9JkjBq1CjFBaRSQw5TduzYIXwjhmEeNFQXWUS0k4hOmvnP2+Q5k/7RZGn++XqumSLLz9Ze3MliGIa5uxQWFmLZsmUYOXIkpk2bhl9++UXRuh9++MFqaLE5lHYSdu/ejQ4dOkCr1WLixInQ6XT4888/hfYqG1qsBEsW8X/99RcCAwMhSRI6duyIPXv2lHpcTbHZuXNnnDp1SmiNaWjxtm3b0LZtW0iShClTpljUb1VFjpQ5bt68iSZNmqBx48bw9PREWlqaonW2QovNofQ62rBhg6zfio6OhrOzc4VDi5VgySI+Ozsbw4YNk/VbZTtJaopNc69ji7Vr12LYsGEwGAxYvXq1WTfAsqg15AgJCRF2EWWYB40q62QRUX8iOkBET5t8j8cFGYZhHjBu3bqFhQsXIjAw0Kp+C7g7FvEGgwGffvopatSoAScnJ8yfP1/xSKMkScJja/3797dpEX/27Fn4+/tDkiT07dsXa9asUWXIoXZsrWxHSq/XY86cOXB0dISLiwuWLFlS6j2KiIgQzie6fPmysEYK+F+RcPLkSXTr1g2SJOGDDz7AlStXLK7x8vISHn9ctWqVkO29MVuqRo0acHV1xZo1axSvVTP+OGTIEJsdqSNHjsDb2xuSJGH48OH49ttvKyW0WAnmDDlM9VutW7cuN74ZFxeH6dOnC+1z+/ZtREZGCh8fwzxoVJXxRQciOkVEdcp8v1kZ44vzbHzBMAzz4GDUbwUGBpbTb6ktEipiEW90A5QkCe3bt8euXbssrrlbFvE7d+7ECy+8gObNmyM0NFSxuN9aaLEllLj2meq3OnfujNTUVFXFZkBAAL7++muhNWlpaWY7Ups3b0br1q2h0+kQGRlZ7jpS071xc3MTHn+Mjo5GYmIirl27hpEjR0KSJHh7e1vUbwElAbpqLOJFf6Z169ahVq1aaN68OeLi4hQbX1SVRXxGRgYGDRoESZLg5+eHEydOyOOPIixfvly2vWeYh5mqKrLOEdFlIjr2z3/zTR6b9I+r4C9E1FHJ63GRxTAMc39h1G9NmTIFkyZNwt69e7Fo0SLh0OKcnBzVGqmy3avz58+jT58+kCQJvXv3LqXfAko6UhUx5FCKsdg0GAyYN2+erN9atGiR1Y6bGkOOiIgIzJo1S/HzT506hU6dOqFmzZoYMGAALl26pHhtVVjE6/V6zJw5U9ZvrVy5EitWrBAOYlZrEW8utPjYsWOyG+DQoUORlZVV6nG1ocVqLOK1Wi0KCgoQGxsLe3t7uLu7Izk52eqau2ERf+jQIbRp0wY1atTA6NGjhYrboKAgoWNjmAcVDiNmGIZhKkRhYSE2bdqE9u3bY/LkyULjgqGhoRZDiy1x4cIFsxopU7777jt06NABkiQhKCgIf//9d4VDi5WydOnSchbxf/31FyZOnAhJktChQ4dy+i21hhxqO1JbtmzB1q1b0bZtW+h0OoSHh1vUbwHAgQMHqtwi/vr16xg9ejRq1qyJtm3b4tChQ4rXWgsttoQSi/j169fDw8MD9vb2iImJQUFBQYVDi5ViziI+KysLQ4cOhSRJ8PHxKfeaajVSajpSxtDilStXws3NDQ4ODlb1W0BJF1DkpgDDPMhwkcUwDMNUGkb9VlBQEObNm4cbN25YfX5VW8QbDAYsWLAAb731Fl544QUsWLBA8X5VZRF/9uxZ9OrVS3YDvHDhgqrQYrUW8WULH71ej9mzZ8PBwQEuLi5YunRpufeoc+fOd9Ui/sSJE/Dz84MkSeXcAM2hRiM1aNAgxRbxBQUFiI+Px9tvv40XXngBSUlJivepyPijNf3j4cOH4e3tDTs7O4wYMQLXrl1DTEwM4uPjhfZRaxFf9u9GXl4eoqKiZP3W5s2by62ZOXMmMjMzhfdimAcRLrIYhmGYKuH8+fOIi4tDUFAQkpOTkZ+fX+pxtRopNR9YO3bsiMOHDyvWbwHKQ4tNEe1Ibd++He3atcNzzz2H4OBg3L59W/FaS6HF1ti/f7/VjtQff/yBsWPHyvqt/fv3V0posVLMWcRv3LhR1m9FRUWV0m8B6kKLAXXjj15eXti9ezeGDx8u67cOHz5sdc3q1asVhRabIur+uGbNGri5uaFGjRpyx00paizibYUWX7lyBQMHDpT1W8YCnUcFmUcJLrIYhmGYKqW4uBgHDx5EWFgYJk+ejNTUVBQXF6Nv3753VSNlyrlz59C7d29otVr06dMH58+fL7dOjUZKrUV8mzZtMHfuXDg6OsLZ2RmLFy+22XFTU/h07twZP//8s6Lnnjp1Ct27d8e///1vNG7cGJcvX1a8j1qNlLWOlF6vR2JiYin9lsFgwMCBA7Fp0yahfdRaxJd9z48ePVpKv3X16tVy69SEFkdHR6vqSLm6uiImJgb29vbw8PDA+vXrba5TU2yKWMQfPHgQXbp0QcuWLTF//nzhvRjmQYWLLIZhGOauUVBQgI0bNyI4OBhNmjTBr7/+KrRerUW8tdDiXbt2oX379pAkCcHBwcjJyalwaLEIAwYMKGURf+vWLXz00UeQJAmdOnXC3r17y61JTU0VDi1W25FycXHB6tWrZf1WREREuW5SWSIjI4W1NyIdKaN+S5IkPP/881bdAM1hKbTYGrZCi9etWwd3d3fY29sjNjYWBQUFyMvLg06nE9oHKLmORDVSQ4cOLVVUZWZmYsiQIZAkCb6+vmY1YWpCiwF1hVlkZKRQp5ZhHnS4yGIYhmHuCab6rc8++8ymfkttkeDs7KwotNio33JyckLDhg3Ro0cPIb2YpdBiW1j7wHrmzJlS+q2LFy8CKDHkEA0t/uqrr+TQYqWU7Ujp9XrMmjVL7iYtW7bM7HukptgcOHCgWR2PNQ4dOgR3d3ch/ZZarZ0tjZSRgoICxMXFwcHBAa+++iref/99oX0shRbbwtrPdOjQIXh5eUGSJIwaNUr+OdSGFotaxBcVFSEkJERoDcM86HCRxTAMw9xzbOm3AGDRokWYOHGi0Ouq7UhptVoEBgZCkiR07NixnBugOZSEFpclNTVVcWjxtm3b0K5dO0iShAYNGlh1AzSHi4uLsEbKmkX8zZs3MXbsWGi1Wlm/BZSEFqsx5FCrkTI15Ni4cSM8PDyg0+kQHR1ttuO2cuVKVRbxalz77OzsZDdApQWNWot4JR0pg8GA1atXw83NDfb29nj55ZeFi2F3d3dhi/gdO3Zgx44dQmsY5kGHiyyGYRjmvqG4uBhpaWmYMmUKJk+ejH379qG4uBhAxUKLRShryHH27Fn4+/tDkiT07dvXrH4LUFckdO7cWdgifsmSJXBxcZH1W0uWLLHZccvNzVWlkVJqEX/y5El069YNWq0Wr7/+OpYsWSK0T1paWqVaxBcWFiIhIUHuuK1evVp+j9SEFkdFRSEhIUFoTdnQYqNZhCRJGD58uMVC5W5ZxK9YsQLvvfcedDodPDw8FDktqrWIDwkJQVFRkfA6hnmQ4SKLYRiGuS8pKCjAhg0bEBQUhOjoaNXaFlGLeGuhxTt37pT1W6GhocjJyQFQYsihtCNlpCIaKaMhx61btzB+/HhZv5Wammp2TXh4OD755BOhfS5evKjKta9x48Zo3bo1JElCZGSkTf0WYDu02BwrV65UZBF//fp1jBw5UnZMfOedd4T2AdSNP1rrSK1du1bWb8XFxcn6q0OHDqkKLVY7/njt2jUAJXq4QYMGyW6AlvRqoqHFAHD79m1ERkYKHx/DPOhwkcUwDMPc99y8eRMzZ85EUFAQ5s+fr6gTodYiXskHVoPBgM8++wxOTk5wdnZG06ZNcfr0aaF9lixZgnHjxgmtsdaROnXqFHr27AlJkjBgwABcunRJfkytIceWLVuE1hw4cEA25NDr9Zg5c6bcTVq+fLnZgvduWsSPHDkSzZo1gyRJGDx4MLKysmyuqUqL+IKCAsTGxsLe3h7u7u549913cfz4caF9zIUWK9nXUkeqrH7LVCupJrR42bJlwj8TwzwMcJHFMAzDPFD89ttvmD59OoKCgpCSkmJWvwWIhRYbUWMR/+eff6JevXqQJAkdOnRQpN8C1FnEh4WFKQot3rp1q+wGOHbs2EoJm1WCp6enWUOOGzduYMyYMZAkCV26dMGhQ4fkxyoSWiyKabG5YcMGtG7dGvb29lazpURCi42osYjPzMxEnTp1IEkSfHx8FI//KTXkMEVJaLHBYMDKlSvh5uYGBwcHREZGwtXVVWgfAAgMDBRewzAPA1xkMQzDMA8kxcXFOHDgACZPnoxJkyZh//79sn4LUFckdOrUCb/88ovQGtPQYlP9Vr9+/XDhwgWza9QacijVSBnR6/Vo1aoVmjVrBhcXFyxdulTR+OT+/furzCL+xIkTshugMbC2MkKLbWGpI1VQUID4+HjY29vDzc0Na9asKfW4mi6bWov4kSNHAiixVlei31JbbIp2pPLy8vDuu+/Ko6BKXSAzMjKEzxPDPCxwkcUwDMM88BQUFGD9+vUICgpCbGwsVqxYUSmhxUpwdnY225Havn277AZoqt8CKhZaLIqxSLh16xbGjRsHnU5Xyg3QHJ07dxa2iF+2bJmwRfy6detQs2ZN6HQ6TJ06VZF+C6g6i/js7GyMGDECWq0W3t7e+PLLL4U1UmrHHy11pJKSkmQ3wPj4+FLFUXR0tLAhR0Ut4jMyMuTi2M/Pz6qWbubMmcjMzBTei2EeBrjIYhiGYR4qbt68icjISIwYMQLz58/HH3/8oWjd4sWLMWHCBKG9lHSkDAYD5s2bJ+u3Fi9eDK1WK1wk9O/fH998843QGkuhxadOnUL37t1l/dbly5dLHa+aYlONRsoYWqzX65GYmCjrt1auXGmx41aVGilTjh49ihdffBFvvfUWhg4dqki/BQCrVq2qEov4goICxMTEyPqtlJQUVcXm0KFDkZKSIrTGUmixUb+l1WoxZsyYcuc/KChIaB+GeZjgIothGIZ5aDl37hxiY2MRGBiI9evXWx2RUmMRP2XKFCGL+L/++guDBg3C888/j44dO2Lv3r2K16q1iLfVkdqyZYus34qIiMDChQuFDTkqQyNl5Pr16xg9erRZ/RagLrT44MGDwhop02IzOTlZdgOMjY21eh2psYgX7UhlZWXB398fNWvWFNJvAeot4q1lfBn1W66urnBwcMDMmTNx+PBhLF++XHgvhnlY4CKLYRiGeegpLi7Gvn37MHnyZEyePBkHDhwopd9Sq5FSaxG/bds2nD17Fr169YJWq7Wq3wLUW8SLfKDW6/WYPXs2atasCXt7eyxbtkzxzxYREaHIkMMUJaHFpvqtQYMGISMjQ7UhhxqL+LIdqYKCAsTFxcndpHXr1pV6vDKLTVsYLeLT09Ph7e0NrVaLESNGWDXBSE9Pr3KL+Ly8PERGRqJx48a4ffu28F4M87DARRbDMAzzSJGfn4+UlBQEBQVh+vTp+O233yoltFgp5vQ627Ztk/VbkydPRm5ubqnHO3XqJBxavHTpUlUW8Y6Ojrh58ybGjh0rZ0tZ028B6oqEgIAAIYv4jRs34t1330WtWrUQHR2tWL9lMBhgZ2cndGyA7fHH7OxsDBs2DJIkoWvXrjh69CiioqKQmJgotE9GRkaFNFKmrFmzBm5ubtDpdEhISCh3TtSEFquxiC8qKkJISIjQGoZ52OAii2EYhnlkuXHjBj777DPY29vjs88+U6zfAtRbxFvrSBkMBsydOxeOjo5wdnbGkiVLUFRUVKmGHNYIDw8v15Ey1W8FBASU0m8B6g051HakfvrpJyQkJMDBwQFubm5YvXp1qa5kWe6GRfyRI0fQtWtX1KhRA0OGDLHoBmiOqrCIz8vLkwO8PTw85FDkioYWK2X79u3YsWOH8F4M8zDBRRbDMAzDAPj1119l/daGDRtsWlyrtYhX2pG6desWxo8fj9deew2NGjVCamqq4n2shRZbw1ZHasuWLWjTpo2s38rLy8OAAQOwdetWoX1MQ4uVYs617/r16xg1ahR0Oh28vb2Rnp5ebp0aQ46pU6eqtohfu3atrN+aPn16lVxHIhbxGRkZGDRoEP7973/jlVdeEQoGthZabI3g4GAUFRUJr2OYhwlLRVY1YhiGYZhHiP/85z8UHBxM06dPp9q1a9PUqVMpLCyMDh48WHL30YTU1FR69dVXhV6/uLiYbty4QY0bN1b0/Jo1a1JiYiK9/PLLtG7dOpozZw7pdDoaMGAAXbp0yera6dOnk7+/v9DxXbp0iZ599lmqXr26xed06tSJduzYQXv37qWaNWtSmzZtaP369fTHH39QcXGx4r2mTZtGkZGRQse3atUq0ul0pb5Xu3ZtmjNnDh04cICio6MpNjaWdDodDRkyhK5evUr5+fmk1+upVq1aQntt3bqVRo0aJbQmLCyMPvzwQ+rWrRt999139P333xMAcnNzIw8PD0pOTi63Jj09nRo2bCi0T3FxMV29epXeeustRc9v0KABLVy4kBo1akQLFy6kyZMnkyRJNHr0aLpx44bVtYmJieTj4yN0fLdv36annnqKHnvsMaF1DPPIYK7yulf/cSeLYRiGuRfk5+cjOTlZ1m+dP38eANCxY0dhjdTixYvx0UcfCa0xZ8jxzTffoG3btpAkCVOmTCmn3wLUaaSMhhwi7Nu3D15eXhgzZgwkSYKnpyfS0tKsrlGbI+Xi4qK4I7Vhwwa0bt0aL730Etq3by8UvFsVFvFZWVml9FvHjh0DoD60eNSoUUJryo4/GgwGrFq1Cm5ubnBwcEBiYqLZ60U0tBgAvvrqK+GfiWEeRshCJ8vybSyGYRiGeUR44oknyNfXl3x9fenmzZu0du1aunDhAl24cIFefPFFodf68ssvafPmzUJrYmNjqVevXqW+16FDB+rQoQMVFRXRZ599Ru3ataNq1arRwIEDqW/fvnTlyhX617/+ZbUjZY4zZ85Q+/bthdbExMRQQkICNWnShIiIfv75Z4qIiKBLly5Rs2bNaOrUqeU6NStXriQHBwehffLz86moqEhxR8rb25u8vb1Jp9ORh4cHubu70+OPP07Dhw+nHj16WF0bFhZGY8eOFTo+Wx2pevXq0WeffUZEREeOHKGIiAjKzMykCxcuUN26dYX2mj9/Pq1du1ZoTWJiIvn6+spfV6tWjXr16kW9evWi/Px8SkhIIGdnZ3rmmWdozJgx5OXlRVevXqUnn3ySHn/8caG9fv75Z+rbt6/QGoZ5pDBXed2r/7iTxTAMw9xPnD17FjExMQgKCsLGjRtt3u1Xq5GSJElRR+rWrVsYN24ctFotGjRoIJS5BJSEFle2RfzmzZvRunVr6HQ6REZGym6AajRSERERmDVrltCay5cvl+pIXb9+HSNGjIAkSfD29sbhw4fNrlOrkVJjEd+uXTtZvxUfH2/zOlISWmwOpZ3NjIwMDBw4EJIk4ZVXXhF+z69cuSK8hmEeVog7WQzDMAwjxhtvvEEhISEEgPbv309RUVGk0WjI09OT7OzsSKPRlHp+bGws9enTR2iPixcvUo0aNRR1pGrWrEkzZswgIqIWLVrQwYMHSZIkatq0KUVFRdnU/cTGxlJiYqLQ8S1fvtxqR8rT05M8PT2pqKiI5syZQx4eHvTYY49RdnY21axZU2ivbdu20d69e4XWhIWF0bhx4+Sva9euTXPnziUiouPHj1NkZCRlZGRQixYtKCIigurVq0cHDx6kl19+WWgfo0aqWbNmQus+//xzSk5Oplq1alFhYSElJiaSm5sbPfXUUzRq1CizWqjExETq1q2b0D5ZWVn09NNPK7qOGjRoQIsWLSIiorfffpt27dpFK1euJEmSKCIiwmYnMSkpqVznlWGYMpirvO7Vf9zJYhiGYe538vPzsW7dOgQFBSEuLg6///67/JgkSapCi9VYxPfq1Uv+esuWLbJ+Kzw83Kx+SzS02IiLi4uwRXxQUBAcHR1l/dahQ4dsrlESWmwOpT9TSkoKPDw8oNPp8MYbb+Do0aNC+6xYsaJSLeKzsrIwdOhQSJIEHx+fUrlW9vb2qkOLRTANLTYYDFi5ciVcXV3h4OCAmTNnWjyGwMBAoX0Y5mGGLHSyNCjjpHQvadWqFX788cd7fRgMwzAMo4ibN29SUlISXbx4kerUqUPbtm2jHTt2CL2GTqejtLQ0oTWdO3emGTNmlHMwLCoqorlz51JSUhJVr16dBg8eTL1796Zq1arRV199RT/99JNQJ+vOnTvUrl07Sk1NFTo+e3t72rt3L1WvXp1OnjxJERERdOXKFXrrrbdo6tSp1KBBg3JrAgICqHv37tSpUyfF+6SlpVFiYqKQdqmgoID+85//UKNGjeiJJ56gESNGKOoaubm5UUpKipCDYXR0ND399NM0fvx4q887fPgwRUVFUVZWFjVt2pR+++03+uGHHxTvQ6TuOuratStNnTqVmjdvXur7+fn5FB8fT9988w0988wzNG7cOOrcuTMREf3000/0888/U+/evYX2YpiHFY1GcxhAq3Lf5yKLYRiGYSrO8ePHKTk5mQoLC8nBwYE6dOhA//d//2d1TWpqKs2dO5dWrVqleJ/i4mJycHCw+YH6jz/+oKioKDpw4ADVrl2brly5Qt9//73QCF9ERAS98MILNHr0aMVrLl26RAMHDjRbbG7atIlmz55Nubm51LlzZ5owYQI9+eSTREQkSRIdPHhQ8T5ERF26dKHp06cLjfCtWLGC0tPTadasWXTt2jWKiIigI0eOUP369WnKlCn07rvvlluTn59PrVu3pn379gkdn4ODA/3www9C5iQeHh50/fp1+te//kV+fn704Ycf2lyfnp5OcXFxtG7dOsX7ACB7e3ub19GVK1coIiKCTp48SS+//DLVrl2bEhMT6emnn1a8F8M8zFgqsliTxTAMwzCVQPPmzal58+YEgPbt20dTp06latWqkaenJ7Vq1aqcfouoxLVv5syZQvssW7aMHB0dbT6vVq1a8msfOXKE2rZtSx06dKCmTZuadQM0x7fffiuskQoPD7fYufHy8iIvLy8qKiqi2bNnU+vWren//u//yN3dXZVG6vr166o0UuvXryciorp169K8efOIiOjYsWMUGRlJmZmZ9O6771JkZKTsCBgfH0/du3cX2iczM1OxRsqUO3fu0IkTJyg/P58SExPJ2dmZnn76aRozZgx5e3ubXRMdHU3Tpk0T2icpKYnee+89m89r2LChrN/av38/JSQkcIHFMArgThbDMAzDVBH5+fm0ZcsWSk9PpxdeeIF69OhBr7zyChEp70iVxdXVlTZu3CjUkQoLC6O6devSqFGjaOvWrTRz5ky6ffs2dejQgYKCguRukimXLl2iQYMG0fbt24WOT7QjdePGDXr33XepVq1a9Morr9CUKVOoVatyN4XLsXz5cjp8+LBQkaq0I5WcnExz586lvLw88vb2pvXr19O+ffuECqZBgwZR165dydPTU/EaSx2pq1evUlhYGB0/fpxeeuklCg8Pl0f8iouLyd7eXrgL6O7uTmvXrqXatWsrXvPtt99S9erVqXXr1kJ7MczDDHeyGIZhGOYu8+STT5Kfnx/5+fnRjRs3aO3atXTx4kX6z3/+Q3l5eeTs7Cz0enfu3CGDwSDs2rdjxw65I9WpUyfq1KmTrN9q06aNrN/y9/enatWqEVFJYfbRRx8J7bNv3z65iFRKrVq1qH79+nTw4EE6ceKErN965513aOrUqVSvXj2z6xYtWkQpKSlCe8XFxSnqSBnPWWFhIYWFhdHZs2epXbt2NHLkSPLz81O018mTJ+UOkFKioqIoJiam3Pfr1atHn3/+ORER/fjjjxQWFkZXr14lOzs7euutt0ir1Qrtk5+fTwUFBUIFFhHR999/T9HR0UJrGOZRpdq9PgCGYRiGeRSoXbs2DR8+nKZPn04uLi50/PhxKioqoq+//pr0er2i15g+fbqw4cClS5fMhhZXr16dPvzwQ0pNTaWUlBQ6dOgQOTg4UJcuXejgwYOqQotjY2MpMjJSaM2KFStki/i3336bkpOT6eDBg9S5c2fq06cP2dvbU0xMDBUWFspr8vLySK/XC5lQEJVYxI8aNUrx8x9//HG6ceMGrVixglatWkU7d+4knU5HPj4+dOzYMYvrbIUWm6O4uJiys7Pprbfesvq8Vq1a0YYNG2j//v3k5OREISEhsgFIUVGRor0SExMVF4tGbt++TU8//TQ99thjQusY5lGFxwUZhmEY5h5RXFxM+/bto2+//ZYee+wxq/otohLXvn379sndJiUEBARQr169FBdMP//8Mw0fPpxOnTolu8+ZcwM097OoHX9cv369xYKpsLCQPvnkE1q/fj098cQT8rHVqlWLxowZo3ifK1euUEBAQKW4Px45coSmTp1KWVlZ5fRbRETe3t4UExMjpBdbtWoVHThwgGbPnq14jXH8cdeuXZSYmEhbtmyR9VteXl4W15m6Pyrlq6++ovfee09YA8cwDzuWxgW5k8UwDMMw94hq1aqRs7MzRUdHU0hICF24cIFCQkLo448/posXL5Z67sWLF+m5554TKrCIiE6fPi3UkWrWrBk999xztG/fPuratSv169eP7O3taerUqZSfn29xna3QYnPcuXOHioqKrHakHn/8cZo4cSLt37+f1q5dS3v27KGZM2fSrl276MiRI4r3KhtarARLocXvvvsubdiwgQ4ePEitW7emXr16kYODA8XHx1NBQQFlZ2cLFyMLFiygiIgIoTUJCQnk5+dHTz75JE2aNIn2799PX331FW3evJl0Oh35+fnRyZMnS61Ra8jx888/c4HFMCKYC8+6V/9xGDHDMAzDANeuXcOnn36KwMBALFq0CH/++WelhBYrwWAwQKvVlvqeXq/HzJkz4eDgAFdXV6xcubJc6LKzs7NwaHF4eDg++eQToTUXL15E69atcezYMfj4+ECSJAwdOhRZWVlW16kJYvb09MTJkycVPbegoAAxMTH497//jfr162PdunWK97EWWmwNnU5nNbT40KFD8PT0hJ2dHUaPHo2bN29i0KBBwqHFly9fFj5PDPOoQBbCiLmTxTAMwzD3GXXq1KGRI0dSXFwcOTo60qeffkrHjx+nwsJCxfotohKNlGh3ZNmyZeTk5FTqe9WrV6exY8fSvn37KCUlhdLS0sjR0ZG8vLwoPT1dtSHHt99+SyNGjBBaEx4eTh999BG988478rG0b99e1m/FxsaW0m8RER04cIAaNWoktE9xcTFdu3ZNcffm8ccfp5CQEGrYsCHt2rWLduzYQZIkka+vLx0/ftzq2o8//lhYI5WZmUnPPPOM1Y6UnZ0dbd68mdLS0sje3p58fX1p7dq19NtvvynWbxGV2L336NFD6PgY5lGH3QUZhmEY5j6mSZMmNGnSJAoJCaG9e/dSREQEVa9enbp06ULvvfeeRf1WcXEx3bx5kxo3biy03+LFi2njxo0WH69VqxZ98sknRFTioBcREUEHDhygl156iTIzMxXpt4hKDDmeffZZ4bG106dPU8eOHUt9z8fHh3x8fGT9lru7Oz3++OM0cuRI6tatG02bNo3i4+OF9lm1apXw+GN+fj7p9Xp68803af78+UT0PzfArKwsatWqFUVGRpZz9du6dauqPDKlmrRq1aqRv78//ec//6Fp06ZRbm4uOTs70zPPPEMffvghdenSxeJaAJSdnW3R5ZFhGPOw8QXDMAzDPGDk5eXR5s2b6ciRI1S7dm3q0aNHuU7N0qVL6fjx45SYmKj4de/cuUPt2rWj1NRUoePR6XQUEhJCc+bMoTt37lCnTp1owoQJZvO3jAQEBFCPHj3KFUzWOHDgAM2cOZOSkpJsPvfatWsUERFBhw8fpnPnztGOHTvo3XffVbyXm5sbpaSkCDkYTp06lZ577jkaO3as2ceTkpLos88+o4KCAvL19aUPP/yQrl+/Tv369aOdO3cq3odIPI+MqCQMOiYmRnYwzMjIoPDwcDp58iQ1bNiQIiMjy3Xujh07RqdPnyZ/f3+hvRjmUcGS8QUXWQzDMAzzAHP9+nVKSkqiS5cuUZMmTcjPz4+ee+65CocWK+XixYs0aNAg2bWvqKiIZs+eTcnJyfR///d/NHToUOrZs2c5ww5zrn228PT0pI8//pjefPNNxWuWL19OX3/9NRUWFlJmZia1bNmynBtgWZSGFpdFqWtfYWEhJSYm0ubNm+n333+n/v370/Tp0xXvk56eTtOnT6fk5GTFa4qLi0mn09GhQ4fMPn7w4EGKjo6ma9eukU6no/DwcKpVqxZFRkbSxIkT6emnn1a8F8M8SnAYMcMwDMM8hBj1W0REZ86coTlz5lBOTg79+eef9Mwzzwi91vbt24W7WGFhYTRhwgT56+rVq9P48eNp/PjxdOPGDYqMjKRZs2ZRvXr1aPLkyWRnZ6cqtLi4uJhu3LghVGAR/S+02NiRSk5Opl69elF+fj55eXnR+PHj6fHHHy+1Ji4uTliDlJGRYVMjZcSo3woJCaFWrVrRH3/8QTqdjl566SUKDw+n5s2bW10/depUio2NFTq+NWvWkE6ns/i4JEm0efNmKi4uplWrVpGvry/p9Xp6++23ucBiGBVwkcUwDMMwDwlG/VZxcTG1a9dO1m95eXnRu+++a1G/RfQ/i3hRjdQvv/xi0SK+du3aNGfOHCIiOnHiBEVERNCVK1foypUrtHLlSqF9Kssi3s/Pj/z8/KiwsJBmzZpFbm5u9OSTT9LIkSNl84lt27YJa6TCwsIsjglaIj09nV599VX6/PPPieh/+q2rV6+SnZ0dhYeHl9NvGQ05bIUWl+Xzzz9X1PmqVq0a9enTh/r06UNff/01hw8zjEp4XJBhGIZhHmLy8vJo06ZNdOTIEapTpw717NnTbPZT//79qXfv3kKZWqmpqfTpp5/S6tWrFa8pLi6mxo0bU6NGjejOnTvk6elJEyZMoCeeeMLqOjXjjxEREfTCCy/Q6NGjrT7PqN86cuQIPf/883Tr1i3hUUY1449dunSh6dOnl9NBFRcX09q1a2n+/PlUUFBAfn5+9OGHH1L16tVp5cqVlJaWpiq0WHT8MSQkhKZNmyaczcYwjxI8LsgwDMMwjyBPPfUU9ezZk3r27EnXrl2jpKQkunLlCjVu3FjWbxGVjBqKFFhEJRbxM2bMEFqzbNky6tKlC82YMYP0ej3Nnj2bPDw86PHHH6dhw4ZRjx49ynXcKmIRr6QjVbduXZo3bx4REXXt2pWISoomJfotIqK0tDSzhas1rFnEV6tWTT5n+fn5lJiYSC4uLvT0009TRkaG8EinMbRYhJycHHrmmWe4wGIYlXAni2EYhmEeQU6fPk3JycmUm5tLtWvXpvT0dOGOlIODg3D3xsXFhTZt2lSuYLp+/TpFRkbSjz/+SC+++CJNmTKFWrUquTmstCNlyqVLl2jgwIGyIYdSTDtS69ato3nz5lF+fj517dqVxo4dW06/RWS5I2WNFStW0KFDh2Q7fCWcP3+edDodvf7669SwYUOKiIhQNDao1JDDlKVLl5KdnR01bdpU8RqGeRThThbDMAzDMDJvvvkmTZ48mYqLi2njxo109epVioiIIG9vb2rRooVV/RZRSUfK0dFRaM87d+5QcXGx2Y5UnTp16NNPPyUiop9++okiIyMpIyODWrRoQenp6RZd8SwRHh5O48ePF1pTNrS4W7du1K1bNyosLKQZM2aY1W+JhhYbWbhwIaWkpAitWb58OYWEhNC4ceMoPT2dJk2aRNnZ2WRnZycXomVRElpsjtOnT1P//v2F1jAM8z+4k8UwDMMwDBH9T7919OhRWb/VsGFDs8+11JGyhhqL+AULFlBISAj997//JW9vb/roo4/MdpPKUlUW8cZi9OjRo/TSSy9RixYt6I8//qBZs2Yp3qcyLeJN9VuFhYXk5+dHY8aMkZ8zaNAg6tq1K3l6eire58qVK7R+/XqhziHDPKpwJ4thGIZhGKuY6reys7MpKSmJMjIy5Pytf/3rX0RkvSNljR07dgi79h04cIBWrVpF7u7u9Mknn5Cbmxs98cQTNHz4cIs262U7UkooLi6m69ev27SIr1evHs2fP5+IiI4cOULt2rWjV155hUaMGEERERE29VtERPHx8dS9e3eh47ty5YrZjlRZ/VZCQgI5OzvTM888Q2PGjKGTJ0/SokWLhPZKSkqi999/X2gNwzCl4U4WwzAMwzBWOXXqFKWkpFBubi65urrS3r17qUGDBnI+lxIuXrxIgwcPpu3btwvtba4jZXQDPHz4MNWvX5/CwsLo3XfflR/v0qULxcfHC2VqLVu2jI4cOUIzZ85UvMa0I7V27VqaN28eFRQUkI+PD3344YcWO246nY5SU1OFRvg++OAD8vX1VdyRyszMpMGDB9PBgwfJzc2NIiMjFY00AqDg4GCKi4tTfGwM8yjDnSyGYRiGYVTRtGlTatq0KRUXF9OePXvo5MmT9Nhjj9HRo0cV6beISkYFP/roI6F99+3bR6+++mq575u6AR47doymTp1KmZmZ1KJFCwoPD1fUkSrLokWLaP369UJrTEOLu3fvTt27d6fCwkJKTEwkNzc3euqpp2j06NGyYyFRSUfq2WefFdZI/fzzz7R48WLFz2/QoAFVq1aN9uzZQ3fu3KHQ0FC6evUq6XQ6Cg8PL5UdZsqxY8eoZcuWQsfGMEx5uJPFMAzDMIwwd+7coU2bNtGxY8eobt261LNnT3rppZcsPl+SJDp48KDQHp6enpSYmEiNGzdW9Pz169dTSEgI/fnnnzR27FgaP368Iv3WnTt3qG3btpWikTLl6tWrFB4eTj/99BM1aNCAIiIiaNasWUIdKSKigwcPUkJCAq1du1bxmuLiYrK3ty/1nhcXF9Pq1avp888/J71eT927d6dRo0aVOv7IyEgKDAykp556SvFeDPMoY6mTxeEHDMMwDMMI8/TTT1OvXr1o+vTp1KdPH0pJSaHg4GBaunQp5eTklHpuamoqvf7660KvX1xcTDdu3FBcYBER+fj40IsvvkjHjx+natWqkbu7O3l4eFBycrLVdfHx8dSrVy+h41PSkapXrx4tWLCA0tLSKDQ0lMLCwig5OZm++eYbunHjhuK9oqOjKSIiQuj4Vq1aRTqdrtT3qlWrRr1796bvv/+edu3aRX///Tc5OztTmzZt6Ouvv6aioiIqLCzkAothKgHuZDEMwzAMU2mY6rfc3NyodevW5O3tTTNmzBAqmJYuXUrHjx+nxMRExWvMdaSuXbtG4eHhdPToUapfvz6Fh4dTixYtSq1TkyMVEBBA3bt3p06dOilec+DAAZoxYwZ169aN5s+fTwUFBeTn50cffvihxb3NdaSU4ObmRikpKRbHAk25cuUKhYWFUVpaGs2YMYM6dOggtBfDPMqwJothGIZhmCqnrH4rPDycLl++THl5eQRAkX6LiGjx4sW0ceNGob3j4uLKdaTq1q1Ln332GRGV6I0iIyMpKyuLWrZsSZGRkZSfn69KI3Xq1CmhAouIaNq0aRQXF0fNmjWT3QATExPJxcWFnnrqKRozZgx5e3uXWmOuI2WL/Px80uv1igosIqKGDRvS4sWLKSQkhNq1aye0F8Mw5uFxQYZhGIZhKh3juN60adMoLS2NTp8+TcHBwTRjxgzKyMiwuvbOnTtkMBiELeK3b99Ow4cPt/h4ixYtaP369ZSWlkZt2rQhf39/srOzo/r161NhYaHifQ4cOECvvPKK0LEZLeJNHf6efPJJmjRpEu3fv5+WLVtGX3/9Nel0OurWrRudPHmSiEpCi8PDw4X2UmMRn5OTQ8888wxVq8YfDRmmMuBOFsMwDMMwVcrTTz9N/v7+5O/vT1evXqWkpCTKzMykpk2bkq+vLz377LOlnj99+nRhjdSlS5foX//6l+KOlJ+fH/n5+ZFWq6WmTZuSm5sbPfnkkzRy5Ejy8/OzunbatGn08ccfCx3fypUrycHBweLjDRo0oIULFxIRUXp6Ok2aNImysrLo8uXLQvsQEW3bto1++OEHoTXJyck2f26GYZTDmiyGYRiGYe4JP//8M6WkpNCdO3fIzc2N2rRpQ4899pgqjdSAAQPI39+f2rdvr3jNvn376JNPPqGkpCQiIsrOzqaIiAg6evQoNWjQgMLCwsrpt9RqpFxdXWn9+vWKR/iIiCIiIujXX3+lzMxMKiwsJD8/PxozZozV9+XKlSs0YMAA2rlzp9DxBQcH0/Tp04XWMAzDmiyGYRiGYe4zmjVrRs2aNSODwUDff/89TZkyhYqLi6l69erCGqkzZ84IFVhERLGxsZSQkCB//eKLL8r6rSNHjsj6rXfffZciIiKobt26tHz5cqsdKXPcuXOHioqKhAosIqJvv/1WLjbz8/MpISGBXFxc6Omnn6YPP/yQunTpUm5NWFgYjRs3TmifK1euWLXfZxhGHO5kMQzDMAxz35CTk0Pr1q2jM2fOUL169ahnz57UoEEDq2tSU1Pp008/pdWrVyvep7i4mBwcHCgtLc3mc9etW0fz5s2j/Px8yszMpIMHD9KLL76oeK+IiAh64YUXaPTo0YrXXLlyhQICAmjHjh3lHsvMzKSwsDA6efIkNWzYkCIjI2Wtl06nU/QzmTJjxgx6//33qW7dukLrGIbhThbDMAzDMA8A//rXvyggIICIiLKysigpKYmysrKoWbNm5OPjU06/RVSi4RKxeicioY5Ut27dqFu3bvTnn39S8+bNycfHh5566ikaNWoU+fj42Fxv7EiJYK0j1aBBA1q0aBERlei3QkND6erVq/TKK69QvXr1hPYBQNeuXeMCi2EqGe5kMQzDMAxz33PixAlav3495efnyyHDjz32mFBHyhRXV1fauHGjkINhWFgY1alTh0aPHk1Xr16V9VsvvfQSRUREUPPmzcutuXTpEg0cONBsR8oakiQJ6b6Ki4vpvffeo8cff5yqV69O3bt3p1GjRtkcuzxy5Aj9+uuv1LNnT6HjYximBO5kMQzDMAzzwPL222/T22+/TQaDgXbv3k1TpkyhJ598koiIHB0dhV7LqJFSYxGfmppKRET16tWj+fPnExHRjz/+SGFhYZSVlUWtWrWiyMhIql27NhERhYeH0/jx44X2UWMRT0T0xBNPUFpaGuXn51N8fDw5OzvTM888Q2PHjiVPT0+zazZt2kRBQUHCezEMYx0OQ2AYhmEY5oHhscceozZt2lBMTAx99NFH8vjgzJkzKTMzU9FrVLZFfKtWrWjDhg108OBBcnV1pe7du5O9vT0lJCTQqVOnqGPHjkJ7TZs2jSIiIoTWrFq1iuzt7YmoJH8rLCyMDhw4QEuWLKENGzaQTqej7t27088//yyvKSoqIr1eT0899ZTQXgzD2IbHBRmGYRiGeeDJysqiNWvWUFZWFr399tvk4+NDzzzzjNnn6nQ6Sk1NFbaI79mzp+KCKT8/n0aNGkUbN26k5s2b05gxY8jb29vmOrUW8W5ubpSSkmLVwfDgwYMUHR1N165dI51ORzqdjurXr09ubm5CezEM8z94XJBhGIZhmIeW+vXr09ixY4moRL81Y8YMysvLIw8PD3J3d6fHHnuMiIguXrwoFFps5MyZM0IdqSeffJKuXr1Ke/fupRo1alB4eDjFxsbK+q23337b7DpbocXmyM/PJ71eb9MiXpIk2rx5MxUXF9OqVasoPj6eDh8+LLQXwzDK4CKLYRiGYZiHClP91nfffSfrt3x8fCghIYEmTJgg9Hr79u2jV199VWhNcXEx3bhxg5o0aUJERJ9//jkRlbgBTp48ma5evUparZbCw8Nl/RYR0aJFiyglJUVor7i4OOrRo4fi51erVo26dOlCFy5coGrVWDnCMFUBF1kMwzAMwzyUPPbYY9S2bVtq27Yt5ebm0vr16ykjI4POnDlDzZs3p/r16yt6nZiYGJoxY4bQ3pYs4u3s7Gjjxo1UXFxMSUlJ1L17dyosLCRfX18aMmSIqtDibdu2CVvEJycnk5+fn9AahmGUw7cvGIZhGIZ56HnmmWfo/fffp507d1L37t1pzZo1FBwcTCtWrKDc3FyL64wdqcaNGwvt98UXX1BYWJjFx6tVq0a9evWi3bt3065duygvL4+aNGlCWVlZtGnTJsX7XLlyhZ599lnh8cdffvlF7rIxDFP5cJHFMAzDMMwjRYMGDWjs2LE0ffp0evvttykxMZFCQ0Np165dZDAYSj132bJl5OTkJPT6d+7cIYPBoNgi/sknn6TJkydTo0aNaPfu3bRp0yaSJIn8/Pzo5MmTVtdaCy22xKVLl6hhw4ZCaxiGEYPHBRmGYRiGeWRp3rw5NW/evJR+66mnniIfHx966623aPHixbRx40ah14yPjxcO97106RI9++yz1KhRI1q0aBERlei3Jk2aRFevXiVJkigiIqLcKOGpU6eoU6dOQnslJSVRv379hNYwDCMGF1kMwzAMwzzymOq3bt++TevXr6fly5fTH3/8Qfn5+UKv9e233wprpMyFFpvqt9asWUO+vr6k1+upe/fuNGrUKEpPT6dGjRoJ7QOArl27RnXr1hVaxzCMGFxkMQzDMAzDmPDss89S3759iYho9OjRtGrVKrp69Sq988471LVrV3r66actrjV2pEQ1UqdPn7ZoEV+tWjXy9/cnf39/ys/Pp/j4eHJ2dqZff/2Vpk6dKrTPkSNHqFWrcpE+DMNUMhxGzDAMwzAMo4CffvqJNm7cSPn5+dSmTRtyc3MrZ4E+YMAA8vf3p/bt2yt+3f3799OsWbMoKSlJ8Zri4mJ677336L333qOTJ0/Syy+/TBEREdSsWTOr6yIiIigoKIieeuopxXsxDGMZDiNmGIZhGIapAO+88w698847ZDAYaNeuXTR58mR66qmnyNfXVy5uzpw5I1RgEZVYxCcmJgqtWblyJbm5udHMmTOJiOjgwYMUHBxM165dI51OR+Hh4eX0W3q9nvR6PRdYDHMX4E4WwzAMwzCMSm7fvk0pKSl06tQpKi4upnPnzgmFCRcXF5ODgwOlpaUJ7evq6krr168vV0gVFxfTqlWraOHChaTX66lHjx40cuRIql69Om3ZsoWeffZZcnV1FdqLYRjLWOpkcZHFMAzDMAxTCRgLrD/++IPeeecd8vb2tqrfIiL66quv6NixY0Jhx3fu3KF27dpRamqq1ecZ9VvffPMNPfvss1SnTh1avnx5uRFHhmHUw0UWwzAMwzDMXQCArN8qKCiwqN8iKulIbdy4UXGmFlGJruqFF16g0aNHK15z+vRpmjt3Ln366aeK1zAMYxvWZDEMwzAMw9wFNBoNtWjRglq0aEFFRUW0a9cumjRpEj399NPk5+dHTZs2JSLx0GIjaiziDxw4QKNGjRJawzCMerjIYhiGYRiGqSKqV69O7du3p/bt21NOTg6lpKTQ0qVL6aWXXqLz589Tr169hF5PrUX82bNn6YMPPhBawzCMengol2EYhmEY5i7wr3/9i/r3709xcXHk6+tLGo2GLly4QKtXr6a8vDxFr2EutNgWly5dopdfflnNITMMoxLuZDEMwzAMw9xlGjZsSDNnziQAdOzYMYqPj6eCggJq27Ytubq6WjSnsBZabImkpCTq379/ZRw2wzAK4SKLYRiGYRjmHqHRaKhly5bUsmVLKioqoh07dtCkSZPomWeeIT8/P3rzzTfl5+7bt49effVVodcHQNevX6c6depU8pEzDGMNLrIYhmEYhmHuA6pXr04dO3akjh070t9//y3rtxo2bEg9evSg2NhY4dDiw4cP03vvvVdFR8wwjCW4yGIYhmEYhrnPeO6552jAgAFERHT58mVatmwZ/fHHH3T06FFq1KgRPfXUU4peZ/PmzRQcHFyFR8owjDnY+IJhGIZhGOY+5uWXX6aPPvqI9u3bR//9738pLi6OJk2aRN9//z0VFxdbXKfX66moqEhxQcYwTOXBYcQMwzAMwzAPGEb91p49e+jZZ5+lbt26UZMmTUo9Z8uWLfSvf/2LXFxc7tFRMszDj6UwYi6yGIZhGIZhHmD+/vtvSk5Opl9++UXWb9WtW5eCg4MpJibGolMhwzAVx1KRxZoshmEYhmGYB5jnnnuOAgICiOh/+q3r169TzZo1ucBimHvEfdXJ0mg0OUT0y70+DuaeUZuIbtzrg2DuCXzuH1343D+68Ll/tOHz/+jysJ37VwCUy0i43zpZv5hrtzGPBhqN5kc+/48mfO4fXfjcP7rwuX+04fP/6PKonHvuITMMwzAMwzAMw1QiXGQxDMMwDMMwDMNUIvdbkfX5vT4A5p7C5//Rhc/9owuf+0cXPvePNnz+H10eiXN/XxlfMAzDMAzDMAzDPOjcb50shmEYhmEYhmGYBxoushiGYRiGYRiGYSqR+6bI0mg0HTQazS8ajeacRqMJvtfHw1QdGo3mZY1Gs1uj0ZzWaDQ/azSaD//5fi2NRrNDo9H8+s//n7/Xx8pUDRqN5jGNRnNUo9F8/c/XfO4fATQaTU2NRrNOo9Gc+efvvz2f+0cHjUYz7p/f+Sc1Gs0qjUbzJJ//hxONRrNYo9Fc02g0J02+Z/FcazSakH8+//2i0Wja35ujZioDC+f+439+7x/XaDTrNRpNTZPHHtpzf18UWRqN5jEimktEHYmoKRH5azSapvf2qJgqpIiIPgLwJhHpiGjkP+c7mIh2AXiDiHb98zXzcPIhEZ02+ZrP/aPBJ0S0DUATInqHSq4BPvePABqN5iUiGkNErQC8RUSPEVEv4vP/sLKEiDqU+Z7Zc/3Pv/+9iKjZP2vm/fO5kHkwWULlz/0OInoLQHMiOktEIUQP/7m/L4osItIS0TkA5wEUEtFqIvK+x8fEVBEAsgAc+efPOVTyQeslKjnnS/952lIi6npPDpCpUjQaTUMi6kxEi0y+zef+IUej0TxHRC5E9AUREYBCAH8Sn/tHiepE9JRGo6lORE8TUSbx+X8oAfADEf1R5tuWzrU3Ea0GUADgdyI6RyWfC5kHEHPnHsB2AEX/fJlGRA3/+fNDfe7vlyLrJSK6bPL1lX++xzzkaDSaV4moJREdJKIXAWQRlRRiRFT3Hh4aU3XMIqJAIio2+R6f+4ef14noOhF9+c+o6CKNRvMM8bl/JACQQUQJRHSJiLKI6C8A24nP/6OEpXPNnwEfLT4gom/++fNDfe7vlyJLY+Z77C3/kKPRaJ4lomQiGgvg73t9PEzVo9FoPInoGoDD9/pYmLtOdSJ6l4g+A9CSiHKJR8MeGf7R33gT0WtE1ICIntFoNO/f26Ni7hP4M+AjgkajmUQlkpEVxm+ZedpDc+7vlyLrChG9bPJ1QyoZI2AeUjQazf9RSYG1AkDKP9/O1mg09f95vD4RXbtXx8dUGY5E5KXRaC5QyViwh0ajWU587h8FrhDRFQAH//l6HZUUXXzuHw3aENHvAK4D0BNRChE5EJ//RwlL55o/Az4CaDSa/kTkSUR98L+Q3of63N8vRVY6Eb2h0Whe02g0j1OJCG7TPT4mporQaDQaKtFlnAYww+ShTUTU/58/9yeijXf72JiqBUAIgIYAXqWSv+ffAXif+Nw/9AC4SkSXNRpN43++1ZqIThGf+0eFS0Sk02g0T//zb0BrKtHj8vl/dLB0rjcRUS+NRvOERqN5jYjeIKJD9+D4mCpCo9F0IKIgIvICcMfkoYf63Gv+V0zeWzQaTScq0Wo8RkSLAUy7t0fEVBUajcaJiPYS0Qn6ny4nlEp0WUlE1IhK/kHuDqCscJZ5SNBoNG5ENAGAp0ajeYH43D/0aDSaFlRiePI4EZ0nogAqudnH5/4RQKPRRBJRTyoZFzpKRIOI6Fni8//QodFoVhGRGxHVJqJsIgonog1k4Vz/M0b2AZVcG2MBfFP+VZkHAQvnPoSIniCim/88LQ3AsH+e/9Ce+/umyGIYhmEYhmEYhnkYuF/GBRmGYRiGYRiGYR4KuMhiGIZhGIZhGIapRLjIYhiGYRiGYRiGqUS4yGIYhmEYhmEYhqlEuMhiGIZhGIZhGIapRLjIYhiGYRiGYRiGqUS4yGIYhmEYhmEYhqlE/h+20No2SYmQvwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -356,7 +355,7 @@ "metadata": {}, "outputs": [], "source": [ - "mu = flopy.modflow.Modflow(model_ws=gridgen_ws, modelname='mfusg')\n", + "mu = flopy.modflowusg.ModflowUsg(model_ws=gridgen_ws, modelname='mfusg')\n", "disu = g.get_disu(mu)\n", "disu.write_file()\n", "# print(disu)" @@ -379,10 +378,10 @@ "output_type": "stream", "text": [ "('nodenumber', 'polyid', 'totalarea', 'SHAPEID')\n", - "[( 322, 0, 0.961169 , 0) ( 382, 0, 0.961169 , 0) ( 325, 0, 0.961169 , 0)\n", - " ... (3275, 0, 0.834025 , 0) (3276, 0, 0.0454391, 0)\n", - " (3278, 0, 0.567496 , 0)]\n", - "[ 322 382 325 ... 3275 3276 3278]\n" + "[(1403, 0, 0.961169 , 0) (1398, 0, 0.961169 , 0) ( 346, 0, 0.961169 , 0)\n", + " ... (6009, 0, 0.0977309, 0) (6005, 0, 0.78625 , 0)\n", + " (6008, 0, 0.697909 , 0)]\n", + "[1403 1398 346 ... 6009 6005 6008]\n" ] } ], @@ -403,9 +402,9 @@ "output_type": "stream", "text": [ "('nodenumber', 'pointid', 'SHAPEID')\n", - "[(5396, 0, 0) (1490, 1, 1) (3133, 2, 2) (2358, 3, 3) ( 582, 4, 4)\n", - " (2198, 6, 6) (1739, 7, 7) (1049, 8, 8) (3955, 9, 9)]\n", - "[5396 1490 3133 2358 582 2198 1739 1049 3955]\n" + "[(3706, 0, 0) (3899, 1, 1) (2912, 2, 2) (2619, 4, 4) ( 580, 5, 5)\n", + " (4953, 6, 6) (1614, 8, 8) ( 189, 9, 9)]\n", + "[3706 3899 2912 2619 580 4953 1614 189]\n" ] } ], @@ -451,7 +450,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 18, @@ -460,7 +459,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -533,7 +532,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 20, @@ -542,7 +541,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -621,7 +620,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 23, @@ -630,7 +629,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -747,7 +746,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAADHCAYAAADbAB3QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAATvUlEQVR4nO3dUYhc93XH8d+plJ1ETkPstg7OyMZrMG6DoE26tG5cirETcF0T9yEPDnUw2xS9NBMlTQkrShkKDsxDCfJDKQjHGVMH58ExjTEhiXFjQiE13XXcVrbiOs2mshQpciitQykzMjl92Blp7nh3duZ/z9w79873A0aavXPP/9zd+Zm//nP3P+buAgAAQH6/UHYDAAAAdcHECgAAIAgTKwAAgCBMrAAAAIIwsQIAAAjCxAoAACDIvhMrM3vEzC6a2amRr11jZs+Y2auDP6+eb5vA4iATQBaZAK6YZsWqK+musa9tSHrW3W+W9OzgMbAsuiITwKiuyAQgSbJpNgg1sxslPe3uRwaPX5F0u7ufN7PrJD3n7rfMtVNggZAJIItMADtS77F6j7ufl6TBn9fGtQRUEpkAssgEltLBeQ9gZkclHZWkQ4cO/ea116Zlq9/vS5JWVlaSe8lbow491OEaImpcunRJ586d+6m7/0pyE4nIxGL1UIdriKhBJmJqlH0+PcTVSM1E6sTqJ2Z23cgS78W9nujuJyWdlKTV1VXf3t5OGrDT6UiSNjbS36bPW6MOPdThGiJqdLtdra+v/2dyA29FJiraQx2uIaIGmYipUfb59BBXIzUTqW8FPiXpgcHfH5D0tcQ6QF2QCSCLTGApTbPdwuOSvivpFjM7a2afkNSR9GEze1XShwePgaVAJoAsMgFcse9bge7+sT0O3RncC1AJZALIIhPAFey8DgAAEISJFQAAQBAmVgAAAEGYWAEAAARhYgUAABCEiRUAAEAQJlYAAABBmFgBAAAEYWIFAAAQhIkVAABAEHP3wgZrNpvearWSzu31epKkRqORPH7eGnXooQ7XEFGj3++r3W5vuftachMByET5PdThGiJqkImYGmWfTw9xNVIzwYoVAABAkH0/hDnSysqKNjY2ks7tdHY+GD31/IgadeihDtcQUaPb7SaPHYlMlN9DHa4hogaZiKlR9vn0EFcjNROsWAEAAARhYgUAABCEiRUAAEAQJlYAAABBmFgBAAAEYWIFAAAQhIkVAABAECZWAAAAQZhYAQAABGFiBQAAEISJFQAAQJBcEysz+4yZvWRmp8zscTN7e1RjQBWRCSCLTGDZJE+szKwp6VOS1tz9iKQDku6LagyoGjIBZJEJLKO8bwUelPQOMzso6ZCkH+dvCag0MgFkkQksFXP39JPNjkn6vKT/k/Qtd/+jSc9vNpvearWSxur1epKkRqORdH5EjTr0UIdriKjR7/fVbre33H0tuYldkInq9VCHa4ioQSZiapR9Pj3E1UjNRJ63Aq+WdK+kVUnvlXSVmd2/y/OOmtmmmW3mmcQBi45MAFlkAsvoYI5zPyRp291flyQze1LSByU9Nvokdz8p6aQkra6u+sbGRtJgnU5HkpR6fkSNOvRQh2uIqNHtdpPHnoBMVLCHOlxDRA0yEVOj7PPpIa5Gaiby3GN1RtKtZnbIzEzSnZJO56gHVB2ZALLIBJZO8sTK3Z+X9ISkFyT926DWyaC+gMohE0AWmcAyyvNWoNy9Lakd1AtQeWQCyCITWDbsvA4AABCEiRUAAEAQJlYAAABBmFgBAAAEYWIFAAAQhIkVAABAECZWAAAAQZhYAQAABGFiBQAAEISJFQAAQBBz98IGazab3mq1ks7t9XqSpEajkTx+3hp16KEO1xBRo9/vq91ub7n7WnITAchE+T3U4RoiapCJmBpln08PcTVSM8GKVaBer3f5B1lWjUXoAYi0CJkAgGnl+hDmWa2srGhjYyPp3E6nI0nJ50fU2O/8aernrTHv41E1JlmEn2W3200eO1LdMxFRo+zj06jC93E/ZCKmRtnn00NcjdRMsGIFAAAQhIkVAABAECZWAAAAQZhYAQAABGFiBQAAEKTQ3wqsg16vd/k3DXY7JmnP49M8p+zj09bIs7cIMC5PriKO83oGEIUVq5Ltt8fOvI8DAIA4rFjNqNFohO4RVfbjlOuYtNoFpMiTq6jjABCBFSsAAIAgrFiVYPR+kvH7P4p4zP0kAADMBytWAAAAQXKtWJnZuyU9LOmIJJf0x+7+3YC+am30fpKy7rHCfJAJIItMYNnkfSvwIUnfcPePmtmKpEMBPQFVRiaALDKBpWLunnai2bsk/Yukm3zKIs1m01utVtJ4w3uF8twflLfGfudPU3/8OWU/ntd1TrIIP8t+v692u73l7mvJTYwhE/Ppoezj06jC93E/ZCKmRtnn00NcjdRM5LnH6iZJr0v6kpl9z8weNrOrxp9kZkfNbNPMNlMncVU1aQ+p8WNFP562T8yETIxJeW0t4t5uZCQZmZiDvK9HXs/zlWfFak3SP0m6zd2fN7OHJL3h7n+51zmrq6u+vb2dNN40+y/Nu8as++Xs9vxOp1P6C3p8z6BZ97qa9/exiBrdblfr6+vR/zonEwn1y97LLXJvNzKRRSbmc35Re7tV+fsYUSM1E3lWrM5KOuvuzw8ePyHpAznqAVVHJoAsMoGlk3zzurtfMLPXzOwWd39F0p2SXo5rrZom7VE1+rUyjX8uG3tdxSAT6djbrZ7IBJZR3t8KbEn68uA3PX4oaT1/S0ClkQkgi0xgqeSaWLn7i5LC3o+vg0l7VA2/Vvaq1bT3WGF2ZCINe7vVF5nAsmHndQAAgCB8VmAJuJ8DAIB6YmI1o/Ebv8ePSXvfJDv6tbLtd/P6+HNGcbMvRs2SiWmeU/bjlOsgE4g0KVPD49Lk12Pe47ye0/FWIAAAQBBWrGY0fuP3qGXbIBSQZsvENM8p+3HKdZAJRJqUKam4DUKRhhUrAACAIKxYBWODUGB2bBAKoC5YsQIAAAjCilUwNggFZscGoQDqghUrAACAIObuhQ3WbDa91WolnTtc5clzL0TeGvudP358t+eXvVo1tFtPk/oeNe/vYxE1+v2+2u32lruX+lEby5aJaZ5T9uN5Xecki/CzJBMxNYo4P+/rcd6v54gai9BDaiZYsQIAAAhS6D1WKysrE/fmmGSavWbmXWPWvUGqfo9Vnr2JJlmEn2W3200eO9KyZWKa55T9eF7XOcki/CzJREyNIs4vah+rKn8fI2qkZoIVKwAAgCD8VmAw9rECZsc+VgDqghUrAACAIKxYBWMfK2B27GMFoC5YsQIAAAjCitWMxu9PGj8m7X0vx+jXyjTNPVajj3c7n3tSMDRLJqZ5TtmPU66DTCDSpEwNj0uTX495j/N6TseKFQAAQBBWrGY0fn/SqGXbxwqQZsvENM8p+3HKdZAJRJqUKam4fayQhhUrAACAIKxYBWMfK2B27GMFoC5YsQIAAAiSe8XKzA5I2pR0zt3vyd9StbGPFcjE7NjHqt7IBJZJxIrVMUmnA+oAdUEmgCwygaVh7p5+stlhSY9K+rykP9vvXyLNZtNbrVbSWMNVnjz3QuStsd/548d3e37Zq1VDu/U0qe9R8/4+FlGj3++r3W5vuftachO7IBOz19/v9Vf043ld5ySL8LMkEzE1ijg/7+tx3q/niBqL0ENqJvKuWJ2Q9DlJP9/rCWZ21Mw2zWwzzySuihqNxp4/0PFjRT+etk/M7ITIxGUpr639zpn38ahzcNkJkYlQeV+PvJ7nK/keKzO7R9JFd98ys9v3ep67n5R0UpJWV1d90t4ck0yz18y8a+TdG2S355T9eF7XOcki/Cy73W7y2HshE/Ppoezj06jC93E/ZCKmRtnn00NcjdRM5Fmxuk3SR8zsR5K+IukOM3ssRz2g6sgEkEUmsHSSV6zc/bik45I0+JfIn7v7/TFt1Rt79tQTmQCyyASWEftYAQAABAnZed3dn5P0XEStZcCePfVHJoAsMoFlwYoVAABAED4rcEbjn7M3fkyavCpUxj1Vkx6nXAf3aSFanlxFHOf1DCAKE6uS7fc/9HkfBwAAcZhYzWj8c/ZGFbFHVBF79kxbA4iSJ1dRxwEgAvdYAQAABGFiBQAAEISJFQAAQBAmVgAAAEGYWAEAAARhYgUAABDE3L2wwZrNprdaraRzh5v85dmXKW+N/c6fpn7eGvM+HlVjkkX4Wfb7fbXb7S13X0tuIkDdMxFRo+zj06jC93E/ZCKmRtnn00NcjdRMsI9VoIjNOPPWWIQegEiLkAkAmFahE6uVlZWJG1NOMs3GlvOuUYce6nANETW63W7y2JHIRPk91OEaImqQiZgaZZ9PD3E1UjPBPVYAAABBmFgBAAAEYWIFAAAQhIkVAABAECZWAAAAQZhYAQAABGFiBQAAEISJFQAAQBAmVgAAAEGYWAEAAARJnliZ2fVm9m0zO21mL5nZscjGgKohE0AWmcAyyvNZgW9K+qy7v2Bmvyhpy8yecfeXg3oDqoZMAFlkAksnecXK3c+7+wuDv/9M0mlJzajGgKohE0AWmcAyMnfPX8TsRknfkXTE3d/Y63nNZtNbrVbSGL1eT5LUaDSSzo+oUYce6nANETX6/b7a7faWu68lNzEBmahOD3W4hogaZCKmRtnn00NcjdRM5L553czeKemrkj69W1jM7KiZbZrZZsQkDlh0ZALIIhNYJrlWrMzsbZKelvRNd//Cfs9fXV317e3tpLE6nY4kaWNjI+n8iBp16KEO1xBRo9vtan19Pfxf52Siej3U4RoiapCJmBpln08PcTVSM5HntwJN0hclnZ4mLEDdkQkgi0xgGeV5K/A2SR+XdIeZvTj47+6gvoAqIhNAFpnA0knebsHd/1GSBfYCVBqZALLIBJYRO68DAAAEYWIFAAAQhIkVAABAECZWAAAAQZhYAQAABGFiBQAAEISJFQAAQBAmVgAAAEGYWAEAAARhYgUAABDE3L2wwZrNprdaraRze72eJKnRaCSPn7dGHXqowzVE1Oj3+2q32zN/ank0MlF+D3W4hogaZCKmRtnn00NcjdRMsGIFAAAQJPlDmFOsrKxoY2Mj6dxOpyNJyedH1KhDD3W4hoga3W43eexIZKL8HupwDRE1yERMjbLPp4e4GqmZYMUKAAAgCBMrAACAIEysAAAAgjCxAgAACMLECgAAIAgTKwAAgCBMrAAAAIIwsQIAAAjCxAoAACAIEysAAIAgTKwAAACC5JpYmdldZvaKmf3AzNI/0AeoCTIBZJEJLJvkiZWZHZD0N5J+X9L7JH3MzN4X1RhQNWQCyCITWEZ5Vqx+S9IP3P2H7t6X9BVJ98a0BVQSmQCyyASWjrl72olmH5V0l7v/yeDxxyX9trt/cq9zDh8+7A8++GDSeGfOnJEk3XDDDUnnR9SoQw91uIaIGhcuXNDx48e33H0tuYkxZKKaPdThGiJqkImYGmWfTw9xNVIzcTBptB22y9feMkszs6OSjg4e9tbX10/lGDPCL0v66ZL3UPb4i9LDLcH1yER1eyh7/EXpgUzsKPtnUfb49HDFzJnIM7E6K+n6kceHJf14/EnuflLSSUkys83Ifw2loIfyx1+kHoJLkomK9lD2+IvUQ3BJMlHB8ekh28Os5+S5x+qfJd1sZqtmtiLpPklP5agHVB2ZALLIBJZO8oqVu79pZp+U9E1JByQ94u4vhXUGVAyZALLIBJZRnrcC5e5fl/T1GU45mWe8IPRQ/vhSTXsgE8nK7qHs8aWa9kAmKjm+RA9DM/eQ/FuBAAAAyOIjbQAAAIIUMrEq+yMNzOx6M/u2mZ02s5fM7FjRPYz0csDMvmdmT5c0/rvN7Akz+/7g+/E7JfTwmcHP4ZSZPW5mby9gzEfM7KKZnRr52jVm9oyZvTr48+p59zEyNpm40guZIBNkItsLmahwJuY+sbLF+EiDNyV91t1/TdKtkv60hB6Gjkk6XdLYkvSQpG+4+69K+vWiezGzpqRPSVpz9yPauaH1vgKG7kq6a+xrG5KedfebJT07eDx3ZOItyASZIBNZZKLCmShixar0jzRw9/Pu/sLg7z/TzoukWWQPkmRmhyX9gaSHix57MP67JP2epC9Kkrv33f2/S2jloKR3mNlBSYe0y7420dz9O5L+a+zL90p6dPD3RyX94bz7GCATA2TiMjJBJiSRiRGVzUQRE6umpNdGHp9VCS/WITO7UdL7JT1fwvAnJH1O0s9LGFuSbpL0uqQvDZaZHzazq4pswN3PSfprSWcknZf0P+7+rSJ7GPEedz8/6Ou8pGsLGpdMXHFCZIJMkIlRJ0QmKp2JIiZWU32kQRHM7J2Svirp0+7+RsFj3yPportvFTnumIOSPiDpb939/ZL+VwUt9Q8N3p++V9KqpPdKusrM7i+yhwVAJkQmhsiEJDIxHJtMqPqZKGJiNdVHGsybmb1NO2H5srs/WfT4km6T9BEz+5F2lrnvMLPHCu7hrKSz7j78V9gT2glQkT4kadvdX3f3S5KelPTBgnsY+omZXSdJgz8vFjQumdhBJnaQCTIxRCZ2VDoTRUysSv9IAzMz7bxffNrdv1Dk2EPuftzdD7v7jdr5HvyDuxc6A3f3C5JeM7Phh0reKenlInvQztLurWZ2aPBzuVPl3aT5lKQHBn9/QNLXChqXTIhMjCATZEISmRhR7Uy4+9z/k3S3pH+X9B+S/qKIMcfG/13tLCv/q6QXB//dXXQfI/3cLunpksb+DUmbg+/F30u6uoQe/krS9yWdkvR3khoFjPm4dt6rv6Sdf5F9QtIvaee3PF4d/HlNgd8DMpHth0yQCTKR7YdMVDQT7LwOAAAQhJ3XAQAAgjCxAgAACMLECgAAIAgTKwAAgCBMrAAAAIIwsQIAAAjCxAoAACAIEysAAIAg/w/JWg9+ggrt5QAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -821,7 +820,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -895,25 +894,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "FloPy is using the following executable to run the model: /Users/jdhughes/.local/bin/mfusg\n", + "FloPy is using the following executable to run the model: C:\\Users\\chris\\.local\\bin\\mfusg.EXE\n", "\n", " MODFLOW-USG \n", " U.S. GEOLOGICAL SURVEY MODULAR FINITE-DIFFERENCE GROUNDWATER FLOW MODEL\n", " Version 1.5.00 02/27/2019 \n", "\n", " Using NAME file: mymodel.nam \n", - " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/08/16 14:51:29\n", + " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:50:48\n", "\n", " Solving: Stress period: 1 Time step: 1 Groundwater Flow Eqn.\n", - " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/08/16 14:51:29\n", - " Elapsed run time: 0.019 Seconds\n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:50:48\n", + " Elapsed run time: 0.002 Seconds\n", "\n", " Normal termination of simulation\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -938,14 +937,14 @@ "gridprops = g.get_gridprops_disu5()\n", "\n", "# create the mfusg modoel\n", - "m = flopy.modflow.Modflow(modelname=name, model_ws=ws,\n", + "m = flopy.modflowusg.ModflowUsg(modelname=name, model_ws=ws,\n", " version='mfusg', exe_name='mfusg',\n", " structured=False)\n", - "disu = flopy.modflow.ModflowDisU(m, **gridprops)\n", + "disu = flopy.modflowusg.ModflowUsgDisU(m, **gridprops)\n", "bas = flopy.modflow.ModflowBas(m)\n", - "lpf = flopy.modflow.ModflowLpf(m)\n", + "lpf = flopy.modflowusg.ModflowUsgLpf(m)\n", "chd = flopy.modflow.ModflowChd(m, stress_period_data=chdspd)\n", - "sms = flopy.modflow.ModflowSms(m)\n", + "sms = flopy.modflowusg.ModflowUsgSms(m)\n", "oc = flopy.modflow.ModflowOc(m)\n", "m.write_input()\n", "m.run_model()\n", @@ -999,7 +998,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.11" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb b/examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb index d36e85f951..6b2a47466b 100644 --- a/examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb +++ b/examples/Notebooks/flopy3_mfusg_conduit_examples.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "id": "1c06d1db-0156-4a25-a1b0-4e0f2f08a2cf", "metadata": {}, "source": [ "# FloPy\n", @@ -13,7 +12,6 @@ { "cell_type": "code", "execution_count": 1, - "id": "2a47ab0b-115d-453e-a02c-53575fb125b2", "metadata": {}, "outputs": [], "source": [ @@ -27,7 +25,6 @@ { "cell_type": "code", "execution_count": 2, - "id": "7b3c55ef-88bc-40a5-9854-56b1aaac0489", "metadata": {}, "outputs": [], "source": [ @@ -39,7 +36,6 @@ }, { "cell_type": "markdown", - "id": "2f98f702-e94c-4a59-9380-971d4884da10", "metadata": {}, "source": [ "## Loading Example 03_conduit_confined\n", @@ -53,7 +49,6 @@ { "cell_type": "code", "execution_count": 3, - "id": "f2fe115d-e9bb-40cb-8cbb-3ff2b6533597", "metadata": {}, "outputs": [ { @@ -117,26 +112,26 @@ "loading CLN package file...\n", "\n", " ncln 1\n", - " iclnnds -1\n", - " iclncb 35\n", - " iclnhd -36\n", - " iclndd 0\n", - " iclnib 0\n", - " nclngwc 2\n", - " TRANSIENT False\n", - " PRINTIAJA False\n", - " RECTANGULAR 0\n", - " BHEDETAIL False\n", - " SAVECLNCON 0\n", - " SAVECLNMAS 0\n", - " GRAVITY None\n", - " VISCOSITY None\n", - " nndcln \n", - " node_prop [[1.0, 1.0, 0.0, 10.0, -110.0, 1.57, 0.0, 0.0], [2.0, 1.0, 0.0, 10.0, -130.0, 1.57, 0.0, 0.0]]\n", - " cln_gwc [[1.0, 1.0, 50.0, 50.0, 0.0, 0.0, 10.0, 1.0, 0.0], [2.0, 2.0, 50.0, 50.0, 0.0, 0.0, 10.0, 1.0, 0.0]]\n", - " cln_circ [[1.0, 0.5, 32300000000.0]]\n", - " ibound \n", - " strt \n", + " iclnnds -1\n", + " iclncb 35\n", + " iclnhd 36\n", + " iclndd 0\n", + " iclnib 0\n", + " nclngwc 2\n", + " TRANSIENT False\n", + " PRINTIAJA False\n", + " RECTANGULAR 0\n", + " BHEDETAIL False\n", + " SAVECLNCON 0\n", + " SAVECLNMAS 0\n", + " GRAVITY None\n", + " VISCOSITY None\n", + " Reading nndcln...\n", + " Reading node_prop...\n", + " Reading cln_gwc...\n", + " Reading cln_circ...\n", + " Reading ibound...\n", + " Reading strt...\n", "Adding ex3.clncbb (unit=35) to the output list.\n", "Adding ex3.clnhds (unit=36) to the output list.\n", "adding Package: CLN\n", @@ -211,7 +206,6 @@ { "cell_type": "code", "execution_count": 4, - "id": "c3e92a46-eb24-4870-921c-bf64b3ca4ce5", "metadata": {}, "outputs": [ { @@ -238,7 +232,6 @@ { "cell_type": "code", "execution_count": 5, - "id": "30aa9aac-02fa-4a45-800c-bf0a017f8e1e", "metadata": {}, "outputs": [ { @@ -258,13 +251,12 @@ " shutil.rmtree(model_ws)\n", "os.mkdir(model_ws)\n", "\n", - "mf.model_ws=model_ws" + "mf.model_ws=model_ws\n" ] }, { "cell_type": "code", "execution_count": 6, - "id": "2323f160-60fa-40b4-9f6a-000ec07f93de", "metadata": {}, "outputs": [ { @@ -281,14 +273,14 @@ " Package: SMS\n", " Package: OC\n", " \n", - "FloPy is using the following executable to run the model: C:\\GWV8\\mfusg.exe\n", + "FloPy is using the following executable to run the model: C:\\Users\\chris\\.local\\bin\\mfusg.exe\n", "\n", " MODFLOW-USG \n", " U.S. GEOLOGICAL SURVEY MODULAR FINITE-DIFFERENCE GROUNDWATER FLOW MODEL\n", " Version 1.5.00 02/27/2019 \n", "\n", " Using NAME file: ex3.nam \n", - " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/09/24 15:28:53\n", + " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:49:44\n", "\n", " Solving: Stress period: 1 Time step: 1 Groundwater Flow Eqn.\n", " Solving: Stress period: 1 Time step: 2 Groundwater Flow Eqn.\n", @@ -350,8 +342,8 @@ " Solving: Stress period: 1 Time step: 58 Groundwater Flow Eqn.\n", " Solving: Stress period: 1 Time step: 59 Groundwater Flow Eqn.\n", " Solving: Stress period: 1 Time step: 60 Groundwater Flow Eqn.\n", - " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/09/24 15:28:55\n", - " Elapsed run time: 1.691 Seconds\n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:49:46\n", + " Elapsed run time: 1.672 Seconds\n", "\n", " Normal termination of simulation\n" ] @@ -375,7 +367,6 @@ { "cell_type": "code", "execution_count": 7, - "id": "81563f65-41b0-4782-9c3b-30b9bd4710c0", "metadata": {}, "outputs": [], "source": [ @@ -386,7 +377,6 @@ { "cell_type": "code", "execution_count": 8, - "id": "a8a32799-e7e0-43bf-9f24-72019c67369b", "metadata": {}, "outputs": [], "source": [ @@ -405,13 +395,12 @@ { "cell_type": "code", "execution_count": 9, - "id": "6559a5f4-c369-4aa4-8865-93bdeed1aad4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -420,7 +409,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -445,7 +434,6 @@ { "cell_type": "code", "execution_count": 10, - "id": "85043c1e-1bab-4f73-9a9f-edd9d49e9d99", "metadata": {}, "outputs": [], "source": [ @@ -463,13 +451,12 @@ { "cell_type": "code", "execution_count": 11, - "id": "5c6c4cb5-292f-457a-8563-6b7a8689176c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -478,7 +465,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -507,7 +494,6 @@ }, { "cell_type": "markdown", - "id": "3073a5aa-1433-4b70-9bd9-6922ce34507d", "metadata": {}, "source": [ "## Create example 03A_conduit_unconfined of mfusg 1.5\n", @@ -517,7 +503,6 @@ { "cell_type": "code", "execution_count": 12, - "id": "4e43acef-6d51-4973-888a-de963a4feff9", "metadata": {}, "outputs": [], "source": [ @@ -535,7 +520,6 @@ { "cell_type": "code", "execution_count": 13, - "id": "6864b760-e157-4d3e-9504-0540313c908c", "metadata": {}, "outputs": [ { @@ -586,7 +570,6 @@ { "cell_type": "code", "execution_count": 14, - "id": "d2a3a309-844b-45b5-a0ad-dea10624236d", "metadata": {}, "outputs": [ { @@ -611,7 +594,6 @@ { "cell_type": "code", "execution_count": 15, - "id": "cad2ba26-ddd9-4a99-97ea-08a579e93636", "metadata": {}, "outputs": [ { @@ -643,7 +625,6 @@ { "cell_type": "code", "execution_count": 16, - "id": "05a22b48-e03c-49df-8fc7-45d1ed3fe410", "metadata": {}, "outputs": [ { @@ -666,7 +647,6 @@ { "cell_type": "code", "execution_count": 17, - "id": "42fd068e-6be9-4211-954b-cbb36173e8f0", "metadata": {}, "outputs": [ { @@ -688,7 +668,6 @@ { "cell_type": "code", "execution_count": 18, - "id": "69b1de37-5897-4c83-88b0-a23c4dd3d66a", "metadata": {}, "outputs": [ { @@ -705,14 +684,14 @@ " Package: CLN\n", " Package: WEL\n", " \n", - "FloPy is using the following executable to run the model: C:\\GWV8\\mfusg.exe\n", + "FloPy is using the following executable to run the model: C:\\Users\\chris\\.local\\bin\\mfusg.exe\n", "\n", " MODFLOW-USG \n", " U.S. GEOLOGICAL SURVEY MODULAR FINITE-DIFFERENCE GROUNDWATER FLOW MODEL\n", " Version 1.5.00 02/27/2019 \n", "\n", " Using NAME file: ex03a.nam \n", - " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/09/24 15:28:58\n", + " Run start date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:49:47\n", "\n", " Solving: Stress period: 1 Time step: 1 Groundwater Flow Eqn.\n", " Solving: Stress period: 1 Time step: 2 Groundwater Flow Eqn.\n", @@ -874,8 +853,8 @@ " Solving: Stress period: 1 Time step: 158 Groundwater Flow Eqn.\n", " Solving: Stress period: 1 Time step: 159 Groundwater Flow Eqn.\n", " Solving: Stress period: 1 Time step: 160 Groundwater Flow Eqn.\n", - " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/09/24 15:29:10\n", - " Elapsed run time: 11.728 Seconds\n", + " Run end date and time (yyyy/mm/dd hh:mm:ss): 2021/10/05 17:49:58\n", + " Elapsed run time: 10.911 Seconds\n", "\n", " Normal termination of simulation\n" ] @@ -899,7 +878,6 @@ { "cell_type": "code", "execution_count": 19, - "id": "c034a566-0e3b-4038-a5f8-8c54db08e438", "metadata": {}, "outputs": [], "source": [ @@ -920,13 +898,12 @@ { "cell_type": "code", "execution_count": 20, - "id": "768fc2d3-06de-4693-b786-73f2ffe6387b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 20, @@ -935,7 +912,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -960,7 +937,6 @@ { "cell_type": "code", "execution_count": 21, - "id": "c13acff3-492d-4ad2-bc3c-7f42639b7fa6", "metadata": {}, "outputs": [], "source": [ @@ -977,7 +953,6 @@ }, { "cell_type": "markdown", - "id": "de189309-199c-4bc4-a664-4eb2a9d23b76", "metadata": {}, "source": [ "## Modify CLN amd WEL package to example create 03B_conduit_unconfined of mfusg 1.5\n", @@ -987,7 +962,6 @@ { "cell_type": "code", "execution_count": 22, - "id": "6c95a97c-3785-4ae0-be9c-ef4ccb75cc08", "metadata": {}, "outputs": [ { @@ -1017,7 +991,6 @@ { "cell_type": "code", "execution_count": 23, - "id": "3d3e7f0d-b31b-48f3-8ddb-8e6459a3b9f3", "metadata": {}, "outputs": [ { @@ -1045,7 +1018,6 @@ { "cell_type": "code", "execution_count": 24, - "id": "04b6301d-4599-4859-8aa7-d83121a016ee", "metadata": {}, "outputs": [ { @@ -1073,7 +1045,6 @@ { "cell_type": "code", "execution_count": 25, - "id": "a7042045-95f7-4205-abe1-579cf7c3bb8f", "metadata": {}, "outputs": [ { @@ -1111,7 +1082,6 @@ { "cell_type": "code", "execution_count": 26, - "id": "70192070-20db-4c2d-a252-5c6d9b96df0d", "metadata": {}, "outputs": [], "source": [ @@ -1132,7 +1102,6 @@ { "cell_type": "code", "execution_count": 27, - "id": "28751490-a504-4afb-ab12-afd692b2299d", "metadata": {}, "outputs": [ { @@ -1147,7 +1116,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1170,7 +1139,6 @@ { "cell_type": "code", "execution_count": 28, - "id": "486e8682-3f8d-4f80-a2ba-80f9bd793059", "metadata": {}, "outputs": [], "source": [ @@ -1187,7 +1155,6 @@ }, { "cell_type": "markdown", - "id": "2d84dd82-252d-428c-8e7c-21e77e4e16f3", "metadata": {}, "source": [ "## Modify CLN amd WEL package to example create 03C_conduit_unconfined of mfusg 1.5\n", @@ -1197,7 +1164,6 @@ { "cell_type": "code", "execution_count": 29, - "id": "c36c1659-b857-4d91-bff1-2f13a1c31e33", "metadata": {}, "outputs": [ { @@ -1227,7 +1193,6 @@ { "cell_type": "code", "execution_count": 30, - "id": "436a89dd-7299-4192-9fdf-8a790e35c14c", "metadata": {}, "outputs": [ { @@ -1256,7 +1221,6 @@ { "cell_type": "code", "execution_count": 31, - "id": "f579c496-5185-46ed-b5eb-c35dfcd5021a", "metadata": {}, "outputs": [ { @@ -1280,7 +1244,6 @@ { "cell_type": "code", "execution_count": 32, - "id": "f4637d24-4259-4a7c-8d6e-68a1f4f3c4d2", "metadata": {}, "outputs": [ { @@ -1318,7 +1281,6 @@ { "cell_type": "code", "execution_count": 33, - "id": "5822a3c8-ea72-450e-87e3-728a3126ac48", "metadata": {}, "outputs": [], "source": [ @@ -1339,13 +1301,12 @@ { "cell_type": "code", "execution_count": 34, - "id": "a3ad338d-e362-4ead-b1ee-2ae5448f78a9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 34, @@ -1354,7 +1315,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1379,7 +1340,6 @@ { "cell_type": "code", "execution_count": 35, - "id": "b32a6c2c-56c4-442d-918b-65f18b42e221", "metadata": {}, "outputs": [], "source": [ @@ -1396,7 +1356,6 @@ }, { "cell_type": "markdown", - "id": "606a8770-41f7-45d4-a54e-8a6d330d7aab", "metadata": {}, "source": [ "## Modify CLN amd WEL package to example create 03D_conduit_unconfined of mfusg 1.5\n", @@ -1406,7 +1365,6 @@ { "cell_type": "code", "execution_count": 36, - "id": "2f5fc636-7ba6-4041-b808-71c6092009f3", "metadata": {}, "outputs": [ { @@ -1436,7 +1394,6 @@ { "cell_type": "code", "execution_count": 37, - "id": "a279aa71-4ff7-4d0d-a088-78abb7fde030", "metadata": {}, "outputs": [ { @@ -1465,7 +1422,6 @@ { "cell_type": "code", "execution_count": 38, - "id": "df3cf10b-1c9d-42df-aadd-b484f6ef1b35", "metadata": {}, "outputs": [ { @@ -1489,7 +1445,6 @@ { "cell_type": "code", "execution_count": 39, - "id": "bd4760c3-e69b-4ccc-94aa-342aedaf1dc6", "metadata": {}, "outputs": [ { @@ -1527,7 +1482,6 @@ { "cell_type": "code", "execution_count": 40, - "id": "436b6009-4fbf-420d-ac9d-fad32b70d2c0", "metadata": {}, "outputs": [], "source": [ @@ -1548,7 +1502,6 @@ { "cell_type": "code", "execution_count": 41, - "id": "411fadcb-05aa-4952-aa20-fbd8a8ad7961", "metadata": {}, "outputs": [], "source": [ @@ -1565,7 +1518,6 @@ }, { "cell_type": "markdown", - "id": "14042416-d887-40c7-a38b-2abeb2a77546", "metadata": {}, "source": [ "## Comparing four cases" @@ -1574,13 +1526,12 @@ { "cell_type": "code", "execution_count": 42, - "id": "e5d84f53-0879-4328-9478-1ff70dfdde2f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 42, @@ -1589,7 +1540,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1616,13 +1567,12 @@ { "cell_type": "code", "execution_count": 43, - "id": "e6a18152-d705-494c-8b7e-e7c0aea87714", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 43, @@ -1631,7 +1581,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1666,7 +1616,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -1680,7 +1630,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.1" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/examples/data/mfusg_test/03_conduit_confined/ex3.cln b/examples/data/mfusg_test/03_conduit_confined/ex3.cln index a999cc2d30..f74a2e6af7 100755 --- a/examples/data/mfusg_test/03_conduit_confined/ex3.cln +++ b/examples/data/mfusg_test/03_conduit_confined/ex3.cln @@ -1,4 +1,4 @@ -1 -1 35 -36 0 0 2 1 NCLN ICLNNDS ICLNCB ICLNHD ICLNDD ICLNIB NCLNGWC NCONDUITYP +1 -1 35 36 0 0 2 1 NCLN ICLNNDS ICLNCB ICLNHD ICLNDD ICLNIB NCLNGWC NCONDUITYP constant 2 NNDCLN(NCLN) CLN cells per segment 1 1 0 10.0 -110. 1.57 0 0 IFNO IFTYP IFDIR FLENG FELEV FANGLE IFLIN ICCWADI 2 1 0 10.0 -130. 1.57 0 0 IFNO IFTYP IFDIR FLENG FELEV FANGLE IFLIN ICCWADI diff --git a/flopy/__init__.py b/flopy/__init__.py index b11a80be9d..dfb4b604c6 100644 --- a/flopy/__init__.py +++ b/flopy/__init__.py @@ -38,13 +38,15 @@ from .mbase import run_model, which __all__ = [ - " __version__", + "__version__", "__author__", - "__author_email__" "modflow", + "__author_email__", + "modflow", "mt3d", "seawat", "modpath", - "modflowlgr" "modflowusg", + "modflowlgr", + "modflowusg", "utils", "plot", "export", diff --git a/flopy/mbase.py b/flopy/mbase.py index 37f579ca92..660042f119 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -1,4 +1,5 @@ -"""mbase module +""" + mbase module. This module contains the base model class from which all of the other models inherit from. @@ -31,9 +32,11 @@ # external exceptions for users class PackageLoadException(Exception): + """FloPy package load exception""" def __init__(self, error, location=""): + """Initialize exception.""" self.message = error super().__init__(f"{error} ({location})") diff --git a/flopy/modflowusg/__init__.py b/flopy/modflowusg/__init__.py index afc81fa56a..3449618c28 100644 --- a/flopy/modflowusg/__init__.py +++ b/flopy/modflowusg/__init__.py @@ -1,4 +1,4 @@ -"""Initialize modflowusg""" +"""Initialize modflowusg.""" from .mfusg import ModflowUsg from .mfusgdisu import ModflowUsgDisU from .mfusgbcf import ModflowUsgBcf diff --git a/flopy/modflowusg/mfusg.py b/flopy/modflowusg/mfusg.py index 1697e86a55..ade44bdcf2 100644 --- a/flopy/modflowusg/mfusg.py +++ b/flopy/modflowusg/mfusg.py @@ -1,7 +1,6 @@ -"""mfusg module""" +"""mfusg module.""" import os import flopy -import warnings from inspect import getfullargspec from ..utils import mfreadnam @@ -10,8 +9,7 @@ class ModflowUsg(Modflow): - """ - MODFLOW-USG Model Class. + """MODFLOW-USG Model Class Parameters ---------- @@ -155,6 +153,7 @@ def __repr__(self): def load( cls, f, + version="mfusg", exe_name="mfusg.exe", verbose=False, model_ws=".", @@ -169,6 +168,8 @@ def load( ---------- f : str Path to MODFLOW name file to load. + version : str, default "mfusg" + MODFLOW version. Must be "mfusg". exe_name : str, default "mfusg.exe" MODFLOW executable name. verbose : bool, default False @@ -196,6 +197,9 @@ def load( >>> import flopy >>> ml = flopy.modflowusg.ModflowUsg.load('model.nam') """ + if version != "mfusg": + version = "mfusg" + # similar to modflow command: if file does not exist , try file.nam namefile_path = os.path.join(model_ws, f) if not os.path.isfile(namefile_path) and os.path.isfile( @@ -314,37 +318,6 @@ def load( # return model object return ml - @staticmethod - def _ext_unit_d_load(ml, ext_unit_dict, ext_unit_d_item): - """ - Method to load a package from an ext_unit_dict item into model - - Parameters - ---------- - ml : ModflowUsg model object for which package in ext_unit_d_item will - be loaded - ext_unit_dict : dict - For each file listed in the name file, a - :class:`flopy.utils.mfreadnam.NamData` instance. - Keyed by unit number. - ext_unit_d_item : :class:`flopy.utils.mfreadnam.NamData` instance. - Must be an item of ext_unit_dict. - """ - package_load_args = getfullargspec(ext_unit_d_item.package.load)[0] - if "check" in package_load_args: - ext_unit_d_item.package.load( - ext_unit_d_item.filehandle, - ml, - ext_unit_dict=ext_unit_dict, - check=False, - ) - else: - ext_unit_d_item.package.load( - ext_unit_d_item.filehandle, - ml, - ext_unit_dict=ext_unit_dict, - ) - @classmethod def _load_packages(cls, ml, ext_unit_dict, ext_pkg_d, load_only, forgive): """ @@ -413,35 +386,18 @@ def _load_packages(cls, ml, ext_unit_dict, ext_pkg_d, load_only, forgive): # try loading packages in ext_unit_dict for key, item in ext_unit_dict.items(): if item.package is not None: - if item.filetype in load_only: - if forgive: - try: - cls._ext_unit_d_load(ml, ext_unit_dict, item) - files_successfully_loaded.append(item.filename) - if ml.verbose: - print( - f" {item.filetype:4s} package \ - load...success" - ) - except PackageLoadException as e: - ml.load_fail = True - if ml.verbose: - raise PackageLoadException( - error=f" {item.filetype:4s} package \ - load...failed\n {e!s}" - ) - files_not_loaded.append(item.filename) - else: - cls._ext_unit_d_load(ml, ext_unit_dict, item) - files_successfully_loaded.append(item.filename) - if ml.verbose: - print( - f" {item.filetype:4s} package load...success" - ) - else: - if ml.verbose: - print(f" {item.filetype:4s} package load...skipped") - files_not_loaded.append(item.filename) + ( + files_successfully_loaded, + files_not_loaded, + ) = cls._load_ext_unit_dict_paks( + ml, + ext_unit_dict, + load_only, + item, + forgive, + files_successfully_loaded, + files_not_loaded, + ) elif "data" not in item.filetype.lower(): files_not_loaded.append(item.filename) if ml.verbose: @@ -464,6 +420,79 @@ def _load_packages(cls, ml, ext_unit_dict, ext_pkg_d, load_only, forgive): return files_successfully_loaded, files_not_loaded + @classmethod + def _load_ext_unit_dict_paks( + cls, + ml, + ext_unit_dict, + load_only, + item, + forgive, + files_successfully_loaded, + files_not_loaded, + ): + """Load packages from ext_unit_dict.""" + if item.filetype in load_only: + if forgive: + try: + cls._ext_unit_d_load(ml, ext_unit_dict, item) + files_successfully_loaded.append(item.filename) + if ml.verbose: + print( + f" {item.filetype:4s} package \ + load...success" + ) + except PackageLoadException as e: + ml.load_fail = True + if ml.verbose: + raise PackageLoadException( + error=f" {item.filetype:4s} package \ + load...failed\n {e!s}" + ) + files_not_loaded.append(item.filename) + else: + cls._ext_unit_d_load(ml, ext_unit_dict, item) + files_successfully_loaded.append(item.filename) + if ml.verbose: + print(f" {item.filetype:4s} package load...success") + else: + if ml.verbose: + print(f" {item.filetype:4s} package load...skipped") + files_not_loaded.append(item.filename) + + return files_successfully_loaded, files_not_loaded + + @staticmethod + def _ext_unit_d_load(ml, ext_unit_dict, ext_unit_d_item): + """ + Method to load a package from an ext_unit_dict item into model + + Parameters + ---------- + ml : ModflowUsg model object for which package in ext_unit_d_item will + be loaded + ext_unit_dict : dict + For each file listed in the name file, a + :class:`flopy.utils.mfreadnam.NamData` instance. + Keyed by unit number. + ext_unit_d_item : :class:`flopy.utils.mfreadnam.NamData` instance. + Must be an item of ext_unit_dict. + """ + package_load_args = getfullargspec(ext_unit_d_item.package.load)[0] + if "check" in package_load_args: + ext_unit_d_item.package.load( + ext_unit_d_item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + check=False, + ) + else: + ext_unit_d_item.package.load( + ext_unit_d_item.filehandle, + ml, + ext_unit_dict=ext_unit_dict, + ) + def fmt_string(array): """ diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py index 262b1f0409..1b1d0a90d7 100644 --- a/flopy/modflowusg/mfusgbcf.py +++ b/flopy/modflowusg/mfusgbcf.py @@ -1,6 +1,7 @@ -"""mfusgbcf module. +""" +mfusgbcf module. -Contains the ModflowUsgBcf class. Note that the user can +Contains the ModflowUsgBcf class. Note that the user can access the ModflowUsgBcf class as `flopy.modflowusg.ModflowUsgBcf`. """ import warnings @@ -196,7 +197,7 @@ def __init__( dis = model.get_package("DISU") structured = self.parent.structured - nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + nrow, ncol, nlay, _ = self.parent.nrow_ncol_nlay_nper if not structured: njag = dis.njag @@ -244,27 +245,9 @@ def __getattr__(self, name): ) return "" - def _write_hy_tran_vcont_kv(self, f, k): - """ - writes hy/tran and vcont/kv file entries - - Parameters - ---------- - f : open file object. - k : model layer index (base 0) - """ - if (self.laycon[k] == 0) or (self.laycon[k] == 2): - f.write(self.tran[k].get_file_entry()) - else: - f.write(self.hy[k].get_file_entry()) - - if (self.ikvflag == 0) and k < (self.parent.nlay - 1): - f.write(self.vcont[k].get_file_entry()) - elif (self.ikvflag == 1) and (self.parent.nlay > 1): - f.write(self.kv[k].get_file_entry()) - def write_file(self, f=None): - """Write the BCF package file. + """ + Write the BCF package file. Parameters ---------- @@ -333,142 +316,24 @@ def write_file(self, f=None): f.close() - @staticmethod - def _load_laycon(f, model): - """ - Loads laycon and intercellt file entries. - - Parameters - ---------- - f : open file object. - model : model object - The model object (of type :class:`flopy.modflow.mf.Modflow`) to - which this package will be added. - - Returns - ------- - laycon : Numpy array of laycon values - intercellt : Numpy array of intercellt values - """ - nlay = model.nlay - ifrefm = model.get_ifrefm() - - if model.verbose: - print(" loading LAYCON...") - - line = f.readline() - - if ifrefm: - laycons = [] - line_split = line.strip().split() - for item in line_split: - laycons.append(item) - # read the rest of the laycon values - if len(laycons) < nlay: - while True: - line = f.readline() - line_split = line.strip().split() - for item in line_split: - laycons.append(item) - if len(laycons) == nlay: - break - else: - laycons = [] - istart = 0 - for k in range(nlay): - lcode = line[istart : istart + 2] - if lcode.strip() == "": - # hit end of line before expected end of data - # read next line - line = f.readline() - istart = 0 - lcode = line[istart : istart + 2] - lcode = lcode.replace(" ", "0") - laycons.append(lcode) - istart += 2 - - intercellt = np.zeros(nlay, dtype=np.int32) - laycon = np.zeros(nlay, dtype=np.int32) - for k in range(nlay): - if len(laycons[k]) > 1: - intercellt[k] = int(laycons[k][0]) - laycon[k] = int(laycons[k][1]) - else: - laycon[k] = int(laycons[k]) - - return laycon, intercellt - - @staticmethod - def _load_hy_tran_kv_vcont(f, model, laycon_k, ext_unit_dict, ikvflag): + def _write_hy_tran_vcont_kv(self, f, k): """ - Loads hy/tran and kv/vcont file entries. + writes hy/tran and vcont/kv file entries Parameters ---------- f : open file object. - model : model object - The model object (of type :class:`flopy.modflow.mf.Modflow`) to - which this package will be added. - laycon_k : tuple of two ints: (k, laycon for layer k) - ext_unit_dict : external unit dictionary - ikvflag : int - flag indicating if vertical hydraulic conductivity is input - instead of leakance between two layers. - - Returns - ------- - _hy : Numpy array of hk values (or 0) - _tran : Numpy array of tran values (or 0) - _kv : Numpy array of kv values (or 0) - _vcont : Numpy array of vcont values (or 0) + k : model layer index (base 0) """ - k = laycon_k[0] - laycon_k = laycon_k[1] - util2d_shape = get_util2d_shape_for_layer(model, layer=k) - - # hy or tran - _tran = 0 - _hy = 0 - if (laycon_k == 0) or (laycon_k == 2): - if model.verbose: - print(f" loading tran layer {k + 1:3d}...") - _tran = Util2d.load( - f, - model, - util2d_shape, - np.float32, - "tran", - ext_unit_dict, - ) + if (self.laycon[k] == 0) or (self.laycon[k] == 2): + f.write(self.tran[k].get_file_entry()) else: - if model.verbose: - print(f" loading hy layer {k + 1:3d}...") - _hy = Util2d.load( - f, model, util2d_shape, np.float32, "hy", ext_unit_dict - ) - - # kv or vcont - _kv = 0 - _vcont = 0 - if k < (model.nlay - 1): - if model.verbose: - print(f" loading vcont layer {k + 1:3d}...") - _vcont = Util2d.load( - f, - model, - util2d_shape, - np.float32, - "vcont", - ext_unit_dict, - ) - elif (ikvflag == 1) and (model.nlay > 1): - if model.verbose: - print(f" loading kv layer {k + 1:3d}...") - _kv = Util2d.load( - f, model, util2d_shape, np.float32, "kv", ext_unit_dict - ) + f.write(self.hy[k].get_file_entry()) - return _hy, _tran, _kv, _vcont + if (self.ikvflag == 0) and k < (self.parent.nlay - 1): + f.write(self.vcont[k].get_file_entry()) + elif (self.ikvflag == 1) and (self.parent.nlay > 1): + f.write(self.kv[k].get_file_entry()) @classmethod def load(cls, f, model, ext_unit_dict=None): @@ -522,7 +387,7 @@ def load(cls, f, model, ext_unit_dict=None): break # determine problem dimensions - nr, nc, nlay, nper = model.get_nrow_ncol_nlay_nper() + nr, nc, nlay, _ = model.get_nrow_ncol_nlay_nper() dis = model.get_package("DIS") if dis is None: dis = model.get_package("DISU") @@ -577,6 +442,172 @@ def load(cls, f, model, ext_unit_dict=None): else: anglex = 0 + # hy, kv, storage + (sf1, tran, hy, vcont, sf2, wetdry, kv) = cls._load_layer_arrays( + f, + model, + nlay, + ext_unit_dict, + transient, + laycon, + ikvflag, + ikcflag, + iwdflg, + ) + + # Ksat mfusg + if (not model.structured) and abs(ikcflag == 1): + if model.verbose: + print(" loading ksat (njag)...") + ksat = Util2d.load( + f, model, (njag,), np.float32, "ksat", ext_unit_dict + ) + else: + ksat = 0 + + if openfile: + f.close() + + # set package unit number + unitnumber, filenames = get_unitnumber_from_ext_unit_dict( + model, cls, ext_unit_dict, ipakcb + ) + + # create instance of bcf object + bcf = cls( + model, + ipakcb=ipakcb, + intercellt=intercellt, + laycon=laycon, + trpy=trpy, + hdry=hdry, + iwdflg=iwdflg, + wetfct=wetfct, + iwetit=iwetit, + ihdwet=ihdwet, + ikvflag=ikvflag, + ikcflag=ikcflag, + tran=tran, + hy=hy, + vcont=vcont, + kv=kv, + anglex=anglex, + ksat=ksat, + sf1=sf1, + sf2=sf2, + wetdry=wetdry, + unitnumber=unitnumber, + filenames=filenames, + ) + + # return bcf object + return bcf + + @staticmethod + def _load_laycon(f, model): + """ + Loads laycon and intercellt file entries. + + Parameters + ---------- + f : open file object. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + + Returns + ------- + laycon : Numpy array of laycon values + intercellt : Numpy array of intercellt values + """ + nlay = model.nlay + ifrefm = model.get_ifrefm() + + if model.verbose: + print(" loading LAYCON...") + + line = f.readline() + + if ifrefm: + laycons = [] + line_split = line.strip().split() + for item in line_split: + laycons.append(item) + # read the rest of the laycon values + if len(laycons) < nlay: + while True: + line = f.readline() + line_split = line.strip().split() + for item in line_split: + laycons.append(item) + if len(laycons) == nlay: + break + else: + laycons = [] + istart = 0 + for k in range(nlay): + lcode = line[istart : istart + 2] + if lcode.strip() == "": + # hit end of line before expected end of data + # read next line + line = f.readline() + istart = 0 + lcode = line[istart : istart + 2] + lcode = lcode.replace(" ", "0") + laycons.append(lcode) + istart += 2 + + intercellt = np.zeros(nlay, dtype=np.int32) + laycon = np.zeros(nlay, dtype=np.int32) + for k in range(nlay): + if len(laycons[k]) > 1: + intercellt[k] = int(laycons[k][0]) + laycon[k] = int(laycons[k][1]) + else: + laycon[k] = int(laycons[k]) + + return laycon, intercellt + + @classmethod + def _load_layer_arrays( + cls, + f, + model, + nlay, + ext_unit_dict, + transient, + laycon, + ikvflag, + ikcflag, + iwdflg, + ): + """ + Loads LPF layer property arrays. + + Parameters + ---------- + f : open file object. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + nlay : int. Number of model layers + laycon : disu laycon array + ext_unit_dict : external unit dictionary + transient : bool. Flag for transient vs steady state models + ikvflag : int + flag indicating if vertical hydraulic conductivity is input + instead of leakance between two layers. + ikcflag : int + flag indicating if hydraulic conductivity or transmissivity + information is input for each of the nodes or whether this information + is directly input for the nodal connections. + iwdflg : int + flag to indicate if wetting is inactive (0) or not (non zero) + + Returns + ------- + sf1, tran, hy, vcont, sf2, wetdry, kv : layer property arrays + """ sf1 = [0] * nlay tran = [0] * nlay hy = [0] * nlay @@ -626,50 +657,76 @@ def load(cls, f, model, ext_unit_dict=None): f, model, util2d_shape, np.float32, "wetdry", ext_unit_dict ) - # Ksat mfusg - if (not model.structured) and abs(ikcflag == 1): + return sf1, tran, hy, vcont, sf2, wetdry, kv + + @staticmethod + def _load_hy_tran_kv_vcont(f, model, laycon_k, ext_unit_dict, ikvflag): + """ + Loads hy/tran and kv/vcont file entries. + + Parameters + ---------- + f : open file object. + model : model object + The model object (of type :class:`flopy.modflow.mf.Modflow`) to + which this package will be added. + laycon_k : tuple of two ints: (k, laycon for layer k) + ext_unit_dict : external unit dictionary + ikvflag : int + flag indicating if vertical hydraulic conductivity is input + instead of leakance between two layers. + + Returns + ------- + _hy : Numpy array of hk values (or 0) + _tran : Numpy array of tran values (or 0) + _kv : Numpy array of kv values (or 0) + _vcont : Numpy array of vcont values (or 0) + """ + k = laycon_k[0] + laycon_k = laycon_k[1] + util2d_shape = get_util2d_shape_for_layer(model, layer=k) + + # hy or tran + _tran = 0 + _hy = 0 + if (laycon_k == 0) or (laycon_k == 2): if model.verbose: - print(" loading ksat (njag)...") - ksat = Util2d.load( - f, model, (njag,), np.float32, "ksat", ext_unit_dict + print(f" loading tran layer {k + 1:3d}...") + _tran = Util2d.load( + f, + model, + util2d_shape, + np.float32, + "tran", + ext_unit_dict, ) else: - ksat = 0 - - if openfile: - f.close() - - # set package unit number - unitnumber, filenames = get_unitnumber_from_ext_unit_dict( - model, cls, ext_unit_dict, ipakcb - ) + if model.verbose: + print(f" loading hy layer {k + 1:3d}...") + _hy = Util2d.load( + f, model, util2d_shape, np.float32, "hy", ext_unit_dict + ) - # create instance of bcf object - bcf = cls( - model, - ipakcb=ipakcb, - intercellt=intercellt, - laycon=laycon, - trpy=trpy, - hdry=hdry, - iwdflg=iwdflg, - wetfct=wetfct, - iwetit=iwetit, - ihdwet=ihdwet, - ikvflag=ikvflag, - ikcflag=ikcflag, - tran=tran, - hy=hy, - vcont=vcont, - kv=kv, - anglex=anglex, - ksat=ksat, - sf1=sf1, - sf2=sf2, - wetdry=wetdry, - unitnumber=unitnumber, - filenames=filenames, - ) + # kv or vcont + _kv = 0 + _vcont = 0 + if k < (model.nlay - 1): + if model.verbose: + print(f" loading vcont layer {k + 1:3d}...") + _vcont = Util2d.load( + f, + model, + util2d_shape, + np.float32, + "vcont", + ext_unit_dict, + ) + elif (ikvflag == 1) and (model.nlay > 1): + if model.verbose: + print(f" loading kv layer {k + 1:3d}...") + _kv = Util2d.load( + f, model, util2d_shape, np.float32, "kv", ext_unit_dict + ) - # return bcf object - return bcf + return _hy, _tran, _kv, _vcont diff --git a/flopy/modflowusg/mfusgcln.py b/flopy/modflowusg/mfusgcln.py index 3aa154a62d..c3156d749a 100644 --- a/flopy/modflowusg/mfusgcln.py +++ b/flopy/modflowusg/mfusgcln.py @@ -1,7 +1,7 @@ """ mfusgcln module. -Contains the ModflowUsgCln class. Note that the user can +Contains the ModflowUsgCln class. Note that the user can access the ModflowUsgCln class as `flopy.modflowusg.ModflowUsgCln`. Compatible with USG-Transport Version 1.7.0. which can be downloade from @@ -9,16 +9,15 @@ Additional information for this MODFLOW package can be found at the `Online MODFLOW Guide -Panday, S., 2021; USG-Transport Version 1.7.0: The Block-Centered Transport +Panday, S., 2021; USG-Transport Version 1.7.0: The Block-Centered Transport Process for MODFLOW-USG, GSI Environmental, March, 2021 -Panday, Sorab, Langevin, C.D., Niswonger, R.G., Ibaraki, Motomu, and Hughes, -J.D., 2013, MODFLOW–USG version 1: An unstructured grid version of MODFLOW -for simulating groundwater flow and tightly coupled processes using a control -volume finite-difference formulation: U.S. Geological Survey Techniques and +Panday, Sorab, Langevin, C.D., Niswonger, R.G., Ibaraki, Motomu, and Hughes, +J.D., 2013, MODFLOW–USG version 1: An unstructured grid version of MODFLOW +for simulating groundwater flow and tightly coupled processes using a control +volume finite-difference formulation: U.S. Geological Survey Techniques and Methods, book 6, chap. A45, 66 p. """ -import warnings import numpy as np from ..pakbase import Package from ..utils import Util2d @@ -165,67 +164,60 @@ class ModflowUsgCln(Package): def __init__( self, model, - **kwargs, + ncln=None, # number of CLNs + iclnnds=None, # number of nodes + nndcln=None, # number of nodes in each CLN segments + clncon=None, # node IDs in each CLN segments + nja_cln=None, # total number of node-node connections (NJAG) + iac_cln=None, # number of connections for each node (sum(IAC)=NJAG + ja_cln=None, # node connections + node_prop=None, # node properties + nclngwc=None, # number of CLN-GW connections + cln_gwc=None, # CLN-GW connections + nconduityp=1, # number of circular conduit types + cln_circ=None, # circular conduit properties + ibound=1, # boundary condition types + strt=1.0, # initial head in CLN cells + transient=False, # OPTIONS: transient IBOUND for each stress period + printiaja=False, # OPTIONS: print IA_CLN and JA_CLN to listing file + nrectyp=0, # OPTIONS2: number of rectangular fracture types + cln_rect=None, # rectangular fracture properties + bhe=False, # OPTIONS2: borehole heat exchanger (BHE) + grav=None, # OPTIONS2: gravitational acceleration constant + visk=None, # OPTIONS2: kinematic viscosity of water + extension=[ + "cln", + "clncb", + "clnhd", + "clndd", + "clnib", + "clncn", + "clnmb", + ], + unitnumber=None, + filenames=None, ): - """Package constructor""" + """Package constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" + "but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg - valid_args_defaults = { - "ncln": None, # number of CLNs - "iclnnds": None, # number of nodes - "nndcln": None, # number of nodes in each CLN segments - "clncon": None, # node IDs in each CLN segments - "nja_cln": None, # total number of node-node connections (NJAG) - "iac_cln": None, # number of connections for each node (sum(IAC)": NJAG - "ja_cln": None, # node connections - "node_prop": None, # node properties - "nclngwc": None, # number of CLN-GW connections - "cln_gwc": None, # CLN-GW connections - "nconduityp": 1, # number of circular conduit types - "cln_circ": None, # circular conduit properties - "ibound": 1, # boundary condition types - "strt": 1.0, # initial head in CLN cells - "transient": False, # OPTIONS: transient IBOUND for each stress period - "printiaja": False, # OPTIONS: print IA_CLN and JA_CLN to listing file - "nrectyp": 0, # OPTIONS2: number of rectangular fracture types - "cln_rect": None, # rectangular fracture properties - "bhe": False, # OPTIONS2: borehole heat exchanger (bhe) - "grav": None, # OPTIONS2: gravitational acceleration constant - "visk": None, # OPTIONS2: kinematic viscosity of water - "extension": [ - "cln", - "clncb", - "clnhd", - "clndd", - "clnib", - "clncn", - "clnmb", - ], - "unitnumber": None, - "filenames": None, - } - - for arg, default_value in valid_args_defaults.items(): - setattr(self, arg, kwargs.pop(arg, default_value)) - # set default unit number of one is not specified - if self.unitnumber is None: + if unitnumber is None: self.unitnumber = ModflowUsgCln._defaultunit() - elif isinstance(self.unitnumber, list): - if len(self.unitnumber) < 7: - for idx in range(len(self.unitnumber), 7): - self.unitnumber.append(0) + elif isinstance(unitnumber, list): + if len(unitnumber) < 7: + for idx in range(len(unitnumber), 7): + unitnumber.append(0) # set filenames - if self.filenames is None: - self.filenames = [None, None, None, None, None, None, None] - elif isinstance(self.filenames, str): - self.filenames = [ - self.filenames, + if filenames is None: + filenames = [None, None, None, None, None, None, None] + elif isinstance(filenames, str): + filenames = [ + filenames, None, None, None, @@ -233,82 +225,76 @@ def __init__( None, None, ] - elif isinstance(self.filenames, list): - if len(self.filenames) < 7: - for idx in range(len(self.filenames), 7): - self.filenames.append(None) + elif isinstance(filenames, list): + if len(filenames) < 7: + for idx in range(len(filenames), 7): + filenames.append(None) # Fill namefile items name = [ModflowUsgCln._ftype()] extra = [""] - exten = [self.extension[0]] - units = self.unitnumber[0] - # set package name - fname = [self.filenames[0]] # Call ancestor's init to set self.parent, extension, name and unit number Package.__init__( self, model, - extension=exten, + extension=extension, name=name, - unit_number=units, + unit_number=unitnumber, extra=extra, - filenames=fname, + filenames=filenames, ) self.url = "Connected_Linear_Network.htm" self._generate_heading() - # CLN output files - # reset extension (overwritten by package init?) - if "extension" not in kwargs.keys(): - self.extension = [ - "cln", - "clncb", - "clnhd", - "clndd", - "clnib", - "clncn", - "clnmb", - ] + # Options + self.transient = transient + self.printiaja = printiaja - for idx, attr in enumerate(self.extension[1:]): - setattr(self, f"i{attr}", self.unitnumber[idx + 1]) + for idx, attr in enumerate(extension[1:]): + setattr(self, f"i{attr}", int(unitnumber[idx + 1])) if getattr(self, f"i{attr}") > 0: model.add_output_file( getattr(self, f"i{attr}"), - fname=self.filenames[idx + 1], + fname=filenames[idx + 1], extension=attr, binflag=True, package=ModflowUsgCln._ftype(), ) # Define CLN networks and connections + self.ncln = ncln + self.iclnnds = iclnnds + self.nndcln = nndcln + self.clncon = clncon + self.iac_cln = iac_cln + self.nja_cln = nja_cln self._define_cln_networks(model) # Define CLN node properties - if self.node_prop is None: + if node_prop is None: raise Exception("mfcln: Node properties must be provided") - if len(self.node_prop) != self.nclnnds: + if len(node_prop) != self.nclnnds: raise Exception( "mfcln: Length of Node properties must equal number of nodes" ) self.node_prop = self._make_recarray( - self.node_prop, dtype=ModflowUsgCln.get_clnnode_dtype() + node_prop, dtype=ModflowUsgCln.get_clnnode_dtype() ) # Define CLN groundwater connections - if self.nclngwc is None: + if nclngwc is None: raise Exception("mfcln: Number of CLN-GW connections not defined") + self.nclngwc = nclngwc - if self.cln_gwc is None: + if cln_gwc is None: raise Exception("mfcln: CLN-GW connections not provided") - if len(self.cln_gwc) != self.nclngwc: + if len(cln_gwc) != nclngwc: raise Exception( "mfcln: Number of CLN-GW connections not equal to nclngwc" ) @@ -316,10 +302,18 @@ def __init__( structured = self.parent.structured self.cln_gwc = self._make_recarray( - self.cln_gwc, dtype=ModflowUsgCln.get_gwconn_dtype(structured) + cln_gwc, dtype=ModflowUsgCln.get_gwconn_dtype(structured) ) # Define CLN geometry types + self.nconduityp = nconduityp + self.cln_circ = cln_circ + self.nrectyp = nrectyp + self.cln_rect = cln_rect + self.bhe = bhe + self.grav = grav + self.visk = visk + self._define_cln_geometries() # Define CLN ibound and initial heads properties @@ -327,7 +321,7 @@ def __init__( model, (self.nclnnds,), np.int32, - self.ibound, + ibound, name="ibound", locat=self.unit_number[0], ) @@ -336,26 +330,28 @@ def __init__( model, (self.nclnnds,), np.float32, - self.strt, + strt, name="strt", locat=self.unit_number[0], ) self.parent.add_package(self) - def __getattr__(self, name): - """ - Get class attributes to avoid pylint E1101 false positives - - Will only get called for undefined attributes, given dynamic variable definitions. - """ - warnings.warn( - f"No member '{name}' contained in {type(self).__name__})" - ) - return "" + @staticmethod + def _get_default_extension(): + """Gets default package file extensions""" + return [ + "cln", + "clncb", + "clnhd", + "clndd", + "clnib", + "clncn", + "clnmb", + ] def _define_cln_networks(self, model): - """Initialises CLN netoworks""" + """Initialises CLN networks.""" if self.ncln is None: raise Exception("mfcln: CLN network not defined") @@ -635,6 +631,11 @@ def write_file(self, f=None): """ Write the package file. + Parameters + ---------- + f : filename or file handle + File to write to. + Returns ------- None @@ -693,7 +694,7 @@ def write_file(self, f=None): f_cln.close() def _write_items_0_1(self, f_cln): - """writes cln items 0 and 1""" + """writes cln items 0 and 1.""" if self.transient or self.printiaja: f_cln.write("OPTIONS ") if self.transient: @@ -834,23 +835,20 @@ def load(cls, f, model, ext_unit_dict=None): # reset unit numbers unitnumber = ModflowUsgCln._defaultunit() filenames = [None] * 7 + extension = cls._get_default_extension() if ext_unit_dict is not None: unitnumber[0], filenames[0] = model.get_ext_dict_attr( ext_unit_dict, filetype=ModflowUsgCln._ftype() ) file_unit_items = [iclncb, iclnhd, iclndd, iclnib, iclncn, iclnmb] - funcs = ( - [lambda clni: abs(clni)] - + [lambda clni: clni] * 3 - + [lambda clni: abs(clni)] * 2 - ) + funcs = [abs] + [int] * 3 + [abs] * 2 for idx, (item, func) in enumerate(zip(file_unit_items, funcs)): if item > 0: ( unitnumber[idx + 1], filenames[idx + 1], ) = model.get_ext_dict_attr(ext_unit_dict, unit=func(item)) - model.add_pop_key_list(func(iclncb)) + model.add_pop_key_list(func(item)) # create dis object instance cln = cls( @@ -885,7 +883,7 @@ def load(cls, f, model, ext_unit_dict=None): @staticmethod def _load_items_0_1(f, model): - """Loads items 0 and 1 from filehandle f""" + """Loads items 0 and 1 from filehandle f.""" # Options transient = False printiaja = False diff --git a/flopy/modflowusg/mfusgdisu.py b/flopy/modflowusg/mfusgdisu.py index cf8a1f0873..a0081580c5 100644 --- a/flopy/modflowusg/mfusgdisu.py +++ b/flopy/modflowusg/mfusgdisu.py @@ -228,7 +228,7 @@ def __init__( filenames=None, start_datetime=None, ): - """disu constructor""" + """disu constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" + "but received type: {type(model)}." diff --git a/flopy/modflowusg/mfusggnc.py b/flopy/modflowusg/mfusggnc.py index 4416c1e670..97b7b16399 100644 --- a/flopy/modflowusg/mfusggnc.py +++ b/flopy/modflowusg/mfusggnc.py @@ -92,7 +92,7 @@ def __init__( unitnumber=None, filenames=None, ): - """Package constructor""" + """Package constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" + "but received type: {type(model)}." @@ -175,6 +175,11 @@ def write_file(self, f=None): """ Write the package file. + Parameters + ---------- + f : filename or file handle + File to write to. + Returns ------- None diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index 549d558a36..dbf4083dc1 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -1,6 +1,8 @@ # pylint: disable=W0223 """ -mfusglpf module. Contains the ModflowUsgLpf class. Note that the user can access +mfusglpf module. + +Contains the ModflowUsgLpf class. Note that the user can access the ModflowUsgLpf class as `flopy.modflowusg.ModflowUsgLpf`. Additional information for this MODFLOW package can be found at the `Online @@ -233,7 +235,7 @@ def __init__( filenames=None, add_package=True, ): - """mfusglpf object constructor""" + """mfusglpf object constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" + "but received type: {type(model)}." @@ -339,7 +341,7 @@ def write_file(self, check=True, f=None): ) # get model information - nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper + nrow, ncol, nlay, _ = self.parent.nrow_ncol_nlay_nper dis = self.parent.get_package("DIS") if dis is None: dis = self.parent.get_package("DISU") @@ -611,7 +613,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): break # determine problem dimensions - nr, nc, nlay, _ = model.get_nrow_ncol_nlay_nper() + _, nc, nlay, _ = model.get_nrow_ncol_nlay_nper() dis = model.get_package("DIS") if dis is None: dis = model.get_package("DISU") diff --git a/flopy/modflowusg/mfusgsms.py b/flopy/modflowusg/mfusgsms.py index 2b057736d2..9478cde33d 100644 --- a/flopy/modflowusg/mfusgsms.py +++ b/flopy/modflowusg/mfusgsms.py @@ -236,78 +236,71 @@ class ModflowUsgSms(Package): def __init__( self, model, - **kwargs, + hclose=1e-4, + hiclose=1e-4, + mxiter=100, + iter1=20, + iprsms=2, + nonlinmeth=0, + linmeth=2, + theta=0.7, + akappa=0.1, + gamma=0.2, + amomentum=0.001, + numtrack=20, + btol=1e4, + breduc=0.2, + reslim=100.0, + iacl=2, + norder=0, + level=7, + north=2, + iredsys=0, + rrctol=0.0, + idroptol=0, + epsrn=1.0e-3, + clin="bcgs", + ipc=3, + iscl=0, + iord=0, + rclosepcgu=0.1, + relaxpcgu=1.0, + extension="sms", + options=None, + unitnumber=None, + filenames=None, ): - """Package constructor""" + """Package constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" + "but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg - valid_args_defaults = { - "hclose": 1e-4, - "hiclose": 1e-4, - "mxiter": 100, - "iter1": 20, - "iprsms": 2, - "nonlinmeth": 0, - "linmeth": 2, - "theta": 0.7, - "akappa": 0.1, - "gamma": 0.2, - "amomentum": 0.001, - "numtrack": 20, - "btol": 1e4, - "breduc": 0.2, - "reslim": 100.0, - "iacl": 2, - "norder": 0, - "level": 7, - "north": 2, - "iredsys": 0, - "rrctol": 0.0, - "idroptol": 0, - "epsrn": 1.0e-3, - "clin": "bcgs", - "ipc": 3, - "iscl": 0, - "iord": 0, - "rclosepcgu": 0.1, - "relaxpcgu": 1.0, - "extension": "sms", - "options": None, - "unitnumber": None, - "filenames": None, - } - - for arg, default_value in valid_args_defaults.items(): - setattr(self, arg, kwargs.pop(arg, default_value)) - # set default unit number of one is not specified - if self.unitnumber is None: - self.unitnumber = ModflowUsgSms._defaultunit() + if unitnumber is None: + unitnumber = ModflowUsgSms._defaultunit() # set filenames - if self.filenames is None: - self.filenames = [None] - elif isinstance(self.filenames, str): - self.filenames = [self.filenames] + if filenames is None: + filenames = [None] + elif isinstance(filenames, str): + filenames = [filenames] # Fill namefile items name = [ModflowUsgSms._ftype()] - units = [self.unitnumber] + units = [unitnumber] extra = [""] # set package name - fname = [self.filenames[0]] + fname = [filenames[0]] # Call ancestor's init to set self.parent, extension, name and # unit number Package.__init__( self, model, - extension=self.extension, + extension=extension, name=name, unit_number=units, extra=extra, @@ -316,11 +309,41 @@ def __init__( self._generate_heading() self.url = " " - if self.options is None: + self.hclose = hclose + self.hiclose = hiclose + self.mxiter = mxiter + self.iter1 = iter1 + self.iprsms = iprsms + self.nonlinmeth = nonlinmeth + self.linmeth = linmeth + self.theta = theta + self.akappa = akappa + self.gamma = gamma + self.amomentum = amomentum + self.numtrack = numtrack + self.btol = btol + self.breduc = breduc + self.reslim = reslim + self.iacl = iacl + self.norder = norder + self.level = level + self.north = north + self.iredsys = iredsys + self.rrctol = rrctol + self.idroptol = idroptol + self.epsrn = epsrn + self.clin = clin + self.ipc = ipc + self.iscl = iscl + self.iord = iord + self.rclosepcgu = rclosepcgu + self.relaxpcgu = relaxpcgu + if options is None: self.options = [] else: - if not isinstance(self.options, list): - self.options = [self.options] + if not isinstance(options, list): + options = [options] + self.options = options self.parent.add_package(self) return diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py index f054a5e82c..c341896209 100644 --- a/flopy/modflowusg/mfusgwel.py +++ b/flopy/modflowusg/mfusgwel.py @@ -308,7 +308,7 @@ def write_file(self, f=None): line += "\n" f_wel.write(line) - _, ncol, nlay, nper = self.parent.get_nrow_ncol_nlay_nper() + _, _, _, nper = self.parent.get_nrow_ncol_nlay_nper() kpers = list(self.stress_period_data.data.keys()) if len(kpers) > 0: @@ -365,7 +365,7 @@ def write_file(self, f=None): @staticmethod def _load_dataset2(line): - """load mfusgwel dataset 2 from line""" + """load mfusgwel dataset 2 from line.""" # dataset 2 -- MXACTW IWELCB [Option] line_text = line.strip().split() n_items = 2 @@ -644,7 +644,7 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): ) if nper is None: - nrow, ncol, nlay, nper = model.get_nrow_ncol_nlay_nper() + _, _, _, nper = model.get_nrow_ncol_nlay_nper() # dataset 5 -- read data for every stress period bnd_output = None @@ -699,12 +699,12 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): ext_unit_dict, filetype=ModflowUsgWel._ftype() ) if ipakcb > 0: - iu, filenames[1] = model.get_ext_dict_attr( + _, filenames[1] = model.get_ext_dict_attr( ext_unit_dict, unit=ipakcb ) model.add_pop_key_list(ipakcb) if iunitafr > 0: - iu, filenames[2] = model.get_ext_dict_attr( + _, filenames[2] = model.get_ext_dict_attr( ext_unit_dict, unit=iunitafr ) model.add_pop_key_list(iunitafr) diff --git a/flopy/pakbase.py b/flopy/pakbase.py index 9a5a250438..3a897bbda8 100644 --- a/flopy/pakbase.py +++ b/flopy/pakbase.py @@ -853,12 +853,10 @@ def write_file(self, f=None, check=False): return @staticmethod - def load(f, model, pak_type=None, ext_unit_dict=None, **kwargs): + def load(f, model, pak_type, ext_unit_dict=None, **kwargs): """ Default load method for standard boundary packages. """ - if pak_type is None: - return # parse keywords if "nper" in kwargs: diff --git a/flopy/utils/utils_def.py b/flopy/utils/utils_def.py index c9efbba766..a90f8cad79 100644 --- a/flopy/utils/utils_def.py +++ b/flopy/utils/utils_def.py @@ -167,7 +167,7 @@ def get_util2d_shape_for_layer(model, layer=0): (nrow,ncol) : tuple of ints util2d shape for the given layer """ - nr, nc, nlay, nper = model.get_nrow_ncol_nlay_nper() + nr, nc, _, _ = model.get_nrow_ncol_nlay_nper() if nr is None: # unstructured nrow = 1 ncol = nc[layer] @@ -210,7 +210,7 @@ def get_unitnumber_from_ext_unit_dict( ext_unit_dict, filetype=pak_class._ftype() ) if ipakcb > 0: - iu, filenames[1] = model.get_ext_dict_attr( + _, filenames[1] = model.get_ext_dict_attr( ext_unit_dict, unit=ipakcb ) model.add_pop_key_list(ipakcb) From 726c42eb1c4767b99d7e3805c127d99809332a8a Mon Sep 17 00:00:00 2001 From: Chris Nicol Date: Wed, 6 Oct 2021 15:23:58 +1100 Subject: [PATCH 14/14] Merge remote-tracking branch 'upstream/develop' into mfusg --- autotest/t004_test_utilarray.py | 18 +- autotest/t007_test.py | 2 +- autotest/t027_test.py | 6 +- autotest/t050_test.py | 35 ++- ...{t075_ugridtests.py => t075_test_ugrid.py} | 38 ++-- ..._thick.py => t076_test_modelgrid_thick.py} | 0 ...tions.py => t078_test_lake_connections.py} | 0 autotest/t079_test_cbc_full3D.py | 205 ++++++++++++++++++ autotest/t505_test.py | 50 +++-- .../data/mf6/test001a_Tharmonic/flow15.ims | 6 +- .../test001e_UZF_3lay/test001e_UZF_3lay.ims | 4 +- examples/data/mf6/test003_gwfs_disv/model.ims | 10 +- .../data/mf6/test003_gwftri_disv/model.ims | 10 +- .../data/mf6/test005_advgw_tidal/model.ims | 4 +- .../mf6/test006_2models_mvr/simulation.ims | 6 +- examples/data/mf6/test006_gwf3/flow.ims | 6 +- .../data/mf6/test027_TimeseriesTest/model.ims | 6 +- .../data/mf6/test036_twrihfb/twrihfb2015.ims | 6 +- .../mf6/test045_lake1ss_table/lakeex1b.ims | 4 +- .../data/mf6/test045_lake2tr/lakeex2a.ims | 12 +- flopy/export/netcdf.py | 111 +++++----- flopy/export/utils.py | 2 +- flopy/mbase.py | 3 - flopy/modflow/mf.py | 4 +- flopy/modflow/mfaddoutsidefile.py | 7 +- flopy/modflow/mfag.py | 20 +- flopy/modflow/mfbas.py | 30 +-- flopy/modflow/mfbcf.py | 33 +-- flopy/modflow/mfbct.py | 7 +- flopy/modflow/mfchd.py | 26 +-- flopy/modflow/mfde4.py | 30 +-- flopy/modflow/mfdis.py | 26 +-- flopy/modflow/mfdrn.py | 28 +-- flopy/modflow/mfdrt.py | 30 +-- flopy/modflow/mfevt.py | 31 +-- flopy/modflow/mffhb.py | 31 +-- flopy/modflow/mfflwob.py | 17 +- flopy/modflow/mfgage.py | 42 +--- flopy/modflow/mfghb.py | 35 +-- flopy/modflow/mfgmg.py | 37 +--- flopy/modflow/mfhfb.py | 26 +-- flopy/modflow/mfhob.py | 37 +--- flopy/modflow/mfhyd.py | 37 +--- flopy/modflow/mflak.py | 42 +--- flopy/modflow/mflmt.py | 26 +-- flopy/modflow/mflpf.py | 39 +--- flopy/modflow/mfmlt.py | 29 +-- flopy/modflow/mfmnw1.py | 23 +- flopy/modflow/mfmnw2.py | 34 +-- flopy/modflow/mfmnwi.py | 52 ++--- flopy/modflow/mfnwt.py | 26 +-- flopy/modflow/mfoc.py | 88 +++----- flopy/modflow/mfpbc.py | 7 +- flopy/modflow/mfpcg.py | 30 +-- flopy/modflow/mfpcgn.py | 48 +--- flopy/modflow/mfpks.py | 30 +-- flopy/modflow/mfpval.py | 31 +-- flopy/modflow/mfrch.py | 35 +-- flopy/modflow/mfriv.py | 36 +-- flopy/modflow/mfsfr2.py | 37 +--- flopy/modflow/mfsip.py | 31 +-- flopy/modflow/mfsor.py | 31 +-- flopy/modflow/mfstr.py | 46 +--- flopy/modflow/mfsub.py | 55 ++--- flopy/modflow/mfswi2.py | 72 +++--- flopy/modflow/mfswr1.py | 31 +-- flopy/modflow/mfswt.py | 71 ++---- flopy/modflow/mfupw.py | 34 +-- flopy/modflow/mfuzf1.py | 50 ++--- flopy/modflow/mfwel.py | 37 +--- flopy/modflow/mfzon.py | 31 +-- flopy/modflowusg/mfusgbcf.py | 7 +- flopy/modflowusg/mfusgcln.py | 40 +--- flopy/modflowusg/mfusgdisu.py | 35 +-- flopy/modflowusg/mfusggnc.py | 33 +-- flopy/modflowusg/mfusglpf.py | 12 +- flopy/modflowusg/mfusgsms.py | 38 +--- flopy/modflowusg/mfusgwel.py | 17 +- flopy/modpath/mp6.py | 9 +- flopy/modpath/mp6bas.py | 6 +- flopy/modpath/mp6sim.py | 11 +- flopy/modpath/mp7.py | 9 +- flopy/modpath/mp7bas.py | 6 +- flopy/modpath/mp7sim.py | 8 +- flopy/mt3d/mt.py | 5 +- flopy/mt3d/mtadv.py | 30 +-- flopy/mt3d/mtbtn.py | 26 +-- flopy/mt3d/mtdsp.py | 26 +-- flopy/mt3d/mtgcg.py | 26 +-- flopy/mt3d/mtlkt.py | 44 +--- flopy/mt3d/mtphc.py | 26 +-- flopy/mt3d/mtrct.py | 30 +-- flopy/mt3d/mtsft.py | 44 +--- flopy/mt3d/mtssm.py | 26 +-- flopy/mt3d/mttob.py | 26 +-- flopy/mt3d/mtuzt.py | 37 +--- flopy/pakbase.py | 40 +++- flopy/seawat/swt.py | 2 +- flopy/seawat/swtvdf.py | 26 +-- flopy/seawat/swtvsc.py | 26 +-- flopy/utils/binaryfile.py | 85 +++++--- 101 files changed, 1007 insertions(+), 1929 deletions(-) rename autotest/{t075_ugridtests.py => t075_test_ugrid.py} (94%) rename autotest/{t076_modelgrid_thick.py => t076_test_modelgrid_thick.py} (100%) rename autotest/{t078_lake_connections.py => t078_test_lake_connections.py} (100%) create mode 100644 autotest/t079_test_cbc_full3D.py diff --git a/autotest/t004_test_utilarray.py b/autotest/t004_test_utilarray.py index 282a7bcd48..c776951d4e 100644 --- a/autotest/t004_test_utilarray.py +++ b/autotest/t004_test_utilarray.py @@ -17,7 +17,7 @@ def test_load_txt_free(): a = np.ones((10,), dtype=np.float32) * 250.0 - fp = StringIO(u"10*250.0") + fp = StringIO("10*250.0") fa = Util2d.load_txt(a.shape, fp, a.dtype, "(FREE)") np.testing.assert_equal(fa, a) assert fa.dtype == a.dtype @@ -25,7 +25,7 @@ def test_load_txt_free(): a = np.arange(10, dtype=np.int32).reshape((2, 5)) fp = StringIO( dedent( - u"""\ + """\ 0 1,2,3, 4 5 6, 7, 8 9 """ @@ -39,7 +39,7 @@ def test_load_txt_free(): a[1, 0] = 2.2 fp = StringIO( dedent( - u"""\ + """\ 5*1.0 2.2 2*1.0, +1E-00 1.0 """ @@ -54,7 +54,7 @@ def test_load_txt_fixed(): a = np.arange(10, dtype=np.int32).reshape((2, 5)) fp = StringIO( dedent( - u"""\ + """\ 01234X 56789 """ @@ -66,7 +66,7 @@ def test_load_txt_fixed(): fp = StringIO( dedent( - u"""\ + """\ 0123X 4 5678 @@ -81,7 +81,7 @@ def test_load_txt_fixed(): a = np.array([[-1, 1, -2, 2, -3], [3, -4, 4, -5, 5]], np.int32) fp = StringIO( dedent( - u"""\ + """\ -1 1-2 2-3 3 -44 -55 """ @@ -96,7 +96,7 @@ def test_load_block(): a = np.ones((2, 5), dtype=np.int32) * 4 fp = StringIO( dedent( - u"""\ + """\ 1 1 2 1 5 4 """ @@ -111,7 +111,7 @@ def test_load_block(): a[0, 2:4] = 6.0 fp = StringIO( dedent( - u"""\ + """\ 3 1 2 1 5 4.0 1 2 2 2 9.0 @@ -127,7 +127,7 @@ def test_load_block(): a[0, 2:4] = 8 fp = StringIO( dedent( - u"""\ + """\ 1 1 1 3 4 8 """ diff --git a/autotest/t007_test.py b/autotest/t007_test.py index 520c8c57d3..3d11d454ad 100644 --- a/autotest/t007_test.py +++ b/autotest/t007_test.py @@ -426,7 +426,7 @@ def test_export_array(): if "yllcorner" in line.lower(): val = float(line.strip().split()[-1]) if rotate: - assert np.abs(val - m.modelgrid.extent[1]) < 1e-6 + assert np.abs(val - m.modelgrid.extent[2]) < 1e-6 else: assert np.abs(val - m.modelgrid.yoffset) < 1e-6 if "cellsize" in line.lower(): diff --git a/autotest/t027_test.py b/autotest/t027_test.py index 33a125d162..3478f66b0f 100644 --- a/autotest/t027_test.py +++ b/autotest/t027_test.py @@ -380,8 +380,10 @@ def test_export(): if netCDF4 is not None: fcw = m.wel.export(os.path.join(cpth, "MNW2-Fig28_well.nc")) fcw.write() - fcm = m.mnw2.export(os.path.join(cpth, "MNW2-Fig28.nc")) - fcm.write() + fpth = os.path.join(cpth, "MNW2-Fig28.nc") + # test context statement + with m.mnw2.export(fpth): + pass fpth = os.path.join(cpth, "MNW2-Fig28.nc") nc = netCDF4.Dataset(fpth) assert np.array_equal( diff --git a/autotest/t050_test.py b/autotest/t050_test.py index 5064f3fd1e..8e5588950f 100644 --- a/autotest/t050_test.py +++ b/autotest/t050_test.py @@ -46,8 +46,9 @@ def test_vtk_export_array2d(): assert nlines == 17615 # with smoothing - m.dis.top.export(output_dir, fmt="vtk", name="top_smooth", - binary=False, smooth=True) + m.dis.top.export( + output_dir, fmt="vtk", name="top_smooth", binary=False, smooth=True + ) filetocheck = os.path.join(output_dir, "top_smooth.vtk") nlines1 = count_lines_in_file(filetocheck) assert nlines1 == 17615 @@ -79,7 +80,11 @@ def test_vtk_export_array3d(): # with point scalars m.upw.hk.export( - output_dir, fmt="vtk", name="hk_points", point_scalars=True, binary=False + output_dir, + fmt="vtk", + name="hk_points", + point_scalars=True, + binary=False, ) filetocheck = os.path.join(output_dir, "hk_points.vtk") nlines1 = count_lines_in_file(filetocheck) @@ -117,7 +122,9 @@ def test_vtk_transient_array_2d(): kpers = [0, 1, 1096] # export and check - m.rch.rech.export(output_dir, fmt="vtk", kpers=kpers, binary=False, xml=True) + m.rch.rech.export( + output_dir, fmt="vtk", kpers=kpers, binary=False, xml=True + ) filetocheck = os.path.join(output_dir, "rech_000001.vtk") nlines = count_lines_in_file(filetocheck) assert nlines == 26837 @@ -179,7 +186,9 @@ def test_vtk_export_packages(): # transient package drain kpers = [0, 1, 1096] output_dir = os.path.join(cpth, "DRN") - m.drn.export(output_dir, fmt="vtk", binary=False, xml=True, kpers=kpers, pvd=True) + m.drn.export( + output_dir, fmt="vtk", binary=False, xml=True, kpers=kpers, pvd=True + ) filetocheck = os.path.join(output_dir, "DRN_000001.vtu") nlines3 = count_lines_in_file(filetocheck) assert nlines3 == 27239 @@ -498,8 +507,9 @@ def test_vtk_vertex(): return # disv test - workspace = os.path.join("..", "examples", "data", "mf6", - "test003_gwfs_disv") + workspace = os.path.join( + "..", "examples", "data", "mf6", "test003_gwfs_disv" + ) # outfile = os.path.join("vtk_transient_test", "vtk_pacakages") outfile = os.path.join("temp", "t050", "vtk_disv", "disv.vtk") sim = flopy.mf6.MFSimulation.load(sim_ws=workspace) @@ -538,8 +548,9 @@ def test_vtk_pathline(): ws = os.path.join("..", "examples", "data", "freyberg") modelpth = os.path.join("temp", "t050") outfile = os.path.join(modelpth, "pathline_test", "pathline.vtk") - ml = flopy.modflow.Modflow.load("freyberg.nam", model_ws=ws, - exe_name="mf2005") + ml = flopy.modflow.Modflow.load( + "freyberg.nam", model_ws=ws, exe_name="mf2005" + ) ml.change_model_ws(new_pth=modelpth) ml.write_input() ml.run_model() @@ -587,8 +598,8 @@ def test_vtk_pathline(): maxtime = 0 for p in plines: - if np.max(p['time']) > maxtime: - maxtime = np.max(p['time']) + if np.max(p["time"]) > maxtime: + maxtime = np.max(p["time"]) if not len(totim) == 12054: raise AssertionError("Array size is incorrect for modpath VTK") @@ -613,4 +624,4 @@ def test_vtk_pathline(): test_vtk_vector() test_vtk_unstructured() test_vtk_vertex() - test_vtk_pathline() \ No newline at end of file + test_vtk_pathline() diff --git a/autotest/t075_ugridtests.py b/autotest/t075_test_ugrid.py similarity index 94% rename from autotest/t075_ugridtests.py rename to autotest/t075_test_ugrid.py index 14fecb01eb..55f96c9a8a 100644 --- a/autotest/t075_ugridtests.py +++ b/autotest/t075_test_ugrid.py @@ -291,9 +291,10 @@ def test_voronoi_grid0(plot=False): vor = VoronoiGrid(tri) gridprops = vor.get_gridprops_vertexgrid() + ncpl = gridprops["ncpl"] assert ( - gridprops["ncpl"] == answer_ncpl - ), "Number of cells should be {answer_ncpl}" + ncpl == answer_ncpl + ), f"Number of cells should be {answer_ncpl}. Found {ncpl}" voronoi_grid = VertexGrid(**gridprops, nlay=1) @@ -326,9 +327,10 @@ def test_voronoi_grid1(plot=False): vor = VoronoiGrid(tri) gridprops = vor.get_gridprops_vertexgrid() voronoi_grid = VertexGrid(**gridprops, nlay=1) + ncpl = gridprops["ncpl"] assert ( - gridprops["ncpl"] == answer_ncpl - ), "Number of cells should be {answer_ncpl}" + ncpl == answer_ncpl + ), f"Number of cells should be {answer_ncpl}. Found {ncpl}" if plot: import matplotlib.pyplot as plt @@ -345,22 +347,23 @@ def test_voronoi_grid1(plot=False): def test_voronoi_grid2(plot=False): name = "vor2" - answer_ncpl = 5058 + answer_ncpl = 538 theta = np.arange(0.0, 2 * np.pi, 0.2) radius = 100.0 x = radius * np.cos(theta) y = radius * np.sin(theta) circle_poly = [(x, y) for x, y in zip(x, y)] - tri = Triangle(maximum_area=5, angle=30, model_ws=tpth) + tri = Triangle(maximum_area=50, angle=30, model_ws=tpth) tri.add_polygon(circle_poly) tri.build(verbose=False) vor = VoronoiGrid(tri) gridprops = vor.get_gridprops_vertexgrid() voronoi_grid = VertexGrid(**gridprops, nlay=1) + ncpl = gridprops["ncpl"] assert ( - gridprops["ncpl"] == answer_ncpl - ), "Number of cells should be {answer_ncpl}" + ncpl == answer_ncpl + ), f"Number of cells should be {answer_ncpl}. Found {ncpl}" if plot: import matplotlib.pyplot as plt @@ -377,7 +380,7 @@ def test_voronoi_grid2(plot=False): def test_voronoi_grid3(plot=False): name = "vor3" - answer_ncpl = 2375 + answer_ncpl = 300 theta = np.arange(0.0, 2 * np.pi, 0.2) radius = 100.0 @@ -391,7 +394,7 @@ def test_voronoi_grid3(plot=False): y = radius * np.sin(theta) + 25.0 inner_circle_poly = [(x, y) for x, y in zip(x, y)] - tri = Triangle(maximum_area=10, angle=30, model_ws=tpth) + tri = Triangle(maximum_area=100, angle=30, model_ws=tpth) tri.add_polygon(circle_poly) tri.add_polygon(inner_circle_poly) tri.add_hole((25, 25)) @@ -400,9 +403,10 @@ def test_voronoi_grid3(plot=False): vor = VoronoiGrid(tri) gridprops = vor.get_gridprops_vertexgrid() voronoi_grid = VertexGrid(**gridprops, nlay=1) + ncpl = gridprops["ncpl"] assert ( - gridprops["ncpl"] == answer_ncpl - ), "Number of cells should be {answer_ncpl}" + ncpl == answer_ncpl + ), f"Number of cells should be {answer_ncpl}. Found {ncpl}" if plot: import matplotlib.pyplot as plt @@ -435,9 +439,10 @@ def test_voronoi_grid4(plot=False): vor = VoronoiGrid(tri) gridprops = vor.get_gridprops_vertexgrid() voronoi_grid = VertexGrid(**gridprops, nlay=1) + ncpl = gridprops["ncpl"] assert ( - gridprops["ncpl"] == answer_ncpl - ), "Number of cells should be {answer_ncpl}" + ncpl == answer_ncpl + ), f"Number of cells should be {answer_ncpl}. Found {ncpl}" if plot: import matplotlib.pyplot as plt @@ -498,9 +503,10 @@ def test_voronoi_grid5(plot=False): vor = VoronoiGrid(tri) gridprops = vor.get_gridprops_vertexgrid() voronoi_grid = VertexGrid(**gridprops, nlay=1) + ncpl = gridprops["ncpl"] assert ( - gridprops["ncpl"] == answer_ncpl - ), "Number of cells should be {answer_ncpl}" + ncpl == answer_ncpl + ), f"Number of cells should be {answer_ncpl}. Found {ncpl}" if plot: import matplotlib.pyplot as plt diff --git a/autotest/t076_modelgrid_thick.py b/autotest/t076_test_modelgrid_thick.py similarity index 100% rename from autotest/t076_modelgrid_thick.py rename to autotest/t076_test_modelgrid_thick.py diff --git a/autotest/t078_lake_connections.py b/autotest/t078_test_lake_connections.py similarity index 100% rename from autotest/t078_lake_connections.py rename to autotest/t078_test_lake_connections.py diff --git a/autotest/t079_test_cbc_full3D.py b/autotest/t079_test_cbc_full3D.py new file mode 100644 index 0000000000..e0025a483d --- /dev/null +++ b/autotest/t079_test_cbc_full3D.py @@ -0,0 +1,205 @@ +import os +import sys +import shutil + +import numpy as np +import flopy + +ex_pths = ( + os.path.join("..", "examples", "data", "freyberg"), + os.path.join("..", "examples", "data", "mf6-freyberg"), + os.path.join("..", "examples", "data", "mf6", "test003_gwfs_disv"), + os.path.join("..", "examples", "data", "mf6", "test003_gwftri_disv"), +) +ismf6_lst = ["mf6" in pth for pth in ex_pths] +names = [os.path.basename(pth) for pth in ex_pths] + +tpth = os.path.join("temp", "t079") +# delete the directory if it exists +if os.path.isdir(tpth): + shutil.rmtree(tpth) +# make the directory +os.makedirs(tpth) + +mf6_exe = "mf6" +mf2005_exe = "mf2005" +if sys.platform == "win32": + mf6_exe += ".exe" + mf2005_exe += ".exe" + + +def load_mf2005(name, ws_in): + name_file = f"{name}.nam" + ml = flopy.modflow.Modflow.load( + name_file, + model_ws=ws_in, + exe_name=mf2005_exe, + check=False, + ) + + # change work space + ws_out = os.path.join(tpth, name) + ml.change_model_ws(ws_out) + + # save all budget data to a cell-by cell file + oc = ml.get_package("OC") + oc.reset_budgetunit() + oc.stress_period_data = {(0, 0): ["save budget"]} + + return ml + + +def load_mf6(name, ws_in): + sim = flopy.mf6.MFSimulation.load( + sim_name=name, + exe_name=mf6_exe, + sim_ws=ws_in, + ) + + # change work space + ws_out = os.path.join(tpth, name) + sim.set_sim_path(ws_out) + + # get the groundwater flow model(s) and redefine the output control + # file to save cell by cell output + models = sim.model_names + for model in models: + gwf = sim.get_model(model) + gwf.name_file.save_flows = True + + gwf.remove_package("oc") + budget_filerecord = f"{model}.cbc" + oc = flopy.mf6.ModflowGwfoc( + gwf, + budget_filerecord=budget_filerecord, + saverecord=[("BUDGET", "ALL")], + ) + + return sim + + +def cbc_eval_size(cbcobj, nnodes, shape3d): + cbc_pth = cbcobj.filename + + assert cbcobj.nnodes == nnodes, ( + f"{cbc_pth} nnodes ({cbcobj.nnodes}) " f"does not equal {nnodes}" + ) + a = np.squeeze(np.ones(cbcobj.shape, dtype=float)) + b = np.squeeze(np.ones(shape3d, dtype=float)) + assert a.shape == b.shape, ( + f"{cbc_pth} shape {cbcobj.shape} " f"does not conform to {shape3d}" + ) + + +def cbc_eval_data(cbcobj, shape3d): + cbc_pth = cbcobj.filename + print(f"{cbc_pth}:\n") + cbcobj.list_unique_records() + + names = cbcobj.get_unique_record_names(decode=True) + times = cbcobj.get_times() + for name in names: + text = name.strip() + arr = np.squeeze( + cbcobj.get_data(text=text, totim=times[0], full3D=True)[0] + ) + if text != "FLOW-JA-FACE": + b = np.squeeze(np.ones(shape3d, dtype=float)) + assert arr.shape == b.shape, ( + f"{cbc_pth} shape {arr.shape} for '{text}' budget item " + f"does not conform to {shape3d}" + ) + + +def cbc_eval(cbcobj, nnodes, shape3d, modelgrid): + cbc_pth = cbcobj.filename + cbc_eval_size(cbcobj, nnodes, shape3d) + cbc_eval_data(cbcobj, shape3d) + cbcobj.close() + + cobj_mg = flopy.utils.CellBudgetFile( + cbc_pth, + modelgrid=modelgrid, + verbose=True, + ) + cbc_eval_size(cobj_mg, nnodes, shape3d) + cbc_eval_data(cobj_mg, shape3d) + cobj_mg.close() + + return + + +def clean_run(name): + ws = os.path.join(tpth, name) + if os.path.isdir(ws): + shutil.rmtree(ws) + + +def mf6_eval(name, ws_in): + + sim = load_mf6(name, ws_in) + + # write the simulation + sim.write_simulation() + + # run the simulation + sim.run_simulation() + + # get the groundwater model and determine the size of the model grid + gwf_name = list(sim.model_names)[0] + gwf = sim.get_model(gwf_name) + nnodes, shape3d = gwf.modelgrid.nnodes, gwf.modelgrid.shape + + # get the cell by cell object + cbc = gwf.output.budget() + + # evaluate the full3D option + cbc_eval(cbc, nnodes, shape3d, gwf.modelgrid) + + # clean the run + clean_run(name) + + return + + +def mf2005_eval(name, ws_in): + ml = load_mf2005(name, ws_in) + + # write the model + ml.write_input() + + # run the model + ml.run_model() + + # determine the size of the model grid + nnodes, shape3d = ml.modelgrid.nnodes, ml.modelgrid.shape + + # get the cell by cell object + fpth = os.path.join(tpth, name, f"{name}.cbc") + cbc = flopy.utils.CellBudgetFile(fpth) + + # evaluate the full3D option + cbc_eval(cbc, nnodes, shape3d, ml.modelgrid) + + # clean the run + clean_run(name) + + +def test_cbc_full3D(): + for (name, ismf6, ws_in) in zip(names, ismf6_lst, ex_pths): + if ismf6: + yield mf6_eval, name, ws_in + else: + yield mf2005_eval, name, ws_in + + +def main(): + for (name, ismf6, ws_in) in zip(names, ismf6_lst, ex_pths): + if ismf6: + mf6_eval(name, ws_in) + else: + mf2005_eval(name, ws_in) + + +if __name__ == "__main__": + main() diff --git a/autotest/t505_test.py b/autotest/t505_test.py index 792d206be7..ec914b26a9 100644 --- a/autotest/t505_test.py +++ b/autotest/t505_test.py @@ -139,11 +139,11 @@ def test_np001(): filename="old_name.ims", print_option="ALL", complexity="SIMPLE", - outer_hclose=0.00001, + outer_dvclose=0.00001, outer_maximum=10, under_relaxation="NONE", inner_maximum=10, - inner_hclose=0.001, + inner_dvclose=0.001, linear_acceleration="CG", preconditioner_levels=2, preconditioner_drop_tolerance=0.00001, @@ -156,11 +156,11 @@ def test_np001(): filename=f"{test_ex_name}.ims", print_option="ALL", complexity="SIMPLE", - outer_hclose=0.00001, + outer_dvclose=0.00001, outer_maximum=50, under_relaxation="NONE", inner_maximum=30, - inner_hclose=0.00001, + inner_dvclose=0.00001, linear_acceleration="CG", preconditioner_levels=7, preconditioner_drop_tolerance=0.01, @@ -415,7 +415,8 @@ def test_np001(): assert pymake.compare_heads( None, None, files1=head_file, files2=head_new, outfile=outfile ) - budget_frf = sim.simulation_data.mfdata[(model_name, "CBC", "RIV")] + # budget_frf = sim.simulation_data.mfdata[(model_name, "CBC", "RIV")] + budget_frf = model.output.budget().get_data(text="RIV", full3D=False) assert array_util.riv_array_comp(budget_frf_valid, budget_frf) # clean up @@ -451,7 +452,8 @@ def test_np001(): None, None, files1=head_file, files2=head_new, outfile=outfile ) - budget_frf = sim.simulation_data.mfdata[(model_name, "CBC", "RIV")] + # budget_frf = sim.simulation_data.mfdata[(model_name, "CBC", "RIV")] + budget_frf = model.output.budget().get_data(text="RIV", full3D=False) assert array_util.riv_array_comp(budget_frf_valid, budget_frf) # clean up @@ -660,11 +662,11 @@ def test_np002(): sim, print_option="ALL", complexity="SIMPLE", - outer_hclose=0.00001, + outer_dvclose=0.00001, outer_maximum=50, under_relaxation="NONE", inner_maximum=30, - inner_hclose=0.00001, + inner_dvclose=0.00001, linear_acceleration="CG", preconditioner_levels=7, preconditioner_drop_tolerance=0.01, @@ -909,11 +911,11 @@ def test021_twri(): ims_package = ModflowIms( sim, print_option="SUMMARY", - outer_hclose=0.0001, + outer_dvclose=0.0001, outer_maximum=500, under_relaxation="NONE", inner_maximum=100, - inner_hclose=0.0001, + inner_dvclose=0.0001, rcloserecord=0.001, linear_acceleration="CG", scaling_method="NONE", @@ -1137,11 +1139,11 @@ def test005_advgw_tidal(): sim, print_option="SUMMARY", complexity="SIMPLE", - outer_hclose=0.0001, + outer_dvclose=0.0001, outer_maximum=500, under_relaxation="NONE", inner_maximum=100, - inner_hclose=0.0001, + inner_dvclose=0.0001, rcloserecord=0.001, linear_acceleration="CG", scaling_method="NONE", @@ -1741,11 +1743,11 @@ def test004_bcfss(): print_option="ALL", csv_output_filerecord="bcf2ss.ims.csv", complexity="SIMPLE", - outer_hclose=0.000001, + outer_dvclose=0.000001, outer_maximum=500, under_relaxation="NONE", inner_maximum=100, - inner_hclose=0.000001, + inner_dvclose=0.000001, rcloserecord=0.001, linear_acceleration="CG", scaling_method="NONE", @@ -1895,11 +1897,11 @@ def test035_fhb(): sim, print_option="SUMMARY", complexity="SIMPLE", - outer_hclose=0.001, + outer_dvclose=0.001, outer_maximum=120, under_relaxation="NONE", inner_maximum=100, - inner_hclose=0.0001, + inner_dvclose=0.0001, rcloserecord=0.1, linear_acceleration="CG", preconditioner_levels=7, @@ -2037,11 +2039,11 @@ def test006_gwf3_disv(): ims_package = ModflowIms( sim, print_option="SUMMARY", - outer_hclose=0.00000001, + outer_dvclose=0.00000001, outer_maximum=1000, under_relaxation="NONE", inner_maximum=1000, - inner_hclose=0.00000001, + inner_dvclose=0.00000001, rcloserecord=0.01, linear_acceleration="BICGSTAB", scaling_method="NONE", @@ -2333,11 +2335,11 @@ def test006_2models_gnc(): ims_package = ModflowIms( sim, print_option="SUMMARY", - outer_hclose=0.00000001, + outer_dvclose=0.00000001, outer_maximum=1000, under_relaxation="NONE", inner_maximum=1000, - inner_hclose=0.00000001, + inner_dvclose=0.00000001, rcloserecord=0.01, linear_acceleration="BICGSTAB", scaling_method="NONE", @@ -2669,11 +2671,11 @@ def test050_circle_island(): ims_package = ModflowIms( sim, print_option="SUMMARY", - outer_hclose=0.000001, + outer_dvclose=0.000001, outer_maximum=500, under_relaxation="NONE", inner_maximum=1000, - inner_hclose=0.000001, + inner_dvclose=0.000001, rcloserecord=0.000001, linear_acceleration="BICGSTAB", relaxation_factor=0.0, @@ -2777,7 +2779,7 @@ def test028_sfr(): ims_package = ModflowIms( sim, print_option="SUMMARY", - outer_hclose=0.00001, + outer_dvclose=0.00001, outer_maximum=100, under_relaxation="DBD", under_relaxation_theta=0.85, @@ -2788,7 +2790,7 @@ def test028_sfr(): backtracking_tolerance=1.1, backtracking_reduction_factor=0.7, backtracking_residual_limit=1.0, - inner_hclose=0.00001, + inner_dvclose=0.00001, rcloserecord=0.1, inner_maximum=100, linear_acceleration="CG", diff --git a/examples/data/mf6/test001a_Tharmonic/flow15.ims b/examples/data/mf6/test001a_Tharmonic/flow15.ims index 72a5dc1b9a..7a03edd57b 100644 --- a/examples/data/mf6/test001a_Tharmonic/flow15.ims +++ b/examples/data/mf6/test001a_Tharmonic/flow15.ims @@ -6,21 +6,21 @@ BEGIN OPTIONS END OPTIONS BEGIN NONLINEAR - OUTER_HCLOSE 0.99999997E-05 + OUTER_DVCLOSE 0.99999997E-05 OUTER_MAXIMUM 50 UNDER_RELAXATION NONE END NONLINEAR BEGIN LINEAR INNER_MAXIMUM 30 - INNER_HCLOSE 0.10000000E-05 + INNER_DVCLOSE 0.10000000E-05 INNER_RCLOSE 0.99999997E-05 LINEAR_ACCELERATION CG END LINEAR BEGIN XMD INNER_MAXIMUM 30 - INNER_HCLOSE 0.10000000E-05 + INNER_DVCLOSE 0.10000000E-05 LINEAR_ACCELERATION CG PRECONDITIONER_LEVELS 7 PRECONDITIONER_DROP_TOLERANCE 0.10000000E-02 diff --git a/examples/data/mf6/test001e_UZF_3lay/test001e_UZF_3lay.ims b/examples/data/mf6/test001e_UZF_3lay/test001e_UZF_3lay.ims index 5004d3f9f6..0d0e8b638c 100644 --- a/examples/data/mf6/test001e_UZF_3lay/test001e_UZF_3lay.ims +++ b/examples/data/mf6/test001e_UZF_3lay/test001e_UZF_3lay.ims @@ -6,14 +6,14 @@ BEGIN Options END Options BEGIN Nonlinear - OUTER_HCLOSE 1.E-06 + OUTER_DVCLOSE 1.E-06 OUTER_MAXIMUM 100 UNDER_RELAXATION dbd END Nonlinear BEGIN LINEAR INNER_MAXIMUM 50 - INNER_HCLOSE 1.E-09 + INNER_DVCLOSE 1.E-09 INNER_RCLOSE 1.E-05 LINEAR_ACCELERATION BICGSTAB END LINEAR diff --git a/examples/data/mf6/test003_gwfs_disv/model.ims b/examples/data/mf6/test003_gwfs_disv/model.ims index 19d342427b..23020b0b3f 100644 --- a/examples/data/mf6/test003_gwfs_disv/model.ims +++ b/examples/data/mf6/test003_gwfs_disv/model.ims @@ -3,13 +3,13 @@ begin options end options begin nonlinear - outer_hclose 1.e-4 - outer_maximum 500 + OUTER_DVCLOSE 1.e-4 + outer_maximum 500 under_relaxation none end nonlinear begin linear - inner_hclose 1.0e-4 + INNER_DVCLOSE 1.0e-4 inner_rclose 0.001 #L2NORM_RCLOSE inner_maximum 100 @@ -28,13 +28,13 @@ end linear 1.0E-4 1.0E-4 500 100 1 0 001 #hclose, hiclose,mxiter,iter1,iprsms,nonmeth,linmeth 2 0 0 2 0 0 0 1e-3 -IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN +IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN 0.0001 0.0001 500 100 1 0 1 2 0 0 2 0 0 0 1e-3 -IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN +IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN 0.0001 0.0001 500 100 1 0 5 3 0 0 100000 diff --git a/examples/data/mf6/test003_gwftri_disv/model.ims b/examples/data/mf6/test003_gwftri_disv/model.ims index 19d342427b..23020b0b3f 100644 --- a/examples/data/mf6/test003_gwftri_disv/model.ims +++ b/examples/data/mf6/test003_gwftri_disv/model.ims @@ -3,13 +3,13 @@ begin options end options begin nonlinear - outer_hclose 1.e-4 - outer_maximum 500 + OUTER_DVCLOSE 1.e-4 + outer_maximum 500 under_relaxation none end nonlinear begin linear - inner_hclose 1.0e-4 + INNER_DVCLOSE 1.0e-4 inner_rclose 0.001 #L2NORM_RCLOSE inner_maximum 100 @@ -28,13 +28,13 @@ end linear 1.0E-4 1.0E-4 500 100 1 0 001 #hclose, hiclose,mxiter,iter1,iprsms,nonmeth,linmeth 2 0 0 2 0 0 0 1e-3 -IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN +IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN 0.0001 0.0001 500 100 1 0 1 2 0 0 2 0 0 0 1e-3 -IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN +IACL NORDER LEVEL NORTH IREDSYS RRCTOL IDROPTOL EPSRN 0.0001 0.0001 500 100 1 0 5 3 0 0 100000 diff --git a/examples/data/mf6/test005_advgw_tidal/model.ims b/examples/data/mf6/test005_advgw_tidal/model.ims index a4a285c6ad..36e547e2a8 100644 --- a/examples/data/mf6/test005_advgw_tidal/model.ims +++ b/examples/data/mf6/test005_advgw_tidal/model.ims @@ -4,14 +4,14 @@ BEGIN options END options BEGIN nonlinear - OUTER_HCLOSE 0.0001 + OUTER_DVCLOSE 0.0001 OUTER_MAXIMUM 500 UNDER_RELAXATION none END nonlinear BEGIN linear INNER_MAXIMUM 100 - INNER_HCLOSE 0.0001 + INNER_DVCLOSE 0.0001 inner_rclose 0.001 LINEAR_ACCELERATION cg RELAXATION_FACTOR 0.97 diff --git a/examples/data/mf6/test006_2models_mvr/simulation.ims b/examples/data/mf6/test006_2models_mvr/simulation.ims index ed52ca4f2a..6a15577531 100644 --- a/examples/data/mf6/test006_2models_mvr/simulation.ims +++ b/examples/data/mf6/test006_2models_mvr/simulation.ims @@ -3,13 +3,13 @@ begin options end options begin nonlinear - outer_hclose 1.e-8 - outer_maximum 1000 + OUTER_DVCLOSE 1.e-8 + outer_maximum 1000 under_relaxation none end nonlinear begin linear - inner_hclose 1.0e-8 + INNER_DVCLOSE 1.0e-8 inner_rclose 0.01 inner_maximum 1000 linear_acceleration bicgstab diff --git a/examples/data/mf6/test006_gwf3/flow.ims b/examples/data/mf6/test006_gwf3/flow.ims index d8045187ee..f01fd7a923 100644 --- a/examples/data/mf6/test006_gwf3/flow.ims +++ b/examples/data/mf6/test006_gwf3/flow.ims @@ -3,13 +3,13 @@ begin options end options begin nonlinear - outer_hclose 1.e-8 - outer_maximum 1000 + OUTER_DVCLOSE 1.e-8 + outer_maximum 1000 under_relaxation none end nonlinear begin linear - inner_hclose 1.0e-8 + INNER_DVCLOSE 1.0e-8 inner_rclose 0.01 inner_maximum 1000 linear_acceleration cg diff --git a/examples/data/mf6/test027_TimeseriesTest/model.ims b/examples/data/mf6/test027_TimeseriesTest/model.ims index b1ab693de6..55c527ebbf 100644 --- a/examples/data/mf6/test027_TimeseriesTest/model.ims +++ b/examples/data/mf6/test027_TimeseriesTest/model.ims @@ -3,8 +3,8 @@ begin options end options begin nonlinear - outer_hclose 1.e-9 - outer_maximum 50 + OUTER_DVCLOSE 1.e-9 + outer_maximum 50 under_relaxation none under_relaxation_theta 0.9 under_relaxation_kappa 0.100000E-03 @@ -18,7 +18,7 @@ end nonlinear begin linear - inner_hclose 1.0e-9 + INNER_DVCLOSE 1.0e-9 inner_rclose 0.001 inner_maximum 100 linear_acceleration cg diff --git a/examples/data/mf6/test036_twrihfb/twrihfb2015.ims b/examples/data/mf6/test036_twrihfb/twrihfb2015.ims index eca52e9732..2ecae27927 100644 --- a/examples/data/mf6/test036_twrihfb/twrihfb2015.ims +++ b/examples/data/mf6/test036_twrihfb/twrihfb2015.ims @@ -6,14 +6,14 @@ BEGIN Options END Options BEGIN Nonlinear - OUTER_HCLOSE 0.10000000E-02 + OUTER_DVCLOSE 0.10000000E-02 OUTER_MAXIMUM 50 UNDER_RELAXATION NONE END Nonlinear BEGIN LINEAR INNER_MAXIMUM 100 - INNER_HCLOSE 0.10000000E-03 - INNER_RCLOSE 0.10000000 + INNER_DVCLOSE 0.10000000E-03 + INNER_RCLOSE 0.10000000 LINEAR_ACCELERATION CG END LINEAR diff --git a/examples/data/mf6/test045_lake1ss_table/lakeex1b.ims b/examples/data/mf6/test045_lake1ss_table/lakeex1b.ims index a842a21936..cc8719a394 100644 --- a/examples/data/mf6/test045_lake1ss_table/lakeex1b.ims +++ b/examples/data/mf6/test045_lake1ss_table/lakeex1b.ims @@ -3,7 +3,7 @@ BEGIN Options END Options BEGIN Nonlinear - OUTER_HCLOSE 0.0001 + OUTER_DVCLOSE 0.0001 OUTER_MAXIMUM 500 UNDER_RELAXATION none UNDER_RELAXATION_THETA 0.0 @@ -14,7 +14,7 @@ END Nonlinear BEGIN LINEAR INNER_MAXIMUM 100 - INNER_HCLOSE 0.0001 + INNER_DVCLOSE 0.0001 INNER_RCLOSE 0.1 LINEAR_ACCELERATION cg RELAXATION_FACTOR 1.0 diff --git a/examples/data/mf6/test045_lake2tr/lakeex2a.ims b/examples/data/mf6/test045_lake2tr/lakeex2a.ims index c67b4b46a3..708a04115c 100644 --- a/examples/data/mf6/test045_lake2tr/lakeex2a.ims +++ b/examples/data/mf6/test045_lake2tr/lakeex2a.ims @@ -6,18 +6,18 @@ BEGIN Options END Options BEGIN Nonlinear - OUTER_HCLOSE 1e-4 + OUTER_DVCLOSE 1e-4 OUTER_MAXIMUM 500 UNDER_RELAXATION NONE - UNDER_RELAXATION_THETA 0.000000 - UNDER_RELAXATION_KAPPA 0.000000 - UNDER_RELAXATION_GAMMA 0.000000 - UNDER_RELAXATION_MOMENTUM 0.000000 + UNDER_RELAXATION_THETA 0.000000 + UNDER_RELAXATION_KAPPA 0.000000 + UNDER_RELAXATION_GAMMA 0.000000 + UNDER_RELAXATION_MOMENTUM 0.000000 END Nonlinear BEGIN LINEAR INNER_MAXIMUM 100 - INNER_HCLOSE 1e-4 + INNER_DVCLOSE 1e-4 INNER_RCLOSE 1e-3 LINEAR_ACCELERATION CG #PRECONDITIONER_LEVELS 7 diff --git a/flopy/export/netcdf.py b/flopy/export/netcdf.py index d919e9ad81..7202995936 100644 --- a/flopy/export/netcdf.py +++ b/flopy/export/netcdf.py @@ -59,7 +59,7 @@ def __init__(self, filename, echo=False): elif filename: self.f = open(filename, "w", 0) # unbuffered self.t = datetime.now() - self.log("opening " + str(filename) + " for logging") + self.log(f"opening {filename} for logging") else: self.filename = None @@ -73,21 +73,18 @@ def log(self, phrase): the thing that happened """ - pass t = datetime.now() if phrase in self.items.keys(): - s = f"{t} finished: {phrase}, took: {t - self.items[phrase]}\n" + t0 = self.items.pop(phrase) + s = f"{t} finished: {phrase}, took: {t - t0}\n" if self.echo: - print(s) + print(s, end="") if self.filename: self.f.write(s) - self.items.pop(phrase) else: - s = str(t) + " starting: " + str(phrase) + "\n" + s = f"{t} starting: {phrase}\n" if self.echo: - print( - s, - ) + print(s, end="") if self.filename: self.f.write(s) self.items[phrase] = copy.deepcopy(t) @@ -102,11 +99,9 @@ def warn(self, message): the warning text """ - s = str(datetime.now()) + " WARNING: " + message + "\n" + s = f"{datetime.now()} WARNING: {message}\n" if self.echo: - print( - s, - ) + print(s, end="") if self.filename: self.f.write(s) return @@ -195,23 +190,21 @@ def __init__( try: import dateutil.parser - except: - print( + except ImportError: + raise ImportError( "python-dateutil is not installed\n" "try pip install python-dateutil" ) - return - self.start_datetime = self._dt_str( - dateutil.parser.parse(self.model_time.start_datetime) - ) - self.logger.warn(f"start datetime:{self.start_datetime!s}") + dt = dateutil.parser.parse(self.model_time.start_datetime) + self.start_datetime = dt.strftime("%Y-%m-%dT%H:%M:%SZ") + self.logger.log(f"start datetime:{self.start_datetime}") proj4_str = self.model_grid.proj4 if proj4_str is None: proj4_str = "epsg:4326" - self.log( - "Warning: model has no coordinate reference system specified. " + self.logger.warn( + "model has no coordinate reference system specified. " f"Using default proj4 string: {proj4_str}" ) self.proj4_str = proj4_str @@ -237,6 +230,14 @@ def __init__( self.initialize_file(time_values=self.time_values_arg) self.log("initializing file") + def __enter__(self): + """Enter context with statement, returning with an open dataset.""" + return self + + def __exit__(self, *exc): + """Exit context with statement, write and close dataset.""" + self.write() + def __add__(self, other): new_net = NetCdf.zeros_like(self) if np.isscalar(other) or isinstance(other, np.ndarray): @@ -253,6 +254,7 @@ def __add__(self, other): raise Exception( f"NetCdf.__add__(): unrecognized other:{type(other)}" ) + new_net.nc.sync() return new_net def __sub__(self, other): @@ -271,6 +273,7 @@ def __sub__(self, other): raise Exception( f"NetCdf.__sub__(): unrecognized other:{type(other)}" ) + new_net.nc.sync() return new_net def __mul__(self, other): @@ -289,6 +292,7 @@ def __mul__(self, other): raise Exception( f"NetCdf.__mul__(): unrecognized other:{type(other)}" ) + new_net.nc.sync() return new_net def __div__(self, other): @@ -312,7 +316,8 @@ def __truediv__(self, other): raise Exception( f"NetCdf.__sub__(): unrecognized other:{type(other)}" ) - return new_net + new_net.nc.sync() + return new_net def append(self, other, suffix="_1"): assert isinstance(other, NetCdf) or isinstance(other, dict) @@ -367,13 +372,14 @@ def append(self, other, suffix="_1"): new_var[:] = array except: new_var[:, 0] = array - + self.nc.sync() return def copy(self, output_filename): new_net = NetCdf.zeros_like(self, output_filename=output_filename) for vname in self.var_attr_dict.keys(): new_net.nc.variables[vname][:] = self.nc.variables[vname][:] + new_net.nc.sync() return new_net @classmethod @@ -416,6 +422,7 @@ def zeros_like( if attr not in new_net.nc.ncattrs(): global_attrs[attr] = other.nc[attr] new_net.add_global_attributes(global_attrs) + new_net.nc.sync() return new_net @classmethod @@ -483,10 +490,9 @@ def difference( ), "can't call difference() if nc hasn't been populated" try: import netCDF4 - except Exception as e: - mess = f"error import netCDF4: {e!s}" - self.logger.warn(mess) - raise Exception(mess) + except ImportError as e: + self.logger.warn("error importing netCDF module") + raise ImportError("NetCdf error importing netCDF4 module") from e if isinstance(other, str): assert os.path.exists(other), f"filename 'other' not found:{other}" @@ -600,14 +606,7 @@ def difference( var[:] = d_data self.log(f"processing variable {vname}") - - def _dt_str(self, dt): - """for datetime to string for year < 1900""" - dt_str = ( - f"{dt.year:04d}-{dt.month:02d}-{dt.day:02d}T" - f"{dt.hour:02d}:{dt.minute:02d}:{dt.second:02}Z" - ) - return dt_str + new_net.nc.sync() def write(self): """write the nc object to disk""" @@ -622,8 +621,8 @@ def write(self): try: if self.nc.attributes.get(k) is not None: self.nc.setncattr(k, v) - except Exception: - self.logger.warn(f"error setting global attribute {k}") + except Exception as e: + self.logger.warn(f"error setting global attribute {k}: {e!s}") self.nc.sync() self.nc.close() @@ -687,9 +686,7 @@ def initialize_geometry(self): try: import pyproj except ImportError as e: - raise ImportError( - "NetCdf error importing pyproj module:\n" + str(e) - ) + raise ImportError("NetCdf error importing pyproj module") from e from distutils.version import LooseVersion # Check if using newer pyproj version conventions @@ -775,17 +772,15 @@ def initialize_file(self, time_values=None): self.log("initializing geometry") try: import netCDF4 - except Exception as e: + except ImportError as e: self.logger.warn("error importing netCDF module") - msg = "NetCdf error importing netCDF4 module:\n" + str(e) - raise Exception(msg) + raise ImportError("NetCdf error importing netCDF4 module") from e # open the file for writing try: self.nc = netCDF4.Dataset(self.output_filename, "w") except Exception as e: - msg = f"error creating netcdf dataset:\n{e!s}" - raise Exception(msg) + raise Exception("error creating netcdf dataset") from e # write some attributes self.log("setting standard attributes") @@ -795,7 +790,7 @@ def initialize_file(self, time_values=None): f"CF-1.6, ACDD-1.3, flopy {flopy.__version__}", ) self.nc.setncattr( - "date_created", datetime.utcnow().strftime("%Y-%m-%dT%H:%M:00Z") + "date_created", datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ") ) self.nc.setncattr("geospatial_vertical_positive", str(self.z_positive)) min_vertical = np.min(self.zs) @@ -807,8 +802,8 @@ def initialize_file(self, time_values=None): for k, v in self.global_attributes.items(): try: self.nc.setncattr(k, v) - except: - self.logger.warn(f"error setting global attribute {k}") + except Exception as e: + self.logger.warn(f"error setting global attribute {k}: {e!s}") self.global_attributes = {} self.log("setting standard attributes") @@ -1002,6 +997,7 @@ def initialize_file(self, time_values=None): exp.existingDataField = "elevation" exp._CoordinateTransformType = "vertical" exp._CoordinateAxes = "layer" + self.nc.sync() return def initialize_group( @@ -1129,6 +1125,7 @@ def initialize_group( dimensions=dim_names, ) var[:] = np.asarray(dimension_data[dim]) + self.nc.sync() @staticmethod def normalize_name(name): @@ -1212,11 +1209,13 @@ def create_group_variable( for k, v in attributes.items(): try: var.setncattr(k, v) - except: + except Exception as e: self.logger.warn( - f"error setting attribute{k} for group {group} variable {name}" + "error setting attribute " + f"{k} for group {group} variable {name}: {e!s}" ) self.log(f"creating group {group} variable: {name}") + self.nc.sync() return var @@ -1275,7 +1274,7 @@ def create_variable( if name in self.nc.variables.keys(): raise Exception(f"duplicate variable name: {name}") - self.log("creating variable: " + str(name)) + self.log(f"creating variable: {name}") assert ( precision_str in PRECISION_STRS ), "netcdf.create_variable() error: precision string {0} not in {1}".format( @@ -1310,11 +1309,12 @@ def create_variable( for k, v in attributes.items(): try: var.setncattr(k, v) - except: + except Exception as e: self.logger.warn( - f"error setting attribute{k} for variable {name}" + f"error setting attribute{k} for variable {name}: {e!s}" ) - self.log("creating variable: " + str(name)) + self.log(f"creating variable: {name}") + self.nc.sync() return var def add_global_attributes(self, attr_dict): @@ -1346,6 +1346,7 @@ def add_global_attributes(self, attr_dict): self.log("setting global attributes") self.nc.setncatts(attr_dict) self.log("setting global attributes") + self.nc.sync() def add_sciencebase_metadata(self, id, check=True): """Add metadata from ScienceBase using the diff --git a/flopy/export/utils.py b/flopy/export/utils.py index 150a2a9183..ec3a859803 100644 --- a/flopy/export/utils.py +++ b/flopy/export/utils.py @@ -1519,7 +1519,7 @@ def export_array( if rotate is not None: a = rotate(a, modelgrid.angrot, cval=nodata) height_rot, width_rot = a.shape - xmin, ymin, xmax, ymax = modelgrid.extent + xmin, xmax, ymin, ymax = modelgrid.extent dx = (xmax - xmin) / width_rot dy = (ymax - ymin) / height_rot cellsize = np.max((dx, dy)) diff --git a/flopy/mbase.py b/flopy/mbase.py index 660042f119..84cd443ebc 100644 --- a/flopy/mbase.py +++ b/flopy/mbase.py @@ -1081,7 +1081,6 @@ class Obj: fake_package = Obj() fake_package.write_file = lambda: None - fake_package.extra = [""] fake_package.name = [ptype] fake_package.extension = [filename.split(".")[-1]] fake_package.unit_number = [self.next_ext_unit()] @@ -1108,8 +1107,6 @@ def get_name_file_entries(self): if p.unit_number[i] == 0: continue s = f"{p.name[i]:14s} {p.unit_number[i]:5d} {p.file_name[i]}" - if p.extra[i]: - s += " " + p.extra[i] lines.append(s) return "\n".join(lines) + "\n" diff --git a/flopy/modflow/mf.py b/flopy/modflow/mf.py index 05438cd453..d709fac22d 100644 --- a/flopy/modflow/mf.py +++ b/flopy/modflow/mf.py @@ -23,7 +23,7 @@ class ModflowGlobal(Package): """ def __init__(self, model, extension="glo"): - Package.__init__(self, model, extension, "GLOBAL", 1) + super().__init__(model, extension, "GLOBAL", 1) return def __repr__(self): @@ -41,7 +41,7 @@ class ModflowList(Package): """ def __init__(self, model, extension="list", unitnumber=2): - Package.__init__(self, model, extension, "LIST", unitnumber) + super().__init__(model, extension, "LIST", unitnumber) return def __repr__(self): diff --git a/flopy/modflow/mfaddoutsidefile.py b/flopy/modflow/mfaddoutsidefile.py index 0450894aab..a5cbcd7b01 100644 --- a/flopy/modflow/mfaddoutsidefile.py +++ b/flopy/modflow/mfaddoutsidefile.py @@ -8,9 +8,10 @@ class mfaddoutsidefile(Package): """ def __init__(self, model, name, extension, unitnumber): - Package.__init__( - self, model, extension, name, unitnumber, allowDuplicates=True - ) # Call ancestor's init to set self.parent, extension, name and unit number + # call base package constructor + super().__init__( + model, extension, name, unitnumber, allowDuplicates=True + ) self.parent.add_package(self) def __repr__(self): diff --git a/flopy/modflow/mfag.py b/flopy/modflow/mfag.py index 6499af5f63..9db3485836 100644 --- a/flopy/modflow/mfag.py +++ b/flopy/modflow/mfag.py @@ -203,25 +203,13 @@ def __init__( if unitnumber is None: unitnumber = ModflowAg._defaultunit() - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - name = [ModflowAg._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - + # call base package constructor super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # set up class diff --git a/flopy/modflow/mfbas.py b/flopy/modflow/mfbas.py index 1d81b29d5f..6a54c87a01 100644 --- a/flopy/modflow/mfbas.py +++ b/flopy/modflow/mfbas.py @@ -102,37 +102,17 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ if unitnumber is None: unitnumber = ModflowBas._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowBas._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self.url = "bas6.htm" diff --git a/flopy/modflow/mfbcf.py b/flopy/modflow/mfbcf.py index 2bb1b1d3e0..3d54c5154f 100644 --- a/flopy/modflow/mfbcf.py +++ b/flopy/modflow/mfbcf.py @@ -117,43 +117,26 @@ def __init__( ): if unitnumber is None: - unitnumber = ModflowBcf._defaultunit() + unitnumber = self._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowBcf._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowBcf._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self.url = "bcf.htm" diff --git a/flopy/modflow/mfbct.py b/flopy/modflow/mfbct.py index bde549876c..73223e0d78 100644 --- a/flopy/modflow/mfbct.py +++ b/flopy/modflow/mfbct.py @@ -42,11 +42,8 @@ def __init__( if unitnumber is None: unitnumber = ModflowBct._defaultunit() - # Call ancestor's init to set self.parent, extension, name and unit - # number - Package.__init__( - self, model, extension, ModflowBct._ftype(), unitnumber - ) + # call base package constructor + super().__init__(model, extension, self._ftype(), unitnumber) self.url = "bct.htm" nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper diff --git a/flopy/modflow/mfchd.py b/flopy/modflow/mfchd.py index d8cb1b7432..74ba5a1927 100644 --- a/flopy/modflow/mfchd.py +++ b/flopy/modflow/mfchd.py @@ -116,29 +116,13 @@ def __init__( if unitnumber is None: unitnumber = ModflowChd._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowChd._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self.url = "chd.htm" diff --git a/flopy/modflow/mfde4.py b/flopy/modflow/mfde4.py index 97a9c7e280..16bf50c56c 100644 --- a/flopy/modflow/mfde4.py +++ b/flopy/modflow/mfde4.py @@ -127,38 +127,18 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowDe4._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowDe4._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # check if a valid model version has been specified diff --git a/flopy/modflow/mfdis.py b/flopy/modflow/mfdis.py index a4c4df0792..19d96ba9b6 100644 --- a/flopy/modflow/mfdis.py +++ b/flopy/modflow/mfdis.py @@ -149,29 +149,13 @@ def __init__( if unitnumber is None: unitnumber = ModflowDis._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowDis._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self.url = "dis.htm" diff --git a/flopy/modflow/mfdrn.py b/flopy/modflow/mfdrn.py index ee68943907..0c0bd5b083 100644 --- a/flopy/modflow/mfdrn.py +++ b/flopy/modflow/mfdrn.py @@ -124,19 +124,12 @@ def __init__( unitnumber = ModflowDrn._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowDrn._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 @@ -151,22 +144,15 @@ def __init__( if self.is_drt: name = ["DRT"] else: - name = [ModflowDrn._ftype()] - units = [unitnumber] - extra = [""] + name = [self._ftype()] - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, name=name, - unit_number=units, - extra=extra, - filenames=fname, + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfdrt.py b/flopy/modflow/mfdrt.py index 7540761bbb..dc339af35f 100644 --- a/flopy/modflow/mfdrt.py +++ b/flopy/modflow/mfdrt.py @@ -122,19 +122,12 @@ def __init__( unitnumber = ModflowDrt._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowDrt._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 @@ -149,22 +142,13 @@ def __init__( if not found: options.append("RETURNFLOW") - name = [ModflowDrt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfevt.py b/flopy/modflow/mfevt.py index 44d3a7c181..1ab8c05875 100644 --- a/flopy/modflow/mfevt.py +++ b/flopy/modflow/mfevt.py @@ -103,40 +103,23 @@ def __init__( unitnumber = ModflowEvt._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowEvt._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowEvt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper diff --git a/flopy/modflow/mffhb.py b/flopy/modflow/mffhb.py index 5d7f7c5dbc..029499ce68 100644 --- a/flopy/modflow/mffhb.py +++ b/flopy/modflow/mffhb.py @@ -160,40 +160,23 @@ def __init__( unitnumber = ModflowFhb._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowFhb._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowFhb._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfflwob.py b/flopy/modflow/mfflwob.py index a8c8a2aec1..7c64a4bfe7 100755 --- a/flopy/modflow/mfflwob.py +++ b/flopy/modflow/mfflwob.py @@ -130,9 +130,6 @@ def __init__( unitnumber=None, ): - """ - Package constructor - """ if nqobfb is None: nqobfb = [] if nqclfb is None: @@ -216,24 +213,14 @@ def __init__( unitnumber = [unitnumber[0], outunits[name[0].lower()]] iufbobsv = unitnumber[1] - # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) - # call base package constructor - Package.__init__( - self, + super().__init__( model, extension=extension, name=name, unit_number=unitnumber, allowDuplicates=True, - filenames=filenames, + filenames=self._prepare_filenames(filenames, 2), ) self.nqfb = nqfb diff --git a/flopy/modflow/mfgage.py b/flopy/modflow/mfgage.py index f4958b618a..3d32c6b7a2 100644 --- a/flopy/modflow/mfgage.py +++ b/flopy/modflow/mfgage.py @@ -88,26 +88,16 @@ def __init__( filenames=None, **kwargs, ): - """ - Package constructor. - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowGage._defaultunit() # set filenames - if filenames is None: - filenames = [None for x in range(numgage + 1)] - elif isinstance(filenames, str): - filenames = [filenames] + [None for x in range(numgage)] - elif isinstance(filenames, list): - if len(filenames) < numgage + 1: - for idx in range(len(filenames), numgage + 2): - filenames.append(None) + filenames = self._prepare_filenames(filenames, numgage + 1) # process gage output files - dtype = ModflowGage.get_default_dtype() + dtype = self.get_default_dtype() if numgage > 0: # check the provided file entries if filenames[1] is None: @@ -172,32 +162,20 @@ def __init__( # add gage output files to model for n in range(numgage): - iu = abs(gage_data["unit"][n]) - fname = files[n] model.add_output_file( - iu, - fname=fname, + abs(gage_data["unit"][n]), + fname=files[n], binflag=False, - package=ModflowGage._ftype(), + package=self._ftype(), ) - # Fill namefile items - name = [ModflowGage._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) # no heading for this format diff --git a/flopy/modflow/mfghb.py b/flopy/modflow/mfghb.py index d5b7308105..019aceb728 100644 --- a/flopy/modflow/mfghb.py +++ b/flopy/modflow/mfghb.py @@ -116,50 +116,29 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowGhb._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowGhb._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowGhb._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfgmg.py b/flopy/modflow/mfgmg.py index 6e6e48c51b..4007475c2a 100644 --- a/flopy/modflow/mfgmg.py +++ b/flopy/modflow/mfgmg.py @@ -205,54 +205,33 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowGmg._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with gmg output, if necessary if iunitmhc is not None: - fname = filenames[1] model.add_output_file( iunitmhc, - fname=fname, + fname=filenames[1], extension="gmg.out", binflag=False, - package=ModflowGmg._ftype(), + package=self._ftype(), ) else: iunitmhc = 0 - # Fill namefile items - name = [ModflowGmg._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) # check if a valid model version has been specified diff --git a/flopy/modflow/mfhfb.py b/flopy/modflow/mfhfb.py index 9670703af9..c9cf3d5cf9 100644 --- a/flopy/modflow/mfhfb.py +++ b/flopy/modflow/mfhfb.py @@ -117,29 +117,13 @@ def __init__( if unitnumber is None: unitnumber = ModflowHfb._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowHfb._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() diff --git a/flopy/modflow/mfhob.py b/flopy/modflow/mfhob.py index 85e53d8a27..b4e1de3d7c 100755 --- a/flopy/modflow/mfhob.py +++ b/flopy/modflow/mfhob.py @@ -93,21 +93,12 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowHob._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # set filenames[1] to hobname if filenames[1] is not None if filenames[1] is None: @@ -115,35 +106,23 @@ def __init__( filenames[1] = hobname if iuhobsv is not None: - fname = filenames[1] model.add_output_file( iuhobsv, - fname=fname, + fname=filenames[1], extension="hob.out", binflag=False, - package=ModflowHob._ftype(), + package=self._ftype(), ) else: iuhobsv = 0 - # Fill namefile items - name = [ModflowHob._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, - # extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self.url = "hob.htm" diff --git a/flopy/modflow/mfhyd.py b/flopy/modflow/mfhyd.py index 5c3fc9c964..8e65553571 100644 --- a/flopy/modflow/mfhyd.py +++ b/flopy/modflow/mfhyd.py @@ -120,54 +120,33 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowHyd._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # set ihydun to a default unit number if it isn't specified if ihydun is None: ihydun = 536 # update external file information with hydmod output - fname = filenames[1] model.add_output_file( ihydun, - fname=fname, + fname=filenames[1], extension="hyd.bin", - package=ModflowHyd._ftype(), + package=self._ftype(), ) - # Fill namefile items - name = [ModflowHyd._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper diff --git a/flopy/modflow/mflak.py b/flopy/modflow/mflak.py index 02b72d4c21..7462759c13 100644 --- a/flopy/modflow/mflak.py +++ b/flopy/modflow/mflak.py @@ -280,10 +280,7 @@ def __init__( lwrt=0, **kwargs, ): - """ - Package constructor. - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowLak._defaultunit() @@ -297,19 +294,12 @@ def __init__( tabdata = True nlen += nlakes break - if filenames is None: - filenames = [None for x in range(nlen)] - elif isinstance(filenames, str): - filenames = [filenames] + [None for x in range(nlen - 1)] - elif isinstance(filenames, list): - if len(filenames) < nlen: - filenames = filenames + [None for x in range(2, nlen)] + filenames = self._prepare_filenames(filenames, nlen) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowLak._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 @@ -328,14 +318,14 @@ def __init__( "{} tabfiles specified " "instead of {} tabfiles".format(len(tab_files), nlakes) ) + # TODO: what should happen with msg? # make sure tab_files are not None - for idx, fname in enumerate(tab_files): + for idx, fname in enumerate(tab_files, 1): if fname is None: - msg = ( + raise ValueError( "a filename must be specified for the " - "tabfile for lake {}".format(idx + 1) + f"tabfile for lake {idx}" ) - raise ValueError(msg) # set unit for tab files if not passed to __init__ if tab_units is None: tab_units = [] @@ -345,23 +335,13 @@ def __init__( for iu, fname in zip(tab_units, tab_files): model.add_external(fname, iu) - # Fill namefile items - name = [ModflowLak._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mflmt.py b/flopy/modflow/mflmt.py index fd998224cb..775a60bacd 100644 --- a/flopy/modflow/mflmt.py +++ b/flopy/modflow/mflmt.py @@ -91,29 +91,13 @@ def __init__( if unitnumber is None: unitnumber = ModflowLmt._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowLmt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() diff --git a/flopy/modflow/mflpf.py b/flopy/modflow/mflpf.py index d331c3a74a..fb6608d4ba 100644 --- a/flopy/modflow/mflpf.py +++ b/flopy/modflow/mflpf.py @@ -25,7 +25,7 @@ class ModflowLpf(Package): The model object (of type :class:`flopy.modflow.mf.Modflow`) to which this package will be added. ipakcb : int - A flag that is used to determine if cell-by-cell budget data should be + A flag that is used to222 determine if cell-by-cell budget data should be saved. If ipakcb is non-zero cell-by-cell budget data will be saved. (default is 0) hdry : float @@ -118,9 +118,9 @@ class ModflowLpf(Package): is a combination of the wetting threshold and a flag to indicate which neighboring cells can cause a cell to become wet. (default is -0.01). - storagecoefficient : boolean + storagecoefficient : boolean212 indicates that variable Ss and SS parameters are read as storage - coefficient rather than specific storage. + coefficient rather t222han specific storage. (default is False). constantcv : boolean indicates that vertical conductance for an unconfined cell is @@ -216,43 +216,26 @@ def __init__( # set default unit number of one is not specified if unitnumber is None: - unitnumber = ModflowLpf._defaultunit() + unitnumber = self._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowLpf._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowLpf._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfmlt.py b/flopy/modflow/mfmlt.py index 884752dce1..eaea8b6d80 100644 --- a/flopy/modflow/mfmlt.py +++ b/flopy/modflow/mfmlt.py @@ -63,37 +63,18 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowMlt._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowMlt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() diff --git a/flopy/modflow/mfmnw1.py b/flopy/modflow/mfmnw1.py index 141eca74bf..d72b424a08 100644 --- a/flopy/modflow/mfmnw1.py +++ b/flopy/modflow/mfmnw1.py @@ -99,34 +99,23 @@ def __init__( unitnumber = ModflowMnw1._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowMnw1._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name, and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension, - ModflowMnw1._ftype(), + self._ftype(), unitnumber, - filenames=fname, + filenames=filenames[0], ) self.url = "mnw1.htm" diff --git a/flopy/modflow/mfmnw2.py b/flopy/modflow/mfmnw2.py index 1fcb4cdcb6..9e23d30119 100644 --- a/flopy/modflow/mfmnw2.py +++ b/flopy/modflow/mfmnw2.py @@ -1009,48 +1009,28 @@ def __init__( filenames=None, gwt=False, ): - """ - Package constructor - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowMnw2._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowMnw2._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowMnw2._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self.url = "mnw2.htm" diff --git a/flopy/modflow/mfmnwi.py b/flopy/modflow/mfmnwi.py index 73a51f138a..f1ddd14135 100644 --- a/flopy/modflow/mfmnwi.py +++ b/flopy/modflow/mfmnwi.py @@ -81,82 +81,60 @@ def __init__( # set filenames nfn = 4 + len(unique_units) - if filenames is None: - filenames = [None for x in range(nfn)] - elif isinstance(filenames, str): - filenames = [filenames] + [None for x in range(nfn)] - elif isinstance(filenames, list): - if len(filenames) < nfn: - n = nfn - len(filenames) + 1 - filenames = filenames + [None for x in range(n)] + filenames = self._prepare_filenames(filenames, nfn) # update external file information with unit_pc output, if necessary if wel1flag is not None: - fname = filenames[1] model.add_output_file( wel1flag, - fname=fname, + fname=filenames[1], extension="wel1", binflag=False, - package=ModflowMnwi._ftype(), + package=self._ftype(), ) else: wel1flag = 0 # update external file information with unit_ts output, if necessary if qsumflag is not None: - fname = filenames[2] model.add_output_file( qsumflag, - fname=fname, + fname=filenames[2], extension="qsum", binflag=False, - package=ModflowMnwi._ftype(), + package=self._ftype(), ) else: qsumflag = 0 # update external file information with ipunit output, if necessary if byndflag is not None: - fname = filenames[3] model.add_output_file( byndflag, - fname=fname, + fname=filenames[3], extension="bynd", binflag=False, - package=ModflowMnwi._ftype(), + package=self._ftype(), ) else: byndflag = 0 - idx = 4 - for iu in unique_units: - fname = filenames[idx] + for idx, iu in enumerate(unique_units, 4): model.add_output_file( iu, - fname=fname, + fname=filenames[idx], extension=f"{iu:04d}.mnwobs", binflag=False, - package=ModflowMnwi._ftype(), + package=self._ftype(), ) - idx += 1 - name = [ModflowMnwi._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self.url = "mnwi.htm" diff --git a/flopy/modflow/mfnwt.py b/flopy/modflow/mfnwt.py index 8d414b7cf7..687ce89fab 100644 --- a/flopy/modflow/mfnwt.py +++ b/flopy/modflow/mfnwt.py @@ -245,29 +245,13 @@ def __init__( if unitnumber is None: unitnumber = ModflowNwt._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowNwt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() diff --git a/flopy/modflow/mfoc.py b/flopy/modflow/mfoc.py index 4cfecd79da..87179a0a5d 100644 --- a/flopy/modflow/mfoc.py +++ b/flopy/modflow/mfoc.py @@ -157,10 +157,6 @@ def __init__( **kwargs, ): - """ - Package constructor. - - """ if unitnumber is None: unitnumber = ModflowOc._defaultunit() elif isinstance(unitnumber, list): @@ -168,15 +164,9 @@ def __init__( for idx in range(len(unitnumber), 6): unitnumber.append(0) self.label = label + # set filenames - if filenames is None: - filenames = [None, None, None, None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None, None, None] - elif isinstance(filenames, list): - if len(filenames) < 5: - for idx in range(len(filenames), 5): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 5) # support structured and unstructured dis dis = model.get_package("DIS") @@ -217,28 +207,26 @@ def __init__( icnt += 1 # set output unit numbers based on oc settings - self.savehead, self.saveddn, self.savebud, self.saveibnd = ( - False, - False, - False, - False, - ) + self.savehead = False + self.saveddn = False + self.savebud = False + self.saveibnd = False for key, value in stress_period_data.items(): - tlist = list(value) - for t in tlist: - if "save head" in t.lower(): + for t in list(value): + tlwr = t.lower() + if "save head" in tlwr: self.savehead = True if unitnumber[1] == 0: unitnumber[1] = 51 - if "save drawdown" in t.lower(): + if "save drawdown" in tlwr: self.saveddn = True if unitnumber[2] == 0: unitnumber[2] = 52 - if "save budget" in t.lower(): + if "save budget" in tlwr: self.savebud = True if unitnumber[3] == 0 and filenames is None: unitnumber[3] = 53 - if "save ibound" in t.lower(): + if "save ibound" in tlwr: self.saveibnd = True if unitnumber[4] == 0: unitnumber[4] = 54 @@ -262,23 +250,19 @@ def __init__( # add output files # head file if self.savehead: - iu = unitnumber[1] - binflag = True - if chedfm is not None: - binflag = False - fname = filenames[1] model.add_output_file( - iu, fname=fname, extension=extension[1], binflag=binflag + unitnumber[1], + fname=filenames[1], + extension=extension[1], + binflag=chedfm is None, ) # drawdown file if self.saveddn: - iu = unitnumber[2] - binflag = True - if cddnfm is not None: - binflag = False - fname = filenames[2] model.add_output_file( - iu, fname=fname, extension=extension[2], binflag=binflag + unitnumber[2], + fname=filenames[2], + extension=extension[2], + binflag=cddnfm is None, ) # budget file # Nothing is needed for the budget file @@ -286,32 +270,20 @@ def __init__( # ibound file ibouun = unitnumber[4] if self.saveibnd: - iu = unitnumber[4] - binflag = True - if cboufm is not None: - binflag = False - fname = filenames[4] model.add_output_file( - iu, fname=fname, extension=extension[4], binflag=binflag + unitnumber[4], + fname=filenames[4], + extension=extension[4], + binflag=cboufm is None, ) - name = [ModflowOc._ftype()] - extra = [""] - extension = [extension[0]] - unitnumber = unitnumber[0] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, - extension=extension, - name=name, - unit_number=unitnumber, - extra=extra, - filenames=fname, + extension=extension[0], + name=self._ftype(), + unit_number=unitnumber[0], + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfpbc.py b/flopy/modflow/mfpbc.py index b3c8d72ec3..2f857ea31b 100644 --- a/flopy/modflow/mfpbc.py +++ b/flopy/modflow/mfpbc.py @@ -21,11 +21,8 @@ def __init__( if unitnumber is None: unitnumber = ModflowPbc._defaultunit() - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, model, extension, ModflowPbc._ftype(), unitnumber - ) + # call base package constructor + super().__init__(model, extension, self._ftype(), unitnumber) self._generate_heading() self.mxactp = 0 if layer_row_column_data is None: diff --git a/flopy/modflow/mfpcg.py b/flopy/modflow/mfpcg.py index 8658bd7851..17a5761077 100644 --- a/flopy/modflow/mfpcg.py +++ b/flopy/modflow/mfpcg.py @@ -110,38 +110,18 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowPcg._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowPcg._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # check if a valid model version has been specified diff --git a/flopy/modflow/mfpcgn.py b/flopy/modflow/mfpcgn.py index 4d32f44f17..5bc9e08ef4 100644 --- a/flopy/modflow/mfpcgn.py +++ b/flopy/modflow/mfpcgn.py @@ -198,46 +198,33 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowPcgn._defaultunit() # set filenames - if filenames is None: - filenames = [None, None, None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None, None] - elif isinstance(filenames, list): - if len(filenames) < 4: - for idx in range(len(filenames), 4): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 4) # update external file information with unit_pc output, if necessary if unit_pc is not None: - fname = filenames[1] model.add_output_file( unit_pc, - fname=fname, + fname=filenames[1], extension="pcgni", binflag=False, - package=ModflowPcgn._ftype(), + package=self._ftype(), ) else: unit_pc = 0 # update external file information with unit_ts output, if necessary if unit_ts is not None: - fname = filenames[2] model.add_output_file( unit_ts, - fname=fname, + fname=filenames[2], extension="pcgnt", binflag=False, - package=ModflowPcgn._ftype(), + package=self._ftype(), ) else: unit_ts = 0 @@ -245,34 +232,23 @@ def __init__( # update external file information with ipunit output, if necessary if ipunit is not None: if ipunit > 0: - fname = filenames[3] model.add_output_file( ipunit, - fname=fname, + fname=filenames[3], extension="pcgno", binflag=False, - package=ModflowPcgn._ftype(), + package=self._ftype(), ) else: ipunit = -1 - name = [ModflowPcgn._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) # check if a valid model version has been specified diff --git a/flopy/modflow/mfpks.py b/flopy/modflow/mfpks.py index 8e31467023..12cd691ae5 100644 --- a/flopy/modflow/mfpks.py +++ b/flopy/modflow/mfpks.py @@ -103,37 +103,17 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowPks._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowPks._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # check if a valid model version has been specified if model.version == "mf2k" or model.version == "mfnwt": diff --git a/flopy/modflow/mfpval.py b/flopy/modflow/mfpval.py index 88c741209e..7bd9d18166 100644 --- a/flopy/modflow/mfpval.py +++ b/flopy/modflow/mfpval.py @@ -65,38 +65,17 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowPval._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowPval._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() diff --git a/flopy/modflow/mfrch.py b/flopy/modflow/mfrch.py index 2fc1540144..5640ae1762 100644 --- a/flopy/modflow/mfrch.py +++ b/flopy/modflow/mfrch.py @@ -100,50 +100,29 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowRch._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowRch._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowRch._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper diff --git a/flopy/modflow/mfriv.py b/flopy/modflow/mfriv.py index 99f6101a17..a86117e018 100644 --- a/flopy/modflow/mfriv.py +++ b/flopy/modflow/mfriv.py @@ -124,50 +124,28 @@ def __init__( filenames=None, **kwargs, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowRiv._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowRiv._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowRiv._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfsfr2.py b/flopy/modflow/mfsfr2.py index 485ef85897..5367f1e70a 100644 --- a/flopy/modflow/mfsfr2.py +++ b/flopy/modflow/mfsfr2.py @@ -344,28 +344,17 @@ def __init__( options=None, ): - """ - Package constructor - """ # set default unit number of one is not specified if unit_number is None: unit_number = ModflowSfr2._defaultunit() # set filenames - if filenames is None: - filenames = [None, None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None] - elif isinstance(filenames, list): - if len(filenames) < 3: - for _ in range(len(filenames), 3): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 3) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowSfr2._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 @@ -385,28 +374,18 @@ def __init__( abs(istcb2), fname=fname, binflag=binflag, - package=ModflowSfr2._ftype(), + package=self._ftype(), ) else: istcb2 = 0 - # Fill namefile items - name = [ModflowSfr2._ftype()] - units = [unit_number] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unit_number, + filenames=filenames[0], ) self.url = "sfr2.htm" diff --git a/flopy/modflow/mfsip.py b/flopy/modflow/mfsip.py index 98db739c87..41c884e267 100644 --- a/flopy/modflow/mfsip.py +++ b/flopy/modflow/mfsip.py @@ -93,38 +93,17 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowSip._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowSip._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # check if a valid model version has been specified diff --git a/flopy/modflow/mfsor.py b/flopy/modflow/mfsor.py index 1595de24de..df646a4f34 100644 --- a/flopy/modflow/mfsor.py +++ b/flopy/modflow/mfsor.py @@ -77,38 +77,17 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowSor._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowSor._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # check if a valid model version has been specified diff --git a/flopy/modflow/mfstr.py b/flopy/modflow/mfstr.py index 0e395e2c04..e92eb2472e 100644 --- a/flopy/modflow/mfstr.py +++ b/flopy/modflow/mfstr.py @@ -242,65 +242,35 @@ def __init__( options=None, **kwargs, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowStr._defaultunit() # set filenames - if filenames is None: - filenames = [None, None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None] - elif isinstance(filenames, list): - if len(filenames) < 3: - for idx in range(len(filenames), 3): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 3) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowStr._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 if istcb2 is not None: - fname = filenames[2] model.add_output_file( - istcb2, fname=fname, package=ModflowStr._ftype() + istcb2, fname=filenames[2], package=self._ftype() ) else: ipakcb = 0 - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowStr._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfsub.py b/flopy/modflow/mfsub.py index d978376e2c..8fa3fbbd4e 100644 --- a/flopy/modflow/mfsub.py +++ b/flopy/modflow/mfsub.py @@ -247,40 +247,27 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowSub._defaultunit() # set filenames - if filenames is None: - filenames = [None for x in range(9)] - elif isinstance(filenames, str): - filenames = [filenames] + [None for x in range(8)] - elif isinstance(filenames, list): - if len(filenames) < 9: - n = 9 - len(filenames) + 1 - filenames = filenames + [None for x in range(n)] + filenames = self._prepare_filenames(filenames, 9) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowSub._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 if idsave is not None: - fname = filenames[2] model.add_output_file( idsave, - fname=fname, + fname=filenames[2], extension="rst", - package=ModflowSub._ftype(), + package=self._ftype(), ) else: idsave = 0 @@ -299,37 +286,25 @@ def __init__( item15_units = [2052 + i for i in range(len(item15_extensions))] if isuboc > 0: - idx = 0 - for k in range(1, 12, 2): - ext = item15_extensions[idx] + for idx, k in enumerate(range(1, 12, 2)): if ids15 is None: iu = item15_units[idx] else: iu = ids15[k] - fname = filenames[idx + 3] model.add_output_file( - iu, fname=fname, extension=ext, package=ModflowSub._ftype() + iu, + fname=filenames[idx + 3], + extension=item15_extensions[idx], + package=self._ftype(), ) - idx += 1 - - extensions = [extension] - name = [ModflowSub._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, - extension=extensions, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + extension=extension, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper diff --git a/flopy/modflow/mfswi2.py b/flopy/modflow/mfswi2.py index bba78f14f1..f55da4a9be 100644 --- a/flopy/modflow/mfswi2.py +++ b/flopy/modflow/mfswi2.py @@ -224,29 +224,20 @@ def __init__( unitnumber=None, filenames=None, ): - """Package constructor.""" # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowSwi2._defaultunit() # set filenames - if filenames is None: - filenames = [None, None, None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None, None] - elif isinstance(filenames, list): - if len(filenames) < 4: - for idx in range(len(filenames), 4): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 4) # update external file information with zeta output, if necessary if iswizt is not None: - fname = filenames[1] model.add_output_file( iswizt, - fname=fname, + fname=filenames[1], extension="zta", - package=ModflowSwi2._ftype(), + package=self._ftype(), ) else: iswizt = 0 @@ -255,9 +246,7 @@ def __init__( # if necessary if ipakcb is not None: fname = filenames[2] - model.add_output_file( - ipakcb, fname=fname, package=ModflowSwi2._ftype() - ) + model.add_output_file(ipakcb, fname=fname, package=self._ftype()) else: ipakcb = 0 @@ -308,29 +297,18 @@ def __init__( fname=fname, binflag=binflag, extension=ext, - package=ModflowSwi2._ftype(), + package=self._ftype(), ) else: iswiobs = 0 - # Fill namefile items - name = [ModflowSwi2._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper @@ -355,29 +333,29 @@ def __init__( print("npln keyword is deprecated. use the nsrf keyword") nsrf = npln - self.nsrf, self.istrat, self.nobs, self.iswizt, self.iswiobs = ( - nsrf, - istrat, - nobs, - iswizt, - iswiobs, - ) + self.nsrf = nsrf + self.istrat = istrat + self.nobs = nobs + self.iswizt = iswizt + self.iswiobs = iswiobs # set cbc unit self.ipakcb = ipakcb # set solver flags - self.nsolver, self.iprsol, self.mutsol = nsolver, iprsol, mutsol + self.nsolver = nsolver + self.iprsol = iprsol + self.mutsol = mutsol # set solver parameters self.solver2params = solver2params # - self.toeslope, self.tipslope, self.alpha, self.beta = ( - toeslope, - tipslope, - alpha, - beta, - ) - self.nadptmx, self.nadptmn, self.adptfct = nadptmx, nadptmn, adptfct + self.toeslope = toeslope + self.tipslope = tipslope + self.alpha = alpha + self.beta = beta + self.nadptmx = nadptmx + self.nadptmn = nadptmn + self.adptfct = adptfct # Create arrays so that they have the correct size if self.istrat == 1: diff --git a/flopy/modflow/mfswr1.py b/flopy/modflow/mfswr1.py index edd6ad2662..650c5018b6 100644 --- a/flopy/modflow/mfswr1.py +++ b/flopy/modflow/mfswr1.py @@ -57,38 +57,17 @@ class ModflowSwr1(Package): def __init__( self, model, extension="swr", unitnumber=None, filenames=None ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowSwr1._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowSwr1._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # check if a valid model version has been specified diff --git a/flopy/modflow/mfswt.py b/flopy/modflow/mfswt.py index 0147fdd248..fcbbfd988c 100644 --- a/flopy/modflow/mfswt.py +++ b/flopy/modflow/mfswt.py @@ -361,29 +361,17 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowSwt._defaultunit() # set filenames - if filenames is None: - filenames = [None for x in range(15)] - elif isinstance(filenames, str): - filenames = [filenames] + [None for x in range(14)] - elif isinstance(filenames, list): - if len(filenames) < 15: - n = 15 - len(filenames) + 1 - filenames = filenames + [None for x in range(n)] + filenames = self._prepare_filenames(filenames, 15) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowSwt._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 @@ -406,37 +394,25 @@ def __init__( item16_units = [2052 + i for i in range(len(item16_extensions))] if iswtoc > 0: - idx = 0 - for k in range(1, 26, 2): - ext = item16_extensions[idx] + for idx, k in enumerate(range(1, 26, 2)): if ids16 is None: iu = item16_units[idx] else: iu = ids16[k] - fname = filenames[idx + 2] model.add_output_file( - iu, fname=fname, extension=ext, package=ModflowSwt._ftype() + iu, + fname=filenames[idx + 2], + extension=item16_extensions[idx], + package=self._ftype(), ) - idx += 1 - - extensions = [extension] - name = [ModflowSwt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, - extension=extensions, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + extension=extension, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper @@ -471,50 +447,45 @@ def __init__( self.sgs = Util2d(model, (nrow, ncol), np.float32, sgs, name="sgs") # interbed data - names = ["thick system " for n in range(nsystm)] self.thick = Util3d( model, (nsystm, nrow, ncol), np.float32, thick, - name=names, + name=["thick system " for n in range(nsystm)], locat=self.unit_number[0], ) - names = ["void system " for n in range(nsystm)] self.void = Util3d( model, (nsystm, nrow, ncol), np.float32, void, - name=names, + name=["void system " for n in range(nsystm)], locat=self.unit_number[0], ) - names = ["sub system " for n in range(nsystm)] self.sub = Util3d( model, (nsystm, nrow, ncol), np.float32, sub, - name=names, + name=["sub system " for n in range(nsystm)], locat=self.unit_number[0], ) if icrcc != 0: - names = ["sse system " for n in range(nsystm)] self.sse = Util3d( model, (nsystm, nrow, ncol), np.float32, sse, - name=names, + name=["sse system " for n in range(nsystm)], locat=self.unit_number[0], ) - names = ["ssc system " for n in range(nsystm)] self.ssv = Util3d( model, (nsystm, nrow, ncol), np.float32, ssv, - name=names, + name=["ssc system " for n in range(nsystm)], locat=self.unit_number[0], ) self.cr = None @@ -522,22 +493,20 @@ def __init__( else: self.sse = None self.ssv = None - names = ["cr system " for n in range(nsystm)] self.cr = Util3d( model, (nsystm, nrow, ncol), np.float32, cr, - name=names, + name=["cr system " for n in range(nsystm)], locat=self.unit_number[0], ) - names = ["cc system " for n in range(nsystm)] self.cc = Util3d( model, (nsystm, nrow, ncol), np.float32, cc, - name=names, + name=["cc system " for n in range(nsystm)], locat=self.unit_number[0], ) diff --git a/flopy/modflow/mfupw.py b/flopy/modflow/mfupw.py index 43c469c796..b606097386 100644 --- a/flopy/modflow/mfupw.py +++ b/flopy/modflow/mfupw.py @@ -162,7 +162,7 @@ def __init__( if model.version != "mfnwt": raise Exception( "Error: model version must be mfnwt to use " - "{} package".format(ModflowUpw._ftype()) + f"{self._ftype()} package" ) # set default unit number of one is not specified @@ -170,41 +170,23 @@ def __init__( unitnumber = ModflowUpw._defaultunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowUpw._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowUpw._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfuzf1.py b/flopy/modflow/mfuzf1.py index b29a75789a..86778a3c96 100644 --- a/flopy/modflow/mfuzf1.py +++ b/flopy/modflow/mfuzf1.py @@ -404,31 +404,22 @@ def __init__( nlen = 3 if uzgag is not None: nlen += len(uzgag) - if filenames is None: - filenames = [None for x in range(nlen)] - elif isinstance(filenames, str): - filenames = [filenames] + [None for x in range(nlen)] - elif isinstance(filenames, list): - if len(filenames) < nlen: - for idx in range(len(filenames), nlen + 1): - filenames.append(None) + filenames = self._prepare_filenames(filenames, nlen) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - abs(ipakcb), fname=fname, package=ModflowUzf1._ftype() + abs(ipakcb), fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 if iuzfcb2 is not None: - fname = filenames[2] model.add_output_file( abs(iuzfcb2), - fname=fname, + fname=filenames[2], extension="uzfcb2.bin", - package=ModflowUzf1._ftype(), + package=self._ftype(), ) else: iuzfcb2 = 0 @@ -445,15 +436,13 @@ def __init__( d[-np.abs(l[0])] = [] uzgag = d for key, value in uzgag.items(): - fname = filenames[ipos] iu = abs(key) - uzgagext = f"uzf{iu}.out" model.add_output_file( iu, - fname=fname, + fname=filenames[ipos], binflag=False, - extension=uzgagext, - package=ModflowUzf1._ftype(), + extension=f"uzf{iu}.out", + package=self._ftype(), ) ipos += 1 # handle case where iftunit is listed in the values @@ -463,29 +452,18 @@ def __init__( elif len(value) == 1: uzgag[-np.abs(key)] = [] - # Fill namefile items - name = [ModflowUzf1._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) if ( - self.parent.get_package("RCH") != None - or self.parent.get_package("EVT") != None + self.parent.get_package("RCH") is not None + or self.parent.get_package("EVT") is not None ): print( "WARNING!\n The RCH and EVT packages should not be " diff --git a/flopy/modflow/mfwel.py b/flopy/modflow/mfwel.py index 2aefdae2ad..135be608d3 100644 --- a/flopy/modflow/mfwel.py +++ b/flopy/modflow/mfwel.py @@ -153,52 +153,29 @@ def __init__( filenames=None, add_package=True, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowWel._defaultunit() self.unitnumber = unitnumber # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - filenames.append(None) - self.filenames = filenames + filenames = self._prepare_filenames(filenames, 2) # update external file information with cbc output, if necessary if ipakcb is not None: - fname = filenames[1] model.add_output_file( - ipakcb, fname=fname, package=ModflowWel._ftype() + ipakcb, fname=filenames[1], package=self._ftype() ) else: ipakcb = 0 - # Fill namefile items - name = [ModflowWel._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) self._generate_heading() diff --git a/flopy/modflow/mfzon.py b/flopy/modflow/mfzon.py index f9ba1537f6..26e7637c7c 100644 --- a/flopy/modflow/mfzon.py +++ b/flopy/modflow/mfzon.py @@ -67,38 +67,17 @@ def __init__( unitnumber=None, filenames=None, ): - """ - Package constructor. - - """ # set default unit number of one is not specified if unitnumber is None: unitnumber = ModflowZon._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowZon._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() diff --git a/flopy/modflowusg/mfusgbcf.py b/flopy/modflowusg/mfusgbcf.py index 1b1d0a90d7..fe500aa8f4 100644 --- a/flopy/modflowusg/mfusgbcf.py +++ b/flopy/modflowusg/mfusgbcf.py @@ -132,10 +132,11 @@ def __init__( """ Constructs the ModflowUsgBcf object. - Overrides the parent ModflowBcf object.""" + Overrides the parent ModflowBcf object. + """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg @@ -368,7 +369,7 @@ def load(cls, f, model, ext_unit_dict=None): """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg diff --git a/flopy/modflowusg/mfusgcln.py b/flopy/modflowusg/mfusgcln.py index c3156d749a..1c9803ed80 100644 --- a/flopy/modflowusg/mfusgcln.py +++ b/flopy/modflowusg/mfusgcln.py @@ -197,51 +197,29 @@ def __init__( unitnumber=None, filenames=None, ): - """Package constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg # set default unit number of one is not specified if unitnumber is None: - self.unitnumber = ModflowUsgCln._defaultunit() + self.unitnumber = self._defaultunit() elif isinstance(unitnumber, list): if len(unitnumber) < 7: for idx in range(len(unitnumber), 7): unitnumber.append(0) # set filenames - if filenames is None: - filenames = [None, None, None, None, None, None, None] - elif isinstance(filenames, str): - filenames = [ - filenames, - None, - None, - None, - None, - None, - None, - ] - elif isinstance(filenames, list): - if len(filenames) < 7: - for idx in range(len(filenames), 7): - filenames.append(None) - - # Fill namefile items - name = [ModflowUsgCln._ftype()] - extra = [""] + filenames = self._prepare_filenames(filenames, num=7) # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + super().__init__( model, extension=extension, - name=name, + name=self._ftype(), unit_number=unitnumber, - extra=extra, filenames=filenames, ) @@ -261,7 +239,7 @@ def __init__( fname=filenames[idx + 1], extension=attr, binflag=True, - package=ModflowUsgCln._ftype(), + package=self._ftype(), ) # Define CLN networks and connections @@ -414,7 +392,7 @@ def _define_cln_networks(self, model): raise Exception("mfcln: ja_cln must be provided") if abs(self.ja_cln[0]) != 1: raise Exception( - "mfcln: first ja_cln entry (node 1) is " "not 1 or -1." + "mfcln: first ja_cln entry (node 1) is not 1 or -1." ) self.ja_cln = Util2d( model, @@ -757,7 +735,7 @@ def load(cls, f, model, ext_unit_dict=None): """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg @@ -838,7 +816,7 @@ def load(cls, f, model, ext_unit_dict=None): extension = cls._get_default_extension() if ext_unit_dict is not None: unitnumber[0], filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowUsgCln._ftype() + ext_unit_dict, filetype=cls._ftype() ) file_unit_items = [iclncb, iclnhd, iclndd, iclnib, iclncn, iclnmb] funcs = [abs] + [int] * 3 + [abs] * 2 diff --git a/flopy/modflowusg/mfusgdisu.py b/flopy/modflowusg/mfusgdisu.py index a0081580c5..2ad6d29488 100644 --- a/flopy/modflowusg/mfusgdisu.py +++ b/flopy/modflowusg/mfusgdisu.py @@ -228,40 +228,23 @@ def __init__( filenames=None, start_datetime=None, ): - """disu constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg # set default unit number of one is not specified if unitnumber is None: - unitnumber = ModflowUsgDisU._defaultunit() + unitnumber = self._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowUsgDisU._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # Set values of all parameters @@ -554,7 +537,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg @@ -785,7 +768,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): filenames = [None] if ext_unit_dict is not None: unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowUsgDisU._ftype() + ext_unit_dict, filetype=cls._ftype() ) # create dis object instance diff --git a/flopy/modflowusg/mfusggnc.py b/flopy/modflowusg/mfusggnc.py index 97b7b16399..515904fbd2 100644 --- a/flopy/modflowusg/mfusggnc.py +++ b/flopy/modflowusg/mfusggnc.py @@ -92,41 +92,24 @@ def __init__( unitnumber=None, filenames=None, ): - """Package constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg # set default unit number of one is not specified if unitnumber is None: - unitnumber = ModflowUsgGnc._defaultunit() - - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowUsgGnc._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] + unitnumber = self._defaultunit() # Call ancestor's init to set self.parent, extension, name and # unit number - Package.__init__( - self, + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() @@ -272,7 +255,7 @@ def load(cls, f, model, ext_unit_dict=None): """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg @@ -339,7 +322,7 @@ def load(cls, f, model, ext_unit_dict=None): filenames = [None] if ext_unit_dict is not None: unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowUsgGnc._ftype() + ext_unit_dict, filetype=cls._ftype() ) return cls( diff --git a/flopy/modflowusg/mfusglpf.py b/flopy/modflowusg/mfusglpf.py index dbf4083dc1..d7d7e9ef6f 100644 --- a/flopy/modflowusg/mfusglpf.py +++ b/flopy/modflowusg/mfusglpf.py @@ -235,10 +235,14 @@ def __init__( filenames=None, add_package=True, ): - """mfusglpf object constructor.""" + """ + Constructs the ModflowUsgBcf object. + + Overrides the parent ModflowBcf object. + """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg @@ -269,7 +273,7 @@ def __init__( novfc=novfc, extension=extension, unitnumber=unitnumber, - filenames=filenames, + filenames=self._prepare_filenames(filenames), add_package=False, ) @@ -594,7 +598,7 @@ def load(cls, f, model, ext_unit_dict=None, check=True): """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg diff --git a/flopy/modflowusg/mfusgsms.py b/flopy/modflowusg/mfusgsms.py index 9478cde33d..18e25a8db8 100644 --- a/flopy/modflowusg/mfusgsms.py +++ b/flopy/modflowusg/mfusgsms.py @@ -270,41 +270,23 @@ def __init__( unitnumber=None, filenames=None, ): - """Package constructor.""" msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg # set default unit number of one is not specified if unitnumber is None: - unitnumber = ModflowUsgSms._defaultunit() - - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [ModflowUsgSms._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__( - self, + unitnumber = self._defaultunit() + + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self._generate_heading() @@ -444,7 +426,7 @@ def load(cls, f, model, ext_unit_dict=None): """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg @@ -616,7 +598,7 @@ def load(cls, f, model, ext_unit_dict=None): filenames = [None] if ext_unit_dict is not None: unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowUsgSms._ftype() + ext_unit_dict, filetype=cls._ftype() ) return cls( diff --git a/flopy/modflowusg/mfusgwel.py b/flopy/modflowusg/mfusgwel.py index c341896209..0596e5a334 100644 --- a/flopy/modflowusg/mfusgwel.py +++ b/flopy/modflowusg/mfusgwel.py @@ -175,15 +175,15 @@ def __init__( filenames=None, add_package=True, ): - """ - Package constructor. - """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg + # set filenames + filenames = self._prepare_filenames(filenames) + super().__init__( model, ipakcb=ipakcb, @@ -208,13 +208,12 @@ def __init__( self.iunitafr = int(line_text[1]) if self.iunitafr > 0: - fname = self.filenames[1] model.add_output_file( self.iunitafr, - fname=fname, + fname=filenames[1], extension="afr", binflag=False, - package=ModflowUsgWel._ftype(), + package=self._ftype(), ) # initialize CLN MfList @@ -597,7 +596,7 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): """ msg = ( "Model object must be of type flopy.modflowusg.ModflowUsg\n" - + "but received type: {type(model)}." + f"but received type: {type(model)}." ) assert isinstance(model, ModflowUsg), msg @@ -696,7 +695,7 @@ def load(cls, f, model, nper=None, ext_unit_dict=None): unitnumber = ModflowUsgWel._defaultunit() if ext_unit_dict is not None: unitnumber, filenames[0] = model.get_ext_dict_attr( - ext_unit_dict, filetype=ModflowUsgWel._ftype() + ext_unit_dict, filetype=cls._ftype() ) if ipakcb > 0: _, filenames[1] = model.get_ext_dict_attr( diff --git a/flopy/modpath/mp6.py b/flopy/modpath/mp6.py index 87e7c119c9..474e238a48 100644 --- a/flopy/modpath/mp6.py +++ b/flopy/modpath/mp6.py @@ -11,13 +11,8 @@ class Modpath6List(Package): """ def __init__(self, model, extension="list", listunit=7): - """ - Package constructor. - - """ - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__(self, model, extension, "LIST", listunit) + # call base package constructor + super().__init__(model, extension, "LIST", listunit) # self.parent.add_package(self) This package is not added to the base # model so that it is not included in get_name_file_entries() return diff --git a/flopy/modpath/mp6bas.py b/flopy/modpath/mp6bas.py index 9e682c612f..4e38187a76 100644 --- a/flopy/modpath/mp6bas.py +++ b/flopy/modpath/mp6bas.py @@ -80,11 +80,7 @@ def __init__( extension="mpbas", unitnumber=86, ): - """ - Package constructor. - - """ - Package.__init__(self, model, extension, "MPBAS", unitnumber) + super().__init__(model, extension, "MPBAS", unitnumber) nrow, ncol, nlay, nper = self.parent.mf.nrow_ncol_nlay_nper self.parent.mf.get_name_file_entries() self.heading1 = "# MPBAS for Modpath, generated by Flopy." diff --git a/flopy/modpath/mp6sim.py b/flopy/modpath/mp6sim.py index 15c34e7db6..ea0bdeed53 100644 --- a/flopy/modpath/mp6sim.py +++ b/flopy/modpath/mp6sim.py @@ -82,8 +82,8 @@ def __init__( extension="mpsim", ): - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__(self, model, extension, "MPSIM", 32) + # call base package constructor + super().__init__(model, extension, "MPSIM", 32) nrow, ncol, nlay, nper = self.parent.mf.nrow_ncol_nlay_nper self.heading1 = "# MPSIM for Modpath, generated by Flopy." @@ -415,7 +415,7 @@ class StartingLocationsFile(Package): def __init__(self, model, inputstyle=1, extension="loc", verbose=False): - Package.__init__(self, model, extension, "LOC", 33) + super().__init__(model, extension, "LOC", 33) self.model = model self.heading = ( @@ -427,9 +427,8 @@ def __init__(self, model, inputstyle=1, extension="loc", verbose=False): self.data = self.get_empty_starting_locations_data(0) self.extension = extension - self.parent.add_package( - self - ) # add to package list so location are written with other ModPath files + # add to package list so location are written with other ModPath files + self.parent.add_package(self) @staticmethod def get_dtypes(): diff --git a/flopy/modpath/mp7.py b/flopy/modpath/mp7.py index d94040320c..5848d3566c 100644 --- a/flopy/modpath/mp7.py +++ b/flopy/modpath/mp7.py @@ -23,16 +23,11 @@ class Modpath7List(Package): """ def __init__(self, model, extension="list", unitnumber=None): - """ - Package constructor. - - """ if unitnumber is None: unitnumber = model.next_unit() - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__(self, model, extension, "LIST", unitnumber) + # call base package constructor + super().__init__(model, extension, "LIST", unitnumber) # self.parent.add_package(self) This package is not added to the base # model so that it is not included in get_name_file_entries() return diff --git a/flopy/modpath/mp7bas.py b/flopy/modpath/mp7bas.py index f47b424d60..07337263ba 100644 --- a/flopy/modpath/mp7bas.py +++ b/flopy/modpath/mp7bas.py @@ -39,14 +39,10 @@ class Modpath7Bas(Package): def __init__( self, model, porosity=0.30, defaultiface=None, extension="mpbas" ): - """ - Package constructor. - - """ unitnumber = model.next_unit() - Package.__init__(self, model, extension, "MPBAS", unitnumber) + super().__init__(model, extension, "MPBAS", unitnumber) shape = model.shape if len(shape) == 3: diff --git a/flopy/modpath/mp7sim.py b/flopy/modpath/mp7sim.py index 8a0491576f..1888bad755 100644 --- a/flopy/modpath/mp7sim.py +++ b/flopy/modpath/mp7sim.py @@ -268,15 +268,11 @@ def __init__( particlegroups=None, extension="mpsim", ): - """ - Package constructor. - - """ unitnumber = model.next_unit() - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__(self, model, extension, "MPSIM", unitnumber) + # call base package constructor + super().__init__(model, extension, "MPSIM", unitnumber) self._generate_heading() diff --git a/flopy/mt3d/mt.py b/flopy/mt3d/mt.py index 531dd37706..693bea7503 100644 --- a/flopy/mt3d/mt.py +++ b/flopy/mt3d/mt.py @@ -24,9 +24,8 @@ class Mt3dList(Package): """ def __init__(self, model, extension="list", listunit=7): - # Call ancestor's init to set self.parent, extension, name and - # unit number - Package.__init__(self, model, extension, "LIST", listunit) + # call base package constructor + super().__init__(model, extension, "LIST", listunit) # self.parent.add_package(self) This package is not added to the base # model so that it is not included in get_name_file_entries() return diff --git a/flopy/mt3d/mtadv.py b/flopy/mt3d/mtadv.py index c044b09fd2..dfe4d1a5f0 100644 --- a/flopy/mt3d/mtadv.py +++ b/flopy/mt3d/mtadv.py @@ -191,29 +191,13 @@ def __init__( elif unitnumber == 0: unitnumber = Mt3dAdv._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dAdv._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self.mixelm = mixelm @@ -229,7 +213,9 @@ def __init__( self.nph = nph self.npmin = npmin self.npmax = npmax - self.interp = 1 # Command-line 'interp' might once be needed if MT3DMS is updated to include other interpolation method + # Command-line 'interp' might once be needed if MT3DMS is updated to + # include other interpolation method + self.interp = 1 self.nlsink = nlsink self.npsink = npsink self.dchmoc = dchmoc diff --git a/flopy/mt3d/mtbtn.py b/flopy/mt3d/mtbtn.py index 47b6a5c223..f9f154d4b7 100644 --- a/flopy/mt3d/mtbtn.py +++ b/flopy/mt3d/mtbtn.py @@ -236,29 +236,13 @@ def __init__( elif unitnumber == 0: unitnumber = Mt3dBtn._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dBtn._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) # Set these variables from the Modflow model (self.parent.mf) unless diff --git a/flopy/mt3d/mtdsp.py b/flopy/mt3d/mtdsp.py index bdd1d29e94..e181cfec9c 100644 --- a/flopy/mt3d/mtdsp.py +++ b/flopy/mt3d/mtdsp.py @@ -120,29 +120,13 @@ def __init__( elif unitnumber == 0: unitnumber = Mt3dDsp._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dDsp._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) nrow = model.nrow diff --git a/flopy/mt3d/mtgcg.py b/flopy/mt3d/mtgcg.py index ab2a413342..8ad8e591aa 100644 --- a/flopy/mt3d/mtgcg.py +++ b/flopy/mt3d/mtgcg.py @@ -97,29 +97,13 @@ def __init__( elif unitnumber == 0: unitnumber = Mt3dGcg._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dGcg._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self.mxiter = mxiter diff --git a/flopy/mt3d/mtlkt.py b/flopy/mt3d/mtlkt.py index a0c1e8da28..aad9442d55 100644 --- a/flopy/mt3d/mtlkt.py +++ b/flopy/mt3d/mtlkt.py @@ -126,26 +126,16 @@ def __init__( unitnumber = Mt3dLkt._reservedunit() # set filenames - if filenames is None: - filenames = [None, None] - if abs(icbclk) > 0: - filenames[1] = model.name - elif isinstance(filenames, str): - filenames = [filenames, None, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - for idx in range(len(filenames), 2): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) + if filenames[1] is None and abs(icbclk) > 0: + filenames[1] = model.name if icbclk is not None: ext = "lkcobs.out" if filenames[1] is not None: - if ( - len(filenames[1].split(".", 1)) > 1 - ): # already has extension - fname = "{}.{}".format(*filenames[1].split(".", 1)) - else: - fname = f"{filenames[1]}.{ext}" + fname = filenames[1] + if "." not in fname: # add extension + fname += f".{ext}" else: fname = f"{model.name}.{ext}" model.add_output_file( @@ -153,28 +143,18 @@ def __init__( fname=fname, extension=None, binflag=False, - package=Mt3dLkt._ftype(), + package=self._ftype(), ) else: icbclk = 0 - # Fill namefile items - name = [Mt3dLkt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) # Set dimensions diff --git a/flopy/mt3d/mtphc.py b/flopy/mt3d/mtphc.py index 28629992c8..29f94960d5 100644 --- a/flopy/mt3d/mtphc.py +++ b/flopy/mt3d/mtphc.py @@ -36,29 +36,13 @@ def __init__( elif unitnumber == 0: unitnumber = Mt3dPhc._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dPhc._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self.os = os diff --git a/flopy/mt3d/mtrct.py b/flopy/mt3d/mtrct.py index 03d2527d18..b7b4e1cdcf 100644 --- a/flopy/mt3d/mtrct.py +++ b/flopy/mt3d/mtrct.py @@ -174,39 +174,19 @@ def __init__( filenames=None, **kwargs, ): - """ - Package constructor. - - """ if unitnumber is None: unitnumber = Mt3dRct._defaultunit() elif unitnumber == 0: unitnumber = Mt3dRct._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dRct._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) nrow = model.nrow diff --git a/flopy/mt3d/mtsft.py b/flopy/mt3d/mtsft.py index b14c75954a..c77d8394f7 100644 --- a/flopy/mt3d/mtsft.py +++ b/flopy/mt3d/mtsft.py @@ -214,26 +214,16 @@ def __init__( unitnumber = Mt3dSft._reservedunit() # set filenames - if filenames is None: # if filename not passed - filenames = [None, None] # setup filenames - if abs(ioutobs) > 0: - filenames[1] = model.name - elif isinstance(filenames, str): - filenames = [filenames, None, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - for idx in range(len(filenames), 2): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) + if filenames[1] is None and abs(ioutobs) > 0: + filenames[1] = model.name if ioutobs is not None: ext = "sftcobs.out" if filenames[1] is not None: - if ( - len(filenames[1].split(".", 1)) > 1 - ): # already has extension - fname = "{}.{}".format(*filenames[1].split(".", 1)) - else: - fname = f"{filenames[1]}.{ext}" + fname = filenames[1] + if "." not in fname: # add extension + fname += f".{ext}" else: fname = f"{model.name}.{ext}" model.add_output_file( @@ -241,28 +231,18 @@ def __init__( fname=fname, extension=None, binflag=False, - package=Mt3dSft._ftype(), + package=self._ftype(), ) else: ioutobs = 0 - # Fill namefile items - name = [Mt3dSft._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) # Set dimensions diff --git a/flopy/mt3d/mtssm.py b/flopy/mt3d/mtssm.py index c2208342c9..76c94405c4 100644 --- a/flopy/mt3d/mtssm.py +++ b/flopy/mt3d/mtssm.py @@ -172,29 +172,13 @@ def __init__( elif unitnumber == 0: unitnumber = Mt3dSsm._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dSsm._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) deprecated_kwargs = ["criv", "cghb", "cibd", "cchd", "cpbc", "cwel"] diff --git a/flopy/mt3d/mttob.py b/flopy/mt3d/mttob.py index 893cf8cbfd..4e74bb1860 100644 --- a/flopy/mt3d/mttob.py +++ b/flopy/mt3d/mttob.py @@ -24,29 +24,13 @@ def __init__( elif unitnumber == 0: unitnumber = Mt3dTob._reservedunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [Mt3dTob._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) self.heading = "# TOB for MT3DMS, generated by Flopy." diff --git a/flopy/mt3d/mtuzt.py b/flopy/mt3d/mtuzt.py index acee737ad9..dcefcebcea 100644 --- a/flopy/mt3d/mtuzt.py +++ b/flopy/mt3d/mtuzt.py @@ -154,45 +154,26 @@ def __init__( unitnumber = Mt3dUzt._reservedunit() # set filenames - if filenames is None: - filenames = [None, None] - elif isinstance(filenames, str): - filenames = [filenames, None, None] - elif isinstance(filenames, list): - if len(filenames) < 2: - for idx in range(len(filenames), 2): - filenames.append(None) + filenames = self._prepare_filenames(filenames, 2) if icbcuz is not None: - fname = filenames[1] - extension = "uzcobs.out" model.add_output_file( icbcuz, - fname=fname, - extension=extension, + fname=filenames[1], + extension="uzcobs.out", binflag=False, - package=Mt3dUzt._ftype(), + package=self._ftype(), ) else: icbcuz = 0 - # Fill namefile items - name = [Mt3dUzt._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=filenames[0], ) # Set dimensions diff --git a/flopy/pakbase.py b/flopy/pakbase.py index 3a897bbda8..9e03c30354 100644 --- a/flopy/pakbase.py +++ b/flopy/pakbase.py @@ -6,6 +6,7 @@ """ import abc import os +import inspect import webbrowser as wb import numpy as np @@ -433,6 +434,19 @@ class Package(PackageInterface): """ Base package class from which most other packages are derived. + Parameters + ---------- + parent : object + Parent model object. + extension : str or list, default "glo" + File extension, without ".", use list to describe more than one. + name : str or list, default "GLOBAL" + Package name, use list to describe more than one. + unit_number : int or list, default 1 + Unit number, use list to describe more than one. + filenames : str or list, default None + allowDuplicates : bool, default False + Allow more than one instance of package in parent. """ def __init__( @@ -441,20 +455,17 @@ def __init__( extension="glo", name="GLOBAL", unit_number=1, - extra="", filenames=None, allowDuplicates=False, ): - """ - Package init - - """ # To be able to access the parent model object's attributes self.parent = parent if not isinstance(extension, list): extension = [extension] self.extension = [] self.file_name = [] + if isinstance(filenames, str): + filenames = [filenames] for idx, e in enumerate(extension): self.extension.append(e) file_name = f"{self.parent.name}.{e}" @@ -471,10 +482,6 @@ def __init__( if not isinstance(unit_number, list): unit_number = [unit_number] self.unit_number = unit_number - if not isinstance(extra, list): - self.extra = len(self.unit_number) * [extra] - else: - self.extra = extra self.url = "index.html" self.allowDuplicates = allowDuplicates @@ -675,6 +682,21 @@ def _generate_heading(self): f"generated by Flopy {__version__}" ) + @staticmethod + def _prepare_filenames(filenames, num=1): + """Prepare filenames parameter.""" + if filenames is None: + return [None] * num + elif isinstance(filenames, str): + filenames = [filenames] + if isinstance(filenames, list): + if len(filenames) < num: + filenames += [None] * (num - len(filenames)) + elif len(filenames) > num: + filenames = filenames[:num] + return filenames + raise ValueError(f"unexpected filenames: {filenames}") + @staticmethod def add_to_dtype(dtype, field_names, field_types): """ diff --git a/flopy/seawat/swt.py b/flopy/seawat/swt.py index 9ea83a24ca..fc44f3ad80 100644 --- a/flopy/seawat/swt.py +++ b/flopy/seawat/swt.py @@ -15,7 +15,7 @@ class SeawatList(Package): """ def __init__(self, model, extension="list", listunit=7): - Package.__init__(self, model, extension, "LIST", listunit) + super().__init__(model, extension, "LIST", listunit) return def __repr__(self): diff --git a/flopy/seawat/swtvdf.py b/flopy/seawat/swtvdf.py index 1109871440..459e502b19 100644 --- a/flopy/seawat/swtvdf.py +++ b/flopy/seawat/swtvdf.py @@ -210,29 +210,13 @@ def __init__( if unitnumber is None: unitnumber = SeawatVdf._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [SeawatVdf._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper diff --git a/flopy/seawat/swtvsc.py b/flopy/seawat/swtvsc.py index 70baec3f18..8e897583a4 100644 --- a/flopy/seawat/swtvsc.py +++ b/flopy/seawat/swtvsc.py @@ -156,29 +156,13 @@ def __init__( if unitnumber is None: unitnumber = SeawatVsc._defaultunit() - # set filenames - if filenames is None: - filenames = [None] - elif isinstance(filenames, str): - filenames = [filenames] - - # Fill namefile items - name = [SeawatVsc._ftype()] - units = [unitnumber] - extra = [""] - - # set package name - fname = [filenames[0]] - - # Call ancestor's init to set self.parent, extension, name and unit number - Package.__init__( - self, + # call base package constructor + super().__init__( model, extension=extension, - name=name, - unit_number=units, - extra=extra, - filenames=fname, + name=self._ftype(), + unit_number=unitnumber, + filenames=self._prepare_filenames(filenames), ) nrow, ncol, nlay, nper = self.parent.nrow_ncol_nlay_nper diff --git a/flopy/utils/binaryfile.py b/flopy/utils/binaryfile.py index f04b2ac296..d1503a4122 100755 --- a/flopy/utils/binaryfile.py +++ b/flopy/utils/binaryfile.py @@ -674,6 +674,14 @@ def __init__(self, filename, precision="auto", verbose=False, **kwargs): else: raise Exception(f"Unknown precision specified: {precision}") + # set shape for full3D option + if self.modelgrid is None: + self.shape = (self.nlay, self.nrow, self.ncol) + self.nnodes = self.nlay * self.nrow * self.ncol + else: + self.shape = self.modelgrid.shape + self.nnodes = self.modelgrid.nnodes + if not success: raise Exception( f"Budget file could not be read using {precision} precision" @@ -788,19 +796,24 @@ def _build_index(self): for i in range(33, 127): asciiset += chr(i) + # read first record header = self._get_header() - self.nrow = header["nrow"] - self.ncol = header["ncol"] - self.nlay = np.abs(header["nlay"]) + nrow = header["nrow"] + ncol = header["ncol"] text = header["text"] if isinstance(text, bytes): text = text.decode() - if self.nrow < 0 or self.ncol < 0: + if nrow < 0 or ncol < 0: raise Exception("negative nrow, ncol") + if not text.endswith("FLOW-JA-FACE"): + self.nrow = nrow + self.ncol = ncol + self.nlay = np.abs(header["nlay"]) self.file.seek(0, 2) self.totalbytes = self.file.tell() self.file.seek(0, 0) self.recorddict = {} + # read the remaining records ipos = 0 while ipos < self.totalbytes: self.iposheader.append(ipos) @@ -865,6 +878,16 @@ def _build_index(self): ): print("") + # set the nrow, ncol, and nlay if they have not been set + if self.nrow == 0: + text = header["text"] + if isinstance(text, bytes): + text = text.decode() + if not text.endswith("FLOW-JA-FACE"): + self.nrow = header["nrow"] + self.ncol = header["ncol"] + self.nlay = np.abs(header["nlay"]) + # store record and byte position mapping self.recorddict[ tuple(header) @@ -1548,13 +1571,16 @@ def get_record(self, idx, full3D=False): dtype = np.dtype([("node", np.int32), ("q", self.realtype)]) if self.verbose: if full3D: - s += f"a numpy masked array of size ({nlay}, {nrow}, {ncol})" + s += ( + f"a numpy masked array of " + f"size ({nlay}, {nrow}, {ncol})" + ) else: s += f"a numpy recarray of size ({nlist}, 2)" print(s) data = binaryread(self.file, dtype, shape=(nlist,)) if full3D: - return self.create3D(data, nlay, nrow, ncol) + return self.__create3D(data) else: return data.view(np.recarray) @@ -1564,23 +1590,27 @@ def get_record(self, idx, full3D=False): data = binaryread(self.file, self.realtype(1), shape=(nrow, ncol)) if self.verbose: if full3D: - s += f"a numpy masked array of size ({nlay}, {nrow}, {ncol})" + s += ( + "a numpy masked array of size " + f"({nlay}, {nrow}, {ncol})" + ) else: s += ( - "a list of two 2D numpy arrays. " - "The first is an integer layer array of shape {}. " - "The second is real data array of shape {}".format( - (nrow, ncol), - (nrow, ncol), - ) + "a list of two 2D numpy arrays. The first is an " + f"integer layer array of shape ({nrow}, {ncol}). The " + f"second is real data array of shape ({nrow}, {ncol})" ) print(s) if full3D: - out = np.ma.zeros((nlay, nrow, ncol), dtype=np.float32) + out = np.ma.zeros(self.nnodes, dtype=np.float32) out.mask = True - vertical_layer = ilayer[0] - 1 # This is always the top layer - out[vertical_layer, :, :] = data - return out + vertical_layer = ilayer.flatten() - 1 + # create the 2D cell index and then move it to + # the correct vertical location + idx = np.arange(0, vertical_layer.shape[0]) + idx += vertical_layer * nrow * ncol + out[idx] = data.flatten() + return out.reshape(self.shape) else: return [ilayer, data] @@ -1608,7 +1638,7 @@ def get_record(self, idx, full3D=False): if self.verbose: s += f"a list array of shape ({nlay}, {nrow}, {ncol})" print(s) - return self.create3D(data, nlay, nrow, ncol) + return self.__create3D(data) else: if self.verbose: s += f"a numpy recarray of size ({nlist}, {2 + naux})" @@ -1631,13 +1661,12 @@ def get_record(self, idx, full3D=False): data = binaryread(self.file, dtype, shape=(nlist,)) if self.verbose: if full3D: - s += f"full 3D arrays not supported for imeth = {imeth}" + s += f"a list array of shape ({nlay}, {nrow}, {ncol})" else: s += f"a numpy recarray of size ({nlist}, 2)" print(s) if full3D: - s += f"full 3D arrays not supported for imeth = {imeth}" - raise ValueError(s) + return self.__create3D(data) else: return data.view(np.recarray) else: @@ -1646,34 +1675,30 @@ def get_record(self, idx, full3D=False): # should not reach this point return - def create3D(self, data, nlay, nrow, ncol): + def __create3D(self, data): """ Convert a dictionary of {node: q, ...} into a numpy masked array. - In most cases this should not be called directly by the user unless - you know what you're doing. Instead, it is used as part of the - full3D keyword for get_data. + Used to create full grid arrays when the full3D keyword is set + to True in get_data. Parameters ---------- data : dictionary Dictionary with node keywords and flows (q) items. - nlay, nrow, ncol : int - Number of layers, rows, and columns of the model grid. - Returns ---------- out : numpy masked array List contains unique simulation times (totim) in binary file. """ - out = np.ma.zeros((nlay * nrow * ncol), dtype=np.float32) + out = np.ma.zeros(self.nnodes, dtype=np.float32) out.mask = True for [node, q] in zip(data["node"], data["q"]): idx = node - 1 out.data[idx] += q out.mask[idx] = False - return np.ma.reshape(out, (nlay, nrow, ncol)) + return np.ma.reshape(out, self.shape) def get_times(self): """