Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtp (Exim 4.80) (envelope-from ) id 1a8y79-0000Wu-6G for pgsql-hackers@arkaria.postgresql.org; Tue, 15 Dec 2015 22:30:35 +0000 Received: from localhost ([127.0.0.1] helo=postgresql.org) by malur.postgresql.org with smtp (Exim 4.84) (envelope-from ) id 1a8y78-0004iw-OJ for pgsql-hackers@arkaria.postgresql.org; Tue, 15 Dec 2015 22:30:34 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA384:256) (Exim 4.84) (envelope-from ) id 1a8y76-0004hb-8S for pgsql-hackers@postgresql.org; Tue, 15 Dec 2015 22:30:32 +0000 Received: from mail-wm0-x233.google.com ([2a00:1450:400c:c09::233]) by magus.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.84) (envelope-from ) id 1a8y6k-0004RQ-Pp for pgsql-hackers@postgresql.org; Tue, 15 Dec 2015 22:30:30 +0000 Received: by mail-wm0-x233.google.com with SMTP id n186so116303371wmn.0 for ; Tue, 15 Dec 2015 14:30:09 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=2ndquadrant-com.20150623.gappssmtp.com; s=20150623; h=to:from:subject:message-id:date:user-agent:mime-version :content-type; bh=iuHZdEXUMiI0P5eixFtWuK2kVsnGwsSBdylj3xWdZxU=; b=GW30tXooXTCddi40WXdIn6vKrnOlb22Pwo+yn5q0Mu6PxGMnead0HlguGl0qRPrUr+ C/Orni8bQTQKouM7Q2HFkx94HDGzMeBtde2l5u50fbUh6mOoCK4VYh5ELoDEXqCZAe6x IaqinBKIxRQov8OsCr4f7WiUqb3IujUhBVyXls8CzCCXRAVYHxhLYKny1bdCkFU3oysO AowBVglwjHHYJAaWh9JiZhyJKarzrP6943IVXv5CFQgESnJ5t/6iZSWV0UBaARXv5J7C Bu19KFJm2eKr7EP8sa62x8fUaoJ4oGmEMQKljfOnNwdQKRZgjRhPhRkx1KtzydZK//7/ 9ItA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:to:from:subject:message-id:date:user-agent :mime-version:content-type; bh=iuHZdEXUMiI0P5eixFtWuK2kVsnGwsSBdylj3xWdZxU=; b=AoArdZEbFRzVRlGCHzKKA17CTFDmK6r9nwzkSFMPbftnKTGIMSdbHggwxq+9GD41eu tkGAoHdVTdbT8hagej1lG18l7YZuf3jhOP5Efsq6uYVjMLFB/KElx8IuuVFZHjHCxwJ3 E09oeUpzAYdp8TK+3GNF9TSgR9WkaDyC5s6GA504CAaOLlezOaj+paTfAGGBbBB5lWiD nwDz61m9cszb++EMit7PkbMLAt6EpIuAFgR3exolHeJ1YdaS6gM9egdebUb1yt+qSQ5u 5e/t43m3cTdZZ9eU+HesOzH4Lp4O8pK9m8EZyrFRezTDFBjawTSU1JMhbLVJszSh6Shc ewhQ== X-Gm-Message-State: ALoCoQnZIsK7XL4pU9m/do7XZsgtfepumaoRbjxcM2g0QUp5BiodWrM36ddyrIDJJb3xvt1wi6+15adMfYqq9jFun+QYkcSK4GApPGDVm/77yZ6XbLDiyt7Pv7FqV75nRqjiGTnmWUvq3f2YwfS8Y8pbTcMXZLYWp2Ws2r5v1LWS8hMPdVjarJvStWeqiik/0pFzFANyrj+wG4lw2g9mbM9xDbj+uBDGBA== X-Received: by 10.28.13.138 with SMTP id 132mr8213805wmn.62.1450218608781; Tue, 15 Dec 2015 14:30:08 -0800 (PST) Received: from [10.137.1.13] (ip-78-45-216-26.net.upcbroadband.cz. [78.45.216.26]) by smtp.gmail.com with ESMTPSA id h7sm4688200wmf.0.2015.12.15.14.30.07 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 15 Dec 2015 14:30:07 -0800 (PST) To: pgsql-hackers@postgresql.org From: Tomas Vondra Subject: WIP: bloom filter in Hash Joins with batches Message-ID: <5670946E.8070705@2ndquadrant.com> Date: Tue, 15 Dec 2015 23:30:06 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.1.0 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------060507030306080009060607" X-Pg-Spam-Score: -2.6 (--) List-Archive: List-Help: List-ID: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: X-Mailing-List: pgsql-hackers Precedence: bulk Sender: pgsql-hackers-owner@postgresql.org This is a multi-part message in MIME format. --------------060507030306080009060607 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Hi, while working on the Hash Join improvements, I've been repeatedly running into the idea of bloom filter - various papers on hash joins mention bloom filters as a way to optimize access to the hash table by doing fewer lookups, etc. Sadly, I've been unable to actually see any real benefit of using a bloom filter, which I believe is mostly due to NTUP_PER_BUCKET=1, which makes the lookups much more efficient (so the room for bloom filter improvements is narrow). The one case where bloom filter might still help, and that's when the bloom filter fits into L3 cache (a few MBs) while the hash table (or more accurately the buckets) do not. Then there's a chance that the bloom filter (which needs to do multiple lookups) might help. But I think there's another case where bloom filter might be way more useful in Hash Join - when we do batching. What we do currently is that we simply 1) build the batches for the hash table (inner relation) 2) read the outer relation (usually the larger one), and split it into batches just like the hash table 3) while doing (2) we join the first batch, and write the remaining batches to disk (temporary files) 4) we read the batches one by one (for both tables) and do the join Now, imagine that only some of the rows in the outer table actually match a row in the hash table. Currently, we do write those rows into the temporary file, but with a bloom filter on the whole hash table (all the batches at once) we can skip that for some types of joins. For inner join we can immediately discard the outer row, for left join we can immediately output the row. In both cases we can completely eliminate the overhead with writing the tuple to the temporary file and then reading it again. The attached patch is a PoC of this approach - I'm pretty sure it's not perfectly correct (e.g. I only tried it with inner join), but it's good enough for demonstrating the benefits. It's rather incomplete (see the end of this e-mail), and I'm mostly soliciting some early feedback at this point. The numbers presented here are for a test case like this: CREATE TABLE dim (id INT, dval TEXT); CREATE TABLE fact (id INT, fval TEXT); INSERT INTO dim SELECT i, md5(i::text) FROM generate_series(1,10000000) s(i); -- repeat 10x INSERT INTO fact SELECT * FROM dim; and a query like this SELECT COUNT(fval) FROM fact JOIN dim USING (id) WHERE dval < 'a'; with different values in the WHERE condition to select a fraction of the inner 'dim' table - this directly affects what portion of the 'fact' table has a matching row, and also the size of the hash table (and number of batches). Now, some numbers from a machine with 8GB of RAM (the 'fact' table has ~6.5GB of data, so there's actually quite a bit of memory pressure, forcing the temp files to disk etc.). With work_mem=16MB, it looks like this: batches filter select. bloom master bloom/master ----------------------------------------------------------- 4 1 6.25% 23871 48631 49.09% 8 2 12.50% 25752 56692 45.42% 8 3 18.75% 31273 57455 54.43% 16 4 25.01% 37430 62325 60.06% 16 5 31.25% 39005 61143 63.79% 16 6 37.50% 46157 63533 72.65% 16 7 43.75% 53500 65483 81.70% 32 8 49.99% 53952 65730 82.08% 32 9 56.23% 55187 67521 81.73% 32 a 62.49% 64454 69448 92.81% 32 b 68.73% 66937 71692 93.37% 32 c 74.97% 73323 72060 101.75% 32 d 81.23% 76703 73513 104.34% 32 e 87.48% 81970 74890 109.45% 32 f 93.74% 86102 76257 112.91% The 'batches' means how many batches were used for the join, 'filter' is the value used in the WHERE condition, selectivity is the fraction of the 'dim' table that matches the condition (and also the 'fact'). Bloom and master are timings of the query in miliseconds, and bloom/master is comparison of the runtimes - so for example 49% means the hash join with bloom filter was running ~2x as fast. Admittedly, work_mem=16MB is quite low, but that's just a way to force batching. What really matters is the number of batches and selectivity (how many tuples we can eliminate using the bloom filter). For work_mem=64MB it looks like this: batches filter select. bloom master bloom/master ----------------------------------------------------------- 1 1 6.25% 24846 23854 104.16% 2 2 12.50% 24369 45672 53.36% 2 3 18.75% 30432 47454 64.13% 4 4 25.01% 36175 59741 60.55% 4 5 31.25% 43103 62631 68.82% 4 6 37.50% 48179 64079 75.19% So initially it's a bit slower (it's not doing any batching in this case, but the code is a bit silly and while not building the bloom filter it still does some checks). But once we start batching, it gets 2x as fast again, and then slowly degrades as the selectivity increases. Attached is a spreadsheet with results for various work_mem values, and also with a smaller data set (just 30M rows in the fact table), which easily fits into memory. Yet it shows similar gains, shaving off ~40% in the best case, suggesting that this is not just thanks to reduction of I/O when forcing the temp files to disk. As I mentioned, the patch is incomplete in several ways: 1) It does not count the bloom filter (which may be quite big) into work_mem properly. 2) It probably does not work for outer joins at this point. 3) Currently the bloom filter is used whenever we do batching, but it should really be driven by selectivity too - it'd be good to (a) estimate the fraction of 'fact' tuples having a match in the hash table, and not to do bloom if it's over ~60% or so. Also, maybe the could should count the matches at runtime, and disable the bloom filter if we reach some threshold. But overall, this seems like a nice optimization opportunity for hash joins on large data sets, where batching is necessary. Ideas? -- Tomas Vondra http://www.2ndQuadrant.com PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services --------------060507030306080009060607 Content-Type: application/sql; name="hashjoin-bloom.sql" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="hashjoin-bloom.sql" Y3JlYXRlIHRhYmxlIGRpbSAoaWQgaW50LCBkdmFsIHRleHQpOwppbnNlcnQg aW50byBkaW0gc2VsZWN0IGksIG1kNShpOjp0ZXh0KSBmcm9tIGdlbmVyYXRl X3NlcmllcygxLDEwMDAwMDAwKSBzKGkpOwoKY3JlYXRlIHRhYmxlIGZhY3Qg KGlkIGludCwgZnZhbCB0ZXh0KTsKaW5zZXJ0IGludG8gZmFjdCBzZWxlY3Qg KiBmcm9tIGRpbTsKaW5zZXJ0IGludG8gZmFjdCBzZWxlY3QgKiBmcm9tIGRp bTsKaW5zZXJ0IGludG8gZmFjdCBzZWxlY3QgKiBmcm9tIGRpbTsKaW5zZXJ0 IGludG8gZmFjdCBzZWxlY3QgKiBmcm9tIGRpbTsKaW5zZXJ0IGludG8gZmFj dCBzZWxlY3QgKiBmcm9tIGRpbTsKaW5zZXJ0IGludG8gZmFjdCBzZWxlY3Qg KiBmcm9tIGZhY3Q7Cgp2YWN1dW0gZnJlZXplOwphbmFseXplOwo= --------------060507030306080009060607 Content-Type: text/x-diff; name="bloom-hashjoin-v1.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="bloom-hashjoin-v1.patch" diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c index 5e05ec3..aad5e98 100644 --- a/src/backend/executor/nodeHash.c +++ b/src/backend/executor/nodeHash.c @@ -36,6 +36,7 @@ #include "utils/memutils.h" #include "utils/lsyscache.h" #include "utils/syscache.h" +#include "utils/murmur3.h" static void ExecHashIncreaseNumBatches(HashJoinTable hashtable); @@ -47,9 +48,16 @@ static void ExecHashSkewTableInsert(HashJoinTable hashtable, uint32 hashvalue, int bucketNumber); static void ExecHashRemoveNextSkewBucket(HashJoinTable hashtable); +static void ExecHashBloomAddValue(HashJoinTable hashtable, uint32 hashvalue); static void *dense_alloc(HashJoinTable hashtable, Size size); +static BloomFilter BloomFilterInit(double nrows, double error); + +/* let's shoot for 5% false positives error rate (arbitrary value) */ +#define BLOOM_ERROR_RATE 0.05 + + /* ---------------------------------------------------------------- * ExecHash * @@ -112,6 +120,8 @@ MultiExecHash(HashState *node) { int bucketNumber; + ExecHashBloomAddValue(hashtable, hashvalue); + bucketNumber = ExecHashGetSkewBucket(hashtable, hashvalue); if (bucketNumber != INVALID_SKEW_BUCKET_NO) { @@ -310,6 +320,11 @@ ExecHashTableCreate(Hash *node, List *hashOperators, bool keepNulls) hashtable->spaceAllowedSkew = hashtable->spaceAllowed * SKEW_WORK_MEM_PERCENT / 100; hashtable->chunks = NULL; + hashtable->bloomFilter = NULL; + + /* do bloom filter only when batching */ + if (nbatch > 1) + hashtable->bloomFilter = BloomFilterInit(outerNode->plan_rows, BLOOM_ERROR_RATE); /* * Get info about the hash functions to be used for each hash key. Also @@ -602,6 +617,7 @@ ExecHashIncreaseNumBatches(HashJoinTable hashtable) long ninmemory; long nfreed; HashMemoryChunk oldchunks; + bool build_bloom_filter = false; /* do nothing if we've decided to shut off growth */ if (!hashtable->growEnabled) @@ -667,6 +683,36 @@ ExecHashIncreaseNumBatches(HashJoinTable hashtable) sizeof(HashJoinTuple) * hashtable->nbuckets); } + /* if we're switching to batched mode, we need to build the bloom filter */ + if (oldnbatch == 1) + { + /* + * We can't use outerNode->plan_rows here, firstly because we don't + * have access to it, but most importantly because it's inaccurate + * anyway (we've expected to do no batching based on the value). So + * we'll just use double the number of entries in the hash table. + * + * We also need to make sure we added the hash values into the bloom + * filter in this case (that's what build_bloom_filter is for). + * + * XXX Maybe we should be more pessimistic and use a higher values, + * in case we need to further increment the number of batches. + * + * XXX We also need to set some maximum number of tuples when the + * false positive rate gets too bad, and stop using the bloom + * filter if we reach it (we can't resize the filter). + * + * XXX There was a paper about adding a larger bloom filter once + * we fill the existing one, and using them at the same time. + * Might be worth implementing if the whole bloom filter idea + * works in general. + */ + hashtable->bloomFilter + = BloomFilterInit(2 * hashtable->totalTuples, BLOOM_ERROR_RATE); + + build_bloom_filter = true; + } + /* * We will scan through the chunks directly, so that we can reset the * buckets now and not have to keep track which tuples in the buckets have @@ -697,6 +743,9 @@ ExecHashIncreaseNumBatches(HashJoinTable hashtable) ExecHashGetBucketAndBatch(hashtable, hashTuple->hashvalue, &bucketno, &batchno); + if (build_bloom_filter) + ExecHashBloomAddValue(hashtable, hashTuple->hashvalue); + if (batchno == curbatch) { /* keep tuple in memory - copy it into the new chunk */ @@ -1705,3 +1754,78 @@ dense_alloc(HashJoinTable hashtable, Size size) /* return pointer to the start of the tuple memory */ return ptr; } + +static void +ExecHashBloomAddValue(HashJoinTable hashtable, uint32 hashvalue) +{ + int i, byteIdx, bitIdx; + BloomFilter filter = hashtable->bloomFilter; + + if (! filter) + return; + + if (hashtable->curbatch > 0) + return; + + Assert(hashtable->nbatch > 1); /* nbatch=1 implies bloomData=NULL */ + + for (i = 0; i < filter->nhashes; i++) + { + uint32_t seed = i; + uint32_t hash = 0; + + MurmurHash3_x86_32(&hashvalue, sizeof(uint32), seed, &hash); + + hash = hash % filter->nbits; + + byteIdx = (hash / 8); + bitIdx = (hash % 8); + + filter->data[byteIdx] |= (0x01 << bitIdx); + } +} + +bool +ExecHashBloomCheckValue(HashJoinTable hashtable, uint32 hashvalue) +{ + int i, byteIdx, bitIdx; + BloomFilter filter = hashtable->bloomFilter; + + if (! filter) + return true; + + for (i = 0; i < filter->nhashes; i++) + { + uint32_t seed = i; + uint32_t hash = 0; + + MurmurHash3_x86_32(&hashvalue, sizeof(uint32), seed, &hash); + + hash = hash % filter->nbits; + + byteIdx = (hash / 8); + bitIdx = (hash % 8); + + if (! (filter->data[byteIdx] & (0x01 << bitIdx))) + return false; + } + + return true; +} + +static BloomFilter +BloomFilterInit(double nrows, double error) +{ + /* perhaps we should round nbits to multiples of 8 ? */ + int nbits = ceil((nrows * log(error)) / log(1.0 / (pow(2.0, log(2.0))))); + int nhashes = round(log(2.0) * nbits / nrows); + + BloomFilter filter = palloc0(offsetof(BloomFilterData, data) + ((nbits + 7) / 8)); + + filter->nbits = nbits; + filter->nhashes = nhashes; + + elog(WARNING, "bloom filter: %d bits (%d bytes), %d hashes", nbits, (nbits + 7) / 8, nhashes); + + return filter; +} diff --git a/src/backend/executor/nodeHashjoin.c b/src/backend/executor/nodeHashjoin.c index 1d78cdf..708877e 100644 --- a/src/backend/executor/nodeHashjoin.c +++ b/src/backend/executor/nodeHashjoin.c @@ -48,7 +48,6 @@ static TupleTableSlot *ExecHashJoinGetSavedTuple(HashJoinState *hjstate, TupleTableSlot *tupleSlot); static bool ExecHashJoinNewBatch(HashJoinState *hjstate); - /* ---------------------------------------------------------------- * ExecHashJoin * @@ -210,6 +209,7 @@ ExecHashJoin(HashJoinState *node) outerTupleSlot = ExecHashJoinOuterGetTuple(outerNode, node, &hashvalue); + if (TupIsNull(outerTupleSlot)) { /* end of batch, or maybe whole join */ @@ -224,6 +224,19 @@ ExecHashJoin(HashJoinState *node) continue; } + /* If still in the first batch, we check the bloom filter. */ + if (hashtable->curbatch == 0) + { + node->hj_BloomLookups += 1; + + if (! ExecHashBloomCheckValue(hashtable, hashvalue)) + { + /* Loop around, staying in HJ_NEED_NEW_OUTER state */ + node->hj_BloomEliminated += 1; + continue; + } + } + econtext->ecxt_outertuple = outerTupleSlot; node->hj_MatchedOuter = false; @@ -423,6 +436,9 @@ ExecHashJoin(HashJoinState *node) (int) node->hj_JoinState); } } + + elog(WARNING, "bloom filter lookups=%lu eliminated=%lu", + node->hj_BloomLookups, node->hj_BloomEliminated); } /* ---------------------------------------------------------------- @@ -591,6 +607,9 @@ ExecInitHashJoin(HashJoin *node, EState *estate, int eflags) hjstate->hj_MatchedOuter = false; hjstate->hj_OuterNotEmpty = false; + hjstate->hj_BloomLookups = 0; + hjstate->hj_BloomEliminated = 0; + return hjstate; } @@ -629,6 +648,9 @@ ExecEndHashJoin(HashJoinState *node) */ ExecEndNode(outerPlanState(node)); ExecEndNode(innerPlanState(node)); + + elog(WARNING, "bloom filter lookups=%lu eliminated=%lu", + node->hj_BloomLookups, node->hj_BloomEliminated); } /* diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile index 2cb7bab..365123b 100644 --- a/src/backend/utils/adt/Makefile +++ b/src/backend/utils/adt/Makefile @@ -16,7 +16,7 @@ OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \ float.o format_type.o formatting.o genfile.o \ geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \ int8.o json.o jsonb.o jsonb_gin.o jsonb_op.o jsonb_util.o \ - jsonfuncs.o like.o lockfuncs.o mac.o misc.o nabstime.o name.o \ + jsonfuncs.o like.o lockfuncs.o mac.o misc.o murmur3.o nabstime.o name.o \ network.o network_gist.o network_selfuncs.o \ numeric.o numutils.o oid.o oracle_compat.o \ orderedsetaggs.o pg_locale.o pg_lsn.o pg_upgrade_support.o \ diff --git a/src/backend/utils/adt/murmur3.c b/src/backend/utils/adt/murmur3.c new file mode 100644 index 0000000..764aeab --- /dev/null +++ b/src/backend/utils/adt/murmur3.c @@ -0,0 +1,315 @@ +//----------------------------------------------------------------------------- +// MurmurHash3 was written by Austin Appleby, and is placed in the public +// domain. The author hereby disclaims copyright to this source code. + +// Note - The x86 and x64 versions do _not_ produce the same results, as the +// algorithms are optimized for their respective platforms. You can still +// compile and run any of them on any platform, but your performance with the +// non-native version will be less than optimal. + +#include "utils/murmur3.h" + +//----------------------------------------------------------------------------- +// Platform-specific functions and macros + +#ifdef __GNUC__ +#define FORCE_INLINE __attribute__((always_inline)) inline +#else +#define FORCE_INLINE inline +#endif + +static FORCE_INLINE uint32_t rotl32 ( uint32_t x, int8_t r ) +{ + return (x << r) | (x >> (32 - r)); +} + +static FORCE_INLINE uint64_t rotl64 ( uint64_t x, int8_t r ) +{ + return (x << r) | (x >> (64 - r)); +} + +#define ROTL32(x,y) rotl32(x,y) +#define ROTL64(x,y) rotl64(x,y) + +#define BIG_CONSTANT(x) (x##LLU) + +//----------------------------------------------------------------------------- +// Block read - if your platform needs to do endian-swapping or can only +// handle aligned reads, do the conversion here + +#define getblock(p, i) (p[i]) + +//----------------------------------------------------------------------------- +// Finalization mix - force all bits of a hash block to avalanche + +static FORCE_INLINE uint32_t fmix32 ( uint32_t h ) +{ + h ^= h >> 16; + h *= 0x85ebca6b; + h ^= h >> 13; + h *= 0xc2b2ae35; + h ^= h >> 16; + + return h; +} + +//---------- + +static FORCE_INLINE uint64_t fmix64 ( uint64_t k ) +{ + k ^= k >> 33; + k *= BIG_CONSTANT(0xff51afd7ed558ccd); + k ^= k >> 33; + k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53); + k ^= k >> 33; + + return k; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_32 ( const void * key, int len, + uint32_t seed, void * out ) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 4; + int i; + + uint32_t h1 = seed; + + uint32_t c1 = 0xcc9e2d51; + uint32_t c2 = 0x1b873593; + + //---------- + // body + + const uint32_t * blocks = (const uint32_t *)(data + nblocks*4); + + for(i = -nblocks; i; i++) + { + uint32_t k1 = getblock(blocks,i); + + k1 *= c1; + k1 = ROTL32(k1,15); + k1 *= c2; + + h1 ^= k1; + h1 = ROTL32(h1,13); + h1 = h1*5+0xe6546b64; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks*4); + + uint32_t k1 = 0; + + switch(len & 3) + { + case 3: k1 ^= tail[2] << 16; + case 2: k1 ^= tail[1] << 8; + case 1: k1 ^= tail[0]; + k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; + + h1 = fmix32(h1); + + *(uint32_t*)out = h1; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_128 ( const void * key, const int len, + uint32_t seed, void * out ) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 16; + int i; + + uint32_t h1 = seed; + uint32_t h2 = seed; + uint32_t h3 = seed; + uint32_t h4 = seed; + + uint32_t c1 = 0x239b961b; + uint32_t c2 = 0xab0e9789; + uint32_t c3 = 0x38b34ae5; + uint32_t c4 = 0xa1e38b93; + + //---------- + // body + + const uint32_t * blocks = (const uint32_t *)(data + nblocks*16); + + for(i = -nblocks; i; i++) + { + uint32_t k1 = getblock(blocks,i*4+0); + uint32_t k2 = getblock(blocks,i*4+1); + uint32_t k3 = getblock(blocks,i*4+2); + uint32_t k4 = getblock(blocks,i*4+3); + + k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; + + h1 = ROTL32(h1,19); h1 += h2; h1 = h1*5+0x561ccd1b; + + k2 *= c2; k2 = ROTL32(k2,16); k2 *= c3; h2 ^= k2; + + h2 = ROTL32(h2,17); h2 += h3; h2 = h2*5+0x0bcaa747; + + k3 *= c3; k3 = ROTL32(k3,17); k3 *= c4; h3 ^= k3; + + h3 = ROTL32(h3,15); h3 += h4; h3 = h3*5+0x96cd1c35; + + k4 *= c4; k4 = ROTL32(k4,18); k4 *= c1; h4 ^= k4; + + h4 = ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks*16); + + uint32_t k1 = 0; + uint32_t k2 = 0; + uint32_t k3 = 0; + uint32_t k4 = 0; + + switch(len & 15) + { + case 15: k4 ^= tail[14] << 16; + case 14: k4 ^= tail[13] << 8; + case 13: k4 ^= tail[12] << 0; + k4 *= c4; k4 = ROTL32(k4,18); k4 *= c1; h4 ^= k4; + + case 12: k3 ^= tail[11] << 24; + case 11: k3 ^= tail[10] << 16; + case 10: k3 ^= tail[ 9] << 8; + case 9: k3 ^= tail[ 8] << 0; + k3 *= c3; k3 = ROTL32(k3,17); k3 *= c4; h3 ^= k3; + + case 8: k2 ^= tail[ 7] << 24; + case 7: k2 ^= tail[ 6] << 16; + case 6: k2 ^= tail[ 5] << 8; + case 5: k2 ^= tail[ 4] << 0; + k2 *= c2; k2 = ROTL32(k2,16); k2 *= c3; h2 ^= k2; + + case 4: k1 ^= tail[ 3] << 24; + case 3: k1 ^= tail[ 2] << 16; + case 2: k1 ^= tail[ 1] << 8; + case 1: k1 ^= tail[ 0] << 0; + k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len; + + h1 += h2; h1 += h3; h1 += h4; + h2 += h1; h3 += h1; h4 += h1; + + h1 = fmix32(h1); + h2 = fmix32(h2); + h3 = fmix32(h3); + h4 = fmix32(h4); + + h1 += h2; h1 += h3; h1 += h4; + h2 += h1; h3 += h1; h4 += h1; + + ((uint32_t*)out)[0] = h1; + ((uint32_t*)out)[1] = h2; + ((uint32_t*)out)[2] = h3; + ((uint32_t*)out)[3] = h4; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x64_128 ( const void * key, const int len, + const uint32_t seed, void * out ) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 16; + int i; + + uint64_t h1 = seed; + uint64_t h2 = seed; + + uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5); + uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f); + + //---------- + // body + + const uint64_t * blocks = (const uint64_t *)(data); + + for(i = 0; i < nblocks; i++) + { + uint64_t k1 = getblock(blocks,i*2+0); + uint64_t k2 = getblock(blocks,i*2+1); + + k1 *= c1; k1 = ROTL64(k1,31); k1 *= c2; h1 ^= k1; + + h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729; + + k2 *= c2; k2 = ROTL64(k2,33); k2 *= c1; h2 ^= k2; + + h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks*16); + + uint64_t k1 = 0; + uint64_t k2 = 0; + + switch(len & 15) + { + case 15: k2 ^= (uint64_t)(tail[14]) << 48; + case 14: k2 ^= (uint64_t)(tail[13]) << 40; + case 13: k2 ^= (uint64_t)(tail[12]) << 32; + case 12: k2 ^= (uint64_t)(tail[11]) << 24; + case 11: k2 ^= (uint64_t)(tail[10]) << 16; + case 10: k2 ^= (uint64_t)(tail[ 9]) << 8; + case 9: k2 ^= (uint64_t)(tail[ 8]) << 0; + k2 *= c2; k2 = ROTL64(k2,33); k2 *= c1; h2 ^= k2; + + case 8: k1 ^= (uint64_t)(tail[ 7]) << 56; + case 7: k1 ^= (uint64_t)(tail[ 6]) << 48; + case 6: k1 ^= (uint64_t)(tail[ 5]) << 40; + case 5: k1 ^= (uint64_t)(tail[ 4]) << 32; + case 4: k1 ^= (uint64_t)(tail[ 3]) << 24; + case 3: k1 ^= (uint64_t)(tail[ 2]) << 16; + case 2: k1 ^= (uint64_t)(tail[ 1]) << 8; + case 1: k1 ^= (uint64_t)(tail[ 0]) << 0; + k1 *= c1; k1 = ROTL64(k1,31); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; h2 ^= len; + + h1 += h2; + h2 += h1; + + h1 = fmix64(h1); + h2 = fmix64(h2); + + h1 += h2; + h2 += h1; + + ((uint64_t*)out)[0] = h1; + ((uint64_t*)out)[1] = h2; +} + +//----------------------------------------------------------------------------- + diff --git a/src/include/executor/hashjoin.h b/src/include/executor/hashjoin.h index 7a51ea6..f2bee7f 100644 --- a/src/include/executor/hashjoin.h +++ b/src/include/executor/hashjoin.h @@ -72,6 +72,15 @@ typedef struct HashJoinTupleData #define HJTUPLE_MINTUPLE(hjtup) \ ((MinimalTuple) ((char *) (hjtup) + HJTUPLE_OVERHEAD)) +typedef struct BloomFilterData +{ + int nbits; /* m */ + int nhashes; /* k */ + char data[1]; /* bits */ +} BloomFilterData; + +typedef BloomFilterData *BloomFilter; + /* * If the outer relation's distribution is sufficiently nonuniform, we attempt * to optimize the join by treating the hash values corresponding to the outer @@ -186,6 +195,11 @@ typedef struct HashJoinTableData /* used for dense allocation of tuples (into linked chunks) */ HashMemoryChunk chunks; /* one list for the whole batch */ + + /* used only when the hash join has multiple batches */ + BloomFilter bloomFilter; /* bloom filter on the hash values */ } HashJoinTableData; +bool ExecHashBloomCheckValue(HashJoinTable hashtable, uint32 hashvalue); + #endif /* HASHJOIN_H */ diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index 5ccf470..e4660bd 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -1764,6 +1764,10 @@ typedef struct HashJoinState int hj_JoinState; bool hj_MatchedOuter; bool hj_OuterNotEmpty; + + /* debugging and profiling of bloom filters */ + uint64 hj_BloomLookups; + uint64 hj_BloomEliminated; } HashJoinState; diff --git a/src/include/utils/murmur3.h b/src/include/utils/murmur3.h new file mode 100644 index 0000000..e12bf08 --- /dev/null +++ b/src/include/utils/murmur3.h @@ -0,0 +1,29 @@ +//----------------------------------------------------------------------------- +// MurmurHash3 was written by Austin Appleby, and is placed in the +// public domain. The author hereby disclaims copyright to this source +// code. + +#ifndef _MURMURHASH3_H_ +#define _MURMURHASH3_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_32 (const void *key, int len, uint32_t seed, void *out); + +void MurmurHash3_x86_128(const void *key, int len, uint32_t seed, void *out); + +void MurmurHash3_x64_128(const void *key, int len, uint32_t seed, void *out); + +//----------------------------------------------------------------------------- + +#ifdef __cplusplus +} +#endif + +#endif // _MURMURHASH3_H_ --------------060507030306080009060607 Content-Type: image/png; name="hashjoin-bloom.png" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="hashjoin-bloom.png" iVBORw0KGgoAAAANSUhEUgAAAl0AAAFUCAIAAACRBx4pAAAACXBIWXMAAA7F AAAOwgEILXo4AAB3wElEQVR4nO2dB1wUx9vHZ69wHEfvvYMoYom9BKOi0Vgi 6iv2RKPRxJKoiTExiTExKkSTmH9iizEaNbaE2DUWNCoWVCwgNpqggHTugDvg yvvsLd6dx4GoS5Pn+1nX2WdnZmd2j/3ts7Mzw1OpVARBEARBEDW8hi4AgiAI gjQiUBcRBEEQRAvqIoIgCIJoQV1EEARBEC2oiwiCIAiiBXURQRAEQbSgLiII giCIFtRFBEEQBNGCuoggCIIgWlAXEQRBEEQL6iKCIAiCaEFdRBAEQRAtqIsI giAIogV1EUEQBEG0oC4iCIIgiBbURQRBEATRgrqIIAiCIFpQFxEEQRBEC+oi giAIgmhBXUTqEIqiVCpV/edWm5jPXTalUtmxY8fY2NhnypPdU4EgSN2Buoi8 hNRGgZ5bpS5fvtyuXbvnS4tUpX///kePHm3oUiCIFtRFBHk2jh8/3rt374Yu xctDYmJiQxcBQZ4AdRGpQ3g83s2bNz/44IMLFy6AfwZysnbtWldXV9iVnJz8 2WefgcYUFRU5OzsPGTJk6dKl5ubmsOvOnTuzZ8++ePGiUqns0KHDqlWr2rRp U3Nueui+tFyzZs3KlSvT0tI8PDy+/fbbUaNG6cUpLy+HXSdOnGBy5vP5r776 6v/+9z93d3eDlYKYmzdvNrgL8jx//jwUPi4uzsHBYeHChe+++27VaNUVqbpd TAl37949Y8YMODleXl6rV6+GY0GB792716pVq40bNzKnSMOjR49cXFySkpIg IWN58OABJIR1YWGhwdNbA7UvwDNdVm9vbzMzM+a8hYWF7dixA8Jwbr///nvI Fq4snMC33noLjGVlZZ6entevX582bdqpU6dKS0vBUnOZEeS5QV1E6hAul/v2 228vWrSoV69ecG+FO+Z77723f/9+2DVu3LixY8f+8ssvcNO8f/8+3D1nzZrF 6M3EiRMh1T///KNQKOCGC7dCEJuac6uOnTt3/vTTT9u3bw8MDAS/ZMKECQKB 4M0339SNY2RkJBaL4f4LOUdGRspksk8//RQKs3fv3qoZSqXS7Oxsg2JM1Pd3 UI7vvvuuS5cuqampUFo7O7vQ0NBaFqm6XUwJFy9evG3bNtCk8PDwSZMmgaj8 +eefoBawCfp08uRJ3aOAKsNzw759+6AijAXCr732GtiHDh1q8PTWQO0L8KyX FR5NdB9i4GrCZf3999979Ohx+fJlOANubm59+vSBAoAQQlZggfMDylpzgRHk RUBdROoQuJd98803AwYMYDa//vrrFi1aMGHde7Gvry9oEvgQzOatW7fGjx9v YmIC4Q/UPDW36gD3C5yPTp06QRgcmoiIiCVLlujpIgD+x1dffTVo0CAIgwcD RwkKCjKY4ZkzZ7p161bd4eB+/fnnn/ft2xfCrVu3hnxAI/V0sYYi1bALSvjl l19Cnsw5gZxBokA+mU1Q06qFGTNmDOiWri6ChVR/emumlgV4jsuqyw9q+vfv D2F4+lm+fDmcE9BF0M6CgoLBgwcPHz68NqVFkBcBdRGpW4KDgzVhe3v7oqIi g9HALcjLy2PCoHzz5s3r2rVrv379wP4cuWm4fv26royBGxcXF2cwJtyFNWFH R0dNYfR4auOibj7g9IDzVPsi1VxajcBYW1vDun379ppNg+cBJAS0B3ZZWFhI JJJz584xLyprOL0186wFILW+rBpiY2NDQkI0m6CI4LtrNjWPRAhSp6AuInUL 4x8wwFO/JgzO39KlS/fu3Zueng53bblcrtm1adOmFStWgK8wZcqU119//eef f/bx8ak5t+qAnJnGLQbwBYuLiw3GNDU1rU3OJ06cmDNnTg1HtLKy0s2zpKSk 9kWqubSaujPF09usiqWlJXiuhw4dAjfxyJEjIOdgITWe3pqpTQGe77JqgPra 2NjoWgQCgSZsZ2dXm3IiyAuCuog0DKNHj27VqtXu3bvhZsfcYTV3QNj8Uk1y cnJhYeG4ceMuXLjwfEcBmYEcGP8GALdGV3ieFXB9ZDKZk5NTDXHEYjEjP0wY XM/aF4nd0hL1q9R//vkH1vv27YMTzhhZPL1VecHLCq5tSkrKC9YaQV4Q1EWk YQAPZuvWrSKRiNmEG3fVON7e3qBD8fHxz32U9u3bnz17dujQoczmuXPnXqTr ITiLuq9Jq4szYsQIJnz58uWuXbvWvkjslhYYMmTIu+++C94bnN61a9fq7X3x 01uVF7ysnTp1io6OHjhwIItFQpBnBXURaRhatGjxxx9/vP3227m5uQcOHIAb qKenZ1JSko+PT3Bw8KhRo9566y0+n79u3brOnTs/91FmzJgxb948cNqCgoIS EhI+/vjjJUuWPHdux48f79evXw0ROBzO8uXL7e3tO3TocO/evTlz5vz444+1 LxK7pSVqF23w4MELFy4EpdFoVQ2n98UH5XmOy+ri4nLlypWAgAAo4Ycffggn YePGjbC3oKDgl19+uX79OuTzIkVCkGcFdRFpGH7//Xe4A3700Udw737jjTe2 bdu2fv36Nm3alJSU/PDDD7Nnz/7kk0+YroQQ87mPMnz48Ozs7NGjRz948MDD w2P+/PkaZ+45iIqK+vbbb6vbW1FRAXX56aefmP6LdnZ2mm9Ta1kkdkvLwHyV qquvLJ7eqjzHZQUVBBcZzh7UfcCAAUuXLp05c+adO3dAJkNCQn7++WcWi4cg tQF1EalDqjofGkv79u3PnTunu2uBGqL+7jE6OvqZcquB6Wpqzq2WOdc8Mgvc 7iUSCQQuXbpU8+GqK1ItS/vUTV3AX9TbW93prTmfWhbgOS5r//79Hz58qNkM U/NMZUMQdkFdRF42FAoFl8tt6FIgCNJUQV1EXioqKiqOHTumGfwMQRDkWUFd RF4qRCKRtbV11a9dEARBagnqIvJSUV5e3tBFQBCkaYO6iCAIgiBaUBcRBEEQ RAvqIoIgCIJoQV1EEARBEC2oiwiCIAiiBXURQRAEQbSgLiIIgiCIFtRFBEEQ BNGCuoggCIIgWlAXEQRBEEQL6iKCIAiCaEFdRBAEQRAtqIsIgiAIogV1EUEQ BEG0oC4iCIIgiBbURQRBEATRgrqIIAiCIFpQFxEEQRBEC+oigiAIgmhBXUQQ BEEQLaiLSHNhy5Ytb731llKp1DX+/PPP4eHhEFi4cOH06dNrtlMUtWfPnjff fFM3h1OnTvXu3VulUtV1qeri6AiCVAV1EWkWgKIcOHBATz/AuG3bttOnT/P5 /NGjR7u6ug4ePLgGO2xu3LhRT5l+/fVXgUBQD6Vi/egIghgEdRFpFly4cGH7 9u27du3SNYJb9tVXX3l5eUH4888///HHHxkFqs4ul8s5HE58fHzr1q2ZHFJS UkpLSysqKnSzlUqlvXr1ev/9999++23GsmnTJsjk3LlzJiYmz12qWh4dAKO3 t/eOHTumTp2alpZWVlZWXl4+f/58OJBEIhk2bNi6deugJA8ePBg4cGBcXBwk yc7OdnJyyszMtLe3h82goKDDhw+DJMfGxs6dOxfWYOzQocOqVavatGnznNcA QZoIqItIs2D58uVVjTdu3IB7PRN+5ZVXrl27VrMdHDtw4EAbwEtjLP/73//+ 7//+Dzw83WyFQuG+ffuCg4NbtmzZpUsXEL/PPvvs7NmzeqL4rKWq5dEBY2Pj kpKS9evXHzp0yNPTEywrV64EsYScuVzuIjXfffcdyB7sSkpK8vHxiYqKAn/0 5MmTYWFhiYmJFEUxe8eOHfv1118PHToU1Be81WnTpp0/f97gGUaQlwbURaT5 UlBQYGVlxYStra3z8/NrtgOhoaEff/xxXl6ejY1NcXHx3r17ly1bNm7cOL2c HR0d//77bxCtrVu3jhw5EhQFHLgXLFXtjw5uJeydN2+en58fY9m2bdvOnTtt bW0hPH36dNA50EUIDxgwAGQVYoIu9u/fH9agi2ABO5OwsLAQPEhjNR+oqWUt EKTpgrqIIM+AkZHRqFGjwBX79NNPf//9dxCq6pr3goKCfvjhh65du3755Zca mam3owOa161AWlqaRiN9fX1hkwkPHDgQfEfQxRMnToAn+uGHHxJ1Ayf4iEyE H3/8cdiwYV5eXn369BkxYkT37t1ZqQiCNGZQF5HmC+ON2dnZQRicMMadqsHO 8O677/bt2xe05Oeffz5w4EAN+d+7d2/SpEl37txhpVTPenRdySwrK9PdRVEU E+jZs+eNGzcuXboklUoHDx48derUy5cvx8fHg52JMHr0aLCDHymRSO7evQtH XLp06TNVB0GaHKiLSPOlffv2IAPgMxH1JzCaVr3q7Az+/v4+Pj7Lli1zdXXV OGFVOXXqFDhhe/fuHTt27IYNG6ZMmfKCpXqmo+vh7e2dmpoKaSGcmJjIfNRD 1A7oa6+99s033/Tq1Qs2g4ODlyxZAmGwa9KampoOHToUAiUlJU5OTqiLyEsP 6iLSfPnwww+/+uqrli1bqlQq0AbNVzDV2TWA0zZt2rTffvutupzv37//1ltv gTQS9dcxnTp16tatW2Bg4IuUqvZHr0pYWNiOHTs++OADhUIBjiZsanYNGDBg 1qxZv/zyC4RBEWfPng0RNHtBKUeNGgV1Ae/z77//9vX1rf1BEaSJgrqINAs0 bw6ZANNlECThwYMHHTt25HA43333XUhICBOnOruGESNGfPvtt6GhoQaPJZVK YRdIF+OW2djYrFy5EtTl0qVLep+kPlOpanl0g3z66aczZ84EfxHyHDNmzOef f67ZBY4piCV4jUStixDWbQ394YcfQCk/+eQTHo/XuXPnrVu31v6gCNJEQV1E mgXVjQgzRU0t7ZpMwHm6efNmdZkLhUKmw5+GUDUvWKpaHt2gEZL8qqZqTE9P T01k8Gj1Enbo0CE6OtpgIRHkZQV1EUEQBEG0oC4iCIIgiBbURQRBEATRgrqI IAiCIFpQFxEEQRBEC+oigiAIgmhBXUQQBEEQLaiLCIIgCKIFdRFBEARBtKAu IgiCIIgW1EUEQRAE0YK6iCAIgiBaUBcRBEEQRAvqIoIgCIJoQV1EEARBEC2o iwiCIAiipVHr4o4dO8aOHatUKvXsW7dunTBhgmYC1cLCwjFjxpw7d6579+6Q xMLCQi++wQgGjZGRkTNmzIAjrlu3btiwYWDJzMwMCQm5cOGCmZlZXdcXQRAE aXAary5GR0ffuHGj6lzkYNm4caOuZdmyZcHBwTt37ly9enV4ePjSpUv1khiM YNA4d+5c0EgOhzNx4kRGF8GyePFiFEUEQZBmQuPVxZiYGNAqUC89+/79+zt1 6nTy5EmN5cCBA3v27DE3Nw8NDR01alRVXTQYwaARvENwH0F6MzIyYPP48ePg Vo4cObJuq4ogCII0GhqvLs6ZM8egHXy7rVu3RkREaCypqamurq4QcHNzS05O rprEYASDRi8vL/BT5XK5t7d3WVnZvHnzIiMjWa0WgiAI0qhpvLpokFOnTllZ WYF66RplMpmxsTEEYF1aWlo1lcEIBo0gt2FhYRRFbdiwAQQYPMXY2FjwIMGy evXq4cOH62YbFRVl8HAIgiAIiwwePLg+D9fEdHH58uUffvihnlEoFILIwVoq lYpEoqqpDEYwaByqBgJJSUkLFy6MiYnx8/PbtWsX0+Kop4t9+vTRO9CBAwfq +fohCIK83MB9tZ6P2MR08V81TBh8uF69eoEH6e3tnZ6e7u/vn5aW5uvrWzWV wQg1p5o5c+bKlSsFAkFWVpZuiyOCIAjycsOaLoLv9dtvv/3999/x8fGFhYWW lpatW7ceOXLkO++8A+rC1lE0n6eCKGrC4OHt3r171qxZsB4yZEjVVAYj1JAK LFZWViEhIRD29PRkWhwNKi6CIAjyksGOLl64cGHChAl9+vRZsGBBmzZtrK2t 8/Pzb9y48ddffwUFBW3ZsqVLly7Pmicon26gaocNDfPnzw8LC4uIiAgODt6+ fbtuDkwqgxGqSyWRSBYtWhQVFcVshoeHQzQOh6PXOQRBEAR5KWFHF+fMmXPk yBEfHx+NxVFN//797927N378+IsXLz5rnjUIod5ec3Pzw4cP1xDHYITqUpmZ mSUkJGg2Q9XUvtgIgiBIk4YdXQTvSigUGhsbFxUV6b019fPz0+1riCAIgiCN GXZ0EUQR1vPmzVu2bNn06dMdHBw0b0EBExMTVo6CIAiCIHUNm9+jrl27ViwW L168WNdY8+tQBEEQBGlUsKmLWVlZfD6fxQwRBEEQpJ5hUxdRFBEEQZCmDpu6 WFhYuHDhwkOHDmVmZspksr59+3799dc9evRg8RAIgiAIUqewqYuhoaHdunWL iYmxt7eHzbFjx06bNi0+Pp7FQyAIgiBIncKmLl68ePHAgQOasUbDwsKqmxMD QRAEQRonbOpiz549lyxZMm/ePAiLxeLvvvuuV69eLOaPIAiCIHUNm7q4efPm Dz74oEWLFnw+PzAwcMCAAb///juL+SMIgiBIXcOmLubl5e3atYvFDBEEQRCk nmFTF4OCgnR78WdmZrZs2bKwsJDFQyAIgiCNjuIicvRPwuWRN6c2dFFYgB1d 7N279927d4nOJBiAjY3NmjVrXiTbHTt2jB07VqlUaiwpKSmTJ0++dOmSj4/P +vXrmWk6QHrHjBlz7ty57t27QxILCwu9fAxGMGiMjIycMWMGHHHdunXDhg0j anUPCQm5cOGCmZnZi9QFQRDkJeTuNbLvNxK1m5RJibUDGfQW4Rk1dJleFHZ0 kRkZHPTj+PHjrGQIREdH37hxQ28YuXfeeadfv34HDx7ctm3btGnTrl27BsZl y5YFBwfv3Llz9erV4eHhS5cu1cvKYASDxrlz54JGcjiciRMnMroIlsWLF6Mo IgiCaAEVPBVJK+LtK1pj/iNyZj/pPaLhisUObL5HZVEUgZiYGNAqUC9d4/jx 48eNGycQCEaPHq3pBHLgwIE9e/aYm5uHhoaOGjWqqi4ajGDQCN4huI8gxhkZ GUyNwK0cOXIki/VCEARpwjxMJvs3kiNbiaTgCbtnSzJ0CunSv4GKxSZs6iJ4 jR999NGVK1f+++8/EDBQlw0bNgwYMOD5cjPY93Hy5MlMABSra9euTDg1NdXV 1RUCbm5uycnJVVMZjGDQ6OXlBX6qXC739vYuKyubN29eZGTk85UfQRDk5UGp IOePkP2/kcsniUrbtkV4fNJzCBn6Dmnbs+EKxzJs6uKMGTO++uorCMyePTsi IsLd3X3q1KnPrYs1cPv2bVDNvXv3MpsymczY2BgCsC4tLa0a32AEg0YodlhY GEVRoOjh4eHgKcbGxoIHCZbVq1cPHz5cN9uoqKiqhwM3lM2qIgiCsEdeccXZ xKKz94r4XCruQcmzZ9CJcDo9YVARcgYW+p+QUu6a1ZalkjYkbOpiUlJSaGgo +GFZWVmjR4+uqKgw6L29IHFxcUOGDFmzZk3btpUXQCgUgsjBWiqVakbb0cVg BIPGoWqYuixcuDAmJsbPz2/Xrl1Mi6OeLvbp00fvQCCKgwcPZre+CIIgL0hu kfSvM7d3nEo4E5euVH+00bO1G3keXawJBUc+aNAg3a8vWaH+nQ02ddHNze3G jRt//fUXSAucmsjISC8vLxbzBzIyMkB4wHUbOHCgxujt7Z2enu7v75+Wlubr 61s1lcEINaeaOXPmypUrBQIBaLxuiyOCIEhTQVxatif67o5Tt45fTamQK3V3 pT4qZP1wKg7JvH3LuWUr1nOuZ9jUxWXLlg0YMMDR0XH//v2w+eOPP/7vf/9j MX/g448/Br8NHkl0jSDDu3fvnjVrFqzBlayaymCEGlKBxcrKKiQkBMKenp5M i6NBxUUQBKlD4s6Ri8dJUQ6xdyOO7sTJgzi4ExtHwuHWkEhaJj8Yk7j9ZMKh mCRZuVx3F4eierZ2Hf1aq/8LbmlrIdRPmRRPtyAe30mkT7iSOcTyTBGJtiFF AaTUT6k0MXxcI0ogMWG/4az+YVMX/0+NZvPChQsvkpvGGWcCTIeN7du3Q2DJ kiXMrnv37oFczZ8/PywsLCIiIjg4GCLo5sCkMhihulQSiWTRokVRUVHMZnh4 OETjcDgbN258keogCILUljIpOb6L7F1PC1WL9uTO1Sf28vjEzoWWSUeQSTda KdXhCkuHo1fvg3e499xdibRcL8tOLZxADkf1aulqW6XXWUUZOb2X7nQR/8RN u0JJLvMFx7z5t9uolMYq/VRqjDnCAIcuga49Wjp28bIJ4nLY1JSGog7r8PDh Q39//5KS53yFrddzkUG3j78Gc3Pzw4cP15CDwQjVpTIzM0tISNBshqqpfbER BGk+KOWKrOu30s9deRhzPe18rImNFQReJENroaKTS9krzjJj3uMboJ4oAvIK kplKL0wZCPUf5badCvybapFPjPXiBrpYjOnbJqxPoK+zlYHjZd1X7ftNdXAz p7jwCbMx92gA/z8/fokR4588cTcW8cxbOncNdOoOWuhu3ZJD1eS8NkXY1MWj R49Onz49JSWF2bSxsfnoo49YzB9BEKTBkeYXpp+/mn4+Ni36SsalG+Ul2o/S hVb6g23VEooiftblnV1lvtYVup+tyJVUYonZozy5EVdlaaygF6FSqJZMFaFi KKftVKtdJCCTMtXL0JsUjlbdGq28FZSWrfqdI9tqWiC0qjCzV1g5quxdKCdP 5aN049hj1vn3KKLSHFDBoS67co/6CRIcuKonv54xN7IOdKGdwpaOXV2t/CnC 8sc1jQo2dXHWrFlfffXV6NGjhUKhWCxetmxZz54vT48WBEGaJyqVKvd2Eq2F 0ZdhDWGDb7OAsiLJs2YOIgfeYUeXMvAUde2FMs6lh8axGQKOjUNxVs4Tuyys 7rh4x9r55hiZ6+XmTCSjVLdBEbuotN8JUkQprBDDQsT3ycNKo5yieDq1KBBy TvjxT/jyIaAxWgsdA527B9Ba2MXZwudZq9Z0YVMX09LSxowZw+fzTUxMKIr6 4IMPOnfurHEfEQRBmgrgBYIvCB4h+IWgheAjVhfT1NHOrdsr7j06wNqpQ2ue oNajgybGkT3rK0cW1QDeYofe5M2plt0G9KM4/dS2MnGxtKAoITHj7wvJe+My k/KlejmZEkV7ac4reSmBhYkmRJxtqTgtMrYUKqz4SmtKKTKk4kk2vBa5FeAU gmsIDiK4ieAsgt3B1D3AqUsrx27gF9qbudW2Li8XbOqir6/v8ePHBw4c6O/v v3//fi8vL/AaWcwfQRCk7ihITks7F/vgfCyss+PvKOUKg9E4XK59a38QQleQ w+6vWHm7P9th5OX0IKL/rCM3Lz5hF5mT18fS81G4PvHp++30vIMXE3ecunX5 bqZeTibGnI6tSPuWJc5OmcXluYXSvLNSeZmc0ruxG8uJbYnCvlhlV6K0o9cK 2xJVicD4cAvqmL9RhjnH2cK3t1PXAIfOrZy6WZs4Plt1XkbY1MVVq1bNnj0b dDEiImLKlCmgi8eOHWMxfwRBEBaRl5VnXolnWgphrfe6UhehtaVbt/bgEbp2 be/Sua3AzMD4IU8nN4Mc2EQObqLH19bFqxUthyFhEsK/+yD/7smEOw/y7qTn 332Qd/tBrpUZeZjzhEJzeXInp/se7omwhnCWgmQ9qOmwMh55YMF98Ljpk8fh mxvbtHV5zYhvHOYIctjFQmj7PNV5eWFTF/v06RMfHw+Bvn374utTBEEaISU5 +ennruTcSryz/wSIIkijwWgURdkG+NBa2KMjrCH8QsO4XD9L9v5Kog/Sn5Kq kRNOCtf6TqvX7/r0uqu0uHs6/86fGzPyiqsm5XLLKcJXEYrDUTo4pru7J7q6 pvB4hotNx+fwQPYshHZWQntzoY2l0B5kz8LY1srEwZwO2JgZWz9/RZoHL0Nf EwRBkBooSE67f+YSOIVpZy8zX804tgnIunFbL5qRyMS5UxumpRC0EHzEFz2w rJTuI7/n1+yU1NuUzV0SeJeyguU21zGZmFcoCUmA5SmDZcrKKXePe3b2mW6u SUYCGcgeCBujc4zgWZrYmdOb9hbGduZCawi/aLGbPWzq4pYtW7744ov09HTd XobVfbiFIAhSRygViuy4O7QWnr18/+xlScYjvQi5d5K5RnxFeYWFu3OlEHbv 4Ni2JYf3ol3xSssq7j7Ivxd3++7Jk3fupt6Rm9+l+hdyBU+Wz3BailKKRBIz 80Jzs0JYm5kVOtmSXi1edbN51dXSDzw/cATBBXy5+0g0BtjUxblz565du3bI kCFGRk1+vmYEQZoWFVIZ3bleLYTp566UiQ28kwRA+ZzaB7r36OjZu4tr53am jnYvclCJtPxWWm5cSs6ttLy4lOxcsfRqYtZjXwC0sEUNEmZlxrO2LOEI0k1E OYwKmpoWcTi0ZloK7Tp5DOjqNailY9eXr9d844dNXQTXcMCAASiKCILUD9L8 QkYI06IvZ1y6oaiQG4xmJDJx7drOvWcnj54dXbu1h83nO1yJrOJ2el58as7N 1Nyb93MSUrJTc57osNiem69SGWi9Ewq4/i42/q7W3s6mRsaZEtWlLOlJFadI L5q1yKmzx0CQwxb2HSmKUzUfpH5gUxeXLl365ZdffvbZZzY2NixmiyAIoqEw 9QEthHR74eWchMTqWmpE9jbgFHoEd3Lv3sHpldbP8YK0rEKRkJiRkJB0M/HB zbT8+EfSVLGhgSh1MOXIOQqVBxH7qfL97U0COnf079nd39XGxpK6mn7sQur+ Gw9PV8jK6Kg6qmdn6trFa1AXjzd87dvjO9LGAJu6KBAINm7c+P333+sasX2R BVQK+vs1SvD0mAjy0qFSKrPj76o/nLl8//Ql8cOs6mJa+3qotbCze48Oti28 a5k7yc8muZnl2Rl37j1IeJAX91Byq0ARV2yULBcqyFOcNi5RepOiIFVOS5IL 61Z+fv4pewQDxpChnxAXH0lZweX7/26/fig+46xcWaGX1tHcs6vX4M4eb3jb BtWqqHUN3GeUxURZQpRl6kApUcmIooS2qMqIopioSolSpt4lVccRPw5I6ADE gdPVsspork0QltsXN2zYwGL74o4dO8aOHav7FU9hYeGYMWPOnTvXvXt32Gth YVGdUZfap4qMjJwxYwYccd26dcOGDQNLZmZmSEjIhQsXzMyqDEJfHyhJ0WGS /QMxH0gc5jVEARCkvlEqFHl3U7Ku3cq8ejMzNj73boo4Xb9LOwOHy3Vs19K9 ZycQQo9XOz2lsVCpIA+TSUoCSb0ll4jvXY+Pz6m4WcJLUFnHU7b3iLWcVkFw 1/QHV9Mejqg8SVFrVU6gKjeQ5LbiSVrZ8gU29sTWidi0JvYuxM2ftF0nJqUX Uw/HHPkiIeu8Qqn/atfV0q+L56Aunm+4W7d8+rlQyYn0Jql4qLWACKke3xJp oXostyBLIGOaVMrHEzaAZ6LUGV9FIan87IfnSMruqkVORksgBFSGxzF4Bl6W Z3c2dZHD4fTv358tUYyOjr5x44aeu7ls2bLg4OCdO3euXr06PDx86dKl1Rmf LxVIO2gkVGTixImMLoJl8eLFDSSKhIj/Jekz4f+yR7+sunqa4tmYCaxMBZbq xcrM2BoClRZjKyOu/lD6CNIkkMvKwCMEFcy4Ep91LeFR3J2KUu1QZ84dg3R1 kW8idOnc1lPtFLp2e6WmLvY5D2kVVAshvb5/h5TLpIT/PdXpisjnH2m3ymjV v7n0VBW1MpK0FlW0sua1djJt6WFj4hhET39o66ywspUJBaUKWZGiTFZRIlfK i6TZ6YV3r0X9evvRJWUVjfGwbsXIoYtlLWZylecRyUkiiSIlZ4lxS1IS8/Qk z4pJByKNYzlP2mVUkqc52Y0fNnXx+++///rrrz/55BNbWxY60MTExIBWgXrp Gg8cOLBnzx5zc/PQ0NBRo0YxYmbQ+HypwDsE9xHEOCODHnX3+PHj4FaOHDny xavznJj1l6ochNQjAUfVknttW1pNrRtcJc9IaSwkJsYqkZBrKuKYifgW5rSC WliY2JoILK0tnUBBrW1d+EbGzzlgB4KwgaxQDPrHqGDmtYTc20nVDboGCMzN RHbWbt1pj9C9Z0enV1pz+YZuXJICknyTpN4mKTdJyi2SmkCK9T9s+Ydq8TGn dxKxdJcaGKLSiS/zNpV6WZXb25Q7OamMnWQV5pxShbRCIbujkF2vKJUrK6R5 EkWuvDTO8PjgxnwRaKSuxce2LWhhZ883HM09n3ZWVEQaTySniOQ4HdB05pDe elrC58LgZ64cE9rn45oRjrAyQAkJx/hxQEA45vQmvagDdBxNwELtLzZ5USTs 6uLs2bMlEsmKFSt0jc/dvjhnzpyqxtTUVFdXVwi4ubklJyfXYHy+VF5eXuCn yuVyb2/vsrKyefPmRUZGPl/52YHi3inu3c5sBwT7O3AOZCmL9BsptCg4cimn WEp0Pk+vUC9gyHsiJkdKTLPMpaZiSk5xHo+bwS15PBF0mYpSqMMKwnn8Yob7 eC4dTjlFMWVQEq5MkyFFlCozB4fyy9lmUjMOl2tsaU5xKPWaI7Aw4/B4oMRc I76RyIQrMIJHfr5QwDMW8GETjKYiuNMJzE2ZhISihFaPE3K5YH/+E4g0DsQP szKvxIMEZl27BVpYkJJec3wQQsd2rZzaBzq9Aktra18P/eFmyqS0BIL4wTo5 nhbCPMPvWhniKbtZnH6nSOVYpmnEXGQktTHPFVkViCwLLCzyLCzy+Xz6jwF+ 3Q/VCylSL8+Cp03r21kXKUL52XdQy+FAO1PXp6RRlpLi/4jkP9o7lBsaiA4k ytifcC1pWWKgjGhjJVzC1fkDAbnS+L9ckfYOT+vc4zd5FF+tf3x1AKTOlHBE lQFEDZu6mJOTw+PV7QA6MpnM2Jh+Wwjr0tLSGozPlyoiIiIsLAz+Ajds2BAe Hg6eYmxsLHiQYFm9evXw4cN1s42Kiqp6OHBDWawvkHfXy9GXOHoTAYeMz+P9 tU+lEBF6MVUp1Wt1GCyq2n/IphSSchN5Bd0Wo/vUUl24tvDE2fzWCvk+sckt jrTgGe8oNWTbspX8VsLT4z0LlJuHKv0+4XIpE/W9QCCgF7AbG1N8Pl19kSkI M1x3SkQ71hSPyxGq70RGAo4R/SOHTXjghlPOMYUcVHDT5ohEHA5RKolSJiWP Owwoi0tV6hu6qrxcVV7x2FjCPC6q5HKVtPKFIQSUCrXPpFSpSh4/3MjKKEtL SmjM9fLht2ppHODPtbenVEoOoWNSSjmlbmriquBwKnhQ56hbm6AUlPo9HhfW lRFoO0VUXHVzF+zlVNe3nA1USqXsYbY0JaM0+UFJUro05WFFkeHehBoEDjYm 3q4mPq702tvFyMYSjGXw/ArLnXjq1nXTwizT3AfmeelmeQ/MctJMCrOpp/1K 5XxBsY1rqqXPEon7nkc2isczCvKNytu2vu7td4WiXugk8CgBh+LyKSGHcIw4 QopwOWKzjqaj3AXtTIiVKpVcTL1GyDWDaUX8XAeTOHvhTWtBIofS95VVhFNY 5vGoNDBHFlhU9jRlrS2aypapF6Ra2JSxuhZFQCgUgp7BWiqVikSiGozPl2qo GggkJSUtXLgwJibGz89v165dTIujni726dNH70AgioMHD2a3yoVlJD3Dw7Fk OoS79zUq6fhnfqGxUq5UiMXlFXJFcYmyvLyiQKrMkFYoimRl+QpOSXl5QQVP qlCKK3gyBbdUwS+jF+MKhbFcIVQojem7CaWqg8/BuSqpn+rhDIXHEsooi7X8 eUZGhnulvQCgePStSKFQSdT6/fit2At+PC0IalMWd+PF8tCHq/JUXE8lFy6A forhwtnaU4FtSau2HHrdhnrelm9XU/LgKVL1DNCnMSXJ5NH94qtXVXcTVIm3 iaEnVC3wROLpQwUEEf+WHP9WlH8rpZl5MdF91wEaL/dIjva7fcQt56Z94nmu otoRQRmUXH6unX+OQ0C2Y+tsx5bZji0ech+euxB18TxVXs5n4oCU+vjebB10 yUSo4vP9eHx7iuJxOCKKMqY4Aq7ai+JyzSnC43JNKcqI4gg5IHiUERd8KYrH 41rQ31FwzcDC0XpsWpxEJLOE3OfSs0XBH4Cx+lUll0P46peLxpwKR1WMi+qk q+qEKchmFeSURSH/1UJB31LjYDnHmkcRWw7RNEqVKWhlgyeqMrWMKlSkQq10 5WBX/3CllY9VtAWAvQq1vUxO/7DBXqaOL1fSi4cZuf/Mk0U+BQGXfPwKy3mS OnA2nkoTGx/V29s7PT3d398/LS3N19e3BuMLppo5c+bKlSsFAkFWVpZui2P9 Yykgll79SVJrIo3nUuUDvCOJ87fPmolMQd/yVeqAQikvLissKZeWyUtLK+h7 TblCLq0ohj+bCvjLqZCUy+m/njKFrEJRBka5UlkulyjUf1EyOUQDMQGvqLxC IVXSPqpKJqebahTKsmLOGaJUgDP6cLmTt/kartQIhIcUS2gfSiJWqeg1HS6R 0IJUUkJPuAPeUlkZKZOpymSkvIzehCKVlsBBIBoFRy0Ww42I5XNaZ1BG7H+P pyx9or1KlZut+u8Y+e+YUj22NfHwplq1BaWkxRIEptbPpi8yCDbJy1GlJKpS k1TJd+l1SiJYwFwaGKS8Wc2nHMZCyr8lpZZAqkUg5eNPqjlX/PJS3zvH/BMO +t3+11haCJZc9/YGRJGiCqw8cpwCc+wDHjm1hnWenR9Io0pVUVx8Vlx0+M7V H69cbisustKksLd/+MorV909XzE3/9HJpnep3ICwsULZY/dPqn6gM6VyXDkn fbmnvDmnjaiSqvFzlP6JytfuKfo+UHZQEv1mP1M+Ka6+9eS5wf5zNdDEdBGc ud27d8+aNQvWQ4YMqcH4IqnAYmVlFRISAmFPT0+mxdGg4tYXFLGfS+5PpoMF u4ntdGL0bPOFGj/+WxPSF5xnWzfTyiTmXP3mcFiZXFquSFfyF33+5m4eh18X B2IFeYW8uJC+ScllZaWlMvqxoBieE+TwVFAuprW8TK6kA/DcIKsoL6G9H7lU Vq7ulC0vLqlQP5PLxWIl/aSgUBQXw4O80MWp1NGOA74Cn88zqRxUhSMSgVzB sz9FD/lc2YTDFQopIyMeh/YqjCwrexZxjIy4JkI+Be4s4UNMLn3ZlDJZaUZW Xuz1nCvXi27cVEi1H2rSjfcgS6lJ5FAkk9y4VaBxm7ZGQW1hTdw8GTdCpr47 67kLtZRFOASV9VAtgffUEngP/MJKJ7sKynxtOzZlZQ06zfEPpNW6RUvi7kVx aupZLyrJ8bt1uEX8Qa/EUzy5THcXU9QSU/tsx1bZIIRqjzDXrkW5QPtySKmS FUuixEWHJJLjRUXU9WvdHjx4TZu5qKRHD2W7V0JFou85HLqZjVs3z1rKx2pD EaUTJ96XG+XLOenMiasqQ3KVIFXVPVHxWqKiT6GqpjeldVRUpAYary5qmtmZ APP9zvz588PCwiIiIoKDg7dv385EMGhkEj5HKolEsmjRoqioKGYzPDwconE4 nI0bN9Z5nWvArDcxeYWUxhJVBcn5H3GJaMjCVIOvXfv3g3/4Meo9cE3vZl9Z e2bejF6rGu34HTw+z9JOv6tr4+Ud+v28Uq7Ijr/zIOb6Q/WSk5BY2SSpRlle XnrtKizMptDa0qVzW9fObV06tYGAyP7po1BB/gXJadk37+beTs5JuJdzKxEC zDNBzXCN+Db+XvaB/natRzu1CXBs18rC3blW9cpIIdEHyNmDJCGG7l+oh40T 6TbAptvrpGVnkYWNFyFeT+4vk5deTY+6kHoQ1hCWy/kJNzvcudNOqawUE4ER mTrYY9lbw02F9dKLSSGpkJzlSKI4JacoeW7V/XKuk8S4T7Ggj8Som0wltCfE Wv2YQtRepkrnLaj88WtSeKKSCQlPXSEBV93FkqIDAJeqfENrxKWfpQCh2g5h I3UA9nLVdgFP3RZO0Z8p0HlyKjNEDMKmLt6/f3/BggWnT5/Ozc21s7MDf2v5 8uWOjs85+7PBD1nNzc0PHz5cG6NuDs+UyszMLCFB+5VHqJpnKnldAS5j6ng6 UBhJbN8jAq+nJWgAungOGt3xk+2Xl0P4bNI/DmYe//cKDkfAGhweFyQHlo7v joHN8uLSjCtxIJAPLl6DddGTnd+l+YWJR/6Dhdm09HR17dKOUUqnVwL5JkJ5 WXnu7SRYQF9BAmHJu5uiKH/6OzsjkYltgLddS1+7Vn4QADm08nZ/hoHW4A/z 3nVaDqMP0X0qquLuT7q/QXoOIQGvEEPDhJaUi2PTj8ekHrr+4L9yBe1cqgiV mhIQd72rVFbppoN4hL3WMmJKHze7avvp11xKohCrB38ppReFpHIIGG24RD3a i0S9KaU3FcVEkcNXyvRzorhE2J5+tDXrwzMOsCLEytDxkMYDm7o4fvz43r17 r1q1ysbGJi8vb8WKFRMmTDh27BiLh2jWmPYgoi6k5CI9LEX2j8RtVUMXyDBv tpmRWZR86t4uCEdeW+Vk4d3Tp3E8WLx0GJmaePbqAguzKcnMZvxIkMmMy3Gy oic+qyhMfQBL/E76EwbQMAsPl6LUh7ruZnUIrSxsW/rY0xLoYx9IryHt80zS q5CT69G0HJ47RLKrTDAP+teyA+kxmPQYRNz8DGYgkeVfSvs3JvWw3rBqeXkO V2N7wlpj6eDn+PPM/l1buhguCWib+DgpT1LrHOhZUaWwwZoOM4L3dC/ZAIIA UvZ4WkeuJTENVsvha3QYaTqwqYvXrl07cuQI822nvb39F1984eJSze8SeT7s 55GUUXSg6ACxn0EE/g1dIMNM6bE8p/jhzcxoFVGtPTPP1tQ1wKFTQxfq5cfM yT7gzX6wEHVPidw7yQ8v3WCUMutagu5cE0q5QmAqMiiKpo52dq187QJ87AL9 6XUr3xeciYmemzfmODl3kFw4QiSF+nt5RqR9MOk5mHQbSI8jY4iC0keX7h+5 mHr4VtYFvXFkwDu8e3PAnURHzdslJ2vTJZOC3+7fhmNQuUHt8jaT3F+JcQAp Of9C9TII35FQKvALiam64QOniGqasKmLHTt2XLp06ezZs21tbcFf/OGHHzp1 wrshq4g60U+gxafprkiPfiTuqxu6QIbhcfjz+v762b5BWeIUeK7//sTUrwfv qcV4HwhrUBwO/Z6zpW+7iXTnInlZedbVm5qGybx7qSIHW/D5wPPTeIG0R9jS B7xDdkpQmEvOH6LflF45ScqrvFo0MSNd+tNy2LkfHdZBWlGcUZT0oOAurGFJ L7yTX5zJvCzVxdm89aP7ISf+U5bIKvXeiMedNazjVxN6mgoNDUWpUURFAb1Z evnpVaCHcRGqB39Rj//CEdE95elxXkzUi0g91ItuWESP+cLD2YSaPGzq4pYt WxYsWNC+fXsQRaZ9ESws5o/QOMxV6yIh4iNEdpMYBzZ0gQxjYmS2oP8fXx4Y JpblwbL86ISlQw+BsaHL1UzhCYxcu7aHhdkszcvPSL836u+fjU3ZvCLSMrlR bjr3nLrh8ObF6r6joRsO279Ke4qgntKch5k3HhYmPSy6lwHrwnv5pfrTZfjY tU3KuU7ojzwpb9s2XTzfyHvU5pstcSlZhZo4b3b3W/FuX19nQy13tCJuIrkb KhWRAdRL1IV+7UlLHaNt5o/DIvUQMKbo7TVb2NTFwsLCrVu3spghYgBhW2LW l0hO0N8FPPqeePzW0AWqFnAQwWv85nAYuIxZ4tSVJ6Z++vqWxtxzozmQkhd3 Numfggv/tCrgJuSlCbhCAV9ozBMJOcYiJc+IZ2zENRbwTCAgKFfwdAd/UNI9 SnWzUsmkqTLOtTLzuHLTG+Wm18rM3ChJdLm9G5G4E09PYuVJFXmRQk8i9nCy dnn1NU7PQdkutg+LQPzuZF44nE57hIml5U/vW24msApw6NzZc2Bnj4EZ2fwP 1hw7df2MZm8rD9uV7/Yd0MnQrFIGFZHvROzeJ1Zh9ChoCGIINnUxKChI9yPS zMzMli1bgliyeAiEBlxGSRSti7CWXiPCdg1doGpp4dBp+qsrf/nvAxVR3cyM /jX6k/de/f7pyRC2geeS6OQ90Ul7LO/d/b/rZb55iocOpp4ZzHhghbXMpJjw 4ym768T+OuVwg9jFUfZi8sQbSy5XXkG4ycQSFrpbgEZVHxFOpEp4eI9IJBaJ imFtUhkgJiYcvcHYuByevZm7i4Wvs6UvrF0s6YAJ3yy3SLro99PrD12TKyrj W5oafzWh54yhHXhVu/ihIiIvADu62Lt377t37xKdToeAjY3NmjVrWMkfeQLj VsRiICk6RIfBZfT8o6ELVBM9fULhpvzXVVoO/7u329nC5802Mxq6UM2FQmnO +eR9oIiJOddaZsunXC9rlV35blNYUqXN70nong/EXCOBVymHFGJR83gAqYpq 38oqlVRJiRksenaKozIXldtaEjcHU18n65aurm29fL0crN3szPmPe9iBEP68 98oXm08XFleWGYTw3TfaLZ4YbGtRZcwaZYm6HbGqIs4gVqNQEZHawI4unjx5 EtYhISHHjx9nJUPkKdh/SIqO0F/fFJ+h52YTdW7oAtXEiPYfZolTzib9A+Ed l8PBG+jmZWBYIoQtSssll+4fOZv8z82Mc0qVokWOYuENWVCWtrVPxeXae3dT +reVCnjSihKZvFRaIcmXSuPEnDiJ0b0i4+RiUVqJlVTxlLlULQXlQTZ5bezy 2tjmOVrkOFoUK6wUJhyLtALTlHxzWKfCkmeWkm+WX2q4W71KSRVJBEUSkpRe cQr8Snq5QmivkXKxNfN0sLAyE15LenT/kXaEndfaun8/LaS9r4N+XrQigo/4 25OK6Kz2EVERkWeAzfeoKIr1h8CPWA4lhXvocPZK4rWzgctTIxShpr+6Mqf4 wZ1Hl5ieG3amrr527Ru6XC8bFYryaw+i4PnjanoU8wGnf65i5I2yNpk6465z eaTv/1Hj5xMX79SswuvJ2TeSs+NSckB7kjMLlTXOCsehVL624jbO+W2dc9s4 5bdxybc3l1wvUl0tVF0uVInlKk+TVqkZCWa87O42uYM8KB9TrXMpKeOnFZil iL1TS7ulSrxTc5X3H4lB7XKKDHcTVChVadliWCBsLqqUZ3d78x/f6xfao0r3 JFREhFUa7zhwyFOw/4AU7af7+IO/WHyWmPZs6ALVBNNz48sDw7LEqWVyacSx SUuHHrB96tR0SC1QqZQJWedBDmNSD5eUV06365OnGHW9rK2uIlIcEjKqYsxH hx6SnX/EXU08fjs9z3COj7EQVrRxzGvjktfWKQ/kMMg534SvzlDgQ8xeV5q+ Wkh5OUjzukqzW0pzC0ofgW/a0f11ZwtfZwtvZ0tfIn9ICv+hl4oMM0FFoGM+ LIRcpp+URJ2IxTBiMbmkwjj1UVFKViFoJChl6qNC2EzNekIvXw1y/+962oKw bnNHdBYKnrxl0Yr4O8nd+KQiuhC791ARkecGdbHJYuRJLEeQAnpYGZL9fSPX RcDc2GZB/z8+2zeotFwiluWBNH41KBJ7brwIybk3opP3nEveB5qkMXrnKUbG lb3y8ElF7D08rvd7v98o2vbxoexCWnK6BOiPX8qhKB8HDviCbR2T2zjmggp6 Wet8LEoZEVE3use6WW9i5EHU87JbwyKqfuwOrg9x+Ij+TKzkAq2ORYceDyKj oh/mYMn6WmTWJ9B6ZKD7q4R64l5UWlYB6khr5KOiCoVi3QcDXGye/KlUq4jg I/4fKiLyItStLsrl8nqYlLH5YjeLvt2oKkjpVfrbVDP9+SAbG47mXuA1Lvt3 glxZkVZw+4eoaZ++voWDvcSeEXVjLcjh3oyiJF27Z4Fy3E0qKK2UaF6HUpz8 HsP/9Byx6fKjK189MSKjRFpuIRK08bINcpW3c0xrYxPT2i5RZFRlcFSevXok s97E9FW6b9/zwCGi7vTi9DUR/0uP7ltyjjDD1ihltFjCwrOh3UfLN4kwiElj IuC38rCFxUB+lYr4G1EUao2oiAh7sCNaBgdLBKOxsXHVGe1fhOvXr7/77rs3 b94MDAxct25du3btiLrf5JgxY86dO9e9e/cdO3ZYWOgP2GEwgkFjZGTkjBkz lEolZD5s2DCi7m0SEhJy4cIFs+edALYOMXKlXxblb6PDj76nb16NdfIKDYFO Pab0WL72DD2YeFzGmd/Pf/FO96UNXaimQWFp9rmUfSCHiTnX9HYFlIgm3RV6 3ErRKKKC4v7bOmyTsOu+y4/Kzl/XjWxvaTLuNZ+xnbM72sWTYpCoqlO3c4iw Nd1NFn5REGDrR8UREsth9CJ/RAr30gIpu1O5S55H8n6jF+MWxDKUjsOr8lkN oCx+3I5YqDXSijiDWI1ERUTYgh1dZLot7tmzB3Rr6tSptra2WVlZa9eu7dyZ 5e8kJ02aNGvWrLCwsD///POdd965coX+dG3ZsmXBwcE7d+5cvXp1eHj40qX6 91mDEQwa586dCxrJ4XAmTpzI6CJYFi9e3BhFkcFuJin4i761yW7SI+CYD2zo Aj2d1/xGZRYl773xC4SP3d7iYO45uPW7DV0oNiguIg+TiIsPMWVz+qqScvGl +0eik/cwH5fq7hLwhK8bd3ojNtfy8kWNIt6mbDe5vbmlxC0jQUaIdjJtPo/z RmefSf1av+HzH1/8Pf1KU/LoiSNxTGmnkPEOeXUyQ2cloHm279KLNJ7+dqxo D62LDKCUWcvJo+/od7aWI4h5/0on1aAiwnOh7fuoiAjrsPmSc8qUKampqaam 9Myr7u7uCxYs8Pb2ZtSFLW7fvj127FiBQAC6NXv2bMZ44MABkGRzc/PQ0NBR o0ZV1UWDEQwawTsE9xFkPiODvqEcP34c3MqRI0eyWAWW4TsS63EkTz03ZPaP xPx1dbtPY2d0x0+yxKkXUw9C+M9LS53MvTq492voQj0v4nx6gojTe8mVU6Td q+TyCWLvSrwD6cUniF6DUnKf/odWrpBlS9Lzih9mF6fnFj/MLX6QU/wAwsZc kyxJqm5MLofXxjm4n0mnticucM8cJCq6n3sREezktNpk1vN8sYg8BIO2e2KQ l92k19uM69PanhtDMqeT3Pu0VRhE+21E3VDNuIaizvUtMOCMwuL4KT20YeHf 9ChOzCRNIP/FZ+kFRBGkkRLQL2BREZH6gk1ddHJyWrVq1bvvvmtlZVVQULBu 3Tp7e3sW8wfAw9u0adP48eN3797du3dvxghi7OpKf9no5uaWnJxcNZXBCAaN Xl5e0dHRcrkcFL2srGzevHmRkZHsVoF97N4jBTvox3/ZXXqeDYuhDV2gp0MR 6v3gH/JKMhJzroIP9NOpGV8N+tvLJqihy/UsFGSTswdoObx+lp5BiSFfPbZn 9gN6ufBvpdHImHgGEO/WtEZ6BZZ5+ORwSrOL00D8ctTix0hgkdTANLaAvbkb E4CT5u/QsYf3sB68lqJda8nJL0ARVYQ6Q7lvpIJ2cQOlSg4p1ia0NhOO7dPq 7f5tOvg5kvL7JHOWepikxyiKieNnxLwfrYsNC8WtdFIVEiI+SDeZl1yqnOAe ftXgUEIEjaMMimg3g3YlURGROoNNXQStAh8RpBF8LAsLi06dOu3YsYPF/IGf fvqpR48e06dPt7W1PXv2LGOUyWTGxnSv4eqaMw1GMGiMiIgICwujKGrDhg3h 4eHgKcbGxoIHCZbVq1cPHz5cN9uoqKiqhwM3lM0K146WVt19LOjOoyUp3556 AHeUJuAyAu1UYzI4qaXKgjK59JsD4wZYfmzCbewzthpL8h0TLzklXrJ+eIdS KfX2ynKyBFwepZA/YS2XkbvX6EWNgBCRkMO15MisuPlWnAxLzkNzjoJTbRte vuSRi6C1Hc/HS9jZPr/M/9AOk9vnQDbSiPlmTtBmKiiJWNLxHpcFcnrFw6xv S6su3uZ8bnnOvXOJ2f96m5/gUJXSIlcK7hYOTJW8plRxCYlXL40HU0ImmPAG uoguu5nFmPBywJQn9bYxvlcqt04sGvCguLPyLhT736dmhCDPDZu6GBAQsGfP HhYzrMr777//7bffjhs3DhR32rRpp06dAqNQKASRg7VUKmVmf9TDYASDxqFq IJCUlLRw4cKYmBg/P79du3YxLY56utinj/73nyCKgwcPZrvStUDRg9wJJspi ES97UI9y+v1SE6FzQfuvDg4vLZeUKgouK//4ZtA+Aa/KyF6Ngaw0cnYf+W8P uXWZVOn8LvPyy2rf/l4Lr9sqTmFJkmn2HfOMdIfcEo8ChXuh0kKmL59WUiUs ms6Fcg71wJJKt+Tl2FuUuLjKvVqY2PvYmbnZmbrailxsTV35XCPyMJlsjSAn dksV1J9Uq02coCjioTcqW4CbDXiHE0JaO9uYqg0quodrZkTl+1IailgO5znO b8Wzb8X6KWKZt+nyl14lRQdsKtKI2TsmlsPbUPw2DV0spP6pf2ejiXWiiI6O hnMEHh5I46xZsxijt7d3enq6v79/Wlqar69v1VQGI9ScaubMmStXrhQIBFlZ Wbotjo0UcLNsJ5Hs/9HhnJ/oz/mopnFl3a0C5vRet+zoBKVKkVZw+6dTM+b1 /bUR9dx4kKj8b4/ydCQv8abeHhWhkuz5592oGFd+jumjBw/u3v1daCIwuf/A G35cfH6FkZFMIJAZ2chEXJktkTrJS13LZV6yEh+pzF5Rak1JrYnMWiXjEiVP qfLMh6WcJIN7BMtVYmlHfFpXvno1v0u/rT2+67zCYRMVspPbsoj2ObVYiARh vVqCInZrpdOVUHaTZC5Wv5B8jDCIOC0mJk1omCGKntoXFgSpX1ieZwp8rEOH DmVmZoIr1rdv36+//rpHjx4sHgJkbOvWrSCK27dvB/eUMYKHt3v3bpBJWA8Z YmDgTYMRakgFFisrq5CQEAh7enoyLY4GFbcRYTOV5P1BFEWkPJ3u7G89tqEL VFuCXF6d1O2b3859BuEracf+uLj47a5f13MZxLK8QmlOXklGYWlOfmmmKvmm 4414n1upTrmlnCc/ZFJS5LY9L8aNXvJN6D0FBXbXorpnZ9Oa5GgnZaJVVPBh 0QyTnaR3PB3dt6DKbVWl1kQKGglrG6LWyyKpdWyOdewhG/K3kuKdUTlvoibd 5j4x4S2Hovq09wA5HN6jxROjwCgKyKMf1L13Hvup8Njk+Andt6+JvGBHkIaF TV0MDQ3t1q1bTEwM87nN2LFjp02bFh/PZuvFxo0bp06dOnv2bBDFX3/9lTHO nz8/LCwsIiIiODgY9FITmaIopgOJwQjVpZJIJIsWLYqKqvxCITw8HKJxOBw4 NIsVYR+uGbGdQh6tpMM5/yNWI+iv+JoI/QImZIlTDsbTF/RIwu8uln5gqaNj gQTeeXQ5S5KalHOtoPRRfklmoTS7QlFO1P3iu94v75Yudxbrv/lUUCTBgXfB nX/JjSc2rnx7KZWZ3LzRLTnZX/X4faZYbGwiIKVVOwRWT5HKqIgYJTETM2nQ CZtRconqib9TH2ert/oFweJub/5EXioFKfiTFkXNEDDgeVtPIPZz6NnkEQSp HWzq4sWLFw8cOKBpqwM5mTNnDov5Ax06dIiNjdUzmpubHz58uGpkzWSQBiNU l8rMzCwhIUGzGarmhQpdb9hMoscBkeeTiiySv53YvN3QBXoGxnVamCVOBX8R wr+f/8LW1KW9K2vD92RL0m5lXbzz6NKd7EsPCxPB4mUTlJIXBwFKRXzzFJ3T 5V3SKuyL9eWwgkPFO3Gve1uktHA3tnGzFNqFiJwthfbmxo77Tpf+dOReiayy jZDHUb3bLWHxCKEtOV7Bcc3nhORTPfLK/fOLy/Il0nyJDNZ5YjqgXlcGiqXl Ty28nZGiuJyrUlGmQqORrwZMer3Nq63dDAykUXKRZH5Dvz7VIOpGnBfTQ8wj CPIssKmLPXv2XLJkybx59FAmYrH4u+++69WrF4v5I0+BIyK200mWuvtmzmp6 /lVOo/yGxRAcijv7tV8WHRyemhevVCn+d2rmV4Mi3a0Cni83yCG94A6jhbcf xegOH8qQUZQYkC1n5NCmVP87GgWfX9S6raxbCP/VYa1tvNtzdTxv+aN/Th6f sflSYrb2nWRfv4c/hZ5r5VhAj71SQfjKBw7KTQ5kE+FZErc+dA8802CD16Jc rsgXyzQyqQ5UimhuUWXY1lzYzco05BUPEEWQRgO1hcegrGX0JzbkcUX4zsTp 8yYxyAOCNELY1MXNmzd/8MEHLVq04PP5gYGBAwYM+P3331nMH3k61hPoGVnl 2USeQ/K30EOKNB0EPOH8kI2fH3gzvySztFyy/OjEpUMPgotWy+TlClly7g1G C+9mX4YcDEazk3FGPDD3lhi5J+iLJTE2IV0HkOA3uV36WxvrjAVa8ZD2xkpi rt5OmPu3x6lEZ01Dna+tOGLIxdCgFPqNpaAV/bmToogenIVBUUiPdgYLx1g9 lEx/Yt6X6PRFMeJxHa1FsNSyjvqoKkjuOpKz5vF43IQ+ED2UzHt0AEGQ54Ll fv27du1iMUPkmYG7od37JPMrOpyzlh4Kh/O899yGwFrktKDf5i8OvFkml4I6 rjj+zhcDd9bQc6OkrOhONniEl25nxaTk3WCaCasi4Jn42b0SXGzX7so989gY Wq7cdN4umlqo5XAo6diXCB4fq/w+PQsEPe3DRdDFTLHJ54c6bbrUVamqfINp KSz/vN/VWf05Rub9iKgLMelEN/EStVaVnKPHZxGfoB9QGJQyIj5GLxlcOiZ4 kGb96C7qL4LkBP3itPy+1mL+OnH6gvZZEQR5AdjURWNj46KiIoGgyXzu8XJi PYb2ISoy6Y8v8n6nB1BtUrhbt5z92i8rT0xVqhSJOVd//m/W3L6/UjofouSV ZIAKghyCa/ig8J6qSud6BnNjmxYOnVo6dg4wbeV55QZn10aSdki7O/0e8WxJ AjqAd0g6vEZ46veTZfdIfkylFj7u81eu4HwX9cryqHbFZZV/LHRTYm/u4gnB to4fG5higuIT01704qwkpdeI+CiRHCVlKZV76fkyL9BL5tfEuBUtkLAYt3y2 c1SeSjK+IsX/aS0CP+K0iJiy+e03gjRb2NTFefPmLVu2bPr06Q4ODgZn2EDq A8qInn8qg+72QL9TtZ7Y5L5F7ODeb0LnLzZf/ArCl+7/u/3y8ld9ht9+FHP3 0eVbjy7mFj+sLqG9mXtLxy4BDp1bOHR0tvAlKTfJ3g3k+CIiLXkiXutuZNhU 8uoQwuOpB8/bTgthaYx29OrH/BPnNX9/l8Rc7Qkc0NFz5bR+huc/0odT2f3O cQGtuCCQsEjjtK2AsgR6yf6RGLmpX7H2JyYdSM19N5WldPy8TbRXygAXFy63 zaSnJEQQpNawqYtr164Vi8WLFy/WNaqqDA6C1DlW/0dy15LyNLqtK/dX4jCv oQv0zAwMfCejKOnY7S0Q3ndjNSwGo3EorrtVQIAjCGEnkEMrE/XkRPIKcmYf 2Teb3Ih+IrZQRPqOIkOnEDdz2mN7OIOUXn5iNGodrma4zt3f69Qd7VtoX2er ldP6Du32XJ93gj9n50cP7FmRRSTH6LesoMSqx8PFladXzrLEtaIHLAWBFPWo 0kCookcKzVqufTcLums1kjh8XLdzXyBI84NNXczKyuLzcTDfRgDFI/azyYOP 6HDe78R2Mmn0445WZVK3b7KL068/OOVk7pUpTtHYjbjGPnZtQQVh8XfoKOSb atPkZpADv5ODm0n+k9/UuPnRctirE1FEE/En5G4CEb5CpPodfugGQpNOmRWd Pv9btCnqofLxI52lqfHnY7vPGtbRiPfCPhk9/8kEelGI6VG8wYMs/k/71Yyi gB6TARaOCf0mFjTSrA/hWtC9LzK+oAdF02DSnjh9SYTtXrQ8CIJUgU1d1BPF hw8f+vv7l5SUVBcfqUMshtFdNcqS6cnNc9bSU/k0NcAX/OC11b+d/yy/JFNS VuBv3zEAnELHzl42bejxQnUBAbt+luxdT6IPEd0xuzlc0v0NMuA14plDJDtI Zrh2V9ntylka4IlB1JGIuhKTzlLK7/vIK8t3ni+WVvaL53E5777RbvHEYFsL tnu8cM0rJ+lVlZHiaHUz5HHti1xQSvFheoFC8hxoL1MzeA3Pjjh8pB4CFwev QZA6gU1dPHr06PTp01NSKh/tbWxsPvroIxbzR54BuJ/af0jS1VNU0h02pjbF t20mRmbvv/pDfmm2rciRogzJQKmEHN1ONyKm3XnCbmVPQvqQnqaEF03k0USv 3ZDi0y155iHEpAsx9mdGl/kn+u6ctb/df1SkiTWgk/fKd/vWrinxBaAEtFMI C4h0aWzlW9bytMq9YJTnVooiXFObyfSHVE2twRhBmhZs6uKsWbO++uqr0aNH C4VCsVi8bNmynj17spg/8mxYDCI5v9AToCuldMBpUUMX6Hngcnh2ps4GdqQk kH0byLEd+t/UtAwgrzmTAHg4O0pv6s74xBES09fUfST66ErL1cRHc9cdP3U9 TWPxd7Ve9V4/0EVWq/I0QPZEnejF8TMiu0136pAcpWe0F7YmijzCd6NfnOLg NQhS97Cpi2lpaWPGjOHz+SYmJhRFffDBB507d9a4j0i9w6EHxkybTgfztxPb aXTjVt2hktM9HMCzMfKgx1upo88j5RXk7H6y7zf6xakuAgHp5ka6SIhzNiHZ T+ziWtBCaD6A7ln/5KAzmfnFn/9+etPRG3XSlPgiGAfQi/2syiEF+PZEhI+Y CFJPsKmLvr6+x48fHzhwoL+///79+728vMBrZDF/5JkB3wi8DfA5VGX0YOLO 39bJUeSPSP4OUrCDGHmRkvO0heIRvisxcqfngjdyIwJPddjjhYYyp7+p2UQO bSZ5WU/YHUxJT4p05hHj/CfsPHv1t50D6LbDKrNuScvk3/8do25KrBwKoA6b El8EvguxHP70aAiCsAeburhq1arZs2eDLkZEREyZMgV08dixYyzmDyiVylmz Zm3evNnBwWHDhg29e/cm6vmtwE89d+5c9+7dd+zYYWFhoZfKYASDxsjIyBkz ZsBR1q1bN2zYMLBkZmaGhIRcuHDBzMyM3brUCxSxn0vuT6aDBbvp0VNBpVhD Rfd2yN9KfzPCdDmQP34Mgs3yVHohp58oDN+BVkd6cdcGuPrXS4tSQUok5O5V +ivTc4doZ1EDhyKtjUhPI+LPf2ImCsjQ/HV6oSca1G+STMsWn45LOxv/4Ex8 esL9XI29npoSEQRpCrCpi3369GFmlerbt28dvT5dv369SCRKT08Hxf3ss8/O n6e9k2XLlgUHB+/cuXP16tXh4eFLly7VS2UwgkHj3LlzQSM5HM7EiRMZXQTL 4sWLm6YoqjHrTXctL42le4KDy+gSwUKeCgkp/IdWxLJ7T9izVETqSGQFRCah O69L1S8ny1T0VyMVKlKuIqoUIlPPRQi7VGojKJ2KR8rhd8injeDYySrg8YeU V5CyyrkMiZGAlOtM3WTGIV1BEY2JpY7sGQeox44ZoDd2jEpFEtJyz8SlR998 AIoIusjY/VwqO66AFoIi1ndTIoIgjZimMau7hj///POXX36xsrIapYYxHjhw YM+ePebm5qGhoWCsqosGIxg0gncI7qNKpcrIyIDN48ePg1s5cuTI+q0l24DL mDqeDhRG0iNKC7yePyvZLXrCWxBFTZc7hiJ/EllC+HbkUtSzZ1rxlP2eluSu uj+iF4+8akza8gmP8RA5xKQtrYXgHYLrqclOrrxyL5NxCkEO88TSqlkmZxb2 6+D1RiefmW924HGxwwOCIFrY1EVwFj/55JOLFy+KxWJLS0sQGPDDWrRowe4h EhISQkJCnJ2dt2/fHhBAz0OUmprq6koPwezm5pacnFw1lcEIBo1eXl7R0dFy udzb27usrGzevHmRkZEslr9hMO1BD2xND7CioEcRc1v1zDmoyon4CMnbQg8Q owvHhPD6k4NF5PDeRwrBDqFVCdXNnYg9VWIPUuhMSrjE8OClzwCXIialpJsx 6SkgrupvYejvNruqX5b2p/v2qSmRVZxPeAhCCK5hzJ0M2DSYmVDA69zCOTjI rUega8/WbiJjHIYCQRB92NTFoUOHTp48efPmzSCKBQUF4NgNHjz43r17T09Z a0Bxb9y4kZiYuGLFitmzZx89Sn+LL5PJjI3pQbNgXVpaWjWVwQgGjREREWFh YRRFbdiwAUQdPMXY2FgQeLCsXr16+PAnvoCIioqqejhwQ1msL1tYC7p1d7oI AVXh/tO3WkvKnWqZUMjL9zA752YaLeAW69qLK+zTinqQaJnv+d3ZMhJB9d7A bdO5LOs/jrb9kkepHHnlLvwyJ2Olq1GFg5A4GiudTFT2Iq6AS1UI6BG3FUYC Pl9qJCg2EpQI+UVGIokJv8BYlM/jVhAjwviFOdKWdsJbChU/pzQgq7Tto9LW FUp6eLYi6flbmaXxD0oSMkuSc2QKpeERB00F3JZOJoEuolbOJn4OJjwO5Cmu yEo4mZVgMD6CIM0cNnUxJydnzpw5IhF9z7KzswNna9WqZ3dNasTMzOytt96C 9dy5c93d3RmjUCgEkYO1VCpljq6HwQgGjUPVQCApKWnhwoUxMTF+fn67du1i Whz1dLFPH/0J5UEU4VGA3SqzRmosKT5NUapeAVeJ+9SnxVaS4rO0g1h8kvYy NYCvZtaPWI83vVXa6o/PU9MyP6S6b+QElal/SGdBFHW0Sa6iHlQIYCFVnlUc rEQe9hbu9uYepvTa08HCw8HC1t7cyvTxoKDyPPWXO+mwtiNcYjyLa9rLkWMi e1QUF5cOfuHZ+PTb6XnVDb7rYmsGTiF4hLBu5WHLwVHsEaTJUv/OBpu6+Ouv vy5btmzmzJkgirm5uWvWrAELi/kDHh4eEgk936xKpeLxKgvv7e2dnp7u7++f lpbm6+tbNZXBCDWnglqsXLlSIBBkZWXptjg2YRzmgi7SAfERerxN40DD0RSF 9Jer+duemNiPqLs9WIcRq7Eko5AsWZh06fJSqvsWzpAKou3n5+dq3c7HUVpe kZYtvv9InC8x0LDH8KigBJaYO/qn1ExoBAIJMgli6W4PYunvbt8R1Pha0qOz 8cdOx6U/zDU82zDQ0t0GhPBVWILcIIenng8EQRCDsKmLkyZNAg/s228NdJJj a1aNESNGbNu2DWTsxx9/ZDppELWTt3v37lmzZsF6yJAhVVMZjFBDKrBYWVmF hIRA2NPTk2lxNKi4TQlhW2LWl57MFny6R98Tj9/0I0hv0J+YFu2nJ9HVRdSV HufavD8RF5E1S28d2L9U1XkH9125Ti+Ijv5OX4zrMaSrn65jViwtv58tTs0q pGUyuwjWsKRkFWbllyir+T1IpOXxqTmw6BrtLE1yCg28HudxOe19HXoGugW3 odsL7SyqTIWIIAjy7LCpi2KxuK7n05g7d+6YMWOcnJw6dOgAAskY58+fHxYW FhERERwcvH37dk1kiqIYPTYYobpU4I8uWrQoKqryu8rw8HCIxuFwNm7cWKdV qw/AZZRE0boIa+m1ytkYQAWLDtBjqIIu6sIxpXuU24ynxx6Tl5O/1sT9sXGp LGgX9bZSR/26t3L9fFz3gZ18qh7NVGgU6GEbWKVTYLlc8SBHwihlalYRE7j/ qCg9R1xWoaiaT4CrjUYXRcb8zi2cwSMEv7BbKxf8cAZBENapw/k06gKRSLRv 3z49o7m5+eHDh6tG1jipBiNUl8rMzCwhQftFRqiaFyp048G4FbEYSIrU09aD y+j8Df2+tGC3/hyExi1oB9EytHIy+rP7r/7yw9e5Hnup/1PpKGKvNu5fju/Z p50HeUaMeFxvJ0tY9OxwubIKikEp03LAsyy6/4gWS1BNF1uzod38QAh7tnbt 4OfE52G3CgRB6hA2dXHLli1ffPFFenq6Uqn9Oh/nJWaBR+nEgaVxauw/JEVH 1J/VnCF3+xDdfhQUn+4LaDORmHSstNy/fSF88ZJ7okNUiK4i9u/g9fm4HiBU 7BRJc3yKOFmbwtKNuLCbM4IgSO1hUxfnzp27du3aIUOGGBkZPT02UkvKZeTt jsTMkrTtSdoHk3bBxPkFOuYL/IjlUHrmd2b2QQa+E7EeR6zCtHNRFeWd+eG7 b88V/EvaaEZZA916o5P35+N6dm2JuoUgyEsLm7oIruGAAQNQFFnmZgwtjXlZ JOovegHsXWl1bK9e7J5douw/IBXq4WNKLhDTnvQrU7M+2ukv5OVRv6z++nDS f0pnQiq/6qQo1ZsdPL6Y3PcV37qckQNBEKQRwKYuLl269Msvv/zss89sbGxY zLa5k5tBTMzoCXg1ZD8gR/+kF8DFm1bHtq/Sayv7WmVo5Em/TZXFE5eldFiH w5v+XLI79lwFXL7KKQ85hIzq6PzZ1DeCvOzYqQ6CIEjjhk1dFAgEGzdu/P77 73WN2L74ovQbTfqMJHevkWtnyLXTJO68dkBt4GEyvRzYRIc9AipftLbtQcyt a8pT1JleHgOXaP8/x5ZsPnlJakZI5TMNj6hGB1l99sGolu74lIMgSDOC5fbF DRs2YPsi+3B5pGVHehkzh+4ycfsKif2PlsmES6RCZ6KJ+7fpZc96QnGIT2Dl u9Y2PWh3sxqUKtU/h2O++e3f6xI+IZXR+JRyvL9g4fyJPm61c0ARBEFeItjU RQ6H079/fxTFuoVnRFp3o5eJC2jH8WYM7USCRoJYKuSVcVRKkhhHL3/9Qjhc 0qK9+pudXqR1V2Jc2fldoVTtPHZt6W9HbhYSeo4nNUZE8Y5nxfz5kzx9Peu/ ZgiCII0BNnXx+++///rrrz/55BNbW5zftV4QCMkrvegFkJaQuHO0QF79j1ZE 5eNvTSFw6zK97PiR1tSADil+wdvKPbfEZN7NL9fkJCQVU+wL5n800bVd+4ao CYIgSGOBTV2cPXu2RCJZsWKFrhHbF+sJoYh07kcvQHERuX5WrZGnSWoCXAM5 4ZyhXA8rfPYn+N6+RRFy34UUE2IKcUWkYroo5eNpQx0GvCzDFyAIgrwALM+n oRnLG2lITC1Ij0Gw5BSVHjx57dDJ2KP3xEXyJ+aUaGUsk8iMZvLiPxzzqt2Y dbQriSAIgrCriyiKjQHwz2MTsw7FJO2/cO/K3azHI3RrRVHAUfXiPRppmrOj F8d6ylpigZ+bIgiCaGFTye7fv79gwYLTp0/n5uba2dmFhIQsX77c0RF7gtcH xdLyfy+nHL6UdDAmMSu/pGoEF1uzgZ28B3fx69vew1SI3iGCIIhh2NTF8ePH 9+7de9WqVTY2Nnl5eStWrJgwYcKxY8dYPATD1q1bIWdNy2VhYeGYMWPOnTvX vXv3HTt2WFjoz71nMIJBY2Rk5IwZM5RK5bp164YNGwaWzMxMEPgLFy6YmVXb 26EBufcw/8DFxIMXk87EpZfL9Sej4FBUl5bOgzr7vtHZp52PA87OiyAI8lTY 1MVr164dOXJEJBJB2N7e/osvvnBxYX8gTZBDvSmfli1bFhwcvHPnztWrV4eH hy9dulQvicEIBo1z584FjeRwOBMnTmR0ESyLFy9uVKII+vffjbRDMUkHLiQm ZhRUjWBlaty/g9fgrr6vd/TGWQkRBEGeCTZ1sWPHjqAus2fPtrW1BX/xhx9+ 6NSpE4v5M+zfvx+yPXnypMZy4MCBPXv2mJubh4aGjho1qqouGoxg0AjeIbiP IL0ZGfRU8sePHwe3cuTIkazX4jnIzC8Gv/BQTOKx2NRiaXnVCK097cAvHNTF t3srFx4XJ2NCEAR5HlieZ2rBggXt27cHUWTaF8HCYv4M4Ntt3bo1IiJCY0lN TXV1dYWAm5tbcnJy1SQGIxg0enl5RUdHy+Vyb2/vsrKyefPmRUZGsl6FZyLh fu6OUwkHLiZeS3pUtc+LUMDr3dZjcBffgZ19PB30XyAjCIIgzwqbuggyA4rF YoZVOXXqlJWVFaiXrlEmkxkbG0MA1qWlpVVTGYxg0AhyGxYWRlHUhg0bQIDB U4yNjQUPEiyrV68ePny4brZRUVFVDwduKDtVfcyhG3lrTmXoGe3NjTp4mHb2 Mg9yFQnoeXoz4i9lxLN7YARBkGZJE+tZsXz58g8//FDPKBQKQeRgLZVKmdbN 2kQwaByqBgJJSUkLFy6MiYnx8/PbtWsX0+Kop4t9+vTROxCI4uDBg9moqJY2 ncVrTv0CAS6H6hHo+ob6Ixqc3QJBkGYC687GU2FTF/fu3btgwYJbt24xmy1a tPjuu+8YmWGLf9UwYfDhevXqBR6kt7d3enq6v79/Wlqar69v1VQGI9ScaubM mStXrhQIBFlZWbotjvWPu735/FFdX/Fz7PeKp7WZsEHKgCAI0nxgUxenTp36 119/aTY3b94cGhrKri5q+maAKGrCcIjdu3fPmjUL1kOGDKmaymCEGlKBxcrK KiQkBMKenp5Mi6NBxa0fwqf0bqhDIwiCNDfY1EVzc/OUlJR27dqZmpoWFhZe uXLFxKQ+OgnMnz8/LCwsIiIiODh4+/btGrtGOw1GqC6VRCJZtGhRVFQUsxke Hg7ROByOXucQBEEQ5KWETV3cs2fPp59+OnfuXLFYbGlp2aNHj0OHDrGYvy66 w5GDHh8+fLiGOAYjVJfKzMwsISFBsxmqhoUSIwiCIE0BdnRRKpUKhcLWrVvv 37+/ur2sHAhBEARB6hR2dLFv375//vmnp6dn1V3Jycnjxo07f/48KwdCEARB kDqFHV1csWJFSEjIgAEDRowYERQUZGFhUVRUdOPGjb/++uvYsWN//PEHK0dB EARBkLqGHV3s3r17XFzc+vXrFy9efPPmzcLCQktLy8DAwNDQ0JUrV+JLVARB EKSpwNp3NyB+H6hhK0MEQRAEqX+a2Hg3CIIgCFKnoC4iCIIgiBbURQRBEATR grqIIAiCIFrY1MWtW7d+/vnn6enpSqVSY1RVnTMQQRAEQRorbOrinDlz1q5d O2TIECMjIxazRRAEQZB6g01dBNewf//+KIoIgiBI04VNXVyxYsXixYsXLFhg a2vLYra6pKSkTJ48+dKlSz4+PuvXr+/SpQsYCwsLx4wZc+7cue7du+/YscPC wkIvlcEIBo2RkZEzZsxQKpXr1q0bNmwYWDIzM0NCQi5cuGBmZlZHlUIQBEEa D2zq4kcffSQWi1euXKlrZLd98Z133unXr9/Bgwe3bds2bdq0a9eugXHZsmXB wcE7d+5cvXp1eHj40qVL9VIZjGDQOHfuXNBIDoczceJERhfBAmKPooggCNJM YFMXs7KyeLy6/cB1/Pjx48aNEwgEo0ePnjNnDmM8cODAnj17zM3NQ0NDR40a VVUXDUYwaATvENxH0PKMjAzYPH78OLiVI0eOrNNKIQiCII0HNmWsrkURmDx5 MhMAxeratSsTTk1NdXV1hYCbm1tycnLVVAYjGDR6eXlFR0fL5XJvb++ysrJ5 8+ZFRkbWcZ0QBEGQRgSbSnb//v0FCxacPn06NzfXzs4uJCRk+fLljo6OLB6C 4fbt2+As7t27l9mUyWTGxsYQgHVpaWnV+AYjGDRGRESEhYVRFLVhw4bw8HDw FGNjY8GDBMvq1auHDx+um21UVFTVw4EbymZVEQRBkPqFTV0cP3587969V61a ZWNjk5eXt2LFigkTJhw7dozFQwBxcXFDhgxZs2ZN27ZtGYtQKASRg7VUKhWJ RFWTGIxg0DhUDQSSkpIWLlwYExPj5+e3a9cupsVRTxf79OmjdyAQxcGDB7Nb XwRBkOZM/TsbbOritWvXjhw5wmiMvb39F1984eLiwmL+QEZGBggPuG4DBw7U GL29vdPT0/39/dPS0nx9faumMhih5lQzZ85cuXKlQCDIysrSbXFEEARBXm7Y 1MWOHTsuXbp09uzZtra24C/+8MMPnTp1YjF/4OOPPwa/bdCgQbpG8PB27949 a9YsWIMrWTWVwQg1pAKLlZVVSEgIhD09PZkWR4OKiyAIgrxksKmLW7ZsWbBg Qfv27UEUmfZFsLCYP7B9+3Zw3ZYsWcJs3rt3D+Rq/vz5YWFhERERwcHBEEET maIoppeIwQjVpZJIJIsWLYqKimI2w8PDIRqHw9m4cSO7dUEQBEEaIWzqoqur 69atW1nMsCq6I69qMDc3P3z4cFW7puukwQjVpTIzM0tISNBshqp5/hIjCIIg TQqcTwNBEARBtLCji8wbS1hX3YXzaSAIgiBNCHZ0kRG/uLi41q1bs5IhgiAI gjQIbL5HDQoK0vUOMzMzW7ZsWVhYyOIhEARBEKROYUcXe/fufffuXaJ+oaox 2tjYrFmzhpX8EQRBEKR+YEcXT548CeuQkJDjx4+zkiGCIAiCNAhsvkfVE8WH Dx/6+/uXlJSweAgEQRAEqVPY1MWjR49Onz49JSWF2bSxsfnoo49YzB9BEARB 6ho2dXHWrFlfffXV6NGjhUKhWCxetmxZz549WcwfQRAEQeoaNnUxLS1tzJgx fD7fxMSEoqgPPvigc+fOGvcRQRAEQRo/bOqir6/v8ePHBw4c6O/vv3//fi8v L/AaWcwfQRAEQeoaNnVx1apVs2fPBl2MiIiYMmUK6CLrky8iCIIgSJ3Cpi72 6dMnPj4eAn379q3P16eFhYVjxow5d+5c9+7dd+zYYWFhUZsIBo2RkZEzZsxQ KpXr1q0bNmwYUY9OEBIScuHCBTMzs3qrEYIgCNJQsKmLxsbGRUVFAoGAxTxr w7Jly4KDg3fu3Ll69erw8PClS5fWJoJB49y5c0EjORzOxIkTGV0Ey+LFi1EU EQRBmgls6uK8efNAbKZPn+7g4GBwDPE64sCBA3v27DE3Nw8NDR01alRVXTQY waARvENwH1UqVUZGBlH3yAS3cuTIkfVWFwRBEKRhYVMX165dKxaLwbvSNdbD fBqpqamurq4QcHNzS05OrmUEg0YvL6/o6Gi5XO7t7V1WVgZKHxkZWdflRxAE QRoPbOpiVlYWn89nMcNaIpPJjI2NifpFbmlpaS0jGDRGRESEhYWBs7thw4bw 8HDwFGNjY8GDBMvq1auHDx+um21UVFTVw4Ebynb9EARBkPqDTV2sKorVTcrI LkKhEEQO1lKpVCQS1TKCQeNQNRBISkpauHBhTEyMn5/frl27mBZHPV3s06eP 3oFAFAcPHsx+DZsseEL0wBOiB56QquA50aP+nQ02dVFPAnk8npmZWX5+PouH MIi3t3d6erq/v39aWpqvr28tI9ScaubMmStXrhQIBOAE67Y4IgiCIC83bOqi blPio0ePIiIi2rVrx2L+1QEe3u7du2fNmgXrIUOG1DJCDanAYmVlFRISAmFP T0+mxdGg4iIIgiAvGWzqoi4ODg6LFi3y8fGZMGFCHR1Cw/z588PCwkCGg4OD t2/frrGD/8pItcEI1aWSSCRQ8qioKGYzPDwconE4nI0bN9Z1RRAEQZAGp650 saKi4ujRo3WUuR7m5uaHDx+uatf4rwYjVJfKzMwsISFBsxmqhr3CIgiCII2a umpfBAfL2dn5+++/ZzH/xo+lpWVDF6FxgSdEDzwheuAJqQqeEz3q/4TUVfti 8wTn1dIDT4geeEL0wBNSFTwnetT/Camr96gMcrmcx6vbQyAIgiAIi7AjWgY7 KYKxuo72CIIgCNI4YUcXmTeoe/bsuX79+tSpU21tbbOystauXdu5c2dW8kcQ BEGQ+oHNl5xTpkxJTU01NTWFsLu7+4IFC7y9vZlZKRAEQRCkScCmLjo5Oa1a terdd9+1srIqKChYt26dvb09i/kjCIIgSF3Dpi7u3r0bfESQxsLCQgsLi06d Ou3YsYPF/OsTnOuYISUlZfLkyZcuXfLx8Vm/fn2XLl0InhxCtm7dOmHCBM0H 2M38hEBpZ82atXnzZgcHhw0bNvTu3Zs073Ny/fp1cA9u3rwZGBgIZWaG/Wqe JwTKPHbsWCiqxlK1Rs93Zqqzs3Jy2NTFgICAPXv2sJhhA4JzHTO88847/fr1 O3jw4LZt26ZNm3bt2jXS7E8OyKHe4EfN/ITAA5NIJEpPTz927Nhnn312/vx5 0rzPyaRJk+BBISws7M8//4S/oCtXrpBmeUKio6Nv3Lih13+vao2e78xUZ2fl 5GAnCsPgXMcM48ePHzdunEAgGD169Jw5cxhjMz85+/fv79Sp08mTJzWWZn5C 4O7/yy+/WFlZjVLDGJvzObl9+zY4SfBXA7fm2bNnM8ZmeEJiYmIY2dM1Vq3R 852Z6uysnBzURcPgXMcMkydPZgLw8+ratSsTbuYnB55Mt27dGhERobE08xMS Hx+fkJAQEhLi7Oy8ffv2gIAA0rzPCTgxmzZtgmfK3bt3M2+VSbM8IZonaV2q 1uj5zkx1dlZODuqiYRpqruPGCTz/wk987969zGZzPjmnTp0Cxwj+9nSNzfmE AGKx+MaNG4mJiStWrAD3iBkYuTmfk59++qlHjx7Tp0+3tbU9e/YsY2zOJ0SX qjV6vjNTnZ2Vk4O6aJiGmuu4ERIXFzdkyJA1a9a0bduWsTTnk7N8+fIPP/xQ z9icTwhRD7X/1ltvwXru3Lnu7u6MsTmfk/fff//bb78dN27cjh07pk2bBs9S pHmfEF2q1uj5zkx1dlZODuqiYXCuYwYo4eDBg+E5a+DAgRpjcz45/6phwvAE 2qtXL7jrNecTAnh4eEgkEqL+Ikkz7mNzPifR0dEHDhwAJwakcdasWYyxOZ8Q XarW6PnOzFMTvsjJQV00DM51zPDxxx/DQ9agQYN0jc355Gg+rtPM7kma9wkB RowYsW3bNijejz/+qGlOa87nBO7UW7duBVHUtLaS5n1CdKlao+c7MzUnfMGT g7poGJzrmAFqAfVdsmQJs3nv3j34beHJ0aOZn5C5c+eOGTPGycmpQ4cOIJCM sTmfEyjV1KlTZ8+eDaL466+/MsZmeEI042YzgeqqWV0dyeOTU12Eujs5qIuG wbmOGXQ75GrAk0OenFWtmZ8QkUi0b98+PWNzPifwfBAbG6tnbIYnxODMg1Vr VF0dNTlUF6HuTg7qIoIgCIJoQV1EEARBEC2oiwiCIAiiBXURQRAEQbSgLiII giCIFtRFBEEQBNGCuoggCIIgWlAXEQRBEEQL6iKCIAiCaEFdRBAEQRAtqIsI giAIogV1EUEQBEG0oC4iCIIgiBbURQRBEATRgrqIII0a3QmQa0Pv3r1PnjxZ Q0KNXRMTQRBdUBcR5KXi7t27TKA6NdXYNTERBNEFdRFBGoC//vrr008/TU9P 9/X1/eWXX3r16gXGzMzMt956Kzo6unPnzv/884+lpaVuEoN7ExISQkNDi4qK NmzYMHjw4JCQkIyMDPAI4+LigoKCHj586OPjk5eXZ2JiIpPJbGxs7t275+Li AtKoiQmZFBcXi0Si0tJSW1vb5ORkR0fHBjgjCNJoQF1EkAbgvffeO3ToULt2 7UAg586de+XKFTB++OGHYImMjFyyZMnChQtBL3WTGNz7ySefLFiwwMvLCzIE XTx+/Lju61NnZ+fAwMD//vtv4MCBp0+fbtWqFViYXZqYPXr0gPCbb7556tSp Dh06oCgiCOoigjQADg4OoHD29vZj1DDGEydO3L5929TUFJSyS5cuekkM7j13 7ty2bdvMzc1v3bpl8EBDhw49evQo6CKsIVw1wvDhw0GhQRf//fffESNGsFdF BGmqoC4iSAOwf//+pUuXdu7cGRy4VatWBQcHg1EsFtvZ2TERBAKBXhKDe8EI SlnDgUALx40bBwHQxS1btlSNALrIvMU9duzYkSNHXqhWCPJSgLqIIA2Al5fX r7/+un79evD2xo8fn5aWRtROZEJCgpmZmcEkBvdaWloWFhZaW1tXd6B27doV FxfHxsaCgrZt29ZgSWxsbMBZBH11d3d/sWohyMsA6iKCNABdu3adO3duaGio t7e3QqFgjAMGDFixYsUnn3yyffv2P//888SJE7pJDO7t3r37jh07goKCpkyZ cufOHbCAyGVlZek2Ew4ePPibb76BtV4ZNDHBZVywYMHo0aPrts4I0kRAXUSQ BuDrr7+ePXv2hAkTPD09wWtkjEuXLp08eTL4heC3rV27Vi+Jwb3h4eGDBg2S SCTgfTKW//3vfwEBAeBEahIOHTp04MCBVd+RamKOGDHiyy+/3LVrV13UFEGa HKiLCNIA9O/f//bt23pGOzu7/fv36xk1H5ca3AvClpSUpGvRfMijSfj6668r lcqqGTIxS0tLd+/eDXH8/PxeqEoI8rKAuoggzRorK6v27duDNDZ0QRCksYC6 iCDNmrKysoYuAoI0LlAXEQRBEEQL6iKCIAiCaEFdRBAEQRAtqIsIgiAIogV1 EUEQBEG0oC4iCIIgiBbURQRBEATRgrqIIAiCIFpQFxEEQRBEC+oigiAIgmhB XUQQBEEQLaiLCIIgCKIFdRFBEARBtKAuIgiCIIgW1EUEQRAE0YK6iCAIgiBa UBcRBEEQRAvqIoIgCIJoQV1EEARBEC2oiwiCIAiiBXURQRAEQbSgLiIIgiCI FtRFBEEQBNGCuoggCIIgWlAXEQRBEEQL6iKCIAiCaEFdrBO2bt06YcIElUrF bFIUdeTIkddff103TnR0dM+ePZk4EIExcjgcOzu7V199NTw83Nvbu56LbZC7 d+9Onjz56tWrLVq0WLduXadOncCYkpICxkuXLvn4+Kxfv75Lly6kKVdTqVTO mjVr8+bNDg4OGzZs6N27t2bXy3QpgR07dowdOxbqq7EYvJTXr19/9913b968 GRgYCBe9Xbt2pInX3WA1Q0JCTpw4wUSYMWPGzz//TKr5MTTpuhND1x04fPjw F198ER8fb2pq+tprr/3www9ubm7MrkZenboGdZF94O9k48aNuhY+nw9/cv37 99f82oAff/xRIBDopmLW2dnZq1evDgsLg7/heitzDUydOjU0NPTo0aNbtmx5 5513bty4AUYI9OvX7+DBg9u2bZs2bdq1a9dIU64m3ChFIlF6evqxY8c+++yz 8+fPM/aX7FLCfRwun0bjGQxeykmTJoE2QMn//PNPiHDlyhXSxOtusJoFBQWJ iYmglLoxDf4YmnTdDV73M2fOTJw48ddffx04cCCch19++WXmzJl79+7VRGi0 1akHUBfZZ//+/eBUnTx5UmOpqKjw8vL6+++/R44cyVjgSQ2eRsvKyvTSwl8d 2D/66KMVK1bUX4lrBHQR/iTgvjB+/Pg5c+YwRgiPGzcObgqjR4/WGJtuNeHu D/cFKyurUWo09pfsUsbExCxdunTZsmW6RoOX8vbt2+BegBFunbNnz2aMTbru BqtZWFhobW2tF9Pgj6FJ193gdY+IiFiyZMmwYcMg7Ojo+M033xhM2wirUw+g LrJPeHj41q1b4Wena3z//fdHjBgBjheXy4VHsC+++OKPP/6APz+9tEqlMisr a+XKlW+88UY9Frkm4IYCa7lcvmnTpj59+jDGyZMnM4Hjx4937dpVE7mJVjM+ Pj4hISEkJMTZ2Xn79u0BAQGM/SW7lBo90MXgpQwODobLDZd+9+7dum+Vm27d DVYTdBFkEjzCDh06bN682d3dnVT/Y2i6dTd43cGDXLdu3VPTNsLq1APNRRfb TNsQl5JTFzmvnvX6e0Ne0WyeOnUKnjTh0VIvGvx1eXt7wx/SpEmT4F4Dj2Ct WrXSjaD7fgYe386cOfOUA/e1eNGiV8eqI6R1Nz0b+IsuLi5QO10jeBXwJ6f7 7oXlalZkkDs9nrcaT6NFNOE7M0GxWAy3icTERHgoBvfo6NGjpB4v5e1Hl746 OJyFGlXBxMhs4/iE2sTUu5Q//fRTjx49pk+fbmtre/bsWU001ut+ac22A+9/ Udv6PAsOQS3ev3FYz6hXzYEDB77zzjsdO3b88ssvZ82axdgN/hhIHdQ96gE5 l/mCtTSMryUZ7feUOJmZmTY2NkxYt+S6TekaY63uSC8RzUUX643ly5d/+OGH BnfNmzfv7bffhudT+CNcs2aN3l7m5whPZw8fPly1ahX87TWqH2JFRcX69evh ofv06dOMJS4ubsiQIVCRtm3b6sZsitU0MzN76623YD137lzGaSAv76WsStVL Cb7Rt99+O27cuB07dkybNk33eajp1r1qNbdu3coEwPnTfFRi8MfA0HTrXhV4 4rl//76/vz+pRgubVnXYBXWRZf5Vw4ThR9arVy/NPeW1116D3+JHH31kamqq +25KFw6H4+bm9vnnn8MDWv0U+Kl899138NQsEAjgZgGFZ4wZGRmDBw9evXo1 PHHrxW+K1fTw8JBIJER9L+DxKv8oXr5LaRCDlzI6OvrAgQPGxsYgjeBI6cZv onU3WM2rV6+CRkJp4e6v+YLG4I+BoYnW3SAhISEbN26Ehz+NRe9rVYamUh12 aS66eGPdlPo5kO6Tl94HYET9vAk3mm3bttWQPC8vD6SI6Q5REyeKXqyktWX/ /v3Ml+tbtmzRvDj6+OOPJ06cOGjQIINJWKsm35m0TnmBsteWESNGQGl9fX1/ /PFHzf2u3i5lgEOnHZPTX6D4L4TBSwluBPhSUEHdBjYNLNa903vjYHnuwtce g9V899134WkPXMBly5b17duXMRr8MWhgse59XOmloVi0aFHXrl1B4KdPnw7r a9euff3117oyyfAMd6SXiOaii42E//u//4MnVlhX3cW8wYC1jY0NPMrt3r27 3ktnmF9//XXSpEnwN+Pn5wdhxgi3S/iDWbJkCbN57949uI9okjS5as6dO3fM mDFOTk4dOnSo4ZanS5OrI9F5S8YEGLE3eCnBk5g6ders2bNBFDUXXUNTrLvB aq5fvx5+2wsWLOjRo8emTZuYXTX/GJpi3Q1edx8fnzNnznz22WfwDFRaWgqb 06ZN03x7TBpxdeoB1MW6QtfD0IR5PJ7uO3qNvao70nho0aLFuXPn9IwGX7k0 3WqKRKJ9+/ZVt/eluZQGy2bwUoIkxMbGVpe8KdbdYDXbt2/PdGTUxeCPoUnX vbqywUNPZGTkMyVpJqAuIgiCIIgW1EUEQRAE0YK6iCAIgiBaUBcRBEEQRAvq IoIgCIJoQV1EEARBEC2oiwiCIAiiBXURQRAEQbSgLiIIgiCIFtRFBEEQBNGC uoggCIIgWlAXEQRBEEQL6iKCIAiCaPl/ogy5a8YlTLMAAAAASUVORK5CYII= --------------060507030306080009060607 Content-Type: application/vnd.oasis.opendocument.spreadsheet; name="hashjoin-bloom-results.ods" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="hashjoin-bloom-results.ods" UEsDBBQAAAgAAEiaj0eFbDmKLgAAAC4AAAAIAAAAbWltZXR5cGVhcHBsaWNh dGlvbi92bmQub2FzaXMub3BlbmRvY3VtZW50LnNwcmVhZHNoZWV0UEsDBBQA CAgIAEiaj0cAAAAAAAAAAAAAAAALAAAAY29udGVudC54bWztvWtzHEeSJfr9 /goa1/Z+QzLcPZ68rV7bmZ4es231S9p77ZqtrY1BQJHENF4GgKLUv37dM6tA AFUJhQcykMWsaM1QYpUXypEZeeJ4xInjv/tvv1ycv/l5dXN7dnX53VvozNs3 q8uTq9Ozy4/fvf1//+cfj+Lb//b7/+t3Vx8+nJ2s3p9enXy+WF3eHZ1cXd7x v9/wpy9v3w/vfvf2883l+6vj27Pb95fHF6vb93cn76+uV5ebT71/GP2+/67h ldu7X8+zP94HP/z03eqXu9wPS+yjzx7/lP/NffDDT5/eHH/J/bDE8kV9+PEP V7kf/uX2/OjDFV/1i+vju7MnWfxyfnb5j+/efrq7u37/7t2XL1+6L9Rd3Xx8 Bymld/279wmf3Mddf74576NOT96tzlfyZbfvoIN3m9iL1d1xbn4S+zCly88X P61usi/N8d3x1l29vlndcgj/ujIw837Qw888Gl8/f8weXT9/HLnMJ5+Ob7LH WR/8eKjQaf5QodOHn704vvs0cn/juz/zm/0ff/7+67i6ucj9Lol9dKlObs6u s3/NIfrh56+uru5TlQ8MD3ufLhpj3w1/fxD95dnwLzdnd6ubB+Enz4afHJ+f 3F/xq4tdF43j4B1HHK1+liF//xDJhbgd+QC+G96+D749Hf3R//+fv//x5NPq 4vhr8NlvBx+dXd7eHV9+vTI3chNGf1P37mZ1fXVzd39hPuSDL98tvM/t093F +Th0yLub0I83p6c7Qzkdescwwg/x0c9nqy//5RG2Pj8e0rs+6CGePvsBMO8k 5v6R5Nv9FfxvPt7PTx+uPl+eDjAwXIzVL9ermzN56/i8/9j7Rz/h4Qg+vyr4 kes57cFPeAT0Z6vzzdN//yvt/DFXV0cXtzwYeNBfXb9/8OnH88bNxS95P04G +tXph6c/8clDf3J7S3e77u3//OGdvHck0yZPDOtvekAX8O3vN9xgwILbd/cv fGCOcPTh+GR1dLo6Ob/9/e8GjL9/+c3wd8n7u7f//ebsmMcaw+8m4OLs/NfN 6++e//D3Zzzb9PfmzY/Hl7c7fsz/fXx9dfv/PIkbXnz75tGPlvijj6tLvoqM Nbdfzm5vH0Vcn92dMBr/fMyJydD9jdT+sPrP4//v8/NpPYjJSenX27vVxW/l 9G7sJqxfP/58d8XzytnJUf9z7u9O/+ej3+DkCu6/bJ12/9DyNHn++eLy7eaT D188uubBtrq5O1vdvvlw9f6nm9XxP45+WvG44x8oX735ievwL2enMsXxkHR4 dtnn/yCd53LD18rNdDEmTW43Y9ft5urLk8T4lYdZDW/Ji59WZx8/3cmXI/Tf /nzGn29XR1fXd2cXx+dHDz9+d/N5pUl85KIWJQ4hvlLed8e7L/jmxQsmmaub o+vjj6uj4RN/4//8Ud77D/fhP27528+f/H4PfreB/J+e3V6fH/+6Tm39g4Wk MLU/urg65R96fnN095Mm691XOzPr8+Obj6s5sqaXZP3jp9XqDuulPdQf7/nH nchMyEls/wp/AXh7Hzn86836bwyV/Vjkbz9ZMSnkO7R+5+Lssp9LP/Ivd3r2 8eyO3wX5/vX7MlH+/r/+7t3Dv97/7Wk6z+DaagxzV+fnm3euj2+kFO//crSZ bT4cfz6/e4p7/KHtx/Rn+Rvzn6Pj87OPPJn/dHXHU8LX+Uxyf4KVjIhXXNX9 F9P/b5NHH8hV5uro7tPN1eePn47W9fzl1eVqPOju1+snMf1c9YgO8Hf2L96e /ZNfBHN99+C1zZfcXByfP/oaJmqrm/67HiWy+eCXNbo8/uT9lx8xhz6+/MpI vr4rWWzeHXJ5+GZ/G9bv7vjRw7c+E9D/dCk9z1e/jP78+/fHv+FpSP5kuhqb TJWDrg2cQxs4uyeD3IGzjugryIfvDwjdBtWBDipbf1C16bENyPwB6WYdkP29 6wfj0e3V5xvZb/lw9svmx96srlfH9/sy/Nbx+e39yPmtscxZH3+8Ob7+9GRA f/3K796uLk/HB//wqpRxX84uT7mC66/4+nl4yN7bw7CMh+HjzVaB0g+gs5P7 sbz++8NhImu3/MNurv5xf6H7lz6cnZ8/ekFuDT9Jx0efrm7O/nkli5mbcSgV lOwIPI57OsIvzk5Pzzc/7YovhvwHX9Dr1cndumLL+0X/tvV73j8sbzWPzzrt re99N7oet37jp6vTX7+usV7zL3t6K9Xz7383FMn9n+uCeUh5WMhYv/QQafoF kuHl65uzryjxYMX25kIyv7l4kM+Hq5PPt/eAMrx5fX3+69Hp6lbAaCjEh7ff bbK6/XR8Lb/EcHtv+OuHW/FPrp5PZcCZt5vR8DW/flDd39dHINnfhp8/vl8v xvkOU+zXleTFzXIRdc5i2rzKXxK7kFzYvPBrH4EJzmRhcBgZP/0nD4jhOy+v 7s4+/Hp0dXn0+ZpBenV09eHo5vjyoywA9Je0+x/wfvMfb9b/gfev+PVLf9oE /WkT9Ce8f2UT9P0m6PtN0Pd4/8om6M+boD9vgv6M969sgv6yCfrLJugveP/K Juivm6C/boL+ivevbIL+tgn62ybob3j/yibo75ugv2+C/o73r2yCftgE/bAJ +gHvX9kE/bgJ+nET9CPev+Lfvun3rd9/ull9+O5t9+6vw42CzevDhHB7JvC1 ee32k2wmri5+Wp1uXjo+ufvMt/K7t1eX318d9xNYf6/PLo4/rnZ+xQ+rftFn 2A6f7lvffX0Q+C+Pn5EHz/F6iXrHs9uvwq+XxQZCMdCERzEr+PoE5v+8YXVq HXp7NDCJ1Wm/7PWb34iTfiPV+h2f+Xk07TWz6Te/c8MIn3zvzdWXHV8q2whP 8uOfd78Vd3z+ebWmRzyxnl1+fPtms6e54z3+QfLO9e+/XN384z8uVhc8FocX NoPy61fs+NIdl0QWKl+Yy0/HdyefVrf7kAoTEZ6ldZm88CtvV+eMMWc/n939 +qrf+9P51dXFm3dv+g2EV/3mYW+g7Kt33Xb74tvOtHB1+vl6khH4mwj3FG10 o/nD+dXx3eN3vntrd/+aQ+z9b2lrPWE7c4pZOcVXzUl4RUZS4F81K8KsrAhf NSufN6j8644qwLxxxXGvmhe6vKHFca+al4O8wcVxr3sfDeaNLwksyWycoFHo CfkT5jUtFdtHlNZMiFyl7UUaL0+CdibxdSf+6U0ynfHorEu7M3zwwa8Q2KH7 ry9mUDuHTPAhb9RIYJ0UAI3JxVyOLLljsqb0+fyY6+UP77/7X92/4f9+97+6 P+L/Vt86T8kESs74lByNXLmdt5C6BMp7WMb/tuvlb2vkTpPp7DeqLGVLFkOA QHZkth9L2cyTMufrXTLrfxQp245mGhgJCaxPPgTvLClSTh3SDClDZwxQDARI KThFxmBMB3aOlHU5mjkGr1xW5H+sC0zlNQNBUsZ5nreUEkDA4MF7O1YQ7Mo5 pblQjVP2iMgjGH0a4xpjKfuilBszfwklJtwLZj5BtagfrIA2xaSYxwA7p4WC 7PUtftDzlrg4sBY1j+Ryl0PITUHNqafmVEDNQ0rEVQpzKLSgmIJ8YJD65qn5 qwzdiSjY3HeqJGV0BCmhZyIWNdw8zFYBSaWGlrkjBua8ipRdZ8sm3henHCMR RvDRMTvXpBy7OAc3N10A8h4sDw9DaWz1f1fKAToKM/FeHsnOQ7AUk4KQCe8l nCllGxjdOHETNE+fpGzjTCkHMpbxwhLEkXl8LOUwV52JXFekYKLBNLKqP1oQ lQ2MRtUXQNVpFqoeg7OoWWmIXai1is58Jm/YSGAlqs7zUCZVl8gpqLrtqbrV U/WAPnnmf4TO2zSS9c5JE7swBWedmaq/xtCdiN7MfadKUjbeWrImIlJUTGOc spmJ9yaXbILAvNeTck3azVMQBZQrzIWcdxG9hvdiR3OsSXPKjqkND2a+2pFH tCJl16W5qDrXF+Sdl9JeU9sLiZxjvVdSZsYbnEdjNRtCknGcZa+iM1wNESXP hXIMqq0L6NIcsCwXmWtOMFzguziydT52kX3ZsGhE/SUM2du9IOoTXAs97KIz gJr1J3T8SFYi6gAwhvxPWbJEVkrCgs0UvEjkFFTd9VTdFVD1aENwSIQ2OtX6 Vpxm5WVeqv4qg3ciejP3ndKnHI1JXFwEz2UGeMXUG7mImqm68BGdM0TOBWMV 63rBz7ZE7SNn6wgCU3Wr4GSS8kxUPRlMxljvDeKYwHhnyqkz81zlSMZZy8+e daIuUoxl6sxMLJIZrOhIuMjAsbWjMeJrZtoIkK0WTz6C061QQ2fnKuGi8Qj8 Z4Kk3AeIjasfLFcvWqF9KYgRMOEJCiggqCdN51xC5nEqiazF1SlmFgwSOQVX 9z1X93quHoMl3/MS72DszNfOKSh0doqJfl6u/iqDdyKyMPedKkjZhZii9xRk AlYsOkXHdG6elJESeeOFScaoUDpE7GimlAGSTc67FGNAzcCADmZKmRxTXx7N zH6TUzx+THzdTFzdJwsAfLEj13Caq+y7NNciNaYIXCrHaKJqXR06mklf71xM xoJJTpexm2dTS7h6CowWwOOZ0U7H1VPZEkrj6gvg6hOcuC6gO8EZGltH3kl3 Qj2tOlCEPLF6H1kpCYdiipmThEROwdVDz9WDnqvLeTkgEFJlAynWBZKZ5rDf zFz9NQbvNKnOfqdKygsC2R12KTGb1HD1wFXUTJTMQXCYPPikksAwJXNzrEVK tw6D1rrkbfDkNFc5zrN8KgMDgo1ygckY0A0MmGP9lB8hkgfQgo8J0Wkev5kO cveL1I4vcUKLOrE6dHamnQCH3vKwgBhJs9spXB3n0Mz1BVHExGhh46h9xNhV xsbVD5arK7nnNCBmKViPCiywVE+sDg5y/VYkslYSDOqZSXDkFFw99lw9FnB1 KzTKpwgxwdh52J1TkF3CydJXGbwTkYW571RJykzFIgWD3qiWTznlWRb2OGVI hGiDNYRgNC4UwHRuppTJc7YeLTMdjdaBU6Z5DgUkazll66JzTHI0xNfOdX5X TpUmCIbnDVBZfbjOz6UnEWEUI0YK4JSCEjcTV/cii2JI5lJZp7D3s2lgev8i rjmt5wun3Lwog+XG1V9Ckrm22guyPoHFagHfEZclDXmwSU8esnmydy5zTVsi ayVhxpjJVhIcOQVZTz1ZT1qyzlhDzKZ4AvJiy6BaF6DOfPuC9VcZvBPNCnPf qRIzM2coWoQkFmwqL7O5di+4pjAhWEJCFVVP8/AbztiL/wtF/gNBs6ye/Gxr 1HJ9EYXgRO8VNDIFrq7nSjkScZUslkZOw9XDbI4qYA1XF2jFv1O1SA2dnWkn wGHwMWDyFrxSA1O4SD3BVY5oovWJZ3KVOxCUDozG1ZfA1dMcMOY8z2uKitJ5 vYlvNksOfswa+ylLlshvsF7YTdXB9Fyd/1WwlhGMScaTtSojQFnLWIARzGuM 3olmhblvVEHK1gEgWZHujPV02Z2y7dxMdMHG5ANYKy77KuWAnUdqJJJZR0mW qIPYk+sks24mKbXxaJitB5RDvEr3jJmWqQn5AidAK95RulIZZ1rzlRPdjBcx GK/Z1hLEgJkkJR4cF3KQuMD3KsTglOc6wuud9REiZ6w5dCxs3Zel3Nj6Etj6 8Rxs3ffWFBrDZ+xstZX1xKVuHlOWyFp03Wc25+sjJ6HrMNB10NN1EHQMMQ1/ KtAG7DTOwfPS9VcZvtPMC7PfqYKpLKB3MSFFvs6q5b0wG8fhiVcURxACWZV6 IHYw0/Ke2O1Q6s3KVXQ9zLPnMmiTpfQMLiT4RrTJQSwm5UQDKg9rhtKeNy8G DJO4WEguRaM53A1gZlPZe0whIjIoU1QuScx1IpYHRCJKibFOd74USj3hG1tf Alv/aRa2HoMcFFLQnagfpbmDBqU5QdbA6SNrrfDTmOvU1go/R07C1odWpaDu VcqQzlzVy1EkZ0F1DglcBwtg668xfCeafOe+UyV8IUQDkWkZWVAVGOJUOU/K hHKRnUPnNVIYAJqLSPKwcERcXohfkCbj4tW9l5dEYv8NVq6xUS37xrn8v2Ho 65WIn0IV9YW5lHNAIifhQjkY0rhHyUi2M1X3zgMw6eWUYayt4VgVV2hZPsHa erTW8oXm8aFUrfumhDlctn4yB1sPVlpaa9x9rb6rRTZbZ3DMs27sIyux9Wgx c4FfIidh60P3UlC3L5UVWwZICt56pxJDg50GH+cl668yeieafGe+UQUZ+8BM PUUvpneaFVTwXZipvPAmWWaQyJzMaeZeTtnMRMqkizwm5ymC5rQ006LZmC8m I8qdiBhVuwGc8kyrvuA9BhfIo0OVqosHhp+puhfTVDnO4BOomjhJyjNJpLwU RVH6w6pQuVfCzHaS1xMSP3wWdNo56FxZdd/Y+hLY+ukcbJ2nCGkto/L3rSZc R7RjzVeesnWJrMXW49gB/C22zpGTsPWhgSmoO5iK17LYvbsgWDMm+t+N6YkJ 5DdP119l+E40+859p/QpI5CVeTdEQ2MStZ0pI8zTW5OvsihhXIw8+ybVqTGY TQnDVZFnAkxyPHasz8RoVTTTdoALzntHaJ1XLa6Dmy3lyAQrkpNqWTsu5hFp QIrSKTaQEymaDjDiTBIp74z1CTkFrRJmlmPpw1negAzKmFBrZ194lrex9SWw 9dUsbD1Y6VGosstVn4XOZus8Y+Wd8Owjq62tj0krttfWaZK2SDD0MAV1E1Mm VMFGabljwKFqFsIwjYB7Zrb+GsN3Iuo7950qSJmrCwoYHdMGjU0fIHVxHpEG p8zVRYg+BRhzYR1NeaaBYVzwUg+JSaYqZdO5mQqMRD4xvbFGZ+wpRJLm2dtC LiGNjSgVhqZvgFSeOM+GACLXFtYbTzF51cDA2RwcgULfJDagC1o7xLlcYfgy I9dFVg6Q6FIu7LHX+PoS+PqHOfh6IqYQmq22RF3QLpxl83UbxlwGnvJ1iazE 19OobcfWYVeOnISvD31MQd3IVFigs2CiTQ4iaQCSWeAkphLz8vVXGb5T8fWZ 71RByi5E5JmX52BUWdmgm0u5jrJYFlHOB/BErEnZdmYmJolkLZpeBq6RHDEr m2kLgxNOgRm7E2cY1biguVZRmaWTtyRNY6NKpsHjYq6nT0RoxmKyNkRNUYR+ NhNHOYUhCxNgvO5gOsxjSNpXGFzIBSRpAKc8aFp4/P/16HruxAu7puj8WXs8 cvRXfe5DUxKM8Q/ZuUqjvIZCE/i5T2AqvxeFURHHfimzNF6c5RQzhddX77kj JowaVj0ZNBJYqSpCMwboT6siiZykKhq6UEFBGyqx7bBkMQQIZBU7055K3QGf AZrUgOY3H3G/F0hTpJV7KdIwxUxRpXbGet2pY8Q8Y14JrAQ1BGNy9a0G2Rw5 CdQMPTRA3USDoUbq4+FYbFCJYHyYfrm3Qc03AzVFU+SLoUY2XlUVe6zYXNNk 96A36h702UlYGNsjfZqERE4BNjiYgKPaBNx0AbmuZmJjIiJFxfJWQCa0DWxe /ynHvQCbCfbZ9GAjsnfUtMhG1xntulX2cw44tuX99DmXyFpgY8a6sWyBDUdO AjaDhSmqLUxNF41JXjwQA4pBtUITZUoFyQ1sFgA2RU3tXgo2XAk4o/F7pwK1 Rf5iiR9bSt5aLOHIWmATcldsJHISsBkc2FDtwMZg40JMUY7/MtpobDWj68LU fU8b2HwzYKNc7pwIbIIzpNksolBvxQYoYWYZJZGVknApF2wkchKwGQxkUG0g Iypvkp1V52TPTyPejIEnmgY2hwo2SsXZNGBjKVivcUmxVHHNxhFmHj2XyEpJ SHeBvCQkchKwGc6/o/r8u+kY7oyJFIx4s2vE7cmWmm83sHkRpbB7ATatoTt4 a3N7qXNkrSTcmAnndpdILJohtsBmOL6H6uN7c3TdblizAKxpDWlDMpmUQiJr JTEKvVtJcOQkUDOcPMCCkwczNA1tWLMArGnt9CCNuqdvnTDiyFpgE8f25rbA hiMnAZswgE0oAJvX73jWwGYBYNO6AaHhOTrvTKVEVgKbyI9vpgcKR04CNoN6 GNXq4VkatjSwWQDYtGYGCG7syMRWMwOOrAU2dswqYttwKUxygBsH/TCq9cOz OM43sFkA2DQvZsRstwis5xYhiupMsAnT6Idp0A+TWj88i11uA5sFgE2zkkQL NpPZSGSthaNRtcq2NU2aZOObBv0wqfXDs7j9NbBZANg0Hyw5UZjpWyuRtRaO IFPq00dOAjaDfpgKOjjPYFX0emCzvzYe6HAmXM1smqjtmFgH0vYDWJuPRhir XZ/6aHBgJQoHyWdSOImcBFUH7SIVaBe9JetdMut/FDfRdrQYCvdNQc1+WPY0 I40YQ972ugRWwhpyY3rjrZMhHDkJ1gzSRSqQLnqZJtCKH1tImmPD3nV2MWfb G9aos2hOGtI3KpNUSGSlJKynvBWyPnIStBnUi6RWLzLaJJdsgiC9ZkmjKPKp c4s5b/pNoc2eGPc0Lw0AO7aeu1XDcGQtuEm57kESOQncDPpFUusXTcc4g84Z Yp4VjGYxPPgulnUDbXCzCLhpbhqAKWXqeSSyUhIu+EzMk8hJ4GZQMFKB/2lE SuSNZ+CzMSo2+iN21NjNAcNN89OQHtiZT7pEVkrC+0wf1j5yErgZNIxU4IEa vYPgMHnwSVVMRd+5xWgYG9zo02iOGsAVQS6x4MhacJPGWohujV6OnAJu7KBi tAUuqAkSIdpgjbTu0Jxyhy61YmqWNdr9MPBpnhrgo8008JHIanCTewBWIieB m0HHaAt8UFNyXAwHS0ioQptU2jW1oc0i0Ka5akSkzDVaiayURKCx43FbB905 chKwGXSMtkDHaGxMPoC1oppSgI24aiync01DG30azVcDkhvTqG0dj+DIWphn xo7+b2EeR04CN4MTqlU7oTLcRIjMTy2EQGO8cDfcxA72XTbd4KZiGs1ZA8Hk ntKQyFpww8VJJtxw5CRwM+iJrVpPDB0QerDOOWl2rGE3QB02jd8Bw03z1kDM Ffn1kbUoFox1Vd9hXTbJoTA7SIqtWlIs3homWW8MMkV1Gq0m+M60bfADhpvm roE8VWe6a0hkLbjxuXvxEjkJ3AyaYlvgiApSTLkYI9g0ZgqyG25aMXXYcNP8 NWQdKdOmUCIrJWFy+/P1kZPAzaAptgWeqEgxpBCiTwGMysyHutjg5oDhpjls oAs+12GDI2vBTfC5DhscOQncDJpiW+CKitYEjOjIWTNWA+6GG9uZfbdgbg4b 28OT8sYmTXDWe4ID53sBrM1hw5s8AiWBlWpGk8Y6o28dhuXIKVDVDVpGV6Bl 9AkJrJd1Ru+U51DVtf/ekrhvCmr2w8ynOWzEGPPcLSSwEtZgdtsgVLcNGsGa QcjoCoSMPkYijOCjY7TR7aIu5xBqwxp92ToL1uyZw4bPPIMqkZWSsMZmrnZI 5CRoMygZXUFH94BkTQwpeRfRKzb7Ay7Ia/qbQpv98PNpBhsANmaKeiSyFtok mwl5EjkJ2gxCRlfQ0j34KB5mBIHRZsype8xgo6HN4aJN89cALgkybQIlslIS LsRM2bREToI2g47RFfiiRhCDfeddijGMuWSPKDZgMcKihjbqLJq9BliXbRPo tDaB+ZvGDrKbusMkuiI3yBhdgTNqjAatdcnb4Mkp7mOMnVmMvUZDG3UWzV0D nM/dDJLISkkEyO1+KpGToM2gYnQFzqgJyBtCj9ahH8t7xF2DFnNG45tCmz0x 82nuGuBjrkugRNaCm2yGFdQMawRuBhWjK3BGFdOw6CjyHwgacpN8B/suK2pw UzGNZq8RcexU07a9hqu1KRXB5Z5358hJ0GYQMboCEaMxjHjROR8Ax0By93l3 vvVtmfiA0abZa0AKKffsJ0fWghs75me8BTccOQncDMaorqC5uwkmeEqGEngV 2oTOLOaERkMbfRrNXQPBZBpb9JG10CZmk5s4Dbnxg5bYF3R3B/COCIJ4FarM NaDzizEqbGijT6OZayCSyzyKJZG1CFbMVRNL5CRoM6iJfUF7d8BoCZPzFEGz 3A+ATXFz0HDTzDWQfC65kchKSRjMbA/aR04CN4Oc2BcYo4IPHjCRWDEHFdz4 LrRtqQOGm2augQ4w08tHImvBTczcluojJ4GbQU/sC4xR0bjgoyEwyam8fNB0 ri3dHDDcNHMN9BAzn3SJrLV+ZMccRrfWjzhyErgZBMW+wBiVq0prhWZ5M3aA fjfafANnpZq3xvbo9Hl7GH6Cs1ATAOte4Grz1kg2r2aUwFopZHYllMBJIHXQ MfoCN0ZjgGIg2ecPY4v4Y1v9sO+Yukyg2Q8Tn+asEf1Y65mnzhocWGktHCG3 AapEToI1g4jRl7R3B/IebEDXb/Ur9jSgo8WIGBvWqLNozhoptx9hqteOEFPm QngfOQnWDBJGX9DbPbgUjPfBJxeDplgMTr9/2rBmOS4+zVcDeJrOVDBKZKUk LOU2fJbISdBmUDD6gtbuIRlMxljvDaLG9jWkzizGM6yhjTqL5qsBOLpRvUUr OLJSEo4pS+YBWI6cAm3CoGAMBW6okRwZ552zdpyT7dw9pc41tDlctGm+GmBh 7KDIFq3gyEpJeMjt1yORk6DNoGAMBX6oMUCwMYnm3ZixhvQjWo3lHD1taKPO ovlqgIu55oASWQttQsi0SZTISdBmEDCGAj/UZK3n6cLJ6dNkR1Byp1TDdnYx AsZvCm32w8Wn2WqAT2NbY1sPOkdWSiLYsad2y1aDIydBm0G/GAr8UFOwhIjM bGz0Y4teO9Em8EzT0OZg0aa5akTIZRUSWSsJM+aFs5UER04CNoN6MRSoF43x aBhsApJzCmYjUhu/GIPCBjbqLJqphvQtzj3z6at1dY9hrIHoFtpw5CRoM9ih hoKu7sahN8n44AJTVA3auA5bIXW4aNNMNdCksZpu6wwWR9aCPKRMtJHISdBm kBGHEhlxjJYC2P5ohqIeBhMXdMy9oY06i2aqIcsPmWgjkbXQJuQ6QEvkJGgz CIlDQU93aRMo5oQRMaocwwC7pJVNNbRZDto0Tw0kN6b82fLU4MhaBIvGWt1t ESyOnARtBilxKHBDBb4O3jtCy+RGw23ALchTo6GNOotmqcG4l+nV1UdWK+dy bYQkchK0GaTEocAMFRL5lDBaY1TaPoDUDkkdMto0Rw30bkz5s+WowZGVkgA7 VlluO2qESY5kxkFKHAvMUJFsCgw4TralNGfdkPQizddGm2apsUtun7mPghMI apqpxp6bavzWMN2Z9JjnRV5ZKYGTgN6gMYx6k0TdzrvZd5Rrj37NLJrNRQwp r3qSwFopZB5IlcBJwGWQFMYCS0RjCJLzwLw4Jo0lImMNLUbl07CmIItmcwEm uweoUfcAzU/CpMx2FhI5Cd4MqsJYpCoMQOSdlxlD2asrLGYv7BvDm/2w1WlW FwCjJxq3rC44slIShJm7YX3kJHgz6ApjSZt1MnLu3EbrrE+Kg3aROrOY/jkN bwqyaGYXjHy5pyYkslISFsYEwTvOwE/DbwZlYSxotB59kpP4kf/PWNW+pu/S YpSFDW8Ksmh2F+Ltm0stYjVzHZvt8GPVDj8jeDNoC2NJp3VKJhkLPiZEVad1 WpC2sOFNQRbN8AJszFRu9JGVknDO5pp5ceQkeDOoC2OBUamsFScIBhxAUKwX J7egQ6HfGNzsh79Oc7wA7zK1Nn1kpSSCMbmOFxw5CdwM8sJY4FSago1EMUFC HzUtu1KBTLThzZLwpnlexGzzwFjPPDA4yhy8EjkF3KRBX5gK9IWG0AfmN2hl n1GzO0UdLkbN3OCmIIvmegEpV0rcR9YCPWMzV4slchK8GcxKU0G7dROk34N3 ENCMdVfcjTehS4s5q9XwpiCL5nshHYXzVm/6yFp448fatWzhDUdOgjeDlDiV 9FuHJIVUIp40FGvFzA71VXGDmyXBTTO+ECu8bOOLWkfRuTaJmYvFEjkJ3Azi 4lQgLgbvMbhAHh2OPXS78cZ3fjF+pQ1vCrJo1hfinpO3UNtH1sKbkNvXSiIn wZtBXJwKxMUQRfZIznpnNWcZIHbQzk0dMtw07wvkhyavkOkja5V0RJmn0SVy ErgZtMWpwLMUAcHYiGK1kzT0BuWzDW8OGG+a+wW6lPJOSfaR1ZaQQt4WWR85 Cd4M2uJU4FrKMEPeUgRIUVMVA9rO7bu2uLlf7HpGMv1h3ATa4aUcS12s+0Xu qAm5dtChmht0SJBH4yRwElQdFI2pwC/RGOR/rAtMUMa2DsdOpOJiqsYGNQVZ NLcN5iF5W3ASWCsFl+u24SZx20iDnDEVuCUaYwPfPENgQlSI4AVrliNnbFhT kEVz2wADYwxr223D1dIXGTN27GHbbSNM0ueCf1APOPLvAsSRThfOM8MxSruN 5TS6aIBTslA2B+Dsl92GGT06sg041VpdGDMmuNoGHJpEYMS/zRpwSiSNYnXk rTNcT42ZI+1GHP7sYk6INcQpyKIZbgCYmHlkQyJrIU7K3ITrI6dBHFwjToGo kWeMFLmg8jEqRdTQUVvAOWTEaZYbgMZkul1IZC3Yy1Vy95HTIA6tEafENBWs I0sJLepWcaCzi/EUa4BTkEXz3AAIYz3wtp51jqyVhBtjCltJcOQ0gGPXgFPi mgrOESSfUoCx1e4xxHENceZ51vfD5afZbvATTJnNQiWyVhIecpPgyGkQx60R p6QfO1iTIKAlsF61K84cZzHaxoY4BVk0440AKXPdWCIrJeEhZZ7ckMhpAMev AaekJbvnPDzXxcF4VSNB4ztYzFH4BjgFWTTrDYjOZrILiayFOCHXnV4ip0Gc sEackrbsTHAMJZeiGbMo2n1azCzIObUBTkEWzXsD+KHJXDaWyFo8a7Q02eJZ HDkN4MQ14JR0ZicLPlH0wdBYRbobcaizbWv8kBGn2W+gSbndkiWyFuIkm7k/ L5HTIE5aI05Jd3bvKUQfnU+gkoyLAUeT/x0y4jQDDkSkzMOhElmvsstcS4oT ucNzgTMgDhTojeVoqkshkENS7Y1D6mI74XDIiNM8OJBsrsWYRNYq7SBz9PaR 0yDOWnAMBYJjnjGst954immsm8fuY3HY9sYPG3GaCwfakFtVSWQtxHE+s82g RE6DOGvBMRQIjtFb5kYWk7VhzI1xN+L4/d8bbz4c2wPUZUo3XJlwY5lSx+bD kcYOsm2ZYGAlP7WQKA9YJXAaXF2rHEGtcuSZMSWAgMH3B8hGxAs7Z8i0oB25 BjYlfHIOsNkvJ46YSeQksFIKwec6cfhpFI6wVjhCicLRBGIS56MliAqwkaPx 6n3VhjZLQpvmxQEGY6bgSCJrJWFyzfAlchrEWUscoUTiyOUrUfJAOGo7Oaap TotZqWqIU5BFM+Pgh2DMY3nbjCMp1YUKxHGZK1USOQ3irCWOUCBxNCCrduQj uDGz3dFDHItpZ9gApyCL5sXBRUVmOdNH1gKclA04aSrAWUscocRM1bmYjJVk dFYcrnOLaTDWAKcgi2bFAWhDrhUHR9ZCvZhpp9pHTgM4a4UjlDiqOvQ2kYUY SUNVBXFwMcfGGuIUZNG8OADJZtpgSGQ1njW2hr7Ns9I0Xhy4VjhiiaOqt94b vosevM5S1bei6rARp3lxAKbsdlFJ2zAqPwmMmUWVRE6DOGuFI5ZYqjoMPgZM Xs6PKTnOYjTVDXEKsmheHBQyJTB9ZDXUy/U3lMhpAGctcMQSR1UPzvItTBbB a47GixdH26g6ZMBpXhxg7diK0tOHXSJrwd7ohs8W7Dltd8UxxFk7qmKJo6rH FCIi30gac8AeQ5zleDg3xCnIoplxgDOZneL7yFqwh7lJSOQ0iLMWG2OJparz ABjEjIP/pSuqfBMbHzLiNDMOcBEyCxqJrIU4yWRyHImcBnHWgmMsERwz4KTE /CZZ1Y3sq6rF2P80xCnIoplxgHchcx1HImvBnnOZpZ1EToM4a8ExFnmqOmN9 QmkYryyq1CqHBjhLApzmxQEOxnZ3t551jqxHcTJ5lkROAzhrvTEW6Y0pOEYc votOe8KB2k7VISNO8+IQFXHuMg5H1krC2twkOHIaxFkLjrFEcAzM9zDYyKTF KvtUwL6rcZoXx86Th7n9t3GCU1NLgdfmxpHGTN63rTAqbcplm8dO5h1La50j qXWOvRuHR0SgiD6N9bwfc+NYjLK6wU1RFs2PI4YxU4ktM4xYicvFMCbe2fbj mGaxitYqRypRORoEz0hjokHdYVXT4WKWxxveFGXRHDm4oMldm5bIWkmYlHmE TSKnwZy10JFKhI7GgwXDHNVFlc7RLEgD0CCnKItmycFAknuYQyKrQU7ugpVE TgM5a6UjlSgdmd94BP4zjTZoHMOc2DDnsDGnuXIAmFyvaImshTnJZTYek8hp MGetdaQSraNJwScDZJwLSp6TFrMt1zCnKItmzAFoTO55UY6sBXwx91iJRE6D OWu1IxU1kMeICXyykSmPbmNuOYdWG+YUZdGsOQCCz1xJkchaSXiTabAqkdNg zlrvSEUGqxQDERnrQSNc7eVHi7Efa5hTlEUz5wC0uY6HElkridc356C15JHK LFYjmmi5vnJO035MPFYbzzlszGn2HAS5q7cSWQty0thR3h32HBMt56w1j1Sk efTO+ggRubzS9FhlyPGLsedokFOURTPoEEVb5siRyFpJjBokbxt0xGlcD2nt s0olPqsQBPtSMgF1S8iwoG45DXOKsmgWHWDtmMBk2xQo1toqt5jtTIQTLSHb tQLZljitgo/WcmXFsKOSWQnPaaXVYWNOM+kAB5lHHvrIWpiTcpeQJXIazFmr kG2JChmcJySK/OmxlupjmOPaqYfDxpxm0wEujDlNbGEOR9ZKIrtzj1N37hnD nLUK2ZaokJkdcVVle8trlTEQ7H8/+YY5dbNoTh3gsg8dOPWhAw3PyVzPkchp MGctQ7YlMmRAZzG4xNBjVDLkAnFnw5w9OsbdrDqmgBxvcyGHI2slYW0uzeHI aSBnrUK2JSpkIAQmOnwXk0ba2atz9v6A5299IReTL/jCxz+e4x7+bHAFCT1n +/H4WcUZDEKe/X0jpde/AxN+4cNXHv3YzU/sv/T8+Eaeou1s7o5x8/I1A/Md P+7H57fywKyfOHlqb9/In++PP99dXRzfnZ0cfbg6+Xy7CV2/eX19/uvR6er2 7OPl0cXV6Wrz9v39vv10fL26/f3vTm+Ov7z/cMNf/6b/z38enV2ern5hXH47 vPAwv483sH5VHtijh2/9jd+5/fnj+y9np3efvnvrO0wxnl0OL35anX38xL8N dcxM0uZV/pLU2eBw88KvEhEo8N/XiV399J+rk7vhKy+v7s4+/Hp0dXn0+fqU 78PR1Yejm+PLj6vb9RXt/ge83/zHm/V/4P0rfv3SnzZBf9oE/QnvX9kEfb8J +n4T9D3ev7IJ+vMm6M+boD/j/SuboL9sgv6yCfoL3r+yCfrrJuivm6C/4v0r m6C/bYL+tgn6G96/sgn6+ybo75ugv+P9K5ugHzZBP2yCfsD7VzZBP26CftwE /Yj3r/AM+cv52eU/3n+6WX347m337q/DjcLN62t6cXZxfb7avHb76erLd29X /Eydbl46Prn7zLeSZ6HL76+OT2V49vf67ILniZ1f8cPq+vz4ZHXBU8nthN/6 7utzcP8Ubx6RR+jQY8EuMP0KbaerD8efz+96JDl6ytCeAm7GzxuHoYxv3Ib4 l3wj1fodn/l529PZi66ZtEX8je/8w/DG0+99aZ2iIeJfrm7+8R8Xq4t9KAp+ Or47+bS63YdUPpyd361uXky6NV95uzpnjDn7+ezu11f93p/Or64u3rwbsPdV v/ni+JYvctlX77rt9sW3/fZ6tTr9fD3JCJyMPO8ezTvrubyViGrLELsthPL8 g141J8isvCc4uKjIivJKcapm+bozK583qPzrjqps2witacQL88KxHd8neXHc q+a1B4bC8yyfjhM0CjMtGc+M0qrFYr8XO1QHbz2KaDNnhz6yThLOxzHfoKco IpEvv2duw6KeLiIPO+XqfXLTUbLBp4Akhs9WY0iSSo9aaYnhc2ul38KQnibT 2W9UwUHMANZRiil6lUWKDaUdb19+dNRElwJJswVE3RFSU3bY+cUnz0i6jQZj RNXrFPIBRx1o9/KmSBk6Y8FFT+CDN6jS5tgOyvSAL04Z+QInDOQpqhSM2Jmy rj8vzrj3MAiAYEHnwwgdzIEXvVutdykBEHnduDAdlvUdeHnKwViKhjwDndJ5 LkzdDqrx9wxTW9wL/t68vNHFMd61tTLAkZUIvE0+T1rbR1Yk8IPsTC06E5LF E1NAL65QXqOuZ5ZlpmBZ8xL4VxnTU9Hhme9UScqUIAQMEMGqLFVCqfnPi1N2 lgv+FB2zTFWHRus6W6aIenHK3oGJKOUSE2PNVfadK9Oqv7zqIOf5SpMBFVXj ooNmYvAGiOm4AxnNimssTA3KDltPwIfJIJd3FpNOT2z0p1EmSzk6HsfDn8qU 5wAMSdkkkW0zvpHWsB4ahT9YCt/aY4grYN6mYx9ZicK7QHneZn1kRQo/yLjV Im6eTJOs1BBab0zQ+J251IUp1j1mpvCvMaYnoj1z36mClK11hriGNpbnZk3K lrn0XCmTYW4ZTUoUNUvanPIcvEc612AkRAg+AI0JRHbuJxU7M784ZTkba5kN O3R+rCP2zpTtPIRY2ifKTkcIIC4mY33YRton+nmK/pSiQeP56Qveak6Uc8px rpSD8Y6HRqLgSdekMsxTjvLACGSTwwQqDs8Zu6kbFjcK/9vc2du9oPCt3RQh pbxx00dWovCy2Z5H4SWyIoUfejOoOzOI/6sHMIk8OQKnM4It7Hq3TxT+Vcb0 RORy7jtVwNS8C46JZRC73qRx/PSdm4lcGuM88OPKRUcYUybvTFk0WfOkzDSN qXAEkL18jcchdmae2s4b58g4K+bFZuzw/MhVdvPUdj5BtMHK4xcAFIvaPs0j SxFy6SmhEyFNsppCSaqOORRWPYXnyxtjsuCTUQwMofDzPH4pWb7EMYQIXOIp in5OuXCdonH4BXD41r6RGPzz/P77yEocPsKYKPkph5fIihx+6HWk7nQkBCBE DxTBkIGoIwBhir3LeTn8q4zpqajazHeqZIHYOOCBL3olo5mRPcwl/vEUEvGI EIUVjrki7UyZ5rrKXGqEGPgKUwyaBokBuzhToRQjMotHLp/DKIzvvMixi/PI lXhEROeTJebDzilSDm4ejYeQS2MpBTAGndcMZSaXZi4KzyBnDKAhIlBgHKc8 044Sp8zXOTIsewjKjYPCgdEo/AIofOuGLF5cmeNGIusk4Rlr8pbh+8iKFH5o HahuHMhTUxAprQvgbEpW0zMglHbx2isK/xpjeiISMfedKuE9ZDHaBJaZsUa/ z7yH5iERAWVhmMgTJtAcDmVCPNNVjkDMhokCcPGhEWpH6GiugQHRc+Hhk/dG YzbPAwNmKpRCCqLwMNFyTaqgavz4pZnYJZd06JGS8YErJgW7jKVHLSdIOfCD 5wMGipotJUl5ni2lJPQducLjijQor3Kcum9C4/DfDIdXLitPM1gtBetRc5KO 6qnhrYexvfmn40YiK3F4k1yeGr6PrMjhh1686k68MpuG6IxYnSSMXgGaPJsu YBn+Vcb0VLxn5jtVwC4NgWwzWxMN8wgFuzSlfvkvJ8TBGOkpYgPpOlLNxHqC 96KgSUwiPGpUKcF3fiYhTTBeOkV5x4xNtdUR5pIrReBxAcYEzp00eMEDA2bi lgkikSETHfLwUK0Pz6b9Ma7fVIopBE0BLRsHcwlpjLUBAKzn/9BtHBTudTQG /xLqDBj3gsJP4Atb4rjGqKBylkg8witReDkJlXegtY+stQxvx+b5rWV4jqxI 4YfW9urG9jw3OVH+Cs4HilbDslzpeZy9ovCvMaYnYhFz36kS4uMsMIUXeUrS SMuZ+Lh5luEjmghowVpEP9Y/emfK2Jl5iI/wHWAC4UJyNOYOvzPl2U46R5SD 2WTRWAhjtl4jV3mm2i4xGeYxDFx3MM9UPH5J9HrzpEyB0cKYRLIbpqGXNNvp 0MjFEsZoI1mvWacoX9OeIGVrvWzfBXQagyVJuZH4wyXxRV1wX36mjqFXd5Su Wrd0J/uwmYdJObISh7dmbLtvq0sIR1bk8GCG5qJGz+KTwZiA/yfGWJo94jSR l9e8LP41BvVULGLmG1WQMnj0/X4+OEqadTXo/DxXOUIgZmvGWpf4QutW4uca GJKv84lrO9SkzANjJjv7mBIx4zEp8tjQ0EuuO9JMAyNEJpbi3BmcAU3dEeY6 dZA4ZeM5ZQzRqRjxfCnH4MjbFIn5qMbXNc3mFpait5QouRRd1LTs4JQLDw43 Er8EEn88yx4o2ug08OWxs9VW4sctybZcHTmyEounONa25imLl8iaLB4GFg8F a/HB2ACRmAQw6dLoaRfhD/8qo3oqHjHznSqY4ZwJkMTYLiSNMU1yc1mmJIzM iQ2TeX5ix1pA7kwZ51sLhJ5CWGE+KjOP2OE8EqBoLHoexIYSEx/NUDZzOXgm ZO4e0ZDnYaFZcMV5nKykJ1W0FoKzojBXtUvC0jXilw9lF8DzUPZcjo6deBsZ yjNtN3LKDG4ohzsgasxoJeWyXaVG4pdA4n+ahcTHQJY0jhhRvziVzZ+9H1tA fcqfJbJSEg4z9wP6yJokfmjSCuourX37QWmqEWwIRnPysO8/+O0Lal5lVE81 Kc98pwpmOOHvkSmmAZUDSfKdnelcHZEP1hummc5pJECJOpqpUSQGLjrkXKtx GgWQjIu5ZBOcrCNvggvOBU3dwVd5rg6iIv0hSMmbpOzlM0vzL05ZnjwKaByq 2jOAifzkzkSJ5Rg8AWctwnhdQTrX7gGGICZL4EElZytPubH4JbD4kzlGa7DJ B01JH2yXtPNa7qBhaBrzcnoycPrISiw++DFP2KcsXiJrsvihUyuoW7Uy1Hsr etpAyvkUjJ+mFc+8LP5VRvVEk/Lcd6rIPznJamsKGGPQNZqZZcNDWtQHx7SY GWZETTcfaVE/y5a+WHGSbNE46cypWnJ18xQePC6sT9KqlWtS0FDiZOc5PyzD woI1loyccFV1aoXOzrMUD1baDyGQCbpxAXY2bVjkysMbiskkqxINxrm0YUka wkXDRTSi1Rx55pRbp9YDJvGn8+hFUdriqHSi1VTxwTrM84XpI2uReAeZ5jQS WZPED71aQd2slaGeIZO89VE6PWqaloKZZlVsXhL/KqN6okl57jtVQH0SWS49 AIkoquqONI/5IadsiRLJnr5KmwLGzmOKyePCE4JNcrIuaVgEgJ/nnKjsHhCG yEw+hahb18aOZtoIS5xpsi5SiJqTrTKU0zyFB1gnJ/eDYz6s8YYSFj9Xe9mQ vE3WOG+kuYRKyD/X7kEIwQbrwUs3DI2gJpSeLG8sfgksfjULi+exOrr0PCLG tVrykDtoIpLJO1baR1Zi8Yzqee2m+siaLH5o1wrqfq0M9YkCWGlayv+nmVAh TbOQNzOLf41RPdGkPPedKkgZuewQ0ahPTrOjD0zW5piThaxZxwWH817ohI6s zbLfwReZmGES0zWu7ZKKxVPpYuAEGiArhw6SQ9L0Teo1QDNdZcTgSdQTOGqr MDaWZ5F6yMAAS8aj2NOM9TYfHRhzyeLJGy78e0W/qsNsnAcx+rV4cJbLjmRj 1Ji8yvZBk8UfLov/MI+UMVieK3RmVVosyGbxjjKPlfaRlTYEwPuRp/bphoBE 1mTxQ8NWUHdsFW4oe4HMDSkZjSWAcEOYYllsXhb/KqN6KhY/850qSDlKx1YC sFG12QwQ5zmOK2wtMVdMBplI6BYwsUvzKCeQIg8McszhkRQFKY+kLs60ss1j GAwEHtOAKn0KzbayHT2BHCznklRzslzG8ix2Sz1iyNEDCsl5zbHLHjFm4sRc KQWu/aN1XOppcHm+kzQxyCRifAALSmvMwqnk9Wh87swLu+bo/Gl7PHL0V33u Q1qGUZSA9OWYp2TKZL77UKrsR8E0gcO7HheMR67uFRDmO6zVWAstjW0gPxk1 fWSdJByMyhueGhJJZM16aeisBQWttSyjvCPZmPdurATddXNt6KCM0T4DQKkB 0G8++n4vEGiC4zR6BAIeIVFT3HINU60/N7o0dpj7KQRJZCUIsiHX2Vgia0LQ 0BkEClqD2EAJQsAAEayqR0boqEx23jBoARg0gUd2AQbF4KzGAxoKvEZzxwwB ZD7+fWQlDJJuMXkYJJEVMQgHY3MsMDZ3lgt0QhdNv+OWf3udLd3tbhj0oocf 9wKDJtjH02OQqO0RFSsz6PSGdNkYFENmKdZHVsKgiGNmyk8xSCJrYtBgy4oF tqyeKzDnAwQCGzTWmd53bmpDioZB3wwGTTCc9RhEwCgUFGSdoN5yEAUPeRSk j6yThAc/ds53q0kjR9bEoMFVDtWucoxBIDucosK3yWgO73go3eFsGLQADJpg dbMAgwJzdqtYtKRQbz3IRpu5HtRHVsIgS2Pn9reaTHFkTQwaPHFQ7YljuFwW naZNYD3fYU2zeFd6frBh0AIwaIJzJQWNfSlYr9ECWaq3HuTAQeZysETWwiAY E/9uYRBH1sSg4Ug/qo/0i1s9gUOI1kSmQZomyKb0QHDDoBcRELsXGDTBtdjT 5uL5GBRDnqNHH1kJg8iPNfLYatPDkTUxaDiQiOoDibN0NW8YtAAMav1+UzR5 T38fWQmCHI7xhh1NBmqeicbhNAWqT1PM0pO1QdACIKh1K/RkM5ek+8hKSfCz m+muJpE1MSgMGBQKMOjVG8o1CFoABLVeS975lLcp3kdWSiJCtjUMVLWGwUEk jQUi6ddvh9MgaAEQ1BpFBKCQ2ShCImslESgPgvrImhA0iKSxQCQ9g5d/w6AF YFDzuQ5h1Mv+6eMvkZWSMCFlYpBEVsQgGkTSpBZJz2JF3DBoARjUXDoZEMcM C56OG4mshEH83OYN3j6yJgYNImlSi6TnMFJsELQACGoWY4yHYwaTT8eNRFaC IGvGDldt9RzhyJoQNGikqaDz9gwuUK+HQftrkIIOZ4LbseawT4YsTKBlm+BE 2l7gbXMoodFVmqf2ABJZJwkrHl+ZmnSOrAm3gxSTCqSYNpnoUqDEbB415mo2 lXal20PK901h0H64JDWPEnTB5ZWdfWQlNZb3Y8qhp2osiawJQoMWkwq0mNZZ ZC4fnbGQNG6l1nV2MXrwBkLqLJpJCQGGzMO5ElkJhLimzTQIkMiaIDSoMalA jemsJWOZL5qUSGOAKiYli1FjflMgtCdWSc2mpLe0zbQI4MhKYiiksQLmqRhK Imui0KDHpAI9pjfGeRAvJyMtYBTVtlToDYUOF4WaUQklfnjyUEgiK6EQQKZh Wx9ZE4UGSSYVSDLlUBzxfZVyG62CC3nqQlsVOmAUalYlVqbvvGVhiayEQuTG hPJbB2Q4siYKDapMKlBlBvROup17wgRjS207RbfY+X3fCmwoVDGNZlbiyGUe TusjK6GQszEThSSyIgrZQZdpC8xrIwQmi8kaG8a2+0ZEt2Exp1O+KQzaE8Ok ZlbiKGVukPWRtTAoZC5N9ZE1MWjQZdoC89qIJgJasBbRj8lMd6IQdmYx5rUN hfRpNLsSMULKAyGJrARCwY1dj6cgJJE1QWhQZtoC91omQkQmGWtd4qJRR4Xa BtkBg1AzLPH80ORax3JkpSSSHVske5qERNZEocG/1hb41yaMjEFMh0IMccwE Zqf8HxnBGgodLgo1zxLvU+ZZ/T6yThIBchWLfWRNFBpk07ZANp2IfLDeRGOd 02zTJ+poMb5JDYX0aTTbkiD95/MAQCIrJYHG5y0L9ZE1UWjQTVu1bho6A1wt Bk4vRPQKEAID+p2HhkILQqFmXBJ8MJkoJJG1oNBl+lj2kTVRaBBOW7VwmlGI +W0iH50d7di9G4TsghqKNBDSp9GcSyKkTDv/PrISCNmYMqmQRNYEoUE3bdW6 aXFPso6il0Nu3moOCJq0oBazDYX0aTTzkugh09G/j6zFxzBTNtlH1kShQTdt 1bpp8U9KfIGSQYNR09dIDJTSvi9ON/OSHUcO8p4bmmAZc4Ij+3uBt828BEPm MZU+sk4SFnNlUX1kRbh1gzTTFUgzHQE55sXGWus1AnFHHSym9PymMGg/DJSa eQk6lymL6iNrabNM5vJXH1kThAZtpivQZjLygIloA1hwUSO99Z3bd87XQKhi /TsLCO2VeQkln3lgVyJrgZDN3I7sI2uC0KDNdAXaTA8YCRGCD0BeYd3rocPF CMS/KRDaDwel5l1CETJPyvWRlZRZQJl0rI+sCUKDNNMVSDM9Gq7CXATwjpJG 84YLaibXQEidRbMusc7GPGl2H1kJhNBmbiD1kTVBaFBmugJlZsAYYrDJMEwa hSYqYBcbETpcDGrGJQ5xTBfxtBCSyEoYZDH7oAxqD8roMGjQZboCP9sI5BCI AiQyoJhiIiyolVMDIXUWzbekt4DOAyGJrARCLmSuS/WRNUFokGW6Aj/b4L2U YclhZLqmuL3Bd75VY7Nsje+He1JzLvEQMsuxPrJSEjGOnSx7moRE1kShQZfp CvxsYwoBvLEuJEdj1eVOKpS60FDogFHo4J1LPKTc4/oSWQuEgs8bvH1kTRAa ZJmuwM42GbEtcT5R5KJR4xlgFtTkqIGQPo3mXOKTG9tP3jIN4cg6SQQTx1yo n4rDJbImCg12tq7AzjZFSC5FZwlJdVIuxQ4XYyXZUEifRnMukQ2d3Na2HFkp CUyYtzbVR1ZEIT9opr1aMw2dQYZIkMVp4zROkmCwC02ueMAo1JxLgrhA5wGA RFZKwpHL26XvI2ui0CCa9mrRNKOQowCRnEEyqtO6bkH2SQ2E9Gk045IYcGyz 7ulpXYmsxscy9Yp9ZE0QGkTTXi2ahg48IdjkArqk2f8E8B0tpu1sQyF9Gs25 JIZg86hQH1kJhYIba9T6FIUksiYKDappr1ZNMwoxA4qUEtdkkFQoRB20ZaED RqHmXMK1oc3z1e8jK6GQ0MM8FJLImig0yKa9WjYtdDWK2aZjCMKxZ3H3GWXq 4r6b+zfnkl1C20yV7T4gHewF3jbnEhvHhIRPTQMkslISFDMV4n1kTbgdxJm+ yDMTXPQEPngztqcwZpoJi2nz/U1h0H64JzXnErTk83bh+sg6SVg3Wolvndfz 2rMyOhAatJm+QJvpiJwXTwMDXgNCjjpqGHS4GNSMS8jY3AULiayEQSG3p1Qf WRODBmmmL5BmeguYbMDg0PmxzdWdNJeJ0L7XncsEof1wT2rGJeRhzL7gKQhJ ZJ0kXMpdgesja4LQoMz0BcpMb5wj4yzzIGc0R+U8k6jFnNdtIKTOohmXWILM Nip9ZJ0kPHrKbK8rkRVBKAzCzFBgZiuH+BiHkCeYwPdXpbuNi1EjNBBSZ9Gc S2yEMYnoUxCSyEogZE1mEn1kTRAadJmhwMw2OIg+huiT9yZqZLeug8WclGsg pM6iOZdYRyGTCUlkJRAKfmyv8OnglciaIDToMkOJmW0wHjChd6IdU4gRfOhM W5ie4/HfD/ukZlzikhlbI99ajuHISoIo8GPur08FURJZE4QGWWYoMLONSGg9 WTQWgtdo/3FB4vAGQuosmm+JdZn9jfrIWhgUMk/J9JE1MWgQZYYCL9uYEqFD kyJ6jIpth8hTTNscO1wMarYlLpHN7OohkZVAiMJYQ6CnICSRNUFoMLMNJWa2 xqJP4A2laJ3GzFYK9AZCBwtCzbUkGByzoN+yLeLISkk4GFvI3fIL4MiaIDTo pUOBmW0iCo68CS44FzTeSdTRYmz9Gwips2imJYFMppdtH1kpiQDZJ3Wh6knd MOilQ4FeOlmxuHPWYoAUFUQ32S4s5qRuAyF1Fs20JKRcL+s+slIS0UDuQV2O rAlCg2A6qAXT4t9GGCIjUQoxKf3bqJVjhwtCzbMkgs8EoT6yFhJam7kmJJE1 QWgQTAe1YLo3kbRiZpAcklNIFXsTySaYPlwQapYlMRDlGidxZKUkrBlbyX2a hERWBKE4CKZjiZMtJQMGuBYDQMW6NBjq0r6XY82yZHvUQubsDVM0w2mmJYsx LTGQ6RcikZWSIJfZwKCPrAm4gy4zFvhlGjTGJgzkKWqM6pj0mX3H2wZCNbNo riU8a2b2tewjayUBYw/uVhIcWROFBmFmLPDLNAaIIcVBwKDprQvGLMgxoMFQ QRbNuAQT+LyB00fWSgJzYUgia8LQoM2MBdrMlFwKJgSuQH0cu6Y7FxdS5xsb momH7AUMNesSMjHzrFwfWScJaz1m+idJZE0YGtSZsUCd6RNEGyyXZC4AaFwD Es9MDYYOGIaaeQmFYPOKsj6yThKMy7kOShJZE4YGfWYs0GcGh9H5ZMlCcpod weA6XIxvQIOhgiyafYk1LlMm3kdWgiFINq+jUx9ZE4YGhWYsUGiGkAInl0y0 1mkWh0LoUmNDhwxDzcDEEoydrNi2cguV3P0dQcrbKOsja8LQoNGMBaa2kSsx A8YEHwxpbm+EDhbT3vIbg6H98FFqFibOY8okIhJZJwmPNNYce8tRkiNrwtCg 0owFtrbJkEkYwbtoXFAUZUnq9AZDBwxDB29i4qz3mSgkkbVQCDP7jfeRFVEo DTLNVOBrG0OMJO2OHNfcGnuIGLrYarJDRqFmY8JPDWXCkERWgiHymdqlPrIm DA3OtqnA2TYhg09EQ17OrSi4EOq3QRsKLQmFmo8JFxCZp/f7yFpJ+MxV8j6y JgoNEupUIqHu3SQJUvJGd3qXq/TFuEo2GCrIojmZMCaO9cV4igASWSmJbM2A 12sGdDA0aKhTiYYaLFhjychCtUpDDZ1tbOiQYah5mQTnxrxYtwzVOLIaFmY2 f+sja8LQoKFOag01w1CK/I/lixSiZn0aTNr/E7wNhmpm0dxMQsTMPth9ZCUY SmFsqewpDElkTRgaNNRJraGGTjqueUoRA8axS7oThgA7bCvUhwxDzc8kOsi0 l+wjK2EhRJOJhRJZE4YGDXVSa6gZhqInIJ+I0dprijKInd/3g63Nz2TXcezc w9gTaKSXcoa3+ZlQoFwrEY6slYTNHbwSWRNwB5lmKrHSBAjeB0Cwo3PY2CrY cs7ONRQqyKIZmvC06TJhSCJrJQEp09tJImvC0CDTTCVmmgbJIIjvU9L0/ZY9 QfUiZ4OhJcFQMzTBhJl2un1krSTI5O0I9JEVYYgxocch+bd+XSFFg8ZHY4O3 RrHMmVIXF7Mc34CoZDVuDiDaK0sTjGHMhPbpwJHIWknEMW3jVhIcWRWIYA1E JVrN5CmJD55l0jamgB/zVtIudDYgWhIQNVMTTibmqaT6yFpJuMymc31kVSDC NRCp5ZoCRMZSCsym+CEbM/AdASLTgOiQgajZmhDFzCYDfWSlJCwZk5eERFYF IloDkVqwyUAUg0GPlIwPo60bdgJRXFDruQZEBVk0YxPCkDIxQCJroaHxmUlI ZFUgsmsgKrK9hcgJkokOU9IA0ZL8Jr8xINoPh6VmbWKjzwSiPrJOEg7SmJJh 2+jN1S3N3BqICoxvEwXGIGMSkcUxPf6YGG4xR1gaEBVk0cxNLLk8zWYfWSkJ 58Zw+WkSElkVh/wahwqcb1OI0XhwEUN0XoNDS7I3aThUkEWzN/FiyZF3fEQi KwFRspmsrI+sCkRhDURq71vpzhatheBsAq85sS3t2WJbqz5kIGoOJ976zE2z PrIWEFFmc6Y+sioQxTUQlciqI5eNFNA4ZEjSAFHskm9AdMBA1DxOgrGYx4j6 yFq0jEKm1ZJEVgWitAaiAmE1WJ5hEgKZQGPHA3cfqLP6maYB0ZKAqLmcBMy2 F8B69gJkfGZ9KJE1gQjWwmpQC6sFiJxsQ3BtBnbMVXgMiJbTK7IBUUEWzeck 4OgzswVEtpoTtzW5rm8SWRWI1sJqUAurGYgIrAClbJmNHZzbDUTEINaA6ICB qDmdhGgyWxP1kZWAKHvXzNfeNYO1sBoKfHAhgTfBUUjOj+0A7Aai1MG+rxE1 r5NdqpPMrl4wAYtfinSzeZ0w/uctRPWRtZLwMfNkn0RWhdy1chNKzDYNei5D mcqR1zRA6G0GFtOUruFQCQOdA4f2ze1krB7edjsJ1dxOMPMsSx9ZFYjWyk0o sNtkIIougB3+VALRYnqFNyAqyKL5nWDCXJsBiayVBGW6/vaRVYFoLd2EEulm CoYpkQ2JgiedzcByJOQNiAqyaH4nyKiYazUStMdI8pPYG78TWEs3QS3d7IGI qVCMyYJPRnFqUoBo31fDGhDVzKL5nRCQyyMjfWStJNyYgmzb7yTUBaK1dBPU 0k0BIgzR8CxjiPhqqYBoOZ0QGhAVZNH8TohiZieEPrJSEnZU6rjD76QuEK2l m6CWbvZ+JwHlIAsGikkDRFx7t8XqQwai5ndCPInnuWL3kbXQ0KQ8mU0fWROI cC3dxCJPXOMCV7BcnIUwZng+5gDXSrNDBqLmd0LWj52I3yIjHFkpCWdipvGS RFYForV0E0s8cWMEwBhtlGulWayOXWyL1YcMRAfvd0LeYaYlrkTWSiLllocS WRWH1spNLLHEjcGRtykSUoiKG5wKdkUbDi0Jh5rfCUUKmWvVElkriZSLhhJZ FYjWlrhYZInrAvjouO52hDpC5NoS0SEDUfM7sQYy9Yx9ZK0k+JJkJsGRVYFo LazGEkvciNEmAgooy0QqIGqbZgcNRM3vRDr85O1X9ZGVksDg89aq+8iqQLQW VmOJJW40MXnDrM0kq1FWMxCZJqw+ZCBqfieWQqYnbh9ZKQnrM70O+siqQLQW VmORJ27yNlnjvAE7Js4a8cRdjgNcA6KCLJrficXRBj9bZMTUapvEPCfTJKOP rApEa2E1lgirI3ljpZlttLpGkrGjBkSHDETN78TSaCpbjIgjKyXhzNgu4tMk JLIqEK2F1VgirPaUgtgDSJaa2jv5zu67A1zzO9ket2DGtiSeDFsJ3Ae82w/U bY4nclou70SbRNZKIkBuEhxZE3Rprd2kAttNY4KxFA15x+irMxpYTtPMhkRF WTTPE3QQ8kZOH1ktCZfrecKRVaFord6kAuNNY0xyXCpbcjSmAhuDImhQdNhQ 1FxPULrOZhqOcGStJMhkmtFJZFUoWgs4qUTAmZy0RXB8pVRQlNKCZFMNiYqy aLYnGH3m2bo+slYS0Wa60UlkVSRaKzipRMGZrEOeZ0KEYDTbLwxFdjFS8gZF RVk04xMCspk6bomslYTLVbRLZFUoWms4qUTDmTAZGyMYD0FpBbccT8oGRUVZ NOsTMTTJWzDuIyslYXHMKWTrtDFHVoWitYqTilScjELoMCJgGFOCLP6gb4Oi oiya+QlhyPUckMhaeGhy7eAksioUrXWcVGSQa6wNAGA9/4fODs4spl1Ug6Ki LJr9CVmfuXfVR1ZKwuXKSfvIqlC0VnJSkZIzWusDeheYG+kO2cUGRYcNRc0A xTvINkCBWktFwUAmKZLIqki0lnJSiZQzekuJkkvRRaurz3xDosNGomaBQpFy +YhE1koiUd4GWh9ZFYrWLrlU5JLLYJ0w+uQhatpoigUKNig6aChqJijWgM+r z/rIWknEMTfHbRMUP8H4HYciu9Za2xKf3IghICCCBwJNC5MlmaA0KCrKotmg WEi5fkwSWSkJDJm7eH1kVShaa61tkVOuSfz/QIRoNdsSDEVNa33gUNSMUCyF zGWaPrJSEna0NeyWEQpHVoWitdbalmitQwg2WA/eOr7HKiOU5bQxaVBUlEWz QmGuM+Ywvc2KYiW7XIuRMpOQyKpQtBZb2yK7XAPOOm+Sjdpla9PWimaDon1I onmhMNVJmXxEImuRInK5pIgjqyLRWmtti/xyg9xa45m4wZhWa6yDwN5voP3W Fzr/ki98/OM57uHPBleQ0HO+Ko9HA87gwPLs7xspvf4dmPALH77y6MdufuJw 4a8uro9vzm6vLt/uSOnumDYvXzNo3zEUHJ/fykOzfuzk0b19I3++P/58d3Vx fHd2cvTh6uTz7SZ0/eb19fmvR6er27OPl0cXV6erzdv3N/320/H16vb3vzu9 Of7y/sMNf/2b/j//eXR2ebr6hR/tt8MLD/P7eAPrV+WpPXr41t/4ndufP77/ cnZ69+m7t77DFOPZ5fDip9XZx0/821DnLKbNq/wloeNaijYv/NofEAQvEevM rn76z9XJ3fCdl1d3Zx9+Pbq6PPp8fcp34+jqw9HN8eXH1e3D69r9d3j/6G9v Hv4NH7/nH775L48++C+PPvgv+Pi9Rx/810cf/NdHH/xXfPzeow/+4dEH//Do g3/Ax+89+uC/Pfrgvz364L/h4/ceffCPjz74x0cf/CM+fu/RB//90Qf//dEH /x0fv+ffvvnl/OzyH+8/3aw+fPe2e/fX4S7S5vU1MTm7uD5fbV67/XT15bu3 K37sTjcvHZ/cfeb7zBPV5fdXx6cyePuBcHbBM8nOr/hhdX1+fLK64MnmdsJv fff1Kbl/0DcP0CMA6eFiF95uod82soRNxOnqw/Hn87sejo6eEq+nqP2Sb5T5 8re+8w/DG0+/twBSM+zDah10/vO/7APxJtyPPPyeXA/AuB+J8Jy+H4nAvxel MW9pvodmbM8etUs2eLFvdBisZumE0iRrY8+qTAnIpWCMtdZr+tM66mCCavlZ 0yMLLnoCH7zRSLbB2A607rva3JAvWcJAnqJiixAMdmaCU5TPpgYQPBfHyOWx zisKOqg63Gax1MsnAc+AWpwX1ObydXv2qAzfSQY1z8UTI4fm9F7oTGXE5YTA RJStPYYQzXEe37kJrF+eR1xynotSMuA1qMaAq7YUVz+dQHJ2GMK4geeoy9wE +8nP58ZXDHmy4nLeKJFjir3u5s6Xi1UzGb89+8wlmREJrecJaGwNfOdDl/T7 6FpJKxclhMhzdgDSNOb2oFc+anOzgExeMTguWDT9D7ytDAi9Dx3z1hCYtvjo dUZ0vvLcKPoxND4aJv5WI8zh3GL13A7Lv28freGeP/fnAUziwoJrM03zI+cZ SyrjAQ9qhoIIIPxdI8Pnsqc2jhrnyDiR2jtjFXzU8zWvPP/4BNEyPeB7GmDs JOXO3FLlkkzwwFNCJ9Vi0vW4SfrziOrcDszhbx/N454HhBA9zyNguJwZs9gd AYQwwRHBZwX6GEMMNhmKYcx4d6dOH7tYm1fFKL235LxLcJpqxscuasVU2svm MDqu6YnxwDlFbsHprezUeGAsJaZ8XKT6MQvTqQxl1LkdmAXgPrrLPTuwg6wK 8QTsbBptGrxzYIfOV8bRCMRoQCKIZyBVYHyEjirnFhxwfRXklLA3mv7kDAhQ G+NDClygJhOtdZqWxXxPU21ixdMOeqRkfBj10BnTqdUuAg/NJHAf/eeef+hC dEZ2DeV8voJY8UNXnVh5L+Vf4uHjUVNpBa5Qa1eBgadfvmbecdWgYQg+dKbq 8rqAPFcxzF0CJ0ma8cYgD5WvW5K+F8QsPjrkO6tiL/Ur1AOzEXwWrGZyqHt2 YHOdgFbGTqA45im+c2A7/ZqiNrcUAvC4cSE5lbFArL/0H1G2JMiisRC85vwm dlS5DOSy2fDUAwykzJkV9zTJSkXl3IgLemdMIpIzU7ojHrVzOzSjwefXsmfx sHt+XGNMPJeA7NVqKgYe19WXN3hIM1L5xCiKTjOuTWdqY3xKxAPapMg1jeaZ YxxNle8pF6eReqVHcEZjVBZD9aW+xLkxJXVRLC9Up5VeIbdDsyJ8fil7Hpe7 5we2YeIbiREh8UysGti1NVYpQj9wLCFPx0rHpsrLG9FY9HzFDCUe15rrJqsB la8bMkRFNOQjqPgBVt56FlErcxcIzvKl0zgbiapVzV3Uw+3AvAqf3z+axwbv +cFjAogILgSjkYP2kuiqhZbkxgUDyPq6Ydany616wcBZOfImMHlxQYOj1FF1 ubYUpgQpeSZ+OmGjrVqgcm6Rpx8KaBziWEvF3bnFLlVe6Ts4N8Nnl4tnMsp7 dvB4KytCgZTPHBivF5Zoc3MknM+J4Fk1CbuOaq8SW59EvM4wDxo8SLbyjpac erFgjSU5/WJU2nXobGVeBVYUlwhkgu6Wgq08bR+g2+HzOzTzGOk9O3gMcQFo fRR9uEZWD6Y6PwBPCDbJUmfSjB0AX3kBWzgfYYgMWClEHXfBjmpz5cQpJesi hahZWweTulQZSME62WLiKhCs1+TGYFVdV39ofojPLw7NY7X37OBhRs7TsDBf ZuWawZMqkxfOjefeSDy0GUaTCqxIP9PpC1QbZD3IIWk0l32BWpmPikjVk5Q0 svqiuW5Y+YCS3FMQJzCUfcAxg7XRe1p9xeqhY6KOWX2Tjom/sWU7ixvf82Al rJfBipIZ8wkdA6vax12RSR8xFjBS4VirmZ25IXWxNnvh68VlE5eA/IirSi2q z17EMEL2S9AnzYYJQOx8bSYvOxKBq3uuoTUr2P14q75i9Q2YKj58ZfNjBaRO j1a/XN+sbm/Pri5v5ZPr3+6WXzw+vf20Wt19ffGnq9Nfv/7t9Orks3h3cRqX d/zv3/8fUEsHCMEEtWECWQAAqzIGAFBLAwQUAAgICABImo9HAAAAAAAAAAAA AAAACAAAAG1ldGEueG1sjZLLTsMwFET3fEVk2CaO86CplRiJBSsQSBSJXZXa l2Jw7cp2SPl78mjagrpgmblnPOMblze7jQq+wDppdIVIFKMANDdC6nWFXhZ3 YYFu2EVp3t4kByoMbzagfbgBXwedVTs6jirUWE1N7aSjut6Ao55TswU9Wegp TYegUdkpqT8r9O79lmLctm3UppGxa0zm8zkephMq+IHbNlYNlOAYFPQJDpOI 4IntG/63VM+eVjLGHIJ6fCw9xCVxnOHxe6LXVgh17gIdm+KuYe3r8EtCe4mC /fVPFp4gNm23r8FKwWnnAJbEJA9JEpJ8kcSUFJTMonxekKIoSF7iCSuH8iCk 735ZKBpb++5k9rTIH7LZc4nPj3+7+DdX4Fj+h97LI7sGDZ3ZWHYvVxYeh8o4 i9JoFiVX91I3u+Vrcb28zoITYLm15gO4x1kaX902Uokw2accDxwDDm/L+a6j 85IHg+7rlYKQm0b7CqVoFDkoNWlJmk6yWfVhRxizEv9aLj73kNkPUEsHCMPV XHqAAQAABgMAAFBLAwQUAAgICABImo9HAAAAAAAAAAAAAAAACgAAAHN0eWxl cy54bWzlW2tv2zgW/b6/wnB3Bi0wih6O69iTOFjMYLELTIuinZkvi0XASJTM rSQKJB0n/fV7SYrUw5KsJPYmM9sWbUUeXl6e++AVqVxe32fp5A4zTmh+NfXP vOkE5yGNSJ5cTX/79e/OxfR6/ZdLGsckxKuIhtsM58Lh4iHFfAKDc77SnVfT LctXFHHCVznKMF+JcEULnJtBqzp6pabSLUrY2OEKXB8t8L0YO1hiG2PR7fiZ Fbg+OmJoN3awxAKn9eExHTv4nqdOTJ2QZgUSpKXFfUryr1fTjRDFynV3u93Z bnZGWeL6y+XSVb1W4dDiii1LFSoKXZxiORl3/TPfNdgMCzRWP4mtq5Rvs1vM RlODBNqzasEwBwgsV/rlOEH1MQ3/uktGe9dd0kNzuEFstJ8pcNNVZtF4V5lF 9bEZEpse+164H6BT/fXhl8qvWDZ2LoltUBUyUoxepkbXx1NKrapygA52pW7g eeeufq6hd4PwHSMCsxo8HISHKA0t4zTrIg1wvgsIB99JlzdoJhfdK3nuMlxQ Jqwi8fhkB+wENlQ3Ikv7Q1X2GmjCoqgTCurMXAhbCBrnjuDdm0YuG+Z/6SpQ PX8NDvA9V2JsCAC9VbJlid0OYrrNIx12mgx8X2BGZBdK1bBVQ0LdY1L6BJHl HlKT0AhVzmeii7tfP7uyz5HbACS6Ukpt9wuma7PVxRS2uRiF2IlwmPL1pU5R tnmin6VyV9O/MYLAdJA9DCAj6YNpd4cH/0IgWaqlTr6gnHeI+R4VlP/YwunG 6aQhWuKdBOdAFYQK3xHOG4iCiBCSyR0CxaQnHFDtZ/wf9Pt2WK0aZoxKD1zg 7JBObp8RynZdfhjdIxyjbVoWJUZyqaNyeCfEaTo18AIxlDBUbJyCgcszQaCS 0V2ABim0cCLCBcplUeOdzUle8SRdZ3+c0rPHmjFdpShPtiiBXpyrhhC8WzBQ 77cv07YIB5IKytvcK4yRYyDfNqanFGg6fvq4L1Zuaym+HxZsQRvSFm27/vlR maiD+zEGUcyT0FqjfG5wCo7GBaNfpT4phULizez8/RydTycyHa1ikqa2ZxEs 4zBWrO5AlEMLXTLk1JHP5RC+QRHdOeA+HAvnXprV9y98sGxX/0Ot3x3jNtIp 0FZQXiDpMyTCVENRWmyQYbLY5qHYKt9QukE0EMmptQLJsXPLMIJyDtZPQmF6 5D4I1aOT0QjEF2Cphn1JHmG598jKXAmReqgKPkYpx5Zr4968sl/XqoZ9fcux A6WspEtNXhpCsC1WVjiQuSANxCPyBKMZygfThJ2Lk29Aih8UYnSwpVhAXeF8 xSxXNGnlxweinddg9OwnjtJqVovqnPe5QazL97KKbwSxTnEfvWkLNCmfMpKD MwqcwLiIJERwUFFN1CHTygD/CuW+Dqp3TOb3zgZ7AslQ6hQpRB3MBAXAIT3K funZ6++sVurRPrXVsaPCLWPwcvzQreX5J8+wfUdT8Hb5Zqkcq0PAQ3ZLU6Nt 02MNtua1679a5VoiRjITHGDG9CaMbosqImqGa659LCXTvlSiwlIn8Dj24Ffb OE7LOH9cBjUBGSpsKOYR0XvUHUq3+O277xPx45V1HlQUacmn03CuZ1ojmD3a QUewpqwz6TbW86K1n9GhqZ/JkH8qht6+HEXvjktRcCKKnEeaUqWUbh2nTRBE nICEfsBzxsXpYJiqEBsX8ulhUf44UcOZQxmsljkq1kbs836wOJwzXjLKO8uJ 4fUcjHA94WsM2Ces9mCw6tX2xl7nlP2Rt3ixyFscL/IWR4q8xcHIG0y1M+91 7ddPr4BOtV8DQ69rvz4ORcfcr4GiV79fz7yXyhoqxI6TNZQvHiFrKIM9eb+e jajxXzLKH7uDzUZU5M/Zr08bsE9Y7f92v569WKU8O16lPDtSpTwbqJT1qH0K f9YHZ/aAbv/SoexR13WN+bz6qWyJ3j9sNa0Ch+JqWv4HR/ZEmZHcWq12BnuL wq/SZ/OoOp5FOS8QJGar7Z2cKYRoQClJgKVbKgTN+q86amc2nvplBCmgOncW G5g02eiVyjP4HPeDxEPRwtSuUcobtfZ5cqu5PPr1yqNf3WbmZhlKG7MDHZjp 8/G6fmbgDpNkI9oj946DzV1f1VueXff2Nw6KverAtlLX9HZMrbUaALQOhLvl 2/7+GdqQ6nj4QBB8xnxUDGjva0SBiZ8Bl6vblAhw1XDYppymJOqB7EgkP6WQ NzU9iNLBq4uNffeAQih6LDnBk9hpErufQuQBq9s/9T8wkp9xHccwAzlK337J HOJwumXyAiwm90Y4wwVGtRylb6SGb9WA8kro1VSexmM2mJjq2eB9RzYwnvM8 Y5aM+k+i1JhjDKWQ5/U1IcoTqf7SG6/kJ3198SyzD7jckMf9VFb+J5obypUR k98E3s3N/PbGu5lHN1Ya4VDzPThN6ORf3r9PpGuwGNSVZhk6FUvDJpIzj6FI 4k7Jz6z+nYfqqz7vkAk6gwAIHdNhZkqwAzrSrWgs6kOR+dMO0H5gNS/SU+aI 24qtDURoVTw32mJK5YVxM+nId4ZNmUi8s2A5nxF945whlkBfimPZ02xkJb7Z qmsvKcZbXpzrzw7cfq1KdV5CU0GLTjWbKrl7thhhw+BPZkNViVMWyU9hg7Pz ZQErltXJxNbPAChQpD+2hmHewjfD9gr4N6Enf1uKagh4pU3wnsPsLfeP4VGv lbQj+PfskH+rlSW2Tr04CxaeWZzqMIz7/tn7pRcQ+4UMvLM68lteJNSxRTmL ejukjFQfUsuvWBkiooP/eZ83zzste7aYdxu37KiroHQvbSogWs2WQhgvO/U7 N5R6UJyRvPoYh8P7KbwxUvli433XkHo1/YYZddS7PT9WAuhe66Oi/8TJ++ka ajs/Mmm7vVty2ZEhbkXYjbpslJKGzkvqYdCxk2tS1pfqpzaK8l++wVij19fX 15duu7FsKVomaBEtaWvWPXtvJpobO/snuZbyofLYtW/mq7XtqWBENUgfVMHd 4/EQtZ/LL9QHmA32mC3fNnAi3zWkQo8ke/JW4wQRaR2in9/tEdGYqdGkXLY1 O5SNuLeChFdqC9JJAPYLz587fuD48+na81z1x/NKLSRw/cPEKAzae95K/bFK d7lPU78X86mJWweqT5vWy2UdqNtexPfkOr7I55t5fMMzVDv3bLxUVLgGqNNZ Zy1nPcDsY20wCnRSnlLIyvgQTw3Q/ydPX2S6CQ4R1UT9iZhyu/dZt/snMtf/ BVBLBwgO4Gq0egkAANE5AABQSwMEFAAICAgASJqPRwAAAAAAAAAAAAAAAAwA AABtYW5pZmVzdC5yZGbNk81ugzAQhO88hWXO2EAvBQVyKMq5ap/ANYZYBS/y mhLevo6TVlGkquqf1OOuRjPfjrSb7WEcyIuyqMFUNGMpJcpIaLXpKzq7Lrml 2zra2LYrH5od8WqDpZ8qunduKjlfloUtNwxsz7OiKHia8zxPvCLB1ThxSAzG tI4ICR6NQmn15HwaOc7iCWZXUXTroJB59yA9i906qaCyCmG2Ur2HtiCRgUCN CUzKhHSDHLpOS8UzlvNROcGh7eLHYL3Tg6I8YPArjs/Y3ogMpuVe4L2w7lyD 33yVaHruY3p108Xx3yOUYJwy7k/quzt5/+f+Ls//GeKvtHZEbEDOo2f6kOe0 8h9VR69QSwcItPdo0gUBAACDAwAAUEsDBBQAAAgAAEiaj0cAAAAAAAAAAAAA AAAcAAAAQ29uZmlndXJhdGlvbnMyL3Byb2dyZXNzYmFyL1BLAwQUAAAIAABI mo9HAAAAAAAAAAAAAAAAGgAAAENvbmZpZ3VyYXRpb25zMi90b29scGFuZWwv UEsDBBQACAgIAEiaj0cAAAAAAAAAAAAAAAAnAAAAQ29uZmlndXJhdGlvbnMy L2FjY2VsZXJhdG9yL2N1cnJlbnQueG1sAwBQSwcIAAAAAAIAAAAAAAAAUEsD BBQAAAgAAEiaj0cAAAAAAAAAAAAAAAAYAAAAQ29uZmlndXJhdGlvbnMyL2Zs b2F0ZXIvUEsDBBQAAAgAAEiaj0cAAAAAAAAAAAAAAAAfAAAAQ29uZmlndXJh dGlvbnMyL2ltYWdlcy9CaXRtYXBzL1BLAwQUAAAIAABImo9HAAAAAAAAAAAA AAAAGAAAAENvbmZpZ3VyYXRpb25zMi90b29sYmFyL1BLAwQUAAAIAABImo9H AAAAAAAAAAAAAAAAGAAAAENvbmZpZ3VyYXRpb25zMi9tZW51YmFyL1BLAwQU AAAIAABImo9HAAAAAAAAAAAAAAAAGgAAAENvbmZpZ3VyYXRpb25zMi9zdGF0 dXNiYXIvUEsDBBQAAAgAAEiaj0cAAAAAAAAAAAAAAAAaAAAAQ29uZmlndXJh dGlvbnMyL3BvcHVwbWVudS9QSwMEFAAICAgASJqPRwAAAAAAAAAAAAAAABQA AABPYmplY3QgMS9jb250ZW50LnhtbO1dW2/jyLF+z68wHCyQPEjq+0XwOG/n 4WRmrznAeaUpSmaWEgWSHtv59akmRaqrh7LojdvyAFkDnhW/JuvS1V9VNVsz N3972hZXX7Oqzsvdp2s6J9dX2S4tV/lu8+n6//7xPzNz/bfbP92U63WeZstV mT5ss10zS8tdA39ewd27etmhn64fqt2yTOq8Xu6SbVYvm3RZ7rNdf9fSH71s ZXVX6ua5mHx7O9i/u8memqk3u7Ho3uRuuuR2sH/3qkoep97sxoJT/dvX5dSb n+piti7B69t90uSBFk9Fvvv90/V90+yXi8Xj4+P8kc/LarOg1tpFiw4Kp8O4 /UNVtKNW6SIrMiesXtA5XfRjt1mTTNXPjfVV2j1s77JqsmuSJvlmVuuvm8kR 8XVzwjXpfVJNjo12MJ5evpo+vXzl37tNmvsTc2IWXwBsf335fIyFajtVlhuL XJVW+X6ymd1o//6yLAdV3Q3dAm3VZYSIRffZG/344vDHKm+yyhuevjg8TYp0 8Hi5HXMajKMLGDHLvrowHQLfOaI+cQNbdPAwuF6dfPT/f/n8W3qfbZPj4Pz8 4Fm+q5tkd/RM5SbhpKVyUWX7smoGx6ynEybMFht0u2+2xenl7tB+6KZarUaH gjp8AUsfFt7sa549/hnx4cvxYBftILTEXryDkkU7yGfNcze4MYMECJAjxVeb IQuty4cdmACZ6+C+7GmfVbmDkqK9bYme4Md8Uf6BRx4yl/cEROd5VvR8MZg0 +piynG1rCB9YJuV+6d2Ns0O1fZr2OLc0ytU6fGJAE2ld82YsGv7x68JhM5cc gf4PkryigF3f9hVA8tCUwG15OmsZu7696bh+CQqlTp9N1iFXHaM7fT9d/0jp 9TCy++Pq8GmVpfk2KWb7IkkzWMwQ5wdkm+9aizZZNVvlm7wBlF4vhuc4dW9/ uFn4H4dPoTq3N50+3+qW3tPrw4V1ss2LZ3fJhWt/y6ZK9vdg8B5cm1VNntVX LjzhUVX5OzxgV+4yp9bCk/CSOPayuPaTL6zLS87xs31Z5007KU31kPXPqcqm DdlZstu4aoY4bTrIOcV/1rqEsID6rc7/BQMp3zeDMv3lGfBRsjsFujxbZE8H +BVW849jNX3J6lHwaDV9ndXizaxevCocr6AmOlwB5YsSarE/33H3c92NXudF 0Y8dLgxDM+V+JjuUvOTQUfDoUPI6h8o/5NB8lxYPq2x2n69W2W6WZkUBZLJO ihrMfyHSPKgz1b/cVFnSzLLtvnnun5hvdmU1DKjyzX3Thedqljw5duuncqq5 atzcw8U2f7f/O/N59kVXrPIaqPZ5ViR3WYENKspNArXb/TZPA+dUmcsGGdBw laWdgw5421BBi5HN7sAdvwf3ud5j5mnp/Fg+VGngyeQprz3fkxeD/XRkf8Bw 1R+G9ewLRo9ig832dSabjxGyUD3k2wdoJ8hcDtcg0Npr9Hjtv6H9B0Pbxg5t +/Fim5JXl4ovzulkuSdK1P9gUdXP27uymDXP+6FmmBbYEwP4MV+5HRAyJybd jtYj0PxLo8bKjyPCV8tsBTV85fqydk9S/vARFwM9UdR/1xO0XgtGRuvDI/Ld TNCJ/uM7n6AVZ2R8gnrku5mgE63Sdz1BUtsVTccm6IB8xIk40WJ91xOhM0IY HZuIA/IRJ+Ltm7/LT4ThabJej03EAfmIE3Gii/uuJ4JTAWXW2EQckI84EW/f W15+IpIsXZPRJH5APuJEnGj+vuuJEHd0rUap6YB8wIlgr29I0WZxXRb56u12 iyer/fpXLlNUHJC0/e9bjRYn32IdgLty9Tx8aHW6venCsP3danGIJKr6OLrP 3Ebvp2vrLrTnLZb3Vbb+dD2f95+7sK5zN819YKdFUtcHy5d1mjTtW/PDR2/x uBdUvRZN3jhnglAIFjnnlPZKPLvY5p1SY89w7/DaHa397X1S3/+zzHdXi6u7 oiy3V1/r+dU2qUH+zeIw5mbhCeyl1w93SAE1F1x6CtA50/KUAvyoACXky9XT FYXfVflYfyO0l9PLLbJNtltd+R+8PaS7soHZvO6V4nOtfaX0XNN2ZrpIONye Pe2TXfd+E+YzG1e5TYIdsC/KZpZUWTI6EErm7nCQew8wq5IdNFzJalVlboLr bVIU8/+ly+5/fnN13WFjs2W1lsxmMCndBmfdWnQ/2EPnnPuzzOaUDxTWx6KY c2HDeBRzweDawYSyLJdpWVbQBCYN9IPZBqzvhbC5DYRwrkMhbE40D4XwudQC Lg6ecjuew8btNjs4+am3uXPZvsq3SfU8exp3fO8hp3O7g9qtH7dsx5eCngtl Pf3VXHdOGnu6PkZinRVu1/dr3jxf/eWHv74c/rBEs01ZOTY6O9ts2U97R4xH 37zsp+dxPz2PW2LGvUHmQlLkDUVPrkt79MbqoWp3YK/+0h6nqrLVVVMemOGM bzZVvhrnLhLw3Tb5Z1md8EmdVV5FgJ9D++d8TYqHrJ6ddv7fe+f//bjU2qXV 3ROOpsPoF5m513EFmQO487UR4K34PXBvM7x+2GcQVitYXtJzSueIKW5hk93y udfo8xS3fKbD6GlueXPL+GTLvvSWfZli2Rc6jL6QZWKyZT/2lv04xbIf6TD6 QpbJyZb91Fv20xTLfqLD6AtZpiZb9nNv2c9TLPuZDqMvZJmebNkvvWW/TLHs FzqMvpBlZrJlv/aW/TrFsl/pMPpCltnJlv3Gvq07T1v227FKjWjZI0gYb1LI MVWuoTWpxkdR78lDYQ5VTJuS29+H9NzdUZRpUsy6U6to1Ow+S1ZZ5drGh+2u xlh30Ql63R2jF3t92sOJ/cDZ0Vn2OhQ0+rCDdNc0YQCuBGJhcvu67ptHd1hw ZTj36SLqUHBDw53vNscCURyLwLbp3kDDDiXmKqvT22+qKei9e+xm0Q9/I0XM WUW8+iWmIlSd1cSrN2JqwtlZTbz6IKYm6nyYePk86uyw84HiJeCYqjB5PlK8 jBlTFUnPh4qX4qJOEGHng8VLSlN1QZdachxj8VEencKsY6ZBvkqaa4S0282K SSG9JpuctddvHd/S+Sc0VNwSza0kylrJhadpCJ1nf6/zfifNBRdMa6q5UKHm HnQ+XXjN8XtoDropacnhB2mOofPpxWt+30NzyzgVyiqtlRQcaY6h8+nIa26j a07nhFBuNKeMWy393egAOZ+8vNY1vt6eoudzmdd6votHGfwIqSHPisCjPnI+ 8XmN5TvEsLWWUs20okoJiXgjgM7nSa9xfB/NFWMMwpUpq0WguQ+dz6peY/jH 0+pbpkrKhDV2PFW+MYlpa7lWGlIEE5QiEsNQPA2Y5NRapoB4DE5dGIqmgStL mADqYxqIG2mAoWgaGMM5M1QZCRkDa4ChWBpoypWiAhxOuKVoFgIojgaOKGGq paJacGMFplAfiSdfaFh0IItoPwxDJJ58zYmAUBecGo3l+0g8+QyY3mpiCLMs SGEe8qL8yLRotBSMvgMtasgcCqiPQ7MqrETLAUPxNCBKQAFMDGOQyLAGCIpG SlZaYakG5lE8rG8RFM8HzkhIQ0pCKsekhKFoGkgIe5htMNjAlCMNMBSRFijn SipXENiAFjwknnygHS0V1LAkEO8B0aQD8XNuFeRfoykSj5B41kPmo1C+wyQb bL0HXJASISlThmqWaEvBCK0lg2JEGBlUCBiKpYEhBDpqAiUpg6YE1aoBFM0H yjAJZRCXEspijXyAoYgagASoijXwnrCBBj4UTQMLVQCUREoR6LFwYsJQtDjg RAoBsSak22NBcYCheLRE2q4YGJgpiWnJR+LJh3JccWWoDEo1H4iYEohiFH5b aoNK1UcuSIucAjFq+Q60aKArUe2aVxJyEQpGDEXTQGpjjVJcu6k3SAMMRdOA ccsVUW7tG4P2YgIomgaUQkEqlbTGaIZnAUPxSEkC98B0A/1YKTEpISiaBsoK SinYayABYR9gKB4tMWugSVbGEIOLRYREky8ltOlQlkFRhsX7QDxatNAMEApz DcsO06KPXJIWNVQowrwDLbo3NpRTxz9Cc1QpBVA8YubUFegSmiNhMS1iKN6C lFCLMehRlA0a6ACKpoEhTECPooRWXGIfYCjeLFAtjLORE0KDWUBQtEjkLuAE VcYyJnEkYihitSbBSssECzYWfSAeKTIlwMvUGM7wqymEREwKhlmIcwFNmgmS godckBYF10Ix9R60KBzjKMiFxlKOqoQAiqcBrDbDNWGKBHVKAEXTgFrOmNCC cGgV8DtHDMXTAEpSzhQTsAIU9gGG4s2CADFCGikh/DEpYSiaBlJRSzWhktLg 9SlC4tGC26qAeLeayqCH9ZFo8pXbpoB1Dyk42NhESDz73UELSH1CURLsbPrI JWnRHQHg8ZtoMJkD70C8KfeiEecIhERbDBbqYiMYte64Az5L4CMR5UuitYA0 zEgo30OiyVfu/TI38ItRXCcGUDQNnImMuag3SqHmNYAiamA4h9zrjhtIEWjg QxHrRALEy4Q7O8aDQtFDIlaK0KBr6EqgJA76Zx+JaL9hxAholaUUgf0eckFK lArWYfwX0C4JaQK9ieJCoGM5IRJNvoDsz6A5gT6dYUZGSDz5xipNhXBnhnHT hJB4mzmSW1eCaXcWEm/m+EjEF4+MAOlp5l4oBW8ePSReRmZgoKVMuEMXOCP7 SLz4p/DDhdFESSwfIRHlS0g71ELqVyaQ7yHxuFBJoaAXBCE22DTwkQtyoWrf 9r4HGVLnb21s99t3BkaiTYZmShrLoApiwelehESTD7Ptdgeo1lzgXgkh8ewn 2n2NwB3/w1zoAzE3sFzC01JDOxJuYB2ReNa7Ez5uw5aFbzUQEi36ofQDD0tr CEdMhIB4RMisNlB/QwlsgkLER+IRIZSdnFsLSy14q4KQSxIhtOuCxz+DAzMO fKvcprGE5IuyAkbihaI2hBpYcVxQTMQIiSYfag8wUkomFcH2IySafMi9nAPZ ujf7SLwPxEsD7sQdFc5EgmsihMSzvj2KbznEGiYiH4g39673hESrCecMz72P xEtDCvoe7aTAHzgN+UjEitBAyweGgrODDUMfuSARauG+8Rb/ayuu7gOXc60E 1MI4FH0gmnRogAyxRrlDFagiwUg8+cQKWOkM1pukWL6PRJPvvsrGrFSQ9xnm QYTEk2+J67+h+DC4IMVIPP8rBjUnV0wyvDmCkYjyuXY7sspSfCYcIxGbY/ev N7pv46DlHiIR3x0pzjjEmKDB5hBCLkiFEP7uaPZ7UKGFJthI7QyWOBgQEks+ g/TrJhvqP07Rri1GotnvWmBpDEy5xbvGGImYDBTQDnevabQKkoGHxOsJtFRQ fTIBxZ/EPYGPRPQ/FP7Qd0DGDd1/BOJFv3FfxNFcMh50RAiJR4WSQOXFgPbC 7tgDYr4xguZXQJSx8MClj1ySCLVw38p4ByIEa407cg05gOFIxEg0+cC1XDMj 3bcUUYOAkYjygWsh+1tNiQjke0g0+URq5ajeHR7C8hESjwq4ggbICIIPNoVI vETIwLuGOb61BidCH4kmnwHVQvEPtbdV2P8IiUdGXLffutFMht/V85F48sFM qL6tcNvSwUFDD7kgGVoOLPQOf69D+9ePC0oMFD6QgikmQx+JJl9qw9xf36Al w++vMRJNvkt/hrn9UELRbhFG4i1GqH0ZaTfkOF6LHhAvFQgLTaiV7jUx9j5C 4nlfcgW9hyt+cIOIkWjy3f4LEcxC/2FQKsBIPCqiSrqqgxIVvDBESEQqhoyj GXdfcAhemvjIK6kwvFLjS7f930R6+Oci+n9jIvjY/csS/af+35ufpeWugT9v /w1QSwcIFY+BFvkQAACJhQAAUEsDBBQACAgIAEiaj0cAAAAAAAAAAAAAAAAT AAAAT2JqZWN0IDEvc3R5bGVzLnhtbJ2V23LjIAyG7/cpMu61QxxvZxomh7s+ QKf7ABRjhylGHsCHvn0Bxy7uJinTS1vfLwlJiP1pqMWqY0pzkIckW2+SFZMU Ci6rQ/Lv9Tl9Sk7HP3soS04ZLoC2NZMm1eZDML2yYqnxaDwkrZIYiOYaS1Iz jQ3F0DA5iXBIYx9q/OOdxco9HKoNG0ys2LELLXmLj+zhUF0o0seKHWtrGspL iBUPWqQlpBTqhhj+LYtBcPl+SM7GNBihvu/Xfb4GVaFst9shb50TpjPXtEp4 qqCICeaCaZStMzSxsq3fmIo+HjHkv87ororualfdOB49ExXdXw8vW5QX8S3K i0X6VPEmOvRIh3oAmMvtBOPg+6JvN5u/aPwO6P4u3itumApwehenRNC5ClBf GxDLZcgSKetc+ydauUPf9PyIFGtAmTmRMv7i2+ps57E9m1rcHltnndBKFcVV 1KaTIzvCdvjSjrP+YXGv79d/hzy0GLO7imyDPBTe/p8Ejpkj2IZ8rSpVzcu0 hFbaI9gFfCkfGxqmuDMR4WV44SGcMQG/cHnZwIGHxYXTOjfXqv36gpwtdUvU romLl+Dt2CbH6aEY3wd03KPrL8fxE1BLBwjlqOG4wgEAAHkGAABQSwMEFAAI CAgASJqPRwAAAAAAAAAAAAAAABEAAABPYmplY3QgMS9tZXRhLnhtbI2SPW+D MBCG9/4K5GbFx5fSYAGROnSK1KWVukXUvhC3YCNjQn5+gykRraKqo33P+X3s c7Y9N7V3QtNJrXIS0oB4qLgWUlU5eX158jdkW9xl+nCQHJnQvG9QWb9BW3qX VtWxqZST3iimy052TJUNdsxypltUcwtb0swFTTvnWqrPnBytbRnAMAx0iKk2 FYRpmoKrzqjgV67tTe0owQFrHBM6CGkIMzsa/ldqZJdKWutr0IhP0i4uCoIE pvVMV0aI+tYFLmwMF8PSlv5J4nA/d/BjaeyfIWEADiLe94MtRhSRYp7HKF5k Tr9Chaa02hQ7+W7w2QGQ0Jg+0Gi1k6o/79826/068RbAvjX6A7mFJA5Wj72s hR9l8OvADH7Ewa3PUHwBUEsHCFRuHHciAQAASgIAAFBLAwQUAAAIAABImo9H ER5nXlltAABZbQAAGAAAAFRodW1ibmFpbHMvdGh1bWJuYWlsLnBuZ4lQTkcN ChoKAAAADUlIRFIAAADfAAAA/wgCAAAA/jeUTQAAbSBJREFUeJztfQV4Fcf3 9l4+NAkEggd3CRDcPbikuLsUGtyCQ4FS3KUUd7fiELRAcAluwd0hRkj/ud/b Pd3pZGXutj+abEPneQh7Z2dnzpxz5j1nPO7//d//SZIUJ04cSQ6RkZHsmY/R xuu+0k1G8VQKPVCglOwTozSsFNVb7bM2H11iVKTqPvApeRp0mWNUUxXxfK35 xLrVUWWuS5s2mSpbI2oFItOSzX+izdkoXpcSrYwkg0AJ4tpsNj5W9ZPFaON1 X+km4+ON8hekUZViVJzDfMyXa54JDqsj4J42XvDTDAMFMYJMBNzWJvtL6mGU uSC9KmVccSK73S7JioyH//f//h/+Osz3iwcqFH9BRty4cRkNRBv9pQT0QM0u +qml4sgWoXSQEf28+nuBsQ7E2+TAs47xX9Jwm/7yyb4sYXFJ6sRNgmgqm6kj 6YSksXcIVBn2OaWnSB7tqdp4q6oPzxrdB/Y5YuLI4bfffiMWUOZ4ZtkypaQY pER6okdSlJVqRwZFUK4RkQLiGZ3EKyqRpdGyhSmBUW6SRvZi2sQx2kx02UI0 4xWTHeMqs8JICd6imqQwpJTEbfqWt9dGNTKiUJXyd8tOgESUMZ4yUlDYrl27 4sWLV7VqVSlqEyFJ0CdEEy97PitdD8OkoSHNvnXr1q+//tqpUyfKnCnB58+f 8Td+/PgsZuPGjenSpStVqhRPJE+bgACHDozAjBKdx44dO3z4cLVq1d6/f4+i S5Ys6eTkxIqmNkzpVWDj0I6bcYqMEmjrwmsbE9lPP/1UvXr1rFmzMjVl3Pv0 6RMinz59+vjx4zJlypCCHjp0qHDhwnhwdnbma6fFUZM1UoW4kO6pU6fKly+/ b9++YsWKhYSEfPz48e7du69evWratOnFixc/fPiwdOnS+vXrBwYGvn79ukSJ EtTUEI4ePYq3qEPOnDlPnjzZrFkz1AHKkSVLlipVqkBIQUFBqHmmTJnOnj3b qFEjFxeXv4H/1IxAz5YtW8AFZA46QS04BSWYO3fus2fPlixZArW4evVq48aN r127BmJAbY0aNZInT75u3TqwskWLFm/fvt25cyd0pW7dugkSJPiylogw5s2b N/379/fw8AgLCwMZ169fnzZtmq+vb5EiRVavXp06dWoU7e/v/+LFi4IFC6Ii KqSJhkDMjIiIAAPBN9CTNGnSVatWubm5QcR79uwpV64cuAe54xUaOYR4+/Zt PI8bNw517NGjB3TgxIkTaPyXL19GHQMCAqCj3377baFChdzd3YEg0Ne/J2ht iAtlB+Py5MkzduzYAQMGgAI8QJaJEyceNWoUKIMG5M+fH6qwdu1aaBiJgVrV sGHDAGbbt28vUKAAqJk4cSLEA53YsGEDxAO9adOmDTKvVKkSdGvOnDkDBw5k Jl5Smo7Kj1TZO2oGeEiUKBEyT5ky5ejRo2fOnAnCQMDIkSOTJUuWPXv206dP r1y50svLa8WKFdBg4Baa+MKFC11dXdHYIAB8BX0FB5E5lCNjxoy8wHQp4Wlg vpeK4yyGPBwQCZ0DAXv37s2bNy94iMgMGTL06dOnZs2akDQa/7Zt23Lnzl2h QgWy9aws1bMUFYF0adMmY4n5BHw8CoUZXLZs2Y4dO9q3bw82Ak2ATVA4QAkE DQW9f/9+vXr1Bg8ejL8HDx6EvkJ9kRUw9dGjR6AfyofageF4BhyAmRA3fvbs 2XPBggVgO/NejGrEZG2kl39YdgTA4fr166F5kCh5eEBBNHT8xVvE+/n5devW bdGiRbly5QIOQb2o4FSpUiENFBdIgHY2ZswYqAWegVhoYWnTpm3evDmaF9oZ GitwizwwnuN8HXR5zRw+oDIwCZAM1UfjDg0NhezBFMB20aJFz507h1o0adIE idFmoKYAbMjg5s2b2bJlQ+lI2aVLl82bN8MHSJEihVGPSpdrvGrqKi57ADCD D5AWyINRAiCh5YCTFy5cAN6jqQC/0ZxAJ16RdmoVXUuYEW267ZlPo42nHkKt WrXu3bsHpkF858+fz5cvX5IkSd69ewfmwJCiFlBQ0AkNRkooAL4FEHh6euIV agfV3LRpEz6Bs4eKQFmRpm/fvlu3bgWWwS6RkpiRtZF2/tFnRwpAMcASzuX8 +fNBIjwPSBHtG5ADuAKjURNA+pEjRwCxJGxyK6GLaHBQRKR5/vw5SAfFSACt hR7DpAIqkAP+IhnUS9cXcYidlAAB5gbahtzAQfARjEOjgjbAxIBfv/zyC5r+ pUuX8BUIA8ugHyAjYcKEqCDQHZ8Ay3v37g3Fhakiz0n6QtjJ1B31RdFgEVgB tgBsQAx0NH369BnkQAjK0vMOWTRgJ0WCM+AerPCUKVOAJmg/4Ans8qxZs3Lk yBEcHIwGDyFCGeAvQR3BYXwLoIECQNC9evUqXbo0TCvgDHWBUJAhcoD+QGsJ 4FTU/k3sxD8QBO1E7kAmlA3/A6bz+PHjI0aM2L9/PyAKbhOUAOKEcYTWsiyA 6rBlMFKZM2eGvcCHaIXQGLRO1BntCZEEY1BN+uRvuFlUByBx69at0YQaNmwI VwEUgphWrVpBCdB4YH1evnwJHwO+MjQA4I02Dee9du3aYBnMEwwrOAjPtW3b tpUrVyYO/lVKxESSSNC2gTrARegoWgvaKjyzCRMmwMMBAUB6b29vCN6mhC9I g/mAhgpnEbKDhoEGog06ABMPacJNAmrCjgNZIUoYPQgazET7B7fBPcAWrCJi 8BV0Y82aNXCfYLsADai7Fjj/dohL9mjo0KF4gNQpFo48PQBs8Bccp5/QObgg gARJ9gngC+OhTp069BZAhb+DBg2in9S/hjLRT4hK0owJmAmkRmgAgD0WiZaj SgbdpQc4APQAFxB/4fOxNKwj/08Eqhokykei2dADfG6eKkmul8OBlS8eiJnA muHDh7NIJm5oJP4C5hs0aEAx8E1ZMgImuChQWfq8ZcuW+AsVf/LkCdxNGHc2 yvtFGl5ccufZmCU9sOlNldXDW5hImC16C2cOdpN1PPnRLN0BVBq6YmX/JcuO fKgggj16ZpkjZ55meqAeGBthlpShR9Woxxex7OyZjchKSleJSKJAjCKUpRhV KbqcMaLt71l2iRseZuwi2vgExDRVMiZcAkh6ixh0BIEX8AG0+YhlLRmEPyw7 /UcCsylDX3y3muVok0dGCQL5XHQTS0oz5cfVVFLX1kHSaAbffWG9MfbMV4/5 OnyMFBWtBdLSLV1LgzaBing27kusYFTxKmsmH0GkOJlRnqqgyxZVO+Q9SNVb fpAbIakcCA50GWWyRqrgYCZTFVTNXdJo5JcNfLa6HVhJT+ljNuh2rmNxYJaN Ka42jZYVJqX25zwKX5i2eB5B2StmWAWfs3gtTWLLrmq7VH/ehWB2RxeWHDab f8iyswFdfqJPW2ueLXwpupwxou1vWHZBzvxPnmz+E23OWvVgMSQvJjgWY1cm z1U5aMuKq6qzVqlVtIpfiVuPlhGSBmy0uoWOIfr+ZCXxDO+CdBSddHR+WZ35 b7Xc1CVJtz1IBkLVzVBbd/LJiFpdnRZoKi9y3cy1n+jyXJWPoMraz7VNUbe1 qz7XVVaE58+fp0mThmRkk0dbX7x4kTp1ajwEBQW9f/8+fvz4+IkHOAaS3KTB PUQS8MVV1dkhdopffRHslBQXAgKuUaNGkyZN0HMEJi1fvnzt2rV79uwJDQ2d MmUKqpE8efIePXrYlRCz2EkdtdOnT/fq1Wvp0qU5c+YU1JpnC1+KLmeMaLMU dvK1IHScMWPGx48fgSy+vr5kVUaOHEm92549ew4aNKhChQpJkiRxc3PbunVr zZo1vb29p06dClknS5aMcrbo+k6aKd24cSMUkcZKIyIismTJQpjk5+f39OnT 1q1bszZqlI8uMYJyxUQKiJcUT8PFxQWI/uHDB5vSYTfDFoc/zTBQECPIRLdQ I8ma4QxZ7ZMnT549e7Z3797ASCgoJBUWFlaoUKGmTZu2atVq3759EGixYsU8 PDxmzZrVr18/gM7OnTvBOjCQjcb8Zb9T/OqLYCe5bsePH3/37l3nzp1hCxCZ IEGCsmXLQmUBmffu3YNZv3bt2tGjR/Ply5c4cWJeTWMEOwnpwfG8efMCDEAk c8pV45qxHjupTT5+/BiCg4z27t0LM+Lu7u7s7AzVXL9+PaCxfv36Dx48gJ0B vgJB586diwQXLlxAPkOHDh08eDB4+Dt2qiSh+slitPG6r3ST8fFG+fMPVD1/ f3/YhUuXLkHknTp1gl9CSzyhoHgGjiJyw4YNqGSBAgVosNNhWeJyHRIpIF4l IVdXVzYoS5ZOTIPDn2YYKIgRZKJbqJFkzXCGYAImGw5lu3btDhw4cPny5QwZ MkCsW7ZsgUABlsCdbt26pU2b9tChQzly5KhSpcq6devQsMnjDAgIqFy58u8L i81Y5y9i3LWvjAwNDdr3798fejlnzhzIGFV9/fr1ypUrnz17hphvvvnm3Llz cGKgl7ly5dI1oAKaBQQ4rKMRc+zK6Obq1avv3LmzYsUK+E/gO985FfPHoR03 4xQJ8jSfsxlPSfBMo/Tly5eHsYaMUqRIAT5AIzt06DBp0qSWLVvOmzcPUluy ZAniYcpLlChx+PDhPHnyQEeHDx8OHvbp0yeKZbdUYMYCLalLly5kHGEXqlat 2qBBAwAqrMC0adOgBDS3xmxoTBP++xB30aJF0XsLDw8H31X73b6SQMqaMGFC dHGuX79O89sNGzZMlCgRABLig6QQWapUqbt37wIv8RZMQwcXD7Dp4FjKlCkt 3WenABKdnJzoFerGJtDt8sANVJNfR6jNJzr9TvYhfCzdIlS15tnCl6LLGXFW VvM7+RggIj0AUPAX9p0VhK4SVJPeQjXZA5+nRfvsfFXt3KAuryIqLTRppk2W 67CmqpSMBvKAKZ71PU1aXsFPMwwUxAgyEZh1M56SbjyTlGoNq3YnIDFHBV42 uWtlUctOQev98DWRolYmxi07o5OfZ5eMFSUWB15k/CoLiVsLoWKO0YNFtZNR T/MubOugpOgie46RdWjawGgAWtijLr/9ShSU5wBVn5a8MfExwyJxR0tQSrZh lTJh02xxVVlLGq+LxegqgdHQg7gCqp+6n1P1+OXrbH+gnduTyUynauBGQLOA AId1NGIO00UVYSqqBCTpMsGMXEzmaT5nVU0dfqJysfg906olB+yVFHUdOpMy m5H+AzuZtlI6o8NYtPG6r3STSX/9pBqbsk1+/fr1cKVpZ9L27dvRT69fv37W rFk3bNjw+PFjemaV1+YjPgtFSwCfA0+nERNYDPOPjx49euLEiRIlSlSoUIG1 HG2tebbwpehyxog2bTJVtkbUCkTG1zSSO0+Gj5E0CsPiw8PDly5dWqVKlSxZ suzatevatWvVqlUrWLAg7ZPZsmXLgwcPwJAOHTpcvXr1+PHjNWvWRN9o9uzZ +fLlq1ix4pUrV4CjBQoU+MPvtGaviFTz1q1bPXr0GDhwYMmSJU+fPn358mVv b29fX9/u3btfuHABz3jYuXOn1kMVEyMo968yQdUrev78+ZIlS3x8fIYNG5Ym TRqaav9KekWkppDLrFmzsmXLhmegybffftuvX7/NmzfTfN7y5cu7du0Kdbx3 7960adN69eo1adKk8uXL4+3JkyfBrm3btvXp04f1Maw4okQxoaGhhw4dgi6C dPwsWrQoAGnBggU5cuQoV66cl5cXICpt2rSsf2eUj66cVOXqUsLTacQEFkPc dHNzW7x48adPn5ycnEC2qvp8rXXjVeM1uowVMFCbrRG1ApHxNVU5LVoK+fg4 8kktxYsXB2oEBQXB4v3888/3799Pnjx5vHjxIpVTho4dOwZARWIPD4/SpUvD Bl68eJEUFM8JEyaEBrdq1QoM/N0T0LIpxv1O2nM9c+ZMPKCeqAzIpVnsZMmS 4SfY4e/vD5RC+2PgFON+JwQQP358wOfQoUOBne7u7mwmU8AE3fh/o98pKY4j reBBgK2bOnXqlClT2KD13LlzU6dODa2FcGEVEfnx48fmzZs/fPgQLgF4CAYm SJAACIrI3/MxY52/iHHXvjIyNCTR6tWrv3jxYsWKFQSN8OdAdP/+/ZctWwb3 Zc2aNd9//z3qRktatAZUQLOAAId1NGIOOV7v37/v1KlTx44dIYOQkBBnZ2et U2jGypsxwQ7JNv+JwLib+YQH1ydPnsBqZ8yYESACGw0Zofpv3ry5ffs2wBJK 2aJFCyRo3LgxdBfWD68KFy4MH33ixIlt27ZdvXp1kiRJWM5WtOykbYUKFZLk jcJoQwB8gD9qsnLlyh9++AEJYNyhr4kSJUKVVEXHiGWX5I7C58+fYa1evny5 bt06iIEwQ5VhbLXsktz1hsJBcABC2OtatWpdunQJHR0ATWBgIBwz9JD27t2L h0aNGv3666+w8pAm3CGkQfcoffr04N65c+fgrRIMW7FXZFfGxgA8np6eFAPM b9q0KfuKdFfiOstmyhKX65BIAfHUolKlSjVkyBD2lvdKxTQ4/GmGgYIYQSYC 4DRji1TxdHCINtA+6cpykGRTU14OkswldNjpoawcJGU8zop+J6swHcNnV2Yy I7kjF9mcGNt9q0tGtPmd7Bk9A0mxADa9GazY6nfSX5KXpJgCu7J0i7mkktKD JEaxcXuKp7kMtvnWouOdrNpxuE3rtL4zkjtRku2n5smIkfFOFthWWn4k4esZ 71QtF1TFkwTZV6p5Tv5z+tCK2MmeeVCkZ35RkmqBkm4+0YydLIb3xoxqLcjn 34idRlkRUrI8eehhEtQlXrLsPLukqB2zj5HKMl4y8ez4U8mRfxltgclANX0X 03RFX2AikxS9pJXITEd1zyni59tUPTAr7ivis0XvLyIiwsXFBRULDQ19+vRp 9uzZkSwkJOTZs2d4JqCKE/VQHT4fI1baNR1YVQ4qpjvsszMZ3Lx5E4SxpQ+6 tebZwpeiyxkj2rTJVNkaUSsQGV9Txkk+XpWzKj0EQdvcEiZMiJ9gBa0Qt8se +Z07d+zyUt0UKVJAgq9fv0aybNmyQaxJkyZ1cnIC3AQHBydJkoQKsuh+drsS KlSo0LZt265du964cWP69Olp0qRJkCCBt7f3hAkTMmXKhLrR+WQOualLkpYA PgeBwLSZULKwsDDQkzx58gcPHowfP552vkpCjVSVossZI9p027wUVXXEVdZ+ rm2Kuq1d9blNmcm8evVq69atp06dWrp06V69ekHzfvrpJwgLkvr06dOBAweQ 5tSpU4ULFz5//jz679BUaPPChQvTpUs3aNCgBQsWoM9Oq5Jt1tyTKSlnK69a tQqNTFK6wL1798ZPHx8faOeIESNQ80qVKg0ZMkQ1Gh8j2GlXpvIaNGhQrlw5 /H316hXUNFKzqyQWYycq6+rqWqhQIeCfXT5junPnzlBNGhx0dnbu1q3b58+f YfS8vLy2b9+eOXNmT09PPLRp0wZqvXPnTjRvMI15RFbsFdGc7N69ewH+jRo1 QmUQkytXLrxq1aoV6pMvXz7EoOY9evSwcdvGtWQIiNElwGEdjZhDEoJJgmoO Hz4ckgAYsCEFARN0440445B+QZ7mc1bV1OEnjANonOnTp4fFgDMGLYSho+N/ EW+XJ6jh7UyePBkS9PDwqFat2qNHj2bNmgUhrlixAsnwE4Zx7Nix7dq1K1Kk yO9qoLIXVsBOstS3bt16+/btmTNnUFW0ucDAwDdv3gBNa9aseeHChS1btjRr 1qxq1aqkmjZuBDSmsBMPwEs/P78xY8b0798fpMIhYUetqmrNs4UvRZczRrRZ DTspBlqYNm1aGG4g6Ny5c5s0aeLv7w+pSfL6OsRDHR8/flyvXr0cOXJAjkCi cePGwabD3N+/f79GjRrHjh0rWrRopDV3DJM4aZUAiIaAgUm0euXXX3+FQwNf +/Lly2ht8+bN69ixI7tiS0uGgBhdAhzW0Yg51DOFXw9JgDwIBsZLS5WAJF0e mpGLyTzN56yqqcNPmPpCcOvWrQOsoGXWr18/ZcqUcMCyZs0KH2zixIm+vr7o /cBwJ06cGP2h0aNHo+eQM2dOwCSgBw4o0HTmzJmQaffu3clTsuJpC3ZlJhN/ AfIEpXny5IF2os3BdkBfq1SpAg2IHz8+f5SZw7IclismUkA8uUow6LNnzwaR AA9qY3G+ptMWUFn0BCAaOjYfnR4Ya9qHSVPnUEfoHx6yZMkCaUJZATGSfLA1 9YSglx8+fIBvQCbRitjJqoqHePHiUeVpNRpUk9yXFHKgV3buTFczNAsI+NvY yQwc2AoiJeVyra9njZIkMyFVqlQsHj/pCBBJPn6WwJUMHUmTXHN8zpbLIJJU 08aPd1oqqORtV+YwVY4p7xiJYTJ6ArPjkcrFfmLHN5YFlWNKgZ8ZsuntVSSO qeTImGbFPjs98E2WJ1rQ6M1YIjEBDusoNqO66ujQdzIi3ihSnExc1l817mY+ UakUH7T9LW16o1rYrDneybhj4y4Mpm6HXVnzQgkilatjrTBXJHFyZXRqEUWb ni9FlzNGtGmTqbI1olYgMr6mvBqpKqL6nLdmzHTQgiObslzLpuwhjsNd6sAW hdi4K27ZGhorWnaJU02+06NawMKWLFnEejKadRc6xe7AVJOtPLJz+4O1b/kL KSVlZYLdaMcwX4y2YN143VcOTYwZW8Or5pkzZ9D7y5kzJ57v3r3r7+9fpkwZ dPGQAD9fvHhRsmRJ1XoLh/ZOUO5fZYIu+IWEhBw/frxq1aoED2bY4vCnGQYK YgSZCMy6NplRWUz5IJEDBw6gA16wYMHdu3e/efPG2dm5bt26tGTz48ePu3bt ypMnj6en5/v370+dOuXl5QUl3rZtW/bs2fEVevGhoaHZsmWjbK24Np4hEKr6 zTffDBgwANp5586dKVOmQOTbt2/v3r17RERE+/bt06ZNy7RT3Mc0Q5JDIgXE S8rAAng9efLkxYsXo/Fo1y8KPhf/NMNAQYwgE91CjSRrVBYpExQLwqpdu/aE CRPatWu3cOFCX19fuhybmNOnTx+o49SpU3v37n3hwoVx48bdvHkT2nzlypWA gAB04ZcvX06XsEm832nNsHXr1jZt2iRKlAiEHjp0CJiEBpcpUyZIfdOmTdWr Vw8KCmJcEyPlPx1symniJ06ccHV1paF4yVELiU3BJu9lmDZtWvLkyYGawcHB YWFhUEHoXL58+cCNhw8fvn79ukWLFh8+fECC/v37//LLL/gKkQUKFHj+/Pn6 9esTJkx4+vTpatWqUXfCimvj6dyIOXPmhIeHJ0uWjM6HoKveK1eujPb36tWr 69evAzVXr16NqqJ1qlxsKdrXxpP7C8IgHh8fn507dz548AAWSrV0XIqla+Ml GR3jxYsH1QReli1btmHDhhkzZkyZMmXPnj1TpEhRqlSpT58+JUiQQJLPRoyU d1dDrNDgmjVrwtqgScMeIsGlS5cQD2fgzx3DLFjEsqOqcESePXsG+IyUb2mA pwK64YOCF6gJmiNQCs2RrhPmO54xZdnJu6hSpQpaTmBg4OPHj5n/9DVYduqt w7JDcDDrV69evXz5cqNGjQCHQJl79+6lT58eunj//n0AKtk9yA7tGcZw9OjR cAa8vb337dtXqFAhsI7ytOIqkDjKfnZJnuOiC2wqVaoElxmNrHXr1vXq1cMr qCYsAurG7mxU5WNEjIpU3QeVAIyYwGKIZoAE3WwLeVSoUEFSMCbWjyhRTeF6 ff78GRA4fvx4OhEED82aNcufP/+KFSvgaw4dOnT+/PnFixeH5zNz5kx0g5Yt W9ajRw/AENAHP2/dunXkyJF+/frREI0VR+OpwrTsqmLFiowF7BZhWi8Iw4E2 anQ3o7izbESAwzqKO8h2eQU4SIUkdA8CEZDksIcuyMrkmIDJnFU1dfgJU1y4 WPDHWDywgz2DIUhQUg70yeDBg9lb+G9QTci0nhwktmPYjHX+IsZd+0psaNi6 OLtyYzG7VziOfPOGXVkyaLfAPDsFu3KPMn+xsUPfScAEM3Ixmaf5nFVkO/zE xh1lxSyYTZlJsStzJdSjUL1lXLIrS38kbhe4FS27rh20KVMO/OAR787r5hNt ll0VGGqqDKKk0WZVKbqcMaLNUpadVVzFBGb3ednZ9VY82pRZQKa7VtxXpBWD 2ECreKfLTV2StASo2qoqcyPmqBKrnnVrzbOFL4VPo8tYAQO12RpRKxCZtinq tnbV52Is0G1XDr0Om2Xn2VXaZlNMvGp0hpXukJu6JH1x7FRBgk2xYrEeO9lf u+KGqVpCHOVqYXa+Cz8vzTvoPJ8tOhrP6sZm0gnzg4ODXVxcWPUcYmp0BoaU 7969s8mXnX1Vi+jsyoIPkpGkaDDzPm3ycD068nSyKbr2eIYQaaST7tJEGjyz zQ5W1E4SM7Wzxo0b161bt02bNp8+fUJ/8O3bt+nSpevatStqNWLEiJCQkMmT J8PXpkXKMUszIUTPnj3d3d2dnJxAM7qilmo//2ggDsyePfvJkyeQyMiRI8+e PTthwoRNmzYRoKDHg5/v379PlChR9+7dfX19ixQpgleVKlWaOnVqzpw5wbo1 a9bkyJGjcOHCxDcr9opsyqzgtm3b7t+/j/rg1b59+27dutWpUyeaNDp37tzJ kyfp5AXGmhi07HalT3rz5s1mzZp5eHjQanAjc8yzhS9FlzNGtFnKsseRD4h0 c3Pr1atX27Ztjx8/niZNGgAhoBRgSaOhiBk+fHjLli23b98eFhbm5eWVN2/e VatWIeby5ctHjx6FZterV+/PHcOqCmjFyZwnSRO0r8R+sSB//oFWJ50/f/7l y5doT3THMK1IOn369NWrVzNlynTw4MEhQ4agXQpoEJtUbTKHRIqJJ2cDeAAi p02bBvCgnc20PEdMg8OfZhgoiBFkoluoEVcFnLHLp1i2bt0a8PnmzZuSJUtC U2E96LplvIWOdu7cec+ePXioXbs25AjEAaNatWq1fv36tGnTHj58GDZwwIAB EDpdMWrFFXTkJu/duxfN7saNG2hzPXr0gBuXJUuWbt26AZmWLl0K3w7tzN/f //bt23TthpmyxOU6JFJAvCRLKDQ0FDYLvgcAfv/+/fnz5xefpiRmvi5jxTQY xQgy0S3USLICzqD68L7QMsEBgOj8+fMHDRqEeDo9gdL4+fkBVn766SfIFI4Z 1LdJkyYwkoBb2EnIF3ayWrVqYB0MvaV3DPfr1w+1RUOkFQO1atU6ceLE+PHj UduBAwciJeoJHc2cObPdAqPxBA+QCkTi6ekZGBgIE2bnrtVyyB+HSGnG7Ajy NJ+zqqYOP+F9mxUrVly8eBHuTfXq1VeuXHnv3r2FCxdWrFgRWtu8eXPwpF27 dkiTPn36JUuWgFHoEuEv5AjW1a9fHw7o8uXLobJ2y+4YJjMBkIdS0tZmxMBl mT59+vXr11EZ6gPVqFED5oMWvNi4MzJjBDsJIOFrAjMuXboEEwa+27+yHcMJ EiSALqIz1KBBgwwZMuABPiW5m1WqVMFbaCTsIToVBQsWLFSoEOweUBMShGr6 +PgARLt06fL06dM8efJYd8dwJHdLGp1xT8/Ozs5Fixa1K+c+QndTpUoVyR3i GoPYyToH6JCWKFFC+ip3DFNlISNJZgg98AFqx54TJkxYvHhxSsk2f7vKgWm8 FUeUVF0Ne9SFmxKnEMyrE/h20RZIQdmswVc12Clx7dOu9PQjuVO6JQ53+K8I U1gy+pxFWtGy8w9MEVUVUFWMt54xYtn5nyo0FVASyyy7yoLpmjLGHIljFJ8V H2lFy84TypZnk/7x80b8jJERGdFp2RnBRvucBEXoEm8UKU4mLuufs+ysNap2 DEvylktKw98xzEyfTXDHsGWx08btGGaVpARsk7ukd5VvTGGnTRnyZDSrgF9A g8Of1sdOW9Q9wZJyczCfjI/hX+neMWy3pt8pcaq5d+9edH3QxQPdAQEBx44d K1euXP78+ZHg4sWLz58/r169unj/UHQSTPtIN2/enC1bNi8vLzP4HWsC6dbd u3f37Nnj6emZI0eOX375hZZJ0E1ZdnnCDwmQuHXr1niANGvUqJElS5alS5fm zZsXnaQ7d+6Eh4fTSmSbZVcfk2o+ePCgTZs2AwcOhHZevXp17ty5DRo08Pf3 h3aGhIT4+PhkypSJaSfv8YhpFhDwty07wXlYWNiIESNA5LVr18Br6n5+PZYd ijVt2rQWLVpMnTq1bdu2RYoUiYiIGDduHG3tR5qff/65ffv2OXPmvH///tix Y/GMv2jGoaGhfn5+UNMNGzZ0797dpgQrYidJ9PPnz2iFPXv2dHJyssn3ZAYH B6NtJUuWDD83btwILjx58oSxUmzHo4FmOg+C9rtJ8ohJDNIT/cEmT6NMnjz5 1q1b8eLFy507d/bs2detW9ewYcPMmTNDcePHj4+/586de/bsGRzNXLlyAVl2 7959/Pjx2rVrA19ox/D27dvRvBMkSGC38h3Ds2bN+u2336CjqA8eAEtQ01at WqHBvXr1CnpQuHDhS5cuvX79mj9TzwzNAgIc1lHs5IH7nz59aty4MfB+9erV HTp0IH9fwATdeDMOokOyzX8icD3NfMKeUVNoFXybpEmTQgXh3mzbtm3evHmS PFCPv5Cpm5vbkiVLFixYANMnyQc01K9fH00arLPLM/Xv37/fsWNHo0aNfl8J xHpJVIAV9rNTl61UqVKoIRof9YJhKKGm0EWwAM2OpiLwE7ViPIrB/ezUNgAS yZMnhzdsk9d3qkYe+FrzbOFL0eWMEW3W2c9O6ICW2atXrzFjxhw5cgTSSZw4 MdAUfz98+AAnDYZ75cqV8DghNdh62lIMXhUtWhQgSrs34bKnS5cObhtlbsU1 SqSdpUuXxjO0EG0ITapMmTJv375dtWoV/JJKlSrhFRLAs0FlVLsfHXpjRskc EikmHgQAGEaNGrV27VrQBotmV1aAm/QLBT/NMFAQI8hE4HSa8eNZPBQUxg3K B1xMkSLFd999d+XKFUAg4qFtJ0+ezC+HFStWAFNhAOG2bdmyZdiwYSlTpoQN rFChQtasWdGdOnPmTI8ePQhrrOt30rZgNtmFUFcO+EmbidOkSQMNMNqYG82B vHiQUVAOkoLlMU5YtAWqbAU5UExhOUCI7u7utM2f3xBcQw6SzCjaW4zIqnKQ VHcMWyqw5sjvQbEr1/dK3GbiyKjnd8Ygzax0alSqzYcxSFi0BYYpbHDarhyw ymZ3yQu3Kyu1JVnKbKrFZnTHMOOglpt2brG0LkH8KyNhsFJUw9f8J9o09qjb 3Mgl5XdJS1F9dm0+As3g0+tSwtNpxAS7ZpqKuq7MFdP2pfgcVPEq50SXsQIG arM1olYgMr6mvG7wMZJGYVg1+VM5eYLFdwyzxOo7hlV11g7NqGgVvzIa2dHl o0oddXWFVdsWdYZd9blDbuqSpCVA1VZVAjBijjZzXil1a82zhS9FlzNGtOm2 eSmq6oirrP1c2xR1W7vqc5bSSPo8iOiyQvcrK1p2KerMmEov+ZVKcSxz9jET Eg+iX49Z54Odc7TImkuKX84zh6VngwZaaLeidqraLg3kUgWePn0KF5uBJR26 ZwUlIGFEREQ8e/bMLi9FTZw4Mci2Am3RE1hNISmIjAY4nzx5ki5dOrviU0J8 eE6YMKGrqyvSvH37FiyCQOkgQTLroaGhiRIlIn5a97QFiq9SpUqzZs06duwY HBw8derUSPme0F69etHeXHjWc+bMoQ2ckp7Fjza/kyA8KCho3bp1EMyJEyda tWpVu3Ztok1gzVWl6HLGiDbr+J1sewIdpo4e+i+//DJjxgwoIuJHjhwJJoSF hW3cuBGfXL58uUiRIhcvXixWrJiTkxP69bNnz86SJcuAAQMWL16Mn+jC2y27 n92m7Bhev349HgCQiNy7dy8aYps2baCRUM1jx449fPgwY8aMMU3sH4Gg3c3N DSwOCQkBbeXLl7fC8pRoC2TQP378uGHDhpQpU7548aJhw4YlS5asUaMGGAJM gT3p06cPBAplLV269Pbt26HE+fPnR/p27dpBZfft28fOto6CnZYK1ASPHj36 4cOH9u3b02Q65P3y5ctbt279+uuvqCreoqpr1qxhDo3Yxf6nA5VOpzZPmjQJ qgnLTgeLxiBV0RZsykp4mLLGjRtDUtmyZUNb7dSpE4AQrGBDRdOnT/fw8ChU qFDRokUvXLgwbdq0Ll260D44CBqGfujQoV27dqXtrNZd33n69Gm0pICAAFgE KGKKFCmAlFBWgOi2bdvwCsh68uRJ6CsdgG2mLDPlCogUEE/PUE2Ax/Xr1wcP HmznztJxyBaHP80wUBAjyES3UCPJCjgDwINjc/PmTTzAuEPtgJoLFy6EYwYo qVixIhQUfvmpU6fmz5///Pnz7777Di6pn58fmAY0XbVqVd68eRFfs2ZNpIdO /7ljmAWto2aL9plMtmMY2DN37lzUCp4cfDjo6/DhwzNkyDBkyBCw4NChQ3b5 AG+VARWUJS7XIZEC4iVFQvfu3UuWLBkIpkksAfe08YKfZhgoiBFkoluokWQF Zdnl8xSWLl2K7s7Vq1fr1q37008/wdABQZMmTYo+Q9++fe/fv48eD37evn17 xIgRefLkgYLSUdzIp06dOtDpn3/+GYhr53cMW61XxFxsuCbkcaOSMAp3797N kSMHJa5QoULx4sVtyqmQkTF6MrekTOWB4xMnTlTlGet7RTxtaJmzZs2C94VO D6AU8gJn0qRJY5cvdcUrPCByyZIl8NZy5syJT/DWx8cHmXTr1u3169d0u+uf O4Z1ecfHRCd28pyiVZJ2OYBcOsCE3sIioLHyO4YdZigu93/ETiIjgRx4mQko iTXYqVJ3tuw6d+7cJDvSzvhysMuLJCFZqCYpNNsXDtaxi4ftbH2npbCTT8D0 UuKmIlh6RgC/PTemsJNBvhR1OdzXgJ18JEtm5w7qZsyhRsv4Qz95kfEZWnH1 sar+KjbxQcsOMzQLCHBYRyPmsGdd8RulF+QjiBQnE5dlJmdVTR1+Iqgg3x8w giFV/rzcLep3sgRa7NTWkLXImMVOFqNdoxTrsVMVz07BUG2e1kqQLQrhxccy tOJ4JwVmsiXO72TPbByRTRSpekUxSDC/DCemiImRwLSQLWtUsYJBKQ0M0zO/ L5wZeptl/U4712e/ceMG3Ge6VDgkJOTy5cvoCSIeD/fv3/fy8nJycjp+/Hho aCjb+Mcyj2bspOegoCA/P78iRYpkypSJZ7eq1jxb+FJ0OWNEm9Wwk8Ghv79/ 6dKlHz16dOHChXLlytHGL5pJOnLkSJ48ebJnz37nzp3r169XqFABXaKDBw9C xFmzZkWHHVLOmDHjH9ipqoDAt5M0QfvKSBt4Z8LMKwLCd+/eVatWrV+/fj17 9gwPD589e/aqVasCAgJ+/fXXRYsWlSpVavjw4VDW06dPo6MHHR05ciR/8bdA NXXLdUikgHhCdEBCp06dmjZtCponTJgAdjMFFdPg8KcZBgpiBJnoFmokWbH4 CFBWr16N6v/yyy+QV8WKFXv37j1z5kwXFxe02+7du0Mdd+zYgb/QyJIlSw4b Nqxu3brH5ICvlixZ0rJlS0lReiv6ncxEbty4sV69erRj2Cbf9QZFjIiIyJ07 9+LFi9++fdunT5/kyZODKcDOtGnT6mKwnpgk6R/ATkm+nxT0gJjEclBVn6+1 bvy/FzuZagYGBj548IDmh1xdXTt06AA1PXv2bOXKlZ88eYJXHTt2BNAMHTq0 S5cuaMktWrSgm6RhDDds2BA/fnzkkCZNGvIBrNhnJ1cS6AgxA35u374NjQTd EPxvckiVKtXDhw/R1EaNGnXp0iXEu7m50fHyPNfExOgS4LCORsyh8OrVKxrP g2BAYYoUKQhTBUzQjTfijEP6BXmaz1lVU4efUB1t8oLGMWPGtG/fHmDZoEGD x48fT506FSBC6gtrDk/sxx9/hCI2b94cVn7KlClQWYDlzp07nZ2daVJw//79 MO7Vq1f/XQ2oAEthJz1D4T5//rxr1y5JXvMH04C/qBJ+wuMcMmQI2l/evHkH Dx4MNfX09KxTp46vry9vaKITO8mjAK8vXrw4ffp0YPyZM2eKFi1Kd+/Feuyk v3Rs7LVr165evQq8rFGjRoYMGeBxwad88eIF/EuIKWfOnGi3uXLlSp8+ferU qeGkFS9evFatWpMmTcJfIC40GJ0NytOKOzeox1e/fn1JuWMYUITqzZs3D5hP fxGDRgZnBW1x2bJlcGXGjRtnUw4z0nJTlyQtATwlAoFpM6HhZXAf7sfAgQPd 3d3xwPqqAo1UlaLLGSPadNu8FFV1xFXWfq5tivwn2pz59MA/eJmIhIvZpEkT WD+opo+PD3pFCxcuhBuGntC5c+fQYQI0zpgxA44QPNGUKVOi8wR9hWZDL2Ho gTKkBlY8bYG6RLQtuGbNmsQLWPMRI0Yw/YO/wtJPnDiRsYx2AErRftqCpOgE /Cr2lsn1KzltgXbJIhLqhb+QF0szYMAAPMDKsYIAK4xLheSAZM3kIKnuGLYU dtJDHO6OYZ4XLJIglt1Ky+4b1rVEuiR9Qexkge2vt0Wdr1PVmmcLX4ouZ4xo sxR20jM7tpLViFdfdlq5TelFMfPCEvPZWrHPris/XU2yR91gpU2pS4yKVN0H PqVWYNpMWCAytLuZtTXSxvMilzT6qqVNt81LUVVHXGXt59qmqNvaVZ+r4tlf hiwMcXT/qj5kVbDieKdARbTPDvMxCoL05pkgLkLwoe7ngp9mGOiQKt1MdAs1 kqyAMwIscMglo6+si50MHdlbNmnLUJPOlrApvWbaXxZT2EkJIuXrPdlR05Ga w/FiN3byr8jJob9s2p2d7yIp/piqF8v8Ijvrs4vx74vAp/aVuClTBfh9OWw+ nerDZtjZW5WuiInRJcBhHQVARaWDDHZjrl0ZqRYwQTfeDMg5JNv8JwL4NPMJ z4E48m2ZNHIJ2alYAebwM+z8M1NNfsGuFUfj6Se1M3SBq1at2rRpU0Ru3bp1 w4YNK1eufPTo0fTp08GCypUre3p6zpo1CzWpV69e6dKl+bYoJkaXAId1NGIO e5g3b15gYGCqVKn69Omju+XNiCRdHpqRi8k8zeesqqnDT+iZejzoiYeFhbm4 uLRv3/7gwYMBAQGpU6fu3r07pYSkILvkyZO3bdt24cKFHz9+LFy4cPXq1ceM GePh4dGlS5ctW7akS5euWLFif/id9JmlLLuk4OLevXtPnz5dqFAhxHz69An6 SmcZPHnypGzZslDNNm3aVKlSBaqQK1eudevWlSlThiFrNFt2ks3Fixd37Nix c+fOb7/9ds+ePXXr1iV4+BosO8WcOXMGgAJBvHz5ctu2bb6+vhAZtVLoIpJN nTq1RYsW4FKJEiUqVarUrFkzxOMv9PjUqVN37typU6eOTQkWxU7U5/r16w8f PkT13r9/b5MP1QU6rlixAk2zZMmSSPnDDz9ANb28vIYOHQqmtGrVStL03KMN O0lCbm5uaB7Hjh17+/YtiLcrQcAE3fh/I3ZKMhNy586NJrpr164kSZIEBwcf OXLk2rVrwMKkSZMmTpy4b9++J06cQDIgKwSKNly8ePFy5cotXbo0bdq0fn5+ dMdw7969aYWXFXtFdDL3xo0boYh3794NDQ1t3bo1qifJbiisBh5mzpyJGJgM NMRRo0blz5+/Zs2a3t7ebIApmrGT3mbIkGHQoEGvX7+OHz8+LBpzOr8G7ATn 4WX27NkTegbU7NevH0xHr169WrZsCQNYq1YttFt/f//169cvWrQIeIkGPGnS JB8fHySDoYce40PIumLFijA7Xbt2/d3s6AkuhgMNqqOdofHNmTMHtYJGvnv3 DnW+ffs2XJPw8HD8RQLYULTLVatW0a0xErcGOZoDCYmILFKkCFoOQP1rOwsE 9R0xYgR6AhcuXJgxYwYcM/xNlChRxowZlyxZgs4DRAa7T8i6YMGC2rVrw2Fz dXUFjoaEhABKp02btmnTJqgyqbtFxzvt8qQtAhofdY8QgEzz589HlxCOc5Ys WYKCgpycnND5OHfuHCoJX0eKOncnVlNBn9Q8E1SfwLKDHvgkkydPBm1GGGZE oeCnGQYKYgSZ6BZqJFkBZ+zyjkqoI9xHqB0EVL58eaBmu3btiBWwJ7B4sIcA RfhmUGL4mhAoOknwTQGW+By6e//+feoV/bmf3YLz7PQTpEtyu4TXgm4Q+zZb tmwsZ2CVxO1Nial5dqIzvRwkvQlrvtY8W/hSdDljRJsF59mhiJXkU/3hnsHi kcjAFrheeKBz1ikAetBtoLew6fSQUg7MWbeiZZc4H5RNqdMKA5ULaFfG5Cmx yq+NfoIlWSp27mzpGCEmRgKTSKRyT6ZdXgXBD7az+3EYc/jhP/Y5m3OxqGVn b/lejkrkvNuucuHFxDgs929bdklht6oL9TVYdvaTH+VV7aJh17na9eYp+M/t /Gi8BQNrbZJSSb4tqoyOpLFi/4VoDgw7+QuD+WlMlowt47IrZ1uzZEyUf2in w9E4o3E+3VcOB97MjMDxZp3ppV3ZgUrP/H5T1c21zDcSG1bBeJ55JmhjyAOJ w+1nF1AiZr4uY83Q8JekoFuokWQFnGGOFn9hsK5nT+sQGKzaBXcMW9CyS5xq njhxwtXVNU+ePKD71atXZ86cqV69Op3uic4d+oboJu/cuTM0NLRevXr8CcgC YozK/d8tu527AZtf/xHrLbukqNTnz583bdqUIkWKqlWrXrhwAb1ydH3QTWQj fXT9qbe3N15dunQJydKkSYNPcubMiZ7T48ePIcocOXJYt1dkU5asPnv2rEGD BgMHDoR2fvr0afHixStXrqxZs+ahQ4fWrFmD/uDQoUPRDbxx40bmzJmHDRs2 fvx4vlFGZyBEB+VXrlyBVAoUKODp6RlTg6/RH2zKGUnDhw9HxSERCGLjxo11 69b18fFZvXo1eui//fZbvHjx5syZM3369CRJkkCa33zzzffffw+4uXfv3rVr 1zJkyAD5du7cmeVpxXl2Ziy2bdvWoUMHVIz8GNAN7ETjK1y4cKVKle7evbtv 3z60s5MnT6J6Hh4eqrZuRIyKVN0HFeuNmKAlHmCfMGFCX1/fn376KUuWLHbN TV98Dqp4vsOnYqYubdpkqmwF1BqJTDUkoipFmzPFk6GDcTt//ny+fPkQg/ZZ rVq18PDwBQsWSPJQBlQT7RavmjVrdu7cOeBrw4YN169ff/DgQWDQ7du3161b B9b5+/vXqFGDFidYdCYTxM2aNQuK6OLiAjSiazfwTJ0k2PqrV6+OHj168uTJ u3fvhl7COly+fJlXhWjWTgqwSm/fvgUw4CE4OJhvaapa82zhS9HljBFt1tFO eo6IiHj37h1MOWS3ZcuWli1bdu3adeTIkTT5/PHjxx9//LFLly6w7IDY7du3 T5s27cWLFwCdU6dO0aBhggQJgLt4AKz+rgYW9DuJC7DmsOybN2+WZGcF1L98 +RKtE1IPDAyEHR81alSqVKn8/Pzat28Pl4VuWhaX5bDcv8oEFhOpnKuzRQ7z 58+HnMjcm2GLw58W9zsJPtEHgIsJHyx58uRPnjwZPHjwd999B0MfFBQE2UFY 6Cc8evTo4cOHFy9eLFmyZLZs2dB/gCX08vKaMGECeg7AGkAv5C5Rb8mC2En4 RxMJmTJlgr+SOHFiVG/p0qV0SS1YACcaenns2LFJkyYtW7YM9hTejE1ZNs/K ijbspNEQoHjjxo2BCnC2wOKvCjvt8lHAP/zww8KFC+FBli1bFpYahh5GHN7n /v37oant2rWT5AuomjRpggaMXtGgQYOg01DWokWL5s6dG/b9+PHjffv2tdOO YQtiJ1WYdgyXL1+eYtDygJfsq0aNGrFn2A72YRy9q7BNkvS/YCc9wDDxm2Il ZaQ21mOnXVnWDuQbO3YsvSpRogRLRt1wOnsC5h4x0Et6ZZcvZpZk+8OukY60 +B3D/I5hdk8t31KZIrJIdsdF9AcGLSQAqgW/gzl2Bwa3bM+QCmhJXjRXRMP1 bECDuGTnJl/+nMmMwSqJA9NRVlsKqjqrnlXOQzRTa5O3zqjoiX5iYiQwefGR TBb8zmBSRzarKSnClbiZT/u/YiZThZdSVAdI5QzFFHDylERyx/h+nYGHCZXn qispLbIwJLZir0hFIl83NiFG8WQjqMGxHTwx0ivirTmzbqxpxfpeEYtnk89s xlz3jmGWMzvrRSs461p2njU0/WNT+vJ25Vjujx8/0k0inz9/hmrSEteYsuzM 63r06FHGjBkZ2TEI59EciPOocnBwsIuLC+HI27dv0SW3K4FG2dB3pMNNP3z4 4OrqKslbGtHftytzobTJWLLmTKYkC5uWd9SvX79evXpt27bFz9WrV69bt472 b0yZMiVRokRFihQpXLjwzz//jPpUrly5Zs2abAVh9BOMcsPCwnr37r1o0aJk yZJ9PV0iSUFBVHnnzp3+/v7QsG7duq1cuTI8PJxmziAgaC04g8R3794tUKDA mzdv3r9/nzVrVm9v73HjxuXMmROsW7VqVe7cuQsVKhTF7+SbuLa5MzulJUv7 SoAWqle6Xohd6btBNbdu3frs2TPUCpGoZ6pUqVBtPAcFBTVr1qxkyZJNmzbF W3d39+zZsx88eJC2VrFlTWJidAlwWEcj5tADaAZa/PTTTxDADz/8QFdIiZmg G2/EGYf0OyzLTM6qmjr8hJ4BlqR//fv3p2NWz549O3XqVOgcGi04A0CFmkJA Q4cOhXZCxKVKlWrRogU+79Chw4ULF44cOfL8+XPgURzr3zGMur1+/ZqupoO+ ogl6eXnNnTs3NDQUeIlk4AJgFfA5ZsyYgICAhg0bSjG3ypP3qEAYwAAY36VL l5halRLNwa5cfw3HBpbt0KFDrVu3BgpOnDgxR44c8ePHh+slyee10PKDsmXL 4me7du0gyqpVq86aNQvu0K+//ko7hnv06JErV65Ia97iSguU9u/fD4y8fv06 ULN9+/ZJkyal9YJ0+yDET0e5QimhnXnz5q1UqVKDBg1iatcb8zvBX/hVcIgB 8xLn/otpcPjTDAMFMYJMdAs1kqyYA0AQuFtww2A02rRp06lTp3nz5rVs2RJq V61aNTRU6OixY8egoPfu3YORWbx4MWwg/DFo5C+//JItWzZEVq9eHWYQmv27 dmrLiPE+O3W9gUBwlufMmYNaQdhwU9auXXv//n14M3h7+PDhjh07wg2FNZ8/ fz78PNRf4ha6RnOfXVI67BEREUCCkydPjh492q6s/Y71fXZJ5jw6QHAihw8f DmFNmzbtwIED6B7AoKdOnRo8ASJCfEgJoIEFB76UL18esJo2bVq0ZPANlhDp lyxZQub+zz2ZuvziY/5Hp1PgIem+IkmjYj4+PqRwaJRwNGEFYNlR22LFigFZ 0Vjz589/584d4KuHh4fEjd4LiDEq1yGRYieSeqxbtmxBz7RRo0Zguj3qWImA Boc/zTBQECPIROB0apMJOEOmA5hy9epVqCmqD1C8efMmfDOoICwe0qRLl27m zJl4ADQuXbr0xo0bnTt3hmShzUgG7n333XfoaaCHFMnfMSy2zl/EuGtfGRka tqrcLm8Upso7OTnRzmAKtMdUkhcOokskKefxqfL828bdqI5iMwr+JpeDpJys pN3Oa8bKmzHBDsk2/4nAuJv5hMdRWgojydWH7IoWLUrxdHVTQjnY5a1FgB72 lt8Xzt8bbcXReFV6u7LCQGV02F92iidLz76NNsvOEkRqrs5VZRgrLTufkt+5 FsldD8lvaovDnVnOf07iY5lbsVdkhCKqmhg9OyTGYbnmmaCF6v92DPNp+Ol1 1VvVsyrS/q+YZ2drlChGhUY8nIh18b/wjwaV6ZCUhspMH59ABatxuJP/VXbP ir0inkS2hZR/5ofc+Yld3rIIiBGXKyBSQDwfo9roLKBEzHxdxpqkQVycQGQ8 wdpkRmUxfVKd28NvFGY/Jc7IsJ+SnptkxV4RQ03I+PHjx/hLd2BGRETcunUL 3T3E3Lt378GDB2XLlo0bN25AQAAd6smDqIBmAQEO62jEHMZQ1SZurVNoxsqb McEOyTb/icC4m/nEpnRkIaCTJ0/iL7rhdJ5UaGjoo0ePaGgd3AgPD/f398+f Pz968WfOnMEnSFmoUKFr166lSZPG3d3948ePwcHBNNwhWXOuSFKEDUIrVqzY s2fPHj16fP78eebMmatWrbpw4QJqOHfuXNTKz8+vWLFihw4dSp069ZEjR3x9 fWNqboY1KrQTSKhAgQLoh4q7ZbEvoL4vXrxAlVeuXAng6NixY79+/aB5EA20 89OnT717986XLx+E2KZNm9evX+OTNWvWNG7c+Pr16/HixRs0aNDChQsbNGgg Mb/TgpadAee6deugnQkTJiQZN2zY8MSJE2iamTJlmjdvHtJ07ty5VKlSCeQA EOXdUAExRuX+L5adHgAV/fv3hwCWL18+ZcoUOhHXDFsc/vxXWHYgIlQN7RNi gmpCKemkDJs8w3L37t2bN2/Onz9/1KhRp0+fBqP27dvXvHlzyLdKlSowhps2 bYLQ3717lzlzZrI/VrTstFITLQytrXDhwg8fPkQMap4uXTpAI7QTD69everW rRvA8unTp/gEJoPduREjlp2a05UrV0JCQkAY6LFxN8IImKAb/y+17BATmDBx 4sRKlSoBRCHBdu3aTZgwATxxdnbOkiULvK9JkyaBSxArPlm8eDFQBlZx7Nix kCkegDJr166FgiKHP+8YtlqwK0v99u/fj2dUL0mSJKg8wAkVePbs2ZAhQwYM GFC0aNE6deqMGDGiYMGCqA98gJiypAQeAMv379+D2j179lSuXBnWKkaIif5A bAdAAFDOnTsH6QQGBmbMmHHXrl035JA9e3bgC3gCZxS2vnTp0pcuXXJxcQHH oKbT5FC1atWzZ8/Wr1//4sWLSGlnq4/F1vmLGHftKyNDQysjW7RoIWnuGIYT De8zRYoUqNLRo0dPnTo1cuRIWvfJ7njl7fvfNu5GdRSbNrj/9erVA0loS3S8 tKDWAuaYMcEOyTb/icC4m/mEpQcTPnz4AMcGaorO67Bhw16+fAnDDdWE7Pr2 7QuDjj6Dp6dnhQoVtm3bBq+Mvrp8+TK0tkSJEnBAgbjAHTt/xzCDHK0jb+cm D7RVVb0y6gfwImSR2nEElsam7Bime7DxAI0cOHAgqgq3BjraunVrPMB0IgYd I9ZBZncMG9GsIt7ogU9pMzFXRB6FXV6qSFdIGcmVz0EVz3veKmbq0qZNpsrW iFqByPia8rrBx0gahWEKiq73jz/+aJeH1RDQNYSOwkZDdkgwfPhw2EOAKF55 e3uzz6HQ6EfiuZ0cJCvvGJaUoTIbN7VFiohnqCbxwsnJSZK3E9EgDjk9YrD8 RwkmgdFZVqqbCGOEpGgOqsbDxMdWGtjl6XWopmrHsJ274k11vLUVe0X0oAIJ Ns/OH5zO3ABem2OkVyQpChqHO16e76UZMUE3/l/XK5KiYrAKfRkG82PyWmBm n/95uiz9tpTfqfuhyqxok6kio9nv5J91TaG4grr5GEWKk4nL+uf8TkEOuv6S IB9mMC1654akaBsjj50FwmZp2T30rEoMR9kngo0ckZoLKFSU8HQaMYGP4b06 thZEUoBfVWueLXwpupwxok2bTJWtEbUCkfE1jfwrd25oP+fNOnvLpMaejY4N tFvz7GNeL/lj8Xk2/TFaG/VMbpWD/7fNunkmaDsHtMw0NDQUDpZqCFZAg8Of ZhgoiBFkIjDr2mRiztiV9Trs9Ch+IYikyIveUgx/zpQ96snckjVnMu3ctsy+ ffuWLVu2QYMGiNy7d+/mzZvnzZv34sWL2bNnQwNq1qyJ7t6sWbOgsk2aNClY sGBM9UJYuycBDBkypHXr1vxy6VgfCDX8/PwOHDjg6uras2fP69evz5w586ef fkL/lc5cWLJkyY0bN9KnT9+yZUs8Q450G+/o0aPz58+P3vru3bvRzadBGJtl ZzJJNQ8fPrx9+/bMmTPj1adPn16/fn3t2jUkuH37dvbs2aGaXbp0qVixIniR K1euhQsXzpkzh3ruYmKMynVIpBmnc/r06SD14sWLbdq0sXNBTIPDn2YYKIgR ZCJwOs348ap4IMW4ceOmTZvm7+8PCd68eTMoKMjZ2Zl2bD59+vSHH37o0KFD ggQJsmTJ4uPj06JFC+ho3bp1r1y5AqZdunSpf//+NiVYcdcbeST37t2DFg4d OhQYaZPvGG7evPmmTZvws6wc0C5LlSpVrVq1wYMHnz59um3btlJU42VEjIpU 3Qc+pc3EeCe1dQDD/v37V6xYAQixcUFba54tfCm6nDGiTZtMla0RtQKR8TVl EuHjVTmrOFC1atWJEycCIzw8PNzd3TNkyBAREUFjn4kTJx4xYsTVq1fx3KpV K/wEvpYoUQJICZMIyNy1axcUGtLs1asXvrVbc66Izhhfvnz558+fHz16FBwc DENAR5qwO4aBlFDTQYMGoSEOGzYMvGjatGmdOnXYkKeAZgEBDusoYA7g4d27 dylTpnRzc0uTJg2kovuJGRw1A3IOyTb/iQA+zXxCxgGKBRSE97Vjx44FCxYs WrRo+PDhdvlWcOon4DkgIACv5s6dCwV9+PDhgAEDkKZ+/fq1atU6f/48UkLi JUuWpAvuf19uYaZn80U6RtpXRk46aViPHj0+fPiAmqRKlQqOC5737dsHS4H6 h4SErFq1Cr7doUOHsmbNum3btnPnzmXKlEmKumNYTIwuAQ7rKGAOioaDQTub YafQwGzK5SECJujGm+m+OCTb/CeCjpGZT2zKqDssOLBjzZo1EEe5cuX27NlD d0IXL178woUL3t7eMOUdO3Y8e/YsPoH6NmvWDOyCVcyTJ8+RI0cANLCHMD4w jHbL7tyg2rrJoV+/fgSlknyy8JQpU0gJgJfAVLADD6hYWFhYp06dbFFXXEdn oGEUmKcZM2bAJ4GE6C7XGOmiRX8gkUE1AY2AjK5du6KHCks9efJkupEC/QSA zqhRo2BSIKxKlSrlzJkTeIk+ExgFCwnxQZqw+FBoWgLy+zx7TNdLJ9i5HUUw kRQDy04zsxRoW6okg2WFChUkbghXbM3/uUDGK6scWORXop1MZPAm2QQ67DVL gK4t/tJdABSSJElC5g4p4Z6yBwTWj7SidjKJskF4dscwS8AUkWbYqfMRJ+rN QNEZWLl0xzBPz9egoLxEIrnTVdkzi2FuA+ty2TT7wtmktBVHlPgHvqPKn/rC 94X59SLissyX67CmRin5fjr7ymSvRfDTDAMFMYJMBF0ibTIxZ+xRN75pD7+I w10fSlxi+TD95iVu0bkiVgHVnnx+YYs96liGyS6Ow3IFRAqIN8pWwD1tvOCn GQYKYgSZCLpE2mQCzmjFQWZE0tyDzWY7I5XrbtknDHrorxXHO3kPklWMX/jD x9O4vVE+AgW1awb/VDnwdBoxQVso6GQ772yK76GtNc8WvhRdzhjRpk2mylZA rZHI+JryusLHSBqFYX/jyBdr0Ct+nplhDSVgm6rpFdtg/a+ZyaQKXL16NVGi ROhngO6goKCAgIBSpUoh/uLFi+gaV6tWDR099NlpVlNsyv/RwETI1gCwW8hj iqRoDiQ19NB37tyZN2/etGnTHjx4EDHosBcrVixlypRkBvH32LFj5cuXf/jw 4alTp7y8vNzc3Pbt2wcRo19Pd/nR7CASW9HvlBSkfPPmTfXq1fv379+rVy9U e86cOatXr4aCQh2XLl1apkyZYcOGoebnzp1Lnz79iRMnRo0aRTohJsao3P/d 74Qw3r59e+DAgYIFC9L9UTbOARXQ4PCn9f1OqmzXrl1r1Kgxfvz4hg0bJkyY EK9mzpw5Y8aMFClS0Mjgzz//PHr0aEhw0KBBrVu37tOnT4sWLU7JAc9LlixB JMvcitjJLMWmTZsaN27M7hhu167d2bNnIyIiPDw8Fi9e/OLFC1QyderUiPnw 4UOGDBnEjuY/GkhIQPfevXtDMD/88EPfvn0LFCggXsUXawLzHd3d3YEpMG55 8uQBFu7fv9/b2ztnzpwAlwQJEsASfvz4EYjj5OSUNGnSd+/eAVbwt2TJko8e PdqwYQOA9ubNm5BpFMtuKb+TdgzPnz8f9ho6B3LpHoZkyZLhFZogGiLMuq+v L5QA+pomTRrEwCjYo56FEp1+J/khgYGBEAD8DZABsj09PVXumhRL/U5qhCEh IUAKqB3sOFiRLVs2YOG0adMkeSYFJnvcuHHffvutvxxg0BEZFhYGLi1btix5 8uT4FnD766+/IhJ+2u9qoGXTP2Tcta+MDA1xATr37NkzODGSfGMIZA9kev/+ PRhx9+7dIUOGwKznypVr4MCBsPuoYb169QYPHmyGZgEBDutoxByiOZkc8uXL BwnR3Y9a19OMlTdjgh2Sbf4TgXE38wnjAAQE3Zo4cSKA8MKFC3RoQqpUqaC1 MG4uLi7Fixe/cuUKxLd27VrEN2/eHOqLr8bLoU6dOocPHy5XrtydO3coWyvO s5NEacohS5YsaENJkiShHcMwBHBc4HEDLP38/I4ePYpaoeXt2bNnwoQJNm5e W0CzgACHdTRijiRzE/JAU9mxYwcAvmjRojz2OOSPLg/NyMVknuZzVtXU4SfM egBQABZwKAGKAwYMQA+hcuXKiIcvvnHjRriVPXv2REqAaI8ePSBNpITnhp4D UsJbgyN048YN4NGfO4Z1axWzgeCTdgzTafB2+Y5hdpcwApode4a9YB/G1LZM mxxQNLslVzL2c2JfsCszPfXlQJFl5IBIuGdQTbtyxS1cMrxFDPvcUw60hBxB YjuGHdqdL2LWzXQ5VfnE4e4YZhsAeO8nTtTr68jzYzECYozKdUikgHgWaAez ndufKaBEzHyHtt58jCATgVnXJnMoPhozUW1gYlMqdGcfG1riTy5n/ivlRlK2 Yq9Im0alkXwRvCqo3HYxdNn1OkN/u1fEnonXqk2x2hrxbOFL0eWMEW3W6RWx lBSv2r0tcbaF1ZQxiqXkE5OaWnomU5VMpXnafFR+3t92Os0zwagp8vsMBZSI me/QEzUfI8hE4HRqkwk4IwBsXjUdEsknsOhJNdrEKiMuKffX2pQQs3cMswT8 XEAc5YiLrwQ7ifn8Lcu0goz1U/mvtGVRiMMd42117OTHL5krQ9Oy7LgiimTb cx0SIy5XQKSYeCodVD169Chr1qy8Nsd67JQUDkA0dFISRfKXB+NvaGgoIvGW DvPhzwFmbZvNANuseRYI/SSFa9u2bfXq1dFDx88tW7asX79+7dq1Dx48oDHe ChUqoK83Z84c1Ac95XLlyrGZTAHNAgIc1tGIOZLSIRg5ciQexo8fb4TEAgvo kDMO6RfkaT5nVU0dfmLn1kUsX7780qVLzs7OnTt3XrJkCd0i/N1330nyQNLs 2bPxAPFBcJApfgYGBo4YMWL48OEeHh5ItnHjxkyZMhUpUoTyt2KvSFJWHu3e vfvixYvFihVDTHh4OCr/+vVrJHv+/LmXl1fFihVbtWpVtWrV1KlT58yZc9Om TeXLl+fHO6PTspMFf/Xq1c6dO5s0aaIygrHespNqPnv2bPHixYcPH0bjnDFj RuXKlYEslSpVgiImS5YMKjt48GBItnfv3sCRu3fvbtu2DYI7cOBA06ZNr169 euLEiXv37nl7ezOPyIrjnZHKOcJPnjzp37//u3fvbPKOYaDjsmXLYB1KlCiB ZN9//z0qj1aIlnf27NmWLVtKMXfHMMqFTUc7QbtHy6FIlV7G7kC73hInTnzw 4MH79++nS5euZs2agMOiRYvSZktavbV06VLAJN6OGzcOqLl582b8/Pnnn9On Tw81hcWHxKG+WbJksVvzrjfSzq1bt0IR79y5ExYW1qZNGzqDHfF0NyEsO1QB lW/WrNmoUaPy589frVo1anZ8WdGGnSwB6xBIipfyNWAnvYJo4Ng8fvwYUAKP E0A4adKkbt26nTx5smTJkv8nB6jgwoULjx8/fuPGDaTZv39/JzlAp6GysP5A 3L1790KyFp1np05f3759Q0JC4FPi2cXFBQgKv/P27dtwTYBS27dv79mzJ0xD 6dKl4eukTJmSHIDIGDr7mD3QkSxMLwW1FjDnX+d30k8A5IYNG/LlyweMgJLB jtPF13g1f/78b7/9FtYcsnNycoKwACinT5+G55Y5c+Y3b95AUxs2bDh16tR1 69YBZex0xzAVYCnspGcnOfTq1Yt8UGB+tmzZ4NbAAXV3d4e/8vHjRyRATdh9 RZLefWFaYlSkfhHslOSl4HgeO3Zs8uTJbUr4SrCT4gGZgwYNgsLVrl0b1rxg wYLoIc2aNStJkiTAF7u8smfy5Ml2+XYOJIZLmjt3bggxKCioa9euiERfCn2m woUL/6GdqgpoxWmL9hElu+Jo4xneNMWgerQzmAL8EnqA7qLbLml2FwmIMSrX IZEC4tlzxowZtZ84ZIvDn2YYKIgRZKJbqJFkxZyBCCAv6JwkywWtlJ4hPgAq IQ665HYloD3T/mA4aZSMbmhmYGzdeXZJ8UHtyrB2ZNRjmxlfyHawJu7Q3hmV 65BIAfEsqDZwiR0MMfMd2nrzMYJMBGZdm0zMGeZ5s6Np+AE+G7eHkSVWQTKL sfHz7NYMKqNjtGOYf47xIAbs2B1IXvywCT+ZonpgWqjKhHdgrLi+U5C/UUrz lkhMgMM6mjSjgk/MWHkznHFItvlPTPJczHyTlJh3vSRr7iv6L/wXKFjR7xR4 QoLizLiPJsv9X/xOVSZfld8pKNFhLXQ//M+yG1Kim9V/lt38818tVxv+w87/ sNPy2MnCPwScglbuEMD+EnyKyzJZrnkmOKyOGMLFzHeIpuZjBJkIuG3GFv29 CjpETUpgxbkiVRp71HkL9lb7rM1HwAW7ZuLErjcfo6JBlzlGNbV9ZXNFuiXq ksrnrBv+wE6j1/+F/0KMh/+0879g3fCfdv4XrBusuL7zP7/zP7/T0n12VmcV s1Q6qlu0yY6hIL15JmhVTUu2gBIx88W1M/rKTHECkfEEa5OZ5IxWZXWxQxcF +DytaNlZ3dhSYnarAS1WYkflxjSl6mBTzj5WXS/7VQW7MgLK7xtmAmX7Lfmz I1Wgzn5acTTepmweVe0NZ6dHsFVqkdx10Np8xOorSG+eCVrTzOjkD2lxyBaH P80wUBAjyES3UCPJmuEM0zP+7O0/tI1rtNodYKrD1yVr9oqIsjdv3ixcuDA4 OLhp06YeHh7h4eErVqy4e/duxYoVq1atasFTW6nNPHr0aPz48YMHD06XLl1k 1Hvev5JAugXp7N69+/jx4zly5GjVqhXFbNiw4cKFC9mzZ2/ZsuX333/v5uaW PHnyUqVKLVu2jA6jW7t2bfny5dOmTUtZWdHvpJ3smzdv/vjxY+XKlSdMmAC9 vHLlyo4dO6ZPn965c2dE0oFeFvQ7AwMDT58+/ezZs/Tp06uOaxTQ4PDnv8jv pFrfuHFj9erV/fr1u3PnDhm6oKCg8+fP+/r6+vj4xIsX7/79+9999x3a8IwZ M+rWrXvy5EnI9O3bt+7u7myRshWxk1yTChUq7N27F8KuV68efqLBJUuWDLBU tmxZ6C5/PrxFApgbEREBaC9UqBBd4WpzNG4QKwNVGdr54sWLAwcOwAbWqFEj YcKELi4uAJoHDx4kSJDA09Nz+/btgEykT5069ZkzZ/AVxA2ZTp48uUePHlBf O9sxzCSttZjMfzJyFPhXRgaXnXzEGzveP+PTUK9i3rx5HTt2hLBh2Zs1a7Zl y5ZMmTKNGDGiefPm169fz5MnjyorbT5i6686xU9LiTZzI+YwqbAHV1dX5vir /GM+B20VdDljRJs2mSpbI2oFIuNryjgpRXWjJY3CaOPt8iYhYCfEB/tevXp1 pLl169bUqVPHjh2bIUOGJUuWJE6cGJItUqQIdDEgIADog09CQ0PPnj1bpkyZ 39WA7+dLmuFGFqON132lm0wyGJnTHR5iXnbKlClRq7CwMGdnZ/rp5+eH5oUY yF41omR3ND6nS5KWAN1xOLtmCFCbCft56tQpwAYwA4xOlSqVNkNtB4IvRZcz RrRpk6myFQzZGImMr6l2DEibszaelLV06dLr5QCgSZEixdatW4Gg8Mo6dOjw +PFjmHu8qlat2ufPn+F3PnnyBJG1a9eeO3cu0sMBpTytiJ1k2dGx2LNnz4cP HxYsWABCQTqEjcY3e/Zsck14tsY4dv7BzbhxX716BcOEn2hF7Myqrw077fI2 S9jow4cPAynxDDniFZ3MTRdNAWJgA+F0ohmjKwmIhelHPLLKmzdvlJNqxKNC X2RQSfvKaICDNVm0NhaJUEwOkmbfo4CMvz2oZFRHI+YwYurUqcO/ivPV3GrA nplo0OOh44MQ0JHF34YNG7KUANTChQvTJ3QDBB7QqWCZ2K15qwFriLQVmKHp b7/9RgniRD27VUDG3+62G9XRiDmMoXTcPUmI6FQBmJn+u5nOtUOyzX8i6Lab +UT1zERDExNsKD6Ochu0xJ2qTsJl0y5M4nZ+vNOC2Clxt39SpOq4RzNkRBt2 sgeeSEnPKYz12MkeyNWhnzbNaLyqz0DPrCXb+Lki3aR8jDZe95VuMka01gHn P9GmYTEsAW84+GeHXrwuSVoC+Bx4Oo2YoBvDuuo8i1S15ivIl6LLGSPatMlU 2RpRKxAZX1NeN1QVUX3Ox/Ol8KyQOIeYJWBOLZMyXwUrWna7Mg9LOESkq6a5 eK+c0WAFy66aydSqTmy17KymTEwqVkgaw0KBXzihysqK2EnJQPHly5ffvn1L xyeheuHh4Tdu3MiXLx9eoWt84cIFdJKSJk1q505oV5UVbdjJ3r5///7UqVPw 91OmTCkAPJ4tfCm6nDGizVLYyRrntWvX0ElHT/zp06eQYJkyZdAZJwW9desW OuxIVqlSpZCQkPPnz5cuXdrJyenEiRMZMmRInz49uvZBQUHoTkXBTl3e8TH/ I3AKWrn2FZ0ovm3btj179uTMmdPPz2/MmDGfP3+eMWPG6tWroZSo9rhx49DR u3LlCl3TxLPYIaIYJXNIpIB4slloS927dy9fvvyiRYumT5+eNm1a5n6IaXD4 0wwDBTGCTATAacYWsXjSv7NnzzZv3nz+/PnZs2fv27evl5fXypUr8ZNOkh81 alSVKlWgfI8ePfrxxx+LFCmye/fub775Bn8TJUrk6+u7cOHCxo0bS8xt1a1G zAaqcOLEieFEo8J4IAE3adLE398fDwcOHAgLC0uSJAlYIJB9NNNskw9oRrPJ nDnzjh07gAFsNcPXEGzycWuQSO3atYGLsGlz5sxJlSrVxo0bgSzgDBTuzZs3 eJUwYUJAjJubWzc5rFmzpnPnzohBSkj85cuXwFHyBKy4go4CpOvs7ExrBPEX jQ/CjoiIwCuYdVj5jBkzjhw5Mlu2bMwQOCxLXK5DIgXEk11zkQMwA3iQK1cu dn2EQ7Y4/GmGgYIYQSa6hRpJVsAZgk8oJTQM0iFwad++fe/evV1dXSnxwIED oZrbt28/evRo06ZN6dty5cpt3rwZfPvtt9/wdtOmTfCOALq/z2TSZ5byO8lN Xrt2bcuWLdEQS5YsCfMN7YRqfvr0CWmgkbdv36bT44ODg7UeEisr2vxOakLg 7/DhwwsVKtS6dWummqoB+djqdzI1pWtfYNzg5LRo0aJq1apQVkRCgoAVGMAz Z84kS5bs/v37wNEHDx4MGjSoWbNmU6ZMgUbCZff29r506RIcADs7IVGMf18E PrWvjJoyiRNiXrBgweHDh4cOHQq7gIrNnTsXrRA+aI8ePVA3WmGQO3duNqtp pq2LCXBYRwFz6NKJwMBAYPzo0aM7duxIoO7QOukyQRApTiYu66/Cp5lP2DPA csWKFejZHDt27MWLFzDo6BgEBATUqVNn586dvXr1unv3LpxLAOTy5cuBPt9/ /32rVq1gx+l8bvRxr1+/DkOPNHbL3jFM2pknT56pU6eypok+4ODBg9H+0BDx F1VlQzaS3qB3jNCMXicME2Dj/8khZkmK/gApACzbtGlDfUQfHx9iRbx48QAi iAFMsku0unbtyoTr6emJPi4e2shBYncMm+l3f5Fuu/aVUReSKKNJLdQE5pLu poVSogLA0Uhl7w7dcscskZk+ppgAh3U0Yg7DGwR0P6Wog00CJujGm+lcOyTb /CeCbruZT3grTzfusSFPxgriD0mNXfzA1ukyoUdGPd7aithpU0bOqFZxuKuw bdwlmeyV1reLQbIlpd0buaqxNfCOKZMFPzlki7rwgBeuClzYLIYV++y6aVQu uZZsk06kmXLNM0FQd15UJv1CwU8zDBTECDIROJ3aZGLOGDVFbX9OXDXGMSta dh4j6QEmIFIOrP1FKnfPs8mxGLfsNm5TLE/qV2LZWU35VaQ2ZZSeX97BlE+1 YpU3NfTXithpU2Yy6Se7PJhWuPzhL8vPpLWkl6ySMYKdjLP8Mhx71NEWAQ0O f1ofO5mLxQRH/UL+WnKSEXUZJWW9HL8SjTf6kjWxkxTu8ePH8+fP//z5s7e3 d6lSpUDurl27Nm/evGDBAiRYvHhxYGBgvnz5WrZsyRbCxCx22uULUBYuXHj7 9u0MGTKgx0qa+pWs7yQFff78+YABA3r27FmkSJF58+Y9fPgwR44c7dq1gwoG BQXNnj0bwnr16hXeXrt2LVmyZEmSJPnmm28mT57s4eHRoUOHHTt2pEqVSr1z gxWmtUR2Y+9e+8rI82Cl8I1PZRFYGjLle/fuRUy1atWgjtDOT58+ffz48dat WxD2gQMHzp8/37lz59evXzOl1OZjRIyKVN0HlbSMmKD6FhRGRERMmTKlRo0a lSpV8vT0jNSctsDnoIrnkVjFTF3atMlU2YqpVUXyP9lfVSnanFX24YUcoH9h YWFbtmxZunQpdK5hw4aurq7Ozs79+/dHAx4+fHjq1Kk3bdoERmXNmnXVqlV1 6tSBskKm+FuzZk2bEqw7Gl+uXLndu3ffvHmzQYMGIDRRokRNmjRZvXr1b7/9 dv36dbDg4MGDb968qVChQrx48Yxq8beNu1EdjZhDNLu5ufXo0QNIkDx5cpom ENRawBwzJtgh2eY/ERh3M58wDqBlokECF0NCQiCv7Nmzf//99/nz53dxccEr JICk1q9fny1bNi8vr0WLFq1duxYSrFWr1v79+8E6iBuoNHDgwF69eqVPn95u zZ0b0D9UY+rUqTCOlStXRmOqX79+ggQJyF9BBfAXNURDrFq1KtS3QIECbNjM DM0CAv4Xy46H4ODgp0+fduzY8ccff9y2bVujRo20ZyrFVsvOAqqcOXPms2fP onHC7rVt2/bYsWMVK1aEWBGzb9++cePGAVnhmwFNgTjx48eHfP39/VOkSAFH rmzZsnDhunTpYtE7hslSwKfcuXPnvXv3MmXKBAHDaILou3fvwl5AZU+ePPnz zz+7u7uDEaqVnQ5pFhDwt7GTTFt4ePigQYOaNm0KHaUbPgW1FjDn34idZPSg iAEBAQBOKNmHDx9g64Ca+Lls2TKoKaT5/v17SO3y5csTJkyAHCFZ2oHp5+cH V2369OmQMpwiu2X9TrKS3bt3hwqihm3atKG5osSJE8+YMSM0NBTAOXHixHPn zs2cORNuNT/6rSor2vxOohkGnS4fh2sFy25XRh60tebZwpeiyxkj2izld0py 7xva5uvrC9jLkycPVO3MmTPTpk2D1aaUQEcoJR5g7keMGHHnzp05c+agGaMH DNWEEkPW6OyWL1+eWGdFy04P0Dm61JoqBtWsXbs2+wm3Gv6KFHVLSgxadklR L0iibt26krKGWrvZPBZbdlSfiYwCsQLxJUqUICFSowVbcsqB3sLLpId0ciBD JFlzvJM90AZTCmw03q7s0yC+sIZr0kybKdc8E7QxRGcc7sJZxmsBDQ5/mmGg IEaQicCs65pv3TwZytIQpqSoLH/ygC3qHcNsc7CksMjGXSlts+x+dvZMBp2Z HvZTiqqXFsFOI7KNai3I51+KnZLehmnBg0BeUfxOFiyFnbzVtitBdRyN1bCT IlUdta8HO+3Kney8uWO+Df/Wrsz6SprDXdiDRdcoSXJNaCzGrvjdrF3ywzRM D6wQbNzOZtVhTLE+MKeLSY3NWDIJsgl3tsqTpZSUXj+f3oraKXHDE69fv4Zn TbW6ePHirVu3qlev7urqis7g/fv3a9So4eLiYrfYCrqwsLBTp07RRuevJDDl e/PmzcGDB/Pmzevh4bF//36Iz9nZuWbNmuTthISE7NmzB915JAgKCjp79my5 cuWgzbt3786aNWuuXLlevHiBNFmyZPkDOy3od9Jy4/Xr1x89erRAgQJ9+/ad Pn065L1y5cry5cv37t27ffv2S5curVixoo+Pz/LlyyWltcWg30leB4H6lClT FixYcPfuXe0BzQKS/tV+JxmK0NDQPn36VK1a9YcffujYsePcuXP79esH7ZQU m463ZcqUmTBhAuKhmuPGjbt58+ahQ4eANfgJyUKs7dq1Y9la0e+kmmfMmDEi IgKNKVu2bIjJnj372LFjz58/nzBhQrS8xYsXP3/+fPPmzYJ8otPvtMndVajm 6dOnQWHlypX5nnus9zslUqa4cSdNmpQ6deoDBw68e/fu06dP165dgxxpV8bD hw8hzbZt2wIdd+7cCU3dunUrWITIYsWKPX36FHiUIEGCy5cvV6pU6Y8dw7rV sEIIDAzMkCFD5syZb9y4AcEnT54cf2E1kiZNmiJFinv37g0ePPjHH3+UFOCM WWrJ/YUhmzZtGhB93759jx8/BvFWoC0aAjXCePHiQTUhlxIlSjRu3Njd3T1l ypSASYgMMXB40G6ROH78+BAlnsE0aCrcs4kTJ7q5uQGMoJ0nT54MDw+vXbv2 nzOZlgq0phgCrlOnDpxOtKTvv//+yJEjAP9Ro0bBcMB3Wbt27dChQ+GpaIe7 YyqQ7wvLFRAQcOfOnQcPHnw92kn2AbIYMmQIwLJr167Xr1+Hb1O4cGEnJydY /EePHqVPnx66+OTJE/DHy8sLkR8/fgTEIh4oAwWFrAG6pUqVAvRQnlbUThLz mDFj5s+fD1MONwXKmj9/fnSSBg4c2K1bN1gQdIz27t0LKAVQWUE7iWZARffu 3SW5YwS32K45vDMWB9Q0ODj4/fv3adOmhd8JVYPJBpo0aNAAskP3AP0HiG/W rFmenp5VqlRBXwI9oUWLFvXs2fPZs2foReXLlw9uKFCpf//+dn7HsGoUlC/V bjDFrPvKCCpU41h8ofaoM8g2ZZ4dTRCVZJ8D+QGW7FtUj71ifXZVPmLcsmsm nVU58HQaMUH1rV0+XRYPAwYM4GcytbXm2cKXossZI9q0yVTZiqlVRfI/2V9V Kdqc+TxdXFwAKCwrOtGYAlTTLq+KRKDEQFn2NlmyZLQWpKEcJLYDQsumf6hj pH1l5KRThSFduzJpqbqJkNih3cxuxosXE+Cwjg57dbRRAcTrUiUgyWEfyGHR 4jzN56wi2+EnTGR2boBdUkZ8mQGh0RiGIwxWWCY27Uymbq1iPPBwyOpGRP8r bKUVxl9jJPDS4Q0aAxR+TohPzJLxJsKi2imZhhzJGn12Fr5OpZT+mYpb8fxO iZuxtSlB4k4xiKPctEK+M+8eicsSl+uQSAHxLPCLpwTJdOMFP80w0HxxJofi tckEnGGmWVImJ0mCNEtEifmDqtmEOz3bNJdV/Ol3WqpXJCmWXYX8KqvBV5gn I0Z6Reyndsewbq15tvCl6HLGiDZtMlW2RtR+8V4R+6u6eYI/0EUyvmOY7QXn 59kla57MTQ8fP35ctmzZ+/fvW7RokTVr1tDQ0NWrVz948KBevXoeHh4LFy58 9erVN998U7hwYdUJ7TGinUwGc+bMAeXx4sXr1KlT0qRJGd6ras2zhS9FlzNG tFlKO6n6R44cOXDgQObMmTt06HD79u2lS5cOGzYsYcKEhJS7d+8+efIkuufo mI8bNy5RokSurq7NmzefOXNmvnz5IM0TJ07Ejx+fZGpjp3zp8o6P0RWzEf4b pRTkzz/QjuF169Y9ffqUhuKXL18eEBAQFhYGkXfv3r1Pnz5Q1pYtW3733Xf7 9+9XHbkhKEtcrkMiBcTblXGGnTt3jh49Onv27HSgvYB72njBTzMMFMQIMtEt 1EiyAs4ghIeH79u3r0ePHj179kyXLt3nz5+3b9+OZ2ghZPThw4c9e/b07dvX 19cXjLpy5crEiRNTp069bdu2XLlyBcrh8OHDAwYMsCnBovPseC5fvryfn9/j x49r1aqFmNKlS5csWRKCL1SokJccfvnlFzQ4m7JoTZuP2E8XpDfPBJ5mkhNw YseOHYDPoUOHurm5CbinjRf8NMNAQYwgE91CjSQr4IxNPiRw7NixaJ9Qvvz5 87u7u69YsYKuW4aMEidODIx8+/ZtggQJsmXLBlWGbXRxcQGU3rhxA9Zm8+bN +Dtp0qSuXbtS27YidlJVgZfA/DJlyvTq1atx48YATsRXrlwZFQ4ODj4qh+nT pzPfzkxZ4nL/F+xkAS4HlHLw4MFr1qwBzP8+WRxXzWSjz//V2CnJqzYBkLnk cOzYsSZNmkApkyRJYpNvQoOkgDXAlyFDhuTJkwdGP1myZI0aNSpatCg8gYcP Hzo7OyMldBq4065du99X1dijjjxpp60juWs9VZRpXxnNekdyN6uySLZKV7Xc XVJ6RVevXkXdPn36hLqdPXsW+tqtW7eXL1+CevigI0eOhHWAD6pyvfmyBIOj fLm6lPB0GjFB9cm7d++GDx8Ojj969Kh69ep27nhHVa15tvCl6HLGiDZtMlW2 AmqNRMbXlJcIHyNpFIbiAZM+Pj5okxAZtO38+fN37tw5fvw4cPTatWswhnBG W7VqhRYL93Tr1q21a9eGCmbJkqV48eJTpkwBZC5YsAD+QIYMGeyWHe8kbYPy bdmy5f79+3THcEV52vr06dNTp079PzlANZ2cnGAXYpre3wN5IylSpIBnjIYE CcEPsX9N8+wIEAf6OnA9YeLQONeuXQs+PHv2DNBICZo1awagOXXqFPQSvdub N2+OHz8+Y8aMt27datq0KbiH+EuXLnl7e0uyGlhxJpMkDYNIV9ewBJXlQDG0 2VTiOsv0YIZmAQEO62jEHPIu8FxEDpIGbIyYoBtvxkF0SLb5TwSup5lPGAdQ WSjit99+S/GtW7dmaWDK8RfYyWLSpk1L2wfwOds6XEAOkupkbhas43dGysdv k9RJ+WiPKSVjIzWqDZDissTl/o99dnoAkaodwwJKYpPfyaTGdrrRSglJcQPi RL1jmN+3GMmd1UrLKv5AKAv6nQwFQSVb9mHnbkvmX0mKk6rNJzr9Tl5aKrK/ Hr/THnUOhU5X5dMTZ9hXLCXfbPhq/n8LQQ4UmG8UjwAAAABJRU5ErkJgglBL AwQUAAgICABImo9HAAAAAAAAAAAAAAAAFAAAAE9iamVjdCAyL2NvbnRlbnQu eG1s1V1bc6NKkn7fX6HwxImYfZBU94vD7Xnbh53uc52N2FeMkMwcJBSA2/b+ +s0CgSqrkYVPuCy7O8K2+Aoqb/VlZgH2zT+etsXse1bVebn7ckUX5GqW7dJy le82X67+51//NTdX/7j9j5tyvc7T7HpVpg/bbNfM03LXwPcZnL2rrzv0y9VD tbsukzqvr3fJNquvm/S63Ge7/qxrf/R1O1d3pG6ei8mnt4P9s5vsqZl6shuL zk3ups/cDvbPXlXJ49ST3Vgwqn/6upx68lNdzNclWH27T5o8kOKpyHd/frm6 b5r99XL5+Pi4eOSLstosqbV22aKDwOkwbv9QFe2oVbrMisxNVi/pgi77sdus SabK58b6Iu0etndZNdk0SZP84NX6+2ZyRHzfnDBNep9Uk2OjHYzdy1fT3ctX /rnbpLk/4ROz/AZg++Xb12MsVNupc7mxyFRple8nq9mN9s8vy3IQ1Z3QLdBW XEaIWHafvdGPLw5/rPImq7zh6YvD06RIB4uX2zGjwTi6hBHz7LsL0yHwnSHq EyewZQcPg+vVyUv/77evf6T32TY5Ds7PD57nu7pJdkfLVM4JJzWVyyrbl1Uz GGY9nTDBW2yQ7b7ZFqeXu0P7oZtqtRodCuLwJSx9WHjz73n2+DfEhy/Hg122 g9ASe/EMSpbtIJ81z53gxgwzQIAcKb7aDFloXT7sQAXIXAfzZU/7rModlBTt adfoCn7MF+VfuOQhc3lXQHSeZ0XPF4NKo5cpy/m2hvCBZVLur72zcXaotk/T LueWRrlah1cMaCKta96MRcO/fl86bO6SI9D/YSavKGBXt30FkDw0JXBbns5b xq5vbzquvwaBUifPJuuQWcfoTt4vVz9TejWM7L7NDp9WWZpvk2K+L5I0g8UM cX5Atvmu1WiTVfNVvskbQOnVcriOE/f2p5ul/3H4FIpze9PJ86Ns6T29OhxY J9u8eHaHXLj2p2yqZH8PCu/BtFnV5Fk9c+EJl6rKP+ECu3KXObGW3gwvTcde nq795E/W5SVn+Pm+rPOmdUpTPWT9daqyaUN2nuw2rpohTpoOckbxr7UuISyg fqvz/4OBlO+bQZj+8Bz4KNmdAl2eLbKnA/wKrfnH0Zq+pPUoeNSavk5r8WZa L18VjjOoiQ5HQPiihFrsb3fc/b/qRq/zoujHDgeGoZly/ycblLxk0FHwaFDy OoPKv2TQfJcWD6tsfp+vVtlunmZFAWSyTooa1H8h0jyoU9U/3FRZ0syz7b55 7q+Yb3ZlNQyo8s1904Xnap48OXbrXTlVXTWu7uFgm7/bH+c+z75oilVeA9U+ z4vkLiuwQkW5SaB2u9/maWCcKnPZIAMarrK0M9ABbxsqaDGy+R2Y48/gPNd7 zD0pnR3LhyoNLJk85bVne/JisJ+O7A8YrvrDsJ59QelRbNDZvk5lE1tl+/F0 tq+uIF6M4qnTUvLm9FA/b+/KYt4874dUMm0pT1yyj/nKNcZkQUy6HU1T0BNK o8ay0hGBXjtbQWlXuXK93aqSP33E5U9PlJaf2kHrtWBktGw4Ip/GQSeK8U/u oBVnZNxBPfJpHHSib/jUDpLarmg65qAD8hEdcaKV+dSO0BkhjI454oB8REec aIE+tSMMT5P1eswRB+QjOuLtm7PLO4JTAWXWmCMOyEd0xIku61M7IsnSNRlN 4gfkIzriRO/3qR0h7uhajVLTAfmIjnh9Q4r2EOuyyFdvt4k4eWf8RD/7l/ro EYnS9t+PEi1P3tw4AHfl6nn40Mp0e9OFYfu1leIQSVT1cXSfuf2/L1fWHWhv w1/fV9n6y9Vi0X/uwrrOnZv7wE6LpK4Pml/XadK0N1MPH73F4+5b9FI0eeOM CZNCsMgFp7QX4tnFNu+EGruGu7XT7uHtb++T+v7fZb6bLWd3RVluZ9/rxWyb 1DD/zfIw5mbpTdjPXj/cIQHUQgpfALpgWp4SgB8F4OTb7GlG4WtVPtY/zNlP 009bZJtst5r5H7wdpLuyAWde9TLxhe5kOMikF5q2jukC4XB69rRPdt1dL3Bn Ni5xmwM7YF+UzTypsmR0IBRq3SMjbnd4XiU76LeS1arKnH+LpNpki/+m190P f7hq4rBD25Jay2Vz8Em3U1u3Gt0P+tAF576N2YLygcH6UBQLLmwYjmIhGBw7 qFCW5XValhX0gEkD7WC2Ae37SdjCBpNwrsNJ2IJoHk7CF1ILODhYym3xDjvQ 2+xg5Kde585k+yrfJtXz/Gnc8L2FnMztlnG3fNyqHV8JeiGU9eRXC90Zaezq +hiIdVa4be7vefM8+/tP//ly9MMKzTZl5cjorLfZde/2jhePtnnZTs/jdno+ ZadRa5CFkBRZQ9GTy9IcrbF6qNr919nf24dsqmw1a8oDMZyxzabKV6OXtwHb bZN/l9UJk9RZ5dUDmAFJf53vSfGQ1fPTtv9nb/t/Hldau7K6c8LRdBj9Ii/3 Mq4gbwBzvjYAvAW/B+Zthtst+wyiagWrS3pG6QwxxSx0slm+9hJ9nWKWr3QY Pc0sb64Zm6zZt16zb1M0+0aH0RfSjE/W7Odes5+naPYzHUZfSDMxWbNfes1+ maLZL3QYfSHN5GTNfu01+3WKZr/SYfSFNFOTNfut1+y3KZr9RofRF9JMT9bs 916z36do9jsdRl9IMzNZsz/Yj2Xnac3+OBapETV7TIpiXC97TJVraEyq8UaG eFce6nIoYtqU3H49pOfujKJMk2LePcqIRs3vs2SVVa5pfNjuaox1B91Erztj 9GAvT/vEWj9wfjRWq/fy7MUOs7ueCQNwJJgWnNuXdT9cusOCI8PDgC6iDvU2 tNv5bnOsD8WxBmxb7g2061BhrrI6vf2hmoLOu8dulv3wNxLEnBXEq19iCkLV WUm8eiOmJJydlcSrD2JKos6HiZfPo3qHnQ8ULwHHFIXJ85HiZcyYokh6PlS8 FBfVQYSdDxYvKU2VBR1qyXGMxUd5dAqzjqkG+SpprhDSbjYrJoW0R5XJWX39 1vEtjX9CQm6FVlYzLpkWQnqShtB59vc673eQXGgqJLfGGiW18QXHyPlk4bXG 7yG3JUZaza3SjDFk8QA6n1y81vcdJJecchCPECGEksyXPIDOJyOvtY0uOV0Q QaVRnCqtCPOWY4icT11e4/oecrs3pyzTXHGjkNg+cD7LeU3pe0hNqVZKU0YF NQaJjZDzKdFrOd9DbsKUtJZSzlUQJQg5nz+9hvJd5NZEcEO4AtbTWG4fOZ9r vXbxryfbt0yglAng8fEE+tbpBBaUZooqCwymcD5BUDwJuKVaM00NFRwnBgxF k0AKJiBxSmBFayiSAEPRJFCSEsNcBgdexjbAUCwJJOdSgbKcUEQCIRJnfrdk KYfCWFLnbYkXs4/Emx8UZJDNBbMkIBMfiTi/keDj7mswv4fEm59Y0FDDMuNB 8kLIi/NHJkWjQQ76DqQIJR2ka86EgkwiBVoNGIomAXQehDNpiAD3YwkwFFEC TmDVG2ItNyyQwIdiSaAoM5wxKJ005QrZIICiSSAog26QacmkIlgCDMWSwFrX XmhNgXyNQu1eAMWTwEDVrSDatBKEYgkQFE8CTaAMFdpyrbjAEiAoohc0F1Yy SxE5hsgFyZFJQhnj70GOSlFKLLRg0P1KFBABFG1ZKqklrHzNKXgeSRBA0SQg RCoqNQMK1gxFRABFkwAWHlCPodT1OBxJgKF4NpCSEwkLX0F1rLANEBRNAkuN gLoEwk1Dh40kwFA8YlDcMun6eitIQE0IikiOoKExVkCbRlRAjj4UTwIBWhqt DYV0xLAECLogPXIKBKnlO9CjYtooSAaUQMNkgoWJoHh1E5GUCuk2EQgOiQCK JgGHhAzmdrsYTKCQCKBYEgDzaqNBSW40QfyMkWgWMIYBCTLIyVoSTE0YimYB CQ2jsoID/0iJJAigeMRABLdQn0LzrkRADAiKJwGsOAKFEeGcU44lQFBECUBV A0teQU0SJAgEXZIcIQ65MO9Ajlq73SzISlJAbkDbTAEUb1lwAV2zpQKYCO93 BlA8anJFEYfSBJoGfDspgGJJYCgH+uFcU6BiinYbAyieFyi0rJANrVLE4DjA ULxItNr1jcQISIcCRyKColED5B+mGIfSTEM+QNSAoYgSaAg0pZnmBvcQARRP AuO2dpmBbKhDGyDogvQouBaKqfegR6mNJO7hA8uM4nhZICgaNRBo3KFkFwSS o0JVQwDFIycNHbRrmaCHx9TkAdE8oJRrmi3EnWK4qQ2gaJWjhnoAnKwkLMGg dsZQPA+ApaE00zAfR3EfQvGqJmiPOHRJRjIwOK6aEBSxdpVtp2Cs1jKsXX0o ZvUsNIVuTcEPPKyePeiS1GjBH/w92moj3ZaaczskJIGJCUPxloUUFPjPdbAW 7/kFUDQJGDHQuVMhGFMcS4ChaBJAyFMIOqmt5BRTA4bi2cDde4NCnQiqFU4Q GIq2MIF8wMkUWBiIAEViAEWTgGsIdkIsdw0LpgYMxazbKDNGGC6U4mHd5kER JRBCuYZJQ5FoAwl86IL0KKGGf5cb1pYwYyEhUHePHnczARRNAgolctu1UCiS cMLEUMTCEQoDlxqlBV2D0tGH4nnBzSGVhTTEsAQBFI+fLYeYJ9aAtTEzBFA0 CaAu4u2TSloSivkZQ9G8ANNAnSwNg44p4CYMReyrJVfCGs64xs+TBVA8CZTg lltpjTQi6KsRdEF2hC7KSPoe9Gg0NI3QN8DyAzLCG14YiuYQSTS17ikJqBBx RCAk2vzMAAFBjahhFVJMzxiKF5K0jTnhIj+4UYmheHsbgilwMuEWAh9HAYbi eQF4D0p1rsDQuGZBSJz53ePzUBlRLYXb2cNPeiMkXgxI6BHA0QpyIMNlCoYi SgDrjLndZWrwU20BdEliNJoLHv9ZnvZ9CvdkqRZaExm+aeEh0dzheM/A4ic0 uEuKkXidFFdaKALrX0rc0wdQPA9Aw+ZesAAzc/zcLUIiWsBVJERDUSa1Cizg Q9Es0LbrnFqroDjFTx77SLT5XZRxzYhk6EnbEIlHSe6mI6cwkdtTxJSEoIgS aO2eR6CKBrs6AXRBUtTCKq3jvxIDblfC7WJpHqyIEIm38ws+hzrEamaMDp64 RVA0C0AlAOwDSx+axeBNNh+JNr/kriaX7s0LXKb4QDT7C2XdGy+Q/ajFOQEh 8awvqCCCu7cGCX4VBiGx5qfCPdLMKCc6MD9G4tEREC+U4sYSK4LNLAxFlMA9 2w65lzHBAkJE0AUJERoF99D3OxAiBYNzJZRxb1tQFBAIibYgLBfAvJRxHr4P jJBo80MxbrlrTlDjGgDRrK84o8K6zWzL0PQYiVehcqg+gPmsNkF9hpB43oeL WyEN10bjN/MQEo8OpbvLCb0xFUpjOvSRePuZ0AtZAV0YcU/u4v1MBMWTQEMf KBRV7slh3DRj6JJ0CHIo9Ph5tICAngDSsCuKGUMLAiPR5mdAuW6rAooR1K8g IN5yFNCOKqmUiz28HH0kmvZQeRje/lICajEdIiRiwy7cPqmVjEsdNOweEs/7 DHpi15e5rSrsfh+JZ38KBahi7v6yxeGHkHi1GVcEkn67Yxm8coOhiNUhlQI4 1wpjRFgd+tAF6RCYSPB3+A0SjvRcMQykxy0xuDpESLT5jXunhVMqjAjqI4TE W5CWEmYJg7AL6gOExJqfQQnOgXGA86Ae8+fHSDRCBO9SQqEjppThdhUh8fyv OHX37yDtKYn97yMR49/tkXJtpTIsiH8PibeHzt1vK1NGSMhAeP8QQxHvdzu2 Icr9jpLwaSAEvZIQwyM1PnTb/z7Uw5+s6P/ORfCx++sW/af+T6HP03LXwPfb /wdQSwcIJKangQwRAAAkhAAAUEsDBBQACAgIAEiaj0cAAAAAAAAAAAAAAAAT AAAAT2JqZWN0IDIvc3R5bGVzLnhtbJ2V23LjIAyG7/cpMu61QxxvZxomh7s+ QKf7ABRjhylGHsCHvn0Bxy7uJinTS1vfLwlJiP1pqMWqY0pzkIckW2+SFZMU Ci6rQ/Lv9Tl9Sk7HP3soS04ZLoC2NZMm1eZDML2yYqnxaDwkrZIYiOYaS1Iz jQ3F0DA5iXBIYx9q/OOdxco9HKoNG0ys2LELLXmLj+zhUF0o0seKHWtrGspL iBUPWqQlpBTqhhj+LYtBcPl+SM7GNBihvu/Xfb4GVaFst9shb50TpjPXtEp4 qqCICeaCaZStMzSxsq3fmIo+HjHkv87ororualfdOB49ExXdXw8vW5QX8S3K i0X6VPEmOvRIh3oAmMvtBOPg+6JvN5u/aPwO6P4u3itumApwehenRNC5ClBf GxDLZcgSKetc+ydauUPf9PyIFGtAmTmRMv7i2+ps57E9m1rcHltnndBKFcVV 1KaTIzvCdvjSjrP+YXGv79d/hzy0GLO7imyDPBTe/p8Ejpkj2IZ8rSpVzcu0 hFbaI9gFfCkfGxqmuDMR4WV44SGcMQG/cHnZwIGHxYXTOjfXqv36gpwtdUvU romLl+Dt2CbH6aEY3wd03KPrL8fxE1BLBwjlqOG4wgEAAHkGAABQSwMEFAAI CAgASJqPRwAAAAAAAAAAAAAAABEAAABPYmplY3QgMi9tZXRhLnhtbI2SPW+D MBCG9/4K5GbFx5fSYAGROnSK1KWVukXUvhC3YCNjQn5+gykRraKqo33P+X3s c7Y9N7V3QtNJrXIS0oB4qLgWUlU5eX158jdkW9xl+nCQHJnQvG9QWb9BW3qX VtWxqZST3iimy052TJUNdsxypltUcwtb0swFTTvnWqrPnBytbRnAMAx0iKk2 FYRpmoKrzqjgV67tTe0owQFrHBM6CGkIMzsa/ldqZJdKWutr0IhP0i4uCoIE pvVMV0aI+tYFLmwMF8PSlv5J4nA/d/BjaeyfIWEADiLe94MtRhSRYp7HKF5k Tr9Chaa02hQ7+W7w2QGQ0Jg+0Gi1k6o/79826/068RbAvjX6A7mFJA5Wj72s hR9l8OvADH7Ewa3PUHwBUEsHCFRuHHciAQAASgIAAFBLAwQUAAgICABImo9H AAAAAAAAAAAAAAAADAAAAHNldHRpbmdzLnhtbO1a33PaOBB+v7+C8TvhR9JQ PIEOoc0l11ybwSTX9k3YC2giaz2SDKF//ckY54hjN45tZW46PAGW9e2y2v12 tdLZhwefNVYgJEU+sDpHbasB3EWP8sXAup1eNN9bH4Z/nOF8Tl2wPXRDH7hq SlBKvyIbejqXdjw8sELBbSSSSpsTH6StXBsD4Mk0e/9teyssfvLAKL8fWEul ArvVWq/XR+vjIxSLVqff77e2o8mrLvI5XRQVFb+9LwoRHwVFE2JltsK67fZJ K/5tNXZK7pmmaw0TOyR/f3i2ExB/NKkCP7JNY/c4Um1gaZH2isL60WpW1ryn c+6opDMGIwFkioGVDKpNoAcpV9awfdZ6DvIq4GuYKzPI/1BPLbOg37V7vePK 8JdAF8tM1d+3253C6jd9EjQp9+ABvLQsWGev0naO9i+xKaIxrK+8lJpSCe0C 1jByiM6rNI1AU3pOibbIS4o+neKiHxBBJfICXjgOhURxg5IqHQTfsizeOSm3 nE+hv2dB98shX6KgP5ErwpyAUfU3epBegyWKCn4OQlHXFHpK+8RAdcbpvv4G 8EeuoivYok8IX+SYp1sOPNG3Zu5KYCd5xFIRt14OT1DPUSn0awT+gehPNUqt Hh2B3hEWplFj+miXtQFZQESwZtCdJa7/FDRN3jNEBkQzpxIhZCNnPPx1zsgj akaEjp1aOLokkRag6E7hFHbg6ANHHzj6wNG/FUdLnzBWD0f3zHH06YGjDxx9 4OgDR/9GHJ03vG2SFI2tbfskpz/zX5+kMv+4AhmbEZHbFev0+iXD+OBoe44W STgXQO5vBETttTynmxMmc7yuiJgfIHD7B+TrvboI/hdUpqDLheJLyBHqGBmK FDTDKJA63dPjbvddySLkyboasMolkVr10OcTXF8C8UCYEeIsAZTmGwPoV/Jr qBjl4Gz8GTLpQDrz1iLE4SSY4oRIBemFriOyYuAruWvzG5MwAanXO7+d3e2V ZKA0fHYtXhHeCWceXVGZq35N4NnKl3WdGH70QKWz4e5SIKc/4e1qgt0RT/YL ElTxU7z4QShItMCvOc67RuJNNL0gZxsTaYms4C4+qfzKxwylifi5kh93h6vO koj89ask4jMIPpKU8JuQuyokGXuqOgSNgoBtbiWIj0SR+tlyrA1EXO3zY11F CpDRwtRept3oQjWKWlBhelM0IxJOT84pJ2JjtQpDfdE/ssvhAhi3gUcUXAhd kIIfMP29fruOQoVjwtzQDPwnfwbehS7ac7P0/zrBvVGONpSD3qSMGTGm68nI 2//C2ZhwF1j9QgwXGmaryWvK7+NQzm/JlbzBUV8h8GI+rH3XkH9X5ALFjHoe 8EfSr35z5JrwRUiet/x2vQko2ZMYYxjJz0G9dUr2QYnQ+TodrMUTxzksKNdu Vz71fOLeL+dXrRsLRKT5TaTpXbaZ3oDRnYXhLZfhZkyVPlLuTqb17IZiK+/u 5vBfUEsHCNu76phMBAAA/SkAAFBLAwQUAAgICABImo9HAAAAAAAAAAAAAAAA FAAAAE9iamVjdCAzL2NvbnRlbnQueG1s1V1bb9vIFX7vrxC8WKB9kDT3i+C4 6F6Sl00f2i3QV5qkJO5SokDSt/76niFFiWdMKXTgsewN4IT8Zjjn+s05QyZ7 /ffHTT65T8sqK7afruiMXE3SbVwk2Xb16eo/v3+emqu/3/zlulguszhdJEV8 t0m39TQutjX8PoHZ22rRop+u7srtooiqrFpso01aLep4UezSbTdr0R+9aNZq 71T1Uz56ejO4P7tOH+uxk91YNDe6Hb9yM7g/Oymjh7GT3Vgwan/6shg7+bHK p8sCrL7ZRXXmSfGYZ9s/P12t63q3mM8fHh5mD3xWlKs5tdbOG/QgcHwYt7sr 82ZUEs/TPHWLVXM6o/Nu7Cato7HyubF9kbZ3m9u0HG2aqI6eebW6X42OiPvV CdPE66gcHRvNYOxenox3L0/6czdRvT7hEzP/CmDz4+tvx1goN2PXcmORqeIy 241Wsx3dn18UxUFUN6FN0EZcRoiYt9e90Q9nhz+UWZ2WveHx2eFxlMcHixeb IaPBODqHEdP03oXpIfCdIaoTE9i8hQ+Dq+Tko//79bd/x+t0Ex0HZ98ePM22 VR1tj5YpnRNOairnZboryvpgmOV4wgRvsYNs63qTn053h3ZDV2WSDA4Fcfgc Uh8Sb3qfpQ8/ID48Hw923gxCKXZ2BiXzZlCfNb81wY05rAABcqT4cnXYhZbF 3RZUgJ1rb770cZeWmYOivJm2QE/ox3xefMcj9ztX7wmIzrM07/jioNLgY4pi uqkgfCBNit2iNxvvDuXmcdzjXGoUydJ/okcTcVXxeigafv/X3GFTtzkC/e9X 6hUF7OqmqwCiu7oAbsviacPY1c11y/ULECh28qzSFpm0jO7k/XT1T0qvDiPb 3yb7qySNs02UT3d5FKeQzBDne2STbRuNVmk5TbJVVgNKr+aH5zhxb368nvcv D1e+ODfXrTzPZYvX9Gp/YxltsvzJ3XLh2k1ZldFuDQrvwLRpWWdpNXHhCY8q iz/hAdtimzqx5r0Vzi3Hzi/XXPUXa/clZ/jprqiyunFKXd6l3XPKom5Cdhpt V66aIU6aFnJG6T9rWUBYQP1WZf+DgZTv6oMw3e0p8FG0PQW6fTZPH/fwC7Tm 70drek7rQfCoNX2Z1uLVtJ6/KBwnUBPt74DweQG12A+33P26akcvszzvxh5u HIamyv0abVByzqCD4NGg5GUGld9l0Gwb53dJOl1nSZJup3Ga50AmyyivQP0z kdaDWlX7t+syjepputnVT90Ts9W2KA8Dymy1rtvwTKbRo2O3zpVj1VXD6u5v Nvt388dpn2fPmiLJKqDap2ke3aY5VigvVhHUbutNFnvGKVO3G6RAw2Uatwba 401DBS1GOr0Fc/zpzXO9x7QnpbNjcVfGniWjx6zq2Z6cDfbTkf0Ow1W/G9az Z5QexA4625epbEKrbN+fzvbFFcTZKB67LCWvTg/V0+a2yKf10+6wlYxL5ZEp +5AlrjEmM2LizeA2BT2hNGpoVzoi0GunCZR2pSvXm6Mq+eN7TH96orT80A5a LgUjg2XDEfkwDjpRjH9wByWckWEHdciHcdCJvuFDO0hqm9B4yEF75D064kQr 86EdoVNCGB1yxB55j4440QJ9aEcYHkfL5ZAj9sh7dMSJ5mxso14VeZa8Xqc+ Wuxv9CQvKlYHJIqb/55LND95grgHbovk6XDRyHRz3YZh87ORYh9JVHVxtE5d kw0Fu7vRvOtarMt0+elqNuuu27CuMufmLrDjPKqqveaLKo7q5o3F/rKXPO5w sJOizmpnTFgUgkXOmBCdEE8utnkr1NAz3Plp0yjvbtZRtZ78UWTbyXxymxfF ZnJfzSabqAIBruf7Qdfz3ord8tXdLZJAzQSXPQnojGl5SgJ+lIAS8nXyOKHw syweqmeLdut06+bpKt0mk/5Fr1G7LWpw51UnFJ1ZynpCmRmjurluQmE/PX3c Rdv2cBkcmg6LLFwItcAuL+ppVKbR4EDgw/bNrDuEmZbQJULGJ0mZNh527wXL rCq2s3/QRe/qi0vf/ZFIQ3ANr03BP+3RSNXotu5pxjntacZmlB/YrAtLMePC +qEpwCZu5F6boihAjqKEqiuqoQBLV2CIbhU2s94q/PkqbEY0f74K0W7mwWju UOVw5rNJ9/Z+7JRurbcrs01UPk0fh33QmcjJ3BzStLnkUng4LfRMq574esb4 yazQx5is0tydK91n9dP5JIBMTVdF6UhpnM/ZAkVAy5RHA5031tOwsZ5OGWvQ JGQmZN+lamaUOGUTc7RJclc2xx6Tv7YapMmkLvZM8bfzVlqVWTL4eOvx3yb6 oyhPmKRKy16FgDmRdM+5j/K7tJp+wws/IS/8dMy8JtPa2YPzKJ53lr07uRPY XYBevz88eqSwA6KuD2eguxSiL4EElD2TtWYaYzT6MqP9jGT7ebTRfqZ43jij vbq27GXa/oK0/WW0tr9QPO9C2vKXafsr0vbX0dr+SvG8C2krXqbtZ6Tt59Ha fqZ43oW0lS/T9gs7UWZ8Q9svXnkSUNuHKM+Hde0R4BKq03J4lO49+VCbwcbV UG7zc0+/7Yy8iCPoLpuvRtCo6TqNkrR0rcPdZlthrL3pFnrZjMGbnTzNxwHd wOnRWG1d8M2H7Vd3dTMG4I63LLi528qfPbrFvDuH7y5clO0LLWi6su3qWBOI rz8dd/6m9VpB2wZ1RZJW8c2ZnRN6sW7U9byb+EpCcTZWKn9rCimVGm0rfwsJ KRVlZqxYPteHFItJNVYsn5SDWuvLSKF87hwr1PxZDg+RzWC6jyGAIR2BVqP6 CiHNyZhiUkh71J2M0/xZBfua/jghK7dCK6sZl0wLIXsy+9BIsvLbgzfQQXLK pdWECCGUZH0dPGgktfnVenAd6IwIKo3iVGlFWC90fGQkDfoV+Fto4L4Atkxz xY1CCvSBkXzp19RvIT+lWilNGRXUGKQAQkZSq18nv4UGRBPBDeFKcquRBggZ ycN+7fv9RPya5EqZsMYOk+vr0ooAmwH9KaoscIfq04oHBZNASUoME5o6DkDk 7EGhJJCcSyUF44SqPi35SJj1XeBSTgmTVDNNJQ7pPhJufVCQwR4imCVeSvWR cOsTCytowSX3SAkhZ9cPnJBGgxz0DRISNnKgYc6EAj6TAkUjhkJJoKDm54zB dqApV0gCDwomgaAM6jKmJdT5BEuAoVASWOsKKq0pJL5Rpi+BB4WTwEBNoQyB +lQQiiVAUEAbaC6sZJaitPSRC6Ylk4Qyxt8iLZWilFgo76DalsgdHhQsKcDl EPSGUlffcJQUGAomAZGSEwkhpyQRqFbwoGASWGoE7AZgag31KpIAQ+GSQnHL pKuSrcDU5EHhJBCwhtHaUKAhhiVA0AUTk1NITS3fIDEV00YBDVECRZrx0gJB oSTQzGijhSXcaIJ4EiPBLGAMg/RjwIRaEpwUGApmAcmMhC6BQ+RLiSTwoHBJ Aa2fhT0ZimUlvKRAUDgJoEQWBoJNUdgcsQQIumRaQhRwYd4gLbV2vRtQsRTA Sqip8qBQEhhoW6B14ZpaSH/UV3pQuLSgUCACB1mliME2wFA4L1gN1bIlRghJ BfYCgoKlBTAfU4xbojQwEUoLDIWTwLgWmhlgQe1LgKALJqbgWiim3iIxpTaS uCNvy4ziOCgRFEwCpVyZCu2DUQyXkR4UbMfUwMSgpJJQK+HdwoPCkRNUaLAl QSNNOPK7D4Xbr6Ak4lAZGWjjLE4LDIXcswXU6lRAIy+4v2f3oEsmpgVr8Lco ZA2UR0w4o2sOnQwKCQwFk8BqTcHgUlvoZHFQYiiYBMydbnHBiKBaoS7bg4IF JYQ9sB+0sQZKFOQFDwomAYdeQRJiOSiLGxoPCrhjCqE0cKCGzdF6O2YfumBi Sqgc3uRA1hJmLFARdWfQuIbyoHASEOBD6KIg+ZnEEYGhcMxgOfibWAMFG45J DwomgTaGN2+BoIWhmBkwFMwLsAzUBtIwqJJw4eRB4fJSQSfLrbRGGuFVsgi6 YF5C3WYkfYvEhPYBagTDIfgtkDIOCQSFcwhtLC44A2ZW2CEICmYDIpgCFQm3 4HZsAwwFswGDnDOMcGWot1cgJNjLQwY7EtVSgKoaf1OCkHAxIKl2/ZJV1Bh8 8oShSyal0Vzw8O9Jmu9gNHVvbDX09P4XMj0k3PpQIlF3tkNgT8br95Fw1RvX kisCvTQU7ZgSMBTMAk2BzKm1CjZl/Da9jwRb3wDxcc2IZJCAaH2EhEtIprU7 8aaKel2MB10wIbWwSuvwH/iA0ZVwXZvmXjz6SLD1JXc7sXRfkmB67gPBgkEo 677gAd6hFr/DRkgw7amggkDr7g518Kc9CAm1PhXuRT2jnGjP/BgJl4zEfa0A rMuYYF4yIuiCyQjlifuQ4A2SkRIORalQxn0/Q5E7EBJsfQU9s7CuebcMkQFG wu3OHFokyDzomLy9CSHB1rfwcCuk4dpo/KUbQsKlo3TniVCTUqE0Tsc+Eq6H 1VB/CUWVkBD0uIdF0CXTEeRQ6MOGYO6AagRI2BUEUJEgdyAk2PrAvIaD2yHl LU5HhAQsloV2zZlkXGqvWO4hwfRnDOpRV5W5Jgnpj5Bw9qewASvmTlOtwPbv IwF3RyqFhGpcGCP83bEPXTAdIRMEf4Nv0V3SuWIAko5b6NRwOvaRUOsz2II5 xDtkHOxG/fUxEiwdQTtKKNSjlDJcLCIkmP3d38BxZ2ZMWYXWx0hA/7vumGso zA3z/N9DwqWjdrFOlPv7Bt4JL4ZemI7+nQrfuun+avL+3xDq/uEh77L954a6 K///bHLzf1BLBwjPv9zw/w0AABplAABQSwMEFAAICAgASJqPRwAAAAAAAAAA AAAAABMAAABPYmplY3QgMy9zdHlsZXMueG1snZXbcuMgDIbv9yky7rVDHG9n GiaHuz5Ap/sAFGOHKUYewIe+fQHHLu4mKdNLW98vCUmI/WmoxapjSnOQhyRb b5IVkxQKLqtD8u/1OX1KTsc/eyhLThkugLY1kybV5kMwvbJiqfFoPCStkhiI 5hpLUjONDcXQMDmJcEhjH2r8453Fyj0cqg0bTKzYsQsteYuP7OFQXSjSx4od a2saykuIFQ9apCWkFOqGGP4ti0Fw+X5IzsY0GKG+79d9vgZVoWy32yFvnROm M9e0SniqoIgJ5oJplK0zNLGyrd+Yij4eMeS/zuiuiu5qV904Hj0TFd1fDy9b lBfxLcqLRfpU8SY69EiHegCYy+0E4+D7om83m79o/A7o/i7eK26YCnB6F6dE 0LkKUF8bEMtlyBIp61z7J1q5Q9/0/IgUa0CZOZEy/uLb6mznsT2bWtweW2ed 0EoVxVXUppMjO8J2+NKOs/5hca/v13+HPLQYs7uKbIM8FN7+nwSOmSPYhnyt KlXNy7SEVtoj2AV8KR8bGqa4MxHhZXjhIZwxAb9wednAgYfFhdM6N9eq/fqC nC11S9SuiYuX4O3YJsfpoRjfB3Tco+svx/ETUEsHCOWo4bjCAQAAeQYAAFBL AwQUAAgICABImo9HAAAAAAAAAAAAAAAAEQAAAE9iamVjdCAzL21ldGEueG1s jZI9b4MwEIb3/grkZsXHl9JgAZE6dIrUpZW6RdS+ELdgI2NCfn6DKRGtoqqj fc/5fexztj03tXdC00mtchLSgHiouBZSVTl5fXnyN2Rb3GX6cJAcmdC8b1BZ v0FbepdW1bGplJPeKKbLTnZMlQ12zHKmW1RzC1vSzAVNO+daqs+cHK1tGcAw DHSIqTYVhGmagqvOqOBXru1N7SjBAWscEzoIaQgzOxr+V2pkl0pa62vQiE/S Li4KggSm9UxXRoj61gUubAwXw9KW/knicD938GNp7J8hYQAOIt73gy1GFJFi nscoXmROv0KFprTaFDv5bvDZAZDQmD7QaLWTqj/v3zbr/TrxFsC+NfoDuYUk DlaPvayFH2Xw68AMfsTBrc9QfAFQSwcIVG4cdyIBAABKAgAAUEsDBBQACAgI AEiaj0cAAAAAAAAAAAAAAAAbAAAAT2JqZWN0UmVwbGFjZW1lbnRzL09iamVj dCAx7Z1/bBxXEcfn7POPi2P7bJ/tJnZiGzetaRq357OdhICJc3VolB926lMv SCip2ybBbWMH2w0NlSCFpEWlKlAlSBWl/AFq+aNNQYGaKFJEgUIARRWEIqAJ lEZN07SuhNSkgCKbmfdms+v1vovudje3Z+9J797uzu7O+8z37eze7lv7zviG jYm1AYiC/ASgDoyf8UUAqxsAvl8BcBAL7OsCaGkGuJgH8A1cHSuYmnoEp8KG zb6Ca93YrK/RCF/FqSacyhMO8sRS+tBagSvb4NJDOBtk43d48xAcwKkC4WoK Avt5RnyGcY1W0fKCae6NzdAc6Z/U++sU+ysU5C28XYth+31dek3L9fW0XR05 coTaHoAncaYatvR1J27vT9zRu75nW3/P5m1rej6zbpP0Rp4GxXcMvwuhGPdT WwswWqLXTSGAZz6h17RcW49DpNczP4Fpc9OaeMCIvgvyoT+jRgRh4Qw/2keK iaHArgRVM0LRs+k2y5bRFkOpg9crfK4T31XkQ7Srhttb43xwYpZOvAS/PiLb RbVr8EYnXoLfVyHbRbVr8EYnXoL/WZlsF9WuwRudeAn+QolsF9WuwRudeAm+ MSTbRbVr8EYnXoGn9rzgdrY3O/HhPQD/r4hsF9WuwZud+PAegO9bLNtFtWvw Zic+vAfgj98o20W1a/BmJz68B+CXRWW7qHYN3uzEh/cAPF15Uru0n9yuXd4a nfjwHoDXrjhdhTc78Qr8mXnX4DaW2YkP7xF41+/hmZ348B6Bd/0GptmJD+8R eNfv3pqd+PAegXf91rXZiQ/vEXjX79ubnfjwHoDXrjhdhTc7cRZ+uGG9hP9L avhx4fMn4vth/C6HHZh868MAW/D0WxWWF2AFWHdhWyfLAW7BZv4H649hWyaw jjQCvIt1YTPAOaw/WgLwT6wvtACcwfrMUoB/YH2yFeAs1q9EAc5j/dN2gA+w /tFygPfKrxrkxGo9ODRtQp0R5O9mFUYTs88RMeG1wzbEXMz8wPyvl0v+c8zf z/xbmT/G/FuZ/9PMv5L572D+1czfxvzvMv+/7YgpUFOImQ0YZ8UMro7aELOK +UPMf5n5LzH/+8z/DvOfZf7zzN/F/IfKJP+qMsl/olTyJ0ol/8X5kv/++TbE FKgpxMwGjLNiTv3+azbErGP+cuYPcGZ6qFLyT1RI/g/Dkn88LPnHwpL/Oeaf ZP4hE/9B5r++VPIftiOmQE0hZjZgnBWzCb5sQ8wa5l8YkfwPVkn+4irJv7NS 8r9dIfnfZP49zB8MS/6t2mmG+TeWSf53mH8H85+yI6ZATSFmNmCcFbP+e0kb Yu6ISP4x5v+I+e9k/mPM/1vm762Q/D9g/iLmX8z8X2L+Xub/FfOvYv7LdsQU qCnEzAaMs2I2npqyIWZ1teSfYP7PRiR/kvm/xfyXmX8V8y9l/vs5M13izNTN /G9wZvo287/Kp5njdsQUqCnEzAaMs2KWrbEj5hLmf5H5A8z/Fp9mapj/TeY/ x5npZubfy/y13JmfZv5Xmb+R+X/D/I/YEVOgphAzGzDOivloD9gQ83rmf4r5 L3BmqufOfJqvGe5i/pPM/wJfAC5l/jruzJOlkj/MmWmI+W9j/jV2xBSoKcTM BowzYtJK2CCogS2Jni2JbX3d6zYl+m/v7uvRBaTP4+ipG+t8WCWoNwzevX1k YGxweKixf2BoVK40EKBXNugOhxanUPCKo6l8UX2dgx+Ax7SrS3rL41HQ3yv5 Aq5Ar3A8HgLYtADESrdCK5ZbAYOF87TkKJZmdHgayyHc46l8shjWy5P3dEJM 1tMbN0KbTAG1KU9tylebgkpTUm3aoG5hn9G0GKvITMVyQNe1WD9TKXUtxOm2 acoWimWk7IhB2V708ESQrG25oG+8QGlKqk1zQ/qSel369rSkb/elz23p9y7R pe9MS/pOX/rclv58qy79irSkX+FLn7vSk+P/LZfSF+F0VAipi18klmri35yn i1+Mu+kpoDVM2+RgF4gXqnuH2jT7ewclhgm0frNWJoaOtBJDR473ijmdGDTp fx2R0i9PS/rlvvS5L/1/K6T0K9OSfqUvfe5KT47b0dparl0ORDO4HIjmeBfw LwdS94575mu9I5ZB74j5vWNW946nQ1rv6Migd+T6ReOs6h1/cK53fIB1VTVA Areiv1/1eRiAUfy+D4ZhEIawzbdguRsewPlh2IXTe9DeivUuseYYbIcRoG1p a9obXXr8GD0/i3ucwHKae1E7hvnnWD6J3e0XWF4qBpjE8j72y7/PA2jD7PUy lt2lAPEygBNYNuD57odhgKfwkmdHJcBrWI6jDp+LkMcM2zq7em+8SG0qVpqS alM8pDbNU+9QbYqXqE3z1aZStalMbSpXm8JKU1JtileoTZVqU5Xal9oUj6hN 1eodqk3xGrWpVm26Tm1aoDYtVJo8mkX3O5dFn8T6PozNW4XkTbtdtxHb+hCW KE+PYFb6IoyKFtFaf8byPDbiYc6WdL59BctS9DOF5U+4t4t4eG/Dg/UslnHO lIdLaA9X8eHVLJfiEa7jp+/McmNOJ0DnjrUZY1XSfiGERpFvbgDor5S1w2NI YpZOXBp1lTb8yWrZnonrbMJbj4aKWTpxafxg2vA762V7HmuwCW89ri9m6cSl kbBpwweaZXuabrAJbz1CNWbpxKUx3WnDJ26S7RlbZhPeeqx1zNKJS28nZJTw 4k0yF1GdMbz1WwN6wjM6cek9m4wSHrWHcpEteOv3X/SEZ3Ti0htjGSU8ag/l Ilvw1m9y6QnP6MRZ+CvvPmaU8Kg9lItswVu/k6gnPKOT2T2Gky7PxvEA/12D jFW72ISmjoqp9vQu8D36C8zhgG1eoAdshSlgK/yATQ8YHkbwXoMMGK0eFX8b Xv75eu1mcJ5c6tBPybkR0wM36DGNQZtFTMVSP6ZpxPSvy/SYdopcaI5pZ7oZ cU7HtBXk2eVYE/mkY79NJMx8MWd8FJSv2dy/nTQ3wk7nKC3sbdAhkq5V2Nnm h92ZsNOZTgt7h+jT1mFnmx92+2Gnnk0nw2NN8oKc7lC3ieQdFPPGwL+dR0uv rJHVe9ceVabL2acVO/Gn0et18mnFKGyHB7DcA2MwCHuwjMFebHkLLIGPg/a0 QtPrl/zEYiH6HMRyFMungnKYGT3rvQv9voRlAT/rfa6I9nAVH159WnEtn8lm 9twhxcOFpNPPHZJZfiRxDQ6o/bKbpHdATWK9Frd4Fk/udMvhXngQRmBAdPVh MTChBTs+DUnYjUtH8DC4F5eN4ZLpQxPoYFsk9mAex0kJsp0HVDyPri/xgUaP CWlQxRvY4w5i19oYko8Jd2OHuQnl34vlRIl8hfmPWD5EBV+kP26AR/TLWIbD AH/DQo+5F9lpt38A+4MqTKaMRk4kMxpUMVtHTsTr1KZ6NZfa5FwufoLv4Wbw jxC1TbX6/1BLBwgPtR2VCQoAAKtxAABQSwMEFAAICAgASJqPRwAAAAAAAAAA AAAAABsAAABPYmplY3RSZXBsYWNlbWVudHMvT2JqZWN0IDLtnX1sHFcRwOds x4l9l/P5O3Y+bMckMQlxYt/FMU1q4hwXEuXDTn1w+aNScMgHRk1sHFMSFUEL +ajaEmibBgGl/BM1+QPaQlCDVaj4kFBbFKoqoRRoJUIV1AKBClWgINFj5r3Z 7Hq976K73e3t+fakd7O3s7szv5nZd+9239qfiG/bntwUgC6QrwDMB+Pr4kKA DS0A360GOI0N7u0D6GgHWFsK8CBuXoLr0un7cCli2O1LuNWydn2LVvgyLrXh UokwUCLW0ou2CtzcB9c+hh/LWHmGd6+A47g0S5hKQ+AYfxCvUdyiU3g+a4p5 oxuaIf2V+Xg94njlgryD9+sw7H9vny5pvb6ddqgLFy6Q7wE4hR/qYddgf3Lz UPKOga2J3UOJnbs3Jj62ZYe0RpZGxHsU38thDh6nsRHgcFCXbRUAj9+mS1qv bcch0uX0V2DKpykuHjeiH4RSGMrJiTJonmZHe8lkYiiwlKB2WigSOz5q6Rnt cShz8AaEzS3ivZZsCL8a2N8G54MTtTTiJfjGek5avYvwRiNegp9XK/0i6Rq8 0YiX4JurpV8kXYM3GvES/Pwq6RdJ1+CNRrwEv3Cu9Iuka/BGI16CXxSUfpF0 Dd5oxEvwrRXSL5KuwRuNeAWe/Pme29/zZiM+vAfgr9ZJv0i6Bm824sN7AH5w kfSLpGvwZiM+vAfgn18m/SLpGrzZiA/vAfiVXdIvkq7Bm4348B6Ap5En+aVd bHFteGs04sN7AF4bcboKbzbiFfg3Kt+HC5hmIz68R+Bdv3prNuLDewTe9UvX ZiM+vEfgXb9ubzbiw3sE3vWbFmYjPrxH4F2/Y2M24sN7BN7121VmIz68R+Bd v1dnNuLDewBe+5XpKrzZiLPwoy1bJfyrmeEvCps/EO/34HsV7A8DBLED3oUD r2aUW+sAOlD2oa8rUK5CN1ehXIy+rENZ1wqwBmV5O8BtKP+zBOAjKP/aAbAR 5RsrALagvNQJsB3lz7sAPo7yRzEMPcrzawFuv/W3SnKDHhxaNqFOC/K38wqj JXPQkWTCy0/ZSGYD89cz/weYv93Ev97Ev4751zN/P/NvNvHvZP5NzH/UTjIF aoZk5gPG2WSWbeiykcx0SPI3Mv9i5l/K/GuYv4/5u5j/p8w/xPxXQpK/NyT5 zwYl//mg5L8UlPzRW3/rq5MpUDMkMx8wziYz/dJXbCTzbeZvYv5lzL8qIvlP V0n+gSrJ/7+w5K8LS/47wpL/bS7mGi7mGyHJ3xqS/G8yf7+dZArUDMnMB4yz yWyDL9pI5g+Z/5fVkv+ZiOQPVUv+D0ck/xnm3x+R/H9i/kXMH6mS/L9i/rPc M11l/ldDkn8yZCOZAjVDMvMB42wyF3wnZSOZL1ZL/vEayX+D+a9xMb/CxXwj LPnHqiT/YuZvZv6tXMyvcc90mov5C9wz/YaL+SeVNpIpUDMkMx8wziaz9XLa RjJX10j+U8x/vlryz+NinuRi/h0X8zvcM/2F+f/J/FfmTi3md5j/KS7mFVzM l+10swI1QzLzAeNsMsMb7SRzD/PfyfznmH+ciznN/I8wfy0X87vM/y8eM3yL +Y8w/3LumTqZ/yoX86CdZArUDMnMB4yzyTyRABvJXFor+fcyfyvzj3ExX2b+ FPOfZP6vMn89F/OBsOR/i3umI1zMdczfyfwxO8kUqBmSmQ8YZ5JJG6FD0AC7 koldyd2D/Vt2JIc29w8m9ATS6wG01I+yFNYJ6m0je/aND0+MjB5qHRo+dFhu NBygB/ToCocWp4qym4bSpULcz8EPwEltdEnP9J0A/SnCz+IG9MDeAxUAO5pA bLQaOrGtBgwWfqY1k9ja0eDr2B7DI14uJY1huxJ5TaeCyRIDcSO0SRVQq0rU qlK1qkypSqlV29QeDhpVi1DUTc9YAeR1E8rHa2Rey3G5e0pmy8U6yuy4IbMD aOGhMtJ2F0J+47OUqpRaVRypDy7QUx/LKvUxP/WFnfqjS/TU92SV+h4/9YWd +rc69dT3ZpX6Xj/1hZt6MvzftTL1s3G5SyRST/5ssVZL/odK9OTPwcMkZtEW pn0KsATi5erqUKtmfnXQCP9JDMDXGv0R/kzKK3X411H79Xp/hF+kqX+41h/h F2nqH632R/hFmnq6y+uP8Isq9WQ4htozc/0RvnV1FPMIX6uObwS16ujOoToK fUToV0fm6vhmhVYdsRyqo9AHjTOqOn7tXHX8A2Ut/oJM4l70B0g/DcNwGN8/ A6MwAofQ51XY9sBd+HkUDuLy3ajvRHlQbDkB+2AcaF/am45GQ49n0PITeMTr 2F7nKophmH+MbT2W28+wPT0H4D1sf8e6/EMl/n4NATyLbQy/4+JhgBewbcOh ztkIwCM42t1fA/AytucxD3fWkcUcfZ1Z1RufrVbNUapSalW8Qq2qVB9QrYoH 1aqQWjVXrQqrVVVqVUSpSqlV8Wq1qkatqlXbUqvidWpVvfqAalW8Qa1qVKvm qVVNalWzUuXRXvSYc73oCZRXMDZ/xvOUijOK35Pb0dMj2Lp4eRz7pM8D2Q6L ba5gO4cuvITHj3FfSRc0V6CVNLbFeGI/iC2Cp+qb2MorZT8Zznz0vPZuqffx V5/jfWKGji+VU5/oeMfn3Ik0bW5Z1g9wRbGn3dkCMFQjpcNzvqKWRlyaJZk1 /KV66c/1eTbhrWcvRi2NuDTfN2v4AwukPydbbMJbz8ONWhpxaeZ61vCBdulP 21Kb8NYzyqOWRlx6BiNr+ORy6c/ESpvw1s9GRC2NuPQ0UU4dXrxN9kUkc4a3 fspH7/CMRlx6Li6nDo/8ob7IFrz182p6h2c04tITnjl1eOQP9UW24K2fvNQ7 PKMRZ+FvPqucU4dH/lBfZAve+hlivcMzGpnZc65peHYRT/AXW2SsYmIXWpoU S7HsRvEe/XnlcMB2NukB6zUFrNcP2NSA4WkEf2uRAaPNu8R/7pH/XEi70lsi 1zr0e7E4Ynp8qR7TKHRbxFSs9WOaRUxfW6nHtEf0heaY9mTbIxZ1TDtBfrs8 10Y25d3AXmG/FKbe5ynVdO5fMyqOsNN3lBb2blgjOl2rsLPOD7szYadvOi3s a0RNW4eddX7Y7YedKpu+DJ9rkwNyugzdLTrvMvHZGPhrJbT25hZ5vUDt0cz0 OZeZUygP4E+j384nawCHYR/che1TMAEjcDe2CTiKnnfAEvig8KjKkK9fYLsH rTSjzRFsk9huL5NzyOhG7ifR7tPYmvhG7pOz6Qi3sJHXjHvkhmtud1Uz3EFI OX1zIZXTDdeCOqGOyTLJ7oR6D+Um3OMJ/HKnSw574XMwDsOi1EfFrIMOLHya bzCGa8fxNNiL6yZwzdR5B3SyLRRHME/SvGa4A3gOTf+bTzS6C0gzJv6IFXca S2s71tBFbGNYMMsx/UexvYDtPsz3K9jexQx+H1O1H8/oZ7GNRgB+j43uYS+0 47d/AvszJkyqnKZFpHKaMTFTp0XE56tVC9RcapVzffFDfA03h39Tre2qyf8D UEsHCDMpszE8CgAASXsAAFBLAwQUAAgICABImo9HAAAAAAAAAAAAAAAAGwAA AE9iamVjdFJlcGxhY2VtZW50cy9PYmplY3QgM+2de2wU1RfHz7aldNllt7tU +FGqtEVCFSy0WwtRfw2wLo8ItNqNxUTFqhBLgGJbH/hAUfT3+2HDX6hRUf9S MPEZDGg0ihjF4AvER3y/glGj5mfiK79f4vo9c+90ptO9S7Y7Y2e7s8ndMzvn zpzzuefM3bv3zrTnx5ctTy7yUQOJl4+mkPm170Si+VOJHowQ7UChm1uI6qYR /VFEdAeqQ1AqtQVb5abDbkKtGdOMGtV0C7ZqsFWkGSjS9vKLa/kGjsHeO/Gx RCrvkof76TZsjdFMpci3VX7QXt2oUa95PmaQebMbuiHjlfl8zdr5SjXyOnlc nen4m1sMyfuNevqp9uzZw777aDs+nEAr2xYkl7Qnz2s9J7GqPXHuqoWJxUtX CGtsqUt7j+G9lMpwHv9kot6AIWv9RDvPMCTv1+vJJjLk0Jdv0KdBLt5mRl9P xdQ+LCdKqHKIHf0lgommQCrRhCFNkVhxdlrP+IgNmRuvVbO5VHufwDY0v8qk v2X2N04srRE3wR+YKPxi6Ri82Yib4G+oEH6xdAzebMRN8HOjwi+WjsGbjbgJ /uew8IulY/BmI26Cf3S88IulY/BmI26CXxMQfrF0DN5sxE3wNX7hF0vH4M1G 3ALP/jzg9Pe81YgH7wL4LyuEXywdg7ca8eBdAN92kvCLpWPwViMevAvgX5gh /GLpGLzViAfvAvjTGoRfLB2Dtxrx4F0AzyNP9kufbHFseGs24sG7AF4fcToK bzXiFvhPx/0NE5hWIx68S+Adn721GvHgXQLv+NS11YgH7xJ4x+ftrUY8eJfA O75oYTXiwbsE3vEVG6sRD94l8I4vV1mNePAugXd8rc5qxIN3Abz+K9NReKsR e+FTh24V8O9nht+n2XxKe78e72FaEyK6Gx3wygjRI5DnYOj9DGTLJKLnIWfD zf2QtfDlLciKaqKDkKXTiN6E/H060VHI7+uIPoD8dCbRZ5Bv1hN9DflSA9EP kE83ER2D3D2X6PDxv1WS843G4W0L6pBGvm9EYfRgttkSzBranEMw/yP5H5L8 T0n+vZL/oOQ/IvlflvyXhQT/d5L/Asm/Kyj4UwHBXxwU/KcFBf/m439RqIOp oWYI5kjA2BvMqvs7cgjmlZJ/t+TfJ/lnRQT/deWCf1a54H87LPhfkfzBsODf ERL8D8pkvlUmc7/kXyz5t+cSTA01QzBHAsbeYFYfTeUQzJjk/yMq+F+MCP4Z UcHfHBH8N0r+rojgfzws+A+HBP+xsOBfFxL8i0KC/wrZM10oe6YzculmNdQM wRwJGHuDGVqYSzD/jAr+FycI/khU8P9fJvN+mcyHwoL/vHLB/55M5jck/xey Z7pIJnNYJvORgOCfLZP593E5BFNDzRDMkYCxN5i3JyiHYPZXCP4nJH+L5L9H JvM3MpmbZTKvk/ytMplflfwny2Tulvz/DQr+zbJnujYg+G/KpZvVUDMEcyRg 7AkmV4JDNJFWJhMrk6vaFixdkWxfsqAtYQSQX9tgaQFkMZ2pUS/runR1T2df V/eG6vbODb2iUqePnxzhobfeTv6SAUOpYk38Wza+j/6ljy75YZPbyXi85UpU 4CdJtmHMPn8KaZXmUD3KHEJj4TPveRZlGgx+gnInzni0mDWmekXix4ZfkiVa 42Zoi8qnVhWpVcVqVYlS1aFWLVN72GZWnQRRMTRieRDXRZA7oyKupdhuHBTZ Um0fR7bHFNlWWOgvYW1jPsQ3Pkap6lCrCiP0gSoj9E1Zhb7JC31+h37TdCP0 zVmFvtkLfX6H/tt6I/Tzsgr9PC/0+Rt6Nvy/uSL0Y7HdoAXSCP5Yba8e/FlF RvDLcJrEGK5hOSYPUyBeqs4OtWr0ZweP8B9GA2yZ7I3wR1NcucP/EdozJ3kj /AIN/a8V3gi/QEP/ZNQb4Rdo6NeWeyP8Ags9G26CdnrIG+Gnz45CHuHr2fF5 QM+OxmFkR76PCL3syJwd9/r17GgaRnbk+6BxVGXH6/Zlx2+Qh/EzIomjqrB9 BXVSL96raS11UxdtwNZslEtpHT5303psX40a9ZDrtbp9tJp6iI/m438iMfh4 ErYfwDlrYawH5RJ4cAjlGTT2WUi4/SiJMqIYsvIWlI3jiC5G/7U3iF+044l+ QXkN33bLwvAPpS6CtsOY93uUJCKxsEL8hYiq4Xvs1izOMKsxvASPj1WrytQq v9pDtSo+Tq0KqE+oVsWDatV4tSqkVoXVqnK1KqJ2Xq2KR9WqCWpVhdqWWhU/ Qa2aqD6hWhWfpFb9Q62arFZVqlVTlCqX9sFb7euDt0OuRbN9VcrW9NH9cvh6 LUqD3O5BX3YN9Woeca13UXbBietlT8vf1i+hzISdFMo7ONuvuPJX4RL/GmUf LtqPcHU+HuAzHMdGwfSNGb78be82M/SNHcPqNm3vG+271obcvJb1ows/oPnj NUTBgJA231QWS2vEodsws4bnG9TYn7OjOcKnvz0yltaIQzcUZw0/cZLwp7ky R/j0N/rG0hpx6Nb4rOHLpgp/6mpzhE9/y3osrRGHHvLIGn7PDOHP0VNzhE// 8EUsrRF74QceV8oa/uI5wp/NsRzh0z9GFEtrZHTf3VoPuRFd+3M1bJMXypbT Qs0+f+I5D/6teqiI90id8yMflw5obWx2/vv1u6Oi2Xl/jBplw5don/XJJp5o 2lrMewdqjOjAszAic2+lEZnmgUtCFZnmv+/CKOjI8G06/bUiMlyJJ+TnydgY t+noU7Q8PfvPEtaY6rn1R1thBG/uTCN4jXQ6LpzjB89UzwveSAWPBwlfxYxB QgMttgwSDsgJ7WJdV7CDhBb7mp3Hx9vg/kGMLnmKo5dW0zqUy6iPuuhqlD7a RKwLkHH9HJAzXpWw1YXyrLyW+CaHT+Q6Q0B1LrdeYy6Z1s8wP5VX6bhVBCG7 dPwTchGOuBujI/69czldRT3UqSVQt7aoVId04uWkjdjbg+S6HPv6sGfwstIp xMfzGaz34hxDaYKFH1F2wfRvMl1TclnsY8RzBwK33C8ma3lJ7FTk/iaU11C2 BImOBMXS2GMhojVhor0o3eVEH6LwEsWJufjtXR6J1o5ROrNr+6pXhqWtDrtX vTIsbXUMa9XLJUtb8So1l1plX1/cLyeQhvFv8vRDdfkXUEsHCHVDiQwpCQAA yW8AAFBLAwQUAAgICABImo9HAAAAAAAAAAAAAAAAFQAAAE1FVEEtSU5GL21h bmlmZXN0LnhtbM1WPW/bMBDd8ysEDl0KiYm0FIrlDAlSdCgKFOlcMNRJZsEP lTwm9r8v6dSyi8KBlJhBNvJ4fO+R707i4mqtZPYA1gmjG3JRnJMMNDet0H1D ftzd5p/I1fJsoZgWHTisd4Ms7NNunDbEW10b5oSrNVPgauS1GUC3hnsFGut/ 8+st0zg7EFCS5Vm25+uEhDzst5t9duelzAeGq4bQYyD7sIJWsBw3AzSEDYMU nGFIow+6LbaCi0OdhRsssNatAJDQOVK40RgBwkGPsCOskcblWbgKkJ0c1OFG gju91r+xwrbdBAtC1sfZHNdGd6L3dgvhSso4Bwlhaizl3trnPXgd18Sycl5H CYUXBT9EmEf+7f4XcMwuaKrKGgkSVcOIn6SER/SX9zpfMTuzy+9WXt1rJqSj uBsWg+6PiBCK9UDj+kvOVqa2vkxsfZnU+sn9eBrrHSCG32Kyy6pSu10ldrtK 6nb1tm4/sX6HQTIOEcTR3Rdngo51HvlN1wkOed+KeDGR8PJRBFWP7mdnrGIY n0rNh9/e4OXnmy9fQ9JtSHoKnErulLfQO5JbvZ3cBf3vWbv8A1BLBwg+Q/yy sAEAABELAABQSwECFAAUAAAIAABImo9HhWw5ii4AAAAuAAAACAAAAAAAAAAA AAAAAAAAAAAAbWltZXR5cGVQSwECFAAUAAgICABImo9HwQS1YQJZAACrMgYA CwAAAAAAAAAAAAAAAABUAAAAY29udGVudC54bWxQSwECFAAUAAgICABImo9H w9VceoABAAAGAwAACAAAAAAAAAAAAAAAAACPWQAAbWV0YS54bWxQSwECFAAU AAgICABImo9HDuBqtHoJAADROQAACgAAAAAAAAAAAAAAAABFWwAAc3R5bGVz LnhtbFBLAQIUABQACAgIAEiaj0e092jSBQEAAIMDAAAMAAAAAAAAAAAAAAAA APdkAABtYW5pZmVzdC5yZGZQSwECFAAUAAAIAABImo9HAAAAAAAAAAAAAAAA HAAAAAAAAAAAAAAAAAA2ZgAAQ29uZmlndXJhdGlvbnMyL3Byb2dyZXNzYmFy L1BLAQIUABQAAAgAAEiaj0cAAAAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAHBm AABDb25maWd1cmF0aW9uczIvdG9vbHBhbmVsL1BLAQIUABQACAgIAEiaj0cA AAAAAgAAAAAAAAAnAAAAAAAAAAAAAAAAAKhmAABDb25maWd1cmF0aW9uczIv YWNjZWxlcmF0b3IvY3VycmVudC54bWxQSwECFAAUAAAIAABImo9HAAAAAAAA AAAAAAAAGAAAAAAAAAAAAAAAAAD/ZgAAQ29uZmlndXJhdGlvbnMyL2Zsb2F0 ZXIvUEsBAhQAFAAACAAASJqPRwAAAAAAAAAAAAAAAB8AAAAAAAAAAAAAAAAA NWcAAENvbmZpZ3VyYXRpb25zMi9pbWFnZXMvQml0bWFwcy9QSwECFAAUAAAI AABImo9HAAAAAAAAAAAAAAAAGAAAAAAAAAAAAAAAAAByZwAAQ29uZmlndXJh dGlvbnMyL3Rvb2xiYXIvUEsBAhQAFAAACAAASJqPRwAAAAAAAAAAAAAAABgA AAAAAAAAAAAAAAAAqGcAAENvbmZpZ3VyYXRpb25zMi9tZW51YmFyL1BLAQIU ABQAAAgAAEiaj0cAAAAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAAN5nAABDb25m aWd1cmF0aW9uczIvc3RhdHVzYmFyL1BLAQIUABQAAAgAAEiaj0cAAAAAAAAA AAAAAAAaAAAAAAAAAAAAAAAAABZoAABDb25maWd1cmF0aW9uczIvcG9wdXBt ZW51L1BLAQIUABQACAgIAEiaj0cVj4EW+RAAAImFAAAUAAAAAAAAAAAAAAAA AE5oAABPYmplY3QgMS9jb250ZW50LnhtbFBLAQIUABQACAgIAEiaj0flqOG4 wgEAAHkGAAATAAAAAAAAAAAAAAAAAIl5AABPYmplY3QgMS9zdHlsZXMueG1s UEsBAhQAFAAICAgASJqPR1RuHHciAQAASgIAABEAAAAAAAAAAAAAAAAAjHsA AE9iamVjdCAxL21ldGEueG1sUEsBAhQAFAAACAAASJqPRxEeZ15ZbQAAWW0A ABgAAAAAAAAAAAAAAAAA7XwAAFRodW1ibmFpbHMvdGh1bWJuYWlsLnBuZ1BL AQIUABQACAgIAEiaj0ckpqeBDBEAACSEAAAUAAAAAAAAAAAAAAAAAHzqAABP YmplY3QgMi9jb250ZW50LnhtbFBLAQIUABQACAgIAEiaj0flqOG4wgEAAHkG AAATAAAAAAAAAAAAAAAAAMr7AABPYmplY3QgMi9zdHlsZXMueG1sUEsBAhQA FAAICAgASJqPR1RuHHciAQAASgIAABEAAAAAAAAAAAAAAAAAzf0AAE9iamVj dCAyL21ldGEueG1sUEsBAhQAFAAICAgASJqPR9u76phMBAAA/SkAAAwAAAAA AAAAAAAAAAAALv8AAHNldHRpbmdzLnhtbFBLAQIUABQACAgIAEiaj0fPv9zw /w0AABplAAAUAAAAAAAAAAAAAAAAALQDAQBPYmplY3QgMy9jb250ZW50Lnht bFBLAQIUABQACAgIAEiaj0flqOG4wgEAAHkGAAATAAAAAAAAAAAAAAAAAPUR AQBPYmplY3QgMy9zdHlsZXMueG1sUEsBAhQAFAAICAgASJqPR1RuHHciAQAA SgIAABEAAAAAAAAAAAAAAAAA+BMBAE9iamVjdCAzL21ldGEueG1sUEsBAhQA FAAICAgASJqPRw+1HZUJCgAAq3EAABsAAAAAAAAAAAAAAAAAWRUBAE9iamVj dFJlcGxhY2VtZW50cy9PYmplY3QgMVBLAQIUABQACAgIAEiaj0czKbMxPAoA AEl7AAAbAAAAAAAAAAAAAAAAAKsfAQBPYmplY3RSZXBsYWNlbWVudHMvT2Jq ZWN0IDJQSwECFAAUAAgICABImo9HdUOJDCkJAADJbwAAGwAAAAAAAAAAAAAA AAAwKgEAT2JqZWN0UmVwbGFjZW1lbnRzL09iamVjdCAzUEsBAhQAFAAICAgA SJqPRz5D/LKwAQAAEQsAABUAAAAAAAAAAAAAAAAAojMBAE1FVEEtSU5GL21h bmlmZXN0LnhtbFBLBQYAAAAAHQAdAJEHAACVNQEAAAA= --------------060507030306080009060607 Content-Type: text/plain Content-Disposition: inline Content-Transfer-Encoding: 8bit MIME-Version: 1.0 -- Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org) To make changes to your subscription: http://www.postgresql.org/mailpref/pgsql-hackers --------------060507030306080009060607--