Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rlBZ7-000dJ3-LF for pgsql-hackers@arkaria.postgresql.org; Fri, 15 Mar 2024 17:41:58 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1rlBZ6-00B2UZ-6k for pgsql-hackers@arkaria.postgresql.org; Fri, 15 Mar 2024 17:41:56 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1rlBZ5-00B2UR-PN for pgsql-hackers@lists.postgresql.org; Fri, 15 Mar 2024 17:41:56 +0000 Received: from mail-io1-xd35.google.com ([2607:f8b0:4864:20::d35]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.94.2) (envelope-from ) id 1rlBZ2-004hAe-U9 for pgsql-hackers@postgresql.org; Fri, 15 Mar 2024 17:41:55 +0000 Received: by mail-io1-xd35.google.com with SMTP id ca18e2360f4ac-7c8dd755793so69855739f.0 for ; Fri, 15 Mar 2024 10:41:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1710524511; x=1711129311; darn=postgresql.org; h=in-reply-to:content-disposition:mime-version:references:message-id :subject:cc:to:from:date:from:to:cc:subject:date:message-id:reply-to; bh=Qgy6uK/9Z+Hd4ONA/XVkobVbe/39c3MaDQasZnUwoM4=; b=KWLMM+CcD+8CHYybNDFNiDeoUIRmzT4ievr3kv5bfC8kFxHckp/fsgwKUFvRKYoI26 LKnm7ewcQvCoXEZHtxwUpOaRZIOKK5BQCI+z3Ur5B8R/SWyASce0dfQdsRD9zlKONIkv Vzj+EIKz8tKhGZtZdjXzkLg0vazOHBUl8PrBMm3ykrJdr5M2KKgfzw9EM8eVxijBuvja y2a40pGBs3KxbhahufU0qQYV6uXgKvmsOXlwA52SLo8ixFpDeNrGtoG9i+MFiWL3b22E pO9wHaxz06IIhKGiPaKkZ3j1bRmy4Dnfz4jFuLCESqBnWqXvzmkqcgWgdXOu8FrEiB10 ug1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1710524511; x=1711129311; h=in-reply-to:content-disposition:mime-version:references:message-id :subject:cc:to:from:date:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=Qgy6uK/9Z+Hd4ONA/XVkobVbe/39c3MaDQasZnUwoM4=; b=SFOOrccOIbBjqZBsn//pYku6QqC+zkGxTMw9G9xXHE6soWGGT6i7oMfIBKusLxOMYx W7kv0yJgk2tBAu8jtoc3Ix55kOQgSVjQqAJ5E+cqP2Mqok2EeqnfdYv3SAUKNLxNfc7J DzuRFkDH4krnTczXRgTdQ6iwv5UVoypRAzyL4Fd4bYaWjXyXIYC2FJ1147YcD7LW4xB3 V2WNiSKCP4dkOfcFRnKe0BZtM8cYfnFMZqzfnrhicna3CPEZFwRzvSAVlOvuvWTVV6dB ELVsb+V+kMGKYXhfTPgjb1FefP2JffgEWRyebY5/lbiGHnEOdZLM5nSDc5PWEbsOj4Is /NTw== X-Forwarded-Encrypted: i=1; AJvYcCV7As8kfiWYQxw7Biv0Sken4jID9GtmmfYROBnG1vXmkRd0gewuOzRw5xGWsIyumxRNk2GL4usccMt36tdgfF0EIilOStj3So2SpgiF X-Gm-Message-State: AOJu0YxoOaYEx+k8X3dceIBFuXranrzpP0+eYRKU2TmM2kiUYRQbtO/L ZFd+TZ11e74pNdgAsvNEa1F62nZbApcXMqC46Tnq4MMQxIhvDRNX X-Google-Smtp-Source: AGHT+IFipmKo+EdNRJeBdgKjsLWh8D+oLwn25F8o/DkO5a8WqU7OVxYzu10FgVevfj4H8oCQ6Z8YXQ== X-Received: by 2002:a05:6602:1655:b0:7c8:a9d5:64f0 with SMTP id y21-20020a056602165500b007c8a9d564f0mr7582797iow.19.1710524511377; Fri, 15 Mar 2024 10:41:51 -0700 (PDT) Received: from nathanxps13 (162-195-168-172.lightspeed.stlsmo.sbcglobal.net. [162.195.168.172]) by smtp.gmail.com with ESMTPSA id el10-20020a0566384d8a00b004778e715be3sm244690jab.35.2024.03.15.10.41.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Mar 2024 10:41:50 -0700 (PDT) Date: Fri, 15 Mar 2024 12:41:49 -0500 From: Nathan Bossart To: John Naylor Cc: Ants Aasma , pgsql-hackers@postgresql.org Subject: Re: add AVX2 support to simd.h Message-ID: <20240315174149.GA3837823@nathanxps13> References: <20231129171526.GA857928@nathanxps13> <20240108173715.GC2611898@nathanxps13> <20240109162009.GA3033933@nathanxps13> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="6c2NcOVqGQ03X4Wi" Content-Disposition: inline In-Reply-To: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --6c2NcOVqGQ03X4Wi Content-Type: text/plain; charset=us-ascii Content-Disposition: inline On Wed, Jan 10, 2024 at 09:06:08AM +0700, John Naylor wrote: > If we have say 25 elements, I mean (for SSE2) check the first 16, then > the last 16. Some will be checked twice, but that's okay. I finally got around to trying this. 0001 adds this overlapping logic. 0002 is a rebased version of the AVX2 patch (it needed some updates after commit 9f225e9). And 0003 is a benchmark for test_lfind32(). It runs pg_lfind32() on an array of the given size 100M times. I've also attached the results of running this benchmark on my machine at HEAD, after applying 0001, and after applying both 0001 and 0002. 0001 appears to work pretty well. When there is a small "tail," it regresses a small amount, but overall, it seems to improve more cases than it harms. 0002 does regress searches on smaller arrays quite a bit, since it postpones the SIMD optimizations until the arrays are longer. It might be possible to mitigate by using 2 registers when the "tail" is long enough, but I have yet to try that. -- Nathan Bossart Amazon Web Services: https://aws.amazon.com --6c2NcOVqGQ03X4Wi Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2-0001-pg_lfind32-process-tail-with-SIMD-intructions.patch" From 3a4d74eeab18d9e8f510e11185109ed910e40268 Mon Sep 17 00:00:00 2001 From: Nathan Bossart Date: Fri, 15 Mar 2024 12:26:26 -0500 Subject: [PATCH v2 1/3] pg_lfind32: process "tail" with SIMD intructions --- src/include/port/pg_lfind.h | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/include/port/pg_lfind.h b/src/include/port/pg_lfind.h index b8dfa66eef..9d21284724 100644 --- a/src/include/port/pg_lfind.h +++ b/src/include/port/pg_lfind.h @@ -103,7 +103,7 @@ pg_lfind32(uint32 key, uint32 *base, uint32 nelem) const uint32 nelem_per_iteration = 4 * nelem_per_vector; /* round down to multiple of elements per iteration */ - const uint32 tail_idx = nelem & ~(nelem_per_iteration - 1); + uint32 tail_idx = nelem & ~(nelem_per_iteration - 1); #if defined(USE_ASSERT_CHECKING) bool assert_result = false; @@ -117,9 +117,11 @@ pg_lfind32(uint32 key, uint32 *base, uint32 nelem) break; } } + i = 0; #endif - for (i = 0; i < tail_idx; i += nelem_per_iteration) +retry: + for (; i < tail_idx; i += nelem_per_iteration) { Vector32 vals1, vals2, @@ -157,6 +159,16 @@ pg_lfind32(uint32 key, uint32 *base, uint32 nelem) return true; } } + + if (i == nelem) + return false; + else if (tail_idx > 0) + { + tail_idx = nelem; + i = nelem - nelem_per_iteration; + goto retry; + } + #endif /* ! USE_NO_SIMD */ /* Process the remaining elements one at a time. */ -- 2.25.1 --6c2NcOVqGQ03X4Wi Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2-0002-add-avx2-support-in-simd.h.patch" From 0ac61e17b6ed07116086ded2a6a5142da9afa28f Mon Sep 17 00:00:00 2001 From: Nathan Bossart Date: Fri, 15 Mar 2024 12:26:52 -0500 Subject: [PATCH v2 2/3] add avx2 support in simd.h --- src/include/port/simd.h | 58 ++++++++++++++++++++++++++++++++--------- 1 file changed, 45 insertions(+), 13 deletions(-) diff --git a/src/include/port/simd.h b/src/include/port/simd.h index 597496f2fb..767127b85c 100644 --- a/src/include/port/simd.h +++ b/src/include/port/simd.h @@ -18,7 +18,15 @@ #ifndef SIMD_H #define SIMD_H -#if (defined(__x86_64__) || defined(_M_AMD64)) +#if defined(__AVX2__) + +#include +#define USE_AVX2 +typedef __m256i Vector8; +typedef __m256i Vector32; + +#elif (defined(__x86_64__) || defined(_M_AMD64)) + /* * SSE2 instructions are part of the spec for the 64-bit x86 ISA. We assume * that compilers targeting this architecture understand SSE2 intrinsics. @@ -107,7 +115,9 @@ static inline Vector32 vector32_eq(const Vector32 v1, const Vector32 v2); static inline void vector8_load(Vector8 *v, const uint8 *s) { -#if defined(USE_SSE2) +#if defined(USE_AVX2) + *v = _mm256_loadu_si256((const __m256i *) s); +#elif defined(USE_SSE2) *v = _mm_loadu_si128((const __m128i *) s); #elif defined(USE_NEON) *v = vld1q_u8(s); @@ -120,7 +130,9 @@ vector8_load(Vector8 *v, const uint8 *s) static inline void vector32_load(Vector32 *v, const uint32 *s) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + *v = _mm256_loadu_si256((const __m256i *) s); +#elif defined(USE_SSE2) *v = _mm_loadu_si128((const __m128i *) s); #elif defined(USE_NEON) *v = vld1q_u32(s); @@ -134,7 +146,9 @@ vector32_load(Vector32 *v, const uint32 *s) static inline Vector8 vector8_broadcast(const uint8 c) { -#if defined(USE_SSE2) +#if defined(USE_AVX2) + return _mm256_set1_epi8(c); +#elif defined(USE_SSE2) return _mm_set1_epi8(c); #elif defined(USE_NEON) return vdupq_n_u8(c); @@ -147,7 +161,9 @@ vector8_broadcast(const uint8 c) static inline Vector32 vector32_broadcast(const uint32 c) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_set1_epi32(c); +#elif defined(USE_SSE2) return _mm_set1_epi32(c); #elif defined(USE_NEON) return vdupq_n_u32(c); @@ -270,7 +286,9 @@ vector8_has_le(const Vector8 v, const uint8 c) static inline bool vector8_is_highbit_set(const Vector8 v) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_movemask_epi8(v) != 0; +#elif defined(USE_SSE2) return _mm_movemask_epi8(v) != 0; #elif defined(USE_NEON) return vmaxvq_u8(v) > 0x7F; @@ -308,7 +326,9 @@ vector32_is_highbit_set(const Vector32 v) static inline uint32 vector8_highbit_mask(const Vector8 v) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return (uint32) _mm256_movemask_epi8(v); +#elif defined(USE_SSE2) return (uint32) _mm_movemask_epi8(v); #elif defined(USE_NEON) /* @@ -337,7 +357,9 @@ vector8_highbit_mask(const Vector8 v) static inline Vector8 vector8_or(const Vector8 v1, const Vector8 v2) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_or_si256(v1, v2); +#elif defined(USE_SSE2) return _mm_or_si128(v1, v2); #elif defined(USE_NEON) return vorrq_u8(v1, v2); @@ -350,7 +372,9 @@ vector8_or(const Vector8 v1, const Vector8 v2) static inline Vector32 vector32_or(const Vector32 v1, const Vector32 v2) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_or_si256(v1, v2); +#elif defined(USE_SSE2) return _mm_or_si128(v1, v2); #elif defined(USE_NEON) return vorrq_u32(v1, v2); @@ -368,7 +392,9 @@ vector32_or(const Vector32 v1, const Vector32 v2) static inline Vector8 vector8_ssub(const Vector8 v1, const Vector8 v2) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_subs_epu8(v1, v2); +#elif defined(USE_SSE2) return _mm_subs_epu8(v1, v2); #elif defined(USE_NEON) return vqsubq_u8(v1, v2); @@ -384,7 +410,9 @@ vector8_ssub(const Vector8 v1, const Vector8 v2) static inline Vector8 vector8_eq(const Vector8 v1, const Vector8 v2) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_cmpeq_epi8(v1, v2); +#elif defined(USE_SSE2) return _mm_cmpeq_epi8(v1, v2); #elif defined(USE_NEON) return vceqq_u8(v1, v2); @@ -396,7 +424,9 @@ vector8_eq(const Vector8 v1, const Vector8 v2) static inline Vector32 vector32_eq(const Vector32 v1, const Vector32 v2) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_cmpeq_epi32(v1, v2); +#elif defined(USE_SSE2) return _mm_cmpeq_epi32(v1, v2); #elif defined(USE_NEON) return vceqq_u32(v1, v2); @@ -411,7 +441,9 @@ vector32_eq(const Vector32 v1, const Vector32 v2) static inline Vector8 vector8_min(const Vector8 v1, const Vector8 v2) { -#ifdef USE_SSE2 +#if defined(USE_AVX2) + return _mm256_min_epu8(v1, v2); +#elif defined(USE_SSE2) return _mm_min_epu8(v1, v2); #elif defined(USE_NEON) return vminq_u8(v1, v2); -- 2.25.1 --6c2NcOVqGQ03X4Wi Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2-0003-test_lfind32-benchmark.patch" From 9b2b61927a8b52637f70659d513ddfeba7c03024 Mon Sep 17 00:00:00 2001 From: Nathan Bossart Date: Fri, 15 Mar 2024 12:28:00 -0500 Subject: [PATCH v2 3/3] test_lfind32() benchmark --- .../modules/test_lfind/sql/test_lfind.sql | 67 +++++++++++++++++++ .../modules/test_lfind/test_lfind--1.0.sql | 4 ++ src/test/modules/test_lfind/test_lfind.c | 16 +++++ 3 files changed, 87 insertions(+) diff --git a/src/test/modules/test_lfind/sql/test_lfind.sql b/src/test/modules/test_lfind/sql/test_lfind.sql index 766c640831..d8fa461bfa 100644 --- a/src/test/modules/test_lfind/sql/test_lfind.sql +++ b/src/test/modules/test_lfind/sql/test_lfind.sql @@ -8,3 +8,70 @@ CREATE EXTENSION test_lfind; SELECT test_lfind8(); SELECT test_lfind8_le(); SELECT test_lfind32(); + +\timing on +SELECT drive_lfind32(0); +SELECT drive_lfind32(1); +SELECT drive_lfind32(2); +SELECT drive_lfind32(3); +SELECT drive_lfind32(4); +SELECT drive_lfind32(5); +SELECT drive_lfind32(6); +SELECT drive_lfind32(7); +SELECT drive_lfind32(8); +SELECT drive_lfind32(9); +SELECT drive_lfind32(10); +SELECT drive_lfind32(11); +SELECT drive_lfind32(12); +SELECT drive_lfind32(13); +SELECT drive_lfind32(14); +SELECT drive_lfind32(15); +SELECT drive_lfind32(16); +SELECT drive_lfind32(17); +SELECT drive_lfind32(18); +SELECT drive_lfind32(19); +SELECT drive_lfind32(20); +SELECT drive_lfind32(21); +SELECT drive_lfind32(22); +SELECT drive_lfind32(23); +SELECT drive_lfind32(24); +SELECT drive_lfind32(25); +SELECT drive_lfind32(26); +SELECT drive_lfind32(27); +SELECT drive_lfind32(28); +SELECT drive_lfind32(29); +SELECT drive_lfind32(30); +SELECT drive_lfind32(31); +SELECT drive_lfind32(32); +SELECT drive_lfind32(33); +SELECT drive_lfind32(34); +SELECT drive_lfind32(35); +SELECT drive_lfind32(36); +SELECT drive_lfind32(37); +SELECT drive_lfind32(38); +SELECT drive_lfind32(39); +SELECT drive_lfind32(40); +SELECT drive_lfind32(41); +SELECT drive_lfind32(42); +SELECT drive_lfind32(43); +SELECT drive_lfind32(44); +SELECT drive_lfind32(45); +SELECT drive_lfind32(46); +SELECT drive_lfind32(47); +SELECT drive_lfind32(48); +SELECT drive_lfind32(49); +SELECT drive_lfind32(50); +SELECT drive_lfind32(51); +SELECT drive_lfind32(52); +SELECT drive_lfind32(53); +SELECT drive_lfind32(54); +SELECT drive_lfind32(55); +SELECT drive_lfind32(56); +SELECT drive_lfind32(57); +SELECT drive_lfind32(58); +SELECT drive_lfind32(59); +SELECT drive_lfind32(60); +SELECT drive_lfind32(61); +SELECT drive_lfind32(62); +SELECT drive_lfind32(63); +SELECT drive_lfind32(64); diff --git a/src/test/modules/test_lfind/test_lfind--1.0.sql b/src/test/modules/test_lfind/test_lfind--1.0.sql index 81801926ae..6b396dbd58 100644 --- a/src/test/modules/test_lfind/test_lfind--1.0.sql +++ b/src/test/modules/test_lfind/test_lfind--1.0.sql @@ -14,3 +14,7 @@ CREATE FUNCTION test_lfind8() CREATE FUNCTION test_lfind8_le() RETURNS pg_catalog.void AS 'MODULE_PATHNAME' LANGUAGE C; + +CREATE FUNCTION drive_lfind32(n int) + RETURNS pg_catalog.void + AS 'MODULE_PATHNAME' LANGUAGE C; diff --git a/src/test/modules/test_lfind/test_lfind.c b/src/test/modules/test_lfind/test_lfind.c index c04bc2f6b4..2234f148b6 100644 --- a/src/test/modules/test_lfind/test_lfind.c +++ b/src/test/modules/test_lfind/test_lfind.c @@ -146,3 +146,19 @@ test_lfind32(PG_FUNCTION_ARGS) PG_RETURN_VOID(); } + +PG_FUNCTION_INFO_V1(drive_lfind32); +Datum +drive_lfind32(PG_FUNCTION_ARGS) +{ + int array_size = PG_GETARG_INT32(0); + uint32 *test_array = palloc0(array_size * sizeof(uint32)); + + for (int i = 0; i < 100000000; i++) + { + if (pg_lfind32(1, test_array, array_size)) + elog(ERROR, "pg_lfind32() found nonexistent element"); + } + + PG_RETURN_VOID(); +} -- 2.25.1 --6c2NcOVqGQ03X4Wi Content-Type: image/jpeg Content-Disposition: attachment; filename="avx2_bench_graph.jpg" Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAaABpAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRof Hh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwh MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wgAR CAGWAtADASIAAhEBAxEB/8QAGgABAQADAQEAAAAAAAAAAAAAAAMEBQYCAf/EABkBAQADAQEA AAAAAAAAAAAAAAABAgMEBf/aAAwDAQACEAMQAAAB78BrBs2sGzAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAABzkuoHL++lHmORMKCagmoJqCagmoJqCagmoJqCagmoJqCagmoJqC agmoJqCagmoJqCagmoJqCagmoJqCagmoI2nQAAAAAAAAAAAJzMhAXnSZQAAAAAAAAAAAABHz hbIQtePo0gAAAAAAAAAAAAACdJ0AAAAAAAAAAANHp+nqc176MVhkzCgmoJqCagmoJqCagmoJ qCagmoJqCanyGFT7k8umvyVD4o685qCagmoJqCagmoJqCagmoJqCagmoJqCagjadAAAAAAAA AAAAABOkygAAAAAAAAAABGk2xFeW9fp2Zx9fHPeo6aAAAAAAAAAAAAAATpOgAAAAAAAAAABq ddsfBi+8j6bWGTMKCagmoJqCagmoJqCagmoJqCZj4WyMTItS3hR1ZzUGMr55r+lHTSagmoJq CagmoJqCagmoJqCagmoJqCagmoI2nQAAAAAAAAAAAAATpMoAAAAAAAAAeIY2Zj5HPcOmgAHi dJ817jpoAAAAAAAAAAAAABOk6AAAAAAAAAAAGE1mObVqvZ0s/UDJTFExRMUTFExRMUTFExRM Ux6Y3PfL9Tb0omlRMUTHqPqPNfMTdNKJiiYomKJiiYomKJiiYomKJiiYomKJiiYUjYAAAAAA AAAAAAATpMoAAAAAAAABiZWNy3yh1UAAA+Y+Ti818odNAAAAAAAAAAAAAAJ0nQAAAAAAAAAA An41mObtzPs6qfqBkpiiYomKJiiYomKJiiYomI5GHlct6JuqlExRMUTFMW2NzXzU3TSiYomK JiiYomKJiiYomKJiiYomKJiiYomFI2AAAAAAAAAAAMJmiC4TpMoAAAAAAAB8+wznzkzpWQ2q AAAxcrF5r5Q6aAAAAAAAAAAAAAATpOgAAAAAAAAAAAajDOjc57Ogn6gZKYomKJiiYomKJiiY omKYtsbmvmpumlExRMUTFExTFtjc181N00omKJiiYomKJiiYomKJiiYomKJiiYomKJhSNiXO 9P5tXmnSrV5rZ7LGrbA1vQ4NbfFscvtcDPAAAAANT53A0/3bhOkygAAAAAAAh4j4zOXQOvMA AABi5WLzXyh00AAAAAAAAAAAAAAnSdAnp6a7xo1NN40d75bVy/m+fVS5kdW43eG2AAAAANWb RrBs50mUAAAAAAPkGJ8zOTR9OvMJAAAAMXKxea+UOmgAAAAAAAAAAAAAE6ToDxV7eET78PEw 9Y32yrGiVzcS5kI2DV/TZtZ6NixMsA+ch2A5f30o8wyZhQTUE1BNQTUE/lcLG18amVlaf2jq zmolNQTUE1BNQTUE8bNxea9lHTSagmoJqCagmoJqCagmoJqCagmoJqCagm1uqvTpbTpS/wAj dnMF1Zhi7FeOd+dGvHOuiHHb7Y+jUZGeNJ43w03jeDFygAAATpMoAAAAeYePkczm0DqzAAAA AAAYuVi818odNAAAAABz016Fpd0kIkAAAc9NdzzNum0pqNf1PLnSUlXLUAAAAAAAAAAD5x3Z YRz1N6MuGTMKCagmoJqeKpw95fLpL7R2Zy1mN45u7oFHTwzUE1BNQTUE1BNQTxsmHNe6jppN QTUE1BNTyecTXY+meL0Gx+xPJ9RzXUzE1Gek1BOGl8aZ9FhaXMMDd7VEzUUvPRdDr7V+bHRb 0CtgAAAAAAAAAAAE6TKAAE6vuOy+bQaXobfQW3We89TuePtTs3j3pzhIAAAayY2eo1G1vTmu lzNNhbphewBx1tM9rttBq5jpOev1JgZ5noETy3U8t0d6W8aLW8/Xb1kW0pn5uj+Z33rRfYne NH8N60X03k9PIx+p5PrOnjClwAAAAAAAAAGh3mqMP3kfTawyZhQTU8Q8Y1Mvl0n59aHe1MrP 56W40OZvt+XkodtzldNtk4ewy0movnNQTUwkZGk13SaU5vZb9Ey+0UvHkuz47J1rxiW0zsTx oJjN6DX+k508SOd9q1PlO4aWqdqwfEU1WVH5a295t0m3JZ4Ya+3z1aPj6l8fR8fR88U+nP8A RTpaQmoAAAAAAAAAAACdJlAMXK1HLrttJPcX21m5wdHvzb3Wz6XTEM9Gl3WBMY+30Oxw681r fts9i1/N2pt4Q3N42TW+sr7Br/Mtk1vo2HMbjW4xmZWihnb1v/ubvlispS0POStGKylZxfuS lLzdeNfyvcay1MullLzUXiXm6kwXEFxBcQ8ZSGNkyrpAXgAAAAAAAAABrNnzhsGq9nSz9QMl LCznLwtfPO2x1dOj7efTb2bO9E0WomKePg5y+lyOb0Ok5jL3/X52t2dmekVhHzkDG92EfGSM bA3GPzaafpIe9saJtYomKJiiYomKJiiYomKJiiYomKJiiYomFI2AAAAAAAAAAAAAEq4FJjzu f0VGHlZDeoRIAAAHBdJTarAqAAAAAAAAAAAAAAAAAAAABOk6AAAAAAAAAAAAB45g6rXZ8M5y UWkWR8mQiLIiyIsiLIiyIsiLIiyIsiLIizH9FkRZEWRFkRZEWRFkRZEWRFkRZj+iyIsiLIiy IsiPVI2AAAAAAAAAAAAGFmh51GeZD1zp0HzxU+NDvgx9abp6xDJYWeeWD6Mx615nMLPPLX7I 8vWpNo+fD01m1PH2OEbN6xTIazanli+TMesAzWFnnlrNienrTm2TseWl3J9etaZ/30PLUbk8 sbwZj1hGWwdgeWD9M30AAAAAAAAAAAAAGvtlBjZIx8gNTsaj5pt0Gh30jR9DOhy+fsbkub6r GMHIzxz2w95xgaXqcE9YO68mm3eHmHOY/Si3N9Jjmk6B7OSzdrlGPzPX4ZibOg4zfZ1zX6Dr pGPj7aZyHUZPo5+XRxPWj6KRzXUysc1mbGp64ztMIwNnkfTk9tkZwAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB//EAC4QAAEEAgEDAwQCAgMBAQAAAAIAAQME ERITBRRAMDIzECAhMRUjIlA0QWAkRP/aAAgBAQABBQL/AM4F4CIL0ZkF6MyjuhIX/lgk7qRg klrMEktaNjOJxyhHLaMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMt GWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRlo y0ZD+D8wPb/vG+XzA9v+8b5fHYwchnhOQZoikGaIpEHt8qQtRCTKKVhTflvOb5fHhEIuoRMT V217GPTtH2Qb4yayayayayayayayayayayayayayayayayayayayayayayayayayafY5DAjR A4gLnrk1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k0OeTxxp 1gIYIQkGGIZBhiGRB7fJd8NC34Uvxh7POb5fMD2+Sb7mzYZS/GHs85vl8wPb48hajrLiMNG+ kvxx/H5zfL48Mk3eQXJCTWJ44Y5p2jchFAYY5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5 AXIC5AXIC5AXIC5AXIC5ATEJScgLkBcgLkBGYOEZiwcgLkBcgLkBcgLkBcgLkBcgLkBcgLkB cgLkBcgLkBcgLkBcgLkBcgLkBcgLkBcgLkBcgLkBcgLkBC7PJ44VpxtBRdkFF2UdIh+ge3xD LQWjImaEWWMfafsi+Pzm+XzA9viD/Yf3n7Ivj85vl8wPb4ZPgYW/r+8vZD8fnN8vjxWgmle1 G1sL0ZlHdCQkHt8OZ/8AAWwP3l7YfZ5zfL48c2b7VrITsEktaNjOJxygBsaMtGWjLRloy0Za MtGWjLRloy0ZaMtGWjLRloy0ZaMpB/z0ZaMtGWjLRloy0ZaMnBsRCzhoy0ZaMtGWjLRloy0Z aMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRkLYk8wPb4f7seh/1B7POb5fMD 2+E74aH0oPb5zfL47GDkM8RSDNEUgzRFIg9vhTOmbDejB+vOb5fHgEI+ojGMztr2MenaPsg3 xk1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k1k0OxSZNZNZNZNZNZNZNZNZNZNRbLJrJrJrJrJ rJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJoc8njtTqiQ06wEMMQyDDEM iD2+C74aFv8AD0of35zfL5ge3wZXxGDYD0ovd5zfL5ge3wZvy/px/J5zfKpTaKL+cgX85Av5 yBfzkCuzvXHvOS7XsHLDcmmY5pTlliOWO36cUso2msTxwtYnjhjmnaNyEUBhjkBcgLkBcgLk BcgLkBcgLkBcgLkBcgLkBcgLkBcgLkBOQvNyAuQFyAuQFyAuQFyAuQFyAuQFyAgIWk5AXIC5 AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXIC5AXICF2e T6astWWrLVlPDzI4d7ENW1BE1GIpOxMHhruEvphWnayFF2QUXZR0iH6B7fAItRiH1A+bzm+X 0hkEz8EPb6/6Xyn6g/P5zfKj2ePivrivrivrjvq4T7bnDOUsxQvzs5PrYaWR1Ud2n9cPb636 X5mdmw3qN/yPOb5fuIBkFoY2jeMCBoYhEoIjUtKKQgjCIfTC8BuF6MyjuhISD2+q74b8zOzY b1W/5HnN8v03FbitxW4qWUIRC3CZPahFPdrsA3R372vpFNHM3IzTKvc7hu8HsCuNCfPPpXn5 4vq+cRQPhgklrRsZxOOUANjRloy0ZaMtGWjLRloy0ZaMtGWgpxFmYeR+MVoy0ZaMtGWjLRlo y0ZaMtGWjLRloy0Za/36MtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy0Za MtGWjLRloy0ZC2JF+24gXEC4gXECtRmRFXmNFTk7ZqpbSQWO4KOWGWsB8xdPhKzcCSSv2skN jtZO8nrHbllO4UVdsQ+gHt9PHLJwr9eB/wDo8y11GCqq3ULEt9vl9NxEvBD2+lIWoRjqHgv/ AMjypp464FatdQer02Gsr/8Ah1Rvl8wPb6JEwsLPIXhF/wAj1Z+rRiXTbZ24vStdTYCh6acx sLCy61+I2/Mnjv8AqDaOJhaKpGAhA+yDfGTWTWTWTWTWTWTWTRGQtg5H/wA1k1k0N7exk1k1 k1k1k1k1k1k1k1k1k1k1k1k1k0W3Lk1k1k1k1k1k1k1k1k1k1k1YstWj/wDr6qq9Uaw9M2C3 k1k1k1k1k1k1JO0LMRE1i4NUXku9TVWmNQcmsmsmurCRUKZOcPkDUgCQKkEcgVII5EHt+8iY WEXN/p+kch3pJYhr2vWMxjE/l9EiEWs9UjjUHT5JpP19IP6+vfbZ6k5SR9KeR3oW6r1+lgBf beHej0otqfmB7fuImFhFzf6GYxicsl4oohhj6j+H9W31CGqrMNuxXrFtX+39JupVnsK3aCpD B04rigpQVn+s39fXvoRMAyXZ7p/xMpqtViqh6BjvH0R/6PMD2/aZsDCDk/0nsSHMNBzcRYBM xjG31COy4PkPSsX69Zc9++qvTYayuDvT6aW1P7J2PqHU36XZNS9JgetH1OaAIKU9mf7ep/4X ZpOKIZ7pjamsSHHVuQhxX1xX1xX12lol2My7GZdlOuC8K4r64r6eS3VLpLs1nyO7kK21ieOG Oado3IRQGGOQFyAuQFyAnlFmBxd+QE80bNPfZ2qxxwRy3K8DH1Y5XalJZLqEUUUteQO35AXI C5AXIC5AXIC5AXLGp+r141tevKvQqQLkBcgJzjIelFiLkBcgLkBWbIQ1+kgMdbkBcgLMO/IC 5AXIC5AXIC5AXWnF692VpR5IoYunf32uQFyAuQFyAuQFyAuQFyAuQFyAuQERRGNSAor/AI7s xD/HQNMFF2UdIh+ge36kWogOzo5BjERO/KEYRtdszSWYOkwg7Cwsurt/XSfNP7rFuGqOLXVX gqQ1m+2m2l6WUIR76uu+rrqM/dONysI99Au9ZfyMbL+SjT9Ryu5tih6gLrvF3rLqErWaVFiO WwUvUbMbRQR8oLlBcgLcVuK3FbitxW4rcVuKYmdN8vmB7frN+V+mltHKY9Py4swjcsjVr9Lr OEf16o2aPTnzV+29f4FV6Z+fvYdeqm/JZ4RZWLobhA+nAK4BXEC4BXAK4BXAK4RXGC4gVgNK 8d2WwmgbDRAy0FaCuMFxAuIFxAuIFxAuIFxAuIEUSjLYvMD2/WewMR8dq2oYQgCxdgrLvrlt RdJZy+y8O1Hpb/0yWoYj7+uu+rortcRsdQsTPTanVfv667+umvV3T3a7Lv667+umu13Xe10b iV9rIVYWit9TevVhrD6ZDsNKiFNvWb5fIC8BEF6MyjuhISD2/SSRgQV2OS9eaoPH1Syq/SoI fvMdw6SWBqRtYkOKtGM9gLJ1umjGPbQLtoF20C7aBPVgdNUgZdtAu2gT1IHXZ109YYJRrc9z zW+XyAk7qRgklrRsZxOOUANjRlJLGIx3qZKXqlcVRpER6MtGWjLRloy0ZaMtGWjJi4S7kwUf S5JnjrRQjoy0ZaMtGWjLRloy0ZaMtGWjKUMCMbMOjLRloy0ZaMtGWjLRloy0ZaMtGWjLRloy 0ZaMtGWjLRloy0ZaMtGWjLRloy0ZaMhbEnmB7ZpmJsF1Of8Aj6mIoIoW9K8/FZ6dU7aD/WN8 vmGWI+yO6UUQQh6h0I5Lv+tb5fMCLcv943y+SbuwRgIQPsg3wxG6YjdmI3bctHI2ZyNmcjZO RsnI2TkbJyNk5Gy2POx52POx52POx5YjdMRumI3TEbpiN0xG6YjdmI3bctHI2ZyNmcjZORsn I2TkbJyNk5Gy2POx52POx52PLEbpiN0xG6YjdMRumI3TEbsxG7blo5GzORszkbJyNk5GycjZ ORsnI2Wx52POx5HPJ5QVII5EzYTNhM2GZsNq2jtlnbLO2U7ZTtlO2U7ZTtlY/OPzj84/OPzj 8s2EzYTNhM2EzYTNhM2GZsNq2jtlnbLO2U7ZTtlO2U7ZTtlY/OPzj84/OPyzYTNhM2EzYTNh M2EzYZmw2raO2Wdss7ZTtlO2U7ZTtlO2Vj84/OPzj8+W8tmWSCZp4l3kzFFKE0aivPxiTGNm bgrd1LXmVibhjrzSGSszvGUVyCY1NMbS1bcdqNd4Hd/SxbevZExNpDaOOCaYrCnlaCBrMsci sTcMcFzaVWJijUNqKUlNObS1rQ2WU1mVpIzaSNd8PJFKE0a792QkJiqtwbTfStf5PpPM8bVZ DOJTzFG8NhykU88jS1bcdqPzJazlLBDwipmldoIWgiT0nGSOMYov2xdPD6E81Um3sW0QEEce 1qaZjeGwDaVgOWSxEcxC0TVacMscdiI5i0dlWrBVCzAUpPmZlZqyzNCFqeFPWn2iaS4J7aTU psVI5Zo7HI9ezVevJVrkEsg7xw2CihpxzaXh3oxScd2tCUQ9QDatA599Wh4IJuZr5tPM8Qcc bdx3leqVpf8AUHdb1d5ZEwSTwVmnsqxydsMrDWghkef/AE8gckYAMYKaEZwZsMpYAmf6R1I4 5/pHUjjnRCxDWrBWjUsbShFEEIKaEZxABjBTVo51+mR1o5ZfpHDHEyf8tHEEMaMBljEWEUQ7 DDAEDKQGkCKIIQUsTTCADGClqQTH+mRU4Cl/9j//xAA0EQABAgMFBgUDAwUAAAAAAAABAAID ERITITFBUQQQIDJAUBQiMEJSYaGxJDORU2BwcYH/2gAIAQMBAT8B/uugymi0i/tjjIyGSJm3 tQEzJCTb93s7SG3TKmBhv9naXm+XB7O0Q+bhHIe0NuBPCOU9ofcKeEcp7O0TMk8zdwt5T2eH jPibgehIOSk/VAHPpD5RLiZgehhww/3ALw4+YUSHRnPo+T/fGzPoZKRUuha2amG4egzP1y8A y3AkYKt2qJJx6F1wp9FmfGXAYoGYnwlwGK8zvongBt3R4rkuGO6Hs7B5YnMR6EPHiL8moMle oeG+udzVU43SQZmdz+UpuHQgTU6bgocMxDIIOhwb2+Z32WzP/UNqz4iZYqou5VBFMT/m+s5B VlvMpV3lAS3QxNxaE7Zi3Fw/leDB5nhDZmj3hWMPOJ+VYwv6n2K8O35heFnc1wKZc2R6Emm4 KFCq8zrmqLHaGUQxd+V5z9FBAZEafqFFEojhvJkpudggwYnc39xqbCe4TaE6BGAuaU3ZooEq Shs0U5LwkbRHZYmV68PE0Wzw3Q4rnuGAUi901Q7RUlSKkVIqRCc4vNTuggtLnXKUODe7zO+y i7S5/MUASZndgtoY50dwaF4eL8SjCi/E/wAIbLGN7mleHi/Eqwi/Eqwi/Eqze1wJC2iJZus2 5Jr4mZVo7VVu1Vo7VWjtVU7VOdEncVW7VTKrdqq3aqt2qrdqq3I+uGk4K2bDEmlSLryg0DDg 2h9lDtM3S/CtIrs5K0f8irR+qtX6q1fqrV+qZGiTlNO5ietaKjJRHVeQcv5UhxPiOiSqyu7K DL/GP//EADkRAAEDAQQGBwYFBQAAAAAAAAEAAgMREhMxUQQgITJBUhAUIkBQcYEjMDNCYbE0 RMHR4WBwcpHw/9oACAECAQE/Af6rM7BJdlNlY4loPhZNNqhjEjC543lG0MnIbl4U94Y20U4v m7Fmg4rBfmPT9fCXzUdYaKlWJJCLzDp/Men6+EE0FVorfZ2jidQ/iB5eEaUaRFAUFNR3x2+R 8Im7T2M9f9asnx2evhEHbc6XVk+Mz18HldZYXKBtmNo1Zfix+v28H0rayzmdab4jP+4dxaW8 QrTMk4jh3Rntn3nAYfvrT7zPPuLnU4K9PKU11rh3PbpH+H3/AIQFNg1tIxZ59xLmjEq8Zmg4 HDuMslilBUlWJJjSQUH39xpPyeY9+I3EV6HRsfvBdXi5QmxtZuincCQBUqL2j704cPc6Tg3z GuGl2CIoaarWl2C7LfqUwkv29zc4NFSg0zm07dy6HSHFuHuNK3B5jWDOLk59dikxr02KbXKy 0baovrsHQzY4Jwoe4ucGirkGmY2n7uX7pzw0Kjn47ApWeyNNYAnBWQ3eWmG1BX6jpsDiVYDt xVsbGomuPRIeyCmy1wBXWSN1pRlJ4FW3cqtv5VeHlKvqYhSb1e4EhoqU1pmNt+HAfqnvpsGK jiLnVcuwPqnuLmkfQpm1o6QKqjW7yMhwHRpP4d3p90XtGJTZIydpTp2E1qusR5q/jzV+zius xcyllY+MNaUXsjbiusRcwV6w8VeMzV4zNXjM1bYdlUAAKDuGlu7FnNdp+wbAo4KbQiQBQdAx UTgIxVXjM0HMPEIzxjY0q8ZmrxmavGZrSHgwuoVo+jtntSyZp2i6PwauqQ8qOjQn5V1SHlXV YeVXEXKE2DR6bWBDR4h8qu2ZK4i5QurxcoXV4uULq8XKE7RoiKWUwENo419/JI2MVcmQSyvD 3ilMAiQzYEXE46kTbb7OVVZjbwqrLclZbkrDclYbkrDclpUbbo7FC2zE1vfZHhjS4qCOhvZN 77fyrR1gA0GnHwV8YfSvD+2P/8QAQxAAAQIDBQUFBwIBDAIDAAAAAQACAxEyEiFCkZIEMUFR YRATIkBxIDAzUoGhsSNiUAUUJDRDU2BygsHR8GPhsuLx/9oACAEBAAY/Av8ADjB3cRrXmTHu FxTPA8MfQ8i5yZ4Hhj6HkXOTPA8Nfcx5Fzv8L2ozIzTf3bDCdJvUnmtl2XuntdDlbJbcJDmt l2XuntdDlbJbcJDmtj2funtdBLbZLbruq45re7ecRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRW LUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLU Vi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi 1FYtRWLUVi1FYtRWLUVi1FYtRRF+4cfO/U/n+On0Hnfqfz/HT6DzBaHAubvE9yMNsVheMIde jDbEYXje0G9GG2IwvG9oN/Z9T+fN9VZdvXP+AH0HmNoDAAO7ZcP9S2J1ppZa/TaKhcd54rYO 6l3sx67vEv5OsS7y0313eJXAZrcN54qluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5ql uapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluapbmpSF3VUtn6rcPWaHhGapbmqW5qlu apbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluap bmqW5qluapbmqW5qluadPkPMBzdnhBw4hgRiNhMDziDb0XthsDzvcBei9sNged7gL+z6n8+a mi7n2FD08+fQed+p/PmrA+ql2FDz59B536n8+Y6qpde0oefPoPMR2RXghrGuAA3b1CjRHRAy JuFgWfTmtn2mJEtNiytMkLp8ls0d8W0IxE2SEhPkryAqhvPFVtzVbc1W3NVtzVbc1W3NVtzV bc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVQVpxAA5qtuarbmq25qtuaP iGaE3DNVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVb c1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NOkZ3DzDozo8M2gA4d1wH16qGx0W1BhmbWWf8A dQ2Pi2oMKhtn8lQmujWoUIzY2zlM9n1P58tNzlz9ooefPoPO/U/nyszuHuD6IefPoPO/U/ny h9yfT+AH0HmHw2h3gkZkb/8AskNnvtkT6BM8Dwx9DyLnJngeGvuY8i53Z9T+fKge4P8AAD6D zEZzYcUW2Na0uhOlO9QAbBufaeJ8Vsuy909rocrZLbhIc1sez909roJbbJbdd1XHNcd5xLFq KxaisWorFqKxaisWorFqKxaisWorFqKxaisWorFqKxaisWorFqKxaisWorFqKa2/NYtRWLUV i1FYtRWLUVi1FYtRWLUVi1Fcc1i1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtR WLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUU70Hnfqfz5T0919fPn0 Hnfqfz5OaLufuj58+g8wWhwLm7xPcjDbFYXje0OvRhtiMLxvaDejDbEYXje0G/s+p/Pkw0cV L3R8+fQeY2hrAAO7Zu/1KGdnaGQoMyw/Mf8AhbB3Uu9mPXd4l/J1iXeWm+u7xK4DNbhvPFUt zVLc1S3NUtzVLc1S3NUtzVLc1S3NUtzVLc1S3NUtzVLc1S3NUtzVLc1S3NF0hd1VLc1S3NUt zVLc1S3NUtzVLc1S3NUtzVLc0ZAZqluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qlua pbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5p0+Q8xabs0EHmGBB zdnhNcNxDAi9sNged7gL0XthsDzvcBf2fU/nyRPvH+fPoPO/U/nyRQ92/wA+fQed+p/Pkmt9 4/z59B2OiHc0TXw4n2Xw4n2Xw4n2Xw4n2UFwJAMUB0hO5QIcMvskOtB0Mj8prn7XtIcflgXf /FBkA+Jje8d1HL6rZRBjFjIoJm0Dl1X83iP7wFltrpSPvNobFeHNaxrgAN2//hbPtMSJabFl aZIXT5LZ9piRLTYsrTJC6fJbNHfFtCMRNkhIT5K8gKobzxVbc1W3NVtzVbc1W3NVtzVbc1W3 NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NAzEgq25qtuarbmq25qtuarbmq25qtuarbmq25qtua d4hJVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W 3NVtzVbc1W3NVtzVbc1W3NVtzVbc1W3NOkZ3Dt3BbgtwW4KF4pWHh6hRbXw53c5oQ2bTCsjd OD/9lEiR2Q4z3He5m4clD7qM1vdl1mbJ3HhvRjRYneRCLM5SAHvHRXR4brYDXDuuA+vVQ2Pi 2oMKhtn8lQ2Pi2oMKhtn8lQmujWoUIzY2zlM9n1P58jNWjvPvHefPoPdvaDewyd5L6n8+R/a Peu8+fQdjrFUrl8Zq+M1fGavjNWzstFrHxJOIMuBTyIjzBgxWgzdO4i/JQnhxltEbi+zJsrh PhuTIZjSB2gNkyKXECybpqPCaXzfGa0SfKfgG8oQzGLQNrsXRJ3Wd01tMK25zGOFm0Zyu3eQ +p/PkP2qQ967z59B7dl7Q5p4ELuxDZ3fyyuVgsaWfLK5Na2GwBpmABuRtwmOtXmbd6hkNY2y 6Z8NQkRL7qzDY1reTRL3kPwRAyJcx53FM8Dwx9DyLnJngeGvuY8i53Z9T+ff8mqQ98fPn0Hb UFUFUFUFaeZDd6prQ7xEykQRenTfS6ybuPJWi+QtWaTOfKSjd5cxrmhtxmZgFB9u4usUmc+S JYdxkZiRCELEWl3/AHPsfKHIgWmAmpvAr+dWcNPXlmi3aG934bQM5z5hQ5bN433yLrm+pVqz ZIJaR1HsXb1s4ayMIwP6loGyLr5cMlsuy909rocrZLbhIc1sez909roJbbJbdd1XHNcd5xLF qKxaisWorFqKxaisWorFqKxaisWorFqKxait51FTJdqK42fVcdRWLUVi1FYtRWLUVi1FYtRW LUVi1FYtRWLUVi1FYtRWLUVi1FSvzWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLU Vi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRWLUVi1FYtRTvQdu5bluW5QIjG 2jCfOzzukou0d3KJba9jJ8v+lQDIuiNf3kRrX2SSd9/1UN4gub+sHOtxLRlZKiua13duigkM dIkWZflMnCPi2kPbN88B+6jxnssd4RJp6BCLZusmY6ow4e9/hJ5DioMRkR8QDwODrNzVZl/R rfff6uWd6IfNkOHfDlxdzUNvcumfiGG4faZ4oNEEwgMJl7n6n8+86BVXfw6RNp/yhMhxWWGP Fwkj6D3gmAZGY6eR+p/Pnh5u1FcGhWNlaYcLi8q0fHE+YrZInO77/wDtH0Hnfqfz7qZVp27y bffWIDTGf03J5iABzXcPd91s472L03Lvtudbd8ik0SA4DsgxPleif2jzOzbU5kNzovETtTI5 8fRbHtEMfrvItO4vmL5rYY7PixHNtu4umL5q4DNbhvPFUtzVLc1S3NUtzVLc1S3NUtzVLc1e G5q0RdyVLc1S3Nbm6kITWg9ZqluapbmqW5qluapbmqW5qluapbmqW5qluapbmqW5qluapbmq W5ptwn6qluapbmqW5qluapbmqW5qluapbmqW5qluapbmrcSyOk96/utn/KlDhN9Z3lbXDAFX NUtzVLc1S3NUtzVLc1S3NTiGG0dXKYDSP8ynEsz+UG9Sht7mBz5rwMba4uJvVLc1S3NUtzTi QPCQd6Y4/wB23zPeNZfvF9w+ittZfwvuHoFbay/hfcPQdn1P59xMq07L2O6hXQhvctmsC6fv 7T3Bo5lM91NxAHVWIH6sQ7pbl3+3G07gztjt+Zv/AB7XcbG3vInzcF3m2RDEeeAK/ocabDhP Bd5tB72J13e1GH7ZpvQS+5879T+fbvVp3bacZBd3CFmHxcgxqgu5O99KdqJ8oT9q2g2Q2li2 Y/tHtiCHzJ48Oy27fhHNfzja3Om7c0KcOHI8/Ygn5m/89pc4yA3ld1sQIbxiL9XbHuVmGPU8 T7lzeYkog5Hzv1P59u0/Lt7jZ6uJVqPFL+istEgi57gAOJXdQwZC+0geY9343zd8o3r9Fvcw vmVo+OJ8xUYfsKg9CR9/ZdCZELGQhvCsP2xzoXFd3DFl43OR2eLCc+O24IbRtvDdD9rY4n7v 905/JBzYTZFN2WKL34QgyG9jW8l8Zq+M1fGavFtOS/rTl/WnL+tOV0cFfGavjNQdGNtnGS2p o3TmPMsIP9HLXS/dLitn2mJEtNiytMkLp8ls0d8W0IxE2SEhPkryAqhvPFVtzVbc1W3NVtzV xBVp725qtuamYjc1YgTLjxV722zvM144rfRWdlgz/c5B+27UJfICoHchoEiLlDm4Ujiq25qt uarbmq25qtuarbmq25qtualDnFd03K97dnh+t6mS2I/m4qtuarbmiLbb+qcw4Xqtuarbmq25 p8S0JgXXoxHuFuIZ71W3NVtzVvwWuarbmq25qtuarbmq25qtuahua4Eh6hQ2OHjvKrbZaOai 7ZFIHBoKrbmq25qtuarbmq25qtuarbmq25qtuarbmq25otc5pB6p5aJwrMrU/MEHcVDe1sgy fhUNj4tqDCobZ/JUJro1qFCM2Ns5TPZ9T+fYmrbuy08yCtvugjcFJjQE3Y9ldJ2J3JWopMV/ XcpNAA6dkF3J8kz25xHeg4lX/pbN+V+mwT58fa2pv71N5kqjkqjkocJk+7nNzkGh1wu3K4k/ 6V8KLkvhxFQ9ShwXEq06B4ei+FEn0XwYi+DFyTmhjw6YIBahEiXWGAXruGTZAbvceKENkg0L et63qoKoKoKoKoKoKoKoK4o+g879T+fYDefZ3WzXni5Wo8RzygAJAIvNWEc0doifFi3/AE9g n5XAr0Ptd1C8cc8OS77az3kU8Dw9xtHUNKlwbct6ELZf1YhP0Q7w+LjJbyt5W5cVvK3lbyuK 3Lcoj2VNaSFChQWjvTUeCEzMrcqQqQty3Lcty3Lcty3Lcps3oz5ed+p/PsF5v5BfqO7uHyVl gX6j7/lG9S2SDZb85XebVEMV/Lh7MYftmnjqrL3X+ir+y+J9lO3PoFYhfos+Y71bMQvinEWq v7Kv7L4n2XxPsq/sq/svifZfEVthBBh8PVCLFvc6+Q4lTinuYHy81KG2XXj7wtO4iSMjaccX v3eg8ywd3Ea15kx7hcUzwPDH0PIucmeB4a+5jyLndn1P57eZQivvA3BANFqK7c1eJ7YLeitP /Vfzd7bm8xJPnyBUWNEaCCbpq09kNo5kLudh2cE/PJTjHvH/AGXwmZL4TMl8JmS+EzJfCavh NXwmZL4TMl8Jq+EFNk5OCaXD9OCMz54+g8zajMjNN/dsMJ0m9Sea2XZe6e10OVsltwkOa2PZ +6e10Ettktuu6rjmuO84li1FEhxkONorxxvsVZgiJEdwvMl/Otqn3h3A8Fi1FYtRWLUVi1FY tRWLUVi1FYtRWLUVHZ6t+6Gy7LDL4oqM9xQftsYu/aCpQ22R0KxaisWorFqKxaisWorFqKxa isWorFqKxaisWoqYnmuOaxaisWorFqKxaisWorFqKxaisWorFqKxaisWorFqKxaisWorFqKx aisWorFqKxaisWorFqKxaisWorFqKxaisWorFqKxaisWop3oPO/U/lETlDG8813bJjZ2b3c1 LuGL9OG1vp7uLLfO5Td8R97v4afQedlzJ/KDojrMAUtG8qxDbZb70bS47sP8OPoPOm3un/HT 6DzRI3yWwx2fFiObbdxdMXzVwGa3DeeKpGaBsi/qgbIv6q3ZEpT3omyLuqJsi7qqRmqRmqRm h4Rf1Q8Iv6oeEX9VKyM1KyM1KyM1KyM1KyM1KyM0fCLuqPhF3VHwi7qqRmqRmqRmgbIv6oGy L+qt2RKU96Jsi7qibIu6qkZqkZqkZoeEX9UPCL+qHhF/VSsjNSsjNSsjNSsjNSsjNHwi7qj4 Rd1R8Iu6qkZqkZqkZoGyL+qBsi/qrdkSlPeibIu6omyLuqpGapGapGaHhF/VDwi/qh4Rf1Ur IzUrIzUrIzTp8h5u21l/C+4eg9gDkgOSscJSRHNEc/YHRDoh0U1NTU1NTR6o9UevsAckByVj hKSI5ojn7A6IdEOimpqampo9UeqPX2AOSA5KxwlJEc0Rz9gdEOiHRTU1NT85G7kwx3TrNhwq +vBWwCDuLTwPZCiul3cRxHdBhLpDihEhmbT2CLEtPtNt2YbPhjqg5pmDeCokWU7ImobY7mPZ E3PYJWf/AFf2TAtOJDWjqokOK1rYjPlNx7GQocu9ibi7cFYY+bpT3Sn6dggwWtMSza8ZkJIF rm2peJs93YYDmlt9kP4EynLta1zJwrM3OHBTa4OHRF7pyHJOZGaG2m22N5f9u7HxXbmiaa3a YbWB9zXtdMT5HsBAtOcQ1o6p0COYbYzTKQdv7GNYAXxHWWz3LuxEaYkrwP8AbsEGCxrohba8 RkJJ11mIwyew8Ox7YENru7bafaMvoE143OE+xziZQWmxum5zvRB8N1pp7GRXBg2d7i0OtX+q DmkFp3EdlJY+U7J5cD2lscCE++V9xv7AGNtxHUhERSO8Y4tdLsYxjQ6JEMhMyCMGKzu4wvlO YcOY7BBgtaYlm14zIAIOa5tqU3NBnLzvfQondxdxMphw6hOm605zrTj17B3L2NP7mzQYDPiS eJ7Hu2eL3QiVizPJNhtpaJBSKswrEOE6vw3n/jsdEjnvIDnEn/x33H0UbuXygulaitP2HY2D /KB7yE6X6nyO5eihxpMEKETYLTVwTxDMn2TZ9Udn2stnZPc7Q78FM2mI1jJQ7LQxQ2f2U/1J GSjQYs3s70sYDvKnHiue89dyhs/sp/qSMkAI9gNiuhNJvNk8AiyHOxOYB4KM+I5wY1n6dl0p HmtmLXgbS1of9OPY9xaXPMSTPHJoZ/2ai7I/u7DHWC4mZHH69kKLZtR7ZLrT/DLl+EP0YcKG ItokGZLgf+eKdZqlcm2Q4vsWnudFxdFssWJYDIbZts7zd9k8QfiSuT4zGP7uG2drvvF1ku8c 0NFmyAHTnfOZTm8xJMg196wC3/d9Hf7Jro3hk2yIYO716qMBOmdy8LBGiystil0g7of3J5fK 3EfbIbuCHic2T2mbT1X6cKEYgDgXTsh/Uf7oM4zJMuqotk/BOFvOfVGHZaNpgkWIjLgAf/zc g0vLzxceKiCwO+wxHDwBnTqordpdLu4psiHwdvn9+yIGsaI/9pEiCYPKz0X85Emh4lFZ+4XT HY5sIS2iHJ0Rz3Gdvotn2iL3YDW2hZ3mY+yid18SybPqokaBBY6A2sRCbZ5oRorGQ7LLDWsM /wCEFkyJ8QgxgDWjcB2WHzs8QOKkOxlu8NM7PA9r415c48cPp2vjXlzjxw+nYWncblZbMni4 7z2WCXD/ACukrDBIdgDi8S+VxCDGCTRuHYLdq7gHEAqQ7A99oy4WjLLtIhsDZmZ9eySDIbQ1 o3DsLHibXXEINaAANw7C2+/kiGTv3kmZPYWkuE/lMirDBIdllxeP8riEGMEmjcOy09k3bp7p qQ7O8MMWuPX/ABl//8QAKxAAAQIFAwMEAwEBAQAAAAAAAQARITFh8PFBUdFAcYEQMJGhILHB 4VBg/9oACAEBAAE/If8AzhOFYBB57uJGYCjI1gwNSL6agKMjWDA1IvpqAgwC9jPUi+moH/li WDprgMAnQ0A0HgfaeQ96ATUJC9E8h70AmoSF6InTqIAQLQkL03Qpz4EEMpMg8ndV7FVXsVVe xVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FV XsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVex VV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVA3Fjk SO/Wzrov+7Ztz1s66L/u2bc9Qy/huJ0nCmAMAIeFJQqJDwpKFRIePSddF1Z4c0k8kfuocIkT B36+zbnqHrIt0u7ygaLE3ilqg1gF2u7anxfbr4WVSL7dGE53Z/ETrc9NFlPCynhZTwsp4WU8 LKeFlPCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFlPCynhGDEaZ P0gUjc/hEb/OH9KA2WvJZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFl PCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFlPCynhSCAdIvv1BK+OBRB7spoHAAXlSEqiC 7lSEqiC7n0nXRdUI5aKIJl676br7NuetnXRdUYUkTIAAkPX/AF+vs2562ddF1Emmkg0PxKmE Smfwf0evs256gRnsDDz5mQQZ3ckdwJAGQ1MCnipgYCLh04Qm6Y2Pbgi4dOEJuvvMKCN+eFYw sYWMLGFjCxhYwsYWMLGFjCxhYwsYWMLGFjCxhYwsYWMLGFAdzsXWgyAJYwsYWMLGEMAc7BA0 GdimMLGFjCxhYwsYWMLGFjCxhYwsYWMLGFjCxhYwsYWMLGFjCxhYwsYWMLGFjCxhYwsYRUEG ke/UCgIlITJFQXTXw6sC6ID7IW8x4IyYRIsDsER0RmMA0RFuw9J10XShc10TiAfRTIHuQAGA Yfj9f/gOzbnrZ10XSg/Sh7H23/A1m3PWzroukeVEw7cv7H3Skd+vs256gTuQIzAF5fJRBiTI HgJ3UZGsGBqRfTUBBgF7GepF9NQPSddF0jDdyqSD2PpL9/X2bc9QQYQbTBnhARCZKSxoixya 7dk8h70AmoSF6InTqIAQLQkL03Qpz4EEQce+blV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV 7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FUBgYpuRVexVV7FVXsVVexVV7FVXsVVexVV7FU 6RksinkTPoYVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7 FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVQRA9Yvv1s66LpBGo9kzKZ16 zbnrZ10XRgIUggJf1e19rr7NueoZfw3E6ThSMCAQ8KShUSHhSUKiQ8ek66LoyETSCGGntfb6 +zbnqH6GG1F3ImGgM2yIeU9V2u7anxfbr4WVSL7dGE53Z/ETrc9NFlPCynhZTwsp4WU8LKeF lPCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeExhDAx/wsp4WU8LKeFlPCynhZTwsp4WU8LK eFlPCIIxHVn8WU8LKeFlPCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8 LKeFlPCynhZTwsp4WU8LKeFlPCynhZTwsp4UggHSL79QNAGIBEfSN3hwIj6UhKogu5UhKogu 59J10XRUkCaI7n2/tdfZtz1s66Lou8IJp09v7XX2bc9bOui6LuA+593r7NufQIpJZgUWH5LD 8lh+SwvJRoAMjE4Zn+E0PCjgsA0g+k/otwEjHQv/AGgtwSNgWJfd8Ipz+YJAAiQqKeRYQCAQ WhqPcYrCTDvmZE8VMDARcOnCE3TxUwMBFw6cITdMbHtwRcOnCE3X3mFBG/PCsYWMLGFjCxhY wsYWMLGFjCxhYwsYWMLGFjCxhFI1TeCxhYwsYWMLGFjCxhYwsYWMLGEUSApF1jCxhYwsYWML GFjCxhYwsYWMLGFjCxhYwsYWMLGFjCxhYwsYWMLGFjCxhYwsYWMLGEVBBpHv64ZYZYZYZO+x x3Z4faluYMGgOFGeGIJmj8IYAMJgDvZQPXzi2HZJKDYUGumA9wP4CJB3JHvIW8x4IyYRIsDs ELeY8EZMIkWB2CI6IzGAaIi3Yek66LoRGLwiR/5eGzbn23YwgGkSH/RHRTrougJAOZKPu99X r7NufQQBMROOhVr/AIrX/Fa/4r3/ABCzvXjOAPo5ARfXUqRATq4gxknoDEOA4aAGJhhuhmPQ RgkQBqinTpIRt3TSKZOo80czFYmO/wDEDjnRTc4uMc9BOui98kA5LBEsRAUAQGHu/U6+zbn8 zWch0CicUQYiP0UK4M4CzsmkLEgFuELEAQCIuEASmmpNDAcKJSsQD3DY9WMOsTu4kZgKMjWD A1IvpqAgwC9jPUi+moHpOui94DhLBdqoAgMPe+l19m3PoSwcyWcWcWcWUQa7CxgSS2AESUTG 6E0YHIIIgW3Qg9iiMrs3MdEFmkgkANdzHBZAOg1uUI03jsiAwxAiCC8DOCjqzCCEVBiEY5Mj ZgQP4RLBzJGrzAz6EHZa+aKOOnzkQAAadbSExtqnDGaJNwdidGUamdMuxGMdfwiYIIOjSVmv ZOdDGSvIe9AJqEheiJ06iAEC0JC9N0Kc+BBEHHvm5VexVV7FVXsVVexVV7FVXsVVexVV7FVX sVVexVV7FUxO0qmUAs1RtHWRQAGDRTkVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FV XsVVexVV7FUyYxtz/Kr2KqvYqq9iqr2KqvYqq9iqr2KqvYqq9iqr2KqvYqq9iqr2KqvYqq9i qr2KqvYqq9iqr2KqvYqq9iqr2KqvYqq9iqr2KqvYqq9iqr2KqvYqq9iqCIHrF9/QgEBkVcKu FXCrhUStF4BAlA8HijgnZ2LwsXMnIZNPkc2AEwAREVaIg7RKnAcuTqZAlCF0LkeMBcNBRScb IsMM5LyawqhzqMgEgMOWgjIGFcMSIL/R+UBsugMgPzfDoCnyFHdQwEiAtOax9mhJkYoEH/jG 3dMH3A8YUDfYIEKNBiP0T7M66L3C5iqcOR2IAAwgOgMvbrXD5/8AnZBImCWKRYv4Vm3PuHDO RgO7cdDOui9t43MAmjcxPRfT6vYlDzPZF8mII/PCaAUmXYLv4FLNuetnXRe2EkqGQ6P6Hukg AklgE9sYC6KZgQgaHtxb2GoD/U+aWToDvwELiQQAwHoJFz/2/iMAJH+nUEQRActJPqMxnMm6 Dsh4T86qgEN3+If3mFu5vRkYTndn8ROtz00WU8LKeFlPCynhZTwsp4WU8LKeE4rXsmgDYRZP /o8LKeEQByIW2QQGEtp/pZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFlPCynhZTwsp4WU8InRg IDBZTwsp4WU8LKeFlPCynhZTwsp4WU8LKeFlPCgpNJvZBNG1pPc/pMfTqb/IyKDw5iyRNFlP CynhZTwsp4WU8LKeEInKAgv9IZOkiHA/SfiOhyXhkEL4mR/bXwmicW6vpZTwsp4WU8IUGII7 VtqplyMg9+pGWIkxLhmQ5h4QQ3FzFLs4jDwghuLmKXZxGHj0nXRex8bAtN+nqJAEksBqjUh8 yQ8YgE7x/wB9+rDVgiBMIg+1VRRMmxuGCMOV9bojvwgAAADASA9KAe/bn8osTBkQ7cyR3RwB 5R+9MlH7QUcfiZgP9QDBh+Pfb8I/xV71qJ10X5vrwC036D1IQx6lPROxtb2QoWA+1a7Tj3gp PZf32TTRAt6E7aLs/fEPyJAEksBqpOEAdez+hzGOG6QsjyvCQTURQzy5/Cl2/oOPUfYJyaIv HU6GP2m88mGJ/ZU1kzfZKwyHJcx9bOui/JwGegXxK9QSUM8aDS7Yf6gwAEgFMKMRgg8seLB/ CoWH23keRf8ACkX/AFmJ88IwN72ewVVWPhMu8H+/iySCdI6/f6TA+EBJf4THMQWJJrRFYl3+ +/8AUUcfS7/l8dHwHKAf0/aP0yjZQEQb+XVCIyQYVr/itf8AFa/4tRjuP+K3PKtzymoh/wA8 qQFVP+K1/wAVr/iGMKW2PpTxg9lzyOpgPNJow/hsnipgYCLh04Qm6Y2Pbgi4dOEJuvvMKCN+ eFYwsYWMLGE9SmwKieNAmMJrCOxFoIBCzKOjFafCfAlBc/ATt5W26PABFngIHwDqd0U0ywXo WMLGFjCxhYwsYWMIgDkQ7URNIf2Ws7pAX9/Sb9qN+lhCxhGCwDSJ4Amn64WMLGFjCC48A1HR RmNHibT+nysYWMLUIbSu3dYwsYWMLGFjCxhaCwRp/ijpAEeS0y+GCIHUJdJWIfKxhYwsYWML GFjCxhYwsYWMLGEABTEEEFRAGi7sR+j1Aw3AxCgOUJi7s2ujIW8x4IyYRIsDsER0RmMA0RFu w9J10X4PW1FnOw9DcEG6iIP7ibZaBPGOV/Wid2USf5coXFUgDD0vacf4u0XH3+cI4mTFETc9 ev6Q6Bt2Jefy2fDh8lBjcSwg6zVZqhH4DCv4iogJgfJbzbAkZoMFJjEHcBY8coPauf8AFLsl oEQoLWAHUA4OfSgD9mAihuwzJFm5QkI84jX2RLALACKuBXAgbSs4s4s4s4s4s4s4s4iTBJ7q zbnrZ10X4E4epQ2AF+t4hDpEugpgGACKsIG3SetMwZj/AFP8LzIt/VCN0fkE25EBHKiDHIh5 x3boBgw/OlvqE7DoeZif4iMSTAGpQQktFtVCZDRf1AIXJHc/AAABzd6W4UMcbwAE5QOXhAH4 QoiMRMnW4O6xixiJluFXCrhVwq4VcKuFXCggSARiwYsH762ddF+AEHCG8VOPGnXxyvKAdSgc DzEJr25p+13j8sVL8O5X4RT/AHH6UNUZgEVXfNA+zuaKPHHJTLASZH+kvCIplCIdlXfNV3zW xO5LRvgiq75qu+a0b5IIh0/BTQr4lqEfSIITCIEOmgJ8u5TK5anEvPuCnxEt33kGht79ir1J OFYBB57uJGYCjI1gwNSL6agIMAvYz1IvpqB6TrovULuyAX7mDboVTMimUdaQH6j9ohFmGR8I AAMID8qySRGYPPtNfEAD3ojcazACcE84LduShajNHKwVYKsFWCqbeAMpN5IrBVgqmXggoCR+ OEDpJC08g3dP111m3PUEsHTXAYBOhoBoPA+08h70AmoSF6InTqIAQLQkL03Qpz4EEQce+blV 7FVqAAbQ+06mNsf2MtsaYDkj5zHOL1qvYqq9iqr2KqvYqq9iqr2KqvYqq9iqr2KpgHDkDG0k 1AxNtqQoi9PSU88LtSxQq9iqr2KqvYqq9iqr2KqvYqq9iqr2KqvYqq9iqr2KoQHJfUihyU6s YVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV 7FVXsVVexVV7FVXsVVexVV7FVXsVVexVV7FUEQPWL79bOuiTQM5lsEH1LKODAANKKZ1ZCPz7 cdtcO4B/qhbrB0p/zbNuetdxMXdA5Obf2JOyDxgaD3THCREkCRI/86zbnrXDE5DQxl/3bNue qAK4EQEP7zC3c3oyMJzuz+InW56aIS4mkePhCayD3ZCayD3ZX2PhGayD3ZGayD3ZCXM0Dz8I S5mgefhCXM0Dz8IgE012RAJprsiATTXZQMaQTdqqBjSCbtVQMaQTdqqJjQAbtRRMaADdqKJj QAbtREAmmuyIBNNdkQCaa7IS4mkePhCXE0jx8IS4mkePhCayD3ZCayD3ZX2PhGayD3ZGayD3 ZCXM0Dz8IS5mgefhCXM0Dz8IgE012RAJprsiATTXZQMaQTdqqBjSCbtVRMaADdqKJjQAbtRR MaADdqIgE012RAJprsiATTXZCXE0jx8IS4mkePhCXE0jx8ITWQe7ITWQe7K+x8IzWQe7IzWQ e7IS5mgefhCXM0Dz8IS5mgefhEAmmuyIBNNdkQCaa7KBjSCbtVQMaQTdqqBjSCbtVSCAdIvv 1YQ3FzFLs4jDx6CFhuT8oQsNyflCGyBkIbIGW9ICOyBkI7IGQhY7g/CELHcH4QhY7g/CARbn QCLc6ARbnTG6wCL+ExusAi/hMbrAIv4TH6yAL+Ux+sgC/lMfrIAv5QCLc6ARbnQCLc6ELDcn 5QhYbk/KELDcn5QhsgZCGyBlvSAjsgZCOyBkIWO4PwhCx3B+EIWO4PwgEW50Ai3OgEW50xus Ai/hMbrAIv4TH6yAL+Ux+sgC/lMfrIAv5QCLc6ARbnQCLc6ELDcn5QhYbk/KELDcn5QhsgZC GyBlvSAjsgZCOyBkIWO4PwhCx3B+EIWO4PwgEW50Ai3OgEW50xusAi/hMbrAIv4TG6wCL+Ex +sgC/nrGC6IzwA6t0IIeARM0FMH0cww4wc0RJgNNVoOeUSwJZ0MZCInYiTa/4UC4GANQmJj7 EQbe5OYBEOZgj6MUaYMCRYOURuIeIAyIfz6TYhpITJ37LSXAE2N3THb0PghGWAIaKF2RCJPp aCgAVo3YLEd/V3SnOo2dtg4fuq2UJ1B0Lljn4TZLQJg7EE6n+vQMBMEGqKrKArsAx9JkKizl JygMT0/lBg8dfSY2wsECXPgFNodzljvFMehPCDhwFtihG94hyX9FfQyzFMTvoTgpB5F9j6Bh RsQ4DNgiw7IObUD0JJHqQWeSTQKG3RyHBTgTKPBAmvJyNwfR4shRHIkGGFjuNR6ESlNo9ydA jqBqFgWMC3Yg+hlQAtDBySfCb9GBUBr6ER4jLIQ0UL0wUn9aNQX4ANRGiLmLPQNIAekXhxJo fkIhSMzIhcn5PoT7oEL77DbIS7B9oIgEACDAgoAkTAABEQLsC8Hj0ZqSWc6R2M+xiodmGIQE a9dO60Ucx0bHVI1Ox8IYkMwTNsDBu6A6KAjoyCChMAYGE3Q/tRJIMS4LFy4GwYIQiXGYkQ0B 2dRgwE8pgDNwddGomOCAYuAiQqdzqhCJcZiRDQHZ0HiOaTsdwuNZAURexiE47f2ggpEzzBMG skRQ3ARAmABLSf8AY9AiuA0g7ioigTFHpioQ4A0NBEYejXE+5QMTMj2MNEVTr5tLQaPBaBiR yfRHHjywaWM0RHQBim1INiHGxFB0dCYGJh7IEyITgqud4NAs7IuAz8HMEIEX/ZUVyH3DR0ZL A6DEiGc2d0BLkwwYO+6DwjxYfEYlo/xOQJXkEnIIg+lGGiaBADD4T1jMaEQB/Dv4Q7z7Ii3D wzEaKqPIMBGDkSWG0UySiO8uOx5QijvOmbFEg6RAxPBFEEiTElNoTksdGAG6Y87JmjRwCMyf oExgeLTKhkZc1szGk+O6aBlxheLEeCOzIuxaeiEgDY9F+wa0YhTHkX1QGqUUBBNvrUEEwZBl BDYy7GbImyNIwkGJYbQH/IGfHFiViyH/ADaQHo850gmM3Y0QAAAAgANPSMmrRo+7eoCuwhzh 06H9QFdhDnDp0P6SHUknHlTr930Lwg6kP5CAWbGbkncnU+gQwTx36KAJFYGnoRjxA1DYgGKA AAAASA9H4lkblpO5vUSgO1qWvoAIQcGBClTTPRubHGoQMLMAQA9BHiABnJj8oFDic8RUn0G1 dRReQgFkxm5J3J1PoPggLx35CAJFYGnowuw4CWNi0xQoAAAABID0ibhBiIBCRIkfP/sv/9oA DAMBAAIAAwAAABDzTzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzyzzwgwwwwwwww wwwwwwwwwwwwwwwwwwwwwzTzzzzzzzzzzzzyjzzzzzzzzzzzzzvfzzzzzzzzzzzzzzxTzzzz zzzzzzzxxgwwwwwwwwwwwwvXgwwwwwwwwwwwwwwxTzzzzzzzzzzzzyjzzzzzzzzzzz6f4Xzz zzzzzzzzzzzzxTzzzzzzzzzzxShgwwwwwwwwwwFQwyEwwwwwwwwwwwwwwxTzzzzzzzzzzzzy jzzzzzzzzz1/zzxnzzzzzzzzzzzzzzxTzzzzzzzzzzwzyTDDDDDDDDDBHDDA3DDDDDDDDDDD DDDBTzzzzzzzzzzzzyjzzzzzzzzz/wA888p888888888888888U88888888888k0kwwwwwww ww7wwwwhwwwwwwwwwwwwwwwU88888888888c8o88888888v+8888p888888888888888U888 8888888804kwwwwwwwwhwwwwwhwwwwwwwwwwwwwwwUGN8I8088888cso88888886W88888p8 88888888888888U4y34s88888888o888888+rf8APPPPKfPPPPPPPPPPPPPPFMcIzLBONOPP HPGDDDDDDHDjDDDDDCTDDDDDDDDDDDDDBFP/ACyzxTyzzzzzyjzzzzlzzzzzzzzynzzzzzzP 7zzzz92pTzzzzzzzzzzwiBgwwwteg8wwwwwww4wwwwgnyUwg1oQwpXzzzzzzzzzzzzyjzzkz 5of/AM88886g88qdNd8T/QX6263e88888888888soYMNcBNGZOMMLaOscOLMCDMHg2MLAAAB 08888888888888o8t68Q858y3gT51n6s+t/8cSt8e8889c88888888888k8k7hBDwwgD2Dwx xxDywwwwwwwwwwwwwwU88888888888889CO88888W8888888888888888888888U88888888 888841wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwU888888888888s88s4w88w8008w8c40w4804 00wY0w88w88888888888888M8cc8oM0IcEoYc840EMcsc4kgMMosc8888888888888888888 88888888888888888888888888888888888888//xAAsEQEAAgACCAYDAQEBAAAAAAABABEh MSBBUWFxkaHREEBQgbHBMOHw8WBw/9oACAEDAQE/EP8AqxK8oAIz9LC2iOafzOMK7fSmIQW2 F1Rbn3+vSTbFEruddfj9/r0gLal1WRhoGbj6QLF6sYtt6HUHpHSnPR+N6RgPc8XR+P6PQxYO j8H59HwbgXS6f78i1xV7T+pC5r8px9z7aXQ+REV4i+zP9d7QKUbbP8PJBcwH8r9xbxdLJweR E5E3UUZnkQurQSnbt27Jnp/E/nGWx8M0VN4maL8gCtEpWz19vw5+B0ybUMhok3FZuDr+pgtl XkwVRFBzGzhM5cYiENmFi793P8CxG50rHMehCVsXbMDNi/PipUX8TJKPSENlvgLDdFZd3kUV EQdZre0y6VirkG1mJO8rBwNb0gqLFPvYkSmnRAWpkhhtfqYLea8bFxCWK6fiDVOGo+2AKDwf NC/MsK7v1vmGKW8WviAUc17SnI5L6m4fxulmXPe0M02wW3pChmGHLyAK0QDrtb9Epr0Zv0bW X4CcdatV9pWa06wQ5mJ7k3UL8+IC2bpNr9EE5jv8M9xOktxTcMYtrgwH0DMlvyg/+e8GWAbk fuC5dR3lCbGN7kdZk5o6s3iI6mbqbqbqGKBI9S1/tXkKabYYwNhmOLr4RgLqyDsYSh9VkeC0 s1RQS3eGOeP3Ee0wRg3BdorwYpwiPaYNlymJZ8pgzYXrE1MUMVFYfP3M14SD1vDMW+c4oChr ihVpvoBrTeJvE3iBN3GLYV+fKUXMW5p9Qxohs7wmhoAlqEm2gLXQm3Rxb/Uw6U92b7zYDk+b Fc3zYDk+bHXNHO2/mYtpfOqAiaqOf6QJsNJiqg07++B7eiuWtf8A5j//xAAsEQEAAQIEAgsB AQEBAAAAAAABEQAxIUFhkVFxECBAUIGhscHR8PHhMGBw/9oACAECAQE/EP8Aq50Q+WOXOpGS X7rAKsVNQlPhl5UMUEfV7qaWSoVJ8U5nA550AILUX/d3dLWnS4hHNanwAMwYy5S6dLb92d0G ysVAOMrzt5dTDzvqd0KMu4bsUZCx1MP2Ld0OE4y5f11cHI9ndGIM2DkfLPV+9odz6PC1p6H9 6t1r3OYDhjzx8jrXOr6uwgL3jX0tJtjx7GoEtbVanP2HWu/rB7C7gTyr8A+aeUo59iUCWlWD Ab/TegAEB1rjT6PYcNA8a0u5V7jy7C5EwgLc9qcAHlM+JMqACDr/AEuf+6CGHQ5IvMmvxipq KXAjsDpICpOEAjkzfHLT/G8+09dqBTsr9VCBU2fY/tY6TMnl2NA8BRYYFuLV04FWp/AJLxxy +f8AAYn0k6wBZPNpBDA4VjPEHp0hEsaZ1dJGl/5TCCDh89Cka1MmvYX7QFHigW4tfYVMn9pw fKZvxSMHAPShknqqQJq+ePA96tqI9Q6YwwnlUCcnH1pIkxzfYpFKnoAXw9KBkrkZU4AxyJ9a Wlm8Pmp7LcrWblcbyPmsxQ4x/aYoWcd+wOGgMaLlB/R7FSw5WXu6VLKU2KmyS8qXFrHg05Wh 0ooK1p4Hu0gsGnRZ83kp+AHnREGOZTZncoyT0CO6OZFC5KByypfK7WKSLqYFfrFApDuVpdyt LuVpdyjCAzqUCDA7AAGxMPC75VOC6mfhwoBDBxfmpvzN326DIKQHGVaXcpzEuaUDH1Zv/Kmy 7lJZdyhsu5RWDgeo1FohgTwMMKsD551oqwRG0elaKg2QUpfYKE1jlhS0g2K0uxSzLsFfjFfj FfjFLoDUITk0ekDP/eUny6BULdcXxzcvCsERc34pmVPSYUsUwaeF2K4YuWH9pZmGxWk2qTJt QFhtSlxtU3BIUzOR53fPttnspLk7GR+saVIXrHjxUvx79yup4KY48J5f+Y//xAAsEAEAAQMD AgUEAwEBAQAAAAABEQAhMUHB8FFhcYGRobEQMEDxIFDRYOFw/9oACAEBAAE/EP8Am1glxQOF KCGBdIIXEUSC2YILCEJElxFqJBbMEFhCEiS4i1LZuICFCCEiS4i3/LAiFAmxLVxkqnJOTJN5 gUJbkWPngEmLqIE2bxFIsfPAJMXUQJs3iKegU4XJi6CBNroikxLHNEp8RO0Bh6D+9qVKlSpU qVKlSpUqVKlSpUqVKlSpUqVKlSpUqVKlSpUqVKlSpUqVKlSpUqVKlSpUqVKlSpUldEhEqzyv Q/8AplQjUIm9pBPSC5MMTmKlBtaozIZKk11YRzIZKk11YRzIZPzakxcJHZSwMdrkftTPj4Nj zoQbAH+3IhpMEJZl3TrlqzssfJliBQl26sXsfbn6qZya5q166tu8a8bXNIEPrN8FRpmarL3v y5UqVKlSpUqVKlSpUqVKlSpUqVKlSpUqz84hK8/JpRCQsGrGSZJD9CFXoYYVikfnypUqVKlS pUqVKlSpUqVKlSpUqVKlSpUqVKlW8TgcROtD8jvVeaICQ1ICa9RmQS1KsLykQl86lWF5SIS+ f5lTCMJp3u+7fv6H1D5pzxLf8sRqIFekOafNAjAQH0u8r5Kc+H/5QjUz7R/1TgAUmRk9qlZi 5D6ifAPkpz/boiLDnESIPQvLmYDFECy44I7FDqgwXKaTG1mYQuUGUr4q7qZYuEL1BlK+KQBZ uBk+tGw2WEYWNa4VvXCt64VvXCt64VvXCt64VvXCt64VvXCt64VvXCt64VvXCt64VvXCt64V vXCt64VvXCt64VvXCt6QsbsfCnGHGk9M+tcK3rhW9cK3rhW9I+hYCtBsYyAS9cK3rhW9cK3r hW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW 9cK3rhW9cK3rhW9cK3rhW9HxgKSTPT+RPnztowRw3So6Wq5kZGyCaQFABsStXFv02UMiNhGA WYp1RVh1AkRLaMAsx+PUcO6sOrRY9d4dqvSHd/lFBBoEfxM+Pq/zvl/5EjUTOmOp9gzxLU/U fn/kCNTqeKPGorqtm32DI8Ipes/tyM1y4GSM7pNxAbJJQxjgEIDcWQjANoWJJJBbMEFhCEiS 4i1LZuICFCCEiS4i341Sb6I32rqUA+P2BI9/xS9/+3IyFFBfGSYMyhfNBGwMEU/ECizGGCkW PngEmLqIE2bxFPQKcLkxdBAm10RSYljmiU9ONsOO9+JUqVKlSpUqVKlSpUqVKlSpUl6znDJ7 rGv2alSpUqVKlQrmZlKKAEZasGgn59SpUqVKlSpUqVKlSpUqVKlSpUqVKlSpUqVKjEMUvrOt X+xqXTJtf+/ZMh2aXrvg/wCPI1MTBLSufa352+ykiVic2P7cib2kE9ILkwxOYqSBdknMhkqT XVhHMhkqTXVhHMhk/FqZQsk7fv4rCsI+1YHT+3kXpuyCRk9Vbrmosd/Ft9dyVZhFrtj7c/VT OTXNWvXVt3jXja5pAh9ZvgqNMzVZe9+HKlSpUqVKlSpUqVKlSpUqVeTMABpZlOuh9sqVKlSp UqVKlYjr6aHun88qVKlSpUqVKlSpUqVKlSpUqVKlSpUqVKlSpVvE4HETrQ/IYo8kjqJKpYcj f1EkNSrC8pEJfOpVheUiEvn+JU7mDUw5d57/AG7A6Hf/AI4jUgWqBXgSXzv9u0+bv/HEaigu /wDG7QQQfbtLv+X+hI5XHKoFQnW38MGDAKhmoDPMlbEASwYTWeB1XUVzDOXjpTJ2DyTCEEgL ypSxCmSL4wovITWVhfwx0dGelLhFgmN8FmEDUj7h2RuTUgehcXMwGKaTG1mYQuUGUr4ppMbW ZhC5QZSvirupli4QvUGUr4pAFm4GT60bDZYRhY1rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9c K3rhW9cK3rhW9cK3rhW9cK3rhW9Eh2DMmHXxa4VvXCt64VvXCt64VvXCt64VvXCt64VvXCt6 4VvTNpVCDfRrhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9c K3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3rhW9cK3o+MBSSZ6fogiII5Gv0Cv0Cv0Cv0C px6CWNRE6r4xXj+12DM2jsZ7Ui5GsopugnPSgCKJwACwELm6qNQOdHsTqAZxBFrpdGAAuXUl uqqwdPuTJKSYYI4W4o6Wq4t+myhkRsIwCzFXFv02UMiNhGAWYp1RVh1AkRLaMAsx+HUzpFh1 aKTnD4fctPs/J/VEb0/hESSUhuLTn+iqOXAEq0QmE6utYIPuWlxj+hIiFMY0Fn1rgFeAV4BU mvB5VGMnUhETeCSI6DeoRLS4dEretKFKC+DL+WATKEqiSZq+W4OneEoCZSRmxRNiVWFCFIil uMdWpw/T4QRAzYRIxDY0QyBUjlSoYbqln59RyYCVauXbd60eAMH3be5/n+mI2xaGeOGzSVkA THIxiHwqy+1rDBIiCC1WwAMjSAIGFJOrQPIgYiQLoAC4CoJM1ECYrCyZCIi9GAJUKVywAfbW CXFT4NE4wiHMIXEUSC2YILCEJElxFqWzcQEKEEJElxFvwKiYwXVpYJKfX/2jgBgPvWd3af0J EGQASrpX6FX6FX6FX6lUCaRVOAFHQFtUDc6TCoMyYgpcmm+QJLKAEFiFpezWQMGoZiUCghNo yTfpA05tlU3YDBcs0qpgEJpHYBQQm0ZJwsk7kYGJCNzWmsTAjJUvWfcoEQASrgqScbuQrAkJ DFrtf7CSzR6HNFJRDYjQLyakImoL9oBF4gcMSxXm9pqbIHGckCwkYf4d5jpTpNDVAgDKXUOp Dey0ix88AkxdRAmzeIp6BThcmLoIE2uiKTEsc0Snpxthx3vuVKlSpUqVKlSpUUAOcTeo0CMt R8iJxOeq3qVPSAPvqlSpUqVKlSpUqVKlQna0npO6ff8APqVKlSpUqVKlSpUqVKlSpUqVKlSp UqVKlSpUYhil9Z1q/QwpCE7V3/qrv/VXf+qu/wDVU5aDMbSRBeShZuUk51rEyJSqwgEvUnRK oIowllgkJhqc/mCGXMIAWCHwvRdxXSsAklIMPVfcGU5g3QT7kRC5ZiG3pIbJZsLYKWlyNl0p tBYoE4nEZAy3SIC8pT/tRqCS55WGWJjv6HN6WaY1IidajwKtRJGCxhFlUkRU2OF8lhOAynBa BuTMCNg6yRm7MzMz+LUiqgYk5yKDEFZmUZMAgD8CzubfzUlA7oe7Hmv2pZn7CEki7KjQ7fdI yI9ZqFLmGFJNF/MqSwYqI4kfhZb3Nr+W960l3oMr4VJcUjIeDHhJ711cdnS9jxu966LFXsQf b+oEaiJIDTVoMEjx/wAOzuf7+6DYEqsAVLoUAbuyX8hHerD4lhIEkVvMn2739jB6FbLsW6ul BLmAteiLR5HdojuQgHQDH0F+4B7pS4soj2X8jE6EnU9KcYqSJiNrIJIFkTQ9yM2UcGiZYcQi Iou0eLMgK0F4OhERSBD6zfBUaZmqy977MqVKlSpUqVjnGgOXwqNJncxHkNAgBhgPpSq4MJVQ BVTMonJibdFvwCpUqVKlSpUqVKlSpUrEjsAkc5cPT7hUqVKlSpUqVKlV54hNboM/g1pWxMJo hPWJfeIeJRKF4d8R8OO1Mlt0AA7XTk6fzKlSpUqVRCEjydtdBq+VwdRL6mwJLPgflYO9FQtV hPSyfAA0WoNGhl2Z2Pf+BUqVmZg3R2IUMIL8k2lNi8z+THw+Ky0lLZZQN3rUzTlVGRE7LMDL UzTlVGRE7LMDL9qoiS/mLUC/bR/n1MsCVMAUxs8XMdDXL2liARlxFXr98nE0EJLi7SDACEZE n7SM8yUHm0mBfIxxKZdj1KFMa6NnQhYOzz1KMsKAQB0Pp0vBd1P4pQFUAytXJjIO56GOqzvR lYzD5VuhAd6mlhADLXU8SHtU4r718wu+7btQAAAQBp/G0swIqXiyJ+UftH9JURtfzFqBft4/ z65Z0pyXtSYthYw78LrWVGlcvVe9eMS/q+8swO6lHu/btSMZwRABfAZllY6RV65Vb1YL3P5G WBKmAKSsqK8G5depbv8ARFSYFv0/A1f/ACpkJoEaZkYOgaUmnEKj7KseUfw6FkO67H6ks+Zg BrTnWgcg6jp92gUwIwwh89mrc5Gend2LfZFLCnmJvWNco6CL8z/R1M5H5lZWzk+t+ILYnWS2 I1ets0BAsqI8JXjwCil/A4ChgNJAebV56mwYJBCYvljGK1e9wJ+2IIHj3cx5kpm45lAdoy+X zo0b0jy9jxu96tPKkdxJ7hVxpXeHQfxTLaSYcoEuqM4oteyUoNBKerbpTa/T/Feq6FjIVnYH sdLLrERhrqoRgmK2oAWDWLrr3/j0GE/sn4VDSMqDrgHmxR40mKJPOdIE1kVzBQsEk50rEGMn q63u1wCvAKyW+CuT2uL9QYehRiU08w4y+6rgFeAVjE+ie6EPTRpv5YoiSI+n5BigdHplQJKk klIZBbiU0mNrMwhcoMpXxV3UyxcIXqDKV8UgCzcDJ9aNhssIwsa1wreuFb1wreuFb080iG38 qQ3zdFvKa4VvSITyv+1W1mLTuJvPp1rrZZV+i+D3qa20lfhI0+dmLAHkMHi+SnYZBYO0keQP jS3KlRvBFZVnLUItIARAbVwreuFb1wreuFb1wreuFb1wrekQISqAHrV1AwWZePPkNNtlcQnh M/ODSwYvIA9pwecvegyCHlrXCt6mBC+kkdagQL3sCD0vrhW9cK3rhW9Py/GFWwjxTyoNhrkQ yS8aHCt64VvXq+fhtUdq4VvXCt64VvXCt64VvXCt6ElYI1BTNu4paiECgbE+q+VZXocYD3bU nyJkREWnpCWs04VvXCt64VvXCt64VvXCt64VvXCt64VvXCt64VvVsiApPWhNZgZICBm0F9/y CSuO1EhKTeugKLI2GhF5q4t+myhkRsIwCzFOqKsOoEiJbRgFmP5VAWJhY6tHL5vpR9CePKrP YNXtUbHRJC/96umCupN7S+Ll86jYubSCTGqBdS9wOlTpNIpLzX8z4UQAoEDwD6Sxdi9J7qG8 mfzjZFPowbsFAkHkGo398O6UWREJ+aV/It2/laWAh2t+yVhQMJL4Fcr2rle1CAIlHa2TAri6 nSh/bFGAgMdKlt3Ir7Uc7tQPaZqcM6C3+nCARsWPaU11hyZB5KnmUTdaBB5yUiRj7Dp+p/7S k7CTADCSYWmbwbpDZPgvFqUAR9pyTns83tIoU0u6xlW613/qrv8A1VgfOt81+hV+hV+hV+hV +hV+hV+hV+hV2cIS/oiNRMkkfgoBEgtdAqG9ywWNYcB39KB6hBB4S3T0qGMQoApRFSDdcW6G XsVMmssoZPNXeX8LcSk+mjmms7/yMW7Hg3Chno8z3iFPOUunU9jEOaAAACANP52OQB9A+81J +RFOTEPJoi9SoAHpQbaTCT2EiXcsdan0qEmD0Eyx3r92f5QLdTpJ/lY056ypLIfaT/K/dn+V +7P8r92f5TkrsrHxSxEfVrv/AFVcpKlSUceVFq0u3SINAgr5HSg5QB5NWNK6pdVNfoVfoVZ0 ngpXf+qu/wDVXf8Aqrv/AFV3/qrv/VXf+qu/9VEpL8JzUPhWRqP+j+hqMimlYg76GWaChL0G Ee583lQWIZfL1WnBbZLt5GPFgpwssRjHeWzwuo2oossOytx6HagAAAFgP4QgShvEQ+KgrQes f5SxphgCcTBXHdqfj0DtUaKCyuwj/YqTPYsr1mXoL3op89eswi06qy1x3auO7Vhiuz2rILwr Fcd2rju1YAOFcpW/lv8ABS3MGAo2SiANY1TyIc0uUMKgaWb+g1Cp2wR6w7MdvuSdWA6JDU7y 8y6ASwder5ffAQASj3v+RWCXFA4UoIYF0ghcRRILZggsIQkSXEWpbNxAQoQQkSXEW/jUJkP/ AKU9ColQX7jK69oO1WUBX20xAXjQNXzrHhysEdrvIijpy4GZ9TH1mgQAEAEAfyBfCnmJRhiJ zSCXzUUVfga69CFYZJlHrWCTnIPUOD9GKcixfDtgQ+J9CgiDzErgm1cE2rgm1YR8WKyY8D8q 4JtXBNqw68D8KARYfH/aXSFrzMYQ51c9KNMkVLXR4AE+J/bEQRCgTYlq4yVTknJkm8wKEtyL HzwCTF1ECbN4inoFOFyYuggTa6IpMSxzRKenG2HHeqCqR/Yoguo5fFOKDYBbdX/SpNjsT7zZ eRQ7qwgGivIxYNDvj7NSpUqVKlSpUmkydTEb3uQc9avlpIWXEELmFUJNaCjbop2KseA86lG1 ZV3b3fH7lSpUqVKlSpUqVIZBDDj2V6FCsoJgU62H86pUqVKlSpUqVKlSpUqVKlSpUqVKlSpU qVKjEMUvrOtX86oeMaAdk+518MxcISIn27uhoXelKPEgkVHVLr3qNciEIvHJ837cTCxrFxHi vSnuyO+PRPtN+6/8URtuCKeqeuPXpQw/Taj6QdMsdJmsfmdZ6rle7927Z4DUh7Wt1D/iyKFG /o1M+AZ8fP8A5cj3HDEhYou0eLMgK0F4OhERSBD6zfBUaZmqy96qkMLh5SPto2MAFzCTU2MA FzCTXyYc5iJ89OxoQOYCauxoQOYCaiUxsHlAe+hKY2DygPfQlMbB5QHvpTTwIeYX4tKaeBDz C/FpTTwIeYX4tJW2hnECD7VJW2hnECD7VJW2hnECD7VDX2hnEKh71DX2hnEKh71DX2hnEKh7 1CaeRLzA/MoTTyJeYH5lCaeRLzA/MpSGFw8pH20pDC4eUj7aUhhcPKR9tGxgAuYSamxgAuYS a+TDnMRPnp2NCBzATV2NCBzATUSmNg8oD30JTGweUB76EpjYPKA99KaeBDzC/FpTTwIeYX4t KaeBDzC/FpK20M4gQfapK20M4gQfaoa+0M4hUPeoa+0M4hUPeoa+0M4hUPeoTTyJeYH5lCae RLzA/MoTTyJeYH5lKQwuHlI+2lIYXDykfbSkMLh5SPto2MAFzCTU2MAFzCTXyYc5iJ89OxoQ OYCauxoQOYCaiUxsHlAe+hKY2DygPfQlMbB5QHvpTTwIeYX4tKaeBDzC/FpTTwIeYX4tJW2h nECD7VJW2hnECD7VJW2hnECD7VN4nA4idaH5czTlVGRE7LMDL9FKKNx1SvzSlFG46pX5p2FA FzARTsKALmAita1ObxEetOwiEmYSKdhEJMwkUJRAsOqE+KEogWHVCfFCUQLDqhPilMswI6wm 7SmWYEdYTdpTLMCOsJu0s5YAaQovwpZywA0hRfhSzlgBpCi/CgjLIDSBU+VBGWQGkCp8qCMs gNIFT5UJlmRPWA2KEyzInrAbFCZZkT1gNilKKNx1SvzSlFG46pX5pSijcdUr807CgC5gIp2F AFzARWtanN4iPWnYRCTMJFOwiEmYSKEogWHVCfFCUQLDqhPihKIFh1QnxSmWYEdYTdpTLMCO sJu0plmBHWE3aWcsANIUX4Us5YAaQovwoIyyA0gVPlQRlkBpAqfKgjLIDSBU+VCZZkT1gNih MsyJ6wGxQmWZE9YDYpSijcdUr80pRRuOqV+aUoo3HVK/NOwoAuYCKdhQBcwEVrWpzeIj1p2E QkzCRTsIhJmEihKIFh1QnxQlECw6oT4oSiBYdUJ8UplmBHWE3aUyzAjrCbtKZZgR1hN2lnLA DSFF+FLOWAGkKL8KWcsANIUX4UEZZAaQKny/MhqFKnmqBBsuFpZmA2aWw9HdD6kOv0Uxahkr kBkLCJOqcACxo2YRG4iIjcSmMSBYMtM5XI3dclEI6zERhwbQSISJ2SmmAA2Be7oaroTSSmyR wppEELZSTX6OcrvbcXINVhsWFtTGxUx9UATARMnf6CYdCB5dawbFl7Eozg8AR2WATapPokrQ KQ0FVWLWIVcDdGNJHRjJMw6/QbyBSaifURPUFz6z1HQsZT1XgXLsDSE4YTmYGJOyetSrIgrd AF1WwUU4u0O8eCWxYY3iWkQtWeGAm1216BqNEpiZEwMItrP0UHRaN8ZEGVYbFhbUVVsWFKmE ogkaP0JjaDsGoCwWRdYO4MyTKiyQIm0k9/pN7gEMyEVWADqriZg9kA1LJZEYGYdRPpPNVtAI gUoTLAWL3gcE11QCT6/TVNxGwSAA6lmbALNlICSEYRG4jZG59I/bE0sqFxKJkEeoCLUGC6iZ pgQE4lqKqhhy6tAmMMj9IQkSkhQYDVwLmbUIS5nD9Ir4vJL0XlfIlQqbZumSBJiYrv8ARx8W JCQFgFYFWO6Gngd4kWZCbIgikmH6JoUQqLkKqsEEEKuBXnShMYY7zf8ANY8RteYlFksIiTmL UJLDPLAZGAAJcXVv9IdrbosuARMw50pscR5KnxYlGDGPoj1ZlG6ZkmlnIt6M6EqygAS62KPA yBIjkSjDzByA+K9CzSHFYe2oosS4MWZBaaOYDyUwg7rmbkOiIgaFpanYEZksHCJCzAyslS/x yrktylLBBQRglS4Y0CIT4MUggYSBkCIQvoSS5FSpMml2RYaTaWWWwCZIx7vEMoyCT4TUWLTr YTjJCCbAqEgMp4aVQQBcwyuwUAmSMe7xDKMgk+E0VBigy2SUABkSGiFqrtgSJvCzct1pzD0M xoRISKyRpdlBxFmFBWSt2Uw/Q9FlWhExECSEWiIjvAVqTMREBSHIpehtQDR9MBdSUUqN3TRo yCIIlZkzZEtoIrtHS5dpij7pi1KrQDEYsCYYprGrnOIxAuIgoXAodUkEJNlFtITE2mKQdaVG 7DXoFArSYaYNoN6k4UliGG5e0E3tUMCSPnSVjZQ6MVmUJvkbXqdYv4gChZvILGVWuhMKg2CX Js86it1CUBciSXi4MYpsQoiyAEFsZYJVYJpiArAdaHsyWo9XoARLCEIDVQtSQ8tAlWkFAdAp EJGBo5Qy9mGbEDQ5Q+tcgWzsARkmvVIkKr0CWwWCAxRIbrEUSAZQERUuQFCsjHM2WSrMksSz LiGKZgDl6oRtQWWaJLfNQ5yuKWpSp6QWNRkTkdFZqEWTia06cDmRcLIYkKIw5JBdLFaQIkhk heC80okeJq1mKMMlkZpJSMMkliSVORYEwUsW2LS3lt/T21fpKyDDEkk5vaG9ApGVAGh9MNui Av1pWkImIxJQYXAIAYA+mFPTSDkYyXCYm6MEfRvCTtARHUJXLjB9W8JO0BEdQlcuMH0JKSk1 EhoJEhlkECuwAGAIPohvhjVGSFEuVKgipSDKhVG6qr9IIIaqsiKSiLaj48JgBp9GJhKQKJGB sWZo4BACADQ+hjkQmpSrqizc+odKI5kq7/EAWPoOISjCOlG+GA2O/dZZW7P0MUqogmS16HUM kCwBofRER2shIkFx7lIU2c3RKlbAZsY+kLapjgjZBMVIhCpSDKhVG6qr9DiNmiskKiiLagoR JgBp9Bl+Izuo84KOAwAgA0D6NkGIxMNlLQhbf9l//9k= --6c2NcOVqGQ03X4Wi--