From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 55339 invoked by alias); 19 Jun 2019 09:21:07 -0000 Mailing-List: contact gcc-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-owner@gcc.gnu.org Received: (qmail 55311 invoked by uid 89); 19 Jun 2019 09:21:07 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-16.6 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,SPF_PASS autolearn=ham version=3.3.1 spammy=facebook, compression X-HELO: mx1.suse.de Received: from mx2.suse.de (HELO mx1.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 19 Jun 2019 09:21:05 +0000 Received: from relay2.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id BD6A2AF55; Wed, 19 Jun 2019 09:21:02 +0000 (UTC) To: GCC Development Cc: Jan Hubicka From: =?UTF-8?Q?Martin_Li=c5=a1ka?= Subject: [RFC] zstd as a compression algorithm for LTO Message-ID: <89e98dc0-e766-ffef-da0f-263c3b284e96@suse.cz> Date: Wed, 19 Jun 2019 09:21:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.0 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------F22B6FADA443D968572DA2FE" X-IsSubscribed: yes X-SW-Source: 2019-06/txt/msg00185.txt.bz2 This is a multi-part message in MIME format. --------------F22B6FADA443D968572DA2FE Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit Content-length: 1047 Hi. I've written a patch draft that replaces zlib with the zstd compression algorithm ([1]) in LTO. I'm also sending statistics that are collected for couple of quite big C++ source files. Observation I did: - LTO stream compression takes 3-4% of LGEN compile time - zstd in default compression level (3) generated slighly smaller LTO elf files - zstd compression is 4-8x faster - decompression is quite negligible, but for a bigger project (godot) I can reduction from 1.37 to 0.53 seconds - ZSTD API is much simpler to use Suggestion based on the observation: - I would suggest to make zstd optional (--enable-zstd) and one would use #include + -lzstd - I like the default level as we want to mainly speed up LTO compilation - we can provide an option to control algorithm (-flto-compression-algorithm), similarly to -flto-compression-level - we can discuss possible compression of LTO bytecode that is distributed between WPA stage and individual LTRANS phases. Thoughts? Thanks, Martin [1] https://github.com/facebook/zstd --------------F22B6FADA443D968572DA2FE Content-Type: text/x-patch; name="0001-Replace-zlib-with-zstd.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0001-Replace-zlib-with-zstd.patch" Content-length: 9131 >From 4939e90b2a8051128b7b2b0214a5fad5183f3bca Mon Sep 17 00:00:00 2001 From: Martin Liska Date: Wed, 19 Jun 2019 09:40:35 +0200 Subject: [PATCH] Replace zlib with zstd. --- gcc/Makefile.in | 2 +- gcc/common.opt | 2 +- gcc/lto-compress.c | 161 ++++++++------------------------------------- gcc/timevar.def | 4 +- 4 files changed, 33 insertions(+), 136 deletions(-) diff --git a/gcc/Makefile.in b/gcc/Makefile.in index d9e0885b96b..8aedcccb717 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -373,7 +373,7 @@ OUTPUT_OPTION = -o $@ # This is where we get zlib from. zlibdir is -L../zlib and zlibinc is # -I../zlib, unless we were configured with --with-system-zlib, in which # case both are empty. -ZLIB = @zlibdir@ -lz +ZLIB = @zlibdir@ -lzstd -lz ZLIBINC = @zlibinc@ # How to find GMP diff --git a/gcc/common.opt b/gcc/common.opt index a1544d06824..f15e21914f3 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -1888,7 +1888,7 @@ Specify the algorithm to partition symbols and vars at linktime. ; The initial value of -1 comes from Z_DEFAULT_COMPRESSION in zlib.h. flto-compression-level= -Common Joined RejectNegative UInteger Var(flag_lto_compression_level) Init(-1) IntegerRange(0, 9) +Common Joined RejectNegative UInteger Var(flag_lto_compression_level) Init(-1) IntegerRange(0, 1111) -flto-compression-level= Use zlib compression level for IL. flto-odr-type-merging diff --git a/gcc/lto-compress.c b/gcc/lto-compress.c index 3287178f257..b24f30f956e 100644 --- a/gcc/lto-compress.c +++ b/gcc/lto-compress.c @@ -27,13 +27,9 @@ along with GCC; see the file COPYING3. If not see #include "gimple.h" #include "cgraph.h" #include "lto-streamer.h" -/* zlib.h includes other system headers. Those headers may test feature - test macros. config.h may define feature test macros. For this reason, - zlib.h needs to be included after, rather than before, config.h and - system.h. */ -#include #include "lto-compress.h" #include "timevar.h" +#include /* Compression stream structure, holds the flush callback and opaque token, the buffered data, and a note of whether compressing or uncompressing. */ @@ -48,45 +44,23 @@ struct lto_compression_stream bool is_compression; }; -/* Overall compression constants for zlib. */ - -static const size_t Z_BUFFER_LENGTH = 4096; static const size_t MIN_STREAM_ALLOCATION = 1024; -/* For zlib, allocate SIZE count of ITEMS and return the address, OPAQUE - is unused. */ - -static void * -lto_zalloc (void *opaque, unsigned items, unsigned size) -{ - gcc_assert (opaque == Z_NULL); - return xmalloc (items * size); -} - -/* For zlib, free memory at ADDRESS, OPAQUE is unused. */ - -static void -lto_zfree (void *opaque, void *address) -{ - gcc_assert (opaque == Z_NULL); - free (address); -} - -/* Return a zlib compression level that zlib will not reject. Normalizes +/* Return a zstd compression level that zstd will not reject. Normalizes the compression level from the command line flag, clamping non-default values to the appropriate end of their valid range. */ static int -lto_normalized_zlib_level (void) +lto_normalized_zstd_level (void) { int level = flag_lto_compression_level; - if (level != Z_DEFAULT_COMPRESSION) + if (level != ZSTD_CLEVEL_DEFAULT) { - if (level < Z_NO_COMPRESSION) - level = Z_NO_COMPRESSION; - else if (level > Z_BEST_COMPRESSION) - level = Z_BEST_COMPRESSION; + if (level < 1) + level = 1; + else if (level > ZSTD_maxCLevel ()) + level = ZSTD_maxCLevel (); } return level; @@ -169,57 +143,19 @@ void lto_end_compression (struct lto_compression_stream *stream) { unsigned char *cursor = (unsigned char *) stream->buffer; - size_t remaining = stream->bytes; - const size_t outbuf_length = Z_BUFFER_LENGTH; - unsigned char *outbuf = (unsigned char *) xmalloc (outbuf_length); - z_stream out_stream; - size_t compressed_bytes = 0; - int status; - - gcc_assert (stream->is_compression); + size_t size = stream->bytes; timevar_push (TV_IPA_LTO_COMPRESS); + size_t const outbuf_length = ZSTD_compressBound (size); + char *outbuf = (char *) xmalloc (outbuf_length); - out_stream.next_out = outbuf; - out_stream.avail_out = outbuf_length; - out_stream.next_in = cursor; - out_stream.avail_in = remaining; - out_stream.zalloc = lto_zalloc; - out_stream.zfree = lto_zfree; - out_stream.opaque = Z_NULL; + size_t const csize = ZSTD_compress (outbuf, outbuf_length, cursor, size, + lto_normalized_zstd_level ()); - status = deflateInit (&out_stream, lto_normalized_zlib_level ()); - if (status != Z_OK) - internal_error ("compressed stream: %s", zError (status)); + if (ZSTD_isError (csize)) + internal_error ("compressed stream: %s", ZSTD_getErrorName (csize)); - do - { - size_t in_bytes, out_bytes; - - status = deflate (&out_stream, Z_FINISH); - if (status != Z_OK && status != Z_STREAM_END) - internal_error ("compressed stream: %s", zError (status)); - - in_bytes = remaining - out_stream.avail_in; - out_bytes = outbuf_length - out_stream.avail_out; - - stream->callback ((const char *) outbuf, out_bytes, stream->opaque); - lto_stats.num_compressed_il_bytes += out_bytes; - compressed_bytes += out_bytes; - - cursor += in_bytes; - remaining -= in_bytes; - - out_stream.next_out = outbuf; - out_stream.avail_out = outbuf_length; - out_stream.next_in = cursor; - out_stream.avail_in = remaining; - } - while (status != Z_STREAM_END); - - status = deflateEnd (&out_stream); - if (status != Z_OK) - internal_error ("compressed stream: %s", zError (status)); + stream->callback (outbuf, csize, NULL); lto_destroy_compression_stream (stream); free (outbuf); @@ -258,61 +194,22 @@ void lto_end_uncompression (struct lto_compression_stream *stream) { unsigned char *cursor = (unsigned char *) stream->buffer; - size_t remaining = stream->bytes; - const size_t outbuf_length = Z_BUFFER_LENGTH; - unsigned char *outbuf = (unsigned char *) xmalloc (outbuf_length); - size_t uncompressed_bytes = 0; + size_t size = stream->bytes; - gcc_assert (!stream->is_compression); timevar_push (TV_IPA_LTO_DECOMPRESS); + unsigned long long const rsize = ZSTD_getFrameContentSize (cursor, size); + if (rsize == ZSTD_CONTENTSIZE_ERROR) + internal_error ("not compressed by zstd"); + else if (rsize == ZSTD_CONTENTSIZE_UNKNOWN) + internal_error ("original size unknown"); - while (remaining > 0) - { - z_stream in_stream; - size_t out_bytes; - int status; - - in_stream.next_out = outbuf; - in_stream.avail_out = outbuf_length; - in_stream.next_in = cursor; - in_stream.avail_in = remaining; - in_stream.zalloc = lto_zalloc; - in_stream.zfree = lto_zfree; - in_stream.opaque = Z_NULL; - - status = inflateInit (&in_stream); - if (status != Z_OK) - internal_error ("compressed stream: %s", zError (status)); - - do - { - size_t in_bytes; - - status = inflate (&in_stream, Z_SYNC_FLUSH); - if (status != Z_OK && status != Z_STREAM_END) - internal_error ("compressed stream: %s", zError (status)); - - in_bytes = remaining - in_stream.avail_in; - out_bytes = outbuf_length - in_stream.avail_out; - - stream->callback ((const char *) outbuf, out_bytes, stream->opaque); - lto_stats.num_uncompressed_il_bytes += out_bytes; - uncompressed_bytes += out_bytes; - - cursor += in_bytes; - remaining -= in_bytes; - - in_stream.next_out = outbuf; - in_stream.avail_out = outbuf_length; - in_stream.next_in = cursor; - in_stream.avail_in = remaining; - } - while (!(status == Z_STREAM_END && out_bytes == 0)); - - status = inflateEnd (&in_stream); - if (status != Z_OK) - internal_error ("compressed stream: %s", zError (status)); - } + char *outbuf = (char *) xmalloc (rsize); + size_t const dsize = ZSTD_decompress (outbuf, rsize, cursor, size); + + if (ZSTD_isError (dsize)) + internal_error ("decompressed stream: %s", ZSTD_getErrorName (dsize)); + + stream->callback (outbuf, dsize, stream->opaque); lto_destroy_compression_stream (stream); free (outbuf); diff --git a/gcc/timevar.def b/gcc/timevar.def index 13cb470b688..626ce493b76 100644 --- a/gcc/timevar.def +++ b/gcc/timevar.def @@ -78,8 +78,8 @@ DEFTIMEVAR (TV_IPA_INLINING , "ipa inlining heuristics") DEFTIMEVAR (TV_IPA_FNSPLIT , "ipa function splitting") DEFTIMEVAR (TV_IPA_COMDATS , "ipa comdats") DEFTIMEVAR (TV_IPA_OPT , "ipa various optimizations") -DEFTIMEVAR (TV_IPA_LTO_DECOMPRESS , "lto stream inflate") -DEFTIMEVAR (TV_IPA_LTO_COMPRESS , "lto stream deflate") +DEFTIMEVAR (TV_IPA_LTO_DECOMPRESS , "lto stream decompression") +DEFTIMEVAR (TV_IPA_LTO_COMPRESS , "lto stream compression") DEFTIMEVAR (TV_IPA_LTO_OUTPUT , "lto stream output") DEFTIMEVAR (TV_IPA_LTO_GIMPLE_IN , "ipa lto gimple in") DEFTIMEVAR (TV_IPA_LTO_GIMPLE_OUT , "ipa lto gimple out") -- 2.21.0 --------------F22B6FADA443D968572DA2FE Content-Type: application/vnd.oasis.opendocument.spreadsheet; name="zstd-vs-zlib.ods" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="zstd-vs-zlib.ods" Content-length: 25271 UEsDBBQAAAgAADdJ006FbDmKLgAAAC4AAAAIAAAAbWltZXR5cGVhcHBsaWNh dGlvbi92bmQub2FzaXMub3BlbmRvY3VtZW50LnNwcmVhZHNoZWV0UEsDBBQA AAgAADdJ005x3Ptz0hsAANIbAAAYAAAAVGh1bWJuYWlscy90aHVtYm5haWwu cG5niVBORw0KGgoAAAANSUhEUgAAANIAAAD/CAMAAACzdXiYAAAAY1BMVEUL CwsSEhIbGxskJCQsLCw0NDQ7OztDQ0NMTExUVFRbW1tjY2Nra2tzc3N7e3uD g4OLi4uTk5Obm5ujo6Orq6uzs7O7u7vDw8PLy8vT09Pb29vj4+Pr6+vz8/P+ /v4AAAD///9/URVFAAAbKklEQVR42u1dh3bbuhJMUSF67+X/P/MtSMtxbkzd hIKdmzzrnChWgzgCubMzABaf+l93+7T3QlEvH3nfe5M/3WoRIgX3Nkcs2osH qvx4yLuQ4unlo5wrLp/bT38t9lWwt4EUXj44xR8P+XVIeDmHU18uVxrPV+xO FyroZ/kZfwkYfSWX6798az2dvljB6gXRXz1gcz47c75If7qeyZd0QidhTldz uTp5vbgFXcqnSi5nz6/n6wrJXi/ia2ecLld/D5Lkn/Upf+6MIdW/iFOnIlzK 50oFEeZS/7W7OF8Akjqxz/UXIX0NJX6J5ZP/2j4npM8ufjWXfsYYEaTKV2bb p/i564XTNto+xQuC3z+e3Cd2pncgpS/lizrlT40xLNtXeelMhHP50pjA2i4/ DWkp/ld76eST/xryJ3/pXwoGSOGrQf2iU8yOkGjPbkBSiPP2pQxIV5WSgM77 nKK7A6nCr3I9d3y90nS5Mn/tXOav8iv8R7RD7eu/QRICOckrfP5XIdnLxbvL xYRL+1qoOeOzsri789Xx5WrQcs2fK79cohDtK/TSJfrLxeVPqvPr1Z3vhwe4 Ubvo3xyQT2FiEB9hTrnfjKibMhfS30a1vbXe5n1Pu/f099/Uvv9AmwYpSl/Q NETVvc6YPI9718yLF9YcAN1iZWE1TYDUBBcBIC1SHUOQhPVB2K6U6lrEaKwt a1vBiiBClSKdbZOycT1A2aq/fVLKLFU4+Sjgsz06II42o5esilLEU+PhECQE B40KjZdGpMrI8sRodqk3pQNuKIbAcGcJ/nMZ4jytz+cDalqhZCTutnAP94o5 M+PEiwxOPJFQN/YYpB7oVamMOydMaWMKQ2tSIn3mHWshKepoPfHqPyD1IC8D eKcKezgATadAqiiXMHop0XQIEk5MLllWgKRZVnDaMeYkpJh6hUSiQahIo92A 5Bsr+PmTAeg82Ij6kolBiSrqxYQTr2itS0rVu2PnXY/G6GJi9z3WYErOLTY7 LvhUGjxbTXbBN+fg5R5CC/05caompmbd+KQtNsOj2EybFMQfYkhGS/9dt/8r qv37ICXlCn2k5ReU5n4g2u203NpX7buQFleOYrePVN7LBEhNaxNkqsj6Y3DG Re5LNNnGPO5tNSPQhOCyqdW4doWEIXQUBkf4Fl5+0gBEn86hGg9BIgemyIzw UCxbqTaRw0FcoYDjJS2OpMVYnAX8OgRSASd0Eg5VEkVZgoDOwIW9/CRwVgS6 bSoxCOVWUatmnHiFrFS7HKdaD5BUxx1bA9Sqz5xbJkkzrjDFscF9Wd/m4CxD LyENqh1vRsDLyOFpVNtIGZDiufF4DFKTz5B4Q8agFsrIEgASXzqHx6gaSIud yf+AVJVENaWBmYKA5pAQ6QmQMhM8e1+UOqhqo5Ba5wBpp7GQAceYxDh7TIup WkgjpNdZGHg5BdN0e3EqJG59EbLpbmVQXthgK6//gSCuBM63aGf+M0H8QX30 QbXvAqnGUA+7Kf/4YMq/0FJZI1K4MWLz0yBFWdthoV4KoawQzgulbtgYv5AA RLnFzGehnt0ESFWwa5AynQU65qiQUhoKoiOhFVxW1uKfDiyMKsOJOXnJMegt qylHU8QFi4OXrl0fo1rcM+EVMY5dhETOuJ/ubyBpeREMdHxUaKKq7co+ZQ/6 2OWEY+5YOtCvueFf6qUFIC2twaeWKiF70JO8BzjjxBDqZyDyY5AyYgQ6imVM rfPW/nQvSUalZiRC3iE4ZZwoyPT+C1T7IQE/IH1AepFMu+Oe+G4C7/PIDVzR /0a1+BZqC215hl4SXK6euDqYRtvspG9KFu/ESByMzM4q0LHBn0GV+7LbbhZK FanDyScJ0qQnz8Qcqh2aRqRTZcckIA64LUYXz+3wvOEvRIMSIN/D6HmRdnkK gwTExSrQs5UHuJ/liSe6qtrDnjgOErI0QTxPjShKmVSkDBtZBbxCQvtUC0Jd DpJlcmQPVk0S6rjUtZfKUU98QPIRyDZXAn0uiqZ1g7S02O5AwqB/cXJAtUsh FmWqqZcTIBUpZYmxOnNQXjhQCK5pXUNd7W6nim85Nx+LD6HekS1FhVghs3Q9 6GySCgmuyY/s4QPSnwwpaVcOz9Xim0TJr5LtvxhpaQ1w/NkTF7/qzbwe8ax1 qyfuj9FSxy3V7FguNvcIBxddhWgTHXBmqneH4eCrZXMxXyA4xR56iRDzZlBt MjRKGU8B52OQIqtLukaciOVOOh4xVVoGoF0V78pBEriiQWoQgIHG1UA2M4J4 r6Q95omfS+Kd24ugGDpFxI5xYXTMOpTh7pj/6okLrnFXYqpQv3niXYSDvUQK BrLF3WtTjbYN0aps863K+72EqgYpnW+eeOdAtVM8ccpFcq4IKY9dS6q7pIUq jusueW5KRFMb/EjQ6v3wELhxmYuqupYezljjTeEfVPsB6U+GVFOsfva3pe+M ZF/yq1+8attbXGphGqQoS8NHD/3HCOAogWPTt+Pzo+lc665Qf/buKi2TPPEl SJXOvzpv7PbLnjVljgJlCiyZ5oJAJuAFB6bpjXbrKiODKvyPrKc5VZZTe/KK E9BaVrNJnji/eeIHDeS+tGIk5dHLRmiqkAYsjnThfYIDbXQIw45fIVHUnbwo Pjxxg2dOXtPmQU8czlnqIxU5qEZYbpBD1IV06WxwmkbEh6uCXjnYpXu1lAK/ wZIFUK2elD3ks1SrJ64OeuIMEhoh1ELTgASJkFGUGiIXANJOfu1H/movCU6l FCO7Q4pxKohiAc+g2goXLpzAtR2dsDs+WOHz69/QS9vs3625p7vWX50PvH5y fWUcQj0wa/g9eMm972D0R/bw50NK64U84Vbta03f5ombpqaAWQeGd4S6HHO0 VbFLMeaI119kiEmG7oYjp3J2zjc1UEWvskoN2r7YQRXcyjqmr9kZiIxftdjr vdSccLK4yL0s5yOqtnBIPGg6FwK/HLY0MZpMBCElPSoohMBB3QXrmYlsTJea cir0SG2/M3mtceKTUL4f6aUxT/zCOfxoHBMubvPEBVPrpGoHjPM8T5x8N0/8 oVvb76UG5BYgi0lwXhzrpSrE0syYJy5l08MNp3HtpTAg4WIJatz7dZ54ejlP /JGbcBntQYLTBqSyzF1mfWjmQ5JaJeG67b5akceU87qOVcUMisVmGZWDmKCB spqzzc25lpqW5c2CuGL4Y574B6TjkAZz8beh2i3v02Um1YJO3o14Y/1IDC2Q mtKR+Np8yfCvp5h6Dq1AgIAQOgIPPAp1tI1ihxdZCMMn73EKonL2u5CiJh7U pKeeuiNBnDgqccD57BfHPLHYM2EYYFJcIYe90uKalRKeSy2Al+YE8U5V6Hc8 8UJZfoBqPVAtDWNJFuHkG9VuS7IiH1Q7fA22Uu0kXlJ+XTX7OiSae6oFqNaY djkCqWmBexxUy00Pg2pxic9LsnANBJR8TmFQbZ2VPRi5LvN/ffIaJDGZ8wBZ GpfiQOOeC2W57LKbIvgYcdaZj8ViLhXTZeCOKV04r6Y0paquck548OntqFaT 2H/X7Y14Kf3GieL/l9lDmPE1bWeWS1rdnzjnS34G0pog47eBZF4I9dTSjC9x mO1KwCo4ypQ7fU1EXg80biB2S8EbFqQybhzTMjCI1t0IKrlKlLqTHSuigaCA 8EWlMyApX+70kvCBppKEsf0IJASgrgb7pTPGzMWozHArJSUFQEDGW01xJ7Vk FrfVz1NOBcMF34Vk9JBxHLIHty4H+3VIjuE83H1OTc6DalFvzRoVElAtt2HL HupUoV77erCve+IXrT1XvCweqyPZA1WQ42kyIDmshIWESPOxrnAT6lypK7aW UT+yB9VmZQ+My920teTSaxlrRWs9wjA+wRlbhqVdobHha9deRkNte6602uD/ 8ed2P4fGank7Xkpctf67bv+XVDvHFyn7snncl3eD5KdRrX+t6RvVTjKQQWDG O1TL4F801yzUkSAeuHZO6C5AmkgRgjQmiyEuvOZOOBAc8WyLEJXLcRS6TvEe rIl3xIU2TrSYhNVHJSBHkYZLp0LGxYrMSAm5NWUiaSgFD7wEEjAyn9k0XmLA O7uQAug+Q/VDQn2xdq2dIqw1dhPqim+euBIje3i1dsojN576roFclxC98SRj d8xOwYHJJfBBtYYEOaiWm1EtZ8seqFcIRaXE6om7WVQbqN0V6tU614Jv3dcY j8jT6IyuLoNqgCTb11Ig1V5FdK4Nnq2+hgSKYrzcY2ypzdHAyb8dLznGfp+s /fDE/3xII1Gb4kf96IlvOeDNE59SWjDHsM9LAa7cHHukLedDwSjW0mLtGTL6 EiFDznmbi1cqtNp6Tg0neHVMvxrH0qcI9Wj1/sCm1ygwox0JxB7yxC1R2OFy totnllhsmVR0DGwygS32Qspr0pINC3OiJ975/ihgw7VgUR7zxAXxmyeO/zn8 nN7GE++Z719LNAODbJ54P5QQdc1xX4U6s3BCDE+8pmdVi2scCVHJcVBtmzai LuMupIQ5ZGXcN5Loobq/lnNluOii68y5Db6qxNjwxGOBZNZzS6XKjBVdqpJV VTEHUn27IK4M/es88fj7BtT/P7OHKZSxt4I5t+0r4rtBsmv0mgEpvtb0TajH NsXmHxHtjlDHoHCcvmZ6yBO3HPQwFw3iZYWI57lWcU3OraSa60yZP9kR8big YUQqPiXghbY/ea1L51l50BN3ZHjinLurkcBLkFuVrGyiHWVvNk88sVjmqdq0 YLMLyalhiYhHPHGKYywje9Ax2jV7aN2oTdUK7bfsoU0V6rTsC/V8sdYLwzJy WB/JHoihCpkxIMEtNnxkD2Py9y17YFpdkTecrUJdT/PEuWa7aes6qySNgFTK EYYJ0RiQ370MVz31NrzHPBqqbf07tVLzeAaeW+/zlFi3rbR5G14KXHx44u8K ac7P/S/1xOu7QQqzqPYX6ok/8LNJUe9QLYfXk7kWqY5AisJ4CJldya2euDa2 iDHk5C0Pwlcx6olXKRvTPE3zHnjIpN+pJ+5EDcMTr8c8cSlQpuHSqJQJGT48 cb/WE4949cSBp1gKkbmJnjgP5drv1BPvmpqHhPrV6K2euDY3T1w+eeKaq716 4g+d3ULte+IoZW8jycSxcMgTj0wu6ameeJKDarmV4Ua1JGqEstRqUC3x0zxx o9UuJPhhm7e12+r9kSQZUiBd7JhHE1s0tYx64mtt8jzqiYdqi4u+Ow8vtxh6 mJOJjwbfjJfsOhXlg2o/IB2ENMh9yjDqj1S75Q1mPT/tDF4C0q530taU8khr E4NM/JAROtZqj0y81PE9tUI+v05LryMBb6NtAgl46Tyts8cnZOL82gMVuxGv WYkC1drhQMyRIM40UdjicjYLtMNAMzElRzEtxTjWBBJ1eYlGsMCEkEO7PR7E 25DJ+xJwVN/OWD7oifObJ47Mk6pV4skTF/ymatO0yWtrg/uQeOylJZKEtu2o 94DhVNs88TSEOq45tboJdVKGJ05KmemJw3elfTslIS4i8H3FkYojExoN50pB 6su7SoxDClvkk0MUi+rcMUOEypQVVaqQdYJDVNmVZUrfbp64djT033V7G0jN p/6XQfqPZw9zzJudVkrbXszvBsn1WZPXwmtN34R6aI8Xnlnrhal+R6iP+d1B XzPongPtey6tEbJxwZvgLnCtEwTAUWmUGQ4hHWTY2JOpcqBbOJQJo4AW9ezo nV5S1nMgkuGJHxPqhi+ehGtnXPhl9cRrgixJ2UQ6ysFtY7WJhTKLavGoEL8P aRTh9FSu2cMxT9xTFPzqicvg7dOIupJyVbVC2flCHXKHst9L5eK9k5YOT9wc m/dAJXJPnrgTQ6gLRZ8nrzGjFuS12DxxM0OoN3exWS/7yxtDCD3Fsb4j5yPB KARrxsrMkXbX0OqYspbyGuFa6QniQSppPANZec4zZqeMQy5jUs2beeKMf3ji fxuk9o6QYj/uib/Q3j9WrIxPgXF9Y7WTfhkldqdFjT024fVsrkXpI5CScMFk K6J0yYpgbZLDyLdWBlGyUPViMjyDjGzDEZ+0La4N+c7ws1NOVg9HpuqhqhxN KORpPbfFsrYYi4q0w4SVKnJbpANWqqYseRTIQGXW9uQB79dOSbQ3Se0jtVNu u2Q5PTb+ukjlxz5rY+MvLonZZomjdXcmPAsSEMJuL1Wca/CZJOp4OtRLmT9v /EULgl5KJj9t/MWgVxTOOPGx8ZcObVovSRN2IRWlVLO6dF3soX30ktbaAZm6 7q3UOeWiRzN+7LEZoi4m2arHzpol+eYnOeIdDrm+nVBn5DYQ721/59sH1f4d kI7a1S9GlPfWbWxNT+OlrV7gXgGssq7YBG1Tj6kzyLjzWKtZ20i9t+WbY27K ukSujKIV4xnU6uo8zJpi2S774kKLJVKpLQrH5hBxSYFqsVwUckgRY7miEMSJ xJxrJUm4eCFxXdQozT2ParnYr53SaE5Y1wdUrVPrXhfAS4NqzVkQJQ0BXsos SGyGpm2zqdZas9tLo4x4bWH1xA/Ox7PP2QMAG0X2ai31aY/NpuHxAhz1yrah j9wEX3bnPaSr4JFyU1HE4si1pDlTNJrGOrOEK+f06ojzZkORAjS7VJbRToG1 RKVFzAoP9u1UrQ78lnT8LXtsQm88x778d0D6j1PtUdIo/2DA3beUXt4R0iML ut09oe5fCHXXJpViD5TtFsCqgtOxoFtfs5BHF3TLpLgVOsC9tWEtLqE1cyxF zsvZRHgG6REHZdVzIKlwr5e0dfyxBd2QPXD4LLKiL8YsUZjacFY6cZ+kHVTr 6lLNTKGuKNmdJLAu6LaPLej+XqhfnY1Cb0Kdav7dDt3TsoenU/l1VTsWdOt1 QTc5tqDb0wGpDaGOAwh1SCK+CfVAOY7EkXWHbjdPqEPKtb+g2znXx4LuUFM8 YldHb3Wsw/2OTntIhbbB2wRJeMsFlHmJzY/13rWMFZyzBnZDeDtecusque1r XH/n24dQ//MhPVJPXL0UMq81fGtatVmZrZd3PHEhu5bFXIs55Iln6aMtg219 dnKsqx3+cQeREWUpUtfLcJGBtMbccTsrewBE+xKwj3ri1aVxf7BStYRAXs51 cbQC1eI6inWSIOTwxJUDuVtUWdJ4dloQ54zuU22mfeyQOYNqrRlUexbCMblR rRD4G9XOFOrsTu2UhkGmx4ITszIf7KUb1Tq6jVy4Z6pdGtOooiJXoR7nUa0T +zZ/gWupjuLcKhtztJ64yxGyceuETCk9XUs95uaDSjqaKke58Zxcm5aJdyff zhNX3zzxv0Wof1Dte0M6euK8uAZTute0rbPSwHrHE29jb502tuxsx3b/ak/F C7ctfSDEvNjOZzzD1z/Q+nSZtWzOCb5ba7Iqfo1EaLOEY7UmQegPT5xjiSwW 1FghyOqJI3igOAlnJwWui0Rxpie+leXYOfFITti2JPTh1c8r1X7niWtHqraF RblRbYV/U6m21zvz8YSHc8+TxAHSA574SrUAbHjgtaW8ZQ+obp54rlv2MK+X 9P76pXQRHNS0rnDiiSMJkWJMkaA77cRhLpxTjAJRsWp9EUwoIpRhpJHujaik 8EmQ2BvWTjFJ/G2eeNXPOU7+8MTfA9LReRYvPrdXjWB7S2jx/SCtCvqoUH+R MfyYzeunwLi9cdK5mdjdeuJLptweryfOuKGBgdpjnnJpreHrKKDEmnrLaDob y1hDcmyXPW0UUPl6Z/IaD4Gm+kDtlMFLAsgH2eHmm4umKiZStM0sWrrO9Ept aVN5KSGyXzvFmIfriT9T7eqJo5Kr8U9UG9WWPcDLU7OHu7VTzkp79kA9cSbp s/eAFeR48MRNqHOsOaUGsr6RPWhVp/USfAvvd2en1K3UyaF64lnbbYvM6kzZ tuvs266Zba2e0tYNOOvI+adVE19Lk/c3rCd++zO+ewm2D6H+50MaHEiOssSL 69a91vCt6XmeuDW7Qr0pqbvVxS3F2UN7bOoQXQk6m5CDGptCbHNbvcm6gg6s VzcyW+zHMbhZc1ul8fsRrzruRB57bPJDbivOXGGQkOe8OJIXY3GRfmzJzaXn JkmHGs6iXKN0Mw3k3PZrpxTSK6ezPHHQ6GfBHZWDlzKXLz3xmTO9MhX7njip PY49Npk9OnIhn0fUIZUzFlX/whPnGjVUVRnZQ5oHKcSwe+JlzkWVIneRlT5y 7UL3KpNDN32YQzEmyBbH5dtirs7LJIMuwsLLKdo2bW5rk6r1N/TE818m1D+o 9r0hHV1g8BOe+PaWaWO1PyXU1QNC/YXf8OOI+lZ3fWt6TiYuLz1hekeos0si TOtrRPKIXpJs6CXMiMAOM2as5GMMjQgkiFUMx9O4b4tAaRYvASPck4Cj+nbE rj/oiY954siqzRPH0npSNVBtWj3xYSmDnp8n1P+ldgrkKa3aOZ74KtQxSL+Q nqi2mu888UkJEe7sTi+lMxeeclWvAfEjkMZgDA4aUm3sEOfWynXwljbjM6eg 0ZnSjKzeg6hTIFV2ohET92ZB3Gbl/jKqLeo5xuX0d0D6j1PtUTskvjSc7r1l 3qzJn4H0yB6b8R7VmhdUOweSg6AqZe9364mzscfm4XrihkXGpABdzJS1lnNI EYQkhgbHaD4bx1lfJFnHBmfs4eJxL/5e7RThPX2snvjqiV87cqsnfrVM50yK NplFz1eqjXVpdh4vofu1U4DyexSP1BP/JtRXql1Syto+GcherlR7W2WGZlHt vdop+WJG8fnj9cSpJs/ZA9bEWgqNrULdZ4YNY8RxhVehrudQbdNnFeV1N21t Y3f6sfAo92P1xH0ypqzLM4s1ubW21TDcdttso2TKWtUQHtcyaWUMnAY1rQPD b8NLkcvbPPH47iXYPoT6nw9pnORHqhjqHk3pAf5F28aAjHoXMM7ue+JGW3i9 elS9P+K2hsjjNbK8eOn9qHzs3wORMW6/nni2zIloA/MsHvLEe5G8EMnpugO3 tfhdeglUeN/3xFtlNB72xCHfCtiLjHEeUxSNRe8Cqbrd9Uuj9C2EeZy4VYeq voM8b4vWkMTZTGq17l0gyVD3R9SZ4EWK2HiWSh0KD4r7poTvUtQQY9Tv0kmS v12R0w9e+oD0MKQjgz//oKGc3X8F0lq5/Ail5EIo8JIQhVLX1+T7XW5L2Bfq 7JoJN/oa8SFPnJTSliAaEmYUcLKOvAsiye6sMmMpEH98njju8ItUzDi2o0Ss fR+qDVrvl4MZNd6KZoeFOk65Y+k6Jrmv2cO7JET0Xu2UsxieuCzXgMSh7CEj RjIRdAz5OP9eOd42931nGcm62mP76xFDoH/bYemDlz4gfUD6027/A1dmGB4u aBMAAAAAAElFTkSuQmCCUEsDBBQACAgIADdJ004AAAAAAAAAAAAAAAAMAAAA c2V0dGluZ3MueG1s7Vldc9o4FH3fX8H4nfCRhBQm0CG0WdhlGwaTdLdvwr6A JrKuR5Ix9NevbEOXuHZKjMW0M/uUiW2dc7k+9+he+fb9xmOVNQhJkXetxkXd qgB30KV82bUeZ/fVd9b73m+3uFhQBzouOoEHXFUlKKUfkRW9nMtOcrtrBYJ3 kEgqO5x4IDvK6aAPfL+sc/h0JyZLrmwY5c9da6WU36nVwjC8CC8vUCxrjXa7 XYvv7h91kC/o8liq5OlDKkT8RhQtSIKJyZr1+lUt+d+q7II8SE3T6u3zsP/5 vdsdQfKnShV4UW4qu8tRaF1LU3bWFMJvWbOy1r1c80QlnTPoCyAz9K39TbX1 9U3KldWr39a+B3kT8BgWKgu5fd08GfszddUqC/zyut1onQw/BLpcZQbfvLm+ ujoWv+oRv0q5Cxtw01wQZr+neI1WmNgeEzGEIzcVplRCi8DqRZJovCnSCDQV 54zojPwo0JdLNkfIbxAIiWKCkiqt/r+zEt04OvbXoP/JhL4pBj1EQb8iV4TZ PqPqL3QhnfsVihNqB4Sijin0VPT7DJVZ+4fxG8DvO4quIUafEr7MSU9Bc9nH m+daBWPew07zDOVE3HLde496h0qhVyLwF0RvplFKVXQE+kRYkEZNirxeNAdk CZGxvoreKghurzD8XdC0Z88RGRBu9ZQIoGBxcEcnE9wZbNSDbisWDMMxLImz zeNaECZzyDIuHu5LebfjDeTYOo63lpy9a3OyxTkCGZsTkdsoNN61Cu4w/2v5 Py1HBHe6YXqeCIgajgJaO4bmCwiM45flF06E/wmVKWgz1R6hDpChyJRLs3XZ bF4XbINfvFYDSRkSqSMPPD7FcAjE1ROQERJ7BaC0yRhAH8mHQOmpEeytN0cm bUhv7aWQxIof6saBRc2DNsaPPPLMXDmdUGQjaXPiz3BKpIK0qMogSID1b0qG LGMMU5BaXPlTRfOmoNul4bMnixPh7WDu0jWVueGXBJ4dfFHpJPD9DZX2Vnch Ajn9mq/SX7vF2U3z2Q9IUMcf2SQXAkEiNb3l7OajNwdt/p7PYKP7HOqre93z GLC5mKgvKeHmacY6DWegeeBs+yjBfZWjRBMq2SXOsvEYdQuDjctZGguD3aLZ nmWiJ6votYIK0icGcyKhdXVHORFbq/aT7LQmWwXTI0Xf92ObER+IImco0DJ7 hfNt52Mk7lTXKWpPNvCS+4HCAWFOwIjKFdGJ24mpbcQma5itAm/OCWW/0ly6 c5lP+p/so50j7GWHMSE+iHuBXqZllZDkwYoI4mimqJcSIKNKKv1cZ0z586Pv agnmH+hf/pyDeiTCp+T75AMfMJQmrNj44DmSf4LgcRc7CbijApLxVaIMouQt R4Kdge7NjZjOSH7YfYC2tXiNnAT0mZ6q4hL8A+cDwh0oYEC5w1Htuy/ctbxv /71/AVBLBwisouQEMAQAAD0gAABQSwMEFAAICAgAN0nTTgAAAAAAAAAAAAAA AAoAAABzdHlsZXMueG1s3Vptb9s2EP6+X2GowLABkynZbRp7iYNtXbcBbTA0 LfaxoClKJkqJAkXbSX/9ji+SJUtyFadOurlBW5HPHe+eeyEp5+LqNuWjDZUF E9mlF44Db0QzIiKWJZfeh/ev/XPvavHdhYhjRug8EmSd0kz5hbrjtBiBcFbM 7eSlt5bZXOCCFfMMp7SYKzIXOc1KoXkdPTdL2RGjbKi4AdelFb1VQ4U1tiGL l8NXNuC6dCTxdqiwxgKndfFYDBW+LbgfC5+INMeK7Vlxy1n26dJbKZXPEdpu t+PtdCxkgsLZbIbMbGUwqXD5WnKDigiinOrFChSOQ1RiU6rwUPs0tm5Stk6X VA6mBivcimouaQEQcFfn5TBFdZlGfm2Swdm1SXpoJissB+eZATdTZRoNT5Vp VJdNsVr1xPccvYVJ89fbN7u8kunQtTS2QRWRLB/spkXX5YUQlalawBa7MXcS BM+Rfa6htwfhW8kUlTU4OQgnmJOKcZF2kQa4EAHCpxud8iVaaqd7Nb9AkuZC qsqQeHizA3YmVamuVMr7S1XPltBERlEnFMyZIihbKBp/w+j2WaOXHeZ/hgyo 3r8OCoQB0piqBIDeXbOVSbUdxGKdRbbsLBn0NqeS6SnMjdi8oaGeMVwcodLt ITUNjcbKKC+rrXKpU40Qflr4LIMkE/m8Jt2o/KKYqq5QvH+H9JyvdxXom26d 2mY68RblzhkL2DVjTKgfUcKLxYXteNXwyD5rIy+9Nwzap3F+dIMzSFJoSyU0 Zfzu0vse56L4eQ9nB71RQ7XG+wnNwGsonmLLiqKByJki0F42WDKTG+iwaa+k YJFZbfSKbnCGExDsNbATPcTMu0LR9CF2Xgsl7MI3v43e0WTNsew1swv81axE fRngxu1RqvQmojFec3fAKjU7Y03x+oRy7pXwHEucSJyv/BwymErF4FRmpwAN WkTuR6xQONMHtOlZrnbE6bRtixkze9IwFnOOs2SNE5ilmRkgUKhKgnUfbrx9 FT70R5z1BsOAS4Ul9vOqnHGay4nfrtv69VbN6W1/WjaXqOArtr9INfXXtQla RzQWF/Zc4443jRC5pAu8PdDIPaUsM20mAbmIJUwV0B/MQh06ywC1F3hl7fH6 EwP1C/9JsT7WHxAeVUlVnfH95sJ9uWMSgQs48z0LzMfkhglUwT6DgslzSL3d mD3xZ3D6wHw3vKUsWUGrXQoe1aLwBVKcXx8nwcewdAFyPuf4zm8gRuFRvpe8 He17eH4P3934Md5PDns/eSLvJyf0/j1Y86CEPlAv0LXoUbqNURVflcQea0tM PiVSH3P8ksAYPoTsoogTkWHuL7mvpOYmo605BdPVnNYqZKSvXsH4JVTcqBAc +uKz80D/6W/9tSBOzacVxOCEQXwthMq+Dtn9fjkKhvjF4GzIyFcozTuww96/ T+iYrjlK7xWwmk5IP2MjLTEmY3ogWxbpqyheK9GD6DPqWApv4Da/Lk5V4X8I ER2l25l1TI0TYmp8SCkGwdlZRz89ZSle07WSuxR5LFJc4xtCymz26KT8ih89 SzQdAwkhpHPXPSUh/2CZHXuS3Cflm3LsdymFfPyOYPwcEuvYfB5Eyf3O1r8Q Ap4+zZXh5G4duDFYwJEXBkfaMbngmHikXLhveexo67lqONqOu2k8gLZ7nG+f lLbpQdqmj01bZD5tR9Deqyn3qM99KVaM+OVEaVRCffBGrFXD77d5GnodoPZL J/2eHzYUPxURyHHpq+UumCu4ge6/GnFjMdwc4J+mo/pdy8qFahKOJ2cutCmW CUxxGsNE0ByUFr43uhRK6a8RXo6DmX1zhvpNcrY8gZlK5B02Nu1BrSgMiN7k /xS9+u14Mn4+292Oa9tPjiP71XcwfhGWQh1bdqD/VOzUECwFplqJ0vL0P5BJ 3yZfX85q1Nut3ESKi0pF1cPcoNZ06I1rvQ46mpw1f3Fhfs8gd/8WK0otenF1 dXWB9gfdSL5Hwl7kdRSbm8elF2NeNL4J0dxUq/+tfXEP2mz7inkRluvVxlom lKoapB80AbV4/BK179x3qgeYnbSYtU+SJkzYzL4v2XYALX6w/1NM8TrUPv/Y IqSxYmPIVNKeFRFWpa/mi9r6fn0Np6MK5G8wX+vX40E484MzP5x5iyBA5icI nBUauPhpVBoMXgTB3PxURnelUdO+p8utknFUFzDfuyxms7qAHTtRLqLu6kfd v9m0+BdQSwcIO7RBD3cGAAAZJQAAUEsDBBQACAgIADdJ004AAAAAAAAAAAAA AAAIAAAAbWV0YS54bWyNkkFv4yAQhe/9FRabqw04iRMjh0g97KmrVmpW2lvk wDSlJRABrtN/X2zH2XSVwx448OYb3mOgWp8OOvkA55U1K0QzghIwwkpl9iv0 e/MzXaI1v6vsy4sSwKQVzQFMSA8Q6iS2Gs+G0go1zjBbe+WZqQ/gWRDMHsGM LeyaZr3RoJy0Mu8r9BrCkWHctm3WTjPr9piWZYn76ohKceGOjdM9JQUGDZ2D xzSjeGS7hP8bqmOvI1lrL0YdPoTu7XJCZnjYj/TeSalvXSCyUxwT1qFOPxS0 P1Byvv7VwHPEx+l2MXglBYsdwHNCy5QUKS03lDKyYGSaLRZTSuZkRis8YlUf HqQK8clS2bg6xJP502b5i86fK3y7/L1LfAoNnhf/0Gd5YPdgIDZbxx/UzsFj HxkXWZ7N4iKTB2Wa0/bPstgWs+QK2R6dfQMR4jQm943SMs3PNn9PHBwun8uH GNIHJZJeD/VOQypsY0IcGBpEAVqPWkHmZ9XuOqtRJwjzCn8bLr71kfkXUEsH CIAGJzOEAQAABgMAAFBLAwQUAAgICAA3SdNOAAAAAAAAAAAAAAAADAAAAG1h bmlmZXN0LnJkZs2TzW6DMBCE7zyFZc7YQC8FBXIoyrlqn8A1hlgFL/KaEt6+ jpNWUaSq6p/U465GM9+OtJvtYRzIi7KowVQ0YyklykhotekrOrsuuaXbOtrY tisfmh3xaoOlnyq6d24qOV+WhS03DGzPs6IoeJrzPE+8IsHVOHFIDMa0jggJ Ho1CafXkfBo5zuIJZldRdOugkHn3ID2L3TqpoLIKYbZSvYe2IJGBQI0JTMqE dIMcuk5LxTOW81E5waHt4sdgvdODojxg8CuOz9jeiAym5V7gvbDuXIPffJVo eu5jenXTxfHfI5RgnDLuT+q7O3n/5/4uz/8Z4q+0dkRsQM6jZ/qQ57TyH1VH r1BLBwi092jSBQEAAIMDAABQSwMEFAAACAAAN0nTTgAAAAAAAAAAAAAAABoA AABDb25maWd1cmF0aW9uczIvdG9vbHBhbmVsL1BLAwQUAAAIAAA3SdNOAAAA AAAAAAAAAAAAHAAAAENvbmZpZ3VyYXRpb25zMi9hY2NlbGVyYXRvci9QSwME FAAACAAAN0nTTgAAAAAAAAAAAAAAABgAAABDb25maWd1cmF0aW9uczIvZmxv YXRlci9QSwMEFAAACAAAN0nTTgAAAAAAAAAAAAAAABgAAABDb25maWd1cmF0 aW9uczIvbWVudWJhci9QSwMEFAAACAAAN0nTTgAAAAAAAAAAAAAAABoAAABD b25maWd1cmF0aW9uczIvcG9wdXBtZW51L1BLAwQUAAAIAAA3SdNOAAAAAAAA AAAAAAAAGAAAAENvbmZpZ3VyYXRpb25zMi90b29sYmFyL1BLAwQUAAAIAAA3 SdNOAAAAAAAAAAAAAAAAGgAAAENvbmZpZ3VyYXRpb25zMi9zdGF0dXNiYXIv UEsDBBQAAAgAADdJ004AAAAAAAAAAAAAAAAcAAAAQ29uZmlndXJhdGlvbnMy L3Byb2dyZXNzYmFyL1BLAwQUAAAIAAA3SdNOAAAAAAAAAAAAAAAAHwAAAENv bmZpZ3VyYXRpb25zMi9pbWFnZXMvQml0bWFwcy9QSwMEFAAICAgAN0nTTgAA AAAAAAAAAAAAABUAAABNRVRBLUlORi9tYW5pZmVzdC54bWytk01uwyAQhfc5 hcW2MrRZVShOFpF6gvQAFAYHCQbET5TcvtiKE1dVpFjKjmGG770ZYLM7O9uc ICbjsSMf9J00gNIrg31Hvg9f7SfZbVcbJ9BoSJlPi6aew3QLO1Iici+SSRyF g8Sz5D4AKi+LA8z8bz0flW7RzMCaXNHWw3nixp5PIO0LKpFr9VUIzgGiGVLC cq+1kcBnhFFpu2ruLWhjoa3l8XI3oIu1bRD52BH20Nd9CKCMaPMlQEdECNbI 0RA7oaLjDOi8dZpCBKHSESATtsTK4VjcDwpjE8vTkgbsH1gxTvTAhvwilQQ5 1+tOtE7tATnXQbIhvQgsPeah/1dzU75YeL1dB1m8Hnrdo1HpJ15QrXpbrLH3 qE1f4ohIa/bkS00Fh3ZpMVTOCYP4hv378dtfUEsHCO5Mhu4zAQAALAQAAFBL AwQUAAgICAA3SdNOAAAAAAAAAAAAAAAACwAAAGNvbnRlbnQueG1s7Z1bb+PI scffz6cwnJPzplbfL87MBAfJbl52F0E2BydAkAdaom1iJVEg6cvk06ebuliy xNnqllqkuIQHHlgqks3b/9dd1VX96Y9v89nNS1qUWb74fEsQvr1JF5N8mi0e P9/+39+/H+nbP375r0/5w0M2Se+m+eR5ni6q0SRfVPb/G7v1orxbffv59rlY 3OVJmZV3i2SelnfV5C5fpovNVne71nf1sVaflNXXGXjz2nh36yp9q6AbO9u9 bZN7+JFr492tp0XyCt3Y2dqLurv5Qw7d+K2cjR5ye9Xny6TKPrTibZYtfvl8 +1RVy7vx+PX1Fb0ylBePY2KMGdffbhs82dotn4tZbTWdjNNZ6g5Wjgki443t PK0SaPuc7W6TFs/z+7QAX5qkSg7u6rJIS2tiT9c9mLAd7W6z93y9PIKfrpfH hss8eUoK8HNWG+8/KmwKf1TYdHfbeVI9NdxfPf7Rfln/+vGH9+eqmEOP5Wz3 LtWkyJbg01xZ726f5/m2qW6D1cteN5dizMerv3esX79p/lpkVVrsmE++aT5J ZpPtFc/nxy6atSNjazFKX9wjv32J3IUoGzag49XXW+Ny2rjrf/z4w8+Tp3Se vBtnv248yhZllSzer0zhbkLjmYpxkS7zotpemAe4+Nq7Rbdte6rms2bpcN9u TB+L6fSoqW0OG1sZsS/x6CVLX3+3p63ffh7MuDba1dNvbkDw2NlsX0l7u9/F v3jc8ukhf15MVzKwuhjp2zItMvdVMqs3u9vbw+4TPMsDdrlm2s4e9oQ+S2eb t397Skd3k+ejeWkfBvvQ58u7na33uVHM32C7cw96Pn34uMcPL/2kLFl17N7+ /W9j993IYdOCYX2kne4Cvf2y6RustKAcbz94sH2E0UMySUfTdDIrv3xaafz2 45vV367dn29/yCww6st783OysG+aFeKN6Tybff18+z/JMi//8MFu9eHtzd6u nf3oMV3YC2HlonzNynLPYplVEyuoL0mR1U/f+NtN+3ORZ9P6aDd/Tl+SRfJo N2xs4FFrSDO/llU6P6WdP+VVvjrwz3+6+Vv6+DxLisZmHjM+WyvHTU/A+vPk ucot1LLJqN7P9tGof++d0yQn24Ot218rhmX07Hm+uN1sufvhaGmf9LSosrS8 ecjv7os0+WV0n9qH3u7QHXqzx7X5azZ1fKUKYbKs6vbvNOdbbaOXaptWyBi/ trFLtU0ZpLhf2/jFrpt/28TFrptEzPOeyku1TQqkhV/b1KXaxoT3PdUXvKfS 87qZi91TjKinvhF8scZxb/ElFyOD5sjzRSUXI4MRiEjPxl0MDYQSZLzeh6KJ 90X++qFl9pPdZq2+ch8+pdnjU+WOjrR7pr7d4ucyHeXLKpsns9Hu1lXxnMLb XSXH2735cJ7YflMxWiaP6Wjdq0wfkudZ9eGkdk5o5W2aZuVylnxdt2e9Nzcq zhaPo3k+tXuaFaPq/rCpKx/Mnd3dxI0G7IEPm/2TfYm2lqv/btZ/2R5bfU3s 0SepHRjbJ3o1rplni9GRL9ebuW/dYOPRnu00e8wq+y1xjVt/70YSX37/abz7 5/avj239xlOcNr396Wy2+WaZFM5XWf/RdNXt8T883HWn9XX9FNzns+leb3f1 xciOs5NF89fOgzRL39YG8HczbdIN2FmtLeqh+O73q9vczTNuEqPTz3hnIHI4 4Fh/cZ9Pv76PYJdWJablU5raZ3L1+jn/gB0aufHmqEwr99Zt3sz3fT5ki+lo ltynM/uwPySz0r6oKxsnLsVqcDWyI/MiLd3A+ZjVazabTpJiWr4rz+rL+vfa cHVub5vtdk/YCdDeJmvlPmJaj6nW6rK6jPXVPnp9x+B90gj7ZBH2ySPsU0TY p4ywTxVhnzrCPk2Efbq+7Pl3+utvklM4jx3++mvkt8MYrxCJstPg+2N7bUf2 6HqSHw5u9/exPfajY61xvYuNszOZPaej6uvSfl5WhQXA7c3Ga3zkO7t/983y SzJ7zG037Wn+abz+5NP446Ev1piHbJZ2oR2ul7CG4M0sfUlnXWiUuzhl9u+u XaAuNOeHv3z3UxfaYccb3bow///X//VqxuV0p6NP840dYZ+lTZe7kn/aaf34 5lyvwvjDxpZe58XZiWf971l273eeJx5wHVsa2bHU5All2UUPvu5rnHzMh1me VPtP3OdbhrA83oyV+bYVzjBOEzCiFNQEZxinCQpxUAusXaRrALsAsW4Agd4A 4ncDYEK4dZSsvlo52tb98HJUpMs0qdKp8+Ad2R9Ua7eDFjex4HmWfL7NH+4+ /xN9T/81/if6C/3XUS1+9/YdXjRMjdr9d/wS7uxhex0pMur3vhdyUOQ9Rc6c L6+HgiwQhWmRM4ylB0wD9YDpOE0gFMGw5Az7KckMKsmsd5LMaklmAZLMMBFa bX43UO2YJNvuDR0k+aQDZkzLXkmxRE1P0IeX0BnG0gEO1QHupwNwKSb2tYJp sbMcxLhnYsxrMeYhYqyN5laIudZSqoZLeFyMDR7E+DQxXpSLUTrPql4pskFa gN5EZxhNkWH9c2cYSZE5lAq1ZT8VGfYcOMPeKbKoFVkEdY+5odvfDZewoXss BkU+6YC/uABRkfZKjzUyBvQeOsNYUiAaPG8HUiBUNGcFA+qxsxz0uGd6LGs9 lgF6zCWlWpHN/3A95kgO7orTDlgVyXzJpqMX3itJVojC9NAZRvMfQ9WAReql E4EYzHdTWw6S3DNJVrUkq5CgHtVcGMEwppJ4KDJFVPdMkctqet2zLI7PeIBN d4hzcIoM7K10hrGEAejVxtG82grBboK166cyN+jKoTKTCMrcLJvfaSeb3/13 wGQIIzkWrhMrNJFNg8Jjumkk4sRPOP1QUJ/T9yHnhM3+j8dJ2W2DzqkRk6z7 k/L6iQuYszeSp9dSAKaUzjAaLqDBr1jBv/ZxgTBUsbGfYvtAA8qMMyHjIxtM OBuEEkQyZrQ0VHv0qY1AytPt3AABEwwBwuTuD7zxhCHJBwj0AgKwPnukDjtF GjYdzxlGE0DojEAcqQkKUViowRkOGIiGAYLDOcAJUZIrLLSmTS7CoxzgiHi6 uxs4sGp9EAj2OdDQLTwaO5V22wEEvQABbFJypBnJFDr7hUac/RLLd3FVAY6W 3UdtI4CEI4ARpqjgBhMjm/oURxHAEAnrTR8ggAQjwANZwvYBPOcwDqLfUdEH yk000Ye5651htH4vrOvtDKO5gKCiz6JFtbvQ+7945OBA/Gm4+FMipJZUcYGN j/ZTRMI60AfaT4O1n4fGArg98bAAx0CCrpEA5gSJ5AGxAg8FQTT5gU61JJFE WEFnWqreTrRsu/PPwvWfCMyoVEYxLaRHcqYhSIR1pg8AwIIBoBTd+fHIZlJu IDoAoBcAgPWDI3WCuwCASHMKPQAATH1S8TKfhoFADQJ+1SDgwSCQmuz8eLRe akQ854gOIOgoCAisG0gi9QO7gAJoRJhEiwi3j4Lf+FhAXDUCRDAC9gjQ9CIc a70mSIdFsgcEdA4BsNcvVhy0AwigUATQeAiANcEZDgiIgQB51QiQgQggiO65 gzymhdLBHXQJBJy5PmT3Usk4tPYCj1h7AVg8GEcrHuwqKsB8UrVlnz1Crdbw /UZSGVErRATUczSCUoOxkowJrXxCxgJRFjOrbHVS34ecFBFKG66Y1JwSnyI8 RCA1pJX1ghytZpVxaFYZj5hVFkuuvMgBuw21ZT9HD+1HEXQ4HDjWzEjDpZC8 KUWmIZ0Ah/nhDyiggynA9jDgkU1gBz9DEKEXEGg1q4wjDYSQNbwu74UPAsAE 6CkALj5oOACACQcAZVJyQilhivt0pI0FepgL5gAAJhgAVO4hwKPSkERsiCH0 ggCtppNxYACBR4wht51M5oQdWCfOWQ4MiMIAisMZQKSrZMw4E4RwHwYQJM8T RKA4nAG7jiDqUVyCamTCKmMMDOgYA1rNLuNIwY7vDHs7k8hpO6wNtWW0IELb dfk6wQJyAguCUYDDggUHKCDBKNjlACMeKOAqdDAzoKBjKGg1vcwqPMwh5Qyj zSiCDghovAGBAA8IRLyE699iPPkABTQcBdiFBAQ3kmjm4143GMnzlJyjNJgF Quw5hzyqTghEh1JDvWBBq5lmVuKhwQEVLTgALPODo5X5cQoPuw215TAsiMkC dgILuNCYWE1VRAmPnrVlAT9P3QnKglmg1iOCFQ08ys4p4r1m18CCbrKg5WSz btAACoNoLJDAfA9nOQQK4lCAXzUFePiIYD9a7DEisE9jmG9roEDXKNBuvlkn KNDk1j2QIB5rYTGKmtbpO+SA6ikHWp81SsVVc0AEcoAg8h4iEMqjCB0hGvFh 0lBsDmRMy35mmwkkgdNVrWE0T0jr2WYYehlqyz5HB6C3gvjdipOzzeg6IZmH FKfWgmmKhdEYS4+cXsOQDnO1ALPN6DpPOeCkCDOCca2Zorgp7adh+ZphhtF1 A6PVJDMB9Z2LmK7ztletcRgAphg4y34OFy6OigMmqHAmUC0U4evfPktAUqTP NFxQ4eKvJeZSECKpMtinSoUOnR07qH9H1L/V7DIr6rA+qjOMJjwtZ5dZRYeF sGvLPg8WIpUN9yCADicAEVRTZiimUnjVoCBInGlaqQ4mAGVUCL0ZBHgEDigb phJdOQFazS4TUF+9iOarj9f19GFAU6n4QwaoXhesbn8UYMIZgAUjQhIuiTIe Imrw2RBgghGw8vzgNQl8Fq5UiA4r11w1AlpNLhOIQV1ALJoLiIInDsWaOYSh y3bWltEQ0IFZpK0jgOFgBOhdN3rTxTxa8tmciwEMBzNg4wKSRknFfeYPkdC1 1wYGdIQBrWaVCejCjSLiwo0U5oJ3hvGGATDxqy37PAxo3RXEyAkMWDuBsGI+ S0BaBNDz1JpgJBwB724gCzGPlDghkB6GAVeNgFaTybqBAOgKxjTSVXCde7An SA+eoKjDAHrNCKDBCHBd//eQsMdkIKkQ5wMCrhkBLeeQdQICDDodiMWbDgRc tKG2HCAQEwLsmiHAgiHw7sOqAwIerddDoaFrh0C7KWQCqsAimgLbcTBUeUSs mDCBZlDVlgMEYkKAnwABJrVSWElOiPFIJLMUOFP1acYDKUDQNh7sXEI+a9Aw HLqyzkABDwosysUonWdVP7PJDHRmpIk4MbLt6aEcEWBc2Fn2GQOR6r+enEvG 1mnGImDGkCaKCm0725TrpilgR6cMaUTC6ADMJWPr7OOAk6Khi15SitQAjeuH RqsZZQYJKDREvDgCjJvOMB42gLWqebSC2W1nlF0cGAdkkOFkUEQoJjHHEhuf 6ZhGhU7FOUCADEaA2GOAB9cEHZY97gMCWk0rM4jDXAbOMBoCoDWIaKwaRBwa zq4t+4kAaDyf+J2/BwJUOAI26s8U9nLBG4lwWBz2AAEqHAFSk50fDwRIpIca RNePgFbzyqyyw0YhzjBaIBkaR44GAAaMIDjLwXUUcySgwzEgNFNCMi6IUl71 hgTSZ8KADsbAPgU8EiKktndjwMDVY6DV3DKr7jD1cYbRMAAVwFga7OQdmFfg LAcQxASBOQEEglFjuKFMe5X1tCA4V26ZCQaBwly8/3jEkpUr0zuA4OpB0GqC WSdA0LR066FLKNacIg5dLqe27KdLqHUEcHzNCOA43CVk8M6PT26ZQdgMCLh6 BLSaYGaVHUqAWNoDDEvgaGEJK+vQdSt5vHUrf/MAICcAgDPCFcWaUNKUKdgA AH4mAJBAABAUOgQg2D6Nwxjg+gHQcnpZBxAAlF8cTX2dsIOjAtGqrv7mEUCv GgE0GAEkMCrslqYZ4gF9QEC7yWVW2mFhWWcYS3+AJR7iVXiw0t7kPTiEgOp1 hnH7KGAnoOB9imhT4nwDCdR5IsOcBZNAa8m2Px4TXInWSA5lJmKT4JdpOsmL tK+ZZUDpMTGlBzpDNFZaF6HQep+1ZW8pYMc5wJQVa3gmCgBzy/g681gGOFsw pZRLwwnmPitYEuxSuGLmlvF1QrL3SbnI2O4Cxx7TiahEbJhVeu3QaDWzTKOm lfE+xrCtYTRotL5WAQXXpaDx6lK06T9yvmgoLvzI7TFoEIFccAWjGKPCECVt B9zHBWMMYmfyH4lwAGisMFGCMy1M0yqrRwGgER4yy64dAK3mlWmkYcrnDKNN Imq9SjUF1sRwhv2Uf1g3wBnGkn8ZLv/KGKWUYFho0zTuaSg5gc9Tlo7LYPnf WdfeDQLgreeuMzLI/5XLf6s5ZRop2ORJZxhN/luvUG1fJGCFamfZZ6dR+xhQ J2BACKqZ5JobzXyiyCp0Ks4BBlQwBgTWShFDjaZcSJ+ZpK6y6YCBK8dAqzll Vt2hFOg1BIAZZTSaJ6obEIAFULxn03pAQIdDQCrFiWGCa6aVh4waabs454GA HiAwQCBIh9vMJ9NIwjTYGcaSPwZ1BbF4riBohQna5woTnRgLmBMwICU1QmvO iPBJKpNInqfUHDfhFDCSG0I3cQGvpDI55BRcOwVaTSmz4g6kkDWMpX7A+aw4 2nxWq+3AYku1ZTQKtL10MYdWnuW+lWfhFBD4BAoIQRTlhCnTRPUGCpzJISRw MAU2AeEVCjxar8SwZtn1U6DlvLJOcKCpQuRhZlmsZcusuoOnk/JeTydtfX6Q INfMARLIAYLepwY5EvhMeiWWIQMHrp0D7SaXdYIDTX7cA/1TscrNUagA1pZ9 5kDrwQFBr5kDNJgDdUSAY1bHCHw4QO3NCPNpDRyAH7AqkvmSTUcvvJ/5ZQpa eV75Vp73EUDogADHGhAI6GzV2rK3jiFKoTCqLc+EAmCGmVinH6uQ1cu0MUIr xgUV3MP1bjQyYVNJgRlmYp2WHHBSlGqhCF//9oiG2HunB3L0gBytJplZIMDk yhnGUsym9aYOk8xiBZYFFKC1ZaTr0GaWASXIwAZRtWWs4QMPh4MdNUhFJVWU CeozflDInKc4heDBFPDIi+A4NC9i0P1O6X6ruWUKYdjxnWE03W89uViAl60U 8ZatbN915DQddi9qy1jqL8LVXxrFtBTEGM6N39pl5jwzS4UIV/+dEYBuCuof ZYFAasgy6wELWk00U1CXhYpYlaf96kQCPLlUxJtc2vYYAAyBWAyQJzBASEJd 9SFmaNMT3RRBOM+8UiHDGRDqB+KDH6gfDGg1y8x1g2AMsoaxGNA0bD/MM4sV ShbARTSdYY/jB8DgQSwGqHAGbMMDXOGmmcpNi1eeaRygghngUTVPDl6gfqh+ q2llEur0lb4+Xx/Vbz27WADXaXCGvfYBdSACoE/QfmE044ZpgonnYmXyPJWG hA7Wfr3X//fwYOmh/98PErSaWmYFHqaBzjCWBrafYGy79eA4MOvvOgVO4WED odoyFgvMCSzgEiujlDFE+dRtc4vWnMkXZIJZYPbCAX6xbDJkl/WABS0nmHWD BlA/CIu1dJkAJxaIeIkFrUYEKHQB59oyEgckvmYOSBzOgT0M+NROJaFLrw0c 6BYH2k0w64R/CLh8JI62eqRVdw2sPucs+zsqAJdipd6lWD1oQK7ZQyRJIA3I /iwhnwV2LjdLaPeTzU4dBaaj9G1ZpGWZ5YvSbbk+t9J+mEzLpzSt3j+8z6df 3/+a5pPnuT0l24hFZf//8h9QSwcIKdeXjT0WAAB5iwEAUEsBAhQAFAAACAAA N0nTToVsOYouAAAALgAAAAgAAAAAAAAAAAAAAAAAAAAAAG1pbWV0eXBlUEsB AhQAFAAACAAAN0nTTnHc+3PSGwAA0hsAABgAAAAAAAAAAAAAAAAAVAAAAFRo dW1ibmFpbHMvdGh1bWJuYWlsLnBuZ1BLAQIUABQACAgIADdJ006souQEMAQA AD0gAAAMAAAAAAAAAAAAAAAAAFwcAABzZXR0aW5ncy54bWxQSwECFAAUAAgI CAA3SdNOO7RBD3cGAAAZJQAACgAAAAAAAAAAAAAAAADGIAAAc3R5bGVzLnht bFBLAQIUABQACAgIADdJ006ABiczhAEAAAYDAAAIAAAAAAAAAAAAAAAAAHUn AABtZXRhLnhtbFBLAQIUABQACAgIADdJ006092jSBQEAAIMDAAAMAAAAAAAA AAAAAAAAAC8pAABtYW5pZmVzdC5yZGZQSwECFAAUAAAIAAA3SdNOAAAAAAAA AAAAAAAAGgAAAAAAAAAAAAAAAABuKgAAQ29uZmlndXJhdGlvbnMyL3Rvb2xw YW5lbC9QSwECFAAUAAAIAAA3SdNOAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAA AACmKgAAQ29uZmlndXJhdGlvbnMyL2FjY2VsZXJhdG9yL1BLAQIUABQAAAgA ADdJ004AAAAAAAAAAAAAAAAYAAAAAAAAAAAAAAAAAOAqAABDb25maWd1cmF0 aW9uczIvZmxvYXRlci9QSwECFAAUAAAIAAA3SdNOAAAAAAAAAAAAAAAAGAAA AAAAAAAAAAAAAAAWKwAAQ29uZmlndXJhdGlvbnMyL21lbnViYXIvUEsBAhQA FAAACAAAN0nTTgAAAAAAAAAAAAAAABoAAAAAAAAAAAAAAAAATCsAAENvbmZp Z3VyYXRpb25zMi9wb3B1cG1lbnUvUEsBAhQAFAAACAAAN0nTTgAAAAAAAAAA AAAAABgAAAAAAAAAAAAAAAAAhCsAAENvbmZpZ3VyYXRpb25zMi90b29sYmFy L1BLAQIUABQAAAgAADdJ004AAAAAAAAAAAAAAAAaAAAAAAAAAAAAAAAAALor AABDb25maWd1cmF0aW9uczIvc3RhdHVzYmFyL1BLAQIUABQAAAgAADdJ004A AAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAPIrAABDb25maWd1cmF0aW9uczIv cHJvZ3Jlc3NiYXIvUEsBAhQAFAAACAAAN0nTTgAAAAAAAAAAAAAAAB8AAAAA AAAAAAAAAAAALCwAAENvbmZpZ3VyYXRpb25zMi9pbWFnZXMvQml0bWFwcy9Q SwECFAAUAAgICAA3SdNO7kyG7jMBAAAsBAAAFQAAAAAAAAAAAAAAAABpLAAA TUVUQS1JTkYvbWFuaWZlc3QueG1sUEsBAhQAFAAICAgAN0nTTinXl409FgAA eYsBAAsAAAAAAAAAAAAAAAAA3y0AAGNvbnRlbnQueG1sUEsFBgAAAAARABEA ZQQAAFVEAAAAAA== --------------F22B6FADA443D968572DA2FE--