hdr-histogram-js/dist/hdrhistogram.umd.js

TypeScript port of HdrHistogram

!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("pako")):"function"==typeof define&&define.amd?define(["exports","pako"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).hdr={},t.pako)}(this,(function(exports,pako){"use strict";function _interopNamespace(t){if(t&&t.__esModule)return t;var e=Object.create(null);return t&&Object.keys(t).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(t,r);Object.defineProperty(e,r,n.get?n:{enumerable:!0,get:function(){return t[r]}})}})),e.default=t,Object.freeze(e)}var pako__namespace=_interopNamespace(pako);const{pow:pow$6,floor:floor$5}=Math,TWO_POW_32=pow$6(2,32);class ByteBuffer{static allocate(t=16){return new ByteBuffer(new Uint8Array(t))}constructor(t){this.position=0,this.data=t,this.int32ArrayForConvert=new Uint32Array(1),this.int8ArrayForConvert=new Uint8Array(this.int32ArrayForConvert.buffer)}put(t){if(this.position===this.data.length){const t=this.data;this.data=new Uint8Array(2*this.data.length),this.data.set(t)}this.data[this.position]=t,this.position++}putInt32(t){if(this.data.length-this.position<4){const t=this.data;this.data=new Uint8Array(2*this.data.length+4),this.data.set(t)}this.int32ArrayForConvert[0]=t,this.data.set(this.int8ArrayForConvert.reverse(),this.position),this.position+=4}putInt64(t){this.putInt32(floor$5(t/TWO_POW_32)),this.putInt32(t)}putArray(t){if(this.data.length-this.position<t.byteLength){const e=this.data;this.data=new Uint8Array(this.position+t.byteLength),this.data.set(e)}this.data.set(t,this.position),this.position+=t.byteLength}get(){const t=this.data[this.position];return this.position++,t}getInt32(){this.int8ArrayForConvert.set(this.data.slice(this.position,this.position+4).reverse());const t=this.int32ArrayForConvert[0];return this.position+=4,t}getInt64(){const t=this.getInt32(),e=this.getInt32();return t*TWO_POW_32+e}resetPosition(){this.position=0}}class HistogramIterationValue{constructor(){this.reset()}reset(){this.valueIteratedTo=0,this.valueIteratedFrom=0,this.countAtValueIteratedTo=0,this.countAddedInThisIterationStep=0,this.totalCountToThisValue=0,this.totalValueToThisValue=0,this.percentile=0,this.percentileLevelIteratedTo=0}}class JsHistogramIterator{constructor(){this.currentIterationValue=new HistogramIterationValue}resetIterator(t){this.histogram=t,this.savedHistogramTotalRawCount=t.totalCount,this.arrayTotalCount=t.totalCount,this.currentIndex=0,this.currentValueAtIndex=0,this.nextValueAtIndex=Math.pow(2,t.unitMagnitude),this.prevValueIteratedTo=0,this.totalCountToPrevIndex=0,this.totalCountToCurrentIndex=0,this.totalValueToCurrentIndex=0,this.countAtThisValue=0,this.freshSubBucket=!0,this.currentIterationValue.reset()}hasNext(){if(this.histogram.totalCount!==this.savedHistogramTotalRawCount)throw"Concurrent Modification Exception";return this.totalCountToCurrentIndex<this.arrayTotalCount}next(){for(;!this.exhaustedSubBuckets();){if(this.countAtThisValue=this.histogram.getCountAtIndex(this.currentIndex),this.freshSubBucket&&(this.totalCountToCurrentIndex+=this.countAtThisValue,this.totalValueToCurrentIndex+=this.countAtThisValue*this.histogram.highestEquivalentValue(this.currentValueAtIndex),this.freshSubBucket=!1),this.reachedIterationLevel()){const t=this.getValueIteratedTo();if(Object.assign(this.currentIterationValue,{valueIteratedTo:t,valueIteratedFrom:this.prevValueIteratedTo,countAtValueIteratedTo:this.countAtThisValue,countAddedInThisIterationStep:this.totalCountToCurrentIndex-this.totalCountToPrevIndex,totalCountToThisValue:this.totalCountToCurrentIndex,totalValueToThisValue:this.totalValueToCurrentIndex,percentile:100*this.totalCountToCurrentIndex/this.arrayTotalCount,percentileLevelIteratedTo:this.getPercentileIteratedTo()}),this.prevValueIteratedTo=t,this.totalCountToPrevIndex=this.totalCountToCurrentIndex,this.incrementIterationLevel(),this.histogram.totalCount!==this.savedHistogramTotalRawCount)throw new Error("Concurrent Modification Exception");return this.currentIterationValue}this.incrementSubBucket()}throw new Error("Index Out Of Bounds Exception")}getPercentileIteratedTo(){return 100*this.totalCountToCurrentIndex/this.arrayTotalCount}getPercentileIteratedFrom(){return 100*this.totalCountToPrevIndex/this.arrayTotalCount}getValueIteratedTo(){return this.histogram.highestEquivalentValue(this.currentValueAtIndex)}exhaustedSubBuckets(){return this.currentIndex>=this.histogram.countsArrayLength}incrementSubBucket(){this.freshSubBucket=!0,this.currentIndex++,this.currentValueAtIndex=this.histogram.valueFromIndex(this.currentIndex),this.nextValueAtIndex=this.histogram.valueFromIndex(this.currentIndex+1)}}class RecordedValuesIterator extends JsHistogramIterator{constructor(t){super(),this.doReset(t)}reset(){this.doReset(this.histogram)}doReset(t){super.resetIterator(t),this.visitedIndex=-1}incrementIterationLevel(){this.visitedIndex=this.currentIndex}reachedIterationLevel(){return 0!=this.histogram.getCountAtIndex(this.currentIndex)&&this.visitedIndex!==this.currentIndex}}const{pow:pow$5,floor:floor$4,log2:log2$2}=Math;class PercentileIterator extends JsHistogramIterator{constructor(t,e){super(),this.percentileTicksPerHalfDistance=0,this.percentileLevelToIterateTo=0,this.percentileLevelToIterateFrom=0,this.reachedLastRecordedValue=!1,this.doReset(t,e)}reset(t){this.doReset(this.histogram,t)}doReset(t,e){super.resetIterator(t),this.percentileTicksPerHalfDistance=e,this.percentileLevelToIterateTo=0,this.percentileLevelToIterateFrom=0,this.reachedLastRecordedValue=!1}hasNext(){return!!super.hasNext()||!this.reachedLastRecordedValue&&this.arrayTotalCount>0&&(this.percentileLevelToIterateTo=100,this.reachedLastRecordedValue=!0,!0)}incrementIterationLevel(){this.percentileLevelToIterateFrom=this.percentileLevelToIterateTo;const t=this.percentileTicksPerHalfDistance*pow$5(2,floor$4(log2$2(100/(100-this.percentileLevelToIterateTo)))+1);this.percentileLevelToIterateTo+=100/t}reachedIterationLevel(){if(0===this.countAtThisValue)return!1;return 100*this.totalCountToCurrentIndex/this.arrayTotalCount>=this.percentileLevelToIterateTo}getPercentileIteratedTo(){return this.percentileLevelToIterateTo}getPercentileIteratedFrom(){return this.percentileLevelToIterateFrom}}const leftPadding=t=>e=>e.length<t?" ".repeat(t-e.length)+e:e,integerFormatter=t=>{const e=leftPadding(t);return t=>e(""+t)},{floor:floor$3,log10:log10,pow:pow$4}=Math,numberOfDigits=t=>floor$3(log10(t)+1),keepSignificantDigits=t=>e=>{const r=numberOfDigits(e);if(r>t){return e-e%pow$4(10,r-t)}return e},floatFormatter=(t,e)=>{const r=new Intl.NumberFormat("en-US",{maximumFractionDigits:e,minimumFractionDigits:e,useGrouping:!1}),n=leftPadding(t);return t=>n(r.format(t))},ulp=t=>Math.pow(2,Math.floor(Math.log2(t))-52),NO_TAG="NO TAG",toSummary=t=>{const{totalCount:e,maxValue:r,numberOfSignificantValueDigits:n}=t,i=keepSignificantDigits(n);return{p50:i(t.getValueAtPercentile(50)),p75:i(t.getValueAtPercentile(75)),p90:i(t.getValueAtPercentile(90)),p97_5:i(t.getValueAtPercentile(97.5)),p99:i(t.getValueAtPercentile(99)),p99_9:i(t.getValueAtPercentile(99.9)),p99_99:i(t.getValueAtPercentile(99.99)),p99_999:i(t.getValueAtPercentile(99.999)),max:r,totalCount:e}},{pow:pow$3,floor:floor$2,ceil:ceil$1,log2:log2$1,max:max$2,min:min}=Math;class JsHistogram{incrementTotalCount(){this._totalCount++}addToTotalCount(t){this._totalCount+=t}setTotalCount(t){this._totalCount=t}get totalCount(){return this._totalCount}updatedMaxValue(t){const e=t+this.unitMagnitudeMask;this.maxValue=e}updateMinNonZeroValue(t){if(t<=this.unitMagnitudeMask)return;const e=floor$2(t/this.lowestDiscernibleValueRounded)*this.lowestDiscernibleValueRounded;this.minNonZeroValue=e}constructor(t,e,r){if(this.autoResize=!1,this.startTimeStampMsec=Number.MAX_SAFE_INTEGER,this.endTimeStampMsec=0,this.tag=NO_TAG,this.maxValue=0,this.minNonZeroValue=Number.MAX_SAFE_INTEGER,this.identity=0,this.highestTrackableValue=0,this.lowestDiscernibleValue=0,this.numberOfSignificantValueDigits=0,this.bucketCount=0,this.subBucketCount=0,this.countsArrayLength=0,this.wordSizeInBytes=0,t<1)throw new Error("lowestDiscernibleValue must be >= 1");if(e<2*t)throw new Error(`highestTrackableValue must be >= 2 * lowestDiscernibleValue ( 2 * ${t} )`);if(r<0||r>5)throw new Error("numberOfSignificantValueDigits must be between 0 and 5");this.identity=JsHistogram.identityBuilder++,this.init(t,e,r)}init(t,e,r){this.lowestDiscernibleValue=t,this.highestTrackableValue=e,this.numberOfSignificantValueDigits=r;const n=2*floor$2(pow$3(10,r));this.unitMagnitude=floor$2(log2$1(t)),this.lowestDiscernibleValueRounded=pow$3(2,this.unitMagnitude),this.unitMagnitudeMask=this.lowestDiscernibleValueRounded-1;const i=ceil$1(log2$1(n));this.subBucketHalfCountMagnitude=(i>1?i:1)-1,this.subBucketCount=pow$3(2,this.subBucketHalfCountMagnitude+1),this.subBucketHalfCount=this.subBucketCount/2,this.subBucketMask=(floor$2(this.subBucketCount)-1)*pow$3(2,this.unitMagnitude),this.establishSize(e),this.leadingZeroCountBase=53-this.unitMagnitude-this.subBucketHalfCountMagnitude-1,this.percentileIterator=new PercentileIterator(this,1),this.recordedValuesIterator=new RecordedValuesIterator(this)}establishSize(t){this.countsArrayLength=this.determineArrayLengthNeeded(t),this.bucketCount=this.getBucketsNeededToCoverValue(t),this.highestTrackableValue=t}determineArrayLengthNeeded(t){if(t<2*this.lowestDiscernibleValue)throw new Error("highestTrackableValue ("+t+") cannot be < (2 * lowestDiscernibleValue)");return this.getLengthForNumberOfBuckets(this.getBucketsNeededToCoverValue(t))}getLengthForNumberOfBuckets(t){return(t+1)*(this.subBucketCount/2)}getBucketsNeededToCoverValue(t){let e=this.subBucketCount*pow$3(2,this.unitMagnitude),r=1;for(;e<=t;){if(e>Number.MAX_SAFE_INTEGER/2)return r+1;e*=2,r++}return r}recordValue(t){this.recordSingleValue(t)}recordSingleValue(t){const e=this.countsArrayIndex(t);e>=this.countsArrayLength?this.handleRecordException(1,t):this.incrementCountAtIndex(e),this.updateMinAndMax(t),this.incrementTotalCount()}handleRecordException(t,e){if(!this.autoResize)throw new Error("Value "+e+" is outside of histogram covered range");this.resize(e);var r=this.countsArrayIndex(e);this.addToCountAtIndex(r,t),this.highestTrackableValue=this.highestEquivalentValue(this.valueFromIndex(this.countsArrayLength-1))}countsArrayIndex(t){if(t<0)throw new Error("Histogram recorded value cannot be negative.");const e=this.getBucketIndex(t),r=this.getSubBucketIndex(t,e);return this.computeCountsArrayIndex(e,r)}computeCountsArrayIndex(t,e){return(t+1)*pow$3(2,this.subBucketHalfCountMagnitude)+(e-this.subBucketHalfCount)}getBucketIndex(t){return max$2(floor$2(log2$1(t))-this.subBucketHalfCountMagnitude-this.unitMagnitude,0)}getSubBucketIndex(t,e){return floor$2(t/pow$3(2,e+this.unitMagnitude))}updateMinAndMax(t){t>this.maxValue&&this.updatedMaxValue(t),t<this.minNonZeroValue&&0!==t&&this.updateMinNonZeroValue(t)}getValueAtPercentile(t){const e=min(t,100)/100*this.totalCount,r=max$2(ceil$1(e-ulp(e)),1);let n=0;for(let e=0;e<this.countsArrayLength;e++)if(n+=this.getCountAtIndex(e),n>=r){var i=this.valueFromIndex(e);return 0===t?this.lowestEquivalentValue(i):this.highestEquivalentValue(i)}return 0}valueFromIndexes(t,e){return e*pow$3(2,t+this.unitMagnitude)}valueFromIndex(t){let e=floor$2(t/this.subBucketHalfCount)-1,r=t%this.subBucketHalfCount+this.subBucketHalfCount;return e<0&&(r-=this.subBucketHalfCount,e=0),this.valueFromIndexes(e,r)}lowestEquivalentValue(t){const e=this.getBucketIndex(t),r=this.getSubBucketIndex(t,e);return this.valueFromIndexes(e,r)}highestEquivalentValue(t){return this.nextNonEquivalentValue(t)-1}nextNonEquivalentValue(t){return this.lowestEquivalentValue(t)+this.sizeOfEquivalentValueRange(t)}sizeOfEquivalentValueRange(t){const e=this.getBucketIndex(t),r=this.getSubBucketIndex(t,e);return pow$3(2,this.unitMagnitude+(r>=this.subBucketCount?e+1:e))}medianEquivalentValue(t){return this.lowestEquivalentValue(t)+floor$2(this.sizeOfEquivalentValueRange(t)/2)}get mean(){if(0===this.totalCount)return 0;this.recordedValuesIterator.reset();let t=0;for(;this.recordedValuesIterator.hasNext();){const e=this.recordedValuesIterator.next();t+=this.medianEquivalentValue(e.valueIteratedTo)*e.countAtValueIteratedTo}return t/this.totalCount}getStdDeviation(t=this.mean){if(0===this.totalCount)return 0;let e=0;for(this.recordedValuesIterator.reset();this.recordedValuesIterator.hasNext();){const r=this.recordedValuesIterator.next(),n=this.medianEquivalentValue(r.valueIteratedTo)-t;e+=n*n*r.countAddedInThisIterationStep}return Math.sqrt(e/this.totalCount)}get stdDeviation(){if(0===this.totalCount)return 0;const t=this.mean;let e=0;for(this.recordedValuesIterator.reset();this.recordedValuesIterator.hasNext();){const r=this.recordedValuesIterator.next(),n=this.medianEquivalentValue(r.valueIteratedTo)-t;e+=n*n*r.countAddedInThisIterationStep}return Math.sqrt(e/this.totalCount)}outputPercentileDistribution(t=5,e=1,r=!1){let n="";n+=r?'"Value","Percentile","TotalCount","1/(1-Percentile)"\n':"       Value     Percentile TotalCount 1/(1-Percentile)\n\n";const i=this.percentileIterator;let s,o;if(i.reset(t),r){const t=floatFormatter(0,this.numberOfSignificantValueDigits),r=floatFormatter(0,12),n=floatFormatter(0,2);s=i=>t(i.valueIteratedTo/e)+","+r(i.percentileLevelIteratedTo/100)+","+i.totalCountToThisValue+","+n(1/(1-i.percentileLevelIteratedTo/100))+"\n",o=n=>t(n.valueIteratedTo/e)+","+r(n.percentileLevelIteratedTo/100)+","+n.totalCountToThisValue+",Infinity\n"}else{const t=floatFormatter(12,this.numberOfSignificantValueDigits),r=floatFormatter(2,12),n=integerFormatter(10),i=floatFormatter(14,2);s=s=>t(s.valueIteratedTo/e)+" "+r(s.percentileLevelIteratedTo/100)+" "+n(s.totalCountToThisValue)+" "+i(1/(1-s.percentileLevelIteratedTo/100))+"\n",o=i=>t(i.valueIteratedTo/e)+" "+r(i.percentileLevelIteratedTo/100)+" "+n(i.totalCountToThisValue)+"\n"}for(;i.hasNext();){const t=i.next();t.percentileLevelIteratedTo<100?n+=s(t):n+=o(t)}if(!r){const t=floatFormatter(12,this.numberOfSignificantValueDigits),r=this.mean,i=t(r/e),s=t(this.getStdDeviation(r)/e),o=t(this.maxValue/e),a=integerFormatter(12);n+=`#[Mean    = ${i}, StdDeviation   = ${s}]\n#[Max     = ${o}, Total count    = ${a(this.totalCount)}]\n#[Buckets = ${a(this.bucketCount)}, SubBuckets     = ${a(this.subBucketCount)}]\n`}return n}get summary(){return toSummary(this)}toJSON(){return this.summary}inspect(){return this.toString()}[Symbol.for("nodejs.util.inspect.custom")](){return this.toString()}get estimatedFootprintInBytes(){return this._getEstimatedFootprintInBytes()}recordSingleValueWithExpectedInterval(t,e){if(this.recordSingleValue(t),!(e<=0))for(let r=t-e;r>=e;r-=e)this.recordSingleValue(r)}recordCountAtValue(t,e){const r=this.countsArrayIndex(e);r>=this.countsArrayLength?this.handleRecordException(t,e):this.addToCountAtIndex(r,t),this.updateMinAndMax(e),this.addToTotalCount(t)}recordValueWithCount(t,e){this.recordCountAtValue(e,t)}recordValueWithExpectedInterval(t,e){this.recordSingleValueWithExpectedInterval(t,e)}recordValueWithCountAndExpectedInterval(t,e,r){if(this.recordCountAtValue(e,t),!(r<=0))for(let n=t-r;n>=r;n-=r)this.recordCountAtValue(e,n)}addWhileCorrectingForCoordinatedOmission(t,e){const r=this,n=new RecordedValuesIterator(t);for(;n.hasNext();){const t=n.next();r.recordValueWithCountAndExpectedInterval(t.valueIteratedTo,t.countAtValueIteratedTo,e)}}add(t){if(!(t instanceof JsHistogram))throw new Error("Cannot add a WASM histogram to a regular JS histogram");if(this.highestEquivalentValue(this.valueFromIndex(this.countsArrayLength-1))<t.maxValue){if(!this.autoResize)throw new Error("The other histogram includes values that do not fit in this histogram's range.");this.resize(t.maxValue)}if(this.bucketCount===t.bucketCount&&this.subBucketCount===t.subBucketCount&&this.unitMagnitude===t.unitMagnitude){let e=0;for(let r=0;r<t.countsArrayLength;r++){const n=t.getCountAtIndex(r);n>0&&(this.addToCountAtIndex(r,n),e+=n)}this.setTotalCount(this.totalCount+e),this.updatedMaxValue(max$2(this.maxValue,t.maxValue)),this.updateMinNonZeroValue(min(this.minNonZeroValue,t.minNonZeroValue))}else{const e=t.countsArrayIndex(t.maxValue);let r=t.getCountAtIndex(e);this.recordCountAtValue(r,t.valueFromIndex(e));for(let n=0;n<e;n++)r=t.getCountAtIndex(n),r>0&&this.recordCountAtValue(r,t.valueFromIndex(n))}this.startTimeStampMsec=min(this.startTimeStampMsec,t.startTimeStampMsec),this.endTimeStampMsec=max$2(this.endTimeStampMsec,t.endTimeStampMsec)}getCountAtValue(t){const e=min(max$2(0,this.countsArrayIndex(t)),this.countsArrayLength-1);return this.getCountAtIndex(e)}subtract(t){const e=this.valueFromIndex(this.countsArrayLength-1);if(!(t instanceof JsHistogram))throw new Error("Cannot subtract a WASM histogram to a regular JS histogram");if(e<t.maxValue){if(!this.autoResize)throw new Error("The other histogram includes values that do not fit in this histogram's range.");this.resize(t.maxValue)}if(this.bucketCount===t.bucketCount&&this.subBucketCount===t.subBucketCount&&this.unitMagnitude===t.unitMagnitude){let e=0;for(let r=0;r<t.countsArrayLength;r++){const n=t.getCountAtIndex(r);n>0&&(this.addToCountAtIndex(r,-n),e+=n)}this.setTotalCount(this.totalCount-e)}else for(let e=0;e<t.countsArrayLength;e++){const r=t.getCountAtIndex(e);if(r>0){const n=t.valueFromIndex(e);if(this.getCountAtValue(n)<r)throw new Error("otherHistogram count ("+r+") at value "+n+" is larger than this one's ("+this.getCountAtValue(n)+")");this.recordCountAtValue(-r,n)}}(this.getCountAtValue(this.maxValue)<=0||this.getCountAtValue(this.minNonZeroValue)<=0)&&this.establishInternalTackingValues()}establishInternalTackingValues(t=this.countsArrayLength){this.maxValue=0,this.minNonZeroValue=Number.MAX_VALUE;let e=-1,r=-1,n=0;for(let i=0;i<t;i++){const t=this.getCountAtIndex(i);t>0&&(n+=t,e=i,-1==r&&0!=i&&(r=i))}e>=0&&this.updatedMaxValue(this.highestEquivalentValue(this.valueFromIndex(e))),r>=0&&this.updateMinNonZeroValue(this.valueFromIndex(r)),this.setTotalCount(n)}reset(){this.clearCounts(),this.setTotalCount(0),this.startTimeStampMsec=0,this.endTimeStampMsec=0,this.tag=NO_TAG,this.maxValue=0,this.minNonZeroValue=Number.MAX_SAFE_INTEGER}destroy(){}}
/*! *****************************************************************************
  Copyright (c) Microsoft Corporation.

  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.

  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */function __awaiter(t,e,r,n){return new(r||(r=Promise))((function(i,s){function o(t){try{u(n.next(t))}catch(t){s(t)}}function a(t){try{u(n.throw(t))}catch(t){s(t)}}function u(t){var e;t.done?i(t.value):(e=t.value,e instanceof r?e:new r((function(t){t(e)}))).then(o,a)}u((n=n.apply(t,e||[])).next())}))}const BINARY="eNrsfQtgVMXV/8zce3c3uQlclLBIUGdvogQRCUkIQbGbmwKiVaGWWoqvBAjCBoGEBW2/kARRxFelL6vV6iZU8bNY8bOtQsWAWkVbLb79V9uC9VU/W6m11bZ+5u85M/fu3VeygbxdabO798ydmXvmnDNnzpz5XVKz+hJKCKH302OqWXMzqabNtBn+NFbTZgKXaHM1a27Ev00EvzZWe5obGxuRpDQ3NpJqpbkZCzeSagp0pVmUbaLN1WpzU1MzqVaamkT5piYsL2ukTVgFba4mpJrgtWbaBB1oqlabsVoKtbBGqBev0OZqrRlJLJcqtSvWajULVzaEyVHKn9nbLCdPISQ7b5RK1Ozso9TsMfnZNMeTTYYrHkXxU5UQouZSv0I9wz2K+B8lZLia61FUv0qVPEVR8tRhhjKaMq8ndwQZTbVhR2gE7stW1bHkSIL/0VGEeIghClFRwKZ156oKl+nRiYTRw+A/lY6iPkpVSvGPT/7P56OE6fgP/9Ozsrwjxe2id4qvl65q8J+Srap0FVE1hRLq2URHNdIZdhG9mVqH8sddRUx1xPLCHx/8GQl/xsKfQvhzIvzZvZFCDdddw3TvJyc9QHO/evrZ8yqsc86xvn7R6TOUYdmzl60Or7y4oeaSCmW47vyYXK4Y0V+lJcqI6K/yMuWI4XNrFtXVLnauKUdqF120ovZSomsXXbRq2QoS9F500ZoV8K0y66KLFq1cvrx2UZhY+kUXNYTDyy5aWLO6VhnpuaT2kpUN32Bk5EUXra4NWw0Xr7mkdkV49Zm1Ky4OLyUzRkU7V7Bo5YrV4YY1i8IrG8g79CgX5eLa8Mk1a8Irz6ldveybteTPMcTVscR3aWHcnUuXXby0dnV4XkPNorqahctrz61ZvqaW/G9MudUpy71HA3H1rQ7XNITnLbuk9ivhmktWnbW6dhH5S0yh1ckL/ZUeG1dT7YrFsUXejymyOlmRg/SYuFouWbbi7JUrFtQ2rBQ9/hv1x5eouUyQPkhga3hluGb5F1euWREmf6f5CU+6eEbt2mU14WUrV5AP6ZHx1dbWrCD/oEXxT7U6vOySmnDt4lkrV4ZXNSxbET59RdU3wrWryT+pe7wbahetbFgsOvZRzIO7KF9bFl4quvcxPSF1kZmXrapdFK5dfPqKcG3D2prl5F/xzMaiVnhubcOi2hXhZctryb/pOFeRlWvCq9a4yDOWrQ43LFu4Bp/9P/SkGEFd9Y0vrmxowBZnrWz44sqVDYuXrYBHnnPJstWr4Y5P6GjXHTWLo4pUQf4vZhTctMnl5NOUxNIS0pGSWF5GWtjRscQ4DSbrYwqsXrMw3FCzKOzq2OXsmM4KTC4nGzovUVpCrui8RHkZuZKZSUrEd3YjG+EqVbti0crFteQqZsTIwOraMNnE/K4exliRq9kYNynBjMRQE+zIcfH3pjIkx8VXk8qSmPE1JjUlZnx1SW0Jj68riTHh8TUlsSbHxteTaE5GJxSJ2pMEBscYlLGJD+yyKNewkQk1g0m5lo1PeLiUNuW62OF3G5XrGU9BilqVb7EJnZRJMCs3sHi+J9qVzazIXaZTw/JtNilWeLu2LN9hR7lviTUt342V+Djb8r3U1NIS8v3U1PIycqNLrwU1XmN/EFsiiX25iR3baYnJ5eTmLoqUlpAfdlGkvIzcwgqSFYnv8a3sCHcxaWR+5LI8KBJgZW5ziVlpSYyVud3Ft9KSzqxMaUlnVkbe27WVkdV0bWVkjV1YGVldF1ZG1tWplZE1dWplZD2dWRm7SDIrI2kprIzzwC4rE3FZGbtmsDKtLitjP1xKK9MWO/xuK7OF8RSkqJX5scvKJJZJsDJ3sHi+J1qZO11WprSkcyuz1WVlUHi7tjJ3uaxMaUmclfnvWImPszJ3p6aWlpCfpKaWl5FtLhsiqPE6e09siSRW5qfs2E5LTC4n93ZRpLSEbO+iSHkZuc9lZVxF4nv8Py4rU1piW5n7XVYGRQKszM9cYlZeFmNlfu7iW3lZZ1amvKwzKyPv7drKyGq6tjKyxi6sjKyuCysj6+rUysiaOrUysp7OrIxdJJmVkbQUVsZ5YJeV+YXLytg1g5V5wGVl7IdLaWUejB1+t5XZwXgKUtTK7HRZmcQyCVbmlyye74lW5iGXlSkv69zK7HJZGRTerq3Mwy4rU14WZ2XaYyU+zsrsTk0tLSF7UlPLy8gjLhsiqPE6+2hsiSRW5jF2bKclJpeTX3VRpLSEPN5FkfIy8oTLyriKxPd4r8vKlJfZVuZJl5VBkQAr8xTLj7s7xtL8mh0TT06wNgklEizO+GR1pLI645NVl8ryHJ+s5qTW5/hk1Sa1QIXJ6kxihQqT1ZjEEhUkqy/RGo1NWixqkZIORIxV4smZ4bJMv2Gjk7YC1ulpNjHpg6e0UM8kio7bSv2WFXZCjlqqfWxSF+USrNWzLNkYJVqs59iJ8eU6tVrPs9JEZejacr3Ajo6/LdZ6vZioRXEW7KXOS5SWkJc7L1FeRl5hZpIS8bbh/yWWSmLRfscKuiw1uZy8mkax0hLyWhrFysvI79m4VMXin+IPbFR8UWnl/sjyEsUJLN1+ZiyuhSKuxzzARsRdm1xOXk+4WFpC/pRwsbyMvMHyxMX47r3JfHRmVhYlFtUVOuu07B884nub5RJOONlVRa9sb71Zv4SyZiuSbbzFrM058He/D/7uu5LipY34ETkC/u4eg9+RvnkfMd5iBZpJi5hqNdYHiFLJCaenqZWcFDF1DCfWyJDxRfyB9Byq6/ouSpXmAg8ns0Q5X6FHZ5V2IZPOlJfH5FCdU/xqsnLm44wzKKPUc9pQzlS9wBtgQM4xqUXPUpstqsG2QxEjnJ6uVlqRbGt/tjXKGmsQonNqKWHrsY00VMSIxev1gALV+QKUE84KfDMtxpV8qBceAZqjnMrmCF5mnJQzn/40pWozkAj0VrFa2OlqM1csda1mHcsV65OOjg7F/jw931QurjNVy1sXYFzhqqXWrbWM1dA6hdZVbMTU1EqucRXq56payVWuwRNyhTNLDYcsFuYkVMSqOQWmxVyFu6q5Clxj4ooYjyauXFoPzXAFeq8gW4FdxGri7NL6ckZ0Xdd/yagmHsdkUNpSQ5xZjfUhU8VrFq3HG1VDhaqiZKUc+Ay/JS/EHQGmc8VicBO11DqoA+gBD7AV6/DAPYpTh85V6HgDVAfsAeYTpJtMMpdJ5jLJXOYwl11cZyrAXI0z6Jxgrsm4FsM2fDACbEBu+LiCXKTI45jCcK3a5hPlWhj7pUnGEiGllLMwSuBVlFLo3qp61gykSM5nfSaccWodGbJW1VtqnUkto25WPowOsAE6YtQFQLL1OpNZI09XK4fryFlWz5nlg4u0oUEwV3QZPnxYqRoKmcxiQCSclbNIDnJV02+klDUHiUktciYoAqd1lcQiszWL6Gol0a3N1zCohljbbxRfQFUt/+kwthYLAz2EzVkkQBUYOwNolBPJG6dENacWDQUo6DIn8BXVGlv42Y0sSCwjbHjgZ2G2/qhClWZWKf4VKMMUQpmiW7RQsUiharACb6GnQB2uF/hmBliBJ2pHCrycoB0p9AieK/Wc4QXObFPRgN0tVKWZgXpiTY3dhl3xLLWyIE9YKdiYPF0YGmJSeFLjLQbPo8rnSdqZTjoiOxHXg4KsACnwFmZxUujlrNBnUws9FitUdHx0j0kKvE71QHN1T4gAfvi0AirksrHeUkN1hTg4IRMLz1ErC7JnqpWGFx+iDsyaNbzeopzko2UUWkrr9THCsBELjCgpyEb50a3s4XqBFwRcWEBozyKFim4R/Q4Qrs/EUCgjFcpoUSuf04vrwpyGLFoHlVqfdnR00NPzTWprJRMmQ5o8ahsoeM5mTsP1JprSpXFGThNPCYpFQ7IQCDxdaoKswu1LHbnEGywwZS8xSptZJaczYXazyMkEbwKNoXXiJ7XYWTaRig8GnZJkZilOQY9TEK2tc90nr3NSZyn1JgP+E6GQlLM6nMGgSbhDKLF9R3QgObNyJBk03i442imYIz4M8TFSfIzmzBrr3Dba+TbS+WbU2V0hllpvjQ6ZLBQQ/ZJKzeeAUFWRqQoRHz7xYYiP0VBEyA6XeqDrf1NghiDWe2Bz56iV1n6fFcmyrmDWsTCxFtACkD5WabUYAaZUcmb46gKsACacAnpP1V7aVPUGadlqtfhChSyH6ZxZ5IxcuNFkBZ+xvsV3upUd5ixUyHTdFuKC7IDCiWUAK9HYf0k0vF23nlKso3FGV6wczhxDC0w9K9/UjCyTzVQrgzB3qVwBowysCVtq3WlhlFrt4rowiKwW4hrXbKkNWR0dSshqaWmst4y1Jsz36hn5aEVhQpZfiC4mZSMsDR1XuGZkwawH9n0MEA0Vv5seq7GeazD7G8B2xj1g4zUxo4BQhUKmhnOe0EWsStOwYFO9GFKYbu3pVYGnIdY6nLphPgBBQa/EKMgy0Z1QwJUR7hFMiDjVwV3CbDWIGRCcqQJq1wvdKATVHBkyKSdGNqf6L7Op0owCo9TDfAbTFzEVNPacmipOAODOTCRScWhdgMkZQamfqVaCHIjHJmhtpIYUMVV6WEXMB73DbznwINQyQih5BjQCwixrZJavPkU91PKJe3yhALDEUmNLwowZoNKqA51J+iRKTqFoDwSdSbp0dqh4Ln04XOMo3eIfPp5F6+REhg0FtOgd4hsV1oWFHJbB9yRcU+qExlgjHE5RU7F8Ya5Zo9c2OA+rmSpcVMRFyb8sUVIVFyUrc03NVTI1V0EPEztvKhazh5g5ncXHASspO3uE01lmKpYBnTVcnfWAwEMXDFdns0VJVVyUnR1maq6SnXSWRjvbpRRiF490uqiYijUauuhzddFrqnBRERdlF3VRUhUXZReHm5qrZOouopwaMdITLwtSDAYjVZFUReoLV1yFhOb4evvZ0+iDmk4f0qiHxdWTWi2S2Az9GUYZ+CEsgII1KxdmYFLHwSPgqkXDdWeJG7hq5IBoi+Uqp5a3nhPLC24quqheqFidmavCXXVQG7gyoiOKEH7G5eOADCqVILxS8scrOMmrlg/vRAsp7SXKKxRGq56yStkqlNYSOsfVUFz/TBWXT1wNJesR9CNaQnTO3Y9UNei6fgKusbiyPKAosGpTvyQWpFCUGbkwT4dEN/XrMLSQZ6l1hXkFedZ119DZEAe4hln7rmEWtSg6LHnoJaExH1lXxAyLrrVo2ISlmfu3GkJHAqoLFeZZB3NQ0wvyYMgN3cRVGAP5wT4o2HMjVxbXOdN3w+oQZ9HNz5A5qvyyCteAm58hK9AhVnHBh0tPxXqDrICl1ifDQlNwDfwGWRX9XcU3XiG5xqn1BtYIVtm5n7rKOxPgG9AO3JBtl3dKu0tqaD0dUnHoFEp0/XqVqt3h51wXu4ahoHFS1dHR0TF8PlA42WoyK3K9Ryzq3yDiM3uORUPQAWCTpUCA4R3vnJAOl1rueV0VpXZfceocy4PlWr73v68pcywflGx55OVJc0I6GG8axoHB+AHKsWFo0GhVS8sP73z33j/RebCQqGqJfO+O64+W3/e9+uiHbIGVHYIfe++NHLcgpOEdf95w3x9GLbBykbD7qb9fsYUtgC4B7a73rrz32fvs6lqu+PTOPxwYscAy5K2R3+7dv/dP1zQvsI7Au1s2/3LnS/cczF0A3WTuboImVcETLMCxsWWBhsCFR0KLKT6b1m39bAYF8THVODFRk4pJbHV46wqzOxLGyVbODEN3BJrqN+YqWpPSnNXI6c12KnBlLQi286tGRJnaIKYhL+4P4sXb7VsONnNif+1YmO8qebC9Rq20vwc52eKmiVpcVwhxlx6u66yR012mVlW2yVSrOoZvqHrYu66qhS7gZJfJ4KpSRddVfTp8QQNE26roRvjZIf5bucDdMhDn5rIx8srHzZxVtYj/Pg5+OZeNAQsbEXXI66vO5SzmZ0Pc/VHawQ7y5SiREK5VBTfNjS8ybxa0QzltwzVTZ90FhpvkhxCSqApu2qo2s2YLai3bBGwwWVWHd14uGWMxzqru950LX0kVrbrfx9m6jSarouu4tqGKnAMEUBznB9MtOgtW1/km2cJFR7fmi/5AQ5WxDXmiDXniGvKs22h64hrSuCfakOmVAcpWCEJsyVF0rkClAcVqaTEswr0WnZUf8HFm86Cjg2yAdVfMWLvZEjdmUYJ9xzzX1ebocKhVLcY8993nzsJntqW2+Ittu9ydsAtGlHVgdebm42pQVrDv7jv+HlxnOrVdtmGdqeAPXyN+rNrQbmZzVjVxU1UH2bDV0sLW9vyQ6Z2gEFNvczrdGsjhrKrsqh3msBmk4t+fVp30VrCNeycoRsQkPIcr7Ty7lettZnbEHB4JGHw4H24rYHubqbcFRnCD5/Ac18Uj2syciJnLc/mwGcUXP/Hdr/39pFOxztERTrjRyodHIjyb6/yISFuEGzy3ledEInw4H9HGh8/wSO1um1H9VfjvzfYIH8GHz/jmj8fjr7YZZ3/16zfffPOfg+L6o8Hjr51ADgbbZvx55uxbzjv9g/ZIG/4zScTMbuUkUpjDGrkGXKnc0G4Snr3L/q63mTlCibdaHcPrTa/1pLfOCs6JDnd7dHh9+VzQkd9zcukYKa6N9hhvtr8Y3JfvfG/T7K8H7S+rXPRVbTr3Wlf7oEKLBLw6z5nx6eUTak/Lu7jSHqeKL0bMXOgoiAXduBX2HLafEjKzxis+7ruHs8aqiRsbAwrP4bnOLa0mDAoM6dr2tgjPmXHyKbc99MOPcna1RcAMw6hyCuPQWpDz2UDAeJO2AOVZEyCKg2VmTJ8HQ/CrYNuMXf8HUvnHYATvpm2czPDv+/HFI0asD7bN+PYE/2+/+tU7gBggHFSONUpB9W2YC0FxW043Bde1mxTqbovYHGhugxndKXIw2Ggyp5CZ7Rj44CKH1QeDPPtOU+fZETOH6zynlWdDt7JbxU2RCNdbTeKy6I1RxWtpad7QrnGiazxbl0UM0obLQcVpV9f1o9G1R9dFeGUiPGtR422m6xsV6mmG+Lz07tjagPqZM5PTuU9jaiJKpomIHfqnGoaA4F7hEEJHNHQRTRGZNaXTBXROrIM5nOTnUF24rXgrLDtEmJOYHlh6etRK7nH8Tg4uOES2aCigYAA5j1OuWe/lYMR2rUmXh2wHQsUQrXSKtdS1ow+ghrjH1Y7psWgY/VZPCKwVjZaDXlNBpZyFxH6OqztatAkR0nQ1QWJdaiNXl8ziqq7/S1VYE2v2NLJGmJEpDvPB7//3R8F1+DXy/SvoPBi5qM0zPbscG+mdQQivPS3vo2BbwAcP02Zm8ay2AOE+nsU9Mz5STn4t64k/BNukUr7dHmkztYiZzT3c2xq9mXtmkLb3T/pEe/vUtgj3gShqEbB3nhlvnHdw7vJLnwu2zQg2QhUvt0ew6vK3Hztmbc1TwbYZb96w9vdZTzwDlgvvOCP/4Lxnr3gs2Dbjlq2LHwrmPSHvWPLXBUWT7t8dbJsxveLErW9c/Yht6yIYy6gq3gTunFFn7e+gbiOGU/kWTtH/oOhmONMQeA0U5k3FOthB6+HPLA6zI6vPj5k646eq6PSEKwH7t5iWTtpUFdyw1VLDpmJtf4GEAqqYZrg6QfGBqaHcPXe1c8Xa/hoJmcoEhbRyZYLia4WipM3UomPlibLb9EYCEEvxtXJvBKZ891BorqEAotZmEq7NeFi1h3LaBjmU4HzMmH2mIsfnP5NWLcbxwXEgUNNJ//IfOG4hDNJD33m36H4xSDDCEV1/iTLWTJtgtTteGV1FN3J6rlpp7XuDWJFniRWhlhcjyoQ1Q1i0eBv8XbVtY0C1KCoY5Sq46KAI4D04c/+54KOpVXRjQHVpCYctLgzcFlt0zfJyVsaZ2CAs3gZ/D6vmbVOVIgj+TlUMvRW2PNJcn4lt7bGo6ri3CMZRRAruolMVHv1aLfYbisSeQDEnVbhjtGrbxqlKhbgoNxFmi4+54mO++IC9GXoyWWVbxbDYKlaEPVXEroMidh0UseuAH1x8FHHFmQ6mKcUxvyowogu2VRh64qL5Yn4ZYu9mtP4p7S6L1FQs8kW/znY2aMQDuFnExUUX+0g83+YKFs23WXS+jCYIFjHBIiZYxEQLTLCIiapZDItYUhZZzbBPsEllcFQXuo4d5Qx3e7hyMuEuUztNmS+/F1Zy5UHjiPuE6BFOdxp5t95dzlbhQwrpraLrpiqbIHim7jTybrkbFt915Ww5PBZXwuWsWGyhg/iXw3QhZB/8fyK51IJ5F8YoQSsznqUgJhGKW/OwMpXMt5C+qg7+Lq+zgqFytrTr4TQVMaCK9TGxhhm6qYltfLyoxUiNFiM1GkqNKDmWa4LpmlAHTYynJsZTE+OpCT3QxLBqQg/wo1p8LBV1ruKa8Rw+YxgfUXMesRu9Av4afrkiB5MI2/EaMkxzpJUYz2M7i2NZqT/CRHCsK8fHlkLh+AhBFaNkWDQEQi82vmWgZSbu/UXeItb+t4jVSi0O9dgbVCreZ2K2y/I1GKDn+COMMlPPlRBsWolNNkGo+2zJh2kkhCvbUKs4C4HIjLbVRTXFztZMNdpwG5W7gjLfRXbXZLD9JVrGmBC0zLBl8G1AyWfj3pyCLTNIf4CW2Ta4sopTbJlLN0bvYLhjDbUv5WQ8SDG94htb60xkyarQtk1bYd+yiBWPEV5oEQuPgR1D+FKHG9oW3r08vDwkbio7G7dkKafGXK0gzxrdlWQntaOYfULBJySYC4R8gbltn2oVit1SSBRSoQKOmT2qSCrBYCvML6pTiQZjrLkreUW1DFmJVs5GYiUaVKKJSrQQV0VMfTSGish4ZTPlwpuDH5sop41Tlc3ofpBz4NJNlNNz60WKCRQ4N1q2qvlKTjdMVW7C/US4dhetgvvvovpFlDbCtQmKD418ESMPOMEn+eXr0S9YsHWLkXerY+kixhFtGPcHUrQg3RKZpvgOR0lWCSUpQiUpEkoyNkFJ9r1HrJeTKUlRzyhJsa0kY+OUBBp+JVFJinpMSSpsJTkJ+eCzlLWcniXy8A5+QKz1WdZuItysIty7VcKwEaD/rptB+5kxQWaCMXnMx8Dlx7FrTZZvUjvKTGWUmdpRZupEmakdZaZOlJlGo8zUFWWmTpSZiz1dsQBz0j4UwxDabk2EsLkTMSUOK2gsK55W41hBw6FJlOjFYmMc7zkjWvwfw6xJrtLyj8/I1a+D/CqLFuqSf5hmJXiYS0BM7dwSXJWhEOVY3ujuhZBOHFvb3ZFpA0Iwo1MNw2QDubDGkq5mXU3GNIjpg7kUBMOaZOjSEYy2qjitKpiVIHPyoq0qYIriPIIAS6dlxfLaLReLxTLharRl1WlZFc+rxrTMwFiOFDtkXBUlh+vxQmltzsHxeX6YlQW//4yJUjhBofaPtpSQxdZwGpotWWzA/8/IFxqKZM8aE7Kk2Bn5oQBLw/BQYXhkUiDsIClh41Wc8AlsdmA6LJJsxW/5gFj7FGuYqEDYG4VTIwBMxfQ3LO72eUVFPpPKzXHDFBKg2iquV8knHQ0puBB9WWPRkFEgsqBC5Ww0Lm2UM2SinBKymo0L3AsZBsKezExcl8RMgNNKINtSNir4ivvwVDQKEysLl7PRBXmWL03bDVWNlEEMN7O+Qy2PZJat4lXEOA5qBtmg+t8ZU5tpk6Nz8UKIKQiwRPedrlaK1GYykQjDJSRDRoqYu6+5ahp9u1u1cuP6ZhwT8Mi+if1JrF+qGvYDh7XaVC0irILmKqLFdEFxBb5AOHJMJ3nY6cLfidMF0QhYLNU1gndSayIOIKZfoYMRUGzuebhyDwotdOyejY0BD3pFAcgM023TyT2JymZidh8aOH0YowynT/CfxFxEjUWw4cqcMpilQ+1y0gBSPY21A7Pz6XKsCsdU2tdwSJitfbLeL3Eqs9Qa1EqwCts/JtZRMqjA5EihCSCOlRUVYaq5Y3X0O8A8YXyiKnjVlSat8m6aKxRzq7ECU3UwstxCr9hqrOC0aphNrvJuckp4N0UL5DkFhkULDHMVGOsUyIsWyHMVKHAKjI0WGOsqcIJToCBaoMBVYLJT4IRogRNcBSqcApOjBSY7BQgW2Wqs0O3/Bsui9ve9t6gd83lb1P4h6aL2SqU3F2Rr+n5BJiLpk+jhrsmgHliWQZpj7y/LujTOzYNGZ/f3ns6anzedPZBUZzf2qs5eS/tBaRkoLW7RHZ7SMqG0QmJ6W2kLulLa79NBo7V/6j2tPeHzprVvJNXa9QqjTUpSvVWieqtKvVWieqtKvVVi9VaJ09tW1Fuji4FRhd6qQm/VqKKRWEVzFFacpIQ7XYqmWAoo2niFVNHGAHPXo6ZQ2M7qweUp5Lb3t8L+hOrjCScPgFJZSp0dGd0XbLvlbouFTWJBrNJ3Rr5F6/QJhMtVqbX/E7G0+4Vi+cTSm1OjrJxxuWmofwFycGVpeQ0O21k+sdJnlm+2Exq6wF7QiSegxhT9dwPeigATlWQLetPWL0u1JsZbAji6YNxH5WLbrZYxShah8VrWtVnCtt1mqMyJn8mLMQqvxCi8IhReEWbI3l0VZkgRZkgRZkgRZkgRZkgRZkgRZkgRZkgRZkgRZkgBM6QBPzUM4NmP1I1exZshBcxQnN3mxHgrmRlKjAs8D+k9EBUsyLPGJoxe8nleHqczfkE5PQPDyS2f4nYuNY4NEBFbGQnXODGG2xdgmd7SIU/ntXQAhYp4GsGqorfCIStiDLcOdhBrsogCQNo4mA1vORvNKrl3IiHgAxll3FvE+CxxTpd7QVsgQwTKFjEVE5XcQkFdQoH55vdJbwUrrITKxoJjMhaix/taKGr176RWO0d7UVmhrYvw4DkNoDPDAx4Fa+Dcg0fe8Lw6MwpNxbiAYxaCE8KDQ9x1AQ+quMq9IPd4p/EA5prb54P1mHgqwXgqs+OpQByLEpA4qFsV5ukswsZZIAsPF6SKsimuKJuSEGWzpSJVlO2nakIEkDMnAggDlDVXJLTLqQBsgRoNtUGgLRqKc9NND7DHqA54eVZVB92wNaDxrCrfpkAWV/B+z1nYf5+41QO3+hL67xP993EPhOhEppe7/+8Tp/9YgwdCdF5XiO4+O0TnBZoa4trJhNghOjHEOscDVqo7Lpc4UK8yRptY73kFO9EryEnTK5C5elE3Xk3uxhfkSXnkijEOXQAxVklvsl0A102cGdPsUHh/zvePUf00CH4fuxZD6Zj6MbtBDDOEIF8mMgYpts1F0p7V8umGy+ot36WcWB3rP/HWW77LGvTVlDbF1OSLqel2GlvTeIWYrMq3qeqzGq46ePvuDrIBMrOdH1W+jVeYrMrYVNXRsaHlYEcQyfJrlbHxiip+jT6OyMbOija0l1gl7oYmEqJ/F3YIMYAK8VZTwnJYyiwwcldSOI38LBP9g/PfEkgEDu/gPhkCiTD8aiY7EqsXaCYTp2dxP6XBDRThFLUP1VIE6SB6ROxGzET8BuwXsft1GgSBN2K//sgsDYVHsRC6gxiKdmhgJ/KEL+PEOeFLeFxRIruOQCX6NFKgWOQMOLBVoKiVBjai64ZvTMyFxEPa+mR094rYXDc0QhGrjv252MQhgZ/6a26gh67/gesI2CDDphE64ogjjmAjR45QRhw5bLhqaB7vyBE++G6MHJElP7Plpz5ypPiWMyJXH65LwAexnZYDaAAyp045XYw9MSGAwLDH4jAwnicdIe8V0XtOQjgxynN4JPa2KCTEcNc/uT/mZkdO7E8j9ufIKLOcXrvpPjcd1NyoEuXGxpYLd1HP+fF0knhDzAWjSlq+1PfpHsJJoa6vJXjoHfAm6iy6tpBZL2RZ+7IAVuQV+8u+rELN+jDLOoi/Pra/HMwq9FpX6FaLDr822V9a9MKs+PSNEyqNI6IpwIW5+mOMeuycjLjt7ZgsjOjxPU5my+1M+wogEoDrdFAXHkGcUyWwUd7TRZY1ngacGXccEPepwib7UgN6GPIUoCq32binztROlx4xq+PKCpMtD3i5ah3EzW1jGPhJIfilcW+dkasJkmbk4toSTg96RL40TLQFedhTHxSJeQxjH416mTAFoHsqE86HO+nWNHGmnteNPEhqjMApEba+LFaIuR7W5twiRkaoBBsUrrverkJibaNcuMe53nGLdcXaTq2cmFXMUvGxXHysEh9h4aZfJj5aqPjcJD83w2czzJeidERevwtcYzV5ToAiUkbegY1LXYIOuZcmRCxNErJS4WI0KxXqKhYfZdHlU7N7+WRFfOVsLn6ij+u0gmtbcW+1+Fgc34NuNm2PgSo2YeHopbV7n/BYTrXTme1MZxAYY4Qpd/AjzyO6S+R5WCgz40jnEkgdYDHAT2MkVrXb9iDEhrYGMBy7nxfN7JW0AmJq0fSqQsSxmCbca/SbjwLxQMcyUSoXCqn0pZn14CQeqtH8Bsj+O8k6IpreIHbFR0t3Vo9QDFx1MzFAjdv5hlZ+APIrizp73+j0jjYpV8D3Rc9XRdAVpK4ySWibSTc9xuH8Hh5b3raxsYquw8O/Mp+g1cMU0cORSXJ44kJemHcMs5XxEhVrHVX0NzYIBv19gwiIFhm8wlkJlpSmB2JYIt7l49rMXIV7oEQOHO+QKxYIz4BdmkjIPZiwPJHMt73WCvgzt3Gq+FIJwfrxylxcDWNPYn1o6Mm7xNKjPrQBy03JN8ZVh2+aQAmDJSJwTuUeN++gN4J3TVxpxFxq0JL5uuSbzTOWgmc8JZ9OscYcOptsJlWRc1R0mkSq7GmwpMf1+0hUU5xLzwiIdG8IgxHx7TOHvwhTy+WPuVNFWuP5DqOL12HMzL6ECebyRyWmmduUnU42Yxv8nr1zCySHd0quECG5IjmumK6O3XeyiZKNZofMAIGhuwuXNL5zwC68LcgtVAw2No2zxUg5PXFioMtpRd4RRTdS4R4nZFbZi68PVCsfLjzOFKWJNqaVmxl7cgtXVHOdY1uO0R0u1+eLk0R9/2l77XlcSItxulKZuvjHzLYLdvEXKWqmJu7wQD887jv+xaxj3At0jXuML4lysGgWNy7lHlhmKWJVjRriDW0LULgMm1WOZmjcG4J46KbGJs4abdicneLRd24JqNFTWPuYQhtZUx/x8SqlW3zcpHSXj1cr6fNRjeMjeG0qVzY9xpVYJu7ktNVknLXBfaN3tkVsjtoMvT1AHUdLvwoAFOXkEmO4JcoWp8YoJ7oQO6eg7KjWkXYUQ07lsMAH9zAnLhocH+XQ4NCEivlmkIslLZLKNbmsYWdI5qnOeUDNKebDs3+Yux2Fz5FRe8ehBGMdobFpkHJaTZzKH4UFcRpbOHEh2ZR7rq93kbkugULuacRsabmGQQa6a3knuuNK0HS7QoN4oCfE2XRMXcfdm/1MIF507yHIROITPub+PwuAN2OE7abnwDV3HBkMYsu7Eg6u5V0IFENHDziH0DgzzhZOiB1QY2kE1EiKkBqnxhyAsCliZXCGFeEURaq3KG8CBhqt4576UECqCyQKqs0WCUiBCddpXNNlsjc4MDHejuiWqYa2iVxQzjY9xhmolOJ4O1MVQzqB+uL0PD63LzYWPVfO3Kns0x2Pz4bD5GJT4TB8vrFx+gntPJ3S5ys+LJ/vas3t83VjyzPq//3O7f+NjfNroO+30wT/ryiZY+NSF3u+7cohXAoyv8p2COfCn6WNU8WX+cIhXGo7hGPjXAjo2h00uUNYfBgO4XzhEK7CkOzSuSDBGp7ywC7GuT/VO7fU6uiUnSOcsrDjlIWla+VzfiyVTlnYedjZtlMWlk4bd37Ml05ZOEWz0ikLy0Ms0gWzOYlnC42xqTm3k8Y7X9x2voD8S5fzFY53vo52nC8oukc6X28xRWmmTbiMH5mmusgjisKxprfeF9CiO7fgNT5gHAFZyRDVaOPaTu5pazXpLaYHTl/boR0gOhgxrUvy7xNLVAGyi8CWIughpjHFOjgMAF8PDounY1BEFZKEwXmuGsOxJr0gLwCgiiMcMqx1/4J7eCp8MYbbFJiJVM7EjeJgUbIu6NgFPZ7ujsvgnObUpNsjwPTzunMSFaGUMRBjTxsYiIEM4mSBmD9ksSwRiLmVHlLqU9KDuIe6VQwfq7oM48CTYhgHgg4wA+/+X5wV4QJ8N4bLUw04Rhh/9gJ7vW6D9YDHGiVtnCByanwZHBgwUNx4mZo+tGMW+OgvUzML0DLzrGzjFTR/IwvyrGEWA4pH5DJ4jf+HTif3Gl8xs2H/PHuCUuFo8SJwDwIqAAeMV8hOzrYY8+x94DNl2G4up9ZBPbo/PINnxVYC94Dp08vZbE65q+h0WUVlXBVlXIMGufFV+8aK2BtPlDcWx91Y6NI4FyZHTG9atxjztJRPlbpLqZ8q7c7ZT6UHsgvyeDYkKFCeHS0BCrsbFJbD4ay/uDbdVS6OsQghsd1WZ9RpOZvHiXFmIAetUA4+EpjT+fib8BzjLHFNK2fni2uwkSeeHW6vhvpATDzlbDEsMIT7b3wVpHCpfaHI+CpI2HLxGxJMjK+Cb7mqIA+PZeyHzn+PCiNzE4XfYJ5ss3MdrCQ2//UzM7qZchW+RWlXULEQ2oRTXfQ6aPk+uKUFbtnnviUseHMZHGeKsgrksuV9IgSz5X0XE2eAnAsh9MYK4W4oD0O+212+rCCP+8Tw+uKG930ix9ddvlDYriKREOFErgvyrO0HcVAJfHFR4HwIFDWlo3wrFfZtK7hLatJ1VvTAiguC5T7wXRPyaTzCuOLAjYY/hpCX2bjRHust4g1eUbVXHKq2cdPlspQT40sgCyr3jlfgcJ0HnBgvbo3C0lE4MQEvrLTAc/ai646b9sVjuBeAX4TrjpfCdQBxBY67R+6F49487oV7cAthrgZQJlwx5uhQ/WbK2TwkenDTmclNZwabzh7cdGa46cxEgXOjZWHTmdmbzlC5ByQbN525Ohcm0PkNM0WuxjqBqCpQKph4RI9rUYKdXDUonkw8De6BSnPhE1stOIdqEEFQrSiIROIXi3CP8QJO9MKNT5K58p8spjThdtXoNMMrYh7WJAx34jItO9kyzfTCQGTbC7VsCF9EF2pe8JY9PBuWaiidtj8NDjRscyOPY4IfHulKAy+9Yjlr7Tso5tjLNXG+ESZXuNM4G/bZveOVIvhd9GW1GVoshg3XYpHKhBdW4blkmduk4H5sGfcJV8oDv6KZm3ZoVXUtOHxc4z5cboDLcg6mLPlARuA8YSOcffZBxMKHsRlQMm90qL3wYxOFv5upKR8YYjpcmZeP0gSkmyTpJkk6N99kSRM0pEQhiP5SpzLqqLhHpBesAi5ugpQeiorgEZvQoAiaOLXNPUIRqFCEQFYsK3KAFVSwwohjRRayIiDPhUtpyIou2rOc0+OmzxYLn92uEAvsog+EgkVjYdh54u48cTpP7M4Td+ftXB0UOdRir63FmAkGWuyNarE9FjFa7I3RYq/Nc1k2Rouh8ujQWgTT1Dw8a7ZMlKLu1N1chftkan0M9zwxgkTjFAowohzuCZQvni3P2WdbJKDpgsfZkodaPA99Ng99MTz0JfLQNwB4qONIivQ9mXRUKTSh0lYEZ0E6WxBm28ozVZkNtk1GAOOiBldkZ4xfTxk/nzjBNYlm7B/z8awoNzIm8FBMoCdRnDJWMGMFB74VxCNxRSxjBdEKOtzIWMFDs4IJ4pSxgr1jBddnrGAPWkH7vGLGCPIshxkZG3hoNjBemDImsHdM4MXdT3UwkpxG+yFNxHziriCkfi1NryH3sbdkDX0rHvgqCXTdK0mg6zg7hdrd0Zf3zEPfScWhxZiHhlf01bufvIc4fGNXHH5Qpb7mbh9Phx18zs4UxwWMYxELUm7sG8eaciNk34eYjb3vQ8jGppiN7boEmyHRS06C9r4PIUEbuv4hk0e2FfEqN+N8UxFok2AetZniTc8WhWOceDhbABZeoMPMpSAZjn7CacosSwHNy7KUWXjoWjEuBJx4znjWWmt4fdjMBkjIZYi+ng0v+RMmJhsmYa6YHuMiHJ8GM3uZqXDfmZCV8A/B4NvsXkIqmdc4PqCCYnuxW5BXdgHopBczl6CjPNu4QExxFg2FuIq/sNuAum5cKN7bZVxowmEndbXolpery9A82e+wzeYUkta/JA67wlfx3lYV9T1kXGTq8mgxDQl6iOvQFXHwMeYgq13MFzKpcX5A4VlwADZL7iNgdjuDV2QBIkBouH3NatYfg/0ALR3ZiXWDbP9Hi/o/XuH/YGiojmvR2c5rT3Fe266KKU6mQEJeozuLNCC9F8jTB6Kpmo7/ozq+D0nl+xC370Pcvg+J931ICt/HY2cmiulK7KGBLGmwGwn7bR5jnD07wX6d29WJGmvxDt6oq2MfvyRRrwRdHjThwtUh0sWh0uVBI36Iro5muzoaznIe6epoUVfHI10dLdbV8cHmaExmOXVSXrnPGBdgMVOyrz4EY29q0A1fdGb22MMOe2fSs/Hano1HDLrm8mwQasb2bLzwQ3o2mugtXop6NpozJztHcvGlWnPBzmicwZwszr4q7rOvipyTlejZVwXnZCUpk5Xo2Vf3WDqejW92vKjkJBEVltyRybK55vJnXMqSZXMty+aaN55rXptrYvM2S3LNG+ValuSadwBwLaknw4Qno9gOi+PJMOHJKLaLM1tarSSezHv0UGCRuwvxZJHUIE+AfpwvwZ5gGLHXs/MBtMNUXRAuiRnATkojk7kHLghOyABWxMYa5GbKlO7HFaY1s6buw0DLzCYiDqhZzQFmNQdUBwrVzmSPUHGw35O0m2IjGvJJojgzMu8SDv7L1V8jiia8erEZ3gJCTqvPB+Sp2Ne1QMfOluw1KWgFq+eI38CcacWkNq40cXClqXTwAVpazCIA8Wz6XBn0DMZPCi+MtBLaZvo2PcZ9MItQBKOGmUSKtYr9YO6eqNgTKgZO9ESxVVMRzYJqUjmPQQOyB5vofOHV2Nrgi2qDV5wEFEfzf+NlTCSNTO9ejq0IQagiJ04VOXGqyIlTRU4cpuFWONLoTciqhrft0DrurQ/BxCDCDNG0ao/9eB778SBHONm0+34PTrvaGTJfmLplMBfEyC1yqjxeELNlio4JV9a5JmKY1QJajgu4gLN1wH8tdYM5rgZzkjfotuXi1aLo63jQfjpmPIaZNMpM6uSoK8ZCXC2C9/xPPDkJWfkyMakCrrlzpCCHafNHModp80fuHCauRBNIixB1xaGNhUypj+z0NPddI9FDXRjN3xwdmwMFvvzmj+VL3jd/bJ8CuM4js3sVt+1URIp51HZ6pO1UHdtZRThbF2C2ZKEP6zKgarLpSO316SgqIlJGNlNj4Vy1qQoys0XFxkIdzq4SOGVsFIHnPD35HPRcRpsPR5slxnzfKbTmQJlmdDqj0xmd7g2dZuGYvaw+0Gkb6TSj0xmdTq7T+zI6fVg6LV6L04cqrYBKC0CvjEZnNDpRo+92NLqipzXaVmU1Icwtw3hqPSBqC1V2he5UW5VVW5W9faDKnli9im6zqnb0NjZuHa+5MaHrpJorWpD1C5MwE97KYkMPxgc7pZp6RIjYVsmYnVsZGw54xc6tyr3ubdt4XS1262pZvK4W2bp6YryucreuFsbq6mhbV8fG66oRr6sjY3WV2Lqak0pX8eCw6tJVhDuIPSWvJeiqfVReGxC6mhC0TUdXK5Lr6o9o9xCVrBxrqqHL19TZr9ASGLY2qpq4yJ23PVP7LTY2wClQ4J1cOHbjZVw1tqB97P309M/AWi0+41XnVC1AKCxzn3jdTLu590vhNVnUBWzDBFgiwzdhJb74Vaghvh5LPB1owvikb8sSO9+/lQAY6b5fyOkFAQBHgfhaZ8n3hEdpggovnVNDRp3zbi4bK4SYDFA78S1MLA7/81vUeQcRvokJjv/Z4J80Cv4pWoG6LDUklA5fYPevHnkgX+oH8nX9QLEwpD9NeKA4DFIaj0FKYzBIaTwGqYBowUf3uR/93u49Oh7XVhI5ABClyZ/d9eDMeXAFqXOiz9tCJRoqUuB5AalFdpi6O9xtJL7R/YvEd1QGiS/P2v8fTPTY/58oEp+45CR67P9PTyLxTegEiW/rQAWhix5cyODQdcIpDTmFfMpA0WWg6A4Lim5VBoquR6DoVvUtFN0N/QhF9/vOoOggibQLNDoJr+wJYQr+JErgxXWHC0n3ZF9D0kW3vA4HlQ6rISHOTqUDDZhudY8C04UHEjDddYMSkc3tHWVA2YYOKFsG0KsXAL3WZgC9BjugV30ngF4NGUCvDKAXysvKNAC9/pAM0GtVXwJ6rbFhr8JDDdCrb56sZwC9/pgB9DJW9yegVzgD6DUwzzCvsU/fhjOAXod6grlPeJiBshkExi8loFc4A+iVMYFDG9ArYwUzVrALQK9wBtArYwWHNqDX4LaC6zNWsNcBvcIZQK+MDRzKgF6D2wQOXTCf1X0K5hPOgPkMEDCfNTYsTTgD5pM+mE+fcK3XwHzeH7JgPopInMKgkgvP58mBhuejYU9F7CYD6fO5h/RZ3c+QPuHBA+nT1O8Hi5sG6sHiNfZhxXCfHyxuijus2OQ6rDjx8wb/sbr/IX3CgwrSJ6PTGZ3O6HRXkD7hQQXpk9HpoaTT+zI63RuQPuHBBOmT0eihpNFDC9JndV9D+oQHNqRPU79D+jQNVEifPtLVZJA+XepqCkifbkN78P6F9ghkoD3yrJZPENqj5ZMotIe45EB7tHzSk9AeJw1KaA8neScD7dEFtIdcFmagPXoT2uOJoQ/tsZH2BbbHs0Mf2yMlI4cguMf+TsE9WFrgHswB9yhiAi5u0IF7OIGywwP3YALc4wvMAfd4fWCAe1xNexTd4xqagfc4bHgPl4eUgfcYOvAeBzLwHj0P73EdzeB7DHZ8j6toJwAfkCGcQfgYJAgf9/QqwseVNA2IjwPJID420r7E+LiW2lAY19ChhvLRV8/WMzgfr3eO8/G5ON50Ne1PoI9raAbpY2AebgJNFudyQJMzWB+Hdripj7jYa8ebrsmYwD6A+/h8WsFBgvcxkA3hoEL8yNjCjC3sGvTj82oLBwXqx8C2hYMI92Ow28KrMraw96E/Pq+mcDBgfwxsSzh40D8GuyF8asjifwjr12cAIC5jl0EA6V8EENBJAWYBOpnBAEkXA6SP+JZBATkEFBDMsMLl1UBHAbFPe2ZQQLqDAvLCUDyPeDhTcI/AgLgm5QGPA/I92u/HEb9HB+p5RDE1qb0/NSU7kfg9GnfM6XvUdc6puJMzib/LaHXvwIH0mmL3Dh5IRrczup3R7TRhQXpRt3sDFySj20NPt1/J6HavwIP0omr3Aj5IRrOHnmb/z5BCCemBGHc3YUJShbkHCk5InM72B1CIW2cHFlJIn+lsMqyQNHS2p9BCivoXLWR8Bi0kz4oItJCICy0kEosWEulRtJDJnaCF3DFg0ULsje4MWEgXYCHCocxghWSwQg4LK+TWDFZIz2CF3Po5wgr5U6dYIUpaWCGKgxWC1v7wsUL2SqyQnDTP2ovHORysEHuFHQcVonYGFaImQIUoAipE9ClnAEGF3N6zUCGRAQUVcu3ghAqJukcZpJAMUkgGKaQTpJC2DFLIoEcK+VFnSCG3ZZBCMkghQmJuSQcp5I1kSCG39ilSSKuDphEZckghffVsPYMU8mYGKcS4vV+RQiIZpJABehSq1TnCE8kghRzyQag+4mLmdPxgMIEpkUIiGaSQjCEc8kghGVuYsYVdI4VEMkghGVs45JFCBrstvCpjC3sfKSSSQQrJWMIhjhQy2A3h0EUKub1vkUIiGaSQgYIU0uogXkQySCHdQArpI771GlLIX4cwUggmWIFP4QIK2TsQgULkGbEMTsjnHifk9v7GCYkMIpyQu/v/VOLdA/ZUYqtzwinS96cS744/4XS3+4RT6ecNS+D2AYATEhlcOCEZ3c7odka308QJiQwunJCMbg893X4lo9u9ghMSGVQ4IRnNHnqaPbRwQm7vc5yQyADHCbm7/3FC7h6wOCF9prPJcELS0NkUOCG/YJQmP3LhRDULrZMMHSAqMMR5MpGRTtUOeOJHjvgwxMdI8TFafIwFjIqOjg4vjD3j9AGZZ19cecfdWE9BLmdFTH1gCVY+kRBxKAEa0ZFiKWE82JwURIRan3R0dCgAgLE5x2r5B7HKrAny3CK1iKHDSR9iZ/8zECYfp9gCtQ8MQys+Ew8dMU4NE1o3yu3sf5aY/d9tfJWS/sVXKc3gq+RZuwW+ym4XvsruWHyV3T2KrzK1E3yVvzmni42u8FUOD1glepAYsyoUsdXoQ5dNNcZ1F0UlFhwhDkVF7FO4UFScfTRTdY4Ja2JjOm0UFaNzFJVuwqekYgcyIyVWipHBSjEyWCldY6Xcn8FK6RmslPv7GCvldOEGqV1wk0qXw3UOFSAAAuCFqOIY608Z9aYzMB4xMB6JmWIpswJglO2540LTs8yELVyj0MwyLuCEZ3GPcQHMuVyDKelLaqXIqBI/TS8cmQiFODGONz3GBXDcF7fQQ8ZFePSaFLGRdq6NZH7LB8S6SbWyZY90kVChg9M/0tShqO4uerPqjKwujuJ7uM6zjWOM4zTsNZVd8dgNQ2oadgr8E+OBmBWnvTu7nkY90E74lQyzhqG/lhyzhqPDSsQOd5lRAYVhgSUc9higGP2W9LrgICukhMyxAWEA9Ab9L06NcajNTp9To7/IZYwc/2l25wYI1MuDPQv1smNAQb38TXU7Y2lHLg4P4yXWE0mSBJLgqXUP0CXWNMcBusR4asUxnpoHBkEAughfTY311DwZQJeuAV2MDKBLPwC6/DID6DLoAV1+1hmgy88zgC4ZQBchMf+TDqDLW8kAXe7vU0CXnQ7oyY4hB+jSV8/WM4Aub2cAXYwH+xXQZUcG0GWAnljb6Zy02pEBdDnk82p9xMUMiMFgMIEpAV12ZABdMoZwyAO6ZGxhxhZ2DeiyIwPokrGFQx7QZbDbwqsytrD3AV12ZABdMpZwiAO6DHZDOHQBXR7sW0CXHRlAl4EC6LLTASbZkQF06QagSx/xrdcAXX4j34aVVuJVX+C4dJYk5cqJkUlSzBiHCXw+kcB3j8JUAdeSXiJZlygtsiuJCY6x6TkEZ7NxsOl4Dm5meRtRNQ8RkgW8YDRPLCkeSuKEwAQiiteVFqmAnwZysAlzAMGcmd5Nj3EvTAmifLcxWZjdB5YEk4U5PUjAZPFGhdojMVl8QxaT5cH+xmTZMYgwWR7t/xOgjw7YE6A7ndNkO/r+BOij8afJHnWfJjvl84bb8OAAwGTZMbgwWTK6ndHtjG6nicmyY3BhsmR0e+jp9isZ3e4VTJYdgwqTJaPZQ0+zhxYmy4N9jsmyY4Bjsjza/5gsjw5YTJY+09lkmCxp6GwKTJafaow1pXUcWZEwH/DcPgkvgicqjC8IXOYiRiwaEoe1Omg9+IEdZAPAXFe10A0oiiLS2cXd1L6fwv1V3o1XQCDQrqMprTpiahi2kbPDrSOvB+oY2wN1FPRAHSf0QB2TD6eOqgq4W+NMT/X/ANXliYsqwmkV3bAO/m66Ur9SY75o6D05ipDohwAREv2YjidzsR9qSIAL3dBUb2248ztv0FlqpZXFmXWQ1lvqWmtYvSCazLoCyZzJcg35VtZpMGOsp1bkP8S6WR5Zth88tkEtpsGkZcZ0XQSPx3Ze5lTIbxFlfKnL6F2XGRNTRLMOXi6e88fUwWTIhgP7cHhvXj5XjdlwsE3lPtacFJrIHg6ZnoN1hwJeOEWJ38/Aw7lP0a1iMxIMoacuoGhcMRnuXcQCG+QqLsdBAhlwH05/WfAYWe59k9/Lc+5c5VkChF/jWY5Hy7ga4p5t0wngGSAwgDzpIwB0cij8NhbZGz6+xPM7mzJiOGDEcOWgFUMRD+WebafSTiWxuRNJvCYjiQNGEq+kg1cUmRTFL7BORfH7NCOLg0IWbxnEsqhIWRRgUill8SedyeJBlXkyshgrZ740ZDGrR2TRB9lRnPIslEVxfF7lnm7JIoQ6tDhZ9Nqy6I2XRV8KWYRApoiQuGBW3EIYDZkw7t0WxUJKJnGPORLnSZS4bTLHqYuFtA0kSmZzYo2sK2KGRdeabBun25qqWlpaWui5DQJedHeO9TRzkCEJp/kCZQmWRdbBnOE6pxZIpX02XSCrUc6WWzRsUQcEFEGoaJhTY5hdVNHvolEUstjRsHHHLNXKkoCmXFxLhYpKYlBR979JrFeJNd0WeSvb0G24BmycyrQqCE0Boo+ExxK0RL7uo+nhpRG7M7uJNVw2KXKv5Id8X5YhPkaLDy4+ijhxIYUWx/yq6JlanGHSd6UnKdGR2E8sw4WL63yots7YgLiiS0x0iYkuMRFCZQKohwmgHiaAepgA6kGs3fmcGc8hNMr5sZC1CFA72gG11b9NSbpiTqTEWrocEJ3LYdLE3oXrq2gM0d3u4+w+rvzEmG0mFhCQmerJxKdHOXo57T6mnipF241U+RKRUWAag1QpiC/bMK020ubseQES7cOybg0qYoQyuyexr5GDxm6hVsCGeSrj7Ex3S19O72EdSfFZRzjSI3SP2eg5ckjP6B77LIC+s00Dj9Ft/aFDGIqxcUMB4FVX0/ih4GIogHiNnFJFhB4Bu6rnQTbgRDJawoKNV6qryDmIAOZgEE0D7bXoyWR0jhNgstBsiq+0+4NYZA/i2LhBhG4+28kg/lG+47ATA5xjeR1EaVOJx56RybJCw3IsJovq3LkfLQSVaJwJyNVHWtMcE02EfKgwe6B8oG2W0IXioipG2mfPgAp3Q10nsdvfdT1gp5tB2F2LSE8DWj0jPwB7JfiawGZ8tR8wBX6fka8hXBzlbHa+zpW6KMGkxqtUSnkRIIWhagEAYG5U0H+SzrSXl+6092lHRwdNNe3RsDXq8Ga+Q5kn8gf3POE/pHliZbrzRFrDf3S6ww9A8yTV8LOwdUzfD3/BwBn+7xzC8B97SMN/JU13/O9OZ/yP68b4B1MNvxK2ju/74Z8wuId/3CEN/y1pD/+hsHTK4Gbp5ENi6f+kzdLbaaqXeni4BNOD9Ad46QCrLNAttW4Yo4zoRMcsg5TKZfffZ/cftAqnfsyiMF6gbt3qBGqtMk13lNseHWSGuEG2v5Cmtx2tgFN4zwXDCvQvMiqwV7vRg/GKsRP8Snvgg4fQhftgjXpYfajsiT5UHl4fZvdEH2bbfZhxSH24icZ04tAq2dwTldwVW8lVlNHGFPOZvdBLwLgUZow18uhryaNhCgnan0swxmecaZyli5fhuCAQk0xVlxxyP9y9gAbTae391JM4tyfxuMaSYOnTBCxP6jp+mPRg4G1e64TYYUmrJTvMp4YcsxKLKulYU+tnNPRg4gOHaE8wl9P7jPzYFhObuocx1sSSt6aJ1hJhUzU5s4jWcOJgCLCKZ5/vizkSS+wjsUTmSoojsSR6JNYjj8SS2COxBL5hwpUGwBvGXI1jxpUxR4fq7XQrDX7Ep1tpMelWmp1uJcvGpFtB5ZqTbtUVu1qpO33qkNhFHHYR5JWRD/CqClfnIbyqAnCkCr6KAeFVIQsuX17FJLCuuvieoijNrMkxNnHvjxKdVBI6qch1uch/k91UYrZ8iAsvXAQZqBNp+XEU91m+A6Mt4LVoIZwU91q7fUWMjMghrbc4oNN33BfwMEigFKESkUBpv/1ABOiTHYwFTogkaRV6qYj0DgUPEHKtEQBbFthHXxU4EwuHX0P4Jo9k500VO19UcZ83hTOujomsUZvE0K1yJwFrINyhbaa26TGubdS4lkCUZ5hN4pSqAtQBJk/I6gFNvqUiR9HxHLMAoZUXq2xnyY1FuzNxtFelMhWpB9qV1xc1FXdzZpwbIPEGKrHBk9NwSZ13TRhfc0fAGlO+Ds4dpIT4Zbx1c+3f2QoEmapEvFUNGpoftbC+pGrRm41/vT8bX9CfjZ/Xn43X9Gfji/uz8dr+bHxJfzZ+cX82vrSrxm/R4MUbTYfju3nkFk5cIXtH0giZAsikiEFSv9f6LqQgGMvhEAT+xe/cAyj2+GW8Mtq4RHwx4EsVhb9wN8w/+0iKdtLY+ZQnNUS0g4hoBxHRDhsRfjM1s12494RnC9x74QsyiQ1PotjwTGLDkxhseNzzh3iCgNCAOQfBIkwoBisI0ye3/WXuSS6DjAThJ2CiiU+860bihmdDrjxFEHusrgkeXNbgg7cf+Gbmgq/pw1clQFoLCgTUQLEGrQrz7eW0DdvyoQAVKfrMopC+4LUIZ3XbjBMAkyrbOMFOL9hHYManiYn5YkwAoUaVqSheiMTU4SiKyAcUUeUyBYsbr0VR57ueuXcw9wZUusKZzF9gcerF4tQn6euztnjtbBEAZUn0TZgMBeH735h07qAQLqY4FedfogTKlZB4ZWyU/fHRIfEO0zjhjINnySEJLnUC63o76DUyRdDrj+kGvXo9MlBvNPRtZKA+ndY+GKSRAbp2IAQHThw6wYE1dnAgPMSCAyd2GRw4sTvBgQ5FgXd7pggOdKOTmGnZvfeDHl6wQLFDBaoNh0rccKjJQgVJ8FHVKMo5Z40AcOVEC+SxUq4BUJYLnSrm5YBxCFl4uhkcgJhoAUuIFjAZLRBvCtSSve1QjUYLnPcJEud9gjoAmIn3iTKIF8CB4oAaEy/Qd6ZjMXsyXnBpz8cLLuureME3+nMd8c3+bPy/+rPxxv5sfF1Xja/rxcZbaH+2vr5fW7+8X1vf0K+tX9Fl662ZoMEADhpgAqlETjvkuAEFt4NgJYMydNA+mEMHFl2bJHoAIwIBhFPoUAggjE0RQHg93QDC1b0dQLiKGptoWiGEFT0VQriKDuUYAhsQMYRJXa047x00MYRrqR1EuIYOsSjCpC6jCJMyUYTuRBGc9wN9PqMI9T0YRbiephNGOKVbYYRvUXccoTfd+xv6dXGxuV9b/3a/tv6dfm39u/3a+o392voP+rX1m/q19Zv7tfUfZoIJgz6YYEM1H0YwgUEwASrJBBP6PJjAkgYTmAgmyMjCIA8mFKYIJrw5YIIJP6LGbX0cTPjRkA4mKAMimFAydIIJrU4wITLUggklXQYTSroTTPjr5++8AgBeKQCw/nk8sdCTsYMtvRA7+HGfxQ7u6Ne1xJ392vrWfm39rn5t/b/7tfVt/dr6Pf3a+k/7tfV7+7X17V22fnsmdjDAYwfyVTCHETpQIHQwXiGZyEGfRw6UpJEDdAXl6m7QRw5OTBE5eHvARA5+Ro2f93Hk4GdpRQ4eHTiRA6iuiKmw3MeQQNJYgNq7oYCTh04oYKcTCtgx1EIBJ3cZCji5O6GA53o0FJAcPrFnIwBSqxTQKiXFi7wlKC8zxg3C5b4v2XLf10/L/Yd6Ybm/q8+W+w/3q/vf3q+t7+7X1vf0a+uP9Gvrv+rX1h/v19af6NfW9/Zr60922fqHKvMd5nLf2+Vy3wclfLhg5z5nue/D5b4Pl/s+7hXLfR/3iuU+foHlvg+X+3i3pyDP2tvDy30vTIheXOdnwafj+GUBKbrO9zqOn9de53vdjp83us5XnXW+Cu8tcK3x8Z6oq5DLYHGEOMhiljfGmVnuZb2Ky3p5EylnMziZmau5Z65xXa/hfdE1vI9nRdfwe1Ou4X1iDQ9vgRVreAA98NTh8Mg1vM+1hvd1ew1/tULVVGv41CudZOsEmmQNH7faQW2gKdbwqF3xMs7cMm5rVLyMx0QLaBHLiQsWtHxArBeI5ZG+hgNRHVAs/BJFvYaXUEAqKnjJIfheZ2TjW12K2FijPIGpPRsNuJl2uVxLbXiMZXJJL9ZrvxZLSyu68E78ApDfxgsJwpJMSnqya79Jt2t/7POuPZ1u117v8649k27X3uzzrv023a69nVbXOCnwYSKEiVEPpX4Wvn5GKYD06EJV10+HrkPwdGSdSV1FXLeYSoFvJl6EqFe+oWgFikVnccVSZsFKnhqKDv+9dulLjFjX+XQ6llg3+fQjKSEkhxByNplDOJlHLHIasbYJ+oM+PUshhPgIIZRYv/HpdDqxXvHpk+CuInzK5WQ5WUkWkRoSJsvISrKCcBImK8lKwslyUkMayMWklljXZeG9N2Xp4ygGxQhpIsvJMrKQTCINJEwmkWUkTBaRS8hqchIJk9XEui5b3JOtT4B7Cgkhp5MVZDGpJZcRTlaSNSSMn0sIJw2khqwQbf0mW6cnEuuVbD0f7huZ0Jas/1Yd679L14+Dcsck6VOYLCeryRL7jtd05Ms7up4FdzB8EusTHdvblKMXwNWxsp9rSQ3Wthg5UYu9C5OlxNqWg+UfdJWPtruahEkDWYal7VZzRKs5OqXE+kT82pSrZ6lybBixbs3VaSOx7srV66DOxYTgKHzFVVsRGS/5tJgsQw6K0VlDLsHeAS8vIWuwB5wsJLXyb5hcSmqxBCcleNcKfKZSUk6sW4cJHg7TJ0K7x8c8yxqUieVkElmBrUBtDc5TDRNPNSzKy2JifTJMv0EpJvBvMikmJaSYlJJiUkaKyRRSTMpJMZlKikkFKSbTsMRk/FdCJpNSMpmUkclkCplMyslkMpVMJhVkMpmGtZRgKfhXSkpIGSkhU0gJKSclZCopIRWkhEzDlkqxJigF/8pIKZmCT1pKppJSUkFKyTTsTRm2VoIlyvDfFFJGykkZmUrKSAUpI9Owx1OwRyVYyxQsBf/KyRQylUwhFWQKmYZPVY69LsGWyrEmKAX/ppJyUkHKyTR88qn4ZCXYm6nY2hQsMRX/VZCpZBpypwKfvgR7XIE9moK1VGAp+DeNTJNcnCaffprs9TTZ2jRZyrruCJ2NVYl10xH6VT4YLaISku4oFZMaUkwWkmKyiBSTxaSY1JJisiTt0ZtMashkspBMJovIZLKYTCa1ZDJZkvaolpAaUkIWkhKyiJSQxaSE1JISsiTt0S4lNaSULCSlZBEpJYtJKaklpWRJ2lJQRmpIGVlIysgiUkYWkzJSS8rIkrSlYwqpIVPIQjKFLCJTyGIyhdSSKWRJ2lJTTmpIOVlIyskiUk4Wk3JSS8rJkrSlaSqpIVPJQjKVLCJTyWIyldSSqWRJ2lJWQWpIBVlIKsgiUkEWkwpSSyrIkrSlbxqpIdPIQjKNLCLTyGIyjdSSaWQJSlUNSkcJjlANcnoKPm0N9roC76zBfwtJDc5Si0kNqSU1ZAlK5EKUrBIc3YU4SlOQUwvxiSuw1YV4N/xbRBaSxWjFFpIlKM2LUCpLUDIW4QhPQS4vQm5VYI8XYctwN/xbTBaRWrKILEFNWIwSXYJStRilYwqO0GLkdAU+7WLs9UK8czH+qyWLyRLUolrUhhKUyFqUrCk4urU4ShXIqVp84oXYai3eDf+WkCVSC5dIbVgipXKJlI4lcpSWSG4tkb1eIu+2to3R6fnEenCMPgdswmy04JNRm8pQDqfiCNbgsy/Guy4mS8kyEiJ1ZDm5hKwgK8kqUk8acM5ZQ9aSS8ll5Bvkm8S6Ll94KPl6liZnOYVYP8/Xlcg/g8Tak6/79+744PITX2pvOXdqUeHP/j0dva4WIB7I1/2++e27nn2xnX+0/xXfHWN3IbEaiOvH6v75M/2Xrn2x/ZK5v3jxxwsLBLESiK1jdf/HE6+6Z8yL7S9evP22N6546yGxh4dtfka87NLvX/TwC+37vzD+u8vyVXEnwTbH6v7qsY9cW/NC+2+uOHP2pFeOPBVp+/8BbR6t++/auLFYfaH9ZP3yv/y96jXR291AbD1a989e9tUz73y+vfp7X974+H1c3BkB4p6jdX/LTT/8/WnPt3+n5VcvnPX14wSxBYgHjtb9/MDO1995rv2VCQ/cfMx/HS+I1djmMbp/0x+OXHD1c+3B7b/9xcin8lzE1hTESmzzGN1/2W//Y41/rn3t775SVLhglHhOjm0eo/tvWrbnpr3Ptqvz3l760L3HSiZgm8fq/rt+8pPzL362/eBdl5c+fuyxkgkfQpvH6v7ZP/3Xtdqz7UsWaP/32F3Hizt3A3HPsbp/8+rXC7fsax+mfNj017ocQYwA8cCxun/fz753XOW+9uaJH972YPnBh6LE9Tw5sQXb5Lq/8sJLRu/4bftV02/+yQlfy5VMwDa57q9+7df3HHymvfDejbc+cPwEyQRsk+v+gyes8I57pt3oCM6bM8kvmYBtBnT/7jl1gfOfbs9f+tQvv70zIO4k2GZA90d++MRHN/ymveyK25fO+cY4F3FPCuL+v0ObAd2/eWJ44yO/br/hgWsnbz/7KEHcDcT1pu7f3XL2k39/qn3J5qeDi87eKWQoAsRWU/dvf/3Yhwqean93z6zXFl933K4ocU8KYgu2aer+uR/euuCcJ9v/9MIe9f89e4LUFWyzQPfv47WR5r3tWf9+tbl9l80hbLNA9+832NU/eaJ9/hlfadj8qpu4JwWRY5tQ7VFvD3/p8fYlr//PltAbhpQhbLNQ92/euqq441ft0+Yat3/xtmNcxNYUxP0fQJuFun9765/ePP5X7Tec59187R+4FDAgHijU/S2/Xj7hrMfap182pWZPjv/UKHH9ccmJESC2Hqf7Nx/DP6l/tP3keePO2njZ36SpwTaP0/0Hj/34nO8/0u57rN5ffH2hZB+2eZzur5704gkP7Gm/ccuI0T9uOclFXH98cmIltnm87t+8r7Hp5d3tH573zqYbl2WfGiXuSUHk2OZn1e5/dfK332tv/6B0y/nz1sjBJkC8fJw+asIK77iH26eTgyecWHbCqVFaW3La/r9Bi+N0/+7zbph34UPtnocvmv+1nKMlZ4F4YJzu33/GyZd8Z2f73rvPe2fKNGmikLi+KDkxAsTWIt0fmfzSzEcfbF967qSzxjce6SLuSUFswTY/q7b6zWueO/iL9t+tLn1y6g+kLanGNsfrfu4JevN/3v61Cx+vOY9JK4TE1hTESmxzvO7fn3/jy9b97X888l+/+d2FJ7qIB1IQObZ5gu5v2fLX8tr72rO23LD2wsaRkrXYJhBH7C7Ovrf9298q33Db1ye6iHtSEPcfhDaBeFT976t+0n7mqpfe/OblY13E9ROSE3cDsXWC7t9d8s/54a3tf239oGzWJyfuihL3pCBGsE0gfrrjqtu2tN/96fH/eID9Y3qUuP7E5MQWILadqI+6bNgtl9/e/kZWU+PxLeN3RWmPJKdVY4sn6v6WF735O37QPu3Of3933vVFUhWAePlEfdQn2+/afUP7rXc+/8/GY/74UJTWlpzGscGJ+iij7oT9ze1vVP4uN/j6UbuitNeT0wjQbjxJZ/D585N0Zff7UNFJ+qir1+QZLcF3Jvzo5ronpLFqAdqBk3R/y3fnn8s3B5/76HXPea/ZzgQQL5+kj3qy6LjTbwqW5Swo2RmRlpUArXWS7q98++oLrEjwKy//7fzdI6gcu79Ci5P0USe98NMlPw4W/d+uNatHydFpAdqBz27cffvIu793V3Dd8Qv2ff8bsu+VQFxfrPt3//7p1b/eFvQWvXLaB0vHyIcGYisQPbsnv/vT4H+d8uScL4wYJm3nX0AiinV/9axnT/nBfcFbbss994ISewIB4oHPiPuf3fqPXfcHXz771Tsu3CslvxqI6yfr/sgPzlrw558Hjzn6gumeZbK3lUBsnaz7d7+b/Tx5IFjylx/99/XHvCfEhWCbnxErv37BhaU7gr87bdfJ548okDx4D9qcrPur77l+b+iXwTeXfjShZfORskNAXF+i+ysfovM3PRR8ftuCx5+dZTs+QGwt0f08e8O0Jx4O7p/51r1Ld0+UHQLinhIwj9O+/U578P+yW+e8VGabR2wTiOMu/5Z/T/AD78RnLntfTuv7/xfaLNX9BwuaJty9J1h2c8WMb22VTIgAsbVU97dszKl59pFg68/W/3r5jxRprIC4p1T3b87b/knto8GrG75UcNekxwUTKoF4oFT3by/dcOq3Hwte9ov/m/eNDdJAcmyzDGa0N94c96vgE+uWvflOqXzO/e9Cm2W637ju4bO/9njwspOmn3jtb21vAYh7ynT/qjXXHnHw8eCBwK1vXj/CHk8gHijT/XNnXHn91U8EtS9+e5WxxPaPgXj5FH3UtP+99+G9wWdP/PPd8071Su4BrW2KPuqj1xYseDK4siMyv+gDr7Rj2OIU3b//mul/+e5TwWWBc+d+sUEq8f4/Q4tTdP++8772yuRfB+8+sO3s66dI9243ENeX6/79p1Rcte/XwV8cMe/rj31JDlgEiK3lut84+Ph/Vv4m+NyEG3/V8N7fhI5XA3HPZ8TNL2w/9b6ng1O25310QodUsUpsE+58u2PYV54JFn9oVY874hHBdg7Ey6fqo37/xj3/eCY44lu/rM0LPCVqJdjk1M+G5P7lY2/+bbD4jzlPvffrfMnYd6DJqbp//lnVFfX7gt8++y+jXr31Y2kdgXhgqu6vrrl44mP7gn9+d/qoa0dL764FiOsrdP87IF3PBscevGPRsIBUlGogtlbo/o+3/fr8umeD60fd8dHTP7SdKWzzszuXLlh0c/uzwQd2nfblv9xpzzzYZoXuf3DYJTNHPhd8d+esnX+4SnoD+9+GNqfp/s2vNR58+Lngh+rcM/59q5zVdwOxdZrur37+wN9GPh98cHrg+W++LkcsAsQ9n91pPLz24rrng3sv/dv2p1eMkI8CxAPTdH9x6aXnPPJ88Pxdnl/MO2W01D9s82Td/86LBT876oXgj/Zvfq/8DZ98FGzzZN2/t/6R6+tfCK556eKsZ8ZNkhYK2zxZ9xf7b9v/5AvBH7+SnX81ly4RwTZP1v2RCu9P