From 45b8188702496716116fa05d10da95aeea98a38b Mon Sep 17 00:00:00 2001 From: Chen Xie Date: Mon, 2 Oct 2017 20:17:33 -0400 Subject: [PATCH 1/3] Tidy and clarify several aspects. Rename gqrs variables and other processing variables, move and change heart rate and gqrs demo. Update function documentation. Correct all cases of dac and adc. Update readme to capture new changes. --- README.rst | 186 +++++++++++++++++++++++++++---------- demo.ipynb | 136 +++++++++++++++++++++++---- examples/Heart Rate.ipynb | 120 ------------------------ wfdb/processing/basic.py | 6 +- wfdb/processing/gqrs.py | 46 +++++---- wfdb/processing/hr.py | 42 ++++++--- wfdb/processing/peaks.py | 22 ++--- wfdb/readwrite/_signals.py | 147 ++++++++++++++++++++++------- wfdb/readwrite/records.py | 2 +- 9 files changed, 443 insertions(+), 264 deletions(-) delete mode 100755 examples/Heart Rate.ipynb diff --git a/README.rst b/README.rst index c84620d0..0ac2d7bc 100644 --- a/README.rst +++ b/README.rst @@ -62,7 +62,8 @@ Example Usage: :: import wfdb - record1 = wfdb.Record(recordname='r1', fs=250, nsig=2, siglen=1000, filename=['r1.dat','r1.dat']) + record1 = wfdb.Record(recordname='r1', fs=250, nsig=2, siglen=1000, + filename=['r1.dat','r1.dat']) **MultiRecord** - The class representing multi-segment WFDB records. @@ -93,7 +94,9 @@ Example Usage: :: import wfdb - recordM = wfdb.MultiRecord(recordname='rm', fs=50, nsig=8, siglen=9999, segname=['rm_1', '~', rm_2'], seglen=[800, 200, 900]) + recordM = wfdb.MultiRecord(recordname='rm', fs=50, nsig=8, siglen=9999, + segname=['rm_1', '~', rm_2'], + seglen=[800, 200, 900]) recordL = wfdb.rdsamp('s00001-2896-10-10-00-31', m2s = False) recordL = recordL.multi_to_single() @@ -148,7 +151,8 @@ Reading Signals :: - record = rdsamp(recordname, sampfrom=0, sampto=None, channels=None, physical=True, pbdir = None, m2s=True) + record = rdsamp(recordname, sampfrom=0, sampto=None, channels=None, + physical=True, pbdir = None, m2s=True) Example Usage: @@ -166,7 +170,7 @@ Input Arguments: - ``physical`` (default=True): Flag that specifies whether to return signals in physical (True) or digital (False) units. - ``pbdir`` (default=None): Option used to stream data from Physiobank. The Physiobank database directory from which to find the required record files. eg. For record '100' in 'http://physionet.org/physiobank/database/mitdb', pbdir = 'mitdb'. - ``m2s`` (default=True): Flag used only for multi-segment records. Specifies whether to convert the returned wfdb.MultiRecord object into a wfdb.Record object (True) or not (False). -- ``smoothframes`` (default=True): Flag used when reading records with signals having multiple samples per frame. Specifies whether to smooth the samples in signals with more than one sample per frame and return an mxn uniform numpy array as the d_signals or p_signals field (True), or to return a list of 1d numpy arrays containing every expanded sample as the e_d_signals or e_p_signals field (False). +- ``smoothframes`` (default=True): Flag used when reading records with signals having multiple samples per frame. Specifies whether to smooth the samples in signals with more than one sample per frame and return an mxn uniform numpy array as the d_signals or p_signals field (True), or to return a list of 1d numpy arrays containing every expanded sample as the e_d_sign.als or e_p_signals field (False). - ``ignoreskew`` (default=False): Flag used when reading records with at least one skewed signal. Specifies whether to apply the skew to align the signals in the output variable (False), or to ignore the skew field and load in all values contained in the dat files unaligned (True). - ``returnres`` (default=64): The numpy array dtype of the returned signals. Options are: 64, 32, 16, and 8, where the value represents the numpy int or float dtype. Note that the value cannot be 8 when physical is True since there is no float8 format. @@ -204,6 +208,80 @@ Output arguments: - ``comments``: Any comments written in the header +Converting between Analog and Digital Values +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When reading signal sample values into ``record`` objects using ``rdsamp``, the samples are stored in either the ``p_signals`` or the ``d_signals`` field depending on the specified return type (``physical`` = ``True`` or ``False`` respectively). + +One can also use existing objects to obtain physical values from digital values and vice versa, without having to re-read the wfdb file with a different set of options. The two following instance methods perform the conversions. + + +**adc** - Performs analogue to digital conversion of the physical signal stored + in p_signals if expanded is False, or e_p_signals if expanded is True. + + The p_signals/e_p_signals, fmt, gain, and baseline fields must all be + valid. + + If inplace is True, the adc will be performed inplace on the variable, + the d_signals/e_d_signals attribute will be set, and the + p_signals/e_p_signals field will be set to None. + +:: + + record.adc(self, expanded=False, inplace=False) + +Input arguments: + +- ``expanded`` (default=False): Boolean specifying whether to transform the e_p_signals attribute (True) or the p_signals attribute (False). +- ``inplace`` (default=False): Boolean specifying whether to automatically set the object's corresponding digital signal attribute and set the physical signal attribute to None (True), or to return the converted signal as a separate variable without changing the original physical signal attribute (False). + +Possible output argument: + +- ``d_signals``: The digital conversion of the signal. Either a 2d numpy array or a list of 1d numpy arrays. + +Example Usage: + +:: + import wfdb + record = wfdb.rdsamp('sampledata/100') + d_signal = record.adc() + record.adc(inplace=True) + record.dac(inplace=True) + + +**dac** - Performs digital to analogue conversion of the digital signal stored + in d_signals if expanded is False, or e_d_signals if expanded is True. + + The d_signals/e_d_signals, fmt, gain, and baseline fields must all be + valid. + + If inplace is True, the dac will be performed inplace on the variable, + the p_signals/e_p_signals attribute will be set, and the + d_signals/e_d_signals field will be set to None. + +:: + + record.dac(self, expanded=False, inplace=False) + +Input arguments: + +- ``expanded`` (default=False): Boolean specifying whether to transform the e_d_signals attribute (True) or the d_signals attribute (False). +- ``inplace`` (default=False): Boolean specifying whether to automatically set the object's corresponding physical signal attribute and set the digital signal attribute to None (True), or to return the converted signal as a separate variable without changing the original digital signal attribute (False). + +Possible output argument: + +- ``p_signals``: The physical conversion of the signal. Either a 2d numpy array or a list of 1d numpy arrays. + +Example Usage: + +:: + import wfdb + record = wfdb.rdsamp('sampledata/100', physical=False) + p_signal = record.dac() + record.dac(inplace=True) + record.adc(inplace=True) + + Writing Signals ~~~~~~~~~~~~~~~ @@ -214,15 +292,18 @@ The Record class has a **wrsamp** instance method for writing wfdb record files. :: - wrsamp(recordname, fs, units, signames, p_signals = None, d_signals=None, fmt = None, gain = None, baseline = None, comments = None) + wrsamp(recordname, fs, units, signames, p_signals = None, d_signals=None, + fmt = None, gain = None, baseline = None, comments = None) Example Usage: :: import wfdb - sig, fields = wfdb.srdsamp('a103l', sampfrom = 50000, channels = [0,1], pbdir = 'challenge/2015/training') - wfdb.wrsamp('ecgrecord', fs = 250, units = ['mV', 'mV'], signames = ['I', 'II'], p_signals = sig, fmt = ['16', '16']) + sig, fields = wfdb.srdsamp('a103l', sampfrom = 50000, channels = [0,1], + pbdir = 'challenge/2015/training') + wfdb.wrsamp('ecgrecord', fs = 250, units = ['mV', 'mV'], + signames = ['I', 'II'], p_signals = sig, fmt = ['16', '16']) Input Arguments: @@ -320,7 +401,8 @@ The Annotation class has a **wrann** instance method for writing wfdb annotation :: - wrann(recordname, extension, sample, symbol=None, subtype=None, chan=None, num=None, aux_note=None, label_store=None, fs=None, custom_labels=None) + wrann(recordname, extension, sample, symbol=None, subtype=None, chan=None, + num=None, aux_note=None, label_store=None, fs=None, custom_labels=None) Example Usage: @@ -381,7 +463,9 @@ Example Usage: record = wfdb.rdsamp('sampledata/100', sampto = 3000) annotation = wfdb.rdann('sampledata/100', 'atr', sampto = 3000) - wfdb.plotrec(record, annotation = annotation, title='Record 100 from MIT-BIH Arrhythmia Database', timeunits = 'seconds', figsize = (10,4), ecggrids = 'all') + wfdb.plotrec(record, annotation = annotation, + title='Record 100 from MIT-BIH Arrhythmia Database', + timeunits = 'seconds', figsize = (10,4), ecggrids = 'all') Input Arguments: @@ -413,7 +497,9 @@ Example Usage: record = wfdb.rdsamp('sampledata/100', sampto = 15000) annotation = wfdb.rdann('sampledata/100', 'atr', sampto = 15000) - wfdb.plotrec(record, annotation = annotation, title='Record 100 from MIT-BIH Arrhythmia Database', timeunits = 'seconds') + wfdb.plotrec(record, annotation = annotation, + title='Record 100 from MIT-BIH Arrhythmia Database', + timeunits = 'seconds') Input Arguments: @@ -450,7 +536,8 @@ Example Usage: :: - dldatabase(pbdb, dlbasedir, records = 'all', annotators = 'all' , keepsubdirs = True, overwrite = False) + dldatabase(pbdb, dlbasedir, records = 'all', annotators = 'all' , + keepsubdirs = True, overwrite = False) Example Usage: @@ -491,10 +578,10 @@ Input arguments: - ``overwrite`` (default=False): If set to True, all files will be redownloaded regardless. If set to False, existing files with the same name and relative subdirectory will be checked. If the local file is the same size as the online file, the download is skipped. If the local file is larger, it will be deleted and the file will be redownloaded. If the local file is smaller, the file will be assumed to be partially downloaded and the remaining bytes will be downloaded and appended. -Signal processing +Signal Processing ----------------- -Basic functionalities +Basic Functionalities ~~~~~~~~~~~~~~~~~~~~~ **resample_sig** - Resample a single-channel signal @@ -608,14 +695,16 @@ Input arguments: - ``window_size`` (required): The smoothing window width. -Peak detection +Peak Detection ~~~~~~~~~~~~~~ **gqrs_detect** - The GQRS detector function :: - gqrs_detect(x, frequency, adcgain, adczero, threshold=1.0, hr=75, RRdelta=0.2, RRmin=0.28, RRmax=2.4, QS=0.07, QT=0.35, RTmin=0.25, RTmax=0.33, QRSa=750, QRSamin=130) + gqrs_detect(x, fs, adcgain, adczero, threshold=1.0, hr=75, RRdelta=0.2, + RRmin=0.28, RRmax=2.4, QS=0.07, QT=0.35, RTmin=0.25, RTmax=0.33, + QRSa=750, QRSamin=130): Example Usage: @@ -624,31 +713,31 @@ Example Usage: import wfdb t0 = 10000 tf = 20000 - sig, fields = wfdb.srdsamp('sampledata/100', sampfrom=t0, sampto=tf, channels=[0]) - record = wfdb.rdsamp("sampledata/100", sampfrom=t0, sampto=tf, channels=[0], physical=False) - peaks_indexes = wfdb.processing.gqrs_detect(x=sig[:,0], frequency=fields['fs'], adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0) + record = wfdb.rdsamp("sampledata/100", sampfrom=t0, sampto=tf, channels=[0]) + d_signal = record.adc()[:,0] + peak_indices = wfdb.processing.gqrs_detect(x=d_signal, fs=record.fs, adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0) Input arguments: -- ``x`` (required): The signal. -- ``frequency`` (required): The signal frequency. -- ``adcgain`` (required): The gain of the signal (the number of adus (q.v.) per physical unit). +- ``x`` (required): The digital signal as a numpy array +- ``fs`` (required): The sampling frequency of the signal +- ``adcgain``: The gain of the signal (the number of adus (q.v.) per physical unit) - ``adczero`` (required): The value produced by the ADC given a 0 volt input. -- ``threshold`` (default=1.0): The threshold for detection. -- ``hr`` (default=75): Typical heart rate, in beats per minute. -- ``RRdelta`` (default=0.2): Typical difference between successive RR intervals in seconds. -- ``RRmin`` (default=0.28): Minimum RR interval ("refractory period"), in seconds. -- ``RRmax`` (default=2.4): Maximum RR interval, in seconds; thresholds will be adjusted if no peaks are detected within this interval. -- ``QS`` (default=0.07): Typical QRS duration, in seconds. -- ``QT`` (default=0.35): Typical QT interval, in seconds. -- ``RTmin`` (default=0.25): Minimum interval between R and T peaks, in seconds. -- ``RTmax`` (default=0.33): Maximum interval between R and T peaks, in seconds. -- ``QRSa`` (default=750): Typical QRS peak-to-peak amplitude, in microvolts. -- ``QRSamin`` (default=130): Minimum QRS peak-to-peak amplitude, in microvolts. +- ``threshold`` (default=1.0): The threshold for detection +- ``hr`` (default=75): Typical heart rate, in beats per minute +- ``RRdelta`` (default=0.2): Typical difference between successive RR intervals in seconds +- ``RRmin`` (default=0.28): Minimum RR interval ("refractory period"), in seconds +- ``RRmax`` (default=2.4): Maximum RR interval, in seconds; thresholds will be adjusted if no peaks are detected within this interval +- ``QS`` (default=0.07): Typical QRS duration, in seconds +- ``QT`` (default=0.35): Typical QT interval, in seconds +- ``RTmin`` (default=0.25): Minimum interval between R and T peaks, in seconds +- ``RTmax`` (default=0.33): Maximum interval between R and T peaks, in seconds +- ``QRSa`` (default=750): Typical QRS peak-to-peak amplitude, in microvolts +- ``QRSamin`` (default=130): Minimum QRS peak-to-peak amplitude, in microvolts Output Arguments: -- ``peaks_indexes``: A python list containing the peaks indexes. +- ``peak_indices``: A python list containing the peak indices. **correct_peaks** - A post-processing algorithm to correct peaks position. @@ -658,7 +747,7 @@ See code comments for details about the algorithm. :: - correct_peaks(x, peaks_indexes, min_gap, max_gap, smooth_window) + correct_peaks(x, peak_indices, min_gap, max_gap, smooth_window) Example Usage: @@ -669,35 +758,38 @@ Example Usage: tf = 20000 sig, fields = wfdb.srdsamp('sampledata/100', sampfrom=t0, sampto=tf, channels=[0]) record = wfdb.rdsamp("sampledata/100", sampfrom=t0, sampto=tf, channels=[0], physical=False) - peak_indexes = wfdb.processing.gqrs_detect(x=sig[:,0], frequency=fields['fs'], adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0) + peak_indices = wfdb.processing.gqrs_detect(x=sig[:,0], frequency=fields['fs'], + adcgain=record.adcgain[0], adczero=record.adczero[0], + threshold=1.0) fs = fields['fs'] min_bpm = 10 max_bpm = 350 min_gap = fs*60/min_bpm max_gap = fs*60/max_bpm - new_indexes = wfdb.processing.correct_peaks(x=sig[:,0], peaks_indexes=peak_indexes, min_gap=min_gap, max_gap=max_gap, smooth_window=150) + new_indices = wfdb.processing.correct_peaks(x=sig[:,0], peak_indices=peak_indices, + min_gap=min_gap, max_gap=max_gap, smooth_window=150) Input arguments: - ``x`` (required): The signal. -- ``peaks_indexes`` (required): The location of the peaks. +- ``peak_indices`` (required): The location of the peaks. - ``min_gap`` (required): The minimum gap in samples between two peaks. - ``max_gap`` (required): The maximum gap in samples between two peaks. - ``smooth_window`` (required): The size of the smoothing window. Output Arguments: -- ``new_indexes``: A python list containing the new peaks indexes. +- ``new_indices``: A python list containing the new peaks indices. -Heart rate +Heart Rate ~~~~~~~~~~~~~~ -**compute_hr** - Compute heart rate from peak indexes and signal frequency. +**compute_hr** - Compute instantaneous heart rate from peak indices and signal frequency. :: - compute_hr(length, peaks_indexes, fs) + compute_hr(siglen, peak_indices, fs) Example Usage: @@ -708,19 +800,19 @@ Example Usage: tf = 20000 sig, fields = wfdb.srdsamp('sampledata/100', sampfrom=t0, sampto=tf, channels=[0]) record = wfdb.rdsamp("sampledata/100", sampfrom=t0, sampto=tf, channels=[0], physical=False) - peaks_indexes = wfdb.processing.gqrs_detect(x=sig[:,0], frequency=fields['fs'], adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0) - hr = compute_hr(length=tf-t0, peaks_indexes=peaks_indexes, fs=fields['fs']) + peak_indices = wfdb.processing.gqrs_detect(x=sig[:,0], frequency=fields['fs'], adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0) + hr = compute_hr(siglen=tf-t0, peak_indices=peak_indices, fs=fields['fs']) Input arguments: -- ``length`` (required): The length of the corresponding signal. -- ``peaks_indexes`` (required): The peak indexes. -- ``fs`` (required): The signal frequency. +- ``siglen`` (required): The length of the corresponding signal. +- ``peak_indices`` (required): The peak indices. +- ``fs`` (required): The corresponding signal's sampling frequency. Output Arguments: -- ``hr``: A numpy.array containing heart rate for each sample. Contains numpy.nan where heart rate could not be computed. +- ``hr``: A numpy array of the instantaneous heart rate, with the length of the corresponding signal. Contains numpy.nan where heart rate could not be computed. diff --git a/demo.ipynb b/demo.ipynb index 06eab39c..f95552fb 100644 --- a/demo.ipynb +++ b/demo.ipynb @@ -12,12 +12,15 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "import wfdb\n", "import numpy as np\n", "import os\n", + "import matplotlib.pyplot as plt\n", "from IPython.display import display" ] }, @@ -46,7 +49,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 1 - Read a wfdb record using the 'rdsamp' function into a wfdb.Record object.\n", @@ -64,7 +69,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 2 - Read certain channels and sections of the WFDB record using the simplified 'srdsamp' function\n", @@ -80,7 +87,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 3 - Read a WFDB header file only (without the signals)\n", @@ -94,7 +103,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 4 - Read part of a WFDB annotation file into a wfdb.Annotation object, and plot the samples\n", @@ -109,7 +120,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 5 - Read a WFDB record and annotation. Plot all channels, and the annotation on top of channel 0.\n", @@ -134,7 +147,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 6 - Read the multi-segment record and plot waveforms from the MIMIC matched waveform database. \n", @@ -151,7 +166,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 7 - Read the multi-segment record and plot waveforms from the MIMIC matched waveform database.\n", @@ -186,7 +203,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 8 - Read a wfdb record in which one channel has multiple samples/frame. Return a smoothed uniform array.\n", @@ -197,7 +216,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 9 - Read a wfdb record in which one channel has multiple samples/frame. Return a list of all the expanded samples.\n", @@ -220,7 +241,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 10 - Read a WFDB record's digital samples and create a copy via the wrsamp() instance method \n", @@ -261,7 +284,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 12 - Write a WFDB record with multiple samples/frame in a channel\n", @@ -280,7 +305,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 13 - Read a WFDB annotation file and create a copy via the wrann() instance method\n", @@ -320,7 +347,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 15 - View what the 'anntype' symbols mean in the standard WFDB library\n", @@ -341,7 +370,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 16 - List the Physiobank Databases\n", @@ -353,7 +384,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 17 - Download all the WFDB records and annotations from a small Physiobank Database\n", @@ -375,7 +408,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "# Demo 18 - Download specified files from a Physiobank database\n", @@ -398,6 +433,73 @@ "display(os.listdir(os.path.join(dldir, 'data')))" ] }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## ECG Peak Detection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def peaks_hr(x, peak_indices, fs, title, figsize=(20, 10), saveto=None):\n", + " \n", + " # Calculate heart rate\n", + " hrs = wfdb.processing.compute_hr(siglen=x.shape[0], peak_indices=peak_indices, fs=fs)\n", + " \n", + " N = x.shape[0]\n", + " \n", + " fig, ax_left = plt.subplots(figsize=figsize)\n", + " ax_right = ax_left.twinx()\n", + " \n", + " ax_left.plot(x, color='#3979f0', label='Signal')\n", + " ax_left.plot(peak_indices, x[peak_indices], 'rx', marker='x', color='#8b0000', label='Peak', markersize=12)\n", + " ax_right.plot(np.arange(N), hrs, label='Heart rate', color='m', linewidth=2)\n", + "\n", + " ax_left.set_title(title)\n", + "\n", + " ax_left.set_xlabel('Time (ms)')\n", + " ax_left.set_ylabel('ECG (mV)', color='#3979f0')\n", + " ax_right.set_ylabel('Heart rate (bpm)', color='m')\n", + " # Make the y-axis label, ticks and tick labels match the line color.\n", + " ax_left.tick_params('y', colors='#3979f0')\n", + " ax_right.tick_params('y', colors='m')\n", + " if saveto is not None:\n", + " plt.savefig(saveto, dpi=600)\n", + " plt.show()\n", + "\n", + "\n", + "recordname = 'sampledata/100'\n", + "\n", + "def gqrs_plot(recordname, t0=0, tf=10000):\n", + " # Load the wfdb record and the physical samples\n", + " record = wfdb.rdsamp(recordname, sampfrom=t0, sampto=tf, channels=[0])\n", + " \n", + " # Use the gqrs algorithm to find peaks in the first channel\n", + " # The gqrs_detect argument expects a digital signal for the first argument.\n", + " d_signal = record.adc()[:,0]\n", + " peak_indices = wfdb.processing.gqrs_detect(d_signal, fs=record.fs, adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0)\n", + " print('gqrs detected peak indices:', peak_indices)\n", + " peaks_hr(x=record.p_signals, peak_indices=peak_indices, fs=record.fs, title=\"GQRS peak detection on sampledata/100\")\n", + " \n", + " # Do peak detection with constraints\n", + " min_bpm = 20\n", + " max_bpm = 230\n", + " min_gap = record.fs*60/min_bpm\n", + " max_gap = record.fs*60/max_bpm\n", + " peak_indices = wfdb.processing.correct_peaks(d_signal, peak_indices=peak_indices, min_gap=min_gap, max_gap=max_gap, smooth_window=150)\n", + " print('corrected gqrs detected peak indices:', sorted(peak_indices))\n", + " peaks_hr(x=record.p_signals, peak_indices=sorted(peak_indices), fs=record.fs, title=\"Corrected GQRS peak detection on sampledata/100\")\n", + "\n", + "gqrs_plot(recordname)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/examples/Heart Rate.ipynb b/examples/Heart Rate.ipynb deleted file mode 100755 index b304acc7..00000000 --- a/examples/Heart Rate.ipynb +++ /dev/null @@ -1,120 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[357, 650, 934, 1218, 1502, 1797, 2032, 2390, 2693, 2985, 3270, 3547, 3850, 4157, 4453, 4752, 5048, 5334, 5621, 5906, 6202, 6514, 6811, 7093, 7379, 7657, 7940, 8233, 8526, 8824, 9129, 9419, 9698]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABLoAAAJcCAYAAAD+Vc3FAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3XmcZFV99/HvmRmWAaFAFmVxwbgCURPXdHy03NEYMcbd\nx12JMYlmc6E1gkTK9VExogZ34gqKuygYraCWaEBQdmUTZhgZ1pph9u4+zx/3VlPT0z3d1V33/G6d\n3+f9evFiurqrzj3LPffcX51zbogxCgAAAAAAABh1y6wPAAAAAAAAABgGAl0AAAAAAADIAoEuAAAA\nAAAAZIFAFwAAAAAAALJAoAsAAAAAAABZINAFAAAAAACALBDoAgAA5kII9w4hxBDCikW+P4YQ7jvs\n41rEcVwSQmhaH0fdhRDaIYRXp34vAADIH4EuAABqKoTwghDCL0IIG0IIa8t/vy6EEPr+ZiyE8KMQ\nwvoQQjeE8K0QwgP7ft8MIUyFEO4o/+aKEMIrZqRzdAjhwhDCuhDCzeXnHZYyr6mU5bFqSJ/12RDC\nO/tfizEeEWNsD+PzsXQhhGtDCE9axPuuCCHcP4Tw+BDCj8tz69pZ/u7e5e83hhAun5lWCOGfQgh/\nKM+tT4cQdltCdgAAwAIQ6AIAoIZCCP8i6SRJ75N0d0l3k/RaSX8uadfyb/5M0lmSvinpYEmHSfqN\npJ+FEO7d93E3xBjvImlvSf8k6RMhhAeUn3FfSadK+hdJjfIzTpY0WWkGgZoKIfyRpOUxxt9K2iDp\n05LeOMeff0nSBZL2k/RWSV8NIRxQfs5TJb1F0hMl3UvSfSS9o9qjBwAABLoAAKiZEEJD0gmSXhdj\n/GqMcX0sXBBjfHGMcUv5p++VdGqM8aTyb26NMb5N0i8lHTfzc8vP+J6kWyU9uHz5oZKuiTH+d/n7\n9THGr8UYr5vj2D4bQvh4COHscobY/4QQ7tX3+weWv7u1nBXzvL7f/UUI4YJydsv1IYTjd1IGf13O\nxjlyjt+/MYSwJoRwQwjhlTN+t1sI4f0hhOtCCDeWx7syhLCnpDMlHVzOcLsjhHBwCGFZCOEtIYSr\nQgi3hBBOCyHcte/zHhNC6IQQbi+P++UhhGMkvVjSm8rP+Xb5t9MziMrj+FB5jDeU/96t/F0zhLAq\nhPAv5Wy9NTNn2s3I08HlbL1bQwhXhhBe0/e748tjPrWsk0tCCA+f43NCCOGDZZrrQggX9cp4Z/UT\n7lxa+oryd7eFEF4bQnhECOE3Zdl8pO/vXx5C+FkI4SPlbKjLQwhP3En+XhlCuKz83B/MaFNPLt/f\nLdPon9H4R6GYgXhLKGYjfiGEsE/5u/+SdE9J3y7r6E3l66eHYpZVN4RwTgjhiBmH8xeSvidJMcZf\nxhj/S9LVsxzz/SX9qaTjYoybYoxfk3SRpL8u/+Rlkj4VY7wkxnibpH+X9PK5ygAAAAwHgS4AAOrn\nzyTtpmKm1qxCCHtIGpN0+iy/Pk3SU2Z5z7IQwjMl7S/pyvLlX0l6YBn8eHwI4S4LOL4Xq7hp31/S\nhZK+UH7+npLOlvRFSQdKeoGkj4YQDi/ft0HSSyXtoyKY8LchhGfNcpyvkPQeSU+KMV48y++PkvSv\nkp4s6X6SZi5Ne7ek+6sI4t1X0iGS3h5j3CDpaSpnuJX/3SDpHyQ9S9LjVMyMu03FrDaVAZczJf2H\npAPKz7wwxnhKme/3lp/zl7OU01slPbp8z0MkPVLS2/p+f3cVs+gOkfQqSSeHEPad5XMk6cuSVpXH\n9xxJrRDCE/p+/8zyb/aR9C1JH9nhEwpPkfTYsnwakp4n6Zbydwupn0epKPPnS/pQmccnSTpC0vNC\nCI+b8bdXqWgnx0k6oz+A2BNCOFrSuKRnqyjjn6iYKaUQwv6SzlBRbvuXn/fn/W+X9K6yXB4k6R6S\njpekGONLJF0n6S/LOnpv+Z4zyzwcqKL9f2HGIT1d0ndnHucsjpB0dYxxfd9rvy5f7/3+1zN+d7cQ\nwn4L+GwAALBIBLoAAKif/SXdHGOc6L3QN6NoUwjhsZLuquI6vmaW969RETDoOTiEcLukTZK+Lumf\nY4wXSFKM8WpJTRXBltMk3RyKWVs7C3h9N8Z4Tjmz7K2S/iyEcA9Jz5B0bYzxMzHGiTKNr0l6bplW\nO8Z4UYxxKsb4GxXBjMfN+Ox/VLFMrBljvFKze56kz8QYLy6DV8f3lVOQdIykfypnuK2X1FIRdJvL\nayW9Nca4qszT8ZKeE4qN8V8k6Ycxxi/FGLfFGG+JMV64k8/q92JJJ8QY18YYb1KxbO0lfb/fVv5+\nWznT7g5JD5j5IWXZ/rmkN8cYN5fpf1JFUKrnpzHG78UYJyX9l4rA2my2SdpL0gMlhRjjZTHGNdKC\n6+ffy2M4S0Vg7Etl/larCFD9Sd/frpX0oTJ/X5F0hYoA2kyvlfSu8lgmVNTXQ8sg49MlXVLObNym\nIrj2h94bY4xXxhjPjjFuKcv4A7Mc83ZijJ8uZy726vohoZhF2QsgP0JSe2efUbqLpO6M17oqyne2\n3/f+vZcAAEBlCHQBAFA/t0jaP/Q9gTDGOBZj3Kf83TIVs46mJB00y/sPknRz3883lO/dW9KHJfXP\nBFKM8dwY4/NijAdI+j8qZvy8dSfHd33fe+9QsRTyYBX7ED2qDMjdXgbXXqxi5pJCCI8KxcbdN4UQ\nuioCHPvP+Ow3Sjo5xrizDeMP7j8GSb/v+/cBkvaQdH7fMXxf2wf+ZrqXpK/3/f1lKvYou5uKGUJX\n7eS9O3PwjGP7fflazy39wUxJG1UER2b7nF7Qrv+zDun7+Q99/94oafcwyxMsY4w/UjHb62RJa0MI\np4QQ9pYWXD839v170yw/9x//6hhjnHHM/fnvuZekk/rK/1YVM7UO0Yy6Lj9v+ucQwt1CCF8OIawO\nIayT9PlZjll9f788hPDuUCxTXSfp2vJXvfc8UVKnb3nwztyh4pzqt7ek9XP8vvfv9QIAAJUh0AUA\nQP38XNIWSUfP9QflTKafq5wtNcPzNMuMlPLm/c2S/ni2JYPl3/yviqVis+6NVbpH7x/lzK+7SrpB\nRQDif2KM+/T9d5cY49+Wf/5FFcvq7hFjbEj6uPr2Wyo9RdLbQgh/rbmt6T8GFfsw9dysIuByRN8x\nNGKxGb8k9Qdeeq6X9LQZx717OUvpekl/NMdxzPZZ/W5QEcTpP84b5nnPXJ9z1xBC/0yge0pavYjP\nUozxwzHGh0k6XMUSxt5G6wupn0EcUs6w65kr/9dL+psZ5b8yxtjRjLouP6+/7lsq6uGPY4x7S/q/\nM455Zh29SMV59SQVSzfv3fvo8v9PV7k/1wJcIuk+M+rlIeXrvd8/ZMbvbowx3iIAAFAZAl0AANRM\njPF2FcvcPhpCeE4IYa9yf62HStqz70/fIullIYTXl3+zbwjhnSpmZbXm+Oytkv6fpLdL0xutvyaE\ncGD58wNV7Pd07k4O8enl+3ZVsVfXuTHG6yV9R9L9QwgvCSHsUv73iBDCg8r37aViZtLmEMIjVQQd\nZrpE0lEq9qt65hzpnybp5SGEw8ulZtMb78cYpyR9QtIH+/J0SCiegCcVM5D26y1VK31c0om9DdBD\nCAeU+0ZJxf5NTwohPC+EsCKEsF9ZD73Pus9OyulLKoJ2B5R7Tb1dxYyjgZRl25H0rhDC7iGEB6vY\n02vgzyrr41EhhF1ULD3crGJmoLSw+hnEgZJeX7aD56rYQ2u2INLHJR3b2xQ+hNAo/14q9so6IoTw\n7HKG2utVzhDsO+Y7JHVDCIdox6cjzqyjvVQEkW9RMfNv5nnyNPXtz1Wed7tL2qX4MexetnvF4qmM\nF0o6rnz9r1Q85OFr5dtPlfSqsp3uo2Kfsc/OUVYAAGBICHQBAFBD5cbZ/yzpTSpu1m+U9J8qZmR1\nyr/5qaSnqtjEe42KJV8vk/TE2TZx7/NpSfcMIfylpNtVBLYuCiHcoWKZ39dVPNFxLl9UEVy6VdLD\nVMyiUbm07ikq9sO6QcVyuveo2Fhfkl4n6YQQwnoVQZ/T5sj7r1Xs9/WJEMLTZvn9mSr2avqRik31\nfzTjT95cvn5uuTzthyr3vooxXq4iAHV1uVTuYEknqZjJdFZ5bOeq2EhdsXj65NMl/UuZ3wt15yyd\nT0k6vPycb8ySlXdKOk/Sb1Q8je9X5WuL8UIVs49uUFE/x8UYf7iIz9lbRSDwNhVLCW+R9L7ydwuq\nnwH8QsWm7zdLOlHSc2abzRRj/LqKdvLlsr4uVhFwUozxZhWzFt9dHuv9JP2s7+3vUPHkw66KANUZ\nMz7+XSqCjbeHEP5VRfDp9ypmw12qvoBuKJ4+eUfc/omjj1UxQ/B7KmakbZJ0Vt/vXyDp4SrK891l\nHm8qj/37Ks6jH6vYFP/3muVpqAAAYLjC9lsnAACAUVXO9PmxpBfFGH9QURqflbQqxvi2+f4WfoUQ\nXi7p1THGx1gfy0KFEN4kaf8Y45usjwUAACweM7oAAMhE+aS8Z6nYg2uHjcgB7NS1kj5jfRAAAGBp\nGAQDAJCRGONPJP3E+jiAURNjXOpSTQAAUAMsXQQAAAAAAEAWKpvRNTbe/bSKjWTXdlqNI8vX3ifp\nLyVtlXSVpFd0Wo3bx8a795Z0maQryref22k1Xlu+52EqnlCzUsVGoG/otBpE5wAAAAAAALCdKpcu\nflbSR1Q83abnbEnHdlqNibHx7nskHaviyUiSdFWn1XiodvQxSa9R8eSe76l45PiZ8yW+bNmyuHLl\nysUfPQAAAAAAALazcePGGGOs7Z7vlQW6Oq3GOeVMrf7X+h/HfK6k5+zsM8bGuwdJ2rvTapxb/nyq\nik125w10rVy5Uhs2bBj0sAEAAAAAADCHEMIm62PYGcvN6F8p6St9Px82Nt69QNI6SW/rtBo/kXSI\npFV9f7OqfG1WY+PdYyQdI0mTU0M/XgAAAAAAANSYSaBrbLz7VkkTkr5QvrRG0j07rcYt5Z5c3xgb\n7x4x6Od2Wo1TJJ0iSXueJPbxAgAAAAAAcCR5oGtsvPtyFZvUP7G3qXyn1dgiaUv57/PHxrtXSbq/\npNWSDu17+6HlawAAAAAAAMB2km4eNjbePUrSmyQ9s9NqbOx7/YCx8e7y8t/3kXQ/SVd3Wo01ktaN\njXcfPTbeDZJeKumbKY8ZAAAAAAAAo6GyGV1j490vSWpK2n9svLtK0nEqnrK4m6Szx8a7knRup9V4\nraTHSjphbLy7TdKUpNd2Wo1by496nYonOK5UsQn9vBvRAwAAAAAAwJ8QY55bWe25556Rpy4CAAAA\nAAAMTwhhY4xxT+vjmEvSpYsAAAAAAABAVQh0AQAAAAAAIAsEugAAAAAAAJAFAl0AAAAAAADIAoEu\nAAAAAAAAZIFAFwAAAAAAALJAoAsAAAAAAABZINAFAAAAAACALBDoAgAAAAAAQBYIdAEAAAAAACAL\nBLoAAAAAAACQBQJdAAAAAAAAyAKBLgAAAAAAAGSBQBcAAAAAAACyQKALAAAAAAAAWVhhfQAAMGyT\nGyc1uX7S+jDuFKRdDthFIQTrIwEAAACArBHoApCVjVds1Hl/ep6mNk5ZH8p2Dvqbg/SAjz/A+jAA\nAEAFrrt5Usd/ZZNOeuWe2mslX2wBgCUCXQCysuHiDZraOKWwa9CKfey7uLgtauK2Ca3/5XrrQwEA\nABX51A+36PLVk+pcsU1Pfeiu1ocDjIyNW6KuWD2pP7mP/bgd+aA1AcjSfs/YT0d+7Ujrw9D6X63X\n+Q873/owAABAhWL5f+ZyAYM5/rSN+ullE/rOsXvprnuxhTiGg5YEAAAAAMNApAsYyJVrin11t0wY\nHwiyQqALAAAAAJYgllO6iHMBg4nz/wkwMAJdAAAAADAEPGAZGMx0kJhzB0NEoAtAVmLkeyEAAJAW\nww9gaYhzYZgIdAEAAADAEsRyARY368BgCBKjCgS6AOSJkSYAAEjkzuVXDECAQfTiXMs4dTBEBLoA\nAAAAAEBy0zO6CHRhiAh0AUAKTMsGAAAAZsdYGUNEoAsAAAAAloAnxwGL0zt3pgh0YYgIdAHIS90u\nkgx4AQDIHquvgMXpBbrqNoTHaCPQBQAAAABDwIwuYDC9ABdPX8QwEegCkCWeegQAAFJhQ21gaQh0\nYZgIdAEAAADAEhDnAhand84Q58IwEegCAAAAgKXgLh1YlN4ijMiULgwRgS4AAAAAWILpGV1M6QIG\ncmegy/Y4kBcCXQDywkUSAAAk1rtJJ84FDIali6gCgS4AAAAAGAJmdAGLw4wuDBOBLgB5qtlAk30H\nAADIF1d5YJFYuogKEOgCAAAAErhyzaTW3DZlfRioAjfpwKJML13kHMIQrbA+AADIWs1mlgEA7Lz0\nP+6QJHVaDeMjwbCxGT2wONOb0dseBjLDjC4AeeEqCQAj5TUfu0Nv/eIG68MAloTN6AGgPpjRBQAA\nADOXXD+pS663PgpgaZjRBQD1wYwujIytE0zVwQAYaAIAgETYXwhYGs4hDBOBLoyEa26cVPPt6/TD\n32y1PhQAAABgVszoAgB7BLowEn67ZlKS9JNLJ4yPBAAAAJgdca7hO+vXW/Xji7dZHwaAEcIeXQAA\nAACwBLFcdxWY0jV0x39lkySeVporlizmqR3ab5D0GhXx/080Y/ND7dC+q6SvSLq3pGslPa8Zm7dV\nkT4zugBkJdb1alnTwwIAAEtX1+EHAKTWDu0jVQS5HinpIZKe0Q7t+0p6i6T/bsbm/ST9d/lzJQh0\nYST0vhtjDJGPE07fqG/9L3uuAQCAfDCfCwD0IEm/aMbmxmZsTkj6H0nPlnS0pM+Vf/M5Sc+q6gBY\nuoiBXbZqQvvvvUwH7J0wTsqoITvfv2Cbvn/BNj3zEbtWk0BN2gxLGAAAyB9fxgLwpKHGinZon9f3\n0inN2Dyl/PfFkk5sh/Z+kjZJerqk8yTdrRmba8q/+YOku1V1fAS6MLBXfXSDdt9F+tE70q+TZ1o4\nAAAAaidu9z8AA+I+b7R01Z1oxubDZ/tdMzYva4f2eySdJWmDpAslTc74m9gO7cpqnaWLWJTNiR98\nwpwYALjTV362RWPjXU1NMSoEgJm+c/5WjY13tWVbuj6yl1Jt9woFgISasfmpZmw+rBmbj5V0m6Tf\nSrqxHdoHSVL5/7VVpU+gCwCAEfORMzdLkohzAcCOPvnDoo+8fUPCQBf9MQBMa4f2geX/76lif64v\nSvqWpJeVf/IySd+sKn0CXQDywkCzNrZOUBlV4YYKAOqJ7hkYDOdMtr7WDu1LJX1b0t81Y/N2Se+W\n9OR2aP9O0pPKnyvBHl0AgKE776oJvf5TG/TR1+yphx7GpWbYGBQCwNwsvwzgiwhgcTh18tKMzf8z\ny2u3SHpiivSZ0YWR0HtwHYMHLBRPO7R13pUTkqQLr50wPpI89fpC+kQAmBtDgeH63ZpJfeZHm60P\nAwDmRaALI4FxCgDsiDgXACCVV558hz7xwy3WhwEA8yLQhZESua3DqPLWdIlOJ8GMLgDYUa9r5FI0\nXJNTxf95siSqQLPCMBHoApAXLpIAAPhmEOnyNPwgIAGg7gh0AUCVvH6dzCA4CW428nbJ9RO6Zf2U\n9WEAGICHftlBFgGMOAJdGAlsLI6B0WTgADcbeXvNxzbo5R+5w/owgJFD31gtD8E8pEezwjAR6MJI\n4cIKjAgCjUnQJ+bvlvVUMrBYSS9FDk5VnoIOYFQQ6AIADB+D4CQoZmBxvvm/W3X56knrwwBGSi9w\nyLUHQ0WDQgUIdGEksHIRWLyJyajJKZtRBOduxYwGh1u2MSqtmtU568V7vr5Jbzx1g/VhoGIWZ5GH\nM5cZXQDqbkVVHzw23v20pGdIWttpNY4sX3ufpL+UtFXSVZJe0Wk1bi9/d6ykV0malPT6Tqvxg/L1\noySdJGm5pE92Wo13V3XMADLA4GsHj/23dfrTw5brI6+5S/K0GQxXy6J4L7xmQq/7xAZ9+JV76uH3\nrWwY4d4Ek40qx7LQfE1fe6jioQpBlCmqQ9vCEFU5o+uzko6a8drZko7stBoPlvRbScdK0th493BJ\nL5B0RPmej46Nd5ePjXeXSzpZ0tMkHS7pheXfAhiSH1+8TWf9eqv1YWRv49aoM87dYpb+r67hrhnD\n8aurJ4r/XzNhfCR5I0gMLF3K08jTKUv/BKDuKgt0dVqNcyTdOuO1szqtRm9kfK6kQ8t/Hy3py51W\nY0un1bhG0pWSHln+d2Wn1bi602pslfTl8m/hFBfW4XvrFzfq+K9ssj6M4avZkrkbbp3S+7+12fow\nkmPpYrUs+sTeirpl1G2luNwhJ6tvndK2ifStOmUfadEfX7t2UtEgYfonAHVnuUfXKyWdWf77EEnX\n9/1uVfnaXK/Pamy8e8zYePe8sfHueZNTQz5aSJLJxVSqXcwCGBhtGFWw6JF7ga7l7PIJYAHu2Bz1\n3Pev13u+ke5Ltd5w1WSPrkSJ/vJ32/SiD92hMy/YliZB8dRFVItmhWEyGaaOjXffKmlC0heG+bmd\nVuOUTqvx8E6r8XAG4NWwvrDRAWKhLrhmQmezJNOcdZ+RPYMCniq/SGK2HjBa1m2c0ks/vF7X3Zx2\nKfuGzUU/dd5V6Zc753wNumZt0RlfYfD00IyLFUAmkoeDxsa7L1exSf2LO61Gr59cLekefX92aPna\nXK/DiPWFLecBC4brpm7UcXVYkkkwABWynNG1jC+UKsX1DsN2zmUTuvIPUzq1nXa/yF6fweVwuKJB\nXzxdh/RPGCKaE6qQ9HFJ5RMU3yTpcZ1WY2Pfr74l6Ytj490PSDpY0v0k/VJFf3q/sfHuYSoCXC+Q\n9KKUxwxgtFgtr8XsmPVTLZs9uopEl1G5ABag10+l7DKmH7qY8ZBgyjBvGRcrgExU9h3A2Hj3S5J+\nLukBY+PdVWPj3VdJ+oikvSSdPTbevXBsvPtxSeq0GpdIOk3SpZK+L+nvOq3GZLlx/d9L+oGkyySd\nVv4tjFgNGLifAjCfX/5um8bGu7ppnZ9NGi365N4emGxGXy1uJJGLO4Pj6dP28NTFlGNk9uhClfiy\nGsNU2YyuTqvxwlle/tRO/v5ESSfO8vr3JH1viIeGUWQwOLpjc9T3L9iqv370rgpE2kZOpMrcOeMX\nxZ5sl14/qccd4WNdneVGy+yFCWAgBmOpnG+co+GS0HxLFUAuGKZipKS8sL7/m5v0gW9v1oXXpN/k\nEwAWxGTpYvo0XaKckYnpvaRSzjxKl9S01DG1XnIm38VmHECED1u20YZzR6ALI8HiGn77xqID3DJB\nRwiMEk/jb0dZBTCipiwCXYZL7FKlaTGja7pcE6YJP1K1q4uum9Djj1unc3+7LVGKsECgCwPxdAPJ\nyjdg8Rx1FaY89cmWPtferMtWTVgfBrAkVuMai83op9NOn2QyUXZrF7n2YJRdfF2xWucXv+O6njMC\nXRgtGX8zhyGpaX2Fmh4XsFieti78z7O26FUf3ZA0TbqM6uS8b1MdTVnOPMq5qqfLNV3J9lLKulz7\nrL51SltZ2ZGdFWUEZJLdabJGoAujxWDaO4DBWZw+0wNwg7SteMorgNFkMaPLQ0Cml7Xcn2ZpZeOW\nqOe+f71aX9tkfSjZS32e9h6mM+nnId0uEegaYad3tujEr21MmqaHC9tMHvOMISJgmozL4DQdVLZy\nvkG3RtmmZbl00UKq5jXdji2+BHZwDvVmcrG8LaFE7Wr58qIhT/B0nawR6BphH/zOZn33fDbRq4qT\n8RhQCQ9Dhxijfnb5Nk0ZDpQ8lLM1y/pFXrwumTR9OmDGLJqTozjXdHvlEpAfZnT5QKALA/E4RvOY\nZ2BYcr6v+f4F2/TGUzfq67/canYM9E/Vs7rJoWpRldT9Rs7XgX5W/bFF+Xq49gQXG735VE7oItCV\nOQJdwFy8jMxyw3ikViyqI9WYdO26YoR0U9dZo3OWXb7Nz49VlXK/nJ5FmadK02RJaC/2kzBJK8uc\nzuh6zvvXq5V4a5weZ0WNihHoAgBgEbhp9WHK2Te+P754m665kUdRAaOC72Wr4eGBBrO54dYpfcfJ\n1jgsp87bCusDABbC4hpj0fdNTUVNTEm7rqDnXapIEdZCztVQhw2WTcbfOVfqLMy+zTe6u3rrF4tv\n8jutRpL0LPatsrpxdXa/7I5ZV5FtYsYczV7zylsQ0xtmdAHzSNkJvuO0TWq+fV26BAEsmbtvBJ0N\nDD0tW5n0lFm4kHOLNr325FywPWUeCYakQ1ljmAh0YSCeNtoMBt/knP0bH1OFgRzUYUBWh2PInafN\n6HPezwgOg/JGUjfppOeQwzZEF5Uv+sS8EejCSPCydBHA6Oj1S/QVebNYWmfFUVZNWJev9/QxBA7r\nkHZbvdRlTJX6QKALA/HYMXCBGzHUFxLjG0FUwcu1x0k2a2E6OO+oz0p5Hnk5ZyUf520vj6zoBkYT\ngS5gLo4GgqhO8HRHYSx1UXu6qfGMegZQZ3RR1eIakE6qomZk7gOBLgzEurNP2TFNP1Y4YZo9npbK\nVIfLGKpVh6cuWnKa7WRM9stKnyT7giE/idqX12tPKvQT+aJqfSDQBcwhGEa6uLgCo4N7jbzRH2NY\naEvIhae27CmvQE4IdAHzsLjAsR8AcpHzjMg6nKaeBuC/vnZCY+Ndrb51yvpQsuWlPTnJJrygQVeC\nPboMZFzWMUaNjXf1xZ9ssT4UNwh0YSAZ9z87sJylwUUVo256WZ/tYSTB8pE0vnv+VknS+VdNJE3X\nqjvmMgCMplQBY4trD/0ScpLyFOrd2538/c0JU/WNQBcwDy97luSC/c1qJuMgEE0tLQKKGHVeuwzL\nfKd96qJNTk3GqQZpIl8e2tP0jjgeMlsTBLowGEcnp+VNFTO6gMGFxFG1OmxG77GrcJNnJxllM/qE\nvOY7UxaXHlffN7jtKFAFWlN6BLowGgx7B/boGk3R1WisfqKjSzozjTLnpymjYl7vm73k20M2PeQR\ndmhfGCYCXUANeRkUehK81en0Hl35R4E4X9PyUt5els07qU4Y8bCsj1mR1XCQRbc4Z3wg0IWBcI4C\nqLvU/ZTp0kVGTpWjhJGb1H0W51BF8v8eqRaYtQ2MJgJdGCkpLza9tCxuJLl3XYK6lR0DpGTuPGdt\njwMYVZxNQWxiAAAgAElEQVQ6wOJx7ckL9ZkeZY5hItCFgXjsgAJf5QAD63UVHk4fb/2iVXat2pJV\n/XppVywh8YO6roanPTGBYfIwRvWMQBcAoDJZjyGYQWaDAq8MRVstt+XrLN+p6tnDHphwwkEf4bb/\nN0SgCwPhHE2Dcgbqj1uMtLzd1HEdqI7XsvWUb0959ZXZdAhMAKONQBcAYOgYIKIqyZ9oljg95Mtr\nW7LMd85lbvsgFLu0U/P1FYstT+0K1SPQBcyBzhZYOvY/qJanfspdW7LYzyh9kq7aMNLx0F1w7lSL\n4sUw0Z7SI9CFwRhdVd1dzN1leIgoulrgG/z8udkcngaVHS6xaZk8vTp5ir5QvgDqjkAXACTBsDA3\noQab0ZsGFBMn7mGGhjkns8isEGAzkLDMqV9gaVKdQsxe9oFAFwbCOYpREbkrRsVoYja8TOjieotc\nWLRlV/1zwsy6uln3lFcgQwS6MFK8DFy4tmbES6OdwWIw7G4PJ2PJy5v6rZyXa4/34KWHU8l2tmvi\n1C1mYrqKeAEYRQS6MBDr6xqXVWC0mASfHHUU1n2yCSd59lK3XvLpmtPl3Tny9IUSbSeduMM/gKUj\n0AUAwBIwLkvD6v6KQEyGvE/pcoDvWKrhsT/0FNwDckKgCyPFy7Um94FEpVPeMy+7UWNyziZKtA6b\n0Xvkpbi9bJbrpT4987KMMPkDOrwMio1wbccw0Z7SI9CFgXCSAkB9eOqTrW7qHBUxMuepv7CU7Mlx\n1Ge2XnnyHXrL5zdYHwYw0lZYHwBQd3xjNnyeB2cxRgUHjcpzHefOum6t08+ZSdE6mkXmtekyUxAY\nzOWrJ3X5auujSC/ZeUuf5AIzujAQBodpcCOHUddrwyljepw3efO2RxftGVg6TqNqeOifHGQRyBqB\nLgBIyMPgEKgSp1CFDDooL3uRWaY7U+pJxRbZtpw3nbye858kDgyXwTnT6xf+7qjd0yfuFIEuDMZo\nkOZqwKL8b+Ryz99sgsdMA8PE5v8AFshTANXloCoFyjW5ZOeQYd062L2kNgh0YSRwrcFCpXzC0mLU\n++iGx0s+PbIapDE2xKhz2y+aPnbRMO2MUazIQdLtNdIlhRKBLmAeRN6Hr+axqOFy3n44f6plMuPU\n0/lryMtsYi/5RNrrgatLj6vMIkeMK1AFAl0YCP1QIhT0kkUiLG5R83kKRksXGYADw5HyXHI1icxJ\nuabmKa9Ajgh0YaQQu8Co46a5ehRx3rxcB5hdVWWiznejT8xV0MkJp00ZFcu6WWWduXoi0IWBeLqw\necorMHScP0l4Kmaz2IRNssDQWbfl3JcuMm7MC/WJKnj5sq4OCHQBNcS1dQkovFroVYPF9ZwxBLA4\nJjd2ju4m/eR0e25mCgLAHOiT0iPQhYFwkmIYHN3XAJWyPJe8BBStnuRa9yfIjjJK1g+b4G3i9Aw6\nYw/dk4Ms1k+iQresWy9jpzog0AXMgw4Jw+RhcAgA2JHX/t9rvpOhfCvFUjMMA/1geiusDwDAjnLv\nDDPPHvowQARGh4fJL0BVaMvA4ng6dzyNi9uh/U+SXq2iii+S9ApJH5f0OEnd8s9e3ozNC6tIn0AX\nBsODigAAwAhjTJGWt6cuJk/T0Y1zSvQT+ePUqU47tA+R9HpJhzdjc1M7tE+T9ILy129sxuZXqz4G\nli5mgH08qkGpVsdzk3WcdQADcLG3kHxdDzzldTaeZjIk5bxdIR85N+Wc87YTKyStbIf2Ckl7SLoh\nZeIEujAQpydpcpTzEtSs8AIj++xRxXnzHpzIkdc6Ncu3k/L20K485BHAwjTUWNEO7fP6/jum97tm\nbK6W9H5J10laI6nbjM2zyl+f2A7t37RD+4Pt0N6tquNj6SIAJMQgMT+WdeqpPTnKqhmTSWSOKtZR\nVuvDQ6Hz1MVK8V0WhiLDk6ar7kQzNh8+2+/aob2vpKMlHSbpdkmnt0P7/0o6VtIfJO0q6RRJb5Z0\nQhXHR6ArAzGmm1GQ4Tk6L2ZrjKZIvQEYAibBAEvjrS17HCvnjOpMJ9V2PJbnqKP7yidJuqYZmzdJ\nUju0z5A01ozNz5e/39IO7c9I+teqDoCli8A8vOyTgjxZ7eHnaaDvaNAiie4Jw8UlNj1vfRawGJ7G\nMaiew+Z0naRHt0N7j3ZoB0lPlHRZO7QPkqTytWdJuriqAyDQlQGHJw5GHIMHVMnTTRynUr4s+kn6\n5orVpHxT17Pp8m67pNOx6CvSJ2nG0ZDCTuJOwnKc6KU9NWPzF5K+KulXki5SEXc6RdIX2qF9Ufna\n/pLeWdUxsHQRA/F0YbNEOWNYrG4wPAWbkDeCPxmiTk3kflmgr8gL1ZkvztU0mrF5nKTjZrz8hFTp\nM6MLQHKVXl9qfvHi4gosjZcgqsmMrvRJ1r7PHqa6ZDX1OVSXfKeSPL9sRo9M5NysOGfSI9CVgZQn\njseT1MtNFaoVjM4dT6esx/7JY55To4yRDYeN2UWWPeTRgNUep8gb95XpEOgCaohra76oWmSDwVp+\nnMwiM3uSptcLgNd8IwsEJvKVsm7d9v+GKtuja2y8+2lJz5C0ttNqHFm+9lxJx0t6kKRHdlqN88rX\n7y3pMklXlG8/t9NqvLb83cMkfVbSSknfk/SGTqtBU3GGb1Xy4qo6jQdIrso6Mco2McobWBru2Ctl\n1kVRrchEqnGV5XCC0zWdKjej/6ykj0g6te+1iyU9W9J/zvL3V3VajYfO8vrHJL1G0i9UBLqOknTm\nUI8UI4PIO4C6sRy00E1h1HGtTchhYZtk2V8xA5gH3UJ6lS1d7LQa50i6dcZrl3VajSvmeMsOxsa7\nB0nau9NqnFvO4jpV0rOGe6QYJV7GaLlns8r81X32X80Pb2i85FPK/3ydk9uMp+FmM3oDVv2Tl/Kd\nyWu+AdST6awqpnQlU+WMrkEdNjbevUDSOklv67QaP5F0iKRVfX+zqnxtVmPj3WMkHSNJk1MVHmnN\neNiMnkESgIVyNYagc6ycp6CtBYrXj9xXTnrqKzzk1UMeveIJwz7UJdC1RtI9O63GLeWeXN8YG+8e\nMeiHdFqNUySdIkl7nkRzypHJICnzgVmuYk3rzUvHZHlDk7qMa9rUquc242mYrLhy0kGZZbMm5RsS\nn7yWM61ZuQigThg6pVOLQFen1dgiaUv57/PHxrtXSbq/pNWSDu3700PL12CEJxWlkX1+E+Uv92+P\nF8JsFmbubRhmUp/WNGUA8Ie+Px3KGlWobI+uQYyNdw8YG+8uL/99H0n3k3R1p9VYI2nd2Hj30WPj\n3SDppZK+aXiotUTnAIwQTtjKeYpv0pwwTCznqJajrG7HNN8pt/dIl5R5wl7bMrBYnDPpVTaja2y8\n+yVJTUn7j413V0k6TsXm9P8h6QBJ3x0b717YaTWeKumxkk4YG+9ukzQl6bWdVqO3kf3rVDzBcaWK\npy3yxEVDVtPPmXqeF8o2HcoaWBpmRWaIsgWA2vFw3WO1STqVBbo6rcYL5/jV12f5269J+tocn3Oe\npCOHeGgActZ3keRaYo86ALAzDu5r3PNw89oveX650FbCW7tFtWhP6dVi6SKWhhOnGowbquO5zabO\nunVZO67qJExm2VKp2bLuL1Jhv1E/KPJq0JaBxeH+Mh0CXRgN3MthYDW5lNTkMDB89BFpUd554oY5\nHYq6YjTmrFCd6aUqcr4j9IFAF1BDXFzz5a1uU8b5IsMIZMRbX+FBXaqUPWKqUZf6xXBxvmCoaFDJ\nEOjCQMw25bVJFhWhPv3Iua7rMFTJuXzrgoBTfqjTtCzLm5kb1fCQxx76i+pRxqgCgS6MlFCLW8vq\n0d/ny9seXTlzW7Q+umFzJk8bJihQKfpjAKiPpJOr6P+TI9CVgZQDJzZwxVBUWaH9T13khtwc526G\nnNWps+y6QJ2mRXlXLOV9gMPKZCyZTur2ZdGeaU/pEOgCAGARajFW4aYDI87jjbNXFueuSfPy0KYd\n5JG+CcNEc0qPQBcwH4ulHJlfXVPkrrYlmLhua1sOFQqJ7qY8lq1HZntTsowQmch8SGOP4D+wKBbB\nd07XdAh0ZSDl+IHN6AEMgnM3XwzWMKq8Bl685jsVyjcvVGfGDE5W+of0CHQBc6FDwhCF8grHZvQY\nJk/V660t22xG76yQE6N4DTjYx9aCp7zypQ6Gie0X0iHQlYGkm9Gb7UZvlK4YmFaBMkUVrNoVg5a8\n0V1Vi+sBckOTxqiy+rIjeaoGAzf6hfQIdAHIS92uJDOupcmfKJM2uR3Ttz6ABCzz6KF83aJuUREP\nsXn6RiwVbShjhpXrof+tCwJdGAlca/KS6vrCTBsAS8YFCENSl6bkaQl9Xco8NyxzzpN1tVqnj7wQ\n6MqApz7By6Op6eiHgCBXwWFbSj0A9xZQddikUCGusX6k7CpN+mXaFYA5cN1Jj0AXRgKdQ148Vydt\nGcPksTmlvn/1tDUl/VO16jILxsM5xJLyamScNchf/QaLb8WdfTlqiUBXDjxsRg9gUThlMWyM0TBM\ndQn+eOCxpGlf1aBUUQXaFYaJQBcwD4sxEh394vUPaut4Q+6lbi3z6aWMkTeLG3Qv546XfNaFxTjK\ny1YXqdVxXFUVjzFSj3lOzdM5ZI1AFwbiaQkHKkSFJmM9aLFOv0q1yFsdjiFzzAgBRg8b4FfMRSYL\n3vbhNOGgPTGUSI9AVwY4b6pBuY426s8W48J8cW6l4W1fo5TcBi+Nss0MX4wi2k56qbpmy7olcJoO\ngS4MxGxs6Oxqk/sYPFX2ankxybxuZ+JmPV+pi9nr5aeW/dgQeTpfPeV1NiFhYzZZuuigfh1kERYy\nv87BBoEuAKhQyoH9bBiU5o36zV/Km2cPN+qemVWvxV6ntOVKeShej22ICQ3VcZDF2iHQlQEPHbHp\ntHeLDYEd1KlXVG31KONEvBQ0A38MSW2q1NHsCZMHCtWmojEMjk4Xdyy+i6Y9pUOgC0BylQ4CGWBu\nz3jEzYAfQ+dslJj90kXrA3DEqj/mOoBR5qn5Wuc1+ZYISWdMW5euPwS6MsBpA4wOrnMYJtpTvqja\n/HC+5s1T9Xpoyw6yCAuZf3lVJwS6MBCP3wZyoRu+JGXKhUSS01VXnLRJeClmL/m0wtKy/Lkp7sQZ\njX5K1pSn4aS3vjH3GdPeEegCAACoGQJAGDaqNxFOpDxQjek5KHNia+kQ6MqBgwuqRQ4dFKsdx2Wb\n8/4D/Swv5J6al+lsVycF7SWfVkwCeumTLNJ12pa85rtqwfBKS5UCqDsCXRiIxwsb36oDg6MJY+ho\nVJWjiPPmcWzhMc/AqPHwJTB9UXoEujAS6BywYDVtK9Pfu6bew8O4PKzTzx3FWz2X+9whayydqVbO\n566na7qjrE7zVL+STV/IvmDpEOjKQMo+yVsHiGqkakZcTHxK1U957w695x+ji7GMH1R1RRIWbOSE\ndSN1VSe9h06YFgoEuoB5mOwPZpBmbmJdvrOecRjULYAFYWlFdijfdCy+6PJQvZ6+QPQYYPOX4/Qc\nnULmCHRlIGU/bNYBOrzY5IzqTMe6qHOecVqLwQrBkOoZ57cW7axC7JWSP4uAAe2qGh7yuIPcO2HH\nUlaty3PHGIEuAEBWUo0lvI9ZPD7RMyXv7QvDZ32jZTLLKuOAVzTsJXL+Ems6XZtkTVn3ES7K3Msg\npgYIdGEkmHZ8GQ+SrFSavZqXXfK6tR601Lw+gPnQhKvlqXw95bWf13wDQA/j4fQIdGUg6Ynj8NtA\nACMmUT9Vh+6IcVO+cp6JAhtUb15CLa5C1aPdpmP2lGFHlezjrK0HAl0YCSYD/vRJYphCPS8mziZ0\nZY2yTYsBeJ48la+nvPbzku/0T4wzXLrooU495BHIGIEuDMRjn+8xz1VzMUCCJNuBOADMxus1yGu+\nU6OYh8u63dbxS9PKsN0FMkKgKwP0CcDoSP6Nr8MOwlOWLevXS9sy2wiZmcyoSOptIGhX1fCydNEK\n7TZflnXLNjzpEOjCQCweES3Zdkjsk4KhoE6zxaAFAOZn0VWmHE+l35qApYvAkiTslDhn0iPQlQNO\nHGCaVTC2rsxLw/wAque1yTnNdjIW5eulLTvJZn14K3Bv+c2Ul/6wn8MsJ8d3o+kQ6MJooOfNiqvB\nA1e05Dy1L0dZneZt2VXuMwZdna+O8goMC+cNckAzTo9AFwbi8SQ1+VbdIM3cUIZIJfdABIywRxeG\nzGy/OZtk06ft6LHK9BV58thHpBYYNCZDoCsDHjoHD3nE8NXxWpJ8EGH9BB0naXrk5lt2L/k04mmJ\npvemVMdrMurP6rzxfr5aYPsRDBOBLgzG0yN+nfW1KS8uzooWqA4nE4Ca6w0vvNzDpsqmk+I05ylA\na9WmPBSxl/6vTgh0ZcDDiWOaR566iBHmqSl5yivScTWbgOtd1qyL2iJgQPuqiIdy9ZDHmkhe1NSt\nCwS6MBBX/YKHrxeMVDp7rOaNtOaHN3QmNxmOvk6vwSEkww0rRh1tOG9UbzU4bxKisJERAl3AXJz1\n9Vzb8kS9Ytiit87RiMW5S83mjb3JqpW6fC2v717qFGl5aFeelsJaI9CVAQ+dgrOViy7qtGqxZheS\n3uG42WiTAXj23DRlJ/m0wmb06dXs8lgpT+0Lw+WxGr3kmX7BBwJdGAgnKTBarE9ZD32G5bdzFoHT\n4Oo22Y7NQNzBCeuY2WxMmhWAnbC69FiMZhhBpUOgCyOBsXf1ciziWlxManEQBhzl22v/ZLZJe+rl\nQWmT88fTEk0aE4bIdOliwrTNZmA6PF+t85wqfbYG8IFAVw5SXmzSJVUbWW+mbcT6QuqJx7L2mGcA\nwCy4ocUSOfrezoynfas85dUagS4AeWGEicRMly6apGl7krl5DLmTG3S67IRYuYgl8jQTxuOXZl5m\nzzmsWpcIdGUg6clq3DOkvKH01gkmnYaeLqna8ThwSoWyTYvyxqjyvhk9quGpfj3lFRgGxkzpEejC\nSPHyTRJ9IXLh5ZxF9axnkqVmkluL85XRfzIeZ8YkTdtBW7aYweygWGvDuqit00+CpYvJEOjCSOAi\nh1zQlDFMLvtGljhgRNUmqMeNVqWy3lC7Jk04BUdZdYcvYX0g0JUBT0vOTPbC4Rvuocs8e7ViVtZe\nvsF3zNsMq9QsrgNeatRLPmfytGST60DFPJWvp93DPdWrEUetyRyBLowE+l0sWH9jqeHVxNvg21l2\nkUDqNpX7Fw/WPJWup7zWBWU++szqkMaTXs5lnnPeamqF9QFgtDDez1fSmYEe25FRps2KuoZBxmHz\n2Iwlp+cv8kIbzp7JXlKZp4f8eWtTFv2EpwmC7dD+J0mvVtG0LpL0CkkHSfqypP0knS/pJc3Y3FpF\n+szoyoCHTsl0I1MnaeYmOrqQ1JJlI07cYbgN/DjJt6fVvyZt2Uk7qgNPS9nd9suJeHriO4DBtUP7\nEEmvl/TwZmweKWm5pBdIeo+kDzZj876SbpP0qqqOgUAXBsLAARhMmPHVTepzyHrZVc59htdYqvW3\nkTm3KWSOtptczv1FznmrA4/F66VNsRl9MiskrWyH9gpJe0haI+kJkr5a/v5zkp5VZeIYcV46JVSL\nZgQMpg7nDE/dypeXgbiXND2zKG+TpYs0rEpQrH54qOucviRtqLGiHdrn9b10SjM2T5GkZmyubof2\n+yVdJ2mTpLNULFW8vRmbE+Xfr5J0SFXHR6ALmAdLOYDRkn6z8sQJ1oSXVVDW9Ws9gw7D47SrmJay\nLZtueeGgoq1ni6fgIIs78JJlm60B8ivdrroTzdh8+Gy/a4f2vpKOlnSYpNslnS7pqISHV12ga2y8\n+2lJz5C0ttNqHFm+9lxJx0t6kKRHdlqN8/r+/lgVazQnJb2+02r8oHz9KEknqVjX+clOq/Huqo4Z\n88vvFIWFKvv6/gsJ94eoUh3aF30yhspJg8rxhmMhrLNtnT5Gk3W7qcO1Hvlw9OXVkyRd04zNmySp\nHdpnSPpzSfu0Q3tFOavrUEmrqzqAKvfo+qx2jNpdLOnZks7pf3FsvHu4is3Jjijf89Gx8e7ysfHu\nckknS3qapMMlvbD8WzjD8pzqecuvlfR7dKVNbzpdm2SLtBMlzimTFn1UnqjX9FLfZ1nUsYenLlok\n7Ol09ZTXaU6C4V62BjB2naRHt0N7j3ZoB0lPlHSppB9Lek75Ny+T9M2qDqCyQFen1ThH0q0zXrus\n02pcMcufHy3py51WY0un1bhG0pWSHln+d2Wn1bi602psVfEoyqOrOmYsgPVZ6mTgYl3MVUuTPz9f\nmdQZN7EYNi9tyks+PfFepzb7Zjkv9IqkLFVqEFXhTqE6zdj8hYpN538l6SIVcadTJL1Z0j+3Q/tK\nSftJ+lRVx1CXPboOkXRu38/9G5NdP+P1R831IWPj3WMkHSNJk1NDPkKY4iIHjBa+LUvD0z40VtP9\nPd0ne/lix1GVbsfLvnrWUuXXU9+ENMz6CNpylpqxeZyk42a8fLWKyUyVq0ugayg6rcYpKiKF2vMk\nP9fVlJ2Dm0JFpTxf0JJvpJ04vTrwmGcPPPcbXsQYFTLewIQmnI6n/iL7rHrcgwH5oT0lV5dA12pJ\n9+j7uX9jsrleh0dO9uryNEDzIt9bt53z0JQ5X/PmaRaMm6cMOz1nPfZVSbOceg/OtMltn7bDtuSB\ndb16aFYZf5dTO3UJdH1L0hfHxrsfkHSwpPtJ+qWKe8P7jY13D1MR4HqBpBeZHWVNeegUrDtejJCa\ntxU/m9FbrqmzS9oT+mVgQE7PGTajrzhdp+2qahRrvthew4fKAl1j490vSWpK2n9svLtKxfrMWyX9\nh6QDJH13bLx7YafVeGqn1bhkbLx7moqd+Cck/V2n1ZgsP+fvJf1A0nJJn+60GpdUdcyYn/nFNOHA\nxTqrqZnXbQVq8a1JHY4ByEiOfdVsvMwm7k8yxpr02xh5nvYvzJ11cXrqk6zL2gNHzclcZYGuTqvx\nwjl+9fU5/v5ESSfO8vr3JH1viIeGEWQ7OyR92lxoli5yJZFkP+C2Tr9KOecNd7KuZ7qy4ePUTczw\nJLI+f6uUc97gVMZtmvM1vWXWB4ClS/noZM7RfCV9VDQNKXum36Znnt52aXMuZY8qzkdd6rIux1El\nZuHkw2wLBocXWC9Ztsymp77JGoEujAZHN812iQIYBIMVG966x5TNzHoDfG91m5qnh9d5Wfqbmoc8\nIj0PzcpDHuuGQBcGw1mKIai0GfV9eB3jEN4GiVk/8cpZXfZ4zbcVinv47GaI2KRbFxbX5JyL3Mts\nYk8BWu9Slbn3vtgLAl0YCfRH1cux088wSwPLsV7n4+XJlpKfGx3LdL3ks0jUIEmHfZQVijpPnEPV\nquOXprkxK2MqN2sEujBSTL4N5BG0GCLqFsAgPI3DU11vrfrh2gQknASLU0ueTSdfsrg/XxPyMnvO\n5CFnDtuTNQJdGUg6fThdUrVMH8ORqs3W6gbRWeOdrmPGEsCiOJnQxfmKajFLcajYmxJYGs6hdAh0\nYSTkPGioC4o4T9Rr3rwum0zJSz6RPy+zNVAdL0uqvbIu6pzv9zLOWm0R6MJArB+162Uj05w7eslZ\nZz+j0eZetz2GE7qSMZn6Dje89BWeppHVpUrrchxYGo97NAJDYdh+mdCVDoGuDHi41nBBxYLRVrbj\n8dzxlGdHMQIzrtqTo7x65LF6k+4l5enBFciS1YQGD23YQx7rhkAXBuLpHHXXIXnLrxGKOSNlZbrr\nK0rc1GFUmTUhr23XWb6dZbdybEbvR6oit6zawCZdyaywPgAsHR1xxdjIdPgS5C9yHTEVnQeBkA+z\nmyyHadJfVIx+OSse6zHGmD5QwHiyclaxH6q23tqhvUzSQyQdLGmTpIubsbl2oe8n0AU4Zr3nWuXq\n+K1J5kWOxBy2J4dZRia8tl32kqpW7nk0z591+g54eFCGeTseIe3Q/iNJb5b0JEm/k3STpN0l3b8d\n2hsl/aekzzVjc2pnn0OgCwPhJM1X0s4+YVrecc5Wx8OG+zBkPb0qVZJ9aSZbtsJJa6KO3z2NMh6I\nUi1K10CiQre8BtANLsg7JX1M0t80Y3O72mqH9oGSXiTpJZI+t7MPIdCVAQ8DNss8OrnXACphMRD3\n0Cdacrc3l3F7IjiAYbEKznvrkz3kN2UezYszcR9sudrCQ9vtl7JqnRXtkjRj84U7+d1aSR9ayOcQ\n6AIcs7thrS7hui/HTH6DkTg9T+rQ1OpwDKl5ybObfFofQEJe6rROPCxN8tSsYkwX/Od8zZdp3fLl\n1YK1Q3u5pL+QdG/1xa2asfmBhbyfQBdGAtea6nFBr5a365pFe+LJTKiCp/q1zmqqsvZUp/285jtb\nXurTSz5L3laxuEHhLsa3JW2WdJGkne7HNRsCXRiI9SDJYgmHSZ5TDfbTJIM+qWecWZ+zJnv+pE/S\nJbvZC9QwRpPXlust3x76qPxzCAse2pW3L76X6NBmbD54sW9eNswjAapifrOOoXJVnVzRslWHdmwS\nh69DxhPytDWYydJvH0nWwnQAxlMBeMhr5nm0zl7qYRxPKU0n5QQKZ0U7LGe2Q/spi30zM7oy4K1T\nSi3jCV0mT7tKqY4xphzLeTaeBmpe6hQAFsPLOJU9OKvnMc+ojkXfxANmBnKupK+3Q3uZpG0qbu1i\nMzb3XsibCXRhIFxgMBQ0pGSsi9o6fQyf1ZPbdjiAzDmZXOWlOguuMruj3O/vPG1G7yF46SGPM1nn\nmX0aMcMHJP2ZpIuasTlwrRHowkihY6pQjMpiGEobqYXcz9Ubv3yjjnzp5Wpti9K7pHbi9J//oH30\nlWcdln051wFlnCGvdWq8ctFNIJWb9aHyks8eb/m1lHTpIvW6GNdLungxQS6JQFcWPDw62ZLJt+qZ\nl3Pm2ds51jZk4fb/vl3LttkV7gOuXmeWtqdZC6he/75gXPsA1AXna74s6zaDKQUpXS2p3Q7tMyVt\n6b3YjM0PLOTNBLowEnIf/GL4IovgayHXc7d3c37G0+6hw99wiF771N2TpDvRndBP9/lpkrTmQ8Ar\nP6SwPbYAACAASURBVLmerzM5yeYOrPPNVbkauS9z7k+LPZXyZt1HVSnnvFXomvK/Xcv/BkKgCyOF\nTmK4rDaj93IzNRsvE7qy3zNkqkzTagTs+BzywuQJiAZ85LJQlzpN/sAOw2zXpMgrkXHWaiHntjMX\nj3lOjsDpgjVj8x2S1A7tvVVsQr9+kPcT6MqAh07JQRa34y2/yFe2Aa/eXjchcR5rMECy7p/S36Rb\n59gPSho5SNGON129SQd/7Fo9+7ptutcvl+vyby1PkKp0+O0rdekD9kmSVo+3Lthbfi2YlDH1OrB2\naD9c0mck7VX+3JX0ymZsnr+Q9xPoAhzLcrZP34fXarp5LzDi5SY98wt6nCoyaJXNXtO2DMJkXsXI\nmNcbSY/5zjXLq09erf2/c6P2L3/+Q6J0j95zRRHoyrVgnbOuVg99VJ1uTUbApyW9rhmbP5Gkdmg/\nRkXg68ELeTOBLgzEvANKmL63b/GdZRcZS9KUe4mkHrHUYYTkrK/I8guBudLk4SuVqktWY+IjqUu+\nq5ayLU9tKtbPX3DEvtqnuY+O+pOBt68ZyOSmSV35D1dql4mpStOpEy/tFqixyV6QS5KasfnTdmhP\nLPTNBLowEtzt75D71TX3/PUJxtPKrIs615vY6Rld7NGVXK5tCunq1msT8prv1FK049416PeH3kUT\nTz5QBx29stL0JtZP6Mp/uFLBT5zLjOV5arYIwEHn5CCLVfifdmj/p6QvqSjC56t4CuOfSlIzNn+1\nszcT6MJAOEnz4uHCUjdeijz7thXv/F/SvM6Iq5nO+sm9jo1lfw455LVOTfOda5n3Ak5BSfIYlhUX\nn1BWZso6NWs/ubYdTLcpnuJZew8p/3/cjNf/RMUZ+oSdvZlAVwY8DJym76sc5NVK0kFLuqTgUJK2\nPP3UxQRpzYJxUjqerjuOsuqSp7acvbIup1JdDMq97pcZtyEPgQnX52nGmfe2Jc4wNGPz8Ut5P4Eu\nYB6sXMRQpa5cGlMlpgcsiUfA1kthJZpUKl7KuX/snyzPXgp3DtxvVSNlsfaWLqZKd+aMrpSsmyvn\nC4apBsO4kdEO7f1UzOZ6jIqu4KeSTmjG5i0Lef+yCo8NiSS9sDJ9GHVHW6mF7Kuhb0ZX6o2di4TT\nLx/Z4RBSp+f0AaIpB8Xc0KFSBjd42T7Uobf0KlEHEZb3Al3bJZ81j/2hlzxb7MDgpGiH7cuSbpL0\n15KeU/77Kwt9MzO6MFJcBPUSMvkmXenKli9NfF5YkwSerAb7NWjU1n2jdfrJOMlnnPMHZIf6HZo7\nH4iSKMFyasSy5BtT2mMGTjoeWhbNaSAHNWPz3/t+fmc7tJ+/0DcT6MJAPE7osnncuoeuvlpWeyfN\nx0vNWm70mYL1Uxdr2rzzlGkb9sxsLOO0LXnJd9J8Jn4gSghheuP7kCjNnv4xMTNwquUlzzb3dunT\nzMBZ7dB+gaTTyp+fI+kHC30zga4McOJUg29wquOxzQaj4YPHsk5S1L00Ej3xaloNnro4nbbHtpUQ\nxYthMz9nLZYuWue5KtPL5xMW6jJJk1KYmvcvsQTZtllggdqhvV7FMChI+kdJ/1X+armkOyT960I+\nh0AXBsOSlSRSZZMlI+l5acO5683oSvbEqx0OwCjdGnCc9SxZLKG3mjXtte16zXeV7nwgSro0w/Kg\nOBlNNqS34CSb27HOc/L0LfLLRIp5NWNzr2F8DpvRYyRYd7wYLlfVaXxBsy7rpMsb0iU1/W16cgyQ\nkvO0zI1rbd5yX1LeL/ssGjwQ5c4nLyZJrjZSX3adFa8Jyrje2qF973l+H9qhfeh8n8OMrgzkuIl4\nHXjIq9Vm9FWq+/5mNT+8LCQp4r4nXpl+IegwGGKdfmrENvPhre3WQbZFbvFAlOkN6dOW6nZj1Wwr\ntB487sWcGtf0BXlfO7SXSfqmpPNVPG1xd0n3lfR4SU+UdJykVTv7EAJdWLQYY7E5ZYq0DLtAvlWv\nQKr8cTUxGz1Ei0F4QtOb0SdON1WfuxCW/XJKVv2xRbLWNZqqrK3z6Y3FOWTZU6bIb/8DUZI9yXq5\nzxldqWV/D1AHBmNU6nXhmrH53HZoHy7pxZJeKekgSRslXSbpe5JObMbm5vk+h0BXDjhxsEg0HeQo\nyWBiekZXgrR2kr5N0j57jhrFGLPC4D+dOOP/Ocs+j73l8yn7pXJGV4gx6ez57OuyTqxnbNsmnwRj\niYVpxualkt66lM9gjy4MpL8DsniMMqqT7V5KNeM57znpfZuukLgvrNFTF70wK2NmE1fGSz7rwtus\n/BR6gaaUX7ZMz+hy8tTFum+FgcXzOGPaI2Z0YaSYLCNMnyQwNHb7LeS+drH8n9FXczY7gxWm++HE\nh8A9R/6o4ooZF3Cq3nLLmi064oJbtHFL1C677qo/XJ7mdufAm6W1+69Mktb0ZvQJp3T1NqNflrgh\nmff9iS/zltm1LurUvC2r9oZAVwZYX4xFM96/ySXPeU8kSfuavslIbOaMLoftyWzPLIdlnYKnYnXb\nhhLn+/KXXa6/OPu24ofvSJcnSveY3ZfrxH/848QPREmRWGl58b8w5eu89ZVZY5Q1hminga6x8e6r\nJN2102q8r/x5taS9VAy139hpNT5e/SGirnJfueitr80mv9lkZDjc3lhVrH/ZiEkRO6xXT0sIrZJ1\n2KxcmZ6MmXlFb127VZJ0+R/trfvcf1fdY//llad54+dv1B6bJ7VsKk3h3rkZfZLkJN05o8vLZvTe\nrjmSn+WaPGhsNLRDO6jYkP4+zdg8oR3a95R092Zs/nIh759vRtdrJR3V9/PaTqtxyNh4d3dJP5BE\noMuIl45oJot9HnLuDHmMcEKZr+SbyeSpiykTm94IOPEk9BrNeffSlnvYQLYa213vYlStGvmQeTtn\nzJQFffbjDtJLjrmrHvSo3SpPcu1paxW3xHT7V/Utn082Tu3bjD4l81uefLuk2vD0dGPa00A+qmLE\n/QRJJ0haL+lrkh6xkDfPF+gKnVbjlr6fT5ekTquxeWy8m2gROubjIejlIIsYsrxvlxaOc6cixk9d\n7CXrqXpNgqcG6U2ny5SuytAvpuXhS7WwPCgqalmixhUTzRzr19uMft/uVsVVm7Vpr8kk6U6suzOv\nSR+c5LCfsM5yqvS9Pj16BD2qGZt/2g7tCySpGZu3tUN714W+eb5A1z79P3RajZYkjY13l0naf9Aj\nxfDY7VFic7FBNbb/Jj1lwgnTska0LUvTy0aUti8MNZhWRN+fVg2qvFI0p3TcnLu9fIZ0j+3ofyJh\nknI2+LKll8e/+fzvpM9Lv0iXtJqPPUjtP797whTteDlN+4XUT7DuYTP6utvWDu3lKmuqHdoH6M41\nFfOaL9B11th4952dVuNtM14/QdJZAx0mKuOhQ7TcV8JkuWTyFJFK6jZs3ZayXfpr/NRF84qVXVtO\nnq6jJRXWgZAaNOtKWZevleT5trh5LYNAqWZ09T8QJVV2DzrmIJ3/ntVSlPbdM2jlrtVf/yY3TGrb\nTdt00NpNlac1k8vTlYe9VMZDHivwYUlfl3RgO7RPlPQcSf+20DfPF+h6o6RPjo13r5T06/K1h0g6\nT9KrBz9WDIuHaeDAotBIkcD0spHUca6Z6ZkE/4Ehog0n4yXf0w8LSZloud99sqWL0w9ESXcRutdb\n7qUXrisW+xz//JV6/EMWvIJo0daevlaXPu/S6Z8t2nDqyzwBkQQMy7gOM/NHRTM2v9AO7fMlPVHF\nqfisZmxettD37zTQ1Wk1Nkh64dh49z6SjihfvrTTaly12AMGRoaDCw0rF9NLnne+natGmb8po/HK\nMptkbeXepmbyll/l32/UJXu5l/OdSxfT5bV/6WIS0w9Eybw+y2us5ZMecy7emazz6m3VA3auHdr/\n1YzNl0i6fJbX5rXTQNfYePepkvbqtBpflXR13+vPkdTttBpnL+6wMVQONmZMne4Np9ygZ/zr1Xr6\ntqjdTg766XxzH4fkbRuLjG79aNBPq38atmJfmld8POi3iW7aJ5cHHfGYQ3XJA/eZ/48Xi29MaiHb\nLRdS3czMVINmbbUp/HT6madnyctyyawDAzvjZAxn8ZTj1EsXp/eJrME1oUq92S+pn/Qoye58sUnW\nlWzHpvk5ov+Hcr+uhy30zfPdvr9d0rNmeb0t6duSCHQZqcMgrQ7HUJWbTr9Ju6+fKH7YLE0kSneP\n3j8M0pzcnCjB0uG/vb3aQFddOfm2KuPuQVL/TYbtXUbu5dzP7Jrj6GYn5+s6HOmb0ZVM6hldxl84\nJEu4BtOXM48lbodrQPU8tafFaof2sZLGJa1sh/Y63VlsWyWdstDPmS/QtVun1bhp5oudVuPmsfHu\nngtNBBg1vZvYLzz7MD32pXfVCx6ze5J0j/r3dZKkdzx/pR51/10qT2/9xik99//dIUk69fV30YGN\n6kcUa09fq9/97e+mf44xVrZenUldNZDroMnoJqMOezvkWqXzsSp5+xqv1nZL6HNvXLnnr2aiEj51\ncYXRZvQ1uCZUasbSxZR9RB1O1yrHyHWUqsyjRXuqQ4MaEc3YfJekd7VD+13N2Dx2sZ8zX6Br77Hx\n7opOq7Hd5JKx8e4uklYuNlEMl6e9lZJ1EmU6m3dbrqnGLtplv+qDTpK0aY/ilAz7pklz+cqp6TRX\n3HUX7bJP9YGuFXuVebRuTMhWin6if9mI3Uwj25PIbC8NL7Mi6SMxZHHG/1NLdb/e26g9ZZQ4lNtN\nhKlE1yCDPFrwFOSZZtj5c9lJwGGTXqxmbB7bDu19Jd1P0u59r5+zkPfPF+g6Q9Inxsa7f19uTK+x\n8e5dJJ1U/g6OJQ2wpb6xcbL3gYmw3f+Gr6ZX6V5+k29V4mRPllvPvlWPft+1OuKOKR303aAL9q02\naLvpivJR59ZLF9loAiMudRue2jKliTf/Vq++sDiHL+gk2BCzFCeCDr7/3XTD3feY/4+xeBZ9VOI9\nuu6c0ZUmuZmSFfH0jC4uPBhttODBtUP71ZLeIOlQSRdKerSkn0t6wkLeP1+g622S3inp92Pj3d+X\nr91T0qck/dtiDhjDl7Tv93KW9i1L8rJRbupBSy+TMZrHClChVO1q9YdX64BL1+kASbpO6iZIMy6T\n1t0lzWzP2Xg7baw2wTcLFlukaT1LMEEa636xTvFbN+k+5c/d6xIk2udhm1eYBbq8fPGx3dLyVE9d\nXJY40DWdx5D37M/yO6tg0P/Xoe9PPkY2bkuJTx9Fgwx7G7st0RskPULSuc3YfHw7tB8oqbXQN+80\n0FUuWXzL2Hj3HZLuW758ZafV2LTYo8VwZH1R24lk2Xay94FJO6p6RlepNqfIjIymvpH0sn/31Lbi\npP1+82D98TMaevrDdq08zc9cJq2/fln68yioRg0cGC1Tm4q+YtXd99CZTzhYH3lNmi1nb/nmLVr1\noVVaZvXE1j7ZjyEtguKJN6P3svKgDksXa3AIyEHu/W41Njdjc3M7tNUO7d2asXl5O7QfsNA37zTQ\nNTbefVOn1Xhvp9XYNDbefWCn1Ti973etTqsxvpQjx+ix2jQ2+dJFJ3sf9EtVxnUYtCBD5c3Fmrut\n1H0f0tC+zeofILHl1o3S9dsqT2dOkUdkp+Bpjy4Ps8imthadxfq7rNA199pL+zYbSdLdePlGSbZL\nsCxmLxTpJk6vbwyXbDP6cgXsspiolHvBPKuli8kKtvyfk/5QchCIrgGLzeh7uA0ayKp2aO8j6RuS\nzm6H9m2Sfj/Pe6bNt3TxBZLeW/77WEmn9/3uKBWPfYSBOMe/MSTWSxdTpWM5oytB2lxMZN5BJJuG\nbrA5vNlg1PmMLnc3AYn6saltUwofv17P+nkRkLni5upnRUpSWBe1f2Nf3bzf7knaddxaJDK5vPqH\nr/TjS56E+pb1pRLKGV1P+OkfdOCa23TF6dXu/bbpymJxTconS5pwvkeX0apfoBaasflX5T+Pb4f2\njyU1JH1/oe+fL9AV5vj3bD/DAev16snSN97kM2sJ91uo47iohodUDcs9WWySTi4YJe5mnx/jdFMn\n3P1pV8s/dr0eWf685sI06S6T9NgHb9UZf3GvJOlNbSku8JPLE1/gDWem9Hjb5y7lncqKA4r9Go/4\nbVf6rbQmUbob90j3MAULvb3PprEvMUZUHe9J6qwd2sslXdKMzQdKUjM2/2fQz5gv0LWziUNUV11Q\nE0PXm/ae8ttACyYTuqa/1a4mdevNlOvGTWn07auXbEZkonR2UJNuye6LD5uEc5+Q09u76sb9d1fn\n4QfozX+1svI07/j1Hbrhozdoj02TlafV01u6OGEU6PIsWREYzMq/z8cfoH/7u9UKUfqzB6zQYw+v\n/kEl31gddMu23bNeeVCHAHHqU9dyGMsQunpcChamGZuT7dC+oh3a92zG5qIeGzNfoOshY+PddSrq\nZGX5b5U/V78BCuZkPbMq+4StH9uc84XG+dLFrOt2FqmCEl425t2Os+uAVYDL6qRNPuumPIdua+yq\n//2T/XXwMdXvXXXrD2/VDR+9QbttLQJdKfJ859JFqxldzi4CfZLl3KCIdzl4N5330P0lSYc3d9PB\nT6n+Nql7xkbpPMN9IlOYfoCR5d52dhx3F9mhKhdlX0mXtEP7l5I29F5sxuYzF/Lm+Z66mPd8WIyc\n5IMkTzfNqezwFMI06XhlNcMteaqWT0pNnNkQwnTQh4EThsZgc+sVexXD0P1u3aLH/+wPWvveW7V+\nt2oPYP0v1ktKH+hij650LB4o5K4vTvUAo3LpoqvN6I3SlewDa9nvsap6fglfY/+2lDfPN6Nr0cbG\nu5+W9AxJazutxpHla3eV9BVJ95Z0raTndVqN28bGu01J35R0Tfn2Mzqtxgnle46SdJKk5ZI+2Wk1\n3l3VMY+qpOdqX2JJn7qYLqkivenZIZn3Rhb1WYNp6MiPq83oS2bfcBs9rWg6vdTppk3uznQd7EK8\ny4HF8q591m/Tk89ZoxvPSZf2pt0rGwLPbsb+lBaszqHk+pcuJk7TQtbVabhF1xyHgIwkvZfN+kSt\nxmL25epX5VX+s5I+IunUvtfeIum/O63Gu8fGu28pf35z+bufdFqNZ/R/wNh4d7mkkyU9WdIqSf87\nNt79VqfVuLTC4wZM9neYJfks9b7V9rZ8w1tgL/mjmw1mo5jxkMcase6qUlW3xRc8Kw9bqYkT76ef\nfLfYGeN5Y7tqZcUzuiTpuvXSz8PelaezHcdf8lhdD6ymTjis4uoYnjd2DyIxStc26aSsr+tIo7JA\nV6fVOGdsvHvvGS8fLalZ/vtzktq6M9A1m0dKurLTalwtSWPj3S+Xn0GgqwZM+ojkg6RE6RkxqcOq\nn+jel6nMq29BvFzLLWdhWu5dSCA+X8nL2ShYPPX0A3T2HXeRJP3DW/bS/ntXfZGQrrt4mzZ8cWPl\n6fx/9s47TpKq6vu/6jBpw+zCEhckSBZFUEFHxVFEARVQjOgjKIr66qM8ojw6giBhBRUlKAgGgj4k\nCYIkgYUBYckLLLDL7gKbc5w8Hev9o+pW3aqu6qkOdU513fp+PtAzvT196uZ7zz1BJuxELEFQZuzq\njhdKkcqgUjD6BDqSZo4P/Vr/vjA8+QR7Avg5gGkAvglgg/l+X6/ee28Yz0Bst40d5szqFhl31wLY\nQfq39/X0DbwEYDWAH82Z1f0qgJkAVkifWQngML8v7+kbOBXAqQBQKjfzsaOHfLiJswuhJZfaVUXB\nwNbJpiUc3HFZklukkBAxuqDARiki85Iql92x708CZQrKVNQIrX3KrEMxd2VXwRVVxOgShVThzMOK\nIoVWYOiw06v3LgTwTgDo1/rTAFYBuAPA1wD8rlfv/c1E39Gv9f+gV++9dKL3/Aj/2syHObO65fPI\nXAC7zZnVfRCAywH8s87vvHrOrO53z5nV/e40W8kSYgFHfAcP+aGLYSgcVUDeZPEyUCVDq4rKaYWK\nCkChw7mASaNHPYZ0n59jRwQGLPd6QGaUbxY0seiKAVFQEHPOiUnHih1xD//swxEA3ujVe5fV+Hcn\nebx3ctA/prboWtfTN7DTnFnda3r6BnYCsB4A5szqHhQfmDOr+96evoErevoGZsDQ/O0q/f0u5nvK\nwzUJcluSkW2SVAlGz0EUNi2MKFrs8JGzLhIrisk3otK0xNGfuDfeKgRp50CldY/lkse0TEkp0p9Y\n4a5jqjWIRoy3bCrhUdgzcvcnQriLypbkhkQWd+02n250Z/q1/uekt67u1Xuv9vjoFwHcKP3+vX6t\n/6sAngNweq/eu0X+cL/W/yUAJwLYs1/rv0v6pykANgd9PmpF110wNHMXmq93AkBP38COANbNmdWt\n9/QNHArD0mwTgK0A9u7pG9gDhoLrizAKnZAQLlKMLlZzdFKZREKtTQu9GXoCIcRKIBUtuvh3pLEW\nxw5XjC5ysaqYdFkeWPyFJNcVcymnKdcDxnaNQJcKDSovAE8iMCfGuGl5YazYOG1TBzBQ7NV7313t\nM/1afxuAYwH81HzrSgDnwWiF8wBcDODrrj+bA2ANgBnmvwuGAMwL+nyhKbp6+gZuhBF4fkZP38BK\nAGfDUHDd0tM3cAqAZQA+b378swC+09M3UAQwBuCLpmtjsadv4HsA/g0gDeCvZuwu5eE2P4+9YMs6\nhFguMZxxSlQlzhtSVhjcrriaUtM06ElAazK4y0t2zmNyXVQGzfGiJmRm+eKFrra554nYYoai0Rjc\nUS0UGrTJHjU8FK7aowHM7dV71wGAeAWAfq3/TwDudv9Br967rF/rXwlgvFfvfbRewWFmXfySzz8d\n4fHZ3wP4vc/33AsglEj8rUwULkDj7DJjx3dQaHUjQtzOhWaGrvBK4oUymxbJdVEVzzYNCrUvJFdR\nJvlchgXUVpHUKNOFI7CdUOWS1LJQp7z4YLDC4ZwTyWSqZ9ClzpzICGvItwisBcR8CZLbYr/Wv1Ov\n3iuSE34awCtef9Sr95b6tf5yv9bf3av3DtQjmNp1MaHVUWX2ZbboIqtmjvZ0JYoI9RHUW0wiA19c\nPSKBnDCXkVvhRA2bcoBJY8sZo4s6WDkloV/y1EDsFeTSHBX7ssacKI0bDshjVtGKUwoV56J+rX8S\ngCMBfEt6+1f9Wv87YXS3pa5/czMM4OV+rf9BACPizV699/tB5CeKrlZFscHCFatEsWqmwXLfCLl2\nVVB4BECZPmwqp7lu8FlgfwBaLOWpWsWmd10kEueWG3ssFyy+R1Clqi1UWg/iShSC0SckJNRFr947\nAmBb13v/VcNX3G7+VxeJoisOUGaMYJJLLZLD7J0bslj0it/OqQL5LaSUMS72WfnkeSk5XYWOKu4r\nUbCKJHPTpBHjxKpXBccstRKVQWnL2aosywCVTMsLQDSqDqrNOdvyytqZ6EUWB4rY9/UBaDrQPnUU\nG7dmQ5c59ek89ltcxPRSGhvbR0OXBwDakiL2W5zH2H+KwAnbTvwHCejVe69r5O8TRVeLoto2iXyx\nkeP9cCj0FNjsa/KeJc649mNxTp3MKt+UU67+qVjBrYePvUJRNZiC0avSrFG45OFeD8hgiJflkKlK\nPRMQhXGTEC7zvzwfJ92z2fjlVp+ATU1mb/M/AHjlVwQCYShdvgpg0wudiaIrIP1a/94AfgngAAAd\n4v1evXfPIH+fKLpaFK7Us8qkvE1cF8OD+3SeEEscFl1EI5dtfpDGEE9SELVmRtVidHFO0tRBvElR\neO1TIRg9B0pMxYzZShODLhryq/IAgKW7TMIOu7Zhl21TE/xF47yxtoQ1W8vYfmoK++ycDl0eAGwY\nLGPh6hIO7ekikRcTrgFwNoDfAfgwgK+hItqzP4miK6El0Ik1T1Fw4aCARXEZdryFiG/8Iv54TYO8\nnIwJJNjaVJXOZKJYccnhWveUOKwDkYg1xF3V1Ba+lJmz4+w9yCpbNCHjBXTMjwLsCMX03Ufugk+f\nvA2OPrw9dJn33zmGO57O46iDszjhczSKpwdezONvt4zhmP+ZTCIvJnT26r2z+7V+rVfvXQbgnH6t\n/3kAPw/yx4miq0Xh3qzEHlHBWugh05VDS7l2LQkJTYDlkM7UhTUFc1MnEBCBKVkFt/0EAiSlCFmf\nisD4iSNiz8ixG4+CNS99uAu+jqyDx9WYmmQLVxO5fq0/BWBxv9b/PQCrAATWFIZvG5gQOpRzkiwq\nzou6MhZdHEKJbrUpb3ITIoAUVy8KB3YKNPDMwzrTzbollynOHdeMQiY3idEVKtaBnXPzxDyG6ASa\nr5RZFx0/E7nPqxDrNAKWkAkhwzBeLdFMZ+iEwPwAQBeA7wN4F4CvADgp6B8nFl2tSqxXtUrID1YK\nxugi61KKb1pif8BgkiuU00qkk090uErAdZOvq3DdzOj/pOraBzAox4nlqUSyZ4wnLNWsWNsqsMI2\njV6991kA6Nf6y71679dq/fvEoqtFYQuQqMpkJN0u8FhMxLeiKd2uksWEH/KYLAwGXTEerp5wB+gl\nVwDRiuODK2WpKhUcgQWJ7eKDuJFZgtFz7BXpRdLDmbmaacDoPj/HFg5XYxoxCQ3Sr/W/r1/rnw/g\nNfP3g/q1/iuC/n1i0RUDuA8dcUTO4BZnODNPCfeNREkQL3kAUBorYYd5W3HAiiK2LaSxITMSuszy\nqHFKpxyzbF1XCnPHOnwUG7vUkFcvk+ui4xFifMgRlzxRsEyhVjyRw610IlfGx7c9I+HyqxCsl/sM\nZy4F9KatziUAPg7gLgDo1Xtf6tf6Dw/6x4miq0VhGyzMo5Q+Y486UJuhh0VUreGicLihYtm5y9Bz\n6XL0mL+/Sii7mCJUdCnUpg4Uu11RpZ1t10ViubTi+LDqlTfYMyexzrrIUbn84d7Ch9F1UdGjFj0M\nZy7OOo65DUXT6dV7V/Rr/fJbpaB/myi64oACEyL5hGQFtuap3lg3aRJvgRSOxTy3OgcAWLVjJ9p3\n7cB+M9MkcmeX2zHWlWFwbSMWKMZQvGcKX9hCo1ErgJjWPU4fOzI9CEcnMoOFKLn2MQajV05pdfjB\nIgAAIABJREFUEDc4XRfFIyhg5coKYzB6SlRoyhBY0a/19wDQ+7X+LIzg9AuC/nGi6GpR+OIsuB8i\nnrMSS3wHRdBcFjehdWUtIrcm7mdQYaUzyzjn3dthh6/uiM9+rotE7OV/HAaWB77oiQeMt9wquOFG\nAqqJjMmSWYmDHKLhuqhKXVvWiZQyCWVZMnXnaxyJwrhJCBk5RhdVxlIVXXdak28DuBTATACrADwA\n4LtB/zhRdLUoKo3Lrf/Ziu36B3Hw0iJ2WZ/G2vRQ6DLL48bVdhk8Jl1kcUoiEKMrIVxYallyG0lS\nNzcfK6GDKgV2o2q5Q0Z2XeS6JKByPWfpQlG4eDGJfUIHBgsRuU5VmKLI+pBpCdmRK+Hglzdh8w2j\nyHXQNGz29SIOfjmPaZM0rL1+lEQmAAwWgLZcG/LtaSUuHpQxLlBhYmgyvXrvRgBfrvfvE0VXDIi7\nT/PqP67G3jesx97m76/9hUaurgHldNxnXQY0x4tyqKDfs5M5MMmnkqPAbboXSXljinBdTGJ0hYPi\nLscc6Ih3/4pz2QSpDkPTNXm0iM/dvRwr7qaTPRnA58yfX7uZTi4AHHHo9rjviJm0QrlgiKnHCWX2\n+ValX+u/HFWmuF699/tBvidRdLUqEVjdqB6h+wPdeGVlCSs3lzFjSgrv2Yum2/4r345cO01sIZUI\n3RolAmNDeZjiLSijkJCUxZwxBMmtQlRpXxPy8qp02GC1ZjYfQdeVOfBw9WVK00TV5icqOnbtQOaM\n3fDMvYMAgI+8PYv2DE27Lt9QwqsrS+hq0/Cht2VJZI69MYbBOYOYNFogkeeG0wuAclOj6kVlC/Gc\n9PMvAJxdz5ckiq4WRR6XlFnmOOaDmd+ZiUXbTce9cwt4z14ZfPXrk0jkXnzFMLCyFOtg9M5+RCTU\nZdGl2iLD5sLBIJPrNp3M9TfRqrKQxAYLB7asi4pUcBSUWqrUtTxo41xm1rIRCs9+YxfcmjZcB0/u\nm4JtJqdI5M5/Kodb7xrHTtM1fPvHU0lkrv37WgzOGURKWNjGuP+6iXtR416+ZtKr914nfu7X+k+T\nf68FmpkiIZbEefMAJBNSaFgarnDFJO3Hhx1vgf9gFyZscyDRGPIlCslQFIC8vFK2YS7olNQMqJx1\n0YQu/ihvMPrE2rW5sJWPQa5mhkxJMRWaRSxjXHhG496E4NTdTImiq0WJ+6KWQAOlNaBAZF1M4pTQ\nwDJXiAMzg2jVYAkca72q0cLc6y3ZppjtMKlGP3K7LnLANWbVCEavSD82Uam0lIoJoehSSSEuj504\nF1uxKSISJK6LMYB03Cg0SFn9txkPr6HjjlMSvqhIocRCJ9qWOIiUEnULKJvQgWtOZlMOkFuF8CaR\nAOgTSVBiuy7q1jPwZbfkkUuGw30+voWNfTuaOMoZ9zJblp/0VolssCim6WS5ibmzQ1Po1/qHYPeM\nrn6tf9D8WQOg9+q9gXyJE0VXixKFiY9yklBlMVeCCNxq86DITTpk10UG4Qxwzk9xjoGWQIzlukg7\ncJXpThFY+7jGri4pnmgEmq8xz/zLJU8VWNzahOtieYIPxglrfqAfsKRnWTpRLU+v3julGd+TKLpa\nlSRGSkITkCd46mD0U4YLOHr2Kiwf24BsE5NbDvxnoHlfllAfTJsW8sMF04QoLEO43H8t10VV1iG2\ncpKbrllQjlyOdYilSRVR/EcJyjWIx42cb1eeKAjCwXZdVMOS2BBqviZzZEKTSRRdMUCl23WOGAgc\nG4k4N2lmmjHtdI2X8MFn1mPdM+HIGe9oovasEZgXbs4YXdCYNv9xPiwnJIREFFwX44wVn5Ix8LIq\nOPaKyXrQ8jA0Z4VcMlxJK1Q448nJI2K9f1OgLaNGouhqUaIQM5Z0sSGUpRIc9dqxSwcKl+yHB+8y\n3K1P/WgH2rLNlfHUKh3Pp6dgenO/timoELBWlLGsyIGZvEWlUD9xViRWylXH/ZdFsBVbj88Sk6yJ\nWXySzJcIrAFR2EOGK8h8jXnMH9ZYsgmhYLsuKrTeKWbRlcTooiNRdCUk+KCGQoJHbvlD2+DxdZ0A\ngLP/ZyomdTR31n/goXEUHs419TsTaoD59pUuhT2NnAQXbC6jMZerUkwYDiJwuFFmzmK2mlOhnhUo\nIgsqZl3kGK8qjNGERNHVsigTG0XI5by1UshiIi4k9ccMk2WIMiiYdXHw2UG856ol2GewjJ0fSeGV\nv9G5Jm8zqmHKXjsgv02TTU+rUBorYdqlS3DignFk0xpeeSH87droa6MAGFwXWWIbMWDW63abczjx\n9jcx/7UsufJ039E0/nPQTrRCwbAmSxYiZEZkyb4jNJQ685iuiymmrIu8Mbq0WI+jGBctsiSKrhYl\nEoMlEg8RHjEvHgD+DExAuPUcxQUzgo/UdHQmk3tquIOyc8FR3pW/XYldn92CXc3fNxLKngLgHUe0\n4bn3b08mc+sjWzH1n+twoPn7xvlkojE0iU6hpxJtO7YBADrHSzhw4QA2LaR/ht0BzNyuG/rbuumF\nM6DK1Bz3crK4N8sQaqRVtOjSmZR6hmx6mSpdUnKTKLpiAGnmE5VuVRQjTof1GBWlYVhccCUzdEbx\n8UWK0cUBS36DnOFX99hh22OnD3Xj+EPbSOSuu3EdNt62EdkCrV9fecyQt3znLjx/+A4487NdJHLn\nLC/jmbXtpJZGHIdYjnmpc/dODFzzdtx91zAA4LwvdSKdoqvoJWctweiCUWTK9D6qbPsLwo6sUrxE\nQzihqAhcylLBHaOLlZhrgOJ0zmoVEkVXi6LqYGGJ90Mo05LNIDOBBiXGruW6SCyWunJVaMsqkF6y\nmJv+5TMnoeN922C74ztJ5A6/PIyNt21EmvjQUTYVa1u727DobdOx3QlTSeTm5+RQvnscEclZGztK\n+03Gq4uMrfeMz0xFJk03Sa68bCWwALGft9zrgEprblyJefGcuLIuGh2YUGFLJqlSKM95i15qEtWD\njkTRlVA3Si08MSUKFnphPEMUN7ZcZuhKZtChsgqhEVOBZu6SNChkRSApTynlaxme23W9aMgrEVr8\ncMGRzZkt3iiTXACO2H6UzzH25hj2/sl8/GB9AW1Z4JkrU+EKVGitjeBWJ6FBbNdFhVpXkX2MQi0a\nGRJFVwxQYuAwFlKZAPj0IkMnimWK4jM1G2F9oxNrulSoW2VhatxU1jiUkyu6Coa8MrGiKxlD8UUo\nyKkbefP9mzF5/hAmm7+PrqGRu2FGB40gE2UuHYRsJmFxn6Ns10Xjd/LysgajZ5DNgCLFjASJoqtF\niYKiXxUFUJxhq86QBUepm2jMNsq8GXQYZBPCF3dGPACTfA7xlkWXRupqICy60iU1FF0cqBKjyxDM\nJBdgy9aqm2Pnpf2nYenxO+O8E2nizX3upgJQjsZ+OWziXkQV2tDCcl1Up9B2MHp6F02FqllJEkVX\nDFAiGL1iN2UqkVRzDGGKt8AZV48LFj0mw+RoWwnSYrsu0ioIhOsiuUWXSoNHNeSuRBrw1HgZ7cpg\n686dmHzg5OqfbxLF7ACQIxFVAZnClkYMO2x6aeZg9FpZh17SLWUxBZSybKHmK3FoAmriXLaokii6\nWpRkrNARZ8M1R2wUSoVp7ATVgALx0q3bubhvWsQrufZFvPBUrkpx37SsadHF5LpYSmlxN4xksjrl\nHztc8wa5YOsCgnbG4rpoUQWVrCIp52Ch6NppwzguuOhFvHgRoXAAaNNw4Cd2wyv7TaeTqdolZdwX\n9QgRckTIhLih+/xMJTfOm6SEJpI0Hi+WUiJZzeMM6UFH2girFIy+nOzSEpoMueuiGLAxXw44LwDi\nrmSLQuIkKjr37kR23y6UNaCswTipU/0HAHkdeywbDr+gElb7Es4RKl2wqExi0dWicLiOJCQ0C5W7\nrxKBRbmCqJqQ9a8IxOhSxa3bcl0kVp4Ki65UWSfV25YLxiAqpWOuHXARd5cvzrWPKxi9KtYaXBby\nCfEi3ZnGzMfehRMvMZRN9/5sCqZNornxWHXFKiz+7mL6LOFWjK74zxNA7HX+kSJRdCXUhEqLt854\nU8YRkJetaXUdzZ72OSwAE2zkG3zKwOFMHjlJP6OAy3XRtOiaMlzAzitGMPg0zQOMLx0HkMToihtc\nVvEAHMHoSWWLvVTMXdk54KxOUoNeLlfjCMQlJn0GEQifK8YGpUWXeI1j2JYEi0TRlVA/lJODIubZ\n1CgUYkFZWN0pmK6tYt+/TMsMpW4FmaxCUu3Gzn+fJUPYZ8kQ5v6VVr4KFl2RuHBRAa5srcyNGncr\nQW7Z1KhUVmo082KF3KLLhDLrIidJVA86EkVXi5KYSCc0nRj1oyiPiSg/W9OQgg8ziKWTp0JbesBj\n5coT52f6EdMx/N7p2LIsB00D9t8lTSZ7XUHDy5QBgRGrZaAqUbDUIIcpiYWcnIRWcMzlQZ01SJFi\nWrCVV1h0Mbo3xzn0hCrjNUokiq6EBB84JySyeT4CJl3JvB8/RDyluKeKFvBlTyOWyylWxH3TNNL6\nzm6bxZpz98U1j+TQngUe+UU3mew/PzSODQ/nMC3mt78Odz4F5gsu5BhdHIkk4m6DyuqWGvNDO/e8\nwGmBQ1l026KLWhlOKs4pm0FmvGfCaJHk82lRuBZUbheDZA+cEAQRF4p7c+SFElZHTG5mVlkVcFUR\nsG4QGQ7LSq47Ch0oqYhCMbkU5OSHrMSVPTTiXDYZLmW4KvOhBZtFF4/FdkL8SRRdLYpqk69q5aWC\nTWFKKIsdFRdu5oNN7OE6sJqo5LrofAY+2dRQWjBwX6ApA9uEwSSXmCQbevxgiJFuyGXqSsLqk9qi\ni+Mii2UfQy9SeRJFV0LdqLKmc1rExEZOgg3P/oFFKHmMLuq6ZbQy4oRlTrRcFxWximSUqwQqtqnk\n8kx7oLRjdMU5wxnvWhtzYl/AKlCWnTlGF4cynmVOTi6ByUgUXS0KVzB69rUmMVmOBaH3X7H5S9qQ\nBTlGF4t8HrFkWNY2us5aVlLZTMrTKBD3/uwg5oWNQvG4XBe5YAlurZD7PAVs4WRVqWATEaMrxXZp\nSDc7cSqmE+hIFF0JLQHvcS6+OOMeJHUcS5hjdCXdqvmoWKWy6yKTVwU5LENXkc6lSDEdaFwRtS1X\ndvWU1AnNIXFvJsKy6GLSdMV8imA0XFOWRNEVA1QKRk+JFdc68eNuOaJcf1F+tqbBvJpTjVmdyXdR\nMytWpRhdyrjoKIhS+4oIuC5yxd9x/Rg7OBXTPHET6WVSw3XJzjUn2lkXCYUCLJejnKEnEp0/HYmi\nq0VRYYGRUTUWTthwWXE5Lclo5KgKz+ZbxGRJVvOwUWYtkGJ0kcN0mOQ4xKrSnZQZNzLy2OFQjBCP\nXa7xCqgzjqhgq09haKTKVoZLK6CIqZOS6w4ziaIroSZUciHkVK6R3Wj4/NzqRHkxifKzNQ2hlACf\nxWkc5VlIQaU54LB2tZSnDDthFYYsJ6q60JMX1bLoohWrSpsyGrqywBGjUUUoh49t0UVb4azGDAxC\nlVGcRoBE0dWi6L6/ED6DwgtPQmMkfYcO1qyhbCFheDZpqqBin+Igzpcs3ChSTAciRhdnMPrEOjEc\n4l5WKi+AanIpYWtPrqyLAk2LdV+Oc9miSqLoalHYNqPMo1SVTTgZEajPMB4hAsWqgNkIhxTb+oZY\nbszlWWj2izJWthGwsFVp2aVUhqjk8hWFGF0AjzUO2/ihEpzEyUpocfhidPHsGblQ6L6OnUTRldAS\nsC7mHJsXepHx9DFTZdUMCJkLiWR9E+sguYr3L9Ipoyzivil0uGNZe9So3Cj0IfJH4LptsdYD2uMd\nZ3bWuLrRy3sIWtd1OllRk0v6CGxZF2nFATwXWFFYd1Qjw/0ACY2jghkvBypMSAoUkR/mqxtt8Qj2\nfX0IALDpngJJivniQBEAyIPRs21KqQWa1brnsiF0PFnCpuE2UvGTN+oAsqQyuQ7LhuhkpgwTR/3G\nvKqjUDxq5yAuC19LPpWcKDRuTOG2BlQlphJ31kWuy1FyVOlQESBRdCW0FCrMf5TEVTEQ6YWS8NlG\nF46i60sv4STz91f+QScbAEqpeC/mbGEsMka9fua+FcB9wMvE8r/QlsL53387rVDp9pX70EMmj0Nw\nlOfOGBAJ10Wd+DlUO8TGGFXDplDDH6OLZ7FTpZnjvTOOFomiq0XhMmuNq2IkarJZ3L3oRYYuWJVF\n04/c6hwAYLQjjeUzJ6FnnwzZCvv4WBYbtm3HvjTilGLns3bHveesAgDsNiOFmdvSRSHYMnsLsrky\nOsZLpANMdl0kR/WJJGzUMehihTsYPVPYn9jKM2QmIyb2EDYxl0WX1Y8JJydhSayCC67KJIquFiUK\nYyXuA5Z+U0ZfoapYRkQJjqKv3b4T13/+rTj1/KlIEVlZXfKHYWBViUQWF1aMB+JGnX7C9rh+fgcA\n4Fsfa8fRvR1ksp/c9UnkVuaQ4jJvUugqVKkLD2L4Lu14YhwBiECMLmK5QjxDSNC4jiNVDbqUWXa4\nsi5aynA1ajrxXKQjCUaf0BJwHShjT1Kf8SYK7ZvcljUdVu8n020yVeZzbVAgTi67fMqNOGcQb6Vw\nZGulw47RRRyzkVQah0B1xovDi0WFPQWTXGHRxXmRFeeYeooM10iRKLpalChM+nEfsNTKNZ15t88V\nBiYMsVFWjEbxmcKA06UiSeoZImnjRStzxflR5yqUIwi+MvOTcoIhWXQl1phxQVQt1XrLdvagExUJ\nuTKkz8Bu0UUPy0USg0xVSRRdCS1BFBabOJLUqxqIuEZxb28VbvANuXzuT8KiK00sWI7RxRXrRxUl\nEDUqXaDJkHsuKhqji8xCxPeXhEbhnnup71e4isuWddF6ACa5RHD3YxVJFF0tinJjRQETU+42JZUf\nsrBILiZRfKYQ0V2vJDIZbwVVQUvzuy6qhhKuOsSomFiH7RApxm7Msy6ylC1RwoeKcvXKlXXRRLf+\nRy2UmJgr9KJEEoy+VYnA5KtKtpc4m9JGoQmj8AyUxEmhGDVU2B9xygVsiy6tTOxYx+j+pKSbGyFO\nt322x4g/UjB6WuWpGo2qRiltaOd/yYqZUi4TOpPVtrDo2n3lCM696EU8+hs62cYDqKEBUqOU0SBR\ndCXUBPctKG1MGGLXHA6rtZjfakdiQxShFU2R84ZSkLsuWhZdtHJt10UG30XxDDxiE2JEFOZgNtdF\nZouyOMLlDkpNjJswUnQd0IXy9m1Irc8jU9ahE67zi3efQicMap25VCZURVdP38BfAXwSwPo5s7oP\nNN/bBsDNAHYHsBTA5+fM6t7S0zegAbgUwDEARgGcPGdW91zzb04CcKb5tefPmdV9XZjP3Qo4LkAV\nGDkKFJGfGNVxlIuiSl9miWsksnsRyeSK3cTZh6KQdZEa7sOdIlMGgPiXldV6TbLoIsWSp7G4stMJ\n9PyRWnQs5FTI5ZqD4z4huchOz2Ls7nfhwltHAQCPntdNIndwTEffhUMA4jt2ZBQxXIsEYcfouhbA\nUa73fgJg9pxZ3XsDmG3+DgBHA9jb/O9UAFcClmLsbACHATgUwNk9fQPTQ37uBB9UmvP1ih8IZVMd\n1GnEJDChghJcRoUNEsCs6BIWXbrOknWRs0erMJxUueVWoS3d2MHomZTUMT/cqaSE55TNsa/hSlTq\n/plEdkpDKZ1CKZ2CltWQakuR/Eet/YlzWJoEm1AVXXNmdT8GYLPr7eMACIus6wAcL71//ZxZ3fqc\nWd1PAZjW0zewE4CPA3hwzqzuzXNmdW8B8CAqlWex5ZXlRTw0L1/xvqoHWLVKHV9Cz7LF4uuakBB/\nbIsuWrnWmhfzgNYyqpRTRsUyk8Fk0cW1X6XeN6qwL+e2blVFrnIoMHZkYq7zjxQcMbp2mDOre435\n81oAO5g/zwSwQvrcSvM9v/cr6OkbOBWGNRhKxJvwsDj1jyMAgI++o83xPpe2X6W5iNMdiUw0o6m9\nsnDcRjKuqnGen+wsj8Tx/EilObEUXdSVba7pOoPNP/u6Rxk4nE6UcjLdkD+D5nihQ7LoYh9LMYPT\n84CUuJfPjbw3V8BU3RmOh0gmQ+iJZP6jhzUY/ZxZ3XpP30DTmn3OrO6rAVwNAJMuVW5aJIfDbYUS\n8ttAIjncMinkJoPfRLGKUKy4PKSNF84YXaq0s2quUFGQHzas5ZM0XKTWR4rEV+I4rHNCecHDHSZA\ngeb0RNeTeFLNRIyZpE7p4FB0revpG9hpzqzuNaZr4nrz/VUAdpU+t4v53ioAva73+wmeM9ooNuuy\neKIpVsdshFjPUWzCKD5TGKgYO4QMxtteYdH1iYdWoe3F9XjhyrBDfRrkVufMByAR5yD2/ckDyo14\nEqOLBitGF5fiiel0R20hQoqC/ZiSuF4GR022ivNxAg0ciq67AJwE4ELz9U7p/e/19A3cBCPw/ICp\nDPs3gFlSAPqPAfgp8TOzs3xjCdO6NEztqjxUJBNEuLBskhhkxsl8NxkTTnRTOxD7jbiClgPUdO7R\niS3Ygh02jgMbxzHwGp3sQlsKI52shuikcFoTqBaLhwrW8nFZEcS9USMAXRwyIkERkZsQX6i9duiF\nJQAhK7p6+gZuhGGNNaOnb2AljOyJFwK4padv4BQAywB83vz4vQCOAfA6gFEAXwOAObO6N/f0DZwH\n4Fnzc+fOmdXtDnAfe77422Fs363hn/87FUA0xkqcY+8A0ajjsFGhjFFBZLpKNmzhQR7KQsG23Ouy\nvXAxJmNoSMe79kzjlI92kMk+o7+E/Hia2SVJtyxjEloX6rh6ns9A/QhM3ZYnSx5v+1L1L9ZSxt/7\nVZnLM27ZzhjF/HNz2CRbCDpCVXTNmdX9JZ9/OsLjszqA7/p8z18B/LWJj9aSrJfCmbEELgfjbQ6H\nzPjPtZEgjGpOms6Ec7PE+AhxjqsH8M3/AJDKprBmt8nYOKhjz/2ymHZ4F5nskblDwHhMMs1EFPZ1\nj+WQRae8ZK9fAJqus4SB4HMDI1I6MSoIyDwPaMRUymV01+eSGQViXWzisSOJTCBEHR+AFuSV5UXu\nR6iKKhM/x+0CmUTmzUPYRKFMifUHHVFobyVQrZ5d8yT1kI57v469S3VU4HZdjHvcN3qRCSEThRhd\nKoRGUG3sqHIq6Nf69wVws/TWngB+DuB68/3dASwF8PlevXdLGM9AE0U2oS7mLSv5/lsUJl9SuQps\nWuJ+mJFRqaxuVAkyyjlmYx18GLybYLf8hPBQsW255VNC7rnIFYxesuiK89qvwnjltCbmIM79NVLo\nPj8TiaRCtf7Uq/cu7NV739mr974TwLtghKa6A8BPAMzu1Xv3BjDb/D0UEkVXhPni+9vw8891TvxB\nhQaOCimxKYltEWNbsBqJQD0kmVJDICLlpLZ2jYJiURXivtRyKYtZDzqa/UJ76WFKIzSF1H1/IZIf\nUysclS67WYlIeZWr95BhmAqjxBEA3ujVe5cBOA7Adeb71wE4PiyhietihEmlNHS2+4yGCARIjPsE\nSG4dIv9MZpEixX2jEVkhK8yyRrKLRvKhEhoh7nOhG26FE2ugXkpZDLGNuOPfqDaWSBHbSUaLroTm\nosp4YTD4MWXxVDBXeQE1LBMTmkc3ujP9Wv9z0ltX9+q9V3t89IsAbjR/3qFX711j/rwWwA5hPV+i\n6Io4i1Z5uy+qNilwZ9BJaC2S3uJENw84cbdc0F2vcYW7fKqlmE+Wn3DhONRxK2tZsCy6mMyNtHi3\nrxLzRKKUTgiZOM8RcWQAA8Vevffd1T7Tr/W3ATgWwE/d/9ar9+r9Wn9orZG4Lkact+6YnvAzKnkG\nxflmm/0WJeZKkKjA4jLCSLzHLH/9cqJK8dncdRhlkspm7kds4okHkJUYRQfLxjHu44i1G8d8LmZb\na1S8XGEQzmqlzSBcQdfFowHM7dV715m/r+vX+ncCAPN1fViCE0VXxPnwgd5Gd8mkH0+Zlmw+0eSE\nUVad5bSWoBpc3YxbwcQ9rLjcSQD11iIKOC5clLQOZDpc2TG6eOQnNA+u2HZcRMJdXoWKZoDlIknd\npvwSbLdFALgLwEnmzycBuDMswYmiK+JoPmpf1WJaKFDEZNJNSKiRV5YXnXHmFFRwsoxh1ZQEKslN\nFHnxRXO80GFZdGmxbutECR4eyp15FLtoV6BJHaik8+/X+icBOBLA7dLbFwI4sl/rXwzgo+bvoZDE\n6EqoCe7JKO6ZoDiJU3k5LT58EZt9lXyNEV555yws4EfXjeL0YztwwnvbDVnhiPJFyTg/jEThdl0V\naNdaSVlNJ9aWybSv4HOZZJJHeLrjUIyweptRyVFs7lWtvG7Iys+oyEzOleHSq/eOANjW9d4mGFkY\nQyex6GpR2C6YuSYjxisGFSZ6TlQqq0qE2a5PLTKUXACwZF2ZVLYXcZZ38V1juOC2Uad8OvGRIDHo\niqNQJiLguqhRPwZzjC4yFFOuUcJdTi7dMAfK7MkZLTAVjNHFRqLoigG0+iZVZkD+hZWCuMcpiUQb\nuhY0lsNrzBbVy+4Zt37miO8TJcIu8m1P5XHP8wWnzJjPGwm0OOP+0DSyin3JDkZPW3jRpjpl1kUi\nOQ6ZrHGciOTQiKmUy3QRrIzVJTMqWEPK+IUlSmg+iaKrVYnAFXPcDbqo4b69j9PGP05laSZxqZes\n7HTPNCclMFiy0Yqz5XIdspKYP7GDtXqZY3SRilRkXVBlvHJdsqtSvzLc7tVxVoYn0JMouloU1awY\nODf8ClQvOSrXaexdfglEF0vV5VDHK1GtP/PdcqtW0wZhFvv7fxnGJ2cNhicgABxKiSj0JPLuLDRc\nOs86pMfciiEKfSp0vJK/JDSduF5C+6FCGRN4SILRtwDHH9qGfz6T534MAIos5CbkPvnJ7X3TiXv5\nVKUkheWSz05xtTB64rUCMmngsL2zhlzueH7MA4u+nZmsCUL+/lufzOG5N0qO9zjKGsdp+qlFBZR1\noGffrON91qFjzpWd4yXom/MYXzFe/fNNojRcmvhDIRJWnW8aKuOe5/P4rw+1Q9O0UBVfWCCPAAAg\nAElEQVS25/5jFDtNS+GbR3Z4/nvsFcTMk4RSe0lFysqRpVupfhQREkVXC3DKEe0Viq4oxEjh8JOn\nvYXU6WU6RTed0ZyOlAZ0tFXerDJUbQIZ4d+kD4yWMaldQyZtyLKsnUJo7JGc/Z0pWdHVdEnR4MfX\nG8Hg58zqBkBXzoHRykD/MuSXAcTyvIjCMzSDQlHHb//lr+jgctEkizUUsswfXmuM2dt+PAU7TtMi\nEZNFMyfLI55YCzyxFk/9lFa+riE2i//QmI6f/H0Ur64o4f37ZfHWHdOhyrv/BSNOolvRRRXTjhs1\nSmmjiuutQCULtggsBUqRKLpagG2npPCZw9ow++WC578r4QkV84kPoCniR38xiO4uDfedOZVAGh9x\nXygDo1f9tWnkizqOPn8Ixx/ahjOO7wxJis2mIbskjk0DsXI6zv0sVzDa1IsoxMpSQW6Y2epeWFKs\nKjOhOZzw6yGccVwHjj+sHYDTYo66X804fgZe/b8N0MfKaMsA0yfRRS/ZmE5jyVsmI/zVwSDsuv34\neba7bxvhSapc1pFK8Z2UuRQwys39jHAonVSpZ0WKGSkSRVeLkEkDxZK0QQpZ3lhex0V3jOG/j+nA\ntlPszZAqkxEQ3wlpYJRuo715uIxL7x5HZzvw8Xe24eA9jCmHarMf1zaMGjlTBz97Xr5C0RV2H0tH\nIdIktSudHv5a8OY6f3cjtkOH65XlGWIyqTw4z/viTKDCIZaKF5eWcPxh9HKfXFjAQ/MKOPOzndA0\nDdMOn4Y7zjoQi1aXcdDuaVx56mSyZznrxlFseblApugKE7cVle7zfhh85tdD+OGnOnH4AVmX7NBF\ns8Kt6FLRejnucOwndJ0hGYjiROGIkBCATBooyl4kIY/MB18q4IGXCjj3H2PYMFDdfYUCrgmJFILD\na3X5zf/K257M48F5Bdz1bAHf/dNI8wUAWLymhPG898YzSlhxgDlcYUNeWYUSnsM9RyNwXcwVdCxc\nVan4CbstR3M6Xl/DE9/mgtvGJvxMWOVfsLKI8byOBStdVkdRHNgtyj3P81uIWzK54++ELcBhdRq2\nMJtzbh7FfS8UMF5dp0lKHGJJ5V3TUqlUKTOsPr1+wHCZ5IJ7rCoDU5gYDnmqkbgu0pIoulqETEpz\nZBqTCWNSSpk949nXizjuIm/3lYTWJ+z1rHuSz4zeJMGjOR0nXT6Ms2/m2/hFmYqb55AaXGz8Uwwr\nSpogGP3l947ja38YxpottEr/s24axVcvH67+oZDKPDLu/8VhzhtrtpRxyhUj+Mg5gzjlihEsXU+v\nYIwKylhryD/H0FWGK47gkBmCzZGllsksMk592L0XF5fQYZWxmqUYZ71yW1mRyKITlUAMy6UzvUjl\nSRRdLUImbWQaEwte2IMl7aefUGBhs2TGXB4FQdzKGim3yL733Bs+8WaigGssxbGdC6ZFV8pD6RR2\neSmsyJZuME42yzZ43zaEVcaXlnr3a4r5sKqIEOW7rTPleGyqxQbjwE4iQSmUUBYBbsWEX0glqmKX\nyvwVTJ3NM8xkA4WS8wtLId9/hP39tZDMwTSwuudzyFRQYZtAQ6LoahGEwsBrwQtjjPpZZoSdqahY\n0nHf3DzKro0Zy802x4ZfiGa41W7Fc83arcaAcLsSsBzWFGVgtGwlyuCIketlLdHsdm/PGkIeeKng\nsHQKu391emRHpeLIg7Isct16S/mQzh0bjFxuiII/+S5n+7rX3DBZur6El5fZk7bDoovoGcK0InOv\nRxqB1alMsaTjmofHpd/p5D+9uIDX15Tw6KtOf8k4rckFt0VXKdwLaD9vDpVg6zYRMKuNw5iZCAWK\naKBMQaNDEoy+RciYJlbFkmHdFXbQS7+vD3uM/uPJPC6/dxylMvDJd7eFLK06jCG66GSG/P1h30R+\n/Q/DJHIS/DnrxlE894axE6dwXSy6btMdMkPq0OKgcf8LBRSKwHlf6gpHkAu/bF4UioF8lbg+YXo/\nuceyrH9h8rqKJe46LJWNsURRtydeYszbc2Z1G88SswYdLzgLRK2uvumJPP70UM76XR5TYVf1/1xj\nhxG483+nYLtunvv0MMvpVjxZ9RvW+hNgfxPWxXPG7d4RgbHaipeyNcuNiGItzhf9ljxacUmMLmIS\ni64WIZM2Xq1YACHLyzF5gm0YNAo46/YxXHyXHQw5bhthan547Qh6+gaqfiaMhXXeUh9XryaJakUF\nF6dLUBiihZIL8AkM32ShY3nn715WZM12k3n2dXtCXC8l5wj7sjfr50NOwFC1GF0h9mH3ITIKm8Kw\nN/6LVpfQ0zeAecucC2+Y7l7jrnEU5DDdDFZu8oi5Jv/MYM3cbNyJHCgSZsgMjzmleLUtxXO4LZ+4\naHZbX3aPs32LHsHom4n7ckcmrH78yCsFfPjsQazYGI1GVO0MoFhxWRV7lKhRymiRKLpaBOG66Lng\nhXGTU5zYpCuMAVuWNmS3PZWv+HfSIJTC1J5YXhg8tchHcxly4doDeD+pssCpAIXr4li+yqY/fPGk\nAfen+SRzoBgy7lhZVLjj3zhqIKZTxVOLDPO5H/x1BMsJDpaFom65GwtKIQfUFvz9sVzlmyHKLJV1\n/GX2OIbG6DrP4wuc623KT1sb0iN1tTt/l/eNYbavOxaYl8smWSuEKOjR+c72LYbs9svhuvjvF/Mo\nlY2y3vyEPWZjOgX7kmxP4wvX2SMCd3dKkSi6WoSMpegyXusdn4WijsEAGz6/292wp4VyhCx0wizr\n5uEIFTRE3C4cgrDXl2Rz4kQnWlnlA11YbSAUXR86wPDrc7i2EbQ7RZZHwWhuYgFhprH3lVnxQ/Nw\nH+o83TRDKvN4Xsfmoepzc5jumrmCoeyyZIUU1+ieuZV+qdWsRprJXc9Wyg5T8uMLivjL7BwuvGMU\nOWk9olwivJJ0hMnUTueE73BdJLTGpIoBumRdCWN5HcPjPO3rpSRuZj2L/fiu21Ye2cJy5xbWxFfc\nP45L7xnHiLkWcbm1ce/pqMVzl1fA8RhhlX3LcNk7FqVC/VhFEkVXi2DF6GpQP9J3wyiOOm9wws/5\nmZyHvcj5uaLFaXJ4enEBn5w1hCdecwVrZXiWsDei41Xi/CQQ4G7UkDuZV5bNZossmJfpH3tnG9Ip\np6LLktlEoRUZ1AjKKBitNGo15IXcjk8tKmD+SmMR+PpH2k2ZNFYhvvFvQpYLAGfeOIrjfzUUrhAP\n5D5cLTZas/C6yfZMdNPkCl+wkj6LqFBuPfJKESddPhyeoGoQX+FnMk6BXhZB4cR0cv5OkUjiidcK\n+PKlwzjinEF87FzvvW3Yeysq18W8hzI6rHoV4VLCllMPpAo2OlGRIUpt3Sw2DZXxiVlDuOYRyTqR\noZw69EiEY1CJRNHVIlgxurwWuhq+54nXjI3mRBmWqG533ZR8Zh5OJVCzJ8P5K4xd0U/+Pur7GbI4\nJSF/f47J/cm65Yzhgh015EWbYgEXm/22jGEpUQ450LL78JYiSi1ZLOlYvbm5lp9PvFbAX2aPT/i5\nRWvsQlfL+BsGbjcgz0N6SLLnLCySKQVk5D6cTvt/rlm0ZSr7MIV71OtrvTuRHIus2XUtd6flGwmj\nsktkfdo0PMWI83e3S2FYuN2OPftUkx9l7pv0ylPBB/YzrIpDD0bfoCdHPbj7bNiZJSeCbSsXgT2k\nCvvYsMu4acgQ8Nh8+yZJgWpNQKLoahma5boo2Do6kaLL+/24ui6WyjpeXUEbgb/i4Bhi5e6/C8Hp\nyYPEoksiJMUpN9tMtg/NKYKgyyvMw2pbRjOyxDVoaTQ4pmPJOv9Tvtu6VbZaC7MtZWVTNWoJWP7j\n60fxl9k5X8saQVeb3ZBC8eJp8RNYcnDc9U1p0WXLqeK2GcIzrN5iF9JLjdpskV5WiRQxujgstjcO\n0bv/7jfTud7K1jEUfbjkVjgRjaGCa1qhyPb4tl2bnzx+/opiIOXgKR/tABD+xfDarUZFnvxhQ153\nV2WIgGa3qzsRipeXR5ilXj9QxrqtUuIXbtfFmO3bqiEXlePSPQyRYm/K7LmYaNcYSBRdLYJwXfR2\nL6j9+8643t+aCKjiIhmyq5vf3iLsyfb6/hy+eeUIXl5u79TCkjkawMqp2aK72nzkhOyKWi1weKO4\nrRKToPYeEFRJe9beEDdrfqrGL24xMl6N5nWkNKDRM8Z3rhrGly/1d2lyH2I8EyGGUc+eLpnmrXqD\n8k65YgTLNvgr0qZIMX7SWuXaQ+u6KCkywxNb9RnClrtyk6ToIojnlDMvIOR1wSugdrPl53xiNjpk\nNlckrrjf24IxzDbt7tJwwC5pHH2wkY2FyKDKokJZLP2uu17DlOvYR4ZUB34KKd33l+osXFXCN64c\nwZ8f8kiaADguRSa1i2eoFNPM4v7wWmO/nivoOPY9WV8LwWbidl205kSivnz8RUP4tORGrpolWbKd\nbS5iXS0TzEkTkbgu0pIoulqEtOW6aLw2Oj5F/BU/SiUdbRkj4PNO06XbowblTkR+AqOqMCb/X94+\nij+Zm5qNg425hgZBPkSddo0UeLjJcmRytMZqttwAwejrTqzg6sKy9VikNgmuRS2sR3vhzSKOPn8Q\nX7h4CPe/4B3cKRTlNEEcFi+KRb3CdbFW8kUdS9YbX+CnKHX3M9kaJsziCrmnH9thvdfIgdkd2P7p\nxf6Tgmy1Jn5uxmH9V/8cwy9vn+CSxaVYLHlsTMPuZy8to01zJltCUuyBxbx82SmTrPdKBO5R7rHU\nLMVt1CgUdWQzQN8JncikXe7VBGV1X1RSWXS9sMQ5p3gpqcPcTzWD068z9mQLV3t/8Yg0j6ZTzti5\nYbdtvmjIbDRWbxDch3G3W2pCuIRt4VRVNkNTh5t1voD/usy4zHRY14Yn0pdkFNGTKLpahA7jYhC5\nIs0weW1VCfkiMKlDI92kTWqnV3X/6zlbQ0LherW/5NbwTJXDZjMJcpMeBmG6LrqVd4Me7rgqLSpX\nPjCOgVEdKzaV8Zu7xhz/pod0haTrOtZutWt5mymV5ii1tMGClUUsDuiyl0pphqLLQ2kadJ6SY2D5\nKdkrFF1EU5R4ns62Sou5eqwVlqx3FuTvj3lbLAB2mX/xhU5Lsed5aK1xgP3zmbxjvvVC7k+G3Npk\nNINrHnZaAYWdtMPRxzzWoGavuyIbrmyN6XV4rkXshoEynlpUvW2373YOHtGlWFxlQmzTfMlwrU6n\nNHS1aeQumw+/7GwHqhhdl93rHDcUcd/8EifVW7mbh42/82szOb5dxhW/UEhs9nK7x/aGoM/3tCGT\nqnRNDYOlG5wV4HXJTqoQYdrMxU0JryJ/kKx606nw3X4nIjHooiVRdLUIImbKqFeK34DfMTLu/OTW\nEf8TxPNvGqtaOlXloBHC5OCnyKNyS/N0G2my6CCb3ua7jDh/F1Y4YdfreEHH299iKPbSTbaEybuU\nd1ypxWslrCqXFdKivcNu35eWOk8ZjSolTrliJHBmtAN3TQOa1lAcGFlZ6qcMzrvmJM+NUo1ygyDk\nyjeQjcRRyrg0dO9+q39sG2Hd8/bdMnYwetn9KcRudeW//Q/LYbpdyVAr1+Q+RrEJHs8b8/GO0+1J\n2VOJWgOnXjWMH147WnXOcSuTKeKCcZAv6pZ7WToVfsIMmXJZx2urnPMyhcIJAA7dyzmnULg7FwJc\n/tYj2k85KFx899oxZc2NbitUDc0t78xtUthn5xTasxrSaZp6dSvTfBWKRPC5LtZ+YdcUuSGeB2p6\nDio5IZqwyfHmvDKDUxK3ta4VSBRdLYK41Re++vUw7jrIBdn8pFPug2S4o3Qiy6Ow5wgKaw0Ks3OZ\nRatLzmxToDnIPfd6EaM5I1j5EW/PYuY2zZ1u3Icmqs18NeYsLKCnbwA9fQNYvpH2gbwsm9w0e5Gt\niMnioZQIi+26U9D1xpJIDI/ZTznm7e2JMZfhU7MVtn4IZeVUKV5WI26aP7vRuXa8ZYb/eBRuKpmU\nrdhrphGBHGR4IkoMrrHzlpXwihyvUf7HEJ5Bnsso3MzGCzras4YF9cUndRlyG2jgjYNlrDMt8aqF\nH3BfTnj1Z7KDVYiSCkUjKyxgzBde8c/CQvSfU49st97zUoyE0bfcc4rcp8KqAV932Dq+66F59iLg\nN9eKNe57R3dI2dCFcOOlFouuBSuL6OkbcMw3bvIl+7Ce8XFdbOalVrmsW5fdAivrYshd+e+P5dDT\nN1DxflQUPwnN4bk3jH5fLRFQs5AvCzMe+7cwutPR5w+ip28Az73hHNc6khhd1CSKrhahqwkufe4N\n6LEXDmHTkPdqPmOKhimdmnEbSbjAuC2PLLnhirXwykbVbPwOFGGV8Xkp/XaXufctNnh7H4QHzU3j\ny8tLyGacMR6a4TYilKKTrDJVfin1huje5+0O/OpyWkWXfItPVew26QJ/5jYp71vwgA/jjiHlx147\n2oM0k9YwfZL9e60WVv98xj7YuC8CBC8udU6cVDeCwspn5jYp9Owr0thXPmPQsspumhMhDm7ZjF3e\nRrMu/uF+253W7UbpxdXfnlQhN+x+vcu2duM+Op8uZaxsleK3BtbCvGVFPPiSj+bWlNFhui0KVyxr\nf1DHei9fpFRLQPLAS0bh3reP2Z8J5mk5K6wfzZafL9qKiY1DOh6bL80hda59/34xj9OuGcHAaPVx\nLBQ/bRkNv/hCJwC6C4hc0VCgCryC0Yd92dLIJZ7sVv3iUu85SoyTbFqzkkQ1Ejv3qUXGF576xxHf\nzxSLunVYT6fCb0+vmK7ujJphyf77o/4u9RyoqFSjKPNj5vr6zOvhh29pkxRdaTnJQojlHDBDqTy+\noHJBT/RctCSKrhah05U1r57bDa9gkj+6zntxndql4eA90kZWsyBZbZrElhEfWQyLTVg3n0FMwJt5\n2yzH+PnGESIdtiknRCVmyry2KOvGLUqzLa4GTWucow82BkcULLrkQ56f4iZsq0iAbryIOv/0YW3Y\ne6eUcwNe4zP8ZbbtslbNrbq7S8NBuxm7lT22T1W4FtbCbCmWjV97XXqP05UuK3vnhBhMW/Tvtoxm\nKQaaaQ36+pryhAH4MynNU9FVa3mLJR3/95hkLeHz97JF727bpSvk2g9Qm/ygDEhx/iizM8mXUI30\nZwAYHC3j21eN4Oybx3w/M17QrbifQjHRSBxH+fLGzzISMCzlAOCdexj9uex14dLkupYVLw7qlJMv\n6hgaq/7HhZLumCfkflVv8X5xyxieWVzEBbf5tytgu5ylU8DeOxljqEhkFZkrAO2ZypiCQHhDaHDM\n21q9GXsbr7Eo+nomY1uKFMvOdaAWi40tw/LY8Z+PhStsJm3Mn+6s083Eay6guBwFKrM9Cij2TVVR\nUOEFILRyu9edMGMmZjKy6yJdcjXAmcEaUFNxyk2i6GoRZIuuYqm+Kd/rRmbh6rLngik2LGnijEET\nmbGGLZ/i5tOtkCl5ReRtIkJJuvt2KenQGv5su60ZmPyQPTLIpLWmK6LOuN5Q0ooDRSNKlmYhH6ou\n/pd3WntSQj+gC2VjtqKNaxUtK7mPuWDI9+BdKttWRm0ZbcJMrUG56J/VD5AzzP4sK47D5JK7jf7T\nJllVlZt4iHv4lQLufMZbKyEObpm0LLv+zrRxyPm3fooCuc09LclCHNiL15Qcz5VJV8ZiA8IZUvIl\nVKP9+ajzh6yfvW6TAWA8r1uB6MWrFdevDpmnXWO7xY77HNYHpboV82SZIOtis+YHwff/MoKPnzc4\noUxZ4dNMHl9QvUBiDs6kbaUBVcy5XMFl0UVw+SQr0IHGyupWUP3w2sqLYHEJkE1rlhuUu5wago+j\nW5+yn/9Tv/TuVwXJddE9L4YRJ9LLqpTKddHPslo1RZMKcbkAkJg3yZ4HGQ+tR5h1PbnDo4CJSRcp\niaKrRZAHasWNacBRKgK9n/XZTsf7w64g9SM5Has2lzGc05HW/K0Iwgh0nfW5zQkLt8KnkY3ZnIUF\n/PmhiZUb7kNe2JtBsUE663OdFTElGmnBS+4ew31z/a/vZ0w1ppfvmrEsfF02Az7Em+tKmHXbKIol\nHRsHyxgyq9pO8c2/E9phWoAptUU2MJfcPYaXq8QNAexDZFtGM9rYy300oLwxl0XVh88e9Dw0l8pA\nOi3crpzKkUasMBetLnu6cn/6UENTfMvpUyq+u96m/L/HchWZ0fxoy2pIiThZTTiwfufjHdbPv7pz\nHI+8UvkcRbNdM2k7bqGndUbACtgw6HzwC+8Yw/yVlX1LHLC+d3SHdaCTXVnCHDrLNzgnYq8NcVjI\nyhg/JWaQ9XaBq05fWuY9fnMFoMNU2DY7o7OfVYq87rkTHMh/0XQ3Qp+Ds+7z80QIq7Rzbhn1DYRe\nKDotuhxym1C+s28a9VUoiv1aJq3Z8fWIXBfvfr6ADYO2BK/4emEvf40kOHBnwZ77ZuXmrGC5LtqZ\nf937qXpj8IzmgFufrHTdK5Zs10WhgA9TeSnmgh8da68Vnp4IITSmn0VoveO1UbgUTvy7WVrCLK98\nOeCIsUpQyZfeM471AwypoxMsEkVXi6BJK+eTCwt1DVCxQAtLG4H7tv2xVwumnCJSKQ0eZ9eKn5uB\nrusYreL2EAbuTJReJv5By/mj60bx14dzeNnncCGYv9IV5DNk9w1hLTCpQ7OUXo2mks8VdNwyJ4/z\nbvW3ghGKrc42mEoQSVYd5fvFLaO4+/kCnlhYxA2P25vBNg+LLi7cVpOyco/zEkevUXihaLTvt6rE\nDQFsi662jLHxb6QNvPrk4rWVX1jNoqvRYXPuP8YqFLIlXceMKZqlGHCnXa9H7h/uH8eZN1bPUCdo\nS3vc4tcoT+b9+zlP4D+7oTLByTpzY5ZOSYflBsavW7mfKwDf/3Nl3xIHrOmTNetgt3W0/jm5FlKu\nTCSyC02Y++HxvI580XD/BSrbpxZ+8FdnnS5Y4T0gc0Ud7aaYCouuBgvrd1CVlULCWM4aaiFVsK7r\n1oVIs3ngxYKl9HJTKMFX0eWgznI/OK+Ahz0U1IBk0ZWSXetkmbULXbahhDuezgW26vzUu7OOZwHo\nDu6NxDEMglgfRPvKFzzNODj/1sMS/PW1ZcuS2Mr0GKaiy+xa20y2j4heHiFhQJEQqtWgVraFbcG8\neE0J4+Y6oXnsjMMsr1jvALo56TJX+Iuki9OSKLpakHNuGcPaGrJWCWTriz22t5v+NNfmeGqXMQwP\nfEu6MjV2iJqufNE4TMkBgT3lNpGrHnDenpWaoCz51lUjvi4jAPCsK/hiI9mugmBvfO3Do3XoqFP0\n+ZKC66Wl3jsgp4l/466LImjyT/8+ipset09Tnq6LjYmqG3ccPC+3mTCezfcAUqewMan7rtzk33BO\niy7Ncetbq2iv/uH1XqmsW5v99qy3JUpQ2TOmGrEIBc++XsTl9zo3JcWS8xZQvvVvdF66/8WJrboy\nadvSVSgWG9mIbjNZwyF7VDedlYMyi/HVSOwoL1cY2TXQ/bn2jEZ+4HHL80s60Oy1SMRcassAb90x\n1VBWT/ezzV1SwmYPK8ViCchmbKtIoPHYYAI/iy45wLWwyPR0xW3KUxjc+az/+GpGO3rFE9J1Q3HZ\n5tG/geaV7+oHvTV4Yg3Kygpyj+yHtZT/S78bxq/vHMdtTwW7iTz5w85YoLXKq4cfH2fIrPcywC+c\nw/OurGnyvgYwFV1W1kXjO5qZVU1Yg4j6y7jCT4QRS1ZYSTsTC4SrQBT4ZQPmtqyiFh/XWE65go6T\nLh+umEuoyttlJ6MNVaZ8jh338DpIoCNRdLUQZ0ouhyJ+CxB8AhbBlid1+Ft0lco6fny9ccN/+qc6\nkdKMwJdelgfNHq8j5vN9oacNn3hX1hHEL6y5YaUrE1mzbsk2Dgb/InFT1sgE+KcHxz3jSQCyK4Ot\nLCo04Lo4MFp2BPHe6pNAQGy4xUG9ULL7UT1y/YIKT24XmY/4VxC3Yitf1B3WmGERJMEBgMCdTHaL\nkQMpV8itsOjysL4J2CxebkBecboqLLqks2ytY6hQBPbY3nladWfbk10l3TTa4877h79F5FtmGNkW\nNU2z5kK3m3ktbDtFw5HvyGLapNqW/SkdQnbdoj3bcXBMr3C/Ep/raIPnuKnnkB4Ud8Zdx51OiFOL\ncA8eHtcrLpYczxPgGUY8EpZ98pdDFetRoQRfV6hGy33xv7z7tBjfv/xKl6VUDDk8JZZtqJwYPS8F\nAj7AUa7YXF6KLjljKQAc9542x+GqHrzWtvUD3g9tx+iSsgI2Kc7qGxPEUBUIa0FPd9gmN/YO3Ro+\ncmC20vK0Rjl+F3Fn/M25r7ISdYjx43GJp9Uh3w9hDXv4AUalWhZdIVqwWxcOWQ03nDbZIS/sg/qO\nPuEfKObjclnHZ389iPtfIHYtiRhhBv7n8LzYb6Y9UVNFOJHlyFsZXW+uIjxhYhJFVwsRJE12NYQi\naVJ75fcId7txaX7vbPcPfOn+uRkIRVxXh4buLq1pN8zVeO8+Tv8CO+BmbRp4tyJwwarqs/nbdk1b\nsht1IwSAax7JWWmq3VhZgiRXBs9U0QGFytZUgBE7y1OuFOenWlDcoHJXb/Y+Ab5n78p6DCtj5kS4\n67XZgZD9aLYc2Srjzw/lHIGkZXKWRZetzBTUWvV5j24ku0GN5nQ88FLepeiq3xJlJKdjYLQylo77\nAFks2bfozbDyWb4x2E6vWNItBZewshXtUE+JNw3pvsriatlCLdmjwrKg0jpkIhau9i7zQ644ZbJF\nlychjme3RL8NebMfQViGFEpGptpGXET9+P39bitF3bIS9Az63wDrtvpcfJhzxaR2zVIqerqZNbGC\nxYEinQKmdjZ+yeOeBzMuM8CHXy5YSTXEpVJXu38Gz6DP4Df/erF6i+l27OHy3Cj/mV/EgpVFz/Es\nFJmH7Z2pcIcNk1IZmNw5QVkDVJ+8dlWLiVuULOYAp0WXEFPLQXaHadU/LOZmkZCqmmK6FhatLmH+\nCp8YfkXbokucFwJfpjWIXxIair1coQSs3qI7MptyW5K5f6am2eXniKX7mnQeo9UYgnUAACAASURB\nVMtIbgtyj/BEz0VLouhqITqyPlYFAQeupUjyuF381lXGrZU8CXVkjayLgPemv/kWXTCfz4glJSsN\nwlJciM3ZnT8xAk3Xe2v1yCvODYPs+iMjDomH7Z3Bxw4ScSzqP7wGwbrhzWjWBq7QQAad6/qdZgN/\nesjDjADGpiGdMuP8uBRd9chd63GAOnTvjB13LAIxuvIVrovhHuQEoj3ft6/RwDOmmnNFnbJkhffT\ni4s45+bKOE5ApetiI22wrYciX7b4ufSeMZxz8xiWrC8jpdkZ4/KWRWRtJ8hL7jY2s6+vcT70TtOd\nzyG7Sh55UBY7y/9eR/1Ws+KSyRftA5c4bHhZdAXpTyLw+93PG/PSFz7gXAT+cJ+tCPmtaZHTbSq4\nRNagRmId3fyE0aGmdTnrdtZtzrqQD1gAcMJ726znAMLd8Lv7LtXBznJLLRj9rBHD1K427/cfcLnI\nFoqVWdyKIZtXibmxLSPF6GpgPQjCDt1G4b750Xac9GGjzzdznShLD758Ywln3jiKn99kzJWiXbMu\nl+56uPCOYHMGAMwzLy1nTk/ZWQHl2KMNPMeWER2nXDGCr/1+uOLfhELmvftkPN1hw0heBBiXLW0Z\nTbJ0qm8/JVsU//LLXf6f83JddLkR1nKQneKVlU1i3By6Yv9vXVY22KdO/v0wvnGltxeAfOFgxXkr\nVtZrGE2aI7oc9KKaDoZc4cWq3QrvqyusH8VWtY4LgCAIxekhe6Sx83Tvi6Qw2tZx+dzYljGhQRJF\nVwvhdjmsFRHksqtdq3DXAYCevgH8j5QmvCNr36znvW5B6xixPX0DOPsm70OzyLo2qc1QyJT18FMa\njxeMiVYE+vQMDB+ArSPBrkz/bR44to7oVa2rmokzOG3jt9rB5dpldCujmiX3p5/ulDbzTfrSBnC3\nJcWNtiz3Qwdk0fu2zISb54m48gGnVmPtFu/KFYeDrGnRVSpLVho1npvTKQ27b5fCTz9ju2ifd+sY\nTr/O2IzLLtZCcdqWMfpy0CDJMpvN73Mrj/afaV/nr9taRv+rRSxZb5Q/k2r8gPGqK0C4X+bSXNEO\nnOrOllrrAHpznbP9Prh/Fr892T7M3f50Hj19A/jYuQO4d67RaUU7Zq15qvG5+I7/nVL132WXGUBY\nS3go9+p/BF/cSmoqV2hhqb3DNCM+l1c8JffPfuy/S7C0xbLrojsDoky9NXD3c5V9+o215hhK226i\nfm6azUIoXI45pK3hOHdeippTrhixMl0KF+olpoWziIGWzRjzopij6qnTxaYF1VEH+5hkSpTLxt5t\nr53S3m1bhz5zSsfEnxGWT13tmqd7XViJJApFHW2Z6lbjQZCf9X37Ouv5r7Pt9VAOyQAYa0LFvkYL\nPk+O5SvjUsmWjrI7tyy3WXvjpesrB74co8vL/TVM/Cy6KBDtGIEE3qxQXiiFjYiP9cEDskiltNAD\n7QtkxXnFbjzxXSQlUXS1EG/doTnN1ZbR0HdCp+OgI5BNPNuztgWQSNFd7yTxyvIi7jP93h+c5336\nX2RaVnS222b/jbpkjeV1XP3guG8a8FzByD6V8diY1YLXt9/zfOVm/85njfeWbig5XFaA+t1C575Z\nvZLEbaMRo8t4z68+6mUkV/l9D84rWAdXUb9WsPYmic+kbaVHsYGg5M3iaVd6cs9A6SE81CtmnJ+U\nBk/LKpF1Mahod5p1r0yDgDE+hdVexpUUoNZi5os62rLAJw5xHjKeXFjEdf1OxZuIWyLmiReXlmqe\nm6wkBmXgth9PwTGm3O5J9ibkDy6Xr6yrbmsto5er1nm3juG0a0YcY3JoTMfQmG1J1qiiWBzyr/jm\nJOs9r828HIerzQpW7q8cD9qX993ZKEi7j1WyYNwVBNmtWAzzVl0oiy8/ZZLj9wq5TX6I/Uzl1Lc/\n1mHFxKyXYgnYfbsUTjmi0mx7w0AZLy4p4t65eazaXLYUAsL7rl5XKHEwtaxIAcy6vdICSfTlmduk\nrHhKlk48LCsy2bXa1Y9rxU+B0mdmLRXKO2H5KNbarGVFbbzWU1Yx38kXGHIMU5k7ns5bVkCeCqfa\nxQf6G2HR1ZE1MpimNFem1jrkbh4u45qHx30vMqzA/5nK7LC1rgeifT59aKVZ5A3/yeHxBQV8/y/D\nWLnRVtgarz4xugKwZbiMVZvLOGh3p4JaviCz69VUnPpYsNfSr2Sl7fMe+8dx6cIh67IgC8syT3z3\n62u9B1rYCopyWceZN45WyiLaRN7+VM5SknM9g6fsJn+3O2FTWHIEC8ws9+3ZyjmpXtl3Ppv3Dccg\nkNeZoo/regINiaKrhXCnPxfUM2662jW8d5/qt4NtGftgYrkHyXJrEHzqH0cmdNkRAfbLurw5dAqp\npayrNpdxyd1juPaRHO561sdqomCUsdFbMi/LnQtu8yiv+b0a5NTfjc183/uzbX7u5SrnlW7cmoSb\nNOle9UClX5Mc68htkdKsud6I/9XcgLvD43rTbhXzTbDoGhwtTxiH6qybjL5279y8GStL9OP6yuGV\nlc9LOZov6Vbg4UY34MIFJZXS8PWPOA/qVz2QszYsgKH8AuzD5Pf+PFKH8sc8+BaBnaancOZnu9Dd\npWHp+hKKJR0bB8t4yKWUT/tYGAVFPLebZxYXcd8LBQyOllEo6rjy3+OOz7vnp1oRSpsdpEC/E1nT\nCGWT31xcCx1ZDYfsaRTiwwc6g6KVHdYLpmxTKZFOa56H5Vq6da6gY3C0jDVbyiiWdF/rW9G/37Jd\nCtMnaWQWDMUSMLnDWIcqgtHXWOWFErDj9BROOaLSBOfnN43i//1pxMqYK/q2phly642fePMThuv6\nxkHnh70C4ANijBs/28o1yYotYONuGCjj9TUlbB0p+2Z6tNzMMpUH9lrxc6lat1VHvqhbFqICIU9k\nX/TMwBuwfY862FC+fK6nDacfa7Tt0JiOclnHSE53xNUbl6asam0bFF3XAyWiEG0grONllz7ji2qX\nffFdY/jTQznMXeLdaKWysV9sy8guuLXLAez57SBz7TvjOHsMpVLAGX8bxXNvlCz3b6FYc1idiv1d\nQE3X5abL+MvLnOWTs7RtGRYWXULRJZ7XIbIm5D7iFfvUadFlyvO8SGzuqX3lJv/GC1vZ88zrxYqM\n6JT85q5xnOThEsxBmHU96h3pxPUAzZP3w2sN5WV7FuZFkrzW1PedF90x5um+bX+v7lhncq71KbHn\noiVRdCnEpHb7Zj0ImqZVxlqo45bBy+JojY8rFABMn6ShzXIzCCbDzdaRMj73myErVpbfJjVXNAI0\nNxq0NVupF/BEVJmmebgjyZ+rcwL2ukkvlowJPpXSrE13I8HoBTtvY/clkQLbj0bN33VdR0oDTup1\nKkAyKa1hazw3Hzt3EP91We0bjpWbKh+gGQkVjjp/CD+6zjuWhptdZ6TMA0ZjMmd0V84TXlk98wXJ\nRcfsz7k6XdzypgsKAPzXhyotUoY8AjLL43Xesto6wHTTZeyQPW3Fy8CojheWlHDhHWM49sKhir+p\nCLhfYxlF+bwSi+SLOo46fwg/+b9RDLoyXdpKcSG3NsGiTeQgy9t7tLGMyHpouy4K2TWJBmC4vgvL\nsAtOnOT4t2sfsXe+7rT2GfOQbmVrrUP2t68axlHnD+GEXw/h21eN4JgLhnyUtsarcINyZBANOQuV\nCGqeSvkr2IKUvSC5i7t5qcr4kJUhtdaxV6ZHADj2wiGskg7Rwio8m5ZjdNXXris3lXDcRUP46uXD\nOOaCIRx/4aDn5yzX6nSlC65MEPn/fNo/E9vR5w/i+391zo+ivwtdz7qtZjKHOvrSNNPKdOY2KZzw\n3nYc8XZjgPztsRyO/MUgPjHLKL/XvJBJO5XUtcaluf/FYLc1Iq6jUHQ1ojwViP2fO0GGQCjG5Rhd\nJQ8X0SAyrWyZZuf86EG2ZVc1RZ+83lr7u4nFOZ7LraiVL05/Z14Ad4g50VJ01T8njUn1eePjlf3a\nipWY8XZDDQvvvXBle4aBUIhUyHe9hoG47GnU8rIVONlHQRS2IjOTMhTWjcoJctlo7Fns3+WwQ3Ft\n1yiTKLpiwubhMs66cRQjVdLPd7VrmDG1tiYXmzUvRVHQAeuOSQPAsQEWnPhBY2Oxy7Zp282gzsPV\nrU86F28/o6l7ni9g/YBu3Xx6BaMPInvapNp09MYNs7/SKShn3ehcnN1BhwEju47AvUlqZNK94ETb\n9XWDeZu/cFUJv7x9tMLVoJrFXNBNaFk34lT866d2nB85o6Mz4G7tB6gVG0vo6RsAYNwsevXRaizz\ncO9zKGrrWGHXmoej594Itss87j1thntdRZ/SAj/CSE737EfPv+mRaatkK6dEVigRq6V2RZdtyePl\n4uZ1aNp5uj2fybFGAo1ZM8j5aZ+stH4RcarcZNNORUStLSrq6IzjOyv+TcQwenJhEQ+/Ysi3FT7G\n3/3t0Rxmz6s99XnBcuGy63WfndO47r8nT/i3mmZYw3hapASWr/teBsjuvmKdEe2fdbnD1srwuI6F\nq+0Gm29aBXqtZ6KOMmmtQqEpE7TM43kdP79pFBsmuAQolm3lVMalHKh1DC1eU8ary40Hn3Wif0Bt\nwLj4Ehhy61sN/DKRAsAqSfmfN5OTZNK2RZcsUhisB3mKNVucn/JLlCDqMp1C1VABQXj8NWNMyhc8\nAndmPsDuu3tsnzKfsf7VViSmEMrnTUNGwa56wNAyCsWIyPgo057RHGO31qd4cUmwDcoj5pzVKWJJ\npRo/uIv14Cd/H8WZN1QqIkQ2yqmdWsOXlXaQeePVx4GigkxKq9g3apoWqLyyUlDm2deLeGheHn97\n1NYi2xZd5qWhaJYaFUF3PpvHJ3/pvMQ5/doRPDrfXvPylgLRnv+LdSrCBSM5HT19A/jjv/21hvJ8\n8NF3GItfszKG1guF2+BEZYyzcoTSLfPNdUbMVVt2beeEclnHOTfbxgTjPpbEYr799seNRVa2pNf1\nJEQXNYmiq8W48CuVm9fX15Rx1QPjmP1yAXd7xIUSlHVg2ynOEdZ3QuWBS8Zt0eWMVRLsmcses4iX\nVrxUtrNGVcgVIgPK/OvDzmtmt4WEFxWm9jXgdyhyl/M9exkF+9GxndaGyp2xpxZmvzzxbWtnm2Zt\nICri7TSwyEyXlHsLVpbw8MtGDIt/PVfA4jXOldttdVXrrfa45NK07RR72sqm7e9esbGxHdHPXBvp\nb1xRm1WXOJy/bVf7RN9ojLmLpGxbyzb4n/YPP8DoV/vOTCObaey2998vBFOkjOZ0PPpq0erHIjOg\nULbX+gSyRRcA3Pg/Eyth5OHql5XWD5EVVFb+TIRIJb9l2NnXglpYiXEnFF4yd3q4V4tnE4qQTUM6\nzrpprGZrBTnjncxeOwbbAhRKsIJu14OIo+PF4jUlXHL3GP79Yt5Kdy/cYYWCr14LRa84iYB3wGMx\nZtpMd2jfGF0B6X+1gIfmFXDcRUOe1oiCYsmOM5hOea+XQRCWSkLZ8YH9M/js+3zSMMIZ48lh0VXj\nyBXfomnAZV93WuvJLmfzlhatDb5QIggFTVib/2LZKJumabYLbp1WtsLqZvftgo0ZYT0tYv4Jq6R6\n4t+450a/urrm4Urzuvasq7/XWHy/7ihbMG8YLOPWp4yxJqy3K9yO66j2JdLlhVD+y9iZxDVrrrAC\n79coT1g5uZM0eCFb5HolzAjal7cz49pd+JVJuORrXThoN0P4hXeM4ec3jVku7IA9J4p+7E6eEZSL\nPDJ4PrmoiJ/+3d7/5Mz+JsKlZNM+e4oaHkHMxdc/6u+7Jlw2Tzmi3VqbrDW+jrNHq9Co5WOzCTMm\npZuyh6I2DInNWF+2juiOeeixBd7nL3Fu7chqmDZJq0j0kui5aEkUXS3G4Qdk8c2POt167nw2b7no\nVTtYlyQXCcEH9sv4fNrAyrooNqTSvwWdjLxiwXgphkolY3MENC8YvWBqV+XU4j6cembPQbCNvyjP\nZJdxyLiPHmrHaZodRD1kk/Dxgo79ZhrCqsUpqXVxmdKp4fwv2YrXM28ctW7Wv/YHp5Io447fVKMw\nK/OQaeHyIVOxk0pp1mZMtsKpZ21eN+D8o4FR/3g+XogDlDw+c0W9YlWr5dnkjIBf+p2/4m37qSnz\nVltzBvCuox7ELTMAfL7HeVCW6+OsG0cxOKZbB2uhvPFzM5mIfMFpybXbdhP7A8uuobXu+4tlveIw\nc8wh1eMWikPQZ39j3ojXKlOyGhBjshofOyjrkGtRo1yhtHFbVWlVdn9HuzK8Pf9mCeWyXtfYKrpc\n6uTnGC8At8zJ4xe3jFm3ramUU8HnZWkbhEkeCkXAO6aibdFl/Odn4RT0GeQyfudq/7FrKGNsy456\nrWCWuxT9mbSGH36qsyLQtcCp6KoMqB0UYWly7Lvb8O69nPuJ6/tzWLymhCXrSnhxacmSIcq7eotw\n5/NOM+9HUMVySRrj1S55gnyb2zVvIoQ1Zleb8wKgHtyK4o+83Xueuu2pSsVue1Zz9PfaLyC83//8\nxXafPk5y8xYu4cZ+Srayrh2R7VbgVlLaccGqx+gKsoe79F5DASRiVvm5AAPOeUVcfhhyaiNnJnPZ\na6c0Dt07i2M9AuELfOfEGmXK7Lqt9xEwX7AVa4ZM20q8XnlB5hdhGXnIHhmrvPUmyWgWesUPzWdC\nqzXiwlOKs86HDA1cq0j33OK3Eghl7rylpQoDipjpaFuCRNHVglSzQKh2W+l1sJs2KYWHz5nqL8vc\nT/3oeiP+RD2ZQP70UOUNzv/+rdIMvVi2rXPcAZAbvVTo9lB0iYVXBL6Ws+fUKu/iu4xN0g2nTUH/\nuXZ9fuzcQcdtqkjrbpiDu9wzaxPpS0/fgPXfBbeNYrygWwoi9612PTLbs8BnDmtDZ5vmu+F2YyvY\n6pNrZ2Mz6uz8E7vwyC/8+209eFld1BK4WBwI5IOQ14G6FoZdh6OevgHPQ56wXAC8s0DVgvz83z+m\nw+Fmd8wFQ3jhzSJ++68xPLnIKPBbdzQaV7hCWRk4a2hkXdexYlPZ6p8TIdyB5MPILCn5QxDRxVLw\n2HoCobD1clUKguj/2bR/1jQZYZGTDupH44PIjumX0MTN1z/SXpEQQHxPrZe9uYKO1Vt0R6zG2edM\nxZRKj9EK3Nlaa503vCznxDO5ucaMFSZcdeoNWi7ISOv0m+vKmHWbdwwY4wLK+PnR+UW8ua5cV0wy\n8by//LLT6lvO1Ccjj/NUAzG6xBj8f0cZDXqwK5HFSZcP48uXOhV9O003Y5JJyq1Gb7n/+XTlPqPs\nmBeN10ZCBQDAdt0afv3V6m6hgD2+RXyWei8AgEqLrs8c5q8QcdOe9c7+W4tswJ5zZcQ+Q9DVBmxn\nhsdIp10HeLEsBHwUL0XzmGs9FcrHjjb74tArRlcQhOu4eL50SvPdY3TJbr+SO7vluhhQpsj6bX2X\nz4lMzqJasW+ssV5l3vVW7wU3XwTask5lXqPzYZDYRlaMxrbKuLn1ngEefCmPz/xqsG7X7LDZMFDG\nked6xxgMm5WbSjjqvEHP+LJUULmmtmc1fPQdWcuKEqi9T7n3DX73hCJx0paRcoULt/GHtclNaIxE\n0dWCuN1PZPIlY6G/d26+YmIvlb1vqTpcN5T/fUwHLjVdEKwYXQWg32U63uiy8dSighWDCHDe+vtZ\ndAWV6Y6ZNee1So2D2Jz4ZgmqATGRdbZpaMtoOPIdtgLopaVFPGHKL5bsWDVu18UwuOf5AsbzlfEd\nGtm0lMrAZJ/Dk5tPvdtpkXLtIzmM5/Wab9OtbGxZYfmgecZxsr6zSVVayyIsDgTyAdLrcFPLo3lZ\nAcgxjWQ54kCVTRvm/vL412uwlkhLc0QqpWGqSyHzl4fHHTHwRHmFUkEouiyPgwAyhSVgZwD3w7ft\nmsYlXzPmpw8fmLXcgWulWLIVV0FxK8ZqKSNgx7LLpDX8/HOdOP1THZ4KJYGfxVWtyqa8mXTDC681\nYUqn5inbK97iRIjYdRukrHyZtBao7oWFb8l1ARHUoqfDRx+wcoL4e5m01lDSAaDy0Hr38wWUyzru\nm5t3HPrc1m7Ge7XLE+PdvT/46We8wxPIz5dOAU8sLFgB0wVBA+DLcifK5ml81mVdBcmia+I/9/zM\nr+6sjP1TKtvKtDb35VkAOTK9bzMG0LeO7MD79slY1pZ+CCtyMS++sa7+E939LxSwdqv9xF5j0y9T\ncHvGZdFV6+FOipt31ueqh7oYlS4A0lUSKwTBSyF5+1M5x9gZK9hrbsalGKmVL77fmCyOk6yq2rOV\n6x/gsuhKwbBYXFLEcnOu07SA83LBqVDyuziUMyOKNejWp3J1Z1UWuJVPuYKOu57N467n8o61Livt\njetxvQWAF5dOPKm9sc74TEfWjrnmjvdaq9yL7hjD2q163ZdTYZvgXP2Qd8yyRts2CPfNLWBwTMf9\nL7jOdnW2cT00YrGn6zrufyFfNUv6O0x34Pfvm0FnW2NnA/fF9WurvPu0fF5JpzRPhX8CHYmiqwWp\ndsAvloyF6vxbx3C7y4y9WApmGfDB/TPW4VHeNPfdMIotsitXgwP2h9eO4suX2CbvRUkRVy1DUhCm\nT9KwQ7dd1kfnV+6axCZbDgTcaAZEYZFy6N52xZ12zSh+fL0RoD1ftA/XdmB4IUdSTDRxMhwe97fo\nqjWLpq7rpoIgmGxxYyjK/J8FRfzu7soYERNhuS4Gv8iuGa/YK0FuIQWiHeVndFtk1cohHjeuXtmB\nhsd1y6IqIwfwrkO8GAPv28f4ore/pXpjiynFdl00fq+lD282gysfOIGsD+yfwZ++MxnbmRkD0ykN\nv/Gyrgh4QHf340++q3oHqxa3JQgiPsp4Qce2U1I44X3tFZlEg/CMh7KzGvmCvyWwUBrKvG9fb+Xh\nf/9lpI6DsvcfjFfZnArsy4DaZAr8ntXLotgtt+jz3I3MzQ/NK+C8W8fw98ds66OixwVUzmWtEUSu\nHHhdZvpk7077xQ/Y/a4jq2HjoF41ZbofRcnlEwC+8P6J+3PF+q7XFkMl5fNhdxy5suQWKtagvNfZ\nJECjFkrGOtqeNdzlfzZBfFOhIOk0117hZlePVXyQu7A/3GcfmPfcwW5zd4yuWpXFIuHHVw5vx4cO\nCGbBDZgJDhoIRu+VsfjqB3O44XF77Ig67cja7exlARRobwOjrtwK+FOPrOzPJx5uvzea01EoAf/v\nTyO44xljzx20L+dcFxB++/MT3muvSyJR09w3S3hjbbnmyxbBjKmao191tRt96MI7xqDrcChW0y7F\nfz08tWjiNeuP/zbatrNNszKzujNa1oq4LKmmDKlG2Pqme56f2Ow/rEcQ29sGDcYbwmtuC1rnLywp\n4dx/jOGye/0THGTSwEG7pY2s85nG+vGYqw/d8J/qMUDbrQzOzn9PDLpoSRRdLUg1i64b/pPHr82b\nza1SBp55y4oolIA31008yuUbLPfhaK6UeS3QzesEM5Z8y1Io2hZHGdcBp9bFZiyvOzJdeCGUGOIm\nMO1hgl4rVsYeD9G5ommqbqWJdpqg14q4wf/GEe1VN93LN5atm1bbFch4rbWYr5gZvRatCbhamALk\nW7nVm8s1y5WD0Xtx1MFZ7DhNMkmu8fsBYHcP14xaYsSJz7ZnNMyZ1Y1MOph1QzVmTg82RRdK9gY4\n646HViPC4uH7nzBckYRSSfCS62ZWbJJEv65nQ3nRPw0F0DZTnLLcGRHP+2KlUiuo0vWrlw05Fese\nCtt37pHx3PSJTGLypmzrSLnueaLd5Rbixe+/UamAEsju4IEsIotOFxmZQ/bMYM6sbitmmKYBb5lR\no09nFfxctvbYfmIZ7mytgqD1XouCbEqH7SqaSaOh7JqA9/gT8ew2D+uOz7ljZ/plc6qGUCoEdXP9\nwP72CXvFJqOwWwMkbXHz59k5h9zeA7OYM6u76t+4LbZ1SIetAI/gF7B/1OW9WJJcF9s8lGu1MF5w\nJrzwGrfCpa33bRlrfU+lNOy6bcoOvF+b2MCXLbdKF5uy+2p7VnNkGa1VvqHcM6yNuto13PbjKRP/\nEUSCAw8FW0C5XiEvAOANKdGNHDfNcnWrc90bz3vvL7Y31z9Z4dWzrz123vXWTN2H53vnFrBu68Q1\ncsCu9uQtW1p5ZdkMyrXfnYxdZ9jr7WjO2YdkZKVlMxQ/PX0DVV0J27OQLLrMN+uUK/a8fvFyAWC+\nS0HudaFFbYhDIe/6fmOM/Xl2Dtc+YiuLwlTu7bZdynGpbLka1yFUXJbd8bS/uV6xZF/wZ9JO44la\nlf6nXzsS6HPiDL3bdukkRlcESBRdLUjQLGHXPJLDQtO08j9m6uDn3vA+uX/rY/YiPklyS6tmwRBk\ncnCbkbvjhwDAhXeMoqdvALNfLlgTl9g0C7cXSeiEMvNFHWu36th5m5Qjq+SaLc7vEgu3iKXiWMwn\nlOJkSoeRQUe4FHgpr3IFHf96rmApIIXC8smF9QVyKlrPP3EQbXHYTKW0huItPPu6UbDHF9gFvPmH\n/tnxRD3KG+1iqfbb1oksurKuWxPn9wdrTa86WRJAMez+rIhrl9K844zUsp573WoDwE2P53DG9SNW\nvZRKurWhc8c1csgOINMOmO49z7jHtFDqikNCzp0pNYBMoTzrrGJQdcGJXZ7WrNUCquu6juv7x7Fu\naxmvry1jyfoy/vao4fLhd8i4/Ywp+PpH2vGDT3Tg9jOm4CuHt+OW043DnVz2jYN6zYe3495jFHDf\nne3TiqZpljWezCF71ueS6UW+WN0SGAB+e3IXvnd0B273OMh+8l32/OKVHXIi2eL7ZS4+eeI4R6Iv\nr9zkjJ8TlKCH3o2DZQyN2+tdtgmui/fOraynax9xHt4fX1DA04uLltJEJLKwLLoQfIPsZ9FVKxRu\nK14xOGu55fZT4r+yoogHXrTr/ZFXCpYywJZZ69Ma5Ao62qX5yWveue3HU3DJ17rws886+7YOI0Ny\nLRbCAr/n3X8Xf0WxvOy0Z4yYMZb7W80Wmc49Z9CwBW5LhlpL7hVYHzCUPw8YaAAAIABJREFUsqM5\nHVc9MG7F1ZSD0f/jyVxd8tzWVYL375fBhV/pwlcOb8cNp03GDac59ztero1hZBAVyG37r+fyNRe0\nq91IhrTNlBS+/EHDoniieIlupaUg6Ly4dmvljUO1S8SOrGa7rTfo2ibGf7XLgycWOB/mMMkjQxXF\nxN8e9b48a7bSq1DUse/MNC4+qcuR7bce5Dudqx4Ytyw8HfJK9l7WbdFVa9GG/Q3HHLzXtIg/+cPt\nFZ5CYWUYTvAnUXS1IH6xVrz42h+GMZKzt8t+A+yz7zU22DtP1xw3wnIaZTdBJgl5Evv/7F13eN1E\n9j16zd1OL5AKBAgthRJwSGITCC10SEIJPZSll8APLyyhmQ7L0pbeW5ZelrKAnQCG0EInEFoCKUBC\nYjsur+r3hzTSaDTSkzSSHuWd7+MzeX7WSKMpd+4999yRg6LclJhn39MdPb+ole/IAf9GlZLqZkF6\n9RPlei8tTBtSkc6+z+iNJxF7zUHAKRPtFBWlErah0sx4DoplqqFJFj1y8OSlVbp1SNgd9gGjHkuc\nimq4PdQMUSMxZ+6lW0aD+0QtGWU7qJHPscP1vlnV7iVyo/wstTismw6mrlsAfmnVBytJe73gUWOa\npSzLWN3O35nJKyAHgVjEe8oVATnwrt/LuFT/67/deHNRBo+oaRxGRhe0z7x0RFobV86+z2rgfPFj\nFktXZV1ZSJsPVhrbaICx0Z23imOD/hHMPasS9VtYL3w9GU0+GcAPv2Txzcoc/v1KEqffo8/9W1/u\nxnc2ejn9aiI4dudSTB9fggE9IvjbbqXorTLNaIael3fb1pVDvxrzGKYj9kEgmZZtmcCAUpjkkAkl\nXCbs+E31vv/n8/mtvbYuWVsDidOfiFQT1JTnNz9Wq8yn2fcrqYZuhzNh/rCOxGF9I1jdntPmMxkf\nZFywe4HB8HfY9htfmtf1VpUxRbT3zmFSKAnD4uvlWciyuwqXJGoctZm3/zxKccCwFTV3splbLJJp\nGb+2ii1sZG1ZuUZ3irvR6KLn3hCKlXLbK0nMmduFdd0yulOygaFmV/zFESsybd5/dhypT6othkRR\nUx7BdiPipmqfxFH77Hsp1wdHslezzoiLOexWgvUoJjBhc59xjzM2AosUwwYtt8lMPYNi4BJtmrUd\nOc92FQ+brh/Ffc1J3NecxB2qvlFpQk/DW/i9soG5F5rmBwMkScLEzeKIRSUM6xfFMIaJyqvoHeRB\ntk+VfnFi67pBSUzCDhsT7VQJx08pxdVHWLOHle+JOSROu8s89uxkSUrjul3Ba9dp8HIxxf77/hdr\nDzc7PH8PuvVegrUiCEsUPpVVbMUdNomjPKHbVMb12NnztlHr+33NSTw4z8wC/aU1p+2JpMgMW+xF\npHd5axvZY0riMGt0oejoChtFR9cfEFbpW1bY5aK2vJt+RamSbvX4bGOVmVhUwom78sM9zoRqlZ+n\n7FGKu/5WiURMcmRUs5F4N+s8iewRnQpi1K9mHCxa6iLR6Ip6T5VkdVZ40Sq2qh9tPL7ykQcDmKrg\nlg8Rg6NL8py6SO5xa4ZtsidH2+ity6q1aGdFqaQVCFj2m/uUL73qIv/38RifweQUa9blDEbREfX8\nMf/kOynsdXk7NwU4mVYcLsRRHI2Ipy6mM0DvKgn/OZufLnL7/5SNna5YShiKXlMXiTaR05RAMt9I\nRb/5X2Qw47p1msC8E2zQP4LeVeYCA70qI3jwtCoM6m1/M+x4eufrDA755zoccaOiOcQyQ2f+y70W\nEWCManelnJpjOr77Occ1ordQHX2ELUAcf47g4CZSGedMYB6s0lGtDPDdLmnTaP7sOkuDJ249Z5r+\nGVlH2T5z2u/EwLzrpEqDzo0MYK/L23HkTevU+ax8MWFIcXDYiAe8uDCNr5frE3S3Mcq9kfH/94c7\n8eJCd4dYJ4yu7UYoaYUXHGR0kuxKOb7y9e1lT3RhnyvbIcuyJeM0H0hg5pn3Unjn67RrjS7aPnj0\nTPPaOOXiNky5xFjJjK386xZ09WKCq2bqDgI6mGOFa551sSiqIMEO1g5bv1cEGw7gv+w4NdfJvOsk\nGmHq5057QVk79H/bpcYeVKt7wWJRxUm2x2XtuPzJLn2NdtgwceyxgYGn301pzA2yPsSj4kElu4Id\nduBV9A7yHMtqiLkdzZmc2Rk+cn37/YZ3WHeDZZziH0nO+rrZoCjGjYghEqHE6D1UoCU4lXKw/ePR\nLi0jgQVtp20+OGp4VpGqlk7QnxP4AsJhko0YSKcQUm0H2HgqrQcdIvS48tDmnLnGQHSKWdt/XJXF\n6nZZy0CJ0/q1PuGKp8yaw0m1Sq4kSZyg2e/Ai/oXQ9HR9QeEXcQ2HxICf+sFGY4zxkmZX6uvOFki\nyLZx4TTFmCdOnbYuGa99ksKvbTlc8Ein5njSU74kbQF0bTwwOiu8jYIVEacNFicVaVjoYvrqoeFc\na+0M2jht65Lx+NspTJ7TinVd7p5UY/twbPq5Z1Xi7pMqcdffKvCfs6tMLDP6X89/4C79ia26yIIc\nTLtSMs5/uBOrqApvTjZtWjMHMI7Rhoc68IMaDbz2OeWgsvy3HGobWnHNM13I5WRc/mQnvvgpY0it\njDDGoRfjN5XRq3S+eD7//V7+ZCe+/CmrHTo1AW96c3Whf6O/Y2d3nM+B4ig11UFqnR28ron5Un5Z\n0HPWkArhcBqVxs3MJgA4erKSFjOsXxRPzK7Sqt7SePzsKpyzr70AthVSmfyMLjt4OeR8oOo5pinm\nKYvdRsdxy6wK3DxLf94po/VJREf9n16QdG2A5zTnj4STdivFdUeWY1DviOb4pJ3bgL7vxKNMxTgv\nlK48+GalvuaTAzbNGPro+4xHMXpzPz9/XhX++3fr/YG+Ni2OzGuTsEi+XZnTim0c7qGgAsHXK7Iq\no0uybJNFpwMNM/YwQ9YzjdHl4j3Ksoy3FmW4TNAXGqpw87EVmMURLefBjk3KA3HmJDjr47+PrzQ5\nCFlnXFLtq9XtMt5alHY9h15amMbyNe4HfTSi2BoA8Ppn7plH41TW0SNnVOGek6zlEQBl7PCq87kB\nneLkBlWc1EU3YPeg586rMuig5St6QLIgnIJX5TVfUItOMfOS2sx7NbxgMO1MJo4u3SZ3/37bGPv2\nq+V8O5sO2CgByvCcEXbaYUHDyuFj2O587op0VtbkPURTF1m8+rGxM1m5mjhTkMTrsz10mr4e8ViV\nqbROZOBldhQJXeGi6Oj6A8JpShENko5yTR6KMg8ti/grsRtGF506d/rU/Ie1UcOMD+lmPSKLGEkh\now/8FzzahVte6sZrn6ZxlyqiW5rQBfB5NFQnz5nNyobD9n7jEpgymn+IZtNGALUctcs201Q0E1Cq\n6FiBF4TtSgH3UAKUTpkhAN+5Mah3FJuuH8XIQTFTqh0LVjQ4HzSNLgtnSHlCYam9/FEar3+Wtiz7\nawWWmbDHWP2w3fy5wg6iKyiSYfLkghRWtSvaa4tX5AxsS6tN3M3m2p2WUaaOz5ryiClFDwCee1+Z\nn8SxoKXoeIxapTjO6X/YlJU/dY88Ah9O2kxbi6U7Aa9yoBPkG6csdh0dx0Yqi+KVj9OuhfdTGX4E\nNxqRtJSYgT0jWgVLGuv1imilsu3wa2sOr3+q3NsnSzIq80bMkWhV9p7F6vYcflptHHh2znFJkjB6\neAxjLNgw0yiGyFXPuFurACPLqTQhYfuN47YOP033MGpk/ojY+rP34c8PWoOIrBs0oyQWlVy1S541\nxhnSvaoi6FFhPdZJhVU3+L+HOrU1kVexlocrDjOn2735ZQaZrOzK+O9SNSeJE2BXi72WBlnPPv4h\ngw+/M56y863JJP2Pt6b2rIxgzAYxx0UA6L3p06X5aYPpjHk9JqgokXD/KUYn0O0nGP/94fd6e7Pv\n7/TFT9uXY2vsxtg1sYjuSE6m3R8qUxkZGw6IoCwhYROGcfT5j+YXsbGqe8jTO3RmT8mebGueTRKR\nnLUZjZgDH72rIhjYM6LpVToZ24Dz/s1wHHr5pC+iESW49+LCFLfvneLwSfrLWbOOw/Ki0kdjTFEd\nP7QDraYobfZHpHBTFy2rD/vwvPlAP6dhCAT4/F0pWgtTT7n3w7n2c6sMWZbx6RJlXWXZj7wgsNP2\naGcoXbiK57BNZfTARDQqWeoHFxEOio6uPyDYyesExCmy4QD3O/n4kfyN1sl81QXT9Xu2q4a4nSoC\nST/jL605V6tDKm00DNmFiBxO31bLHfes5GgquVyM2NTF8hIJ51tE4qZy0vy8lPdlUxclScJlh/B1\nO3hVIAH3DiceQ88p9tnORmk8D5J5UhdJimRbp7fwEDtGiHOJxgFX6akwdOoM7cz6gUqRi0ZU2r1A\n+KYzabwXR8YzpdHlRdsho/YFPZ55+ljxqOJcZSsleoEoo8vLugY4Z60R9K6KoFEtqPHyR2lD1Vgn\nSGfFUgh58459w/tc2Y7zH+nE5DltOOG2Dry5KONIo8sOJXEJEzczX4AdXntd3o5p1xrTQt2sGRuv\nZxxLFQ6Fr61A1nN6y7Rj1OisSHHjtE+VhL23jWPHTfmL1pc/6Q0QJijrKHcDwkL1IkZvNQ/Yx573\nhR706uiWNUcXT6B8EjNezt67FBM3M/fFZ0uzeP/brLYHOulqkrq2yyjlepMdOGKJo3XeFxmcfGeH\nQZMxH+z0hJxgU4vUsDmPdeGj7+2dXUkbRhegrH0062ejgfYTjTDZRQ5cF0032xm0Uxowr3O8A60d\nulJGJ9JoKvhJzx2CaETCLlvF0atSmQDupSC82TU8p5+TPT+bk5HNWbf52pwatXqz+WJ0ypkbyLKM\ndJbvDLdDNKIUAbjkP11ofNKcqpUPvVVdMTJfAeCkO8y6XXRBALJfseloIrDy55GPZ+yYQISRnAjS\nMZHLyVq2QiGQE8w4cAvCqHtovmI4JWKS78//1IIUjr+tA298mTadq9gzoZt3+8KHyo32qlQ0kWm9\naXYvoRn0MV7Au0jpChVFR9cfEF42Y2LAezns0BW3aDhZJDR9FgcjbVjfCK453GxA0WllblhkxDCs\nZKjlzZ8bDUtS5p72vIumLgKKs47HwEhwuvOTJYqukds2STsE9VvE8fqcatN3eUwgFk761o7RlQ/H\nTi7BIRO8Obu604oz0Grsk3f971dceu5U0I6upovM/QfAoDlFsz0OuLqd+/2ID7TsBYsz+IIy6ns4\neI8kVeWom9Z5KrVO2qMZCiVxyTCG9tw6jlcvrOZW6POCTFa8WpwXeLE3yjlOUKfrRSojc5lNTmHn\nmHvjyzRqG1q1f5No7doOWVijC1CqXpKqgCwefiOJWbea16+T7lhnm7pIo/niatx5on2KklvkXDp/\nyJq68PsMVrfL+HGVKmxNfcfpuyapUFZBBhpkqtGO/CfeSbnS+HtJ1fTyU+h2amMb3v4qjauf6UJt\nQytepCpJtnbKuOgx5dDLc0heekg5mi6qxutzlP/2G2e/9ru5706VFUD2Ayd9zDKuWM1MO4gextiK\nozRWWRQ3ISBONjvGK08jk2Azm+qMTlBZCuy1jdFoGT08htfmVKPpomo0X1yNV/5RbXLmsSl93S6D\nAklGE+1fx1TktX1L4nrVX7fIZI0BWaeo5hTV6E4p6ZrvLrYeOHTVbLe462+VjmwBFp+pbKzFK90Z\nBlbrp1NHwY6bxlFRYgxIpbPAjn/X96tvV2axqk3WCnZomno+aiWS4lYsyB518m6lih4Z57mCcHjx\ndMq09vxvzoCF32Xw42p97aHX3wAy9QEA7Z3GqyXi+tnUS/9uxNEoXLpKeaZlq3OmlMG4gH7tUjWI\nTc6jb3+lvzw6I+TOV7vx4sI0Vqjp3tGoM7meIoJD0dH1B4SXA2HLVxlEI97YYHYpD/lAp4LQuPEY\nc6pRaULi3t9LC1OOy7oClDNGbfOsvexTJYkxRVeWcUuTZhldBI2HlJschfQiSzYXVivGCaxSgkqp\ng/jcsypx2p6lOINKF63fwvtJW2ORebhEJCJx9SycbHDdaSXSZ0Wxt9tHnLw/eqNywixykhppJeAq\nsuVdZ5OiR9aFbynGylqG4eak7USMv8bQh/DSuIR4zDxfrz3CfKBbtCxrYpYt/D6DJb/qfZjNmXVD\n3CKsSjY9bSrR5kMqAyQ8rMEEPI3Fps/SaOvM4Vymgh/BmnU5Q6TcK6IRict0XLwii5te7OamtCz8\nPosFi0kagf31E5zxZAWnc4jMPyeOEEBfB4ixfNKdHfitPeexeqkypntXRXDufvZ7EJke7NpD7sMJ\nWlTD2y3L0A7JNHDTi914aoFy0flMhWByUOIxuqIRpbhEaUL5L196lPaOHPR1e5eMqlL9mtuPsN6Q\njp/Cd85+vEQfr/n2IJFCJ4D9nvLDL0offvFTBl8vz6K1M4cmStNKF1y37797TqrEVTPN6+/lh/Kd\nbItX5Cw1i2hkc3xHZllCeb+JmMR9/+xnXQ501Wh0p2WDLROLSnkZniVxCb+0ynhqQdLRYf2Vj3Rh\n+3TWW+oioBQRoRmMxFlDisU0fZZGa2cOd73WjbdUKZCMwwAAD7GoZLpXJ73bsihj+EmDDoKftmep\nQYdIFKmMzK1OSey2H1dl8feHlf2LCMaTwIwX9o0dWN0mQEln7lstIRKRlNRFmtEVoMup2+mcCOAW\n7nrNeKgyOLoCeuQqdQycpVZtL6EYXV6aTGXM2TBkH8nJwKo25UUSxqvO6HLHLgXs7ctvV+bw9ldp\n/Lw2h7tfNwbbYxGY2OFFQle4KDq6/oDgRfWnj9cjenWbm42+z3/MCmng8OCGXcVu5ltvGMMxk40G\n6GET+Qbp3JaUSVTStk2SfqI+bz6xUGIsKwuS++U2m1PKwFtpo0wfb3yuoZSeiZeURQK7qosH75hA\nTbmEQb2jmD6+xGAgHmrRz47aZHTB3GIiJw3WSbDDqvS3dg3BiAnZbEc50EACgMfeyn+a5FKWBTGg\nR8RyPBPnFK3pkfEQDW3rlLHFEHM/HDNZ1xpi9VgIdtiE//mH3xkPVCfd0YGDr9cZQFkfGF1e5pKX\nUSNJ5kOGU6QDYHT9tk7Gibeb00AI/v1KUhVHFTeveO+IVLa0wrsOHV1BgLf/2OmckbVxn22V/XRV\nm4yT7+zwpB9Ca+GQ61lhE1VfiN2j3Ti6eqkO2PVc6s7lg5Ol1U6OwCncjM62TuPBOWIz+Q/Y3vt+\nR0DWcasKaflgt16Qg9Gxt3TgyJvW4cLHuvD3hzvx81qlUY2Nn8dRvcn6UezI2V/71kQsJQ2Ousl+\n7sqyklrlZe34eIlx8yEOJafzpztl1r/i2bD0AZSsrVc/05033fSzpRnMmduF655TWInpjHe7Zli/\nKHbeiq+9+lt7Dn9/uBP7XtmOu15LYvb9ikPHTdVsHmbt4l4bk6QQsrY3oMuGXH5YOaaPL8Hw/vqN\nvf+tWJm6ZNqeUTz9unXaWkfGmpa6yHNKCJh7B15jZuC3dcnoUNOwIxHjmhdk6qKdEH3QWk7sUcco\n0RVM4+R8NVDdoxIxsz6uG6zpkE32MNnqszng4v8oc5uwH1lGl5s+Jq3w7JjzHurEWfd14oTbzetp\njJFBAMILyhahoOjo+gOC51A5bc8ytDQqOf2Nh1Zo/09TzjsFIr0tjTWmz5ysESQy+Wub2WAnB+ea\ncgktjTWOBI+dsXOUA5lTcVgCRYzeeTsEVqw1+ro0aIbcCAs9DUdpoTaR3lP2KMOL5/NT8DYbxD9p\nO+3beDS/eKkVhveP4qAdjIe+OY/xmSiXPdGJ2oZW/NKaw1MLUljbYX2HblJ8eCDpDn8/0FtVOx4i\nklKR5daXjJEzp5sroTuz6WIvnV+FO080M7vIdTegDNRbXnJfzr69W2FLsNhz64S2rmw+2J23Zl3S\n/qEVRqTY7i/iNHYLVpRaloHahlbLsUz/nUgKoVXq+fe/2E+AZEbOe1B2AtbR9cF3zg9AbtdjP0AO\n13Q11Eb10D+kj/Fhrj68HFNGKV88YVd9zv3wa05jaDjFu4vTSGWAZb/l75+WxhpN587OmZ9v3dhm\noxjW6xXR9ArdoqWxBjMnmQ/ATtZWr23SIFuKk55u7zYfcMYM5++lPLaRW5A9/pQ9vO0P+Zz4L3+k\nG2e/qnov+12lHMh1hrr35+BpLBLM+zyNI29qxwFXt+HD7zKobWhFbUMrbnihC+mscuj3wgatYRg8\nblj5AGF0GT8byUnDvOtvOvOIniOH/NPeiUf05X5RBay//yVnkrVwA56ztTst4zJV04pOf61taMU3\nK5X37HXfm7p1AuVU/zixK8gt7s1xvJPCLL0EGMtWoDWL2IrCdLo9AJSot8ZWSfWC9XpFTGL+sgx0\nMPZILgdMVh2VUYmfahaE66fTxi4KOtmNDcKGIUbPshhL4pIuG+Kyza+XZ9HeJaN/D+N4fegNZS3N\nUROCyE0Qp/LMf61zxGalQcYEOX/zZBx+Xqu3eYpapEkpSkXJ77hqtQg/UBBHV21D62m1Da2f1Ta0\nfl7b0Hq6+tmc2obWZbUNrR+p/+1Bff+82obWb2obWr+qbWjdtRD3/HuCmwiQVZU6P+BkY33mPWXR\n+XYl31q+/YQKPHCqv7osyYy5gttxDkp/xyJUSXnq4djnlGUZD8xL4qvlWZx2d4dmkFqFpO3ywe20\nO/Lhu5/VKns+M/XskM6KMVIAoIypKPfDrzkuY4+UuV+8wkF6hc1YXP5b/pOaiPYYjZtn6UYcEaaf\n2+LNw8zTYAMUJ+NmHEeTk/RNJ3M2H3tOFE+8rVO7k2kZybSMz3/MajRzr3CankbDazTdCq98nLZk\nEpDqh6Ki8JfMcH/Y9kOjC1B0DMPGybubmQtOncVdKUXnh3ay9aqK4IajK3ANlWZ75cxy1FLismyK\nppM1hAZZu76iUpx5z7FeT4ax4sKhsGJNDne+2o1Zt67Dfc3d6OiWuRXn3IAXv6B1XPzE42dXGTQb\n3cRO0hlzcYULp5Xjao7GpxPkG07ELvDKSpQkCdcfVW7JCHvmXX2PKGXGnoi+Ko3LORUvAaVy8NfL\nc1ixRsb/PagzQx97K6U5Z7zsBz2FJC9k1QFl/Pz8A/VnmLxlHNceUW7QBhtpIfpPrtPWJeOfz3cZ\nKv5JkjfNHhY8P76S0sT31Nz5quL5E9mD6PV46aocnn/f3tawG8cn7lqKa44ox5ZD/Dcok9T+s+1G\n9te3ZHR58BBkLNJRf1lrXNMUNp/SLsvoEsF1z3Xhiqc6LYsCfcEpqsBDEM6Rz5Ya27Z8ZoeN/9ae\nw9E3r0PLV9Y0NRIgJM6iRAyuK1cTEPLE6GH88ZTN6hpeo9UgCD3uP/hWn5fuspOUnzMnldhWGybP\nGIvCoBVWTF0MH6E7umobWrcAMAvAdgBGAZha29C6kfrr61saa0ar//1X/f5mAGYA2BzAbgBuqW1o\nLUASxO8HboytGTuK0/YJ+qi0ZzeRV1IN6dCJ/NSNLYbE0Kfa32HIO9QdVOvA0RU1V8/gYeVaGbe+\n3I2jblqH977JaEyj+RbRwMF9ItxIJCCmf7ZGbXeQz6kqdhDVGAKAcs6ruPQ/ChMmmZbx/jcZQ6Rr\nVXv+kcZLGyA49S7rtC6C1eqmKXKY2HqDqG1aFIHTbZ3dWFkMVA/JJFWZt1l7eVOZrLheFot1qiMz\nl5Nx7XN6aP/Kp7vwjpraZlcNzwnYYTlhpNIve2+rj42jdzIOProKlBtcNN3obKILZvzvE93QW7Mu\np9H1rTT13CLfQYGHTNZezNopCuDnEqrWuqpd5gZ7tt0ohoE99XVzwsi4gaXKzjlauNyN5h+9D23M\nYe9ee6SR3RCLSth+Y2cv6twHOnD360l8/mMWt72SRGunLMxecvp+SQqUCNbrFcHJu5dpVetI9692\nsN7ncmaWVL+aCMZvGjcEtVjnotf0aJGKlgTjRsQxdRv+WCbsIgBYSWkIZbIyOtS4gFXVRafYzMIJ\nRDSRlPsw/k6rduxh7TjWonCFk/nzqrqG/vdD46G5nAqSlSbMqfKTNrdfz19emMLclhSefjelHewj\nki4KbndwzQe3gZZPVI04IUcXMyToiojLfjMHELXgGccrl4hJqLWQHiB7qVekOMFnKxA9JU2jS8AJ\n+UurzM14YKts00ViWI0uL2jvkrF4RRaPv53Cs++lscwiUHK5XQXLkKk/Bh0pD3/f+GQXFi3L4uz7\nrFntWnEydcwnYjqjy608APm7yVvFscl6EVPBrbUdssaaJHv7mnXGC7txnhKm4z+mlavPIOHfJ+Qn\nacQi5tTFoqcrXBSC0TUSwIKWxprOlsaaDIB5APa3+f4+AB5taaxJtjTWfA/gGyhOsr8s3FCduaWP\nPWL/7RUjTVscHCwSpXHFeTCot/vdnOcQcdJmMm0WXq4okfDWZeZUPrpyzSsfK+kmi5ZlbYVMrSLP\nVrnmiZiE20+wFhHnwcn6SyrVkbQXUTiKaghqDAFAGcdgf1MVRz3wmnacencHdr6oTfvdlU/lL2dN\nSorz4KS61p2vKacJ+mDaz6Uey43HVvqanqVpzeWZOiQFmC53LAKrwgoiuOwJ5R12McG+lxamcaWH\ncuU8sAeNCw4qR0tjjUEf6didSw2pGXbjxg67jEoYUt9oLSVygEplZOzZ2I5rn1VOj2mfWIN2ekR2\nYNMtvaAQlTErSiSD0DPg3BBfvDxruV5FI5LlHGdTs91G+LVDNNVffZm2nphdhaF9zRPtuiP5ewV7\nC2wlwM+WZlFRIjq2nH2v0ULzyQuII5IM61tf7s7LoMvkrOfBkfWlOFC1Vdi0Ja/O3mweeQKnsFrL\nv6EY72uoFP0bXujW9j9eIQo38JJ+SBxAXhhdvLHtFE5EunnVJEvikkGvlgVJZe5O6/aOBN2hd8AO\n3p3qXrd+N9U/TW1y5ms2p7CkD7qmHbtd0mb4XSZndDQ4xZUzKzCgh/kBnToKUhmjo3bEQOuFZsuh\nyiTVqy6aGV1Omv38R2XwvvZpGhuvZ2wvy9x4KqszydgiQl6YZLuAmf04AAAgAElEQVRe0mbQrrSq\nOEr2U3pd4LG//Nbr4qVmij4zmw7KAyvzUhL3zugi562acgn3nFylsbYIHn/H3On0th6RqEwHB+2R\n/hlHFT6xS9nPUuzJohh9YVEIR9dnACbUNrT2rm1oLQewB4DB6u9Orm1o/aS2ofXu2obWnupn6wP4\nkfr7n9TPTKhtaD2utqH1/dqG1vf9FoH+PcHNJkUfTA6vE2N3sQ62t79O4+ib1+HmlxRD7Lufs7j4\nP50GQfdMznvE6snZVZ7+zipNh6crdd/JukeejJmjb16H7y3YJU8tSGL/q8xiloC9AzIIeZpU1py+\n4RRuHW96m3xBbDewOiy3duYcRfPdgmjTfbY0g2ue6cI7X6dR29DKzdGn+/PB06rw9LlVeP68Kjx2\npvv0WlMajctH08uP8/ubGCOlCQmPn12FSw+2OXy6yAuiafxe8NL5VdiQU/b5jS/T2OWiNtPna13q\nH1mBnd9kzo0cFMOdf6vAE+p64leqr9U4/uDbDG5+sUuLOP7vY2UAEraoiPiqXbuAUv2LgJ3jfqRj\neHV02R1snOCcfb1pI3UmZWw0wHoDInOch51sdI2cgnYQDO0bxcOnV6L54mo8ckalgVHmFu8uTnNT\nCkVTjp3uU719Cq4Aun4aPX9/5jCrX/4ohYffUAISWQ6ji8ape5bi0TMrTfdpuXflmRsk9UQ0kOHW\nSf3O1zr1RFRjz8vYIIfQUo9te3UMZmzs9+fOq8ItsyqwrwXT02pcZLIy/v2KMn4emKeLwr/9dUZz\nGotIfXgVmE4KaFDxnvX/Huw0MIwPvLoNtQ2teHpBUnPYelnHRbaPL3/KGmyrW47Lb0/pqYve2lyq\nSke0dcm4ZVYlDtheHy+07lcuJyuFQ2hGF8+pJtAB7d38Pyb3RGd8aJXfvTeXF/lSde0C/VZwwoJj\n5ThKYpI2/t0619jAIa8iNKCnLwLGOfrmorSrNu94VVk7nBJN9D3DrNFVFKMPF6E7uloaa74EcCWA\nVwC8BOAjAFkAtwLYEMBoACsAXOvh2re3NNZs09JYs00hIs9hgSdGbwXaeDxS0NHF9umz76WxaFkW\nD81XDnL/eLQTLy1MY8mv+oqnVFPzNqury729xFTGzOiyboN/bxf/h0+/vfoZa0VVNp2Jhlfxdjtk\nMt6FTHlMlk+XZiy1BAjSGVk4smxl7N/fnOR+7gc6kzJOu7sDTy5I4cx7lXd71E3rMO+LtCFNku7P\nylIJ/Woi6FUV4VYyO35KCe47pRIVJcD1R5mdTAOsKpE53FzzpS6Sy0QkJQ2Ie5Bh9eUctJvJuVtj\nWFSXR9CXk4587gP2Qu2iYKcCvV5tNkhPVfOLdWd1iHv5ozQeeiOFlHpIJI5WUl3t5YU2pZYcwO72\nh/aN4Mh6ZVxuMSRmMPL8eGyv++qg3mIbcr7KuVZo7ZQxrJ9122SO88AysDQ4mESkIMTFM4zrwrB+\nUSRiUl62C08Qem2HjC9+zCCVkXH6Pfy59MOvYrQ9p4wuVmhcBGTdoq/Y8lUa3640PstFc7tw04vK\n/puTZds0y1hUwpA+5j4mh1m2EAEAfLsyi7cWpfGpWi1wxZocXvskhWxO1hldIVeGpVOeRIIPgLe0\n/Ga1mJBXB+odJ1Ti6J1K0MPleCHzo+EAs03VuyqC0cNjljbV4XX8aoRsGiQNLUVTwJlYgFob3Pn6\n1qIMrnxaZ0kvX6M821XPdGuOBr/OR04cBbIsm5xHFSUSnjzHPpCtpS5yUtucgNa6Ky+RcMKu+rig\n9UBZSYFIRKyKN8+GXmahc5jNKWsp/SdeKgK6hR+adCw+XZr/omyl0UScr8HmSh5AvdZJu/HnPb2G\n0kU52ErgfoOsB0WNrsKjIO6glsaau1oaa7ZuaayZCGANgK9bGmt+bmmsybY01uQA3AE9PXEZdMYX\nAAxSP/vLwmvqCity6hZ2myPZzJT/1z/PF3l1CycLYL5SxjQcdaXDDWcwx7BmsefWZkvqrL28iS2L\nMLp4B5XH3krh8bftxUzTGXFGjNV4eORNgbKgeXDO/R3cMXHeg52GNEkr8MbJnmMTGDEwiv9dWINx\nIzhl3UnasMdpRzZyK4fKnmOVaKAfFc9oZLIyYoLv+Pdg9Fvdg+hhVbtOnoMnrY/ya2tO1/kRdBTb\nraeSJOG4XUq1aq4VPlScM7ad/3q8NU6YCcP+uQtnsVcGKpsa6AYZdW1e36N+4vmc6q/H37YOx97a\ngWuftU71FT3ARBwEZHpVSgZZgS2GiA1owhai3/FD81OY+S/rqnle7QqSxlzHYevN/Nc6zL6/E8ff\n1oH3vsnggKvbccGjXbi3KamlfInOXZFpICpGL0mSwfHtBCSl36uja5P1ozh251Lj2uzAuCFr5VCO\nQzIfePvh8t9yuMJGAkEkRZPA67vd0oGupxWstqB3F/NpUESWwFPg1aPjpTutOLm2GmocwJaBQBXE\nzuSmLjq4FzJfCFuKTuu+4FF9LLBVTaMRY3Ejtw4n3r7RaCHPQORHJlMaszyJAb99Xmm76k0IzsnG\nFkMoiUme91ndQam8t54WMhRbUuOOPQNoqYsBPG+ZSiBkNbpkoEjpChmFqrrYT/05BIo+18O1Da0D\nqa/sByXFEQCeBTCjtqG1pLahdTiAEQDeDfN+i1Bgd65LZXSdiQse1aPNmZwsZByO3cDZHz/6ZhJH\n3EjKcVs7gJovrsb/LqzWnBBOIthvLsrg0TeTmH4tP2XRKZouqsZ5+5kPMPtvnzCkHAFKRZHahlbs\nclGr6fsESoqZt3upKJVwJsfB9s1K+5NSKuuDxlDAazxPmP7D77NoFUiR4xmG+TZHK0ai07vIZ3wf\nM7kETRdVO3Jm0G1e8VQnLrFgLAKK8cUTq3WD34Ojy8qW6OODkDaQ32F2zTO6cdvWJWuOMa+6YARW\nB/zmi80ahP2pw4SoUDlgvV7SWoclnPVBVNvIKrjT1pnDHpe2aSwcGrmcjKxA6nyZhVzPPle24+Mf\n7PNpkhkx8f/tN44btEAAYFWbMoufe9/6ZCAq2cCOLV7hg56VEiRJwutzqvHSBdW4ZZa3NHgCEoDj\nzdeDr1f23O9/Nu5LXpniR++krJmsM2Tq5ca9/afVentf/pTV9VYELWaR841X9jYNL5VpATGmE2Ae\nVx1JGbtf2ob3v+HPoyyV9uMHPvrB3q55a5HKXBOYs14D0CJVDt3OgUxW9jyGvWrBtql2l5OA3D8O\n0u1j8mx3vpZEOiO7dvaQMXT23nymz7crs9jpwlZtrtOpi7x11Gn7L33k3HOTzSmFfw7aIaEVziBO\nqCBTF2ln2l7b2E9up6w9GrUNrahtaMVpdxsLQbGpi4mY0teZrPv3m+RUo71wmvl8ZTunffBwWdkJ\nNar9/+nSDLI5SouvyOgKHYVK8HuitqH1CwDPATippbFmLYCrahtaP61taP0EQD2AMwCgpbHmcwBz\nAXwBJdXxpJbGmmA5h38yXH5oOR441b3GEAs7I+n1T/XF3ZC6KMjoYlM/fmmVcf88PX3w/W8y+Gl1\nFv/6bzcWr8ipQpzWzoFETEJFiYR/H1+JCw4sMxgKD56m99HKtcYF8F//7RYus14Sl7jGkCRJJiOA\n0Ow7qGy+Rcuy+PIn3TBMZ8XSGco5wsWvfJzGE28n8cIHKbzzdRrXPdtl0FxLZ8Qr8nk1tq+caS+A\nfNvxFbjh6ArP13eK8w8swzn7lKKvRcqTX0jlqXglSZLlOL95VgUunsFJpZWVlOMX1fQ5WZbx94c7\nNPFnWZbVcSV2717ewRWHiQlcs1PLat255OByjBsRE14T882DD7/Xt6mOpKw5Lk7dg294OwXP6XrL\nrAquA/qsvfQxMK3Wu9AyAa9PN+gfwV1/0/vyxF1LscfYuOF9+u34lKEcTu98LYm1nTLupdKeP/g2\ngx9XZbXosdexfOzO1u8pX5p1KiMLV8nzss6KOgbYoUUb8Y+dWYmG/ctwzeGKY6s0oexbog4YoovE\ncwIt+TWH2//XjVn/NrK7crK3NYasmfn6ibZncrJ/Gl1O388dJ4o5D63ghLHHQ0os29rwrpIZpRJy\na6eMU+/mV0TWHF0hlXm9S5C5Bjhf4/YYqzsWjpksJifiZg70rlKYJV7ttysOK8cuTBDRiZugm+i8\n2Ww/z/xfFU7Zo9SyCvI1z3Yh6aBAAQ3CBKPf6RlT9TV9bksS3Wmg6TPFpiYBmtKEZGjLrSvkn887\nL66TUc9HkiRpgSg/0gr//XI3Fiy2nrR0G6fuqdgIdMVwP1hsgF7R9avlWbzyUQrXPaf0DXG2knez\nfI3xbOUoo0Vtk3Z0OQn0PESd8/JVdH/90zQenJ/UHHmbcirXPnhaFYZz5BFINfSFqh14/fPKWUqW\ni4SusOGTLK87tDTWTOB8NtPm+5cBuCzQm/oTI1/JZaewi1hd8jh/cVccXd5nda/KCPr3kPAz5Xj6\n98tJ7LV1Aj0rIyZD6cWFaZXRZd/mwJ4RDOxp3Hl5i1VYsDM+iKPp6JsVY7+lsQaAeAVEngMlmQau\nfc6oQ7ZerwgO3CGBWFQpBcxzkLmBV9uV6N5YgVCUX1zoLQVy88HOLMDtR8SEKl06NSKI8eDF+B4z\nXOmLJ/N8r+mzjPpfO1oaawyVYkTgZMqXJ4BNB0U1rYRtNhTbjtg2rdIzelZGcP1R4gdJNwf8tk5Z\nOyz7nWoKAKOH8/uO1rYSLSIB8A/qVxxWjoE9I5gyKo7vfs6iolTC+QcanZZ7bSPuZKORk6GJSQPG\nd3/KXcqe8L8LFYabV0dMWULCAdsn8ASnelO+kKxSEMVTsxqG9YvgrUXu/kb0DbNzaDClrTa4T9RR\ner5bJCgmBQ/3NpmdihnBAFq+9emD78wMMkB8XXRywKnbPIbNBwdjmnvts+H9RVmoEojLIJVRWHIE\nuZxssi1FGXRjN4h60uAJ2tF17RHl6FUV0QKZR+8k6Ohycbt9qyOq/qa3Z+xbHcEBOyTwv0/ceT2J\nU8UuKNu3OoKDd7TuCzsWqxUIa4leh3cZFcf1z3cbrqnpRqnfqyiR0JFUgn6SJLn2dLkRz89S7Hmt\nyiQZtl4U4aEw1e6fl8T98/Szgvke9QtWlEjYbkQMHZRgvltH1zoLsX2CM+7pwFqqmizpa/Jujrxx\nHa49wp1NllQzd2g7b/Qw87pJFyEAgOH9o9hmwyje/zar679Z3P75jyg2Bqn6PGGk+foDe0bw0OlV\nqG0wZt+QNW2HjWN4++sMXlqYxvB+UUWM3tETFuEX/sSS7UX4DTfnBRJNyAoKWwP8jbkrBfz9YXM0\nsDslI5XxZrB40S2w2kjcwi5yefo9HZh4ga4jRRZU0TRCpwLPt/+vGzvNaUNnUkY6KwfO9rGKZjsd\nR179qvk295bGGrQ01gg5udyg2weBXBb7XKmn6NQ2tGobOQDc8EKXiVruFU6YA6/OqcFpajRx723j\nwg5Ur6kjXuFmXWvrkrUIs+hhuZDgrcUkkDFnejnuP9UoMEzmzCiOAeoW9JD6jBG+5aVLZhjhWy84\na+8y7DraPAFJa3e+2o3ahlaTeHHaovKvG3gJEIlGillHSEWppL3DoEDadHPv2Zws5uhy+bdkLIky\n5thldfKW5rF14TQxZqsd7PrY7h2LVtm0205OurNDS3U65U4lmKfpGXps9oIDvfWhWOqi9e/W7xVB\nS2MNdtgkrrEkp4yOCxcpcrOXpDKykroosB6ye97jb6eUCtbLrJ2K+YrqeIETP0yaY8v0qDC/pMfe\nUgIZXWpRospSCTlZOWN4QZVKGvvHQWUG1vgLH5gvmKHWMfJe0oJVmWmnU21Dq6Hin9Yu87riURgy\nN2i4Ye1ZgXZyAfo7Ic/c7YEx+tD8lMmpuJ46z8YO1wfbdhz93Hzzru4frTjzXv18SYLOTu3inpSU\nw0EUk37ximyR0VUAFITRVcQfE26Mw9c+SWPciDiyOVk4bYW3Qb79dVqjHNOIRSUk095F2pVSsPm/\nN318Qitv/eiZlcJ0Y7tDs1VkUoSGDjhPeySb0NoOWT3AeW8TMDtBSHSFYMP+UVx/VDne+CKDJxfo\nxoFTo9ercSxQaCcQaJWgBA7MRHxYdnCJx95KYeZEJaoadHrqo2cqBuCIgVFce0Q5xm4gvhWFrQvG\n0x7cYZMY3v7KvC7R+nCiDhC3uOfkSt9YZLy5FVaF44hkFAmmEYsB73ydxnkP6Y7bTpUIJHrA4j1f\ni/qO71NTGNNZoIT63mufCuZ6wVuASNSANqf/Bj9WyX7g5t5zgowuN378d77OYAOV0SQaAJCY/pQk\n4N6TK/HhdxnstGUci1dkhVhF+cDe/lUzy3EOpxru33YrxS0vWVeYdt2uzbv6mNLPIkw6vzW6aOyz\nbQLPvMf3Yoj0vd34ve0EPXg3pI9i34waGu6e993POXz3s5j8htX4f2dxGptw0roAM2OKBqtN6yfY\nqnz50KY6iCpUYllHUkZ5ieRasHyvbRN4+I0UdmUcmZc90YU9tzayi2gbntjjWtVFZ82ZkGNe8Wuf\npDFltLFdVvA+HjV+5lovy+V2V67eDn2vr/qwZ7KYvQ9ffoCdq0tX5XDyneswc1IJ+lRFkMoo6z5B\ne7fzIOVtJ1RgIKWNSq8pmawcyp5ahBFFRlcRjuHKEFVXymxOvFIRb4O89tluLtMlFiVCwN4WE14O\nNovNBkVx2p5lWgnsIX2iedPq8sGtYyGbk5UUTYFm3Ua1u1KysC4YYDZeSxnjMhEDxo2I49CJJRgx\nUP+y0/HnhE1UwWHJ88pCBwEr2c22zhy+WZHV2CG6GL33tgbmqWzE4ib1cBMka++Kw8oxhEqB2mGT\nuC+Hu7DtB9YRsen6Ucv+bussHKNrk/WiGNjTn62e917D6ne7Q286I+PMezsNBjc5zMaEmVX8z+mq\nmsmMIjbb7VJHxku7BKTaIc0KEn0XTnXu/AQZU07vXZaVIgNe9aYA99pPD7+hjCXR/mCfMRIBNl4v\nihk7lqBfTQTjN9XfJY9JKAp2/laWSpi9T6kmSN2wv8JgHNrX3xfv1tbICmqi9bYpOCJD1n7P2nsi\ney1vSF1wYBkmbxk3FSAZNyIuXAUdsGcxE40gP2FlF/zE6Nd2pWSNWZTJkL813+uwflEM6xfMhqix\n052u/+rSTYr7kFQ+t2ZhTlYcOcTJNYwzl2RZxqq2nEHDWKsymTW36+YWMoyja85cs6wMaYPIdcSi\nxsqAbj1dRBh++nizRAGPKUb6Zt4X+ob91AL/qq6fskcZNlkvgt3G8CUTTtnd6ADL5hRCwRn3dHKr\n/d7wgtKHdnbxUfUlOLK+BFsOiaFPNe3o0r/z27qiRlchUHR0FeEYbmxDskiLRl4Ba2OHW8b3iS6k\n0jISHg2WUcPyb7pjHFaCdAO3Bl1HUo0GCRzi3BqfnSlZWBeM1y676BPjbWDPCO47pUoTb2UdYpbX\nd/C1Z8+rNlX09INVZId8t7Xbpe04/MZ1eFY9oGuMrhBLnr+kitR3Ch7Yrdrda5s4Jm4mfoB796qr\nsLSpyfCZ1TqztKkJ7151le/tsdHt06eWYrPBUfRZMh8j3rkBADB2eBQ9yiUldTGAFI6wUWhGlxV4\n7F4S0RdndPEbPvSfehpwKi1j10vacNTNZiPZe7v2v7/m8HK0NNbghF11o31rUZ075lnDeLdu4ybZ\nnLhdUaigusnRZXMfF04r19IJtxvhz97Ec2TuN64E5+2vpPpN3SaBC6eV+1GMzNSOU7z5ZVo7dHt9\nx3bMu03Wi+K6IxWG1STGGeQ3o2v3sQlccnBwqahW/TNmeBSNh/pf0MDK9nvhA6MxfsBV7ZhysSK3\nkfYhhdwLSFobGwy2svGHq8FqzdGV9DYJlIqw+r95ffbUghT2vqIdi1dkTWl8LNvKLZzYbsT5eMIU\nZe9QGF0WAvwOuoGcxcZvYrbtrn3WyAwdROk+iu5XVthk/SjuObkKZRbO5A0HRNGr0vlc/3q54j20\nY1nP2qUUx+1iZpDRpItPlmTR3i0XNbpCRtHRVYRjuHGMkKpuomL0gPsNsjPlndFFFn4rbLtRDMdz\nFrOw0dEt4/Mfs1gmUAnSrRH55DspVWRZVL/J+t9PzDZq/ADAufuWYe5ZlZoBkvf6zHPxqs2VxICr\nD68wRHRP3DWc9/rQ/BTmfW5N077lZcUwEBGjJ/BagbJTMGuFfcfHT1EodH6l5QzYdls8N22awfnE\ne9alTU14bto0DNh2W9/bY5lZEQnYfO2bmPzS0Tj2hFrMmV6Gyw4tR3W5pDK6lL8JW0vMTxTU0eWy\nHTJ/nGoRWsHq+Va3yxrzhByq6IrD+2wrJsCfb98kB6T1e+k3eNJuYmsY28e/R0ZXOqswmkWq63r9\nWyeyBrbtunB0ETwxuwpXClak1dpjGrTqB78ZB25swE+XZoU1unh49v+qcOtxFdh3uwRGDIzi4dMr\ntVR9AjGNrvDXddafd/GMMjwxu0oT9n5idhVuPKbCNxaxnQNxl4taceeriuGwlkrV17Wy3LdnKdbv\nwPlyq2pHsY6m64/kOwAnjFScNKT64fVqUSYtdTF/kwBIoQy9n+j/r21oRSYra3Ikv7bJmvMkofat\nJpDusD0WT7xtLt6xcq2+cK1uz2H2A4r+FOmbGJu66LLxH1cp1+cxItk0YXqaHD7JezGGHuUSxgz3\nPrC9rC1eiAVsn5BKlEWEh6KjqwjH4KUK5KPXi1ZHArxFgrxS0PNpcFxycLmwTgfAZ4hYgWaIEHzx\no7JYLvtNwNHl0pp9+aO0L2L07HiQJGDO9DJcNL2Mm2IVj0kY1Nt5o6y9OXJQ1EQfj0QklCUkQ0ll\nP94rDzybgdYSWrk2h+9+1q2MdaqTiQh8lgkQoLza3n47B2aML8F+2yVw7M7+OBOH1Ndjr7lzDc4n\n9lmJk2uvuXMxpL7e9/bY6N6ad5rx/PTp2O/xuZgwbWdMGZVATXkEVWUKoyvlw9wpNHgH1rAOeG6b\nIYxIUX0yRwxRypgnqcd26VNOwNs3iSNr+viEJmoNAJcfWo6/H1DmQxEJ+38HAeJscSrM3dYpo70b\nltF6J7CySYb1jeCmY/WDMBGWJvbEej0F+zcPm5mHgT0jvgUInL7fHTaOmaqVicCNDdjRLQei0dWn\nOoJRw2J6Slm/qGntEqlMW4j4BTueNuivpKmTtMiBPSPYesOYIS1NZAzb7V8dSeDu15P44Fv9IJ/L\nyY6qLlrhsIliVSkB857FSxnddiPdG0YyB774yRu1KpszCv6zYvCLlmUNzrd1SaOGGU+M3o3jida7\nJbjz1W78ti6HJb9mcfdrSZN+ZTwqIS3gfyHpiT0rJZy8eym2tsl6ofvGas138rzlJUC/Gu8LhBfH\nqxfdTN65uZi6GC6Kjq4iHINndFw4rVwrvXr4pBIcO9m4MYlWRwLc62kAwQg+TxgZ803UmccQ4aHP\nkvkY99RRWDNwjOHzLh90G71EtVO+iNEb/x2NSJgyKoFdRvljWLPPFZF0I6J/jbHxkGS5bLH/Ve04\n7AZzylNXSjFExIxvb3+7/cZiL5lttiQuYfa+Zb7NH8DsfKIN2j5L5vvm5LJqj3Yq9FkyHwtPPJjb\nnsLoyiGTEde3KzQKm7po7ruTd7d2nHapKRzCTlsHBvH98/QoOq+svRewhviZe5Xi0IklaGlUqpXS\nh4RJm8dNQsdeYNaQCn68kinhtKmDrlVSRt/80vsmaDUNr5ipFMYY1jeCiAQtLTSZBrYaGhWukmdK\n0w95OTDtjRY3EItKOGtvpSLuTluIp5q7ec6KUklzdAUVfOLBiWyFHQri6HI4ngZT6WI7C9hZTpwD\np9ylV6t78I2kFnDwInlRmpCwzYbBR4doNr/JmefSRswywf0pTH9HIsY2vl2pDHZyZtEYXT7appWl\nEg66ph0HX2+0M4k9Eo/ZpC46ALnnHhURHDKhBDceW2nQ16Ux1Yd9ClCqzosEDr1kGnlpr6b8j23z\n+YFmqblHs9T8eLPUvKhZav6yWWreoVlqntMsNS9rlpo/Uv/bI6j2i46uIhzDyjFy2SHlePmCahy3\nSwmOoqjGT7+bMi36XuBlcekS0BiaM73M9FnzxdVoPNQ/rQUeQ4QFcXIt2O8erBo60fC7F94XF27k\nrfOvXliN5xvM6YME6ayY4wUwG9d+Rzd4xl9PVQz26sMr0HxxtfY7MkrsDsxBQZZlzG0x08wJupKy\nEGsB0PuCV3XxfxdW4+ULqs2/gKJhIAK3bEGvoOdRxeL5APR546eTi9de9LN5hva2u/0RbnvJlIyv\nluewaHlWWN+u0OCt5WEd8Hj7T3mJhEstNHAIM9Kptp8V3J619ZQZfxldYbKrCLxEsN23qTyY0yWD\nMETY0vJe2qTRdFG1ViTj/lMr0XRRtaEq2CdLBMVzYB5LIoL6frSfb2w3X1yNi2aY7SHX7TLjyG6/\nrSmXAq26yOJfx6gMPkHHQiEcXWwQ2MpGf+SMSuw/TnEwiNymW8fjdz/n0N4lxqy9/qgKjGVS1ER9\nQDST//U51QYJC3qPfuGDlOu22DPPIROMjp1jb+nA8x+YnfQkMJLiMLpEMbclhS71yPDUu/rZgTgu\noxGlSrHGJnMphK9VuKT6rkcFfzDyBOu9oLNbdixnwoOn1EUPjveKUglNFxnt7L8go+sGAC/VyXWb\nAhgF4Ev18+vr5LrR6n//DarxoqOrCMew2sgjEQlVZRIiEQmSJGnRo6ue7gpEo+uyQ/I7nGitFLfg\nHYwSMcn3srB2zi47JxcAfOyH0W1xcGQrBNGQZR/EnQOOapvTQyRceFAZZu9Tio0GRg1sPxJtLPMv\nS8OAh0+vRO0mfO/G7Ps78c/nrcWwOlMyygSZ+1aG7xOzq1BRoszbG472X7Q2TLVNMo/Wv+twjJx/\nmTZv/HZyse3JV880tDdgAr+9D79X5upnS7NY3f47oBAKoJCMLradsgQwdes4xm/Kn1+kapZIJTWl\nXXeDeW6LcpAQqYjLazdMdpV+D4E3qa3/tPF/8YwynD5VccNpWGIAACAASURBVIaMGhrFKXuUavqN\no9RD6rn7enfAsM/Vq1IypAfGohLiMUn4QM2CZYSF7RwxF36x/75fdg/bTkWpZNBf+tcxFdhRncfv\nfpPBomXKmhnG+COH85zgyy7E4dWpLRWJSJr4tsjr5Nl+VXYxQhlo7RRj1kYjkhao9Av/PEqxeWbv\nU2pKZaSdGZc9QVUsdEixymSNa7ckSdh4vfz3TwIjmlYW1Z5TdhexZ52CtEnul7wrr4wuenxceJBx\nfT5r71Jce0S5I1Ys2/6iZVltTQCUVMnOFFAVsqPL6xrBpp7/lRxdzVJzDYCJAO4CgDq5LlUn160N\n8x6Kjq4iLMHqSNltkHRlsz231k8W2Zx4VJj1oltRYs+Yqu+4U7fxfrrxS7jTCWhnV58lRkZK+swH\nNCcXYS2wG6ZINSY7I5ccJnYbY+5HYTF6DzolbsCyiQija79xZq8RSfcZN8L/Uu6AogMyeSv+tVu+\nsqckdCZllIsyuixMFloLjdan8AthH+CG1NejbeKxGPnW1fhu7NFc57Df7cX2nGVoz8pwCnM9CRpc\nja6wGF1MOxdOU/QSS+ISelDpAfefUgkAWnl7UX0jz5Xf/oCMLpMjJoyqi0Sji/ps560SGNJH+UUi\nLuHgHUs0zbOkumz2dFE1y6pNAqtghKjzI1+7YR94CjGmlHYl5t/A9PH6frzNhjFcoQruv7s4g1c/\nSWvfCxrkzkTfNX2vO46MYbRgKqQT8IJ6ViDPJzLmeLb8zlvZRwnbumRUlIilofo9DkoTEloaa7g2\nIevM63JZfZEn1zLJptI0CcSQwEgq7c3ZBAB3qMUAykuAyVvmt2mJk5eQE7xWfExmZCRixvHXq8rY\nCftsm8AOnKqMO47Mb38effM6HE1VNCYVMSsFZAm8jCm/2HZ/Nj9XDWpizVLz+9R/x1G/Hg7gVwD3\nNEvNC5ul5jubpWYSXT+5WWr+pFlqvrtZau4Z1P0VHV1FWILVkbIyetnKZh1UNpYfGl3sQZGuqHjd\nkUoJ7pbGGhxUq29aIo6LQhzS95o7F+OeOsrAEJlz6e7as5H9Y2CPiEHk+Mg675Qfu+e89fhKtDTW\n4B8HKf27A6XZJJp+xdPQ8hNmHRLr7241NIaWxhqs1yu4pdCrLlNbpyysaSWqKeMEvMIKVu+Udoj7\niaVNTaiZfye+HD8bG3x4t+Y0DgpLm5qQ/e8dhvasmA8j1xc78LgpXBFU/xJwUxfDEqNn2qYPJP89\nv1pbK2sqlPtZSipB+bxeOYUoo8vNOuYX2PcbJqOLPUJY6Vl1q7IEIg5k9tpWc5dOXRSp8GXVbuga\nXZLZ4RQGTONKUhg+ZM4C/HUkjPsjTKOhfcUao7v2qpkVuOW4SqHrOYEbx6UXR5cp2M1pgMxbXtEk\nWVYcXdWCOkVW99zamUNtQ6uhGIjSrnJXR9W7t49ZR5fb7Ilszrw2De1rvXZcNF1x8BJm2bwvzAFQ\np+6Vn9cq30ymlcJZZG5ZgdiXmhC+qtNFM8icsMmS6fz7rNVcdlNR9qkFSdQ2tGLFGtXRJcDocuJ4\nZVmIIunyNP5sjK5WtGbq5LptqP9up34dAzAWwK11ct0YAB0A/g/ArQA2BDAawAoA1wZ1f0VH158A\noqK3VjCJPXNmJ6+yWTelj/X18hy+/VkszY7deGiDf/uN/WfixAogtjCkvh7fjT3akpFCbiknw5D+\nlBB4fDcpCUt+1d+hKKOL3V/C0OgqJNweyIhBkMwobAYR6M+uX2dAD+tr3jyrAg+f7s5A5xVW4L1T\n1iHuF8h1fz3ufnw58e9YsN89GPfUUY6dQ17bq7jgQUN7v77Fb+/8A3UKP812dQqnhSuC6l8aYR2M\nuW0zY8rKUGVZB6KOOLtnvvlY67Rf0YBA0CnePLDONL/T9e3aZA9UxClDqliS99CVJnow3u/NXBCF\n/z1a63Ph9/7LBYR94DGnLobkpHaZEtu3WkJJPJxAzbB+UVx/VDnO3ltMiyyMucLCja1DHF1ubtPJ\n3iPLxqJJx1AFqWQoAbuacrGNgx0vH/2QQToj44gbFZbPFU91QZZl3PN6N859oENI481qX3HqbOLp\nEtdvETMI3tMgzvSqMgmxqH7e8SJG7zZNn7CdSTD2bTXLQHbJJ0tl5Ly2qtVcliQJp+xh7Bv62X9a\nra+7Vz+jMNa+Xq58JuLoYt8Rnb0yZ3oZTtmjFA+dZrSFUy5TQ2ncdkJFQe2nAuInAD/VyXUL1H8/\nDmBsnVz3c51cl62T63IA7gCwXVA38Nfs9j8RxgyP4nIfRdJZ0M6u1gXNht9ZVTabsaMxikK8717B\nGhCSpFQC+sdBfMOErjDjBWFEzlksbWrCBh/ebclI2WbDGDZdP4rjdjFuCCUujH2vqaiALuwMiGve\nsMa174yugB1pbuHG0XXg9gmUlyg3nMnKwmlvvEe/+nDz4XzOtDLUbR7DmOExDOvnrlGe1hzb5zyH\nuB+gr5vaTHEOrxo6EQv2u8eRc0ikvdKxkwztzT9qBrc9Opq96XruX6iTwhVB9S+LQqyNetvGQWU1\nN0RF4Fmw+8+WQ/SGx2xg7c0SL9ph/HcQ61i+PYG+h6DYglZjaoshUWy6fhQn767s85IkIRoBkip5\nw8+KW1b3MHUbPS2rl0CqJIFbjSy/UShGmYl5lOe5M1lguwBS6q0wbkTcpNXkFgXR6HJhSxHngZv7\ndLL34NNmg57stNoSbDRAecFdKRkdSRnlghqo7D3/++UkbnyxG7+06meL595P445Xk3jjywze/lpx\n2Hixn0Q1aHm6xJIkYWcLCQs6ZXaLwVEtLc8LvBYvImSJG15QDH23TjarauybD3bWmROY9MW1HTIy\nKrvsrHs7Td//bZ3iHfRTo2u/cQmtKvuEkXEcvGMJ+lRHcPXh+vl6JwfpoFbYckhMK3pQ6DNJmKiT\n61YC+LFZat5E/WgygC+apeaB1Nf2A/BZUPdQdHT9wfGvYyq4ec9+gmx2n516sElHinewovV//ACP\nnn3pIeXYbYx592xprMFjZ1lXDfTSXtAgh9QF+91jyUipKJVw90mVpmp4bth8+VJRyXPzmCGdVGR7\nbYeY49LuMOUHrJ6rUIhb5eZwEItB2+AzOXGji+3ryVvGuRUVp4xOoPFQ76L0rEFMt2vlEBcF69yh\nHSGrhk7Mb6ALt6f/btXQidjp/ke57dGpq58u9cYKyVe4IgwnFyCms+IGTtJhydxgHTB+Vwpk149+\nNRFDqjPRTWS1I4VTF9k0swC63rQnsKw5mz3BLxCmOGv8lyWUPW8TKvU3IgHdalRdhDFnTl3kf69v\ndUT7rh8VUwvNNnbLrPIL5pRY+wdf2ym7Svn/PaR3h7Q0Gtt04QzPqd4Lt2Mu394TufZwzcl19E4l\nqCqTtDNJSUxCKiOuk8i758ffNqYrXvGULhxPRNm9tCsaXMxk+XItbGof+c6Anvo9xtX+Ahhz0aHJ\nXaoeBes2d3cmtFvbHFVdTPMZtqft6ayaOWtXLFicwVVPK++zm8OiIqL5flZdjErAU+cqEgi0w3D8\npkpfrt8rIlwUQSu8InSVPyROAfBQs9T8CZRUxUYAVzVLzZ+qn9UDOCOoxouOrj84wpowQ+rrMeqm\nR0w6Uk4OViwt1S2C1nTK116QoA/PJF3RDSPFDWvAnIpq/L0kWTND6MMjqWbmFSbjzOdR/HtjdDk9\nIM2ZVoZYREJG9YVksuJptOTZZfVnkAcbenzJn8wDYO8QFwFvnLJd5SgaLdSescHB9Ttx26Od0d8J\npHHbFa4Iw8kFiOtdOQUvZYYdu7GoxHXA+C3+b24XuPfkSjxzrhJQuWVWJW49rgK3HV9pcHYRZqZf\n7QaxL5kc1JwgQdBsQdKmk95KZ4FuRafcs/Yh4K66pJbK7YMOccEdXb8TMXqrsXzOPoqtKMvu5vHv\nIb27EHaGm/dJHMpeghV2e0/0XKVo0sxJJVolzeN2UX6+/lkaybQsLK/C7rX5cON/FWaSF0eXJEla\nhVe3yOZkvP9tFj/8Yt7nSxi21SETSvDw6ZXYbJDeOYkYJXgusN7Qcgmz98l//hJZSwE1dZHzjp3u\nWbzg1LzPlYWed8b5rV2skifAzxSywtPnVuHek8U197TCK4U+lISMOrnuI1W7a6s6uW7fOrluTZ1c\nN7NOrttS/WzvOrluRVDtFx1df3CEOV/6jK+z1ZGyQv8a58OMF5kzR62Uh/6jR+bsDhBOGSluD1O0\nwbLyDeN1+9owQ26lhFVFoihA8I4oc2pkYTeVmI2R16NcL/s9qHcE8ahymMvlZMXRJcoKYayloJ24\nZHylLp/p2iHuBivfe880TnlGPrmfle+953t7bHNRid8efbCYtYuY09+qcEUYTi4gOD1IFk7SYde+\nw18/6f1ij7HibGcTyymqaIP0Vfe18hIJo4bFUJqQsEF/fcJWuFibuQw20yE2mH2P7uu2BfO0z/cY\nG0efH94InC2oRbldLtNu2K5mUW32HvTG2f4d0ieCw+tKcO2R3hmvervmlKYwETSb2mm7VqxLmm3s\nZu/7PaR3B+00dMJyJe+Tt0YcNqkE+41LYL9x3vIIrfaeg0+cgt3HxHHoxBJtfNNOhPYuWTyN2+Wf\n/9pGGF3e2hvYM4ITphglWJyk85F227vNv2ODRLEITDIRiRiweEXOoA3oBqkMUFlqdPD1reZPtntO\n0m16tuKo29TFZIbP6Np0PSX9fFqt/ZjjzfWShITWzhyW/5Yz/a5JdYKJidEb/22nV9ivJiJ87gEK\nn13yV0Wx2//gCNNQWvNOs62OlBXcbDZOIvkRKeBUihDCnE6MLifGW6WHoovkuq8fMcMQnRv7hDUz\nhE4f2WqomPeFNa69iG7aXr/AUXMWVtGyYyaX4L/nV2t085qKCD5eovDWH5yfRCbng0YXsz6E0RdD\n6usRnzrLtUPcDbY75xzTOLU6tA2pr8d255zje3tW6U927YlWYCTX9xJw8ANh7jcmBir1fvssmY93\njz+Yu17R93jMZDHHIsBhdNlMolLqgOEmCMHb93jrWFD7HunrL07T5QkO770ALx86PXC2oBbldvl3\nIowfN2n7kiThhCmlBiemVxTK0WSF0FIX2UOlxcumD66LlrljvxY6vTvodylqG1eWSpi9T5lnHSeA\nv/cM7BnBBQeVW1aI7kj6wOjy2LefeZQKAIADdvBe0ZwHlkm3DUeDjlSsv/LpLkOI0qmJnMqY7c1h\n/fidx6aE0zC07aDxVEbmnvMiESX9/PSp9oUeeCzDsriEade0c79Psh7KBV4RL3UxaETVRv5ihK6C\no+joKsIRljY1YeGJB9vqSFnBDX2YZ6ywjJzl88JJpQgSPIYIDzyGyP5qRG6LIVHPVZOG1NdjyoOP\nGaJzHx9ozwxpvrgar82pxuaDxawWdoNxW+HF7fUL7+gyfzb3rEqN5k/y/uNRpUIRAHz2YxaZrPhB\nRCqAXtnSpiZkXrjDtUNcFGFrpHjRu+ljEV11g3yFK8LCefuXYd7F1YG2Qe8HlYuNKTMT7nrUcr0i\na5UfepFRZmDZMYlKqcB1hQsfG2/fY8dT+3vNge57Q+rrscWNujxBWLpvXhldbpyudhqCQDgpmgCH\nzRxIK87bD4vt7HStpB1dXgJghUzvDtrO4K8RjG08P9g1ws3ec/LuygLYmQS6U5ZfcwSvwzQpUCXP\ni4A+0Vc9b3++Y6fpomq8PqcaTRdVY8xwsx29tkNhL327Mutp/KezZqfioN5R03xjmc509+48p9Wj\nGL33CcCbO11pmcuMoyFCSmBZpWEshV6DOkWIoejoKiIviAG4zW2PONaROmsv3cp3Sx/OF8l/+bBg\no8xhOAOcMEQIWIbIe98orB+RaBUADGaic2s3tGeGJGKSUDSQgDWu/WZ0sf1Y6OgJbzzVlEe0g9rl\nh5bjvP3LFHq0ygLp6Jaxul02UcrdIuJz3+YDWSvK//6ga4e4KApdwSwsJyJduKL3JQ9h55eODqV/\nWUQj/lc45IHsB4PvOcKQMrN+nfX679daBXD0nGwcXXRQp9xl+/kKOnx71iGBH9b7UfIEo048MZSU\nWBKsCXqdpvv3t7ebDb/LfTyvIFVLw96bwqj6yEuxIwEcvV1+Gm4lxQryOn8Lld7tNejoBvnWiFdn\nBmcbOymaRIPWT/roh4xQ21731kMneKf8sI70jiTw+Y/85/ilNYe3FqU1ppHVmackLqE0IVkG/ztV\nRtd3P+c8hX/XdcvcFLuHT69Ew/5lWkV6U7V26p+dKeCn1eZ0QTt0p2QtM8ELeO93VVuwxivrJAvD\nfiO2RKHPJH81FB1dRdiCjnL239G4edrpSI2mohWmRdUB6A09xwhb7/7wY3/oyJxouxuqpZt32ESM\nWbV8njE61+v7N4SuZ4V8+ig0/NCfYQ+mhU4P4RnA9D31qY5gL7WMPTlEL/xesZhe+CAt1DbL6Aoy\ngk+vFfExkwC4K6wgCvrZRg3zWZHcSfsBLxy8whU7Hbwz9n3c3+qSNHiHVtLN7NMGpZkIKPvB2gnH\nGlJm/BadB5xpRNKVCNnnpY19L05Aet9rXWDc9za45uHAD+trKXmCj2+9NRQHaphRbtK/C080VpBu\nv+SwQBwEpr3P5iGDnD8EpsNdAJ3OS7F7c5HRQUAz6OgUO5HDMo0h9fX4Yetw07vDOrzSa4T0mXGN\n2PWhYGxjL0WT6PX5t3ViTgurvj1nn1Lsva1x0Gy9gd7wAEFG75RRxmvPurWD+73jb1uH2fd3ao4u\nr0WEpqtaVrJsDAA7DQa3dcpcgfbBfaKYuk0C1x5ZDgDYnWF0bdjf2E+fLHEXRO9MyULFVwpx5gqj\n2Eu+NosIB8VuL8ISLJXfTuyZ3exKqWicV0FIcu3OSw8LNTIXxAHKT5CIjdsSwjSWNjXhpUOmG6Jz\nW809MpCDDWv4ssY1YS35pT9TqMpSBE4ON6QP2MPN+r38XZJJ06TqYlCbud1a4bSwgihImxccVGYo\nnhB0e07hRjybhVValST5W12SBe/Qyqu8GKRmIrl+zzfuNKTMiFaK4sGRDk6EX+0REEvfIKD1suh9\nr2q7OuFr22FpUxMW/k2XJwhjzgL6PCL7wLC+wZqlQ+rrsc1txgrSPeY8GIhdYdIGY4aH7PPeR4Pr\npGa+E7Vx2nqFk/Wo9R1+ip1fGoBLm5owLOT07jBT50kfy1cFW/QF8F40SWS/Y2G11+47rgT/t185\nthhC6U1RXxZl9fIcEx98a2Z1/bxWmcgdSeWnHevXDrQu2APzkq7+Np2R8dEPWXz8g7WTalDvKFoa\na7DFEOMmXl0ewc5beTtPtHbm8PNaGa9+4j0o68QubWms8Xx9Hkxi9KGkLobDXi7CiKKjqwhLsDpS\ndmLPrI4UvWh4KfFLX7tsb6OwddCLRKGq9DltlhjHXm+TGC57PvqYITr3+Yx7AznY5CthL8v+6qOY\nqy4KXc418h1uAGUu8Q43Z6iinX7dcxjC/Lx3x47NIJ0xBNq4Cild0838u+tvFXj8bG8ly+3mBnmf\nQfUv77qaM4dy1gatC/PctGn4+bj7DSkzbNVYP8DViGTWq6xNmtskgeADex+DDj3esO/5neJNg/Tx\ntpQ8QRhzFtD7V5aBW4+rwC3HWVc3rNvcn7Kf/Xc0pu2XbV3ny3VZmPc+86IR1PzhOW3ZNSses3ba\nioB97pmT9AN8nyXz8fHJ/EISfoA8z4cHuNeTFUHYZuOQ+npE9zw2UNtYpGgSHYgQtTvy2eTXHKGv\nGX6yZnjXOucBhdX10+osDrymHYtX6I6ldxcrTjCrqqJu4JYFlxLLDsW5+9kLxluBpBiKtO90fDx6\npn8BTLOWb/ATuKjRVRgUHV1FWILVkbLbQFgdqb7V+lROCDIZup41ClsH7bgoVKqb0+c6vK4EIwZG\nMHGke6OfNlyGTd7J8Lu2jYJj3tDGEH1A3WhABLvFWnw19M3Ct+FuK6zhx9s/rQoqlCYk9O8haeyG\nE3YVq/zDNh3EXs4rrMCbQzyHuJ8g61M2ZEdXLGoWd2UxclAMfWu8LSzc/rVh1/rdv+x4JgxdCeE5\nufaaOxepkcaUmVcOnR7I4dWsEal3dp8l85FstE5z61/jHyPlp4duM+x7ckCeLrqPB0wwPlMYzi4y\nb3MyMGpYDD0qrOfJTlv640hc3WJM209/1OzLdXmg+3B1i7EP0x8Fpw3GL+yj/G6jARFM3jIe6Pyl\n26/+xphiN/bWRwJfL9YMd5Zi5xfCDqgtbWpC9oU7A7WNRYom0YyZSw4uF7oP3nORYj4ADBUfyXqy\n8XrihjzPjulKAT/8ksW0a9dh+W85HHHjOu139zQpLCy/s0KsVv6ulIx13cpvs6rRuPlgb41XeEw9\nJM/Kpnm6gVMm55A+Udx+gnUgxA3Yc0EoqYtqXxUZXeGi6OgqwjFYj/cOG1s7WmJRCbuPURa+Eo/0\nYWK09LrIKGz9Y3Owkbnfex71kD5R3HdKFarL3d1oPqM26DQocu2mI2ZoqQSXbvk+FszyN7rLGkVe\nU2dFQPfjL28pRr6kmit9lszHCzOsRWMJDR4AdthY7ObDYHRxCytYfJd1iPsJsjwFyXwxtKf+nLp1\nAucfKGbI28GucAX7PoPqX2M1M0XLb13AVQDZ9Yo2TFcNnYipjz0W2OGVft517zUD0A/p5edbp7n5\nsXeQ5x5zyyOGfS+xyP/0K1Mfc85IQTu7CPHDSeGNwb2VGyQV3bxgaVMT3jnOWEF69T8OC9QJQvrw\ngxOM2mDdNk5TP9tl2dRTRicwa8CCwAX4Sfu/nG+Un+g3Pn97bg+DpvR5ai6GkT4fZoCUPGspU/Tl\nJ59tY5GiSXTq4rgRYkxMtm83XT+KY3c2rwF9qiRtTzyq3vsaQWAVJD3kn+u4nxN41egCgMkunPn7\nX9WOKRe3AYCmD7bbGH8N3nz2FGl34mbhGNok7VJU5oPdq8NIPdYqDAffVBEUfudH+iJ+T6A3mydm\nV6HxUPvD3bn7lWHuWZWeIgW00VK+TR0APTL3/PRgIvkEYWot0Ajay58vOkeeO0jmzZD6euzy4GOB\nlrBnNzCR1FkRkH6cf8xh2mduS52LOukKVeXLL60VN2C1foJG2I41GprBVABdmBEPKNUPfzz30NCc\nXIDZqTd0p50CPbyS5/32rEMMh/SEWmiBB9FxTz933/F1AJR9b5cHH8UnJx3s+3Oye4LVwS7IPcFN\nEYdN1o/ikTMqMWN8wlNbpH/H32msID3gsgcDZ/wMqa/HdrcbtcFKG4LRBmPbJfNE/lQJuqQ+DNZJ\nzbbf88DjQk+xY5sI2mEbFqPLUPRltLHoywszgrWNAefPSQfGRYsMsG3yxs8z/1eFh8+o8kUnkcBr\n4CIsnd9WqpppNkfa9n8gLvwug/97sAPnPdiBjm4Zv63L4ax7O7Dk16zm6Ir7k1VugBUr75lzq3Dv\nyWJpjAUVoy96ukJF0dFVhGPQ6+fAnpG8DoRETMKg3u5X/EILW3sVkhRF0IYSLzpHgzYegmTeDK6r\nD7SEvZYHLwGHTyrBgB6F21WG1Nej/t4HlfuRc65FY91WLGUFiCXGCUOPsSCrfBWCFUkO6bmQPF3E\nqSGHJQpmaNv4MywMqa/HbxOOwci3rkbvg44L7JBc6HRN+voDDzYe0oNap82MFL2h7fbfOZB9j90T\n7LRlgtoTIlTqohMM7Rv1VOGU7t+BE41p+6Vj60LRIxswwagNFhtl7TT1E2SeZK9QxMvXzgmWSUZj\naVMT1jxxuyHFzu/94fewXoQR3Cm0bQw433My1IQWrUjshJnetzqCylIJZ0wtxQHbJ1ArWJUcKIyj\nK8eLnDlYGzOqo0tkbg3pw//jk+7swPwvMpj3RQa3vNyN/7Sk8PbXGTzxdgppVSvCz+IDBBv0j2LO\ntDJcyqS+9q2JaEW5nIBXmIN9R2RcB2kXE6Zf0c8VLoqOrj8opoyOo0JMvsc1wvB48yJz7MIdfGSu\nMMtQoRe/sCKSK+Y3BVrCnjg8BvWK4IRdSwvCLqIxaFKd8j9yznWpc7eMLlaAWLKoQBl0lbxCdDlp\nM5cLpz3Sl38VRhegjJteb96FL8fPxur/3B7YgYrnlLcrhhKUU35pUxNWPmI8pI8Z7n/omrvvcdJS\nw9LLChPREOYR27/svElnw+lfVhtsg1/fDKQdHmjx8vJ9ZoXm5Hpu2jRscPXDhhS7VW9Z9y85gLqp\nAsdPsdNf8qih+qk2yPUiSPxeir443XLS1sX/XMPN2aNXVQRn7V2GuA/MLs+OLgFj2us6SDS6RITw\nL55hztJhb+epBSnc15xU29TfcxBMskmbxzFldEJYm5FfTdl4v1GLAlF+gg7CFxEeio6uPyguOLAM\nT/9fdahthuEI4QtbmxsONpXC90s6Q4EXv7Aiki8dMj3QEvaEkReWKHk+LJuvpItAirgude427dKk\nyaIOKll9t5GIxDWY/Qa56wO3T2D+JeGsU5rjKZTWKMdaAR1dYQogk3Gz7Bil+uHQqx8KnD1AoxBi\nz89Nm4bN/6VoZX15yL2Y8srR6PXDG7639Xsr6BAmdEZXcBPJnKJp/D1ZZ4Ps36VNTWg5VtcGm/HM\nXCw+w/90VLv2iXh5xzN3BN4uvc/03KEOgJ5it+B46+d+fU41Xr2wGtNqvaWnEpD14rojy3HDMf4I\nWBcSvDWCjOPDJ5Vg3sXKPhv0GuHUTPST4cOuhWHtBV4LGYmso9Xl5jZPvbsDtQ2ttn9HUghF2t54\nvSj23c75vItE9Hb9ZnS9fEE1Jvmk+8VzALP9tGJ+8Oncmhh9IFcvwgpFR9cfFNGI5LlKhvc2g2+D\nF5mzajeoyJwfpYG9oNCLXyKAHHsaxPDd89HHAi1hT95fWClsdlja1ITXjzwEACBLEdelzks8vBOD\nkPa3iwy/y34cXJUvGpoxLAUT6eO2qf4MTaNL/VkIRlchmFxk3HRtrMzd6u3CSfciIGeOI+tLcPlh\nwYn/A8bn7aNqZf02bCL2dvC8lx1SjodPd6cfwmWwAksrVwAAIABJREFUWbzjIBkp0QIIVIbBjGT7\nl+7bU/coxdSt9QNVEP1LxlPdvY9qe9+GuwSrMcdrn4iXV18YrCYZG0yh04RWDZ2IHe54xLL9WFRC\neYkkHHgjf14Sl3zVbSoUbIXhJRgYTGEUfcmHcSNi2H1MHJfMKBNuM8o0Gtb+59WhJhJkPWWP/P31\n8kcptHcZG/FLo6tHhfHvGx7qsPyuJCGw1MVynzOWzNWU9d/1WTIfr860LhDlFyLUfC0iPBQdXUU4\nhmievVeEHWUu0GMWrF2CIEXbacN36E7GjcRvZxcZL9mQUtisQJ556iOPaJ+5LXXudc6RPl3ywB3a\nZ32WzEcy4CpfBOQdhOkECr3qYgHnq87oCl8XRqLaDiNVhoC0u0H/iG+RXh7M1R6Vz7Oys7Wqfos4\nhvUTt/oLo3NXiDZVbb0Q1wp6WZ2xY0mgznh6PA2qC3bvy9d+TBUvj4+eFFi7PMYwGzwcODH45yYs\noD/zmVIrwBKirePUJJEkCRccVI7JW4kx84DCFdVh18MDtnf2LFmBxayiRLLt46+WZ3HR3C4cekO7\n9pksy74wugBzwHvxCuvBFZGCS10M4jxEr7fZj5VMC1IgateHHgvBLi5qdBUCRUdXEY7xV3EAFcLY\nB2DYvdmoShjYaEAwD24+KFunoro1fHkik1YHpyBFJlnQzzy4zig4nE80tgeHuu4FQ+rrscHhs5Rr\nrlyIcU8dhfLzg6/yBYTPrgLCd3SFXeXRAPVhgzb47dJcSdthObs0Af7AWrDXiCQM0bCetxCBpUKw\nmQtyWA/pOc3MJv/2Pi/t0+y5oNrlC8OzjBzdSR50it2fWQ+HrBFyiBGlQnSnEzH6IMCeBTYbFEVL\nYw0qS+3/rjwhdoNn78NnddX9oxXpjPKuV7Xp7/yBeUk81qLoZiXTYmPBzdooSUAmEwyjKygpFbLu\ntF98mKGachh2cVGjqzAoOrqKcIxCOYBCZ3QVyKNHmj1771I8cKpY6Vy3uO7Icpy1tzjFnAee4cuD\nF8OXLzKp/KQZXUGLTNJwooFld8g4eQ/FiurvQ7XI6hGbAAB6/PwJvht7NBJjwqnypef1hdMcQDm6\nQmtQ+VFIja6gDSbe3NUZXfr3gj60Ku2ph7rAWrDXiKTPkuE8b2CXtkQhNbrCbTOczmXHk1U1tiDG\nE28fYp3zQTi7bFPsVJD7CDLFrlAFO8JEIYIthehPdl0K6xbYdiMWTPXLDzWm0osyeq3W4VQG+PIn\ns8r/v19J4qWFaQDA0lViEQM2TdQOr36S1hhd8YClT/zEkPp6VO47y1BNOYy9T3d0/YkXpd8h/kBD\ns4hCo1CMLloQsm7zP++QJWvf5oNj6F0VrvW//cbBpQK5MWSH1Ne7iqzQhjqbakQYAmGIr9OwdOwx\nxhF9uKG/SyJjWwwWH+vrvvkaQARr+2+FDT48E9mPJgOTdxW+bj4UwM9VMEZXqA/JtB30msybu5rM\nBNO227nrFUEe6njPS6cu0gj6eQvidCrgIbZQqYtBgh1Pdow5v8eTnZPaymkb1Hhm+zuMc95fQQ6n\nEAVRCnFGL8T4Acxi9Kye4PFTSvDLWhmTNo/jqpnlOOeBTjQcIB4wtlufrn++m/v5Ptsm8Mx7Key1\njWARBxf7zup2PWUyLC1WP7C0qQkdz9yhVb/9degESNLUwNvVg/CF1w/+K+HP6zUowncUqhohWfRr\nN4mh8dA/fvUcK0im/ynCCVhnV3TDCQCUzSRsJxcg7tgjW6CoMbe0qQnf3H8HBuF4rBk4Bgsm34NJ\nlxyGpWOD74tCGMOa3ylkMfpC2CyF0ECzuoewoI2pkJ+5UH1dkANlATxdYYjRW7UZNqwYXUGAtw9Z\nMYCCdtqyYzmMQkrSX8DTVYi0X4WNEu5iyK5LoYnRM3sccXztsEkcr32axsE7lmiFDnYcGUdLY00g\n7TpBV0qGJAF9q8U6x+3amAwodTEokDNBv0sfxOPLtsevQydg3FNH4afmuRi6006Btv17sNv+iiim\nLhbhGAVjdKkL6J/dCR6GBs2fFbSza807zQCAHt/ND93JxYXLF0q+LnIoIpv5xkfM0j5bNXQiauYE\nW22LRSEOr2GnLhbCaKlRNfy6UoVbFMN2xBRKE420G3Zxiz9QgFwIkQIwugolw1DolJVCMIAA/R2v\n3yuC/5xdhaqy4PuhUBIUYaIQTuJC9KopdTGkeWRKXVSbPf/AMjx+dlVg1Ty9rP0r1uQQj4r3jd3a\nOH5TMzeGVH8MY06Lgg58V26rnAlIgajnp08P3C7W9IMLXCjrr4aio6sIxyiUkVaog0bY+CuIpwYJ\n4uxaeOLBGDn/Mox+/KjCO7k8oG7zOA7cPoFTds+jeGoBejPvsfHGht+Vjq0LRzhc/SmHKtKl/Pj/\n9u4+uq6qzv/455unNk3blFLpI+kDFFoQSyulmJaStAgoDNBRgQ5CbXkYEIQRf6DG5egwkJ+Caxxc\n4/QnD63FcVoZHJaIDqOLSegPIuWhjoJ0/MFUWtDyUIGIhRHa7t8f99zk5OQmJM09e9+c+36t1ZXc\nc2/vPvfm7LP3+Z69v3u/p15/yOuor368TuctqVHDBP9NeKEcXX4Kzv3wHdqrCnSjJdQIat/yOWGy\nPv2qFIQIjEjd33dVZS7Y5UNXji4vpYXR1TcOcEPpE80j9L8/Pqr/Fxe5zL4ep6WvHF0jqk1TUjyO\nD+Tc//s39g85Cb7Uf6Br/GjT35xb22P01qtvONXWKLWgX7H0Xhik+7l3WyCqWPpKg4B0lUlXCsNZ\n93DPdM4OhVbui4vfqUhz5T5GdA1dQ3OzZq76S819+GY9t2DNsAtySVJ1lemaM2t10OjBn577WmUr\nr8I8rRoX4Eqya2Uvbzm68hfo/nstU8ZX6KoP1wYZtdBXjq60hcqJ1pUE33ugK5stQbK9reinfU+r\nvc3oV/uu8jcr93uO2oacnprloKbvvJTxMk+bX62Tjkovt2tcMvDjLUdXohxfI0GTq5T257JTRkiS\nfveaU93IoX8x/bU7S+ZW64PzavTg33ZP0bz7kbc1tsRHc/W3mnKej35xfgT+K50ZH7VRYgh0oeSl\nPdyz0Mp9eTddMEo/ahkjKf2V+0JdQGbJzrY2/ebOb2nb4ms144l13qbolYpkAuJkh2lUlBvFx6px\nUpgpFb5H3pRdvoWuEV1+T1Sh/r7BVhvOaDuQbG/7CoKk2d6G+puGFmr6b8iATEarkaTuoITPmy35\noJPP7zV5LvQW6EoU7Ou8Uaic80/smWQ+X5drY6O4aoqQdbtQu9N+/Vi1/c1YnTi3O7C59KjuwsaO\nKu1aVmhhjkLfcdr94pnRapxZT8NTakhGj5KXdues0Mp9ZrlOWVVlbjURH0nNCXANTf5v1Hj7Rm16\ndKFemX6ixpVCji6PkgmI4zfnrj59pP7suO6OSpoJiIPkDvFcZrnW11ABec8D9rqECopkdepir8VD\njl4qqWe9Tbu9DZ0rK5RQdahrVKTXMqNfMvynDpmjy2cV6jWiK4UyHr3pJk1auLDfYEj++97Z1qYX\nH3tsUAsPDUahc//LnT3/yLesqdPzu/dp1qTuOXjFWOyiUNmFpiWOq+veVur5uQquphzt8tTxFbr6\n9O40Ian2i/Ojl1N5d/Qlo10pZImPJNPJYav5ZcDN0u905zGi68DF/0ZTluZWTvE1776UxY+lcxeP\n6LVcdlpCJJhefkwuiLfU13SKQKMjQgs1UiLEqBAp/GrDWRRvb3d35M7N+XoUYqXcchE6R1eI0a8Z\nrkZh8td2TQn1980mRw+ncW4sNLOjV+qHCkt9ZkehciXplGN79mvmTqvU2YtG9MiXVYz+3UDfYnRs\nmuSYQU6ZfLd0MXFpTV/PH7+zJlZoyVy/fUYiXX4R6MKgjTmwHNkHzFcnKd75PmTnZklS5yPt3jrd\n5TDUPg298lLFzmpe8lGVsK4Lm0D5lHwGgQ6fXKmO1nodNsnPOtehVjArV119RM/fd1WoqYsZ753l\nz80/u3ilJuzYLOcIcqWt65zlOUWM9xVxFZtil+E7h9357TyWGaCf2ldS+GIq1FdMluvreqDQuf/o\nQ3P9mg8cUaWO1vquNBQjqrv/EmmM6Jp5SOEve0RslNdgc4P1ly4mLs2gYohzUqgRteWOqYsYlNs/\nWadDxvrtgfu8G5hv7DrP+JjGzl+jbf9nvVZ830+nu5xWXfzOVaM1sggrxAw2yWS5XUCFulauCHRB\n5VPIUQohhbopGSqw6GsUZFKWR3TlNTQ3a8m6TfrDeedq166L9MO/W5f5c/S3rxwdLKdNqBFd3eV6\nzCVVBjcOQ5wTQ/RTfUxdlApMq56wpOu5CTs266lvrdGKu9M/PxU694+rq9A/XFynI6f0jGbFV15+\n462hHwgDzYcWD6oN9lgYSJ887ZseIYPE5dZnDC3j9wxRbEdNq9IEz4Eu35H3huZmvbDwIs19+GZN\nOf8vvXW6s3znMemwSZVFWWa8VJJMDkSQv26gQ6ocpvUtmFWlOVMrddkpnoe4lqmu06PnXmKwqYvl\nEOmSNGVps7YvWKMZbTdp3uWXZzrIJUlHTKnUpHFhDqpyTEafZSFuKIU4Dec/Z1WldOSUCl3ywfTa\n3HgQZs/j7ZJyQa5F96zWsd/c6OX8lDz355PML5hV1Wv0VFUsMrXjlaEfCMmy+6pHZy7sTo7/oyfe\nGXQ5/c22mLBjc+o3psshjyxyCHSh9Hk+Oexsa9O0x+7QtsXX6nff/Za3KW9lcl1TVMdfd12vhrCv\nKT8Nzc2pJQ8tfX4PrmnRXcajpvmZRhhC3QjTuitGe5sqWTICDekKkdBayv4UwkJqa979NcXy0kNt\nmrV1nX7TdJ1+sXZtWU4x9yXUqMggUxejD+tzRULfQgQuQ/wt8+fg2hrT+ivHaNbEdNvcfBDmvz/z\nF5q7+UYtume1tqxYr/csaUq13LzkqCqf1wZ9JeBPOnjM0BvGeLBrwo5cuph8UDH1nMgBgk4h6g6Y\nuohhwOcdpPxw2afO/baem3Si/uLyU/zl6Mr/9Nio/fgLY/wV5kmoqUZ9KaeRenlHTavSpmtG69CD\nyzBKkHHBpi5GP0NdpJeL+z4/RtUFVtlKw862Nm3+xHnasmK93p5zkj7716eV5RRz30ItJOHzpFEO\nORSDTIUyk+SCTEP1WWZDc7MmrbxUe/+xVdsWX6vd05d6qzfJUcQ+RxUfyI2d+TMPPPCYD3a9fvrH\ntH3BGs3auk5bVqzXFzxNDw0RfM9w7L0kcRWCkufrhBSfE/76rNyS5+Mbm7wlMw9xh2FcXYXG1WXr\nNFDKF6YtH6nVzReO8ldgwAa1YUJlWQb5ss4CXHRI3Yey7yOq3EZ0jR9T4WW5+Hx7u+zOTdo9famc\nc2W/eEhWhWiTy2H6vAUYtRYiuJafTufzb7mzrU0vbrxV2xZfq1lb12nCjs29Vn9MSzKwlRzhVUzJ\nFRB7rTQZe9zXCoh//bGh9WkbmnPT1+c+fLO2L1ij3dOXDun9BiJkfjsCXX6VWRcOw5KHk0NfiQ9N\nrNw33JTyhekZ76/R4jl+ljIG0hAqeLkv6pFWptnrLyD/ec9cGKbefvB92TtfxNvbac3LJHVfcNDe\nZk+IU0baAZlkgKA/fQUIhirf1/F6sS7/ZVZ6DhDkz09Hf2Ojti39grasWK9F96zW7zv8nI96TV0c\nYKT4fdMHP7IquQJir8T/UeUttALiB46o0pTxFZo4xJyDO9ty09fjQcW0MXWxfJTwJSGQ0z11MZ3T\nQ8EgV1Ro/qTvo/P9zr7c56vxNG0kq0o50BUKDSuKzfcxtS/Ks+s5ziVJevD6sbrurNog5X7pHP/l\npinZ3ha6iCXYlS1dI2E81t2uERspJWpPBgj6UihAUCzlMiqlwmNAL35+mtDYJEnaPX2ptqxYr8cv\nW+nlfJQMbL1bnCvf5/3mJXWDLit5rq0sEJXuayDAVy8YpX+6avSgyyz03ltWrO8RVEx9Bk300+fI\n9FAL6pQ7LglR8rqTiqbz/oVW7suLn/LTXrnvnb25n9Vlltu62Ah0xdCeIiW++2pdga4A9bu6yoKs\nghiq3DQl29u+LtbTbm+/fG7tAV0YYvBCjOhKOyAzkGBsXwGCYgmx6mKYqYt+yuwVhI/1xXdPX6rj\nb93oJfiePOW/W5v33b8arRtWjjrg/LTxY7lzS3uP5+qe6XsFxKpK08iaA6/c8e87P13x8v91qk64\nbVPq37MFyJfVdRz7KxIi0IXhIOVOUqGV+/oqO82V+/JLJo+ry9aFjW/khQLSE6p6nRUtZz5/Fmvo\nDGfJ9ra/6RxptrenzKvR/JkcSz7kLyZ9njp8TBPqL9iVdpBLCjO66hPLRkiSDhnidLXBqOwjGF5M\nhf5eyQDTIUv8jDTttfLhu3zVDRMqteyYoU1xzx/LT121sscKiFPvuDCVY7iv+jFvepWWn39y6t+z\neTg/9FkmkS6vCHSh5I0emTs7zHiPv6FO+Q6Zz5vpf3ZcjTpa672teJV1rPgXwyGFYe7YmVXqaK3X\nJI8XWEhf/qLu8EkMZUbx+JrWFw925QMEPoJcUpgcXafMy/VT60b461R0JaNPceRaoZkdhRKzpz3S\ntK9yfWhobta8f9ioRfes1tzNN2rRPav1u4vu9BbkkrrrbdrT14OMTCRHVxDczkLJmzq+Qt9YU6ej\nG/x3hIkPDE/fuqxO08ZzQex7ZTxkH2kmUEzVVaa1l9Zp5kQCXSgenxey+Yvy10//mLYvWKMf3rY+\n9SCXFCZHVwg+VtAsNHI0ORUwHoRJ82+bHMHlc/r6e5Y0da2AuG3xtaqcU/wVEPtLFxP/qPGgYrG/\n7xCLKnTn6PJXJhjRhWHiuMOrVDuEueAHillww9MxDVU6aHRpnd44lJAFV5w2UnOmVmreDO6ToTjm\nzajS2FrOkGlbdky1Zk+u0MoTa4KU77M/ZV25Xf1cVTY0N6v+I5dq7sM3a97ll6ce5JJi+WszFulK\nrmjZX46qtFa0LFSur+M3WW6Vx67saz9r77EC4qhfF38FxP7SxSRjeqlNXw8QdMrX12zV1tJXWleC\nQIkh3xOKJeSRRMOKYjl8cqXWXTFaozxOXQEwdOPqKrThU2M07WC/o+dCtD++pybtbGuT3X+bTvji\nF/WLtWu9rM43cVzuQ2btpkNyRcu+uuFprmgpFciVlVKTlwzsVSQ+cLzcNAN7O9vatPXylT1WQJx8\n+4VejuWuj+ypWxFiGiE5usIg0AUUEGA1bGQVES4AQJnKN4HVlf4aw+oo9uPjojKec2jJ9dd7SVgu\n5ZKQ3/WZ0VodJYjPimR+pkIBJp/J/rsfp3P8JgN7yamL+WLTDOzl3/v4Wzd2rYC4e/pSvXjJnV5X\nmvQ1S9PHdNi+yqRb7heBLqCArkAXkS5kQOOcbN3xBQAMD5MPMl1w0gjdfOEob2V+9uxanbu4RgsP\nT7ftKxRwSTuRdty0gyt75ZLKgvh3uLvD/4qWUs8RXReeNEJTDkrne04eL8l4cFVlup85/t4Tl/R8\n7z/NWep1pUlv11whk9ET6fKKQBfQDwJdyIIp40n0DADwz8x0+akjdegEf+3QwWMqdPXptapKcRRZ\nf8EHn8GurMp/hz+7eKX3FS2lniO4Ljt1ZKqpTOLHy0sP9TxeRj+z2UuQq6G5ueBoMh/Hsu8RXSEW\n1eF6MgwCXUA/OC8BAAAgbyABF4JdQ9fQ3Kwld2zSontWa+7mG70FuSR/QZe8/PHSvuq8rsDehB2b\ndej6Val95uQKiH0l4I+vgJiGfLllMXWREV1eMZ8FKKArLyKRLgxnNKgAABRVMkDQl3iAwEdwJosm\nLW3W9gVrcitafvGL3r7HEP3/huZmnfydTer8yLnavmCNZm1dp+cv3pDaZ06uaJhMhB9/1NDcnNp+\n5KbfOm9d1n378+V6KlCxZPT+ioQIdAH9ItAFAACAvGSAoD9pBgjKwSsPtWnW1nXatvha1a5d6+37\nDJX6bFrzsq7A3rbF12rv7KXeyu4rEb6vcvMBqLS9vTf3s8ZjFIQRXWEwdREohFUXkSUcyAAAYBjZ\n2damB1efpy0r1mvb0i94nQoa6kb3rge7A3uztq5T3f/b7K3s3lMX/XwJR07J5e9LM6deXN3IXDmH\nTfSXN5CBE2EQ6AL6wYkJRRPiLg53jgAAwDCTz4O2bMMm7Z6eG9XkM+9ZiBFdO9va9O8fP7crsLdl\nxXo1rF/lLcdbMs7k6xrohpWj9M2L6zS21k+Bc6ZW6uurR+nKD4/0Up7UPS2UEV1+BZm62NjSebWk\nS5QbZ3BbR2v93ze2dI6X9D1JMyQ9J+mcjtb61xpbOk3SLZI+LOlNSZ/oaK3fGmK/UX4IdAEAAAB+\nxJP9j1l4kvTwG13PxYNdaSam9x3oyn/mMzZ9T//8wPslSbunL9XO1Ru8JeHvNXUx1dK61Y00zZ/l\nNySxaHa11/LI0RWG9xFdjS2d71UuyHW8pHmSzmhs6Txc0uckPdDRWj9b0gPRY0n6kKTZ0b9LJa31\nvc8oPySjR9GUwjFUCvsAAADQj+SKlsngi+RnZFehctMS/8wzli/r8dycDy3zN4otEd3jGqh4yNEV\nRoipi3MlbelorX+zo7V+r6QHJf25pLMkbYhes0HS2dHvZ0m6s6O13nW01j8iaVxjS+dk3zuN8hQq\nGSVQDI4WFQAADBPJFS2TKwHmxVe0TIOv/FTJwF7cXZ8ZrU+eOtLblM1eUxdTK6n8cD0ZRoipi09J\nurGxpfNgSW8pNyXxcUkTO1rrd0WveVHSxOj3qZKej/3/F6Jtu5TQ2NJ5qXKjvryt3AAAAAAAGJrk\nipb9BQjSXIHRV2AiGdiLm3Zwd7L0eGAvtc+cHP5CcKZoGB0XhvdAV0dr/bbGls6vSvqJpD2S/lPS\nvsRrXGNL56CHInS01t8q6VZJqruFabA4cPkTkq87OkCqOIwBAMAw43MKYZyv7n8ysNefNAN7Uu/g\n3rL3+s1jlWWM6AojSDL6jtb6OyTdIUmNLZ2tyo3SeqmxpXNyR2v9rmhq4svRy38r6dDYf58WbQNS\nx3kJwxrhfgAAMEyFChCUY2CiMhZUbL9+rGqqyvBLSAnjJsIIEidvbOk8JPrZoFx+rn+WdK+kVdFL\nVkn6QfT7vZIubGzptMaWzhMkdcamOAKp2B9Nfa2u7P91AAAAAIqPQJc/8c9MkKu4Qo1MLHehvvbv\nN7Z0Pi3ph5Ku6Gitf13SVyR9sLGl8xlJJ0ePJenHkrZLelbSbZI+GWB/UWb2RoGuSgJdyACm4AIA\ngOEmVPelLANd5fihPaEfHkaoqYsnFtj2e0nLC2x3kq7wsV9AXn4xgyoi8AAAAIB3oWIvxCVQTMQQ\nw+AyHihg375ccqNKzkwYzsjRBQAAhqlQo4zo/qOYCJyGEWREF1Dqbjx/lDY+9LZqa0LvCQAAAFCe\nmo6u0ocW+O2QE5hAMVVyPAVBoAsoYNHsai2azbK6GLqSmJdfArsAAAAwWK3n13kvsyT6bsiM/OFU\nyVw6r/i6ASCrmLoIAAAABDeSMRReMaILAAAAAACgyEZUmy5ePkInHU2kyycCXQCQdYzABwAAAIJY\ns3xk6F0oO0xdBICMco65iwAAAAeiqjL0HgA4UIzoAgAAAAAgcsPKUTpiCmNCgOGKQBcAZB1TFwEA\nAAZs2THll0+pYUKFFh5OeADZwJEMAAAAAEAZ23TNmNC7ABQNgS4A8OThQx72Orpq3559/goDAAAA\ngBJAoAsAUjbm+DF649E39M4r7/gvvEIa837u0AEAAJS6y04ZoTf/FHovgOHPsroqV11dnduzZ0/o\n3QAAuX1O7+wOEOSSZCNM1ePKL88EAAAAgHSY2ZvOubrQ+9EXRnQBQMqs0lQzsSb0bgAAAABA6tqt\nfZyk2yW9V5KTtEbSryV9T9IMSc9JOqfJNb2WRvmsmQoAAAAAAIBiuUXS/U2uaY6keZK2SfqcpAea\nXNNsSQ9Ej1NBoAsAAAAAAABD1m7t9ZKWSrpDkppc09tNrul1SWdJ2hC9bIOks9PaB6YuAgAAAAAA\nYEDqVV/Vbu2Pxzbd2uSabo1+nynpFUnr2619nqQnJF0taWKTa9oVveZFSRPT2j8CXQAAAAAAABiQ\nTnXubXJNx/XxdJWkBZI+1eSatrRb+y1KTFNsck2u3dpTWxmRqYsAAAAAAAAohhckvdDkmrZEj+9W\nLvD1Uru1T5ak6OfLae0AgS4AAAAAAAAMWZNrelHS8+3WfmS0abmkpyXdK2lVtG2VpB+ktQ/mXGqj\nxYKqq6tze/bsCb0bAAAAAAAAmWFmbzrn6vp6vt3aj5V0u6QaSdslrVZuoNVdkhok7ZB0TpNrejWV\n/SPQBQAAAAAAgIF4t0BXaExdBAAAAAAAQCYQ6AIAAAAAAEAmEOgCAAAAAABAJhDoAgAAAAAAQCYQ\n6AIAAAAAAEAmEOgCAAAAAABAJhDoAgAAAAAAQCYQ6AIAAAAAAEAmEOgCAAAAAABAJhDoAgAAAAAA\nQCYQ6AIAAAAAAEAmEOgCAAAAAABAJhDoAgAAAAAAQCYQ6AIAAAAAAEAmmHMu9D6kwsz2S3or9H4U\nQZWkvaF3AhgGqCvAwFBXgIGhrgADQ10BBiZLdaXWOVeyA6cyG+jKCjN73Dl3XOj9AEoddQUYGOoK\nMDDUFWBgqCvAwFBX/CnZCBwAAAAAAAAwGAS6AAAAAAAAkAkEukrfraF3ABgmqCvAwFBXgIGhrgAD\nQ10BBoa64gk5ugAAAAAAAJAJjOgCAAAAAABAJhDoAgAAAAAAQCYQ6CphZnaamf3azJ41s8+F3h/A\nJzM71MzazOxpM/uVmV0dbR9vZj81s2einwdF283MvhHVl1+a2YLYe62KXv+Mma0K9ZmANJlZpZn9\n3Mzuix7PNLMtUZ34npnVRNtHRI+fjZ6fEXuPz0fbf21mp4b5JEB6zGycmd1tZv9lZtvM7AO0K0Bv\nZvbpqP/1lJltNLORtCuAZGbrzOxlM3sqtq31TRAOAAAHB0lEQVRo7YiZvd/Mnoz+zzfMzPx+wmwg\n0FWizKxS0jclfUjSUZJWmtlRYfcK8GqvpM84546SdIKkK6I68DlJDzjnZkt6IHos5erK7OjfpZLW\nSrmGR9KXJC2SdLykL+UbHyBjrpa0Lfb4q5K+7pw7XNJrki6Ktl8k6bVo+9ej1ymqX+dJOlrSaZL+\nMWqLgCy5RdL9zrk5kuYpV2doV4AYM5sq6SpJxznn3iupUrn2gXYFkL6t3PEcV8x2ZK2kS2L/L1kW\nBoBAV+k6XtKzzrntzrm3JW2SdFbgfQK8cc7tcs5tjX5/Q7mLkanK1YMN0cs2SDo7+v0sSXe6nEck\njTOzyZJOlfRT59yrzrnXJP1UNBjIGDObJul0SbdHj03SMkl3Ry9J1pV8Hbpb0vLo9WdJ2uSc+5Nz\n7jeSnlWuLQIywczqJS2VdIckOefeds69LtoVoJAqSbVmViVplKRdol0B5JzbLOnVxOaitCPRc2Od\nc4+43KqBd8beC4NAoKt0TZX0fOzxC9E2oOxEQ+DnS9oiaaJzblf01IuSJka/91VnqEsoB38v6TpJ\n+6PHB0t63Tm3N3ocP+676kT0fGf0euoKsm6mpFckrY+m+d5uZnWiXQF6cM79VtLXJO1ULsDVKekJ\n0a4AfSlWOzI1+j25HYNEoAtASTOz0ZK+L+mvnHN/iD8X3elwQXYMKBFmdoakl51zT4TeF6DEVUla\nIGmtc26+pD3qnl4iiXYFkKRoCtVZygWHp0iqE6MWgQGhHSkNBLpK128lHRp7PC3aBpQNM6tWLsj1\nXefcv0abX4qG9Sr6+XK0va86Q11C1i2WdKaZPafcNPdlyuUhGhdNOZF6HvdddSJ6vl7S70VdQfa9\nIOkF59yW6PHdygW+aFeAnk6W9Bvn3CvOuXck/atybQ3tClBYsdqR30a/J7djkAh0la7HJM2OVjep\nUS6R472B9wnwJsrtcIekbc65v4s9da+k/MokqyT9ILb9wmh1kxMkdUZDiP9d0ilmdlB0h/KUaBuQ\nCc65zzvnpjnnZijXVvyHc+58SW2SPhq9LFlX8nXoo9HrXbT9vGj1rJnKJUB91NPHAFLnnHtR0vNm\ndmS0abmkp0W7AiTtlHSCmY2K+mP5ukK7AhRWlHYkeu4PZnZCVPcujL0XBqHq3V+CEJxze83sSuUq\nQaWkdc65XwXeLcCnxZIukPSkmf1ntK1F0lck3WVmF0naIemc6LkfS/qwcolO35S0WpKcc6+a2d8q\nFzyWpOudc8kEkkAWfVbSJjO7QdLPFSXgjn5+x8yeVS6Z6nmS5Jz7lZndpdzFzF5JVzjn9vnfbSBV\nn5L03egm4nbl2ooK0a4AXZxzW8zsbklblWsPfi7pVkk/Eu0KypyZbZTUJGmCmb2g3OqJxbw++aRy\nKzvWSvq36B8GyXLBdgAAAAAAAGB4Y+oiAAAAAAAAMoFAFwAAAAAAADKBQBcAAAAAAAAygUAXAAAA\nAAAAMoFAFwAAAAAAADKhKvQOAAAAlCozO1jSA9HDSZL2SXolevymc64xhTLnS7rSOXfREN/nSuX2\ncV1x9gwAAKD0mXMu9D4AAACUPDP7sqQ/Oue+lnI5/yLpBufcL4b4PqMkPeycm1+cPQMAACh9TF0E\nAAA4AGb2x+hnk5k9aGY/MLPtZvYVMzvfzB41syfN7LDode8xs++b2WPRv8UF3nOMpPflg1xm9mUz\n22Bm/9fMdpjZn5vZTdH73m9m1dHrvmJmT5vZL83sa5LknHtT0nNmdryv7wQAACA0Al0AAABDN0/S\nZZLmSrpA0hHOueMl3S7pU9FrbpH0defcQkkfiZ5LOk7SU4lth0laJulMSf8kqc05d4yktySdHk2v\nXCHpaOfc+yTdEPu/j0s6cegfDwAAYHggRxcAAMDQPeac2yVJZvbfkn4SbX9SUnP0+8mSjjKz/P8Z\na2ajnXN/jL3PZHXnAMv7N+fcO2b2pKRKSffH3nuGpPsk/Y+kO8zsvuhx3suS5gzxswEAAAwbBLoA\nAACG7k+x3/fHHu9Xd3+rQtIJzrn/6ed93pI0stB7O+f2m9k7rjvB6n5JVc65vdH0xOWSPirpSuVG\ngCl6r7cO4PMAAAAMS0xdBAAA8OMn6p7GKDM7tsBrtkk6fDBvamajJdU7534s6dPKTaPMO0K9p0IC\nAABkFoEuAAAAP66SdFyUMP5p5XJ69eCc+y9J9VFS+oEaI+k+M/ulpIckXRN7brGknw5hnwEAAIYV\n6x79DgAAgNDM7NOS3nDOFUpWP5j3mS/pGufcBcXZMwAAgNLHiC4AAIDSslY9c34dqAmSvliE9wEA\nABg2GNEFAAAAAACATGBEFwAAAAAAADKBQBcAAAAAAAAygUAXAAAAAAAAMoFAFwAAAAAAADKBQBcA\nAAAAAAAy4f8DWNKI2beymAAAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[370, 663, 947, 1231, 1515, 1809, 2045, 2403, 2706, 2998, 3283, 3560, 3863, 4171, 4466, 4765, 5061, 5347, 5634, 5919, 6215, 6527, 6824, 7106, 7393, 7670, 7953, 8246, 8539, 8837, 9142, 9432, 9710]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABLoAAAJcCAYAAAD+Vc3FAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy\n", - "import wfdb\n", - "\n", - "def peaks_hr(x, peaks_indexes, fs, title, figsize=(20, 10), saveto=None):\n", - " hrs = wfdb.processing.compute_hr(length=x.shape[0], peaks_indexes=peaks_indexes, fs=fs)\n", - " \n", - " N = x.shape[0]\n", - " \n", - " fig, ax_left = plt.subplots(figsize=figsize)\n", - " ax_right = ax_left.twinx()\n", - " \n", - " ax_left.plot(x, color='#3979f0', label='Signal')\n", - " ax_left.plot(peaks_indexes, x[peaks_indexes], 'rx', marker='x', color='#8b0000', label='Peak', markersize=12)\n", - " ax_right.plot(numpy.arange(N), hrs, label='Heart rate', color='m', linewidth=2)\n", - "\n", - " ax_left.set_title(title)\n", - "\n", - " ax_left.set_xlabel('Time (ms)')\n", - " ax_left.set_ylabel('ECG', color='#3979f0')\n", - " ax_right.set_ylabel('Heart rate (bpm)', color='m')\n", - " # Make the y-axis label, ticks and tick labels match the line color.\n", - " ax_left.tick_params('y', colors='#3979f0')\n", - " ax_right.tick_params('y', colors='m')\n", - " if saveto is not None:\n", - " plt.savefig(saveto, dpi=600)\n", - " plt.show()\n", - "\n", - "\n", - "f = 'sampledata/100'\n", - "\n", - "def gqrs_plot(t, t0=0, tf=10000):\n", - " sig, fields = wfdb.srdsamp(f, sampfrom=t0, sampto=tf, channels=[0])\n", - " record = wfdb.rdsamp(f, sampfrom=t0, sampto=tf, channels=[0], physical=False)\n", - " x = record.d_signals[:,0]\n", - " fs = fields['fs']\n", - " peaks_indexes = wfdb.processing.gqrs_detect(x=x, frequency=fs, adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0)\n", - " print(peaks_indexes)\n", - " peaks_hr(x=x, peaks_indexes=peaks_indexes, fs=fs, title=\"GQRS peak detection on sampledata/100\")\n", - " min_bpm = 20\n", - " max_bpm = 230\n", - " min_gap = fs*60/min_bpm\n", - " max_gap = fs*60/max_bpm\n", - " peaks_indexes = wfdb.processing.correct_peaks(x=x, peaks_indexes=peaks_indexes, min_gap=min_gap, max_gap=max_gap, smooth_window=150)\n", - " print(sorted(peaks_indexes))\n", - " peaks_hr(x=x, peaks_indexes=sorted(peaks_indexes), fs=fs, title=\"Corrected GQRS peak detection on sampledata/100\")\n", - "\n", - "\n", - "gqrs_plot(f)" - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python [conda root]", - "language": "python", - "name": "conda-root-py" - }, - "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.5.2" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/wfdb/processing/basic.py b/wfdb/processing/basic.py index 1b7f685f..a5eda8fe 100644 --- a/wfdb/processing/basic.py +++ b/wfdb/processing/basic.py @@ -6,9 +6,9 @@ def resample_ann(tt, sample): # tt: numpy.array as returned by signal.resample - # sample: numpy.array containing indexes of annotations (Annotation.sample) + # sample: numpy.array containing indices of annotations (Annotation.sample) - # Compute the new annotation indexes + # Compute the new annotation indices tmp = numpy.zeros(len(tt), dtype='int16') j = 0 @@ -86,7 +86,7 @@ def resample_multichan(xs, ann, fs, fs_target, resamp_ann_chan=0): # ann: an Annotation object # fs: the current frequency # fs_target: the target frequency - # resample_ann_channel: the signal channel that is used to compute new annotation indexes + # resample_ann_channel: the signal channel that is used to compute new annotation indices # Resample multiple channels with their annotations diff --git a/wfdb/processing/gqrs.py b/wfdb/processing/gqrs.py index 8a9f3e5f..0dcb8478 100644 --- a/wfdb/processing/gqrs.py +++ b/wfdb/processing/gqrs.py @@ -453,31 +453,37 @@ def find_missing(r, p): p = p.next_peak -def gqrs_detect(x, frequency, adcgain, adczero, threshold=1.0, +def gqrs_detect(x, fs, adcgain, adczero, threshold=1.0, hr=75, RRdelta=0.2, RRmin=0.28, RRmax=2.4, QS=0.07, QT=0.35, RTmin=0.25, RTmax=0.33, QRSa=750, QRSamin=130): """ - A signal with a frequency of only 50Hz is not handled by the original algorithm, - thus it is not recommended to use this algorithm for this case. - - * x: The signal as an array - * frequency: The signal frequency - * adcgain: The gain of the signal (the number of adus (q.v.) per physical unit) - * adczero: The value produced by the ADC given a 0 volt input. - * threshold: The threshold for detection - * hr: Typical heart rate, in beats per minute - * RRdelta: Typical difference between successive RR intervals in seconds - * RRmin: Minimum RR interval ("refractory period"), in seconds - * RRmax: Maximum RR interval, in seconds; thresholds will be adjusted if no peaks are detected within this interval - * QS: Typical QRS duration, in seconds - * QT: Typical QT interval, in seconds - * RTmin: Minimum interval between R and T peaks, in seconds - * RTmax: Maximum interval between R and T peaks, in seconds - * QRSa: Typical QRS peak-to-peak amplitude, in microvolts - * QRSamin: Minimum QRS peak-to-peak amplitude, in microvolts + Detect qrs locations in a single channel ecg. + + Functionally, a direct port of the gqrs algorithm from the original + wfdb package. Therefore written to accept wfdb record fields. + + Input arguments: + - x (required): The digital signal as a numpy array + - fs (required): The sampling frequency of the signal + - adcgain: The gain of the signal (the number of adus (q.v.) per physical unit) + - adczero (required): The value produced by the ADC given a 0 volt input. + - threshold (default=1.0): The threshold for detection + - hr (default=75): Typical heart rate, in beats per minute + - RRdelta (default=0.2): Typical difference between successive RR intervals in seconds + - RRmin (default=0.28): Minimum RR interval ("refractory period"), in seconds + - RRmax (default=2.4): Maximum RR interval, in seconds; thresholds will be adjusted + if no peaks are detected within this interval + - QS (default=0.07): Typical QRS duration, in seconds + - QT (default=0.35): Typical QT interval, in seconds + - RTmin (default=0.25): Minimum interval between R and T peaks, in seconds + - RTmax (default=0.33): Maximum interval between R and T peaks, in seconds + - QRSa (default=750): Typical QRS peak-to-peak amplitude, in microvolts + - QRSamin (default=130): Minimum QRS peak-to-peak amplitude, in microvolts + + Note: This function should not be used for signals with fs <= 50Hz """ - conf = Conf(freq=frequency, gain=adcgain, hr=hr, + conf = Conf(freq=fs, gain=adcgain, hr=hr, RRdelta=RRdelta, RRmin=RRmin, RRmax=RRmax, QS=QS, QT=QT, RTmin=RTmin, RTmax=RTmax, diff --git a/wfdb/processing/hr.py b/wfdb/processing/hr.py index ea6ab3a1..f07e30b5 100644 --- a/wfdb/processing/hr.py +++ b/wfdb/processing/hr.py @@ -1,21 +1,37 @@ -import numpy +import numpy as np -def compute_hr(length, peaks_indexes, fs): - result = numpy.full(length, numpy.nan, dtype='float32') +def compute_hr(siglen, peak_indices, fs): + """ + Compute instantaneous heart rate from peak indices. - if len(peaks_indexes) < 2: - return result + Usage: + heart_rate = compute_hr(siglen, peak_indices, fs) - current_hr = numpy.nan + Input argumnets: + - siglen (required): The length of the corresponding signal + - peak_indices (required): The peak indices. + - fs (required): The corresponding signal's sampling frequency. - for i in range(0, len(peaks_indexes)-2): - a = peaks_indexes[i] - b = peaks_indexes[i+1] - c = peaks_indexes[i+2] + Output arguments: + - heart_rate: A numpy array of the instantaneous heart rate, with the length + of the corresponding signal. Contains numpy.nan where heart rate could not be computed. + """ + heart_rate = np.full(siglen, np.nan, dtype='float32') + + if len(peak_indices) < 2: + return heart_rate + + current_hr = np.nan + + for i in range(0, len(peak_indices)-2): + a = peak_indices[i] + b = peak_indices[i+1] + c = peak_indices[i+2] RR = (b-a) * (1.0 / fs) * 1000 hr = 60000.0 / RR - result[b+1:c+1] = hr - result[peaks_indexes[-1]:] = result[peaks_indexes[-1]] + heart_rate[b+1:c+1] = hr + + heart_rate[peak_indices[-1]:] = heart_rate[peak_indices[-1]] - return result + return heart_rate diff --git a/wfdb/processing/peaks.py b/wfdb/processing/peaks.py index 2ad2567f..bcf95548 100644 --- a/wfdb/processing/peaks.py +++ b/wfdb/processing/peaks.py @@ -9,8 +9,8 @@ def find_peaks(x): # * Soft peak: a peak that is either /-*\ or \-*/ (In that cas we define the middle of it as the peak) # Returns two numpy arrays: - # * hard_peaks contains the indexes of the Hard peaks - # * soft_peaks contains the indexes of the Soft peaks + # * hard_peaks contains the indices of the Hard peaks + # * soft_peaks contains the indices of the Soft peaks if len(x) == 0: return numpy.empty([0]), numpy.empty([0]) @@ -40,11 +40,11 @@ def find_peaks(x): return hard_peaks, soft_peaks -def correct_peaks(x, peaks_indexes, min_gap, max_gap, smooth_window): +def correct_peaks(x, peak_indices, min_gap, max_gap, smooth_window): N = x.shape[0] rpeaks = numpy.zeros(N) - rpeaks[peaks_indexes] = 1.0 + rpeaks[peak_indices] = 1.0 rpeaks = rpeaks.astype('int32') @@ -76,21 +76,21 @@ def correct_peaks(x, peaks_indexes, min_gap, max_gap, smooth_window): # Replace all peaks by the peak within x-max_gap < x < x+max_gap which have the bigget distance from smooth curve dist = numpy.absolute(x-smoothed) # Peak distance from the smoothed mean - rpeaks_indexes = set() + rpeak_indices = set() for p in tmp: a = max(0, p-max_gap) b = min(N, p+max_gap) r = numpy.arange(a, b, dtype='int64') idx_best = r[numpy.argmax(dist[r])] - rpeaks_indexes.add(idx_best) + rpeak_indices.add(idx_best) - rpeaks_indexes = list(rpeaks_indexes) + rpeak_indices = list(rpeak_indices) # Prevent multiple peaks to appear in the max bpm range (max_gap) # If we found more than one peak in this interval, then we choose the peak with the maximum amplitude compared to the mean of the signal - tmp = numpy.asarray(rpeaks_indexes) + tmp = numpy.asarray(rpeak_indices) to_remove = {} - for idx in rpeaks_indexes: + for idx in rpeak_indices: if idx in to_remove: continue r = tmp[numpy.where(numpy.absolute(tmp-idx)<=max_gap)[0]] @@ -104,6 +104,6 @@ def correct_peaks(x, peaks_indexes, min_gap, max_gap, smooth_window): if i != the_one: to_remove[i] = True for v, _ in to_remove.items(): - rpeaks_indexes.remove(v) + rpeak_indices.remove(v) - return sorted(rpeaks_indexes) + return sorted(rpeak_indices) diff --git a/wfdb/readwrite/_signals.py b/wfdb/readwrite/_signals.py index 9c6c1a9e..3d5394f7 100644 --- a/wfdb/readwrite/_signals.py +++ b/wfdb/readwrite/_signals.py @@ -259,31 +259,94 @@ def set_d_features(self, do_adc = False, singlefmt = 1, expanded=False): self.checksum = self.calc_checksum() - # Returns the analogue to digital conversion for the physical signal stored in p_signals. - # The p_signals, fmt, gain, and baseline fields must all be valid. - def adc(self, expanded=False): + + def adc(self, expanded=False, inplace=False): + """ + Performs analogue to digital conversion of the physical signal stored + in p_signals if expanded is False, or e_p_signals if expanded is True. + + The p_signals/e_p_signals, fmt, gain, and baseline fields must all be + valid. + + If inplace is True, the adc will be performed inplace on the variable, + the d_signals/e_d_signals attribute will be set, and the + p_signals/e_p_signals field will be set to None. + + Input arguments: + - expanded (default=False): Boolean specifying whether to transform the + e_p_signals attribute (True) or the p_signals attribute (False). + - inplace (default=False): Boolean specifying whether to automatically + set the object's corresponding digital signal attribute and set the + physical signal attribute to None (True), or to return the converted + signal as a separate variable without changing the original physical + signal attribute (False). + + Possible output argument: + - d_signals: The digital conversion of the signal. Either a 2d numpy + array or a list of 1d numpy arrays. + + Example Usage: + import wfdb + record = wfdb.rdsamp('sampledata/100') + d_signal = record.adc() + record.adc(inplace=True) + record.dac(inplace=True) + """ # The digital nan values for each channel dnans = digi_nan(self.fmt) - if expanded: - d_signals = [] - for ch in range(0, self.nsig): - chnanloc = np.isnan(self.e_p_signals) - d_signals.append(self.e_p_signals[ch] * self.adcgain[ch] + self.baseline[ch]) - d_signals[ch][chnanlocs] = dnans[ch] + # To do: choose the minimum return res needed + intdtype = 'int64' + + # Do inplace conversion and set relevant variables. + if inplace: + if expanded: + for ch in range(0, self.nsig): + # nan locations for the channel + ch_nanlocs = np.isnan(self.e_p_signals[ch]) + np.multiply(self.e_p_signals[ch], self.adcgain[ch], self.e_p_signals[ch]) + np.add(e_p_signals[ch], self.baseline[ch], self.e_p_signals[ch]) + self.e_p_signals[ch] = self.e_p_signals[ch].astype(intdtype, copy=False) + self.e_p_signals[ch][ch_nanlocs] = dnans[ch] + self.e_d_signals = self.e_p_signals + self.e_p_signals = None + else: + nanlocs = np.isnan(self.p_signals) + np.multiply(self.p_signals, self.adcgain, self.p_signals) + np.add(self.p_signals, self.baseline, self.p_signals) + self.p_signals = self.p_signals.astype(intdtype, copy=False) + self.d_signals = self.p_signals + self.p_signals = None + + # Return the variable else: - d_signals = self.p_signals * self.adcgain + self.baseline - - for ch in range(0, np.shape(self.p_signals)[1]): - # Nan locations - nanlocs = np.isnan(self.p_signals[:,ch]) - if nanlocs.any(): - d_signals[nanlocs,ch] = dnans[ch] - - d_signals = d_signals.astype('int64') + if expanded: + d_signals = [] + for ch in range(0, self.nsig): + # nan locations for the channel + ch_nanlocs = np.isnan(self.e_p_signals[ch]) + ch_d_signal = self.e_p_signals.copy() + np.multiply(ch_d_signal, self.adcgain[ch], ch_d_signal) + np.add(ch_d_signal, self.baseline[ch], ch_d_signal) + ch_d_signal = ch_d_signal.astype(intdtype, copy=False) + ch_d_signal[ch_nanlocs] = dnans[ch] + d_signals.append(ch_d_signal) + + else: + nanlocs = np.isnan(self.p_signals) + # Cannot cast dtype to int now because gain is float. + d_signals = self.p_signals.copy() + np.multiply(d_signals, self.adcgain, d_signals) + np.add(d_signals, self.baseline, d_signals) + d_signals = d_signals.astype(intdtype, copy=False) - return d_signals + if nanlocs.any(): + for ch in range(d_signals.shape[1]): + if nanlocs[:,ch].any(): + d_signals[nanlocs[:,ch],ch] = dnans[ch] + + return d_signals def dac(self, expanded=False, returnres=64, inplace=False): @@ -291,18 +354,38 @@ def dac(self, expanded=False, returnres=64, inplace=False): Performs the digital to analogue conversion of the signal stored in d_signals if expanded is False, or e_d_signals if expanded is True. - The d_signals/e_d_signals, fmt, gain, and baseline fields must all be valid. - - If inplace is True, the dac will be performed inplace on the variable, the - p_signals attribute will be set, and d_signals will be set to None. + The d_signals/e_d_signals, fmt, gain, and baseline fields must all be + valid. + If inplace is True, the dac will be performed inplace on the variable, + the p_signals/e_p_signals attribute will be set, and the + d_signals/e_d_signals field will be set to None. + + Input arguments: + - expanded (default=False): Boolean specifying whether to transform the + e_d_signals attribute (True) or the d_signals attribute (False). + - inplace (default=False): Boolean specifying whether to automatically + set the object's corresponding physical signal attribute and set the + digital signal attribute to None (True), or to return the converted + signal as a separate variable without changing the original digital + signal attribute (False). + + Possible output argument: + - p_signals: The physical conversion of the signal. Either a 2d numpy + array or a list of 1d numpy arrays. + + Example Usage: + import wfdb + record = wfdb.rdsamp('sampledata/100', physical=False) + p_signal = record.dac() + record.dac(inplace=True) + record.adc(inplace=True) """ # The digital nan values for each channel dnans = digi_nan(self.fmt) # Get the appropriate float dtype - if returnres == 64: floatdtype = 'float64' elif returnres == 32: @@ -336,7 +419,7 @@ def dac(self, expanded=False, returnres=64, inplace=False): # Return the variable else: if expanded: - p_signal = [] + p_signals = [] for ch in range(0, self.nsig): # nan locations for the channel ch_nanlocs = self.e_d_signals[ch] == dnans[ch] @@ -344,15 +427,15 @@ def dac(self, expanded=False, returnres=64, inplace=False): np.subtract(ch_p_signal, self.baseline[ch], ch_p_signal) np.divide(ch_p_signal, self.adcgain[ch], ch_p_signal) ch_p_signal[ch_nanlocs] = np.nan - p_signal.append(ch_p_signal) + p_signals.append(ch_p_signal) else: nanlocs = self.d_signals == dnans - p_signal = self.d_signal.astype(floatdtype, copy=False) - np.subtract(p_signal, self.baseline, p_signal) - np.divide(p_signal, self.adcgain, p_signal) - p_signal[nanlocs] = np.nan + p_signals = self.d_signals.astype(floatdtype, copy=False) + np.subtract(p_signals, self.baseline, p_signals) + np.divide(p_signals, self.adcgain, p_signals) + p_signals[nanlocs] = np.nan - return p_signal + return p_signals # Compute appropriate gain and baseline parameters given the physical signal and the fmts @@ -406,7 +489,7 @@ def calculate_adcparams(self): raise Exception('adcgain and baseline must have magnitudes < 214748364') gains.append(gain) - baselines.append(baseline) + baselines.append(baseline) return (gains, baselines) diff --git a/wfdb/readwrite/records.py b/wfdb/readwrite/records.py index 4a081837..726e0df8 100644 --- a/wfdb/readwrite/records.py +++ b/wfdb/readwrite/records.py @@ -344,7 +344,7 @@ def __init__(self, p_signals=None, d_signals=None, Example Usage: import wfdb - record1 = wfdb.Record(recordname='r1', fs=250, nsig=2, siglen=1000, filename=['r1.dat','r1.dat']) + record = wfdb.Record(recordname='r1', fs=250, nsig=2, siglen=1000, filename=['r1.dat','r1.dat']) """ # Constructor From 33bcfc74b854d628e7573122da4c1401489c2ba7 Mon Sep 17 00:00:00 2001 From: Chen Xie Date: Mon, 2 Oct 2017 20:24:43 -0400 Subject: [PATCH 2/3] fix readme --- README.rst | 28 +++++++--------------------- 1 file changed, 7 insertions(+), 21 deletions(-) diff --git a/README.rst b/README.rst index 0ac2d7bc..0ce37718 100644 --- a/README.rst +++ b/README.rst @@ -216,15 +216,7 @@ When reading signal sample values into ``record`` objects using ``rdsamp``, the One can also use existing objects to obtain physical values from digital values and vice versa, without having to re-read the wfdb file with a different set of options. The two following instance methods perform the conversions. -**adc** - Performs analogue to digital conversion of the physical signal stored - in p_signals if expanded is False, or e_p_signals if expanded is True. - - The p_signals/e_p_signals, fmt, gain, and baseline fields must all be - valid. - - If inplace is True, the adc will be performed inplace on the variable, - the d_signals/e_d_signals attribute will be set, and the - p_signals/e_p_signals field will be set to None. +**adc** - Performs analogue to digital conversion of the physical signal stored in p_signals if expanded is False, or e_p_signals if expanded is True. The p_signals/e_p_signals, fmt, gain, and baseline fields must all be valid. If inplace is True, the adc will be performed inplace on the variable, the d_signals/e_d_signals attribute will be set, and the p_signals/e_p_signals field will be set to None. :: @@ -241,7 +233,8 @@ Possible output argument: Example Usage: -:: +:: + import wfdb record = wfdb.rdsamp('sampledata/100') d_signal = record.adc() @@ -249,15 +242,7 @@ Example Usage: record.dac(inplace=True) -**dac** - Performs digital to analogue conversion of the digital signal stored - in d_signals if expanded is False, or e_d_signals if expanded is True. - - The d_signals/e_d_signals, fmt, gain, and baseline fields must all be - valid. - - If inplace is True, the dac will be performed inplace on the variable, - the p_signals/e_p_signals attribute will be set, and the - d_signals/e_d_signals field will be set to None. +**dac** - Performs digital to analogue conversion of the digital signal stored in d_signals if expanded is False, or e_d_signals if expanded is True. The d_signals/e_d_signals, fmt, gain, and baseline fields must all be valid. If inplace is True, the dac will be performed inplace on the variable, the p_signals/e_p_signals attribute will be set, and the d_signals/e_d_signals field will be set to None. :: @@ -274,7 +259,8 @@ Possible output argument: Example Usage: -:: +:: + import wfdb record = wfdb.rdsamp('sampledata/100', physical=False) p_signal = record.dac() @@ -344,7 +330,7 @@ Example Usage: import wfdb ann = wfdb.rdann('sampledata/100', 'atr', sampto = 300000) -Input arguments: +Input Arguments: - ``recordname`` (required): The record name of the WFDB annotation file. ie. for file `100.atr`, recordname='100' - ``extension`` (required): The annotatator extension of the annotation file. ie. for From d7a7cbb3c86d755c4dbd8418d75d6e778dd603b4 Mon Sep 17 00:00:00 2001 From: Chen Xie Date: Tue, 3 Oct 2017 13:21:11 -0400 Subject: [PATCH 3/3] fix examples --- README.rst | 70 +++++++++++++++++++++++++++++------------------------- demo.ipynb | 6 +++-- 2 files changed, 42 insertions(+), 34 deletions(-) diff --git a/README.rst b/README.rst index 0ce37718..753509cf 100644 --- a/README.rst +++ b/README.rst @@ -735,26 +735,6 @@ See code comments for details about the algorithm. correct_peaks(x, peak_indices, min_gap, max_gap, smooth_window) -Example Usage: - -:: - - import wfdb - t0 = 10000 - tf = 20000 - sig, fields = wfdb.srdsamp('sampledata/100', sampfrom=t0, sampto=tf, channels=[0]) - record = wfdb.rdsamp("sampledata/100", sampfrom=t0, sampto=tf, channels=[0], physical=False) - peak_indices = wfdb.processing.gqrs_detect(x=sig[:,0], frequency=fields['fs'], - adcgain=record.adcgain[0], adczero=record.adczero[0], - threshold=1.0) - fs = fields['fs'] - min_bpm = 10 - max_bpm = 350 - min_gap = fs*60/min_bpm - max_gap = fs*60/max_bpm - new_indices = wfdb.processing.correct_peaks(x=sig[:,0], peak_indices=peak_indices, - min_gap=min_gap, max_gap=max_gap, smooth_window=150) - Input arguments: - ``x`` (required): The signal. @@ -768,6 +748,28 @@ Output Arguments: - ``new_indices``: A python list containing the new peaks indices. +Example Usage: + +:: + + import wfdb + t0 = 10000 + tf = 20000 + record = wfdb.rdsamp('sampledata/100', sampfrom=t0, sampto=tf, channels=[0]) + d_signal = record.adc()[:,0] + peak_indices = wfdb.processing.gqrs_detect(d_signal, fs=record.fs, + adcgain=record.adcgain[0], + adczero=record.adczero[0], + threshold=1.0) + min_bpm = 10 + max_bpm = 350 + min_gap = record.fs*60/min_bpm + max_gap = record.fs*60/max_bpm + new_indices = wfdb.processing.correct_peaks(d_signal, peak_indices=peak_indices, + min_gap=min_gap, max_gap=max_gap, + smooth_window=150) + + Heart Rate ~~~~~~~~~~~~~~ @@ -777,18 +779,6 @@ Heart Rate compute_hr(siglen, peak_indices, fs) -Example Usage: - -:: - - import wfdb - t0 = 10000 - tf = 20000 - sig, fields = wfdb.srdsamp('sampledata/100', sampfrom=t0, sampto=tf, channels=[0]) - record = wfdb.rdsamp("sampledata/100", sampfrom=t0, sampto=tf, channels=[0], physical=False) - peak_indices = wfdb.processing.gqrs_detect(x=sig[:,0], frequency=fields['fs'], adcgain=record.adcgain[0], adczero=record.adczero[0], threshold=1.0) - hr = compute_hr(siglen=tf-t0, peak_indices=peak_indices, fs=fields['fs']) - Input arguments: - ``siglen`` (required): The length of the corresponding signal. @@ -801,6 +791,22 @@ Output Arguments: - ``hr``: A numpy array of the instantaneous heart rate, with the length of the corresponding signal. Contains numpy.nan where heart rate could not be computed. +Example Usage: + +:: + + import wfdb + t0 = 10000 + tf = 20000 + record = wfdb.rdsamp("sampledata/100", sampfrom=t0, sampto=tf, channels=[0]) + peak_indices = wfdb.processing.gqrs_detect(record.adc(), fs=record.fs, + adcgain=record.adcgain[0], + adczero=record.adczero[0], + threshold=1.0) + hr = wfdb.processing.compute_hr(siglen=tf-t0, peak_indices=peak_indices, fs=record.fs) + + + Based on the original WFDB software package specifications ---------------------------------------------------------- diff --git a/demo.ipynb b/demo.ipynb index f95552fb..a5a34776 100644 --- a/demo.ipynb +++ b/demo.ipynb @@ -445,7 +445,9 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "def peaks_hr(x, peak_indices, fs, title, figsize=(20, 10), saveto=None):\n", @@ -488,7 +490,7 @@ " print('gqrs detected peak indices:', peak_indices)\n", " peaks_hr(x=record.p_signals, peak_indices=peak_indices, fs=record.fs, title=\"GQRS peak detection on sampledata/100\")\n", " \n", - " # Do peak detection with constraints\n", + " # Correct the peaks by applying constraints\n", " min_bpm = 20\n", " max_bpm = 230\n", " min_gap = record.fs*60/min_bpm\n",