{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UgqzEwle2xCd"
   },
   "source": [
    "## **IMPORT PACKAGES**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3X7UsV832B6j"
   },
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "import numpy as np\n",
    "import pickle\n",
    "import math\n",
    "import json as j\n",
    "\n",
    "from pypulseq.Sequence.sequence import Sequence\n",
    "from pypulseq.calc_rf_center import calc_rf_center\n",
    "from pypulseq.calc_duration import calc_duration\n",
    "from pypulseq.make_adc import make_adc\n",
    "from pypulseq.make_delay import make_delay\n",
    "from pypulseq.make_sinc_pulse import make_sinc_pulse\n",
    "from pypulseq.make_trapezoid import make_trapezoid\n",
    "from pypulseq.make_extended_trapezoid import make_extended_trapezoid\n",
    "from pypulseq.opts import Opts\n",
    "from pypulseq.align import align\n",
    "from pypulseq.traj_to_grad import traj_to_grad\n",
    "\n",
    "from pypulseq.utilities import phase_grad_utils as pgu\n",
    "\n",
    "from py2jemris.seq2xml import seq2xml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **temporal functions**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def TSE_k_space_fill(n_ex, ETL, k_steps, TE_eff_number):\n",
    "    #function defines phase encoding steps for k space filling in liner order \n",
    "    #with shifting according to the TE effective number\n",
    "    \n",
    "    k_space_list_with_zero = []\n",
    "    for i in range(ETL):\n",
    "        k_space_list_with_zero.append((ETL-1)*n_ex - i*n_ex)\n",
    "    #print(k_space_list_with_zero)\n",
    "    central_num = np.int32(k_steps/2)\n",
    "    #print(central_num)\n",
    "    index_central_line = k_space_list_with_zero.index(central_num)\n",
    "    shift = index_central_line - TE_eff_number + 1\n",
    "    \n",
    "    if shift>0:\n",
    "        a = k_space_list_with_zero[:shift]\n",
    "        b = k_space_list_with_zero[shift:]\n",
    "        k_space_list_with_zero = b+a\n",
    "    elif shift<0:\n",
    "        a = k_space_list_with_zero[:shift]\n",
    "        b = k_space_list_with_zero[shift:]\n",
    "        k_space_list_with_zero = b+a\n",
    "        \n",
    "    k_space_order_filing = [k_space_list_with_zero]\n",
    "    for i in range(n_ex-1):\n",
    "        k_space_list_temp = []\n",
    "        for k in k_space_list_with_zero:\n",
    "            k_space_list_temp.append(k+i+1)\n",
    "        k_space_order_filing.append(k_space_list_temp)\n",
    "        \n",
    "    return k_space_order_filing\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UQ4AWw9l4et_"
   },
   "source": [
    "## **USER INPUTS**\n",
    "\n",
    "These parameters are typically on the user interface of the scanner computer console "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'G_amp_max': 1609372.8,\n",
       " 'G_slew_max': 5151696000.0,\n",
       " 'gamma': 42576000.0,\n",
       " 'grad_raster_time': 1e-05,\n",
       " 'rf_raster_time': 1e-06,\n",
       " 't_BW_product_ex': 3.55,\n",
       " 't_BW_product_ref': 3.55,\n",
       " 't_ex': 0.00298,\n",
       " 't_ref': 0.00333,\n",
       " 'rf_ringdown_time': [2e-05],\n",
       " 'rf_dead_time': [0.0001],\n",
       " 'adc_dead_time': [1e-05],\n",
       " 'aapodization': 0.27,\n",
       " 'dG': 0.00025,\n",
       " 'sl_nb': 1.0,\n",
       " 'sl_thkn': 0.005,\n",
       " 'sl_gap': 100.0,\n",
       " 'FoV_f': 0.032,\n",
       " 'FoV_ph': 0.032,\n",
       " 'Nf': 16.0,\n",
       " 'Np': 16.0,\n",
       " 'BW_pixel': 500.0,\n",
       " 'TE': 0.02,\n",
       " 'N_TE': 2.0,\n",
       " 'ES': 0.01,\n",
       " 'TR': 0.5,\n",
       " 'FA': 90.0,\n",
       " 'conct': 1.0,\n",
       " 'ETL': 16.0,\n",
       " 'Average': 1,\n",
       " 'delay_TR': 0.33484}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weightning = 'T1'\n",
    "\n",
    "if weightning == 'T1':\n",
    "    with open('C:\\MRI_seq_files_mess\\TSE_T1.json', 'rb') as f:\n",
    "        params = j.load(f)\n",
    "        \n",
    "elif weightning == 'T2':\n",
    "    with open('C:\\MRI_seq_files_mess\\TSE_T2.json', 'rb') as f:\n",
    "        params = j.load(f)\n",
    "        \n",
    "elif weightning == 'T1':\n",
    "    with open('C:\\MRI_seq_files_mess\\TSE_T1.json', 'rb') as f:\n",
    "        params = j.load(f)    \n",
    "else:\n",
    "    print('Please choose image weightning')\n",
    "    \n",
    "\n",
    "tau = params['TE'] / 2  # s  #TODO - introduce in GUI\n",
    "readout_time = round(1/params['BW_pixel'], 8)\n",
    "\n",
    "params\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "    from pypulseq.make_gauss_pulse import make_gauss_pulse\n",
    "    FS = True\n",
    "    if FS: #TODO add to GUI choise of including or not Fat Sat block\n",
    "        params['B0'] = 1.5 #TODO add to GUI\n",
    "        params['FS_sat_ppm'] = -3.45 #TODO add to GUI\n",
    "        params['FS_pulse_duration'] = 8e-3 #TODO add to GUI\n",
    "        FS_sat_frequency = params['B0'] * 1e-6 * params['FS_sat_ppm'] * params['gamma']\n",
    "        flip_fs = (110 * pi) / 180\n",
    "\n",
    "        rf_fs = make_gauss_pulse(flip_angle=flip_fs, system=scanner_parameters, duration=params['FS_pulse_duration'],\n",
    "                                       bandwidth=abs(FS_sat_frequency), freq_offset=FS_sat_frequency)\n",
    "        gx_fs = make_trapezoid(channel=\"x\", system=scanner_parameters, delay=calc_duration(rf_fs),\n",
    "                              area = 10*gz_ex.area, rise_time=params['dG'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.008119999999999999"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_duration(rf_fs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.01293"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_duration(gx_fs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PeYeI0V45ZfD"
   },
   "source": [
    "## **SYSTEM LIMITS**\n",
    "Set the hardware limits and initialize sequence object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XHs1LT965kqg"
   },
   "outputs": [],
   "source": [
    "# Set system limits\n",
    "scanner_parameters = Opts(\n",
    "    max_grad=37.8,  \n",
    "    grad_unit=\"mT/m\",\n",
    "    max_slew=121,  \n",
    "    slew_unit=\"T/m/s\",\n",
    "    rf_ringdown_time = params['rf_ringdown_time'][0],   \n",
    "    rf_dead_time = params['rf_dead_time'][0],          \n",
    "    adc_dead_time = params['adc_dead_time'][0],            \n",
    "    rf_raster_time = params['rf_raster_time'],            \n",
    "    grad_raster_time = params['grad_raster_time'],        \n",
    "    block_duration_raster = params['grad_raster_time'],\n",
    "    adc_raster_time = 1/(params['BW_pixel']*params['Nf'])\n",
    ")\n",
    "seq = Sequence(scanner_parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OTw7M03g79bH"
   },
   "source": [
    "## **RF & basis gradients**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XDZyQrbL8I3Q"
   },
   "outputs": [],
   "source": [
    "rf90_phase = np.pi / 2\n",
    "rf180_phase = 0\n",
    "\n",
    "flip90 = round(params['FA'] * pi / 180, 3)\n",
    "flip180 = round(180 * pi / 180)\n",
    "rf90, gz_ex, _ = make_sinc_pulse(flip_angle = flip90, system = scanner_parameters, duration = params['t_ex'], \n",
    "                                slice_thickness = params['sl_thkn'], apodization=0.3, \n",
    "                                time_bw_product = round(params['t_BW_product_ex'],8), return_gz = True)\n",
    "\n",
    "rf180, gz_ref, _ = make_sinc_pulse(flip_angle = flip180, system = scanner_parameters, duration = params['t_ref'], \n",
    "                                  slice_thickness = params['sl_thkn'], apodization=0.3, \n",
    "                                  time_bw_product = round(params['t_BW_product_ref'],8), phase_offset=90 * pi/180, return_gz = True)\n",
    "\n",
    "#Restore RF pulse -90\n",
    "rf_restore, gz_resto, _ = make_sinc_pulse(flip_angle = -flip90, system = scanner_parameters, duration = params['t_ex'], \n",
    "                                slice_thickness = params['sl_thkn'], apodization=0.3, \n",
    "                                time_bw_product = round(params['t_BW_product_ex'],8), return_gz = True)\n",
    "\n",
    "\n",
    "\n",
    "# Prepare RF offsets. This is required for multi-slice acquisition\n",
    "pulse_offsets90 = (np.linspace(0.0,params['sl_nb'] - 1.0,np.int16(params['sl_nb'])) - 0.5*(np.double(params['sl_nb'])  - 1.0))*(params['sl_thkn']*(100.0 + params['sl_gap'])/100.0)*gz_ex.amplitude\n",
    "pulse_offsets180 = (np.linspace(0.0,params['sl_nb'] - 1.0,np.int16(params['sl_nb'])) - 0.5*(np.double(params['sl_nb'])  - 1.0))*(params['sl_thkn']*(100.0 + params['sl_gap'])/100.0)*gz_ref.amplitude\n",
    "pulse_offsets_restore = (np.linspace(0.0,params['sl_nb'] - 1.0,np.int16(params['sl_nb'])) - 0.5*(np.double(params['sl_nb'])  - 1.0))*(params['sl_thkn']*(100.0 + params['sl_gap'])/100.0)*gz_restore.amplitude\n",
    "\n",
    "\n",
    "# slice selective gradient drafts for complex gradient blocks\n",
    "t_exwd = params['t_ex'] + scanner_parameters.rf_ringdown_time + scanner_parameters.rf_dead_time\n",
    "t_refwd = params['t_ref'] + scanner_parameters.rf_ringdown_time + scanner_parameters.rf_dead_time\n",
    "t_restore = t_exwd\n",
    "\n",
    "gz90 = make_trapezoid(channel=\"z\", system=scanner_parameters, amplitude=gz_ex.amplitude,\n",
    "                         flat_time=t_exwd, rise_time=params['dG'])\n",
    "gz180 = make_trapezoid(channel=\"z\", system=scanner_parameters, amplitude=gz_ref.amplitude,\n",
    "                         flat_time=t_refwd, rise_time=params['dG'])\n",
    "gz_restore = make_trapezoid(channel=\"z\", system=scanner_parameters, amplitude=gz_resto.amplitude,\n",
    "                         flat_time=t_restore, rise_time=params['dG'])\n",
    "\n",
    "# generate basic gx readout gradient - G_read\n",
    "k_read = np.double(params['Nf'])/np.double(params['FoV_f'])\n",
    "t_gx = np.ceil(readout_time / scanner_parameters.grad_raster_time) * scanner_parameters.grad_raster_time\n",
    "gx = make_trapezoid(channel='x', system=scanner_parameters, flat_area=k_read, \n",
    "                    flat_time=t_gx + 2*scanner_parameters.adc_dead_time)\n",
    "\n",
    "# generate gx spoiler gradient - G_crr\n",
    "gx_spoil = make_trapezoid(channel='x', system=scanner_parameters, area=gx.area, flat_time = params['dG'],  \n",
    "                         rise_time=params['dG'])\n",
    "\n",
    "\n",
    "# read prephase gradient - G_pre\n",
    "gx_pre = make_trapezoid(channel=\"x\", system=scanner_parameters, area=gx.area*1.50,\n",
    "                        rise_time=params['dG'])\n",
    "\n",
    "# rephase gradient draft after 90 RF pulse  - G_reph\n",
    "gz_reph = make_trapezoid(channel=\"z\", system=scanner_parameters, area=gz_ex.area*0.25,\n",
    "                        flat_time = calc_duration(gx_pre), rise_time=params['dG'])\n",
    "\n",
    "#spoil gradient around 180 RF pulse - G_crs\n",
    "t_gz_spoil = np.ceil(params['t_ref'] / 2 / scanner_parameters.grad_raster_time) * scanner_parameters.grad_raster_time\n",
    "gz_spoil = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*0.75, rise_time=params['dG'], flat_time = params['dG'])\n",
    "\n",
    "#spoil gradient G_sps\n",
    "gz_cr = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*4, rise_time=params['dG'])\n",
    "\n",
    "# Creation of ADC\n",
    "adc = make_adc(num_samples=params['Nf'], duration=t_gx, delay=scanner_parameters.adc_dead_time, system=scanner_parameters)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "o829kzm8kVFB"
   },
   "source": [
    "## **k-space filling quantification**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "m5zA1bMakTVs"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10]]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_phase = np.double(params['Np'])/np.double(params['FoV_ph'])\n",
    "k_steps_PE = pgu.create_k_steps(k_phase, np.int16(params['Np'])) #list of phase encoding gradients\n",
    "\n",
    "n_ex = math.floor(params['Np'] / params['ETL']) # number of excitations \n",
    "k_space_order_filing = TSE_k_space_fill(n_ex, np.int32(params['ETL']), np.int32(params['Np']), np.int32(params['N_TE'])) #TODO: create function on different k space order filling\n",
    "k_space_order_filing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3F5JUpE9-4lo"
   },
   "source": [
    "## **DELAYS**\n",
    "Echo time (TE) and repetition time (TR). Here, TE is broken down into `delay1` and `delay2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aOKRJclb_mDQ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.13277999999999995"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "block_duration = 0\n",
    "block_duration = max(calc_duration(rf90), calc_duration(gz90))/2\n",
    "block_duration += max(calc_duration(gx_pre), calc_duration(gz_spoil))\n",
    "for i in range(np.int32(params['ETL'])):\n",
    "    block_duration +=  max(calc_duration(rf180), calc_duration(gz180))  \n",
    "    block_duration +=  max(calc_duration(gx_spoil), calc_duration(gz_spoil))  \n",
    "    block_duration +=  max(calc_duration(gx_spoil), calc_duration(adc))\n",
    "    block_duration +=  calc_duration(gz_spoil)\n",
    "block_duration +=  max(calc_duration(rf180), calc_duration(gz180))\n",
    "block_duration += max(calc_duration(gx_pre), calc_duration(gz_spoil))\n",
    "block_duration += max(calc_duration(rf90), calc_duration(gz90))\n",
    "block_duration +=  calc_duration(gz_cr)    \n",
    "    \n",
    "    \n",
    "    \n",
    "block_duration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.36722000000000005"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.5 - block_duration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **CONSTRUCT CONCATINATIONS timings**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Quantification of Effective TE loop\n",
    "#eff_time = TE + calc_duration(gx) / 2 + max(calc_duration(gy_pre),calc_duration(gz_spoil)) + calc_duration(gx_spoil) + calc_duration(gz90) / 2\n",
    "eff_time = block_duration #equal to previous!\n",
    "\n",
    "max_slices_per_TR = np.floor(params['TR']/eff_time)\n",
    "required_concats = np.int32(np.ceil(params['sl_nb']/max_slices_per_TR))\n",
    "slice_list = list(range(np.int32(params['sl_nb'])))\n",
    "slice_list = [slice_list[x::required_concats] for x in range(required_concats)]\n",
    "    \n",
    "# Calculate the TR fillers\n",
    "tr_pauses = [(params['TR']/np.double(len(x))) - eff_time for x in slice_list]\n",
    "tr_pauses = [max(seq.grad_raster_time,seq.rf_raster_time)*np.floor(x/max(seq.grad_raster_time,seq.rf_raster_time)) for x in tr_pauses]\n",
    "    \n",
    "# Generate the TR fillers\n",
    "tr_fillers = [make_delay(x) for x in tr_pauses]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6Dq4wT-UAEOR"
   },
   "source": [
    "## **CONSTRUCT SEQUENCE**\n",
    "Construct sequence for one phase encode and multiple slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_9\n",
      "-31.25\n",
      "phase step_8\n",
      "0.0\n",
      "phase step_7\n",
      "31.25\n",
      "phase step_6\n",
      "62.5\n",
      "phase step_5\n",
      "93.75\n",
      "phase step_4\n",
      "125.0\n",
      "phase step_3\n",
      "156.25\n",
      "phase step_2\n",
      "187.5\n",
      "phase step_1\n",
      "218.75\n",
      "phase step_0\n",
      "250.0\n",
      "phase step_15\n",
      "-218.75\n",
      "phase step_14\n",
      "-187.5\n",
      "phase step_13\n",
      "-156.25\n",
      "phase step_12\n",
      "-125.0\n",
      "phase step_11\n",
      "-93.75\n",
      "phase step_10\n",
      "-62.5\n"
     ]
    }
   ],
   "source": [
    "#working version without concatinations\n",
    "\n",
    "for k in range(params['Average']):  # Averages\n",
    "    for curr_concat in range(required_concats): \n",
    "        for phase_steps in k_space_order_filing: # in stead of phase steps list of phase steps\n",
    "            for curr_slice in range(np.int32(params['sl_nb'])):  # Slices\n",
    "                # Apply RF offsets\n",
    "                n_echo_temp = 0\n",
    "                rf90.freq_offset = pulse_offsets90[curr_slice]\n",
    "                rf180.freq_offset = pulse_offsets180[curr_slice]\n",
    "                rf_restore.freq_offset = pulse_offsets_restore[curr_slice]\n",
    "                #rf90.phase_offset = (rf90_phase - 2 * np.pi * rf90.freq_offset * calc_rf_center(rf90)[0])\n",
    "                #rf180.phase_offset = (rf180_phase - 2 * np.pi * rf180.freq_offset * calc_rf_center(rf180)[0])\n",
    "                print('curr_concat_' + str(curr_concat))\n",
    "                print('curr_slice_' + str(curr_slice))\n",
    "                \n",
    "\n",
    "                seq.add_block(gz90, rf90)\n",
    "                seq.add_block(gz_reph, gx_pre)\n",
    "                for phase_step in phase_steps:\n",
    "                    print('phase step_' + str(phase_step))\n",
    "                    seq.add_block(gz180, rf180)      \n",
    "                    gy_pre = make_trapezoid(channel='y', system=scanner_parameters, \n",
    "                                            area=-k_steps_PE[phase_step], duration = calc_duration(gz_spoil),\n",
    "                                            rise_time=params['dG'])\n",
    "                    print(k_steps_PE[phase_step])\n",
    "                      \n",
    "                    seq.add_block(gz_spoil,gx_spoil,gy_pre)\n",
    "                    seq.add_block(gx, adc)\n",
    "                    n_echo_temp += 1                    \n",
    "                    gy_pre = make_trapezoid(channel='y', system=scanner_parameters, \n",
    "                                            area=k_steps_PE[phase_step], duration = calc_duration(gz_spoil),\n",
    "                                            rise_time=params['dG'])\n",
    "                    if n_echo_temp == np.int32(params['ETL']):\n",
    "                        seq.add_block(gz_spoil,gx_spoil,gy_pre)\n",
    "                        seq.add_block(gz180, rf180)\n",
    "                        seq.add_block(gz_reph, gx_pre)\n",
    "                        seq.add_block(gz_restore, rf_restore)\n",
    "                        seq.add_block(gz_cr)\n",
    "                    else:\n",
    "                        seq.add_block(gz_spoil,gx_spoil,gy_pre)\n",
    "                seq.add_block(tr_fillers[curr_concat])\n",
    "    \n",
    "  \n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l-YP9djBJCpC"
   },
   "source": [
    "## **PLOTTING TIMNG DIAGRAM**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "d_iCUR4nfoH9"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHVCAYAAAB8NLYkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADOoklEQVR4nOydeXxU1fn/P3ebSQJZWEwCsgiCKwiICtFWVBAQWzfqXsWlLhRcQBRRWQRbqPpVq0Vr/SlaLS5oRatIiWwVCCjIvgkIBCQJkJCFLDN3Ob8/7tybuZlJMjP3ZLI979crryT33nnmnDPnzH3usx2BMcZAEARBEARBNHvExm4AQRAEQRAEwQdS7AiCIAiCIFoIpNgRBEEQBEG0EEixIwiCIAiCaCGQYkcQBEEQBNFCIMWOIAiCIAiihUCKHUEQBEEQRAuBFDuCIAiCIIgWgtzYDWgJGIaBI0eOIDk5GYIgNHZzCIIgCIJoRBhjKCsrQ+fOnSGK8bWhkWLHgSNHjqBr166N3QyCIAiCIJoQhw4dQpcuXeL6ns1OsZs7dy5eeOEF5Ofno1+/fnjttddw0UUX1Xr9ggULMHXqVBw4cAC9e/fGX/7yF4waNco+f9ddd+G9995zvGbEiBFYvHhxxG1KTk4GAOzfvx/t27ePskfNH1VVsWTJEgwfPhyKojR2cxoFGgMaA4DGAKAxAGgMWnv/AaCoqAg9evSw9YN40qwUu48//hgTJ07E3//+dwwaNAivvPIKRowYgd27dyM9PT3k+jVr1uDWW2/F7Nmz8Zvf/Abz58/Hddddhx9//BF9+vSxrxs5ciTmzZtn/+/1eqNql+V+TU5ORkpKSoy9a76oqoqkpCSkpKS02kVMY0BjANAYADQGAI1Ba+8/YI4BgEYJz2pWyRMvvfQS7rvvPtx9990455xz8Pe//x1JSUl45513wl7/17/+FSNHjsTjjz+Os88+G7NmzcL555+Pv/3tb47rvF4vMjMz7Z927drFozsEQRAEQRBcaTYWO7/fjw0bNmDKlCn2MVEUMWzYMOTk5IR9TU5ODiZOnOg4NmLECCxcuNBxbMWKFUhPT0e7du1wxRVX4LnnnkOHDh1qbYvP54PP57P/Ly0tBWBq6JaW3pqw+twa+25BY0BjANAYADQGAI1Ba+8/0Lh9bzaK3fHjx6HrOjIyMhzHMzIysGvXrrCvyc/PD3t9fn6+/f/IkSNxww03oEePHti3bx+eeuopXHXVVcjJyYEkSWHlzp49G88++2zI8eXLlyMpKSnarrUYsrOzG7sJjQ6NAY0BQGMA0BgANAatuf8VFRWN9t7NRrFrKG655Rb77759++K8887D6aefjhUrVmDo0KFhXzNlyhSHJbC0tBRdu3bF5ZdfXqelr6Wiqiqys7Nx5ZVXtup4ChoDGgMaAxoDgMagtfcfAAoLCxvtvZuNYtexY0dIkoSCggLH8YKCAmRmZoZ9TWZmZlTXA0DPnj3RsWNH7N27t1bFzuv1hk2wUBSl1U5igPoP0BgANAYAjQFAYwDQGLTm/jdmv5tN8oTH48HAgQOxdOlS+5hhGFi6dCmysrLCviYrK8txPWCahmu7HgAOHz6MwsJCdOrUiU/DCYIgCIIg4kSzUewAYOLEiXjrrbfw3nvvYefOnRg7dizKy8tx9913AwDuvPNOR3LFI488gsWLF+P//u//sGvXLsyYMQPr16/H+PHjAQAnT57E448/jrVr1+LAgQNYunQprr32WvTq1QsjRoxolD4SBEEQBEHESrNxxQLAzTffjGPHjmHatGnIz89H//79sXjxYjtBIjc317F1x8UXX4z58+fjmWeewVNPPYXevXtj4cKFdg07SZKwZcsWvPfeeyguLkbnzp0xfPhwzJo1K+padgRBEARBEI1Ns1LsAGD8+PG2xa0mK1asCDl244034sYbbwx7fWJiIv773//ybB5BEARBEESj0axcsQRBEARBEETtkGJHEARBEATRQiDFjiAIgiAIooVAih1BEARBEEQLgRQ7giAIgiCIFgIpdgRBEARBEC0EUuwIgiAIgiBaCKTYEQRBEARBtBBIsSMIgiAIgmghkGJHEARBEATRQiDFjiAIgiAIooVAih1BEARBEEQLgRQ7giAIgiCIFgIpdgRBEARBEC0EUuwIgiAIgiBaCKTYEQRBEARBtBBIsSMIgiAIgmghkGJHEARBEATRQiDFjiAIgiAIooVAih1BEARBEEQLgRQ7giAIgiCIFgIpdgRBEARBEC0EUuwIgiAIgiBaCKTYEQRBEARBtBBIsSMIgiAIgmghkGJHEARBEATRQiDFjiAIgiAIooVAih1BEARBEEQLgRQ7giAIgiCIFgIpdgRBEARBEC2EiBU7XdexZcsWVFZWhpyrqKjAli1bYBgG18YRBEEQBEEQkROxYvf+++/jnnvugcfjCTnn8Xhwzz33YP78+VwbRxAEQRAEQUROxIrd22+/jUmTJkGSpJBzsizjiSeewD/+8Q+ujSMIgiAIgiAiJ2LFbvfu3Rg8eHCt5y+88ELs3LmTS6MIgiAIgiCI6IlYsSsvL0dpaWmt58vKylBRUcGlUQRBEARBEET0RKzY9e7dG2vWrKn1/KpVq9C7d28ujSIIgiAIgiCiJ2LF7rbbbsMzzzyDLVu2hJzbvHkzpk2bhttuu41r4wiCIAiCIIjIkSO9cMKECfjmm28wcOBADBs2DGeddRYAYNeuXfj2229xySWXYMKECQ3WUIIgCIIgCKJuIrbYKYqCJUuW4E9/+hPy8vLwj3/8A2+++Sby8vLwpz/9CUuWLIGiKA3Z1tbHaacBslz9I4pAu3bmuZ49Q8+lpdUua8YM87x1rSgCCQnA0KHArFmm3JrnLrusdnmXXWZeI4qQvV789vrrIZ9yiilr6FAgMbFaliyb7z1jRu3y0tKqr7V+evY0z7VrF3rutNPqb1vw9VZfrbbVPFdXX2t+DrJstmnWLPtzkBMT8ZsbboCcmFh3X4M/h5p9Df4cmnBfHT8tqa8c1pecmIhrrrsOstfLbX3Zc9/6HJr4+pKSk6vXQiSfA0EQXInYYgeYyt0TTzyBJ554oqHaUy9z587FCy+8gPz8fPTr1w+vvfYaLrroolqvX7BgAaZOnYoDBw6gd+/e+Mtf/oJRo0bZ5xljmD59Ot566y0UFxfjkksuwRtvvNE04gVFEdB157HiYkCSgHDFoAWhdlmSBJSUOI/5fMCyZeZPTXw+8zV1yfP5zLcN/KCkBJg2LfRaXTfP1SVPEADGnP3dv9/Z1+BzYh3PJEFtc7QhXD+tc3W1rbbPIaivAgBbQl19Dfc5AGZfw42d9f610Qh9ddAS++pifdlXMMZtfQEw21nb59DE1lfIK+v7HAiC4AuLEsMw2A8//MAWLFjAPv30U/bjjz8ywzCiFRMTH330EfN4POydd95h27dvZ/fddx9LS0tjBQUFYa9fvXo1kySJPf/882zHjh3smWeeYYqisK1bt9rXzJkzh6WmprKFCxeyzZs3s2uuuYb16NGDVVZWRtyukpISBoAdP37cdR9D6NGDMfMrue6ftLT6Zc2cGZksgLErrqhf3hVXRC5v5sz65aWlRSarRw++bYukr5F+DpH0NZrPoRn11e/3s4ULFzK/39/y+krrK/a2RdLXFkbYtdCKaO39Z4yx48ePMwCspKQk7u8tMMZYpErg8uXLce+99+LgwYOwXiYIAnr06IF33nkHl156aQOpnyaDBg3ChRdeiL/97W8AAMMw0LVrVzz00EN48sknQ66/+eabUV5ejq+++so+NnjwYPTv3x9///vfwRhD586d8dhjj2HSpEkAgJKSEmRkZODdd9/FLbfcErYdPp8PvqAn1tLSUnTt2hV5eXno0KEDzy4DAKQzzoB44ECt5420NOhHj0YkS/zTnyA9+2yd1xiXXQZ9yZLI2jZ8OMQVK+q8Rp8+HcbTT0cmLz0dYnFx7W077TToP/3ErW1R9bWezwEA/FOnQpg6tV5ZEX0OTbyvNT9XVVWRnZ2NK6+80hGW0dz7Gs36YrNmwTNrFr+2taL11ZKobS20Flp7/wGgsLAQnTp1QklJCVJSUuL63hErdnv37kW/fv0waNAgPPLIIzjrrLPAGMOOHTvw6quvYv369diyZQt6WnEbnPH7/UhKSsKnn36K6667zj4+ZswYFBcX44svvgh5Tbdu3TBx4kQ8+uij9rHp06dj4cKF2Lx5M37++Wecfvrp2LhxI/r3729fM2TIEPTv3x9//etfw7ZlxowZeDbMjWr+/PlISkqKuY91cc111yGcI4gB+HLhwqhk/eZ3v4OkaWHPxSKvtrYBgC7L+OrTT7nI4922xu5rPD8H6mts8mh9xd62WOQRREuhoqICt912W6ModhHH2L3yyisYPHgwli5d6jh+1lln4frrr8ewYcPw8ssv47XXXuPeSAA4fvw4dF1HRkaG43hGRgZ27doV9jX5+flhr8/Pz7fPW8dquyYcU6ZMwcSJE+3/LYvd5Zdf3mAWu9q+PAUAv73rrugsdrXcdGx5r7wSlUWhjsgjSJqG32zcGJVFoc6+PvpoVBaFutoWdV/r+BwAs69XbdgQucWuvs+hife15udap8WumfY12vXFZs2i9RUsL4q+tiRau8WqtfcfMC12jUakPttzzz2Xffnll7We//LLL9m5557rzjFcB7/88gsDwNasWeM4/vjjj7OLLroo7GsURWHz5893HJs7dy5LT09njJkxeADYkSNHHNfceOON7Kabboq4bRRj1wpigCjGrt6+Uowdra+Y+9rCaO0xZq29/4w1boxdxOVOcnNz0bdv31rP9+nTBwcPHnStaNZGx44dIUkSCgoKHMcLCgqQmZkZ9jWZmZl1Xm/9jkZmXOnZ08xcq0m4jLXi4upSDeGYNav2TMRwLFtmli+ojaFDa89GDMe0aWYbaqNdO7MPNQnX1/37q0s18GhbfX2t7XOojbr6Gu3nQH2tJl59pfUV38+BIAiuRKzYnTx5ss74saSkpAbdK9bj8WDgwIEOV7BhGFi6dCmysrLCviYrKyvEdZydnW1f36NHD2RmZjquKS0txbp162qVGVcMwywTYP0IglmPSteBHj1CzzFWuyxdB1JTq68VBMDrBa64Apg505Rb81zNUhA15Xm9gCCACQIMQQBLTTVlXXGFWbvKkiVJ5nvXJY+x6mutnx49zNekpYWeC1eOombbgq+3+mq1rea5utpW83OQJLNNM2fanwOTJOiiCFZfX4M/h5p9Df4cmnBfHT8tqa8c1heTJDAAjOP6sue+9Tk08fVleL3VayGSz4EgCL5EatoTBIEtX76cbd68OezP0qVLmSiKDWldZB999BHzer3s3XffZTt27GD3338/S0tLY/n5+Ywxxu644w725JNP2tevXr2aybLMXnzxRbZz5042ffr0sOVO0tLS2BdffMG2bNnCrr322qZV7qQZQGZ3GgPGaAwYozFgjMaAMRqD1t5/xhrXFRtVgeKhQ4eC1fHUKtRVwJMDN998M44dO4Zp06YhPz8f/fv3x+LFi+3kh9zcXIhBroWLL74Y8+fPxzPPPIOnnnoKvXv3xsKFC9GnTx/7mieeeALl5eW4//77UVxcjF/96ldYvHgxEhISGrQvBEEQBEEQvIlYsdsfQdxNWVmZq8ZEwvjx4zF+/Piw51aEqal044034sYbb6xVniAImDlzJmbOnMmriQRBEARBEI1CxIpd9+7dwx4vKyvDhx9+iLfffhvr16+HTrEUBEEQBEEQjULEyRM1+d///ocxY8agU6dOePHFF3H55Zdj7dq1PNtGEARBEARBREFUMXb5+fl499138fbbb6O0tBQ33XQTfD4fFi5ciHPOOaeh2kgQBEEQBEFEQMQWu9/+9rc488wzsWXLFrzyyis4cuRIg+0yQRAEQRAEQURPxBa7b775Bg8//DDGjh2L3r17N2SbCIIgCIIgiBiI2GK3atUqlJWVYeDAgRg0aBD+9re/4fjx4w3ZNoIgCIIgCCIKIlbsBg8ejLfeegt5eXl44IEH8NFHH6Fz584wDAPZ2dlxKXVCEARBEARB1E7UWbFt2rTBPffcg1WrVmHr1q147LHHMGfOHKSnp+Oaa65piDYSBEEQBEEQERBzuRMAOPPMM/H888/j8OHD+PDDD3m1iSAIgiAIgogBV4qdhSRJuO666/Dll1/yEEcQBEEQBEHEABfFjiAIgiAIgmh8SLEjCIIgCIJoIZBiRxAEQRAE0UIgxY4gCIIgCKKFQIodQRAEQRBEC4EUO4IgCIIgiBYCKXYEQRAEQRAtBFLsCIIgCIIgWgik2BEEQRAEQbQQSLEjCIIgCIJoIZBiRxAEQRAE0UIgxY4gCIIgCKKFQIodQRAEQRBEC4EUO4IgCIIgiBYCKXYEQRAEQRAtBFLsCIIgCIIgWgik2BEEQRAEQbQQSLEjCIIgCIJoIZBiRxAEQRAE0UIgxY4gCIIgCKKFQIodQRAEQRBEC4EUO4IgCIIgiBYCKXYEQRAEQRAtBFLsCIIgCIIgWgik2BEEQRAEQbQQSLEjCIIgCIJoIZBiRxAEQRAE0UIgxY4gCIIgCKKFQIodQRAEQRBEC6HZKHZFRUW4/fbbkZKSgrS0NNx77704efJkna+pqqrCuHHj0KFDB7Rt2xajR49GQUGB4xpBEEJ+Pvroo4bsCkEQBEEQRIPQbBS722+/Hdu3b0d2dja++uor/O9//8P9999f52smTJiA//znP1iwYAFWrlyJI0eO4IYbbgi5bt68ecjLy7N/rrvuugbqBUEQBEEQRMMhN3YDImHnzp1YvHgxfvjhB1xwwQUAgNdeew2jRo3Ciy++iM6dO4e8pqSkBG+//Tbmz5+PK664AoCpwJ199tlYu3YtBg8ebF+blpaGzMzMiNvj8/ng8/ns/0tLSwEAqqpCVdWY+ticsfrcGvtuQWNAYwDQGAA0BgCNQWvvP9C4fRcYY6zR3j1C3nnnHTz22GM4ceKEfUzTNCQkJGDBggW4/vrrQ16zbNkyDB06FCdOnEBaWpp9vHv37nj00UcxYcIEAKYrtnPnzvD5fOjZsycefPBB3H333RAEodb2zJgxA88++2zI8fnz5yMpKclFTwmCIAiCaO5UVFTgtttuQ0lJCVJSUuL63s3CYpefn4/09HTHMVmW0b59e+Tn59f6Go/H41DqACAjI8PxmpkzZ+KKK65AUlISlixZgj/+8Y84efIkHn744VrbM2XKFEycONH+v7S0FF27dsXll1+ODh06xNDD5o2qqsjOzsaVV14JRVEauzmNAo0BjQFAYwDQGAA0Bq29/wBQWFjYaO/dqIrdk08+ib/85S91XrNz584GbcPUqVPtvwcMGIDy8nK88MILdSp2Xq8XXq835LiiKK12EgPUf4DGAKAxAGgMABoDgMagNfe/MfvdqIrdY489hrvuuqvOa3r27InMzEwcPXrUcVzTNBQVFdUaG5eZmQm/34/i4mKH1a6goKDOeLpBgwZh1qxZ8Pl8YZU3giAIgiCIpkqjKnannHIKTjnllHqvy8rKQnFxMTZs2ICBAwcCMGPoDMPAoEGDwr5m4MCBUBQFS5cuxejRowEAu3fvRm5uLrKysmp9r02bNqFdu3ZRKXVWmGJZWVmrfDpRVRUVFRUoLS1tlf0HaAwAGgOAxgCgMQBoDFp7/wFTHwCq9YO4wpoJI0eOZAMGDGDr1q1jq1atYr1792a33nqrff7w4cPszDPPZOvWrbOPPfjgg6xbt25s2bJlbP369SwrK4tlZWXZ57/88kv21ltvsa1bt7I9e/aw119/nSUlJbFp06ZF1bZ9+/YxAPRDP/RDP/RDP/RDP/bPvn373CtAUdIskicA4F//+hfGjx+PoUOHQhRFjB49Gq+++qp9XlVV7N69GxUVFfaxl19+2b7W5/NhxIgReP311+3ziqJg7ty5mDBhAhhj6NWrF1566SXcd999UbWtffv2AIDc3Fykpqa67Gnzw0oeOXToUNyzf5oKNAY0BgCNAUBjANAYtPb+A2bJtW7dutn6QTxpFuVOmjqlpaVITU1tlLTmpkBr7z9AYwDQGAA0BgCNAUBj0Nr7DzTuGDSbnScIgiAIgiCIuiHFjiAIgiAIooVAih0HvF4vpk+f3mrLo7T2/gM0BgCNAUBjANAYADQGrb3/QOOOAcXYEQRBEARBtBDIYkcQBEEQBNFCIMWOIAiCIAiihUCKHUEQBEEQRAuBFDuCIAiCIIgWAil2BEEQBEEQLQRS7ADMnTsXp512GhISEjBo0CB8//33dV6/YMECnHXWWUhISEDfvn2xaNEix3nGGKZNm4ZOnTohMTERw4YNw549exzXFBUV4fbbb0dKSgrS0tJw77334uTJk9z7Fik8x0BVVUyePBl9+/ZFmzZt0LlzZ9x55504cuSIQ8Zpp50GQRAcP3PmzGmQ/tUH7zlw1113hfRt5MiRjmta8hwAENJ/6+eFF16wr2lKcwCIbgy2b9+O0aNH23145ZVXYpJZVVWFcePGoUOHDmjbti1Gjx6NgoICnt2KCt5jMHv2bFx44YVITk5Geno6rrvuOuzevdtxzWWXXRYyDx588EHeXYsY3mMwY8aMkP6dddZZjmta+jwIt9YFQcC4cePsa5rzPHjrrbfw61//Gu3atUO7du0wbNiwkOvjphvEfXfaJsZHH33EPB4Pe+edd9j27dvZfffdx9LS0lhBQUHY61evXs0kSWLPP/8827FjB3vmmWeYoihs69at9jVz5sxhqampbOHChWzz5s3smmuuYT169GCVlZX2NSNHjmT9+vVja9euZd999x3r1asXu/XWWxu8v+HgPQbFxcVs2LBh7OOPP2a7du1iOTk57KKLLmIDBw50yOnevTubOXMmy8vLs39OnjzZ4P2tSUPMgTFjxrCRI0c6+lZUVOSQ05LnAGPM0fe8vDz2zjvvMEEQHJtiN5U5wFj0Y/D999+zSZMmsQ8//JBlZmayl19+OSaZDz74IOvatStbunQpW79+PRs8eDC7+OKLG6qbddIQYzBixAg2b948tm3bNrZp0yY2atQo1q1bN8fnPGTIEHbfffc55kFJSUlDdbNOGmIMpk+fzs4991xH/44dO+a4pqXPg6NHjzr6n52dzQCw5cuX29c053lw2223sblz57KNGzeynTt3srvuuoulpqayw4cP29fESzdo9YrdRRddxMaNG2f/r+s669y5M5s9e3bY62+66SZ29dVXO44NGjSIPfDAA4wxxgzDYJmZmeyFF16wzxcXFzOv18s+/PBDxhhjO3bsYADYDz/8YF/zzTffMEEQ2C+//MKtb5HCewzC8f333zMA7ODBg/ax7t27h/0CiDcN0f8xY8awa6+9ttb3bI1z4Nprr2VXXHGF41hTmQOMRT8GwdTWj/pkFhcXM0VR2IIFC+xrdu7cyQCwnJwcF72JjYYYg5ocPXqUAWArV660jw0ZMoQ98sgjsTSZOw0xBtOnT2f9+vWr9XWtcR488sgj7PTTT2eGYdjHWso8YIwxTdNYcnIye++99xhj8dUNWrUr1u/3Y8OGDRg2bJh9TBRFDBs2DDk5OWFfk5OT47geAEaMGGFfv3//fuTn5zuuSU1NxaBBg+xrcnJykJaWhgsuuMC+ZtiwYRBFEevWrePWv0hoiDEIR0lJCQRBQFpamuP4nDlz0KFDBwwYMAAvvPACNE2LvTMx0JD9X7FiBdLT03HmmWdi7NixKCwsdMhoTXOgoKAAX3/9Ne69996Qc409B4DYxoCHzA0bNkBVVcc1Z511Frp16xbz+8ZKQ4xBOEpKSgAA7du3dxz/17/+hY4dO6JPnz6YMmUKKioquL1npDTkGOzZswedO3dGz549cfvttyM3N9c+19rmgd/vxwcffIB77rkHgiA4zrWUeVBRUQFVVe15Hk/dQI74yhbI8ePHoes6MjIyHMczMjKwa9eusK/Jz88Pe31+fr593jpW1zXp6emO87Iso3379vY18aIhxqAmVVVVmDx5Mm699VakpKTYxx9++GGcf/75aN++PdasWYMpU6YgLy8PL730ksteRU5D9X/kyJG44YYb0KNHD+zbtw9PPfUUrrrqKuTk5ECSpFY3B9577z0kJyfjhhtucBxvCnMAiG0MeMjMz8+Hx+MJeeCpaywbioYYg5oYhoFHH30Ul1xyCfr06WMfv+2229C9e3d07twZW7ZsweTJk7F79278+9//5vK+kdJQYzBo0CC8++67OPPMM5GXl4dnn30Wv/71r7Ft2zYkJye3unmwcOFCFBcX46677nIcb0nzYPLkyejcubOtyMVTN2jVih3R8KiqiptuugmMMbzxxhuOcxMnTrT/Pu+88+DxePDAAw9g9uzZzX6PwVtuucX+u2/fvjjvvPNw+umnY8WKFRg6dGgjtqxxeOedd3D77bcjISHBcbwlzwEilHHjxmHbtm1YtWqV4/j9999v/923b1906tQJQ4cOxb59+3D66afHu5ncueqqq+y/zzvvPAwaNAjdu3fHJ598EtaK3dJ5++23cdVVV6Fz586O4y1lHsyZMwcfffQRVqxYEfKdFw9atSu2Y8eOkCQpJPOooKAAmZmZYV+TmZlZ5/XW7/quOXr0qOO8pmkoKiqq9X0bioYYAwtLqTt48CCys7Md1rpwDBo0CJqm4cCBA9F3JEYasv/B9OzZEx07dsTevXttGa1hDgDAd999h927d+MPf/hDvW1pjDkAxDYGPGRmZmbC7/ejuLiY2/vGSkOMQTDjx4/HV199heXLl6NLly51Xjto0CAAsNdLvGjoMbBIS0vDGWec4fg+aC3z4ODBg/j2228j/j4Amtc8ePHFFzFnzhwsWbIE5513nn08nrpBq1bsPB4PBg4ciKVLl9rHDMPA0qVLkZWVFfY1WVlZjusBIDs7276+R48eyMzMdFxTWlqKdevW2ddkZWWhuLgYGzZssK9ZtmwZDMOwJ3K8aIgxAKqVuj179uDbb79Fhw4d6m3Lpk2bIIpiiCm6IWmo/tfk8OHDKCwsRKdOnWwZLX0OWLz99tsYOHAg+vXrV29bGmMOALGNAQ+ZAwcOhKIojmt2796N3NzcmN83VhpiDACzxMP48ePx+eefY9myZejRo0e9r9m0aRMA2OslXjTUGNTk5MmT2Ldvn92/1jAPLObNm4f09HRcffXV9V7b3ObB888/j1mzZmHx4sWOODkgzrpBxGkWLZSPPvqIeb1e9u6777IdO3aw+++/n6WlpbH8/HzGGGN33HEHe/LJJ+3rV69ezWRZZi+++CLbuXMnmz59ethyJ2lpaeyLL75gW7ZsYddee23YlOYBAwawdevWsVWrVrHevXs3aqkLnmPg9/vZNddcw7p06cI2bdrkSF33+XyMMcbWrFnDXn75ZbZp0ya2b98+9sEHH7BTTjmF3Xnnnc2+/2VlZWzSpEksJyeH7d+/n3377bfs/PPPZ71792ZVVVW2nJY8ByxKSkpYUlISe+ONN0LesynNAcaiHwOfz8c2btzINm7cyDp16sQmTZrENm7cyPbs2ROxTMbMMhfdunVjy5YtY+vXr2dZWVksKysrfh0PoiHGYOzYsSw1NZWtWLHC8V1QUVHBGGNs7969bObMmWz9+vVs//797IsvvmA9e/Zkl156aXw7H6AhxuCxxx5jK1asYPv372erV69mw4YNYx07dmRHjx61r2np84AxM7O0W7dubPLkySHv2dznwZw5c5jH42GffvqpY56XlZU5romHbtDqFTvGGHvttddYt27dmMfjYRdddBFbu3atfW7IkCFszJgxjus/+eQTdsYZZzCPx8POPfdc9vXXXzvOG4bBpk6dyjIyMpjX62VDhw5lu3fvdlxTWFjIbr31Vta2bVuWkpLC7r77bscEiDc8x2D//v0MQNgfq2bRhg0b2KBBg1hqaipLSEhgZ599Nvvzn//sUHziCc/+V1RUsOHDh7NTTjmFKYrCunfvzu677z7HzZyxlj0HLN58802WmJjIiouLQ841tTnAWHRjUNs8HzJkSMQyGWOssrKS/fGPf2Tt2rVjSUlJ7Prrr2d5eXkN2c064T0GtX0XzJs3jzHGWG5uLrv00ktZ+/btmdfrZb169WKPP/54o9UvY4z/GNx8882sU6dOzOPxsFNPPZXdfPPNbO/evY73bOnzgDHG/vvf/zIAIfdDxpr/POjevXvYMZg+fbp9Tbx0A4ExxiK37xEEQRAEQRBNlVYdY0cQBEEQBNGSIMWOIAiCIAiihUCKHUEQBEEQRAuBFDuCIAiCIIgWAil2BEEQBEEQLQRS7AiCIAiCIFoIpNgRBEEQBEG0EEixIwiCIAiCaCGQYkcQBEEQBNFCIMWOIAiCIAiihUCKHUEQBEEQRAuBFDuCIAiCIIgWAil2BEEQBEEQLQRS7AiCIAiCIFoIpNgRBEEQBEG0EOTGbkBLwDAMHDlyBMnJyRAEobGbQxAEQRBEI8IYQ1lZGTp37gxRjK8NjRQ7Dhw5cgRdu3Zt7GYQBEEQBNGEOHToELp06RLX9yTFjgPJyckAgP3796N9+/aN3Jr4o6oqlixZguHDh0NRlMZuTqNAY0BjANAYADQGAI1Ba+8/ABQVFaFHjx62fhBPSLHjgOV+TU5ORkpKSiO3Jv6oqoqkpCSkpKS02kVMY0BjANAYADQGAI1Ba+8/YI4BgEYJz6LkCYIgCIIgiBYCKXZNhR/fB/K2cBHl1/14af1LYIxxkVe5eTNK/vMVF1kAsHnpIZQcq+Aiq6r8JFZ/8gEXWQBQ9dMJVO4s5CZv5cqVKC8v5yKrypePAwff5CILAP5ztBhri09ykcUYwwtLfoJf5yIOOPYT8MP/4yQM+HzP59hdtJuLLMPvR8ELL3BbX/k/l+Cn7/O5yAKADV9/geICPvKMSg0lSw5wkQUAe/fuxU8//cRNHkEQoZBi11T4cjywYjYXUXuL92Le9nk4VnmMi7y8Z6biyOOPc5EFAKsW7MGuHD43nkPbt2DtZx/B0PloFMff2YbC93ZwkaVpGpYvX44DBw5wkZd3ZAH27XueiywAuG/7ATy8M5eLrKNlPvzjuwMoqOQizlwLXz/GSRgwbc00vL7pdS6yfD/tQdHb70A7xmd9LXt/F7Lf4TPnAGDFP9/C9pVLucjy7StG2bJDYAYfJfaDDz7A/PnzucgiCCI8pNg1JQQ+H0eJrwQAUOwr5iLPqKriIgeAbeUQRD5xB5rPB8C03DU1qgLjpnNSOhnTA78NLvIAQOIU/nGiwg8AqNA5CdR8fOQEIXJaX3pJsfm7uJiLPI2bmbN6fYkSn74agbYZlRoXeQRBNDyk2DUlON3MKjXTbGIpeG4ROAa/6qqplOgaH+XEH1Ceqk6WcZHHEyt4trKSkxkroJhoGj8l1s/JElMRUAAqeN3/ZQ8nQdX4DT8XOSzweRolfNaXJPP7Gtb85neIHph7bmF+c50aFXzkEQTR8JBi1xSwYnU4Zc9UaGb8mqXgNSVUn6kA6H4+ip3qMxU7laNVkRd+v9/x2y26bn6uusEnPpEnFYHPlaPxycRwL9C2EoPP+jIqzPE3eCnsHLHWgaXguYUFPlDGab0SBNHwkGLXFLAsdZxcRZZC59M5ubMMfl/qlmKnqXw0AEux0zgpTzyxFDpN42PG0vWApUjnp8SKvB4m/GYfVV5TxQiMmepeebLWAT/FLvA5cHqY4BW/BvBfD7Zix8nCThBEw0OKXVPAH8ia1Pl8GVcGboZVGqcbTyCmi0cWoOq3FDtOFruqpqvYWa5YlZNbzAhY7AzDvcJufZa8YuwqA4o6N8XOH7BKcpjDlgVbNTh9DgFLHfNxsooFPgsu64vzejACljrG6UGMIIiGhxS7poAaUOxUPoqYdSPjZrHTrS939zdG22LH2RWrqfyD7d3C22Kn2a5Y9/OkyrDck3wo93FW7NSAYsfBYmdZsKs4WTqNCnO9crPYBfQ5Q3ev2Fkxpypvix23D5YgiIaGFLumgGWx4xQTx9sVywI3CcbhRqZZMXa8XLEcLRS86pJZWIodd4sdBwWlIqCs80uesFyxnFRFfyBBhIfFLqAk+jglJ1nJE6yKjzwrkYiHFbvaFcs5xo5D23ivL4IgwkOKXVPAtk7wsQBYLlherljLMsHDQmFZ6ri5YgPuMC6upyCLCY+4J0uh4xZjF7DUGRwsdpWBuMkqTopdVUBR5xZjb1nqOFjs7PXAy2JXacphPj7y7DXBIfPEUui4xdiphuO3G4LXgcExbpcgCCek2DUF9IBFh5PFzool4maxU1VAELjEFOm6AQj8XLF64GbBw0LB9Oo28QgWt+rXcbPYGSoAgYsrVjUYBABVnG6w/oBSzM1jZ8Wbcng4aZD1AMDgZLEzNHNN6BwGT9c0QBD4KXaBdcBzPQD8HnYIgghFjuebFRcX4/PPP8d3332HgwcPoqKiAqeccgoGDBiAESNG4OKLL45nc5oOugp4krlZ7DRDQxulDTcLBdM0iG3acHHFGjqDxytxy4o1dA2exER+FrtANgFTDcAjuWubYcDj8XC7iTGmQpLawOCgoKiMoa0kooKTYqfpBtp4Jai8LDG6FlgT7h92rPXAzRVrrQdOyRP2muDwsGNoGjwJidxcsTAYBK/ExWJnGAYkSQJjDJqmwePhX6uQIIg4WeyOHDmCP/zhD+jUqROee+45VFZWon///hg6dCi6dOmC5cuX48orr8Q555yDjz/+OB5NaloYKqAkmr85oBkaEqQEaIZ7hYIxBqgqhMQEMA4KiqEzyB6JS6C4KU+H7PHaljs3MJ1BEAUIkuhwy8aKrutQFIXjzhMaJCkRjLnvq8YYEiUROuMT+6QZDImKxGPYTDiuCXs9cBg3AGCaCiExkct6YIzBMAJrgoNSbOg6FK+X2xZ7TGcQFH7rQRRFSJLEbU0QBBFKXCx2AwYMwJgxY7Bhwwacc845Ya+prKzEwoUL8corr+DQoUOYNGlSPJrWNNA1wNMGqCjiIk4zNCQpSVwUOwRuXmJiEpcbma4ZkL0cFTtNg5KQwOVGxgwGSCIEEWA8brIBix2veCLDULkpdn6DISmw7ZTKGDwu69n5NQOJigRuJdl0FUhsZ64Nl2jMXA+8ttiDpkFM4rMerHXAa03omgbFmwCDl5VYZxA8Erf1IEmS/TdBEA1DXBS7HTt2oEOHDnVek5iYiFtvvRW33norCgsL49GspoPuNxW7snwu4lRDRaKcyKVuF7MVu0Qu5U4MnUHxSFB9nBIKAjcyHhY7aAYESTBrgGh8LBQej4ejxU6FJCUFYu3coTGGBDGg2BkMHpe2e80wkOSRoPEqJ6ir5prgUNtR1c31cLzyOIeGmTF25npw3zZLmVM8InQOc87QNSheL/ycEjugGxA9Ihin9WApdmSxI4iGIy6u2PqUOrfXN3sawhUrc3LFahogSRA8HjCVj4VC8YocXbFawPXEoa+GGWMnSCKXrFjurlhDgyQmgjEO9QQDVjqPIEDl4YrVGRI9TdMVqzIVCXICtwLFTNUgJvAKTTAgigIkWYSh80ie0CEnJMDQeM0502LHwxRLrliCiA9xz4qVJAmXX345ioqcbseCggL7aa7VoWuAkmRuo8TBRaEyvhY7QZYhKAoni50B2SPZtbvcous6P4tdIMYOssAlC9AwDK6KncE002LHQbHTDAZZFKCIfBQ7VWdI4hljp6vmmtD5xNglyonQDI1LPCHTNAhJiQAnC7YoCRAlEQY3i10CdI2PEgvLFctB6bRcsaTYEUTDEnfFjjEGn8+HCy64ANu3bw851yoxAm4n62+XBN/I3MJU1VTsZJmb64lr8oQVY8creUISTOWOU7A4X1esBlFKBONixWJQBAGKIHApUqwZRsBix6FAsaEDYNxcsdZ6sP52C9M0M+aUq2InmKWAXMsLJE/wjLFTRG6hCaIoQhRFUuwIogGJu2InCAI+++wz/Pa3v0VWVha++OILx7lWia4CckL13y7RDA2JUiJUDrIQbLHjFCyueCXonLNiebhiwdkVa1nseAWKmzF2iTA4ZcXKgmmx0zi5YhN4WeyseaskclsPCZK5vvhYsVXTFcshNEHXDYiSCEkWuDzsGFbMKS/FybCSJ/isB8tiR8kTBNFwNIrFTpIk/PWvf8WLL76Im2++Gc8991zrtdYBppVOUgBR4WehUDgmTygKBFnm5HoyIHtEsygrB6pdTzwsdgYEUQQkPq5Y3jF2hhVjZ3BIKOBssVP1QPIEj4/VmrcyP8VOERXIgswnzk41XbF8LXYil/AE3XrQ4eSKZboBQRG5rQeKsSOIhieuBYprcv/996N379648cYb8b///a8xm9K46Jqp2Eke7jFFbrFdsR4+MXZ6ICvW0BkYY66ttHrA9VRVftJ125jOAJmfK9Yqd8IzK1aUErnE2KlWjB2n5AlVN/ha7CSPuSY4PegokgJFUrg97IiJSdBU91nshlbtiuVjsVOhJJh1HXmsL+gMokeCUcnBWh+w2JErliAalrhb7Lp37+5Ikrj88suxdu1aHDp0yJXcOXPmQBAEPProo/axqqoqjBs3Dh06dEDbtm0xevRoFBQUOF6Xm5uLq6++GklJSUhPT8fjjz8e/+1uDNW01kkK1xg77skTvAoUe61aVrxcT5xiioxA8kQTzIpljAUKFCeBcVDYLYudh1PyhGZwTJ4wtMB68HBbD7IgQxZljjF2fAoUG4YBUeKYFRtIJgL41GI0s2L5rQdKniCIhifuit3+/ftDypn06tULGzduxM8//xyTzB9++AFvvvkmzjvvPMfxCRMm4D//+Q8WLFiAlStX4siRI7jhhhvs87qu4+qrr4bf78eaNWvw3nvv4d1338W0adNiakfM6P6AxY6PhcKqY8fHYmcqdpBlflmxijntuGQBcqxjx3Qrxk4AD58iz+QJqyixxMtiF4ixkwUBKidXbKJHAgfdJLAe5MB64GGdVCGLMhSRk8VOVSFydcWKZvIEr6xYjxcAuGTGMo1BUCRu64GSJwii4WlUV2wwCQkJ6N69e9SvO3nyJG6//Xa89dZbeO655+zjJSUlePvttzF//nxcccUVAIB58+bh7LPPxtq1azF48GAsWbIEO3bswLfffouMjAz0798fs2bNwuTJkzFjxoxa9zL0+XzwBe0TWVpaCsDc7D2WDd9F1QdAhCgq0HxVrmPZVF2FIijw637XG9BrVZWmUifJ0Kp8YeVZxyJ5L03VAVGGIArwVfkB0d0U1HUNoqJA02Ibe0fbfCogAEwENL8WlbxwY6BpGkRRhGEYrtum69aeqR7oHD5Xn6pBBoMsAJUxzttgVM2AVzI92G5lwVcJWVRgCBKg+mC47avmgwgRsiCjyl/lun1MVcEUDww19HOIZi0AgN+nQpQAiIAa5ZwLh+ZXAVGEIIrwVVXBFO4Cw4AhmzvGRNq22sbA7/fbil2s35XNhWjnQUujtfcfaNy+x02xa9euXUTxHjXr29XHuHHjcPXVV2PYsGEOxW7Dhg1QVRXDhg2zj5111lno1q0bcnJyMHjwYOTk5KBv377IyMiwrxkxYgTGjh2L7du3Y8CAAWHfc/bs2Xj22WdDji9fvhxJSUlRtR8AzjqyEyLT0dmn4fuVS1GauCdqGcGUlZdh3859KPIVYdGiRa5kJe7fj1MqKlCVdwSq34cTi9JqvTY7O7teeScOeCEfMwDBiyX/zYbkdWel0Pwqdu3Zg5N5ea77mlaooGORF4YAFP94GEWHoreeBo9BXl4eKioqoOs6vv76a5fxTpVo01bEjh17IEkHsXePu75uVpKRL3lQLspYvfYginR3OxUcL5JwYG8hdCZGNA/qom1VHi5WdRz8+SAkw48dFe76uqtyFwyYismylcuQKWW6ktejrAyH9+1FamEhttYy5yIdA1+RhLKTXvh+KUZBsYHc8k2u2nb0wH54ThQDgoAlixdDSkh0JW+A2g7bd+9AWqGCnEX7onptzTE4ceIEioqKIAgCNmzYgP3797tqW3PA7Vpo7rTm/ldUVDTae8dNsXvllVfsvxljGDt2LGbOnIn09PSYZX700Uf48ccf8cMPP4Scy8/Ph8fjQVpamuN4RkYG8vPz7WuClTrrvHWuNqZMmYKJEyfa/5eWlqJr1664/PLLY9o1Q1y2HhBliLt249dZg8A6h1coI+Wvn/8VF/a/EFu2b8GoUaNcyapYtw6Fq1cjo+fpkE7piPZh5KmqiuzsbFx55ZVQFKVOeSuKfkLHrm2x/uABXH7ZFWjbzuuqfa99+DYGDLwA28uKXfe1cvNxVG0thCAL6N47DYkDI5+b4cbgww8/RN++fXHo0CGMHDnSVQFuVT2Bdd/PRN++/VFcXImzz3LX119+OQ6xwg+j0ocBXc7AFe2TXcl780AOzu/XBf/J3RHRPKiTozshH2mL3meeDVQU4bTh7vq6Z+MeKKKC3NxcDL5kMM5pH36/6kjZ/+L/4bwLL8KJzaHrK5q1AAC/7D6BHwoO4pRubdEm1Yv+w7u6alv2ob1I79kLOTu34PLLLkPb9u528SlYuxZ9z++Hyg1HccaoSyN6TW1jsG3bNuzYsQOSJKFXr17o16+fq7Y1ZaKdBy2N1t5/AI26NWrcFLsxY8Y4/n/ooYcwevRo9OzZMyZ5hw4dwiOPPILs7GwkJCTwaGLEeL1eeL2hComiKDFOYgNQvIDkhSwCcLkQdKajrbctNKa5XlQSA0TFA8nrhRioy1YbEfWfAYpHhiSLkETJVfuYYYAxAwlJSWD1tC0S/IIISRYhKCJEQYxJXvAYMMbsuSmKscmzMAxAEBQocgIA9301BBEeWYJXEsFcfg4AoBtA2wQPdOZmHQQQGSApkJQEADok13014FE8UCQFEOH+RqNpkNu2AbTa11ekYyAIEiRZhOyRAQiu28YMAx6PF5IsQxTcyWMGM9drgoIqFv24hRsDWZYhy7J9vqXjei00c1pz/xuz33FPnuDFhg0bcPToUZx//vn2l8XKlSvx6quvQpZlZGRkwO/3o7i42PG6goICZGaarpjMzMyQLFnrf+uauKCrZqxZU0ye0FTOW4rxq9tlBWAr3gQ+dbsCyROQRC7B4jzLOzCmQRBkCKLCZa9YjTEoAqAIIvw8yp0YPJMngrJieZU7ERUzeYJDMkZD7DwhSXz2TzZ0HaIkQZJl9wlFgfaYW4rxLVBMyRME0XA0W8Vu6NCh2Lp1KzZt2mT/XHDBBbj99tvtvxVFwdKlS+3X7N69G7m5ucjKygIAZGVlYevWrTh69Kh9TXZ2NlJSUnDOOe7cNVFh8K/bxa1AsWNLMQ517DQDEqe6XdZuE7LXyycr1jAgSCIESeByI7PKO/BQ7AzDD1GUIQoKDA4Fiv32zhOmUuYWVTc4ljsJXg/8ChRzy4rVNH5ZsZoRlBXLIfNU0yDKMkRZdv2wY5VLMbcU45MVS3XsCKLhaTJZsdGSnJyMPn36OI61adMGHTp0sI/fe++9mDhxItq3b4+UlBQ89NBDyMrKwuDBgwEAw4cPxznnnIM77rgDzz//PPLz8/HMM89g3LhxYV2tDYauBhUo5rBdFMcCxdA0QDELFINDEWDDYIEtlNxbKAyt2jph8CgpYlvsBG5bKFmV9t1uoeS02PGYI9bOEyKfOnaBLcUYBOgGgysnhK5yLXeiGRpksYnWsbMsdrIA1cen3IltsXO7JprweiAIonbiptgFJxsAZur7n/70J6SmpjqOv/TSS9ze8+WXX4Yoihg9ejR8Ph9GjBiB119/3T4vSRK++uorjB07FllZWWjTpg3GjBmDmTNncmtDRBia6YoVZdcWO8ZYAxQoVrhZ7Bybnru0Apg3MRmiJHOp2QWdQQjsFcvTQsHD9WQwDYKgQBRkGBw+V5UxJEoiFE4FilWdIckjBf424Crq1SrYzXGLPVngU8eOMQaoqqnYcarrKIpmaAKPbfYMXYcUWBNui3Yz3SzYLUgil51YqEAxQcSHuCl2GzdudPx/8cUXhxQkdrv9zYoVKxz/JyQkYO7cuZg7d26tr+nevbvrMhmuCS5Q7PLGozMdDAwJUgK/AsWKEihQzMNCYUCURS6uWF3TIMmyaQHgZbET+VkoeBZkZYYKUVQgCDIfix1j8AgCZAFcChRrhgGvLEIAg+pWCbAt2Ir50OMSq0AxF4tdQFkSOFnsdJ1BCqwHndNOLKIsQ5Qk6C6t/6YF2wpNoALFBNFciJtit3z58ni9VfNDV4OCxd19GVs3rgSZk2LXAFuKWckTbrdQstxOoqzw2VJMr46x47VXrGWh4OeK9XBJnlAZIAsCPIIIjZMrVpZEmJt2uFQCHMlE/Fyxiqi4XhPWGhATEhpgPXC0iskyDM2tK9Yw10ITXA8EQdROs02eaFEYmnkT4+CK1QwNAgR4JS90psNgLhUKKytW5psVK0kCdNcWOx2iLEOSJU7JE4EtxUR+yRNWTBEPV6zI0RWrGQyKKEAWBfg5bSkmiwIkAe4tdkbAYsfTFRuw2Ll2xWqaubODxwNomumadUFwaAIfV6xlseORPNF01wNBELUTF8Vuzpw5EVdhXrduHb7++usGblETI9hC4fLGE3wTs/53J1CDoASyYjlZKHhmxYqSZN7EeNwoAjFFkEQurieu5U4MFYIoc3PFWnvFKgL4WOwMBkUyFTvN7djZ5U44uWIZP1esbcEO1GJzu/2foVdnxXIpdxJIKBJlDsqTYz3ws9iRK5YgGpa4KHY7duxA9+7d8cc//hHffPMNjh07Zp/TNA1btmzB66+/josvvhg333wzkpPdVcFvdljlHUT3rieNmaUdJMEMZHd9I1NVQJYhKDIYhwQFXQu+kbl1xVqB4u7jiYBAsLgkmO4nTjF2/FyxanVWLBdlx8yKlQX3yROGwaAbDLIoQhQ5xOzZFjuZa7kTLoqdqtoxpwBcP+wEW7C5uGI11U4oMjjE2FWvB77JROSKJYiGIy4xdv/85z+xefNm/O1vf8Ntt92G0tJSSJIEr9drW/IGDBiAP/zhD7jrrrvivpNEo6Nr3ILFLYudIAjcXE9WViy4JE8EXE9cyp1YpR0U9/FEgKnMSaKZPMHJQsHTFSsIsumK5RFjZzDIogBFEKC57KpVB0+WzGQMjVvyhMe1BRuoEWPn1tppWewEwUwocq3YGdxiTk15uplQxKMEkOWKbYLrgSCI2olb8kS/fv3w1ltv4c0338SWLVtw8OBBVFZWomPHjujfvz86duwYr6Y0PQx+O09YGYAA+JR3UM0bGbjtPBG4kYnuY4p0XQ8UY5Vg6Ga8k5vMahYIFueVPMGzICszzBg7QeC584QARRRQ4VKhsBS56hg7lwqKVe6kAerYud15gmmaveUfj91YdN2s6yjK7mNOAWd4gtu4U6YbEETRTp5wu76oQDFBxIe4FygWRRH9+/dH//794/3WTRc9OFicT4wdAO4xRdyyAEXR3FKMY4yd+b9prYgVq9yJIPKLseNXoNiMsRNFBQZHV6xpsXP3OWi6af0TBCvGzq3FTjMLFHNYD0ANV6xLi521HgBwWRM8s8SBwMOOFCgBxKGOnZk8EYjYMQBIscujAsUEER8oK7YpEGyh4OCKVUTTosCnvIMaSJ7gXe6EQ/KEZsbYSZIUkO2yfQbjVt6BMcZ3SzGr3AmvOnaGmTxhxti5k6UaBmTJtOSIAoctyuz1IHN1xXIJTVBrKHYuwxN4rgfAqmMnmVuKcXDF2usBcB1nRxY7gogPpNg1BXR+weLBrlhZ4FOQVVCUQPIEJ8VO5hMsrusqRFmGIIoQBNH1jcy2UHAoUGxZJLhZ7AwNougJKHZ8dp7wiKYrVnPZV01nUCTzq4SPxc4fZMHmVKBY4JQVG9g7GTAVO7hMKDJ0AxLPrNiA1ZpfgWKz3AkEuI6zCy53QhY7gmg4SLFrALb9UgJ/NPFjdrkT98Hi1vZJAKBIfGLsYBUo5hRjJ0liIHnCZVaspkOSTWudJLuPKUJQTJHbm5h14+K1hZKVFWu6YvnE2MkBV6zfZa1DVTdsxU4WOcTY2eVOGiB5wvWDjmnBBvjE2FVnxYqut9gz5Znb7JkFijmsh8DnymtNxLIeNK0MJ8v3uHpvgmhNkGLHGcYYfvPaKizbVRD5i6xyJxyCxTVDgyKZrlh+FgqFi3UCsILFedaxM2+yoswnpkiQAzFFLpUTXdchCAK3LZQMpkIUZAiCAsAAc6mM+Y3q5AnXWbGB4sSA6Yp1awG0y51I7gt2A84YOy4FigPJE+BgxTY0g6srVtd4Jk8EttgDAmvCvcUuFlfs3n3PY926ka7emyBaE6TYcabMZ36ZFldEcQOxyp1wcMUGW+x4uGLtYHFue8UGK3YcsmID8XVcihQbQXvFcrBOiIGgc16uWCvGDoBrd6zGzIQHWRBc150zixNbrljGwWKncnXF8t5STJADWbEc4k4NKyuWY4Fiyc4U5xRjBwT2T3ZpYY8xeaKq6hdX70sQrY24Z8Vef/31YVPmBUFAQkICevXqhdtuuw1nnnlmvJvGheJy84Z7IhrFLrjcCaedJwDwywLklDzBGAMzrBsZh6xYLchixymmiFeBYss6AYBPuROmQhAVCIHC04ahQRS9McvjmRWr6tXJE1xi7AwNUJK4rAfALNotizKfBx3OyRM6x6xYZpiW3OrdWDisB8tixyGhKPbkCbMNbsutEERrIe4Wu9TUVCxbtgw//vgjBMEskbBx40YsW7YMmqbh448/Rr9+/bB69ep4N40LRRWm66ikMhqLXVBBVpdfxtZNDACnul2BvWIVmUs8EYDqSvsufYBGoI4dAC5Fis1gcZFLQVbeFrvqrFiBSy07K8ZOFtzvFWuVOwHAp46drppuWE517KyEIkXilCXuUOz4xNjxsNhZypIVY+c+5pTZGbE810S064ExPfB6n6v3J4jWQtwVu8zMTNx22234+eef8dlnn+Gzzz7Dvn378Pvf/x6nn346du7ciTFjxmDy5MnxbhoXigOKXaU/ii9VIxAsLrqPKapZoJhHVqydPMHB7QSAmyvW0LVqq5gsQXcbA2hU743JI8bOahuX5AlDgxhww4qiAsOlJVY1GBRRgEfkUMfOMJxZsTxi7MSAK9ZQAdftq7bY8dmJJSh5gktWrACJQ4Fiy0LHa/9kZgQnT7jfLzZ4S7HokidOBl4f2X7jBNHaibti9/bbb+PRRx+1rRmA6ap66KGH8I9//AOCIGD8+PHYtm1bvJvGhSrV/MKq8EfxpWpb7JqgK1at3lKMx/ZJQqCQrel6cnmj0PQgVyyHG5lu2OUdeFrseLpiAZglT9zOExZcx86tK5ZVu2JF839XBK8HgFttRx7JRNA0QAkud+JyTQSFJvDIEhclySwUzatAsZ08Ibh+2LHWRLTrwTAqAQC6Xunq/QmitRB3xU7TNOzatSvk+K5du+zFnpCQ0GxjKapU88uvQo3iRm7F2DXAzhO8LBTmXrF83E4A+GXFytVWMdcFivXqgqxu69jVtNjxcsUC4FKkmP/OE8EWO7cFirXq9QC4WhOMMUeBYp7JE1yyYhssS1x2XwRYr5k8wc9iF8160PUq87dBFjuCiIS4J0/ccccduPfee/HUU0/hwgsvBAD88MMP+POf/4w777wTALBy5Uqce+658W4aF3yBOK/KSC12hg4wo7rcicsbj2qo9s4T3BQ7jxLIinWv2EmWZUcWobt1d2qavYWYKMtcYuyEQIwdr0BxgJMrlmkQhbYAAFFwX8tOY6YrVhHdx9iphgFPkCvWvcXOb64HUQQEyZUVW2c6GBgUUeGTFetXIShBWbGu14QBUQ5kxbqMOdX16vVg1rFzufZrxNjxWhPRrgcrts4gix1BRETcFbuXX34ZGRkZeP7551FQYNZ6y8jIwIQJE+y4uuHDh2PkyOZZt8inGUhLUlARaYydZY2wXE8cLXZcbmSqlTzhcW2d0DUDYkAB4G2hkCTZdVZsdbkT9/FEvF2xhhHkihXdJ0/Ydex4ZMVqNbNiOZU7AQJrIvbP1Zr/9pZiLsctJMbO7ZZiWnWBYveuWC2o/A+Hcic63xi7YFdsNBY7w/BBltMoxo4gIiTuip0kSXj66afx9NNPo7S0FACQkpLiuKZbt27xbhY3fKqBdkmeKCx2KgABEKWAK9Zd8kTwXrF8XE/VWbFgDEzXIUix7QTO3xUbVMeOS4Fiwyx3wiGeqKbFzu9397myQIFigI8rNnjnCbcxdprBIPO02FnJRIDrNaEZGkRBhCiI5npwWwKkZlas24edIFcsYwAzqkuMRC1Lq84S51Kg2Aiy2HFcE9Fb7PzweDpSjB1BREjcFbtgaip0LQGfpiM1MUqLXbB1gkOguCN5wm2wuLWlWOCGwTSNo2Ln3kIhBd/IOMQU2XvFNjGLnVWg2JTHISuWMSgCIHPYK1bVDShB5U5cZ8Va5U4A87cLV6yjYDeH0AQE6joClmLHJyvWWheGziDFqNiZFuygBx0eMXYi/3In0SdP+KAoadANUuwIIhIaRbH79NNP8cknnyA3NzfEkvHjjz82RpO4UaUaSE6Q7bIn9RJsneDlihU4umIDweKCJAGCYLqevLEVxjUMI0ix45AVq+vwBOKdJJlDQVa73AnfAsVcdp5gGresWMYYdGYqdVwsdjWyYl27Yq1yJ0CgtqMLxY7VCE3gULAbtiuWQ1ZsYOcJS4HSdQOSEltOm6HrkKzQBFnhUqBYVKr3iuW1JqJZD4zpYEyFLCfDMNxvL0cQrYG4Z8W++uqruPvuu5GRkYGNGzfioosuQocOHfDzzz/jqquuindzuOPTdKQkKPBHuqF3sHVC5FDupGaBYh7JE8EWCjX2L1frJgaYFjvddYFi584TXMo7SCIEzjF2PJInjBquWMNFrJilyCmcyp1ohsHXFWttsQcE1oS7GDueFmyr/I8pkF+BYrMEkLvwhJoxdq4LFAe7YjmuiWjWg6XMyVJbMFLsCCIi4q7Yvf766/jHP/6B1157DR6PB0888QSys7Px8MMPo6SkJN7N4Y5PM5CSKMMXqWLnsE64t9jxLlBcM1jcjYUi2BXLJ1jcuVcsj0r7VrkTGAzMhcLDf0sxpyuWufhcgxU7j+h+r1hVZzVcsTwsdkGuWBcxdjXXA/cCxW6TJ/QgK7bszoqtB+/Ewqmuo2DVGxUFs86jC4K3FDMMI6L1ZRhVEAQPRCkBOu08QRAREXfFLjc3FxdffDEAIDExEWVlZQDMMigffvhhvJvDHZ9qRGmxC7ZOyNzr2PHcQgkud59w3MQ4ZcU6yp1wqLQPUagOXndjPeG8pVhwjJ25pZgbKxaDJJj7M8tc6tgFW+wYvwLFgOvajg25Hnjsn2zoLGieuIs7DYmx42LB5lfuJNhiZ/1fH7rhgyR5IYoestgRRIQ0ypZiRUVFAMzs17Vr1wIA9u/f78pC0lTwaTqSE2T4Iv2CrhlPxHPnCQ6bnlvJE4D7LEA92BUr882K5RFj57DYAa4KsvKuY2cE7TwhCrKrcicqM611ALhlxSoSb4td8Jpw54q1ssR5bbHHN3mCX6a4oQXF2PFIJjKqCxQLHAsUW4psJO0zdB9E0QtR9FKMHUFESNwVuyuuuAJffvklAODuu+/GhAkTcOWVV+Lmm2/G9ddfH+/mcKdKNZCSaFrsIlJUddUsdQK4rtkFNMDOE7oeVJDVXUxRcIFiHlso6Zozxk53UaCYGQxgMC12gmDWs+NksYu2blfY9jG9OsZOlF0VKNYDpU4AM4GChyvW3nmCy5ZiWg1XrDuLnSSY64tXjF1w8oTrGDsjSLETBeiRWvrDyQraiUXkVaDYsl5Louv1AMDOihUEIaI1YRiWYuexCxUTBFE3cVfs/vGPf+Dpp58GAIwbNw7vvPMOzj77bMycORNvvPFGVLJmz56NCy+8EMnJyUhPT8d1112H3bt3O66pqqrCuHHj0KFDB7Rt2xajR4+2CyNb5Obm4uqrr0ZSUhLS09Px+OOPQ4vRMmVZ7ADAH4niYqhOVywHi51toZD4x9i5iSmqaZ1wv+m5HrSlmEuLXUC5cVgoXCieDbHzBC9XrLWdGAB4uGTFci5QbPBLKOLviq1OnnAbcwrUSCjiEWMX/KDD22Lnsm0Aok4oshU7wUMWO4KIkLgrdqIoQrZitgDccsstePXVV/HQQw/B4/FEJWvlypUYN24c1q5di+zsbKiqiuHDh6O8vNy+ZsKECfjPf/6DBQsWYOXKlThy5AhuuOEG+7yu67j66qvh9/uxZs0avPfee3j33Xcxbdq0mPrn0wy08cgQBEQWZ6fXLHfivkCxbaEQOGXFBhQUt64nQzfs+DVuO0+I1TFFbpIn7JuWZaHgbLFzX8dOrU6eEBRXWbEaY5Asi50ggMG04sWKajDIQckTXGLsOCUUNUiWuFXHUZb5Jk+4dcUGx9hJMp8Yu6D14OZBJ9hiZ/2OSrETvTAYKXYEEQmNUseuqqoKW7ZswdGjR0PM8ddcc03EchYvXuz4/91330V6ejo2bNiASy+9FCUlJXj77bcxf/58XHHFFQCAefPm4eyzz8batWsxePBgLFmyBDt27MC3336LjIwM9O/fH7NmzcLkyZMxY8aMsMqmz+eDz1ftFrB20FBVFVWqDllk8Moiyit9SKinlq+gVkESJWiqChgCZF01/44RVVchMAGqqkKECL/mh+pCHlNVaIHfkCVoVVUh8qz/63sf1a9BEM3rGDNgaIartmmaBgazrxBEaP7Y+2r4NEAUqi21kgDV54ehRvbsU3MMav7Wdd1VX3VDhWEExg4iNNUXs7xKvwpZCLQtoNBV+P1IEGN7zlNVDSJMeZIA+DV3fZUNDRoTAFWFJMow/JUxuzx9fh8kQYKqqhB0AZqhuWqbofphiOacY4IIvcaci3Qt2PJ0Bt3QoKoCRFGA36fG3D7V74cgiIE5YoYquOqrpsNgRqCvDLoambxwY+Dz+SCKor2+rN1Y6pPn91dAEDxgkKGpla76E0+inQctjdbef6Bx+x53xW7x4sW48847cfz48ZBzgiC4smxY5VLat28PANiwYQNUVcWwYcPsa8466yx069YNOTk5GDx4MHJyctC3b19kZGTY14wYMQJjx47F9u3bMWDAgJD3mT17Np599tmQ48uXL8fRwmRsXP89BEPC4uylaFdPLd+OZdtxdmk5vlu0CB6tDMNVHxYtWhRL9wEAB8oPQJVVLPp5EfZU7cEx4xgWHYtdXm9NQ/ayZTASEtCtogL7vvsOlYcPh702Ozu7TlkVv8ioOC5j0aJFUMtEnDyZ6KqvR/PzUbVlM/YVl+H4wYMQJAnHY5QnqwL6Is1uT181DSuWrYAvMTorhTUGR48eRVVVFRYtWoSysjIUFha66mtiUhHWrlsPQy+CN6EAhw9twsaNbWOS9YuoQE1Kt9sjJHfD14v/i0TEZi3afVCEIgDZ2h5IgoAj+QWu+jqi4iRWfbca5d69GFxYjIPrv0fe3tjatlfdi5NVJ7Fo0SKUG+XwuVxfGQcOosowULJoEdrt3QPl2HH8EEZefWsBMHVqQ0/Gt0uzIcrAyfIkrF61Bt4dsX0Hlu3fg5OFx7Fo0SL4iotwsqzUVV97FSTj+OZDKD6s4tSDiTBEIK9iS8SvDx4D6yZntUdVVSxbtgzeeoqdS9J2KJ6TOH5sD0TpCPbsib0/jUEk86Al05r7X1HReHsbx12xe+ihh3DjjTdi2rRpDmXKLYZh4NFHH8Ull1yCPn36AADy8/Ph8XiQlpbmuDYjIwP5+fn2NTXbYf1vXVOTKVOmYOLEifb/paWl6Nq1Ky6//HL8vyO7MORXffDhwY341aUXoXuHpDrbLezzQly9EqNGjQKqSiFue9j8O0ZWr16Nfhn9MKrXKJTuLsXOEzsxanBs8piuY9/kJzF81CiICQk49P4H6HnBBUgaNMhxnaqqyM7OxpVXXgklkGgRjt1rC5ArFuLKUeeguKACX23dilGjhsTUNgD496a16HfhhTh94CDklJ+AYRi4JMax00v9KNy62R77Yzt+xJBf94ecXvfnZ1FzDNasWYPS0lKMHDkSubm5yM7OdvW5rt/wOgae/2ukpPTDTz+tQVKb3uhyamzytp6sxPu7DmPUpebrldU7cMWVV6KdEtvXwcZFu5CaqODKX3XDxg+/RbsOHTFq1AUxyQIAedejGHLFMCC1K6SPP0CHPn3Bzo2tr6uPrMbm7Zsx6spRKPOX4YXPXnD1OeSvWInEfv2QOmoUik+cgG/XblwQJC/StQCY1rr/t3gVRl41ErIi4vPtGzHooh7ofEZaTG3bsXIpDug+jBo1CkVHDuPznBWu+lqUvwPdLshEwtntcTI7FwzAgCvr38c73BiUlpZiz549dnv27duHX//61+jYsWOdso4dE5Ff8BM6dhiA4hINZ58Ve3/iSTTzoCXS2vsPAIWFhY323nFX7AoKCjBx4kSuSh1gJmJs27YNq1at4io3HF6vN+yTpqIo8OsG2iR44JUlGIJY/6QWGCApEBUFYIkA06FIEhCjW0yHDq/shaIo8CpeGDBiXliWm9yTmAhBliF6PJAYapWnKEqd7yVAgCxLUBQFHq8HzGCuFj0zDHi8Zl9lxQN/ZUXM8gRRhyAJ9usFWYQkSFHLCx4D62+PxwPDiP1zAMzkCcWTAEVRIMleiIILeaIfilg9NxVRACQ59nkCAV6P+Xprr3hXX+aGBsWTCCgKIHsgwjD/jgEmMHgkDxRFQQISzJg7WTYzn2NAMAzIXvNzkBMS4Df0sH2tby0AgMZMy5w3wQNRFCDJEoRIvjNqaxsAWTH76vUmgNXStojlMUD2mv0QFRnMH5284DGw6tdZ/0uSBEEQ6pUniDpkKQGKkghAa3ZKQiTzoCXTmvvfmP2Oe/LE7373O6xYsYKrzPHjx+Orr77C8uXL0aVLF/t4ZmYm/H4/iouLHdcXFBQgMzPTvqZmlqz1v3VNNPhUAwmKBK8swqdGkjwRlBVr/eaUBei2bpcdGM4tecK5pRiX5Al7b0yXBYqDirECMJM8mlLyBNMgCkF7xbrNig1a+W5r2Zk7T1SXO9F4FiiWXGbF1tgrFoC7NVGjjp3bnVggmGVOAPdrQudcoBg6s5Od3BYoDl4PQJTJE1JCoI4dlTshiEiIu8Xub3/7G2688UZ899136Nu3b4hW+/DDD0csizGGhx56CJ9//jlWrFiBHj16OM4PHDgQiqJg6dKlGD16NABg9+7dyM3NRVZWFgAgKysLf/rTn3D06FGkp6cDMOMCUlJScM4550TdP59mwCuL8Mgi/JHczIOLsVq1u3QVkOsJzqsFjVWXO5FFGaqbnSw0FVAU27rBo46dvaWYLLqq2WXKC9q2y2WBYmaw6u2TENgbk2OBYvd17IK2FBPc1bFTg+rYAXC9X2xwuRNZAFQe5U7sOnYerjtPAOY2Y4oUowUweCcWjusBCCh2LvZPNrfYsx50FNdb7DFHuRN+6wGIfE0E17GjnScIIjLirth9+OGHWLJkCRISErBixQqHS0QQhKgUu3HjxmH+/Pn44osvkJycbMfEpaamIjExEampqbj33nsxceJEtG/fHikpKXjooYeQlZWFwYMHAwCGDx+Oc845B3fccQeef/555Ofn45lnnsG4cePqDewNh0/T4ZFF02IXabkT6yYjCPzrdrmw7ATXsAMAKO4tFFy3FAsqUCy5LVBcw2IHKeBTjLVtQa5XLjtPBJU7EUTF1c4TWlAdO8B0xbopUqwZLGhLMfP/mGHM3GkieEsxlztPWOvB3ELN3Zpw7sTirq6jrhu2BRswi3brLrcUk6wCxZLEYScWwzTBAoH1wM9iF10dOw8EkerYEUSkxF2xe/rpp/Hss8/iySefdCz0WLAKGl922WWO4/PmzcNdd90FAHj55ZchiiJGjx4Nn8+HESNG4PXXX7evlSQJX331FcaOHYusrCy0adMGY8aMwcyZM6NuD2PMYbGLSLEzgnaeANzX7eLpitV1h2InuN0r1jBCXLGMsZjjnfSgAsVm3S4X1smgGnsAn4KsCQkJZtu4uGJ1iPaWYgp0oypmWRqDw2KnuNwvVtUNM04PgOh2r1hrvjp2noj9hh5c1xFwb8UOKdjtpnaiUb0TCwBILrfZMxwFit1vKcZquGLdFuyOyRXr2FKMXLEEEQlxV+z8fj9uvvlm10odgIi27EpISMDcuXMxd+7cWq/p3r27q7IAFprBwBjglSXTFRuRxS7IFQs0qU3Pmeq02Lm1UNS02AFOd0/08oK2FJPdWcWYUcNiJ7pT7IItFLxdsW5j7DSD2YoY4D7GTtNrWOzcuGKtuS8GWexcrAfVUO31AHBYE46dJ9ztnRzWFevmYUJzxtiBMRiGbhfxjhbHmuCwHmJyxTJ/9ZZiVKCYICIi7skTY8aMwccffxzvt40LloVOkQR4ZSkyxS7Y7QS4DxbnuVdscDwR+MbYWZY7N9uKBcfYSbLizvUUZJ0AzKxYN64n/luKOV2xXGPsXLtiDShWjJ3bvWINs9i0nRUuebi5YoGAFdtteEJQ8oTr9SAGK3bu9k82t9irTiYC4C7OTnfG2MFljF3MrljBE7DYkWJHEJEQd4udrut4/vnn8d///hfnnXdeSPLESy+9FO8mcUPVDHhkc4NrjySiSo3gZq4HBYoDAVesi4xHQ4UscLLYaZoZVxfAzIp1Y6EI2j5JFCAIcOd60jT7RmbGFHGMsRMFMBdWtppZsTwsdtWuWJlvjB2HrFjZ6qtgKnoxE7zFHhBwxbp70FGC5LlfE9UPO26zxENj7NxvKWYpdKIoAYIAQ9OB6HZqtAneUsxtaEJNi12ka8Iw/FDkNHOvWD328AOCaE3EXbHbunWrvZvDtm3bHOdijbVqKvgNA97AF7VXEeGP5OnbUJ0WO7fJE4xjjF2Q2wmwYorc3MgYPErQl7tLC4VeI6bIVXkHg5lWiQBuyzvwtNgxxsCY7kyecPG5muVO+MXYaUZ1VqzpinVpsWug9QC4V+ygOmPswCk0AQAkDoqd4k0IkucygcIwqteEy2Si2C12foiih/aKJYgoiLtit3z58ni/ZdzwaQa8gQJhUdWxC7FQuAsWd5Q7cXFTDImx45gVC3De9FyWXLmdmG5Ub3gOs44drxg7URTBGAvJDIy4bQHrHM8YO5ljVqyqM9sVKwmA6spiF8aC7XORKGKEKnau1oSmAdbDjmsLds314C4rVtd0ez2Y8tzVdgy2YvNYDzUtdpFnxXohSpQ8QRCREvcYu5aMqhnwWBY7WYrQYlczxs7jyhWrGRqkQLA0F7dT0Jcxl7pdwTFFsuCqlp0RdCPjUaDYkcTBIcYuOHkCQMzuWEuJq65jp8Bw4YptiDp2UqCvZh07jhY7HlniQo0YO9dWbKtgt9K06tgFPegA5prQXWWKB8WdyqLrLPGaFrtIXbGi6IFEMXYEETGk2HHErzF45CgtdobmtFC4dD3phl4dYye4TZ6oGWPnLiuWBcXYAZYr1o0VoFqxM8s7uCxQXGPnCbcxdnbxZNFKFIlN8TQMDYIgVReKFmQwjskTbmPs9KAsW9FtVqyhh2aJc0omAjg87OjBrlgeMac1Y+zcJE8YdmgCECja7aa2oxEUYycKrpInwmXFRrIemOGHYLliDV9ElRAIorVDih1H/JoBb+Bp3quI8EXyparXtFC4DxZvsBg7Lq6n4Kd2l65YTbeDxSVJcnUTQ9BNzBTIzxUrCIKrBIrgjFgAEEQZhttyJzUtdi5dsdwKFOuquQYs3FrswsTYuXrYCY6xawBXrOvQBDnYFSu5ethB8MOOyzp24bYUi2bnCUEwM0AYxdkRRL2QYscR1TCCLHZShAWKtVALhZsYO+7JE/wKFOscY+yYYYAxw2Gxc1OgmNVwxfJMngDcJVCYNeyq54goeFzvFSsHKbEekWPyRKDcScyWFaNGzKnI70EH4Btj5zaZKESx41CgWAq22LmIsWMGAxiCyp00znqoTp6QIQgyuWMJIgJIseOIXzOcrthILXaOnSfc1e0KLsjKe0sx0/XEM6Yo9qxY66ZQvTemy0r7utNiJ0juYopi3UIpHMEZsYBpsXPjitUZgxIcTsihQLESFGMHmO7Z2BpXIzRB8nB1xXJ52AmqY+cqK9bgnBWrhcbYxZwpbrXDsjo30nowmB9iwFonil7olEBBEPUSN8Xu0ksvRXFxsf3/l19+icrKyni9fVzwO5InIo2xazhXLM/tkwAeBVkNxxZKbix2VhmH6qxY2VVpBxZc2gEwlTyX5R1iqdsVDsNQIQYpJ6Igc02ecJ0VG2Sxs3TjmBMoGjh5gs/OEwF5rpMn+O4VqwcVKDblxZ4pbseXWs1zGWMXbkuxaJInzNd4Yeik2BFEfcRNsVu1ahX8/moz+u9//3vk5eXF6+3jgj+43IkSoSs23JZiLi0UweVOXNXsqpE8AdlluRODcQsWtzJirYQCLgWKa+4V6zJYnJ/FTnNa7NyWO2GoEWMH9xa7IMVOdFPypGa5E1HhuvMET8WuqW0pVjMr1tXDTqDUiZ2wwyHGLjZXrBljB8DcVowsdgRRL43mim2J2U1+vYbFLhJXbLgtxVyWO3HE2Ll2xdYoUMyxIKtpoYjdYifWjCfitH0SgEBBVn4xRe6SJ5wxdoLocVeg2KgRYyeIrmLsgneeAABZEmMvUtyAFmwAUITYXbGMMUBVHQWKXSt2nLcUC46xk1w87LAaW+zxWA9cLHak2BFEvVCMHUf8egzJE2G3FIstQFg3dDAwhyvWYAZ0I8Yv95oFimW3NzJnuRPJRbC4HrZml7tyJ5CaZoydwfi6YmtuKcZjr1g5aOwUSYi95EnIlmIe1wW7HYqdpMSePGF9foFtEAVZBnQ95rI44cuduN1iL9hip8T8sNMQ68FN8gRAih1BREpcd57473//i9TUVADmQl+6dGnItmLXXHNNPJvEFUe5k1hj7Fy4Yi3rXPBesdZxCVKtr6uN4H0xAU6bnte8kcVYoNjQasQTye5csQhjoXDjeuKaFWuEc8XyrGPHwxVb/bkqYoTb6YXDqFHuxK0rtma5EyF2V6z1UBNc7sQ6Lnii35A1nCtWd1GgOHiLPcCac7G7YmtasHkXKI7eFUuKHUFEQlwVuzFjxjj+f+CBBxz/C4LgLrOxkfHrDJ6o69jVtFDEHiyuGRoECPbOE5Ig2ce9kjdqeeGzYptG3S5D12ooTi4LFOuGWasjAI+CrLG4nsK2LcQVq8BwpeyEqWPnyhVrOFy7siTE7ooNu8WeCyU2KEsccBdjxzQNEEUI1udqrQ1VBWJU7KSQrFg3rtgwMXYx1nY0t9iruR74xdiRK5YgGo64KXax3tSaE6pmwBu1K9YHyEE3BVGO2ULh1/3wSNWyBEFwdyPz+x2WCLMgq4syG5oBSebjetJVFZISVNtNclllX2cQZH4WCk3TIMs1rSex7jzhs29ugOmKdWOx8xkGPGKwxU6IuagwY8wRggCYrl0t5uQJPyAHPYS4TCZSdRWeoLFzUwIoZD0Igqv9YnXNgKg4s2INN5mnIWvCpcVODnbFNs56YKxasZNIsSOIiGhSMXbNvfxJaB27CG5umg8Itqa5iCny637HTQwwEyhijSliftXpYlIUV3W7dNWp2Elu6thpGqSgxA4pkAEYc1KO5ix3Ikju94rl5YoNtloAgCAorrJi/QaDVwx2ncZusdMMBsbgUOwUSYy93InmM9eAheRxZbHzG86HHUVUYi4BVFOxA9wlUIQ86LgsUKyrKuSQNRGjxU4zIAS1DYH1EOv60nU9asWOMQbD8Nu7TpDFjiAio0kodj6fD//3f/+HHj16NHZTXOHTgyx2Ebti/U6LnQtXrN/wQwmO14NL11M4i52LGDtdMyApNWKKYryRaTWtEwEXOK8bmdvyDjUtFK7q2AUVaTVlKTBcWLH8Bgux2MWq2PkDDy+e4Bg7SYAac/KEz2mxc+mKrfmww9NiB7hbEzUfdERJjDnmFAB0LdSKrcdoYWchDzqB+RJj8zRNi9oVa20fRjF2BBEdcVPsfD4fpkyZggsuuAAXX3wxFi5cCACYN28eevTogVdeeQUTJkyIV3MaBNVR7kSKLHmipsXOhStW1VWHdQJwa7Grqdi53FJMY3xdsbLzJgYg5rpdTGPV2yYAgQLFTdVi566Ona+GYudmr1irKLfgyLJ1Y7HzOy12Ll2xft35sONmSzFzPTgfnNzsF2uuB3517MK5YmOOsQu3HoCY4+xisdiZ24eJdkY47TxBEJERN8Vu2rRpeOONN3DaaafhwIEDuPHGG3H//ffj5ZdfxksvvYQDBw5g8uTJ8WpOgxC1K9ZXZip2DguFAmhVgO9kVO+tGzpK/aUhrlhZkFHqK4XBovtCNsrLwXxVjhuZlTyhl5VFJQsA/FVa2Bg71adD80d389E1Fb7KcsdNTBAECKKIyrLSqN1Fhk+rxWLHYFRFf9OuqqqCYRghFjufzwctSiVA133QtXIIIYqdCk2L/nM4qenwGQa8QqgrtixKJYAxhqIKv8MNC5jJE6VVavQlT/wVgFoeuh50DagqiU4WgHK1PCTuVBZl+HU/KtSKqGQxXYdeWgpRCbXY6cUlUZc88Vdp0FQ9ZD3oOoOvMvo556+sMK1iNVyxqq8Kqj86ZYhpBliV5lwPogAIgF4efbiDNe9rWux0XUdVVVWtr6v5QEMFigkiMuKm2C1YsAD//Oc/8emnn2LJkiXQdR2apmHz5s245ZZbHIu+uVKl6kj0BJU7qetGWfQzMLsLcGxnqIVi1cvA3EFRvfdrG1/DHd/cEWqxkxTc8vUt+GDHBxHLYoxh98ALUPTeP50WO0VB1dat+OnCi6CdOBGxvPz9JXjr0f+h6qQa4npa89lefPHKpohlAcDi11/Bly/+CbLizP0RBAFvjbsHe7/PiVgW0wwcmZ6Dys3HnFuKSQKqdhXhyIwcsCjcY7t378acOXNMETUsdgsXLsS///3viGUBwMZNd2LX7qdr3OAUGIYfK//XH8UlGyKWVaRq6PXdVqwuPhniip2fV4SzV22N6qb9z5yDGPp/K8MqdnfP+wF/WbwrYlkAgL9dCCx7roYFWwFKcoE53YDCfRGLyi3NxeD5g7GvZF+IK/b/bf1/uP6L66Nq2rGXX8bB224PG2N34He/w4kPoltfbz36P2xZdjgk5vTogVL8vwnmWomUIz/twmt33YSqstIQi93K99/Gp89NjVgWABQt+AmFH+x0xtgBgADkz/keVdsLI5alqipmz56Nbdu2hVjsfvrpJ8yZM6fWhx1dr4IkJQb1xxuw4hEEURdxU+wOHz6MgQMHAgD69OkDr9eLCRMmOFw4zZ0qzUCiYpU7MbNia71RHlhV/becUP23pZiVHo7Karfy8EoAsLcTq26T+UT8Q8EPEcvS8vPtv0Vv9U02uPRJ5Y8/Rizv8M5qJVBSgm9k5mef/3NJVArFrtUrA7KcN1krvu7gts0Ry1Lzyu2/BSU4C7C6nf4jkX8OBw4csP+uWbcLAHbs2BGxLMYYSkrWB2QFfQ5BpU9OFK2JWN76ErOvDIA3WLEL/K0x4FBV5DfOnH3mDd6nOh9grF0olu48GrEs+CvMOQ+EWuws9v8vYnE/5FfP9+BSP9b6OFJ+JCqrXdnyFQBMRS4YI2BxKv/++8hlFVVbqSTFabGzyNtXHLG83K2b7L/loDUhBqx3R3bviGp9VW4+BgChil3g+aYqirYVFBRUt62GYmeRH/R943g7oxKSGKTYUYwdQURE3BQ7XdfhCXralWUZbdu2jdfbx4VK1XBY7BirYzP04z9V/+1IngiyQhXujfi9i6qKAABlfqd7rrDKvPkeKj0UsSzfzz/bfzssFEFfzL59PyNSThRUK081LXYW5cWRKRTBu0sIYvjpW/RL5H1Vj1Xf3Gta7Cy0o5FnaxcW1m/NiNQd61erZdWMsbMor4jcirWnovqmGJwVG1ysOPia+jhQaH6u5TVc6cUV5md5oiIK60pRUD9qU+yC10w97C/Zb/9dM8bO4mDpwYjl6QELtV7uVPL1InPdqQcjl1WcXz3narpiLU7kR650Fh05XC1PCa88lZ8oikiWwzothn/o1o5G3rbjx4+HbU/wQ0/wNcHoegVEiRQ7goiWuNWxY4zhrrvugjdgAaqqqsKDDz6INm3aOK6L1lXVlKjy67bFThYFiALg0/QQVxUA4PgeIK0bUJwb6noCgHY9TMWuc/9637fEV4JSfykAoFILr4TkluVCN3S7eHFd+H/eD+XUU6H+8gsExZk8AQBKt27wB1mm6qM4vwJt0rwoL/Y5gsWtTLuUUxJRfLQCbdvVX0S5uCAPbdq1R/mJIui1ZCOeyPsl4rZpxyohtU+AXlQF1IwpAiB1SIB2PPIbWWFhIQRBCLGQqIG2Jicn48SJEzjllFPqlVVRvg8JCV1QVXW4hmJnfoaK0gEVFftre3kIeyuq0C3Bg9wqf4grFgBOS/Tg5wofhnaoX5ZuMPx8vDzsOUvRK/fpOFHuR7s2ERTvPf4TkNYdKD4YGpoAAO17RvWgs790P05teyp+OfmLwxVrWey6JnfFgdIDOLvD2fXK0ouL7bhSVhF+ffkP5oJFmBxzIr8CKR0TUHq8KuyDTsopiSguiE6xa9uuPU6eKHLGnQYUqbSMTjiR9wvatq//g9WKqiAme2CU+cOHIAiAdjzyB53jx48jLS0NxcXFYS127dq1q0Oxq4IkVXszRNELVY08BIQgWitxs9iNGTMG6enpSE1NRWpqKn7/+9+jc+fO9v/WT3NmQ26xbbGzXMy/fn45NuaG+TI6/hPQ5SLz73AWis4DIr6RHSg9gK7JXQEAVXpoMLIkSEhSkpBXnheRPP/+n5HYv7/ZD0eMnfnFnNjn3IgVO8YYTuRX4JSupnU22Epn1bBL75Yc8Y2s6MhhtO90KgBA9YU+vXfsdhrKT5yAWkdQdjDa0Qp4uiYDQEhBVgDwnNoW2rHIbmS6rqOsrAwZGRkh5yzFrkOHDhFZ9QDTGpeSch4Ac1sxu22BuZXc9mxUVByI2M22t9yHC1LNB6maWbEA0C85CfsqI7OI/HKiEkkeyS7vE0xVwDXbrUMS9heGV/5COL4H6HJhoEE1yp0AUa0HwLTYnXeKOXY1kycA4NwO5+JA6YGIZPn274enezcA1a5XB4oCITERal54l2JNThRUIKOH+V1Xs/wPAKR3T0ZxhFYxxhiKjvyC9B6nmzKCHtysfWLTe5yOE3lHIpKnHa2AcoppJWNhkpqUjDbQS/0wIkx4On78OLp06QIgvMWuc+fOYdfDkbxP8ePGWyGJSUGv8eLQoXnYsnVsRO9NEK2VuFns5s2bF6+3alQsix1g7khVXKHii01HMKBbO+eFFUVAh17m38EWCitbMbNvxDeyEl8J2ie0x/6S/XZMXTAJcgJObXsqjpw8gi7JXeqVpxcXw3O6eaOomTwBAN6zzkbFhshi7AyDQfXpSO6QGHJO85uKXUrHRJQVRqaIVZ0sQ2Jqmvn6MIqdN6kN2rRrh9LjR9GhS7d65ekVGhJOT0UlEFqQFYDSuS0qt4a3KITI0nV4vV4kJob21VLsLOtFJGhqMTwe07KnG6HKZWJSd5wo/h6aVgJFSatXXrGm4bJEU4kNzoq1lLw+bROxtjgyRay40o8ObTwohD8k+7syUOanS7tEHD5RifNrzv1wBK+HYKy1kdEH2PGlWW6jFhe8o32+YpyWchoAhCQUAcCZ7c+M2BWrFxdDbt8BfuwLq9iJCQnwBCzcnoz0euX5ylW072wq2I7kicCDRccubZG/L7IsYEPXoFZVIuWU0Pe1HnxSMzJRcqwg5HxYeRUaxLbmOmdhyjUJiTLEZA/0Yh/E9KSQ8zWprKy065OGs9hlZmaGjTvNO/Kp2Yagsj5WnOmxY0vg9xfB42kfUZ8IorXRJAoUtySSPKG68oaDYSx2hgYkBm54wRYKSzFL6gCokVmKgvfD1Fnok3SClIAkOSmsNS8cTNUgtze/NIWgmB0reULJSAeL0CJm1eXyJIS6gLWAZUfxSvbf9crTquvDhSvjoHi9UBISofkjjO8yGMQ25o0sXEFWKcUDFmHbGGMQRdFxA7Ow4uo8Ho+t5NXfNA1iIJ5O10PngiQlQZISoBuRfRYqY+gQmJ/hLHYZXgVVEZbtUHUGRRKRIId+rlbR4jYe2bbe1YuhAp6AohA87y1XbNt085oIy/ZohoYUTwoAOFyx/sCuLu287eDTIrNOOvZMDvPZiQkJEJOSwHyRr4nEgPIkSaGu2LZpXvuhp15Zgcx7T2KokqUF1ofHmxDxemBGdWHicPNe9IgQPVJYpS8cuq4jKclsW80scQBISUkJiTk1DBWlZdsAAH5/tTVPEk23rCgmoqR0Y0TvTxCtEVLsAsydOxennXYaEhISMGjQIHwfRZZbMMEWOwDo2j4Ru/JLQ2t66SqgBCw7wRYF66YWRbawZmiOoPCaJARn3UYA0zSIbU3LTnDckHVzE5OTI5Zl6AyCKDiy/ywivXk55Wl2MeJwMU2yp/44vWCYbkBMCoxdsMUuoPiICZEbtS3FLlzpnkiVOYc8Q4UQUGzCFSQOzhiMBNVgSAsoYsGKnRZw5SZLkX8daLoBWRKgyJHP0zrR1Wolzgj6XK3QBCW6vmqGZs/74LURzqJdvzANUGqfB0IYC21dGLoBT2DOBe8Na7liPYmRzzld1yBKEqRwDxNR1q8DzD2Tq4sRh54XwqzjujAMw7Zg16zrCMCOuQ7G58uzy5yoWql9XJJMBbFjx8tRVrY9qnYQRGuCFDsAH3/8MSZOnIjp06fjxx9/RL9+/TBixAgcPRpFuYYACR7nkGamJEDVWegm60aQYhesxEVZOBUwb2KKoNR6PkGKXrGzyzoEZ6EGjolRZDMbugFREuxkhGCiLUxsytPt7cPCbXAueyII1A9GZ7byJgRlJQq2Yhd5fUXGGCRJcmT8WcSk2DHNzoANp9iJUX6uGmNIDYxdcFZsZeChQ4rqYYJBFkW7tIlrDK1aiQveGcJqkxy9YmeVOQkuqVQZxvJZH6bFrvb1JYZRTurC0JltqQveacI6Fo1iZ+g6REl2xNZZhItBrRed2esg3JZ6ISVQ6hOn60hIMOdp8AOP9ZlY55yvqbKtc8FZsFbSUFLiadD16L8nCaK1ELcYu6bMSy+9hPvuuw933303AODvf/87vv76a7zzzjt48sknQ673+XzwBX1plpZWP1UqAnPcxK3gclVVIVmPwMyAwgxoggwZzpu+qPkhAdB0HSIzas38dLRH9UEMipmqqUSIggjGGHRNj0jBMPx+6IEvXk1V7dcYgS9mw+MBC3qfmr+D8VepECXBrswffI0ecNnphg7DMCJqm+r32zd7Fu41ggAwBk3TIuurbkAPrAJN1WxXm+o3f+uCucl9fbJUVQVjzKFEBL/G2hfTMAzoemSfg6b7IAvWDS60P5ZXUlM1qGIEY2cweAIvEnUNauBvq5C2pulgjEXUtiq/ClkErN6qQfPEIpq+SpoPBhMgwyxpYwS9RkFAkQSgaqoZvFoHuqGDgUEOfL0Fv78a2DtV13UYLLI5p1X5wMTa1xeTJBiBOSfWsRZseZoOI/BdEDxPmWB+DoLEwBDZ5+CrqjK3DgtYXZ3ry3wY0A0j4vWlqxoMwZTFjNA2GAIDC/RVqEVe8PdB8FZiwX0Nlltzzvn95RAC8XSG4bfP+f1mqRmDCRH3p7Go6zuxNdDa+w80bt9bvWLn9/uxYcMGTJkyxT4miiKGDRuGnJzwOxjMnj0bzz77bNhzK79dYhsZTkmQ0Ek/ClkQsXjxfxFImIVgaLhaULBix1EMA7Bo0SL79eklCThfTsb2rdtxStlR/Bh0rjY2+zejUC3EIM8g+OF3yOsh90DPqp7Ye3Iv1q9fj9LNpXVIMjm1qAh7Nm9CFwDr8vLgt+QxhjMAfLd+PboahuN9ACA7OztEllYpQGdJ2H90BwQx0fGaclmBkqLgp59+gqEKKF60u962ndi1E3pVFZJO7QalXUeHPLltMk4YIsorK7Fq9Wok7Kxf3tknU7B17Rqcg1QszVkBXTFvarIqoB/aYfWa1ehe3gbfR/A5AKbSX15eDq/X62hb27ZtIcsyDh48CEVRUFJSf3C8x3sAzEiGrHTGkSMZyD1YLa9NWwnbtlUiIZFh2bKlYCytXnla2y7YlrMaaHsqvl282FbKikQFaNsZP25Yj2JPMhYtqr+I8vYTAk4WCzgnlUFOFRx9vaCjgSQZOFqQh22+I0jKr79g9PlH8nGsbBf6SG2wvkDGsSB51wJYufUQLhMUfPPNN2BC3VZUjWmQIePIZjMTNLhtgiqgjdAG27ZuQ4FWEDKHw5GyZTMSCwvBBg+GoKmO13Tp2QPHevZE0k8/Ye/6DagIlEUJtxYsCgsT8eOPeQCSsG3PBuzON5U8UzdLxpp1q6BqSRG1TS0/CR1A7okSCJLseI2vTQq87Tvipz17YPh9OBmBvIxfEiCrAhLaSahoU4kfgl7Tx5uKn08eQKeKBGxdvQqVbeq2uGdnZ+PkyZNYu3YtAGD16tW2kmfd9NasWYPy8nJHu0XxALwJGgyjP8AS7HOiWICkNsCePT9DgB+7dka2JhuTuuZBa6A197+iovGsygKLduO/FsaRI0dw6qmnYs2aNcjKyrKPP/HEE1i5ciXWrVsX8ppwFruuXbsiLy8PHTpEUASshaGqKrKzs3HllVdCUWp3WbVkaAxoDAAaA4DGAKAxaO39B8yapp06dUJJSQlSUlLi+t6t3mIXC16vN2zQr6IorXYSA9R/gMYAoDEAaAwAGgOAxqA1978x+93qkyc6duwISZIcexoC5h6HmZmZjdQqgiAIgiCI6Gn1FjuPx4OBAwdi6dKluO666wCYQd9Lly7F+PHjI5JhebPLyspa5dOJqqqoqKhAaWlpq+w/QGMA0BgANAYAjQFAY9Da+w+Y+gCAiHcG4kmrV+wAYOLEiRgzZgwuuOACXHTRRXjllVdQXl5uZ8nWh7UljlVhnSAIgiAIorCwMO7bpZJiB+Dmm2/GsWPHMG3aNOTn56N///5YvHhx2D0/w9E+sEtDbm5us9/vNhas5JFDhw7FPUi0qUBjQGMA0BgANAYAjUFr7z8AlJSUoFu3brZ+EE9IsQswfvz4iF2vNbEK0qamprbaSQyY2wO15v4DNAYAjQFAYwDQGAA0Bq29/wDCFqxv8PeM+zsSBEEQBEEQDQIpdgRBEARBEC0EUuw44PV6MX369LC17VoDrb3/AI0BQGMA0BgANAYAjUFr7z/QuGPQ6neeIAiCIAiCaCmQxY4gCIIgCKKFQIodQRAEQRBEC4EUO4IgCIIgiBYCKXYEQRAEQRAtBFLsCIIgCIIgWgik2AGYO3cuTjvtNCQkJGDQoEH4/vvv67x+wYIFOOuss5CQkIC+ffti0aJFjvOMMUybNg2dOnVCYmIihg0bhj179jiuKSoqwu23346UlBSkpaXh3nvvxcmTJ7n3LVJ4joGqqpg8eTL69u2LNm3aoHPnzrjzzjtx5MgRh4zTTjsNgiA4fubMmdMg/asP3nPgrrvuCunbyJEjHde05DkAIKT/1s8LL7xgX9OU5gAQ3Rhs374do0ePtvvwyiuvxCSzqqoK48aNQ4cOHdC2bVuMHj0aBQUFPLsVFbzHYPbs2bjwwguRnJyM9PR0XHfdddi9e7fjmssuuyxkHjz44IO8uxYxvMdgxowZIf0766yzHNe09HkQbq0LgoBx48bZ1zTnefDWW2/h17/+Ndq1a4d27dph2LBhIdfHTTdgrZyPPvqIeTwe9s4777Dt27ez++67j6WlpbGCgoKw169evZpJksSef/55tmPHDvbMM88wRVHY1q1b7WvmzJnDUlNT2cKFC9nmzZvZNddcw3r06MEqKyvta0aOHMn69evH1q5dy7777jvWq1cvduuttzZ4f8PBewyKi4vZsGHD2Mcff8x27drFcnJy2EUXXcQGDhzokNO9e3c2c+ZMlpeXZ/+cPHmywftbk4aYA2PGjGEjR4509K2oqMghpyXPAcaYo+95eXnsnXfeYYIgsH379tnXNJU5wFj0Y/D999+zSZMmsQ8//JBlZmayl19+OSaZDz74IOvatStbunQpW79+PRs8eDC7+OKLG6qbddIQYzBixAg2b948tm3bNrZp0yY2atQo1q1bN8fnPGTIEHbfffc55kFJSUlDdbNOGmIMpk+fzs4991xH/44dO+a4pqXPg6NHjzr6n52dzQCw5cuX29c053lw2223sblz57KNGzeynTt3srvuuoulpqayw4cP29fESzdo9YrdRRddxMaNG2f/r+s669y5M5s9e3bY62+66SZ29dVXO44NGjSIPfDAA4wxxgzDYJmZmeyFF16wzxcXFzOv18s+/PBDxhhjO3bsYADYDz/8YF/zzTffMEEQ2C+//MKtb5HCewzC8f333zMA7ODBg/ax7t27h/0CiDcN0f8xY8awa6+9ttb3bI1z4Nprr2VXXHGF41hTmQOMRT8GwdTWj/pkFhcXM0VR2IIFC+xrdu7cyQCwnJwcF72JjYYYg5ocPXqUAWArV660jw0ZMoQ98sgjsTSZOw0xBtOnT2f9+vWr9XWtcR488sgj7PTTT2eGYdjHWso8YIwxTdNYcnIye++99xhj8dUNWrUr1u/3Y8OGDRg2bJh9TBRFDBs2DDk5OWFfk5OT47geAEaMGGFfv3//fuTn5zuuSU1NxaBBg+xrcnJykJaWhgsuuMC+ZtiwYRBFEevWrePWv0hoiDEIR0lJCQRBQFpamuP4nDlz0KFDBwwYMAAvvPACNE2LvTMx0JD9X7FiBdLT03HmmWdi7NixKCwsdMhoTXOgoKAAX3/9Ne69996Qc409B4DYxoCHzA0bNkBVVcc1Z511Frp16xbz+8ZKQ4xBOEpKSgAA7du3dxz/17/+hY4dO6JPnz6YMmUKKioquL1npDTkGOzZswedO3dGz549cfvttyM3N9c+19rmgd/vxwcffIB77rkHgiA4zrWUeVBRUQFVVe15Hk/dQI74yhbI8ePHoes6MjIyHMczMjKwa9eusK/Jz88Pe31+fr593jpW1zXp6emO87Iso3379vY18aIhxqAmVVVVmDx5Mm699VakpKTYxx9++GGcf/75aN++PdasWYMpU6YgLy8PL730ksteRU5D9X/kyJG44YYb0KNHD+zbtw9PPfUUrrrqKuTk5ECSpFY3B9577z0kJyfjhhtucBxvCnMAiG0MeMjMz8+Hx+MJeeCpaywbioYYg5oYhoFHH30Ul1xyCfr06WMfv+2229C9e3d07twZW7ZsweTJk7F79278+9//5vK+kdJQYzBo0CC8++67OPPMM5GXl4dnn30Wv/71r7Ft2zYkJye3unmwcOFCFBcX46677nIcb0nzYPLkyejcubOtyMVTN2jVih3R8KiqiptuugmMMbzxxhuOcxMnTrT/Pu+88+DxePDAAw9g9uzZzX6PwVtuucX+u2/fvjjvvPNw+umnY8WKFRg6dGgjtqxxeOedd3D77bcjISHBcbwlzwEilHHjxmHbtm1YtWqV4/j9999v/923b1906tQJQ4cOxb59+3D66afHu5ncueqqq+y/zzvvPAwaNAjdu3fHJ598EtaK3dJ5++23cdVVV6Fz586O4y1lHsyZMwcfffQRVqxYEfKdFw9atSu2Y8eOkCQpJPOooKAAmZmZYV+TmZlZ5/XW7/quOXr0qOO8pmkoKiqq9X0bioYYAwtLqTt48CCys7Md1rpwDBo0CJqm4cCBA9F3JEYasv/B9OzZEx07dsTevXttGa1hDgDAd999h927d+MPf/hDvW1pjDkAxDYGPGRmZmbC7/ejuLiY2/vGSkOMQTDjx4/HV199heXLl6NLly51Xjto0CAAsNdLvGjoMbBIS0vDGWec4fg+aC3z4ODBg/j2228j/j4Amtc8ePHFFzFnzhwsWbIE5513nn08nrpBq1bsPB4PBg4ciKVLl9rHDMPA0qVLkZWVFfY1WVlZjusBIDs7276+R48eyMzMdFxTWlqKdevW2ddkZWWhuLgYGzZssK9ZtmwZDMOwJ3K8aIgxAKqVuj179uDbb79Fhw4d6m3Lpk2bIIpiiCm6IWmo/tfk8OHDKCwsRKdOnWwZLX0OWLz99tsYOHAg+vXrV29bGmMOALGNAQ+ZAwcOhKIojmt2796N3NzcmN83VhpiDACzxMP48ePx+eefY9myZejRo0e9r9m0aRMA2OslXjTUGNTk5MmT2Ldvn92/1jAPLObNm4f09HRcffXV9V7b3ObB888/j1mzZmHx4sWOODkgzrpBxGkWLZSPPvqIeb1e9u6777IdO3aw+++/n6WlpbH8/HzGGGN33HEHe/LJJ+3rV69ezWRZZi+++CLbuXMnmz59ethyJ2lpaeyLL75gW7ZsYddee23YlOYBAwawdevWsVWrVrHevXs3aqkLnmPg9/vZNddcw7p06cI2bdrkSF33+XyMMcbWrFnDXn75ZbZp0ya2b98+9sEHH7BTTjmF3Xnnnc2+/2VlZWzSpEksJyeH7d+/n3377bfs/PPPZ71792ZVVVW2nJY8ByxKSkpYUlISe+ONN0LesynNAcaiHwOfz8c2btzINm7cyDp16sQmTZrENm7cyPbs2ROxTMbMMhfdunVjy5YtY+vXr2dZWVksKysrfh0PoiHGYOzYsSw1NZWtWLHC8V1QUVHBGGNs7969bObMmWz9+vVs//797IsvvmA9e/Zkl156aXw7H6AhxuCxxx5jK1asYPv372erV69mw4YNYx07dmRHjx61r2np84AxM7O0W7dubPLkySHv2dznwZw5c5jH42GffvqpY56XlZU5romHbtDqFTvGGHvttddYt27dmMfjYRdddBFbu3atfW7IkCFszJgxjus/+eQTdsYZZzCPx8POPfdc9vXXXzvOG4bBpk6dyjIyMpjX62VDhw5lu3fvdlxTWFjIbr31Vta2bVuWkpLC7r77bscEiDc8x2D//v0MQNgfq2bRhg0b2KBBg1hqaipLSEhgZ599Nvvzn//sUHziCc/+V1RUsOHDh7NTTjmFKYrCunfvzu677z7HzZyxlj0HLN58802WmJjIiouLQ841tTnAWHRjUNs8HzJkSMQyGWOssrKS/fGPf2Tt2rVjSUlJ7Prrr2d5eXkN2c064T0GtX0XzJs3jzHGWG5uLrv00ktZ+/btmdfrZb169WKPP/54o9UvY4z/GNx8882sU6dOzOPxsFNPPZXdfPPNbO/evY73bOnzgDHG/vvf/zIAIfdDxpr/POjevXvYMZg+fbp9Tbx0A4ExxiK37xEEQRAEQRBNlVYdY0cQBEEQBNGSIMWOIAiCIAiihUCKHUEQBEEQRAuBFDuCIAiCIIgWAil2BEEQBEEQLYRmuaVYcXExPv/8c3z33Xc4ePAgKioqcMopp2DAgAEYMWIELr744sZuIkEQBEEQRNxpVha7I0eO4A9/+AM6deqE5557DpWVlejfvz+GDh2KLl26YPny5bjyyitxzjnn4OOPP27s5hIEQRAEQcSVZmWxGzBgAMaMGYMNGzbgnHPOCXtNZWUlFi5ciFdeeQWHDh3CpEmT4txKgiAIgiCIxqFZFSguLCyMaM/RWK8nCIIgCIJozjQrxY4gCIIgCIKonWbliv3yyy8jvvaaa65pwJYQBEEQBEE0PZqVxU4UnbkegiAguPmCINh/67oet3YRBEEQBEE0BZpVVqxhGPbPkiVL0L9/f3zzzTcoLi5GcXExFi1ahPPPPx+LFy9u7KYSBEEQBEHEnWZlsQumT58++Pvf/45f/epXjuPfffcd7r//fuzcubORWkYQBEEQBNE4NCuLXTD79u1DWlpayPHU1FQcOHAg7u0hCIIgCIJobJqtxe7SSy9FQkIC3n//fWRkZAAACgoKcOedd6KqqgorV66MW1sMw8CRI0eQnJzsiPMjCIIgCKL1wRhDWVkZOnfuHJIf0NA0W8Vu7969uP766/HTTz+ha9euAIBDhw6hd+/eWLhwIXr16hW3thw+fNhuA0EQBEEQBGDqJV26dInrezZbxQ4wNeLs7Gzs2rULAHD22Wdj2LBhcbealZSUIC0tDfv370f79u3j+t5NAVVVsWTJEgwfPhyKojR2cxoFGgMaA4DGAOAzBrNnA6IITJ4ceu4vfwEMA5gyxWVDG5DWPg9ae/8BoKioCD169EBxcTFSU1Pj+t7Nqo5dTQRBwPDhwzF8+PBGbwcAJCcnIyUlpVHb0hioqoqkpCSkpKS02kVMY0BjANAYAHzGICkJmDYNSEgApk6tPj5rFvDnPwMzZwJN+au2tc+D1t5/wBwDAI0SntWsFbvy8nKsXLkSubm58Pv9jnMPP/xwI7WKIAiCcIOlzE2bVv3/rFnm/zNnOpU9giCcNFvFbuPGjRg1ahQqKipQXl6O9u3b4/jx40hKSkJ6enqjKHbLdh3FjZdU702779hJ/LC/CMkJCq4+r1Pc20MQBNFceeKJoygtLcC0aX3x3HM6/H4JU6bkYurUbo3dNIJo0jTbcicTJkzAb3/7W5w4cQKJiYlYu3YtDh48iIEDB+LFF19slDY99uk2x//vrj6A93IOYtz8H1Gl0k4YBEEQkXL06CJcd/1DUBQNfr8ERVHxm9/e3djNIogmT7NV7DZt2oTHHnsMoihCkiT4fD507doVzz//PJ566qnGbh4AgIHhuv6dG7sZBEEQzQ4Gho8/ehqqKsPjAVRVwbx5v2/sZhFEk6fZKnaKoti1YdLT05GbmwvALFB86NChxmyaTfPNNyYIgmhc/vrXfnjttSsxcybg8wFPP30U/++tuzFrVmO3jCCaNs02xm7AgAH44Ycf0Lt3bwwZMgTTpk3D8ePH8f7776NPnz6N3TyCIAgiRmbNAl76v/Px0EPZmDr1SgDA5MnHUXD0K0ybdg8ASqAgiNpotha7P//5z+jUyUxI+NOf/oR27dph7NixOHbsGP7xj380WruCywIyALQRBUEQRHToOjBx4gaM/ePyoKMC7r77fcycaZ4nCCI8zdJixxhDenq6bZlLT0/H4sWLG7lVBEEQBA9mzAByczejvCL0HFnqCKJumqXFjjGGXr16NZlYuroQQCY7giCI6GFA8PenIJiHCIKok2ap2ImiiN69e6OwsLCxmxJCcMIEJU8QBEEQBBFPmqViBwBz5szB448/jm3bttV/cSNCMXYEQRCxEezxIO8HQURGs4yxA4A777wTFRUV6NevHzweDxITEx3ni4qKGqVdrI7/CIIgiMhgYb4/wx0jCMJJs1XsXnnllcZuAkEQBEEQRJOi2Sp2Y8aMaewmhMUsdyIE/m7cthAEQTRfWJhYFvpSJYj6aFYxduXl5Q16PUEQBEEQRHOmWSl2vXr1wpw5c5CXl1frNYwxZGdn46qrrsKrr74ax9aFR6DsCYIgiOhhNcqdQABZ7AiifpqVK3bFihV46qmnMGPGDPTr1w8XXHABOnfujISEBJw4cQI7duxATk4OZFnGlClT8MADD8S9jcFfO+SKJQiCIAginjQrxe7MM8/EZ599htzcXCxYsADfffcd1qxZg8rKSnTs2BEDBgzAW2+9hauuugqSJDV2cwGAEvQJgiBipkaBYoIg6qVZKXYW3bp1w2OPPYbHHnussZsSgqNAMbkNCIIgYiTM9ye5QQiiXppVjB1BEARBEARRO6TYcSbYSsfCZesTBEEQ9WKmTjh3niAvCEHUDyl2BEEQBEEQLQRS7BoYMtgRBEHEAGM1vkCp3AlBREKrV+xmz56NCy+8EMnJyUhPT8d1112H3bt3xyzPmTxBEARBEAQRP5q1Yvfdd9/h97//PbKysvDLL78AAN5//32sWrUqYhkrV67EuHHjsHbtWmRnZ0NVVQwfPpzbrhVUoJggCCIWwhUoJgiiPppluRMA+Oyzz3DHHXfg9ttvx8aNG+Hz+QAAJSUl+POf/4xFixZFJGfx4sWO/999912kp6djw4YNuPTSS8O+xufz2e8HAKWlpfbfqqpCggEA0A0Duq6HHG9pqKrq+N0aoTGgMQBoDAB+Y6AbOgzDsOVomgrGWLMY29Y+D1p7/4HG7bvAWPMsDDRgwABMmDABd955J5KTk7F582b07NkTGzduxFVXXYX8/PyY5O7duxe9e/fG1q1b0adPn7DXzJgxA88++2zI8a6PfoL/+7UHnkBt5H/tFdG1DcNnByS8cJFmHycIgiDqRvF8C0Eohd93AwBAEI4iMekNVJRPb+SWEUT9VFRU4LbbbkNJSQlSUlLi+t7N1mK3e/fusBa11NRUFBcXxyTTMAw8+uijuOSSS2pV6gBgypQpmDhxov1/aWkpunbtCgAYOXIEEhRTg1vx723oc2oKPjuwy3G8paGqKrKzs3HllVdCUZTGbk6jQGNAYwDQGAD8xiA3Nxd+tRC9Th8FAKio2I8tW9/BZUNG8Wpqg9Ha50Fr7z8AFBYWNtp7N1vFLjMzE3v37sVpp53mOL5q1Sr07NkzJpnjxo3Dtm3b6o3R83q98Hq9Yc/JsgIloMAJgmBvbaYo1cdbKmYfW+citqAxoDEAaAwA92MgSRJEXbRlKIoCAUKzGtfWPg9ac/8bs9/NNnnivvvuwyOPPIJ169ZBEAQcOXIE//rXvzBp0iSMHTs2annjx4/HV199heXLl6NLly7c2knhvgRBENHDwBwFiq1jBEHUTbO12D355JMwDANDhw5FRUUFLr30Uni9XkyaNAkPPfRQxHIYY3jooYfw+eefY8WKFejRo4erdjm+eOg7iCAIgiCIONJsLXaCIODpp59GUVERtm3bhrVr1+LYsWOYNWtWVHLGjRuHDz74APPnz0dycjLy8/ORn5+PyspKXg2t9dSMGUBtzZ01yzwfKTxlNXV5TbltvOU15bbxlkdtaxrymkzbQvZkpALFBBEJzVaxs/B4PDjnnHNw1lln4dtvv8XOnTujev0bb7yBkpISXHbZZejUqZP98/HHH8fUnmgKFEsSMG1a6JferFnmcSmKkDyespq6vKbcNt7ymnLbeMujtjUNeU25bQRBRABrptx4443stddeY4wxVlFRwc444wymKAqTZZl9+umncW1LSUkJA8C6PvoJO1ml2scf/Wgj+2fOAdZ98les0q+Ffe3MmYwB5u9w/0cDT1nRyPP7/WzhwoXM7/fHrX2N1dfaqDkGLbmvtcmbPl1jCxcuZNOnay2yr5HIinQt8G4bb3luZIUbg1jk/fzzq2z3T7Ps/8vL97P/fXdR9J1pBKKZBy2R1t5/xhg7fvw4A8BKSkri/t7NVrHLyMhgmzZtYowx9q9//Yv16tWLlZeXs9dff531798/rm2pS7F7vx7FjhXuYzMfz2MAYx6Pbn7ZPVMWUzv8mp89NOUoAxhTArIemnKU+bXYFpd6/Dib9pApz6OY8qZPPBH6vhEu4qK8k2zyY1WBvhoMYGzaM7WMSz34fVVs8oRCh6zJE4uYrscmTyuuYtMnOds2Y0rk4xY8BoZhsPz8fPb446XOvk6L8XNQS9nTTxc45sgzzxxjhmHEJC+30sfGPe0LzBOzbY9PU+t/YRg03WA7jpSw8ZMqGcCYLJtK3dTpekzyWHlh6HqYfCw2WYyxgyUHQ9bEk1NPxiTL8PlC1sO0h44yw+ezr4nmhlZe4gtZD09N9tX7uto4fjg3ZE1MfaYqJlm6TwtZD9Mf9zFDr3/OhRuDkpKSkPXw1FMVdcoxFbvn7P/Lyw+QYtdMaO39Z6xxFbtm64otKSlB+/btAZi7R4wePRpJSUm4+uqrsWfPnkZpkyA43a+svtrPmh94bSCmnjoSHskPv1+ER/Jjas+bY3r/RfsXYd25v4Eoq1D9IkRZxbpzf4P//PyfmOT9MmkSfr9xNBTBD78qQhH8uPmbS2AE7boRKeXFPnz47Dr0SfwRsmTA7xcgSwYu7h6d69xi4zf/QZcTYyGLqilLVNHp6B9wYNOPMck79s42PNB+EzyBtnkkA3/wro9JVn5+Pt5880106TIPkqTD7xcgSRoGD/42Jnk/738VVw6/CopizhFF8ePyK36FsrJtMckbsX431l29F4JiQPULEBQDOaNiWzP/23MM181dja3pORAkA5omQZAMZAz5OSZ5WPQ4pp7yK+d6SOwNlPwStShVV/Hbhb/F3gvG2GtCkP0ouCTy5KpgSr76GretGulYD7etGomS/8S2vpa8vR1nSj841sOpJaugq9HvUFNWdBzvPTYOvfXJjjVxUce/xtS2k2uO4L42G5zrwfMDqn46EZO8999/H5mZbznWQ0rKqzHJIgiibpqtYte1a1fk5OSgvLwcixcvxvDhwwEAJ06cQEJCQiO3rpo6t4plBsAMzCr5EX7dA48H8OsezPrippjeSzVUeJbNgqEp8HgAQ1PgXf4cNEOLSR5TVfzzzH9CZWbbVObBG0cfAIzobzy6ZsDbRsF+TxY0XYTHA2i6iA++PCWmtumaih9LH4dmmH3VDAU5eX+ErsfWV+gMbxb1hz/QNr8u4pXlp8YmStfRsWNHlJQ8DF2X4PEAui7jX/+Krb4iM1R8+cXfoaqBz0H14OOPngZjsW1ZoxoMVyw+E0w1+8pUEQfe7hCbLM3ABae1w9Cqy8F0EbKsg+kivn6vXUzyoPsxa/+/nethzTTAiL6vOtNhMAODt31trwmmefDjB1fH1DSmqvh/SX92rIf/l/RnMDW2OWfoBrZVnO9YD4vWn1b/A2E4WZqGhORkHOn4lmNNfLh4UExtg2bg9b1nOdbD37b1AvTYkhd0XUd+/n2O9ZCdPbjO15g7xVZ/gQqCENPYEESrI+42Qk7MnTuXybLM0tLSWL9+/Zium66fV199lV122WVxbYvliu0+4RNWWllten74wx/ZB2vrcMX6K9jMy2Y5Y08e2RtzXMxND28NG8dy40NbYugVYxP6Lggr79mpTndRJGb3kmMV7NqL9zvkPXxfacx9ve/mzWHb9sj9B6MXxhh7fPghh7wZT6sxx9jl5uay3/xmreP1f/jDgZj7+tDDS8P29amnDkcvjDHW7p48h7zxz/hjbtvibXms77W5jhi7K27Ljz2268bwc27mlKKoZVWoFSz9+tecn8Ok2D+HKTduCdu2KTdWr69oXFC3DD/skPfsswGXZwxu7BP5eew3Az9xfq73xP5d8vSYE2H7OnV8/W7scGNw1VVrHPKefrqq3rbt+/lV9tNPf7L/r6g4yFb+78LoO9MItHZXZGvvP2MUYxcz69evZ//+979ZWVl1TNpXX33FVq1aFdd21KXY/WvtwVoVu5nTAzfUZ4O+yPd8y2ZeOy/qL2Tri/dX9/zXcfzX9y6J6cvdkvfMvfsdxx/q8NeYAsaffjJUediVc4T9/rfRKwFW2+6+4QfH8ZuHfuuqr9MnVccjaaU+NmlI5EpA8Bg89lhxyOtWrVrFbr99V8x9nTjxe8fx++//p6u+PjGtej5uK6tgXe4riEneHeOrlXNrDGZ+uZVdNeZYzH2dOXaz8/jwl2Jq29QZ5px79tnquLBVh1ex836/IOa2TbpkseP4pEsWO2RFm0g0cXy5fcwwDHb1Bfti6utTT4Q+JG1b8S27bcSKmPv61O2FjuOTr41srdaWSPT446X2NaWlpWzo0Lrbtu/nv9ZQ7HLZyv9dEHlHGpHWrti09v4z1riKXbMtUAwAAwcOxMCBAx3Hrr46NjcLL5wxdnVfq+vAzMuew9SpT1cfFARM/c2/gIF3Qdcjf19dB256eBt6/G4ZgOH28V+NWY7MpEzoet/IhQXkTei7AJPHdAJwmn18bMc30HHsg9B1T9TyrrvkAKZOrZYFQcCtVxXgjAszou7rfTdvwW2jNgG4wD7+u8tXIPP03tD1blG37fHhh/HUhDQA1VvFPXrpYaQM7R5V2yx5v/nNOkyd6nSD3XLLHpx55plR9/Whh5fi4Yf3AbjQPn7PvR+hY8croOvRuYt1HWh3Tz4ee6oDgMDWdwA6330c93dNj7qvhi7gvGsPYerUrlCDvKVX3l6ErNM7Rt3XmTd+iqn3qwDOs49PHfZ6YD1E597VdSD9+r9h2rTx9jEBAs679Qv87ozfRd22KTduxbjTlgIYYR9/9OKlUDp3jml93XzlL3hkbAKAJLNtgoCrBh7ABaNOg65HFyWj6wJ+M/BTTJ36O/uYIAi4adgqnHXJkKj7+vSYYky6sRhAe/v4Y789Ck/XttD1NlG2DbjqqhxMnNgDQLJ9/IorVmPIkOjaRhBE/TRrxe7w4cP48ssvzc2i/X7HuZdeeinu7RHqDKgLZcZUFfjzCwCernGGYerU6N57xgzgk9078OPR0HM3/HE7bjkruhvPjBnAgZ8WAgjdnu2ZJ1WIbaJT7J58XMNnzx9CsJJoEUtf1yzYBn+YGtLj7jmM3oOiU+xmzADyXsgDkOY8waJvGwBMnFiK//xnAwCnYsdYbJ/rrt0rAYRuc/f443lIS4tOsZsxA3j/f0cBhMbUxdLX3//xJD5YewRAV9fyZswA8NHnAH4TKmvSCaB9dIrd01NVfDn/TQDjHcdZjOvrxEfbUREmN+fx67eh3a3Rr6/Pns9HuPXw9FMMSvitqGvlyUll+LB0IYDfhZyLpa8l2SVg/tBzUx6oRGKf6BS7GTOAv/71ewDOXX3qXQ8UT0cQMdFsFbulS5fimmuuQc+ePbFr1y706dMHBw4cAGMM559/fmM3zyYiXS+kurqL96vx+miVzVCBQt3/NyYC5746hLl8Oe+2hbze5TwJernbUQudIk14zjWxz7XmeuWK68+BTzNscUHtiXjcOH43EkRrodlmxU6ZMgWTJk3C1q1bkZCQgM8++wyHDh3CkCFDcOONNzZKmwQ4HzLrf96s5QrOT6oxb5xdSztiax7vp+9a2hZzX100paYo7pYG3vOB5zvU9jlwhuOY8l8PsbaNn7za+9Q0rF781wRBELXRbBW7nTt34s477wQAyLKMyspKtG3bFjNnzsRf/vKXRm5dNVE/YzY1C0CIociF/BBrR+yizNdztuw0JWtkCHwtdg2J+5bx62uIBdu9fbKe/xtPXIg1MXZR4SXEfX2wGm2gvWIJIhKarWLXpk0bO66uU6dO2Ldvn33u+PHjjdImocb3Tr1PqbWej+3Lq7b3i/lpmWP7ahPFv2kcLTuc7yG8P4dYLU/hxMVsc+L9OcTDMhdz0/hOYq7zi6t1vQHkhZVFShpBNATNNsZu8ODBWLVqFc4++2yMGjUKjz32GLZu3Yp///vfGDy47sKXTRu+T8UNGsPTwnCG83D+HJq0NdAd3PvWgGPVnNra6DRo+F/9wsMp5qQMEkT9NFvF7qWXXsLJkycBAM8++yxOnjyJjz/+GL17926UjFiL4C8jhki+9/l9ezIwvjcuFkaeIMT82B7Ssgb2GjcmPD8HBsbZpeiUZ26Fx++GWXNrPS4CY34p3/XAXZGrubyA2AcvbGhC01GEYvksau48QRBE/TRbxa5nz+rtmdq0aYO///3vjdiaWGniyRN8GxEXgXxdT3xd4txpAtYL/i3gtyZqDU3g3erG/xjiOBXiuSb4pvkQRGuh2Sp2Fn6/H0ePHoVRY//Sbt2iq2XWUNRrWeGYABDuhuXmKZchjIXChcUu1DrhQhYaIHmiyVIziDz0XzfSBAiuFIPQ+H938pps8kQ4E7yb9cXCWbGF2A124WS5WV+h4hqBlrqmCaLhaLaK3U8//YR7770Xa9ascRxnAfeh3hjlzIUaN7T6vlM5J0+0KniPXRyMA029DEpMLeDeJY4JOxzLidT9Ro3/OfCfrA3/NrEllzWFsSaIpk2zVezuvvtuyLKMr776Cp06dWq68RdRx9hxLlDsviJr3f9HI6reA9EK5F0EuFbR0Ytq1QWKm47Aprwewr3elTTe5U6oQPH/b+/d46Kq9v//1549DKAIiCiICoKaWoF5SbyVleStc/SU59SxMvWczDqU9VHLzNLSSk/263LKrF+nrHO6WFZeTlKmeFcEb4gXJEABRe4wXOQ2l/X9Y2BkM3tgmFlz5f18PHjorL32e6/3uux5z9prvTZBuCVuG9ilpqbi5MmTGDJkiLOLYqT1UuX21/Lwlk/gLXdi9kIdN2V2vZN1mFeecP4vesfNCFnZT6wviYwt3uvYOK6x4y5i7SDNHo7jyzVmE11jXBJEZ8Ftdexuvvlmp+nV2RWS2bAYz/XMvXCnduAvd8LXnGvhbOfoUSxBWINbBXZVVVXGv3/+85944YUXsH//fpSVlUmOVVVVOaV8hn0FLeRO5BZHy53ECXvInbT2QDCmW4Fc2eg+bSX8Fu3zFsUQwHuiyJbXMfArhWUDumPILU+wuu7svZnIKT8SOa6PIIhOgls9ig0MDJQELowxTJo0SZLHqZsnOoqDNk+4hNwJd3g/FrP8EtbC+3GUK7SrS2+ecJTciQu0g8NccuDmCdkhSY90CaJd3Cqw27dvn7OL0CZyvyfbn0Fz4c0TcoKsNkgomJqyURbDngvZbX1nL8fNE7wFik3kTmwUFDaVnbHx+9+Omydsw4z8j7XWZFRsbJucNO1zNgVCLrB5orUsD0EQ7eNWgd3EiROdXYR2kWyeaPee6pgFz67wK9dR7121/jL8puxIoNgOFrm+A5jkTiyzJxdIOXJMmCsDQRBt4VaBXWsqKirw2WefIT09HYBhQ8X8+fMRFBTk5JLdoMO3JVpHYjF23RhCzWAx/KvKfpXPe9bHkzcnuQYkd0IQHcWtNk+05ODBg+jfvz/+9a9/oaKiAhUVFfjXv/6FyMhIHDx40Cllav1ShnbX8ph996T1v4rlvmhsknfgJT9vtgj8pCIEW96K4dJr7GRmLmx4D6jh0W4LU7BFsUOmHWx584Tsidb5ypjpI2ybMDe+bHp7SqvPVj7HZvKvseA7HjjvsiGBYoKwD247YxcfH4+HHnoIGzduhCiKAACdTod//OMfiI+Px9mzZ51cQmuhGQXLcR/pCk9uB+6u2bGu+LeD57YrjQeCcE/cdsYuKysLS5YsMQZ1ACCKIhYvXoysrCynlMnwg7aV3En7eifcri+3yN42gzIzFDzfFctbZ8OFvmS5y85wfPMEQ6uF7BC47hQ1bMbg2LC2bCjgKScku9uBsz0b6s50w45rzW9Z1Rb05gmC6DBuG9iNGDHCuLauJenp6Rg2bJgTSsQJzndjV9lJxltiwhCcyB3g9DYGmzYTu9LXqSPgvPNUzh6nN0/wDmJdJnriLqXDF+s3T1iSRhBES9z2UeyiRYvw7LPPIisrC2PGjAEAHDt2DBs2bMC6deuQlpZmzBsTE+OYQsl8H7WvdsJ7BoAfzJy8g7VyJ7KzE/zw3Kc7fHUxHCFQ7CozsXxnsGEH0V+Zj1bXHcfZdVnzzhhg/CSICKKz4LaB3ezZswEAL7zwguyxZg0nh4sVM9n/msnrIIFiV5hBcpCQrdWXcenNE2bsucDshUsLFJt7V6wHyp1wL4FLCBQzk7DcJe5lBOHiuG1gd/nyZWcXwQS52YGOzxjYJmRr+/UlBs2kc727W3+uXV+Z5DqbWOzxGNuSNEvh/qY4V908IddXbRUo7kC6dddwofElMW2pQHHLtaAEQViC2wZ2ERERXO1t2LAB69evR2FhIYYNG4YPPvgAo0eP7pCNkiORsgLF6iMD8fpqAa+vaX0Gv/VEzXCVOzEYbPtzh2y1/mjLl6IZPQabJEX4YE52xhZM3zwB2/pJy//bFPvLyc5Yb0+2Hax8pMhd/qe5LKYXst5cuwkWwpi8dIrV8J0Rt25M0Bo7grAGt908wZPvvvsOixcvxqpVq3Dq1CkMGzYMU6ZMQXFxcYfslB0egHfeEiVp33/aDZWHB0MUzZzUGt4BgUevS+EdPNnNtEfDv6rsOFPkRhI5BEEQ1kCBHYB33nkHCxYswPz583HzzTfj448/RpcuXfD55593yE7whGy89YYX1jTNzJ3e3hvfbvRHwIQMLF9h5pemnWd2bEJGZsOWmSI5xQ6+a7s99VvWnEAxH2sCOLcDbHxHqYxFl0BWBNgWe+A8Iy63E4MjTmkGkjshiI7ito9iedHY2IiTJ09i+fLlxjSFQoG4uDgkJSXJntPQ0ICGhgbj56qqKgBAxN150ApdsHLlYKx8TQfo+mBOfBUO+mVBo4mACL3hBF0jlP/sB+3TqVAC0Go0RluCTgeR6aE7/gUUOQeg+9P/31RO4L33gOZ9IHo9oFYDa9YAv+ZvQ0phCoYGDYVer4emhT29Xg+tTou//fo3PDb0MYwPGw+9Hjh9GkhMBDQaoKwM6NULiIoCHngAKHrycQQ+NheMMWi1Wok9BqDu6lUUzJyJyAMHAAB1dRocOhSKU6f0KC/XIDgY8PICJk0CBkY0YNvbp3Hf09FgDBJbOq0WjDGk/JyN+utajH0gCgBQXw+8/DIQFHTju0qlAp55Bjjz64+oq6qEQqEw9ZXpodVqsWnxU5j85LPoFTkAWi3www9ATs6N4EWhACIjDb6qPzqDgFkDAAZodFqwJntMY6jo2ssVqNqajR7PDJNtBwBQKoGJE7WoqbmOTz75BPfeey8YYybtoNfrsXPnTvj5+WHcuHGSdmhpr9nXK1fehJcqGHo9g06nk7YDY9DqNDhwcCRGjtgOb++Qdn0dceIidg0fAADQaDXQMH3T/7UAGH4pKsdn+WX4Nrp/m75OmgSou5Tgy6Rc3D88zOhrc/l0eh30eob4r07ijkE9MGtEn3Z99d35OPRRk6DQ66HX6Y3tABhuUrr66xBfC4L2xXxAoWzT1z/MbMTEn8Zj58ydBv9a2NJqtdAzPbZc3ILjhcfxxvg3ZH1tOb4aE35CbXIKvIcOkelzDDqdFjmPPYbA+fOhio2FXg8kJ2tx4ID8+Pr1ozTETOorO77AGCqKa7B5zXnMeXNMU5kNvl66BJSWQjK+BvQtwfevPo8/LVtl0ud0Wh30ej2O/vAN6mtqcMcj8wG0Pb40SfnQ12oBARBEQdrn9HrotFoU/H8nEPDngfAK6yrbDozpUV0dirvv1uCTTz7BjBkzjHXfbE+r1QIAcnJykJCQgAULFhivU1l1CmfOzAGgQ1TkCzf6lU4BxnRI3HsT+vX9GyIjl8BVaS6zpG07EZ3df8C5vnf6wK60tBQ6nQ4hISGS9JCQEFy8eFH2nLVr1+K1114zSV80uBaqYRcxJ2kgtFoRSqUOD8Ttw3QdkPjbLuNNVNBrMYPpsHdvIibpdEhISDDa6H49C7dVVyP7bBp6VuXjZNOx7dsjUVLijezsAABAfb0SAweWYc4cAdEPpyFfmw8UAeX6ciSU3rCXV5uHKkUVSjQlSDmegkqvSuTkdENycgjy87vgypVuUCq1UCqBIUMqkJZWhQdLSpB1/DiCqyqRlXQM9QUFRnsDdDocPXIEfeobjOU+ejQUOTn+SE9XQ6Nh0GqV6Nu3GufO1SJ2RBFUDQyHDh1Cba2vxNe6IiVqSr1QrS+CvlFARYKhvjdtGoq6OgUyMwPh42P4AoiKUuP33xtxx8CL0NXXQ1AoIIhKlLewV1hYhOozZ1BdXYXDRw7DJz0DR4+GIjvbHzk5/qitNTwP9/XVIiKiGmlpVVjgW4dzR45gYEM37N+/H40+hmBH0AEjEIQjR46gf7Ufks20AwAEB9fh3LlajBzZFRpNHlJSUqBWqyW+lpaWoqamBkqlEkqlEmq1WtIOJSW+xrzNvv7lwUtgrBQKRRHydF5ITb1hz9dXjaLC4/DxbcDevYlgLLBdXxumKLF3716gW1/8tus3eDetVyoVlGjoGorjJ06gROWPhIQL7frac9g1lOjqceZMCYrKBYmvl7KzUacToG4EztTlw7fwTLu+rom5huKaM+hTUYqcUydRcOnG7Myk2lqcPHoEE5kOv/zyC5ggtunr6bNl0A3VYe/evdBppeMrT5uH6tpqpKWl4ar2qvFYW+Pr2VvS0CU/Hw1g8CqvwIkW9nrl5kFTXY2uJaXITDmO2qoq5OV1w5Ytl8yOr4GKShw/XoDqam8kJR2F90W90Z5O54ejR46god5XMr6ys/2Rnh5kMr5G35YJ1lCPw4cPo662TuJrzZUcVJaW4npGBnQNDahuOtbW+Fo4sgBKrQIMDHqRoaD+hmxUVJEf1Jor6F3ti7OHD6POT9dGO/jjjTfOIjCwGkeOHEFDQwP2798Pb2/vJj91Tb4dRVVVlaTcgA7AagBAWpoP0tJaHlsDQIf0dBHp6S3TXZPdu3c7uwhOpTP7X1tb67Rru11gV1FRga+++gpz586Fv7+/5FhlZSX+85//yB7jyfLly7F48WLj56qqKvTr1w+TJ92Njz/uCa1WhErF0NgoIjX1D1ixQi81oGsEzgD33HMPxN+VmD59uvGQkH8SYsX3iI6OhuJyGUKajsXFGWYUbr/dkM8woxDQNGMXg9qCWgzpMQRXq69i+ugb9tKOpyG0ayhKr5Xi9qG3Y0KfCdDrgdhYuRm7HnjgAaBwQQ8MuH0Uyo4eRdS4sfC97TajvezVazBu3Dhc++9XxnLffbcGq1efxS23RKG8XNE0oxDQNGMXga1vncIdEybgt4x0TJ8+0WgrJ60M52uuofdNAaiv0WDcdMNs0j33GGYUxo1rOaPQwzBj98tg1FVVQhBFqHx8Edui7nZmnkNUTAxO5GZhwvgJ6BU5AJMnm5vZCTHM2G1Ixfjxw6C+lIG77roLyiAfAADT6FGckoLx48ahsugSpk8fL9sOwI0Zu5ycMygv74rRo0fj0KFDknY9deoU8vLy4OvrCz8/P4wfP17SDtJZLIOveVf6Q6XqidpaJfz9b0VY7xv2Us98hfB+t+Nixmbcc88keHuHtOvrtuPpuOeee4Djv2PKlCnoIhpWYuTVN+KdM5cw6pZRSL1Whul3jWzT10mTgArf7ihKykFMTB8UXyzG9Om3QaPRYPfu3RgwYABqNQwFlfWIuSkY05tm7Nry1ffn3ggZEAPF+UwEjRwFNviGr8qcVRg/bhzwOzBt2jRAoWzT1z/MDMeuH4G777kbH/78oaQd0krTsDd5L6IHR6OuqA7Tx7c/vhp2RqOuthbeQ4ZAk5+PUS3slZw6DWVYb1wvKsaA20dBNWYMdu3ajZEjx+LAAaXs+PplwxkMu70fUgouY9y4EQiJvHGv2rT3KMaNG49f0s4Zx0qzr9HRLWfsAppm7Lrju5XfYcKECUg4eVTia/aJZKRVFKPPTYNRX1ONO5uOtTW+Go/6g9VqAEGA4CNi+N19jfbUlb8jYkh3XK/Ix4QJt8ErrKtsOxhm7PKxYkU0vvgiGePHj8eVK1dw9913IzAwEIBhNiMtLQ3jxo1DeXm5pNyeQPNYuPfee+Hl5eXs4jiczu4/AJSVlTnt2m4X2H344YdIS0vDM888Y3IsICAAhw4dQlVVFVasWGGRveDgYIiiiKKiIkl6UVERQkNDZc/x9vY2/vJsyfvve2PdOhGrVwOvvCJgzRpg5UoRoijilVdaZBQMd0AvpaH6JR1fqQQgQCmKgKCAoumYlxdgziVRFKFQKIx/Le01pwmCAFEpGo+NGWP4k0MhCBBFEQIApaiU2DOkGY61TL/jjkJMn64wGcTV5TpAAJReSpNzRFEEBAGiQoRCoTMe8/IC3n+/bV8FWV8FiEolIAhQKg3l9vIC5syRtwUAlU15IRjaQ9lkj8EQfYhKJQQBkrLJtYNGA+TmGtb5iaIIQRBMfG1uC1G0sB0UCkPdNNmUtIMgQKk0zJAovSzzFUJT/TSf07SjR6nVgwFQKqXlbqvPJaaLEASDLwqhVTuIIgSdvkO+QhCgaOoPClE0XLzFMWXzWFF6AaKyTV8bdYbxpZQZX81t3brcbfmqbcorKhTQte5zYnMd3OhzCgUQG6vEhAnyX2jN9QbcOKclolKEAGk7mPO1qvRGfzfpc0rDOBVbjZW2xpdOVECvUBjaobWvLfp2W+NLo9EgIaEQvr4jjHkBSHxtXoMpV25PwlBHnumbJXRm/53pt9ttnvjxxx/x5JNPmj2+cOFC/PDDDxbbU6lUGDlyJBITE41per0eiYmJGDt2bIfKdiOoM3x+5RVg9Wpg5UoYN1RIkXsHaFO6lfCXdzC5gFVmmMxCcZv2Osgszrdp0b4DVBR4byiwpV156YOZEZ2xwSBfGRvusjNy44vvzhOrYDIbO9xhBzAJDhMEf9xuxi47OxuDBg0ye3zQoEHIzs7ukM3Fixdj7ty5GDVqFEaPHo333nsP169fx/z58ztk58UXddKZOdwI8ix/+QVngWLegqxtpVt3EavP5L4LthMIFNvja5SztJt9hXHtoZ3IG66N5N4CxQRBdBy3C+xEUcS1a9cQHh4ue/zatWtQKDo2EfnQQw+hpKQEK1euRGFhIW677Tb8+uuvJhsq2mPpUr1seutgT4pr3+BMbsA23JBNxVjtGZg5F/sLFNtmXypQ7DpBrBmD1p/q6pofHBVKeI5VMxew8XTXGZ8E4cm43aPY4cOHY9u2bWaPb926FcOHD++w3aeffhq5ubloaGhAcnIyYmNjbSilhci+oshMupXw/2KzEnu8zFL2KTanN08I8skWWXLU4yUXeIzFZN54YKNFmGnYjlvi/bheDkFwjZchOOr9t9audHCBvkoQnQW3m7F7+umn8de//hV9+/bFU0891bQI2bB9/qOPPsK7776Lb775xsml7AAcvxUZY5wDOZk1gIINX4xysxNcl525SBDLHX4Cxc3VbV+BYt7vt3WRGTs5QWFbzDGZ8tlk33QNK8VTBNH5cLvAbtasWXjhhRewaNEirFixAlFRBlHbS5cuoaamBs8//zz+/Oc/O7mUlmJuzQ7HGTtbAjEXRvZLETYEFOYmijjhse0A3sGTmQ1F1rwr1syaU65BpydHT7LNysfX5seynjgmCMLZuF1gBwBvvPEGZs6cia+//hpZWVlgjGHixIl4+OGHMXr0aGcXz2nwnSVp46bL8TJ0X7cAjpVkrk15N4NHtquDHnfy3ZvkiQ1BEERbuGVgBwCjR4/2kCDOzRau27KQ3c7vsnSlB7H230Bg60J2Xpbatu10g65UFll7HM1z7iOm9m083WOXShCEa+G2gV1mZia2b9+OnJwcCIKAqKgozJw50/ho1i2Q3TzB99GOYIvemdnT+Cxktwmzj+xssCmndmLNI0DOvppvP2seT/Ky1OJE7t/XnDZPyD2KtWk82H+8mr1Ou6eYm4nlvDSBNk8QhMvjloHd2rVrsXLlSuj1evTq1QuMMZSUlGDZsmV48803sXTpUmcX0XK4/6i270yRS//m9uAZAd7taj/FPnv0ERfZPAFw72M8zZlqiXvueCAIwjxuJ3eyb98+vPzyy1ixYgVKS0tRUFCAwsJClJSU4MUXX8SLL76IgwcPOruYFmL/zROAZ/5aZmBc3wJgOM2+AsWOm8lzHAyMb03x3DxhRk6I/5sinN8O9llLZ3+BYk+8NxGEs3G7GbuPP/4Yjz/+OF599VVJelBQEFavXo3CwkJs3LgRd955p3MK2GE4y53w/JXOzMhsWP16p9af+QY7rjRDwbcspu1gu0DxjfMNUmwuvBOb57pOmzCjnWitNXNvT7PWoNwaVheSE3Kl8UkQnozbzdilpKRgThtvOp8zZw6OHTvmwBLZgCPW2PGWd7AS7j/MOa7/M54mu8bOClOdSqDY/kHsjfSOWpJfY8cTwUXkTuyyI57W2BGEW+J2gV1RURH69+9v9nhkZCQKCwsdVyAXgnsA55B3xRKOxOzmCd5dh68518BhATtHUzRWCaLT4XaBXX19PVQqldnjXl5eaGxsdGCJbIS3jAXnR3Y85U5Mbdt6vv02FPDG9lktvu0gnZzkZ4sLHMcE93fscped4Vc+nrbsDT2WJQj74XZr7ADg3//+N/z8/GSPVVdXO7g0tsBXfIK/5AHHGTvOOhv8xZMdIcbMuR2skp3hZant86x/Za/9+5y148Hs+LJ6ww7HQcF7aYJZa7SxiyBcHbcL7MLDw/Hpp5+2m8d9cPFfrqYaCjbYsq90iivNAvAXKG43oWPmOolAMf9ZKzv3MZ7m7d4HO3i6C41PgvBk3C6wy8nJcXYR+MF584TZxeKcZ0+s+ZVt7pe+9T/Y+cqdmN084QJizK4sUGxeJ9qWOUA7bp6wZccu781OPCcneb+ezEy70uYJgnB93G6NXXuo1Wp8+OGHzi6G5XAXPLWzPZukJ1onWG3Kwgt4DtzXipn5Pw/4N4OryJ3A7rNgtk2I23lGnLM9giDsg8cEdomJiXj44YfRu3dvrFq1ytnFsQG+4lOuInfiqA27tl2opbZbs4CqDeZaWiaBYgsNmpPZ4Cd3wrXeBFuE53hCAsUEQRhw68DuypUrWL16NSIjIzF58mQIgoCtW7eS3Im97XG9DN3Y24dfHZl9JM7tCk32PLFZHSUJw/M6HtkQBEG0hdsFdhqNBlu2bMGUKVMwePBgpKamYv369VAoFFixYgWmTp0KLy8vZxezA/CWsXAfuRPe0hM2l4ynkgv/HQTtfLbemq1F5S+zYUeJHVvhPB64usZ7rPLcOAVpP6GNFARhP9xu80SfPn0wZMgQPProo9i8eTO6d+8OAJg9e7aTS2YFvAWAOcs7OELNlrcshi2LxXnB//ESv5lT3k3KXXWG50YRzvIk/Mcrv9lT8+3gGg1Lj1wJwnG43YydVquFIAgQBAGiKDq7OLZjZ4Fi7iLA/NRO7FA215J3kJhyNYFirjOvrW3batCOAsW2T0+2voCNcNycZJJAs2IE0Rlxu8Du2rVreOKJJ/Dtt98iNDQUs2bNwtatW910ap+zQLFZSRHXFca1Hs6zJ51coNj6PtfR67RnkF+7ml9P6CIzdh29jjXnOO4lzdZZo5k8guCO2wV2Pj4+eOSRR7B3716cPXsWQ4cOxaJFi6DVavHGG29g9+7d0Ol0zi4mQRAEQRCEw3G7wK4lAwYMwOuvv47c3Fzs3LkTDQ0N+MMf/oCQkBBnF80ymIwYqw3yCUxGtNcmeQcZ9VmD4LG1Mwqmj7Gsn8QyldmwSdrFnC6ulWu7eM4gMzNqsdb4KneGoY9YiYw8iWD2ShYZhLxB62bs+G7skPFVsF6eSE7c2Vprcn3ENnFyyO/XsWW8uuVTFYJwP9xu88SlS5cQFRUlSVMoFJg2bRqmTZuGkpIS/Pe//3VS6QiCIAiCIJyH283YxcTE4NZbb8VLL72E5ORkk+M9e/bE4sWLnVAyK7Hz5gmXkp7gvu7czq+ycKHNEzzblfseFntvUOC5eYKzxI5Lbdix98YOztAMHkHYB7cL7EpLS7F27VoUFxdj5syZ6N27NxYsWID//e9/qK+vd3bxLKP5hrZlLiC02tmrUAI1hcDBtwGFZbt+FYICv+b8ip8yf4JCkDapqBCxLXMb0svTIba+lhmYTof8xUugLSqCILbqIkoRhWteByzckaxQCGi4rsW+rzOgUEhv5ApRQHnBdZw/lA9BYdlNXlAocOqXHcg6fgwKhbRsClGBE//biqqSIggKy7o2a9Sj9IvzYFq9aRkUAtTbsy3+8hYEAaWlpdizZ49p2RQK5Obm4vz58xZ/oQmCiOxLb0OtTgFatasgKJGd/Ta02hoIsKwtKrU6PJp2CWKry4sC0KBneC3rmskxcygUApIuleGTg5fQuouICgG/nS/CkexSiJZ+eQsCsOMZoOiC/JhIeB6WBhrNwdvSA0tlx0NxbTE+PfupSRuZtacQUZWQAPWPP5mOSVGE+ocfUZ+ebvF41esYdv37PK5XNpj0OYVCwKHNv7du7jbKpkB9dRX2fLpBZjyIKL2SizOJv1o8HqAQUHPkGurOl5l+OygEVB+8Cq263uKYT6PR4Ouvv4ZWq5UdEwkJCRTgEQRnBObG25IYY0hKSsKOHTuwY8cO5OXlIS4uDjNmzMAf//hH9OzZ0yHlqKqqQkBAAEpLS9GjRw/LTso/BTRUAV17ASE330hnDMg7BugagB6DgIA+7Zqq1dQirTQNADC4+2B09+luPKauV+NixUUooMDwXsPhJbYv3tx45Qo0V69C8PKC74gRki+FhsxMaEtLIQYFwWfwYACGm3dCQgKmT59uIg7NGEPhpSpoNTp06+6DwJAuxmM6nR6FWZXQM4bgPn7w7aZqt2z112tQdCkLABA64CZ4d7lhr6aiHGVX8yCKSoQNGQqFBV+0muJa6KoaIKhEeIf7S+shvwb6Og1Ef2949epixgKMdbBz505ER0dDEAR0797dqLHYfPzKlSsAgLCwMPj4+LRbtsbGUtTUZAAQEBAwAqJ445y6unzU1eVAIfogMGBku7YA4EJNHcoatQjwEhHTTerPycrrqNXpEe6rQoSvd/tl0+pxIrccjAEDe/khxN/H2A/unDQZFwqvQwAwPLw7fFUWBDyV+UBZpiGoCx8DtOynZdlA5RXA2x/oM8IiX8+VnkONpgY9fHpgUPdBxnTGGE4Vn4JGr0GkfyRCura/HldfW4u6M2cAAN5DhkDZol21FRVouHgREBToMmI4tIJgdiwYXS2pQ1VZHURRgd4DAiTBXVl+DWqrG9Glmwo9+vi1WzbGGK5lpEOraUS3Hj0RFHbjfqHTanEt4wL0ej16RkSii39A+77WadGYXw0AUPXtBoXPjdU6uqpGaIqvQ1AooOrvb/bHWMv7gVqtRnV1Nby8vNCvXz9JvmvXrqG+vh7+/v4IDg5ut2zuRFv3xM5AZ/cfAMrKyhAcHIzKykr4+/u3fwJH3Dqwa01mZiZ27NiB7du3Izk5Ge+88w7i4+Ptfl2rAjsPggYx1QFAdQBQHQBUBwDVQWf3H3BuYOd2myfaYtCgQViyZAmWLFmCsrIylJeXO7tIBEEQBEEQDsPt1tjdeeedUKvVxs87duxAXV2dSb4ePXpg0KBBJukEQRAEQRCeitvN2B0+fBiNjY3Gz48++ihSU1NNJFAcSfPT7Oa1JJ0NjUaD2tpaVFVVdUr/AaoDgOoAoDoAqA4AqoPO7j9giAcA57xdxe0Cu9a4whLBsrIyAEBkZKSTS0IQBEEQhKtQVlaGgID2Ny7xxO0DO1cgKCgIAJCXl+fwBnQFqqqq0K9fP1y5csXhi0RdBaoDqgOA6gCgOgCoDjq7/wBQWVmJ8PBwY3zgSNwysNu1a5cxgNLr9UhMTMS5c+ckeWbMmOGw8jTrMwUEBHTaTgwA/v7+ndp/gOoAoDoAqA4AqgOA6qCz+w/AYr1MnrhlYDd37lzJ54ULF0o+C4IAnU7nyCIRBEEQBEE4HbcL7PR6vbOLQBAEQRAE4ZK4ndyJJcjJn9gTb29vrFq1Ct7e7Sv2eyKd3X+A6gCgOgCoDgCqA4DqoLP7Dzi3DjzqzRMNDQ348MMPsX79ehQWFjq7OARBEARBEA7F7WbsGhoasHz5cowaNQrjxo3Dtm3bAACbNm1CZGQk3nvvPfzf//2fcwtJEARBEAThBNxuxm7ZsmX45JNPEBcXh6NHj6KkpATz58/HsWPH8NJLL+Evf/kLRNGCl44TBEEQBEF4GG63eWLLli34z3/+gxkzZuDcuXOIiYmBVqvFmTNnIAiCs4tHEARBEAThNNxuxk6lUuHy5cvo06cPAMDX1xcpKSmIjo52cskIgiAIgiCci9utsdPpdFCpVMbPSqUSfn5+NtncsGED+vfvDx8fH8TGxiIlJaXN/Fu2bMGQIUPg4+OD6OhoJCQkSI4zxrBy5Ur07t0bvr6+iIuLQ2ZmpiRPeXk5HnnkEfj7+yMwMBB///vfUVNTY5MftsCzDjQaDZYtW4bo6Gh07doVYWFheOyxx3Dt2jWJjf79+0MQBMnfunXr7OJfe/DuA/PmzTPxberUqZI8ntwHAJj43/y3fv16Yx5X6gNAx+rg/PnzmDVrltGH9957zyqb9fX1iI+PR48ePeDn54dZs2ahqKiIp1sdgncdrF27Frfffju6deuGXr164U9/+hMyMjIkee666y6TfvDkk0/yds1ieNfBq6++auLfkCFDJHk8vR/IjXVBEBAfH2/M48794NNPP8Udd9yB7t27o3v37oiLizPJ77DYgLkZgiCw6dOns/vvv5/df//9TKlUssmTJxs/N/9ZyubNm5lKpWKff/45O3/+PFuwYAELDAxkRUVFsvmPHDnCRFFkb731Frtw4QJ7+eWXmZeXFzt79qwxz7p161hAQADbtm0bO3PmDJsxYwaLjIxkdXV1xjxTp05lw4YNY8eOHWOHDh1iAwcOZLNnz7a+YmyAdx2o1WoWFxfHvvvuO3bx4kWWlJTERo8ezUaOHCmxExERwVavXs0KCgqMfzU1NXb3tzX26ANz585lU6dOlfhWXl4usePJfYAxJvG9oKCAff7550wQBJadnW3M4yp9gLGO10FKSgpbunQp+/bbb1loaCh79913rbL55JNPsn79+rHExER24sQJNmbMGDZu3Dh7udkm9qiDKVOmsE2bNrFz586x1NRUNn36dBYeHi5p54kTJ7IFCxZI+kFlZaW93GwTe9TBqlWr2C233CLxr6SkRJLH0/tBcXGxxP/du3czAGzfvn3GPO7cDx5++GG2YcMGdvr0aZaens7mzZvHAgIC2NWrV415HBUbuF1gN2/ePIv+LGX06NEsPj7e+Fmn07GwsDC2du1a2fwPPvggu++++yRpsbGxbOHChYwxxvR6PQsNDWXr1683Hler1czb25t9++23jDHGLly4wACw48ePG/P88ssvTBAElp+fb3HZecG7DuRISUlhAFhubq4xLSIiQvYG4Gjs4f/cuXPZzJkzzV6zM/aBmTNnsnvuuUeS5ip9gLGO10FLzPnRnk21Ws28vLzYli1bjHnS09MZAJaUlGSDN9ZhjzpoTXFxMQPADhw4YEybOHEie/bZZ60pMnfsUQerVq1iw4YNM3teZ+wHzz77LBswYADT6/XGNE/pB4wxptVqWbdu3diXX37JGHNsbOB2j2I3bdpk0Z8lNDY24uTJk4iLizOmKRQKxMXFISkpSfacpKQkSX4AmDJlijH/5cuXUVhYKMkTEBCA2NhYY56kpCQEBgZi1KhRxjxxcXFQKBRITk62rCI4YY86kKOyshKCICAwMFCSvm7dOvTo0QPDhw/H+vXrodVqrXfGCuzp//79+9GrVy8MHjwYTz31FMrKyiQ2OlMfKCoqws6dO/H3v//d5Jiz+wBgXR3wsHny5EloNBpJniFDhiA8PNzq61qLPepAjsrKSgAweTn6119/jeDgYNx6661Yvnw5amtruV3TUuxZB5mZmQgLC0NUVBQeeeQR5OXlGY91tn7Q2NiIr776Cn/7299MNj16Sj+ora2FRqMx9nNHxgZutyuWJ6WlpdDpdAgJCZGkh4SE4OLFi7LnFBYWyuZvFkRu/re9PL169ZIcVyqVCAoKcriwsj3qoDX19fVYtmwZZs+eLXkh9KJFizBixAgEBQXh6NGjWL58OQoKCvDOO+/Y6JXl2Mv/qVOn4oEHHkBkZCSys7Px0ksvYdq0aUhKSoIoip2uD3z55Zfo1q0bHnjgAUm6K/QBwLo64GGzsLAQKpXK5AdPW3VpL+xRB63R6/V47rnnMH78eNx6663G9IcffhgREREICwtDWloali1bhoyMDPz0009crmsp9qqD2NhYfPHFFxg8eDAKCgrw2muv4Y477sC5c+fQrVu3TtcPtm3bBrVajXnz5knSPakfLFu2DGFhYcZAzpGxQacO7Aj7o9Fo8OCDD4Ixho0bN0qOLV682Pj/mJgYqFQqLFy4EGvXrnX7V9H89a9/Nf4/OjoaMTExGDBgAPbv349JkyY5sWTO4fPPP8cjjzwCHx8fSbon9wHClPj4eJw7dw6HDx+WpD/xxBPG/0dHR6N3796YNGkSsrOzMWDAAEcXkzvTpk0z/j8mJgaxsbGIiIjA999/LzuL7el89tlnmDZtGsLCwiTpntIP1q1bh82bN2P//v0m9zxH4HaPYnkSHBwMURRNdh4VFRUhNDRU9pzQ0NA28zf/216e4uJiyXGtVovy8nKz17UX9qiDZpqDutzcXOzevVsyWydHbGwstFotcnJyOu6IldjT/5ZERUUhODgYWVlZRhudoQ8AwKFDh5CRkYHHH3+83bI4ow8A1tUBD5uhoaFobGyEWq3mdl1rsUcdtOTpp5/Gzz//jH379qFv375t5o2NjQUA43hxFPaug2YCAwNx0003Se4HnaUf5ObmYs+ePRbfDwD36gdvv/021q1bh99++w0xMTHGdEfGBp06sFOpVBg5ciQSExONaXq9HomJiRg7dqzsOWPHjpXkB4Ddu3cb80dGRiI0NFSSp6qqCsnJycY8Y8eOhVqtxsmTJ4159u7dC71eb+zIjsIedQDcCOoyMzOxZ88e9OjRo92ypKamQqFQmExF2xN7+d+aq1evoqysDL179zba8PQ+0Mxnn32GkSNHYtiwYe2WxRl9ALCuDnjYHDlyJLy8vCR5MjIykJeXZ/V1rcUedQAYJB6efvppbN26FXv37kVkZGS756SmpgKAcbw4CnvVQWtqamqQnZ1t9K8z9INmNm3ahF69euG+++5rN6+79YO33noLa9aswa+//ipZJwc4ODaweJuFh7J582bm7e3NvvjiC3bhwgX2xBNPsMDAQFZYWMgYY2zOnDnsxRdfNOY/cuQIUyqV7O2332bp6els1apVsnIngYGBbPv27SwtLY3NnDlTdkvz8OHDWXJyMjt8+DAbNGiQU6UueNZBY2MjmzFjBuvbty9LTU2VbF1vaGhgjDF29OhR9u6777LU1FSWnZ3NvvrqK9azZ0/22GOPub3/1dXVbOnSpSwpKYldvnyZ7dmzh40YMYINGjSI1dfXG+14ch9oprKyknXp0oVt3LjR5Jqu1AcY63gdNDQ0sNOnT7PTp0+z3r17s6VLl7LTp0+zzMxMi20yZpC5CA8PZ3v37mUnTpxgY8eOZWPHjnWc4y2wRx089dRTLCAggO3fv19yL6itrWWMMZaVlcVWr17NTpw4wS5fvsy2b9/OoqKi2J133ulY55uwRx0sWbKE7d+/n12+fJkdOXKExcXFseDgYFZcXGzM4+n9gDHDztLw8HC2bNkyk2u6ez9Yt24dU6lU7IcffpD08+rqakkeR8QGnT6wY4yxDz74gIWHhzOVSsVGjx7Njh07Zjw2ceJENnfuXEn+77//nt10001MpVKxW265he3cuVNyXK/Xs1deeYWFhIQwb29vNmnSJJaRkSHJU1ZWxmbPns38/PyYv78/mz9/vqQDOBqedXD58mUGQPavWbPo5MmTLDY2lgUEBDAfHx82dOhQ9uabb0oCH0fC0//a2lo2efJk1rNnT+bl5cUiIiLYggULJF/mjHl2H2jmk08+Yb6+vkytVpscc7U+wFjH6sBcP584caLFNhljrK6ujv3jH/9g3bt3Z126dGH3338/KygosKebbcK7DszdCzZt2sQYYywvL4/deeedLCgoiHl7e7OBAwey559/3mn6ZYzxr4OHHnqI9e7dm6lUKtanTx/20EMPsaysLMk1Pb0fMMbYrl27GACT70PG3L8fREREyNbBqlWrjHkcFRu43SvFCIIgCIIgCHk69Ro7giAIgiAIT4ICO4IgCIIgCA+BAjuCIAiCIAgPgQI7giAIgiAID4ECO4IgCIIgCA+BAjuCIAiCIAgPgQI7giAIgiAID4ECO4IgCIIgCA+BAjuCIAgOZGRkIDQ0FNXV1e3mvXDhAvr27Yvr1687oGQEQXQmKLAjCIIww1133YXnnnvOorzLly/HM888g27durWb9+abb8aYMWPwzjvv2FhCgiAIKRTYEQRB2EheXh5+/vlnzJs3z+Jz5s+fj40bN0Kr1dqvYARBdDoosCMIgpBh3rx5OHDgAN5//30IggBBEJCTkyOb9/vvv8ewYcPQp08fY1pubi7++Mc/onv37ujatStuueUWJCQkGI/fe++9KC8vx4EDB+ztCkEQnQilswtAEAThirz//vv4/fffceutt2L16tUAgJ49e8rmPXToEEaNGiVJi4+PR2NjIw4ePIiuXbviwoUL8PPzMx5XqVS47bbbcOjQIUyaNMl+jhAE0amgwI4gCEKGgIAAqFQqdOnSBaGhoW3mzc3NNQns8vLyMGvWLERHRwMAoqKiTM4LCwtDbm4uv0ITBNHpoUexBEEQNlJXVwcfHx9J2qJFi/D6669j/PjxWLVqFdLS0kzO8/X1RW1traOKSRBEJ4ACO4IgCBsJDg5GRUWFJO3xxx/HpUuXMGfOHJw9exajRo3CBx98IMlTXl5u9vEuQRCENVBgRxAEYQaVSgWdTtduvuHDh+PChQsm6f369cOTTz6Jn376CUuWLMGnn34qOX7u3DkMHz6cW3kJgiAosCMIgjBD//79kZycjJycHJSWlkKv18vmmzJlCpKSkiRB4HPPPYddu3bh8uXLOHXqFPbt24ehQ4caj+fk5CA/Px9xcXF294MgiM4DBXYEQRBmWLp0KURRxM0334yePXsiLy9PNt+0adOgVCqxZ88eY5pOp0N8fDyGDh2KqVOn4qabbsJHH31kPP7tt99i8uTJiIiIsLsfBEF0HgTGGHN2IQiCINydDRs2YMeOHdi1a1e7eRsbGzFo0CB88803GD9+vANKRxBEZ4HkTgiCIDiwcOFCqNVqVFdXt/tasby8PLz00ksU1BEEwR2asSMIgiAIgvAQaI0dQRAEQRCEh0CBHUEQBEEQhIdAgR1BEARBEISHQIEdQRAEQRCEh0CBHUEQBEEQhIdAgR1BEARBEISHQIEdQRAEQRCEh0CBHUEQBEEQhIdAgR1BEARBEISH8P8AxslzpYBCmm4AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "seq.plot(time_range=(0.0, 0.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timing check passed successfully\n"
     ]
    }
   ],
   "source": [
    "ok, error_report = seq.check_timing()\n",
    "if ok:\n",
    "    print(\"Timing check passed successfully\")\n",
    "else:\n",
    "    print(\"Timing check failed. Error listing follows:\")\n",
    "    [print(e) for e in error_report]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fYNgdWc_KiK7"
   },
   "source": [
    "## **GENERATING `.SEQ` FILE**\n",
    "Uncomment the code in the cell below to generate a `.seq` file and download locally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6iN0aeuuqKRe"
   },
   "outputs": [],
   "source": [
    "if weightning == 'T2':\n",
    "    seq.write('C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t2_TSE_RESTORE\\\\t2_TSE_RESTORE_matrx16x16.seq')  # Save to disk\n",
    "    seq2xml(seq, seq_name='t2_TSE_RESTORE_matrx16x16_myGrad', out_folder='C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t2_TSE_RESTORE')\n",
    "    \n",
    "else:\n",
    "    print('Please choose image weightning')\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "write_t2_se.ipynb",
   "private_outputs": true,
   "provenance": []
  },
  "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}