From cc00c045e4b19018bb47cf179583cd0b53db76b2 Mon Sep 17 00:00:00 2001 From: Moussa Sidibe Date: Tue, 22 Jan 2019 16:04:20 +0000 Subject: [PATCH 01/14] development: Update composer version to 2.0.0 --- composer.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/composer.json b/composer.json index 4eb5e340..7d2bc2db 100755 --- a/composer.json +++ b/composer.json @@ -1,7 +1,7 @@ { "name": "yoti/yoti-php-sdk", "description": "Yoti SDK for quickly integrating your PHP backend with Yoti", - "version": "1.2.1", + "version": "2.0.0", "keywords": [ "yoti", "sdk" From 05ce9f13c3feb528b0b4f31b172f2cabba9bf13c Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 5 Feb 2019 15:01:25 +0000 Subject: [PATCH 02/14] SDK-752: Prevent log messages surfacing when error_log hasn't been configured --- tests/bootstrap.php | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/bootstrap.php b/tests/bootstrap.php index e1d07fa4..5c248476 100644 --- a/tests/bootstrap.php +++ b/tests/bootstrap.php @@ -4,6 +4,11 @@ */ require_once __DIR__ . '/../vendor/autoload.php'; +// Prevent log messages surfacing when error_log hasn't been configured. +if (!ini_get('error_log')) { + ini_set('error_log', '/dev/null'); +} + define('SDK_ID', '990a3996-5762-4e8a-aa64-cb406fdb0e68'); define('RECEIPT_JSON', __DIR__ . '/sample-data/receipt.json'); define('INVALID_YOTI_CONNECT_TOKEN', 'sdfsdfsdasdajsopifajsd='); From 14887b3137b019ee0490b80ed932432b3bf4d1f5 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 5 Feb 2019 18:02:32 +0000 Subject: [PATCH 03/14] SDK-752: Further test coverage for AttributeConverter --- tests/TestCase.php | 17 +++- tests/Util/Profile/AttributeConverterTest.php | 92 ++++++++++++++++++- 2 files changed, 107 insertions(+), 2 deletions(-) diff --git a/tests/TestCase.php b/tests/TestCase.php index eaa3f79a..6778a03d 100644 --- a/tests/TestCase.php +++ b/tests/TestCase.php @@ -6,5 +6,20 @@ class TestCase extends PHPUnit_Framework_TestCase { - + /** + * Call protected/private method of a class. + * + * @param object $class Class that we will run method on. + * @param string $methodName Method name to call + * @param array $parameters Array of parameters to pass into method. + * + * @return mixed Method return. + */ + public function invokeStaticMethod($class, $methodName, array $parameters = array()) + { + $reflection = new \ReflectionClass($class); + $method = $reflection->getMethod($methodName); + $method->setAccessible(true); + return $method->invokeArgs(new $class, $parameters); + } } \ No newline at end of file diff --git a/tests/Util/Profile/AttributeConverterTest.php b/tests/Util/Profile/AttributeConverterTest.php index 0bfcabc1..758b0cd8 100644 --- a/tests/Util/Profile/AttributeConverterTest.php +++ b/tests/Util/Profile/AttributeConverterTest.php @@ -7,9 +7,37 @@ use Yoti\Entity\Receipt; use Yoti\ActivityDetails; use Yoti\Util\Profile\AttributeConverter; +use Yoti\Exception\AttributeException; +/** + * @coversDefaultClass \Yoti\Util\Profile\AttributeConverter + */ class AttributeConverterTest extends TestCase { + /** + * Mocks \Attrpubapi\Attribute with provided name and value. + */ + private function getMockForProtobufAttribute($name, $value) { + // Setup protobuf mock. + $protobufAttribute = $this->getMockBuilder(\Attrpubapi\Attribute::class) + ->disableOriginalConstructor() + ->getMock(); + $protobufAttribute + ->method('getAnchors') + ->willReturn($this->getMockBuilder(\Traversable::class)->getMock()); + $protobufAttribute + ->method('getName') + ->willReturn($name); + $protobufAttribute + ->method('getValue') + ->willReturn($value); + + return $protobufAttribute; + } + + /** + * @covers ::convertTimestampToDate + */ public function testDateTypeShouldReturnDateTime() { $dateTime = AttributeConverter::convertTimestampToDate('1980/12/01'); @@ -17,6 +45,9 @@ public function testDateTypeShouldReturnDateTime() $this->assertEquals('01-12-1980', $dateTime->format('d-m-Y')); } + /** + * @covers ::convertValueBasedOnContentType + */ public function testSelfieValueShouldReturnImageObject() { $pem = file_get_contents(PEM_FILE); @@ -27,4 +58,63 @@ public function testSelfieValueShouldReturnImageObject() $this->profile = $this->activityDetails->getProfile(); $this->assertInstanceOf(Image::class, $this->profile->getSelfie()->getValue()); } -} \ No newline at end of file + + /** + * @covers ::convertToYotiAttribute + */ + public function testConvertToYotiAttribute() { + $attr = AttributeConverter::convertToYotiAttribute($this->getMockForProtobufAttribute('test_attr', 'my_value')); + $this->assertEquals('test_attr', $attr->getName()); + $this->assertEquals('my_value', $attr->getValue()); + } + + /** + * @covers ::convertToYotiAttribute + */ + public function testConvertToYotiAttributeNullValue() { + $attr = AttributeConverter::convertToYotiAttribute($this->getMockForProtobufAttribute('test_attr', '')); + $this->assertNull($attr); + } + + /** + * @covers ::convertValueBasedOnContentType + * @covers ::validateInput + */ + public function testConvertValueBasedOnContentTypeValidation() { + $this->expectException(AttributeException::class); + $this->expectExceptionMessage('Warning: test_attr value is NULL'); + $this->invokeStaticMethod( + AttributeConverter::class, + 'convertValueBasedOnContentType', + [$this->getMockForProtobufAttribute('test_attr', '')] + ); + } + + /** + * @covers ::convertValueBasedOnAttributeName + * @covers ::validateInput + */ + public function testConvertValueBasedOnAttributeNameValidation() { + $this->expectException(AttributeException::class); + $this->expectExceptionMessage('Warning: test_attr value is NULL'); + $this->invokeStaticMethod( + AttributeConverter::class, + 'convertValueBasedOnAttributeName', + ['', 'test_attr'] + ); + } + + /** + * @covers ::validateInput + */ + public function testValidateInput() { + $this->expectException(AttributeException::class); + $this->expectExceptionMessage('Warning: test_attr value is NULL'); + $this->invokeStaticMethod( + AttributeConverter::class, + 'validateInput', + ['', 'test_attr'] + ); + } + +} From 4777d4a17cb6aaf11b3065d6d6bfec19cad4d158 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 5 Feb 2019 18:30:52 +0000 Subject: [PATCH 04/14] SDK-752: Remove tests for private methods --- tests/TestCase.php | 17 +------- tests/Util/Profile/AttributeConverterTest.php | 41 ------------------- 2 files changed, 1 insertion(+), 57 deletions(-) diff --git a/tests/TestCase.php b/tests/TestCase.php index 6778a03d..eaa3f79a 100644 --- a/tests/TestCase.php +++ b/tests/TestCase.php @@ -6,20 +6,5 @@ class TestCase extends PHPUnit_Framework_TestCase { - /** - * Call protected/private method of a class. - * - * @param object $class Class that we will run method on. - * @param string $methodName Method name to call - * @param array $parameters Array of parameters to pass into method. - * - * @return mixed Method return. - */ - public function invokeStaticMethod($class, $methodName, array $parameters = array()) - { - $reflection = new \ReflectionClass($class); - $method = $reflection->getMethod($methodName); - $method->setAccessible(true); - return $method->invokeArgs(new $class, $parameters); - } + } \ No newline at end of file diff --git a/tests/Util/Profile/AttributeConverterTest.php b/tests/Util/Profile/AttributeConverterTest.php index 758b0cd8..4720d4d8 100644 --- a/tests/Util/Profile/AttributeConverterTest.php +++ b/tests/Util/Profile/AttributeConverterTest.php @@ -76,45 +76,4 @@ public function testConvertToYotiAttributeNullValue() { $this->assertNull($attr); } - /** - * @covers ::convertValueBasedOnContentType - * @covers ::validateInput - */ - public function testConvertValueBasedOnContentTypeValidation() { - $this->expectException(AttributeException::class); - $this->expectExceptionMessage('Warning: test_attr value is NULL'); - $this->invokeStaticMethod( - AttributeConverter::class, - 'convertValueBasedOnContentType', - [$this->getMockForProtobufAttribute('test_attr', '')] - ); - } - - /** - * @covers ::convertValueBasedOnAttributeName - * @covers ::validateInput - */ - public function testConvertValueBasedOnAttributeNameValidation() { - $this->expectException(AttributeException::class); - $this->expectExceptionMessage('Warning: test_attr value is NULL'); - $this->invokeStaticMethod( - AttributeConverter::class, - 'convertValueBasedOnAttributeName', - ['', 'test_attr'] - ); - } - - /** - * @covers ::validateInput - */ - public function testValidateInput() { - $this->expectException(AttributeException::class); - $this->expectExceptionMessage('Warning: test_attr value is NULL'); - $this->invokeStaticMethod( - AttributeConverter::class, - 'validateInput', - ['', 'test_attr'] - ); - } - } From 96c58fdd981840b794eccad67305fc73436d68af Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 5 Feb 2019 18:58:19 +0000 Subject: [PATCH 05/14] SDK-752: Remove ini_set() in bootstrap --- tests/bootstrap.php | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/bootstrap.php b/tests/bootstrap.php index 5c248476..e1d07fa4 100644 --- a/tests/bootstrap.php +++ b/tests/bootstrap.php @@ -4,11 +4,6 @@ */ require_once __DIR__ . '/../vendor/autoload.php'; -// Prevent log messages surfacing when error_log hasn't been configured. -if (!ini_get('error_log')) { - ini_set('error_log', '/dev/null'); -} - define('SDK_ID', '990a3996-5762-4e8a-aa64-cb406fdb0e68'); define('RECEIPT_JSON', __DIR__ . '/sample-data/receipt.json'); define('INVALID_YOTI_CONNECT_TOKEN', 'sdfsdfsdasdajsopifajsd='); From 7111206f57dc446b765cea78e64321c49e4c6035 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 7 Feb 2019 10:36:22 +0000 Subject: [PATCH 06/14] SDK-752: Apply PSR2 coding standards --- tests/Util/Profile/AttributeConverterTest.php | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/tests/Util/Profile/AttributeConverterTest.php b/tests/Util/Profile/AttributeConverterTest.php index 4720d4d8..6066cb05 100644 --- a/tests/Util/Profile/AttributeConverterTest.php +++ b/tests/Util/Profile/AttributeConverterTest.php @@ -17,7 +17,8 @@ class AttributeConverterTest extends TestCase /** * Mocks \Attrpubapi\Attribute with provided name and value. */ - private function getMockForProtobufAttribute($name, $value) { + private function getMockForProtobufAttribute($name, $value) + { // Setup protobuf mock. $protobufAttribute = $this->getMockBuilder(\Attrpubapi\Attribute::class) ->disableOriginalConstructor() @@ -62,7 +63,8 @@ public function testSelfieValueShouldReturnImageObject() /** * @covers ::convertToYotiAttribute */ - public function testConvertToYotiAttribute() { + public function testConvertToYotiAttribute() + { $attr = AttributeConverter::convertToYotiAttribute($this->getMockForProtobufAttribute('test_attr', 'my_value')); $this->assertEquals('test_attr', $attr->getName()); $this->assertEquals('my_value', $attr->getValue()); @@ -71,9 +73,9 @@ public function testConvertToYotiAttribute() { /** * @covers ::convertToYotiAttribute */ - public function testConvertToYotiAttributeNullValue() { + public function testConvertToYotiAttributeNullValue() + { $attr = AttributeConverter::convertToYotiAttribute($this->getMockForProtobufAttribute('test_attr', '')); $this->assertNull($attr); } - } From fc646f438d8075ac746ea9251b0016eaf173b282 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 8 Feb 2019 12:24:33 +0000 Subject: [PATCH 07/14] SDK-752: Remove unrequired use statement --- tests/Util/Profile/AttributeConverterTest.php | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/Util/Profile/AttributeConverterTest.php b/tests/Util/Profile/AttributeConverterTest.php index 6066cb05..46261bdf 100644 --- a/tests/Util/Profile/AttributeConverterTest.php +++ b/tests/Util/Profile/AttributeConverterTest.php @@ -7,7 +7,6 @@ use Yoti\Entity\Receipt; use Yoti\ActivityDetails; use Yoti\Util\Profile\AttributeConverter; -use Yoti\Exception\AttributeException; /** * @coversDefaultClass \Yoti\Util\Profile\AttributeConverter From 9e7c83b84f1f0332b5a9c7bc1d8d4b50d9fd79c2 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 8 Mar 2019 15:39:51 +0000 Subject: [PATCH 08/14] SDK-848: Annotate unit tests --- tests/ActivityDetailsTest.php | 38 ++++++++++--- tests/Entity/AnchorTest.php | 12 ++++ tests/Entity/ApplicationProfileTest.php | 20 +++++++ tests/Entity/AttributeTest.php | 26 ++++++++- tests/Entity/DocumentDetailsTest.php | 45 +++++++++++++++ tests/Entity/ImageTest.php | 17 +++++- tests/Entity/ProfileTest.php | 57 ++++++++++++++++--- tests/Entity/ReceiptTest.php | 27 +++++++++ tests/Http/AmlResultTest.php | 12 ++++ tests/Http/CurlRequestHandlerTest.php | 32 +++++++++-- tests/Http/PayloadTest.php | 14 +++++ tests/Http/RequestSignerTest.php | 26 +++++++-- .../Age/AgeOverVerificationProcessorTest.php | 18 ++++++ .../Age/AgeUnderVerificationProcessorTest.php | 18 ++++++ .../Util/Age/AgeVerificationConverterTest.php | 12 ++++ tests/Util/ConfigTest.php | 9 +++ .../Util/Profile/AnchorListConverterTest.php | 12 ++++ tests/YotiClientTest.php | 32 ++++++++++- 18 files changed, 397 insertions(+), 30 deletions(-) diff --git a/tests/ActivityDetailsTest.php b/tests/ActivityDetailsTest.php index 50e52277..d8123ee7 100644 --- a/tests/ActivityDetailsTest.php +++ b/tests/ActivityDetailsTest.php @@ -9,6 +9,9 @@ use Yoti\Entity\Image; use Yoti\Entity\ApplicationProfile; +/** + * @coversDefaultClass \Yoti\ActivityDetails + */ class ActivityDetailsTest extends TestCase { /** @@ -26,6 +29,9 @@ class ActivityDetailsTest extends TestCase */ public $applicationProfile; + /** + * @var string Remember Me ID + */ public $rememberMeId = 'Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU'; public function setUp() @@ -40,7 +46,7 @@ public function setUp() } /** - * Test getting ActivityDetails Instance + * Test getting ActivityDetails Instance. */ public function testActivityDetailsInstance() { @@ -48,26 +54,32 @@ public function testActivityDetailsInstance() } /** - * Test getting RememberMeId + * @covers ::getRememberMeId */ public function testGetRememberMeId() { $this->assertEquals($this->rememberMeId, $this->activityDetails->getRememberMeId()); } + /** + * @covers ::getParentRememberMeId + */ public function testGetParentRememberMeIdExists() { $this->assertTrue(method_exists($this->activityDetails, 'getParentRememberMeId')); } /** - * Test getting Given Names + * @covers ::getProfile */ public function testGetProfile() { $this->assertInstanceOf(Profile::class, $this->activityDetails->getProfile()); } + /** + * @covers ::getApplicationProfile + */ public function testGetApplicationProfile() { $this->assertInstanceOf( @@ -77,7 +89,7 @@ public function testGetApplicationProfile() } /** - * Test getting Family Name + * @covers \Yoti\Entity\Profile::getFamilyName */ public function testGetFamilyName() { @@ -85,7 +97,7 @@ public function testGetFamilyName() } /** - * Test getting Full Name + * @covers \Yoti\Entity\Profile::getFullName */ public function testGetFullName() { @@ -93,7 +105,7 @@ public function testGetFullName() } /** - * Test getting Date Of Birth + * @covers \Yoti\Entity\Profile::getDateOfBirth */ public function testGetDateOfBirth() { @@ -101,7 +113,8 @@ public function testGetDateOfBirth() } /** - * Test getting Phone Number + * @covers \Yoti\Entity\Profile::getPhoneNumber + * @covers \Yoti\Entity\Attribute::getValue */ public function testGetPhoneNumber() { @@ -109,7 +122,7 @@ public function testGetPhoneNumber() } /** - * Test getting Email Address + * @covers \Yoti\Entity\Profile::getEmailAddress */ public function testGetEmailAddress() { @@ -117,7 +130,8 @@ public function testGetEmailAddress() } /** - * Test getting Selfie + * @covers \Yoti\Entity\Profile::getSelfie + * @covers \Yoti\Entity\Attribute::getValue */ public function testGetSelfie() { @@ -125,12 +139,18 @@ public function testGetSelfie() $this->assertInstanceOf(Image::class, $this->profile->getSelfie()->getValue()); } + /** + * ::getTimestamp + */ public function testGetTimestamp() { $timestamp = $this->activityDetails->getTimestamp(); $this->assertEquals('19-07-2016 08:55:38', $timestamp->format('d-m-Y H:i:s')); } + /** + * ::getReceiptId + */ public function testGetReceipt() { $receiptId = '9HNJDX5bEIN5TqBm0OGzVIc1LaAmbzfx6eIrwNdwpHvKeQmgPujyogC+r7hJCVPl'; diff --git a/tests/Entity/AnchorTest.php b/tests/Entity/AnchorTest.php index 7b80baef..4be4e588 100644 --- a/tests/Entity/AnchorTest.php +++ b/tests/Entity/AnchorTest.php @@ -8,13 +8,25 @@ use YotiTest\Util\Profile\TestAnchors; use Yoti\Util\Profile\AnchorListConverter; +/** + * @coversDefaultClass \Yoti\Entity\Anchor + */ class AnchorTest extends TestCase { + /** + * Check Anchor class exists. + */ public function testAnchorClassExists() { $this->assertTrue(class_exists(Anchor::class)); } + /** + * @covers ::getType + * @covers ::getValue + * @covers ::getSignedTimeStamp + * @covers ::getOriginServerCerts + */ public function testYotiAnchorEndpoints() { $dlAnchor = new \Attrpubapi\Anchor(); diff --git a/tests/Entity/ApplicationProfileTest.php b/tests/Entity/ApplicationProfileTest.php index bafca2ca..5d82805b 100644 --- a/tests/Entity/ApplicationProfileTest.php +++ b/tests/Entity/ApplicationProfileTest.php @@ -6,6 +6,9 @@ use YotiTest\TestCase; use Yoti\Entity\ApplicationProfile; +/** + * @coversDefaultClass \Yoti\Entity\ApplicationProfile + */ class ApplicationProfileTest extends TestCase { /** @@ -24,6 +27,9 @@ public function setup() $this->dummyProfile = new ApplicationProfile($dummyData); } + /** + * @covers ::getApplicationName + */ public function testGetApplicationName() { $this->assertEquals( @@ -32,6 +38,9 @@ public function testGetApplicationName() ); } + /** + * @covers ::getApplicationUrl + */ public function testGetApplicationUrl() { $this->assertEquals( @@ -40,6 +49,9 @@ public function testGetApplicationUrl() ); } + /** + * @covers ::getApplicationReceiptBgColor + */ public function testGetApplicationReceiptBgColor() { $this->assertEquals( @@ -48,6 +60,10 @@ public function testGetApplicationReceiptBgColor() ); } + /** + * @covers ::getApplicationLogo + * @covers \Yoti\Entity\Image::getContent + */ public function testGetApplicationLogoImageData() { $this->assertEquals( @@ -56,6 +72,10 @@ public function testGetApplicationLogoImageData() ); } + /** + * @covers ::getApplicationLogo + * @covers \Yoti\Entity\Image::getMimeType + */ public function testGetApplicationLogoImageType() { $this->assertEquals( diff --git a/tests/Entity/AttributeTest.php b/tests/Entity/AttributeTest.php index 5e04eeb0..3a04e540 100644 --- a/tests/Entity/AttributeTest.php +++ b/tests/Entity/AttributeTest.php @@ -9,12 +9,15 @@ use YotiTest\Util\Profile\TestAnchors; use Yoti\Util\Profile\AnchorListConverter; +/** + * @coversDefaultClass \Yoti\Entity\Attribute + */ class AttributeTest extends TestCase { const ATTR_VALUE = 'Test FullName'; /** - * @var Attribute + * @var \Yoti\Entity\Attribute */ public $dummyAttribute; @@ -33,16 +36,25 @@ public function setup() ); } + /** + * @covers ::getName + */ public function testAttributeName() { $this->assertEquals(Profile::ATTR_FULL_NAME, $this->dummyAttribute->getName()); } + /** + * @covers ::getValue + */ public function testAttributeValue() { $this->assertEquals(self::ATTR_VALUE, $this->dummyAttribute->getValue()); } + /** + * @covers ::getSources + */ public function testGetSources() { $sources = $this->dummyAttribute->getSources(); @@ -59,6 +71,9 @@ public function testGetSources() ); } + /** + * @covers ::getVerifiers + */ public function testVerifiers() { $verifiers = $this->dummyAttribute->getVerifiers(); @@ -72,6 +87,9 @@ public function testVerifiers() ); } + /** + * @covers ::getAnchors + */ public function testGetAnchors() { $anchors = $this->dummyAttribute->getAnchors(); @@ -84,6 +102,12 @@ public function testGetAnchors() $this->assertEquals('YOTI_ADMIN', $anchors[2]->getValue()); } + /** + * Convert anchor string to Protobuf Anchor + * + * @param string $anchorString + * @return \Attrpubapi\Anchor + */ public function convertToProtobufAnchor($anchorString) { $anchor = new \Attrpubapi\Anchor(); diff --git a/tests/Entity/DocumentDetailsTest.php b/tests/Entity/DocumentDetailsTest.php index bde9e734..d34642bd 100644 --- a/tests/Entity/DocumentDetailsTest.php +++ b/tests/Entity/DocumentDetailsTest.php @@ -4,6 +4,9 @@ use Yoti\Entity\DocumentDetails; use YotiTest\TestCase; +/** + * @coversDefaultClass \Yoti\Entity\DocumentDetails + */ class DocumentDetailsTest extends TestCase { /** @@ -17,6 +20,12 @@ public function setup() $this->dummyDocumentDetails = new DocumentDetails($dummyValue); } + /** + * @covers ::getType + * @covers ::getIssuingCountry + * @covers ::getDocumentNumber + * @covers ::getExpirationDate + */ public function testShouldParseOneOptionalAttribute() { $document = new DocumentDetails('PASSPORT GBR 01234567 2020-01-01'); @@ -26,6 +35,13 @@ public function testShouldParseOneOptionalAttribute() $this->assertEquals('2020-01-01', $document->getExpirationDate()->format('Y-m-d')); } + /** + * @covers ::getType + * @covers ::getIssuingCountry + * @covers ::getDocumentNumber + * @covers ::getExpirationDate + * @covers ::getIssuingAuthority + */ public function testShouldParseTwoOptionalAttributes() { $document = new DocumentDetails('DRIVING_LICENCE GBR 1234abc 2016-05-01 DVLA'); @@ -36,24 +52,40 @@ public function testShouldParseTwoOptionalAttributes() $this->assertEquals('DVLA', $document->getIssuingAuthority()); } + /** + * @covers ::__construct + */ public function testShouldThrowExceptionWhenValueIsEmpty() { $this->expectException('Yoti\Exception\AttributeException'); $document = new DocumentDetails(''); } + /** + * @covers ::__construct + */ public function testShouldThrowExceptionForInvalidCountry() { $this->expectException('Yoti\Exception\AttributeException'); $document = new DocumentDetails('PASSPORT 13 1234abc 2016-05-01'); } + /** + * @covers ::__construct + */ public function testShouldThrowExceptionForInvalidNumber() { $this->expectException('Yoti\Exception\AttributeException'); $document = new DocumentDetails("PASSPORT GBR $%^$%^£ 2016-05-01"); } + /** + * @covers ::getType + * @covers ::getIssuingCountry + * @covers ::getDocumentNumber + * @covers ::getExpirationDate + * @covers ::getIssuingAuthority + */ public function testWhenExpirationDateIsMissing() { $document = new DocumentDetails('PASS_CARD GBR 22719564893 - CITIZENCARD'); @@ -64,18 +96,31 @@ public function testWhenExpirationDateIsMissing() $this->assertEquals('CITIZENCARD', $document->getIssuingAuthority()); } + /** + * @covers ::__construct + */ public function testWhenTheValueIsLessThanThreeWords() { $this->expectException('Yoti\Exception\AttributeException'); $documentDetails = new DocumentDetails('PASS_CARD GBR'); } + /** + * @covers ::__construct + */ public function testShouldThrowExceptionForInvalidDate() { $this->expectException('Yoti\Exception\AttributeException'); $document = new DocumentDetails('PASSPORT GBR 1234abc X016-05-01'); } + /** + * @covers ::getType + * @covers ::getIssuingCountry + * @covers ::getDocumentNumber + * @covers ::getExpirationDate + * @covers ::getIssuingAuthority + */ public function testShouldIgnoreTheSixthOptionalAttribute() { $value = 'DRIVING_LICENCE GBR 1234abc 2016-05-01 DVLA someThirdAttribute'; diff --git a/tests/Entity/ImageTest.php b/tests/Entity/ImageTest.php index 68081a6c..f0bf1261 100644 --- a/tests/Entity/ImageTest.php +++ b/tests/Entity/ImageTest.php @@ -4,10 +4,13 @@ use Yoti\Entity\Image; use YotiTest\TestCase; +/** + * @coversDefaultClass \Yoti\Entity\Image + */ class ImageTest extends TestCase { /** - * @var Image + * @var \Yoti\Entity\Image */ public $dummyImage; @@ -16,22 +19,34 @@ public function setup() $this->dummyImage = new Image('dummyImageData', 'png'); } + /** + * @covers ::getMimeType + */ public function testGetMimeType() { $this->assertEquals('image/png', $this->dummyImage->getMimeType()); } + /** + * @covers ::getContent + */ public function testGetContent() { $this->assertEquals('dummyImageData', $this->dummyImage->getContent()); } + /** + * @covers ::getBase64Content + */ public function testGetBase64Content() { $expectedValue = 'data:image/png;base64,ZHVtbXlJbWFnZURhdGE='; $this->assertEquals($expectedValue, $this->dummyImage->getBase64Content()); } + /** + * @covers ::__construct + */ public function testShouldThrowExceptionForUnsupportedExtension() { $this->expectException("\Yoti\Exception\AttributeException"); diff --git a/tests/Entity/ProfileTest.php b/tests/Entity/ProfileTest.php index 8575b3c6..cbc5d7ff 100644 --- a/tests/Entity/ProfileTest.php +++ b/tests/Entity/ProfileTest.php @@ -7,21 +7,29 @@ use Yoti\Entity\Attribute; use Yoti\Entity\AgeVerification; +/** + * @coversDefaultClass \Yoti\Entity\Profile + */ class ProfileTest extends TestCase { /** * @var \Yoti\Entity\Profile */ public $profile; + /** * @var \Yoti\YotiClient */ public $yotiClient; + /** * @var string */ public $expectedPhoneNumber; + /** + * @var Array Structured Postal Address + */ public $dummyStructuredPostalAddress; public function setup() @@ -55,18 +63,34 @@ public function setup() $this->profile = $activityDetails->getProfile(); } + /** + * @covers \Yoti\Entity\Attribute::getValue + * @covers ::getPhoneNumber + * @covers ::getProfileAttribute + */ public function testGetAttributeValue() { $phoneNumber = $this->profile->getPhoneNumber(); + $this->assertInstanceOf(Attribute::class, $phoneNumber); $this->assertEquals($this->expectedPhoneNumber, $phoneNumber->getValue()); } + /** + * @covers \Yoti\Entity\Attribute::getName + * @covers ::getPhoneNumber + * @covers ::getProfileAttribute + */ public function testGetAttributeName() { $phoneNumber = $this->profile->getPhoneNumber(); + $this->assertInstanceOf(Attribute::class, $phoneNumber); $this->assertEquals('phone_number', $phoneNumber->getName()); } + /** + * @covers ::getPostalAddress + * @covers ::getStructuredPostalAddress + */ public function testShouldReturnFormattedAddressAsPostalAddressWhenNull() { $structuredPostalAddress = new Attribute( @@ -95,18 +119,26 @@ public function testShouldReturnFormattedAddressAsPostalAddressWhenNull() /** * Should not return age_verifications in the array + * + * @covers ::getAttributes + * @dataProvider getDummyProfileDataWithAgeVerifications */ - public function testGetAttributes() + public function testGetAttributes($profileData) { - $profileData = $this->getDummyProfileDataWithAgeVerifications(); $profile = new Profile($profileData); $this->assertArrayNotHasKey(Profile::ATTR_AGE_VERIFICATIONS, $profile->getAttributes()); } - public function testFindAgeOverVerification() + /** + * @covers ::findAgeOverVerification + * @covers \Yoti\Entity\AgeVerification::getCheckType + * @covers \Yoti\Entity\AgeVerification::getAge + * @covers \Yoti\Entity\AgeVerification::getResult + * @dataProvider getDummyProfileDataWithAgeVerifications + */ + public function testFindAgeOverVerification($profileData) { - $profileData = $this->getDummyProfileDataWithAgeVerifications(); $profile = new Profile($profileData); $ageOver35 = $profile->findAgeOverVerification(35); @@ -116,9 +148,15 @@ public function testFindAgeOverVerification() $this->assertTrue($ageOver35->getResult()); } - public function testFindAgeUnderVerification() + /** + * @covers ::findAgeUnderVerification + * @covers \Yoti\Entity\AgeVerification::getCheckType + * @covers \Yoti\Entity\AgeVerification::getAge + * @covers \Yoti\Entity\AgeVerification::getResult + * @dataProvider getDummyProfileDataWithAgeVerifications + */ + public function testFindAgeUnderVerification($profileData) { - $profileData = $this->getDummyProfileDataWithAgeVerifications(); $profile = new Profile($profileData); $ageUnder18 = $profile->findAgeUnderVerification(18); @@ -128,6 +166,9 @@ public function testFindAgeUnderVerification() $this->assertFalse($ageUnder18->getResult()); } + /** + * Profile data provider with age verifications. + */ public function getDummyProfileDataWithAgeVerifications() { $profileData = [ @@ -164,6 +205,6 @@ public function getDummyProfileDataWithAgeVerifications() [] ), ]; - return $profileData; + return [[$profileData]]; } -} \ No newline at end of file +} diff --git a/tests/Entity/ReceiptTest.php b/tests/Entity/ReceiptTest.php index c491ddf0..92a905e6 100644 --- a/tests/Entity/ReceiptTest.php +++ b/tests/Entity/ReceiptTest.php @@ -7,8 +7,14 @@ use Yoti\Entity\ApplicationProfile; use Yoti\Util\Profile\AttributeListConverter; +/** + * @coversDefaultClass \Yoti\Entity\Receipt + */ class ReceiptTest extends TestCase { + /** + * @var string Pem file contents. + */ public $pem; /** @@ -23,28 +29,43 @@ public function setup() $this->receipt = new Receipt($receiptArr['receipt']); } + /** + * @covers ::__construct + */ public function testShouldThrowExceptionForInvalidReceipt() { $this->expectException('\Yoti\Exception\ReceiptException'); $receipt = new Receipt([]); } + /** + * @covers ::getTimestamp + */ public function testGetTimestamp() { $this->assertEquals('2016-07-19T08:55:38Z', $this->receipt->getTimestamp()); } + /** + * @covers ::getRememberMeId + */ public function testGetRememberMeId() { $expectedRememberMeId = 'Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU'; $this->assertEquals($expectedRememberMeId, $this->receipt->getRememberMeId()); } + /** + * @covers ::getSharingOutcome + */ public function testGetSharingOutcome() { $this->assertEquals('SUCCESS', $this->receipt->getSharingOutcome()); } + /** + * @covers ::getReceiptId + */ public function testGetReceiptId() { $expectedReceiptId = '9HNJDX5bEIN5TqBm0OGzVIc1LaAmbzfx6eIrwNdwpHvKeQmgPujyogC+r7hJCVPl'; @@ -54,6 +75,9 @@ public function testGetReceiptId() ); } + /** + * @covers ::parseAttribute + */ public function testShouldParseOtherPartyProfileContent() { $protobufAttributesList = $this->receipt->parseAttribute( @@ -67,6 +91,9 @@ public function testShouldParseOtherPartyProfileContent() $this->assertEquals('+447474747474', $profile->getPhoneNumber()->getValue()); } + /** + * @covers ::parseAttribute + */ public function testShouldParseProfileContent() { $protobufAttributesList = $this->receipt->parseAttribute( diff --git a/tests/Http/AmlResultTest.php b/tests/Http/AmlResultTest.php index 76ef5239..2822bc6e 100644 --- a/tests/Http/AmlResultTest.php +++ b/tests/Http/AmlResultTest.php @@ -5,6 +5,9 @@ use Yoti\Http\AmlResult; use YotiTest\TestCase; +/** + * @coversDefaultClass \Yoti\Http\AmlResult + */ class AmlResultTest extends TestCase { /** @@ -18,16 +21,25 @@ public function setup() $this->amlResult = new AmlResult($resultArr); } + /** + * @covers ::isOnPepList + */ public function testIsOnPepeList() { $this->assertTrue($this->amlResult->isOnPepList()); } + /** + * @covers ::isOnFraudList + */ public function testIsOnFraudList() { $this->assertFalse($this->amlResult->isOnFraudList()); } + /** + * @covers ::isOnWatchList + */ public function testIsOnWatchList() { $this->assertFalse($this->amlResult->isOnWatchList()); diff --git a/tests/Http/CurlRequestHandlerTest.php b/tests/Http/CurlRequestHandlerTest.php index f4ffec68..6f558488 100644 --- a/tests/Http/CurlRequestHandlerTest.php +++ b/tests/Http/CurlRequestHandlerTest.php @@ -12,30 +12,37 @@ use Yoti\Http\CurlRequestHandler; use Yoti\Http\AbstractRequestHandler; +/** + * @coversDefaultClass \Yoti\Http\CurlRequestHandler + */ class CurlRequestHandlerTest extends TestCase { + /** + * @var string Pem file contents + */ public $pem; + /** * @var CurlRequestHandler */ public $requestHandler; + /** - * @var Payload + * @var \Yoti\Http\Payload */ public $payload; + /** + * @var Yoti\Http\RequestSigner + */ public $requestSigner; - public $postMethod = CurlRequestHandler::METHOD_POST; - public function setup() { $endpoint = '/aml-check'; $amlAddress = new AmlAddress(new Country('GBR')); $amlProfile = new AmlProfile('Edward Richard George', 'Heath', $amlAddress); $this->payload = new Payload($amlProfile->getData()); - $this->postMethod = CurlRequestHandler::METHOD_POST; - $this->pem = file_get_contents(PEM_FILE); $this->requestSigner = new RequestSigner( @@ -52,16 +59,25 @@ public function setup() ); } + /** + * @covers ::getPem + */ public function testGetPem() { $this->assertEquals($this->pem, $this->requestHandler->getPem()); } + /** + * @covers ::getSdkId + */ public function testGetSdkId() { $this->assertEquals(SDK_ID, $this->requestHandler->getSdkId()); } + /** + * @covers ::sendRequest + */ public function testInvalidHttpMethod() { $this->expectException('\Yoti\Exception\RequestException'); @@ -72,11 +88,17 @@ public function testInvalidHttpMethod() ); } + /** + * @covers ::sendRequest + */ public function testClassIsInstanceOfAbstractRequestHandler() { $this->assertInstanceOf(AbstractRequestHandler::class, $this->requestHandler); } + /** + * @covers ::sendRequest + */ public function testSendRequest() { $expectedResult['response'] = file_get_contents(RECEIPT_JSON); diff --git a/tests/Http/PayloadTest.php b/tests/Http/PayloadTest.php index 1dd16715..ed217b87 100644 --- a/tests/Http/PayloadTest.php +++ b/tests/Http/PayloadTest.php @@ -8,6 +8,9 @@ use Yoti\Http\Payload; use YotiTest\TestCase; +/** + * @coversDefaultClass \Yoti\Http\Payload + */ class PayloadTest extends TestCase { /** @@ -38,6 +41,8 @@ public function setup() /** * Test getting Payload data as a JSON string. + * + * @covers ::getPayloadJSON */ public function testGetPayloadJSON() { @@ -46,17 +51,26 @@ public function testGetPayloadJSON() /** * Test getting Payload data as a Base64 string. + * + * @covers ::getBase64Payload */ public function testGetBase64Payload() { $this->assertEquals($this->base64Payload, $this->payload->getBase64Payload()); } + /** + * @covers ::getRawData + */ public function testGetRawData() { $this->assertEquals($this->payloadJSON, json_encode($this->payload->getRawData())); } + /** + * @covers ::__construct + * @covers ::getPayloadJSON + */ public function testPassingAStringAsPayloadData() { $payloadData = 'payloadDataAsAString'; diff --git a/tests/Http/RequestSignerTest.php b/tests/Http/RequestSignerTest.php index a4d31de5..27904e33 100644 --- a/tests/Http/RequestSignerTest.php +++ b/tests/Http/RequestSignerTest.php @@ -11,17 +11,20 @@ use Yoti\Entity\AmlProfile; use Yoti\Http\RequestSigner; +/** + * @coversDefaultClass \Yoti\Http\RequestSigner + */ class RequestSignerTest extends TestCase { /** - * @var Payload + * @var \Yoti\Http\Payload */ public $payload; + /** - * @var CurlRequestHandler + * @var \Yoti\Http\CurlRequestHandler */ public $request; - public $messageToSign; public function setup() { @@ -37,7 +40,7 @@ public function setup() } /** - * Test verifying a signed message. + * @covers ::signRequest */ public function testShouldVerifySignedMessage() { @@ -58,6 +61,11 @@ public function testShouldVerifySignedMessage() $this->assertEquals(1, $verify); } + /** + * Dummy request payload + * + * @return \Yoti\Http\Payload + */ public function getDummyPayload() { $amlAddress = new AmlAddress(new Country('GBR')); @@ -65,11 +73,21 @@ public function getDummyPayload() return new Payload($amlProfile->getData()); } + /** + * Dummy private key + * + * @return string + */ public function getDummyPrivateKey() { return file_get_contents(AML_PRIVATE_KEY); } + /** + * Dummy public key + * + * @return string + */ public function getDummyPublicKey() { return file_get_contents(AML_PUBLIC_KEY); diff --git a/tests/Util/Age/AgeOverVerificationProcessorTest.php b/tests/Util/Age/AgeOverVerificationProcessorTest.php index 7c5941ee..f938d84c 100644 --- a/tests/Util/Age/AgeOverVerificationProcessorTest.php +++ b/tests/Util/Age/AgeOverVerificationProcessorTest.php @@ -6,8 +6,17 @@ use Yoti\Entity\AgeVerification; use Yoti\Util\Age\AgeOverVerificationProcessor; +/** + * @coversDefaultClass \Yoti\Util\Age\AgeOverVerificationProcessor + */ class AgeOverVerificationProcessorTest extends TestCase { + /** + * @covers ::process + * @covers \Yoti\Entity\AgeVerification::getResult + * @covers \Yoti\Entity\AgeVerification::getCheckType + * @covers \Yoti\Entity\AgeVerification::getAge + */ public function testProcessWithAgeOver() { $ageAttribute = new Attribute('age_over:18', 'true', []); @@ -19,6 +28,12 @@ public function testProcessWithAgeOver() $this->assertEquals(18, $ageVerificationObj->getAge()); } + /** + * @covers ::process + * @covers \Yoti\Entity\AgeVerification::getResult + * @covers \Yoti\Entity\AgeVerification::getCheckType + * @covers \Yoti\Entity\AgeVerification::getAge + */ public function testForAgeOver20ShouldReturnTrue() { $ageAttribute = new Attribute('age_over:20', 'true', []); @@ -30,6 +45,9 @@ public function testForAgeOver20ShouldReturnTrue() $this->assertEquals(20, $ageVerificationObj->getAge()); } + /** + * @covers ::process + */ public function testWhenThereIsNotAgeOverShouldReturnNull() { $ageAttribute = new Attribute('age_under:20', 'false', []); diff --git a/tests/Util/Age/AgeUnderVerificationProcessorTest.php b/tests/Util/Age/AgeUnderVerificationProcessorTest.php index bf6b14ad..39072c14 100644 --- a/tests/Util/Age/AgeUnderVerificationProcessorTest.php +++ b/tests/Util/Age/AgeUnderVerificationProcessorTest.php @@ -6,8 +6,17 @@ use Yoti\Entity\AgeVerification; use Yoti\Util\Age\AgeUnderVerificationProcessor; +/** + * @coversDefaultClass \Yoti\Util\Age\AgeUnderVerificationProcessor + */ class AgeUnderVerificationProcessorTest extends TestCase { + /** + * @covers ::process + * @covers \Yoti\Entity\AgeVerification::getResult + * @covers \Yoti\Entity\AgeVerification::getCheckType + * @covers \Yoti\Entity\AgeVerification::getAge + */ public function testProcessWithAgeUnder() { $ageAttribute = new Attribute('age_under:18', 'false', []); @@ -19,6 +28,12 @@ public function testProcessWithAgeUnder() $this->assertEquals(18, $ageVerificationObj->getAge()); } + /** + * @covers ::process + * @covers \Yoti\Entity\AgeVerification::getResult + * @covers \Yoti\Entity\AgeVerification::getCheckType + * @covers \Yoti\Entity\AgeVerification::getAge + */ public function testForAgeUnder20ShouldReturnTrue() { $ageAttribute = new Attribute('age_under:20', 'true', []); @@ -30,6 +45,9 @@ public function testForAgeUnder20ShouldReturnTrue() $this->assertEquals(20, $ageVerificationObj->getAge()); } + /** + * @covers ::process + */ public function testWhenThereIsNotAgeUnderShouldReturnNull() { $ageAttribute = new Attribute('age_over:20', 'false', []); diff --git a/tests/Util/Age/AgeVerificationConverterTest.php b/tests/Util/Age/AgeVerificationConverterTest.php index 126bc409..b4c061b9 100644 --- a/tests/Util/Age/AgeVerificationConverterTest.php +++ b/tests/Util/Age/AgeVerificationConverterTest.php @@ -8,8 +8,14 @@ use Yoti\Entity\AgeVerification; use Yoti\Util\Age\AgeVerificationConverter; +/** + * @coversDefaultClass \Yoti\Util\Age\AgeVerificationConverter + */ class AgeVerificationConverterTest extends TestCase { + /** + * @covers ::getAgeVerificationsFromAttrsMap + */ public function testGetAgeVerificationsFromAttrsMap() { $ageAttribute = new Attribute('age_under:18', 'true', []); @@ -24,6 +30,9 @@ public function testGetAgeVerificationsFromAttrsMap() $this->assertInstanceOf(Attribute::class, $ageUnder18->getAttribute()); } + /** + * @covers ::getAgeVerificationsFromAttrsMap + */ public function testMultipleAgeDerivations() { $profileData = [ @@ -49,6 +58,9 @@ public function testMultipleAgeDerivations() $this->assertArrayNotHasKey('age_breaker:50', $ageVerifications); } + /** + * @covers ::getAgeVerificationsFromAttrsMap + */ public function testShouldReturnEmptyAgeVerifications() { $profileData = [ diff --git a/tests/Util/ConfigTest.php b/tests/Util/ConfigTest.php index 58eaa73d..0a81c511 100644 --- a/tests/Util/ConfigTest.php +++ b/tests/Util/ConfigTest.php @@ -5,13 +5,22 @@ use YotiTest\TestCase; use Yoti\Util\Config; +/** + * @coversDefaultClass \Yoti\Util\Config + */ class ConfigTest extends TestCase { + /** + * @covers ::getInstance + */ public function testConfigInstance() { $this->assertInstanceOf(Config::class, Config::getInstance()); } + /** + * @covers ::get + */ public function testGetSDKVersion() { $sdkVersion = Config::getInstance()->get('version'); diff --git a/tests/Util/Profile/AnchorListConverterTest.php b/tests/Util/Profile/AnchorListConverterTest.php index 30d36f10..5d705b4e 100644 --- a/tests/Util/Profile/AnchorListConverterTest.php +++ b/tests/Util/Profile/AnchorListConverterTest.php @@ -7,14 +7,23 @@ use YotiTest\TestCase; use Yoti\Util\Profile\AnchorListConverter; +/** + * @coversDefaultClass \Yoti\Util\Profile\AnchorListConverter + */ class AnchorListConverterTest extends TestCase { + /** + * @covers ::convert + */ public function testConvertingSourceAnchor() { $anchorsData = $this->parseFromBase64String(TestAnchors::SOURCE_PP_ANCHOR); $this->assertEquals('PASSPORT', $anchorsData[Anchor::TYPE_SOURCE_OID][0]->getValue()); } + /** + * @covers ::convert + */ public function testConvertingVerifierAnchor() { $anchorsData = $this->parseFromBase64String(TestAnchors::VERIFIER_YOTI_ADMIN_ANCHOR); @@ -22,6 +31,9 @@ public function testConvertingVerifierAnchor() $this->assertEquals('YOTI_ADMIN', $anchorVerifiersObj->getValue()); } + /** + * @covers ::convert + */ public function testConvertingTwoSources() { $passportAnchor = new \Attrpubapi\Anchor(); diff --git a/tests/YotiClientTest.php b/tests/YotiClientTest.php index ed0dfab0..fdb8c0b8 100755 --- a/tests/YotiClientTest.php +++ b/tests/YotiClientTest.php @@ -8,6 +8,9 @@ use Yoti\Entity\AmlProfile; use Yoti\Http\AmlResult; +/** + * @coversDefaultClass \Yoti\YotiClient + */ class YotiClientTest extends TestCase { /** @@ -15,10 +18,19 @@ class YotiClientTest extends TestCase */ public $yotiClient; + /** + * @var string Pem file contents + */ public $pem; + /** + * @var \Yoti\Entity\AmlProfile + */ public $amlProfile; + /** + * @var array Aml Result + */ public $amlResult = []; public function setUp() @@ -38,6 +50,8 @@ public function setUp() /** * Test the use of pem file + * + * @covers ::__construct */ public function testCanUsePemFile() { @@ -47,6 +61,8 @@ public function testCanUsePemFile() /** * Test passing invalid pem file path + * + * @covers ::__construct */ public function testInvalidPem() { @@ -55,7 +71,7 @@ public function testInvalidPem() } /** - * Test getting activity details + * @covers ::getActivityDetails */ public function testGetActivityDetails() { @@ -71,7 +87,7 @@ public function testGetActivityDetails() } /** - * Test performAmlCheck with a mock result + * @covers ::performAmlCheck */ public function testPerformAmlCheck() { @@ -85,6 +101,8 @@ public function testPerformAmlCheck() /** * Test invalid Token + * + * @covers ::getActivityDetails */ public function testInvalidConnectToken() { @@ -96,6 +114,8 @@ public function testInvalidConnectToken() /** * Test invalid http header value for X-Yoti-SDK + * + * @covers ::__construct */ public function testInvalidSdkIdentifier() { @@ -110,6 +130,8 @@ public function testInvalidSdkIdentifier() /** * Test X-Yoti-SDK http header value for Wordpress + * + * @covers ::__construct */ public function testCanUseWordPressAsSdkIdentifier() { @@ -125,6 +147,8 @@ public function testCanUseWordPressAsSdkIdentifier() /** * Test X-Yoti-SDK http header value for Drupal + * + * @covers ::__construct */ public function testCanUseDrupalAsSdkIdentifier() { @@ -140,6 +164,8 @@ public function testCanUseDrupalAsSdkIdentifier() /** * Test X-Yoti-SDK http header value for Joomla + * + * @covers ::__construct */ public function testCanUseJoomlaAsSdkIdentifier() { @@ -155,6 +181,8 @@ public function testCanUseJoomlaAsSdkIdentifier() /** * Test X-Yoti-SDK http header value for PHP + * + * @covers ::__construct */ public function testCanUsePHPAsSdkIdentifier() { From f3fcaf3f03fe95d730d9600663e7854e105824c0 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 8 Mar 2019 15:59:12 +0000 Subject: [PATCH 09/14] SDK-848: PSR-2 Coding Standards --- tests/ActivityDetailsTest.php | 2 +- tests/Entity/AnchorTest.php | 2 +- tests/Entity/ApplicationProfileTest.php | 6 +++--- tests/Entity/AttributeTest.php | 2 +- tests/Entity/DocumentDetailsTest.php | 2 +- tests/Entity/ImageTest.php | 2 +- tests/Entity/ReceiptTest.php | 2 +- tests/Http/AmlResultTest.php | 4 ++-- tests/Http/CurlRequestHandlerTest.php | 2 +- tests/Http/PayloadTest.php | 8 +++++--- tests/Http/RequestSignerTest.php | 4 ++-- tests/TestCase.php | 2 +- tests/Util/Age/AgeOverVerificationProcessorTest.php | 2 +- .../Util/Age/AgeUnderVerificationProcessorTest.php | 2 +- tests/Util/ConfigTest.php | 2 +- tests/Util/Profile/AnchorListConverterTest.php | 2 +- tests/Util/Profile/TestAnchors.php | 2 +- tests/YotiClientTest.php | 2 +- tests/bootstrap.php | 11 +---------- tests/config.php | 13 +++++++++++++ 20 files changed, 40 insertions(+), 34 deletions(-) create mode 100644 tests/config.php diff --git a/tests/ActivityDetailsTest.php b/tests/ActivityDetailsTest.php index d8123ee7..4c6bf5a7 100644 --- a/tests/ActivityDetailsTest.php +++ b/tests/ActivityDetailsTest.php @@ -156,4 +156,4 @@ public function testGetReceipt() $receiptId = '9HNJDX5bEIN5TqBm0OGzVIc1LaAmbzfx6eIrwNdwpHvKeQmgPujyogC+r7hJCVPl'; $this->assertEquals($receiptId, $this->activityDetails->getReceiptId()); } -} \ No newline at end of file +} diff --git a/tests/Entity/AnchorTest.php b/tests/Entity/AnchorTest.php index 4be4e588..91cd2583 100644 --- a/tests/Entity/AnchorTest.php +++ b/tests/Entity/AnchorTest.php @@ -55,4 +55,4 @@ public function testYotiAnchorEndpoints() $sourceAnchor->getOriginServerCerts()[0] ); } -} \ No newline at end of file +} diff --git a/tests/Entity/ApplicationProfileTest.php b/tests/Entity/ApplicationProfileTest.php index 5d82805b..59d33a79 100644 --- a/tests/Entity/ApplicationProfileTest.php +++ b/tests/Entity/ApplicationProfileTest.php @@ -19,10 +19,10 @@ class ApplicationProfileTest extends TestCase public function setup() { $dummyData = [ - 'application_name' => new Attribute('application_name','Test PHP SDK',[]), + 'application_name' => new Attribute('application_name', 'Test PHP SDK', []), 'application_url' => new Attribute('application_url', 'https://localhost', []), 'application_receipt_bgcolor' => new Attribute('application_receipt_bgcolor', '#F5F5F5', []), - 'application_logo' => new Attribute('application_logo', new Image('dummyImageData','png'), []), + 'application_logo' => new Attribute('application_logo', new Image('dummyImageData', 'png'), []), ]; $this->dummyProfile = new ApplicationProfile($dummyData); } @@ -83,4 +83,4 @@ public function testGetApplicationLogoImageType() $this->dummyProfile->getApplicationLogo()->getValue()->getMimeType() ); } -} \ No newline at end of file +} diff --git a/tests/Entity/AttributeTest.php b/tests/Entity/AttributeTest.php index 3a04e540..555e27d0 100644 --- a/tests/Entity/AttributeTest.php +++ b/tests/Entity/AttributeTest.php @@ -114,4 +114,4 @@ public function convertToProtobufAnchor($anchorString) $anchor->mergeFromString(base64_decode($anchorString)); return $anchor; } -} \ No newline at end of file +} diff --git a/tests/Entity/DocumentDetailsTest.php b/tests/Entity/DocumentDetailsTest.php index d34642bd..4309ed51 100644 --- a/tests/Entity/DocumentDetailsTest.php +++ b/tests/Entity/DocumentDetailsTest.php @@ -132,4 +132,4 @@ public function testShouldIgnoreTheSixthOptionalAttribute() $this->assertEquals('2016-05-01', $document->getExpirationDate()->format('Y-m-d')); $this->assertEquals('DVLA', $document->getIssuingAuthority()); } -} \ No newline at end of file +} diff --git a/tests/Entity/ImageTest.php b/tests/Entity/ImageTest.php index f0bf1261..c3df7113 100644 --- a/tests/Entity/ImageTest.php +++ b/tests/Entity/ImageTest.php @@ -52,4 +52,4 @@ public function testShouldThrowExceptionForUnsupportedExtension() $this->expectException("\Yoti\Exception\AttributeException"); $image = new Image('dummyImageData', 'bmp'); } -} \ No newline at end of file +} diff --git a/tests/Entity/ReceiptTest.php b/tests/Entity/ReceiptTest.php index 92a905e6..feb6dbe1 100644 --- a/tests/Entity/ReceiptTest.php +++ b/tests/Entity/ReceiptTest.php @@ -110,4 +110,4 @@ public function testShouldParseProfileContent() $this->assertEquals('Node SDK Test', $applicationProfile->getApplicationName()->getValue()); $this->assertEquals('#ffffff', $applicationProfile->getApplicationReceiptBgColor()->getValue()); } -} \ No newline at end of file +} diff --git a/tests/Http/AmlResultTest.php b/tests/Http/AmlResultTest.php index 2822bc6e..6c6e10ab 100644 --- a/tests/Http/AmlResultTest.php +++ b/tests/Http/AmlResultTest.php @@ -17,7 +17,7 @@ class AmlResultTest extends TestCase public function setup() { - $resultArr = json_decode(file_get_contents(AML_CHECK_RESULT_JSON), TRUE); + $resultArr = json_decode(file_get_contents(AML_CHECK_RESULT_JSON), true); $this->amlResult = new AmlResult($resultArr); } @@ -44,4 +44,4 @@ public function testIsOnWatchList() { $this->assertFalse($this->amlResult->isOnWatchList()); } -} \ No newline at end of file +} diff --git a/tests/Http/CurlRequestHandlerTest.php b/tests/Http/CurlRequestHandlerTest.php index 6f558488..3a31f183 100644 --- a/tests/Http/CurlRequestHandlerTest.php +++ b/tests/Http/CurlRequestHandlerTest.php @@ -118,4 +118,4 @@ public function testSendRequest() ); $this->assertEquals(json_encode($expectedResult), json_encode($result)); } -} \ No newline at end of file +} diff --git a/tests/Http/PayloadTest.php b/tests/Http/PayloadTest.php index ed217b87..7a57aae3 100644 --- a/tests/Http/PayloadTest.php +++ b/tests/Http/PayloadTest.php @@ -35,8 +35,10 @@ public function setup() $this->payload = new Payload($amlProfile->getData()); // Expected test data - $this->payloadJSON = '{"given_names":"Edward Richard George","family_name":"Heath","ssn":null,"address":{"post_code":null,"country":"GBR"}}'; - $this->base64Payload = 'eyJnaXZlbl9uYW1lcyI6IkVkd2FyZCBSaWNoYXJkIEdlb3JnZSIsImZhbWlseV9uYW1lIjoiSGVhdGgiLCJzc24iOm51bGwsImFkZHJlc3MiOnsicG9zdF9jb2RlIjpudWxsLCJjb3VudHJ5IjoiR0JSIn19'; + $this->payloadJSON = '{"given_names":"Edward Richard George","family_name":"Heath",' . + '"ssn":null,"address":{"post_code":null,"country":"GBR"}}'; + $this->base64Payload = 'eyJnaXZlbl9uYW1lcyI6IkVkd2FyZCBSaWNoYXJkIEdlb3JnZSIsImZhbWls' . + 'eV9uYW1lIjoiSGVhdGgiLCJzc24iOm51bGwsImFkZHJlc3MiOnsicG9zdF9jb2RlIjpudWxsLCJjb3VudHJ5IjoiR0JSIn19'; } /** @@ -77,4 +79,4 @@ public function testPassingAStringAsPayloadData() $payload = new Payload($payloadData); $this->assertEquals(json_encode($payloadData), $payload->getPayloadJSON()); } -} \ No newline at end of file +} diff --git a/tests/Http/RequestSignerTest.php b/tests/Http/RequestSignerTest.php index 27904e33..99261506 100644 --- a/tests/Http/RequestSignerTest.php +++ b/tests/Http/RequestSignerTest.php @@ -33,7 +33,7 @@ public function setup() $this->request = new CurlRequestHandler( YotiClient::DEFAULT_CONNECT_API, - $pem , + $pem, SDK_ID, 'PHP' ); @@ -92,4 +92,4 @@ public function getDummyPublicKey() { return file_get_contents(AML_PUBLIC_KEY); } -} \ No newline at end of file +} diff --git a/tests/TestCase.php b/tests/TestCase.php index eaa3f79a..455e8632 100644 --- a/tests/TestCase.php +++ b/tests/TestCase.php @@ -7,4 +7,4 @@ class TestCase extends PHPUnit_Framework_TestCase { -} \ No newline at end of file +} diff --git a/tests/Util/Age/AgeOverVerificationProcessorTest.php b/tests/Util/Age/AgeOverVerificationProcessorTest.php index f938d84c..46311a6f 100644 --- a/tests/Util/Age/AgeOverVerificationProcessorTest.php +++ b/tests/Util/Age/AgeOverVerificationProcessorTest.php @@ -54,4 +54,4 @@ public function testWhenThereIsNotAgeOverShouldReturnNull() $ageOverVerificationProcessor = new AgeOverVerificationProcessor($ageAttribute); $this->assertNull($ageOverVerificationProcessor->process()); } -} \ No newline at end of file +} diff --git a/tests/Util/Age/AgeUnderVerificationProcessorTest.php b/tests/Util/Age/AgeUnderVerificationProcessorTest.php index 39072c14..16ac1f54 100644 --- a/tests/Util/Age/AgeUnderVerificationProcessorTest.php +++ b/tests/Util/Age/AgeUnderVerificationProcessorTest.php @@ -54,4 +54,4 @@ public function testWhenThereIsNotAgeUnderShouldReturnNull() $ageUnderVerificationProcessor = new AgeUnderVerificationProcessor($ageAttribute); $this->assertNull($ageUnderVerificationProcessor->process()); } -} \ No newline at end of file +} diff --git a/tests/Util/ConfigTest.php b/tests/Util/ConfigTest.php index 0a81c511..9a389ac4 100644 --- a/tests/Util/ConfigTest.php +++ b/tests/Util/ConfigTest.php @@ -26,4 +26,4 @@ public function testGetSDKVersion() $sdkVersion = Config::getInstance()->get('version'); $this->assertNotNull($sdkVersion); } -} \ No newline at end of file +} diff --git a/tests/Util/Profile/AnchorListConverterTest.php b/tests/Util/Profile/AnchorListConverterTest.php index 5d705b4e..5db179d9 100644 --- a/tests/Util/Profile/AnchorListConverterTest.php +++ b/tests/Util/Profile/AnchorListConverterTest.php @@ -68,4 +68,4 @@ public function parseFromBase64String($anchorString) return AnchorListConverter::convert($collection); } -} \ No newline at end of file +} diff --git a/tests/Util/Profile/TestAnchors.php b/tests/Util/Profile/TestAnchors.php index e456ca31..6d87ad03 100644 --- a/tests/Util/Profile/TestAnchors.php +++ b/tests/Util/Profile/TestAnchors.php @@ -123,4 +123,4 @@ class TestAnchors . "b185Qe6PWL4Jl+DvbzN2C0wsUFKRQyRwgBEIaQ8PyYstoCGhyG6joGfHdvA8tGS+Ol98" . "igUHdLW56nhnGLovTMIhz+RsUWrtszSjWSim2/4vJAE8QjXJ98ou4AVzKUOg9EUklWSU" . "5HX0xJQ0VOQ0U="; -} \ No newline at end of file +} diff --git a/tests/YotiClientTest.php b/tests/YotiClientTest.php index fdb8c0b8..97071260 100755 --- a/tests/YotiClientTest.php +++ b/tests/YotiClientTest.php @@ -196,4 +196,4 @@ public function testCanUsePHPAsSdkIdentifier() $this->assertInstanceOf(YotiClient::class, $yotiClientObj); } -} \ No newline at end of file +} diff --git a/tests/bootstrap.php b/tests/bootstrap.php index e1d07fa4..c7184b55 100644 --- a/tests/bootstrap.php +++ b/tests/bootstrap.php @@ -3,13 +3,4 @@ * loads all required files including composer vendor autoload */ require_once __DIR__ . '/../vendor/autoload.php'; - -define('SDK_ID', '990a3996-5762-4e8a-aa64-cb406fdb0e68'); -define('RECEIPT_JSON', __DIR__ . '/sample-data/receipt.json'); -define('INVALID_YOTI_CONNECT_TOKEN', 'sdfsdfsdasdajsopifajsd='); -define('PEM_FILE', __DIR__ . '/sample-data/yw-access-security.pem'); -define('DUMMY_SELFIE_FILE', __DIR__ . '/sample-data/dummy-avatar.png'); -define('AML_PRIVATE_KEY', __DIR__ . '/sample-data/aml-check-private-key.pem'); -define('AML_PUBLIC_KEY', __DIR__ . '/sample-data/aml-check-public-key.pem'); -define('AML_CHECK_RESULT_JSON', __DIR__ . '/sample-data/aml-check-result.json'); -define('YOTI_CONNECT_TOKEN', file_get_contents(__DIR__ . '/sample-data/connect-token.txt')); \ No newline at end of file +require_once __DIR__ . '/config.php'; diff --git a/tests/config.php b/tests/config.php new file mode 100644 index 00000000..cd13004b --- /dev/null +++ b/tests/config.php @@ -0,0 +1,13 @@ + Date: Fri, 8 Mar 2019 15:43:09 +0000 Subject: [PATCH 10/14] SDK-707: Document and test Parent Remember Me ID --- README.md | 3 ++- tests/ActivityDetailsTest.php | 11 ++++------- tests/sample-data/receipt.json | 2 +- 3 files changed, 7 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 868c2de4..8bbd648b 100755 --- a/README.md +++ b/README.md @@ -300,7 +300,8 @@ $ ./vendor/bin/phpunit tests ## API Coverage * Activity Details - * [X] RememberMe ID `getRememberMeId()` + * [X] Remember Me ID `getRememberMeId()` + * [X] Parent Remember Me ID `getParentRememberMeId()` * [X] Receipt ID `getReceiptId()` * [X] Timestamp `getTimestamp()` // DateTime Object * [X] Application Profile `getApplicationProfile()` diff --git a/tests/ActivityDetailsTest.php b/tests/ActivityDetailsTest.php index 4c6bf5a7..996a2b54 100644 --- a/tests/ActivityDetailsTest.php +++ b/tests/ActivityDetailsTest.php @@ -29,11 +29,6 @@ class ActivityDetailsTest extends TestCase */ public $applicationProfile; - /** - * @var string Remember Me ID - */ - public $rememberMeId = 'Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU'; - public function setUp() { $pem = file_get_contents(PEM_FILE); @@ -58,7 +53,8 @@ public function testActivityDetailsInstance() */ public function testGetRememberMeId() { - $this->assertEquals($this->rememberMeId, $this->activityDetails->getRememberMeId()); + $rememberMeId = 'Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU'; + $this->assertEquals($rememberMeId, $this->activityDetails->getRememberMeId()); } /** @@ -66,7 +62,8 @@ public function testGetRememberMeId() */ public function testGetParentRememberMeIdExists() { - $this->assertTrue(method_exists($this->activityDetails, 'getParentRememberMeId')); + $parentRememberMeId = 'f5RjVQMyoKOvO/hkv43Ik+t6d6mGfP2tdrNijH4k4qafTG0FSNUgQIvd2Z3Nx1j8'; + $this->assertEquals($parentRememberMeId, $this->activityDetails->getParentRememberMeId()); } /** diff --git a/tests/sample-data/receipt.json b/tests/sample-data/receipt.json index f0569b6e..8110c73c 100755 --- a/tests/sample-data/receipt.json +++ b/tests/sample-data/receipt.json @@ -1 +1 @@ -{"session_data":"i79CctmY-22ad195c-d166-49a2-af16-8f356788c9dd","receipt":{"receipt_id":"9HNJDX5bEIN5TqBm0OGzVIc1LaAmbzfx6eIrwNdwpHvKeQmgPujyogC+r7hJCVPl","other_party_profile_content":"ChAc3eEiqqy3R+unfX0bmAlPEuC/CU256SaZeIxVFXCjKAlLhMBJn/3V8OICfyx4NdjZjkUXTAOWa5d/6CwGBzRH+q7lAHW1oyJWN6uiopsiHEsp54j1rPIEdlaeMSEGjsLHiPAWa8AQmYBKkJDF2GSM/tOUPCbGE4nXyAwJt+RiAakC13kkQV4Li9opOGxGlVG7GS1L5NO1oqGQr8r7cRu8rUwRQfw07FuMUZ5NMPw3FXnCa5WwjSELWLA3FQeGahVJkDlhCKDkBd71KVK6kZY4MIBnNtLjWgq9JYdzQm1Y2OupMHbP4HRZ+S3f0OE1TFQxEqu2Pw4Urh2ax4Url2NXhcefLDG6B5NoKoQfC974ZLYNvrKn/uav5gzcDiscnaoNAdp6TjMbDSLiWg054Mk1Y+lHR3tHz4Ty6YUglUhaOn1mg6IK3F0nRXF+uGogDutrbmp74UIYs3l89qCB0RS3TjBLTyOUbhv6vzT2QAyhigs8k8+HqWA98Kvr7XQwuthheuN+OWPxYM/mv0YY6mxJKe4cTPXzFF4xJkN7cJPCCQPT+qMTl6dGEQeCOcBHZhI9LMdnvwx/C02MymugVDwk3q1Dh/OJuVKBtvDfa+S7d4NUINml/5ljtxXS1FYTFmjJuLJe228U1KRQu+PMxJ7dvpGGeOyPj8+hTyTA6SSov2nUdw4gCZ+7tImmetguxFlowQl3Vyoccp/JhpbMageZ8J28mv78BP5LWpuq1JgrMxvzl0qMrn+H848c6OUfU+Pj3Nad+bj3dgVwzNd0kXpqGWKKMv9d/50tkpq8DsnDLvSvz2dYdmztTL4M029k9UqF8iqvjxRYJsP4EBjae94qLpCHR1x03SKur2PZ3KJB/gGbdb/QJ59dsuzRrDSJhqp4/mNnQAGfxpz1KamZSFp1HlthbVPnjE6cM2uWfGRCe+UP/vGfcFNfSjiZQvEdPYTPIZlXDs+ahhGjYwhuRdJdbhBlVYa0FccVT/QoNZv2AY8ZEAjvO3nExAsqEzDmZcinXcH4TEIi0k3XF6TbXhN3Xc+nOVe/o6J6fDzjbVsaBw/hC8BKKdtW02AT3FiXxmJl3HYbjMiaJxqAT9ZOezmic7hVRp3dm0biauqOQEs9UWVMMNTc9KLPHkJ7abfzHuGYRmTYgJCcVuZZPUbwIYKDnIA2v0A305il9OVae1jqIvpj8IAOOOZScr62wwLe+2OvZx5jQ5HqD60CS1InIRZmbG3lhEeJP9GG5cLqpGkxyETeFo3O75K0jsd2hjgfcim5ewxO3zDj75ezsFC30WhGKAvs+cNdA7o6nl+3S2D3BbZOgd1/qid4S7SQ0uHmnvTltoSZLG5wcachhzT9Y0GcXAvuTR2zGawBCljQICbPCJX78uiKxvH/vA3IYl70uxO4DPmICPrTS4A7bdiXWZRylBQ3aCuvIM67t2z/HKAtcEW7gM0oX068HrbCPJE90/eyqHVNxhAL7z1wkAA+InWnpB2AtzH9xKfjCjCAteheop/J0pVDFr3ReJwLAN8Oyybj6TLWU1PtF5bs4AnBEr3KuzZ2LKobCnu/NLc1BvHHebU/YWT0OqYoJVcMDCAoR9uT/Xu8wzbgnC4mYq+RExWYDiAx7dUzb0i3DddeWOCWFf+z56aMLtIV5Csspx6Qq6Ca8CEVw0DDpBKe+imwXyAFWd7rLl8yqGIiNJFqiNk7SA1EPazsKito/G6p3Lfmn0HRnpq88zH7CNbP2iJLKW3o/MTgTZz5u8vaLABnX8oOi0DbruulEjqXkjnAiWyEjB3vna3f1SSE8J7s8Wvl+dPlIh9OtSLN6obJcAC1JmeAI33E5IxfNziZJyHn1S27+4de7Mv2q6FEXbNALL6SsJoZ1RxKp8051xU7RPkkGrZGiaj9l+m1NxxEGXQds0/QAPvFHqJ9eyLZhsX3DqjoziV9PwVrzX+KXpzrB0t+q+w0KvJ7yLHzBLj8Y4DXANsdhJ6l0Xrd6eOLuAAA4TghL8WjirjbzWIRbUcncceI0PHBJCQ676jY8IbAjY0jEfwct0iQMJIT0S5p4PpQm8pCiPM7JBxxTWlzb6brRwtB03Q05uMDBI47/R5StejukC2F2kh12DrzNEvw6qDbSbTdOxvrDBPhH52c/myrcNzBual3mRoIw3qpPUq2Lt2os5+FC2WhXY/39FvSFhDQNNLXMHtr4LDYYU4soO3nQcZjeEHFhFLAP0fuzCz/TYzBA8z/Di09M64kbu9SZRa5zi9GOgap93HKkJ/u0BihbetoHAlsBn62tAUSrbFfjXC+jju3t+fOfpgCvxuYBMh7xcdBp1u13gdyMWAwHhKyYFOVU6S6KuDaUe1mehyCv6hJTHlASlGzBPzDqTVhy+lJtPp29no9A4c0IWaTR7K1kup7dw1xenxdxNvXVWSZaAG2mnydMAKU0skwCd+uWeG9kYIPY1d/uiTezKx3rzhMYVHlpO/JRQqZ7z7wxA1YEgzFWX0+OwNkfdTDFRWHa2fu3doY8sr1MwS+bYJQDcOtTHYTs5ZyynzWXfQHMsHOLTRdeb8bMwmiScqEpJR6NN9TwmZuIQW5JeghGxgh2iH2jxlkWc69N3bC64tAXuOMBUlJo7C7NemueNVc4BdovTii8rk7lqW9qtzIKJrWkZUIXHcqMUlkV60fSmxYsByxJqTaxqn9xDgUjFOWRnLFyyIeuA6EEIBA5lyRbA+hayr7WnXAPVRHLGdP7cUgMB4U+RjMCZM+pW1T7EF/wViWzAxhIN+jpevSwMVjaCHnnYmTHZuAAo4UgVFhfDmPqvUf2LfkgwXbhRA7LA1zGRV8fiziN+ei8UvsSjMtmCJXjN2ilcGfJN8rPl+YFqcMoCVWeHgCdH5vljSnIRWo/rUloSqc/wFAlg2E0lEyRRF/nizMGAExW0vXDFvBKviXF3VHPAXqXSTzfw6mo/gubIkyU/vCVTw8mOaCCpebTpz+MpDlb6vqby8GamqcfLt6VEm6z4d8kikMhcWTn1TEsXXkLBan7RjTcB4bS4/dw0JNaqV82IDcXmxE7qM5tod7XgvEsdGGvYUpwImQSeacM3NpWyl/K0QkBRbms9QCQZNXKkGVolfDhBsqYun784KoW4lPOIiDCHALMix4lIm4hq83WQc2EhZJ6GPJlAvOqyZ3w0ohk8bnN0sgEwPXipMbU0ONLwImOxtsQyZNkfxVHp0OvD2dnYeQvqECLax1ezzDL+Ifh6h/S26dl86drTeKo1aICBE447F+7cGof5/G3Lpf8aj64KfmWqtRJ77Nz6b7NCbfez8RrRrmmajIBapyL0GgxHSo99DtzQ1iBcu6Gwn3we0gQyfeoNrtQVQtnjDPwtrxIoi6WiNjtHsQ042qZOUqUVBwYaqEal1WTRKFNKtXwIyyhYe30rHG4ua4GlEoIm7fb+AYEMuDSwlc152EJRoOGI8wSc3DozFm1pWyMGO+fhOBoNFIGAi7/sFTFA3HuIIheoskwaWX9SK/vELbjv0JJ5zq3iOASODKQQGG5KBqeQJKRAYASCK/NrVSTbglGrkcuWvJle+9vxT44cGm6ZOwwi0cLNCmk7ynh+aD7ToxyYU/nKbiwdnK+8y2deS+ro01hNDV2NxfjrTkt/gWiPiKzJj2QCwxbJrlAFBj5+v2pU9Lmzo+WzX14QqnA3jfyebOfJ6qSGVu1GV6ZgYvTdTtRggsHTdHf5jrJUG8zCoqHAaJ2c4WyF4trJSs2GFA2o4MtmVSqrBrSpCB8qe4KLMIbZsE7JUdiWDzePsuCC+38GRFflT4kyHzd7hx7iLg29XYRXvMO869/W24ieNn/JkjAcToO+dd5lm5T/bqf1CV9OmoCPzgRs/nUUfrN8Cpz4Wt97BgcGust90gAL0njCfU9LMCArOd53bsF2KYnVPFbl+9eCtOSzbUYX04QDXCEMDMChAVOjlKnoDxCBUQhnd1hGENFQWBwuMnCgwJ4zi4V8kkKvAlJdkj59CK+yI5hiWQbm1JpELkHhPmoKO9WfOzKxk5if+Q/3XOxvZVzTVSBcLTQeNCRApgf89hU77dF3CAZgaCvpBW/bHPDo/ZWIoXvZOaZyPOqF01UAA6d9tqpTV1XYH/Nw2WriBm/1uuUtutZYPBvaTRETvsVwK/yC9NqEhX4G4I+brmJs5rca5ApNj8QG2Ypwkv67WKVuGocQZTBAjIq2iPAs4KTTbDflzPNdABegetmEoXe1myiV/3HnAvnhV3bdKpTfoKftg/oecqiSX6DGpHsO7oz26HDuMUpxMREr1EkIZxYzQcmrBIU6CSqs+gHU93qmFxa0dZrVWuFYo7bdZ6NO6wz805zNbdUTC2OjlGTz0xd73OsGiznXnJD6tmVTPdrm4fjoFj/wu9SVgMpqVUffMzawX3I4PTthVnRthLzT4IRD9YTfwm7XFUgoZ+iOuQRHQGglvSpo1h0waT26t6FDpmEV/mmzQ5gTMZ93NAwjIxvtb/8j3ILQN0rPvcwQpbLSNynmslPI9+xBrtevw+1ParrYAmeCxLP0AEukmMD6NtvjCy8RJhG7ixL73ab3tb/57UY+nJv63grGf1QMiYaaU2JuBRpI8cGrlgNDOLfHlMyqzyh6zTDFencJuh/WaOIpCqs+9Sl+1Lt1offbsvSEExDAEeDfl13oXv6L0IVv6ExLpWjpMwNZQy3Og8LDvUyUOhdycWeCPfG7alttuSWDlmu7tks3Ose5hfFWxJVAjTRgVi5Vr5hUstah+q8icJitHlBPyRObmj0uAvC2A/+yk/nJKwq/IjrfiVdGbSE7Cu7s7ohno9Md/z0RuDawbG6MYDebeiHWCyctkJS+z2J5wYQXnu3HMAH4oOnE+VELM0uJqOshq75HmPPbsABiCl4TzKww7Nl2BtOGOeZpoeSemwdUe9LscnweBpd/3JaHjJWF5LKkGVl5TmBW3jKiiCZ4DFiBQNfYpexb7D9ciB6ncNWyY0t8QwHmWJjXp7Xny3l1P/rTlynq7GYhPB7WbQqSUTNqZDhfHF0KFml8FdTr/0RH8L7Ie+psXlvFnKBIFWoDrUbH1TfqDoRWFfj4K3JGsWizy5ikksf6P9/8HOz/1Jl2sEIhoGu8FU7yherwah4p9zs0S/TMHPKE+m8VaIUKz6m7MW7A0ItCQvxvC7Ex6mCeI2t+oMWHETY+hzSIOjs76h15ReShG4ZfkAK6cugQYvbUxfSRKIqOgw0cMQtzdYUSkpKnx+Y8hDktDHexHs4y8GXHTUAmJJz6AUEXCp/jXdRBn0vD9Y2xwm7AyuKJ+R+A5fGt6/Xm/uUCcwCzwoFpAnXNPwk4LKsVIJsDzfjmk8OTtRm6Qfku/3pwH5ecQR2kIxz59I8RjZ9KEriGaRuqQdUoU7Hep3eBQzA7+QMRaNIpWyTk/Ry3vsdBcQqLGD/N8/hthaopeBFN+7qQMbX3uC+ZYBtwPevalDbPAWj0EyTqWKEVOdGsIRlEJfoXBORD79MyZGwXKoiUFb5dS5XCUZ4YW3uSzTzKQRnbusyUA+f1zSEw5tNDQn5jFIV38YFNP7eusEFDM73szkHM6F16dvchVkFG+gGKIlhKTcfXCmeSD5TyywOGstSMm3I5jxcfO3B5JpcnpRnZig0cccXRigVCp7YjFOlq6XVZ1XL+bK4rh0FcfUUD27Dntnh4ECgbBNTBVaL4WfzNotszvFL7gm04xbxDGslGg2RrgXWoI/8jB8FpU9fqx7AgwvER5qNrtAKbVshm4OyQi8OnT0Wrk8hhm+c9/RejW5/m91zNg48YdDL6b11X5uZLj4n5+dKgs8o1YiJpI+UmxvOMdGRFkHkVjj79H4ROApAOiUgQxGFmjrkNtsZJYf6Wv7w5nljyvniCqAVLUto4VfCAZZ5EavmTVuYZ4uQtZ0wCLpMT5jXMqwufcsLjVxoTmEGxHLeI7UeUbNQzMfMeSO4upxmZSjdX66dpbdLPtrdBOWIT+7mreOtPnPadSUlJice5qvvUyPTftU7cOdSmRJ9RwY3Zg10UchGO4oKUl98cqiCbyoE4Ix7o8dipA4soPreao1mRpaRBcsEyLndMczHxA0e5L58bp9Je71o2K8jOjBXwpPRYEoF+hO/h4hdGa7zWb/7VqguUr1T9GFn1LZgz9PclTr1apF5KOfEjWy+SkDx6cAN2ItQtwuxSSb6KhFNX6LXaRAs18kVqeb6cOGdWTD/uXDltvzyVWHS3K4nQdaUmyyBifPaYt+n+T+kBcPCnnFXEQ9yMg1NjIkwq9xtX+ncvLUJCVq9Gl5ELgOYMGUI4pKkkK9J3yCqZ0yRxvabNCD+Fm/rLqe6R4u1hGzB+v295RwfDG8xrhHqRB8SFJyAEt5ZAp6xd5cY5so7g56zUy+FKGopVnnW+uLKALJfGbdQT9ZqAAqCX/MAADGkLHjVg6ogIDvaA/iw0gfLWOlqrN6VvTQQ3l2smd4iboI65/yYnVrfkj+2d0EMOTeA1Zfq7tS+pap/GVdF1hkwkQDdNg2LB5Xz0FStcV3abb9pTVKNIHWUS7d4NKYYtN5EDKZi4RLTSMwIbe42oddkThpKZU9W8eP4JYF8aIlPXbE0Z/eLKoofEj/DmiG/IHktzY+nRfhDGGygq/kKrw7NPAKi7YFhQInmFa/BTxWDnl8DJlXN92vXumJMT/7FiUMIsIuKA5ZPlYya8CXIT+8w4DBMbiuEUUwm6hP4XRzBIGGU6+IaXGCi+0vmbE/pZ30ThqQIKfLlhd4BlPJR2NsetLVahh+HIALsotAuuSvFf5NSaUUUhwsrK5VSn6A1S3I9WbYfLpiFI/Cxo+qUQW9fuvgyFVj95RiQP3hf4QqTAieAEWnRDmGlFNxbhkDiuWsJKvFxg9pT23iJWQNX6ywBu5jGFjXp+IbMathRLY8+VdZxtuVwOgAt9kVlQoqobt8SoFKGT3pqzBYhD75rDPP59HftQKCxuag1oPWRT5WZhBpIcNnBG0IKxeQ6Otp79vDKGP8LHswo2aIK9byaV/vXxuOnztT3/bP0D1jdW6BFskjCVmAHpR0MDfFYNcm3PQ1a6fsFJTQDKn63lFWzFqfAn29uSngjcWb8y8sBin5nT04yn3kjcJ+b2z8ZQgB9L1gtlkpbD21URZmt665jAfaamH0N0kiG8IV4UrTBl2MFP2+t9YShAMhBFL1j9l7kDXBMeUyMx8/9dC71WvtnqNK4iIHz1SV9zUJv44EPVP6DbemKo4RCX5jvI+soYcxpMdwQYGHuirN1VR2SpRzl6HrT/HtQ1tXNFtulVGFCVQ7iOA6MwcLPlrV8dalrH5+C/I7vC42qlmPA8wwt+CAuzcfwccYpwh3bh/CQQOPZe2Txdk6iRZ0bgUsOg6Vz9Frf+1BrxXTszKY3hSY5j7Juv4vsqqjW0MUFccX1kwIwu0a9TZnYG9y3LVl1BGHQdUE9+qOr+EL05VEfIJbgH1aOqbIas4jnZNswfWbwXIoGw67qqkQ5ORjwM7aUHhedyfcFxKv2ws7KKHG6HVxRxiu3NRhh+nPOK4xhu1rV+FwrJq+U9RSDyOUgXrToKHRRQC9U8yQ12A4gH++tGqXXvnrYOC9CDONWjz9hK4rlfTs19ZLE/VPOiUv3DCQqPCD5WigXSgJ1mt1FCGzWeKioKPZ84zM3xcB3KVl7cFH9aaVGqzTTJRNzBBZ+dXkofvTJ4B0xTfTdct5bqLoBX/aUdovdS9kY6czaAOiQmBmqRKweOQTHOiRl+6y5W633lfYfH2vSQ1P0E3F2xStJnWI50/deeuFksLeeHEBu+p1Hf0HLyaftcLzDPOhF4GzP7sH6ptln4NaOqyuPQUyKAxh64RBxr94QS6cAC2Uo42RXkpehBoQiT07kYVSeO5mkoLosEvvnoFoizFs5RCK8EG7KJO99qdX+F8WgwEIvwEOPGxquI1O1CtDrqMNqKZH/i5VBo62QqGhhISKj4Mgv0R6nqN3hahHA2DbKQxSmHgcJ2r2hqMlBKo5hNnlbBXij6aWGJvynMMGH2zwSLQp4Sqagq2Y/h0Bxf+Koj5t26XbwbV6sslv04zhSdyPlVp4DtLNp5ENBgVAQVAa4yrzMRM69IrX/der0TEt2Bl+abuW8Ap/BvmLgL4rRekARGJb1y9jLXPNLSqWy4HhpR+l4+H6dET9kYLD0c4oC31kQKE7uOspaursICPwCwIAu/8T1w8KTtpNNBtsa/IfKzjj6lzLt7IOZbalmkg0eGHCJj3HiF++P0ENsd0PnqosNajOiaKxxSN0/pa4V7bbrD6+o0lUKJ2VGt/wcOyU3Tjm6OXQHS7EazcXiAUeqB1KPVPf5JfWvUzeKiAEzNEPsmzohT3SIdUhL6GXQMJPPlv5xo6O9FDh1RqnoF8ajRQWZzBBBfClVf9eT30n2BUEDi0RyFHbygDmzgxOl47UPqxw8f9IKMnMK3IN9MhPzpdEC0zA6e0nkp5Lh68SYF9WpTmrvWujoRBlADpM/EAxPyDIpN8RBX9sxATYI8lo4EAqn0XeGyZ2cs2br9+cNNaFEZKdTNrHQtfRhfuxBtKs+nHkveOLewykUsi0RUQLn4/5UM4jqLVlpc2ClQ6GREjyY88AlgiGF62TZT/CYZCkmVWPWRlqNUDIAVSF2Zj8qqWbju/Z51MVuQDe/aL1AhkQyE3z81j+5JJeaavrlZ1oFPJjkzhATmam06QMvIaLgrb1bWoyOXvE/jN7DaWCEes4rcxMLprz59HyA19CsdF/SukmSeF6Iv+igIG42hWLELb7ZbYfQuWeFN8py77INUburpUbOoFtmEHT2m8jqyWIsY5IHeDPTn0si0TNcsy/pQzozMTWW+TTGyxB7YCgp3MtkQBVbtvhOj/AUcVYXRyuQPa/O/g6THbFP4ZgOaE7cT87L6tI1qYOxUjApsg7uZ+F9udXp50f2WMXUN67zBFZNadGtjTs+/9sQBqtoCECBiSw70PKb25sN9rgFX7FMqxodi+w7TSZQS6BcHqJU/PRs76EeeHgM917O3qHL+lTF7I0ezbHlm85hFNHqHr01U1YIxAkdiR/MMlSUJ7l/o+okL15VTBFwXH5qd2bi2ZiledqzjVgUEy0Gzs+/I9nExyR82hBsU7/eH2+liqatD6fTkDaI8VhtqxX/aoMHTKjEMA04/i6SuhAWVH5mfDL2Jws7vCDCaKTphr6XTv/ycoaQztEVwYrMucoyJALgInv1DLnjSnoOAdwipF0SVUyOqyR0rcsOBSaXtIe3V+/fyYsvhoE/k+rKtqsHUIY02s/kQn4Xp5em/Wb4LuwvD5gyaqv4yumgnYHi8EVhRfnZtyiogdHKsjkcY8ctXdE3uOD/pRVgi3xqPBgOWcHC5mzrqsDrliVWUZoUALL7LzPg21yIVLjqKf6sApYE5wCm4sdfpoGk9WjlgjWoBJuhw7+I6Rl7aqEUtt0lGgJblp9gcX2eeD49Rg8perx5wqzhWP2s7gpmTMNds9+QI4VKIzhaYOslB2z90vRk2W/9Z5kEermAEj+d6tyB25Q60PJSoxE32UESQJfNNJg/Y5634r+ZU6X/4Dpk6QYBuKmTh/kfbDcMqXlAUF0ph1zUxolTKAvVTfqhTzyV5sw67/3SHsxuagSNfOzxnDcf20k0utjQhDXZoQpssAVDrweHfvTCFbFbQcvCLBUj5WCPR1pDuxM8tKJ1js5dhr1c2ZyGZpRD1RdMBCIJS+aOFJjtfYb2G/wp/k+4nUf727/54SjOKlBR4MWeSJL8BPh0H8E2/w2TkonRbwVisPJGlA/SMuGlHt91khxIRoGKX4tShzeZfW/CfdVyxEcZ4+qQfkqK6Ezs/GhEpW5tZPDqOAOW12C5CBzY075Uh8xj380eSXrpNx+yATboeqRfHNJfQt27M3HZ0nhS0uWTW16k5nx13hRFDoW+BhpuPRACs2xHkHlpbDITLvJ0UraPk+Z5ZGZBlRtLVsgLWQDStnvcqn7WEfmxFH/vC6lek3jpZ12RetIOEi3cYvLgmCN0lPPcNYtYvq+ArbcwBMzkxkwzUaxxndezdR+t64omyWLMlzi0FL/Dk5Hseop28IGSMeSaMsxVMU/cOjj4QWzuzKzuZCwuqulcVMOBnpQfuXwQE16/L0VQRWFY38DI+8tL8y2Dxo3ffRJTYO3tumHwRa25Owggcqz6qv1LqgB6p2Vm0u1KbHB+2c1huIxJ8N53/dGmAP/yBaxgUN5BwbASDsluD7BMqv+uIYAooUSCFU+NhmKQlQE/uAy4eLkgRysqQdtAHbA6/GtgVtZWrkz0RAjnkNA+rSE/aPAJtRT2I3yZUhd+XmgqQ0zc6eJbma1xiCOREOUnwishPkxAodEJiprVua1vLjxLNtgKzRJJNJOeNa0/oYMmcGFieSWiUGSIsGswlzZuFSNi7+WGzYS1Ei614W6YEeTEpo+DhvtDzHqSlWhjoAayefmk9Iji6MdXWlZCNr/CyCpbE1Tg7b4Vyx+wrgxOOSh40MYc9Da70iqmtBj1ALw/N++GgndyG30H1L8ChvKk1kLcVi6UsBqwARwiwhctlI1QkPR/QkE+Fq/XlkyXlmuO0vPSydfuYFojEns2u1mAnJgGHzwc8EAUKImkKV4HPAxZTuwMYL1GEsae4uATv3qqZCY4ccLMw6EGzrvlFjE+4ZtPXbh5cQZL/oS5zcLbL0zvQWJVfGQvcQ9I3ErHhP8766V9umQrEZt3EdhkKtozDLtro2hwwi4sywcU2yOpLciMnT0kdp036oJ2eiHT79cidAHmg8bMiPPtzmheHOyPhNcGJBh8eBJvfX1+ur79cQcZNPyHtIxr6PyhxxbOirCSsmULL3hWc/qNnRLSUZRdmupM3HB8W9GA15xNrWbAO59Nq7s4ccjekthBJrynvUQ12b/cMB8Y91sN/93WQ7h35uNmdyDxjAOExCjsgpX8/dFtqdRgI73yNjyDrKgNKbDsGx8m1wVze4cXjOkKrMSR73KywDI77CxuicT4HMW9jmd1ejaBd9CD82QrMwz4bt3vh32yEI7Lvj6QKaC/fGTf49Zq3L9O6j+38ySGK3K6X/wdiELWtN8QoNYU9jcGpNjqAE5ySH+f52jx8Y8rnQjZxVWsuYcJzMUK0+2un17xRzj2BKyQylw4Vfvv+QGPhzwwWg80w+YGjib9jXvvPtVO380Jqn1P4w5NBuuAdrh4mWl2bp+JTmBvyNmgBKzhiur24dcYVomYwnvoxs0usa6Sfm6BKKOTHPhYZ6/ZDha/bJh0kFyVRwyJUG1sAN6mcsYfldKLhJoL9dAnB8DF8jygtDhL87VjIFCJ+kd4kkJNCHwHlsPAqa4hG3Nlmm7ADhaptWbO/PpPZADrikLXBiu0+kJjIgMHv7BVYpOf6/snZzRP1lOyE0DqMAzdeDsvKpdn6oQgyZvw2sLMzZAG9hhMy4Koqr+sRxk1L7CfARzFq7Vx9UfA+ys0HiJhODyw8jFru37oFEuWyowDEB7Zt/CbjJII3JTgztzvjKJrPEIONnNOVHDaqm2+7AIQTaYo8txheG0tOlJrWGxc2xxosG2U+zDCCAS7olGePkj+HbcW/oZs4MfHYVmgYKu98GfXbSgjtZH4ENgcpHn0J6ugUvwxA/OuQ4jeaV0nqNFIYruhybU5AqOl2PYrnruUhs7uKVz6TZUuyyqf/KAhUI5X+ZWNNZNYXksZB0+A7ip9aByLZxDtvAa+fUjmL+msVDpKBkdsDHPQ8vVEp27+27zUvXTkfLDx/m8QJYIO9QtJ4TK+Q2pRjpjQ3V5WpJUufwto4V0wcLIYDv9QLGJlSfRbDlnOrXm5j8mmE+jjQEQH1DT2N2Ax6EJSDAJl7VgcDqYA05fOQHlIW6Byzi+MHe6jbiKTNBB7d2Tj2ubUbRQksbZH0RrDNbn42u6nAnFPH3x5RGd5D9SF6W8gB1fQS0RRo5ntQ2CYGYVDgXJg7lv5Eyj56heIDi5CAzNfBlstJm2k4RAfYAm41ZKbshlT/S/NT4oLWSz2Jh406H344shSazRZ0wY5oJLVENTRp1IpoANIwsjCd+7a8EFQ1nyIXnD6qBPv5sgqxCMVZTM628kBdK3gtVBpYL5H6HT6peDWpMUqxldqDfifu1oOfpZmsMTh9g6Ecnk5dSSoQoKwXnH+OxyVGYQW+zG0nNTV/1ny8L1HQCsDaS5I2eL4rERPZ204wTpK+nxt5aGTfiRoqhqoiPyaraAgoEEF8O1HpokC7qnP3q5FxjwCC6Qx7x3YnD9XRnZNipuoQlSIf7p4tc1nCgZ1eaSgJTQ1OvqlWsNuoRK9MxyNq847s9ZgZSzDOt34c4O1pamupEalcqo02ZA5vCvivyuPjZws91DR0bdt1c5caJOdT0WLRDOl/Y1x0jj38EXWPmtwp/KNA7cguJFFpeQhF0E4Tv+j/d6TxpTmxmGA6fKTHM9Q0XkKJ/VZUW3IyNh31jOGJUT6N4a/Fi9A9wtPHvDDVyJe1wkUDoTrLiDsX0/LdOG9ijXYtvUNakS/KBS94gsG/ZDob0QRdwUzEclJdMfabs0hH+WoI/gu+e9wL/JWGChpPYD0Hhq3QOBxjcVJ+en8RClKuV2OhHZUj56COkfSVhJZw9RK71SL8H8Af5D1cw8Ro2rRTO8/hk5XVTg1RIh2YH/zS2TlsApleha/YCa696ZNgXrLN5CrchbsgCwn6Hpizw//RvvFdf5kfS1PPmn5xsTvGyZNdxw07w3rVANC76LYVmLkJ6rVJ35JYDTyfm1ZEIRc6OgpunkKBeSirGCKn1b2p2+jW8iHi7ax+mrvh74BCoALH0ArTHEVxKLPjK0Nq9BnvDyvkImnysRkSRv3byZpKLJgEjuUI0ZO6X/aHCplMRa3KDaGbo06PDkuL1LWBD9boZAHPXaHdDX0sHK1uyxa8LZR5XfIWiyVW7u7oTCCkfGWJwK7dxdd6x5MempTZm4eL33ZYvJqedl3sPbdWBbHik+JsN0lIXyHGvP/tWrHULmRkXuVnoT2ljb6ZOYaxhfJBTAgTxJl4IBK0fGDmV42sRhTbSbwO7kCKUXuVGthj4sZ2OKxnbzMLWWdD6birbB+hlSsQlDc9JoeaT46IlmSg1afRmm77AdigCg664aom0+TwNgjVsXxMerpUORc2TekkH6acX85pRACXK+Ni3hZr0uhv5/29X8NbHr554mX7QUhvOT/IJAA9BLSeuBa6WlI+9pV6e4s0Dd4r+qOcGgsW+Nv8WqBjcjr3VbuZZgXt7TO9PqyLh5N989bHYv6I8PSudss/C3C25YpfmIEBJ6G4ipKYKaor874hqAhJ9P66pe///xNJYjThzkyq6602z8xNwzEox8ew+xie0l7qBs5wMcr3aVplTNE2xZ95ZSiuKeS6zxFuY3KxReTD/tcuP4hLpWhOfdgIFpl+xXBVAzmmCXt0+XH7u750XNEt2T+fbQW+imZ2ZCZzkt80xCxgZKxQ5HOVUW+WW5FSV5DJvTycIXjM/9LLQciXGawbp2Q3eCLFZVE6WEcmV0RNb1u7jcUyTDRFbaPLkOrBBZOJctFOTYH927Fp8yg3oXZuEvtm8Fkoyc3tGOv/awt836MFOZh7Q3XlhRtUCad/sWKE3TDquaIUsxsSU3t2Vv8iNJlpj8oQlFY60yc6GWdR9o0mnTopHyfPH1LqRYQaAYLV2LkJ5i6WkIShUvBBc7a/Zo86BegsK5t0HEgoWF3cSi9vtkv6wrMC2x5AT8ucXyWBxQZcPvCLWoetYTV1/mP+ikLtoTvNEvMy/bMWpTssL1lnMP/ryoxx34Es7tcbvit2o4eUDgJbi3jja94rYx3BtmMjGn40EBVu4SejJIpZZla/ngQXpKyuLzgF5bhcwNczXyJfXSFUHLgUhEUfLmtFL5F+M5smFqg59ia06tcvJimOwq5FTHMLLSn+Zl8Cl2LWzgk9rypASFKoWEW2JlDG0G3vAWmUnNsTzW6DKFRnDq5/hpx7IHMgxd+I5qwBtppibPtNj2rZsGIzFwHekpvdHkuzXZ9ZEp7ONCzZT5fgKtN2rSzpsaSKvDHamNk0ou5spKokFlTe3cYbpGBBTsrZCLXGBI53EVLNQ+0XJvFQ6qvi7cAWsFc14qRJlw6Wh4oyS8nXGhi0RuCVUaytIHM9Rq2QLEjxigUTs5TBcauKfGYbY8L1QfjL3hP/gELUl5dm7BgnMD0SWTQYdHP8qNkA3tfQxvLtaxvdoVha/EzHVILlD3DFSd3i+Uop39q+mXBZdVh3NhnO+CnTEYu12Tb+8Ey7noqDRWRruhgmnCBOIhp9f7tTf5PP/AZdg0BBOH94iP9BgerYc7gUX93rYG4Cg34aYkQhIxRHdggJlBWUC/5/ymjOsA9kEYYBARvMj7Hb/rL/QdBmHs5eR+/M62tVAQRNzyDwpGB/KUyiFuMhJhhLDG6gs9PKdbzb+yp+ZvsAl5qIc5VEpWy9H0tY1tpDm/fOCLI25XVfBtR42Yue1cwleVWbgf1bWODUyuN2d4a04c4K1t7fApUxO2ElYASzGHZZ35KmIMRr5z1lKYdBsdDmfwh/ILHiXTwEyO7VVRGBtF0uinPGsVwY2/0/C/joxFrja/hvI/FU25luqUsDzjnJH2/6fxRyVZAofNO7x+6DDfgw1+6TXQHY5Xes+SS/q92RXc7NgWQLr3FK3Ej3nDCgj1XMwUWbiRUOeVYfwiOUPjd07G7V4bJ6AmGUMCSkWk3tbI9AdEyvKUF5Kj4UEIq01hdnN9cUckqAfGKceaZ/yBSXgmODTawscGigu8x47mO98+LGXVp9AP6F21YXdXgp7MFX+ItrpTQb7SP9aDfR2aS1uYnlMLXX347XNd2wgXwBRzf9TmCya0H3cRURcM/le8ayQUWTZDJuhr/gsubozrFpY3mQ7uW/HWndsqSGN71+X7AjAq4mttUmwgeVgfzz3L6rupndjgPQV7I/oVajJaUPliglHuCf+9/foWgSjLqZmZ99k9qxrhfjqvR3h1deQ57RbwyacF4yUqp9DeGKwXIWwNrH5abI3Zd6vdAy5xovjnGo9ilgKxrgQUVYREwYVOCkhEEyqcuKrXT6BoALCHf18iYopzXLQIA246f+Nfmm3YwGe+uRY4pod1wKN0BgED0Ebt09ZPCgPDaz6EBF7BeBVNIkXUMYShX051ZlD+eqbhSZjaD4I49lSBKaWQt4aL21ePjpIlt61YTNvAkRiSuCRzjNw/kUV6yA2ZaAbmbNmw1sWMld/e4u2MkC3Oa0/8N71TRKikDQmvwTfzpua+WNm1WWPtxi0uVu1uWHD5oeR1k0M6EZ1pfKoCfFWjddt+pEHBdv6J2U93J5fNWGBnKbKBnpnWHeNMVrGrmJnQ81gcD0MKYHMYxcuN20RaqyuFkA5Xwc/mUHhvXVSjXbd75H5ZCQ4BMQb9zGOuWY2i8CmyRrOh0FqEpwcZmYyMHahHkLsrE8K2JMVmEj8flH4RbWsVMCkhNFyNxJhAQz1RA4+Arche8MrRS8k4WQzGv9jYlo+hMFKYFgWrhvfQNIq2QzCpdymhiJca+Uj4nxp9YRl3/D8nCt0msG3EoU82xplW1AKiO03eEOuU/APR5+wvEbDZ3ijc7z0dGsGn4jTrZllYVe5s8201NCdjHIAPp2/1ftVyT8xW4OKOoGXYFWKkIbcTv3ewbiuUffmlqcXUDAiL5blKrAZ/7KLX9hwZJrRRWSCb+hvOCPRaldgb9aD/7KO0B8T19+Rz8xx+cqKj8SLbSYFVFEjKp0DPmPK8XxqszchRRgERcV89quXNMhmmifhELPv6ZqS4llHsR4lD9Awz48tEJWGKtYH8Ku44VPp+n4SKTkNh+CtYGc0y0+15BHUsQVCeUo9H3F4xfFucJERIrr7u2/DK+7FQfluv7fIGu56H7Rpz6gi2xQnAcg9H4dTmxqubNEHrJv81CoEXiFNnpiRGaLpC6+MvL0oqdDF/WfL4g9jsE9aKaXdRQM4IoNXn7jcYqXfA1/w2IIT57cK0MtccbkaIKa1dRSTQClcZAVhviDW50zimFTL9C79RN3UobS52g9x+lu81OOydJ5xktMFjoo+HGySJECqJhIVtpA2nIblg6WLFL050ByGgopagp/3uefJqYnrzsvaaj/gMbt5aeEl1Uswh9y7rY2tZKtZUc7kwikj28FZZOls5e4Amz6OmgKAfwyCjsxK4jbDJrZMuQ5osE95G4vCKG62UVHNpT7p6HljArF4wTsNSPyLHby1XBQqlnXwS+deWVs88t9lSQeW1z+fOhT110+DoscEc4gdA0C8cFLa6SSjJ29VBpXjazSag9RWU7rgIa4utObLgQReZxmkckGUvDbpqso0SheCgxsF7aK1UJ72XchDMEbXlTBz/pNUgmE8hlqvbkfBSSCnnrPbDNk294g1J4Cdgd8lBe06GdPHxHd4ZgiJIiLqu2cZ0YMFNRcUb5Bvh3Bz8v3o2eX3pSymou9v0bsOX0NQva7AKP6WcM+XaFkgEwALNCxWCxopKFn1U1V7Pl8+LzqztY1IKG4gAhr9WA6npk1dgosxlwdoqa/fjkGyqFNP/xy2WrmzHrGSEZKZo5FzvUvfiFfOcjKRf0KOyu7fIwUiArhhtszHai5jUG3jArJD5fvE50Tz8dTvFWaHDJQReWQOTpP4peTJcWcTI+hTqZvE/n0NViqu/0DAS/9LVYtc2iRUQCtjAHdAU6Lw+Ul9tQP9OErJQc/N+ydljEYVdiw/eWYeB+P4gRMLBY0Qsm8EtEee7zJD/lpOPVGUK1HOq8SHv5UK/h+TjWeCItmwumDkmv2skjflrfQSDTbmSUk7C7C763hl677OQWaN+2W55VR3YFUJkf7CuH+f+dyfHbpfLNKBA8ZaCKmZGfWxxVqar3Y5snFyzsfdlRG3IHOg69tcwG1ouNx5G2pxgRXc7/ve+eumkmkayhk9j7l5SiJph3aAdXPPGdcNQqn7M7Ww2M+GKiAQZLDt69aPRfiCcYqRn8EsskhQkQ0qOlauC+7Y5+0qJAWLt/xBYfG7BQg94A9D1dwj6AyF3yQjCzWup/JuC6XeZYT/Y30dR3Wq192tNd4mruuWRWyY5eh2SHvL8mcca/DoNXEwtao30uW6ohZsv59zbSklSz3FoQ3TKIn2fapkpHoe3NYsw8eRijwwaWIfuOaHN85eWqgf40bRYOKn/gfgEWrS73p4dhYgmwZYXWkr4v5H/W2JUlIThOe4OGmxUG3id6QAC59ksFzEO29jyKA0Gm+l9qzSJQ8H/nt50wwD9cpJjnVTltDSDrOFaPGmkY82fDNOO8LyscaLn4646ZErdvgFnJVxMzCrWnGWg+hFhPFY81Gza4iVvEwqa7frOM5nBBoIDHqqKAoXYXmnmoj06x67m21ilzOcYmzt5+95mzokjF1hoc0SWeIx4zG/m0ImFEwFZQFf7vQ3P9fhKYw92+pFyHVk7TFgQ0iRPMkIz83qVjXvh4jF+craJxFk1KMGSx4x2Erby/c+VY1WIZXPaeCT89cwuY3dBKV4atSIE9EHtf/coMuvugRvgFvlm1ApLl7grXf9IHuIXeRZdbHf/c8G67TjxFST7BdDYpFBdw2xO9uJSaG+uIN+1xV7mZUh73wt0AzFKlSk9iNyVpQoxMZYAWJlsxYWPZiciCNu2VAKfz4qlK/yjCB/RKMPZgmzUPqSjP85w5inlQvpPLqAiap8+/2nEhJaWCEsLGaXFk4se+Vf+fjxHvOnEd/uLkahHjvB2oOc4MzZBDrYBFe2kvoyIHhOscWHAk5ppQczLu9moZkrr/eXHMoC6aDTVDQ7QA9or8/4S9lSrbIG0rkWhMiN0zHiuM9ULuXhU77lIe9JDv5U1jdglArcLVet7Mu2SAVV3SjyeQ+stuvSY9MYSzPW3tdGB83S+Rq18c1rPaFx0OXSs48H7MZyQ+ZJz1HbyUax+fTjzAndCgXj5BFWp4aURr8eVRDGh/aJN2eINepq6T0FxzM+r3o3rZo6jB+5Pno9/E55Ek/RBIT945UR533Yj7ifalyVNNyuEqqDSyVnsQVmkVgGikDpZn5Nrrur9PZehelgiHHJOiNsff5H1koZ0t8ZKe8eFQrKsPgVo6IVbLZshnCF3k+F0a27NyAvfmKqm8+WSw6Xz1SwUwVRBecAvJ+CQe4OfjtjxGw4LAKoWBp4wALbbwW6+/+6ErmNvDk9/K34ot05sLT0TmURPr6xzJpHPKJCWeJYmzdv6+Ylpc/cbDydk9ihUQottQ/RHCPDdcAdlN3K4r9e6kwAzmul8dojbDwHgzZDKBQdu8RWJhuUL2L9Gap7OS0Afp09+r8sLc/Fo2rHBzumUQS68Sn7WdkBUVl7FohsNK73PeXWWsy3HdNoEtYq6VtEBWFxxNpnKo+ZuRulxGWCbCbHkcEigF7apBC9glcNCVTZ0ALp1yKlatIafVKpvwtYqjngl0xsifWqv6ZPVfEJMRz2yUJKyP0V4aPCQjhffqz/VRa0dZTxtWvuhGqLOF/SvWHRxbB1GlrVkTH9iRx00y5RlFpFkiOG+7B40170ZiWvmqnEPAYdBnf3CEGkyS6Z9S3mIfrf6nMiaR4MG5oMKYK85H7gbBUzXad0K37AfT9nTisvozBB2UD1XMHlQiMlK9BmnhsoyyMYnqoCPDyRwxdDZhdS886OaOJecYBLNC80amddgFbxVNwpD/sm8PyFewZ5dYa7wkzFOn+8HTXNtpitK3nxjVMBmxXMp/c6okAEEjnU3lAd1cLndd8QQ4wB6Z1a9JslJ/wgWBksfY1MVyRNAq5fixGUvEs0hk0/b7l7+y6OHVgByYzlHIWfx407u65c0nVs45ak4VpSEkaZG556xGfNHaJoxVTq6DsnsVqg6ltL3GjZdBhhIaI5J0KfICUpS77GvNk/N/yD40gMyJZT3x3P7SEBYirjDYHE8q1jPajqNfX8iG6ag1ZGHJCA2gQdxg+e981cp4dbVDBHVTK5RmnAfz0RgXZm/Oxd6cwDlKWq7rcrGWGiM4yZwz9swKA6GNk5XWSVDgeAIvoLOc9kyscxqs0yfj5Oc3PD1BpQhnw4OsnRbVl7zkMrNH7l/lzPvBWdzjW8nK74eczDi2I3MwL4UT+3HywXlx16srw6sWGLn1kXyB0Fu+hG/vMfWbSJMSufvLjOwnqx3Npkfu7Afl3OMWqkyDDm8z6BpsoG/+hpMcKuVys6A8U/IsHhXKB0t6u3X889Mi5XZ0rVPIv+cCfrx2Zjxp+ssaNAsS9N7D0g7s/G57g6MVDWzo+fyOTlOxsxOyejl52xIPK8861DtJTVLCOgtZegmfx3XR4UmuSmo7hc5cbnWdaMYYSnL80/NKytAQ60ZVsD4jlTk5LAsGtajnjwP2GY/ez5qycN+km423MgFbXqGPT7fZCxx9ujIXkHxTl2Mwq+K9w3tGCkbt9z63QY5vCrDbJfVB57ljhaxkHWhW6bu115B9gs7+BWPFAM4vmP/iiPUCfgESYdvlZYjMJpTqqAagVurVcupQpeuQ1XIE99BQVKCIBYx0t2D8SU+1U7JXKHRDL/rvytI7KJ50JNZRvBpAHOEmYQd3i5YzSW9dUIEisMFI9FNEMsViV0oHknpv8SbXVTVzpBpWMrFg98VjSX+8dhJ+yfYt1a1VNhxOSYEWY8bUdvqkfeoHhVlTLhB0QcC/Mw4eylXM09XAwJivZVOmYP7A9nv2br/Q+5KXMvSWKVBECCMGhmVoRb3quAB8H1MQQfW//q1tmlAEtPRRthPkGqyFIEtoE8wRrNmVoArfwbzgK73Cf2Vhej2gLpJK0la7TXtLMAhU9qrQL2/fn+/sZ6JkkAkfGGY3vkw6PhMmJ+GIvam3X1nRFuwBVN5RzHkeJ+GMGrjNhRoIiYks5fZ0UrE5O8i5/pCPp267e7VKOzqwvqTdVZnKPJAkWheaKVoMaQZ8RpvfHZIZix/3ORqxYwlPYAMsRCX8SurZY+OaBYw7LaGoHqkx+QaBXf35zuoZzTf44hh2Y+Nxab7jwkDhaWrFEh5q1dSEyAHyuLU4PW7JXLo2dz+RzmvlxDqyiFpHlt9WedBj/1wq2tQSRoENSC4Vfgt0yPN4h+3trIviI1xr7yzCfRKRwGe3l/KAaMR5tFADSodoa3UXlWMuRc4XSe3KvRgt/pIBiaixikkVo6SHxokcot6ynilINqvz3LAORBke+j89jby0ReGFALRGaKElgsHEMKtgeFyUzHhhvIuZIT2bljumg4RK3NNaqCi+4pZ0pFAzAOFUkEGRcQAd9n+VLgkrV6N1vU1CDYJVXnBWwd/GUNXPgmaJ1aimTg4GP8bXHdY3FHNqnhzmslCJ0br6qEPS86z19s6tlMU4gd91iGshkcQq2ONNsaMR+sfG1cFNA0FTHHZ6LquwWKIsUh4lL88Drutxr7y2z81au6mryuga/39jA8zkp9mHc6DvDlOuhhuSDcUxKYzHFyzeKcmVgWWJ6C93yzRnYouObQhhx26Ai1CvsGboLWFGQgqBCaqRmrvfSmUSNO5eQ5hP8VRJJdufCDJdXR4bV/aIMtrrb0tDb0ZcNn9mWtF8p6w7JvFWp0Wy2K0ounzWTPnv26clbnEmeJj6Wb9NXCyet40b0PtDqJxlI29trCLlCFJSkfTVn1oftMIWo7M7/A+pWyKjw3IwbGtuYvAcdD6ZJ8fwC9vESK6ya5v1/hXcurwR+6vpT52uELe/c/mrxN9IBmEtynX+ooMcML8ag84HDgvkJDb1j/ozSptl+6wdkWSvMdyMZ7+AFMpG5Gg8cs4nLk2tRpEhRexlhU7HDlG/4htaestDbXMtEEnfReoqri9wT2g0fJX+6IHZ9pgsLZRsPgBW4tx1RGuMj7J7Yj8H6pxbxF90fSqhhcaPUwSQCS+H+punBnWLw5WonOJDbJTNgVFBnRosTXRlK1UDKN9pPqwfMECVuVuANDDbHR0T737bRAbY/UBVXTEk/BFkcfreauhrTJSUBXdSVE0xZIn0e+qEPVqLDSr25b5FGDQLh5/LuWeQx4E7p6IsvXnbnPT65sMmx8EFXDFi3wfk+8mgWw5YX1D0O1+j6NmypHrL1hZ16p/8dvlOWNNPqmBjeYbfzo9ouRVMDeT24FzZljDs/4FZJVohar9ztwKNckF/9/F8tbRStyg0ZPchkeff4Tgid/jN3BK4TETkfo/uwSibtD1iZEHpzt4QTA7vmdrtxLxxQAjisCs4FayQ8oScaJ3ZzeC5xGSpEGN4gCcEM4XS1eWdpUSjSE4xe4awYVYUpgbC/77tnwQNaqI081FAgkYM69YMAsI2D5ZnMl2pgV+ifxx38JtQLIjGxQXiQBJl8qZtMpTk+foOaPnMky3TRBjqxrvEPT/wsc4S2koXihV1DkyoUeH29u19Dip5BU46UjipM7wrBgze+wpCKzwCVKN95hy1Rg39qotoQg0RSwMCBmyd8b6Cio7t8oCKdECzCknyqHN4beQN6Cnm0b/NU8qM2aWNODQJyCXKvfdAXVGqyJUF1qVGZpyKK5RXaiapjliarKKGrZJKhKdJOtto1dIF/6QU36n3ALGAtlzL5IjjPeowiXamVwMndM7NfdZa2/t6klO6QS1Hk8GFnNc2YPkUOZIcyvYa9U6CRRdPECvvDVRVWO/LQ4LHci8YUp++4oQVLSsPiCJPXF1lbqJKZtnl8m3A40SpUZEKrr93RTjUppCGN3PdA/LYFgzvdcIUXldiw3uHxgAZ1agrxGacWcmYYWVwYhofzZJhEBRHVZdFAYB++eCkptgk6dtpwCQO/q5TIzDP//UPdWX2f5U8jgYtNQ8i+/0EwN6TkPI4gQxgxTc5PRv6euErcppHs8cwj2RjWZYnaCzQAZCJu/7cKNyegwnXRUKgZPRZomghCHJ7RDN3mdd3JYkcFAeHRYqOCcviEZz00VlC7jZbQLr6LyLWFCK9lBQdjN7KLwsB/BHQ+mdAnemf0cdNmdn6pCSQyUwL473w8fJaz/twfP/C6NWEwDO9g6IEt1oQ7ETc0QciP7B7ffI71ISKwaM0qjD7n9KgLx4z8ySbW7kKhxA00huSiRBTCMPPUDAx1yvjV4aV7mXccFb5eYgJwcGUpfMOnOdPQq/mULWgA32WZ6IfejZdADcwGDoEEKSBBHwvD9GJ5ZJfh/8G8HCEkJQtu8n4cP131esK7/9YpNA+sZGjqCS/qvd4Geer6nn5PTNvIRp4vAARJfaxAx81U8i78LXIqWWNWEpQc7VuOgIBfjvW0wz3MCK1P50cBfLbzNG81weaY1WrcKDl9xvLQWpYfByXbSE/9qXDK7CDZiLG0dkl9sexgnZu9VJaAp5vP82MVJ1tuWKwOmqbhHHksvFwlEfdJcPrIAKAtscd7UUcls5RgJ8Ctjlq0qj5qtk1bkWWX+dcb/wx36N48qNvQPdpnVn8H3dGJFY3MCMgD+YAzoiVDmabzcsQsKUtZxZ0cyccUcskV9KlKF9Xy991DflrJjNqlL4SEYWNoi/3SuW/2rqrHJz90d8wsraN84dQBVKjdUNRjSPOTlTv4Tf8K2Q74+1x5rVUL8BDdqTb6OyPeLAcpBN1TIOr0f5zCwBuSmTYOcK08PRKTfXUXTpCJgZbA7y+lhrutNcDysdicdoOdbL71dkiGgXVmbCg8HdVoCr3/ugZ++NNqO20e+lDc20VtDXav3r0rij38clV5nyJNmhvX9D2bP3/DaQrDbLGEOYipLqsbMBYtD5ynN3hu9tXtfmIIo7nOKIYJdPCm75y85dZ9URN/OjZcE0PebD+Zy3Kqzo1M4MZmyQsXCSR7eFQSHDB2EvmNNMcrXcsnYChBwRSiHFkTFIjldO54P7f6wEt+95NKWTkQJSgGe7mtdO+cq7byLczlx572lX1NI1iWLWUhafoVN9UN5J9iAUDqGJWCmFFgtdJKhjYQe3AkLYh2fmiPHfTklIbn9MxEknuDKNH54f8fpSL97iLE9FnUJx96qslXWEg9jYo9jkXsOKxmPXXArxj3Fbf/CZ1XLqjHMMt9128oWiQRUCLG99SWHkJALWzbp2DA6I42cb1pIGHzcFQrIbSG03ySEJ4x6NX6kAPkUkMpIx/w/zyjYCoPDGcsPFAIgDAZepYAPs3sQ+5Fjy4V6c5Qkoy5ZSj0CwIoO2IyQg4j+z8A/zKtSTc91uOZCgSl0YDJji5WJj4m+ZPaq4ajscM9cK8N4SfDRDnUDuX2gWdcWfTUmb9zAM59ANE1YVb1GjcgF+1CSggYEjSJY5ueUIzc95RuFwrlgagI9U13zsGEIjUmvzDvLM4YIg4aFyA+Y8xbumKA4QMyxpb4PB/go5Q/0eXR3RzEzeLAe7IHcMrBVhcJHyS2p/k6D9fqHQzHZBCjam0xmTNM9NmJeFeEVl4G0JIsZP6k79l0awJc620TgG1AK0m7MH+qDj0dhsWs2kjBP/5hArLDyfck+TZnJUnqhR69NXXHMq5Pa/rsaCfVnUbhxdg6SIFbqEV2KdVLpRYkHaxPdsGJKNyHaQ5CjqLJdzAwElcWdD8lXTjghlxN3wlCG2AMx9WXzo2SBfqiaHJcwDb1YoGK8aLEOcIICa/MBhSvtAA//z42fApugDo4cuZ3qNS1w/R3Ionxm/xrrlwyFLb6f78Zu996QQdzJ9ExFDAPmg4z17MAkRQNerE+W3jXTcXDScW9maBKzAfS2IpnNEzfen3QwxmDYSISwSujahmrLL+odVe0VSX1Y+upNLx6XNlpUfaEbRLMJnMSEtdyqTWwn+v1Hc7mNV0qWacprsdYcgIMil95krSo75qt9rF3a6r1Aq7oMqF1GRrwq108U83T+2iWGKrXCkGwiGbM5ka/6vZXpFH19MOaMbIQQYzsdmH3SJ8yQg1XUo55YwNT3ddUJlvG/Gl3MVyjiK54XIwp5QR7Dogvynh7lAfaNW8rzlB75LBGcXPpqwB3TgQrytrK6VCcC5oifboWpFLvnMpl0k7Ld0pd2WAcK6xI+er0k0gFRvNdmSJbm9cGDKSz4aM/FV8NGjJEIMJcWqiHRtVJtPL9fUFecvf4LHqtiPn8MJqX7S0FLumj5kifhfzTTh5SJR8s0pz4VOtkU71v28wfyWSfvn7urZrnvQ9SgN2689jVdwjg+GqaDNc+XVsCPgVZRLNJuVQea0KMfsnp6nLcEvmaM4SUuFafHnMMi3fDXcJwOWxc8BzfWfrAh3spYZEJWsggs5KUDAsw/lF4IXF10Hc3ynSqy1jsPbYS6Cupp7qsJ8+9guJHsZXCZeQUjnLhp/g+iHYrsq7/va2ds3mopenkWJ5degkP/4u+du3Fc+qSgKL68hrjnG3ukUAH9lOcfKo/9qDCetgSjS1WO8bKd+yMVWe51Iows+WMYE723WN3OCbtMdrCx2M1MUoESquQ62shc/o9c8oxJw0IwvGSEi0zMUJV3MFX5sTAH0dGtJS+gC6r+8WjNK3X94w6k7zINuYsywsvI70JqlMoyeDJSh4J4eHz1J5bmLBQ8PKEaGYlJ7ggKyiYW/k7IRfS6rDjSWJ/nqX3aa6iIJs8+MLdzwbsxnqkA81ztk7SDCU6wRKTtrjxeqre9J2sPcH/V+i4IIytARN8XDFSgMkGkcC7vm35GRgksgvy54+p0S49J6g4QoowQs/d32KGqxvXGWSdHQSqB1JFbFja5u6RCkGq++6CcOjjz0p3xSvX1ZfJciZCuj7llntRwJ4laWQUuDkXEj9YAt4i7SrGX/DeErcZT9feeo3A0knpiIVvI+AlR7XwaKGjybQkKbo7wCK28CUC/x+9kBC6a4Y9LMGZjrfCZBzq/xzhybmrZWw/GKBfQOKdroREMvAHSAbLmDwct9FO6BlfFKg2Sc1j23r+akpgcfa15rE7pivqwM3sTy//BcQ2qG9/hq1lM9CjZz/bZJCOk1SaIT4g5yDcDXSgkgONI9xPBgE/T17V3+QltlbvxRAo5VEmbuvydWS9Ds5pBMsxZe6vKvwgLYlzEBorVV+4Wf6I5doEfMg3WD+NtC2aPJaotWo+uBMgtHmXaJyn/tgGWoHkTltBpD6T5J5G76lVUn6tV/i5e0YDxd8RoBU5bwVAqe4wKR2Uy8jfL76vbHxX1K6kM9hxBj/I6CPwycCxAJG+uIsSIohpf2qBRTg35JgSJr0vLrVIVoBliyZmwoXNbP5LenBZZhDlAJIXEBQqj1QxtKyNq2+OR4W5NyenTdcTd5RjT2pcRobH5QbdhUKS8Pww8XVqap7X812QQQcEsXH0qrr+GQwm0MGqtpDera4AaEVjmwJwWPHttpDXlAXxbVEB0Ng4Ip3D8QznUQB+bTsPyU+E4mGtNitDF+BgbzmXlhTODMrh8lINl+4DdZZ3pjoZadiL5flHARC9JMFfsgOML5A62a5eNVVjJO53tmz9iDBvK60YKbdNM075qajeBHFFT/F/vJ5S71cUI0S3rHO8R0jdNZLBxeALoQAT+4143LRfN2w22Gkg1yIrobItoeS+NVRSwjC8R6elWx3OjKW9Bd+fDYyMvtvnGqSR0NHwykzaJN8jT9Ndijh+fspqS1Hguf/jx1XqH4ZyXmDxRMrSjKpkF5N2xsnt/hSMiz+0okD/Xpi8rGI0OuS0LaECsCjVzCf5EkRpDkU+SM3h5bVPGLetLGY5Ca4tEy45X7/ayD03XXIWt7BjNvBRANsf6D4DigUWOZJz0hvp55CkP9ndry64ZOgeITPSuijnyeIImEmA3kVFJRaFTPiD2EQqRvsz1VzcK5BkYP9g5LO8zh8OzsvApZOnRmEX3VlOk0R2MWtSM8uAcvtPFARnVzrtRxzN62uwylo3Q7l2rVw1fwUT08y+zEcUQXAnz+K69nUNF9riJJKtYxhzxaEUpqp46pflWTM4+dVdgmMXfJlUYyv2RJqlXzxjyw2QGKzxg8mDOQ5G3JYynHQieMsl+ec2QYhALwY+3H08I9tt74B4faxbRrRy/3Y+u7ArK3fIzTRoBESw7a0InFpEplXrJpNtlinXKD2WU4NdI04NQ7bD8ZQs1Tvne0fHYZ5sFjhhKj9aF4kQWvbdviPR2k0ziOaCgMRI0m/A5psBPOOFI4RB3/iLUt8e97RquXFHiylJmcmV3SSf6UMQYrpR0jIAD4gNbRJ+xkK8SLnEU8AfB1cPggz+22Oxn2o9bV0DdsnB/2S1h1i92DiGPkB/Xcd3REvax1n1N8lgG/Nh2LSJg7rtem5BMjTfP9y6bRCerdoF8zBkePcovjCl3OTSzf7kptETg+KXiSy5DTNFCvblVBS6cNR/pf1wIeqFIUQGrNcjcNfxUmivAYbYLfPdWl9JhprEX4tARecsjmJkDIKN6kiWdDegYl9L3QJJDxYEcFOm2Htw1TpWDYVVNBhVU+961tcChNQoVMFzKSqp9IuYYSHGhk/df0Z+ikE5fwok4ksu0kHPVrtwi5lanyTpKOriiiZok/wmeMestr96WCnV5S/xCaISPM2IDFeKMJqFYQb+f2Cq6kWbGl7+3WzcRzlJ9XRIW1fVxX1AkFMMYC1qr3x3+K2pp0ugbeevx+iXXWZyY8TEhmx3G+xtJJT4CC31LjpnMGXFPU+aoE77QX4PDblBapNurdPFqukH/uTIrLV0kfmDQ26SrrMuxfwiRracCBBD8KW4IkpDy4Gk75v/5Hb+S8dLtNNXXCIdzTmwpGamM60W48WvFnDyGZNKQDl2Vt8pBmRfs/RCo+uiEPJ0yJUBGSNT+d6O7jal0+vD6KCNxwL/ILKO2M8cEdVesZ62dS40J3w9cL7j1P4AGVmplH500Z88u+6CiAA8CNhGz+w+WezUKLnhyINq93NDQ3Ei3BBzSAzQLiL0hdMNB35pBq4s+ySudx+suDlkFVW7KiNbGZe+pa7eTlqWBFtwtmwpmqNb5ea1BWguZek8HFyjs8PEbtz0pXSfEdqEMo3j7A1OXt240cZzKlOz7waI2XmDnJByp5CPCkN3Ok7ga8140EPYYhOsVaNHT0WngVUN543PIDZmFze6N2yYtuPMczKPgkHyXTMrxKI4m4zR0lEZv8JvukRUFfTirXjrP+CUfk4o8HgR+5THZLCTszrg3ExMLOn8cBu/XFWSp5UXgsbjdrgT9G39PWc6pqQNvmSpo3zoZeMeOEbzxuYAZTTkdu3M+0hWt5yBUY4lNDfqvIhzyf2EO8La71HeMKxxfKjJFBJtiS8SESGIlBR3yDT2H/7H7s5qanFGZiSsfoJ0D3OwQBFMGagdSQw/hUrEeTLmOWgMnVH19VAa1rFbQVV5QkDn24ShWIYeqOVCZzrLfLIuw7OS0MC534R2NTEZRX8jMZUpFEfhd/Abd/KtKNUw2oRAG4LGqp5RxjJsNh1ZX+RhEjRaVsDB9uJ/7gCWle1SYBEb2a+76p/Dp2JqUvlmdAHrIxntJBCiPm7VFVPz3gwvEaD0QmsReEDEAXnQ5o7Qq1+48DKw42ep4Ci5gzvrOelcghGDL77hO7HcukUeO+LLSYZS/ZJBK6fo2pbeNo9oEYuWYVZ3we1tsDpnbkZutOL6z5e4lr32BN9JTd0jmEY5Wrp/Iu51ZyNP4CH4HMefMXmvbfGpGwTBGcAIJMBY6zsKwQKILfAnxkGOeOEkwA0SiHbYy2wOhzIM5ugZLw8DU8splHkepLcuD1Jn9HDpZvEdf1z3x8xCAprE1Xx6OoWc4bd4JpoYye2IDyqpWcVyDmghU9zMInUZBjv3gwBzjkUQa3BYybnlYx4WO2DsQb1eQCxuwHJAwTwHGSMuDvrRWkx6t17ClFT/CIJ6o0vlTeJvQNCP0Wn/FAoO7lxx/ufPRgF2zZv9ELXlM51KAJjJXywmFMpZ4deimPNhBUmsDm2mPcK6Qstd47A5Devanyx8BUrWQabPJ5DwQ/tPGnI2sgEB+zjJeqEqORS3zRQMJwiNgmzRcbgdQZigMPgSPywDeSScw8uUZXFK2gfgkQB2vyJAp7gFi2MFtoSVDlL4pEQdvxx215jVehvgNmxbr13jtJqKOG8dXGIG3sUdU6YUaVjmGsmb0XS7vO9kM6tSs2C+R0WDWlDiztPGI5ZQglkW24LL/lYOTNO4o8n/oMLn6ewxlD38OLVy2jO2SCRkIaV2Qk7J60/0eH+oZ6XOpuaMLxFt/C6HxKg7Bv+J1w6KbA3KhHENn8WSJ1oM0R3NwW+9boAVHut1hZ2WOgZPS/YgOU57Yx28mHpDyIAdpPGurCE8YBkSzHBfJY5i1ibmfd7ssslyzzJpGm6LpOTOzL34N/oH4t+YIDis4Mf49g4DXDpBLb/Vqf/SPqK+0Pqkcjtc482bgF1xmPZ9L4DnQe83hcg89tItQ2swqcCqBgvWNwZPR7vvanryNqJyacudsPgJsRPi9zFLxxOvUbqnm6iPC6FUcBj+yU508iAmAqZlHC1rzjSTb4xNyD77mQzntQBhkLj8F9z2FpXGqdu0eLPyzaeD9dR/ZHOIMscgVhCQWgk5PsduwhOUwAXZlxTEP5hRCxzB8nXktXY4VKcXoOJNyb9ZTKUwDOdHGLxFywNmTNM/AZdgBypcm6TQChIuEDUnxQFsAkiC2vnKiPu8Lt1cZJPr/KVnS7HenXfe06ixD9Lc1tlYyabyqNUQ1TYpvR/q8oMO/PmZWuc+W1SX+ccmq+1f1NFYn2WeK4Rv0HD7FHnh3ppMSvhfOX1Z2cq+6pMPECSW9Dsoz1Q0um//sZd8xlPKyy/lIU+bT3owR7AEl+nMS87Pk7GnVDPmS4aSCYl1WDCtM/L9AWc6IyVievUcLvNa6fjoGkY7JkpRmAQhG5G2SZEFlr9/dHL68jPHmoHG5BtAarxXNGJcZyX2Mo7Ht7W3mtrZFgxoWIos0RTFbtat8spiiYOVwkzTsZRGVHFW8n5NGZPELiXv0HZ/QyFN1dx2FeFlermyS8xNDIuXAJ61Z3KAPW4q7rd389BZjLuvMIymLfGhgVKAyF++e2FxYiiFjGCiY7Do/spaplY44+iG8WmumIQh+z2nYcVuOnqAcLCDxqHEZXb1GGboI85awqRtIcGJCFDe/PgUCJkqPi+/YxaOcUjyt9WA9Jko48nM+uBKTmtaiEv4SYhOw2z+xu2nanPc2pJTLg+qMNKAn5wPHpyMLhOt5ZfL1yyagi+UBPwXPp6g2RcaFW4a4AlBWTeSaYWHC2eJ6VDWozsj6xSYaYy7HihDnib6HZchNJ+lZPQ6Re5Cbg7Vz9D82pPZTVj/uTansktBmtkHznQ1a7PZclF1m2ewTpw4pNJgm9C6sblzBEqJDHoq48RscBzdY11hVA+nXgcJHpXviS60/lAyGY6ANduk6KxTatoBf7DrZ6kSlIKPkvBkg5Imxyi9hx/kddEI/0vSPh8mFSdcb+kXWnlipae546IMg/rI4E1QExbFhG6f8ztF2U+2qDSN3dqy7s+Ep2XXXfl0x7qhuie3y7PdljfG1mMf0wYwemsUKU7HP1fcuxhkP5zyJ5pYIaGKte/OUUXYZp2Cg6KUxwbVp2eq4A0zLoaj7PeXW4QeDHUbCu5/ZC55k4qd7wqu6Uk8yyXYE4X9oSiEzNIUhgsPBUuWKjEr3g3SS45QC1Lb6eFm+KdMulbqAHfrYL03enhIkA4LU4xPtuqvNvtXT3gbuQ4u/ycK/90Uwp5nqWxyT1YZFr6LPQLogL99fiR5+6OhTTUCe3wi0ayDRxt+WhrJDwcQs3Y7PXJkb5Usqpu3PR/jz3DD79Wn2VPKYSYgXgzPy2mXK5UaJYdmJoXyrwlt7qBNq0+6Na1KmfHwwgk1OeU+NGQIMvrx1lNH1un/SoAzq5rixT7pqVzm1bYsK0L85yPwZ2QBdXG0Zns6o2WEIrx5iAgKeJOb5IqtiFnPKgBWEK2wycptyUDOX1jHcTCZ8PwzjtKHmjh8+V8URF1xiiETvLm+PcpEN+gLxAj9FXJg1MS2bORfVplnAHKEmnXGQTRHlhFTviSVKYoQJojr7DgIlESVbN0z0eoMgk8CmmamUNaZZ3g+X6wHrpSz3ncb5b+Z+9ARG8fWxRoyc3agmE4YrkUgfAVYhxxJoFb6TAD+yp+I7/i6dmU5r1EsDzUC1Pi0Vz6eDE0INR30XL08XfoHWme/f9CweZx+R05K6b4+74P9XAMXZSOTJLmxidtqUnjQiZwhs/fiv1VS9mBwknLeJ5nQ9nu7imxxR1eDJDi2VgiTgkUlZr/ih3yt5LHiTpO9h2H4IS0MRp/D4DlG6sFbdZKQXdN4pvA5RZlgm/VSREonr9x5XV8TY2OJRcnLKVxB2Zs1BbHSpcySdEdR1s624cmHJufU3DQWda3blkq8Sz91jJ//kktC93H2gA+HGgPNLyPlM0hD4KP9BiMDFxXEqHgqcvWJKqpMeH/+Z7n9HLkO5unVBFpwRFbQmV7qqLX9X3sGxZEcZO9rwGxoZ0J8hKbqZzCCD7wb7MMOWAKk9ZMK24BxvFk3lwr++kOKhZeWwUvU2QM1/yDgXGG6J3hS9QDQPh1VRaI2tfZ+2CwbW1LNXEtjleQRMdhWI0RjIj2XIZLtgA8bQNGUQ+k0UIQQsOovxPHH5+nc2NiSMExNBrH7fqboKN98xfiZHH+StXIPyF6r51I7Wq2Z+awEEuHlsO38YzL6/DEtZDEFvLkKoIObUsBXpmPSPlg6GSWFwLBDdyIOucNElj9dstA6L89FbZaqozqEu8vYvAYRx2/xXzlTatN4BM911XpcM7gjfMLBSalLawyQBKBj4ktmUtc01x6v934q6/A/dI1Htt7CVXTdPTh0C7QlJlCKJH/qh7c/LsgS82Yh9EzgsaSt7wpVQznPSJrI3qtctpZbZBRMEi1Zq9T1zJv0e6ukl6ckbIEouEADbroe18ugWFUbKQJfYXGLIqs3axKh1ghLhhyWcUX5BcvNZ4B6H5MOM2VON5xzxZaKZXNBbdYlnq6YJon/Zzlin4djKZOl4gcakU7z+HAXKSIlnV83t2U1s72n6igGWX3CZRO8+Ao0cv4YqHvmB+U+FA2BCXfkbqYgOpYlWcQQcje6yZToyYLw9zGHBGYCkA2IWLzCAFqYpRoOcX/vVODjpwmlVYUnr3FXJajqCqCqEbS5yUBszLAmFY8QEkjGq4fUqVYPgFolw5o4tMQRgUHFtXkKiE6M1TifYDfmFYpDl4pwS/85XWJXiONEFYlCFPuxYJcMnfidm5JNNA2DLDVw04xYZQh2XsX9lUIC6beEBE5KNiLsrHbys8iM6QZnlYnzjHu2N4DBn+9ohunIXGYJAxlc25Ri8tZvr1hEN8nhD2Sm/Aap4SteFI08J7A31vvyBriqhUv9Taivzy2vVRMHj0frRynxZzu51TRzziRmbV0cR2kz3QNSqA/0mn/y+2iIM3Af7pBRVJBCUB3h/WGRL761MIJbSicWo9aBhjS0acm5ZX2l0QHKFhb13HUwJ2b7WAi83njVCWQoL74VC3JTiip/X5odHKsJyDn+bbrlmmxqNnnfvTe08MIIx+iIE6FJWrSknm7Ru+yJGFOieHW26R4h1cqG7gTz9n0GJs3EJ/XoxeGGEdtQ1LMO1yfLgrIfsnKpqyfPIh/M9muNX7ipbFuE2v/nWJKlB+ijyMJHKJ1pg2QI1zLS6EanKLaVWXYk7CZWj3So9oS6rm2KNCDYJfHLDmZYfSy/u/Ga93aXCz9WwvSguKl72w3Rwy6xsRADgIaLbKD9cXGF5cpAOz1Ic4iWTo2suaNyurYvah1K8i7qI6JpJpuYF27wBcP30Wn+bE3Vl79UZ/t8gxxjjvihxrrY0sBebOsZDg+GM2pyzPkAwKQ8wGkvqHdOfzE2ipEZoCKb+biihc6ZO7CmzypFdx+1wLC8xRiaVM9JTR/zOFLmnJJXV9HhF8VnbXSERFY3wp2YMP+saU4gggo/5LppJnA7OdfJBAEOY/yhJbkoDkNZ5QlOBkozHf53PtlOA4Lx4EovCOdc7Z5HOBiTl3AlKSSlAyvpDfS5g0UQWcgG8OCIcehbjdrL80S7Am273326OA4C7gF+UL14tFuX7I5GNTMxiJp03A/2gdIhlip2f6Njo28E0gSpMuteUidoqAyStoqg2K+Va+WvLl6XRTknRwKHHIVXY6V2bvJJIgbN5NLgVUoAfINiZ4zCInsEbZWmT0XNcAJKdfN27dgsViggeSEN92jW3Knh5LoaQsSOkL6lJnfRc6lLADlcgY8g7jvCo95t+SQ9ORJ+Za21NZAvXNTgYFHfYkzDpb5QOJATU7bkIuR/OmrC+1LI6mY+UBk2TZHqB8q7WdWOIJcRuO5W+gu/UwtwlFKIZopzZL9qE/TiYaRD6LVGlxKNWUWTO0aWiEWIi/ORPcOL3kImq+AARbFwUIkggNSMch2NH7JbXVGe/2Rp5F6Q4QNeWyg0uISar3zR2aHYu2iVIZOHTg3ov6ZUR8/U8ISGes+nmQtjg0+sAF9hMwL9gA0fdtVSpr+FzLaU9pYW4IqBttO2wwwthwViwu4/88ewSmCf2yzKraiqT/nprXtzNidRj33Eu60FBIPX6zISt0jSQmoK9eAM9qv6Fa3kSYXrm7g1MCWZc580IfuLr17aMhdPutGluZbNE6vsVU92hNT7iZpJxQ3qw2bd8xwNKo97pABF9vo6KC1D3PTQ9RvNmkXTod0qyWyFQj7b2O9AxgXKZC23KxhWS8p7OkEmNtccBeXiBYEopQKVBPFbeyUwwoG0NGnqehkd+oWUJAngxGY4usN30v/J4TKvQGrCkwR2+sLiUAs8+EFbDMlsYBNQ5mnIUS4Ft5eMNN6AAu/gHm8xBB7Vl4U09kaqVwVf8LeP7NjorTjAkxNWsaXoSFQHh9i8i2hy9F9mJfLp28RYeHwRi3nXH4DzqavPtdaJWh543rrJlcA0W5LtoPWFWTY2XJfO2dT6hIR5eQQPpn0VO6eEhiRTI0vW1loxGuHzFGvxtIMjHaV8TpPtO5GI93p/+Lr2kqbXWQPY024p/mTK7ZMkI/rwRDDbGq7aQqtqhVE/cGlhM2o4QkvSrQIjpIi701AGuZZDuzsy+jZLu/SeIpLaeKW1SPaPCxB9OGnxIerRFSaLYCzBZsortO/X6utnlUrwyOij5dy0zxDYJJ1TsT9CmrPav5MvrohYsvd1gB84B+9Od8gzd7QvEC3kauIxg5WGWnhWbHOCplzoncyXi1gsJA+To3XQGuM0XnjKnjGDVwabi+zQVXn10mj0rxI2zbnZnIPAPFseXUTlaUsPMdVuYAORQdzT70LPN02JvgPwETQYbIIQnuKqBMCz6E9Kv2LDM3kVZryMy7DZnHFq8E+mRSbxeoqF9q+20wLqD+iPDNazNyYjg9jq/8g8VPPEyovXYdEcfHGnn7kq/YvSHMjNssclPDKk0ZHHJv1L3iOgMJuh250zSq1ormSUj7xWWLOV9QYp61So0DRfQ3L+SqLVyqW8XwhQ6VfCPLJ0LcczDBeFJ6K/XH5wCDWtRMlQP/Vo/YQ3U4Ei1CNtlIOQI+pEP5wxIdiZE/ZiO/9kINgDajmL1SGXpGjpR0mDclCVJTGSaDjE9/syUOyeQSMMUoJ7if5S0+ICq1+dqfHgC8ouPjeK8uDqHBmAgPZoev/E60EmzzkWo1rNFH9xDFkprlqm+OGQQL/OPUVZkATElZHJYkW5SFxWD53s2U/Rc7fU/yNOWpiX9ovVUz1tBC9WYjQLk8A7PxVH0s1DmnrYKyr+PNDIrYrU3DKWxrff/OqgdYR8aeKlBDU26zzZ7cUusHoDVjH5CD9LNo0kKx11uPAwBHrk6jK880Tw7yPdWrAPaFb2F/TJfh9944cc0nvEGKMBYQ3ewTiHiQmjmqsC0FYUAVaEAIYUs2KLADQPd9GMPVgMLfDoItjHs1lGNwvW2B7+IHc1sN82Nnm+5S9cQ6d8+PDE/jH9wnc7CD8Jzo/q/NyTm7Cu1hLaoRx70+/lQOjeYCddNEMaWOXNoMnF1hLapdaov+DK+/RctCesreAvxnn6uHUieCvMvC/lzztwVjijmnqprdDATGIyUtF8CxEOkvBz1HknVFy2dveSWIRFpxF+4n5tHVvaCCZeVvERKV82SyckGVuV4fAcDoz0kHdCYQDnvL96xEILGUcJsMOlCl26x4nzGtNBOTkxv5R6ZtLChWkqw4C9B/3BrbgNO7Fd88VRjWApbd/v+H5qZTvSgyJWWUyG4xznAc/Df/u55LYL750ej/XOsP2R0Dmg8Bp2bo1LITsqomK8wX97dVVzvSQ8jN5V3n9YhK7U4hkjlNtFDrXFBKZ4TSNGEQdppG1hNVJdUcpVrEk+zfgRl63NV5WWUj56Uahu0m30U7mxiFh83Nj6O8bOHAQ2bOO0a2VTMl4S+OYEPfRIz1G8pYSsstrtskC22hrl0y/QePc68uGVftV+GCwNE8JQA42Bk6DuaPMDxQGCw9x/izuYn/qf4AvtblsXiV5tXhBAyjcjn1ajqUqU7MBnmZnB0kPHeXGwtxZfFw89z93TPZfdRKDA64miE/JO2E45nCfeT6KyatlAJ5E1Ou5IBWiT8KGwl9nwjzzOPFK2OAPPmzQOUEi8eAp3RGRZhHqwbGzOW2NENeRTLgaaIKLEjJCVhEAcXKNXy7gxs/tbOFSEwB6blmUyAaDhzIrzMRAI3KQ9sYeH21XPOMns+NX0j4LBmZge9FvjBLRhkuniFot5yjmw3gSHjK9HGz4p5Mqd2k8+4trqeXItNgelNo4G8/junPMmHO+V9UKSYxf6fJXLi2MKhGP96U4rSdRHMReVMwqwQXbROiJQ9BaJqFyKBxXrkxfMYT9W8iaWMeN8Dq/2Q1NRO3P6bywhID/tUVAm5JkbqYHxPvjypwQ+F6fmwR55dtvBE+PFGm0lemGzUz1QHkBfGcOUDxVYku/tQSrjGJTF04Ho5YleVibPxBDDz5wriIq52s6VZgz3ouF0fbE1EIzRLlvceWoVxqRgRWQ3qOqdNYsZN4iP6b4AXpAzoHlAYhlYzpoifXjU+OvBagKgnOi009eJk1BbSuvCaOZ7lzaEYdSd8ft1YxP/XCFQCltrNS13JokUlY4d71E/ugxe7aYSHZW8UU79uS+FK2p79v6l0IF/L5N/OPRwd5uCcx0/MGjd2wn4FYsnaQUKAAtuSvy71C1NBLNPmj+cwzrSI8bwTBvnJSncKmz+J/J+p2e05Eog5cWfTJW1DURnpnYaOx9Dtv3Hx/fyj3ztdyUfN0HCW9xVgT5wkUgwQLaxA0xPFIOSlDM1Ms3Yp56tUP5uwVxypV1LcsSuJK7rFR3Uz5vmf3sZzVIyaIDp5tjaGG7F6JuRn60qCUy2gdPPiOptylUAf/yi177s3TDow/dMGr2plpHasZivDyersN8sGk90zdBCxpEXjWOkfDA4e33lpssa9PPssbhQOh737qARpswsmoSXWOkGkca5SA7gAoK5Ry36xSbq1XetxuFEql2rWo2XZQQn1ya/cY3CD/8bdXrf9TIF3DT82fcaWz30sO1pa6DThtK3Jm/rLbwIUllxH60mCMeLC7PczMo6LwwVjMyfY4klQOB1aTSZr2fwEm3jaDzU1wXQ9nOiyBATCgYer8VrNCmEa68ILXeaRGWIrEuXD4PzU/l7PXnHPP56unnnLShXJTf8je1NXeVSjchRY08qpZ9fUXWJ9lE+TKIIJBEi7tEzP6qpitvp8rSL6gDo8p3gOt4V+Tkku6epywxbFLY01DYrkqe2pqZMnkdpFwN1GhryigWkAhTX7S/fJzVNV8IuSolyqflj0HlDfoN3pbGEhDzm6TTTjis6QB42H5fGo8ItgGUO4jWtaE9Trsn9OxVxMt0++iZezYlzepJBidE+GiTDcplBaRlqgxI0OHYKk5VmgNvaMC+K+8RlpEb+wmdesmfhz+fcfc6ldNuF/RZBfR9l1eUcMRji+XIGRxrhVAENeLojb4wGamZ8AFtzK01eynNItmlYe4/bAse3iwdzgmPGyLmw/x0UyGP8yQK25yxYvdo/d+vfnm3MwsPm8BV5ctQ8bEntHZSFtgIosV5U6zo9+maNJV4cQAluE/LMz+iBvPmbzI942CJCab8gCSer5eVCRqMl/DBeqyudlclDBYGogE2U2iWjuTE9pyXP1RfxzzctDiV947hFMUswJyCjQcm0562Jv/Ib7xL72/gXPxQfSzb2JudbDJvbURO3Aztk8+ef2CEmlPBjRSLnBhIM+Euexkbn+v4B7CB4IcRDa3ZczmUUS6SL6DPhE/6nR8iFxnh6lkdbwIJTjJ9cu7LKJoz/SWmCLREIh0QxbI6E8vyMofriYxUXNnNaxqYr0+5KFSFPd5Ee2/ULUQbd/akxwqXBGBt//LN9Je9szcA8exN6d6cqvE7rSB9qQQgBQRzngs3tig/ZksKSDxF2dy6I2aD1v0d9Kc1av2h6TiUklQpy71T+1pLAiE0T8V3RT6lmMZ6nOqSpOa5GRvZ92bMfQrXZeVKUJSjeh+AIgXdWcTOK2kW14Y/NYZKKaCttcnLsdZ8INpVK1Hsh7RgyERzjit1tKblDNG/znsFvMQzWJjOwPkJR0osQ3IvRlluvX/fdYIQU+wWgQfM4TgUbwLs2ZE/OBPbeaSzhsE4PPvpsRkX2JiaoR37gILm8AmBHNdQNKQ7Jc6Tt72fzn+U5yo2xo4YWM2B5zZ6MvPkJVJuyUJ3LTyAsFlqLKvsKXzQnlbI5skh3reOBtlstAOIzVYpouf86Wyki3+WJRROaPlPGk//YgipfEmBQXmO6S9DNYJ9xdUcChSe073lmzzBHkiO+ejZQXO4jPNSp66phJbjG3dhZPXQQaN7WptFtp00fgrNcWmVmeeDaD9yqFOLb1QZBd0ghFBUGKvGgiDMyVUI5NqvYhybQwX9AhmtVsfBD6O+FuXBrpsTD+nprCHYvgGuw2mvbn8J3vFKS4qTXpcaX030nn8BqwcF+/suU4qqExQ+sKNMCGfMlPvOWM8aB852YlFlY5fSMUh/DeNZvMTZAWQ6U41XT6syJtqA59hpBr501U+t4nsQ+kIW9vmmL2OHN9isPVTLFjWiktMGhVdl5agST5lnfnn0jYgrKIPVP4CxmP4NPTykzQLywa8vHI35OS+jIMM0Axus3hVkY+ggYEjATHiU3WPUSoYswb6EpBK63nPig8GJnL9XCs5Q5k0PUA0jyZafX4fFFaIdNtEjr7lx9zSoci6kSjrEMG0svTiQCKqeNpAllOpC0SnSQnZ3UpocvInKi45FJESOSFhEoDXhXoIjrORf6Y/cD8TlvkVaEtdSJVZrFThNG3UqUBhm69aJ/2K5XrW2ektCYD3CwtaMFKd/KN16v3HB/MNEiCGoop5/UKvcPKapB6SMur6Wn7zeCMWImjZ9dFBPbTQckpV8lDOlu6dcI8SpRqj3VXkavzIiXqBrnVpetB15noLGvhFGWQuyAMDTkPY0+u7G2H9rxmhQytI+QOxjMq91zzDYFA1B7r3+H9uuJ67twhndimAbtL+rVbQystMKgr5u19JGVqHijcZeSJd9GpQLRSbhhWO1qzWaANXvCZGiZ37TgkQXgo7Dw/mU4GUXwCP6GayA2rP3I8N5sYQXJeNNRfhqBXWsA0eV6l5zcbXwyusr/BKApfXug4MLupvZ3MxOG0ZrCh8F6ypELAazs4WqrsC6Xyn4uoq3DLN44ba423Yyk+r8wnYprPrpZV1wuKAoY1b5AiyQ9iN1xnKWW7m5tRu54SDNCLr67HMuZYYSPeXCwyQDZfHgb5Uey0BP0o+eJBEglO8H5XqMjkRXi1gh+11w4NiADuFuB2vNOtYUdt2BmJI9h34hl3VRQ1whncsAdl7dY447576I8DjcsZDQirz1mqwwpPaqgR3Ocu9jUEVfBJaYR0DKc4sE1WwQsWitmH2iA+vDxejxS0bcIMH65H1Xp2i9QZtCNN2vqyoajVyLXZ0iPhbUESPObUNMr1Oq77YLjKUp9OqQc5lfDE4qyxzkQaJwnKl/RV/co7eMi1UniXBOARtSI1kLi+M4ArYhFyMtqNBValoSV3g3Srom7ninCfCrURYhPJJzE5yKS6FZz8qcNmDMg4lxifKWt2+TOLAcFRlCAnR6RQtpa5kfwhLeEQRTc5o2aA8Tznpbqoif8VFGbe51/Lg+VCD1NEmsTgutROhRyYqxiDT7HfuTL54MSnPPhFc81rrD7IYBL5FW5YY3gLUH6YPh2EneLFe1bmS9RsdlTO3eZ0u7MGw4xIAlMlSktOkzO0k51yYYQg2uch9SJzkbln5AbzfJGZ7eUs/r9m60mP0iMdQ4b0IdqpDguyKFj7IJA6xkg/jTizBvQfQFhLuKgB7si6vxTjBKx6jNmIdTkQyXfiZjf2WGi11+HbsTdDpMrQIMR9detSVVzCf5oYuZMUGh3RFtuLpeLkmz4ykq53mQVQUCAI4AJA4ji4w9R2mbjin827vGjoi/MGW/CPZjFgtNob5EhEsSRAuSfV7IXlHqSkTTLwHYKvy1j5DcImlcVVMNx7yot4yHHzDg81pr+6HAX3LHD/IzXsM6LbyNcbFfcmkC/i3Zb5V5dZTDx5Z+qNltlg8/t1gJrNjQ+Vxj63kijohQ4WBo5yZ3e03Gd+dr9458Rfx6gJYW8msxmNiu+CceaBH8IAbm3bnh8kMPWTy8C8CSQb6XL+WqGIwBD4N5E7afkEuaHtvuwfIXgzBf/wOh8Q4Rkke7RfQLrS8msx0g5gWp1Hwo86pKSImNu52pxIWsxdXFuPy5DwHrm6OFG0Mvms1/VqdKDJY977DKJk9t0oC57vlAGndoXoscE4CGi2deN279SUuzlMw7z1+avDVG4Btp77bTnLnSVpcyNUCj0pdVG3Ixy71FM0uSHUzGbQw55fKrCm+f/zzDGVPSS9gUfE71x2+etEmTEEqoFXNGpHHUa8eOMbisy1m4YKZgWq8/Tt7FuJtzXk86szU1k/8kFuk0LsNZJOsznXYOWQhtOFyUlsf3ekT1n13l/xpDXWeMXySoUY2zstRialfysVZn+CEkBR3WT//TAgWjYtfX2X1YGLUAIrR2mH7+kAguaLLls+QeST0oBKJ42eIVwYNo73JODEGywHkj13zLNSB7hpNJV/qu3kTmKQTAaUqsjKk4nDKonfhw1EE8BpG82c6Dkc6riMWwSUsX/ilxU4b0EFWlkrON8P2kLEGUTfwLxgaQZhgFXbNC/pAOmwNND9wWG8d55rLdeF7c7hRVgO+vgf4YpMHaXYhIkHUefadYje5IiKQpRdlFfQbwxKzt+aLRZHGmrpAkN0ZwPOPmkF4qnEa/0rDYh3OdKtbLKA0t8ZIG4qCiS9GOrTJOuLnkCoAj90ljVKldLLFwnqL+OHI/KspVVs8aH1ASAip1Ea7T4gmc8cLW0hGCiRcQKGSDPitE1FMryndEWIl9i6+0ujCTtXjF1bgHHWubVtMTvER8rwqvPfOIdU6pQsNYZdRFoYPBFpkRLomVBbOhfnI8PfbWd8IV6FWJhuoiwSi6JZ9PpLtXQCxgXuqJ8Uintj+b4qx7zkwOSaOSkzUMo2JOiCMqjpOLSnm8HVdhve6AQ/6qCfZLeGeN43OTa2MYV5uPt1LNSKWSDRof971wEAXgKi6euRMTGA2WBeNCTX9aXAE9vnkvkybISE/94qU4H2jklK89R/4PK7ZcThiTXzpXOrlQ5p+IS/C2KSoFTzBho0CUwPMMvsvzJhJQbAafAceiZ2XRkK3vuROme6xFVRRDzjt9mMz2+w2whsJ/coQi+cCsKBn4uH3pz0pxyVVz6TtoktJVaivurXafaYxoDdSbBPbKvly3jinvjQZDfq9by/A5zTMqirBj2Y/mYMJI/uuzzNeaPf1WyIWseCJwF1Fh6LjPrf2jp32nF8LxcLpagpvzD/pLy1YoRaI7D0fidTi4iIE/RbEjQS3haEuJJSP9VDidm8JQ50Do6Hhkynp/LJok+OLZicI0+gBqBbRgS9g+zMBIMCX7OpHi2KyXnOmigatRqR1qPJaOofmXAOI3ty5NeKaJlVvaVw0ugzrwPSnxu1kZuvMrGvy0yyUF+frEwq6HfOawQDPF/7vor/lM7QUPI9XKPXlXJoH30oBaVsguxJ9Ro4fRR1nXGTi8jQMYPUGpBD++XyWRvHGwIdy3mgNh26er8C1LPgfpiagrEw92s/RbLQxATNTJQMBQEoayvzvJgyfeyVgAblcE8qT2sL+TSp3RcsJoZVksbLoSnjaN/xqVwdXfvGt+5ksJNUy0O8bjEuUIkDvtgi7yNpnhCO/+Gj1Fxlzx8BQELPiM4AziSY/r6UFoiS4+HgVMzUTrM/AGVijDomP0yo1hA1cuWnhjId5J/EWulbnl5r6pddjJL9he4/Z6i3G0oLroEM4O867jVvbVFADuGEtEpZ9LoSkXKsHsH1RttPpgMOvuOkP+vie9+lQqhPlEhS7lcqyq9NxlAyTZIGvXTT7l2LW8VEaMjuxhF3d5DPTcZbOJHQDGPX/VsZUUeTzzBrB0S9+m3AaU91AS3kCyGvWMjrqpqFMdb7ldqfXhvW7aw/YEeu0mTE2wF2ZX1p5PlCi4SKWpVQIsyis/0ukx/9sALsfDUnZ+wCJEIfE1uv+uvOnmxhDc2wkWgWVvu4UmKujQepemptDCpR0xbQFxKGfiQoZy8zmHNQxHXYu44AUvpeKXAVsjZ0OB9A5LixyRgCd+0cWcC/erqfheybWKJyywcYWcmFgStHJRoelxRjjOs3MbCYBP96rVRUv06V+03eShstr0hOsnLosQ4VSvHofWotv0N5Xco1p8ktmmI8EiPf/HVKgSCMFkmTz4mNqotw2yn3JOYzjPpWCXYIK05CpDcaCbgfN7+MWphGxrUgkB0k86ev7+Ba4pRHgVET8PaUJR0AwPO5Hygrvyor03xyZMxvs91KvsZiLLhSf7RsPNyV0FoZ9q//oNpklR8s1yO+zcHoJPY1eM5WHYj/R0j8d3x7804m4kRjziOKqTa9wet2WPZ/Hp2KPyUlHzQXOFhUxmEJxNouSXCShBTTHGrfmlg8YGHgryOXtGVIUb0tKW7v6txAz03o+f3aGU9x9THlR9Ciqkm9InmfIkNdlNG/h/AuWp027laFpmbLfDTfWDUbJ6iqwM65fwsJ3LY+n/zJLuknlyT8k06DoTy4ZXWZYb4mu7Z3UiciM4gG7unVI2yaKhj0gTin7CtuCyoqkLAIR0Q3w2+xmwg6hYYXByT4mUlCe/2PUkdevzJS09VcrN3+KpOBTkyaNb6I7ZDMgJdb68xGuHCRPm1WtjNShHIZNAVJZe0LZu6+roFggw9+/aCcqGhvQLzJzSgTurlLZnYPFyBMG/G6i3TwSIGiRsd6VWNNIfoUpxO1CLal/2VXVXtl8/4mEme/qxv+PVWR1+pyfDeZjwhVP33KUPA96AMCxCriYcedbld4RB7kh17FFAGL6ptej/lbAyu9Es09fuFMy+DdeFuYB3yUVy4P5BpaGsSz3MwqzdxPVKv3v0y+q6TBz4tJHPuCAhQomxVa0NSeQoa7KERap4rY1xEGDrryEL/5dBNA8aBE/pCgOuZfrN00ouqg6nY37zqKuyhD/0EQFdKmzvRegriGKhwUhnMB3ovigUZVQgs0izotEzqE73B1i3rvl/oustVweENCHkjh38J2KOCuBlAjrO6tzoWa1rIZuB7N8YOJfrLFuKnh2qUEaR/pqIF0qy7rJqa/LA3WCfZlaYgr4kfcLodVyPO7spxGpBkvD/kkyKxhJAf8rXKszVwJfgTUWLkH6K+RSyEHlwNPBWVk4du5DSLF72G6nGanYy7cMKggf7mM6lZ1d14S/zRHu6Vx6K5ND13m3etPdRPb05/iO5KVNTu0us3aDNamX4NJF34oOY2lbZrLuGhkvVwlweAyUJvG7G3Yhmz4PAHlEAS72tiCiFuF/m+WFX5pGuc6p3K2KtO68Zp2KPw8RsNo03lZOLHMwIvH1CW34NBFkoB4PrwNLBgU6K+h8khBXRrGvGYM5PZipj9WPt+l1kl9j3fSTOTqSIO6TimiiQCNj9Y7gV18Exf7sTgx6ipPXlAiXNRAhATfoEwzi8LkWs3+gGvnRwEGJgYNE/kdmAE4ee5OkNAsfHRZvOlFL3V9KPW5bEYBNe2NlOXcYlRuaDz/zgeQy0hWOpRdBLXTMFoChjQ2wHdt9R6eV+EVOU4h2Guojdt/JNowx/tXW2VrO+/jSUvOWtXI1PRTs0TGFoEJIoyL5qDOgXrzDGkVoqpS2xSGfBCCNsTa6GbYkFmdVpSc9YKbK2hBDzOZkqH2GYC3Qor4TYhZyGP1KpyncHE55YzUVdPBtmHkOkp+OuZ7HVt/ehuYHGBr7p6dJ9tN1mrCApJaVuBOAgdjtmAXYbihEvg3npghQ9zbn9O5TOeRNGAYrJ40O06F/OTZnaNhbXgLpor7R7j0fthlHIHDP+IG0wmNlcppISEDC9u+L/JESi+58DAbylR/qWnyTrRV3P4tUfT3tH2EpnBwu4/237hETpJeEpLufj+Z89ri9f2+BLBuSytXXdrBbIDDXJXzjHYV4z3wfJqj5QNuQIC38AJcWul2czXAVWQKjOiiL9TJySzE/wgURAPDVenlkHnPeSOreYvHYzU8bOjHyETLIC4nLau45CH06KRuc3qQdHGYgXXIvB8gybEHczhnUZAY/NX6snODyavrphft3KEtknQhgIFBpFTRXR18xABI1+woxt9p9GcDCSUTvnWiDss46UV+sBBS4+TlhJU5ey7VO2CZ7a2HtmILL6fGT/WM10HArJiqvRrI05z13ioJFqHhb448hgVKmz3yXhyt85UhK5fcojOQDPj42iImYsPaGPk7AUab5KpoHYeSwWtn/5R73t0WaUwvBRM5UG2cqznVD4KJ5vdwvB+dUsL/+D4txgTcKpW4uXDQXqljO+tM0tP7x8v2YuG3BagqIkHPBfrvdgERph+/cQCkiTTQEItbNEGzto8kLPWOHvxk7NuervP2em4LUZgi1cp2opgnuYUcHFOYoMt4/Xo/Wq5l8sD0zouZKDEsLdPO85usuRKPReaujpcl3Ak5rpH78uf2g5o33rR5i0W2AtnDKNIY2K0n2V4nSphQmU+TkfyeUXvaKPhzj3PHI02gg0uaunBVGvBk6SiCAHHTIEHYURv2Ua/HRcUkOBmDkwhbqF4X8kUP9tFVKHLk6iFDl2nSVi3SafZLQrAN0mBA5hT/XXCnfTwTn5JceYu9RzPlbhyVUocCX4nxR1HiRegCSVvlWGfJqm6qulom7K9fKldsxnsmec6OYKGfXZOYlRoGPiQX3JOmzCCt/Lj4pw0fesNRrLRhPVH/zLpp3dRjZ168B+j127jv4cAHwIpEFcGDd61rBkGXq4/wLlNTYnLJNILK2hJ9QndLkbXNaBPNJlF9vXSezCPkD6/22GALcnV05S1PG5ZPDqd07V5ZHo7Z8yI7ujOwDVdLGp6A01NH106uZBnLwJl1172CbGfecLxLr2lufQPwtTI+6YzsvXfRuHWsg5LE1sr7G/yhw4zgOiKjIadD1As4SfQowx/+eZMFEYHoIrCMHQECNcWFOuN9c4bTVs/M8avib74xy3j+m/DYYeeSdzU4a2NhAV1l33WBkjn/AvuRTAHd/GDFUKWv7ahTJUzg94F5QjaHWJqrQUvREoxkDOmnXOYwUCs0egOWn2HJrWzJ3FEisesRqMEfXlbw9+hIcfTofgOKffUcKHEwXD7XphSnhTG6VXBLpRpW6zjcMVKD5jvQRXstnC35fum8zuC9ySea5curoo6YtxByev21H2H6WToYeK7MzXzbsXCYIdKjbFfZBYEufRxThL3VJQGPsdZSwkPC53uHPtqwwEPZ7UtYnoZhniZ7BJFwSl7DK/RU5VgL3N95Xjoh83f8rvqXEgm1TFbfBib+tCV0fvzMAWHsnlu74+99roxF8f58mOeFHt6EK8yel7wF48shHB0cM/CDHDpvVEfda6NylRLmP+QmTvMPeHjTLV6OSwaeoMXdx+2glmz7Qi1QVcBWMO0jwDjyaZnkpiPF0UxX/jzivl8IYp2CHRACnLd81VBWoEX4LgNUt+FRYH5wrXnGm6tkuzQ+ACD/L2TcYgCTJkGDBsFaPUoI4VSyHqZKtbDeMiy/FHLdjExJZEFrKaUwF+TBjx9FCKskMNoUdo8NkBnoRK3QdqBsJmcnjZ2c+J8wPiwA0C6IrH5F3DwAvx61UTIfADmuy7yyc8CVzNMPGvg38qdtQGLkvRVsZLEIUUSbkp4bOTnumWOMpZ2imSm4V/EjOne5eMf4t0i32pkNN+Qs2i1R8q+TGuOayM9H0xxW8WqMClHzwa7cZmXR4SZX5SJk7Tl6sTQPPFuC4l5SUMUjFeLKxvPwbLPje1q0jHcbf3EeDMzN/UhSc/Scvthg9r/3dgm0SmMrteHgyTbCquyJcMBvo7T5OiC8p/EWo4APvyyYJuvxL17zURwtV9SNsrQ2lVdegiisX0NxeHQ5+DbfjYHVHsnEvga0J1DsCYn9cJ8mTBqN/cx3K9FI8hvQwbBs0fz1S70UJ7hEMWjzjWb2c2wK4EgxQaVfescn2qqWGACcI11QYjQH3G2k5rchG85hHZfkaJcCsPs5S1SHAX9HtaJU3MQ5984OFd9qdRQi+lIYFstitWDeoHor4xZsHl9xydkRtcsDD+V9l+nzWjoP37WgK870pnOwDxlHE431ylbJYRsMqMevwWgXmLJQ5x57wAJA9zU0RyHLIBAbg2LwUkzMeT2GiFMID1UggnqCRu7k3SMrEHGknfjqdx1qxo+gPgun314kO6PU7PH0mTLFfMNYtkPwKLl+Ags5OQERr6n2mef+ekg7Ec4KkvhwDuaPDU9tc/XJWOaQ1O5kcIIf2zNQi8aVlitUc5k2mowyu/UdCrDfXG/lgdHC+J8PSIva3Il1rvbMTJ5TzduB1cZMslVjJClkfB244VllF4di3r31PG/vM0dgeFHfcyDfEVpfjbdidJY2ocCMIb7S9nQ0cU+4seLTi/dMj+Bqa9bb810DHcXu7R5YwDw8FRXxNVtBMdOOvUHUteDRQwOX2YixNDQpg/BJFzxfZSypDiJecR8LWpRful+ImIHPvRSe+S1jtJTZQRQzlmYnRup9JH1ElCedvYt8XBDrLXF+X/bc4RjR18jPVOqXNbhPVbJrKcr4w8zxWfN1UZZkDWF5pcYDY8bhHYQ8V6zyCDeF3O7j7sAxEvhmsM6Ee7/j6mjJ5EuSENpd2oSDQZzjGhNrs3Bn8xNH/YPZo4gH8fAWGoeMth2hGmDTDozmPYycJ0maK9fgVX1EF4ljIzS6joBLy80A1PRsu0U/1Wal8xW4ucQ0ZJuvRB0SMDMNHO7RebKhEzxxmEGl/fx2LwZJ0pTC++mKPxCtpvL16h3uReoOlRLkagbC685K8PRamEhWUEBTDxRx4gNOwxFloZI/Mi4EU3XM7yFvOxRoIbb4tSuASxiLXqQVrqw8eGU39i7enChyOr88oo7AzK/btsNW5IaBhgInDscS1YcoWU/TDyVuTI3nQWPQqTzpWBqUbtACguEUkiMz+We6oZmpZ+gNL2viEqgfUebNACKNoHHFzseuCner6VeZF6lAenSgeRpLoEIw/BCvJQMzlw56ngRy45yBsEBdNzQSt/qNKAE2kgtq6eGAJyHtO9Do8x9UyoJmY2zkwHsqWmdslLDtqkmlC3PC26SCSyiKzFehA/gqmfG8x8afvqymxWdMyo03eIELSONLd46G5bfydjfCaaC8VstvelwyexEVFRd1dzsvimac4Wn26ALtp/pu8AXXaFLagiZGNBfohNn5C5h5C03yC4iYAKiF7CWdup6CXsnWXSytkKbKJjGSlaOQPUKC16nXWqsJ+XQK7rvzOqNaNeLHsJhDBafiPtvfJ2dpFMlp2uYbKcPTNCwWaajgboubGLgsImwQBOEbhXK4jLGksnUtL71q/PkSCBjvmAsgoOmgqfbUjG8fQjZkr+AtPtd8gWIXWj6FoyijX0szv+Wx4oUx9Y+i/NyRl09Wq2WvcFTVDfOgYnXleX9PLp3zi7YmJluNwPXpgB3cfecp5Yq62Cu1pRn4Mi/3jTPZ3I0+jmav4ypFfzTSustHcNeEwePS64DyvmpxI9boZTqRDO6I9eM/Uhm8Vk0+bFRtY73oZHp7S1R1dTLAhnnIQ2ajTE9KSn3KW+uhCQsNorSTg689R7ncMFyWU9pZ0Kn/j7VRg+QXDHDtXn1QyxdyUm1wA0jy5GWuNbg7EkPRcemVMWr52pgw55zB3qYtvEap8ys6fn826FsjwnwGjesb2iBslMnRJ88ujNWQF4VxMl7EpYd3LR+jQYVQHsrxXavM01i2jBf9p1keaJ9rtymKaJ5llw5w1arfehZVfhOCjkLl7T8IgEbIvmKp48Mih4dBYJ1gBzqFNfSSqLUHs2QlGbgMKAJ8CjipypQoOIDkrBDokhGqr8ouWA48sMeueRlhEM0OKJjpxQp0QACfNa/Zw0YJcD0qRmUOfB28Dzysb5GEHqa2PpfIxpYL1qee1GA/3t0R4fJ1lvfErRWQaJw3fgFJ1bocxvYrl2y+A3S0/C1uZdEHjZqtj5bRzOrmNwV0oxoNZUVSU6dAu3H7qruJhC6sXMvMjvr9gRl1x43n4w4SxFbNVLxiLjPmEVi6XQ7i1GtkMl/+z36dq4bt6thIwocWZ9N9y7dRpU5kfKRA2mbURccLqIJu+djnmDcwoOAbKeYrPgUvk3xuQdDPnkFrMSHoCmlTXgXQmn64QJ5mXefWEZssDQ+r3RaYxLn6uOCo54mHqn0PbMZK/o5JHSacgnFEGHB8amJ4Islhb2p8qschKfqAlRM94/WWOnDQiLBB2Lz//8NpN4aET48xY0b5PE9/UX7jCYe5wjeCM2qSDPA5JXRJ4swNcTfGRLFBbwfbUdxsSpx2N9y1fV8zWdMoIgPne/4CDXUx9EOgE7Ulvf99uFFlK15ES/gXhDjpnHbBifNaTD0VMDRgj3R8rGBIols+YN6K4+sj0UWULehMDRA8KhGaEW+WroNbZ8l+MwzX4BbgaPA66nKXJG8ACVjJlYt7FIIr9KhFwRmCXdgZ71IaJLt/LaYkjQxugi8iqm/g6a+3T3FxzUMcPpNPWsq/9Soc7Ln61N0YtmiQJfVvLxpsHIJ/Nn5qq8Vd80G/EGzGnT90rxof/vFu2ERKY/atCgWKv56wFx2qO7Y6rCKrjX4BjDQGeIo4GEF28xcuQixUGiBcRsT1qrnpoc28feO26aDrk788wl/wCrnOK44h2U6ufF7fyO3yBSVzmxXWmxn8SRxqW4WCcde7PhAbRvx3MYqAzcI0mxIlo7JLUQIMKDaH44rD/ZouZpWK62RfX8b38zYtrJGlcDl0lGHo11CnodAazACZX+cal2L9XZHW3FiXRds10azRfrkaEi7OcXj0ed5x19EsurPVAaMNvwTQnSktkBRa5BW2Okmr9lJVyGfEWGi358Mtv4LZq7yfoPl3iaUQun5dtec6gYrIl2++GlaDIqTBVYhtjVuLI9TYbwYmzWcgDGjN6qQ7TmaduMMIDXrcRiGAO8u188Tkr/CsZYMr66B2bYOWgsRpoDWPlfuwpqfiEiyabLer9BJyjnhh1/0S5w7L2Oyg670qPmT+bt407jxJRHSSJhvKGhcOYUKZ9DHxkmnV8P5rp027jv5EGp7gSI6pId+c9BaU7KGpVUzr7wa04ITgmfhR50mf/VPvPOSXi/gIng/ojPOWkV/IvtnDe8XJJloRtyju/UNWpETsBAeBPhfcVS7PpsIP4DxA+qhyif7c8wq5DvwLBx47OON7uN5FqQgzb3tx0jKlEWo4VoVw4o6RYTWlgRnbtNg6Ekx6L/Q+y017J99UgFLShNSfLIPqehLeWfEFkRgxk6LH9DiICJQcGrK5PdG0RKS2twUzm5gaslZ7ymD62QITCqmhnxDeYnN8zBS49d5BBmRD5P+AbHh2QHQdzuApGsCxPYYV1CH5YR1Bd1tFFX8hIW3ul+1YcMxqADCbZt8TXs19NL5ZuwKb7mNe3K7mT6w0qHJpxcu7YxguZJDRYXJLxNX4xtWX1Ju/bEkH1W+4H56tUacBAaFleA36z0OUjYPIPhYTe/gwyp8edodD3HLqDjlT7ZYU928JgWE6BCp5NUH3JI5hvWFcf2w1216T5WzI/Bgg1vFmAEyIQopSUYGdf1EWFnkLIxEYmKXVlswH4bBIcqB8tKFVrJ0va4zkffAhA82894CIKZaQLgUJiZLRYxTYW1Zd3+jGfPpWBcIXie+SEO/cOge+9ATw8jSDab9HsJe7UnTZo8My1KXvfUSu5AW292hHn9Rd2Oz5p3+f/GSoumd91BDVV0eqd2PTxi45lDGIOgigEL3aQl6yQOFM5pV8jiBhl28k8/oyEing2yxB4OANz41zrSXw2OnIIECpuOO/b0iuCXiDzHWSr3ysmjUJgyuhB3A5W2F5xM/NNJJc8qzZfLA4zhLVMWHUuEHFopuiCtHZmcC5ajQkE6g7su0o9Peg2Cw9Qf41XPxYsmvA4RlnWQuOZTSfeu+Lfm8+vsgcnSi13LsuhizL5Wr9smXjZbWiO+lhEzrTWRIdolfAlxEyWwp213Z8HUyZgkvYdORRKf9JqtNEfJe6vfLV2U+LHVnG4w8878FgvmK4M+roJJsEVP9+xj0231xu8bgIYwKJ6wReMrlBVS/9oJ+v/ErfPrPJtkZ0uGOrfU5Mz0TRw8mLHXff+hmQFWZgZkkhuGyjNVISTqOHAS67aPyGXezSef/nainwAemSgQ7/+AiHhFKYoVxX3WfCCqA65ngirKMz9LGOButoPKs6RUppXMSsZluvVSt6X4RccubGm2vawFKbFXktajySNY5vBOq12IWr1Z6zQu/Fd+fgOuFyjIYyteewLXlQ9KdlBTfdG0WAldd7U/g18TVHDW6RsHs7aPyMgSjJ3Mz+kytZqJOwC9O/vYMOc0ta4Zj1+jDzrX6woeOaQCzLZIwxPrajkyTUzgcTNeN66iVemWIYY2OTGglFL5aQlEzKcYIJcUmkDAMX0QYE6sVi0v0/RCWx1hlbB7p05uMEW+5vJ/PId4+DHxrGwt8n1PE06NE1kQLU08T+3mC1Rqz65HpVuhz4AqUZU71XozVt5GOdwNSYol16tzMuC3IeVOLxISRJGauSJgZQ86ULz/AAJBe2tuW0UMIjfK1tu9n/azAUGmT28RZCymItuUXyZiLMS69cHb8wdMaXE4wVTSeJ6f5SBaebGlK7Hc1PbEHGGF0+AELjWt6q0DmWCOeeAhVV5A1fADewDuWw2blJrovYNCYzq6EEN0T/XyyY0gqVGp9jMhD/PmU8FnMx2JEA6NUr9lDOEhq6SLx5CwB45IK8F3qTbXAo4FqQjerowsGNnEyyr0g4gSV1ydq32hDM68jYG7Z/p5HRB1nhBhGRnv2n9wG5minYBK9qPPUvDhCkYWgA5rzr1B/uVfLaMoeFXbyCu/dBdvbOfQXIlDdZAtrqUapqfjIZ+Viw+kA1K22TvOZePp/6ljKOO8A4H7A04TvvV57gCP/3s8vz0bjzYNSOh+ssgJc9hNGd+n/w8WJuxnPfZ+JWBNMnSyQB+qTKOW+whRt48OsuSmj14R2uVowgahmMHr3gbdaPxrTmrPPGsbxzXkaA//kAw2QWhz+o0fwTEKkEh6XKoNAchXJfMrGXUH8y/B4R3Ue2XD/jmub49KFspEbhlW7GyaOMyWjjSFa2UqwV2pLU5VfVVEhbrwXke9ObQHKVudKQxuNLyrhLEx5WUxD+GHN2suJ/VdNL8l44aHlcNvp0XDfalh+44mY5FR882H01FU01bU8i7fVMfdQK2muOMQM2hpHj1V3C56tY+W/GxxtQjprcMSkCtLPEF56QRWNvAH1CSewXqTlw8ENZzk85TLmVPtihh+0n2qx/CcI6hGFUdraJI74do9ZEex6qMp4l1argUAp7puFJaeU75V0ZqQKnJX2gYspgApPPquZLrHlecDl/GJ4LYTYAtdm7kwuFskKjPNaaMJbpJm8zJfMtnIgmkjglub/JWCgXJ6fygEwCJdcVsfIs6prTNJYbHdKy3IzWW6TLD5MCtPyTq3QkhKxLImw/OHmxBeFZFzXHl1MZR0ShBfRr8LLgpaBaFls/HJv9bYEysyNcAH2WcvXbAALeG4e5Tpeghd7cGKCaKirbJXutDighafbAqj/rrOwBb7zt22AZPk6mmJgxYNO/zjM7le2vHVIyGbxiLRlmU40AuJGV3KYR3yrPhfr3vo+piOHizjV4yG0b4QQ/2565+NaJUF+qX20y9jDxg4GPt3JT8BoqQXTkPLPal8Ta36OkeyP8IBIUatE2nWb3flizeTqt/1H2SxzU9g5nIcDugwpvUIKHetduOhN6CbkunXMTP7ouIfytA25w7CPgV+iUumpG39oD6EeX7ZvUiUySLL9W6NBZR0yMZvGJ3bYrWXv0PL8ak44foDdeJ+IfN9pTK8QBM25ae5BD2fNI4jN55gaPcjzVwWoqR0mItjSi9XGWERAKqFJTxgrGA0/rGTlcyRDb11TkScQqUl6XbuOCVTdeAYD8N/oks0Kyj2HF7dJ5LS703JNpo457twxFG1B5EumDWsmIgs0HJlmH0TxndR4q0afK3gomhPPG938mFJOSmHgu5rWJof5wj4usr7+GI0dtSMfZp8e2r/4pWIE+X4zZlBihYA9h53j9ts/1Capwa2VD/xkQKlhaoE3K+4lsLANr7OquiHT5+7FSVfDlDwINgNJZHeXh7X1M4XGCrKGkyiwXOTm2Nm1VFtF/DCCUh/UdgpOMSoHqlGplLzJYLcHStJ8NZonJd09lC1WXZ++ZcMTyBGnpKml6cU4x9DUKBDvN5qvS2dfLs5PO+XvB573jfE8SKrcAGrc13LMUV9XDvHAJvZpV3cMrc9mFOPepRlh11mMx83y9r8fe3Axl+Uelr88EeJ0OyH7rHmYPPXni44xP6a5BrZESK0pukOS7MMJWOdmNcg7FC5MP04m/uSmhmjy0VulWnB6JKEMxitflEVThJc8pvQcMG+FiJcETEgeNnhuvj3u1se0+9AVDp+xHOSsBOXu7AFVvNWRQZ+roVNZvj+otJbm2Um7gE0kqE89Pyu1f20TNHMt51sm54e1G+7mYxivj37EdfHx+k+l/Fu9//I8nE1Pv+TE29C0tzQu3d3OBJ7W2d+CDtVNk7bt2sMVx7MqpvZ2Lbm/Ctx5gkN/dw6b63P+Waf7imI/i3VzP7uhvdmgjSbw6Zy3sOyIN8IWWX3BiyVi0nDFLItkqQ8TDpAHAtAQ4Y3e2dwAMxj0GDO9ow7+17OYNSyzzXH49hByuNwpdxa+Awq5UA/p1FDJiHpnjbDhyNHWNcrmAN2meSPoHL1qAInY0LFN5qRAB1jmpkDb5qsNNacVOumPckACwMDh+/8N8eJMdACEL/i4z0gw2QT8j9EE+iN0afN653T6qGCGJe2Cq9H9rX3q0NuHIpSCaXDHTj74roMc5pcU+XzSsY0TRcongmrlKNlS4j13PidLqe59C0q1J0Ugs+wzzGnpyotGKY1yT3vilssi8VnmvWSrNjPBzaU27VQV+rQeUcMeVrxOK5PJgnnainy1Xuz39vsLf2y+IyUn/9zr8pPFwP/OvlMecbYl1etY/PpCJaLx3jVPMbGfobw2jG80iRsvXc1PZlrWJvo9moMKidfkHiOf5ZYovtJQjsL8QNx60ZRQcFs+PDEK6fCEcMCXeaKeeoe/XS4w+8XeYl+sy+hVNSNDqF3fQGSrswIa08AH+MNhSgTCcEa2RWyaJ8tchIm6qCk1+BkHG3YaBewMUMo9jftDOEvON+NUQtUwCQ4h8axPqjzPk74+H/cbH1jEMl6ZS73NFDUePGz4CTu7jNGLNyunZ56bCNDshdQBwvVLWsfI2vMqaVjKrn2IfpYCQnfYIBjj+IZ8fKSqh823Q+5HPC0Pr4x6YdjqCOxG++CJT+AglwvgN92keviiUDPUU6mVVczcNwMCRpaPHmdXiU6v9dHW4OD1rm7hfpoaqJvbjICV0IVSnvTURh5X5XWxpzhx7QlBmJax1CCNPpou7Go8RVV+GFLyZj/cmp/OdR1FASzb/kJWY0exIljHaKg2IOkB/Eadei3Cyf4LS2jxUR8etWIuWnhLbASJCIHAWYd+uG3TOtXfy6+e3cMve8tOmiGBUeWVpZn9XI1xa863MzR+vZA+9FXaqPjYPN4rB+9dPufZQ550BWZczDlJXSiiAqfhcWmUeiUoUJJRKl4qM7cq0ExosIo2jyVkEqgReHfoues3gNgSW9dzz8yt4/npK0fOGpQUTsZIlo7dfWSJyG8IRrJ6aLftSpki8fEp+uOM/cEI0mlgJ0O8GW5zZCOjgKpZtBMfa8A+dxsL4sb0Vs9mdzm0olfIeyeANhDDsAI5SMFPRJiBqPhIG+Wj/ii4+l2kSoQmF4ynUFlvuzuQNBJpjxAM9N5l2qL0t5flaHA6eMaB+bxTHmLy8NxYuI8aT8luEhXRA74vkGLdXcS7hmIQHDLB8odEJh+wEH41vtYlgUEEGMOhHe1x5zMCHapIuMtNW8tIkUJ5kXC4VMAb+XPDqZv0cEBrTV4hk06St0M5JeITQOdGXOKjOTJf/OXkei2IYQUvG4zziduTsKVFCXNTH6VyTL9YJy2qgpE/vu7WEqU3lyON6vM6IUcnZDGT2mnG7v2Xmb5dzvTEb5zRzkYrbmy9SasfbrxvQ/RiZdIDzlQXeqzpO1roarByk94VoPl15VSwjf+oflsI5qDb5radoubr+5JVNRJV2hjeesJZFHVBcaFG4qQ0QrxY7G4VowtmK4CIG5m29MBneITJrA8yKIerm3vL1uNTVBpmj1Le400/zXDRfM+OXqxbKeEtTwO1I8+aYB2HoL5qlKhKjXB5MzjKs3NSzdJQqmBFb3+zyU7qR5aSfkqoJwXjbblm3dQCorwOgiGna6ZvP3nsO4JH6iVhucaPOXSnOfd2qpCTY7RoGqWAB1mhiMJOB3tbcG1n1ZGp2EGlO6GZaBEVWbulDNG+zuUnc4uRKZxf/pd4zNkf50lts0uC3dR6AVc8zOcZTh8TnmefXsot+Qwobt3XqVsG5CrwSqE3/GdUmjpN4jnqyQrXgGAf9CDgZp32g/hpd9g2b+3hrJPJg8w+zzUNWkI18Ba2oPvW7PAHNfSElknr4VzoHWo+S5Gke3UgEeZcT18mKUDXVB7KOkiJcRIuzwsRmMAEC3wU45+o1JN50g8YwYdEjrmOqL1RpBOKiC7+HvNXQ6TN3yDT/RbrcywCqryF9NdNhCjm6lwnMXYMySaqoZw9yFYj/PgA8eorvuvsqMW22eblacwPzORbMB6UXU4UiZEoPCCr+ijffBo0Cn3vMDm/SDn08YhlnFM5M+0i+iTgfmjGcPRVp/boew53zRbKbB08l7vy83VRpfi+KX+O4dOzEXWp3v1oZ+FGatRV0XRgrZIcc1LkEQcWB/7AN86OjRIA7am20jkH/CjCKP+r52WL1t4K+dXnsWC+3107FGi/lDQGZi1l3vdfTs8zGBRPlpg7E5ZOuBWU3bBFYVox9gVBkAnlvI68AEkn9SrmBvu7EYwTN91ONeDbKNmG8f8CbGyg1hK8bJ785e0Glu5o8vRn8gP4wgd0b+htylR96Id4I2Z8wWlB+ebvuUQcCDGO94yz+M0eXmUfgdIeOrz9pvcOQ/jszsmlc5rwAi29cQqB120kRGy1UNNBA+vEc5hXMSwnWIkB9OzfaH2GrC4bGrPIT+q3+i8MgDXfUZcEBISs8Gygo8btYjeRC8fG5fC/HJFS+uFeTDKA2Avj3z+2lO2z2tWrl/xSMlRzRLPp/VY287KEBXDvej4yllQXPKeFGouUUFrgwS5vNMU0xLTeHiU+8OlhzD+iX0SZvj3oG/fjW9Wc1LaI7suzULlwu2hX755ABPS5L4kAmZxTOaN8jqb0TuIOWooACtsLnLZCp62iT/wK1YeOp1/QgrsHbYo5ooq/1IPhBGkCiVFnrxZ3/axMN0o0YdLumDGUfDjXOj3Un4JzflYviSTbLHL5Oe1UY60d29332itstMxGZ5ymYzdAV9lA07wmSRRsbBynx9tqaz6YrzvLLWLhLwtcTB00lEBXvTcTGIFF0Zr6bpRsbw5MYeOtFhx9+K+NBRjX2POVJWu4mbuUKH9V6UneUIjTDx5bru6Yj3s4yS1muSx9l4M5TClSDL/hzqElH5GPcz5W61oZvtbhQNpXmz20bULQqhvhAk01u+t5gXSh9toue2lUnA8KL5rh/EBsb/Ssk26nKmZKKgcYMjzWiNLK32sRUAZszRunZS7kJgxJ4xZHlj6rlUhZyvz3Iv/SpD7Aggcr8V1YnEIjTHqdeanJlIAsm9JQYT94OI0SCbU3l30f3s3b2UNcFzPVhC4QqEO+vmj5sFor/t0nnBuRjwsz/+HvNzUpktI43Q3L4XfayIlSPQ+Dpo23sWkNf9oDRcozRWnY8YhKPR35oXoSx278K9HXT2GR4fBJVq5KXhGl7zN2ri55f08Ui+9CMKWpg1xHv1fnMjn4hOt7UgneRlN13Mj/YKJegMk6QVSU06P27P5Jx6FzjwCS1XWii+OURmQNN5+Qn1dSmuNwHT9rIrBzOf7BPSsHXHG7dlhCGfDKkV8XPjEkj/aOME3e92yHVG2RXpThwg//md/Mlwd7EJYCP1+kGkTQjV/rrXIwYe1q5gtvuXmV1RM1v9AG8oFBFNDRYKgCNy6P1HZJnucFrpmbXEbrPiQLgaGXMiCjSDpzP9vyA/i/Zm6Cw/RjmCkmtDRINF/IdLBZAiBIP0ExiasYYY2sIYkNMdGrdBmNdEICPW1tsLIXs2Vs+m1D8VDuIlY2qzKFc2rWLoovf9zuz5jUHSLlBieE94eP2AQHJvo1C5SDaOsw4jahM5kJT+fb2yLyxAYg/XBXDddlfq0bTeks9OJM7MQtVG+48MG+wzrHDKfPoS33YP2w5z2UNHUYkMr8ofWV3TcbNGcBmDT2pA6PZGdWJcs38Q2X2JxYLQdcQhwZHXL9eqSPS6+XFVsev+4emdPVSoWhamvCfDcldVqXdo21fvFAjrW5mZOeVXhrXJilUUewxJmun0CEsNxPjdxQQ3b1Z3CrVUrYwY4q3Ka6aaZ5tP5Ejnl3ee7ITlOgRHK1+Xea3Pbe65Hj5bGqD3dUlA016rQuxI4a9K9RQfRf68biG2yygcm/BDh2FPSpZukkipqR0/0M/epoqbR5vTr2o7s5+fHrb+2WF/b7djiNY4dAx0sNHg13D+xJryjaPqnlgIqGg1RE7KLFYiOiD5IWUwVOe/nh8josejBYdE4hyYVT78S7WhCdsufJXQoUEL1lgNoKOue3YqycTqdCuf0l2+7HHDkU0/Q9ig8ASifKqWQH59offhpX/XYPC3h+YRPVfMGN7gYD5JZKIn+lmA0XZ6R/YiBamlPY77xb8ShQLD8xfz64d/VUbAqzGXFSOdQCYjyWhtDCsPycrm4cvaxO378T8gMcMpnmPl+2Rj4LunaRs5XK24QgpfNqkRB61l+KclmN0ZqiJKDmvyOw294b6LABNhaPn2Lu7aIm90Zch48atBOe40MvUULpaqPwavjJw9eoGigp/fiLyc6kBQAKWcOMaVDOQ5MJsSxuSEUYFxbhwuH5gEAEk9uLuME+kMwd3iTEnv3p+05S/c2DNhok9qpBH465gXlLLelDiPwuPJ9m8EMxbvJV/nOUf0VU3PNxuaIHjm3DEPi3Epzjw0URIcFNm45wgJCzL8PewWnEo6TuYP8xLYgCfOmUvBmkZWaGB0qJcIv3pcNz+FWsx1ZSLI0EdCEe9F2Yun8tGWpPkj9Bq1DOwW+vDogaSgoeSyLipK9FKZQnoBbNnrWqMj+qRNGJW/0pB3gZxhG9DxEyHSyVT2Zdfp12oHmo4SkzugbupMw6RpG2OMCuZ8xw4EhGpi/xY25tZTidjL1itBZpojutMi3l1leL0r3a4eJksvQaNdp9jsYuPJyJJ+JeVu/TsfMxQv4PnWi1k0E/dbU0K/lKfpxlb18Ao6H/mCkSAgLjHkC2oxVIxEgetyl7GKANH871zkNd8JlJwaOBv63eeM6WNo9VgoNlj/Gpg08izNlWg24I/n3AGh4sQbBR6L2m/PXcpqe2cbSaFvkbwijyIEyIjMdveKneO1wFyXJsEZFy3NvNVv5wPVvwU34qW4UXBhdbevxq0o/6nRTJW+Mo1UZhCJkbX7SqTVQzOB/F686ou5wkSMtIv/YWNsA8/x3DgVwWrnGxW/z4QWrPJP4TRZAedNV+yqfKwexqlc0FHz4y9e3DAmn9IfPZjM4iyWHU8lOMHi0KboPlKQSbaj3z2ZroSHOVblLpbDzZ+TIkGPlRbv9qbSwVD5E3bjb3iXfBf+XyJyNmh0KkhnUEUJaizKDLuDI0oFer20FINsdCgY6ycD0aHOkFeBl44dTXxmwQXg+RVL+mnndzyBMgBz3xjGEB1/a3RfZ7QxtT73A/9OCScK9+hTtR8vTOAHxIGX6hrKDo++ITjyUG3EEFsm21zO+gMfGRWnKoaRnVTe9A4SHr/dlo6D9hEjb8dpiS34m4Ss+MKn6cM/iu/9g9qGqr4NGS1DrzLbap4jPQjdKrJ3F50uNYFcDhW7V2li2YMQdNET5+aqOdoXZAGW3Lp31Y7prY1Z4iF2CM3BEttJ/6OgE4j++ehX0Keb3asMFw3PwdSqGFHGMtXtuOdH7yYHSfbar2B+juDU4FnI498shCg2FzIYVKYrwvJYtT7oT4hUToieByzIsyd7trxqh6jelLcVhUXlwVXBzZU6gwrSWWQBhbfSww08Ch6p3mnBaJMSHswciccOYymUrrfH+WsH7sQuEvkANexRQpSpXACdeqYYH735+yDopI6wd1yaH1Nj6sGY+++Ra/nRyGni5RqT8EbnznbpXXNgfZGrlcjCII9EwT7xa0aiWBfgA5ahPHBWMQT5GvNY9QblFyVE6cj9iVKqPLvmEmAr74I4AhgGU/0sHKqqvAJSse0sYEFt2Aa+YBluDb3v6fQ0cB1VuCEKkv9473vUdjgXiLJ1trQWJ5cPh7RtsuBfAhsufbxnh1UYhFpnzExN5CQRMBjLlvWO7azZ5/rRCRGeoP0yU8c3TaWk3iHFfY0+fxDXkRV68GnMek4Z4b0KxV+gB0SvCIsFHONCjFFy/iDSDaH681iLuSilEiSDuIrKGiSLQE0aMqOSCDQtkfDnvdkhwCceBrqcEakbNFwxtFivytOUqORioqGtm+cgJxcjmkVfGG87GLZ+C4AsrePevmTXDuyzkooWi4IMxd0tjT07BKMevgwt25nO+E1pycl89o8kzxfkmSbWqbL1JYiEitcQZPwiSrgz3+OOBm+Dib44WgeH8co7AT0yNRfzoASEvGk6ZPkwki1MCmgK18WTE5iBKaZXqNkkEhLdh0UWbXfz230ZWodl6GWG4mmPfqeSO2l1Us3zBBHRtC8RGOGnBFQ/YWKM5RBNfNQk067kQbgwgUUyOPpFZPsb8ZSNH2FVaYu5o0QrWBatGqoUFp4/hQxblyq/bUCSfW1OTFc1xBF12Fq4CAf+U6Bu+cta6sDS6fTefouJ3Ox9J1VjLfjoso7a/U2drX48/nAmS1J2bOWIUC1jSztgLrAXeZqXah7spM2o+eqdYh1ShayA8Siin4k4Qa77WC5JhFw1PIapuxECt4Hgn1X8XMNaNcYT80rsRRsl1WbFQrGj6w0euWHtm4sUPwdl04Tf2bD5IDIubgpuOgaQml4Oc5jSi7Rti8N7epWCQK6RSPIIUcs3LmpVrjS64g7WlKKzTC9oqMq+B8FqXGMxQ3eq3zSS2j2UbrB3cQcoWNF50T/fTacaXdWAOF76ZNpb0KsIsCq3jGQCsGTYh3JvH6Ud2qRGkJnXiNxRSVmlW/TF0urY0k3EOCKlpS2ccUeoRUpZ/jvWfbkh9aC9VpSlEwW9SaSXLhdhywpHoMn/Kitb121r2d7nPwEg/Yi2C0T26amZOxzhFNvV5SfaIZ8oQiWRgEm+4XBRLWraC/shNkk2aoabLijESAcA+L+y9cyN0bgjf1pS/lVqq7QvQwHPebESWK1jtTebMxNejFPD/TKoBkQLfeH2LCx15CpUlaeb+Wdh6omVCwj6Kc8XxnWphiq8UafuD13MuNjrlXg2RrAWEY5vr4SFKNItbfEe6ARlu2tPPbjvMyUgCz/30wimWp2MhUIUiXtJIwWBmfWBqZ7fGQt5jfThzuNp5abftJi0uLe3rPpKwjXCNv0hV0lCG940lChvyeHaQGWD9h4U4GMUe4wA1QwS3z9A5nktvYufDSr880I84WhnVcSdk+Dt6L07c7wgFnFAmWKkprXHUi6fOIh3WwnbkBCOoh8gVOWOQ3G2YpbR+rEmyhPKtaBH2oRy82hwW/LdNuoDbFf/VjA4F/QTcO1fI9yzuCLjqV5jOEinYVm14JWXjWEGNNtr8FWTcpyq+nQ+ia4GviwrlZqrUn3N1kQQO0YmfOKayuHDBJ4/2IzD3rVxE4xJZI47D4s6bAv40jd23yhCGPLE80SzdVtcE7AGLtsbMgLUm0Uy7JJWacl4LLdZQc2cWMfDuI36BlHeOSbxB02uL1sZXQhOgPu5j/Dv74lYvpndXy0+p8Fv+ManbxHzD/G9W/gAGjtoa/G1sueukqmKgMcWdhtGWApt7lMkshpVRZMhQ5c/PIOccm4Mbces0hqtKkMpuoJqcR15p7h6Zv9ssNSasnm5Nv8LePMNfaQ7tjoYk7yX10IlSja/OWPILAOhX5LI8QFqcWPGvdMXet5O4nSY/w5H8bDQm522S1sUssEngB7rfvIDJLrsBhOGUoAXENbuL8cAFZRyzvwRfcwdNTwcZGArMZBfU67zIXTVgeiIu2s2UlEeir0phNAs7FObSw5gvh4OKNVj2EM5VFJVK2Dw6wR93Yfk5dNULOZspMxlcjkwBwlxbh1bgZpOc2hPTyclnfAG+0Q72MtTAAu5uaDPwqtXwrq8p4aiuzj4i1LTYv0WDCcmC+Kwh+9X7Q5QHdmNr+lsZrbFHphwbV3Dy66zqfBSueQpfB92ju/glqjAhf0Ljl1DUe9ZL+Nt7TzbA7ULG/bEBhSDLyggCdw6Y1SxI7pwHTf1+QVoegDgFHIl1QwBR3my6TUVFYHWPwVJlWttgGxu3RIwbghTt6JjRaOhVczYLCVCuXgQCQI0E+2a4hS8bqTl3+2y9dNjZZsCrB4oNDv+6rKYb2/GbFS3RV+iX1JLuwNqa4M5FpUZTIQkWUk2U4dmyDpYi8ae1VqxRR4F7JKig6thiw8FDrq1cQYNz9GRQxk3PQHTP0hLPy7yFMyDKiHSptfxQLKP0u50KgbA4G9FcYLuIQm8xWRX2r/zDaNKYrtvOa91SduZjuqTjdapZimf3kbfn4/WdJf5pyM29aMzfXAwwAIgcOxbbB+Srd4gfZkVSMuvqf0COZ/BOADltmSTFLN3sBPtVKV0NGgmBYQ/UQgAv4nelu0zDWrNGp2SUlpi/aME7fIsT8b18iB3JAkIPNx9Ktft8LiTXNz+Oa77g4mgDvW264rtJfYane+Q+paM2VrtqTgdAitA4D2cYVI2SbCt7VUMLD5bNPaqo46BH7yNEX0ghjPS6D8wv8By7ZNqaxEwThaZPXsq7VKEiSDDXgBV2Dmct78jnPo2ksP17Nvwia0nQdH9QemkAFF9nYUZBForl1AV+t3NSN+bCIf7qO6lbJRZy5X8UkRnu8Gp3v2WjAg5u9i8XbVBfoGU2UjY6fznkbcANUVzPum4RmpXzA7RpeyQ+N8o8xzHnS+kAmLF/fOHzs8AiP7y43cTMUVaqv7NF/40QHl3e3dGMZlFlAUZBtdQokm2/+W7DkE3/wZEux6f4rDroUkrCw1pa0tjpgvpuexxz3XsSDDnXwEpQ6Edl7Q8ghbd/mygmDMlzhij+MWyFs7PySgTIMBMHx1Gw00/TIKa7nFCL/c1T8lXwR52jR2TSSZX16E+pBREsB0OYPX85Sw4P4Vn5V3swqjfA+NafoumudheHVJdpJ8aGrsEZEJRVJ0HiF8sfhpLJ2xZKilH6grA9U3Qxh1cCRSz6ceW5yAtZg0D3xxO5120PqmkXTFH35Ujw2nEGNWkb1iZqHpHBViZfEUQdBIwQF7Nmihfu+rLUYJje7CG1LMCT/tL5Zu8MuuFUiph6zY4J1wqtCiUYQEwPu8JBokPLrCFFhSqusH6u7CB9QmfLuOi7zVzagvELpPBaXSXsEA46fzaAJukSlYert1cymDFqge1TSr1KPAlPKI+m9yZjQLr3k8yIHXQ0US2D8Cv326NmVdevLTux/Xajq5W7B5BQbB4J83ULBxTvcdJthZIExGGywYAoCiENrgmnnkTSPn4ScR6rO23bpKPCoHHc2ILW2v0pUjU8UdckywZ8H+abinXASv5mfh24Sflz8q9Vcio/Z6ftleXsDFQZwFXMatmj6MMlH4XYn7uWCCaLhEes58Fr/UG7Bhan9vMHGW0X5jwylxCOPP6Df2o6wC2d/OqXqg+rOQSADU3soxv2Jo7B3+IcaKF+BWMERK93dUtZYjnBqnOsa4ZLlxc2cZHynfFPOkt+EBU+xQBD3QGOAFZJ2L1HQjgOV7oadUi8AmNDjXAhrA1JvbMDvgUr+NnoUhZlzKJoEEbrFxxDrcelGA+EkQgr+opuQ4eyqLKTCW4GhJC5gfDfwyd6P2GivQWdKfWjSlIu0OGNGyKCAcW90XtbVkrpnh7wKp5C15WOzunObo07e9fE6DC1ZDgWR2F4siCp5/zQJyfoqMDISrbrXIVK3lDozWggGJj5C0Mnpr85eWhhwBpzQN2A8pra2Yy45CpJgxIUjeu6QwgskzceKJOCIE0zNdnwHo5HLSAV8riS+0b+Hpv7KpUj13oLvoHPJt7A4lTPsZMhHM/duJyudVjl83/8o4P48lqMPM9y9uGK+bpYO2Xvz8AW6idrRHoOIRF+76UKP0hozf+FSB+qOJF5CBBXD3CVgMrv6HBt2sDPTldoPRGvMM1jAvyVvuDXu1yjxwffu8jc08IbHiNmHfSCmkpIgkaAOe/fXluR6nFo+yr1TrTQca7RrG71BopiV4lM3HRffe7xz2Ou67UPygZE1KdW3zlg9WhOO1UcFbJ7forlmyiuX7VxVfteZk+HBKtPuajXnMToqBuHb78l5fogQ9m6KYFrEiUwAFAQ5r8Q1qBKSbhb2mCq6zUHJuibA18R7sK6YZIlMbs+btq66tDoYZaUvlcUkkVrZB5L+Ea62CacmSYzPv4aVh0435mhi+Jax8pFZbQQIPW1jB3xe3/NlW2tq1eHlt12/kJU/kGZjB9mzc1FvKJMrzybD36Y0G8rW9j58KutqArQCdIFZ7dpK5BelxIkmcb33FdbqX2xpaEyx2gJdv+sFpyXZTto1ZNFuM13YnxWekc/EHqJmxStUd0DeHu4sVZh+Zu24g+iinC8Xi8+fHp4fX0lSIqlvSVxKtpw+7AsYrAfdyxGWvpVe6avwXvwIOgNwzltbk9MhAJiaHdTSI7w+0sGppQIqCPasM8ZdkJbICrc0wFoCfDJKUw4C0EZmzij3pRz3HQX+Q/oAeW8Eurn7nMDR2ghiCzRUFcc+Lyb8V66PMzGGwIyMz1a6pyxjvLOxLdVwzyVuK0X6MB5lEkb9IdrlKREzT6rK8FxDsQWZWIVvhiCuZkA3i3M0kI3d61ixBn85P2QClGDjoMtbdExJzFQaDbN41m+1GjzEwEDsO5PZUfCIg2mF2oZYrQO7wMDJx8bXwq/AanGTL3Ee3S7fVwE08NmRCjsLTsGivnejz8ex8C6WuRqnJRBDHumlw+3AX2bRFrSB8UUEoayrWp36YAfb9fxw8tFleTJBgPCcve6rV64CUZrF1HcW6mzwBd29VvVQyKjmAJksxl7RZUGn65F3b0e/EI70Rgv29m6f10zid3K1cG05JtRPA74VKj0vfFsEvIQETvMnEFhabJubZ2CG5JqCnUUy46wnxTx38wY6OLOaRn65uzGJ4s7OZ6YDyJaDdT7GEtYYMx1L8mJXsBdnax/kyEFvUGaoG+5HharcfOfn/tyCKOyCEmn4tvODcOtZVeZ7lzIdrCHIkm4JDdmcEWQMLpDIJK2KH1E4BA7JpeDOUMzMkk8YNMLKfpON4NiOJMc1uBNpwHiTm5+ni9HdxB88sS//qOwTiQXWonW8I8LpwWpMVpz1pn9oVyzjGrCHIzF1AARuwQomaD/SRZysAdDazCoQ1HnB3EJP6l2wh+kqpJWJEDB5FT8izNkw5nvtoJXLwFpoArooaREfKCP2xpmdBMsb9ZJD+kpGfV68sWEMGFLveBQIdeg0hPYPi6PUTVL6hjppi6cb1as1H4iybwzrCNUeepPKvifxKbl+RumABsQ7FkR3tI2w8khYm+Sc7vgaKtH+PmBAy6V8xeVeX7GUiq40AYDKDFvF4WA10oQZtpIGZYUTagb17WKNpxi0RWPSGDVELt83jdzWR1ongsD887hvNeIhI7tKOG4rKKXI04aCop+GG6ywC82iM4Z+WY4LG+4X7baL6g7IaV+aY+xmEPrIl/YUkJkRnSdWc2yE+nlloMq83LBGU99sV/tiUtPpTOXSijQd9THSSs1kj7E9dYxyZBoyKlj4KJuqkZFkRTUCGoBOpCWV5wUPn5WbJR1JSeaXDlonq+jMD1cLd4JI7oLoqaR3USaWpXlgaYbPc6mHrhxu+y/zmEVFmoAOOLz2XKop6XKqCPTBpiqhjK2E9Y8V6A7cGnU/H3fkmwejjzVp5d57PbMcq9RsX01A9lTuP2y4O9fd+W96kbQZ2r0fxoQlM3OZTPau4uFlWkDMSrqdYrx8yOIY50rncWPHJYTsym0iQlI31oCK22MW7s9Fb+EjZF9Lw89+7zfz64dOzDdPpLk4ldVrDsY93DPWKB8i8x24BGZyYDIXKAP8C/PETSfD6pLaU6AQBd0kCoRXpD6mz/NDjAWSrVqnxY/wis1ARcCDKz/nofi6PGLhSdBgCZ2+7wQH1nvib69+ulljUd2GbCGCTMUoeiOtWQflB7TQnBFU2FDUNBagP0kzPGbuXtOuXShzWrtok8Trb8aMPgfWPwlO+mq/4reqUl/o6ElcBrQJFgUs1mUpGlKDyAxRIyi88TeJOirqS2rbAf+tKnNeDSkd/aUZp9qFtW0PVeF8GGQJyINcYKLNMI7EnG1gQMWOsniF8hIPdN8YctrMrfXhLEp/Xb9YKWYv8PD7WFZCHeigY+uhdid5m+mAx6UZUziSCLZ/oCWQwoDAGPntA/CEMPUjlBEwtFZsKzbMR/wWSfYwvW9FjPBJbO94viQ6V6CXpMx/VUgbVw8Fq/BSaAYDb55gbMC+78OUdX5lIAS88eODdXH7k1kZZZxA1lRw80dKxPWXjVfsOniU7tw/IIs9c/iLtVgkzvlUHUyYgHvzyvrl8xgOtUMnlSs+TIk9o5kSMRLFtPqRwhfa2YiOZHriitW9GT0jHAT5P5UfjW5QkP6M7fYDZsrjOVI7p9kH0HzlyDQWm6/vK8p9fBvBswJahsoP0clgLsb+zNc+cqdJ5mFti5ADz/mOgMqxM8Ps1C4h1EsAPIF+QxBJVwoxOeEVRV4+HHY5bpbsCMRoClY7IZJuvCdRIpwttN4VT4wMi1pk8qD2cgrQ5YTfDwA9jmoKfCmMo3f+qGmYNtVlMV703X6QD32sme/0MJuWXfIL9YN0uJ4ajzJzvuA828xsJknVnQZhxslYuBLsb7fwroffKYnkTGi64JEXv46ywXyRFOY5Jo9pn8xAZ8BohMy+JjSlcXnY3aFpDmD1AfjXa9xk/RI7lT/eWT6vCf29joPANQszQRf9sbf7VioFtM+SgfATbJIePzCF7o1PvJip0+fyAIeqPUDyLWqoV+gB+8gPC8aRrz4jySVIzvBFsaru59KaXCrTEHp7Caua3I8XQDN0ma0kI2xk9qLqVBk24NeeVUDjvYeAL9m2wVXmEWfY0E/utSOjK734m55BrarsHcmRU+1V+p0La0Nz2kDIpxtLCOh16ntvd4eOz64wkrZvyNUDqSqo4LluvIADz6KVBY6JuGM/TQLCfHcEDJHFfVfBg6/KCFgZT/0Hgupj56mtcV2Hjp/IwdWu6p8wbt1sasVBe92abd1KzI5EYlpMOUdePrZmV7xRlJJKgOv9KDYpTUUrSsad/qbTkPflu80jlQlncUgdvEkYcuwOyTCULgukiWAc3NFKn9Rdh1xyXnktYV7JPUI0T3CKvMCvnRtcQtJ7tyCzUGMC/ShGEX9i4dY7vjEGdIQ3NpGP7e4DLRaXsbSiAEVMXvBTwO69voUUjYJ+6Cjr96QrGmqVn3fi++1W+IWG2EcVSh0ZrgqgpkGBcyPOdzxJ7FP2fGk1QyUWH//KtamdxbXQH/jg+ts5mGQwviQLSxVjGf+SwJYu0wuBQHP5l25Q2LoUz9lcLMLNEAOp9SDmpfEjYLwFanC8d/ZmeHD6MoYCEi9hVPtxRJk1ExV5Aw2tZElqewb1Aa/H696PZXxyOr/ZiJVhF4gGda/RoN2C/6tpFndhtH3Qwa/EtofVNMMwsVos8vw9+oItUU+AHDvc1Lem7+fcY/tw1WgwPitVLWoOO3n/v9V60ei3ckf9wYeJ+EXYU0IVZ5qlR0wRjUmZH4kDvlNXsFqs0MrPCW9eUSgD3VYMjJ7FRep3XP/cQEVUfohEsv70sfhzZgdeqlDe905YIOD+ocPn9EVZ4Gn5cCZT+KdxEbb5orruEsJh3GgsDmD2ERxx6M8DrN3HPSvbXdYJcJJIAzaS6j/whgVU9v/BopiwHut5SzNOlgXEIKHwZX7r9ebcyZH6Mq9MaUbxdUWZvtVqYXomPIzbQ71iPLzBHl8GNgF+Il+tVfVzLSA9xbUJzxAdY0qqZhesykHhzA9kyp0TAkDE9fjPvq/Ym+QH/24E6za92Y3MOJZHWztU04U+zLsJDVEqrGyQOz1tErHzjIgbRg+R0ohrJ5d7flbK13ofCTBcuGR7xqeilfSShNhWHIwa5V++0D0V+CQciUmuIuWtnKkOrcileFFHefXQX+QN3hoO4wglbMMJrTD/xPi07M4C68MnF+hg2X3pmCHvaYnJ6dtkgIRPTl3gvkBtNHOj5IK5UBufhj24Ff6vp7P7QlPimqttC2SqqYL7p+P9z+dji3xdpFCAXvV9PQIHDdsYVGKuJMUHRgPfHMSb6AdR3U18B0brVTWqJoHA3rlCLeK7XOqIkEajQtvmT/NHqIllZIVGwI1/u/CplGFwnOyXp26S03L+qIN1dYncns789xgP44T4VrTewqtq5EGtClxsvkk2HXpCkVmfXTjxzlPHERSbnC1Xqy/xqX+JUcuXGD96OG1qOo1qybcMbDq8GCR1wjJJciAoOeknuetdctD0ZP3B6Y82Qf7avcAAuEYGISKa+q7L+lS2efXcxrMjNBIf7Xq+ez+oScH4B/6z/M+1N/DeU7OVFjovxvrP2SOm/tifgJeicdXox85wxfQWrQIxwpe2+5z2y7Ncrp57xFBBZJf+OF19L8d2jL0V7xoYGiMQgdWpCD6NPlLpvrWcS+DhRULxaK3SiaiP1XfrNkfevUD9Yfr5x8tEm81A//MLPyb4SNAeb5nCGN8il+KknzsgQM+xS08MN/p4B7v8lX6G4a6CF7XXTdjSDeJuFJNXBv16QN0+KSq1JFxEdKzNsIa4PQ6kE+iz/6fYvz9d7nybV3gotnUJ/apf6tykxMrXDZKWRssUzjrSt2tQ+NGk1H5jFgKMiMrsItIdD3fKTsMux6Bwk6x+5QRvtH7czUauEtr0HoNC8D5d5uxxgv7pQmkmCocSCH9Ls66VcgMIQ0Vh7AgqwTohJKPwbpvAvihM4FRaTuqPvt05odvkyocv5fY8ZTNOQVXFwh3hcnFuK9uSaK75ReKXi6/cMU7zem/6rMdLpNRZIAYpV44IdUFoBYKK9gOPuqovqVwHLe9wbYKMxeAzx3RpXVX3lKklWdkzDDHP7T0bQeeIflPru1rPUgYBlGYbKCB3hJ9jTbQsFJtNsyWubFSo85RHncVYJOr8vDd51z6YE8FZwSxyNQC4bZQoX0k6Ph/Hd8a6Q90VJDT51HSRcp5HIhdOUmUT7agJZK6mPOI1S0Y8AdfH+yL19qHHEdqQjEjBR3jBO9+bdlTbxsFgE3nrZsvQnT2bDmE+gt3eVn4J9kAGslhHb+m0BSIFxLLXYvjcUBKSXBZk4zzUXQYOG6sdXIc7916gGrZCHaKqfjnKvcjTur0xDB5yyJS08anei6ZPU4A2/NNlpciWiXJjQPv9DsXW6DDXi7Ox+FonAu5489qR3FgnI7lgvwcy2obI8yqWgRppjNiki9ojGp6C5TGOBJSx5fUtDCEhdPBg5W9ZUNV9u6UoKDkIrBXf275BOtY8Y3SkmPuMVpooOpjL8tFLDobKz4Fm8uy6UURCST7wC0jGcNNQJUPix4nyWa9wDYExf+Imh+u3FQHUobbI3XFqoyhCzfNeZQGTNKyf1f7AUGFruRV2go2jV8aALNG/m/z1gW93ThL1ZUUdf3o/OEd89YfecIXj1cG5jHVb2Hk3ESf4Ggn908hm1rkpcui0PwF1wwdZO87U1q632n4jaA4/Yz4j7cbUOpGIoEk4jrnhrWquu+aEB8WFzkLKD/pta0TI3O86GMtizEzuD3CVRpiIM+mmB1eYrdw9W9Pu+Li7HZsTcVagQPcOzIR1n6a+f6mQ/emXKXicFdv1jBuQtiCLhk6eU07jlmeXfUO4JEPtjA4+kSxKEbuFR/5JvwuO7hNDpPqiMXnk1F6wFj7CheVjPVFTsq51WFFm3GgpavRGTeHjl1iAk6WtQb5bohQteO84tJ5okB7sBfgHiar3nH6ZPIbv9YGRceOvydQN1OdOb5UIhY1/aat88q+mJ24uTm1rHwl/p+0Pgv5kDsXsyIMsptRQCZ52vVvQainzr+uvkNQ9wXLkq+29pUUzjsbUqx+je7DPCH9+Y+mKxfONNyHhHz815j4MmVD+ftMCtRcKzHHlitJ2KRFcwgUo7DvVabbyoUGZW7R7M9g+GcW86n9dKEuac04vEcrDcxZ8mZM6sFFbGqzZC17aRtJmig0/rDs6Y+bNRmMOD/1G091KJS0250b83O/N4Qgtz6HkHNr0f3VReADzWPbOVnp2WMB8Kr7AHn2r0dbMkhYUeNJ7yXwIINdvewMJI2bGxSHe2a9jhZqDyqFoyP7E05EO8TT37FCHWZZk2BBls6/ByvBPbKc0GhVN1tiAdTYlozT1K/r/h9bv4mCQgB3LrZA5B4zoHBgeWV83DRFxhZUiHRZrAOhHHO50K9sW9Gi+NnH9IFHWD5tkK6GRK85GBavYMklg1Tq8BJg9Ugd0rxJjNdpHsJJAV1l1Dra0mZ4PiTjldereo4zA3+iyh2j7fJoaXL4nHyiTGwWEhxoTF3h90ijNgVzs7oIWCVRkP/6j/uMabsQcn9XKQXK0EuOihA2xHgYVZKsTH5SJWUuI7WIWGv86XEFLO/+enVVarUWBSOMfNGlPDYhgxm7qBii188U/IbRIpB49LawQsb6EJD++reqhejg/jIcZzDJhouFvJDfnbDn9pd4IurWtGeGXsamS7M7+PuxENW/LQKmo1k9qSl3WwcRVmJQo1HuwFzgc1ZWXMJ0XOvMn+/6ykSs25L4wpmZ5mLAv4b1hX6TvDFPPWdYp9AmR1pMraDPOgpOJY6BUkHbkxHvLbICarXkrWCB+GfxZ+eb7s39FXE0gLohHBHsXQmqxS3XezcYzZ5OkcAh+sAHsju1GNFDeZI/XZrCfvIn3zS+75p3ygCB8N11Q3k0jhaVFHdqq5nofkvLTutbWtJ7zIMr/mlk5U0NaJCxDWoP6/JEpm7oEGLoaRqzbfwcN7YX8aZUdSFHO+by6u3AcFpGu8zuHnrVtuvW7v8pP1d0y8tBioDLJT6miIlxLl8suqy3sVRhy05BVy6xs+ZCn2WhdZtQbgCOeZCTTIRvCiyYNvPRa/Pad9KX5gH+Oa4/yyueM4DsEP0DWarDVZWnUE5lHdBLxVE+zdkkSXkxQf+hvRtTOoK6oTIKl8nmYa/890/YKxGOFbV2AEJSE1Yal1EkSJnnct/tYfvn4DKj0lWG3KU/Fc9bvHpo2gcbqH5FpiHygHzZO78fMp6EBc5T2KaVMmy9Yuec/Wv5cev3k4+/kN2GhK6uB1smpQI16VaTvqNghaT/E0FMJ0K6h86j2tSLchDAUKq/dSkAKyxf2XgxDyHYeU+uWrtkFCBNCA2vqCG3nuIf5rYcVMiCYt61G++1bqygGyHD3UOYo9Cf6UiXIOfSf9iZA0Dzewx3gYMAlTgpQCl3aaETVws6KTpllfE0gmk8Mvif35VJSHXBF5fYYJiYcyG1+ijh3c4SIfYBCBsbKaepmHlon2PMYadQQxy8hJ1Yc0GpD8Pp+/QKEnZGUSM2+W0inzi1MwpdMKhpzWaiNWANZz61vn5abhsW9zkfzwjRzcGqWHcesXiQ9RJpIkMAALe2UjdNN6O9mPklkcJ/LF56F4NjwtFABxMgFXn+X8zSRT6vlaSoC5+6bZ+XI8p/GWmpMeo9e3y6d2aUvOuk/JsfSVVSJVkgcHIGpb6jy7lIF8AuPwr4LVm5rCNNixjOKxQbs9xxLBj8lVVubAf8ePzz5g1oZL7l3SFyEFB+m9Wb+1/70Ic5vR6B5p+1bT0fYdy5hHnvyy06XKO48pOf4JGboksqNV6EQw/qBTMJbdlhFrT6wxPHb5jrTSjUHekKKZdrDPcWu9zMS05WPqvA20BjyiY/Zs9X844XfXIQEaDfM4oMY6sy4vIA5vso5TdjTOifE9WGzSjpV96OOcQIOeLIQvCXqCs+2n0gugVHoq+h7ZOSZJr1tG3vpSPJbtXKKfa8hWs6h4dILna04kT2aLmJekU1djyp9rh7lBulgtVx0+C3Morw1kFWeSqhcGgs+cxsKuhjYvS53Qz+UeDUq0USJpmnJNyxr4wGMCXQg6wlPRgGsrKBq8q5DX3JVzrcAgpy0UyzBPMzDfnvOB+vHpEFNzmtAbo62G+AKW5GL/oROW/xe/6041/uFnQvt468vCIKWlc3vrXEJWSDj0vmjDWfaS7W4LQX3LI5AC/97DGMELFS/5xsKXRUJShhX3HcIaJPtOrYJRd7BwMTBNWEIwY5aXIzMR6zMZI4XxPo5bQh+oX4fxQ7qMUBM5my55kqW3rU+IHdVLh0LjNC+Av/9FmPUNM820sJCRLDRopdLMirR6ZftUpPI6NC1WXZqzdF1lKQPTbSSwFzPJHhWPAaNuXTJeMCcMlaXKaqYRc3QNfnwJe4/S4ery2t8vhVMt3hFjzyvIN3Dmcl+6mFln9aSA0rlK7UnvAF6S6PdsYEgboaA9oUIk1G4OZaBUOwQcmoJZCHRk4I3x8Yykh+uedXcraWsFEXaebXWy9R+s+QZio6XefOH9MvWedTifMSwfCCU5RTo8WIYk2PhrUEL1wEFNF95a/A69LPKgNNRdETNv7sNF9KiPSb0xgRnAjrAj8PIyjyjQkUhCB3/N0weBrpbUE3ac1TCzPmjE6r9xR7LthqoUD3NmYtdYEFoC/XcpxIk7uJWbQEum28St3+Urx4ReC/ly037acCLV9zGYRXUwoT3s0nycIEeFBcCrvWNhTUFqrJiHjBmttq+23yENFXKxHvo5Nu8oi9dkYiaYM2jfgaxaB7SiVUMFgQPdVEpWtt+GCgzS4gXiBqjRu2Mi7vEuPSrwHfFIP2QNRT/zqEpHMZlrw+yjAi41BJ0EvwoPEstqya/reh4LJH6MEzIGqTgekKngo7cASafrnNTIK6DA86gOLJ7T/jZs2EDdY7I0L2X3Gprx53NPEWeci5+qnKx++FQD+NqRZobYrzAAeUaWIDZRl+X3xdRuxCWayTUDsDNtkshgy6Ps9s5O6b1yEfya+NupHRVMMZcxSJVNT4IPgjbokWg4/OW+Dhet6sx1cTzFLgaxRSEb4WxQqXcKIwsydZJy3zK8kbbeNY6mP6hluW9Q/lc9WwKrMwweQuNUHJOJlnULyUfZeZ5ZW8e2Nof8XIW+LUHWLt5HlklG+B0B6fu7ZdJvSEzyDfWXB4H+iFiJtolhsxWwCPXICEEgg+nH8pcEXznJAlFEit2MlAYEB+mLHPghRGyqbCRMrU3R+dyqZPevr/jfxNemqkfimQLisaxYGkDyuRIn/5xIpe+AHxDJkfjlN3PKdBz24U2ze77z2C7C1Lw8d6kIMc8fPFt74+2ahCWQ/9n51dUZ2Y82S5hGlmm1hKqDRVL3Win7IeXCsk09vx+ArOscQPLCGdUQd0QXJ78LcpFPeUHYpiD8I386YxX7g5Kp1tuIr8RjTQ5sw09vVcySkkOAUnxMb/+YGzsJDWdweSia6l+RxgYmyzgjmJ+d8/0YqhKX95PVpFUhx1rlW/vh1NIUWulC/f53S2NFYqaSGLsa7bX+iOeKzFLg5a+0uWJEAkGigatxNGVteC8EJ65/Ux+OI07OiPOZOkLSFX6RmD1F0Kk8jjlNbHMz17IAlP5DFlpwbszWAS/K734KTSH3sQn9XtqYnPtGrITSAhFBEii/CzGN5MYpId+vXg2umkWWuINUZqWw5HLuiFlN+b0XJCk/lKZ0mZ3fxc9oOSt8ujOQ8C4cnWEBSv1vAyj+kWRgQEfDtU1u3E3ifgqHk7RFBUKzgKMQZaeyvLzYh1CszhCp9lXLCGWJUnHFv6vpdTETfBcbuudxfzjAQJXfCPkL9N5ojJSIhcV263seFQ0jpdIISMxJ6m15F9JgTtmYbGzJyu2zJ/mPeCzLjWY4bmpUvRgu+f3vo4OMZYP4hmu5BGVJoMnZ8ccQLL7FB7gU1UXG5qhzlQbRW1NAM3hOjuYPWfYbVB8eT1/vaBZcxwps7ajISwz2YCUGHEhyFIaSsHXw8ZgQ9ByLo3mzMS5NJ3twk31wCF5G1wamTjWspgS8vWGe8VYufJLB2aVOztYHVqy9WBlDvEC+idbUgzJWzxoNe7Ku6Iw0A7Z6B8M4nrIAhUJwW1g1ehxZmbYSd+Gf8Nd+TLzRGwC8mer3gcJRIlHiWzKKj+CuMFApNsZ1Cz6XZp46bi02UypeNJKmPo4JE5bvA67SZ6j/+80w4NzQZPgifqdOCk6jcVeFVmsXK7vs7IwUt4XN0VKojyt4Kwqm/Bsv9+PzG7qiUEP8V7k5CQ3Eo+wxKsI1QYI1ebtq5xT2xoMysi7F4pFzI38zqjEHtt2kuuVjMmAFImX7y50PryxA2jzxDhNJtwIDeZexIF+Yh7WIEzLmfGP3O5gES5nW6gwA7tUJ+oFMMS3+5drcSTTx7yAem6HfI6TUAwq3LpfCUURL+SfTLsL7Yx0amBvc7t3zJp9vlSIR6LjDxvZwfks1WPCRZPhyrs6/jFB6H2ZU4r4TgZjoALR7KZbo1dk3a2w43vOqZcUaLhxuXauRAIkNanFA+yDN+iQ+Pyi0LxT6O+h2FxLq4C9ap0BByp+J915k1mF1iqK8niO7TQPzupIeNeJdHaidImSy88jERHQBoIM9XuIYhzlvCy+VgRtNWiz1sU8uF19WtGKI145VTr9kszA67Pd25anVaTvqnA7rGsVkZIyxxUgtNxrRiMFRxQfIxT9ZI47gKDxmd305XOYrcVCaUse6by+3GSJX94gzPg0j/y/XeARp+XetqjCjsZfgZSqS9pXzINpuj3QBq0NCX5vVD+3T2U94HU3Q/1u4H6MHMudkGan+ra9Aeuwi7n7M82zyDx9Gt2hJhR/EwZTh9Qec0OniobfeLPfYpILP0bM5eF4qrRllqPnPlcM5ISNFhhh9dtcoDshthFs+7qQU+rleb5cMPuZGW2rL9CPIEVgmEtV4b5img9oCI/ssR2FduToIoNrEveVta7rNeAC+Uc7mg7AddxtfwfAMcZwLW+aw1Vi9+wbN/hmyQNE5L63AJO2fzYOkP+ITQ7a0hoKqUqqSTkqAlrJXawBbIQPC73hmcVnh2D4JrQlb9s3G9veOC0QSVTnM1RX02FFFhnScUOFV5gya9Y9gFtwNzxcEbM7kF+HTysZKeTeE69zXrvMPWeDyMM5hGuBefdaunlrLYp+w4+QoYMu1KP/sUWX+mvDmdZTUpFz8FHZufmOleoWltIYLBomXr77VQzq0PSmsPQ5ngI20YPli33rizRddLK0yDgqhrV5nCfqg4syu4RslTLcJiNYakVKlDR6XOUz/zvziN9rFh0d3AsiFIuOfoaSb6gDBj4vjp32m+XrSI+p5NRA0C2hAEEfznO+WtEVWX6Knn5VCM/ZwGftPiPLvJz8R8n9wR/NfJxM1+UiXJsw+GIXl8lr+aEPwKe4aycrYJw0WRCy30d5p6Rzz+9whWTXXTF+meXsAHXo2ApJtVHZglHJJ2a2KIGGe2wbuip18CtMYy9QeuEuHKIP6Y3Kp9XcacRBhHJzwn8qk9ISc/NXs/f7v0NqlSEEPsMl4F1I8qIdokxtrZ3GsTxw6Fzp97AonFu5dkSab5aVCwsS7Wy6zlSwIJVWXdZ4mFeyphSwv0/hITM7sa86kYsipF6oXKo9Z2A3JZmIigJkF4LIJMXELZl5iWhjDh9jSKCIEJQJrzN8No4iVOsa0ndzU1G6ZwSvapIkFDzk6tdQNyKmFxvENAhZxx1ndTg1ng3o7C/IQDyJfH3nXwBIXgAl0sDU+aVGZ1rJiFP+YP/cRwU9lT6hT10moAlMdftCPomjgIjev7gZqQoFuzxBVSrG7JfmQq63eiNagfEyESH6WIVCVVXR08kParzNVIrzVeJaqmhwlscKnxiJyCva7wWlbjoM6GEsJ1zV6H3raCO1ShhqNEqSJsMHp+5YGCHJ08EC0w4dLOkHkVLy5UtH8XRwsDb0XGghgcyOfkGHayuiflmiQEgJ4/ckwHvPIbP+CDjROZidzhgSSbeu9ajqrItPtW2wBD39LxTkJOlpz5Yyqe3cEUKL1e2Le9vvwNvL7irJeclo8A5ANLtnIuFnA8ipdOAQmHsA3849/z0P8kHVDPi/1iGPQl9AS7rjv4fvTu9GiZl0eumQRuSMgmPJW1h+RT6i4cYMTrypKJx+WhN0TUQZldXbDn5WxDeWlvoE7A2+CV08LQw6WgxiCKdV0tVae54k1cgX5GynCDiZebP/zgGGAVLWJmGu+Ts9XOQrEccdrsHaX1Y3F+xFQJye9L5jlj9FVNHEPmEU6lFFJbHlyFzZTti0t6l567KtrDqzFifTORCo0a2JmpZKj7Mzhj/Q1h1Pw2hb/om9mz9mhbGXkPpkBa0qYqOLiMFT9HkWCNVvj4DrqsDpSNioeyreA2GwCNi29PwQ9Nr7oh98ybmlFKtZvyPiV439ERku7lbMv5H56EX6yDx6aidaDtHEKASWZ+M/IVW613IxwSkyjBTVYgyh6lr7mnPaVSOI6E4lLiu6kEq7Fph2YTunzx7+js2gfBVy3wQPNxRwakH0YJV+l6NTqEufCn1YIkHtctX2dSC2bZ7vI53DbHrhZDa9GvpiF325FmlDTyLNm+Vjq2FEhhGIL17CrOLZYHuwHvNZqt33GWm+OWM8yQfTTbZga8DAcBxqwvibhCRwX0essqq7xYt20AIuysbZjIvnbh90HZjPcpH5wXdtYG0C+5DSdvLQY2WQLBjGI7i30KyfXM+yAJO2vD19laEEym8uPJli/zBIRH7guZ7UIjvnlJlAwPXWdcv53BSkaORzSsiiNT5HGfCURNzyxYSMrJokGpbYSlixyE6mdsfajGngR0ghkAXDgTgMu0NwUaroY9N23zq66FCnLAIALmsYf6zr1wzpL9HIB329ZZngDBhxT4uEMBUqoZ8Af9yj0/8oeZvi6WCseycg7JZ9opIYM9k0g1fGYOkTvnBzdJcmuWl6y2WiUkv+4yxTHLreTAL+1XHs6ZrJhYEAte05AbEpJ9cMwZ6hdOPIasXyp1R1A2SJmGixDvvB1dN62kKMDeu9PtcZ+47Euv03LKKrddcQCwTvq6+u02EU0TG3z4afYQJ5VWQOd0c/kh4uiCBAB7kPfhYpHa9koF4xvSrGnCvCd6IW2Wi4S6xopAgHDnEho4Zyfb4/PHXTRe+ZddCxbPMnOzyzFxWVCi4iHUuv8KIlVC9v34RgqZ6TV7KYwqLuqtRVsdH/nVPVNW6Twyy1E8Spm5/GCLDCmzWCO38eCbXxtqHMxqQccorUJPXsDgePCVpzglSnfaQzFj46lNFWqnuyAXi8YlJ1bhyYYzu13DujBhwyA9bxBmxnbVNOmPuMjy0OS/fTJxlw0bAPPhsixLpARkaS6TSDJaOFz+jrNKvNZmvZOfYKoOEW156Q+qq2u246FY4Yc4KlEslxIk1G9P/iQHY0Pog0wUmXQRK/ViYL5wECS0grC2eqrVpdzs8Q70zWkMmXZlV6gIR44xjeJ18ny/YeCzPRBcduBKv7wSNv7D4frrb2mKHUjWHeOsYSf9k4SbMoObf3+DjyBI9+eFXy59v8/vaZH+IX52DWClekRCec7hKhgZa3fKX9s6qry/fHkWNKB4tHEcQiiN2fNzaap8SbVQOyZENheeYYWxcvJeP235/d0+WDtMavXuZ38O5H/t0p6W/l7IuWJj1hjGmbH+LeLi5hQT0u22YTgWDGrsXhLv9agCBxB7LU9ccgBJXzIQKmd6vax9+NSTuo/2/kewi0oZKP2x0H2vNU5+ScUHk0LisCxmEZpSzKvwvQ92Q5pZHWtjF0xpVTj7qGQDgH+rxZOG+Hq+i5UZAkOmZ6qWoWDTULK8M9zlenP/oO++zPJoJYJhDjLz9jtYC7brtCusazPMAJC+0Y1OmZKuv4eUSmgzVawPn4R+Q7IcIbxz0Z8i0Kz1kGhpJWBeWkZ9IxIMhVaWAqjYeM9sXAQksXOuW5LREZHImzY44ExiX73ycUW3DLN7GytfNNrWS+8QgtcoBPK8HQCHs76fwkoACdenoumKbuFcGRHYg5oVnR3EEButxiumP9fKtb+KZoXkkVpHrXdoGhfM+h5yS3A2T90SkQP2c/TwZfuRFpmoV5AKIVx2704c/SQej7NtZomaidwxNbCPCPS/ik49z2I5EnOzlnn89HqlHr7IdU9d8bUhakdaEfin369vcFA/PkoLyVChhP1Vunol8YputQNMHh99v5yaVtKqVWe5ECbY5g+eFvJz1vbXla2NrWQQ2D3XhshtZy5K4OCJnsKZqn0Vv5ugovTti8/vnOGouorjedI9izNQr86YkqWHA3OEesxQwSg5jRrVU9PJt0r3pabLI1whebqnSf111KV/5hQEoz/FhggQzlXpspstuUxi8TBV0DtFzcxi5qwgehYRDX2HK7ziszxqUrkYFimLLl8qqYO5AHJd/BZFU0pDhWRw3q5rpcDyFQnzp+zUI2D2ika4pemuhEb+f1xfFDekI8rzjxuOjE+eWvU+knc96jJ4ll2iUkci/L8nWzZKLc/Mkf15/9MjvFltDBDlBbqiPK8X2c7m3JMCT6/i+eMDfzutG71kp0/SF45Wn2Di9E8j6C60CP4RgHv+hj8JJH+hX1rrjH9x5Uz7NgvvOXTgfYR9pa1M4YaD0jpxtXGMeAB4tANyK8rUmnPvsf4L8JomjlwDR2A4dqDu+Xfo3DCgIn4VIL2wSYoBRlNPmrf0RjCGlg8O7dBmyadFKnSXk5lnJhVICJmUm2n47xvLOBbfniXXPJQ4797WhYqO19OFaHezN78zxrUmaudP6tEjEtxoiJhYAHea12/+AvynfZi8Yyt2ehekR/IppO04mYziT5212SwEvp3Lc76M7XlGX16xBrnJ7uEYN6EgHoDNmihzxwIa7IlvaxUSGp6Ar+geHnVRUNdBcGdrBfHCmGa18zgwosf8PMjNyDSyzndKDNITOrKnPiaQyggxGPOut0ZxuD7nUKbpPZ9tpspeL8LqYSTReheNgRifLWY8UzAS/WiDoHQmMjuCfP0XuQc0gwBz1argJlyfZOweqAuDlX67btrUWaa9bGDrNgXQmoQkldSFHa7VlR4TJLN5m54iHA5bUB0nA6KtLMeX6cbbrctHwbWtIPQ52Yx93fRyXJbbngRwqYrm8BU9aFaOjbhgctsEo7PAyiscgtTqwWvoCAQmklgJhOaOxvBWseZk1ov7NSH1BavtAoQlN6pigbQkHksDjh7TAmLj7ycoisH8gt0t70xNpTHCVUoeIPb2Jp4dmRm5RZ5wG+UdczJ3bBRFXQtXRGfL1Mxt/fM3rxhLCHBkoB+s58a1+nzo+1cGvOlQRqLU3h8HZbM724yTxbSR0klP7fnmHrFn2yV1UvQjpRZ+mQsJCot1cEmUu67ZO4F92n2EUMCToS0SxG1e5JOyKO4mG35EQC7fwssruvHOvccDv7DAb3UMu5tVIAC1bkVVzC1m7XG7ueDSLq8QvSBJuCVEYVik0hwL9HhDlL7vcyHj0c8lyMdWFWrYvVxXuyTba0ZUUEXJM8D9lUymSNc8nQUBo7hf7TDv1RhHq0xdOdql/X2qu7SGHm7ZZjLhuCC8vlut/biYV0UvRxRcbC4jyUhhOoPoKWBifGSmDiZ5+ztsYBhImJD3fWJy76n4Zk2iPc6jfJLGohrSQqmY9MPG4HYlMFh+pL7AXYEUNz/bRvi0mg8fOufE8ArU0icC6FcbjFCqYjw/CJLlcqKMZj4Nx/TDlyrotpV8CMdldbpmQnp65/1n0tg7utYvA7u2HaD/PKii2Fk13+HWTH9YubdHqkLqcYxgoMLPbBv/DU4oJdf/a3rPOVCQ20Xe917iVQsFKqpHFvZMgt4W7s8lRacux7PWW1LHH6+ET4eQI65otoi5wCP5hBw41Y9f2KHPJdl0vUy0MxbyNxKwu591W1IsCY89MliuPxNHOFWuWsnn+OTGH7WPQ3BvXjz2/ErnK/HxSo0iHH3meIYfBURtXoFpHINrpcq6lh+7W0J0iQ9DC73G6iE3e7D+miwog97KOLtgeUXA2yDbx4GJkOm6uBpKAv9rYFFu54qJqcr5Z6hbUvX/Mpqd+iaL1V2eQi68KJBjrHOke86DOO9lah6YynzUSexFUm4o+pjyonTi+MaAnOQVEyuBt5KfHlF1YYruKSssGIjnVJbPfkypf42AZ84h2uWrAbyIKlT7meZyhs0j0V7+d7vDgBMd1KHsqfWhzB6NCshKjJufEA5Qhyqp2J8a/QxrGMCfyhCXFz7xuxfpvYO+Sx+f2nw+jlw1ND0/AZh0Mn75EdD16nGZedujZSXkTFcxqDezXPQd2g76wE+6vd1C4Qh+M+b3HlKFeeeOt8RbtMrL66nMUJR+PJwVTX8lQEnMpOoDSKKb9bILMclIfHs47n2mOORNkSqiuiSK8mHYDgqbv0SDv4HT4bUGsJa9Rjy5fa8d6RDd0/6ix+mEfmjtXR/WyIX7tmOqT4UaeVkbXA/2szzwrOYJ6htODQ6gR3/0ywRXpOzqQOXfT3YOLNPPeqWSp0AkLcaCMGdYaysVb+kR+YIkXkZBSirumALhlJileoAo2GEEZ6jrUKQeP0bN9+Ty9TD/WcVvGImkLzYD5J+8QNwRkethiftmxqlmU76kHa5e1UCVxOszM+M4MjRssQ3XzwX/SKeT1Vp64cvXmn9BsmFAe+/XdcIZle4z5j03Gd/YhoXzlFPRUgR26xetm2JvkUD00GMUF40tbFWC1yGPrHDH1WkGUu03BWbcn2XJQj4a1vWaNlKUNUi2LcFajM3wpT691JFbaOvvGBQus2yNIt6RnwgDCIqHkQ0120Q0VASLJdosYh5i0y67uUQtriAGAZH0iyWbXnRNBqOLU8JuB3LQO1N7/ZHoeviIo4N4Ty23b155wv4PhbPTkS0vNFMA+7Z91ht69lcfkgcu6+vV+3EjG5/WA6FXSoq488Y6Yys9L5iObUb7+f6O6jJrhMlpFsIx7RXrG8prd7YOo9Qb9zWA6oP1FEyFAgMCP2OYRNo23UD+Z17rdGowBDe+Dlu5RtLPjMjw1M2qCHN/LKXruIbXp0PDcC3locdvK96Rk8nMeCb5NiGVPVR40kmc/fd1Zc081AqlK5FgWZraimxZsLLR8dhZOzKb2kU5acQfRht5yPXWHr3mXtBcs9IK28rVt6Yl8qVeXr3e2iiWsiMY1yLGoaVDKbob0IUpwRzqcmwI9Tuw8H1sK8z7DRuO8S2OiJ1y7eSZogoumqqx6V1m/B8Zhz8QYLSirbjMKGmb/+iHDaXU+9tvubxsYuL9sck1onEaHDT81YVtciXaq3Uvm1cRhPMV43HUepdzccx9KobDlDEguMsRtfObCfm8H2Id27LctrfcbYGjkRTTQcQFlywY+sYBHA0MVeGQlhazMU6mfLC/w7PrH7E0XkF/1c9H70yxwiL85Pm1jpCLHX9vnONWwEVRunMKH5Zwe9umww82VNOYfItX5K2ycQof0o+GFVqZQyJRu1U3V3RMSw9jPml3Ds9mP8RODLRYpRj7tL4uYdBhpxGpwpZo0zcz3n2GkdKIWtp7ccgjnsXSTCqgTjKlniUPvpHnMLGNkaehiGnzzYN3VJv7hESOddmobkguzAeeiqbcuNr1DKS+WvtXMRo86Q2YEmVSZAJ/s81NZFS0GKaH/yWvRjb5m7ZaT4fgWC8eIC69CkAm3lOpRv72ImektmwAl2PS3lr2w7FpftzGSP6vZ7nl5tGFddPdVMJIWySY5aWVs7Wzt9WG4r/WFHOz7O5C0xxdRIxqYT6/w56bx/fKKGNK4mDrxGBmrcVgU2fbkWSZV2y/VFri5ANaigW8CsYoWt5GZrZumlDXaS0j2/0s9xs/YTkJ92XJ7+IF2PGuCRlbUSR1+H84JUVDfyTHxgEnLiD8Vxf4qiXKLgpct7wmvv7mzCw4uolpXxKA9ls1sntirvq3UzTJqjzvbGPSmcUQISIuPehfOrwN/HTBpIP2zNDQRkN04oMuOSF3DRONlVAmfmgB5UmCwOxwZDxi1JaaeZQJ2Hj4gXI6jCyLyH3hwNOl1AFr2771eWWSk26s9h/UPWL8jte9jj2IBgt15+8cg/TE9rzm4IfDtrY/BAYwBcXuwefvl6XttlgTUG3GquixeUwRPYWW9hpj6jT3XANCT6Qj8wKGQDiPcNqVB2hd1MdipMfvjm1ksoNY1OnsT46jZbQRv+4QwITAhD2R36fVAlVvc4a4ZZHPHwaKeQWIDWyZqjUm3rJHBo510SXImR+RYJGnNQjXGauDs358WshBxkgppJ1gh62q4/ISUgOs+/vjHitftoA5Urfp66ipzXqzRalRIbJ6e1DB8ocd5i4gV8ugz/HthvPMI5WACdyw0K84a3B27ZE2tgMyH4Abl6M5X8vSryciUIeXMybH3z4wNVPJjhz7I6fbrG+CF7oJK0Se8FtCbjC8B/1JzF+Gx2oDk3siU5wvDNChwwkUHRXfS6tzBnoJSR3WNB599/UnJAstgBRAkFUmDg7JB58TQj2NFUVFP2RiUSDAV7DH5ITSsyW0gi7YaLj6dnyYd+bUrChRuRuGYcssfiJiG4Ck+S4+hRdKjH39OclqyJK0MscFCP42DlIg8YjHMOQS9dBpYPkohb9HaolMsaUQ2MqitN7dCPutVxqMgIdDlx4xhV04PkQftqi5fXpahSIk3Y79/npwRjjVrUEvBaT0p1rcscmBRo2fVqECBLf4TeA31rWGYn0jec5S3Smp24JJA5Ebgt+bLz7hqecXcYSqVWzhUIw7WqxvZYtwq7ZRUvcqfodVKQyVDfRXLSuFVkaWKMFUFz2P73d8Yg793+BxpneLJyF3WhdSwAMbI8d3ojqBZ0GXpWBXegry80/k26+Hr2OV5IbUoXwzdmgXEK6mDoM/+6hgWr4kx4Pp7yw9j3uN9iyrK9iISuhXrT9Z1PnpY266T/zcPj71nRvWmJu1ya7QLVT1pkQPhysFJE9IwOs88Cl1BgsaO39PprhsT7z9e9ePD18IsikCtOIrUrzuYOsTakBsSViOByESmGzJoMprhUXjXDbVsGfz9CCvJO2E9abcDijEYQMRXlM7x/KqtiWPez3HcPd9QKZ6/c3JSwiT8DnGYrYW8DT77wGEuX0n5NZcE9YCF5aW3+Ksn1tSpebFt+BgPhqp1A4mGNVIvvHdZ6yzdifgJjjgZj2CYlNjNhloB67U/akWA/HVrOfgfNGu42WOA5uFFDB0B0hdETAoZlx/NKFyCI2nQN1gaGksuZEtG+U7RhwtJ/J1gilq5gTkdyRRHULe49SYuO6boUMmcXecUlaJqjPzVAe6q8nrZv/j+98JJz5UVNwBFrmItgA+2JPg1TbDrnPugcsOQ8NQQ4hzD6LoziHzgRTXIozthwnUegSus9Dwje7CWONKAUi2X3+rj3B5EddD56ModT0vxav//tGU+VIYn4Lyokh8ptkeaDghhjVRxkxR7/Nlzv8aB2ndGFnTPThcONlewmlFr6Hx4yJs3zNZV4tQ4oClQZuDt1LQpFvdby9Ezqu/whPZdo/eb9OhcWOk+2y+x15bLLXR6DZO7xKqIE4pwZknp6T4AAhqvDZDpuATWS6jW/bMeg7XGb9V117LK1VFIzG0HEkJwrySUrFdM9FpMNwsVOMO+wfRpna8ih0j0x8MUaYfO+yS/ubrwOmeeE8Ri5lg3dV68P+XyGj5odJm4YLvkuYC43sqq/d9/Ps8t9HDjK8WAI0b5R+kE87vuQsjv32/5H6zxf8I//zuoBkaQVVeeyLMJ3hhirq2rbJWYjN6eK9r3zAvnmLsZruUK71Qk0gf3QPgTfd9L1Z35aZKmf5/V8HGBrAylHKDPqCMy1x+eawPOoeMKDxLSWR95c01EpAlkdsspof0uZIyeY5rMfXyz+GbSaEa3m70RirhssqRMvVmsXisPQ39d9YY32cTduil65I7FKfMC2AiojmbCyLkxe4WdFWnrxfKb8OymJqzfD3+gZuwRzFMoKnBeRdGfFZLktE0Lb6rGy6ruBLEoFzEuhQSHoADYT9k/D8rKmpYG7K7CdvAD3PnbhayyECP2yLBFyRsyr90p1duzl3avm5K+H7sKJsFtgO2D7JaqPMR08cyKl0l9BMdj9OvDp33w7oKqpaSuNuXUPxVzg39KdEfoA34bcmNllOLKkyLG7OIfxYfAd2ryas/YfLoiNoLKP8kGEWD6XaiNT0Ul0etn4g3qNhlg44UiyXKu2acbK8tWdhRr6zSxw4OpXoggIQAMajP7Ho4Ivgg4DOd12MexC33QE0fyBgzmCXxDlCc4SdXFk5fLBTwoSRbNxIu07tZKT4ntvbBiEcF+FtTBITOheAM4eqwDKziDfVZ/laoARsm/k8XkRRV6XUgmJjS9dQvc3+FUJubhdxQMEgDz5MvZOWU6vxRY5HniWZ1lhrBMBBt8sFTm19Sjt3KXK1wiM4b6Mb5WIxK4JGOWMYnHtVYZIo+KDl0i9q2r+ZrPn8v9myRkvnkG503vZnx0gBnRSHY6Hd1fb4t7X5VxTuCkGicBel/f8fsKgcKNXM3rMKRoPSpNg03fHOZ8Hz8RoR5IPiLrA8zwJgPGi1m03tKa6RA27kx8DEv+4yihKh7/wRH3y5evBJXSZiyQeqmuVE2hGy21DYiud2u5/F2QxmsHQorScjr4B0m9b3d0SwEMtKLoQJUouzQ1GMo/Fr4/EqKWnEJoT8y/fetiTrNms1EzwA/4c3Ex/PiSbWPJCyXAtmgPOIhG7479iTaVNVksOJRwCtFD7WQHBjt2AzECWm1h3dKo08ehp8t++EAkdVV7FxAXxakdPCerOk5+QSbc/tP7dDCaAQIPzK7DNuYiSvWE484STxrcKnyCF4CIIYpHCipMaXvSAQsBymZuTkm8PWL3oXWDW5ZpL6/14mKnR5hSLjhhxM0p8uQoaC0JqN2nS0Lv985FLeK1S+Gj63oLQVc7KlSBOVxwsh96j/TjwEak2SGzaMPts3DZWbIDBCdkSvcjSV3pFRg4NIh5ii9fAOCXPxdYQX9y1ytga/GTl5/CF4/z699LEhgc1G6S2Y0NjKYrH88ArDgww71OIkfUm8sX23hj9++zZX0g/kwj+c0xn55+IN9r+ni+hNc2Rwm+q+KG7Pp8yuPPNjRUTWScid8pe0US3zXKP9Q0wY5xl2oOJks4i2ykVDvbToFQ8T/jEfcEbio+29aMpQdnwYjZksmrm5dxaDLghADxeOcZd3iG9eDhOtpLPDdBFHc60PLhmigtGNLcFAASZzFsIfccWFIkwCqDKzzIETXd0Eh1FarU0KCzZr1BHodE9eSfn3Rssqk2ezgZwGKbmVKnCUGeRlffE8yUogFjmVjrNEaI+ullp/mK1XhKkiefa9unBO8SUELOkYhwMmMacWZ1/lAsOdplZk80dnwvbm7tps+LHHxGeLUCPqQmyo1L8fWjSKUeMXxyoqvmJLrb2MUG5gO4JxJ65gA2O+v/7HqL2Xj1GNNjJxcDJpf4JhKXN0HHhp/ecAWI0iir6HVjXULOY1mgspSh++zFcWmB/Se7tPlBvGL8aI1b0J0BFZKL/FKB7BuhMc+tf4cQBlS9l+erAj0GmK+QrcnOlwU9vhdoRidgdgWcvBKPMrs4KTO1tZlf7A1ZgCCtGzIYwOGM0iyiiBvn7Ex1C+xWYJlr9rvpAQvi+gMRUvmJImhxWA5nm8GUevSEgychK/C8i34cuNF5aeyCOh3GUM3IOIFk5hxlrQdhdbv97B4+XXcYXrMlZSjxd41Mt9+hb1bSYZ4mF37tRp2VnqSLqz8OTajTcWZA1ZTWvNB7dFlAx+4JfKD3EtaCTIcLmoVbbbiVlPpc1y3hulnTb/nlbgr4V7Qs+/rig0Po0OAvJuQ8q9hC+KlrkaeM8uey5OaAtUVBEhnlBQtlmjrj6wQw7pSxqQmjdlNeR8wggzjWj8NUpZ0eR1CdvILqIns5KrSmR7ONPZO38CaN/aBUdIEGo2vzQ2LsqNSwNyk8K68cQlks4Zz2YhbRCjEF1S4bfRNaR2LE/JEVZdIuJDYV7olJZWztL0zQHK8VkGfFK7+3iMYZwBBwIots8EovWxeuZ6B1dFZtnB5W8/4dInYNikBwq08CGDlK2MM0cRBzaCiQ1M6bal7BXwgqBDo9YKBDSbIzLgsIORFt/gpZUOqTGkGeuRtZwDkz4jQ+A1DxOXSrOElj90kkaS48NbN10NkaN8zYkYalfjhc3QzXzXNuHUBFt/6c70+slAGDS7WXv9JWLroc74QVIJg/qO/F1CwX8nJYTDwSn1qmgMkZR74WIcktnAeEkjWaFA1ataYpz2BfapRIkGwNd7QQrNnosw2a1hPAkbVtxWQz026i6NKsUfgw7RrBg98SbMgrOZeBe7RN8xt2SGgKzCXKq32Z/dYu5yFvRIXapRlmXVAgtQTZ2KMl8TskQfJAYZyviIiGt3HESQzXexa1zaxThrxrWmMXGyj0nSHPbJkGvep4Bf6QgegWDvA/dQmas7mOXWq/YUZ+RM6rML3dP+ive5gOE9HklysBJNxPx79wqKj/gqXPBMmaYjynZZBZqdNQZ3WaxeoxL1MNiNLZGdv0kn6H5TRU3cuL73kCHYWOellf8kXffGUudIHtRxUvjUKKgn4BauKD8IWny7plprocaCVm6NuAnKw/VJ4r8q+txqS0TYwe4QmGFMY5w1i/1TB+8oIzcq9qb0+pOQ9M4tfHi6I+9sw/jDEoGqMXuyPkDu14zf4TJ3l36Hg8293ZTJ+7zS9M5dPyGoifNPO3MTBAaiD+p0N6uiFaAGLCYMgAKyvBwZqMMhgm4lyjIoXpw/seSdRxlqCKlEfKeJ44IO6jI6yHY7hJzXu+hx5ZGF3na4pamaOPlFHCqr3RXJDVKajx//WDrqj5vfBc8nGIXgICovvi4qDORJO9fLEHAG1s3R1KjwsJDqv938McBlzOHi9Gm6mFuwo750HwzN6hB20NyxaXYAjFHxi3S+eo9wtlDt36fYS4LlcIYJ5vNTBwoMpNIPr7K9pMh/3aj6RSgudFrb5BhqPC8Pbng4EtFagE6LjN3BOz0GCk2Lyag+NMPDVCr+dETTjUwlJzPyrc8mXoNpJ6CpqKLckKq9BReUjCqOTZJOnGr26eZu+9vHPwHHH1mohbu1ZhZXWdAb5A/idbRBC1q3/b/+lsRLf5cedRD9JyLYFlPtsecq0khhzpAL+QumIqhSI5pZ7F4LhYGL4eWdybvMgb92+hUvfc515xQD4pB5ZqafQTJTD+VhTr0QyDKO09/spw3IEZOut6ePIRpgvLozTdslqHSu8Wpyj9z6nJrxVQyDXKaHRWIJp7OdOtjlwMPE11dECIN54NiALl4bxKPoNbtIHwC9/85jQpcgJD2K/k337EDsnSpxINoLeOd2a0udznkOEuRjmeKAidR3NbqcfxMeYuute0c4nok4QR4gojLXNgwHvpbnW2p0d+fWJhrSN0pQ18YSWpIsg39I7yPJt/vKUzpXbyDi4WFBN9Z62omcr/akPvclezDlDCSFqs4mfJ5WtU7bq5ClSgDiUJOF3Qxehdqogj7GXTorwvUKIbH3ZUn/O7nihrwOmPyF0kbb2dJtd+FURtY3x+c3Me8QwUNr/Vc09PH5Teu6IEVERN/bZ+mk6PAzq2ScgNH27z78g/1ilYdqgpUOACQWMliamnD7B+ssQGofbXnzXzvjRGpmHlXW3CbbwG3WF4wcxzjIar0J4r8QihpZytBu9M16fksLyYR0eEAIc8gS1KgVm6xTQv1ryICmnYQA+xzNCF+K9pyKBY0Zw4qLzWiqpFN0HRNSoyMSLmJqfXX08/iL+lJIfiOAdfhO+Mzf+0YDrzuzNHxFtkBKLxeqTOWCneJ4XBS3E1e95t3xpgd/cmnN9v0OBwfV3637NcNO49hTl5jnoHk8Q9nDX4T7w6dmv96zyxRHGyJw2e0hHzbP86TdMymyweMbzDmzMvqRJQRBl9DDvNsRO0BqI6/+mHX6nsDPeA2Bqt4i5c4MYq0IjjkcTkyoJD6oQi2o46iTnh6KZc8h0MSu94d2/9d+HVeOzubB2EbisMCXC7t8VVKNTXEPr1RW8u/T19wd4tPmLJwMZz91N9+TLHYWchW54gmTQ1gHZYOMeYCYsSxsm4u1I4XSD6SEnZtQoK1NQyqrBzgc4hPxaTS4+3zeL/nZqCmRwordYhsgfcwVd7zaiOCIqmMY/Q0jDl6hpjaC5IM3UfC1xaqnFXNFeRMhzcWcmHIndgOKHEmU83f4M/iNelXbe9kQV4hrZ+VjOVOlgBhO+edrMvdvnW5hLv0tYu7yUeTjaxGxbFuRdxGIzhvpfiTh9Hse0tnyhbtU6X2DDynkH2sh6PlcfEdWML+y8+vdSM7ZvawyOHYiNNm7ukOQRGwwZQ+LDN2kvvkCG0e1kCHrrgkJtxKFvAZ4AwodpK84mvYW6Y4deePvJnleRWc/C1P8TtHUKnQw6ob8TdbL9Cj6eoe1IpbhdHjxZeMhZ/+cldhHSUb7ulnYZgcfqaLtvgt5u9D71WLnwFaC6Yj3Tf+k4BATn07Ig+wJ2qZC4moGdvJQ69SAR9dVeYljygcp1XB86MSr8gA53SEY03vkfh+xkteJ2pocG9Q7PeWuuHQV9rE6i80x6cvGUIQL3z7xjzy258ptENjWmyLdTUBp3y/7zk8TUzrS8u3mbpINaY5naaTWc+wp94jrshY5NIk8754Kjl1pqLWgIre3lf0UYjl8eiUl0JXF4W7u1EB2PlObaW5omYUovvTsJyNOOWvLNmf6ammKqyxTwg5oUvI61LWuJJj1gI31CIdAnRhFzat80B9iwGeHESCvBsv81CS2pY/3dqi1Pq4ulCQaYJg1M6uQeSrRBGRGZSy4Qyi9F4GHpKBXnU3FD6oTLKw/zDrVLor+Xl5fOp1FCDVp0oxaOllDyMBuHu2lKykCOO4uHp86M64NDrqCTGesEhHdCjabsh2izl/f0nmcMzbHZmGltBoFhz6zSATccYuer4bvhzQeY6VfSNstqBf9kkZfyjlC4i68wSWmDVtKLPCWicc9grYJTAV3C+M5GxbvFeZMOzagF8JniR08lPX/TTma/GKkkFTyKnyTm06Qg7jcGPjfq85ID8WRixDFOu8g1awTZGU+XR4w02mZbFTT1Pd6Qajg0yG8n5BzN3SAeMXpyt+mFDfefj5Iy0GJAXQrk7VYIUFYCqgfYs3Oka5MNhtfFp/SW5hyjEWMLTIMJqTU+FGyUa2IvDZRXWj8fou5P8NTUjs9HaeaxRbI65krtePjquGtu822yoXwxHYBCnjmremn7WRQS/Zm2LFN6KWkIOxHyTdg6ZHGzYo3dsYS1flNxmqaZ8rd6BlI2ODGNVzzv643ifD/aWVRkJUhC6grMQcWm421LtHm5iXuSX02+tMYasvmRzEsefXDbHbuRyV+oVFTY7jreCKcsxReNxJgpF/ht7ZL20SJzGdo1qks7SEHft9SyVywgcYPSBqx4kGltuxoOBqNMEgWt0hTEt7ZGMEbnfBw6d7dmd+JKe46DAGEvbNoaUma6Wrfh7p0BD3FxhH9u9WsEXnOcrFWgC9FWDJ0pPj+Kuq3Ib7TNsDnx/cUppu/aMchmwlwIs9bpLV0UDSofjFbO0/tEeM5V0vCu6OE7VXQi8qeP8bk4AkW+Q4wxku1Y9T+sX17tBmvmZxCfdLANGWadRuc6scZltMnDEuqNGvQC2SPBc0c5l2UPYmo2i3TdZaQDSDD0pPHrpRwnfM0GdqenMAL4J8YN9576cPNznkeBe78pJALPddB7iTB7tyVlcrLBHXsbJlrhCU6msu51rfd9SgDJ0i/I0gUHs4uOdvmTEKvCY5ecOzFSaEoOtIYh4zQcF+8kUcF0pWDkIqF3vaJMGgOtSiIvcYTWof4wqez37ndo4kqTAwqsfo/cVPkVW+hj1Gr2uGbbDm7onB8Rc4Go3C2aVYQO/KTc+qSkTeC2ZgLdMJOqgKZik0fVzibz6zts/V4k32Kfdr4fO0nGb+gF5KhmVDVbCR/2wyOtWH8PkR21FEFSfOJaexi9GSFSnBpLMsbAe3KjPs0KJ3ZChgnuixutuAqI4aUIgO5GBopO6Z/qC24Wi+AsQNDaNss9ojYwS3K3NIyZtt/QTefxWhvxHbwN9I/Mf//Ycs2Uj5pq4vTjGLf6XLTiJ84g3IKPpxPS353rKBClSk/xp9lZHuJfzcAFgFc9NNKOw9KyJaZXMR+r+e6wM3U7HqW207+rcVwyMY/yg1FUTBDA7Nj1uEQvOcQe7MF3U+jXB32zMc6c8Yo4phgbtz/Jjp+0gC+uLDsrwa//cKkUrQbDNIa7Os3dFM+mbPTrEeaKPCcpDdSxGsjTIXqat/JunChphmVoClVqIVKHsRDD5jLt20pu+FwCI353mgVQ8DmL8TNzWk1hazGea6UWfZ4gcqcAC1AJ7+vInKdPDVmb75MG/oSqJEtCZGl5yeXp3FFhXPOUKWuZ3XJOaRADIedIbqh8wGW/vNxw6Xuy9kZ6mBdE+MvWlUPSuRWVSbGoq126Q1qHnZHeyiXZauKIYBwlaKloeDaXbBGAI4NrkGFMkqp56aePhAMkc0YAHDLPyzLHQlnQNtjrJV9fV6Xb+9nc/bixjk2XEpdckhovAimtKn3TGsh0yjz3UHCTEeM8Glffe/0p1uAjQ9bbCPzktxV9DZTjURUz9M5DecPmEm4iqZFIstpPY4bpl1dbc+J5NeZP/Sxt8+vxJg8sIxYevvZWNeSfydlFoqt8R4HOlphk1Fr1FTx31Xspz0i44NAzshVZlgcaPXKIJ7gmrEnPIaNKs9jZlRSiT6eQLtBtAboHBWGyTuThbSNpDhJBs7U+tgYfl/4Wfw1mtWTqOz+zgA6KBbYAqlQHB4K39wVs5JZcSPLdZfzuo6ObXpM2mYgwftFbWRHjk2n6eufpG+nNkAQA0ZNpt6p7vKnDdUjOBOmHSHOElaNZ2hQk7UMDqzX1FRCPLWZsT+uWk745GIpcBqASPGfzW8PTIS+xtkop4FQmSkd1NiVPg84ORogAI5VfoEuV1p8KTzKi7i6KypqmJtsPsLnQ95iQiAQ99ScUVKQhFUw4qVyytukfz4nSQ4ePJXKwGGPtG4mnE4361tlaTAACZrD4xDp7czTdjBoVk+VHl/t8J/1L5517dN/3bUcnqkBXDPtdxA8eWS3/jMVKJyoQMqhMbEGIeb1rEnD+Mx5W8tJggx3UJMhPtnqJhHeu8os8TJyPJRbLMfv7BoCp3L8LOYWiA3BG0ldFXMrJqyKe0abG0eF/9ZN27SJKiWDzvTsT0tWfdx/igR6ojVJRWlGCN/GRaqQT/ZQoGfELqkDbOBsNG6wKPIn9SXojvohvNHt+i45FcWZ1NFB/iRutlpqw+dlGFHNnXDoVNgF6A/p3S+WzqKmeoHm4AYGbFArxzpdMWNtQX1kojL+1UQzD2IptAQgIuA1/5p8uevHlWxfPOFomnC/nWGWdl3ALMdGHjl5rwuUvI+UUd5cx6i8muWTFQ/ksNkhucluUSS7mnLXRQjmoFmfoNCbf34qvXWkLm7zDW/Mmwbo4Wy2+XsK3CvtSWTLFDYfSRyKam2zaQlOZvP1NWztk/xeWztaEnRd+uuU3WjYvRA7sL4THr/h1k/ioYoEP4JXqwzTZcXq2EE7PkCh7bUratqlLVhpMDIxbpoJynewp93clJUmEyWQvqixKlYS3SH1raKl4eAqen5WU5g/ZNs4bbK02y9XXvRChfE7h2w39b7xdzv1taqsfMMrGOUGOSnoUuv10mp4/RpZ0op41azBKwJlztBVbDt1CcQHu94n6oyVv1Bv7mOvHK2eZOPZRurhPt3SLama7FGR1QxyKJBj9lyfgT4N/w4wPWjLfcFyqCJDI5MoVedjn9K9wW9MjAGl7lWgQTdlUpfI0U258pjnQLb4QaTsaMjGfgwqES57o3t6vnxVLgGJ4p/dOMnGGN0rmvFHQGHkcF6Iee4ZOHsj2LaAOf2CqFIMEanDCcVDuVlH1YGeSR7du46dGPEMgLZqZ6BN58RQzj/VTuaQ2U7vQztqyCdyuiS7UfrI1wLogqXMDu0wGcfeR7816TgPYRmjnfZKs5RGPfZhZnEHGU6NpqHVUc8ikI9h/zby/TUfqw5Y+uSxy6BaVSWruj2t4e91ZYTYGNqiRRtenQJJcK6IEmPST2ICJgfIfwmNwjSYs+mCNEjeNnj2/tHChflIL7zUBjGa8BuQJvec69pEWBpI+auW1khTzJ/yMdNm6NHQFHbhR7ujP90dRHDG4wlhhZ+jG0WFu6NWbzE8ub5OAasm8LV/UZVXKGzfO0YWrLexAU6mhQqxowwV1pzV62MCv8rIJf3FeaX89daQETqynoBCsM174xJnudgGFoUgrRJWr/z2WjyjtWUGttkHulQ2hCs1gzyVe4/KnNNRiZjyLnLX3M8f1C5PYiFywdFY9TSZu5SKkOHDBajKeRbqkQnq/2UAMcQy+Jps2gOMWgmfmPG0SN8AcUPssmM3+/4vjHsqZ8YrkawOV8vrYJohEvQ0kYUCSpX584XNjn2Sx1o4LNJ+7imGsko+p1FPKzg6GWOfxh/64oLhuMx7CjqZI7bdmGXvimTYfIpM8Kfeke4GjiDPMka+TBLMugGIqu6ho06u8iHVWqwXq/yyLUYsb16LQPWHJPJ1f9gWBTP+sMJjjPO5b21j95kzQ1vsREzD8IcCTp8g/oQohjNS5I5uKPls85BLyruMUdQcgd+RpjcEQe160xL7ovCgOmngP04PWd6aycuitlt6QgRHSRCoS7Bl2GP5Ary3CyTbfDdKbgwJfVDy+oqjczaY+rhuNy2n5gXrUVaFS+h35ySkEPa7C6HiN5RvfTIFLnyR84FzSbuadPOiP97h12N891uEWDgspQ3Eo+e/BrmW/BW/zonUbETaJ8s42C0HQltUaZqjNmiZhLHpkeho5B35/UvABAJDokfz24nc98gpfg9HhAwDXoV+xRxoy/pNDQZewy47EtJagsT2EwihW1eNY8f98dfMVNtN1wYpSD29mYMv+rVNO9calJCJR3eeo3t1iBUvJv73MFrU2ST9wt77DW2+ZtINgTZhzqOJWhaLmyFD1UFIfZtn+fILEUkW1X4Ww0awIU66kM4s6N4ZHPZC5W1THof7EjuAjFSUqGrHFsmmpjYnma7KA2FhUsJ4ujh2fh0WwrbopgUgoRMYMP8y4uCu/4z4Fnf9RSO7RZnOn8R6R7dYjt71PkrD6wPaQ0A+Orfme2xJ/XZ4i/Jn1xuqIv+WOF5wxZb6UX/5Yh+aHoVyB+Co4TjheBO8kig3XnG9ob8RKkVIifFhbNUJHc1lGvprdHB9M1A8l1WiBYfvRoLhuGy0dmro7eBoo5jd0oBV0RrDMBTLkKfU/voBXWbP/fzWj2aEvMgiRQliDfXrbbdKbnhYFrdR3DcOpixyFNEoWqejMHFH9KJyMP3Wg1opQhH2CCkyAvUlYFLdi1PfbFh/g+kvkvQDsL9t51bEwL1Z9SE0e9hOZMBGlji8We+2p+eIAGJpcvG19Mb3hgl5P3k/Af6fLFQ/o+gsAbUqOTedCY/LZYpttLgxtkGmPuiNqQkrW9Q7D7BXF92Fpl7CEtl0s7BsiaMo4OHeP5O8vw8Edvj7NoG2ouRckgR0ictOgdoBW+3XFahSJ6qc77oY5S/8mK54BST5mo/5t3lG523uUWO4Q/uasuzukQi619WXSdNzrotTxn+QadVC3cESu7bxJ29cTluhzOX/1KlGdf0KhY7ItXplbEVXGgQSsiXHUDqieCjt/7t59W11ZUBXowqvLCq5Y67Y2qJslsdVrZf0weZsKsGSXicCv83HW/qvxIbFogO3xBDLXEvlSCd1csCf1MPmdaelzA0Qw9caO92wPHdjxYF4S+xgMDJ2nEVTv58D9Tvv7QXro2fzW+MRpZPVA7uGDeIuzNBDOaZeW9KxEFNupaTz/44lsS/kW+gIU0SEvvEUXuXIYO1CGO82jZdonYxWjJw3/ieco/6Nw9th+0v+b380XYAwI1s80I0nonIztASGE/+hMbb3mg4sc5r1cOS2awph3kcEfV8K/ASHXO7rPe1AG5o/jTZf/2aeOP8dXpImUh/W+SOtkjRx+NzNdagYfFcHDG+O14Fux/PqqJ52CmIEuj3+cqbavkHWiZlt/e6isU9WEgWU+Q+kooBdx80DKYYiEgBTUe9+qaa44gGfZ3LrPWCRP+3VZUNqg/YGmPHLft1cRghqTWYjrY1JtN2TYfYE0hJnHghNMd9qo7BYGn4rP7JTqoCeyIxwtgBvaKD4fO4LARY1fnO0jIhSBE+8ggMvD5BQI8Lz4zeoaTAvtWC4HqKbz44DTD0x59rGy3X18kEjosLnJ6PyKojDEu9Vozx4M8qdmeWwsPn8KGJ3wuqxNX8CGDqKYUbPDAPQPYXWtVOuw2kH0ouw9mAOb+/3yQx5ZgwdhRxkUouxijpiamlscu/VzJllKKT2hJQ7mJIislRBCQdx0F5wI7yqkqpXwy9ikfg05/MrKtB7LNa1IBfDaeCNmwwMNtcA+ihA3+kzgI9Uuwjm+onWXLT+AJsx/kqc/9Jzs/KkT0kmmCVBsQM/rPEVlU/4NI42Y0nnGBwvPWGwKSz1q8yuA2fxdQIOnbXMddjcdKPsW2WDb/btSMirnRLxkF14QPa9PTBUjteF0Ynyd3iinunwH4OQ8lkSeZKxeXbKxmh4IdOYqUrlNlxihOUV8Z0++mmseFAHooGCWguKVz1nU7fv1DYzUnnhFKcKjT086X2I4aFDKa6VbGWc0Q/+HTCZg3lllo083HkfzAizmjiVy6MIUmSxsk+/Zt3TMhduOa43xbJN/Q03WAM24WHSMKegFqSOQwCOmEuFZBUK4F4xP2fIT6NU3VXIudVgVPZmLgNcG0LeA3Edk+0/de5QFpFwUAO3+/u0B2QRHLyXU8CUxLfgG/3D1/WUNYxHYiprNuD6anaf+Sb1MzRpX6IC6EQH1sHBo4ievJRJEcx6TC++JYtMRC4uw3W+yRn1ljgueEZuWqy4VSt4X94XNsekFJBYKEUUBhIjvRMm+XOynC2BoyKOon/H+KovBReEeevojSEYjrVuKSAuhGHVvL4F2j3cywt5a/lkzpsysKJkRwnVR4jZH8oz5m7F3UPPOvOP02eIMdwfL18Ks5x0Z+NzxGFjbh4NQWgOSuOxIhAYkRJMuvp/Gg7A5nx5mu+NxH7xyQwahji5oJhBSBDQDd5/NbUHgb3qzL1hOSvDE/e9dxGP4skEDQp+/OmtZvz60ZKmFY8YPvVZJHUavRW3sGmLWLIQQNyhIMZjE1X5dN5/gHulo74pC691bDVz+4QpHrCxAHM7Nv70cC28RjceBBQLaonm0vXW2cn1uRlI/HaSnwhKrMOVBLsw+kQr6lsFmbI4rT5HiKnf3C5v8G73lfMI+Ecj4xQWqGAKIFqP9Hg3WoIHeU1zkaqA4kyOYz3WT2kgl2/BiPhwaC+VX2BsfTd71pjn7ZdeFdNEjASxb4VAxII2WBV3U5ne7muts6ZyzQkYt0i0+3HtzzlAA7i5TlZLqZGWW7xzNgm1/9Zu9sNuB8NqXEWu8y0OHVaCfeo0k1TTiSb+KFSTUhgMWf/RHxduDhuhlIlxRW8dp8oWHMYiVKD4LQGw71mn/RUUx8uwOoYNQSC4jypDx4RHjr+8Qae6tX/VeP4XzQVLeXjSpfReDSXKgHmpKyAyDoBzH7t2n4jyHyOImI7bl34Dfk4tDsb3P1vWlSshbFw36uI9ZN2f/caVJxLSPuT2kQPy4ywUEgf9+Ka0M7+FNzy6oWZDu3QGjK1y2wkkREAD+xr6AoOJuK+KbVjtPCwy5dInsp5a5XMJbFrD8lannOs0brL0drMafyJYGw5cgIsC76LwwG8U3JF/J4gwS3fFjRAoKeOz1JSQFhPW98LJvgwevzh9iB48Yr8gIq7IY5gQJb3DU9J6H7C5mReLnqIrjh+TBKVVOEBHSdxdh/OqgHVwX4ID5KR6c3Ch+B3GkOPpIwb+QsLg9mgXleRPVQxE9t0ASjR3olZYSYwwoVs4GxlZO5O4N8KWkOfrD6PNc/p1x0ZN4TedrRbkK12/5qkTiNNEwQ4To0PMqZQJhNkMh2h1z10UMSqvwroNIrcPDUKUbTiiirXNhOl9E/y4CC+L8xqI9YpApr8Ld1JDwCyiNr2ev5rrlUe/thHQHRSshD3ZvIv/hiQBrpsbszYnWGDg8CHneUZvYP2wjB9AzkNS2gkpfQNpGzob3lQSsiP+HalTHc3M6CVVwinllm5lNOnbfdFdkBhFox6MSjKDTGh6Eei7fArAw1uIjCtPFpENfxod5AXGT4Wy11IwniXU8aLaXNC4qYMKHu3CQLRHDzTWXPu/tkAgdZY27gwbrDXZPvK2Xyzgejn7aflG+tqUAku5bAD1oFSG7duy3OLAEyW4J2k0gDMicz9AAtx50bD3qXiXpqRy89ylZRIymS7PXh5pkn8pAsixNT+53ax3F0X4ifR7tzYdOaZaET9C/ji2eEWvbJaVAPPszUI0WoS3vbEdpdpbL8VvUdrVUNeBCzhFKGrIrQYyeYwub0UByerLvKkHzrVjSz2OEHlejO3FmUczepCB0e211ovdADPFAi6nC+oH775YURSYcmtMH73/FOrb4YBy94jS2k69bzlF3F35mYqwtOeoA60/uPBN5YJASRqmNpQA2EdMvK6AaK9/075Vj+WF1FcWZCqC8Z3DwuRt0aWUhA3EgNLSSgbJ3I0zXZjKyybpbnwwlUUKf2ifg6YC4BQPeY4n2YxwundYme3rWXZozo/ujVuf5RUTZN1CehiOLoybDWqBePu/lHMfCpbsbBs2Lympp920Eswj3dzm4P8yGxxtZmNCjRsTw/xqEyzA9tpoPRXtzDHSyRQJvIuG368h81Loqpdnf9dZy7ZR3E1hvtQ0T8fGGioDaPyvpgvIz+4AGFqJyCIyAGk9ZYFxYJgr+QBCGRVey9ok2Ih+2vdl5I3RQDKAGaG9IIPEMwMJp1BRMutHfjMT4mFPNzp65l7DprIGfo7aFkLPC3sO5nmSZlxP4wIJAeMvc9ZQmhrFzJNd31eQNNDjLwyXPnwQh7USaiI9BQzL1sxQuGrFoTnb3WKh6CzzGtSVG50hlbUfeP1TsW3cXKyJUXOZSUDrBjbatnFyCOdC/zpd0h0BzP5OwYreAvfBd/6auoeV+0Trk2SeDkBQPFB2tDCDOujqGz5kNaTDfInoakfcrqhb5uRhtxAjwjb7zn3H9UQMvO9o6yPCabY9yuGHsSuasUCrtCaLY3+qzqjPg4fXNMoXIo93Tt8GTxwwtIXWSnmZBNY+29CgGbxBZPZpwCVQdsDBkJQwsfMJz1MH0Yei8bvqc3df8vrLZMOp8t44w6p17K7VYA5BGmPEtK/28MFhXQ9E/+sUiEYA/6Wqp1sMevgk7pIsAr+34dtAZw/xaCj15O8ZI6hfzc56EzooIGj/uGdo4zQ16YxVk1+6bu6upPa7CWTJAWPwSpI6WXU5p0/NBUrbzJp8Q+9NMEAJF4vb6ZtKBiwNkPvlzLpGM4leLmB1A8ejpoORwtHoIAEWgkcxsIL1OD45Bpovw9mhpmuOnqu9d69DI8S78+PmC0McRL43s0zRWOm9c0i5VlvI8ldYubBWpZPUrYopGrS9wJt8BT7zNEHc1gG25DvBow/kD4PGcY8fsvu3WSn7mKjEuMNTFRdiczecCiCQYSJ0bWkUdftZBMF+uPnhDAkAKmlkr3BlSvLwSGeCFEQPvDqRnTBCq9Ha8Hyg5/MHoEcUArO+3ZAVwfxkIpUCLaTSLdrSj/KBcqSOoim7i8ALS816m1Rx1mBpXHUxTP2lVoSf8VbFKl+8MNUmYPuUsLeTeNctZV/88PeEJzHszYszGUxy50YpLSmYhu6Dz9ghj4nT0cxh2nDh9L6+bAfQVZsu5IkMau04ztwMAUvR7VIX2hPsrMbgQvKmk2kI6uQW31MeGosJKFDlNIqEHKjudsjCk5+fHLh5umNVU4RuxZpIvcdYOydJAOICkrKWZ5ulijzyntefWhibNAe8GCqrQYN5DnsahuNb13cwAGgOIwFikv1olzMAx2iAJP4zKjkQcfgnOlIcQsFCydD7zmKANg55eiPRX4pfe++JGNaHvIzYP1DwRvcDTpOfxlRs0nS2UZqPTxHPKiZpV+6ZFytO8fjmxlsiqLULpsZZIx5HVZyqseIEgHt54Lzs1qkmDUB1vKjYnlrqf2Kj5WMskTWlgdEvp28O8Q3oRhJ2sbhB5Sinv5bSWNPM26espHOiF/a6W21D2rpv9rlxswU1muK4tA9W1AYaZvd3rNWQcZIiBH8mFMXTXAdjzgMTy4xttCfUalarzSsdJNpv5a+qIcX4QEdv9Yejq2dnCurQXql1Ld4V6tMGNhmH34eRuJ/+pZGVGND+uL+m2Zf5VaK9qIN/tlNPjAsc7ViWf8KX+/y72MOibRx/NsInT2uQlyKf9VKpUBfYggJQG8u0MRxz0ts6EPyU1tlDnYAIoEqqN0pq0+yKIzGTUjfg6diV6WpUmigqAdxGM6eD/Gsw1xvp4Ud62pv7qrCMwnlRt1Ay+YGz4HY+ZGbxDcRre0IxpzDgaLTtsa7BhKacsid6Ly+R169ZS4AxZNtBC/GBEF1OCUgbGr/w/z3IkRaHjzAlhznB8+hZ6IhXG0/TBK54DDx5JHrFg3wzdCQfmbOzMB6vcysrAXfDttPCsegAxN0u2bG8KWiyJNAdtmso3RVJ6QWghfmjePLyxUN0n3KkaLGEbS73WnF3+x7dD3xvy9f3IswlqMUSd8dC2q9f9FvIga1cy1xTMdO7p3x5DKhFNdLRFM3ksKO6Z4yvJP8s96eSMa5CeYHte+odJT0vPvBOGzaTdn7rLjyDRUi1U6rg1NQEXRj8IDH+GpgccL+cQzQqQb6YG0gDYnwReTwxMQG03wKXU7TMvPtFSHF1/irR6ihKjjWy/MNJdlZaG5q2ffUNJ3VqIqoSmX9rYg6qLO4I/n604I6eoGdP5uBvym9mpqJkyoG9HW5eueCjqnW5jdcCuv5r4Wx6aYXOU58zKqVNxRJl4RFsYUPoO2fNkcJQOb46j4pEzrs+70lAo7uQ+/rkfMgqnvK0GdwpnzLUxFWTSxii3vLymx9tXNfQ6xWRD73KwSbrPqt3bLlRGtmyltuxmtiZK8M1EEaFpjLtW1okFc9+iAnmYCh2ZQs58mTUWMYO8kz1iFAoKAarfprD4BLo2/FLC8oHCdtj/XVO5zCUKVTfb3GDKndRmmK3xKwgsD4rtoy7FcJTXM4iYZRCSLX+HjnQPs5zfIruntUDF53KiLm6ThvGTWNpKt7PhGagTVvblJ4hn58W2VZQ2KnS26bExxmeFhVfghaywEPPyzugIpZ2sYRm98kzPePyFH6CqUo9Bz97BTO7k5cV2ja/k2onAQ1RDgjVpCIZjMXG6TM5W4CUd7KkgeIHx4p0txIDQp/kluTVpDNfh6rKTKRSQj+UiDRtm7Z2Zn9rsx8lL3l+TGYlD7T2cY3xp1A50LJA0Cjw3NHTVCPzCdm57Qu+cSt6upMNKSaCtNShhBBpZ+aQlkJigrSfcQ+vaQLtd4m30xnNnGjL96x3zfgbHHgdcaOO3BvvTomPvUkSv3C1WbFVM5nXPmvtgJ4whtkN4WyfGLhUhDK4pJ3a9q+yKr/9SXpFvdQlwlQSeu5j/FHyRZNXQV+7ca8JneaXyqOOQg3Y/oKCyAoTTNV5jpkJVEqXXkFzcxFDzY3yi9AvqOL5uv6x47Wdhglifvsmtxm2Z/VsLlnlYxyCnUwWzppgHdEXkChkTnx6KkJe5nTmjgmsbgdpi8iwCnafrgSLilwXN3wl3OWipkBbCts3ep1tx7+FwGHh+iFFy0bubZixUK7hATCo7uqBDZiwEW0+vubxJdh7aCgq5T8Bpk888LxwNOKC/TVfiUZ47eYm/zUHLWfMn7ybNafDO6FBftl7MHBNuhx8Tc1/1TDr98u+gvBGSyUgjH7/zq1RHjUiwxeT51hJsNG0Z9r+IQhebRjLDaIuMyKbaMvsJINPo2+3TAXJpUXX62+09b36GH+w7c4sFc8N+8fKJ3nrHI+vrI+8/OKkM4RUam8bSAKiF3avXmD112P1q+Dd44MBvaT2cfqVcPSWyKddlhQK5maaK1lqNvHxLXLw61/zrFTOBRjFhTBF4+fE0XtbzPeYpori3MCb/Px5B1qOmNNqZTinaFd+25ahaqIuh2mIbYvIIv8Zo0BzaI8kaclwuDpoOkCX5dnCudOz8Jc14am6nXKZR7Wv4h7RaChPs4vWIvKfMXPBZ5PkUiySnd9v8ng5FNv9UEthTTXnGM8XZ+jARbk/gRRy4NtCI/L+FmPNtHSSRgtFmwi+D8TceIv/TfN9m3yEgLD6mQQzeh7ERtlh924tNexZqiIXZVifwBVgyRHWEPKYlXCqfc7aIQabW657jceZIc6fAEb4dlVEShGaRYW6UMczcFVWx+mPBs+LIQTy8I1Ti/JNfVkbNXwuXiqJVS77YzJ6bEDM+qW+E7LKIcfxJEyD2REcazfabvmUxrHbCpPcidJWF3cUcurnJPO2FCCgdUfIV2cKbe/gDYe9owY/38Tho4OILE1c3W3PlLTMhF/BHbTsF5HangwZ8o66r9u/6zMAWn35YfwWZEw4GYo3yazKiumFgQJcgKCa0DlX9JGgHFE7dMiGko/qN/LDtInF/rVA4WkfbSaF8MfWVZXJnldTpBDDPFHuP8aI9NuS2A5ZQc+EoblN4HULWuDfcZhXacEn3gDy5xXMMYpaihWtSpR8TQD+nnbII5eLjjhHrHgcvAk63DV/+P2AeBxDQdc3f97L1GCXuaSDb4ecyXzNoPyJ1y8rsn2OJTH6+ZIVTjj1TNY9l8rPjlgAIjdcsrdqoxqcwJVUuuTFQGJhQA7HJ9gQydPoLse9G6DWy/jiwmZ2r4/wyVo/oTezqo4k0kgyvCt/XOTDFRYuthP/7ClYmf/eTSN5nA5kUf0Krh6o35oA41FvFcNwtVQVcdk5WTTDm7I21i3ts4FXRU9bAzIQ6j7PmcBiUnsMP0VYMgMCVDUWEusuDA1bXmpPe6dp3KZSshl185mClM2y9oPQD7FWqwYlMrZI44fqIL5l6lIdFNKiC53l4oTn6RnuFmQIDIkE3ZweFg0ytVWN2PbYSR/qhOTojZQQWJz6OGeqbeHi3/MCNmV3+sdnZaYBbb3D/94QBPaBNZtkXg7YW3qlVUq5/8at61dGIylQSsolwpHYrQSk2afXOaiX2PdC5CFHt4z9CTFb9jkxzj3+AfxtBLFLf8cGUxTKLXY6yUFxjCZsjnzR0uLTa/beuEj2fvIrBlRTB844z6YC8ECgoLfqgqS31QTEFaCQrPvbQfSRx+dwBRm8y3r9fQspeYAJ4h1yq0jOqrMFkOm8d2RsYLz7QUEjG+Urw7HYuCyl6aGWTD8L0SrDhI5fqHPHJFD+ypAK61L3NzmqVg2AitPWYHx71Ko+mTkz5ke2e+xv5IWaOPJUOyw4oyP6Ouh1OfXrpyS8XhcIYcXQNiI45lmMyx4VQ5Gbo7BGeSP4mT8dYo3cNajbKFs7+F2gw6YWHhT8kmfvIm6aTvx78ioOeZnFDkp2Oww1ejFZe78v4eAMSKsCRzMFQ7sHJ+XBW+aTDED+IADdFDmHZf7G6RHK7LwsoCPRZqtFzQr3sgGeIu4ODBO4/cmiCIaSGK9k7wQU1Bj8UAKTzvp5y5cFn+n1TZdnrorRKO6srKgurci+qe272HcJtTvvbf43ijd+k4pfxHMi9qYKN6FmFKcEXXRWcDi+icosj0aPUdCAUGpQPbLMb3+6P6KnxGpy7KLf7bLAzvX5Q/ffpJCrZd/gFly1ZEL63+DUQuP1xMDaHJamdtzOr5EuZAKlhoa8w/8Lf/vN+1vOPfQnjcTIRKUD7zCls1Ei4RMouQDQFr9KWXJB3vFqYkA98U4Y8Bh34I9Cxb3CFvgpkS6oqAek2mCqoPnyC+ApPnJV4PNocyPy0eszuKicf9FcP6JYnussOwkQRpneaOTxNkRVnzM4NL7M+iORajrKE245TH7yhX5npY1L8EaLhhR4PQsPy00d2+Z3VkOORIKtl/P87lNqDr6bceLewbJPY5ya/+DKnYFbRxTwCPRFmVrfwsls7DuhodhCjzzeLH1JxSc3urw5ge1CS+0OLj2mhqTyAxvVVANwdgyNFVRd/eXK5R25Qi6fOXH4OjsKiR4ERFxL5UhcnzndeAYdWYD1/+ljLwCNVF6OOtMlOEn9ePMwQJXngEyLwppg5KvVSSXg/iEKSe+XqK3DwHCdTbcJSOJtCdvlA5wB2GmVDNb5XvHpL4rKksRSMx7RjhXINAdsiGQwcMxCVDQ/X4CCtXnoUtLhyyjUxj9b+rkRBwOd/7+g6Ig5lktXoE7WmN6/zhpsKgq3iI/8Gwv9Z4b/Fyf//xVtUlHPXaDkX0VmRuOeYmYuC+8oicOTQpMXgxCF/sc7Fw5bko9M0/ruERXlLnjWGQu9AELXa+caS6NO/xJzhUX3Z/48GUhmXPgsdHwHfMnb4RuppFohHBpJ2d+WAFe7hLWhRSAa7f+1DXAiFQB4i0MFnK3O3wz4bdAjkWN+faKuYraGUdirtuLEIxKxOdYCNgRkAJRPVlSot9lODKrLKIQ2wLizBe8+9oP3YGSYpkmY13lggxjXksNVVaPF395z7/6gVRzrQ4Z5qY8SusHbtVl7V9LB00KJ8/D04xTSNncdRTMfCqynmPBU4pDhXtFnGq6LDOx6qRHA4pDeuQFqnupSrDFVrT4ol01g9dGcEh8FT+PDOy1f6/PLubtoLeifM/mb1eavbN5m12yTHk32HqvlGBxR0vFimrCsMwvXHXXMNHEE2QYKahAJaHRb30+o9PNYm8ucrfS++LU8dJnOK6yqoW/W9A8eJfUUwWmwb29PrbF6bDUZMMgzz5Lk2cYmDy4f6L8r+HZ822Vve0prmX8oWqorM1OSI4oLbfG/2wSmuOffUgnOHQmv4Rg6TG/Cjkk47AeIhZLmgsEB1cTM7Pgf4JIuBx8xeMhuyJti2vOlq2N8+kFEpcJW8LQt95MncvVgmZbEGRmeLf7r9YOeihZYnKssOatKHaYflbEG+b9y/pYvXegtfYkBwGoS0GB4Tbb2qEQLCBN1aPVx1GPUxpFETYIVfirHiSPTMf3rgx02TUlNDnApQgBpVydt4Fwwz9XFdcBtvgwr5H3y0OW7WBgqeFvE6SmDHXIbSC0hLdwCWAjDRcqZEr+G4bxiJIsp++EyGnTS8oKIuWcp/RbTQKbCG/Df8a34IHiEpuCJPulkniv1H7BA41xf2G0bhgBp8qa0uLUatXohKiFaSJeh1Q2xn2rFrgo5PWLuR9bkkM0Ag5ko3ZxColVOmsSXfDZb6ty5aGAq4pfb38XaQ1rH33Vod964CL03XBc0kPgVicY7MipCPLe4jn3ofYvXpdWR7B/qvq6s5IC604bda2nK5mpXRWqOnwKz6PPR2M+u8c4HlhLjbx8ffCSDYpwFUqLjKLhgw44qF0DxKJ5Ntir7QNT7GDOmQalGaQ31/m4OSTzCskWOT0D8LQlJ8A9r3Vm5QKdkiRst+Rxu+nKb1jcxACPpKdheUkEyfTLdmavNoSK8yOF4RP9qXfq2O7gMfh43t6NK09mPkyJNpUkcY0htdlqrFf/6Zo6RjXkotNxZyyjoEcL9GhqFKp8jBxtrDVNkGL5wjqc7us331jfcTowOmVy9bpQKdVUKDyZic8cZPWxAVgBmJg+aHagOXbkh0AEnemJQ8PflnXwJlOB+D/EUKsy3I4JdNxIujRImPLSASGzr4UaMhZHziu56yZ7wSKkHrc2eNKtHfJ3M+oVl97ZxqICCQNU9xkjByPLJl/LKKvsA6nq0Ob+0Q4VRO8QJ3vczIGuPSazOiFgcMNnyv9UrmDBQZzsBn7lhZbv/5lYilOYE1mRznkMELI+G+nrBoQK1q+nSmge5j5OSFTgJMH4CKAtz0SDYaIioQIzohLjYLKDEpipXx11ue1hBYsggtMPgeNeSkQemDuKTrEBMJv3Py9NqT77ZJzvyZ9SsObUP4dhnp9zcE65tElotbBJQcDxo5fsnEfh6KaTFQiu+J4qTQr07yiFI0T+IxABDOLUWbK25N20FbjweC96YJaJbyDPgWjlewqET0xcgQH4EcUnEeCLEyJ+QIn/Ap43tMezmLM3KAjUARBBsI36aXmblPfHA6CM7DEOjJZTPp5RMY8RRQkorTgWJaGf6qHFSCytcHoCy6e/g/sgo2+yOymznLQsea4eP9OBaDqaHa+d7fzmgYvhgfZpTyRtYSuDOBLZvSa3mMCwVrTxMxj19cUDvZSOimbTn+GAD9jrx0jyHIFiSSQiq9GrLFT1DbKWqUE8gu9QHAXh2c+ty5d/v19Ak9nryUUPXkFklTbnHwgERGnzPKPPA9zZLzO5zhCSVQXbSrZUB23g1gyb2dzv1dQifIZlvXlWQIpEpPOengFBnrUzZPK81wgHbsE0GiywC/GtE+vlPbv9FO/c74+vR2dQjalSQernzfYTyJ1AOGXdi0dpaUn6kbeDqtM/af+KobgXIl9QNHVIi6p3Dc9aVqoifoM2na440QiCjlFnsdwYolJsEo+w5NkGEx+YnmzoZLzQg7zAov5apKOVSSsbPhZ9QqSfTFmJYrTQu7zwqAVgMpV5e+9ERWy5CP2VjYdR6BAT5sSGbBLNrYapBn6w/DwrTSeCnL0BFCHBm3XVSKK91csePblGfQBCukJQf+PZEYuRrguusgvjq/uiEFto7Ya6kIq1vL7eJqIhgCHkwuV18wWG8STRPd+cx8bkELqrjdoXtNHEgn1T2xbs53PUfRoqzQG06iaj645UuGCnv9o3XP3U3Hh1lIrZhyt+ntTOcqxE6fgSQFhlKFS/rMQq/rNTOql7QQSeqGE5mr3VdaHNmDG4qkv+KCLUhmexUCPP9pESoD02AYh4hsYZSIvJKluD0L4MwFk67h0ugUaIHLCioGNZkgYRiGL0LjmdDJDaSlwPbaSI3t9kNiRvcZpujaR8x5UvYUQ0zpdw1FMSpSGY7UoBJUdsbExwKus7hAbsWgwYMtn9eeD7vpUyFpDl80pzZERsAbRUcdFhjwR4ftlr59eJ1XFXmAkJHa56MCc/nKprWaxHL3GDbgf1OR671ngPHb+JOBqriI605dYRwqYxgjjzQvH7MSga2RkeoJXIyXmocNqDSNde5m+JLTuOrsw3NfxxMzgywFeJvpy2A2aaE1ymJ2xMV6qaGxWwTR3kBeb08pQFB+6raJlPukb9vD6yOP+APu0FEcq1acYGQcUpblbS7M1q/rEVPfaIXRGyet+crsuwh7Ro76cEuw3PiPmozcAV5gK/deJknB5KQF48RtdvhjmyNCDhvmBgcBo7aeGQRxHRA3xd83+caRSJKRwWuEop4l4FkoCdSMNlbdSRg/PqCqFGgRaHB4x7WV7/1diJyXo5oPZ88AqxGLI1TITRZWXgg3Nq/Lp8uBRgxKLnHU1VUgW/6W06R48xEYZlR2ILEf5kBBUb6+h7W4/4IyYu2sVT2Q+BqQNM1Ng4t0gNcLm++rkOo5G+SntnAcoMA9rtsOFBTD2UPam+uh8ufVjSwTUFstzn/o0YzSc4M48WExQiyD2ShoNPj4IsSitz1mG1+dDV2XjQzvKsYWPItQd9CWA7rv7Kc8vqbVXoRzbMQzPSya7cfj8L99eJec531Wm9KLUC93Dp9Qn9bp4zcXHto9eC08raSMpkW2RqUKgqDGAza64iZYVVrvNp0MJWQivExEUeTPmFFdAiyz2oJlkC3/C/g3bqeGHJa1VC+GfWvGlAuoDfEe9v6xQuXa5vU0HUt/lDRtwkgheuQTQHoqWYUniYcF3JGkpaZ7yeoffdwWgjDGAfASeclGp473NbtH7wZmLFX8Hfdi0N1tgBVeaQIglwPn3pMGjpy4TpAHun/ocqbsav6KqhISJqmRoSqLJZ9G3M1qyBjJ/CAPVC38cwZd3iWF41suGE3gOphef6iXYWlRJT2nCwYP33qE2b6+QzmV/LRjw8mJv8m1Y1GtbVchflqnxOVeiAws6OjKx4D1SO25hD7jGNIRwTd9oRVkSJuQQI3HqmnxeKH4Wig2UULgNamMekUBGkI4U8KQCyL/esPPS4y5GlZXnzT7w2EE8eAsAx1WZtKKu89rKyrAr/fEKtN5xd7HCSJ2mZaciC+TH2N/4OPCgZjTd5k22q2qzAuXylrfj1cRy/zSWv+5xHJwOyv4CIh0D/yUfuew9HniAS9vQ+ACtF2dgMmkWN0S0rjynoNPgg3oiMecETOoPOGnaT9Q4GtJvi3Qe8+E3sEdj3xCfV3NwgcVBhseH+RKsv5X5vrQicWK6T0S153ZZPGnaiqFH671Spn3nuNJHtlGxC3lLKbxi2PiDIYH4nZVMwoDCvWZIhcYmWER7SjJjgSYCtkhA/u+ndUNGLMntZdYBCjkFPTS+pqRLGmlAmhvmrTsNrsbD0Jo/G+UXeuzIfTce/EYhJi3Daz61wYv7MAeX64875WXiHYJ/AGPFvQWCFkH0r52w7BsFqhroAj1ry8QN5E7OKOzYHJiKnhqKb+LGrMuuYjmsTdULJELgmERRMSCrXOAj/b5e1KcbH/wjthLVZAWcJTHjZtAEUJCA+KkON8kIp5a4u+CseGxa1qjwwSUUS0xPzwh0UK2MOGE3EK+XjOIMPqRlha0hst4HOLHjxG1WrBWLFAXCSYYSooNIJ1CR94sC46TokOOFKMRfbWOcIA/luiQfLgbZ9gAe42nJFD1GynAMpVcNb7z/Z8dp9rXy/IoDMSYhWxSIiMC716Wg30jxSYUvvNN0+lE0YwiBFz6/jSOzqaE1iFuUAjTnOf6tWQNvn4um8JBJjiHNN2zmuSz83FOoKJPLHpAOZc30Wf3PBl2rYoNV1KT8fEiXJ1tX5RJaYw959sKgmdt1l3t5C96SCj3wsvK34K+0KzjcOpa3wszSewGactEphhCTGytQWJpY0uC05tLmZqt4PEyy5OlVFHNcVdyfl8NIhf6RXFrXKAHNUJykx03wFL3Y+FXINIyih7b+2fKjGJO4b28PQ4QgauBedYHU3jHmC56xLkfYt5+PovdOdmaQsK9RittLL6q+WSXQNRSl6NKSGczncwOLWiaLV80Y78tcGyRR+DJ/vXkWkSvtzl2i1LQ+9XbTjJx3mkNnrh7KpcEYhonqLtectR+yiQHsKKA3jvjNeSk2aF2lH10XAwcHrP9SwDGmiMv6V5RoS9tELHKaK+n7igjlO+HEQa20NNVATrpAUIBYd2vyVk8NsXJJqCDTuaB7CpXVO8Cq7wylNV2rwK08bWDjd7V7rK9AlZbvAAdUPprxb8mbHmVEKpaPECrYTkaErwy/QfwY4Dr4zCWgsPqSV/eti2QyeiGp9CtpUnTACCNOCi1N63YXsdgu5a/GcIycThTa30MGKCnLdjVKGYcds/lcxuNeN8c14g2rzZYGcteEbRV1t9E7zG9M7yYfVW3JOpOA5Hgbu2HyJIlOY4amIJDKigG4qlcU2ewTO4ghywci4zahQupTXFinDBjq/ycVJ7CEamT0qebpwWnhpCJL75wW6MK4t88KGHofAulShGvRy6/Os8Z+46KAO1fQwBh5cJWwFSrS9lE9L96atATC5p2Ypyf3drF6wZ44BFnXXKm4ZhS1B6SRgmzykpIJweRhteRbRxT86pwpUBsPggl6OfPaGeeD3DSchpg5SfMHy9kOFDmUeqmySC3F0xZEN5lRbneyWL1wTTnTE8qLnV5KS0qqxlC3tAREdLPW5xlASDYIVYO/ZCt2GLUUsIJFp6OiroZ2Rr/iWM7k0faMgWRrRVzp3f3p8fzXTCsMLcEreu979UxkaX/t6L4azElv8S1Ers/yNCIwX0vLZ5A6KHxEqLF9loZxgi4mvCHaJ+/HM6dzm5OG0WTyOXDXPttGXaxBpS5mFRGc+5s42EcZTQ+jBUtB0J+OHueQ+jS6A9pXlC15bb3V9+g1ROIBvq1lOTCM0+Cy0UIxBSy0BHjDgGgeF80YZfbuMuY/f/QLUMUQ/rgQtvDKtafbDyCxpCzG3U1OFG5Ri2TRtYXrBXJwRspVgg/wMe/mkcTlA/LDXjve6GGUqiARTcrMp9Wj1qGxxLs7kNryxPjQYio39X6f0dgLIKlxQyfALyp3k5rQszXoLHSYZZt10hHt2vBKPnZIX5dhCYyi90aSHEgKcLFNj43dS3zix3awmvS2ht8S/y77URr9hp+S4X4ldW+I8xad2mRyzwvS2GwW1yPLRcR5h7qco9dkDwkGHCx0XNQEOQIPu4sUCnfGzsXMQcTlD5twFpsYJ0leIfiJup9G6Pwa357DSvLD38UEmWW7nRYa0tIBx8u66iTKZV6kiH4dCYPVLjKqVZNiYqxNUgSU/aKhuNQ88tKephKtKiKGF2OXZXdQvR5+vNJJsDEngs4FMov0Z/dxyiLjmMdQLK9/SaahIJV/rcvoWnwjHj9mtZp+IAuCxWvA3jkoK3Il6yFes1N7mVFdZHfFCrCRVdZVcYh0wTGlGuPidWiqu0jBSSj81QLTQgKoUIW5L29y1XzOlgdSZOg9joLndKIXRpT2jdp0oSKKmUajCyBOrobFCP0eIxLhD5/jCnuThoRC2F5WiyBikFvFtlUI0cMgiJVOPoP5Rqu4z8n1w11t/BuhdL9gbAh8xZZpIyiDx25EGdPsV0J9nKEqNCvND4CDK8jYcMMBjJB/IP1xKvmQVFY9YBm21/Qw86cqG0VgrNQuagOey/I+CyVCzohAk0RvoyAZ9gN3RAfP11m82SCvlcaSDCMZBxXbR23XkWshXHdVB68PyEIsIP/uvZTQoqLdy2NMwcPUxjlidFoKhCNGGzbarfjmjkvoyAi7iWJar/g6cXyA5p1EPU8AMXeoyvZVdXbWJSq6XnpWS40yd1IIgHHN97jqSnBo9zQUA2JfL4bCuxpPNupC7DJ4Wd06TnXmQfjiqYF4moT3+SSjRLjZBmVB8U1FAAbi6epmlgDDANm+Ik1eGH/Z1hVgOGcWZQoBvQmTJT+gZVR/EoebaZpXt14Hfp12JQj+C7Wg6PpoKImethO7Nx80CTiQ5nr5KuLCSSmrRfC0TC2fs3q/mawe5gMgEh38wAdcdiXBJikcGWhSv9m0fOHDisvd4SNdN8zD5JGfGE5bApXpvKRq1RWC96vHrUSX7Dm4S4/ZyrGGaXoU1/6po8EMI/gyapjGL4Gp25mwGphaKZLrfOxn71jBq7/tSAEPVK3K+ChPq+i4cjdjAxi3HoYodf+yyEMJOylSknS3ZMmMv1A2/vWvNEK1s+Mzp33ygV+R8W7INWAMxfpuKw1QZnIvfPfH/woUQ2J4ez+nHPD2FUzSOnLENnjyW/DEixXvZATXo7Mtc0gSdFPMNC6cLmN22SVXlUU7OIBw3fVBRF9IEpiLj6k8Ss/Bsji5sGLHmsDEVOLhjFfGpyTtBZbfeIMi8MVV5dZqOjhcaBPpI0aIpyieT2Eykmho/EAfk81BWfDsJ8UeEI+OEpdugCCKJxsNWKQikN/WgXzeNgIZT0mfF6pcMWIJbmOAyf6xAi1JC3Do1eo1AkgTD02GLz+bXJfcojA77dspVDoHsERhtaUcOpA5XPddl9xDxj3Wdw4oqzs7RuywK86/Q86uDiD/x1yNxeSUqOj8Bynrtj4p32fqmty/XC35gCUccegeG4Mzj6u6FzEf3/pJr52s/ClOg52YBtW8DTlIxt9jPjPzhRE43Zu/kM8n6XEUgrGYxtFEa64Kqj/ErAtU1/tTxB5jx0bKsJcDMpkF2fvms7QAEFfz0JE5jaPu3E79br4p70kJkpFS8XA0cBMHZydwJzGPao40nIYxe6t9GrjqiMktlev/9LF3rhLCabAIXC/M7wzd1w3jtuDM5QHcirKrvqe3WNsERo3RXzk64ion6IDev/sU9xus+cLYq8CUGMM4nULOALnB8DFxUnZ1QSOlHFlmLY5zMfVyY5A9AiB10K92yHYCyXNNL2qTeAWnYuE+i7WkV5QwkDSgotjTuxRIWEruxiQ0vkI6G/dBDO8u2R1/2Bf7ds7pa/T5A7PXj6KLVGtGksiaPFLUhtS33k2oWFUijpLfMgNapiWdd4tZcjWKyv+LxmZ4M+7zVcgVUegnxc/1LTzYUtKBR2qcoe++IfPtagPCB8c1zd245XqFGuB+g9VhGFsXHVK/ZYRUE//+Y7gkSX71BmmNYHL3TQrZ6pLT92gY/pyNNLVOaWrntLB71v8H/Dm/bI+UbbpLi6qXSknMQbjpE8A3dCrctIpz+XLZfB2h3A/lfCa95I8ckg8FNG2FhYxabv2ihty+2a6+0rpLPG0MGl1yhZhOuT3Ny+CKS33AI0auLMb/HFoDfarvon1bYBBZ/Enp/P/p2qvLtc7Xd5eqTOlAsCtsWHISxcdHNydFBMeKIy7NtiZzCttGzDiANozCpUrb1HM/ePPMtPA59snVP33zgA5NrQJCl3yIq7ummjUopDpm51sBqx4E6xaZUF9Qej82bkkyBvhJkWmg4rMTL5VlQb2HPM90SgNxcmevuEChlwBgn1gyi6vb6rAKFBgFFJNxxQaRDW19kKHT2u4E/BzkCOTHFDvfqnG2PiSP2BpwKV8ScnzoXx3wDp3SaMsgLPjyGf9A9F+YVzbHZnA9pOCklumLX4EYWSDltm+A4GS2cCp93SN4T0124BFBiKgdrsiqN/SHHSWGd0MCI0cWFZso21oODncuBJ8mgEs1S9dP+eiXRxk3PtlkZr1aThPXdaOuay15ktOpoUnDGe7+AQGXX4vbRERa8AHgJOosJMtlqweIrRFKL8gU/4nkYQhZY5rCi5nXmj74nsGtL/FZiOFEEJSNjtIqrQK5sYjtzUAUztus77nP8ALsZw8QIO2sLMAIhqthyZms+CueqA8URM2ui/F1WX6+cQaYtmxtetl7C6X5qWKXwx8A2WbdKVzYzKEnW210h7guOIfy8MNVg5UpdKFKGqVHlErLiNhsC+9SdhkQ2/YKjUQOA8sz3VnttbploLsUBmQ7VCzL2BtI+2NpVDzMlpkE1md470e7BFf8xnzA/IWa8K0uuaBTSgGClLBGtNR4zTqenvGWFHPuJIk+HvVnGu72XtX8BOeNX7vA0kw6d/1rMTdwHzcMRC3F0AsPB42mxSJATzXbM1DuS6WrVDri8P7fMAd2KtmkEDJ0j0PUwBb1gzqZPEgjDxhHXYBMBMrW4JDi08bpGODwi/R/6MF2vC7Z9nVDnrWNj/tgH4/t5X2cEBSDsOn2hdbfnFJmBKaRboE2wgrCKbxmWRvCOU5sI5C8WHglHV2QOvmV6kfwa2OBF/HobIpPAynTFB97EnBpN8aRTgfVZhTIsJVIlDbD5SFcjwuiBm8UQslvh1BFosHCI5iaNldmeNP39jJ/8X4Y0gQr7LQrhfse7dhzKQ/Re5c1HpGiBoaSxAGzee7IMLbgclZKUy6yadVFR5cGjtCLESYDjGbnNncbI9ccHfs5VAcs+N5hczZC1TbQusWYwNZLh/D6TFs8CPtWLux3irdJhzgv8rrE/+IqmJgsVanE/AdD/yMkJZCf+lk/rJRNxc7Xw/AQqoyCsiPqgVUu1JitHvA/0lrRkKCSFSurmao8gnDE0InvvRr5LV2lSDh05weHPoVwa5ZNU0GxLeagr9kUPWhP1blH1e9Gu0KuV8WquUv6dgJbtfXDN5xdp679hfOKFaejdJVYEYx+V4uARuSVVIJGh4rwJeFvvJuR5ZR97N+CZemk7eAtiNegbkHiupCDfCVKhXt9XdpSdprf3HsY6Kwo7h/AthMsYp12o9nYIxcLFFUfF68YiF+67mLUg1uEA7s93Bxsg84Km9ONKmRKOoARCe4OUT4DvBzqHK8N32o9z/+zcCBV7fCLDnBTwozPSDWUEPIuQDR94PKd6lkG/Abe9uyVfsSOY7K9Q3fGcnUX7ithr09oOSpTk+sgCpNAfqQaiFKs/bt4ypGgPLEe0irt31qseTIszxFzU6Z6i4eTmlP8OFpLm362UeKwVvYVrcQlp4zIhNBKkF5Ror8npwyJlqhFIgLrpWajHy0W3pXizBtHmql50ip7Z1b5nKJZK7IZNJvltWcTUMS+Dnc6SntOL6OnT/HO7zMhGZOs6lCEMcs86ttZ5xfTj9Uwmqe3L64u5pZLooOL/2Oybni0Cnv4drvCbPNoTRhkZfCGYTqB1ywTwPzYe0Hi+34TxK5401F+/6czonwrH57Ye/E7XW3jbYIHOsek6Fwh+W//NLSKkwE3wmU09usD57CTIhxNtZDqjFGGPtcOM0/gUBaP6WGkskbr8ANwttYsebhYo/kKtuVgFw4CvqQ7VK3mcWrzToMzGs/Ij2msOmjZTfYBIaTBXkMCSDOCGg7wNTGTOZVnSCesKTKsNve8VKwU8vHoupjqGYmINusACOAXaAZFOzcor/gki6dxWLIQ8AAG+qwXnyj8jg7lJDipT8rgVhWPzuEyBFB41ILHxSG9WzwMH2pgdg8sgBxY05/+YI6lDZBcTaPUIWpVYWWLhuebXOrCDKoGqeJk1T9Js3l27vkw0HL15QuyX3xV9EtJyS7xeZLbGqBRL7GdlgRQb90pHoFJ6p1v7CFKy5VvJfNnwHQuQypFhhcXFlApzGoReNKHSBKmLgIdruCzeQT2Ieys7rpRKoa36kvSXlFGMbYWr7PxTIpjeB0/6pSOyIkAATg1bNgHqtivf/9dCoym/jNeBG6hlhFto0IpmSA0HITt+HAEfLIdWB61ZxOd8/68l9iSbM7EYQ5CCc5F1I0YGn8lZmoq5la07dtXZfvPngfwYfTMbROGeZl4TzAFoi/PrfUjMYq8xwjlQH/QkdCeWo1LHU/Lfo1tDTZnA3acXz6LVwD1XyhniF2zjfhIpYl1wbqtHri7jDZjcwTYONWwDLnKa8ZP6C8/Bb/Ra5+VIUvmhKT5rTb218xQwe+SQwUdUwybLDh5XI4WqfUofEttYNqhoT296mLhQgNq+mlGKSJmAgBhEJ3XJWr/RwaaX+/0V7TSWNbZqneB1P18EmGEimpnJCzAs2otMAiukOgDtfdEDpBpwjz+LEt/2jYF9jNV+iUi7uUAZkT+R5E+tkuNRRXE04Wg5S+xYy5Q/gl0LvYBBwnZtLghrNDjxWtkfZwdcR3gBGuvUhR1CGbstwy98Yfg2fYBC9gU2Y3Sv86zDMfB5Oq2nLg1ue+/4HxJcAZRnr2M+Sf0wS7vk28f490pLcNX76FoUp7KiDUHFIcFFUwq/MIh6HlCRZjpxzJM3f4MvoG8OoII0JRV3m1fq7W6+vWbgrSxO6p5fMsSIBwbqqZx0C9cWpZdnmY1J1jnyHoTodA3unOBq3uFqxAire6V90CMIDeouoLFAP5Q91ScuuzYSeC2jOgcqa339zcUiwNKIbq1I6xVz5qh+rO0bKB7Q16Tpc86Lb5UzqsgvCgw4lbd2kdJNPhpFTWSkWHDykeXhtIsgYVTu7Twc7jLJpNkmXMzAdrHfwqrk+OpYqcjm3IwJLpg3M2wAnus676AldNYXzhkc9ueLsVc2qJw8DBOG0byhz2wsVT7IV1cHrAKB/USRZqF+C5MyzHn0poRRrATRy4+Oxth6c5hqkAFZpaKHjva7xvSbi4Kme804gjzqs7bUx7eqVOEkt3Gw8bgAJgeOMhhIS4OYtETjIsYO9jyT43fZ+D1sb/iH8uP6mhvYF27oPDxmNHdbE/riWc2Q9sON3JJf/zfJmhqjocoBkV+mnH535sVql65mVWIuwDt4q7dw0lvn84dt3xCx0j6KP3fP2+4Ntf5uumS9iHa+wKmFjhpjvjI1NmFFPYA0JrhgCol8ahw5oZ2yMP6Bsh/lTVYmpB8J8yetFTWeooQPAtPbVKTEPKVir6wmGP5e2X+VeXhL5tT7ZC+tWfeizWUOb1Q8xLcRJ1OzklxwB7pZwWsp2qkbMD9VJsbxq0McFI2Cvxg79yUu+ay/gvRW+6NXuXme92nImjflJSKpn1nyRBTL0wRgc3IB11foSfwPPxYFZEAe7YfbiOqCRR621CaEWCLs8AhzRobglMg64yn836OhwVuNOZ3q1Qc7UdB7n0svus7SULInJl+oPnrYzBESAlO9DPBG6LW9dfQE73zIagdAPxCdNTSDcvhiKTcl1QTnHz/mPTshKn8ItgVp3MA0+4hZScb78BZt7NclRoAhK9HjlJGSOjnP/bCLcbdaJKIZOntRrK2BZJclixYKqwz8Xc7OVBALjqHxmdIJTlIw2fkxSgZAf5qOLlJfRZ087Mv/lGuIzaeUaQ90rn+k3ORl90kcwcZj/OJmIi1qVuW+JIRpI+iDYO5oE/6dIGKyQVmw+FSLYhEEkVzZjexCJ4gtXo35BnGTIquH4gvqnBt4t9z48h6sc00ICcP2isBpcpeRsYtBVvA9OD/G07f/WjWwzez/mInjDkh4RQVvT1WjuiTjo/7KGY6jDg/lYTls2eBqQcL9VzHAv0ONFYqf8uXije9b0GUkrknULjACkJw9ecrHS4PkH0oOSGk+CHgSqT+82NS8/AOa7U9TsOcgpHXSTFpQGZEKWIx5N3YyxR6wRsG8GtfW4R6XWCilUpIu8RdYwhUTPwOl4XaOZq01cdB6kN7XEJ//U37i5YmWYaogDSVGKAzXtyW+YMAhnAGmiK3sbDflgg8jzzxZi6jM/zWo80b80xY6IQ0IbtZSES92pqvQT1STHMWtsjBJB/PUGahEjrjF37BaoyVV0+oxVnTkU0/Bp70X3oEpreoPzaQZbVp3cvQKM+6wmriGXbv4SEr87rash2QRM68bRTcT+RIPAECC0xfnNKwe6U661qFcYoa3oJDuYWEo8YMHvlHoW0M8rZAsXI08D+I18OiYCjngHftOJYeG+dgR127pJN0GBMANAhdqu8VQlAopbMtwGSOc+AlfBTGvf6S11kRJciOrmUvZ8FY8jUIEQOlPCjTFlHWik7bcFOO5igsT17MgaES0SMSd+0IyNnO2G6uY39loIgf281F6OwDi+vEHJYRGJ9+vnihZDBZ+fBeYTQ96vy6sn3/crq4n9kw2qGy9dcsQC3RsLxIYIZ/O2vbJ9YOwc+tXHhzv0UF04tXH0AaZd0zJK58QH5WcOO50Xsm/ZYpoGBu7RghotD5YBhHBmCihrNSlsEfO8/SdXaIppunDqoJR1WnWImK5gCJD7KI9gCSV5zrZLUVI77gnUd5LCgWdPilfZLl8qtF7hrPUiZ04x5a/KMyr0O6pr2yZLT2bfP6lmAwGk/V5KtGnZNuOq/MtH7vLYynC4wfzGhxnvcefPbb2AfeUvC4TOKPrr20hc4l0Js9N3VifcLjTCx5xmamJ/kBka2KkuToJHJBWMkTKaZWcRyDn8W2noIxGZSzm9JSmwyXycje0Z/LgabThtj3gCNoiB0AJUVeLeD7pb19VcG4LeInWB5zjwUEKkxEnIr4zmc+fu20Va8noVlnepaaB6MTg/YZUH1CnPDglO6by1jSazbBBUUzLc5RCBnKc0x/uUSEX34AWXVVnoQxZjJBCzdocTePxKtX1Yz04/WzSR+BLVD75SZT5c22Ai0Ft7fS6F1yR3WygFp9R719sMIQBZ8SF9LMM3aKPA7Hj91efVlUVJYNJz+VkCetGjnaKi/RdkgGavR6O7MULvyoe6G8w3nmhZ8Mw2j/qj0sd/dvq7gjo1S9Th0JuzHG+hBmqeio4mbjUnrxQVDLJDL5Q6AixYcZeH+9J58dhsf3x/7dEO+fe16r4Wv585ZM80Tuob/hWSj+xownaetn+niAUso39fEi6yU5CKvuaZqZB76tMC48MNVimVz029SNBWA30gH2X/8vfkOC9K+fMtn5u17gJfuRonoT5cZtQPoZV3nbMeIfulLgMCmRTNLL/8dVywP2C1WILZoPMQUF/Y69KbDb+vgmY+5vLutKQigl+7AXuTU6ACuCf7dBP8+i+Vi0uGjzl/nAsJWzjWF+ySvrGV8pgJJk3CBQd9Pewp24DSbmy3Fnb5NQmsaurTwFCan5IunWOygtoCtaFxEfs+LLv8KH4Xl6590PzlN7m0iqirvZXkse29M7jHg56+wmjBlCI6BauMQ0mnI9/EGhGv8oTWZCanJxwvvRh1CUlvMgO+1VmSCh8USNHQIM+TJ6FcZBEsl7NuDaeKbUdD1q8NqsO6tDCxuFYmwBGIssuRN1FwcBmDRR4Y5zBUemlfLtTTH3DvOTk5e5+9tQrNWtRsho6bq9zcpqbD/BIUEzpsOlACnBrtrY/jHeG59mGVV2pjTTooHu2+SSEasVA918wOik2Wlw/9Roxp1nfYyRaqDdtWIvOBFViXcHV4dp4Tqo0hb2oXFUuqGyZYvpkC/rmXoC04IfpvtRyvxdH9Lx1vG9TQ8MYeZEUfECYiu2NhqwvtfhCMKEtulJDiVT+QlmS0TsUmJ75nuov1I4Yb58OqByhW0h3sNiHGCZq3VsSlMRhD88L/J1AOrYXS/viei2MzTrjAug6g6xZPHpZ6np0ZG3DyIZ/pxtLU2IrtYmOGGKf5jSDMdV04l9zR2I/jo3Y+qhmasG860hP8JJm41kxS844N3m2dGkedytEqwoKc3t2iGyg5XRhR+3T8gNBUAC84v1hAvfa9SOH9yiVcntwlur/axnsikC4wDn/w2P7NGnxH4qB1VQ9tZZ+6E/NkuN9o0A6hvPIXi/S7npL6opIoGogsDQwdtqgCf6x/B5i9x2AeX3w6qwBgkb63K/G9rwWcAi+m9OAwB2gc7EbdJOE7ONTcnY1suidfOLidumpaqTbdWTCMJLFFg2av5d4lV00RE8U4g1fFyJ+NvjvtUpgpHrAiflWbjnSv/q7hhU60hirfYR0FkFjNOH4NNmJkpnMyKf/ox0hMMYflQRuMf1CVTYr94lNiZ4ggFCCqkvqmUUNRk0YEcIJPByZdMwALKwCGAnQm0Z15eGGVzSqVPA8fOHQm+9AVU4iyx6aZ/9zU0LrbGFEEXX4eFQL78mn+B9mQaYjZD5RbFiGMG1zLNl9ljURmYViYWt5btyXMja7O70uQIS8QsVadP6RSckAs4MSZQH+8XDQIyB7EpunQ6vvj6pgPTMi8KRo6eSq5JcptNzfbcH1l6+JHUaR1RPkdgaGtUtKbAK/9Zb8WdPZ0FBWaKiNuPKsHEXSH0/ilDqkl6dIJCXMzemA0me3Ber8u9h6fBLgWUIFeOeKsZYPlA4m+sHAaAS45DtyP5JlHrPk58SL4nH7xezr5RYPwP8I54QYcdt3re+gMGnqjCbJvPcWZumyyyTDbnZ7N2TA861OIETbZPFB+tNOBJnXb18lb6Owv1Q3r4SzHWk7r8gj4nXMEs3+GCVO2a4YcgA8IHceX5jZXjsHKFwpAN7hEvgjQNK+JMRuG7qNLAyP9EEWuQFaVoU1+l6QbU9cfjbXWvJtVFrZg2EO2xM7O+Q7vDkY/8gLI0spSWS3JQZAMCM+uhdxRDQK1uK2+9XwX3DiHt3t5u6CwJuO6gN97TCbSj7Exqbtq1AhxuNYY9Kos3vKWfcm3lNcqOu+AHOSH2jz2Adu5vffYky7e0iI7N4lBBjjwgdkxRGybLKylYVyQO+n6Rs9ljxaCk9z/hpKYHsERpyx5/gLeEG5LhdiFncGz2U9nMHparqMuPYi98gOnJImOn0qua8kAy0zimD368K+w3wmV4TcJ33kLft+93eNcXGatRrKcXVCo9FmYzmfUW5Z/PRs0AIvURxnN4zRQ9nItwNK+OgAPCEbhgfCPV+9ViI/cGQt+n65r9A6/Ebt4zBDWq4d7KXuAdE41KPyMmtM/ra3Q5zOOa6hZZ8P6bfndKfxOj5dT3pYbTqzBoakOdsvmLS7l76BrnbASm0cno1bSVL9AMwl5vIpCjGrEcepTEJMytjuljxNBDsPOU9UkDbrZ/dJPJ6SzJTNDIdZuxMxY8rNqJyqMqaKPNLzgbhAB8p/Mv9rDvUUM9IMsSHDB0l0s8EfLCTZg2+7wAyaQL5oIRugj8wBuubS84+Vtg7I5ioTeh02hBhQKWO9e1pxXkxYFEwm3wgqmnOAWAJThGpJnm2PsJKyl70WmbiNfTHiFVqWGFq523p0cF8rnTj5+wdAP14nsFlP2cy6bH1mzo0TKJAC4UGx8ZOeKLmVvQ2GCS8rf0TQ7wA+CWCcKr6dE4pcsAFsvDjn6tToxqnd5PQKD2q8aZDabcXpRU8y3osnuhgffNZTGJnHlJT9eJMaAtrqheh8BQx+iTnkxLKJLssjWKov6Ke8oO+auAgIPkVM44I/6ALEd46QrtqgdS+mGu4bXe7/aXgYbqJTqWqqYh7duk2GMbyMAS1F7+1bQpyvsgBw3IfPwRWHvdiN2a1fDAW6AUz2XQqcQ8Z1MMfctkXUr2EtT2ApS5Zv5Ki0cmOt/YUf/VdWJlAZ0aTsZAESwFjMqyevSktFdLAlrJIAMhfuvDlXQ2qcWffPbQgK5RXS9zRSLEiogmHhlVXiKKGWIhVgKEkI1LIW3UTYduq2Dn1JsUoaqr/CzcG4k7vhMstLclQF/KVFHrLm30OH41TbuH9zTFA74xZCjouSFwmBYAoaPQR8n+qBtNXM1dgYS5qTR+MgnmZHVBg8NPjrMii4XbdHOYwh6eF0W4evPIaXa8CZsscr7D4wDe4wZINVWX+VQ5HfwddRcL+fYzoBMByJp7TgfaXg5qTJ9sMiUvqHrvn7CU3cwK1Stklrl1bmjCabnBY7d8ZVi3dLmRAqHHNKdiCv4gEGHmGmfNtb97lMv5Iaa8qCEZ+VLd31Hl/X+xCywwAmndcZor927gBZfD87QIm3pyiHxqVxMBwAtbsuLQ84mpIlfnWi/x+tOEVRzHbpyTgbHtfWX5W4PdnhpnQs9WFgkwNxORAr7i/ePwh5W8pUmwyo3S84ntSEeCH3yPYkxnsOxnPxX8mZkpxUq1j5N5zInMiQpqE+F2pMn6OrERXQDR1MAa0kpaoAhf51nEDkZn92okKwgHk5aQ0fkrOf2xSZ5s0HXb3QcUvg24nGH/8jMJwcOpfOQJe3RSzThVKBxEtHXuJUCz/PFRHR3NBTpOORjow0VDmPv0gtzgCinFvaUEi7KkCiFA95KeT6qy9YuP0dlGhmOZEoRo5Zx8V7zt+Dr1/EiAkPXop1R4O37coeQKujFQArpBeNIrpQnDE47Lfsze29CUl2ewLN6Mfhoi14K7X8cFkVAjstdB8bSqEsZqb8iJ8lp/UNUCjHjiFVcxv6XC0/CgZhQa6utJkzMk5BzpSmpFqIbyIM7yblIVbrxrWfSuW8Imslqm14VccN5Fbh3zgJHjA5W81RmbSBmAD3Hy+g1f3aSOmXxtMD6GBPm5jgc6v8xkQtnbIMckvWrs2iWafFLV+AQNzIqOYSsWH/3uYWAXrBXSJP3yEuscWI0qwAv9UWVMNBpBk+6hfEvYz4W8o1YHj9LZn5qoXiV8WA4sxmZmEjtd4EkBabcRdrdLfZUnGKLfN57tcRCTVFa6tZlA0WeJDDkaYG9ZOQIhq4Li5G9l/i/iN6SD/JLpv3iYcwUOKEeozqRueNSQHjp6O2nT3vNydUw4ITvfVhbpPrNiktHznHiJXrJAKQvGp23Y0q9oxymL7zC+tj7BAlkLuLWNouJ3QYy88E42mPXcOuv/CGQl8eDaEeVfyPNUnkLkAQ6FTFJWmblVsRovZbYHt90P6FZsb8dpZSdahZImwrRCAOtwMKouMQnjgwMobAyDd8Ifl/mwpIJ5WfgKOOBE7rALpo8zPlh/9cA31JKjmCpooxxA7KghoZk3m89SG7FBL/8zo0sa8Npu0UclPzogS/REVJkQQQI6NPe6Mea3O5qEjLcM+B2E3HG9t3jSkuZasedpg5nFlKwAa0yY5ENYfVy+JoQpfKc1pR9q84SAp3XmHfpZ+d2PQQ2itaElH7yEKgN3jBbqoQ7z2otHKaeWNaVIn3SRjzQn8oU8ycdMRApRkUwqZa2AQS36AEZHIcl2AkzAAarcanW94ASgNaR7xGesuuRPJZ1TEJw16lcO0uLJf+S2ugn/zkVoeV6bHv0ZpreHbH+AW58mWXmlBOKdTi7d9xAjVE4MxYTCpAHULyCoXunMZk+QCRf7N9oVjIW1kS1VTK8FPL8c2A00llqT0bLk0pzqSDUN0zWnv8Vu5lhkJgAqqCh38Ic6YWVPvA7lR7kj2kd8OIjVd5ub9FzLyLI5a/5NckUV+kR8+8JVlJz80hMvvcHMVArPiubdw//vwXVrSyvV5vJvwFmNEI/720aXK70YIHuOTCnojB+pzrZVBIxh/X1C/l+0c0KeuDTYb+J0XfBsl0FemMPriik7BGhOYVbT0/o+KUGmg8bZ2oXw3g4OR2BntnCYB0M2Z/oeeOIHgdzTrNlHT7b0e8TZQsrec2zXEVu5757OrraMbVlF8IysA9xNtWevSiRHn9vKJ7+4IDuhR/i+llEfBm07G0Wz5yW066ZfGHC3qq6v9+4++kx7wTfxDTYZCp1mK/X7Yz5QTPOhxFtgrdZOYRjdeRtCosmxadNMC+eTWF71qn+d2yckobK4KqOWTNY/0wpPBzTMFrF9p5IYqUVIydX0WdNwZmP9p+6PSttKUNEiXakuLeZYiZ7DqvlH8qSYgLUJnxjhvt/vGgVmOPNz4p5B3s+Ex56raWXaHbgjLsPw9Z/S19DXGNTpIXVCjP64O9U9Cd7qkSKHnoaK5tKytCLgtpSQj4Wo9dMZiE2i+yuCRAE0ONpGsM625upGdbaTMa/iYBu2S4KMMx1m79bKfwPJbP4iQFEeq+OsPn7rs3r0AlqlEf4vmP+en7Ky2Lh0yzMCmkbczp2KFGfhRXhgPtS/bdSLplve2TD9FTG/ttfsZaOqQh5xG82QppXpaRCvszL4Qvfb/l+e+4blE2XYkN8bP8gAKolZgXSOIO3LrkZC+l7U9ztoX/2k7wHGu7NtotKTvMgpvsLxuPDRG+O3/iC8D5aZohgaOlOv06ON52jmxLiiAcUnbh/VXJI9DEucPuIqsBnSiuFJn1QtyITmLGjp5is6PRpDq1+AWIrWl/BEE0ppXxWLoECx3o+ZLfRIKKhgFbor3DF9DssQcKdjH4CBmG3o7wsLrv1oGyU17sNW3KPTwNzDD9jcUEKHBx/lPfEzIMkuysH3jZIG+SKakPj4O/r36ET63YSWrlMGkerKzXmUHB4foReGpGbDOgRoMX/6M0h1629WtYfnRkVMXa3mcWfD4xY1068hVk7LdY6d/jRyr1eKQIZ6U27T+rFocP6Z1kjVa53WOiYkOFmXsZdAzqukfrtyBxffW9SxbhoYNesqQ4IZ3TTUSRl8lsfO387ysS6seThvMn5tXEyZIgdLwYAKL3HxSYyN9o/IT6IxVlbqTHommUHe2SarBE0SO2C6o2MZsCz6MxOPryPXAOFY1A9V3zjNVdnvHywGnsCidZM4PTA7R5HKDYc/TtwGpNzOKBCYOOMM2U+LvPkqVa5KFuLhNy347SR8VRKIgNxbkCOZQOF0+/XfThiH+vvEEJc36YrnpnkT/GUU2QMN5uRIkEtGg3w5+8fEPgqazyiacxKzp1KerWNMAwTLWRN5w23vH+zly61HOK/aDOV7OVzuNdO8uJdgxQPQs3qsYJgjT3dX2NAMt74LdZCeANtiFbj+T19aqkvc/pirX1dEZHmaoNFLGtW/RPPbXR+zpy2gKD0muqh5rXXOMmZyIC9ffsrIQAIeIwRhNmpSRmd/UFLC0jw9WkoOJ2phU6ZmtHnel+cpHF4h8DTETQxdyowH8OioBpehQCEnIt38QWUT/NVDJm/0ZmqzewdeO4hn78mg6jC7KasLmIp4KstOeUYvEGrxTF3h1bTNAu04Asf7lpubpEqjxdcFKlnVBf3ieim0WtssFvhm15dey1crERhUB5h8axo++iB5ymMbaWFv6DgbZAgYeU/2tdAZ5e4N9I2UVzwyChBM9eU88DNLABy0rXaIsIDipLhad+LQVr2x6wpi+vgZ7DXxriHEb/ti1MMfMJLOOXGgIWa0ZQBdMhGux9KyG80uayHJhDVYcg3KJplgRm72UqTIfRTU9zMGr0PQsaZiHAthtSRESSpOTSe0WZIcn5fYFai5oAKtBAVj4+Uu+oXZFTfjvUX4zhy7GAqDXSA6yDoZKWfZIi/C9vkKil6gSnFTL+SVdVA3pVarsdGtOUIr/qFigg82spalNEtffEloQ9VhJ9M42n6jvaTFACTtGEWM/Rcz7tVADSKAzOxbKJGLKGGY5X3x/g6DW2lSs2Hpslbda5WmBO+zDpLqG0teh++Ahuu8KA0QZ6V996lf+D+llvz8KXXiNcgw7Jx0JTX0aMAnBKIB2qpMf7fEE52ReQ55fdAerxfozuQ23ntx18YXHSPwfnCB0MqqedrEZKZYIWFmxqL1CeB2oWE2DpBs6mM92CVna9rT01EMRlUBGxv19yoppZVJcJGiY4La6u9ZwM3dYoc7ro5FM6JhgT8zPdy8CyDlBUVPA/hTkNvixFP+Vdb/HdIwO+xgzvC8xcV68qHqV2TFoFX/Sruq7lNESUjvlzEYIt/OExjjmYxSugN3mJjkQlb2lgzpSa+qSKuSDo3TFgP0YwADEWjZTkWiGJwbk1P7E5O+Zqj3TnIoQIlEUsofvsnTmsYNyNaS/SprGz/ZDLNgu6et4f3NtXBn86yKBkOK1OR+j8id6EqYzlsQxG6oWh6UUVRDCNzjioB/ykxCclpB+cBr//5Sl81qY20C0Pyqeg/GqQcw29F02LCaC1kHiMY+cY9l/PBQK4zgWJ4MqUhszKuWBgiQI7mud8QEUk2ZAX7CO9r03JWfT0S7R4jQuC8UGY6cYY9jl+opuJ5RWRTNbNyR67/46y3wkhfzHSaPPZawXFOZS45f6n5SXg9ApcigWCGlSexfj4/Ezk3uRTAgTOk5qzHYIT1Ib7LEYZ+KTT12QDZpatwD7fuPd54RpRX3QGrT2i0IV8EU+hyW3GGBR7ZfGddkn0a15+t1B9sEm+m0ez0rmom1S9/4DZru+aSzmBNuSpn7Jrp9h6Z/uy0NGpVXzE8HpihFLk709Uh9iHJoeloc1eBJR8zy9g7Bx6tMn/VImzMjLFVcnxXvlUPita5WDsXk1MrcLIYh3oPvAEiiDPCxVeHIqD/jhJ74y6V1O0f7ncVRjPMZmIHWCw2P/vv5Sfv6LEIXicf37Dxh/1gP9NQYQMol2YOZjiImjcJwlXu5HSH0L6t3GI6sK9lQZLibHY1V0WIZCGePq43z12ART0daA99XOmTCrxuXi0ZOsNVRcAj3McucdrRHKLVx7s+WtmvgHD3fCF4bcz0cPqrTKwpeS00fqNDHAm43KZSObYk67fc92a9hw7Vr2fWrWnMXDY9O3fQejzGlFuRpmev0NWhfTA0wu+bYBp9Yf+VpNrzvF3nBF/qRoaBsKJV1yStvnpt7SkDgVcwS/98ZzEq+3oQwB03q5IL0B6/l50hcLokz8E9D360mOm7EE1LDUSDXWDspvZNk30/WkQIsCXmeD7SvMa0AbGI++TOXFHm90jnzLXYn5JIbJlTmlePZPw9wzktvehNlWaCUbeabsR0Y/WVKAnlvoXUZ+C9Z3sz1U/cNCTVZL1WMWdsHm2iwxQdw9fQI+XqtyGfzZkyCvlju6KQViKMfcYZMA49Gm3OJpY6Kt9HtQjgFWqts00m3Z0OHJ8gl6AFpq7iizePxFTwS6PCcctVX0yV1fslMD7KbeoQ1l6MHb2ueFuP5az/IjX/eryZfhKFidpARC2UZ58qYZuYBVfxNVsdkBbQOT7r+ulEg/hTn0u/oVQyqrG4bmILiTdFRKU8pV2TeeOkbBw7BD2SCfdDQxcjzpGYbbjiH3Tp4lQn8fJm5lhp1IPuPuiORA7amZ0A3eUNHsb7EA+IQVXMXfytb5iICePH8fCRVxur4XkN1endK0aEpTYJuuw6E0eWfM1ea0KI2v573yjFdeR6s1w1AwP3F0JuecbiB+F2Qhb1nRsvqlcRsmt6THZlGNunzwO48Zb/u+1XF3Uazrz+IN99EUs4F02nfXTFL07Uf0+M7DULmHKUTGr9iHbta3yD/rX0TR/Tx2cp96FkhdItybuXO3T4QQYoCX0g9yhJ7nI5cw2Wqy1vti6pwMj5/+Ku/+LacN1/xf6aIsYOiYA8oBx5GJpaoqQe3ZsYG74O1h5FMxwkgnn0LyhJwJ3piJMFd/UFfIfXPgEbBhKV1GTIUTqjjFIbAk7caSsent9QJLSLwaXLN7ZkLLXReAMBLFmYzRp8GLUo+aMbMfTUIbizpchQ16iqF5sbiM2KyD1yV3MUS37zrdHzGbWxKCVDfqF7c8TZU/M/tFUXoQfwaKWMBNgUn/0//TlGIZMv3jkaK9Mhy9+tNk1wYxTiSAiCFU4NM/fmaGk5oO2nMCC+y029BuZWYd3SQnTH2ki+cWdQMY1TRbwH0IN4XaUwZvXGO15UjDzZPsKY0SeP/wazW4q8s5wU3Qet07bYYO6258vV0HjqyqBoaTwavFlRUe+ibGQlCBzifB2eMcOkAVKAB6NEBfoPDQQOPGK5GLMQokPT0UpGqEiUrQK+TJWbb44F8Q8aPefmF4Hi2MCIt5J0xgSmiN9avbgBBOMR+Nc/qljwBViElDOu99VMM2on7QvIVLuIWQYHZZ7XLWlFnc10vzDmSJj19GXgmEVmxQUA1mPwCBEdae+25D6PnByzxhLOvVGLZDezWqFEp4jQAzCosO/X6XP8AgSFUl9jo4nFgxCSqYpgnckAn6Holeil0JAgxUnZkFZWFt0hYQCoQFbo5GAe6YzZO/13vIpWCbon3UO3mYMp5Ws3m5C+eo1uF7fEnTn/daftTey+QEr0kMBsbXzQCmYrXwIYk7ZlX3COwMHvRIOGmzZhAgzu9NJV8Agq/BcVedUS7BTCyCOuQp+BuFaVEvmD9HVrYNwHTpu424mA/MkngQPntt5YdpnAE3aySHToF47pXDh0zVmNQZGAZw1sXYcKKiqdA1yxVPlf3TYB9UV/kOq7nGs+Pw9Awudw8aSYRqaWilRf4sSGRfgnJ3aLmaTgSYnehWngl0IB14F9DP3Ov1RiSEwqxut08tT4wHRqtGC7xA4Fpkms42bqsDEaVe/K5vGxPw/1htaW1gqXG6HENh4ryOmu198S/+6FFJ5aJ27g3zdmB4MqqHEGAKi0SRL3Q3XYHBAPfkLWxRoEHzjmbXR0OtpkqoRgjXiYJvkVfY1rHJzvfDguayMVwW5uekMqMKtglTG9oC98z4OpFpXcTFhEUs3pvUJuZbgmUcFZCIOmQIcYMP245WU12+E+/wE/qY57tlAOUR3SNkEam6TMnKqAUEeiuNjILRsMymCkScXcENMYSV4rRN9Uf6yi0Z/xRtC3zwHfAuj72GHI1Y4MLwITXAdzhR0B19IuAtBW3jSO+5ty+Mnktk4mRJZsvtDAnBBhEDcBpI6X5p8PIuHIXhjqAT35U/VnDOi+lhcbR7twq3qT+8e9c6vy4mAi3cHxZbfr0dWIlcAdwJkfCmtEzBJPKaAi17RceUHYbeS636vhNfn1dPjVHtFVbJCZioj9b8i62PdL1PXf4xjCJ55DZ6JmKTgCjy6bR8eKI7PLqZNI5LAofMVMS1xksqyeP5SCqL4iRFompG+61sSOrsBQaubPMJVcheUCBdLzKiSo4FTucBWGGaXStbIjhAOGJawSC8R6tuuEtpDcap3kNljhQtZ0Fd32nwXs8di2u0QJzZrQMfU2kX/rLxz7ol11zXlYHpbvaGqXp5A0FN3oD6Ga06So7SUhEAi+BxqGb8SUWx/awm37yKGYn6vlyIg7hnGw7KNWyBDGw++hFIJMyjpLZ1aJeIgpALzfPcQXAj/R4bmkceyAGF1GJ6y/4zOgahmlXBIDfxyMOmpdjK+yYFGiNf+DwuBLTUv3RUpBVZdg1c0zSLiegRHBOxhn/Z50cyjeCQaxpZBdafUTtasgYnq4xluRfDFRdkOy30URaTmiYnmzWR8zcvoBZk4Z+7UJ9vLLKHHIBsvnKl6Wn1NwguHSXFZ8I577Qr0NJ/fbsqQZUo+mbe5fWOZfUm9GZb2OuSc+wukHbPVg0kUzZvj4B4DeM/IFbkmv18DI2iC6x55d4GqMtrU5qcS3hPSqlEK4NPycLCZRbWaCWqMbsCQSFaX2tsG8HyDdsf1+CelOrodPF2Zz7KMLGKt/v2R5NIpMrxAaC6I5hkc1MGCPKvz9H5/KjxfALeqcTOAVs28CIvYAmKCZG1PdqNgBBE7eVmTOIvh3wzwPp07VfR00fsn2tm59+5VOF2FNoVBdEU7zGJFECJqbaQW1JFXGLvIlaONjHgUZeMDis63wKZBZfee0+bFGwqzKJeew/oxNYZ9oWea1C/Z1KguIiij1xYpzp10D2kdczc6F/rcPNt47UjF+unE7gSmOFTm9iwznluc0gpfBZ2eAiOshGQhnA0xGJqP4pSvZ8see8v4W/VNFLjkRuhQHnZlV19ldoCml1YPiNais83u7I3kqI3tLsndPwILze7EJHmVSqiJP4XTliZ6eq5qIIbp0XFoFchSFB1NvImapJ/zInARN3ZXSsmREVGDBwCPGYqhqViKLS0xWUewlMq4MbOgXpOjDkIodfMNdg9+C5vK9Y+VlohGCM8F8zkVXKHhoL1oSDyVF62OlBDsOO23Cxqtmn6eXtHR88Q5UfMLCR2OoCfviYe2yMRyUslYCVhAY2qgtdjQRz7oT2aJMAjt9zme7T9R0pI5Ydbhpnx+PNbhjBLV+/dVmF3R32qxL7vJNOe2HYHFyTtTfH29vqOMaR8s+QrIQczDaJJNAPNVlQUt7pyjXNhzB5vmtNovG3JjYmFRoGBt8oFg5xzSOLr3yZP9IOXwOMHitaWoR/VumLu/TANs+jEHjpYJLMfR9ywEhaFGE/eGQYH8ZzXoxU3iVdOdhwYmmERgpvVBASKhuiK0xx/5JvO6t30M8dx3AkKLus2SJOlkXtzpjRvyQVX0veuXICTlYYbNYQfBNjTl1oJQjpgKZkQQJ54fdNVOKw5Ii3/taYKBw3Bq391ngAQCft0S3Pqj8dFJkK5M++5dypmAp+/Ud61XqL7vHBGfBpNyPmmg/ZCrLxGUjV3FXPjbEqlUvL0/IHgqnoWkSj2qJOHUOBeEwYNQOwejBca/grU7ISUCJLbecXec2AKjiNYYTf/tXVDPOL3vXNS4JbxbALaQ0L2LttyTiUjACeZebEjM+He0i140nG+UWoYcXPB71+MXuTXc52N9+048mXKsi5qlLJ4W5h9LX2AjI3N9iMrn/hJ38zJCH2Vg+R5+QoO1V9b/jQWtXidn1wTpMlyLUOckrxFb4p6bhXBXiQWannW2JrItZpUKGhMLq9KiDnQBwv5KKS66fg8TVxByz33r5Eg8tigsBCbuT7cjwQwtnmOaqhQcdPknM80QvaSgTZnjUIgnPjQ+jpVz/pox+psUYtJKNeYecJGosbhlMuro9RSr4CTAPBdpehH1wPGScU1oWplzyOWIq92y3CTsa82AtHsOK3sk1R/7NBEc2s7BFgrYKBwz72w5/rmajgdOOTqBZ7STONvP3YD40RfoMcJqgbuVTVsldCCQbXZK7kxzKqTBjFFldx/nfEVPqdO7ZczPIE4iEcuy1DqMrarkLgKwtkneMJo62l8B+PsJoPApaIOocXxI90X9u1BeEcrTL0SqE/KH23DMRurRryhmSaGvTLqglBMcDWy6kE4zY23wAvGD1gQwVP67JCMVLNn5EcW6uppzvdGNTGvSmMlHSQTaFHAJhDBwklVVWA+0aSTQCK4WbvAd+v80XJOC6RLzZZmcaW0GJMUueOKmzZqMKWXMi3Npig/IaXgY4HHYJzCzsKEFL5OQZ4enZ7OliwdE4U8VfifiTtYHMTlJLjCng79/OdrwbDRZhJQCak0sNL3C69zJZCu8xHBCtNmrG6RqrqKU6IgLkog6O1qhK3I1cYBojG0IOnYglcxrsRjaRK4Qn/tH19UkpzS1e48ZrjzjVk0TOs4trjaaoyLnQu0mOa5xxMiQdbq7XG+rjCrWfiKCRgd4sPp6mkq5mjInBrFWaH3ZqM8QOsQDlDkNQBfMickCFtw493H5qqHhSTQB6kaymbb/GSvbWUkMDOs098crONnT1M9mMjFi8KyNQhET6XqS/0c9dFz1ikotZqOY233sLIyc5qHynCJTQoQGPBAb8QW2kUEY5HZsX+HYpzr8ix5f9AbcVPOjZZiTs+Zn30w6jU3u1vsVnQlB+YIzc7K0SJ6SxsFfDm9WQEMFAg8283yyulMv1BMN2C8u5VphRNZ4VbA+bzfB9shgNcSuG/0RK+Nw/QdV8pUn1zx1LcKkSNMIkjrcr/htuDelRNtwAZWl5QCpqZDM1rM0hpWqJ3EhFeGhQ9DGbmh+43G4zqw0Qpg4kUzcI0ZYKdAnVlzzMXJwUATJBtNz9n0TOOSPpVoQwTZSkC0F0zxfWUpcTBXA/sQdVjNnwXYWtOjlqKHtblLd/4R1Ycchn6A8clUFEskbW/xiwzbcjw7bIjsknglbX5JjHEn3f6kGA2JxdFrPZqeIfNMhdVZgCdC56I8IXnbJCSldtDv/eoO/O4VlYOX1NiLPLL3zb5+s8hfBuNLfIXVhPp2TTtxdgmS67u88BYCl+fZ7NpogW7v3jljHVoG7JkWIZbBovhU03hDmKsaBetCuikt0lPq+e7IcE6o5AwPZC4RtGHViDTQLXDWwDnAQkaG2XUgnfuKkFlYp/uC/kleoRAQieO/Q6j+O/OJElXewmdErGdYcthtj5CA7W0lfRoXFYb3C4retNbXlRpFbunwkT+UlZb6CjFbqihfo3rSQCCC0hkCXFqYVbBXsgjVFNfxa7R7JQEQvN/FTLBaFB57xLlJmz9qIeQZfqlLV5dBDb+GWIT9OtgSP2fwKbwA0x+6YLXZdWCvGBQdQWk3YP0a0iwmt6gyYH8K2pkg3SIAOvtD/vSMEuskzZemBK3ChtzmQFJgLwg6eu4tRtEU3/kSybI4c6t0H216ZFwpsnhI1hTChD8HMFgx567gouEQJiMiTd2Ro/9OojOzrFdIlgxCj0m0ir9YZOI5+VKBC6xgivY8rEgBU1cRSO56Ev4CuwsTShQcPBzudOTPs1Ercd25+nyPGrTzAuxc9rASjSCPkVeRMEJx+gKVOm3A25x8+SKR3HUHPyANcUWewgFuRCRgNfeq50FOE6ZkokGXcsteYSL+yphZrRi3YdtX6fg7EBGr9b1Dy5vjaqirIYC6aHNnZp/sL+u64STyASi0ZMM3pEeRJUfaA+mQ/hh6H47pMkqJaiNMAzThR99pvYU6wtKKyWK1rgJYbMwO0KOB6f7KdZL5HSk4iwZYn/swl88qd/8nyq6F0xwatC6lOm5us0Zf8NnTW81IxN5GQONztZ7jbkBLSnSxhvZuthJUP7GUD09zbcmqwuhFr6lMwsV0b4trW/HGGYPJ5kthzmnD1Fs32d2S2y4GMqcvA2McEc8hANmxqhp0VBqqSonNAHw2wN/XhoxrX0qauzIHlGTolbugS3wmT2qnlPkMbaWvWWVXE1YQc6a59bp8/eMY1xMN6Vq6rhR1sP+dzv2Zi0CbpwC64WiPwqo/XuI1MJOnZZv38dDLZoPbQ/oUvZYlRvOwOIogXTaoiqJScWj7OlqpPCSntMLGY8c6lYGOZM3/LMBobPMDTJo++FP6Gt3qu3EEkfJGygYFIfiLRITqeRmw9+SHxTUrxVqMtwK+Q2z+NhEkBFVBcrHKGtG5D/r90pNCPf2l6uMPrlCaQEk4GFu+McDMUJMVL+wK82mOzJenvw25M8/Vn1t188vp0xWzmCAku6mA31YPfhiH68zDR4NjX7Q9il85d6dCS22/LCP+2HBbCO+Zh4jNxmoWZ3BxbtOHzwT4HTXc+PQeNROCyzIY218gSzo6SKK+rqT9C3XQVMCBTFo/bzNf75OXRO5hHB53aQ+CSYuuCYYvFF7hQCQmvvg9Hz61TpiACvRwj5lkU/5tNzOgAWczKDo083T9vXZjzkwfSxu+sfwHs2JZJIyZ+ZxgZLRcFKYyxbgPnc0SZX0+iC+tGEVKZQzaqGQ1Bm52fRoj+J/OdzDhh3lftBIUt6ZE+gJUw/Rmm+O9fNDvA2z0HAPmqLfl64kDOCsvv3h6RKa45LKr+Mri33LFi/Kvc+jmQB3SqIOmp19Ki7he8bIvC9NwwjfP2ju3q7je3t0an2+KHHM0YUbfGHgLsIvFiRoiskzi1Yra+3QoOKpktgE8lhIQ+qS8DTml3a6cNinmYNsZ7rIAJ2RUYHq+OUNtqskLRWV8rxSOrUDXAApYt7nnA3dYr4ITxldS0wiN/Ii87cAIfmKqDtkKBj1wuQh6KcgsMUiVygcajHqEvFUPI0zAXLHI/qiDtgQiUe/lfkenXQ5n0oVetCJUO5lH5KTBTftd1XnIo28GpXNu4ZltlDItOVs2L4SzkgGjNJ1N/2eFy0pot6IUPwuNzhIdukGxmMt3QEh6t/GsamcD8khxSbKkc7kjJ27pIqkZabpf6Ts1tsFTzRMEG0nAPLGcVt8NzHEzLmcXZQALqyDefUDSFFi6VwxRKfyHof5tijYtNV9272oMBwWsuOJq1YOdcnFcgpZc6Gl6kOg/uBO/enhPpREXsDGGb1vJce06Dbx6M0T3L4tzSOurySt8KTeghENsqC//yUvzfCfGMwLSth/C6hJPQ9ZXKWltfrxwV3O0RtcUwSegef8iCh+PYmZJS95AIOGfcOrbDggc2MpJTSShuQjly9oJA6gihauI4UxEaY5N3zjIdaB7qsjPj4sjQ7FEPMqrOyefIJb8xtAQJK3OcPJ1IC8KKWRYrx12QNs28irnfCmetxfLIDITkjAIdDq2lHZVcNFSn2R9+4ChHzUYdTGl0gHCcKhxQs8k6tRcNGyt/71EjIjIm638BmxUEPPgDOtdTD1OLOQr8roQ9IbAs5A5zhwr2vbUwX0dtumw8ODTdl6Ac7qDAdgWHaCN5ben1SohA0o6/WcTAmWQrnbjFO7pS7L/ZG9dC+9ysFNa1WzKrMRyGb+CCRAgsBHqyuFDDohEsA847YQxs2wdgd2v8dwwJ3G+KWIIt6toe2S7h6sjsNB6uLmx1uAFk53NBT25ue9bpYpKAAmc83a9yrjnQpYrgN6FG4ruVvRA5VJ0KgxduBZfh/ICUsmkJy3wqmsLB2r/CWTjpN4tYzNz0GDtFwuz+wcG1l6ss1+4kLo3yGwlE1NaqML9ailvCdTd/SLe/+puT/RkKn2LMhtVsiT7CDTuIGhJRiTMvSZL8fcC0QAUvh0XGVacdifkfi6QhXqUGvynga7Pr4AVCoGFgeRMumaqhANypzKKFA0XaomaYCXIaannHtC64zLa2juFg0dSo4exosnE4J3s62RVzNs/hRBTv2JsP3o3zNmGKDTAxGs6o7COpJKSnRDHmRhXW1sZ68GQhjlBPQBGyReLFYSvBzzSgWa9Cos0zSJ5cnKmUP8EBe3IXW6IRF7knqiUnDzBOepak0/eqFFaJeHyNh3hYE0iWWgfJSMcvpSvsb4n9CDbRIH8mQmFzf79D1jdLfQAm2k0h3TLmBDPx6l3D9s08WmH7Ya9pAU//F2o22+2uW56oSvFqMdqHHdaeLIIswcbKCvTQX5xKxX37yZtzV8k5+i5m4x2ED8+0reWeNZjq76ROeRn6nr6uhy+FjPEaY67yvgHwJ6k//arrPYWoY9H6jSj6QUyLUcTrWoBhio8Q9UP2ehCQ3R+yCFO+qf65Tt2EHPSXdNUZdCxKZ9ytL9DxZagcaTuN4rLsQMkznfGsRy++VkS5FY3FEpq0FOR7TRn/v+lPei7yuworPOQGq54rnhKxPx57o9LXmW1PHqTN2Bu858UrlTnYWXLwFKQQX7dw+KDllYLWqSlmjc1SAheEzghT2L30eHKY+wNZCxE2tjehwaSUhvla7CA/v0Aqy6lK4leKs7VvtKuBKDYkmQzUefXl+a5iDzpgYp2fPyXy3L9WwP8JaHzaZRf3ffJdnwMW6DCGEwXL1DHS+7WOEFlQKJ4UdMiajll4mcg1HvdsRiS+v5e+3x67EWwRo7+Vhdf63Vbm/gEeSbWqqmYTrrh/7Um5O8+sBIML1M87l5wj4Fc1VbHhepJBZTXCtUpGqgo/I67PY5i6alaHRSnJepBJkYRj5A7qJZ8o0K9t01ltg6y6JA3NGcCnOUY2K2s63ruX3tpI5vgwEnEedc5z65RM63wfpx4SWTod0lYIE9adcaxrs+HNb8T5rNVgtzh/AGnEX4TVQy7EL/UIcKeXszAdPzw1UQkE1FZilzAaoi0O2sPHmU7h67WdPtpK+jcBVO2XKEuKPooUN7UDn3IS2Nf9m3jXx1KY/4QYS1KY3NFz4osJ4+nvLYsUtbc2yFHP5w0AAI71PuPTEI6A4ChQcW2RHk35Ne0CpMHsHXIOa0xJ2TAAbjvdnCCc4s4Zrz+34JDGZu4veM9XvnGIHphMmCXMpXS7AtZw9Yfw8u4D/wm0bH0x+aNX9Q8HOBP6N1KnwG46dgVQKeYyRkGEZEupo4cPsTP/NhLGP6XJtv2JcMH65RBJBy80uHG9zl4RHZ3SsC3+SA4PaUYN0CFVED4Pf7RzHXBoGBndkF5rA7JE4VwsFmDB1uIZs7hpC9s9uJAB9FM/yzQpJLivuzvDWY6nDQjPLtjVebSsap7PE7ypekXSKlZnlK+6Bdi3uIGLPRZaBoaIad4+Q26R0TWmWFZknCAFhYASdhsOE7KchmC5Ma3PdsNo59vji+N3OeG+tzRSu6dz4vayMN07dIjRy0RjW8JjprryxCYUzfi0lu3bc4KSzbc69Dk6slNRS0WdiYXGnYREZcs/gNChJBvesDAgbiU2oZqdB86jKKsoauNeFLusx7WiO7X69Jd/ugf8QwY5YmAxGlJAUfbSypO1lnS/iLjdcVlfSAk2RjKvhnvKL4zKiY53jJk92ateVSs+EaPPWbBSuA35rTFS2NVD0r3TuKKKaZCxcE8ilsJHG6kx/iVrDiKjce/aXPOt6JXepfKni1eOiPRiCm02Ot2LHVaocLBgaDkHbxjHfAqlRUfmb3QRqaahSR4//nLrS7JHnX+WNze1VcLW6GQ6vcCfx94OaApsXKz8ogK5+GS8V13CuQjdaVqpYh/yoIo1yaurKNOTj0UD42JzCrSQB8yF/pNiFtFOX0NRj52KGTVV0JjjJQXaVIdIRSrIrYDfLJGoa8X53CZApsiERUx8gEAUujjL0p4vjr0D/3qoZ3Lb403uZfZ2+gpP79FWyUTcrM99O64PqGWmeMdv5kaIetHwEDq/y7lIeuE5uqyyZ5M6hzB9sOt5+sd/6UaPOvMeO84zmvzR7rlVqN6UXvVexyb6y74O5loQvU3LaD+4l1m1QU1Y8s5+dhN3kAqyrKQfWavDuDcv9wBTZxe6dHVU5pNEzR8KI/xl//5WV6M22PIxH7m5vXQ8ltmk1DEOFdCZbPmI0LowwbOzLWKUJpIy5ncgiVwJY38AckiHGnswwAIscamTkiwBMbMEmas6WwOl0UEWC9R0Kx2UPg9cYNfX1HHNvYu2S30oCQevhWrTxFVhtzhkkljdse20Z2BSl2B89kaWch2xaygCZ2VlBdhFfvSGndb6LHkbo9U8iK5HnECG+bxXZ3NACsJ2HHaC+yr5ZCS2eSVwdnVSmbus27JCFfl5d4SYieiuPoYuKv2QVgmc9TZF0on66/vNsU5KkenVBTLC4Glv92dMCBNr5Zre7JqLM2ypepooiIYwPA5rzFtahZe8EaLGNR43/6vvPdKR77pC/yxvTHWyqCXxwCfdUCGWjTeyp5JKWQXGfzHS99ww6gmRP5/M329ESsujKHMndpq+GS4isK0Md4W3H8w3vToC73RrYdORI1ppVPLQumCVyksSJHyWgnLhkakvQJ7ZXrrmnuk1wZ5PZEE3acLGsuC3GrCqbwaRwHHLCof+zZzzANGD4n+R0Nk0U4L/c2VFkZpgL5gNywLhBxQMJ4PmLVUPOgDB0L5de85YZgnJlMSudMIj5lbS9BGbdinJLXOepa6i+Vy8insVUF5t5mRvecz1ARRYPpQ87fP0LB0mndZVooLIt32qb2dR5whdmF7COyPcIxEl95wFKvqCSNQHY/8Tnk4D0/8evrlUNV/F17ka/+UKI6N7HGbNsK1KfEM3J/4HTd/soH+CuDje9avUw84cjh42kutmKtp+7ZUbUJt2h8HXc9vyJUD+oXuVzxmWNNngEWB8Ynf4on21txDYB+MbJcQwHkmptoExMtHguqP/1ztPETsDObNNbIVYkq7TXgqme+SraqHOWws5pydKgMPc0W2uePOyBMOoiPitVRWh9YMp7npd9VH36+7uS6DdB/zcg6uo7vp4BxYU9sa4+66M3QWrI5sN/mId2av9NKKS+93TR3WaK+gNbBv9CjiEAMMMUKngu1N8DHd2glYIUnRFD0ofQL+pcz6ecfBmSvApqS5lcScCAOINFUeK0OOOU1NNDNEcUIac/f6Qha5uhdVqS+fOGUUkf3Z1Ef/80DLGWjekSSDi0NvaEq+SxETsLU3uXo/bshpJB+FRU0xGvPnd7OwQXE0LOLbYiVtjQg/PaM+8K5J/OSYHkvC7roFgF2iRNhzqG/PcLG2QVAJE5/E1+5M5cNv1H5h+nzYXw18qXCEZrdLjel9q2h0/SLrSthtXfo8WIC+SG2iLyXqkEjUYojn0eqMKSyUV1UOVThxv6B0z1n9smH9CvHJig1SPaIpcbSC7jPwU+I4NiL7w4FY+Pr5DvQr+R0Aek5bhjwCYFhcgpFF3rOp3hWpwWyP8bssi6dttZaqOvsOyU1TD6jbVlm78o1pinFwWT/qHWo3tscm033zObcoUlnX2NlrVBRGZ1xwlHcbf7uErKl/HSySfPTFFU7x6FhXJkZs9V8kcYmz0JY1NScqISXfPzCfvxuDBOOGCKH3ann7p9tYVQgGHdc3yCbQQOHT9JUf+hbcGTocGWUTtDOAR4P0UPxJLy+CvRoDtgjNEpQVF8ocqDIL8RxKWuuEwAnek3ImiTPtsyTylDx2UTCxhr9jYUZ2s+walTnOQHa903tMvNpD3th41ChRIlZCbUWH7RY3iFEGpQphMNYr2OxzjOlDHtvrtBBcNEvS53h6PtQrkTgXQxKyrtq4KQOodazvEMkpGmNSjOBi7O1IqTWrEbkpj7vmTcbp+F7AlySyaFQZphPJ6UQM6kIahbtxW37O+z6DYBEx5jAWx6iZvfHFmXzo3mzXIy0aY5okzazta/OyP2D4iRshpuomyBFxrna+Em7lLtcQXtoa8VoBp4EuK+Q5DrTd7StFkXpX15ceUQtu+Xx6rygKrLQ/aPwg6sRTg1fgRf2puy9+udl7yxYC7jKyIs0/NPZazOVvG72Ex+3fA6S7rw7H/B1yrCBkssEMD/u8JxEAFhXoHe2XQRxULPGAtSeSF1GBRxZ2iGsrEnp5SIbOqjj9hU899Y0mfghGI1Po1sq9D3Iv6PDUcr4Fw3dNE4mmtbpOvfYzJN9AOzeLX9IsK+Y0SCwT7bGsy8B6bIDlZXC7QUD5zTG1IWJH0hXM0LbZzdy4eDnHEtCONPVfp1eicoIve9MSyYhXazjs/cyPFXZafiLJaMMV+cdW9m1FbuxrzYRm6gkY6gh2YRBmC6ktwAEYMfvmifdAYRRKfuUZgjmz6n+yR6xydxrDyqvt7k59GFBQEkJwUwCx4o+YtgbLR2A9DSX/6Z+gx9UXcvAveykb70ALokrG3F/K+UAd3WvaIWjSu14lRrm2xm5po7NBsSWAg8wJcbBe2xov/Hj/pfovW3/IRBnZAbysg+DXanz4aolwlrGOwKKCr8CqEcjA7vhYEF3l6/4+vnQ/IRHfbyM2IJKDNLqCVEflXIW0DBjKfwR5IAo4LBIpLnmd/iJjg2f1EQHP5eckGr4yjFENRpS0nxemE1uHzch0n7jlDAiBDOZA2dU23rOLKTe6o2fK4Az9jFIpEgUNhk4k7txEzLbsGlzJ1S0U5ea9KhK+BKEfhyYQ/GAbzr4jnyI9vf42bx06AVt1+wvmvC5/MNeTq21QKmYSAHti95uCa1J7fOVhXQn7X9MmU3fg/mnsfIbTxIbThDvZzKxTUlNfHXWcKSrctVI5BSwm6u3OENqpLUaPmt5Zu82gwc9HSfRmKDpoQrbpysnaDBskGGgPjLW28ts2Ip3q/JcG6KTn5f6+tL6lnEKnMOwh8QyoVUQGrAx/BbS5RY0Ss5Wy7T62k5g6v4cn39W7/tSUFa0/TuAbDfoegpGeE8pku/KgcxQHfH+C89mHeraQzmJD+qTZWQR0ofqOhc9hOCDuSBQDVM+qtxkP4eg9DGLVlHJ99vVewrpkjVDvV5BS/skgRz6POvxV9s8b11VfcsnsnUnNLVoeKLHEXo/U4A9zi9pARfE+82Ns6ZpDU5TaZBl/zUxwcYOL/huRVog1Lj8V0OctNSV+a9+qMMheztt3Z8CytVSt/+YLC3pVtUFfBxUsTtHDVwIBBAQRr1u9RocNXrLpgKkFxf/PkN9nxsfmgQ+6/ZtCQhe9F0FHeXZ2llUJpNYFshivFv312fmPIyCczj/M00J45hOUdwlfOFElMSsZJWsVIJW1Unl7GhoWjTfUyuEmTzYXuDlBZuylR5cOgkloS2Pfstbof3IgcQOMrkcJ3pX3gXbgsV+ZjCl0YaxD/c5VyisyGQHQGHpBvM+WAPCiTcr8daW4hoKLDR1Nu+6scDpHUA9px+Wgnz38DWCuZNfeuNeeujsbfbb0k2HoSjJD01Jaq8rjlIAPcvwu58yrT2WI4P+u++fASTmwKLVFALbmtuGF1hmhOW1vH2syP7Ghn+wLFk3dcRuWUDF3ZNJf/QiZQkrDQsqZKUEk7wrb5CUMTH2/8t/83MWTyjWYYBYNu0uzxlvmkXitPaplOBGHnNNEzP3yKX77FkIzdNjtak6Xu7CLm5Odt/KMnB283N3iY+a/2AToh6bBnCchHL+zwehWLph7n/tw3kLhWg2dY5qJNBV7GqyT+r0hxF15YSRr2attM9FqRFIP3+jHKdC6Hdiy5F3hOkpnxvoHXW1zzFqLXJ5XSEfHTFvmx9K1pi0EJ5IvMB4IL+ovm+yEA5kC2oJNO6vQSEwHVUpagSoC2pXULjpOT7O+wLpW4EUKGY71iqUgKjIBajsWEpG7lvaoQT+T2xuQ846lvhz+7dLo4lBhRs3Jbk4T/DCh5Gw5ZdS2eEzPdxaM/6yrj9ba3qyJVM6moS7t/GtB0AR38FCMXgzEUjBZBcoYGECn3sImNjXupMO8rkysIITG6GJLNq0AenWLbNbexxyvquVGWPJY8cQLeGJ5Qt76rXdIicXmdE+KWjf+pCKPfk2lt49RzuwqZU+l/8k7uTWfsZECpw3ZEPtR5CbrT8XD89/ngKUJka9tajk3Hz326gt27OZ72hqAPgTTn6RIDI1IprqW/SlMMHQZlIjqK10quCZww4d9WccxTLWvpzH2BANcSrPNEbIzuf4l8u7CLsbgsYqLk83qecX5Ycg0mjXuSlU4GAIsZsvPYHQcy+jn2XfbPyYmz+PUH2+VLYC/EHTHjwTbwvIYNwDTwMji5wKoDhx6rMt4cVu6pSW0GsyS8K/y1ZpGtZr+V7rDYxoUKJYD5EfJin8O9v8G0lbzn7uSBZThibLIBQCcdKoVkJaCraBKBWyAOxNDqbWNbGyWFlcjw2+tPIKGkQMDKsgOx1ojqqb7r5dbV0wK+exsunkDW6zuxNuwBZFYh/L4FJCUBtQR4zsmCRz3iFb0OgjZ+JlC+eLp7PfbsO3cVVwlcJ6B6G88uchD1tFuxceJw/p/0zyKBSG9QAtKEO9Jrnbq4nJiorg1Z/wT3jrVJRusOgLJ//6weN+RC11EGK5K3Y9J56nXxHMjHwBjRWoUtpQtHIXLIrgxPqdQyVymRszdx5FSFpm8hAFPKgqy1awSp+ax2DGu7aAIUzK60zxw7lt54R152RyD0V/AfabW8o1DSglnlXC6vVPCBgTwP8eCy7MGbONSYWdicNYFrdJP49k3LHtVZEouLdScqp0k5NOXtVLmPVKg+tAsH5N88szeoX+Z7kf+SVmQK65Aypzy/NMUyx3uZDBPj9d1LrLqRUSxLssFXzVo3UC5a3YgoNMlafMntnImrgu3lcChL6PRcOhx/T3rhTaDfXd5nG9q0PI2hT+pekNXJ2e0J21iLRxuumvU6ljB31e5+rvzFCc4tnZjvRbbKguPtHm5dvSW6rxIM/r8jUmVcqZ9ehxhRVHMr/20v2Hu5IEEaAvMj15FFzVNayEEIoqZlz3yVofhvumm2bPcYflbW0QNTpsRKn6fsCWN8vQ7z0Le7+K6F0VlH3jiqoNPpOj/cOaroprhXWhK/Puacy9wleJvM6jVoWAGFnOS+Zh7HI1vbhFDA2DyYT1nARbVPlPcWaiqYilVql9TMzb/iCLvAFnzp0BoWXkTIX0hSe9gozOfafauJiEsJqEXcWRs6oNF+UY94UgKLMypRf18T8iuLgn4FChEH0zDRbxQNn17QLB9TK5Bkr7pcP6MrUeKekz6NU7uJof2RAXZ+D4NhaLWGzZ5h+Mz3Yh5PuaTRosrek9CXkFd0PgyljGgQ5TH0sFTEFdgaebR8b6CV7teVb1REVDcOb6yqqSq/AOjKgzUQ+NLiy11tkrLJzD0SjqNwohThty48IB4PPEAG3GJ91DmUNO3qpu9udjjyoCWR9Cpcl7Rn+jxQkMln5IdovjfUuUL9UACB244BIH4LiWeXuStIUXBCoHJ70S/OOQDtoH62bwhg1YTId4WgcZzZtrIXIY+v0WbUsSZ6j8BQPEr7xsmX462mYMGw1XqwbQY3tTaSxyQ66SZMJjOBY9XdOu+dRUTrIpGlPCfyjV5DqEh3I0wlaKLVdMGpE1K3+T/MWK41cZrGg+13GLUoj+BiPGHTub5wR1EKdEXycK7fstdB160FUhSsuWcO5fdfFWrf+oUmy5kj2pEoCPkAkcavEU7nPUDmUVqFCDnQ7Pg0OMm60s5CvZP+jH5nsY/fzvf8pBwrivNs2emEggB493n3z3XjvNNNsoKRdqtfLlNyz4Gdv3CXK7sHVW3RZbkRfUvG4sANjAyurAQ7sAxPpTXk8GFRPt/K6ktdqHrpgwrwQvMNns8X7jWtI/eGWRwai/12ONutvzGWz6E/S1tYRMRl7K0ilgFCuzlW2dpMrBFHsXIOxi/fDYCUZKFrxQlnUSBwnY0m/BC4pIuutwrBjxPgOBM/2qBAqF8/2Fvgc3bLXImGEjpuUKxcVWSlrc+rvoSYBKPluAASFyHbMSfOuUHo/vv1N2EI6jKn15PWTEiP5amK17AKhLjdBA3/vkOVbEeI1w9r+ENfBJKp9uUjmTVg9Uf7SQV7/9C4Q7Ly1O6z0zxtegAklrbrjeVmQiBZI3IbZZNtGBXFCV6jTdkYPyYxrB7gmeG4rltC4lh4KGjxWwtDXRI3m8qcuzZuAiBBHyCphfgSbOwx48MZZ+630y6PZnB0cFrFdLDgVayuZd4SVO0dd1Y68pFl485tcRNCoUApRagcUxWp2oT1dyXZEX0vVSilcAuyliTLlJPNb/l9kD87bfAobSIFsDVvyn17XgiSgiOFp+t7UHs52IwhGDeg9LvRQpIXVTPRRVUucn9Fl7b1aVn9Mf06ekAIZv80elqS1LSHrL+1kuEaN14lGmYHfVrZlc5Y46MPNwUTwhq4wlKWGwivP1cHjHtiS6Lji3wbP4/j1N11GfxWUqKqzHsnBUEYSJWPtG7D1tBVLsXTYeXBcDi7zJlGRwT1AqAxk6NguabUDViGs+HHYe1Cd8ScixNFd8tRwXci1kDW7JdPBtYs8XSJU5Zuey1XH3dP9WFQ84A+K2xvmeqEsCENc9b4kAqZKU55bcxTpL/I9EOVZnmqnRRTuQHkyUbqn/cZ+ba9epOYCefIuG5xWnNHGvkAs6YehguLvSh6l7ERQ2Gw2nqra5bE3p75bmnVL2qqH8vFuxoPmVQchYxnaAPXrttT6ILw6ObRKD/vE5QyTN53hgxohpMXd3F5wlM0SBhJWBG0Gg8DueWPRcNs9hTWYlKDwA/nQY18R0sSpiTVqXocFUVQEyAIqD110xLD3F4dvhVsGagGz5AMF07YAJ6rHGcB149Hrmb1xcU4ypCiJZ57+ozyOaXc4LoDaITMt971YQ7Sej8jn8829vNyM3vvBH/PerhYyBELn31lUFP79QouTgfzB3wGXEnDXKfTt60EUoCBrISS5PENae9iMzb44bWJxFldi4bieDoaKYW2py3SrcX657hzewebQsp61tRb0sXwhDQEahukOJyzWrayE4DULAPqJilh/k9rh1GT4XZdW6xqPWqfAwV0YcWCEp6ewLpzGsvArKVjycuvuLeRd9e3ld/xcuTEVtioPqj/xqDfsxS8VNN1NNgCkC3NSCW6gK8HmhZXpQuGyRFAvbP1SEZED4gRpYcJ56MFMDsunfxtuK50GapMXhVbITKQecAJpLpFMPCZvs0RzsHWXbJn7AmDDIWPVuiiJm+jBm70WZkCPbfASPL3Vzu4QFDIUYeqODpWWWAzIJzmM5G0vDX4PHEp3genCmNfYPhClM301OkoOHfZ3H1WhGkLWf7lXzQeP52aDWebcMySDNpPVq4HjjRz+po/JrMVC1XKVihCoCm3Xo0r0WY+5yleAYZjskqm+de1SxAEwePHc1K81SApAagaLg3ygjRff9Ms7qgZMiXErIpS56afui7wOjZj4ATKf+diRtCaR1OnuGlJ8tyxzpWCHnwd/X002jld3MnHB18Nkp6GwIvVVHi6QXqyJwEhMmAcn2Zx7Uc9xRfLwcn9IV1A4tHkBE3Eog/YAjLoGTyx8D0c4sE0qlUqkpafX3EXx7GU3LRS0nWvlai/giN3ou/8id/kQVsjfUhdQbZSQANosXG6aT0BdkWlC/KzeWgLEp3G4kwnGjfEjmz0FK0e0nRKoEZPSSBlP+U9WZwL6V0ynTLPtL7+CH7SGwoDz6TqvCfbI7DUBpPWgR5B0PzOdMpL9v+pyPvnikrO+y2rJKh3jAuFKAqOg4Wnhh14T1AE/yVkY+ne2c5a39tjpiA7GQfwURngUNkau9UGrcc94rS5ljRavRtFsaxAoRsav6MUEs3h9xnSIirjtVzt4tOQhLjUPy5IABRsT6TDyw0PsWtfai1rju2MECg+946KmuTwWLl4ZDgvIhE3c52TgScbSi6EQaDPRg4ZF7wXJSKP1YMLXfGlqWU2NHSMI687fbbPDKonjDDJCLdfFYu9f2/foZGDZo24qMkipbxrTqVQf7Vv1PxLkDQlxnW0A+OFBZj/vqHMgvtoyKWHtJGR9Fp1B3xfXD8OVRM4fdrNjsU4cHeNknq6QTXeP528I0Viw1PEc0IU1bCOCs1kNd/mkFzRmaQ9xUgtwbpNHOIp1JiBKFSBj4bKbnA948Uad1eVtFPBgrzQ0wz32SeB0J/WRDeAkrizFg0eOJD3xOtSbZfszLMvrckqUk07kDa0lqFHCQ3OtRu+x5jYAW+6c+iALZPno7uFyWJWpQFNhSGEMsvSTTK/J+qe5L8sVaO7KI5WXK7scRKs34H3eIxL2jX7Nh5sn/u41O683rUflYLr2/crURYq81Td5Yf5TuH0LSVAF2lEEiCRsqo4P3BGVdpJvK1UPjvY/DrgATTph0YDlC5pfXMDtQPC8Y44XV1G2TA/9tQYUTreMDgy1irMWpGaX17hr4eZ1iPrYzsPTsVL139eQ6/FwT7WuWXQpY9ESrJ2+7uXiFSxWLD5jPd281u/nseavuo7J2zUih9PJD/lBNvRwXKkJU6ZTV6MSxBOSqcxDYbdZ2wnbKrkk/ZVIVlne4mHW8M6/dFGLnQPMN+0gfKt6CGBVxOiH8kkC5MjQQo0Awvphf+sbQMig14c9QIR6qcivBeZmvXASH5tnidgH9pJUjYB70nNXxiT/aJj0iD2Lfh2OIq/UvPl1LsYqGJaRRHQwnCznxM8+rOGCfb+As1KaFZR0UrMseostSDFgwwzHm3/f7n/aICx4Lnlza+aNV1bfX/liTPgtPU67jTZJTaxL5jBLJHGoeODMzqe5UhhyJa5pOiscq0/aJWxLmqakSBmyaRwQHM7AMYsovuyBgVoJ8/rV/eX6zELeHGr4qpGQs9z8/zyuD/LFtK4/NpNZQXzjIUgHgXpX0aZAyvqI7HUsDsXeeTW5aKS5zNMd92k8lFzGHQKospQk8pL5Eyd+peNcXPak23S60Og8AGuTu8MLeDelx6En+kMES60LoJWfgsi1EFu0BJRjIW9IrTjoiM7xEWzMq/FcaWncm9TWooBxgOYkBHf8bIfSFDinocCeEJLIfhnfRRDFK8/267QS+aetElvBPTmPjORBE2nkdaHRhvFf0zsQpY1s5RxrpYN0xVhgOhy6P5+ViGbPyBF4kYE3C8LHz6aZfOmz+Dp8WCIVvWHcXyv60/dUsi+yTe7a724Na+uSheW0ZV+5DeYjr69qz8tmy7rG4t6xlXXAOgjW0Oqj/8cRJXOT5N/dpHzJIa25NoP3r+XA3nvH9sludGYmv88MFn76QG4jXEoIRkBlLRlLmtX7xZbdapW1WwdcSkuAPlOlBiItqqDKmKUTel7djujLw4bomN8L6+i/KG5LTBZkZouZiI2a6xRrhy+f5JAwsFCGL1TaBT+rbgWXS4+RnryFqe6D941gty6DDTk/7fW7HeYqIX2wlK3a+NsL1gc1R1YcUpjwEvuokEQ6rCjvU4pUkjzwOU/fNVhGX5dfvzJzrcqz1EhQZMPAzc8tubULpQOWY0YhocakEQY57R6V9ThTuFiU7+qjLQziJe4B7Xum96fC6YPi0eE1G8aaBwahCXaKFDVqBIRh45indoWZ2amHC8OMiyhM3i1ssVlmp7ZWp65DGgnHEydLjrLs9i6iKUEA/ECPCUbj2wVHcGzaQCy62Inw5suhaXsHBBxtEIW14hBMOzr3em5e8/ynAmfWIXEPbmctoA9SO3eFheDYOC/teZsmDpuvZTy+NGX6XUQdL1ayNIdKGa+dyTCT3CQPro7MPGlmMMkaVTrr0omgpth5WBrtjPKuz1rlvYKMBLItS0L/5JnXnnsoShRs3s18uk6/IbuJkwI47azfXHXXjIL7Z4Qp7lglruhvK9yX6YozCiWVClkje9xMT/NVplzaivdr6HmEpLrpbgsbnkuH3Iq5GHdglQd8kXlAjph/3e5kL9XFPwyCj+TOjl+jInfDLL/melToBEmkrzrN00mWEyFG6bX53u1Gdi1ttJ7/MIzj2bxKZarRRLoHWpHOgeY8JWKaR5S7GY8pLBLuVh53IPvSBSDY2p1PZEWxhJoXNCCEh2ZzZM7BprDZQe3uTf+BmhTT/pzJ5qhuc2sH9h+wb1GeY9xKHHcBEhvrRSqyaU3IMpMwPnrA+ZlPodNyVv17j76Omwbi31cCcnCQmKyf+7FqjHyuJSDVbOPfIjmEjqCsKZqA3+YQNF9EVqPtyTiLQ8Mc232zDV9RIdbPZLAl903pzhjRA1VUjfZ93I82IgyZG9XpItgYs5ItJMP5mZRc2pKBdabd0CU/LI/DW3GCf6dEB53usVEkvyxWi2PhptPIYNxynO47P/O2yyjFlA/KthxtkqdlSVq4i44pCz0DxdXfsLkLgaQwFcCYqidE1gdAOi4ZR2lus8OuR0L7mdKCY78BuB9oWC4f77yDlihdldT47+wuS9L29NJ6pN83HYC1Unc7gHlLyf0pDnNH5bG/JqIyTl/nVLIGIHL3LNUQiXTSbrGWhtPfj3Sct8bi81ACwuy2L1lSR24AikC1HoN6pOHpH8jtOs3EawdPtuV7hZTS6bdmFlZj8hcG6tAFlJlG0Ov175CrQtXVG+gu9azAgZXwU+AkBzSsxmo9pjCHp12p4HI5rsns2bCccy/GVu2egSE/pHSi17OK/5kE+gvRy9OMym5wH0X5MTOhsakjxKym7DREGk/ILOTqdKQ+2zwoKdcxvgcHvyBJDoeikXpiLH44g6ZwvzyMlCDUAmKhQq9KcUlcFce/voRkmbm8e3QlTQNTzKbZdsVUTaMCbB7eVcXvzjz1EactWwm5Fqjof9snM75Aa0NhseoYpY99vHOIeCT2MxAIXxOIVYC32xgEpzpoCxz++IoBxoooDwzrMOZV5ijAuItlNTxCtyyLeYK9DvEN1zhVeDVODRNslQj8bgRxAnlyPsCRl2I+0FkmLZ1luIW7vPZw808v1kbngqLFIA52aaph1FJoMFNQ8PAvNrUIBw6KbDTu+WNzmR7nB5VaHX76QhUOYJvwVp7opUyixBF1a8M1PiVyvTCMPAU1R0oI3b711B443Ds+1w4X+nAJD1sWMM4H/0q/Ov4iauuMR84Zcj+kJxfubQ+Ljypzi4eZAcfdwapJB7ZIz/XCttskDb6fNxPmMdoXqReIpdQsLcVuJEGEi1MVE6HX8pP1MRMS0m3JiPoIs6zULBeAOc2w6gIrOYA8iWVmvATMvWwgmnARRoEmV2c0ggo8o5X4tlEDlrUdK8R1/uZWt1dcXwWf052loE3X9cSsJ2HjMiKU4KdW02OGN0V+BBMtM8n9vE526SJOAkY+ErVogycYKj7pC+mHL+1/0kGVit2kaoUwXYNWOLTQc8AwTJ0nQpq3nvw6tH7Ig+1OaQGkr4Kp+MwdJTJHZjgrzoNALQHC7KgNAyjGecSv6GTIh5wE1rcJ0Y/G5GPIcFugjh6lIEtuU4d0k3Rozz/RGAxhysN4KVaQjLSyF2oaRzKB5SjsbMu1lKg1XDbNwSiDrRYd2uYhEvxYXkLbsk+LkyjF/TCnQ/iAHvmSPmxyB+Uc0IEX6IgOzTeHYxkcgO6AXJTCVJUPiaAlAy0fkpB7Le754miEmaJ3HQ/00KGwkO5Bs+avDNpOgsS1vPGPAeZfCF2AN5kh/OqfofJ4hRLPoGAzCCc5ixeS8bcJhWQjDb3zg/WK4NC/vklbGs7vX0UDTUldsu/qcGZCZ10ZWvF5qe0ZELiZ0weC2laFFcdCx2TqbEAbtK26FbYEEvWG9HUS2Kdnnugo0HTTlVin4Bq33LYPFD3p48SgQspr7s7SGrdzuKHV6EarboO2QcGLYt5xgbBGBjBC9rewgpSuQBPH+RiHBnihOvNkxcEmElYUZVlhw9fcNzmNCLQAJayiXzeUXlTUTqr4Kp1Kq8jMrVaZK6QZsM/h/d8a+KjuIMNvSp4oZzaWcbpfpWHnIjMCrydmo4LXFSpDWjpfhNtwn7LRhV2wRJtZSHeiGjSCA+xBYD3o4/eHXN+NCVPxnYqDbiTSmmNXQxLVGcmufgUaWYYYTKVWz6zyALQV2QQ5s/rsTocuSdkn2z/9/Pls1mvNRESn2lpCHJvvZBX0GolCqkrF3NaW4xWrMtilWe3wzUHAlTjVBpDNx7X8f0JjmBelsn6q9E9IKPK9h8bm8kSt5kabqx6pulqIb6edxT5tu4pZyrw2DZUNnu2+AXaKb3cUUNvOTANpfWaNGCw/eGkrpzD3M4KeNG1VjFtZaftvCyuYNySDJ7fONTSUH6VF7HO8GH/zflrk4ZXVVpq/XvgcFzvGCyonCm7vPojk3ORKqvpcYQMC2Ps40RHcOIlXDS8kf3z5Sev+8LjRM+CzuvHdXtiJUxbT2yJLoFlCFKcOQuU9yED4N+PBLegJa4I4V6vo2/CnFiIcrnZu6oAgJYuNq8q4/g7nSqHuDs9JJ0rBjDxgM1CyTWel2hz6d/GYUh+ndGT5ENzGqHX9YDsZ0/ggG3TnVep7sUy72ZxwCSurRV4qMjcGbN8Eea7UmHd5LyZyFyUlTd+k8ErFluKKl8ylFSMHeQ0wzDl+o343+lbUXRtg0ICDVHBJCG0B8RMwVyRT1tuNRCcFc+6qg2gicadp+ggMeKycYeQPMIMxHgBpgb4rlMLrWAvFibDMwtq6TZK4GYhx0twvEr+mvdKEyiCn3fboMhx/Wh3npKrG0G20fd7gZA2hyqr5jXuL7l+FMZSfPKEUH2Jgi0HiPljQXSjmH4UN3mq8tD9YqrtdbMCl+zVjshUc8LO2JSjgFt2lRJjaxeBNjCapqHir04xuEcp9YZsX6O+7TiuyumtglbBld1LEdxCRJDK7pnlOI54bnsbTtTzdz/7w+6uUInFvTX3sXwxP9wGhVQOr9cKV8PTEC2TQC0i/BhNW+ksIUHLz1N+/jjhrvhdLcOi3i6QmPs2ilxo5bO9hpj5p+dcRoTWGVe74sdgNxPy2jpYwzZpLTRTZlvKjCzvVkPpKS989UWT1Aqj+yA5tmFW5V+OBEjU91b0AlBGHQMrxdHZaQUF7gc3B4N0jZUdj7cai3R49/JiCXVKuD+WnsffUCrzI8MuYJ+Pmt1T0bPVbCvcHKB1ZDyLWrWFc+u2GXvN1UrBzYGGN/uE0zU0v27tdAuMhKl76nqWBx80RbISW57PkWk8jBqCHytFKR6yxNMe5i7iU9SVZxnl8rUwCUTYFiMUX1VmCo06WeBtGfJO/aJ3MEnzNwjNPyzsnaJzjNoITjt9TfkP0gL/FCh9HXJshbTykZz+rkgPCtOBPduQOK1RiAlB+jQ/d8jj47cfPKCRGq2lDL8bzs5FxVeQia11gh4BGk2QCOhZy/d+Ytgqnw0E4HMV+dHuMfVFjLSlIaK5L1BNqwul5xxiy4pgZJuHmNMd2DIa78hKWBtsQ8nYJkVlzPbJzk6d1gg8cC6esJkRF9trWf7hoTz2u2LjcHq9GKg14LmfSfcB8P0CFIu3cVErK81IlaohBClZNsb6uVrsEfCFuBHH2vAzNVSWAtDokjXQ2/FWGoSJGikWm9Qr1W2fyHGyVLetuyhDaLilhxSF9sHVuJwWNvhBkV6E2S9vnQJuEsfVSxPCYlyMyLt+SV9o3Y9UCihI7BXOYn0RsjHqUinefTBmmk2D3cm4B5jXHmoEYKWCrAOjUeupRY1O+nksN5emljq1JnfWml7LiFX5hUPOTLa+Xc90Brhe3YNtdTGjKhldISCUiKRpZcY69nAg8xSSYGlaCx4OXI9fDUi3ieBVkJ+1q+TdQjm/o+izwa/xo2UJrHDWMdZcATP+r7p613p+PqhqK10eA08854aBUUeIOBvm8AymczHW0y9wqOnqGgZAfO26ufBIxW7QXawQHZa+MtrCHqffKuE24BEooKrpHO2QSC7UB0e1snCVkLByKqph4+3s8zZtQQY5hxxrT/GKAiIXEx5GRVmbSmIF/p2bxMSjRlrYxcznFTTuU0P/BdpYeMmJb8KcGbHwEiWUgiIeYFhafiG7wmrGmISummICqYIfcosAYDV1Dcc9oSvz1mQFqbEn+ID+q/QtR391HzX/AjL0Y3jkIrkp+ipJN/rtHfEkaI6/WiTObBNUqVEYkmBxiA8jXQxcZ4mtWHqAGXazR6kBDOInY/C1NG5rGBJ+KxhmWhgHCwzPmF3XDJwG4Q5/7R+wem9rUZ2kwujz+Tu6TdshMtux2J/VwrDFRzcQrDjPpXInxtAVfvWC6O3hH5CCtPAJor1rGnJK/TK6saH4SIdfDcx+2BBrttlefmHG3pVdiSIzb6Y6agVOty+iuo5WC/we5wbTcaj5m9vXvmMlbbt1PIEyoh2GzNwlYUDInNgWLqKH5A39gsMj2b+j0k2Hb+ufyZFS4T6emKJt0bi5HmFMuDRGOFgDe4/vANpyhIIusHYlbonc7gIELrxJM69/2XjO6sneQ/OJ6onJkJ/jzWP3NavOmjXxwgP9fzDuKgm6JpugHhqBdzQWdt8xY6ucOtEmgpxY9LWnUKBHF5tWIEacSE1JEVowzDLJUut2VMEtcirshMombcnXQQKMpk2xlpcoqRER5M4twVbNmWHtpyKcmwfneLT31B6kOsqBEvbpKuvw6iyNypfJ95Pq+2ihjUSP2pIhMo9D6n8xWFJhyve2xmW8sIz8sO0bDQMIs661RAcV/7K0K73WmdScGiRKEPXMVxVNsU5JeebO+Fu+vygq8bZTEQW2HmgoJRDqTw7CxyPEZGYaZKDgVYYM2FfWJgN6ByOL+11dKA6m4LxThoisqj3vka22zgJRDU0Wo3v+rR82xQh6wYjd4jw4tbSp7dQz6KcDVxN6K4HNg1VhbdaOMhxI/CJAg/lqTcI96BYgYpQC7xI3H4+5ZpRr6IT3tC0CbMuHMcrJIwirwbbKDQ9pqSAMvyXSHIAVM6V8HXF6HZMnWJrKObz+U38i5WKE6mDg410fJaOhqsv0ifYWHHxLicr63afJHE2vlEit9Uc7CdDHAcGSWXV1EWgJ5/1Ik3imLPPa7Xbq8UeP9qEcwWNpvAAw6Unnvm6fY37dSHAFNegOY5tH4uL/QoBMGwVsrsnl5L7/6BxOnORgUe8cingNfHvyKs5m5s/julXAlj4gqaXurtJbJgdgjh/Zg+cQzs/6HXxf7qVWKLCCDgnD8KFyiKlyz7XUsd3QdQaovvIS07+sFxdYzHwcdpgWTkQ5p/PPayDIXI2D6GTcVSmi/arkQn0jn9YEdJ7RQNau2iRMiuFI+4BucrBzamxfdVOAZwf/PkPBvqGM9683VeZQALPfVz1ma4sfeCurv81E81A9xKZwrnjZy35wD3+dj+UFeOj1PrX2jHyoDJjtfnq9PyYMAcMP2F9scxzvGp6N0SeiUZ7kBN+pSbNDHDkQuHnB0x4La+vvlfDqfOmvd5VkufSUqtpQN4lqo9spab+Qi1jWgCjRpaFfsF63fIagIAgnAKeWq2vW6v4yLJRrZv57iOJv8plKzxSCHHyNnWRvmsHFiDmiCdSbJ3jL8prFzqCh2yHXTCbdo97litNAmf4Y1pQr4X83p655g1WPYVa1yZ1WrFMVPNeAIC2AuoSru/gQX8Nrys2anXG2VnD3U6NiANpm4Etz9OKw+0lGgCqXr8goncXuOY7TdjBIF84uH0t4ztVlso53IVE04+4K7MoQbJY55p5hXiXdtPiDDWwAGligb9fg0l1tWjbh6b9gyVQ+X6lYc8S8tKECtYrzJQJzCN/azd8NH7EFi22YuqP6IGMkqzPe4kk3vBC4Uo54Rv66JvyoQosRScHD2nEx2MKvhoNdYrtztQxn+xGN8mInE/fmD61YFqY78LTptUwhLBHpk9Y0NObSsZiNM1nDlo4UAmWhrh9Ehw2sFaYgP1RD4DRc7dBVS1BNr/e+/BPpstvkCNcpV2q/MU75ZhAoIWgQ1S49Bj3C72MIslXgaRkIjbkNQgF9vorCH7U9gQFJG5hEWWu3CZoQ4nsDIZpW5dptYqA51OIhcTYEVNPQtXoBr0wftQEqYca9Ply48CR4zxLCfZzBF8kcfGJplxQPG7HbBHFLLsAEPDdjguzmDnjNDKpf0w7Swpa+nCLVOa1jbxLzgbsnGC6IHyqp1UvpBESwP/ToeSRrcviAS1ihSEnMj+FtrDlAeJ585lEIHg6F9orLXtcRJqLRG4M1iSiJz+Kc6jNXG6f1iL/PHf99sayrnmDnu7G3FBUafuAQlgBLrYVAPSItt01e13YWR28o68Y2FrZfz7MYY/ipx5PRysfBSsX1oCuW+h1kMfxlpTmB/i7gwQ4C+FPkWbGU08kN+yKbPKzoW1fxYkCb199mkNcqfaGPqrQ3mjCTb7OTYvwZzgyEiwW3/IDF8JkVOkDBEwZK4GALLwg3OqMM2SCXqtwsfHPODHhKWTNmCIdTHb2BpHT29eFvasVNanU4ogFbSeGX5hbyJwEFmWuMiV2ALowYZYf5CxX/kIhsInlRq75Ai70NPS0Kbgu5IFQhjOY/BRIPq77fYU6w8Z5IK11gnC9+U49eT/qqRzXzb0bwWUgGsOaa+qhJRIeyvOuUjAJXHufA8K7X0xBPKYev52q8bl6Y51vJq2OQ80JTOgUAT/GI1qBXEb2+OLV/0XTRZib9Jkco7oU76RdnS8KTQnIvt3IQvTZyHYuzTEiu7WO9lBcwGzUhL/GwCneXQz0WLLdEe+z2B1qc+sY2uYMZHAkOCo3HknCLG/KF0H7U9dmELASwmmXU6vLEU7M+vmfjkudHDwn+qoaZY4JfPVeyvV7eT8kTXU2MoDZq2REporsNibBIQXOkXyeAX4EqsMUI5bhOYQ2QbUrrAlnO2DDlD0yrYv0m4R9gUd6usAb6ZqRbuBDfzTTeGlDgyxiUUbzpHpdH7gB9vxpu9nIXAyAMaHKBn7T+f7NIytrVQrl1GGZjzrZqMdmOlum6FtogAK3qtRzC6i8gWgbRe8de/w+/VPUqVrQgQLT+kz0ZXvLxX5my7Phji/1TKvLj1fVZpzJ92pmFM4SXBPDmHG4HjU9g+AsY/ihRI35MxBbBejKsKQ+rfberBRAfQc69nehXAgM8nKGGHUl1iQZGsqbaV1wj/P80LNMYirjNZJl/yDUTyF8S/lBrzAPzyB0j2HOzBX9i+8B6LhFu+lJtAo0fHEpK/ZTwilQePGLnXITea5ObSwEpLl7Ri9cSnF5HKC7TqGG3pqyu6arOMgcYsemUrvOIo0pDQa28wndo7jlwycVh+qhXNEOdrhtNKagLeJ/jQNe50iVBQtJxUxa7HVvyc/ZVj9d8XmqXe2/ZFbq4nuxaBYpVzGAlN06Nx7PvY8XOKtzM9ZUHfNnDKMjcvvQwPVqpNq4qagflbg0vtHfXqw8HM6ghC6A1n9hFdMcNNFadBXsVdBRM9WXgb0sc7c3besAtH0VW2SouS4sw8hi0ddjcbmIy3Nvu4CYllCE4S+uko7hjfhiYrwvAdfxCNK0S3YAoVh8qBdHJRw/pZGu6tFbTxTPpyUdaeb8MwX6ElWHTQmAqxSZmg6xRNNZR6uU8NZ1btAhUd3O41YpOfP1B8JMXSclP1N6T6D6sae4SiFvVns+h5GjaXgevDbH6RPFvwUDWHC9wRvDopIYDPxvDPvbdRpOqiw8U3bH8oCbNC7vvLvKR6J7dryZJQfcuN9vg2g3xYs2nDeABW+yWczLRg3UvO2PG+usqcHDW2ck28jjm3CRTPxJxUfSx8S63rmrgvGjGhxeYZ2ALwpdzzGw+EZCZRloLvKWBCveyWg4RFlgyqwYBaiW1VSlqGShI4txY151nr7x6aZVhau165iuQmWT+3TNC495WZw1SNgPoIcYn+zeTI1Dpx9zxgiFo06sMPoKdwUjfXFc+SNbKJIh6a8FrqgzMuO8OVtZ8h3OW2UItjcCDpfOtWLgTP6KNO4/GDxNpVs4gRnSv8sxG1XbxOL2RC+1PllV+Iw9ZbKT0cKajI7KT6or2L32uT9AQBmmoEV3R32k4uax4/doezimSXVIkzBcijGxsOqJ5OD6OhwFgieDcozGkZiZeKvBk2u/CI3Nwpl8A+69pta6e3ypXYyRElTNWfh/rcuGanvnluinXbjklZ70Mr7fhSGEnfiPgf48Cqw/wTdbE4/TO+HZBPNeZ+Y+LsfwJdaK+WF7WLTlvdfC3lklL9zwpW6l3g8y1MNJlNBfjmx1rPKsrg+grxqpM/R2T5tNGeS8ORCrWz4ynDPOUom1NmHwQffmL0zqc0fg8QfxaNdYR+ZGyqcKfpZa9RTTPOzz+esFyV2cF/pCguCU3CU2TKrY9cB/DBgfRslcu4Thg8EHeMJn0LtgKisKs5yM4Ae7i7Bfu8BY4YQwjXmdwEV7n7lo1h+eJZNcarm6TsqAJNDlDcORpAZdetWeXwO+p8tntv8585EoFhMtru5nJcrX1Diq2q4H94D0bMYPbIlJqtmgJtHZckHSK7oawxguq7LBOg2Oninczceo8BEMBaKU7fe9c7OSX4WMR0+VGA182m5cBUjmQO1plqiILkCQMlZuvliVTz993rTbaUwA2CFOTTK0S9yR2HtuMvdXEfUsXb0T4zlIs3oJAFaTkt+4SSftdNSAry05PZ3sEZA0PUKxiTy7qtCXvl2ogHKmnFxcunzyMx04Q2SsMXvb3jO9T6gliv94SWQ7kSYpHhl27mGmJQHJIgYMOHSTf32DTx8WzaR6J0iVaG0gVzzXcejVT388SR7A2dHIHiY77X7G+QJiq+fckBsvYdhUs1AZhJH2RohhhGS3jUISGOF3ogiqJXO4i50Rl1+St/9hdrbJMCYgU6yJ2nXU3nio4o+u7CKr9S4FMzYBJ12APORI+Nc+TAyqICya0VrlK96RawGWAsmb7w78bmFaXm1kl/Cslcdz0fqRYS1gW9WmOKTcMvMMVe0mhKs9NzNT0YU4g26NhC8U0iPTwqkI335np2ixcflpY7qM/1kWbG+J06bVWrIno4+x+8TVQqUz/+CYO76NaYWGA8FNKlIu3qsXH/6Hk1w8cHB4xUtqpjSHNaEmgovcOW8VQCj8vKckJ6SFWZ7k7os7iEBF5gZm79nFCjm7sb+akDbWofXC7mE3FdwriAkDDXwkKHlb5DUFZyPe6MM/N1nP0KO6ODz2hWVQiaCZf310fHeXfULkRk+pVENcX54YDvMOFiMsXJNcXQ+42KWsELJ5h+uBNxraOJV9G+vKMUM+RZs0Nn3cpeKEFXvxqdFKkYONV+BePXekOdlqTQ74sStcII7uTYGU/LPomEXWlGu1jBqlhTljyy+urJJ6ljdV6e3MjBHpZgYbCypaEAEZ92o9sY58gbyyQgjHzV8bs2aWpysJ8M23+eoxWp5C7BsqyAWAWleNTG9OlVgO+QPkunqswZ+fcu+Pn8Wy5WonRJcs+4gEdnLjLtIU6Ew+kpf6cdpiATsuRqaUqWpistlgVCLXjRsWWWmmrexXlmnCGOR0wwNZ4HbniLq3CzJg2XqanJrQ+jcMDsr95rR+hTlX4vGyL5njjc7vX0zgr8RdS/M1Fm9CJvOf0wIMs0OwHsy/CEH61U4MVkMJYHiIYeMdPV3xxbtHcgEGloi+ASgyybbLnl2W2xnb3PNKhx3eT71C+N4m1TKCtE2eiCJqFa/UDpdFpVqjXVU0PJCt3R0yuhxmao92MOaeS1Ymb8xlI/Rh/O66gZbBVroM1qYWPBA2oE21IfZWknMjZG0xIFjktE+bp5+i1cBgTvwYHBu66F52BtTT0/ksi5rwhEOe4DTs/JL2dIVI5ShwnpEB4G9i5sL/1l2u+0hVdxj71ZUk+AU1zdf5A+xgS11yEm+twnb6Eikllj5cNva+Qwavwn7cRCvFryt0b1+0h3dFFnapN2HvFlcEjEL6O5/iIS8B8BcVGjVWP2Kp9mJ3U/pZ4W45a+JTQ3iHmDmOoWwuakPnlOrdgC6j/LP0AoLYkcvJYc/Eipy4ENP4iERq2qMj+y0rJAG3c6UD226TAnU+tqbTScRVL4jTW3p1uxZ3lnX0P9RVl86hV+PF0l5o6XqjpBCO2vb9Wp/zEaweR+B1Q+Q0nHYRcJLBg3xRoGxATc8u7Bjo/B9DYmdUz1yDS4H6xKQnq9Kzd+7l9q/iwFSR5WzBC5N5ZaLsEsxaDL0tTeuHvXOOK1lTcb2/9KPL4lg5+pT4Eo6n815TaEkL9hSWnupB/3gZ0AweunfbS2R0ghv065OrHzg5gXI/rOm+4n+qQZELln5dIaAohhq059cHnnWRPmXcgxZGypcGiVosSS0Kd6lfWYRlir2O2R5zJt+ZBciiwKPhS/b/cPjGwMR+Q6A6+J5ArUD2/Xt4fmmOZi9lROhJyfLZcBtElJaukPFy0l+z8TCnaCIdwkgdLh/oQL/06fZvTVJ/waj5RqTnEZuWVbMt9aqCOrQtz/bRptWZSAcTN0BWdVrRA51H7ymQ/Oo8i+hpqdxETHngXcZ6BvjwLqDd56QDtLipyDiDs2lndyqE4Kw10eAmZc+bZ1LuxQoSsvCKqf9iCW1mtAsQ49seCTBLbIrkhew8zWVRQbDJmLC6UCK6YoRnsvqfa5STw0dujvkFmv3V8kyamEQO1G5Z8KGbVDBRi4fQTMKKRKark3AXc0xAE25jDi/T6Gwu24bIJxPIgKLGN5c0JN4e5D9HkfE31LoNmnGSLj5jZGZ+G4aDC/LrzoVKB8quegxqPTM9k4+WpeFGo/a+l492FU9V5PEu9KiE38oVsQX3tcjO714A0BstZ1YXIhcTHf7Ikd9PhdL3fMHqGWRdreIs1WTTl4i5Iuh9F/2SHTwheawezZaNPAoGBlIJZXurBvgZBVEu0Y6q/CLxhoS4ad8nA6KbWUfbxGfhyFP7FPzNrSGpmzwXtAf7biufOLkF1B+O09TfJKwE+Di1Wu/DcQwWTvRZM0XR4x5K/9II1xE6AeCZkLxcP/HGvpEiCZ48Xz86OQRwA7WAqQ0AR/7Kv9AJo4dNLoErllm46/wsl2HsgKtGhdXDHOuQLArtMkL1uCgXJLOWAxNGyQqcsXK+1TrMz6tFx5NOFOv1iVeBSxdAxd5MkUSOuJLkNXhd42gVXaP+lRbcnwaUHa5vFumAGFCK3Dg+4hj1RvJxt+U+O2IXcci1YOh//KzDRQd22M61sm+i2DlxpeZKnWaHeuY+eEbqLDQ+UqWtyFKhLvdV3XVCqmp9HH+tuz2upGcVqMcp0l21OQbLN5z2JCBs372BODVOClmuTqHfxgYfx9LKGDaQn9MahbIj2jGMRs81NGcCbS4bhKKQ0YLdqRQnyTNRFiORhjCODxcEqSh2x2HxnGRN+zBPtzSx9RvVvXAfa2tRWR07NZA2+e3uc/P92uH7JIBBk2++fsou1sbNPjo7mtO6IBG1xtXF9e1VHNPIrqaH8dVaEs5LnbDQN/5+jEOwwqUPXjTpjkPuKSA/3PSAkfnKXHh3GPF1TWdKdQkiTStVW7yHasAS0HciwJcoN7f7L45m3G1Z8nKboGrrVtr/SIIaw1/oD8ITA2yy2ECfVadZse/coVPbFBFUejAAsdVbBReEWNpsBPpe4bmDKB9TqqWTq1P3FyZYBj7o068htQDPdg9KAJlfbOTAqLdNqjo0x6pF1vmzBhLQJ6FW0aAhpAFrfbjm2bu0T6Nfy6V417G/js1eb2ilg1pUKReP3bVZ2FtNzrjKHs7M0EdqMx2VhHHpbsgLz0f7eu759LKg+JkXgVAPeD2Xo77yNTfC0sj6UJVobyMD/3g+hN4V/YwsNFqcD1JYj8IMBgW8hVZS0upJykJGKJJ2WUAsu76DpOB4H/tNDiIkStE/ssidnLekb+5MBqlAifTt/vEGzQb13HQUKcpHCs7WlW+aIw6hBCmjWKpNtKLEgoh+/RgVoqK3ym+wBN0x+7F0jgNMZ9Fr2yAivGb2KjiXfxnU6mtF1R/v4YzWGIHyf1g1phbRPswOhQel8wPYtQ4Mw7D2/xc7W6Jd/wbapO2j1IvqoPz5c2dNDTfFZ6rCSLbeLUO0X3Ewq/2FOgOwNBqEAFprFLr7thvmeO3o2YHiI/ocUhAHCtUBq9NKBFRM0ck0mviTBtoG8KYmgjCMtIytcl1fxV9a1wOH+ssdm8dT9Ov/Pz7JMdwVYUd4e1htpK+t0K8+NxuxzR7eSc87WdLoiJ2Su1CGmU69yCu5xVYwo0OhZHu4c71Znvhr6BD3Oj5SHysgWcmBNGkQ76n+Gh39lN3mwqcQiV+dctuUEYd2cVlthDeHejo8ve51iF3bAbxtgf1YPeNwGO9mSeKrm/kc/deSX+X7YaZriOeE5siBO5LTuPWxuXRFmYuKMmEA9IEqN/SgG9ev24Ii208EFqwP2MvN8UnG1qUh7AxEXtmwQ4pPK6cYQuy9grvWoEeZAG6ffIatzGwihpdrZpXi9TWdKO3sCPfk1bc0YHOPmUCjNLi7OOCb4zHlP+OL8EtlPkfuqPaCuub9S0xreuUUB43dD2tZbo7IiRELO8BAtHbyiHgAKQUSJeN/3RTCekTYfuQ5mkCUDZgJ0b0FSv2ESPYQT1kwReEIqUp2GdFtD/fISqadr9j5DgOJEYOlLac9VtmjHN+m4vWo+8JFBu1y7WsVgSZJgiMDYXfZ2SLSYl73PFfGGiBevKLrU7ko+etYQQk0iCpg7GrqqFTDuPDNn77SRjxo6vYo+yerlUxgF3bzs1ryq+Ix2QGMkGINfjw3hwKV00jrz6mQOZ+lFVHXdSOzzbcl18s8H7I4on7Wv2fH4yxQTu7RioEL/g9MqekaTzqWZPSTZTR9fLha+FxKVYISgNVBw41K132i71DIBNRzcEZvGYCfZ3U+HHm19UlkoRbCK8NS/eIwvOq3VDhfXkCVBKSD/U4ig3+evgHKG1emz+OR5qhk2et6yY5OdCr6QGa0nO7dMABBdfjgDxFXgqu7ob+VoOwTZjLOLwSbOX1YM9Vf9oMSithmjwlJiDXAWhGXlF62ouQbHs32iDBFgkahKAhhHOxIiWSburQUcN/KNeWApjTftXXSBi8NR5Al8Dz/iw9eTWnavgQYhnhuFTtUIbTEk/NDVVbiXbhDDmeGXP0VZrtnGovGmEluuMKEoZVNczY+kBs+bd3+ASEi7Z+ex526GxmXaM1/pGtmv6kphKM8go4yEGNEUBObx1H89vxwXzpYqDJx5uiulAvFiQD5wJSOcQpF/H+QMHEzOIGUrEQstvbDEzVsuVHl5+mN7M0u9jxhsqP8zTzMOM4ZuDRvHQXbOm7K3cfbr6gKPP4oXONbNgQ/VygZ3jKP2TpDVnx+IlpxvBzJdJVCaNDBmHHY2WzuNcHPr3vVeevFK0NlJYAg/buHcGofDcLOZYjns4dDxsvQQTIyca4JTylZWigZ0JpkS3pLr526cGKQIY7Ouzxq77uDdQSn3Lf2yYtMvZF/zzF+RGACpoDr8MSTqyQbejF841BRUFTfLbybxqS1NAVWz11UhSaAvo0PiFB+pu5FNRlPS6oBswnFEXdPG7ZvqpWv+O2aQYU1lptD5TMXG5KEa724S1cu/m74N7k0KPCB0ihtrYNCda1t3indSeyK0rWX84F5kB2uX0Xma0dn/jZmHWpBiR17+AIN5p8elhTDr4T/6QGaJ5kbl+hnTHqe5pZfWqzi+u9HYhBUsEtMXnslxA13zrSjuSh403XvxhOM+WoFLlc4yFFctZg2jcoTxuewulerC0FlFMR41svVsd+T++BtCprJnq8QYD3ryERJINPeBtLxkcWw6Nk1ga27+cY39kRoTVW+Fdzd7ZQcJCsKJ31uIXWZ3ctvC1gD9dcxIeYttIk/FrUXIxzQWKwlSViT4MnW9//c9WPoxLjp4DUHPW3y6P/Dlw4HQkbkmbbNDWAp870w5+Ns9zCULF7d+kyTDSn42bJtTZ5vKJGiJcSY9iywL76m2BVkBLS0pL6Xoq95APpheskUx2qHWE4sYIdxOwQXtS7Rep+oxI+ZGp7qK8C5uyZB7uunRra76UaEH/0/OyOhYVoi6XIXHo9JRsa0Yh5M6NeWhQtm83rSgzav2UDpZflVR7RpLhfBIrLZOn4TtiaPPzIonCQWeDThUNwUQSlSQ7ono0sbTkxUJj01j6TO8Y+WFESYpJyd2M3tYIwy6NFVcGbmwvVtEbPS3GCZv2khWqJQv2JtW49S9C1nfhqUG2Teq6KcbylrM7BJITUMb63u2fdndd4IDtesQex1OjasIZh1m5GOT/pXm/SP+8foZPT78EGivl/id71MTvw9D4oQvs3CA7TXjRELV54rHlhEjYZtxAQmauJhVKt6ljcBje8P6tuP5/A2Yg2WfO8JXzlHqsVlhornPbbowhQd4nMTEDrUoJ6z/k5qPTKwMLOdUm3NdXLQ8teBsOKu3sim7C+H/7HSxRR2x8Qs3cROV8NoJ19N8XiyxMRoq6u5be4sZPfqcvFbchf5ItuigFbeW/uwVs+7vsd9aPL6/qLP25V678GI2CDEItLUMS5ZHfik4RNBdai1uo1lMaBxWVwB8eVx9PAGFi1lVm24HR9/p2ifJbkn2JraVtkzFWhYIjhdKV67TT5MReVG37xJIZvDo7nRxfgSllcWhQ4eHsf6Q6+mzsGbAb6Mn/Io3iXFfZUl+YPL/1E6AuecbO72EnmQ+55CYbOBciqv2BXNuqVTdAMj7HL+dceo7huH9Eq/p8LSguon1zrFRMEd652RF01tHD21+MZ8wh95rVP8ae8CKLNeQh9iEEQMXq9WWxY44XfOEAHamW9itmjT8Sv03M06q0hqJx6nLKTV8Eg7Nliu/OWxxlZq9DulwF19MnpCTveBybIuQyaCQAmTXPPgrWKLk6/I0k8gQN5Sz2WHUmPhlz6A+3eJWd8h5K+1tu44qkokl6T5DcKXlezLgMcTYkk5wSxpbTnZ7GnZtc7YFuSbvrAflVm12pLS0I2Y6qMx7cyFLYffVAWKU1qv78Mw+uh6ZJJDZxIBOvPzzDEbvm7tomiDjZmSNsaiLBe6Saqm1U7goQs8f4qO6BJ4xbFqJRQztdkxURrOFqDaf+i7+ruPKvNxghfSvW68Vdl7f30vuFr1j6BLvEyazd6Z4SEHCWuOS2HaK30JPdA4E4K6bhnxkY1NVZm41qhAK5sV3bgqbsQvRMRYtTmyJK8B3Rbh7Vtomohd+Y4ZH8MJ2TisGq4uXAbV9buKpKgYOiMqwalEivjbHhqFzRP6qPLD1e/gzVtaLvCRLtXMh+RtsVALBW0pbKG5JmKen+XxfGpG/TRgjAKbSrCV2rMOXtLzNAPBOUIUfYzKtWoH+ejGgH8gTJZn9GYDzKqxwyUS0Ly+XRpcIlO/PMBaiU4Xvh+ZYUFi4x5+oluAlXmX7dE1GCaCAdcXAGIcCNoD4K+Pcvm3Q8oDYFMXkNeI5jZ+QZBy9w2JUIPI6oF92+aCoXSKEGJeEzgFvzBFnSeUmUVcIGli+afwFeIF4CQKg6D/iGpNiv6q5pb2yE4xsiMkDjjxwCt4oUMDILDZO4E56JD4WPHTH8DklAXkKpKphsm3ZXkS7jqlGd5sHhMuK5vv6wvHNlXzcp+FSMC21tAY2ohC4j4ykOqLUFZwOxUzH8Y5zeAYKPMD2OjipJ5O7sEBXVNNzihK+Zd3XRv0OpdlUzBV/hmGHlOH6nItoGiana6EkPbiSMIURo9vvfKZmTVLi9CPSXlBr6t0M+L99Z9cKNNyvu6rtpnh0Zwu7kv1NUV9EyLSTNL9x2+yHVZ+gcnUELBDQJCRyivfFvJQqSqBzjy/i94n1lbdsgdaCDUuo0JQ9rhzolwCpqEc4kRirEFmf6Iojhrgz117E5I45roZtQlcWlwzIgDKVBGXnreJJG2bKXwGqxvS6xxAX+rke2HTtd25aH3EI/VAmLn6zoAD3UNuPQh4Qt2RRS41eamtLJfVHP0hKHQDxUhMnXwyDJG5h8/rgHWZew0nyRa7fxh9dw5NN/3duzrHt2aDWs4TeOGlN8Jz2GLrZ7wDwg+rP+nbvl03Dt2xChdpv5GSdD//2fZnoXQq2iSGOWevaIwN2w6Np+k4Jm/s3PTclWcVK93h4emYHGFHSQQreNE951YXw1eCkCUKUaFeUn8PlAXOtCUZ8O8MLVtoRsoRIbfLLn6TPqaKifVkXLrFOYBjjihb9bJSzbT1mUJ2rnLU6oTXN/9kXIH7oy1wDkrjvK/VgEKRNB9XSHNmyeCF+MrnRyWNawDqHWQN9XbUsr/aWmwjqWCUPV4ymjXgPjCjdQwqCauHMBKpZcsKWlTaHIJoTdyOF4dSOhboe1aZqfmUqWtkfAB8T0/uZ0+YqN/csXTKS1DugclP/8Axxqw0y7qu/y5A9n1esTq4PQRLGjZxYRZu2PGKl0DsL7VrwrkfnR8CuNuCPJ9JgrEyMwnzriD4t53mFOncmegXe0C3JuBLhZHcpwSMgU9TmPN2vAWP++Kd5NeXu4zaC5Uau8br4V7Stdory0iHusSmbihySp46GYue7t3d4CHNBeyBAJG+pSmHI0jHVZfps4/9z6GB6JgqcfGndo6QKwengb8BfdQ31UO/hdrvKWxU0ufiod/dD3mVDOCa0vNkoTxDwxMkIGP7+bR6PW0q5UuvlI3ffVCi0LVLIzpvT+xoLKg1eTHW/aA4g4CeDPzVjBGREec4mgfvp33DBa8k62/LL1ZQ37Tz71Zo3gBk7NgNOd9U5PBNhIfY50es25UAVFaWf+X3iyv1bnW/rh9vVt9mcQ6VSMZdv0Sn3WoL/jvvC822fWgH6xqskC93d/qM3Y1iLKAW8JLgQUrhWZi2aBRe/Mrjp9DqC8u7GcLKp3l/igocT210+yaAycjMVqTuox1hAhczLkNfWfxvH4diYYBnpvLuQOCsg9erzz0mN+gKC5ZKjOA5wSkCrHsTiZYIIczDYyxlyU5ax4zyFno7B7TvdKXoyAtGzvgwkBGqxHEKz91qWO8WjnUqSZMnpnVTVdEN2vo3/K+buu6aqr73P+ldi6EojDpujNskMAI8srwoTdqMq8Q07xZcWVXD6rZWKD5Fdzto6Rl5oAH7TDL1RH4ySdO+fQo5/cDIOwgydwcg4kRAGzR/lpRSq1+AoMzNrinM3mClGCT2NwbtUhWFy/HgStOMfu/Akg1YyKDbyrAXeJeAPRQesJGQllGXH5B8WtxlyD6rcUie9O9Ucz7EHKStf+R8dqCdkG7qGbkSSY4G8uz4F4fWsv3aV1XdFHIGU8a8wLHHg83R5GpmquwAxYXDuwELnCkKEXSOUbgT7kjygWnEf7jyYtre/IanYDoUGZ+6W3v65ELKTqlXM7dZsDYdJGLBOAMrpBnmwdvBiJwHxicZo81OivsyNUZgxgq6yozDGEE2xx5ObsHoZf4ZUTs6yJO64mfXcRH+wsRNJoQu1ycY9TwPs5xNYPSlp2FHepqr8kbA/RLpnlkc6qixJi7e1yNUrKF3mKJCamrQ/JD+QiZi34dHi1paFTW4fTQdCkNibASNkwu87f2QrvQ1E0OoEp2f5fmQbV0rgmvhqn/t/bafWCm+iyUJNdheU9ci0nb4Bbh7N+f+Z6PAu40HPXyzjhZh+jwT7L5/qrOPHhZQyKmBNZw2qSMnmeA0AnvGNasxM027yV0N1BhKH5GRzPO1t7cwqTUj+mbRsPa2wTSQzPfLtdHkYkDjhU8E/wRMiXYpBN3a58PksAQ+nbnKKOzIwLGjJaEZuEyTg5z16dd7+oN2rBYkjdYRDLH2FHZzrOWuM1/FenbZbg1zy2/dGhyA0mwM0Z66QYPf44Hwfzn7UmBaBEIcrn3UKJ8rShJh8Zj6R0jMLSJwX0cMAA3Mfvlk8OgNJXV80q/q6/3SxHlhY9r4XBu0uY0mL3yQyRkla982z+UR/D1VCvoSi1i8dlI3IofmN2FOg1Eo41WbEM5fEp0RlwBcsgTvNSDYT6Pc5d9XGg7BvhsMLNB/uqnD8ArZLdO2tYULyOy/iNPbNaGNg/ITtIXhyeqZBBDZSl5hKfQ2VjyVj2XxoNconYYGBljsH1vvQNZKCIvxCTmG5kRpgLKJqpB31nd4wspJzrOJ2pZXfHUOJRNCQ+J0P7utl5/JedxOAIRhOoTpLodkAiLW7t6iAMCmzgZszS0nOMeeUpJO2hWVSYWod5y26f8vaqBkqQu3Cr8yVRPdbwFsBwEwomKcEDhjC62BfV1TDMS4JltFGuGcLVeIsmnOFy4MMHJlAdFnKpFc7Q2yfHOJ3kIVvCzw+mHFVu51fE/HNJ/AZJCJjsOtnbKG3ALNmZRgznMoKfilO153dkXHT55MG3HArdcVrq+H80ke2zmELBEh5UGbs67uwYirOkN1QIqb3Tgw//tBFPf+0YeYyOxsppXr1cNAd/pj+7xvgA1IFsuxu36qPXmdExYdaVIsYzb5Xf6jDTZsfBE99lCWW6T8slhdsZ6UlQmCV3MOrt62KXtVoA7Hnm6bVVcn+RF4vLMsfdJC0GvHwf+AgqiIPmAwbwfyWXdgoYYmQs1CYufzJhzqNa8oF8Sc0r0L3S9F/SObiWjXdjherKkWrNDt4K55oL1U8QjXe4sNKxo66y2PUwUqcb/gkWlxvwD+G3vlWZ847g6EF6rVrfghR9w+stonnm0+5RkmtojVv+pQLhdOgTGySqJXBJl+0odpTI9daNlt22SlJcBQkcj25TGSoixZNPdrNXAh+eKRpuWeP0kBIgoK2GwypsIzqV4QINiJAZt1U6+X8ZiiXOVPRzX4obq8CZ0dLr0EjPC5Bf4IRbZp7kksmCmSXUTguuxTZiJID+h0x0cxTPKcZSu56fpWwriVwQdOmCysg1iEj2lrJNeTRq5w6+OXP9U49W+UbH3CJli9J6XpEMRqblJbulXrTB7gzXteI9VsNI7xmtpEl6f/tVLRI0vwpKJk38pnaCs1XpznDBVo6EVCQ68eYkGQxaOo1l/kxbPJgv87EXBQ3hQMLdW93a9qT+gsuGYpHjt0WvluhAxKiAoIL9LRJPFiyMyt4lcbmTkdfwi/UiAq8rVWTtj2pwvfS96Od20RbdTtI1px3hm+ZenR+waiJiW3aibqs3kHaWy/ac9L7dyOpbOB2Vkqdaze05d9g7SKudO6ZseIqQYECkARLc6AQ2cGKhnPzKn73z1z4Yeq6Tj06V1IkaxYQ1MkEKp41mPCCLf5icFYgjqPCS2nuX4FPUqgwM2W4HpSK2Dx3cuBvBTa1roFR+P3dtb98D8g921LZ3QD3n+MSUSIAnq1orEp4KhkcSo/x7jGQ6fjNzrd57t8V/I9UF4+m53ccsC2M+l/fdwIugwjFjmh46l+QLaABOqvbb3IY1sy3HBe9/p+Ubq2CGedIUoMlVDfc6DIzNpMkUouo4jEprx5uzcLi4/WFBx+cuHl6tua1pByWaQyn/ERLD8sdeqrqNpMqCHgPjPsDSrUbpg3SrRV0OohY2mqQSqakipd+Lx8K07eVCS476AnME7cu9yHSclsZpU6kVaxnvFXvOKKrYLdUvOkZNili6ojOomsdrTCAewhQmASq0jkdEORvPFp1325mMKfa9yOWRsFiiHLqWZf1Kj4xusyHhzZ+umDoPvhFvHaBBBGSe1Gj8XdgTX0MPhPKUO2GA41lMtKSg9577GLgTzNKkjgOTYxgWn8C+mvXTsdNHrm9gXvcaCuxWN169Thq7gNQ+GhvjQPHZcwc6vOfSNCtuoMseHye8IGGkxSUrEWg1q8uyvA/lcrcKJJVun9ml67+SLQMhdt7md+u4s8SYWl6hYtt8yJdDQDeUY4nA7VyHwJDrsP8Afs/zdDJbpOqrW4DxJ/5TuVXMCVJ3zdZaX4HsL0bNhsskPdQtWDStw+Uai4V1Ll+Z+R+DYrJco78nGQXd/V2CcpU0bLchoU5UhgHofYwXUclEwEDj3NCvFSvSlCORVxlMiJw1iKGiQHbvnz5tNxFyCic7fyc89iqN7d/jFic8m8fmWOOh5FgubtP8GVzcn5iFEyGSfi4tyuWGKm2BUzQnXatJeh9LYaoPvRj3tqsqdyBzYoUlRCRCNUvpvMsyDnjaZ927mMPv5rTFNSiDIQltOpFV6CqA52MFM9ps3FBw4dHX9wVaqlghsa1HZe7Ok3OZ2yAqKESjE8mRs11uWaDTwFGxEuVpkeOnlqxYmYvWDAjPSda08twD8i96pF1q8ev0P7q0CzZEI1jYyiccfo/DR9NPXJ5i0JE7/saGKakkSXBQ13Kn7xq+N4aMgBp0mXqHp0pI5cuUnwOZ/7ScT47ZuLiezr2cyFjjRzb03pafdmvlRfJ8yRdyZWmuJvirRZPgo+vy0XnvRcb7ITlaEfQvmwNF8Y7+78NDYpyzvRS3U3NjNciTOEQacBPEn+FlPvZkzTxHoDdfItO9HS3iJ5gU3fZUfSTMQ44Cu9qHIIHxfbBmvORoqAf2Npk1OtmmQ0XkutYXgmga5kWXaxRZWswbe8vfRAr+xNLUyTUjzRq74k6mz7LW3J4AnuLLg2dbLqbXI1FBgdpVrueNXhpAbPxy40wKObBBRDBMVkCWcORRhvDforcfHB+bucH0DEFiCACt9V19D/jfiIdqQotDB1ElSQrQpG+yoKVELJIt2J0T4cf2tYthcX6kI/UMTGVYSV7UDMLhHJN1wtVw5gJG6y68Ugs+D6R3BmAZyNPa0t7s00GqWYE4p7NWbegLurPHNJPIhuV6/JHdpdpylewLqK7j8QYDhLhNJC8QUBmQvaL/QLWhufw/QhGRUYlQNzbLW++KFkdft0xCWdTod809F1wXbqCflwYJYeztrnqenCO+nLNDF4sFWYA2NNxM4UYIinvf5ogmptt+yNL6QcRgr8lJvdCoFdzCkoSp3JE7CSH3Amwc7IsxZ5BpGWqMq7RkLZxxbe1nDxl0z9nHtxnMe3Zd+yqBWCYOQTyMkmzhj+26/a3lW8LNiMucPe6qlC2b7Y4JYQO2YM7ONzLzXRawcb39KiY4SJ6WQ3i/11/JA2ECkqfX4RPY6ykCQpnVDVZAYiP8ADL0C/x3KPoWA8FzSG6zTJ1irR94pVYonJX8wDEz82I03oELA30gge/L+kXXlaNFXCgEScY1fuAkNnwhB+CAgEkHAsQRTQpyordsN21kyWtxiss7hPa3R/FgBvSbwr07w/l/ZHMWJf1IapzVtqOkctg0PZVTmyOfYiR/U2G83eayjbIR5nKjbIRjG3kWqo/LrqWYS5xgPvgIsNHS6WwObOodyMD7gF4MfxdjOsyOmvtVt2GrHu+LVol9tbWFaSkr93tgB4/MrJAdBeiF+mtr+5RpPUfh/nldimlN6U4iAwKJzS+LGGsWgEG33aA8105XDEpjGHBAApzerj5Go9rgyPgMxk4FgeEvfe4FDFGlivL4RePIZfOOzYqI2OY0vOTNP1R1CWKGdxbQ3n0zdX9ieobIjMBtQrzg7Ep21dPFue1Oc1DtSM41CFoC6lw5D4Uk6HLzZsnrgo4HPHIji7ULc7Akx2wOiZWkg5FKCGCPqzxMfGAB1AeL4wCJrqVMfMedus1s1V7NpWNG5JxmiDRt5O2VKTTTDAYA4+yeSQjaBvxctkv3BwaPkpAKP3IEC+/azuzyYFBEquMtO7wBwsIIDq7/CIkrsevhC9lKlNoFdtYEij5An+zsmCFtA43JyqtthZzVT5MoMlXxNYwACN5Ie0KOUEhoLaAFsLbiZaXy9GZeF4uczOUbFWzGfBp5wPf6yBTwDJmIOSAntMYfVAPvEH6+dQu3t3JE1zxmpb/wnHRPbMDJpqmXKcShFIi53rrjRrGK4CFdGaPyFK9H4hXVzqzVqL07XpiQSkbejaPNUigaR0Ptce5NtzrEgQVbE1PC068+w+5VpTDFJcov/9PAsptBEkGbIFz+rhHu/ir3iYzSF9JCmU06Bc2ocqbYVOocsTK2/LlrrT1KSyZIyzeREfoSVc8orO57WahJ6+1b2tcgcEscgQbok5gr+F/6ND3QcsJsrYXxQmlmlgSLwFkqE3I7f91dWXEIO/3sJ1I6vyKpcBThxdYHV3CCFYUI9gpY+jZRXIXEacRbZiCuwPa3TniqpzxcJ+4jV6D7/Hxz2PGG7YrrW3+n29dE4jNmoY9nJj54eeTRrXV9ckykPuibFXHRf+iFMdR+QPaWYnLTFPrgSS3Guk1KaM51djjMGUbKNvwyHwHYDsyHHElr7MtXpBJU9xVgvCY0bUl5xr6Vg7MMnELv3xpRhM+oComhr31vOrMJZf7IjasmW1Tl6RqsecCD9W5PzykttF6/QwDUWh6Od/14U/8C1pq7FRfCvWxt7b7+bIh5ZHAbQT6qDouxAc5pXtniP3cDzxUeU7cNrjQ20LIeSn+DZg1PrZXCH/j3jYobVwdMh4LaQOY0ifIU0ROcbWIsmZONxhs3JHI2XKSQxyuf3afSj4Gvo5zKmKQCqlHCL2oyMJyEE+uL79lMUn1AbbNP2MB60dshIDaIH4ZReQeeNrWrKWkU8HezjWduGkWaf3R7itPy0sYgJnmy9qrEyhNFQps/SB8ItpJU41BiKgZEOZkFuoLtQihb/v53ZH2JE+03jpZY88v5vvBB3ppPDtwhqbYcZmIN4X+VQl3p3ea1wOZj2cXKwFWxwtqdv/B0MAD4kyCYueq8rR/yLbJZAuMKWdmVnviygWrPnLnmElUnlvDdWLbrhNSGcFAU2axZV1lwaV138UmTMss1KLJKWdAGjmRDF+IzOIp/4oq+Rg/HI/wMYkeUMkq8lfUMp925vbk4+C/6IjHOhGKd6pmXbA0ihf2QP97NhC2zgXxl/JGooH1LAXajo2SoTan/tTbucjomx4JtD3Jlh7iT+38Yg0ga5DX68L/0TtgIfXlWCi2yrQ4/3oZfu/I0Udc20UO+Oza9QT/jO9Nj9e2qTeeKK02kl2SZXhN2JKoyAYPtoxVSbE5IAGxr3qxBTKRVHCLHYpfi1sdr+vRoqDPi99RPA/2NPBDkODuqnsxMKFEHnx9jNlPXJBJLG8zYB6CJbG467OBXuv9kClzTAO3EiVC0F3h8DGS5MWE5EylM9rlfMnxIpjZ4fbn5dXl2FhMiQ8d+oWDbUpQ+nHPVACqZpQA+bO4L6zSlCO/FMT08etaWCOnu96YBnc3pcNS90EJdkqAJBbOaa5mwraqdTxbhUAkwwuT+fV2LcYIKXlsqSxKDnqZUnPosrKcplikaVwuVVZBlzuh0WfrlER8bMzhTsb6YHOAHmQ+hPmBJtSVMxZzXIUy4H2i18t2x2ZlfUUi/qG39hcMupoIoBgpwjFilXMoXjg28tB6L5Iay4PrH/toADVpo7xQAH7U6zc5lTPz4pWPQ0q94xI3qCT5A4Fy5BAoOqZNfu2jJwti5C9folbxgrJ2VUVHs+9vBjGyQhRWMWneyHzcmEEDF5Ut5boHPWmZQoNRGXSvpTrblVxOgzGKU/6q8SXwE+1sp1+dklZFkvjayhCcXqYkwDhHhAUtjA+s3y9XuID7MWchtLJgGhFfisYwPj+1it8nVEdpz0PXFjY860boIUDND0ioITesWyX2bL2TjRLWSoxdk2M5ZRNsLBummX7dvqLcAqo95TBafoF8/IAIQHDQhkj3ept6CFiT/MpPjIAQANsWktbwE8u2PjSwSMjEVxAON4GEY+WAH7Aso6JqG9zzTN7Xh9o9i7U+IKcjNIw2GUW3GqoSSbyoTGrGarYdUR5OFHIPWpyEp7Lik890AfdkyYGCVWITwvJ+Nr47/KPecOU+lkcfIrAsOf6P2euhnDAhXLv0dRFXJDr9IrzRlXaYaImv2qMcAIEDOUjt7wgkEZ6ywX75uTn7T1B+jM0rl8k5zQMj/m2V87tCD1v8rhn0N4BNxuZp47m2hlNb4FMFQ5KVHoIAkq5WQPsnVEsaCkyjYS/3wZuPk9+LzQb2FPahZ+RLh4T60pA+X5WjRI8R898/PIziLL8wWz8FDh0XfzKMmqIEcz2BWkCCpwAQUJc+CCtXGtS0JG7RihrxDS1QE/DezacpELIV2LYXMEnFY+PVg3hBXG756D667Cxjsv4TdRYf5ojqvD/y3eXkDcSJ4mB+ZrlBf72zRB7AycGGBrppzJ1CYwXdc2LTcqIa1g5ak7dZGnPzW6DSgBx9izQnmJctCSy+pbzLLA2NOhOkQwR+0nGpg1USqP1IiLyFjnRF6T3sOleJSZ7qFXs16/9fb65H/4HalOKHqu3gVi08tSR2zJXTtZUHdbYJ4E4P/wE2/oiXOEwpvsnf4AXWpomlczj87uUQoDsQPVsVlfk9AEFeY00cdSklHGlUZuYjlxoGAQ7cW7lZrUvAvbtGjeP6baOgwjMRPDwOx4gJ6LkKXWAI4QYAgVgdAAtq8IP2dOJ2S/xm+tjEXJugCmC0w6uD+Y8nEGoBOTUo51zUaISqhl5vML8OsxmielC7MaarUpGkDypOw+FKw3Dk5AzqqHP/6AUupoo+SrbrbxEsB2NaXVUtpXY9Lq41KMAy+6dv1zaPI3jCdCbggvbnTPewn9lRJ0PTHP9vfHafyTSyZP8zPy+tteCyb4JAnUpeJZ/jwf/Ez0ht1ZOC5tODa/Vw79bbENPwTs1dCpwjMcMypbxJWipeFfR5vlKNctJRg/nOgk1sQDewiJW01P62tar8i56Nv+10NhbAqoeGh21Pgz8yAD99U8sAbet1hgCQNj3mcGEJd9U/OQD3fwtKNK+gRw5/o4R1DnlQzlzZi+SpNWAGUYLkomffFT1p8Eg5vtiwF36Z6p8cuSksqAfou3PiuZsgusnkeOHl2sMYu3eN3oftpin6pIooiu5ELggbvSd7J3oDtbIWGWg6pPgzHkOLQARrNWTj3/c3guQ4MGVRjieHNaoSl/ih5QA40tSH6fjyAlYWBhvCZ06rC2MYe6bIF1fIPgF1JLOXhk8YW7wz3H945ErEVKhptI71xT+I2/fych+AnmDrZMzSwdbuAEzTCYmgbe8vWCt0CPYYPOeWLtGqZ7gsntduAM0sPzt+vJhbu/zNd8pyRFpBpqZcqOc/8qiQTIpa1DAIQ0Isgbk1dqy0myaxxp3AIFGdUdO2f/4Fe7U245XwF3tl2muVggMuIZwPs+rNmACsIEnFLv03zQMIaO1Ny1mUUIG+1vBtMJ1rHzeRiO0JX6rRi5bzu4i6714HtPCpL+rjLuHop19YDAxIm1zIH9USXxm01CuWZO00piuaRKZkfc2TRQP/+ouGLyOZzwfHcbBD3mLEVM4NmAlPA4w7TQ3xynILekJ0z6oCFE8YBzrnWphHlB5IArBymy0yhY+MN9AUe/0UGAb3wdZrilSLHsvNRgGK1u7kLLVzMRmUW2txOBJa27I6VgdKnmwqGgyykbMvlVMt1u9x8m9xhXtihvYjhqJHJA7kvwpx027zaZF263FYIGo1h6OAADnIt41ZEqQJIry2hjaY+pTPY3Uxf5mxH9AeuDy2QyIi8jo+Y2SFOnY2Gfu8WSNJIU8VOcKtkd/NGd5PzfS13HoAI6EQTcrM25sjdL2TgEQm24F5xfb5iwS5zduXXtvTt3OedAKYIt1UqD3QJ5R+H0gKjzzpo92NX1k4Gs0D89QcVPDFFuU8HfRT6fyDattb03YRE7sRsdmsog88xw2s5XnhI2JlP8IuiJeTFeAD+PNkMcIPi2IKtkfL313Qj7m2P25x9vVFJIY4RjpqbRXmjcMaxHX5oVqblzQnYTSsDAG37u1tZd4DvdUz73sI4hXOvBgzwM9wtbpRcBUkCD7sZSZwE1KAHOYMorUIJrJ9UhJq5nr+0gf/XVKJ/PFBRvECXUaEi7dv2n9k9eHDhe+Ek7PhIeZNKvhezVGxcFCXJ9TX14MEBlF8xD0OKfwTri0FPZdJ8qkImINc1XzPGx0N90bGet683ZSg3J5iG8VRHV4/+QT8evrYW8b5SepipuEgwD4WuLkTEBpmkU/1zgu5J9ieK/1Fs/AQ2511yqbpfnLUc30mbz6NB6ixd2zJGow+kIeCgsuRocgvdu5FaIqNXnoLLRWvRBSwKEshZD5fQxT7wP5AjMcEbyhIf1d3U6i9lnWes/rfGQ5GOGxudvqI8zeP2a6zsXlYgwhDITeBbpc4lZB6+MxQwztYBDfLN5ESRzJw56QjZ6bElSkPP7bAFl2RmIt51B9+7yY5h0RQ1Lplze0fCf/Ii4rIag1WnSQxv80iKMVG5aYjktIOBHeXPxM68rn6HfHEs/5tMqv3C3ZApWBqL2/hckqLrwsljvtYDI38qyq4nQ9dWgGSYVmBHRW2Mh1wKz/aE5fHmToPyzToBUXKjj9xM34RwqwmgobjQXfPKUHlDMiq2+W72yg0df5AB/bYIs4m022+ajZeF7c60OdlfZag9OE0rR/A/2t1DtpZYeZ6NB8jDMx51Tpf+3scEcM9SeNQWx9McRCtGCgj2iXwMeh6Gsluy50v7amGTg5wRtWgFM1cfvohu4HQQJMfrDZXgvngwy2FiC4yzfVzVXLjxzDCukx0sK+Cwl2o12Cc5vmsGflw0K4GVYL7f0tcMvsVfps2JOOqKNbQnbyp6b+QdTI+Tmb+BN5rbHqWqLbAo9AjPltqFIjt/HL/okIZC9m59xVynMBEhQLeA7p8c72o2BKUbJ5eyHfz0bElTnagxAqjyUpGUUruibbD79X9n7rgLyfe8OBPLnWB+SHrVgNsIcx5vQQS6uAGzRcmJaUY9/IwgqwxmsgYcsECF8GBW6jrtDuZtiJM4fvxkBoLYmzby15HrmsrH8hsIjztkgRGr0HTbcV8+jMCIyfPeM+9MN8upEFxmU66fRIkWD++y+uR+LbevXl+nFiaPoC3S/yYK4lPjnhcVi19Y4tG7MPs6yS7eIwXWFFfc2msLUpsj+viVYQI8m3WWuFJE9olZRqfHEGUof7C3JyAf/w9UkKocqJBypClAS+gH4CxYLAFdzY+ZH5276tCr1WSuErxEi9D+QbnbRYFQZgPvsuD2Yaczg4H/Xd1QaCzFHTscT5jzawaCTkeBBDP2S8+tHnhdeoda3TQRwjd6F8ANeK81PFx/YEBVBjAvRueGnCa4rWYA/LAju9MYhAlyBtz27KaUcJ3tfESERbnXD5Edm9KFtL4oU53qZj0+1QR1CFtL3dcmW36AogRXBDFdG6xrgQe33IPXdt9RPQO4UP3Z6tlbEHraFImucxiQe3Am0qIuBpRnL8Fc7hXh7sPnEv227+WTkTBlYT+bjXSJi9ikMjPl73b7vszzIYwIZqQHYvWDJoI6tXWbW/HneCFc+5Z7FGZyOL8z9oB/sGswuglMhfb7Rt6rggzK1gZsNXfCaPSt/IFPhqGkJSwElr/lz3U3LEcBkznzgWNlU1JedUCEZLtM+2I3P9slyHD88dXkPi2+ZAkybziw96B1XMkCea5JjUtwztpYZPbrkN9Aft/BBtUGkmJs4d5q90Rqu8lNljjMbnBOxmvR4iai5OwY/AOCJqUOjQT+P7ROP6zJVl6CrHPhkwx5DaTshsoQ6QqKS1aLulCZ4n6hJNHaoue56rQPmz+h4LUc6dYMtNJLuoC62EPMCslLWJYrNNU1rxk8txM0fU5Nd6mPbLOoKzDOXXuLYMUIJOHZ/jRVeUspajdXn5+rG+XlaSyLTW9fixf3NvUwS/5ReY5yf3WVpkLtmprKZ+2QbrgdvN+JyHNdqHJ2fPV3wXgmHxwEu4n1By3lC5maF80SW76/BX1p532Jop+p9Cp8UtBNNwI3h2ZAEZz+MzdxzS6/KNbMgjcpdrUi3bV3bvAv+rSmyD2Uj3LgOSLUEAbWPPqFNEyRzkdeO8Npxq4xsXHgOzmukVWBb9wgVs3GxN3otoylhNZLjxxnBRU+CHNMWNFbZvFmZS0/EHzhSpjWXC0pqpR4z9x7wasJGUMwS5pXQZ+6i0Pf3yNhmh6qyx+3o428h4lvWPF4bDLFGqcFKsp8ybnYqlR5VC5hTw6+Qn+R7UWKio0C6JIKwiUVKUA3zIeEls3UZaooQeIwNmScRyOclv7KF/4GNnaYLuIbwvJSh92q2ENOd7mvqNMfNEDkk48lFjD6Iizaw9pY0rJXB+manp2NeOkQ6yXL0fk8PLxVf5Tr1oVGWKP6sxMm699igWsf87SsNOf59J4KLCfYMfUXq4So2djp3frD0A+VxTseSUiuOekOJw1Z/G3RBkhEsR5A5szsV2UzneDjQT6nZByDnumM39A54LcCRIbHPGWgOECIp3kSBuyXUch1Dde7vlCFaHZMYQcKjjltpdoM+hAtSUSup8zfNEiqj5u3tChfnrH4DWN2BPLnu6PqVk/ijcRhiNRQRPRtS+mGpbFBjX7CQlzlT/JPdj6N7Me0FtCuHlq/lZAGT8HaFIhjXso8mbshXqecgtvai27UwVrVy3N5rv0h1z1HukJPtjhLaiUPKPLQ4KeoxKXNLs2FkDn1VFNmAWC56JYBWinrh/OBVmto/u0XSB5jPO7e1xlPQo+Le0zoe+Nfhi9bofBdrBJjyOJcTyE3T3c02AdR2HZGqDf0QN+3WMgqKly9hctNtoNiI+0/EMyKDGoOolf3pEc4oQA5kWPxeIm4/Ognk5CJr2hHpP7UnqdARjOV+WRvU5/wgUKpexoOVXWVRJqFo8gqtRC85JCVtd8HU7W2BiCIdG+0pNrVEs2MI7k6pzW9+Zfa7IOSrKuoNCsnx7OV2X7iTfxVTHhEOz27M76rHnaltXzezo0d/Opt7QEULxmSBfIHUzBVrc3SNtLn9OCvVyGymxjOBLp3yVFHytme7I7ouuWmo4enHEQeo0JYv8zfWVUNuZotRjZCPWMFl8oEwC2hfGgyAPH3CucmA7Py9HwgHdHN52LcIgRelrTwsOHtnJ5xaQuTE6qevj/nJUqzl0RomU24nWACJGjrzKT1FH9V9o/ijoUs+Xu0Yav/x2rKnF8909vp87m58zVbBhTfb1C7mcVBLliQzpaE184ddoDTdS3/fnxVQ294CxJKD3HJ6eOMfa2hnT9jnzMoHa9ThFAx+dvOpb3p0vUe/vO0bq+hzwi106eFPHkijo++pQqCqm3yUDQGhw8KLoukJzvCqArAmlrXdRlI2HMUAPGYrd+gzy6XOA0Mck6TOkmB23Yn9cTDgtIMbPAZluoLvDFm6FsNsWM9dkOCCnhbfkqXL0czSmlw2BvV+QdHKP2QPtdCSx85LBzSfBH683fvYd8rDtunnCxSoRUsVYdHI39wjX4gZ9aYAuJIgm1uyyRCoFFLbmvCr+ZrZ1MG+iImKLgZkBraseyXEAkSTcNX7+fKxufrOfFtt8Zh1/kMJw1FXSgCQrRxzcaISJoZ+MoSBHH3qipAzQhlovjhBN1aueoHA5GxRxfAKlZCkMlihRuJeeh1NDfs0IZeczBGfkOQPCYkakEG0weNNrAE+zKW5HBp93jVBIshM1JPOtJTYU5YX8AzprlJAPaQjF5sPpbCjwQBIqR7DLTZT9TxebT4rHWp2XXUdsMv7lsgWS2jm7RWkOT/KhgDCqheq53hlvfCvx5wuzJH7yRQfRcL5TX7dUjTqQZTz9JKLOvFlEpgf0SLOZHu51YVPoLuDLCzsFSkB6kq6Q4P4so3SqKagSdqgNH0xfqo8dC6ifxKta2s5Lzwcp9jQPpIwdLry30Z1FnW7UdgR4tP/WL0HGO+U1QcDQL9HBr+COwa3BOJl2T8Tq/ekxqDdek/G0c7PfzyVd0QdIMh8bCmvH0Zaym8lwPa/0L5/ZjlANBJC/8xnH/O+HmzrlfrcCiDdyWtqhJYSukxk9JyuzMx8jRVp0CA7PbNIbatu9oM2642xMuW85CMq+AAs62GYFPAVfkqdSXpCfRCAmVF+/rm1k0dpSLmyRABoxh++ihpK7KYUv7yYZRXC/8TcuOvCX7cdUifCV4AKr1PrZp+dh8eYT5yzI+U7zhFCKOXIcQke6x2xZJ4BzLwbLqyeUpINheeKqt7Us4QgpaMMqo6cB4uuf8onmtreFc9CRHKHwJRHAq9m7b+6ZZG7ykR11g2l4Kbogw1S8M8mHzIAQWdcgC0bbn1VYCcpNacPyfaTZv+ueim+zNxNSp5mxdhyo1eSA6JID7G2HijsESslSeDgQ1IozBg1XYnmqhaAzRS1R88vsZ+woCDFQt2d5fWiRCbhPyJ3J9xOm0mZ8TOHWH+rkRR+0bh44dJRfT73rctkTJRq4/R17KIx8jlNIppOPWANGrqv/WuF3d36nYgDyHnjWiiuLkul+CHO+TPlfTMfoIdhE9bWBOQgm3t30lInUsgY/F05WGzoc+uMsxH65F/rv2EKTJD4mMna9OkO2YQEOl+IDNrZnJxmZ666VZCZeefFGPG5IJEiMMiWqiUziXh3LaVlp7rZCfz7lYkfe1iYLOoW6xPKqlfD//02bgRcg2vdU6d1XVWdR5xMFYaj8j7c+CyAUV291TH6zZxpZINcdrf0UFan3rDTZsndgM0SqhppE8owqaKg6/rlWMzb7sUGG3qSnYy2+l6da2JmHzh+E2Z8W2cHDqql5yZ8+ZIapGcYLEtAvLDX2JFDMYGNVGltPWvvG+e/8IKQc05VH/9KeTRns3GIxBHkkZX+IjSJvsqOkeFJleTBTZ9Hd9dX7rWMT0aA6ob/EAsMxLW3v30nrKzAyOlXPgpOVHxgzv/e5nwJwPgH0i8HNr2g1LCbJ3/5ZhaAJE5naWGZ/DSVFYiAtI1VkRBKwYn/Ggx0IAmtDuMlWWWRx9EhJMS28zC4YoQZXAJ6WELR/uCg0gjGJ3pK3HGVfMprhdk1nZNy8XrgP3mDsaSXvUMc/oooWIL5eafs7RBra5+ztMq/qZaaKYQoBi9XZIoNIFBBO3+l6wOy4J5Wp3UpiqVYaaRvzjiLm1BmI4Mrq7qZ4ffOzMYXDTQSrQmKGyCVeWjvDSROXenqPK1YsksW4nhWHdPQTTE1gGPc/UHdR5gK2DvJZqbX/ogcT1mKaYTo+1cDxjqoGj/FzcxIcKlHt/HJBRBqmfPstXJTaHq6J84WrjrwrT5kCCV7mpl0tQ4BdpKswfMt4OssKLMnMvb1SLqTQ16dBmNi5DyR+CS/C08HfICQHSc2X144bzAMXxABK1c3ANmYWDbpB+fgIcVNhBn2JRucE5/hkut2gxUpjouDX+YZ6Qeh2gm1CBfoWPQ27GUkPlsI/uqHCpOQIoKJADW6FLl8fDTaZ1ytiXo76hlwnzunEX/Behi3nSlA2e+AsrvUJvEiyFOAWB60aWqMBz4RQHVzvyQVc3P5EcrtIjcpis1GoAQ7t4WJEC1wuIF29iY7FVdGxkRklxFv6SOFP1TXtPZ/qz56XC5wC2yx+uowqBwfuFr/ipaMprQc3+2YlNfhQ9lL4WK+KC6iBSKua5pyTTkoQEsh2egGoqRkz0lg9qWyfmtf5vv4iG1INWPoa82VH5njl78gYMnJKhOphXLe5craH2rzM/Y10ajZ4Hub9EVPhmcHID4pfihYSHHoP5oFFxmXf4k/5RrM58kbMffpSQNxYkDP4MBodA0ydvJ11zb4XaU7i9yVVxGHl7GYm4JSjeWeDNcOELwYJZJsm7NyzHXrnvbyum6oRF9PlkW92vCTF9OK1AdHHeaSOrS1nGSXPTw62kW2rwFxlQDa7H4lpWI7hKPk89HJQkYUfMJSX4vzfYRVtLTscD2jR6xw9NiHrMEQoLpXtyrOOPJ468VlOLImIWW0MftYELhCPgh5imuUEJVNXITtUC+d6zWBIEMbYBT0AJEPrWf/+xoO0eaX3Uicy+Zc6fha7nvYCXSbb386WwHp4TtdbiMhBYAresLD8/A63khL7gZHyN48ZIcWm5IOHP6BbQJQLF/DtOaMOuy6q8uwCJXBy4RuZjAH2uoDfu63POxGCUU6L0kS3UIi+7uqhK5QAMiMXdjsbpJf1h0otK3kLhqpZPWEPRJFs43BYJ5LDrfBYNXImT1e/lRypFSX4AzOnoXzDYdf5o0ewxO7Bk05BIgoERszEUMC7BrZzygwPEF0LZvsIIVe1DvLKSOs+bGx9U6D5LeCBURgjdXMmJ31oppk6feqHisyIT9j8zzfIpT/JBfHM2/0WRq5FBOmiGrQ95HIa89f0PQcw3z5vvGPfD8O2kAkwyRuTG5ntCrPQjLwJwEr4HDNHjWZRXu1sAXGAOKqtdKAtxFPJOnVaSBk6S8o9vdQwN00NmP1Sfp8fZbYSYBUUi60UaV6zfoviOZd+DdR0MIFj5PONXCIKiA+41NBkuyKFQX4UIPgYDE/ekDaQ/KQ5rs17nk3ChLO7ww/6YkBO4Qrrud5KoK2g6CvZ7PCCIL2A1gqRVZ59SYnyYfWWUNnO0WW7OWle0/5lR8h20MkIQngrQ+E3JkT9buf2UdWjaGXpW9aYSJZz3UjNZ8x1RD8pf2IcQVeXMM2tSGKJr5v8q4UAAWXE1KtNRBpVFF1o9IbUCry0DL+k4xYSWTzjOVfdIBwHv3RdtUvfqXMGgVIGoFG9ePdQCt2K9Mp3QE4rXwP896kfX8FcXxIFVLd7w2hvckQVFTHJpjqTYpi6NczEETGzJJ6uoencE6f+XrzBiOg3LJHyH8AVgFk95cQQuCZc/AIGV7V1pPDmqCRog5bKi4qJVqOvbbR9UxHR2bexyWj896ZCfmfuzeBsrqmknmUjPvGkjojbDgtFcN65m7xfFrbt5puFsEmDZAn6I3YfQImacKeY2cdNteA6Tv1tcCLTS9e8jcYCK9PT0n1Sy7m2DvKTClAILGqMUjiuLRdqMTAROg0lT/vAbvmTnIAVG7Fowa2Ir3hI+xl/m97ngyyemnEh/QvyyB36rYWHTe3UU42+caI5vgFkofoSAtTs3mpDoYzoVLGCuhe8nxA3P6RqRo4wl0wQrhMu2uFW77/r+96vejv5NHMJBnLjSMpzyXRurmcFqIn6DbK6OhEePYUzl8LLTQWIsKSA8jACmdN6ZcpR79IC2STXOV3F+xYBFcA0DkekuIWESwHHeV2tchXT8VJCx8YlALcQ2C8qdOBOr9eEdyCyK1TtAhFgT39M7sNgXummqqVC6MJOFMEXcgAqrh/5RMKsfRpBBB1ZtNr+z1/0sU/PcDM3HhM5ATutB6OidYM/dAIJ8pDZsnqNCFeS8kKWlys/8fsVotxkqtdWuGcFF8wA/KAJOD+NTqEo8mVIYZ8yZjrbl31tCdFiu4k3XhPEFuMHyg5u2qbXe/bBu85tTyUxiXb/jJwA4yn2fKaSX75FhTJ3eqDU3Z9JLBjON/vKgSKxAIGZoWR2Um/d3821LkmbD4vzl9ymfXSeeSxzHxJurxBtyNWN2aHvvk2VTLIcmgOX0aZKpP6VHz86kUnu0ePBmcHeUFjHMlwhSjXlUAHutj0eKIlqNgWh2jRIYcEl4DrXkEzPHcg1NInvM/5JgiNxKdUmYgIWGGaZEQNEIvU80yPPoIkagZeb7F6H881wsOaj48vSeYjMIYJBdbxmo39Eao4uveTYceaGenbXwtBvTGKUsFTrqBLyh7HSxxlzuDQnGyEJzavYbnvEh22Nl75qqmgCuAsD2IULm8K+WMLhqUiBR4EVhRMjE1YH5ILYVm0vm58b54+rb1sWqOZbc9EqB5x3qhwi0taNcXJPyneNYUbocmP6XNVAk+awSA1Vwck9cUKr3Vvux7fBGgE5YxvEqjiOieX2qzwPUoUP9kOz9xiNljfIPXIvyQ7yyNWiZbI24GY6/P+BOoN1u2jf4rUeR4vSw3M5CZTjBxhKtEUsr0AEEyXI/t0tWViZLOYhdfUJ4bPH+BHCqCbGGIyAEnTLQZY5UBEqsMTDN7WGIQEBrtHr2g+RTyUJTLiXqkg7pI69dRr1s+LWpeuJQnNWzgiAli+XVwmjVB/HWCpWXN8zfp/ZcHpQ3q/zp4W5gmL8wotE29CRl/DEFs3m8Y63s497E34mJQm+trpbWPUy8vFJoIow/MOJBH5Gz46wOYWWOjt/3e4RVUZCtRttLmQROFmektQU4cCiCA4DJucPqU0uBd1LN1GzGhzlQ3vzwnU3Ww7oRjO5TfNGAt763LS95/dlQhHJruoLJVfBF43g9+KHRq21VHZKvze2eBPCdXRUD9U4T3KOGHZiJXbEIwva9oRzhVC5vVo/FQn1U75GZbgaMV41OSc3D3qVjMEUF5h5leg0JXcthk7qIfo38ctRY7Nl2TsJWeTWIbvzDBv//8yLWF4mFciw7P3ieJdLnmjtPcevdStEoX9Q8D4s9VAMZo0o/SDc2Zi+Hy7gtMaStKhHSWq9MquF6yU6Jw2DRHp5BfhY8emMwilt5WAuGyq045xhcYwXhA9Z5W9QCdbGYMnxMJf09+Ym3GMf//O0lNFzulAQ+dMsJvPZ7/MZH2qn34jwjbCvULdS6dsQgXZRU+nxOJHGRLQHEvdHY+jLuaOAhpieiSC/Yn9bcYK4IQthMHWlY+AbBTx66oDI7eOfI9HQHW25YBc+AwwEYAKfmnGfxPAdXZBwac2uOApkOKgvKdBphTPQR48gh/A0UnLrRHAb1LiGYsUmh45nWYRpbHCk3p9mBS44vFSUsqp7OXETOSxIg82BbHYcetLFGelZs/486ffjclf0e2ZqVBvQqYqd8odV2czHu1KZIpxCOOr4K8A3Wfy4TKuMiaYKeMdWLBx2jb0ATuLlVWtsHq8HXJT+lakBtHUgGkF5bPdMR/Oi6NPHM4M4OchYK/oSE01Aio2Q1gkpNm2UVx4/a6Jef0zsH2BfUO2tBJNu5UtGPOLVi1y/B5XgJDEYCKwU5S2/jeRElxqKRhoMlraYJGleyS9IF5d78SCkSlQ5zllz4H1dHHpTNLYUv0/Yc7/iYKMx/aQ+w4hipOkwqRt3FN3Ntp64D0Na6aPp+lX1hjrzoU6nTpUI0K7nUMMwiJkxcChpIr3xzBArjSLs7z5hHQecNDKM5cnEBktKHV/LB2gwKRLp2uXHHsmnOa0dZ6KxXzueYw/rKFYAoqxK9suqtt2J7TrAqLLzOEpI2hZw+Xj7dYlHy0uw9orbv5I7Wrp/4hU2f4Eoe4pqxMuouEvpRbxUuA7llUKGI3NQI8oQ6pC73RRkOWCNseQZXGDSZeu+d5ByI7vio1Bkqg+OUXZhVqfw7ke2Yg5l2OARyoBH9oKr4hvq5hxUlU1z5q4Y7xHT8C8cDtc3nGuoUyQcGxM64ZDTyzdgHsz70M2wi7WRSKnPLCaeZQdoJn3sBsjWTYOogj5GqUSWmGNWIbttd+Qx6jFjQO8S5R+VR9TfsXmc5eCaWGRP6uyliw+0QW20zyjcv3HDk/VDAfrgmpjhHtZnrMQ/v+I6BTHgmqlbG/RgmMooqKnfNRYXDCdlzRmCCTG7vzGkkmDzHFraFMZzHxh4idP9FtQPdC/P18I3mAZfRFw3roGp0j8CZnojrznx9qSUjIWFVgA8WG8qnMrRn09bel/eLjc7It0viUskEiuSpK9oEElwwznCe8AJNt4Snj9opWljPSCuePtoLY6y0Pdq0ILGuWN/fo6SYdyYvYgHlDS9KGC9xa6X3vbBsAEbvIuMcaA34nM79Lx78/BfVxdLu0sFkmlCZjnJ0pRNIr9dTnxxd0TM4p0Pz5OvYb4lirMkihueTw5BkAcjHYqZXOYmk80/zjV7cibyHU4dOYDjJ2qbm8eVu/tIegUZCwlUi2fVFhOaiRmi0Mg8C301RxVc9V2n7YsO9UiLMthTu12yetlx3Dcx/3R1+xwsTHqy3EyQKGj60JaJMuF18NU1GdXDQEECi109Hxe020w1wrBBk0v1DOMWRq0DUD+Wc5PxQS7IVBSZlmAcA3IJmi5V7+ZN2obfHM7M/AA1bOtg+775m3c2UWA8u1U1VbANgDX+HJHz48t/VE+E2JArEngA919m/5wltnwCXbOx/u7d+gQRP5NAuPNu0HMnknLiNXvFxYQqpgm1AcnBhaNluqjtB818dNTSDqhmtWG7uucjw+SkhRL5SN4fcQcMIAAyri93A4dZMiV5TAawjsBJWi0Y/BwoNcrxr+HkF66PIpUx2z91YOjkIokuRcDDdoM4T9hR69ZBYFeh7yhZ6TJnPNhtsORyWp4wztZRbLw3E8i+O/QEd8mVTTHKGXS1+NtxsV5pA/4oVQTuysFY1zHY+bvCJ+Thz1MGCELiweHpjS0rQO1/TdoncuXCRUEi4W+1lpkKJyItNrAIT+5lJuXnx2uXOOLNCi7t2OLaG5h1XbJOF5NXAaNlhbGUHaAljI5u9JAevbU6j6oLSJ1jWcmHe7JdxA+9RCMRUmKhdAjO3ZaghtIP13MMI+GNgCTosLfv7EPggZ9svF3c9WsnL4/sax30LlDl3qnFS1rTjwpB/Gk01vv/FYdCh6lLDSONbap+CVTke+1VYsJH0V/uyAdYZTAWuFduWjCnIFFvdp9AbNpg4HPpVLVP9roNDphv56GVrmHTzzkxfipQTDRiRqvNmIvyszKws6w+WHvOAieKIRdSkK9a5jjuXZ+GgIT32AIyipO1XBIZe+NkqwRl6iRyxAfEGkj2uiUQAFRvNnlcXMO9DV68qSez+yJR9Pu7m6FJn1EdIS4qb42nNtSv/kSxOZ44jkBOfekMZdunCXNfVXD1a1MSh2iUZl0+ndBj5uQI5uxVxJTCw1wt46F4RqIcCv4mXfTiF4VNESmMUQPNrsBVpGFjNJnkBIpuvl1chdbQCUMQ/WvbIyJuKlj0uKG0Woc1oQtDLhP7xnweySvc1wReeaJHXSuXA8JZ4tfmqYH5gcegklqga9Yu6KmMXCRFbQvJOkh1PZTuYKYUBPdKtD5fZ2yweUw/EFcQrlFbNjTzJVDnu3M5lynSsC7c7qN58+Xg8ooTPsbVffnAs7IFTBB08+fT+u3p1uG3fpSzDo1jUiUhEUeXme2chTxVwETQQBd24mpkav+9j/Yl+TxAXXpgRuscO4IP1BFsjYF7HEx9YA4WrjwRSGBwG+QWIbal/2fBx4QhQ5rRiAaD0esxH0fNtnI0hvL8X4KGtvlLokkJIKoct3MzJCnd2FdLjVsKTM7SMcAZlD0vbLaQRH4InwghpSmfS9woTZOHv55t6dkhgcUaIE7yUIhXv1W0Ifpj/K0tvHVa2xi26UXao/7SXQn8JXPqqQa+w19+mAMGumimqBuTgc7DPY21ShtHNB9PyOjHgkubGed418bPNnYuPR3jmDuIjaVznDvxFvOEvuPlWpl65BMFKrRo6/bdu2yk+mXhz9YNM/92CEDYGOo/bYB+ohPjOqIps0NQkfANIEEkFGvM0l3FnCm7AM+/o2IElaNyUofZJzIuq0q6Y40i20p6aPsXPyjaYCnCPHh/yG6VufDOuXaNImdFQM5r17bhiV33K9OMqxfkvXgyCNt8LfZ1c/5OtJYhCPN/sH6jAFxN3im5p8FT3BCDkamoTk7RaJeoGry6Q8td/KX6DsSj1STA0Nfjx6QwCf/BYSy9k4oiJeuCj03gIrYHJ0TEXI2H2Nd4dLhltH1mW+5YwfPn/F8j1WYyzMVzSi7Nu+/bXFbXTUliI76MDiPlabgCQDReC8Vlmk270cfdJdeyOjzN9ICkS4xGOdYU+a5q9LN5iW0vBu2nFrYqNDzcp1MVddRbg+L9yvqx7tzOjj54iBSC5j7wa+S/O/BiIhvw7m6KPe+/qLAcrzSNKwEsfS3SaBDN9gh16cPpN61I253cVW7sqG+ATrBLOJV6tVFvggPLLUH6KixrTNVbT9CEqfn1XCn617xJmP6zWvLG9lNlaJqCQrDPat2KXFsGRurcGFL0JZ0B1srnHX02fHz7MjomK0gkohc3X31Vne/GyOXVDhiqaDK0HUUysZBPdz4F5iQDD6XT6UDb1daZwJBjlOcTQiqFKvj1FBmcrp0A8MdulnoR6FTCMho3RY+JYuFnBXY9LDuAAR2wzxqfxG1+mwfu3xs70aCUtODtyvEGuh596yPjCKyEN3Q2cFP+cK5DKD0h2ubm99nIXsquflZfvAxi6dHRLnAV/E5S+tJE7m33TNHnJCDnHim5ZrM2k3opyWU9zVCs96Mazvpe0ZU/RzWkENuq0btoBRSJJbEe86vzJfzw2YIW1VVdZ22jK0GDOi5cbu9Vl2rzgQZrla3VChMht5rqTdN/aSuh//PAbmXZs50QK+N2oW4jM86AShuWPKExSQapZ/s6u4A4+CayZMl6CsozF8UC1tzVejETmahmMgd9d1duJrNf+0HmZWHqJUMxPcIT/MkTyVP7r4ukSPKu77D9TzYY/MwLu9XcrqJWLsL1Dy3Ni9kcoI10gpzqaEBGQsOdC1NyINKC0nSsGwwtNZPx8fVg+aMTYoXquBt6z5GAczhDuBceX29WSuDgPqVhyy8rj4+kR4pAhy8IgMjBk38bHd2r5GXunAjtOVH2T9AUy5LcYZHg/R39MZxBGbTkb7qJRQFhKZI47LahOs5RNniQJcxNtF0+bktRzr2JrgBBlneYg5JBn/H5xaSK1tLeb6RFzbizF0a8Bj464N+0FBLzCCUVCvoALWyo3NHEEzA39un3M7LC8Jj1WjIKesw71jhTUGgOK4xJMEq/Jr1RNDA2N2Ht/DoNPHwxZ1yOF8IzlAlIg3usa1z5OIYjU6F6wQhNLgGGUuvLxxnivROONq1c4rqxAKVSplKko/Ka9DNb1cAmZqWefK12TRVrUKvcaAtFmqmlT6ERd63G0pM2WyVAoMGpUgl44NzpBIyZzE9ZGNk7TbyDr1QxVt/bvRXLX96HB72B05oqyfidA8mtm4JAXUixotqrbcwGloEvdRrwSs4EVxYl+iO7rDLhu566UNfPlmIG7vTpD/0N66tQrB7PUNMO9I5CK8pQk0W+21IiqKQnsLCpYl1qXhSMk/tbfNlOCDI/1GOdq+Y3rqLck9c4G88/o+UDXyDqROLq/9cuRwnDcMUUxKVFt0QdvYsOdIlkDmyJ4U1TDFguy8dTH65+55sWfHqJKDwjsjPa/mLUyak0MDUsY8FsGRNOev0uNBPm8fyX/bMZFILHGZnV8b/LxBmz2X1r2OzUKBFNxCta2L3FVMPlJQ5e1KXoDRPY+tE4yyvmJH1ifMifWR/qgK5HwS4J1JEFZ0LU7ubTWq1fwpaQnc3RRds7G7w2+vi0QL/xXTYq4WjGljZN0YPma9IY27TeBgOCBscwRkMjpE2BSYurE8JzZ4g1KEt6CcGEDF7BiosktJPaRvyCYyUh4iEedKYfXYKN0EDCvKOuzBtroxC7yWvsgHW5zVGqL0p0gMNSl0w9cITsBuu58C8HP20J+iFSXXkKc7v/ZlQr5cfYsv/Epqy8B3sYDs9DsKtue1WiBIEvq292icR8ALf1q892azNaNGlZTPrJKUXTfNvmUHZm6VQMTdyX2NUD4w8r4OGwEtWd0sdnLOawiuWcBvHHzuh4+uYCXRvUFFwJlNfbuWcshCOkhWlkQ6QDRQb/TwKY3wcQgSafmXcCI+0pWqRAWIQ/u2dlyfSh54zQsLi3JyXWm3fWYw0HfD3nwcMQuo9eOuT55qObWCo1Dq4b6i26cOLO40H2UybpMTMRxayh/vHRsmvZWYSUbd0XN2v70K0vRMk9ADAS1H40bJD1ef7EkcudX8Wm65FyRKS1M4Mc1ABLJhcMMXXpNnOMEKFonZ3+eqwd/4vwIx4e7AxHvqzFi5UHfcMek4CH0UV7nCcOWjpo7Nx+QtVCSOFSCn2ReWZOeF9aSlniLfIn/XOEdqb3NALhiI1MwWz6G+WEIpCGVNFuv3yIzFLGYKWBcr9Dw8LHQa6+YV6T3x/d2KYuuC4I/sP2W0mVx6WY1TN/JtcsEEORHPps8e6cNBzP677Uw2J8pdRvcRazSU+Bh9dgDANggKF90VHuOGeoeQrlJQcksBjL3ficrWu8tkM4wMycKRqdAVdHURoOHFUmhagBGD5qodoUN4oJXTVA+p7JVvquQzoGZZZvpDFGtYd+nOIbAjO0zEiqlQ1KFM7+jb2qhStZoZNqrKZJoZlIdjjt/ZMbb+mm2mbPdkpTTZGhAyz0tfnlopXzz7utMhvHBpQO7v/nb3zFJWnX6EzDVzEiNUnGbsi51Ypnqic5tpWKXE8A0fr2OgmWJ0XI+c5nRWNinAnr2Q6NyHlS7zuqjIFQsKuykaTFZJrhWcbDztDxUXEIi06A3PpYpwNKQ0oOmWDjsdnYaQKTaXur83EDe8lXbpxnLmWxr9Z/0yOr26j3lGYSGXzb9v8hzeH/chMny+k0h/rF3XSDopkOWJhayNFyB+HgnEtyhjKBU/UnRCo8bYJD0Gf+JQOmwavddbU9fel2zpWNcrNcJqCOhqI8EU5AKhy3IWi8Q7ZTMiL3B26Siz4/v/vNDuWWVlZjoMsSKcFJYupDDJfzb4vj0KR6bqjDfrYUvWGfGSTXGFqf5ioT94GIS1QHdtl0/Vz4QVJXJ+k9wMSrnAStwiXLpuWodRAZE5eiua2px7PMe/qlqP463nNwOAq34ECzgIoC8PxyvkhmplyxUUgCkNusw1HipKsxLpV+OieG2vDGk5mLgFM7IsARVYal0yoscc7EcxDPhLjF8Qj0yTPegEThjYnJrQIeDXgaw3rOeyMIj8JKhkCa6RB2vHYYsfQ+smM+zppTOxxtDShGKRjkk8fIFmWAObHYSypnnSNmMe9ZhoMFjoG9iFl4Bzt5kP+XzFbpVyTSO/8E5+kCB34b3IlF2pT2Xl5S7vxie7DTpwT4s6IZWHh5bUnjJdSvu9Tsm2jKl3UDZefvhjQZDWSOqpSYP5YFU3+5WYaMtr6IJJPr8n3jvA0I88aaeMHJWLFrrmfYIypw1i8PX/fu6SMV5Y4uFZw1d6GT50wN+26yHGsM+EJ4fJzJoSaSO5zjAi3ZFIGiQziozfq2Fg/gaGZCpvIcVCnGJlR+H/UFys8efXUqtoat3Z3vmBXhHJbG26kfC9mVtY7/0K3J2CMwwYtlohx2UE/bHUBAE5Qvnh3uIX3TJS4VD5/P1BT69raDG+VVsUhab/AntG1FFNC33HYLEaJgH9IK7A8+S6KOOLEtuBkIpEv+LDZNUDbfb6rBkDtY7JAEaYJ5/X4CcVjDBTNmvrbQqGPCAZ4PtEPH32/+RQUY5UnpMOyTlM6hTx5egWU0KhHxNrOgAnXti32VpKVN+N1HPSopAU+RVf4tXxk9BsZjpOJM1NlJP9FZgRCeKV9zXxNoCVxJYO7XehE0aTizQBkTIcjfnRIXb0tY4IK0dvg3QAUxkyZ2ewArR7Hh/73qRtGqzPcCtn/P0vPtvsjJx4pdziAc4D6bkrJH8T8DBvkriGOb6l15E06ELrixH3gh03Kai+RpklQp11P/UI7cFeoaLr51dr0RPSPdm5ZvFT9TpHUlye6cA4QF0B6L1/nITunGrJYmuIm36VmyeVBrv49XI/Y8EVkAOOFh0qBMUQvEqyLuhoUXVbQo20iKSr1p4n1dxpO1fQil8rdNjUhGT9y2qyaGW/iThCRtYEmHEgAaTCwaRtiGHjcklvC4Pop0fLD8s1AuvC/gErYbzTODkBulf24m8uc3rDGUMkiBBTlVzKUBCvDN+PC29dRrW4c8O/0nJD6P46VIIVkSDGY6jvqoVoBDzbz7zQfbEfWkFwZncHpBZOZYQNRWpHA1nYJcitVumC4dqBpuk1+P182MVolGrzO6heb6UDw9MaAo3go99N1R5FMrkKPL5NtHCT47uAH4MLYQzuJnNzJCQl/lP2F5AR+2Jp1LWouWGvKBIDk10n8JcGMwYg2V0LTLADMHeKLXpn+QrAutXE53sIKxHLaQOGRz0BFzgTWWjSlADMpRl9GppSFooaK/hHQexjwEgYsfcOz6+RzySghpJhmk/NUoTAaEK+GgvDrmx41lpl1itvOB6L/AhWQLpjO8yCtf7tceEfWz4rA69wjc01nUuNZYTgWGs8KdmIHY42+L7LI3LzWBan/+XrCTBpigQmqdnTmhdGcvympPGa196JnsyfLbCgyqmjT1V5k3rZblFdW2jn6TvJjMUvTieYfXcxqtbCjysus7xMfX6YQH72uDMajlQeMFE4OPzypMrfYqGmvwQt2K848u8D3ZGl2gRfS9FQiLyxx/PdNsh6haSQbdJHpWRZqbDBtjVGT5pjlZtJjYuqDXGslQhlYcqH2PpQaFWAoVWRRqy3pJ+RsRZBTIo9qIAc9bYFAi/fwKVxVX1AgddRT92RMFtJtQbv61Q3ALb8Hx0wLLlOywWHWiBgj9nuyWeCR0qhYrABx48yILTVMYj+BsUdtlAIytIBc3G37M5hqeROF1nmTVItE0oveKVqwlrNzO0hcsyGXIjRFGpJWxNSiRyDoV9pwfZ2s2VvVPF95tuy0rcjSVXCQatgKBBlIv1K+juOO51iakOK2ARULFQx+FDS9B1zQikf+q3QwwkMgjmvHYH8+i0kO79OGafTak9rexX8UQtCni+Ezc1WnLnVYBo/nUv5CrPoU4wmDJry4OX9mTm6CfG/G8FG8H16NMSLsfG2B0bx74L6WSjwracAiGqHCsLq8zIXDG2dmEdP15BoRVWBVAePwrD8AmV6OXc74HhiI9Qc1xlRRXxSGzR3LOSpVjhlX1EfKxoRwTkLQSdNamMvjoQr+7RZ/tnLDVDQ0IckiwSV1i+FMwblvW1SUWpO8IQqcz6qQM2/r68PJ8A+YAZzzSMfkP0uNvd9KQpnWZmsk1Ks8o5DEpBKGWuN6YRWiZBid+ieVhWy+M+l7OTbj6qTi5F4UjP9BD1wSa04m20KiaxvttXY4H2hEj0POLKFSK5klm1L2ytrdaBUxfUhrAzeZx3CGssKpMC6L+bP2pdqrTrHr+O4je6p+0p3lvv+KUwlmn6c+vetajA+nGL1vkefYhjwe5pSkXeyv0o4Tqj2NVdxxXOYj1q5ERJ4/j6T8bJR1952AMQpDVD3QvZAElksAFYVgDodZjcKdR4hk85N0WHRJtGCakwek0aoZpZi+uRQRK1FMxh/LTMrj8ePE8YdwmdQNV2yAig5dKkzxaDP8cxzSKlHCe0Rs++6ahKa9IVLju8EH7IOWgAKWZY8hOh4Qb5Cyn8W/9BC1HU6vMuqY7sk1bg6T/KiVNNJNuZ6FQ0cAWivnMPFPFfgZ6nUy8eCsMo4ix4M5i6WdEAL1qntl57n4RzUuX9J8oOhJafVe+m/cfcGn2l3Pyik0mJMnG+HHkb6OcISQWlrKlKDvDT65WnWh9FQV3H/DeXoHiEs5LUVgetBjkT8g8IujN/qQM7pnso6ha73VRu0kV1m2yNhPX7Or6YOstxBLM5YqZaavkXbpu3iH+DOVKHcfz5sXeDmRA8IhkMbEt/qv++fIWj8THYiMJ2n4+X5w9nJLJf1ZyPISwBJnmhw2y2JFE4fJ/MarnOHQcDEEh9R5QkHlW5FkjYJ3Q4mmYtaLw4tnPJ8PpnAT1m/Kt5FOK5JdzXAHkj+TW4AWgVKQL2o7OytIshgA1/56B4ZzAF/1MTNO3ebbWzqp8919/r/t4lmGVhVCZca6VvB5El/P7gkACG3B7iVJT6/mS/au6Z9JF0sm9bcYirAMkz4qm6B19Ycf/bFHlvNOAx+Ttr53dypG+dmIlR/WunMugx+szNDKzEEhzPlQ6gmCxHLdadCfOiEL5IiUpSnHgO5Q31vK/NVnaEpLW2XrD8xqq5fY9eLVW+VhHDzXKPI8hnUn9I3rZ48V1ilginr98L5sF6vom3qGV+2eCSxsKM0UQZzb6k93rNt9JakGsNP1VoPT11Ie+dqceQ1MVyN6T6XP9oxaYJRHxhEUJ92lHHlWR+hjiBuapAidsENpN+SA8uSxkyqVC7dE/VpaNvXXvTiuvWTpuZYMFIDMQn4JIV7Sc9E8FA/fTzowpHDQsALQMOIweFv0F2IivLahNndpxjI1n8B0F8mYKmB1M89Wg+vLa+LYqnBcGeZtUgQm46Kel+dJplXzpQ86srskMjcBPDCRhfda2wCh70k5G+aVhBvmD6SWIFmgg+nX/JbG+h9imj233aNWeKai+d1R4Vi0tTHRFrbi2GwtgQNmWDfXeBOeoliqFwm3wAaWlk0kkVZAX7jZMRxvjMtscH9bRkV8G03+OSQU2Bwb7aW63oedTEa7XMxsZg29lZIH7PqqTbOIY9jdCFtFhcbzRXN3s0j2jWJRR/3H3C+Jyd1eIT3z2ZdSsEC2AVI+HZgTaCN5Jvj7Rhk8BTn3cuOVr3EcKc4tz0SlW4i++8vSjzxm3grwCzULKxN4KIh1iPAd+rRXVI2UeDhxjRblb456/9FxGoNznz4gb4HlM2lCthXj0gU3ivquykbEqvpWIbXVqIl+qhWnT8wPZ3j/y7um1LgnU9wdkWF0b3YPqnI1/TXJGy4VS8868M6ER6aGhTTS8Um/Dirc+XU920qYW6Ky5a+iFyz9lrh6KEEDzInXq6x89VpwTP7Uk8CZqzjHKx4Q/Q7c7iqSXWYnqsQ0Z9/5/pnO3MIBadP7AKdUyMlrE73FoAZSxOomoX3aUP6sSnCqBJWfx3cxOuWtnBPfGun5iaHQjFxuO6DF4LfRYWUhAAz3wU5KiRFcnAorLyqfur512YykdnvLCNzdYFX05hAJWgjTXUl6N5ToYqoyrktvTHb2gY8cLlNWtmOo6zoN6kZ1rNA+BdIqGMfRrB7uubtRra21f0F9JGxvwaP6Dw1zThjtkpwETuHCMW722WUOuKcLmHuEjg3Q9Y35fAeCU+v7AqHp08to9oJ/4sg6Kr+vTuLgZJRju3tc70pT4BG6mU1JHYQW6AOJC1kRh3db96qSR6pXcpWETSSfimA/SvB9Qoyk0PY28gAvcKmE77qnvstXRUtHtwWmNTObNcwBIeu0LkawoZI2LvPCbL/NT2GcwPv+xqDmfR8nkUF56V0F+nfG8JcFR4U0fMYnvHa/hd8zOoo5F4cGdr1yJTjO27+r6gaVHSL+bTQOkeInZo7assDMnhMGiTIPL7X1MU9Enr9MXzVsHZlkbubhDRLArTdFzDIL5r8bXYIotAhZyV5PwN38D7ZiPxdavL3GR32FtyjHxy0R4xYvRSMzGmQFqJa2tJ0tSJ7CtT3t0wmu/cnnx6TOnppabv8112K8XihqkB0FfZa5jhVXysOHI7YFgIh5NO5JYEU7jFawdPPxpGtCQPTXB4dAkPaTKImF+utQnVdTpelQXoEt7PaO/XSVhJ4ayIsDLg19RrdYX8eaHF6bw32vTgjTq8WM14fQRTJjUf6ouO/7JC4Mq9gMBXyVhbdZVHNMZC+SIoxpvk4iyvdmBUt1ZpiLjj3UVEZaLOs8rAgTFLN6q+yw8/aXnE3LhVM4mFnuhlJSbiUBfV91LEhB4GCGS+oBFxJXbUYEEfjjxll+qHHYRSYjFFLZvRVC+BCOB4nVKXm53MC+lV2Qdby0/DDZEcBiCnCmdiszRlCxG3HMzif3Pm3YyNZy6Wl0eyK/J3V9+bg3d7pHYAHPxVQkKFl7UMqTtEQILKL6eFLWZRVGfyj4in6qjrDqScR10qt657v3vTWZ/sL6xRY1ViFgWAPa9zDl2D40A1GfkyMr+jsJtoOlCvrpYbtsHVD5qFrDPn3FlImmRaY7kkfPLYHJsz/DtxvMaywY7oPDSBHBZUMsAFO9RcLtZyiKl4JyDzV6iuK2FzaVQOSTG04NL8ndhoELxKyQesWxxd9phUmSkbS6nkwGrtiNxLVE1GIqMolUHTlA7XpFGhNpWgtshmu2OLiPoNLkIUshDsN3c6jQpEtubocqB5MirFdGdUlApXRsPv9GJP4v0LArXXG8zGfZilmrw9w3GoRSXWngQDGHPuLBtScCxK6THCnEhMz4Ln4vUc+NEEhG97Gvus0u0B3jgR8REFr/3nilgNAvgkVP9HFQbnucEzO7cdmnwB+WJBIqM4mFNubwnJ2R54RlKLjIajWYxTHvERpJKxaAARYFNEi2zWYzzim56SzModMPsrTnmV/Eo1RyYttcGB5SDAN5IAntaMghZ437iKsNb+ALPrh1EnB59VR+cEk/zkmymkAaYi9+dKedykCAOOxmrHDeEsgZbz45KsIiB+qrjoeBX9zLtBqbxWvYmujj7SpM8paCptqxDgBIVaou5qlbBcUme8IM1GuhLOsTJQvZC+j0CHXym/W8m/Vi7HXpxUNV6YMKzWZtp+i911UciZM6sQuinYX62o0+glfzjLPZVQMPxJFK/sK8jTR4WD8jRE3DvZ0yBILbd96MmyS0Mu77B8wpncEp26bMvlvorqz1FmViwtfVAfzBz2FnmaYYOEYNl9Wc5NG27zTdhpjV3+g8kNGyZTDUmwSHJYBvIUsXDxf+jDHiFmbPciv0M3BaAtzsNdfOaQUnRaoNgoXvKJclohwY5IryUd3V4C7U8pZeL3J45yeOBiXltbdFg3HcFj9Phm0EoQuNBGA3JdRIAUFf8fKIkUCJph/DoxVycOy7XhIcGbIGKzTs07+wHVYF+3mP51/NsKJsRjOJXRmOFMgy6tnI3LQNCVUcCE4Al7h5MpksBdyHJ2yq86ca0oZvRfSqjEBAyICzt0J2xx8tgrayx6V9/NtKfSDSR5vHHuDcaog2yo6mF9tJhgA4lBKJ+4mM+N6mrie9Dt/JwBILW/yRVQzH9heBc/68/ul96K7eXu8GqliZEEriLp1CtABITh1dDD1+oNIHIJ5b6+VbA/hgTZF9pCFBauVC8Yt6dtUUMPPxIAqiTYedOfudlRtJqPyonec7sGz+4+3DgMAAwMRJ8OohiBl2axNv8inJ4GCDhs96gt2ixxh7ksqAe8TLH9RMzclJeaU/QilpO3Nhr0shQB+tqcxr5tuMDB98rQRuHAViFITfjl+kdnDxwoVXhb7UHm98Zx31E6RAep/ykjKNLXnEpXP1MYIKQYMXEL6LxoR2dkIFsa9Rx6ymTaqx8wVJDhFQrNs45ZgDs7So/hJIu8PLzeUfitVxXdMLI/G8oNN8pAGLOnLKNNlfq9XjeNGtAWHhUi7bsp+QBPUhY39VJITfEx1/3Mdq1x4eRxe/lIjkdl2dCHQWpSclM4ZfrzTxGSHVPe5XEYgdxYKe3g6E8i9q6ohxYV8LbtsTVf1pwNHZfVllGBUVGXbGCdEpYd5ksj2kdB2yU4UgOSvYoBBW0KkyyPiPsdpu9Y2Cnb3ZZ1NO4Err5TcWjcv0xbRnH7OAIZO7Hm4fbyzHS9n/RmXAHGEWACtKKTStQMIsyl7/v6ZW5Znfv35KPcbqICARmGVuSFdfz81q0nqXJ0OvmDTvbACxxbJYWc5lH2O26Bxowvd0GkoPJgbVe5nn6mFHmkmevAaMvMRAT8J9DjZyULQSjC77bYfoKnN8LDXvK7Zn1mjAce19FTTtO5MqSbYjfmuMXyuSAqJTijtNEF+eyl0ZO4LeEMPD0Ox29NDSpoAmB7xI3mJ3N/XRy2UHDGmJW4Qcx+aIl4lkN/QD7qfj4fMJku5WeqAccdAIiFwRbDbDAdd6QNdTBB6Z+5xvMVdVWqvBkexl48YX2iQ8taVrhTSyviXNV4E/lvRorV60FAmJNjRMy5uIeLJJ1OblT3SG+qpWGPznQqkDGunL1HOISHiUpB2I6W5I5PsRHKdSQp06HFQD2k1dMN5EqLStpqPoOgb/Yn6tiKQxVUg642Ju1acyq386zcHsQpaY6h0Ed1h4eE0qWGWTFrVQZZNbT0+nivv5/50aHVFRGA2AzsPeS7rSWmbsMBBYpaswlgmjcyrb+CaCfm7N8WvmK68ValcScOKj16RZQcN/x/dYq1R23OxlP1UextrOoIKAnorO3kxIiL6f9qG2wgx/gFXYzxtnUePm4x2IVyXZfp/KBYyQklZc+ubZ5rEUhk5Lnm9hXaYw6E4DNeOXSlvzDEkdCcTVGBqH8CijMmEdonbo2dLP++ul3NW/ucWDPTlHYm7Ook4ViqZ0F6X5Vxgvs0z15kzJmEwiaTINhpqQ3YtCo2E0tEoMtNd8mn0UuZmi78TA+97pfbiKq5bHCtB9Nb+eug/BVx7CM1p8fl2knQUnyS2YGE8lw9Mw6LBgiL7S9iYnmxf1v8IIrFg7y1+Q21TU2uLo5duRQf7HTVkY3v6bWWhslXYjPMwaISK7hfOCGIO4uqkeoTQgFp+dQ9t+PsA6CODlYOxt2zMOHSn7Zrf9EcN85YmnhgMLFUTesHW2HRj3OW/HZVXhQWUTb0Kln/uyuFDtj/IwzWIpkGwCexYnRXLv1QeHwQj83SiuUgUQKXcdPkLASWuwSfhV8bzHsurCqVvyyGjUtVAlvHUCT/Z/onNZJ7eUPJTWI1b5bpPb3y1VXohA5+xSbh0ClEMV6Bop7XM8kyIsxRM2wC8uikCbOFIdHuQjnureXMOWWhCWOzlU1e3MotNbeztlNoPXDoYMokrNUJDjAB0l4MuY69qRe6Wk5n90/etzyDBBXwEnDgYv9OBc703OW9GMaNXtZSJQztApK5KV3DAShPBJGZeNtrPsU/kgEs3UKtjAGEv3mnJAWq2gD4vjDCTE2nkP55bJUfV/uCay0ntYswiFDOuk4qO0LFN+lyJWLUFnAi2EGhqFU4vUmI+QWAO12JmjW+lT40j4OlefNp639n1AyrF6JkUSg9mPKti3/sZ2l4sN5TieA9E6i6RB5XDG7eKSeRuJuBk2RatOy1aWtTdvJ57uy0EcywDKeZnIt+NMIb4MpJzghW0oGc0VS95mQcj9keYFZduEQOmExamwCS/z2xvUUSFfJr5Dtqn8ZaqoZwrbX4H3AYbYAl05gKYgwoikSenHzRqSutBvJ1YUKQdgy/sv6YkQTwVhs5voCX8dm9uxn/P8mwPmt4rMOj/h21UaEAH9mh22aP2f+s4qTFDuco5nXi89/kVX02eygXAwIAXyr/I/HakHp1tapayV+xYLKyLLZ9mLe+G+YT+NwX8tv5v+pKJsDZX5scJdvz3dycvTDNxZGrQ/EPV6lkWPxMXvmeqpn3LG6IZmbmspJnsSHyW6Y22QPkHgq9Z3Hjc9DLATGjm7Ws3Tblc0HKITRn3AvCbWjmXqMs/KkQySD3rHEm+i1ZVLJU4AgZgkTCB+SDO0qkZpiac9WwLtlHXYXBngruJ7s0xextlJkLFxM9i/TRNGKch7Wl/P2ELkoidawWmZ8e0ydGfwYn6DEz1pI4YrbzAXxQ62vew6BXpVhn+gbynYCBG6+OZqzyag3eIZ5wLBcDg4kCNiLryE/5MLBo4CJznmsRC94gZPm+M+spng9G+JMcG4zC6NQy5oJfUxXhUoY1V3D60KC7V4RRiW/uMJNdJSoJSC+kBjS+yW+t6LqVw9XAC1ZyuWnZM+HyHcyr8Ff8jvasmW/BmCyAZGUahyE/DjPn7m6MIs0nP+dYQqpqibJTJfo9wxa6HGnhsQ0G0EO2tbJu8vvVs3zBa5/Tg9VAnMYa54+EMFxxZK+FLgVy0YQSpjhMcLkGq9R8XZtMIrRHZjDeNv9T9dDUDnkPzx1gwMjjojFz+DC4sUYfYltNkjWzeL/sgyiY3f/bPKSa4LMkb/Zh0665P7LoWVADUu0hzLOLWpaGnfF34oBJXzgXV95SzqXw+HS/aAXzLNAUs/wAUSAb9pUzoT+7eG4x3cM5x5VVjTaOstnPhCZ31wmglBAFuqmxAsfLgSO2OYOd8BDDWVdoETBZMSRCxSmClx5+EJUGr122s/BvkJDsKz3gLhBSfOHumkMX8rtnpM5bS00qdr4YJxvKpRshGor+WdeRAfXNiNqcaamivBdR90hOUYxQt5ccU7CWric1dZ9Jcdqt5X9/M2X1t/Ezbeg0BBGsBi1MmCE7Rri1gJ2R9Nan8fB08z1ommxR0HVHcIcTfiaHMFIcpcakDbxNuKfoLsIEzeH+/yRGx/2an+BD2cemZM6bLM+/KGo73CAuAxU0hpvQdkBMdUao+RylZP0RNWMFUTu/u5ZUKyUHBAnEW4Uny8ThWLdc0IzlZHuvT/gMlahP/YSt5OUZoBTAYeAY9tYpmzVKPniV2W8r168Qks2b7nXlw2bRDJFTpq2yAp6Jp96UwiBfjzpSUP2HLjvLPytEfPdGcaC6wUDsiWTv+KR9/f8LLPNIEN9wwXIyZcbh+7X7a4FHvE3s207O9P5pNIOaoNlRBo7sRW43ZdAfd3HG0Hem7wUiTlYBbbtXH7eLCi5h3kA7RIlXMvmVW81+ZkGhmCb4FSFitzfJorn1auYeMzaVnWHxpCVrht4DTmDfNswnhxz0dFzbBIp8LJyjj6MKN51Jkx6+b4Vja3m68UnbkOvrMJ3IutNp9pDlAfNJKbNglIxxjj8qoFMhVFmlrROmPLW0roq6h7leuC/IxfA8OfKHQVHLtdarxI/XjCVDNP11PgBZ5gNsCUp38m31WP5tW2YwprLa0wSsGXjVmHqSQXXCqMI5KGrNenW9VZEkJM9u0WfeLVW3UGvvXj25lOSPAVTcmK426E701PsHUQBBgXTXAhPv20eRXPMN2N6AS0qeU3cHl/98hnnpVsuqcHSsijAcShigIk87alPU8Ib3YTerM8Cnofw/4lu2WzID9GteyOZTNN1dwRludvvHLqAtWUAjVMf9mh6K2Vk+ocxv7aMHqwU4OPkg8ILZPtAJ630I9qXP5VRG09238uHafCdjQxJkVEH2GO2BGq6qnEa+ebYh1/TNIdPHs6cts+8SKW4EczdSSyOpXNFwBayLrwtXZryaCOwk9XnyeuYQVXpfvOnfURnPliRj8We/rIhXjXSxzxihfqhGrpmtARDlVgFHjJORtTYnqrIEAy5aj8di+jY7mkoIm1A8avwomnDtjZeVrhYT0+ocSNAKVo2xPBDSelR+4kL3L2ZDsSdVYxzA23P2FHIzCuPq6xpWVZFVq7oCjzVwPZ4Gr67vOI6dT5jhJvgnajBoZvqyRTZQw9IiA8+oxsfNJ/jNgE4Az6kuNz722poHU8tQ98TUcIECr5ubiqqoNhG//WnK8flLsRPue3dYChu9q0U89F2xNbfUdnbQRf377PSA2I70MGzUaupLqcqwXFz6n8coLe8/D2tYT/0cnYaO8CzgHaC8tX2v6xn6XaQPnxj2Wy8PKxUOBcrqTRZueMbBlgQwl0xGJWrnXm/4p721bHTnJXMQaSFQp1jRIQZcVETIJaAFotZaaHAhuEM3SZm9nHhcEskr4MU8Bg/GmShdnEWiAzCx4hoVvInHRYLuhpq8W3uiiBspW8PvnBfzUT/ceefUCSLyN9mem3wmKszSgKUPPMwbudn8aScg8JtKz/iPsatGphUxdouW+QJak/AhuDetubkbkddvHbGovBFeFsESce6T8+w0+eP3FMPCdO8pUH+43Ltq2zEs33IHmRb7beeNqM7Yi0siWNJ/IITlwurtKscSHC1u5OlA+4YO/HqJJFQmnkengyrdiDw4UoWJHhWSgKqW0YpvaQr0YAi7QcOdfvGvVgV1EkT/r1wBaSfVN/jOWjEhLIh5D9uq475P53js/8g8+LK6yia+pkw4vVFCoOBtKu9jH2Zpwq1dKRU+KEX9aLY544q/+ukhQdcZdCMgE+FHk3wnJEMEmIMN+8jQ8P9tC51wIU0E2eX4WTfCuONBLjHYvOf0aZApzzQ0aAI28vRoGpFg9UTEKy0rbHT+UvyGDAwwEf9Y2wAgDF3Q9RQpVRm7qX4NLPeMIkeYFKjlEa/jdv+SP2oSmLAYoF9Dvtq+8/yxlY3sAIIWB0C9yRsNKjTKENAi+Tc8Lqp639hsI5G3Z4EpphYLbic6z0nyJevHN8UOvlh9MLTh+hAHDl8lj11LO3jfpywgeSuTn9dMsmpzLGpCVJdX6JATYZ1BQaf0EdCyV9HRAWNYsM0CR6UZZCOAdgjPvFY2PIrwz264AwaUMjk++Fntm8jT2xtchweC5RnM65+Osh7dlmw24BGqxSoAcsqCvk5wS/XFV8iJRb85POQHb4yJ6AWuIwxdPSWbaW0dtzYySJZus0zQo16chtB8uiLJiASKu0aiCshkphj8jTDGyhykfdT0Yh/SwiFqBBkrzqhVbg6WTmU8JA6owXSL00ypW4ud9MiLBpo8ZIDqUbKgpmgSYgvHI+NcK/EACjNPowzRyRpqJ5RR/zUwht6bFtzl6Uksk2/HduHCEUBEICbnD1IyHGZsD+Vo15mjNDeJfC0RbaKVJgAmfX23olIIQjaX+UXmFt0fZAurZApRetMt2HrNQAy8aGSnf2GnfYNWw6Qp6BjwYcxGTG1+/5YKMV34yuImPLePAK+NOnT+Abo4EKVU3QQDx812MUd3owzBTFbEXeVn50XYkx0sOqwIo4p5Gw/tlXQuHVBcU0trLR6ZMZPWi8AJuEbeLWvMuNevYfbn+g59tK06ks8ZajgusyE5bW3a+4S6y7cjzDDmWhxyPZWbig/zOA06ddrSW+RdKoQeaNFHPb6DKXq4ZVXYwt044MevBlqN/sA05qrrZy7d/0UVmZu2wyJ95V9ZkBj0l7CrSDR8K9pi7mSQg3LR2Dag1kQFvNzhsUl+st8WpcVwbfOorY83TLiBhVFowKMrjW1+Yvt6mLUSmsqj34miX2Ldckc36iN9uzsPmtqgaN2vs3EqTnERg5GvRCULZFqFXfnEs3rwCuyYyYMFrrKa9Fy6Rpmd81qB/PgxTySg9vqOYc766E28Zagnjg+ESk2W0aNLz2XtxjHM8ZL8DocYjYUQJdyzHto/VXw+K3tLkEAxwzzX6vb/AALAML+4ct00BBRGf0CM/Rc3d4Nrio1jbm9stWDBilteH5XqkjpLFafw4GJ8l4VdZ6WHiAiBP5ApzsfUAnvEJ44Cd4MVqUq/FAYWYJwW9SNvH3VSMv5kYTggiSOl2mAEL86zUZOvMlNwFPJPjVfyacBSjsaXzJUBrDWhBAbFG4reSG+Qg9kaEsMKCHhgzxkWBKVoYr8g5/sOP/anzgwHC+10P9GFR4VIhIYJiRzkCnBhIabe3etCZRUddlrdgegLOYPE8y6f4/fwoP31ByPGs+XFExGkktbnsT+pHUUPPU2uZPaPaMBrTvYI7QTmtBV3fxA0vGTr96SxpxQgB82z5mbNCy89T4sX3vqb98r+nYssY9txBaQnSNJqz2ILqh3sStX4TRHFger2J+Z+YOXnpt6oYHXK3RmdumAPzzqcxfrTt8YTBjpuYwteezB3X8/x0h/vKp/XeGsRWsmtsno1eRz2RXZl8SA0ncspf79aTBBmErL82RhwUjXNSUPooTUzyrS8XV3UnzK/XyPmA3yq18hoizW0eWYb+hOtRwvaaCSL/ljUw1/cLPOiwQFCNU7N6fBYyaXgFMFWEKgB2ZmNuLcoT8HWNNPNfNtkeQv7MWc8qijXqXZXGbasafNp4Q7DwJAiKuQ9w+e3wQvLKkrb/qK5Y89/Kr8IS1UByfzXTv5xJcKGVBVgbGEpN4bPcrrhG1DACnxKoXAwEoZyAy7ILXAjpDGNExfP0Iibg3LZOXX7LYpwwvABXb7zjAGYO4fjHVvZEvInrDbCcbpS/QDpZSsDw2CuQl8FvROJhEoT7d4/t4sI4I5JiXLsJJZBXuP2FZzanOQwnHV4mC1W8ZOJkPEsS+0Om/WJOemKzUOWDFbD8ZYBrBXN9sBPZXPPW9ux2TJp4lWTnFyY5xSKXnpt6BAp0mJ2YXvZDEsSnO76LmveXb2nRVErDJ30D9YWpTgs+Dmn74KU+zpLcbDgrXFH0MOvT/ew/s00cGLSvNR3JI2WdCnbSb6uKGduY7KKu0bdhw6+6iHxz68jZWtxNkWLXrUorIU7jQzz36mJm/5TRXJ1ew9Bp6tRXsUBwVvpm9QJH77vH1G2YueIqJ15m6oP4rYDzkmatGrpcZX1dQN69fqN2HxEbfE6EBBN0BCpPNsD/F3Corg2D4H3uzDavGn/AgfKMGNktnv/DokUzHPoHyd0yz7CvemB8zIjHk9z1MEeC4/7J6A2Tn19+rSnhm6TpdPOS9NEqTlFR5C/NQmQ3D/6ewiYniBhfmgDDg+7VuYcHlHOV/F2qI1yrYyAN2DGZoE5IdNpq8iGY4J8tnCBzcu/5k6CN2bxiVsv5hFKzIN+y1ZV201aSAHGKAbzKQQjFnQslCSXNWQvjn8796EOvSACrw6l12cpUxAKHLd5y5kSvZmgBMx2TQ1ZtODWVI5TvaJqnqUazBa5eHT4R5I7W+WqzY4OkFHEJWu7H51fXAwmrhupFHy1LC3tTCTrB5ZlFP1ziOeVaqp8eVyLY7WBLWYk07BnDiUek8hNtqV3pQs/w9sBb60RPvF8hksw0+sCU6CTdzGNHCsMNkBXZRfTr1CpbPnurXIqcn8+DgxvAwDnKOJdbaLjLeUE9bHyGpO0AqVxuqOmzfpkWiZ9eH4d5TFUbQYYQmQa0aeKFhVRs1AHuOJnc9PiPL+p8AQ9KOaeoHiDcwuKjjcgDMhEiztF6k5s2iIU7GiqwLCPUMjQtQjsLr0Br3T3Mw7eY7Cb3J+TLIiPTYIjjLoHlD9vhoTjzqyp1dAjR88i1pcSTfpcrBGHkiBXIdYuwIGWReFscUmRIFn6mog09hlRxrW8mP77uXqQ+AxN0/Z43u/qkhLz1/5NM77q7krmBL2LRPMilJRVxBo6zmEHGAfbkK6rF3pD2qJKAsKhoS1otIiRn+bHRr/cYsGIQBBwMLRwXC/M2nWFZXfxbeBLCzfrMl3kQEAk5ju5jb7sqYbJOal1UHPccpXOqVNgR1/HmMeYQL6Ec8lMiFuXrTioIGQPs927qlFWm06zSBkTc1fXQFh6LWm2qFkqDkjs2+lWiUoRPTl5pa7ovIpUgd1/gyLlQBWfEr6X0YLrrCZGo6OSQs5pMUoBHo70Wz3ZJcJkj3hWg51UL4R69Hbuk+2pgXGWvmR0PBXjOyY1/5kqlayApWytCgg69aM7IzQQdG6SdoEHTxZKUwKW9MyEyO2iZ/4raPgHdCS644GyDw54BT4gtO3rKAfPOwFmSTUr/NMBKg1rNoLcbn2jSnVB4CmK+u/pQWcLTAx4oq6VamWUjXi36RQBEPD2pxarnEbnyQaRzjflBx+JJ1IUkiE17u7j92prr7aFWHU9L95DGLSXPf1IrAXG0SEaWY2ZZK78EjYYNYH8dQi7zTrmnYIq6adXHksODITt1absYL0TO5JEbatEQwZM9NLCB9AgmpRkRi/R/XUfv+dKj0E4w2wJYghU9oHbWrNhi3HwoNNzUivmIR9DA2IWzEMqlzqY+PNdnuidZK37JXGL2URLUach+RwFtEF2SfXCDwR0TUAM8tP6iPm/t+DGoQIxVUl1eIbE6T/rUlUzKAxQ6kKGomwDXD57BnHLC8PVPnI1NM+4bxNzL3tPxP/LQ4mlgVG3cEuLH8tazluLSRi4h6JdT/LPpPm5LMAng7TQ/1ahNTVPJMGD1KgwUuzibE8XZms+/2ucgBEEG+TCFwv9Q04B0B1EZVWgL6Khw+ZOLVgVONhthwyNVvhPO5FJEky75oAnhnLrvzayRvc97ha3DscZQsIymlJXOINQO+6KSqYroajcXTpvWLIFYB0E9VZgQUOUFp8FsCIv2DEIcyh0gAZJUfWQJ0MX7lIkFYkYyj2bdULAbmyVmNSn6LD9h8MZPKtG9dh8Ts6RpbrN6se6wmiH6YByjnkznXq1l/j3xUKqsJCTbtGEP8gtNBjOJOtmgcZcGSd8bB+zr1dEgvWfJD0hhHHp8vO4EUK/pwlN9aip+SG6gmGCf6DRM8KMXtzKICKWEkvNHRuZEBmm3sgUitmyJfU5lZo80mV61jLU2gJKs5Q6gFPvksGf7GxwRexqxKWB0j4SW7GVmcIV+crRzrX3kWyUBh61gTze4JhI5cLciOsB+dHMusS6070yCAYzu0UrIMfOpQLxn1wEc265TpcSq2R/p290ML63udv/++TF2VUpOMg8YIVMvPyaUXAEfNsxHkSFqCea+AUln0KAqlE+N7J+ssNbhpe47ofoGP78NjH9dcxwtw9v7TDxaCiGwaoOy1IrWXNqhiyL9sTNmq7hOdk4CWQckAMelVWOof8Cgyn9uon/wNLvMda5iZTAnHftxxON6Gnld5nynj5yEdCpmIiWOc26CPRHxxu//qqoBib0PUu18dNsbzKy0HTf6Cnhtdl1EtV8qnuABG+8Prwf9TG3JRvRYuqeO6GETIYOM4kzyLKfj9S7gAYoCiX5rjD4y6jpPagNDZfvaarP/EaHIm+NAcDKSxiQ+sVPRV1Ka9Wen/J64BV8nu1CmB+E03mIY944OPx3HxVj1FEdVRC2uymahwYa3ibRckTkyYtGa09oTrEt6nN3s+gS2WkNc72FxJb/PJZ95tIS8Z0aLZpF1brv6iyuGjczi6e+aGCWumNNdF+FkJ1wtQ3WgIuTGBGN+cS0VkGUr/6g6avtdx4O1qLs466CMuThvZFQTE4lZD9B5Cs/GCH5vXNtHL7jL4uLze9lFKMuMtytsBrhMre12gqRSe209owbH/68mXg+qtGQrN6kMSOw4NtQevh+f3qyj+qZ46BXg2Ig+j1vaGJpE2ceKDXSIbvKN2beK8dZFHCRgSZq7DaW42y12BbX776xtWGVSSGtGCI9lSy1WX+FWFJGwLq3cE54kDd00MOCnjRDWsianksTmIFF4Ldkmk8dKsXYaD/1QDl5qa19b8jU8HuwfIAfq/72BzkidAJXpdPphXowZXApLDA/CNjhcgkH028u7NCqrix5UYwKsYpdd8weNgN8qgRpRKbxy+PyqWv5OZsXvlaxPF16BtePsgpCbgodRHsbd4ARRe/p8dhDCtIz06nRvopY7C8ExcOsRo8xE2euuyDkTVWL1OtZtFoxjQmMDxeXQen0dtakgnFW5xijRH6XcmHI9bPpAFHZiYj/Y4D6HxBicxs6nPDraOrVyIpQFWgS4K2MLAGVkTEQDqzP+ORhNYOYzre/wxkxAkM09Rk2apZskhM1OXgrlmot7SWXjrk7KAgGu2r/1fK6KRcAPsjOairtvwi4OjfK+Bo9wpmCtNghXQTZzefiDf0sqgtpvxrV4ksYnbNUyNH45VzikNJGj/fUBOmvj8UOztyG40kKApsXDfOboc+KETO+GUz6MgFYdKv5MjyjB/Z+rSXO1vISenD3dM/7nAl1/zLT/HnbJwqF+CkqYIXhoHhxKR/hO2gsmTJ71v9AZH45v2qNxsocVmY12YUmjzb+nmkoST0RTR2pUpC/31BQcqvziUW+7SF/Wysgn5rQaYH5d/ESnjna+6Sj+k0FbeWxowr5E/kDCMKi8qZzi8eHnlsO1UWhq95PicsxuW8xrov93RgiW2luAtV8xeDQQ4edfxtACYiVeS99flc+7fof2uhO3iGxgeFM6inqGggpY2hjn0dIvmuGa8keXOgBUI78Gk38WCHf2wKPNt3uJwFZsI+OX6ogq2KfoAxRme3wnj2c4Uk2bQsoAni+m0ORDPX3BBWBLp2PmKrSiKC+WoL48Ec70ipz0yKBf/E2seEmRvbf65ddIv12DlramxK5c1jNAqMKcGqd7SlKHMCPI1gcL8qDTWed28VjMKSRkAidOPMCSEngh7pRxa5C530EFvTkasFRc7BMHCT2psI501YMfzmlRvVj6tNaK/mVj61PipftqwwEBvShRawQ5Rjc9jYJnCIR2KAWHjGZcgxCnJ1+3Xv3k/iheXyP/y0jidKxJVV43IR7VaCzHxWQYvwGm7BS239UPGHuVEdQWqKYYOKdGbsz6BEPkLQtpSmLkC/WEL3mCQLH5Cyj6RJfBjva/oTmDDh2rVj+DvYwBw6ylMuH+xGBFVX9S6Ya8oed6qp8uTV+W22PzbhJsvLjepc+ZLNTr+PNvhw3HUtxNYLUNvuHLM3iz2w9Upba7bQqs5v/W1b23foOxKzNoQC/iuVv/bKAQ+5iqGUbehEJWNoBibVDdvJE10cFjJbXLCW7cysu7+zeNOlvV5GN7ImXWrsU0Ctmo3lwiWw40FF9vpUTBoieMeZ1WEHsUIVt0HdmQ18OZafIwbVDNVCwT95s/QV+xTabm0Xo9/nNILVO15noH99Pai+Db4KmhVNAFrUBz2OJ5ViXDC2kxbobP6Rf2x7lMXlNqNZ/6oq47PZPNS/cHkU4Nj6LGNLIU3Us0FRwxwTKs6fgPN+OllZDkYjqYRzjLeVYJXwrv4+v2QZmawDbAzzh6ZHM5iS7+657FY/HhzzqPSWZ0Mdlj9MHAJIv3iRPA/+uqTyyR6BVfHnLV3FKqn+1uTI9htgYJJnm1i9PqDW+q6RCWczqtgdweRHx+riUrngdWB8KaaxKjHtSc7f8V9RWKwLH5hY2al4XHgmCslVDNd2BTobfbgzx6KM/OSZMlVkHLRxDD2RV9zLBMkeClHrRVnBnM7ElNndl7oVC7/AX2YycDprMt5gmMhDpss4Zkclhie39FhagvkhFEelVjNUp+ISKq94psGrEUpP51EWK7JfLzEe+130jK2RSJ+up1Q8i/coSXM3lINju/ilLD9gtLYl3gk2naP0rrAbqnnOvUoNaJD8dV7G5JaerOE+c/D9CgJZcWYS1g7ZXUm6kmqwOYWu249gVpFRWaDGrHCcTTG73uygxWh3jP3wbdjfpcEEBOtVmOCRJ2i14A9J7WkwOLN86kAsllNVF1HEXGokpD9F12U4X2FZeJssDatEprXE7Uao+V/HeRfx6Y/BRDJM41O0HNEwlVQARGAXGIZIotWvPbheOhD7TSaDKC1fpIy8Uks3okYxdH7DwGviBhqwolEW15Y/7qgbhvX9Ch62QWrQHz7SUBzPFi/Qyd2D5qXLTOPsjd8fmKiZzSi/pyBPraANBrQEn4+dGJPY7RjUnAeA30uyTis2F64Ct83qbkG/yZRlL9pLwNOU5vPfAEt26TLxn5QCaUbrmh7+ZTyiGBnTlCHt7OuMoTegm1B1h9VHLtM7kWsRNh+MV2f/qScHF5iZxpKzbE7DQpUU4U8q6BHBgTP5lw/7yPkfvhXTHdAJbPz4AWV7VGNupU5cDykcSGGf31XIY3DWvAyj2pVf2sR7N06Kz4OpfH/8BJA/FtobO+u56CzWeuWrwpf+sPQ0kOKRaKIAzUmD72kwRvErkQe1Y7QIZkYzgopOotebNbfqe45DTEnkopcqgrXmC7BDxKGMOCaHGlrJrZnMiWxLwlwGGI21pBd2C7D6ngSBpu46AtJ1fixzKQ0XIYpyjwTsXKad9Q88ma/OigmiShdZ4LLNYl1hsJGzyEgYZkc6Ze1CD0gNdHMnh979Yj7I3fnnogkh4dx1TTG1SXmc9KA3tR8oie0Z7b+kgDEEoCIgkIx+Yap69FMQ48ZsicJrD75OhFv/yc2DFA88JOsK1Pwem1Oeo4A6ttNGACzf/tzQicJfo3rTU7QcSjihS9NTiS7eqJGGpfTN+/3DlVwBTc9oYThwd7aI3SxCsVegSZonIweMmBpzdVC3mw1snL9IlbxQtYGHfXK3o64NX+VZsJ/PcW4gfcs88+yaTmJ0c68OPQ+Dn8jm1VNsjp7kRMaYe94DpOwMtbnCeAOpn66darsmQCerxyB6tKqzcmzBAO78qSlxdAKthPLeQDAZ9qrUKAXsIvSU6WH3mqX97tO0GASVSIC0iaN1IttcVkHzXf/0xcuwyu0hGFEGYsuA+cHIH9Lv+nX0gelREI4Y8kFl0lV34ZLQ0bv95ODSZM6nup1wbTkKEFfaLjQ7YCWCd4cd8kU2ghsXpPrjfQGu+Zwb8Y1J1/+Bj9iiKsmpQ8v5it4pGM+9uVF1nWCov04vhx2se+cMCtN+72do3nQxfHUCSYu9XCzCQx4pXzBl/ESl6vwXOwJR1zF31atXOy3/spudHDkRLeUK7eGK1MEYlzYF7d2srcZtyZWZbcpxgLxxWvKRs9EUguf/yxC6b6aW3fY7mnO9EqNSV6uFeyJdTC0G9K2pl1G2owTZbsI7kZp+FqoUr4NdKu9DQM+6NubX6DeFct9dX36b7vLuKEx89vURi2N8U7+Ce6aEIyV7AFjx0D1lReN2YlSSVb8Ema68BTrV0aNP9VBFW6bzXBM3Yo8sCt5hHvqYvQXky4zLJFloSn81D+AHEw7yiM0EG8gi6kYHYAHqkzikz7baFTiNjv+nQfXs8jjpD6Nm7CRXpOo8Hkfnhch/0NQ8d169EyLMDaW/575gwJr4CftcBM2vXxjXz5SNmqKcd713pp409F5nbYLyW1dbqK/9PJ1hC75AViA42sRSwuVLXyTKadkB93QhLAVo3xlmFTd5mC5t7njbc9mKtHv7H1l0Pt84+XUJYHk1DlabH7lr894LGi2T2WRAks/JqGUs4YWjGBX6TfenjtXmKJqu2CBOWhbS3/uY2+Z8ZeVSppXe7FF4z4hr2FNF+WZRiri28mdULUNfIk0hNjj+yrhDsdyI1rNgi+V9UKZxXVj3h8E57ynbXUVIjwUH8yKi9wNRrNsa7hbXWmLqqyKF+3/kwfnO7ZdASgEVzwrNr8lbEyzMWa4d/DsIj228rGWzDY8+RvA8A6gZnTL/zTb5Zzt+ATmJe2NITcES/O7MfmJ1fO8YhNdpcpK1yfX4EAUnig030oEwRfe2bOSpSOsr8EADX5VE9Il4cREjStiHJYYb+mLlM86rUQStRnUmtVGY95ggcPlUkM0lnhZsIJKey3z5yYewK6kqI1MHi6BXiLT5zA14OvBlTEspjubK3TgNR8lthnXNjyxn6vFpoZfHtQ2i2X4YoqRWJkm3mY8c5ThecrrCs/XzkcKBbDu0dVs+JyXpxLv5apScf736pfge4hGoQhZwRaqHh8xz0CoNmsoWpzgaIBpwRJ3Zzo4vPdk7KZ36w2opT/tQwMFdyt//dcptm3//h76L5zIeRDsgkDPsVXqICjC69XHPN5PmTcEYBZbZSKHh3Wzbp4KXJytcgQHhIXYggrmCcuuzMOl29J2dKeofMo8lMMstpZdcWjNxU4S2eTyljkxqaeSUltHkCFsltGUUByMvqXb6eohpdIqRx6IdhRns89CTPYBrstk6LbobKKQMOdWE01nEN6vfpmgvGlRCBv9B4FbZS5n7uvNou0gq5fVQnOQSy4gI0CXvp5mzQsxrm3l8BbQiyMmNLQyk1Ili9MUUtGIo1nIEc0zypYzjN2qRuSyPFKPU06TLeBfbKIh5YDk9GpkWskASMZJjIm5TnwlCcMIgfOdx0npvJzdjul3jvoSDvIMJabKfcZL3Gj90TsnDDIA5Sm6vNwlAHEglWyE8PSlM2fdoSd2J0t2OO8JWV1sxWfe3hAAvYp6YmB3Pb5GiY+ETbvYiwywMqLD+zCTB0t1o4Qz6h1PYzPOHAVNa2ftAkMHWYDpH6V8B1pbHdpYSJkJzwcCNJdaqwExRL3BJzs2bX9j5aYS0a5cC3Q90ayBrpdkVzye58WdsxavvZQInWwULxb9nHwP6abJROrzcewcGB0V5cFzIJOtm0YWQfouJkwiO3FzVGnLgMfeYIV3x4CBuTrSPYYKUjIIBY2TUQ7UgyiqyLzQ7FcG3ud7qZvPUcJuId2aPwz7IPUnpb/t+yYiWyMliNjxs2bHVCamVOVJNWWLdvh3B/QaSnCblBVsZKZNHrAmKe3BKrjsYfzv4JisW5obRwVgrSU/G1LcEcEVTwA+ABMqZqHj+ZKELkl+WNSHMV16/qawt30/CBYct5SAAZQPEpY7k2cYbdFY60GsDXs1HJVuip6oa2mNaJ8k23BD5yYdg51wlsmuK33luDTNPoYYWAK/lRcUrajkK4HGOxGoBScktCjo7ueKA1XkeIiIqMjWlF6TUGh3IdfHN4G2oodRFnYmOZbfDg3nHwltQ0XjMzfc5TONc9q0k2s0KwOof0Xhdvkuw/LkjYCKfIMexetkToPgporIBw1Vf4KR0vOQf1SucbvoALXJ3+2ANLdk/WVu7pAf/DQHXz40sAGQKn8oDRWvvm1C9kmwsvRv56ralzsHyzFiTVIesO2JAefJp3lgwHVAriKd4myLYFYcXjaW2JQAC/VgGrhmKAk6CcVQZiPFvDQGmQ9bYfxGBIPT2bzel2/+79gssHLEhwuLnsJq6jGDT2HzyvnaFYzq8O7GOK4TTu7rtWyDfcg0lmFof/8ryfIFdMgSli1kEd/0efmaWHzGUGpivLT+Le26Zxii4UvhwVYaO8bbmp9eAGoyEPVUmzQHRnrGmbeS8bc6pkTBEk+risg6/9RJ1Svd6IyF0Ep0Ji+DzIvRcmH4ntznt0Rm4MtqrEec5b6FSvZSyk6rU9RiYuIYyRizxAJTUSmWgZD1tVaDB3BwPBE0illGl2eqi4fP219/E25VVh4yl8zhXYdmpkBKHK2F6GPU4ebI1iHb2rY7yYJ4ATS0pKtUyRHK2DRTrRNovfB5mJpyMTp0KPMoz79+vhrFvmX2dDVRFzqX6FFHeLpgYyC2TXThuU8rYFpa5TP8UmjPskAN7gwjY9qV7t8QWMoFLGw71ub+XsqtKMiRkxrHlKfhO7ZD9i1ZlVei94cOc4aep5NSRMiUce4kk3S3VcwAciagOOfLx7Ohiv5y563ya/fHYOzuB/gI/XSguSotQP2da/FlNDUQFk1NpjN5lBe/MDkZQeputiJV1IC1ST4IlacOmHSduoAcvBiQL4a2khdJfXeOi/iCbJKGFwoCX/72snG75WstRSsETuqbbSqZAnv5cRBz9j/6qwpJldXqryBAtEmfnA1/5d076uQj0mntGbRsS83FD4Zp5ZRYhf9xcaI2K20VtIaElnXDuvQMWkIa/rX/SUt8/gC6ANdPOfPsi5FJtpmhKFjQN0cx8J5O3YhpLjzmQyQH7RG5k7f63xebwsvsccld+O/XpTMeUr7gFElrqwkXsRIayQnRCd6b+1rxYOUepHgx9BXhvvaEstz8kkram4x9TqxWHRenkKijrWkss+syZP0/1iTmdBRiyJPTTPoogQsPdMKMVbFK8pzUdrSvxYD4U9qIUKZ7cxWUPm4Dsu6trWNadivnj1aKnxbPTlJ9lsmYxIzwL/83RqUD5LTZIZuJ7t8jNmhHaed+H4acXx/PUIU/lahyUDfhp2Dt1xd2jlbSYniOtPP57ioDCLKjsOLuPi8UobLmdEC0Rj2DIsUlE3HdiBXcnyRCaLn6G7239JPAvmhMI876mnu9kVBQEjHzQ7rNom8lsVZuMOCEqCPF/CT5aUsYeM3/Pw6ylBDVrQrkFt2q/pDROxlLHFBiRm7ZiNqaKMQU792UV1U304c9/z+o3S/3nv2ZX+FL1FNhJ8eIro88TJ2BICBahil0kzyULuo/z/NMNmqxFl8w63rhfqU46x/MCj2MUsZypDZArgWHMh8vkDlNXQy95WjHtXZTNzAUFvUCQIvfx75HxT/iKfdP+ZVRA0GYCXze2jpF+ZrwYUOTo7C2jIhhb9XT2ZYXZBRidoCPLymkWfEQ93iZsKP1teFFywyfJlOft65CtW5QhwrDNy+NYAvaBmbfzFTMMqNrWY94vGOTE92VJ96klNfiiMQa35IvaMTd9zDI27fzyI89dMhMuxJioV0F07rAhoYLLrjVoi4eWQxJHV9rQ2n7P9lYH7cXr+3N/pIl/azS27gSZzLQdqYYeJxIlA9B8v8qzn+tuDg9t6O2Gp7+rx4B8p3MsuQSEDY+34ZjZLy264X7ewwm/qwJ+ZIJDjNAiBDhrgPC9iH7R8TGcMYtrOLzy3vHLVDTCl5I5Nxe/DoyqfGFWJlIqzytbMb7qHX5dsA2hl8fNMwj7nAveSBJqrxorzNz6I5Kcu+Fs+982PfiPEWRoFviB3pzIB/eccRBsaZuhGC6xVvUZS6nMjs7uLzzjAsML+ZIjWo+pSxEOfvKAOyRGohyUo2/SYUer9/h1TbCBrjp098EC0yebwvWgPKZuUOlDOYTupo6rjUwICBlATlHllhR4iQnHYffAt/d62r9jBGrZWU6U698rmGzvW5127+RRiyP1kUSQKM17J7eeay900E6RfuMRB8ZQ3RVx8M/d1OS43nO/tY2yz/JiWCRi+FmRNpkrbdF+ZQCmJadIVT2GfBdtHDr2BtwvsQH6hhgIl6L9v9wJdH2p5Kx31DEgKC0jzYZ2gyJzRhXGdiq5fFGADtbWR6lWb1h+O78Zy5lB/ev29D9Fz+n6y+NZhuenGVj89jJF/NlEKKVcNeyrCq+2Hq7L/1H2ao9Eqp2+Mcd55zoua9dsWlZQC+B9X/TuGBhf/osZ8Fpw5cVYAT5Sx9ieyHvP5GFAaV/qedIl7rQh5KWMoZtHnryWdYhbefGjiBl0JpoJzbZZfPXTe+eQWcukb1EnNj6xRN5gJC7zRCouwgS9Mun+eHqwFi87ZRLYJCnSQczqr50fztZfJg40DpYNjfgIs0/rA/O8Xc3smu0F2roM3sVvzILIBeaGKRvqvpg4a7XPHe3oXxRty38ZeN2gxGr1jqul48jPKhx9FAmta0plt3FgDH1u5yP4QbsE0exWqtdyHo7NH1HGlb420Rz600qkPquMUm3Mm/bjiY52Hmtyy7BVU0bGMRDzDPBtBzo5fioS+SOCfsn00O75vR5lnFUTrT3Ke9B5j7b41sTss9hUQmahE50d9x1PZJKGdSEnnxqjPsrlNGNrsIDdmTDqfK+apwV59CpJVdUv0j+iDudGcP/2pFrWS+NzWcfFs1/nzz/e2sUqRoC8zPl0AbQC2HdRbLh2wMZWn5FC10YPEZLBbn90Pqh+lRWLrKgoXJfXr5jmkYxQKMiS8+6Dm1LjeCSj8mo1Wio1+Z1x0fNdkE2JIis0iebR2+lYFTs8D57NVFDZrxD8tgCyhP23wRnj7M6yHlu6bKcqStPWT8Vn0m7wJ9ciH+egfiJv+kCWGSQ+Yv2jaV8mXLUuIZxiJf8CTi1lzFXaHqgY4DHn1VhMYSNKxCRXfh2khu83gj5BArc3qDvWhRzxPJHbq3E/rZToEMDqkcZyqY53/mDkMyYWONdoFMPTd6UdNZzSAv6F8FN1Paj93/TEzLAINT4ck5jQ/jPMt4Ip1bAeWPGdWcuw8MPvICnx9v3KCLCpphQsSFnBqmsCUPrGll9xltSGBPhyMX9C0ZYcfw/kpHfnIeR2pnBSfIqSNlH+Pj1fi8p1+KYCOlsK7yDSh7PVYWQbpbWJi6xC86oW0xLlbMPHEGNQii3p6AKp0UtZaSZPylBIa7dYDqI3AfloRABOkAcWLaELbtRxok7LGDVRn24SaI705pXxYBE4R3gtl3nus7udHyIYUMVOaqawXxwlgLhoZCZ9GSdGMX2XJVMvIh1X6uO6mYSzfitdPWvIzziGBS1XFKn8b9f83BuHmphIDECE2MmrWn1dUv4AlwRmAYwXW5HkjGZ1kadqJNH+UKKGbfVV0lVAXoV10TTmSFQ04bmY1lxqUvwV726qKKgaNAUndK0FJbjr3OqL0FtqEbBW15PeakHDt6iFq9PN021QAOV6ktykgfJvWN426Vjs8YiHjdbi+xbtKuiA+YNSrhf/W2hsVsFBzbI8qLEFdrZWgQ5qcDz68bLlMdiRlDDm8e1ZuJUOd79/FMTNY7Plx+DILKWCQ/mBSXO9BcI9VbX5EmY8aEoa0UtJB+M4hdq9W7jYEXSkFl5GRUMaHlsfnuy9rWMYilSIeMFGkgydSjfTq8XW/DzBiSIoY8kinxpEmJC0kpSfanYdB2pdVIk+mSYA0+K07ipXIIOW1+X6mBT0ky7K12zn6mvEvJQvtJGDSmICpNztjvNH7tZrMM2UCkr87CT4jID/C1mtyDw1HU0mJnVfYPBz1M8h+h8aql5057tI0bgokpNckiRdwi6FUdfOAJ7ahCZkM+RxfuWyo+63cIEXOIoZxm3jeR5DBY8jzDft2YpzzBe1RACk3UhUUBM8BFeYYnwF/i3ElXyeAErrYL3M7/0LcOH9Axs+0cdwUijWSBtyRPLU/fOUx+dOObFjPqEKWVHMBhTfo0y18jtip6a+iUJsnbB+o43C3YB30BNwrpkws20zhHFn94RwIh9xDlWpagt4gt9eAqERLmKbr5ZwAFiJxDigmmg/SyntuUhZiwMick0ky8SGaBHxmXiD6qkjcviIBXJInq0YblhMHMdV6i4RX40bXmFlZvyJfHLPyxVwJUclAqGmUXfJ2INefj0Ww7tCUoF6adWQI52r0CQwwnhNQ/43OQrQR3zKRUOPzW/OW5wfAnZg3bxGlmAQPvmMt4CHYyJMINVUB1RKZzBCL6+NPqtIlvT8VvswmaekBdwI+YuTpJnA6u/1zHmG8F1Gk+QnR+UZwisI6ahf+IF31Iglvt4FnFd8Im7vCmU2PDKtFnW2dysEg/4X9IeygvbldwqkYkVsA88GfqCRP0vP2M+7rpPD3Nec07WRCdQ/D5nroUzBKdJuCTXJgoWKzOdigPPq1TFTRz5lPPP5uWjEevACy46tgLndUn9UitbP2K0PeyeI1Ng0OmgyIm542+lvX4TlFXgZ9DThLwy2I1zVTYLAUYEUVIPnYJ+R9ZRqT6YeuvBJDGWbNYwblZT7/BlKPaobEPI7sy35ZgGsT8p+ZfgP0ttMYMVAgv1rIapbjaIQSYqPuo1TotDfWoJ8Icz8sOfJJAyuuJqPjixk7dqFuw9Cjbo6BgM03XxEbMLN0DQqED6qRQnS+wtHp97zFRzEV6FvpeqUgtKBmw78NmR5YF4V273DEMXS9ipXK3AeAB7NGlarFzIwWwhcn21I0hF7IaQ2OCRliMpMLKgSF6h0dpfjfwmvQwvAz1JNldh3M94FByWyA2CmkeyEEzy/9WElk3HeheCF+MyftbAXJhmxUnYCOXKO+7jCMQ4G4l1EgxqhFn93hA8eyMXWYTbxdCCGgzLACo5I/tuYfsfKj39ss9fdVqAxxBzjrw47QT0uidLgBWwWIj+fy689L8ypdXIKMzCiwDGZ31Hy10MWMJSSXqsN+NrArla8gS2q7CQcE3rM5iwnpFHA6A1AqMlLpEalJRjJbdywyHvTzIMKbX2voA8uWg46r+M0wOs4F7mNo+Jq/1/7KhPXHGMqL0eU1zVMmOBY2ldi62s1wVYXCGRvR52q0Gme5N3nvaFiwBE46dFbhehM2P0x2zxRBnKZnGsiYFnDTo2S3EoOGvaFGSt/N2qE7Vmit4QcCYrnFQBZw1vXF5jn0wbJj6TRgBmlT3+YsUBbB1jEByIOWYXeF4T2q14WYwadVqTxpjVh7lJNS5u0A==","profile_content":"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","other_party_extra_data_content":null,"extra_data_content":null,"wrapped_receipt_key":"UqAI7cCcSFZ3NHWqEoXW3YfCXMxmvUBeN+JC2mQ/EVFvCjJ1DUVSzDP87bKtbZqKLqkj8oD0rQvMkS7VcYrUZ8aW6cTh+anX11LJLrP3ZYjr5QRQc5RHkOa+c3cFJV8ZwXzwJPkZny3BlHpEuAUhjcxywAcOPX4PULzO4zPrrkWq0cOtASVRqT+6CpR03RItL3yEY0CFa3RoYgrfkMsE8f8glft0GVVleVs85bAhiPmkfNQY0YZ/Ba12Ofph/S+4qB8ydfk96gpp+amb/Wfbd4gvs2DUCVpHu7U+937JEcEi6NJ08A5ufuWXoBxVKwVN1Tz7PNYDeSLhko77AIrJhg==","policy_uri":"lNVPUiMEAf9oUBc56Tn_mZcbp4eOyXOd6mPTO_uYe8kKtZEgQFRekJrparpy8WHR","personal_key":"t7es00YGJZgU2Wxoo3OqcJAdI8BSgKA134G1NGBK5xY=","remember_me_id":"Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU","sharing_outcome":"SUCCESS","timestamp":"2016-07-19T08:55:38Z"}} \ No newline at end of file +{"session_data":"i79CctmY-22ad195c-d166-49a2-af16-8f356788c9dd","receipt":{"receipt_id":"9HNJDX5bEIN5TqBm0OGzVIc1LaAmbzfx6eIrwNdwpHvKeQmgPujyogC+r7hJCVPl","other_party_profile_content":"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","profile_content":"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","other_party_extra_data_content":null,"extra_data_content":null,"wrapped_receipt_key":"UqAI7cCcSFZ3NHWqEoXW3YfCXMxmvUBeN+JC2mQ/EVFvCjJ1DUVSzDP87bKtbZqKLqkj8oD0rQvMkS7VcYrUZ8aW6cTh+anX11LJLrP3ZYjr5QRQc5RHkOa+c3cFJV8ZwXzwJPkZny3BlHpEuAUhjcxywAcOPX4PULzO4zPrrkWq0cOtASVRqT+6CpR03RItL3yEY0CFa3RoYgrfkMsE8f8glft0GVVleVs85bAhiPmkfNQY0YZ/Ba12Ofph/S+4qB8ydfk96gpp+amb/Wfbd4gvs2DUCVpHu7U+937JEcEi6NJ08A5ufuWXoBxVKwVN1Tz7PNYDeSLhko77AIrJhg==","policy_uri":"lNVPUiMEAf9oUBc56Tn_mZcbp4eOyXOd6mPTO_uYe8kKtZEgQFRekJrparpy8WHR","personal_key":"t7es00YGJZgU2Wxoo3OqcJAdI8BSgKA134G1NGBK5xY=","remember_me_id":"Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU","parent_remember_me_id":"f5RjVQMyoKOvO/hkv43Ik+t6d6mGfP2tdrNijH4k4qafTG0FSNUgQIvd2Z3Nx1j8","sharing_outcome":"SUCCESS","timestamp":"2016-07-19T08:55:38Z"}} \ No newline at end of file From 9b0d9b2e9379d90120b9c4337c27d789e7ccd404 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 8 Mar 2019 16:52:43 +0000 Subject: [PATCH 11/14] SDK-818: Add test coverage for empty Remember Me ID --- tests/ActivityDetailsTest.php | 57 ++++++++++++++++++++++++++++++++--- tests/Entity/ReceiptTest.php | 11 +++++++ 2 files changed, 63 insertions(+), 5 deletions(-) diff --git a/tests/ActivityDetailsTest.php b/tests/ActivityDetailsTest.php index 996a2b54..89835dc7 100644 --- a/tests/ActivityDetailsTest.php +++ b/tests/ActivityDetailsTest.php @@ -31,15 +31,34 @@ class ActivityDetailsTest extends TestCase public function setUp() { - $pem = file_get_contents(PEM_FILE); - $receiptArr = json_decode(file_get_contents(RECEIPT_JSON), true); - $receipt = new Receipt($receiptArr['receipt']); - - $this->activityDetails = new ActivityDetails($receipt, $pem); + $this->activityDetails = new ActivityDetails( + new Receipt($this->getReceiptArray()), + $this->getPem() + ); $this->profile = $this->activityDetails->getProfile(); $this->applicationProfile = $this->activityDetails->getApplicationProfile(); } + /** + * Get pem file contents. + * + * @return string + */ + private function getPem() + { + return file_get_contents(PEM_FILE); + } + + /** + * Get test receipt. + * + * @return array + */ + private function getReceiptArray() + { + return json_decode(file_get_contents(RECEIPT_JSON), true)['receipt']; + } + /** * Test getting ActivityDetails Instance. */ @@ -57,6 +76,34 @@ public function testGetRememberMeId() $this->assertEquals($rememberMeId, $this->activityDetails->getRememberMeId()); } + /** + * @covers ::getRememberMeId + */ + public function testGetRememberMeIdNotPresent() + { + // Remove Remember Me ID from test receipt. + $receiptArr = $this->getReceiptArray(); + unset($receiptArr['remember_me_id']); + $receipt = new Receipt($receiptArr); + + $activityDetails = new ActivityDetails($receipt, $this->getPem()); + $this->assertNull($activityDetails->getRememberMeId()); + } + + /** + * @covers ::getRememberMeId + */ + public function testGetRememberMeIdEmpty() + { + // Set Remember Me ID to empty string. + $receiptArr = $this->getReceiptArray(); + $receiptArr['remember_me_id'] = ''; + $receipt = new Receipt($receiptArr); + + $activityDetails = new ActivityDetails($receipt, $this->getPem()); + $this->assertEquals('', $activityDetails->getRememberMeId()); + } + /** * @covers ::getParentRememberMeId */ diff --git a/tests/Entity/ReceiptTest.php b/tests/Entity/ReceiptTest.php index feb6dbe1..72d42261 100644 --- a/tests/Entity/ReceiptTest.php +++ b/tests/Entity/ReceiptTest.php @@ -55,6 +55,17 @@ public function testGetRememberMeId() $this->assertEquals($expectedRememberMeId, $this->receipt->getRememberMeId()); } + /** + * @covers ::getRememberMeId + */ + public function testGetRememberMeIdNotPresent() + { + $receiptArr = json_decode(file_get_contents(RECEIPT_JSON), true); + unset($receiptArr['receipt']['remember_me_id']); + $receipt = new Receipt($receiptArr['receipt']); + $this->assertNull($receipt->getRememberMeId()); + } + /** * @covers ::getSharingOutcome */ From 04d77f5e060bb5d713176978dcc3493c892e1cdf Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 8 Mar 2019 17:09:11 +0000 Subject: [PATCH 12/14] SDK-818: Add coverage for empty Remember Me ID on receipt --- tests/ActivityDetailsTest.php | 50 ++++++++++++++--------------------- tests/Entity/ReceiptTest.php | 24 +++++++++++++---- 2 files changed, 39 insertions(+), 35 deletions(-) diff --git a/tests/ActivityDetailsTest.php b/tests/ActivityDetailsTest.php index 89835dc7..399e1bb8 100644 --- a/tests/ActivityDetailsTest.php +++ b/tests/ActivityDetailsTest.php @@ -29,34 +29,26 @@ class ActivityDetailsTest extends TestCase */ public $applicationProfile; - public function setUp() - { - $this->activityDetails = new ActivityDetails( - new Receipt($this->getReceiptArray()), - $this->getPem() - ); - $this->profile = $this->activityDetails->getProfile(); - $this->applicationProfile = $this->activityDetails->getApplicationProfile(); - } - /** - * Get pem file contents. - * - * @return string + * @var string Pem file contents. */ - private function getPem() - { - return file_get_contents(PEM_FILE); - } + private $pem; /** - * Get test receipt. - * - * @return array + * @var array Receipt array. */ - private function getReceiptArray() + private $receiptArr; + + public function setUp() { - return json_decode(file_get_contents(RECEIPT_JSON), true)['receipt']; + $this->pem = file_get_contents(PEM_FILE); + $this->receiptArr = json_decode(file_get_contents(RECEIPT_JSON), true)['receipt']; + $this->activityDetails = new ActivityDetails( + new Receipt($this->receiptArr), + $this->pem + ); + $this->profile = $this->activityDetails->getProfile(); + $this->applicationProfile = $this->activityDetails->getApplicationProfile(); } /** @@ -82,11 +74,10 @@ public function testGetRememberMeId() public function testGetRememberMeIdNotPresent() { // Remove Remember Me ID from test receipt. - $receiptArr = $this->getReceiptArray(); - unset($receiptArr['remember_me_id']); - $receipt = new Receipt($receiptArr); + unset($this->receiptArr['remember_me_id']); + $receipt = new Receipt($this->receiptArr); - $activityDetails = new ActivityDetails($receipt, $this->getPem()); + $activityDetails = new ActivityDetails($receipt, $this->pem); $this->assertNull($activityDetails->getRememberMeId()); } @@ -96,11 +87,10 @@ public function testGetRememberMeIdNotPresent() public function testGetRememberMeIdEmpty() { // Set Remember Me ID to empty string. - $receiptArr = $this->getReceiptArray(); - $receiptArr['remember_me_id'] = ''; - $receipt = new Receipt($receiptArr); + $this->receiptArr['remember_me_id'] = ''; + $receipt = new Receipt($this->receiptArr); - $activityDetails = new ActivityDetails($receipt, $this->getPem()); + $activityDetails = new ActivityDetails($receipt, $this->pem); $this->assertEquals('', $activityDetails->getRememberMeId()); } diff --git a/tests/Entity/ReceiptTest.php b/tests/Entity/ReceiptTest.php index 72d42261..98559177 100644 --- a/tests/Entity/ReceiptTest.php +++ b/tests/Entity/ReceiptTest.php @@ -17,6 +17,11 @@ class ReceiptTest extends TestCase */ public $pem; + /** + * @var array Receipt array. + */ + private $receiptArr; + /** * @var Receipt */ @@ -25,8 +30,8 @@ class ReceiptTest extends TestCase public function setup() { $this->pem = file_get_contents(PEM_FILE); - $receiptArr = json_decode(file_get_contents(RECEIPT_JSON), true); - $this->receipt = new Receipt($receiptArr['receipt']); + $this->receiptArr = json_decode(file_get_contents(RECEIPT_JSON), true)['receipt']; + $this->receipt = new Receipt($this->receiptArr); } /** @@ -60,12 +65,21 @@ public function testGetRememberMeId() */ public function testGetRememberMeIdNotPresent() { - $receiptArr = json_decode(file_get_contents(RECEIPT_JSON), true); - unset($receiptArr['receipt']['remember_me_id']); - $receipt = new Receipt($receiptArr['receipt']); + unset($this->receiptArr['remember_me_id']); + $receipt = new Receipt($this->receiptArr); $this->assertNull($receipt->getRememberMeId()); } + /** + * @covers ::getRememberMeId + */ + public function testGetRememberMeIdEmpty() + { + $this->receiptArr['remember_me_id'] = ''; + $receipt = new Receipt($this->receiptArr); + $this->assertEquals('', $receipt->getRememberMeId()); + } + /** * @covers ::getSharingOutcome */ From a19e24223eb8b4ff4bf4a7299d8710855cd95380 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 4 Mar 2019 15:32:18 +0000 Subject: [PATCH 13/14] SDK-810: Allow API URLs to be configured --- examples/.env.dist | 7 ++++++- examples/assets/css/index.css | 2 +- examples/composer.lock | 24 ++++++++++++------------ examples/error.php | 2 +- examples/index.php | 8 +++++++- examples/profile.inc.php | 8 +++++++- 6 files changed, 34 insertions(+), 17 deletions(-) diff --git a/examples/.env.dist b/examples/.env.dist index 310a55f0..79a10f5f 100644 --- a/examples/.env.dist +++ b/examples/.env.dist @@ -5,4 +5,9 @@ YOTI_APP_ID=xxxxxxxxxxxxxxxxxx YOTI_SCENARIO_ID=xxxxxxxxxxxxxxxx YOTI_SDK_ID=xxxxxxxxxxxxxxxxxxxxx # Below is the private key (in .pem format) associated with the Yoti Application you created on Dashboard -YOTI_KEY_FILE_PATH=/path_to_pem_dir/php-sdk-access-security.pem \ No newline at end of file +YOTI_KEY_FILE_PATH=/path_to_pem_dir/php-sdk-access-security.pem + +# Change the API URLs (optional) +YOTI_CONNECT_API=xxxxxxxxxxxxxxxx +YOTI_QR_URL=xxxxxxxxxxxxxxxx +YOTI_CONNECT_URL=xxxxxxxxxxxxxxxx \ No newline at end of file diff --git a/examples/assets/css/index.css b/examples/assets/css/index.css index 8fd8dc35..2c238ddc 100644 --- a/examples/assets/css/index.css +++ b/examples/assets/css/index.css @@ -166,4 +166,4 @@ .yoti-app-button-link { text-decoration: none; -} \ No newline at end of file +} diff --git a/examples/composer.lock b/examples/composer.lock index 25ba897e..183443eb 100644 --- a/examples/composer.lock +++ b/examples/composer.lock @@ -1,11 +1,10 @@ { "_readme": [ "This file locks the dependencies of your project to a known state", - "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file", + "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", "This file is @generated automatically" ], - "hash": "7a6c48264e6454ff581a7f0189792926", - "content-hash": "2a81e6ba4478b78c3d08f434b9ed3156", + "content-hash": "5da8436cec4125630cc7875a14bcad6c", "packages": [ { "name": "symfony/dotenv", @@ -62,20 +61,20 @@ "env", "environment" ], - "time": "2017-04-27 07:47:28" + "time": "2017-04-27T07:47:28+00:00" }, { "name": "yoti/yoti-php-sdk", - "version": "1.2.0", + "version": "2.0.0", "source": { "type": "git", "url": "https://github.com/getyoti/yoti-php-sdk.git", - "reference": "59890106c25a19025e1e0914b56e2c38aa979fc5" + "reference": "b214dc5d69216265ba06c9820f85890bb334d61d" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/getyoti/yoti-php-sdk/zipball/59890106c25a19025e1e0914b56e2c38aa979fc5", - "reference": "59890106c25a19025e1e0914b56e2c38aa979fc5", + "url": "https://api.github.com/repos/getyoti/yoti-php-sdk/zipball/b214dc5d69216265ba06c9820f85890bb334d61d", + "reference": "b214dc5d69216265ba06c9820f85890bb334d61d", "shasum": "" }, "require": { @@ -91,12 +90,13 @@ "src/phpseclib/bootstrap.php" ], "psr-4": { - "Attrpubapi_v1\\": "src/attrpubapi_v1", - "Compubapi_v1\\": "src/compubapi_v1", + "Attrpubapi\\": "src/Attrpubapi", + "Compubapi\\": "src/Compubapi", "Google\\Protobuf\\": "src/protobuflib/Google/Protobuf", "GPBMetadata\\": "src/protobuflib/GPBMetadata", "phpseclib\\": "src/phpseclib/", - "Yoti\\": "src/Yoti" + "Yoti\\": "src/Yoti", + "YotiSandbox\\": "sandbox/src" } }, "notification-url": "https://packagist.org/downloads/", @@ -131,7 +131,7 @@ "sdk", "yoti" ], - "time": "2018-06-25 09:59:44" + "time": "2019-01-22T16:04:34+00:00" } ], "packages-dev": [], diff --git a/examples/error.php b/examples/error.php index b787eae7..8ec922c3 100644 --- a/examples/error.php +++ b/examples/error.php @@ -6,6 +6,6 @@

Home

-

Could not login user for the following reason:

+

Could not login user for the following reason:

\ No newline at end of file diff --git a/examples/index.php b/examples/index.php index f78d0ce6..b9b9d4f9 100644 --- a/examples/index.php +++ b/examples/index.php @@ -71,7 +71,13 @@ \ No newline at end of file diff --git a/examples/profile.inc.php b/examples/profile.inc.php index 2d6cb68d..9af880e5 100644 --- a/examples/profile.inc.php +++ b/examples/profile.inc.php @@ -7,8 +7,14 @@ $token = isset($_GET['token']) ? $_GET['token'] : ''; $profileAttributes = []; +// Allow Connect API to be configured. +$connect_api = Yoti\YotiClient::DEFAULT_CONNECT_API; +if (!empty(getenv('YOTI_CONNECT_API'))) { + $connect_api = getenv('YOTI_CONNECT_API'); +} + try { - $yotiClient = new Yoti\YotiClient(getenv('YOTI_SDK_ID'), getenv('YOTI_KEY_FILE_PATH')); + $yotiClient = new Yoti\YotiClient(getenv('YOTI_SDK_ID'), getenv('YOTI_KEY_FILE_PATH'), $connect_api); $activityDetails = $yotiClient->getActivityDetails($token); $profile = $activityDetails->getProfile(); From 6cfb07ae7c9c216ea3a731a525777d3c03bb54fb Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 8 Mar 2019 17:30:06 +0000 Subject: [PATCH 14/14] SDK-810: Move dev environment variables into .env.dev --- examples/.env.dev | 13 +++++++++++++ examples/.env.dist | 7 +------ examples/assets/css/index.css | 2 +- 3 files changed, 15 insertions(+), 7 deletions(-) create mode 100644 examples/.env.dev diff --git a/examples/.env.dev b/examples/.env.dev new file mode 100644 index 00000000..79a10f5f --- /dev/null +++ b/examples/.env.dev @@ -0,0 +1,13 @@ +# This file is a template for defining the environment variables +# Set the application config values here + +YOTI_APP_ID=xxxxxxxxxxxxxxxxxx +YOTI_SCENARIO_ID=xxxxxxxxxxxxxxxx +YOTI_SDK_ID=xxxxxxxxxxxxxxxxxxxxx +# Below is the private key (in .pem format) associated with the Yoti Application you created on Dashboard +YOTI_KEY_FILE_PATH=/path_to_pem_dir/php-sdk-access-security.pem + +# Change the API URLs (optional) +YOTI_CONNECT_API=xxxxxxxxxxxxxxxx +YOTI_QR_URL=xxxxxxxxxxxxxxxx +YOTI_CONNECT_URL=xxxxxxxxxxxxxxxx \ No newline at end of file diff --git a/examples/.env.dist b/examples/.env.dist index 79a10f5f..310a55f0 100644 --- a/examples/.env.dist +++ b/examples/.env.dist @@ -5,9 +5,4 @@ YOTI_APP_ID=xxxxxxxxxxxxxxxxxx YOTI_SCENARIO_ID=xxxxxxxxxxxxxxxx YOTI_SDK_ID=xxxxxxxxxxxxxxxxxxxxx # Below is the private key (in .pem format) associated with the Yoti Application you created on Dashboard -YOTI_KEY_FILE_PATH=/path_to_pem_dir/php-sdk-access-security.pem - -# Change the API URLs (optional) -YOTI_CONNECT_API=xxxxxxxxxxxxxxxx -YOTI_QR_URL=xxxxxxxxxxxxxxxx -YOTI_CONNECT_URL=xxxxxxxxxxxxxxxx \ No newline at end of file +YOTI_KEY_FILE_PATH=/path_to_pem_dir/php-sdk-access-security.pem \ No newline at end of file diff --git a/examples/assets/css/index.css b/examples/assets/css/index.css index 2c238ddc..8fd8dc35 100644 --- a/examples/assets/css/index.css +++ b/examples/assets/css/index.css @@ -166,4 +166,4 @@ .yoti-app-button-link { text-decoration: none; -} +} \ No newline at end of file